1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
49 cl::desc("Disable debug info printing"));
51 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58 } // end anonymous namespace
60 //===----------------------------------------------------------------------===//
62 /// Configuration values for initial hash set sizes (log2).
64 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
68 //===----------------------------------------------------------------------===//
69 /// CompileUnit - This dwarf writer support class manages information associate
70 /// with a source file.
72 /// ID - File identifier for source.
76 /// Die - Compile unit debug information entry.
78 const OwningPtr<DIE> CUDie;
80 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
83 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
84 /// variables to debug information entries.
85 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
87 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
89 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
91 /// Globals - A map of globally visible named entities for this unit.
93 StringMap<DIE*> Globals;
95 /// GlobalTypes - A map of globally visible types for this unit.
97 StringMap<DIE*> GlobalTypes;
100 CompileUnit(unsigned I, DIE *D)
101 : ID(I), CUDie(D), IndexTyDie(0) {}
104 unsigned getID() const { return ID; }
105 DIE* getCUDie() const { return CUDie.get(); }
106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
109 /// hasContent - Return true if this compile unit has something to write out.
111 bool hasContent() const { return !CUDie->getChildren().empty(); }
113 /// addGlobal - Add a new global entity to the compile unit.
115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
117 /// addGlobalType - Add a new global type to the compile unit.
119 void addGlobalType(StringRef Name, DIE *Die) {
120 GlobalTypes[Name] = Die;
123 /// getDIE - Returns the debug information entry map slot for the
124 /// specified debug variable.
125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
127 /// insertDIE - Insert DIE into the map.
128 void insertDIE(const MDNode *N, DIE *D) {
129 MDNodeToDieMap.insert(std::make_pair(N, D));
132 /// getDIEEntry - Returns the debug information entry for the speciefied
134 DIEEntry *getDIEEntry(const MDNode *N) {
135 DenseMap<const MDNode *, DIEEntry *>::iterator I = MDNodeToDIEEntryMap.find(N);
136 if (I == MDNodeToDIEEntryMap.end())
141 /// insertDIEEntry - Insert debug information entry into the map.
142 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
143 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
146 /// addDie - Adds or interns the DIE to the compile unit.
148 void addDie(DIE *Buffer) {
149 this->CUDie->addChild(Buffer);
152 // getIndexTyDie - Get an anonymous type for index type.
153 DIE *getIndexTyDie() {
157 // setIndexTyDie - Set D as anonymous type for index which can be reused
159 void setIndexTyDie(DIE *D) {
165 //===----------------------------------------------------------------------===//
166 /// DbgVariable - This class is used to track local variable information.
169 DIVariable Var; // Variable Descriptor.
170 DIE *TheDIE; // Variable DIE.
171 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
173 // AbsVar may be NULL.
174 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
177 DIVariable getVariable() const { return Var; }
178 void setDIE(DIE *D) { TheDIE = D; }
179 DIE *getDIE() const { return TheDIE; }
180 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
181 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
184 //===----------------------------------------------------------------------===//
185 /// DbgRange - This is used to track range of instructions with identical
186 /// debug info scope.
188 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
190 //===----------------------------------------------------------------------===//
191 /// DbgScope - This class is used to track scope information.
194 DbgScope *Parent; // Parent to this scope.
195 DIDescriptor Desc; // Debug info descriptor for scope.
196 // Location at which this scope is inlined.
197 AssertingVH<const MDNode> InlinedAtLocation;
198 bool AbstractScope; // Abstract Scope
199 const MachineInstr *LastInsn; // Last instruction of this scope.
200 const MachineInstr *FirstInsn; // First instruction of this scope.
201 unsigned DFSIn, DFSOut;
202 // Scopes defined in scope. Contents not owned.
203 SmallVector<DbgScope *, 4> Scopes;
204 // Variables declared in scope. Contents owned.
205 SmallVector<DbgVariable *, 8> Variables;
206 SmallVector<DbgRange, 4> Ranges;
207 // Private state for dump()
208 mutable unsigned IndentLevel;
210 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
211 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
212 LastInsn(0), FirstInsn(0),
213 DFSIn(0), DFSOut(0), IndentLevel(0) {}
217 DbgScope *getParent() const { return Parent; }
218 void setParent(DbgScope *P) { Parent = P; }
219 DIDescriptor getDesc() const { return Desc; }
220 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
221 const MDNode *getScopeNode() const { return Desc; }
222 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
223 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
224 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
226 /// openInsnRange - This scope covers instruction range starting from MI.
227 void openInsnRange(const MachineInstr *MI) {
232 Parent->openInsnRange(MI);
235 /// extendInsnRange - Extend the current instruction range covered by
237 void extendInsnRange(const MachineInstr *MI) {
238 assert (FirstInsn && "MI Range is not open!");
241 Parent->extendInsnRange(MI);
244 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
245 /// until now. This is used when a new scope is encountered while walking
246 /// machine instructions.
247 void closeInsnRange(DbgScope *NewScope = NULL) {
248 assert (LastInsn && "Last insn missing!");
249 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
252 // If Parent dominates NewScope then do not close Parent's instruction
254 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
255 Parent->closeInsnRange(NewScope);
258 void setAbstractScope() { AbstractScope = true; }
259 bool isAbstractScope() const { return AbstractScope; }
261 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
262 unsigned getDFSOut() const { return DFSOut; }
263 void setDFSOut(unsigned O) { DFSOut = O; }
264 unsigned getDFSIn() const { return DFSIn; }
265 void setDFSIn(unsigned I) { DFSIn = I; }
266 bool dominates(const DbgScope *S) {
269 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
274 /// addScope - Add a scope to the scope.
276 void addScope(DbgScope *S) { Scopes.push_back(S); }
278 /// addVariable - Add a variable to the scope.
280 void addVariable(DbgVariable *V) { Variables.push_back(V); }
287 } // end llvm namespace
290 void DbgScope::dump() const {
291 raw_ostream &err = dbgs();
292 err.indent(IndentLevel);
293 const MDNode *N = Desc;
296 err << "Abstract Scope\n";
300 err << "Children ...\n";
301 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
302 if (Scopes[i] != this)
309 DbgScope::~DbgScope() {
310 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
314 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
315 : Asm(A), MMI(Asm->MMI), FirstCU(0),
316 AbbreviationsSet(InitAbbreviationsSetSize),
317 CurrentFnDbgScope(0), PrevLabel(NULL) {
318 NextStringPoolNumber = 0;
320 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
321 DwarfStrSectionSym = TextSectionSym = 0;
322 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
323 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
324 FunctionBeginSym = FunctionEndSym = 0;
325 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
327 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
331 DwarfDebug::~DwarfDebug() {
332 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
333 DIEBlocks[j]->~DIEBlock();
336 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
337 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
338 if (Entry.first) return Entry.first;
340 Entry.second = NextStringPoolNumber++;
341 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
345 /// assignAbbrevNumber - Define a unique number for the abbreviation.
347 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
348 // Profile the node so that we can make it unique.
352 // Check the set for priors.
353 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
355 // If it's newly added.
356 if (InSet == &Abbrev) {
357 // Add to abbreviation list.
358 Abbreviations.push_back(&Abbrev);
360 // Assign the vector position + 1 as its number.
361 Abbrev.setNumber(Abbreviations.size());
363 // Assign existing abbreviation number.
364 Abbrev.setNumber(InSet->getNumber());
368 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
369 /// information entry.
370 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
371 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
375 /// addUInt - Add an unsigned integer attribute data and value.
377 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
378 unsigned Form, uint64_t Integer) {
379 if (!Form) Form = DIEInteger::BestForm(false, Integer);
380 DIEValue *Value = Integer == 1 ?
381 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
382 Die->addValue(Attribute, Form, Value);
385 /// addSInt - Add an signed integer attribute data and value.
387 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
388 unsigned Form, int64_t Integer) {
389 if (!Form) Form = DIEInteger::BestForm(true, Integer);
390 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
391 Die->addValue(Attribute, Form, Value);
394 /// addString - Add a string attribute data and value. DIEString only
395 /// keeps string reference.
396 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
398 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
399 Die->addValue(Attribute, Form, Value);
402 /// addLabel - Add a Dwarf label attribute data and value.
404 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
405 const MCSymbol *Label) {
406 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
407 Die->addValue(Attribute, Form, Value);
410 /// addDelta - Add a label delta attribute data and value.
412 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
413 const MCSymbol *Hi, const MCSymbol *Lo) {
414 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
415 Die->addValue(Attribute, Form, Value);
418 /// addDIEEntry - Add a DIE attribute data and value.
420 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
422 Die->addValue(Attribute, Form, createDIEEntry(Entry));
426 /// addBlock - Add block data.
428 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
430 Block->ComputeSize(Asm);
431 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
432 Die->addValue(Attribute, Block->BestForm(), Block);
435 /// addSourceLine - Add location information to specified debug information
437 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
442 unsigned Line = V->getLineNumber();
443 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
444 V->getContext().getFilename());
445 assert(FileID && "Invalid file id");
446 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
447 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
450 /// addSourceLine - Add location information to specified debug information
452 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
453 // Verify global variable.
457 unsigned Line = G->getLineNumber();
458 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
459 G->getContext().getFilename());
460 assert(FileID && "Invalid file id");
461 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
462 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
465 /// addSourceLine - Add location information to specified debug information
467 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
468 // Verify subprogram.
471 // If the line number is 0, don't add it.
472 if (SP->getLineNumber() == 0)
475 unsigned Line = SP->getLineNumber();
476 if (!SP->getContext().Verify())
478 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
480 assert(FileID && "Invalid file id");
481 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
482 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
485 /// addSourceLine - Add location information to specified debug information
487 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
492 unsigned Line = Ty->getLineNumber();
493 if (!Ty->getContext().Verify())
495 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
496 Ty->getContext().getFilename());
497 assert(FileID && "Invalid file id");
498 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
499 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
502 /// addSourceLine - Add location information to specified debug information
504 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
509 unsigned Line = NS->getLineNumber();
510 StringRef FN = NS->getFilename();
511 StringRef Dir = NS->getDirectory();
513 unsigned FileID = GetOrCreateSourceID(Dir, FN);
514 assert(FileID && "Invalid file id");
515 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
516 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
519 /* Byref variables, in Blocks, are declared by the programmer as
520 "SomeType VarName;", but the compiler creates a
521 __Block_byref_x_VarName struct, and gives the variable VarName
522 either the struct, or a pointer to the struct, as its type. This
523 is necessary for various behind-the-scenes things the compiler
524 needs to do with by-reference variables in blocks.
526 However, as far as the original *programmer* is concerned, the
527 variable should still have type 'SomeType', as originally declared.
529 The following function dives into the __Block_byref_x_VarName
530 struct to find the original type of the variable. This will be
531 passed back to the code generating the type for the Debug
532 Information Entry for the variable 'VarName'. 'VarName' will then
533 have the original type 'SomeType' in its debug information.
535 The original type 'SomeType' will be the type of the field named
536 'VarName' inside the __Block_byref_x_VarName struct.
538 NOTE: In order for this to not completely fail on the debugger
539 side, the Debug Information Entry for the variable VarName needs to
540 have a DW_AT_location that tells the debugger how to unwind through
541 the pointers and __Block_byref_x_VarName struct to find the actual
542 value of the variable. The function addBlockByrefType does this. */
544 /// Find the type the programmer originally declared the variable to be
545 /// and return that type.
547 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
550 unsigned tag = Ty.getTag();
552 if (tag == dwarf::DW_TAG_pointer_type) {
553 DIDerivedType DTy = DIDerivedType(Ty);
554 subType = DTy.getTypeDerivedFrom();
557 DICompositeType blockStruct = DICompositeType(subType);
558 DIArray Elements = blockStruct.getTypeArray();
560 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
561 DIDescriptor Element = Elements.getElement(i);
562 DIDerivedType DT = DIDerivedType(Element);
563 if (Name == DT.getName())
564 return (DT.getTypeDerivedFrom());
570 /// addComplexAddress - Start with the address based on the location provided,
571 /// and generate the DWARF information necessary to find the actual variable
572 /// given the extra address information encoded in the DIVariable, starting from
573 /// the starting location. Add the DWARF information to the die.
575 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
577 const MachineLocation &Location) {
578 const DIVariable &VD = DV->getVariable();
579 DIType Ty = VD.getType();
581 // Decode the original location, and use that as the start of the byref
582 // variable's location.
583 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
584 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
585 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
587 if (Location.isReg()) {
589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
591 Reg = Reg - dwarf::DW_OP_reg0;
592 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
593 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
599 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
600 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
603 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
606 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
607 uint64_t Element = VD.getAddrElement(i);
609 if (Element == DIFactory::OpPlus) {
610 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
611 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
612 } else if (Element == DIFactory::OpDeref) {
613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
614 } else llvm_unreachable("unknown DIFactory Opcode");
617 // Now attach the location information to the DIE.
618 addBlock(Die, Attribute, 0, Block);
621 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
622 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
623 gives the variable VarName either the struct, or a pointer to the struct, as
624 its type. This is necessary for various behind-the-scenes things the
625 compiler needs to do with by-reference variables in Blocks.
627 However, as far as the original *programmer* is concerned, the variable
628 should still have type 'SomeType', as originally declared.
630 The function getBlockByrefType dives into the __Block_byref_x_VarName
631 struct to find the original type of the variable, which is then assigned to
632 the variable's Debug Information Entry as its real type. So far, so good.
633 However now the debugger will expect the variable VarName to have the type
634 SomeType. So we need the location attribute for the variable to be an
635 expression that explains to the debugger how to navigate through the
636 pointers and struct to find the actual variable of type SomeType.
638 The following function does just that. We start by getting
639 the "normal" location for the variable. This will be the location
640 of either the struct __Block_byref_x_VarName or the pointer to the
641 struct __Block_byref_x_VarName.
643 The struct will look something like:
645 struct __Block_byref_x_VarName {
647 struct __Block_byref_x_VarName *forwarding;
648 ... <various other fields>
650 ... <maybe more fields>
653 If we are given the struct directly (as our starting point) we
654 need to tell the debugger to:
656 1). Add the offset of the forwarding field.
658 2). Follow that pointer to get the real __Block_byref_x_VarName
659 struct to use (the real one may have been copied onto the heap).
661 3). Add the offset for the field VarName, to find the actual variable.
663 If we started with a pointer to the struct, then we need to
664 dereference that pointer first, before the other steps.
665 Translating this into DWARF ops, we will need to append the following
666 to the current location description for the variable:
668 DW_OP_deref -- optional, if we start with a pointer
669 DW_OP_plus_uconst <forward_fld_offset>
671 DW_OP_plus_uconst <varName_fld_offset>
673 That is what this function does. */
675 /// addBlockByrefAddress - Start with the address based on the location
676 /// provided, and generate the DWARF information necessary to find the
677 /// actual Block variable (navigating the Block struct) based on the
678 /// starting location. Add the DWARF information to the die. For
679 /// more information, read large comment just above here.
681 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
683 const MachineLocation &Location) {
684 const DIVariable &VD = DV->getVariable();
685 DIType Ty = VD.getType();
687 unsigned Tag = Ty.getTag();
688 bool isPointer = false;
690 StringRef varName = VD.getName();
692 if (Tag == dwarf::DW_TAG_pointer_type) {
693 DIDerivedType DTy = DIDerivedType(Ty);
694 TmpTy = DTy.getTypeDerivedFrom();
698 DICompositeType blockStruct = DICompositeType(TmpTy);
700 // Find the __forwarding field and the variable field in the __Block_byref
702 DIArray Fields = blockStruct.getTypeArray();
703 DIDescriptor varField = DIDescriptor();
704 DIDescriptor forwardingField = DIDescriptor();
706 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
707 DIDescriptor Element = Fields.getElement(i);
708 DIDerivedType DT = DIDerivedType(Element);
709 StringRef fieldName = DT.getName();
710 if (fieldName == "__forwarding")
711 forwardingField = Element;
712 else if (fieldName == varName)
716 // Get the offsets for the forwarding field and the variable field.
717 unsigned forwardingFieldOffset =
718 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
719 unsigned varFieldOffset =
720 DIDerivedType(varField).getOffsetInBits() >> 3;
722 // Decode the original location, and use that as the start of the byref
723 // variable's location.
724 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
725 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
728 if (Location.isReg()) {
730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
732 Reg = Reg - dwarf::DW_OP_reg0;
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
741 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
744 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
747 // If we started with a pointer to the __Block_byref... struct, then
748 // the first thing we need to do is dereference the pointer (DW_OP_deref).
750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
752 // Next add the offset for the '__forwarding' field:
753 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
754 // adding the offset if it's 0.
755 if (forwardingFieldOffset > 0) {
756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
757 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
760 // Now dereference the __forwarding field to get to the real __Block_byref
761 // struct: DW_OP_deref.
762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
764 // Now that we've got the real __Block_byref... struct, add the offset
765 // for the variable's field to get to the location of the actual variable:
766 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
767 if (varFieldOffset > 0) {
768 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
769 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
772 // Now attach the location information to the DIE.
773 addBlock(Die, Attribute, 0, Block);
776 /// addAddress - Add an address attribute to a die based on the location
778 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
779 const MachineLocation &Location) {
780 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
781 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
784 if (Location.isReg()) {
786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
788 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
789 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
799 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
802 addBlock(Die, Attribute, 0, Block);
805 /// addRegisterAddress - Add register location entry in variable DIE.
806 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
807 const MachineOperand &MO) {
808 assert (MO.isReg() && "Invalid machine operand!");
811 MachineLocation Location;
812 Location.set(MO.getReg());
813 addAddress(Die, dwarf::DW_AT_location, Location);
815 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
819 /// addConstantValue - Add constant value entry in variable DIE.
820 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
821 const MachineOperand &MO) {
822 assert (MO.isImm() && "Invalid machine operand!");
823 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
824 unsigned Imm = MO.getImm();
825 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
826 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
828 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
832 /// addConstantFPValue - Add constant value entry in variable DIE.
833 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
834 const MachineOperand &MO) {
835 assert (MO.isFPImm() && "Invalid machine operand!");
836 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
837 APFloat FPImm = MO.getFPImm()->getValueAPF();
839 // Get the raw data form of the floating point.
840 const APInt FltVal = FPImm.bitcastToAPInt();
841 const char *FltPtr = (const char*)FltVal.getRawData();
843 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
844 bool LittleEndian = Asm->getTargetData().isLittleEndian();
845 int Incr = (LittleEndian ? 1 : -1);
846 int Start = (LittleEndian ? 0 : NumBytes - 1);
847 int Stop = (LittleEndian ? NumBytes : -1);
849 // Output the constant to DWARF one byte at a time.
850 for (; Start != Stop; Start += Incr)
851 addUInt(Block, 0, dwarf::DW_FORM_data1,
852 (unsigned char)0xFF & FltPtr[Start]);
854 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
861 /// addToContextOwner - Add Die into the list of its context owner's children.
862 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
863 if (Context.isType()) {
864 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
865 ContextDIE->addChild(Die);
866 } else if (Context.isNameSpace()) {
867 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
868 ContextDIE->addChild(Die);
869 } else if (Context.isSubprogram()) {
870 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
872 ContextDIE->addChild(Die);
873 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
874 ContextDIE->addChild(Die);
876 getCompileUnit(Context)->addDie(Die);
879 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
881 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
882 CompileUnit *TypeCU = getCompileUnit(Ty);
883 DIE *TyDIE = TypeCU->getDIE(Ty);
888 TyDIE = new DIE(dwarf::DW_TAG_base_type);
889 TypeCU->insertDIE(Ty, TyDIE);
890 if (Ty.isBasicType())
891 constructTypeDIE(*TyDIE, DIBasicType(Ty));
892 else if (Ty.isCompositeType())
893 constructTypeDIE(*TyDIE, DICompositeType(Ty));
895 assert(Ty.isDerivedType() && "Unknown kind of DIType");
896 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
899 addToContextOwner(TyDIE, Ty.getContext());
903 /// addType - Add a new type attribute to the specified entity.
904 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
908 // Check for pre-existence.
909 CompileUnit *TypeCU = getCompileUnit(Ty);
910 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
911 // If it exists then use the existing value.
913 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
918 DIE *Buffer = getOrCreateTypeDIE(Ty);
921 Entry = createDIEEntry(Buffer);
922 TypeCU->insertDIEEntry(Ty, Entry);
924 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
927 /// constructTypeDIE - Construct basic type die from DIBasicType.
928 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
929 // Get core information.
930 StringRef Name = BTy.getName();
931 Buffer.setTag(dwarf::DW_TAG_base_type);
932 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
935 // Add name if not anonymous or intermediate type.
937 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
938 uint64_t Size = BTy.getSizeInBits() >> 3;
939 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
942 /// constructTypeDIE - Construct derived type die from DIDerivedType.
943 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
944 // Get core information.
945 StringRef Name = DTy.getName();
946 uint64_t Size = DTy.getSizeInBits() >> 3;
947 unsigned Tag = DTy.getTag();
949 // FIXME - Workaround for templates.
950 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
954 // Map to main type, void will not have a type.
955 DIType FromTy = DTy.getTypeDerivedFrom();
956 addType(&Buffer, FromTy);
958 // Add name if not anonymous or intermediate type.
960 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
962 // Add size if non-zero (derived types might be zero-sized.)
964 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
966 // Add source line info if available and TyDesc is not a forward declaration.
967 if (!DTy.isForwardDecl())
968 addSourceLine(&Buffer, &DTy);
971 /// constructTypeDIE - Construct type DIE from DICompositeType.
972 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
973 // Get core information.
974 StringRef Name = CTy.getName();
976 uint64_t Size = CTy.getSizeInBits() >> 3;
977 unsigned Tag = CTy.getTag();
981 case dwarf::DW_TAG_vector_type:
982 case dwarf::DW_TAG_array_type:
983 constructArrayTypeDIE(Buffer, &CTy);
985 case dwarf::DW_TAG_enumeration_type: {
986 DIArray Elements = CTy.getTypeArray();
988 // Add enumerators to enumeration type.
989 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
991 DIDescriptor Enum(Elements.getElement(i));
992 if (Enum.isEnumerator()) {
993 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
994 Buffer.addChild(ElemDie);
999 case dwarf::DW_TAG_subroutine_type: {
1001 DIArray Elements = CTy.getTypeArray();
1002 DIDescriptor RTy = Elements.getElement(0);
1003 addType(&Buffer, DIType(RTy));
1005 // Add prototype flag.
1006 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1009 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1010 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1011 DIDescriptor Ty = Elements.getElement(i);
1012 addType(Arg, DIType(Ty));
1013 Buffer.addChild(Arg);
1017 case dwarf::DW_TAG_structure_type:
1018 case dwarf::DW_TAG_union_type:
1019 case dwarf::DW_TAG_class_type: {
1020 // Add elements to structure type.
1021 DIArray Elements = CTy.getTypeArray();
1023 // A forward struct declared type may not have elements available.
1024 unsigned N = Elements.getNumElements();
1028 // Add elements to structure type.
1029 for (unsigned i = 0; i < N; ++i) {
1030 DIDescriptor Element = Elements.getElement(i);
1031 DIE *ElemDie = NULL;
1032 if (Element.isSubprogram())
1033 ElemDie = createSubprogramDIE(DISubprogram(Element));
1034 else if (Element.isVariable()) {
1035 DIVariable DV(Element);
1036 ElemDie = new DIE(dwarf::DW_TAG_variable);
1037 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1039 addType(ElemDie, DV.getType());
1040 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1041 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1042 addSourceLine(ElemDie, &DV);
1043 } else if (Element.isDerivedType())
1044 ElemDie = createMemberDIE(DIDerivedType(Element));
1047 Buffer.addChild(ElemDie);
1050 if (CTy.isAppleBlockExtension())
1051 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1053 unsigned RLang = CTy.getRunTimeLang();
1055 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1056 dwarf::DW_FORM_data1, RLang);
1058 DICompositeType ContainingType = CTy.getContainingType();
1059 if (DIDescriptor(ContainingType).isCompositeType())
1060 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1061 getOrCreateTypeDIE(DIType(ContainingType)));
1063 DIDescriptor Context = CTy.getContext();
1064 addToContextOwner(&Buffer, Context);
1072 // Add name if not anonymous or intermediate type.
1074 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1076 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1077 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1079 // Add size if non-zero (derived types might be zero-sized.)
1081 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1083 // Add zero size if it is not a forward declaration.
1084 if (CTy.isForwardDecl())
1085 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1087 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1090 // Add source line info if available.
1091 if (!CTy.isForwardDecl())
1092 addSourceLine(&Buffer, &CTy);
1096 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1097 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1098 int64_t L = SR.getLo();
1099 int64_t H = SR.getHi();
1100 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1102 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1104 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1105 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1107 Buffer.addChild(DW_Subrange);
1110 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1111 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1112 DICompositeType *CTy) {
1113 Buffer.setTag(dwarf::DW_TAG_array_type);
1114 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1115 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1117 // Emit derived type.
1118 addType(&Buffer, CTy->getTypeDerivedFrom());
1119 DIArray Elements = CTy->getTypeArray();
1121 // Get an anonymous type for index type.
1122 CompileUnit *TheCU = getCompileUnit(*CTy);
1123 DIE *IdxTy = TheCU->getIndexTyDie();
1125 // Construct an anonymous type for index type.
1126 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1127 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1128 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1129 dwarf::DW_ATE_signed);
1130 TheCU->addDie(IdxTy);
1131 TheCU->setIndexTyDie(IdxTy);
1134 // Add subranges to array type.
1135 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1136 DIDescriptor Element = Elements.getElement(i);
1137 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1138 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1142 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1143 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1144 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1145 StringRef Name = ETy.getName();
1146 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1147 int64_t Value = ETy.getEnumValue();
1148 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1152 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1153 /// printer to not emit usual symbol prefix before the symbol name is used then
1154 /// return linkage name after skipping this special LLVM prefix.
1155 static StringRef getRealLinkageName(StringRef LinkageName) {
1157 if (LinkageName.startswith(StringRef(&One, 1)))
1158 return LinkageName.substr(1);
1162 /// createGlobalVariableDIE - Create new DIE using GV.
1163 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1164 // If the global variable was optmized out then no need to create debug info
1166 if (!GV.getGlobal()) return NULL;
1167 if (GV.getDisplayName().empty()) return NULL;
1169 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1170 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1171 GV.getDisplayName());
1173 StringRef LinkageName = GV.getLinkageName();
1174 if (!LinkageName.empty())
1175 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1176 getRealLinkageName(LinkageName));
1178 addType(GVDie, GV.getType());
1179 if (!GV.isLocalToUnit())
1180 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1181 addSourceLine(GVDie, &GV);
1186 /// createMemberDIE - Create new member DIE.
1187 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1188 DIE *MemberDie = new DIE(DT.getTag());
1189 StringRef Name = DT.getName();
1191 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1193 addType(MemberDie, DT.getTypeDerivedFrom());
1195 addSourceLine(MemberDie, &DT);
1197 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1198 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1200 uint64_t Size = DT.getSizeInBits();
1201 uint64_t FieldSize = DT.getOriginalTypeSize();
1203 if (Size != FieldSize) {
1205 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1206 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1208 uint64_t Offset = DT.getOffsetInBits();
1209 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1210 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1211 uint64_t FieldOffset = (HiMark - FieldSize);
1212 Offset -= FieldOffset;
1214 // Maybe we need to work from the other end.
1215 if (Asm->getTargetData().isLittleEndian())
1216 Offset = FieldSize - (Offset + Size);
1217 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1219 // Here WD_AT_data_member_location points to the anonymous
1220 // field that includes this bit field.
1221 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1224 // This is not a bitfield.
1225 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1227 if (DT.getTag() == dwarf::DW_TAG_inheritance
1228 && DT.isVirtual()) {
1230 // For C++, virtual base classes are not at fixed offset. Use following
1231 // expression to extract appropriate offset from vtable.
1232 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1234 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1243 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1246 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1248 if (DT.isProtected())
1249 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1250 dwarf::DW_ACCESS_protected);
1251 else if (DT.isPrivate())
1252 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1253 dwarf::DW_ACCESS_private);
1254 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1255 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1256 dwarf::DW_ACCESS_public);
1258 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1259 dwarf::DW_VIRTUALITY_virtual);
1263 /// createSubprogramDIE - Create new DIE using SP.
1264 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1265 CompileUnit *SPCU = getCompileUnit(SP);
1266 DIE *SPDie = SPCU->getDIE(SP);
1270 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1271 // Constructors and operators for anonymous aggregates do not have names.
1272 if (!SP.getName().empty())
1273 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1275 StringRef LinkageName = SP.getLinkageName();
1276 if (!LinkageName.empty())
1277 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1278 getRealLinkageName(LinkageName));
1280 addSourceLine(SPDie, &SP);
1282 // Add prototyped tag, if C or ObjC.
1283 unsigned Lang = SP.getCompileUnit().getLanguage();
1284 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1285 Lang == dwarf::DW_LANG_ObjC)
1286 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1289 DICompositeType SPTy = SP.getType();
1290 DIArray Args = SPTy.getTypeArray();
1291 unsigned SPTag = SPTy.getTag();
1293 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1294 addType(SPDie, SPTy);
1296 addType(SPDie, DIType(Args.getElement(0)));
1298 unsigned VK = SP.getVirtuality();
1300 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1301 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1302 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1303 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1304 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1305 ContainingTypeMap.insert(std::make_pair(SPDie,
1306 SP.getContainingType()));
1309 if (MakeDecl || !SP.isDefinition()) {
1310 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1312 // Add arguments. Do not add arguments for subprogram definition. They will
1313 // be handled while processing variables.
1314 DICompositeType SPTy = SP.getType();
1315 DIArray Args = SPTy.getTypeArray();
1316 unsigned SPTag = SPTy.getTag();
1318 if (SPTag == dwarf::DW_TAG_subroutine_type)
1319 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1320 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1321 DIType ATy = DIType(DIType(Args.getElement(i)));
1323 if (ATy.isArtificial())
1324 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1325 SPDie->addChild(Arg);
1329 if (SP.isArtificial())
1330 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1332 if (!SP.isLocalToUnit())
1333 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1335 if (SP.isOptimized())
1336 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1338 // DW_TAG_inlined_subroutine may refer to this DIE.
1339 SPCU->insertDIE(SP, SPDie);
1341 // Add to context owner.
1342 addToContextOwner(SPDie, SP.getContext());
1347 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1348 assert(N && "Invalid Scope encoding!");
1350 DbgScope *AScope = AbstractScopes.lookup(N);
1354 DbgScope *Parent = NULL;
1356 DIDescriptor Scope(N);
1357 if (Scope.isLexicalBlock()) {
1358 DILexicalBlock DB(N);
1359 DIDescriptor ParentDesc = DB.getContext();
1360 Parent = getOrCreateAbstractScope(ParentDesc);
1363 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1366 Parent->addScope(AScope);
1367 AScope->setAbstractScope();
1368 AbstractScopes[N] = AScope;
1369 if (DIDescriptor(N).isSubprogram())
1370 AbstractScopesList.push_back(AScope);
1374 /// isSubprogramContext - Return true if Context is either a subprogram
1375 /// or another context nested inside a subprogram.
1376 static bool isSubprogramContext(const MDNode *Context) {
1379 DIDescriptor D(Context);
1380 if (D.isSubprogram())
1383 return isSubprogramContext(DIType(Context).getContext());
1387 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1388 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1389 /// If there are global variables in this scope then create and insert
1390 /// DIEs for these variables.
1391 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1392 CompileUnit *SPCU = getCompileUnit(SPNode);
1393 DIE *SPDie = SPCU->getDIE(SPNode);
1395 assert(SPDie && "Unable to find subprogram DIE!");
1396 DISubprogram SP(SPNode);
1398 // There is not any need to generate specification DIE for a function
1399 // defined at compile unit level. If a function is defined inside another
1400 // function then gdb prefers the definition at top level and but does not
1401 // expect specification DIE in parent function. So avoid creating
1402 // specification DIE for a function defined inside a function.
1403 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1404 !SP.getContext().isFile() &&
1405 !isSubprogramContext(SP.getContext())) {
1406 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1409 DICompositeType SPTy = SP.getType();
1410 DIArray Args = SPTy.getTypeArray();
1411 unsigned SPTag = SPTy.getTag();
1412 if (SPTag == dwarf::DW_TAG_subroutine_type)
1413 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1414 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1415 DIType ATy = DIType(DIType(Args.getElement(i)));
1417 if (ATy.isArtificial())
1418 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1419 SPDie->addChild(Arg);
1421 DIE *SPDeclDie = SPDie;
1422 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1423 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1425 SPCU->addDie(SPDie);
1428 // Pick up abstract subprogram DIE.
1429 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1430 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1431 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1432 dwarf::DW_FORM_ref4, AbsSPDIE);
1433 SPCU->addDie(SPDie);
1436 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1437 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1438 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1439 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1440 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1441 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1442 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1447 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1448 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1449 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1451 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1452 if (Scope->isAbstractScope())
1455 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1459 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1460 if (Ranges.size() > 1) {
1461 // .debug_range section has not been laid out yet. Emit offset in
1462 // .debug_range as a uint, size 4, for now. emitDIE will handle
1463 // DW_AT_ranges appropriately.
1464 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1465 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1466 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1467 RE = Ranges.end(); RI != RE; ++RI) {
1468 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1469 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1471 DebugRangeSymbols.push_back(NULL);
1472 DebugRangeSymbols.push_back(NULL);
1476 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1477 const MCSymbol *End = getLabelAfterInsn(RI->second);
1479 if (End == 0) return 0;
1481 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1482 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1484 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1485 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1490 /// constructInlinedScopeDIE - This scope represents inlined body of
1491 /// a function. Construct DIE to represent this concrete inlined copy
1492 /// of the function.
1493 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1495 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1496 assert (Ranges.empty() == false
1497 && "DbgScope does not have instruction markers!");
1499 // FIXME : .debug_inlined section specification does not clearly state how
1500 // to emit inlined scope that is split into multiple instruction ranges.
1501 // For now, use first instruction range and emit low_pc/high_pc pair and
1502 // corresponding .debug_inlined section entry for this pair.
1503 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1504 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1505 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1507 if (StartLabel == 0 || EndLabel == 0) {
1508 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1511 assert(StartLabel->isDefined() &&
1512 "Invalid starting label for an inlined scope!");
1513 assert(EndLabel->isDefined() &&
1514 "Invalid end label for an inlined scope!");
1516 if (!Scope->getScopeNode())
1518 DIScope DS(Scope->getScopeNode());
1519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1521 DISubprogram InlinedSP = getDISubprogram(DS);
1522 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1523 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1524 assert(OriginDIE && "Unable to find Origin DIE!");
1525 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1526 dwarf::DW_FORM_ref4, OriginDIE);
1528 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1529 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1531 InlinedSubprogramDIEs.insert(OriginDIE);
1533 // Track the start label for this inlined function.
1534 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1535 I = InlineInfo.find(InlinedSP);
1537 if (I == InlineInfo.end()) {
1538 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1540 InlinedSPNodes.push_back(InlinedSP);
1542 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1544 DILocation DL(Scope->getInlinedAt());
1545 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1546 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1552 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1553 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1554 // Get the descriptor.
1555 const DIVariable &VD = DV->getVariable();
1556 StringRef Name = VD.getName();
1560 // Translate tag to proper Dwarf tag. The result variable is dropped for
1563 switch (VD.getTag()) {
1564 case dwarf::DW_TAG_return_variable:
1566 case dwarf::DW_TAG_arg_variable:
1567 Tag = dwarf::DW_TAG_formal_parameter;
1569 case dwarf::DW_TAG_auto_variable: // fall thru
1571 Tag = dwarf::DW_TAG_variable;
1575 // Define variable debug information entry.
1576 DIE *VariableDie = new DIE(Tag);
1579 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1580 V2AVI = VarToAbstractVarMap.find(DV);
1581 if (V2AVI != VarToAbstractVarMap.end())
1582 AbsDIE = V2AVI->second->getDIE();
1585 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1586 dwarf::DW_FORM_ref4, AbsDIE);
1588 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1589 addSourceLine(VariableDie, &VD);
1591 // Add variable type.
1592 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1593 // addresses instead.
1594 if (VD.isBlockByrefVariable())
1595 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1597 addType(VariableDie, VD.getType());
1600 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1601 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1603 if (Scope->isAbstractScope()) {
1604 DV->setDIE(VariableDie);
1608 // Add variable address.
1610 unsigned Offset = DV->getDotDebugLocOffset();
1611 if (Offset != ~0U) {
1612 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1613 Asm->GetTempSymbol("debug_loc", Offset));
1614 DV->setDIE(VariableDie);
1615 UseDotDebugLocEntry.insert(VariableDie);
1619 // Check if variable is described by a DBG_VALUE instruction.
1620 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1621 DbgVariableToDbgInstMap.find(DV);
1622 if (DVI != DbgVariableToDbgInstMap.end()) {
1623 const MachineInstr *DVInsn = DVI->second;
1624 const MCSymbol *DVLabel = findVariableLabel(DV);
1625 bool updated = false;
1626 // FIXME : Handle getNumOperands != 3
1627 if (DVInsn->getNumOperands() == 3) {
1628 if (DVInsn->getOperand(0).isReg())
1630 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1631 else if (DVInsn->getOperand(0).isImm())
1632 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1633 else if (DVInsn->getOperand(0).isFPImm())
1635 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1637 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1638 if (Location.getReg()) {
1639 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1641 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1647 // If variableDie is not updated then DBG_VALUE instruction does not
1648 // have valid variable info.
1652 DV->setDIE(VariableDie);
1656 // .. else use frame index, if available.
1657 MachineLocation Location;
1659 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1661 if (findVariableFrameIndex(DV, &FI)) {
1662 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1663 Location.set(FrameReg, Offset);
1665 if (VD.hasComplexAddress())
1666 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1667 else if (VD.isBlockByrefVariable())
1668 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1670 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1672 DV->setDIE(VariableDie);
1677 void DwarfDebug::addPubTypes(DISubprogram SP) {
1678 DICompositeType SPTy = SP.getType();
1679 unsigned SPTag = SPTy.getTag();
1680 if (SPTag != dwarf::DW_TAG_subroutine_type)
1683 DIArray Args = SPTy.getTypeArray();
1684 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1685 DIType ATy(Args.getElement(i));
1688 DICompositeType CATy = getDICompositeType(ATy);
1689 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1690 && !CATy.isForwardDecl()) {
1691 CompileUnit *TheCU = getCompileUnit(CATy);
1692 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1693 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1698 /// constructScopeDIE - Construct a DIE for this scope.
1699 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1700 if (!Scope || !Scope->getScopeNode())
1703 DIScope DS(Scope->getScopeNode());
1704 DIE *ScopeDIE = NULL;
1705 if (Scope->getInlinedAt())
1706 ScopeDIE = constructInlinedScopeDIE(Scope);
1707 else if (DS.isSubprogram()) {
1708 ProcessedSPNodes.insert(DS);
1709 if (Scope->isAbstractScope()) {
1710 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1711 // Note down abstract DIE.
1713 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1716 ScopeDIE = updateSubprogramScopeDIE(DS);
1719 ScopeDIE = constructLexicalScopeDIE(Scope);
1720 if (!ScopeDIE) return NULL;
1722 // Add variables to scope.
1723 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1724 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1725 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1727 ScopeDIE->addChild(VariableDIE);
1730 // Add nested scopes.
1731 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1732 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1733 // Define the Scope debug information entry.
1734 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1736 ScopeDIE->addChild(NestedDIE);
1739 if (DS.isSubprogram())
1740 addPubTypes(DISubprogram(DS));
1745 /// GetOrCreateSourceID - Look up the source id with the given directory and
1746 /// source file names. If none currently exists, create a new id and insert it
1747 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1749 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1751 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1752 if (DI != DirectoryIdMap.end()) {
1753 DId = DI->getValue();
1755 DId = DirectoryNames.size() + 1;
1756 DirectoryIdMap[DirName] = DId;
1757 DirectoryNames.push_back(DirName);
1761 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1762 if (FI != SourceFileIdMap.end()) {
1763 FId = FI->getValue();
1765 FId = SourceFileNames.size() + 1;
1766 SourceFileIdMap[FileName] = FId;
1767 SourceFileNames.push_back(FileName);
1770 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1771 SourceIdMap.find(std::make_pair(DId, FId));
1772 if (SI != SourceIdMap.end())
1775 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1776 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1777 SourceIds.push_back(std::make_pair(DId, FId));
1782 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1783 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1784 CompileUnit *TheCU = getCompileUnit(NS);
1785 DIE *NDie = TheCU->getDIE(NS);
1788 NDie = new DIE(dwarf::DW_TAG_namespace);
1789 TheCU->insertDIE(NS, NDie);
1790 if (!NS.getName().empty())
1791 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1792 addSourceLine(NDie, &NS);
1793 addToContextOwner(NDie, NS.getContext());
1797 /// constructCompileUnit - Create new CompileUnit for the given
1798 /// metadata node with tag DW_TAG_compile_unit.
1799 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1800 DICompileUnit DIUnit(N);
1801 StringRef FN = DIUnit.getFilename();
1802 StringRef Dir = DIUnit.getDirectory();
1803 unsigned ID = GetOrCreateSourceID(Dir, FN);
1805 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1806 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1807 DIUnit.getProducer());
1808 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1809 DIUnit.getLanguage());
1810 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1811 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1812 // simplifies debug range entries.
1813 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1814 // DW_AT_stmt_list is a offset of line number information for this
1815 // compile unit in debug_line section. This offset is calculated
1816 // during endMoudle().
1817 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1820 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1821 if (DIUnit.isOptimized())
1822 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1824 StringRef Flags = DIUnit.getFlags();
1826 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1828 unsigned RVer = DIUnit.getRunTimeVersion();
1830 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1831 dwarf::DW_FORM_data1, RVer);
1833 CompileUnit *NewCU = new CompileUnit(ID, Die);
1836 CUMap.insert(std::make_pair(N, NewCU));
1839 /// getCompielUnit - Get CompileUnit DIE.
1840 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1841 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1843 const MDNode *CUNode = NULL;
1844 if (D.isCompileUnit())
1846 else if (D.isSubprogram())
1847 CUNode = DISubprogram(N).getCompileUnit();
1848 else if (D.isType())
1849 CUNode = DIType(N).getCompileUnit();
1850 else if (D.isGlobalVariable())
1851 CUNode = DIGlobalVariable(N).getCompileUnit();
1852 else if (D.isVariable())
1853 CUNode = DIVariable(N).getCompileUnit();
1854 else if (D.isNameSpace())
1855 CUNode = DINameSpace(N).getCompileUnit();
1856 else if (D.isFile())
1857 CUNode = DIFile(N).getCompileUnit();
1861 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1862 = CUMap.find(CUNode);
1863 if (I == CUMap.end())
1869 /// constructGlobalVariableDIE - Construct global variable DIE.
1870 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1871 DIGlobalVariable DI_GV(N);
1873 // If debug information is malformed then ignore it.
1874 if (DI_GV.Verify() == false)
1877 // Check for pre-existence.
1878 CompileUnit *TheCU = getCompileUnit(N);
1879 if (TheCU->getDIE(DI_GV))
1882 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1887 TheCU->insertDIE(N, VariableDie);
1889 // Add to context owner.
1890 DIDescriptor GVContext = DI_GV.getContext();
1891 // Do not create specification DIE if context is either compile unit
1893 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1894 !GVContext.isFile() &&
1895 !isSubprogramContext(GVContext)) {
1896 // Create specification DIE.
1897 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1898 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1899 dwarf::DW_FORM_ref4, VariableDie);
1900 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1901 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1902 addLabel(Block, 0, dwarf::DW_FORM_udata,
1903 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1904 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1905 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1906 TheCU->addDie(VariableSpecDIE);
1908 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1909 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1910 addLabel(Block, 0, dwarf::DW_FORM_udata,
1911 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1912 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1914 addToContextOwner(VariableDie, GVContext);
1916 // Expose as global. FIXME - need to check external flag.
1917 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1919 DIType GTy = DI_GV.getType();
1920 if (GTy.isCompositeType() && !GTy.getName().empty()
1921 && !GTy.isForwardDecl()) {
1922 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1923 assert(Entry && "Missing global type!");
1924 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1929 /// construct SubprogramDIE - Construct subprogram DIE.
1930 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1933 // Check for pre-existence.
1934 CompileUnit *TheCU = getCompileUnit(N);
1935 if (TheCU->getDIE(N))
1938 if (!SP.isDefinition())
1939 // This is a method declaration which will be handled while constructing
1943 DIE *SubprogramDie = createSubprogramDIE(SP);
1946 TheCU->insertDIE(N, SubprogramDie);
1948 // Add to context owner.
1949 addToContextOwner(SubprogramDie, SP.getContext());
1951 // Expose as global.
1952 TheCU->addGlobal(SP.getName(), SubprogramDie);
1957 /// beginModule - Emit all Dwarf sections that should come prior to the
1958 /// content. Create global DIEs and emit initial debug info sections.
1959 /// This is inovked by the target AsmPrinter.
1960 void DwarfDebug::beginModule(Module *M) {
1961 if (DisableDebugInfoPrinting)
1964 DebugInfoFinder DbgFinder;
1965 DbgFinder.processModule(*M);
1967 bool HasDebugInfo = false;
1969 // Scan all the compile-units to see if there are any marked as the main unit.
1970 // if not, we do not generate debug info.
1971 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1972 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1973 if (DICompileUnit(*I).isMain()) {
1974 HasDebugInfo = true;
1979 if (!HasDebugInfo) return;
1981 // Tell MMI that we have debug info.
1982 MMI->setDebugInfoAvailability(true);
1984 // Emit initial sections.
1985 EmitSectionLabels();
1987 // Create all the compile unit DIEs.
1988 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1989 E = DbgFinder.compile_unit_end(); I != E; ++I)
1990 constructCompileUnit(*I);
1992 // Create DIEs for each subprogram.
1993 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1994 E = DbgFinder.subprogram_end(); I != E; ++I)
1995 constructSubprogramDIE(*I);
1997 // Create DIEs for each global variable.
1998 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1999 E = DbgFinder.global_variable_end(); I != E; ++I)
2000 constructGlobalVariableDIE(*I);
2002 // Prime section data.
2003 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2005 // Print out .file directives to specify files for .loc directives. These are
2006 // printed out early so that they precede any .loc directives.
2007 if (Asm->MAI->hasDotLocAndDotFile()) {
2008 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2009 // Remember source id starts at 1.
2010 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2011 // FIXME: don't use sys::path for this! This should not depend on the
2013 sys::Path FullPath(getSourceDirectoryName(Id.first));
2015 FullPath.appendComponent(getSourceFileName(Id.second));
2016 assert(AppendOk && "Could not append filename to directory!");
2018 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2023 /// endModule - Emit all Dwarf sections that should come after the content.
2025 void DwarfDebug::endModule() {
2026 if (!FirstCU) return;
2027 const Module *M = MMI->getModule();
2028 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2029 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2030 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2031 DISubprogram SP(AllSPs->getOperand(SI));
2032 if (!SP.Verify()) continue;
2034 // Collect info for variables that were optimized out.
2035 StringRef FName = SP.getLinkageName();
2037 FName = SP.getName();
2039 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2041 unsigned E = NMD->getNumOperands();
2043 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2044 for (unsigned I = 0; I != E; ++I) {
2045 DIVariable DV(NMD->getOperand(I));
2046 if (!DV.Verify()) continue;
2047 Scope->addVariable(new DbgVariable(DV));
2050 // Construct subprogram DIE and add variables DIEs.
2051 constructSubprogramDIE(SP);
2052 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2053 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2054 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2055 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2057 ScopeDIE->addChild(VariableDIE);
2062 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2063 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2064 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2066 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2069 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2070 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2071 DIE *SPDie = CI->first;
2072 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2074 DIE *NDie = getCompileUnit(N)->getDIE(N);
2075 if (!NDie) continue;
2076 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2079 // Standard sections final addresses.
2080 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2081 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2082 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2083 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2085 // End text sections.
2086 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2087 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2088 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2091 // Emit common frame information.
2092 emitCommonDebugFrame();
2094 // Emit function debug frame information
2095 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2096 E = DebugFrames.end(); I != E; ++I)
2097 emitFunctionDebugFrame(*I);
2099 // Compute DIE offsets and sizes.
2100 computeSizeAndOffsets();
2102 // Emit source line correspondence into a debug line section.
2105 // Emit all the DIEs into a debug info section
2108 // Corresponding abbreviations into a abbrev section.
2109 emitAbbreviations();
2111 // Emit info into a debug pubnames section.
2112 emitDebugPubNames();
2114 // Emit info into a debug pubtypes section.
2115 emitDebugPubTypes();
2117 // Emit info into a debug loc section.
2120 // Emit info into a debug aranges section.
2123 // Emit info into a debug ranges section.
2126 // Emit info into a debug macinfo section.
2129 // Emit inline info.
2130 emitDebugInlineInfo();
2132 // Emit info into a debug str section.
2135 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2136 E = CUMap.end(); I != E; ++I)
2138 FirstCU = NULL; // Reset for the next Module, if any.
2141 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2142 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2143 DebugLoc ScopeLoc) {
2145 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2147 return AbsDbgVariable;
2149 LLVMContext &Ctx = Var->getContext();
2150 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2154 AbsDbgVariable = new DbgVariable(Var);
2155 Scope->addVariable(AbsDbgVariable);
2156 AbstractVariables[Var] = AbsDbgVariable;
2157 return AbsDbgVariable;
2160 /// collectVariableInfoFromMMITable - Collect variable information from
2161 /// side table maintained by MMI.
2163 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2164 SmallPtrSet<const MDNode *, 16> &Processed) {
2165 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2166 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2167 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2168 VE = VMap.end(); VI != VE; ++VI) {
2169 const MDNode *Var = VI->first;
2171 Processed.insert(Var);
2173 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2175 DbgScope *Scope = 0;
2176 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2177 Scope = ConcreteScopes.lookup(IA);
2179 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2181 // If variable scope is not found then skip this variable.
2185 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2186 DbgVariable *RegVar = new DbgVariable(DV);
2187 recordVariableFrameIndex(RegVar, VP.first);
2188 Scope->addVariable(RegVar);
2189 if (AbsDbgVariable) {
2190 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2191 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2196 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2197 /// DBG_VALUE instruction, is in undefined reg.
2198 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2199 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2200 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2205 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2206 /// DBG_VALUE instruction, is in a defined reg.
2207 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2208 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2209 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2214 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2216 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2217 SmallPtrSet<const MDNode *, 16> &Processed) {
2219 /// collection info from MMI table.
2220 collectVariableInfoFromMMITable(MF, Processed);
2222 SmallVector<const MachineInstr *, 8> DbgValues;
2223 // Collect variable information from DBG_VALUE machine instructions;
2224 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2226 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2228 const MachineInstr *MInsn = II;
2229 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2231 DbgValues.push_back(MInsn);
2234 // This is a collection of DBV_VALUE instructions describing same variable.
2235 SmallVector<const MachineInstr *, 4> MultipleValues;
2236 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2237 E = DbgValues.end(); I != E; ++I) {
2238 const MachineInstr *MInsn = *I;
2239 MultipleValues.clear();
2240 if (isDbgValueInDefinedReg(MInsn))
2241 MultipleValues.push_back(MInsn);
2242 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2243 if (Processed.count(DV) != 0)
2246 const MachineInstr *PrevMI = MInsn;
2247 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2248 ME = DbgValues.end(); MI != ME; ++MI) {
2250 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2251 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2252 !PrevMI->isIdenticalTo(*MI))
2253 MultipleValues.push_back(*MI);
2257 DbgScope *Scope = findDbgScope(MInsn);
2258 bool CurFnArg = false;
2259 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2260 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2262 if (!Scope && CurFnArg)
2263 Scope = CurrentFnDbgScope;
2264 // If variable scope is not found then skip this variable.
2268 Processed.insert(DV);
2269 DbgVariable *RegVar = new DbgVariable(DV);
2270 Scope->addVariable(RegVar);
2272 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2273 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2274 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2275 VarToAbstractVarMap[RegVar] = AbsVar;
2277 if (MultipleValues.size() <= 1) {
2278 DbgVariableToDbgInstMap[RegVar] = MInsn;
2282 // handle multiple DBG_VALUE instructions describing one variable.
2283 if (DotDebugLocEntries.empty())
2284 RegVar->setDotDebugLocOffset(0);
2286 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2287 const MachineInstr *Begin = NULL;
2288 const MachineInstr *End = NULL;
2289 for (SmallVector<const MachineInstr *, 4>::iterator
2290 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2291 MVI != MVE; ++MVI) {
2297 MachineLocation MLoc;
2298 MLoc.set(Begin->getOperand(0).getReg(), 0);
2299 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2300 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2301 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2303 if (MVI + 1 == MVE) {
2304 // If End is the last instruction then its value is valid
2305 // until the end of the funtion.
2306 MLoc.set(End->getOperand(0).getReg(), 0);
2308 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2311 DotDebugLocEntries.push_back(DotDebugLocEntry());
2314 // Collect info for variables that were optimized out.
2315 const Function *F = MF->getFunction();
2316 const Module *M = F->getParent();
2317 if (NamedMDNode *NMD =
2318 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2319 getRealLinkageName(F->getName())))) {
2320 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2321 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2322 if (!DV || !Processed.insert(DV))
2324 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2326 Scope->addVariable(new DbgVariable(DV));
2331 /// getLabelBeforeInsn - Return Label preceding the instruction.
2332 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2333 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2334 LabelsBeforeInsn.find(MI);
2335 if (I == LabelsBeforeInsn.end())
2336 // FunctionBeginSym always preceeds all the instruction in current function.
2337 return FunctionBeginSym;
2341 /// getLabelAfterInsn - Return Label immediately following the instruction.
2342 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2343 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2344 LabelsAfterInsn.find(MI);
2345 if (I == LabelsAfterInsn.end())
2350 /// beginScope - Process beginning of a scope.
2351 void DwarfDebug::beginScope(const MachineInstr *MI) {
2352 if (InsnNeedsLabel.count(MI) == 0) {
2353 LabelsBeforeInsn[MI] = PrevLabel;
2358 DebugLoc DL = MI->getDebugLoc();
2359 if (!DL.isUnknown()) {
2360 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2361 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2363 LabelsBeforeInsn[MI] = PrevLabel;
2367 // If location is unknown then use temp label for this DBG_VALUE
2369 if (MI->isDebugValue()) {
2370 PrevLabel = MMI->getContext().CreateTempSymbol();
2371 Asm->OutStreamer.EmitLabel(PrevLabel);
2372 LabelsBeforeInsn[MI] = PrevLabel;
2376 if (UnknownLocations) {
2377 PrevLabel = recordSourceLine(0, 0, 0);
2378 LabelsBeforeInsn[MI] = PrevLabel;
2382 assert (0 && "Instruction is not processed!");
2385 /// endScope - Process end of a scope.
2386 void DwarfDebug::endScope(const MachineInstr *MI) {
2387 if (InsnsEndScopeSet.count(MI) != 0) {
2388 // Emit a label if this instruction ends a scope.
2389 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2390 Asm->OutStreamer.EmitLabel(Label);
2391 LabelsAfterInsn[MI] = Label;
2395 /// getOrCreateDbgScope - Create DbgScope for the scope.
2396 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2397 const MDNode *InlinedAt) {
2399 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2402 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2403 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2404 if (DIDescriptor(Scope).isLexicalBlock()) {
2406 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2407 WScope->setParent(Parent);
2408 Parent->addScope(WScope);
2411 if (!WScope->getParent()) {
2412 StringRef SPName = DISubprogram(Scope).getLinkageName();
2413 // We used to check only for a linkage name, but that fails
2414 // since we began omitting the linkage name for private
2415 // functions. The new way is to check for the name in metadata,
2416 // but that's not supported in old .ll test cases. Ergo, we
2418 if (SPName == Asm->MF->getFunction()->getName() ||
2419 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2420 CurrentFnDbgScope = WScope;
2426 getOrCreateAbstractScope(Scope);
2427 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2431 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2432 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2433 DILocation DL(InlinedAt);
2435 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2436 WScope->setParent(Parent);
2437 Parent->addScope(WScope);
2439 ConcreteScopes[InlinedAt] = WScope;
2444 /// hasValidLocation - Return true if debug location entry attached with
2445 /// machine instruction encodes valid location info.
2446 static bool hasValidLocation(LLVMContext &Ctx,
2447 const MachineInstr *MInsn,
2448 const MDNode *&Scope, const MDNode *&InlinedAt) {
2449 DebugLoc DL = MInsn->getDebugLoc();
2450 if (DL.isUnknown()) return false;
2452 const MDNode *S = DL.getScope(Ctx);
2454 // There is no need to create another DIE for compile unit. For all
2455 // other scopes, create one DbgScope now. This will be translated
2456 // into a scope DIE at the end.
2457 if (DIScope(S).isCompileUnit()) return false;
2460 InlinedAt = DL.getInlinedAt(Ctx);
2464 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2466 static void calculateDominanceGraph(DbgScope *Scope) {
2467 assert (Scope && "Unable to calculate scop edominance graph!");
2468 SmallVector<DbgScope *, 4> WorkStack;
2469 WorkStack.push_back(Scope);
2470 unsigned Counter = 0;
2471 while (!WorkStack.empty()) {
2472 DbgScope *WS = WorkStack.back();
2473 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2474 bool visitedChildren = false;
2475 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2476 SE = Children.end(); SI != SE; ++SI) {
2477 DbgScope *ChildScope = *SI;
2478 if (!ChildScope->getDFSOut()) {
2479 WorkStack.push_back(ChildScope);
2480 visitedChildren = true;
2481 ChildScope->setDFSIn(++Counter);
2485 if (!visitedChildren) {
2486 WorkStack.pop_back();
2487 WS->setDFSOut(++Counter);
2492 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2494 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2495 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2498 unsigned PrevDFSIn = 0;
2499 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2501 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2503 const MachineInstr *MInsn = II;
2504 const MDNode *Scope = NULL;
2505 const MDNode *InlinedAt = NULL;
2507 // Check if instruction has valid location information.
2508 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2512 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2513 MI2ScopeMap.find(MInsn);
2514 if (DI != MI2ScopeMap.end()) {
2515 DbgScope *S = DI->second;
2516 dbgs() << S->getDFSIn();
2517 PrevDFSIn = S->getDFSIn();
2519 dbgs() << PrevDFSIn;
2521 dbgs() << " [ x" << PrevDFSIn;
2529 /// extractScopeInformation - Scan machine instructions in this function
2530 /// and collect DbgScopes. Return true, if at least one scope was found.
2531 bool DwarfDebug::extractScopeInformation() {
2532 // If scope information was extracted using .dbg intrinsics then there is not
2533 // any need to extract these information by scanning each instruction.
2534 if (!DbgScopeMap.empty())
2537 // Scan each instruction and create scopes. First build working set of scopes.
2538 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2539 SmallVector<DbgRange, 4> MIRanges;
2540 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2541 const MDNode *PrevScope = NULL;
2542 const MDNode *PrevInlinedAt = NULL;
2543 const MachineInstr *RangeBeginMI = NULL;
2544 const MachineInstr *PrevMI = NULL;
2545 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2547 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2549 const MachineInstr *MInsn = II;
2550 const MDNode *Scope = NULL;
2551 const MDNode *InlinedAt = NULL;
2553 // Check if instruction has valid location information.
2554 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2559 // If scope has not changed then skip this instruction.
2560 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2566 // If we have alread seen a beginning of a instruction range and
2567 // current instruction scope does not match scope of first instruction
2568 // in this range then create a new instruction range.
2569 DbgRange R(RangeBeginMI, PrevMI);
2570 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2572 MIRanges.push_back(R);
2575 // This is a beginning of a new instruction range.
2576 RangeBeginMI = MInsn;
2578 // Reset previous markers.
2581 PrevInlinedAt = InlinedAt;
2585 // Create last instruction range.
2586 if (RangeBeginMI && PrevMI && PrevScope) {
2587 DbgRange R(RangeBeginMI, PrevMI);
2588 MIRanges.push_back(R);
2589 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2592 if (!CurrentFnDbgScope)
2595 calculateDominanceGraph(CurrentFnDbgScope);
2597 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2599 // Find ranges of instructions covered by each DbgScope;
2600 DbgScope *PrevDbgScope = NULL;
2601 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2602 RE = MIRanges.end(); RI != RE; ++RI) {
2603 const DbgRange &R = *RI;
2604 DbgScope *S = MI2ScopeMap.lookup(R.first);
2605 assert (S && "Lost DbgScope for a machine instruction!");
2606 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2607 PrevDbgScope->closeInsnRange(S);
2608 S->openInsnRange(R.first);
2609 S->extendInsnRange(R.second);
2614 PrevDbgScope->closeInsnRange();
2616 identifyScopeMarkers();
2618 return !DbgScopeMap.empty();
2621 /// identifyScopeMarkers() -
2622 /// Each DbgScope has first instruction and last instruction to mark beginning
2623 /// and end of a scope respectively. Create an inverse map that list scopes
2624 /// starts (and ends) with an instruction. One instruction may start (or end)
2625 /// multiple scopes. Ignore scopes that are not reachable.
2626 void DwarfDebug::identifyScopeMarkers() {
2627 SmallVector<DbgScope *, 4> WorkList;
2628 WorkList.push_back(CurrentFnDbgScope);
2629 while (!WorkList.empty()) {
2630 DbgScope *S = WorkList.pop_back_val();
2632 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2633 if (!Children.empty())
2634 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2635 SE = Children.end(); SI != SE; ++SI)
2636 WorkList.push_back(*SI);
2638 if (S->isAbstractScope())
2641 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2644 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2645 RE = Ranges.end(); RI != RE; ++RI) {
2646 assert(RI->first && "DbgRange does not have first instruction!");
2647 assert(RI->second && "DbgRange does not have second instruction!");
2648 InsnsEndScopeSet.insert(RI->second);
2653 /// FindFirstDebugLoc - Find the first debug location in the function. This
2654 /// is intended to be an approximation for the source position of the
2655 /// beginning of the function.
2656 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2657 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2659 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2660 MBBI != MBBE; ++MBBI) {
2661 DebugLoc DL = MBBI->getDebugLoc();
2662 if (!DL.isUnknown())
2668 /// beginFunction - Gather pre-function debug information. Assumes being
2669 /// emitted immediately after the function entry point.
2670 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2671 if (!MMI->hasDebugInfo()) return;
2672 if (!extractScopeInformation()) return;
2674 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2675 Asm->getFunctionNumber());
2676 // Assumes in correct section after the entry point.
2677 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2679 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2681 DebugLoc FDL = FindFirstDebugLoc(MF);
2682 if (FDL.isUnknown()) return;
2684 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2686 DISubprogram SP = getDISubprogram(Scope);
2689 Line = SP.getLineNumber();
2692 Line = FDL.getLine();
2696 recordSourceLine(Line, Col, Scope);
2698 /// ProcessedArgs - Collection of arguments already processed.
2699 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2702 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2704 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2706 const MachineInstr *MI = II;
2707 DebugLoc DL = MI->getDebugLoc();
2708 if (MI->isDebugValue()) {
2709 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2710 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2711 if (!DV.Verify()) continue;
2712 // If DBG_VALUE is for a local variable then it needs a label.
2713 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2714 && isDbgValueInUndefinedReg(MI) == false)
2715 InsnNeedsLabel.insert(MI);
2716 // DBG_VALUE for inlined functions argument needs a label.
2717 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2718 describes(MF->getFunction()))
2719 InsnNeedsLabel.insert(MI);
2720 // DBG_VALUE indicating argument location change needs a label.
2721 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV))
2722 InsnNeedsLabel.insert(MI);
2724 // If location is unknown then instruction needs a location only if
2725 // UnknownLocations flag is set.
2726 if (DL.isUnknown()) {
2727 if (UnknownLocations && !PrevLoc.isUnknown())
2728 InsnNeedsLabel.insert(MI);
2729 } else if (DL != PrevLoc)
2730 // Otherwise, instruction needs a location only if it is new location.
2731 InsnNeedsLabel.insert(MI);
2734 if (!DL.isUnknown() || UnknownLocations)
2738 PrevLabel = FunctionBeginSym;
2741 /// endFunction - Gather and emit post-function debug information.
2743 void DwarfDebug::endFunction(const MachineFunction *MF) {
2744 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2746 if (CurrentFnDbgScope) {
2748 // Define end label for subprogram.
2749 FunctionEndSym = Asm->GetTempSymbol("func_end",
2750 Asm->getFunctionNumber());
2751 // Assumes in correct section after the entry point.
2752 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2754 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2755 collectVariableInfo(MF, ProcessedVars);
2757 // Get function line info.
2758 if (!Lines.empty()) {
2759 // Get section line info.
2760 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2761 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2762 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2763 // Append the function info to section info.
2764 SectionLineInfos.insert(SectionLineInfos.end(),
2765 Lines.begin(), Lines.end());
2768 // Construct abstract scopes.
2769 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2770 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2771 DISubprogram SP((*AI)->getScopeNode());
2773 // Collect info for variables that were optimized out.
2774 StringRef FName = SP.getLinkageName();
2776 FName = SP.getName();
2777 const Module *M = MF->getFunction()->getParent();
2778 if (NamedMDNode *NMD =
2779 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2780 getRealLinkageName(FName)))) {
2781 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2782 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2783 if (!DV || !ProcessedVars.insert(DV))
2785 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2787 Scope->addVariable(new DbgVariable(DV));
2791 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2792 constructScopeDIE(*AI);
2795 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2797 if (!DisableFramePointerElim(*MF))
2798 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2799 dwarf::DW_FORM_flag, 1);
2802 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2803 MMI->getFrameMoves()));
2807 CurrentFnDbgScope = NULL;
2808 InsnNeedsLabel.clear();
2809 DbgVariableToFrameIndexMap.clear();
2810 VarToAbstractVarMap.clear();
2811 DbgVariableToDbgInstMap.clear();
2812 DbgVariableLabelsMap.clear();
2813 DeleteContainerSeconds(DbgScopeMap);
2814 InsnsEndScopeSet.clear();
2815 ConcreteScopes.clear();
2816 DeleteContainerSeconds(AbstractScopes);
2817 AbstractScopesList.clear();
2818 AbstractVariables.clear();
2819 LabelsBeforeInsn.clear();
2820 LabelsAfterInsn.clear();
2825 /// recordVariableFrameIndex - Record a variable's index.
2826 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2827 assert (V && "Invalid DbgVariable!");
2828 DbgVariableToFrameIndexMap[V] = Index;
2831 /// findVariableFrameIndex - Return true if frame index for the variable
2832 /// is found. Update FI to hold value of the index.
2833 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2834 assert (V && "Invalid DbgVariable!");
2835 DenseMap<const DbgVariable *, int>::iterator I =
2836 DbgVariableToFrameIndexMap.find(V);
2837 if (I == DbgVariableToFrameIndexMap.end())
2843 /// findVariableLabel - Find MCSymbol for the variable.
2844 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2845 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2846 = DbgVariableLabelsMap.find(V);
2847 if (I == DbgVariableLabelsMap.end())
2849 else return I->second;
2852 /// findDbgScope - Find DbgScope for the debug loc attached with an
2854 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2855 DbgScope *Scope = NULL;
2857 MInsn->getParent()->getParent()->getFunction()->getContext();
2858 DebugLoc DL = MInsn->getDebugLoc();
2863 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2864 Scope = ConcreteScopes.lookup(IA);
2866 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2872 /// recordSourceLine - Register a source line with debug info. Returns the
2873 /// unique label that was emitted and which provides correspondence to
2874 /// the source line list.
2875 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2882 DIDescriptor Scope(S);
2884 if (Scope.isCompileUnit()) {
2885 DICompileUnit CU(S);
2886 Dir = CU.getDirectory();
2887 Fn = CU.getFilename();
2888 } else if (Scope.isSubprogram()) {
2890 Dir = SP.getDirectory();
2891 Fn = SP.getFilename();
2892 } else if (Scope.isLexicalBlock()) {
2893 DILexicalBlock DB(S);
2894 Dir = DB.getDirectory();
2895 Fn = DB.getFilename();
2897 assert(0 && "Unexpected scope info");
2899 Src = GetOrCreateSourceID(Dir, Fn);
2903 if (!Lines.empty()) {
2904 SrcLineInfo lastSrcLineInfo = Lines.back();
2905 // Emitting sequential line records with the same line number (but
2906 // different addresses) seems to confuse GDB. Avoid this.
2907 if (lastSrcLineInfo.getLine() == Line)
2912 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2913 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2915 Asm->OutStreamer.EmitLabel(Label);
2919 //===----------------------------------------------------------------------===//
2921 //===----------------------------------------------------------------------===//
2923 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2926 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2927 // Get the children.
2928 const std::vector<DIE *> &Children = Die->getChildren();
2930 // If not last sibling and has children then add sibling offset attribute.
2931 if (!Last && !Children.empty())
2932 Die->addSiblingOffset(DIEValueAllocator);
2934 // Record the abbreviation.
2935 assignAbbrevNumber(Die->getAbbrev());
2937 // Get the abbreviation for this DIE.
2938 unsigned AbbrevNumber = Die->getAbbrevNumber();
2939 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2942 Die->setOffset(Offset);
2944 // Start the size with the size of abbreviation code.
2945 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2947 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2948 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2950 // Size the DIE attribute values.
2951 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2952 // Size attribute value.
2953 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2955 // Size the DIE children if any.
2956 if (!Children.empty()) {
2957 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2958 "Children flag not set");
2960 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2961 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2963 // End of children marker.
2964 Offset += sizeof(int8_t);
2967 Die->setSize(Offset - Die->getOffset());
2971 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2973 void DwarfDebug::computeSizeAndOffsets() {
2974 unsigned PrevOffset = 0;
2975 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2976 E = CUMap.end(); I != E; ++I) {
2977 // Compute size of compile unit header.
2978 static unsigned Offset = PrevOffset +
2979 sizeof(int32_t) + // Length of Compilation Unit Info
2980 sizeof(int16_t) + // DWARF version number
2981 sizeof(int32_t) + // Offset Into Abbrev. Section
2982 sizeof(int8_t); // Pointer Size (in bytes)
2983 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2984 PrevOffset = Offset;
2988 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2989 /// temporary label to it if SymbolStem is specified.
2990 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2991 const char *SymbolStem = 0) {
2992 Asm->OutStreamer.SwitchSection(Section);
2993 if (!SymbolStem) return 0;
2995 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2996 Asm->OutStreamer.EmitLabel(TmpSym);
3000 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3001 /// the start of each one.
3002 void DwarfDebug::EmitSectionLabels() {
3003 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3005 // Dwarf sections base addresses.
3006 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3007 DwarfFrameSectionSym =
3008 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3011 DwarfInfoSectionSym =
3012 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3013 DwarfAbbrevSectionSym =
3014 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3015 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3017 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3018 EmitSectionSym(Asm, MacroInfo);
3020 DwarfDebugLineSectionSym =
3021 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3022 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3023 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3024 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3025 DwarfStrSectionSym =
3026 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3027 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3030 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3031 "section_debug_loc");
3033 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3034 EmitSectionSym(Asm, TLOF.getDataSection());
3037 /// emitDIE - Recusively Emits a debug information entry.
3039 void DwarfDebug::emitDIE(DIE *Die) {
3040 // Get the abbreviation for this DIE.
3041 unsigned AbbrevNumber = Die->getAbbrevNumber();
3042 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3044 // Emit the code (index) for the abbreviation.
3045 if (Asm->isVerbose())
3046 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3047 Twine::utohexstr(Die->getOffset()) + ":0x" +
3048 Twine::utohexstr(Die->getSize()) + " " +
3049 dwarf::TagString(Abbrev->getTag()));
3050 Asm->EmitULEB128(AbbrevNumber);
3052 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3053 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3055 // Emit the DIE attribute values.
3056 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3057 unsigned Attr = AbbrevData[i].getAttribute();
3058 unsigned Form = AbbrevData[i].getForm();
3059 assert(Form && "Too many attributes for DIE (check abbreviation)");
3061 if (Asm->isVerbose())
3062 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3065 case dwarf::DW_AT_sibling:
3066 Asm->EmitInt32(Die->getSiblingOffset());
3068 case dwarf::DW_AT_abstract_origin: {
3069 DIEEntry *E = cast<DIEEntry>(Values[i]);
3070 DIE *Origin = E->getEntry();
3071 unsigned Addr = Origin->getOffset();
3072 Asm->EmitInt32(Addr);
3075 case dwarf::DW_AT_ranges: {
3076 // DW_AT_range Value encodes offset in debug_range section.
3077 DIEInteger *V = cast<DIEInteger>(Values[i]);
3078 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3080 DwarfDebugRangeSectionSym,
3084 case dwarf::DW_AT_stmt_list: {
3085 Asm->EmitLabelDifference(CurrentLineSectionSym,
3086 DwarfDebugLineSectionSym, 4);
3089 case dwarf::DW_AT_location: {
3090 if (UseDotDebugLocEntry.count(Die) != 0) {
3091 DIELabel *L = cast<DIELabel>(Values[i]);
3092 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3094 Values[i]->EmitValue(Asm, Form);
3098 // Emit an attribute using the defined form.
3099 Values[i]->EmitValue(Asm, Form);
3104 // Emit the DIE children if any.
3105 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3106 const std::vector<DIE *> &Children = Die->getChildren();
3108 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3109 emitDIE(Children[j]);
3111 if (Asm->isVerbose())
3112 Asm->OutStreamer.AddComment("End Of Children Mark");
3117 /// emitDebugInfo - Emit the debug info section.
3119 void DwarfDebug::emitDebugInfo() {
3120 // Start debug info section.
3121 Asm->OutStreamer.SwitchSection(
3122 Asm->getObjFileLowering().getDwarfInfoSection());
3123 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3124 E = CUMap.end(); I != E; ++I) {
3125 CompileUnit *TheCU = I->second;
3126 DIE *Die = TheCU->getCUDie();
3128 // Emit the compile units header.
3129 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3132 // Emit size of content not including length itself
3133 unsigned ContentSize = Die->getSize() +
3134 sizeof(int16_t) + // DWARF version number
3135 sizeof(int32_t) + // Offset Into Abbrev. Section
3136 sizeof(int8_t) + // Pointer Size (in bytes)
3137 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3139 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3140 Asm->EmitInt32(ContentSize);
3141 Asm->OutStreamer.AddComment("DWARF version number");
3142 Asm->EmitInt16(dwarf::DWARF_VERSION);
3143 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3144 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3145 DwarfAbbrevSectionSym);
3146 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3147 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3150 // FIXME - extra padding for gdb bug.
3151 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3156 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3160 /// emitAbbreviations - Emit the abbreviation section.
3162 void DwarfDebug::emitAbbreviations() const {
3163 // Check to see if it is worth the effort.
3164 if (!Abbreviations.empty()) {
3165 // Start the debug abbrev section.
3166 Asm->OutStreamer.SwitchSection(
3167 Asm->getObjFileLowering().getDwarfAbbrevSection());
3169 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3171 // For each abbrevation.
3172 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3173 // Get abbreviation data
3174 const DIEAbbrev *Abbrev = Abbreviations[i];
3176 // Emit the abbrevations code (base 1 index.)
3177 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3179 // Emit the abbreviations data.
3183 // Mark end of abbreviations.
3184 Asm->EmitULEB128(0, "EOM(3)");
3186 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3190 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3191 /// the line matrix.
3193 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3194 // Define last address of section.
3195 Asm->OutStreamer.AddComment("Extended Op");
3198 Asm->OutStreamer.AddComment("Op size");
3199 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3200 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3201 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3203 Asm->OutStreamer.AddComment("Section end label");
3205 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3206 Asm->getTargetData().getPointerSize(),
3209 // Mark end of matrix.
3210 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3216 /// emitDebugLines - Emit source line information.
3218 void DwarfDebug::emitDebugLines() {
3219 // If the target is using .loc/.file, the assembler will be emitting the
3220 // .debug_line table automatically.
3221 if (Asm->MAI->hasDotLocAndDotFile())
3224 // Minimum line delta, thus ranging from -10..(255-10).
3225 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3226 // Maximum line delta, thus ranging from -10..(255-10).
3227 const int MaxLineDelta = 255 + MinLineDelta;
3229 // Start the dwarf line section.
3230 Asm->OutStreamer.SwitchSection(
3231 Asm->getObjFileLowering().getDwarfLineSection());
3233 // Construct the section header.
3234 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3235 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3236 Asm->OutStreamer.AddComment("Length of Source Line Info");
3237 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3238 Asm->GetTempSymbol("line_begin"), 4);
3239 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3241 Asm->OutStreamer.AddComment("DWARF version number");
3242 Asm->EmitInt16(dwarf::DWARF_VERSION);
3244 Asm->OutStreamer.AddComment("Prolog Length");
3245 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3246 Asm->GetTempSymbol("line_prolog_begin"), 4);
3247 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3249 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3251 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3253 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3254 Asm->EmitInt8(MinLineDelta);
3255 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3256 Asm->EmitInt8(MaxLineDelta);
3257 Asm->OutStreamer.AddComment("Special Opcode Base");
3258 Asm->EmitInt8(-MinLineDelta);
3260 // Line number standard opcode encodings argument count
3261 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3263 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3265 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3267 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3269 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3271 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3273 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3275 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3277 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3280 // Emit directories.
3281 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3282 const std::string &Dir = getSourceDirectoryName(DI);
3283 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3284 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3287 Asm->OutStreamer.AddComment("End of directories");
3291 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3292 // Remember source id starts at 1.
3293 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3294 const std::string &FN = getSourceFileName(Id.second);
3295 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3296 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3298 Asm->EmitULEB128(Id.first, "Directory #");
3299 Asm->EmitULEB128(0, "Mod date");
3300 Asm->EmitULEB128(0, "File size");
3303 Asm->OutStreamer.AddComment("End of files");
3306 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3308 // A sequence for each text section.
3309 unsigned SecSrcLinesSize = SectionSourceLines.size();
3311 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3312 // Isolate current sections line info.
3313 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3315 // Dwarf assumes we start with first line of first source file.
3316 unsigned Source = 1;
3319 // Construct rows of the address, source, line, column matrix.
3320 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3321 const SrcLineInfo &LineInfo = LineInfos[i];
3322 MCSymbol *Label = LineInfo.getLabel();
3323 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3325 if (Asm->isVerbose()) {
3326 std::pair<unsigned, unsigned> SrcID =
3327 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3328 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3330 Twine(getSourceFileName(SrcID.second)) +
3331 ":" + Twine(LineInfo.getLine()));
3334 // Define the line address.
3335 Asm->OutStreamer.AddComment("Extended Op");
3337 Asm->OutStreamer.AddComment("Op size");
3338 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3340 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3341 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3343 Asm->OutStreamer.AddComment("Location label");
3344 Asm->OutStreamer.EmitSymbolValue(Label,
3345 Asm->getTargetData().getPointerSize(),
3348 // If change of source, then switch to the new source.
3349 if (Source != LineInfo.getSourceID()) {
3350 Source = LineInfo.getSourceID();
3351 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3352 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3353 Asm->EmitULEB128(Source, "New Source");
3356 // If change of line.
3357 if (Line != LineInfo.getLine()) {
3358 // Determine offset.
3359 int Offset = LineInfo.getLine() - Line;
3360 int Delta = Offset - MinLineDelta;
3363 Line = LineInfo.getLine();
3365 // If delta is small enough and in range...
3366 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3367 // ... then use fast opcode.
3368 Asm->OutStreamer.AddComment("Line Delta");
3369 Asm->EmitInt8(Delta - MinLineDelta);
3371 // ... otherwise use long hand.
3372 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3373 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3374 Asm->EmitSLEB128(Offset, "Line Offset");
3375 Asm->OutStreamer.AddComment("DW_LNS_copy");
3376 Asm->EmitInt8(dwarf::DW_LNS_copy);
3379 // Copy the previous row (different address or source)
3380 Asm->OutStreamer.AddComment("DW_LNS_copy");
3381 Asm->EmitInt8(dwarf::DW_LNS_copy);
3385 emitEndOfLineMatrix(j + 1);
3388 if (SecSrcLinesSize == 0)
3389 // Because we're emitting a debug_line section, we still need a line
3390 // table. The linker and friends expect it to exist. If there's nothing to
3391 // put into it, emit an empty table.
3392 emitEndOfLineMatrix(1);
3394 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3397 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3399 void DwarfDebug::emitCommonDebugFrame() {
3400 if (!Asm->MAI->doesDwarfRequireFrameSection())
3403 int stackGrowth = Asm->getTargetData().getPointerSize();
3404 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3405 TargetFrameInfo::StackGrowsDown)
3408 // Start the dwarf frame section.
3409 Asm->OutStreamer.SwitchSection(
3410 Asm->getObjFileLowering().getDwarfFrameSection());
3412 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3413 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3414 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3415 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3417 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3418 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3419 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3420 Asm->OutStreamer.AddComment("CIE Version");
3421 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3422 Asm->OutStreamer.AddComment("CIE Augmentation");
3423 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3424 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3425 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3426 Asm->OutStreamer.AddComment("CIE RA Column");
3427 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3428 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3430 std::vector<MachineMove> Moves;
3431 RI->getInitialFrameState(Moves);
3433 Asm->EmitFrameMoves(Moves, 0, false);
3435 Asm->EmitAlignment(2);
3436 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3439 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3442 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3443 if (!Asm->MAI->doesDwarfRequireFrameSection())
3446 // Start the dwarf frame section.
3447 Asm->OutStreamer.SwitchSection(
3448 Asm->getObjFileLowering().getDwarfFrameSection());
3450 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3451 MCSymbol *DebugFrameBegin =
3452 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3453 MCSymbol *DebugFrameEnd =
3454 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3455 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3457 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3459 Asm->OutStreamer.AddComment("FDE CIE offset");
3460 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3461 DwarfFrameSectionSym);
3463 Asm->OutStreamer.AddComment("FDE initial location");
3464 MCSymbol *FuncBeginSym =
3465 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3466 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3467 Asm->getTargetData().getPointerSize(),
3471 Asm->OutStreamer.AddComment("FDE address range");
3472 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3473 FuncBeginSym, Asm->getTargetData().getPointerSize());
3475 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3477 Asm->EmitAlignment(2);
3478 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3481 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3483 void DwarfDebug::emitDebugPubNames() {
3484 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3485 E = CUMap.end(); I != E; ++I) {
3486 CompileUnit *TheCU = I->second;
3487 // Start the dwarf pubnames section.
3488 Asm->OutStreamer.SwitchSection(
3489 Asm->getObjFileLowering().getDwarfPubNamesSection());
3491 Asm->OutStreamer.AddComment("Length of Public Names Info");
3492 Asm->EmitLabelDifference(
3493 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3494 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3496 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3499 Asm->OutStreamer.AddComment("DWARF Version");
3500 Asm->EmitInt16(dwarf::DWARF_VERSION);
3502 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3503 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3504 DwarfInfoSectionSym);
3506 Asm->OutStreamer.AddComment("Compilation Unit Length");
3507 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3508 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3511 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3512 for (StringMap<DIE*>::const_iterator
3513 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3514 const char *Name = GI->getKeyData();
3515 DIE *Entity = GI->second;
3517 Asm->OutStreamer.AddComment("DIE offset");
3518 Asm->EmitInt32(Entity->getOffset());
3520 if (Asm->isVerbose())
3521 Asm->OutStreamer.AddComment("External Name");
3522 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3525 Asm->OutStreamer.AddComment("End Mark");
3527 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3532 void DwarfDebug::emitDebugPubTypes() {
3533 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3534 E = CUMap.end(); I != E; ++I) {
3535 CompileUnit *TheCU = I->second;
3536 // Start the dwarf pubnames section.
3537 Asm->OutStreamer.SwitchSection(
3538 Asm->getObjFileLowering().getDwarfPubTypesSection());
3539 Asm->OutStreamer.AddComment("Length of Public Types Info");
3540 Asm->EmitLabelDifference(
3541 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3542 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3544 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3547 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3548 Asm->EmitInt16(dwarf::DWARF_VERSION);
3550 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3551 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3552 DwarfInfoSectionSym);
3554 Asm->OutStreamer.AddComment("Compilation Unit Length");
3555 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3556 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3559 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3560 for (StringMap<DIE*>::const_iterator
3561 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3562 const char *Name = GI->getKeyData();
3563 DIE * Entity = GI->second;
3565 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3566 Asm->EmitInt32(Entity->getOffset());
3568 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3569 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3572 Asm->OutStreamer.AddComment("End Mark");
3574 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3579 /// emitDebugStr - Emit visible names into a debug str section.
3581 void DwarfDebug::emitDebugStr() {
3582 // Check to see if it is worth the effort.
3583 if (StringPool.empty()) return;
3585 // Start the dwarf str section.
3586 Asm->OutStreamer.SwitchSection(
3587 Asm->getObjFileLowering().getDwarfStrSection());
3589 // Get all of the string pool entries and put them in an array by their ID so
3590 // we can sort them.
3591 SmallVector<std::pair<unsigned,
3592 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3594 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3595 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3596 Entries.push_back(std::make_pair(I->second.second, &*I));
3598 array_pod_sort(Entries.begin(), Entries.end());
3600 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3601 // Emit a label for reference from debug information entries.
3602 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3604 // Emit the string itself.
3605 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3609 /// emitDebugLoc - Emit visible names into a debug loc section.
3611 void DwarfDebug::emitDebugLoc() {
3612 if (DotDebugLocEntries.empty())
3615 // Start the dwarf loc section.
3616 Asm->OutStreamer.SwitchSection(
3617 Asm->getObjFileLowering().getDwarfLocSection());
3618 unsigned char Size = Asm->getTargetData().getPointerSize();
3619 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3621 for (SmallVector<DotDebugLocEntry, 4>::iterator
3622 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3623 I != E; ++I, ++index) {
3624 DotDebugLocEntry Entry = *I;
3625 if (Entry.isEmpty()) {
3626 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3627 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3628 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3630 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3631 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3632 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3633 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3635 Asm->OutStreamer.AddComment("Loc expr size");
3637 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3639 Asm->OutStreamer.AddComment("Loc expr size");
3640 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3641 Asm->EmitInt8(dwarf::DW_OP_regx);
3642 Asm->EmitULEB128(Reg);
3648 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3650 void DwarfDebug::EmitDebugARanges() {
3651 // Start the dwarf aranges section.
3652 Asm->OutStreamer.SwitchSection(
3653 Asm->getObjFileLowering().getDwarfARangesSection());
3656 /// emitDebugRanges - Emit visible names into a debug ranges section.
3658 void DwarfDebug::emitDebugRanges() {
3659 // Start the dwarf ranges section.
3660 Asm->OutStreamer.SwitchSection(
3661 Asm->getObjFileLowering().getDwarfRangesSection());
3662 unsigned char Size = Asm->getTargetData().getPointerSize();
3663 for (SmallVector<const MCSymbol *, 8>::iterator
3664 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3667 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3669 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3673 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3675 void DwarfDebug::emitDebugMacInfo() {
3676 if (const MCSection *LineInfo =
3677 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3678 // Start the dwarf macinfo section.
3679 Asm->OutStreamer.SwitchSection(LineInfo);
3683 /// emitDebugInlineInfo - Emit inline info using following format.
3685 /// 1. length of section
3686 /// 2. Dwarf version number
3687 /// 3. address size.
3689 /// Entries (one "entry" for each function that was inlined):
3691 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3692 /// otherwise offset into __debug_str for regular function name.
3693 /// 2. offset into __debug_str section for regular function name.
3694 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3695 /// instances for the function.
3697 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3698 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3699 /// __debug_info section, and the low_pc is the starting address for the
3700 /// inlining instance.
3701 void DwarfDebug::emitDebugInlineInfo() {
3702 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3708 Asm->OutStreamer.SwitchSection(
3709 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3711 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3712 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3713 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3715 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3717 Asm->OutStreamer.AddComment("Dwarf Version");
3718 Asm->EmitInt16(dwarf::DWARF_VERSION);
3719 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3720 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3722 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3723 E = InlinedSPNodes.end(); I != E; ++I) {
3725 const MDNode *Node = *I;
3726 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3727 = InlineInfo.find(Node);
3728 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3729 DISubprogram SP(Node);
3730 StringRef LName = SP.getLinkageName();
3731 StringRef Name = SP.getName();
3733 Asm->OutStreamer.AddComment("MIPS linkage name");
3734 if (LName.empty()) {
3735 Asm->OutStreamer.EmitBytes(Name, 0);
3736 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3738 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3739 DwarfStrSectionSym);
3741 Asm->OutStreamer.AddComment("Function name");
3742 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3743 Asm->EmitULEB128(Labels.size(), "Inline count");
3745 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3746 LE = Labels.end(); LI != LE; ++LI) {
3747 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3748 Asm->EmitInt32(LI->second->getOffset());
3750 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3751 Asm->OutStreamer.EmitSymbolValue(LI->first,
3752 Asm->getTargetData().getPointerSize(),0);
3756 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));