1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
48 cl::desc("Disable debug info printing"));
50 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
51 cl::desc("Make an absense of debug location information explicit."),
55 const char *DWARFGroupName = "DWARF Emission";
56 const char *DbgTimerName = "DWARF Debug Writer";
57 } // end anonymous namespace
59 //===----------------------------------------------------------------------===//
61 /// Configuration values for initial hash set sizes (log2).
63 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
67 //===----------------------------------------------------------------------===//
68 /// CompileUnit - This dwarf writer support class manages information associate
69 /// with a source file.
71 /// ID - File identifier for source.
75 /// Die - Compile unit debug information entry.
77 const OwningPtr<DIE> CUDie;
79 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
82 /// GVToDieMap - Tracks the mapping of unit level debug informaton
83 /// variables to debug information entries.
84 /// FIXME : Rename GVToDieMap -> NodeToDieMap
85 DenseMap<const MDNode *, DIE *> GVToDieMap;
87 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
90 DenseMap<const MDNode *, DIEEntry *> GVToDIEEntryMap;
92 /// Globals - A map of globally visible named entities for this unit.
94 StringMap<DIE*> Globals;
96 /// GlobalTypes - A map of globally visible types for this unit.
98 StringMap<DIE*> GlobalTypes;
101 CompileUnit(unsigned I, DIE *D)
102 : ID(I), CUDie(D), IndexTyDie(0) {}
105 unsigned getID() const { return ID; }
106 DIE* getCUDie() const { return CUDie.get(); }
107 const StringMap<DIE*> &getGlobals() const { return Globals; }
108 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
110 /// hasContent - Return true if this compile unit has something to write out.
112 bool hasContent() const { return !CUDie->getChildren().empty(); }
114 /// addGlobal - Add a new global entity to the compile unit.
116 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
118 /// addGlobalType - Add a new global type to the compile unit.
120 void addGlobalType(StringRef Name, DIE *Die) {
121 GlobalTypes[Name] = Die;
124 /// getDIE - Returns the debug information entry map slot for the
125 /// specified debug variable.
126 DIE *getDIE(const MDNode *N) { return GVToDieMap.lookup(N); }
128 /// insertDIE - Insert DIE into the map.
129 void insertDIE(const MDNode *N, DIE *D) {
130 GVToDieMap.insert(std::make_pair(N, D));
133 /// getDIEEntry - Returns the debug information entry for the speciefied
135 DIEEntry *getDIEEntry(const MDNode *N) {
136 DenseMap<const MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
137 if (I == GVToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 GVToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 unsigned FrameIndex; // Variable frame index.
172 const MachineInstr *DbgValueMInsn; // DBG_VALUE
173 // DbgValueLabel - DBG_VALUE is effective from this label.
174 MCSymbol *DbgValueLabel;
175 DbgVariable *const AbstractVar; // Abstract variable for this variable.
178 // AbsVar may be NULL.
179 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
180 : Var(V), FrameIndex(I), DbgValueMInsn(0),
181 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
182 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
183 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
184 AbstractVar(AbsVar), TheDIE(0)
188 DIVariable getVariable() const { return Var; }
189 unsigned getFrameIndex() const { return FrameIndex; }
190 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
191 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
192 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
193 DbgVariable *getAbstractVariable() const { return AbstractVar; }
194 void setDIE(DIE *D) { TheDIE = D; }
195 DIE *getDIE() const { return TheDIE; }
197 return DbgValueMInsn || FrameIndex != ~0U;
201 //===----------------------------------------------------------------------===//
202 /// DbgRange - This is used to track range of instructions with identical
203 /// debug info scope.
205 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
207 //===----------------------------------------------------------------------===//
208 /// DbgScope - This class is used to track scope information.
211 DbgScope *Parent; // Parent to this scope.
212 DIDescriptor Desc; // Debug info descriptor for scope.
213 // Location at which this scope is inlined.
214 AssertingVH<const MDNode> InlinedAtLocation;
215 bool AbstractScope; // Abstract Scope
216 const MachineInstr *LastInsn; // Last instruction of this scope.
217 const MachineInstr *FirstInsn; // First instruction of this scope.
218 unsigned DFSIn, DFSOut;
219 // Scopes defined in scope. Contents not owned.
220 SmallVector<DbgScope *, 4> Scopes;
221 // Variables declared in scope. Contents owned.
222 SmallVector<DbgVariable *, 8> Variables;
223 SmallVector<DbgRange, 4> Ranges;
224 // Private state for dump()
225 mutable unsigned IndentLevel;
227 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
228 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
229 LastInsn(0), FirstInsn(0),
230 DFSIn(0), DFSOut(0), IndentLevel(0) {}
234 DbgScope *getParent() const { return Parent; }
235 void setParent(DbgScope *P) { Parent = P; }
236 DIDescriptor getDesc() const { return Desc; }
237 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
238 const MDNode *getScopeNode() const { return Desc; }
239 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
240 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
241 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
243 /// openInsnRange - This scope covers instruction range starting from MI.
244 void openInsnRange(const MachineInstr *MI) {
249 Parent->openInsnRange(MI);
252 /// extendInsnRange - Extend the current instruction range covered by
254 void extendInsnRange(const MachineInstr *MI) {
255 assert (FirstInsn && "MI Range is not open!");
258 Parent->extendInsnRange(MI);
261 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
262 /// until now. This is used when a new scope is encountered while walking
263 /// machine instructions.
264 void closeInsnRange(DbgScope *NewScope = NULL) {
265 assert (LastInsn && "Last insn missing!");
266 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
269 // If Parent dominates NewScope then do not close Parent's instruction
271 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
272 Parent->closeInsnRange(NewScope);
275 void setAbstractScope() { AbstractScope = true; }
276 bool isAbstractScope() const { return AbstractScope; }
278 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
279 unsigned getDFSOut() const { return DFSOut; }
280 void setDFSOut(unsigned O) { DFSOut = O; }
281 unsigned getDFSIn() const { return DFSIn; }
282 void setDFSIn(unsigned I) { DFSIn = I; }
283 bool dominates(const DbgScope *S) {
286 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
291 /// addScope - Add a scope to the scope.
293 void addScope(DbgScope *S) { Scopes.push_back(S); }
295 /// addVariable - Add a variable to the scope.
297 void addVariable(DbgVariable *V) { Variables.push_back(V); }
304 } // end llvm namespace
307 void DbgScope::dump() const {
308 raw_ostream &err = dbgs();
309 err.indent(IndentLevel);
310 const MDNode *N = Desc;
313 err << "Abstract Scope\n";
317 err << "Children ...\n";
318 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
319 if (Scopes[i] != this)
326 DbgScope::~DbgScope() {
327 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
331 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
332 : Asm(A), MMI(Asm->MMI), FirstCU(0),
333 AbbreviationsSet(InitAbbreviationsSetSize),
334 CurrentFnDbgScope(0), PrevLabel(NULL) {
335 NextStringPoolNumber = 0;
337 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
338 DwarfStrSectionSym = TextSectionSym = 0;
339 DwarfDebugRangeSectionSym = 0;
340 FunctionBeginSym = 0;
341 if (TimePassesIsEnabled) {
342 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
348 DwarfDebug::~DwarfDebug() {
349 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
350 DIEBlocks[j]->~DIEBlock();
353 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
354 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
355 if (Entry.first) return Entry.first;
357 Entry.second = NextStringPoolNumber++;
358 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
362 /// assignAbbrevNumber - Define a unique number for the abbreviation.
364 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
365 // Profile the node so that we can make it unique.
369 // Check the set for priors.
370 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
372 // If it's newly added.
373 if (InSet == &Abbrev) {
374 // Add to abbreviation list.
375 Abbreviations.push_back(&Abbrev);
377 // Assign the vector position + 1 as its number.
378 Abbrev.setNumber(Abbreviations.size());
380 // Assign existing abbreviation number.
381 Abbrev.setNumber(InSet->getNumber());
385 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
386 /// information entry.
387 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
388 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
392 /// addUInt - Add an unsigned integer attribute data and value.
394 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
395 unsigned Form, uint64_t Integer) {
396 if (!Form) Form = DIEInteger::BestForm(false, Integer);
397 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
398 Die->addValue(Attribute, Form, Value);
401 /// addSInt - Add an signed integer attribute data and value.
403 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
404 unsigned Form, int64_t Integer) {
405 if (!Form) Form = DIEInteger::BestForm(true, Integer);
406 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
407 Die->addValue(Attribute, Form, Value);
410 /// addString - Add a string attribute data and value. DIEString only
411 /// keeps string reference.
412 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
414 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
415 Die->addValue(Attribute, Form, Value);
418 /// addLabel - Add a Dwarf label attribute data and value.
420 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
421 const MCSymbol *Label) {
422 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
423 Die->addValue(Attribute, Form, Value);
426 /// addDelta - Add a label delta attribute data and value.
428 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
429 const MCSymbol *Hi, const MCSymbol *Lo) {
430 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
431 Die->addValue(Attribute, Form, Value);
434 /// addDIEEntry - Add a DIE attribute data and value.
436 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
438 Die->addValue(Attribute, Form, createDIEEntry(Entry));
442 /// addBlock - Add block data.
444 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
446 Block->ComputeSize(Asm);
447 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
448 Die->addValue(Attribute, Block->BestForm(), Block);
451 /// addSourceLine - Add location information to specified debug information
453 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
458 unsigned Line = V->getLineNumber();
459 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
460 V->getContext().getFilename());
461 assert(FileID && "Invalid file id");
462 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
463 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
466 /// addSourceLine - Add location information to specified debug information
468 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
469 // Verify global variable.
473 unsigned Line = G->getLineNumber();
474 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
475 G->getContext().getFilename());
476 assert(FileID && "Invalid file id");
477 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
478 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
481 /// addSourceLine - Add location information to specified debug information
483 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
484 // Verify subprogram.
487 // If the line number is 0, don't add it.
488 if (SP->getLineNumber() == 0)
491 unsigned Line = SP->getLineNumber();
492 if (!SP->getContext().Verify())
494 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
496 assert(FileID && "Invalid file id");
497 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
498 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
501 /// addSourceLine - Add location information to specified debug information
503 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
508 unsigned Line = Ty->getLineNumber();
509 if (!Ty->getContext().Verify())
511 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
512 Ty->getContext().getFilename());
513 assert(FileID && "Invalid file id");
514 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
515 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
518 /// addSourceLine - Add location information to specified debug information
520 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
525 unsigned Line = NS->getLineNumber();
526 StringRef FN = NS->getFilename();
527 StringRef Dir = NS->getDirectory();
529 unsigned FileID = GetOrCreateSourceID(Dir, FN);
530 assert(FileID && "Invalid file id");
531 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
532 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
535 /* Byref variables, in Blocks, are declared by the programmer as
536 "SomeType VarName;", but the compiler creates a
537 __Block_byref_x_VarName struct, and gives the variable VarName
538 either the struct, or a pointer to the struct, as its type. This
539 is necessary for various behind-the-scenes things the compiler
540 needs to do with by-reference variables in blocks.
542 However, as far as the original *programmer* is concerned, the
543 variable should still have type 'SomeType', as originally declared.
545 The following function dives into the __Block_byref_x_VarName
546 struct to find the original type of the variable. This will be
547 passed back to the code generating the type for the Debug
548 Information Entry for the variable 'VarName'. 'VarName' will then
549 have the original type 'SomeType' in its debug information.
551 The original type 'SomeType' will be the type of the field named
552 'VarName' inside the __Block_byref_x_VarName struct.
554 NOTE: In order for this to not completely fail on the debugger
555 side, the Debug Information Entry for the variable VarName needs to
556 have a DW_AT_location that tells the debugger how to unwind through
557 the pointers and __Block_byref_x_VarName struct to find the actual
558 value of the variable. The function addBlockByrefType does this. */
560 /// Find the type the programmer originally declared the variable to be
561 /// and return that type.
563 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
566 unsigned tag = Ty.getTag();
568 if (tag == dwarf::DW_TAG_pointer_type) {
569 DIDerivedType DTy = DIDerivedType(Ty);
570 subType = DTy.getTypeDerivedFrom();
573 DICompositeType blockStruct = DICompositeType(subType);
574 DIArray Elements = blockStruct.getTypeArray();
576 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
577 DIDescriptor Element = Elements.getElement(i);
578 DIDerivedType DT = DIDerivedType(Element);
579 if (Name == DT.getName())
580 return (DT.getTypeDerivedFrom());
586 /// addComplexAddress - Start with the address based on the location provided,
587 /// and generate the DWARF information necessary to find the actual variable
588 /// given the extra address information encoded in the DIVariable, starting from
589 /// the starting location. Add the DWARF information to the die.
591 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
593 const MachineLocation &Location) {
594 const DIVariable &VD = DV->getVariable();
595 DIType Ty = VD.getType();
597 // Decode the original location, and use that as the start of the byref
598 // variable's location.
599 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
600 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
601 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
603 if (Location.isReg()) {
605 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
607 Reg = Reg - dwarf::DW_OP_reg0;
608 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
609 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
615 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
616 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
619 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
622 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
623 uint64_t Element = VD.getAddrElement(i);
625 if (Element == DIFactory::OpPlus) {
626 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
627 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
628 } else if (Element == DIFactory::OpDeref) {
629 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
630 } else llvm_unreachable("unknown DIFactory Opcode");
633 // Now attach the location information to the DIE.
634 addBlock(Die, Attribute, 0, Block);
637 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
638 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
639 gives the variable VarName either the struct, or a pointer to the struct, as
640 its type. This is necessary for various behind-the-scenes things the
641 compiler needs to do with by-reference variables in Blocks.
643 However, as far as the original *programmer* is concerned, the variable
644 should still have type 'SomeType', as originally declared.
646 The function getBlockByrefType dives into the __Block_byref_x_VarName
647 struct to find the original type of the variable, which is then assigned to
648 the variable's Debug Information Entry as its real type. So far, so good.
649 However now the debugger will expect the variable VarName to have the type
650 SomeType. So we need the location attribute for the variable to be an
651 expression that explains to the debugger how to navigate through the
652 pointers and struct to find the actual variable of type SomeType.
654 The following function does just that. We start by getting
655 the "normal" location for the variable. This will be the location
656 of either the struct __Block_byref_x_VarName or the pointer to the
657 struct __Block_byref_x_VarName.
659 The struct will look something like:
661 struct __Block_byref_x_VarName {
663 struct __Block_byref_x_VarName *forwarding;
664 ... <various other fields>
666 ... <maybe more fields>
669 If we are given the struct directly (as our starting point) we
670 need to tell the debugger to:
672 1). Add the offset of the forwarding field.
674 2). Follow that pointer to get the real __Block_byref_x_VarName
675 struct to use (the real one may have been copied onto the heap).
677 3). Add the offset for the field VarName, to find the actual variable.
679 If we started with a pointer to the struct, then we need to
680 dereference that pointer first, before the other steps.
681 Translating this into DWARF ops, we will need to append the following
682 to the current location description for the variable:
684 DW_OP_deref -- optional, if we start with a pointer
685 DW_OP_plus_uconst <forward_fld_offset>
687 DW_OP_plus_uconst <varName_fld_offset>
689 That is what this function does. */
691 /// addBlockByrefAddress - Start with the address based on the location
692 /// provided, and generate the DWARF information necessary to find the
693 /// actual Block variable (navigating the Block struct) based on the
694 /// starting location. Add the DWARF information to the die. For
695 /// more information, read large comment just above here.
697 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
699 const MachineLocation &Location) {
700 const DIVariable &VD = DV->getVariable();
701 DIType Ty = VD.getType();
703 unsigned Tag = Ty.getTag();
704 bool isPointer = false;
706 StringRef varName = VD.getName();
708 if (Tag == dwarf::DW_TAG_pointer_type) {
709 DIDerivedType DTy = DIDerivedType(Ty);
710 TmpTy = DTy.getTypeDerivedFrom();
714 DICompositeType blockStruct = DICompositeType(TmpTy);
716 // Find the __forwarding field and the variable field in the __Block_byref
718 DIArray Fields = blockStruct.getTypeArray();
719 DIDescriptor varField = DIDescriptor();
720 DIDescriptor forwardingField = DIDescriptor();
722 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
723 DIDescriptor Element = Fields.getElement(i);
724 DIDerivedType DT = DIDerivedType(Element);
725 StringRef fieldName = DT.getName();
726 if (fieldName == "__forwarding")
727 forwardingField = Element;
728 else if (fieldName == varName)
732 // Get the offsets for the forwarding field and the variable field.
733 unsigned forwardingFieldOffset =
734 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
735 unsigned varFieldOffset =
736 DIDerivedType(varField).getOffsetInBits() >> 3;
738 // Decode the original location, and use that as the start of the byref
739 // variable's location.
740 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
741 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
742 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
744 if (Location.isReg()) {
746 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
748 Reg = Reg - dwarf::DW_OP_reg0;
749 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
750 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
754 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
757 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
760 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
763 // If we started with a pointer to the __Block_byref... struct, then
764 // the first thing we need to do is dereference the pointer (DW_OP_deref).
766 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
768 // Next add the offset for the '__forwarding' field:
769 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
770 // adding the offset if it's 0.
771 if (forwardingFieldOffset > 0) {
772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
773 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
776 // Now dereference the __forwarding field to get to the real __Block_byref
777 // struct: DW_OP_deref.
778 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
780 // Now that we've got the real __Block_byref... struct, add the offset
781 // for the variable's field to get to the location of the actual variable:
782 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
783 if (varFieldOffset > 0) {
784 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
785 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
788 // Now attach the location information to the DIE.
789 addBlock(Die, Attribute, 0, Block);
792 /// addAddress - Add an address attribute to a die based on the location
794 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
795 const MachineLocation &Location) {
796 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
797 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
798 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
800 if (Location.isReg()) {
802 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
804 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
805 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
809 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
811 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
812 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
815 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
818 addBlock(Die, Attribute, 0, Block);
821 /// addRegisterAddress - Add register location entry in variable DIE.
822 bool DwarfDebug::addRegisterAddress(DIE *Die, DbgVariable *DV,
823 const MachineOperand &MO) {
824 assert (MO.isReg() && "Invalid machine operand!");
827 MachineLocation Location;
828 Location.set(MO.getReg());
829 addAddress(Die, dwarf::DW_AT_location, Location);
830 if (MCSymbol *VS = DV->getDbgValueLabel())
831 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
835 /// addConstantValue - Add constant value entry in variable DIE.
836 bool DwarfDebug::addConstantValue(DIE *Die, DbgVariable *DV,
837 const MachineOperand &MO) {
838 assert (MO.isImm() && "Invalid machine operand!");
839 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
840 unsigned Imm = MO.getImm();
841 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
842 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
843 if (MCSymbol *VS = DV->getDbgValueLabel())
844 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
848 /// addConstantFPValue - Add constant value entry in variable DIE.
849 bool DwarfDebug::addConstantFPValue(DIE *Die, DbgVariable *DV,
850 const MachineOperand &MO) {
851 assert (MO.isFPImm() && "Invalid machine operand!");
852 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
853 APFloat FPImm = MO.getFPImm()->getValueAPF();
855 // Get the raw data form of the floating point.
856 const APInt FltVal = FPImm.bitcastToAPInt();
857 const char *FltPtr = (const char*)FltVal.getRawData();
859 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
860 bool LittleEndian = Asm->getTargetData().isLittleEndian();
861 int Incr = (LittleEndian ? 1 : -1);
862 int Start = (LittleEndian ? 0 : NumBytes - 1);
863 int Stop = (LittleEndian ? NumBytes : -1);
865 // Output the constant to DWARF one byte at a time.
866 for (; Start != Stop; Start += Incr)
867 addUInt(Block, 0, dwarf::DW_FORM_data1,
868 (unsigned char)0xFF & FltPtr[Start]);
870 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
872 if (MCSymbol *VS = DV->getDbgValueLabel())
873 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
879 /// addToContextOwner - Add Die into the list of its context owner's children.
880 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
881 if (Context.isType()) {
882 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
883 ContextDIE->addChild(Die);
884 } else if (Context.isNameSpace()) {
885 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
886 ContextDIE->addChild(Die);
887 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
888 ContextDIE->addChild(Die);
890 getCompileUnit(Context)->addDie(Die);
893 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
895 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
896 CompileUnit *TypeCU = getCompileUnit(Ty);
897 DIE *TyDIE = TypeCU->getDIE(Ty);
902 TyDIE = new DIE(dwarf::DW_TAG_base_type);
903 TypeCU->insertDIE(Ty, TyDIE);
904 if (Ty.isBasicType())
905 constructTypeDIE(*TyDIE, DIBasicType(Ty));
906 else if (Ty.isCompositeType())
907 constructTypeDIE(*TyDIE, DICompositeType(Ty));
909 assert(Ty.isDerivedType() && "Unknown kind of DIType");
910 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
913 addToContextOwner(TyDIE, Ty.getContext());
917 /// addType - Add a new type attribute to the specified entity.
918 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
922 // Check for pre-existence.
923 CompileUnit *TypeCU = getCompileUnit(Ty);
924 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
925 // If it exists then use the existing value.
927 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
932 DIE *Buffer = getOrCreateTypeDIE(Ty);
935 Entry = createDIEEntry(Buffer);
936 TypeCU->insertDIEEntry(Ty, Entry);
938 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
941 /// constructTypeDIE - Construct basic type die from DIBasicType.
942 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
943 // Get core information.
944 StringRef Name = BTy.getName();
945 Buffer.setTag(dwarf::DW_TAG_base_type);
946 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
949 // Add name if not anonymous or intermediate type.
951 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
952 uint64_t Size = BTy.getSizeInBits() >> 3;
953 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
956 /// constructTypeDIE - Construct derived type die from DIDerivedType.
957 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
958 // Get core information.
959 StringRef Name = DTy.getName();
960 uint64_t Size = DTy.getSizeInBits() >> 3;
961 unsigned Tag = DTy.getTag();
963 // FIXME - Workaround for templates.
964 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
968 // Map to main type, void will not have a type.
969 DIType FromTy = DTy.getTypeDerivedFrom();
970 addType(&Buffer, FromTy);
972 // Add name if not anonymous or intermediate type.
974 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
976 // Add size if non-zero (derived types might be zero-sized.)
978 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
980 // Add source line info if available and TyDesc is not a forward declaration.
981 if (!DTy.isForwardDecl())
982 addSourceLine(&Buffer, &DTy);
985 /// constructTypeDIE - Construct type DIE from DICompositeType.
986 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
987 // Get core information.
988 StringRef Name = CTy.getName();
990 uint64_t Size = CTy.getSizeInBits() >> 3;
991 unsigned Tag = CTy.getTag();
995 case dwarf::DW_TAG_vector_type:
996 case dwarf::DW_TAG_array_type:
997 constructArrayTypeDIE(Buffer, &CTy);
999 case dwarf::DW_TAG_enumeration_type: {
1000 DIArray Elements = CTy.getTypeArray();
1002 // Add enumerators to enumeration type.
1003 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1004 DIE *ElemDie = NULL;
1005 DIDescriptor Enum(Elements.getElement(i));
1006 if (Enum.isEnumerator()) {
1007 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1008 Buffer.addChild(ElemDie);
1013 case dwarf::DW_TAG_subroutine_type: {
1015 DIArray Elements = CTy.getTypeArray();
1016 DIDescriptor RTy = Elements.getElement(0);
1017 addType(&Buffer, DIType(RTy));
1019 // Add prototype flag.
1020 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1023 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1024 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1025 DIDescriptor Ty = Elements.getElement(i);
1026 addType(Arg, DIType(Ty));
1027 Buffer.addChild(Arg);
1031 case dwarf::DW_TAG_structure_type:
1032 case dwarf::DW_TAG_union_type:
1033 case dwarf::DW_TAG_class_type: {
1034 // Add elements to structure type.
1035 DIArray Elements = CTy.getTypeArray();
1037 // A forward struct declared type may not have elements available.
1038 unsigned N = Elements.getNumElements();
1042 // Add elements to structure type.
1043 for (unsigned i = 0; i < N; ++i) {
1044 DIDescriptor Element = Elements.getElement(i);
1045 DIE *ElemDie = NULL;
1046 if (Element.isSubprogram())
1047 ElemDie = createSubprogramDIE(DISubprogram(Element));
1048 else if (Element.isVariable()) {
1049 DIVariable DV(Element);
1050 ElemDie = new DIE(dwarf::DW_TAG_variable);
1051 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1053 addType(ElemDie, DV.getType());
1054 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1055 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1056 addSourceLine(ElemDie, &DV);
1057 } else if (Element.isDerivedType())
1058 ElemDie = createMemberDIE(DIDerivedType(Element));
1061 Buffer.addChild(ElemDie);
1064 if (CTy.isAppleBlockExtension())
1065 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1067 unsigned RLang = CTy.getRunTimeLang();
1069 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1070 dwarf::DW_FORM_data1, RLang);
1072 DICompositeType ContainingType = CTy.getContainingType();
1073 if (DIDescriptor(ContainingType).isCompositeType())
1074 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1075 getOrCreateTypeDIE(DIType(ContainingType)));
1082 // Add name if not anonymous or intermediate type.
1084 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1086 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1087 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1088 // Add size if non-zero (derived types might be zero-sized.)
1090 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1092 // Add zero size if it is not a forward declaration.
1093 if (CTy.isForwardDecl())
1094 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1096 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1099 // Add source line info if available.
1100 if (!CTy.isForwardDecl())
1101 addSourceLine(&Buffer, &CTy);
1105 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1106 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1107 int64_t L = SR.getLo();
1108 int64_t H = SR.getHi();
1109 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1111 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1113 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1114 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1116 Buffer.addChild(DW_Subrange);
1119 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1120 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1121 DICompositeType *CTy) {
1122 Buffer.setTag(dwarf::DW_TAG_array_type);
1123 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1124 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1126 // Emit derived type.
1127 addType(&Buffer, CTy->getTypeDerivedFrom());
1128 DIArray Elements = CTy->getTypeArray();
1130 // Get an anonymous type for index type.
1131 CompileUnit *TheCU = getCompileUnit(*CTy);
1132 DIE *IdxTy = TheCU->getIndexTyDie();
1134 // Construct an anonymous type for index type.
1135 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1136 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1137 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1138 dwarf::DW_ATE_signed);
1139 TheCU->addDie(IdxTy);
1140 TheCU->setIndexTyDie(IdxTy);
1143 // Add subranges to array type.
1144 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1145 DIDescriptor Element = Elements.getElement(i);
1146 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1147 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1151 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1152 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1153 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1154 StringRef Name = ETy.getName();
1155 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1156 int64_t Value = ETy.getEnumValue();
1157 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1161 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1162 /// printer to not emit usual symbol prefix before the symbol name is used then
1163 /// return linkage name after skipping this special LLVM prefix.
1164 static StringRef getRealLinkageName(StringRef LinkageName) {
1166 if (LinkageName.startswith(StringRef(&One, 1)))
1167 return LinkageName.substr(1);
1171 /// createGlobalVariableDIE - Create new DIE using GV.
1172 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1173 // If the global variable was optmized out then no need to create debug info
1175 if (!GV.getGlobal()) return NULL;
1176 if (GV.getDisplayName().empty()) return NULL;
1178 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1179 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1180 GV.getDisplayName());
1182 StringRef LinkageName = GV.getLinkageName();
1183 if (!LinkageName.empty())
1184 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1185 getRealLinkageName(LinkageName));
1187 addType(GVDie, GV.getType());
1188 if (!GV.isLocalToUnit())
1189 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1190 addSourceLine(GVDie, &GV);
1195 /// createMemberDIE - Create new member DIE.
1196 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1197 DIE *MemberDie = new DIE(DT.getTag());
1198 StringRef Name = DT.getName();
1200 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1202 addType(MemberDie, DT.getTypeDerivedFrom());
1204 addSourceLine(MemberDie, &DT);
1206 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1207 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1209 uint64_t Size = DT.getSizeInBits();
1210 uint64_t FieldSize = DT.getOriginalTypeSize();
1212 if (Size != FieldSize) {
1214 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1215 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1217 uint64_t Offset = DT.getOffsetInBits();
1218 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1219 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1220 uint64_t FieldOffset = (HiMark - FieldSize);
1221 Offset -= FieldOffset;
1223 // Maybe we need to work from the other end.
1224 if (Asm->getTargetData().isLittleEndian())
1225 Offset = FieldSize - (Offset + Size);
1226 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1228 // Here WD_AT_data_member_location points to the anonymous
1229 // field that includes this bit field.
1230 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1233 // This is not a bitfield.
1234 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1236 if (DT.getTag() == dwarf::DW_TAG_inheritance
1237 && DT.isVirtual()) {
1239 // For C++, virtual base classes are not at fixed offset. Use following
1240 // expression to extract appropriate offset from vtable.
1241 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1243 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1244 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1245 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1246 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1247 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1248 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1249 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1250 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1252 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1255 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1257 if (DT.isProtected())
1258 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1259 dwarf::DW_ACCESS_protected);
1260 else if (DT.isPrivate())
1261 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1262 dwarf::DW_ACCESS_private);
1263 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1264 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1265 dwarf::DW_ACCESS_public);
1267 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1268 dwarf::DW_VIRTUALITY_virtual);
1272 /// createSubprogramDIE - Create new DIE using SP.
1273 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1274 CompileUnit *SPCU = getCompileUnit(SP);
1275 DIE *SPDie = SPCU->getDIE(SP);
1279 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1280 // Constructors and operators for anonymous aggregates do not have names.
1281 if (!SP.getName().empty())
1282 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1284 StringRef LinkageName = SP.getLinkageName();
1285 if (!LinkageName.empty())
1286 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1287 getRealLinkageName(LinkageName));
1289 addSourceLine(SPDie, &SP);
1291 // Add prototyped tag, if C or ObjC.
1292 unsigned Lang = SP.getCompileUnit().getLanguage();
1293 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1294 Lang == dwarf::DW_LANG_ObjC)
1295 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1298 DICompositeType SPTy = SP.getType();
1299 DIArray Args = SPTy.getTypeArray();
1300 unsigned SPTag = SPTy.getTag();
1302 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1303 addType(SPDie, SPTy);
1305 addType(SPDie, DIType(Args.getElement(0)));
1307 unsigned VK = SP.getVirtuality();
1309 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1310 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1311 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1312 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1313 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1314 ContainingTypeMap.insert(std::make_pair(SPDie,
1315 SP.getContainingType()));
1318 if (MakeDecl || !SP.isDefinition()) {
1319 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1321 // Add arguments. Do not add arguments for subprogram definition. They will
1322 // be handled while processing variables.
1323 DICompositeType SPTy = SP.getType();
1324 DIArray Args = SPTy.getTypeArray();
1325 unsigned SPTag = SPTy.getTag();
1327 if (SPTag == dwarf::DW_TAG_subroutine_type)
1328 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1329 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1330 DIType ATy = DIType(DIType(Args.getElement(i)));
1332 if (ATy.isArtificial())
1333 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1334 SPDie->addChild(Arg);
1338 if (SP.isArtificial())
1339 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1341 if (!SP.isLocalToUnit())
1342 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1344 if (SP.isOptimized())
1345 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1347 // DW_TAG_inlined_subroutine may refer to this DIE.
1348 SPCU->insertDIE(SP, SPDie);
1353 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1354 assert(N && "Invalid Scope encoding!");
1356 DbgScope *AScope = AbstractScopes.lookup(N);
1360 DbgScope *Parent = NULL;
1362 DIDescriptor Scope(N);
1363 if (Scope.isLexicalBlock()) {
1364 DILexicalBlock DB(N);
1365 DIDescriptor ParentDesc = DB.getContext();
1366 Parent = getOrCreateAbstractScope(ParentDesc);
1369 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1372 Parent->addScope(AScope);
1373 AScope->setAbstractScope();
1374 AbstractScopes[N] = AScope;
1375 if (DIDescriptor(N).isSubprogram())
1376 AbstractScopesList.push_back(AScope);
1380 /// isSubprogramContext - Return true if Context is either a subprogram
1381 /// or another context nested inside a subprogram.
1382 static bool isSubprogramContext(const MDNode *Context) {
1385 DIDescriptor D(Context);
1386 if (D.isSubprogram())
1389 return isSubprogramContext(DIType(Context).getContext());
1393 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1394 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1395 /// If there are global variables in this scope then create and insert
1396 /// DIEs for these variables.
1397 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1398 CompileUnit *SPCU = getCompileUnit(SPNode);
1399 DIE *SPDie = SPCU->getDIE(SPNode);
1400 assert(SPDie && "Unable to find subprogram DIE!");
1401 DISubprogram SP(SPNode);
1403 // There is not any need to generate specification DIE for a function
1404 // defined at compile unit level. If a function is defined inside another
1405 // function then gdb prefers the definition at top level and but does not
1406 // expect specification DIE in parent function. So avoid creating
1407 // specification DIE for a function defined inside a function.
1408 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1409 !SP.getContext().isFile() &&
1410 !isSubprogramContext(SP.getContext())) {
1411 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1414 DICompositeType SPTy = SP.getType();
1415 DIArray Args = SPTy.getTypeArray();
1416 unsigned SPTag = SPTy.getTag();
1417 if (SPTag == dwarf::DW_TAG_subroutine_type)
1418 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1419 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1420 DIType ATy = DIType(DIType(Args.getElement(i)));
1422 if (ATy.isArtificial())
1423 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1424 SPDie->addChild(Arg);
1426 DIE *SPDeclDie = SPDie;
1427 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1428 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1430 SPCU->addDie(SPDie);
1433 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1434 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1435 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1436 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1437 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1438 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1439 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1444 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1445 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1446 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1448 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1449 if (Scope->isAbstractScope())
1452 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1456 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1457 if (Ranges.size() > 1) {
1458 // .debug_range section has not been laid out yet. Emit offset in
1459 // .debug_range as a uint, size 4, for now. emitDIE will handle
1460 // DW_AT_ranges appropriately.
1461 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1462 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1463 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1464 RE = Ranges.end(); RI != RE; ++RI) {
1465 DebugRangeSymbols.push_back(LabelsBeforeInsn.lookup(RI->first));
1466 DebugRangeSymbols.push_back(LabelsAfterInsn.lookup(RI->second));
1468 DebugRangeSymbols.push_back(NULL);
1469 DebugRangeSymbols.push_back(NULL);
1473 MCSymbol *Start = LabelsBeforeInsn.lookup(RI->first);
1474 MCSymbol *End = LabelsAfterInsn.lookup(RI->second);
1476 if (Start == 0 || End == 0) return 0;
1478 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1479 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1481 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1482 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1487 /// constructInlinedScopeDIE - This scope represents inlined body of
1488 /// a function. Construct DIE to represent this concrete inlined copy
1489 /// of the function.
1490 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1492 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1493 assert (Ranges.empty() == false
1494 && "DbgScope does not have instruction markers!");
1496 // FIXME : .debug_inlined section specification does not clearly state how
1497 // to emit inlined scope that is split into multiple instruction ranges.
1498 // For now, use first instruction range and emit low_pc/high_pc pair and
1499 // corresponding .debug_inlined section entry for this pair.
1500 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1501 MCSymbol *StartLabel = LabelsBeforeInsn.lookup(RI->first);
1502 MCSymbol *EndLabel = LabelsAfterInsn.lookup(RI->second);
1504 if (StartLabel == 0 || EndLabel == 0) {
1505 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1508 assert(StartLabel->isDefined() &&
1509 "Invalid starting label for an inlined scope!");
1510 assert(EndLabel->isDefined() &&
1511 "Invalid end label for an inlined scope!");
1513 if (!Scope->getScopeNode())
1515 DIScope DS(Scope->getScopeNode());
1516 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1518 DISubprogram InlinedSP = getDISubprogram(DS);
1519 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1520 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1521 assert(OriginDIE && "Unable to find Origin DIE!");
1522 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1523 dwarf::DW_FORM_ref4, OriginDIE);
1525 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1526 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1528 InlinedSubprogramDIEs.insert(OriginDIE);
1530 // Track the start label for this inlined function.
1531 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1532 I = InlineInfo.find(InlinedSP);
1534 if (I == InlineInfo.end()) {
1535 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1537 InlinedSPNodes.push_back(InlinedSP);
1539 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1541 DILocation DL(Scope->getInlinedAt());
1542 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1543 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1549 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1550 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1551 // Get the descriptor.
1552 const DIVariable &VD = DV->getVariable();
1553 StringRef Name = VD.getName();
1557 // Translate tag to proper Dwarf tag. The result variable is dropped for
1560 switch (VD.getTag()) {
1561 case dwarf::DW_TAG_return_variable:
1563 case dwarf::DW_TAG_arg_variable:
1564 Tag = dwarf::DW_TAG_formal_parameter;
1566 case dwarf::DW_TAG_auto_variable: // fall thru
1568 Tag = dwarf::DW_TAG_variable;
1572 // Define variable debug information entry.
1573 DIE *VariableDie = new DIE(Tag);
1577 if (DbgVariable *AV = DV->getAbstractVariable())
1578 AbsDIE = AV->getDIE();
1581 DIScope DS(Scope->getScopeNode());
1582 DISubprogram InlinedSP = getDISubprogram(DS);
1583 DIE *OriginSPDIE = getCompileUnit(InlinedSP)->getDIE(InlinedSP);
1585 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1586 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1587 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1588 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1589 dwarf::DW_FORM_ref4, AbsDIE);
1592 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1593 addSourceLine(VariableDie, &VD);
1595 // Add variable type.
1596 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1597 // addresses instead.
1598 if (VD.isBlockByrefVariable())
1599 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1601 addType(VariableDie, VD.getType());
1604 // Add variable address.
1605 if (!Scope->isAbstractScope()) {
1606 // Check if variable is described by DBG_VALUE instruction.
1607 if (const MachineInstr *DVInsn = DV->getDbgValue()) {
1608 bool updated = false;
1609 // FIXME : Handle getNumOperands != 3
1610 if (DVInsn->getNumOperands() == 3) {
1611 if (DVInsn->getOperand(0).isReg())
1612 updated = addRegisterAddress(VariableDie, DV, DVInsn->getOperand(0));
1613 else if (DVInsn->getOperand(0).isImm())
1614 updated = addConstantValue(VariableDie, DV, DVInsn->getOperand(0));
1615 else if (DVInsn->getOperand(0).isFPImm())
1616 updated = addConstantFPValue(VariableDie, DV, DVInsn->getOperand(0));
1618 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1619 if (Location.getReg()) {
1620 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1621 if (MCSymbol *VS = DV->getDbgValueLabel())
1622 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1628 // If variableDie is not updated then DBG_VALUE instruction does not
1629 // have valid variable info.
1635 MachineLocation Location;
1637 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1638 if (DV->hasLocation()) {
1639 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1641 Location.set(FrameReg, Offset);
1643 if (VD.hasComplexAddress())
1644 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1645 else if (VD.isBlockByrefVariable())
1646 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1648 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1653 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1654 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1655 DV->setDIE(VariableDie);
1660 void DwarfDebug::addPubTypes(DISubprogram SP) {
1661 DICompositeType SPTy = SP.getType();
1662 unsigned SPTag = SPTy.getTag();
1663 if (SPTag != dwarf::DW_TAG_subroutine_type)
1666 DIArray Args = SPTy.getTypeArray();
1667 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1668 DIType ATy(Args.getElement(i));
1671 DICompositeType CATy = getDICompositeType(ATy);
1672 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1673 && !CATy.isForwardDecl()) {
1674 CompileUnit *TheCU = getCompileUnit(CATy);
1675 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1676 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1681 /// constructScopeDIE - Construct a DIE for this scope.
1682 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1683 if (!Scope || !Scope->getScopeNode())
1686 DIScope DS(Scope->getScopeNode());
1687 DIE *ScopeDIE = NULL;
1688 if (Scope->getInlinedAt())
1689 ScopeDIE = constructInlinedScopeDIE(Scope);
1690 else if (DS.isSubprogram()) {
1691 if (Scope->isAbstractScope())
1692 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1694 ScopeDIE = updateSubprogramScopeDIE(DS);
1697 ScopeDIE = constructLexicalScopeDIE(Scope);
1698 if (!ScopeDIE) return NULL;
1700 // Add variables to scope.
1701 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1702 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1703 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1705 ScopeDIE->addChild(VariableDIE);
1708 // Add nested scopes.
1709 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1710 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1711 // Define the Scope debug information entry.
1712 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1714 ScopeDIE->addChild(NestedDIE);
1717 if (DS.isSubprogram())
1718 addPubTypes(DISubprogram(DS));
1723 /// GetOrCreateSourceID - Look up the source id with the given directory and
1724 /// source file names. If none currently exists, create a new id and insert it
1725 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1727 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1729 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1730 if (DI != DirectoryIdMap.end()) {
1731 DId = DI->getValue();
1733 DId = DirectoryNames.size() + 1;
1734 DirectoryIdMap[DirName] = DId;
1735 DirectoryNames.push_back(DirName);
1739 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1740 if (FI != SourceFileIdMap.end()) {
1741 FId = FI->getValue();
1743 FId = SourceFileNames.size() + 1;
1744 SourceFileIdMap[FileName] = FId;
1745 SourceFileNames.push_back(FileName);
1748 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1749 SourceIdMap.find(std::make_pair(DId, FId));
1750 if (SI != SourceIdMap.end())
1753 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1754 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1755 SourceIds.push_back(std::make_pair(DId, FId));
1760 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1761 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1762 CompileUnit *TheCU = getCompileUnit(NS);
1763 DIE *NDie = TheCU->getDIE(NS);
1766 NDie = new DIE(dwarf::DW_TAG_namespace);
1767 TheCU->insertDIE(NS, NDie);
1768 if (!NS.getName().empty())
1769 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1770 addSourceLine(NDie, &NS);
1771 addToContextOwner(NDie, NS.getContext());
1775 /// constructCompileUnit - Create new CompileUnit for the given
1776 /// metadata node with tag DW_TAG_compile_unit.
1777 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1778 DICompileUnit DIUnit(N);
1779 StringRef FN = DIUnit.getFilename();
1780 StringRef Dir = DIUnit.getDirectory();
1781 unsigned ID = GetOrCreateSourceID(Dir, FN);
1783 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1784 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1785 DIUnit.getProducer());
1786 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1787 DIUnit.getLanguage());
1788 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1789 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1790 // simplifies debug range entries.
1791 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_data4, 0);
1792 // DW_AT_stmt_list is a offset of line number information for this
1793 // compile unit in debug_line section. It is always zero when only one
1794 // compile unit is emitted in one object file.
1795 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1798 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1799 if (DIUnit.isOptimized())
1800 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1802 StringRef Flags = DIUnit.getFlags();
1804 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1806 unsigned RVer = DIUnit.getRunTimeVersion();
1808 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1809 dwarf::DW_FORM_data1, RVer);
1811 CompileUnit *NewCU = new CompileUnit(ID, Die);
1814 CUMap.insert(std::make_pair(N, NewCU));
1817 /// getCompielUnit - Get CompileUnit DIE.
1818 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1819 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1821 const MDNode *CUNode = NULL;
1822 if (D.isCompileUnit())
1824 else if (D.isSubprogram())
1825 CUNode = DISubprogram(N).getCompileUnit();
1826 else if (D.isType())
1827 CUNode = DIType(N).getCompileUnit();
1828 else if (D.isGlobalVariable())
1829 CUNode = DIGlobalVariable(N).getCompileUnit();
1830 else if (D.isVariable())
1831 CUNode = DIVariable(N).getCompileUnit();
1832 else if (D.isNameSpace())
1833 CUNode = DINameSpace(N).getCompileUnit();
1834 else if (D.isFile())
1835 CUNode = DIFile(N).getCompileUnit();
1839 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1840 = CUMap.find(CUNode);
1841 if (I == CUMap.end())
1847 /// constructGlobalVariableDIE - Construct global variable DIE.
1848 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1849 DIGlobalVariable DI_GV(N);
1851 // If debug information is malformed then ignore it.
1852 if (DI_GV.Verify() == false)
1855 // Check for pre-existence.
1856 CompileUnit *TheCU = getCompileUnit(N);
1857 if (TheCU->getDIE(DI_GV))
1860 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1865 TheCU->insertDIE(N, VariableDie);
1867 // Add to context owner.
1868 DIDescriptor GVContext = DI_GV.getContext();
1869 // Do not create specification DIE if context is either compile unit
1871 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1872 !GVContext.isFile() &&
1873 !isSubprogramContext(GVContext)) {
1874 // Create specification DIE.
1875 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1876 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1877 dwarf::DW_FORM_ref4, VariableDie);
1878 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1879 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1880 addLabel(Block, 0, dwarf::DW_FORM_udata,
1881 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1882 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1883 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1884 TheCU->addDie(VariableSpecDIE);
1886 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1887 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1888 addLabel(Block, 0, dwarf::DW_FORM_udata,
1889 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1890 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1892 addToContextOwner(VariableDie, GVContext);
1894 // Expose as global. FIXME - need to check external flag.
1895 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1897 DIType GTy = DI_GV.getType();
1898 if (GTy.isCompositeType() && !GTy.getName().empty()
1899 && !GTy.isForwardDecl()) {
1900 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1901 assert(Entry && "Missing global type!");
1902 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1907 /// construct SubprogramDIE - Construct subprogram DIE.
1908 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1911 // Check for pre-existence.
1912 CompileUnit *TheCU = getCompileUnit(N);
1913 if (TheCU->getDIE(N))
1916 if (!SP.isDefinition())
1917 // This is a method declaration which will be handled while constructing
1921 DIE *SubprogramDie = createSubprogramDIE(SP);
1924 TheCU->insertDIE(N, SubprogramDie);
1926 // Add to context owner.
1927 addToContextOwner(SubprogramDie, SP.getContext());
1929 // Expose as global.
1930 TheCU->addGlobal(SP.getName(), SubprogramDie);
1935 /// beginModule - Emit all Dwarf sections that should come prior to the
1936 /// content. Create global DIEs and emit initial debug info sections.
1937 /// This is inovked by the target AsmPrinter.
1938 void DwarfDebug::beginModule(Module *M) {
1939 if (DisableDebugInfoPrinting)
1942 DebugInfoFinder DbgFinder;
1943 DbgFinder.processModule(*M);
1945 bool HasDebugInfo = false;
1947 // Scan all the compile-units to see if there are any marked as the main unit.
1948 // if not, we do not generate debug info.
1949 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1950 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1951 if (DICompileUnit(*I).isMain()) {
1952 HasDebugInfo = true;
1957 if (!HasDebugInfo) return;
1959 // Tell MMI that we have debug info.
1960 MMI->setDebugInfoAvailability(true);
1962 // Emit initial sections.
1963 EmitSectionLabels();
1965 // Create all the compile unit DIEs.
1966 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1967 E = DbgFinder.compile_unit_end(); I != E; ++I)
1968 constructCompileUnit(*I);
1970 // Create DIEs for each subprogram.
1971 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1972 E = DbgFinder.subprogram_end(); I != E; ++I)
1973 constructSubprogramDIE(*I);
1975 // Create DIEs for each global variable.
1976 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1977 E = DbgFinder.global_variable_end(); I != E; ++I)
1978 constructGlobalVariableDIE(*I);
1980 // Prime section data.
1981 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1983 // Print out .file directives to specify files for .loc directives. These are
1984 // printed out early so that they precede any .loc directives.
1985 if (Asm->MAI->hasDotLocAndDotFile()) {
1986 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1987 // Remember source id starts at 1.
1988 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1989 // FIXME: don't use sys::path for this! This should not depend on the
1991 sys::Path FullPath(getSourceDirectoryName(Id.first));
1993 FullPath.appendComponent(getSourceFileName(Id.second));
1994 assert(AppendOk && "Could not append filename to directory!");
1996 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2001 /// endModule - Emit all Dwarf sections that should come after the content.
2003 void DwarfDebug::endModule() {
2004 if (!FirstCU) return;
2006 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2007 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2008 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2010 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2013 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2014 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2015 DIE *SPDie = CI->first;
2016 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2018 DIE *NDie = getCompileUnit(N)->getDIE(N);
2019 if (!NDie) continue;
2020 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2023 // Standard sections final addresses.
2024 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2025 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2026 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2027 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2029 // End text sections.
2030 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2031 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2032 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2035 // Emit common frame information.
2036 emitCommonDebugFrame();
2038 // Emit function debug frame information
2039 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2040 E = DebugFrames.end(); I != E; ++I)
2041 emitFunctionDebugFrame(*I);
2043 // Compute DIE offsets and sizes.
2044 computeSizeAndOffsets();
2046 // Emit all the DIEs into a debug info section
2049 // Corresponding abbreviations into a abbrev section.
2050 emitAbbreviations();
2052 // Emit source line correspondence into a debug line section.
2055 // Emit info into a debug pubnames section.
2056 emitDebugPubNames();
2058 // Emit info into a debug pubtypes section.
2059 emitDebugPubTypes();
2061 // Emit info into a debug loc section.
2064 // Emit info into a debug aranges section.
2067 // Emit info into a debug ranges section.
2070 // Emit info into a debug macinfo section.
2073 // Emit inline info.
2074 emitDebugInlineInfo();
2076 // Emit info into a debug str section.
2079 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2080 E = CUMap.end(); I != E; ++I)
2082 FirstCU = NULL; // Reset for the next Module, if any.
2085 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2086 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2088 DebugLoc ScopeLoc) {
2090 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2092 return AbsDbgVariable;
2094 LLVMContext &Ctx = Var->getContext();
2095 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2099 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
2100 NULL /* No more-abstract variable*/);
2101 Scope->addVariable(AbsDbgVariable);
2102 AbstractVariables[Var] = AbsDbgVariable;
2103 return AbsDbgVariable;
2106 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2107 /// FIXME : Refactor findAbstractVariable.
2108 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2109 const MachineInstr *MI,
2110 DebugLoc ScopeLoc) {
2112 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2114 return AbsDbgVariable;
2116 LLVMContext &Ctx = Var->getContext();
2117 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2121 AbsDbgVariable = new DbgVariable(Var, MI,
2122 NULL /* No more-abstract variable*/);
2123 Scope->addVariable(AbsDbgVariable);
2124 AbstractVariables[Var] = AbsDbgVariable;
2125 DbgValueStartMap[MI] = AbsDbgVariable;
2126 return AbsDbgVariable;
2129 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2130 void DwarfDebug::collectVariableInfo(const MachineFunction *MF) {
2131 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2132 SmallPtrSet<const MDNode *, 16> Processed;
2133 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2134 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2135 VE = VMap.end(); VI != VE; ++VI) {
2136 const MDNode *Var = VI->first;
2138 Processed.insert(Var);
2140 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2142 DbgScope *Scope = 0;
2143 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2144 Scope = ConcreteScopes.lookup(IA);
2146 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2148 // If variable scope is not found then skip this variable.
2152 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2153 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2154 Scope->addVariable(RegVar);
2157 // Collect variable information from DBG_VALUE machine instructions;
2158 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2160 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2162 const MachineInstr *MInsn = II;
2163 if (!MInsn->isDebugValue())
2166 // Ignore Undef values.
2167 if (MInsn->getOperand(0).isReg() && !MInsn->getOperand(0).getReg())
2171 const_cast<const MDNode *>(MInsn->getOperand(MInsn->getNumOperands() - 1)
2173 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2174 // FIXME Handle inlined subroutine arguments.
2175 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2176 CurrentFnDbgScope->addVariable(ArgVar);
2177 DbgValueStartMap[MInsn] = ArgVar;
2178 Processed.insert(DV);
2182 DebugLoc DL = MInsn->getDebugLoc();
2183 if (DL.isUnknown()) continue;
2184 DbgScope *Scope = 0;
2185 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2186 Scope = ConcreteScopes.lookup(IA);
2188 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2190 // If variable scope is not found then skip this variable.
2194 Processed.insert(DV);
2195 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2196 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2197 DbgValueStartMap[MInsn] = RegVar;
2198 Scope->addVariable(RegVar);
2202 // Collect info for variables that were optimized out.
2203 if (NamedMDNode *NMD =
2204 MF->getFunction()->getParent()->getNamedMetadata("llvm.dbg.lv")) {
2205 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2206 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2207 if (!Processed.insert(DV))
2209 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2211 Scope->addVariable(new DbgVariable(DV, ~0U, NULL));
2217 /// beginScope - Process beginning of a scope.
2218 void DwarfDebug::beginScope(const MachineInstr *MI) {
2220 DebugLoc DL = MI->getDebugLoc();
2221 if (DL.isUnknown()) {
2222 if (UnknownLocations) {
2223 // This instruction has no debug location. If the preceding instruction
2224 // did, emit debug location information to indicate that the debug
2225 // location is now unknown.
2226 MCSymbol *Label = NULL;
2227 if (DL == PrevInstLoc)
2230 Label = recordSourceLine(DL.getLine(), DL.getCol(), 0);
2235 // If this instruction begins a scope then note down corresponding label.
2236 if (InsnsBeginScopeSet.count(MI) != 0)
2237 LabelsBeforeInsn[MI] = Label;
2243 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2245 // FIXME: Should only verify each scope once!
2246 if (!DIScope(Scope).Verify())
2249 // DBG_VALUE instruction establishes new value.
2250 if (MI->isDebugValue()) {
2251 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2252 = DbgValueStartMap.find(MI);
2253 if (DI != DbgValueStartMap.end()) {
2254 MCSymbol *Label = NULL;
2255 if (DL == PrevInstLoc)
2258 Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2262 DI->second->setDbgValueLabel(Label);
2267 // Emit a label to indicate location change. This is used for line
2268 // table even if this instruction does not start a new scope.
2269 MCSymbol *Label = NULL;
2270 if (DL == PrevInstLoc)
2273 Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2278 // If this instruction begins a scope then note down corresponding label.
2279 if (InsnsBeginScopeSet.count(MI) != 0)
2280 LabelsBeforeInsn[MI] = Label;
2283 /// endScope - Process end of a scope.
2284 void DwarfDebug::endScope(const MachineInstr *MI) {
2285 if (InsnsEndScopeSet.count(MI) != 0) {
2286 // Emit a label if this instruction ends a scope.
2287 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2288 Asm->OutStreamer.EmitLabel(Label);
2289 LabelsAfterInsn[MI] = Label;
2293 /// getOrCreateDbgScope - Create DbgScope for the scope.
2294 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2296 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2299 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2300 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2301 if (DIDescriptor(Scope).isLexicalBlock()) {
2303 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2304 WScope->setParent(Parent);
2305 Parent->addScope(WScope);
2308 if (!WScope->getParent()) {
2309 StringRef SPName = DISubprogram(Scope).getLinkageName();
2310 if (SPName == Asm->MF->getFunction()->getName())
2311 CurrentFnDbgScope = WScope;
2317 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2321 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2322 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2323 DILocation DL(InlinedAt);
2325 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2326 WScope->setParent(Parent);
2327 Parent->addScope(WScope);
2329 ConcreteScopes[InlinedAt] = WScope;
2330 getOrCreateAbstractScope(Scope);
2335 /// hasValidLocation - Return true if debug location entry attached with
2336 /// machine instruction encodes valid location info.
2337 static bool hasValidLocation(LLVMContext &Ctx,
2338 const MachineInstr *MInsn,
2339 const MDNode *&Scope, const MDNode *&InlinedAt) {
2340 if (MInsn->isDebugValue())
2342 DebugLoc DL = MInsn->getDebugLoc();
2343 if (DL.isUnknown()) return false;
2345 const MDNode *S = DL.getScope(Ctx);
2347 // There is no need to create another DIE for compile unit. For all
2348 // other scopes, create one DbgScope now. This will be translated
2349 // into a scope DIE at the end.
2350 if (DIScope(S).isCompileUnit()) return false;
2353 InlinedAt = DL.getInlinedAt(Ctx);
2357 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2359 static void calculateDominanceGraph(DbgScope *Scope) {
2360 assert (Scope && "Unable to calculate scop edominance graph!");
2361 SmallVector<DbgScope *, 4> WorkStack;
2362 WorkStack.push_back(Scope);
2363 unsigned Counter = 0;
2364 while (!WorkStack.empty()) {
2365 DbgScope *WS = WorkStack.back();
2366 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2367 bool visitedChildren = false;
2368 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2369 SE = Children.end(); SI != SE; ++SI) {
2370 DbgScope *ChildScope = *SI;
2371 if (!ChildScope->getDFSOut()) {
2372 WorkStack.push_back(ChildScope);
2373 visitedChildren = true;
2374 ChildScope->setDFSIn(++Counter);
2378 if (!visitedChildren) {
2379 WorkStack.pop_back();
2380 WS->setDFSOut(++Counter);
2385 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2387 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2388 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2391 unsigned PrevDFSIn = 0;
2392 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2394 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2396 const MachineInstr *MInsn = II;
2397 const MDNode *Scope = NULL;
2398 const MDNode *InlinedAt = NULL;
2400 // Check if instruction has valid location information.
2401 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2405 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2406 MI2ScopeMap.find(MInsn);
2407 if (DI != MI2ScopeMap.end()) {
2408 DbgScope *S = DI->second;
2409 dbgs() << S->getDFSIn();
2410 PrevDFSIn = S->getDFSIn();
2412 dbgs() << PrevDFSIn;
2414 dbgs() << " [ x" << PrevDFSIn;
2422 /// extractScopeInformation - Scan machine instructions in this function
2423 /// and collect DbgScopes. Return true, if at least one scope was found.
2424 bool DwarfDebug::extractScopeInformation() {
2425 // If scope information was extracted using .dbg intrinsics then there is not
2426 // any need to extract these information by scanning each instruction.
2427 if (!DbgScopeMap.empty())
2430 // Scan each instruction and create scopes. First build working set of scopes.
2431 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2432 SmallVector<DbgRange, 4> MIRanges;
2433 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2434 const MDNode *PrevScope = NULL;
2435 const MDNode *PrevInlinedAt = NULL;
2436 const MachineInstr *RangeBeginMI = NULL;
2437 const MachineInstr *PrevMI = NULL;
2438 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2440 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2442 const MachineInstr *MInsn = II;
2443 const MDNode *Scope = NULL;
2444 const MDNode *InlinedAt = NULL;
2446 // Check if instruction has valid location information.
2447 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2452 // If scope has not changed then skip this instruction.
2453 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2459 // If we have alread seen a beginning of a instruction range and
2460 // current instruction scope does not match scope of first instruction
2461 // in this range then create a new instruction range.
2462 DbgRange R(RangeBeginMI, PrevMI);
2463 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2464 MIRanges.push_back(R);
2467 // This is a beginning of a new instruction range.
2468 RangeBeginMI = MInsn;
2470 // Reset previous markers.
2473 PrevInlinedAt = InlinedAt;
2477 // Create last instruction range.
2478 if (RangeBeginMI && PrevMI && PrevScope) {
2479 DbgRange R(RangeBeginMI, PrevMI);
2480 MIRanges.push_back(R);
2481 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2484 if (!CurrentFnDbgScope)
2487 calculateDominanceGraph(CurrentFnDbgScope);
2489 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2491 // Find ranges of instructions covered by each DbgScope;
2492 DbgScope *PrevDbgScope = NULL;
2493 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2494 RE = MIRanges.end(); RI != RE; ++RI) {
2495 const DbgRange &R = *RI;
2496 DbgScope *S = MI2ScopeMap.lookup(R.first);
2497 assert (S && "Lost DbgScope for a machine instruction!");
2498 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2499 PrevDbgScope->closeInsnRange(S);
2500 S->openInsnRange(R.first);
2501 S->extendInsnRange(R.second);
2506 PrevDbgScope->closeInsnRange();
2508 identifyScopeMarkers();
2510 return !DbgScopeMap.empty();
2513 /// identifyScopeMarkers() -
2514 /// Each DbgScope has first instruction and last instruction to mark beginning
2515 /// and end of a scope respectively. Create an inverse map that list scopes
2516 /// starts (and ends) with an instruction. One instruction may start (or end)
2517 /// multiple scopes. Ignore scopes that are not reachable.
2518 void DwarfDebug::identifyScopeMarkers() {
2519 SmallVector<DbgScope *, 4> WorkList;
2520 WorkList.push_back(CurrentFnDbgScope);
2521 while (!WorkList.empty()) {
2522 DbgScope *S = WorkList.pop_back_val();
2524 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2525 if (!Children.empty())
2526 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2527 SE = Children.end(); SI != SE; ++SI)
2528 WorkList.push_back(*SI);
2530 if (S->isAbstractScope())
2533 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2536 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2537 RE = Ranges.end(); RI != RE; ++RI) {
2538 assert(RI->first && "DbgRange does not have first instruction!");
2539 assert(RI->second && "DbgRange does not have second instruction!");
2540 InsnsBeginScopeSet.insert(RI->first);
2541 InsnsEndScopeSet.insert(RI->second);
2546 /// FindFirstDebugLoc - Find the first debug location in the function. This
2547 /// is intended to be an approximation for the source position of the
2548 /// beginning of the function.
2549 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2550 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2552 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2553 MBBI != MBBE; ++MBBI) {
2554 DebugLoc DL = MBBI->getDebugLoc();
2555 if (!DL.isUnknown())
2561 /// beginFunction - Gather pre-function debug information. Assumes being
2562 /// emitted immediately after the function entry point.
2563 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2564 if (!MMI->hasDebugInfo()) return;
2565 if (!extractScopeInformation()) return;
2567 collectVariableInfo(MF);
2569 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2570 Asm->getFunctionNumber());
2571 // Assumes in correct section after the entry point.
2572 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2574 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2576 DebugLoc FDL = FindFirstDebugLoc(MF);
2577 if (FDL.isUnknown()) return;
2579 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2581 DISubprogram SP = getDISubprogram(Scope);
2584 Line = SP.getLineNumber();
2587 Line = FDL.getLine();
2591 recordSourceLine(Line, Col, Scope);
2594 /// endFunction - Gather and emit post-function debug information.
2596 void DwarfDebug::endFunction(const MachineFunction *MF) {
2597 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2599 if (CurrentFnDbgScope) {
2600 // Define end label for subprogram.
2601 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2602 Asm->getFunctionNumber()));
2604 // Get function line info.
2605 if (!Lines.empty()) {
2606 // Get section line info.
2607 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2608 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2609 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2610 // Append the function info to section info.
2611 SectionLineInfos.insert(SectionLineInfos.end(),
2612 Lines.begin(), Lines.end());
2615 // Construct abstract scopes.
2616 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2617 AE = AbstractScopesList.end(); AI != AE; ++AI)
2618 constructScopeDIE(*AI);
2620 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2622 if (!DisableFramePointerElim(*MF))
2623 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2624 dwarf::DW_FORM_flag, 1);
2627 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2628 MMI->getFrameMoves()));
2632 CurrentFnDbgScope = NULL;
2633 DeleteContainerSeconds(DbgScopeMap);
2634 InsnsBeginScopeSet.clear();
2635 InsnsEndScopeSet.clear();
2636 DbgValueStartMap.clear();
2637 ConcreteScopes.clear();
2638 DeleteContainerSeconds(AbstractScopes);
2639 AbstractScopesList.clear();
2640 AbstractVariables.clear();
2641 LabelsBeforeInsn.clear();
2642 LabelsAfterInsn.clear();
2647 /// recordSourceLine - Register a source line with debug info. Returns the
2648 /// unique label that was emitted and which provides correspondence to
2649 /// the source line list.
2650 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2656 DIDescriptor Scope(S);
2658 if (Scope.isCompileUnit()) {
2659 DICompileUnit CU(S);
2660 Dir = CU.getDirectory();
2661 Fn = CU.getFilename();
2662 } else if (Scope.isSubprogram()) {
2664 Dir = SP.getDirectory();
2665 Fn = SP.getFilename();
2666 } else if (Scope.isLexicalBlock()) {
2667 DILexicalBlock DB(S);
2668 Dir = DB.getDirectory();
2669 Fn = DB.getFilename();
2671 assert(0 && "Unexpected scope info");
2673 Src = GetOrCreateSourceID(Dir, Fn);
2676 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2677 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2679 Asm->OutStreamer.EmitLabel(Label);
2683 //===----------------------------------------------------------------------===//
2685 //===----------------------------------------------------------------------===//
2687 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2690 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2691 // Get the children.
2692 const std::vector<DIE *> &Children = Die->getChildren();
2694 // If not last sibling and has children then add sibling offset attribute.
2695 if (!Last && !Children.empty())
2696 Die->addSiblingOffset(DIEValueAllocator);
2698 // Record the abbreviation.
2699 assignAbbrevNumber(Die->getAbbrev());
2701 // Get the abbreviation for this DIE.
2702 unsigned AbbrevNumber = Die->getAbbrevNumber();
2703 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2706 Die->setOffset(Offset);
2708 // Start the size with the size of abbreviation code.
2709 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2711 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2712 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2714 // Size the DIE attribute values.
2715 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2716 // Size attribute value.
2717 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2719 // Size the DIE children if any.
2720 if (!Children.empty()) {
2721 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2722 "Children flag not set");
2724 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2725 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2727 // End of children marker.
2728 Offset += sizeof(int8_t);
2731 Die->setSize(Offset - Die->getOffset());
2735 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2737 void DwarfDebug::computeSizeAndOffsets() {
2738 unsigned PrevOffset = 0;
2739 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2740 E = CUMap.end(); I != E; ++I) {
2741 // Compute size of compile unit header.
2742 static unsigned Offset = PrevOffset +
2743 sizeof(int32_t) + // Length of Compilation Unit Info
2744 sizeof(int16_t) + // DWARF version number
2745 sizeof(int32_t) + // Offset Into Abbrev. Section
2746 sizeof(int8_t); // Pointer Size (in bytes)
2747 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2748 PrevOffset = Offset;
2752 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2753 /// temporary label to it if SymbolStem is specified.
2754 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2755 const char *SymbolStem = 0) {
2756 Asm->OutStreamer.SwitchSection(Section);
2757 if (!SymbolStem) return 0;
2759 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2760 Asm->OutStreamer.EmitLabel(TmpSym);
2764 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2765 /// the start of each one.
2766 void DwarfDebug::EmitSectionLabels() {
2767 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2769 // Dwarf sections base addresses.
2770 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2771 DwarfFrameSectionSym =
2772 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2775 DwarfInfoSectionSym =
2776 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2777 DwarfAbbrevSectionSym =
2778 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2779 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2781 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2782 EmitSectionSym(Asm, MacroInfo);
2784 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2785 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2786 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2787 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2788 DwarfStrSectionSym =
2789 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2790 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2793 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2794 EmitSectionSym(Asm, TLOF.getDataSection());
2797 /// emitDIE - Recusively Emits a debug information entry.
2799 void DwarfDebug::emitDIE(DIE *Die) {
2800 // Get the abbreviation for this DIE.
2801 unsigned AbbrevNumber = Die->getAbbrevNumber();
2802 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2804 // Emit the code (index) for the abbreviation.
2805 if (Asm->isVerbose())
2806 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2807 Twine::utohexstr(Die->getOffset()) + ":0x" +
2808 Twine::utohexstr(Die->getSize()) + " " +
2809 dwarf::TagString(Abbrev->getTag()));
2810 Asm->EmitULEB128(AbbrevNumber);
2812 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2813 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2815 // Emit the DIE attribute values.
2816 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2817 unsigned Attr = AbbrevData[i].getAttribute();
2818 unsigned Form = AbbrevData[i].getForm();
2819 assert(Form && "Too many attributes for DIE (check abbreviation)");
2821 if (Asm->isVerbose())
2822 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2825 case dwarf::DW_AT_sibling:
2826 Asm->EmitInt32(Die->getSiblingOffset());
2828 case dwarf::DW_AT_abstract_origin: {
2829 DIEEntry *E = cast<DIEEntry>(Values[i]);
2830 DIE *Origin = E->getEntry();
2831 unsigned Addr = Origin->getOffset();
2832 Asm->EmitInt32(Addr);
2835 case dwarf::DW_AT_ranges: {
2836 // DW_AT_range Value encodes offset in debug_range section.
2837 DIEInteger *V = cast<DIEInteger>(Values[i]);
2838 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2840 DwarfDebugRangeSectionSym,
2845 // Emit an attribute using the defined form.
2846 Values[i]->EmitValue(Asm, Form);
2851 // Emit the DIE children if any.
2852 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2853 const std::vector<DIE *> &Children = Die->getChildren();
2855 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2856 emitDIE(Children[j]);
2858 if (Asm->isVerbose())
2859 Asm->OutStreamer.AddComment("End Of Children Mark");
2864 /// emitDebugInfo - Emit the debug info section.
2866 void DwarfDebug::emitDebugInfo() {
2867 // Start debug info section.
2868 Asm->OutStreamer.SwitchSection(
2869 Asm->getObjFileLowering().getDwarfInfoSection());
2870 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2871 E = CUMap.end(); I != E; ++I) {
2872 CompileUnit *TheCU = I->second;
2873 DIE *Die = TheCU->getCUDie();
2875 // Emit the compile units header.
2876 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2879 // Emit size of content not including length itself
2880 unsigned ContentSize = Die->getSize() +
2881 sizeof(int16_t) + // DWARF version number
2882 sizeof(int32_t) + // Offset Into Abbrev. Section
2883 sizeof(int8_t) + // Pointer Size (in bytes)
2884 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2886 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2887 Asm->EmitInt32(ContentSize);
2888 Asm->OutStreamer.AddComment("DWARF version number");
2889 Asm->EmitInt16(dwarf::DWARF_VERSION);
2890 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2891 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2892 DwarfAbbrevSectionSym);
2893 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2894 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2897 // FIXME - extra padding for gdb bug.
2898 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2903 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2907 /// emitAbbreviations - Emit the abbreviation section.
2909 void DwarfDebug::emitAbbreviations() const {
2910 // Check to see if it is worth the effort.
2911 if (!Abbreviations.empty()) {
2912 // Start the debug abbrev section.
2913 Asm->OutStreamer.SwitchSection(
2914 Asm->getObjFileLowering().getDwarfAbbrevSection());
2916 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2918 // For each abbrevation.
2919 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2920 // Get abbreviation data
2921 const DIEAbbrev *Abbrev = Abbreviations[i];
2923 // Emit the abbrevations code (base 1 index.)
2924 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2926 // Emit the abbreviations data.
2930 // Mark end of abbreviations.
2931 Asm->EmitULEB128(0, "EOM(3)");
2933 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2937 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2938 /// the line matrix.
2940 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2941 // Define last address of section.
2942 Asm->OutStreamer.AddComment("Extended Op");
2945 Asm->OutStreamer.AddComment("Op size");
2946 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2947 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2948 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2950 Asm->OutStreamer.AddComment("Section end label");
2952 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2953 Asm->getTargetData().getPointerSize(),
2956 // Mark end of matrix.
2957 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2963 /// emitDebugLines - Emit source line information.
2965 void DwarfDebug::emitDebugLines() {
2966 // If the target is using .loc/.file, the assembler will be emitting the
2967 // .debug_line table automatically.
2968 if (Asm->MAI->hasDotLocAndDotFile())
2971 // Minimum line delta, thus ranging from -10..(255-10).
2972 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2973 // Maximum line delta, thus ranging from -10..(255-10).
2974 const int MaxLineDelta = 255 + MinLineDelta;
2976 // Start the dwarf line section.
2977 Asm->OutStreamer.SwitchSection(
2978 Asm->getObjFileLowering().getDwarfLineSection());
2980 // Construct the section header.
2981 Asm->OutStreamer.AddComment("Length of Source Line Info");
2982 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2983 Asm->GetTempSymbol("line_begin"), 4);
2984 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2986 Asm->OutStreamer.AddComment("DWARF version number");
2987 Asm->EmitInt16(dwarf::DWARF_VERSION);
2989 Asm->OutStreamer.AddComment("Prolog Length");
2990 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2991 Asm->GetTempSymbol("line_prolog_begin"), 4);
2992 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2994 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2996 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2998 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2999 Asm->EmitInt8(MinLineDelta);
3000 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3001 Asm->EmitInt8(MaxLineDelta);
3002 Asm->OutStreamer.AddComment("Special Opcode Base");
3003 Asm->EmitInt8(-MinLineDelta);
3005 // Line number standard opcode encodings argument count
3006 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3008 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3010 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3012 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3014 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3016 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3018 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3020 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3022 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3025 // Emit directories.
3026 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3027 const std::string &Dir = getSourceDirectoryName(DI);
3028 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3029 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3032 Asm->OutStreamer.AddComment("End of directories");
3036 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3037 // Remember source id starts at 1.
3038 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3039 const std::string &FN = getSourceFileName(Id.second);
3040 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3041 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3043 Asm->EmitULEB128(Id.first, "Directory #");
3044 Asm->EmitULEB128(0, "Mod date");
3045 Asm->EmitULEB128(0, "File size");
3048 Asm->OutStreamer.AddComment("End of files");
3051 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3053 // A sequence for each text section.
3054 unsigned SecSrcLinesSize = SectionSourceLines.size();
3056 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3057 // Isolate current sections line info.
3058 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3060 // Dwarf assumes we start with first line of first source file.
3061 unsigned Source = 1;
3064 // Construct rows of the address, source, line, column matrix.
3065 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3066 const SrcLineInfo &LineInfo = LineInfos[i];
3067 MCSymbol *Label = LineInfo.getLabel();
3068 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3070 if (Asm->isVerbose()) {
3071 std::pair<unsigned, unsigned> SrcID =
3072 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3073 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3075 Twine(getSourceFileName(SrcID.second)) +
3076 ":" + Twine(LineInfo.getLine()));
3079 // Define the line address.
3080 Asm->OutStreamer.AddComment("Extended Op");
3082 Asm->OutStreamer.AddComment("Op size");
3083 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3085 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3086 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3088 Asm->OutStreamer.AddComment("Location label");
3089 Asm->OutStreamer.EmitSymbolValue(Label,
3090 Asm->getTargetData().getPointerSize(),
3093 // If change of source, then switch to the new source.
3094 if (Source != LineInfo.getSourceID()) {
3095 Source = LineInfo.getSourceID();
3096 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3097 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3098 Asm->EmitULEB128(Source, "New Source");
3101 // If change of line.
3102 if (Line != LineInfo.getLine()) {
3103 // Determine offset.
3104 int Offset = LineInfo.getLine() - Line;
3105 int Delta = Offset - MinLineDelta;
3108 Line = LineInfo.getLine();
3110 // If delta is small enough and in range...
3111 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3112 // ... then use fast opcode.
3113 Asm->OutStreamer.AddComment("Line Delta");
3114 Asm->EmitInt8(Delta - MinLineDelta);
3116 // ... otherwise use long hand.
3117 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3118 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3119 Asm->EmitSLEB128(Offset, "Line Offset");
3120 Asm->OutStreamer.AddComment("DW_LNS_copy");
3121 Asm->EmitInt8(dwarf::DW_LNS_copy);
3124 // Copy the previous row (different address or source)
3125 Asm->OutStreamer.AddComment("DW_LNS_copy");
3126 Asm->EmitInt8(dwarf::DW_LNS_copy);
3130 emitEndOfLineMatrix(j + 1);
3133 if (SecSrcLinesSize == 0)
3134 // Because we're emitting a debug_line section, we still need a line
3135 // table. The linker and friends expect it to exist. If there's nothing to
3136 // put into it, emit an empty table.
3137 emitEndOfLineMatrix(1);
3139 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3142 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3144 void DwarfDebug::emitCommonDebugFrame() {
3145 if (!Asm->MAI->doesDwarfRequireFrameSection())
3148 int stackGrowth = Asm->getTargetData().getPointerSize();
3149 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3150 TargetFrameInfo::StackGrowsDown)
3153 // Start the dwarf frame section.
3154 Asm->OutStreamer.SwitchSection(
3155 Asm->getObjFileLowering().getDwarfFrameSection());
3157 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3158 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3159 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3160 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3162 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3163 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3164 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3165 Asm->OutStreamer.AddComment("CIE Version");
3166 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3167 Asm->OutStreamer.AddComment("CIE Augmentation");
3168 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3169 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3170 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3171 Asm->OutStreamer.AddComment("CIE RA Column");
3172 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3173 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3175 std::vector<MachineMove> Moves;
3176 RI->getInitialFrameState(Moves);
3178 Asm->EmitFrameMoves(Moves, 0, false);
3180 Asm->EmitAlignment(2);
3181 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3184 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3187 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3188 if (!Asm->MAI->doesDwarfRequireFrameSection())
3191 // Start the dwarf frame section.
3192 Asm->OutStreamer.SwitchSection(
3193 Asm->getObjFileLowering().getDwarfFrameSection());
3195 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3196 MCSymbol *DebugFrameBegin =
3197 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3198 MCSymbol *DebugFrameEnd =
3199 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3200 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3202 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3204 Asm->OutStreamer.AddComment("FDE CIE offset");
3205 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3206 DwarfFrameSectionSym);
3208 Asm->OutStreamer.AddComment("FDE initial location");
3209 MCSymbol *FuncBeginSym =
3210 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3211 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3212 Asm->getTargetData().getPointerSize(),
3216 Asm->OutStreamer.AddComment("FDE address range");
3217 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3218 FuncBeginSym, Asm->getTargetData().getPointerSize());
3220 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3222 Asm->EmitAlignment(2);
3223 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3226 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3228 void DwarfDebug::emitDebugPubNames() {
3229 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3230 E = CUMap.end(); I != E; ++I) {
3231 CompileUnit *TheCU = I->second;
3232 // Start the dwarf pubnames section.
3233 Asm->OutStreamer.SwitchSection(
3234 Asm->getObjFileLowering().getDwarfPubNamesSection());
3236 Asm->OutStreamer.AddComment("Length of Public Names Info");
3237 Asm->EmitLabelDifference(
3238 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3239 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3241 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3244 Asm->OutStreamer.AddComment("DWARF Version");
3245 Asm->EmitInt16(dwarf::DWARF_VERSION);
3247 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3248 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3249 DwarfInfoSectionSym);
3251 Asm->OutStreamer.AddComment("Compilation Unit Length");
3252 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3253 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3256 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3257 for (StringMap<DIE*>::const_iterator
3258 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3259 const char *Name = GI->getKeyData();
3260 DIE *Entity = GI->second;
3262 Asm->OutStreamer.AddComment("DIE offset");
3263 Asm->EmitInt32(Entity->getOffset());
3265 if (Asm->isVerbose())
3266 Asm->OutStreamer.AddComment("External Name");
3267 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3270 Asm->OutStreamer.AddComment("End Mark");
3272 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3277 void DwarfDebug::emitDebugPubTypes() {
3278 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3279 E = CUMap.end(); I != E; ++I) {
3280 CompileUnit *TheCU = I->second;
3281 // Start the dwarf pubnames section.
3282 Asm->OutStreamer.SwitchSection(
3283 Asm->getObjFileLowering().getDwarfPubTypesSection());
3284 Asm->OutStreamer.AddComment("Length of Public Types Info");
3285 Asm->EmitLabelDifference(
3286 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3287 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3289 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3292 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3293 Asm->EmitInt16(dwarf::DWARF_VERSION);
3295 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3296 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3297 DwarfInfoSectionSym);
3299 Asm->OutStreamer.AddComment("Compilation Unit Length");
3300 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3301 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3304 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3305 for (StringMap<DIE*>::const_iterator
3306 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3307 const char *Name = GI->getKeyData();
3308 DIE * Entity = GI->second;
3310 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3311 Asm->EmitInt32(Entity->getOffset());
3313 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3314 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3317 Asm->OutStreamer.AddComment("End Mark");
3319 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3324 /// emitDebugStr - Emit visible names into a debug str section.
3326 void DwarfDebug::emitDebugStr() {
3327 // Check to see if it is worth the effort.
3328 if (StringPool.empty()) return;
3330 // Start the dwarf str section.
3331 Asm->OutStreamer.SwitchSection(
3332 Asm->getObjFileLowering().getDwarfStrSection());
3334 // Get all of the string pool entries and put them in an array by their ID so
3335 // we can sort them.
3336 SmallVector<std::pair<unsigned,
3337 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3339 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3340 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3341 Entries.push_back(std::make_pair(I->second.second, &*I));
3343 array_pod_sort(Entries.begin(), Entries.end());
3345 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3346 // Emit a label for reference from debug information entries.
3347 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3349 // Emit the string itself.
3350 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3354 /// emitDebugLoc - Emit visible names into a debug loc section.
3356 void DwarfDebug::emitDebugLoc() {
3357 // Start the dwarf loc section.
3358 Asm->OutStreamer.SwitchSection(
3359 Asm->getObjFileLowering().getDwarfLocSection());
3362 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3364 void DwarfDebug::EmitDebugARanges() {
3365 // Start the dwarf aranges section.
3366 Asm->OutStreamer.SwitchSection(
3367 Asm->getObjFileLowering().getDwarfARangesSection());
3370 /// emitDebugRanges - Emit visible names into a debug ranges section.
3372 void DwarfDebug::emitDebugRanges() {
3373 // Start the dwarf ranges section.
3374 Asm->OutStreamer.SwitchSection(
3375 Asm->getObjFileLowering().getDwarfRangesSection());
3376 unsigned char Size = Asm->getTargetData().getPointerSize();
3377 for (SmallVector<const MCSymbol *, 8>::iterator
3378 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3381 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3383 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3387 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3389 void DwarfDebug::emitDebugMacInfo() {
3390 if (const MCSection *LineInfo =
3391 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3392 // Start the dwarf macinfo section.
3393 Asm->OutStreamer.SwitchSection(LineInfo);
3397 /// emitDebugInlineInfo - Emit inline info using following format.
3399 /// 1. length of section
3400 /// 2. Dwarf version number
3401 /// 3. address size.
3403 /// Entries (one "entry" for each function that was inlined):
3405 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3406 /// otherwise offset into __debug_str for regular function name.
3407 /// 2. offset into __debug_str section for regular function name.
3408 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3409 /// instances for the function.
3411 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3412 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3413 /// __debug_info section, and the low_pc is the starting address for the
3414 /// inlining instance.
3415 void DwarfDebug::emitDebugInlineInfo() {
3416 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3422 Asm->OutStreamer.SwitchSection(
3423 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3425 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3426 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3427 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3429 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3431 Asm->OutStreamer.AddComment("Dwarf Version");
3432 Asm->EmitInt16(dwarf::DWARF_VERSION);
3433 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3434 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3436 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3437 E = InlinedSPNodes.end(); I != E; ++I) {
3439 const MDNode *Node = *I;
3440 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3441 = InlineInfo.find(Node);
3442 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3443 DISubprogram SP(Node);
3444 StringRef LName = SP.getLinkageName();
3445 StringRef Name = SP.getName();
3447 Asm->OutStreamer.AddComment("MIPS linkage name");
3448 if (LName.empty()) {
3449 Asm->OutStreamer.EmitBytes(Name, 0);
3450 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3452 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3453 DwarfStrSectionSym);
3455 Asm->OutStreamer.AddComment("Function name");
3456 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3457 Asm->EmitULEB128(Labels.size(), "Inline count");
3459 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3460 LE = Labels.end(); LI != LE; ++LI) {
3461 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3462 Asm->EmitInt32(LI->second->getOffset());
3464 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3465 Asm->OutStreamer.EmitSymbolValue(LI->first,
3466 Asm->getTargetData().getPointerSize(),0);
3470 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));