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/Support/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().getFilename());
518 assert(FileID && "Invalid file id");
519 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
520 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
523 /// addSourceLine - Add location information to specified debug information
525 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
526 // Verify global variable.
530 unsigned Line = G.getLineNumber();
533 unsigned FileID = GetOrCreateSourceID(G.getContext().getFilename());
534 assert(FileID && "Invalid file id");
535 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
536 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
539 /// addSourceLine - Add location information to specified debug information
541 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
542 // Verify subprogram.
545 // If the line number is 0, don't add it.
546 if (SP.getLineNumber() == 0)
549 unsigned Line = SP.getLineNumber();
550 if (!SP.getContext().Verify())
552 unsigned FileID = GetOrCreateSourceID(SP.getFilename());
553 assert(FileID && "Invalid file id");
554 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
555 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
558 /// addSourceLine - Add location information to specified debug information
560 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
565 unsigned Line = Ty.getLineNumber();
566 if (Line == 0 || !Ty.getContext().Verify())
568 unsigned FileID = GetOrCreateSourceID(Ty.getFilename());
569 assert(FileID && "Invalid file id");
570 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
571 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
574 /// addSourceLine - Add location information to specified debug information
576 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
581 unsigned Line = NS.getLineNumber();
584 StringRef FN = NS.getFilename();
586 unsigned FileID = GetOrCreateSourceID(FN);
587 assert(FileID && "Invalid file id");
588 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
589 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
592 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based
593 /// on provided frame index.
594 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) {
595 MachineLocation Location;
597 const TargetFrameInfo *TFI = Asm->TM.getFrameInfo();
598 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
599 Location.set(FrameReg, Offset);
601 if (DV->variableHasComplexAddress())
602 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
603 else if (DV->isBlockByrefVariable())
604 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
606 addAddress(Die, dwarf::DW_AT_location, Location);
609 /// addComplexAddress - Start with the address based on the location provided,
610 /// and generate the DWARF information necessary to find the actual variable
611 /// given the extra address information encoded in the DIVariable, starting from
612 /// the starting location. Add the DWARF information to the die.
614 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
616 const MachineLocation &Location) {
617 DIType Ty = DV->getType();
619 // Decode the original location, and use that as the start of the byref
620 // variable's location.
621 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
622 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
623 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
625 if (Location.isReg()) {
627 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
629 Reg = Reg - dwarf::DW_OP_reg0;
630 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
631 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
635 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
637 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
638 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
641 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
644 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
645 uint64_t Element = DV->getAddrElement(i);
647 if (Element == DIFactory::OpPlus) {
648 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
649 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
650 } else if (Element == DIFactory::OpDeref) {
651 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
652 } else llvm_unreachable("unknown DIFactory Opcode");
655 // Now attach the location information to the DIE.
656 addBlock(Die, Attribute, 0, Block);
659 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
660 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
661 gives the variable VarName either the struct, or a pointer to the struct, as
662 its type. This is necessary for various behind-the-scenes things the
663 compiler needs to do with by-reference variables in Blocks.
665 However, as far as the original *programmer* is concerned, the variable
666 should still have type 'SomeType', as originally declared.
668 The function getBlockByrefType dives into the __Block_byref_x_VarName
669 struct to find the original type of the variable, which is then assigned to
670 the variable's Debug Information Entry as its real type. So far, so good.
671 However now the debugger will expect the variable VarName to have the type
672 SomeType. So we need the location attribute for the variable to be an
673 expression that explains to the debugger how to navigate through the
674 pointers and struct to find the actual variable of type SomeType.
676 The following function does just that. We start by getting
677 the "normal" location for the variable. This will be the location
678 of either the struct __Block_byref_x_VarName or the pointer to the
679 struct __Block_byref_x_VarName.
681 The struct will look something like:
683 struct __Block_byref_x_VarName {
685 struct __Block_byref_x_VarName *forwarding;
686 ... <various other fields>
688 ... <maybe more fields>
691 If we are given the struct directly (as our starting point) we
692 need to tell the debugger to:
694 1). Add the offset of the forwarding field.
696 2). Follow that pointer to get the real __Block_byref_x_VarName
697 struct to use (the real one may have been copied onto the heap).
699 3). Add the offset for the field VarName, to find the actual variable.
701 If we started with a pointer to the struct, then we need to
702 dereference that pointer first, before the other steps.
703 Translating this into DWARF ops, we will need to append the following
704 to the current location description for the variable:
706 DW_OP_deref -- optional, if we start with a pointer
707 DW_OP_plus_uconst <forward_fld_offset>
709 DW_OP_plus_uconst <varName_fld_offset>
711 That is what this function does. */
713 /// addBlockByrefAddress - Start with the address based on the location
714 /// provided, and generate the DWARF information necessary to find the
715 /// actual Block variable (navigating the Block struct) based on the
716 /// starting location. Add the DWARF information to the die. For
717 /// more information, read large comment just above here.
719 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
721 const MachineLocation &Location) {
722 DIType Ty = DV->getType();
724 unsigned Tag = Ty.getTag();
725 bool isPointer = false;
727 StringRef varName = DV->getName();
729 if (Tag == dwarf::DW_TAG_pointer_type) {
730 DIDerivedType DTy = DIDerivedType(Ty);
731 TmpTy = DTy.getTypeDerivedFrom();
735 DICompositeType blockStruct = DICompositeType(TmpTy);
737 // Find the __forwarding field and the variable field in the __Block_byref
739 DIArray Fields = blockStruct.getTypeArray();
740 DIDescriptor varField = DIDescriptor();
741 DIDescriptor forwardingField = DIDescriptor();
743 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
744 DIDescriptor Element = Fields.getElement(i);
745 DIDerivedType DT = DIDerivedType(Element);
746 StringRef fieldName = DT.getName();
747 if (fieldName == "__forwarding")
748 forwardingField = Element;
749 else if (fieldName == varName)
753 // Get the offsets for the forwarding field and the variable field.
754 unsigned forwardingFieldOffset =
755 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
756 unsigned varFieldOffset =
757 DIDerivedType(varField).getOffsetInBits() >> 3;
759 // Decode the original location, and use that as the start of the byref
760 // variable's location.
761 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
762 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
763 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
765 if (Location.isReg()) {
767 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
769 Reg = Reg - dwarf::DW_OP_reg0;
770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
771 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
775 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
777 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
778 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
781 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
784 // If we started with a pointer to the __Block_byref... struct, then
785 // the first thing we need to do is dereference the pointer (DW_OP_deref).
787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
789 // Next add the offset for the '__forwarding' field:
790 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
791 // adding the offset if it's 0.
792 if (forwardingFieldOffset > 0) {
793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
794 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
797 // Now dereference the __forwarding field to get to the real __Block_byref
798 // struct: DW_OP_deref.
799 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
801 // Now that we've got the real __Block_byref... struct, add the offset
802 // for the variable's field to get to the location of the actual variable:
803 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
804 if (varFieldOffset > 0) {
805 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
806 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
809 // Now attach the location information to the DIE.
810 addBlock(Die, Attribute, 0, Block);
813 /// addAddress - Add an address attribute to a die based on the location
815 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
816 const MachineLocation &Location) {
817 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
818 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
819 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
821 if (RI->getFrameRegister(*Asm->MF) == Location.getReg()
822 && Location.getOffset()) {
823 // If variable offset is based in frame register then use fbreg.
824 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
825 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
826 addBlock(Die, Attribute, 0, Block);
830 if (Location.isReg()) {
832 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
834 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
835 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
839 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
841 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
842 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
845 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
848 addBlock(Die, Attribute, 0, Block);
851 /// addRegisterAddress - Add register location entry in variable DIE.
852 bool DwarfDebug::addRegisterAddress(DIE *Die, const MachineOperand &MO) {
853 assert (MO.isReg() && "Invalid machine operand!");
856 MachineLocation Location;
857 Location.set(MO.getReg());
858 addAddress(Die, dwarf::DW_AT_location, Location);
862 /// addConstantValue - Add constant value entry in variable DIE.
863 bool DwarfDebug::addConstantValue(DIE *Die, const MachineOperand &MO) {
864 assert (MO.isImm() && "Invalid machine operand!");
865 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
866 unsigned Imm = MO.getImm();
867 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
868 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
872 /// addConstantFPValue - Add constant value entry in variable DIE.
873 bool DwarfDebug::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
874 assert (MO.isFPImm() && "Invalid machine operand!");
875 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
876 APFloat FPImm = MO.getFPImm()->getValueAPF();
878 // Get the raw data form of the floating point.
879 const APInt FltVal = FPImm.bitcastToAPInt();
880 const char *FltPtr = (const char*)FltVal.getRawData();
882 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
883 bool LittleEndian = Asm->getTargetData().isLittleEndian();
884 int Incr = (LittleEndian ? 1 : -1);
885 int Start = (LittleEndian ? 0 : NumBytes - 1);
886 int Stop = (LittleEndian ? NumBytes : -1);
888 // Output the constant to DWARF one byte at a time.
889 for (; Start != Stop; Start += Incr)
890 addUInt(Block, 0, dwarf::DW_FORM_data1,
891 (unsigned char)0xFF & FltPtr[Start]);
893 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
897 /// addConstantValue - Add constant value entry in variable DIE.
898 bool DwarfDebug::addConstantValue(DIE *Die, ConstantInt *CI,
900 if (CI->getBitWidth() <= 64) {
902 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
905 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
910 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
912 // Get the raw data form of the large APInt.
913 const APInt Val = CI->getValue();
914 const char *Ptr = (const char*)Val.getRawData();
916 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
917 bool LittleEndian = Asm->getTargetData().isLittleEndian();
918 int Incr = (LittleEndian ? 1 : -1);
919 int Start = (LittleEndian ? 0 : NumBytes - 1);
920 int Stop = (LittleEndian ? NumBytes : -1);
922 // Output the constant to DWARF one byte at a time.
923 for (; Start != Stop; Start += Incr)
924 addUInt(Block, 0, dwarf::DW_FORM_data1,
925 (unsigned char)0xFF & Ptr[Start]);
927 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
931 /// addToContextOwner - Add Die into the list of its context owner's children.
932 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
933 if (Context.isType()) {
934 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
935 ContextDIE->addChild(Die);
936 } else if (Context.isNameSpace()) {
937 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
938 ContextDIE->addChild(Die);
939 } else if (Context.isSubprogram()) {
940 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context));
941 ContextDIE->addChild(Die);
942 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
943 ContextDIE->addChild(Die);
945 getCompileUnit(Context)->addDie(Die);
948 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
950 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
951 CompileUnit *TypeCU = getCompileUnit(Ty);
952 DIE *TyDIE = TypeCU->getDIE(Ty);
957 TyDIE = new DIE(dwarf::DW_TAG_base_type);
958 TypeCU->insertDIE(Ty, TyDIE);
959 if (Ty.isBasicType())
960 constructTypeDIE(*TyDIE, DIBasicType(Ty));
961 else if (Ty.isCompositeType())
962 constructTypeDIE(*TyDIE, DICompositeType(Ty));
964 assert(Ty.isDerivedType() && "Unknown kind of DIType");
965 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
968 addToContextOwner(TyDIE, Ty.getContext());
972 /// addType - Add a new type attribute to the specified entity.
973 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
977 // Check for pre-existence.
978 CompileUnit *TypeCU = getCompileUnit(Ty);
979 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
980 // If it exists then use the existing value.
982 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
987 DIE *Buffer = getOrCreateTypeDIE(Ty);
990 Entry = createDIEEntry(Buffer);
991 TypeCU->insertDIEEntry(Ty, Entry);
993 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
996 /// constructTypeDIE - Construct basic type die from DIBasicType.
997 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
998 // Get core information.
999 StringRef Name = BTy.getName();
1000 Buffer.setTag(dwarf::DW_TAG_base_type);
1001 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1004 // Add name if not anonymous or intermediate type.
1006 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1007 uint64_t Size = BTy.getSizeInBits() >> 3;
1008 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1011 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1012 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1013 // Get core information.
1014 StringRef Name = DTy.getName();
1015 uint64_t Size = DTy.getSizeInBits() >> 3;
1016 unsigned Tag = DTy.getTag();
1018 // FIXME - Workaround for templates.
1019 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
1023 // Map to main type, void will not have a type.
1024 DIType FromTy = DTy.getTypeDerivedFrom();
1025 addType(&Buffer, FromTy);
1027 // Add name if not anonymous or intermediate type.
1029 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1031 // Add size if non-zero (derived types might be zero-sized.)
1033 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1035 // Add source line info if available and TyDesc is not a forward declaration.
1036 if (!DTy.isForwardDecl())
1037 addSourceLine(&Buffer, DTy);
1040 /// constructTypeDIE - Construct type DIE from DICompositeType.
1041 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1042 // Get core information.
1043 StringRef Name = CTy.getName();
1045 uint64_t Size = CTy.getSizeInBits() >> 3;
1046 unsigned Tag = CTy.getTag();
1050 case dwarf::DW_TAG_vector_type:
1051 case dwarf::DW_TAG_array_type:
1052 constructArrayTypeDIE(Buffer, &CTy);
1054 case dwarf::DW_TAG_enumeration_type: {
1055 DIArray Elements = CTy.getTypeArray();
1057 // Add enumerators to enumeration type.
1058 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1059 DIE *ElemDie = NULL;
1060 DIDescriptor Enum(Elements.getElement(i));
1061 if (Enum.isEnumerator()) {
1062 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1063 Buffer.addChild(ElemDie);
1068 case dwarf::DW_TAG_subroutine_type: {
1070 DIArray Elements = CTy.getTypeArray();
1071 DIDescriptor RTy = Elements.getElement(0);
1072 addType(&Buffer, DIType(RTy));
1074 bool isPrototyped = true;
1076 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1077 DIDescriptor Ty = Elements.getElement(i);
1078 if (Ty.isUnspecifiedParameter()) {
1079 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1080 Buffer.addChild(Arg);
1081 isPrototyped = false;
1083 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1084 addType(Arg, DIType(Ty));
1085 Buffer.addChild(Arg);
1088 // Add prototype flag.
1090 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1093 case dwarf::DW_TAG_structure_type:
1094 case dwarf::DW_TAG_union_type:
1095 case dwarf::DW_TAG_class_type: {
1096 // Add elements to structure type.
1097 DIArray Elements = CTy.getTypeArray();
1099 // A forward struct declared type may not have elements available.
1100 unsigned N = Elements.getNumElements();
1104 // Add elements to structure type.
1105 for (unsigned i = 0; i < N; ++i) {
1106 DIDescriptor Element = Elements.getElement(i);
1107 DIE *ElemDie = NULL;
1108 if (Element.isSubprogram()) {
1109 DISubprogram SP(Element);
1110 ElemDie = createSubprogramDIE(DISubprogram(Element));
1111 if (SP.isProtected())
1112 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1113 dwarf::DW_ACCESS_protected);
1114 else if (SP.isPrivate())
1115 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1116 dwarf::DW_ACCESS_private);
1118 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1119 dwarf::DW_ACCESS_public);
1120 if (SP.isExplicit())
1121 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
1123 else if (Element.isVariable()) {
1124 DIVariable DV(Element);
1125 ElemDie = new DIE(dwarf::DW_TAG_variable);
1126 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1128 addType(ElemDie, DV.getType());
1129 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1130 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1131 addSourceLine(ElemDie, DV);
1132 } else if (Element.isDerivedType())
1133 ElemDie = createMemberDIE(DIDerivedType(Element));
1136 Buffer.addChild(ElemDie);
1139 if (CTy.isAppleBlockExtension())
1140 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1142 unsigned RLang = CTy.getRunTimeLang();
1144 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1145 dwarf::DW_FORM_data1, RLang);
1147 DICompositeType ContainingType = CTy.getContainingType();
1148 if (DIDescriptor(ContainingType).isCompositeType())
1149 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1150 getOrCreateTypeDIE(DIType(ContainingType)));
1152 DIDescriptor Context = CTy.getContext();
1153 addToContextOwner(&Buffer, Context);
1161 // Add name if not anonymous or intermediate type.
1163 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1165 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1166 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1168 // Add size if non-zero (derived types might be zero-sized.)
1170 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1172 // Add zero size if it is not a forward declaration.
1173 if (CTy.isForwardDecl())
1174 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1176 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1179 // Add source line info if available.
1180 if (!CTy.isForwardDecl())
1181 addSourceLine(&Buffer, CTy);
1185 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1186 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1187 int64_t L = SR.getLo();
1188 int64_t H = SR.getHi();
1189 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1191 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1193 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1194 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1196 Buffer.addChild(DW_Subrange);
1199 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1200 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1201 DICompositeType *CTy) {
1202 Buffer.setTag(dwarf::DW_TAG_array_type);
1203 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1204 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1206 // Emit derived type.
1207 addType(&Buffer, CTy->getTypeDerivedFrom());
1208 DIArray Elements = CTy->getTypeArray();
1210 // Get an anonymous type for index type.
1211 CompileUnit *TheCU = getCompileUnit(*CTy);
1212 DIE *IdxTy = TheCU->getIndexTyDie();
1214 // Construct an anonymous type for index type.
1215 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1216 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1217 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1218 dwarf::DW_ATE_signed);
1219 TheCU->addDie(IdxTy);
1220 TheCU->setIndexTyDie(IdxTy);
1223 // Add subranges to array type.
1224 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1225 DIDescriptor Element = Elements.getElement(i);
1226 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1227 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1231 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1232 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1233 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1234 StringRef Name = ETy.getName();
1235 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1236 int64_t Value = ETy.getEnumValue();
1237 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1241 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1242 /// printer to not emit usual symbol prefix before the symbol name is used then
1243 /// return linkage name after skipping this special LLVM prefix.
1244 static StringRef getRealLinkageName(StringRef LinkageName) {
1246 if (LinkageName.startswith(StringRef(&One, 1)))
1247 return LinkageName.substr(1);
1251 /// createMemberDIE - Create new member DIE.
1252 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1253 DIE *MemberDie = new DIE(DT.getTag());
1254 StringRef Name = DT.getName();
1256 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1258 addType(MemberDie, DT.getTypeDerivedFrom());
1260 addSourceLine(MemberDie, DT);
1262 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1263 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1265 uint64_t Size = DT.getSizeInBits();
1266 uint64_t FieldSize = DT.getOriginalTypeSize();
1268 if (Size != FieldSize) {
1270 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1271 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1273 uint64_t Offset = DT.getOffsetInBits();
1274 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1275 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1276 uint64_t FieldOffset = (HiMark - FieldSize);
1277 Offset -= FieldOffset;
1279 // Maybe we need to work from the other end.
1280 if (Asm->getTargetData().isLittleEndian())
1281 Offset = FieldSize - (Offset + Size);
1282 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1284 // Here WD_AT_data_member_location points to the anonymous
1285 // field that includes this bit field.
1286 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1289 // This is not a bitfield.
1290 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1292 if (DT.getTag() == dwarf::DW_TAG_inheritance
1293 && DT.isVirtual()) {
1295 // For C++, virtual base classes are not at fixed offset. Use following
1296 // expression to extract appropriate offset from vtable.
1297 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1299 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1300 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1301 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1302 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1303 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1304 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1305 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1306 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1308 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1311 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1313 if (DT.isProtected())
1314 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1315 dwarf::DW_ACCESS_protected);
1316 else if (DT.isPrivate())
1317 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1318 dwarf::DW_ACCESS_private);
1319 // Otherwise C++ member and base classes are considered public.
1320 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1321 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1322 dwarf::DW_ACCESS_public);
1324 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1325 dwarf::DW_VIRTUALITY_virtual);
1329 /// createSubprogramDIE - Create new DIE using SP.
1330 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
1331 CompileUnit *SPCU = getCompileUnit(SP);
1332 DIE *SPDie = SPCU->getDIE(SP);
1336 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1337 // Constructors and operators for anonymous aggregates do not have names.
1338 if (!SP.getName().empty())
1339 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1341 StringRef LinkageName = SP.getLinkageName();
1342 if (!LinkageName.empty())
1343 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1344 getRealLinkageName(LinkageName));
1346 addSourceLine(SPDie, SP);
1348 if (SP.isPrototyped())
1349 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1352 DICompositeType SPTy = SP.getType();
1353 DIArray Args = SPTy.getTypeArray();
1354 unsigned SPTag = SPTy.getTag();
1356 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1357 addType(SPDie, SPTy);
1359 addType(SPDie, DIType(Args.getElement(0)));
1361 unsigned VK = SP.getVirtuality();
1363 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1364 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1365 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1366 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1367 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1368 ContainingTypeMap.insert(std::make_pair(SPDie,
1369 SP.getContainingType()));
1372 if (!SP.isDefinition()) {
1373 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1375 // Add arguments. Do not add arguments for subprogram definition. They will
1376 // be handled while processing variables.
1377 DICompositeType SPTy = SP.getType();
1378 DIArray Args = SPTy.getTypeArray();
1379 unsigned SPTag = SPTy.getTag();
1381 if (SPTag == dwarf::DW_TAG_subroutine_type)
1382 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1383 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1384 DIType ATy = DIType(DIType(Args.getElement(i)));
1386 if (ATy.isArtificial())
1387 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1388 SPDie->addChild(Arg);
1392 if (SP.isArtificial())
1393 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1395 if (!SP.isLocalToUnit())
1396 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1398 if (SP.isOptimized())
1399 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1401 if (unsigned isa = Asm->getISAEncoding()) {
1402 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1405 // DW_TAG_inlined_subroutine may refer to this DIE.
1406 SPCU->insertDIE(SP, SPDie);
1408 // Add to context owner.
1409 addToContextOwner(SPDie, SP.getContext());
1414 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1415 assert(N && "Invalid Scope encoding!");
1417 DbgScope *AScope = AbstractScopes.lookup(N);
1421 DbgScope *Parent = NULL;
1423 DIDescriptor Scope(N);
1424 if (Scope.isLexicalBlock()) {
1425 DILexicalBlock DB(N);
1426 DIDescriptor ParentDesc = DB.getContext();
1427 Parent = getOrCreateAbstractScope(ParentDesc);
1430 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1433 Parent->addScope(AScope);
1434 AScope->setAbstractScope();
1435 AbstractScopes[N] = AScope;
1436 if (DIDescriptor(N).isSubprogram())
1437 AbstractScopesList.push_back(AScope);
1441 /// isSubprogramContext - Return true if Context is either a subprogram
1442 /// or another context nested inside a subprogram.
1443 static bool isSubprogramContext(const MDNode *Context) {
1446 DIDescriptor D(Context);
1447 if (D.isSubprogram())
1450 return isSubprogramContext(DIType(Context).getContext());
1454 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1455 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1456 /// If there are global variables in this scope then create and insert
1457 /// DIEs for these variables.
1458 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1459 CompileUnit *SPCU = getCompileUnit(SPNode);
1460 DIE *SPDie = SPCU->getDIE(SPNode);
1462 assert(SPDie && "Unable to find subprogram DIE!");
1463 DISubprogram SP(SPNode);
1465 // There is not any need to generate specification DIE for a function
1466 // defined at compile unit level. If a function is defined inside another
1467 // function then gdb prefers the definition at top level and but does not
1468 // expect specification DIE in parent function. So avoid creating
1469 // specification DIE for a function defined inside a function.
1470 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1471 !SP.getContext().isFile() &&
1472 !isSubprogramContext(SP.getContext())) {
1473 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1476 DICompositeType SPTy = SP.getType();
1477 DIArray Args = SPTy.getTypeArray();
1478 unsigned SPTag = SPTy.getTag();
1479 if (SPTag == dwarf::DW_TAG_subroutine_type)
1480 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1481 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1482 DIType ATy = DIType(DIType(Args.getElement(i)));
1484 if (ATy.isArtificial())
1485 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1486 SPDie->addChild(Arg);
1488 DIE *SPDeclDie = SPDie;
1489 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1490 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1492 SPCU->addDie(SPDie);
1495 // Pick up abstract subprogram DIE.
1496 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1497 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1498 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1499 dwarf::DW_FORM_ref4, AbsSPDIE);
1500 SPCU->addDie(SPDie);
1503 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1504 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1505 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1506 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1507 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1508 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1509 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1514 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1515 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1516 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1518 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1519 if (Scope->isAbstractScope())
1522 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1526 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1527 if (Ranges.size() > 1) {
1528 // .debug_range section has not been laid out yet. Emit offset in
1529 // .debug_range as a uint, size 4, for now. emitDIE will handle
1530 // DW_AT_ranges appropriately.
1531 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1532 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1533 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1534 RE = Ranges.end(); RI != RE; ++RI) {
1535 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1536 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1538 DebugRangeSymbols.push_back(NULL);
1539 DebugRangeSymbols.push_back(NULL);
1543 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1544 const MCSymbol *End = getLabelAfterInsn(RI->second);
1546 if (End == 0) return 0;
1548 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1549 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1551 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1552 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1557 /// constructInlinedScopeDIE - This scope represents inlined body of
1558 /// a function. Construct DIE to represent this concrete inlined copy
1559 /// of the function.
1560 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1562 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1563 assert (Ranges.empty() == false
1564 && "DbgScope does not have instruction markers!");
1566 // FIXME : .debug_inlined section specification does not clearly state how
1567 // to emit inlined scope that is split into multiple instruction ranges.
1568 // For now, use first instruction range and emit low_pc/high_pc pair and
1569 // corresponding .debug_inlined section entry for this pair.
1570 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1571 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1572 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1574 if (StartLabel == 0 || EndLabel == 0) {
1575 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1578 assert(StartLabel->isDefined() &&
1579 "Invalid starting label for an inlined scope!");
1580 assert(EndLabel->isDefined() &&
1581 "Invalid end label for an inlined scope!");
1583 if (!Scope->getScopeNode())
1585 DIScope DS(Scope->getScopeNode());
1586 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1588 DISubprogram InlinedSP = getDISubprogram(DS);
1589 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1590 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1591 assert(OriginDIE && "Unable to find Origin DIE!");
1592 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1593 dwarf::DW_FORM_ref4, OriginDIE);
1595 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1596 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1598 InlinedSubprogramDIEs.insert(OriginDIE);
1600 // Track the start label for this inlined function.
1601 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1602 I = InlineInfo.find(InlinedSP);
1604 if (I == InlineInfo.end()) {
1605 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1607 InlinedSPNodes.push_back(InlinedSP);
1609 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1611 DILocation DL(Scope->getInlinedAt());
1612 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1613 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1619 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1620 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1621 StringRef Name = DV->getName();
1625 // Translate tag to proper Dwarf tag. The result variable is dropped for
1628 switch (DV->getTag()) {
1629 case dwarf::DW_TAG_return_variable:
1631 case dwarf::DW_TAG_arg_variable:
1632 Tag = dwarf::DW_TAG_formal_parameter;
1634 case dwarf::DW_TAG_auto_variable: // fall thru
1636 Tag = dwarf::DW_TAG_variable;
1640 // Define variable debug information entry.
1641 DIE *VariableDie = new DIE(Tag);
1644 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1645 V2AVI = VarToAbstractVarMap.find(DV);
1646 if (V2AVI != VarToAbstractVarMap.end())
1647 AbsDIE = V2AVI->second->getDIE();
1650 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1651 dwarf::DW_FORM_ref4, AbsDIE);
1653 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1654 addSourceLine(VariableDie, DV->getVariable());
1656 // Add variable type.
1657 addType(VariableDie, DV->getType());
1660 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1661 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1662 else if (DIVariable(DV->getVariable()).isArtificial())
1663 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1665 if (Scope->isAbstractScope()) {
1666 DV->setDIE(VariableDie);
1670 // Add variable address.
1672 unsigned Offset = DV->getDotDebugLocOffset();
1673 if (Offset != ~0U) {
1674 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1675 Asm->GetTempSymbol("debug_loc", Offset));
1676 DV->setDIE(VariableDie);
1677 UseDotDebugLocEntry.insert(VariableDie);
1681 // Check if variable is described by a DBG_VALUE instruction.
1682 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1683 DbgVariableToDbgInstMap.find(DV);
1684 if (DVI != DbgVariableToDbgInstMap.end()) {
1685 const MachineInstr *DVInsn = DVI->second;
1686 bool updated = false;
1687 // FIXME : Handle getNumOperands != 3
1688 if (DVInsn->getNumOperands() == 3) {
1689 if (DVInsn->getOperand(0).isReg()) {
1690 const MachineOperand RegOp = DVInsn->getOperand(0);
1691 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1692 if (DVInsn->getOperand(1).isImm() &&
1693 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1694 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1697 updated = addRegisterAddress(VariableDie, RegOp);
1699 else if (DVInsn->getOperand(0).isImm())
1700 updated = addConstantValue(VariableDie, DVInsn->getOperand(0));
1701 else if (DVInsn->getOperand(0).isFPImm())
1703 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1705 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1706 if (Location.getReg()) {
1707 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1712 // If variableDie is not updated then DBG_VALUE instruction does not
1713 // have valid variable info.
1717 DV->setDIE(VariableDie);
1721 // .. else use frame index, if available.
1723 if (findVariableFrameIndex(DV, &FI))
1724 addVariableAddress(DV, VariableDie, FI);
1726 DV->setDIE(VariableDie);
1731 void DwarfDebug::addPubTypes(DISubprogram SP) {
1732 DICompositeType SPTy = SP.getType();
1733 unsigned SPTag = SPTy.getTag();
1734 if (SPTag != dwarf::DW_TAG_subroutine_type)
1737 DIArray Args = SPTy.getTypeArray();
1738 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1739 DIType ATy(Args.getElement(i));
1742 DICompositeType CATy = getDICompositeType(ATy);
1743 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1744 && !CATy.isForwardDecl()) {
1745 CompileUnit *TheCU = getCompileUnit(CATy);
1746 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1747 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1752 /// constructScopeDIE - Construct a DIE for this scope.
1753 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1754 if (!Scope || !Scope->getScopeNode())
1757 DIScope DS(Scope->getScopeNode());
1758 DIE *ScopeDIE = NULL;
1759 if (Scope->getInlinedAt())
1760 ScopeDIE = constructInlinedScopeDIE(Scope);
1761 else if (DS.isSubprogram()) {
1762 ProcessedSPNodes.insert(DS);
1763 if (Scope->isAbstractScope()) {
1764 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1765 // Note down abstract DIE.
1767 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1770 ScopeDIE = updateSubprogramScopeDIE(DS);
1773 ScopeDIE = constructLexicalScopeDIE(Scope);
1774 if (!ScopeDIE) return NULL;
1776 // Add variables to scope.
1777 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1778 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1779 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1781 ScopeDIE->addChild(VariableDIE);
1784 // Add nested scopes.
1785 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1786 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1787 // Define the Scope debug information entry.
1788 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1790 ScopeDIE->addChild(NestedDIE);
1793 if (DS.isSubprogram())
1794 addPubTypes(DISubprogram(DS));
1799 /// GetOrCreateSourceID - Look up the source id with the given directory and
1800 /// source file names. If none currently exists, create a new id and insert it
1801 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1804 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName){
1805 // If FE did not provide a file name, then assume stdin.
1806 if (FileName.empty())
1807 return GetOrCreateSourceID("<stdin>");
1809 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
1810 if (Entry.getValue())
1811 return Entry.getValue();
1813 unsigned SrcId = SourceIdMap.size();
1814 Entry.setValue(SrcId);
1816 // Print out a .file directive to specify files for .loc directives.
1817 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, FileName);
1822 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1823 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1824 CompileUnit *TheCU = getCompileUnit(NS);
1825 DIE *NDie = TheCU->getDIE(NS);
1828 NDie = new DIE(dwarf::DW_TAG_namespace);
1829 TheCU->insertDIE(NS, NDie);
1830 if (!NS.getName().empty())
1831 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1832 addSourceLine(NDie, NS);
1833 addToContextOwner(NDie, NS.getContext());
1837 /// constructCompileUnit - Create new CompileUnit for the given
1838 /// metadata node with tag DW_TAG_compile_unit.
1839 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1840 DICompileUnit DIUnit(N);
1841 StringRef FN = DIUnit.getFilename();
1842 StringRef Dir = DIUnit.getDirectory();
1843 unsigned ID = GetOrCreateSourceID(FN);
1845 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1846 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1847 DIUnit.getProducer());
1848 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1849 DIUnit.getLanguage());
1850 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1851 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1852 // simplifies debug range entries.
1853 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1854 // DW_AT_stmt_list is a offset of line number information for this
1855 // compile unit in debug_line section.
1856 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1857 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1858 Asm->GetTempSymbol("section_line"));
1860 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1863 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1864 if (DIUnit.isOptimized())
1865 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1867 StringRef Flags = DIUnit.getFlags();
1869 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1871 unsigned RVer = DIUnit.getRunTimeVersion();
1873 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1874 dwarf::DW_FORM_data1, RVer);
1876 CompileUnit *NewCU = new CompileUnit(ID, Die);
1879 CUMap.insert(std::make_pair(N, NewCU));
1882 /// getCompielUnit - Get CompileUnit DIE.
1883 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1884 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1886 const MDNode *CUNode = NULL;
1887 if (D.isCompileUnit())
1889 else if (D.isSubprogram())
1890 CUNode = DISubprogram(N).getCompileUnit();
1891 else if (D.isType())
1892 CUNode = DIType(N).getCompileUnit();
1893 else if (D.isGlobalVariable())
1894 CUNode = DIGlobalVariable(N).getCompileUnit();
1895 else if (D.isVariable())
1896 CUNode = DIVariable(N).getCompileUnit();
1897 else if (D.isNameSpace())
1898 CUNode = DINameSpace(N).getCompileUnit();
1899 else if (D.isFile())
1900 CUNode = DIFile(N).getCompileUnit();
1904 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1905 = CUMap.find(CUNode);
1906 if (I == CUMap.end())
1911 /// isUnsignedDIType - Return true if type encoding is unsigned.
1912 static bool isUnsignedDIType(DIType Ty) {
1913 DIDerivedType DTy(Ty);
1915 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1917 DIBasicType BTy(Ty);
1919 unsigned Encoding = BTy.getEncoding();
1920 if (Encoding == dwarf::DW_ATE_unsigned ||
1921 Encoding == dwarf::DW_ATE_unsigned_char)
1927 /// constructGlobalVariableDIE - Construct global variable DIE.
1928 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1929 DIGlobalVariable GV(N);
1931 // If debug information is malformed then ignore it.
1932 if (GV.Verify() == false)
1935 // Check for pre-existence.
1936 CompileUnit *TheCU = getCompileUnit(N);
1937 if (TheCU->getDIE(GV))
1940 DIType GTy = GV.getType();
1941 DIE *VariableDIE = new DIE(GV.getTag());
1943 bool isGlobalVariable = GV.getGlobal() != NULL;
1946 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1947 GV.getDisplayName());
1948 StringRef LinkageName = GV.getLinkageName();
1949 if (!LinkageName.empty() && isGlobalVariable)
1950 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1951 getRealLinkageName(LinkageName));
1953 addType(VariableDIE, GTy);
1954 if (GTy.isCompositeType() && !GTy.getName().empty()
1955 && !GTy.isForwardDecl()) {
1956 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1957 assert(Entry && "Missing global type!");
1958 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1960 // Add scoping info.
1961 if (!GV.isLocalToUnit()) {
1962 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1963 // Expose as global.
1964 TheCU->addGlobal(GV.getName(), VariableDIE);
1966 // Add line number info.
1967 addSourceLine(VariableDIE, GV);
1969 TheCU->insertDIE(N, VariableDIE);
1970 // Add to context owner.
1971 DIDescriptor GVContext = GV.getContext();
1972 addToContextOwner(VariableDIE, GVContext);
1974 if (isGlobalVariable) {
1975 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1976 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1977 addLabel(Block, 0, dwarf::DW_FORM_udata,
1978 Asm->Mang->getSymbol(GV.getGlobal()));
1979 // Do not create specification DIE if context is either compile unit
1981 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1982 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1983 // Create specification DIE.
1984 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1985 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1986 dwarf::DW_FORM_ref4, VariableDIE);
1987 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1988 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1989 TheCU->addDie(VariableSpecDIE);
1991 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1993 } else if (ConstantInt *CI =
1994 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1995 addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
2000 /// construct SubprogramDIE - Construct subprogram DIE.
2001 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2004 // Check for pre-existence.
2005 CompileUnit *TheCU = getCompileUnit(N);
2006 if (TheCU->getDIE(N))
2009 if (!SP.isDefinition())
2010 // This is a method declaration which will be handled while constructing
2014 DIE *SubprogramDie = createSubprogramDIE(SP);
2017 TheCU->insertDIE(N, SubprogramDie);
2019 // Add to context owner.
2020 addToContextOwner(SubprogramDie, SP.getContext());
2022 // Expose as global.
2023 TheCU->addGlobal(SP.getName(), SubprogramDie);
2028 /// beginModule - Emit all Dwarf sections that should come prior to the
2029 /// content. Create global DIEs and emit initial debug info sections.
2030 /// This is inovked by the target AsmPrinter.
2031 void DwarfDebug::beginModule(Module *M) {
2032 if (DisableDebugInfoPrinting)
2035 DebugInfoFinder DbgFinder;
2036 DbgFinder.processModule(*M);
2038 bool HasDebugInfo = false;
2040 // Scan all the compile-units to see if there are any marked as the main unit.
2041 // if not, we do not generate debug info.
2042 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2043 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2044 if (DICompileUnit(*I).isMain()) {
2045 HasDebugInfo = true;
2050 if (!HasDebugInfo) return;
2052 // Tell MMI that we have debug info.
2053 MMI->setDebugInfoAvailability(true);
2055 // Emit initial sections.
2056 EmitSectionLabels();
2058 // Create all the compile unit DIEs.
2059 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2060 E = DbgFinder.compile_unit_end(); I != E; ++I)
2061 constructCompileUnit(*I);
2063 // Create DIEs for each subprogram.
2064 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2065 E = DbgFinder.subprogram_end(); I != E; ++I)
2066 constructSubprogramDIE(*I);
2068 // Create DIEs for each global variable.
2069 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2070 E = DbgFinder.global_variable_end(); I != E; ++I)
2071 constructGlobalVariableDIE(*I);
2073 //getOrCreateTypeDIE
2074 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2075 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2076 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2078 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2079 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2080 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2082 // Prime section data.
2083 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2086 /// endModule - Emit all Dwarf sections that should come after the content.
2088 void DwarfDebug::endModule() {
2089 if (!FirstCU) return;
2090 const Module *M = MMI->getModule();
2091 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2092 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2093 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2094 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2095 DISubprogram SP(AllSPs->getOperand(SI));
2096 if (!SP.Verify()) continue;
2098 // Collect info for variables that were optimized out.
2099 if (!SP.isDefinition()) continue;
2100 StringRef FName = SP.getLinkageName();
2102 FName = SP.getName();
2103 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
2105 unsigned E = NMD->getNumOperands();
2107 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2108 DeadFnScopeMap[SP] = Scope;
2109 for (unsigned I = 0; I != E; ++I) {
2110 DIVariable DV(NMD->getOperand(I));
2111 if (!DV.Verify()) continue;
2112 Scope->addVariable(new DbgVariable(DV));
2115 // Construct subprogram DIE and add variables DIEs.
2116 constructSubprogramDIE(SP);
2117 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2118 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2119 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2120 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2122 ScopeDIE->addChild(VariableDIE);
2127 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2128 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2129 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2131 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2134 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2135 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2136 DIE *SPDie = CI->first;
2137 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2139 DIE *NDie = getCompileUnit(N)->getDIE(N);
2140 if (!NDie) continue;
2141 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2144 // Standard sections final addresses.
2145 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2146 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2147 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2148 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2150 // End text sections.
2151 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2152 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2153 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2156 // Emit common frame information.
2157 emitCommonDebugFrame();
2159 // Emit function debug frame information
2160 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2161 E = DebugFrames.end(); I != E; ++I)
2162 emitFunctionDebugFrame(*I);
2164 // Compute DIE offsets and sizes.
2165 computeSizeAndOffsets();
2167 // Emit all the DIEs into a debug info section
2170 // Corresponding abbreviations into a abbrev section.
2171 emitAbbreviations();
2173 // Emit info into a debug pubnames section.
2174 emitDebugPubNames();
2176 // Emit info into a debug pubtypes section.
2177 emitDebugPubTypes();
2179 // Emit info into a debug loc section.
2182 // Emit info into a debug aranges section.
2185 // Emit info into a debug ranges section.
2188 // Emit info into a debug macinfo section.
2191 // Emit inline info.
2192 emitDebugInlineInfo();
2194 // Emit info into a debug str section.
2198 DeleteContainerSeconds(DeadFnScopeMap);
2199 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2200 E = CUMap.end(); I != E; ++I)
2202 FirstCU = NULL; // Reset for the next Module, if any.
2205 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2206 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2207 DebugLoc ScopeLoc) {
2209 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2211 return AbsDbgVariable;
2213 LLVMContext &Ctx = Var->getContext();
2214 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2218 AbsDbgVariable = new DbgVariable(Var);
2219 Scope->addVariable(AbsDbgVariable);
2220 AbstractVariables[Var] = AbsDbgVariable;
2221 return AbsDbgVariable;
2224 /// collectVariableInfoFromMMITable - Collect variable information from
2225 /// side table maintained by MMI.
2227 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2228 SmallPtrSet<const MDNode *, 16> &Processed) {
2229 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2230 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2231 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2232 VE = VMap.end(); VI != VE; ++VI) {
2233 const MDNode *Var = VI->first;
2235 Processed.insert(Var);
2237 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2239 DbgScope *Scope = 0;
2240 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2241 Scope = ConcreteScopes.lookup(IA);
2243 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2245 // If variable scope is not found then skip this variable.
2249 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2250 DbgVariable *RegVar = new DbgVariable(DV);
2251 recordVariableFrameIndex(RegVar, VP.first);
2252 Scope->addVariable(RegVar);
2253 if (AbsDbgVariable) {
2254 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2255 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2260 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2261 /// DBG_VALUE instruction, is in a defined reg.
2262 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2263 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2264 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2269 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2271 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2272 SmallPtrSet<const MDNode *, 16> &Processed) {
2274 /// collection info from MMI table.
2275 collectVariableInfoFromMMITable(MF, Processed);
2277 SmallVector<const MachineInstr *, 8> DbgValues;
2278 // Collect variable information from DBG_VALUE machine instructions;
2279 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2281 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2283 const MachineInstr *MInsn = II;
2284 if (!MInsn->isDebugValue())
2286 DbgValues.push_back(MInsn);
2289 // This is a collection of DBV_VALUE instructions describing same variable.
2290 SmallVector<const MachineInstr *, 4> MultipleValues;
2291 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2292 E = DbgValues.end(); I != E; ++I) {
2293 const MachineInstr *MInsn = *I;
2294 MultipleValues.clear();
2295 if (isDbgValueInDefinedReg(MInsn))
2296 MultipleValues.push_back(MInsn);
2297 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2298 if (Processed.count(DV) != 0)
2301 const MachineInstr *PrevMI = MInsn;
2302 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2303 ME = DbgValues.end(); MI != ME; ++MI) {
2305 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2307 !PrevMI->isIdenticalTo(*MI))
2308 MultipleValues.push_back(*MI);
2312 DbgScope *Scope = NULL;
2313 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2314 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2315 Scope = CurrentFnDbgScope;
2317 Scope = findDbgScope(MInsn);
2318 // If variable scope is not found then skip this variable.
2322 Processed.insert(DV);
2323 DbgVariable *RegVar = new DbgVariable(DV);
2324 Scope->addVariable(RegVar);
2325 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2326 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2327 VarToAbstractVarMap[RegVar] = AbsVar;
2329 if (MultipleValues.size() <= 1) {
2330 DbgVariableToDbgInstMap[RegVar] = MInsn;
2334 // handle multiple DBG_VALUE instructions describing one variable.
2335 if (DotDebugLocEntries.empty())
2336 RegVar->setDotDebugLocOffset(0);
2338 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2339 const MachineInstr *Begin = NULL;
2340 const MachineInstr *End = NULL;
2341 for (SmallVector<const MachineInstr *, 4>::iterator
2342 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2343 MVI != MVE; ++MVI) {
2349 MachineLocation MLoc;
2350 if (Begin->getNumOperands() == 3) {
2351 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2352 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2354 MLoc = Asm->getDebugValueLocation(Begin);
2356 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2357 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2359 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2362 if (MVI + 1 == MVE) {
2363 // If End is the last instruction then its value is valid
2364 // until the end of the funtion.
2365 MachineLocation EMLoc;
2366 if (End->getNumOperands() == 3) {
2367 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2368 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2370 EMLoc = Asm->getDebugValueLocation(End);
2373 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2376 DotDebugLocEntries.push_back(DotDebugLocEntry());
2379 // Collect info for variables that were optimized out.
2380 const Function *F = MF->getFunction();
2381 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
2382 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2383 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2384 if (!DV || !Processed.insert(DV))
2386 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2388 Scope->addVariable(new DbgVariable(DV));
2393 /// getLabelBeforeInsn - Return Label preceding the instruction.
2394 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2395 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2396 LabelsBeforeInsn.find(MI);
2397 if (I == LabelsBeforeInsn.end())
2398 // FunctionBeginSym always preceeds all the instruction in current function.
2399 return FunctionBeginSym;
2403 /// getLabelAfterInsn - Return Label immediately following the instruction.
2404 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2405 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2406 LabelsAfterInsn.find(MI);
2407 if (I == LabelsAfterInsn.end())
2412 /// beginInstruction - Process beginning of an instruction.
2413 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
2414 if (InsnNeedsLabel.count(MI) == 0) {
2415 LabelsBeforeInsn[MI] = PrevLabel;
2420 DebugLoc DL = MI->getDebugLoc();
2421 if (!DL.isUnknown()) {
2422 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2423 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2425 LabelsBeforeInsn[MI] = PrevLabel;
2429 // If location is unknown then use temp label for this DBG_VALUE
2431 if (MI->isDebugValue()) {
2432 PrevLabel = MMI->getContext().CreateTempSymbol();
2433 Asm->OutStreamer.EmitLabel(PrevLabel);
2434 LabelsBeforeInsn[MI] = PrevLabel;
2438 if (UnknownLocations) {
2439 PrevLabel = recordSourceLine(0, 0, 0);
2440 LabelsBeforeInsn[MI] = PrevLabel;
2444 assert (0 && "Instruction is not processed!");
2447 /// endInstruction - Process end of an instruction.
2448 void DwarfDebug::endInstruction(const MachineInstr *MI) {
2449 if (InsnsEndScopeSet.count(MI) != 0) {
2450 // Emit a label if this instruction ends a scope.
2451 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2452 Asm->OutStreamer.EmitLabel(Label);
2453 LabelsAfterInsn[MI] = Label;
2457 /// getOrCreateDbgScope - Create DbgScope for the scope.
2458 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2459 const MDNode *InlinedAt) {
2461 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2464 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2465 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2466 if (DIDescriptor(Scope).isLexicalBlock()) {
2468 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2469 WScope->setParent(Parent);
2470 Parent->addScope(WScope);
2473 if (!WScope->getParent()) {
2474 StringRef SPName = DISubprogram(Scope).getLinkageName();
2475 // We used to check only for a linkage name, but that fails
2476 // since we began omitting the linkage name for private
2477 // functions. The new way is to check for the name in metadata,
2478 // but that's not supported in old .ll test cases. Ergo, we
2480 if (SPName == Asm->MF->getFunction()->getName() ||
2481 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2482 CurrentFnDbgScope = WScope;
2488 getOrCreateAbstractScope(Scope);
2489 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2493 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2494 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2495 DILocation DL(InlinedAt);
2497 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2498 WScope->setParent(Parent);
2499 Parent->addScope(WScope);
2501 ConcreteScopes[InlinedAt] = WScope;
2506 /// hasValidLocation - Return true if debug location entry attached with
2507 /// machine instruction encodes valid location info.
2508 static bool hasValidLocation(LLVMContext &Ctx,
2509 const MachineInstr *MInsn,
2510 const MDNode *&Scope, const MDNode *&InlinedAt) {
2511 DebugLoc DL = MInsn->getDebugLoc();
2512 if (DL.isUnknown()) return false;
2514 const MDNode *S = DL.getScope(Ctx);
2516 // There is no need to create another DIE for compile unit. For all
2517 // other scopes, create one DbgScope now. This will be translated
2518 // into a scope DIE at the end.
2519 if (DIScope(S).isCompileUnit()) return false;
2522 InlinedAt = DL.getInlinedAt(Ctx);
2526 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2528 static void calculateDominanceGraph(DbgScope *Scope) {
2529 assert (Scope && "Unable to calculate scop edominance graph!");
2530 SmallVector<DbgScope *, 4> WorkStack;
2531 WorkStack.push_back(Scope);
2532 unsigned Counter = 0;
2533 while (!WorkStack.empty()) {
2534 DbgScope *WS = WorkStack.back();
2535 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2536 bool visitedChildren = false;
2537 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2538 SE = Children.end(); SI != SE; ++SI) {
2539 DbgScope *ChildScope = *SI;
2540 if (!ChildScope->getDFSOut()) {
2541 WorkStack.push_back(ChildScope);
2542 visitedChildren = true;
2543 ChildScope->setDFSIn(++Counter);
2547 if (!visitedChildren) {
2548 WorkStack.pop_back();
2549 WS->setDFSOut(++Counter);
2554 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2556 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2557 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2560 unsigned PrevDFSIn = 0;
2561 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2563 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2565 const MachineInstr *MInsn = II;
2566 const MDNode *Scope = NULL;
2567 const MDNode *InlinedAt = NULL;
2569 // Check if instruction has valid location information.
2570 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2574 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2575 MI2ScopeMap.find(MInsn);
2576 if (DI != MI2ScopeMap.end()) {
2577 DbgScope *S = DI->second;
2578 dbgs() << S->getDFSIn();
2579 PrevDFSIn = S->getDFSIn();
2581 dbgs() << PrevDFSIn;
2583 dbgs() << " [ x" << PrevDFSIn;
2591 /// extractScopeInformation - Scan machine instructions in this function
2592 /// and collect DbgScopes. Return true, if at least one scope was found.
2593 bool DwarfDebug::extractScopeInformation() {
2594 // If scope information was extracted using .dbg intrinsics then there is not
2595 // any need to extract these information by scanning each instruction.
2596 if (!DbgScopeMap.empty())
2599 // Scan each instruction and create scopes. First build working set of scopes.
2600 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2601 SmallVector<DbgRange, 4> MIRanges;
2602 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2603 const MDNode *PrevScope = NULL;
2604 const MDNode *PrevInlinedAt = NULL;
2605 const MachineInstr *RangeBeginMI = NULL;
2606 const MachineInstr *PrevMI = NULL;
2607 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2609 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2611 const MachineInstr *MInsn = II;
2612 const MDNode *Scope = NULL;
2613 const MDNode *InlinedAt = NULL;
2615 // Check if instruction has valid location information.
2616 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2621 // If scope has not changed then skip this instruction.
2622 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2628 // If we have alread seen a beginning of a instruction range and
2629 // current instruction scope does not match scope of first instruction
2630 // in this range then create a new instruction range.
2631 DbgRange R(RangeBeginMI, PrevMI);
2632 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2634 MIRanges.push_back(R);
2637 // This is a beginning of a new instruction range.
2638 RangeBeginMI = MInsn;
2640 // Reset previous markers.
2643 PrevInlinedAt = InlinedAt;
2647 // Create last instruction range.
2648 if (RangeBeginMI && PrevMI && PrevScope) {
2649 DbgRange R(RangeBeginMI, PrevMI);
2650 MIRanges.push_back(R);
2651 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2654 if (!CurrentFnDbgScope)
2657 calculateDominanceGraph(CurrentFnDbgScope);
2659 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2661 // Find ranges of instructions covered by each DbgScope;
2662 DbgScope *PrevDbgScope = NULL;
2663 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2664 RE = MIRanges.end(); RI != RE; ++RI) {
2665 const DbgRange &R = *RI;
2666 DbgScope *S = MI2ScopeMap.lookup(R.first);
2667 assert (S && "Lost DbgScope for a machine instruction!");
2668 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2669 PrevDbgScope->closeInsnRange(S);
2670 S->openInsnRange(R.first);
2671 S->extendInsnRange(R.second);
2676 PrevDbgScope->closeInsnRange();
2678 identifyScopeMarkers();
2680 return !DbgScopeMap.empty();
2683 /// identifyScopeMarkers() -
2684 /// Each DbgScope has first instruction and last instruction to mark beginning
2685 /// and end of a scope respectively. Create an inverse map that list scopes
2686 /// starts (and ends) with an instruction. One instruction may start (or end)
2687 /// multiple scopes. Ignore scopes that are not reachable.
2688 void DwarfDebug::identifyScopeMarkers() {
2689 SmallVector<DbgScope *, 4> WorkList;
2690 WorkList.push_back(CurrentFnDbgScope);
2691 while (!WorkList.empty()) {
2692 DbgScope *S = WorkList.pop_back_val();
2694 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2695 if (!Children.empty())
2696 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2697 SE = Children.end(); SI != SE; ++SI)
2698 WorkList.push_back(*SI);
2700 if (S->isAbstractScope())
2703 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2706 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2707 RE = Ranges.end(); RI != RE; ++RI) {
2708 assert(RI->first && "DbgRange does not have first instruction!");
2709 assert(RI->second && "DbgRange does not have second instruction!");
2710 InsnsEndScopeSet.insert(RI->second);
2715 /// FindFirstDebugLoc - Find the first debug location in the function. This
2716 /// is intended to be an approximation for the source position of the
2717 /// beginning of the function.
2718 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2719 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2721 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2722 MBBI != MBBE; ++MBBI) {
2723 DebugLoc DL = MBBI->getDebugLoc();
2724 if (!DL.isUnknown())
2731 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2732 /// line number information.
2733 static void CheckLineNumbers(const MachineFunction *MF) {
2734 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2736 bool FoundLineNo = false;
2737 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2739 const MachineInstr *MI = II;
2740 if (!MI->getDebugLoc().isUnknown()) {
2745 if (!FoundLineNo && I->size())
2746 ++BlocksWithoutLineNo;
2751 /// beginFunction - Gather pre-function debug information. Assumes being
2752 /// emitted immediately after the function entry point.
2753 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2754 if (!MMI->hasDebugInfo()) return;
2755 if (!extractScopeInformation()) return;
2758 CheckLineNumbers(MF);
2761 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2762 Asm->getFunctionNumber());
2763 // Assumes in correct section after the entry point.
2764 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2766 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2768 DebugLoc FDL = FindFirstDebugLoc(MF);
2769 if (FDL.isUnknown()) return;
2771 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2772 const MDNode *TheScope = 0;
2774 DISubprogram SP = getDISubprogram(Scope);
2777 Line = SP.getLineNumber();
2781 Line = FDL.getLine();
2786 recordSourceLine(Line, Col, TheScope);
2788 /// ProcessedArgs - Collection of arguments already processed.
2789 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2792 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2794 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2796 const MachineInstr *MI = II;
2797 DebugLoc DL = MI->getDebugLoc();
2798 if (MI->isDebugValue()) {
2799 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2800 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2801 if (!DV.Verify()) continue;
2802 // If DBG_VALUE is for a local variable then it needs a label.
2803 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2804 InsnNeedsLabel.insert(MI);
2805 // DBG_VALUE for inlined functions argument needs a label.
2806 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2807 describes(MF->getFunction()))
2808 InsnNeedsLabel.insert(MI);
2809 // DBG_VALUE indicating argument location change needs a label.
2810 else if (!ProcessedArgs.insert(DV))
2811 InsnNeedsLabel.insert(MI);
2813 // If location is unknown then instruction needs a location only if
2814 // UnknownLocations flag is set.
2815 if (DL.isUnknown()) {
2816 if (UnknownLocations && !PrevLoc.isUnknown())
2817 InsnNeedsLabel.insert(MI);
2818 } else if (DL != PrevLoc)
2819 // Otherwise, instruction needs a location only if it is new location.
2820 InsnNeedsLabel.insert(MI);
2823 if (!DL.isUnknown() || UnknownLocations)
2827 PrevLabel = FunctionBeginSym;
2830 /// endFunction - Gather and emit post-function debug information.
2832 void DwarfDebug::endFunction(const MachineFunction *MF) {
2833 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2835 if (CurrentFnDbgScope) {
2837 // Define end label for subprogram.
2838 FunctionEndSym = Asm->GetTempSymbol("func_end",
2839 Asm->getFunctionNumber());
2840 // Assumes in correct section after the entry point.
2841 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2843 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2844 collectVariableInfo(MF, ProcessedVars);
2846 // Construct abstract scopes.
2847 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2848 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2849 DISubprogram SP((*AI)->getScopeNode());
2851 // Collect info for variables that were optimized out.
2852 StringRef FName = SP.getLinkageName();
2854 FName = SP.getName();
2855 if (NamedMDNode *NMD =
2856 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2857 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2858 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2859 if (!DV || !ProcessedVars.insert(DV))
2861 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2863 Scope->addVariable(new DbgVariable(DV));
2867 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2868 constructScopeDIE(*AI);
2871 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2873 if (!DisableFramePointerElim(*MF))
2874 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2875 dwarf::DW_FORM_flag, 1);
2878 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2879 MMI->getFrameMoves()));
2883 CurrentFnDbgScope = NULL;
2884 InsnNeedsLabel.clear();
2885 DbgVariableToFrameIndexMap.clear();
2886 VarToAbstractVarMap.clear();
2887 DbgVariableToDbgInstMap.clear();
2888 DeleteContainerSeconds(DbgScopeMap);
2889 InsnsEndScopeSet.clear();
2890 ConcreteScopes.clear();
2891 DeleteContainerSeconds(AbstractScopes);
2892 AbstractScopesList.clear();
2893 AbstractVariables.clear();
2894 LabelsBeforeInsn.clear();
2895 LabelsAfterInsn.clear();
2899 /// recordVariableFrameIndex - Record a variable's index.
2900 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2901 assert (V && "Invalid DbgVariable!");
2902 DbgVariableToFrameIndexMap[V] = Index;
2905 /// findVariableFrameIndex - Return true if frame index for the variable
2906 /// is found. Update FI to hold value of the index.
2907 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2908 assert (V && "Invalid DbgVariable!");
2909 DenseMap<const DbgVariable *, int>::iterator I =
2910 DbgVariableToFrameIndexMap.find(V);
2911 if (I == DbgVariableToFrameIndexMap.end())
2917 /// findDbgScope - Find DbgScope for the debug loc attached with an
2919 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2920 DbgScope *Scope = NULL;
2922 MInsn->getParent()->getParent()->getFunction()->getContext();
2923 DebugLoc DL = MInsn->getDebugLoc();
2928 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2929 Scope = ConcreteScopes.lookup(IA);
2931 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2937 /// recordSourceLine - Register a source line with debug info. Returns the
2938 /// unique label that was emitted and which provides correspondence to
2939 /// the source line list.
2940 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2946 DIDescriptor Scope(S);
2948 if (Scope.isCompileUnit()) {
2949 DICompileUnit CU(S);
2950 Fn = CU.getFilename();
2951 } else if (Scope.isFile()) {
2953 Fn = F.getFilename();
2954 } else if (Scope.isSubprogram()) {
2956 Fn = SP.getFilename();
2957 } else if (Scope.isLexicalBlock()) {
2958 DILexicalBlock DB(S);
2959 Fn = DB.getFilename();
2961 assert(0 && "Unexpected scope info");
2963 Src = GetOrCreateSourceID(Fn);
2966 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
2969 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2970 Asm->OutStreamer.EmitLabel(Label);
2974 //===----------------------------------------------------------------------===//
2976 //===----------------------------------------------------------------------===//
2978 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2981 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2982 // Get the children.
2983 const std::vector<DIE *> &Children = Die->getChildren();
2985 // If not last sibling and has children then add sibling offset attribute.
2986 if (!Last && !Children.empty())
2987 Die->addSiblingOffset(DIEValueAllocator);
2989 // Record the abbreviation.
2990 assignAbbrevNumber(Die->getAbbrev());
2992 // Get the abbreviation for this DIE.
2993 unsigned AbbrevNumber = Die->getAbbrevNumber();
2994 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2997 Die->setOffset(Offset);
2999 // Start the size with the size of abbreviation code.
3000 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3002 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3003 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3005 // Size the DIE attribute values.
3006 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3007 // Size attribute value.
3008 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3010 // Size the DIE children if any.
3011 if (!Children.empty()) {
3012 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3013 "Children flag not set");
3015 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3016 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3018 // End of children marker.
3019 Offset += sizeof(int8_t);
3022 Die->setSize(Offset - Die->getOffset());
3026 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3028 void DwarfDebug::computeSizeAndOffsets() {
3029 unsigned PrevOffset = 0;
3030 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3031 E = CUMap.end(); I != E; ++I) {
3032 // Compute size of compile unit header.
3033 static unsigned Offset = PrevOffset +
3034 sizeof(int32_t) + // Length of Compilation Unit Info
3035 sizeof(int16_t) + // DWARF version number
3036 sizeof(int32_t) + // Offset Into Abbrev. Section
3037 sizeof(int8_t); // Pointer Size (in bytes)
3038 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3039 PrevOffset = Offset;
3043 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3044 /// temporary label to it if SymbolStem is specified.
3045 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3046 const char *SymbolStem = 0) {
3047 Asm->OutStreamer.SwitchSection(Section);
3048 if (!SymbolStem) return 0;
3050 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3051 Asm->OutStreamer.EmitLabel(TmpSym);
3055 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3056 /// the start of each one.
3057 void DwarfDebug::EmitSectionLabels() {
3058 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3060 // Dwarf sections base addresses.
3061 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3062 DwarfFrameSectionSym =
3063 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3066 DwarfInfoSectionSym =
3067 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3068 DwarfAbbrevSectionSym =
3069 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3070 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3072 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3073 EmitSectionSym(Asm, MacroInfo);
3075 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3076 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3077 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3078 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3079 DwarfStrSectionSym =
3080 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3081 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3084 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3085 "section_debug_loc");
3087 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3088 EmitSectionSym(Asm, TLOF.getDataSection());
3091 /// emitDIE - Recusively Emits a debug information entry.
3093 void DwarfDebug::emitDIE(DIE *Die) {
3094 // Get the abbreviation for this DIE.
3095 unsigned AbbrevNumber = Die->getAbbrevNumber();
3096 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3098 // Emit the code (index) for the abbreviation.
3099 if (Asm->isVerbose())
3100 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3101 Twine::utohexstr(Die->getOffset()) + ":0x" +
3102 Twine::utohexstr(Die->getSize()) + " " +
3103 dwarf::TagString(Abbrev->getTag()));
3104 Asm->EmitULEB128(AbbrevNumber);
3106 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3107 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3109 // Emit the DIE attribute values.
3110 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3111 unsigned Attr = AbbrevData[i].getAttribute();
3112 unsigned Form = AbbrevData[i].getForm();
3113 assert(Form && "Too many attributes for DIE (check abbreviation)");
3115 if (Asm->isVerbose())
3116 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3119 case dwarf::DW_AT_sibling:
3120 Asm->EmitInt32(Die->getSiblingOffset());
3122 case dwarf::DW_AT_abstract_origin: {
3123 DIEEntry *E = cast<DIEEntry>(Values[i]);
3124 DIE *Origin = E->getEntry();
3125 unsigned Addr = Origin->getOffset();
3126 Asm->EmitInt32(Addr);
3129 case dwarf::DW_AT_ranges: {
3130 // DW_AT_range Value encodes offset in debug_range section.
3131 DIEInteger *V = cast<DIEInteger>(Values[i]);
3133 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3134 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3138 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3140 DwarfDebugRangeSectionSym,
3145 case dwarf::DW_AT_location: {
3146 if (UseDotDebugLocEntry.count(Die) != 0) {
3147 DIELabel *L = cast<DIELabel>(Values[i]);
3148 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3150 Values[i]->EmitValue(Asm, Form);
3153 case dwarf::DW_AT_accessibility: {
3154 if (Asm->isVerbose()) {
3155 DIEInteger *V = cast<DIEInteger>(Values[i]);
3156 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3158 Values[i]->EmitValue(Asm, Form);
3162 // Emit an attribute using the defined form.
3163 Values[i]->EmitValue(Asm, Form);
3168 // Emit the DIE children if any.
3169 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3170 const std::vector<DIE *> &Children = Die->getChildren();
3172 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3173 emitDIE(Children[j]);
3175 if (Asm->isVerbose())
3176 Asm->OutStreamer.AddComment("End Of Children Mark");
3181 /// emitDebugInfo - Emit the debug info section.
3183 void DwarfDebug::emitDebugInfo() {
3184 // Start debug info section.
3185 Asm->OutStreamer.SwitchSection(
3186 Asm->getObjFileLowering().getDwarfInfoSection());
3187 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3188 E = CUMap.end(); I != E; ++I) {
3189 CompileUnit *TheCU = I->second;
3190 DIE *Die = TheCU->getCUDie();
3192 // Emit the compile units header.
3193 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3196 // Emit size of content not including length itself
3197 unsigned ContentSize = Die->getSize() +
3198 sizeof(int16_t) + // DWARF version number
3199 sizeof(int32_t) + // Offset Into Abbrev. Section
3200 sizeof(int8_t) + // Pointer Size (in bytes)
3201 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3203 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3204 Asm->EmitInt32(ContentSize);
3205 Asm->OutStreamer.AddComment("DWARF version number");
3206 Asm->EmitInt16(dwarf::DWARF_VERSION);
3207 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3208 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3209 DwarfAbbrevSectionSym);
3210 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3211 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3214 // FIXME - extra padding for gdb bug.
3215 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3220 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3224 /// emitAbbreviations - Emit the abbreviation section.
3226 void DwarfDebug::emitAbbreviations() const {
3227 // Check to see if it is worth the effort.
3228 if (!Abbreviations.empty()) {
3229 // Start the debug abbrev section.
3230 Asm->OutStreamer.SwitchSection(
3231 Asm->getObjFileLowering().getDwarfAbbrevSection());
3233 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3235 // For each abbrevation.
3236 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3237 // Get abbreviation data
3238 const DIEAbbrev *Abbrev = Abbreviations[i];
3240 // Emit the abbrevations code (base 1 index.)
3241 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3243 // Emit the abbreviations data.
3247 // Mark end of abbreviations.
3248 Asm->EmitULEB128(0, "EOM(3)");
3250 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3254 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3255 /// the line matrix.
3257 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3258 // Define last address of section.
3259 Asm->OutStreamer.AddComment("Extended Op");
3262 Asm->OutStreamer.AddComment("Op size");
3263 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3264 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3265 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3267 Asm->OutStreamer.AddComment("Section end label");
3269 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3270 Asm->getTargetData().getPointerSize(),
3273 // Mark end of matrix.
3274 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3280 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3282 void DwarfDebug::emitCommonDebugFrame() {
3283 if (!Asm->MAI->doesDwarfRequireFrameSection())
3286 int stackGrowth = Asm->getTargetData().getPointerSize();
3287 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3288 TargetFrameInfo::StackGrowsDown)
3291 // Start the dwarf frame section.
3292 Asm->OutStreamer.SwitchSection(
3293 Asm->getObjFileLowering().getDwarfFrameSection());
3295 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3296 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3297 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3298 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3300 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3301 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3302 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3303 Asm->OutStreamer.AddComment("CIE Version");
3304 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3305 Asm->OutStreamer.AddComment("CIE Augmentation");
3306 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3307 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3308 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3309 Asm->OutStreamer.AddComment("CIE RA Column");
3310 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3311 const TargetFrameInfo *TFI = Asm->TM.getFrameInfo();
3312 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3314 std::vector<MachineMove> Moves;
3315 TFI->getInitialFrameState(Moves);
3317 Asm->EmitFrameMoves(Moves, 0, false);
3319 Asm->EmitAlignment(2);
3320 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3323 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3326 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3327 if (!Asm->MAI->doesDwarfRequireFrameSection())
3330 // Start the dwarf frame section.
3331 Asm->OutStreamer.SwitchSection(
3332 Asm->getObjFileLowering().getDwarfFrameSection());
3334 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3335 MCSymbol *DebugFrameBegin =
3336 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3337 MCSymbol *DebugFrameEnd =
3338 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3339 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3341 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3343 Asm->OutStreamer.AddComment("FDE CIE offset");
3344 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3345 DwarfFrameSectionSym);
3347 Asm->OutStreamer.AddComment("FDE initial location");
3348 MCSymbol *FuncBeginSym =
3349 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3350 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3351 Asm->getTargetData().getPointerSize(),
3355 Asm->OutStreamer.AddComment("FDE address range");
3356 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3357 FuncBeginSym, Asm->getTargetData().getPointerSize());
3359 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3361 Asm->EmitAlignment(2);
3362 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3365 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3367 void DwarfDebug::emitDebugPubNames() {
3368 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3369 E = CUMap.end(); I != E; ++I) {
3370 CompileUnit *TheCU = I->second;
3371 // Start the dwarf pubnames section.
3372 Asm->OutStreamer.SwitchSection(
3373 Asm->getObjFileLowering().getDwarfPubNamesSection());
3375 Asm->OutStreamer.AddComment("Length of Public Names Info");
3376 Asm->EmitLabelDifference(
3377 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3378 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3380 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3383 Asm->OutStreamer.AddComment("DWARF Version");
3384 Asm->EmitInt16(dwarf::DWARF_VERSION);
3386 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3387 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3388 DwarfInfoSectionSym);
3390 Asm->OutStreamer.AddComment("Compilation Unit Length");
3391 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3392 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3395 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3396 for (StringMap<DIE*>::const_iterator
3397 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3398 const char *Name = GI->getKeyData();
3399 DIE *Entity = GI->second;
3401 Asm->OutStreamer.AddComment("DIE offset");
3402 Asm->EmitInt32(Entity->getOffset());
3404 if (Asm->isVerbose())
3405 Asm->OutStreamer.AddComment("External Name");
3406 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3409 Asm->OutStreamer.AddComment("End Mark");
3411 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3416 void DwarfDebug::emitDebugPubTypes() {
3417 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3418 E = CUMap.end(); I != E; ++I) {
3419 CompileUnit *TheCU = I->second;
3420 // Start the dwarf pubnames section.
3421 Asm->OutStreamer.SwitchSection(
3422 Asm->getObjFileLowering().getDwarfPubTypesSection());
3423 Asm->OutStreamer.AddComment("Length of Public Types Info");
3424 Asm->EmitLabelDifference(
3425 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3426 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3428 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3431 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3432 Asm->EmitInt16(dwarf::DWARF_VERSION);
3434 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3435 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3436 DwarfInfoSectionSym);
3438 Asm->OutStreamer.AddComment("Compilation Unit Length");
3439 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3440 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3443 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3444 for (StringMap<DIE*>::const_iterator
3445 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3446 const char *Name = GI->getKeyData();
3447 DIE * Entity = GI->second;
3449 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3450 Asm->EmitInt32(Entity->getOffset());
3452 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3453 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3456 Asm->OutStreamer.AddComment("End Mark");
3458 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3463 /// emitDebugStr - Emit visible names into a debug str section.
3465 void DwarfDebug::emitDebugStr() {
3466 // Check to see if it is worth the effort.
3467 if (StringPool.empty()) return;
3469 // Start the dwarf str section.
3470 Asm->OutStreamer.SwitchSection(
3471 Asm->getObjFileLowering().getDwarfStrSection());
3473 // Get all of the string pool entries and put them in an array by their ID so
3474 // we can sort them.
3475 SmallVector<std::pair<unsigned,
3476 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3478 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3479 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3480 Entries.push_back(std::make_pair(I->second.second, &*I));
3482 array_pod_sort(Entries.begin(), Entries.end());
3484 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3485 // Emit a label for reference from debug information entries.
3486 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3488 // Emit the string itself.
3489 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3493 /// emitDebugLoc - Emit visible names into a debug loc section.
3495 void DwarfDebug::emitDebugLoc() {
3496 if (DotDebugLocEntries.empty())
3499 // Start the dwarf loc section.
3500 Asm->OutStreamer.SwitchSection(
3501 Asm->getObjFileLowering().getDwarfLocSection());
3502 unsigned char Size = Asm->getTargetData().getPointerSize();
3503 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3505 for (SmallVector<DotDebugLocEntry, 4>::iterator
3506 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3507 I != E; ++I, ++index) {
3508 DotDebugLocEntry Entry = *I;
3509 if (Entry.isEmpty()) {
3510 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3511 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3512 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3514 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3515 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3516 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3517 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3518 if (int Offset = Entry.Loc.getOffset()) {
3519 // If the value is at a certain offset from frame register then
3521 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3522 Asm->OutStreamer.AddComment("Loc expr size");
3523 Asm->EmitInt16(1 + OffsetSize);
3524 Asm->OutStreamer.AddComment(
3525 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3526 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3527 Asm->OutStreamer.AddComment("Offset");
3528 Asm->EmitSLEB128(Offset);
3531 Asm->OutStreamer.AddComment("Loc expr size");
3533 Asm->OutStreamer.AddComment(
3534 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3535 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3537 Asm->OutStreamer.AddComment("Loc expr size");
3538 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3539 Asm->EmitInt8(dwarf::DW_OP_regx);
3540 Asm->EmitULEB128(Reg);
3547 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3549 void DwarfDebug::EmitDebugARanges() {
3550 // Start the dwarf aranges section.
3551 Asm->OutStreamer.SwitchSection(
3552 Asm->getObjFileLowering().getDwarfARangesSection());
3555 /// emitDebugRanges - Emit visible names into a debug ranges section.
3557 void DwarfDebug::emitDebugRanges() {
3558 // Start the dwarf ranges section.
3559 Asm->OutStreamer.SwitchSection(
3560 Asm->getObjFileLowering().getDwarfRangesSection());
3561 unsigned char Size = Asm->getTargetData().getPointerSize();
3562 for (SmallVector<const MCSymbol *, 8>::iterator
3563 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3566 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3568 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3572 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3574 void DwarfDebug::emitDebugMacInfo() {
3575 if (const MCSection *LineInfo =
3576 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3577 // Start the dwarf macinfo section.
3578 Asm->OutStreamer.SwitchSection(LineInfo);
3582 /// emitDebugInlineInfo - Emit inline info using following format.
3584 /// 1. length of section
3585 /// 2. Dwarf version number
3586 /// 3. address size.
3588 /// Entries (one "entry" for each function that was inlined):
3590 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3591 /// otherwise offset into __debug_str for regular function name.
3592 /// 2. offset into __debug_str section for regular function name.
3593 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3594 /// instances for the function.
3596 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3597 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3598 /// __debug_info section, and the low_pc is the starting address for the
3599 /// inlining instance.
3600 void DwarfDebug::emitDebugInlineInfo() {
3601 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3607 Asm->OutStreamer.SwitchSection(
3608 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3610 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3611 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3612 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3614 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3616 Asm->OutStreamer.AddComment("Dwarf Version");
3617 Asm->EmitInt16(dwarf::DWARF_VERSION);
3618 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3619 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3621 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3622 E = InlinedSPNodes.end(); I != E; ++I) {
3624 const MDNode *Node = *I;
3625 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3626 = InlineInfo.find(Node);
3627 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3628 DISubprogram SP(Node);
3629 StringRef LName = SP.getLinkageName();
3630 StringRef Name = SP.getName();
3632 Asm->OutStreamer.AddComment("MIPS linkage name");
3633 if (LName.empty()) {
3634 Asm->OutStreamer.EmitBytes(Name, 0);
3635 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3637 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3638 DwarfStrSectionSym);
3640 Asm->OutStreamer.AddComment("Function name");
3641 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3642 Asm->EmitULEB128(Labels.size(), "Inline count");
3644 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3645 LE = Labels.end(); LI != LE; ++LI) {
3646 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3647 Asm->EmitInt32(LI->second->getOffset());
3649 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3650 Asm->OutStreamer.EmitSymbolValue(LI->first,
3651 Asm->getTargetData().getPointerSize(),0);
3655 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));