1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
49 cl::desc("Disable debug info printing"));
51 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58 } // end anonymous namespace
60 //===----------------------------------------------------------------------===//
62 /// Configuration values for initial hash set sizes (log2).
64 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
68 //===----------------------------------------------------------------------===//
69 /// CompileUnit - This dwarf writer support class manages information associate
70 /// with a source file.
72 /// ID - File identifier for source.
76 /// Die - Compile unit debug information entry.
78 const OwningPtr<DIE> CUDie;
80 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
83 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
84 /// variables to debug information entries.
85 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
87 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
89 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
91 /// Globals - A map of globally visible named entities for this unit.
93 StringMap<DIE*> Globals;
95 /// GlobalTypes - A map of globally visible types for this unit.
97 StringMap<DIE*> GlobalTypes;
100 CompileUnit(unsigned I, DIE *D)
101 : ID(I), CUDie(D), IndexTyDie(0) {}
104 unsigned getID() const { return ID; }
105 DIE* getCUDie() const { return CUDie.get(); }
106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
109 /// hasContent - Return true if this compile unit has something to write out.
111 bool hasContent() const { return !CUDie->getChildren().empty(); }
113 /// addGlobal - Add a new global entity to the compile unit.
115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
117 /// addGlobalType - Add a new global type to the compile unit.
119 void addGlobalType(StringRef Name, DIE *Die) {
120 GlobalTypes[Name] = Die;
123 /// getDIE - Returns the debug information entry map slot for the
124 /// specified debug variable.
125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
127 /// insertDIE - Insert DIE into the map.
128 void insertDIE(const MDNode *N, DIE *D) {
129 MDNodeToDieMap.insert(std::make_pair(N, D));
132 /// getDIEEntry - Returns the debug information entry for the speciefied
134 DIEEntry *getDIEEntry(const MDNode *N) {
135 DenseMap<const MDNode *, DIEEntry *>::iterator I =
136 MDNodeToDIEEntryMap.find(N);
137 if (I == MDNodeToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 DIE *TheDIE; // Variable DIE.
172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
174 // AbsVar may be NULL.
175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
178 DIVariable getVariable() const { return Var; }
179 void setDIE(DIE *D) { TheDIE = D; }
180 DIE *getDIE() const { return TheDIE; }
181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
185 //===----------------------------------------------------------------------===//
186 /// DbgRange - This is used to track range of instructions with identical
187 /// debug info scope.
189 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
191 //===----------------------------------------------------------------------===//
192 /// DbgScope - This class is used to track scope information.
195 DbgScope *Parent; // Parent to this scope.
196 DIDescriptor Desc; // Debug info descriptor for scope.
197 // Location at which this scope is inlined.
198 AssertingVH<const MDNode> InlinedAtLocation;
199 bool AbstractScope; // Abstract Scope
200 const MachineInstr *LastInsn; // Last instruction of this scope.
201 const MachineInstr *FirstInsn; // First instruction of this scope.
202 unsigned DFSIn, DFSOut;
203 // Scopes defined in scope. Contents not owned.
204 SmallVector<DbgScope *, 4> Scopes;
205 // Variables declared in scope. Contents owned.
206 SmallVector<DbgVariable *, 8> Variables;
207 SmallVector<DbgRange, 4> Ranges;
208 // Private state for dump()
209 mutable unsigned IndentLevel;
211 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
212 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
213 LastInsn(0), FirstInsn(0),
214 DFSIn(0), DFSOut(0), IndentLevel(0) {}
218 DbgScope *getParent() const { return Parent; }
219 void setParent(DbgScope *P) { Parent = P; }
220 DIDescriptor getDesc() const { return Desc; }
221 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
222 const MDNode *getScopeNode() const { return Desc; }
223 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
224 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
225 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
227 /// openInsnRange - This scope covers instruction range starting from MI.
228 void openInsnRange(const MachineInstr *MI) {
233 Parent->openInsnRange(MI);
236 /// extendInsnRange - Extend the current instruction range covered by
238 void extendInsnRange(const MachineInstr *MI) {
239 assert (FirstInsn && "MI Range is not open!");
242 Parent->extendInsnRange(MI);
245 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
246 /// until now. This is used when a new scope is encountered while walking
247 /// machine instructions.
248 void closeInsnRange(DbgScope *NewScope = NULL) {
249 assert (LastInsn && "Last insn missing!");
250 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
253 // If Parent dominates NewScope then do not close Parent's instruction
255 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
256 Parent->closeInsnRange(NewScope);
259 void setAbstractScope() { AbstractScope = true; }
260 bool isAbstractScope() const { return AbstractScope; }
262 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
263 unsigned getDFSOut() const { return DFSOut; }
264 void setDFSOut(unsigned O) { DFSOut = O; }
265 unsigned getDFSIn() const { return DFSIn; }
266 void setDFSIn(unsigned I) { DFSIn = I; }
267 bool dominates(const DbgScope *S) {
270 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
275 /// addScope - Add a scope to the scope.
277 void addScope(DbgScope *S) { Scopes.push_back(S); }
279 /// addVariable - Add a variable to the scope.
281 void addVariable(DbgVariable *V) { Variables.push_back(V); }
288 } // end llvm namespace
291 void DbgScope::dump() const {
292 raw_ostream &err = dbgs();
293 err.indent(IndentLevel);
294 const MDNode *N = Desc;
297 err << "Abstract Scope\n";
301 err << "Children ...\n";
302 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
303 if (Scopes[i] != this)
310 DbgScope::~DbgScope() {
311 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
315 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
316 : Asm(A), MMI(Asm->MMI), FirstCU(0),
317 AbbreviationsSet(InitAbbreviationsSetSize),
318 CurrentFnDbgScope(0), PrevLabel(NULL) {
319 NextStringPoolNumber = 0;
321 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
322 DwarfStrSectionSym = TextSectionSym = 0;
323 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
324 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
325 FunctionBeginSym = FunctionEndSym = 0;
326 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
328 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
332 DwarfDebug::~DwarfDebug() {
333 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
334 DIEBlocks[j]->~DIEBlock();
337 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
338 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
339 if (Entry.first) return Entry.first;
341 Entry.second = NextStringPoolNumber++;
342 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
346 /// assignAbbrevNumber - Define a unique number for the abbreviation.
348 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
349 // Profile the node so that we can make it unique.
353 // Check the set for priors.
354 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
356 // If it's newly added.
357 if (InSet == &Abbrev) {
358 // Add to abbreviation list.
359 Abbreviations.push_back(&Abbrev);
361 // Assign the vector position + 1 as its number.
362 Abbrev.setNumber(Abbreviations.size());
364 // Assign existing abbreviation number.
365 Abbrev.setNumber(InSet->getNumber());
369 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
370 /// information entry.
371 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
372 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
376 /// addUInt - Add an unsigned integer attribute data and value.
378 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
379 unsigned Form, uint64_t Integer) {
380 if (!Form) Form = DIEInteger::BestForm(false, Integer);
381 DIEValue *Value = Integer == 1 ?
382 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
383 Die->addValue(Attribute, Form, Value);
386 /// addSInt - Add an signed integer attribute data and value.
388 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
389 unsigned Form, int64_t Integer) {
390 if (!Form) Form = DIEInteger::BestForm(true, Integer);
391 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
392 Die->addValue(Attribute, Form, Value);
395 /// addString - Add a string attribute data and value. DIEString only
396 /// keeps string reference.
397 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
399 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
400 Die->addValue(Attribute, Form, Value);
403 /// addLabel - Add a Dwarf label attribute data and value.
405 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
406 const MCSymbol *Label) {
407 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
408 Die->addValue(Attribute, Form, Value);
411 /// addDelta - Add a label delta attribute data and value.
413 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
414 const MCSymbol *Hi, const MCSymbol *Lo) {
415 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
416 Die->addValue(Attribute, Form, Value);
419 /// addDIEEntry - Add a DIE attribute data and value.
421 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
423 Die->addValue(Attribute, Form, createDIEEntry(Entry));
427 /// addBlock - Add block data.
429 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
431 Block->ComputeSize(Asm);
432 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
433 Die->addValue(Attribute, Block->BestForm(), Block);
436 /// addSourceLine - Add location information to specified debug information
438 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
443 unsigned Line = V->getLineNumber();
444 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
445 V->getContext().getFilename());
446 assert(FileID && "Invalid file id");
447 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
448 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
451 /// addSourceLine - Add location information to specified debug information
453 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
454 // Verify global variable.
458 unsigned Line = G->getLineNumber();
459 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
460 G->getContext().getFilename());
461 assert(FileID && "Invalid file id");
462 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
463 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
466 /// addSourceLine - Add location information to specified debug information
468 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
469 // Verify subprogram.
472 // If the line number is 0, don't add it.
473 if (SP->getLineNumber() == 0)
476 unsigned Line = SP->getLineNumber();
477 if (!SP->getContext().Verify())
479 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
481 assert(FileID && "Invalid file id");
482 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
483 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
486 /// addSourceLine - Add location information to specified debug information
488 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
493 unsigned Line = Ty->getLineNumber();
494 if (!Ty->getContext().Verify())
496 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
497 Ty->getContext().getFilename());
498 assert(FileID && "Invalid file id");
499 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
500 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
503 /// addSourceLine - Add location information to specified debug information
505 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
510 unsigned Line = NS->getLineNumber();
511 StringRef FN = NS->getFilename();
512 StringRef Dir = NS->getDirectory();
514 unsigned FileID = GetOrCreateSourceID(Dir, FN);
515 assert(FileID && "Invalid file id");
516 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
517 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
520 /* Byref variables, in Blocks, are declared by the programmer as
521 "SomeType VarName;", but the compiler creates a
522 __Block_byref_x_VarName struct, and gives the variable VarName
523 either the struct, or a pointer to the struct, as its type. This
524 is necessary for various behind-the-scenes things the compiler
525 needs to do with by-reference variables in blocks.
527 However, as far as the original *programmer* is concerned, the
528 variable should still have type 'SomeType', as originally declared.
530 The following function dives into the __Block_byref_x_VarName
531 struct to find the original type of the variable. This will be
532 passed back to the code generating the type for the Debug
533 Information Entry for the variable 'VarName'. 'VarName' will then
534 have the original type 'SomeType' in its debug information.
536 The original type 'SomeType' will be the type of the field named
537 'VarName' inside the __Block_byref_x_VarName struct.
539 NOTE: In order for this to not completely fail on the debugger
540 side, the Debug Information Entry for the variable VarName needs to
541 have a DW_AT_location that tells the debugger how to unwind through
542 the pointers and __Block_byref_x_VarName struct to find the actual
543 value of the variable. The function addBlockByrefType does this. */
545 /// Find the type the programmer originally declared the variable to be
546 /// and return that type.
548 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
551 unsigned tag = Ty.getTag();
553 if (tag == dwarf::DW_TAG_pointer_type) {
554 DIDerivedType DTy = DIDerivedType(Ty);
555 subType = DTy.getTypeDerivedFrom();
558 DICompositeType blockStruct = DICompositeType(subType);
559 DIArray Elements = blockStruct.getTypeArray();
561 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
562 DIDescriptor Element = Elements.getElement(i);
563 DIDerivedType DT = DIDerivedType(Element);
564 if (Name == DT.getName())
565 return (DT.getTypeDerivedFrom());
571 /// addComplexAddress - Start with the address based on the location provided,
572 /// and generate the DWARF information necessary to find the actual variable
573 /// given the extra address information encoded in the DIVariable, starting from
574 /// the starting location. Add the DWARF information to the die.
576 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
578 const MachineLocation &Location) {
579 const DIVariable &VD = DV->getVariable();
580 DIType Ty = VD.getType();
582 // Decode the original location, and use that as the start of the byref
583 // variable's location.
584 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
585 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
586 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
588 if (Location.isReg()) {
590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
592 Reg = Reg - dwarf::DW_OP_reg0;
593 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
594 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
598 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
600 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
601 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
604 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
607 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
608 uint64_t Element = VD.getAddrElement(i);
610 if (Element == DIFactory::OpPlus) {
611 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
612 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
613 } else if (Element == DIFactory::OpDeref) {
614 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
615 } else llvm_unreachable("unknown DIFactory Opcode");
618 // Now attach the location information to the DIE.
619 addBlock(Die, Attribute, 0, Block);
622 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
623 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
624 gives the variable VarName either the struct, or a pointer to the struct, as
625 its type. This is necessary for various behind-the-scenes things the
626 compiler needs to do with by-reference variables in Blocks.
628 However, as far as the original *programmer* is concerned, the variable
629 should still have type 'SomeType', as originally declared.
631 The function getBlockByrefType dives into the __Block_byref_x_VarName
632 struct to find the original type of the variable, which is then assigned to
633 the variable's Debug Information Entry as its real type. So far, so good.
634 However now the debugger will expect the variable VarName to have the type
635 SomeType. So we need the location attribute for the variable to be an
636 expression that explains to the debugger how to navigate through the
637 pointers and struct to find the actual variable of type SomeType.
639 The following function does just that. We start by getting
640 the "normal" location for the variable. This will be the location
641 of either the struct __Block_byref_x_VarName or the pointer to the
642 struct __Block_byref_x_VarName.
644 The struct will look something like:
646 struct __Block_byref_x_VarName {
648 struct __Block_byref_x_VarName *forwarding;
649 ... <various other fields>
651 ... <maybe more fields>
654 If we are given the struct directly (as our starting point) we
655 need to tell the debugger to:
657 1). Add the offset of the forwarding field.
659 2). Follow that pointer to get the real __Block_byref_x_VarName
660 struct to use (the real one may have been copied onto the heap).
662 3). Add the offset for the field VarName, to find the actual variable.
664 If we started with a pointer to the struct, then we need to
665 dereference that pointer first, before the other steps.
666 Translating this into DWARF ops, we will need to append the following
667 to the current location description for the variable:
669 DW_OP_deref -- optional, if we start with a pointer
670 DW_OP_plus_uconst <forward_fld_offset>
672 DW_OP_plus_uconst <varName_fld_offset>
674 That is what this function does. */
676 /// addBlockByrefAddress - Start with the address based on the location
677 /// provided, and generate the DWARF information necessary to find the
678 /// actual Block variable (navigating the Block struct) based on the
679 /// starting location. Add the DWARF information to the die. For
680 /// more information, read large comment just above here.
682 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
684 const MachineLocation &Location) {
685 const DIVariable &VD = DV->getVariable();
686 DIType Ty = VD.getType();
688 unsigned Tag = Ty.getTag();
689 bool isPointer = false;
691 StringRef varName = VD.getName();
693 if (Tag == dwarf::DW_TAG_pointer_type) {
694 DIDerivedType DTy = DIDerivedType(Ty);
695 TmpTy = DTy.getTypeDerivedFrom();
699 DICompositeType blockStruct = DICompositeType(TmpTy);
701 // Find the __forwarding field and the variable field in the __Block_byref
703 DIArray Fields = blockStruct.getTypeArray();
704 DIDescriptor varField = DIDescriptor();
705 DIDescriptor forwardingField = DIDescriptor();
707 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
708 DIDescriptor Element = Fields.getElement(i);
709 DIDerivedType DT = DIDerivedType(Element);
710 StringRef fieldName = DT.getName();
711 if (fieldName == "__forwarding")
712 forwardingField = Element;
713 else if (fieldName == varName)
717 // Get the offsets for the forwarding field and the variable field.
718 unsigned forwardingFieldOffset =
719 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
720 unsigned varFieldOffset =
721 DIDerivedType(varField).getOffsetInBits() >> 3;
723 // Decode the original location, and use that as the start of the byref
724 // variable's location.
725 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
726 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
727 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
729 if (Location.isReg()) {
731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
733 Reg = Reg - dwarf::DW_OP_reg0;
734 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
741 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
742 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
745 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
748 // If we started with a pointer to the __Block_byref... struct, then
749 // the first thing we need to do is dereference the pointer (DW_OP_deref).
751 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
753 // Next add the offset for the '__forwarding' field:
754 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
755 // adding the offset if it's 0.
756 if (forwardingFieldOffset > 0) {
757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
758 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
761 // Now dereference the __forwarding field to get to the real __Block_byref
762 // struct: DW_OP_deref.
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
765 // Now that we've got the real __Block_byref... struct, add the offset
766 // for the variable's field to get to the location of the actual variable:
767 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
768 if (varFieldOffset > 0) {
769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
770 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
773 // Now attach the location information to the DIE.
774 addBlock(Die, Attribute, 0, Block);
777 /// addAddress - Add an address attribute to a die based on the location
779 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
780 const MachineLocation &Location) {
781 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
782 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
783 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
785 if (Location.isReg()) {
787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
790 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
794 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
796 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
797 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
800 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
803 addBlock(Die, Attribute, 0, Block);
806 /// addRegisterAddress - Add register location entry in variable DIE.
807 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
808 const MachineOperand &MO) {
809 assert (MO.isReg() && "Invalid machine operand!");
812 MachineLocation Location;
813 Location.set(MO.getReg());
814 addAddress(Die, dwarf::DW_AT_location, Location);
816 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
820 /// addConstantValue - Add constant value entry in variable DIE.
821 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
822 const MachineOperand &MO) {
823 assert (MO.isImm() && "Invalid machine operand!");
824 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
825 unsigned Imm = MO.getImm();
826 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
827 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
829 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
833 /// addConstantFPValue - Add constant value entry in variable DIE.
834 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
835 const MachineOperand &MO) {
836 assert (MO.isFPImm() && "Invalid machine operand!");
837 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
838 APFloat FPImm = MO.getFPImm()->getValueAPF();
840 // Get the raw data form of the floating point.
841 const APInt FltVal = FPImm.bitcastToAPInt();
842 const char *FltPtr = (const char*)FltVal.getRawData();
844 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
845 bool LittleEndian = Asm->getTargetData().isLittleEndian();
846 int Incr = (LittleEndian ? 1 : -1);
847 int Start = (LittleEndian ? 0 : NumBytes - 1);
848 int Stop = (LittleEndian ? NumBytes : -1);
850 // Output the constant to DWARF one byte at a time.
851 for (; Start != Stop; Start += Incr)
852 addUInt(Block, 0, dwarf::DW_FORM_data1,
853 (unsigned char)0xFF & FltPtr[Start]);
855 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
857 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
862 /// addToContextOwner - Add Die into the list of its context owner's children.
863 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
864 if (Context.isType()) {
865 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
866 ContextDIE->addChild(Die);
867 } else if (Context.isNameSpace()) {
868 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
869 ContextDIE->addChild(Die);
870 } else if (Context.isSubprogram()) {
871 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
873 ContextDIE->addChild(Die);
874 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
875 ContextDIE->addChild(Die);
877 getCompileUnit(Context)->addDie(Die);
880 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
882 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
883 CompileUnit *TypeCU = getCompileUnit(Ty);
884 DIE *TyDIE = TypeCU->getDIE(Ty);
889 TyDIE = new DIE(dwarf::DW_TAG_base_type);
890 TypeCU->insertDIE(Ty, TyDIE);
891 if (Ty.isBasicType())
892 constructTypeDIE(*TyDIE, DIBasicType(Ty));
893 else if (Ty.isCompositeType())
894 constructTypeDIE(*TyDIE, DICompositeType(Ty));
896 assert(Ty.isDerivedType() && "Unknown kind of DIType");
897 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
900 addToContextOwner(TyDIE, Ty.getContext());
904 /// addType - Add a new type attribute to the specified entity.
905 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
909 // Check for pre-existence.
910 CompileUnit *TypeCU = getCompileUnit(Ty);
911 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
912 // If it exists then use the existing value.
914 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
919 DIE *Buffer = getOrCreateTypeDIE(Ty);
922 Entry = createDIEEntry(Buffer);
923 TypeCU->insertDIEEntry(Ty, Entry);
925 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
928 /// constructTypeDIE - Construct basic type die from DIBasicType.
929 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
930 // Get core information.
931 StringRef Name = BTy.getName();
932 Buffer.setTag(dwarf::DW_TAG_base_type);
933 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
936 // Add name if not anonymous or intermediate type.
938 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
939 uint64_t Size = BTy.getSizeInBits() >> 3;
940 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
943 /// constructTypeDIE - Construct derived type die from DIDerivedType.
944 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
945 // Get core information.
946 StringRef Name = DTy.getName();
947 uint64_t Size = DTy.getSizeInBits() >> 3;
948 unsigned Tag = DTy.getTag();
950 // FIXME - Workaround for templates.
951 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
955 // Map to main type, void will not have a type.
956 DIType FromTy = DTy.getTypeDerivedFrom();
957 addType(&Buffer, FromTy);
959 // Add name if not anonymous or intermediate type.
961 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
963 // Add size if non-zero (derived types might be zero-sized.)
965 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
967 // Add source line info if available and TyDesc is not a forward declaration.
968 if (!DTy.isForwardDecl())
969 addSourceLine(&Buffer, &DTy);
972 /// constructTypeDIE - Construct type DIE from DICompositeType.
973 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
974 // Get core information.
975 StringRef Name = CTy.getName();
977 uint64_t Size = CTy.getSizeInBits() >> 3;
978 unsigned Tag = CTy.getTag();
982 case dwarf::DW_TAG_vector_type:
983 case dwarf::DW_TAG_array_type:
984 constructArrayTypeDIE(Buffer, &CTy);
986 case dwarf::DW_TAG_enumeration_type: {
987 DIArray Elements = CTy.getTypeArray();
989 // Add enumerators to enumeration type.
990 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
992 DIDescriptor Enum(Elements.getElement(i));
993 if (Enum.isEnumerator()) {
994 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
995 Buffer.addChild(ElemDie);
1000 case dwarf::DW_TAG_subroutine_type: {
1002 DIArray Elements = CTy.getTypeArray();
1003 DIDescriptor RTy = Elements.getElement(0);
1004 addType(&Buffer, DIType(RTy));
1006 // Add prototype flag.
1007 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1010 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1011 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1012 DIDescriptor Ty = Elements.getElement(i);
1013 addType(Arg, DIType(Ty));
1014 Buffer.addChild(Arg);
1018 case dwarf::DW_TAG_structure_type:
1019 case dwarf::DW_TAG_union_type:
1020 case dwarf::DW_TAG_class_type: {
1021 // Add elements to structure type.
1022 DIArray Elements = CTy.getTypeArray();
1024 // A forward struct declared type may not have elements available.
1025 unsigned N = Elements.getNumElements();
1029 // Add elements to structure type.
1030 for (unsigned i = 0; i < N; ++i) {
1031 DIDescriptor Element = Elements.getElement(i);
1032 DIE *ElemDie = NULL;
1033 if (Element.isSubprogram())
1034 ElemDie = createSubprogramDIE(DISubprogram(Element));
1035 else if (Element.isVariable()) {
1036 DIVariable DV(Element);
1037 ElemDie = new DIE(dwarf::DW_TAG_variable);
1038 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1040 addType(ElemDie, DV.getType());
1041 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1042 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1043 addSourceLine(ElemDie, &DV);
1044 } else if (Element.isDerivedType())
1045 ElemDie = createMemberDIE(DIDerivedType(Element));
1048 Buffer.addChild(ElemDie);
1051 if (CTy.isAppleBlockExtension())
1052 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1054 unsigned RLang = CTy.getRunTimeLang();
1056 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1057 dwarf::DW_FORM_data1, RLang);
1059 DICompositeType ContainingType = CTy.getContainingType();
1060 if (DIDescriptor(ContainingType).isCompositeType())
1061 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1062 getOrCreateTypeDIE(DIType(ContainingType)));
1064 DIDescriptor Context = CTy.getContext();
1065 addToContextOwner(&Buffer, Context);
1073 // Add name if not anonymous or intermediate type.
1075 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1077 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1078 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1080 // Add size if non-zero (derived types might be zero-sized.)
1082 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1084 // Add zero size if it is not a forward declaration.
1085 if (CTy.isForwardDecl())
1086 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1088 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1091 // Add source line info if available.
1092 if (!CTy.isForwardDecl())
1093 addSourceLine(&Buffer, &CTy);
1097 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1098 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1099 int64_t L = SR.getLo();
1100 int64_t H = SR.getHi();
1101 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1103 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1105 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1106 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1108 Buffer.addChild(DW_Subrange);
1111 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1112 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1113 DICompositeType *CTy) {
1114 Buffer.setTag(dwarf::DW_TAG_array_type);
1115 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1116 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1118 // Emit derived type.
1119 addType(&Buffer, CTy->getTypeDerivedFrom());
1120 DIArray Elements = CTy->getTypeArray();
1122 // Get an anonymous type for index type.
1123 CompileUnit *TheCU = getCompileUnit(*CTy);
1124 DIE *IdxTy = TheCU->getIndexTyDie();
1126 // Construct an anonymous type for index type.
1127 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1128 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1129 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1130 dwarf::DW_ATE_signed);
1131 TheCU->addDie(IdxTy);
1132 TheCU->setIndexTyDie(IdxTy);
1135 // Add subranges to array type.
1136 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1137 DIDescriptor Element = Elements.getElement(i);
1138 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1139 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1143 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1144 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1145 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1146 StringRef Name = ETy.getName();
1147 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1148 int64_t Value = ETy.getEnumValue();
1149 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1153 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1154 /// printer to not emit usual symbol prefix before the symbol name is used then
1155 /// return linkage name after skipping this special LLVM prefix.
1156 static StringRef getRealLinkageName(StringRef LinkageName) {
1158 if (LinkageName.startswith(StringRef(&One, 1)))
1159 return LinkageName.substr(1);
1163 /// createGlobalVariableDIE - Create new DIE using GV.
1164 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1165 // If the global variable was optmized out then no need to create debug info
1167 if (!GV.getGlobal()) return NULL;
1168 if (GV.getDisplayName().empty()) return NULL;
1170 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1171 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1172 GV.getDisplayName());
1174 StringRef LinkageName = GV.getLinkageName();
1175 if (!LinkageName.empty())
1176 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1177 getRealLinkageName(LinkageName));
1179 addType(GVDie, GV.getType());
1180 if (!GV.isLocalToUnit())
1181 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1182 addSourceLine(GVDie, &GV);
1187 /// createMemberDIE - Create new member DIE.
1188 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1189 DIE *MemberDie = new DIE(DT.getTag());
1190 StringRef Name = DT.getName();
1192 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1194 addType(MemberDie, DT.getTypeDerivedFrom());
1196 addSourceLine(MemberDie, &DT);
1198 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1199 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1201 uint64_t Size = DT.getSizeInBits();
1202 uint64_t FieldSize = DT.getOriginalTypeSize();
1204 if (Size != FieldSize) {
1206 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1207 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1209 uint64_t Offset = DT.getOffsetInBits();
1210 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1211 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1212 uint64_t FieldOffset = (HiMark - FieldSize);
1213 Offset -= FieldOffset;
1215 // Maybe we need to work from the other end.
1216 if (Asm->getTargetData().isLittleEndian())
1217 Offset = FieldSize - (Offset + Size);
1218 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1220 // Here WD_AT_data_member_location points to the anonymous
1221 // field that includes this bit field.
1222 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1225 // This is not a bitfield.
1226 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1228 if (DT.getTag() == dwarf::DW_TAG_inheritance
1229 && DT.isVirtual()) {
1231 // For C++, virtual base classes are not at fixed offset. Use following
1232 // expression to extract appropriate offset from vtable.
1233 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1235 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1242 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1244 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1247 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1249 if (DT.isProtected())
1250 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1251 dwarf::DW_ACCESS_protected);
1252 else if (DT.isPrivate())
1253 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1254 dwarf::DW_ACCESS_private);
1255 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1256 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1257 dwarf::DW_ACCESS_public);
1259 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1260 dwarf::DW_VIRTUALITY_virtual);
1264 /// createSubprogramDIE - Create new DIE using SP.
1265 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1266 CompileUnit *SPCU = getCompileUnit(SP);
1267 DIE *SPDie = SPCU->getDIE(SP);
1271 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1272 // Constructors and operators for anonymous aggregates do not have names.
1273 if (!SP.getName().empty())
1274 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1276 StringRef LinkageName = SP.getLinkageName();
1277 if (!LinkageName.empty())
1278 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1279 getRealLinkageName(LinkageName));
1281 addSourceLine(SPDie, &SP);
1283 // Add prototyped tag, if C or ObjC.
1284 unsigned Lang = SP.getCompileUnit().getLanguage();
1285 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1286 Lang == dwarf::DW_LANG_ObjC)
1287 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1290 DICompositeType SPTy = SP.getType();
1291 DIArray Args = SPTy.getTypeArray();
1292 unsigned SPTag = SPTy.getTag();
1294 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1295 addType(SPDie, SPTy);
1297 addType(SPDie, DIType(Args.getElement(0)));
1299 unsigned VK = SP.getVirtuality();
1301 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1302 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1303 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1304 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1305 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1306 ContainingTypeMap.insert(std::make_pair(SPDie,
1307 SP.getContainingType()));
1310 if (MakeDecl || !SP.isDefinition()) {
1311 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1313 // Add arguments. Do not add arguments for subprogram definition. They will
1314 // be handled while processing variables.
1315 DICompositeType SPTy = SP.getType();
1316 DIArray Args = SPTy.getTypeArray();
1317 unsigned SPTag = SPTy.getTag();
1319 if (SPTag == dwarf::DW_TAG_subroutine_type)
1320 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1321 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1322 DIType ATy = DIType(DIType(Args.getElement(i)));
1324 if (ATy.isArtificial())
1325 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1326 SPDie->addChild(Arg);
1330 if (SP.isArtificial())
1331 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1333 if (!SP.isLocalToUnit())
1334 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1336 if (SP.isOptimized())
1337 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1339 if (unsigned isa = Asm->getISAEncoding()) {
1340 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1343 // DW_TAG_inlined_subroutine may refer to this DIE.
1344 SPCU->insertDIE(SP, SPDie);
1346 // Add to context owner.
1347 addToContextOwner(SPDie, SP.getContext());
1352 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1353 assert(N && "Invalid Scope encoding!");
1355 DbgScope *AScope = AbstractScopes.lookup(N);
1359 DbgScope *Parent = NULL;
1361 DIDescriptor Scope(N);
1362 if (Scope.isLexicalBlock()) {
1363 DILexicalBlock DB(N);
1364 DIDescriptor ParentDesc = DB.getContext();
1365 Parent = getOrCreateAbstractScope(ParentDesc);
1368 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1371 Parent->addScope(AScope);
1372 AScope->setAbstractScope();
1373 AbstractScopes[N] = AScope;
1374 if (DIDescriptor(N).isSubprogram())
1375 AbstractScopesList.push_back(AScope);
1379 /// isSubprogramContext - Return true if Context is either a subprogram
1380 /// or another context nested inside a subprogram.
1381 static bool isSubprogramContext(const MDNode *Context) {
1384 DIDescriptor D(Context);
1385 if (D.isSubprogram())
1388 return isSubprogramContext(DIType(Context).getContext());
1392 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1393 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1394 /// If there are global variables in this scope then create and insert
1395 /// DIEs for these variables.
1396 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1397 CompileUnit *SPCU = getCompileUnit(SPNode);
1398 DIE *SPDie = SPCU->getDIE(SPNode);
1400 assert(SPDie && "Unable to find subprogram DIE!");
1401 DISubprogram SP(SPNode);
1403 // There is not any need to generate specification DIE for a function
1404 // defined at compile unit level. If a function is defined inside another
1405 // function then gdb prefers the definition at top level and but does not
1406 // expect specification DIE in parent function. So avoid creating
1407 // specification DIE for a function defined inside a function.
1408 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1409 !SP.getContext().isFile() &&
1410 !isSubprogramContext(SP.getContext())) {
1411 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1414 DICompositeType SPTy = SP.getType();
1415 DIArray Args = SPTy.getTypeArray();
1416 unsigned SPTag = SPTy.getTag();
1417 if (SPTag == dwarf::DW_TAG_subroutine_type)
1418 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1419 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1420 DIType ATy = DIType(DIType(Args.getElement(i)));
1422 if (ATy.isArtificial())
1423 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1424 SPDie->addChild(Arg);
1426 DIE *SPDeclDie = SPDie;
1427 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1428 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1430 SPCU->addDie(SPDie);
1433 // Pick up abstract subprogram DIE.
1434 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1435 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1436 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1437 dwarf::DW_FORM_ref4, AbsSPDIE);
1438 SPCU->addDie(SPDie);
1441 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1442 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1443 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1444 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1445 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1446 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1447 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1452 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1453 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1454 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1456 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1457 if (Scope->isAbstractScope())
1460 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1464 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1465 if (Ranges.size() > 1) {
1466 // .debug_range section has not been laid out yet. Emit offset in
1467 // .debug_range as a uint, size 4, for now. emitDIE will handle
1468 // DW_AT_ranges appropriately.
1469 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1470 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1471 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1472 RE = Ranges.end(); RI != RE; ++RI) {
1473 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1474 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1476 DebugRangeSymbols.push_back(NULL);
1477 DebugRangeSymbols.push_back(NULL);
1481 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1482 const MCSymbol *End = getLabelAfterInsn(RI->second);
1484 if (End == 0) return 0;
1486 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1487 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1489 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1490 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1495 /// constructInlinedScopeDIE - This scope represents inlined body of
1496 /// a function. Construct DIE to represent this concrete inlined copy
1497 /// of the function.
1498 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1500 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1501 assert (Ranges.empty() == false
1502 && "DbgScope does not have instruction markers!");
1504 // FIXME : .debug_inlined section specification does not clearly state how
1505 // to emit inlined scope that is split into multiple instruction ranges.
1506 // For now, use first instruction range and emit low_pc/high_pc pair and
1507 // corresponding .debug_inlined section entry for this pair.
1508 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1509 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1510 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1512 if (StartLabel == 0 || EndLabel == 0) {
1513 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1516 assert(StartLabel->isDefined() &&
1517 "Invalid starting label for an inlined scope!");
1518 assert(EndLabel->isDefined() &&
1519 "Invalid end label for an inlined scope!");
1521 if (!Scope->getScopeNode())
1523 DIScope DS(Scope->getScopeNode());
1524 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1526 DISubprogram InlinedSP = getDISubprogram(DS);
1527 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1528 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1529 assert(OriginDIE && "Unable to find Origin DIE!");
1530 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1531 dwarf::DW_FORM_ref4, OriginDIE);
1533 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1534 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1536 InlinedSubprogramDIEs.insert(OriginDIE);
1538 // Track the start label for this inlined function.
1539 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1540 I = InlineInfo.find(InlinedSP);
1542 if (I == InlineInfo.end()) {
1543 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1545 InlinedSPNodes.push_back(InlinedSP);
1547 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1549 DILocation DL(Scope->getInlinedAt());
1550 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1551 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1557 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1558 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1559 // Get the descriptor.
1560 const DIVariable &VD = DV->getVariable();
1561 StringRef Name = VD.getName();
1565 // Translate tag to proper Dwarf tag. The result variable is dropped for
1568 switch (VD.getTag()) {
1569 case dwarf::DW_TAG_return_variable:
1571 case dwarf::DW_TAG_arg_variable:
1572 Tag = dwarf::DW_TAG_formal_parameter;
1574 case dwarf::DW_TAG_auto_variable: // fall thru
1576 Tag = dwarf::DW_TAG_variable;
1580 // Define variable debug information entry.
1581 DIE *VariableDie = new DIE(Tag);
1584 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1585 V2AVI = VarToAbstractVarMap.find(DV);
1586 if (V2AVI != VarToAbstractVarMap.end())
1587 AbsDIE = V2AVI->second->getDIE();
1590 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1591 dwarf::DW_FORM_ref4, AbsDIE);
1593 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1594 addSourceLine(VariableDie, &VD);
1596 // Add variable type.
1597 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1598 // addresses instead.
1599 if (VD.isBlockByrefVariable())
1600 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1602 addType(VariableDie, VD.getType());
1605 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1606 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1608 if (Scope->isAbstractScope()) {
1609 DV->setDIE(VariableDie);
1613 // Add variable address.
1615 unsigned Offset = DV->getDotDebugLocOffset();
1616 if (Offset != ~0U) {
1617 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1618 Asm->GetTempSymbol("debug_loc", Offset));
1619 DV->setDIE(VariableDie);
1620 UseDotDebugLocEntry.insert(VariableDie);
1624 // Check if variable is described by a DBG_VALUE instruction.
1625 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1626 DbgVariableToDbgInstMap.find(DV);
1627 if (DVI != DbgVariableToDbgInstMap.end()) {
1628 const MachineInstr *DVInsn = DVI->second;
1629 const MCSymbol *DVLabel = findVariableLabel(DV);
1630 bool updated = false;
1631 // FIXME : Handle getNumOperands != 3
1632 if (DVInsn->getNumOperands() == 3) {
1633 if (DVInsn->getOperand(0).isReg())
1635 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1636 else if (DVInsn->getOperand(0).isImm())
1637 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1638 else if (DVInsn->getOperand(0).isFPImm())
1640 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1642 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1643 if (Location.getReg()) {
1644 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1646 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1652 // If variableDie is not updated then DBG_VALUE instruction does not
1653 // have valid variable info.
1657 DV->setDIE(VariableDie);
1661 // .. else use frame index, if available.
1662 MachineLocation Location;
1664 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1666 if (findVariableFrameIndex(DV, &FI)) {
1667 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1668 Location.set(FrameReg, Offset);
1670 if (VD.hasComplexAddress())
1671 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1672 else if (VD.isBlockByrefVariable())
1673 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1675 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1677 DV->setDIE(VariableDie);
1682 void DwarfDebug::addPubTypes(DISubprogram SP) {
1683 DICompositeType SPTy = SP.getType();
1684 unsigned SPTag = SPTy.getTag();
1685 if (SPTag != dwarf::DW_TAG_subroutine_type)
1688 DIArray Args = SPTy.getTypeArray();
1689 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1690 DIType ATy(Args.getElement(i));
1693 DICompositeType CATy = getDICompositeType(ATy);
1694 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1695 && !CATy.isForwardDecl()) {
1696 CompileUnit *TheCU = getCompileUnit(CATy);
1697 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1698 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1703 /// constructScopeDIE - Construct a DIE for this scope.
1704 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1705 if (!Scope || !Scope->getScopeNode())
1708 DIScope DS(Scope->getScopeNode());
1709 DIE *ScopeDIE = NULL;
1710 if (Scope->getInlinedAt())
1711 ScopeDIE = constructInlinedScopeDIE(Scope);
1712 else if (DS.isSubprogram()) {
1713 ProcessedSPNodes.insert(DS);
1714 if (Scope->isAbstractScope()) {
1715 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1716 // Note down abstract DIE.
1718 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1721 ScopeDIE = updateSubprogramScopeDIE(DS);
1724 ScopeDIE = constructLexicalScopeDIE(Scope);
1725 if (!ScopeDIE) return NULL;
1727 // Add variables to scope.
1728 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1729 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1730 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1732 ScopeDIE->addChild(VariableDIE);
1735 // Add nested scopes.
1736 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1737 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1738 // Define the Scope debug information entry.
1739 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1741 ScopeDIE->addChild(NestedDIE);
1744 if (DS.isSubprogram())
1745 addPubTypes(DISubprogram(DS));
1750 /// GetOrCreateSourceID - Look up the source id with the given directory and
1751 /// source file names. If none currently exists, create a new id and insert it
1752 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1754 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1756 assert (DirName.empty() == false && "Invalid directory name!");
1758 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1759 if (DI != DirectoryIdMap.end()) {
1760 DId = DI->getValue();
1762 DId = DirectoryNames.size() + 1;
1763 DirectoryIdMap[DirName] = DId;
1764 DirectoryNames.push_back(DirName);
1768 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1769 if (FI != SourceFileIdMap.end()) {
1770 FId = FI->getValue();
1772 FId = SourceFileNames.size() + 1;
1773 SourceFileIdMap[FileName] = FId;
1774 SourceFileNames.push_back(FileName);
1777 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1778 SourceIdMap.find(std::make_pair(DId, FId));
1779 if (SI != SourceIdMap.end())
1782 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1783 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1784 SourceIds.push_back(std::make_pair(DId, FId));
1789 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1790 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1791 CompileUnit *TheCU = getCompileUnit(NS);
1792 DIE *NDie = TheCU->getDIE(NS);
1795 NDie = new DIE(dwarf::DW_TAG_namespace);
1796 TheCU->insertDIE(NS, NDie);
1797 if (!NS.getName().empty())
1798 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1799 addSourceLine(NDie, &NS);
1800 addToContextOwner(NDie, NS.getContext());
1804 /// constructCompileUnit - Create new CompileUnit for the given
1805 /// metadata node with tag DW_TAG_compile_unit.
1806 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1807 DICompileUnit DIUnit(N);
1808 StringRef FN = DIUnit.getFilename();
1809 StringRef Dir = DIUnit.getDirectory();
1810 unsigned ID = GetOrCreateSourceID(Dir, FN);
1812 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1813 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1814 DIUnit.getProducer());
1815 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1816 DIUnit.getLanguage());
1817 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1818 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1819 // simplifies debug range entries.
1820 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1821 // DW_AT_stmt_list is a offset of line number information for this
1822 // compile unit in debug_line section. This offset is calculated
1823 // during endMoudle().
1824 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1827 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1828 if (DIUnit.isOptimized())
1829 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1831 StringRef Flags = DIUnit.getFlags();
1833 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1835 unsigned RVer = DIUnit.getRunTimeVersion();
1837 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1838 dwarf::DW_FORM_data1, RVer);
1840 CompileUnit *NewCU = new CompileUnit(ID, Die);
1843 CUMap.insert(std::make_pair(N, NewCU));
1846 /// getCompielUnit - Get CompileUnit DIE.
1847 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1848 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1850 const MDNode *CUNode = NULL;
1851 if (D.isCompileUnit())
1853 else if (D.isSubprogram())
1854 CUNode = DISubprogram(N).getCompileUnit();
1855 else if (D.isType())
1856 CUNode = DIType(N).getCompileUnit();
1857 else if (D.isGlobalVariable())
1858 CUNode = DIGlobalVariable(N).getCompileUnit();
1859 else if (D.isVariable())
1860 CUNode = DIVariable(N).getCompileUnit();
1861 else if (D.isNameSpace())
1862 CUNode = DINameSpace(N).getCompileUnit();
1863 else if (D.isFile())
1864 CUNode = DIFile(N).getCompileUnit();
1868 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1869 = CUMap.find(CUNode);
1870 if (I == CUMap.end())
1876 /// constructGlobalVariableDIE - Construct global variable DIE.
1877 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1878 DIGlobalVariable DI_GV(N);
1880 // If debug information is malformed then ignore it.
1881 if (DI_GV.Verify() == false)
1884 // Check for pre-existence.
1885 CompileUnit *TheCU = getCompileUnit(N);
1886 if (TheCU->getDIE(DI_GV))
1889 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1894 TheCU->insertDIE(N, VariableDie);
1896 // Add to context owner.
1897 DIDescriptor GVContext = DI_GV.getContext();
1898 // Do not create specification DIE if context is either compile unit
1900 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1901 !GVContext.isFile() &&
1902 !isSubprogramContext(GVContext)) {
1903 // Create specification DIE.
1904 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1905 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1906 dwarf::DW_FORM_ref4, VariableDie);
1907 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1908 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1909 addLabel(Block, 0, dwarf::DW_FORM_udata,
1910 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1911 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1912 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1913 TheCU->addDie(VariableSpecDIE);
1915 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1916 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1917 addLabel(Block, 0, dwarf::DW_FORM_udata,
1918 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1919 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1921 addToContextOwner(VariableDie, GVContext);
1923 // Expose as global. FIXME - need to check external flag.
1924 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1926 DIType GTy = DI_GV.getType();
1927 if (GTy.isCompositeType() && !GTy.getName().empty()
1928 && !GTy.isForwardDecl()) {
1929 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1930 assert(Entry && "Missing global type!");
1931 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1936 /// construct SubprogramDIE - Construct subprogram DIE.
1937 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1940 // Check for pre-existence.
1941 CompileUnit *TheCU = getCompileUnit(N);
1942 if (TheCU->getDIE(N))
1945 if (!SP.isDefinition())
1946 // This is a method declaration which will be handled while constructing
1950 DIE *SubprogramDie = createSubprogramDIE(SP);
1953 TheCU->insertDIE(N, SubprogramDie);
1955 // Add to context owner.
1956 addToContextOwner(SubprogramDie, SP.getContext());
1958 // Expose as global.
1959 TheCU->addGlobal(SP.getName(), SubprogramDie);
1964 /// beginModule - Emit all Dwarf sections that should come prior to the
1965 /// content. Create global DIEs and emit initial debug info sections.
1966 /// This is inovked by the target AsmPrinter.
1967 void DwarfDebug::beginModule(Module *M) {
1968 if (DisableDebugInfoPrinting)
1971 DebugInfoFinder DbgFinder;
1972 DbgFinder.processModule(*M);
1974 bool HasDebugInfo = false;
1976 // Scan all the compile-units to see if there are any marked as the main unit.
1977 // if not, we do not generate debug info.
1978 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1979 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1980 if (DICompileUnit(*I).isMain()) {
1981 HasDebugInfo = true;
1986 if (!HasDebugInfo) return;
1988 // Tell MMI that we have debug info.
1989 MMI->setDebugInfoAvailability(true);
1991 // Emit initial sections.
1992 EmitSectionLabels();
1994 // Create all the compile unit DIEs.
1995 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1996 E = DbgFinder.compile_unit_end(); I != E; ++I)
1997 constructCompileUnit(*I);
1999 // Create DIEs for each subprogram.
2000 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2001 E = DbgFinder.subprogram_end(); I != E; ++I)
2002 constructSubprogramDIE(*I);
2004 // Create DIEs for each global variable.
2005 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2006 E = DbgFinder.global_variable_end(); I != E; ++I)
2007 constructGlobalVariableDIE(*I);
2009 // Prime section data.
2010 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2012 // Print out .file directives to specify files for .loc directives. These are
2013 // printed out early so that they precede any .loc directives.
2014 if (Asm->MAI->hasDotLocAndDotFile()) {
2015 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2016 // Remember source id starts at 1.
2017 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2018 // FIXME: don't use sys::path for this! This should not depend on the
2020 sys::Path FullPath(getSourceDirectoryName(Id.first));
2022 FullPath.appendComponent(getSourceFileName(Id.second));
2023 assert(AppendOk && "Could not append filename to directory!");
2025 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2030 /// endModule - Emit all Dwarf sections that should come after the content.
2032 void DwarfDebug::endModule() {
2033 if (!FirstCU) return;
2034 const Module *M = MMI->getModule();
2035 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2036 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2037 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2038 DISubprogram SP(AllSPs->getOperand(SI));
2039 if (!SP.Verify()) continue;
2041 // Collect info for variables that were optimized out.
2042 if (!SP.isDefinition()) continue;
2043 StringRef FName = SP.getLinkageName();
2045 FName = SP.getName();
2047 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2049 unsigned E = NMD->getNumOperands();
2051 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2052 for (unsigned I = 0; I != E; ++I) {
2053 DIVariable DV(NMD->getOperand(I));
2054 if (!DV.Verify()) continue;
2055 Scope->addVariable(new DbgVariable(DV));
2058 // Construct subprogram DIE and add variables DIEs.
2059 constructSubprogramDIE(SP);
2060 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2061 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2062 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2063 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2065 ScopeDIE->addChild(VariableDIE);
2070 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2071 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2072 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2074 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2077 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2078 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2079 DIE *SPDie = CI->first;
2080 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2082 DIE *NDie = getCompileUnit(N)->getDIE(N);
2083 if (!NDie) continue;
2084 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2087 // Standard sections final addresses.
2088 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2089 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2090 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2091 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2093 // End text sections.
2094 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2095 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2096 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2099 // Emit common frame information.
2100 emitCommonDebugFrame();
2102 // Emit function debug frame information
2103 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2104 E = DebugFrames.end(); I != E; ++I)
2105 emitFunctionDebugFrame(*I);
2107 // Compute DIE offsets and sizes.
2108 computeSizeAndOffsets();
2110 // Emit source line correspondence into a debug line section.
2113 // Emit all the DIEs into a debug info section
2116 // Corresponding abbreviations into a abbrev section.
2117 emitAbbreviations();
2119 // Emit info into a debug pubnames section.
2120 emitDebugPubNames();
2122 // Emit info into a debug pubtypes section.
2123 emitDebugPubTypes();
2125 // Emit info into a debug loc section.
2128 // Emit info into a debug aranges section.
2131 // Emit info into a debug ranges section.
2134 // Emit info into a debug macinfo section.
2137 // Emit inline info.
2138 emitDebugInlineInfo();
2140 // Emit info into a debug str section.
2143 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2144 E = CUMap.end(); I != E; ++I)
2146 FirstCU = NULL; // Reset for the next Module, if any.
2149 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2150 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2151 DebugLoc ScopeLoc) {
2153 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2155 return AbsDbgVariable;
2157 LLVMContext &Ctx = Var->getContext();
2158 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2162 AbsDbgVariable = new DbgVariable(Var);
2163 Scope->addVariable(AbsDbgVariable);
2164 AbstractVariables[Var] = AbsDbgVariable;
2165 return AbsDbgVariable;
2168 /// collectVariableInfoFromMMITable - Collect variable information from
2169 /// side table maintained by MMI.
2171 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2172 SmallPtrSet<const MDNode *, 16> &Processed) {
2173 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2174 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2175 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2176 VE = VMap.end(); VI != VE; ++VI) {
2177 const MDNode *Var = VI->first;
2179 Processed.insert(Var);
2181 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2183 DbgScope *Scope = 0;
2184 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2185 Scope = ConcreteScopes.lookup(IA);
2187 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2189 // If variable scope is not found then skip this variable.
2193 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2194 DbgVariable *RegVar = new DbgVariable(DV);
2195 recordVariableFrameIndex(RegVar, VP.first);
2196 Scope->addVariable(RegVar);
2197 if (AbsDbgVariable) {
2198 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2199 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2204 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2205 /// DBG_VALUE instruction, is in undefined reg.
2206 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2207 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2208 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2213 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2214 /// DBG_VALUE instruction, is in a defined reg.
2215 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2216 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2217 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2222 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2224 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2225 SmallPtrSet<const MDNode *, 16> &Processed) {
2227 /// collection info from MMI table.
2228 collectVariableInfoFromMMITable(MF, Processed);
2230 SmallVector<const MachineInstr *, 8> DbgValues;
2231 // Collect variable information from DBG_VALUE machine instructions;
2232 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2234 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2236 const MachineInstr *MInsn = II;
2237 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2239 DbgValues.push_back(MInsn);
2242 // This is a collection of DBV_VALUE instructions describing same variable.
2243 SmallVector<const MachineInstr *, 4> MultipleValues;
2244 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2245 E = DbgValues.end(); I != E; ++I) {
2246 const MachineInstr *MInsn = *I;
2247 MultipleValues.clear();
2248 if (isDbgValueInDefinedReg(MInsn))
2249 MultipleValues.push_back(MInsn);
2250 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2251 if (Processed.count(DV) != 0)
2254 const MachineInstr *PrevMI = MInsn;
2255 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2256 ME = DbgValues.end(); MI != ME; ++MI) {
2258 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2259 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2260 !PrevMI->isIdenticalTo(*MI))
2261 MultipleValues.push_back(*MI);
2265 DbgScope *Scope = findDbgScope(MInsn);
2266 bool CurFnArg = false;
2267 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2268 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2270 if (!Scope && CurFnArg)
2271 Scope = CurrentFnDbgScope;
2272 // If variable scope is not found then skip this variable.
2276 Processed.insert(DV);
2277 DbgVariable *RegVar = new DbgVariable(DV);
2278 Scope->addVariable(RegVar);
2280 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2281 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2282 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2283 VarToAbstractVarMap[RegVar] = AbsVar;
2285 if (MultipleValues.size() <= 1) {
2286 DbgVariableToDbgInstMap[RegVar] = MInsn;
2290 // handle multiple DBG_VALUE instructions describing one variable.
2291 if (DotDebugLocEntries.empty())
2292 RegVar->setDotDebugLocOffset(0);
2294 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2295 const MachineInstr *Begin = NULL;
2296 const MachineInstr *End = NULL;
2297 for (SmallVector<const MachineInstr *, 4>::iterator
2298 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2299 MVI != MVE; ++MVI) {
2305 MachineLocation MLoc;
2306 MLoc.set(Begin->getOperand(0).getReg(), 0);
2307 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2308 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2309 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2311 if (MVI + 1 == MVE) {
2312 // If End is the last instruction then its value is valid
2313 // until the end of the funtion.
2314 MLoc.set(End->getOperand(0).getReg(), 0);
2316 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2319 DotDebugLocEntries.push_back(DotDebugLocEntry());
2322 // Collect info for variables that were optimized out.
2323 const Function *F = MF->getFunction();
2324 const Module *M = F->getParent();
2325 if (NamedMDNode *NMD =
2326 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2327 getRealLinkageName(F->getName())))) {
2328 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2329 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2330 if (!DV || !Processed.insert(DV))
2332 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2334 Scope->addVariable(new DbgVariable(DV));
2339 /// getLabelBeforeInsn - Return Label preceding the instruction.
2340 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2341 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2342 LabelsBeforeInsn.find(MI);
2343 if (I == LabelsBeforeInsn.end())
2344 // FunctionBeginSym always preceeds all the instruction in current function.
2345 return FunctionBeginSym;
2349 /// getLabelAfterInsn - Return Label immediately following the instruction.
2350 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2351 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2352 LabelsAfterInsn.find(MI);
2353 if (I == LabelsAfterInsn.end())
2358 /// beginScope - Process beginning of a scope.
2359 void DwarfDebug::beginScope(const MachineInstr *MI) {
2360 if (InsnNeedsLabel.count(MI) == 0) {
2361 LabelsBeforeInsn[MI] = PrevLabel;
2366 DebugLoc DL = MI->getDebugLoc();
2367 if (!DL.isUnknown()) {
2368 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2369 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2371 LabelsBeforeInsn[MI] = PrevLabel;
2375 // If location is unknown then use temp label for this DBG_VALUE
2377 if (MI->isDebugValue()) {
2378 PrevLabel = MMI->getContext().CreateTempSymbol();
2379 Asm->OutStreamer.EmitLabel(PrevLabel);
2380 LabelsBeforeInsn[MI] = PrevLabel;
2384 if (UnknownLocations) {
2385 PrevLabel = recordSourceLine(0, 0, 0);
2386 LabelsBeforeInsn[MI] = PrevLabel;
2390 assert (0 && "Instruction is not processed!");
2393 /// endScope - Process end of a scope.
2394 void DwarfDebug::endScope(const MachineInstr *MI) {
2395 if (InsnsEndScopeSet.count(MI) != 0) {
2396 // Emit a label if this instruction ends a scope.
2397 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2398 Asm->OutStreamer.EmitLabel(Label);
2399 LabelsAfterInsn[MI] = Label;
2403 /// getOrCreateDbgScope - Create DbgScope for the scope.
2404 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2405 const MDNode *InlinedAt) {
2407 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2410 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2411 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2412 if (DIDescriptor(Scope).isLexicalBlock()) {
2414 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2415 WScope->setParent(Parent);
2416 Parent->addScope(WScope);
2419 if (!WScope->getParent()) {
2420 StringRef SPName = DISubprogram(Scope).getLinkageName();
2421 // We used to check only for a linkage name, but that fails
2422 // since we began omitting the linkage name for private
2423 // functions. The new way is to check for the name in metadata,
2424 // but that's not supported in old .ll test cases. Ergo, we
2426 if (SPName == Asm->MF->getFunction()->getName() ||
2427 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2428 CurrentFnDbgScope = WScope;
2434 getOrCreateAbstractScope(Scope);
2435 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2439 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2440 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2441 DILocation DL(InlinedAt);
2443 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2444 WScope->setParent(Parent);
2445 Parent->addScope(WScope);
2447 ConcreteScopes[InlinedAt] = WScope;
2452 /// hasValidLocation - Return true if debug location entry attached with
2453 /// machine instruction encodes valid location info.
2454 static bool hasValidLocation(LLVMContext &Ctx,
2455 const MachineInstr *MInsn,
2456 const MDNode *&Scope, const MDNode *&InlinedAt) {
2457 DebugLoc DL = MInsn->getDebugLoc();
2458 if (DL.isUnknown()) return false;
2460 const MDNode *S = DL.getScope(Ctx);
2462 // There is no need to create another DIE for compile unit. For all
2463 // other scopes, create one DbgScope now. This will be translated
2464 // into a scope DIE at the end.
2465 if (DIScope(S).isCompileUnit()) return false;
2468 InlinedAt = DL.getInlinedAt(Ctx);
2472 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2474 static void calculateDominanceGraph(DbgScope *Scope) {
2475 assert (Scope && "Unable to calculate scop edominance graph!");
2476 SmallVector<DbgScope *, 4> WorkStack;
2477 WorkStack.push_back(Scope);
2478 unsigned Counter = 0;
2479 while (!WorkStack.empty()) {
2480 DbgScope *WS = WorkStack.back();
2481 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2482 bool visitedChildren = false;
2483 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2484 SE = Children.end(); SI != SE; ++SI) {
2485 DbgScope *ChildScope = *SI;
2486 if (!ChildScope->getDFSOut()) {
2487 WorkStack.push_back(ChildScope);
2488 visitedChildren = true;
2489 ChildScope->setDFSIn(++Counter);
2493 if (!visitedChildren) {
2494 WorkStack.pop_back();
2495 WS->setDFSOut(++Counter);
2500 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2502 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2503 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2506 unsigned PrevDFSIn = 0;
2507 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2509 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2511 const MachineInstr *MInsn = II;
2512 const MDNode *Scope = NULL;
2513 const MDNode *InlinedAt = NULL;
2515 // Check if instruction has valid location information.
2516 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2520 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2521 MI2ScopeMap.find(MInsn);
2522 if (DI != MI2ScopeMap.end()) {
2523 DbgScope *S = DI->second;
2524 dbgs() << S->getDFSIn();
2525 PrevDFSIn = S->getDFSIn();
2527 dbgs() << PrevDFSIn;
2529 dbgs() << " [ x" << PrevDFSIn;
2537 /// extractScopeInformation - Scan machine instructions in this function
2538 /// and collect DbgScopes. Return true, if at least one scope was found.
2539 bool DwarfDebug::extractScopeInformation() {
2540 // If scope information was extracted using .dbg intrinsics then there is not
2541 // any need to extract these information by scanning each instruction.
2542 if (!DbgScopeMap.empty())
2545 // Scan each instruction and create scopes. First build working set of scopes.
2546 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2547 SmallVector<DbgRange, 4> MIRanges;
2548 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2549 const MDNode *PrevScope = NULL;
2550 const MDNode *PrevInlinedAt = NULL;
2551 const MachineInstr *RangeBeginMI = NULL;
2552 const MachineInstr *PrevMI = NULL;
2553 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2555 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2557 const MachineInstr *MInsn = II;
2558 const MDNode *Scope = NULL;
2559 const MDNode *InlinedAt = NULL;
2561 // Check if instruction has valid location information.
2562 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2567 // If scope has not changed then skip this instruction.
2568 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2574 // If we have alread seen a beginning of a instruction range and
2575 // current instruction scope does not match scope of first instruction
2576 // in this range then create a new instruction range.
2577 DbgRange R(RangeBeginMI, PrevMI);
2578 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2580 MIRanges.push_back(R);
2583 // This is a beginning of a new instruction range.
2584 RangeBeginMI = MInsn;
2586 // Reset previous markers.
2589 PrevInlinedAt = InlinedAt;
2593 // Create last instruction range.
2594 if (RangeBeginMI && PrevMI && PrevScope) {
2595 DbgRange R(RangeBeginMI, PrevMI);
2596 MIRanges.push_back(R);
2597 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2600 if (!CurrentFnDbgScope)
2603 calculateDominanceGraph(CurrentFnDbgScope);
2605 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2607 // Find ranges of instructions covered by each DbgScope;
2608 DbgScope *PrevDbgScope = NULL;
2609 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2610 RE = MIRanges.end(); RI != RE; ++RI) {
2611 const DbgRange &R = *RI;
2612 DbgScope *S = MI2ScopeMap.lookup(R.first);
2613 assert (S && "Lost DbgScope for a machine instruction!");
2614 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2615 PrevDbgScope->closeInsnRange(S);
2616 S->openInsnRange(R.first);
2617 S->extendInsnRange(R.second);
2622 PrevDbgScope->closeInsnRange();
2624 identifyScopeMarkers();
2626 return !DbgScopeMap.empty();
2629 /// identifyScopeMarkers() -
2630 /// Each DbgScope has first instruction and last instruction to mark beginning
2631 /// and end of a scope respectively. Create an inverse map that list scopes
2632 /// starts (and ends) with an instruction. One instruction may start (or end)
2633 /// multiple scopes. Ignore scopes that are not reachable.
2634 void DwarfDebug::identifyScopeMarkers() {
2635 SmallVector<DbgScope *, 4> WorkList;
2636 WorkList.push_back(CurrentFnDbgScope);
2637 while (!WorkList.empty()) {
2638 DbgScope *S = WorkList.pop_back_val();
2640 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2641 if (!Children.empty())
2642 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2643 SE = Children.end(); SI != SE; ++SI)
2644 WorkList.push_back(*SI);
2646 if (S->isAbstractScope())
2649 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2652 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2653 RE = Ranges.end(); RI != RE; ++RI) {
2654 assert(RI->first && "DbgRange does not have first instruction!");
2655 assert(RI->second && "DbgRange does not have second instruction!");
2656 InsnsEndScopeSet.insert(RI->second);
2661 /// FindFirstDebugLoc - Find the first debug location in the function. This
2662 /// is intended to be an approximation for the source position of the
2663 /// beginning of the function.
2664 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2665 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2667 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2668 MBBI != MBBE; ++MBBI) {
2669 DebugLoc DL = MBBI->getDebugLoc();
2670 if (!DL.isUnknown())
2676 /// beginFunction - Gather pre-function debug information. Assumes being
2677 /// emitted immediately after the function entry point.
2678 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2679 if (!MMI->hasDebugInfo()) return;
2680 if (!extractScopeInformation()) return;
2682 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2683 Asm->getFunctionNumber());
2684 // Assumes in correct section after the entry point.
2685 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2687 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2689 DebugLoc FDL = FindFirstDebugLoc(MF);
2690 if (FDL.isUnknown()) return;
2692 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2693 const MDNode *TheScope = 0;
2695 DISubprogram SP = getDISubprogram(Scope);
2698 Line = SP.getLineNumber();
2702 Line = FDL.getLine();
2707 recordSourceLine(Line, Col, TheScope);
2709 /// ProcessedArgs - Collection of arguments already processed.
2710 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2713 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2715 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2717 const MachineInstr *MI = II;
2718 DebugLoc DL = MI->getDebugLoc();
2719 if (MI->isDebugValue()) {
2720 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2721 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2722 if (!DV.Verify()) continue;
2723 // If DBG_VALUE is for a local variable then it needs a label.
2724 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2725 && isDbgValueInUndefinedReg(MI) == false)
2726 InsnNeedsLabel.insert(MI);
2727 // DBG_VALUE for inlined functions argument needs a label.
2728 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2729 describes(MF->getFunction()))
2730 InsnNeedsLabel.insert(MI);
2731 // DBG_VALUE indicating argument location change needs a label.
2732 else if (isDbgValueInUndefinedReg(MI) == false
2733 && !ProcessedArgs.insert(DV))
2734 InsnNeedsLabel.insert(MI);
2736 // If location is unknown then instruction needs a location only if
2737 // UnknownLocations flag is set.
2738 if (DL.isUnknown()) {
2739 if (UnknownLocations && !PrevLoc.isUnknown())
2740 InsnNeedsLabel.insert(MI);
2741 } else if (DL != PrevLoc)
2742 // Otherwise, instruction needs a location only if it is new location.
2743 InsnNeedsLabel.insert(MI);
2746 if (!DL.isUnknown() || UnknownLocations)
2750 PrevLabel = FunctionBeginSym;
2753 /// endFunction - Gather and emit post-function debug information.
2755 void DwarfDebug::endFunction(const MachineFunction *MF) {
2756 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2758 if (CurrentFnDbgScope) {
2760 // Define end label for subprogram.
2761 FunctionEndSym = Asm->GetTempSymbol("func_end",
2762 Asm->getFunctionNumber());
2763 // Assumes in correct section after the entry point.
2764 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2766 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2767 collectVariableInfo(MF, ProcessedVars);
2769 // Get function line info.
2770 if (!Lines.empty()) {
2771 // Get section line info.
2772 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2773 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2774 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2775 // Append the function info to section info.
2776 SectionLineInfos.insert(SectionLineInfos.end(),
2777 Lines.begin(), Lines.end());
2780 // Construct abstract scopes.
2781 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2782 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2783 DISubprogram SP((*AI)->getScopeNode());
2785 // Collect info for variables that were optimized out.
2786 StringRef FName = SP.getLinkageName();
2788 FName = SP.getName();
2789 const Module *M = MF->getFunction()->getParent();
2790 if (NamedMDNode *NMD =
2791 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2792 getRealLinkageName(FName)))) {
2793 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2794 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2795 if (!DV || !ProcessedVars.insert(DV))
2797 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2799 Scope->addVariable(new DbgVariable(DV));
2803 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2804 constructScopeDIE(*AI);
2807 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2809 if (!DisableFramePointerElim(*MF))
2810 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2811 dwarf::DW_FORM_flag, 1);
2814 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2815 MMI->getFrameMoves()));
2819 CurrentFnDbgScope = NULL;
2820 InsnNeedsLabel.clear();
2821 DbgVariableToFrameIndexMap.clear();
2822 VarToAbstractVarMap.clear();
2823 DbgVariableToDbgInstMap.clear();
2824 DbgVariableLabelsMap.clear();
2825 DeleteContainerSeconds(DbgScopeMap);
2826 InsnsEndScopeSet.clear();
2827 ConcreteScopes.clear();
2828 DeleteContainerSeconds(AbstractScopes);
2829 AbstractScopesList.clear();
2830 AbstractVariables.clear();
2831 LabelsBeforeInsn.clear();
2832 LabelsAfterInsn.clear();
2837 /// recordVariableFrameIndex - Record a variable's index.
2838 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2839 assert (V && "Invalid DbgVariable!");
2840 DbgVariableToFrameIndexMap[V] = Index;
2843 /// findVariableFrameIndex - Return true if frame index for the variable
2844 /// is found. Update FI to hold value of the index.
2845 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2846 assert (V && "Invalid DbgVariable!");
2847 DenseMap<const DbgVariable *, int>::iterator I =
2848 DbgVariableToFrameIndexMap.find(V);
2849 if (I == DbgVariableToFrameIndexMap.end())
2855 /// findVariableLabel - Find MCSymbol for the variable.
2856 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2857 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2858 = DbgVariableLabelsMap.find(V);
2859 if (I == DbgVariableLabelsMap.end())
2861 else return I->second;
2864 /// findDbgScope - Find DbgScope for the debug loc attached with an
2866 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2867 DbgScope *Scope = NULL;
2869 MInsn->getParent()->getParent()->getFunction()->getContext();
2870 DebugLoc DL = MInsn->getDebugLoc();
2875 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2876 Scope = ConcreteScopes.lookup(IA);
2878 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2884 /// recordSourceLine - Register a source line with debug info. Returns the
2885 /// unique label that was emitted and which provides correspondence to
2886 /// the source line list.
2887 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2894 DIDescriptor Scope(S);
2896 if (Scope.isCompileUnit()) {
2897 DICompileUnit CU(S);
2898 Dir = CU.getDirectory();
2899 Fn = CU.getFilename();
2900 } else if (Scope.isSubprogram()) {
2902 Dir = SP.getDirectory();
2903 Fn = SP.getFilename();
2904 } else if (Scope.isLexicalBlock()) {
2905 DILexicalBlock DB(S);
2906 Dir = DB.getDirectory();
2907 Fn = DB.getFilename();
2909 assert(0 && "Unexpected scope info");
2911 Src = GetOrCreateSourceID(Dir, Fn);
2914 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2915 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2917 Asm->OutStreamer.EmitLabel(Label);
2921 //===----------------------------------------------------------------------===//
2923 //===----------------------------------------------------------------------===//
2925 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2928 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2929 // Get the children.
2930 const std::vector<DIE *> &Children = Die->getChildren();
2932 // If not last sibling and has children then add sibling offset attribute.
2933 if (!Last && !Children.empty())
2934 Die->addSiblingOffset(DIEValueAllocator);
2936 // Record the abbreviation.
2937 assignAbbrevNumber(Die->getAbbrev());
2939 // Get the abbreviation for this DIE.
2940 unsigned AbbrevNumber = Die->getAbbrevNumber();
2941 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2944 Die->setOffset(Offset);
2946 // Start the size with the size of abbreviation code.
2947 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2949 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2950 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2952 // Size the DIE attribute values.
2953 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2954 // Size attribute value.
2955 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2957 // Size the DIE children if any.
2958 if (!Children.empty()) {
2959 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2960 "Children flag not set");
2962 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2963 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2965 // End of children marker.
2966 Offset += sizeof(int8_t);
2969 Die->setSize(Offset - Die->getOffset());
2973 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2975 void DwarfDebug::computeSizeAndOffsets() {
2976 unsigned PrevOffset = 0;
2977 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2978 E = CUMap.end(); I != E; ++I) {
2979 // Compute size of compile unit header.
2980 static unsigned Offset = PrevOffset +
2981 sizeof(int32_t) + // Length of Compilation Unit Info
2982 sizeof(int16_t) + // DWARF version number
2983 sizeof(int32_t) + // Offset Into Abbrev. Section
2984 sizeof(int8_t); // Pointer Size (in bytes)
2985 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2986 PrevOffset = Offset;
2990 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2991 /// temporary label to it if SymbolStem is specified.
2992 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2993 const char *SymbolStem = 0) {
2994 Asm->OutStreamer.SwitchSection(Section);
2995 if (!SymbolStem) return 0;
2997 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2998 Asm->OutStreamer.EmitLabel(TmpSym);
3002 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3003 /// the start of each one.
3004 void DwarfDebug::EmitSectionLabels() {
3005 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3007 // Dwarf sections base addresses.
3008 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3009 DwarfFrameSectionSym =
3010 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3013 DwarfInfoSectionSym =
3014 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3015 DwarfAbbrevSectionSym =
3016 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3017 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3019 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3020 EmitSectionSym(Asm, MacroInfo);
3022 DwarfDebugLineSectionSym =
3023 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3024 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3025 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3026 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3027 DwarfStrSectionSym =
3028 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3029 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3032 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3033 "section_debug_loc");
3035 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3036 EmitSectionSym(Asm, TLOF.getDataSection());
3039 /// emitDIE - Recusively Emits a debug information entry.
3041 void DwarfDebug::emitDIE(DIE *Die) {
3042 // Get the abbreviation for this DIE.
3043 unsigned AbbrevNumber = Die->getAbbrevNumber();
3044 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3046 // Emit the code (index) for the abbreviation.
3047 if (Asm->isVerbose())
3048 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3049 Twine::utohexstr(Die->getOffset()) + ":0x" +
3050 Twine::utohexstr(Die->getSize()) + " " +
3051 dwarf::TagString(Abbrev->getTag()));
3052 Asm->EmitULEB128(AbbrevNumber);
3054 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3055 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3057 // Emit the DIE attribute values.
3058 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3059 unsigned Attr = AbbrevData[i].getAttribute();
3060 unsigned Form = AbbrevData[i].getForm();
3061 assert(Form && "Too many attributes for DIE (check abbreviation)");
3063 if (Asm->isVerbose())
3064 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3067 case dwarf::DW_AT_sibling:
3068 Asm->EmitInt32(Die->getSiblingOffset());
3070 case dwarf::DW_AT_abstract_origin: {
3071 DIEEntry *E = cast<DIEEntry>(Values[i]);
3072 DIE *Origin = E->getEntry();
3073 unsigned Addr = Origin->getOffset();
3074 Asm->EmitInt32(Addr);
3077 case dwarf::DW_AT_ranges: {
3078 // DW_AT_range Value encodes offset in debug_range section.
3079 DIEInteger *V = cast<DIEInteger>(Values[i]);
3080 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3082 DwarfDebugRangeSectionSym,
3086 case dwarf::DW_AT_stmt_list: {
3087 Asm->EmitLabelDifference(CurrentLineSectionSym,
3088 DwarfDebugLineSectionSym, 4);
3091 case dwarf::DW_AT_location: {
3092 if (UseDotDebugLocEntry.count(Die) != 0) {
3093 DIELabel *L = cast<DIELabel>(Values[i]);
3094 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3096 Values[i]->EmitValue(Asm, Form);
3100 // Emit an attribute using the defined form.
3101 Values[i]->EmitValue(Asm, Form);
3106 // Emit the DIE children if any.
3107 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3108 const std::vector<DIE *> &Children = Die->getChildren();
3110 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3111 emitDIE(Children[j]);
3113 if (Asm->isVerbose())
3114 Asm->OutStreamer.AddComment("End Of Children Mark");
3119 /// emitDebugInfo - Emit the debug info section.
3121 void DwarfDebug::emitDebugInfo() {
3122 // Start debug info section.
3123 Asm->OutStreamer.SwitchSection(
3124 Asm->getObjFileLowering().getDwarfInfoSection());
3125 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3126 E = CUMap.end(); I != E; ++I) {
3127 CompileUnit *TheCU = I->second;
3128 DIE *Die = TheCU->getCUDie();
3130 // Emit the compile units header.
3131 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3134 // Emit size of content not including length itself
3135 unsigned ContentSize = Die->getSize() +
3136 sizeof(int16_t) + // DWARF version number
3137 sizeof(int32_t) + // Offset Into Abbrev. Section
3138 sizeof(int8_t) + // Pointer Size (in bytes)
3139 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3141 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3142 Asm->EmitInt32(ContentSize);
3143 Asm->OutStreamer.AddComment("DWARF version number");
3144 Asm->EmitInt16(dwarf::DWARF_VERSION);
3145 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3146 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3147 DwarfAbbrevSectionSym);
3148 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3149 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3152 // FIXME - extra padding for gdb bug.
3153 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3158 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3162 /// emitAbbreviations - Emit the abbreviation section.
3164 void DwarfDebug::emitAbbreviations() const {
3165 // Check to see if it is worth the effort.
3166 if (!Abbreviations.empty()) {
3167 // Start the debug abbrev section.
3168 Asm->OutStreamer.SwitchSection(
3169 Asm->getObjFileLowering().getDwarfAbbrevSection());
3171 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3173 // For each abbrevation.
3174 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3175 // Get abbreviation data
3176 const DIEAbbrev *Abbrev = Abbreviations[i];
3178 // Emit the abbrevations code (base 1 index.)
3179 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3181 // Emit the abbreviations data.
3185 // Mark end of abbreviations.
3186 Asm->EmitULEB128(0, "EOM(3)");
3188 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3192 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3193 /// the line matrix.
3195 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3196 // Define last address of section.
3197 Asm->OutStreamer.AddComment("Extended Op");
3200 Asm->OutStreamer.AddComment("Op size");
3201 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3202 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3203 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3205 Asm->OutStreamer.AddComment("Section end label");
3207 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3208 Asm->getTargetData().getPointerSize(),
3211 // Mark end of matrix.
3212 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3218 /// emitDebugLines - Emit source line information.
3220 void DwarfDebug::emitDebugLines() {
3221 // If the target is using .loc/.file, the assembler will be emitting the
3222 // .debug_line table automatically.
3223 if (Asm->MAI->hasDotLocAndDotFile())
3226 // Minimum line delta, thus ranging from -10..(255-10).
3227 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3228 // Maximum line delta, thus ranging from -10..(255-10).
3229 const int MaxLineDelta = 255 + MinLineDelta;
3231 // Start the dwarf line section.
3232 Asm->OutStreamer.SwitchSection(
3233 Asm->getObjFileLowering().getDwarfLineSection());
3235 // Construct the section header.
3236 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3237 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3238 Asm->OutStreamer.AddComment("Length of Source Line Info");
3239 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3240 Asm->GetTempSymbol("line_begin"), 4);
3241 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3243 Asm->OutStreamer.AddComment("DWARF version number");
3244 Asm->EmitInt16(dwarf::DWARF_VERSION);
3246 Asm->OutStreamer.AddComment("Prolog Length");
3247 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3248 Asm->GetTempSymbol("line_prolog_begin"), 4);
3249 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3251 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3253 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3255 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3256 Asm->EmitInt8(MinLineDelta);
3257 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3258 Asm->EmitInt8(MaxLineDelta);
3259 Asm->OutStreamer.AddComment("Special Opcode Base");
3260 Asm->EmitInt8(-MinLineDelta);
3262 // Line number standard opcode encodings argument count
3263 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3265 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3267 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3269 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3271 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3273 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3275 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3277 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3279 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3282 // Emit directories.
3283 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3284 const std::string &Dir = getSourceDirectoryName(DI);
3285 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3286 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3289 Asm->OutStreamer.AddComment("End of directories");
3293 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3294 // Remember source id starts at 1.
3295 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3296 const std::string &FN = getSourceFileName(Id.second);
3297 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3298 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3300 Asm->EmitULEB128(Id.first, "Directory #");
3301 Asm->EmitULEB128(0, "Mod date");
3302 Asm->EmitULEB128(0, "File size");
3305 Asm->OutStreamer.AddComment("End of files");
3308 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3310 // A sequence for each text section.
3311 unsigned SecSrcLinesSize = SectionSourceLines.size();
3313 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3314 // Isolate current sections line info.
3315 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3317 // Dwarf assumes we start with first line of first source file.
3318 unsigned Source = 1;
3321 // Construct rows of the address, source, line, column matrix.
3322 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3323 const SrcLineInfo &LineInfo = LineInfos[i];
3324 MCSymbol *Label = LineInfo.getLabel();
3325 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3327 if (Asm->isVerbose()) {
3328 std::pair<unsigned, unsigned> SrcID =
3329 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3330 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3332 Twine(getSourceFileName(SrcID.second)) +
3333 ":" + Twine(LineInfo.getLine()));
3336 // Define the line address.
3337 Asm->OutStreamer.AddComment("Extended Op");
3339 Asm->OutStreamer.AddComment("Op size");
3340 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3342 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3343 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3345 Asm->OutStreamer.AddComment("Location label");
3346 Asm->OutStreamer.EmitSymbolValue(Label,
3347 Asm->getTargetData().getPointerSize(),
3350 // If change of source, then switch to the new source.
3351 if (Source != LineInfo.getSourceID()) {
3352 Source = LineInfo.getSourceID();
3353 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3354 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3355 Asm->EmitULEB128(Source, "New Source");
3358 // If change of line.
3359 if (Line != LineInfo.getLine()) {
3360 // Determine offset.
3361 int Offset = LineInfo.getLine() - Line;
3362 int Delta = Offset - MinLineDelta;
3365 Line = LineInfo.getLine();
3367 // If delta is small enough and in range...
3368 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3369 // ... then use fast opcode.
3370 Asm->OutStreamer.AddComment("Line Delta");
3371 Asm->EmitInt8(Delta - MinLineDelta);
3373 // ... otherwise use long hand.
3374 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3375 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3376 Asm->EmitSLEB128(Offset, "Line Offset");
3377 Asm->OutStreamer.AddComment("DW_LNS_copy");
3378 Asm->EmitInt8(dwarf::DW_LNS_copy);
3381 // Copy the previous row (different address or source)
3382 Asm->OutStreamer.AddComment("DW_LNS_copy");
3383 Asm->EmitInt8(dwarf::DW_LNS_copy);
3387 emitEndOfLineMatrix(j + 1);
3390 if (SecSrcLinesSize == 0)
3391 // Because we're emitting a debug_line section, we still need a line
3392 // table. The linker and friends expect it to exist. If there's nothing to
3393 // put into it, emit an empty table.
3394 emitEndOfLineMatrix(1);
3396 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3399 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3401 void DwarfDebug::emitCommonDebugFrame() {
3402 if (!Asm->MAI->doesDwarfRequireFrameSection())
3405 int stackGrowth = Asm->getTargetData().getPointerSize();
3406 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3407 TargetFrameInfo::StackGrowsDown)
3410 // Start the dwarf frame section.
3411 Asm->OutStreamer.SwitchSection(
3412 Asm->getObjFileLowering().getDwarfFrameSection());
3414 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3415 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3416 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3417 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3419 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3420 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3421 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3422 Asm->OutStreamer.AddComment("CIE Version");
3423 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3424 Asm->OutStreamer.AddComment("CIE Augmentation");
3425 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3426 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3427 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3428 Asm->OutStreamer.AddComment("CIE RA Column");
3429 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3430 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3432 std::vector<MachineMove> Moves;
3433 RI->getInitialFrameState(Moves);
3435 Asm->EmitFrameMoves(Moves, 0, false);
3437 Asm->EmitAlignment(2);
3438 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3441 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3444 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3445 if (!Asm->MAI->doesDwarfRequireFrameSection())
3448 // Start the dwarf frame section.
3449 Asm->OutStreamer.SwitchSection(
3450 Asm->getObjFileLowering().getDwarfFrameSection());
3452 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3453 MCSymbol *DebugFrameBegin =
3454 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3455 MCSymbol *DebugFrameEnd =
3456 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3457 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3459 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3461 Asm->OutStreamer.AddComment("FDE CIE offset");
3462 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3463 DwarfFrameSectionSym);
3465 Asm->OutStreamer.AddComment("FDE initial location");
3466 MCSymbol *FuncBeginSym =
3467 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3468 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3469 Asm->getTargetData().getPointerSize(),
3473 Asm->OutStreamer.AddComment("FDE address range");
3474 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3475 FuncBeginSym, Asm->getTargetData().getPointerSize());
3477 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3479 Asm->EmitAlignment(2);
3480 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3483 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3485 void DwarfDebug::emitDebugPubNames() {
3486 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3487 E = CUMap.end(); I != E; ++I) {
3488 CompileUnit *TheCU = I->second;
3489 // Start the dwarf pubnames section.
3490 Asm->OutStreamer.SwitchSection(
3491 Asm->getObjFileLowering().getDwarfPubNamesSection());
3493 Asm->OutStreamer.AddComment("Length of Public Names Info");
3494 Asm->EmitLabelDifference(
3495 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3496 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3498 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3501 Asm->OutStreamer.AddComment("DWARF Version");
3502 Asm->EmitInt16(dwarf::DWARF_VERSION);
3504 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3505 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3506 DwarfInfoSectionSym);
3508 Asm->OutStreamer.AddComment("Compilation Unit Length");
3509 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3510 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3513 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3514 for (StringMap<DIE*>::const_iterator
3515 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3516 const char *Name = GI->getKeyData();
3517 DIE *Entity = GI->second;
3519 Asm->OutStreamer.AddComment("DIE offset");
3520 Asm->EmitInt32(Entity->getOffset());
3522 if (Asm->isVerbose())
3523 Asm->OutStreamer.AddComment("External Name");
3524 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3527 Asm->OutStreamer.AddComment("End Mark");
3529 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3534 void DwarfDebug::emitDebugPubTypes() {
3535 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3536 E = CUMap.end(); I != E; ++I) {
3537 CompileUnit *TheCU = I->second;
3538 // Start the dwarf pubnames section.
3539 Asm->OutStreamer.SwitchSection(
3540 Asm->getObjFileLowering().getDwarfPubTypesSection());
3541 Asm->OutStreamer.AddComment("Length of Public Types Info");
3542 Asm->EmitLabelDifference(
3543 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3544 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3546 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3549 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3550 Asm->EmitInt16(dwarf::DWARF_VERSION);
3552 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3553 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3554 DwarfInfoSectionSym);
3556 Asm->OutStreamer.AddComment("Compilation Unit Length");
3557 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3558 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3561 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3562 for (StringMap<DIE*>::const_iterator
3563 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3564 const char *Name = GI->getKeyData();
3565 DIE * Entity = GI->second;
3567 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3568 Asm->EmitInt32(Entity->getOffset());
3570 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3571 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3574 Asm->OutStreamer.AddComment("End Mark");
3576 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3581 /// emitDebugStr - Emit visible names into a debug str section.
3583 void DwarfDebug::emitDebugStr() {
3584 // Check to see if it is worth the effort.
3585 if (StringPool.empty()) return;
3587 // Start the dwarf str section.
3588 Asm->OutStreamer.SwitchSection(
3589 Asm->getObjFileLowering().getDwarfStrSection());
3591 // Get all of the string pool entries and put them in an array by their ID so
3592 // we can sort them.
3593 SmallVector<std::pair<unsigned,
3594 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3596 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3597 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3598 Entries.push_back(std::make_pair(I->second.second, &*I));
3600 array_pod_sort(Entries.begin(), Entries.end());
3602 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3603 // Emit a label for reference from debug information entries.
3604 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3606 // Emit the string itself.
3607 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3611 /// emitDebugLoc - Emit visible names into a debug loc section.
3613 void DwarfDebug::emitDebugLoc() {
3614 if (DotDebugLocEntries.empty())
3617 // Start the dwarf loc section.
3618 Asm->OutStreamer.SwitchSection(
3619 Asm->getObjFileLowering().getDwarfLocSection());
3620 unsigned char Size = Asm->getTargetData().getPointerSize();
3621 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3623 for (SmallVector<DotDebugLocEntry, 4>::iterator
3624 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3625 I != E; ++I, ++index) {
3626 DotDebugLocEntry Entry = *I;
3627 if (Entry.isEmpty()) {
3628 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3629 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3630 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3632 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3633 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3634 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3635 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3637 Asm->OutStreamer.AddComment("Loc expr size");
3639 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3641 Asm->OutStreamer.AddComment("Loc expr size");
3642 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3643 Asm->EmitInt8(dwarf::DW_OP_regx);
3644 Asm->EmitULEB128(Reg);
3650 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3652 void DwarfDebug::EmitDebugARanges() {
3653 // Start the dwarf aranges section.
3654 Asm->OutStreamer.SwitchSection(
3655 Asm->getObjFileLowering().getDwarfARangesSection());
3658 /// emitDebugRanges - Emit visible names into a debug ranges section.
3660 void DwarfDebug::emitDebugRanges() {
3661 // Start the dwarf ranges section.
3662 Asm->OutStreamer.SwitchSection(
3663 Asm->getObjFileLowering().getDwarfRangesSection());
3664 unsigned char Size = Asm->getTargetData().getPointerSize();
3665 for (SmallVector<const MCSymbol *, 8>::iterator
3666 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3669 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3671 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3675 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3677 void DwarfDebug::emitDebugMacInfo() {
3678 if (const MCSection *LineInfo =
3679 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3680 // Start the dwarf macinfo section.
3681 Asm->OutStreamer.SwitchSection(LineInfo);
3685 /// emitDebugInlineInfo - Emit inline info using following format.
3687 /// 1. length of section
3688 /// 2. Dwarf version number
3689 /// 3. address size.
3691 /// Entries (one "entry" for each function that was inlined):
3693 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3694 /// otherwise offset into __debug_str for regular function name.
3695 /// 2. offset into __debug_str section for regular function name.
3696 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3697 /// instances for the function.
3699 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3700 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3701 /// __debug_info section, and the low_pc is the starting address for the
3702 /// inlining instance.
3703 void DwarfDebug::emitDebugInlineInfo() {
3704 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3710 Asm->OutStreamer.SwitchSection(
3711 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3713 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3714 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3715 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3717 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3719 Asm->OutStreamer.AddComment("Dwarf Version");
3720 Asm->EmitInt16(dwarf::DWARF_VERSION);
3721 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3722 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3724 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3725 E = InlinedSPNodes.end(); I != E; ++I) {
3727 const MDNode *Node = *I;
3728 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3729 = InlineInfo.find(Node);
3730 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3731 DISubprogram SP(Node);
3732 StringRef LName = SP.getLinkageName();
3733 StringRef Name = SP.getName();
3735 Asm->OutStreamer.AddComment("MIPS linkage name");
3736 if (LName.empty()) {
3737 Asm->OutStreamer.EmitBytes(Name, 0);
3738 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3740 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3741 DwarfStrSectionSym);
3743 Asm->OutStreamer.AddComment("Function name");
3744 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3745 Asm->EmitULEB128(Labels.size(), "Inline count");
3747 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3748 LE = Labels.end(); LI != LE; ++LI) {
3749 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3750 Asm->EmitInt32(LI->second->getOffset());
3752 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3753 Asm->OutStreamer.EmitSymbolValue(LI->first,
3754 Asm->getTargetData().getPointerSize(),0);
3758 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));