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;
319 if (TimePassesIsEnabled) {
320 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
326 DwarfDebug::~DwarfDebug() {
327 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
328 DIEBlocks[j]->~DIEBlock();
331 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
332 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
333 if (Entry.first) return Entry.first;
335 Entry.second = NextStringPoolNumber++;
336 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
340 /// assignAbbrevNumber - Define a unique number for the abbreviation.
342 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
343 // Profile the node so that we can make it unique.
347 // Check the set for priors.
348 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
350 // If it's newly added.
351 if (InSet == &Abbrev) {
352 // Add to abbreviation list.
353 Abbreviations.push_back(&Abbrev);
355 // Assign the vector position + 1 as its number.
356 Abbrev.setNumber(Abbreviations.size());
358 // Assign existing abbreviation number.
359 Abbrev.setNumber(InSet->getNumber());
363 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
364 /// information entry.
365 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
366 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
370 /// addUInt - Add an unsigned integer attribute data and value.
372 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
373 unsigned Form, uint64_t Integer) {
374 if (!Form) Form = DIEInteger::BestForm(false, Integer);
375 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
376 Die->addValue(Attribute, Form, Value);
379 /// addSInt - Add an signed integer attribute data and value.
381 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
382 unsigned Form, int64_t Integer) {
383 if (!Form) Form = DIEInteger::BestForm(true, Integer);
384 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
385 Die->addValue(Attribute, Form, Value);
388 /// addString - Add a string attribute data and value. DIEString only
389 /// keeps string reference.
390 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
392 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
393 Die->addValue(Attribute, Form, Value);
396 /// addLabel - Add a Dwarf label attribute data and value.
398 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
399 const MCSymbol *Label) {
400 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
401 Die->addValue(Attribute, Form, Value);
404 /// addDelta - Add a label delta attribute data and value.
406 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
407 const MCSymbol *Hi, const MCSymbol *Lo) {
408 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
409 Die->addValue(Attribute, Form, Value);
412 /// addDIEEntry - Add a DIE attribute data and value.
414 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
416 Die->addValue(Attribute, Form, createDIEEntry(Entry));
420 /// addBlock - Add block data.
422 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
424 Block->ComputeSize(Asm);
425 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
426 Die->addValue(Attribute, Block->BestForm(), Block);
429 /// addSourceLine - Add location information to specified debug information
431 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
432 // If there is no compile unit specified, don't add a line #.
433 if (!V->getCompileUnit().Verify())
436 unsigned Line = V->getLineNumber();
437 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
438 V->getContext().getFilename());
439 assert(FileID && "Invalid file id");
440 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
441 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
444 /// addSourceLine - Add location information to specified debug information
446 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
447 // If there is no compile unit specified, don't add a line #.
448 if (!G->getCompileUnit().Verify())
451 unsigned Line = G->getLineNumber();
452 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
453 G->getContext().getFilename());
454 assert(FileID && "Invalid file id");
455 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
456 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
459 /// addSourceLine - Add location information to specified debug information
461 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
462 // If there is no compile unit specified, don't add a line #.
463 if (!SP->getCompileUnit().Verify())
465 // If the line number is 0, don't add it.
466 if (SP->getLineNumber() == 0)
469 unsigned Line = SP->getLineNumber();
470 if (!SP->getContext().Verify())
472 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
474 assert(FileID && "Invalid file id");
475 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
476 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
479 /// addSourceLine - Add location information to specified debug information
481 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
482 // If there is no compile unit specified, don't add a line #.
483 DICompileUnit CU = Ty->getCompileUnit();
487 unsigned Line = Ty->getLineNumber();
488 if (!Ty->getContext().Verify())
490 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
491 Ty->getContext().getFilename());
492 assert(FileID && "Invalid file id");
493 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
494 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
497 /// addSourceLine - Add location information to specified debug information
499 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
500 // If there is no compile unit specified, don't add a line #.
501 if (!NS->getCompileUnit().Verify())
504 unsigned Line = NS->getLineNumber();
505 StringRef FN = NS->getFilename();
506 StringRef Dir = NS->getDirectory();
508 unsigned FileID = GetOrCreateSourceID(Dir, FN);
509 assert(FileID && "Invalid file id");
510 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
511 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
514 /* Byref variables, in Blocks, are declared by the programmer as
515 "SomeType VarName;", but the compiler creates a
516 __Block_byref_x_VarName struct, and gives the variable VarName
517 either the struct, or a pointer to the struct, as its type. This
518 is necessary for various behind-the-scenes things the compiler
519 needs to do with by-reference variables in blocks.
521 However, as far as the original *programmer* is concerned, the
522 variable should still have type 'SomeType', as originally declared.
524 The following function dives into the __Block_byref_x_VarName
525 struct to find the original type of the variable. This will be
526 passed back to the code generating the type for the Debug
527 Information Entry for the variable 'VarName'. 'VarName' will then
528 have the original type 'SomeType' in its debug information.
530 The original type 'SomeType' will be the type of the field named
531 'VarName' inside the __Block_byref_x_VarName struct.
533 NOTE: In order for this to not completely fail on the debugger
534 side, the Debug Information Entry for the variable VarName needs to
535 have a DW_AT_location that tells the debugger how to unwind through
536 the pointers and __Block_byref_x_VarName struct to find the actual
537 value of the variable. The function addBlockByrefType does this. */
539 /// Find the type the programmer originally declared the variable to be
540 /// and return that type.
542 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
545 unsigned tag = Ty.getTag();
547 if (tag == dwarf::DW_TAG_pointer_type) {
548 DIDerivedType DTy = DIDerivedType(Ty.getNode());
549 subType = DTy.getTypeDerivedFrom();
552 DICompositeType blockStruct = DICompositeType(subType.getNode());
553 DIArray Elements = blockStruct.getTypeArray();
555 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
556 DIDescriptor Element = Elements.getElement(i);
557 DIDerivedType DT = DIDerivedType(Element.getNode());
558 if (Name == DT.getName())
559 return (DT.getTypeDerivedFrom());
565 /// addComplexAddress - Start with the address based on the location provided,
566 /// and generate the DWARF information necessary to find the actual variable
567 /// given the extra address information encoded in the DIVariable, starting from
568 /// the starting location. Add the DWARF information to the die.
570 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
572 const MachineLocation &Location) {
573 const DIVariable &VD = DV->getVariable();
574 DIType Ty = VD.getType();
576 // Decode the original location, and use that as the start of the byref
577 // variable's location.
578 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
579 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
580 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
582 if (Location.isReg()) {
584 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
586 Reg = Reg - dwarf::DW_OP_reg0;
587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
588 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
592 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
594 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
595 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
598 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
601 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
602 uint64_t Element = VD.getAddrElement(i);
604 if (Element == DIFactory::OpPlus) {
605 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
606 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
607 } else if (Element == DIFactory::OpDeref) {
608 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
609 } else llvm_unreachable("unknown DIFactory Opcode");
612 // Now attach the location information to the DIE.
613 addBlock(Die, Attribute, 0, Block);
616 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
617 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
618 gives the variable VarName either the struct, or a pointer to the struct, as
619 its type. This is necessary for various behind-the-scenes things the
620 compiler needs to do with by-reference variables in Blocks.
622 However, as far as the original *programmer* is concerned, the variable
623 should still have type 'SomeType', as originally declared.
625 The function getBlockByrefType dives into the __Block_byref_x_VarName
626 struct to find the original type of the variable, which is then assigned to
627 the variable's Debug Information Entry as its real type. So far, so good.
628 However now the debugger will expect the variable VarName to have the type
629 SomeType. So we need the location attribute for the variable to be an
630 expression that explains to the debugger how to navigate through the
631 pointers and struct to find the actual variable of type SomeType.
633 The following function does just that. We start by getting
634 the "normal" location for the variable. This will be the location
635 of either the struct __Block_byref_x_VarName or the pointer to the
636 struct __Block_byref_x_VarName.
638 The struct will look something like:
640 struct __Block_byref_x_VarName {
642 struct __Block_byref_x_VarName *forwarding;
643 ... <various other fields>
645 ... <maybe more fields>
648 If we are given the struct directly (as our starting point) we
649 need to tell the debugger to:
651 1). Add the offset of the forwarding field.
653 2). Follow that pointer to get the real __Block_byref_x_VarName
654 struct to use (the real one may have been copied onto the heap).
656 3). Add the offset for the field VarName, to find the actual variable.
658 If we started with a pointer to the struct, then we need to
659 dereference that pointer first, before the other steps.
660 Translating this into DWARF ops, we will need to append the following
661 to the current location description for the variable:
663 DW_OP_deref -- optional, if we start with a pointer
664 DW_OP_plus_uconst <forward_fld_offset>
666 DW_OP_plus_uconst <varName_fld_offset>
668 That is what this function does. */
670 /// addBlockByrefAddress - Start with the address based on the location
671 /// provided, and generate the DWARF information necessary to find the
672 /// actual Block variable (navigating the Block struct) based on the
673 /// starting location. Add the DWARF information to the die. For
674 /// more information, read large comment just above here.
676 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
678 const MachineLocation &Location) {
679 const DIVariable &VD = DV->getVariable();
680 DIType Ty = VD.getType();
682 unsigned Tag = Ty.getTag();
683 bool isPointer = false;
685 StringRef varName = VD.getName();
687 if (Tag == dwarf::DW_TAG_pointer_type) {
688 DIDerivedType DTy = DIDerivedType(Ty.getNode());
689 TmpTy = DTy.getTypeDerivedFrom();
693 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
695 // Find the __forwarding field and the variable field in the __Block_byref
697 DIArray Fields = blockStruct.getTypeArray();
698 DIDescriptor varField = DIDescriptor();
699 DIDescriptor forwardingField = DIDescriptor();
701 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
702 DIDescriptor Element = Fields.getElement(i);
703 DIDerivedType DT = DIDerivedType(Element.getNode());
704 StringRef fieldName = DT.getName();
705 if (fieldName == "__forwarding")
706 forwardingField = Element;
707 else if (fieldName == varName)
711 // Get the offsets for the forwarding field and the variable field.
712 unsigned forwardingFieldOffset =
713 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
714 unsigned varFieldOffset =
715 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
717 // Decode the original location, and use that as the start of the byref
718 // variable's location.
719 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
720 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
721 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
723 if (Location.isReg()) {
725 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
727 Reg = Reg - dwarf::DW_OP_reg0;
728 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
729 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
736 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
739 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
742 // If we started with a pointer to the __Block_byref... struct, then
743 // the first thing we need to do is dereference the pointer (DW_OP_deref).
745 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
747 // Next add the offset for the '__forwarding' field:
748 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
749 // adding the offset if it's 0.
750 if (forwardingFieldOffset > 0) {
751 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
752 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
755 // Now dereference the __forwarding field to get to the real __Block_byref
756 // struct: DW_OP_deref.
757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
759 // Now that we've got the real __Block_byref... struct, add the offset
760 // for the variable's field to get to the location of the actual variable:
761 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
762 if (varFieldOffset > 0) {
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
764 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
767 // Now attach the location information to the DIE.
768 addBlock(Die, Attribute, 0, Block);
771 /// addAddress - Add an address attribute to a die based on the location
773 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
774 const MachineLocation &Location) {
775 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
776 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
777 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
779 if (Location.isReg()) {
781 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
783 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
784 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
788 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
790 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
791 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
794 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
797 addBlock(Die, Attribute, 0, Block);
800 /// addToContextOwner - Add Die into the list of its context owner's children.
801 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
802 if (Context.isType()) {
803 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
804 ContextDIE->addChild(Die);
805 } else if (Context.isNameSpace()) {
806 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
807 ContextDIE->addChild(Die);
808 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
809 ContextDIE->addChild(Die);
811 ModuleCU->addDie(Die);
814 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
816 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
817 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
822 TyDIE = new DIE(dwarf::DW_TAG_base_type);
823 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
824 if (Ty.isBasicType())
825 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
826 else if (Ty.isCompositeType())
827 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
829 assert(Ty.isDerivedType() && "Unknown kind of DIType");
830 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
833 addToContextOwner(TyDIE, Ty.getContext());
837 /// addType - Add a new type attribute to the specified entity.
838 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
842 // Check for pre-existence.
843 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
844 // If it exists then use the existing value.
846 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
851 DIE *Buffer = getOrCreateTypeDIE(Ty);
854 Entry = createDIEEntry(Buffer);
855 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
857 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
860 /// constructTypeDIE - Construct basic type die from DIBasicType.
861 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
862 // Get core information.
863 StringRef Name = BTy.getName();
864 Buffer.setTag(dwarf::DW_TAG_base_type);
865 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
868 // Add name if not anonymous or intermediate type.
870 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
871 uint64_t Size = BTy.getSizeInBits() >> 3;
872 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
875 /// constructTypeDIE - Construct derived type die from DIDerivedType.
876 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
877 // Get core information.
878 StringRef Name = DTy.getName();
879 uint64_t Size = DTy.getSizeInBits() >> 3;
880 unsigned Tag = DTy.getTag();
882 // FIXME - Workaround for templates.
883 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
887 // Map to main type, void will not have a type.
888 DIType FromTy = DTy.getTypeDerivedFrom();
889 addType(&Buffer, FromTy);
891 // Add name if not anonymous or intermediate type.
893 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
895 // Add size if non-zero (derived types might be zero-sized.)
897 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
899 // Add source line info if available and TyDesc is not a forward declaration.
900 if (!DTy.isForwardDecl())
901 addSourceLine(&Buffer, &DTy);
904 /// constructTypeDIE - Construct type DIE from DICompositeType.
905 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
906 // Get core information.
907 StringRef Name = CTy.getName();
909 uint64_t Size = CTy.getSizeInBits() >> 3;
910 unsigned Tag = CTy.getTag();
914 case dwarf::DW_TAG_vector_type:
915 case dwarf::DW_TAG_array_type:
916 constructArrayTypeDIE(Buffer, &CTy);
918 case dwarf::DW_TAG_enumeration_type: {
919 DIArray Elements = CTy.getTypeArray();
921 // Add enumerators to enumeration type.
922 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
924 DIDescriptor Enum(Elements.getElement(i).getNode());
925 if (Enum.isEnumerator()) {
926 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
927 Buffer.addChild(ElemDie);
932 case dwarf::DW_TAG_subroutine_type: {
934 DIArray Elements = CTy.getTypeArray();
935 DIDescriptor RTy = Elements.getElement(0);
936 addType(&Buffer, DIType(RTy.getNode()));
938 // Add prototype flag.
939 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
942 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
943 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
944 DIDescriptor Ty = Elements.getElement(i);
945 addType(Arg, DIType(Ty.getNode()));
946 Buffer.addChild(Arg);
950 case dwarf::DW_TAG_structure_type:
951 case dwarf::DW_TAG_union_type:
952 case dwarf::DW_TAG_class_type: {
953 // Add elements to structure type.
954 DIArray Elements = CTy.getTypeArray();
956 // A forward struct declared type may not have elements available.
957 unsigned N = Elements.getNumElements();
961 // Add elements to structure type.
962 for (unsigned i = 0; i < N; ++i) {
963 DIDescriptor Element = Elements.getElement(i);
965 if (Element.isSubprogram())
966 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
967 else if (Element.isVariable()) {
968 DIVariable DV(Element.getNode());
969 ElemDie = new DIE(dwarf::DW_TAG_variable);
970 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
972 addType(ElemDie, DV.getType());
973 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
974 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
975 addSourceLine(ElemDie, &DV);
976 } else if (Element.isDerivedType())
977 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
980 Buffer.addChild(ElemDie);
983 if (CTy.isAppleBlockExtension())
984 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
986 unsigned RLang = CTy.getRunTimeLang();
988 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
989 dwarf::DW_FORM_data1, RLang);
991 DICompositeType ContainingType = CTy.getContainingType();
992 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
993 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
994 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
1001 // Add name if not anonymous or intermediate type.
1003 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1005 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1006 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1007 // Add size if non-zero (derived types might be zero-sized.)
1009 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1011 // Add zero size if it is not a forward declaration.
1012 if (CTy.isForwardDecl())
1013 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1015 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1018 // Add source line info if available.
1019 if (!CTy.isForwardDecl())
1020 addSourceLine(&Buffer, &CTy);
1024 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1025 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1026 int64_t L = SR.getLo();
1027 int64_t H = SR.getHi();
1028 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1030 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1032 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1033 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1035 Buffer.addChild(DW_Subrange);
1038 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1039 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1040 DICompositeType *CTy) {
1041 Buffer.setTag(dwarf::DW_TAG_array_type);
1042 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1043 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1045 // Emit derived type.
1046 addType(&Buffer, CTy->getTypeDerivedFrom());
1047 DIArray Elements = CTy->getTypeArray();
1049 // Get an anonymous type for index type.
1050 DIE *IdxTy = ModuleCU->getIndexTyDie();
1052 // Construct an anonymous type for index type.
1053 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1054 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1055 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1056 dwarf::DW_ATE_signed);
1057 ModuleCU->addDie(IdxTy);
1058 ModuleCU->setIndexTyDie(IdxTy);
1061 // Add subranges to array type.
1062 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1063 DIDescriptor Element = Elements.getElement(i);
1064 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1065 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1069 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1070 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1071 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1072 StringRef Name = ETy.getName();
1073 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1074 int64_t Value = ETy.getEnumValue();
1075 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1079 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1080 /// printer to not emit usual symbol prefix before the symbol name is used then
1081 /// return linkage name after skipping this special LLVM prefix.
1082 static StringRef getRealLinkageName(StringRef LinkageName) {
1084 if (LinkageName.startswith(StringRef(&One, 1)))
1085 return LinkageName.substr(1);
1089 /// createGlobalVariableDIE - Create new DIE using GV.
1090 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1091 // If the global variable was optmized out then no need to create debug info
1093 if (!GV.getGlobal()) return NULL;
1094 if (GV.getDisplayName().empty()) return NULL;
1096 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1097 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1098 GV.getDisplayName());
1100 StringRef LinkageName = GV.getLinkageName();
1101 if (!LinkageName.empty())
1102 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1103 getRealLinkageName(LinkageName));
1105 addType(GVDie, GV.getType());
1106 if (!GV.isLocalToUnit())
1107 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1108 addSourceLine(GVDie, &GV);
1113 /// createMemberDIE - Create new member DIE.
1114 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1115 DIE *MemberDie = new DIE(DT.getTag());
1116 StringRef Name = DT.getName();
1118 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1120 addType(MemberDie, DT.getTypeDerivedFrom());
1122 addSourceLine(MemberDie, &DT);
1124 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1125 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1127 uint64_t Size = DT.getSizeInBits();
1128 uint64_t FieldSize = DT.getOriginalTypeSize();
1130 if (Size != FieldSize) {
1132 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1133 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1135 uint64_t Offset = DT.getOffsetInBits();
1136 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1137 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1138 uint64_t FieldOffset = (HiMark - FieldSize);
1139 Offset -= FieldOffset;
1141 // Maybe we need to work from the other end.
1142 if (Asm->getTargetData().isLittleEndian())
1143 Offset = FieldSize - (Offset + Size);
1144 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1146 // Here WD_AT_data_member_location points to the anonymous
1147 // field that includes this bit field.
1148 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1151 // This is not a bitfield.
1152 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1154 if (DT.getTag() == dwarf::DW_TAG_inheritance
1155 && DT.isVirtual()) {
1157 // For C++, virtual base classes are not at fixed offset. Use following
1158 // expression to extract appropriate offset from vtable.
1159 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1161 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1162 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1163 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1164 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1165 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1166 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1167 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1168 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1170 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1173 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1175 if (DT.isProtected())
1176 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1177 dwarf::DW_ACCESS_protected);
1178 else if (DT.isPrivate())
1179 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1180 dwarf::DW_ACCESS_private);
1181 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1182 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1183 dwarf::DW_ACCESS_public);
1185 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1186 dwarf::DW_VIRTUALITY_virtual);
1190 /// createSubprogramDIE - Create new DIE using SP.
1191 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1192 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1196 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1197 // Constructors and operators for anonymous aggregates do not have names.
1198 if (!SP.getName().empty())
1199 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1201 StringRef LinkageName = SP.getLinkageName();
1202 if (!LinkageName.empty())
1203 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1204 getRealLinkageName(LinkageName));
1206 addSourceLine(SPDie, &SP);
1208 // Add prototyped tag, if C or ObjC.
1209 unsigned Lang = SP.getCompileUnit().getLanguage();
1210 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1211 Lang == dwarf::DW_LANG_ObjC)
1212 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1215 DICompositeType SPTy = SP.getType();
1216 DIArray Args = SPTy.getTypeArray();
1217 unsigned SPTag = SPTy.getTag();
1219 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1220 addType(SPDie, SPTy);
1222 addType(SPDie, DIType(Args.getElement(0).getNode()));
1224 unsigned VK = SP.getVirtuality();
1226 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1227 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1228 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1229 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1230 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1231 ContainingTypeMap.insert(std::make_pair(SPDie,
1232 SP.getContainingType().getNode()));
1235 if (MakeDecl || !SP.isDefinition()) {
1236 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1238 // Add arguments. Do not add arguments for subprogram definition. They will
1239 // be handled while processing variables.
1240 DICompositeType SPTy = SP.getType();
1241 DIArray Args = SPTy.getTypeArray();
1242 unsigned SPTag = SPTy.getTag();
1244 if (SPTag == dwarf::DW_TAG_subroutine_type)
1245 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1246 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1247 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1249 if (ATy.isArtificial())
1250 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1251 SPDie->addChild(Arg);
1255 if (SP.isArtificial())
1256 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1258 // DW_TAG_inlined_subroutine may refer to this DIE.
1259 ModuleCU->insertDIE(SP.getNode(), SPDie);
1263 /// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1264 /// Update scope hierarchy. Create abstract scope if required.
1265 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1266 MDNode *InlinedAt) {
1267 assert(N && "Invalid Scope encoding!");
1268 assert(MI && "Missing machine instruction!");
1269 bool isAConcreteScope = InlinedAt != 0;
1271 DbgScope *NScope = NULL;
1274 NScope = DbgScopeMap.lookup(InlinedAt);
1276 NScope = DbgScopeMap.lookup(N);
1277 assert(NScope && "Unable to find working scope!");
1279 if (NScope->getFirstInsn())
1282 DbgScope *Parent = NULL;
1283 if (isAConcreteScope) {
1284 DILocation IL(InlinedAt);
1285 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1286 IL.getOrigLocation().getNode());
1287 assert(Parent && "Unable to find Parent scope!");
1288 NScope->setParent(Parent);
1289 Parent->addScope(NScope);
1290 } else if (DIDescriptor(N).isLexicalBlock()) {
1291 DILexicalBlock DB(N);
1292 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1293 NScope->setParent(Parent);
1294 Parent->addScope(NScope);
1297 NScope->setFirstInsn(MI);
1299 if (!Parent && !InlinedAt) {
1300 StringRef SPName = DISubprogram(N).getLinkageName();
1301 if (SPName == Asm->MF->getFunction()->getName())
1302 CurrentFnDbgScope = NScope;
1305 if (isAConcreteScope) {
1306 ConcreteScopes[InlinedAt] = NScope;
1307 getOrCreateAbstractScope(N);
1313 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1314 assert(N && "Invalid Scope encoding!");
1316 DbgScope *AScope = AbstractScopes.lookup(N);
1320 DbgScope *Parent = NULL;
1322 DIDescriptor Scope(N);
1323 if (Scope.isLexicalBlock()) {
1324 DILexicalBlock DB(N);
1325 DIDescriptor ParentDesc = DB.getContext();
1326 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1329 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1332 Parent->addScope(AScope);
1333 AScope->setAbstractScope();
1334 AbstractScopes[N] = AScope;
1335 if (DIDescriptor(N).isSubprogram())
1336 AbstractScopesList.push_back(AScope);
1340 /// isSubprogramContext - Return true if Context is either a subprogram
1341 /// or another context nested inside a subprogram.
1342 bool isSubprogramContext(MDNode *Context) {
1345 DIDescriptor D(Context);
1346 if (D.isSubprogram())
1349 return isSubprogramContext(DIType(Context).getContext().getNode());
1353 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1354 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1355 /// If there are global variables in this scope then create and insert
1356 /// DIEs for these variables.
1357 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1358 DIE *SPDie = ModuleCU->getDIE(SPNode);
1359 assert(SPDie && "Unable to find subprogram DIE!");
1360 DISubprogram SP(SPNode);
1362 // There is not any need to generate specification DIE for a function
1363 // defined at compile unit level. If a function is defined inside another
1364 // function then gdb prefers the definition at top level and but does not
1365 // expect specification DIE in parent function. So avoid creating
1366 // specification DIE for a function defined inside a function.
1367 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1368 !SP.getContext().isFile() &&
1369 !isSubprogramContext(SP.getContext().getNode())) {
1370 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1373 DICompositeType SPTy = SP.getType();
1374 DIArray Args = SPTy.getTypeArray();
1375 unsigned SPTag = SPTy.getTag();
1376 if (SPTag == dwarf::DW_TAG_subroutine_type)
1377 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1378 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1379 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1381 if (ATy.isArtificial())
1382 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1383 SPDie->addChild(Arg);
1385 DIE *SPDeclDie = SPDie;
1386 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1387 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1389 ModuleCU->addDie(SPDie);
1392 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1393 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1394 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1395 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1396 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1397 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1398 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1400 if (!DISubprogram(SPNode).isLocalToUnit())
1401 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1406 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1407 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1408 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1409 MCSymbol *Start = Scope->getStartLabel();
1410 MCSymbol *End = Scope->getEndLabel();
1411 if (Start == 0 || End == 0) return 0;
1413 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1414 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1416 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1417 if (Scope->isAbstractScope())
1420 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1421 Start ? Start : Asm->GetTempSymbol("func_begin",
1422 Asm->getFunctionNumber()));
1423 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1424 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1429 /// constructInlinedScopeDIE - This scope represents inlined body of
1430 /// a function. Construct DIE to represent this concrete inlined copy
1431 /// of the function.
1432 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1433 MCSymbol *StartLabel = Scope->getStartLabel();
1434 MCSymbol *EndLabel = Scope->getEndLabel();
1435 if (StartLabel == 0 || EndLabel == 0) return 0;
1437 assert(StartLabel->isDefined() &&
1438 "Invalid starting label for an inlined scope!");
1439 assert(EndLabel->isDefined() &&
1440 "Invalid end label for an inlined scope!");
1441 if (!Scope->getScopeNode())
1443 DIScope DS(Scope->getScopeNode());
1444 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1446 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1447 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1448 assert(OriginDIE && "Unable to find Origin DIE!");
1449 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1450 dwarf::DW_FORM_ref4, OriginDIE);
1452 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1453 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1455 InlinedSubprogramDIEs.insert(OriginDIE);
1457 // Track the start label for this inlined function.
1458 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1459 I = InlineInfo.find(InlinedSP.getNode());
1461 if (I == InlineInfo.end()) {
1462 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1464 InlinedSPNodes.push_back(InlinedSP.getNode());
1466 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1468 DILocation DL(Scope->getInlinedAt());
1469 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1470 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1476 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1477 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1478 // Get the descriptor.
1479 const DIVariable &VD = DV->getVariable();
1480 StringRef Name = VD.getName();
1484 // Translate tag to proper Dwarf tag. The result variable is dropped for
1487 switch (VD.getTag()) {
1488 case dwarf::DW_TAG_return_variable:
1490 case dwarf::DW_TAG_arg_variable:
1491 Tag = dwarf::DW_TAG_formal_parameter;
1493 case dwarf::DW_TAG_auto_variable: // fall thru
1495 Tag = dwarf::DW_TAG_variable;
1499 // Define variable debug information entry.
1500 DIE *VariableDie = new DIE(Tag);
1504 if (DbgVariable *AV = DV->getAbstractVariable())
1505 AbsDIE = AV->getDIE();
1508 DIScope DS(Scope->getScopeNode());
1509 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1510 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1512 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1513 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1514 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1515 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1516 dwarf::DW_FORM_ref4, AbsDIE);
1519 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1520 addSourceLine(VariableDie, &VD);
1522 // Add variable type.
1523 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1524 // addresses instead.
1525 if (VD.isBlockByrefVariable())
1526 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1528 addType(VariableDie, VD.getType());
1531 // Add variable address.
1532 if (!Scope->isAbstractScope()) {
1533 // Check if variable is described by DBG_VALUE instruction.
1534 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1535 if (DbgValueInsn->getNumOperands() == 3) {
1536 // FIXME : Handle getNumOperands != 3
1537 if (DbgValueInsn->getOperand(0).getType()
1538 == MachineOperand::MO_Register
1539 && DbgValueInsn->getOperand(0).getReg()) {
1540 MachineLocation Location;
1541 Location.set(DbgValueInsn->getOperand(0).getReg());
1542 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1543 if (MCSymbol *VS = DV->getDbgValueLabel())
1544 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1546 } else if (DbgValueInsn->getOperand(0).getType() ==
1547 MachineOperand::MO_Immediate) {
1548 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1549 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1550 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1551 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1552 if (MCSymbol *VS = DV->getDbgValueLabel())
1553 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1555 } else if (DbgValueInsn->getOperand(0).getType() ==
1556 MachineOperand::MO_FPImmediate) {
1557 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1558 APFloat FPImm = DbgValueInsn->getOperand(0).getFPImm()->getValueAPF();
1560 // Get the raw data form of the floating point.
1561 const APInt FltVal = FPImm.bitcastToAPInt();
1562 const char *FltPtr = (const char*)FltVal.getRawData();
1564 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
1565 bool LittleEndian = Asm->getTargetData().isLittleEndian();
1566 int Incr = (LittleEndian ? 1 : -1);
1567 int Start = (LittleEndian ? 0 : NumBytes - 1);
1568 int Stop = (LittleEndian ? NumBytes : -1);
1570 // Output the constant to DWARF one byte at a time.
1571 for (; Start != Stop; Start += Incr)
1572 addUInt(Block, 0, dwarf::DW_FORM_data1,
1573 (unsigned char)0xFF & FltPtr[Start]);
1575 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1577 if (MCSymbol *VS = DV->getDbgValueLabel())
1578 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1581 //FIXME : Handle other operand types.
1587 MachineLocation Location;
1589 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1590 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1592 Location.set(FrameReg, Offset);
1594 if (VD.hasComplexAddress())
1595 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1596 else if (VD.isBlockByrefVariable())
1597 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1599 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1603 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1604 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1605 DV->setDIE(VariableDie);
1610 void DwarfDebug::addPubTypes(DISubprogram SP) {
1611 DICompositeType SPTy = SP.getType();
1612 unsigned SPTag = SPTy.getTag();
1613 if (SPTag != dwarf::DW_TAG_subroutine_type)
1616 DIArray Args = SPTy.getTypeArray();
1617 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1618 DIType ATy(Args.getElement(i).getNode());
1621 DICompositeType CATy = getDICompositeType(ATy);
1622 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1623 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1624 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1629 /// constructScopeDIE - Construct a DIE for this scope.
1630 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1631 if (!Scope || !Scope->getScopeNode())
1634 DIScope DS(Scope->getScopeNode());
1635 DIE *ScopeDIE = NULL;
1636 if (Scope->getInlinedAt())
1637 ScopeDIE = constructInlinedScopeDIE(Scope);
1638 else if (DS.isSubprogram()) {
1639 if (Scope->isAbstractScope())
1640 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1642 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1645 ScopeDIE = constructLexicalScopeDIE(Scope);
1646 if (!ScopeDIE) return NULL;
1648 // Add variables to scope.
1649 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1650 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1651 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1653 ScopeDIE->addChild(VariableDIE);
1656 // Add nested scopes.
1657 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1658 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1659 // Define the Scope debug information entry.
1660 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1662 ScopeDIE->addChild(NestedDIE);
1665 if (DS.isSubprogram())
1666 addPubTypes(DISubprogram(DS.getNode()));
1671 /// GetOrCreateSourceID - Look up the source id with the given directory and
1672 /// source file names. If none currently exists, create a new id and insert it
1673 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1675 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1677 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1678 if (DI != DirectoryIdMap.end()) {
1679 DId = DI->getValue();
1681 DId = DirectoryNames.size() + 1;
1682 DirectoryIdMap[DirName] = DId;
1683 DirectoryNames.push_back(DirName);
1687 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1688 if (FI != SourceFileIdMap.end()) {
1689 FId = FI->getValue();
1691 FId = SourceFileNames.size() + 1;
1692 SourceFileIdMap[FileName] = FId;
1693 SourceFileNames.push_back(FileName);
1696 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1697 SourceIdMap.find(std::make_pair(DId, FId));
1698 if (SI != SourceIdMap.end())
1701 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1702 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1703 SourceIds.push_back(std::make_pair(DId, FId));
1708 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1709 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1710 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1713 NDie = new DIE(dwarf::DW_TAG_namespace);
1714 ModuleCU->insertDIE(NS.getNode(), NDie);
1715 if (!NS.getName().empty())
1716 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1717 addSourceLine(NDie, &NS);
1718 addToContextOwner(NDie, NS.getContext());
1722 void DwarfDebug::constructCompileUnit(MDNode *N) {
1723 DICompileUnit DIUnit(N);
1724 // Use first compile unit marked as isMain as the compile unit for this
1726 if (ModuleCU || !DIUnit.isMain())
1728 StringRef FN = DIUnit.getFilename();
1729 StringRef Dir = DIUnit.getDirectory();
1730 unsigned ID = GetOrCreateSourceID(Dir, FN);
1732 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1733 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1734 DIUnit.getProducer());
1735 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1736 DIUnit.getLanguage());
1737 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1738 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1739 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1740 Asm->GetTempSymbol("text_end"));
1741 // DW_AT_stmt_list is a offset of line number information for this
1742 // compile unit in debug_line section. It is always zero when only one
1743 // compile unit is emitted in one object file.
1744 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1747 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1748 if (DIUnit.isOptimized())
1749 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1751 StringRef Flags = DIUnit.getFlags();
1753 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1755 unsigned RVer = DIUnit.getRunTimeVersion();
1757 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1758 dwarf::DW_FORM_data1, RVer);
1761 "ModuleCU assigned since the top of constructCompileUnit");
1762 ModuleCU = new CompileUnit(ID, Die);
1765 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1766 DIGlobalVariable DI_GV(N);
1768 // If debug information is malformed then ignore it.
1769 if (DI_GV.Verify() == false)
1772 // Check for pre-existence.
1773 if (ModuleCU->getDIE(DI_GV.getNode()))
1776 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1781 ModuleCU->insertDIE(N, VariableDie);
1783 // Add to context owner.
1784 DIDescriptor GVContext = DI_GV.getContext();
1785 // Do not create specification DIE if context is either compile unit
1787 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1788 !GVContext.isFile() &&
1789 !isSubprogramContext(GVContext.getNode())) {
1790 // Create specification DIE.
1791 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1792 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1793 dwarf::DW_FORM_ref4, VariableDie);
1794 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1796 addLabel(Block, 0, dwarf::DW_FORM_udata,
1797 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1798 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1799 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1800 ModuleCU->addDie(VariableSpecDIE);
1802 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1803 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1804 addLabel(Block, 0, dwarf::DW_FORM_udata,
1805 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1806 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1808 addToContextOwner(VariableDie, GVContext);
1810 // Expose as global. FIXME - need to check external flag.
1811 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1813 DIType GTy = DI_GV.getType();
1814 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1815 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1816 assert(Entry && "Missing global type!");
1817 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1822 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1825 // Check for pre-existence.
1826 if (ModuleCU->getDIE(N))
1829 if (!SP.isDefinition())
1830 // This is a method declaration which will be handled while constructing
1834 DIE *SubprogramDie = createSubprogramDIE(SP);
1837 ModuleCU->insertDIE(N, SubprogramDie);
1839 // Add to context owner.
1840 addToContextOwner(SubprogramDie, SP.getContext());
1842 // Expose as global.
1843 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1848 /// beginModule - Emit all Dwarf sections that should come prior to the
1849 /// content. Create global DIEs and emit initial debug info sections.
1850 /// This is inovked by the target AsmPrinter.
1851 void DwarfDebug::beginModule(Module *M) {
1852 DebugInfoFinder DbgFinder;
1853 DbgFinder.processModule(*M);
1855 bool HasDebugInfo = false;
1857 // Scan all the compile-units to see if there are any marked as the main unit.
1858 // if not, we do not generate debug info.
1859 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1860 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1861 if (DICompileUnit(*I).isMain()) {
1862 HasDebugInfo = true;
1867 if (!HasDebugInfo) return;
1869 // Tell MMI that we have debug info.
1870 MMI->setDebugInfoAvailability(true);
1872 // Emit initial sections.
1873 EmitSectionLabels();
1875 // Create all the compile unit DIEs.
1876 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1877 E = DbgFinder.compile_unit_end(); I != E; ++I)
1878 constructCompileUnit(*I);
1880 // Create DIEs for each subprogram.
1881 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1882 E = DbgFinder.subprogram_end(); I != E; ++I)
1883 constructSubprogramDIE(*I);
1885 // Create DIEs for each global variable.
1886 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1887 E = DbgFinder.global_variable_end(); I != E; ++I)
1888 constructGlobalVariableDIE(*I);
1890 // Prime section data.
1891 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1893 // Print out .file directives to specify files for .loc directives. These are
1894 // printed out early so that they precede any .loc directives.
1895 if (Asm->MAI->hasDotLocAndDotFile()) {
1896 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1897 // Remember source id starts at 1.
1898 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1899 // FIXME: don't use sys::path for this! This should not depend on the
1901 sys::Path FullPath(getSourceDirectoryName(Id.first));
1903 FullPath.appendComponent(getSourceFileName(Id.second));
1904 assert(AppendOk && "Could not append filename to directory!");
1906 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1911 /// endModule - Emit all Dwarf sections that should come after the content.
1913 void DwarfDebug::endModule() {
1914 if (!ModuleCU) return;
1916 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1917 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1918 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1920 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1923 // Insert top level DIEs.
1924 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1925 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1926 ModuleCU->getCUDie()->addChild(*TI);
1928 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1929 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1930 DIE *SPDie = CI->first;
1931 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1933 DIE *NDie = ModuleCU->getDIE(N);
1934 if (!NDie) continue;
1935 addDIEEntry(SPDie, 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 populateDbgScopeInverseMaps();
2271 return !DbgScopeMap.empty();
2274 /// populateDbgScopeInverseMaps() - Populate DbgScopeBeginMap and
2275 /// DbgScopeEndMap. This maps are used to indentify debug scope started
2276 /// and ended by an instruction.
2277 void DwarfDebug::populateDbgScopeInverseMaps() {
2279 // Each scope has first instruction and last instruction to mark beginning
2280 // and end of a scope respectively. Create an inverse map that list scopes
2281 // starts (and ends) with an instruction. One instruction may start (or end)
2282 // multiple scopes. Ignore scopes that are not reachable.
2283 SmallVector<DbgScope *, 4> WorkList;
2284 WorkList.push_back(CurrentFnDbgScope);
2285 while (!WorkList.empty()) {
2286 DbgScope *S = WorkList.pop_back_val();
2288 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2289 if (!Children.empty())
2290 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2291 SE = Children.end(); SI != SE; ++SI)
2292 WorkList.push_back(*SI);
2294 if (S->isAbstractScope())
2296 const MachineInstr *MI = S->getFirstInsn();
2297 assert(MI && "DbgScope does not have first instruction!");
2299 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2300 if (IDI != DbgScopeBeginMap.end())
2301 IDI->second.push_back(S);
2303 DbgScopeBeginMap[MI].push_back(S);
2305 MI = S->getLastInsn();
2306 assert(MI && "DbgScope does not have last instruction!");
2307 IDI = DbgScopeEndMap.find(MI);
2308 if (IDI != DbgScopeEndMap.end())
2309 IDI->second.push_back(S);
2311 DbgScopeEndMap[MI].push_back(S);
2315 /// beginFunction - Gather pre-function debug information. Assumes being
2316 /// emitted immediately after the function entry point.
2317 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2318 if (!MMI->hasDebugInfo()) return;
2319 if (!extractScopeInformation()) return;
2321 collectVariableInfo();
2323 // Assumes in correct section after the entry point.
2324 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2325 Asm->getFunctionNumber()));
2327 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2329 DebugLoc FDL = MF->getDefaultDebugLoc();
2330 if (FDL.isUnknown()) return;
2332 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2334 DISubprogram SP = getDISubprogram(Scope);
2337 Line = SP.getLineNumber();
2340 Line = FDL.getLine();
2344 recordSourceLine(Line, Col, Scope);
2347 /// endFunction - Gather and emit post-function debug information.
2349 void DwarfDebug::endFunction(const MachineFunction *MF) {
2350 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2352 if (CurrentFnDbgScope) {
2353 // Define end label for subprogram.
2354 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2355 Asm->getFunctionNumber()));
2357 // Get function line info.
2358 if (!Lines.empty()) {
2359 // Get section line info.
2360 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2361 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2362 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2363 // Append the function info to section info.
2364 SectionLineInfos.insert(SectionLineInfos.end(),
2365 Lines.begin(), Lines.end());
2368 // Construct abstract scopes.
2369 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2370 AE = AbstractScopesList.end(); AI != AE; ++AI)
2371 constructScopeDIE(*AI);
2373 constructScopeDIE(CurrentFnDbgScope);
2375 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2376 MMI->getFrameMoves()));
2380 CurrentFnDbgScope = NULL;
2381 DeleteContainerSeconds(DbgScopeMap);
2382 DbgScopeBeginMap.clear();
2383 DbgScopeEndMap.clear();
2384 DbgValueStartMap.clear();
2385 ConcreteScopes.clear();
2386 DeleteContainerSeconds(AbstractScopes);
2387 AbstractScopesList.clear();
2388 AbstractVariables.clear();
2392 /// recordSourceLine - Register a source line with debug info. Returns the
2393 /// unique label that was emitted and which provides correspondence to
2394 /// the source line list.
2395 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2399 DIDescriptor Scope(S);
2400 if (Scope.isCompileUnit()) {
2401 DICompileUnit CU(S);
2402 Dir = CU.getDirectory();
2403 Fn = CU.getFilename();
2404 } else if (Scope.isSubprogram()) {
2406 Dir = SP.getDirectory();
2407 Fn = SP.getFilename();
2408 } else if (Scope.isLexicalBlock()) {
2409 DILexicalBlock DB(S);
2410 Dir = DB.getDirectory();
2411 Fn = DB.getFilename();
2413 assert(0 && "Unexpected scope info");
2415 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2416 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2417 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2419 Asm->OutStreamer.EmitLabel(Label);
2423 //===----------------------------------------------------------------------===//
2425 //===----------------------------------------------------------------------===//
2427 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2430 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2431 // Get the children.
2432 const std::vector<DIE *> &Children = Die->getChildren();
2434 // If not last sibling and has children then add sibling offset attribute.
2435 if (!Last && !Children.empty())
2436 Die->addSiblingOffset(DIEValueAllocator);
2438 // Record the abbreviation.
2439 assignAbbrevNumber(Die->getAbbrev());
2441 // Get the abbreviation for this DIE.
2442 unsigned AbbrevNumber = Die->getAbbrevNumber();
2443 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2446 Die->setOffset(Offset);
2448 // Start the size with the size of abbreviation code.
2449 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2451 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2452 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2454 // Size the DIE attribute values.
2455 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2456 // Size attribute value.
2457 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2459 // Size the DIE children if any.
2460 if (!Children.empty()) {
2461 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2462 "Children flag not set");
2464 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2465 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2467 // End of children marker.
2468 Offset += sizeof(int8_t);
2471 Die->setSize(Offset - Die->getOffset());
2475 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2477 void DwarfDebug::computeSizeAndOffsets() {
2478 // Compute size of compile unit header.
2479 static unsigned Offset =
2480 sizeof(int32_t) + // Length of Compilation Unit Info
2481 sizeof(int16_t) + // DWARF version number
2482 sizeof(int32_t) + // Offset Into Abbrev. Section
2483 sizeof(int8_t); // Pointer Size (in bytes)
2485 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2486 CompileUnitOffsets[ModuleCU] = 0;
2489 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2490 /// temporary label to it if SymbolStem is specified.
2491 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2492 const char *SymbolStem = 0) {
2493 Asm->OutStreamer.SwitchSection(Section);
2494 if (!SymbolStem) return 0;
2496 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2497 Asm->OutStreamer.EmitLabel(TmpSym);
2501 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2502 /// the start of each one.
2503 void DwarfDebug::EmitSectionLabels() {
2504 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2506 // Dwarf sections base addresses.
2507 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2508 DwarfFrameSectionSym =
2509 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2512 DwarfInfoSectionSym =
2513 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2514 DwarfAbbrevSectionSym =
2515 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2516 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2518 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2519 EmitSectionSym(Asm, MacroInfo);
2521 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2522 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2523 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2524 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2525 DwarfStrSectionSym =
2526 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2527 EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
2529 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2530 EmitSectionSym(Asm, TLOF.getDataSection());
2533 /// emitDIE - Recusively Emits a debug information entry.
2535 void DwarfDebug::emitDIE(DIE *Die) {
2536 // Get the abbreviation for this DIE.
2537 unsigned AbbrevNumber = Die->getAbbrevNumber();
2538 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2540 // Emit the code (index) for the abbreviation.
2541 if (Asm->isVerbose())
2542 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2543 Twine::utohexstr(Die->getOffset()) + ":0x" +
2544 Twine::utohexstr(Die->getSize()) + " " +
2545 dwarf::TagString(Abbrev->getTag()));
2546 Asm->EmitULEB128(AbbrevNumber);
2548 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2549 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2551 // Emit the DIE attribute values.
2552 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2553 unsigned Attr = AbbrevData[i].getAttribute();
2554 unsigned Form = AbbrevData[i].getForm();
2555 assert(Form && "Too many attributes for DIE (check abbreviation)");
2557 if (Asm->isVerbose())
2558 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2561 case dwarf::DW_AT_sibling:
2562 Asm->EmitInt32(Die->getSiblingOffset());
2564 case dwarf::DW_AT_abstract_origin: {
2565 DIEEntry *E = cast<DIEEntry>(Values[i]);
2566 DIE *Origin = E->getEntry();
2567 unsigned Addr = Origin->getOffset();
2568 Asm->EmitInt32(Addr);
2572 // Emit an attribute using the defined form.
2573 Values[i]->EmitValue(Asm, Form);
2578 // Emit the DIE children if any.
2579 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2580 const std::vector<DIE *> &Children = Die->getChildren();
2582 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2583 emitDIE(Children[j]);
2585 if (Asm->isVerbose())
2586 Asm->OutStreamer.AddComment("End Of Children Mark");
2591 /// emitDebugInfo - Emit the debug info section.
2593 void DwarfDebug::emitDebugInfo() {
2594 // Start debug info section.
2595 Asm->OutStreamer.SwitchSection(
2596 Asm->getObjFileLowering().getDwarfInfoSection());
2597 DIE *Die = ModuleCU->getCUDie();
2599 // Emit the compile units header.
2600 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2601 ModuleCU->getID()));
2603 // Emit size of content not including length itself
2604 unsigned ContentSize = Die->getSize() +
2605 sizeof(int16_t) + // DWARF version number
2606 sizeof(int32_t) + // Offset Into Abbrev. Section
2607 sizeof(int8_t) + // Pointer Size (in bytes)
2608 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2610 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2611 Asm->EmitInt32(ContentSize);
2612 Asm->OutStreamer.AddComment("DWARF version number");
2613 Asm->EmitInt16(dwarf::DWARF_VERSION);
2614 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2615 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2616 DwarfAbbrevSectionSym);
2617 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2618 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2621 // FIXME - extra padding for gdb bug.
2622 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2627 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2630 /// emitAbbreviations - Emit the abbreviation section.
2632 void DwarfDebug::emitAbbreviations() const {
2633 // Check to see if it is worth the effort.
2634 if (!Abbreviations.empty()) {
2635 // Start the debug abbrev section.
2636 Asm->OutStreamer.SwitchSection(
2637 Asm->getObjFileLowering().getDwarfAbbrevSection());
2639 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2641 // For each abbrevation.
2642 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2643 // Get abbreviation data
2644 const DIEAbbrev *Abbrev = Abbreviations[i];
2646 // Emit the abbrevations code (base 1 index.)
2647 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2649 // Emit the abbreviations data.
2653 // Mark end of abbreviations.
2654 Asm->EmitULEB128(0, "EOM(3)");
2656 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2660 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2661 /// the line matrix.
2663 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2664 // Define last address of section.
2665 Asm->OutStreamer.AddComment("Extended Op");
2668 Asm->OutStreamer.AddComment("Op size");
2669 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2670 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2671 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2673 Asm->OutStreamer.AddComment("Section end label");
2675 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2676 Asm->getTargetData().getPointerSize(),
2679 // Mark end of matrix.
2680 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2686 /// emitDebugLines - Emit source line information.
2688 void DwarfDebug::emitDebugLines() {
2689 // If the target is using .loc/.file, the assembler will be emitting the
2690 // .debug_line table automatically.
2691 if (Asm->MAI->hasDotLocAndDotFile())
2694 // Minimum line delta, thus ranging from -10..(255-10).
2695 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2696 // Maximum line delta, thus ranging from -10..(255-10).
2697 const int MaxLineDelta = 255 + MinLineDelta;
2699 // Start the dwarf line section.
2700 Asm->OutStreamer.SwitchSection(
2701 Asm->getObjFileLowering().getDwarfLineSection());
2703 // Construct the section header.
2704 Asm->OutStreamer.AddComment("Length of Source Line Info");
2705 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2706 Asm->GetTempSymbol("line_begin"), 4);
2707 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2709 Asm->OutStreamer.AddComment("DWARF version number");
2710 Asm->EmitInt16(dwarf::DWARF_VERSION);
2712 Asm->OutStreamer.AddComment("Prolog Length");
2713 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2714 Asm->GetTempSymbol("line_prolog_begin"), 4);
2715 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2717 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2719 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2721 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2722 Asm->EmitInt8(MinLineDelta);
2723 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2724 Asm->EmitInt8(MaxLineDelta);
2725 Asm->OutStreamer.AddComment("Special Opcode Base");
2726 Asm->EmitInt8(-MinLineDelta);
2728 // Line number standard opcode encodings argument count
2729 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2731 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2733 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2735 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2737 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2739 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2741 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2743 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2745 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2748 // Emit directories.
2749 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2750 const std::string &Dir = getSourceDirectoryName(DI);
2751 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2752 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2755 Asm->OutStreamer.AddComment("End of directories");
2759 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2760 // Remember source id starts at 1.
2761 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2762 const std::string &FN = getSourceFileName(Id.second);
2763 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2764 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2766 Asm->EmitULEB128(Id.first, "Directory #");
2767 Asm->EmitULEB128(0, "Mod date");
2768 Asm->EmitULEB128(0, "File size");
2771 Asm->OutStreamer.AddComment("End of files");
2774 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2776 // A sequence for each text section.
2777 unsigned SecSrcLinesSize = SectionSourceLines.size();
2779 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2780 // Isolate current sections line info.
2781 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2783 // Dwarf assumes we start with first line of first source file.
2784 unsigned Source = 1;
2787 // Construct rows of the address, source, line, column matrix.
2788 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2789 const SrcLineInfo &LineInfo = LineInfos[i];
2790 MCSymbol *Label = LineInfo.getLabel();
2791 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2793 if (LineInfo.getLine() == 0) continue;
2795 if (Asm->isVerbose()) {
2796 std::pair<unsigned, unsigned> SrcID =
2797 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2798 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2800 Twine(getSourceFileName(SrcID.second)) +
2801 ":" + Twine(LineInfo.getLine()));
2804 // Define the line address.
2805 Asm->OutStreamer.AddComment("Extended Op");
2807 Asm->OutStreamer.AddComment("Op size");
2808 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2810 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2811 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2813 Asm->OutStreamer.AddComment("Location label");
2814 Asm->OutStreamer.EmitSymbolValue(Label,
2815 Asm->getTargetData().getPointerSize(),
2818 // If change of source, then switch to the new source.
2819 if (Source != LineInfo.getSourceID()) {
2820 Source = LineInfo.getSourceID();
2821 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2822 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2823 Asm->EmitULEB128(Source, "New Source");
2826 // If change of line.
2827 if (Line != LineInfo.getLine()) {
2828 // Determine offset.
2829 int Offset = LineInfo.getLine() - Line;
2830 int Delta = Offset - MinLineDelta;
2833 Line = LineInfo.getLine();
2835 // If delta is small enough and in range...
2836 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2837 // ... then use fast opcode.
2838 Asm->OutStreamer.AddComment("Line Delta");
2839 Asm->EmitInt8(Delta - MinLineDelta);
2841 // ... otherwise use long hand.
2842 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2843 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2844 Asm->EmitSLEB128(Offset, "Line Offset");
2845 Asm->OutStreamer.AddComment("DW_LNS_copy");
2846 Asm->EmitInt8(dwarf::DW_LNS_copy);
2849 // Copy the previous row (different address or source)
2850 Asm->OutStreamer.AddComment("DW_LNS_copy");
2851 Asm->EmitInt8(dwarf::DW_LNS_copy);
2855 emitEndOfLineMatrix(j + 1);
2858 if (SecSrcLinesSize == 0)
2859 // Because we're emitting a debug_line section, we still need a line
2860 // table. The linker and friends expect it to exist. If there's nothing to
2861 // put into it, emit an empty table.
2862 emitEndOfLineMatrix(1);
2864 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2867 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2869 void DwarfDebug::emitCommonDebugFrame() {
2870 if (!Asm->MAI->doesDwarfRequireFrameSection())
2873 int stackGrowth = Asm->getTargetData().getPointerSize();
2874 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2875 TargetFrameInfo::StackGrowsDown)
2878 // Start the dwarf frame section.
2879 Asm->OutStreamer.SwitchSection(
2880 Asm->getObjFileLowering().getDwarfFrameSection());
2882 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2883 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2884 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2885 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2887 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2888 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2889 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2890 Asm->OutStreamer.AddComment("CIE Version");
2891 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2892 Asm->OutStreamer.AddComment("CIE Augmentation");
2893 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2894 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2895 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2896 Asm->OutStreamer.AddComment("CIE RA Column");
2897 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2898 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2900 std::vector<MachineMove> Moves;
2901 RI->getInitialFrameState(Moves);
2903 Asm->EmitFrameMoves(Moves, 0, false);
2905 Asm->EmitAlignment(2, 0, 0, false);
2906 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2909 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2912 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2913 if (!Asm->MAI->doesDwarfRequireFrameSection())
2916 // Start the dwarf frame section.
2917 Asm->OutStreamer.SwitchSection(
2918 Asm->getObjFileLowering().getDwarfFrameSection());
2920 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2921 MCSymbol *DebugFrameBegin =
2922 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2923 MCSymbol *DebugFrameEnd =
2924 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2925 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2927 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2929 Asm->OutStreamer.AddComment("FDE CIE offset");
2930 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2931 DwarfFrameSectionSym);
2933 Asm->OutStreamer.AddComment("FDE initial location");
2934 MCSymbol *FuncBeginSym =
2935 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2936 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2937 Asm->getTargetData().getPointerSize(),
2941 Asm->OutStreamer.AddComment("FDE address range");
2942 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2943 FuncBeginSym, Asm->getTargetData().getPointerSize());
2945 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2947 Asm->EmitAlignment(2, 0, 0, false);
2948 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2951 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2953 void DwarfDebug::emitDebugPubNames() {
2954 // Start the dwarf pubnames section.
2955 Asm->OutStreamer.SwitchSection(
2956 Asm->getObjFileLowering().getDwarfPubNamesSection());
2958 Asm->OutStreamer.AddComment("Length of Public Names Info");
2959 Asm->EmitLabelDifference(
2960 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2961 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2963 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2964 ModuleCU->getID()));
2966 Asm->OutStreamer.AddComment("DWARF Version");
2967 Asm->EmitInt16(dwarf::DWARF_VERSION);
2969 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2970 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2971 DwarfInfoSectionSym);
2973 Asm->OutStreamer.AddComment("Compilation Unit Length");
2974 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2975 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2978 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2979 for (StringMap<DIE*>::const_iterator
2980 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2981 const char *Name = GI->getKeyData();
2982 DIE *Entity = GI->second;
2984 Asm->OutStreamer.AddComment("DIE offset");
2985 Asm->EmitInt32(Entity->getOffset());
2987 if (Asm->isVerbose())
2988 Asm->OutStreamer.AddComment("External Name");
2989 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2992 Asm->OutStreamer.AddComment("End Mark");
2994 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2995 ModuleCU->getID()));
2998 void DwarfDebug::emitDebugPubTypes() {
2999 // Start the dwarf pubnames section.
3000 Asm->OutStreamer.SwitchSection(
3001 Asm->getObjFileLowering().getDwarfPubTypesSection());
3002 Asm->OutStreamer.AddComment("Length of Public Types Info");
3003 Asm->EmitLabelDifference(
3004 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
3005 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
3007 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3008 ModuleCU->getID()));
3010 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3011 Asm->EmitInt16(dwarf::DWARF_VERSION);
3013 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
3014 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3015 DwarfInfoSectionSym);
3017 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
3018 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
3019 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3022 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
3023 for (StringMap<DIE*>::const_iterator
3024 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3025 const char *Name = GI->getKeyData();
3026 DIE * Entity = GI->second;
3028 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3029 Asm->EmitInt32(Entity->getOffset());
3031 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3032 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3035 Asm->OutStreamer.AddComment("End Mark");
3037 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3038 ModuleCU->getID()));
3041 /// emitDebugStr - Emit visible names into a debug str section.
3043 void DwarfDebug::emitDebugStr() {
3044 // Check to see if it is worth the effort.
3045 if (StringPool.empty()) return;
3047 // Start the dwarf str section.
3048 Asm->OutStreamer.SwitchSection(
3049 Asm->getObjFileLowering().getDwarfStrSection());
3051 // Get all of the string pool entries and put them in an array by their ID so
3052 // we can sort them.
3053 SmallVector<std::pair<unsigned,
3054 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3056 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3057 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3058 Entries.push_back(std::make_pair(I->second.second, &*I));
3060 array_pod_sort(Entries.begin(), Entries.end());
3062 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3063 // Emit a label for reference from debug information entries.
3064 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3066 // Emit the string itself.
3067 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3071 /// emitDebugLoc - Emit visible names into a debug loc section.
3073 void DwarfDebug::emitDebugLoc() {
3074 // Start the dwarf loc section.
3075 Asm->OutStreamer.SwitchSection(
3076 Asm->getObjFileLowering().getDwarfLocSection());
3079 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3081 void DwarfDebug::EmitDebugARanges() {
3082 // Start the dwarf aranges section.
3083 Asm->OutStreamer.SwitchSection(
3084 Asm->getObjFileLowering().getDwarfARangesSection());
3087 /// emitDebugRanges - Emit visible names into a debug ranges section.
3089 void DwarfDebug::emitDebugRanges() {
3090 // Start the dwarf ranges section.
3091 Asm->OutStreamer.SwitchSection(
3092 Asm->getObjFileLowering().getDwarfRangesSection());
3095 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3097 void DwarfDebug::emitDebugMacInfo() {
3098 if (const MCSection *LineInfo =
3099 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3100 // Start the dwarf macinfo section.
3101 Asm->OutStreamer.SwitchSection(LineInfo);
3105 /// emitDebugInlineInfo - Emit inline info using following format.
3107 /// 1. length of section
3108 /// 2. Dwarf version number
3109 /// 3. address size.
3111 /// Entries (one "entry" for each function that was inlined):
3113 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3114 /// otherwise offset into __debug_str for regular function name.
3115 /// 2. offset into __debug_str section for regular function name.
3116 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3117 /// instances for the function.
3119 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3120 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3121 /// __debug_info section, and the low_pc is the starting address for the
3122 /// inlining instance.
3123 void DwarfDebug::emitDebugInlineInfo() {
3124 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3130 Asm->OutStreamer.SwitchSection(
3131 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3133 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3134 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3135 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3137 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3139 Asm->OutStreamer.AddComment("Dwarf Version");
3140 Asm->EmitInt16(dwarf::DWARF_VERSION);
3141 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3142 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3144 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3145 E = InlinedSPNodes.end(); I != E; ++I) {
3148 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3149 = InlineInfo.find(Node);
3150 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3151 DISubprogram SP(Node);
3152 StringRef LName = SP.getLinkageName();
3153 StringRef Name = SP.getName();
3155 Asm->OutStreamer.AddComment("MIPS linkage name");
3156 if (LName.empty()) {
3157 Asm->OutStreamer.EmitBytes(Name, 0);
3158 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3160 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3161 DwarfStrSectionSym);
3163 Asm->OutStreamer.AddComment("Function name");
3164 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3165 Asm->EmitULEB128(Labels.size(), "Inline count");
3167 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3168 LE = Labels.end(); LI != LE; ++LI) {
3169 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3170 Asm->EmitInt32(LI->second->getOffset());
3172 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3173 Asm->OutStreamer.EmitSymbolValue(LI->first,
3174 Asm->getTargetData().getPointerSize(),0);
3178 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));