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 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
325 FunctionBeginSym = FunctionEndSym = 0;
327 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
331 DwarfDebug::~DwarfDebug() {
332 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
333 DIEBlocks[j]->~DIEBlock();
336 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
337 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
338 if (Entry.first) return Entry.first;
340 Entry.second = NextStringPoolNumber++;
341 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
345 /// assignAbbrevNumber - Define a unique number for the abbreviation.
347 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
348 // Profile the node so that we can make it unique.
352 // Check the set for priors.
353 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
355 // If it's newly added.
356 if (InSet == &Abbrev) {
357 // Add to abbreviation list.
358 Abbreviations.push_back(&Abbrev);
360 // Assign the vector position + 1 as its number.
361 Abbrev.setNumber(Abbreviations.size());
363 // Assign existing abbreviation number.
364 Abbrev.setNumber(InSet->getNumber());
368 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
369 /// information entry.
370 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
371 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
375 /// addUInt - Add an unsigned integer attribute data and value.
377 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
378 unsigned Form, uint64_t Integer) {
379 if (!Form) Form = DIEInteger::BestForm(false, Integer);
380 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
381 Die->addValue(Attribute, Form, Value);
384 /// addSInt - Add an signed integer attribute data and value.
386 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
387 unsigned Form, int64_t Integer) {
388 if (!Form) Form = DIEInteger::BestForm(true, Integer);
389 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
390 Die->addValue(Attribute, Form, Value);
393 /// addString - Add a string attribute data and value. DIEString only
394 /// keeps string reference.
395 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
397 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
398 Die->addValue(Attribute, Form, Value);
401 /// addLabel - Add a Dwarf label attribute data and value.
403 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
404 const MCSymbol *Label) {
405 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
406 Die->addValue(Attribute, Form, Value);
409 /// addDelta - Add a label delta attribute data and value.
411 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
412 const MCSymbol *Hi, const MCSymbol *Lo) {
413 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
414 Die->addValue(Attribute, Form, Value);
417 /// addDIEEntry - Add a DIE attribute data and value.
419 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
421 Die->addValue(Attribute, Form, createDIEEntry(Entry));
425 /// addBlock - Add block data.
427 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
429 Block->ComputeSize(Asm);
430 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
431 Die->addValue(Attribute, Block->BestForm(), Block);
434 /// addSourceLine - Add location information to specified debug information
436 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
441 unsigned Line = V->getLineNumber();
442 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
443 V->getContext().getFilename());
444 assert(FileID && "Invalid file id");
445 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
446 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
449 /// addSourceLine - Add location information to specified debug information
451 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
452 // Verify global variable.
456 unsigned Line = G->getLineNumber();
457 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
458 G->getContext().getFilename());
459 assert(FileID && "Invalid file id");
460 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
461 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
464 /// addSourceLine - Add location information to specified debug information
466 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
467 // Verify subprogram.
470 // If the line number is 0, don't add it.
471 if (SP->getLineNumber() == 0)
474 unsigned Line = SP->getLineNumber();
475 if (!SP->getContext().Verify())
477 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
479 assert(FileID && "Invalid file id");
480 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
481 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
484 /// addSourceLine - Add location information to specified debug information
486 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
491 unsigned Line = Ty->getLineNumber();
492 if (!Ty->getContext().Verify())
494 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
495 Ty->getContext().getFilename());
496 assert(FileID && "Invalid file id");
497 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
498 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
501 /// addSourceLine - Add location information to specified debug information
503 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
508 unsigned Line = NS->getLineNumber();
509 StringRef FN = NS->getFilename();
510 StringRef Dir = NS->getDirectory();
512 unsigned FileID = GetOrCreateSourceID(Dir, FN);
513 assert(FileID && "Invalid file id");
514 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
515 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
518 /* Byref variables, in Blocks, are declared by the programmer as
519 "SomeType VarName;", but the compiler creates a
520 __Block_byref_x_VarName struct, and gives the variable VarName
521 either the struct, or a pointer to the struct, as its type. This
522 is necessary for various behind-the-scenes things the compiler
523 needs to do with by-reference variables in blocks.
525 However, as far as the original *programmer* is concerned, the
526 variable should still have type 'SomeType', as originally declared.
528 The following function dives into the __Block_byref_x_VarName
529 struct to find the original type of the variable. This will be
530 passed back to the code generating the type for the Debug
531 Information Entry for the variable 'VarName'. 'VarName' will then
532 have the original type 'SomeType' in its debug information.
534 The original type 'SomeType' will be the type of the field named
535 'VarName' inside the __Block_byref_x_VarName struct.
537 NOTE: In order for this to not completely fail on the debugger
538 side, the Debug Information Entry for the variable VarName needs to
539 have a DW_AT_location that tells the debugger how to unwind through
540 the pointers and __Block_byref_x_VarName struct to find the actual
541 value of the variable. The function addBlockByrefType does this. */
543 /// Find the type the programmer originally declared the variable to be
544 /// and return that type.
546 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
549 unsigned tag = Ty.getTag();
551 if (tag == dwarf::DW_TAG_pointer_type) {
552 DIDerivedType DTy = DIDerivedType(Ty);
553 subType = DTy.getTypeDerivedFrom();
556 DICompositeType blockStruct = DICompositeType(subType);
557 DIArray Elements = blockStruct.getTypeArray();
559 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
560 DIDescriptor Element = Elements.getElement(i);
561 DIDerivedType DT = DIDerivedType(Element);
562 if (Name == DT.getName())
563 return (DT.getTypeDerivedFrom());
569 /// addComplexAddress - Start with the address based on the location provided,
570 /// and generate the DWARF information necessary to find the actual variable
571 /// given the extra address information encoded in the DIVariable, starting from
572 /// the starting location. Add the DWARF information to the die.
574 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
576 const MachineLocation &Location) {
577 const DIVariable &VD = DV->getVariable();
578 DIType Ty = VD.getType();
580 // Decode the original location, and use that as the start of the byref
581 // variable's location.
582 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
583 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
584 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
586 if (Location.isReg()) {
588 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
590 Reg = Reg - dwarf::DW_OP_reg0;
591 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
592 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
596 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
598 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
599 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
602 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
605 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
606 uint64_t Element = VD.getAddrElement(i);
608 if (Element == DIFactory::OpPlus) {
609 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
610 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
611 } else if (Element == DIFactory::OpDeref) {
612 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
613 } else llvm_unreachable("unknown DIFactory Opcode");
616 // Now attach the location information to the DIE.
617 addBlock(Die, Attribute, 0, Block);
620 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
621 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
622 gives the variable VarName either the struct, or a pointer to the struct, as
623 its type. This is necessary for various behind-the-scenes things the
624 compiler needs to do with by-reference variables in Blocks.
626 However, as far as the original *programmer* is concerned, the variable
627 should still have type 'SomeType', as originally declared.
629 The function getBlockByrefType dives into the __Block_byref_x_VarName
630 struct to find the original type of the variable, which is then assigned to
631 the variable's Debug Information Entry as its real type. So far, so good.
632 However now the debugger will expect the variable VarName to have the type
633 SomeType. So we need the location attribute for the variable to be an
634 expression that explains to the debugger how to navigate through the
635 pointers and struct to find the actual variable of type SomeType.
637 The following function does just that. We start by getting
638 the "normal" location for the variable. This will be the location
639 of either the struct __Block_byref_x_VarName or the pointer to the
640 struct __Block_byref_x_VarName.
642 The struct will look something like:
644 struct __Block_byref_x_VarName {
646 struct __Block_byref_x_VarName *forwarding;
647 ... <various other fields>
649 ... <maybe more fields>
652 If we are given the struct directly (as our starting point) we
653 need to tell the debugger to:
655 1). Add the offset of the forwarding field.
657 2). Follow that pointer to get the real __Block_byref_x_VarName
658 struct to use (the real one may have been copied onto the heap).
660 3). Add the offset for the field VarName, to find the actual variable.
662 If we started with a pointer to the struct, then we need to
663 dereference that pointer first, before the other steps.
664 Translating this into DWARF ops, we will need to append the following
665 to the current location description for the variable:
667 DW_OP_deref -- optional, if we start with a pointer
668 DW_OP_plus_uconst <forward_fld_offset>
670 DW_OP_plus_uconst <varName_fld_offset>
672 That is what this function does. */
674 /// addBlockByrefAddress - Start with the address based on the location
675 /// provided, and generate the DWARF information necessary to find the
676 /// actual Block variable (navigating the Block struct) based on the
677 /// starting location. Add the DWARF information to the die. For
678 /// more information, read large comment just above here.
680 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
682 const MachineLocation &Location) {
683 const DIVariable &VD = DV->getVariable();
684 DIType Ty = VD.getType();
686 unsigned Tag = Ty.getTag();
687 bool isPointer = false;
689 StringRef varName = VD.getName();
691 if (Tag == dwarf::DW_TAG_pointer_type) {
692 DIDerivedType DTy = DIDerivedType(Ty);
693 TmpTy = DTy.getTypeDerivedFrom();
697 DICompositeType blockStruct = DICompositeType(TmpTy);
699 // Find the __forwarding field and the variable field in the __Block_byref
701 DIArray Fields = blockStruct.getTypeArray();
702 DIDescriptor varField = DIDescriptor();
703 DIDescriptor forwardingField = DIDescriptor();
705 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
706 DIDescriptor Element = Fields.getElement(i);
707 DIDerivedType DT = DIDerivedType(Element);
708 StringRef fieldName = DT.getName();
709 if (fieldName == "__forwarding")
710 forwardingField = Element;
711 else if (fieldName == varName)
715 // Get the offsets for the forwarding field and the variable field.
716 unsigned forwardingFieldOffset =
717 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
718 unsigned varFieldOffset =
719 DIDerivedType(varField).getOffsetInBits() >> 3;
721 // Decode the original location, and use that as the start of the byref
722 // variable's location.
723 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
724 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
725 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
727 if (Location.isReg()) {
729 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
731 Reg = Reg - dwarf::DW_OP_reg0;
732 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
733 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
737 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
740 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
743 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
746 // If we started with a pointer to the __Block_byref... struct, then
747 // the first thing we need to do is dereference the pointer (DW_OP_deref).
749 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
751 // Next add the offset for the '__forwarding' field:
752 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
753 // adding the offset if it's 0.
754 if (forwardingFieldOffset > 0) {
755 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
756 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
759 // Now dereference the __forwarding field to get to the real __Block_byref
760 // struct: DW_OP_deref.
761 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
763 // Now that we've got the real __Block_byref... struct, add the offset
764 // for the variable's field to get to the location of the actual variable:
765 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
766 if (varFieldOffset > 0) {
767 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
768 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
771 // Now attach the location information to the DIE.
772 addBlock(Die, Attribute, 0, Block);
775 /// addAddress - Add an address attribute to a die based on the location
777 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
778 const MachineLocation &Location) {
779 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
780 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
781 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
783 if (Location.isReg()) {
785 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
788 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
792 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
794 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
795 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
798 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
801 addBlock(Die, Attribute, 0, Block);
804 /// addRegisterAddress - Add register location entry in variable DIE.
805 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
806 const MachineOperand &MO) {
807 assert (MO.isReg() && "Invalid machine operand!");
810 MachineLocation Location;
811 Location.set(MO.getReg());
812 addAddress(Die, dwarf::DW_AT_location, Location);
814 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
818 /// addConstantValue - Add constant value entry in variable DIE.
819 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
820 const MachineOperand &MO) {
821 assert (MO.isImm() && "Invalid machine operand!");
822 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
823 unsigned Imm = MO.getImm();
824 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
825 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
827 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
831 /// addConstantFPValue - Add constant value entry in variable DIE.
832 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
833 const MachineOperand &MO) {
834 assert (MO.isFPImm() && "Invalid machine operand!");
835 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
836 APFloat FPImm = MO.getFPImm()->getValueAPF();
838 // Get the raw data form of the floating point.
839 const APInt FltVal = FPImm.bitcastToAPInt();
840 const char *FltPtr = (const char*)FltVal.getRawData();
842 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
843 bool LittleEndian = Asm->getTargetData().isLittleEndian();
844 int Incr = (LittleEndian ? 1 : -1);
845 int Start = (LittleEndian ? 0 : NumBytes - 1);
846 int Stop = (LittleEndian ? NumBytes : -1);
848 // Output the constant to DWARF one byte at a time.
849 for (; Start != Stop; Start += Incr)
850 addUInt(Block, 0, dwarf::DW_FORM_data1,
851 (unsigned char)0xFF & FltPtr[Start]);
853 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
855 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
860 /// addToContextOwner - Add Die into the list of its context owner's children.
861 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
862 if (Context.isType()) {
863 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
864 ContextDIE->addChild(Die);
865 } else if (Context.isNameSpace()) {
866 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
867 ContextDIE->addChild(Die);
868 } else if (Context.isSubprogram()) {
869 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
871 ContextDIE->addChild(Die);
872 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
873 ContextDIE->addChild(Die);
875 getCompileUnit(Context)->addDie(Die);
878 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
880 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
881 CompileUnit *TypeCU = getCompileUnit(Ty);
882 DIE *TyDIE = TypeCU->getDIE(Ty);
887 TyDIE = new DIE(dwarf::DW_TAG_base_type);
888 TypeCU->insertDIE(Ty, TyDIE);
889 if (Ty.isBasicType())
890 constructTypeDIE(*TyDIE, DIBasicType(Ty));
891 else if (Ty.isCompositeType())
892 constructTypeDIE(*TyDIE, DICompositeType(Ty));
894 assert(Ty.isDerivedType() && "Unknown kind of DIType");
895 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
898 addToContextOwner(TyDIE, Ty.getContext());
902 /// addType - Add a new type attribute to the specified entity.
903 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
907 // Check for pre-existence.
908 CompileUnit *TypeCU = getCompileUnit(Ty);
909 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
910 // If it exists then use the existing value.
912 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
917 DIE *Buffer = getOrCreateTypeDIE(Ty);
920 Entry = createDIEEntry(Buffer);
921 TypeCU->insertDIEEntry(Ty, Entry);
923 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
926 /// constructTypeDIE - Construct basic type die from DIBasicType.
927 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
928 // Get core information.
929 StringRef Name = BTy.getName();
930 Buffer.setTag(dwarf::DW_TAG_base_type);
931 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
934 // Add name if not anonymous or intermediate type.
936 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
937 uint64_t Size = BTy.getSizeInBits() >> 3;
938 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
941 /// constructTypeDIE - Construct derived type die from DIDerivedType.
942 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
943 // Get core information.
944 StringRef Name = DTy.getName();
945 uint64_t Size = DTy.getSizeInBits() >> 3;
946 unsigned Tag = DTy.getTag();
948 // FIXME - Workaround for templates.
949 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
953 // Map to main type, void will not have a type.
954 DIType FromTy = DTy.getTypeDerivedFrom();
955 addType(&Buffer, FromTy);
957 // Add name if not anonymous or intermediate type.
959 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
961 // Add size if non-zero (derived types might be zero-sized.)
963 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
965 // Add source line info if available and TyDesc is not a forward declaration.
966 if (!DTy.isForwardDecl())
967 addSourceLine(&Buffer, &DTy);
970 /// constructTypeDIE - Construct type DIE from DICompositeType.
971 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
972 // Get core information.
973 StringRef Name = CTy.getName();
975 uint64_t Size = CTy.getSizeInBits() >> 3;
976 unsigned Tag = CTy.getTag();
980 case dwarf::DW_TAG_vector_type:
981 case dwarf::DW_TAG_array_type:
982 constructArrayTypeDIE(Buffer, &CTy);
984 case dwarf::DW_TAG_enumeration_type: {
985 DIArray Elements = CTy.getTypeArray();
987 // Add enumerators to enumeration type.
988 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
990 DIDescriptor Enum(Elements.getElement(i));
991 if (Enum.isEnumerator()) {
992 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
993 Buffer.addChild(ElemDie);
998 case dwarf::DW_TAG_subroutine_type: {
1000 DIArray Elements = CTy.getTypeArray();
1001 DIDescriptor RTy = Elements.getElement(0);
1002 addType(&Buffer, DIType(RTy));
1004 // Add prototype flag.
1005 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1008 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1009 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1010 DIDescriptor Ty = Elements.getElement(i);
1011 addType(Arg, DIType(Ty));
1012 Buffer.addChild(Arg);
1016 case dwarf::DW_TAG_structure_type:
1017 case dwarf::DW_TAG_union_type:
1018 case dwarf::DW_TAG_class_type: {
1019 // Add elements to structure type.
1020 DIArray Elements = CTy.getTypeArray();
1022 // A forward struct declared type may not have elements available.
1023 unsigned N = Elements.getNumElements();
1027 // Add elements to structure type.
1028 for (unsigned i = 0; i < N; ++i) {
1029 DIDescriptor Element = Elements.getElement(i);
1030 DIE *ElemDie = NULL;
1031 if (Element.isSubprogram())
1032 ElemDie = createSubprogramDIE(DISubprogram(Element));
1033 else if (Element.isVariable()) {
1034 DIVariable DV(Element);
1035 ElemDie = new DIE(dwarf::DW_TAG_variable);
1036 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1038 addType(ElemDie, DV.getType());
1039 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1040 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1041 addSourceLine(ElemDie, &DV);
1042 } else if (Element.isDerivedType())
1043 ElemDie = createMemberDIE(DIDerivedType(Element));
1046 Buffer.addChild(ElemDie);
1049 if (CTy.isAppleBlockExtension())
1050 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1052 unsigned RLang = CTy.getRunTimeLang();
1054 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1055 dwarf::DW_FORM_data1, RLang);
1057 DICompositeType ContainingType = CTy.getContainingType();
1058 if (DIDescriptor(ContainingType).isCompositeType())
1059 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1060 getOrCreateTypeDIE(DIType(ContainingType)));
1062 DIDescriptor Context = CTy.getContext();
1063 addToContextOwner(&Buffer, Context);
1071 // Add name if not anonymous or intermediate type.
1073 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1075 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1076 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1077 // Add size if non-zero (derived types might be zero-sized.)
1079 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1081 // Add zero size if it is not a forward declaration.
1082 if (CTy.isForwardDecl())
1083 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1085 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1088 // Add source line info if available.
1089 if (!CTy.isForwardDecl())
1090 addSourceLine(&Buffer, &CTy);
1094 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1095 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1096 int64_t L = SR.getLo();
1097 int64_t H = SR.getHi();
1098 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1100 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1102 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1103 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1105 Buffer.addChild(DW_Subrange);
1108 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1109 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1110 DICompositeType *CTy) {
1111 Buffer.setTag(dwarf::DW_TAG_array_type);
1112 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1113 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1115 // Emit derived type.
1116 addType(&Buffer, CTy->getTypeDerivedFrom());
1117 DIArray Elements = CTy->getTypeArray();
1119 // Get an anonymous type for index type.
1120 CompileUnit *TheCU = getCompileUnit(*CTy);
1121 DIE *IdxTy = TheCU->getIndexTyDie();
1123 // Construct an anonymous type for index type.
1124 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1125 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1126 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1127 dwarf::DW_ATE_signed);
1128 TheCU->addDie(IdxTy);
1129 TheCU->setIndexTyDie(IdxTy);
1132 // Add subranges to array type.
1133 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1134 DIDescriptor Element = Elements.getElement(i);
1135 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1136 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1140 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1141 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1142 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1143 StringRef Name = ETy.getName();
1144 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1145 int64_t Value = ETy.getEnumValue();
1146 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1150 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1151 /// printer to not emit usual symbol prefix before the symbol name is used then
1152 /// return linkage name after skipping this special LLVM prefix.
1153 static StringRef getRealLinkageName(StringRef LinkageName) {
1155 if (LinkageName.startswith(StringRef(&One, 1)))
1156 return LinkageName.substr(1);
1160 /// createGlobalVariableDIE - Create new DIE using GV.
1161 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1162 // If the global variable was optmized out then no need to create debug info
1164 if (!GV.getGlobal()) return NULL;
1165 if (GV.getDisplayName().empty()) return NULL;
1167 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1168 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1169 GV.getDisplayName());
1171 StringRef LinkageName = GV.getLinkageName();
1172 if (!LinkageName.empty())
1173 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1174 getRealLinkageName(LinkageName));
1176 addType(GVDie, GV.getType());
1177 if (!GV.isLocalToUnit())
1178 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1179 addSourceLine(GVDie, &GV);
1184 /// createMemberDIE - Create new member DIE.
1185 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1186 DIE *MemberDie = new DIE(DT.getTag());
1187 StringRef Name = DT.getName();
1189 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1191 addType(MemberDie, DT.getTypeDerivedFrom());
1193 addSourceLine(MemberDie, &DT);
1195 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1196 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1198 uint64_t Size = DT.getSizeInBits();
1199 uint64_t FieldSize = DT.getOriginalTypeSize();
1201 if (Size != FieldSize) {
1203 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1204 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1206 uint64_t Offset = DT.getOffsetInBits();
1207 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1208 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1209 uint64_t FieldOffset = (HiMark - FieldSize);
1210 Offset -= FieldOffset;
1212 // Maybe we need to work from the other end.
1213 if (Asm->getTargetData().isLittleEndian())
1214 Offset = FieldSize - (Offset + Size);
1215 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1217 // Here WD_AT_data_member_location points to the anonymous
1218 // field that includes this bit field.
1219 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1222 // This is not a bitfield.
1223 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1225 if (DT.getTag() == dwarf::DW_TAG_inheritance
1226 && DT.isVirtual()) {
1228 // For C++, virtual base classes are not at fixed offset. Use following
1229 // expression to extract appropriate offset from vtable.
1230 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1232 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1233 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1234 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1241 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1244 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1246 if (DT.isProtected())
1247 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1248 dwarf::DW_ACCESS_protected);
1249 else if (DT.isPrivate())
1250 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1251 dwarf::DW_ACCESS_private);
1252 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1253 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1254 dwarf::DW_ACCESS_public);
1256 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1257 dwarf::DW_VIRTUALITY_virtual);
1261 /// createSubprogramDIE - Create new DIE using SP.
1262 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1263 CompileUnit *SPCU = getCompileUnit(SP);
1264 DIE *SPDie = SPCU->getDIE(SP);
1268 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1269 // Constructors and operators for anonymous aggregates do not have names.
1270 if (!SP.getName().empty())
1271 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1273 StringRef LinkageName = SP.getLinkageName();
1274 if (!LinkageName.empty())
1275 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1276 getRealLinkageName(LinkageName));
1278 addSourceLine(SPDie, &SP);
1280 // Add prototyped tag, if C or ObjC.
1281 unsigned Lang = SP.getCompileUnit().getLanguage();
1282 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1283 Lang == dwarf::DW_LANG_ObjC)
1284 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1287 DICompositeType SPTy = SP.getType();
1288 DIArray Args = SPTy.getTypeArray();
1289 unsigned SPTag = SPTy.getTag();
1291 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1292 addType(SPDie, SPTy);
1294 addType(SPDie, DIType(Args.getElement(0)));
1296 unsigned VK = SP.getVirtuality();
1298 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1299 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1300 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1301 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1302 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1303 ContainingTypeMap.insert(std::make_pair(SPDie,
1304 SP.getContainingType()));
1307 if (MakeDecl || !SP.isDefinition()) {
1308 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1310 // Add arguments. Do not add arguments for subprogram definition. They will
1311 // be handled while processing variables.
1312 DICompositeType SPTy = SP.getType();
1313 DIArray Args = SPTy.getTypeArray();
1314 unsigned SPTag = SPTy.getTag();
1316 if (SPTag == dwarf::DW_TAG_subroutine_type)
1317 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1318 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1319 DIType ATy = DIType(DIType(Args.getElement(i)));
1321 if (ATy.isArtificial())
1322 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1323 SPDie->addChild(Arg);
1327 if (SP.isArtificial())
1328 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1330 if (!SP.isLocalToUnit())
1331 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1333 if (SP.isOptimized())
1334 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1336 // DW_TAG_inlined_subroutine may refer to this DIE.
1337 SPCU->insertDIE(SP, SPDie);
1339 // Add to context owner.
1340 addToContextOwner(SPDie, SP.getContext());
1345 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1346 assert(N && "Invalid Scope encoding!");
1348 DbgScope *AScope = AbstractScopes.lookup(N);
1352 DbgScope *Parent = NULL;
1354 DIDescriptor Scope(N);
1355 if (Scope.isLexicalBlock()) {
1356 DILexicalBlock DB(N);
1357 DIDescriptor ParentDesc = DB.getContext();
1358 Parent = getOrCreateAbstractScope(ParentDesc);
1361 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1364 Parent->addScope(AScope);
1365 AScope->setAbstractScope();
1366 AbstractScopes[N] = AScope;
1367 if (DIDescriptor(N).isSubprogram())
1368 AbstractScopesList.push_back(AScope);
1372 /// isSubprogramContext - Return true if Context is either a subprogram
1373 /// or another context nested inside a subprogram.
1374 static bool isSubprogramContext(const MDNode *Context) {
1377 DIDescriptor D(Context);
1378 if (D.isSubprogram())
1381 return isSubprogramContext(DIType(Context).getContext());
1385 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1386 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1387 /// If there are global variables in this scope then create and insert
1388 /// DIEs for these variables.
1389 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1390 CompileUnit *SPCU = getCompileUnit(SPNode);
1391 DIE *SPDie = SPCU->getDIE(SPNode);
1392 assert(SPDie && "Unable to find subprogram DIE!");
1393 DISubprogram SP(SPNode);
1395 // There is not any need to generate specification DIE for a function
1396 // defined at compile unit level. If a function is defined inside another
1397 // function then gdb prefers the definition at top level and but does not
1398 // expect specification DIE in parent function. So avoid creating
1399 // specification DIE for a function defined inside a function.
1400 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1401 !SP.getContext().isFile() &&
1402 !isSubprogramContext(SP.getContext())) {
1403 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1406 DICompositeType SPTy = SP.getType();
1407 DIArray Args = SPTy.getTypeArray();
1408 unsigned SPTag = SPTy.getTag();
1409 if (SPTag == dwarf::DW_TAG_subroutine_type)
1410 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1411 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1412 DIType ATy = DIType(DIType(Args.getElement(i)));
1414 if (ATy.isArtificial())
1415 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1416 SPDie->addChild(Arg);
1418 DIE *SPDeclDie = SPDie;
1419 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1420 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1422 SPCU->addDie(SPDie);
1425 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1426 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1427 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1428 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1429 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1430 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1431 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1436 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1437 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1438 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1440 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1441 if (Scope->isAbstractScope())
1444 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1448 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1449 if (Ranges.size() > 1) {
1450 // .debug_range section has not been laid out yet. Emit offset in
1451 // .debug_range as a uint, size 4, for now. emitDIE will handle
1452 // DW_AT_ranges appropriately.
1453 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1454 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1455 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1456 RE = Ranges.end(); RI != RE; ++RI) {
1457 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1458 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1460 DebugRangeSymbols.push_back(NULL);
1461 DebugRangeSymbols.push_back(NULL);
1465 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1466 const MCSymbol *End = getLabelAfterInsn(RI->second);
1468 if (End == 0) return 0;
1470 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1471 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1473 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1474 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1479 /// constructInlinedScopeDIE - This scope represents inlined body of
1480 /// a function. Construct DIE to represent this concrete inlined copy
1481 /// of the function.
1482 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1484 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1485 assert (Ranges.empty() == false
1486 && "DbgScope does not have instruction markers!");
1488 // FIXME : .debug_inlined section specification does not clearly state how
1489 // to emit inlined scope that is split into multiple instruction ranges.
1490 // For now, use first instruction range and emit low_pc/high_pc pair and
1491 // corresponding .debug_inlined section entry for this pair.
1492 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1493 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1494 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1496 if (StartLabel == FunctionBeginSym || EndLabel == 0) {
1497 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1500 assert(StartLabel->isDefined() &&
1501 "Invalid starting label for an inlined scope!");
1502 assert(EndLabel->isDefined() &&
1503 "Invalid end label for an inlined scope!");
1505 if (!Scope->getScopeNode())
1507 DIScope DS(Scope->getScopeNode());
1508 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1510 DISubprogram InlinedSP = getDISubprogram(DS);
1511 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1512 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1513 assert(OriginDIE && "Unable to find Origin DIE!");
1514 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1515 dwarf::DW_FORM_ref4, OriginDIE);
1517 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1518 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1520 InlinedSubprogramDIEs.insert(OriginDIE);
1522 // Track the start label for this inlined function.
1523 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1524 I = InlineInfo.find(InlinedSP);
1526 if (I == InlineInfo.end()) {
1527 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1529 InlinedSPNodes.push_back(InlinedSP);
1531 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1533 DILocation DL(Scope->getInlinedAt());
1534 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1535 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1541 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1542 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1543 // Get the descriptor.
1544 const DIVariable &VD = DV->getVariable();
1545 StringRef Name = VD.getName();
1549 // Translate tag to proper Dwarf tag. The result variable is dropped for
1552 switch (VD.getTag()) {
1553 case dwarf::DW_TAG_return_variable:
1555 case dwarf::DW_TAG_arg_variable:
1556 Tag = dwarf::DW_TAG_formal_parameter;
1558 case dwarf::DW_TAG_auto_variable: // fall thru
1560 Tag = dwarf::DW_TAG_variable;
1564 // Define variable debug information entry.
1565 DIE *VariableDie = new DIE(Tag);
1568 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1569 V2AVI = VarToAbstractVarMap.find(DV);
1570 if (V2AVI != VarToAbstractVarMap.end())
1571 AbsDIE = V2AVI->second->getDIE();
1574 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1575 dwarf::DW_FORM_ref4, AbsDIE);
1577 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1578 addSourceLine(VariableDie, &VD);
1580 // Add variable type.
1581 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1582 // addresses instead.
1583 if (VD.isBlockByrefVariable())
1584 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1586 addType(VariableDie, VD.getType());
1589 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1590 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1592 if (Scope->isAbstractScope()) {
1593 DV->setDIE(VariableDie);
1597 // Add variable address.
1599 unsigned Offset = DV->getDotDebugLocOffset();
1600 if (Offset != ~0U) {
1601 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1602 Asm->GetTempSymbol("debug_loc", Offset));
1603 DV->setDIE(VariableDie);
1604 UseDotDebugLocEntry.insert(VariableDie);
1608 // Check if variable is described by a DBG_VALUE instruction.
1609 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1610 DbgVariableToDbgInstMap.find(DV);
1611 if (DVI != DbgVariableToDbgInstMap.end()) {
1612 const MachineInstr *DVInsn = DVI->second;
1613 const MCSymbol *DVLabel = findVariableLabel(DV);
1614 bool updated = false;
1615 // FIXME : Handle getNumOperands != 3
1616 if (DVInsn->getNumOperands() == 3) {
1617 if (DVInsn->getOperand(0).isReg())
1618 updated = addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1619 else if (DVInsn->getOperand(0).isImm())
1620 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1621 else if (DVInsn->getOperand(0).isFPImm())
1622 updated = addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1624 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1625 if (Location.getReg()) {
1626 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1628 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1634 // If variableDie is not updated then DBG_VALUE instruction does not
1635 // have valid variable info.
1639 DV->setDIE(VariableDie);
1643 // .. else use frame index, if available.
1644 MachineLocation Location;
1646 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1648 if (findVariableFrameIndex(DV, &FI)) {
1649 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1650 Location.set(FrameReg, Offset);
1652 if (VD.hasComplexAddress())
1653 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1654 else if (VD.isBlockByrefVariable())
1655 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1657 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1659 DV->setDIE(VariableDie);
1664 void DwarfDebug::addPubTypes(DISubprogram SP) {
1665 DICompositeType SPTy = SP.getType();
1666 unsigned SPTag = SPTy.getTag();
1667 if (SPTag != dwarf::DW_TAG_subroutine_type)
1670 DIArray Args = SPTy.getTypeArray();
1671 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1672 DIType ATy(Args.getElement(i));
1675 DICompositeType CATy = getDICompositeType(ATy);
1676 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1677 && !CATy.isForwardDecl()) {
1678 CompileUnit *TheCU = getCompileUnit(CATy);
1679 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1680 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1685 /// constructScopeDIE - Construct a DIE for this scope.
1686 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1687 if (!Scope || !Scope->getScopeNode())
1690 DIScope DS(Scope->getScopeNode());
1691 DIE *ScopeDIE = NULL;
1692 if (Scope->getInlinedAt())
1693 ScopeDIE = constructInlinedScopeDIE(Scope);
1694 else if (DS.isSubprogram()) {
1695 ProcessedSPNodes.insert(DS);
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_addr, 0);
1797 // DW_AT_stmt_list is a offset of line number information for this
1798 // compile unit in debug_line section. This offset is calculated
1799 // during endMoudle().
1800 addLabel(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;
2010 const Module *M = MMI->getModule();
2011 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2012 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2013 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2014 DISubprogram SP(AllSPs->getOperand(SI));
2015 if (!SP.Verify()) continue;
2017 // Collect info for variables that were optimized out.
2018 StringRef FName = SP.getLinkageName();
2020 FName = SP.getName();
2022 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2024 unsigned E = NMD->getNumOperands();
2026 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2027 for (unsigned I = 0; I != E; ++I) {
2028 DIVariable DV(NMD->getOperand(I));
2029 if (!DV.Verify()) continue;
2030 Scope->addVariable(new DbgVariable(DV));
2033 // Construct subprogram DIE and add variables DIEs.
2034 constructSubprogramDIE(SP);
2035 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2036 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2037 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2038 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2040 ScopeDIE->addChild(VariableDIE);
2045 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2046 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2047 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2049 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2052 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2053 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2054 DIE *SPDie = CI->first;
2055 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2057 DIE *NDie = getCompileUnit(N)->getDIE(N);
2058 if (!NDie) continue;
2059 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2062 // Standard sections final addresses.
2063 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2064 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2065 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2066 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2068 // End text sections.
2069 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2070 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2071 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2074 // Emit common frame information.
2075 emitCommonDebugFrame();
2077 // Emit function debug frame information
2078 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2079 E = DebugFrames.end(); I != E; ++I)
2080 emitFunctionDebugFrame(*I);
2082 // Compute DIE offsets and sizes.
2083 computeSizeAndOffsets();
2085 // Emit source line correspondence into a debug line section.
2088 // Emit all the DIEs into a debug info section
2091 // Corresponding abbreviations into a abbrev section.
2092 emitAbbreviations();
2094 // Emit info into a debug pubnames section.
2095 emitDebugPubNames();
2097 // Emit info into a debug pubtypes section.
2098 emitDebugPubTypes();
2100 // Emit info into a debug loc section.
2103 // Emit info into a debug aranges section.
2106 // Emit info into a debug ranges section.
2109 // Emit info into a debug macinfo section.
2112 // Emit inline info.
2113 emitDebugInlineInfo();
2115 // Emit info into a debug str section.
2118 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2119 E = CUMap.end(); I != E; ++I)
2121 FirstCU = NULL; // Reset for the next Module, if any.
2124 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2125 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2126 DebugLoc ScopeLoc) {
2128 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2130 return AbsDbgVariable;
2132 LLVMContext &Ctx = Var->getContext();
2133 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2137 AbsDbgVariable = new DbgVariable(Var);
2138 Scope->addVariable(AbsDbgVariable);
2139 AbstractVariables[Var] = AbsDbgVariable;
2140 return AbsDbgVariable;
2143 /// collectVariableInfoFromMMITable - Collect variable information from
2144 /// side table maintained by MMI.
2146 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2147 SmallPtrSet<const MDNode *, 16> &Processed) {
2148 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2149 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2150 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2151 VE = VMap.end(); VI != VE; ++VI) {
2152 const MDNode *Var = VI->first;
2154 Processed.insert(Var);
2156 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2158 DbgScope *Scope = 0;
2159 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2160 Scope = ConcreteScopes.lookup(IA);
2162 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2164 // If variable scope is not found then skip this variable.
2168 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2169 DbgVariable *RegVar = new DbgVariable(DV);
2170 recordVariableFrameIndex(RegVar, VP.first);
2171 Scope->addVariable(RegVar);
2172 if (AbsDbgVariable) {
2173 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2174 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2179 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2180 /// DBG_VALUE instruction, is in undefined reg.
2181 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2182 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2183 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2188 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2189 /// DBG_VALUE instruction, is in a defined reg.
2190 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2191 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2192 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2197 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2199 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2200 SmallPtrSet<const MDNode *, 16> &Processed) {
2202 /// collection info from MMI table.
2203 collectVariableInfoFromMMITable(MF, Processed);
2205 SmallVector<const MachineInstr *, 8> DbgValues;
2206 // Collect variable information from DBG_VALUE machine instructions;
2207 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2209 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2211 const MachineInstr *MInsn = II;
2212 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2214 DbgValues.push_back(MInsn);
2217 // This is a collection of DBV_VALUE instructions describing same variable.
2218 SmallVector<const MachineInstr *, 4> MultipleValues;
2219 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2220 E = DbgValues.end(); I != E; ++I) {
2221 const MachineInstr *MInsn = *I;
2222 MultipleValues.clear();
2223 if (isDbgValueInDefinedReg(MInsn))
2224 MultipleValues.push_back(MInsn);
2225 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2226 if (Processed.count(DV) != 0)
2229 const MachineInstr *PrevMI = MInsn;
2230 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2231 ME = DbgValues.end(); MI != ME; ++MI) {
2233 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2234 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2235 !PrevMI->isIdenticalTo(*MI))
2236 MultipleValues.push_back(*MI);
2240 DbgScope *Scope = findDbgScope(MInsn);
2241 bool CurFnArg = false;
2242 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2243 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2245 if (!Scope && CurFnArg)
2246 Scope = CurrentFnDbgScope;
2247 // If variable scope is not found then skip this variable.
2251 Processed.insert(DV);
2252 DbgVariable *RegVar = new DbgVariable(DV);
2253 Scope->addVariable(RegVar);
2255 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2256 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2257 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2258 VarToAbstractVarMap[RegVar] = AbsVar;
2260 if (MultipleValues.size() <= 1) {
2261 DbgVariableToDbgInstMap[RegVar] = MInsn;
2265 // handle multiple DBG_VALUE instructions describing one variable.
2266 if (DotDebugLocEntries.empty())
2267 RegVar->setDotDebugLocOffset(0);
2269 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2270 const MachineInstr *Begin = NULL;
2271 const MachineInstr *End = NULL;
2272 for (SmallVector<const MachineInstr *, 4>::iterator
2273 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); MVI != MVE; ++MVI) {
2279 MachineLocation MLoc;
2280 MLoc.set(Begin->getOperand(0).getReg(), 0);
2281 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2282 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2283 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2285 if (MVI + 1 == MVE) {
2286 // If End is the last instruction then its value is valid
2287 // until the end of the funtion.
2288 MLoc.set(End->getOperand(0).getReg(), 0);
2290 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2293 DotDebugLocEntries.push_back(DotDebugLocEntry());
2296 // Collect info for variables that were optimized out.
2297 const Function *F = MF->getFunction();
2298 const Module *M = F->getParent();
2299 if (NamedMDNode *NMD =
2300 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2301 getRealLinkageName(F->getName())))) {
2302 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2303 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2304 if (!DV || !Processed.insert(DV))
2306 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2308 Scope->addVariable(new DbgVariable(DV));
2313 /// getLabelBeforeInsn - Return Label preceding the instruction.
2314 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2315 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2316 LabelsBeforeInsn.find(MI);
2317 if (I == LabelsBeforeInsn.end())
2318 // FunctionBeginSym always preceeds all the instruction in current function.
2319 return FunctionBeginSym;
2323 /// getLabelAfterInsn - Return Label immediately following the instruction.
2324 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2325 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2326 LabelsAfterInsn.find(MI);
2327 if (I == LabelsAfterInsn.end())
2332 /// beginScope - Process beginning of a scope.
2333 void DwarfDebug::beginScope(const MachineInstr *MI) {
2334 if (InsnNeedsLabel.count(MI) == 0) {
2335 LabelsBeforeInsn[MI] = PrevLabel;
2340 DebugLoc DL = MI->getDebugLoc();
2341 if (!DL.isUnknown()) {
2342 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2343 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2345 LabelsBeforeInsn[MI] = PrevLabel;
2349 // If location is unknown then use temp label for this DBG_VALUE
2351 if (MI->isDebugValue()) {
2352 PrevLabel = MMI->getContext().CreateTempSymbol();
2353 Asm->OutStreamer.EmitLabel(PrevLabel);
2354 LabelsBeforeInsn[MI] = PrevLabel;
2358 if (UnknownLocations) {
2359 PrevLabel = recordSourceLine(0, 0, 0);
2360 LabelsBeforeInsn[MI] = PrevLabel;
2364 assert (0 && "Instruction is not processed!");
2367 /// endScope - Process end of a scope.
2368 void DwarfDebug::endScope(const MachineInstr *MI) {
2369 if (InsnsEndScopeSet.count(MI) != 0) {
2370 // Emit a label if this instruction ends a scope.
2371 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2372 Asm->OutStreamer.EmitLabel(Label);
2373 LabelsAfterInsn[MI] = Label;
2377 /// getOrCreateDbgScope - Create DbgScope for the scope.
2378 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2380 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2383 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2384 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2385 if (DIDescriptor(Scope).isLexicalBlock()) {
2387 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2388 WScope->setParent(Parent);
2389 Parent->addScope(WScope);
2392 if (!WScope->getParent()) {
2393 StringRef SPName = DISubprogram(Scope).getLinkageName();
2394 // We used to check only for a linkage name, but that fails
2395 // since we began omitting the linkage name for private
2396 // functions. The new way is to check for the name in metadata,
2397 // but that's not supported in old .ll test cases. Ergo, we
2399 if (SPName == Asm->MF->getFunction()->getName() ||
2400 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2401 CurrentFnDbgScope = WScope;
2407 getOrCreateAbstractScope(Scope);
2408 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2412 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2413 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2414 DILocation DL(InlinedAt);
2416 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2417 WScope->setParent(Parent);
2418 Parent->addScope(WScope);
2420 ConcreteScopes[InlinedAt] = WScope;
2425 /// hasValidLocation - Return true if debug location entry attached with
2426 /// machine instruction encodes valid location info.
2427 static bool hasValidLocation(LLVMContext &Ctx,
2428 const MachineInstr *MInsn,
2429 const MDNode *&Scope, const MDNode *&InlinedAt) {
2430 DebugLoc DL = MInsn->getDebugLoc();
2431 if (DL.isUnknown()) return false;
2433 const MDNode *S = DL.getScope(Ctx);
2435 // There is no need to create another DIE for compile unit. For all
2436 // other scopes, create one DbgScope now. This will be translated
2437 // into a scope DIE at the end.
2438 if (DIScope(S).isCompileUnit()) return false;
2441 InlinedAt = DL.getInlinedAt(Ctx);
2445 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2447 static void calculateDominanceGraph(DbgScope *Scope) {
2448 assert (Scope && "Unable to calculate scop edominance graph!");
2449 SmallVector<DbgScope *, 4> WorkStack;
2450 WorkStack.push_back(Scope);
2451 unsigned Counter = 0;
2452 while (!WorkStack.empty()) {
2453 DbgScope *WS = WorkStack.back();
2454 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2455 bool visitedChildren = false;
2456 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2457 SE = Children.end(); SI != SE; ++SI) {
2458 DbgScope *ChildScope = *SI;
2459 if (!ChildScope->getDFSOut()) {
2460 WorkStack.push_back(ChildScope);
2461 visitedChildren = true;
2462 ChildScope->setDFSIn(++Counter);
2466 if (!visitedChildren) {
2467 WorkStack.pop_back();
2468 WS->setDFSOut(++Counter);
2473 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2475 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2476 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2479 unsigned PrevDFSIn = 0;
2480 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2482 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2484 const MachineInstr *MInsn = II;
2485 const MDNode *Scope = NULL;
2486 const MDNode *InlinedAt = NULL;
2488 // Check if instruction has valid location information.
2489 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2493 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2494 MI2ScopeMap.find(MInsn);
2495 if (DI != MI2ScopeMap.end()) {
2496 DbgScope *S = DI->second;
2497 dbgs() << S->getDFSIn();
2498 PrevDFSIn = S->getDFSIn();
2500 dbgs() << PrevDFSIn;
2502 dbgs() << " [ x" << PrevDFSIn;
2510 /// extractScopeInformation - Scan machine instructions in this function
2511 /// and collect DbgScopes. Return true, if at least one scope was found.
2512 bool DwarfDebug::extractScopeInformation() {
2513 // If scope information was extracted using .dbg intrinsics then there is not
2514 // any need to extract these information by scanning each instruction.
2515 if (!DbgScopeMap.empty())
2518 // Scan each instruction and create scopes. First build working set of scopes.
2519 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2520 SmallVector<DbgRange, 4> MIRanges;
2521 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2522 const MDNode *PrevScope = NULL;
2523 const MDNode *PrevInlinedAt = NULL;
2524 const MachineInstr *RangeBeginMI = NULL;
2525 const MachineInstr *PrevMI = NULL;
2526 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2528 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2530 const MachineInstr *MInsn = II;
2531 const MDNode *Scope = NULL;
2532 const MDNode *InlinedAt = NULL;
2534 // Check if instruction has valid location information.
2535 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2540 // If scope has not changed then skip this instruction.
2541 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2547 // If we have alread seen a beginning of a instruction range and
2548 // current instruction scope does not match scope of first instruction
2549 // in this range then create a new instruction range.
2550 DbgRange R(RangeBeginMI, PrevMI);
2551 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2552 MIRanges.push_back(R);
2555 // This is a beginning of a new instruction range.
2556 RangeBeginMI = MInsn;
2558 // Reset previous markers.
2561 PrevInlinedAt = InlinedAt;
2565 // Create last instruction range.
2566 if (RangeBeginMI && PrevMI && PrevScope) {
2567 DbgRange R(RangeBeginMI, PrevMI);
2568 MIRanges.push_back(R);
2569 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2572 if (!CurrentFnDbgScope)
2575 calculateDominanceGraph(CurrentFnDbgScope);
2577 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2579 // Find ranges of instructions covered by each DbgScope;
2580 DbgScope *PrevDbgScope = NULL;
2581 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2582 RE = MIRanges.end(); RI != RE; ++RI) {
2583 const DbgRange &R = *RI;
2584 DbgScope *S = MI2ScopeMap.lookup(R.first);
2585 assert (S && "Lost DbgScope for a machine instruction!");
2586 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2587 PrevDbgScope->closeInsnRange(S);
2588 S->openInsnRange(R.first);
2589 S->extendInsnRange(R.second);
2594 PrevDbgScope->closeInsnRange();
2596 identifyScopeMarkers();
2598 return !DbgScopeMap.empty();
2601 /// identifyScopeMarkers() -
2602 /// Each DbgScope has first instruction and last instruction to mark beginning
2603 /// and end of a scope respectively. Create an inverse map that list scopes
2604 /// starts (and ends) with an instruction. One instruction may start (or end)
2605 /// multiple scopes. Ignore scopes that are not reachable.
2606 void DwarfDebug::identifyScopeMarkers() {
2607 SmallVector<DbgScope *, 4> WorkList;
2608 WorkList.push_back(CurrentFnDbgScope);
2609 while (!WorkList.empty()) {
2610 DbgScope *S = WorkList.pop_back_val();
2612 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2613 if (!Children.empty())
2614 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2615 SE = Children.end(); SI != SE; ++SI)
2616 WorkList.push_back(*SI);
2618 if (S->isAbstractScope())
2621 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2624 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2625 RE = Ranges.end(); RI != RE; ++RI) {
2626 assert(RI->first && "DbgRange does not have first instruction!");
2627 assert(RI->second && "DbgRange does not have second instruction!");
2628 InsnsEndScopeSet.insert(RI->second);
2633 /// FindFirstDebugLoc - Find the first debug location in the function. This
2634 /// is intended to be an approximation for the source position of the
2635 /// beginning of the function.
2636 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2637 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2639 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2640 MBBI != MBBE; ++MBBI) {
2641 DebugLoc DL = MBBI->getDebugLoc();
2642 if (!DL.isUnknown())
2648 /// beginFunction - Gather pre-function debug information. Assumes being
2649 /// emitted immediately after the function entry point.
2650 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2651 if (!MMI->hasDebugInfo()) return;
2652 if (!extractScopeInformation()) return;
2654 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2655 Asm->getFunctionNumber());
2656 // Assumes in correct section after the entry point.
2657 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2659 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2661 DebugLoc FDL = FindFirstDebugLoc(MF);
2662 if (FDL.isUnknown()) return;
2664 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2666 DISubprogram SP = getDISubprogram(Scope);
2669 Line = SP.getLineNumber();
2672 Line = FDL.getLine();
2676 recordSourceLine(Line, Col, Scope);
2678 /// ProcessedArgs - Collection of arguments already processed.
2679 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2682 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2684 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2686 const MachineInstr *MI = II;
2687 DebugLoc DL = MI->getDebugLoc();
2688 if (MI->isDebugValue()) {
2689 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2690 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2691 if (!DV.Verify()) continue;
2692 // If DBG_VALUE is for a local variable then it needs a label.
2693 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2694 && isDbgValueInUndefinedReg(MI) == false)
2695 InsnNeedsLabel.insert(MI);
2696 // DBG_VALUE for inlined functions argument needs a label.
2697 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2698 describes(MF->getFunction()))
2699 InsnNeedsLabel.insert(MI);
2700 // DBG_VALUE indicating argument location change needs a label.
2701 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV))
2702 InsnNeedsLabel.insert(MI);
2704 // If location is unknown then instruction needs a location only if
2705 // UnknownLocations flag is set.
2706 if (DL.isUnknown()) {
2707 if (UnknownLocations && !PrevLoc.isUnknown())
2708 InsnNeedsLabel.insert(MI);
2709 } else if (DL != PrevLoc)
2710 // Otherwise, instruction needs a location only if it is new location.
2711 InsnNeedsLabel.insert(MI);
2714 if (!DL.isUnknown() || UnknownLocations)
2718 PrevLabel = FunctionBeginSym;
2721 /// endFunction - Gather and emit post-function debug information.
2723 void DwarfDebug::endFunction(const MachineFunction *MF) {
2724 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2726 if (CurrentFnDbgScope) {
2728 // Define end label for subprogram.
2729 FunctionEndSym = Asm->GetTempSymbol("func_end",
2730 Asm->getFunctionNumber());
2731 // Assumes in correct section after the entry point.
2732 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2734 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2735 collectVariableInfo(MF, ProcessedVars);
2737 // Get function line info.
2738 if (!Lines.empty()) {
2739 // Get section line info.
2740 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2741 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2742 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2743 // Append the function info to section info.
2744 SectionLineInfos.insert(SectionLineInfos.end(),
2745 Lines.begin(), Lines.end());
2748 // Construct abstract scopes.
2749 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2750 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2751 DISubprogram SP((*AI)->getScopeNode());
2753 // Collect info for variables that were optimized out.
2754 StringRef FName = SP.getLinkageName();
2756 FName = SP.getName();
2757 const Module *M = MF->getFunction()->getParent();
2758 if (NamedMDNode *NMD =
2759 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2760 getRealLinkageName(FName)))) {
2761 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2762 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2763 if (!DV || !ProcessedVars.insert(DV))
2765 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2767 Scope->addVariable(new DbgVariable(DV));
2771 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2772 constructScopeDIE(*AI);
2775 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2777 if (!DisableFramePointerElim(*MF))
2778 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2779 dwarf::DW_FORM_flag, 1);
2782 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2783 MMI->getFrameMoves()));
2787 CurrentFnDbgScope = NULL;
2788 InsnNeedsLabel.clear();
2789 DbgVariableToFrameIndexMap.clear();
2790 VarToAbstractVarMap.clear();
2791 DbgVariableToDbgInstMap.clear();
2792 DbgVariableLabelsMap.clear();
2793 DeleteContainerSeconds(DbgScopeMap);
2794 InsnsEndScopeSet.clear();
2795 ConcreteScopes.clear();
2796 DeleteContainerSeconds(AbstractScopes);
2797 AbstractScopesList.clear();
2798 AbstractVariables.clear();
2799 LabelsBeforeInsn.clear();
2800 LabelsAfterInsn.clear();
2805 /// recordVariableFrameIndex - Record a variable's index.
2806 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2807 assert (V && "Invalid DbgVariable!");
2808 DbgVariableToFrameIndexMap[V] = Index;
2811 /// findVariableFrameIndex - Return true if frame index for the variable
2812 /// is found. Update FI to hold value of the index.
2813 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2814 assert (V && "Invalid DbgVariable!");
2815 DenseMap<const DbgVariable *, int>::iterator I =
2816 DbgVariableToFrameIndexMap.find(V);
2817 if (I == DbgVariableToFrameIndexMap.end())
2823 /// findVariableLabel - Find MCSymbol for the variable.
2824 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2825 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2826 = DbgVariableLabelsMap.find(V);
2827 if (I == DbgVariableLabelsMap.end())
2829 else return I->second;
2832 /// findDbgScope - Find DbgScope for the debug loc attached with an
2834 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2835 DbgScope *Scope = NULL;
2837 MInsn->getParent()->getParent()->getFunction()->getContext();
2838 DebugLoc DL = MInsn->getDebugLoc();
2843 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2844 Scope = ConcreteScopes.lookup(IA);
2846 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2852 /// recordSourceLine - Register a source line with debug info. Returns the
2853 /// unique label that was emitted and which provides correspondence to
2854 /// the source line list.
2855 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2861 DIDescriptor Scope(S);
2863 if (Scope.isCompileUnit()) {
2864 DICompileUnit CU(S);
2865 Dir = CU.getDirectory();
2866 Fn = CU.getFilename();
2867 } else if (Scope.isSubprogram()) {
2869 Dir = SP.getDirectory();
2870 Fn = SP.getFilename();
2871 } else if (Scope.isLexicalBlock()) {
2872 DILexicalBlock DB(S);
2873 Dir = DB.getDirectory();
2874 Fn = DB.getFilename();
2876 assert(0 && "Unexpected scope info");
2878 Src = GetOrCreateSourceID(Dir, Fn);
2882 if (!Lines.empty()) {
2883 SrcLineInfo lastSrcLineInfo = Lines.back();
2884 // Emitting sequential line records with the same line number (but
2885 // different addresses) seems to confuse GDB. Avoid this.
2886 if (lastSrcLineInfo.getLine() == Line)
2891 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2892 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2894 Asm->OutStreamer.EmitLabel(Label);
2898 //===----------------------------------------------------------------------===//
2900 //===----------------------------------------------------------------------===//
2902 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2905 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2906 // Get the children.
2907 const std::vector<DIE *> &Children = Die->getChildren();
2909 // If not last sibling and has children then add sibling offset attribute.
2910 if (!Last && !Children.empty())
2911 Die->addSiblingOffset(DIEValueAllocator);
2913 // Record the abbreviation.
2914 assignAbbrevNumber(Die->getAbbrev());
2916 // Get the abbreviation for this DIE.
2917 unsigned AbbrevNumber = Die->getAbbrevNumber();
2918 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2921 Die->setOffset(Offset);
2923 // Start the size with the size of abbreviation code.
2924 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2926 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2927 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2929 // Size the DIE attribute values.
2930 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2931 // Size attribute value.
2932 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2934 // Size the DIE children if any.
2935 if (!Children.empty()) {
2936 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2937 "Children flag not set");
2939 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2940 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2942 // End of children marker.
2943 Offset += sizeof(int8_t);
2946 Die->setSize(Offset - Die->getOffset());
2950 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2952 void DwarfDebug::computeSizeAndOffsets() {
2953 unsigned PrevOffset = 0;
2954 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2955 E = CUMap.end(); I != E; ++I) {
2956 // Compute size of compile unit header.
2957 static unsigned Offset = PrevOffset +
2958 sizeof(int32_t) + // Length of Compilation Unit Info
2959 sizeof(int16_t) + // DWARF version number
2960 sizeof(int32_t) + // Offset Into Abbrev. Section
2961 sizeof(int8_t); // Pointer Size (in bytes)
2962 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2963 PrevOffset = Offset;
2967 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2968 /// temporary label to it if SymbolStem is specified.
2969 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2970 const char *SymbolStem = 0) {
2971 Asm->OutStreamer.SwitchSection(Section);
2972 if (!SymbolStem) return 0;
2974 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2975 Asm->OutStreamer.EmitLabel(TmpSym);
2979 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2980 /// the start of each one.
2981 void DwarfDebug::EmitSectionLabels() {
2982 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2984 // Dwarf sections base addresses.
2985 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2986 DwarfFrameSectionSym =
2987 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2990 DwarfInfoSectionSym =
2991 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2992 DwarfAbbrevSectionSym =
2993 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2994 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2996 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2997 EmitSectionSym(Asm, MacroInfo);
2999 DwarfDebugLineSectionSym =
3000 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3001 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3002 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3003 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3004 DwarfStrSectionSym =
3005 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3006 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3009 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3010 "section_debug_loc");
3012 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3013 EmitSectionSym(Asm, TLOF.getDataSection());
3016 /// emitDIE - Recusively Emits a debug information entry.
3018 void DwarfDebug::emitDIE(DIE *Die) {
3019 // Get the abbreviation for this DIE.
3020 unsigned AbbrevNumber = Die->getAbbrevNumber();
3021 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3023 // Emit the code (index) for the abbreviation.
3024 if (Asm->isVerbose())
3025 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3026 Twine::utohexstr(Die->getOffset()) + ":0x" +
3027 Twine::utohexstr(Die->getSize()) + " " +
3028 dwarf::TagString(Abbrev->getTag()));
3029 Asm->EmitULEB128(AbbrevNumber);
3031 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3032 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3034 // Emit the DIE attribute values.
3035 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3036 unsigned Attr = AbbrevData[i].getAttribute();
3037 unsigned Form = AbbrevData[i].getForm();
3038 assert(Form && "Too many attributes for DIE (check abbreviation)");
3040 if (Asm->isVerbose())
3041 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3044 case dwarf::DW_AT_sibling:
3045 Asm->EmitInt32(Die->getSiblingOffset());
3047 case dwarf::DW_AT_abstract_origin: {
3048 DIEEntry *E = cast<DIEEntry>(Values[i]);
3049 DIE *Origin = E->getEntry();
3050 unsigned Addr = Origin->getOffset();
3051 Asm->EmitInt32(Addr);
3054 case dwarf::DW_AT_ranges: {
3055 // DW_AT_range Value encodes offset in debug_range section.
3056 DIEInteger *V = cast<DIEInteger>(Values[i]);
3057 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3059 DwarfDebugRangeSectionSym,
3063 case dwarf::DW_AT_stmt_list: {
3064 Asm->EmitLabelDifference(CurrentLineSectionSym,
3065 DwarfDebugLineSectionSym, 4);
3068 case dwarf::DW_AT_location: {
3069 if (UseDotDebugLocEntry.count(Die) != 0) {
3070 DIELabel *L = cast<DIELabel>(Values[i]);
3071 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3073 Values[i]->EmitValue(Asm, Form);
3077 // Emit an attribute using the defined form.
3078 Values[i]->EmitValue(Asm, Form);
3083 // Emit the DIE children if any.
3084 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3085 const std::vector<DIE *> &Children = Die->getChildren();
3087 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3088 emitDIE(Children[j]);
3090 if (Asm->isVerbose())
3091 Asm->OutStreamer.AddComment("End Of Children Mark");
3096 /// emitDebugInfo - Emit the debug info section.
3098 void DwarfDebug::emitDebugInfo() {
3099 // Start debug info section.
3100 Asm->OutStreamer.SwitchSection(
3101 Asm->getObjFileLowering().getDwarfInfoSection());
3102 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3103 E = CUMap.end(); I != E; ++I) {
3104 CompileUnit *TheCU = I->second;
3105 DIE *Die = TheCU->getCUDie();
3107 // Emit the compile units header.
3108 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3111 // Emit size of content not including length itself
3112 unsigned ContentSize = Die->getSize() +
3113 sizeof(int16_t) + // DWARF version number
3114 sizeof(int32_t) + // Offset Into Abbrev. Section
3115 sizeof(int8_t) + // Pointer Size (in bytes)
3116 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3118 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3119 Asm->EmitInt32(ContentSize);
3120 Asm->OutStreamer.AddComment("DWARF version number");
3121 Asm->EmitInt16(dwarf::DWARF_VERSION);
3122 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3123 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3124 DwarfAbbrevSectionSym);
3125 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3126 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3129 // FIXME - extra padding for gdb bug.
3130 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3135 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3139 /// emitAbbreviations - Emit the abbreviation section.
3141 void DwarfDebug::emitAbbreviations() const {
3142 // Check to see if it is worth the effort.
3143 if (!Abbreviations.empty()) {
3144 // Start the debug abbrev section.
3145 Asm->OutStreamer.SwitchSection(
3146 Asm->getObjFileLowering().getDwarfAbbrevSection());
3148 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3150 // For each abbrevation.
3151 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3152 // Get abbreviation data
3153 const DIEAbbrev *Abbrev = Abbreviations[i];
3155 // Emit the abbrevations code (base 1 index.)
3156 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3158 // Emit the abbreviations data.
3162 // Mark end of abbreviations.
3163 Asm->EmitULEB128(0, "EOM(3)");
3165 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3169 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3170 /// the line matrix.
3172 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3173 // Define last address of section.
3174 Asm->OutStreamer.AddComment("Extended Op");
3177 Asm->OutStreamer.AddComment("Op size");
3178 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3179 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3180 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3182 Asm->OutStreamer.AddComment("Section end label");
3184 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3185 Asm->getTargetData().getPointerSize(),
3188 // Mark end of matrix.
3189 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3195 /// emitDebugLines - Emit source line information.
3197 void DwarfDebug::emitDebugLines() {
3198 // If the target is using .loc/.file, the assembler will be emitting the
3199 // .debug_line table automatically.
3200 if (Asm->MAI->hasDotLocAndDotFile())
3203 // Minimum line delta, thus ranging from -10..(255-10).
3204 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3205 // Maximum line delta, thus ranging from -10..(255-10).
3206 const int MaxLineDelta = 255 + MinLineDelta;
3208 // Start the dwarf line section.
3209 Asm->OutStreamer.SwitchSection(
3210 Asm->getObjFileLowering().getDwarfLineSection());
3212 // Construct the section header.
3213 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3214 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3215 Asm->OutStreamer.AddComment("Length of Source Line Info");
3216 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3217 Asm->GetTempSymbol("line_begin"), 4);
3218 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3220 Asm->OutStreamer.AddComment("DWARF version number");
3221 Asm->EmitInt16(dwarf::DWARF_VERSION);
3223 Asm->OutStreamer.AddComment("Prolog Length");
3224 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3225 Asm->GetTempSymbol("line_prolog_begin"), 4);
3226 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3228 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3230 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3232 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3233 Asm->EmitInt8(MinLineDelta);
3234 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3235 Asm->EmitInt8(MaxLineDelta);
3236 Asm->OutStreamer.AddComment("Special Opcode Base");
3237 Asm->EmitInt8(-MinLineDelta);
3239 // Line number standard opcode encodings argument count
3240 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3242 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3244 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3246 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3248 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3250 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3252 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3254 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3256 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3259 // Emit directories.
3260 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3261 const std::string &Dir = getSourceDirectoryName(DI);
3262 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3263 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3266 Asm->OutStreamer.AddComment("End of directories");
3270 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3271 // Remember source id starts at 1.
3272 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3273 const std::string &FN = getSourceFileName(Id.second);
3274 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3275 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3277 Asm->EmitULEB128(Id.first, "Directory #");
3278 Asm->EmitULEB128(0, "Mod date");
3279 Asm->EmitULEB128(0, "File size");
3282 Asm->OutStreamer.AddComment("End of files");
3285 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3287 // A sequence for each text section.
3288 unsigned SecSrcLinesSize = SectionSourceLines.size();
3290 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3291 // Isolate current sections line info.
3292 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3294 // Dwarf assumes we start with first line of first source file.
3295 unsigned Source = 1;
3298 // Construct rows of the address, source, line, column matrix.
3299 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3300 const SrcLineInfo &LineInfo = LineInfos[i];
3301 MCSymbol *Label = LineInfo.getLabel();
3302 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3304 if (Asm->isVerbose()) {
3305 std::pair<unsigned, unsigned> SrcID =
3306 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3307 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3309 Twine(getSourceFileName(SrcID.second)) +
3310 ":" + Twine(LineInfo.getLine()));
3313 // Define the line address.
3314 Asm->OutStreamer.AddComment("Extended Op");
3316 Asm->OutStreamer.AddComment("Op size");
3317 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3319 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3320 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3322 Asm->OutStreamer.AddComment("Location label");
3323 Asm->OutStreamer.EmitSymbolValue(Label,
3324 Asm->getTargetData().getPointerSize(),
3327 // If change of source, then switch to the new source.
3328 if (Source != LineInfo.getSourceID()) {
3329 Source = LineInfo.getSourceID();
3330 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3331 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3332 Asm->EmitULEB128(Source, "New Source");
3335 // If change of line.
3336 if (Line != LineInfo.getLine()) {
3337 // Determine offset.
3338 int Offset = LineInfo.getLine() - Line;
3339 int Delta = Offset - MinLineDelta;
3342 Line = LineInfo.getLine();
3344 // If delta is small enough and in range...
3345 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3346 // ... then use fast opcode.
3347 Asm->OutStreamer.AddComment("Line Delta");
3348 Asm->EmitInt8(Delta - MinLineDelta);
3350 // ... otherwise use long hand.
3351 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3352 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3353 Asm->EmitSLEB128(Offset, "Line Offset");
3354 Asm->OutStreamer.AddComment("DW_LNS_copy");
3355 Asm->EmitInt8(dwarf::DW_LNS_copy);
3358 // Copy the previous row (different address or source)
3359 Asm->OutStreamer.AddComment("DW_LNS_copy");
3360 Asm->EmitInt8(dwarf::DW_LNS_copy);
3364 emitEndOfLineMatrix(j + 1);
3367 if (SecSrcLinesSize == 0)
3368 // Because we're emitting a debug_line section, we still need a line
3369 // table. The linker and friends expect it to exist. If there's nothing to
3370 // put into it, emit an empty table.
3371 emitEndOfLineMatrix(1);
3373 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3376 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3378 void DwarfDebug::emitCommonDebugFrame() {
3379 if (!Asm->MAI->doesDwarfRequireFrameSection())
3382 int stackGrowth = Asm->getTargetData().getPointerSize();
3383 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3384 TargetFrameInfo::StackGrowsDown)
3387 // Start the dwarf frame section.
3388 Asm->OutStreamer.SwitchSection(
3389 Asm->getObjFileLowering().getDwarfFrameSection());
3391 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3392 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3393 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3394 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3396 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3397 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3398 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3399 Asm->OutStreamer.AddComment("CIE Version");
3400 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3401 Asm->OutStreamer.AddComment("CIE Augmentation");
3402 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3403 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3404 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3405 Asm->OutStreamer.AddComment("CIE RA Column");
3406 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3407 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3409 std::vector<MachineMove> Moves;
3410 RI->getInitialFrameState(Moves);
3412 Asm->EmitFrameMoves(Moves, 0, false);
3414 Asm->EmitAlignment(2);
3415 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3418 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3421 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3422 if (!Asm->MAI->doesDwarfRequireFrameSection())
3425 // Start the dwarf frame section.
3426 Asm->OutStreamer.SwitchSection(
3427 Asm->getObjFileLowering().getDwarfFrameSection());
3429 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3430 MCSymbol *DebugFrameBegin =
3431 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3432 MCSymbol *DebugFrameEnd =
3433 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3434 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3436 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3438 Asm->OutStreamer.AddComment("FDE CIE offset");
3439 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3440 DwarfFrameSectionSym);
3442 Asm->OutStreamer.AddComment("FDE initial location");
3443 MCSymbol *FuncBeginSym =
3444 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3445 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3446 Asm->getTargetData().getPointerSize(),
3450 Asm->OutStreamer.AddComment("FDE address range");
3451 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3452 FuncBeginSym, Asm->getTargetData().getPointerSize());
3454 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3456 Asm->EmitAlignment(2);
3457 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3460 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3462 void DwarfDebug::emitDebugPubNames() {
3463 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3464 E = CUMap.end(); I != E; ++I) {
3465 CompileUnit *TheCU = I->second;
3466 // Start the dwarf pubnames section.
3467 Asm->OutStreamer.SwitchSection(
3468 Asm->getObjFileLowering().getDwarfPubNamesSection());
3470 Asm->OutStreamer.AddComment("Length of Public Names Info");
3471 Asm->EmitLabelDifference(
3472 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3473 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3475 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3478 Asm->OutStreamer.AddComment("DWARF Version");
3479 Asm->EmitInt16(dwarf::DWARF_VERSION);
3481 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3482 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3483 DwarfInfoSectionSym);
3485 Asm->OutStreamer.AddComment("Compilation Unit Length");
3486 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3487 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3490 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3491 for (StringMap<DIE*>::const_iterator
3492 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3493 const char *Name = GI->getKeyData();
3494 DIE *Entity = GI->second;
3496 Asm->OutStreamer.AddComment("DIE offset");
3497 Asm->EmitInt32(Entity->getOffset());
3499 if (Asm->isVerbose())
3500 Asm->OutStreamer.AddComment("External Name");
3501 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3504 Asm->OutStreamer.AddComment("End Mark");
3506 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3511 void DwarfDebug::emitDebugPubTypes() {
3512 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3513 E = CUMap.end(); I != E; ++I) {
3514 CompileUnit *TheCU = I->second;
3515 // Start the dwarf pubnames section.
3516 Asm->OutStreamer.SwitchSection(
3517 Asm->getObjFileLowering().getDwarfPubTypesSection());
3518 Asm->OutStreamer.AddComment("Length of Public Types Info");
3519 Asm->EmitLabelDifference(
3520 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3521 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3523 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3526 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3527 Asm->EmitInt16(dwarf::DWARF_VERSION);
3529 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3530 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3531 DwarfInfoSectionSym);
3533 Asm->OutStreamer.AddComment("Compilation Unit Length");
3534 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3535 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3538 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3539 for (StringMap<DIE*>::const_iterator
3540 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3541 const char *Name = GI->getKeyData();
3542 DIE * Entity = GI->second;
3544 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3545 Asm->EmitInt32(Entity->getOffset());
3547 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3548 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3551 Asm->OutStreamer.AddComment("End Mark");
3553 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3558 /// emitDebugStr - Emit visible names into a debug str section.
3560 void DwarfDebug::emitDebugStr() {
3561 // Check to see if it is worth the effort.
3562 if (StringPool.empty()) return;
3564 // Start the dwarf str section.
3565 Asm->OutStreamer.SwitchSection(
3566 Asm->getObjFileLowering().getDwarfStrSection());
3568 // Get all of the string pool entries and put them in an array by their ID so
3569 // we can sort them.
3570 SmallVector<std::pair<unsigned,
3571 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3573 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3574 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3575 Entries.push_back(std::make_pair(I->second.second, &*I));
3577 array_pod_sort(Entries.begin(), Entries.end());
3579 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3580 // Emit a label for reference from debug information entries.
3581 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3583 // Emit the string itself.
3584 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3588 /// emitDebugLoc - Emit visible names into a debug loc section.
3590 void DwarfDebug::emitDebugLoc() {
3591 if (DotDebugLocEntries.empty())
3594 // Start the dwarf loc section.
3595 Asm->OutStreamer.SwitchSection(
3596 Asm->getObjFileLowering().getDwarfLocSection());
3597 unsigned char Size = Asm->getTargetData().getPointerSize();
3598 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3600 for (SmallVector<DotDebugLocEntry, 4>::iterator I = DotDebugLocEntries.begin(),
3601 E = DotDebugLocEntries.end(); I != E; ++I, ++index) {
3602 DotDebugLocEntry Entry = *I;
3603 if (Entry.isEmpty()) {
3604 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3605 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3606 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3608 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3609 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3610 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3611 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3613 Asm->OutStreamer.AddComment("Loc expr size");
3615 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3617 Asm->OutStreamer.AddComment("Loc expr size");
3618 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3619 Asm->EmitInt8(dwarf::DW_OP_regx);
3620 Asm->EmitULEB128(Reg);
3626 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3628 void DwarfDebug::EmitDebugARanges() {
3629 // Start the dwarf aranges section.
3630 Asm->OutStreamer.SwitchSection(
3631 Asm->getObjFileLowering().getDwarfARangesSection());
3634 /// emitDebugRanges - Emit visible names into a debug ranges section.
3636 void DwarfDebug::emitDebugRanges() {
3637 // Start the dwarf ranges section.
3638 Asm->OutStreamer.SwitchSection(
3639 Asm->getObjFileLowering().getDwarfRangesSection());
3640 unsigned char Size = Asm->getTargetData().getPointerSize();
3641 for (SmallVector<const MCSymbol *, 8>::iterator
3642 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3645 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3647 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3651 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3653 void DwarfDebug::emitDebugMacInfo() {
3654 if (const MCSection *LineInfo =
3655 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3656 // Start the dwarf macinfo section.
3657 Asm->OutStreamer.SwitchSection(LineInfo);
3661 /// emitDebugInlineInfo - Emit inline info using following format.
3663 /// 1. length of section
3664 /// 2. Dwarf version number
3665 /// 3. address size.
3667 /// Entries (one "entry" for each function that was inlined):
3669 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3670 /// otherwise offset into __debug_str for regular function name.
3671 /// 2. offset into __debug_str section for regular function name.
3672 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3673 /// instances for the function.
3675 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3676 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3677 /// __debug_info section, and the low_pc is the starting address for the
3678 /// inlining instance.
3679 void DwarfDebug::emitDebugInlineInfo() {
3680 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3686 Asm->OutStreamer.SwitchSection(
3687 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3689 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3690 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3691 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3693 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3695 Asm->OutStreamer.AddComment("Dwarf Version");
3696 Asm->EmitInt16(dwarf::DWARF_VERSION);
3697 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3698 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3700 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3701 E = InlinedSPNodes.end(); I != E; ++I) {
3703 const MDNode *Node = *I;
3704 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3705 = InlineInfo.find(Node);
3706 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3707 DISubprogram SP(Node);
3708 StringRef LName = SP.getLinkageName();
3709 StringRef Name = SP.getName();
3711 Asm->OutStreamer.AddComment("MIPS linkage name");
3712 if (LName.empty()) {
3713 Asm->OutStreamer.EmitBytes(Name, 0);
3714 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3716 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3717 DwarfStrSectionSym);
3719 Asm->OutStreamer.AddComment("Function name");
3720 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3721 Asm->EmitULEB128(Labels.size(), "Inline count");
3723 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3724 LE = Labels.end(); LI != LE; ++LI) {
3725 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3726 Asm->EmitInt32(LI->second->getOffset());
3728 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3729 Asm->OutStreamer.EmitSymbolValue(LI->first,
3730 Asm->getTargetData().getPointerSize(),0);
3734 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));