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> &getDbgVariables() { 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->getDbgVariables();
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 assert (DirName.empty() == false && "Invalid directory name!");
1758 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1759 if (DI != DirectoryIdMap.end()) {
1760 DId = DI->getValue();
1762 DId = DirectoryNames.size() + 1;
1763 DirectoryIdMap[DirName] = DId;
1764 DirectoryNames.push_back(DirName);
1768 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1769 if (FI != SourceFileIdMap.end()) {
1770 FId = FI->getValue();
1772 FId = SourceFileNames.size() + 1;
1773 SourceFileIdMap[FileName] = FId;
1774 SourceFileNames.push_back(FileName);
1777 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1778 SourceIdMap.find(std::make_pair(DId, FId));
1779 if (SI != SourceIdMap.end())
1782 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1783 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1784 SourceIds.push_back(std::make_pair(DId, FId));
1789 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1790 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1791 CompileUnit *TheCU = getCompileUnit(NS);
1792 DIE *NDie = TheCU->getDIE(NS);
1795 NDie = new DIE(dwarf::DW_TAG_namespace);
1796 TheCU->insertDIE(NS, NDie);
1797 if (!NS.getName().empty())
1798 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1799 addSourceLine(NDie, NS);
1800 addToContextOwner(NDie, NS.getContext());
1804 /// constructCompileUnit - Create new CompileUnit for the given
1805 /// metadata node with tag DW_TAG_compile_unit.
1806 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1807 DICompileUnit DIUnit(N);
1808 StringRef FN = DIUnit.getFilename();
1809 StringRef Dir = DIUnit.getDirectory();
1810 unsigned ID = GetOrCreateSourceID(Dir, FN);
1812 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1813 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1814 DIUnit.getProducer());
1815 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1816 DIUnit.getLanguage());
1817 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1818 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1819 // simplifies debug range entries.
1820 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1821 // DW_AT_stmt_list is a offset of line number information for this
1822 // compile unit in debug_line section. This offset is calculated
1823 // during endMoudle().
1824 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1827 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1828 if (DIUnit.isOptimized())
1829 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1831 StringRef Flags = DIUnit.getFlags();
1833 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1835 unsigned RVer = DIUnit.getRunTimeVersion();
1837 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1838 dwarf::DW_FORM_data1, RVer);
1840 CompileUnit *NewCU = new CompileUnit(ID, Die);
1843 CUMap.insert(std::make_pair(N, NewCU));
1846 /// getCompielUnit - Get CompileUnit DIE.
1847 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1848 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1850 const MDNode *CUNode = NULL;
1851 if (D.isCompileUnit())
1853 else if (D.isSubprogram())
1854 CUNode = DISubprogram(N).getCompileUnit();
1855 else if (D.isType())
1856 CUNode = DIType(N).getCompileUnit();
1857 else if (D.isGlobalVariable())
1858 CUNode = DIGlobalVariable(N).getCompileUnit();
1859 else if (D.isVariable())
1860 CUNode = DIVariable(N).getCompileUnit();
1861 else if (D.isNameSpace())
1862 CUNode = DINameSpace(N).getCompileUnit();
1863 else if (D.isFile())
1864 CUNode = DIFile(N).getCompileUnit();
1868 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1869 = CUMap.find(CUNode);
1870 if (I == CUMap.end())
1876 /// constructGlobalVariableDIE - Construct global variable DIE.
1877 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1878 DIGlobalVariable DI_GV(N);
1880 // If debug information is malformed then ignore it.
1881 if (DI_GV.Verify() == false)
1884 // Check for pre-existence.
1885 CompileUnit *TheCU = getCompileUnit(N);
1886 if (TheCU->getDIE(DI_GV))
1889 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1894 TheCU->insertDIE(N, VariableDie);
1896 // Add to context owner.
1897 DIDescriptor GVContext = DI_GV.getContext();
1898 // Do not create specification DIE if context is either compile unit
1900 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1901 !GVContext.isFile() &&
1902 !isSubprogramContext(GVContext)) {
1903 // Create specification DIE.
1904 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1905 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1906 dwarf::DW_FORM_ref4, VariableDie);
1907 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1908 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1909 addLabel(Block, 0, dwarf::DW_FORM_udata,
1910 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1911 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1912 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1913 TheCU->addDie(VariableSpecDIE);
1915 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1916 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1917 addLabel(Block, 0, dwarf::DW_FORM_udata,
1918 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1919 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1921 addToContextOwner(VariableDie, GVContext);
1923 // Expose as global. FIXME - need to check external flag.
1924 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1926 DIType GTy = DI_GV.getType();
1927 if (GTy.isCompositeType() && !GTy.getName().empty()
1928 && !GTy.isForwardDecl()) {
1929 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1930 assert(Entry && "Missing global type!");
1931 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1936 /// construct SubprogramDIE - Construct subprogram DIE.
1937 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1940 // Check for pre-existence.
1941 CompileUnit *TheCU = getCompileUnit(N);
1942 if (TheCU->getDIE(N))
1945 if (!SP.isDefinition())
1946 // This is a method declaration which will be handled while constructing
1950 DIE *SubprogramDie = createSubprogramDIE(SP);
1953 TheCU->insertDIE(N, SubprogramDie);
1955 // Add to context owner.
1956 addToContextOwner(SubprogramDie, SP.getContext());
1958 // Expose as global.
1959 TheCU->addGlobal(SP.getName(), SubprogramDie);
1964 /// beginModule - Emit all Dwarf sections that should come prior to the
1965 /// content. Create global DIEs and emit initial debug info sections.
1966 /// This is inovked by the target AsmPrinter.
1967 void DwarfDebug::beginModule(Module *M) {
1968 if (DisableDebugInfoPrinting)
1971 DebugInfoFinder DbgFinder;
1972 DbgFinder.processModule(*M);
1974 bool HasDebugInfo = false;
1976 // Scan all the compile-units to see if there are any marked as the main unit.
1977 // if not, we do not generate debug info.
1978 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1979 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1980 if (DICompileUnit(*I).isMain()) {
1981 HasDebugInfo = true;
1986 if (!HasDebugInfo) return;
1988 // Tell MMI that we have debug info.
1989 MMI->setDebugInfoAvailability(true);
1991 // Emit initial sections.
1992 EmitSectionLabels();
1994 // Create all the compile unit DIEs.
1995 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1996 E = DbgFinder.compile_unit_end(); I != E; ++I)
1997 constructCompileUnit(*I);
1999 // Create DIEs for each subprogram.
2000 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2001 E = DbgFinder.subprogram_end(); I != E; ++I)
2002 constructSubprogramDIE(*I);
2004 // Create DIEs for each global variable.
2005 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2006 E = DbgFinder.global_variable_end(); I != E; ++I)
2007 constructGlobalVariableDIE(*I);
2009 // Prime section data.
2010 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2012 // Print out .file directives to specify files for .loc directives. These are
2013 // printed out early so that they precede any .loc directives.
2014 if (Asm->MAI->hasDotLocAndDotFile()) {
2015 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2016 // Remember source id starts at 1.
2017 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2018 // FIXME: don't use sys::path for this! This should not depend on the
2020 sys::Path FullPath(getSourceDirectoryName(Id.first));
2022 FullPath.appendComponent(getSourceFileName(Id.second));
2023 assert(AppendOk && "Could not append filename to directory!");
2025 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2030 /// endModule - Emit all Dwarf sections that should come after the content.
2032 void DwarfDebug::endModule() {
2033 if (!FirstCU) return;
2034 const Module *M = MMI->getModule();
2035 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2036 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2037 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2038 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2039 DISubprogram SP(AllSPs->getOperand(SI));
2040 if (!SP.Verify()) continue;
2042 // Collect info for variables that were optimized out.
2043 if (!SP.isDefinition()) continue;
2044 StringRef FName = SP.getLinkageName();
2046 FName = SP.getName();
2048 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2050 unsigned E = NMD->getNumOperands();
2052 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2053 DeadFnScopeMap[SP] = Scope;
2054 for (unsigned I = 0; I != E; ++I) {
2055 DIVariable DV(NMD->getOperand(I));
2056 if (!DV.Verify()) continue;
2057 Scope->addVariable(new DbgVariable(DV));
2060 // Construct subprogram DIE and add variables DIEs.
2061 constructSubprogramDIE(SP);
2062 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2063 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2064 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2065 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2067 ScopeDIE->addChild(VariableDIE);
2072 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2073 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2074 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2076 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2079 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2080 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2081 DIE *SPDie = CI->first;
2082 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2084 DIE *NDie = getCompileUnit(N)->getDIE(N);
2085 if (!NDie) continue;
2086 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2089 // Standard sections final addresses.
2090 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2091 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2092 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2093 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2095 // End text sections.
2096 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2097 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2098 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2101 // Emit common frame information.
2102 emitCommonDebugFrame();
2104 // Emit function debug frame information
2105 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2106 E = DebugFrames.end(); I != E; ++I)
2107 emitFunctionDebugFrame(*I);
2109 // Compute DIE offsets and sizes.
2110 computeSizeAndOffsets();
2112 // Emit source line correspondence into a debug line section.
2115 // Emit all the DIEs into a debug info section
2118 // Corresponding abbreviations into a abbrev section.
2119 emitAbbreviations();
2121 // Emit info into a debug pubnames section.
2122 emitDebugPubNames();
2124 // Emit info into a debug pubtypes section.
2125 emitDebugPubTypes();
2127 // Emit info into a debug loc section.
2130 // Emit info into a debug aranges section.
2133 // Emit info into a debug ranges section.
2136 // Emit info into a debug macinfo section.
2139 // Emit inline info.
2140 emitDebugInlineInfo();
2142 // Emit info into a debug str section.
2146 DeleteContainerSeconds(DeadFnScopeMap);
2147 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2148 E = CUMap.end(); I != E; ++I)
2150 FirstCU = NULL; // Reset for the next Module, if any.
2153 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2154 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2155 DebugLoc ScopeLoc) {
2157 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2159 return AbsDbgVariable;
2161 LLVMContext &Ctx = Var->getContext();
2162 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2166 AbsDbgVariable = new DbgVariable(Var);
2167 Scope->addVariable(AbsDbgVariable);
2168 AbstractVariables[Var] = AbsDbgVariable;
2169 return AbsDbgVariable;
2172 /// collectVariableInfoFromMMITable - Collect variable information from
2173 /// side table maintained by MMI.
2175 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2176 SmallPtrSet<const MDNode *, 16> &Processed) {
2177 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2178 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2179 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2180 VE = VMap.end(); VI != VE; ++VI) {
2181 const MDNode *Var = VI->first;
2183 Processed.insert(Var);
2185 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2187 DbgScope *Scope = 0;
2188 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2189 Scope = ConcreteScopes.lookup(IA);
2191 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2193 // If variable scope is not found then skip this variable.
2197 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2198 DbgVariable *RegVar = new DbgVariable(DV);
2199 recordVariableFrameIndex(RegVar, VP.first);
2200 Scope->addVariable(RegVar);
2201 if (AbsDbgVariable) {
2202 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2203 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2208 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2209 /// DBG_VALUE instruction, is in undefined reg.
2210 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2211 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2212 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2217 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2218 /// DBG_VALUE instruction, is in a defined reg.
2219 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2220 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2221 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2226 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2228 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2229 SmallPtrSet<const MDNode *, 16> &Processed) {
2231 /// collection info from MMI table.
2232 collectVariableInfoFromMMITable(MF, Processed);
2234 SmallVector<const MachineInstr *, 8> DbgValues;
2235 // Collect variable information from DBG_VALUE machine instructions;
2236 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2238 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2240 const MachineInstr *MInsn = II;
2241 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2243 DbgValues.push_back(MInsn);
2246 // This is a collection of DBV_VALUE instructions describing same variable.
2247 SmallVector<const MachineInstr *, 4> MultipleValues;
2248 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2249 E = DbgValues.end(); I != E; ++I) {
2250 const MachineInstr *MInsn = *I;
2251 MultipleValues.clear();
2252 if (isDbgValueInDefinedReg(MInsn))
2253 MultipleValues.push_back(MInsn);
2254 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2255 if (Processed.count(DV) != 0)
2258 const MachineInstr *PrevMI = MInsn;
2259 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2260 ME = DbgValues.end(); MI != ME; ++MI) {
2262 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2263 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2264 !PrevMI->isIdenticalTo(*MI))
2265 MultipleValues.push_back(*MI);
2269 DbgScope *Scope = findDbgScope(MInsn);
2270 bool CurFnArg = false;
2271 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2272 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2274 if (!Scope && CurFnArg)
2275 Scope = CurrentFnDbgScope;
2276 // If variable scope is not found then skip this variable.
2280 Processed.insert(DV);
2281 DbgVariable *RegVar = new DbgVariable(DV);
2282 Scope->addVariable(RegVar);
2284 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2285 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2286 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2287 VarToAbstractVarMap[RegVar] = AbsVar;
2289 if (MultipleValues.size() <= 1) {
2290 DbgVariableToDbgInstMap[RegVar] = MInsn;
2294 // handle multiple DBG_VALUE instructions describing one variable.
2295 if (DotDebugLocEntries.empty())
2296 RegVar->setDotDebugLocOffset(0);
2298 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2299 const MachineInstr *Begin = NULL;
2300 const MachineInstr *End = NULL;
2301 for (SmallVector<const MachineInstr *, 4>::iterator
2302 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2303 MVI != MVE; ++MVI) {
2309 MachineLocation MLoc;
2310 if (Begin->getNumOperands() == 3) {
2311 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2312 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2314 MLoc = Asm->getDebugValueLocation(Begin);
2316 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2317 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2319 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2322 if (MVI + 1 == MVE) {
2323 // If End is the last instruction then its value is valid
2324 // until the end of the funtion.
2325 MachineLocation EMLoc;
2326 if (End->getNumOperands() == 3) {
2327 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2328 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2330 EMLoc = Asm->getDebugValueLocation(End);
2333 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2336 DotDebugLocEntries.push_back(DotDebugLocEntry());
2339 // Collect info for variables that were optimized out.
2340 const Function *F = MF->getFunction();
2341 const Module *M = F->getParent();
2342 if (NamedMDNode *NMD =
2343 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2344 getRealLinkageName(F->getName())))) {
2345 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2346 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2347 if (!DV || !Processed.insert(DV))
2349 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2351 Scope->addVariable(new DbgVariable(DV));
2356 /// getLabelBeforeInsn - Return Label preceding the instruction.
2357 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2358 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2359 LabelsBeforeInsn.find(MI);
2360 if (I == LabelsBeforeInsn.end())
2361 // FunctionBeginSym always preceeds all the instruction in current function.
2362 return FunctionBeginSym;
2366 /// getLabelAfterInsn - Return Label immediately following the instruction.
2367 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2368 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2369 LabelsAfterInsn.find(MI);
2370 if (I == LabelsAfterInsn.end())
2375 /// beginScope - Process beginning of a scope.
2376 void DwarfDebug::beginScope(const MachineInstr *MI) {
2377 if (InsnNeedsLabel.count(MI) == 0) {
2378 LabelsBeforeInsn[MI] = PrevLabel;
2383 DebugLoc DL = MI->getDebugLoc();
2384 if (!DL.isUnknown()) {
2385 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2386 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2388 LabelsBeforeInsn[MI] = PrevLabel;
2392 // If location is unknown then use temp label for this DBG_VALUE
2394 if (MI->isDebugValue()) {
2395 PrevLabel = MMI->getContext().CreateTempSymbol();
2396 Asm->OutStreamer.EmitLabel(PrevLabel);
2397 LabelsBeforeInsn[MI] = PrevLabel;
2401 if (UnknownLocations) {
2402 PrevLabel = recordSourceLine(0, 0, 0);
2403 LabelsBeforeInsn[MI] = PrevLabel;
2407 assert (0 && "Instruction is not processed!");
2410 /// endScope - Process end of a scope.
2411 void DwarfDebug::endScope(const MachineInstr *MI) {
2412 if (InsnsEndScopeSet.count(MI) != 0) {
2413 // Emit a label if this instruction ends a scope.
2414 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2415 Asm->OutStreamer.EmitLabel(Label);
2416 LabelsAfterInsn[MI] = Label;
2420 /// getOrCreateDbgScope - Create DbgScope for the scope.
2421 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2422 const MDNode *InlinedAt) {
2424 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2427 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2428 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2429 if (DIDescriptor(Scope).isLexicalBlock()) {
2431 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2432 WScope->setParent(Parent);
2433 Parent->addScope(WScope);
2436 if (!WScope->getParent()) {
2437 StringRef SPName = DISubprogram(Scope).getLinkageName();
2438 // We used to check only for a linkage name, but that fails
2439 // since we began omitting the linkage name for private
2440 // functions. The new way is to check for the name in metadata,
2441 // but that's not supported in old .ll test cases. Ergo, we
2443 if (SPName == Asm->MF->getFunction()->getName() ||
2444 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2445 CurrentFnDbgScope = WScope;
2451 getOrCreateAbstractScope(Scope);
2452 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2456 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2457 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2458 DILocation DL(InlinedAt);
2460 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2461 WScope->setParent(Parent);
2462 Parent->addScope(WScope);
2464 ConcreteScopes[InlinedAt] = WScope;
2469 /// hasValidLocation - Return true if debug location entry attached with
2470 /// machine instruction encodes valid location info.
2471 static bool hasValidLocation(LLVMContext &Ctx,
2472 const MachineInstr *MInsn,
2473 const MDNode *&Scope, const MDNode *&InlinedAt) {
2474 DebugLoc DL = MInsn->getDebugLoc();
2475 if (DL.isUnknown()) return false;
2477 const MDNode *S = DL.getScope(Ctx);
2479 // There is no need to create another DIE for compile unit. For all
2480 // other scopes, create one DbgScope now. This will be translated
2481 // into a scope DIE at the end.
2482 if (DIScope(S).isCompileUnit()) return false;
2485 InlinedAt = DL.getInlinedAt(Ctx);
2489 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2491 static void calculateDominanceGraph(DbgScope *Scope) {
2492 assert (Scope && "Unable to calculate scop edominance graph!");
2493 SmallVector<DbgScope *, 4> WorkStack;
2494 WorkStack.push_back(Scope);
2495 unsigned Counter = 0;
2496 while (!WorkStack.empty()) {
2497 DbgScope *WS = WorkStack.back();
2498 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2499 bool visitedChildren = false;
2500 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2501 SE = Children.end(); SI != SE; ++SI) {
2502 DbgScope *ChildScope = *SI;
2503 if (!ChildScope->getDFSOut()) {
2504 WorkStack.push_back(ChildScope);
2505 visitedChildren = true;
2506 ChildScope->setDFSIn(++Counter);
2510 if (!visitedChildren) {
2511 WorkStack.pop_back();
2512 WS->setDFSOut(++Counter);
2517 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2519 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2520 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2523 unsigned PrevDFSIn = 0;
2524 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2526 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2528 const MachineInstr *MInsn = II;
2529 const MDNode *Scope = NULL;
2530 const MDNode *InlinedAt = NULL;
2532 // Check if instruction has valid location information.
2533 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2537 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2538 MI2ScopeMap.find(MInsn);
2539 if (DI != MI2ScopeMap.end()) {
2540 DbgScope *S = DI->second;
2541 dbgs() << S->getDFSIn();
2542 PrevDFSIn = S->getDFSIn();
2544 dbgs() << PrevDFSIn;
2546 dbgs() << " [ x" << PrevDFSIn;
2554 /// extractScopeInformation - Scan machine instructions in this function
2555 /// and collect DbgScopes. Return true, if at least one scope was found.
2556 bool DwarfDebug::extractScopeInformation() {
2557 // If scope information was extracted using .dbg intrinsics then there is not
2558 // any need to extract these information by scanning each instruction.
2559 if (!DbgScopeMap.empty())
2562 // Scan each instruction and create scopes. First build working set of scopes.
2563 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2564 SmallVector<DbgRange, 4> MIRanges;
2565 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2566 const MDNode *PrevScope = NULL;
2567 const MDNode *PrevInlinedAt = NULL;
2568 const MachineInstr *RangeBeginMI = NULL;
2569 const MachineInstr *PrevMI = NULL;
2570 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2572 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2574 const MachineInstr *MInsn = II;
2575 const MDNode *Scope = NULL;
2576 const MDNode *InlinedAt = NULL;
2578 // Check if instruction has valid location information.
2579 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2584 // If scope has not changed then skip this instruction.
2585 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2591 // If we have alread seen a beginning of a instruction range and
2592 // current instruction scope does not match scope of first instruction
2593 // in this range then create a new instruction range.
2594 DbgRange R(RangeBeginMI, PrevMI);
2595 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2597 MIRanges.push_back(R);
2600 // This is a beginning of a new instruction range.
2601 RangeBeginMI = MInsn;
2603 // Reset previous markers.
2606 PrevInlinedAt = InlinedAt;
2610 // Create last instruction range.
2611 if (RangeBeginMI && PrevMI && PrevScope) {
2612 DbgRange R(RangeBeginMI, PrevMI);
2613 MIRanges.push_back(R);
2614 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2617 if (!CurrentFnDbgScope)
2620 calculateDominanceGraph(CurrentFnDbgScope);
2622 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2624 // Find ranges of instructions covered by each DbgScope;
2625 DbgScope *PrevDbgScope = NULL;
2626 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2627 RE = MIRanges.end(); RI != RE; ++RI) {
2628 const DbgRange &R = *RI;
2629 DbgScope *S = MI2ScopeMap.lookup(R.first);
2630 assert (S && "Lost DbgScope for a machine instruction!");
2631 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2632 PrevDbgScope->closeInsnRange(S);
2633 S->openInsnRange(R.first);
2634 S->extendInsnRange(R.second);
2639 PrevDbgScope->closeInsnRange();
2641 identifyScopeMarkers();
2643 return !DbgScopeMap.empty();
2646 /// identifyScopeMarkers() -
2647 /// Each DbgScope has first instruction and last instruction to mark beginning
2648 /// and end of a scope respectively. Create an inverse map that list scopes
2649 /// starts (and ends) with an instruction. One instruction may start (or end)
2650 /// multiple scopes. Ignore scopes that are not reachable.
2651 void DwarfDebug::identifyScopeMarkers() {
2652 SmallVector<DbgScope *, 4> WorkList;
2653 WorkList.push_back(CurrentFnDbgScope);
2654 while (!WorkList.empty()) {
2655 DbgScope *S = WorkList.pop_back_val();
2657 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2658 if (!Children.empty())
2659 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2660 SE = Children.end(); SI != SE; ++SI)
2661 WorkList.push_back(*SI);
2663 if (S->isAbstractScope())
2666 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2669 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2670 RE = Ranges.end(); RI != RE; ++RI) {
2671 assert(RI->first && "DbgRange does not have first instruction!");
2672 assert(RI->second && "DbgRange does not have second instruction!");
2673 InsnsEndScopeSet.insert(RI->second);
2678 /// FindFirstDebugLoc - Find the first debug location in the function. This
2679 /// is intended to be an approximation for the source position of the
2680 /// beginning of the function.
2681 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2682 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2684 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2685 MBBI != MBBE; ++MBBI) {
2686 DebugLoc DL = MBBI->getDebugLoc();
2687 if (!DL.isUnknown())
2693 /// beginFunction - Gather pre-function debug information. Assumes being
2694 /// emitted immediately after the function entry point.
2695 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2696 if (!MMI->hasDebugInfo()) return;
2697 if (!extractScopeInformation()) return;
2699 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2700 Asm->getFunctionNumber());
2701 // Assumes in correct section after the entry point.
2702 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2704 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2706 DebugLoc FDL = FindFirstDebugLoc(MF);
2707 if (FDL.isUnknown()) return;
2709 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2710 const MDNode *TheScope = 0;
2712 DISubprogram SP = getDISubprogram(Scope);
2715 Line = SP.getLineNumber();
2719 Line = FDL.getLine();
2724 recordSourceLine(Line, Col, TheScope);
2726 /// ProcessedArgs - Collection of arguments already processed.
2727 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2730 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2732 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2734 const MachineInstr *MI = II;
2735 DebugLoc DL = MI->getDebugLoc();
2736 if (MI->isDebugValue()) {
2737 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2738 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2739 if (!DV.Verify()) continue;
2740 // If DBG_VALUE is for a local variable then it needs a label.
2741 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2742 && isDbgValueInUndefinedReg(MI) == false)
2743 InsnNeedsLabel.insert(MI);
2744 // DBG_VALUE for inlined functions argument needs a label.
2745 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2746 describes(MF->getFunction()))
2747 InsnNeedsLabel.insert(MI);
2748 // DBG_VALUE indicating argument location change needs a label.
2749 else if (isDbgValueInUndefinedReg(MI) == false
2750 && !ProcessedArgs.insert(DV))
2751 InsnNeedsLabel.insert(MI);
2753 // If location is unknown then instruction needs a location only if
2754 // UnknownLocations flag is set.
2755 if (DL.isUnknown()) {
2756 if (UnknownLocations && !PrevLoc.isUnknown())
2757 InsnNeedsLabel.insert(MI);
2758 } else if (DL != PrevLoc)
2759 // Otherwise, instruction needs a location only if it is new location.
2760 InsnNeedsLabel.insert(MI);
2763 if (!DL.isUnknown() || UnknownLocations)
2767 PrevLabel = FunctionBeginSym;
2770 /// endFunction - Gather and emit post-function debug information.
2772 void DwarfDebug::endFunction(const MachineFunction *MF) {
2773 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2775 if (CurrentFnDbgScope) {
2777 // Define end label for subprogram.
2778 FunctionEndSym = Asm->GetTempSymbol("func_end",
2779 Asm->getFunctionNumber());
2780 // Assumes in correct section after the entry point.
2781 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2783 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2784 collectVariableInfo(MF, ProcessedVars);
2786 // Get function line info.
2787 if (!Lines.empty()) {
2788 // Get section line info.
2789 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2790 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2791 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2792 // Append the function info to section info.
2793 SectionLineInfos.insert(SectionLineInfos.end(),
2794 Lines.begin(), Lines.end());
2797 // Construct abstract scopes.
2798 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2799 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2800 DISubprogram SP((*AI)->getScopeNode());
2802 // Collect info for variables that were optimized out.
2803 StringRef FName = SP.getLinkageName();
2805 FName = SP.getName();
2806 const Module *M = MF->getFunction()->getParent();
2807 if (NamedMDNode *NMD =
2808 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2809 getRealLinkageName(FName)))) {
2810 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2811 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2812 if (!DV || !ProcessedVars.insert(DV))
2814 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2816 Scope->addVariable(new DbgVariable(DV));
2820 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2821 constructScopeDIE(*AI);
2824 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2826 if (!DisableFramePointerElim(*MF))
2827 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2828 dwarf::DW_FORM_flag, 1);
2831 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2832 MMI->getFrameMoves()));
2836 CurrentFnDbgScope = NULL;
2837 InsnNeedsLabel.clear();
2838 DbgVariableToFrameIndexMap.clear();
2839 VarToAbstractVarMap.clear();
2840 DbgVariableToDbgInstMap.clear();
2841 DbgVariableLabelsMap.clear();
2842 DeleteContainerSeconds(DbgScopeMap);
2843 InsnsEndScopeSet.clear();
2844 ConcreteScopes.clear();
2845 DeleteContainerSeconds(AbstractScopes);
2846 AbstractScopesList.clear();
2847 AbstractVariables.clear();
2848 LabelsBeforeInsn.clear();
2849 LabelsAfterInsn.clear();
2854 /// recordVariableFrameIndex - Record a variable's index.
2855 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2856 assert (V && "Invalid DbgVariable!");
2857 DbgVariableToFrameIndexMap[V] = Index;
2860 /// findVariableFrameIndex - Return true if frame index for the variable
2861 /// is found. Update FI to hold value of the index.
2862 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2863 assert (V && "Invalid DbgVariable!");
2864 DenseMap<const DbgVariable *, int>::iterator I =
2865 DbgVariableToFrameIndexMap.find(V);
2866 if (I == DbgVariableToFrameIndexMap.end())
2872 /// findVariableLabel - Find MCSymbol for the variable.
2873 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2874 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2875 = DbgVariableLabelsMap.find(V);
2876 if (I == DbgVariableLabelsMap.end())
2878 else return I->second;
2881 /// findDbgScope - Find DbgScope for the debug loc attached with an
2883 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2884 DbgScope *Scope = NULL;
2886 MInsn->getParent()->getParent()->getFunction()->getContext();
2887 DebugLoc DL = MInsn->getDebugLoc();
2892 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2893 Scope = ConcreteScopes.lookup(IA);
2895 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2901 /// recordSourceLine - Register a source line with debug info. Returns the
2902 /// unique label that was emitted and which provides correspondence to
2903 /// the source line list.
2904 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2911 DIDescriptor Scope(S);
2913 if (Scope.isCompileUnit()) {
2914 DICompileUnit CU(S);
2915 Dir = CU.getDirectory();
2916 Fn = CU.getFilename();
2917 } else if (Scope.isSubprogram()) {
2919 Dir = SP.getDirectory();
2920 Fn = SP.getFilename();
2921 } else if (Scope.isLexicalBlock()) {
2922 DILexicalBlock DB(S);
2923 Dir = DB.getDirectory();
2924 Fn = DB.getFilename();
2926 assert(0 && "Unexpected scope info");
2928 Src = GetOrCreateSourceID(Dir, Fn);
2931 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2932 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2934 Asm->OutStreamer.EmitLabel(Label);
2938 //===----------------------------------------------------------------------===//
2940 //===----------------------------------------------------------------------===//
2942 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2945 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2946 // Get the children.
2947 const std::vector<DIE *> &Children = Die->getChildren();
2949 // If not last sibling and has children then add sibling offset attribute.
2950 if (!Last && !Children.empty())
2951 Die->addSiblingOffset(DIEValueAllocator);
2953 // Record the abbreviation.
2954 assignAbbrevNumber(Die->getAbbrev());
2956 // Get the abbreviation for this DIE.
2957 unsigned AbbrevNumber = Die->getAbbrevNumber();
2958 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2961 Die->setOffset(Offset);
2963 // Start the size with the size of abbreviation code.
2964 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2966 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2967 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2969 // Size the DIE attribute values.
2970 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2971 // Size attribute value.
2972 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2974 // Size the DIE children if any.
2975 if (!Children.empty()) {
2976 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2977 "Children flag not set");
2979 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2980 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2982 // End of children marker.
2983 Offset += sizeof(int8_t);
2986 Die->setSize(Offset - Die->getOffset());
2990 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2992 void DwarfDebug::computeSizeAndOffsets() {
2993 unsigned PrevOffset = 0;
2994 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2995 E = CUMap.end(); I != E; ++I) {
2996 // Compute size of compile unit header.
2997 static unsigned Offset = PrevOffset +
2998 sizeof(int32_t) + // Length of Compilation Unit Info
2999 sizeof(int16_t) + // DWARF version number
3000 sizeof(int32_t) + // Offset Into Abbrev. Section
3001 sizeof(int8_t); // Pointer Size (in bytes)
3002 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3003 PrevOffset = Offset;
3007 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3008 /// temporary label to it if SymbolStem is specified.
3009 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3010 const char *SymbolStem = 0) {
3011 Asm->OutStreamer.SwitchSection(Section);
3012 if (!SymbolStem) return 0;
3014 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3015 Asm->OutStreamer.EmitLabel(TmpSym);
3019 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3020 /// the start of each one.
3021 void DwarfDebug::EmitSectionLabels() {
3022 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3024 // Dwarf sections base addresses.
3025 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3026 DwarfFrameSectionSym =
3027 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3030 DwarfInfoSectionSym =
3031 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3032 DwarfAbbrevSectionSym =
3033 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3034 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3036 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3037 EmitSectionSym(Asm, MacroInfo);
3039 DwarfDebugLineSectionSym =
3040 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3041 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3042 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3043 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3044 DwarfStrSectionSym =
3045 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3046 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3049 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3050 "section_debug_loc");
3052 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3053 EmitSectionSym(Asm, TLOF.getDataSection());
3056 /// emitDIE - Recusively Emits a debug information entry.
3058 void DwarfDebug::emitDIE(DIE *Die) {
3059 // Get the abbreviation for this DIE.
3060 unsigned AbbrevNumber = Die->getAbbrevNumber();
3061 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3063 // Emit the code (index) for the abbreviation.
3064 if (Asm->isVerbose())
3065 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3066 Twine::utohexstr(Die->getOffset()) + ":0x" +
3067 Twine::utohexstr(Die->getSize()) + " " +
3068 dwarf::TagString(Abbrev->getTag()));
3069 Asm->EmitULEB128(AbbrevNumber);
3071 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3072 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3074 // Emit the DIE attribute values.
3075 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3076 unsigned Attr = AbbrevData[i].getAttribute();
3077 unsigned Form = AbbrevData[i].getForm();
3078 assert(Form && "Too many attributes for DIE (check abbreviation)");
3080 if (Asm->isVerbose())
3081 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3084 case dwarf::DW_AT_sibling:
3085 Asm->EmitInt32(Die->getSiblingOffset());
3087 case dwarf::DW_AT_abstract_origin: {
3088 DIEEntry *E = cast<DIEEntry>(Values[i]);
3089 DIE *Origin = E->getEntry();
3090 unsigned Addr = Origin->getOffset();
3091 Asm->EmitInt32(Addr);
3094 case dwarf::DW_AT_ranges: {
3095 // DW_AT_range Value encodes offset in debug_range section.
3096 DIEInteger *V = cast<DIEInteger>(Values[i]);
3097 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3099 DwarfDebugRangeSectionSym,
3103 case dwarf::DW_AT_stmt_list: {
3104 Asm->EmitLabelDifference(CurrentLineSectionSym,
3105 DwarfDebugLineSectionSym, 4);
3108 case dwarf::DW_AT_location: {
3109 if (UseDotDebugLocEntry.count(Die) != 0) {
3110 DIELabel *L = cast<DIELabel>(Values[i]);
3111 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3113 Values[i]->EmitValue(Asm, Form);
3117 // Emit an attribute using the defined form.
3118 Values[i]->EmitValue(Asm, Form);
3123 // Emit the DIE children if any.
3124 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3125 const std::vector<DIE *> &Children = Die->getChildren();
3127 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3128 emitDIE(Children[j]);
3130 if (Asm->isVerbose())
3131 Asm->OutStreamer.AddComment("End Of Children Mark");
3136 /// emitDebugInfo - Emit the debug info section.
3138 void DwarfDebug::emitDebugInfo() {
3139 // Start debug info section.
3140 Asm->OutStreamer.SwitchSection(
3141 Asm->getObjFileLowering().getDwarfInfoSection());
3142 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3143 E = CUMap.end(); I != E; ++I) {
3144 CompileUnit *TheCU = I->second;
3145 DIE *Die = TheCU->getCUDie();
3147 // Emit the compile units header.
3148 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3151 // Emit size of content not including length itself
3152 unsigned ContentSize = Die->getSize() +
3153 sizeof(int16_t) + // DWARF version number
3154 sizeof(int32_t) + // Offset Into Abbrev. Section
3155 sizeof(int8_t) + // Pointer Size (in bytes)
3156 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3158 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3159 Asm->EmitInt32(ContentSize);
3160 Asm->OutStreamer.AddComment("DWARF version number");
3161 Asm->EmitInt16(dwarf::DWARF_VERSION);
3162 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3163 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3164 DwarfAbbrevSectionSym);
3165 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3166 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3169 // FIXME - extra padding for gdb bug.
3170 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3175 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3179 /// emitAbbreviations - Emit the abbreviation section.
3181 void DwarfDebug::emitAbbreviations() const {
3182 // Check to see if it is worth the effort.
3183 if (!Abbreviations.empty()) {
3184 // Start the debug abbrev section.
3185 Asm->OutStreamer.SwitchSection(
3186 Asm->getObjFileLowering().getDwarfAbbrevSection());
3188 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3190 // For each abbrevation.
3191 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3192 // Get abbreviation data
3193 const DIEAbbrev *Abbrev = Abbreviations[i];
3195 // Emit the abbrevations code (base 1 index.)
3196 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3198 // Emit the abbreviations data.
3202 // Mark end of abbreviations.
3203 Asm->EmitULEB128(0, "EOM(3)");
3205 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3209 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3210 /// the line matrix.
3212 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3213 // Define last address of section.
3214 Asm->OutStreamer.AddComment("Extended Op");
3217 Asm->OutStreamer.AddComment("Op size");
3218 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3219 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3220 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3222 Asm->OutStreamer.AddComment("Section end label");
3224 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3225 Asm->getTargetData().getPointerSize(),
3228 // Mark end of matrix.
3229 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3235 /// emitDebugLines - Emit source line information.
3237 void DwarfDebug::emitDebugLines() {
3238 // If the target is using .loc/.file, the assembler will be emitting the
3239 // .debug_line table automatically.
3240 if (Asm->MAI->hasDotLocAndDotFile())
3243 // Minimum line delta, thus ranging from -10..(255-10).
3244 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3245 // Maximum line delta, thus ranging from -10..(255-10).
3246 const int MaxLineDelta = 255 + MinLineDelta;
3248 // Start the dwarf line section.
3249 Asm->OutStreamer.SwitchSection(
3250 Asm->getObjFileLowering().getDwarfLineSection());
3252 // Construct the section header.
3253 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3254 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3255 Asm->OutStreamer.AddComment("Length of Source Line Info");
3256 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3257 Asm->GetTempSymbol("line_begin"), 4);
3258 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3260 Asm->OutStreamer.AddComment("DWARF version number");
3261 Asm->EmitInt16(dwarf::DWARF_VERSION);
3263 Asm->OutStreamer.AddComment("Prolog Length");
3264 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3265 Asm->GetTempSymbol("line_prolog_begin"), 4);
3266 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3268 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3270 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3272 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3273 Asm->EmitInt8(MinLineDelta);
3274 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3275 Asm->EmitInt8(MaxLineDelta);
3276 Asm->OutStreamer.AddComment("Special Opcode Base");
3277 Asm->EmitInt8(-MinLineDelta);
3279 // Line number standard opcode encodings argument count
3280 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3282 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3284 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3286 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3288 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3290 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3292 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3294 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3296 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3299 // Emit directories.
3300 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3301 const std::string &Dir = getSourceDirectoryName(DI);
3302 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3303 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3306 Asm->OutStreamer.AddComment("End of directories");
3310 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3311 // Remember source id starts at 1.
3312 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3313 const std::string &FN = getSourceFileName(Id.second);
3314 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3315 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3317 Asm->EmitULEB128(Id.first, "Directory #");
3318 Asm->EmitULEB128(0, "Mod date");
3319 Asm->EmitULEB128(0, "File size");
3322 Asm->OutStreamer.AddComment("End of files");
3325 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3327 // A sequence for each text section.
3328 unsigned SecSrcLinesSize = SectionSourceLines.size();
3330 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3331 // Isolate current sections line info.
3332 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3334 // Dwarf assumes we start with first line of first source file.
3335 unsigned Source = 1;
3338 // Construct rows of the address, source, line, column matrix.
3339 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3340 const SrcLineInfo &LineInfo = LineInfos[i];
3341 MCSymbol *Label = LineInfo.getLabel();
3342 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3344 if (Asm->isVerbose()) {
3345 std::pair<unsigned, unsigned> SrcID =
3346 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3347 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3349 Twine(getSourceFileName(SrcID.second)) +
3350 ":" + Twine(LineInfo.getLine()));
3353 // Define the line address.
3354 Asm->OutStreamer.AddComment("Extended Op");
3356 Asm->OutStreamer.AddComment("Op size");
3357 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3359 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3360 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3362 Asm->OutStreamer.AddComment("Location label");
3363 Asm->OutStreamer.EmitSymbolValue(Label,
3364 Asm->getTargetData().getPointerSize(),
3367 // If change of source, then switch to the new source.
3368 if (Source != LineInfo.getSourceID()) {
3369 Source = LineInfo.getSourceID();
3370 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3371 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3372 Asm->EmitULEB128(Source, "New Source");
3375 // If change of line.
3376 if (Line != LineInfo.getLine()) {
3377 // Determine offset.
3378 int Offset = LineInfo.getLine() - Line;
3379 int Delta = Offset - MinLineDelta;
3382 Line = LineInfo.getLine();
3384 // If delta is small enough and in range...
3385 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3386 // ... then use fast opcode.
3387 Asm->OutStreamer.AddComment("Line Delta");
3388 Asm->EmitInt8(Delta - MinLineDelta);
3390 // ... otherwise use long hand.
3391 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3392 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3393 Asm->EmitSLEB128(Offset, "Line Offset");
3394 Asm->OutStreamer.AddComment("DW_LNS_copy");
3395 Asm->EmitInt8(dwarf::DW_LNS_copy);
3398 // Copy the previous row (different address or source)
3399 Asm->OutStreamer.AddComment("DW_LNS_copy");
3400 Asm->EmitInt8(dwarf::DW_LNS_copy);
3404 emitEndOfLineMatrix(j + 1);
3407 if (SecSrcLinesSize == 0)
3408 // Because we're emitting a debug_line section, we still need a line
3409 // table. The linker and friends expect it to exist. If there's nothing to
3410 // put into it, emit an empty table.
3411 emitEndOfLineMatrix(1);
3413 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3416 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3418 void DwarfDebug::emitCommonDebugFrame() {
3419 if (!Asm->MAI->doesDwarfRequireFrameSection())
3422 int stackGrowth = Asm->getTargetData().getPointerSize();
3423 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3424 TargetFrameInfo::StackGrowsDown)
3427 // Start the dwarf frame section.
3428 Asm->OutStreamer.SwitchSection(
3429 Asm->getObjFileLowering().getDwarfFrameSection());
3431 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3432 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3433 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3434 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3436 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3437 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3438 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3439 Asm->OutStreamer.AddComment("CIE Version");
3440 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3441 Asm->OutStreamer.AddComment("CIE Augmentation");
3442 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3443 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3444 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3445 Asm->OutStreamer.AddComment("CIE RA Column");
3446 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3447 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3449 std::vector<MachineMove> Moves;
3450 RI->getInitialFrameState(Moves);
3452 Asm->EmitFrameMoves(Moves, 0, false);
3454 Asm->EmitAlignment(2);
3455 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3458 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3461 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3462 if (!Asm->MAI->doesDwarfRequireFrameSection())
3465 // Start the dwarf frame section.
3466 Asm->OutStreamer.SwitchSection(
3467 Asm->getObjFileLowering().getDwarfFrameSection());
3469 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3470 MCSymbol *DebugFrameBegin =
3471 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3472 MCSymbol *DebugFrameEnd =
3473 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3474 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3476 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3478 Asm->OutStreamer.AddComment("FDE CIE offset");
3479 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3480 DwarfFrameSectionSym);
3482 Asm->OutStreamer.AddComment("FDE initial location");
3483 MCSymbol *FuncBeginSym =
3484 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3485 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3486 Asm->getTargetData().getPointerSize(),
3490 Asm->OutStreamer.AddComment("FDE address range");
3491 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3492 FuncBeginSym, Asm->getTargetData().getPointerSize());
3494 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3496 Asm->EmitAlignment(2);
3497 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3500 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3502 void DwarfDebug::emitDebugPubNames() {
3503 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3504 E = CUMap.end(); I != E; ++I) {
3505 CompileUnit *TheCU = I->second;
3506 // Start the dwarf pubnames section.
3507 Asm->OutStreamer.SwitchSection(
3508 Asm->getObjFileLowering().getDwarfPubNamesSection());
3510 Asm->OutStreamer.AddComment("Length of Public Names Info");
3511 Asm->EmitLabelDifference(
3512 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3513 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3515 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3518 Asm->OutStreamer.AddComment("DWARF Version");
3519 Asm->EmitInt16(dwarf::DWARF_VERSION);
3521 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3522 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3523 DwarfInfoSectionSym);
3525 Asm->OutStreamer.AddComment("Compilation Unit Length");
3526 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3527 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3530 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3531 for (StringMap<DIE*>::const_iterator
3532 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3533 const char *Name = GI->getKeyData();
3534 DIE *Entity = GI->second;
3536 Asm->OutStreamer.AddComment("DIE offset");
3537 Asm->EmitInt32(Entity->getOffset());
3539 if (Asm->isVerbose())
3540 Asm->OutStreamer.AddComment("External Name");
3541 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3544 Asm->OutStreamer.AddComment("End Mark");
3546 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3551 void DwarfDebug::emitDebugPubTypes() {
3552 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3553 E = CUMap.end(); I != E; ++I) {
3554 CompileUnit *TheCU = I->second;
3555 // Start the dwarf pubnames section.
3556 Asm->OutStreamer.SwitchSection(
3557 Asm->getObjFileLowering().getDwarfPubTypesSection());
3558 Asm->OutStreamer.AddComment("Length of Public Types Info");
3559 Asm->EmitLabelDifference(
3560 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3561 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3563 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3566 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3567 Asm->EmitInt16(dwarf::DWARF_VERSION);
3569 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3570 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3571 DwarfInfoSectionSym);
3573 Asm->OutStreamer.AddComment("Compilation Unit Length");
3574 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3575 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3578 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3579 for (StringMap<DIE*>::const_iterator
3580 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3581 const char *Name = GI->getKeyData();
3582 DIE * Entity = GI->second;
3584 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3585 Asm->EmitInt32(Entity->getOffset());
3587 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3588 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3591 Asm->OutStreamer.AddComment("End Mark");
3593 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3598 /// emitDebugStr - Emit visible names into a debug str section.
3600 void DwarfDebug::emitDebugStr() {
3601 // Check to see if it is worth the effort.
3602 if (StringPool.empty()) return;
3604 // Start the dwarf str section.
3605 Asm->OutStreamer.SwitchSection(
3606 Asm->getObjFileLowering().getDwarfStrSection());
3608 // Get all of the string pool entries and put them in an array by their ID so
3609 // we can sort them.
3610 SmallVector<std::pair<unsigned,
3611 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3613 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3614 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3615 Entries.push_back(std::make_pair(I->second.second, &*I));
3617 array_pod_sort(Entries.begin(), Entries.end());
3619 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3620 // Emit a label for reference from debug information entries.
3621 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3623 // Emit the string itself.
3624 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3628 /// emitDebugLoc - Emit visible names into a debug loc section.
3630 void DwarfDebug::emitDebugLoc() {
3631 if (DotDebugLocEntries.empty())
3634 // Start the dwarf loc section.
3635 Asm->OutStreamer.SwitchSection(
3636 Asm->getObjFileLowering().getDwarfLocSection());
3637 unsigned char Size = Asm->getTargetData().getPointerSize();
3638 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3640 for (SmallVector<DotDebugLocEntry, 4>::iterator
3641 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3642 I != E; ++I, ++index) {
3643 DotDebugLocEntry Entry = *I;
3644 if (Entry.isEmpty()) {
3645 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3646 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3647 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3649 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3650 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3651 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3652 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3653 if (int Offset = Entry.Loc.getOffset()) {
3654 // If the value is at a certain offset from frame register then
3656 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3657 Asm->OutStreamer.AddComment("Loc expr size");
3658 Asm->EmitInt16(1 + OffsetSize);
3659 Asm->OutStreamer.AddComment(
3660 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3661 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3662 Asm->OutStreamer.AddComment("Offset");
3663 Asm->EmitSLEB128(Offset);
3666 Asm->OutStreamer.AddComment("Loc expr size");
3668 Asm->OutStreamer.AddComment(
3669 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3670 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3672 Asm->OutStreamer.AddComment("Loc expr size");
3673 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3674 Asm->EmitInt8(dwarf::DW_OP_regx);
3675 Asm->EmitULEB128(Reg);
3682 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3684 void DwarfDebug::EmitDebugARanges() {
3685 // Start the dwarf aranges section.
3686 Asm->OutStreamer.SwitchSection(
3687 Asm->getObjFileLowering().getDwarfARangesSection());
3690 /// emitDebugRanges - Emit visible names into a debug ranges section.
3692 void DwarfDebug::emitDebugRanges() {
3693 // Start the dwarf ranges section.
3694 Asm->OutStreamer.SwitchSection(
3695 Asm->getObjFileLowering().getDwarfRangesSection());
3696 unsigned char Size = Asm->getTargetData().getPointerSize();
3697 for (SmallVector<const MCSymbol *, 8>::iterator
3698 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3701 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3703 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3707 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3709 void DwarfDebug::emitDebugMacInfo() {
3710 if (const MCSection *LineInfo =
3711 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3712 // Start the dwarf macinfo section.
3713 Asm->OutStreamer.SwitchSection(LineInfo);
3717 /// emitDebugInlineInfo - Emit inline info using following format.
3719 /// 1. length of section
3720 /// 2. Dwarf version number
3721 /// 3. address size.
3723 /// Entries (one "entry" for each function that was inlined):
3725 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3726 /// otherwise offset into __debug_str for regular function name.
3727 /// 2. offset into __debug_str section for regular function name.
3728 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3729 /// instances for the function.
3731 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3732 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3733 /// __debug_info section, and the low_pc is the starting address for the
3734 /// inlining instance.
3735 void DwarfDebug::emitDebugInlineInfo() {
3736 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3742 Asm->OutStreamer.SwitchSection(
3743 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3745 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3746 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3747 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3749 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3751 Asm->OutStreamer.AddComment("Dwarf Version");
3752 Asm->EmitInt16(dwarf::DWARF_VERSION);
3753 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3754 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3756 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3757 E = InlinedSPNodes.end(); I != E; ++I) {
3759 const MDNode *Node = *I;
3760 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3761 = InlineInfo.find(Node);
3762 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3763 DISubprogram SP(Node);
3764 StringRef LName = SP.getLinkageName();
3765 StringRef Name = SP.getName();
3767 Asm->OutStreamer.AddComment("MIPS linkage name");
3768 if (LName.empty()) {
3769 Asm->OutStreamer.EmitBytes(Name, 0);
3770 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3772 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3773 DwarfStrSectionSym);
3775 Asm->OutStreamer.AddComment("Function name");
3776 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3777 Asm->EmitULEB128(Labels.size(), "Inline count");
3779 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3780 LE = Labels.end(); LI != LE; ++LI) {
3781 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3782 Asm->EmitInt32(LI->second->getOffset());
3784 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3785 Asm->OutStreamer.EmitSymbolValue(LI->first,
3786 Asm->getTargetData().getPointerSize(),0);
3790 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));