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.
173 // AbsVar may be NULL.
174 DbgVariable(DIVariable V) : Var(V), TheDIE(0) {}
177 DIVariable getVariable() const { return Var; }
178 void setDIE(DIE *D) { TheDIE = D; }
179 DIE *getDIE() const { return TheDIE; }
182 //===----------------------------------------------------------------------===//
183 /// DbgRange - This is used to track range of instructions with identical
184 /// debug info scope.
186 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
188 //===----------------------------------------------------------------------===//
189 /// DbgScope - This class is used to track scope information.
192 DbgScope *Parent; // Parent to this scope.
193 DIDescriptor Desc; // Debug info descriptor for scope.
194 // Location at which this scope is inlined.
195 AssertingVH<const MDNode> InlinedAtLocation;
196 bool AbstractScope; // Abstract Scope
197 const MachineInstr *LastInsn; // Last instruction of this scope.
198 const MachineInstr *FirstInsn; // First instruction of this scope.
199 unsigned DFSIn, DFSOut;
200 // Scopes defined in scope. Contents not owned.
201 SmallVector<DbgScope *, 4> Scopes;
202 // Variables declared in scope. Contents owned.
203 SmallVector<DbgVariable *, 8> Variables;
204 SmallVector<DbgRange, 4> Ranges;
205 // Private state for dump()
206 mutable unsigned IndentLevel;
208 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
209 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
210 LastInsn(0), FirstInsn(0),
211 DFSIn(0), DFSOut(0), IndentLevel(0) {}
215 DbgScope *getParent() const { return Parent; }
216 void setParent(DbgScope *P) { Parent = P; }
217 DIDescriptor getDesc() const { return Desc; }
218 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
219 const MDNode *getScopeNode() const { return Desc; }
220 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
221 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
222 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
224 /// openInsnRange - This scope covers instruction range starting from MI.
225 void openInsnRange(const MachineInstr *MI) {
230 Parent->openInsnRange(MI);
233 /// extendInsnRange - Extend the current instruction range covered by
235 void extendInsnRange(const MachineInstr *MI) {
236 assert (FirstInsn && "MI Range is not open!");
239 Parent->extendInsnRange(MI);
242 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
243 /// until now. This is used when a new scope is encountered while walking
244 /// machine instructions.
245 void closeInsnRange(DbgScope *NewScope = NULL) {
246 assert (LastInsn && "Last insn missing!");
247 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
250 // If Parent dominates NewScope then do not close Parent's instruction
252 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
253 Parent->closeInsnRange(NewScope);
256 void setAbstractScope() { AbstractScope = true; }
257 bool isAbstractScope() const { return AbstractScope; }
259 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
260 unsigned getDFSOut() const { return DFSOut; }
261 void setDFSOut(unsigned O) { DFSOut = O; }
262 unsigned getDFSIn() const { return DFSIn; }
263 void setDFSIn(unsigned I) { DFSIn = I; }
264 bool dominates(const DbgScope *S) {
267 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
272 /// addScope - Add a scope to the scope.
274 void addScope(DbgScope *S) { Scopes.push_back(S); }
276 /// addVariable - Add a variable to the scope.
278 void addVariable(DbgVariable *V) { Variables.push_back(V); }
285 } // end llvm namespace
288 void DbgScope::dump() const {
289 raw_ostream &err = dbgs();
290 err.indent(IndentLevel);
291 const MDNode *N = Desc;
294 err << "Abstract Scope\n";
298 err << "Children ...\n";
299 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
300 if (Scopes[i] != this)
307 DbgScope::~DbgScope() {
308 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
312 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
313 : Asm(A), MMI(Asm->MMI), FirstCU(0),
314 AbbreviationsSet(InitAbbreviationsSetSize),
315 CurrentFnDbgScope(0), PrevLabel(NULL) {
316 NextStringPoolNumber = 0;
318 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
319 DwarfStrSectionSym = TextSectionSym = 0;
320 DwarfDebugRangeSectionSym = 0;
321 FunctionBeginSym = 0;
322 if (TimePassesIsEnabled) {
323 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
329 DwarfDebug::~DwarfDebug() {
330 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
331 DIEBlocks[j]->~DIEBlock();
334 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
335 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
336 if (Entry.first) return Entry.first;
338 Entry.second = NextStringPoolNumber++;
339 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
343 /// assignAbbrevNumber - Define a unique number for the abbreviation.
345 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
346 // Profile the node so that we can make it unique.
350 // Check the set for priors.
351 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
353 // If it's newly added.
354 if (InSet == &Abbrev) {
355 // Add to abbreviation list.
356 Abbreviations.push_back(&Abbrev);
358 // Assign the vector position + 1 as its number.
359 Abbrev.setNumber(Abbreviations.size());
361 // Assign existing abbreviation number.
362 Abbrev.setNumber(InSet->getNumber());
366 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
367 /// information entry.
368 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
369 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
373 /// addUInt - Add an unsigned integer attribute data and value.
375 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
376 unsigned Form, uint64_t Integer) {
377 if (!Form) Form = DIEInteger::BestForm(false, Integer);
378 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
379 Die->addValue(Attribute, Form, Value);
382 /// addSInt - Add an signed integer attribute data and value.
384 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
385 unsigned Form, int64_t Integer) {
386 if (!Form) Form = DIEInteger::BestForm(true, Integer);
387 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
388 Die->addValue(Attribute, Form, Value);
391 /// addString - Add a string attribute data and value. DIEString only
392 /// keeps string reference.
393 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
395 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
396 Die->addValue(Attribute, Form, Value);
399 /// addLabel - Add a Dwarf label attribute data and value.
401 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
402 const MCSymbol *Label) {
403 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
404 Die->addValue(Attribute, Form, Value);
407 /// addDelta - Add a label delta attribute data and value.
409 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
410 const MCSymbol *Hi, const MCSymbol *Lo) {
411 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
412 Die->addValue(Attribute, Form, Value);
415 /// addDIEEntry - Add a DIE attribute data and value.
417 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
419 Die->addValue(Attribute, Form, createDIEEntry(Entry));
423 /// addBlock - Add block data.
425 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
427 Block->ComputeSize(Asm);
428 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
429 Die->addValue(Attribute, Block->BestForm(), Block);
432 /// addSourceLine - Add location information to specified debug information
434 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
439 unsigned Line = V->getLineNumber();
440 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
441 V->getContext().getFilename());
442 assert(FileID && "Invalid file id");
443 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
444 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
447 /// addSourceLine - Add location information to specified debug information
449 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
450 // Verify global variable.
454 unsigned Line = G->getLineNumber();
455 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
456 G->getContext().getFilename());
457 assert(FileID && "Invalid file id");
458 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
459 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
462 /// addSourceLine - Add location information to specified debug information
464 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
465 // Verify subprogram.
468 // If the line number is 0, don't add it.
469 if (SP->getLineNumber() == 0)
472 unsigned Line = SP->getLineNumber();
473 if (!SP->getContext().Verify())
475 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
477 assert(FileID && "Invalid file id");
478 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
479 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
482 /// addSourceLine - Add location information to specified debug information
484 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
489 unsigned Line = Ty->getLineNumber();
490 if (!Ty->getContext().Verify())
492 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
493 Ty->getContext().getFilename());
494 assert(FileID && "Invalid file id");
495 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
496 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
499 /// addSourceLine - Add location information to specified debug information
501 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
506 unsigned Line = NS->getLineNumber();
507 StringRef FN = NS->getFilename();
508 StringRef Dir = NS->getDirectory();
510 unsigned FileID = GetOrCreateSourceID(Dir, FN);
511 assert(FileID && "Invalid file id");
512 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
513 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
516 /* Byref variables, in Blocks, are declared by the programmer as
517 "SomeType VarName;", but the compiler creates a
518 __Block_byref_x_VarName struct, and gives the variable VarName
519 either the struct, or a pointer to the struct, as its type. This
520 is necessary for various behind-the-scenes things the compiler
521 needs to do with by-reference variables in blocks.
523 However, as far as the original *programmer* is concerned, the
524 variable should still have type 'SomeType', as originally declared.
526 The following function dives into the __Block_byref_x_VarName
527 struct to find the original type of the variable. This will be
528 passed back to the code generating the type for the Debug
529 Information Entry for the variable 'VarName'. 'VarName' will then
530 have the original type 'SomeType' in its debug information.
532 The original type 'SomeType' will be the type of the field named
533 'VarName' inside the __Block_byref_x_VarName struct.
535 NOTE: In order for this to not completely fail on the debugger
536 side, the Debug Information Entry for the variable VarName needs to
537 have a DW_AT_location that tells the debugger how to unwind through
538 the pointers and __Block_byref_x_VarName struct to find the actual
539 value of the variable. The function addBlockByrefType does this. */
541 /// Find the type the programmer originally declared the variable to be
542 /// and return that type.
544 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
547 unsigned tag = Ty.getTag();
549 if (tag == dwarf::DW_TAG_pointer_type) {
550 DIDerivedType DTy = DIDerivedType(Ty);
551 subType = DTy.getTypeDerivedFrom();
554 DICompositeType blockStruct = DICompositeType(subType);
555 DIArray Elements = blockStruct.getTypeArray();
557 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
558 DIDescriptor Element = Elements.getElement(i);
559 DIDerivedType DT = DIDerivedType(Element);
560 if (Name == DT.getName())
561 return (DT.getTypeDerivedFrom());
567 /// addComplexAddress - Start with the address based on the location provided,
568 /// and generate the DWARF information necessary to find the actual variable
569 /// given the extra address information encoded in the DIVariable, starting from
570 /// the starting location. Add the DWARF information to the die.
572 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
574 const MachineLocation &Location) {
575 const DIVariable &VD = DV->getVariable();
576 DIType Ty = VD.getType();
578 // Decode the original location, and use that as the start of the byref
579 // variable's location.
580 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
581 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
582 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
584 if (Location.isReg()) {
586 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
588 Reg = Reg - dwarf::DW_OP_reg0;
589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
590 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
594 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
596 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
597 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
600 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
603 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
604 uint64_t Element = VD.getAddrElement(i);
606 if (Element == DIFactory::OpPlus) {
607 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
608 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
609 } else if (Element == DIFactory::OpDeref) {
610 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
611 } else llvm_unreachable("unknown DIFactory Opcode");
614 // Now attach the location information to the DIE.
615 addBlock(Die, Attribute, 0, Block);
618 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
619 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
620 gives the variable VarName either the struct, or a pointer to the struct, as
621 its type. This is necessary for various behind-the-scenes things the
622 compiler needs to do with by-reference variables in Blocks.
624 However, as far as the original *programmer* is concerned, the variable
625 should still have type 'SomeType', as originally declared.
627 The function getBlockByrefType dives into the __Block_byref_x_VarName
628 struct to find the original type of the variable, which is then assigned to
629 the variable's Debug Information Entry as its real type. So far, so good.
630 However now the debugger will expect the variable VarName to have the type
631 SomeType. So we need the location attribute for the variable to be an
632 expression that explains to the debugger how to navigate through the
633 pointers and struct to find the actual variable of type SomeType.
635 The following function does just that. We start by getting
636 the "normal" location for the variable. This will be the location
637 of either the struct __Block_byref_x_VarName or the pointer to the
638 struct __Block_byref_x_VarName.
640 The struct will look something like:
642 struct __Block_byref_x_VarName {
644 struct __Block_byref_x_VarName *forwarding;
645 ... <various other fields>
647 ... <maybe more fields>
650 If we are given the struct directly (as our starting point) we
651 need to tell the debugger to:
653 1). Add the offset of the forwarding field.
655 2). Follow that pointer to get the real __Block_byref_x_VarName
656 struct to use (the real one may have been copied onto the heap).
658 3). Add the offset for the field VarName, to find the actual variable.
660 If we started with a pointer to the struct, then we need to
661 dereference that pointer first, before the other steps.
662 Translating this into DWARF ops, we will need to append the following
663 to the current location description for the variable:
665 DW_OP_deref -- optional, if we start with a pointer
666 DW_OP_plus_uconst <forward_fld_offset>
668 DW_OP_plus_uconst <varName_fld_offset>
670 That is what this function does. */
672 /// addBlockByrefAddress - Start with the address based on the location
673 /// provided, and generate the DWARF information necessary to find the
674 /// actual Block variable (navigating the Block struct) based on the
675 /// starting location. Add the DWARF information to the die. For
676 /// more information, read large comment just above here.
678 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
680 const MachineLocation &Location) {
681 const DIVariable &VD = DV->getVariable();
682 DIType Ty = VD.getType();
684 unsigned Tag = Ty.getTag();
685 bool isPointer = false;
687 StringRef varName = VD.getName();
689 if (Tag == dwarf::DW_TAG_pointer_type) {
690 DIDerivedType DTy = DIDerivedType(Ty);
691 TmpTy = DTy.getTypeDerivedFrom();
695 DICompositeType blockStruct = DICompositeType(TmpTy);
697 // Find the __forwarding field and the variable field in the __Block_byref
699 DIArray Fields = blockStruct.getTypeArray();
700 DIDescriptor varField = DIDescriptor();
701 DIDescriptor forwardingField = DIDescriptor();
703 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
704 DIDescriptor Element = Fields.getElement(i);
705 DIDerivedType DT = DIDerivedType(Element);
706 StringRef fieldName = DT.getName();
707 if (fieldName == "__forwarding")
708 forwardingField = Element;
709 else if (fieldName == varName)
713 // Get the offsets for the forwarding field and the variable field.
714 unsigned forwardingFieldOffset =
715 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
716 unsigned varFieldOffset =
717 DIDerivedType(varField).getOffsetInBits() >> 3;
719 // Decode the original location, and use that as the start of the byref
720 // variable's location.
721 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
722 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
723 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
725 if (Location.isReg()) {
727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
729 Reg = Reg - dwarf::DW_OP_reg0;
730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
731 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
737 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
738 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
741 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
744 // If we started with a pointer to the __Block_byref... struct, then
745 // the first thing we need to do is dereference the pointer (DW_OP_deref).
747 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
749 // Next add the offset for the '__forwarding' field:
750 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
751 // adding the offset if it's 0.
752 if (forwardingFieldOffset > 0) {
753 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
754 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
757 // Now dereference the __forwarding field to get to the real __Block_byref
758 // struct: DW_OP_deref.
759 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
761 // Now that we've got the real __Block_byref... struct, add the offset
762 // for the variable's field to get to the location of the actual variable:
763 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
764 if (varFieldOffset > 0) {
765 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
766 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
769 // Now attach the location information to the DIE.
770 addBlock(Die, Attribute, 0, Block);
773 /// addAddress - Add an address attribute to a die based on the location
775 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
776 const MachineLocation &Location) {
777 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
778 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
779 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
781 if (Location.isReg()) {
783 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
785 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
786 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
790 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
792 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
793 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
796 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
799 addBlock(Die, Attribute, 0, Block);
802 /// addRegisterAddress - Add register location entry in variable DIE.
803 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
804 const MachineOperand &MO) {
805 assert (MO.isReg() && "Invalid machine operand!");
808 MachineLocation Location;
809 Location.set(MO.getReg());
810 addAddress(Die, dwarf::DW_AT_location, Location);
812 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
816 /// addConstantValue - Add constant value entry in variable DIE.
817 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
818 const MachineOperand &MO) {
819 assert (MO.isImm() && "Invalid machine operand!");
820 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
821 unsigned Imm = MO.getImm();
822 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
823 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
825 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
829 /// addConstantFPValue - Add constant value entry in variable DIE.
830 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
831 const MachineOperand &MO) {
832 assert (MO.isFPImm() && "Invalid machine operand!");
833 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
834 APFloat FPImm = MO.getFPImm()->getValueAPF();
836 // Get the raw data form of the floating point.
837 const APInt FltVal = FPImm.bitcastToAPInt();
838 const char *FltPtr = (const char*)FltVal.getRawData();
840 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
841 bool LittleEndian = Asm->getTargetData().isLittleEndian();
842 int Incr = (LittleEndian ? 1 : -1);
843 int Start = (LittleEndian ? 0 : NumBytes - 1);
844 int Stop = (LittleEndian ? NumBytes : -1);
846 // Output the constant to DWARF one byte at a time.
847 for (; Start != Stop; Start += Incr)
848 addUInt(Block, 0, dwarf::DW_FORM_data1,
849 (unsigned char)0xFF & FltPtr[Start]);
851 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
853 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
858 /// addToContextOwner - Add Die into the list of its context owner's children.
859 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
860 if (Context.isType()) {
861 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
862 ContextDIE->addChild(Die);
863 } else if (Context.isNameSpace()) {
864 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
865 ContextDIE->addChild(Die);
866 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
867 ContextDIE->addChild(Die);
869 getCompileUnit(Context)->addDie(Die);
872 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
874 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
875 CompileUnit *TypeCU = getCompileUnit(Ty);
876 DIE *TyDIE = TypeCU->getDIE(Ty);
881 TyDIE = new DIE(dwarf::DW_TAG_base_type);
882 TypeCU->insertDIE(Ty, TyDIE);
883 if (Ty.isBasicType())
884 constructTypeDIE(*TyDIE, DIBasicType(Ty));
885 else if (Ty.isCompositeType())
886 constructTypeDIE(*TyDIE, DICompositeType(Ty));
888 assert(Ty.isDerivedType() && "Unknown kind of DIType");
889 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
892 addToContextOwner(TyDIE, Ty.getContext());
896 /// addType - Add a new type attribute to the specified entity.
897 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
901 // Check for pre-existence.
902 CompileUnit *TypeCU = getCompileUnit(Ty);
903 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
904 // If it exists then use the existing value.
906 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
911 DIE *Buffer = getOrCreateTypeDIE(Ty);
914 Entry = createDIEEntry(Buffer);
915 TypeCU->insertDIEEntry(Ty, Entry);
917 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
920 /// constructTypeDIE - Construct basic type die from DIBasicType.
921 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
922 // Get core information.
923 StringRef Name = BTy.getName();
924 Buffer.setTag(dwarf::DW_TAG_base_type);
925 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
928 // Add name if not anonymous or intermediate type.
930 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
931 uint64_t Size = BTy.getSizeInBits() >> 3;
932 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
935 /// constructTypeDIE - Construct derived type die from DIDerivedType.
936 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
937 // Get core information.
938 StringRef Name = DTy.getName();
939 uint64_t Size = DTy.getSizeInBits() >> 3;
940 unsigned Tag = DTy.getTag();
942 // FIXME - Workaround for templates.
943 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
947 // Map to main type, void will not have a type.
948 DIType FromTy = DTy.getTypeDerivedFrom();
949 addType(&Buffer, FromTy);
951 // Add name if not anonymous or intermediate type.
953 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
955 // Add size if non-zero (derived types might be zero-sized.)
957 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
959 // Add source line info if available and TyDesc is not a forward declaration.
960 if (!DTy.isForwardDecl())
961 addSourceLine(&Buffer, &DTy);
964 /// constructTypeDIE - Construct type DIE from DICompositeType.
965 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
966 // Get core information.
967 StringRef Name = CTy.getName();
969 uint64_t Size = CTy.getSizeInBits() >> 3;
970 unsigned Tag = CTy.getTag();
974 case dwarf::DW_TAG_vector_type:
975 case dwarf::DW_TAG_array_type:
976 constructArrayTypeDIE(Buffer, &CTy);
978 case dwarf::DW_TAG_enumeration_type: {
979 DIArray Elements = CTy.getTypeArray();
981 // Add enumerators to enumeration type.
982 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
984 DIDescriptor Enum(Elements.getElement(i));
985 if (Enum.isEnumerator()) {
986 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
987 Buffer.addChild(ElemDie);
992 case dwarf::DW_TAG_subroutine_type: {
994 DIArray Elements = CTy.getTypeArray();
995 DIDescriptor RTy = Elements.getElement(0);
996 addType(&Buffer, DIType(RTy));
998 // Add prototype flag.
999 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1002 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1003 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1004 DIDescriptor Ty = Elements.getElement(i);
1005 addType(Arg, DIType(Ty));
1006 Buffer.addChild(Arg);
1010 case dwarf::DW_TAG_structure_type:
1011 case dwarf::DW_TAG_union_type:
1012 case dwarf::DW_TAG_class_type: {
1013 // Add elements to structure type.
1014 DIArray Elements = CTy.getTypeArray();
1016 // A forward struct declared type may not have elements available.
1017 unsigned N = Elements.getNumElements();
1021 // Add elements to structure type.
1022 for (unsigned i = 0; i < N; ++i) {
1023 DIDescriptor Element = Elements.getElement(i);
1024 DIE *ElemDie = NULL;
1025 if (Element.isSubprogram())
1026 ElemDie = createSubprogramDIE(DISubprogram(Element));
1027 else if (Element.isVariable()) {
1028 DIVariable DV(Element);
1029 ElemDie = new DIE(dwarf::DW_TAG_variable);
1030 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1032 addType(ElemDie, DV.getType());
1033 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1034 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1035 addSourceLine(ElemDie, &DV);
1036 } else if (Element.isDerivedType())
1037 ElemDie = createMemberDIE(DIDerivedType(Element));
1040 Buffer.addChild(ElemDie);
1043 if (CTy.isAppleBlockExtension())
1044 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1046 unsigned RLang = CTy.getRunTimeLang();
1048 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1049 dwarf::DW_FORM_data1, RLang);
1051 DICompositeType ContainingType = CTy.getContainingType();
1052 if (DIDescriptor(ContainingType).isCompositeType())
1053 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1054 getOrCreateTypeDIE(DIType(ContainingType)));
1061 // Add name if not anonymous or intermediate type.
1063 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1065 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1066 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1067 // Add size if non-zero (derived types might be zero-sized.)
1069 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1071 // Add zero size if it is not a forward declaration.
1072 if (CTy.isForwardDecl())
1073 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1075 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1078 // Add source line info if available.
1079 if (!CTy.isForwardDecl())
1080 addSourceLine(&Buffer, &CTy);
1084 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1085 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1086 int64_t L = SR.getLo();
1087 int64_t H = SR.getHi();
1088 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1090 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1092 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1093 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1095 Buffer.addChild(DW_Subrange);
1098 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1099 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1100 DICompositeType *CTy) {
1101 Buffer.setTag(dwarf::DW_TAG_array_type);
1102 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1103 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1105 // Emit derived type.
1106 addType(&Buffer, CTy->getTypeDerivedFrom());
1107 DIArray Elements = CTy->getTypeArray();
1109 // Get an anonymous type for index type.
1110 CompileUnit *TheCU = getCompileUnit(*CTy);
1111 DIE *IdxTy = TheCU->getIndexTyDie();
1113 // Construct an anonymous type for index type.
1114 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1115 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1116 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1117 dwarf::DW_ATE_signed);
1118 TheCU->addDie(IdxTy);
1119 TheCU->setIndexTyDie(IdxTy);
1122 // Add subranges to array type.
1123 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1124 DIDescriptor Element = Elements.getElement(i);
1125 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1126 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1130 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1131 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1132 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1133 StringRef Name = ETy.getName();
1134 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1135 int64_t Value = ETy.getEnumValue();
1136 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1140 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1141 /// printer to not emit usual symbol prefix before the symbol name is used then
1142 /// return linkage name after skipping this special LLVM prefix.
1143 static StringRef getRealLinkageName(StringRef LinkageName) {
1145 if (LinkageName.startswith(StringRef(&One, 1)))
1146 return LinkageName.substr(1);
1150 /// createGlobalVariableDIE - Create new DIE using GV.
1151 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1152 // If the global variable was optmized out then no need to create debug info
1154 if (!GV.getGlobal()) return NULL;
1155 if (GV.getDisplayName().empty()) return NULL;
1157 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1158 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1159 GV.getDisplayName());
1161 StringRef LinkageName = GV.getLinkageName();
1162 if (!LinkageName.empty())
1163 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1164 getRealLinkageName(LinkageName));
1166 addType(GVDie, GV.getType());
1167 if (!GV.isLocalToUnit())
1168 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1169 addSourceLine(GVDie, &GV);
1174 /// createMemberDIE - Create new member DIE.
1175 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1176 DIE *MemberDie = new DIE(DT.getTag());
1177 StringRef Name = DT.getName();
1179 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1181 addType(MemberDie, DT.getTypeDerivedFrom());
1183 addSourceLine(MemberDie, &DT);
1185 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1186 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1188 uint64_t Size = DT.getSizeInBits();
1189 uint64_t FieldSize = DT.getOriginalTypeSize();
1191 if (Size != FieldSize) {
1193 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1194 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1196 uint64_t Offset = DT.getOffsetInBits();
1197 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1198 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1199 uint64_t FieldOffset = (HiMark - FieldSize);
1200 Offset -= FieldOffset;
1202 // Maybe we need to work from the other end.
1203 if (Asm->getTargetData().isLittleEndian())
1204 Offset = FieldSize - (Offset + Size);
1205 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1207 // Here WD_AT_data_member_location points to the anonymous
1208 // field that includes this bit field.
1209 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1212 // This is not a bitfield.
1213 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1215 if (DT.getTag() == dwarf::DW_TAG_inheritance
1216 && DT.isVirtual()) {
1218 // For C++, virtual base classes are not at fixed offset. Use following
1219 // expression to extract appropriate offset from vtable.
1220 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1222 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1223 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1224 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1225 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1226 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1227 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1228 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1229 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1231 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1234 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1236 if (DT.isProtected())
1237 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1238 dwarf::DW_ACCESS_protected);
1239 else if (DT.isPrivate())
1240 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1241 dwarf::DW_ACCESS_private);
1242 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1243 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1244 dwarf::DW_ACCESS_public);
1246 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1247 dwarf::DW_VIRTUALITY_virtual);
1251 /// createSubprogramDIE - Create new DIE using SP.
1252 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1253 CompileUnit *SPCU = getCompileUnit(SP);
1254 DIE *SPDie = SPCU->getDIE(SP);
1258 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1259 // Constructors and operators for anonymous aggregates do not have names.
1260 if (!SP.getName().empty())
1261 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1263 StringRef LinkageName = SP.getLinkageName();
1264 if (!LinkageName.empty())
1265 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1266 getRealLinkageName(LinkageName));
1268 addSourceLine(SPDie, &SP);
1270 // Add prototyped tag, if C or ObjC.
1271 unsigned Lang = SP.getCompileUnit().getLanguage();
1272 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1273 Lang == dwarf::DW_LANG_ObjC)
1274 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1277 DICompositeType SPTy = SP.getType();
1278 DIArray Args = SPTy.getTypeArray();
1279 unsigned SPTag = SPTy.getTag();
1281 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1282 addType(SPDie, SPTy);
1284 addType(SPDie, DIType(Args.getElement(0)));
1286 unsigned VK = SP.getVirtuality();
1288 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1289 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1290 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1291 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1292 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1293 ContainingTypeMap.insert(std::make_pair(SPDie,
1294 SP.getContainingType()));
1297 if (MakeDecl || !SP.isDefinition()) {
1298 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1300 // Add arguments. Do not add arguments for subprogram definition. They will
1301 // be handled while processing variables.
1302 DICompositeType SPTy = SP.getType();
1303 DIArray Args = SPTy.getTypeArray();
1304 unsigned SPTag = SPTy.getTag();
1306 if (SPTag == dwarf::DW_TAG_subroutine_type)
1307 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1308 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1309 DIType ATy = DIType(DIType(Args.getElement(i)));
1311 if (ATy.isArtificial())
1312 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1313 SPDie->addChild(Arg);
1317 if (SP.isArtificial())
1318 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1320 if (!SP.isLocalToUnit())
1321 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1323 if (SP.isOptimized())
1324 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1326 // DW_TAG_inlined_subroutine may refer to this DIE.
1327 SPCU->insertDIE(SP, SPDie);
1332 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1333 assert(N && "Invalid Scope encoding!");
1335 DbgScope *AScope = AbstractScopes.lookup(N);
1339 DbgScope *Parent = NULL;
1341 DIDescriptor Scope(N);
1342 if (Scope.isLexicalBlock()) {
1343 DILexicalBlock DB(N);
1344 DIDescriptor ParentDesc = DB.getContext();
1345 Parent = getOrCreateAbstractScope(ParentDesc);
1348 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1351 Parent->addScope(AScope);
1352 AScope->setAbstractScope();
1353 AbstractScopes[N] = AScope;
1354 if (DIDescriptor(N).isSubprogram())
1355 AbstractScopesList.push_back(AScope);
1359 /// isSubprogramContext - Return true if Context is either a subprogram
1360 /// or another context nested inside a subprogram.
1361 static bool isSubprogramContext(const MDNode *Context) {
1364 DIDescriptor D(Context);
1365 if (D.isSubprogram())
1368 return isSubprogramContext(DIType(Context).getContext());
1372 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1373 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1374 /// If there are global variables in this scope then create and insert
1375 /// DIEs for these variables.
1376 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1377 CompileUnit *SPCU = getCompileUnit(SPNode);
1378 DIE *SPDie = SPCU->getDIE(SPNode);
1379 assert(SPDie && "Unable to find subprogram DIE!");
1380 DISubprogram SP(SPNode);
1382 // There is not any need to generate specification DIE for a function
1383 // defined at compile unit level. If a function is defined inside another
1384 // function then gdb prefers the definition at top level and but does not
1385 // expect specification DIE in parent function. So avoid creating
1386 // specification DIE for a function defined inside a function.
1387 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1388 !SP.getContext().isFile() &&
1389 !isSubprogramContext(SP.getContext())) {
1390 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1393 DICompositeType SPTy = SP.getType();
1394 DIArray Args = SPTy.getTypeArray();
1395 unsigned SPTag = SPTy.getTag();
1396 if (SPTag == dwarf::DW_TAG_subroutine_type)
1397 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1398 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1399 DIType ATy = DIType(DIType(Args.getElement(i)));
1401 if (ATy.isArtificial())
1402 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1403 SPDie->addChild(Arg);
1405 DIE *SPDeclDie = SPDie;
1406 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1407 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1409 SPCU->addDie(SPDie);
1412 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1413 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1414 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1415 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1416 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1417 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1418 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1423 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1424 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1425 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1427 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1428 if (Scope->isAbstractScope())
1431 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1435 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1436 if (Ranges.size() > 1) {
1437 // .debug_range section has not been laid out yet. Emit offset in
1438 // .debug_range as a uint, size 4, for now. emitDIE will handle
1439 // DW_AT_ranges appropriately.
1440 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1441 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1442 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1443 RE = Ranges.end(); RI != RE; ++RI) {
1444 DebugRangeSymbols.push_back(LabelsBeforeInsn.lookup(RI->first));
1445 DebugRangeSymbols.push_back(LabelsAfterInsn.lookup(RI->second));
1447 DebugRangeSymbols.push_back(NULL);
1448 DebugRangeSymbols.push_back(NULL);
1452 MCSymbol *Start = LabelsBeforeInsn.lookup(RI->first);
1453 MCSymbol *End = LabelsAfterInsn.lookup(RI->second);
1455 if (Start == 0 || End == 0) return 0;
1457 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1458 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1460 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1461 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1466 /// constructInlinedScopeDIE - This scope represents inlined body of
1467 /// a function. Construct DIE to represent this concrete inlined copy
1468 /// of the function.
1469 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1471 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1472 assert (Ranges.empty() == false
1473 && "DbgScope does not have instruction markers!");
1475 // FIXME : .debug_inlined section specification does not clearly state how
1476 // to emit inlined scope that is split into multiple instruction ranges.
1477 // For now, use first instruction range and emit low_pc/high_pc pair and
1478 // corresponding .debug_inlined section entry for this pair.
1479 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1480 MCSymbol *StartLabel = LabelsBeforeInsn.lookup(RI->first);
1481 MCSymbol *EndLabel = LabelsAfterInsn.lookup(RI->second);
1483 if (StartLabel == 0 || EndLabel == 0) {
1484 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1487 assert(StartLabel->isDefined() &&
1488 "Invalid starting label for an inlined scope!");
1489 assert(EndLabel->isDefined() &&
1490 "Invalid end label for an inlined scope!");
1492 if (!Scope->getScopeNode())
1494 DIScope DS(Scope->getScopeNode());
1495 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1497 DISubprogram InlinedSP = getDISubprogram(DS);
1498 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1499 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1500 assert(OriginDIE && "Unable to find Origin DIE!");
1501 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1502 dwarf::DW_FORM_ref4, OriginDIE);
1504 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1505 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1507 InlinedSubprogramDIEs.insert(OriginDIE);
1509 // Track the start label for this inlined function.
1510 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1511 I = InlineInfo.find(InlinedSP);
1513 if (I == InlineInfo.end()) {
1514 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1516 InlinedSPNodes.push_back(InlinedSP);
1518 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1520 DILocation DL(Scope->getInlinedAt());
1521 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1522 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1528 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1529 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1530 // Get the descriptor.
1531 const DIVariable &VD = DV->getVariable();
1532 StringRef Name = VD.getName();
1536 // Translate tag to proper Dwarf tag. The result variable is dropped for
1539 switch (VD.getTag()) {
1540 case dwarf::DW_TAG_return_variable:
1542 case dwarf::DW_TAG_arg_variable:
1543 Tag = dwarf::DW_TAG_formal_parameter;
1545 case dwarf::DW_TAG_auto_variable: // fall thru
1547 Tag = dwarf::DW_TAG_variable;
1551 // Define variable debug information entry.
1552 DIE *VariableDie = new DIE(Tag);
1555 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1556 V2AVI = VarToAbstractVarMap.find(DV);
1557 if (V2AVI != VarToAbstractVarMap.end())
1558 AbsDIE = V2AVI->second->getDIE();
1561 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1562 dwarf::DW_FORM_ref4, AbsDIE);
1564 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1565 addSourceLine(VariableDie, &VD);
1567 // Add variable type.
1568 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1569 // addresses instead.
1570 if (VD.isBlockByrefVariable())
1571 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1573 addType(VariableDie, VD.getType());
1576 // Add variable address.
1577 if (!Scope->isAbstractScope()) {
1578 // Check if variable is described by DBG_VALUE instruction.
1579 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1580 DbgVariableToDbgInstMap.find(DV);
1581 if (DVI != DbgVariableToDbgInstMap.end()) {
1582 const MachineInstr *DVInsn = DVI->second;
1583 const MCSymbol *DVLabel = findVariableLabel(DV);
1584 bool updated = false;
1585 // FIXME : Handle getNumOperands != 3
1586 if (DVInsn->getNumOperands() == 3) {
1587 if (DVInsn->getOperand(0).isReg())
1588 updated = addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1589 else if (DVInsn->getOperand(0).isImm())
1590 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1591 else if (DVInsn->getOperand(0).isFPImm())
1592 updated = addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1594 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1595 if (Location.getReg()) {
1596 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1598 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1604 // If variableDie is not updated then DBG_VALUE instruction does not
1605 // have valid variable info.
1611 MachineLocation Location;
1613 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1615 if (findVariableFrameIndex(DV, &FI)) {
1616 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1617 Location.set(FrameReg, Offset);
1619 if (VD.hasComplexAddress())
1620 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1621 else if (VD.isBlockByrefVariable())
1622 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1624 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1629 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1630 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1631 DV->setDIE(VariableDie);
1636 void DwarfDebug::addPubTypes(DISubprogram SP) {
1637 DICompositeType SPTy = SP.getType();
1638 unsigned SPTag = SPTy.getTag();
1639 if (SPTag != dwarf::DW_TAG_subroutine_type)
1642 DIArray Args = SPTy.getTypeArray();
1643 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1644 DIType ATy(Args.getElement(i));
1647 DICompositeType CATy = getDICompositeType(ATy);
1648 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1649 && !CATy.isForwardDecl()) {
1650 CompileUnit *TheCU = getCompileUnit(CATy);
1651 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1652 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1657 /// constructScopeDIE - Construct a DIE for this scope.
1658 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1659 if (!Scope || !Scope->getScopeNode())
1662 DIScope DS(Scope->getScopeNode());
1663 DIE *ScopeDIE = NULL;
1664 if (Scope->getInlinedAt())
1665 ScopeDIE = constructInlinedScopeDIE(Scope);
1666 else if (DS.isSubprogram()) {
1667 if (Scope->isAbstractScope())
1668 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1670 ScopeDIE = updateSubprogramScopeDIE(DS);
1673 ScopeDIE = constructLexicalScopeDIE(Scope);
1674 if (!ScopeDIE) return NULL;
1676 // Add variables to scope.
1677 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1678 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1679 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1681 ScopeDIE->addChild(VariableDIE);
1684 // Add nested scopes.
1685 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1686 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1687 // Define the Scope debug information entry.
1688 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1690 ScopeDIE->addChild(NestedDIE);
1693 if (DS.isSubprogram())
1694 addPubTypes(DISubprogram(DS));
1699 /// GetOrCreateSourceID - Look up the source id with the given directory and
1700 /// source file names. If none currently exists, create a new id and insert it
1701 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1703 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1705 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1706 if (DI != DirectoryIdMap.end()) {
1707 DId = DI->getValue();
1709 DId = DirectoryNames.size() + 1;
1710 DirectoryIdMap[DirName] = DId;
1711 DirectoryNames.push_back(DirName);
1715 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1716 if (FI != SourceFileIdMap.end()) {
1717 FId = FI->getValue();
1719 FId = SourceFileNames.size() + 1;
1720 SourceFileIdMap[FileName] = FId;
1721 SourceFileNames.push_back(FileName);
1724 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1725 SourceIdMap.find(std::make_pair(DId, FId));
1726 if (SI != SourceIdMap.end())
1729 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1730 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1731 SourceIds.push_back(std::make_pair(DId, FId));
1736 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1737 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1738 CompileUnit *TheCU = getCompileUnit(NS);
1739 DIE *NDie = TheCU->getDIE(NS);
1742 NDie = new DIE(dwarf::DW_TAG_namespace);
1743 TheCU->insertDIE(NS, NDie);
1744 if (!NS.getName().empty())
1745 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1746 addSourceLine(NDie, &NS);
1747 addToContextOwner(NDie, NS.getContext());
1751 /// constructCompileUnit - Create new CompileUnit for the given
1752 /// metadata node with tag DW_TAG_compile_unit.
1753 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1754 DICompileUnit DIUnit(N);
1755 StringRef FN = DIUnit.getFilename();
1756 StringRef Dir = DIUnit.getDirectory();
1757 unsigned ID = GetOrCreateSourceID(Dir, FN);
1759 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1760 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1761 DIUnit.getProducer());
1762 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1763 DIUnit.getLanguage());
1764 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1765 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1766 // simplifies debug range entries.
1767 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_data4, 0);
1768 // DW_AT_stmt_list is a offset of line number information for this
1769 // compile unit in debug_line section. It is always zero when only one
1770 // compile unit is emitted in one object file.
1771 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1774 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1775 if (DIUnit.isOptimized())
1776 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1778 StringRef Flags = DIUnit.getFlags();
1780 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1782 unsigned RVer = DIUnit.getRunTimeVersion();
1784 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1785 dwarf::DW_FORM_data1, RVer);
1787 CompileUnit *NewCU = new CompileUnit(ID, Die);
1790 CUMap.insert(std::make_pair(N, NewCU));
1793 /// getCompielUnit - Get CompileUnit DIE.
1794 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1795 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1797 const MDNode *CUNode = NULL;
1798 if (D.isCompileUnit())
1800 else if (D.isSubprogram())
1801 CUNode = DISubprogram(N).getCompileUnit();
1802 else if (D.isType())
1803 CUNode = DIType(N).getCompileUnit();
1804 else if (D.isGlobalVariable())
1805 CUNode = DIGlobalVariable(N).getCompileUnit();
1806 else if (D.isVariable())
1807 CUNode = DIVariable(N).getCompileUnit();
1808 else if (D.isNameSpace())
1809 CUNode = DINameSpace(N).getCompileUnit();
1810 else if (D.isFile())
1811 CUNode = DIFile(N).getCompileUnit();
1815 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1816 = CUMap.find(CUNode);
1817 if (I == CUMap.end())
1823 /// constructGlobalVariableDIE - Construct global variable DIE.
1824 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1825 DIGlobalVariable DI_GV(N);
1827 // If debug information is malformed then ignore it.
1828 if (DI_GV.Verify() == false)
1831 // Check for pre-existence.
1832 CompileUnit *TheCU = getCompileUnit(N);
1833 if (TheCU->getDIE(DI_GV))
1836 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1841 TheCU->insertDIE(N, VariableDie);
1843 // Add to context owner.
1844 DIDescriptor GVContext = DI_GV.getContext();
1845 // Do not create specification DIE if context is either compile unit
1847 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1848 !GVContext.isFile() &&
1849 !isSubprogramContext(GVContext)) {
1850 // Create specification DIE.
1851 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1852 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1853 dwarf::DW_FORM_ref4, VariableDie);
1854 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1855 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1856 addLabel(Block, 0, dwarf::DW_FORM_udata,
1857 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1858 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1859 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1860 TheCU->addDie(VariableSpecDIE);
1862 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1863 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1864 addLabel(Block, 0, dwarf::DW_FORM_udata,
1865 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1866 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1868 addToContextOwner(VariableDie, GVContext);
1870 // Expose as global. FIXME - need to check external flag.
1871 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1873 DIType GTy = DI_GV.getType();
1874 if (GTy.isCompositeType() && !GTy.getName().empty()
1875 && !GTy.isForwardDecl()) {
1876 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1877 assert(Entry && "Missing global type!");
1878 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1883 /// construct SubprogramDIE - Construct subprogram DIE.
1884 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1887 // Check for pre-existence.
1888 CompileUnit *TheCU = getCompileUnit(N);
1889 if (TheCU->getDIE(N))
1892 if (!SP.isDefinition())
1893 // This is a method declaration which will be handled while constructing
1897 DIE *SubprogramDie = createSubprogramDIE(SP);
1900 TheCU->insertDIE(N, SubprogramDie);
1902 // Add to context owner.
1903 addToContextOwner(SubprogramDie, SP.getContext());
1905 // Expose as global.
1906 TheCU->addGlobal(SP.getName(), SubprogramDie);
1911 /// beginModule - Emit all Dwarf sections that should come prior to the
1912 /// content. Create global DIEs and emit initial debug info sections.
1913 /// This is inovked by the target AsmPrinter.
1914 void DwarfDebug::beginModule(Module *M) {
1915 if (DisableDebugInfoPrinting)
1918 DebugInfoFinder DbgFinder;
1919 DbgFinder.processModule(*M);
1921 bool HasDebugInfo = false;
1923 // Scan all the compile-units to see if there are any marked as the main unit.
1924 // if not, we do not generate debug info.
1925 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1926 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1927 if (DICompileUnit(*I).isMain()) {
1928 HasDebugInfo = true;
1933 if (!HasDebugInfo) return;
1935 // Tell MMI that we have debug info.
1936 MMI->setDebugInfoAvailability(true);
1938 // Emit initial sections.
1939 EmitSectionLabels();
1941 // Create all the compile unit DIEs.
1942 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1943 E = DbgFinder.compile_unit_end(); I != E; ++I)
1944 constructCompileUnit(*I);
1946 // Create DIEs for each subprogram.
1947 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1948 E = DbgFinder.subprogram_end(); I != E; ++I)
1949 constructSubprogramDIE(*I);
1951 // Create DIEs for each global variable.
1952 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1953 E = DbgFinder.global_variable_end(); I != E; ++I)
1954 constructGlobalVariableDIE(*I);
1956 // Prime section data.
1957 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1959 // Print out .file directives to specify files for .loc directives. These are
1960 // printed out early so that they precede any .loc directives.
1961 if (Asm->MAI->hasDotLocAndDotFile()) {
1962 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1963 // Remember source id starts at 1.
1964 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1965 // FIXME: don't use sys::path for this! This should not depend on the
1967 sys::Path FullPath(getSourceDirectoryName(Id.first));
1969 FullPath.appendComponent(getSourceFileName(Id.second));
1970 assert(AppendOk && "Could not append filename to directory!");
1972 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1977 /// endModule - Emit all Dwarf sections that should come after the content.
1979 void DwarfDebug::endModule() {
1980 if (!FirstCU) return;
1982 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1983 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1984 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1986 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1989 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1990 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1991 DIE *SPDie = CI->first;
1992 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1994 DIE *NDie = getCompileUnit(N)->getDIE(N);
1995 if (!NDie) continue;
1996 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1999 // Standard sections final addresses.
2000 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2001 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2002 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2003 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2005 // End text sections.
2006 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2007 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2008 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2011 // Emit common frame information.
2012 emitCommonDebugFrame();
2014 // Emit function debug frame information
2015 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2016 E = DebugFrames.end(); I != E; ++I)
2017 emitFunctionDebugFrame(*I);
2019 // Compute DIE offsets and sizes.
2020 computeSizeAndOffsets();
2022 // Emit all the DIEs into a debug info section
2025 // Corresponding abbreviations into a abbrev section.
2026 emitAbbreviations();
2028 // Emit source line correspondence into a debug line section.
2031 // Emit info into a debug pubnames section.
2032 emitDebugPubNames();
2034 // Emit info into a debug pubtypes section.
2035 emitDebugPubTypes();
2037 // Emit info into a debug loc section.
2040 // Emit info into a debug aranges section.
2043 // Emit info into a debug ranges section.
2046 // Emit info into a debug macinfo section.
2049 // Emit inline info.
2050 emitDebugInlineInfo();
2052 // Emit info into a debug str section.
2055 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2056 E = CUMap.end(); I != E; ++I)
2058 FirstCU = NULL; // Reset for the next Module, if any.
2061 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2062 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2063 DebugLoc ScopeLoc) {
2065 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2067 return AbsDbgVariable;
2069 LLVMContext &Ctx = Var->getContext();
2070 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2074 AbsDbgVariable = new DbgVariable(Var);
2075 Scope->addVariable(AbsDbgVariable);
2076 AbstractVariables[Var] = AbsDbgVariable;
2077 return AbsDbgVariable;
2080 /// collectVariableInfoFromMMITable - Collect variable information from
2081 /// side table maintained by MMI.
2083 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2084 SmallPtrSet<const MDNode *, 16> &Processed) {
2085 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2086 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2087 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2088 VE = VMap.end(); VI != VE; ++VI) {
2089 const MDNode *Var = VI->first;
2091 Processed.insert(Var);
2093 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2095 DbgScope *Scope = 0;
2096 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2097 Scope = ConcreteScopes.lookup(IA);
2099 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2101 // If variable scope is not found then skip this variable.
2105 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2106 DbgVariable *RegVar = new DbgVariable(DV);
2107 recordVariableFrameIndex(RegVar, VP.first);
2108 Scope->addVariable(RegVar);
2109 if (AbsDbgVariable) {
2110 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2111 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2116 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2117 void DwarfDebug::collectVariableInfo(const MachineFunction *MF) {
2118 SmallPtrSet<const MDNode *, 16> Processed;
2120 /// collection info from MMI table.
2121 collectVariableInfoFromMMITable(MF, Processed);
2123 SmallVector<const MachineInstr *, 8> DbgValues;
2124 // Collect variable information from DBG_VALUE machine instructions;
2125 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2127 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2129 const MachineInstr *MInsn = II;
2130 if (!MInsn->isDebugValue())
2133 // Ignore Undef values.
2134 if (MInsn->getOperand(0).isReg() && !MInsn->getOperand(0).getReg())
2137 DbgValues.push_back(MInsn);
2140 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2141 E = DbgValues.end(); I != E; ++I) {
2142 const MachineInstr *MInsn = *I;
2144 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2145 if (Processed.count(DV) != 0)
2148 DbgScope *Scope = findDbgScope(MInsn);
2149 if (!Scope && DV.getTag() == dwarf::DW_TAG_arg_variable)
2150 Scope = CurrentFnDbgScope;
2151 // If variable scope is not found then skip this variable.
2155 Processed.insert(DV);
2156 DbgVariable *RegVar = new DbgVariable(DV);
2157 DbgVariableToDbgInstMap[RegVar] = MInsn;
2158 Scope->addVariable(RegVar);
2159 if (DV.getTag() != dwarf::DW_TAG_arg_variable) {
2160 DbgValueStartMap[MInsn] = RegVar;
2161 DbgVariableLabelsMap[RegVar] = LabelsBeforeInsn.lookup(MInsn);
2163 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2164 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2165 VarToAbstractVarMap[RegVar] = AbsVar;
2169 // Collect info for variables that were optimized out.
2170 if (NamedMDNode *NMD =
2171 MF->getFunction()->getParent()->getNamedMetadata("llvm.dbg.lv")) {
2172 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2173 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2174 if (!DV || !Processed.insert(DV))
2176 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2178 Scope->addVariable(new DbgVariable(DV));
2184 /// beginScope - Process beginning of a scope.
2185 void DwarfDebug::beginScope(const MachineInstr *MI) {
2187 DebugLoc DL = MI->getDebugLoc();
2188 if (DL.isUnknown() && !UnknownLocations)
2191 bool LocalVar = false;
2192 if (MI->isDebugValue()) {
2193 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2194 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2195 if (!DV.Verify()) return;
2196 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2200 MCSymbol *Label = NULL;
2201 if (DL == PrevInstLoc)
2203 // Do not emit line number entry for arguments.
2204 else if (!MI->isDebugValue() || LocalVar) {
2205 const MDNode *Scope = 0;
2206 if (DL.isUnknown() == false) {
2207 Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2208 // FIXME: Should only verify each scope once!
2209 if (!DIScope(Scope).Verify())
2213 // This instruction has no debug location. If the preceding instruction
2214 // did, emit debug location information to indicate that the debug
2215 // location is now unknown.
2217 Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2222 // If this instruction begins a scope then note down corresponding label
2223 // even if previous label is reused.
2224 if (InsnsBeginScopeSet.count(MI) != 0)
2225 LabelsBeforeInsn[MI] = Label;
2228 /// endScope - Process end of a scope.
2229 void DwarfDebug::endScope(const MachineInstr *MI) {
2230 if (InsnsEndScopeSet.count(MI) != 0) {
2231 // Emit a label if this instruction ends a scope.
2232 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2233 Asm->OutStreamer.EmitLabel(Label);
2234 LabelsAfterInsn[MI] = Label;
2238 /// getOrCreateDbgScope - Create DbgScope for the scope.
2239 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2241 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2244 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2245 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2246 if (DIDescriptor(Scope).isLexicalBlock()) {
2248 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2249 WScope->setParent(Parent);
2250 Parent->addScope(WScope);
2253 if (!WScope->getParent()) {
2254 StringRef SPName = DISubprogram(Scope).getLinkageName();
2255 if (SPName == Asm->MF->getFunction()->getName())
2256 CurrentFnDbgScope = WScope;
2262 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2266 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2267 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2268 DILocation DL(InlinedAt);
2270 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2271 WScope->setParent(Parent);
2272 Parent->addScope(WScope);
2274 ConcreteScopes[InlinedAt] = WScope;
2275 getOrCreateAbstractScope(Scope);
2280 /// hasValidLocation - Return true if debug location entry attached with
2281 /// machine instruction encodes valid location info.
2282 static bool hasValidLocation(LLVMContext &Ctx,
2283 const MachineInstr *MInsn,
2284 const MDNode *&Scope, const MDNode *&InlinedAt) {
2285 if (MInsn->isDebugValue())
2287 DebugLoc DL = MInsn->getDebugLoc();
2288 if (DL.isUnknown()) return false;
2290 const MDNode *S = DL.getScope(Ctx);
2292 // There is no need to create another DIE for compile unit. For all
2293 // other scopes, create one DbgScope now. This will be translated
2294 // into a scope DIE at the end.
2295 if (DIScope(S).isCompileUnit()) return false;
2298 InlinedAt = DL.getInlinedAt(Ctx);
2302 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2304 static void calculateDominanceGraph(DbgScope *Scope) {
2305 assert (Scope && "Unable to calculate scop edominance graph!");
2306 SmallVector<DbgScope *, 4> WorkStack;
2307 WorkStack.push_back(Scope);
2308 unsigned Counter = 0;
2309 while (!WorkStack.empty()) {
2310 DbgScope *WS = WorkStack.back();
2311 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2312 bool visitedChildren = false;
2313 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2314 SE = Children.end(); SI != SE; ++SI) {
2315 DbgScope *ChildScope = *SI;
2316 if (!ChildScope->getDFSOut()) {
2317 WorkStack.push_back(ChildScope);
2318 visitedChildren = true;
2319 ChildScope->setDFSIn(++Counter);
2323 if (!visitedChildren) {
2324 WorkStack.pop_back();
2325 WS->setDFSOut(++Counter);
2330 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2332 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2333 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2336 unsigned PrevDFSIn = 0;
2337 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2339 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2341 const MachineInstr *MInsn = II;
2342 const MDNode *Scope = NULL;
2343 const MDNode *InlinedAt = NULL;
2345 // Check if instruction has valid location information.
2346 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2350 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2351 MI2ScopeMap.find(MInsn);
2352 if (DI != MI2ScopeMap.end()) {
2353 DbgScope *S = DI->second;
2354 dbgs() << S->getDFSIn();
2355 PrevDFSIn = S->getDFSIn();
2357 dbgs() << PrevDFSIn;
2359 dbgs() << " [ x" << PrevDFSIn;
2367 /// extractScopeInformation - Scan machine instructions in this function
2368 /// and collect DbgScopes. Return true, if at least one scope was found.
2369 bool DwarfDebug::extractScopeInformation() {
2370 // If scope information was extracted using .dbg intrinsics then there is not
2371 // any need to extract these information by scanning each instruction.
2372 if (!DbgScopeMap.empty())
2375 // Scan each instruction and create scopes. First build working set of scopes.
2376 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2377 SmallVector<DbgRange, 4> MIRanges;
2378 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2379 const MDNode *PrevScope = NULL;
2380 const MDNode *PrevInlinedAt = NULL;
2381 const MachineInstr *RangeBeginMI = NULL;
2382 const MachineInstr *PrevMI = NULL;
2383 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2385 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2387 const MachineInstr *MInsn = II;
2388 const MDNode *Scope = NULL;
2389 const MDNode *InlinedAt = NULL;
2391 // Check if instruction has valid location information.
2392 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2397 // If scope has not changed then skip this instruction.
2398 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2404 // If we have alread seen a beginning of a instruction range and
2405 // current instruction scope does not match scope of first instruction
2406 // in this range then create a new instruction range.
2407 DbgRange R(RangeBeginMI, PrevMI);
2408 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2409 MIRanges.push_back(R);
2412 // This is a beginning of a new instruction range.
2413 RangeBeginMI = MInsn;
2415 // Reset previous markers.
2418 PrevInlinedAt = InlinedAt;
2422 // Create last instruction range.
2423 if (RangeBeginMI && PrevMI && PrevScope) {
2424 DbgRange R(RangeBeginMI, PrevMI);
2425 MIRanges.push_back(R);
2426 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2429 if (!CurrentFnDbgScope)
2432 calculateDominanceGraph(CurrentFnDbgScope);
2434 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2436 // Find ranges of instructions covered by each DbgScope;
2437 DbgScope *PrevDbgScope = NULL;
2438 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2439 RE = MIRanges.end(); RI != RE; ++RI) {
2440 const DbgRange &R = *RI;
2441 DbgScope *S = MI2ScopeMap.lookup(R.first);
2442 assert (S && "Lost DbgScope for a machine instruction!");
2443 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2444 PrevDbgScope->closeInsnRange(S);
2445 S->openInsnRange(R.first);
2446 S->extendInsnRange(R.second);
2451 PrevDbgScope->closeInsnRange();
2453 identifyScopeMarkers();
2455 return !DbgScopeMap.empty();
2458 /// identifyScopeMarkers() -
2459 /// Each DbgScope has first instruction and last instruction to mark beginning
2460 /// and end of a scope respectively. Create an inverse map that list scopes
2461 /// starts (and ends) with an instruction. One instruction may start (or end)
2462 /// multiple scopes. Ignore scopes that are not reachable.
2463 void DwarfDebug::identifyScopeMarkers() {
2464 SmallVector<DbgScope *, 4> WorkList;
2465 WorkList.push_back(CurrentFnDbgScope);
2466 while (!WorkList.empty()) {
2467 DbgScope *S = WorkList.pop_back_val();
2469 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2470 if (!Children.empty())
2471 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2472 SE = Children.end(); SI != SE; ++SI)
2473 WorkList.push_back(*SI);
2475 if (S->isAbstractScope())
2478 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2481 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2482 RE = Ranges.end(); RI != RE; ++RI) {
2483 assert(RI->first && "DbgRange does not have first instruction!");
2484 assert(RI->second && "DbgRange does not have second instruction!");
2485 InsnsBeginScopeSet.insert(RI->first);
2486 InsnsEndScopeSet.insert(RI->second);
2491 /// FindFirstDebugLoc - Find the first debug location in the function. This
2492 /// is intended to be an approximation for the source position of the
2493 /// beginning of the function.
2494 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2495 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2497 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2498 MBBI != MBBE; ++MBBI) {
2499 DebugLoc DL = MBBI->getDebugLoc();
2500 if (!DL.isUnknown())
2506 /// beginFunction - Gather pre-function debug information. Assumes being
2507 /// emitted immediately after the function entry point.
2508 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2509 if (!MMI->hasDebugInfo()) return;
2510 if (!extractScopeInformation()) return;
2512 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2513 Asm->getFunctionNumber());
2514 // Assumes in correct section after the entry point.
2515 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2517 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2519 DebugLoc FDL = FindFirstDebugLoc(MF);
2520 if (FDL.isUnknown()) return;
2522 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2524 DISubprogram SP = getDISubprogram(Scope);
2527 Line = SP.getLineNumber();
2530 Line = FDL.getLine();
2534 recordSourceLine(Line, Col, Scope);
2537 /// endFunction - Gather and emit post-function debug information.
2539 void DwarfDebug::endFunction(const MachineFunction *MF) {
2540 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2542 if (CurrentFnDbgScope) {
2544 collectVariableInfo(MF);
2546 // Define end label for subprogram.
2547 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2548 Asm->getFunctionNumber()));
2550 // Get function line info.
2551 if (!Lines.empty()) {
2552 // Get section line info.
2553 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2554 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2555 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2556 // Append the function info to section info.
2557 SectionLineInfos.insert(SectionLineInfos.end(),
2558 Lines.begin(), Lines.end());
2561 // Construct abstract scopes.
2562 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2563 AE = AbstractScopesList.end(); AI != AE; ++AI)
2564 constructScopeDIE(*AI);
2566 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2568 if (!DisableFramePointerElim(*MF))
2569 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2570 dwarf::DW_FORM_flag, 1);
2573 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2574 MMI->getFrameMoves()));
2578 CurrentFnDbgScope = NULL;
2579 DbgVariableToFrameIndexMap.clear();
2580 VarToAbstractVarMap.clear();
2581 DbgVariableToDbgInstMap.clear();
2582 DbgVariableLabelsMap.clear();
2583 DeleteContainerSeconds(DbgScopeMap);
2584 InsnsBeginScopeSet.clear();
2585 InsnsEndScopeSet.clear();
2586 DbgValueStartMap.clear();
2587 ConcreteScopes.clear();
2588 DeleteContainerSeconds(AbstractScopes);
2589 AbstractScopesList.clear();
2590 AbstractVariables.clear();
2591 LabelsBeforeInsn.clear();
2592 LabelsAfterInsn.clear();
2597 /// recordVariableFrameIndex - Record a variable's index.
2598 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2599 assert (V && "Invalid DbgVariable!");
2600 DbgVariableToFrameIndexMap[V] = Index;
2603 /// findVariableFrameIndex - Return true if frame index for the variable
2604 /// is found. Update FI to hold value of the index.
2605 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2606 assert (V && "Invalid DbgVariable!");
2607 DenseMap<const DbgVariable *, int>::iterator I =
2608 DbgVariableToFrameIndexMap.find(V);
2609 if (I == DbgVariableToFrameIndexMap.end())
2615 /// findVariableLabel - Find MCSymbol for the variable.
2616 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2617 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2618 = DbgVariableLabelsMap.find(V);
2619 if (I == DbgVariableLabelsMap.end())
2621 else return I->second;
2624 /// findDbgScope - Find DbgScope for the debug loc attached with an
2626 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2627 DbgScope *Scope = NULL;
2629 MInsn->getParent()->getParent()->getFunction()->getContext();
2630 DebugLoc DL = MInsn->getDebugLoc();
2635 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2636 Scope = ConcreteScopes.lookup(IA);
2638 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2644 /// recordSourceLine - Register a source line with debug info. Returns the
2645 /// unique label that was emitted and which provides correspondence to
2646 /// the source line list.
2647 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2653 DIDescriptor Scope(S);
2655 if (Scope.isCompileUnit()) {
2656 DICompileUnit CU(S);
2657 Dir = CU.getDirectory();
2658 Fn = CU.getFilename();
2659 } else if (Scope.isSubprogram()) {
2661 Dir = SP.getDirectory();
2662 Fn = SP.getFilename();
2663 } else if (Scope.isLexicalBlock()) {
2664 DILexicalBlock DB(S);
2665 Dir = DB.getDirectory();
2666 Fn = DB.getFilename();
2668 assert(0 && "Unexpected scope info");
2670 Src = GetOrCreateSourceID(Dir, Fn);
2673 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2674 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2676 Asm->OutStreamer.EmitLabel(Label);
2680 //===----------------------------------------------------------------------===//
2682 //===----------------------------------------------------------------------===//
2684 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2687 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2688 // Get the children.
2689 const std::vector<DIE *> &Children = Die->getChildren();
2691 // If not last sibling and has children then add sibling offset attribute.
2692 if (!Last && !Children.empty())
2693 Die->addSiblingOffset(DIEValueAllocator);
2695 // Record the abbreviation.
2696 assignAbbrevNumber(Die->getAbbrev());
2698 // Get the abbreviation for this DIE.
2699 unsigned AbbrevNumber = Die->getAbbrevNumber();
2700 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2703 Die->setOffset(Offset);
2705 // Start the size with the size of abbreviation code.
2706 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2708 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2709 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2711 // Size the DIE attribute values.
2712 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2713 // Size attribute value.
2714 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2716 // Size the DIE children if any.
2717 if (!Children.empty()) {
2718 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2719 "Children flag not set");
2721 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2722 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2724 // End of children marker.
2725 Offset += sizeof(int8_t);
2728 Die->setSize(Offset - Die->getOffset());
2732 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2734 void DwarfDebug::computeSizeAndOffsets() {
2735 unsigned PrevOffset = 0;
2736 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2737 E = CUMap.end(); I != E; ++I) {
2738 // Compute size of compile unit header.
2739 static unsigned Offset = PrevOffset +
2740 sizeof(int32_t) + // Length of Compilation Unit Info
2741 sizeof(int16_t) + // DWARF version number
2742 sizeof(int32_t) + // Offset Into Abbrev. Section
2743 sizeof(int8_t); // Pointer Size (in bytes)
2744 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2745 PrevOffset = Offset;
2749 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2750 /// temporary label to it if SymbolStem is specified.
2751 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2752 const char *SymbolStem = 0) {
2753 Asm->OutStreamer.SwitchSection(Section);
2754 if (!SymbolStem) return 0;
2756 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2757 Asm->OutStreamer.EmitLabel(TmpSym);
2761 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2762 /// the start of each one.
2763 void DwarfDebug::EmitSectionLabels() {
2764 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2766 // Dwarf sections base addresses.
2767 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2768 DwarfFrameSectionSym =
2769 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2772 DwarfInfoSectionSym =
2773 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2774 DwarfAbbrevSectionSym =
2775 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2776 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2778 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2779 EmitSectionSym(Asm, MacroInfo);
2781 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2782 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2783 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2784 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2785 DwarfStrSectionSym =
2786 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2787 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2790 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2791 EmitSectionSym(Asm, TLOF.getDataSection());
2794 /// emitDIE - Recusively Emits a debug information entry.
2796 void DwarfDebug::emitDIE(DIE *Die) {
2797 // Get the abbreviation for this DIE.
2798 unsigned AbbrevNumber = Die->getAbbrevNumber();
2799 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2801 // Emit the code (index) for the abbreviation.
2802 if (Asm->isVerbose())
2803 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2804 Twine::utohexstr(Die->getOffset()) + ":0x" +
2805 Twine::utohexstr(Die->getSize()) + " " +
2806 dwarf::TagString(Abbrev->getTag()));
2807 Asm->EmitULEB128(AbbrevNumber);
2809 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2810 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2812 // Emit the DIE attribute values.
2813 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2814 unsigned Attr = AbbrevData[i].getAttribute();
2815 unsigned Form = AbbrevData[i].getForm();
2816 assert(Form && "Too many attributes for DIE (check abbreviation)");
2818 if (Asm->isVerbose())
2819 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2822 case dwarf::DW_AT_sibling:
2823 Asm->EmitInt32(Die->getSiblingOffset());
2825 case dwarf::DW_AT_abstract_origin: {
2826 DIEEntry *E = cast<DIEEntry>(Values[i]);
2827 DIE *Origin = E->getEntry();
2828 unsigned Addr = Origin->getOffset();
2829 Asm->EmitInt32(Addr);
2832 case dwarf::DW_AT_ranges: {
2833 // DW_AT_range Value encodes offset in debug_range section.
2834 DIEInteger *V = cast<DIEInteger>(Values[i]);
2835 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2837 DwarfDebugRangeSectionSym,
2842 // Emit an attribute using the defined form.
2843 Values[i]->EmitValue(Asm, Form);
2848 // Emit the DIE children if any.
2849 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2850 const std::vector<DIE *> &Children = Die->getChildren();
2852 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2853 emitDIE(Children[j]);
2855 if (Asm->isVerbose())
2856 Asm->OutStreamer.AddComment("End Of Children Mark");
2861 /// emitDebugInfo - Emit the debug info section.
2863 void DwarfDebug::emitDebugInfo() {
2864 // Start debug info section.
2865 Asm->OutStreamer.SwitchSection(
2866 Asm->getObjFileLowering().getDwarfInfoSection());
2867 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2868 E = CUMap.end(); I != E; ++I) {
2869 CompileUnit *TheCU = I->second;
2870 DIE *Die = TheCU->getCUDie();
2872 // Emit the compile units header.
2873 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2876 // Emit size of content not including length itself
2877 unsigned ContentSize = Die->getSize() +
2878 sizeof(int16_t) + // DWARF version number
2879 sizeof(int32_t) + // Offset Into Abbrev. Section
2880 sizeof(int8_t) + // Pointer Size (in bytes)
2881 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2883 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2884 Asm->EmitInt32(ContentSize);
2885 Asm->OutStreamer.AddComment("DWARF version number");
2886 Asm->EmitInt16(dwarf::DWARF_VERSION);
2887 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2888 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2889 DwarfAbbrevSectionSym);
2890 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2891 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2894 // FIXME - extra padding for gdb bug.
2895 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2900 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2904 /// emitAbbreviations - Emit the abbreviation section.
2906 void DwarfDebug::emitAbbreviations() const {
2907 // Check to see if it is worth the effort.
2908 if (!Abbreviations.empty()) {
2909 // Start the debug abbrev section.
2910 Asm->OutStreamer.SwitchSection(
2911 Asm->getObjFileLowering().getDwarfAbbrevSection());
2913 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2915 // For each abbrevation.
2916 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2917 // Get abbreviation data
2918 const DIEAbbrev *Abbrev = Abbreviations[i];
2920 // Emit the abbrevations code (base 1 index.)
2921 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2923 // Emit the abbreviations data.
2927 // Mark end of abbreviations.
2928 Asm->EmitULEB128(0, "EOM(3)");
2930 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2934 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2935 /// the line matrix.
2937 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2938 // Define last address of section.
2939 Asm->OutStreamer.AddComment("Extended Op");
2942 Asm->OutStreamer.AddComment("Op size");
2943 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2944 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2945 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2947 Asm->OutStreamer.AddComment("Section end label");
2949 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2950 Asm->getTargetData().getPointerSize(),
2953 // Mark end of matrix.
2954 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2960 /// emitDebugLines - Emit source line information.
2962 void DwarfDebug::emitDebugLines() {
2963 // If the target is using .loc/.file, the assembler will be emitting the
2964 // .debug_line table automatically.
2965 if (Asm->MAI->hasDotLocAndDotFile())
2968 // Minimum line delta, thus ranging from -10..(255-10).
2969 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2970 // Maximum line delta, thus ranging from -10..(255-10).
2971 const int MaxLineDelta = 255 + MinLineDelta;
2973 // Start the dwarf line section.
2974 Asm->OutStreamer.SwitchSection(
2975 Asm->getObjFileLowering().getDwarfLineSection());
2977 // Construct the section header.
2978 Asm->OutStreamer.AddComment("Length of Source Line Info");
2979 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2980 Asm->GetTempSymbol("line_begin"), 4);
2981 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2983 Asm->OutStreamer.AddComment("DWARF version number");
2984 Asm->EmitInt16(dwarf::DWARF_VERSION);
2986 Asm->OutStreamer.AddComment("Prolog Length");
2987 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2988 Asm->GetTempSymbol("line_prolog_begin"), 4);
2989 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2991 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2993 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2995 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2996 Asm->EmitInt8(MinLineDelta);
2997 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2998 Asm->EmitInt8(MaxLineDelta);
2999 Asm->OutStreamer.AddComment("Special Opcode Base");
3000 Asm->EmitInt8(-MinLineDelta);
3002 // Line number standard opcode encodings argument count
3003 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3005 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3007 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3009 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3011 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3013 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3015 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3017 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3019 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3022 // Emit directories.
3023 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3024 const std::string &Dir = getSourceDirectoryName(DI);
3025 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3026 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3029 Asm->OutStreamer.AddComment("End of directories");
3033 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3034 // Remember source id starts at 1.
3035 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3036 const std::string &FN = getSourceFileName(Id.second);
3037 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3038 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3040 Asm->EmitULEB128(Id.first, "Directory #");
3041 Asm->EmitULEB128(0, "Mod date");
3042 Asm->EmitULEB128(0, "File size");
3045 Asm->OutStreamer.AddComment("End of files");
3048 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3050 // A sequence for each text section.
3051 unsigned SecSrcLinesSize = SectionSourceLines.size();
3053 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3054 // Isolate current sections line info.
3055 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3057 // Dwarf assumes we start with first line of first source file.
3058 unsigned Source = 1;
3061 // Construct rows of the address, source, line, column matrix.
3062 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3063 const SrcLineInfo &LineInfo = LineInfos[i];
3064 MCSymbol *Label = LineInfo.getLabel();
3065 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3067 if (Asm->isVerbose()) {
3068 std::pair<unsigned, unsigned> SrcID =
3069 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3070 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3072 Twine(getSourceFileName(SrcID.second)) +
3073 ":" + Twine(LineInfo.getLine()));
3076 // Define the line address.
3077 Asm->OutStreamer.AddComment("Extended Op");
3079 Asm->OutStreamer.AddComment("Op size");
3080 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3082 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3083 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3085 Asm->OutStreamer.AddComment("Location label");
3086 Asm->OutStreamer.EmitSymbolValue(Label,
3087 Asm->getTargetData().getPointerSize(),
3090 // If change of source, then switch to the new source.
3091 if (Source != LineInfo.getSourceID()) {
3092 Source = LineInfo.getSourceID();
3093 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3094 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3095 Asm->EmitULEB128(Source, "New Source");
3098 // If change of line.
3099 if (Line != LineInfo.getLine()) {
3100 // Determine offset.
3101 int Offset = LineInfo.getLine() - Line;
3102 int Delta = Offset - MinLineDelta;
3105 Line = LineInfo.getLine();
3107 // If delta is small enough and in range...
3108 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3109 // ... then use fast opcode.
3110 Asm->OutStreamer.AddComment("Line Delta");
3111 Asm->EmitInt8(Delta - MinLineDelta);
3113 // ... otherwise use long hand.
3114 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3115 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3116 Asm->EmitSLEB128(Offset, "Line Offset");
3117 Asm->OutStreamer.AddComment("DW_LNS_copy");
3118 Asm->EmitInt8(dwarf::DW_LNS_copy);
3121 // Copy the previous row (different address or source)
3122 Asm->OutStreamer.AddComment("DW_LNS_copy");
3123 Asm->EmitInt8(dwarf::DW_LNS_copy);
3127 emitEndOfLineMatrix(j + 1);
3130 if (SecSrcLinesSize == 0)
3131 // Because we're emitting a debug_line section, we still need a line
3132 // table. The linker and friends expect it to exist. If there's nothing to
3133 // put into it, emit an empty table.
3134 emitEndOfLineMatrix(1);
3136 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3139 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3141 void DwarfDebug::emitCommonDebugFrame() {
3142 if (!Asm->MAI->doesDwarfRequireFrameSection())
3145 int stackGrowth = Asm->getTargetData().getPointerSize();
3146 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3147 TargetFrameInfo::StackGrowsDown)
3150 // Start the dwarf frame section.
3151 Asm->OutStreamer.SwitchSection(
3152 Asm->getObjFileLowering().getDwarfFrameSection());
3154 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3155 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3156 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3157 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3159 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3160 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3161 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3162 Asm->OutStreamer.AddComment("CIE Version");
3163 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3164 Asm->OutStreamer.AddComment("CIE Augmentation");
3165 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3166 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3167 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3168 Asm->OutStreamer.AddComment("CIE RA Column");
3169 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3170 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3172 std::vector<MachineMove> Moves;
3173 RI->getInitialFrameState(Moves);
3175 Asm->EmitFrameMoves(Moves, 0, false);
3177 Asm->EmitAlignment(2);
3178 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3181 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3184 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3185 if (!Asm->MAI->doesDwarfRequireFrameSection())
3188 // Start the dwarf frame section.
3189 Asm->OutStreamer.SwitchSection(
3190 Asm->getObjFileLowering().getDwarfFrameSection());
3192 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3193 MCSymbol *DebugFrameBegin =
3194 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3195 MCSymbol *DebugFrameEnd =
3196 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3197 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3199 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3201 Asm->OutStreamer.AddComment("FDE CIE offset");
3202 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3203 DwarfFrameSectionSym);
3205 Asm->OutStreamer.AddComment("FDE initial location");
3206 MCSymbol *FuncBeginSym =
3207 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3208 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3209 Asm->getTargetData().getPointerSize(),
3213 Asm->OutStreamer.AddComment("FDE address range");
3214 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3215 FuncBeginSym, Asm->getTargetData().getPointerSize());
3217 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3219 Asm->EmitAlignment(2);
3220 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3223 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3225 void DwarfDebug::emitDebugPubNames() {
3226 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3227 E = CUMap.end(); I != E; ++I) {
3228 CompileUnit *TheCU = I->second;
3229 // Start the dwarf pubnames section.
3230 Asm->OutStreamer.SwitchSection(
3231 Asm->getObjFileLowering().getDwarfPubNamesSection());
3233 Asm->OutStreamer.AddComment("Length of Public Names Info");
3234 Asm->EmitLabelDifference(
3235 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3236 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3238 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3241 Asm->OutStreamer.AddComment("DWARF Version");
3242 Asm->EmitInt16(dwarf::DWARF_VERSION);
3244 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3245 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3246 DwarfInfoSectionSym);
3248 Asm->OutStreamer.AddComment("Compilation Unit Length");
3249 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3250 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3253 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3254 for (StringMap<DIE*>::const_iterator
3255 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3256 const char *Name = GI->getKeyData();
3257 DIE *Entity = GI->second;
3259 Asm->OutStreamer.AddComment("DIE offset");
3260 Asm->EmitInt32(Entity->getOffset());
3262 if (Asm->isVerbose())
3263 Asm->OutStreamer.AddComment("External Name");
3264 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3267 Asm->OutStreamer.AddComment("End Mark");
3269 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3274 void DwarfDebug::emitDebugPubTypes() {
3275 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3276 E = CUMap.end(); I != E; ++I) {
3277 CompileUnit *TheCU = I->second;
3278 // Start the dwarf pubnames section.
3279 Asm->OutStreamer.SwitchSection(
3280 Asm->getObjFileLowering().getDwarfPubTypesSection());
3281 Asm->OutStreamer.AddComment("Length of Public Types Info");
3282 Asm->EmitLabelDifference(
3283 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3284 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3286 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3289 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3290 Asm->EmitInt16(dwarf::DWARF_VERSION);
3292 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3293 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3294 DwarfInfoSectionSym);
3296 Asm->OutStreamer.AddComment("Compilation Unit Length");
3297 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3298 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3301 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3302 for (StringMap<DIE*>::const_iterator
3303 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3304 const char *Name = GI->getKeyData();
3305 DIE * Entity = GI->second;
3307 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3308 Asm->EmitInt32(Entity->getOffset());
3310 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3311 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3314 Asm->OutStreamer.AddComment("End Mark");
3316 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3321 /// emitDebugStr - Emit visible names into a debug str section.
3323 void DwarfDebug::emitDebugStr() {
3324 // Check to see if it is worth the effort.
3325 if (StringPool.empty()) return;
3327 // Start the dwarf str section.
3328 Asm->OutStreamer.SwitchSection(
3329 Asm->getObjFileLowering().getDwarfStrSection());
3331 // Get all of the string pool entries and put them in an array by their ID so
3332 // we can sort them.
3333 SmallVector<std::pair<unsigned,
3334 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3336 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3337 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3338 Entries.push_back(std::make_pair(I->second.second, &*I));
3340 array_pod_sort(Entries.begin(), Entries.end());
3342 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3343 // Emit a label for reference from debug information entries.
3344 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3346 // Emit the string itself.
3347 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3351 /// emitDebugLoc - Emit visible names into a debug loc section.
3353 void DwarfDebug::emitDebugLoc() {
3354 // Start the dwarf loc section.
3355 Asm->OutStreamer.SwitchSection(
3356 Asm->getObjFileLowering().getDwarfLocSection());
3359 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3361 void DwarfDebug::EmitDebugARanges() {
3362 // Start the dwarf aranges section.
3363 Asm->OutStreamer.SwitchSection(
3364 Asm->getObjFileLowering().getDwarfARangesSection());
3367 /// emitDebugRanges - Emit visible names into a debug ranges section.
3369 void DwarfDebug::emitDebugRanges() {
3370 // Start the dwarf ranges section.
3371 Asm->OutStreamer.SwitchSection(
3372 Asm->getObjFileLowering().getDwarfRangesSection());
3373 unsigned char Size = Asm->getTargetData().getPointerSize();
3374 for (SmallVector<const MCSymbol *, 8>::iterator
3375 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3378 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3380 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3384 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3386 void DwarfDebug::emitDebugMacInfo() {
3387 if (const MCSection *LineInfo =
3388 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3389 // Start the dwarf macinfo section.
3390 Asm->OutStreamer.SwitchSection(LineInfo);
3394 /// emitDebugInlineInfo - Emit inline info using following format.
3396 /// 1. length of section
3397 /// 2. Dwarf version number
3398 /// 3. address size.
3400 /// Entries (one "entry" for each function that was inlined):
3402 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3403 /// otherwise offset into __debug_str for regular function name.
3404 /// 2. offset into __debug_str section for regular function name.
3405 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3406 /// instances for the function.
3408 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3409 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3410 /// __debug_info section, and the low_pc is the starting address for the
3411 /// inlining instance.
3412 void DwarfDebug::emitDebugInlineInfo() {
3413 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3419 Asm->OutStreamer.SwitchSection(
3420 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3422 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3423 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3424 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3426 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3428 Asm->OutStreamer.AddComment("Dwarf Version");
3429 Asm->EmitInt16(dwarf::DWARF_VERSION);
3430 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3431 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3433 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3434 E = InlinedSPNodes.end(); I != E; ++I) {
3436 const MDNode *Node = *I;
3437 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3438 = InlineInfo.find(Node);
3439 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3440 DISubprogram SP(Node);
3441 StringRef LName = SP.getLinkageName();
3442 StringRef Name = SP.getName();
3444 Asm->OutStreamer.AddComment("MIPS linkage name");
3445 if (LName.empty()) {
3446 Asm->OutStreamer.EmitBytes(Name, 0);
3447 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3449 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3450 DwarfStrSectionSym);
3452 Asm->OutStreamer.AddComment("Function name");
3453 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3454 Asm->EmitULEB128(Labels.size(), "Inline count");
3456 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3457 LE = Labels.end(); LI != LE; ++LI) {
3458 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3459 Asm->EmitInt32(LI->second->getOffset());
3461 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3462 Asm->OutStreamer.EmitSymbolValue(LI->first,
3463 Asm->getTargetData().getPointerSize(),0);
3467 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));