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 // DW_TAG_inlined_subroutine may refer to this DIE.
1340 SPCU->insertDIE(SP, SPDie);
1342 // Add to context owner.
1343 addToContextOwner(SPDie, SP.getContext());
1348 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1349 assert(N && "Invalid Scope encoding!");
1351 DbgScope *AScope = AbstractScopes.lookup(N);
1355 DbgScope *Parent = NULL;
1357 DIDescriptor Scope(N);
1358 if (Scope.isLexicalBlock()) {
1359 DILexicalBlock DB(N);
1360 DIDescriptor ParentDesc = DB.getContext();
1361 Parent = getOrCreateAbstractScope(ParentDesc);
1364 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1367 Parent->addScope(AScope);
1368 AScope->setAbstractScope();
1369 AbstractScopes[N] = AScope;
1370 if (DIDescriptor(N).isSubprogram())
1371 AbstractScopesList.push_back(AScope);
1375 /// isSubprogramContext - Return true if Context is either a subprogram
1376 /// or another context nested inside a subprogram.
1377 static bool isSubprogramContext(const MDNode *Context) {
1380 DIDescriptor D(Context);
1381 if (D.isSubprogram())
1384 return isSubprogramContext(DIType(Context).getContext());
1388 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1389 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1390 /// If there are global variables in this scope then create and insert
1391 /// DIEs for these variables.
1392 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1393 CompileUnit *SPCU = getCompileUnit(SPNode);
1394 DIE *SPDie = SPCU->getDIE(SPNode);
1396 assert(SPDie && "Unable to find subprogram DIE!");
1397 DISubprogram SP(SPNode);
1399 // There is not any need to generate specification DIE for a function
1400 // defined at compile unit level. If a function is defined inside another
1401 // function then gdb prefers the definition at top level and but does not
1402 // expect specification DIE in parent function. So avoid creating
1403 // specification DIE for a function defined inside a function.
1404 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1405 !SP.getContext().isFile() &&
1406 !isSubprogramContext(SP.getContext())) {
1407 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1410 DICompositeType SPTy = SP.getType();
1411 DIArray Args = SPTy.getTypeArray();
1412 unsigned SPTag = SPTy.getTag();
1413 if (SPTag == dwarf::DW_TAG_subroutine_type)
1414 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1415 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1416 DIType ATy = DIType(DIType(Args.getElement(i)));
1418 if (ATy.isArtificial())
1419 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1420 SPDie->addChild(Arg);
1422 DIE *SPDeclDie = SPDie;
1423 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1424 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1426 SPCU->addDie(SPDie);
1429 // Pick up abstract subprogram DIE.
1430 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1431 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1432 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1433 dwarf::DW_FORM_ref4, AbsSPDIE);
1434 SPCU->addDie(SPDie);
1437 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1438 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1439 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1440 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1441 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1442 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1443 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1448 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1449 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1450 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1452 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1453 if (Scope->isAbstractScope())
1456 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1460 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1461 if (Ranges.size() > 1) {
1462 // .debug_range section has not been laid out yet. Emit offset in
1463 // .debug_range as a uint, size 4, for now. emitDIE will handle
1464 // DW_AT_ranges appropriately.
1465 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1466 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1467 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1468 RE = Ranges.end(); RI != RE; ++RI) {
1469 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1470 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1472 DebugRangeSymbols.push_back(NULL);
1473 DebugRangeSymbols.push_back(NULL);
1477 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1478 const MCSymbol *End = getLabelAfterInsn(RI->second);
1480 if (End == 0) return 0;
1482 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1483 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1485 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1486 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1491 /// constructInlinedScopeDIE - This scope represents inlined body of
1492 /// a function. Construct DIE to represent this concrete inlined copy
1493 /// of the function.
1494 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1496 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1497 assert (Ranges.empty() == false
1498 && "DbgScope does not have instruction markers!");
1500 // FIXME : .debug_inlined section specification does not clearly state how
1501 // to emit inlined scope that is split into multiple instruction ranges.
1502 // For now, use first instruction range and emit low_pc/high_pc pair and
1503 // corresponding .debug_inlined section entry for this pair.
1504 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1505 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1506 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1508 if (StartLabel == 0 || EndLabel == 0) {
1509 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1512 assert(StartLabel->isDefined() &&
1513 "Invalid starting label for an inlined scope!");
1514 assert(EndLabel->isDefined() &&
1515 "Invalid end label for an inlined scope!");
1517 if (!Scope->getScopeNode())
1519 DIScope DS(Scope->getScopeNode());
1520 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1522 DISubprogram InlinedSP = getDISubprogram(DS);
1523 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1524 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1525 assert(OriginDIE && "Unable to find Origin DIE!");
1526 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1527 dwarf::DW_FORM_ref4, OriginDIE);
1529 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1530 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1532 InlinedSubprogramDIEs.insert(OriginDIE);
1534 // Track the start label for this inlined function.
1535 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1536 I = InlineInfo.find(InlinedSP);
1538 if (I == InlineInfo.end()) {
1539 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1541 InlinedSPNodes.push_back(InlinedSP);
1543 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1545 DILocation DL(Scope->getInlinedAt());
1546 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1547 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1553 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1554 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1555 // Get the descriptor.
1556 const DIVariable &VD = DV->getVariable();
1557 StringRef Name = VD.getName();
1561 // Translate tag to proper Dwarf tag. The result variable is dropped for
1564 switch (VD.getTag()) {
1565 case dwarf::DW_TAG_return_variable:
1567 case dwarf::DW_TAG_arg_variable:
1568 Tag = dwarf::DW_TAG_formal_parameter;
1570 case dwarf::DW_TAG_auto_variable: // fall thru
1572 Tag = dwarf::DW_TAG_variable;
1576 // Define variable debug information entry.
1577 DIE *VariableDie = new DIE(Tag);
1580 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1581 V2AVI = VarToAbstractVarMap.find(DV);
1582 if (V2AVI != VarToAbstractVarMap.end())
1583 AbsDIE = V2AVI->second->getDIE();
1586 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1587 dwarf::DW_FORM_ref4, AbsDIE);
1589 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1590 addSourceLine(VariableDie, &VD);
1592 // Add variable type.
1593 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1594 // addresses instead.
1595 if (VD.isBlockByrefVariable())
1596 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1598 addType(VariableDie, VD.getType());
1601 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1602 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1604 if (Scope->isAbstractScope()) {
1605 DV->setDIE(VariableDie);
1609 // Add variable address.
1611 unsigned Offset = DV->getDotDebugLocOffset();
1612 if (Offset != ~0U) {
1613 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1614 Asm->GetTempSymbol("debug_loc", Offset));
1615 DV->setDIE(VariableDie);
1616 UseDotDebugLocEntry.insert(VariableDie);
1620 // Check if variable is described by a DBG_VALUE instruction.
1621 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1622 DbgVariableToDbgInstMap.find(DV);
1623 if (DVI != DbgVariableToDbgInstMap.end()) {
1624 const MachineInstr *DVInsn = DVI->second;
1625 const MCSymbol *DVLabel = findVariableLabel(DV);
1626 bool updated = false;
1627 // FIXME : Handle getNumOperands != 3
1628 if (DVInsn->getNumOperands() == 3) {
1629 if (DVInsn->getOperand(0).isReg())
1631 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1632 else if (DVInsn->getOperand(0).isImm())
1633 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1634 else if (DVInsn->getOperand(0).isFPImm())
1636 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1638 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1639 if (Location.getReg()) {
1640 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1642 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1648 // If variableDie is not updated then DBG_VALUE instruction does not
1649 // have valid variable info.
1653 DV->setDIE(VariableDie);
1657 // .. else use frame index, if available.
1658 MachineLocation Location;
1660 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1662 if (findVariableFrameIndex(DV, &FI)) {
1663 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1664 Location.set(FrameReg, Offset);
1666 if (VD.hasComplexAddress())
1667 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1668 else if (VD.isBlockByrefVariable())
1669 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1671 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1673 DV->setDIE(VariableDie);
1678 void DwarfDebug::addPubTypes(DISubprogram SP) {
1679 DICompositeType SPTy = SP.getType();
1680 unsigned SPTag = SPTy.getTag();
1681 if (SPTag != dwarf::DW_TAG_subroutine_type)
1684 DIArray Args = SPTy.getTypeArray();
1685 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1686 DIType ATy(Args.getElement(i));
1689 DICompositeType CATy = getDICompositeType(ATy);
1690 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1691 && !CATy.isForwardDecl()) {
1692 CompileUnit *TheCU = getCompileUnit(CATy);
1693 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1694 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1699 /// constructScopeDIE - Construct a DIE for this scope.
1700 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1701 if (!Scope || !Scope->getScopeNode())
1704 DIScope DS(Scope->getScopeNode());
1705 DIE *ScopeDIE = NULL;
1706 if (Scope->getInlinedAt())
1707 ScopeDIE = constructInlinedScopeDIE(Scope);
1708 else if (DS.isSubprogram()) {
1709 ProcessedSPNodes.insert(DS);
1710 if (Scope->isAbstractScope()) {
1711 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1712 // Note down abstract DIE.
1714 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1717 ScopeDIE = updateSubprogramScopeDIE(DS);
1720 ScopeDIE = constructLexicalScopeDIE(Scope);
1721 if (!ScopeDIE) return NULL;
1723 // Add variables to scope.
1724 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1725 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1726 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1728 ScopeDIE->addChild(VariableDIE);
1731 // Add nested scopes.
1732 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1733 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1734 // Define the Scope debug information entry.
1735 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1737 ScopeDIE->addChild(NestedDIE);
1740 if (DS.isSubprogram())
1741 addPubTypes(DISubprogram(DS));
1746 /// GetOrCreateSourceID - Look up the source id with the given directory and
1747 /// source file names. If none currently exists, create a new id and insert it
1748 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1750 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1752 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1753 if (DI != DirectoryIdMap.end()) {
1754 DId = DI->getValue();
1756 DId = DirectoryNames.size() + 1;
1757 DirectoryIdMap[DirName] = DId;
1758 DirectoryNames.push_back(DirName);
1762 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1763 if (FI != SourceFileIdMap.end()) {
1764 FId = FI->getValue();
1766 FId = SourceFileNames.size() + 1;
1767 SourceFileIdMap[FileName] = FId;
1768 SourceFileNames.push_back(FileName);
1771 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1772 SourceIdMap.find(std::make_pair(DId, FId));
1773 if (SI != SourceIdMap.end())
1776 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1777 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1778 SourceIds.push_back(std::make_pair(DId, FId));
1783 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1784 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1785 CompileUnit *TheCU = getCompileUnit(NS);
1786 DIE *NDie = TheCU->getDIE(NS);
1789 NDie = new DIE(dwarf::DW_TAG_namespace);
1790 TheCU->insertDIE(NS, NDie);
1791 if (!NS.getName().empty())
1792 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1793 addSourceLine(NDie, &NS);
1794 addToContextOwner(NDie, NS.getContext());
1798 /// constructCompileUnit - Create new CompileUnit for the given
1799 /// metadata node with tag DW_TAG_compile_unit.
1800 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1801 DICompileUnit DIUnit(N);
1802 StringRef FN = DIUnit.getFilename();
1803 StringRef Dir = DIUnit.getDirectory();
1804 unsigned ID = GetOrCreateSourceID(Dir, FN);
1806 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1807 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1808 DIUnit.getProducer());
1809 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1810 DIUnit.getLanguage());
1811 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1812 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1813 // simplifies debug range entries.
1814 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1815 // DW_AT_stmt_list is a offset of line number information for this
1816 // compile unit in debug_line section. This offset is calculated
1817 // during endMoudle().
1818 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1821 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1822 if (DIUnit.isOptimized())
1823 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1825 StringRef Flags = DIUnit.getFlags();
1827 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1829 unsigned RVer = DIUnit.getRunTimeVersion();
1831 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1832 dwarf::DW_FORM_data1, RVer);
1834 CompileUnit *NewCU = new CompileUnit(ID, Die);
1837 CUMap.insert(std::make_pair(N, NewCU));
1840 /// getCompielUnit - Get CompileUnit DIE.
1841 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1842 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1844 const MDNode *CUNode = NULL;
1845 if (D.isCompileUnit())
1847 else if (D.isSubprogram())
1848 CUNode = DISubprogram(N).getCompileUnit();
1849 else if (D.isType())
1850 CUNode = DIType(N).getCompileUnit();
1851 else if (D.isGlobalVariable())
1852 CUNode = DIGlobalVariable(N).getCompileUnit();
1853 else if (D.isVariable())
1854 CUNode = DIVariable(N).getCompileUnit();
1855 else if (D.isNameSpace())
1856 CUNode = DINameSpace(N).getCompileUnit();
1857 else if (D.isFile())
1858 CUNode = DIFile(N).getCompileUnit();
1862 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1863 = CUMap.find(CUNode);
1864 if (I == CUMap.end())
1870 /// constructGlobalVariableDIE - Construct global variable DIE.
1871 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1872 DIGlobalVariable DI_GV(N);
1874 // If debug information is malformed then ignore it.
1875 if (DI_GV.Verify() == false)
1878 // Check for pre-existence.
1879 CompileUnit *TheCU = getCompileUnit(N);
1880 if (TheCU->getDIE(DI_GV))
1883 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1888 TheCU->insertDIE(N, VariableDie);
1890 // Add to context owner.
1891 DIDescriptor GVContext = DI_GV.getContext();
1892 // Do not create specification DIE if context is either compile unit
1894 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1895 !GVContext.isFile() &&
1896 !isSubprogramContext(GVContext)) {
1897 // Create specification DIE.
1898 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1899 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1900 dwarf::DW_FORM_ref4, VariableDie);
1901 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1902 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1903 addLabel(Block, 0, dwarf::DW_FORM_udata,
1904 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1905 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1906 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1907 TheCU->addDie(VariableSpecDIE);
1909 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1910 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1911 addLabel(Block, 0, dwarf::DW_FORM_udata,
1912 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1913 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1915 addToContextOwner(VariableDie, GVContext);
1917 // Expose as global. FIXME - need to check external flag.
1918 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1920 DIType GTy = DI_GV.getType();
1921 if (GTy.isCompositeType() && !GTy.getName().empty()
1922 && !GTy.isForwardDecl()) {
1923 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1924 assert(Entry && "Missing global type!");
1925 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1930 /// construct SubprogramDIE - Construct subprogram DIE.
1931 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1934 // Check for pre-existence.
1935 CompileUnit *TheCU = getCompileUnit(N);
1936 if (TheCU->getDIE(N))
1939 if (!SP.isDefinition())
1940 // This is a method declaration which will be handled while constructing
1944 DIE *SubprogramDie = createSubprogramDIE(SP);
1947 TheCU->insertDIE(N, SubprogramDie);
1949 // Add to context owner.
1950 addToContextOwner(SubprogramDie, SP.getContext());
1952 // Expose as global.
1953 TheCU->addGlobal(SP.getName(), SubprogramDie);
1958 /// beginModule - Emit all Dwarf sections that should come prior to the
1959 /// content. Create global DIEs and emit initial debug info sections.
1960 /// This is inovked by the target AsmPrinter.
1961 void DwarfDebug::beginModule(Module *M) {
1962 if (DisableDebugInfoPrinting)
1965 DebugInfoFinder DbgFinder;
1966 DbgFinder.processModule(*M);
1968 bool HasDebugInfo = false;
1970 // Scan all the compile-units to see if there are any marked as the main unit.
1971 // if not, we do not generate debug info.
1972 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1973 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1974 if (DICompileUnit(*I).isMain()) {
1975 HasDebugInfo = true;
1980 if (!HasDebugInfo) return;
1982 // Tell MMI that we have debug info.
1983 MMI->setDebugInfoAvailability(true);
1985 // Emit initial sections.
1986 EmitSectionLabels();
1988 // Create all the compile unit DIEs.
1989 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1990 E = DbgFinder.compile_unit_end(); I != E; ++I)
1991 constructCompileUnit(*I);
1993 // Create DIEs for each subprogram.
1994 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1995 E = DbgFinder.subprogram_end(); I != E; ++I)
1996 constructSubprogramDIE(*I);
1998 // Create DIEs for each global variable.
1999 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2000 E = DbgFinder.global_variable_end(); I != E; ++I)
2001 constructGlobalVariableDIE(*I);
2003 // Prime section data.
2004 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2006 // Print out .file directives to specify files for .loc directives. These are
2007 // printed out early so that they precede any .loc directives.
2008 if (Asm->MAI->hasDotLocAndDotFile()) {
2009 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2010 // Remember source id starts at 1.
2011 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2012 // FIXME: don't use sys::path for this! This should not depend on the
2014 sys::Path FullPath(getSourceDirectoryName(Id.first));
2016 FullPath.appendComponent(getSourceFileName(Id.second));
2017 assert(AppendOk && "Could not append filename to directory!");
2019 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2024 /// endModule - Emit all Dwarf sections that should come after the content.
2026 void DwarfDebug::endModule() {
2027 if (!FirstCU) return;
2028 const Module *M = MMI->getModule();
2029 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2030 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2031 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2032 DISubprogram SP(AllSPs->getOperand(SI));
2033 if (!SP.Verify()) continue;
2035 // Collect info for variables that were optimized out.
2036 if (!SP.isDefinition()) continue;
2037 StringRef FName = SP.getLinkageName();
2039 FName = SP.getName();
2041 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2043 unsigned E = NMD->getNumOperands();
2045 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2046 for (unsigned I = 0; I != E; ++I) {
2047 DIVariable DV(NMD->getOperand(I));
2048 if (!DV.Verify()) continue;
2049 Scope->addVariable(new DbgVariable(DV));
2052 // Construct subprogram DIE and add variables DIEs.
2053 constructSubprogramDIE(SP);
2054 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2055 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2056 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2057 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2059 ScopeDIE->addChild(VariableDIE);
2064 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2065 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2066 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2068 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2071 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2072 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2073 DIE *SPDie = CI->first;
2074 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2076 DIE *NDie = getCompileUnit(N)->getDIE(N);
2077 if (!NDie) continue;
2078 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2081 // Standard sections final addresses.
2082 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2083 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2084 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2085 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2087 // End text sections.
2088 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2089 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2090 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2093 // Emit common frame information.
2094 emitCommonDebugFrame();
2096 // Emit function debug frame information
2097 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2098 E = DebugFrames.end(); I != E; ++I)
2099 emitFunctionDebugFrame(*I);
2101 // Compute DIE offsets and sizes.
2102 computeSizeAndOffsets();
2104 // Emit source line correspondence into a debug line section.
2107 // Emit all the DIEs into a debug info section
2110 // Corresponding abbreviations into a abbrev section.
2111 emitAbbreviations();
2113 // Emit info into a debug pubnames section.
2114 emitDebugPubNames();
2116 // Emit info into a debug pubtypes section.
2117 emitDebugPubTypes();
2119 // Emit info into a debug loc section.
2122 // Emit info into a debug aranges section.
2125 // Emit info into a debug ranges section.
2128 // Emit info into a debug macinfo section.
2131 // Emit inline info.
2132 emitDebugInlineInfo();
2134 // Emit info into a debug str section.
2137 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2138 E = CUMap.end(); I != E; ++I)
2140 FirstCU = NULL; // Reset for the next Module, if any.
2143 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2144 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2145 DebugLoc ScopeLoc) {
2147 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2149 return AbsDbgVariable;
2151 LLVMContext &Ctx = Var->getContext();
2152 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2156 AbsDbgVariable = new DbgVariable(Var);
2157 Scope->addVariable(AbsDbgVariable);
2158 AbstractVariables[Var] = AbsDbgVariable;
2159 return AbsDbgVariable;
2162 /// collectVariableInfoFromMMITable - Collect variable information from
2163 /// side table maintained by MMI.
2165 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2166 SmallPtrSet<const MDNode *, 16> &Processed) {
2167 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2168 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2169 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2170 VE = VMap.end(); VI != VE; ++VI) {
2171 const MDNode *Var = VI->first;
2173 Processed.insert(Var);
2175 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2177 DbgScope *Scope = 0;
2178 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2179 Scope = ConcreteScopes.lookup(IA);
2181 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2183 // If variable scope is not found then skip this variable.
2187 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2188 DbgVariable *RegVar = new DbgVariable(DV);
2189 recordVariableFrameIndex(RegVar, VP.first);
2190 Scope->addVariable(RegVar);
2191 if (AbsDbgVariable) {
2192 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2193 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2198 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2199 /// DBG_VALUE instruction, is in undefined reg.
2200 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2201 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2202 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2207 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2208 /// DBG_VALUE instruction, is in a defined reg.
2209 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2210 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2211 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2216 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2218 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2219 SmallPtrSet<const MDNode *, 16> &Processed) {
2221 /// collection info from MMI table.
2222 collectVariableInfoFromMMITable(MF, Processed);
2224 SmallVector<const MachineInstr *, 8> DbgValues;
2225 // Collect variable information from DBG_VALUE machine instructions;
2226 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2228 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2230 const MachineInstr *MInsn = II;
2231 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2233 DbgValues.push_back(MInsn);
2236 // This is a collection of DBV_VALUE instructions describing same variable.
2237 SmallVector<const MachineInstr *, 4> MultipleValues;
2238 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2239 E = DbgValues.end(); I != E; ++I) {
2240 const MachineInstr *MInsn = *I;
2241 MultipleValues.clear();
2242 if (isDbgValueInDefinedReg(MInsn))
2243 MultipleValues.push_back(MInsn);
2244 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2245 if (Processed.count(DV) != 0)
2248 const MachineInstr *PrevMI = MInsn;
2249 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2250 ME = DbgValues.end(); MI != ME; ++MI) {
2252 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2253 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2254 !PrevMI->isIdenticalTo(*MI))
2255 MultipleValues.push_back(*MI);
2259 DbgScope *Scope = findDbgScope(MInsn);
2260 bool CurFnArg = false;
2261 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2262 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2264 if (!Scope && CurFnArg)
2265 Scope = CurrentFnDbgScope;
2266 // If variable scope is not found then skip this variable.
2270 Processed.insert(DV);
2271 DbgVariable *RegVar = new DbgVariable(DV);
2272 Scope->addVariable(RegVar);
2274 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2275 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2276 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2277 VarToAbstractVarMap[RegVar] = AbsVar;
2279 if (MultipleValues.size() <= 1) {
2280 DbgVariableToDbgInstMap[RegVar] = MInsn;
2284 // handle multiple DBG_VALUE instructions describing one variable.
2285 if (DotDebugLocEntries.empty())
2286 RegVar->setDotDebugLocOffset(0);
2288 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2289 const MachineInstr *Begin = NULL;
2290 const MachineInstr *End = NULL;
2291 for (SmallVector<const MachineInstr *, 4>::iterator
2292 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2293 MVI != MVE; ++MVI) {
2299 MachineLocation MLoc;
2300 MLoc.set(Begin->getOperand(0).getReg(), 0);
2301 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2302 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2303 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2305 if (MVI + 1 == MVE) {
2306 // If End is the last instruction then its value is valid
2307 // until the end of the funtion.
2308 MLoc.set(End->getOperand(0).getReg(), 0);
2310 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2313 DotDebugLocEntries.push_back(DotDebugLocEntry());
2316 // Collect info for variables that were optimized out.
2317 const Function *F = MF->getFunction();
2318 const Module *M = F->getParent();
2319 if (NamedMDNode *NMD =
2320 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2321 getRealLinkageName(F->getName())))) {
2322 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2323 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2324 if (!DV || !Processed.insert(DV))
2326 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2328 Scope->addVariable(new DbgVariable(DV));
2333 /// getLabelBeforeInsn - Return Label preceding the instruction.
2334 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2335 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2336 LabelsBeforeInsn.find(MI);
2337 if (I == LabelsBeforeInsn.end())
2338 // FunctionBeginSym always preceeds all the instruction in current function.
2339 return FunctionBeginSym;
2343 /// getLabelAfterInsn - Return Label immediately following the instruction.
2344 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2345 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2346 LabelsAfterInsn.find(MI);
2347 if (I == LabelsAfterInsn.end())
2352 /// beginScope - Process beginning of a scope.
2353 void DwarfDebug::beginScope(const MachineInstr *MI) {
2354 if (InsnNeedsLabel.count(MI) == 0) {
2355 LabelsBeforeInsn[MI] = PrevLabel;
2360 DebugLoc DL = MI->getDebugLoc();
2361 if (!DL.isUnknown()) {
2362 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2363 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2365 LabelsBeforeInsn[MI] = PrevLabel;
2369 // If location is unknown then use temp label for this DBG_VALUE
2371 if (MI->isDebugValue()) {
2372 PrevLabel = MMI->getContext().CreateTempSymbol();
2373 Asm->OutStreamer.EmitLabel(PrevLabel);
2374 LabelsBeforeInsn[MI] = PrevLabel;
2378 if (UnknownLocations) {
2379 PrevLabel = recordSourceLine(0, 0, 0);
2380 LabelsBeforeInsn[MI] = PrevLabel;
2384 assert (0 && "Instruction is not processed!");
2387 /// endScope - Process end of a scope.
2388 void DwarfDebug::endScope(const MachineInstr *MI) {
2389 if (InsnsEndScopeSet.count(MI) != 0) {
2390 // Emit a label if this instruction ends a scope.
2391 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2392 Asm->OutStreamer.EmitLabel(Label);
2393 LabelsAfterInsn[MI] = Label;
2397 /// getOrCreateDbgScope - Create DbgScope for the scope.
2398 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2399 const MDNode *InlinedAt) {
2401 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2404 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2405 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2406 if (DIDescriptor(Scope).isLexicalBlock()) {
2408 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2409 WScope->setParent(Parent);
2410 Parent->addScope(WScope);
2413 if (!WScope->getParent()) {
2414 StringRef SPName = DISubprogram(Scope).getLinkageName();
2415 // We used to check only for a linkage name, but that fails
2416 // since we began omitting the linkage name for private
2417 // functions. The new way is to check for the name in metadata,
2418 // but that's not supported in old .ll test cases. Ergo, we
2420 if (SPName == Asm->MF->getFunction()->getName() ||
2421 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2422 CurrentFnDbgScope = WScope;
2428 getOrCreateAbstractScope(Scope);
2429 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2433 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2434 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2435 DILocation DL(InlinedAt);
2437 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2438 WScope->setParent(Parent);
2439 Parent->addScope(WScope);
2441 ConcreteScopes[InlinedAt] = WScope;
2446 /// hasValidLocation - Return true if debug location entry attached with
2447 /// machine instruction encodes valid location info.
2448 static bool hasValidLocation(LLVMContext &Ctx,
2449 const MachineInstr *MInsn,
2450 const MDNode *&Scope, const MDNode *&InlinedAt) {
2451 DebugLoc DL = MInsn->getDebugLoc();
2452 if (DL.isUnknown()) return false;
2454 const MDNode *S = DL.getScope(Ctx);
2456 // There is no need to create another DIE for compile unit. For all
2457 // other scopes, create one DbgScope now. This will be translated
2458 // into a scope DIE at the end.
2459 if (DIScope(S).isCompileUnit()) return false;
2462 InlinedAt = DL.getInlinedAt(Ctx);
2466 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2468 static void calculateDominanceGraph(DbgScope *Scope) {
2469 assert (Scope && "Unable to calculate scop edominance graph!");
2470 SmallVector<DbgScope *, 4> WorkStack;
2471 WorkStack.push_back(Scope);
2472 unsigned Counter = 0;
2473 while (!WorkStack.empty()) {
2474 DbgScope *WS = WorkStack.back();
2475 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2476 bool visitedChildren = false;
2477 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2478 SE = Children.end(); SI != SE; ++SI) {
2479 DbgScope *ChildScope = *SI;
2480 if (!ChildScope->getDFSOut()) {
2481 WorkStack.push_back(ChildScope);
2482 visitedChildren = true;
2483 ChildScope->setDFSIn(++Counter);
2487 if (!visitedChildren) {
2488 WorkStack.pop_back();
2489 WS->setDFSOut(++Counter);
2494 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2496 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2497 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2500 unsigned PrevDFSIn = 0;
2501 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2503 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2505 const MachineInstr *MInsn = II;
2506 const MDNode *Scope = NULL;
2507 const MDNode *InlinedAt = NULL;
2509 // Check if instruction has valid location information.
2510 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2514 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2515 MI2ScopeMap.find(MInsn);
2516 if (DI != MI2ScopeMap.end()) {
2517 DbgScope *S = DI->second;
2518 dbgs() << S->getDFSIn();
2519 PrevDFSIn = S->getDFSIn();
2521 dbgs() << PrevDFSIn;
2523 dbgs() << " [ x" << PrevDFSIn;
2531 /// extractScopeInformation - Scan machine instructions in this function
2532 /// and collect DbgScopes. Return true, if at least one scope was found.
2533 bool DwarfDebug::extractScopeInformation() {
2534 // If scope information was extracted using .dbg intrinsics then there is not
2535 // any need to extract these information by scanning each instruction.
2536 if (!DbgScopeMap.empty())
2539 // Scan each instruction and create scopes. First build working set of scopes.
2540 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2541 SmallVector<DbgRange, 4> MIRanges;
2542 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2543 const MDNode *PrevScope = NULL;
2544 const MDNode *PrevInlinedAt = NULL;
2545 const MachineInstr *RangeBeginMI = NULL;
2546 const MachineInstr *PrevMI = NULL;
2547 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2549 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2551 const MachineInstr *MInsn = II;
2552 const MDNode *Scope = NULL;
2553 const MDNode *InlinedAt = NULL;
2555 // Check if instruction has valid location information.
2556 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2561 // If scope has not changed then skip this instruction.
2562 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2568 // If we have alread seen a beginning of a instruction range and
2569 // current instruction scope does not match scope of first instruction
2570 // in this range then create a new instruction range.
2571 DbgRange R(RangeBeginMI, PrevMI);
2572 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2574 MIRanges.push_back(R);
2577 // This is a beginning of a new instruction range.
2578 RangeBeginMI = MInsn;
2580 // Reset previous markers.
2583 PrevInlinedAt = InlinedAt;
2587 // Create last instruction range.
2588 if (RangeBeginMI && PrevMI && PrevScope) {
2589 DbgRange R(RangeBeginMI, PrevMI);
2590 MIRanges.push_back(R);
2591 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2594 if (!CurrentFnDbgScope)
2597 calculateDominanceGraph(CurrentFnDbgScope);
2599 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2601 // Find ranges of instructions covered by each DbgScope;
2602 DbgScope *PrevDbgScope = NULL;
2603 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2604 RE = MIRanges.end(); RI != RE; ++RI) {
2605 const DbgRange &R = *RI;
2606 DbgScope *S = MI2ScopeMap.lookup(R.first);
2607 assert (S && "Lost DbgScope for a machine instruction!");
2608 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2609 PrevDbgScope->closeInsnRange(S);
2610 S->openInsnRange(R.first);
2611 S->extendInsnRange(R.second);
2616 PrevDbgScope->closeInsnRange();
2618 identifyScopeMarkers();
2620 return !DbgScopeMap.empty();
2623 /// identifyScopeMarkers() -
2624 /// Each DbgScope has first instruction and last instruction to mark beginning
2625 /// and end of a scope respectively. Create an inverse map that list scopes
2626 /// starts (and ends) with an instruction. One instruction may start (or end)
2627 /// multiple scopes. Ignore scopes that are not reachable.
2628 void DwarfDebug::identifyScopeMarkers() {
2629 SmallVector<DbgScope *, 4> WorkList;
2630 WorkList.push_back(CurrentFnDbgScope);
2631 while (!WorkList.empty()) {
2632 DbgScope *S = WorkList.pop_back_val();
2634 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2635 if (!Children.empty())
2636 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2637 SE = Children.end(); SI != SE; ++SI)
2638 WorkList.push_back(*SI);
2640 if (S->isAbstractScope())
2643 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2646 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2647 RE = Ranges.end(); RI != RE; ++RI) {
2648 assert(RI->first && "DbgRange does not have first instruction!");
2649 assert(RI->second && "DbgRange does not have second instruction!");
2650 InsnsEndScopeSet.insert(RI->second);
2655 /// FindFirstDebugLoc - Find the first debug location in the function. This
2656 /// is intended to be an approximation for the source position of the
2657 /// beginning of the function.
2658 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2659 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2661 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2662 MBBI != MBBE; ++MBBI) {
2663 DebugLoc DL = MBBI->getDebugLoc();
2664 if (!DL.isUnknown())
2670 /// beginFunction - Gather pre-function debug information. Assumes being
2671 /// emitted immediately after the function entry point.
2672 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2673 if (!MMI->hasDebugInfo()) return;
2674 if (!extractScopeInformation()) return;
2676 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2677 Asm->getFunctionNumber());
2678 // Assumes in correct section after the entry point.
2679 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2681 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2683 DebugLoc FDL = FindFirstDebugLoc(MF);
2684 if (FDL.isUnknown()) return;
2686 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2687 const MDNode *TheScope = 0;
2689 DISubprogram SP = getDISubprogram(Scope);
2692 Line = SP.getLineNumber();
2696 Line = FDL.getLine();
2701 recordSourceLine(Line, Col, TheScope);
2703 /// ProcessedArgs - Collection of arguments already processed.
2704 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2707 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2709 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2711 const MachineInstr *MI = II;
2712 DebugLoc DL = MI->getDebugLoc();
2713 if (MI->isDebugValue()) {
2714 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2715 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2716 if (!DV.Verify()) continue;
2717 // If DBG_VALUE is for a local variable then it needs a label.
2718 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2719 && isDbgValueInUndefinedReg(MI) == false)
2720 InsnNeedsLabel.insert(MI);
2721 // DBG_VALUE for inlined functions argument needs a label.
2722 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2723 describes(MF->getFunction()))
2724 InsnNeedsLabel.insert(MI);
2725 // DBG_VALUE indicating argument location change needs a label.
2726 else if (isDbgValueInUndefinedReg(MI) == false
2727 && !ProcessedArgs.insert(DV))
2728 InsnNeedsLabel.insert(MI);
2730 // If location is unknown then instruction needs a location only if
2731 // UnknownLocations flag is set.
2732 if (DL.isUnknown()) {
2733 if (UnknownLocations && !PrevLoc.isUnknown())
2734 InsnNeedsLabel.insert(MI);
2735 } else if (DL != PrevLoc)
2736 // Otherwise, instruction needs a location only if it is new location.
2737 InsnNeedsLabel.insert(MI);
2740 if (!DL.isUnknown() || UnknownLocations)
2744 PrevLabel = FunctionBeginSym;
2747 /// endFunction - Gather and emit post-function debug information.
2749 void DwarfDebug::endFunction(const MachineFunction *MF) {
2750 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2752 if (CurrentFnDbgScope) {
2754 // Define end label for subprogram.
2755 FunctionEndSym = Asm->GetTempSymbol("func_end",
2756 Asm->getFunctionNumber());
2757 // Assumes in correct section after the entry point.
2758 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2760 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2761 collectVariableInfo(MF, ProcessedVars);
2763 // Get function line info.
2764 if (!Lines.empty()) {
2765 // Get section line info.
2766 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2767 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2768 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2769 // Append the function info to section info.
2770 SectionLineInfos.insert(SectionLineInfos.end(),
2771 Lines.begin(), Lines.end());
2774 // Construct abstract scopes.
2775 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2776 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2777 DISubprogram SP((*AI)->getScopeNode());
2779 // Collect info for variables that were optimized out.
2780 StringRef FName = SP.getLinkageName();
2782 FName = SP.getName();
2783 const Module *M = MF->getFunction()->getParent();
2784 if (NamedMDNode *NMD =
2785 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2786 getRealLinkageName(FName)))) {
2787 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2788 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2789 if (!DV || !ProcessedVars.insert(DV))
2791 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2793 Scope->addVariable(new DbgVariable(DV));
2797 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2798 constructScopeDIE(*AI);
2801 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2803 if (!DisableFramePointerElim(*MF))
2804 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2805 dwarf::DW_FORM_flag, 1);
2808 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2809 MMI->getFrameMoves()));
2813 CurrentFnDbgScope = NULL;
2814 InsnNeedsLabel.clear();
2815 DbgVariableToFrameIndexMap.clear();
2816 VarToAbstractVarMap.clear();
2817 DbgVariableToDbgInstMap.clear();
2818 DbgVariableLabelsMap.clear();
2819 DeleteContainerSeconds(DbgScopeMap);
2820 InsnsEndScopeSet.clear();
2821 ConcreteScopes.clear();
2822 DeleteContainerSeconds(AbstractScopes);
2823 AbstractScopesList.clear();
2824 AbstractVariables.clear();
2825 LabelsBeforeInsn.clear();
2826 LabelsAfterInsn.clear();
2831 /// recordVariableFrameIndex - Record a variable's index.
2832 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2833 assert (V && "Invalid DbgVariable!");
2834 DbgVariableToFrameIndexMap[V] = Index;
2837 /// findVariableFrameIndex - Return true if frame index for the variable
2838 /// is found. Update FI to hold value of the index.
2839 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2840 assert (V && "Invalid DbgVariable!");
2841 DenseMap<const DbgVariable *, int>::iterator I =
2842 DbgVariableToFrameIndexMap.find(V);
2843 if (I == DbgVariableToFrameIndexMap.end())
2849 /// findVariableLabel - Find MCSymbol for the variable.
2850 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2851 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2852 = DbgVariableLabelsMap.find(V);
2853 if (I == DbgVariableLabelsMap.end())
2855 else return I->second;
2858 /// findDbgScope - Find DbgScope for the debug loc attached with an
2860 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2861 DbgScope *Scope = NULL;
2863 MInsn->getParent()->getParent()->getFunction()->getContext();
2864 DebugLoc DL = MInsn->getDebugLoc();
2869 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2870 Scope = ConcreteScopes.lookup(IA);
2872 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2878 /// recordSourceLine - Register a source line with debug info. Returns the
2879 /// unique label that was emitted and which provides correspondence to
2880 /// the source line list.
2881 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2888 DIDescriptor Scope(S);
2890 if (Scope.isCompileUnit()) {
2891 DICompileUnit CU(S);
2892 Dir = CU.getDirectory();
2893 Fn = CU.getFilename();
2894 } else if (Scope.isSubprogram()) {
2896 Dir = SP.getDirectory();
2897 Fn = SP.getFilename();
2898 } else if (Scope.isLexicalBlock()) {
2899 DILexicalBlock DB(S);
2900 Dir = DB.getDirectory();
2901 Fn = DB.getFilename();
2903 assert(0 && "Unexpected scope info");
2905 Src = GetOrCreateSourceID(Dir, Fn);
2908 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2909 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2911 Asm->OutStreamer.EmitLabel(Label);
2915 //===----------------------------------------------------------------------===//
2917 //===----------------------------------------------------------------------===//
2919 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2922 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2923 // Get the children.
2924 const std::vector<DIE *> &Children = Die->getChildren();
2926 // If not last sibling and has children then add sibling offset attribute.
2927 if (!Last && !Children.empty())
2928 Die->addSiblingOffset(DIEValueAllocator);
2930 // Record the abbreviation.
2931 assignAbbrevNumber(Die->getAbbrev());
2933 // Get the abbreviation for this DIE.
2934 unsigned AbbrevNumber = Die->getAbbrevNumber();
2935 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2938 Die->setOffset(Offset);
2940 // Start the size with the size of abbreviation code.
2941 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2943 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2944 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2946 // Size the DIE attribute values.
2947 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2948 // Size attribute value.
2949 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2951 // Size the DIE children if any.
2952 if (!Children.empty()) {
2953 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2954 "Children flag not set");
2956 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2957 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2959 // End of children marker.
2960 Offset += sizeof(int8_t);
2963 Die->setSize(Offset - Die->getOffset());
2967 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2969 void DwarfDebug::computeSizeAndOffsets() {
2970 unsigned PrevOffset = 0;
2971 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2972 E = CUMap.end(); I != E; ++I) {
2973 // Compute size of compile unit header.
2974 static unsigned Offset = PrevOffset +
2975 sizeof(int32_t) + // Length of Compilation Unit Info
2976 sizeof(int16_t) + // DWARF version number
2977 sizeof(int32_t) + // Offset Into Abbrev. Section
2978 sizeof(int8_t); // Pointer Size (in bytes)
2979 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2980 PrevOffset = Offset;
2984 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2985 /// temporary label to it if SymbolStem is specified.
2986 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2987 const char *SymbolStem = 0) {
2988 Asm->OutStreamer.SwitchSection(Section);
2989 if (!SymbolStem) return 0;
2991 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2992 Asm->OutStreamer.EmitLabel(TmpSym);
2996 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2997 /// the start of each one.
2998 void DwarfDebug::EmitSectionLabels() {
2999 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3001 // Dwarf sections base addresses.
3002 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3003 DwarfFrameSectionSym =
3004 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3007 DwarfInfoSectionSym =
3008 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3009 DwarfAbbrevSectionSym =
3010 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3011 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3013 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3014 EmitSectionSym(Asm, MacroInfo);
3016 DwarfDebugLineSectionSym =
3017 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3018 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3019 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3020 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3021 DwarfStrSectionSym =
3022 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3023 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3026 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3027 "section_debug_loc");
3029 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3030 EmitSectionSym(Asm, TLOF.getDataSection());
3033 /// emitDIE - Recusively Emits a debug information entry.
3035 void DwarfDebug::emitDIE(DIE *Die) {
3036 // Get the abbreviation for this DIE.
3037 unsigned AbbrevNumber = Die->getAbbrevNumber();
3038 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3040 // Emit the code (index) for the abbreviation.
3041 if (Asm->isVerbose())
3042 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3043 Twine::utohexstr(Die->getOffset()) + ":0x" +
3044 Twine::utohexstr(Die->getSize()) + " " +
3045 dwarf::TagString(Abbrev->getTag()));
3046 Asm->EmitULEB128(AbbrevNumber);
3048 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3049 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3051 // Emit the DIE attribute values.
3052 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3053 unsigned Attr = AbbrevData[i].getAttribute();
3054 unsigned Form = AbbrevData[i].getForm();
3055 assert(Form && "Too many attributes for DIE (check abbreviation)");
3057 if (Asm->isVerbose())
3058 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3061 case dwarf::DW_AT_sibling:
3062 Asm->EmitInt32(Die->getSiblingOffset());
3064 case dwarf::DW_AT_abstract_origin: {
3065 DIEEntry *E = cast<DIEEntry>(Values[i]);
3066 DIE *Origin = E->getEntry();
3067 unsigned Addr = Origin->getOffset();
3068 Asm->EmitInt32(Addr);
3071 case dwarf::DW_AT_ranges: {
3072 // DW_AT_range Value encodes offset in debug_range section.
3073 DIEInteger *V = cast<DIEInteger>(Values[i]);
3074 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3076 DwarfDebugRangeSectionSym,
3080 case dwarf::DW_AT_stmt_list: {
3081 Asm->EmitLabelDifference(CurrentLineSectionSym,
3082 DwarfDebugLineSectionSym, 4);
3085 case dwarf::DW_AT_location: {
3086 if (UseDotDebugLocEntry.count(Die) != 0) {
3087 DIELabel *L = cast<DIELabel>(Values[i]);
3088 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3090 Values[i]->EmitValue(Asm, Form);
3094 // Emit an attribute using the defined form.
3095 Values[i]->EmitValue(Asm, Form);
3100 // Emit the DIE children if any.
3101 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3102 const std::vector<DIE *> &Children = Die->getChildren();
3104 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3105 emitDIE(Children[j]);
3107 if (Asm->isVerbose())
3108 Asm->OutStreamer.AddComment("End Of Children Mark");
3113 /// emitDebugInfo - Emit the debug info section.
3115 void DwarfDebug::emitDebugInfo() {
3116 // Start debug info section.
3117 Asm->OutStreamer.SwitchSection(
3118 Asm->getObjFileLowering().getDwarfInfoSection());
3119 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3120 E = CUMap.end(); I != E; ++I) {
3121 CompileUnit *TheCU = I->second;
3122 DIE *Die = TheCU->getCUDie();
3124 // Emit the compile units header.
3125 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3128 // Emit size of content not including length itself
3129 unsigned ContentSize = Die->getSize() +
3130 sizeof(int16_t) + // DWARF version number
3131 sizeof(int32_t) + // Offset Into Abbrev. Section
3132 sizeof(int8_t) + // Pointer Size (in bytes)
3133 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3135 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3136 Asm->EmitInt32(ContentSize);
3137 Asm->OutStreamer.AddComment("DWARF version number");
3138 Asm->EmitInt16(dwarf::DWARF_VERSION);
3139 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3140 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3141 DwarfAbbrevSectionSym);
3142 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3143 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3146 // FIXME - extra padding for gdb bug.
3147 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3152 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3156 /// emitAbbreviations - Emit the abbreviation section.
3158 void DwarfDebug::emitAbbreviations() const {
3159 // Check to see if it is worth the effort.
3160 if (!Abbreviations.empty()) {
3161 // Start the debug abbrev section.
3162 Asm->OutStreamer.SwitchSection(
3163 Asm->getObjFileLowering().getDwarfAbbrevSection());
3165 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3167 // For each abbrevation.
3168 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3169 // Get abbreviation data
3170 const DIEAbbrev *Abbrev = Abbreviations[i];
3172 // Emit the abbrevations code (base 1 index.)
3173 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3175 // Emit the abbreviations data.
3179 // Mark end of abbreviations.
3180 Asm->EmitULEB128(0, "EOM(3)");
3182 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3186 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3187 /// the line matrix.
3189 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3190 // Define last address of section.
3191 Asm->OutStreamer.AddComment("Extended Op");
3194 Asm->OutStreamer.AddComment("Op size");
3195 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3196 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3197 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3199 Asm->OutStreamer.AddComment("Section end label");
3201 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3202 Asm->getTargetData().getPointerSize(),
3205 // Mark end of matrix.
3206 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3212 /// emitDebugLines - Emit source line information.
3214 void DwarfDebug::emitDebugLines() {
3215 // If the target is using .loc/.file, the assembler will be emitting the
3216 // .debug_line table automatically.
3217 if (Asm->MAI->hasDotLocAndDotFile())
3220 // Minimum line delta, thus ranging from -10..(255-10).
3221 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3222 // Maximum line delta, thus ranging from -10..(255-10).
3223 const int MaxLineDelta = 255 + MinLineDelta;
3225 // Start the dwarf line section.
3226 Asm->OutStreamer.SwitchSection(
3227 Asm->getObjFileLowering().getDwarfLineSection());
3229 // Construct the section header.
3230 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3231 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3232 Asm->OutStreamer.AddComment("Length of Source Line Info");
3233 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3234 Asm->GetTempSymbol("line_begin"), 4);
3235 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3237 Asm->OutStreamer.AddComment("DWARF version number");
3238 Asm->EmitInt16(dwarf::DWARF_VERSION);
3240 Asm->OutStreamer.AddComment("Prolog Length");
3241 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3242 Asm->GetTempSymbol("line_prolog_begin"), 4);
3243 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3245 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3247 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3249 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3250 Asm->EmitInt8(MinLineDelta);
3251 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3252 Asm->EmitInt8(MaxLineDelta);
3253 Asm->OutStreamer.AddComment("Special Opcode Base");
3254 Asm->EmitInt8(-MinLineDelta);
3256 // Line number standard opcode encodings argument count
3257 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3259 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3261 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3263 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3265 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3267 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3269 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3271 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3273 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3276 // Emit directories.
3277 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3278 const std::string &Dir = getSourceDirectoryName(DI);
3279 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3280 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3283 Asm->OutStreamer.AddComment("End of directories");
3287 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3288 // Remember source id starts at 1.
3289 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3290 const std::string &FN = getSourceFileName(Id.second);
3291 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3292 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3294 Asm->EmitULEB128(Id.first, "Directory #");
3295 Asm->EmitULEB128(0, "Mod date");
3296 Asm->EmitULEB128(0, "File size");
3299 Asm->OutStreamer.AddComment("End of files");
3302 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3304 // A sequence for each text section.
3305 unsigned SecSrcLinesSize = SectionSourceLines.size();
3307 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3308 // Isolate current sections line info.
3309 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3311 // Dwarf assumes we start with first line of first source file.
3312 unsigned Source = 1;
3315 // Construct rows of the address, source, line, column matrix.
3316 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3317 const SrcLineInfo &LineInfo = LineInfos[i];
3318 MCSymbol *Label = LineInfo.getLabel();
3319 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3321 if (Asm->isVerbose()) {
3322 std::pair<unsigned, unsigned> SrcID =
3323 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3324 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3326 Twine(getSourceFileName(SrcID.second)) +
3327 ":" + Twine(LineInfo.getLine()));
3330 // Define the line address.
3331 Asm->OutStreamer.AddComment("Extended Op");
3333 Asm->OutStreamer.AddComment("Op size");
3334 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3336 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3337 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3339 Asm->OutStreamer.AddComment("Location label");
3340 Asm->OutStreamer.EmitSymbolValue(Label,
3341 Asm->getTargetData().getPointerSize(),
3344 // If change of source, then switch to the new source.
3345 if (Source != LineInfo.getSourceID()) {
3346 Source = LineInfo.getSourceID();
3347 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3348 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3349 Asm->EmitULEB128(Source, "New Source");
3352 // If change of line.
3353 if (Line != LineInfo.getLine()) {
3354 // Determine offset.
3355 int Offset = LineInfo.getLine() - Line;
3356 int Delta = Offset - MinLineDelta;
3359 Line = LineInfo.getLine();
3361 // If delta is small enough and in range...
3362 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3363 // ... then use fast opcode.
3364 Asm->OutStreamer.AddComment("Line Delta");
3365 Asm->EmitInt8(Delta - MinLineDelta);
3367 // ... otherwise use long hand.
3368 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3369 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3370 Asm->EmitSLEB128(Offset, "Line Offset");
3371 Asm->OutStreamer.AddComment("DW_LNS_copy");
3372 Asm->EmitInt8(dwarf::DW_LNS_copy);
3375 // Copy the previous row (different address or source)
3376 Asm->OutStreamer.AddComment("DW_LNS_copy");
3377 Asm->EmitInt8(dwarf::DW_LNS_copy);
3381 emitEndOfLineMatrix(j + 1);
3384 if (SecSrcLinesSize == 0)
3385 // Because we're emitting a debug_line section, we still need a line
3386 // table. The linker and friends expect it to exist. If there's nothing to
3387 // put into it, emit an empty table.
3388 emitEndOfLineMatrix(1);
3390 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3393 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3395 void DwarfDebug::emitCommonDebugFrame() {
3396 if (!Asm->MAI->doesDwarfRequireFrameSection())
3399 int stackGrowth = Asm->getTargetData().getPointerSize();
3400 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3401 TargetFrameInfo::StackGrowsDown)
3404 // Start the dwarf frame section.
3405 Asm->OutStreamer.SwitchSection(
3406 Asm->getObjFileLowering().getDwarfFrameSection());
3408 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3409 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3410 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3411 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3413 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3414 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3415 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3416 Asm->OutStreamer.AddComment("CIE Version");
3417 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3418 Asm->OutStreamer.AddComment("CIE Augmentation");
3419 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3420 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3421 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3422 Asm->OutStreamer.AddComment("CIE RA Column");
3423 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3424 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3426 std::vector<MachineMove> Moves;
3427 RI->getInitialFrameState(Moves);
3429 Asm->EmitFrameMoves(Moves, 0, false);
3431 Asm->EmitAlignment(2);
3432 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3435 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3438 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3439 if (!Asm->MAI->doesDwarfRequireFrameSection())
3442 // Start the dwarf frame section.
3443 Asm->OutStreamer.SwitchSection(
3444 Asm->getObjFileLowering().getDwarfFrameSection());
3446 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3447 MCSymbol *DebugFrameBegin =
3448 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3449 MCSymbol *DebugFrameEnd =
3450 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3451 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3453 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3455 Asm->OutStreamer.AddComment("FDE CIE offset");
3456 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3457 DwarfFrameSectionSym);
3459 Asm->OutStreamer.AddComment("FDE initial location");
3460 MCSymbol *FuncBeginSym =
3461 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3462 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3463 Asm->getTargetData().getPointerSize(),
3467 Asm->OutStreamer.AddComment("FDE address range");
3468 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3469 FuncBeginSym, Asm->getTargetData().getPointerSize());
3471 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3473 Asm->EmitAlignment(2);
3474 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3477 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3479 void DwarfDebug::emitDebugPubNames() {
3480 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3481 E = CUMap.end(); I != E; ++I) {
3482 CompileUnit *TheCU = I->second;
3483 // Start the dwarf pubnames section.
3484 Asm->OutStreamer.SwitchSection(
3485 Asm->getObjFileLowering().getDwarfPubNamesSection());
3487 Asm->OutStreamer.AddComment("Length of Public Names Info");
3488 Asm->EmitLabelDifference(
3489 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3490 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3492 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3495 Asm->OutStreamer.AddComment("DWARF Version");
3496 Asm->EmitInt16(dwarf::DWARF_VERSION);
3498 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3499 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3500 DwarfInfoSectionSym);
3502 Asm->OutStreamer.AddComment("Compilation Unit Length");
3503 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3504 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3507 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3508 for (StringMap<DIE*>::const_iterator
3509 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3510 const char *Name = GI->getKeyData();
3511 DIE *Entity = GI->second;
3513 Asm->OutStreamer.AddComment("DIE offset");
3514 Asm->EmitInt32(Entity->getOffset());
3516 if (Asm->isVerbose())
3517 Asm->OutStreamer.AddComment("External Name");
3518 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3521 Asm->OutStreamer.AddComment("End Mark");
3523 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3528 void DwarfDebug::emitDebugPubTypes() {
3529 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3530 E = CUMap.end(); I != E; ++I) {
3531 CompileUnit *TheCU = I->second;
3532 // Start the dwarf pubnames section.
3533 Asm->OutStreamer.SwitchSection(
3534 Asm->getObjFileLowering().getDwarfPubTypesSection());
3535 Asm->OutStreamer.AddComment("Length of Public Types Info");
3536 Asm->EmitLabelDifference(
3537 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3538 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3540 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3543 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3544 Asm->EmitInt16(dwarf::DWARF_VERSION);
3546 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3547 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3548 DwarfInfoSectionSym);
3550 Asm->OutStreamer.AddComment("Compilation Unit Length");
3551 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3552 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3555 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3556 for (StringMap<DIE*>::const_iterator
3557 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3558 const char *Name = GI->getKeyData();
3559 DIE * Entity = GI->second;
3561 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3562 Asm->EmitInt32(Entity->getOffset());
3564 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3565 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3568 Asm->OutStreamer.AddComment("End Mark");
3570 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3575 /// emitDebugStr - Emit visible names into a debug str section.
3577 void DwarfDebug::emitDebugStr() {
3578 // Check to see if it is worth the effort.
3579 if (StringPool.empty()) return;
3581 // Start the dwarf str section.
3582 Asm->OutStreamer.SwitchSection(
3583 Asm->getObjFileLowering().getDwarfStrSection());
3585 // Get all of the string pool entries and put them in an array by their ID so
3586 // we can sort them.
3587 SmallVector<std::pair<unsigned,
3588 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3590 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3591 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3592 Entries.push_back(std::make_pair(I->second.second, &*I));
3594 array_pod_sort(Entries.begin(), Entries.end());
3596 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3597 // Emit a label for reference from debug information entries.
3598 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3600 // Emit the string itself.
3601 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3605 /// emitDebugLoc - Emit visible names into a debug loc section.
3607 void DwarfDebug::emitDebugLoc() {
3608 if (DotDebugLocEntries.empty())
3611 // Start the dwarf loc section.
3612 Asm->OutStreamer.SwitchSection(
3613 Asm->getObjFileLowering().getDwarfLocSection());
3614 unsigned char Size = Asm->getTargetData().getPointerSize();
3615 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3617 for (SmallVector<DotDebugLocEntry, 4>::iterator
3618 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3619 I != E; ++I, ++index) {
3620 DotDebugLocEntry Entry = *I;
3621 if (Entry.isEmpty()) {
3622 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3623 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3624 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3626 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3627 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3628 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3629 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3631 Asm->OutStreamer.AddComment("Loc expr size");
3633 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3635 Asm->OutStreamer.AddComment("Loc expr size");
3636 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3637 Asm->EmitInt8(dwarf::DW_OP_regx);
3638 Asm->EmitULEB128(Reg);
3644 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3646 void DwarfDebug::EmitDebugARanges() {
3647 // Start the dwarf aranges section.
3648 Asm->OutStreamer.SwitchSection(
3649 Asm->getObjFileLowering().getDwarfARangesSection());
3652 /// emitDebugRanges - Emit visible names into a debug ranges section.
3654 void DwarfDebug::emitDebugRanges() {
3655 // Start the dwarf ranges section.
3656 Asm->OutStreamer.SwitchSection(
3657 Asm->getObjFileLowering().getDwarfRangesSection());
3658 unsigned char Size = Asm->getTargetData().getPointerSize();
3659 for (SmallVector<const MCSymbol *, 8>::iterator
3660 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3663 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3665 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3669 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3671 void DwarfDebug::emitDebugMacInfo() {
3672 if (const MCSection *LineInfo =
3673 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3674 // Start the dwarf macinfo section.
3675 Asm->OutStreamer.SwitchSection(LineInfo);
3679 /// emitDebugInlineInfo - Emit inline info using following format.
3681 /// 1. length of section
3682 /// 2. Dwarf version number
3683 /// 3. address size.
3685 /// Entries (one "entry" for each function that was inlined):
3687 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3688 /// otherwise offset into __debug_str for regular function name.
3689 /// 2. offset into __debug_str section for regular function name.
3690 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3691 /// instances for the function.
3693 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3694 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3695 /// __debug_info section, and the low_pc is the starting address for the
3696 /// inlining instance.
3697 void DwarfDebug::emitDebugInlineInfo() {
3698 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3704 Asm->OutStreamer.SwitchSection(
3705 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3707 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3708 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3709 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3711 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3713 Asm->OutStreamer.AddComment("Dwarf Version");
3714 Asm->EmitInt16(dwarf::DWARF_VERSION);
3715 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3716 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3718 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3719 E = InlinedSPNodes.end(); I != E; ++I) {
3721 const MDNode *Node = *I;
3722 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3723 = InlineInfo.find(Node);
3724 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3725 DISubprogram SP(Node);
3726 StringRef LName = SP.getLinkageName();
3727 StringRef Name = SP.getName();
3729 Asm->OutStreamer.AddComment("MIPS linkage name");
3730 if (LName.empty()) {
3731 Asm->OutStreamer.EmitBytes(Name, 0);
3732 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3734 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3735 DwarfStrSectionSym);
3737 Asm->OutStreamer.AddComment("Function name");
3738 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3739 Asm->EmitULEB128(Labels.size(), "Inline count");
3741 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3742 LE = Labels.end(); LI != LE; ++LI) {
3743 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3744 Asm->EmitInt32(LI->second->getOffset());
3746 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3747 Asm->OutStreamer.EmitSymbolValue(LI->first,
3748 Asm->getTargetData().getPointerSize(),0);
3752 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));