1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
48 cl::desc("Disable debug info printing"));
50 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
51 cl::desc("Make an absense of debug location information explicit."),
55 const char *DWARFGroupName = "DWARF Emission";
56 const char *DbgTimerName = "DWARF Debug Writer";
57 } // end anonymous namespace
59 //===----------------------------------------------------------------------===//
61 /// Configuration values for initial hash set sizes (log2).
63 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
67 //===----------------------------------------------------------------------===//
68 /// CompileUnit - This dwarf writer support class manages information associate
69 /// with a source file.
71 /// ID - File identifier for source.
75 /// Die - Compile unit debug information entry.
77 const OwningPtr<DIE> CUDie;
79 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
82 /// GVToDieMap - Tracks the mapping of unit level debug informaton
83 /// variables to debug information entries.
84 /// FIXME : Rename GVToDieMap -> NodeToDieMap
85 DenseMap<const MDNode *, DIE *> GVToDieMap;
87 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
90 DenseMap<const MDNode *, DIEEntry *> GVToDIEEntryMap;
92 /// Globals - A map of globally visible named entities for this unit.
94 StringMap<DIE*> Globals;
96 /// GlobalTypes - A map of globally visible types for this unit.
98 StringMap<DIE*> GlobalTypes;
101 CompileUnit(unsigned I, DIE *D)
102 : ID(I), CUDie(D), IndexTyDie(0) {}
105 unsigned getID() const { return ID; }
106 DIE* getCUDie() const { return CUDie.get(); }
107 const StringMap<DIE*> &getGlobals() const { return Globals; }
108 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
110 /// hasContent - Return true if this compile unit has something to write out.
112 bool hasContent() const { return !CUDie->getChildren().empty(); }
114 /// addGlobal - Add a new global entity to the compile unit.
116 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
118 /// addGlobalType - Add a new global type to the compile unit.
120 void addGlobalType(StringRef Name, DIE *Die) {
121 GlobalTypes[Name] = Die;
124 /// getDIE - Returns the debug information entry map slot for the
125 /// specified debug variable.
126 DIE *getDIE(const MDNode *N) { return GVToDieMap.lookup(N); }
128 /// insertDIE - Insert DIE into the map.
129 void insertDIE(const MDNode *N, DIE *D) {
130 GVToDieMap.insert(std::make_pair(N, D));
133 /// getDIEEntry - Returns the debug information entry for the speciefied
135 DIEEntry *getDIEEntry(const MDNode *N) {
136 DenseMap<const MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
137 if (I == GVToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 GVToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 DIE *TheDIE; // Variable DIE.
172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
174 // AbsVar may be NULL.
175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
178 DIVariable getVariable() const { return Var; }
179 void setDIE(DIE *D) { TheDIE = D; }
180 DIE *getDIE() const { return TheDIE; }
181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
185 //===----------------------------------------------------------------------===//
186 /// DbgRange - This is used to track range of instructions with identical
187 /// debug info scope.
189 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
191 //===----------------------------------------------------------------------===//
192 /// DbgScope - This class is used to track scope information.
195 DbgScope *Parent; // Parent to this scope.
196 DIDescriptor Desc; // Debug info descriptor for scope.
197 // Location at which this scope is inlined.
198 AssertingVH<const MDNode> InlinedAtLocation;
199 bool AbstractScope; // Abstract Scope
200 const MachineInstr *LastInsn; // Last instruction of this scope.
201 const MachineInstr *FirstInsn; // First instruction of this scope.
202 unsigned DFSIn, DFSOut;
203 // Scopes defined in scope. Contents not owned.
204 SmallVector<DbgScope *, 4> Scopes;
205 // Variables declared in scope. Contents owned.
206 SmallVector<DbgVariable *, 8> Variables;
207 SmallVector<DbgRange, 4> Ranges;
208 // Private state for dump()
209 mutable unsigned IndentLevel;
211 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
212 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
213 LastInsn(0), FirstInsn(0),
214 DFSIn(0), DFSOut(0), IndentLevel(0) {}
218 DbgScope *getParent() const { return Parent; }
219 void setParent(DbgScope *P) { Parent = P; }
220 DIDescriptor getDesc() const { return Desc; }
221 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
222 const MDNode *getScopeNode() const { return Desc; }
223 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
224 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
225 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
227 /// openInsnRange - This scope covers instruction range starting from MI.
228 void openInsnRange(const MachineInstr *MI) {
233 Parent->openInsnRange(MI);
236 /// extendInsnRange - Extend the current instruction range covered by
238 void extendInsnRange(const MachineInstr *MI) {
239 assert (FirstInsn && "MI Range is not open!");
242 Parent->extendInsnRange(MI);
245 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
246 /// until now. This is used when a new scope is encountered while walking
247 /// machine instructions.
248 void closeInsnRange(DbgScope *NewScope = NULL) {
249 assert (LastInsn && "Last insn missing!");
250 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
253 // If Parent dominates NewScope then do not close Parent's instruction
255 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
256 Parent->closeInsnRange(NewScope);
259 void setAbstractScope() { AbstractScope = true; }
260 bool isAbstractScope() const { return AbstractScope; }
262 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
263 unsigned getDFSOut() const { return DFSOut; }
264 void setDFSOut(unsigned O) { DFSOut = O; }
265 unsigned getDFSIn() const { return DFSIn; }
266 void setDFSIn(unsigned I) { DFSIn = I; }
267 bool dominates(const DbgScope *S) {
270 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
275 /// addScope - Add a scope to the scope.
277 void addScope(DbgScope *S) { Scopes.push_back(S); }
279 /// addVariable - Add a variable to the scope.
281 void addVariable(DbgVariable *V) { Variables.push_back(V); }
288 } // end llvm namespace
291 void DbgScope::dump() const {
292 raw_ostream &err = dbgs();
293 err.indent(IndentLevel);
294 const MDNode *N = Desc;
297 err << "Abstract Scope\n";
301 err << "Children ...\n";
302 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
303 if (Scopes[i] != this)
310 DbgScope::~DbgScope() {
311 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
315 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
316 : Asm(A), MMI(Asm->MMI), FirstCU(0),
317 AbbreviationsSet(InitAbbreviationsSetSize),
318 CurrentFnDbgScope(0), PrevLabel(NULL) {
319 NextStringPoolNumber = 0;
321 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
322 DwarfStrSectionSym = TextSectionSym = 0;
323 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
324 FunctionBeginSym = FunctionEndSym = 0;
325 if (TimePassesIsEnabled) {
326 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
332 DwarfDebug::~DwarfDebug() {
333 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
334 DIEBlocks[j]->~DIEBlock();
337 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
338 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
339 if (Entry.first) return Entry.first;
341 Entry.second = NextStringPoolNumber++;
342 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
346 /// assignAbbrevNumber - Define a unique number for the abbreviation.
348 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
349 // Profile the node so that we can make it unique.
353 // Check the set for priors.
354 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
356 // If it's newly added.
357 if (InSet == &Abbrev) {
358 // Add to abbreviation list.
359 Abbreviations.push_back(&Abbrev);
361 // Assign the vector position + 1 as its number.
362 Abbrev.setNumber(Abbreviations.size());
364 // Assign existing abbreviation number.
365 Abbrev.setNumber(InSet->getNumber());
369 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
370 /// information entry.
371 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
372 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
376 /// addUInt - Add an unsigned integer attribute data and value.
378 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
379 unsigned Form, uint64_t Integer) {
380 if (!Form) Form = DIEInteger::BestForm(false, Integer);
381 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
382 Die->addValue(Attribute, Form, Value);
385 /// addSInt - Add an signed integer attribute data and value.
387 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
388 unsigned Form, int64_t Integer) {
389 if (!Form) Form = DIEInteger::BestForm(true, Integer);
390 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
391 Die->addValue(Attribute, Form, Value);
394 /// addString - Add a string attribute data and value. DIEString only
395 /// keeps string reference.
396 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
398 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
399 Die->addValue(Attribute, Form, Value);
402 /// addLabel - Add a Dwarf label attribute data and value.
404 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
405 const MCSymbol *Label) {
406 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
407 Die->addValue(Attribute, Form, Value);
410 /// addDelta - Add a label delta attribute data and value.
412 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
413 const MCSymbol *Hi, const MCSymbol *Lo) {
414 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
415 Die->addValue(Attribute, Form, Value);
418 /// addDIEEntry - Add a DIE attribute data and value.
420 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
422 Die->addValue(Attribute, Form, createDIEEntry(Entry));
426 /// addBlock - Add block data.
428 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
430 Block->ComputeSize(Asm);
431 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
432 Die->addValue(Attribute, Block->BestForm(), Block);
435 /// addSourceLine - Add location information to specified debug information
437 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
442 unsigned Line = V->getLineNumber();
443 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
444 V->getContext().getFilename());
445 assert(FileID && "Invalid file id");
446 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
447 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
450 /// addSourceLine - Add location information to specified debug information
452 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
453 // Verify global variable.
457 unsigned Line = G->getLineNumber();
458 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
459 G->getContext().getFilename());
460 assert(FileID && "Invalid file id");
461 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
462 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
465 /// addSourceLine - Add location information to specified debug information
467 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
468 // Verify subprogram.
471 // If the line number is 0, don't add it.
472 if (SP->getLineNumber() == 0)
475 unsigned Line = SP->getLineNumber();
476 if (!SP->getContext().Verify())
478 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
480 assert(FileID && "Invalid file id");
481 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
482 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
485 /// addSourceLine - Add location information to specified debug information
487 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
492 unsigned Line = Ty->getLineNumber();
493 if (!Ty->getContext().Verify())
495 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
496 Ty->getContext().getFilename());
497 assert(FileID && "Invalid file id");
498 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
499 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
502 /// addSourceLine - Add location information to specified debug information
504 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
509 unsigned Line = NS->getLineNumber();
510 StringRef FN = NS->getFilename();
511 StringRef Dir = NS->getDirectory();
513 unsigned FileID = GetOrCreateSourceID(Dir, FN);
514 assert(FileID && "Invalid file id");
515 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
516 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
519 /* Byref variables, in Blocks, are declared by the programmer as
520 "SomeType VarName;", but the compiler creates a
521 __Block_byref_x_VarName struct, and gives the variable VarName
522 either the struct, or a pointer to the struct, as its type. This
523 is necessary for various behind-the-scenes things the compiler
524 needs to do with by-reference variables in blocks.
526 However, as far as the original *programmer* is concerned, the
527 variable should still have type 'SomeType', as originally declared.
529 The following function dives into the __Block_byref_x_VarName
530 struct to find the original type of the variable. This will be
531 passed back to the code generating the type for the Debug
532 Information Entry for the variable 'VarName'. 'VarName' will then
533 have the original type 'SomeType' in its debug information.
535 The original type 'SomeType' will be the type of the field named
536 'VarName' inside the __Block_byref_x_VarName struct.
538 NOTE: In order for this to not completely fail on the debugger
539 side, the Debug Information Entry for the variable VarName needs to
540 have a DW_AT_location that tells the debugger how to unwind through
541 the pointers and __Block_byref_x_VarName struct to find the actual
542 value of the variable. The function addBlockByrefType does this. */
544 /// Find the type the programmer originally declared the variable to be
545 /// and return that type.
547 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
550 unsigned tag = Ty.getTag();
552 if (tag == dwarf::DW_TAG_pointer_type) {
553 DIDerivedType DTy = DIDerivedType(Ty);
554 subType = DTy.getTypeDerivedFrom();
557 DICompositeType blockStruct = DICompositeType(subType);
558 DIArray Elements = blockStruct.getTypeArray();
560 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
561 DIDescriptor Element = Elements.getElement(i);
562 DIDerivedType DT = DIDerivedType(Element);
563 if (Name == DT.getName())
564 return (DT.getTypeDerivedFrom());
570 /// addComplexAddress - Start with the address based on the location provided,
571 /// and generate the DWARF information necessary to find the actual variable
572 /// given the extra address information encoded in the DIVariable, starting from
573 /// the starting location. Add the DWARF information to the die.
575 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
577 const MachineLocation &Location) {
578 const DIVariable &VD = DV->getVariable();
579 DIType Ty = VD.getType();
581 // Decode the original location, and use that as the start of the byref
582 // variable's location.
583 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
584 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
585 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
587 if (Location.isReg()) {
589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
591 Reg = Reg - dwarf::DW_OP_reg0;
592 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
593 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
599 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
600 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
603 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
606 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
607 uint64_t Element = VD.getAddrElement(i);
609 if (Element == DIFactory::OpPlus) {
610 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
611 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
612 } else if (Element == DIFactory::OpDeref) {
613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
614 } else llvm_unreachable("unknown DIFactory Opcode");
617 // Now attach the location information to the DIE.
618 addBlock(Die, Attribute, 0, Block);
621 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
622 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
623 gives the variable VarName either the struct, or a pointer to the struct, as
624 its type. This is necessary for various behind-the-scenes things the
625 compiler needs to do with by-reference variables in Blocks.
627 However, as far as the original *programmer* is concerned, the variable
628 should still have type 'SomeType', as originally declared.
630 The function getBlockByrefType dives into the __Block_byref_x_VarName
631 struct to find the original type of the variable, which is then assigned to
632 the variable's Debug Information Entry as its real type. So far, so good.
633 However now the debugger will expect the variable VarName to have the type
634 SomeType. So we need the location attribute for the variable to be an
635 expression that explains to the debugger how to navigate through the
636 pointers and struct to find the actual variable of type SomeType.
638 The following function does just that. We start by getting
639 the "normal" location for the variable. This will be the location
640 of either the struct __Block_byref_x_VarName or the pointer to the
641 struct __Block_byref_x_VarName.
643 The struct will look something like:
645 struct __Block_byref_x_VarName {
647 struct __Block_byref_x_VarName *forwarding;
648 ... <various other fields>
650 ... <maybe more fields>
653 If we are given the struct directly (as our starting point) we
654 need to tell the debugger to:
656 1). Add the offset of the forwarding field.
658 2). Follow that pointer to get the real __Block_byref_x_VarName
659 struct to use (the real one may have been copied onto the heap).
661 3). Add the offset for the field VarName, to find the actual variable.
663 If we started with a pointer to the struct, then we need to
664 dereference that pointer first, before the other steps.
665 Translating this into DWARF ops, we will need to append the following
666 to the current location description for the variable:
668 DW_OP_deref -- optional, if we start with a pointer
669 DW_OP_plus_uconst <forward_fld_offset>
671 DW_OP_plus_uconst <varName_fld_offset>
673 That is what this function does. */
675 /// addBlockByrefAddress - Start with the address based on the location
676 /// provided, and generate the DWARF information necessary to find the
677 /// actual Block variable (navigating the Block struct) based on the
678 /// starting location. Add the DWARF information to the die. For
679 /// more information, read large comment just above here.
681 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
683 const MachineLocation &Location) {
684 const DIVariable &VD = DV->getVariable();
685 DIType Ty = VD.getType();
687 unsigned Tag = Ty.getTag();
688 bool isPointer = false;
690 StringRef varName = VD.getName();
692 if (Tag == dwarf::DW_TAG_pointer_type) {
693 DIDerivedType DTy = DIDerivedType(Ty);
694 TmpTy = DTy.getTypeDerivedFrom();
698 DICompositeType blockStruct = DICompositeType(TmpTy);
700 // Find the __forwarding field and the variable field in the __Block_byref
702 DIArray Fields = blockStruct.getTypeArray();
703 DIDescriptor varField = DIDescriptor();
704 DIDescriptor forwardingField = DIDescriptor();
706 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
707 DIDescriptor Element = Fields.getElement(i);
708 DIDerivedType DT = DIDerivedType(Element);
709 StringRef fieldName = DT.getName();
710 if (fieldName == "__forwarding")
711 forwardingField = Element;
712 else if (fieldName == varName)
716 // Get the offsets for the forwarding field and the variable field.
717 unsigned forwardingFieldOffset =
718 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
719 unsigned varFieldOffset =
720 DIDerivedType(varField).getOffsetInBits() >> 3;
722 // Decode the original location, and use that as the start of the byref
723 // variable's location.
724 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
725 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
728 if (Location.isReg()) {
730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
732 Reg = Reg - dwarf::DW_OP_reg0;
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
741 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
744 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
747 // If we started with a pointer to the __Block_byref... struct, then
748 // the first thing we need to do is dereference the pointer (DW_OP_deref).
750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
752 // Next add the offset for the '__forwarding' field:
753 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
754 // adding the offset if it's 0.
755 if (forwardingFieldOffset > 0) {
756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
757 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
760 // Now dereference the __forwarding field to get to the real __Block_byref
761 // struct: DW_OP_deref.
762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
764 // Now that we've got the real __Block_byref... struct, add the offset
765 // for the variable's field to get to the location of the actual variable:
766 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
767 if (varFieldOffset > 0) {
768 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
769 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
772 // Now attach the location information to the DIE.
773 addBlock(Die, Attribute, 0, Block);
776 /// addAddress - Add an address attribute to a die based on the location
778 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
779 const MachineLocation &Location) {
780 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
781 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
784 if (Location.isReg()) {
786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
788 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
789 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
799 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
802 addBlock(Die, Attribute, 0, Block);
805 /// addRegisterAddress - Add register location entry in variable DIE.
806 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
807 const MachineOperand &MO) {
808 assert (MO.isReg() && "Invalid machine operand!");
811 MachineLocation Location;
812 Location.set(MO.getReg());
813 addAddress(Die, dwarf::DW_AT_location, Location);
815 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
819 /// addConstantValue - Add constant value entry in variable DIE.
820 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
821 const MachineOperand &MO) {
822 assert (MO.isImm() && "Invalid machine operand!");
823 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
824 unsigned Imm = MO.getImm();
825 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
826 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
828 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
832 /// addConstantFPValue - Add constant value entry in variable DIE.
833 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
834 const MachineOperand &MO) {
835 assert (MO.isFPImm() && "Invalid machine operand!");
836 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
837 APFloat FPImm = MO.getFPImm()->getValueAPF();
839 // Get the raw data form of the floating point.
840 const APInt FltVal = FPImm.bitcastToAPInt();
841 const char *FltPtr = (const char*)FltVal.getRawData();
843 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
844 bool LittleEndian = Asm->getTargetData().isLittleEndian();
845 int Incr = (LittleEndian ? 1 : -1);
846 int Start = (LittleEndian ? 0 : NumBytes - 1);
847 int Stop = (LittleEndian ? NumBytes : -1);
849 // Output the constant to DWARF one byte at a time.
850 for (; Start != Stop; Start += Incr)
851 addUInt(Block, 0, dwarf::DW_FORM_data1,
852 (unsigned char)0xFF & FltPtr[Start]);
854 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
861 /// addToContextOwner - Add Die into the list of its context owner's children.
862 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
863 if (Context.isType()) {
864 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
865 ContextDIE->addChild(Die);
866 } else if (Context.isNameSpace()) {
867 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
868 ContextDIE->addChild(Die);
869 } else if (Context.isSubprogram()) {
870 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
872 ContextDIE->addChild(Die);
873 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
874 ContextDIE->addChild(Die);
876 getCompileUnit(Context)->addDie(Die);
879 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
881 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
882 CompileUnit *TypeCU = getCompileUnit(Ty);
883 DIE *TyDIE = TypeCU->getDIE(Ty);
888 TyDIE = new DIE(dwarf::DW_TAG_base_type);
889 TypeCU->insertDIE(Ty, TyDIE);
890 if (Ty.isBasicType())
891 constructTypeDIE(*TyDIE, DIBasicType(Ty));
892 else if (Ty.isCompositeType())
893 constructTypeDIE(*TyDIE, DICompositeType(Ty));
895 assert(Ty.isDerivedType() && "Unknown kind of DIType");
896 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
899 addToContextOwner(TyDIE, Ty.getContext());
903 /// addType - Add a new type attribute to the specified entity.
904 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
908 // Check for pre-existence.
909 CompileUnit *TypeCU = getCompileUnit(Ty);
910 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
911 // If it exists then use the existing value.
913 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
918 DIE *Buffer = getOrCreateTypeDIE(Ty);
921 Entry = createDIEEntry(Buffer);
922 TypeCU->insertDIEEntry(Ty, Entry);
924 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
927 /// constructTypeDIE - Construct basic type die from DIBasicType.
928 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
929 // Get core information.
930 StringRef Name = BTy.getName();
931 Buffer.setTag(dwarf::DW_TAG_base_type);
932 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
935 // Add name if not anonymous or intermediate type.
937 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
938 uint64_t Size = BTy.getSizeInBits() >> 3;
939 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
942 /// constructTypeDIE - Construct derived type die from DIDerivedType.
943 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
944 // Get core information.
945 StringRef Name = DTy.getName();
946 uint64_t Size = DTy.getSizeInBits() >> 3;
947 unsigned Tag = DTy.getTag();
949 // FIXME - Workaround for templates.
950 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
954 // Map to main type, void will not have a type.
955 DIType FromTy = DTy.getTypeDerivedFrom();
956 addType(&Buffer, FromTy);
958 // Add name if not anonymous or intermediate type.
960 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
962 // Add size if non-zero (derived types might be zero-sized.)
964 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
966 // Add source line info if available and TyDesc is not a forward declaration.
967 if (!DTy.isForwardDecl())
968 addSourceLine(&Buffer, &DTy);
971 /// constructTypeDIE - Construct type DIE from DICompositeType.
972 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
973 // Get core information.
974 StringRef Name = CTy.getName();
976 uint64_t Size = CTy.getSizeInBits() >> 3;
977 unsigned Tag = CTy.getTag();
981 case dwarf::DW_TAG_vector_type:
982 case dwarf::DW_TAG_array_type:
983 constructArrayTypeDIE(Buffer, &CTy);
985 case dwarf::DW_TAG_enumeration_type: {
986 DIArray Elements = CTy.getTypeArray();
988 // Add enumerators to enumeration type.
989 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
991 DIDescriptor Enum(Elements.getElement(i));
992 if (Enum.isEnumerator()) {
993 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
994 Buffer.addChild(ElemDie);
999 case dwarf::DW_TAG_subroutine_type: {
1001 DIArray Elements = CTy.getTypeArray();
1002 DIDescriptor RTy = Elements.getElement(0);
1003 addType(&Buffer, DIType(RTy));
1005 // Add prototype flag.
1006 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1009 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1010 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1011 DIDescriptor Ty = Elements.getElement(i);
1012 addType(Arg, DIType(Ty));
1013 Buffer.addChild(Arg);
1017 case dwarf::DW_TAG_structure_type:
1018 case dwarf::DW_TAG_union_type:
1019 case dwarf::DW_TAG_class_type: {
1020 // Add elements to structure type.
1021 DIArray Elements = CTy.getTypeArray();
1023 // A forward struct declared type may not have elements available.
1024 unsigned N = Elements.getNumElements();
1028 // Add elements to structure type.
1029 for (unsigned i = 0; i < N; ++i) {
1030 DIDescriptor Element = Elements.getElement(i);
1031 DIE *ElemDie = NULL;
1032 if (Element.isSubprogram())
1033 ElemDie = createSubprogramDIE(DISubprogram(Element));
1034 else if (Element.isVariable()) {
1035 DIVariable DV(Element);
1036 ElemDie = new DIE(dwarf::DW_TAG_variable);
1037 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1039 addType(ElemDie, DV.getType());
1040 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1041 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1042 addSourceLine(ElemDie, &DV);
1043 } else if (Element.isDerivedType())
1044 ElemDie = createMemberDIE(DIDerivedType(Element));
1047 Buffer.addChild(ElemDie);
1050 if (CTy.isAppleBlockExtension())
1051 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1053 unsigned RLang = CTy.getRunTimeLang();
1055 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1056 dwarf::DW_FORM_data1, RLang);
1058 DICompositeType ContainingType = CTy.getContainingType();
1059 if (DIDescriptor(ContainingType).isCompositeType())
1060 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1061 getOrCreateTypeDIE(DIType(ContainingType)));
1063 DIDescriptor Context = CTy.getContext();
1064 addToContextOwner(&Buffer, Context);
1072 // Add name if not anonymous or intermediate type.
1074 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1076 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1077 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1078 // Add size if non-zero (derived types might be zero-sized.)
1080 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1082 // Add zero size if it is not a forward declaration.
1083 if (CTy.isForwardDecl())
1084 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1086 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1089 // Add source line info if available.
1090 if (!CTy.isForwardDecl())
1091 addSourceLine(&Buffer, &CTy);
1095 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1096 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1097 int64_t L = SR.getLo();
1098 int64_t H = SR.getHi();
1099 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1101 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1103 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1104 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1106 Buffer.addChild(DW_Subrange);
1109 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1110 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1111 DICompositeType *CTy) {
1112 Buffer.setTag(dwarf::DW_TAG_array_type);
1113 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1114 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1116 // Emit derived type.
1117 addType(&Buffer, CTy->getTypeDerivedFrom());
1118 DIArray Elements = CTy->getTypeArray();
1120 // Get an anonymous type for index type.
1121 CompileUnit *TheCU = getCompileUnit(*CTy);
1122 DIE *IdxTy = TheCU->getIndexTyDie();
1124 // Construct an anonymous type for index type.
1125 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1126 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1127 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1128 dwarf::DW_ATE_signed);
1129 TheCU->addDie(IdxTy);
1130 TheCU->setIndexTyDie(IdxTy);
1133 // Add subranges to array type.
1134 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1135 DIDescriptor Element = Elements.getElement(i);
1136 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1137 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1141 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1142 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1143 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1144 StringRef Name = ETy.getName();
1145 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1146 int64_t Value = ETy.getEnumValue();
1147 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1151 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1152 /// printer to not emit usual symbol prefix before the symbol name is used then
1153 /// return linkage name after skipping this special LLVM prefix.
1154 static StringRef getRealLinkageName(StringRef LinkageName) {
1156 if (LinkageName.startswith(StringRef(&One, 1)))
1157 return LinkageName.substr(1);
1161 /// createGlobalVariableDIE - Create new DIE using GV.
1162 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1163 // If the global variable was optmized out then no need to create debug info
1165 if (!GV.getGlobal()) return NULL;
1166 if (GV.getDisplayName().empty()) return NULL;
1168 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1169 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1170 GV.getDisplayName());
1172 StringRef LinkageName = GV.getLinkageName();
1173 if (!LinkageName.empty())
1174 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1175 getRealLinkageName(LinkageName));
1177 addType(GVDie, GV.getType());
1178 if (!GV.isLocalToUnit())
1179 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1180 addSourceLine(GVDie, &GV);
1185 /// createMemberDIE - Create new member DIE.
1186 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1187 DIE *MemberDie = new DIE(DT.getTag());
1188 StringRef Name = DT.getName();
1190 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1192 addType(MemberDie, DT.getTypeDerivedFrom());
1194 addSourceLine(MemberDie, &DT);
1196 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1197 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1199 uint64_t Size = DT.getSizeInBits();
1200 uint64_t FieldSize = DT.getOriginalTypeSize();
1202 if (Size != FieldSize) {
1204 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1205 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1207 uint64_t Offset = DT.getOffsetInBits();
1208 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1209 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1210 uint64_t FieldOffset = (HiMark - FieldSize);
1211 Offset -= FieldOffset;
1213 // Maybe we need to work from the other end.
1214 if (Asm->getTargetData().isLittleEndian())
1215 Offset = FieldSize - (Offset + Size);
1216 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1218 // Here WD_AT_data_member_location points to the anonymous
1219 // field that includes this bit field.
1220 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1223 // This is not a bitfield.
1224 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1226 if (DT.getTag() == dwarf::DW_TAG_inheritance
1227 && DT.isVirtual()) {
1229 // For C++, virtual base classes are not at fixed offset. Use following
1230 // expression to extract appropriate offset from vtable.
1231 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1233 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1234 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1242 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1245 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1247 if (DT.isProtected())
1248 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1249 dwarf::DW_ACCESS_protected);
1250 else if (DT.isPrivate())
1251 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1252 dwarf::DW_ACCESS_private);
1253 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1254 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1255 dwarf::DW_ACCESS_public);
1257 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1258 dwarf::DW_VIRTUALITY_virtual);
1262 /// createSubprogramDIE - Create new DIE using SP.
1263 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1264 CompileUnit *SPCU = getCompileUnit(SP);
1265 DIE *SPDie = SPCU->getDIE(SP);
1269 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1270 // Constructors and operators for anonymous aggregates do not have names.
1271 if (!SP.getName().empty())
1272 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1274 StringRef LinkageName = SP.getLinkageName();
1275 if (!LinkageName.empty())
1276 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1277 getRealLinkageName(LinkageName));
1279 addSourceLine(SPDie, &SP);
1281 // Add prototyped tag, if C or ObjC.
1282 unsigned Lang = SP.getCompileUnit().getLanguage();
1283 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1284 Lang == dwarf::DW_LANG_ObjC)
1285 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1288 DICompositeType SPTy = SP.getType();
1289 DIArray Args = SPTy.getTypeArray();
1290 unsigned SPTag = SPTy.getTag();
1292 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1293 addType(SPDie, SPTy);
1295 addType(SPDie, DIType(Args.getElement(0)));
1297 unsigned VK = SP.getVirtuality();
1299 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1300 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1301 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1302 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1303 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1304 ContainingTypeMap.insert(std::make_pair(SPDie,
1305 SP.getContainingType()));
1308 if (MakeDecl || !SP.isDefinition()) {
1309 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1311 // Add arguments. Do not add arguments for subprogram definition. They will
1312 // be handled while processing variables.
1313 DICompositeType SPTy = SP.getType();
1314 DIArray Args = SPTy.getTypeArray();
1315 unsigned SPTag = SPTy.getTag();
1317 if (SPTag == dwarf::DW_TAG_subroutine_type)
1318 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1319 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1320 DIType ATy = DIType(DIType(Args.getElement(i)));
1322 if (ATy.isArtificial())
1323 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1324 SPDie->addChild(Arg);
1328 if (SP.isArtificial())
1329 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1331 if (!SP.isLocalToUnit())
1332 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1334 if (SP.isOptimized())
1335 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1337 // DW_TAG_inlined_subroutine may refer to this DIE.
1338 SPCU->insertDIE(SP, SPDie);
1340 // Add to context owner.
1341 addToContextOwner(SPDie, SP.getContext());
1346 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1347 assert(N && "Invalid Scope encoding!");
1349 DbgScope *AScope = AbstractScopes.lookup(N);
1353 DbgScope *Parent = NULL;
1355 DIDescriptor Scope(N);
1356 if (Scope.isLexicalBlock()) {
1357 DILexicalBlock DB(N);
1358 DIDescriptor ParentDesc = DB.getContext();
1359 Parent = getOrCreateAbstractScope(ParentDesc);
1362 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1365 Parent->addScope(AScope);
1366 AScope->setAbstractScope();
1367 AbstractScopes[N] = AScope;
1368 if (DIDescriptor(N).isSubprogram())
1369 AbstractScopesList.push_back(AScope);
1373 /// isSubprogramContext - Return true if Context is either a subprogram
1374 /// or another context nested inside a subprogram.
1375 static bool isSubprogramContext(const MDNode *Context) {
1378 DIDescriptor D(Context);
1379 if (D.isSubprogram())
1382 return isSubprogramContext(DIType(Context).getContext());
1386 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1387 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1388 /// If there are global variables in this scope then create and insert
1389 /// DIEs for these variables.
1390 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1391 CompileUnit *SPCU = getCompileUnit(SPNode);
1392 DIE *SPDie = SPCU->getDIE(SPNode);
1393 assert(SPDie && "Unable to find subprogram DIE!");
1394 DISubprogram SP(SPNode);
1396 // There is not any need to generate specification DIE for a function
1397 // defined at compile unit level. If a function is defined inside another
1398 // function then gdb prefers the definition at top level and but does not
1399 // expect specification DIE in parent function. So avoid creating
1400 // specification DIE for a function defined inside a function.
1401 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1402 !SP.getContext().isFile() &&
1403 !isSubprogramContext(SP.getContext())) {
1404 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1407 DICompositeType SPTy = SP.getType();
1408 DIArray Args = SPTy.getTypeArray();
1409 unsigned SPTag = SPTy.getTag();
1410 if (SPTag == dwarf::DW_TAG_subroutine_type)
1411 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1412 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1413 DIType ATy = DIType(DIType(Args.getElement(i)));
1415 if (ATy.isArtificial())
1416 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1417 SPDie->addChild(Arg);
1419 DIE *SPDeclDie = SPDie;
1420 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1421 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1423 SPCU->addDie(SPDie);
1426 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1427 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1428 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1429 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1430 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1431 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1432 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1437 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1438 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1439 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1441 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1442 if (Scope->isAbstractScope())
1445 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1449 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1450 if (Ranges.size() > 1) {
1451 // .debug_range section has not been laid out yet. Emit offset in
1452 // .debug_range as a uint, size 4, for now. emitDIE will handle
1453 // DW_AT_ranges appropriately.
1454 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1455 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1456 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1457 RE = Ranges.end(); RI != RE; ++RI) {
1458 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1459 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1461 DebugRangeSymbols.push_back(NULL);
1462 DebugRangeSymbols.push_back(NULL);
1466 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1467 const MCSymbol *End = getLabelAfterInsn(RI->second);
1469 if (End == 0) return 0;
1471 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1472 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1474 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1475 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1480 /// constructInlinedScopeDIE - This scope represents inlined body of
1481 /// a function. Construct DIE to represent this concrete inlined copy
1482 /// of the function.
1483 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1485 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1486 assert (Ranges.empty() == false
1487 && "DbgScope does not have instruction markers!");
1489 // FIXME : .debug_inlined section specification does not clearly state how
1490 // to emit inlined scope that is split into multiple instruction ranges.
1491 // For now, use first instruction range and emit low_pc/high_pc pair and
1492 // corresponding .debug_inlined section entry for this pair.
1493 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1494 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1495 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1497 if (StartLabel == FunctionBeginSym || EndLabel == 0) {
1498 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1501 assert(StartLabel->isDefined() &&
1502 "Invalid starting label for an inlined scope!");
1503 assert(EndLabel->isDefined() &&
1504 "Invalid end label for an inlined scope!");
1506 if (!Scope->getScopeNode())
1508 DIScope DS(Scope->getScopeNode());
1509 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1511 DISubprogram InlinedSP = getDISubprogram(DS);
1512 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1513 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1514 assert(OriginDIE && "Unable to find Origin DIE!");
1515 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1516 dwarf::DW_FORM_ref4, OriginDIE);
1518 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1519 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1521 InlinedSubprogramDIEs.insert(OriginDIE);
1523 // Track the start label for this inlined function.
1524 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1525 I = InlineInfo.find(InlinedSP);
1527 if (I == InlineInfo.end()) {
1528 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1530 InlinedSPNodes.push_back(InlinedSP);
1532 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1534 DILocation DL(Scope->getInlinedAt());
1535 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1536 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1542 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1543 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1544 // Get the descriptor.
1545 const DIVariable &VD = DV->getVariable();
1546 StringRef Name = VD.getName();
1550 // Translate tag to proper Dwarf tag. The result variable is dropped for
1553 switch (VD.getTag()) {
1554 case dwarf::DW_TAG_return_variable:
1556 case dwarf::DW_TAG_arg_variable:
1557 Tag = dwarf::DW_TAG_formal_parameter;
1559 case dwarf::DW_TAG_auto_variable: // fall thru
1561 Tag = dwarf::DW_TAG_variable;
1565 // Define variable debug information entry.
1566 DIE *VariableDie = new DIE(Tag);
1569 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1570 V2AVI = VarToAbstractVarMap.find(DV);
1571 if (V2AVI != VarToAbstractVarMap.end())
1572 AbsDIE = V2AVI->second->getDIE();
1575 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1576 dwarf::DW_FORM_ref4, AbsDIE);
1578 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1579 addSourceLine(VariableDie, &VD);
1581 // Add variable type.
1582 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1583 // addresses instead.
1584 if (VD.isBlockByrefVariable())
1585 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1587 addType(VariableDie, VD.getType());
1590 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1591 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1593 if (Scope->isAbstractScope()) {
1594 DV->setDIE(VariableDie);
1598 // Add variable address.
1600 unsigned Offset = DV->getDotDebugLocOffset();
1601 if (Offset != ~0U) {
1602 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1603 Asm->GetTempSymbol("debug_loc", Offset));
1604 DV->setDIE(VariableDie);
1605 UseDotDebugLocEntry.insert(VariableDie);
1609 // Check if variable is described by a DBG_VALUE instruction.
1610 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1611 DbgVariableToDbgInstMap.find(DV);
1612 if (DVI != DbgVariableToDbgInstMap.end()) {
1613 const MachineInstr *DVInsn = DVI->second;
1614 const MCSymbol *DVLabel = findVariableLabel(DV);
1615 bool updated = false;
1616 // FIXME : Handle getNumOperands != 3
1617 if (DVInsn->getNumOperands() == 3) {
1618 if (DVInsn->getOperand(0).isReg())
1619 updated = 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())
1623 updated = addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1625 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1626 if (Location.getReg()) {
1627 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1629 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1635 // If variableDie is not updated then DBG_VALUE instruction does not
1636 // have valid variable info.
1640 DV->setDIE(VariableDie);
1644 // .. else use frame index, if available.
1645 MachineLocation Location;
1647 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1649 if (findVariableFrameIndex(DV, &FI)) {
1650 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1651 Location.set(FrameReg, Offset);
1653 if (VD.hasComplexAddress())
1654 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1655 else if (VD.isBlockByrefVariable())
1656 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1658 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1660 DV->setDIE(VariableDie);
1665 void DwarfDebug::addPubTypes(DISubprogram SP) {
1666 DICompositeType SPTy = SP.getType();
1667 unsigned SPTag = SPTy.getTag();
1668 if (SPTag != dwarf::DW_TAG_subroutine_type)
1671 DIArray Args = SPTy.getTypeArray();
1672 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1673 DIType ATy(Args.getElement(i));
1676 DICompositeType CATy = getDICompositeType(ATy);
1677 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1678 && !CATy.isForwardDecl()) {
1679 CompileUnit *TheCU = getCompileUnit(CATy);
1680 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1681 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1686 /// constructScopeDIE - Construct a DIE for this scope.
1687 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1688 if (!Scope || !Scope->getScopeNode())
1691 DIScope DS(Scope->getScopeNode());
1692 DIE *ScopeDIE = NULL;
1693 if (Scope->getInlinedAt())
1694 ScopeDIE = constructInlinedScopeDIE(Scope);
1695 else if (DS.isSubprogram()) {
1696 if (Scope->isAbstractScope())
1697 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1699 ScopeDIE = updateSubprogramScopeDIE(DS);
1702 ScopeDIE = constructLexicalScopeDIE(Scope);
1703 if (!ScopeDIE) return NULL;
1705 // Add variables to scope.
1706 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1707 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1708 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1710 ScopeDIE->addChild(VariableDIE);
1713 // Add nested scopes.
1714 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1715 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1716 // Define the Scope debug information entry.
1717 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1719 ScopeDIE->addChild(NestedDIE);
1722 if (DS.isSubprogram())
1723 addPubTypes(DISubprogram(DS));
1728 /// GetOrCreateSourceID - Look up the source id with the given directory and
1729 /// source file names. If none currently exists, create a new id and insert it
1730 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1732 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1734 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1735 if (DI != DirectoryIdMap.end()) {
1736 DId = DI->getValue();
1738 DId = DirectoryNames.size() + 1;
1739 DirectoryIdMap[DirName] = DId;
1740 DirectoryNames.push_back(DirName);
1744 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1745 if (FI != SourceFileIdMap.end()) {
1746 FId = FI->getValue();
1748 FId = SourceFileNames.size() + 1;
1749 SourceFileIdMap[FileName] = FId;
1750 SourceFileNames.push_back(FileName);
1753 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1754 SourceIdMap.find(std::make_pair(DId, FId));
1755 if (SI != SourceIdMap.end())
1758 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1759 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1760 SourceIds.push_back(std::make_pair(DId, FId));
1765 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1766 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1767 CompileUnit *TheCU = getCompileUnit(NS);
1768 DIE *NDie = TheCU->getDIE(NS);
1771 NDie = new DIE(dwarf::DW_TAG_namespace);
1772 TheCU->insertDIE(NS, NDie);
1773 if (!NS.getName().empty())
1774 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1775 addSourceLine(NDie, &NS);
1776 addToContextOwner(NDie, NS.getContext());
1780 /// constructCompileUnit - Create new CompileUnit for the given
1781 /// metadata node with tag DW_TAG_compile_unit.
1782 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1783 DICompileUnit DIUnit(N);
1784 StringRef FN = DIUnit.getFilename();
1785 StringRef Dir = DIUnit.getDirectory();
1786 unsigned ID = GetOrCreateSourceID(Dir, FN);
1788 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1789 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1790 DIUnit.getProducer());
1791 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1792 DIUnit.getLanguage());
1793 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1794 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1795 // simplifies debug range entries.
1796 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_data4, 0);
1797 // DW_AT_stmt_list is a offset of line number information for this
1798 // compile unit in debug_line section. It is always zero when only one
1799 // compile unit is emitted in one object file.
1800 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1803 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1804 if (DIUnit.isOptimized())
1805 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1807 StringRef Flags = DIUnit.getFlags();
1809 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1811 unsigned RVer = DIUnit.getRunTimeVersion();
1813 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1814 dwarf::DW_FORM_data1, RVer);
1816 CompileUnit *NewCU = new CompileUnit(ID, Die);
1819 CUMap.insert(std::make_pair(N, NewCU));
1822 /// getCompielUnit - Get CompileUnit DIE.
1823 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1824 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1826 const MDNode *CUNode = NULL;
1827 if (D.isCompileUnit())
1829 else if (D.isSubprogram())
1830 CUNode = DISubprogram(N).getCompileUnit();
1831 else if (D.isType())
1832 CUNode = DIType(N).getCompileUnit();
1833 else if (D.isGlobalVariable())
1834 CUNode = DIGlobalVariable(N).getCompileUnit();
1835 else if (D.isVariable())
1836 CUNode = DIVariable(N).getCompileUnit();
1837 else if (D.isNameSpace())
1838 CUNode = DINameSpace(N).getCompileUnit();
1839 else if (D.isFile())
1840 CUNode = DIFile(N).getCompileUnit();
1844 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1845 = CUMap.find(CUNode);
1846 if (I == CUMap.end())
1852 /// constructGlobalVariableDIE - Construct global variable DIE.
1853 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1854 DIGlobalVariable DI_GV(N);
1856 // If debug information is malformed then ignore it.
1857 if (DI_GV.Verify() == false)
1860 // Check for pre-existence.
1861 CompileUnit *TheCU = getCompileUnit(N);
1862 if (TheCU->getDIE(DI_GV))
1865 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1870 TheCU->insertDIE(N, VariableDie);
1872 // Add to context owner.
1873 DIDescriptor GVContext = DI_GV.getContext();
1874 // Do not create specification DIE if context is either compile unit
1876 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1877 !GVContext.isFile() &&
1878 !isSubprogramContext(GVContext)) {
1879 // Create specification DIE.
1880 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1881 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1882 dwarf::DW_FORM_ref4, VariableDie);
1883 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1884 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1885 addLabel(Block, 0, dwarf::DW_FORM_udata,
1886 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1887 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1888 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1889 TheCU->addDie(VariableSpecDIE);
1891 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1892 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1893 addLabel(Block, 0, dwarf::DW_FORM_udata,
1894 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1895 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1897 addToContextOwner(VariableDie, GVContext);
1899 // Expose as global. FIXME - need to check external flag.
1900 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1902 DIType GTy = DI_GV.getType();
1903 if (GTy.isCompositeType() && !GTy.getName().empty()
1904 && !GTy.isForwardDecl()) {
1905 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1906 assert(Entry && "Missing global type!");
1907 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1912 /// construct SubprogramDIE - Construct subprogram DIE.
1913 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1916 // Check for pre-existence.
1917 CompileUnit *TheCU = getCompileUnit(N);
1918 if (TheCU->getDIE(N))
1921 if (!SP.isDefinition())
1922 // This is a method declaration which will be handled while constructing
1926 DIE *SubprogramDie = createSubprogramDIE(SP);
1929 TheCU->insertDIE(N, SubprogramDie);
1931 // Add to context owner.
1932 addToContextOwner(SubprogramDie, SP.getContext());
1934 // Expose as global.
1935 TheCU->addGlobal(SP.getName(), SubprogramDie);
1940 /// beginModule - Emit all Dwarf sections that should come prior to the
1941 /// content. Create global DIEs and emit initial debug info sections.
1942 /// This is inovked by the target AsmPrinter.
1943 void DwarfDebug::beginModule(Module *M) {
1944 if (DisableDebugInfoPrinting)
1947 DebugInfoFinder DbgFinder;
1948 DbgFinder.processModule(*M);
1950 bool HasDebugInfo = false;
1952 // Scan all the compile-units to see if there are any marked as the main unit.
1953 // if not, we do not generate debug info.
1954 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1955 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1956 if (DICompileUnit(*I).isMain()) {
1957 HasDebugInfo = true;
1962 if (!HasDebugInfo) return;
1964 // Tell MMI that we have debug info.
1965 MMI->setDebugInfoAvailability(true);
1967 // Emit initial sections.
1968 EmitSectionLabels();
1970 // Create all the compile unit DIEs.
1971 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1972 E = DbgFinder.compile_unit_end(); I != E; ++I)
1973 constructCompileUnit(*I);
1975 // Create DIEs for each subprogram.
1976 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1977 E = DbgFinder.subprogram_end(); I != E; ++I)
1978 constructSubprogramDIE(*I);
1980 // Create DIEs for each global variable.
1981 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1982 E = DbgFinder.global_variable_end(); I != E; ++I)
1983 constructGlobalVariableDIE(*I);
1985 // Prime section data.
1986 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1988 // Print out .file directives to specify files for .loc directives. These are
1989 // printed out early so that they precede any .loc directives.
1990 if (Asm->MAI->hasDotLocAndDotFile()) {
1991 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1992 // Remember source id starts at 1.
1993 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1994 // FIXME: don't use sys::path for this! This should not depend on the
1996 sys::Path FullPath(getSourceDirectoryName(Id.first));
1998 FullPath.appendComponent(getSourceFileName(Id.second));
1999 assert(AppendOk && "Could not append filename to directory!");
2001 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2006 /// endModule - Emit all Dwarf sections that should come after the content.
2008 void DwarfDebug::endModule() {
2009 if (!FirstCU) return;
2011 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2012 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2013 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2015 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2018 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2019 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2020 DIE *SPDie = CI->first;
2021 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2023 DIE *NDie = getCompileUnit(N)->getDIE(N);
2024 if (!NDie) continue;
2025 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2028 // Standard sections final addresses.
2029 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2030 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2031 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2032 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2034 // End text sections.
2035 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2036 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2037 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2040 // Emit common frame information.
2041 emitCommonDebugFrame();
2043 // Emit function debug frame information
2044 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2045 E = DebugFrames.end(); I != E; ++I)
2046 emitFunctionDebugFrame(*I);
2048 // Compute DIE offsets and sizes.
2049 computeSizeAndOffsets();
2051 // Emit all the DIEs into a debug info section
2054 // Corresponding abbreviations into a abbrev section.
2055 emitAbbreviations();
2057 // Emit source line correspondence into a debug line section.
2060 // Emit info into a debug pubnames section.
2061 emitDebugPubNames();
2063 // Emit info into a debug pubtypes section.
2064 emitDebugPubTypes();
2066 // Emit info into a debug loc section.
2069 // Emit info into a debug aranges section.
2072 // Emit info into a debug ranges section.
2075 // Emit info into a debug macinfo section.
2078 // Emit inline info.
2079 emitDebugInlineInfo();
2081 // Emit info into a debug str section.
2084 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2085 E = CUMap.end(); I != E; ++I)
2087 FirstCU = NULL; // Reset for the next Module, if any.
2090 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2091 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2092 DebugLoc ScopeLoc) {
2094 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2096 return AbsDbgVariable;
2098 LLVMContext &Ctx = Var->getContext();
2099 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2103 AbsDbgVariable = new DbgVariable(Var);
2104 Scope->addVariable(AbsDbgVariable);
2105 AbstractVariables[Var] = AbsDbgVariable;
2106 return AbsDbgVariable;
2109 /// collectVariableInfoFromMMITable - Collect variable information from
2110 /// side table maintained by MMI.
2112 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2113 SmallPtrSet<const MDNode *, 16> &Processed) {
2114 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2115 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2116 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2117 VE = VMap.end(); VI != VE; ++VI) {
2118 const MDNode *Var = VI->first;
2120 Processed.insert(Var);
2122 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2124 DbgScope *Scope = 0;
2125 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2126 Scope = ConcreteScopes.lookup(IA);
2128 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2130 // If variable scope is not found then skip this variable.
2134 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2135 DbgVariable *RegVar = new DbgVariable(DV);
2136 recordVariableFrameIndex(RegVar, VP.first);
2137 Scope->addVariable(RegVar);
2138 if (AbsDbgVariable) {
2139 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2140 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2145 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2146 /// DBG_VALUE instruction, is in undefined reg.
2147 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2148 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2149 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2154 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2155 /// DBG_VALUE instruction, is in a defined reg.
2156 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2157 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2158 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2163 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2164 void DwarfDebug::collectVariableInfo(const MachineFunction *MF) {
2165 SmallPtrSet<const MDNode *, 16> Processed;
2167 /// collection info from MMI table.
2168 collectVariableInfoFromMMITable(MF, Processed);
2170 SmallVector<const MachineInstr *, 8> DbgValues;
2171 // Collect variable information from DBG_VALUE machine instructions;
2172 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2174 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2176 const MachineInstr *MInsn = II;
2177 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2179 DbgValues.push_back(MInsn);
2182 // This is a collection of DBV_VALUE instructions describing same variable.
2183 SmallVector<const MachineInstr *, 4> MultipleValues;
2184 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2185 E = DbgValues.end(); I != E; ++I) {
2186 const MachineInstr *MInsn = *I;
2187 MultipleValues.clear();
2188 if (isDbgValueInDefinedReg(MInsn))
2189 MultipleValues.push_back(MInsn);
2190 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2191 if (Processed.count(DV) != 0)
2194 const MachineInstr *PrevMI = MInsn;
2195 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2196 ME = DbgValues.end(); MI != ME; ++MI) {
2198 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2199 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2200 !PrevMI->isIdenticalTo(*MI))
2201 MultipleValues.push_back(*MI);
2205 DbgScope *Scope = findDbgScope(MInsn);
2206 bool CurFnArg = false;
2207 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2208 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2210 if (!Scope && CurFnArg)
2211 Scope = CurrentFnDbgScope;
2212 // If variable scope is not found then skip this variable.
2216 Processed.insert(DV);
2217 DbgVariable *RegVar = new DbgVariable(DV);
2218 Scope->addVariable(RegVar);
2220 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2221 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2222 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2223 VarToAbstractVarMap[RegVar] = AbsVar;
2225 if (MultipleValues.size() <= 1) {
2226 DbgVariableToDbgInstMap[RegVar] = MInsn;
2230 // handle multiple DBG_VALUE instructions describing one variable.
2231 if (DotDebugLocEntries.empty())
2232 RegVar->setDotDebugLocOffset(0);
2234 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2235 const MachineInstr *Begin = NULL;
2236 const MachineInstr *End = NULL;
2237 for (SmallVector<const MachineInstr *, 4>::iterator
2238 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); MVI != MVE; ++MVI) {
2244 MachineLocation MLoc;
2245 MLoc.set(Begin->getOperand(0).getReg(), 0);
2246 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2247 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2248 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2250 if (MVI + 1 == MVE) {
2251 // If End is the last instruction then its value is valid
2252 // until the end of the funtion.
2253 MLoc.set(End->getOperand(0).getReg(), 0);
2255 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2258 DotDebugLocEntries.push_back(DotDebugLocEntry());
2261 // Collect info for variables that were optimized out.
2262 if (NamedMDNode *NMD =
2263 MF->getFunction()->getParent()->getNamedMetadata("llvm.dbg.lv")) {
2264 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2265 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2266 if (!DV || !Processed.insert(DV))
2268 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2270 Scope->addVariable(new DbgVariable(DV));
2275 /// getLabelBeforeInsn - Return Label preceding the instruction.
2276 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2277 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2278 LabelsBeforeInsn.find(MI);
2279 if (I == LabelsBeforeInsn.end())
2280 // FunctionBeginSym always preceeds all the instruction in current function.
2281 return FunctionBeginSym;
2285 /// getLabelAfterInsn - Return Label immediately following the instruction.
2286 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2287 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2288 LabelsAfterInsn.find(MI);
2289 if (I == LabelsAfterInsn.end())
2294 /// beginScope - Process beginning of a scope.
2295 void DwarfDebug::beginScope(const MachineInstr *MI) {
2296 if (InsnNeedsLabel.count(MI) == 0) {
2297 LabelsBeforeInsn[MI] = PrevLabel;
2302 DebugLoc DL = MI->getDebugLoc();
2303 if (!DL.isUnknown()) {
2304 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2305 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2307 LabelsBeforeInsn[MI] = PrevLabel;
2311 // If location is unknown then use temp label for this DBG_VALUE
2313 if (MI->isDebugValue()) {
2314 PrevLabel = MMI->getContext().CreateTempSymbol();
2315 Asm->OutStreamer.EmitLabel(PrevLabel);
2316 LabelsBeforeInsn[MI] = PrevLabel;
2320 if (UnknownLocations) {
2321 PrevLabel = recordSourceLine(0, 0, 0);
2322 LabelsBeforeInsn[MI] = PrevLabel;
2326 assert (0 && "Instruction is not processed!");
2329 /// endScope - Process end of a scope.
2330 void DwarfDebug::endScope(const MachineInstr *MI) {
2331 if (InsnsEndScopeSet.count(MI) != 0) {
2332 // Emit a label if this instruction ends a scope.
2333 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2334 Asm->OutStreamer.EmitLabel(Label);
2335 LabelsAfterInsn[MI] = Label;
2339 /// getOrCreateDbgScope - Create DbgScope for the scope.
2340 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2342 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2345 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2346 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2347 if (DIDescriptor(Scope).isLexicalBlock()) {
2349 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2350 WScope->setParent(Parent);
2351 Parent->addScope(WScope);
2354 if (!WScope->getParent()) {
2355 StringRef SPName = DISubprogram(Scope).getLinkageName();
2356 if (SPName == Asm->MF->getFunction()->getName() ||
2357 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2358 CurrentFnDbgScope = WScope;
2364 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2368 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2369 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2370 DILocation DL(InlinedAt);
2372 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2373 WScope->setParent(Parent);
2374 Parent->addScope(WScope);
2376 ConcreteScopes[InlinedAt] = WScope;
2377 getOrCreateAbstractScope(Scope);
2382 /// hasValidLocation - Return true if debug location entry attached with
2383 /// machine instruction encodes valid location info.
2384 static bool hasValidLocation(LLVMContext &Ctx,
2385 const MachineInstr *MInsn,
2386 const MDNode *&Scope, const MDNode *&InlinedAt) {
2387 if (MInsn->isDebugValue())
2389 DebugLoc DL = MInsn->getDebugLoc();
2390 if (DL.isUnknown()) return false;
2392 const MDNode *S = DL.getScope(Ctx);
2394 // There is no need to create another DIE for compile unit. For all
2395 // other scopes, create one DbgScope now. This will be translated
2396 // into a scope DIE at the end.
2397 if (DIScope(S).isCompileUnit()) return false;
2400 InlinedAt = DL.getInlinedAt(Ctx);
2404 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2406 static void calculateDominanceGraph(DbgScope *Scope) {
2407 assert (Scope && "Unable to calculate scop edominance graph!");
2408 SmallVector<DbgScope *, 4> WorkStack;
2409 WorkStack.push_back(Scope);
2410 unsigned Counter = 0;
2411 while (!WorkStack.empty()) {
2412 DbgScope *WS = WorkStack.back();
2413 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2414 bool visitedChildren = false;
2415 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2416 SE = Children.end(); SI != SE; ++SI) {
2417 DbgScope *ChildScope = *SI;
2418 if (!ChildScope->getDFSOut()) {
2419 WorkStack.push_back(ChildScope);
2420 visitedChildren = true;
2421 ChildScope->setDFSIn(++Counter);
2425 if (!visitedChildren) {
2426 WorkStack.pop_back();
2427 WS->setDFSOut(++Counter);
2432 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2434 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2435 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2438 unsigned PrevDFSIn = 0;
2439 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2441 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2443 const MachineInstr *MInsn = II;
2444 const MDNode *Scope = NULL;
2445 const MDNode *InlinedAt = NULL;
2447 // Check if instruction has valid location information.
2448 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2452 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2453 MI2ScopeMap.find(MInsn);
2454 if (DI != MI2ScopeMap.end()) {
2455 DbgScope *S = DI->second;
2456 dbgs() << S->getDFSIn();
2457 PrevDFSIn = S->getDFSIn();
2459 dbgs() << PrevDFSIn;
2461 dbgs() << " [ x" << PrevDFSIn;
2469 /// extractScopeInformation - Scan machine instructions in this function
2470 /// and collect DbgScopes. Return true, if at least one scope was found.
2471 bool DwarfDebug::extractScopeInformation() {
2472 // If scope information was extracted using .dbg intrinsics then there is not
2473 // any need to extract these information by scanning each instruction.
2474 if (!DbgScopeMap.empty())
2477 // Scan each instruction and create scopes. First build working set of scopes.
2478 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2479 SmallVector<DbgRange, 4> MIRanges;
2480 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2481 const MDNode *PrevScope = NULL;
2482 const MDNode *PrevInlinedAt = NULL;
2483 const MachineInstr *RangeBeginMI = NULL;
2484 const MachineInstr *PrevMI = NULL;
2485 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2487 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2489 const MachineInstr *MInsn = II;
2490 const MDNode *Scope = NULL;
2491 const MDNode *InlinedAt = NULL;
2493 // Check if instruction has valid location information.
2494 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2499 // If scope has not changed then skip this instruction.
2500 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2506 // If we have alread seen a beginning of a instruction range and
2507 // current instruction scope does not match scope of first instruction
2508 // in this range then create a new instruction range.
2509 DbgRange R(RangeBeginMI, PrevMI);
2510 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2511 MIRanges.push_back(R);
2514 // This is a beginning of a new instruction range.
2515 RangeBeginMI = MInsn;
2517 // Reset previous markers.
2520 PrevInlinedAt = InlinedAt;
2524 // Create last instruction range.
2525 if (RangeBeginMI && PrevMI && PrevScope) {
2526 DbgRange R(RangeBeginMI, PrevMI);
2527 MIRanges.push_back(R);
2528 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2531 if (!CurrentFnDbgScope)
2534 calculateDominanceGraph(CurrentFnDbgScope);
2536 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2538 // Find ranges of instructions covered by each DbgScope;
2539 DbgScope *PrevDbgScope = NULL;
2540 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2541 RE = MIRanges.end(); RI != RE; ++RI) {
2542 const DbgRange &R = *RI;
2543 DbgScope *S = MI2ScopeMap.lookup(R.first);
2544 assert (S && "Lost DbgScope for a machine instruction!");
2545 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2546 PrevDbgScope->closeInsnRange(S);
2547 S->openInsnRange(R.first);
2548 S->extendInsnRange(R.second);
2553 PrevDbgScope->closeInsnRange();
2555 identifyScopeMarkers();
2557 return !DbgScopeMap.empty();
2560 /// identifyScopeMarkers() -
2561 /// Each DbgScope has first instruction and last instruction to mark beginning
2562 /// and end of a scope respectively. Create an inverse map that list scopes
2563 /// starts (and ends) with an instruction. One instruction may start (or end)
2564 /// multiple scopes. Ignore scopes that are not reachable.
2565 void DwarfDebug::identifyScopeMarkers() {
2566 SmallVector<DbgScope *, 4> WorkList;
2567 WorkList.push_back(CurrentFnDbgScope);
2568 while (!WorkList.empty()) {
2569 DbgScope *S = WorkList.pop_back_val();
2571 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2572 if (!Children.empty())
2573 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2574 SE = Children.end(); SI != SE; ++SI)
2575 WorkList.push_back(*SI);
2577 if (S->isAbstractScope())
2580 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2583 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2584 RE = Ranges.end(); RI != RE; ++RI) {
2585 assert(RI->first && "DbgRange does not have first instruction!");
2586 assert(RI->second && "DbgRange does not have second instruction!");
2587 InsnsBeginScopeSet.insert(RI->first);
2588 InsnsEndScopeSet.insert(RI->second);
2593 /// FindFirstDebugLoc - Find the first debug location in the function. This
2594 /// is intended to be an approximation for the source position of the
2595 /// beginning of the function.
2596 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2597 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2599 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2600 MBBI != MBBE; ++MBBI) {
2601 DebugLoc DL = MBBI->getDebugLoc();
2602 if (!DL.isUnknown())
2608 /// beginFunction - Gather pre-function debug information. Assumes being
2609 /// emitted immediately after the function entry point.
2610 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2611 if (!MMI->hasDebugInfo()) return;
2612 if (!extractScopeInformation()) return;
2614 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2615 Asm->getFunctionNumber());
2616 // Assumes in correct section after the entry point.
2617 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2619 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2621 DebugLoc FDL = FindFirstDebugLoc(MF);
2622 if (FDL.isUnknown()) return;
2624 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2626 DISubprogram SP = getDISubprogram(Scope);
2629 Line = SP.getLineNumber();
2632 Line = FDL.getLine();
2636 recordSourceLine(Line, Col, Scope);
2638 /// ProcessedArgs - Collection of arguments already processed.
2639 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2642 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2644 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2646 const MachineInstr *MI = II;
2647 DebugLoc DL = MI->getDebugLoc();
2648 if (MI->isDebugValue()) {
2649 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2650 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2651 if (!DV.Verify()) continue;
2652 if (isDbgValueInUndefinedReg(MI)) continue;
2653 // If DBG_VALUE is for a local variable then it needs a label.
2654 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2655 InsnNeedsLabel.insert(MI);
2656 // DBG_VALUE for inlined functions argument needs a label.
2657 else if (!DISubprogram(DV.getContext()).describes(MF->getFunction()))
2658 InsnNeedsLabel.insert(MI);
2659 // DBG_VALUE indicating argument location change needs a label.
2660 else if (!ProcessedArgs.insert(DV))
2661 InsnNeedsLabel.insert(MI);
2663 // If location is unknown then instruction needs a location only if
2664 // UnknownLocations flag is set.
2665 if (DL.isUnknown()) {
2666 if (UnknownLocations && !PrevLoc.isUnknown())
2667 InsnNeedsLabel.insert(MI);
2668 } else if (DL != PrevLoc)
2669 // Otherwise, instruction needs a location only if it is new location.
2670 InsnNeedsLabel.insert(MI);
2673 if (!DL.isUnknown() || UnknownLocations)
2677 PrevLabel = FunctionBeginSym;
2680 /// endFunction - Gather and emit post-function debug information.
2682 void DwarfDebug::endFunction(const MachineFunction *MF) {
2683 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2685 if (CurrentFnDbgScope) {
2687 // Define end label for subprogram.
2688 FunctionEndSym = Asm->GetTempSymbol("func_end",
2689 Asm->getFunctionNumber());
2690 // Assumes in correct section after the entry point.
2691 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2693 collectVariableInfo(MF);
2695 // Get function line info.
2696 if (!Lines.empty()) {
2697 // Get section line info.
2698 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2699 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2700 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2701 // Append the function info to section info.
2702 SectionLineInfos.insert(SectionLineInfos.end(),
2703 Lines.begin(), Lines.end());
2706 // Construct abstract scopes.
2707 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2708 AE = AbstractScopesList.end(); AI != AE; ++AI)
2709 constructScopeDIE(*AI);
2711 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2713 if (!DisableFramePointerElim(*MF))
2714 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2715 dwarf::DW_FORM_flag, 1);
2718 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2719 MMI->getFrameMoves()));
2723 CurrentFnDbgScope = NULL;
2724 InsnNeedsLabel.clear();
2725 DbgVariableToFrameIndexMap.clear();
2726 VarToAbstractVarMap.clear();
2727 DbgVariableToDbgInstMap.clear();
2728 DbgVariableLabelsMap.clear();
2729 DeleteContainerSeconds(DbgScopeMap);
2730 InsnsBeginScopeSet.clear();
2731 InsnsEndScopeSet.clear();
2732 ConcreteScopes.clear();
2733 DeleteContainerSeconds(AbstractScopes);
2734 AbstractScopesList.clear();
2735 AbstractVariables.clear();
2736 LabelsBeforeInsn.clear();
2737 LabelsAfterInsn.clear();
2742 /// recordVariableFrameIndex - Record a variable's index.
2743 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2744 assert (V && "Invalid DbgVariable!");
2745 DbgVariableToFrameIndexMap[V] = Index;
2748 /// findVariableFrameIndex - Return true if frame index for the variable
2749 /// is found. Update FI to hold value of the index.
2750 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2751 assert (V && "Invalid DbgVariable!");
2752 DenseMap<const DbgVariable *, int>::iterator I =
2753 DbgVariableToFrameIndexMap.find(V);
2754 if (I == DbgVariableToFrameIndexMap.end())
2760 /// findVariableLabel - Find MCSymbol for the variable.
2761 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2762 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2763 = DbgVariableLabelsMap.find(V);
2764 if (I == DbgVariableLabelsMap.end())
2766 else return I->second;
2769 /// findDbgScope - Find DbgScope for the debug loc attached with an
2771 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2772 DbgScope *Scope = NULL;
2774 MInsn->getParent()->getParent()->getFunction()->getContext();
2775 DebugLoc DL = MInsn->getDebugLoc();
2780 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2781 Scope = ConcreteScopes.lookup(IA);
2783 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2789 /// recordSourceLine - Register a source line with debug info. Returns the
2790 /// unique label that was emitted and which provides correspondence to
2791 /// the source line list.
2792 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2798 DIDescriptor Scope(S);
2800 if (Scope.isCompileUnit()) {
2801 DICompileUnit CU(S);
2802 Dir = CU.getDirectory();
2803 Fn = CU.getFilename();
2804 } else if (Scope.isSubprogram()) {
2806 Dir = SP.getDirectory();
2807 Fn = SP.getFilename();
2808 } else if (Scope.isLexicalBlock()) {
2809 DILexicalBlock DB(S);
2810 Dir = DB.getDirectory();
2811 Fn = DB.getFilename();
2813 assert(0 && "Unexpected scope info");
2815 Src = GetOrCreateSourceID(Dir, Fn);
2819 if (!Lines.empty()) {
2820 SrcLineInfo lastSrcLineInfo = Lines.back();
2821 // Emitting sequential line records with the same line number (but
2822 // different addresses) seems to confuse GDB. Avoid this.
2823 if (lastSrcLineInfo.getLine() == Line)
2828 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2829 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2831 Asm->OutStreamer.EmitLabel(Label);
2835 //===----------------------------------------------------------------------===//
2837 //===----------------------------------------------------------------------===//
2839 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2842 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2843 // Get the children.
2844 const std::vector<DIE *> &Children = Die->getChildren();
2846 // If not last sibling and has children then add sibling offset attribute.
2847 if (!Last && !Children.empty())
2848 Die->addSiblingOffset(DIEValueAllocator);
2850 // Record the abbreviation.
2851 assignAbbrevNumber(Die->getAbbrev());
2853 // Get the abbreviation for this DIE.
2854 unsigned AbbrevNumber = Die->getAbbrevNumber();
2855 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2858 Die->setOffset(Offset);
2860 // Start the size with the size of abbreviation code.
2861 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2863 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2864 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2866 // Size the DIE attribute values.
2867 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2868 // Size attribute value.
2869 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2871 // Size the DIE children if any.
2872 if (!Children.empty()) {
2873 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2874 "Children flag not set");
2876 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2877 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2879 // End of children marker.
2880 Offset += sizeof(int8_t);
2883 Die->setSize(Offset - Die->getOffset());
2887 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2889 void DwarfDebug::computeSizeAndOffsets() {
2890 unsigned PrevOffset = 0;
2891 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2892 E = CUMap.end(); I != E; ++I) {
2893 // Compute size of compile unit header.
2894 static unsigned Offset = PrevOffset +
2895 sizeof(int32_t) + // Length of Compilation Unit Info
2896 sizeof(int16_t) + // DWARF version number
2897 sizeof(int32_t) + // Offset Into Abbrev. Section
2898 sizeof(int8_t); // Pointer Size (in bytes)
2899 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2900 PrevOffset = Offset;
2904 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2905 /// temporary label to it if SymbolStem is specified.
2906 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2907 const char *SymbolStem = 0) {
2908 Asm->OutStreamer.SwitchSection(Section);
2909 if (!SymbolStem) return 0;
2911 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2912 Asm->OutStreamer.EmitLabel(TmpSym);
2916 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2917 /// the start of each one.
2918 void DwarfDebug::EmitSectionLabels() {
2919 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2921 // Dwarf sections base addresses.
2922 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2923 DwarfFrameSectionSym =
2924 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2927 DwarfInfoSectionSym =
2928 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2929 DwarfAbbrevSectionSym =
2930 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2931 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2933 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2934 EmitSectionSym(Asm, MacroInfo);
2936 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2937 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2938 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2939 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2940 DwarfStrSectionSym =
2941 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2942 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2945 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2946 "section_debug_loc");
2948 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2949 EmitSectionSym(Asm, TLOF.getDataSection());
2952 /// emitDIE - Recusively Emits a debug information entry.
2954 void DwarfDebug::emitDIE(DIE *Die) {
2955 // Get the abbreviation for this DIE.
2956 unsigned AbbrevNumber = Die->getAbbrevNumber();
2957 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2959 // Emit the code (index) for the abbreviation.
2960 if (Asm->isVerbose())
2961 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2962 Twine::utohexstr(Die->getOffset()) + ":0x" +
2963 Twine::utohexstr(Die->getSize()) + " " +
2964 dwarf::TagString(Abbrev->getTag()));
2965 Asm->EmitULEB128(AbbrevNumber);
2967 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2968 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2970 // Emit the DIE attribute values.
2971 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2972 unsigned Attr = AbbrevData[i].getAttribute();
2973 unsigned Form = AbbrevData[i].getForm();
2974 assert(Form && "Too many attributes for DIE (check abbreviation)");
2976 if (Asm->isVerbose())
2977 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2980 case dwarf::DW_AT_sibling:
2981 Asm->EmitInt32(Die->getSiblingOffset());
2983 case dwarf::DW_AT_abstract_origin: {
2984 DIEEntry *E = cast<DIEEntry>(Values[i]);
2985 DIE *Origin = E->getEntry();
2986 unsigned Addr = Origin->getOffset();
2987 Asm->EmitInt32(Addr);
2990 case dwarf::DW_AT_ranges: {
2991 // DW_AT_range Value encodes offset in debug_range section.
2992 DIEInteger *V = cast<DIEInteger>(Values[i]);
2993 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2995 DwarfDebugRangeSectionSym,
2999 case dwarf::DW_AT_location: {
3000 if (UseDotDebugLocEntry.count(Die) != 0) {
3001 DIELabel *L = cast<DIELabel>(Values[i]);
3002 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3004 Values[i]->EmitValue(Asm, Form);
3008 // Emit an attribute using the defined form.
3009 Values[i]->EmitValue(Asm, Form);
3014 // Emit the DIE children if any.
3015 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3016 const std::vector<DIE *> &Children = Die->getChildren();
3018 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3019 emitDIE(Children[j]);
3021 if (Asm->isVerbose())
3022 Asm->OutStreamer.AddComment("End Of Children Mark");
3027 /// emitDebugInfo - Emit the debug info section.
3029 void DwarfDebug::emitDebugInfo() {
3030 // Start debug info section.
3031 Asm->OutStreamer.SwitchSection(
3032 Asm->getObjFileLowering().getDwarfInfoSection());
3033 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3034 E = CUMap.end(); I != E; ++I) {
3035 CompileUnit *TheCU = I->second;
3036 DIE *Die = TheCU->getCUDie();
3038 // Emit the compile units header.
3039 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3042 // Emit size of content not including length itself
3043 unsigned ContentSize = Die->getSize() +
3044 sizeof(int16_t) + // DWARF version number
3045 sizeof(int32_t) + // Offset Into Abbrev. Section
3046 sizeof(int8_t) + // Pointer Size (in bytes)
3047 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3049 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3050 Asm->EmitInt32(ContentSize);
3051 Asm->OutStreamer.AddComment("DWARF version number");
3052 Asm->EmitInt16(dwarf::DWARF_VERSION);
3053 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3054 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3055 DwarfAbbrevSectionSym);
3056 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3057 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3060 // FIXME - extra padding for gdb bug.
3061 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3066 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3070 /// emitAbbreviations - Emit the abbreviation section.
3072 void DwarfDebug::emitAbbreviations() const {
3073 // Check to see if it is worth the effort.
3074 if (!Abbreviations.empty()) {
3075 // Start the debug abbrev section.
3076 Asm->OutStreamer.SwitchSection(
3077 Asm->getObjFileLowering().getDwarfAbbrevSection());
3079 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3081 // For each abbrevation.
3082 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3083 // Get abbreviation data
3084 const DIEAbbrev *Abbrev = Abbreviations[i];
3086 // Emit the abbrevations code (base 1 index.)
3087 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3089 // Emit the abbreviations data.
3093 // Mark end of abbreviations.
3094 Asm->EmitULEB128(0, "EOM(3)");
3096 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3100 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3101 /// the line matrix.
3103 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3104 // Define last address of section.
3105 Asm->OutStreamer.AddComment("Extended Op");
3108 Asm->OutStreamer.AddComment("Op size");
3109 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3110 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3111 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3113 Asm->OutStreamer.AddComment("Section end label");
3115 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3116 Asm->getTargetData().getPointerSize(),
3119 // Mark end of matrix.
3120 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3126 /// emitDebugLines - Emit source line information.
3128 void DwarfDebug::emitDebugLines() {
3129 // If the target is using .loc/.file, the assembler will be emitting the
3130 // .debug_line table automatically.
3131 if (Asm->MAI->hasDotLocAndDotFile())
3134 // Minimum line delta, thus ranging from -10..(255-10).
3135 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3136 // Maximum line delta, thus ranging from -10..(255-10).
3137 const int MaxLineDelta = 255 + MinLineDelta;
3139 // Start the dwarf line section.
3140 Asm->OutStreamer.SwitchSection(
3141 Asm->getObjFileLowering().getDwarfLineSection());
3143 // Construct the section header.
3144 Asm->OutStreamer.AddComment("Length of Source Line Info");
3145 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3146 Asm->GetTempSymbol("line_begin"), 4);
3147 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3149 Asm->OutStreamer.AddComment("DWARF version number");
3150 Asm->EmitInt16(dwarf::DWARF_VERSION);
3152 Asm->OutStreamer.AddComment("Prolog Length");
3153 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3154 Asm->GetTempSymbol("line_prolog_begin"), 4);
3155 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3157 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3159 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3161 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3162 Asm->EmitInt8(MinLineDelta);
3163 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3164 Asm->EmitInt8(MaxLineDelta);
3165 Asm->OutStreamer.AddComment("Special Opcode Base");
3166 Asm->EmitInt8(-MinLineDelta);
3168 // Line number standard opcode encodings argument count
3169 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3171 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3173 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3175 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3177 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3179 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3181 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3183 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3185 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3188 // Emit directories.
3189 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3190 const std::string &Dir = getSourceDirectoryName(DI);
3191 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3192 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3195 Asm->OutStreamer.AddComment("End of directories");
3199 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3200 // Remember source id starts at 1.
3201 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3202 const std::string &FN = getSourceFileName(Id.second);
3203 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3204 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3206 Asm->EmitULEB128(Id.first, "Directory #");
3207 Asm->EmitULEB128(0, "Mod date");
3208 Asm->EmitULEB128(0, "File size");
3211 Asm->OutStreamer.AddComment("End of files");
3214 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3216 // A sequence for each text section.
3217 unsigned SecSrcLinesSize = SectionSourceLines.size();
3219 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3220 // Isolate current sections line info.
3221 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3223 // Dwarf assumes we start with first line of first source file.
3224 unsigned Source = 1;
3227 // Construct rows of the address, source, line, column matrix.
3228 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3229 const SrcLineInfo &LineInfo = LineInfos[i];
3230 MCSymbol *Label = LineInfo.getLabel();
3231 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3233 if (Asm->isVerbose()) {
3234 std::pair<unsigned, unsigned> SrcID =
3235 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3236 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3238 Twine(getSourceFileName(SrcID.second)) +
3239 ":" + Twine(LineInfo.getLine()));
3242 // Define the line address.
3243 Asm->OutStreamer.AddComment("Extended Op");
3245 Asm->OutStreamer.AddComment("Op size");
3246 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3248 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3249 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3251 Asm->OutStreamer.AddComment("Location label");
3252 Asm->OutStreamer.EmitSymbolValue(Label,
3253 Asm->getTargetData().getPointerSize(),
3256 // If change of source, then switch to the new source.
3257 if (Source != LineInfo.getSourceID()) {
3258 Source = LineInfo.getSourceID();
3259 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3260 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3261 Asm->EmitULEB128(Source, "New Source");
3264 // If change of line.
3265 if (Line != LineInfo.getLine()) {
3266 // Determine offset.
3267 int Offset = LineInfo.getLine() - Line;
3268 int Delta = Offset - MinLineDelta;
3271 Line = LineInfo.getLine();
3273 // If delta is small enough and in range...
3274 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3275 // ... then use fast opcode.
3276 Asm->OutStreamer.AddComment("Line Delta");
3277 Asm->EmitInt8(Delta - MinLineDelta);
3279 // ... otherwise use long hand.
3280 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3281 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3282 Asm->EmitSLEB128(Offset, "Line Offset");
3283 Asm->OutStreamer.AddComment("DW_LNS_copy");
3284 Asm->EmitInt8(dwarf::DW_LNS_copy);
3287 // Copy the previous row (different address or source)
3288 Asm->OutStreamer.AddComment("DW_LNS_copy");
3289 Asm->EmitInt8(dwarf::DW_LNS_copy);
3293 emitEndOfLineMatrix(j + 1);
3296 if (SecSrcLinesSize == 0)
3297 // Because we're emitting a debug_line section, we still need a line
3298 // table. The linker and friends expect it to exist. If there's nothing to
3299 // put into it, emit an empty table.
3300 emitEndOfLineMatrix(1);
3302 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3305 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3307 void DwarfDebug::emitCommonDebugFrame() {
3308 if (!Asm->MAI->doesDwarfRequireFrameSection())
3311 int stackGrowth = Asm->getTargetData().getPointerSize();
3312 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3313 TargetFrameInfo::StackGrowsDown)
3316 // Start the dwarf frame section.
3317 Asm->OutStreamer.SwitchSection(
3318 Asm->getObjFileLowering().getDwarfFrameSection());
3320 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3321 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3322 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3323 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3325 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3326 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3327 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3328 Asm->OutStreamer.AddComment("CIE Version");
3329 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3330 Asm->OutStreamer.AddComment("CIE Augmentation");
3331 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3332 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3333 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3334 Asm->OutStreamer.AddComment("CIE RA Column");
3335 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3336 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3338 std::vector<MachineMove> Moves;
3339 RI->getInitialFrameState(Moves);
3341 Asm->EmitFrameMoves(Moves, 0, false);
3343 Asm->EmitAlignment(2);
3344 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3347 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3350 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3351 if (!Asm->MAI->doesDwarfRequireFrameSection())
3354 // Start the dwarf frame section.
3355 Asm->OutStreamer.SwitchSection(
3356 Asm->getObjFileLowering().getDwarfFrameSection());
3358 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3359 MCSymbol *DebugFrameBegin =
3360 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3361 MCSymbol *DebugFrameEnd =
3362 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3363 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3365 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3367 Asm->OutStreamer.AddComment("FDE CIE offset");
3368 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3369 DwarfFrameSectionSym);
3371 Asm->OutStreamer.AddComment("FDE initial location");
3372 MCSymbol *FuncBeginSym =
3373 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3374 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3375 Asm->getTargetData().getPointerSize(),
3379 Asm->OutStreamer.AddComment("FDE address range");
3380 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3381 FuncBeginSym, Asm->getTargetData().getPointerSize());
3383 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3385 Asm->EmitAlignment(2);
3386 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3389 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3391 void DwarfDebug::emitDebugPubNames() {
3392 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3393 E = CUMap.end(); I != E; ++I) {
3394 CompileUnit *TheCU = I->second;
3395 // Start the dwarf pubnames section.
3396 Asm->OutStreamer.SwitchSection(
3397 Asm->getObjFileLowering().getDwarfPubNamesSection());
3399 Asm->OutStreamer.AddComment("Length of Public Names Info");
3400 Asm->EmitLabelDifference(
3401 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3402 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3404 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3407 Asm->OutStreamer.AddComment("DWARF Version");
3408 Asm->EmitInt16(dwarf::DWARF_VERSION);
3410 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3411 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3412 DwarfInfoSectionSym);
3414 Asm->OutStreamer.AddComment("Compilation Unit Length");
3415 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3416 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3419 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3420 for (StringMap<DIE*>::const_iterator
3421 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3422 const char *Name = GI->getKeyData();
3423 DIE *Entity = GI->second;
3425 Asm->OutStreamer.AddComment("DIE offset");
3426 Asm->EmitInt32(Entity->getOffset());
3428 if (Asm->isVerbose())
3429 Asm->OutStreamer.AddComment("External Name");
3430 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3433 Asm->OutStreamer.AddComment("End Mark");
3435 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3440 void DwarfDebug::emitDebugPubTypes() {
3441 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3442 E = CUMap.end(); I != E; ++I) {
3443 CompileUnit *TheCU = I->second;
3444 // Start the dwarf pubnames section.
3445 Asm->OutStreamer.SwitchSection(
3446 Asm->getObjFileLowering().getDwarfPubTypesSection());
3447 Asm->OutStreamer.AddComment("Length of Public Types Info");
3448 Asm->EmitLabelDifference(
3449 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3450 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3452 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3455 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3456 Asm->EmitInt16(dwarf::DWARF_VERSION);
3458 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3459 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3460 DwarfInfoSectionSym);
3462 Asm->OutStreamer.AddComment("Compilation Unit Length");
3463 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3464 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3467 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3468 for (StringMap<DIE*>::const_iterator
3469 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3470 const char *Name = GI->getKeyData();
3471 DIE * Entity = GI->second;
3473 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3474 Asm->EmitInt32(Entity->getOffset());
3476 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3477 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3480 Asm->OutStreamer.AddComment("End Mark");
3482 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3487 /// emitDebugStr - Emit visible names into a debug str section.
3489 void DwarfDebug::emitDebugStr() {
3490 // Check to see if it is worth the effort.
3491 if (StringPool.empty()) return;
3493 // Start the dwarf str section.
3494 Asm->OutStreamer.SwitchSection(
3495 Asm->getObjFileLowering().getDwarfStrSection());
3497 // Get all of the string pool entries and put them in an array by their ID so
3498 // we can sort them.
3499 SmallVector<std::pair<unsigned,
3500 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3502 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3503 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3504 Entries.push_back(std::make_pair(I->second.second, &*I));
3506 array_pod_sort(Entries.begin(), Entries.end());
3508 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3509 // Emit a label for reference from debug information entries.
3510 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3512 // Emit the string itself.
3513 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3517 /// emitDebugLoc - Emit visible names into a debug loc section.
3519 void DwarfDebug::emitDebugLoc() {
3520 if (DotDebugLocEntries.empty())
3523 // Start the dwarf loc section.
3524 Asm->OutStreamer.SwitchSection(
3525 Asm->getObjFileLowering().getDwarfLocSection());
3526 unsigned char Size = Asm->getTargetData().getPointerSize();
3527 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3529 for (SmallVector<DotDebugLocEntry, 4>::iterator I = DotDebugLocEntries.begin(),
3530 E = DotDebugLocEntries.end(); I != E; ++I, ++index) {
3531 DotDebugLocEntry Entry = *I;
3532 if (Entry.isEmpty()) {
3533 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3534 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3535 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3537 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3538 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3539 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3540 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3542 Asm->OutStreamer.AddComment("Loc expr size");
3544 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3546 Asm->OutStreamer.AddComment("Loc expr size");
3547 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3548 Asm->EmitInt8(dwarf::DW_OP_regx);
3549 Asm->EmitULEB128(Reg);
3555 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3557 void DwarfDebug::EmitDebugARanges() {
3558 // Start the dwarf aranges section.
3559 Asm->OutStreamer.SwitchSection(
3560 Asm->getObjFileLowering().getDwarfARangesSection());
3563 /// emitDebugRanges - Emit visible names into a debug ranges section.
3565 void DwarfDebug::emitDebugRanges() {
3566 // Start the dwarf ranges section.
3567 Asm->OutStreamer.SwitchSection(
3568 Asm->getObjFileLowering().getDwarfRangesSection());
3569 unsigned char Size = Asm->getTargetData().getPointerSize();
3570 for (SmallVector<const MCSymbol *, 8>::iterator
3571 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3574 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3576 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3580 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3582 void DwarfDebug::emitDebugMacInfo() {
3583 if (const MCSection *LineInfo =
3584 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3585 // Start the dwarf macinfo section.
3586 Asm->OutStreamer.SwitchSection(LineInfo);
3590 /// emitDebugInlineInfo - Emit inline info using following format.
3592 /// 1. length of section
3593 /// 2. Dwarf version number
3594 /// 3. address size.
3596 /// Entries (one "entry" for each function that was inlined):
3598 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3599 /// otherwise offset into __debug_str for regular function name.
3600 /// 2. offset into __debug_str section for regular function name.
3601 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3602 /// instances for the function.
3604 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3605 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3606 /// __debug_info section, and the low_pc is the starting address for the
3607 /// inlining instance.
3608 void DwarfDebug::emitDebugInlineInfo() {
3609 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3615 Asm->OutStreamer.SwitchSection(
3616 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3618 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3619 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3620 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3622 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3624 Asm->OutStreamer.AddComment("Dwarf Version");
3625 Asm->EmitInt16(dwarf::DWARF_VERSION);
3626 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3627 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3629 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3630 E = InlinedSPNodes.end(); I != E; ++I) {
3632 const MDNode *Node = *I;
3633 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3634 = InlineInfo.find(Node);
3635 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3636 DISubprogram SP(Node);
3637 StringRef LName = SP.getLinkageName();
3638 StringRef Name = SP.getName();
3640 Asm->OutStreamer.AddComment("MIPS linkage name");
3641 if (LName.empty()) {
3642 Asm->OutStreamer.EmitBytes(Name, 0);
3643 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3645 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3646 DwarfStrSectionSym);
3648 Asm->OutStreamer.AddComment("Function name");
3649 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3650 Asm->EmitULEB128(Labels.size(), "Inline count");
3652 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3653 LE = Labels.end(); LI != LE; ++LI) {
3654 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3655 Asm->EmitInt32(LI->second->getOffset());
3657 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3658 Asm->OutStreamer.EmitSymbolValue(LI->first,
3659 Asm->getTargetData().getPointerSize(),0);
3663 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));