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",
49 cl::desc("Disable debug info printing"));
51 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58 } // end anonymous namespace
60 //===----------------------------------------------------------------------===//
62 /// Configuration values for initial hash set sizes (log2).
64 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
68 //===----------------------------------------------------------------------===//
69 /// CompileUnit - This dwarf writer support class manages information associate
70 /// with a source file.
72 /// ID - File identifier for source.
76 /// Die - Compile unit debug information entry.
78 const OwningPtr<DIE> CUDie;
80 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
83 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
84 /// variables to debug information entries.
85 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
87 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
89 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
91 /// Globals - A map of globally visible named entities for this unit.
93 StringMap<DIE*> Globals;
95 /// GlobalTypes - A map of globally visible types for this unit.
97 StringMap<DIE*> GlobalTypes;
100 CompileUnit(unsigned I, DIE *D)
101 : ID(I), CUDie(D), IndexTyDie(0) {}
104 unsigned getID() const { return ID; }
105 DIE* getCUDie() const { return CUDie.get(); }
106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
109 /// hasContent - Return true if this compile unit has something to write out.
111 bool hasContent() const { return !CUDie->getChildren().empty(); }
113 /// addGlobal - Add a new global entity to the compile unit.
115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
117 /// addGlobalType - Add a new global type to the compile unit.
119 void addGlobalType(StringRef Name, DIE *Die) {
120 GlobalTypes[Name] = Die;
123 /// getDIE - Returns the debug information entry map slot for the
124 /// specified debug variable.
125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
127 /// insertDIE - Insert DIE into the map.
128 void insertDIE(const MDNode *N, DIE *D) {
129 MDNodeToDieMap.insert(std::make_pair(N, D));
132 /// getDIEEntry - Returns the debug information entry for the speciefied
134 DIEEntry *getDIEEntry(const MDNode *N) {
135 DenseMap<const MDNode *, DIEEntry *>::iterator I =
136 MDNodeToDIEEntryMap.find(N);
137 if (I == MDNodeToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 DIE *TheDIE; // Variable DIE.
172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
174 // AbsVar may be NULL.
175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
178 DIVariable getVariable() const { return Var; }
179 void setDIE(DIE *D) { TheDIE = D; }
180 DIE *getDIE() const { return TheDIE; }
181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
185 //===----------------------------------------------------------------------===//
186 /// DbgRange - This is used to track range of instructions with identical
187 /// debug info scope.
189 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
191 //===----------------------------------------------------------------------===//
192 /// DbgScope - This class is used to track scope information.
195 DbgScope *Parent; // Parent to this scope.
196 DIDescriptor Desc; // Debug info descriptor for scope.
197 // Location at which this scope is inlined.
198 AssertingVH<const MDNode> InlinedAtLocation;
199 bool AbstractScope; // Abstract Scope
200 const MachineInstr *LastInsn; // Last instruction of this scope.
201 const MachineInstr *FirstInsn; // First instruction of this scope.
202 unsigned DFSIn, DFSOut;
203 // Scopes defined in scope. Contents not owned.
204 SmallVector<DbgScope *, 4> Scopes;
205 // Variables declared in scope. Contents owned.
206 SmallVector<DbgVariable *, 8> Variables;
207 SmallVector<DbgRange, 4> Ranges;
208 // Private state for dump()
209 mutable unsigned IndentLevel;
211 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
212 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
213 LastInsn(0), FirstInsn(0),
214 DFSIn(0), DFSOut(0), IndentLevel(0) {}
218 DbgScope *getParent() const { return Parent; }
219 void setParent(DbgScope *P) { Parent = P; }
220 DIDescriptor getDesc() const { return Desc; }
221 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
222 const MDNode *getScopeNode() const { return Desc; }
223 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
224 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
225 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
227 /// openInsnRange - This scope covers instruction range starting from MI.
228 void openInsnRange(const MachineInstr *MI) {
233 Parent->openInsnRange(MI);
236 /// extendInsnRange - Extend the current instruction range covered by
238 void extendInsnRange(const MachineInstr *MI) {
239 assert (FirstInsn && "MI Range is not open!");
242 Parent->extendInsnRange(MI);
245 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
246 /// until now. This is used when a new scope is encountered while walking
247 /// machine instructions.
248 void closeInsnRange(DbgScope *NewScope = NULL) {
249 assert (LastInsn && "Last insn missing!");
250 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
253 // If Parent dominates NewScope then do not close Parent's instruction
255 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
256 Parent->closeInsnRange(NewScope);
259 void setAbstractScope() { AbstractScope = true; }
260 bool isAbstractScope() const { return AbstractScope; }
262 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
263 unsigned getDFSOut() const { return DFSOut; }
264 void setDFSOut(unsigned O) { DFSOut = O; }
265 unsigned getDFSIn() const { return DFSIn; }
266 void setDFSIn(unsigned I) { DFSIn = I; }
267 bool dominates(const DbgScope *S) {
270 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
275 /// addScope - Add a scope to the scope.
277 void addScope(DbgScope *S) { Scopes.push_back(S); }
279 /// addVariable - Add a variable to the scope.
281 void addVariable(DbgVariable *V) { Variables.push_back(V); }
288 } // end llvm namespace
291 void DbgScope::dump() const {
292 raw_ostream &err = dbgs();
293 err.indent(IndentLevel);
294 const MDNode *N = Desc;
297 err << "Abstract Scope\n";
301 err << "Children ...\n";
302 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
303 if (Scopes[i] != this)
310 DbgScope::~DbgScope() {
311 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
315 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
316 : Asm(A), MMI(Asm->MMI), FirstCU(0),
317 AbbreviationsSet(InitAbbreviationsSetSize),
318 CurrentFnDbgScope(0), PrevLabel(NULL) {
319 NextStringPoolNumber = 0;
321 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
322 DwarfStrSectionSym = TextSectionSym = 0;
323 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
324 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
325 FunctionBeginSym = FunctionEndSym = 0;
326 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
328 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
332 DwarfDebug::~DwarfDebug() {
333 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
334 DIEBlocks[j]->~DIEBlock();
337 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
338 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
339 if (Entry.first) return Entry.first;
341 Entry.second = NextStringPoolNumber++;
342 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
346 /// assignAbbrevNumber - Define a unique number for the abbreviation.
348 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
349 // Profile the node so that we can make it unique.
353 // Check the set for priors.
354 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
356 // If it's newly added.
357 if (InSet == &Abbrev) {
358 // Add to abbreviation list.
359 Abbreviations.push_back(&Abbrev);
361 // Assign the vector position + 1 as its number.
362 Abbrev.setNumber(Abbreviations.size());
364 // Assign existing abbreviation number.
365 Abbrev.setNumber(InSet->getNumber());
369 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
370 /// information entry.
371 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
372 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
376 /// addUInt - Add an unsigned integer attribute data and value.
378 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
379 unsigned Form, uint64_t Integer) {
380 if (!Form) Form = DIEInteger::BestForm(false, Integer);
381 DIEValue *Value = Integer == 1 ?
382 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
383 Die->addValue(Attribute, Form, Value);
386 /// addSInt - Add an signed integer attribute data and value.
388 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
389 unsigned Form, int64_t Integer) {
390 if (!Form) Form = DIEInteger::BestForm(true, Integer);
391 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
392 Die->addValue(Attribute, Form, Value);
395 /// addString - Add a string attribute data and value. DIEString only
396 /// keeps string reference.
397 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
399 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
400 Die->addValue(Attribute, Form, Value);
403 /// addLabel - Add a Dwarf label attribute data and value.
405 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
406 const MCSymbol *Label) {
407 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
408 Die->addValue(Attribute, Form, Value);
411 /// addDelta - Add a label delta attribute data and value.
413 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
414 const MCSymbol *Hi, const MCSymbol *Lo) {
415 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
416 Die->addValue(Attribute, Form, Value);
419 /// addDIEEntry - Add a DIE attribute data and value.
421 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
423 Die->addValue(Attribute, Form, createDIEEntry(Entry));
427 /// addBlock - Add block data.
429 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
431 Block->ComputeSize(Asm);
432 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
433 Die->addValue(Attribute, Block->BestForm(), Block);
436 /// addSourceLine - Add location information to specified debug information
438 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
443 unsigned Line = V->getLineNumber();
444 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
445 V->getContext().getFilename());
446 assert(FileID && "Invalid file id");
447 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
448 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
451 /// addSourceLine - Add location information to specified debug information
453 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
454 // Verify global variable.
458 unsigned Line = G->getLineNumber();
459 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
460 G->getContext().getFilename());
461 assert(FileID && "Invalid file id");
462 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
463 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
466 /// addSourceLine - Add location information to specified debug information
468 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
469 // Verify subprogram.
472 // If the line number is 0, don't add it.
473 if (SP->getLineNumber() == 0)
476 unsigned Line = SP->getLineNumber();
477 if (!SP->getContext().Verify())
479 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
481 assert(FileID && "Invalid file id");
482 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
483 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
486 /// addSourceLine - Add location information to specified debug information
488 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
493 unsigned Line = Ty->getLineNumber();
494 if (!Ty->getContext().Verify())
496 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
497 Ty->getContext().getFilename());
498 assert(FileID && "Invalid file id");
499 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
500 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
503 /// addSourceLine - Add location information to specified debug information
505 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
510 unsigned Line = NS->getLineNumber();
511 StringRef FN = NS->getFilename();
512 StringRef Dir = NS->getDirectory();
514 unsigned FileID = GetOrCreateSourceID(Dir, FN);
515 assert(FileID && "Invalid file id");
516 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
517 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
520 /* Byref variables, in Blocks, are declared by the programmer as
521 "SomeType VarName;", but the compiler creates a
522 __Block_byref_x_VarName struct, and gives the variable VarName
523 either the struct, or a pointer to the struct, as its type. This
524 is necessary for various behind-the-scenes things the compiler
525 needs to do with by-reference variables in blocks.
527 However, as far as the original *programmer* is concerned, the
528 variable should still have type 'SomeType', as originally declared.
530 The following function dives into the __Block_byref_x_VarName
531 struct to find the original type of the variable. This will be
532 passed back to the code generating the type for the Debug
533 Information Entry for the variable 'VarName'. 'VarName' will then
534 have the original type 'SomeType' in its debug information.
536 The original type 'SomeType' will be the type of the field named
537 'VarName' inside the __Block_byref_x_VarName struct.
539 NOTE: In order for this to not completely fail on the debugger
540 side, the Debug Information Entry for the variable VarName needs to
541 have a DW_AT_location that tells the debugger how to unwind through
542 the pointers and __Block_byref_x_VarName struct to find the actual
543 value of the variable. The function addBlockByrefType does this. */
545 /// Find the type the programmer originally declared the variable to be
546 /// and return that type.
548 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
551 unsigned tag = Ty.getTag();
553 if (tag == dwarf::DW_TAG_pointer_type) {
554 DIDerivedType DTy = DIDerivedType(Ty);
555 subType = DTy.getTypeDerivedFrom();
558 DICompositeType blockStruct = DICompositeType(subType);
559 DIArray Elements = blockStruct.getTypeArray();
561 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
562 DIDescriptor Element = Elements.getElement(i);
563 DIDerivedType DT = DIDerivedType(Element);
564 if (Name == DT.getName())
565 return (DT.getTypeDerivedFrom());
571 /// addComplexAddress - Start with the address based on the location provided,
572 /// and generate the DWARF information necessary to find the actual variable
573 /// given the extra address information encoded in the DIVariable, starting from
574 /// the starting location. Add the DWARF information to the die.
576 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
578 const MachineLocation &Location) {
579 const DIVariable &VD = DV->getVariable();
580 DIType Ty = VD.getType();
582 // Decode the original location, and use that as the start of the byref
583 // variable's location.
584 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
585 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
586 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
588 if (Location.isReg()) {
590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
592 Reg = Reg - dwarf::DW_OP_reg0;
593 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
594 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
598 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
600 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
601 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
604 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
607 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
608 uint64_t Element = VD.getAddrElement(i);
610 if (Element == DIFactory::OpPlus) {
611 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
612 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
613 } else if (Element == DIFactory::OpDeref) {
614 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
615 } else llvm_unreachable("unknown DIFactory Opcode");
618 // Now attach the location information to the DIE.
619 addBlock(Die, Attribute, 0, Block);
622 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
623 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
624 gives the variable VarName either the struct, or a pointer to the struct, as
625 its type. This is necessary for various behind-the-scenes things the
626 compiler needs to do with by-reference variables in Blocks.
628 However, as far as the original *programmer* is concerned, the variable
629 should still have type 'SomeType', as originally declared.
631 The function getBlockByrefType dives into the __Block_byref_x_VarName
632 struct to find the original type of the variable, which is then assigned to
633 the variable's Debug Information Entry as its real type. So far, so good.
634 However now the debugger will expect the variable VarName to have the type
635 SomeType. So we need the location attribute for the variable to be an
636 expression that explains to the debugger how to navigate through the
637 pointers and struct to find the actual variable of type SomeType.
639 The following function does just that. We start by getting
640 the "normal" location for the variable. This will be the location
641 of either the struct __Block_byref_x_VarName or the pointer to the
642 struct __Block_byref_x_VarName.
644 The struct will look something like:
646 struct __Block_byref_x_VarName {
648 struct __Block_byref_x_VarName *forwarding;
649 ... <various other fields>
651 ... <maybe more fields>
654 If we are given the struct directly (as our starting point) we
655 need to tell the debugger to:
657 1). Add the offset of the forwarding field.
659 2). Follow that pointer to get the real __Block_byref_x_VarName
660 struct to use (the real one may have been copied onto the heap).
662 3). Add the offset for the field VarName, to find the actual variable.
664 If we started with a pointer to the struct, then we need to
665 dereference that pointer first, before the other steps.
666 Translating this into DWARF ops, we will need to append the following
667 to the current location description for the variable:
669 DW_OP_deref -- optional, if we start with a pointer
670 DW_OP_plus_uconst <forward_fld_offset>
672 DW_OP_plus_uconst <varName_fld_offset>
674 That is what this function does. */
676 /// addBlockByrefAddress - Start with the address based on the location
677 /// provided, and generate the DWARF information necessary to find the
678 /// actual Block variable (navigating the Block struct) based on the
679 /// starting location. Add the DWARF information to the die. For
680 /// more information, read large comment just above here.
682 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
684 const MachineLocation &Location) {
685 const DIVariable &VD = DV->getVariable();
686 DIType Ty = VD.getType();
688 unsigned Tag = Ty.getTag();
689 bool isPointer = false;
691 StringRef varName = VD.getName();
693 if (Tag == dwarf::DW_TAG_pointer_type) {
694 DIDerivedType DTy = DIDerivedType(Ty);
695 TmpTy = DTy.getTypeDerivedFrom();
699 DICompositeType blockStruct = DICompositeType(TmpTy);
701 // Find the __forwarding field and the variable field in the __Block_byref
703 DIArray Fields = blockStruct.getTypeArray();
704 DIDescriptor varField = DIDescriptor();
705 DIDescriptor forwardingField = DIDescriptor();
707 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
708 DIDescriptor Element = Fields.getElement(i);
709 DIDerivedType DT = DIDerivedType(Element);
710 StringRef fieldName = DT.getName();
711 if (fieldName == "__forwarding")
712 forwardingField = Element;
713 else if (fieldName == varName)
717 // Get the offsets for the forwarding field and the variable field.
718 unsigned forwardingFieldOffset =
719 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
720 unsigned varFieldOffset =
721 DIDerivedType(varField).getOffsetInBits() >> 3;
723 // Decode the original location, and use that as the start of the byref
724 // variable's location.
725 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
726 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
727 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
729 if (Location.isReg()) {
731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
733 Reg = Reg - dwarf::DW_OP_reg0;
734 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
741 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
742 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
745 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
748 // If we started with a pointer to the __Block_byref... struct, then
749 // the first thing we need to do is dereference the pointer (DW_OP_deref).
751 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
753 // Next add the offset for the '__forwarding' field:
754 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
755 // adding the offset if it's 0.
756 if (forwardingFieldOffset > 0) {
757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
758 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
761 // Now dereference the __forwarding field to get to the real __Block_byref
762 // struct: DW_OP_deref.
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
765 // Now that we've got the real __Block_byref... struct, add the offset
766 // for the variable's field to get to the location of the actual variable:
767 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
768 if (varFieldOffset > 0) {
769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
770 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
773 // Now attach the location information to the DIE.
774 addBlock(Die, Attribute, 0, Block);
777 /// addAddress - Add an address attribute to a die based on the location
779 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
780 const MachineLocation &Location) {
781 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
782 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
783 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
785 if (Location.isReg()) {
787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
790 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
794 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
796 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
797 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
800 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
803 addBlock(Die, Attribute, 0, Block);
806 /// addRegisterAddress - Add register location entry in variable DIE.
807 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
808 const MachineOperand &MO) {
809 assert (MO.isReg() && "Invalid machine operand!");
812 MachineLocation Location;
813 Location.set(MO.getReg());
814 addAddress(Die, dwarf::DW_AT_location, Location);
816 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
820 /// addConstantValue - Add constant value entry in variable DIE.
821 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
822 const MachineOperand &MO) {
823 assert (MO.isImm() && "Invalid machine operand!");
824 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
825 unsigned Imm = MO.getImm();
826 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
827 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
829 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
833 /// addConstantFPValue - Add constant value entry in variable DIE.
834 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
835 const MachineOperand &MO) {
836 assert (MO.isFPImm() && "Invalid machine operand!");
837 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
838 APFloat FPImm = MO.getFPImm()->getValueAPF();
840 // Get the raw data form of the floating point.
841 const APInt FltVal = FPImm.bitcastToAPInt();
842 const char *FltPtr = (const char*)FltVal.getRawData();
844 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
845 bool LittleEndian = Asm->getTargetData().isLittleEndian();
846 int Incr = (LittleEndian ? 1 : -1);
847 int Start = (LittleEndian ? 0 : NumBytes - 1);
848 int Stop = (LittleEndian ? NumBytes : -1);
850 // Output the constant to DWARF one byte at a time.
851 for (; Start != Stop; Start += Incr)
852 addUInt(Block, 0, dwarf::DW_FORM_data1,
853 (unsigned char)0xFF & FltPtr[Start]);
855 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
857 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
862 /// addToContextOwner - Add Die into the list of its context owner's children.
863 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
864 if (Context.isType()) {
865 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
866 ContextDIE->addChild(Die);
867 } else if (Context.isNameSpace()) {
868 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
869 ContextDIE->addChild(Die);
870 } else if (Context.isSubprogram()) {
871 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
873 ContextDIE->addChild(Die);
874 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
875 ContextDIE->addChild(Die);
877 getCompileUnit(Context)->addDie(Die);
880 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
882 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
883 CompileUnit *TypeCU = getCompileUnit(Ty);
884 DIE *TyDIE = TypeCU->getDIE(Ty);
889 TyDIE = new DIE(dwarf::DW_TAG_base_type);
890 TypeCU->insertDIE(Ty, TyDIE);
891 if (Ty.isBasicType())
892 constructTypeDIE(*TyDIE, DIBasicType(Ty));
893 else if (Ty.isCompositeType())
894 constructTypeDIE(*TyDIE, DICompositeType(Ty));
896 assert(Ty.isDerivedType() && "Unknown kind of DIType");
897 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
900 addToContextOwner(TyDIE, Ty.getContext());
904 /// addType - Add a new type attribute to the specified entity.
905 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
909 // Check for pre-existence.
910 CompileUnit *TypeCU = getCompileUnit(Ty);
911 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
912 // If it exists then use the existing value.
914 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
919 DIE *Buffer = getOrCreateTypeDIE(Ty);
922 Entry = createDIEEntry(Buffer);
923 TypeCU->insertDIEEntry(Ty, Entry);
925 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
928 /// constructTypeDIE - Construct basic type die from DIBasicType.
929 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
930 // Get core information.
931 StringRef Name = BTy.getName();
932 Buffer.setTag(dwarf::DW_TAG_base_type);
933 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
936 // Add name if not anonymous or intermediate type.
938 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
939 uint64_t Size = BTy.getSizeInBits() >> 3;
940 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
943 /// constructTypeDIE - Construct derived type die from DIDerivedType.
944 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
945 // Get core information.
946 StringRef Name = DTy.getName();
947 uint64_t Size = DTy.getSizeInBits() >> 3;
948 unsigned Tag = DTy.getTag();
950 // FIXME - Workaround for templates.
951 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
955 // Map to main type, void will not have a type.
956 DIType FromTy = DTy.getTypeDerivedFrom();
957 addType(&Buffer, FromTy);
959 // Add name if not anonymous or intermediate type.
961 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
963 // Add size if non-zero (derived types might be zero-sized.)
965 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
967 // Add source line info if available and TyDesc is not a forward declaration.
968 if (!DTy.isForwardDecl())
969 addSourceLine(&Buffer, &DTy);
972 /// constructTypeDIE - Construct type DIE from DICompositeType.
973 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
974 // Get core information.
975 StringRef Name = CTy.getName();
977 uint64_t Size = CTy.getSizeInBits() >> 3;
978 unsigned Tag = CTy.getTag();
982 case dwarf::DW_TAG_vector_type:
983 case dwarf::DW_TAG_array_type:
984 constructArrayTypeDIE(Buffer, &CTy);
986 case dwarf::DW_TAG_enumeration_type: {
987 DIArray Elements = CTy.getTypeArray();
989 // Add enumerators to enumeration type.
990 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
992 DIDescriptor Enum(Elements.getElement(i));
993 if (Enum.isEnumerator()) {
994 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
995 Buffer.addChild(ElemDie);
1000 case dwarf::DW_TAG_subroutine_type: {
1002 DIArray Elements = CTy.getTypeArray();
1003 DIDescriptor RTy = Elements.getElement(0);
1004 addType(&Buffer, DIType(RTy));
1006 // Add prototype flag.
1007 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1010 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1011 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1012 DIDescriptor Ty = Elements.getElement(i);
1013 addType(Arg, DIType(Ty));
1014 Buffer.addChild(Arg);
1018 case dwarf::DW_TAG_structure_type:
1019 case dwarf::DW_TAG_union_type:
1020 case dwarf::DW_TAG_class_type: {
1021 // Add elements to structure type.
1022 DIArray Elements = CTy.getTypeArray();
1024 // A forward struct declared type may not have elements available.
1025 unsigned N = Elements.getNumElements();
1029 // Add elements to structure type.
1030 for (unsigned i = 0; i < N; ++i) {
1031 DIDescriptor Element = Elements.getElement(i);
1032 DIE *ElemDie = NULL;
1033 if (Element.isSubprogram())
1034 ElemDie = createSubprogramDIE(DISubprogram(Element));
1035 else if (Element.isVariable()) {
1036 DIVariable DV(Element);
1037 ElemDie = new DIE(dwarf::DW_TAG_variable);
1038 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1040 addType(ElemDie, DV.getType());
1041 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1042 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1043 addSourceLine(ElemDie, &DV);
1044 } else if (Element.isDerivedType())
1045 ElemDie = createMemberDIE(DIDerivedType(Element));
1048 Buffer.addChild(ElemDie);
1051 if (CTy.isAppleBlockExtension())
1052 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1054 unsigned RLang = CTy.getRunTimeLang();
1056 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1057 dwarf::DW_FORM_data1, RLang);
1059 DICompositeType ContainingType = CTy.getContainingType();
1060 if (DIDescriptor(ContainingType).isCompositeType())
1061 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1062 getOrCreateTypeDIE(DIType(ContainingType)));
1064 DIDescriptor Context = CTy.getContext();
1065 addToContextOwner(&Buffer, Context);
1073 // Add name if not anonymous or intermediate type.
1075 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1077 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1078 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1080 // Add size if non-zero (derived types might be zero-sized.)
1082 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1084 // Add zero size if it is not a forward declaration.
1085 if (CTy.isForwardDecl())
1086 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1088 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1091 // Add source line info if available.
1092 if (!CTy.isForwardDecl())
1093 addSourceLine(&Buffer, &CTy);
1097 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1098 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1099 int64_t L = SR.getLo();
1100 int64_t H = SR.getHi();
1101 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1103 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1105 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1106 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1108 Buffer.addChild(DW_Subrange);
1111 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1112 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1113 DICompositeType *CTy) {
1114 Buffer.setTag(dwarf::DW_TAG_array_type);
1115 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1116 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1118 // Emit derived type.
1119 addType(&Buffer, CTy->getTypeDerivedFrom());
1120 DIArray Elements = CTy->getTypeArray();
1122 // Get an anonymous type for index type.
1123 CompileUnit *TheCU = getCompileUnit(*CTy);
1124 DIE *IdxTy = TheCU->getIndexTyDie();
1126 // Construct an anonymous type for index type.
1127 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1128 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1129 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1130 dwarf::DW_ATE_signed);
1131 TheCU->addDie(IdxTy);
1132 TheCU->setIndexTyDie(IdxTy);
1135 // Add subranges to array type.
1136 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1137 DIDescriptor Element = Elements.getElement(i);
1138 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1139 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1143 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1144 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1145 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1146 StringRef Name = ETy.getName();
1147 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1148 int64_t Value = ETy.getEnumValue();
1149 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1153 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1154 /// printer to not emit usual symbol prefix before the symbol name is used then
1155 /// return linkage name after skipping this special LLVM prefix.
1156 static StringRef getRealLinkageName(StringRef LinkageName) {
1158 if (LinkageName.startswith(StringRef(&One, 1)))
1159 return LinkageName.substr(1);
1163 /// createGlobalVariableDIE - Create new DIE using GV.
1164 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1165 // If the global variable was optmized out then no need to create debug info
1167 if (!GV.getGlobal()) return NULL;
1168 if (GV.getDisplayName().empty()) return NULL;
1170 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1171 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1172 GV.getDisplayName());
1174 StringRef LinkageName = GV.getLinkageName();
1175 if (!LinkageName.empty())
1176 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1177 getRealLinkageName(LinkageName));
1179 addType(GVDie, GV.getType());
1180 if (!GV.isLocalToUnit())
1181 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1182 addSourceLine(GVDie, &GV);
1187 /// createMemberDIE - Create new member DIE.
1188 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1189 DIE *MemberDie = new DIE(DT.getTag());
1190 StringRef Name = DT.getName();
1192 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1194 addType(MemberDie, DT.getTypeDerivedFrom());
1196 addSourceLine(MemberDie, &DT);
1198 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1199 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1201 uint64_t Size = DT.getSizeInBits();
1202 uint64_t FieldSize = DT.getOriginalTypeSize();
1204 if (Size != FieldSize) {
1206 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1207 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1209 uint64_t Offset = DT.getOffsetInBits();
1210 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1211 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1212 uint64_t FieldOffset = (HiMark - FieldSize);
1213 Offset -= FieldOffset;
1215 // Maybe we need to work from the other end.
1216 if (Asm->getTargetData().isLittleEndian())
1217 Offset = FieldSize - (Offset + Size);
1218 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1220 // Here WD_AT_data_member_location points to the anonymous
1221 // field that includes this bit field.
1222 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1225 // This is not a bitfield.
1226 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1228 if (DT.getTag() == dwarf::DW_TAG_inheritance
1229 && DT.isVirtual()) {
1231 // For C++, virtual base classes are not at fixed offset. Use following
1232 // expression to extract appropriate offset from vtable.
1233 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1235 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1242 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1244 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1247 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1249 if (DT.isProtected())
1250 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1251 dwarf::DW_ACCESS_protected);
1252 else if (DT.isPrivate())
1253 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1254 dwarf::DW_ACCESS_private);
1255 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1256 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1257 dwarf::DW_ACCESS_public);
1259 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1260 dwarf::DW_VIRTUALITY_virtual);
1264 /// createSubprogramDIE - Create new DIE using SP.
1265 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1266 CompileUnit *SPCU = getCompileUnit(SP);
1267 DIE *SPDie = SPCU->getDIE(SP);
1271 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1272 // Constructors and operators for anonymous aggregates do not have names.
1273 if (!SP.getName().empty())
1274 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1276 StringRef LinkageName = SP.getLinkageName();
1277 if (!LinkageName.empty())
1278 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1279 getRealLinkageName(LinkageName));
1281 addSourceLine(SPDie, &SP);
1283 // Add prototyped tag, if C or ObjC.
1284 unsigned Lang = SP.getCompileUnit().getLanguage();
1285 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1286 Lang == dwarf::DW_LANG_ObjC)
1287 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1290 DICompositeType SPTy = SP.getType();
1291 DIArray Args = SPTy.getTypeArray();
1292 unsigned SPTag = SPTy.getTag();
1294 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1295 addType(SPDie, SPTy);
1297 addType(SPDie, DIType(Args.getElement(0)));
1299 unsigned VK = SP.getVirtuality();
1301 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1302 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1303 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1304 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1305 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1306 ContainingTypeMap.insert(std::make_pair(SPDie,
1307 SP.getContainingType()));
1310 if (MakeDecl || !SP.isDefinition()) {
1311 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1313 // Add arguments. Do not add arguments for subprogram definition. They will
1314 // be handled while processing variables.
1315 DICompositeType SPTy = SP.getType();
1316 DIArray Args = SPTy.getTypeArray();
1317 unsigned SPTag = SPTy.getTag();
1319 if (SPTag == dwarf::DW_TAG_subroutine_type)
1320 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1321 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1322 DIType ATy = DIType(DIType(Args.getElement(i)));
1324 if (ATy.isArtificial())
1325 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1326 SPDie->addChild(Arg);
1330 if (SP.isArtificial())
1331 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1333 if (!SP.isLocalToUnit())
1334 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1336 if (SP.isOptimized())
1337 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1339 if (unsigned isa = Asm->getISAEncoding()) {
1340 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1343 // DW_TAG_inlined_subroutine may refer to this DIE.
1344 SPCU->insertDIE(SP, SPDie);
1346 // Add to context owner.
1347 addToContextOwner(SPDie, SP.getContext());
1352 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1353 assert(N && "Invalid Scope encoding!");
1355 DbgScope *AScope = AbstractScopes.lookup(N);
1359 DbgScope *Parent = NULL;
1361 DIDescriptor Scope(N);
1362 if (Scope.isLexicalBlock()) {
1363 DILexicalBlock DB(N);
1364 DIDescriptor ParentDesc = DB.getContext();
1365 Parent = getOrCreateAbstractScope(ParentDesc);
1368 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1371 Parent->addScope(AScope);
1372 AScope->setAbstractScope();
1373 AbstractScopes[N] = AScope;
1374 if (DIDescriptor(N).isSubprogram())
1375 AbstractScopesList.push_back(AScope);
1379 /// isSubprogramContext - Return true if Context is either a subprogram
1380 /// or another context nested inside a subprogram.
1381 static bool isSubprogramContext(const MDNode *Context) {
1384 DIDescriptor D(Context);
1385 if (D.isSubprogram())
1388 return isSubprogramContext(DIType(Context).getContext());
1392 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1393 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1394 /// If there are global variables in this scope then create and insert
1395 /// DIEs for these variables.
1396 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1397 CompileUnit *SPCU = getCompileUnit(SPNode);
1398 DIE *SPDie = SPCU->getDIE(SPNode);
1400 assert(SPDie && "Unable to find subprogram DIE!");
1401 DISubprogram SP(SPNode);
1403 // There is not any need to generate specification DIE for a function
1404 // defined at compile unit level. If a function is defined inside another
1405 // function then gdb prefers the definition at top level and but does not
1406 // expect specification DIE in parent function. So avoid creating
1407 // specification DIE for a function defined inside a function.
1408 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1409 !SP.getContext().isFile() &&
1410 !isSubprogramContext(SP.getContext())) {
1411 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1414 DICompositeType SPTy = SP.getType();
1415 DIArray Args = SPTy.getTypeArray();
1416 unsigned SPTag = SPTy.getTag();
1417 if (SPTag == dwarf::DW_TAG_subroutine_type)
1418 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1419 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1420 DIType ATy = DIType(DIType(Args.getElement(i)));
1422 if (ATy.isArtificial())
1423 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1424 SPDie->addChild(Arg);
1426 DIE *SPDeclDie = SPDie;
1427 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1428 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1430 SPCU->addDie(SPDie);
1433 // Pick up abstract subprogram DIE.
1434 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1435 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1436 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1437 dwarf::DW_FORM_ref4, AbsSPDIE);
1438 SPCU->addDie(SPDie);
1441 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1442 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1443 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1444 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1445 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1446 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1447 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1452 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1453 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1454 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1456 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1457 if (Scope->isAbstractScope())
1460 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1464 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1465 if (Ranges.size() > 1) {
1466 // .debug_range section has not been laid out yet. Emit offset in
1467 // .debug_range as a uint, size 4, for now. emitDIE will handle
1468 // DW_AT_ranges appropriately.
1469 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1470 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1471 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1472 RE = Ranges.end(); RI != RE; ++RI) {
1473 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1474 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1476 DebugRangeSymbols.push_back(NULL);
1477 DebugRangeSymbols.push_back(NULL);
1481 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1482 const MCSymbol *End = getLabelAfterInsn(RI->second);
1484 if (End == 0) return 0;
1486 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1487 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1489 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1490 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1495 /// constructInlinedScopeDIE - This scope represents inlined body of
1496 /// a function. Construct DIE to represent this concrete inlined copy
1497 /// of the function.
1498 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1500 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1501 assert (Ranges.empty() == false
1502 && "DbgScope does not have instruction markers!");
1504 // FIXME : .debug_inlined section specification does not clearly state how
1505 // to emit inlined scope that is split into multiple instruction ranges.
1506 // For now, use first instruction range and emit low_pc/high_pc pair and
1507 // corresponding .debug_inlined section entry for this pair.
1508 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1509 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1510 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1512 if (StartLabel == 0 || EndLabel == 0) {
1513 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1516 assert(StartLabel->isDefined() &&
1517 "Invalid starting label for an inlined scope!");
1518 assert(EndLabel->isDefined() &&
1519 "Invalid end label for an inlined scope!");
1521 if (!Scope->getScopeNode())
1523 DIScope DS(Scope->getScopeNode());
1524 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1526 DISubprogram InlinedSP = getDISubprogram(DS);
1527 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1528 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1529 assert(OriginDIE && "Unable to find Origin DIE!");
1530 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1531 dwarf::DW_FORM_ref4, OriginDIE);
1533 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1534 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1536 InlinedSubprogramDIEs.insert(OriginDIE);
1538 // Track the start label for this inlined function.
1539 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1540 I = InlineInfo.find(InlinedSP);
1542 if (I == InlineInfo.end()) {
1543 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1545 InlinedSPNodes.push_back(InlinedSP);
1547 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1549 DILocation DL(Scope->getInlinedAt());
1550 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1551 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1557 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1558 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1559 // Get the descriptor.
1560 const DIVariable &VD = DV->getVariable();
1561 StringRef Name = VD.getName();
1565 // Translate tag to proper Dwarf tag. The result variable is dropped for
1568 switch (VD.getTag()) {
1569 case dwarf::DW_TAG_return_variable:
1571 case dwarf::DW_TAG_arg_variable:
1572 Tag = dwarf::DW_TAG_formal_parameter;
1574 case dwarf::DW_TAG_auto_variable: // fall thru
1576 Tag = dwarf::DW_TAG_variable;
1580 // Define variable debug information entry.
1581 DIE *VariableDie = new DIE(Tag);
1584 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1585 V2AVI = VarToAbstractVarMap.find(DV);
1586 if (V2AVI != VarToAbstractVarMap.end())
1587 AbsDIE = V2AVI->second->getDIE();
1590 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1591 dwarf::DW_FORM_ref4, AbsDIE);
1593 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1594 addSourceLine(VariableDie, &VD);
1596 // Add variable type.
1597 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1598 // addresses instead.
1599 if (VD.isBlockByrefVariable())
1600 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1602 addType(VariableDie, VD.getType());
1605 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1606 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1608 if (Scope->isAbstractScope()) {
1609 DV->setDIE(VariableDie);
1613 // Add variable address.
1615 unsigned Offset = DV->getDotDebugLocOffset();
1616 if (Offset != ~0U) {
1617 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1618 Asm->GetTempSymbol("debug_loc", Offset));
1619 DV->setDIE(VariableDie);
1620 UseDotDebugLocEntry.insert(VariableDie);
1624 // Check if variable is described by a DBG_VALUE instruction.
1625 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1626 DbgVariableToDbgInstMap.find(DV);
1627 if (DVI != DbgVariableToDbgInstMap.end()) {
1628 const MachineInstr *DVInsn = DVI->second;
1629 const MCSymbol *DVLabel = findVariableLabel(DV);
1630 bool updated = false;
1631 // FIXME : Handle getNumOperands != 3
1632 if (DVInsn->getNumOperands() == 3) {
1633 if (DVInsn->getOperand(0).isReg())
1635 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1636 else if (DVInsn->getOperand(0).isImm())
1637 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1638 else if (DVInsn->getOperand(0).isFPImm())
1640 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1642 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1643 if (Location.getReg()) {
1644 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1646 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1652 // If variableDie is not updated then DBG_VALUE instruction does not
1653 // have valid variable info.
1657 DV->setDIE(VariableDie);
1661 // .. else use frame index, if available.
1662 MachineLocation Location;
1664 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1666 if (findVariableFrameIndex(DV, &FI)) {
1667 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1668 Location.set(FrameReg, Offset);
1670 if (VD.hasComplexAddress())
1671 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1672 else if (VD.isBlockByrefVariable())
1673 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1675 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1677 DV->setDIE(VariableDie);
1682 void DwarfDebug::addPubTypes(DISubprogram SP) {
1683 DICompositeType SPTy = SP.getType();
1684 unsigned SPTag = SPTy.getTag();
1685 if (SPTag != dwarf::DW_TAG_subroutine_type)
1688 DIArray Args = SPTy.getTypeArray();
1689 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1690 DIType ATy(Args.getElement(i));
1693 DICompositeType CATy = getDICompositeType(ATy);
1694 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1695 && !CATy.isForwardDecl()) {
1696 CompileUnit *TheCU = getCompileUnit(CATy);
1697 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1698 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1703 /// constructScopeDIE - Construct a DIE for this scope.
1704 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1705 if (!Scope || !Scope->getScopeNode())
1708 DIScope DS(Scope->getScopeNode());
1709 DIE *ScopeDIE = NULL;
1710 if (Scope->getInlinedAt())
1711 ScopeDIE = constructInlinedScopeDIE(Scope);
1712 else if (DS.isSubprogram()) {
1713 ProcessedSPNodes.insert(DS);
1714 if (Scope->isAbstractScope()) {
1715 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1716 // Note down abstract DIE.
1718 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1721 ScopeDIE = updateSubprogramScopeDIE(DS);
1724 ScopeDIE = constructLexicalScopeDIE(Scope);
1725 if (!ScopeDIE) return NULL;
1727 // Add variables to scope.
1728 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1729 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1730 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1732 ScopeDIE->addChild(VariableDIE);
1735 // Add nested scopes.
1736 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1737 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1738 // Define the Scope debug information entry.
1739 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1741 ScopeDIE->addChild(NestedDIE);
1744 if (DS.isSubprogram())
1745 addPubTypes(DISubprogram(DS));
1750 /// GetOrCreateSourceID - Look up the source id with the given directory and
1751 /// source file names. If none currently exists, create a new id and insert it
1752 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1754 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1756 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1757 if (DI != DirectoryIdMap.end()) {
1758 DId = DI->getValue();
1760 DId = DirectoryNames.size() + 1;
1761 DirectoryIdMap[DirName] = DId;
1762 DirectoryNames.push_back(DirName);
1766 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1767 if (FI != SourceFileIdMap.end()) {
1768 FId = FI->getValue();
1770 FId = SourceFileNames.size() + 1;
1771 SourceFileIdMap[FileName] = FId;
1772 SourceFileNames.push_back(FileName);
1775 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1776 SourceIdMap.find(std::make_pair(DId, FId));
1777 if (SI != SourceIdMap.end())
1780 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1781 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1782 SourceIds.push_back(std::make_pair(DId, FId));
1787 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1788 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1789 CompileUnit *TheCU = getCompileUnit(NS);
1790 DIE *NDie = TheCU->getDIE(NS);
1793 NDie = new DIE(dwarf::DW_TAG_namespace);
1794 TheCU->insertDIE(NS, NDie);
1795 if (!NS.getName().empty())
1796 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1797 addSourceLine(NDie, &NS);
1798 addToContextOwner(NDie, NS.getContext());
1802 /// constructCompileUnit - Create new CompileUnit for the given
1803 /// metadata node with tag DW_TAG_compile_unit.
1804 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1805 DICompileUnit DIUnit(N);
1806 StringRef FN = DIUnit.getFilename();
1807 StringRef Dir = DIUnit.getDirectory();
1809 sys::Path AbsFileDirName(FN);
1810 AbsFileDirName.makeAbsolute();
1811 Dir = AbsFileDirName.getDirname();
1813 unsigned ID = GetOrCreateSourceID(Dir, FN);
1815 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1816 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1817 DIUnit.getProducer());
1818 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1819 DIUnit.getLanguage());
1820 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1821 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1822 // simplifies debug range entries.
1823 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1824 // DW_AT_stmt_list is a offset of line number information for this
1825 // compile unit in debug_line section. This offset is calculated
1826 // during endMoudle().
1827 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1830 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1831 if (DIUnit.isOptimized())
1832 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1834 StringRef Flags = DIUnit.getFlags();
1836 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1838 unsigned RVer = DIUnit.getRunTimeVersion();
1840 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1841 dwarf::DW_FORM_data1, RVer);
1843 CompileUnit *NewCU = new CompileUnit(ID, Die);
1846 CUMap.insert(std::make_pair(N, NewCU));
1849 /// getCompielUnit - Get CompileUnit DIE.
1850 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1851 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1853 const MDNode *CUNode = NULL;
1854 if (D.isCompileUnit())
1856 else if (D.isSubprogram())
1857 CUNode = DISubprogram(N).getCompileUnit();
1858 else if (D.isType())
1859 CUNode = DIType(N).getCompileUnit();
1860 else if (D.isGlobalVariable())
1861 CUNode = DIGlobalVariable(N).getCompileUnit();
1862 else if (D.isVariable())
1863 CUNode = DIVariable(N).getCompileUnit();
1864 else if (D.isNameSpace())
1865 CUNode = DINameSpace(N).getCompileUnit();
1866 else if (D.isFile())
1867 CUNode = DIFile(N).getCompileUnit();
1871 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1872 = CUMap.find(CUNode);
1873 if (I == CUMap.end())
1879 /// constructGlobalVariableDIE - Construct global variable DIE.
1880 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1881 DIGlobalVariable DI_GV(N);
1883 // If debug information is malformed then ignore it.
1884 if (DI_GV.Verify() == false)
1887 // Check for pre-existence.
1888 CompileUnit *TheCU = getCompileUnit(N);
1889 if (TheCU->getDIE(DI_GV))
1892 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1897 TheCU->insertDIE(N, VariableDie);
1899 // Add to context owner.
1900 DIDescriptor GVContext = DI_GV.getContext();
1901 // Do not create specification DIE if context is either compile unit
1903 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1904 !GVContext.isFile() &&
1905 !isSubprogramContext(GVContext)) {
1906 // Create specification DIE.
1907 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1908 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1909 dwarf::DW_FORM_ref4, VariableDie);
1910 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1911 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1912 addLabel(Block, 0, dwarf::DW_FORM_udata,
1913 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1914 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1915 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1916 TheCU->addDie(VariableSpecDIE);
1918 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1919 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1920 addLabel(Block, 0, dwarf::DW_FORM_udata,
1921 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1922 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1924 addToContextOwner(VariableDie, GVContext);
1926 // Expose as global. FIXME - need to check external flag.
1927 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1929 DIType GTy = DI_GV.getType();
1930 if (GTy.isCompositeType() && !GTy.getName().empty()
1931 && !GTy.isForwardDecl()) {
1932 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1933 assert(Entry && "Missing global type!");
1934 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1939 /// construct SubprogramDIE - Construct subprogram DIE.
1940 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1943 // Check for pre-existence.
1944 CompileUnit *TheCU = getCompileUnit(N);
1945 if (TheCU->getDIE(N))
1948 if (!SP.isDefinition())
1949 // This is a method declaration which will be handled while constructing
1953 DIE *SubprogramDie = createSubprogramDIE(SP);
1956 TheCU->insertDIE(N, SubprogramDie);
1958 // Add to context owner.
1959 addToContextOwner(SubprogramDie, SP.getContext());
1961 // Expose as global.
1962 TheCU->addGlobal(SP.getName(), SubprogramDie);
1967 /// beginModule - Emit all Dwarf sections that should come prior to the
1968 /// content. Create global DIEs and emit initial debug info sections.
1969 /// This is inovked by the target AsmPrinter.
1970 void DwarfDebug::beginModule(Module *M) {
1971 if (DisableDebugInfoPrinting)
1974 DebugInfoFinder DbgFinder;
1975 DbgFinder.processModule(*M);
1977 bool HasDebugInfo = false;
1979 // Scan all the compile-units to see if there are any marked as the main unit.
1980 // if not, we do not generate debug info.
1981 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1982 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1983 if (DICompileUnit(*I).isMain()) {
1984 HasDebugInfo = true;
1989 if (!HasDebugInfo) return;
1991 // Tell MMI that we have debug info.
1992 MMI->setDebugInfoAvailability(true);
1994 // Emit initial sections.
1995 EmitSectionLabels();
1997 // Create all the compile unit DIEs.
1998 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1999 E = DbgFinder.compile_unit_end(); I != E; ++I)
2000 constructCompileUnit(*I);
2002 // Create DIEs for each subprogram.
2003 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2004 E = DbgFinder.subprogram_end(); I != E; ++I)
2005 constructSubprogramDIE(*I);
2007 // Create DIEs for each global variable.
2008 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2009 E = DbgFinder.global_variable_end(); I != E; ++I)
2010 constructGlobalVariableDIE(*I);
2012 // Prime section data.
2013 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2015 // Print out .file directives to specify files for .loc directives. These are
2016 // printed out early so that they precede any .loc directives.
2017 if (Asm->MAI->hasDotLocAndDotFile()) {
2018 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2019 // Remember source id starts at 1.
2020 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2021 // FIXME: don't use sys::path for this! This should not depend on the
2023 sys::Path FullPath(getSourceDirectoryName(Id.first));
2025 FullPath.appendComponent(getSourceFileName(Id.second));
2026 assert(AppendOk && "Could not append filename to directory!");
2028 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2033 /// endModule - Emit all Dwarf sections that should come after the content.
2035 void DwarfDebug::endModule() {
2036 if (!FirstCU) return;
2037 const Module *M = MMI->getModule();
2038 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2039 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2040 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2041 DISubprogram SP(AllSPs->getOperand(SI));
2042 if (!SP.Verify()) continue;
2044 // Collect info for variables that were optimized out.
2045 if (!SP.isDefinition()) continue;
2046 StringRef FName = SP.getLinkageName();
2048 FName = SP.getName();
2050 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2052 unsigned E = NMD->getNumOperands();
2054 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2055 for (unsigned I = 0; I != E; ++I) {
2056 DIVariable DV(NMD->getOperand(I));
2057 if (!DV.Verify()) continue;
2058 Scope->addVariable(new DbgVariable(DV));
2061 // Construct subprogram DIE and add variables DIEs.
2062 constructSubprogramDIE(SP);
2063 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2064 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2065 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2066 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2068 ScopeDIE->addChild(VariableDIE);
2073 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2074 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2075 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2077 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2080 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2081 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2082 DIE *SPDie = CI->first;
2083 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2085 DIE *NDie = getCompileUnit(N)->getDIE(N);
2086 if (!NDie) continue;
2087 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2090 // Standard sections final addresses.
2091 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2092 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2093 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2094 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2096 // End text sections.
2097 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2098 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2099 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2102 // Emit common frame information.
2103 emitCommonDebugFrame();
2105 // Emit function debug frame information
2106 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2107 E = DebugFrames.end(); I != E; ++I)
2108 emitFunctionDebugFrame(*I);
2110 // Compute DIE offsets and sizes.
2111 computeSizeAndOffsets();
2113 // Emit source line correspondence into a debug line section.
2116 // Emit all the DIEs into a debug info section
2119 // Corresponding abbreviations into a abbrev section.
2120 emitAbbreviations();
2122 // Emit info into a debug pubnames section.
2123 emitDebugPubNames();
2125 // Emit info into a debug pubtypes section.
2126 emitDebugPubTypes();
2128 // Emit info into a debug loc section.
2131 // Emit info into a debug aranges section.
2134 // Emit info into a debug ranges section.
2137 // Emit info into a debug macinfo section.
2140 // Emit inline info.
2141 emitDebugInlineInfo();
2143 // Emit info into a debug str section.
2146 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2147 E = CUMap.end(); I != E; ++I)
2149 FirstCU = NULL; // Reset for the next Module, if any.
2152 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2153 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2154 DebugLoc ScopeLoc) {
2156 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2158 return AbsDbgVariable;
2160 LLVMContext &Ctx = Var->getContext();
2161 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2165 AbsDbgVariable = new DbgVariable(Var);
2166 Scope->addVariable(AbsDbgVariable);
2167 AbstractVariables[Var] = AbsDbgVariable;
2168 return AbsDbgVariable;
2171 /// collectVariableInfoFromMMITable - Collect variable information from
2172 /// side table maintained by MMI.
2174 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2175 SmallPtrSet<const MDNode *, 16> &Processed) {
2176 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2177 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2178 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2179 VE = VMap.end(); VI != VE; ++VI) {
2180 const MDNode *Var = VI->first;
2182 Processed.insert(Var);
2184 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2186 DbgScope *Scope = 0;
2187 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2188 Scope = ConcreteScopes.lookup(IA);
2190 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2192 // If variable scope is not found then skip this variable.
2196 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2197 DbgVariable *RegVar = new DbgVariable(DV);
2198 recordVariableFrameIndex(RegVar, VP.first);
2199 Scope->addVariable(RegVar);
2200 if (AbsDbgVariable) {
2201 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2202 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2207 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2208 /// DBG_VALUE instruction, is in undefined reg.
2209 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2210 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2211 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2216 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2217 /// DBG_VALUE instruction, is in a defined reg.
2218 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2219 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2220 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2225 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2227 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2228 SmallPtrSet<const MDNode *, 16> &Processed) {
2230 /// collection info from MMI table.
2231 collectVariableInfoFromMMITable(MF, Processed);
2233 SmallVector<const MachineInstr *, 8> DbgValues;
2234 // Collect variable information from DBG_VALUE machine instructions;
2235 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2237 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2239 const MachineInstr *MInsn = II;
2240 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2242 DbgValues.push_back(MInsn);
2245 // This is a collection of DBV_VALUE instructions describing same variable.
2246 SmallVector<const MachineInstr *, 4> MultipleValues;
2247 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2248 E = DbgValues.end(); I != E; ++I) {
2249 const MachineInstr *MInsn = *I;
2250 MultipleValues.clear();
2251 if (isDbgValueInDefinedReg(MInsn))
2252 MultipleValues.push_back(MInsn);
2253 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2254 if (Processed.count(DV) != 0)
2257 const MachineInstr *PrevMI = MInsn;
2258 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2259 ME = DbgValues.end(); MI != ME; ++MI) {
2261 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2262 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2263 !PrevMI->isIdenticalTo(*MI))
2264 MultipleValues.push_back(*MI);
2268 DbgScope *Scope = findDbgScope(MInsn);
2269 bool CurFnArg = false;
2270 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2271 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2273 if (!Scope && CurFnArg)
2274 Scope = CurrentFnDbgScope;
2275 // If variable scope is not found then skip this variable.
2279 Processed.insert(DV);
2280 DbgVariable *RegVar = new DbgVariable(DV);
2281 Scope->addVariable(RegVar);
2283 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2284 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2285 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2286 VarToAbstractVarMap[RegVar] = AbsVar;
2288 if (MultipleValues.size() <= 1) {
2289 DbgVariableToDbgInstMap[RegVar] = MInsn;
2293 // handle multiple DBG_VALUE instructions describing one variable.
2294 if (DotDebugLocEntries.empty())
2295 RegVar->setDotDebugLocOffset(0);
2297 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2298 const MachineInstr *Begin = NULL;
2299 const MachineInstr *End = NULL;
2300 for (SmallVector<const MachineInstr *, 4>::iterator
2301 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2302 MVI != MVE; ++MVI) {
2308 MachineLocation MLoc;
2309 MLoc.set(Begin->getOperand(0).getReg(), 0);
2310 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2311 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2312 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2314 if (MVI + 1 == MVE) {
2315 // If End is the last instruction then its value is valid
2316 // until the end of the funtion.
2317 MLoc.set(End->getOperand(0).getReg(), 0);
2319 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2322 DotDebugLocEntries.push_back(DotDebugLocEntry());
2325 // Collect info for variables that were optimized out.
2326 const Function *F = MF->getFunction();
2327 const Module *M = F->getParent();
2328 if (NamedMDNode *NMD =
2329 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2330 getRealLinkageName(F->getName())))) {
2331 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2332 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2333 if (!DV || !Processed.insert(DV))
2335 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2337 Scope->addVariable(new DbgVariable(DV));
2342 /// getLabelBeforeInsn - Return Label preceding the instruction.
2343 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2344 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2345 LabelsBeforeInsn.find(MI);
2346 if (I == LabelsBeforeInsn.end())
2347 // FunctionBeginSym always preceeds all the instruction in current function.
2348 return FunctionBeginSym;
2352 /// getLabelAfterInsn - Return Label immediately following the instruction.
2353 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2354 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2355 LabelsAfterInsn.find(MI);
2356 if (I == LabelsAfterInsn.end())
2361 /// beginScope - Process beginning of a scope.
2362 void DwarfDebug::beginScope(const MachineInstr *MI) {
2363 if (InsnNeedsLabel.count(MI) == 0) {
2364 LabelsBeforeInsn[MI] = PrevLabel;
2369 DebugLoc DL = MI->getDebugLoc();
2370 if (!DL.isUnknown()) {
2371 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2372 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2374 LabelsBeforeInsn[MI] = PrevLabel;
2378 // If location is unknown then use temp label for this DBG_VALUE
2380 if (MI->isDebugValue()) {
2381 PrevLabel = MMI->getContext().CreateTempSymbol();
2382 Asm->OutStreamer.EmitLabel(PrevLabel);
2383 LabelsBeforeInsn[MI] = PrevLabel;
2387 if (UnknownLocations) {
2388 PrevLabel = recordSourceLine(0, 0, 0);
2389 LabelsBeforeInsn[MI] = PrevLabel;
2393 assert (0 && "Instruction is not processed!");
2396 /// endScope - Process end of a scope.
2397 void DwarfDebug::endScope(const MachineInstr *MI) {
2398 if (InsnsEndScopeSet.count(MI) != 0) {
2399 // Emit a label if this instruction ends a scope.
2400 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2401 Asm->OutStreamer.EmitLabel(Label);
2402 LabelsAfterInsn[MI] = Label;
2406 /// getOrCreateDbgScope - Create DbgScope for the scope.
2407 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2408 const MDNode *InlinedAt) {
2410 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2413 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2414 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2415 if (DIDescriptor(Scope).isLexicalBlock()) {
2417 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2418 WScope->setParent(Parent);
2419 Parent->addScope(WScope);
2422 if (!WScope->getParent()) {
2423 StringRef SPName = DISubprogram(Scope).getLinkageName();
2424 // We used to check only for a linkage name, but that fails
2425 // since we began omitting the linkage name for private
2426 // functions. The new way is to check for the name in metadata,
2427 // but that's not supported in old .ll test cases. Ergo, we
2429 if (SPName == Asm->MF->getFunction()->getName() ||
2430 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2431 CurrentFnDbgScope = WScope;
2437 getOrCreateAbstractScope(Scope);
2438 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2442 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2443 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2444 DILocation DL(InlinedAt);
2446 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2447 WScope->setParent(Parent);
2448 Parent->addScope(WScope);
2450 ConcreteScopes[InlinedAt] = WScope;
2455 /// hasValidLocation - Return true if debug location entry attached with
2456 /// machine instruction encodes valid location info.
2457 static bool hasValidLocation(LLVMContext &Ctx,
2458 const MachineInstr *MInsn,
2459 const MDNode *&Scope, const MDNode *&InlinedAt) {
2460 DebugLoc DL = MInsn->getDebugLoc();
2461 if (DL.isUnknown()) return false;
2463 const MDNode *S = DL.getScope(Ctx);
2465 // There is no need to create another DIE for compile unit. For all
2466 // other scopes, create one DbgScope now. This will be translated
2467 // into a scope DIE at the end.
2468 if (DIScope(S).isCompileUnit()) return false;
2471 InlinedAt = DL.getInlinedAt(Ctx);
2475 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2477 static void calculateDominanceGraph(DbgScope *Scope) {
2478 assert (Scope && "Unable to calculate scop edominance graph!");
2479 SmallVector<DbgScope *, 4> WorkStack;
2480 WorkStack.push_back(Scope);
2481 unsigned Counter = 0;
2482 while (!WorkStack.empty()) {
2483 DbgScope *WS = WorkStack.back();
2484 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2485 bool visitedChildren = false;
2486 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2487 SE = Children.end(); SI != SE; ++SI) {
2488 DbgScope *ChildScope = *SI;
2489 if (!ChildScope->getDFSOut()) {
2490 WorkStack.push_back(ChildScope);
2491 visitedChildren = true;
2492 ChildScope->setDFSIn(++Counter);
2496 if (!visitedChildren) {
2497 WorkStack.pop_back();
2498 WS->setDFSOut(++Counter);
2503 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2505 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2506 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2509 unsigned PrevDFSIn = 0;
2510 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2512 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2514 const MachineInstr *MInsn = II;
2515 const MDNode *Scope = NULL;
2516 const MDNode *InlinedAt = NULL;
2518 // Check if instruction has valid location information.
2519 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2523 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2524 MI2ScopeMap.find(MInsn);
2525 if (DI != MI2ScopeMap.end()) {
2526 DbgScope *S = DI->second;
2527 dbgs() << S->getDFSIn();
2528 PrevDFSIn = S->getDFSIn();
2530 dbgs() << PrevDFSIn;
2532 dbgs() << " [ x" << PrevDFSIn;
2540 /// extractScopeInformation - Scan machine instructions in this function
2541 /// and collect DbgScopes. Return true, if at least one scope was found.
2542 bool DwarfDebug::extractScopeInformation() {
2543 // If scope information was extracted using .dbg intrinsics then there is not
2544 // any need to extract these information by scanning each instruction.
2545 if (!DbgScopeMap.empty())
2548 // Scan each instruction and create scopes. First build working set of scopes.
2549 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2550 SmallVector<DbgRange, 4> MIRanges;
2551 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2552 const MDNode *PrevScope = NULL;
2553 const MDNode *PrevInlinedAt = NULL;
2554 const MachineInstr *RangeBeginMI = NULL;
2555 const MachineInstr *PrevMI = NULL;
2556 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2558 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2560 const MachineInstr *MInsn = II;
2561 const MDNode *Scope = NULL;
2562 const MDNode *InlinedAt = NULL;
2564 // Check if instruction has valid location information.
2565 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2570 // If scope has not changed then skip this instruction.
2571 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2577 // If we have alread seen a beginning of a instruction range and
2578 // current instruction scope does not match scope of first instruction
2579 // in this range then create a new instruction range.
2580 DbgRange R(RangeBeginMI, PrevMI);
2581 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2583 MIRanges.push_back(R);
2586 // This is a beginning of a new instruction range.
2587 RangeBeginMI = MInsn;
2589 // Reset previous markers.
2592 PrevInlinedAt = InlinedAt;
2596 // Create last instruction range.
2597 if (RangeBeginMI && PrevMI && PrevScope) {
2598 DbgRange R(RangeBeginMI, PrevMI);
2599 MIRanges.push_back(R);
2600 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2603 if (!CurrentFnDbgScope)
2606 calculateDominanceGraph(CurrentFnDbgScope);
2608 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2610 // Find ranges of instructions covered by each DbgScope;
2611 DbgScope *PrevDbgScope = NULL;
2612 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2613 RE = MIRanges.end(); RI != RE; ++RI) {
2614 const DbgRange &R = *RI;
2615 DbgScope *S = MI2ScopeMap.lookup(R.first);
2616 assert (S && "Lost DbgScope for a machine instruction!");
2617 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2618 PrevDbgScope->closeInsnRange(S);
2619 S->openInsnRange(R.first);
2620 S->extendInsnRange(R.second);
2625 PrevDbgScope->closeInsnRange();
2627 identifyScopeMarkers();
2629 return !DbgScopeMap.empty();
2632 /// identifyScopeMarkers() -
2633 /// Each DbgScope has first instruction and last instruction to mark beginning
2634 /// and end of a scope respectively. Create an inverse map that list scopes
2635 /// starts (and ends) with an instruction. One instruction may start (or end)
2636 /// multiple scopes. Ignore scopes that are not reachable.
2637 void DwarfDebug::identifyScopeMarkers() {
2638 SmallVector<DbgScope *, 4> WorkList;
2639 WorkList.push_back(CurrentFnDbgScope);
2640 while (!WorkList.empty()) {
2641 DbgScope *S = WorkList.pop_back_val();
2643 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2644 if (!Children.empty())
2645 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2646 SE = Children.end(); SI != SE; ++SI)
2647 WorkList.push_back(*SI);
2649 if (S->isAbstractScope())
2652 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2655 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2656 RE = Ranges.end(); RI != RE; ++RI) {
2657 assert(RI->first && "DbgRange does not have first instruction!");
2658 assert(RI->second && "DbgRange does not have second instruction!");
2659 InsnsEndScopeSet.insert(RI->second);
2664 /// FindFirstDebugLoc - Find the first debug location in the function. This
2665 /// is intended to be an approximation for the source position of the
2666 /// beginning of the function.
2667 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2668 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2670 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2671 MBBI != MBBE; ++MBBI) {
2672 DebugLoc DL = MBBI->getDebugLoc();
2673 if (!DL.isUnknown())
2679 /// beginFunction - Gather pre-function debug information. Assumes being
2680 /// emitted immediately after the function entry point.
2681 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2682 if (!MMI->hasDebugInfo()) return;
2683 if (!extractScopeInformation()) return;
2685 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2686 Asm->getFunctionNumber());
2687 // Assumes in correct section after the entry point.
2688 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2690 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2692 DebugLoc FDL = FindFirstDebugLoc(MF);
2693 if (FDL.isUnknown()) return;
2695 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2696 const MDNode *TheScope = 0;
2698 DISubprogram SP = getDISubprogram(Scope);
2701 Line = SP.getLineNumber();
2705 Line = FDL.getLine();
2710 recordSourceLine(Line, Col, TheScope);
2712 /// ProcessedArgs - Collection of arguments already processed.
2713 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2716 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2718 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2720 const MachineInstr *MI = II;
2721 DebugLoc DL = MI->getDebugLoc();
2722 if (MI->isDebugValue()) {
2723 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2724 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2725 if (!DV.Verify()) continue;
2726 // If DBG_VALUE is for a local variable then it needs a label.
2727 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2728 && isDbgValueInUndefinedReg(MI) == false)
2729 InsnNeedsLabel.insert(MI);
2730 // DBG_VALUE for inlined functions argument needs a label.
2731 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2732 describes(MF->getFunction()))
2733 InsnNeedsLabel.insert(MI);
2734 // DBG_VALUE indicating argument location change needs a label.
2735 else if (isDbgValueInUndefinedReg(MI) == false
2736 && !ProcessedArgs.insert(DV))
2737 InsnNeedsLabel.insert(MI);
2739 // If location is unknown then instruction needs a location only if
2740 // UnknownLocations flag is set.
2741 if (DL.isUnknown()) {
2742 if (UnknownLocations && !PrevLoc.isUnknown())
2743 InsnNeedsLabel.insert(MI);
2744 } else if (DL != PrevLoc)
2745 // Otherwise, instruction needs a location only if it is new location.
2746 InsnNeedsLabel.insert(MI);
2749 if (!DL.isUnknown() || UnknownLocations)
2753 PrevLabel = FunctionBeginSym;
2756 /// endFunction - Gather and emit post-function debug information.
2758 void DwarfDebug::endFunction(const MachineFunction *MF) {
2759 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2761 if (CurrentFnDbgScope) {
2763 // Define end label for subprogram.
2764 FunctionEndSym = Asm->GetTempSymbol("func_end",
2765 Asm->getFunctionNumber());
2766 // Assumes in correct section after the entry point.
2767 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2769 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2770 collectVariableInfo(MF, ProcessedVars);
2772 // Get function line info.
2773 if (!Lines.empty()) {
2774 // Get section line info.
2775 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2776 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2777 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2778 // Append the function info to section info.
2779 SectionLineInfos.insert(SectionLineInfos.end(),
2780 Lines.begin(), Lines.end());
2783 // Construct abstract scopes.
2784 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2785 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2786 DISubprogram SP((*AI)->getScopeNode());
2788 // Collect info for variables that were optimized out.
2789 StringRef FName = SP.getLinkageName();
2791 FName = SP.getName();
2792 const Module *M = MF->getFunction()->getParent();
2793 if (NamedMDNode *NMD =
2794 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2795 getRealLinkageName(FName)))) {
2796 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2797 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2798 if (!DV || !ProcessedVars.insert(DV))
2800 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2802 Scope->addVariable(new DbgVariable(DV));
2806 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2807 constructScopeDIE(*AI);
2810 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2812 if (!DisableFramePointerElim(*MF))
2813 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2814 dwarf::DW_FORM_flag, 1);
2817 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2818 MMI->getFrameMoves()));
2822 CurrentFnDbgScope = NULL;
2823 InsnNeedsLabel.clear();
2824 DbgVariableToFrameIndexMap.clear();
2825 VarToAbstractVarMap.clear();
2826 DbgVariableToDbgInstMap.clear();
2827 DbgVariableLabelsMap.clear();
2828 DeleteContainerSeconds(DbgScopeMap);
2829 InsnsEndScopeSet.clear();
2830 ConcreteScopes.clear();
2831 DeleteContainerSeconds(AbstractScopes);
2832 AbstractScopesList.clear();
2833 AbstractVariables.clear();
2834 LabelsBeforeInsn.clear();
2835 LabelsAfterInsn.clear();
2840 /// recordVariableFrameIndex - Record a variable's index.
2841 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2842 assert (V && "Invalid DbgVariable!");
2843 DbgVariableToFrameIndexMap[V] = Index;
2846 /// findVariableFrameIndex - Return true if frame index for the variable
2847 /// is found. Update FI to hold value of the index.
2848 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2849 assert (V && "Invalid DbgVariable!");
2850 DenseMap<const DbgVariable *, int>::iterator I =
2851 DbgVariableToFrameIndexMap.find(V);
2852 if (I == DbgVariableToFrameIndexMap.end())
2858 /// findVariableLabel - Find MCSymbol for the variable.
2859 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2860 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2861 = DbgVariableLabelsMap.find(V);
2862 if (I == DbgVariableLabelsMap.end())
2864 else return I->second;
2867 /// findDbgScope - Find DbgScope for the debug loc attached with an
2869 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2870 DbgScope *Scope = NULL;
2872 MInsn->getParent()->getParent()->getFunction()->getContext();
2873 DebugLoc DL = MInsn->getDebugLoc();
2878 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2879 Scope = ConcreteScopes.lookup(IA);
2881 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2887 /// recordSourceLine - Register a source line with debug info. Returns the
2888 /// unique label that was emitted and which provides correspondence to
2889 /// the source line list.
2890 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2897 DIDescriptor Scope(S);
2899 if (Scope.isCompileUnit()) {
2900 DICompileUnit CU(S);
2901 Dir = CU.getDirectory();
2902 Fn = CU.getFilename();
2903 } else if (Scope.isSubprogram()) {
2905 Dir = SP.getDirectory();
2906 Fn = SP.getFilename();
2907 } else if (Scope.isLexicalBlock()) {
2908 DILexicalBlock DB(S);
2909 Dir = DB.getDirectory();
2910 Fn = DB.getFilename();
2912 assert(0 && "Unexpected scope info");
2914 Src = GetOrCreateSourceID(Dir, Fn);
2917 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2918 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2920 Asm->OutStreamer.EmitLabel(Label);
2924 //===----------------------------------------------------------------------===//
2926 //===----------------------------------------------------------------------===//
2928 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2931 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2932 // Get the children.
2933 const std::vector<DIE *> &Children = Die->getChildren();
2935 // If not last sibling and has children then add sibling offset attribute.
2936 if (!Last && !Children.empty())
2937 Die->addSiblingOffset(DIEValueAllocator);
2939 // Record the abbreviation.
2940 assignAbbrevNumber(Die->getAbbrev());
2942 // Get the abbreviation for this DIE.
2943 unsigned AbbrevNumber = Die->getAbbrevNumber();
2944 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2947 Die->setOffset(Offset);
2949 // Start the size with the size of abbreviation code.
2950 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2952 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2953 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2955 // Size the DIE attribute values.
2956 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2957 // Size attribute value.
2958 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2960 // Size the DIE children if any.
2961 if (!Children.empty()) {
2962 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2963 "Children flag not set");
2965 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2966 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2968 // End of children marker.
2969 Offset += sizeof(int8_t);
2972 Die->setSize(Offset - Die->getOffset());
2976 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2978 void DwarfDebug::computeSizeAndOffsets() {
2979 unsigned PrevOffset = 0;
2980 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2981 E = CUMap.end(); I != E; ++I) {
2982 // Compute size of compile unit header.
2983 static unsigned Offset = PrevOffset +
2984 sizeof(int32_t) + // Length of Compilation Unit Info
2985 sizeof(int16_t) + // DWARF version number
2986 sizeof(int32_t) + // Offset Into Abbrev. Section
2987 sizeof(int8_t); // Pointer Size (in bytes)
2988 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2989 PrevOffset = Offset;
2993 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2994 /// temporary label to it if SymbolStem is specified.
2995 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2996 const char *SymbolStem = 0) {
2997 Asm->OutStreamer.SwitchSection(Section);
2998 if (!SymbolStem) return 0;
3000 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3001 Asm->OutStreamer.EmitLabel(TmpSym);
3005 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3006 /// the start of each one.
3007 void DwarfDebug::EmitSectionLabels() {
3008 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3010 // Dwarf sections base addresses.
3011 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3012 DwarfFrameSectionSym =
3013 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3016 DwarfInfoSectionSym =
3017 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3018 DwarfAbbrevSectionSym =
3019 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3020 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3022 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3023 EmitSectionSym(Asm, MacroInfo);
3025 DwarfDebugLineSectionSym =
3026 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3027 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3028 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3029 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3030 DwarfStrSectionSym =
3031 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3032 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3035 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3036 "section_debug_loc");
3038 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3039 EmitSectionSym(Asm, TLOF.getDataSection());
3042 /// emitDIE - Recusively Emits a debug information entry.
3044 void DwarfDebug::emitDIE(DIE *Die) {
3045 // Get the abbreviation for this DIE.
3046 unsigned AbbrevNumber = Die->getAbbrevNumber();
3047 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3049 // Emit the code (index) for the abbreviation.
3050 if (Asm->isVerbose())
3051 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3052 Twine::utohexstr(Die->getOffset()) + ":0x" +
3053 Twine::utohexstr(Die->getSize()) + " " +
3054 dwarf::TagString(Abbrev->getTag()));
3055 Asm->EmitULEB128(AbbrevNumber);
3057 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3058 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3060 // Emit the DIE attribute values.
3061 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3062 unsigned Attr = AbbrevData[i].getAttribute();
3063 unsigned Form = AbbrevData[i].getForm();
3064 assert(Form && "Too many attributes for DIE (check abbreviation)");
3066 if (Asm->isVerbose())
3067 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3070 case dwarf::DW_AT_sibling:
3071 Asm->EmitInt32(Die->getSiblingOffset());
3073 case dwarf::DW_AT_abstract_origin: {
3074 DIEEntry *E = cast<DIEEntry>(Values[i]);
3075 DIE *Origin = E->getEntry();
3076 unsigned Addr = Origin->getOffset();
3077 Asm->EmitInt32(Addr);
3080 case dwarf::DW_AT_ranges: {
3081 // DW_AT_range Value encodes offset in debug_range section.
3082 DIEInteger *V = cast<DIEInteger>(Values[i]);
3083 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3085 DwarfDebugRangeSectionSym,
3089 case dwarf::DW_AT_stmt_list: {
3090 Asm->EmitLabelDifference(CurrentLineSectionSym,
3091 DwarfDebugLineSectionSym, 4);
3094 case dwarf::DW_AT_location: {
3095 if (UseDotDebugLocEntry.count(Die) != 0) {
3096 DIELabel *L = cast<DIELabel>(Values[i]);
3097 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3099 Values[i]->EmitValue(Asm, Form);
3103 // Emit an attribute using the defined form.
3104 Values[i]->EmitValue(Asm, Form);
3109 // Emit the DIE children if any.
3110 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3111 const std::vector<DIE *> &Children = Die->getChildren();
3113 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3114 emitDIE(Children[j]);
3116 if (Asm->isVerbose())
3117 Asm->OutStreamer.AddComment("End Of Children Mark");
3122 /// emitDebugInfo - Emit the debug info section.
3124 void DwarfDebug::emitDebugInfo() {
3125 // Start debug info section.
3126 Asm->OutStreamer.SwitchSection(
3127 Asm->getObjFileLowering().getDwarfInfoSection());
3128 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3129 E = CUMap.end(); I != E; ++I) {
3130 CompileUnit *TheCU = I->second;
3131 DIE *Die = TheCU->getCUDie();
3133 // Emit the compile units header.
3134 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3137 // Emit size of content not including length itself
3138 unsigned ContentSize = Die->getSize() +
3139 sizeof(int16_t) + // DWARF version number
3140 sizeof(int32_t) + // Offset Into Abbrev. Section
3141 sizeof(int8_t) + // Pointer Size (in bytes)
3142 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3144 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3145 Asm->EmitInt32(ContentSize);
3146 Asm->OutStreamer.AddComment("DWARF version number");
3147 Asm->EmitInt16(dwarf::DWARF_VERSION);
3148 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3149 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3150 DwarfAbbrevSectionSym);
3151 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3152 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3155 // FIXME - extra padding for gdb bug.
3156 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3161 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3165 /// emitAbbreviations - Emit the abbreviation section.
3167 void DwarfDebug::emitAbbreviations() const {
3168 // Check to see if it is worth the effort.
3169 if (!Abbreviations.empty()) {
3170 // Start the debug abbrev section.
3171 Asm->OutStreamer.SwitchSection(
3172 Asm->getObjFileLowering().getDwarfAbbrevSection());
3174 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3176 // For each abbrevation.
3177 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3178 // Get abbreviation data
3179 const DIEAbbrev *Abbrev = Abbreviations[i];
3181 // Emit the abbrevations code (base 1 index.)
3182 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3184 // Emit the abbreviations data.
3188 // Mark end of abbreviations.
3189 Asm->EmitULEB128(0, "EOM(3)");
3191 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3195 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3196 /// the line matrix.
3198 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3199 // Define last address of section.
3200 Asm->OutStreamer.AddComment("Extended Op");
3203 Asm->OutStreamer.AddComment("Op size");
3204 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3205 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3206 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3208 Asm->OutStreamer.AddComment("Section end label");
3210 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3211 Asm->getTargetData().getPointerSize(),
3214 // Mark end of matrix.
3215 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3221 /// emitDebugLines - Emit source line information.
3223 void DwarfDebug::emitDebugLines() {
3224 // If the target is using .loc/.file, the assembler will be emitting the
3225 // .debug_line table automatically.
3226 if (Asm->MAI->hasDotLocAndDotFile())
3229 // Minimum line delta, thus ranging from -10..(255-10).
3230 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3231 // Maximum line delta, thus ranging from -10..(255-10).
3232 const int MaxLineDelta = 255 + MinLineDelta;
3234 // Start the dwarf line section.
3235 Asm->OutStreamer.SwitchSection(
3236 Asm->getObjFileLowering().getDwarfLineSection());
3238 // Construct the section header.
3239 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3240 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3241 Asm->OutStreamer.AddComment("Length of Source Line Info");
3242 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3243 Asm->GetTempSymbol("line_begin"), 4);
3244 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3246 Asm->OutStreamer.AddComment("DWARF version number");
3247 Asm->EmitInt16(dwarf::DWARF_VERSION);
3249 Asm->OutStreamer.AddComment("Prolog Length");
3250 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3251 Asm->GetTempSymbol("line_prolog_begin"), 4);
3252 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3254 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3256 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3258 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3259 Asm->EmitInt8(MinLineDelta);
3260 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3261 Asm->EmitInt8(MaxLineDelta);
3262 Asm->OutStreamer.AddComment("Special Opcode Base");
3263 Asm->EmitInt8(-MinLineDelta);
3265 // Line number standard opcode encodings argument count
3266 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3268 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3270 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3272 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3274 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3276 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3278 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3280 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3282 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3285 // Emit directories.
3286 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3287 const std::string &Dir = getSourceDirectoryName(DI);
3288 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3289 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3292 Asm->OutStreamer.AddComment("End of directories");
3296 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3297 // Remember source id starts at 1.
3298 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3299 const std::string &FN = getSourceFileName(Id.second);
3300 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3301 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3303 Asm->EmitULEB128(Id.first, "Directory #");
3304 Asm->EmitULEB128(0, "Mod date");
3305 Asm->EmitULEB128(0, "File size");
3308 Asm->OutStreamer.AddComment("End of files");
3311 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3313 // A sequence for each text section.
3314 unsigned SecSrcLinesSize = SectionSourceLines.size();
3316 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3317 // Isolate current sections line info.
3318 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3320 // Dwarf assumes we start with first line of first source file.
3321 unsigned Source = 1;
3324 // Construct rows of the address, source, line, column matrix.
3325 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3326 const SrcLineInfo &LineInfo = LineInfos[i];
3327 MCSymbol *Label = LineInfo.getLabel();
3328 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3330 if (Asm->isVerbose()) {
3331 std::pair<unsigned, unsigned> SrcID =
3332 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3333 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3335 Twine(getSourceFileName(SrcID.second)) +
3336 ":" + Twine(LineInfo.getLine()));
3339 // Define the line address.
3340 Asm->OutStreamer.AddComment("Extended Op");
3342 Asm->OutStreamer.AddComment("Op size");
3343 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3345 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3346 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3348 Asm->OutStreamer.AddComment("Location label");
3349 Asm->OutStreamer.EmitSymbolValue(Label,
3350 Asm->getTargetData().getPointerSize(),
3353 // If change of source, then switch to the new source.
3354 if (Source != LineInfo.getSourceID()) {
3355 Source = LineInfo.getSourceID();
3356 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3357 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3358 Asm->EmitULEB128(Source, "New Source");
3361 // If change of line.
3362 if (Line != LineInfo.getLine()) {
3363 // Determine offset.
3364 int Offset = LineInfo.getLine() - Line;
3365 int Delta = Offset - MinLineDelta;
3368 Line = LineInfo.getLine();
3370 // If delta is small enough and in range...
3371 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3372 // ... then use fast opcode.
3373 Asm->OutStreamer.AddComment("Line Delta");
3374 Asm->EmitInt8(Delta - MinLineDelta);
3376 // ... otherwise use long hand.
3377 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3378 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3379 Asm->EmitSLEB128(Offset, "Line Offset");
3380 Asm->OutStreamer.AddComment("DW_LNS_copy");
3381 Asm->EmitInt8(dwarf::DW_LNS_copy);
3384 // Copy the previous row (different address or source)
3385 Asm->OutStreamer.AddComment("DW_LNS_copy");
3386 Asm->EmitInt8(dwarf::DW_LNS_copy);
3390 emitEndOfLineMatrix(j + 1);
3393 if (SecSrcLinesSize == 0)
3394 // Because we're emitting a debug_line section, we still need a line
3395 // table. The linker and friends expect it to exist. If there's nothing to
3396 // put into it, emit an empty table.
3397 emitEndOfLineMatrix(1);
3399 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3402 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3404 void DwarfDebug::emitCommonDebugFrame() {
3405 if (!Asm->MAI->doesDwarfRequireFrameSection())
3408 int stackGrowth = Asm->getTargetData().getPointerSize();
3409 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3410 TargetFrameInfo::StackGrowsDown)
3413 // Start the dwarf frame section.
3414 Asm->OutStreamer.SwitchSection(
3415 Asm->getObjFileLowering().getDwarfFrameSection());
3417 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3418 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3419 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3420 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3422 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3423 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3424 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3425 Asm->OutStreamer.AddComment("CIE Version");
3426 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3427 Asm->OutStreamer.AddComment("CIE Augmentation");
3428 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3429 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3430 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3431 Asm->OutStreamer.AddComment("CIE RA Column");
3432 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3433 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3435 std::vector<MachineMove> Moves;
3436 RI->getInitialFrameState(Moves);
3438 Asm->EmitFrameMoves(Moves, 0, false);
3440 Asm->EmitAlignment(2);
3441 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3444 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3447 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3448 if (!Asm->MAI->doesDwarfRequireFrameSection())
3451 // Start the dwarf frame section.
3452 Asm->OutStreamer.SwitchSection(
3453 Asm->getObjFileLowering().getDwarfFrameSection());
3455 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3456 MCSymbol *DebugFrameBegin =
3457 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3458 MCSymbol *DebugFrameEnd =
3459 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3460 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3462 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3464 Asm->OutStreamer.AddComment("FDE CIE offset");
3465 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3466 DwarfFrameSectionSym);
3468 Asm->OutStreamer.AddComment("FDE initial location");
3469 MCSymbol *FuncBeginSym =
3470 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3471 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3472 Asm->getTargetData().getPointerSize(),
3476 Asm->OutStreamer.AddComment("FDE address range");
3477 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3478 FuncBeginSym, Asm->getTargetData().getPointerSize());
3480 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3482 Asm->EmitAlignment(2);
3483 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3486 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3488 void DwarfDebug::emitDebugPubNames() {
3489 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3490 E = CUMap.end(); I != E; ++I) {
3491 CompileUnit *TheCU = I->second;
3492 // Start the dwarf pubnames section.
3493 Asm->OutStreamer.SwitchSection(
3494 Asm->getObjFileLowering().getDwarfPubNamesSection());
3496 Asm->OutStreamer.AddComment("Length of Public Names Info");
3497 Asm->EmitLabelDifference(
3498 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3499 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3501 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3504 Asm->OutStreamer.AddComment("DWARF Version");
3505 Asm->EmitInt16(dwarf::DWARF_VERSION);
3507 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3508 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3509 DwarfInfoSectionSym);
3511 Asm->OutStreamer.AddComment("Compilation Unit Length");
3512 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3513 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3516 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3517 for (StringMap<DIE*>::const_iterator
3518 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3519 const char *Name = GI->getKeyData();
3520 DIE *Entity = GI->second;
3522 Asm->OutStreamer.AddComment("DIE offset");
3523 Asm->EmitInt32(Entity->getOffset());
3525 if (Asm->isVerbose())
3526 Asm->OutStreamer.AddComment("External Name");
3527 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3530 Asm->OutStreamer.AddComment("End Mark");
3532 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3537 void DwarfDebug::emitDebugPubTypes() {
3538 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3539 E = CUMap.end(); I != E; ++I) {
3540 CompileUnit *TheCU = I->second;
3541 // Start the dwarf pubnames section.
3542 Asm->OutStreamer.SwitchSection(
3543 Asm->getObjFileLowering().getDwarfPubTypesSection());
3544 Asm->OutStreamer.AddComment("Length of Public Types Info");
3545 Asm->EmitLabelDifference(
3546 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3547 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3549 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3552 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3553 Asm->EmitInt16(dwarf::DWARF_VERSION);
3555 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3556 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3557 DwarfInfoSectionSym);
3559 Asm->OutStreamer.AddComment("Compilation Unit Length");
3560 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3561 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3564 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3565 for (StringMap<DIE*>::const_iterator
3566 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3567 const char *Name = GI->getKeyData();
3568 DIE * Entity = GI->second;
3570 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3571 Asm->EmitInt32(Entity->getOffset());
3573 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3574 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3577 Asm->OutStreamer.AddComment("End Mark");
3579 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3584 /// emitDebugStr - Emit visible names into a debug str section.
3586 void DwarfDebug::emitDebugStr() {
3587 // Check to see if it is worth the effort.
3588 if (StringPool.empty()) return;
3590 // Start the dwarf str section.
3591 Asm->OutStreamer.SwitchSection(
3592 Asm->getObjFileLowering().getDwarfStrSection());
3594 // Get all of the string pool entries and put them in an array by their ID so
3595 // we can sort them.
3596 SmallVector<std::pair<unsigned,
3597 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3599 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3600 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3601 Entries.push_back(std::make_pair(I->second.second, &*I));
3603 array_pod_sort(Entries.begin(), Entries.end());
3605 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3606 // Emit a label for reference from debug information entries.
3607 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3609 // Emit the string itself.
3610 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3614 /// emitDebugLoc - Emit visible names into a debug loc section.
3616 void DwarfDebug::emitDebugLoc() {
3617 if (DotDebugLocEntries.empty())
3620 // Start the dwarf loc section.
3621 Asm->OutStreamer.SwitchSection(
3622 Asm->getObjFileLowering().getDwarfLocSection());
3623 unsigned char Size = Asm->getTargetData().getPointerSize();
3624 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3626 for (SmallVector<DotDebugLocEntry, 4>::iterator
3627 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3628 I != E; ++I, ++index) {
3629 DotDebugLocEntry Entry = *I;
3630 if (Entry.isEmpty()) {
3631 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3632 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3633 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3635 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3636 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3637 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3638 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3640 Asm->OutStreamer.AddComment("Loc expr size");
3642 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3644 Asm->OutStreamer.AddComment("Loc expr size");
3645 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3646 Asm->EmitInt8(dwarf::DW_OP_regx);
3647 Asm->EmitULEB128(Reg);
3653 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3655 void DwarfDebug::EmitDebugARanges() {
3656 // Start the dwarf aranges section.
3657 Asm->OutStreamer.SwitchSection(
3658 Asm->getObjFileLowering().getDwarfARangesSection());
3661 /// emitDebugRanges - Emit visible names into a debug ranges section.
3663 void DwarfDebug::emitDebugRanges() {
3664 // Start the dwarf ranges section.
3665 Asm->OutStreamer.SwitchSection(
3666 Asm->getObjFileLowering().getDwarfRangesSection());
3667 unsigned char Size = Asm->getTargetData().getPointerSize();
3668 for (SmallVector<const MCSymbol *, 8>::iterator
3669 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3672 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3674 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3678 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3680 void DwarfDebug::emitDebugMacInfo() {
3681 if (const MCSection *LineInfo =
3682 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3683 // Start the dwarf macinfo section.
3684 Asm->OutStreamer.SwitchSection(LineInfo);
3688 /// emitDebugInlineInfo - Emit inline info using following format.
3690 /// 1. length of section
3691 /// 2. Dwarf version number
3692 /// 3. address size.
3694 /// Entries (one "entry" for each function that was inlined):
3696 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3697 /// otherwise offset into __debug_str for regular function name.
3698 /// 2. offset into __debug_str section for regular function name.
3699 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3700 /// instances for the function.
3702 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3703 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3704 /// __debug_info section, and the low_pc is the starting address for the
3705 /// inlining instance.
3706 void DwarfDebug::emitDebugInlineInfo() {
3707 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3713 Asm->OutStreamer.SwitchSection(
3714 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3716 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3717 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3718 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3720 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3722 Asm->OutStreamer.AddComment("Dwarf Version");
3723 Asm->EmitInt16(dwarf::DWARF_VERSION);
3724 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3725 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3727 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3728 E = InlinedSPNodes.end(); I != E; ++I) {
3730 const MDNode *Node = *I;
3731 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3732 = InlineInfo.find(Node);
3733 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3734 DISubprogram SP(Node);
3735 StringRef LName = SP.getLinkageName();
3736 StringRef Name = SP.getName();
3738 Asm->OutStreamer.AddComment("MIPS linkage name");
3739 if (LName.empty()) {
3740 Asm->OutStreamer.EmitBytes(Name, 0);
3741 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3743 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3744 DwarfStrSectionSym);
3746 Asm->OutStreamer.AddComment("Function name");
3747 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3748 Asm->EmitULEB128(Labels.size(), "Inline count");
3750 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3751 LE = Labels.end(); LI != LE; ++LI) {
3752 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3753 Asm->EmitInt32(LI->second->getOffset());
3755 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3756 Asm->OutStreamer.EmitSymbolValue(LI->first,
3757 Asm->getTargetData().getPointerSize(),0);
3761 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));