1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
49 cl::desc("Disable debug info printing"));
51 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58 } // end anonymous namespace
60 //===----------------------------------------------------------------------===//
62 /// Configuration values for initial hash set sizes (log2).
64 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
68 //===----------------------------------------------------------------------===//
69 /// CompileUnit - This dwarf writer support class manages information associate
70 /// with a source file.
72 /// ID - File identifier for source.
76 /// Die - Compile unit debug information entry.
78 const OwningPtr<DIE> CUDie;
80 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
83 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
84 /// variables to debug information entries.
85 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
87 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
89 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
91 /// Globals - A map of globally visible named entities for this unit.
93 StringMap<DIE*> Globals;
95 /// GlobalTypes - A map of globally visible types for this unit.
97 StringMap<DIE*> GlobalTypes;
100 CompileUnit(unsigned I, DIE *D)
101 : ID(I), CUDie(D), IndexTyDie(0) {}
104 unsigned getID() const { return ID; }
105 DIE* getCUDie() const { return CUDie.get(); }
106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
109 /// hasContent - Return true if this compile unit has something to write out.
111 bool hasContent() const { return !CUDie->getChildren().empty(); }
113 /// addGlobal - Add a new global entity to the compile unit.
115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
117 /// addGlobalType - Add a new global type to the compile unit.
119 void addGlobalType(StringRef Name, DIE *Die) {
120 GlobalTypes[Name] = Die;
123 /// getDIE - Returns the debug information entry map slot for the
124 /// specified debug variable.
125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
127 /// insertDIE - Insert DIE into the map.
128 void insertDIE(const MDNode *N, DIE *D) {
129 MDNodeToDieMap.insert(std::make_pair(N, D));
132 /// getDIEEntry - Returns the debug information entry for the speciefied
134 DIEEntry *getDIEEntry(const MDNode *N) {
135 DenseMap<const MDNode *, DIEEntry *>::iterator I =
136 MDNodeToDIEEntryMap.find(N);
137 if (I == MDNodeToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 DIE *TheDIE; // Variable DIE.
172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
174 // AbsVar may be NULL.
175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
178 DIVariable getVariable() const { return Var; }
179 void setDIE(DIE *D) { TheDIE = D; }
180 DIE *getDIE() const { return TheDIE; }
181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
185 //===----------------------------------------------------------------------===//
186 /// DbgRange - This is used to track range of instructions with identical
187 /// debug info scope.
189 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
191 //===----------------------------------------------------------------------===//
192 /// DbgScope - This class is used to track scope information.
195 DbgScope *Parent; // Parent to this scope.
196 DIDescriptor Desc; // Debug info descriptor for scope.
197 // Location at which this scope is inlined.
198 AssertingVH<const MDNode> InlinedAtLocation;
199 bool AbstractScope; // Abstract Scope
200 const MachineInstr *LastInsn; // Last instruction of this scope.
201 const MachineInstr *FirstInsn; // First instruction of this scope.
202 unsigned DFSIn, DFSOut;
203 // Scopes defined in scope. Contents not owned.
204 SmallVector<DbgScope *, 4> Scopes;
205 // Variables declared in scope. Contents owned.
206 SmallVector<DbgVariable *, 8> Variables;
207 SmallVector<DbgRange, 4> Ranges;
208 // Private state for dump()
209 mutable unsigned IndentLevel;
211 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
212 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
213 LastInsn(0), FirstInsn(0),
214 DFSIn(0), DFSOut(0), IndentLevel(0) {}
218 DbgScope *getParent() const { return Parent; }
219 void setParent(DbgScope *P) { Parent = P; }
220 DIDescriptor getDesc() const { return Desc; }
221 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
222 const MDNode *getScopeNode() const { return Desc; }
223 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
224 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
225 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
227 /// openInsnRange - This scope covers instruction range starting from MI.
228 void openInsnRange(const MachineInstr *MI) {
233 Parent->openInsnRange(MI);
236 /// extendInsnRange - Extend the current instruction range covered by
238 void extendInsnRange(const MachineInstr *MI) {
239 assert (FirstInsn && "MI Range is not open!");
242 Parent->extendInsnRange(MI);
245 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
246 /// until now. This is used when a new scope is encountered while walking
247 /// machine instructions.
248 void closeInsnRange(DbgScope *NewScope = NULL) {
249 assert (LastInsn && "Last insn missing!");
250 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
253 // If Parent dominates NewScope then do not close Parent's instruction
255 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
256 Parent->closeInsnRange(NewScope);
259 void setAbstractScope() { AbstractScope = true; }
260 bool isAbstractScope() const { return AbstractScope; }
262 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
263 unsigned getDFSOut() const { return DFSOut; }
264 void setDFSOut(unsigned O) { DFSOut = O; }
265 unsigned getDFSIn() const { return DFSIn; }
266 void setDFSIn(unsigned I) { DFSIn = I; }
267 bool dominates(const DbgScope *S) {
270 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
275 /// addScope - Add a scope to the scope.
277 void addScope(DbgScope *S) { Scopes.push_back(S); }
279 /// addVariable - Add a variable to the scope.
281 void addVariable(DbgVariable *V) { Variables.push_back(V); }
288 } // end llvm namespace
291 void DbgScope::dump() const {
292 raw_ostream &err = dbgs();
293 err.indent(IndentLevel);
294 const MDNode *N = Desc;
297 err << "Abstract Scope\n";
301 err << "Children ...\n";
302 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
303 if (Scopes[i] != this)
310 DbgScope::~DbgScope() {
311 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
315 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
316 : Asm(A), MMI(Asm->MMI), FirstCU(0),
317 AbbreviationsSet(InitAbbreviationsSetSize),
318 CurrentFnDbgScope(0), PrevLabel(NULL) {
319 NextStringPoolNumber = 0;
321 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
322 DwarfStrSectionSym = TextSectionSym = 0;
323 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
324 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
325 FunctionBeginSym = FunctionEndSym = 0;
326 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
328 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
332 DwarfDebug::~DwarfDebug() {
333 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
334 DIEBlocks[j]->~DIEBlock();
337 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
338 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
339 if (Entry.first) return Entry.first;
341 Entry.second = NextStringPoolNumber++;
342 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
346 /// assignAbbrevNumber - Define a unique number for the abbreviation.
348 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
349 // Profile the node so that we can make it unique.
353 // Check the set for priors.
354 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
356 // If it's newly added.
357 if (InSet == &Abbrev) {
358 // Add to abbreviation list.
359 Abbreviations.push_back(&Abbrev);
361 // Assign the vector position + 1 as its number.
362 Abbrev.setNumber(Abbreviations.size());
364 // Assign existing abbreviation number.
365 Abbrev.setNumber(InSet->getNumber());
369 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
370 /// information entry.
371 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
372 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
376 /// addUInt - Add an unsigned integer attribute data and value.
378 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
379 unsigned Form, uint64_t Integer) {
380 if (!Form) Form = DIEInteger::BestForm(false, Integer);
381 DIEValue *Value = Integer == 1 ?
382 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
383 Die->addValue(Attribute, Form, Value);
386 /// addSInt - Add an signed integer attribute data and value.
388 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
389 unsigned Form, int64_t Integer) {
390 if (!Form) Form = DIEInteger::BestForm(true, Integer);
391 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
392 Die->addValue(Attribute, Form, Value);
395 /// addString - Add a string attribute data and value. DIEString only
396 /// keeps string reference.
397 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
399 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
400 Die->addValue(Attribute, Form, Value);
403 /// addLabel - Add a Dwarf label attribute data and value.
405 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
406 const MCSymbol *Label) {
407 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
408 Die->addValue(Attribute, Form, Value);
411 /// addDelta - Add a label delta attribute data and value.
413 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
414 const MCSymbol *Hi, const MCSymbol *Lo) {
415 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
416 Die->addValue(Attribute, Form, Value);
419 /// addDIEEntry - Add a DIE attribute data and value.
421 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
423 Die->addValue(Attribute, Form, createDIEEntry(Entry));
427 /// addBlock - Add block data.
429 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
431 Block->ComputeSize(Asm);
432 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
433 Die->addValue(Attribute, Block->BestForm(), Block);
436 /// addSourceLine - Add location information to specified debug information
438 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
443 unsigned Line = V->getLineNumber();
444 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
445 V->getContext().getFilename());
446 assert(FileID && "Invalid file id");
447 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
448 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
451 /// addSourceLine - Add location information to specified debug information
453 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
454 // Verify global variable.
458 unsigned Line = G->getLineNumber();
459 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
460 G->getContext().getFilename());
461 assert(FileID && "Invalid file id");
462 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
463 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
466 /// addSourceLine - Add location information to specified debug information
468 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
469 // Verify subprogram.
472 // If the line number is 0, don't add it.
473 if (SP->getLineNumber() == 0)
476 unsigned Line = SP->getLineNumber();
477 if (!SP->getContext().Verify())
479 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
481 assert(FileID && "Invalid file id");
482 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
483 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
486 /// addSourceLine - Add location information to specified debug information
488 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
493 unsigned Line = Ty->getLineNumber();
494 if (!Ty->getContext().Verify())
496 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
497 Ty->getContext().getFilename());
498 assert(FileID && "Invalid file id");
499 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
500 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
503 /// addSourceLine - Add location information to specified debug information
505 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
510 unsigned Line = NS->getLineNumber();
511 StringRef FN = NS->getFilename();
512 StringRef Dir = NS->getDirectory();
514 unsigned FileID = GetOrCreateSourceID(Dir, FN);
515 assert(FileID && "Invalid file id");
516 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
517 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
520 /* Byref variables, in Blocks, are declared by the programmer as
521 "SomeType VarName;", but the compiler creates a
522 __Block_byref_x_VarName struct, and gives the variable VarName
523 either the struct, or a pointer to the struct, as its type. This
524 is necessary for various behind-the-scenes things the compiler
525 needs to do with by-reference variables in blocks.
527 However, as far as the original *programmer* is concerned, the
528 variable should still have type 'SomeType', as originally declared.
530 The following function dives into the __Block_byref_x_VarName
531 struct to find the original type of the variable. This will be
532 passed back to the code generating the type for the Debug
533 Information Entry for the variable 'VarName'. 'VarName' will then
534 have the original type 'SomeType' in its debug information.
536 The original type 'SomeType' will be the type of the field named
537 'VarName' inside the __Block_byref_x_VarName struct.
539 NOTE: In order for this to not completely fail on the debugger
540 side, the Debug Information Entry for the variable VarName needs to
541 have a DW_AT_location that tells the debugger how to unwind through
542 the pointers and __Block_byref_x_VarName struct to find the actual
543 value of the variable. The function addBlockByrefType does this. */
545 /// Find the type the programmer originally declared the variable to be
546 /// and return that type.
548 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
551 unsigned tag = Ty.getTag();
553 if (tag == dwarf::DW_TAG_pointer_type) {
554 DIDerivedType DTy = DIDerivedType(Ty);
555 subType = DTy.getTypeDerivedFrom();
558 DICompositeType blockStruct = DICompositeType(subType);
559 DIArray Elements = blockStruct.getTypeArray();
561 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
562 DIDescriptor Element = Elements.getElement(i);
563 DIDerivedType DT = DIDerivedType(Element);
564 if (Name == DT.getName())
565 return (DT.getTypeDerivedFrom());
571 /// addComplexAddress - Start with the address based on the location provided,
572 /// and generate the DWARF information necessary to find the actual variable
573 /// given the extra address information encoded in the DIVariable, starting from
574 /// the starting location. Add the DWARF information to the die.
576 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
578 const MachineLocation &Location) {
579 const DIVariable &VD = DV->getVariable();
580 DIType Ty = VD.getType();
582 // Decode the original location, and use that as the start of the byref
583 // variable's location.
584 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
585 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
586 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
588 if (Location.isReg()) {
590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
592 Reg = Reg - dwarf::DW_OP_reg0;
593 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
594 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
598 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
600 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
601 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
604 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
607 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
608 uint64_t Element = VD.getAddrElement(i);
610 if (Element == DIFactory::OpPlus) {
611 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
612 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
613 } else if (Element == DIFactory::OpDeref) {
614 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
615 } else llvm_unreachable("unknown DIFactory Opcode");
618 // Now attach the location information to the DIE.
619 addBlock(Die, Attribute, 0, Block);
622 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
623 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
624 gives the variable VarName either the struct, or a pointer to the struct, as
625 its type. This is necessary for various behind-the-scenes things the
626 compiler needs to do with by-reference variables in Blocks.
628 However, as far as the original *programmer* is concerned, the variable
629 should still have type 'SomeType', as originally declared.
631 The function getBlockByrefType dives into the __Block_byref_x_VarName
632 struct to find the original type of the variable, which is then assigned to
633 the variable's Debug Information Entry as its real type. So far, so good.
634 However now the debugger will expect the variable VarName to have the type
635 SomeType. So we need the location attribute for the variable to be an
636 expression that explains to the debugger how to navigate through the
637 pointers and struct to find the actual variable of type SomeType.
639 The following function does just that. We start by getting
640 the "normal" location for the variable. This will be the location
641 of either the struct __Block_byref_x_VarName or the pointer to the
642 struct __Block_byref_x_VarName.
644 The struct will look something like:
646 struct __Block_byref_x_VarName {
648 struct __Block_byref_x_VarName *forwarding;
649 ... <various other fields>
651 ... <maybe more fields>
654 If we are given the struct directly (as our starting point) we
655 need to tell the debugger to:
657 1). Add the offset of the forwarding field.
659 2). Follow that pointer to get the real __Block_byref_x_VarName
660 struct to use (the real one may have been copied onto the heap).
662 3). Add the offset for the field VarName, to find the actual variable.
664 If we started with a pointer to the struct, then we need to
665 dereference that pointer first, before the other steps.
666 Translating this into DWARF ops, we will need to append the following
667 to the current location description for the variable:
669 DW_OP_deref -- optional, if we start with a pointer
670 DW_OP_plus_uconst <forward_fld_offset>
672 DW_OP_plus_uconst <varName_fld_offset>
674 That is what this function does. */
676 /// addBlockByrefAddress - Start with the address based on the location
677 /// provided, and generate the DWARF information necessary to find the
678 /// actual Block variable (navigating the Block struct) based on the
679 /// starting location. Add the DWARF information to the die. For
680 /// more information, read large comment just above here.
682 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
684 const MachineLocation &Location) {
685 const DIVariable &VD = DV->getVariable();
686 DIType Ty = VD.getType();
688 unsigned Tag = Ty.getTag();
689 bool isPointer = false;
691 StringRef varName = VD.getName();
693 if (Tag == dwarf::DW_TAG_pointer_type) {
694 DIDerivedType DTy = DIDerivedType(Ty);
695 TmpTy = DTy.getTypeDerivedFrom();
699 DICompositeType blockStruct = DICompositeType(TmpTy);
701 // Find the __forwarding field and the variable field in the __Block_byref
703 DIArray Fields = blockStruct.getTypeArray();
704 DIDescriptor varField = DIDescriptor();
705 DIDescriptor forwardingField = DIDescriptor();
707 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
708 DIDescriptor Element = Fields.getElement(i);
709 DIDerivedType DT = DIDerivedType(Element);
710 StringRef fieldName = DT.getName();
711 if (fieldName == "__forwarding")
712 forwardingField = Element;
713 else if (fieldName == varName)
717 // Get the offsets for the forwarding field and the variable field.
718 unsigned forwardingFieldOffset =
719 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
720 unsigned varFieldOffset =
721 DIDerivedType(varField).getOffsetInBits() >> 3;
723 // Decode the original location, and use that as the start of the byref
724 // variable's location.
725 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
726 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
727 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
729 if (Location.isReg()) {
731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
733 Reg = Reg - dwarf::DW_OP_reg0;
734 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
741 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
742 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
745 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
748 // If we started with a pointer to the __Block_byref... struct, then
749 // the first thing we need to do is dereference the pointer (DW_OP_deref).
751 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
753 // Next add the offset for the '__forwarding' field:
754 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
755 // adding the offset if it's 0.
756 if (forwardingFieldOffset > 0) {
757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
758 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
761 // Now dereference the __forwarding field to get to the real __Block_byref
762 // struct: DW_OP_deref.
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
765 // Now that we've got the real __Block_byref... struct, add the offset
766 // for the variable's field to get to the location of the actual variable:
767 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
768 if (varFieldOffset > 0) {
769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
770 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
773 // Now attach the location information to the DIE.
774 addBlock(Die, Attribute, 0, Block);
777 /// addAddress - Add an address attribute to a die based on the location
779 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
780 const MachineLocation &Location) {
781 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
782 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
783 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
785 if (Location.isReg()) {
787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
790 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
794 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
796 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
797 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
800 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
803 addBlock(Die, Attribute, 0, Block);
806 /// addRegisterAddress - Add register location entry in variable DIE.
807 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
808 const MachineOperand &MO) {
809 assert (MO.isReg() && "Invalid machine operand!");
812 MachineLocation Location;
813 Location.set(MO.getReg());
814 addAddress(Die, dwarf::DW_AT_location, Location);
816 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
820 /// addConstantValue - Add constant value entry in variable DIE.
821 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
822 const MachineOperand &MO) {
823 assert (MO.isImm() && "Invalid machine operand!");
824 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
825 unsigned Imm = MO.getImm();
826 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
827 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
829 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
833 /// addConstantFPValue - Add constant value entry in variable DIE.
834 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
835 const MachineOperand &MO) {
836 assert (MO.isFPImm() && "Invalid machine operand!");
837 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
838 APFloat FPImm = MO.getFPImm()->getValueAPF();
840 // Get the raw data form of the floating point.
841 const APInt FltVal = FPImm.bitcastToAPInt();
842 const char *FltPtr = (const char*)FltVal.getRawData();
844 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
845 bool LittleEndian = Asm->getTargetData().isLittleEndian();
846 int Incr = (LittleEndian ? 1 : -1);
847 int Start = (LittleEndian ? 0 : NumBytes - 1);
848 int Stop = (LittleEndian ? NumBytes : -1);
850 // Output the constant to DWARF one byte at a time.
851 for (; Start != Stop; Start += Incr)
852 addUInt(Block, 0, dwarf::DW_FORM_data1,
853 (unsigned char)0xFF & FltPtr[Start]);
855 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
857 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
862 /// addToContextOwner - Add Die into the list of its context owner's children.
863 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
864 if (Context.isType()) {
865 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
866 ContextDIE->addChild(Die);
867 } else if (Context.isNameSpace()) {
868 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
869 ContextDIE->addChild(Die);
870 } else if (Context.isSubprogram()) {
871 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
873 ContextDIE->addChild(Die);
874 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
875 ContextDIE->addChild(Die);
877 getCompileUnit(Context)->addDie(Die);
880 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
882 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
883 CompileUnit *TypeCU = getCompileUnit(Ty);
884 DIE *TyDIE = TypeCU->getDIE(Ty);
889 TyDIE = new DIE(dwarf::DW_TAG_base_type);
890 TypeCU->insertDIE(Ty, TyDIE);
891 if (Ty.isBasicType())
892 constructTypeDIE(*TyDIE, DIBasicType(Ty));
893 else if (Ty.isCompositeType())
894 constructTypeDIE(*TyDIE, DICompositeType(Ty));
896 assert(Ty.isDerivedType() && "Unknown kind of DIType");
897 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
900 addToContextOwner(TyDIE, Ty.getContext());
904 /// addType - Add a new type attribute to the specified entity.
905 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
909 // Check for pre-existence.
910 CompileUnit *TypeCU = getCompileUnit(Ty);
911 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
912 // If it exists then use the existing value.
914 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
919 DIE *Buffer = getOrCreateTypeDIE(Ty);
922 Entry = createDIEEntry(Buffer);
923 TypeCU->insertDIEEntry(Ty, Entry);
925 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
928 /// constructTypeDIE - Construct basic type die from DIBasicType.
929 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
930 // Get core information.
931 StringRef Name = BTy.getName();
932 Buffer.setTag(dwarf::DW_TAG_base_type);
933 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
936 // Add name if not anonymous or intermediate type.
938 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
939 uint64_t Size = BTy.getSizeInBits() >> 3;
940 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
943 /// constructTypeDIE - Construct derived type die from DIDerivedType.
944 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
945 // Get core information.
946 StringRef Name = DTy.getName();
947 uint64_t Size = DTy.getSizeInBits() >> 3;
948 unsigned Tag = DTy.getTag();
950 // FIXME - Workaround for templates.
951 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
955 // Map to main type, void will not have a type.
956 DIType FromTy = DTy.getTypeDerivedFrom();
957 addType(&Buffer, FromTy);
959 // Add name if not anonymous or intermediate type.
961 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
963 // Add size if non-zero (derived types might be zero-sized.)
965 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
967 // Add source line info if available and TyDesc is not a forward declaration.
968 if (!DTy.isForwardDecl())
969 addSourceLine(&Buffer, &DTy);
972 /// constructTypeDIE - Construct type DIE from DICompositeType.
973 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
974 // Get core information.
975 StringRef Name = CTy.getName();
977 uint64_t Size = CTy.getSizeInBits() >> 3;
978 unsigned Tag = CTy.getTag();
982 case dwarf::DW_TAG_vector_type:
983 case dwarf::DW_TAG_array_type:
984 constructArrayTypeDIE(Buffer, &CTy);
986 case dwarf::DW_TAG_enumeration_type: {
987 DIArray Elements = CTy.getTypeArray();
989 // Add enumerators to enumeration type.
990 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
992 DIDescriptor Enum(Elements.getElement(i));
993 if (Enum.isEnumerator()) {
994 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
995 Buffer.addChild(ElemDie);
1000 case dwarf::DW_TAG_subroutine_type: {
1002 DIArray Elements = CTy.getTypeArray();
1003 DIDescriptor RTy = Elements.getElement(0);
1004 addType(&Buffer, DIType(RTy));
1006 // Add prototype flag.
1007 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1010 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1011 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1012 DIDescriptor Ty = Elements.getElement(i);
1013 addType(Arg, DIType(Ty));
1014 Buffer.addChild(Arg);
1018 case dwarf::DW_TAG_structure_type:
1019 case dwarf::DW_TAG_union_type:
1020 case dwarf::DW_TAG_class_type: {
1021 // Add elements to structure type.
1022 DIArray Elements = CTy.getTypeArray();
1024 // A forward struct declared type may not have elements available.
1025 unsigned N = Elements.getNumElements();
1029 // Add elements to structure type.
1030 for (unsigned i = 0; i < N; ++i) {
1031 DIDescriptor Element = Elements.getElement(i);
1032 DIE *ElemDie = NULL;
1033 if (Element.isSubprogram())
1034 ElemDie = createSubprogramDIE(DISubprogram(Element));
1035 else if (Element.isVariable()) {
1036 DIVariable DV(Element);
1037 ElemDie = new DIE(dwarf::DW_TAG_variable);
1038 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1040 addType(ElemDie, DV.getType());
1041 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1042 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1043 addSourceLine(ElemDie, &DV);
1044 } else if (Element.isDerivedType())
1045 ElemDie = createMemberDIE(DIDerivedType(Element));
1048 Buffer.addChild(ElemDie);
1051 if (CTy.isAppleBlockExtension())
1052 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1054 unsigned RLang = CTy.getRunTimeLang();
1056 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1057 dwarf::DW_FORM_data1, RLang);
1059 DICompositeType ContainingType = CTy.getContainingType();
1060 if (DIDescriptor(ContainingType).isCompositeType())
1061 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1062 getOrCreateTypeDIE(DIType(ContainingType)));
1064 DIDescriptor Context = CTy.getContext();
1065 addToContextOwner(&Buffer, Context);
1073 // Add name if not anonymous or intermediate type.
1075 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1077 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1078 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1080 // Add size if non-zero (derived types might be zero-sized.)
1082 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1084 // Add zero size if it is not a forward declaration.
1085 if (CTy.isForwardDecl())
1086 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1088 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1091 // Add source line info if available.
1092 if (!CTy.isForwardDecl())
1093 addSourceLine(&Buffer, &CTy);
1097 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1098 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1099 int64_t L = SR.getLo();
1100 int64_t H = SR.getHi();
1101 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1103 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1105 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1106 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1108 Buffer.addChild(DW_Subrange);
1111 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1112 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1113 DICompositeType *CTy) {
1114 Buffer.setTag(dwarf::DW_TAG_array_type);
1115 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1116 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1118 // Emit derived type.
1119 addType(&Buffer, CTy->getTypeDerivedFrom());
1120 DIArray Elements = CTy->getTypeArray();
1122 // Get an anonymous type for index type.
1123 CompileUnit *TheCU = getCompileUnit(*CTy);
1124 DIE *IdxTy = TheCU->getIndexTyDie();
1126 // Construct an anonymous type for index type.
1127 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1128 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1129 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1130 dwarf::DW_ATE_signed);
1131 TheCU->addDie(IdxTy);
1132 TheCU->setIndexTyDie(IdxTy);
1135 // Add subranges to array type.
1136 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1137 DIDescriptor Element = Elements.getElement(i);
1138 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1139 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1143 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1144 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1145 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1146 StringRef Name = ETy.getName();
1147 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1148 int64_t Value = ETy.getEnumValue();
1149 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1153 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1154 /// printer to not emit usual symbol prefix before the symbol name is used then
1155 /// return linkage name after skipping this special LLVM prefix.
1156 static StringRef getRealLinkageName(StringRef LinkageName) {
1158 if (LinkageName.startswith(StringRef(&One, 1)))
1159 return LinkageName.substr(1);
1163 /// createGlobalVariableDIE - Create new DIE using GV.
1164 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1165 // If the global variable was optmized out then no need to create debug info
1167 if (!GV.getGlobal()) return NULL;
1168 if (GV.getDisplayName().empty()) return NULL;
1170 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1171 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1172 GV.getDisplayName());
1174 StringRef LinkageName = GV.getLinkageName();
1175 if (!LinkageName.empty())
1176 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1177 getRealLinkageName(LinkageName));
1179 addType(GVDie, GV.getType());
1180 if (!GV.isLocalToUnit())
1181 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1182 addSourceLine(GVDie, &GV);
1187 /// createMemberDIE - Create new member DIE.
1188 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1189 DIE *MemberDie = new DIE(DT.getTag());
1190 StringRef Name = DT.getName();
1192 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1194 addType(MemberDie, DT.getTypeDerivedFrom());
1196 addSourceLine(MemberDie, &DT);
1198 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1199 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1201 uint64_t Size = DT.getSizeInBits();
1202 uint64_t FieldSize = DT.getOriginalTypeSize();
1204 if (Size != FieldSize) {
1206 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1207 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1209 uint64_t Offset = DT.getOffsetInBits();
1210 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1211 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1212 uint64_t FieldOffset = (HiMark - FieldSize);
1213 Offset -= FieldOffset;
1215 // Maybe we need to work from the other end.
1216 if (Asm->getTargetData().isLittleEndian())
1217 Offset = FieldSize - (Offset + Size);
1218 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1220 // Here WD_AT_data_member_location points to the anonymous
1221 // field that includes this bit field.
1222 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1225 // This is not a bitfield.
1226 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1228 if (DT.getTag() == dwarf::DW_TAG_inheritance
1229 && DT.isVirtual()) {
1231 // For C++, virtual base classes are not at fixed offset. Use following
1232 // expression to extract appropriate offset from vtable.
1233 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1235 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1242 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1244 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1247 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1249 if (DT.isProtected())
1250 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1251 dwarf::DW_ACCESS_protected);
1252 else if (DT.isPrivate())
1253 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1254 dwarf::DW_ACCESS_private);
1255 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1256 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1257 dwarf::DW_ACCESS_public);
1259 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1260 dwarf::DW_VIRTUALITY_virtual);
1264 /// createSubprogramDIE - Create new DIE using SP.
1265 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1266 CompileUnit *SPCU = getCompileUnit(SP);
1267 DIE *SPDie = SPCU->getDIE(SP);
1271 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1272 // Constructors and operators for anonymous aggregates do not have names.
1273 if (!SP.getName().empty())
1274 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1276 StringRef LinkageName = SP.getLinkageName();
1277 if (!LinkageName.empty())
1278 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1279 getRealLinkageName(LinkageName));
1281 addSourceLine(SPDie, &SP);
1283 // Add prototyped tag, if C or ObjC.
1284 unsigned Lang = SP.getCompileUnit().getLanguage();
1285 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1286 Lang == dwarf::DW_LANG_ObjC)
1287 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1290 DICompositeType SPTy = SP.getType();
1291 DIArray Args = SPTy.getTypeArray();
1292 unsigned SPTag = SPTy.getTag();
1294 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1295 addType(SPDie, SPTy);
1297 addType(SPDie, DIType(Args.getElement(0)));
1299 unsigned VK = SP.getVirtuality();
1301 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1302 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1303 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1304 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1305 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1306 ContainingTypeMap.insert(std::make_pair(SPDie,
1307 SP.getContainingType()));
1310 if (MakeDecl || !SP.isDefinition()) {
1311 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1313 // Add arguments. Do not add arguments for subprogram definition. They will
1314 // be handled while processing variables.
1315 DICompositeType SPTy = SP.getType();
1316 DIArray Args = SPTy.getTypeArray();
1317 unsigned SPTag = SPTy.getTag();
1319 if (SPTag == dwarf::DW_TAG_subroutine_type)
1320 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1321 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1322 DIType ATy = DIType(DIType(Args.getElement(i)));
1324 if (ATy.isArtificial())
1325 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1326 SPDie->addChild(Arg);
1330 if (SP.isArtificial())
1331 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1333 if (!SP.isLocalToUnit())
1334 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1336 if (SP.isOptimized())
1337 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1339 if (unsigned isa = Asm->getISAEncoding()) {
1340 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1343 // DW_TAG_inlined_subroutine may refer to this DIE.
1344 SPCU->insertDIE(SP, SPDie);
1346 // Add to context owner.
1347 addToContextOwner(SPDie, SP.getContext());
1352 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1353 assert(N && "Invalid Scope encoding!");
1355 DbgScope *AScope = AbstractScopes.lookup(N);
1359 DbgScope *Parent = NULL;
1361 DIDescriptor Scope(N);
1362 if (Scope.isLexicalBlock()) {
1363 DILexicalBlock DB(N);
1364 DIDescriptor ParentDesc = DB.getContext();
1365 Parent = getOrCreateAbstractScope(ParentDesc);
1368 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1371 Parent->addScope(AScope);
1372 AScope->setAbstractScope();
1373 AbstractScopes[N] = AScope;
1374 if (DIDescriptor(N).isSubprogram())
1375 AbstractScopesList.push_back(AScope);
1379 /// isSubprogramContext - Return true if Context is either a subprogram
1380 /// or another context nested inside a subprogram.
1381 static bool isSubprogramContext(const MDNode *Context) {
1384 DIDescriptor D(Context);
1385 if (D.isSubprogram())
1388 return isSubprogramContext(DIType(Context).getContext());
1392 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1393 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1394 /// If there are global variables in this scope then create and insert
1395 /// DIEs for these variables.
1396 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1397 CompileUnit *SPCU = getCompileUnit(SPNode);
1398 DIE *SPDie = SPCU->getDIE(SPNode);
1400 assert(SPDie && "Unable to find subprogram DIE!");
1401 DISubprogram SP(SPNode);
1403 // There is not any need to generate specification DIE for a function
1404 // defined at compile unit level. If a function is defined inside another
1405 // function then gdb prefers the definition at top level and but does not
1406 // expect specification DIE in parent function. So avoid creating
1407 // specification DIE for a function defined inside a function.
1408 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1409 !SP.getContext().isFile() &&
1410 !isSubprogramContext(SP.getContext())) {
1411 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1414 DICompositeType SPTy = SP.getType();
1415 DIArray Args = SPTy.getTypeArray();
1416 unsigned SPTag = SPTy.getTag();
1417 if (SPTag == dwarf::DW_TAG_subroutine_type)
1418 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1419 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1420 DIType ATy = DIType(DIType(Args.getElement(i)));
1422 if (ATy.isArtificial())
1423 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1424 SPDie->addChild(Arg);
1426 DIE *SPDeclDie = SPDie;
1427 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1428 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1430 SPCU->addDie(SPDie);
1433 // Pick up abstract subprogram DIE.
1434 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1435 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1436 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1437 dwarf::DW_FORM_ref4, AbsSPDIE);
1438 SPCU->addDie(SPDie);
1441 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1442 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1443 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1444 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1445 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1446 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1447 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1452 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1453 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1454 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1456 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1457 if (Scope->isAbstractScope())
1460 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1464 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1465 if (Ranges.size() > 1) {
1466 // .debug_range section has not been laid out yet. Emit offset in
1467 // .debug_range as a uint, size 4, for now. emitDIE will handle
1468 // DW_AT_ranges appropriately.
1469 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1470 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1471 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1472 RE = Ranges.end(); RI != RE; ++RI) {
1473 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1474 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1476 DebugRangeSymbols.push_back(NULL);
1477 DebugRangeSymbols.push_back(NULL);
1481 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1482 const MCSymbol *End = getLabelAfterInsn(RI->second);
1484 if (End == 0) return 0;
1486 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1487 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1489 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1490 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1495 /// constructInlinedScopeDIE - This scope represents inlined body of
1496 /// a function. Construct DIE to represent this concrete inlined copy
1497 /// of the function.
1498 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1500 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1501 assert (Ranges.empty() == false
1502 && "DbgScope does not have instruction markers!");
1504 // FIXME : .debug_inlined section specification does not clearly state how
1505 // to emit inlined scope that is split into multiple instruction ranges.
1506 // For now, use first instruction range and emit low_pc/high_pc pair and
1507 // corresponding .debug_inlined section entry for this pair.
1508 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1509 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1510 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1512 if (StartLabel == 0 || EndLabel == 0) {
1513 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1516 assert(StartLabel->isDefined() &&
1517 "Invalid starting label for an inlined scope!");
1518 assert(EndLabel->isDefined() &&
1519 "Invalid end label for an inlined scope!");
1521 if (!Scope->getScopeNode())
1523 DIScope DS(Scope->getScopeNode());
1524 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1526 DISubprogram InlinedSP = getDISubprogram(DS);
1527 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1528 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1529 assert(OriginDIE && "Unable to find Origin DIE!");
1530 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1531 dwarf::DW_FORM_ref4, OriginDIE);
1533 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1534 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1536 InlinedSubprogramDIEs.insert(OriginDIE);
1538 // Track the start label for this inlined function.
1539 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1540 I = InlineInfo.find(InlinedSP);
1542 if (I == InlineInfo.end()) {
1543 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1545 InlinedSPNodes.push_back(InlinedSP);
1547 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1549 DILocation DL(Scope->getInlinedAt());
1550 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1551 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1557 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1558 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1559 // Get the descriptor.
1560 const DIVariable &VD = DV->getVariable();
1561 StringRef Name = VD.getName();
1565 // Translate tag to proper Dwarf tag. The result variable is dropped for
1568 switch (VD.getTag()) {
1569 case dwarf::DW_TAG_return_variable:
1571 case dwarf::DW_TAG_arg_variable:
1572 Tag = dwarf::DW_TAG_formal_parameter;
1574 case dwarf::DW_TAG_auto_variable: // fall thru
1576 Tag = dwarf::DW_TAG_variable;
1580 // Define variable debug information entry.
1581 DIE *VariableDie = new DIE(Tag);
1584 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1585 V2AVI = VarToAbstractVarMap.find(DV);
1586 if (V2AVI != VarToAbstractVarMap.end())
1587 AbsDIE = V2AVI->second->getDIE();
1590 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1591 dwarf::DW_FORM_ref4, AbsDIE);
1593 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1594 addSourceLine(VariableDie, &VD);
1596 // Add variable type.
1597 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1598 // addresses instead.
1599 if (VD.isBlockByrefVariable())
1600 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1602 addType(VariableDie, VD.getType());
1605 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1606 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1608 if (Scope->isAbstractScope()) {
1609 DV->setDIE(VariableDie);
1613 // Add variable address.
1615 unsigned Offset = DV->getDotDebugLocOffset();
1616 if (Offset != ~0U) {
1617 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1618 Asm->GetTempSymbol("debug_loc", Offset));
1619 DV->setDIE(VariableDie);
1620 UseDotDebugLocEntry.insert(VariableDie);
1624 // Check if variable is described by a DBG_VALUE instruction.
1625 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1626 DbgVariableToDbgInstMap.find(DV);
1627 if (DVI != DbgVariableToDbgInstMap.end()) {
1628 const MachineInstr *DVInsn = DVI->second;
1629 const MCSymbol *DVLabel = findVariableLabel(DV);
1630 bool updated = false;
1631 // FIXME : Handle getNumOperands != 3
1632 if (DVInsn->getNumOperands() == 3) {
1633 if (DVInsn->getOperand(0).isReg())
1635 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1636 else if (DVInsn->getOperand(0).isImm())
1637 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1638 else if (DVInsn->getOperand(0).isFPImm())
1640 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1642 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1643 if (Location.getReg()) {
1644 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1646 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1652 // If variableDie is not updated then DBG_VALUE instruction does not
1653 // have valid variable info.
1657 DV->setDIE(VariableDie);
1661 // .. else use frame index, if available.
1662 MachineLocation Location;
1664 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1666 if (findVariableFrameIndex(DV, &FI)) {
1667 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1668 Location.set(FrameReg, Offset);
1670 if (VD.hasComplexAddress())
1671 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1672 else if (VD.isBlockByrefVariable())
1673 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1675 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1677 DV->setDIE(VariableDie);
1682 void DwarfDebug::addPubTypes(DISubprogram SP) {
1683 DICompositeType SPTy = SP.getType();
1684 unsigned SPTag = SPTy.getTag();
1685 if (SPTag != dwarf::DW_TAG_subroutine_type)
1688 DIArray Args = SPTy.getTypeArray();
1689 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1690 DIType ATy(Args.getElement(i));
1693 DICompositeType CATy = getDICompositeType(ATy);
1694 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1695 && !CATy.isForwardDecl()) {
1696 CompileUnit *TheCU = getCompileUnit(CATy);
1697 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1698 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1703 /// constructScopeDIE - Construct a DIE for this scope.
1704 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1705 if (!Scope || !Scope->getScopeNode())
1708 DIScope DS(Scope->getScopeNode());
1709 DIE *ScopeDIE = NULL;
1710 if (Scope->getInlinedAt())
1711 ScopeDIE = constructInlinedScopeDIE(Scope);
1712 else if (DS.isSubprogram()) {
1713 ProcessedSPNodes.insert(DS);
1714 if (Scope->isAbstractScope()) {
1715 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1716 // Note down abstract DIE.
1718 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1721 ScopeDIE = updateSubprogramScopeDIE(DS);
1724 ScopeDIE = constructLexicalScopeDIE(Scope);
1725 if (!ScopeDIE) return NULL;
1727 // Add variables to scope.
1728 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1729 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1730 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1732 ScopeDIE->addChild(VariableDIE);
1735 // Add nested scopes.
1736 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1737 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1738 // Define the Scope debug information entry.
1739 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1741 ScopeDIE->addChild(NestedDIE);
1744 if (DS.isSubprogram())
1745 addPubTypes(DISubprogram(DS));
1750 /// GetOrCreateSourceID - Look up the source id with the given directory and
1751 /// source file names. If none currently exists, create a new id and insert it
1752 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1754 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1756 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->getVariables();
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 MLoc.set(Begin->getOperand(0).getReg(), 0);
2311 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2312 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2313 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2315 if (MVI + 1 == MVE) {
2316 // If End is the last instruction then its value is valid
2317 // until the end of the funtion.
2318 MLoc.set(End->getOperand(0).getReg(), 0);
2320 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2323 DotDebugLocEntries.push_back(DotDebugLocEntry());
2326 // Collect info for variables that were optimized out.
2327 const Function *F = MF->getFunction();
2328 const Module *M = F->getParent();
2329 if (NamedMDNode *NMD =
2330 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2331 getRealLinkageName(F->getName())))) {
2332 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2333 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2334 if (!DV || !Processed.insert(DV))
2336 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2338 Scope->addVariable(new DbgVariable(DV));
2343 /// getLabelBeforeInsn - Return Label preceding the instruction.
2344 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2345 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2346 LabelsBeforeInsn.find(MI);
2347 if (I == LabelsBeforeInsn.end())
2348 // FunctionBeginSym always preceeds all the instruction in current function.
2349 return FunctionBeginSym;
2353 /// getLabelAfterInsn - Return Label immediately following the instruction.
2354 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2355 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2356 LabelsAfterInsn.find(MI);
2357 if (I == LabelsAfterInsn.end())
2362 /// beginScope - Process beginning of a scope.
2363 void DwarfDebug::beginScope(const MachineInstr *MI) {
2364 if (InsnNeedsLabel.count(MI) == 0) {
2365 LabelsBeforeInsn[MI] = PrevLabel;
2370 DebugLoc DL = MI->getDebugLoc();
2371 if (!DL.isUnknown()) {
2372 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2373 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2375 LabelsBeforeInsn[MI] = PrevLabel;
2379 // If location is unknown then use temp label for this DBG_VALUE
2381 if (MI->isDebugValue()) {
2382 PrevLabel = MMI->getContext().CreateTempSymbol();
2383 Asm->OutStreamer.EmitLabel(PrevLabel);
2384 LabelsBeforeInsn[MI] = PrevLabel;
2388 if (UnknownLocations) {
2389 PrevLabel = recordSourceLine(0, 0, 0);
2390 LabelsBeforeInsn[MI] = PrevLabel;
2394 assert (0 && "Instruction is not processed!");
2397 /// endScope - Process end of a scope.
2398 void DwarfDebug::endScope(const MachineInstr *MI) {
2399 if (InsnsEndScopeSet.count(MI) != 0) {
2400 // Emit a label if this instruction ends a scope.
2401 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2402 Asm->OutStreamer.EmitLabel(Label);
2403 LabelsAfterInsn[MI] = Label;
2407 /// getOrCreateDbgScope - Create DbgScope for the scope.
2408 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2409 const MDNode *InlinedAt) {
2411 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2414 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2415 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2416 if (DIDescriptor(Scope).isLexicalBlock()) {
2418 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2419 WScope->setParent(Parent);
2420 Parent->addScope(WScope);
2423 if (!WScope->getParent()) {
2424 StringRef SPName = DISubprogram(Scope).getLinkageName();
2425 // We used to check only for a linkage name, but that fails
2426 // since we began omitting the linkage name for private
2427 // functions. The new way is to check for the name in metadata,
2428 // but that's not supported in old .ll test cases. Ergo, we
2430 if (SPName == Asm->MF->getFunction()->getName() ||
2431 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2432 CurrentFnDbgScope = WScope;
2438 getOrCreateAbstractScope(Scope);
2439 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2443 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2444 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2445 DILocation DL(InlinedAt);
2447 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2448 WScope->setParent(Parent);
2449 Parent->addScope(WScope);
2451 ConcreteScopes[InlinedAt] = WScope;
2456 /// hasValidLocation - Return true if debug location entry attached with
2457 /// machine instruction encodes valid location info.
2458 static bool hasValidLocation(LLVMContext &Ctx,
2459 const MachineInstr *MInsn,
2460 const MDNode *&Scope, const MDNode *&InlinedAt) {
2461 DebugLoc DL = MInsn->getDebugLoc();
2462 if (DL.isUnknown()) return false;
2464 const MDNode *S = DL.getScope(Ctx);
2466 // There is no need to create another DIE for compile unit. For all
2467 // other scopes, create one DbgScope now. This will be translated
2468 // into a scope DIE at the end.
2469 if (DIScope(S).isCompileUnit()) return false;
2472 InlinedAt = DL.getInlinedAt(Ctx);
2476 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2478 static void calculateDominanceGraph(DbgScope *Scope) {
2479 assert (Scope && "Unable to calculate scop edominance graph!");
2480 SmallVector<DbgScope *, 4> WorkStack;
2481 WorkStack.push_back(Scope);
2482 unsigned Counter = 0;
2483 while (!WorkStack.empty()) {
2484 DbgScope *WS = WorkStack.back();
2485 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2486 bool visitedChildren = false;
2487 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2488 SE = Children.end(); SI != SE; ++SI) {
2489 DbgScope *ChildScope = *SI;
2490 if (!ChildScope->getDFSOut()) {
2491 WorkStack.push_back(ChildScope);
2492 visitedChildren = true;
2493 ChildScope->setDFSIn(++Counter);
2497 if (!visitedChildren) {
2498 WorkStack.pop_back();
2499 WS->setDFSOut(++Counter);
2504 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2506 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2507 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2510 unsigned PrevDFSIn = 0;
2511 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2513 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2515 const MachineInstr *MInsn = II;
2516 const MDNode *Scope = NULL;
2517 const MDNode *InlinedAt = NULL;
2519 // Check if instruction has valid location information.
2520 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2524 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2525 MI2ScopeMap.find(MInsn);
2526 if (DI != MI2ScopeMap.end()) {
2527 DbgScope *S = DI->second;
2528 dbgs() << S->getDFSIn();
2529 PrevDFSIn = S->getDFSIn();
2531 dbgs() << PrevDFSIn;
2533 dbgs() << " [ x" << PrevDFSIn;
2541 /// extractScopeInformation - Scan machine instructions in this function
2542 /// and collect DbgScopes. Return true, if at least one scope was found.
2543 bool DwarfDebug::extractScopeInformation() {
2544 // If scope information was extracted using .dbg intrinsics then there is not
2545 // any need to extract these information by scanning each instruction.
2546 if (!DbgScopeMap.empty())
2549 // Scan each instruction and create scopes. First build working set of scopes.
2550 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2551 SmallVector<DbgRange, 4> MIRanges;
2552 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2553 const MDNode *PrevScope = NULL;
2554 const MDNode *PrevInlinedAt = NULL;
2555 const MachineInstr *RangeBeginMI = NULL;
2556 const MachineInstr *PrevMI = NULL;
2557 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2559 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2561 const MachineInstr *MInsn = II;
2562 const MDNode *Scope = NULL;
2563 const MDNode *InlinedAt = NULL;
2565 // Check if instruction has valid location information.
2566 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2571 // If scope has not changed then skip this instruction.
2572 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2578 // If we have alread seen a beginning of a instruction range and
2579 // current instruction scope does not match scope of first instruction
2580 // in this range then create a new instruction range.
2581 DbgRange R(RangeBeginMI, PrevMI);
2582 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2584 MIRanges.push_back(R);
2587 // This is a beginning of a new instruction range.
2588 RangeBeginMI = MInsn;
2590 // Reset previous markers.
2593 PrevInlinedAt = InlinedAt;
2597 // Create last instruction range.
2598 if (RangeBeginMI && PrevMI && PrevScope) {
2599 DbgRange R(RangeBeginMI, PrevMI);
2600 MIRanges.push_back(R);
2601 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2604 if (!CurrentFnDbgScope)
2607 calculateDominanceGraph(CurrentFnDbgScope);
2609 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2611 // Find ranges of instructions covered by each DbgScope;
2612 DbgScope *PrevDbgScope = NULL;
2613 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2614 RE = MIRanges.end(); RI != RE; ++RI) {
2615 const DbgRange &R = *RI;
2616 DbgScope *S = MI2ScopeMap.lookup(R.first);
2617 assert (S && "Lost DbgScope for a machine instruction!");
2618 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2619 PrevDbgScope->closeInsnRange(S);
2620 S->openInsnRange(R.first);
2621 S->extendInsnRange(R.second);
2626 PrevDbgScope->closeInsnRange();
2628 identifyScopeMarkers();
2630 return !DbgScopeMap.empty();
2633 /// identifyScopeMarkers() -
2634 /// Each DbgScope has first instruction and last instruction to mark beginning
2635 /// and end of a scope respectively. Create an inverse map that list scopes
2636 /// starts (and ends) with an instruction. One instruction may start (or end)
2637 /// multiple scopes. Ignore scopes that are not reachable.
2638 void DwarfDebug::identifyScopeMarkers() {
2639 SmallVector<DbgScope *, 4> WorkList;
2640 WorkList.push_back(CurrentFnDbgScope);
2641 while (!WorkList.empty()) {
2642 DbgScope *S = WorkList.pop_back_val();
2644 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2645 if (!Children.empty())
2646 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2647 SE = Children.end(); SI != SE; ++SI)
2648 WorkList.push_back(*SI);
2650 if (S->isAbstractScope())
2653 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2656 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2657 RE = Ranges.end(); RI != RE; ++RI) {
2658 assert(RI->first && "DbgRange does not have first instruction!");
2659 assert(RI->second && "DbgRange does not have second instruction!");
2660 InsnsEndScopeSet.insert(RI->second);
2665 /// FindFirstDebugLoc - Find the first debug location in the function. This
2666 /// is intended to be an approximation for the source position of the
2667 /// beginning of the function.
2668 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2669 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2671 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2672 MBBI != MBBE; ++MBBI) {
2673 DebugLoc DL = MBBI->getDebugLoc();
2674 if (!DL.isUnknown())
2680 /// beginFunction - Gather pre-function debug information. Assumes being
2681 /// emitted immediately after the function entry point.
2682 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2683 if (!MMI->hasDebugInfo()) return;
2684 if (!extractScopeInformation()) return;
2686 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2687 Asm->getFunctionNumber());
2688 // Assumes in correct section after the entry point.
2689 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2691 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2693 DebugLoc FDL = FindFirstDebugLoc(MF);
2694 if (FDL.isUnknown()) return;
2696 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2697 const MDNode *TheScope = 0;
2699 DISubprogram SP = getDISubprogram(Scope);
2702 Line = SP.getLineNumber();
2706 Line = FDL.getLine();
2711 recordSourceLine(Line, Col, TheScope);
2713 /// ProcessedArgs - Collection of arguments already processed.
2714 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2717 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2719 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2721 const MachineInstr *MI = II;
2722 DebugLoc DL = MI->getDebugLoc();
2723 if (MI->isDebugValue()) {
2724 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2725 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2726 if (!DV.Verify()) continue;
2727 // If DBG_VALUE is for a local variable then it needs a label.
2728 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2729 && isDbgValueInUndefinedReg(MI) == false)
2730 InsnNeedsLabel.insert(MI);
2731 // DBG_VALUE for inlined functions argument needs a label.
2732 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2733 describes(MF->getFunction()))
2734 InsnNeedsLabel.insert(MI);
2735 // DBG_VALUE indicating argument location change needs a label.
2736 else if (isDbgValueInUndefinedReg(MI) == false
2737 && !ProcessedArgs.insert(DV))
2738 InsnNeedsLabel.insert(MI);
2740 // If location is unknown then instruction needs a location only if
2741 // UnknownLocations flag is set.
2742 if (DL.isUnknown()) {
2743 if (UnknownLocations && !PrevLoc.isUnknown())
2744 InsnNeedsLabel.insert(MI);
2745 } else if (DL != PrevLoc)
2746 // Otherwise, instruction needs a location only if it is new location.
2747 InsnNeedsLabel.insert(MI);
2750 if (!DL.isUnknown() || UnknownLocations)
2754 PrevLabel = FunctionBeginSym;
2757 /// endFunction - Gather and emit post-function debug information.
2759 void DwarfDebug::endFunction(const MachineFunction *MF) {
2760 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2762 if (CurrentFnDbgScope) {
2764 // Define end label for subprogram.
2765 FunctionEndSym = Asm->GetTempSymbol("func_end",
2766 Asm->getFunctionNumber());
2767 // Assumes in correct section after the entry point.
2768 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2770 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2771 collectVariableInfo(MF, ProcessedVars);
2773 // Get function line info.
2774 if (!Lines.empty()) {
2775 // Get section line info.
2776 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2777 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2778 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2779 // Append the function info to section info.
2780 SectionLineInfos.insert(SectionLineInfos.end(),
2781 Lines.begin(), Lines.end());
2784 // Construct abstract scopes.
2785 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2786 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2787 DISubprogram SP((*AI)->getScopeNode());
2789 // Collect info for variables that were optimized out.
2790 StringRef FName = SP.getLinkageName();
2792 FName = SP.getName();
2793 const Module *M = MF->getFunction()->getParent();
2794 if (NamedMDNode *NMD =
2795 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2796 getRealLinkageName(FName)))) {
2797 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2798 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2799 if (!DV || !ProcessedVars.insert(DV))
2801 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2803 Scope->addVariable(new DbgVariable(DV));
2807 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2808 constructScopeDIE(*AI);
2811 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2813 if (!DisableFramePointerElim(*MF))
2814 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2815 dwarf::DW_FORM_flag, 1);
2818 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2819 MMI->getFrameMoves()));
2823 CurrentFnDbgScope = NULL;
2824 InsnNeedsLabel.clear();
2825 DbgVariableToFrameIndexMap.clear();
2826 VarToAbstractVarMap.clear();
2827 DbgVariableToDbgInstMap.clear();
2828 DbgVariableLabelsMap.clear();
2829 DeleteContainerSeconds(DbgScopeMap);
2830 InsnsEndScopeSet.clear();
2831 ConcreteScopes.clear();
2832 DeleteContainerSeconds(AbstractScopes);
2833 AbstractScopesList.clear();
2834 AbstractVariables.clear();
2835 LabelsBeforeInsn.clear();
2836 LabelsAfterInsn.clear();
2841 /// recordVariableFrameIndex - Record a variable's index.
2842 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2843 assert (V && "Invalid DbgVariable!");
2844 DbgVariableToFrameIndexMap[V] = Index;
2847 /// findVariableFrameIndex - Return true if frame index for the variable
2848 /// is found. Update FI to hold value of the index.
2849 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2850 assert (V && "Invalid DbgVariable!");
2851 DenseMap<const DbgVariable *, int>::iterator I =
2852 DbgVariableToFrameIndexMap.find(V);
2853 if (I == DbgVariableToFrameIndexMap.end())
2859 /// findVariableLabel - Find MCSymbol for the variable.
2860 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2861 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2862 = DbgVariableLabelsMap.find(V);
2863 if (I == DbgVariableLabelsMap.end())
2865 else return I->second;
2868 /// findDbgScope - Find DbgScope for the debug loc attached with an
2870 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2871 DbgScope *Scope = NULL;
2873 MInsn->getParent()->getParent()->getFunction()->getContext();
2874 DebugLoc DL = MInsn->getDebugLoc();
2879 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2880 Scope = ConcreteScopes.lookup(IA);
2882 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2888 /// recordSourceLine - Register a source line with debug info. Returns the
2889 /// unique label that was emitted and which provides correspondence to
2890 /// the source line list.
2891 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2898 DIDescriptor Scope(S);
2900 if (Scope.isCompileUnit()) {
2901 DICompileUnit CU(S);
2902 Dir = CU.getDirectory();
2903 Fn = CU.getFilename();
2904 } else if (Scope.isSubprogram()) {
2906 Dir = SP.getDirectory();
2907 Fn = SP.getFilename();
2908 } else if (Scope.isLexicalBlock()) {
2909 DILexicalBlock DB(S);
2910 Dir = DB.getDirectory();
2911 Fn = DB.getFilename();
2913 assert(0 && "Unexpected scope info");
2915 Src = GetOrCreateSourceID(Dir, Fn);
2918 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2919 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2921 Asm->OutStreamer.EmitLabel(Label);
2925 //===----------------------------------------------------------------------===//
2927 //===----------------------------------------------------------------------===//
2929 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2932 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2933 // Get the children.
2934 const std::vector<DIE *> &Children = Die->getChildren();
2936 // If not last sibling and has children then add sibling offset attribute.
2937 if (!Last && !Children.empty())
2938 Die->addSiblingOffset(DIEValueAllocator);
2940 // Record the abbreviation.
2941 assignAbbrevNumber(Die->getAbbrev());
2943 // Get the abbreviation for this DIE.
2944 unsigned AbbrevNumber = Die->getAbbrevNumber();
2945 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2948 Die->setOffset(Offset);
2950 // Start the size with the size of abbreviation code.
2951 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2953 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2954 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2956 // Size the DIE attribute values.
2957 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2958 // Size attribute value.
2959 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2961 // Size the DIE children if any.
2962 if (!Children.empty()) {
2963 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2964 "Children flag not set");
2966 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2967 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2969 // End of children marker.
2970 Offset += sizeof(int8_t);
2973 Die->setSize(Offset - Die->getOffset());
2977 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2979 void DwarfDebug::computeSizeAndOffsets() {
2980 unsigned PrevOffset = 0;
2981 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2982 E = CUMap.end(); I != E; ++I) {
2983 // Compute size of compile unit header.
2984 static unsigned Offset = PrevOffset +
2985 sizeof(int32_t) + // Length of Compilation Unit Info
2986 sizeof(int16_t) + // DWARF version number
2987 sizeof(int32_t) + // Offset Into Abbrev. Section
2988 sizeof(int8_t); // Pointer Size (in bytes)
2989 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2990 PrevOffset = Offset;
2994 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2995 /// temporary label to it if SymbolStem is specified.
2996 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2997 const char *SymbolStem = 0) {
2998 Asm->OutStreamer.SwitchSection(Section);
2999 if (!SymbolStem) return 0;
3001 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3002 Asm->OutStreamer.EmitLabel(TmpSym);
3006 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3007 /// the start of each one.
3008 void DwarfDebug::EmitSectionLabels() {
3009 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3011 // Dwarf sections base addresses.
3012 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3013 DwarfFrameSectionSym =
3014 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3017 DwarfInfoSectionSym =
3018 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3019 DwarfAbbrevSectionSym =
3020 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3021 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3023 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3024 EmitSectionSym(Asm, MacroInfo);
3026 DwarfDebugLineSectionSym =
3027 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3028 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3029 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3030 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3031 DwarfStrSectionSym =
3032 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3033 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3036 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3037 "section_debug_loc");
3039 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3040 EmitSectionSym(Asm, TLOF.getDataSection());
3043 /// emitDIE - Recusively Emits a debug information entry.
3045 void DwarfDebug::emitDIE(DIE *Die) {
3046 // Get the abbreviation for this DIE.
3047 unsigned AbbrevNumber = Die->getAbbrevNumber();
3048 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3050 // Emit the code (index) for the abbreviation.
3051 if (Asm->isVerbose())
3052 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3053 Twine::utohexstr(Die->getOffset()) + ":0x" +
3054 Twine::utohexstr(Die->getSize()) + " " +
3055 dwarf::TagString(Abbrev->getTag()));
3056 Asm->EmitULEB128(AbbrevNumber);
3058 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3059 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3061 // Emit the DIE attribute values.
3062 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3063 unsigned Attr = AbbrevData[i].getAttribute();
3064 unsigned Form = AbbrevData[i].getForm();
3065 assert(Form && "Too many attributes for DIE (check abbreviation)");
3067 if (Asm->isVerbose())
3068 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3071 case dwarf::DW_AT_sibling:
3072 Asm->EmitInt32(Die->getSiblingOffset());
3074 case dwarf::DW_AT_abstract_origin: {
3075 DIEEntry *E = cast<DIEEntry>(Values[i]);
3076 DIE *Origin = E->getEntry();
3077 unsigned Addr = Origin->getOffset();
3078 Asm->EmitInt32(Addr);
3081 case dwarf::DW_AT_ranges: {
3082 // DW_AT_range Value encodes offset in debug_range section.
3083 DIEInteger *V = cast<DIEInteger>(Values[i]);
3084 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3086 DwarfDebugRangeSectionSym,
3090 case dwarf::DW_AT_stmt_list: {
3091 Asm->EmitLabelDifference(CurrentLineSectionSym,
3092 DwarfDebugLineSectionSym, 4);
3095 case dwarf::DW_AT_location: {
3096 if (UseDotDebugLocEntry.count(Die) != 0) {
3097 DIELabel *L = cast<DIELabel>(Values[i]);
3098 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3100 Values[i]->EmitValue(Asm, Form);
3104 // Emit an attribute using the defined form.
3105 Values[i]->EmitValue(Asm, Form);
3110 // Emit the DIE children if any.
3111 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3112 const std::vector<DIE *> &Children = Die->getChildren();
3114 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3115 emitDIE(Children[j]);
3117 if (Asm->isVerbose())
3118 Asm->OutStreamer.AddComment("End Of Children Mark");
3123 /// emitDebugInfo - Emit the debug info section.
3125 void DwarfDebug::emitDebugInfo() {
3126 // Start debug info section.
3127 Asm->OutStreamer.SwitchSection(
3128 Asm->getObjFileLowering().getDwarfInfoSection());
3129 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3130 E = CUMap.end(); I != E; ++I) {
3131 CompileUnit *TheCU = I->second;
3132 DIE *Die = TheCU->getCUDie();
3134 // Emit the compile units header.
3135 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3138 // Emit size of content not including length itself
3139 unsigned ContentSize = Die->getSize() +
3140 sizeof(int16_t) + // DWARF version number
3141 sizeof(int32_t) + // Offset Into Abbrev. Section
3142 sizeof(int8_t) + // Pointer Size (in bytes)
3143 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3145 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3146 Asm->EmitInt32(ContentSize);
3147 Asm->OutStreamer.AddComment("DWARF version number");
3148 Asm->EmitInt16(dwarf::DWARF_VERSION);
3149 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3150 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3151 DwarfAbbrevSectionSym);
3152 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3153 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3156 // FIXME - extra padding for gdb bug.
3157 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3162 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3166 /// emitAbbreviations - Emit the abbreviation section.
3168 void DwarfDebug::emitAbbreviations() const {
3169 // Check to see if it is worth the effort.
3170 if (!Abbreviations.empty()) {
3171 // Start the debug abbrev section.
3172 Asm->OutStreamer.SwitchSection(
3173 Asm->getObjFileLowering().getDwarfAbbrevSection());
3175 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3177 // For each abbrevation.
3178 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3179 // Get abbreviation data
3180 const DIEAbbrev *Abbrev = Abbreviations[i];
3182 // Emit the abbrevations code (base 1 index.)
3183 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3185 // Emit the abbreviations data.
3189 // Mark end of abbreviations.
3190 Asm->EmitULEB128(0, "EOM(3)");
3192 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3196 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3197 /// the line matrix.
3199 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3200 // Define last address of section.
3201 Asm->OutStreamer.AddComment("Extended Op");
3204 Asm->OutStreamer.AddComment("Op size");
3205 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3206 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3207 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3209 Asm->OutStreamer.AddComment("Section end label");
3211 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3212 Asm->getTargetData().getPointerSize(),
3215 // Mark end of matrix.
3216 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3222 /// emitDebugLines - Emit source line information.
3224 void DwarfDebug::emitDebugLines() {
3225 // If the target is using .loc/.file, the assembler will be emitting the
3226 // .debug_line table automatically.
3227 if (Asm->MAI->hasDotLocAndDotFile())
3230 // Minimum line delta, thus ranging from -10..(255-10).
3231 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3232 // Maximum line delta, thus ranging from -10..(255-10).
3233 const int MaxLineDelta = 255 + MinLineDelta;
3235 // Start the dwarf line section.
3236 Asm->OutStreamer.SwitchSection(
3237 Asm->getObjFileLowering().getDwarfLineSection());
3239 // Construct the section header.
3240 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3241 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3242 Asm->OutStreamer.AddComment("Length of Source Line Info");
3243 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3244 Asm->GetTempSymbol("line_begin"), 4);
3245 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3247 Asm->OutStreamer.AddComment("DWARF version number");
3248 Asm->EmitInt16(dwarf::DWARF_VERSION);
3250 Asm->OutStreamer.AddComment("Prolog Length");
3251 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3252 Asm->GetTempSymbol("line_prolog_begin"), 4);
3253 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3255 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3257 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3259 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3260 Asm->EmitInt8(MinLineDelta);
3261 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3262 Asm->EmitInt8(MaxLineDelta);
3263 Asm->OutStreamer.AddComment("Special Opcode Base");
3264 Asm->EmitInt8(-MinLineDelta);
3266 // Line number standard opcode encodings argument count
3267 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3269 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3271 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3273 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3275 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3277 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3279 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3281 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3283 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3286 // Emit directories.
3287 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3288 const std::string &Dir = getSourceDirectoryName(DI);
3289 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3290 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3293 Asm->OutStreamer.AddComment("End of directories");
3297 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3298 // Remember source id starts at 1.
3299 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3300 const std::string &FN = getSourceFileName(Id.second);
3301 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3302 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3304 Asm->EmitULEB128(Id.first, "Directory #");
3305 Asm->EmitULEB128(0, "Mod date");
3306 Asm->EmitULEB128(0, "File size");
3309 Asm->OutStreamer.AddComment("End of files");
3312 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3314 // A sequence for each text section.
3315 unsigned SecSrcLinesSize = SectionSourceLines.size();
3317 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3318 // Isolate current sections line info.
3319 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3321 // Dwarf assumes we start with first line of first source file.
3322 unsigned Source = 1;
3325 // Construct rows of the address, source, line, column matrix.
3326 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3327 const SrcLineInfo &LineInfo = LineInfos[i];
3328 MCSymbol *Label = LineInfo.getLabel();
3329 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3331 if (Asm->isVerbose()) {
3332 std::pair<unsigned, unsigned> SrcID =
3333 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3334 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3336 Twine(getSourceFileName(SrcID.second)) +
3337 ":" + Twine(LineInfo.getLine()));
3340 // Define the line address.
3341 Asm->OutStreamer.AddComment("Extended Op");
3343 Asm->OutStreamer.AddComment("Op size");
3344 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3346 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3347 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3349 Asm->OutStreamer.AddComment("Location label");
3350 Asm->OutStreamer.EmitSymbolValue(Label,
3351 Asm->getTargetData().getPointerSize(),
3354 // If change of source, then switch to the new source.
3355 if (Source != LineInfo.getSourceID()) {
3356 Source = LineInfo.getSourceID();
3357 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3358 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3359 Asm->EmitULEB128(Source, "New Source");
3362 // If change of line.
3363 if (Line != LineInfo.getLine()) {
3364 // Determine offset.
3365 int Offset = LineInfo.getLine() - Line;
3366 int Delta = Offset - MinLineDelta;
3369 Line = LineInfo.getLine();
3371 // If delta is small enough and in range...
3372 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3373 // ... then use fast opcode.
3374 Asm->OutStreamer.AddComment("Line Delta");
3375 Asm->EmitInt8(Delta - MinLineDelta);
3377 // ... otherwise use long hand.
3378 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3379 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3380 Asm->EmitSLEB128(Offset, "Line Offset");
3381 Asm->OutStreamer.AddComment("DW_LNS_copy");
3382 Asm->EmitInt8(dwarf::DW_LNS_copy);
3385 // Copy the previous row (different address or source)
3386 Asm->OutStreamer.AddComment("DW_LNS_copy");
3387 Asm->EmitInt8(dwarf::DW_LNS_copy);
3391 emitEndOfLineMatrix(j + 1);
3394 if (SecSrcLinesSize == 0)
3395 // Because we're emitting a debug_line section, we still need a line
3396 // table. The linker and friends expect it to exist. If there's nothing to
3397 // put into it, emit an empty table.
3398 emitEndOfLineMatrix(1);
3400 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3403 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3405 void DwarfDebug::emitCommonDebugFrame() {
3406 if (!Asm->MAI->doesDwarfRequireFrameSection())
3409 int stackGrowth = Asm->getTargetData().getPointerSize();
3410 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3411 TargetFrameInfo::StackGrowsDown)
3414 // Start the dwarf frame section.
3415 Asm->OutStreamer.SwitchSection(
3416 Asm->getObjFileLowering().getDwarfFrameSection());
3418 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3419 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3420 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3421 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3423 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3424 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3425 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3426 Asm->OutStreamer.AddComment("CIE Version");
3427 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3428 Asm->OutStreamer.AddComment("CIE Augmentation");
3429 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3430 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3431 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3432 Asm->OutStreamer.AddComment("CIE RA Column");
3433 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3434 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3436 std::vector<MachineMove> Moves;
3437 RI->getInitialFrameState(Moves);
3439 Asm->EmitFrameMoves(Moves, 0, false);
3441 Asm->EmitAlignment(2);
3442 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3445 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3448 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3449 if (!Asm->MAI->doesDwarfRequireFrameSection())
3452 // Start the dwarf frame section.
3453 Asm->OutStreamer.SwitchSection(
3454 Asm->getObjFileLowering().getDwarfFrameSection());
3456 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3457 MCSymbol *DebugFrameBegin =
3458 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3459 MCSymbol *DebugFrameEnd =
3460 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3461 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3463 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3465 Asm->OutStreamer.AddComment("FDE CIE offset");
3466 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3467 DwarfFrameSectionSym);
3469 Asm->OutStreamer.AddComment("FDE initial location");
3470 MCSymbol *FuncBeginSym =
3471 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3472 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3473 Asm->getTargetData().getPointerSize(),
3477 Asm->OutStreamer.AddComment("FDE address range");
3478 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3479 FuncBeginSym, Asm->getTargetData().getPointerSize());
3481 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3483 Asm->EmitAlignment(2);
3484 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3487 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3489 void DwarfDebug::emitDebugPubNames() {
3490 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3491 E = CUMap.end(); I != E; ++I) {
3492 CompileUnit *TheCU = I->second;
3493 // Start the dwarf pubnames section.
3494 Asm->OutStreamer.SwitchSection(
3495 Asm->getObjFileLowering().getDwarfPubNamesSection());
3497 Asm->OutStreamer.AddComment("Length of Public Names Info");
3498 Asm->EmitLabelDifference(
3499 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3500 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3502 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3505 Asm->OutStreamer.AddComment("DWARF Version");
3506 Asm->EmitInt16(dwarf::DWARF_VERSION);
3508 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3509 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3510 DwarfInfoSectionSym);
3512 Asm->OutStreamer.AddComment("Compilation Unit Length");
3513 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3514 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3517 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3518 for (StringMap<DIE*>::const_iterator
3519 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3520 const char *Name = GI->getKeyData();
3521 DIE *Entity = GI->second;
3523 Asm->OutStreamer.AddComment("DIE offset");
3524 Asm->EmitInt32(Entity->getOffset());
3526 if (Asm->isVerbose())
3527 Asm->OutStreamer.AddComment("External Name");
3528 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3531 Asm->OutStreamer.AddComment("End Mark");
3533 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3538 void DwarfDebug::emitDebugPubTypes() {
3539 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3540 E = CUMap.end(); I != E; ++I) {
3541 CompileUnit *TheCU = I->second;
3542 // Start the dwarf pubnames section.
3543 Asm->OutStreamer.SwitchSection(
3544 Asm->getObjFileLowering().getDwarfPubTypesSection());
3545 Asm->OutStreamer.AddComment("Length of Public Types Info");
3546 Asm->EmitLabelDifference(
3547 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3548 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3550 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3553 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3554 Asm->EmitInt16(dwarf::DWARF_VERSION);
3556 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3557 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3558 DwarfInfoSectionSym);
3560 Asm->OutStreamer.AddComment("Compilation Unit Length");
3561 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3562 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3565 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3566 for (StringMap<DIE*>::const_iterator
3567 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3568 const char *Name = GI->getKeyData();
3569 DIE * Entity = GI->second;
3571 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3572 Asm->EmitInt32(Entity->getOffset());
3574 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3575 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3578 Asm->OutStreamer.AddComment("End Mark");
3580 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3585 /// emitDebugStr - Emit visible names into a debug str section.
3587 void DwarfDebug::emitDebugStr() {
3588 // Check to see if it is worth the effort.
3589 if (StringPool.empty()) return;
3591 // Start the dwarf str section.
3592 Asm->OutStreamer.SwitchSection(
3593 Asm->getObjFileLowering().getDwarfStrSection());
3595 // Get all of the string pool entries and put them in an array by their ID so
3596 // we can sort them.
3597 SmallVector<std::pair<unsigned,
3598 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3600 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3601 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3602 Entries.push_back(std::make_pair(I->second.second, &*I));
3604 array_pod_sort(Entries.begin(), Entries.end());
3606 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3607 // Emit a label for reference from debug information entries.
3608 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3610 // Emit the string itself.
3611 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3615 /// emitDebugLoc - Emit visible names into a debug loc section.
3617 void DwarfDebug::emitDebugLoc() {
3618 if (DotDebugLocEntries.empty())
3621 // Start the dwarf loc section.
3622 Asm->OutStreamer.SwitchSection(
3623 Asm->getObjFileLowering().getDwarfLocSection());
3624 unsigned char Size = Asm->getTargetData().getPointerSize();
3625 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3627 for (SmallVector<DotDebugLocEntry, 4>::iterator
3628 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3629 I != E; ++I, ++index) {
3630 DotDebugLocEntry Entry = *I;
3631 if (Entry.isEmpty()) {
3632 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3633 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3634 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3636 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3637 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3638 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3639 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3641 Asm->OutStreamer.AddComment("Loc expr size");
3643 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3645 Asm->OutStreamer.AddComment("Loc expr size");
3646 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3647 Asm->EmitInt8(dwarf::DW_OP_regx);
3648 Asm->EmitULEB128(Reg);
3654 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3656 void DwarfDebug::EmitDebugARanges() {
3657 // Start the dwarf aranges section.
3658 Asm->OutStreamer.SwitchSection(
3659 Asm->getObjFileLowering().getDwarfARangesSection());
3662 /// emitDebugRanges - Emit visible names into a debug ranges section.
3664 void DwarfDebug::emitDebugRanges() {
3665 // Start the dwarf ranges section.
3666 Asm->OutStreamer.SwitchSection(
3667 Asm->getObjFileLowering().getDwarfRangesSection());
3668 unsigned char Size = Asm->getTargetData().getPointerSize();
3669 for (SmallVector<const MCSymbol *, 8>::iterator
3670 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3673 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3675 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3679 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3681 void DwarfDebug::emitDebugMacInfo() {
3682 if (const MCSection *LineInfo =
3683 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3684 // Start the dwarf macinfo section.
3685 Asm->OutStreamer.SwitchSection(LineInfo);
3689 /// emitDebugInlineInfo - Emit inline info using following format.
3691 /// 1. length of section
3692 /// 2. Dwarf version number
3693 /// 3. address size.
3695 /// Entries (one "entry" for each function that was inlined):
3697 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3698 /// otherwise offset into __debug_str for regular function name.
3699 /// 2. offset into __debug_str section for regular function name.
3700 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3701 /// instances for the function.
3703 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3704 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3705 /// __debug_info section, and the low_pc is the starting address for the
3706 /// inlining instance.
3707 void DwarfDebug::emitDebugInlineInfo() {
3708 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3714 Asm->OutStreamer.SwitchSection(
3715 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3717 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3718 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3719 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3721 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3723 Asm->OutStreamer.AddComment("Dwarf Version");
3724 Asm->EmitInt16(dwarf::DWARF_VERSION);
3725 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3726 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3728 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3729 E = InlinedSPNodes.end(); I != E; ++I) {
3731 const MDNode *Node = *I;
3732 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3733 = InlineInfo.find(Node);
3734 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3735 DISubprogram SP(Node);
3736 StringRef LName = SP.getLinkageName();
3737 StringRef Name = SP.getName();
3739 Asm->OutStreamer.AddComment("MIPS linkage name");
3740 if (LName.empty()) {
3741 Asm->OutStreamer.EmitBytes(Name, 0);
3742 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3744 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3745 DwarfStrSectionSym);
3747 Asm->OutStreamer.AddComment("Function name");
3748 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3749 Asm->EmitULEB128(Labels.size(), "Inline count");
3751 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3752 LE = Labels.end(); LI != LE; ++LI) {
3753 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3754 Asm->EmitInt32(LI->second->getOffset());
3756 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3757 Asm->OutStreamer.EmitSymbolValue(LI->first,
3758 Asm->getTargetData().getPointerSize(),0);
3762 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));