1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
48 cl::desc("Disable debug info printing"));
50 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
51 cl::desc("Make an absense of debug location information explicit."),
55 const char *DWARFGroupName = "DWARF Emission";
56 const char *DbgTimerName = "DWARF Debug Writer";
57 } // end anonymous namespace
59 //===----------------------------------------------------------------------===//
61 /// Configuration values for initial hash set sizes (log2).
63 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
67 //===----------------------------------------------------------------------===//
68 /// CompileUnit - This dwarf writer support class manages information associate
69 /// with a source file.
71 /// ID - File identifier for source.
75 /// Die - Compile unit debug information entry.
77 const OwningPtr<DIE> CUDie;
79 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
82 /// GVToDieMap - Tracks the mapping of unit level debug informaton
83 /// variables to debug information entries.
84 /// FIXME : Rename GVToDieMap -> NodeToDieMap
85 DenseMap<const MDNode *, DIE *> GVToDieMap;
87 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
90 DenseMap<const MDNode *, DIEEntry *> GVToDIEEntryMap;
92 /// Globals - A map of globally visible named entities for this unit.
94 StringMap<DIE*> Globals;
96 /// GlobalTypes - A map of globally visible types for this unit.
98 StringMap<DIE*> GlobalTypes;
101 CompileUnit(unsigned I, DIE *D)
102 : ID(I), CUDie(D), IndexTyDie(0) {}
105 unsigned getID() const { return ID; }
106 DIE* getCUDie() const { return CUDie.get(); }
107 const StringMap<DIE*> &getGlobals() const { return Globals; }
108 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
110 /// hasContent - Return true if this compile unit has something to write out.
112 bool hasContent() const { return !CUDie->getChildren().empty(); }
114 /// addGlobal - Add a new global entity to the compile unit.
116 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
118 /// addGlobalType - Add a new global type to the compile unit.
120 void addGlobalType(StringRef Name, DIE *Die) {
121 GlobalTypes[Name] = Die;
124 /// getDIE - Returns the debug information entry map slot for the
125 /// specified debug variable.
126 DIE *getDIE(const MDNode *N) { return GVToDieMap.lookup(N); }
128 /// insertDIE - Insert DIE into the map.
129 void insertDIE(const MDNode *N, DIE *D) {
130 GVToDieMap.insert(std::make_pair(N, D));
133 /// getDIEEntry - Returns the debug information entry for the speciefied
135 DIEEntry *getDIEEntry(const MDNode *N) {
136 DenseMap<const MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
137 if (I == GVToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 GVToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 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 FunctionBeginSym = FunctionEndSym = 0;
326 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
330 DwarfDebug::~DwarfDebug() {
331 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
332 DIEBlocks[j]->~DIEBlock();
335 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
336 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
337 if (Entry.first) return Entry.first;
339 Entry.second = NextStringPoolNumber++;
340 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
344 /// assignAbbrevNumber - Define a unique number for the abbreviation.
346 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
347 // Profile the node so that we can make it unique.
351 // Check the set for priors.
352 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
354 // If it's newly added.
355 if (InSet == &Abbrev) {
356 // Add to abbreviation list.
357 Abbreviations.push_back(&Abbrev);
359 // Assign the vector position + 1 as its number.
360 Abbrev.setNumber(Abbreviations.size());
362 // Assign existing abbreviation number.
363 Abbrev.setNumber(InSet->getNumber());
367 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
368 /// information entry.
369 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
370 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
374 /// addUInt - Add an unsigned integer attribute data and value.
376 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
377 unsigned Form, uint64_t Integer) {
378 if (!Form) Form = DIEInteger::BestForm(false, Integer);
379 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
380 Die->addValue(Attribute, Form, Value);
383 /// addSInt - Add an signed integer attribute data and value.
385 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
386 unsigned Form, int64_t Integer) {
387 if (!Form) Form = DIEInteger::BestForm(true, Integer);
388 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
389 Die->addValue(Attribute, Form, Value);
392 /// addString - Add a string attribute data and value. DIEString only
393 /// keeps string reference.
394 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
396 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
397 Die->addValue(Attribute, Form, Value);
400 /// addLabel - Add a Dwarf label attribute data and value.
402 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
403 const MCSymbol *Label) {
404 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
405 Die->addValue(Attribute, Form, Value);
408 /// addDelta - Add a label delta attribute data and value.
410 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
411 const MCSymbol *Hi, const MCSymbol *Lo) {
412 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
413 Die->addValue(Attribute, Form, Value);
416 /// addDIEEntry - Add a DIE attribute data and value.
418 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
420 Die->addValue(Attribute, Form, createDIEEntry(Entry));
424 /// addBlock - Add block data.
426 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
428 Block->ComputeSize(Asm);
429 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
430 Die->addValue(Attribute, Block->BestForm(), Block);
433 /// addSourceLine - Add location information to specified debug information
435 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
440 unsigned Line = V->getLineNumber();
441 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
442 V->getContext().getFilename());
443 assert(FileID && "Invalid file id");
444 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
445 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
448 /// addSourceLine - Add location information to specified debug information
450 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
451 // Verify global variable.
455 unsigned Line = G->getLineNumber();
456 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
457 G->getContext().getFilename());
458 assert(FileID && "Invalid file id");
459 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
460 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
463 /// addSourceLine - Add location information to specified debug information
465 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
466 // Verify subprogram.
469 // If the line number is 0, don't add it.
470 if (SP->getLineNumber() == 0)
473 unsigned Line = SP->getLineNumber();
474 if (!SP->getContext().Verify())
476 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
478 assert(FileID && "Invalid file id");
479 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
480 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
483 /// addSourceLine - Add location information to specified debug information
485 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
490 unsigned Line = Ty->getLineNumber();
491 if (!Ty->getContext().Verify())
493 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
494 Ty->getContext().getFilename());
495 assert(FileID && "Invalid file id");
496 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
497 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
500 /// addSourceLine - Add location information to specified debug information
502 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
507 unsigned Line = NS->getLineNumber();
508 StringRef FN = NS->getFilename();
509 StringRef Dir = NS->getDirectory();
511 unsigned FileID = GetOrCreateSourceID(Dir, FN);
512 assert(FileID && "Invalid file id");
513 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
514 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
517 /* Byref variables, in Blocks, are declared by the programmer as
518 "SomeType VarName;", but the compiler creates a
519 __Block_byref_x_VarName struct, and gives the variable VarName
520 either the struct, or a pointer to the struct, as its type. This
521 is necessary for various behind-the-scenes things the compiler
522 needs to do with by-reference variables in blocks.
524 However, as far as the original *programmer* is concerned, the
525 variable should still have type 'SomeType', as originally declared.
527 The following function dives into the __Block_byref_x_VarName
528 struct to find the original type of the variable. This will be
529 passed back to the code generating the type for the Debug
530 Information Entry for the variable 'VarName'. 'VarName' will then
531 have the original type 'SomeType' in its debug information.
533 The original type 'SomeType' will be the type of the field named
534 'VarName' inside the __Block_byref_x_VarName struct.
536 NOTE: In order for this to not completely fail on the debugger
537 side, the Debug Information Entry for the variable VarName needs to
538 have a DW_AT_location that tells the debugger how to unwind through
539 the pointers and __Block_byref_x_VarName struct to find the actual
540 value of the variable. The function addBlockByrefType does this. */
542 /// Find the type the programmer originally declared the variable to be
543 /// and return that type.
545 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
548 unsigned tag = Ty.getTag();
550 if (tag == dwarf::DW_TAG_pointer_type) {
551 DIDerivedType DTy = DIDerivedType(Ty);
552 subType = DTy.getTypeDerivedFrom();
555 DICompositeType blockStruct = DICompositeType(subType);
556 DIArray Elements = blockStruct.getTypeArray();
558 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
559 DIDescriptor Element = Elements.getElement(i);
560 DIDerivedType DT = DIDerivedType(Element);
561 if (Name == DT.getName())
562 return (DT.getTypeDerivedFrom());
568 /// addComplexAddress - Start with the address based on the location provided,
569 /// and generate the DWARF information necessary to find the actual variable
570 /// given the extra address information encoded in the DIVariable, starting from
571 /// the starting location. Add the DWARF information to the die.
573 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
575 const MachineLocation &Location) {
576 const DIVariable &VD = DV->getVariable();
577 DIType Ty = VD.getType();
579 // Decode the original location, and use that as the start of the byref
580 // variable's location.
581 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
582 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
583 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
585 if (Location.isReg()) {
587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
589 Reg = Reg - dwarf::DW_OP_reg0;
590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
591 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
595 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
598 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
601 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
604 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
605 uint64_t Element = VD.getAddrElement(i);
607 if (Element == DIFactory::OpPlus) {
608 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
609 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
610 } else if (Element == DIFactory::OpDeref) {
611 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
612 } else llvm_unreachable("unknown DIFactory Opcode");
615 // Now attach the location information to the DIE.
616 addBlock(Die, Attribute, 0, Block);
619 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
620 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
621 gives the variable VarName either the struct, or a pointer to the struct, as
622 its type. This is necessary for various behind-the-scenes things the
623 compiler needs to do with by-reference variables in Blocks.
625 However, as far as the original *programmer* is concerned, the variable
626 should still have type 'SomeType', as originally declared.
628 The function getBlockByrefType dives into the __Block_byref_x_VarName
629 struct to find the original type of the variable, which is then assigned to
630 the variable's Debug Information Entry as its real type. So far, so good.
631 However now the debugger will expect the variable VarName to have the type
632 SomeType. So we need the location attribute for the variable to be an
633 expression that explains to the debugger how to navigate through the
634 pointers and struct to find the actual variable of type SomeType.
636 The following function does just that. We start by getting
637 the "normal" location for the variable. This will be the location
638 of either the struct __Block_byref_x_VarName or the pointer to the
639 struct __Block_byref_x_VarName.
641 The struct will look something like:
643 struct __Block_byref_x_VarName {
645 struct __Block_byref_x_VarName *forwarding;
646 ... <various other fields>
648 ... <maybe more fields>
651 If we are given the struct directly (as our starting point) we
652 need to tell the debugger to:
654 1). Add the offset of the forwarding field.
656 2). Follow that pointer to get the real __Block_byref_x_VarName
657 struct to use (the real one may have been copied onto the heap).
659 3). Add the offset for the field VarName, to find the actual variable.
661 If we started with a pointer to the struct, then we need to
662 dereference that pointer first, before the other steps.
663 Translating this into DWARF ops, we will need to append the following
664 to the current location description for the variable:
666 DW_OP_deref -- optional, if we start with a pointer
667 DW_OP_plus_uconst <forward_fld_offset>
669 DW_OP_plus_uconst <varName_fld_offset>
671 That is what this function does. */
673 /// addBlockByrefAddress - Start with the address based on the location
674 /// provided, and generate the DWARF information necessary to find the
675 /// actual Block variable (navigating the Block struct) based on the
676 /// starting location. Add the DWARF information to the die. For
677 /// more information, read large comment just above here.
679 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
681 const MachineLocation &Location) {
682 const DIVariable &VD = DV->getVariable();
683 DIType Ty = VD.getType();
685 unsigned Tag = Ty.getTag();
686 bool isPointer = false;
688 StringRef varName = VD.getName();
690 if (Tag == dwarf::DW_TAG_pointer_type) {
691 DIDerivedType DTy = DIDerivedType(Ty);
692 TmpTy = DTy.getTypeDerivedFrom();
696 DICompositeType blockStruct = DICompositeType(TmpTy);
698 // Find the __forwarding field and the variable field in the __Block_byref
700 DIArray Fields = blockStruct.getTypeArray();
701 DIDescriptor varField = DIDescriptor();
702 DIDescriptor forwardingField = DIDescriptor();
704 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
705 DIDescriptor Element = Fields.getElement(i);
706 DIDerivedType DT = DIDerivedType(Element);
707 StringRef fieldName = DT.getName();
708 if (fieldName == "__forwarding")
709 forwardingField = Element;
710 else if (fieldName == varName)
714 // Get the offsets for the forwarding field and the variable field.
715 unsigned forwardingFieldOffset =
716 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
717 unsigned varFieldOffset =
718 DIDerivedType(varField).getOffsetInBits() >> 3;
720 // Decode the original location, and use that as the start of the byref
721 // variable's location.
722 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
723 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
724 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
726 if (Location.isReg()) {
728 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
730 Reg = Reg - dwarf::DW_OP_reg0;
731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
732 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
736 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
739 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
742 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
745 // If we started with a pointer to the __Block_byref... struct, then
746 // the first thing we need to do is dereference the pointer (DW_OP_deref).
748 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
750 // Next add the offset for the '__forwarding' field:
751 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
752 // adding the offset if it's 0.
753 if (forwardingFieldOffset > 0) {
754 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
755 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
758 // Now dereference the __forwarding field to get to the real __Block_byref
759 // struct: DW_OP_deref.
760 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
762 // Now that we've got the real __Block_byref... struct, add the offset
763 // for the variable's field to get to the location of the actual variable:
764 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
765 if (varFieldOffset > 0) {
766 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
767 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
770 // Now attach the location information to the DIE.
771 addBlock(Die, Attribute, 0, Block);
774 /// addAddress - Add an address attribute to a die based on the location
776 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
777 const MachineLocation &Location) {
778 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
779 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
780 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
782 if (Location.isReg()) {
784 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
787 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
791 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
794 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
797 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
800 addBlock(Die, Attribute, 0, Block);
803 /// addRegisterAddress - Add register location entry in variable DIE.
804 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
805 const MachineOperand &MO) {
806 assert (MO.isReg() && "Invalid machine operand!");
809 MachineLocation Location;
810 Location.set(MO.getReg());
811 addAddress(Die, dwarf::DW_AT_location, Location);
813 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
817 /// addConstantValue - Add constant value entry in variable DIE.
818 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
819 const MachineOperand &MO) {
820 assert (MO.isImm() && "Invalid machine operand!");
821 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
822 unsigned Imm = MO.getImm();
823 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
824 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
826 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
830 /// addConstantFPValue - Add constant value entry in variable DIE.
831 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
832 const MachineOperand &MO) {
833 assert (MO.isFPImm() && "Invalid machine operand!");
834 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
835 APFloat FPImm = MO.getFPImm()->getValueAPF();
837 // Get the raw data form of the floating point.
838 const APInt FltVal = FPImm.bitcastToAPInt();
839 const char *FltPtr = (const char*)FltVal.getRawData();
841 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
842 bool LittleEndian = Asm->getTargetData().isLittleEndian();
843 int Incr = (LittleEndian ? 1 : -1);
844 int Start = (LittleEndian ? 0 : NumBytes - 1);
845 int Stop = (LittleEndian ? NumBytes : -1);
847 // Output the constant to DWARF one byte at a time.
848 for (; Start != Stop; Start += Incr)
849 addUInt(Block, 0, dwarf::DW_FORM_data1,
850 (unsigned char)0xFF & FltPtr[Start]);
852 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
854 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
859 /// addToContextOwner - Add Die into the list of its context owner's children.
860 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
861 if (Context.isType()) {
862 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
863 ContextDIE->addChild(Die);
864 } else if (Context.isNameSpace()) {
865 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
866 ContextDIE->addChild(Die);
867 } else if (Context.isSubprogram()) {
868 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
870 ContextDIE->addChild(Die);
871 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
872 ContextDIE->addChild(Die);
874 getCompileUnit(Context)->addDie(Die);
877 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
879 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
880 CompileUnit *TypeCU = getCompileUnit(Ty);
881 DIE *TyDIE = TypeCU->getDIE(Ty);
886 TyDIE = new DIE(dwarf::DW_TAG_base_type);
887 TypeCU->insertDIE(Ty, TyDIE);
888 if (Ty.isBasicType())
889 constructTypeDIE(*TyDIE, DIBasicType(Ty));
890 else if (Ty.isCompositeType())
891 constructTypeDIE(*TyDIE, DICompositeType(Ty));
893 assert(Ty.isDerivedType() && "Unknown kind of DIType");
894 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
897 addToContextOwner(TyDIE, Ty.getContext());
901 /// addType - Add a new type attribute to the specified entity.
902 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
906 // Check for pre-existence.
907 CompileUnit *TypeCU = getCompileUnit(Ty);
908 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
909 // If it exists then use the existing value.
911 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
916 DIE *Buffer = getOrCreateTypeDIE(Ty);
919 Entry = createDIEEntry(Buffer);
920 TypeCU->insertDIEEntry(Ty, Entry);
922 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
925 /// constructTypeDIE - Construct basic type die from DIBasicType.
926 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
927 // Get core information.
928 StringRef Name = BTy.getName();
929 Buffer.setTag(dwarf::DW_TAG_base_type);
930 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
933 // Add name if not anonymous or intermediate type.
935 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
936 uint64_t Size = BTy.getSizeInBits() >> 3;
937 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
940 /// constructTypeDIE - Construct derived type die from DIDerivedType.
941 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
942 // Get core information.
943 StringRef Name = DTy.getName();
944 uint64_t Size = DTy.getSizeInBits() >> 3;
945 unsigned Tag = DTy.getTag();
947 // FIXME - Workaround for templates.
948 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
952 // Map to main type, void will not have a type.
953 DIType FromTy = DTy.getTypeDerivedFrom();
954 addType(&Buffer, FromTy);
956 // Add name if not anonymous or intermediate type.
958 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
960 // Add size if non-zero (derived types might be zero-sized.)
962 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
964 // Add source line info if available and TyDesc is not a forward declaration.
965 if (!DTy.isForwardDecl())
966 addSourceLine(&Buffer, &DTy);
969 /// constructTypeDIE - Construct type DIE from DICompositeType.
970 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
971 // Get core information.
972 StringRef Name = CTy.getName();
974 uint64_t Size = CTy.getSizeInBits() >> 3;
975 unsigned Tag = CTy.getTag();
979 case dwarf::DW_TAG_vector_type:
980 case dwarf::DW_TAG_array_type:
981 constructArrayTypeDIE(Buffer, &CTy);
983 case dwarf::DW_TAG_enumeration_type: {
984 DIArray Elements = CTy.getTypeArray();
986 // Add enumerators to enumeration type.
987 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
989 DIDescriptor Enum(Elements.getElement(i));
990 if (Enum.isEnumerator()) {
991 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
992 Buffer.addChild(ElemDie);
997 case dwarf::DW_TAG_subroutine_type: {
999 DIArray Elements = CTy.getTypeArray();
1000 DIDescriptor RTy = Elements.getElement(0);
1001 addType(&Buffer, DIType(RTy));
1003 // Add prototype flag.
1004 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1007 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1008 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1009 DIDescriptor Ty = Elements.getElement(i);
1010 addType(Arg, DIType(Ty));
1011 Buffer.addChild(Arg);
1015 case dwarf::DW_TAG_structure_type:
1016 case dwarf::DW_TAG_union_type:
1017 case dwarf::DW_TAG_class_type: {
1018 // Add elements to structure type.
1019 DIArray Elements = CTy.getTypeArray();
1021 // A forward struct declared type may not have elements available.
1022 unsigned N = Elements.getNumElements();
1026 // Add elements to structure type.
1027 for (unsigned i = 0; i < N; ++i) {
1028 DIDescriptor Element = Elements.getElement(i);
1029 DIE *ElemDie = NULL;
1030 if (Element.isSubprogram())
1031 ElemDie = createSubprogramDIE(DISubprogram(Element));
1032 else if (Element.isVariable()) {
1033 DIVariable DV(Element);
1034 ElemDie = new DIE(dwarf::DW_TAG_variable);
1035 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1037 addType(ElemDie, DV.getType());
1038 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1039 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1040 addSourceLine(ElemDie, &DV);
1041 } else if (Element.isDerivedType())
1042 ElemDie = createMemberDIE(DIDerivedType(Element));
1045 Buffer.addChild(ElemDie);
1048 if (CTy.isAppleBlockExtension())
1049 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1051 unsigned RLang = CTy.getRunTimeLang();
1053 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1054 dwarf::DW_FORM_data1, RLang);
1056 DICompositeType ContainingType = CTy.getContainingType();
1057 if (DIDescriptor(ContainingType).isCompositeType())
1058 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1059 getOrCreateTypeDIE(DIType(ContainingType)));
1061 DIDescriptor Context = CTy.getContext();
1062 addToContextOwner(&Buffer, Context);
1070 // Add name if not anonymous or intermediate type.
1072 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1074 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1075 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1076 // Add size if non-zero (derived types might be zero-sized.)
1078 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1080 // Add zero size if it is not a forward declaration.
1081 if (CTy.isForwardDecl())
1082 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1084 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1087 // Add source line info if available.
1088 if (!CTy.isForwardDecl())
1089 addSourceLine(&Buffer, &CTy);
1093 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1094 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1095 int64_t L = SR.getLo();
1096 int64_t H = SR.getHi();
1097 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1099 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1101 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1102 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1104 Buffer.addChild(DW_Subrange);
1107 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1108 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1109 DICompositeType *CTy) {
1110 Buffer.setTag(dwarf::DW_TAG_array_type);
1111 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1112 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1114 // Emit derived type.
1115 addType(&Buffer, CTy->getTypeDerivedFrom());
1116 DIArray Elements = CTy->getTypeArray();
1118 // Get an anonymous type for index type.
1119 CompileUnit *TheCU = getCompileUnit(*CTy);
1120 DIE *IdxTy = TheCU->getIndexTyDie();
1122 // Construct an anonymous type for index type.
1123 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1124 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1125 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1126 dwarf::DW_ATE_signed);
1127 TheCU->addDie(IdxTy);
1128 TheCU->setIndexTyDie(IdxTy);
1131 // Add subranges to array type.
1132 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1133 DIDescriptor Element = Elements.getElement(i);
1134 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1135 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1139 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1140 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1141 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1142 StringRef Name = ETy.getName();
1143 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1144 int64_t Value = ETy.getEnumValue();
1145 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1149 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1150 /// printer to not emit usual symbol prefix before the symbol name is used then
1151 /// return linkage name after skipping this special LLVM prefix.
1152 static StringRef getRealLinkageName(StringRef LinkageName) {
1154 if (LinkageName.startswith(StringRef(&One, 1)))
1155 return LinkageName.substr(1);
1159 /// createGlobalVariableDIE - Create new DIE using GV.
1160 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1161 // If the global variable was optmized out then no need to create debug info
1163 if (!GV.getGlobal()) return NULL;
1164 if (GV.getDisplayName().empty()) return NULL;
1166 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1167 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1168 GV.getDisplayName());
1170 StringRef LinkageName = GV.getLinkageName();
1171 if (!LinkageName.empty())
1172 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1173 getRealLinkageName(LinkageName));
1175 addType(GVDie, GV.getType());
1176 if (!GV.isLocalToUnit())
1177 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1178 addSourceLine(GVDie, &GV);
1183 /// createMemberDIE - Create new member DIE.
1184 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1185 DIE *MemberDie = new DIE(DT.getTag());
1186 StringRef Name = DT.getName();
1188 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1190 addType(MemberDie, DT.getTypeDerivedFrom());
1192 addSourceLine(MemberDie, &DT);
1194 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1195 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1197 uint64_t Size = DT.getSizeInBits();
1198 uint64_t FieldSize = DT.getOriginalTypeSize();
1200 if (Size != FieldSize) {
1202 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1203 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1205 uint64_t Offset = DT.getOffsetInBits();
1206 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1207 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1208 uint64_t FieldOffset = (HiMark - FieldSize);
1209 Offset -= FieldOffset;
1211 // Maybe we need to work from the other end.
1212 if (Asm->getTargetData().isLittleEndian())
1213 Offset = FieldSize - (Offset + Size);
1214 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1216 // Here WD_AT_data_member_location points to the anonymous
1217 // field that includes this bit field.
1218 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1221 // This is not a bitfield.
1222 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1224 if (DT.getTag() == dwarf::DW_TAG_inheritance
1225 && DT.isVirtual()) {
1227 // For C++, virtual base classes are not at fixed offset. Use following
1228 // expression to extract appropriate offset from vtable.
1229 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1231 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1232 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1233 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1234 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1240 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1243 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1245 if (DT.isProtected())
1246 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1247 dwarf::DW_ACCESS_protected);
1248 else if (DT.isPrivate())
1249 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1250 dwarf::DW_ACCESS_private);
1251 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1252 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1253 dwarf::DW_ACCESS_public);
1255 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1256 dwarf::DW_VIRTUALITY_virtual);
1260 /// createSubprogramDIE - Create new DIE using SP.
1261 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1262 CompileUnit *SPCU = getCompileUnit(SP);
1263 DIE *SPDie = SPCU->getDIE(SP);
1267 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1268 // Constructors and operators for anonymous aggregates do not have names.
1269 if (!SP.getName().empty())
1270 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1272 StringRef LinkageName = SP.getLinkageName();
1273 if (!LinkageName.empty())
1274 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1275 getRealLinkageName(LinkageName));
1277 addSourceLine(SPDie, &SP);
1279 // Add prototyped tag, if C or ObjC.
1280 unsigned Lang = SP.getCompileUnit().getLanguage();
1281 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1282 Lang == dwarf::DW_LANG_ObjC)
1283 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1286 DICompositeType SPTy = SP.getType();
1287 DIArray Args = SPTy.getTypeArray();
1288 unsigned SPTag = SPTy.getTag();
1290 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1291 addType(SPDie, SPTy);
1293 addType(SPDie, DIType(Args.getElement(0)));
1295 unsigned VK = SP.getVirtuality();
1297 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1298 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1299 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1300 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1301 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1302 ContainingTypeMap.insert(std::make_pair(SPDie,
1303 SP.getContainingType()));
1306 if (MakeDecl || !SP.isDefinition()) {
1307 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1309 // Add arguments. Do not add arguments for subprogram definition. They will
1310 // be handled while processing variables.
1311 DICompositeType SPTy = SP.getType();
1312 DIArray Args = SPTy.getTypeArray();
1313 unsigned SPTag = SPTy.getTag();
1315 if (SPTag == dwarf::DW_TAG_subroutine_type)
1316 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1317 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1318 DIType ATy = DIType(DIType(Args.getElement(i)));
1320 if (ATy.isArtificial())
1321 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1322 SPDie->addChild(Arg);
1326 if (SP.isArtificial())
1327 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1329 if (!SP.isLocalToUnit())
1330 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1332 if (SP.isOptimized())
1333 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1335 // DW_TAG_inlined_subroutine may refer to this DIE.
1336 SPCU->insertDIE(SP, SPDie);
1338 // Add to context owner.
1339 addToContextOwner(SPDie, SP.getContext());
1344 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1345 assert(N && "Invalid Scope encoding!");
1347 DbgScope *AScope = AbstractScopes.lookup(N);
1351 DbgScope *Parent = NULL;
1353 DIDescriptor Scope(N);
1354 if (Scope.isLexicalBlock()) {
1355 DILexicalBlock DB(N);
1356 DIDescriptor ParentDesc = DB.getContext();
1357 Parent = getOrCreateAbstractScope(ParentDesc);
1360 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1363 Parent->addScope(AScope);
1364 AScope->setAbstractScope();
1365 AbstractScopes[N] = AScope;
1366 if (DIDescriptor(N).isSubprogram())
1367 AbstractScopesList.push_back(AScope);
1371 /// isSubprogramContext - Return true if Context is either a subprogram
1372 /// or another context nested inside a subprogram.
1373 static bool isSubprogramContext(const MDNode *Context) {
1376 DIDescriptor D(Context);
1377 if (D.isSubprogram())
1380 return isSubprogramContext(DIType(Context).getContext());
1384 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1385 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1386 /// If there are global variables in this scope then create and insert
1387 /// DIEs for these variables.
1388 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1389 CompileUnit *SPCU = getCompileUnit(SPNode);
1390 DIE *SPDie = SPCU->getDIE(SPNode);
1391 assert(SPDie && "Unable to find subprogram DIE!");
1392 DISubprogram SP(SPNode);
1394 // There is not any need to generate specification DIE for a function
1395 // defined at compile unit level. If a function is defined inside another
1396 // function then gdb prefers the definition at top level and but does not
1397 // expect specification DIE in parent function. So avoid creating
1398 // specification DIE for a function defined inside a function.
1399 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1400 !SP.getContext().isFile() &&
1401 !isSubprogramContext(SP.getContext())) {
1402 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1405 DICompositeType SPTy = SP.getType();
1406 DIArray Args = SPTy.getTypeArray();
1407 unsigned SPTag = SPTy.getTag();
1408 if (SPTag == dwarf::DW_TAG_subroutine_type)
1409 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1410 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1411 DIType ATy = DIType(DIType(Args.getElement(i)));
1413 if (ATy.isArtificial())
1414 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1415 SPDie->addChild(Arg);
1417 DIE *SPDeclDie = SPDie;
1418 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1419 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1421 SPCU->addDie(SPDie);
1424 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1425 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1426 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1427 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1428 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1429 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1430 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1435 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1436 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1437 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1439 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1440 if (Scope->isAbstractScope())
1443 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1447 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1448 if (Ranges.size() > 1) {
1449 // .debug_range section has not been laid out yet. Emit offset in
1450 // .debug_range as a uint, size 4, for now. emitDIE will handle
1451 // DW_AT_ranges appropriately.
1452 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1453 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1454 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1455 RE = Ranges.end(); RI != RE; ++RI) {
1456 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1457 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1459 DebugRangeSymbols.push_back(NULL);
1460 DebugRangeSymbols.push_back(NULL);
1464 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1465 const MCSymbol *End = getLabelAfterInsn(RI->second);
1467 if (End == 0) return 0;
1469 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1470 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1472 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1473 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1478 /// constructInlinedScopeDIE - This scope represents inlined body of
1479 /// a function. Construct DIE to represent this concrete inlined copy
1480 /// of the function.
1481 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1483 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1484 assert (Ranges.empty() == false
1485 && "DbgScope does not have instruction markers!");
1487 // FIXME : .debug_inlined section specification does not clearly state how
1488 // to emit inlined scope that is split into multiple instruction ranges.
1489 // For now, use first instruction range and emit low_pc/high_pc pair and
1490 // corresponding .debug_inlined section entry for this pair.
1491 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1492 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1493 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1495 if (StartLabel == FunctionBeginSym || EndLabel == 0) {
1496 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1499 assert(StartLabel->isDefined() &&
1500 "Invalid starting label for an inlined scope!");
1501 assert(EndLabel->isDefined() &&
1502 "Invalid end label for an inlined scope!");
1504 if (!Scope->getScopeNode())
1506 DIScope DS(Scope->getScopeNode());
1507 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1509 DISubprogram InlinedSP = getDISubprogram(DS);
1510 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1511 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1512 assert(OriginDIE && "Unable to find Origin DIE!");
1513 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1514 dwarf::DW_FORM_ref4, OriginDIE);
1516 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1517 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1519 InlinedSubprogramDIEs.insert(OriginDIE);
1521 // Track the start label for this inlined function.
1522 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1523 I = InlineInfo.find(InlinedSP);
1525 if (I == InlineInfo.end()) {
1526 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1528 InlinedSPNodes.push_back(InlinedSP);
1530 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1532 DILocation DL(Scope->getInlinedAt());
1533 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1534 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1540 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1541 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1542 // Get the descriptor.
1543 const DIVariable &VD = DV->getVariable();
1544 StringRef Name = VD.getName();
1548 // Translate tag to proper Dwarf tag. The result variable is dropped for
1551 switch (VD.getTag()) {
1552 case dwarf::DW_TAG_return_variable:
1554 case dwarf::DW_TAG_arg_variable:
1555 Tag = dwarf::DW_TAG_formal_parameter;
1557 case dwarf::DW_TAG_auto_variable: // fall thru
1559 Tag = dwarf::DW_TAG_variable;
1563 // Define variable debug information entry.
1564 DIE *VariableDie = new DIE(Tag);
1567 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1568 V2AVI = VarToAbstractVarMap.find(DV);
1569 if (V2AVI != VarToAbstractVarMap.end())
1570 AbsDIE = V2AVI->second->getDIE();
1573 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1574 dwarf::DW_FORM_ref4, AbsDIE);
1576 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1577 addSourceLine(VariableDie, &VD);
1579 // Add variable type.
1580 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1581 // addresses instead.
1582 if (VD.isBlockByrefVariable())
1583 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1585 addType(VariableDie, VD.getType());
1588 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1589 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1591 if (Scope->isAbstractScope()) {
1592 DV->setDIE(VariableDie);
1596 // Add variable address.
1598 unsigned Offset = DV->getDotDebugLocOffset();
1599 if (Offset != ~0U) {
1600 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1601 Asm->GetTempSymbol("debug_loc", Offset));
1602 DV->setDIE(VariableDie);
1603 UseDotDebugLocEntry.insert(VariableDie);
1607 // Check if variable is described by a DBG_VALUE instruction.
1608 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1609 DbgVariableToDbgInstMap.find(DV);
1610 if (DVI != DbgVariableToDbgInstMap.end()) {
1611 const MachineInstr *DVInsn = DVI->second;
1612 const MCSymbol *DVLabel = findVariableLabel(DV);
1613 bool updated = false;
1614 // FIXME : Handle getNumOperands != 3
1615 if (DVInsn->getNumOperands() == 3) {
1616 if (DVInsn->getOperand(0).isReg())
1617 updated = addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1618 else if (DVInsn->getOperand(0).isImm())
1619 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1620 else if (DVInsn->getOperand(0).isFPImm())
1621 updated = addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1623 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1624 if (Location.getReg()) {
1625 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1627 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1633 // If variableDie is not updated then DBG_VALUE instruction does not
1634 // have valid variable info.
1638 DV->setDIE(VariableDie);
1642 // .. else use frame index, if available.
1643 MachineLocation Location;
1645 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1647 if (findVariableFrameIndex(DV, &FI)) {
1648 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1649 Location.set(FrameReg, Offset);
1651 if (VD.hasComplexAddress())
1652 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1653 else if (VD.isBlockByrefVariable())
1654 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1656 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1658 DV->setDIE(VariableDie);
1663 void DwarfDebug::addPubTypes(DISubprogram SP) {
1664 DICompositeType SPTy = SP.getType();
1665 unsigned SPTag = SPTy.getTag();
1666 if (SPTag != dwarf::DW_TAG_subroutine_type)
1669 DIArray Args = SPTy.getTypeArray();
1670 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1671 DIType ATy(Args.getElement(i));
1674 DICompositeType CATy = getDICompositeType(ATy);
1675 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1676 && !CATy.isForwardDecl()) {
1677 CompileUnit *TheCU = getCompileUnit(CATy);
1678 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1679 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1684 /// constructScopeDIE - Construct a DIE for this scope.
1685 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1686 if (!Scope || !Scope->getScopeNode())
1689 DIScope DS(Scope->getScopeNode());
1690 DIE *ScopeDIE = NULL;
1691 if (Scope->getInlinedAt())
1692 ScopeDIE = constructInlinedScopeDIE(Scope);
1693 else if (DS.isSubprogram()) {
1694 ProcessedSPNodes.insert(DS);
1695 if (Scope->isAbstractScope())
1696 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1698 ScopeDIE = updateSubprogramScopeDIE(DS);
1701 ScopeDIE = constructLexicalScopeDIE(Scope);
1702 if (!ScopeDIE) return NULL;
1704 // Add variables to scope.
1705 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1706 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1707 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1709 ScopeDIE->addChild(VariableDIE);
1712 // Add nested scopes.
1713 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1714 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1715 // Define the Scope debug information entry.
1716 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1718 ScopeDIE->addChild(NestedDIE);
1721 if (DS.isSubprogram())
1722 addPubTypes(DISubprogram(DS));
1727 /// GetOrCreateSourceID - Look up the source id with the given directory and
1728 /// source file names. If none currently exists, create a new id and insert it
1729 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1731 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1733 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1734 if (DI != DirectoryIdMap.end()) {
1735 DId = DI->getValue();
1737 DId = DirectoryNames.size() + 1;
1738 DirectoryIdMap[DirName] = DId;
1739 DirectoryNames.push_back(DirName);
1743 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1744 if (FI != SourceFileIdMap.end()) {
1745 FId = FI->getValue();
1747 FId = SourceFileNames.size() + 1;
1748 SourceFileIdMap[FileName] = FId;
1749 SourceFileNames.push_back(FileName);
1752 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1753 SourceIdMap.find(std::make_pair(DId, FId));
1754 if (SI != SourceIdMap.end())
1757 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1758 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1759 SourceIds.push_back(std::make_pair(DId, FId));
1764 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1765 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1766 CompileUnit *TheCU = getCompileUnit(NS);
1767 DIE *NDie = TheCU->getDIE(NS);
1770 NDie = new DIE(dwarf::DW_TAG_namespace);
1771 TheCU->insertDIE(NS, NDie);
1772 if (!NS.getName().empty())
1773 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1774 addSourceLine(NDie, &NS);
1775 addToContextOwner(NDie, NS.getContext());
1779 /// constructCompileUnit - Create new CompileUnit for the given
1780 /// metadata node with tag DW_TAG_compile_unit.
1781 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1782 DICompileUnit DIUnit(N);
1783 StringRef FN = DIUnit.getFilename();
1784 StringRef Dir = DIUnit.getDirectory();
1785 unsigned ID = GetOrCreateSourceID(Dir, FN);
1787 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1788 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1789 DIUnit.getProducer());
1790 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1791 DIUnit.getLanguage());
1792 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1793 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1794 // simplifies debug range entries.
1795 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1796 // DW_AT_stmt_list is a offset of line number information for this
1797 // compile unit in debug_line section. It is always zero when only one
1798 // compile unit is emitted in one object file.
1799 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1802 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1803 if (DIUnit.isOptimized())
1804 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1806 StringRef Flags = DIUnit.getFlags();
1808 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1810 unsigned RVer = DIUnit.getRunTimeVersion();
1812 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1813 dwarf::DW_FORM_data1, RVer);
1815 CompileUnit *NewCU = new CompileUnit(ID, Die);
1818 CUMap.insert(std::make_pair(N, NewCU));
1821 /// getCompielUnit - Get CompileUnit DIE.
1822 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1823 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1825 const MDNode *CUNode = NULL;
1826 if (D.isCompileUnit())
1828 else if (D.isSubprogram())
1829 CUNode = DISubprogram(N).getCompileUnit();
1830 else if (D.isType())
1831 CUNode = DIType(N).getCompileUnit();
1832 else if (D.isGlobalVariable())
1833 CUNode = DIGlobalVariable(N).getCompileUnit();
1834 else if (D.isVariable())
1835 CUNode = DIVariable(N).getCompileUnit();
1836 else if (D.isNameSpace())
1837 CUNode = DINameSpace(N).getCompileUnit();
1838 else if (D.isFile())
1839 CUNode = DIFile(N).getCompileUnit();
1843 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1844 = CUMap.find(CUNode);
1845 if (I == CUMap.end())
1851 /// constructGlobalVariableDIE - Construct global variable DIE.
1852 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1853 DIGlobalVariable DI_GV(N);
1855 // If debug information is malformed then ignore it.
1856 if (DI_GV.Verify() == false)
1859 // Check for pre-existence.
1860 CompileUnit *TheCU = getCompileUnit(N);
1861 if (TheCU->getDIE(DI_GV))
1864 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1869 TheCU->insertDIE(N, VariableDie);
1871 // Add to context owner.
1872 DIDescriptor GVContext = DI_GV.getContext();
1873 // Do not create specification DIE if context is either compile unit
1875 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1876 !GVContext.isFile() &&
1877 !isSubprogramContext(GVContext)) {
1878 // Create specification DIE.
1879 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1880 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1881 dwarf::DW_FORM_ref4, VariableDie);
1882 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1883 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1884 addLabel(Block, 0, dwarf::DW_FORM_udata,
1885 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1886 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1887 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1888 TheCU->addDie(VariableSpecDIE);
1890 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1891 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1892 addLabel(Block, 0, dwarf::DW_FORM_udata,
1893 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1894 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1896 addToContextOwner(VariableDie, GVContext);
1898 // Expose as global. FIXME - need to check external flag.
1899 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1901 DIType GTy = DI_GV.getType();
1902 if (GTy.isCompositeType() && !GTy.getName().empty()
1903 && !GTy.isForwardDecl()) {
1904 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1905 assert(Entry && "Missing global type!");
1906 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1911 /// construct SubprogramDIE - Construct subprogram DIE.
1912 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1915 // Check for pre-existence.
1916 CompileUnit *TheCU = getCompileUnit(N);
1917 if (TheCU->getDIE(N))
1920 if (!SP.isDefinition())
1921 // This is a method declaration which will be handled while constructing
1925 DIE *SubprogramDie = createSubprogramDIE(SP);
1928 TheCU->insertDIE(N, SubprogramDie);
1930 // Add to context owner.
1931 addToContextOwner(SubprogramDie, SP.getContext());
1933 // Expose as global.
1934 TheCU->addGlobal(SP.getName(), SubprogramDie);
1939 /// beginModule - Emit all Dwarf sections that should come prior to the
1940 /// content. Create global DIEs and emit initial debug info sections.
1941 /// This is inovked by the target AsmPrinter.
1942 void DwarfDebug::beginModule(Module *M) {
1943 if (DisableDebugInfoPrinting)
1946 DebugInfoFinder DbgFinder;
1947 DbgFinder.processModule(*M);
1949 bool HasDebugInfo = false;
1951 // Scan all the compile-units to see if there are any marked as the main unit.
1952 // if not, we do not generate debug info.
1953 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1954 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1955 if (DICompileUnit(*I).isMain()) {
1956 HasDebugInfo = true;
1961 if (!HasDebugInfo) return;
1963 // Tell MMI that we have debug info.
1964 MMI->setDebugInfoAvailability(true);
1966 // Emit initial sections.
1967 EmitSectionLabels();
1969 // Create all the compile unit DIEs.
1970 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1971 E = DbgFinder.compile_unit_end(); I != E; ++I)
1972 constructCompileUnit(*I);
1974 // Create DIEs for each subprogram.
1975 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1976 E = DbgFinder.subprogram_end(); I != E; ++I)
1977 constructSubprogramDIE(*I);
1979 // Create DIEs for each global variable.
1980 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1981 E = DbgFinder.global_variable_end(); I != E; ++I)
1982 constructGlobalVariableDIE(*I);
1984 // Prime section data.
1985 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1987 // Print out .file directives to specify files for .loc directives. These are
1988 // printed out early so that they precede any .loc directives.
1989 if (Asm->MAI->hasDotLocAndDotFile()) {
1990 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1991 // Remember source id starts at 1.
1992 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1993 // FIXME: don't use sys::path for this! This should not depend on the
1995 sys::Path FullPath(getSourceDirectoryName(Id.first));
1997 FullPath.appendComponent(getSourceFileName(Id.second));
1998 assert(AppendOk && "Could not append filename to directory!");
2000 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2005 /// endModule - Emit all Dwarf sections that should come after the content.
2007 void DwarfDebug::endModule() {
2008 if (!FirstCU) return;
2009 const Module *M = MMI->getModule();
2010 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2011 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2012 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2013 DISubprogram SP(AllSPs->getOperand(SI));
2014 if (!SP.Verify()) continue;
2016 // Collect info for variables that were optimized out.
2017 StringRef FName = SP.getLinkageName();
2019 FName = SP.getName();
2021 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2023 unsigned E = NMD->getNumOperands();
2025 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2026 for (unsigned I = 0; I != E; ++I) {
2027 DIVariable DV(NMD->getOperand(I));
2028 if (!DV.Verify()) continue;
2029 Scope->addVariable(new DbgVariable(DV));
2032 // Construct subprogram DIE and add variables DIEs.
2033 constructSubprogramDIE(SP);
2034 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2035 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2036 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2037 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2039 ScopeDIE->addChild(VariableDIE);
2044 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2045 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2046 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2048 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2051 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2052 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2053 DIE *SPDie = CI->first;
2054 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2056 DIE *NDie = getCompileUnit(N)->getDIE(N);
2057 if (!NDie) continue;
2058 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2061 // Standard sections final addresses.
2062 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2063 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2064 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2065 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2067 // End text sections.
2068 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2069 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2070 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2073 // Emit common frame information.
2074 emitCommonDebugFrame();
2076 // Emit function debug frame information
2077 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2078 E = DebugFrames.end(); I != E; ++I)
2079 emitFunctionDebugFrame(*I);
2081 // Compute DIE offsets and sizes.
2082 computeSizeAndOffsets();
2084 // Emit all the DIEs into a debug info section
2087 // Corresponding abbreviations into a abbrev section.
2088 emitAbbreviations();
2090 // Emit source line correspondence into a debug line section.
2093 // Emit info into a debug pubnames section.
2094 emitDebugPubNames();
2096 // Emit info into a debug pubtypes section.
2097 emitDebugPubTypes();
2099 // Emit info into a debug loc section.
2102 // Emit info into a debug aranges section.
2105 // Emit info into a debug ranges section.
2108 // Emit info into a debug macinfo section.
2111 // Emit inline info.
2112 emitDebugInlineInfo();
2114 // Emit info into a debug str section.
2117 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2118 E = CUMap.end(); I != E; ++I)
2120 FirstCU = NULL; // Reset for the next Module, if any.
2123 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2124 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2125 DebugLoc ScopeLoc) {
2127 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2129 return AbsDbgVariable;
2131 LLVMContext &Ctx = Var->getContext();
2132 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2136 AbsDbgVariable = new DbgVariable(Var);
2137 Scope->addVariable(AbsDbgVariable);
2138 AbstractVariables[Var] = AbsDbgVariable;
2139 return AbsDbgVariable;
2142 /// collectVariableInfoFromMMITable - Collect variable information from
2143 /// side table maintained by MMI.
2145 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2146 SmallPtrSet<const MDNode *, 16> &Processed) {
2147 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2148 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2149 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2150 VE = VMap.end(); VI != VE; ++VI) {
2151 const MDNode *Var = VI->first;
2153 Processed.insert(Var);
2155 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2157 DbgScope *Scope = 0;
2158 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2159 Scope = ConcreteScopes.lookup(IA);
2161 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2163 // If variable scope is not found then skip this variable.
2167 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2168 DbgVariable *RegVar = new DbgVariable(DV);
2169 recordVariableFrameIndex(RegVar, VP.first);
2170 Scope->addVariable(RegVar);
2171 if (AbsDbgVariable) {
2172 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2173 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2178 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2179 /// DBG_VALUE instruction, is in undefined reg.
2180 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2181 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2182 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2187 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2188 /// DBG_VALUE instruction, is in a defined reg.
2189 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2190 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2191 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2196 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2198 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2199 SmallPtrSet<const MDNode *, 16> &Processed) {
2201 /// collection info from MMI table.
2202 collectVariableInfoFromMMITable(MF, Processed);
2204 SmallVector<const MachineInstr *, 8> DbgValues;
2205 // Collect variable information from DBG_VALUE machine instructions;
2206 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2208 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2210 const MachineInstr *MInsn = II;
2211 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2213 DbgValues.push_back(MInsn);
2216 // This is a collection of DBV_VALUE instructions describing same variable.
2217 SmallVector<const MachineInstr *, 4> MultipleValues;
2218 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2219 E = DbgValues.end(); I != E; ++I) {
2220 const MachineInstr *MInsn = *I;
2221 MultipleValues.clear();
2222 if (isDbgValueInDefinedReg(MInsn))
2223 MultipleValues.push_back(MInsn);
2224 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2225 if (Processed.count(DV) != 0)
2228 const MachineInstr *PrevMI = MInsn;
2229 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2230 ME = DbgValues.end(); MI != ME; ++MI) {
2232 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2233 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2234 !PrevMI->isIdenticalTo(*MI))
2235 MultipleValues.push_back(*MI);
2239 DbgScope *Scope = findDbgScope(MInsn);
2240 bool CurFnArg = false;
2241 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2242 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2244 if (!Scope && CurFnArg)
2245 Scope = CurrentFnDbgScope;
2246 // If variable scope is not found then skip this variable.
2250 Processed.insert(DV);
2251 DbgVariable *RegVar = new DbgVariable(DV);
2252 Scope->addVariable(RegVar);
2254 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2255 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2256 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2257 VarToAbstractVarMap[RegVar] = AbsVar;
2259 if (MultipleValues.size() <= 1) {
2260 DbgVariableToDbgInstMap[RegVar] = MInsn;
2264 // handle multiple DBG_VALUE instructions describing one variable.
2265 if (DotDebugLocEntries.empty())
2266 RegVar->setDotDebugLocOffset(0);
2268 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2269 const MachineInstr *Begin = NULL;
2270 const MachineInstr *End = NULL;
2271 for (SmallVector<const MachineInstr *, 4>::iterator
2272 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); MVI != MVE; ++MVI) {
2278 MachineLocation MLoc;
2279 MLoc.set(Begin->getOperand(0).getReg(), 0);
2280 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2281 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2282 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2284 if (MVI + 1 == MVE) {
2285 // If End is the last instruction then its value is valid
2286 // until the end of the funtion.
2287 MLoc.set(End->getOperand(0).getReg(), 0);
2289 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2292 DotDebugLocEntries.push_back(DotDebugLocEntry());
2295 // Collect info for variables that were optimized out.
2296 const Function *F = MF->getFunction();
2297 const Module *M = F->getParent();
2298 if (NamedMDNode *NMD =
2299 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2300 getRealLinkageName(F->getName())))) {
2301 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2302 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2303 if (!DV || !Processed.insert(DV))
2305 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2307 Scope->addVariable(new DbgVariable(DV));
2312 /// getLabelBeforeInsn - Return Label preceding the instruction.
2313 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2314 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2315 LabelsBeforeInsn.find(MI);
2316 if (I == LabelsBeforeInsn.end())
2317 // FunctionBeginSym always preceeds all the instruction in current function.
2318 return FunctionBeginSym;
2322 /// getLabelAfterInsn - Return Label immediately following the instruction.
2323 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2324 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2325 LabelsAfterInsn.find(MI);
2326 if (I == LabelsAfterInsn.end())
2331 /// beginScope - Process beginning of a scope.
2332 void DwarfDebug::beginScope(const MachineInstr *MI) {
2333 if (InsnNeedsLabel.count(MI) == 0) {
2334 LabelsBeforeInsn[MI] = PrevLabel;
2339 DebugLoc DL = MI->getDebugLoc();
2340 if (!DL.isUnknown()) {
2341 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2342 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2344 LabelsBeforeInsn[MI] = PrevLabel;
2348 // If location is unknown then use temp label for this DBG_VALUE
2350 if (MI->isDebugValue()) {
2351 PrevLabel = MMI->getContext().CreateTempSymbol();
2352 Asm->OutStreamer.EmitLabel(PrevLabel);
2353 LabelsBeforeInsn[MI] = PrevLabel;
2357 if (UnknownLocations) {
2358 PrevLabel = recordSourceLine(0, 0, 0);
2359 LabelsBeforeInsn[MI] = PrevLabel;
2363 assert (0 && "Instruction is not processed!");
2366 /// endScope - Process end of a scope.
2367 void DwarfDebug::endScope(const MachineInstr *MI) {
2368 if (InsnsEndScopeSet.count(MI) != 0) {
2369 // Emit a label if this instruction ends a scope.
2370 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2371 Asm->OutStreamer.EmitLabel(Label);
2372 LabelsAfterInsn[MI] = Label;
2376 /// getOrCreateDbgScope - Create DbgScope for the scope.
2377 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2379 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2382 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2383 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2384 if (DIDescriptor(Scope).isLexicalBlock()) {
2386 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2387 WScope->setParent(Parent);
2388 Parent->addScope(WScope);
2391 if (!WScope->getParent()) {
2392 StringRef SPName = DISubprogram(Scope).getLinkageName();
2393 // We used to check only for a linkage name, but that fails
2394 // since we began omitting the linkage name for private
2395 // functions. The new way is to check for the name in metadata,
2396 // but that's not supported in old .ll test cases. Ergo, we
2398 if (SPName == Asm->MF->getFunction()->getName() ||
2399 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2400 CurrentFnDbgScope = WScope;
2406 getOrCreateAbstractScope(Scope);
2407 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2411 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2412 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2413 DILocation DL(InlinedAt);
2415 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2416 WScope->setParent(Parent);
2417 Parent->addScope(WScope);
2419 ConcreteScopes[InlinedAt] = WScope;
2424 /// hasValidLocation - Return true if debug location entry attached with
2425 /// machine instruction encodes valid location info.
2426 static bool hasValidLocation(LLVMContext &Ctx,
2427 const MachineInstr *MInsn,
2428 const MDNode *&Scope, const MDNode *&InlinedAt) {
2429 DebugLoc DL = MInsn->getDebugLoc();
2430 if (DL.isUnknown()) return false;
2432 const MDNode *S = DL.getScope(Ctx);
2434 // There is no need to create another DIE for compile unit. For all
2435 // other scopes, create one DbgScope now. This will be translated
2436 // into a scope DIE at the end.
2437 if (DIScope(S).isCompileUnit()) return false;
2440 InlinedAt = DL.getInlinedAt(Ctx);
2444 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2446 static void calculateDominanceGraph(DbgScope *Scope) {
2447 assert (Scope && "Unable to calculate scop edominance graph!");
2448 SmallVector<DbgScope *, 4> WorkStack;
2449 WorkStack.push_back(Scope);
2450 unsigned Counter = 0;
2451 while (!WorkStack.empty()) {
2452 DbgScope *WS = WorkStack.back();
2453 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2454 bool visitedChildren = false;
2455 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2456 SE = Children.end(); SI != SE; ++SI) {
2457 DbgScope *ChildScope = *SI;
2458 if (!ChildScope->getDFSOut()) {
2459 WorkStack.push_back(ChildScope);
2460 visitedChildren = true;
2461 ChildScope->setDFSIn(++Counter);
2465 if (!visitedChildren) {
2466 WorkStack.pop_back();
2467 WS->setDFSOut(++Counter);
2472 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2474 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2475 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2478 unsigned PrevDFSIn = 0;
2479 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2481 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2483 const MachineInstr *MInsn = II;
2484 const MDNode *Scope = NULL;
2485 const MDNode *InlinedAt = NULL;
2487 // Check if instruction has valid location information.
2488 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2492 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2493 MI2ScopeMap.find(MInsn);
2494 if (DI != MI2ScopeMap.end()) {
2495 DbgScope *S = DI->second;
2496 dbgs() << S->getDFSIn();
2497 PrevDFSIn = S->getDFSIn();
2499 dbgs() << PrevDFSIn;
2501 dbgs() << " [ x" << PrevDFSIn;
2509 /// extractScopeInformation - Scan machine instructions in this function
2510 /// and collect DbgScopes. Return true, if at least one scope was found.
2511 bool DwarfDebug::extractScopeInformation() {
2512 // If scope information was extracted using .dbg intrinsics then there is not
2513 // any need to extract these information by scanning each instruction.
2514 if (!DbgScopeMap.empty())
2517 // Scan each instruction and create scopes. First build working set of scopes.
2518 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2519 SmallVector<DbgRange, 4> MIRanges;
2520 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2521 const MDNode *PrevScope = NULL;
2522 const MDNode *PrevInlinedAt = NULL;
2523 const MachineInstr *RangeBeginMI = NULL;
2524 const MachineInstr *PrevMI = NULL;
2525 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2527 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2529 const MachineInstr *MInsn = II;
2530 const MDNode *Scope = NULL;
2531 const MDNode *InlinedAt = NULL;
2533 // Check if instruction has valid location information.
2534 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2539 // If scope has not changed then skip this instruction.
2540 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2546 // If we have alread seen a beginning of a instruction range and
2547 // current instruction scope does not match scope of first instruction
2548 // in this range then create a new instruction range.
2549 DbgRange R(RangeBeginMI, PrevMI);
2550 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2551 MIRanges.push_back(R);
2554 // This is a beginning of a new instruction range.
2555 RangeBeginMI = MInsn;
2557 // Reset previous markers.
2560 PrevInlinedAt = InlinedAt;
2564 // Create last instruction range.
2565 if (RangeBeginMI && PrevMI && PrevScope) {
2566 DbgRange R(RangeBeginMI, PrevMI);
2567 MIRanges.push_back(R);
2568 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2571 if (!CurrentFnDbgScope)
2574 calculateDominanceGraph(CurrentFnDbgScope);
2576 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2578 // Find ranges of instructions covered by each DbgScope;
2579 DbgScope *PrevDbgScope = NULL;
2580 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2581 RE = MIRanges.end(); RI != RE; ++RI) {
2582 const DbgRange &R = *RI;
2583 DbgScope *S = MI2ScopeMap.lookup(R.first);
2584 assert (S && "Lost DbgScope for a machine instruction!");
2585 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2586 PrevDbgScope->closeInsnRange(S);
2587 S->openInsnRange(R.first);
2588 S->extendInsnRange(R.second);
2593 PrevDbgScope->closeInsnRange();
2595 identifyScopeMarkers();
2597 return !DbgScopeMap.empty();
2600 /// identifyScopeMarkers() -
2601 /// Each DbgScope has first instruction and last instruction to mark beginning
2602 /// and end of a scope respectively. Create an inverse map that list scopes
2603 /// starts (and ends) with an instruction. One instruction may start (or end)
2604 /// multiple scopes. Ignore scopes that are not reachable.
2605 void DwarfDebug::identifyScopeMarkers() {
2606 SmallVector<DbgScope *, 4> WorkList;
2607 WorkList.push_back(CurrentFnDbgScope);
2608 while (!WorkList.empty()) {
2609 DbgScope *S = WorkList.pop_back_val();
2611 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2612 if (!Children.empty())
2613 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2614 SE = Children.end(); SI != SE; ++SI)
2615 WorkList.push_back(*SI);
2617 if (S->isAbstractScope())
2620 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2623 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2624 RE = Ranges.end(); RI != RE; ++RI) {
2625 assert(RI->first && "DbgRange does not have first instruction!");
2626 assert(RI->second && "DbgRange does not have second instruction!");
2627 InsnsEndScopeSet.insert(RI->second);
2632 /// FindFirstDebugLoc - Find the first debug location in the function. This
2633 /// is intended to be an approximation for the source position of the
2634 /// beginning of the function.
2635 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2636 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2638 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2639 MBBI != MBBE; ++MBBI) {
2640 DebugLoc DL = MBBI->getDebugLoc();
2641 if (!DL.isUnknown())
2647 /// beginFunction - Gather pre-function debug information. Assumes being
2648 /// emitted immediately after the function entry point.
2649 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2650 if (!MMI->hasDebugInfo()) return;
2651 if (!extractScopeInformation()) return;
2653 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2654 Asm->getFunctionNumber());
2655 // Assumes in correct section after the entry point.
2656 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2658 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2660 DebugLoc FDL = FindFirstDebugLoc(MF);
2661 if (FDL.isUnknown()) return;
2663 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2665 DISubprogram SP = getDISubprogram(Scope);
2668 Line = SP.getLineNumber();
2671 Line = FDL.getLine();
2675 recordSourceLine(Line, Col, Scope);
2677 /// ProcessedArgs - Collection of arguments already processed.
2678 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2681 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2683 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2685 const MachineInstr *MI = II;
2686 DebugLoc DL = MI->getDebugLoc();
2687 if (MI->isDebugValue()) {
2688 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2689 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2690 if (!DV.Verify()) continue;
2691 // If DBG_VALUE is for a local variable then it needs a label.
2692 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2693 InsnNeedsLabel.insert(MI);
2694 // DBG_VALUE for inlined functions argument needs a label.
2695 else if (!DISubprogram(DV.getContext()).describes(MF->getFunction()))
2696 InsnNeedsLabel.insert(MI);
2697 // DBG_VALUE indicating argument location change needs a label.
2698 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV))
2699 InsnNeedsLabel.insert(MI);
2701 // If location is unknown then instruction needs a location only if
2702 // UnknownLocations flag is set.
2703 if (DL.isUnknown()) {
2704 if (UnknownLocations && !PrevLoc.isUnknown())
2705 InsnNeedsLabel.insert(MI);
2706 } else if (DL != PrevLoc)
2707 // Otherwise, instruction needs a location only if it is new location.
2708 InsnNeedsLabel.insert(MI);
2711 if (!DL.isUnknown() || UnknownLocations)
2715 PrevLabel = FunctionBeginSym;
2718 /// endFunction - Gather and emit post-function debug information.
2720 void DwarfDebug::endFunction(const MachineFunction *MF) {
2721 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2723 if (CurrentFnDbgScope) {
2725 // Define end label for subprogram.
2726 FunctionEndSym = Asm->GetTempSymbol("func_end",
2727 Asm->getFunctionNumber());
2728 // Assumes in correct section after the entry point.
2729 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2731 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2732 collectVariableInfo(MF, ProcessedVars);
2734 // Get function line info.
2735 if (!Lines.empty()) {
2736 // Get section line info.
2737 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2738 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2739 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2740 // Append the function info to section info.
2741 SectionLineInfos.insert(SectionLineInfos.end(),
2742 Lines.begin(), Lines.end());
2745 // Construct abstract scopes.
2746 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2747 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2748 constructScopeDIE(*AI);
2749 DISubprogram SP((*AI)->getScopeNode());
2751 // Collect info for variables that were optimized out.
2752 StringRef FName = SP.getLinkageName();
2754 FName = SP.getName();
2755 const Module *M = MF->getFunction()->getParent();
2756 if (NamedMDNode *NMD =
2757 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2758 getRealLinkageName(FName)))) {
2759 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2760 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2761 if (!DV || !ProcessedVars.insert(DV))
2763 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2765 Scope->addVariable(new DbgVariable(DV));
2771 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2773 if (!DisableFramePointerElim(*MF))
2774 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2775 dwarf::DW_FORM_flag, 1);
2778 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2779 MMI->getFrameMoves()));
2783 CurrentFnDbgScope = NULL;
2784 InsnNeedsLabel.clear();
2785 DbgVariableToFrameIndexMap.clear();
2786 VarToAbstractVarMap.clear();
2787 DbgVariableToDbgInstMap.clear();
2788 DbgVariableLabelsMap.clear();
2789 DeleteContainerSeconds(DbgScopeMap);
2790 InsnsEndScopeSet.clear();
2791 ConcreteScopes.clear();
2792 DeleteContainerSeconds(AbstractScopes);
2793 AbstractScopesList.clear();
2794 AbstractVariables.clear();
2795 LabelsBeforeInsn.clear();
2796 LabelsAfterInsn.clear();
2801 /// recordVariableFrameIndex - Record a variable's index.
2802 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2803 assert (V && "Invalid DbgVariable!");
2804 DbgVariableToFrameIndexMap[V] = Index;
2807 /// findVariableFrameIndex - Return true if frame index for the variable
2808 /// is found. Update FI to hold value of the index.
2809 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2810 assert (V && "Invalid DbgVariable!");
2811 DenseMap<const DbgVariable *, int>::iterator I =
2812 DbgVariableToFrameIndexMap.find(V);
2813 if (I == DbgVariableToFrameIndexMap.end())
2819 /// findVariableLabel - Find MCSymbol for the variable.
2820 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2821 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2822 = DbgVariableLabelsMap.find(V);
2823 if (I == DbgVariableLabelsMap.end())
2825 else return I->second;
2828 /// findDbgScope - Find DbgScope for the debug loc attached with an
2830 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2831 DbgScope *Scope = NULL;
2833 MInsn->getParent()->getParent()->getFunction()->getContext();
2834 DebugLoc DL = MInsn->getDebugLoc();
2839 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2840 Scope = ConcreteScopes.lookup(IA);
2842 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2848 /// recordSourceLine - Register a source line with debug info. Returns the
2849 /// unique label that was emitted and which provides correspondence to
2850 /// the source line list.
2851 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2857 DIDescriptor Scope(S);
2859 if (Scope.isCompileUnit()) {
2860 DICompileUnit CU(S);
2861 Dir = CU.getDirectory();
2862 Fn = CU.getFilename();
2863 } else if (Scope.isSubprogram()) {
2865 Dir = SP.getDirectory();
2866 Fn = SP.getFilename();
2867 } else if (Scope.isLexicalBlock()) {
2868 DILexicalBlock DB(S);
2869 Dir = DB.getDirectory();
2870 Fn = DB.getFilename();
2872 assert(0 && "Unexpected scope info");
2874 Src = GetOrCreateSourceID(Dir, Fn);
2878 if (!Lines.empty()) {
2879 SrcLineInfo lastSrcLineInfo = Lines.back();
2880 // Emitting sequential line records with the same line number (but
2881 // different addresses) seems to confuse GDB. Avoid this.
2882 if (lastSrcLineInfo.getLine() == Line)
2887 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2888 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2890 Asm->OutStreamer.EmitLabel(Label);
2894 //===----------------------------------------------------------------------===//
2896 //===----------------------------------------------------------------------===//
2898 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2901 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2902 // Get the children.
2903 const std::vector<DIE *> &Children = Die->getChildren();
2905 // If not last sibling and has children then add sibling offset attribute.
2906 if (!Last && !Children.empty())
2907 Die->addSiblingOffset(DIEValueAllocator);
2909 // Record the abbreviation.
2910 assignAbbrevNumber(Die->getAbbrev());
2912 // Get the abbreviation for this DIE.
2913 unsigned AbbrevNumber = Die->getAbbrevNumber();
2914 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2917 Die->setOffset(Offset);
2919 // Start the size with the size of abbreviation code.
2920 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2922 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2923 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2925 // Size the DIE attribute values.
2926 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2927 // Size attribute value.
2928 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2930 // Size the DIE children if any.
2931 if (!Children.empty()) {
2932 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2933 "Children flag not set");
2935 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2936 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2938 // End of children marker.
2939 Offset += sizeof(int8_t);
2942 Die->setSize(Offset - Die->getOffset());
2946 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2948 void DwarfDebug::computeSizeAndOffsets() {
2949 unsigned PrevOffset = 0;
2950 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2951 E = CUMap.end(); I != E; ++I) {
2952 // Compute size of compile unit header.
2953 static unsigned Offset = PrevOffset +
2954 sizeof(int32_t) + // Length of Compilation Unit Info
2955 sizeof(int16_t) + // DWARF version number
2956 sizeof(int32_t) + // Offset Into Abbrev. Section
2957 sizeof(int8_t); // Pointer Size (in bytes)
2958 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2959 PrevOffset = Offset;
2963 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2964 /// temporary label to it if SymbolStem is specified.
2965 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2966 const char *SymbolStem = 0) {
2967 Asm->OutStreamer.SwitchSection(Section);
2968 if (!SymbolStem) return 0;
2970 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2971 Asm->OutStreamer.EmitLabel(TmpSym);
2975 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2976 /// the start of each one.
2977 void DwarfDebug::EmitSectionLabels() {
2978 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2980 // Dwarf sections base addresses.
2981 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2982 DwarfFrameSectionSym =
2983 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2986 DwarfInfoSectionSym =
2987 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2988 DwarfAbbrevSectionSym =
2989 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2990 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2992 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2993 EmitSectionSym(Asm, MacroInfo);
2995 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2996 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2997 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2998 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2999 DwarfStrSectionSym =
3000 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3001 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3004 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3005 "section_debug_loc");
3007 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3008 EmitSectionSym(Asm, TLOF.getDataSection());
3011 /// emitDIE - Recusively Emits a debug information entry.
3013 void DwarfDebug::emitDIE(DIE *Die) {
3014 // Get the abbreviation for this DIE.
3015 unsigned AbbrevNumber = Die->getAbbrevNumber();
3016 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3018 // Emit the code (index) for the abbreviation.
3019 if (Asm->isVerbose())
3020 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3021 Twine::utohexstr(Die->getOffset()) + ":0x" +
3022 Twine::utohexstr(Die->getSize()) + " " +
3023 dwarf::TagString(Abbrev->getTag()));
3024 Asm->EmitULEB128(AbbrevNumber);
3026 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3027 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3029 // Emit the DIE attribute values.
3030 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3031 unsigned Attr = AbbrevData[i].getAttribute();
3032 unsigned Form = AbbrevData[i].getForm();
3033 assert(Form && "Too many attributes for DIE (check abbreviation)");
3035 if (Asm->isVerbose())
3036 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3039 case dwarf::DW_AT_sibling:
3040 Asm->EmitInt32(Die->getSiblingOffset());
3042 case dwarf::DW_AT_abstract_origin: {
3043 DIEEntry *E = cast<DIEEntry>(Values[i]);
3044 DIE *Origin = E->getEntry();
3045 unsigned Addr = Origin->getOffset();
3046 Asm->EmitInt32(Addr);
3049 case dwarf::DW_AT_ranges: {
3050 // DW_AT_range Value encodes offset in debug_range section.
3051 DIEInteger *V = cast<DIEInteger>(Values[i]);
3052 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3054 DwarfDebugRangeSectionSym,
3058 case dwarf::DW_AT_location: {
3059 if (UseDotDebugLocEntry.count(Die) != 0) {
3060 DIELabel *L = cast<DIELabel>(Values[i]);
3061 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3063 Values[i]->EmitValue(Asm, Form);
3067 // Emit an attribute using the defined form.
3068 Values[i]->EmitValue(Asm, Form);
3073 // Emit the DIE children if any.
3074 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3075 const std::vector<DIE *> &Children = Die->getChildren();
3077 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3078 emitDIE(Children[j]);
3080 if (Asm->isVerbose())
3081 Asm->OutStreamer.AddComment("End Of Children Mark");
3086 /// emitDebugInfo - Emit the debug info section.
3088 void DwarfDebug::emitDebugInfo() {
3089 // Start debug info section.
3090 Asm->OutStreamer.SwitchSection(
3091 Asm->getObjFileLowering().getDwarfInfoSection());
3092 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3093 E = CUMap.end(); I != E; ++I) {
3094 CompileUnit *TheCU = I->second;
3095 DIE *Die = TheCU->getCUDie();
3097 // Emit the compile units header.
3098 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3101 // Emit size of content not including length itself
3102 unsigned ContentSize = Die->getSize() +
3103 sizeof(int16_t) + // DWARF version number
3104 sizeof(int32_t) + // Offset Into Abbrev. Section
3105 sizeof(int8_t) + // Pointer Size (in bytes)
3106 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3108 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3109 Asm->EmitInt32(ContentSize);
3110 Asm->OutStreamer.AddComment("DWARF version number");
3111 Asm->EmitInt16(dwarf::DWARF_VERSION);
3112 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3113 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3114 DwarfAbbrevSectionSym);
3115 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3116 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3119 // FIXME - extra padding for gdb bug.
3120 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3125 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3129 /// emitAbbreviations - Emit the abbreviation section.
3131 void DwarfDebug::emitAbbreviations() const {
3132 // Check to see if it is worth the effort.
3133 if (!Abbreviations.empty()) {
3134 // Start the debug abbrev section.
3135 Asm->OutStreamer.SwitchSection(
3136 Asm->getObjFileLowering().getDwarfAbbrevSection());
3138 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3140 // For each abbrevation.
3141 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3142 // Get abbreviation data
3143 const DIEAbbrev *Abbrev = Abbreviations[i];
3145 // Emit the abbrevations code (base 1 index.)
3146 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3148 // Emit the abbreviations data.
3152 // Mark end of abbreviations.
3153 Asm->EmitULEB128(0, "EOM(3)");
3155 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3159 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3160 /// the line matrix.
3162 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3163 // Define last address of section.
3164 Asm->OutStreamer.AddComment("Extended Op");
3167 Asm->OutStreamer.AddComment("Op size");
3168 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3169 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3170 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3172 Asm->OutStreamer.AddComment("Section end label");
3174 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3175 Asm->getTargetData().getPointerSize(),
3178 // Mark end of matrix.
3179 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3185 /// emitDebugLines - Emit source line information.
3187 void DwarfDebug::emitDebugLines() {
3188 // If the target is using .loc/.file, the assembler will be emitting the
3189 // .debug_line table automatically.
3190 if (Asm->MAI->hasDotLocAndDotFile())
3193 // Minimum line delta, thus ranging from -10..(255-10).
3194 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3195 // Maximum line delta, thus ranging from -10..(255-10).
3196 const int MaxLineDelta = 255 + MinLineDelta;
3198 // Start the dwarf line section.
3199 Asm->OutStreamer.SwitchSection(
3200 Asm->getObjFileLowering().getDwarfLineSection());
3202 // Construct the section header.
3203 Asm->OutStreamer.AddComment("Length of Source Line Info");
3204 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3205 Asm->GetTempSymbol("line_begin"), 4);
3206 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3208 Asm->OutStreamer.AddComment("DWARF version number");
3209 Asm->EmitInt16(dwarf::DWARF_VERSION);
3211 Asm->OutStreamer.AddComment("Prolog Length");
3212 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3213 Asm->GetTempSymbol("line_prolog_begin"), 4);
3214 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3216 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3218 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3220 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3221 Asm->EmitInt8(MinLineDelta);
3222 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3223 Asm->EmitInt8(MaxLineDelta);
3224 Asm->OutStreamer.AddComment("Special Opcode Base");
3225 Asm->EmitInt8(-MinLineDelta);
3227 // Line number standard opcode encodings argument count
3228 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3230 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3232 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3234 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3236 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3238 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3240 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3242 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3244 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3247 // Emit directories.
3248 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3249 const std::string &Dir = getSourceDirectoryName(DI);
3250 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3251 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3254 Asm->OutStreamer.AddComment("End of directories");
3258 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3259 // Remember source id starts at 1.
3260 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3261 const std::string &FN = getSourceFileName(Id.second);
3262 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3263 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3265 Asm->EmitULEB128(Id.first, "Directory #");
3266 Asm->EmitULEB128(0, "Mod date");
3267 Asm->EmitULEB128(0, "File size");
3270 Asm->OutStreamer.AddComment("End of files");
3273 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3275 // A sequence for each text section.
3276 unsigned SecSrcLinesSize = SectionSourceLines.size();
3278 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3279 // Isolate current sections line info.
3280 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3282 // Dwarf assumes we start with first line of first source file.
3283 unsigned Source = 1;
3286 // Construct rows of the address, source, line, column matrix.
3287 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3288 const SrcLineInfo &LineInfo = LineInfos[i];
3289 MCSymbol *Label = LineInfo.getLabel();
3290 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3292 if (Asm->isVerbose()) {
3293 std::pair<unsigned, unsigned> SrcID =
3294 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3295 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3297 Twine(getSourceFileName(SrcID.second)) +
3298 ":" + Twine(LineInfo.getLine()));
3301 // Define the line address.
3302 Asm->OutStreamer.AddComment("Extended Op");
3304 Asm->OutStreamer.AddComment("Op size");
3305 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3307 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3308 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3310 Asm->OutStreamer.AddComment("Location label");
3311 Asm->OutStreamer.EmitSymbolValue(Label,
3312 Asm->getTargetData().getPointerSize(),
3315 // If change of source, then switch to the new source.
3316 if (Source != LineInfo.getSourceID()) {
3317 Source = LineInfo.getSourceID();
3318 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3319 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3320 Asm->EmitULEB128(Source, "New Source");
3323 // If change of line.
3324 if (Line != LineInfo.getLine()) {
3325 // Determine offset.
3326 int Offset = LineInfo.getLine() - Line;
3327 int Delta = Offset - MinLineDelta;
3330 Line = LineInfo.getLine();
3332 // If delta is small enough and in range...
3333 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3334 // ... then use fast opcode.
3335 Asm->OutStreamer.AddComment("Line Delta");
3336 Asm->EmitInt8(Delta - MinLineDelta);
3338 // ... otherwise use long hand.
3339 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3340 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3341 Asm->EmitSLEB128(Offset, "Line Offset");
3342 Asm->OutStreamer.AddComment("DW_LNS_copy");
3343 Asm->EmitInt8(dwarf::DW_LNS_copy);
3346 // Copy the previous row (different address or source)
3347 Asm->OutStreamer.AddComment("DW_LNS_copy");
3348 Asm->EmitInt8(dwarf::DW_LNS_copy);
3352 emitEndOfLineMatrix(j + 1);
3355 if (SecSrcLinesSize == 0)
3356 // Because we're emitting a debug_line section, we still need a line
3357 // table. The linker and friends expect it to exist. If there's nothing to
3358 // put into it, emit an empty table.
3359 emitEndOfLineMatrix(1);
3361 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3364 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3366 void DwarfDebug::emitCommonDebugFrame() {
3367 if (!Asm->MAI->doesDwarfRequireFrameSection())
3370 int stackGrowth = Asm->getTargetData().getPointerSize();
3371 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3372 TargetFrameInfo::StackGrowsDown)
3375 // Start the dwarf frame section.
3376 Asm->OutStreamer.SwitchSection(
3377 Asm->getObjFileLowering().getDwarfFrameSection());
3379 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3380 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3381 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3382 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3384 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3385 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3386 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3387 Asm->OutStreamer.AddComment("CIE Version");
3388 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3389 Asm->OutStreamer.AddComment("CIE Augmentation");
3390 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3391 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3392 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3393 Asm->OutStreamer.AddComment("CIE RA Column");
3394 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3395 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3397 std::vector<MachineMove> Moves;
3398 RI->getInitialFrameState(Moves);
3400 Asm->EmitFrameMoves(Moves, 0, false);
3402 Asm->EmitAlignment(2);
3403 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3406 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3409 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3410 if (!Asm->MAI->doesDwarfRequireFrameSection())
3413 // Start the dwarf frame section.
3414 Asm->OutStreamer.SwitchSection(
3415 Asm->getObjFileLowering().getDwarfFrameSection());
3417 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3418 MCSymbol *DebugFrameBegin =
3419 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3420 MCSymbol *DebugFrameEnd =
3421 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3422 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3424 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3426 Asm->OutStreamer.AddComment("FDE CIE offset");
3427 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3428 DwarfFrameSectionSym);
3430 Asm->OutStreamer.AddComment("FDE initial location");
3431 MCSymbol *FuncBeginSym =
3432 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3433 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3434 Asm->getTargetData().getPointerSize(),
3438 Asm->OutStreamer.AddComment("FDE address range");
3439 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3440 FuncBeginSym, Asm->getTargetData().getPointerSize());
3442 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3444 Asm->EmitAlignment(2);
3445 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3448 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3450 void DwarfDebug::emitDebugPubNames() {
3451 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3452 E = CUMap.end(); I != E; ++I) {
3453 CompileUnit *TheCU = I->second;
3454 // Start the dwarf pubnames section.
3455 Asm->OutStreamer.SwitchSection(
3456 Asm->getObjFileLowering().getDwarfPubNamesSection());
3458 Asm->OutStreamer.AddComment("Length of Public Names Info");
3459 Asm->EmitLabelDifference(
3460 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3461 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3463 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3466 Asm->OutStreamer.AddComment("DWARF Version");
3467 Asm->EmitInt16(dwarf::DWARF_VERSION);
3469 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3470 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3471 DwarfInfoSectionSym);
3473 Asm->OutStreamer.AddComment("Compilation Unit Length");
3474 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3475 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3478 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3479 for (StringMap<DIE*>::const_iterator
3480 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3481 const char *Name = GI->getKeyData();
3482 DIE *Entity = GI->second;
3484 Asm->OutStreamer.AddComment("DIE offset");
3485 Asm->EmitInt32(Entity->getOffset());
3487 if (Asm->isVerbose())
3488 Asm->OutStreamer.AddComment("External Name");
3489 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3492 Asm->OutStreamer.AddComment("End Mark");
3494 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3499 void DwarfDebug::emitDebugPubTypes() {
3500 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3501 E = CUMap.end(); I != E; ++I) {
3502 CompileUnit *TheCU = I->second;
3503 // Start the dwarf pubnames section.
3504 Asm->OutStreamer.SwitchSection(
3505 Asm->getObjFileLowering().getDwarfPubTypesSection());
3506 Asm->OutStreamer.AddComment("Length of Public Types Info");
3507 Asm->EmitLabelDifference(
3508 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3509 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3511 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3514 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3515 Asm->EmitInt16(dwarf::DWARF_VERSION);
3517 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3518 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3519 DwarfInfoSectionSym);
3521 Asm->OutStreamer.AddComment("Compilation Unit Length");
3522 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3523 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3526 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3527 for (StringMap<DIE*>::const_iterator
3528 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3529 const char *Name = GI->getKeyData();
3530 DIE * Entity = GI->second;
3532 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3533 Asm->EmitInt32(Entity->getOffset());
3535 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3536 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3539 Asm->OutStreamer.AddComment("End Mark");
3541 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3546 /// emitDebugStr - Emit visible names into a debug str section.
3548 void DwarfDebug::emitDebugStr() {
3549 // Check to see if it is worth the effort.
3550 if (StringPool.empty()) return;
3552 // Start the dwarf str section.
3553 Asm->OutStreamer.SwitchSection(
3554 Asm->getObjFileLowering().getDwarfStrSection());
3556 // Get all of the string pool entries and put them in an array by their ID so
3557 // we can sort them.
3558 SmallVector<std::pair<unsigned,
3559 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3561 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3562 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3563 Entries.push_back(std::make_pair(I->second.second, &*I));
3565 array_pod_sort(Entries.begin(), Entries.end());
3567 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3568 // Emit a label for reference from debug information entries.
3569 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3571 // Emit the string itself.
3572 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3576 /// emitDebugLoc - Emit visible names into a debug loc section.
3578 void DwarfDebug::emitDebugLoc() {
3579 if (DotDebugLocEntries.empty())
3582 // Start the dwarf loc section.
3583 Asm->OutStreamer.SwitchSection(
3584 Asm->getObjFileLowering().getDwarfLocSection());
3585 unsigned char Size = Asm->getTargetData().getPointerSize();
3586 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3588 for (SmallVector<DotDebugLocEntry, 4>::iterator I = DotDebugLocEntries.begin(),
3589 E = DotDebugLocEntries.end(); I != E; ++I, ++index) {
3590 DotDebugLocEntry Entry = *I;
3591 if (Entry.isEmpty()) {
3592 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3593 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3594 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3596 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3597 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3598 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3599 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3601 Asm->OutStreamer.AddComment("Loc expr size");
3603 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3605 Asm->OutStreamer.AddComment("Loc expr size");
3606 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3607 Asm->EmitInt8(dwarf::DW_OP_regx);
3608 Asm->EmitULEB128(Reg);
3614 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3616 void DwarfDebug::EmitDebugARanges() {
3617 // Start the dwarf aranges section.
3618 Asm->OutStreamer.SwitchSection(
3619 Asm->getObjFileLowering().getDwarfARangesSection());
3622 /// emitDebugRanges - Emit visible names into a debug ranges section.
3624 void DwarfDebug::emitDebugRanges() {
3625 // Start the dwarf ranges section.
3626 Asm->OutStreamer.SwitchSection(
3627 Asm->getObjFileLowering().getDwarfRangesSection());
3628 unsigned char Size = Asm->getTargetData().getPointerSize();
3629 for (SmallVector<const MCSymbol *, 8>::iterator
3630 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3633 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3635 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3639 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3641 void DwarfDebug::emitDebugMacInfo() {
3642 if (const MCSection *LineInfo =
3643 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3644 // Start the dwarf macinfo section.
3645 Asm->OutStreamer.SwitchSection(LineInfo);
3649 /// emitDebugInlineInfo - Emit inline info using following format.
3651 /// 1. length of section
3652 /// 2. Dwarf version number
3653 /// 3. address size.
3655 /// Entries (one "entry" for each function that was inlined):
3657 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3658 /// otherwise offset into __debug_str for regular function name.
3659 /// 2. offset into __debug_str section for regular function name.
3660 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3661 /// instances for the function.
3663 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3664 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3665 /// __debug_info section, and the low_pc is the starting address for the
3666 /// inlining instance.
3667 void DwarfDebug::emitDebugInlineInfo() {
3668 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3674 Asm->OutStreamer.SwitchSection(
3675 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3677 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3678 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3679 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3681 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3683 Asm->OutStreamer.AddComment("Dwarf Version");
3684 Asm->EmitInt16(dwarf::DWARF_VERSION);
3685 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3686 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3688 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3689 E = InlinedSPNodes.end(); I != E; ++I) {
3691 const MDNode *Node = *I;
3692 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3693 = InlineInfo.find(Node);
3694 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3695 DISubprogram SP(Node);
3696 StringRef LName = SP.getLinkageName();
3697 StringRef Name = SP.getName();
3699 Asm->OutStreamer.AddComment("MIPS linkage name");
3700 if (LName.empty()) {
3701 Asm->OutStreamer.EmitBytes(Name, 0);
3702 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3704 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3705 DwarfStrSectionSym);
3707 Asm->OutStreamer.AddComment("Function name");
3708 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3709 Asm->EmitULEB128(Labels.size(), "Inline count");
3711 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3712 LE = Labels.end(); LI != LE; ++LI) {
3713 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3714 Asm->EmitInt32(LI->second->getOffset());
3716 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3717 Asm->OutStreamer.EmitSymbolValue(LI->first,
3718 Asm->getTargetData().getPointerSize(),0);
3722 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));