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/Statistic.h"
34 #include "llvm/ADT/STLExtras.h"
35 #include "llvm/ADT/StringExtras.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/ErrorHandling.h"
39 #include "llvm/Support/ValueHandle.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/Timer.h"
42 #include "llvm/System/Path.h"
45 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
46 cl::desc("Print DbgScope information for each machine instruction"));
48 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
50 cl::desc("Disable debug info printing"));
52 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
53 cl::desc("Make an absense of debug location information explicit."),
57 STATISTIC(BlocksWithoutLineNo, "Number of blocks without any line number");
61 const char *DWARFGroupName = "DWARF Emission";
62 const char *DbgTimerName = "DWARF Debug Writer";
63 } // end anonymous namespace
65 //===----------------------------------------------------------------------===//
67 /// Configuration values for initial hash set sizes (log2).
69 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
73 //===----------------------------------------------------------------------===//
74 /// CompileUnit - This dwarf writer support class manages information associate
75 /// with a source file.
77 /// ID - File identifier for source.
81 /// Die - Compile unit debug information entry.
83 const OwningPtr<DIE> CUDie;
85 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
88 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
89 /// variables to debug information entries.
90 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
92 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
93 /// descriptors to debug information entries using a DIEEntry proxy.
94 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
96 /// Globals - A map of globally visible named entities for this unit.
98 StringMap<DIE*> Globals;
100 /// GlobalTypes - A map of globally visible types for this unit.
102 StringMap<DIE*> GlobalTypes;
105 CompileUnit(unsigned I, DIE *D)
106 : ID(I), CUDie(D), IndexTyDie(0) {}
109 unsigned getID() const { return ID; }
110 DIE* getCUDie() const { return CUDie.get(); }
111 const StringMap<DIE*> &getGlobals() const { return Globals; }
112 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
114 /// hasContent - Return true if this compile unit has something to write out.
116 bool hasContent() const { return !CUDie->getChildren().empty(); }
118 /// addGlobal - Add a new global entity to the compile unit.
120 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
122 /// addGlobalType - Add a new global type to the compile unit.
124 void addGlobalType(StringRef Name, DIE *Die) {
125 GlobalTypes[Name] = Die;
128 /// getDIE - Returns the debug information entry map slot for the
129 /// specified debug variable.
130 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
132 /// insertDIE - Insert DIE into the map.
133 void insertDIE(const MDNode *N, DIE *D) {
134 MDNodeToDieMap.insert(std::make_pair(N, D));
137 /// getDIEEntry - Returns the debug information entry for the speciefied
139 DIEEntry *getDIEEntry(const MDNode *N) {
140 DenseMap<const MDNode *, DIEEntry *>::iterator I =
141 MDNodeToDIEEntryMap.find(N);
142 if (I == MDNodeToDIEEntryMap.end())
147 /// insertDIEEntry - Insert debug information entry into the map.
148 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
149 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
152 /// addDie - Adds or interns the DIE to the compile unit.
154 void addDie(DIE *Buffer) {
155 this->CUDie->addChild(Buffer);
158 // getIndexTyDie - Get an anonymous type for index type.
159 DIE *getIndexTyDie() {
163 // setIndexTyDie - Set D as anonymous type for index which can be reused
165 void setIndexTyDie(DIE *D) {
171 //===----------------------------------------------------------------------===//
172 /// DbgVariable - This class is used to track local variable information.
175 DIVariable Var; // Variable Descriptor.
176 DIE *TheDIE; // Variable DIE.
177 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
179 // AbsVar may be NULL.
180 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
183 DIVariable getVariable() const { return Var; }
184 void setDIE(DIE *D) { TheDIE = D; }
185 DIE *getDIE() const { return TheDIE; }
186 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
187 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
188 StringRef getName() const { return Var.getName(); }
189 unsigned getTag() const { return Var.getTag(); }
190 bool variableHasComplexAddress() const {
191 assert(Var.Verify() && "Invalid complex DbgVariable!");
192 return Var.hasComplexAddress();
194 bool isBlockByrefVariable() const {
195 assert(Var.Verify() && "Invalid complex DbgVariable!");
196 return Var.isBlockByrefVariable();
198 unsigned getNumAddrElements() const {
199 assert(Var.Verify() && "Invalid complex DbgVariable!");
200 return Var.getNumAddrElements();
202 uint64_t getAddrElement(unsigned i) const {
203 return Var.getAddrElement(i);
205 DIType getType() const {
206 DIType Ty = Var.getType();
207 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
208 // addresses instead.
209 if (Var.isBlockByrefVariable()) {
210 /* Byref variables, in Blocks, are declared by the programmer as
211 "SomeType VarName;", but the compiler creates a
212 __Block_byref_x_VarName struct, and gives the variable VarName
213 either the struct, or a pointer to the struct, as its type. This
214 is necessary for various behind-the-scenes things the compiler
215 needs to do with by-reference variables in blocks.
217 However, as far as the original *programmer* is concerned, the
218 variable should still have type 'SomeType', as originally declared.
220 The following function dives into the __Block_byref_x_VarName
221 struct to find the original type of the variable. This will be
222 passed back to the code generating the type for the Debug
223 Information Entry for the variable 'VarName'. 'VarName' will then
224 have the original type 'SomeType' in its debug information.
226 The original type 'SomeType' will be the type of the field named
227 'VarName' inside the __Block_byref_x_VarName struct.
229 NOTE: In order for this to not completely fail on the debugger
230 side, the Debug Information Entry for the variable VarName needs to
231 have a DW_AT_location that tells the debugger how to unwind through
232 the pointers and __Block_byref_x_VarName struct to find the actual
233 value of the variable. The function addBlockByrefType does this. */
235 unsigned tag = Ty.getTag();
237 if (tag == dwarf::DW_TAG_pointer_type) {
238 DIDerivedType DTy = DIDerivedType(Ty);
239 subType = DTy.getTypeDerivedFrom();
242 DICompositeType blockStruct = DICompositeType(subType);
243 DIArray Elements = blockStruct.getTypeArray();
245 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
246 DIDescriptor Element = Elements.getElement(i);
247 DIDerivedType DT = DIDerivedType(Element);
248 if (getName() == DT.getName())
249 return (DT.getTypeDerivedFrom());
257 //===----------------------------------------------------------------------===//
258 /// DbgRange - This is used to track range of instructions with identical
259 /// debug info scope.
261 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
263 //===----------------------------------------------------------------------===//
264 /// DbgScope - This class is used to track scope information.
267 DbgScope *Parent; // Parent to this scope.
268 DIDescriptor Desc; // Debug info descriptor for scope.
269 // Location at which this scope is inlined.
270 AssertingVH<const MDNode> InlinedAtLocation;
271 bool AbstractScope; // Abstract Scope
272 const MachineInstr *LastInsn; // Last instruction of this scope.
273 const MachineInstr *FirstInsn; // First instruction of this scope.
274 unsigned DFSIn, DFSOut;
275 // Scopes defined in scope. Contents not owned.
276 SmallVector<DbgScope *, 4> Scopes;
277 // Variables declared in scope. Contents owned.
278 SmallVector<DbgVariable *, 8> Variables;
279 SmallVector<DbgRange, 4> Ranges;
280 // Private state for dump()
281 mutable unsigned IndentLevel;
283 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
284 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
285 LastInsn(0), FirstInsn(0),
286 DFSIn(0), DFSOut(0), IndentLevel(0) {}
290 DbgScope *getParent() const { return Parent; }
291 void setParent(DbgScope *P) { Parent = P; }
292 DIDescriptor getDesc() const { return Desc; }
293 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
294 const MDNode *getScopeNode() const { return Desc; }
295 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
296 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
297 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
299 /// openInsnRange - This scope covers instruction range starting from MI.
300 void openInsnRange(const MachineInstr *MI) {
305 Parent->openInsnRange(MI);
308 /// extendInsnRange - Extend the current instruction range covered by
310 void extendInsnRange(const MachineInstr *MI) {
311 assert (FirstInsn && "MI Range is not open!");
314 Parent->extendInsnRange(MI);
317 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
318 /// until now. This is used when a new scope is encountered while walking
319 /// machine instructions.
320 void closeInsnRange(DbgScope *NewScope = NULL) {
321 assert (LastInsn && "Last insn missing!");
322 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
325 // If Parent dominates NewScope then do not close Parent's instruction
327 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
328 Parent->closeInsnRange(NewScope);
331 void setAbstractScope() { AbstractScope = true; }
332 bool isAbstractScope() const { return AbstractScope; }
334 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
335 unsigned getDFSOut() const { return DFSOut; }
336 void setDFSOut(unsigned O) { DFSOut = O; }
337 unsigned getDFSIn() const { return DFSIn; }
338 void setDFSIn(unsigned I) { DFSIn = I; }
339 bool dominates(const DbgScope *S) {
342 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
347 /// addScope - Add a scope to the scope.
349 void addScope(DbgScope *S) { Scopes.push_back(S); }
351 /// addVariable - Add a variable to the scope.
353 void addVariable(DbgVariable *V) { Variables.push_back(V); }
360 } // end llvm namespace
363 void DbgScope::dump() const {
364 raw_ostream &err = dbgs();
365 err.indent(IndentLevel);
366 const MDNode *N = Desc;
369 err << "Abstract Scope\n";
373 err << "Children ...\n";
374 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
375 if (Scopes[i] != this)
382 DbgScope::~DbgScope() {
383 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
387 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
388 : Asm(A), MMI(Asm->MMI), FirstCU(0),
389 AbbreviationsSet(InitAbbreviationsSetSize),
390 CurrentFnDbgScope(0), PrevLabel(NULL) {
391 NextStringPoolNumber = 0;
393 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
394 DwarfStrSectionSym = TextSectionSym = 0;
395 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
396 FunctionBeginSym = FunctionEndSym = 0;
397 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
399 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
403 DwarfDebug::~DwarfDebug() {
404 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
405 DIEBlocks[j]->~DIEBlock();
408 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
409 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
410 if (Entry.first) return Entry.first;
412 Entry.second = NextStringPoolNumber++;
413 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
417 /// assignAbbrevNumber - Define a unique number for the abbreviation.
419 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
420 // Profile the node so that we can make it unique.
424 // Check the set for priors.
425 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
427 // If it's newly added.
428 if (InSet == &Abbrev) {
429 // Add to abbreviation list.
430 Abbreviations.push_back(&Abbrev);
432 // Assign the vector position + 1 as its number.
433 Abbrev.setNumber(Abbreviations.size());
435 // Assign existing abbreviation number.
436 Abbrev.setNumber(InSet->getNumber());
440 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
441 /// information entry.
442 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
443 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
447 /// addUInt - Add an unsigned integer attribute data and value.
449 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
450 unsigned Form, uint64_t Integer) {
451 if (!Form) Form = DIEInteger::BestForm(false, Integer);
452 DIEValue *Value = Integer == 1 ?
453 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
454 Die->addValue(Attribute, Form, Value);
457 /// addSInt - Add an signed integer attribute data and value.
459 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
460 unsigned Form, int64_t Integer) {
461 if (!Form) Form = DIEInteger::BestForm(true, Integer);
462 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
463 Die->addValue(Attribute, Form, Value);
466 /// addString - Add a string attribute data and value. DIEString only
467 /// keeps string reference.
468 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
470 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
471 Die->addValue(Attribute, Form, Value);
474 /// addLabel - Add a Dwarf label attribute data and value.
476 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
477 const MCSymbol *Label) {
478 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
479 Die->addValue(Attribute, Form, Value);
482 /// addDelta - Add a label delta attribute data and value.
484 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
485 const MCSymbol *Hi, const MCSymbol *Lo) {
486 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
487 Die->addValue(Attribute, Form, Value);
490 /// addDIEEntry - Add a DIE attribute data and value.
492 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
494 Die->addValue(Attribute, Form, createDIEEntry(Entry));
498 /// addBlock - Add block data.
500 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
502 Block->ComputeSize(Asm);
503 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
504 Die->addValue(Attribute, Block->BestForm(), Block);
507 /// addSourceLine - Add location information to specified debug information
509 void DwarfDebug::addSourceLine(DIE *Die, DIVariable V) {
514 unsigned Line = V.getLineNumber();
517 unsigned FileID = GetOrCreateSourceID(V.getContext().getDirectory(),
518 V.getContext().getFilename());
519 assert(FileID && "Invalid file id");
520 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
521 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
524 /// addSourceLine - Add location information to specified debug information
526 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
527 // Verify global variable.
531 unsigned Line = G.getLineNumber();
534 unsigned FileID = GetOrCreateSourceID(G.getContext().getDirectory(),
535 G.getContext().getFilename());
536 assert(FileID && "Invalid file id");
537 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
538 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
541 /// addSourceLine - Add location information to specified debug information
543 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
544 // Verify subprogram.
547 // If the line number is 0, don't add it.
548 if (SP.getLineNumber() == 0)
551 unsigned Line = SP.getLineNumber();
552 if (!SP.getContext().Verify())
554 unsigned FileID = GetOrCreateSourceID(SP.getDirectory(),
556 assert(FileID && "Invalid file id");
557 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
558 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
561 /// addSourceLine - Add location information to specified debug information
563 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
568 unsigned Line = Ty.getLineNumber();
569 if (Line == 0 || !Ty.getContext().Verify())
571 unsigned FileID = GetOrCreateSourceID(Ty.getContext().getDirectory(),
572 Ty.getContext().getFilename());
573 assert(FileID && "Invalid file id");
574 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
575 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
578 /// addSourceLine - Add location information to specified debug information
580 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
585 unsigned Line = NS.getLineNumber();
588 StringRef FN = NS.getFilename();
589 StringRef Dir = NS.getDirectory();
591 unsigned FileID = GetOrCreateSourceID(Dir, FN);
592 assert(FileID && "Invalid file id");
593 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
594 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
597 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based
598 /// on provided frame index.
599 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) {
600 MachineLocation Location;
602 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
603 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
604 Location.set(FrameReg, Offset);
606 if (DV->variableHasComplexAddress())
607 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
608 else if (DV->isBlockByrefVariable())
609 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
611 addAddress(Die, dwarf::DW_AT_location, Location);
614 /// addComplexAddress - Start with the address based on the location provided,
615 /// and generate the DWARF information necessary to find the actual variable
616 /// given the extra address information encoded in the DIVariable, starting from
617 /// the starting location. Add the DWARF information to the die.
619 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
621 const MachineLocation &Location) {
622 DIType Ty = DV->getType();
624 // Decode the original location, and use that as the start of the byref
625 // variable's location.
626 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
627 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
628 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
630 if (Location.isReg()) {
632 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
634 Reg = Reg - dwarf::DW_OP_reg0;
635 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
636 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
640 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
642 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
643 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
646 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
649 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
650 uint64_t Element = DV->getAddrElement(i);
652 if (Element == DIFactory::OpPlus) {
653 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
654 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
655 } else if (Element == DIFactory::OpDeref) {
656 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
657 } else llvm_unreachable("unknown DIFactory Opcode");
660 // Now attach the location information to the DIE.
661 addBlock(Die, Attribute, 0, Block);
664 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
665 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
666 gives the variable VarName either the struct, or a pointer to the struct, as
667 its type. This is necessary for various behind-the-scenes things the
668 compiler needs to do with by-reference variables in Blocks.
670 However, as far as the original *programmer* is concerned, the variable
671 should still have type 'SomeType', as originally declared.
673 The function getBlockByrefType dives into the __Block_byref_x_VarName
674 struct to find the original type of the variable, which is then assigned to
675 the variable's Debug Information Entry as its real type. So far, so good.
676 However now the debugger will expect the variable VarName to have the type
677 SomeType. So we need the location attribute for the variable to be an
678 expression that explains to the debugger how to navigate through the
679 pointers and struct to find the actual variable of type SomeType.
681 The following function does just that. We start by getting
682 the "normal" location for the variable. This will be the location
683 of either the struct __Block_byref_x_VarName or the pointer to the
684 struct __Block_byref_x_VarName.
686 The struct will look something like:
688 struct __Block_byref_x_VarName {
690 struct __Block_byref_x_VarName *forwarding;
691 ... <various other fields>
693 ... <maybe more fields>
696 If we are given the struct directly (as our starting point) we
697 need to tell the debugger to:
699 1). Add the offset of the forwarding field.
701 2). Follow that pointer to get the real __Block_byref_x_VarName
702 struct to use (the real one may have been copied onto the heap).
704 3). Add the offset for the field VarName, to find the actual variable.
706 If we started with a pointer to the struct, then we need to
707 dereference that pointer first, before the other steps.
708 Translating this into DWARF ops, we will need to append the following
709 to the current location description for the variable:
711 DW_OP_deref -- optional, if we start with a pointer
712 DW_OP_plus_uconst <forward_fld_offset>
714 DW_OP_plus_uconst <varName_fld_offset>
716 That is what this function does. */
718 /// addBlockByrefAddress - Start with the address based on the location
719 /// provided, and generate the DWARF information necessary to find the
720 /// actual Block variable (navigating the Block struct) based on the
721 /// starting location. Add the DWARF information to the die. For
722 /// more information, read large comment just above here.
724 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
726 const MachineLocation &Location) {
727 DIType Ty = DV->getType();
729 unsigned Tag = Ty.getTag();
730 bool isPointer = false;
732 StringRef varName = DV->getName();
734 if (Tag == dwarf::DW_TAG_pointer_type) {
735 DIDerivedType DTy = DIDerivedType(Ty);
736 TmpTy = DTy.getTypeDerivedFrom();
740 DICompositeType blockStruct = DICompositeType(TmpTy);
742 // Find the __forwarding field and the variable field in the __Block_byref
744 DIArray Fields = blockStruct.getTypeArray();
745 DIDescriptor varField = DIDescriptor();
746 DIDescriptor forwardingField = DIDescriptor();
748 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
749 DIDescriptor Element = Fields.getElement(i);
750 DIDerivedType DT = DIDerivedType(Element);
751 StringRef fieldName = DT.getName();
752 if (fieldName == "__forwarding")
753 forwardingField = Element;
754 else if (fieldName == varName)
758 // Get the offsets for the forwarding field and the variable field.
759 unsigned forwardingFieldOffset =
760 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
761 unsigned varFieldOffset =
762 DIDerivedType(varField).getOffsetInBits() >> 3;
764 // Decode the original location, and use that as the start of the byref
765 // variable's location.
766 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
767 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
768 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
770 if (Location.isReg()) {
772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
774 Reg = Reg - dwarf::DW_OP_reg0;
775 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
776 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
780 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
782 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
783 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
786 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
789 // If we started with a pointer to the __Block_byref... struct, then
790 // the first thing we need to do is dereference the pointer (DW_OP_deref).
792 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
794 // Next add the offset for the '__forwarding' field:
795 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
796 // adding the offset if it's 0.
797 if (forwardingFieldOffset > 0) {
798 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
799 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
802 // Now dereference the __forwarding field to get to the real __Block_byref
803 // struct: DW_OP_deref.
804 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
806 // Now that we've got the real __Block_byref... struct, add the offset
807 // for the variable's field to get to the location of the actual variable:
808 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
809 if (varFieldOffset > 0) {
810 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
811 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
814 // Now attach the location information to the DIE.
815 addBlock(Die, Attribute, 0, Block);
818 /// addAddress - Add an address attribute to a die based on the location
820 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
821 const MachineLocation &Location) {
822 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
823 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
824 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
825 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
827 if (TRI->getFrameRegister(*Asm->MF) == Location.getReg()
828 && Location.getOffset()) {
829 // If variable offset is based in frame register then use fbreg.
830 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
831 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
832 addBlock(Die, Attribute, 0, Block);
836 if (Location.isReg()) {
838 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
840 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
841 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
845 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
847 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
848 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
851 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
854 addBlock(Die, Attribute, 0, Block);
857 /// addRegisterAddress - Add register location entry in variable DIE.
858 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
859 const MachineOperand &MO) {
860 assert (MO.isReg() && "Invalid machine operand!");
863 MachineLocation Location;
864 Location.set(MO.getReg());
865 addAddress(Die, dwarf::DW_AT_location, Location);
867 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
871 /// addConstantValue - Add constant value entry in variable DIE.
872 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
873 const MachineOperand &MO) {
874 assert (MO.isImm() && "Invalid machine operand!");
875 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
876 unsigned Imm = MO.getImm();
877 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
878 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
880 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
884 /// addConstantFPValue - Add constant value entry in variable DIE.
885 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
886 const MachineOperand &MO) {
887 assert (MO.isFPImm() && "Invalid machine operand!");
888 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
889 APFloat FPImm = MO.getFPImm()->getValueAPF();
891 // Get the raw data form of the floating point.
892 const APInt FltVal = FPImm.bitcastToAPInt();
893 const char *FltPtr = (const char*)FltVal.getRawData();
895 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
896 bool LittleEndian = Asm->getTargetData().isLittleEndian();
897 int Incr = (LittleEndian ? 1 : -1);
898 int Start = (LittleEndian ? 0 : NumBytes - 1);
899 int Stop = (LittleEndian ? NumBytes : -1);
901 // Output the constant to DWARF one byte at a time.
902 for (; Start != Stop; Start += Incr)
903 addUInt(Block, 0, dwarf::DW_FORM_data1,
904 (unsigned char)0xFF & FltPtr[Start]);
906 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
908 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
913 /// addToContextOwner - Add Die into the list of its context owner's children.
914 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
915 if (Context.isType()) {
916 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
917 ContextDIE->addChild(Die);
918 } else if (Context.isNameSpace()) {
919 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
920 ContextDIE->addChild(Die);
921 } else if (Context.isSubprogram()) {
922 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context));
923 ContextDIE->addChild(Die);
924 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
925 ContextDIE->addChild(Die);
927 getCompileUnit(Context)->addDie(Die);
930 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
932 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
933 CompileUnit *TypeCU = getCompileUnit(Ty);
934 DIE *TyDIE = TypeCU->getDIE(Ty);
939 TyDIE = new DIE(dwarf::DW_TAG_base_type);
940 TypeCU->insertDIE(Ty, TyDIE);
941 if (Ty.isBasicType())
942 constructTypeDIE(*TyDIE, DIBasicType(Ty));
943 else if (Ty.isCompositeType())
944 constructTypeDIE(*TyDIE, DICompositeType(Ty));
946 assert(Ty.isDerivedType() && "Unknown kind of DIType");
947 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
950 addToContextOwner(TyDIE, Ty.getContext());
954 /// addType - Add a new type attribute to the specified entity.
955 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
959 // Check for pre-existence.
960 CompileUnit *TypeCU = getCompileUnit(Ty);
961 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
962 // If it exists then use the existing value.
964 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
969 DIE *Buffer = getOrCreateTypeDIE(Ty);
972 Entry = createDIEEntry(Buffer);
973 TypeCU->insertDIEEntry(Ty, Entry);
975 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
978 /// constructTypeDIE - Construct basic type die from DIBasicType.
979 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
980 // Get core information.
981 StringRef Name = BTy.getName();
982 Buffer.setTag(dwarf::DW_TAG_base_type);
983 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
986 // Add name if not anonymous or intermediate type.
988 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
989 uint64_t Size = BTy.getSizeInBits() >> 3;
990 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
993 /// constructTypeDIE - Construct derived type die from DIDerivedType.
994 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
995 // Get core information.
996 StringRef Name = DTy.getName();
997 uint64_t Size = DTy.getSizeInBits() >> 3;
998 unsigned Tag = DTy.getTag();
1000 // FIXME - Workaround for templates.
1001 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
1005 // Map to main type, void will not have a type.
1006 DIType FromTy = DTy.getTypeDerivedFrom();
1007 addType(&Buffer, FromTy);
1009 // Add name if not anonymous or intermediate type.
1011 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1013 // Add size if non-zero (derived types might be zero-sized.)
1015 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1017 // Add source line info if available and TyDesc is not a forward declaration.
1018 if (!DTy.isForwardDecl())
1019 addSourceLine(&Buffer, DTy);
1022 /// constructTypeDIE - Construct type DIE from DICompositeType.
1023 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1024 // Get core information.
1025 StringRef Name = CTy.getName();
1027 uint64_t Size = CTy.getSizeInBits() >> 3;
1028 unsigned Tag = CTy.getTag();
1032 case dwarf::DW_TAG_vector_type:
1033 case dwarf::DW_TAG_array_type:
1034 constructArrayTypeDIE(Buffer, &CTy);
1036 case dwarf::DW_TAG_enumeration_type: {
1037 DIArray Elements = CTy.getTypeArray();
1039 // Add enumerators to enumeration type.
1040 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1041 DIE *ElemDie = NULL;
1042 DIDescriptor Enum(Elements.getElement(i));
1043 if (Enum.isEnumerator()) {
1044 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1045 Buffer.addChild(ElemDie);
1050 case dwarf::DW_TAG_subroutine_type: {
1052 DIArray Elements = CTy.getTypeArray();
1053 DIDescriptor RTy = Elements.getElement(0);
1054 addType(&Buffer, DIType(RTy));
1056 bool isPrototyped = true;
1058 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1059 DIDescriptor Ty = Elements.getElement(i);
1060 if (Ty.isUnspecifiedParameter()) {
1061 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1062 Buffer.addChild(Arg);
1063 isPrototyped = false;
1065 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1066 addType(Arg, DIType(Ty));
1067 Buffer.addChild(Arg);
1070 // Add prototype flag.
1072 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1075 case dwarf::DW_TAG_structure_type:
1076 case dwarf::DW_TAG_union_type:
1077 case dwarf::DW_TAG_class_type: {
1078 // Add elements to structure type.
1079 DIArray Elements = CTy.getTypeArray();
1081 // A forward struct declared type may not have elements available.
1082 unsigned N = Elements.getNumElements();
1086 // Add elements to structure type.
1087 for (unsigned i = 0; i < N; ++i) {
1088 DIDescriptor Element = Elements.getElement(i);
1089 DIE *ElemDie = NULL;
1090 if (Element.isSubprogram()) {
1091 DISubprogram SP(Element);
1092 ElemDie = createSubprogramDIE(DISubprogram(Element));
1093 if (SP.isProtected())
1094 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1095 dwarf::DW_ACCESS_protected);
1096 else if (SP.isPrivate())
1097 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1098 dwarf::DW_ACCESS_private);
1100 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1101 dwarf::DW_ACCESS_public);
1102 if (SP.isExplicit())
1103 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
1105 else if (Element.isVariable()) {
1106 DIVariable DV(Element);
1107 ElemDie = new DIE(dwarf::DW_TAG_variable);
1108 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1110 addType(ElemDie, DV.getType());
1111 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1112 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1113 addSourceLine(ElemDie, DV);
1114 } else if (Element.isDerivedType())
1115 ElemDie = createMemberDIE(DIDerivedType(Element));
1118 Buffer.addChild(ElemDie);
1121 if (CTy.isAppleBlockExtension())
1122 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1124 unsigned RLang = CTy.getRunTimeLang();
1126 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1127 dwarf::DW_FORM_data1, RLang);
1129 DICompositeType ContainingType = CTy.getContainingType();
1130 if (DIDescriptor(ContainingType).isCompositeType())
1131 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1132 getOrCreateTypeDIE(DIType(ContainingType)));
1134 DIDescriptor Context = CTy.getContext();
1135 addToContextOwner(&Buffer, Context);
1143 // Add name if not anonymous or intermediate type.
1145 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1147 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1148 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1150 // Add size if non-zero (derived types might be zero-sized.)
1152 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1154 // Add zero size if it is not a forward declaration.
1155 if (CTy.isForwardDecl())
1156 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1158 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1161 // Add source line info if available.
1162 if (!CTy.isForwardDecl())
1163 addSourceLine(&Buffer, CTy);
1167 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1168 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1169 int64_t L = SR.getLo();
1170 int64_t H = SR.getHi();
1171 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1173 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1175 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1176 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1178 Buffer.addChild(DW_Subrange);
1181 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1182 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1183 DICompositeType *CTy) {
1184 Buffer.setTag(dwarf::DW_TAG_array_type);
1185 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1186 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1188 // Emit derived type.
1189 addType(&Buffer, CTy->getTypeDerivedFrom());
1190 DIArray Elements = CTy->getTypeArray();
1192 // Get an anonymous type for index type.
1193 CompileUnit *TheCU = getCompileUnit(*CTy);
1194 DIE *IdxTy = TheCU->getIndexTyDie();
1196 // Construct an anonymous type for index type.
1197 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1198 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1199 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1200 dwarf::DW_ATE_signed);
1201 TheCU->addDie(IdxTy);
1202 TheCU->setIndexTyDie(IdxTy);
1205 // Add subranges to array type.
1206 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1207 DIDescriptor Element = Elements.getElement(i);
1208 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1209 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1213 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1214 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1215 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1216 StringRef Name = ETy.getName();
1217 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1218 int64_t Value = ETy.getEnumValue();
1219 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1223 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1224 /// printer to not emit usual symbol prefix before the symbol name is used then
1225 /// return linkage name after skipping this special LLVM prefix.
1226 static StringRef getRealLinkageName(StringRef LinkageName) {
1228 if (LinkageName.startswith(StringRef(&One, 1)))
1229 return LinkageName.substr(1);
1233 /// createMemberDIE - Create new member DIE.
1234 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1235 DIE *MemberDie = new DIE(DT.getTag());
1236 StringRef Name = DT.getName();
1238 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1240 addType(MemberDie, DT.getTypeDerivedFrom());
1242 addSourceLine(MemberDie, DT);
1244 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1245 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1247 uint64_t Size = DT.getSizeInBits();
1248 uint64_t FieldSize = DT.getOriginalTypeSize();
1250 if (Size != FieldSize) {
1252 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1253 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1255 uint64_t Offset = DT.getOffsetInBits();
1256 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1257 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1258 uint64_t FieldOffset = (HiMark - FieldSize);
1259 Offset -= FieldOffset;
1261 // Maybe we need to work from the other end.
1262 if (Asm->getTargetData().isLittleEndian())
1263 Offset = FieldSize - (Offset + Size);
1264 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1266 // Here WD_AT_data_member_location points to the anonymous
1267 // field that includes this bit field.
1268 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1271 // This is not a bitfield.
1272 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1274 if (DT.getTag() == dwarf::DW_TAG_inheritance
1275 && DT.isVirtual()) {
1277 // For C++, virtual base classes are not at fixed offset. Use following
1278 // expression to extract appropriate offset from vtable.
1279 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1281 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1282 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1283 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1284 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1285 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1286 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1287 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1288 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1290 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1293 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1295 if (DT.isProtected())
1296 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1297 dwarf::DW_ACCESS_protected);
1298 else if (DT.isPrivate())
1299 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1300 dwarf::DW_ACCESS_private);
1301 // Otherwise C++ member and base classes are considered public.
1302 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1303 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1304 dwarf::DW_ACCESS_public);
1306 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1307 dwarf::DW_VIRTUALITY_virtual);
1311 /// createSubprogramDIE - Create new DIE using SP.
1312 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
1313 CompileUnit *SPCU = getCompileUnit(SP);
1314 DIE *SPDie = SPCU->getDIE(SP);
1318 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1319 // Constructors and operators for anonymous aggregates do not have names.
1320 if (!SP.getName().empty())
1321 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1323 StringRef LinkageName = SP.getLinkageName();
1324 if (!LinkageName.empty())
1325 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1326 getRealLinkageName(LinkageName));
1328 addSourceLine(SPDie, SP);
1330 if (SP.isPrototyped())
1331 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1334 DICompositeType SPTy = SP.getType();
1335 DIArray Args = SPTy.getTypeArray();
1336 unsigned SPTag = SPTy.getTag();
1338 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1339 addType(SPDie, SPTy);
1341 addType(SPDie, DIType(Args.getElement(0)));
1343 unsigned VK = SP.getVirtuality();
1345 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1346 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1347 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1348 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1349 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1350 ContainingTypeMap.insert(std::make_pair(SPDie,
1351 SP.getContainingType()));
1354 if (!SP.isDefinition()) {
1355 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1357 // Add arguments. Do not add arguments for subprogram definition. They will
1358 // be handled while processing variables.
1359 DICompositeType SPTy = SP.getType();
1360 DIArray Args = SPTy.getTypeArray();
1361 unsigned SPTag = SPTy.getTag();
1363 if (SPTag == dwarf::DW_TAG_subroutine_type)
1364 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1365 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1366 DIType ATy = DIType(DIType(Args.getElement(i)));
1368 if (ATy.isArtificial())
1369 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1370 SPDie->addChild(Arg);
1374 if (SP.isArtificial())
1375 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1377 if (!SP.isLocalToUnit())
1378 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1380 if (SP.isOptimized())
1381 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1383 if (unsigned isa = Asm->getISAEncoding()) {
1384 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1387 // DW_TAG_inlined_subroutine may refer to this DIE.
1388 SPCU->insertDIE(SP, SPDie);
1390 // Add to context owner.
1391 addToContextOwner(SPDie, SP.getContext());
1396 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1397 assert(N && "Invalid Scope encoding!");
1399 DbgScope *AScope = AbstractScopes.lookup(N);
1403 DbgScope *Parent = NULL;
1405 DIDescriptor Scope(N);
1406 if (Scope.isLexicalBlock()) {
1407 DILexicalBlock DB(N);
1408 DIDescriptor ParentDesc = DB.getContext();
1409 Parent = getOrCreateAbstractScope(ParentDesc);
1412 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1415 Parent->addScope(AScope);
1416 AScope->setAbstractScope();
1417 AbstractScopes[N] = AScope;
1418 if (DIDescriptor(N).isSubprogram())
1419 AbstractScopesList.push_back(AScope);
1423 /// isSubprogramContext - Return true if Context is either a subprogram
1424 /// or another context nested inside a subprogram.
1425 static bool isSubprogramContext(const MDNode *Context) {
1428 DIDescriptor D(Context);
1429 if (D.isSubprogram())
1432 return isSubprogramContext(DIType(Context).getContext());
1436 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1437 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1438 /// If there are global variables in this scope then create and insert
1439 /// DIEs for these variables.
1440 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1441 CompileUnit *SPCU = getCompileUnit(SPNode);
1442 DIE *SPDie = SPCU->getDIE(SPNode);
1444 assert(SPDie && "Unable to find subprogram DIE!");
1445 DISubprogram SP(SPNode);
1447 // There is not any need to generate specification DIE for a function
1448 // defined at compile unit level. If a function is defined inside another
1449 // function then gdb prefers the definition at top level and but does not
1450 // expect specification DIE in parent function. So avoid creating
1451 // specification DIE for a function defined inside a function.
1452 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1453 !SP.getContext().isFile() &&
1454 !isSubprogramContext(SP.getContext())) {
1455 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1458 DICompositeType SPTy = SP.getType();
1459 DIArray Args = SPTy.getTypeArray();
1460 unsigned SPTag = SPTy.getTag();
1461 if (SPTag == dwarf::DW_TAG_subroutine_type)
1462 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1463 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1464 DIType ATy = DIType(DIType(Args.getElement(i)));
1466 if (ATy.isArtificial())
1467 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1468 SPDie->addChild(Arg);
1470 DIE *SPDeclDie = SPDie;
1471 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1472 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1474 SPCU->addDie(SPDie);
1477 // Pick up abstract subprogram DIE.
1478 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1479 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1480 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1481 dwarf::DW_FORM_ref4, AbsSPDIE);
1482 SPCU->addDie(SPDie);
1485 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1486 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1487 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1488 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1489 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1490 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1491 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1496 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1497 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1498 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1500 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1501 if (Scope->isAbstractScope())
1504 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1508 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1509 if (Ranges.size() > 1) {
1510 // .debug_range section has not been laid out yet. Emit offset in
1511 // .debug_range as a uint, size 4, for now. emitDIE will handle
1512 // DW_AT_ranges appropriately.
1513 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1514 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1515 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1516 RE = Ranges.end(); RI != RE; ++RI) {
1517 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1518 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1520 DebugRangeSymbols.push_back(NULL);
1521 DebugRangeSymbols.push_back(NULL);
1525 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1526 const MCSymbol *End = getLabelAfterInsn(RI->second);
1528 if (End == 0) return 0;
1530 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1531 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1533 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1534 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1539 /// constructInlinedScopeDIE - This scope represents inlined body of
1540 /// a function. Construct DIE to represent this concrete inlined copy
1541 /// of the function.
1542 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1544 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1545 assert (Ranges.empty() == false
1546 && "DbgScope does not have instruction markers!");
1548 // FIXME : .debug_inlined section specification does not clearly state how
1549 // to emit inlined scope that is split into multiple instruction ranges.
1550 // For now, use first instruction range and emit low_pc/high_pc pair and
1551 // corresponding .debug_inlined section entry for this pair.
1552 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1553 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1554 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1556 if (StartLabel == 0 || EndLabel == 0) {
1557 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1560 assert(StartLabel->isDefined() &&
1561 "Invalid starting label for an inlined scope!");
1562 assert(EndLabel->isDefined() &&
1563 "Invalid end label for an inlined scope!");
1565 if (!Scope->getScopeNode())
1567 DIScope DS(Scope->getScopeNode());
1568 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1570 DISubprogram InlinedSP = getDISubprogram(DS);
1571 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1572 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1573 assert(OriginDIE && "Unable to find Origin DIE!");
1574 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1575 dwarf::DW_FORM_ref4, OriginDIE);
1577 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1578 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1580 InlinedSubprogramDIEs.insert(OriginDIE);
1582 // Track the start label for this inlined function.
1583 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1584 I = InlineInfo.find(InlinedSP);
1586 if (I == InlineInfo.end()) {
1587 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1589 InlinedSPNodes.push_back(InlinedSP);
1591 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1593 DILocation DL(Scope->getInlinedAt());
1594 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1595 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1601 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1602 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1603 StringRef Name = DV->getName();
1607 // Translate tag to proper Dwarf tag. The result variable is dropped for
1610 switch (DV->getTag()) {
1611 case dwarf::DW_TAG_return_variable:
1613 case dwarf::DW_TAG_arg_variable:
1614 Tag = dwarf::DW_TAG_formal_parameter;
1616 case dwarf::DW_TAG_auto_variable: // fall thru
1618 Tag = dwarf::DW_TAG_variable;
1622 // Define variable debug information entry.
1623 DIE *VariableDie = new DIE(Tag);
1626 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1627 V2AVI = VarToAbstractVarMap.find(DV);
1628 if (V2AVI != VarToAbstractVarMap.end())
1629 AbsDIE = V2AVI->second->getDIE();
1632 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1633 dwarf::DW_FORM_ref4, AbsDIE);
1635 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1636 addSourceLine(VariableDie, DV->getVariable());
1638 // Add variable type.
1639 addType(VariableDie, DV->getType());
1642 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1643 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1644 else if (DIVariable(DV->getVariable()).isArtificial())
1645 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1647 if (Scope->isAbstractScope()) {
1648 DV->setDIE(VariableDie);
1652 // Add variable address.
1654 unsigned Offset = DV->getDotDebugLocOffset();
1655 if (Offset != ~0U) {
1656 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1657 Asm->GetTempSymbol("debug_loc", Offset));
1658 DV->setDIE(VariableDie);
1659 UseDotDebugLocEntry.insert(VariableDie);
1663 // Check if variable is described by a DBG_VALUE instruction.
1664 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1665 DbgVariableToDbgInstMap.find(DV);
1666 if (DVI != DbgVariableToDbgInstMap.end()) {
1667 const MachineInstr *DVInsn = DVI->second;
1668 const MCSymbol *DVLabel = findVariableLabel(DV);
1669 bool updated = false;
1670 // FIXME : Handle getNumOperands != 3
1671 if (DVInsn->getNumOperands() == 3) {
1672 if (DVInsn->getOperand(0).isReg()) {
1673 const MachineOperand RegOp = DVInsn->getOperand(0);
1674 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1675 if (DVInsn->getOperand(1).isImm() &&
1676 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1677 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1680 updated = addRegisterAddress(VariableDie, DVLabel, RegOp);
1682 else if (DVInsn->getOperand(0).isImm())
1683 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1684 else if (DVInsn->getOperand(0).isFPImm())
1686 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1688 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1689 if (Location.getReg()) {
1690 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1692 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1698 // If variableDie is not updated then DBG_VALUE instruction does not
1699 // have valid variable info.
1703 DV->setDIE(VariableDie);
1707 // .. else use frame index, if available.
1709 if (findVariableFrameIndex(DV, &FI))
1710 addVariableAddress(DV, VariableDie, FI);
1712 DV->setDIE(VariableDie);
1717 void DwarfDebug::addPubTypes(DISubprogram SP) {
1718 DICompositeType SPTy = SP.getType();
1719 unsigned SPTag = SPTy.getTag();
1720 if (SPTag != dwarf::DW_TAG_subroutine_type)
1723 DIArray Args = SPTy.getTypeArray();
1724 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1725 DIType ATy(Args.getElement(i));
1728 DICompositeType CATy = getDICompositeType(ATy);
1729 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1730 && !CATy.isForwardDecl()) {
1731 CompileUnit *TheCU = getCompileUnit(CATy);
1732 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1733 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1738 /// constructScopeDIE - Construct a DIE for this scope.
1739 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1740 if (!Scope || !Scope->getScopeNode())
1743 DIScope DS(Scope->getScopeNode());
1744 DIE *ScopeDIE = NULL;
1745 if (Scope->getInlinedAt())
1746 ScopeDIE = constructInlinedScopeDIE(Scope);
1747 else if (DS.isSubprogram()) {
1748 ProcessedSPNodes.insert(DS);
1749 if (Scope->isAbstractScope()) {
1750 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1751 // Note down abstract DIE.
1753 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1756 ScopeDIE = updateSubprogramScopeDIE(DS);
1759 ScopeDIE = constructLexicalScopeDIE(Scope);
1760 if (!ScopeDIE) return NULL;
1762 // Add variables to scope.
1763 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1764 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1765 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1767 ScopeDIE->addChild(VariableDIE);
1770 // Add nested scopes.
1771 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1772 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1773 // Define the Scope debug information entry.
1774 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1776 ScopeDIE->addChild(NestedDIE);
1779 if (DS.isSubprogram())
1780 addPubTypes(DISubprogram(DS));
1785 /// GetOrCreateSourceID - Look up the source id with the given directory and
1786 /// source file names. If none currently exists, create a new id and insert it
1787 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1789 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1791 assert (DirName.empty() == false && "Invalid directory name!");
1793 // If FE did not provide a file name, then assume stdin.
1794 if (FileName.empty())
1795 return GetOrCreateSourceID(DirName, "<stdin>");
1797 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1798 if (DI != DirectoryIdMap.end()) {
1799 DId = DI->getValue();
1801 DId = DirectoryNames.size() + 1;
1802 DirectoryIdMap[DirName] = DId;
1803 DirectoryNames.push_back(DirName);
1807 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1808 if (FI != SourceFileIdMap.end()) {
1809 FId = FI->getValue();
1811 FId = SourceFileNames.size() + 1;
1812 SourceFileIdMap[FileName] = FId;
1813 SourceFileNames.push_back(FileName);
1816 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1817 SourceIdMap.find(std::make_pair(DId, FId));
1818 if (SI != SourceIdMap.end())
1821 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1822 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1823 SourceIds.push_back(std::make_pair(DId, FId));
1828 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1829 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1830 CompileUnit *TheCU = getCompileUnit(NS);
1831 DIE *NDie = TheCU->getDIE(NS);
1834 NDie = new DIE(dwarf::DW_TAG_namespace);
1835 TheCU->insertDIE(NS, NDie);
1836 if (!NS.getName().empty())
1837 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1838 addSourceLine(NDie, NS);
1839 addToContextOwner(NDie, NS.getContext());
1843 /// constructCompileUnit - Create new CompileUnit for the given
1844 /// metadata node with tag DW_TAG_compile_unit.
1845 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1846 DICompileUnit DIUnit(N);
1847 StringRef FN = DIUnit.getFilename();
1848 StringRef Dir = DIUnit.getDirectory();
1849 unsigned ID = GetOrCreateSourceID(Dir, FN);
1851 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1852 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1853 DIUnit.getProducer());
1854 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1855 DIUnit.getLanguage());
1856 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1857 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1858 // simplifies debug range entries.
1859 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1860 // DW_AT_stmt_list is a offset of line number information for this
1861 // compile unit in debug_line section.
1862 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1863 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1864 Asm->GetTempSymbol("section_line"));
1866 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1869 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1870 if (DIUnit.isOptimized())
1871 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1873 StringRef Flags = DIUnit.getFlags();
1875 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1877 unsigned RVer = DIUnit.getRunTimeVersion();
1879 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1880 dwarf::DW_FORM_data1, RVer);
1882 CompileUnit *NewCU = new CompileUnit(ID, Die);
1885 CUMap.insert(std::make_pair(N, NewCU));
1888 /// getCompielUnit - Get CompileUnit DIE.
1889 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1890 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1892 const MDNode *CUNode = NULL;
1893 if (D.isCompileUnit())
1895 else if (D.isSubprogram())
1896 CUNode = DISubprogram(N).getCompileUnit();
1897 else if (D.isType())
1898 CUNode = DIType(N).getCompileUnit();
1899 else if (D.isGlobalVariable())
1900 CUNode = DIGlobalVariable(N).getCompileUnit();
1901 else if (D.isVariable())
1902 CUNode = DIVariable(N).getCompileUnit();
1903 else if (D.isNameSpace())
1904 CUNode = DINameSpace(N).getCompileUnit();
1905 else if (D.isFile())
1906 CUNode = DIFile(N).getCompileUnit();
1910 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1911 = CUMap.find(CUNode);
1912 if (I == CUMap.end())
1917 /// isUnsignedDIType - Return true if type encoding is unsigned.
1918 static bool isUnsignedDIType(DIType Ty) {
1919 DIDerivedType DTy(Ty);
1921 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1923 DIBasicType BTy(Ty);
1925 unsigned Encoding = BTy.getEncoding();
1926 if (Encoding == dwarf::DW_ATE_unsigned ||
1927 Encoding == dwarf::DW_ATE_unsigned_char)
1933 /// constructGlobalVariableDIE - Construct global variable DIE.
1934 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1935 DIGlobalVariable GV(N);
1937 // If debug information is malformed then ignore it.
1938 if (GV.Verify() == false)
1941 // Check for pre-existence.
1942 CompileUnit *TheCU = getCompileUnit(N);
1943 if (TheCU->getDIE(GV))
1946 DIType GTy = GV.getType();
1947 DIE *VariableDIE = new DIE(GV.getTag());
1949 bool isGlobalVariable = GV.getGlobal() != NULL;
1952 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1953 GV.getDisplayName());
1954 StringRef LinkageName = GV.getLinkageName();
1955 if (!LinkageName.empty() && isGlobalVariable)
1956 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1957 getRealLinkageName(LinkageName));
1959 addType(VariableDIE, GTy);
1960 if (GTy.isCompositeType() && !GTy.getName().empty()
1961 && !GTy.isForwardDecl()) {
1962 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1963 assert(Entry && "Missing global type!");
1964 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1966 // Add scoping info.
1967 if (!GV.isLocalToUnit()) {
1968 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1969 // Expose as global.
1970 TheCU->addGlobal(GV.getName(), VariableDIE);
1972 // Add line number info.
1973 addSourceLine(VariableDIE, GV);
1975 TheCU->insertDIE(N, VariableDIE);
1976 // Add to context owner.
1977 DIDescriptor GVContext = GV.getContext();
1978 addToContextOwner(VariableDIE, GVContext);
1980 if (isGlobalVariable) {
1981 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1982 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1983 addLabel(Block, 0, dwarf::DW_FORM_udata,
1984 Asm->Mang->getSymbol(GV.getGlobal()));
1985 // Do not create specification DIE if context is either compile unit
1987 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1988 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1989 // Create specification DIE.
1990 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1991 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1992 dwarf::DW_FORM_ref4, VariableDIE);
1993 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1994 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1995 TheCU->addDie(VariableSpecDIE);
1997 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1999 } else if (Constant *C = GV.getConstant()) {
2000 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
2001 if (isUnsignedDIType(GTy))
2002 addUInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
2003 CI->getZExtValue());
2005 addSInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
2006 CI->getSExtValue());
2012 /// construct SubprogramDIE - Construct subprogram DIE.
2013 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2016 // Check for pre-existence.
2017 CompileUnit *TheCU = getCompileUnit(N);
2018 if (TheCU->getDIE(N))
2021 if (!SP.isDefinition())
2022 // This is a method declaration which will be handled while constructing
2026 DIE *SubprogramDie = createSubprogramDIE(SP);
2029 TheCU->insertDIE(N, SubprogramDie);
2031 // Add to context owner.
2032 addToContextOwner(SubprogramDie, SP.getContext());
2034 // Expose as global.
2035 TheCU->addGlobal(SP.getName(), SubprogramDie);
2040 /// beginModule - Emit all Dwarf sections that should come prior to the
2041 /// content. Create global DIEs and emit initial debug info sections.
2042 /// This is inovked by the target AsmPrinter.
2043 void DwarfDebug::beginModule(Module *M) {
2044 if (DisableDebugInfoPrinting)
2047 DebugInfoFinder DbgFinder;
2048 DbgFinder.processModule(*M);
2050 bool HasDebugInfo = false;
2052 // Scan all the compile-units to see if there are any marked as the main unit.
2053 // if not, we do not generate debug info.
2054 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2055 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2056 if (DICompileUnit(*I).isMain()) {
2057 HasDebugInfo = true;
2062 if (!HasDebugInfo) return;
2064 // Tell MMI that we have debug info.
2065 MMI->setDebugInfoAvailability(true);
2067 // Emit initial sections.
2068 EmitSectionLabels();
2070 // Create all the compile unit DIEs.
2071 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2072 E = DbgFinder.compile_unit_end(); I != E; ++I)
2073 constructCompileUnit(*I);
2075 // Create DIEs for each subprogram.
2076 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2077 E = DbgFinder.subprogram_end(); I != E; ++I)
2078 constructSubprogramDIE(*I);
2080 // Create DIEs for each global variable.
2081 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2082 E = DbgFinder.global_variable_end(); I != E; ++I)
2083 constructGlobalVariableDIE(*I);
2085 //getOrCreateTypeDIE
2086 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2087 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2088 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2090 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2091 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2092 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2094 // Prime section data.
2095 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2097 // Print out .file directives to specify files for .loc directives. These are
2098 // printed out early so that they precede any .loc directives.
2099 if (Asm->MAI->hasDotLocAndDotFile()) {
2100 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2101 // Remember source id starts at 1.
2102 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2103 // FIXME: don't use sys::path for this! This should not depend on the
2105 sys::Path FullPath(getSourceDirectoryName(Id.first));
2107 FullPath.appendComponent(getSourceFileName(Id.second));
2108 assert(AppendOk && "Could not append filename to directory!");
2110 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2115 /// endModule - Emit all Dwarf sections that should come after the content.
2117 void DwarfDebug::endModule() {
2118 if (!FirstCU) return;
2119 const Module *M = MMI->getModule();
2120 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2121 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2122 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2123 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2124 DISubprogram SP(AllSPs->getOperand(SI));
2125 if (!SP.Verify()) continue;
2127 // Collect info for variables that were optimized out.
2128 if (!SP.isDefinition()) continue;
2129 StringRef FName = SP.getLinkageName();
2131 FName = SP.getName();
2133 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2135 unsigned E = NMD->getNumOperands();
2137 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2138 DeadFnScopeMap[SP] = Scope;
2139 for (unsigned I = 0; I != E; ++I) {
2140 DIVariable DV(NMD->getOperand(I));
2141 if (!DV.Verify()) continue;
2142 Scope->addVariable(new DbgVariable(DV));
2145 // Construct subprogram DIE and add variables DIEs.
2146 constructSubprogramDIE(SP);
2147 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2148 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2149 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2150 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2152 ScopeDIE->addChild(VariableDIE);
2157 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2158 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2159 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2161 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2164 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2165 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2166 DIE *SPDie = CI->first;
2167 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2169 DIE *NDie = getCompileUnit(N)->getDIE(N);
2170 if (!NDie) continue;
2171 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2174 // Standard sections final addresses.
2175 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2176 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2177 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2178 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2180 // End text sections.
2181 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2182 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2183 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2186 // Emit common frame information.
2187 emitCommonDebugFrame();
2189 // Emit function debug frame information
2190 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2191 E = DebugFrames.end(); I != E; ++I)
2192 emitFunctionDebugFrame(*I);
2194 // Compute DIE offsets and sizes.
2195 computeSizeAndOffsets();
2197 // Emit all the DIEs into a debug info section
2200 // Corresponding abbreviations into a abbrev section.
2201 emitAbbreviations();
2203 // Emit source line correspondence into a debug line section.
2206 // Emit info into a debug pubnames section.
2207 emitDebugPubNames();
2209 // Emit info into a debug pubtypes section.
2210 emitDebugPubTypes();
2212 // Emit info into a debug loc section.
2215 // Emit info into a debug aranges section.
2218 // Emit info into a debug ranges section.
2221 // Emit info into a debug macinfo section.
2224 // Emit inline info.
2225 emitDebugInlineInfo();
2227 // Emit info into a debug str section.
2231 DeleteContainerSeconds(DeadFnScopeMap);
2232 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2233 E = CUMap.end(); I != E; ++I)
2235 FirstCU = NULL; // Reset for the next Module, if any.
2238 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2239 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2240 DebugLoc ScopeLoc) {
2242 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2244 return AbsDbgVariable;
2246 LLVMContext &Ctx = Var->getContext();
2247 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2251 AbsDbgVariable = new DbgVariable(Var);
2252 Scope->addVariable(AbsDbgVariable);
2253 AbstractVariables[Var] = AbsDbgVariable;
2254 return AbsDbgVariable;
2257 /// collectVariableInfoFromMMITable - Collect variable information from
2258 /// side table maintained by MMI.
2260 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2261 SmallPtrSet<const MDNode *, 16> &Processed) {
2262 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2263 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2264 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2265 VE = VMap.end(); VI != VE; ++VI) {
2266 const MDNode *Var = VI->first;
2268 Processed.insert(Var);
2270 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2272 DbgScope *Scope = 0;
2273 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2274 Scope = ConcreteScopes.lookup(IA);
2276 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2278 // If variable scope is not found then skip this variable.
2282 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2283 DbgVariable *RegVar = new DbgVariable(DV);
2284 recordVariableFrameIndex(RegVar, VP.first);
2285 Scope->addVariable(RegVar);
2286 if (AbsDbgVariable) {
2287 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2288 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2293 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2294 /// DBG_VALUE instruction, is in undefined reg.
2295 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2296 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2297 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2302 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2303 /// DBG_VALUE instruction, is in a defined reg.
2304 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2305 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2306 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2311 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2313 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2314 SmallPtrSet<const MDNode *, 16> &Processed) {
2316 /// collection info from MMI table.
2317 collectVariableInfoFromMMITable(MF, Processed);
2319 SmallVector<const MachineInstr *, 8> DbgValues;
2320 // Collect variable information from DBG_VALUE machine instructions;
2321 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2323 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2325 const MachineInstr *MInsn = II;
2326 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2328 DbgValues.push_back(MInsn);
2331 // This is a collection of DBV_VALUE instructions describing same variable.
2332 SmallVector<const MachineInstr *, 4> MultipleValues;
2333 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2334 E = DbgValues.end(); I != E; ++I) {
2335 const MachineInstr *MInsn = *I;
2336 MultipleValues.clear();
2337 if (isDbgValueInDefinedReg(MInsn))
2338 MultipleValues.push_back(MInsn);
2339 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2340 if (Processed.count(DV) != 0)
2343 const MachineInstr *PrevMI = MInsn;
2344 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2345 ME = DbgValues.end(); MI != ME; ++MI) {
2347 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2348 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2349 !PrevMI->isIdenticalTo(*MI))
2350 MultipleValues.push_back(*MI);
2354 DbgScope *Scope = findDbgScope(MInsn);
2355 bool CurFnArg = false;
2356 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2357 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2359 if (!Scope && CurFnArg)
2360 Scope = CurrentFnDbgScope;
2361 // If variable scope is not found then skip this variable.
2365 Processed.insert(DV);
2366 DbgVariable *RegVar = new DbgVariable(DV);
2367 Scope->addVariable(RegVar);
2369 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2370 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2371 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2372 VarToAbstractVarMap[RegVar] = AbsVar;
2374 if (MultipleValues.size() <= 1) {
2375 DbgVariableToDbgInstMap[RegVar] = MInsn;
2379 // handle multiple DBG_VALUE instructions describing one variable.
2380 if (DotDebugLocEntries.empty())
2381 RegVar->setDotDebugLocOffset(0);
2383 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2384 const MachineInstr *Begin = NULL;
2385 const MachineInstr *End = NULL;
2386 for (SmallVector<const MachineInstr *, 4>::iterator
2387 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2388 MVI != MVE; ++MVI) {
2394 MachineLocation MLoc;
2395 if (Begin->getNumOperands() == 3) {
2396 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2397 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2399 MLoc = Asm->getDebugValueLocation(Begin);
2401 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2402 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2404 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2407 if (MVI + 1 == MVE) {
2408 // If End is the last instruction then its value is valid
2409 // until the end of the funtion.
2410 MachineLocation EMLoc;
2411 if (End->getNumOperands() == 3) {
2412 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2413 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2415 EMLoc = Asm->getDebugValueLocation(End);
2418 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2421 DotDebugLocEntries.push_back(DotDebugLocEntry());
2424 // Collect info for variables that were optimized out.
2425 const Function *F = MF->getFunction();
2426 const Module *M = F->getParent();
2427 if (NamedMDNode *NMD =
2428 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2429 getRealLinkageName(F->getName())))) {
2430 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2431 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2432 if (!DV || !Processed.insert(DV))
2434 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2436 Scope->addVariable(new DbgVariable(DV));
2441 /// getLabelBeforeInsn - Return Label preceding the instruction.
2442 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2443 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2444 LabelsBeforeInsn.find(MI);
2445 if (I == LabelsBeforeInsn.end())
2446 // FunctionBeginSym always preceeds all the instruction in current function.
2447 return FunctionBeginSym;
2451 /// getLabelAfterInsn - Return Label immediately following the instruction.
2452 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2453 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2454 LabelsAfterInsn.find(MI);
2455 if (I == LabelsAfterInsn.end())
2460 /// beginScope - Process beginning of a scope.
2461 void DwarfDebug::beginScope(const MachineInstr *MI) {
2462 if (InsnNeedsLabel.count(MI) == 0) {
2463 LabelsBeforeInsn[MI] = PrevLabel;
2468 DebugLoc DL = MI->getDebugLoc();
2469 if (!DL.isUnknown()) {
2470 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2471 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2473 LabelsBeforeInsn[MI] = PrevLabel;
2477 // If location is unknown then use temp label for this DBG_VALUE
2479 if (MI->isDebugValue()) {
2480 PrevLabel = MMI->getContext().CreateTempSymbol();
2481 Asm->OutStreamer.EmitLabel(PrevLabel);
2482 LabelsBeforeInsn[MI] = PrevLabel;
2486 if (UnknownLocations) {
2487 PrevLabel = recordSourceLine(0, 0, 0);
2488 LabelsBeforeInsn[MI] = PrevLabel;
2492 assert (0 && "Instruction is not processed!");
2495 /// endScope - Process end of a scope.
2496 void DwarfDebug::endScope(const MachineInstr *MI) {
2497 if (InsnsEndScopeSet.count(MI) != 0) {
2498 // Emit a label if this instruction ends a scope.
2499 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2500 Asm->OutStreamer.EmitLabel(Label);
2501 LabelsAfterInsn[MI] = Label;
2505 /// getOrCreateDbgScope - Create DbgScope for the scope.
2506 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2507 const MDNode *InlinedAt) {
2509 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2512 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2513 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2514 if (DIDescriptor(Scope).isLexicalBlock()) {
2516 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2517 WScope->setParent(Parent);
2518 Parent->addScope(WScope);
2521 if (!WScope->getParent()) {
2522 StringRef SPName = DISubprogram(Scope).getLinkageName();
2523 // We used to check only for a linkage name, but that fails
2524 // since we began omitting the linkage name for private
2525 // functions. The new way is to check for the name in metadata,
2526 // but that's not supported in old .ll test cases. Ergo, we
2528 if (SPName == Asm->MF->getFunction()->getName() ||
2529 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2530 CurrentFnDbgScope = WScope;
2536 getOrCreateAbstractScope(Scope);
2537 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2541 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2542 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2543 DILocation DL(InlinedAt);
2545 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2546 WScope->setParent(Parent);
2547 Parent->addScope(WScope);
2549 ConcreteScopes[InlinedAt] = WScope;
2554 /// hasValidLocation - Return true if debug location entry attached with
2555 /// machine instruction encodes valid location info.
2556 static bool hasValidLocation(LLVMContext &Ctx,
2557 const MachineInstr *MInsn,
2558 const MDNode *&Scope, const MDNode *&InlinedAt) {
2559 DebugLoc DL = MInsn->getDebugLoc();
2560 if (DL.isUnknown()) return false;
2562 const MDNode *S = DL.getScope(Ctx);
2564 // There is no need to create another DIE for compile unit. For all
2565 // other scopes, create one DbgScope now. This will be translated
2566 // into a scope DIE at the end.
2567 if (DIScope(S).isCompileUnit()) return false;
2570 InlinedAt = DL.getInlinedAt(Ctx);
2574 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2576 static void calculateDominanceGraph(DbgScope *Scope) {
2577 assert (Scope && "Unable to calculate scop edominance graph!");
2578 SmallVector<DbgScope *, 4> WorkStack;
2579 WorkStack.push_back(Scope);
2580 unsigned Counter = 0;
2581 while (!WorkStack.empty()) {
2582 DbgScope *WS = WorkStack.back();
2583 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2584 bool visitedChildren = false;
2585 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2586 SE = Children.end(); SI != SE; ++SI) {
2587 DbgScope *ChildScope = *SI;
2588 if (!ChildScope->getDFSOut()) {
2589 WorkStack.push_back(ChildScope);
2590 visitedChildren = true;
2591 ChildScope->setDFSIn(++Counter);
2595 if (!visitedChildren) {
2596 WorkStack.pop_back();
2597 WS->setDFSOut(++Counter);
2602 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2604 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2605 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2608 unsigned PrevDFSIn = 0;
2609 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2611 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2613 const MachineInstr *MInsn = II;
2614 const MDNode *Scope = NULL;
2615 const MDNode *InlinedAt = NULL;
2617 // Check if instruction has valid location information.
2618 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2622 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2623 MI2ScopeMap.find(MInsn);
2624 if (DI != MI2ScopeMap.end()) {
2625 DbgScope *S = DI->second;
2626 dbgs() << S->getDFSIn();
2627 PrevDFSIn = S->getDFSIn();
2629 dbgs() << PrevDFSIn;
2631 dbgs() << " [ x" << PrevDFSIn;
2639 /// extractScopeInformation - Scan machine instructions in this function
2640 /// and collect DbgScopes. Return true, if at least one scope was found.
2641 bool DwarfDebug::extractScopeInformation() {
2642 // If scope information was extracted using .dbg intrinsics then there is not
2643 // any need to extract these information by scanning each instruction.
2644 if (!DbgScopeMap.empty())
2647 // Scan each instruction and create scopes. First build working set of scopes.
2648 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2649 SmallVector<DbgRange, 4> MIRanges;
2650 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2651 const MDNode *PrevScope = NULL;
2652 const MDNode *PrevInlinedAt = NULL;
2653 const MachineInstr *RangeBeginMI = NULL;
2654 const MachineInstr *PrevMI = NULL;
2655 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2657 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2659 const MachineInstr *MInsn = II;
2660 const MDNode *Scope = NULL;
2661 const MDNode *InlinedAt = NULL;
2663 // Check if instruction has valid location information.
2664 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2669 // If scope has not changed then skip this instruction.
2670 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2676 // If we have alread seen a beginning of a instruction range and
2677 // current instruction scope does not match scope of first instruction
2678 // in this range then create a new instruction range.
2679 DbgRange R(RangeBeginMI, PrevMI);
2680 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2682 MIRanges.push_back(R);
2685 // This is a beginning of a new instruction range.
2686 RangeBeginMI = MInsn;
2688 // Reset previous markers.
2691 PrevInlinedAt = InlinedAt;
2695 // Create last instruction range.
2696 if (RangeBeginMI && PrevMI && PrevScope) {
2697 DbgRange R(RangeBeginMI, PrevMI);
2698 MIRanges.push_back(R);
2699 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2702 if (!CurrentFnDbgScope)
2705 calculateDominanceGraph(CurrentFnDbgScope);
2707 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2709 // Find ranges of instructions covered by each DbgScope;
2710 DbgScope *PrevDbgScope = NULL;
2711 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2712 RE = MIRanges.end(); RI != RE; ++RI) {
2713 const DbgRange &R = *RI;
2714 DbgScope *S = MI2ScopeMap.lookup(R.first);
2715 assert (S && "Lost DbgScope for a machine instruction!");
2716 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2717 PrevDbgScope->closeInsnRange(S);
2718 S->openInsnRange(R.first);
2719 S->extendInsnRange(R.second);
2724 PrevDbgScope->closeInsnRange();
2726 identifyScopeMarkers();
2728 return !DbgScopeMap.empty();
2731 /// identifyScopeMarkers() -
2732 /// Each DbgScope has first instruction and last instruction to mark beginning
2733 /// and end of a scope respectively. Create an inverse map that list scopes
2734 /// starts (and ends) with an instruction. One instruction may start (or end)
2735 /// multiple scopes. Ignore scopes that are not reachable.
2736 void DwarfDebug::identifyScopeMarkers() {
2737 SmallVector<DbgScope *, 4> WorkList;
2738 WorkList.push_back(CurrentFnDbgScope);
2739 while (!WorkList.empty()) {
2740 DbgScope *S = WorkList.pop_back_val();
2742 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2743 if (!Children.empty())
2744 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2745 SE = Children.end(); SI != SE; ++SI)
2746 WorkList.push_back(*SI);
2748 if (S->isAbstractScope())
2751 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2754 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2755 RE = Ranges.end(); RI != RE; ++RI) {
2756 assert(RI->first && "DbgRange does not have first instruction!");
2757 assert(RI->second && "DbgRange does not have second instruction!");
2758 InsnsEndScopeSet.insert(RI->second);
2763 /// FindFirstDebugLoc - Find the first debug location in the function. This
2764 /// is intended to be an approximation for the source position of the
2765 /// beginning of the function.
2766 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2767 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2769 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2770 MBBI != MBBE; ++MBBI) {
2771 DebugLoc DL = MBBI->getDebugLoc();
2772 if (!DL.isUnknown())
2779 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2780 /// line number information.
2781 static void CheckLineNumbers(const MachineFunction *MF) {
2782 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2784 bool FoundLineNo = false;
2785 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2787 const MachineInstr *MI = II;
2788 if (!MI->getDebugLoc().isUnknown()) {
2794 ++BlocksWithoutLineNo;
2799 /// beginFunction - Gather pre-function debug information. Assumes being
2800 /// emitted immediately after the function entry point.
2801 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2802 if (!MMI->hasDebugInfo()) return;
2803 if (!extractScopeInformation()) return;
2806 CheckLineNumbers(MF);
2809 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2810 Asm->getFunctionNumber());
2811 // Assumes in correct section after the entry point.
2812 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2814 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2816 DebugLoc FDL = FindFirstDebugLoc(MF);
2817 if (FDL.isUnknown()) return;
2819 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2820 const MDNode *TheScope = 0;
2822 DISubprogram SP = getDISubprogram(Scope);
2825 Line = SP.getLineNumber();
2829 Line = FDL.getLine();
2834 recordSourceLine(Line, Col, TheScope);
2836 /// ProcessedArgs - Collection of arguments already processed.
2837 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2840 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2842 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2844 const MachineInstr *MI = II;
2845 DebugLoc DL = MI->getDebugLoc();
2846 if (MI->isDebugValue()) {
2847 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2848 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2849 if (!DV.Verify()) continue;
2850 // If DBG_VALUE is for a local variable then it needs a label.
2851 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2852 && isDbgValueInUndefinedReg(MI) == false)
2853 InsnNeedsLabel.insert(MI);
2854 // DBG_VALUE for inlined functions argument needs a label.
2855 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2856 describes(MF->getFunction()))
2857 InsnNeedsLabel.insert(MI);
2858 // DBG_VALUE indicating argument location change needs a label.
2859 else if (isDbgValueInUndefinedReg(MI) == false
2860 && !ProcessedArgs.insert(DV))
2861 InsnNeedsLabel.insert(MI);
2863 // If location is unknown then instruction needs a location only if
2864 // UnknownLocations flag is set.
2865 if (DL.isUnknown()) {
2866 if (UnknownLocations && !PrevLoc.isUnknown())
2867 InsnNeedsLabel.insert(MI);
2868 } else if (DL != PrevLoc)
2869 // Otherwise, instruction needs a location only if it is new location.
2870 InsnNeedsLabel.insert(MI);
2873 if (!DL.isUnknown() || UnknownLocations)
2877 PrevLabel = FunctionBeginSym;
2880 /// endFunction - Gather and emit post-function debug information.
2882 void DwarfDebug::endFunction(const MachineFunction *MF) {
2883 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2885 if (CurrentFnDbgScope) {
2887 // Define end label for subprogram.
2888 FunctionEndSym = Asm->GetTempSymbol("func_end",
2889 Asm->getFunctionNumber());
2890 // Assumes in correct section after the entry point.
2891 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2893 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2894 collectVariableInfo(MF, ProcessedVars);
2896 // Get function line info.
2897 if (!Lines.empty()) {
2898 // Get section line info.
2899 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2900 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2901 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2902 // Append the function info to section info.
2903 SectionLineInfos.insert(SectionLineInfos.end(),
2904 Lines.begin(), Lines.end());
2907 // Construct abstract scopes.
2908 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2909 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2910 DISubprogram SP((*AI)->getScopeNode());
2912 // Collect info for variables that were optimized out.
2913 StringRef FName = SP.getLinkageName();
2915 FName = SP.getName();
2916 const Module *M = MF->getFunction()->getParent();
2917 if (NamedMDNode *NMD =
2918 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2919 getRealLinkageName(FName)))) {
2920 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2921 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2922 if (!DV || !ProcessedVars.insert(DV))
2924 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2926 Scope->addVariable(new DbgVariable(DV));
2930 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2931 constructScopeDIE(*AI);
2934 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2936 if (!DisableFramePointerElim(*MF))
2937 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2938 dwarf::DW_FORM_flag, 1);
2941 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2942 MMI->getFrameMoves()));
2946 CurrentFnDbgScope = NULL;
2947 InsnNeedsLabel.clear();
2948 DbgVariableToFrameIndexMap.clear();
2949 VarToAbstractVarMap.clear();
2950 DbgVariableToDbgInstMap.clear();
2951 DbgVariableLabelsMap.clear();
2952 DeleteContainerSeconds(DbgScopeMap);
2953 InsnsEndScopeSet.clear();
2954 ConcreteScopes.clear();
2955 DeleteContainerSeconds(AbstractScopes);
2956 AbstractScopesList.clear();
2957 AbstractVariables.clear();
2958 LabelsBeforeInsn.clear();
2959 LabelsAfterInsn.clear();
2964 /// recordVariableFrameIndex - Record a variable's index.
2965 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2966 assert (V && "Invalid DbgVariable!");
2967 DbgVariableToFrameIndexMap[V] = Index;
2970 /// findVariableFrameIndex - Return true if frame index for the variable
2971 /// is found. Update FI to hold value of the index.
2972 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2973 assert (V && "Invalid DbgVariable!");
2974 DenseMap<const DbgVariable *, int>::iterator I =
2975 DbgVariableToFrameIndexMap.find(V);
2976 if (I == DbgVariableToFrameIndexMap.end())
2982 /// findVariableLabel - Find MCSymbol for the variable.
2983 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2984 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2985 = DbgVariableLabelsMap.find(V);
2986 if (I == DbgVariableLabelsMap.end())
2988 else return I->second;
2991 /// findDbgScope - Find DbgScope for the debug loc attached with an
2993 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2994 DbgScope *Scope = NULL;
2996 MInsn->getParent()->getParent()->getFunction()->getContext();
2997 DebugLoc DL = MInsn->getDebugLoc();
3002 if (const MDNode *IA = DL.getInlinedAt(Ctx))
3003 Scope = ConcreteScopes.lookup(IA);
3005 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
3011 /// recordSourceLine - Register a source line with debug info. Returns the
3012 /// unique label that was emitted and which provides correspondence to
3013 /// the source line list.
3014 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
3021 DIDescriptor Scope(S);
3023 if (Scope.isCompileUnit()) {
3024 DICompileUnit CU(S);
3025 Dir = CU.getDirectory();
3026 Fn = CU.getFilename();
3027 } else if (Scope.isSubprogram()) {
3029 Dir = SP.getDirectory();
3030 Fn = SP.getFilename();
3031 } else if (Scope.isLexicalBlock()) {
3032 DILexicalBlock DB(S);
3033 Dir = DB.getDirectory();
3034 Fn = DB.getFilename();
3036 assert(0 && "Unexpected scope info");
3038 Src = GetOrCreateSourceID(Dir, Fn);
3041 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
3042 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
3044 Asm->OutStreamer.EmitLabel(Label);
3048 //===----------------------------------------------------------------------===//
3050 //===----------------------------------------------------------------------===//
3052 /// computeSizeAndOffset - Compute the size and offset of a DIE.
3055 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
3056 // Get the children.
3057 const std::vector<DIE *> &Children = Die->getChildren();
3059 // If not last sibling and has children then add sibling offset attribute.
3060 if (!Last && !Children.empty())
3061 Die->addSiblingOffset(DIEValueAllocator);
3063 // Record the abbreviation.
3064 assignAbbrevNumber(Die->getAbbrev());
3066 // Get the abbreviation for this DIE.
3067 unsigned AbbrevNumber = Die->getAbbrevNumber();
3068 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3071 Die->setOffset(Offset);
3073 // Start the size with the size of abbreviation code.
3074 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3076 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3077 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3079 // Size the DIE attribute values.
3080 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3081 // Size attribute value.
3082 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3084 // Size the DIE children if any.
3085 if (!Children.empty()) {
3086 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3087 "Children flag not set");
3089 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3090 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3092 // End of children marker.
3093 Offset += sizeof(int8_t);
3096 Die->setSize(Offset - Die->getOffset());
3100 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3102 void DwarfDebug::computeSizeAndOffsets() {
3103 unsigned PrevOffset = 0;
3104 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3105 E = CUMap.end(); I != E; ++I) {
3106 // Compute size of compile unit header.
3107 static unsigned Offset = PrevOffset +
3108 sizeof(int32_t) + // Length of Compilation Unit Info
3109 sizeof(int16_t) + // DWARF version number
3110 sizeof(int32_t) + // Offset Into Abbrev. Section
3111 sizeof(int8_t); // Pointer Size (in bytes)
3112 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3113 PrevOffset = Offset;
3117 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3118 /// temporary label to it if SymbolStem is specified.
3119 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3120 const char *SymbolStem = 0) {
3121 Asm->OutStreamer.SwitchSection(Section);
3122 if (!SymbolStem) return 0;
3124 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3125 Asm->OutStreamer.EmitLabel(TmpSym);
3129 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3130 /// the start of each one.
3131 void DwarfDebug::EmitSectionLabels() {
3132 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3134 // Dwarf sections base addresses.
3135 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3136 DwarfFrameSectionSym =
3137 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3140 DwarfInfoSectionSym =
3141 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3142 DwarfAbbrevSectionSym =
3143 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3144 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3146 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3147 EmitSectionSym(Asm, MacroInfo);
3149 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3150 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3151 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3152 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3153 DwarfStrSectionSym =
3154 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3155 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3158 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3159 "section_debug_loc");
3161 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3162 EmitSectionSym(Asm, TLOF.getDataSection());
3165 /// emitDIE - Recusively Emits a debug information entry.
3167 void DwarfDebug::emitDIE(DIE *Die) {
3168 // Get the abbreviation for this DIE.
3169 unsigned AbbrevNumber = Die->getAbbrevNumber();
3170 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3172 // Emit the code (index) for the abbreviation.
3173 if (Asm->isVerbose())
3174 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3175 Twine::utohexstr(Die->getOffset()) + ":0x" +
3176 Twine::utohexstr(Die->getSize()) + " " +
3177 dwarf::TagString(Abbrev->getTag()));
3178 Asm->EmitULEB128(AbbrevNumber);
3180 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3181 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3183 // Emit the DIE attribute values.
3184 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3185 unsigned Attr = AbbrevData[i].getAttribute();
3186 unsigned Form = AbbrevData[i].getForm();
3187 assert(Form && "Too many attributes for DIE (check abbreviation)");
3189 if (Asm->isVerbose())
3190 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3193 case dwarf::DW_AT_sibling:
3194 Asm->EmitInt32(Die->getSiblingOffset());
3196 case dwarf::DW_AT_abstract_origin: {
3197 DIEEntry *E = cast<DIEEntry>(Values[i]);
3198 DIE *Origin = E->getEntry();
3199 unsigned Addr = Origin->getOffset();
3200 Asm->EmitInt32(Addr);
3203 case dwarf::DW_AT_ranges: {
3204 // DW_AT_range Value encodes offset in debug_range section.
3205 DIEInteger *V = cast<DIEInteger>(Values[i]);
3207 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3208 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3212 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3214 DwarfDebugRangeSectionSym,
3219 case dwarf::DW_AT_location: {
3220 if (UseDotDebugLocEntry.count(Die) != 0) {
3221 DIELabel *L = cast<DIELabel>(Values[i]);
3222 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3224 Values[i]->EmitValue(Asm, Form);
3227 case dwarf::DW_AT_accessibility: {
3228 if (Asm->isVerbose()) {
3229 DIEInteger *V = cast<DIEInteger>(Values[i]);
3230 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3232 Values[i]->EmitValue(Asm, Form);
3236 // Emit an attribute using the defined form.
3237 Values[i]->EmitValue(Asm, Form);
3242 // Emit the DIE children if any.
3243 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3244 const std::vector<DIE *> &Children = Die->getChildren();
3246 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3247 emitDIE(Children[j]);
3249 if (Asm->isVerbose())
3250 Asm->OutStreamer.AddComment("End Of Children Mark");
3255 /// emitDebugInfo - Emit the debug info section.
3257 void DwarfDebug::emitDebugInfo() {
3258 // Start debug info section.
3259 Asm->OutStreamer.SwitchSection(
3260 Asm->getObjFileLowering().getDwarfInfoSection());
3261 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3262 E = CUMap.end(); I != E; ++I) {
3263 CompileUnit *TheCU = I->second;
3264 DIE *Die = TheCU->getCUDie();
3266 // Emit the compile units header.
3267 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3270 // Emit size of content not including length itself
3271 unsigned ContentSize = Die->getSize() +
3272 sizeof(int16_t) + // DWARF version number
3273 sizeof(int32_t) + // Offset Into Abbrev. Section
3274 sizeof(int8_t) + // Pointer Size (in bytes)
3275 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3277 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3278 Asm->EmitInt32(ContentSize);
3279 Asm->OutStreamer.AddComment("DWARF version number");
3280 Asm->EmitInt16(dwarf::DWARF_VERSION);
3281 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3282 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3283 DwarfAbbrevSectionSym);
3284 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3285 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3288 // FIXME - extra padding for gdb bug.
3289 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3294 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3298 /// emitAbbreviations - Emit the abbreviation section.
3300 void DwarfDebug::emitAbbreviations() const {
3301 // Check to see if it is worth the effort.
3302 if (!Abbreviations.empty()) {
3303 // Start the debug abbrev section.
3304 Asm->OutStreamer.SwitchSection(
3305 Asm->getObjFileLowering().getDwarfAbbrevSection());
3307 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3309 // For each abbrevation.
3310 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3311 // Get abbreviation data
3312 const DIEAbbrev *Abbrev = Abbreviations[i];
3314 // Emit the abbrevations code (base 1 index.)
3315 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3317 // Emit the abbreviations data.
3321 // Mark end of abbreviations.
3322 Asm->EmitULEB128(0, "EOM(3)");
3324 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3328 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3329 /// the line matrix.
3331 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3332 // Define last address of section.
3333 Asm->OutStreamer.AddComment("Extended Op");
3336 Asm->OutStreamer.AddComment("Op size");
3337 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3338 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3339 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3341 Asm->OutStreamer.AddComment("Section end label");
3343 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3344 Asm->getTargetData().getPointerSize(),
3347 // Mark end of matrix.
3348 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3354 /// emitDebugLines - Emit source line information.
3356 void DwarfDebug::emitDebugLines() {
3357 // If the target is using .loc/.file, the assembler will be emitting the
3358 // .debug_line table automatically.
3359 if (Asm->MAI->hasDotLocAndDotFile())
3362 // Minimum line delta, thus ranging from -10..(255-10).
3363 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3364 // Maximum line delta, thus ranging from -10..(255-10).
3365 const int MaxLineDelta = 255 + MinLineDelta;
3367 // Start the dwarf line section.
3368 Asm->OutStreamer.SwitchSection(
3369 Asm->getObjFileLowering().getDwarfLineSection());
3371 // Construct the section header.
3372 Asm->OutStreamer.AddComment("Length of Source Line Info");
3373 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3374 Asm->GetTempSymbol("line_begin"), 4);
3375 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3377 Asm->OutStreamer.AddComment("DWARF version number");
3378 Asm->EmitInt16(dwarf::DWARF_VERSION);
3380 Asm->OutStreamer.AddComment("Prolog Length");
3381 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3382 Asm->GetTempSymbol("line_prolog_begin"), 4);
3383 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3385 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3387 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3389 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3390 Asm->EmitInt8(MinLineDelta);
3391 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3392 Asm->EmitInt8(MaxLineDelta);
3393 Asm->OutStreamer.AddComment("Special Opcode Base");
3394 Asm->EmitInt8(-MinLineDelta);
3396 // Line number standard opcode encodings argument count
3397 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3399 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3401 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3403 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3405 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3407 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3409 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3411 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3413 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3416 // Emit directories.
3417 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3418 const std::string &Dir = getSourceDirectoryName(DI);
3419 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3420 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3423 Asm->OutStreamer.AddComment("End of directories");
3427 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3428 // Remember source id starts at 1.
3429 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3430 const std::string &FN = getSourceFileName(Id.second);
3431 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3432 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3434 Asm->EmitULEB128(Id.first, "Directory #");
3435 Asm->EmitULEB128(0, "Mod date");
3436 Asm->EmitULEB128(0, "File size");
3439 Asm->OutStreamer.AddComment("End of files");
3442 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3444 // A sequence for each text section.
3445 unsigned SecSrcLinesSize = SectionSourceLines.size();
3447 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3448 // Isolate current sections line info.
3449 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3451 // Dwarf assumes we start with first line of first source file.
3452 unsigned Source = 1;
3455 // Construct rows of the address, source, line, column matrix.
3456 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3457 const SrcLineInfo &LineInfo = LineInfos[i];
3458 MCSymbol *Label = LineInfo.getLabel();
3459 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3461 if (Asm->isVerbose()) {
3462 std::pair<unsigned, unsigned> SrcID =
3463 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3464 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3466 Twine(getSourceFileName(SrcID.second)) +
3467 ":" + Twine(LineInfo.getLine()));
3470 // Define the line address.
3471 Asm->OutStreamer.AddComment("Extended Op");
3473 Asm->OutStreamer.AddComment("Op size");
3474 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3476 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3477 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3479 Asm->OutStreamer.AddComment("Location label");
3480 Asm->OutStreamer.EmitSymbolValue(Label,
3481 Asm->getTargetData().getPointerSize(),
3484 // If change of source, then switch to the new source.
3485 if (Source != LineInfo.getSourceID()) {
3486 Source = LineInfo.getSourceID();
3487 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3488 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3489 Asm->EmitULEB128(Source, "New Source");
3492 // If change of line.
3493 if (Line != LineInfo.getLine()) {
3494 // Determine offset.
3495 int Offset = LineInfo.getLine() - Line;
3496 int Delta = Offset - MinLineDelta;
3499 Line = LineInfo.getLine();
3501 // If delta is small enough and in range...
3502 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3503 // ... then use fast opcode.
3504 Asm->OutStreamer.AddComment("Line Delta");
3505 Asm->EmitInt8(Delta - MinLineDelta);
3507 // ... otherwise use long hand.
3508 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3509 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3510 Asm->EmitSLEB128(Offset, "Line Offset");
3511 Asm->OutStreamer.AddComment("DW_LNS_copy");
3512 Asm->EmitInt8(dwarf::DW_LNS_copy);
3515 // Copy the previous row (different address or source)
3516 Asm->OutStreamer.AddComment("DW_LNS_copy");
3517 Asm->EmitInt8(dwarf::DW_LNS_copy);
3521 emitEndOfLineMatrix(j + 1);
3524 if (SecSrcLinesSize == 0)
3525 // Because we're emitting a debug_line section, we still need a line
3526 // table. The linker and friends expect it to exist. If there's nothing to
3527 // put into it, emit an empty table.
3528 emitEndOfLineMatrix(1);
3530 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3533 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3535 void DwarfDebug::emitCommonDebugFrame() {
3536 if (!Asm->MAI->doesDwarfRequireFrameSection())
3539 int stackGrowth = Asm->getTargetData().getPointerSize();
3540 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3541 TargetFrameInfo::StackGrowsDown)
3544 // Start the dwarf frame section.
3545 Asm->OutStreamer.SwitchSection(
3546 Asm->getObjFileLowering().getDwarfFrameSection());
3548 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3549 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3550 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3551 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3553 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3554 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3555 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3556 Asm->OutStreamer.AddComment("CIE Version");
3557 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3558 Asm->OutStreamer.AddComment("CIE Augmentation");
3559 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3560 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3561 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3562 Asm->OutStreamer.AddComment("CIE RA Column");
3563 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3564 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3566 std::vector<MachineMove> Moves;
3567 RI->getInitialFrameState(Moves);
3569 Asm->EmitFrameMoves(Moves, 0, false);
3571 Asm->EmitAlignment(2);
3572 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3575 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3578 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3579 if (!Asm->MAI->doesDwarfRequireFrameSection())
3582 // Start the dwarf frame section.
3583 Asm->OutStreamer.SwitchSection(
3584 Asm->getObjFileLowering().getDwarfFrameSection());
3586 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3587 MCSymbol *DebugFrameBegin =
3588 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3589 MCSymbol *DebugFrameEnd =
3590 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3591 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3593 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3595 Asm->OutStreamer.AddComment("FDE CIE offset");
3596 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3597 DwarfFrameSectionSym);
3599 Asm->OutStreamer.AddComment("FDE initial location");
3600 MCSymbol *FuncBeginSym =
3601 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3602 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3603 Asm->getTargetData().getPointerSize(),
3607 Asm->OutStreamer.AddComment("FDE address range");
3608 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3609 FuncBeginSym, Asm->getTargetData().getPointerSize());
3611 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3613 Asm->EmitAlignment(2);
3614 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3617 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3619 void DwarfDebug::emitDebugPubNames() {
3620 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3621 E = CUMap.end(); I != E; ++I) {
3622 CompileUnit *TheCU = I->second;
3623 // Start the dwarf pubnames section.
3624 Asm->OutStreamer.SwitchSection(
3625 Asm->getObjFileLowering().getDwarfPubNamesSection());
3627 Asm->OutStreamer.AddComment("Length of Public Names Info");
3628 Asm->EmitLabelDifference(
3629 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3630 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3632 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3635 Asm->OutStreamer.AddComment("DWARF Version");
3636 Asm->EmitInt16(dwarf::DWARF_VERSION);
3638 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3639 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3640 DwarfInfoSectionSym);
3642 Asm->OutStreamer.AddComment("Compilation Unit Length");
3643 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3644 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3647 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3648 for (StringMap<DIE*>::const_iterator
3649 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3650 const char *Name = GI->getKeyData();
3651 DIE *Entity = GI->second;
3653 Asm->OutStreamer.AddComment("DIE offset");
3654 Asm->EmitInt32(Entity->getOffset());
3656 if (Asm->isVerbose())
3657 Asm->OutStreamer.AddComment("External Name");
3658 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3661 Asm->OutStreamer.AddComment("End Mark");
3663 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3668 void DwarfDebug::emitDebugPubTypes() {
3669 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3670 E = CUMap.end(); I != E; ++I) {
3671 CompileUnit *TheCU = I->second;
3672 // Start the dwarf pubnames section.
3673 Asm->OutStreamer.SwitchSection(
3674 Asm->getObjFileLowering().getDwarfPubTypesSection());
3675 Asm->OutStreamer.AddComment("Length of Public Types Info");
3676 Asm->EmitLabelDifference(
3677 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3678 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3680 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3683 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3684 Asm->EmitInt16(dwarf::DWARF_VERSION);
3686 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3687 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3688 DwarfInfoSectionSym);
3690 Asm->OutStreamer.AddComment("Compilation Unit Length");
3691 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3692 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3695 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3696 for (StringMap<DIE*>::const_iterator
3697 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3698 const char *Name = GI->getKeyData();
3699 DIE * Entity = GI->second;
3701 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3702 Asm->EmitInt32(Entity->getOffset());
3704 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3705 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3708 Asm->OutStreamer.AddComment("End Mark");
3710 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3715 /// emitDebugStr - Emit visible names into a debug str section.
3717 void DwarfDebug::emitDebugStr() {
3718 // Check to see if it is worth the effort.
3719 if (StringPool.empty()) return;
3721 // Start the dwarf str section.
3722 Asm->OutStreamer.SwitchSection(
3723 Asm->getObjFileLowering().getDwarfStrSection());
3725 // Get all of the string pool entries and put them in an array by their ID so
3726 // we can sort them.
3727 SmallVector<std::pair<unsigned,
3728 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3730 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3731 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3732 Entries.push_back(std::make_pair(I->second.second, &*I));
3734 array_pod_sort(Entries.begin(), Entries.end());
3736 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3737 // Emit a label for reference from debug information entries.
3738 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3740 // Emit the string itself.
3741 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3745 /// emitDebugLoc - Emit visible names into a debug loc section.
3747 void DwarfDebug::emitDebugLoc() {
3748 if (DotDebugLocEntries.empty())
3751 // Start the dwarf loc section.
3752 Asm->OutStreamer.SwitchSection(
3753 Asm->getObjFileLowering().getDwarfLocSection());
3754 unsigned char Size = Asm->getTargetData().getPointerSize();
3755 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3757 for (SmallVector<DotDebugLocEntry, 4>::iterator
3758 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3759 I != E; ++I, ++index) {
3760 DotDebugLocEntry Entry = *I;
3761 if (Entry.isEmpty()) {
3762 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3763 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3764 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3766 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3767 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3768 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3769 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3770 if (int Offset = Entry.Loc.getOffset()) {
3771 // If the value is at a certain offset from frame register then
3773 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3774 Asm->OutStreamer.AddComment("Loc expr size");
3775 Asm->EmitInt16(1 + OffsetSize);
3776 Asm->OutStreamer.AddComment(
3777 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3778 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3779 Asm->OutStreamer.AddComment("Offset");
3780 Asm->EmitSLEB128(Offset);
3783 Asm->OutStreamer.AddComment("Loc expr size");
3785 Asm->OutStreamer.AddComment(
3786 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3787 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3789 Asm->OutStreamer.AddComment("Loc expr size");
3790 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3791 Asm->EmitInt8(dwarf::DW_OP_regx);
3792 Asm->EmitULEB128(Reg);
3799 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3801 void DwarfDebug::EmitDebugARanges() {
3802 // Start the dwarf aranges section.
3803 Asm->OutStreamer.SwitchSection(
3804 Asm->getObjFileLowering().getDwarfARangesSection());
3807 /// emitDebugRanges - Emit visible names into a debug ranges section.
3809 void DwarfDebug::emitDebugRanges() {
3810 // Start the dwarf ranges section.
3811 Asm->OutStreamer.SwitchSection(
3812 Asm->getObjFileLowering().getDwarfRangesSection());
3813 unsigned char Size = Asm->getTargetData().getPointerSize();
3814 for (SmallVector<const MCSymbol *, 8>::iterator
3815 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3818 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3820 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3824 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3826 void DwarfDebug::emitDebugMacInfo() {
3827 if (const MCSection *LineInfo =
3828 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3829 // Start the dwarf macinfo section.
3830 Asm->OutStreamer.SwitchSection(LineInfo);
3834 /// emitDebugInlineInfo - Emit inline info using following format.
3836 /// 1. length of section
3837 /// 2. Dwarf version number
3838 /// 3. address size.
3840 /// Entries (one "entry" for each function that was inlined):
3842 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3843 /// otherwise offset into __debug_str for regular function name.
3844 /// 2. offset into __debug_str section for regular function name.
3845 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3846 /// instances for the function.
3848 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3849 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3850 /// __debug_info section, and the low_pc is the starting address for the
3851 /// inlining instance.
3852 void DwarfDebug::emitDebugInlineInfo() {
3853 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3859 Asm->OutStreamer.SwitchSection(
3860 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3862 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3863 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3864 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3866 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3868 Asm->OutStreamer.AddComment("Dwarf Version");
3869 Asm->EmitInt16(dwarf::DWARF_VERSION);
3870 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3871 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3873 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3874 E = InlinedSPNodes.end(); I != E; ++I) {
3876 const MDNode *Node = *I;
3877 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3878 = InlineInfo.find(Node);
3879 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3880 DISubprogram SP(Node);
3881 StringRef LName = SP.getLinkageName();
3882 StringRef Name = SP.getName();
3884 Asm->OutStreamer.AddComment("MIPS linkage name");
3885 if (LName.empty()) {
3886 Asm->OutStreamer.EmitBytes(Name, 0);
3887 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3889 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3890 DwarfStrSectionSym);
3892 Asm->OutStreamer.AddComment("Function name");
3893 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3894 Asm->EmitULEB128(Labels.size(), "Inline count");
3896 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3897 LE = Labels.end(); LI != LE; ++LI) {
3898 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3899 Asm->EmitInt32(LI->second->getOffset());
3901 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3902 Asm->OutStreamer.EmitSymbolValue(LI->first,
3903 Asm->getTargetData().getPointerSize(),0);
3907 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));