1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
49 cl::desc("Disable debug info printing"));
51 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58 } // end anonymous namespace
60 //===----------------------------------------------------------------------===//
62 /// Configuration values for initial hash set sizes (log2).
64 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
68 //===----------------------------------------------------------------------===//
69 /// CompileUnit - This dwarf writer support class manages information associate
70 /// with a source file.
72 /// ID - File identifier for source.
76 /// Die - Compile unit debug information entry.
78 const OwningPtr<DIE> CUDie;
80 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
83 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
84 /// variables to debug information entries.
85 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
87 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
89 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
91 /// Globals - A map of globally visible named entities for this unit.
93 StringMap<DIE*> Globals;
95 /// GlobalTypes - A map of globally visible types for this unit.
97 StringMap<DIE*> GlobalTypes;
100 CompileUnit(unsigned I, DIE *D)
101 : ID(I), CUDie(D), IndexTyDie(0) {}
104 unsigned getID() const { return ID; }
105 DIE* getCUDie() const { return CUDie.get(); }
106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
109 /// hasContent - Return true if this compile unit has something to write out.
111 bool hasContent() const { return !CUDie->getChildren().empty(); }
113 /// addGlobal - Add a new global entity to the compile unit.
115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
117 /// addGlobalType - Add a new global type to the compile unit.
119 void addGlobalType(StringRef Name, DIE *Die) {
120 GlobalTypes[Name] = Die;
123 /// getDIE - Returns the debug information entry map slot for the
124 /// specified debug variable.
125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
127 /// insertDIE - Insert DIE into the map.
128 void insertDIE(const MDNode *N, DIE *D) {
129 MDNodeToDieMap.insert(std::make_pair(N, D));
132 /// getDIEEntry - Returns the debug information entry for the speciefied
134 DIEEntry *getDIEEntry(const MDNode *N) {
135 DenseMap<const MDNode *, DIEEntry *>::iterator I = MDNodeToDIEEntryMap.find(N);
136 if (I == MDNodeToDIEEntryMap.end())
141 /// insertDIEEntry - Insert debug information entry into the map.
142 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
143 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
146 /// addDie - Adds or interns the DIE to the compile unit.
148 void addDie(DIE *Buffer) {
149 this->CUDie->addChild(Buffer);
152 // getIndexTyDie - Get an anonymous type for index type.
153 DIE *getIndexTyDie() {
157 // setIndexTyDie - Set D as anonymous type for index which can be reused
159 void setIndexTyDie(DIE *D) {
165 //===----------------------------------------------------------------------===//
166 /// DbgVariable - This class is used to track local variable information.
169 DIVariable Var; // Variable Descriptor.
170 DIE *TheDIE; // Variable DIE.
171 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
173 // AbsVar may be NULL.
174 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
177 DIVariable getVariable() const { return Var; }
178 void setDIE(DIE *D) { TheDIE = D; }
179 DIE *getDIE() const { return TheDIE; }
180 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
181 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
184 //===----------------------------------------------------------------------===//
185 /// DbgRange - This is used to track range of instructions with identical
186 /// debug info scope.
188 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
190 //===----------------------------------------------------------------------===//
191 /// DbgScope - This class is used to track scope information.
194 DbgScope *Parent; // Parent to this scope.
195 DIDescriptor Desc; // Debug info descriptor for scope.
196 // Location at which this scope is inlined.
197 AssertingVH<const MDNode> InlinedAtLocation;
198 bool AbstractScope; // Abstract Scope
199 const MachineInstr *LastInsn; // Last instruction of this scope.
200 const MachineInstr *FirstInsn; // First instruction of this scope.
201 unsigned DFSIn, DFSOut;
202 // Scopes defined in scope. Contents not owned.
203 SmallVector<DbgScope *, 4> Scopes;
204 // Variables declared in scope. Contents owned.
205 SmallVector<DbgVariable *, 8> Variables;
206 SmallVector<DbgRange, 4> Ranges;
207 // Private state for dump()
208 mutable unsigned IndentLevel;
210 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
211 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
212 LastInsn(0), FirstInsn(0),
213 DFSIn(0), DFSOut(0), IndentLevel(0) {}
217 DbgScope *getParent() const { return Parent; }
218 void setParent(DbgScope *P) { Parent = P; }
219 DIDescriptor getDesc() const { return Desc; }
220 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
221 const MDNode *getScopeNode() const { return Desc; }
222 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
223 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
224 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
226 /// openInsnRange - This scope covers instruction range starting from MI.
227 void openInsnRange(const MachineInstr *MI) {
232 Parent->openInsnRange(MI);
235 /// extendInsnRange - Extend the current instruction range covered by
237 void extendInsnRange(const MachineInstr *MI) {
238 assert (FirstInsn && "MI Range is not open!");
241 Parent->extendInsnRange(MI);
244 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
245 /// until now. This is used when a new scope is encountered while walking
246 /// machine instructions.
247 void closeInsnRange(DbgScope *NewScope = NULL) {
248 assert (LastInsn && "Last insn missing!");
249 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
252 // If Parent dominates NewScope then do not close Parent's instruction
254 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
255 Parent->closeInsnRange(NewScope);
258 void setAbstractScope() { AbstractScope = true; }
259 bool isAbstractScope() const { return AbstractScope; }
261 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
262 unsigned getDFSOut() const { return DFSOut; }
263 void setDFSOut(unsigned O) { DFSOut = O; }
264 unsigned getDFSIn() const { return DFSIn; }
265 void setDFSIn(unsigned I) { DFSIn = I; }
266 bool dominates(const DbgScope *S) {
269 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
274 /// addScope - Add a scope to the scope.
276 void addScope(DbgScope *S) { Scopes.push_back(S); }
278 /// addVariable - Add a variable to the scope.
280 void addVariable(DbgVariable *V) { Variables.push_back(V); }
287 } // end llvm namespace
290 void DbgScope::dump() const {
291 raw_ostream &err = dbgs();
292 err.indent(IndentLevel);
293 const MDNode *N = Desc;
296 err << "Abstract Scope\n";
300 err << "Children ...\n";
301 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
302 if (Scopes[i] != this)
309 DbgScope::~DbgScope() {
310 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
314 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
315 : Asm(A), MMI(Asm->MMI), FirstCU(0),
316 AbbreviationsSet(InitAbbreviationsSetSize),
317 CurrentFnDbgScope(0), PrevLabel(NULL) {
318 NextStringPoolNumber = 0;
320 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
321 DwarfStrSectionSym = TextSectionSym = 0;
322 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
323 DwarfDebugLineSectionSym = CurrentLineSectionSym = 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)
1077 // Add size if non-zero (derived types might be zero-sized.)
1079 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1081 // Add zero size if it is not a forward declaration.
1082 if (CTy.isForwardDecl())
1083 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1085 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1088 // Add source line info if available.
1089 if (!CTy.isForwardDecl())
1090 addSourceLine(&Buffer, &CTy);
1094 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1095 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1096 int64_t L = SR.getLo();
1097 int64_t H = SR.getHi();
1098 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1100 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1102 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1103 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1105 Buffer.addChild(DW_Subrange);
1108 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1109 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1110 DICompositeType *CTy) {
1111 Buffer.setTag(dwarf::DW_TAG_array_type);
1112 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1113 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1115 // Emit derived type.
1116 addType(&Buffer, CTy->getTypeDerivedFrom());
1117 DIArray Elements = CTy->getTypeArray();
1119 // Get an anonymous type for index type.
1120 CompileUnit *TheCU = getCompileUnit(*CTy);
1121 DIE *IdxTy = TheCU->getIndexTyDie();
1123 // Construct an anonymous type for index type.
1124 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1125 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1126 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1127 dwarf::DW_ATE_signed);
1128 TheCU->addDie(IdxTy);
1129 TheCU->setIndexTyDie(IdxTy);
1132 // Add subranges to array type.
1133 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1134 DIDescriptor Element = Elements.getElement(i);
1135 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1136 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1140 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1141 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1142 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1143 StringRef Name = ETy.getName();
1144 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1145 int64_t Value = ETy.getEnumValue();
1146 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1150 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1151 /// printer to not emit usual symbol prefix before the symbol name is used then
1152 /// return linkage name after skipping this special LLVM prefix.
1153 static StringRef getRealLinkageName(StringRef LinkageName) {
1155 if (LinkageName.startswith(StringRef(&One, 1)))
1156 return LinkageName.substr(1);
1160 /// createGlobalVariableDIE - Create new DIE using GV.
1161 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1162 // If the global variable was optmized out then no need to create debug info
1164 if (!GV.getGlobal()) return NULL;
1165 if (GV.getDisplayName().empty()) return NULL;
1167 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1168 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1169 GV.getDisplayName());
1171 StringRef LinkageName = GV.getLinkageName();
1172 if (!LinkageName.empty())
1173 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1174 getRealLinkageName(LinkageName));
1176 addType(GVDie, GV.getType());
1177 if (!GV.isLocalToUnit())
1178 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1179 addSourceLine(GVDie, &GV);
1184 /// createMemberDIE - Create new member DIE.
1185 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1186 DIE *MemberDie = new DIE(DT.getTag());
1187 StringRef Name = DT.getName();
1189 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1191 addType(MemberDie, DT.getTypeDerivedFrom());
1193 addSourceLine(MemberDie, &DT);
1195 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1196 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1198 uint64_t Size = DT.getSizeInBits();
1199 uint64_t FieldSize = DT.getOriginalTypeSize();
1201 if (Size != FieldSize) {
1203 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1204 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1206 uint64_t Offset = DT.getOffsetInBits();
1207 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1208 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1209 uint64_t FieldOffset = (HiMark - FieldSize);
1210 Offset -= FieldOffset;
1212 // Maybe we need to work from the other end.
1213 if (Asm->getTargetData().isLittleEndian())
1214 Offset = FieldSize - (Offset + Size);
1215 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1217 // Here WD_AT_data_member_location points to the anonymous
1218 // field that includes this bit field.
1219 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1222 // This is not a bitfield.
1223 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1225 if (DT.getTag() == dwarf::DW_TAG_inheritance
1226 && DT.isVirtual()) {
1228 // For C++, virtual base classes are not at fixed offset. Use following
1229 // expression to extract appropriate offset from vtable.
1230 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1232 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1233 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1234 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1241 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1244 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1246 if (DT.isProtected())
1247 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1248 dwarf::DW_ACCESS_protected);
1249 else if (DT.isPrivate())
1250 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1251 dwarf::DW_ACCESS_private);
1252 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1253 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1254 dwarf::DW_ACCESS_public);
1256 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1257 dwarf::DW_VIRTUALITY_virtual);
1261 /// createSubprogramDIE - Create new DIE using SP.
1262 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1263 CompileUnit *SPCU = getCompileUnit(SP);
1264 DIE *SPDie = SPCU->getDIE(SP);
1268 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1269 // Constructors and operators for anonymous aggregates do not have names.
1270 if (!SP.getName().empty())
1271 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1273 StringRef LinkageName = SP.getLinkageName();
1274 if (!LinkageName.empty())
1275 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1276 getRealLinkageName(LinkageName));
1278 addSourceLine(SPDie, &SP);
1280 // Add prototyped tag, if C or ObjC.
1281 unsigned Lang = SP.getCompileUnit().getLanguage();
1282 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1283 Lang == dwarf::DW_LANG_ObjC)
1284 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1287 DICompositeType SPTy = SP.getType();
1288 DIArray Args = SPTy.getTypeArray();
1289 unsigned SPTag = SPTy.getTag();
1291 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1292 addType(SPDie, SPTy);
1294 addType(SPDie, DIType(Args.getElement(0)));
1296 unsigned VK = SP.getVirtuality();
1298 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1299 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1300 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1301 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1302 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1303 ContainingTypeMap.insert(std::make_pair(SPDie,
1304 SP.getContainingType()));
1307 if (MakeDecl || !SP.isDefinition()) {
1308 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1310 // Add arguments. Do not add arguments for subprogram definition. They will
1311 // be handled while processing variables.
1312 DICompositeType SPTy = SP.getType();
1313 DIArray Args = SPTy.getTypeArray();
1314 unsigned SPTag = SPTy.getTag();
1316 if (SPTag == dwarf::DW_TAG_subroutine_type)
1317 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1318 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1319 DIType ATy = DIType(DIType(Args.getElement(i)));
1321 if (ATy.isArtificial())
1322 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1323 SPDie->addChild(Arg);
1327 if (SP.isArtificial())
1328 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1330 if (!SP.isLocalToUnit())
1331 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1333 if (SP.isOptimized())
1334 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1336 // DW_TAG_inlined_subroutine may refer to this DIE.
1337 SPCU->insertDIE(SP, SPDie);
1339 // Add to context owner.
1340 addToContextOwner(SPDie, SP.getContext());
1345 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1346 assert(N && "Invalid Scope encoding!");
1348 DbgScope *AScope = AbstractScopes.lookup(N);
1352 DbgScope *Parent = NULL;
1354 DIDescriptor Scope(N);
1355 if (Scope.isLexicalBlock()) {
1356 DILexicalBlock DB(N);
1357 DIDescriptor ParentDesc = DB.getContext();
1358 Parent = getOrCreateAbstractScope(ParentDesc);
1361 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1364 Parent->addScope(AScope);
1365 AScope->setAbstractScope();
1366 AbstractScopes[N] = AScope;
1367 if (DIDescriptor(N).isSubprogram())
1368 AbstractScopesList.push_back(AScope);
1372 /// isSubprogramContext - Return true if Context is either a subprogram
1373 /// or another context nested inside a subprogram.
1374 static bool isSubprogramContext(const MDNode *Context) {
1377 DIDescriptor D(Context);
1378 if (D.isSubprogram())
1381 return isSubprogramContext(DIType(Context).getContext());
1385 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1386 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1387 /// If there are global variables in this scope then create and insert
1388 /// DIEs for these variables.
1389 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1390 CompileUnit *SPCU = getCompileUnit(SPNode);
1391 DIE *SPDie = SPCU->getDIE(SPNode);
1392 assert(SPDie && "Unable to find subprogram DIE!");
1393 DISubprogram SP(SPNode);
1395 // There is not any need to generate specification DIE for a function
1396 // defined at compile unit level. If a function is defined inside another
1397 // function then gdb prefers the definition at top level and but does not
1398 // expect specification DIE in parent function. So avoid creating
1399 // specification DIE for a function defined inside a function.
1400 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1401 !SP.getContext().isFile() &&
1402 !isSubprogramContext(SP.getContext())) {
1403 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1406 DICompositeType SPTy = SP.getType();
1407 DIArray Args = SPTy.getTypeArray();
1408 unsigned SPTag = SPTy.getTag();
1409 if (SPTag == dwarf::DW_TAG_subroutine_type)
1410 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1411 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1412 DIType ATy = DIType(DIType(Args.getElement(i)));
1414 if (ATy.isArtificial())
1415 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1416 SPDie->addChild(Arg);
1418 DIE *SPDeclDie = SPDie;
1419 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1420 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1422 SPCU->addDie(SPDie);
1425 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1426 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1427 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1428 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1429 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1430 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1431 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1436 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1437 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1438 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1440 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1441 if (Scope->isAbstractScope())
1444 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1448 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1449 if (Ranges.size() > 1) {
1450 // .debug_range section has not been laid out yet. Emit offset in
1451 // .debug_range as a uint, size 4, for now. emitDIE will handle
1452 // DW_AT_ranges appropriately.
1453 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1454 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1455 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1456 RE = Ranges.end(); RI != RE; ++RI) {
1457 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1458 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1460 DebugRangeSymbols.push_back(NULL);
1461 DebugRangeSymbols.push_back(NULL);
1465 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1466 const MCSymbol *End = getLabelAfterInsn(RI->second);
1468 if (End == 0) return 0;
1470 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1471 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1473 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1474 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1479 /// constructInlinedScopeDIE - This scope represents inlined body of
1480 /// a function. Construct DIE to represent this concrete inlined copy
1481 /// of the function.
1482 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1484 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1485 assert (Ranges.empty() == false
1486 && "DbgScope does not have instruction markers!");
1488 // FIXME : .debug_inlined section specification does not clearly state how
1489 // to emit inlined scope that is split into multiple instruction ranges.
1490 // For now, use first instruction range and emit low_pc/high_pc pair and
1491 // corresponding .debug_inlined section entry for this pair.
1492 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1493 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1494 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1496 if (StartLabel == FunctionBeginSym || EndLabel == 0) {
1497 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1500 assert(StartLabel->isDefined() &&
1501 "Invalid starting label for an inlined scope!");
1502 assert(EndLabel->isDefined() &&
1503 "Invalid end label for an inlined scope!");
1505 if (!Scope->getScopeNode())
1507 DIScope DS(Scope->getScopeNode());
1508 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1510 DISubprogram InlinedSP = getDISubprogram(DS);
1511 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1512 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1513 assert(OriginDIE && "Unable to find Origin DIE!");
1514 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1515 dwarf::DW_FORM_ref4, OriginDIE);
1517 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1518 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1520 InlinedSubprogramDIEs.insert(OriginDIE);
1522 // Track the start label for this inlined function.
1523 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1524 I = InlineInfo.find(InlinedSP);
1526 if (I == InlineInfo.end()) {
1527 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1529 InlinedSPNodes.push_back(InlinedSP);
1531 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1533 DILocation DL(Scope->getInlinedAt());
1534 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1535 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1541 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1542 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1543 // Get the descriptor.
1544 const DIVariable &VD = DV->getVariable();
1545 StringRef Name = VD.getName();
1549 // Translate tag to proper Dwarf tag. The result variable is dropped for
1552 switch (VD.getTag()) {
1553 case dwarf::DW_TAG_return_variable:
1555 case dwarf::DW_TAG_arg_variable:
1556 Tag = dwarf::DW_TAG_formal_parameter;
1558 case dwarf::DW_TAG_auto_variable: // fall thru
1560 Tag = dwarf::DW_TAG_variable;
1564 // Define variable debug information entry.
1565 DIE *VariableDie = new DIE(Tag);
1568 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1569 V2AVI = VarToAbstractVarMap.find(DV);
1570 if (V2AVI != VarToAbstractVarMap.end())
1571 AbsDIE = V2AVI->second->getDIE();
1574 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1575 dwarf::DW_FORM_ref4, AbsDIE);
1577 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1578 addSourceLine(VariableDie, &VD);
1580 // Add variable type.
1581 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1582 // addresses instead.
1583 if (VD.isBlockByrefVariable())
1584 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1586 addType(VariableDie, VD.getType());
1589 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1590 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1592 if (Scope->isAbstractScope()) {
1593 DV->setDIE(VariableDie);
1597 // Add variable address.
1599 unsigned Offset = DV->getDotDebugLocOffset();
1600 if (Offset != ~0U) {
1601 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1602 Asm->GetTempSymbol("debug_loc", Offset));
1603 DV->setDIE(VariableDie);
1604 UseDotDebugLocEntry.insert(VariableDie);
1608 // Check if variable is described by a DBG_VALUE instruction.
1609 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1610 DbgVariableToDbgInstMap.find(DV);
1611 if (DVI != DbgVariableToDbgInstMap.end()) {
1612 const MachineInstr *DVInsn = DVI->second;
1613 const MCSymbol *DVLabel = findVariableLabel(DV);
1614 bool updated = false;
1615 // FIXME : Handle getNumOperands != 3
1616 if (DVInsn->getNumOperands() == 3) {
1617 if (DVInsn->getOperand(0).isReg())
1619 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1620 else if (DVInsn->getOperand(0).isImm())
1621 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1622 else if (DVInsn->getOperand(0).isFPImm())
1624 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1626 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1627 if (Location.getReg()) {
1628 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1630 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1636 // If variableDie is not updated then DBG_VALUE instruction does not
1637 // have valid variable info.
1641 DV->setDIE(VariableDie);
1645 // .. else use frame index, if available.
1646 MachineLocation Location;
1648 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1650 if (findVariableFrameIndex(DV, &FI)) {
1651 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1652 Location.set(FrameReg, Offset);
1654 if (VD.hasComplexAddress())
1655 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1656 else if (VD.isBlockByrefVariable())
1657 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1659 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1661 DV->setDIE(VariableDie);
1666 void DwarfDebug::addPubTypes(DISubprogram SP) {
1667 DICompositeType SPTy = SP.getType();
1668 unsigned SPTag = SPTy.getTag();
1669 if (SPTag != dwarf::DW_TAG_subroutine_type)
1672 DIArray Args = SPTy.getTypeArray();
1673 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1674 DIType ATy(Args.getElement(i));
1677 DICompositeType CATy = getDICompositeType(ATy);
1678 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1679 && !CATy.isForwardDecl()) {
1680 CompileUnit *TheCU = getCompileUnit(CATy);
1681 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1682 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1687 /// constructScopeDIE - Construct a DIE for this scope.
1688 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1689 if (!Scope || !Scope->getScopeNode())
1692 DIScope DS(Scope->getScopeNode());
1693 DIE *ScopeDIE = NULL;
1694 if (Scope->getInlinedAt())
1695 ScopeDIE = constructInlinedScopeDIE(Scope);
1696 else if (DS.isSubprogram()) {
1697 ProcessedSPNodes.insert(DS);
1698 if (Scope->isAbstractScope())
1699 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1701 ScopeDIE = updateSubprogramScopeDIE(DS);
1704 ScopeDIE = constructLexicalScopeDIE(Scope);
1705 if (!ScopeDIE) return NULL;
1707 // Add variables to scope.
1708 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1709 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1710 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1712 ScopeDIE->addChild(VariableDIE);
1715 // Add nested scopes.
1716 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1717 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1718 // Define the Scope debug information entry.
1719 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1721 ScopeDIE->addChild(NestedDIE);
1724 if (DS.isSubprogram())
1725 addPubTypes(DISubprogram(DS));
1730 /// GetOrCreateSourceID - Look up the source id with the given directory and
1731 /// source file names. If none currently exists, create a new id and insert it
1732 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1734 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1736 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1737 if (DI != DirectoryIdMap.end()) {
1738 DId = DI->getValue();
1740 DId = DirectoryNames.size() + 1;
1741 DirectoryIdMap[DirName] = DId;
1742 DirectoryNames.push_back(DirName);
1746 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1747 if (FI != SourceFileIdMap.end()) {
1748 FId = FI->getValue();
1750 FId = SourceFileNames.size() + 1;
1751 SourceFileIdMap[FileName] = FId;
1752 SourceFileNames.push_back(FileName);
1755 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1756 SourceIdMap.find(std::make_pair(DId, FId));
1757 if (SI != SourceIdMap.end())
1760 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1761 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1762 SourceIds.push_back(std::make_pair(DId, FId));
1767 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1768 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1769 CompileUnit *TheCU = getCompileUnit(NS);
1770 DIE *NDie = TheCU->getDIE(NS);
1773 NDie = new DIE(dwarf::DW_TAG_namespace);
1774 TheCU->insertDIE(NS, NDie);
1775 if (!NS.getName().empty())
1776 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1777 addSourceLine(NDie, &NS);
1778 addToContextOwner(NDie, NS.getContext());
1782 /// constructCompileUnit - Create new CompileUnit for the given
1783 /// metadata node with tag DW_TAG_compile_unit.
1784 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1785 DICompileUnit DIUnit(N);
1786 StringRef FN = DIUnit.getFilename();
1787 StringRef Dir = DIUnit.getDirectory();
1788 unsigned ID = GetOrCreateSourceID(Dir, FN);
1790 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1791 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1792 DIUnit.getProducer());
1793 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1794 DIUnit.getLanguage());
1795 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1796 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1797 // simplifies debug range entries.
1798 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1799 // DW_AT_stmt_list is a offset of line number information for this
1800 // compile unit in debug_line section. This offset is calculated
1801 // during endMoudle().
1802 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1805 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1806 if (DIUnit.isOptimized())
1807 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1809 StringRef Flags = DIUnit.getFlags();
1811 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1813 unsigned RVer = DIUnit.getRunTimeVersion();
1815 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1816 dwarf::DW_FORM_data1, RVer);
1818 CompileUnit *NewCU = new CompileUnit(ID, Die);
1821 CUMap.insert(std::make_pair(N, NewCU));
1824 /// getCompielUnit - Get CompileUnit DIE.
1825 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1826 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1828 const MDNode *CUNode = NULL;
1829 if (D.isCompileUnit())
1831 else if (D.isSubprogram())
1832 CUNode = DISubprogram(N).getCompileUnit();
1833 else if (D.isType())
1834 CUNode = DIType(N).getCompileUnit();
1835 else if (D.isGlobalVariable())
1836 CUNode = DIGlobalVariable(N).getCompileUnit();
1837 else if (D.isVariable())
1838 CUNode = DIVariable(N).getCompileUnit();
1839 else if (D.isNameSpace())
1840 CUNode = DINameSpace(N).getCompileUnit();
1841 else if (D.isFile())
1842 CUNode = DIFile(N).getCompileUnit();
1846 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1847 = CUMap.find(CUNode);
1848 if (I == CUMap.end())
1854 /// constructGlobalVariableDIE - Construct global variable DIE.
1855 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1856 DIGlobalVariable DI_GV(N);
1858 // If debug information is malformed then ignore it.
1859 if (DI_GV.Verify() == false)
1862 // Check for pre-existence.
1863 CompileUnit *TheCU = getCompileUnit(N);
1864 if (TheCU->getDIE(DI_GV))
1867 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1872 TheCU->insertDIE(N, VariableDie);
1874 // Add to context owner.
1875 DIDescriptor GVContext = DI_GV.getContext();
1876 // Do not create specification DIE if context is either compile unit
1878 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1879 !GVContext.isFile() &&
1880 !isSubprogramContext(GVContext)) {
1881 // Create specification DIE.
1882 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1883 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1884 dwarf::DW_FORM_ref4, VariableDie);
1885 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1886 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1887 addLabel(Block, 0, dwarf::DW_FORM_udata,
1888 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1889 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1890 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1891 TheCU->addDie(VariableSpecDIE);
1893 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1894 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1895 addLabel(Block, 0, dwarf::DW_FORM_udata,
1896 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1897 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1899 addToContextOwner(VariableDie, GVContext);
1901 // Expose as global. FIXME - need to check external flag.
1902 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1904 DIType GTy = DI_GV.getType();
1905 if (GTy.isCompositeType() && !GTy.getName().empty()
1906 && !GTy.isForwardDecl()) {
1907 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1908 assert(Entry && "Missing global type!");
1909 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1914 /// construct SubprogramDIE - Construct subprogram DIE.
1915 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1918 // Check for pre-existence.
1919 CompileUnit *TheCU = getCompileUnit(N);
1920 if (TheCU->getDIE(N))
1923 if (!SP.isDefinition())
1924 // This is a method declaration which will be handled while constructing
1928 DIE *SubprogramDie = createSubprogramDIE(SP);
1931 TheCU->insertDIE(N, SubprogramDie);
1933 // Add to context owner.
1934 addToContextOwner(SubprogramDie, SP.getContext());
1936 // Expose as global.
1937 TheCU->addGlobal(SP.getName(), SubprogramDie);
1942 /// beginModule - Emit all Dwarf sections that should come prior to the
1943 /// content. Create global DIEs and emit initial debug info sections.
1944 /// This is inovked by the target AsmPrinter.
1945 void DwarfDebug::beginModule(Module *M) {
1946 if (DisableDebugInfoPrinting)
1949 DebugInfoFinder DbgFinder;
1950 DbgFinder.processModule(*M);
1952 bool HasDebugInfo = false;
1954 // Scan all the compile-units to see if there are any marked as the main unit.
1955 // if not, we do not generate debug info.
1956 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1957 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1958 if (DICompileUnit(*I).isMain()) {
1959 HasDebugInfo = true;
1964 if (!HasDebugInfo) return;
1966 // Tell MMI that we have debug info.
1967 MMI->setDebugInfoAvailability(true);
1969 // Emit initial sections.
1970 EmitSectionLabels();
1972 // Create all the compile unit DIEs.
1973 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1974 E = DbgFinder.compile_unit_end(); I != E; ++I)
1975 constructCompileUnit(*I);
1977 // Create DIEs for each subprogram.
1978 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1979 E = DbgFinder.subprogram_end(); I != E; ++I)
1980 constructSubprogramDIE(*I);
1982 // Create DIEs for each global variable.
1983 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1984 E = DbgFinder.global_variable_end(); I != E; ++I)
1985 constructGlobalVariableDIE(*I);
1987 // Prime section data.
1988 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1990 // Print out .file directives to specify files for .loc directives. These are
1991 // printed out early so that they precede any .loc directives.
1992 if (Asm->MAI->hasDotLocAndDotFile()) {
1993 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1994 // Remember source id starts at 1.
1995 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1996 // FIXME: don't use sys::path for this! This should not depend on the
1998 sys::Path FullPath(getSourceDirectoryName(Id.first));
2000 FullPath.appendComponent(getSourceFileName(Id.second));
2001 assert(AppendOk && "Could not append filename to directory!");
2003 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2008 /// endModule - Emit all Dwarf sections that should come after the content.
2010 void DwarfDebug::endModule() {
2011 if (!FirstCU) return;
2012 const Module *M = MMI->getModule();
2013 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2014 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2015 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2016 DISubprogram SP(AllSPs->getOperand(SI));
2017 if (!SP.Verify()) continue;
2019 // Collect info for variables that were optimized out.
2020 StringRef FName = SP.getLinkageName();
2022 FName = SP.getName();
2024 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2026 unsigned E = NMD->getNumOperands();
2028 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2029 for (unsigned I = 0; I != E; ++I) {
2030 DIVariable DV(NMD->getOperand(I));
2031 if (!DV.Verify()) continue;
2032 Scope->addVariable(new DbgVariable(DV));
2035 // Construct subprogram DIE and add variables DIEs.
2036 constructSubprogramDIE(SP);
2037 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2038 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2039 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2040 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2042 ScopeDIE->addChild(VariableDIE);
2047 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2048 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2049 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2051 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2054 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2055 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2056 DIE *SPDie = CI->first;
2057 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2059 DIE *NDie = getCompileUnit(N)->getDIE(N);
2060 if (!NDie) continue;
2061 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2064 // Standard sections final addresses.
2065 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2066 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2067 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2068 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2070 // End text sections.
2071 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2072 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2073 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2076 // Emit common frame information.
2077 emitCommonDebugFrame();
2079 // Emit function debug frame information
2080 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2081 E = DebugFrames.end(); I != E; ++I)
2082 emitFunctionDebugFrame(*I);
2084 // Compute DIE offsets and sizes.
2085 computeSizeAndOffsets();
2087 // Emit source line correspondence into a debug line section.
2090 // Emit all the DIEs into a debug info section
2093 // Corresponding abbreviations into a abbrev section.
2094 emitAbbreviations();
2096 // Emit info into a debug pubnames section.
2097 emitDebugPubNames();
2099 // Emit info into a debug pubtypes section.
2100 emitDebugPubTypes();
2102 // Emit info into a debug loc section.
2105 // Emit info into a debug aranges section.
2108 // Emit info into a debug ranges section.
2111 // Emit info into a debug macinfo section.
2114 // Emit inline info.
2115 emitDebugInlineInfo();
2117 // Emit info into a debug str section.
2120 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2121 E = CUMap.end(); I != E; ++I)
2123 FirstCU = NULL; // Reset for the next Module, if any.
2126 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2127 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2128 DebugLoc ScopeLoc) {
2130 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2132 return AbsDbgVariable;
2134 LLVMContext &Ctx = Var->getContext();
2135 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2139 AbsDbgVariable = new DbgVariable(Var);
2140 Scope->addVariable(AbsDbgVariable);
2141 AbstractVariables[Var] = AbsDbgVariable;
2142 return AbsDbgVariable;
2145 /// collectVariableInfoFromMMITable - Collect variable information from
2146 /// side table maintained by MMI.
2148 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2149 SmallPtrSet<const MDNode *, 16> &Processed) {
2150 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2151 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2152 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2153 VE = VMap.end(); VI != VE; ++VI) {
2154 const MDNode *Var = VI->first;
2156 Processed.insert(Var);
2158 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2160 DbgScope *Scope = 0;
2161 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2162 Scope = ConcreteScopes.lookup(IA);
2164 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2166 // If variable scope is not found then skip this variable.
2170 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2171 DbgVariable *RegVar = new DbgVariable(DV);
2172 recordVariableFrameIndex(RegVar, VP.first);
2173 Scope->addVariable(RegVar);
2174 if (AbsDbgVariable) {
2175 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2176 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2181 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2182 /// DBG_VALUE instruction, is in undefined reg.
2183 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2184 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2185 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2190 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2191 /// DBG_VALUE instruction, is in a defined reg.
2192 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2193 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2194 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2199 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2201 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2202 SmallPtrSet<const MDNode *, 16> &Processed) {
2204 /// collection info from MMI table.
2205 collectVariableInfoFromMMITable(MF, Processed);
2207 SmallVector<const MachineInstr *, 8> DbgValues;
2208 // Collect variable information from DBG_VALUE machine instructions;
2209 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2211 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2213 const MachineInstr *MInsn = II;
2214 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2216 DbgValues.push_back(MInsn);
2219 // This is a collection of DBV_VALUE instructions describing same variable.
2220 SmallVector<const MachineInstr *, 4> MultipleValues;
2221 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2222 E = DbgValues.end(); I != E; ++I) {
2223 const MachineInstr *MInsn = *I;
2224 MultipleValues.clear();
2225 if (isDbgValueInDefinedReg(MInsn))
2226 MultipleValues.push_back(MInsn);
2227 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2228 if (Processed.count(DV) != 0)
2231 const MachineInstr *PrevMI = MInsn;
2232 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2233 ME = DbgValues.end(); MI != ME; ++MI) {
2235 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2236 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2237 !PrevMI->isIdenticalTo(*MI))
2238 MultipleValues.push_back(*MI);
2242 DbgScope *Scope = findDbgScope(MInsn);
2243 bool CurFnArg = false;
2244 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2245 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2247 if (!Scope && CurFnArg)
2248 Scope = CurrentFnDbgScope;
2249 // If variable scope is not found then skip this variable.
2253 Processed.insert(DV);
2254 DbgVariable *RegVar = new DbgVariable(DV);
2255 Scope->addVariable(RegVar);
2257 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2258 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2259 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2260 VarToAbstractVarMap[RegVar] = AbsVar;
2262 if (MultipleValues.size() <= 1) {
2263 DbgVariableToDbgInstMap[RegVar] = MInsn;
2267 // handle multiple DBG_VALUE instructions describing one variable.
2268 if (DotDebugLocEntries.empty())
2269 RegVar->setDotDebugLocOffset(0);
2271 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2272 const MachineInstr *Begin = NULL;
2273 const MachineInstr *End = NULL;
2274 for (SmallVector<const MachineInstr *, 4>::iterator
2275 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2276 MVI != MVE; ++MVI) {
2282 MachineLocation MLoc;
2283 MLoc.set(Begin->getOperand(0).getReg(), 0);
2284 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2285 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2286 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2288 if (MVI + 1 == MVE) {
2289 // If End is the last instruction then its value is valid
2290 // until the end of the funtion.
2291 MLoc.set(End->getOperand(0).getReg(), 0);
2293 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2296 DotDebugLocEntries.push_back(DotDebugLocEntry());
2299 // Collect info for variables that were optimized out.
2300 const Function *F = MF->getFunction();
2301 const Module *M = F->getParent();
2302 if (NamedMDNode *NMD =
2303 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2304 getRealLinkageName(F->getName())))) {
2305 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2306 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2307 if (!DV || !Processed.insert(DV))
2309 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2311 Scope->addVariable(new DbgVariable(DV));
2316 /// getLabelBeforeInsn - Return Label preceding the instruction.
2317 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2318 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2319 LabelsBeforeInsn.find(MI);
2320 if (I == LabelsBeforeInsn.end())
2321 // FunctionBeginSym always preceeds all the instruction in current function.
2322 return FunctionBeginSym;
2326 /// getLabelAfterInsn - Return Label immediately following the instruction.
2327 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2328 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2329 LabelsAfterInsn.find(MI);
2330 if (I == LabelsAfterInsn.end())
2335 /// beginScope - Process beginning of a scope.
2336 void DwarfDebug::beginScope(const MachineInstr *MI) {
2337 if (InsnNeedsLabel.count(MI) == 0) {
2338 LabelsBeforeInsn[MI] = PrevLabel;
2343 DebugLoc DL = MI->getDebugLoc();
2344 if (!DL.isUnknown()) {
2345 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2346 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2348 LabelsBeforeInsn[MI] = PrevLabel;
2352 // If location is unknown then use temp label for this DBG_VALUE
2354 if (MI->isDebugValue()) {
2355 PrevLabel = MMI->getContext().CreateTempSymbol();
2356 Asm->OutStreamer.EmitLabel(PrevLabel);
2357 LabelsBeforeInsn[MI] = PrevLabel;
2361 if (UnknownLocations) {
2362 PrevLabel = recordSourceLine(0, 0, 0);
2363 LabelsBeforeInsn[MI] = PrevLabel;
2367 assert (0 && "Instruction is not processed!");
2370 /// endScope - Process end of a scope.
2371 void DwarfDebug::endScope(const MachineInstr *MI) {
2372 if (InsnsEndScopeSet.count(MI) != 0) {
2373 // Emit a label if this instruction ends a scope.
2374 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2375 Asm->OutStreamer.EmitLabel(Label);
2376 LabelsAfterInsn[MI] = Label;
2380 /// getOrCreateDbgScope - Create DbgScope for the scope.
2381 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2382 const MDNode *InlinedAt) {
2384 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2387 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2388 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2389 if (DIDescriptor(Scope).isLexicalBlock()) {
2391 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2392 WScope->setParent(Parent);
2393 Parent->addScope(WScope);
2396 if (!WScope->getParent()) {
2397 StringRef SPName = DISubprogram(Scope).getLinkageName();
2398 // We used to check only for a linkage name, but that fails
2399 // since we began omitting the linkage name for private
2400 // functions. The new way is to check for the name in metadata,
2401 // but that's not supported in old .ll test cases. Ergo, we
2403 if (SPName == Asm->MF->getFunction()->getName() ||
2404 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2405 CurrentFnDbgScope = WScope;
2411 getOrCreateAbstractScope(Scope);
2412 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2416 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2417 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2418 DILocation DL(InlinedAt);
2420 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2421 WScope->setParent(Parent);
2422 Parent->addScope(WScope);
2424 ConcreteScopes[InlinedAt] = WScope;
2429 /// hasValidLocation - Return true if debug location entry attached with
2430 /// machine instruction encodes valid location info.
2431 static bool hasValidLocation(LLVMContext &Ctx,
2432 const MachineInstr *MInsn,
2433 const MDNode *&Scope, const MDNode *&InlinedAt) {
2434 DebugLoc DL = MInsn->getDebugLoc();
2435 if (DL.isUnknown()) return false;
2437 const MDNode *S = DL.getScope(Ctx);
2439 // There is no need to create another DIE for compile unit. For all
2440 // other scopes, create one DbgScope now. This will be translated
2441 // into a scope DIE at the end.
2442 if (DIScope(S).isCompileUnit()) return false;
2445 InlinedAt = DL.getInlinedAt(Ctx);
2449 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2451 static void calculateDominanceGraph(DbgScope *Scope) {
2452 assert (Scope && "Unable to calculate scop edominance graph!");
2453 SmallVector<DbgScope *, 4> WorkStack;
2454 WorkStack.push_back(Scope);
2455 unsigned Counter = 0;
2456 while (!WorkStack.empty()) {
2457 DbgScope *WS = WorkStack.back();
2458 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2459 bool visitedChildren = false;
2460 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2461 SE = Children.end(); SI != SE; ++SI) {
2462 DbgScope *ChildScope = *SI;
2463 if (!ChildScope->getDFSOut()) {
2464 WorkStack.push_back(ChildScope);
2465 visitedChildren = true;
2466 ChildScope->setDFSIn(++Counter);
2470 if (!visitedChildren) {
2471 WorkStack.pop_back();
2472 WS->setDFSOut(++Counter);
2477 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2479 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2480 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2483 unsigned PrevDFSIn = 0;
2484 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2486 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2488 const MachineInstr *MInsn = II;
2489 const MDNode *Scope = NULL;
2490 const MDNode *InlinedAt = NULL;
2492 // Check if instruction has valid location information.
2493 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2497 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2498 MI2ScopeMap.find(MInsn);
2499 if (DI != MI2ScopeMap.end()) {
2500 DbgScope *S = DI->second;
2501 dbgs() << S->getDFSIn();
2502 PrevDFSIn = S->getDFSIn();
2504 dbgs() << PrevDFSIn;
2506 dbgs() << " [ x" << PrevDFSIn;
2514 /// extractScopeInformation - Scan machine instructions in this function
2515 /// and collect DbgScopes. Return true, if at least one scope was found.
2516 bool DwarfDebug::extractScopeInformation() {
2517 // If scope information was extracted using .dbg intrinsics then there is not
2518 // any need to extract these information by scanning each instruction.
2519 if (!DbgScopeMap.empty())
2522 // Scan each instruction and create scopes. First build working set of scopes.
2523 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2524 SmallVector<DbgRange, 4> MIRanges;
2525 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2526 const MDNode *PrevScope = NULL;
2527 const MDNode *PrevInlinedAt = NULL;
2528 const MachineInstr *RangeBeginMI = NULL;
2529 const MachineInstr *PrevMI = NULL;
2530 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2532 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2534 const MachineInstr *MInsn = II;
2535 const MDNode *Scope = NULL;
2536 const MDNode *InlinedAt = NULL;
2538 // Check if instruction has valid location information.
2539 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2544 // If scope has not changed then skip this instruction.
2545 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2551 // If we have alread seen a beginning of a instruction range and
2552 // current instruction scope does not match scope of first instruction
2553 // in this range then create a new instruction range.
2554 DbgRange R(RangeBeginMI, PrevMI);
2555 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2557 MIRanges.push_back(R);
2560 // This is a beginning of a new instruction range.
2561 RangeBeginMI = MInsn;
2563 // Reset previous markers.
2566 PrevInlinedAt = InlinedAt;
2570 // Create last instruction range.
2571 if (RangeBeginMI && PrevMI && PrevScope) {
2572 DbgRange R(RangeBeginMI, PrevMI);
2573 MIRanges.push_back(R);
2574 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2577 if (!CurrentFnDbgScope)
2580 calculateDominanceGraph(CurrentFnDbgScope);
2582 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2584 // Find ranges of instructions covered by each DbgScope;
2585 DbgScope *PrevDbgScope = NULL;
2586 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2587 RE = MIRanges.end(); RI != RE; ++RI) {
2588 const DbgRange &R = *RI;
2589 DbgScope *S = MI2ScopeMap.lookup(R.first);
2590 assert (S && "Lost DbgScope for a machine instruction!");
2591 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2592 PrevDbgScope->closeInsnRange(S);
2593 S->openInsnRange(R.first);
2594 S->extendInsnRange(R.second);
2599 PrevDbgScope->closeInsnRange();
2601 identifyScopeMarkers();
2603 return !DbgScopeMap.empty();
2606 /// identifyScopeMarkers() -
2607 /// Each DbgScope has first instruction and last instruction to mark beginning
2608 /// and end of a scope respectively. Create an inverse map that list scopes
2609 /// starts (and ends) with an instruction. One instruction may start (or end)
2610 /// multiple scopes. Ignore scopes that are not reachable.
2611 void DwarfDebug::identifyScopeMarkers() {
2612 SmallVector<DbgScope *, 4> WorkList;
2613 WorkList.push_back(CurrentFnDbgScope);
2614 while (!WorkList.empty()) {
2615 DbgScope *S = WorkList.pop_back_val();
2617 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2618 if (!Children.empty())
2619 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2620 SE = Children.end(); SI != SE; ++SI)
2621 WorkList.push_back(*SI);
2623 if (S->isAbstractScope())
2626 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2629 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2630 RE = Ranges.end(); RI != RE; ++RI) {
2631 assert(RI->first && "DbgRange does not have first instruction!");
2632 assert(RI->second && "DbgRange does not have second instruction!");
2633 InsnsEndScopeSet.insert(RI->second);
2638 /// FindFirstDebugLoc - Find the first debug location in the function. This
2639 /// is intended to be an approximation for the source position of the
2640 /// beginning of the function.
2641 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2642 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2644 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2645 MBBI != MBBE; ++MBBI) {
2646 DebugLoc DL = MBBI->getDebugLoc();
2647 if (!DL.isUnknown())
2653 /// beginFunction - Gather pre-function debug information. Assumes being
2654 /// emitted immediately after the function entry point.
2655 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2656 if (!MMI->hasDebugInfo()) return;
2657 if (!extractScopeInformation()) return;
2659 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2660 Asm->getFunctionNumber());
2661 // Assumes in correct section after the entry point.
2662 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2664 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2666 DebugLoc FDL = FindFirstDebugLoc(MF);
2667 if (FDL.isUnknown()) return;
2669 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2671 DISubprogram SP = getDISubprogram(Scope);
2674 Line = SP.getLineNumber();
2677 Line = FDL.getLine();
2681 recordSourceLine(Line, Col, Scope);
2683 /// ProcessedArgs - Collection of arguments already processed.
2684 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2687 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2689 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2691 const MachineInstr *MI = II;
2692 DebugLoc DL = MI->getDebugLoc();
2693 if (MI->isDebugValue()) {
2694 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2695 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2696 if (!DV.Verify()) continue;
2697 // If DBG_VALUE is for a local variable then it needs a label.
2698 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2699 && isDbgValueInUndefinedReg(MI) == false)
2700 InsnNeedsLabel.insert(MI);
2701 // DBG_VALUE for inlined functions argument needs a label.
2702 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2703 describes(MF->getFunction()))
2704 InsnNeedsLabel.insert(MI);
2705 // DBG_VALUE indicating argument location change needs a label.
2706 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV))
2707 InsnNeedsLabel.insert(MI);
2709 // If location is unknown then instruction needs a location only if
2710 // UnknownLocations flag is set.
2711 if (DL.isUnknown()) {
2712 if (UnknownLocations && !PrevLoc.isUnknown())
2713 InsnNeedsLabel.insert(MI);
2714 } else if (DL != PrevLoc)
2715 // Otherwise, instruction needs a location only if it is new location.
2716 InsnNeedsLabel.insert(MI);
2719 if (!DL.isUnknown() || UnknownLocations)
2723 PrevLabel = FunctionBeginSym;
2726 /// endFunction - Gather and emit post-function debug information.
2728 void DwarfDebug::endFunction(const MachineFunction *MF) {
2729 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2731 if (CurrentFnDbgScope) {
2733 // Define end label for subprogram.
2734 FunctionEndSym = Asm->GetTempSymbol("func_end",
2735 Asm->getFunctionNumber());
2736 // Assumes in correct section after the entry point.
2737 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2739 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2740 collectVariableInfo(MF, ProcessedVars);
2742 // Get function line info.
2743 if (!Lines.empty()) {
2744 // Get section line info.
2745 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2746 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2747 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2748 // Append the function info to section info.
2749 SectionLineInfos.insert(SectionLineInfos.end(),
2750 Lines.begin(), Lines.end());
2753 // Construct abstract scopes.
2754 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2755 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2756 DISubprogram SP((*AI)->getScopeNode());
2758 // Collect info for variables that were optimized out.
2759 StringRef FName = SP.getLinkageName();
2761 FName = SP.getName();
2762 const Module *M = MF->getFunction()->getParent();
2763 if (NamedMDNode *NMD =
2764 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2765 getRealLinkageName(FName)))) {
2766 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2767 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2768 if (!DV || !ProcessedVars.insert(DV))
2770 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2772 Scope->addVariable(new DbgVariable(DV));
2776 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2777 constructScopeDIE(*AI);
2780 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2782 if (!DisableFramePointerElim(*MF))
2783 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2784 dwarf::DW_FORM_flag, 1);
2787 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2788 MMI->getFrameMoves()));
2792 CurrentFnDbgScope = NULL;
2793 InsnNeedsLabel.clear();
2794 DbgVariableToFrameIndexMap.clear();
2795 VarToAbstractVarMap.clear();
2796 DbgVariableToDbgInstMap.clear();
2797 DbgVariableLabelsMap.clear();
2798 DeleteContainerSeconds(DbgScopeMap);
2799 InsnsEndScopeSet.clear();
2800 ConcreteScopes.clear();
2801 DeleteContainerSeconds(AbstractScopes);
2802 AbstractScopesList.clear();
2803 AbstractVariables.clear();
2804 LabelsBeforeInsn.clear();
2805 LabelsAfterInsn.clear();
2810 /// recordVariableFrameIndex - Record a variable's index.
2811 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2812 assert (V && "Invalid DbgVariable!");
2813 DbgVariableToFrameIndexMap[V] = Index;
2816 /// findVariableFrameIndex - Return true if frame index for the variable
2817 /// is found. Update FI to hold value of the index.
2818 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2819 assert (V && "Invalid DbgVariable!");
2820 DenseMap<const DbgVariable *, int>::iterator I =
2821 DbgVariableToFrameIndexMap.find(V);
2822 if (I == DbgVariableToFrameIndexMap.end())
2828 /// findVariableLabel - Find MCSymbol for the variable.
2829 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2830 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2831 = DbgVariableLabelsMap.find(V);
2832 if (I == DbgVariableLabelsMap.end())
2834 else return I->second;
2837 /// findDbgScope - Find DbgScope for the debug loc attached with an
2839 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2840 DbgScope *Scope = NULL;
2842 MInsn->getParent()->getParent()->getFunction()->getContext();
2843 DebugLoc DL = MInsn->getDebugLoc();
2848 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2849 Scope = ConcreteScopes.lookup(IA);
2851 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2857 /// recordSourceLine - Register a source line with debug info. Returns the
2858 /// unique label that was emitted and which provides correspondence to
2859 /// the source line list.
2860 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2867 DIDescriptor Scope(S);
2869 if (Scope.isCompileUnit()) {
2870 DICompileUnit CU(S);
2871 Dir = CU.getDirectory();
2872 Fn = CU.getFilename();
2873 } else if (Scope.isSubprogram()) {
2875 Dir = SP.getDirectory();
2876 Fn = SP.getFilename();
2877 } else if (Scope.isLexicalBlock()) {
2878 DILexicalBlock DB(S);
2879 Dir = DB.getDirectory();
2880 Fn = DB.getFilename();
2882 assert(0 && "Unexpected scope info");
2884 Src = GetOrCreateSourceID(Dir, Fn);
2888 if (!Lines.empty()) {
2889 SrcLineInfo lastSrcLineInfo = Lines.back();
2890 // Emitting sequential line records with the same line number (but
2891 // different addresses) seems to confuse GDB. Avoid this.
2892 if (lastSrcLineInfo.getLine() == Line)
2897 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2898 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2900 Asm->OutStreamer.EmitLabel(Label);
2904 //===----------------------------------------------------------------------===//
2906 //===----------------------------------------------------------------------===//
2908 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2911 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2912 // Get the children.
2913 const std::vector<DIE *> &Children = Die->getChildren();
2915 // If not last sibling and has children then add sibling offset attribute.
2916 if (!Last && !Children.empty())
2917 Die->addSiblingOffset(DIEValueAllocator);
2919 // Record the abbreviation.
2920 assignAbbrevNumber(Die->getAbbrev());
2922 // Get the abbreviation for this DIE.
2923 unsigned AbbrevNumber = Die->getAbbrevNumber();
2924 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2927 Die->setOffset(Offset);
2929 // Start the size with the size of abbreviation code.
2930 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2932 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2933 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2935 // Size the DIE attribute values.
2936 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2937 // Size attribute value.
2938 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2940 // Size the DIE children if any.
2941 if (!Children.empty()) {
2942 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2943 "Children flag not set");
2945 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2946 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2948 // End of children marker.
2949 Offset += sizeof(int8_t);
2952 Die->setSize(Offset - Die->getOffset());
2956 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2958 void DwarfDebug::computeSizeAndOffsets() {
2959 unsigned PrevOffset = 0;
2960 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2961 E = CUMap.end(); I != E; ++I) {
2962 // Compute size of compile unit header.
2963 static unsigned Offset = PrevOffset +
2964 sizeof(int32_t) + // Length of Compilation Unit Info
2965 sizeof(int16_t) + // DWARF version number
2966 sizeof(int32_t) + // Offset Into Abbrev. Section
2967 sizeof(int8_t); // Pointer Size (in bytes)
2968 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2969 PrevOffset = Offset;
2973 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2974 /// temporary label to it if SymbolStem is specified.
2975 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2976 const char *SymbolStem = 0) {
2977 Asm->OutStreamer.SwitchSection(Section);
2978 if (!SymbolStem) return 0;
2980 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2981 Asm->OutStreamer.EmitLabel(TmpSym);
2985 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2986 /// the start of each one.
2987 void DwarfDebug::EmitSectionLabels() {
2988 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2990 // Dwarf sections base addresses.
2991 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2992 DwarfFrameSectionSym =
2993 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2996 DwarfInfoSectionSym =
2997 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2998 DwarfAbbrevSectionSym =
2999 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3000 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3002 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3003 EmitSectionSym(Asm, MacroInfo);
3005 DwarfDebugLineSectionSym =
3006 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3007 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3008 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3009 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3010 DwarfStrSectionSym =
3011 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3012 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3015 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3016 "section_debug_loc");
3018 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3019 EmitSectionSym(Asm, TLOF.getDataSection());
3022 /// emitDIE - Recusively Emits a debug information entry.
3024 void DwarfDebug::emitDIE(DIE *Die) {
3025 // Get the abbreviation for this DIE.
3026 unsigned AbbrevNumber = Die->getAbbrevNumber();
3027 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3029 // Emit the code (index) for the abbreviation.
3030 if (Asm->isVerbose())
3031 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3032 Twine::utohexstr(Die->getOffset()) + ":0x" +
3033 Twine::utohexstr(Die->getSize()) + " " +
3034 dwarf::TagString(Abbrev->getTag()));
3035 Asm->EmitULEB128(AbbrevNumber);
3037 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3038 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3040 // Emit the DIE attribute values.
3041 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3042 unsigned Attr = AbbrevData[i].getAttribute();
3043 unsigned Form = AbbrevData[i].getForm();
3044 assert(Form && "Too many attributes for DIE (check abbreviation)");
3046 if (Asm->isVerbose())
3047 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3050 case dwarf::DW_AT_sibling:
3051 Asm->EmitInt32(Die->getSiblingOffset());
3053 case dwarf::DW_AT_abstract_origin: {
3054 DIEEntry *E = cast<DIEEntry>(Values[i]);
3055 DIE *Origin = E->getEntry();
3056 unsigned Addr = Origin->getOffset();
3057 Asm->EmitInt32(Addr);
3060 case dwarf::DW_AT_ranges: {
3061 // DW_AT_range Value encodes offset in debug_range section.
3062 DIEInteger *V = cast<DIEInteger>(Values[i]);
3063 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3065 DwarfDebugRangeSectionSym,
3069 case dwarf::DW_AT_stmt_list: {
3070 Asm->EmitLabelDifference(CurrentLineSectionSym,
3071 DwarfDebugLineSectionSym, 4);
3074 case dwarf::DW_AT_location: {
3075 if (UseDotDebugLocEntry.count(Die) != 0) {
3076 DIELabel *L = cast<DIELabel>(Values[i]);
3077 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3079 Values[i]->EmitValue(Asm, Form);
3083 // Emit an attribute using the defined form.
3084 Values[i]->EmitValue(Asm, Form);
3089 // Emit the DIE children if any.
3090 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3091 const std::vector<DIE *> &Children = Die->getChildren();
3093 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3094 emitDIE(Children[j]);
3096 if (Asm->isVerbose())
3097 Asm->OutStreamer.AddComment("End Of Children Mark");
3102 /// emitDebugInfo - Emit the debug info section.
3104 void DwarfDebug::emitDebugInfo() {
3105 // Start debug info section.
3106 Asm->OutStreamer.SwitchSection(
3107 Asm->getObjFileLowering().getDwarfInfoSection());
3108 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3109 E = CUMap.end(); I != E; ++I) {
3110 CompileUnit *TheCU = I->second;
3111 DIE *Die = TheCU->getCUDie();
3113 // Emit the compile units header.
3114 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3117 // Emit size of content not including length itself
3118 unsigned ContentSize = Die->getSize() +
3119 sizeof(int16_t) + // DWARF version number
3120 sizeof(int32_t) + // Offset Into Abbrev. Section
3121 sizeof(int8_t) + // Pointer Size (in bytes)
3122 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3124 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3125 Asm->EmitInt32(ContentSize);
3126 Asm->OutStreamer.AddComment("DWARF version number");
3127 Asm->EmitInt16(dwarf::DWARF_VERSION);
3128 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3129 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3130 DwarfAbbrevSectionSym);
3131 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3132 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3135 // FIXME - extra padding for gdb bug.
3136 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3141 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3145 /// emitAbbreviations - Emit the abbreviation section.
3147 void DwarfDebug::emitAbbreviations() const {
3148 // Check to see if it is worth the effort.
3149 if (!Abbreviations.empty()) {
3150 // Start the debug abbrev section.
3151 Asm->OutStreamer.SwitchSection(
3152 Asm->getObjFileLowering().getDwarfAbbrevSection());
3154 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3156 // For each abbrevation.
3157 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3158 // Get abbreviation data
3159 const DIEAbbrev *Abbrev = Abbreviations[i];
3161 // Emit the abbrevations code (base 1 index.)
3162 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3164 // Emit the abbreviations data.
3168 // Mark end of abbreviations.
3169 Asm->EmitULEB128(0, "EOM(3)");
3171 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3175 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3176 /// the line matrix.
3178 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3179 // Define last address of section.
3180 Asm->OutStreamer.AddComment("Extended Op");
3183 Asm->OutStreamer.AddComment("Op size");
3184 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3185 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3186 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3188 Asm->OutStreamer.AddComment("Section end label");
3190 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3191 Asm->getTargetData().getPointerSize(),
3194 // Mark end of matrix.
3195 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3201 /// emitDebugLines - Emit source line information.
3203 void DwarfDebug::emitDebugLines() {
3204 // If the target is using .loc/.file, the assembler will be emitting the
3205 // .debug_line table automatically.
3206 if (Asm->MAI->hasDotLocAndDotFile())
3209 // Minimum line delta, thus ranging from -10..(255-10).
3210 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3211 // Maximum line delta, thus ranging from -10..(255-10).
3212 const int MaxLineDelta = 255 + MinLineDelta;
3214 // Start the dwarf line section.
3215 Asm->OutStreamer.SwitchSection(
3216 Asm->getObjFileLowering().getDwarfLineSection());
3218 // Construct the section header.
3219 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3220 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3221 Asm->OutStreamer.AddComment("Length of Source Line Info");
3222 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3223 Asm->GetTempSymbol("line_begin"), 4);
3224 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3226 Asm->OutStreamer.AddComment("DWARF version number");
3227 Asm->EmitInt16(dwarf::DWARF_VERSION);
3229 Asm->OutStreamer.AddComment("Prolog Length");
3230 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3231 Asm->GetTempSymbol("line_prolog_begin"), 4);
3232 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3234 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3236 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3238 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3239 Asm->EmitInt8(MinLineDelta);
3240 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3241 Asm->EmitInt8(MaxLineDelta);
3242 Asm->OutStreamer.AddComment("Special Opcode Base");
3243 Asm->EmitInt8(-MinLineDelta);
3245 // Line number standard opcode encodings argument count
3246 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3248 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3250 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3252 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3254 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3256 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3258 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3260 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3262 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3265 // Emit directories.
3266 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3267 const std::string &Dir = getSourceDirectoryName(DI);
3268 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3269 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3272 Asm->OutStreamer.AddComment("End of directories");
3276 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3277 // Remember source id starts at 1.
3278 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3279 const std::string &FN = getSourceFileName(Id.second);
3280 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3281 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3283 Asm->EmitULEB128(Id.first, "Directory #");
3284 Asm->EmitULEB128(0, "Mod date");
3285 Asm->EmitULEB128(0, "File size");
3288 Asm->OutStreamer.AddComment("End of files");
3291 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3293 // A sequence for each text section.
3294 unsigned SecSrcLinesSize = SectionSourceLines.size();
3296 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3297 // Isolate current sections line info.
3298 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3300 // Dwarf assumes we start with first line of first source file.
3301 unsigned Source = 1;
3304 // Construct rows of the address, source, line, column matrix.
3305 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3306 const SrcLineInfo &LineInfo = LineInfos[i];
3307 MCSymbol *Label = LineInfo.getLabel();
3308 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3310 if (Asm->isVerbose()) {
3311 std::pair<unsigned, unsigned> SrcID =
3312 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3313 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3315 Twine(getSourceFileName(SrcID.second)) +
3316 ":" + Twine(LineInfo.getLine()));
3319 // Define the line address.
3320 Asm->OutStreamer.AddComment("Extended Op");
3322 Asm->OutStreamer.AddComment("Op size");
3323 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3325 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3326 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3328 Asm->OutStreamer.AddComment("Location label");
3329 Asm->OutStreamer.EmitSymbolValue(Label,
3330 Asm->getTargetData().getPointerSize(),
3333 // If change of source, then switch to the new source.
3334 if (Source != LineInfo.getSourceID()) {
3335 Source = LineInfo.getSourceID();
3336 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3337 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3338 Asm->EmitULEB128(Source, "New Source");
3341 // If change of line.
3342 if (Line != LineInfo.getLine()) {
3343 // Determine offset.
3344 int Offset = LineInfo.getLine() - Line;
3345 int Delta = Offset - MinLineDelta;
3348 Line = LineInfo.getLine();
3350 // If delta is small enough and in range...
3351 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3352 // ... then use fast opcode.
3353 Asm->OutStreamer.AddComment("Line Delta");
3354 Asm->EmitInt8(Delta - MinLineDelta);
3356 // ... otherwise use long hand.
3357 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3358 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3359 Asm->EmitSLEB128(Offset, "Line Offset");
3360 Asm->OutStreamer.AddComment("DW_LNS_copy");
3361 Asm->EmitInt8(dwarf::DW_LNS_copy);
3364 // Copy the previous row (different address or source)
3365 Asm->OutStreamer.AddComment("DW_LNS_copy");
3366 Asm->EmitInt8(dwarf::DW_LNS_copy);
3370 emitEndOfLineMatrix(j + 1);
3373 if (SecSrcLinesSize == 0)
3374 // Because we're emitting a debug_line section, we still need a line
3375 // table. The linker and friends expect it to exist. If there's nothing to
3376 // put into it, emit an empty table.
3377 emitEndOfLineMatrix(1);
3379 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3382 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3384 void DwarfDebug::emitCommonDebugFrame() {
3385 if (!Asm->MAI->doesDwarfRequireFrameSection())
3388 int stackGrowth = Asm->getTargetData().getPointerSize();
3389 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3390 TargetFrameInfo::StackGrowsDown)
3393 // Start the dwarf frame section.
3394 Asm->OutStreamer.SwitchSection(
3395 Asm->getObjFileLowering().getDwarfFrameSection());
3397 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3398 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3399 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3400 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3402 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3403 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3404 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3405 Asm->OutStreamer.AddComment("CIE Version");
3406 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3407 Asm->OutStreamer.AddComment("CIE Augmentation");
3408 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3409 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3410 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3411 Asm->OutStreamer.AddComment("CIE RA Column");
3412 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3413 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3415 std::vector<MachineMove> Moves;
3416 RI->getInitialFrameState(Moves);
3418 Asm->EmitFrameMoves(Moves, 0, false);
3420 Asm->EmitAlignment(2);
3421 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3424 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3427 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3428 if (!Asm->MAI->doesDwarfRequireFrameSection())
3431 // Start the dwarf frame section.
3432 Asm->OutStreamer.SwitchSection(
3433 Asm->getObjFileLowering().getDwarfFrameSection());
3435 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3436 MCSymbol *DebugFrameBegin =
3437 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3438 MCSymbol *DebugFrameEnd =
3439 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3440 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3442 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3444 Asm->OutStreamer.AddComment("FDE CIE offset");
3445 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3446 DwarfFrameSectionSym);
3448 Asm->OutStreamer.AddComment("FDE initial location");
3449 MCSymbol *FuncBeginSym =
3450 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3451 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3452 Asm->getTargetData().getPointerSize(),
3456 Asm->OutStreamer.AddComment("FDE address range");
3457 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3458 FuncBeginSym, Asm->getTargetData().getPointerSize());
3460 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3462 Asm->EmitAlignment(2);
3463 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3466 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3468 void DwarfDebug::emitDebugPubNames() {
3469 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3470 E = CUMap.end(); I != E; ++I) {
3471 CompileUnit *TheCU = I->second;
3472 // Start the dwarf pubnames section.
3473 Asm->OutStreamer.SwitchSection(
3474 Asm->getObjFileLowering().getDwarfPubNamesSection());
3476 Asm->OutStreamer.AddComment("Length of Public Names Info");
3477 Asm->EmitLabelDifference(
3478 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3479 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3481 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3484 Asm->OutStreamer.AddComment("DWARF Version");
3485 Asm->EmitInt16(dwarf::DWARF_VERSION);
3487 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3488 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3489 DwarfInfoSectionSym);
3491 Asm->OutStreamer.AddComment("Compilation Unit Length");
3492 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3493 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3496 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3497 for (StringMap<DIE*>::const_iterator
3498 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3499 const char *Name = GI->getKeyData();
3500 DIE *Entity = GI->second;
3502 Asm->OutStreamer.AddComment("DIE offset");
3503 Asm->EmitInt32(Entity->getOffset());
3505 if (Asm->isVerbose())
3506 Asm->OutStreamer.AddComment("External Name");
3507 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3510 Asm->OutStreamer.AddComment("End Mark");
3512 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3517 void DwarfDebug::emitDebugPubTypes() {
3518 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3519 E = CUMap.end(); I != E; ++I) {
3520 CompileUnit *TheCU = I->second;
3521 // Start the dwarf pubnames section.
3522 Asm->OutStreamer.SwitchSection(
3523 Asm->getObjFileLowering().getDwarfPubTypesSection());
3524 Asm->OutStreamer.AddComment("Length of Public Types Info");
3525 Asm->EmitLabelDifference(
3526 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3527 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3529 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3532 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3533 Asm->EmitInt16(dwarf::DWARF_VERSION);
3535 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3536 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3537 DwarfInfoSectionSym);
3539 Asm->OutStreamer.AddComment("Compilation Unit Length");
3540 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3541 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3544 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3545 for (StringMap<DIE*>::const_iterator
3546 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3547 const char *Name = GI->getKeyData();
3548 DIE * Entity = GI->second;
3550 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3551 Asm->EmitInt32(Entity->getOffset());
3553 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3554 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3557 Asm->OutStreamer.AddComment("End Mark");
3559 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3564 /// emitDebugStr - Emit visible names into a debug str section.
3566 void DwarfDebug::emitDebugStr() {
3567 // Check to see if it is worth the effort.
3568 if (StringPool.empty()) return;
3570 // Start the dwarf str section.
3571 Asm->OutStreamer.SwitchSection(
3572 Asm->getObjFileLowering().getDwarfStrSection());
3574 // Get all of the string pool entries and put them in an array by their ID so
3575 // we can sort them.
3576 SmallVector<std::pair<unsigned,
3577 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3579 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3580 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3581 Entries.push_back(std::make_pair(I->second.second, &*I));
3583 array_pod_sort(Entries.begin(), Entries.end());
3585 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3586 // Emit a label for reference from debug information entries.
3587 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3589 // Emit the string itself.
3590 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3594 /// emitDebugLoc - Emit visible names into a debug loc section.
3596 void DwarfDebug::emitDebugLoc() {
3597 if (DotDebugLocEntries.empty())
3600 // Start the dwarf loc section.
3601 Asm->OutStreamer.SwitchSection(
3602 Asm->getObjFileLowering().getDwarfLocSection());
3603 unsigned char Size = Asm->getTargetData().getPointerSize();
3604 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3606 for (SmallVector<DotDebugLocEntry, 4>::iterator
3607 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3608 I != E; ++I, ++index) {
3609 DotDebugLocEntry Entry = *I;
3610 if (Entry.isEmpty()) {
3611 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3612 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3613 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3615 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3616 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3617 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3618 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3620 Asm->OutStreamer.AddComment("Loc expr size");
3622 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3624 Asm->OutStreamer.AddComment("Loc expr size");
3625 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3626 Asm->EmitInt8(dwarf::DW_OP_regx);
3627 Asm->EmitULEB128(Reg);
3633 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3635 void DwarfDebug::EmitDebugARanges() {
3636 // Start the dwarf aranges section.
3637 Asm->OutStreamer.SwitchSection(
3638 Asm->getObjFileLowering().getDwarfARangesSection());
3641 /// emitDebugRanges - Emit visible names into a debug ranges section.
3643 void DwarfDebug::emitDebugRanges() {
3644 // Start the dwarf ranges section.
3645 Asm->OutStreamer.SwitchSection(
3646 Asm->getObjFileLowering().getDwarfRangesSection());
3647 unsigned char Size = Asm->getTargetData().getPointerSize();
3648 for (SmallVector<const MCSymbol *, 8>::iterator
3649 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3652 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3654 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3658 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3660 void DwarfDebug::emitDebugMacInfo() {
3661 if (const MCSection *LineInfo =
3662 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3663 // Start the dwarf macinfo section.
3664 Asm->OutStreamer.SwitchSection(LineInfo);
3668 /// emitDebugInlineInfo - Emit inline info using following format.
3670 /// 1. length of section
3671 /// 2. Dwarf version number
3672 /// 3. address size.
3674 /// Entries (one "entry" for each function that was inlined):
3676 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3677 /// otherwise offset into __debug_str for regular function name.
3678 /// 2. offset into __debug_str section for regular function name.
3679 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3680 /// instances for the function.
3682 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3683 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3684 /// __debug_info section, and the low_pc is the starting address for the
3685 /// inlining instance.
3686 void DwarfDebug::emitDebugInlineInfo() {
3687 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3693 Asm->OutStreamer.SwitchSection(
3694 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3696 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3697 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3698 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3700 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3702 Asm->OutStreamer.AddComment("Dwarf Version");
3703 Asm->EmitInt16(dwarf::DWARF_VERSION);
3704 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3705 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3707 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3708 E = InlinedSPNodes.end(); I != E; ++I) {
3710 const MDNode *Node = *I;
3711 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3712 = InlineInfo.find(Node);
3713 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3714 DISubprogram SP(Node);
3715 StringRef LName = SP.getLinkageName();
3716 StringRef Name = SP.getName();
3718 Asm->OutStreamer.AddComment("MIPS linkage name");
3719 if (LName.empty()) {
3720 Asm->OutStreamer.EmitBytes(Name, 0);
3721 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3723 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3724 DwarfStrSectionSym);
3726 Asm->OutStreamer.AddComment("Function name");
3727 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3728 Asm->EmitULEB128(Labels.size(), "Inline count");
3730 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3731 LE = Labels.end(); LI != LE; ++LI) {
3732 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3733 Asm->EmitInt32(LI->second->getOffset());
3735 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3736 Asm->OutStreamer.EmitSymbolValue(LI->first,
3737 Asm->getTargetData().getPointerSize(),0);
3741 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));