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/Analysis/DebugInfo.h"
32 #include "llvm/ADT/STLExtras.h"
33 #include "llvm/ADT/StringExtras.h"
34 #include "llvm/Support/Debug.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include "llvm/Support/ValueHandle.h"
37 #include "llvm/Support/FormattedStream.h"
38 #include "llvm/Support/Timer.h"
39 #include "llvm/System/Path.h"
43 const char *DWARFGroupName = "DWARF Emission";
44 const char *DbgTimerName = "DWARF Debug Writer";
45 } // end anonymous namespace
47 //===----------------------------------------------------------------------===//
49 /// Configuration values for initial hash set sizes (log2).
51 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
55 //===----------------------------------------------------------------------===//
56 /// CompileUnit - This dwarf writer support class manages information associate
57 /// with a source file.
59 /// ID - File identifier for source.
63 /// Die - Compile unit debug information entry.
65 const OwningPtr<DIE> CUDie;
67 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
70 /// GVToDieMap - Tracks the mapping of unit level debug informaton
71 /// variables to debug information entries.
72 /// FIXME : Rename GVToDieMap -> NodeToDieMap
73 DenseMap<MDNode *, DIE *> GVToDieMap;
75 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
76 /// descriptors to debug information entries using a DIEEntry proxy.
78 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
80 /// Globals - A map of globally visible named entities for this unit.
82 StringMap<DIE*> Globals;
84 /// GlobalTypes - A map of globally visible types for this unit.
86 StringMap<DIE*> GlobalTypes;
89 CompileUnit(unsigned I, DIE *D)
90 : ID(I), CUDie(D), IndexTyDie(0) {}
93 unsigned getID() const { return ID; }
94 DIE* getCUDie() const { return CUDie.get(); }
95 const StringMap<DIE*> &getGlobals() const { return Globals; }
96 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
98 /// hasContent - Return true if this compile unit has something to write out.
100 bool hasContent() const { return !CUDie->getChildren().empty(); }
102 /// addGlobal - Add a new global entity to the compile unit.
104 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
106 /// addGlobalType - Add a new global type to the compile unit.
108 void addGlobalType(StringRef Name, DIE *Die) {
109 GlobalTypes[Name] = Die;
112 /// getDIE - Returns the debug information entry map slot for the
113 /// specified debug variable.
114 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
116 /// insertDIE - Insert DIE into the map.
117 void insertDIE(MDNode *N, DIE *D) {
118 GVToDieMap.insert(std::make_pair(N, D));
121 /// getDIEEntry - Returns the debug information entry for the speciefied
123 DIEEntry *getDIEEntry(MDNode *N) {
124 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
125 if (I == GVToDIEEntryMap.end())
130 /// insertDIEEntry - Insert debug information entry into the map.
131 void insertDIEEntry(MDNode *N, DIEEntry *E) {
132 GVToDIEEntryMap.insert(std::make_pair(N, E));
135 /// addDie - Adds or interns the DIE to the compile unit.
137 void addDie(DIE *Buffer) {
138 this->CUDie->addChild(Buffer);
141 // getIndexTyDie - Get an anonymous type for index type.
142 DIE *getIndexTyDie() {
146 // setIndexTyDie - Set D as anonymous type for index which can be reused
148 void setIndexTyDie(DIE *D) {
154 //===----------------------------------------------------------------------===//
155 /// DbgVariable - This class is used to track local variable information.
158 DIVariable Var; // Variable Descriptor.
159 unsigned FrameIndex; // Variable frame index.
160 const MachineInstr *DbgValueMInsn; // DBG_VALUE
161 // DbgValueLabel - DBG_VALUE is effective from this label.
162 MCSymbol *DbgValueLabel;
163 DbgVariable *const AbstractVar; // Abstract variable for this variable.
166 // AbsVar may be NULL.
167 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
168 : Var(V), FrameIndex(I), DbgValueMInsn(0),
169 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
170 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
171 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
172 AbstractVar(AbsVar), TheDIE(0)
176 DIVariable getVariable() const { return Var; }
177 unsigned getFrameIndex() const { return FrameIndex; }
178 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
179 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
180 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
181 DbgVariable *getAbstractVariable() const { return AbstractVar; }
182 void setDIE(DIE *D) { TheDIE = D; }
183 DIE *getDIE() const { return TheDIE; }
186 //===----------------------------------------------------------------------===//
187 /// DbgScope - This class is used to track scope information.
190 DbgScope *Parent; // Parent to this scope.
191 DIDescriptor Desc; // Debug info descriptor for scope.
192 // Location at which this scope is inlined.
193 AssertingVH<MDNode> InlinedAtLocation;
194 bool AbstractScope; // Abstract Scope
195 MCSymbol *StartLabel; // Label ID of the beginning of scope.
196 MCSymbol *EndLabel; // Label ID of the end of scope.
197 const MachineInstr *LastInsn; // Last instruction of this scope.
198 const MachineInstr *FirstInsn; // First instruction of this scope.
199 // Scopes defined in scope. Contents not owned.
200 SmallVector<DbgScope *, 4> Scopes;
201 // Variables declared in scope. Contents owned.
202 SmallVector<DbgVariable *, 8> Variables;
204 // Private state for dump()
205 mutable unsigned IndentLevel;
207 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
208 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
209 StartLabel(0), EndLabel(0),
210 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
214 DbgScope *getParent() const { return Parent; }
215 void setParent(DbgScope *P) { Parent = P; }
216 DIDescriptor getDesc() const { return Desc; }
217 MDNode *getInlinedAt() const { return InlinedAtLocation; }
218 MDNode *getScopeNode() const { return Desc.getNode(); }
219 MCSymbol *getStartLabel() const { return StartLabel; }
220 MCSymbol *getEndLabel() const { return EndLabel; }
221 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
222 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
223 void setStartLabel(MCSymbol *S) { StartLabel = S; }
224 void setEndLabel(MCSymbol *E) { EndLabel = E; }
225 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
226 const MachineInstr *getLastInsn() { return LastInsn; }
227 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
228 void setAbstractScope() { AbstractScope = true; }
229 bool isAbstractScope() const { return AbstractScope; }
230 const MachineInstr *getFirstInsn() { return FirstInsn; }
232 /// addScope - Add a scope to the scope.
234 void addScope(DbgScope *S) { Scopes.push_back(S); }
236 /// addVariable - Add a variable to the scope.
238 void addVariable(DbgVariable *V) { Variables.push_back(V); }
240 void fixInstructionMarkers(DenseMap<const MachineInstr *,
241 unsigned> &MIIndexMap) {
242 assert(getFirstInsn() && "First instruction is missing!");
244 // Use the end of last child scope as end of this scope.
245 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
246 const MachineInstr *LastInsn = getFirstInsn();
248 if (Scopes.empty()) {
249 assert(getLastInsn() && "Inner most scope does not have last insn!");
252 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
253 SE = Scopes.end(); SI != SE; ++SI) {
255 DS->fixInstructionMarkers(MIIndexMap);
256 const MachineInstr *DSLastInsn = DS->getLastInsn();
257 unsigned DSI = MIIndexMap[DSLastInsn];
259 LastInsn = DSLastInsn;
264 unsigned CurrentLastInsnIndex = 0;
265 if (const MachineInstr *CL = getLastInsn())
266 CurrentLastInsnIndex = MIIndexMap[CL];
267 unsigned FIndex = MIIndexMap[getFirstInsn()];
269 // Set LastInsn as the last instruction for this scope only if
271 // 1) this scope's first instruction and
272 // 2) current last instruction for this scope, if any.
273 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
274 setLastInsn(LastInsn);
282 } // end llvm namespace
285 void DbgScope::dump() const {
286 raw_ostream &err = dbgs();
287 err.indent(IndentLevel);
288 MDNode *N = Desc.getNode();
290 err << " [" << StartLabel << ", " << EndLabel << "]\n";
292 err << "Abstract Scope\n";
296 err << "Children ...\n";
297 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
298 if (Scopes[i] != this)
305 DbgScope::~DbgScope() {
306 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
310 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
311 : Asm(A), MMI(Asm->MMI), ModuleCU(0),
312 AbbreviationsSet(InitAbbreviationsSetSize),
313 CurrentFnDbgScope(0) {
314 NextStringPoolNumber = 0;
316 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
317 DwarfStrSectionSym = TextSectionSym = 0;
321 DwarfDebug::~DwarfDebug() {
322 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
323 DIEBlocks[j]->~DIEBlock();
326 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
327 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
328 if (Entry.first) return Entry.first;
330 Entry.second = NextStringPoolNumber++;
331 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
335 /// assignAbbrevNumber - Define a unique number for the abbreviation.
337 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
338 // Profile the node so that we can make it unique.
342 // Check the set for priors.
343 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
345 // If it's newly added.
346 if (InSet == &Abbrev) {
347 // Add to abbreviation list.
348 Abbreviations.push_back(&Abbrev);
350 // Assign the vector position + 1 as its number.
351 Abbrev.setNumber(Abbreviations.size());
353 // Assign existing abbreviation number.
354 Abbrev.setNumber(InSet->getNumber());
358 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
359 /// information entry.
360 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
361 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
365 /// addUInt - Add an unsigned integer attribute data and value.
367 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
368 unsigned Form, uint64_t Integer) {
369 if (!Form) Form = DIEInteger::BestForm(false, Integer);
370 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
371 Die->addValue(Attribute, Form, Value);
374 /// addSInt - Add an signed integer attribute data and value.
376 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
377 unsigned Form, int64_t Integer) {
378 if (!Form) Form = DIEInteger::BestForm(true, Integer);
379 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
380 Die->addValue(Attribute, Form, Value);
383 /// addString - Add a string attribute data and value. DIEString only
384 /// keeps string reference.
385 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
387 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
388 Die->addValue(Attribute, Form, Value);
391 /// addLabel - Add a Dwarf label attribute data and value.
393 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
394 const MCSymbol *Label) {
395 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
396 Die->addValue(Attribute, Form, Value);
399 /// addDelta - Add a label delta attribute data and value.
401 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
402 const MCSymbol *Hi, const MCSymbol *Lo) {
403 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
404 Die->addValue(Attribute, Form, Value);
407 /// addDIEEntry - Add a DIE attribute data and value.
409 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
411 Die->addValue(Attribute, Form, createDIEEntry(Entry));
415 /// addBlock - Add block data.
417 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
419 Block->ComputeSize(Asm);
420 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
421 Die->addValue(Attribute, Block->BestForm(), Block);
424 /// addSourceLine - Add location information to specified debug information
426 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
427 // If there is no compile unit specified, don't add a line #.
428 if (!V->getCompileUnit().Verify())
431 unsigned Line = V->getLineNumber();
432 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
433 V->getContext().getFilename());
434 assert(FileID && "Invalid file id");
435 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
436 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
439 /// addSourceLine - Add location information to specified debug information
441 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
442 // If there is no compile unit specified, don't add a line #.
443 if (!G->getCompileUnit().Verify())
446 unsigned Line = G->getLineNumber();
447 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
448 G->getContext().getFilename());
449 assert(FileID && "Invalid file id");
450 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
451 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
454 /// addSourceLine - Add location information to specified debug information
456 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
457 // If there is no compile unit specified, don't add a line #.
458 if (!SP->getCompileUnit().Verify())
460 // If the line number is 0, don't add it.
461 if (SP->getLineNumber() == 0)
464 unsigned Line = SP->getLineNumber();
465 if (!SP->getContext().Verify())
467 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
469 assert(FileID && "Invalid file id");
470 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
471 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
474 /// addSourceLine - Add location information to specified debug information
476 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
477 // If there is no compile unit specified, don't add a line #.
478 DICompileUnit CU = Ty->getCompileUnit();
482 unsigned Line = Ty->getLineNumber();
483 if (!Ty->getContext().Verify())
485 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
486 Ty->getContext().getFilename());
487 assert(FileID && "Invalid file id");
488 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
489 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
492 /// addSourceLine - Add location information to specified debug information
494 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
495 // If there is no compile unit specified, don't add a line #.
496 if (!NS->getCompileUnit().Verify())
499 unsigned Line = NS->getLineNumber();
500 StringRef FN = NS->getFilename();
501 StringRef Dir = NS->getDirectory();
503 unsigned FileID = GetOrCreateSourceID(Dir, FN);
504 assert(FileID && "Invalid file id");
505 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
506 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
509 /* Byref variables, in Blocks, are declared by the programmer as
510 "SomeType VarName;", but the compiler creates a
511 __Block_byref_x_VarName struct, and gives the variable VarName
512 either the struct, or a pointer to the struct, as its type. This
513 is necessary for various behind-the-scenes things the compiler
514 needs to do with by-reference variables in blocks.
516 However, as far as the original *programmer* is concerned, the
517 variable should still have type 'SomeType', as originally declared.
519 The following function dives into the __Block_byref_x_VarName
520 struct to find the original type of the variable. This will be
521 passed back to the code generating the type for the Debug
522 Information Entry for the variable 'VarName'. 'VarName' will then
523 have the original type 'SomeType' in its debug information.
525 The original type 'SomeType' will be the type of the field named
526 'VarName' inside the __Block_byref_x_VarName struct.
528 NOTE: In order for this to not completely fail on the debugger
529 side, the Debug Information Entry for the variable VarName needs to
530 have a DW_AT_location that tells the debugger how to unwind through
531 the pointers and __Block_byref_x_VarName struct to find the actual
532 value of the variable. The function addBlockByrefType does this. */
534 /// Find the type the programmer originally declared the variable to be
535 /// and return that type.
537 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
540 unsigned tag = Ty.getTag();
542 if (tag == dwarf::DW_TAG_pointer_type) {
543 DIDerivedType DTy = DIDerivedType(Ty.getNode());
544 subType = DTy.getTypeDerivedFrom();
547 DICompositeType blockStruct = DICompositeType(subType.getNode());
548 DIArray Elements = blockStruct.getTypeArray();
550 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
551 DIDescriptor Element = Elements.getElement(i);
552 DIDerivedType DT = DIDerivedType(Element.getNode());
553 if (Name == DT.getName())
554 return (DT.getTypeDerivedFrom());
560 /// addComplexAddress - Start with the address based on the location provided,
561 /// and generate the DWARF information necessary to find the actual variable
562 /// given the extra address information encoded in the DIVariable, starting from
563 /// the starting location. Add the DWARF information to the die.
565 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
567 const MachineLocation &Location) {
568 const DIVariable &VD = DV->getVariable();
569 DIType Ty = VD.getType();
571 // Decode the original location, and use that as the start of the byref
572 // variable's location.
573 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
574 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
575 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
577 if (Location.isReg()) {
579 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
581 Reg = Reg - dwarf::DW_OP_reg0;
582 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
583 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
590 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
593 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
596 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
597 uint64_t Element = VD.getAddrElement(i);
599 if (Element == DIFactory::OpPlus) {
600 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
601 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
602 } else if (Element == DIFactory::OpDeref) {
603 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
604 } else llvm_unreachable("unknown DIFactory Opcode");
607 // Now attach the location information to the DIE.
608 addBlock(Die, Attribute, 0, Block);
611 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
612 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
613 gives the variable VarName either the struct, or a pointer to the struct, as
614 its type. This is necessary for various behind-the-scenes things the
615 compiler needs to do with by-reference variables in Blocks.
617 However, as far as the original *programmer* is concerned, the variable
618 should still have type 'SomeType', as originally declared.
620 The function getBlockByrefType dives into the __Block_byref_x_VarName
621 struct to find the original type of the variable, which is then assigned to
622 the variable's Debug Information Entry as its real type. So far, so good.
623 However now the debugger will expect the variable VarName to have the type
624 SomeType. So we need the location attribute for the variable to be an
625 expression that explains to the debugger how to navigate through the
626 pointers and struct to find the actual variable of type SomeType.
628 The following function does just that. We start by getting
629 the "normal" location for the variable. This will be the location
630 of either the struct __Block_byref_x_VarName or the pointer to the
631 struct __Block_byref_x_VarName.
633 The struct will look something like:
635 struct __Block_byref_x_VarName {
637 struct __Block_byref_x_VarName *forwarding;
638 ... <various other fields>
640 ... <maybe more fields>
643 If we are given the struct directly (as our starting point) we
644 need to tell the debugger to:
646 1). Add the offset of the forwarding field.
648 2). Follow that pointer to get the real __Block_byref_x_VarName
649 struct to use (the real one may have been copied onto the heap).
651 3). Add the offset for the field VarName, to find the actual variable.
653 If we started with a pointer to the struct, then we need to
654 dereference that pointer first, before the other steps.
655 Translating this into DWARF ops, we will need to append the following
656 to the current location description for the variable:
658 DW_OP_deref -- optional, if we start with a pointer
659 DW_OP_plus_uconst <forward_fld_offset>
661 DW_OP_plus_uconst <varName_fld_offset>
663 That is what this function does. */
665 /// addBlockByrefAddress - Start with the address based on the location
666 /// provided, and generate the DWARF information necessary to find the
667 /// actual Block variable (navigating the Block struct) based on the
668 /// starting location. Add the DWARF information to the die. For
669 /// more information, read large comment just above here.
671 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
673 const MachineLocation &Location) {
674 const DIVariable &VD = DV->getVariable();
675 DIType Ty = VD.getType();
677 unsigned Tag = Ty.getTag();
678 bool isPointer = false;
680 StringRef varName = VD.getName();
682 if (Tag == dwarf::DW_TAG_pointer_type) {
683 DIDerivedType DTy = DIDerivedType(Ty.getNode());
684 TmpTy = DTy.getTypeDerivedFrom();
688 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
690 // Find the __forwarding field and the variable field in the __Block_byref
692 DIArray Fields = blockStruct.getTypeArray();
693 DIDescriptor varField = DIDescriptor();
694 DIDescriptor forwardingField = DIDescriptor();
696 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
697 DIDescriptor Element = Fields.getElement(i);
698 DIDerivedType DT = DIDerivedType(Element.getNode());
699 StringRef fieldName = DT.getName();
700 if (fieldName == "__forwarding")
701 forwardingField = Element;
702 else if (fieldName == varName)
706 // Get the offsets for the forwarding field and the variable field.
707 unsigned forwardingFieldOffset =
708 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
709 unsigned varFieldOffset =
710 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
712 // Decode the original location, and use that as the start of the byref
713 // variable's location.
714 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
715 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
716 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
718 if (Location.isReg()) {
720 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
722 Reg = Reg - dwarf::DW_OP_reg0;
723 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
724 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
728 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
731 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
734 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
737 // If we started with a pointer to the __Block_byref... struct, then
738 // the first thing we need to do is dereference the pointer (DW_OP_deref).
740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
742 // Next add the offset for the '__forwarding' field:
743 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
744 // adding the offset if it's 0.
745 if (forwardingFieldOffset > 0) {
746 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
747 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
750 // Now dereference the __forwarding field to get to the real __Block_byref
751 // struct: DW_OP_deref.
752 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
754 // Now that we've got the real __Block_byref... struct, add the offset
755 // for the variable's field to get to the location of the actual variable:
756 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
757 if (varFieldOffset > 0) {
758 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
759 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
762 // Now attach the location information to the DIE.
763 addBlock(Die, Attribute, 0, Block);
766 /// addAddress - Add an address attribute to a die based on the location
768 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
769 const MachineLocation &Location) {
770 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
771 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
772 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
774 if (Location.isReg()) {
776 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
778 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
779 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
783 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
785 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
786 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
789 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
792 addBlock(Die, Attribute, 0, Block);
795 /// addToContextOwner - Add Die into the list of its context owner's children.
796 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
797 if (Context.isType()) {
798 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
799 ContextDIE->addChild(Die);
800 } else if (Context.isNameSpace()) {
801 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
802 ContextDIE->addChild(Die);
803 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
804 ContextDIE->addChild(Die);
806 ModuleCU->addDie(Die);
809 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
811 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
812 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
817 TyDIE = new DIE(dwarf::DW_TAG_base_type);
818 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
819 if (Ty.isBasicType())
820 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
821 else if (Ty.isCompositeType())
822 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
824 assert(Ty.isDerivedType() && "Unknown kind of DIType");
825 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
828 addToContextOwner(TyDIE, Ty.getContext());
832 /// addType - Add a new type attribute to the specified entity.
833 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
837 // Check for pre-existence.
838 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
839 // If it exists then use the existing value.
841 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
846 DIE *Buffer = getOrCreateTypeDIE(Ty);
849 Entry = createDIEEntry(Buffer);
850 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
852 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
855 /// constructTypeDIE - Construct basic type die from DIBasicType.
856 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
857 // Get core information.
858 StringRef Name = BTy.getName();
859 Buffer.setTag(dwarf::DW_TAG_base_type);
860 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
863 // Add name if not anonymous or intermediate type.
865 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
866 uint64_t Size = BTy.getSizeInBits() >> 3;
867 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
870 /// constructTypeDIE - Construct derived type die from DIDerivedType.
871 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
872 // Get core information.
873 StringRef Name = DTy.getName();
874 uint64_t Size = DTy.getSizeInBits() >> 3;
875 unsigned Tag = DTy.getTag();
877 // FIXME - Workaround for templates.
878 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
882 // Map to main type, void will not have a type.
883 DIType FromTy = DTy.getTypeDerivedFrom();
884 addType(&Buffer, FromTy);
886 // Add name if not anonymous or intermediate type.
888 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
890 // Add size if non-zero (derived types might be zero-sized.)
892 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
894 // Add source line info if available and TyDesc is not a forward declaration.
895 if (!DTy.isForwardDecl())
896 addSourceLine(&Buffer, &DTy);
899 /// constructTypeDIE - Construct type DIE from DICompositeType.
900 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
901 // Get core information.
902 StringRef Name = CTy.getName();
904 uint64_t Size = CTy.getSizeInBits() >> 3;
905 unsigned Tag = CTy.getTag();
909 case dwarf::DW_TAG_vector_type:
910 case dwarf::DW_TAG_array_type:
911 constructArrayTypeDIE(Buffer, &CTy);
913 case dwarf::DW_TAG_enumeration_type: {
914 DIArray Elements = CTy.getTypeArray();
916 // Add enumerators to enumeration type.
917 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
919 DIDescriptor Enum(Elements.getElement(i).getNode());
920 if (Enum.isEnumerator()) {
921 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
922 Buffer.addChild(ElemDie);
927 case dwarf::DW_TAG_subroutine_type: {
929 DIArray Elements = CTy.getTypeArray();
930 DIDescriptor RTy = Elements.getElement(0);
931 addType(&Buffer, DIType(RTy.getNode()));
933 // Add prototype flag.
934 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
937 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
938 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
939 DIDescriptor Ty = Elements.getElement(i);
940 addType(Arg, DIType(Ty.getNode()));
941 Buffer.addChild(Arg);
945 case dwarf::DW_TAG_structure_type:
946 case dwarf::DW_TAG_union_type:
947 case dwarf::DW_TAG_class_type: {
948 // Add elements to structure type.
949 DIArray Elements = CTy.getTypeArray();
951 // A forward struct declared type may not have elements available.
952 unsigned N = Elements.getNumElements();
956 // Add elements to structure type.
957 for (unsigned i = 0; i < N; ++i) {
958 DIDescriptor Element = Elements.getElement(i);
960 if (Element.isSubprogram())
961 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
962 else if (Element.isVariable()) {
963 DIVariable DV(Element.getNode());
964 ElemDie = new DIE(dwarf::DW_TAG_variable);
965 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
967 addType(ElemDie, DV.getType());
968 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
969 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
970 addSourceLine(ElemDie, &DV);
971 } else if (Element.isDerivedType())
972 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
975 Buffer.addChild(ElemDie);
978 if (CTy.isAppleBlockExtension())
979 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
981 unsigned RLang = CTy.getRunTimeLang();
983 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
984 dwarf::DW_FORM_data1, RLang);
986 DICompositeType ContainingType = CTy.getContainingType();
987 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
988 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
989 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
996 // Add name if not anonymous or intermediate type.
998 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1000 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1001 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1002 // Add size if non-zero (derived types might be zero-sized.)
1004 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1006 // Add zero size if it is not a forward declaration.
1007 if (CTy.isForwardDecl())
1008 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1010 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1013 // Add source line info if available.
1014 if (!CTy.isForwardDecl())
1015 addSourceLine(&Buffer, &CTy);
1019 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1020 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1021 int64_t L = SR.getLo();
1022 int64_t H = SR.getHi();
1023 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1025 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1027 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1028 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1030 Buffer.addChild(DW_Subrange);
1033 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1034 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1035 DICompositeType *CTy) {
1036 Buffer.setTag(dwarf::DW_TAG_array_type);
1037 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1038 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1040 // Emit derived type.
1041 addType(&Buffer, CTy->getTypeDerivedFrom());
1042 DIArray Elements = CTy->getTypeArray();
1044 // Get an anonymous type for index type.
1045 DIE *IdxTy = ModuleCU->getIndexTyDie();
1047 // Construct an anonymous type for index type.
1048 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1049 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1050 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1051 dwarf::DW_ATE_signed);
1052 ModuleCU->addDie(IdxTy);
1053 ModuleCU->setIndexTyDie(IdxTy);
1056 // Add subranges to array type.
1057 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1058 DIDescriptor Element = Elements.getElement(i);
1059 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1060 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1064 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1065 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1066 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1067 StringRef Name = ETy.getName();
1068 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1069 int64_t Value = ETy.getEnumValue();
1070 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1074 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1075 /// printer to not emit usual symbol prefix before the symbol name is used then
1076 /// return linkage name after skipping this special LLVM prefix.
1077 static StringRef getRealLinkageName(StringRef LinkageName) {
1079 if (LinkageName.startswith(StringRef(&One, 1)))
1080 return LinkageName.substr(1);
1084 /// createGlobalVariableDIE - Create new DIE using GV.
1085 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1086 // If the global variable was optmized out then no need to create debug info
1088 if (!GV.getGlobal()) return NULL;
1089 if (GV.getDisplayName().empty()) return NULL;
1091 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1092 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1093 GV.getDisplayName());
1095 StringRef LinkageName = GV.getLinkageName();
1096 if (!LinkageName.empty())
1097 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1098 getRealLinkageName(LinkageName));
1100 addType(GVDie, GV.getType());
1101 if (!GV.isLocalToUnit())
1102 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1103 addSourceLine(GVDie, &GV);
1108 /// createMemberDIE - Create new member DIE.
1109 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1110 DIE *MemberDie = new DIE(DT.getTag());
1111 StringRef Name = DT.getName();
1113 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1115 addType(MemberDie, DT.getTypeDerivedFrom());
1117 addSourceLine(MemberDie, &DT);
1119 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1120 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1122 uint64_t Size = DT.getSizeInBits();
1123 uint64_t FieldSize = DT.getOriginalTypeSize();
1125 if (Size != FieldSize) {
1127 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1128 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1130 uint64_t Offset = DT.getOffsetInBits();
1131 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1132 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1133 uint64_t FieldOffset = (HiMark - FieldSize);
1134 Offset -= FieldOffset;
1136 // Maybe we need to work from the other end.
1137 if (Asm->getTargetData().isLittleEndian())
1138 Offset = FieldSize - (Offset + Size);
1139 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1141 // Here WD_AT_data_member_location points to the anonymous
1142 // field that includes this bit field.
1143 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1146 // This is not a bitfield.
1147 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1149 if (DT.getTag() == dwarf::DW_TAG_inheritance
1150 && DT.isVirtual()) {
1152 // For C++, virtual base classes are not at fixed offset. Use following
1153 // expression to extract appropriate offset from vtable.
1154 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1156 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1157 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1158 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1159 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1160 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1161 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1162 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1163 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1165 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1168 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1170 if (DT.isProtected())
1171 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1172 dwarf::DW_ACCESS_protected);
1173 else if (DT.isPrivate())
1174 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1175 dwarf::DW_ACCESS_private);
1176 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1177 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1178 dwarf::DW_ACCESS_public);
1180 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1181 dwarf::DW_VIRTUALITY_virtual);
1185 /// createSubprogramDIE - Create new DIE using SP.
1186 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1187 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1191 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1192 // Constructors and operators for anonymous aggregates do not have names.
1193 if (!SP.getName().empty())
1194 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1196 StringRef LinkageName = SP.getLinkageName();
1197 if (!LinkageName.empty())
1198 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1199 getRealLinkageName(LinkageName));
1201 addSourceLine(SPDie, &SP);
1203 // Add prototyped tag, if C or ObjC.
1204 unsigned Lang = SP.getCompileUnit().getLanguage();
1205 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1206 Lang == dwarf::DW_LANG_ObjC)
1207 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1210 DICompositeType SPTy = SP.getType();
1211 DIArray Args = SPTy.getTypeArray();
1212 unsigned SPTag = SPTy.getTag();
1214 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1215 addType(SPDie, SPTy);
1217 addType(SPDie, DIType(Args.getElement(0).getNode()));
1219 unsigned VK = SP.getVirtuality();
1221 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1222 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1223 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1224 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1225 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1226 ContainingTypeMap.insert(std::make_pair(SPDie,
1227 SP.getContainingType().getNode()));
1230 if (MakeDecl || !SP.isDefinition()) {
1231 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1233 // Add arguments. Do not add arguments for subprogram definition. They will
1234 // be handled while processing variables.
1235 DICompositeType SPTy = SP.getType();
1236 DIArray Args = SPTy.getTypeArray();
1237 unsigned SPTag = SPTy.getTag();
1239 if (SPTag == dwarf::DW_TAG_subroutine_type)
1240 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1241 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1242 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1244 if (ATy.isArtificial())
1245 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1246 SPDie->addChild(Arg);
1250 if (SP.isArtificial())
1251 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1253 // DW_TAG_inlined_subroutine may refer to this DIE.
1254 ModuleCU->insertDIE(SP.getNode(), SPDie);
1258 /// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1259 /// Update scope hierarchy. Create abstract scope if required.
1260 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1261 MDNode *InlinedAt) {
1262 assert(N && "Invalid Scope encoding!");
1263 assert(MI && "Missing machine instruction!");
1264 bool isAConcreteScope = InlinedAt != 0;
1266 DbgScope *NScope = NULL;
1269 NScope = DbgScopeMap.lookup(InlinedAt);
1271 NScope = DbgScopeMap.lookup(N);
1272 assert(NScope && "Unable to find working scope!");
1274 if (NScope->getFirstInsn())
1277 DbgScope *Parent = NULL;
1278 if (isAConcreteScope) {
1279 DILocation IL(InlinedAt);
1280 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1281 IL.getOrigLocation().getNode());
1282 assert(Parent && "Unable to find Parent scope!");
1283 NScope->setParent(Parent);
1284 Parent->addScope(NScope);
1285 } else if (DIDescriptor(N).isLexicalBlock()) {
1286 DILexicalBlock DB(N);
1287 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1288 NScope->setParent(Parent);
1289 Parent->addScope(NScope);
1292 NScope->setFirstInsn(MI);
1294 if (!Parent && !InlinedAt) {
1295 StringRef SPName = DISubprogram(N).getLinkageName();
1296 if (SPName == Asm->MF->getFunction()->getName())
1297 CurrentFnDbgScope = NScope;
1300 if (isAConcreteScope) {
1301 ConcreteScopes[InlinedAt] = NScope;
1302 getOrCreateAbstractScope(N);
1308 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1309 assert(N && "Invalid Scope encoding!");
1311 DbgScope *AScope = AbstractScopes.lookup(N);
1315 DbgScope *Parent = NULL;
1317 DIDescriptor Scope(N);
1318 if (Scope.isLexicalBlock()) {
1319 DILexicalBlock DB(N);
1320 DIDescriptor ParentDesc = DB.getContext();
1321 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1324 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1327 Parent->addScope(AScope);
1328 AScope->setAbstractScope();
1329 AbstractScopes[N] = AScope;
1330 if (DIDescriptor(N).isSubprogram())
1331 AbstractScopesList.push_back(AScope);
1335 /// isSubprogramContext - Return true if Context is either a subprogram
1336 /// or another context nested inside a subprogram.
1337 bool isSubprogramContext(MDNode *Context) {
1340 DIDescriptor D(Context);
1341 if (D.isSubprogram())
1344 return isSubprogramContext(DIType(Context).getContext().getNode());
1348 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1349 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1350 /// If there are global variables in this scope then create and insert
1351 /// DIEs for these variables.
1352 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1353 DIE *SPDie = ModuleCU->getDIE(SPNode);
1354 assert(SPDie && "Unable to find subprogram DIE!");
1355 DISubprogram SP(SPNode);
1357 // There is not any need to generate specification DIE for a function
1358 // defined at compile unit level. If a function is defined inside another
1359 // function then gdb prefers the definition at top level and but does not
1360 // expect specification DIE in parent function. So avoid creating
1361 // specification DIE for a function defined inside a function.
1362 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1363 !SP.getContext().isFile() &&
1364 !isSubprogramContext(SP.getContext().getNode())) {
1365 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1368 DICompositeType SPTy = SP.getType();
1369 DIArray Args = SPTy.getTypeArray();
1370 unsigned SPTag = SPTy.getTag();
1371 if (SPTag == dwarf::DW_TAG_subroutine_type)
1372 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1373 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1374 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1376 if (ATy.isArtificial())
1377 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1378 SPDie->addChild(Arg);
1380 DIE *SPDeclDie = SPDie;
1381 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1382 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1384 ModuleCU->addDie(SPDie);
1387 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1388 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1389 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1390 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1391 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1392 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1393 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1395 if (!DISubprogram(SPNode).isLocalToUnit())
1396 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1401 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1402 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1403 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1404 MCSymbol *Start = Scope->getStartLabel();
1405 MCSymbol *End = Scope->getEndLabel();
1406 if (Start == 0 || End == 0) return 0;
1408 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1409 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1411 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1412 if (Scope->isAbstractScope())
1415 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1416 Start ? Start : Asm->GetTempSymbol("func_begin",
1417 Asm->getFunctionNumber()));
1418 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1419 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1424 /// constructInlinedScopeDIE - This scope represents inlined body of
1425 /// a function. Construct DIE to represent this concrete inlined copy
1426 /// of the function.
1427 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1428 MCSymbol *StartLabel = Scope->getStartLabel();
1429 MCSymbol *EndLabel = Scope->getEndLabel();
1430 if (StartLabel == 0 || EndLabel == 0) return 0;
1432 assert(StartLabel->isDefined() &&
1433 "Invalid starting label for an inlined scope!");
1434 assert(EndLabel->isDefined() &&
1435 "Invalid end label for an inlined scope!");
1436 if (!Scope->getScopeNode())
1438 DIScope DS(Scope->getScopeNode());
1439 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1441 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1442 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1443 assert(OriginDIE && "Unable to find Origin DIE!");
1444 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1445 dwarf::DW_FORM_ref4, OriginDIE);
1447 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1448 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1450 InlinedSubprogramDIEs.insert(OriginDIE);
1452 // Track the start label for this inlined function.
1453 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1454 I = InlineInfo.find(InlinedSP.getNode());
1456 if (I == InlineInfo.end()) {
1457 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1459 InlinedSPNodes.push_back(InlinedSP.getNode());
1461 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1463 DILocation DL(Scope->getInlinedAt());
1464 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1465 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1471 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1472 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1473 // Get the descriptor.
1474 const DIVariable &VD = DV->getVariable();
1475 StringRef Name = VD.getName();
1479 // Translate tag to proper Dwarf tag. The result variable is dropped for
1482 switch (VD.getTag()) {
1483 case dwarf::DW_TAG_return_variable:
1485 case dwarf::DW_TAG_arg_variable:
1486 Tag = dwarf::DW_TAG_formal_parameter;
1488 case dwarf::DW_TAG_auto_variable: // fall thru
1490 Tag = dwarf::DW_TAG_variable;
1494 // Define variable debug information entry.
1495 DIE *VariableDie = new DIE(Tag);
1499 if (DbgVariable *AV = DV->getAbstractVariable())
1500 AbsDIE = AV->getDIE();
1503 DIScope DS(Scope->getScopeNode());
1504 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1505 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1507 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1508 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1509 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1510 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1511 dwarf::DW_FORM_ref4, AbsDIE);
1514 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1515 addSourceLine(VariableDie, &VD);
1517 // Add variable type.
1518 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1519 // addresses instead.
1520 if (VD.isBlockByrefVariable())
1521 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1523 addType(VariableDie, VD.getType());
1526 // Add variable address.
1527 if (!Scope->isAbstractScope()) {
1528 // Check if variable is described by DBG_VALUE instruction.
1529 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1530 if (DbgValueInsn->getNumOperands() == 3) {
1531 // FIXME : Handle getNumOperands != 3
1532 if (DbgValueInsn->getOperand(0).getType()
1533 == MachineOperand::MO_Register
1534 && DbgValueInsn->getOperand(0).getReg()) {
1535 MachineLocation Location;
1536 Location.set(DbgValueInsn->getOperand(0).getReg());
1537 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1538 if (MCSymbol *VS = DV->getDbgValueLabel())
1539 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1541 } else if (DbgValueInsn->getOperand(0).getType() ==
1542 MachineOperand::MO_Immediate) {
1543 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1544 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1545 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1546 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1547 if (MCSymbol *VS = DV->getDbgValueLabel())
1548 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1550 } else if (DbgValueInsn->getOperand(0).getType() ==
1551 MachineOperand::MO_FPImmediate) {
1552 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1553 APFloat FPImm = DbgValueInsn->getOperand(0).getFPImm()->getValueAPF();
1555 // Get the raw data form of the floating point.
1556 const APInt FltVal = FPImm.bitcastToAPInt();
1557 const char *FltPtr = (const char*)FltVal.getRawData();
1559 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
1560 bool LittleEndian = Asm->getTargetData().isLittleEndian();
1561 int Incr = (LittleEndian ? 1 : -1);
1562 int Start = (LittleEndian ? 0 : NumBytes - 1);
1563 int Stop = (LittleEndian ? NumBytes : -1);
1565 // Output the constant to DWARF one byte at a time.
1566 for (; Start != Stop; Start += Incr)
1567 addUInt(Block, 0, dwarf::DW_FORM_data1,
1568 (unsigned char)0xFF & FltPtr[Start]);
1570 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1572 if (MCSymbol *VS = DV->getDbgValueLabel())
1573 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1576 //FIXME : Handle other operand types.
1582 MachineLocation Location;
1584 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1585 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1587 Location.set(FrameReg, Offset);
1589 if (VD.hasComplexAddress())
1590 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1591 else if (VD.isBlockByrefVariable())
1592 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1594 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1598 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1599 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1600 DV->setDIE(VariableDie);
1605 void DwarfDebug::addPubTypes(DISubprogram SP) {
1606 DICompositeType SPTy = SP.getType();
1607 unsigned SPTag = SPTy.getTag();
1608 if (SPTag != dwarf::DW_TAG_subroutine_type)
1611 DIArray Args = SPTy.getTypeArray();
1612 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1613 DIType ATy(Args.getElement(i).getNode());
1616 DICompositeType CATy = getDICompositeType(ATy);
1617 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1618 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1619 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1624 /// constructScopeDIE - Construct a DIE for this scope.
1625 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1626 if (!Scope || !Scope->getScopeNode())
1629 DIScope DS(Scope->getScopeNode());
1630 DIE *ScopeDIE = NULL;
1631 if (Scope->getInlinedAt())
1632 ScopeDIE = constructInlinedScopeDIE(Scope);
1633 else if (DS.isSubprogram()) {
1634 if (Scope->isAbstractScope())
1635 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1637 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1640 ScopeDIE = constructLexicalScopeDIE(Scope);
1641 if (!ScopeDIE) return NULL;
1643 // Add variables to scope.
1644 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1645 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1646 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1648 ScopeDIE->addChild(VariableDIE);
1651 // Add nested scopes.
1652 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1653 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1654 // Define the Scope debug information entry.
1655 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1657 ScopeDIE->addChild(NestedDIE);
1660 if (DS.isSubprogram())
1661 addPubTypes(DISubprogram(DS.getNode()));
1666 /// GetOrCreateSourceID - Look up the source id with the given directory and
1667 /// source file names. If none currently exists, create a new id and insert it
1668 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1670 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1672 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1673 if (DI != DirectoryIdMap.end()) {
1674 DId = DI->getValue();
1676 DId = DirectoryNames.size() + 1;
1677 DirectoryIdMap[DirName] = DId;
1678 DirectoryNames.push_back(DirName);
1682 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1683 if (FI != SourceFileIdMap.end()) {
1684 FId = FI->getValue();
1686 FId = SourceFileNames.size() + 1;
1687 SourceFileIdMap[FileName] = FId;
1688 SourceFileNames.push_back(FileName);
1691 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1692 SourceIdMap.find(std::make_pair(DId, FId));
1693 if (SI != SourceIdMap.end())
1696 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1697 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1698 SourceIds.push_back(std::make_pair(DId, FId));
1703 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1704 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1705 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1708 NDie = new DIE(dwarf::DW_TAG_namespace);
1709 ModuleCU->insertDIE(NS.getNode(), NDie);
1710 if (!NS.getName().empty())
1711 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1712 addSourceLine(NDie, &NS);
1713 addToContextOwner(NDie, NS.getContext());
1717 void DwarfDebug::constructCompileUnit(MDNode *N) {
1718 DICompileUnit DIUnit(N);
1719 // Use first compile unit marked as isMain as the compile unit for this
1721 if (ModuleCU || !DIUnit.isMain())
1723 StringRef FN = DIUnit.getFilename();
1724 StringRef Dir = DIUnit.getDirectory();
1725 unsigned ID = GetOrCreateSourceID(Dir, FN);
1727 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1728 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1729 DIUnit.getProducer());
1730 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1731 DIUnit.getLanguage());
1732 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1733 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1734 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1735 Asm->GetTempSymbol("text_end"));
1736 // DW_AT_stmt_list is a offset of line number information for this
1737 // compile unit in debug_line section. It is always zero when only one
1738 // compile unit is emitted in one object file.
1739 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1742 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1743 if (DIUnit.isOptimized())
1744 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1746 StringRef Flags = DIUnit.getFlags();
1748 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1750 unsigned RVer = DIUnit.getRunTimeVersion();
1752 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1753 dwarf::DW_FORM_data1, RVer);
1756 "ModuleCU assigned since the top of constructCompileUnit");
1757 ModuleCU = new CompileUnit(ID, Die);
1760 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1761 DIGlobalVariable DI_GV(N);
1763 // If debug information is malformed then ignore it.
1764 if (DI_GV.Verify() == false)
1767 // Check for pre-existence.
1768 if (ModuleCU->getDIE(DI_GV.getNode()))
1771 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1776 ModuleCU->insertDIE(N, VariableDie);
1778 // Add to context owner.
1779 DIDescriptor GVContext = DI_GV.getContext();
1780 // Do not create specification DIE if context is either compile unit
1782 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1783 !GVContext.isFile() &&
1784 !isSubprogramContext(GVContext.getNode())) {
1785 // Create specification DIE.
1786 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1787 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1788 dwarf::DW_FORM_ref4, VariableDie);
1789 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1790 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1791 addLabel(Block, 0, dwarf::DW_FORM_udata,
1792 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1793 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1794 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1795 ModuleCU->addDie(VariableSpecDIE);
1797 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1798 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1799 addLabel(Block, 0, dwarf::DW_FORM_udata,
1800 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1801 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1803 addToContextOwner(VariableDie, GVContext);
1805 // Expose as global. FIXME - need to check external flag.
1806 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1808 DIType GTy = DI_GV.getType();
1809 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1810 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1811 assert(Entry && "Missing global type!");
1812 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1817 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1820 // Check for pre-existence.
1821 if (ModuleCU->getDIE(N))
1824 if (!SP.isDefinition())
1825 // This is a method declaration which will be handled while constructing
1829 DIE *SubprogramDie = createSubprogramDIE(SP);
1832 ModuleCU->insertDIE(N, SubprogramDie);
1834 // Add to context owner.
1835 addToContextOwner(SubprogramDie, SP.getContext());
1837 // Expose as global.
1838 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1843 /// beginModule - Emit all Dwarf sections that should come prior to the
1844 /// content. Create global DIEs and emit initial debug info sections.
1845 /// This is inovked by the target AsmPrinter.
1846 void DwarfDebug::beginModule(Module *M) {
1847 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
1849 DebugInfoFinder DbgFinder;
1850 DbgFinder.processModule(*M);
1852 bool HasDebugInfo = false;
1854 // Scan all the compile-units to see if there are any marked as the main unit.
1855 // if not, we do not generate debug info.
1856 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1857 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1858 if (DICompileUnit(*I).isMain()) {
1859 HasDebugInfo = true;
1864 if (!HasDebugInfo) return;
1866 // Tell MMI that we have debug info.
1867 MMI->setDebugInfoAvailability(true);
1869 // Emit initial sections.
1870 EmitSectionLabels();
1872 // Create all the compile unit DIEs.
1873 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1874 E = DbgFinder.compile_unit_end(); I != E; ++I)
1875 constructCompileUnit(*I);
1877 // Create DIEs for each subprogram.
1878 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1879 E = DbgFinder.subprogram_end(); I != E; ++I)
1880 constructSubprogramDIE(*I);
1882 // Create DIEs for each global variable.
1883 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1884 E = DbgFinder.global_variable_end(); I != E; ++I)
1885 constructGlobalVariableDIE(*I);
1887 // Prime section data.
1888 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1890 // Print out .file directives to specify files for .loc directives. These are
1891 // printed out early so that they precede any .loc directives.
1892 if (Asm->MAI->hasDotLocAndDotFile()) {
1893 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1894 // Remember source id starts at 1.
1895 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1896 // FIXME: don't use sys::path for this! This should not depend on the
1898 sys::Path FullPath(getSourceDirectoryName(Id.first));
1900 FullPath.appendComponent(getSourceFileName(Id.second));
1901 assert(AppendOk && "Could not append filename to directory!");
1903 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1908 /// endModule - Emit all Dwarf sections that should come after the content.
1910 void DwarfDebug::endModule() {
1911 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
1912 if (!ModuleCU) return;
1914 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1915 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1916 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1918 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1921 // Insert top level DIEs.
1922 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1923 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1924 ModuleCU->getCUDie()->addChild(*TI);
1926 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1927 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1928 DIE *SPDie = CI->first;
1929 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1931 DIE *NDie = ModuleCU->getDIE(N);
1932 if (!NDie) continue;
1933 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1934 // FIXME - This is not the correct approach.
1935 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
1938 // Standard sections final addresses.
1939 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1940 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1941 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1942 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1944 // End text sections.
1945 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1946 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1947 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1950 // Emit common frame information.
1951 emitCommonDebugFrame();
1953 // Emit function debug frame information
1954 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1955 E = DebugFrames.end(); I != E; ++I)
1956 emitFunctionDebugFrame(*I);
1958 // Compute DIE offsets and sizes.
1959 computeSizeAndOffsets();
1961 // Emit all the DIEs into a debug info section
1964 // Corresponding abbreviations into a abbrev section.
1965 emitAbbreviations();
1967 // Emit source line correspondence into a debug line section.
1970 // Emit info into a debug pubnames section.
1971 emitDebugPubNames();
1973 // Emit info into a debug pubtypes section.
1974 emitDebugPubTypes();
1976 // Emit info into a debug loc section.
1979 // Emit info into a debug aranges section.
1982 // Emit info into a debug ranges section.
1985 // Emit info into a debug macinfo section.
1988 // Emit inline info.
1989 emitDebugInlineInfo();
1991 // Emit info into a debug str section.
1995 ModuleCU = NULL; // Reset for the next Module, if any.
1998 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1999 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2001 DebugLoc ScopeLoc) {
2003 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
2005 return AbsDbgVariable;
2007 LLVMContext &Ctx = Var.getNode()->getContext();
2008 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2012 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
2013 NULL /* No more-abstract variable*/);
2014 Scope->addVariable(AbsDbgVariable);
2015 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2016 return AbsDbgVariable;
2019 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2020 /// FIXME : Refactor findAbstractVariable.
2021 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2022 const MachineInstr *MI,
2023 DebugLoc ScopeLoc) {
2025 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
2027 return AbsDbgVariable;
2029 LLVMContext &Ctx = Var.getNode()->getContext();
2030 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2034 AbsDbgVariable = new DbgVariable(Var, MI,
2035 NULL /* No more-abstract variable*/);
2036 Scope->addVariable(AbsDbgVariable);
2037 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2038 DbgValueStartMap[MI] = AbsDbgVariable;
2039 return AbsDbgVariable;
2042 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2043 void DwarfDebug::collectVariableInfo() {
2044 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2046 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2047 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2048 VE = VMap.end(); VI != VE; ++VI) {
2049 MDNode *Var = VI->first;
2052 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2054 DbgScope *Scope = 0;
2055 if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2056 Scope = ConcreteScopes.lookup(IA);
2058 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2060 // If variable scope is not found then skip this variable.
2064 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2065 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2066 Scope->addVariable(RegVar);
2069 // Collect variable information from DBG_VALUE machine instructions;
2070 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2072 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2074 const MachineInstr *MInsn = II;
2075 if (!MInsn->isDebugValue())
2078 // FIXME : Lift this restriction.
2079 if (MInsn->getNumOperands() != 3)
2081 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2082 - 1).getMetadata()));
2083 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2084 // FIXME Handle inlined subroutine arguments.
2085 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2086 CurrentFnDbgScope->addVariable(ArgVar);
2087 DbgValueStartMap[MInsn] = ArgVar;
2091 DebugLoc DL = MInsn->getDebugLoc();
2092 if (DL.isUnknown()) continue;
2093 DbgScope *Scope = 0;
2094 if (MDNode *IA = DL.getInlinedAt(Ctx))
2095 Scope = ConcreteScopes.lookup(IA);
2097 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2099 // If variable scope is not found then skip this variable.
2103 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2104 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2105 DbgValueStartMap[MInsn] = RegVar;
2106 Scope->addVariable(RegVar);
2111 /// beginScope - Process beginning of a scope.
2112 void DwarfDebug::beginScope(const MachineInstr *MI) {
2114 DebugLoc DL = MI->getDebugLoc();
2118 // Check and update last known location info.
2119 if (DL == PrevInstLoc)
2122 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2124 // FIXME: Should only verify each scope once!
2125 if (!DIScope(Scope).Verify())
2128 // DBG_VALUE instruction establishes new value.
2129 if (MI->isDebugValue()) {
2130 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2131 = DbgValueStartMap.find(MI);
2132 if (DI != DbgValueStartMap.end()) {
2133 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2135 DI->second->setDbgValueLabel(Label);
2140 // Emit a label to indicate location change. This is used for line
2141 // table even if this instruction does start a new scope.
2142 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2145 // update DbgScope if this instruction starts a new scope.
2146 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2147 if (I == DbgScopeBeginMap.end())
2150 ScopeVector &SD = I->second;
2151 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2153 (*SDI)->setStartLabel(Label);
2156 /// endScope - Process end of a scope.
2157 void DwarfDebug::endScope(const MachineInstr *MI) {
2158 // Ignore DBG_VALUE instruction.
2159 if (MI->isDebugValue())
2163 DebugLoc DL = MI->getDebugLoc();
2167 // Emit a label and update DbgScope if this instruction ends a scope.
2168 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2169 if (I == DbgScopeEndMap.end())
2172 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2173 Asm->OutStreamer.EmitLabel(Label);
2175 SmallVector<DbgScope*, 2> &SD = I->second;
2176 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2178 (*SDI)->setEndLabel(Label);
2182 /// createDbgScope - Create DbgScope for the scope.
2183 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2185 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2188 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2189 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2190 if (DIDescriptor(Scope).isLexicalBlock())
2191 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2195 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2199 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2200 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2201 DILocation DL(InlinedAt);
2202 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2205 /// extractScopeInformation - Scan machine instructions in this function
2206 /// and collect DbgScopes. Return true, if at least one scope was found.
2207 bool DwarfDebug::extractScopeInformation() {
2208 // If scope information was extracted using .dbg intrinsics then there is not
2209 // any need to extract these information by scanning each instruction.
2210 if (!DbgScopeMap.empty())
2213 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2214 unsigned MIIndex = 0;
2215 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2217 // Scan each instruction and create scopes. First build working set of scopes.
2218 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2220 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2222 const MachineInstr *MInsn = II;
2223 // FIXME : Remove DBG_VALUE check.
2224 if (MInsn->isDebugValue()) continue;
2225 MIIndexMap[MInsn] = MIIndex++;
2227 DebugLoc DL = MInsn->getDebugLoc();
2228 if (DL.isUnknown()) continue;
2230 MDNode *Scope = DL.getScope(Ctx);
2232 // There is no need to create another DIE for compile unit. For all
2233 // other scopes, create one DbgScope now. This will be translated
2234 // into a scope DIE at the end.
2235 if (DIScope(Scope).isCompileUnit()) continue;
2236 createDbgScope(Scope, DL.getInlinedAt(Ctx));
2241 // Build scope hierarchy using working set of scopes.
2242 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2244 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2246 const MachineInstr *MInsn = II;
2247 // FIXME : Remove DBG_VALUE check.
2248 if (MInsn->isDebugValue()) continue;
2249 DebugLoc DL = MInsn->getDebugLoc();
2250 if (DL.isUnknown()) continue;
2252 MDNode *Scope = DL.getScope(Ctx);
2253 if (Scope == 0) continue;
2255 // There is no need to create another DIE for compile unit. For all
2256 // other scopes, create one DbgScope now. This will be translated
2257 // into a scope DIE at the end.
2258 if (DIScope(Scope).isCompileUnit()) continue;
2259 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2260 DScope->setLastInsn(MInsn);
2264 if (!CurrentFnDbgScope)
2267 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2269 // Each scope has first instruction and last instruction to mark beginning
2270 // and end of a scope respectively. Create an inverse map that list scopes
2271 // starts (and ends) with an instruction. One instruction may start (or end)
2272 // multiple scopes. Ignore scopes that are not reachable.
2273 SmallVector<DbgScope *, 4> WorkList;
2274 WorkList.push_back(CurrentFnDbgScope);
2275 while (!WorkList.empty()) {
2276 DbgScope *S = WorkList.pop_back_val();
2278 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2279 if (!Children.empty())
2280 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2281 SE = Children.end(); SI != SE; ++SI)
2282 WorkList.push_back(*SI);
2284 if (S->isAbstractScope())
2286 const MachineInstr *MI = S->getFirstInsn();
2287 assert(MI && "DbgScope does not have first instruction!");
2289 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2290 if (IDI != DbgScopeBeginMap.end())
2291 IDI->second.push_back(S);
2293 DbgScopeBeginMap[MI].push_back(S);
2295 MI = S->getLastInsn();
2296 assert(MI && "DbgScope does not have last instruction!");
2297 IDI = DbgScopeEndMap.find(MI);
2298 if (IDI != DbgScopeEndMap.end())
2299 IDI->second.push_back(S);
2301 DbgScopeEndMap[MI].push_back(S);
2304 return !DbgScopeMap.empty();
2307 /// beginFunction - Gather pre-function debug information. Assumes being
2308 /// emitted immediately after the function entry point.
2309 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2310 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
2312 if (!MMI->hasDebugInfo()) return;
2313 if (!extractScopeInformation()) return;
2315 collectVariableInfo();
2317 // Assumes in correct section after the entry point.
2318 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2319 Asm->getFunctionNumber()));
2321 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2323 DebugLoc FDL = MF->getDefaultDebugLoc();
2324 if (FDL.isUnknown()) return;
2326 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2328 DISubprogram SP = getDISubprogram(Scope);
2331 Line = SP.getLineNumber();
2334 Line = FDL.getLine();
2338 recordSourceLine(Line, Col, Scope);
2341 /// endFunction - Gather and emit post-function debug information.
2343 void DwarfDebug::endFunction(const MachineFunction *MF) {
2344 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
2346 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2348 if (CurrentFnDbgScope) {
2349 // Define end label for subprogram.
2350 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2351 Asm->getFunctionNumber()));
2353 // Get function line info.
2354 if (!Lines.empty()) {
2355 // Get section line info.
2356 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2357 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2358 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2359 // Append the function info to section info.
2360 SectionLineInfos.insert(SectionLineInfos.end(),
2361 Lines.begin(), Lines.end());
2364 // Construct abstract scopes.
2365 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2366 AE = AbstractScopesList.end(); AI != AE; ++AI)
2367 constructScopeDIE(*AI);
2369 constructScopeDIE(CurrentFnDbgScope);
2371 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2372 MMI->getFrameMoves()));
2376 CurrentFnDbgScope = NULL;
2377 DeleteContainerSeconds(DbgScopeMap);
2378 DbgScopeBeginMap.clear();
2379 DbgScopeEndMap.clear();
2380 DbgValueStartMap.clear();
2381 ConcreteScopes.clear();
2382 DeleteContainerSeconds(AbstractScopes);
2383 AbstractScopesList.clear();
2384 AbstractVariables.clear();
2388 /// recordSourceLine - Register a source line with debug info. Returns the
2389 /// unique label that was emitted and which provides correspondence to
2390 /// the source line list.
2391 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2392 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
2397 DIDescriptor Scope(S);
2398 if (Scope.isCompileUnit()) {
2399 DICompileUnit CU(S);
2400 Dir = CU.getDirectory();
2401 Fn = CU.getFilename();
2402 } else if (Scope.isSubprogram()) {
2404 Dir = SP.getDirectory();
2405 Fn = SP.getFilename();
2406 } else if (Scope.isLexicalBlock()) {
2407 DILexicalBlock DB(S);
2408 Dir = DB.getDirectory();
2409 Fn = DB.getFilename();
2411 assert(0 && "Unexpected scope info");
2413 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2414 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2415 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2417 Asm->OutStreamer.EmitLabel(Label);
2421 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2422 /// timed. Look up the source id with the given directory and source file
2423 /// names. If none currently exists, create a new id and insert it in the
2424 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2426 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2427 const std::string &FileName) {
2428 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
2429 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2432 //===----------------------------------------------------------------------===//
2434 //===----------------------------------------------------------------------===//
2436 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2439 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2440 // Get the children.
2441 const std::vector<DIE *> &Children = Die->getChildren();
2443 // If not last sibling and has children then add sibling offset attribute.
2444 if (!Last && !Children.empty())
2445 Die->addSiblingOffset(DIEValueAllocator);
2447 // Record the abbreviation.
2448 assignAbbrevNumber(Die->getAbbrev());
2450 // Get the abbreviation for this DIE.
2451 unsigned AbbrevNumber = Die->getAbbrevNumber();
2452 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2455 Die->setOffset(Offset);
2457 // Start the size with the size of abbreviation code.
2458 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2460 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2461 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2463 // Size the DIE attribute values.
2464 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2465 // Size attribute value.
2466 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2468 // Size the DIE children if any.
2469 if (!Children.empty()) {
2470 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2471 "Children flag not set");
2473 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2474 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2476 // End of children marker.
2477 Offset += sizeof(int8_t);
2480 Die->setSize(Offset - Die->getOffset());
2484 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2486 void DwarfDebug::computeSizeAndOffsets() {
2487 // Compute size of compile unit header.
2488 static unsigned Offset =
2489 sizeof(int32_t) + // Length of Compilation Unit Info
2490 sizeof(int16_t) + // DWARF version number
2491 sizeof(int32_t) + // Offset Into Abbrev. Section
2492 sizeof(int8_t); // Pointer Size (in bytes)
2494 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2495 CompileUnitOffsets[ModuleCU] = 0;
2498 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2499 /// temporary label to it if SymbolStem is specified.
2500 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2501 const char *SymbolStem = 0) {
2502 Asm->OutStreamer.SwitchSection(Section);
2503 if (!SymbolStem) return 0;
2505 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2506 Asm->OutStreamer.EmitLabel(TmpSym);
2510 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2511 /// the start of each one.
2512 void DwarfDebug::EmitSectionLabels() {
2513 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2515 // Dwarf sections base addresses.
2516 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2517 DwarfFrameSectionSym =
2518 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2521 DwarfInfoSectionSym =
2522 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2523 DwarfAbbrevSectionSym =
2524 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2525 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2527 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2528 EmitSectionSym(Asm, MacroInfo);
2530 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2531 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2532 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2533 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2534 DwarfStrSectionSym =
2535 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2536 EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
2538 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2539 EmitSectionSym(Asm, TLOF.getDataSection());
2542 /// emitDIE - Recusively Emits a debug information entry.
2544 void DwarfDebug::emitDIE(DIE *Die) {
2545 // Get the abbreviation for this DIE.
2546 unsigned AbbrevNumber = Die->getAbbrevNumber();
2547 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2549 // Emit the code (index) for the abbreviation.
2550 if (Asm->isVerbose())
2551 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2552 Twine::utohexstr(Die->getOffset()) + ":0x" +
2553 Twine::utohexstr(Die->getSize()) + " " +
2554 dwarf::TagString(Abbrev->getTag()));
2555 Asm->EmitULEB128(AbbrevNumber);
2557 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2558 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2560 // Emit the DIE attribute values.
2561 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2562 unsigned Attr = AbbrevData[i].getAttribute();
2563 unsigned Form = AbbrevData[i].getForm();
2564 assert(Form && "Too many attributes for DIE (check abbreviation)");
2566 if (Asm->isVerbose())
2567 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2570 case dwarf::DW_AT_sibling:
2571 Asm->EmitInt32(Die->getSiblingOffset());
2573 case dwarf::DW_AT_abstract_origin: {
2574 DIEEntry *E = cast<DIEEntry>(Values[i]);
2575 DIE *Origin = E->getEntry();
2576 unsigned Addr = Origin->getOffset();
2577 Asm->EmitInt32(Addr);
2581 // Emit an attribute using the defined form.
2582 Values[i]->EmitValue(Asm, Form);
2587 // Emit the DIE children if any.
2588 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2589 const std::vector<DIE *> &Children = Die->getChildren();
2591 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2592 emitDIE(Children[j]);
2594 if (Asm->isVerbose())
2595 Asm->OutStreamer.AddComment("End Of Children Mark");
2600 /// emitDebugInfo - Emit the debug info section.
2602 void DwarfDebug::emitDebugInfo() {
2603 // Start debug info section.
2604 Asm->OutStreamer.SwitchSection(
2605 Asm->getObjFileLowering().getDwarfInfoSection());
2606 DIE *Die = ModuleCU->getCUDie();
2608 // Emit the compile units header.
2609 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2610 ModuleCU->getID()));
2612 // Emit size of content not including length itself
2613 unsigned ContentSize = Die->getSize() +
2614 sizeof(int16_t) + // DWARF version number
2615 sizeof(int32_t) + // Offset Into Abbrev. Section
2616 sizeof(int8_t) + // Pointer Size (in bytes)
2617 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2619 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2620 Asm->EmitInt32(ContentSize);
2621 Asm->OutStreamer.AddComment("DWARF version number");
2622 Asm->EmitInt16(dwarf::DWARF_VERSION);
2623 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2624 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2625 DwarfAbbrevSectionSym);
2626 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2627 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2630 // FIXME - extra padding for gdb bug.
2631 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2636 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2639 /// emitAbbreviations - Emit the abbreviation section.
2641 void DwarfDebug::emitAbbreviations() const {
2642 // Check to see if it is worth the effort.
2643 if (!Abbreviations.empty()) {
2644 // Start the debug abbrev section.
2645 Asm->OutStreamer.SwitchSection(
2646 Asm->getObjFileLowering().getDwarfAbbrevSection());
2648 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2650 // For each abbrevation.
2651 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2652 // Get abbreviation data
2653 const DIEAbbrev *Abbrev = Abbreviations[i];
2655 // Emit the abbrevations code (base 1 index.)
2656 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2658 // Emit the abbreviations data.
2662 // Mark end of abbreviations.
2663 Asm->EmitULEB128(0, "EOM(3)");
2665 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2669 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2670 /// the line matrix.
2672 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2673 // Define last address of section.
2674 Asm->OutStreamer.AddComment("Extended Op");
2677 Asm->OutStreamer.AddComment("Op size");
2678 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2679 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2680 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2682 Asm->OutStreamer.AddComment("Section end label");
2684 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2685 Asm->getTargetData().getPointerSize(),
2688 // Mark end of matrix.
2689 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2695 /// emitDebugLines - Emit source line information.
2697 void DwarfDebug::emitDebugLines() {
2698 // If the target is using .loc/.file, the assembler will be emitting the
2699 // .debug_line table automatically.
2700 if (Asm->MAI->hasDotLocAndDotFile())
2703 // Minimum line delta, thus ranging from -10..(255-10).
2704 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2705 // Maximum line delta, thus ranging from -10..(255-10).
2706 const int MaxLineDelta = 255 + MinLineDelta;
2708 // Start the dwarf line section.
2709 Asm->OutStreamer.SwitchSection(
2710 Asm->getObjFileLowering().getDwarfLineSection());
2712 // Construct the section header.
2713 Asm->OutStreamer.AddComment("Length of Source Line Info");
2714 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2715 Asm->GetTempSymbol("line_begin"), 4);
2716 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2718 Asm->OutStreamer.AddComment("DWARF version number");
2719 Asm->EmitInt16(dwarf::DWARF_VERSION);
2721 Asm->OutStreamer.AddComment("Prolog Length");
2722 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2723 Asm->GetTempSymbol("line_prolog_begin"), 4);
2724 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2726 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2728 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2730 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2731 Asm->EmitInt8(MinLineDelta);
2732 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2733 Asm->EmitInt8(MaxLineDelta);
2734 Asm->OutStreamer.AddComment("Special Opcode Base");
2735 Asm->EmitInt8(-MinLineDelta);
2737 // Line number standard opcode encodings argument count
2738 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2740 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2742 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2744 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2746 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2748 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2750 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2752 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2754 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2757 // Emit directories.
2758 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2759 const std::string &Dir = getSourceDirectoryName(DI);
2760 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2761 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2764 Asm->OutStreamer.AddComment("End of directories");
2768 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2769 // Remember source id starts at 1.
2770 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2771 const std::string &FN = getSourceFileName(Id.second);
2772 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2773 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2775 Asm->EmitULEB128(Id.first, "Directory #");
2776 Asm->EmitULEB128(0, "Mod date");
2777 Asm->EmitULEB128(0, "File size");
2780 Asm->OutStreamer.AddComment("End of files");
2783 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2785 // A sequence for each text section.
2786 unsigned SecSrcLinesSize = SectionSourceLines.size();
2788 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2789 // Isolate current sections line info.
2790 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2792 // Dwarf assumes we start with first line of first source file.
2793 unsigned Source = 1;
2796 // Construct rows of the address, source, line, column matrix.
2797 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2798 const SrcLineInfo &LineInfo = LineInfos[i];
2799 MCSymbol *Label = LineInfo.getLabel();
2800 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2802 if (LineInfo.getLine() == 0) continue;
2804 if (Asm->isVerbose()) {
2805 std::pair<unsigned, unsigned> SrcID =
2806 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2807 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2809 Twine(getSourceFileName(SrcID.second)) +
2810 ":" + Twine(LineInfo.getLine()));
2813 // Define the line address.
2814 Asm->OutStreamer.AddComment("Extended Op");
2816 Asm->OutStreamer.AddComment("Op size");
2817 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2819 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2820 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2822 Asm->OutStreamer.AddComment("Location label");
2823 Asm->OutStreamer.EmitSymbolValue(Label,
2824 Asm->getTargetData().getPointerSize(),
2827 // If change of source, then switch to the new source.
2828 if (Source != LineInfo.getSourceID()) {
2829 Source = LineInfo.getSourceID();
2830 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2831 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2832 Asm->EmitULEB128(Source, "New Source");
2835 // If change of line.
2836 if (Line != LineInfo.getLine()) {
2837 // Determine offset.
2838 int Offset = LineInfo.getLine() - Line;
2839 int Delta = Offset - MinLineDelta;
2842 Line = LineInfo.getLine();
2844 // If delta is small enough and in range...
2845 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2846 // ... then use fast opcode.
2847 Asm->OutStreamer.AddComment("Line Delta");
2848 Asm->EmitInt8(Delta - MinLineDelta);
2850 // ... otherwise use long hand.
2851 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2852 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2853 Asm->EmitSLEB128(Offset, "Line Offset");
2854 Asm->OutStreamer.AddComment("DW_LNS_copy");
2855 Asm->EmitInt8(dwarf::DW_LNS_copy);
2858 // Copy the previous row (different address or source)
2859 Asm->OutStreamer.AddComment("DW_LNS_copy");
2860 Asm->EmitInt8(dwarf::DW_LNS_copy);
2864 emitEndOfLineMatrix(j + 1);
2867 if (SecSrcLinesSize == 0)
2868 // Because we're emitting a debug_line section, we still need a line
2869 // table. The linker and friends expect it to exist. If there's nothing to
2870 // put into it, emit an empty table.
2871 emitEndOfLineMatrix(1);
2873 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2876 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2878 void DwarfDebug::emitCommonDebugFrame() {
2879 if (!Asm->MAI->doesDwarfRequireFrameSection())
2882 int stackGrowth = Asm->getTargetData().getPointerSize();
2883 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2884 TargetFrameInfo::StackGrowsDown)
2887 // Start the dwarf frame section.
2888 Asm->OutStreamer.SwitchSection(
2889 Asm->getObjFileLowering().getDwarfFrameSection());
2891 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2892 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2893 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2894 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2896 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2897 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2898 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2899 Asm->OutStreamer.AddComment("CIE Version");
2900 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2901 Asm->OutStreamer.AddComment("CIE Augmentation");
2902 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2903 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2904 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2905 Asm->OutStreamer.AddComment("CIE RA Column");
2906 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2907 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2909 std::vector<MachineMove> Moves;
2910 RI->getInitialFrameState(Moves);
2912 Asm->EmitFrameMoves(Moves, 0, false);
2914 Asm->EmitAlignment(2, 0, 0, false);
2915 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2918 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2921 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2922 if (!Asm->MAI->doesDwarfRequireFrameSection())
2925 // Start the dwarf frame section.
2926 Asm->OutStreamer.SwitchSection(
2927 Asm->getObjFileLowering().getDwarfFrameSection());
2929 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2930 MCSymbol *DebugFrameBegin =
2931 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2932 MCSymbol *DebugFrameEnd =
2933 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2934 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2936 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2938 Asm->OutStreamer.AddComment("FDE CIE offset");
2939 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2940 DwarfFrameSectionSym);
2942 Asm->OutStreamer.AddComment("FDE initial location");
2943 MCSymbol *FuncBeginSym =
2944 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2945 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2946 Asm->getTargetData().getPointerSize(),
2950 Asm->OutStreamer.AddComment("FDE address range");
2951 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2952 FuncBeginSym, Asm->getTargetData().getPointerSize());
2954 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2956 Asm->EmitAlignment(2, 0, 0, false);
2957 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2960 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2962 void DwarfDebug::emitDebugPubNames() {
2963 // Start the dwarf pubnames section.
2964 Asm->OutStreamer.SwitchSection(
2965 Asm->getObjFileLowering().getDwarfPubNamesSection());
2967 Asm->OutStreamer.AddComment("Length of Public Names Info");
2968 Asm->EmitLabelDifference(
2969 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2970 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2972 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2973 ModuleCU->getID()));
2975 Asm->OutStreamer.AddComment("DWARF Version");
2976 Asm->EmitInt16(dwarf::DWARF_VERSION);
2978 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2979 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2980 DwarfInfoSectionSym);
2982 Asm->OutStreamer.AddComment("Compilation Unit Length");
2983 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2984 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2987 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2988 for (StringMap<DIE*>::const_iterator
2989 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2990 const char *Name = GI->getKeyData();
2991 DIE *Entity = GI->second;
2993 Asm->OutStreamer.AddComment("DIE offset");
2994 Asm->EmitInt32(Entity->getOffset());
2996 if (Asm->isVerbose())
2997 Asm->OutStreamer.AddComment("External Name");
2998 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3001 Asm->OutStreamer.AddComment("End Mark");
3003 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3004 ModuleCU->getID()));
3007 void DwarfDebug::emitDebugPubTypes() {
3008 // Start the dwarf pubnames section.
3009 Asm->OutStreamer.SwitchSection(
3010 Asm->getObjFileLowering().getDwarfPubTypesSection());
3011 Asm->OutStreamer.AddComment("Length of Public Types Info");
3012 Asm->EmitLabelDifference(
3013 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
3014 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
3016 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3017 ModuleCU->getID()));
3019 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3020 Asm->EmitInt16(dwarf::DWARF_VERSION);
3022 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
3023 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3024 DwarfInfoSectionSym);
3026 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
3027 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
3028 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3031 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
3032 for (StringMap<DIE*>::const_iterator
3033 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3034 const char *Name = GI->getKeyData();
3035 DIE * Entity = GI->second;
3037 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3038 Asm->EmitInt32(Entity->getOffset());
3040 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3041 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3044 Asm->OutStreamer.AddComment("End Mark");
3046 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3047 ModuleCU->getID()));
3050 /// emitDebugStr - Emit visible names into a debug str section.
3052 void DwarfDebug::emitDebugStr() {
3053 // Check to see if it is worth the effort.
3054 if (StringPool.empty()) return;
3056 // Start the dwarf str section.
3057 Asm->OutStreamer.SwitchSection(
3058 Asm->getObjFileLowering().getDwarfStrSection());
3060 // Get all of the string pool entries and put them in an array by their ID so
3061 // we can sort them.
3062 SmallVector<std::pair<unsigned,
3063 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3065 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3066 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3067 Entries.push_back(std::make_pair(I->second.second, &*I));
3069 array_pod_sort(Entries.begin(), Entries.end());
3071 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3072 // Emit a label for reference from debug information entries.
3073 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3075 // Emit the string itself.
3076 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3080 /// emitDebugLoc - Emit visible names into a debug loc section.
3082 void DwarfDebug::emitDebugLoc() {
3083 // Start the dwarf loc section.
3084 Asm->OutStreamer.SwitchSection(
3085 Asm->getObjFileLowering().getDwarfLocSection());
3088 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3090 void DwarfDebug::EmitDebugARanges() {
3091 // Start the dwarf aranges section.
3092 Asm->OutStreamer.SwitchSection(
3093 Asm->getObjFileLowering().getDwarfARangesSection());
3096 /// emitDebugRanges - Emit visible names into a debug ranges section.
3098 void DwarfDebug::emitDebugRanges() {
3099 // Start the dwarf ranges section.
3100 Asm->OutStreamer.SwitchSection(
3101 Asm->getObjFileLowering().getDwarfRangesSection());
3104 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3106 void DwarfDebug::emitDebugMacInfo() {
3107 if (const MCSection *LineInfo =
3108 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3109 // Start the dwarf macinfo section.
3110 Asm->OutStreamer.SwitchSection(LineInfo);
3114 /// emitDebugInlineInfo - Emit inline info using following format.
3116 /// 1. length of section
3117 /// 2. Dwarf version number
3118 /// 3. address size.
3120 /// Entries (one "entry" for each function that was inlined):
3122 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3123 /// otherwise offset into __debug_str for regular function name.
3124 /// 2. offset into __debug_str section for regular function name.
3125 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3126 /// instances for the function.
3128 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3129 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3130 /// __debug_info section, and the low_pc is the starting address for the
3131 /// inlining instance.
3132 void DwarfDebug::emitDebugInlineInfo() {
3133 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3139 Asm->OutStreamer.SwitchSection(
3140 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3142 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3143 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3144 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3146 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3148 Asm->OutStreamer.AddComment("Dwarf Version");
3149 Asm->EmitInt16(dwarf::DWARF_VERSION);
3150 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3151 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3153 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3154 E = InlinedSPNodes.end(); I != E; ++I) {
3157 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3158 = InlineInfo.find(Node);
3159 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3160 DISubprogram SP(Node);
3161 StringRef LName = SP.getLinkageName();
3162 StringRef Name = SP.getName();
3164 Asm->OutStreamer.AddComment("MIPS linkage name");
3165 if (LName.empty()) {
3166 Asm->OutStreamer.EmitBytes(Name, 0);
3167 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3169 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3170 DwarfStrSectionSym);
3172 Asm->OutStreamer.AddComment("Function name");
3173 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3174 Asm->EmitULEB128(Labels.size(), "Inline count");
3176 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3177 LE = Labels.end(); LI != LE; ++LI) {
3178 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3179 Asm->EmitInt32(LI->second->getOffset());
3181 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3182 Asm->OutStreamer.EmitSymbolValue(LI->first,
3183 Asm->getTargetData().getPointerSize(),0);
3187 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));