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"
42 //===----------------------------------------------------------------------===//
44 /// Configuration values for initial hash set sizes (log2).
46 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
50 //===----------------------------------------------------------------------===//
51 /// CompileUnit - This dwarf writer support class manages information associate
52 /// with a source file.
54 /// ID - File identifier for source.
58 /// Die - Compile unit debug information entry.
60 const OwningPtr<DIE> CUDie;
62 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
65 /// GVToDieMap - Tracks the mapping of unit level debug informaton
66 /// variables to debug information entries.
67 /// FIXME : Rename GVToDieMap -> NodeToDieMap
68 DenseMap<MDNode *, DIE *> GVToDieMap;
70 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
71 /// descriptors to debug information entries using a DIEEntry proxy.
73 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
75 /// Globals - A map of globally visible named entities for this unit.
77 StringMap<DIE*> Globals;
79 /// GlobalTypes - A map of globally visible types for this unit.
81 StringMap<DIE*> GlobalTypes;
84 CompileUnit(unsigned I, DIE *D)
85 : ID(I), CUDie(D), IndexTyDie(0) {}
88 unsigned getID() const { return ID; }
89 DIE* getCUDie() const { return CUDie.get(); }
90 const StringMap<DIE*> &getGlobals() const { return Globals; }
91 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
93 /// hasContent - Return true if this compile unit has something to write out.
95 bool hasContent() const { return !CUDie->getChildren().empty(); }
97 /// addGlobal - Add a new global entity to the compile unit.
99 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
101 /// addGlobalType - Add a new global type to the compile unit.
103 void addGlobalType(StringRef Name, DIE *Die) {
104 GlobalTypes[Name] = Die;
107 /// getDIE - Returns the debug information entry map slot for the
108 /// specified debug variable.
109 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
111 /// insertDIE - Insert DIE into the map.
112 void insertDIE(MDNode *N, DIE *D) {
113 GVToDieMap.insert(std::make_pair(N, D));
116 /// getDIEEntry - Returns the debug information entry for the speciefied
118 DIEEntry *getDIEEntry(MDNode *N) {
119 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
120 if (I == GVToDIEEntryMap.end())
125 /// insertDIEEntry - Insert debug information entry into the map.
126 void insertDIEEntry(MDNode *N, DIEEntry *E) {
127 GVToDIEEntryMap.insert(std::make_pair(N, E));
130 /// addDie - Adds or interns the DIE to the compile unit.
132 void addDie(DIE *Buffer) {
133 this->CUDie->addChild(Buffer);
136 // getIndexTyDie - Get an anonymous type for index type.
137 DIE *getIndexTyDie() {
141 // setIndexTyDie - Set D as anonymous type for index which can be reused
143 void setIndexTyDie(DIE *D) {
149 //===----------------------------------------------------------------------===//
150 /// DbgVariable - This class is used to track local variable information.
153 DIVariable Var; // Variable Descriptor.
154 unsigned FrameIndex; // Variable frame index.
155 const MachineInstr *DbgValueMInsn; // DBG_VALUE
156 // DbgValueLabel - DBG_VALUE is effective from this label.
157 MCSymbol *DbgValueLabel;
158 DbgVariable *const AbstractVar; // Abstract variable for this variable.
161 // AbsVar may be NULL.
162 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
163 : Var(V), FrameIndex(I), DbgValueMInsn(0),
164 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
165 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
166 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
167 AbstractVar(AbsVar), TheDIE(0)
171 DIVariable getVariable() const { return Var; }
172 unsigned getFrameIndex() const { return FrameIndex; }
173 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
174 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
175 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
176 DbgVariable *getAbstractVariable() const { return AbstractVar; }
177 void setDIE(DIE *D) { TheDIE = D; }
178 DIE *getDIE() const { return TheDIE; }
181 //===----------------------------------------------------------------------===//
182 /// DbgScope - This class is used to track scope information.
185 DbgScope *Parent; // Parent to this scope.
186 DIDescriptor Desc; // Debug info descriptor for scope.
187 // Location at which this scope is inlined.
188 AssertingVH<MDNode> InlinedAtLocation;
189 bool AbstractScope; // Abstract Scope
190 MCSymbol *StartLabel; // Label ID of the beginning of scope.
191 MCSymbol *EndLabel; // Label ID of the end of scope.
192 const MachineInstr *LastInsn; // Last instruction of this scope.
193 const MachineInstr *FirstInsn; // First instruction of this scope.
194 // Scopes defined in scope. Contents not owned.
195 SmallVector<DbgScope *, 4> Scopes;
196 // Variables declared in scope. Contents owned.
197 SmallVector<DbgVariable *, 8> Variables;
199 // Private state for dump()
200 mutable unsigned IndentLevel;
202 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
203 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
204 StartLabel(0), EndLabel(0),
205 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
209 DbgScope *getParent() const { return Parent; }
210 void setParent(DbgScope *P) { Parent = P; }
211 DIDescriptor getDesc() const { return Desc; }
212 MDNode *getInlinedAt() const { return InlinedAtLocation; }
213 MDNode *getScopeNode() const { return Desc.getNode(); }
214 MCSymbol *getStartLabel() const { return StartLabel; }
215 MCSymbol *getEndLabel() const { return EndLabel; }
216 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
217 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
218 void setStartLabel(MCSymbol *S) { StartLabel = S; }
219 void setEndLabel(MCSymbol *E) { EndLabel = E; }
220 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
221 const MachineInstr *getLastInsn() { return LastInsn; }
222 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
223 void setAbstractScope() { AbstractScope = true; }
224 bool isAbstractScope() const { return AbstractScope; }
225 const MachineInstr *getFirstInsn() { return FirstInsn; }
227 /// addScope - Add a scope to the scope.
229 void addScope(DbgScope *S) { Scopes.push_back(S); }
231 /// addVariable - Add a variable to the scope.
233 void addVariable(DbgVariable *V) { Variables.push_back(V); }
235 void fixInstructionMarkers(DenseMap<const MachineInstr *,
236 unsigned> &MIIndexMap) {
237 assert(getFirstInsn() && "First instruction is missing!");
239 // Use the end of last child scope as end of this scope.
240 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
241 const MachineInstr *LastInsn = getFirstInsn();
243 if (Scopes.empty()) {
244 assert(getLastInsn() && "Inner most scope does not have last insn!");
247 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
248 SE = Scopes.end(); SI != SE; ++SI) {
250 DS->fixInstructionMarkers(MIIndexMap);
251 const MachineInstr *DSLastInsn = DS->getLastInsn();
252 unsigned DSI = MIIndexMap[DSLastInsn];
254 LastInsn = DSLastInsn;
259 unsigned CurrentLastInsnIndex = 0;
260 if (const MachineInstr *CL = getLastInsn())
261 CurrentLastInsnIndex = MIIndexMap[CL];
262 unsigned FIndex = MIIndexMap[getFirstInsn()];
264 // Set LastInsn as the last instruction for this scope only if
266 // 1) this scope's first instruction and
267 // 2) current last instruction for this scope, if any.
268 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
269 setLastInsn(LastInsn);
277 } // end llvm namespace
280 void DbgScope::dump() const {
281 raw_ostream &err = dbgs();
282 err.indent(IndentLevel);
283 MDNode *N = Desc.getNode();
285 err << " [" << StartLabel << ", " << EndLabel << "]\n";
287 err << "Abstract Scope\n";
291 err << "Children ...\n";
292 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
293 if (Scopes[i] != this)
300 DbgScope::~DbgScope() {
301 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
305 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
306 : Asm(A), MMI(Asm->MMI), ModuleCU(0),
307 AbbreviationsSet(InitAbbreviationsSetSize),
308 CurrentFnDbgScope(0), DebugTimer(0) {
309 NextStringPoolNumber = 0;
311 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
312 DwarfStrSectionSym = TextSectionSym = 0;
314 if (TimePassesIsEnabled)
315 DebugTimer = new Timer("Dwarf Debug Writer");
319 DwarfDebug::~DwarfDebug() {
320 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
321 DIEBlocks[j]->~DIEBlock();
326 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
327 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
328 if (Entry.first) return Entry.first;
330 Entry.second = NextStringPoolNumber++;
331 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
335 /// assignAbbrevNumber - Define a unique number for the abbreviation.
337 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
338 // Profile the node so that we can make it unique.
342 // Check the set for priors.
343 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
345 // If it's newly added.
346 if (InSet == &Abbrev) {
347 // Add to abbreviation list.
348 Abbreviations.push_back(&Abbrev);
350 // Assign the vector position + 1 as its number.
351 Abbrev.setNumber(Abbreviations.size());
353 // Assign existing abbreviation number.
354 Abbrev.setNumber(InSet->getNumber());
358 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
359 /// information entry.
360 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
361 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
365 /// addUInt - Add an unsigned integer attribute data and value.
367 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
368 unsigned Form, uint64_t Integer) {
369 if (!Form) Form = DIEInteger::BestForm(false, Integer);
370 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
371 Die->addValue(Attribute, Form, Value);
374 /// addSInt - Add an signed integer attribute data and value.
376 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
377 unsigned Form, int64_t Integer) {
378 if (!Form) Form = DIEInteger::BestForm(true, Integer);
379 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
380 Die->addValue(Attribute, Form, Value);
383 /// addString - Add a string attribute data and value. DIEString only
384 /// keeps string reference.
385 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
387 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
388 Die->addValue(Attribute, Form, Value);
391 /// addLabel - Add a Dwarf label attribute data and value.
393 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
394 const MCSymbol *Label) {
395 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
396 Die->addValue(Attribute, Form, Value);
399 /// addDelta - Add a label delta attribute data and value.
401 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
402 const MCSymbol *Hi, const MCSymbol *Lo) {
403 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
404 Die->addValue(Attribute, Form, Value);
407 /// addDIEEntry - Add a DIE attribute data and value.
409 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
411 Die->addValue(Attribute, Form, createDIEEntry(Entry));
415 /// addBlock - Add block data.
417 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
419 Block->ComputeSize(Asm);
420 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
421 Die->addValue(Attribute, Block->BestForm(), Block);
424 /// addSourceLine - Add location information to specified debug information
426 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
427 // If there is no compile unit specified, don't add a line #.
428 if (!V->getCompileUnit().Verify())
431 unsigned Line = V->getLineNumber();
432 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
433 V->getContext().getFilename());
434 assert(FileID && "Invalid file id");
435 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
436 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
439 /// addSourceLine - Add location information to specified debug information
441 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
442 // If there is no compile unit specified, don't add a line #.
443 if (!G->getCompileUnit().Verify())
446 unsigned Line = G->getLineNumber();
447 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
448 G->getContext().getFilename());
449 assert(FileID && "Invalid file id");
450 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
451 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
454 /// addSourceLine - Add location information to specified debug information
456 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
457 // If there is no compile unit specified, don't add a line #.
458 if (!SP->getCompileUnit().Verify())
460 // If the line number is 0, don't add it.
461 if (SP->getLineNumber() == 0)
464 unsigned Line = SP->getLineNumber();
465 if (!SP->getContext().Verify())
467 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
469 assert(FileID && "Invalid file id");
470 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
471 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
474 /// addSourceLine - Add location information to specified debug information
476 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
477 // If there is no compile unit specified, don't add a line #.
478 DICompileUnit CU = Ty->getCompileUnit();
482 unsigned Line = Ty->getLineNumber();
483 if (!Ty->getContext().Verify())
485 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
486 Ty->getContext().getFilename());
487 assert(FileID && "Invalid file id");
488 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
489 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
492 /// addSourceLine - Add location information to specified debug information
494 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
495 // If there is no compile unit specified, don't add a line #.
496 if (!NS->getCompileUnit().Verify())
499 unsigned Line = NS->getLineNumber();
500 StringRef FN = NS->getFilename();
501 StringRef Dir = NS->getDirectory();
503 unsigned FileID = GetOrCreateSourceID(Dir, FN);
504 assert(FileID && "Invalid file id");
505 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
506 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
509 /* Byref variables, in Blocks, are declared by the programmer as
510 "SomeType VarName;", but the compiler creates a
511 __Block_byref_x_VarName struct, and gives the variable VarName
512 either the struct, or a pointer to the struct, as its type. This
513 is necessary for various behind-the-scenes things the compiler
514 needs to do with by-reference variables in blocks.
516 However, as far as the original *programmer* is concerned, the
517 variable should still have type 'SomeType', as originally declared.
519 The following function dives into the __Block_byref_x_VarName
520 struct to find the original type of the variable. This will be
521 passed back to the code generating the type for the Debug
522 Information Entry for the variable 'VarName'. 'VarName' will then
523 have the original type 'SomeType' in its debug information.
525 The original type 'SomeType' will be the type of the field named
526 'VarName' inside the __Block_byref_x_VarName struct.
528 NOTE: In order for this to not completely fail on the debugger
529 side, the Debug Information Entry for the variable VarName needs to
530 have a DW_AT_location that tells the debugger how to unwind through
531 the pointers and __Block_byref_x_VarName struct to find the actual
532 value of the variable. The function addBlockByrefType does this. */
534 /// Find the type the programmer originally declared the variable to be
535 /// and return that type.
537 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
540 unsigned tag = Ty.getTag();
542 if (tag == dwarf::DW_TAG_pointer_type) {
543 DIDerivedType DTy = DIDerivedType(Ty.getNode());
544 subType = DTy.getTypeDerivedFrom();
547 DICompositeType blockStruct = DICompositeType(subType.getNode());
548 DIArray Elements = blockStruct.getTypeArray();
550 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
551 DIDescriptor Element = Elements.getElement(i);
552 DIDerivedType DT = DIDerivedType(Element.getNode());
553 if (Name == DT.getName())
554 return (DT.getTypeDerivedFrom());
560 /// addComplexAddress - Start with the address based on the location provided,
561 /// and generate the DWARF information necessary to find the actual variable
562 /// given the extra address information encoded in the DIVariable, starting from
563 /// the starting location. Add the DWARF information to the die.
565 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
567 const MachineLocation &Location) {
568 const DIVariable &VD = DV->getVariable();
569 DIType Ty = VD.getType();
571 // Decode the original location, and use that as the start of the byref
572 // variable's location.
573 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
574 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
575 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
577 if (Location.isReg()) {
579 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
581 Reg = Reg - dwarf::DW_OP_reg0;
582 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
583 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
590 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
593 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
596 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
597 uint64_t Element = VD.getAddrElement(i);
599 if (Element == DIFactory::OpPlus) {
600 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
601 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
602 } else if (Element == DIFactory::OpDeref) {
603 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
604 } else llvm_unreachable("unknown DIFactory Opcode");
607 // Now attach the location information to the DIE.
608 addBlock(Die, Attribute, 0, Block);
611 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
612 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
613 gives the variable VarName either the struct, or a pointer to the struct, as
614 its type. This is necessary for various behind-the-scenes things the
615 compiler needs to do with by-reference variables in Blocks.
617 However, as far as the original *programmer* is concerned, the variable
618 should still have type 'SomeType', as originally declared.
620 The function getBlockByrefType dives into the __Block_byref_x_VarName
621 struct to find the original type of the variable, which is then assigned to
622 the variable's Debug Information Entry as its real type. So far, so good.
623 However now the debugger will expect the variable VarName to have the type
624 SomeType. So we need the location attribute for the variable to be an
625 expression that explains to the debugger how to navigate through the
626 pointers and struct to find the actual variable of type SomeType.
628 The following function does just that. We start by getting
629 the "normal" location for the variable. This will be the location
630 of either the struct __Block_byref_x_VarName or the pointer to the
631 struct __Block_byref_x_VarName.
633 The struct will look something like:
635 struct __Block_byref_x_VarName {
637 struct __Block_byref_x_VarName *forwarding;
638 ... <various other fields>
640 ... <maybe more fields>
643 If we are given the struct directly (as our starting point) we
644 need to tell the debugger to:
646 1). Add the offset of the forwarding field.
648 2). Follow that pointer to get the real __Block_byref_x_VarName
649 struct to use (the real one may have been copied onto the heap).
651 3). Add the offset for the field VarName, to find the actual variable.
653 If we started with a pointer to the struct, then we need to
654 dereference that pointer first, before the other steps.
655 Translating this into DWARF ops, we will need to append the following
656 to the current location description for the variable:
658 DW_OP_deref -- optional, if we start with a pointer
659 DW_OP_plus_uconst <forward_fld_offset>
661 DW_OP_plus_uconst <varName_fld_offset>
663 That is what this function does. */
665 /// addBlockByrefAddress - Start with the address based on the location
666 /// provided, and generate the DWARF information necessary to find the
667 /// actual Block variable (navigating the Block struct) based on the
668 /// starting location. Add the DWARF information to the die. For
669 /// more information, read large comment just above here.
671 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
673 const MachineLocation &Location) {
674 const DIVariable &VD = DV->getVariable();
675 DIType Ty = VD.getType();
677 unsigned Tag = Ty.getTag();
678 bool isPointer = false;
680 StringRef varName = VD.getName();
682 if (Tag == dwarf::DW_TAG_pointer_type) {
683 DIDerivedType DTy = DIDerivedType(Ty.getNode());
684 TmpTy = DTy.getTypeDerivedFrom();
688 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
690 // Find the __forwarding field and the variable field in the __Block_byref
692 DIArray Fields = blockStruct.getTypeArray();
693 DIDescriptor varField = DIDescriptor();
694 DIDescriptor forwardingField = DIDescriptor();
696 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
697 DIDescriptor Element = Fields.getElement(i);
698 DIDerivedType DT = DIDerivedType(Element.getNode());
699 StringRef fieldName = DT.getName();
700 if (fieldName == "__forwarding")
701 forwardingField = Element;
702 else if (fieldName == varName)
706 // Get the offsets for the forwarding field and the variable field.
707 unsigned forwardingFieldOffset =
708 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
709 unsigned varFieldOffset =
710 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
712 // Decode the original location, and use that as the start of the byref
713 // variable's location.
714 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
715 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
716 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
718 if (Location.isReg()) {
720 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
722 Reg = Reg - dwarf::DW_OP_reg0;
723 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
724 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
728 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
731 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
734 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
737 // If we started with a pointer to the __Block_byref... struct, then
738 // the first thing we need to do is dereference the pointer (DW_OP_deref).
740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
742 // Next add the offset for the '__forwarding' field:
743 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
744 // adding the offset if it's 0.
745 if (forwardingFieldOffset > 0) {
746 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
747 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
750 // Now dereference the __forwarding field to get to the real __Block_byref
751 // struct: DW_OP_deref.
752 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
754 // Now that we've got the real __Block_byref... struct, add the offset
755 // for the variable's field to get to the location of the actual variable:
756 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
757 if (varFieldOffset > 0) {
758 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
759 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
762 // Now attach the location information to the DIE.
763 addBlock(Die, Attribute, 0, Block);
766 /// addAddress - Add an address attribute to a die based on the location
768 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
769 const MachineLocation &Location) {
770 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
771 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
772 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
774 if (Location.isReg()) {
776 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
778 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
779 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
783 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
785 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
786 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
789 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
792 addBlock(Die, Attribute, 0, Block);
795 /// addToContextOwner - Add Die into the list of its context owner's children.
796 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
797 if (Context.isType()) {
798 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
799 ContextDIE->addChild(Die);
800 } else if (Context.isNameSpace()) {
801 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
802 ContextDIE->addChild(Die);
803 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
804 ContextDIE->addChild(Die);
806 ModuleCU->addDie(Die);
809 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
811 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
812 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
817 TyDIE = new DIE(dwarf::DW_TAG_base_type);
818 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
819 if (Ty.isBasicType())
820 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
821 else if (Ty.isCompositeType())
822 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
824 assert(Ty.isDerivedType() && "Unknown kind of DIType");
825 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
828 addToContextOwner(TyDIE, Ty.getContext());
832 /// addType - Add a new type attribute to the specified entity.
833 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
837 // Check for pre-existence.
838 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
839 // If it exists then use the existing value.
841 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
846 DIE *Buffer = getOrCreateTypeDIE(Ty);
849 Entry = createDIEEntry(Buffer);
850 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
852 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
855 /// constructTypeDIE - Construct basic type die from DIBasicType.
856 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
857 // Get core information.
858 StringRef Name = BTy.getName();
859 Buffer.setTag(dwarf::DW_TAG_base_type);
860 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
863 // Add name if not anonymous or intermediate type.
865 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
866 uint64_t Size = BTy.getSizeInBits() >> 3;
867 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
870 /// constructTypeDIE - Construct derived type die from DIDerivedType.
871 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
872 // Get core information.
873 StringRef Name = DTy.getName();
874 uint64_t Size = DTy.getSizeInBits() >> 3;
875 unsigned Tag = DTy.getTag();
877 // FIXME - Workaround for templates.
878 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
882 // Map to main type, void will not have a type.
883 DIType FromTy = DTy.getTypeDerivedFrom();
884 addType(&Buffer, FromTy);
886 // Add name if not anonymous or intermediate type.
888 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
890 // Add size if non-zero (derived types might be zero-sized.)
892 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
894 // Add source line info if available and TyDesc is not a forward declaration.
895 if (!DTy.isForwardDecl())
896 addSourceLine(&Buffer, &DTy);
899 /// constructTypeDIE - Construct type DIE from DICompositeType.
900 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
901 // Get core information.
902 StringRef Name = CTy.getName();
904 uint64_t Size = CTy.getSizeInBits() >> 3;
905 unsigned Tag = CTy.getTag();
909 case dwarf::DW_TAG_vector_type:
910 case dwarf::DW_TAG_array_type:
911 constructArrayTypeDIE(Buffer, &CTy);
913 case dwarf::DW_TAG_enumeration_type: {
914 DIArray Elements = CTy.getTypeArray();
916 // Add enumerators to enumeration type.
917 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
919 DIDescriptor Enum(Elements.getElement(i).getNode());
920 if (Enum.isEnumerator()) {
921 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
922 Buffer.addChild(ElemDie);
927 case dwarf::DW_TAG_subroutine_type: {
929 DIArray Elements = CTy.getTypeArray();
930 DIDescriptor RTy = Elements.getElement(0);
931 addType(&Buffer, DIType(RTy.getNode()));
933 // Add prototype flag.
934 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
937 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
938 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
939 DIDescriptor Ty = Elements.getElement(i);
940 addType(Arg, DIType(Ty.getNode()));
941 Buffer.addChild(Arg);
945 case dwarf::DW_TAG_structure_type:
946 case dwarf::DW_TAG_union_type:
947 case dwarf::DW_TAG_class_type: {
948 // Add elements to structure type.
949 DIArray Elements = CTy.getTypeArray();
951 // A forward struct declared type may not have elements available.
952 unsigned N = Elements.getNumElements();
956 // Add elements to structure type.
957 for (unsigned i = 0; i < N; ++i) {
958 DIDescriptor Element = Elements.getElement(i);
960 if (Element.isSubprogram())
961 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
962 else if (Element.isVariable()) {
963 DIVariable DV(Element.getNode());
964 ElemDie = new DIE(dwarf::DW_TAG_variable);
965 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
967 addType(ElemDie, DV.getType());
968 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
969 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
970 addSourceLine(ElemDie, &DV);
971 } else if (Element.isDerivedType())
972 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
975 Buffer.addChild(ElemDie);
978 if (CTy.isAppleBlockExtension())
979 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
981 unsigned RLang = CTy.getRunTimeLang();
983 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
984 dwarf::DW_FORM_data1, RLang);
986 DICompositeType ContainingType = CTy.getContainingType();
987 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
988 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
989 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
996 // Add name if not anonymous or intermediate type.
998 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1000 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1001 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1002 // Add size if non-zero (derived types might be zero-sized.)
1004 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1006 // Add zero size if it is not a forward declaration.
1007 if (CTy.isForwardDecl())
1008 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1010 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1013 // Add source line info if available.
1014 if (!CTy.isForwardDecl())
1015 addSourceLine(&Buffer, &CTy);
1019 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1020 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1021 int64_t L = SR.getLo();
1022 int64_t H = SR.getHi();
1023 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1025 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1027 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1028 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1030 Buffer.addChild(DW_Subrange);
1033 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1034 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1035 DICompositeType *CTy) {
1036 Buffer.setTag(dwarf::DW_TAG_array_type);
1037 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1038 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1040 // Emit derived type.
1041 addType(&Buffer, CTy->getTypeDerivedFrom());
1042 DIArray Elements = CTy->getTypeArray();
1044 // Get an anonymous type for index type.
1045 DIE *IdxTy = ModuleCU->getIndexTyDie();
1047 // Construct an anonymous type for index type.
1048 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1049 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1050 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1051 dwarf::DW_ATE_signed);
1052 ModuleCU->addDie(IdxTy);
1053 ModuleCU->setIndexTyDie(IdxTy);
1056 // Add subranges to array type.
1057 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1058 DIDescriptor Element = Elements.getElement(i);
1059 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1060 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1064 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1065 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1066 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1067 StringRef Name = ETy.getName();
1068 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1069 int64_t Value = ETy.getEnumValue();
1070 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1074 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1075 /// printer to not emit usual symbol prefix before the symbol name is used then
1076 /// return linkage name after skipping this special LLVM prefix.
1077 static StringRef getRealLinkageName(StringRef LinkageName) {
1079 if (LinkageName.startswith(StringRef(&One, 1)))
1080 return LinkageName.substr(1);
1084 /// createGlobalVariableDIE - Create new DIE using GV.
1085 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1086 // If the global variable was optmized out then no need to create debug info
1088 if (!GV.getGlobal()) return NULL;
1089 if (GV.getDisplayName().empty()) return NULL;
1091 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1092 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1093 GV.getDisplayName());
1095 StringRef LinkageName = GV.getLinkageName();
1096 if (!LinkageName.empty())
1097 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1098 getRealLinkageName(LinkageName));
1100 addType(GVDie, GV.getType());
1101 if (!GV.isLocalToUnit())
1102 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1103 addSourceLine(GVDie, &GV);
1108 /// createMemberDIE - Create new member DIE.
1109 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1110 DIE *MemberDie = new DIE(DT.getTag());
1111 StringRef Name = DT.getName();
1113 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1115 addType(MemberDie, DT.getTypeDerivedFrom());
1117 addSourceLine(MemberDie, &DT);
1119 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1120 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1122 uint64_t Size = DT.getSizeInBits();
1123 uint64_t FieldSize = DT.getOriginalTypeSize();
1125 if (Size != FieldSize) {
1127 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1128 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1130 uint64_t Offset = DT.getOffsetInBits();
1131 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1132 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1133 uint64_t FieldOffset = (HiMark - FieldSize);
1134 Offset -= FieldOffset;
1136 // Maybe we need to work from the other end.
1137 if (Asm->getTargetData().isLittleEndian())
1138 Offset = FieldSize - (Offset + Size);
1139 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1141 // Here WD_AT_data_member_location points to the anonymous
1142 // field that includes this bit field.
1143 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1146 // This is not a bitfield.
1147 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1149 if (DT.getTag() == dwarf::DW_TAG_inheritance
1150 && DT.isVirtual()) {
1152 // For C++, virtual base classes are not at fixed offset. Use following
1153 // expression to extract appropriate offset from vtable.
1154 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1156 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1157 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1158 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1159 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1160 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1161 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1162 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1163 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1165 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1168 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1170 if (DT.isProtected())
1171 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1172 dwarf::DW_ACCESS_protected);
1173 else if (DT.isPrivate())
1174 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1175 dwarf::DW_ACCESS_private);
1176 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1177 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1178 dwarf::DW_ACCESS_public);
1180 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1181 dwarf::DW_VIRTUALITY_virtual);
1185 /// createSubprogramDIE - Create new DIE using SP.
1186 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1187 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1191 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1192 // Constructors and operators for anonymous aggregates do not have names.
1193 if (!SP.getName().empty())
1194 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1196 StringRef LinkageName = SP.getLinkageName();
1197 if (!LinkageName.empty())
1198 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1199 getRealLinkageName(LinkageName));
1201 addSourceLine(SPDie, &SP);
1203 // Add prototyped tag, if C or ObjC.
1204 unsigned Lang = SP.getCompileUnit().getLanguage();
1205 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1206 Lang == dwarf::DW_LANG_ObjC)
1207 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1210 DICompositeType SPTy = SP.getType();
1211 DIArray Args = SPTy.getTypeArray();
1212 unsigned SPTag = SPTy.getTag();
1214 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1215 addType(SPDie, SPTy);
1217 addType(SPDie, DIType(Args.getElement(0).getNode()));
1219 unsigned VK = SP.getVirtuality();
1221 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1222 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1223 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1224 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1225 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1226 ContainingTypeMap.insert(std::make_pair(SPDie,
1227 SP.getContainingType().getNode()));
1230 if (MakeDecl || !SP.isDefinition()) {
1231 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1233 // Add arguments. Do not add arguments for subprogram definition. They will
1234 // be handled while processing variables.
1235 DICompositeType SPTy = SP.getType();
1236 DIArray Args = SPTy.getTypeArray();
1237 unsigned SPTag = SPTy.getTag();
1239 if (SPTag == dwarf::DW_TAG_subroutine_type)
1240 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1241 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1242 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1244 if (ATy.isArtificial())
1245 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1246 SPDie->addChild(Arg);
1250 if (SP.isArtificial())
1251 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1253 // DW_TAG_inlined_subroutine may refer to this DIE.
1254 ModuleCU->insertDIE(SP.getNode(), SPDie);
1258 /// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1259 /// Update scope hierarchy. Create abstract scope if required.
1260 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1261 MDNode *InlinedAt) {
1262 assert(N && "Invalid Scope encoding!");
1263 assert(MI && "Missing machine instruction!");
1264 bool isAConcreteScope = InlinedAt != 0;
1266 DbgScope *NScope = NULL;
1269 NScope = DbgScopeMap.lookup(InlinedAt);
1271 NScope = DbgScopeMap.lookup(N);
1272 assert(NScope && "Unable to find working scope!");
1274 if (NScope->getFirstInsn())
1277 DbgScope *Parent = NULL;
1278 if (isAConcreteScope) {
1279 DILocation IL(InlinedAt);
1280 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1281 IL.getOrigLocation().getNode());
1282 assert(Parent && "Unable to find Parent scope!");
1283 NScope->setParent(Parent);
1284 Parent->addScope(NScope);
1285 } else if (DIDescriptor(N).isLexicalBlock()) {
1286 DILexicalBlock DB(N);
1287 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1288 NScope->setParent(Parent);
1289 Parent->addScope(NScope);
1292 NScope->setFirstInsn(MI);
1294 if (!Parent && !InlinedAt) {
1295 StringRef SPName = DISubprogram(N).getLinkageName();
1296 if (SPName == Asm->MF->getFunction()->getName())
1297 CurrentFnDbgScope = NScope;
1300 if (isAConcreteScope) {
1301 ConcreteScopes[InlinedAt] = NScope;
1302 getOrCreateAbstractScope(N);
1308 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1309 assert(N && "Invalid Scope encoding!");
1311 DbgScope *AScope = AbstractScopes.lookup(N);
1315 DbgScope *Parent = NULL;
1317 DIDescriptor Scope(N);
1318 if (Scope.isLexicalBlock()) {
1319 DILexicalBlock DB(N);
1320 DIDescriptor ParentDesc = DB.getContext();
1321 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1324 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1327 Parent->addScope(AScope);
1328 AScope->setAbstractScope();
1329 AbstractScopes[N] = AScope;
1330 if (DIDescriptor(N).isSubprogram())
1331 AbstractScopesList.push_back(AScope);
1335 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1336 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1337 /// If there are global variables in this scope then create and insert
1338 /// DIEs for these variables.
1339 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1340 DIE *SPDie = ModuleCU->getDIE(SPNode);
1341 assert(SPDie && "Unable to find subprogram DIE!");
1342 DISubprogram SP(SPNode);
1344 // There is not any need to generate specification DIE for a function
1345 // defined at compile unit level. If a function is defined inside another
1346 // function then gdb prefers the definition at top level and but does not
1347 // expect specification DIE in parent function. So avoid creating
1348 // specification DIE for a function defined inside a function.
1349 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1350 !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1351 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1354 DICompositeType SPTy = SP.getType();
1355 DIArray Args = SPTy.getTypeArray();
1356 unsigned SPTag = SPTy.getTag();
1357 if (SPTag == dwarf::DW_TAG_subroutine_type)
1358 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1359 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1360 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1362 if (ATy.isArtificial())
1363 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1364 SPDie->addChild(Arg);
1366 DIE *SPDeclDie = SPDie;
1367 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1368 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1370 ModuleCU->addDie(SPDie);
1373 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1374 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1375 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1376 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1377 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1378 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1379 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1381 if (!DISubprogram(SPNode).isLocalToUnit())
1382 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1387 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1388 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1389 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1390 MCSymbol *Start = Scope->getStartLabel();
1391 MCSymbol *End = Scope->getEndLabel();
1392 if (Start == 0 || End == 0) return 0;
1394 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1395 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1397 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1398 if (Scope->isAbstractScope())
1401 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1402 Start ? Start : Asm->GetTempSymbol("func_begin",
1403 Asm->getFunctionNumber()));
1404 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1405 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1410 /// constructInlinedScopeDIE - This scope represents inlined body of
1411 /// a function. Construct DIE to represent this concrete inlined copy
1412 /// of the function.
1413 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1414 MCSymbol *StartLabel = Scope->getStartLabel();
1415 MCSymbol *EndLabel = Scope->getEndLabel();
1416 if (StartLabel == 0 || EndLabel == 0) return 0;
1418 assert(StartLabel->isDefined() &&
1419 "Invalid starting label for an inlined scope!");
1420 assert(EndLabel->isDefined() &&
1421 "Invalid end label for an inlined scope!");
1422 if (!Scope->getScopeNode())
1424 DIScope DS(Scope->getScopeNode());
1425 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1427 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1428 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1429 assert(OriginDIE && "Unable to find Origin DIE!");
1430 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1431 dwarf::DW_FORM_ref4, OriginDIE);
1433 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1434 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1436 InlinedSubprogramDIEs.insert(OriginDIE);
1438 // Track the start label for this inlined function.
1439 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1440 I = InlineInfo.find(InlinedSP.getNode());
1442 if (I == InlineInfo.end()) {
1443 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1445 InlinedSPNodes.push_back(InlinedSP.getNode());
1447 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1449 DILocation DL(Scope->getInlinedAt());
1450 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1451 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1457 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1458 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1459 // Get the descriptor.
1460 const DIVariable &VD = DV->getVariable();
1461 StringRef Name = VD.getName();
1465 // Translate tag to proper Dwarf tag. The result variable is dropped for
1468 switch (VD.getTag()) {
1469 case dwarf::DW_TAG_return_variable:
1471 case dwarf::DW_TAG_arg_variable:
1472 Tag = dwarf::DW_TAG_formal_parameter;
1474 case dwarf::DW_TAG_auto_variable: // fall thru
1476 Tag = dwarf::DW_TAG_variable;
1480 // Define variable debug information entry.
1481 DIE *VariableDie = new DIE(Tag);
1485 if (DbgVariable *AV = DV->getAbstractVariable())
1486 AbsDIE = AV->getDIE();
1489 DIScope DS(Scope->getScopeNode());
1490 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1491 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1493 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1494 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1495 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1496 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1497 dwarf::DW_FORM_ref4, AbsDIE);
1500 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1501 addSourceLine(VariableDie, &VD);
1503 // Add variable type.
1504 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1505 // addresses instead.
1506 if (VD.isBlockByrefVariable())
1507 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1509 addType(VariableDie, VD.getType());
1512 // Add variable address.
1513 if (!Scope->isAbstractScope()) {
1514 // Check if variable is described by DBG_VALUE instruction.
1515 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1516 if (DbgValueInsn->getNumOperands() == 3) {
1517 // FIXME : Handle getNumOperands != 3
1518 if (DbgValueInsn->getOperand(0).getType()
1519 == MachineOperand::MO_Register
1520 && DbgValueInsn->getOperand(0).getReg()) {
1521 MachineLocation Location;
1522 Location.set(DbgValueInsn->getOperand(0).getReg());
1523 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1524 if (MCSymbol *VS = DV->getDbgValueLabel())
1525 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1527 } else if (DbgValueInsn->getOperand(0).getType() ==
1528 MachineOperand::MO_Immediate) {
1529 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1530 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1531 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1532 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1533 if (MCSymbol *VS = DV->getDbgValueLabel())
1534 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1536 } else if (DbgValueInsn->getOperand(0).getType() ==
1537 MachineOperand::MO_FPImmediate) {
1538 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1539 APFloat FPImm = DbgValueInsn->getOperand(0).getFPImm()->getValueAPF();
1541 // Get the raw data form of the floating point.
1542 const APInt FltVal = FPImm.bitcastToAPInt();
1543 const char *FltPtr = (const char*)FltVal.getRawData();
1545 unsigned NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
1546 bool LittleEndian = Asm->getTargetData().isLittleEndian();
1547 int Incr = (LittleEndian ? 1 : -1);
1548 int Start = (LittleEndian ? 0 : NumBytes - 1);
1549 int Stop = (LittleEndian ? NumBytes : -1);
1551 // Output the constant to DWARF one byte at a time.
1552 for (; Start != Stop; Start += Incr)
1553 addUInt(Block, 0, dwarf::DW_FORM_data1,
1554 (unsigned char)0xFF & FltPtr[Start]);
1556 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1558 if (MCSymbol *VS = DV->getDbgValueLabel())
1559 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1562 //FIXME : Handle other operand types.
1568 MachineLocation Location;
1570 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1571 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1573 Location.set(FrameReg, Offset);
1575 if (VD.hasComplexAddress())
1576 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1577 else if (VD.isBlockByrefVariable())
1578 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1580 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1584 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1585 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1586 DV->setDIE(VariableDie);
1591 void DwarfDebug::addPubTypes(DISubprogram SP) {
1592 DICompositeType SPTy = SP.getType();
1593 unsigned SPTag = SPTy.getTag();
1594 if (SPTag != dwarf::DW_TAG_subroutine_type)
1597 DIArray Args = SPTy.getTypeArray();
1598 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1599 DIType ATy(Args.getElement(i).getNode());
1602 DICompositeType CATy = getDICompositeType(ATy);
1603 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1604 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1605 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1610 /// constructScopeDIE - Construct a DIE for this scope.
1611 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1612 if (!Scope || !Scope->getScopeNode())
1615 DIScope DS(Scope->getScopeNode());
1616 DIE *ScopeDIE = NULL;
1617 if (Scope->getInlinedAt())
1618 ScopeDIE = constructInlinedScopeDIE(Scope);
1619 else if (DS.isSubprogram()) {
1620 if (Scope->isAbstractScope())
1621 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1623 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1626 ScopeDIE = constructLexicalScopeDIE(Scope);
1627 if (!ScopeDIE) return NULL;
1629 // Add variables to scope.
1630 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1631 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1632 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1634 ScopeDIE->addChild(VariableDIE);
1637 // Add nested scopes.
1638 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1639 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1640 // Define the Scope debug information entry.
1641 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1643 ScopeDIE->addChild(NestedDIE);
1646 if (DS.isSubprogram())
1647 addPubTypes(DISubprogram(DS.getNode()));
1652 /// GetOrCreateSourceID - Look up the source id with the given directory and
1653 /// source file names. If none currently exists, create a new id and insert it
1654 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1656 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1658 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1659 if (DI != DirectoryIdMap.end()) {
1660 DId = DI->getValue();
1662 DId = DirectoryNames.size() + 1;
1663 DirectoryIdMap[DirName] = DId;
1664 DirectoryNames.push_back(DirName);
1668 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1669 if (FI != SourceFileIdMap.end()) {
1670 FId = FI->getValue();
1672 FId = SourceFileNames.size() + 1;
1673 SourceFileIdMap[FileName] = FId;
1674 SourceFileNames.push_back(FileName);
1677 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1678 SourceIdMap.find(std::make_pair(DId, FId));
1679 if (SI != SourceIdMap.end())
1682 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1683 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1684 SourceIds.push_back(std::make_pair(DId, FId));
1689 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1690 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1691 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1694 NDie = new DIE(dwarf::DW_TAG_namespace);
1695 ModuleCU->insertDIE(NS.getNode(), NDie);
1696 if (!NS.getName().empty())
1697 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1698 addSourceLine(NDie, &NS);
1699 addToContextOwner(NDie, NS.getContext());
1703 void DwarfDebug::constructCompileUnit(MDNode *N) {
1704 DICompileUnit DIUnit(N);
1705 // Use first compile unit marked as isMain as the compile unit for this
1707 if (ModuleCU || !DIUnit.isMain())
1709 StringRef FN = DIUnit.getFilename();
1710 StringRef Dir = DIUnit.getDirectory();
1711 unsigned ID = GetOrCreateSourceID(Dir, FN);
1713 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1714 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1715 DIUnit.getProducer());
1716 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1717 DIUnit.getLanguage());
1718 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1719 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1720 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1721 Asm->GetTempSymbol("text_end"));
1722 // DW_AT_stmt_list is a offset of line number information for this
1723 // compile unit in debug_line section. It is always zero when only one
1724 // compile unit is emitted in one object file.
1725 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1728 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1729 if (DIUnit.isOptimized())
1730 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1732 StringRef Flags = DIUnit.getFlags();
1734 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1736 unsigned RVer = DIUnit.getRunTimeVersion();
1738 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1739 dwarf::DW_FORM_data1, RVer);
1742 "ModuleCU assigned since the top of constructCompileUnit");
1743 ModuleCU = new CompileUnit(ID, Die);
1746 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1747 DIGlobalVariable DI_GV(N);
1749 // If debug information is malformed then ignore it.
1750 if (DI_GV.Verify() == false)
1753 // Check for pre-existence.
1754 if (ModuleCU->getDIE(DI_GV.getNode()))
1757 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1762 ModuleCU->insertDIE(N, VariableDie);
1764 // Add to context owner.
1765 DIDescriptor GVContext = DI_GV.getContext();
1766 // Do not create specification DIE if context is either compile unit
1768 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1769 !GVContext.isFile() && !GVContext.isSubprogram()) {
1770 // Create specification DIE.
1771 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1772 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1773 dwarf::DW_FORM_ref4, VariableDie);
1774 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1775 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1776 addLabel(Block, 0, dwarf::DW_FORM_udata,
1777 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1778 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1779 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1780 ModuleCU->addDie(VariableSpecDIE);
1782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1783 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1784 addLabel(Block, 0, dwarf::DW_FORM_udata,
1785 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1786 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1788 addToContextOwner(VariableDie, GVContext);
1790 // Expose as global. FIXME - need to check external flag.
1791 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1793 DIType GTy = DI_GV.getType();
1794 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1795 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1796 assert(Entry && "Missing global type!");
1797 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1802 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1805 // Check for pre-existence.
1806 if (ModuleCU->getDIE(N))
1809 if (!SP.isDefinition())
1810 // This is a method declaration which will be handled while constructing
1814 DIE *SubprogramDie = createSubprogramDIE(SP);
1817 ModuleCU->insertDIE(N, SubprogramDie);
1819 // Add to context owner.
1820 addToContextOwner(SubprogramDie, SP.getContext());
1822 // Expose as global.
1823 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1828 /// beginModule - Emit all Dwarf sections that should come prior to the
1829 /// content. Create global DIEs and emit initial debug info sections.
1830 /// This is inovked by the target AsmPrinter.
1831 void DwarfDebug::beginModule(Module *M) {
1832 TimeRegion Timer(DebugTimer);
1834 DebugInfoFinder DbgFinder;
1835 DbgFinder.processModule(*M);
1837 bool HasDebugInfo = false;
1839 // Scan all the compile-units to see if there are any marked as the main unit.
1840 // if not, we do not generate debug info.
1841 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1842 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1843 if (DICompileUnit(*I).isMain()) {
1844 HasDebugInfo = true;
1849 if (!HasDebugInfo) return;
1851 // Tell MMI that we have debug info.
1852 MMI->setDebugInfoAvailability(true);
1854 // Emit initial sections.
1855 EmitSectionLabels();
1857 // Create all the compile unit DIEs.
1858 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1859 E = DbgFinder.compile_unit_end(); I != E; ++I)
1860 constructCompileUnit(*I);
1862 // Create DIEs for each subprogram.
1863 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1864 E = DbgFinder.subprogram_end(); I != E; ++I)
1865 constructSubprogramDIE(*I);
1867 // Create DIEs for each global variable.
1868 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1869 E = DbgFinder.global_variable_end(); I != E; ++I)
1870 constructGlobalVariableDIE(*I);
1872 // Prime section data.
1873 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1875 // Print out .file directives to specify files for .loc directives. These are
1876 // printed out early so that they precede any .loc directives.
1877 if (Asm->MAI->hasDotLocAndDotFile()) {
1878 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1879 // Remember source id starts at 1.
1880 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1881 // FIXME: don't use sys::path for this! This should not depend on the
1883 sys::Path FullPath(getSourceDirectoryName(Id.first));
1885 FullPath.appendComponent(getSourceFileName(Id.second));
1886 assert(AppendOk && "Could not append filename to directory!");
1888 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1893 /// endModule - Emit all Dwarf sections that should come after the content.
1895 void DwarfDebug::endModule() {
1899 TimeRegion Timer(DebugTimer);
1901 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1902 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1903 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1905 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1908 // Insert top level DIEs.
1909 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1910 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1911 ModuleCU->getCUDie()->addChild(*TI);
1913 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1914 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1915 DIE *SPDie = CI->first;
1916 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1918 DIE *NDie = ModuleCU->getDIE(N);
1919 if (!NDie) continue;
1920 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1921 // FIXME - This is not the correct approach.
1922 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
1925 // Standard sections final addresses.
1926 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1927 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1928 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1929 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1931 // End text sections.
1932 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1933 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1934 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1937 // Emit common frame information.
1938 emitCommonDebugFrame();
1940 // Emit function debug frame information
1941 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1942 E = DebugFrames.end(); I != E; ++I)
1943 emitFunctionDebugFrame(*I);
1945 // Compute DIE offsets and sizes.
1946 computeSizeAndOffsets();
1948 // Emit all the DIEs into a debug info section
1951 // Corresponding abbreviations into a abbrev section.
1952 emitAbbreviations();
1954 // Emit source line correspondence into a debug line section.
1957 // Emit info into a debug pubnames section.
1958 emitDebugPubNames();
1960 // Emit info into a debug pubtypes section.
1961 emitDebugPubTypes();
1963 // Emit info into a debug loc section.
1966 // Emit info into a debug aranges section.
1969 // Emit info into a debug ranges section.
1972 // Emit info into a debug macinfo section.
1975 // Emit inline info.
1976 emitDebugInlineInfo();
1978 // Emit info into a debug str section.
1982 ModuleCU = NULL; // Reset for the next Module, if any.
1985 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1986 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1988 DebugLoc ScopeLoc) {
1990 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1992 return AbsDbgVariable;
1994 LLVMContext &Ctx = Var.getNode()->getContext();
1995 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1999 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
2000 NULL /* No more-abstract variable*/);
2001 Scope->addVariable(AbsDbgVariable);
2002 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2003 return AbsDbgVariable;
2006 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2007 /// FIXME : Refactor findAbstractVariable.
2008 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2009 const MachineInstr *MI,
2010 DebugLoc ScopeLoc) {
2012 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
2014 return AbsDbgVariable;
2016 LLVMContext &Ctx = Var.getNode()->getContext();
2017 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2021 AbsDbgVariable = new DbgVariable(Var, MI,
2022 NULL /* No more-abstract variable*/);
2023 Scope->addVariable(AbsDbgVariable);
2024 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2025 DbgValueStartMap[MI] = AbsDbgVariable;
2026 return AbsDbgVariable;
2029 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2030 void DwarfDebug::collectVariableInfo() {
2031 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2033 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2034 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2035 VE = VMap.end(); VI != VE; ++VI) {
2036 MDNode *Var = VI->first;
2039 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2041 DbgScope *Scope = 0;
2042 if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2043 Scope = ConcreteScopes.lookup(IA);
2045 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2047 // If variable scope is not found then skip this variable.
2051 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2052 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2053 Scope->addVariable(RegVar);
2056 // Collect variable information from DBG_VALUE machine instructions;
2057 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2059 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2061 const MachineInstr *MInsn = II;
2062 if (!MInsn->isDebugValue())
2065 // FIXME : Lift this restriction.
2066 if (MInsn->getNumOperands() != 3)
2068 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2069 - 1).getMetadata()));
2070 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2071 // FIXME Handle inlined subroutine arguments.
2072 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2073 CurrentFnDbgScope->addVariable(ArgVar);
2074 DbgValueStartMap[MInsn] = ArgVar;
2078 DebugLoc DL = MInsn->getDebugLoc();
2079 if (DL.isUnknown()) continue;
2080 DbgScope *Scope = 0;
2081 if (MDNode *IA = DL.getInlinedAt(Ctx))
2082 Scope = ConcreteScopes.lookup(IA);
2084 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2086 // If variable scope is not found then skip this variable.
2090 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2091 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2092 DbgValueStartMap[MInsn] = RegVar;
2093 Scope->addVariable(RegVar);
2098 /// beginScope - Process beginning of a scope.
2099 void DwarfDebug::beginScope(const MachineInstr *MI) {
2101 DebugLoc DL = MI->getDebugLoc();
2105 // Check and update last known location info.
2106 if (DL == PrevInstLoc)
2109 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2111 // FIXME: Should only verify each scope once!
2112 if (!DIScope(Scope).Verify())
2115 // DBG_VALUE instruction establishes new value.
2116 if (MI->isDebugValue()) {
2117 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2118 = DbgValueStartMap.find(MI);
2119 if (DI != DbgValueStartMap.end()) {
2120 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2122 DI->second->setDbgValueLabel(Label);
2127 // Emit a label to indicate location change. This is used for line
2128 // table even if this instruction does start a new scope.
2129 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2132 // update DbgScope if this instruction starts a new scope.
2133 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2134 if (I == DbgScopeBeginMap.end())
2137 ScopeVector &SD = I->second;
2138 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2140 (*SDI)->setStartLabel(Label);
2143 /// endScope - Process end of a scope.
2144 void DwarfDebug::endScope(const MachineInstr *MI) {
2145 // Ignore DBG_VALUE instruction.
2146 if (MI->isDebugValue())
2150 DebugLoc DL = MI->getDebugLoc();
2154 // Emit a label and update DbgScope if this instruction ends a scope.
2155 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2156 if (I == DbgScopeEndMap.end())
2159 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2160 Asm->OutStreamer.EmitLabel(Label);
2162 SmallVector<DbgScope*, 2> &SD = I->second;
2163 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2165 (*SDI)->setEndLabel(Label);
2169 /// createDbgScope - Create DbgScope for the scope.
2170 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2172 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2175 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2176 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2177 if (DIDescriptor(Scope).isLexicalBlock())
2178 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2182 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2186 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2187 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2188 DILocation DL(InlinedAt);
2189 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2192 /// extractScopeInformation - Scan machine instructions in this function
2193 /// and collect DbgScopes. Return true, if at least one scope was found.
2194 bool DwarfDebug::extractScopeInformation() {
2195 // If scope information was extracted using .dbg intrinsics then there is not
2196 // any need to extract these information by scanning each instruction.
2197 if (!DbgScopeMap.empty())
2200 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2201 unsigned MIIndex = 0;
2202 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2204 // Scan each instruction and create scopes. First build working set of scopes.
2205 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2207 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2209 const MachineInstr *MInsn = II;
2210 // FIXME : Remove DBG_VALUE check.
2211 if (MInsn->isDebugValue()) continue;
2212 MIIndexMap[MInsn] = MIIndex++;
2214 DebugLoc DL = MInsn->getDebugLoc();
2215 if (DL.isUnknown()) continue;
2217 MDNode *Scope = DL.getScope(Ctx);
2219 // There is no need to create another DIE for compile unit. For all
2220 // other scopes, create one DbgScope now. This will be translated
2221 // into a scope DIE at the end.
2222 if (DIScope(Scope).isCompileUnit()) continue;
2223 createDbgScope(Scope, DL.getInlinedAt(Ctx));
2228 // Build scope hierarchy using working set of scopes.
2229 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2231 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2233 const MachineInstr *MInsn = II;
2234 // FIXME : Remove DBG_VALUE check.
2235 if (MInsn->isDebugValue()) continue;
2236 DebugLoc DL = MInsn->getDebugLoc();
2237 if (DL.isUnknown()) continue;
2239 MDNode *Scope = DL.getScope(Ctx);
2240 if (Scope == 0) continue;
2242 // There is no need to create another DIE for compile unit. For all
2243 // other scopes, create one DbgScope now. This will be translated
2244 // into a scope DIE at the end.
2245 if (DIScope(Scope).isCompileUnit()) continue;
2246 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2247 DScope->setLastInsn(MInsn);
2251 if (!CurrentFnDbgScope)
2254 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2256 // Each scope has first instruction and last instruction to mark beginning
2257 // and end of a scope respectively. Create an inverse map that list scopes
2258 // starts (and ends) with an instruction. One instruction may start (or end)
2259 // multiple scopes. Ignore scopes that are not reachable.
2260 SmallVector<DbgScope *, 4> WorkList;
2261 WorkList.push_back(CurrentFnDbgScope);
2262 while (!WorkList.empty()) {
2263 DbgScope *S = WorkList.pop_back_val();
2265 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2266 if (!Children.empty())
2267 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2268 SE = Children.end(); SI != SE; ++SI)
2269 WorkList.push_back(*SI);
2271 if (S->isAbstractScope())
2273 const MachineInstr *MI = S->getFirstInsn();
2274 assert(MI && "DbgScope does not have first instruction!");
2276 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2277 if (IDI != DbgScopeBeginMap.end())
2278 IDI->second.push_back(S);
2280 DbgScopeBeginMap[MI].push_back(S);
2282 MI = S->getLastInsn();
2283 assert(MI && "DbgScope does not have last instruction!");
2284 IDI = DbgScopeEndMap.find(MI);
2285 if (IDI != DbgScopeEndMap.end())
2286 IDI->second.push_back(S);
2288 DbgScopeEndMap[MI].push_back(S);
2291 return !DbgScopeMap.empty();
2294 /// beginFunction - Gather pre-function debug information. Assumes being
2295 /// emitted immediately after the function entry point.
2296 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2297 if (!MMI->hasDebugInfo()) return;
2299 TimeRegion Timer(DebugTimer);
2300 if (!extractScopeInformation())
2303 collectVariableInfo();
2305 // Assumes in correct section after the entry point.
2306 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2307 Asm->getFunctionNumber()));
2309 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2311 DebugLoc FDL = MF->getDefaultDebugLoc();
2312 if (FDL.isUnknown()) return;
2314 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2316 DISubprogram SP = getDISubprogram(Scope);
2319 Line = SP.getLineNumber();
2322 Line = FDL.getLine();
2326 recordSourceLine(Line, Col, Scope);
2329 /// endFunction - Gather and emit post-function debug information.
2331 void DwarfDebug::endFunction(const MachineFunction *MF) {
2332 if (!MMI->hasDebugInfo() ||
2333 DbgScopeMap.empty()) return;
2335 TimeRegion Timer(DebugTimer);
2337 if (CurrentFnDbgScope) {
2338 // Define end label for subprogram.
2339 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2340 Asm->getFunctionNumber()));
2342 // Get function line info.
2343 if (!Lines.empty()) {
2344 // Get section line info.
2345 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2346 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2347 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2348 // Append the function info to section info.
2349 SectionLineInfos.insert(SectionLineInfos.end(),
2350 Lines.begin(), Lines.end());
2353 // Construct abstract scopes.
2354 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2355 AE = AbstractScopesList.end(); AI != AE; ++AI)
2356 constructScopeDIE(*AI);
2358 constructScopeDIE(CurrentFnDbgScope);
2360 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2361 MMI->getFrameMoves()));
2365 CurrentFnDbgScope = NULL;
2366 DeleteContainerSeconds(DbgScopeMap);
2367 DbgScopeBeginMap.clear();
2368 DbgScopeEndMap.clear();
2369 DbgValueStartMap.clear();
2370 ConcreteScopes.clear();
2371 DeleteContainerSeconds(AbstractScopes);
2372 AbstractScopesList.clear();
2373 AbstractVariables.clear();
2377 /// recordSourceLine - Register a source line with debug info. Returns the
2378 /// unique label that was emitted and which provides correspondence to
2379 /// the source line list.
2380 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2381 TimeRegion Timer(DebugTimer);
2386 DIDescriptor Scope(S);
2387 if (Scope.isCompileUnit()) {
2388 DICompileUnit CU(S);
2389 Dir = CU.getDirectory();
2390 Fn = CU.getFilename();
2391 } else if (Scope.isSubprogram()) {
2393 Dir = SP.getDirectory();
2394 Fn = SP.getFilename();
2395 } else if (Scope.isLexicalBlock()) {
2396 DILexicalBlock DB(S);
2397 Dir = DB.getDirectory();
2398 Fn = DB.getFilename();
2400 assert(0 && "Unexpected scope info");
2402 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2403 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2404 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2406 Asm->OutStreamer.EmitLabel(Label);
2410 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2411 /// timed. Look up the source id with the given directory and source file
2412 /// names. If none currently exists, create a new id and insert it in the
2413 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2415 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2416 const std::string &FileName) {
2417 TimeRegion Timer(DebugTimer);
2418 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2421 //===----------------------------------------------------------------------===//
2423 //===----------------------------------------------------------------------===//
2425 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2428 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2429 // Get the children.
2430 const std::vector<DIE *> &Children = Die->getChildren();
2432 // If not last sibling and has children then add sibling offset attribute.
2433 if (!Last && !Children.empty())
2434 Die->addSiblingOffset(DIEValueAllocator);
2436 // Record the abbreviation.
2437 assignAbbrevNumber(Die->getAbbrev());
2439 // Get the abbreviation for this DIE.
2440 unsigned AbbrevNumber = Die->getAbbrevNumber();
2441 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2444 Die->setOffset(Offset);
2446 // Start the size with the size of abbreviation code.
2447 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2449 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2450 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2452 // Size the DIE attribute values.
2453 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2454 // Size attribute value.
2455 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2457 // Size the DIE children if any.
2458 if (!Children.empty()) {
2459 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2460 "Children flag not set");
2462 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2463 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2465 // End of children marker.
2466 Offset += sizeof(int8_t);
2469 Die->setSize(Offset - Die->getOffset());
2473 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2475 void DwarfDebug::computeSizeAndOffsets() {
2476 // Compute size of compile unit header.
2477 static unsigned Offset =
2478 sizeof(int32_t) + // Length of Compilation Unit Info
2479 sizeof(int16_t) + // DWARF version number
2480 sizeof(int32_t) + // Offset Into Abbrev. Section
2481 sizeof(int8_t); // Pointer Size (in bytes)
2483 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2484 CompileUnitOffsets[ModuleCU] = 0;
2487 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2488 /// temporary label to it if SymbolStem is specified.
2489 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2490 const char *SymbolStem = 0) {
2491 Asm->OutStreamer.SwitchSection(Section);
2492 if (!SymbolStem) return 0;
2494 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2495 Asm->OutStreamer.EmitLabel(TmpSym);
2499 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2500 /// the start of each one.
2501 void DwarfDebug::EmitSectionLabels() {
2502 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2504 // Dwarf sections base addresses.
2505 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2506 DwarfFrameSectionSym =
2507 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2510 DwarfInfoSectionSym =
2511 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2512 DwarfAbbrevSectionSym =
2513 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2514 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2516 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2517 EmitSectionSym(Asm, MacroInfo);
2519 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2520 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2521 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2522 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2523 DwarfStrSectionSym =
2524 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2525 EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
2527 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2528 EmitSectionSym(Asm, TLOF.getDataSection());
2531 /// emitDIE - Recusively Emits a debug information entry.
2533 void DwarfDebug::emitDIE(DIE *Die) {
2534 // Get the abbreviation for this DIE.
2535 unsigned AbbrevNumber = Die->getAbbrevNumber();
2536 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2538 // Emit the code (index) for the abbreviation.
2539 if (Asm->isVerbose())
2540 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2541 Twine::utohexstr(Die->getOffset()) + ":0x" +
2542 Twine::utohexstr(Die->getSize()) + " " +
2543 dwarf::TagString(Abbrev->getTag()));
2544 Asm->EmitULEB128(AbbrevNumber);
2546 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2547 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2549 // Emit the DIE attribute values.
2550 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2551 unsigned Attr = AbbrevData[i].getAttribute();
2552 unsigned Form = AbbrevData[i].getForm();
2553 assert(Form && "Too many attributes for DIE (check abbreviation)");
2555 if (Asm->isVerbose())
2556 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2559 case dwarf::DW_AT_sibling:
2560 Asm->EmitInt32(Die->getSiblingOffset());
2562 case dwarf::DW_AT_abstract_origin: {
2563 DIEEntry *E = cast<DIEEntry>(Values[i]);
2564 DIE *Origin = E->getEntry();
2565 unsigned Addr = Origin->getOffset();
2566 Asm->EmitInt32(Addr);
2570 // Emit an attribute using the defined form.
2571 Values[i]->EmitValue(Asm, Form);
2576 // Emit the DIE children if any.
2577 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2578 const std::vector<DIE *> &Children = Die->getChildren();
2580 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2581 emitDIE(Children[j]);
2583 if (Asm->isVerbose())
2584 Asm->OutStreamer.AddComment("End Of Children Mark");
2589 /// emitDebugInfo - Emit the debug info section.
2591 void DwarfDebug::emitDebugInfo() {
2592 // Start debug info section.
2593 Asm->OutStreamer.SwitchSection(
2594 Asm->getObjFileLowering().getDwarfInfoSection());
2595 DIE *Die = ModuleCU->getCUDie();
2597 // Emit the compile units header.
2598 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2599 ModuleCU->getID()));
2601 // Emit size of content not including length itself
2602 unsigned ContentSize = Die->getSize() +
2603 sizeof(int16_t) + // DWARF version number
2604 sizeof(int32_t) + // Offset Into Abbrev. Section
2605 sizeof(int8_t) + // Pointer Size (in bytes)
2606 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2608 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2609 Asm->EmitInt32(ContentSize);
2610 Asm->OutStreamer.AddComment("DWARF version number");
2611 Asm->EmitInt16(dwarf::DWARF_VERSION);
2612 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2613 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2614 DwarfAbbrevSectionSym);
2615 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2616 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2619 // FIXME - extra padding for gdb bug.
2620 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2625 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2628 /// emitAbbreviations - Emit the abbreviation section.
2630 void DwarfDebug::emitAbbreviations() const {
2631 // Check to see if it is worth the effort.
2632 if (!Abbreviations.empty()) {
2633 // Start the debug abbrev section.
2634 Asm->OutStreamer.SwitchSection(
2635 Asm->getObjFileLowering().getDwarfAbbrevSection());
2637 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2639 // For each abbrevation.
2640 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2641 // Get abbreviation data
2642 const DIEAbbrev *Abbrev = Abbreviations[i];
2644 // Emit the abbrevations code (base 1 index.)
2645 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2647 // Emit the abbreviations data.
2651 // Mark end of abbreviations.
2652 Asm->EmitULEB128(0, "EOM(3)");
2654 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2658 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2659 /// the line matrix.
2661 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2662 // Define last address of section.
2663 Asm->OutStreamer.AddComment("Extended Op");
2666 Asm->OutStreamer.AddComment("Op size");
2667 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2668 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2669 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2671 Asm->OutStreamer.AddComment("Section end label");
2673 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2674 Asm->getTargetData().getPointerSize(),
2677 // Mark end of matrix.
2678 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2684 /// emitDebugLines - Emit source line information.
2686 void DwarfDebug::emitDebugLines() {
2687 // If the target is using .loc/.file, the assembler will be emitting the
2688 // .debug_line table automatically.
2689 if (Asm->MAI->hasDotLocAndDotFile())
2692 // Minimum line delta, thus ranging from -10..(255-10).
2693 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2694 // Maximum line delta, thus ranging from -10..(255-10).
2695 const int MaxLineDelta = 255 + MinLineDelta;
2697 // Start the dwarf line section.
2698 Asm->OutStreamer.SwitchSection(
2699 Asm->getObjFileLowering().getDwarfLineSection());
2701 // Construct the section header.
2702 Asm->OutStreamer.AddComment("Length of Source Line Info");
2703 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2704 Asm->GetTempSymbol("line_begin"), 4);
2705 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2707 Asm->OutStreamer.AddComment("DWARF version number");
2708 Asm->EmitInt16(dwarf::DWARF_VERSION);
2710 Asm->OutStreamer.AddComment("Prolog Length");
2711 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2712 Asm->GetTempSymbol("line_prolog_begin"), 4);
2713 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2715 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2717 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2719 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2720 Asm->EmitInt8(MinLineDelta);
2721 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2722 Asm->EmitInt8(MaxLineDelta);
2723 Asm->OutStreamer.AddComment("Special Opcode Base");
2724 Asm->EmitInt8(-MinLineDelta);
2726 // Line number standard opcode encodings argument count
2727 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2729 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2731 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2733 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2735 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2737 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2739 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2741 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2743 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2746 // Emit directories.
2747 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2748 const std::string &Dir = getSourceDirectoryName(DI);
2749 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2750 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2753 Asm->OutStreamer.AddComment("End of directories");
2757 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2758 // Remember source id starts at 1.
2759 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2760 const std::string &FN = getSourceFileName(Id.second);
2761 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2762 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2764 Asm->EmitULEB128(Id.first, "Directory #");
2765 Asm->EmitULEB128(0, "Mod date");
2766 Asm->EmitULEB128(0, "File size");
2769 Asm->OutStreamer.AddComment("End of files");
2772 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2774 // A sequence for each text section.
2775 unsigned SecSrcLinesSize = SectionSourceLines.size();
2777 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2778 // Isolate current sections line info.
2779 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2781 // Dwarf assumes we start with first line of first source file.
2782 unsigned Source = 1;
2785 // Construct rows of the address, source, line, column matrix.
2786 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2787 const SrcLineInfo &LineInfo = LineInfos[i];
2788 MCSymbol *Label = LineInfo.getLabel();
2789 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2791 if (LineInfo.getLine() == 0) continue;
2793 if (Asm->isVerbose()) {
2794 std::pair<unsigned, unsigned> SrcID =
2795 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2796 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2798 Twine(getSourceFileName(SrcID.second)) +
2799 ":" + Twine(LineInfo.getLine()));
2802 // Define the line address.
2803 Asm->OutStreamer.AddComment("Extended Op");
2805 Asm->OutStreamer.AddComment("Op size");
2806 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2808 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2809 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2811 Asm->OutStreamer.AddComment("Location label");
2812 Asm->OutStreamer.EmitSymbolValue(Label,
2813 Asm->getTargetData().getPointerSize(),
2816 // If change of source, then switch to the new source.
2817 if (Source != LineInfo.getSourceID()) {
2818 Source = LineInfo.getSourceID();
2819 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2820 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2821 Asm->EmitULEB128(Source, "New Source");
2824 // If change of line.
2825 if (Line != LineInfo.getLine()) {
2826 // Determine offset.
2827 int Offset = LineInfo.getLine() - Line;
2828 int Delta = Offset - MinLineDelta;
2831 Line = LineInfo.getLine();
2833 // If delta is small enough and in range...
2834 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2835 // ... then use fast opcode.
2836 Asm->OutStreamer.AddComment("Line Delta");
2837 Asm->EmitInt8(Delta - MinLineDelta);
2839 // ... otherwise use long hand.
2840 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2841 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2842 Asm->EmitSLEB128(Offset, "Line Offset");
2843 Asm->OutStreamer.AddComment("DW_LNS_copy");
2844 Asm->EmitInt8(dwarf::DW_LNS_copy);
2847 // Copy the previous row (different address or source)
2848 Asm->OutStreamer.AddComment("DW_LNS_copy");
2849 Asm->EmitInt8(dwarf::DW_LNS_copy);
2853 emitEndOfLineMatrix(j + 1);
2856 if (SecSrcLinesSize == 0)
2857 // Because we're emitting a debug_line section, we still need a line
2858 // table. The linker and friends expect it to exist. If there's nothing to
2859 // put into it, emit an empty table.
2860 emitEndOfLineMatrix(1);
2862 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2865 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2867 void DwarfDebug::emitCommonDebugFrame() {
2868 if (!Asm->MAI->doesDwarfRequireFrameSection())
2871 int stackGrowth = Asm->getTargetData().getPointerSize();
2872 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2873 TargetFrameInfo::StackGrowsDown)
2876 // Start the dwarf frame section.
2877 Asm->OutStreamer.SwitchSection(
2878 Asm->getObjFileLowering().getDwarfFrameSection());
2880 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2881 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2882 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2883 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2885 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2886 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2887 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2888 Asm->OutStreamer.AddComment("CIE Version");
2889 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2890 Asm->OutStreamer.AddComment("CIE Augmentation");
2891 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2892 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2893 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2894 Asm->OutStreamer.AddComment("CIE RA Column");
2895 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2896 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2898 std::vector<MachineMove> Moves;
2899 RI->getInitialFrameState(Moves);
2901 Asm->EmitFrameMoves(Moves, 0, false);
2903 Asm->EmitAlignment(2, 0, 0, false);
2904 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2907 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2910 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2911 if (!Asm->MAI->doesDwarfRequireFrameSection())
2914 // Start the dwarf frame section.
2915 Asm->OutStreamer.SwitchSection(
2916 Asm->getObjFileLowering().getDwarfFrameSection());
2918 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2919 MCSymbol *DebugFrameBegin =
2920 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2921 MCSymbol *DebugFrameEnd =
2922 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2923 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2925 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2927 Asm->OutStreamer.AddComment("FDE CIE offset");
2928 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2929 DwarfFrameSectionSym);
2931 Asm->OutStreamer.AddComment("FDE initial location");
2932 MCSymbol *FuncBeginSym =
2933 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2934 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2935 Asm->getTargetData().getPointerSize(),
2939 Asm->OutStreamer.AddComment("FDE address range");
2940 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2941 FuncBeginSym, Asm->getTargetData().getPointerSize());
2943 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2945 Asm->EmitAlignment(2, 0, 0, false);
2946 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2949 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2951 void DwarfDebug::emitDebugPubNames() {
2952 // Start the dwarf pubnames section.
2953 Asm->OutStreamer.SwitchSection(
2954 Asm->getObjFileLowering().getDwarfPubNamesSection());
2956 Asm->OutStreamer.AddComment("Length of Public Names Info");
2957 Asm->EmitLabelDifference(
2958 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2959 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2961 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2962 ModuleCU->getID()));
2964 Asm->OutStreamer.AddComment("DWARF Version");
2965 Asm->EmitInt16(dwarf::DWARF_VERSION);
2967 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2968 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2969 DwarfInfoSectionSym);
2971 Asm->OutStreamer.AddComment("Compilation Unit Length");
2972 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2973 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2976 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2977 for (StringMap<DIE*>::const_iterator
2978 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2979 const char *Name = GI->getKeyData();
2980 DIE *Entity = GI->second;
2982 Asm->OutStreamer.AddComment("DIE offset");
2983 Asm->EmitInt32(Entity->getOffset());
2985 if (Asm->isVerbose())
2986 Asm->OutStreamer.AddComment("External Name");
2987 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2990 Asm->OutStreamer.AddComment("End Mark");
2992 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2993 ModuleCU->getID()));
2996 void DwarfDebug::emitDebugPubTypes() {
2997 // Start the dwarf pubnames section.
2998 Asm->OutStreamer.SwitchSection(
2999 Asm->getObjFileLowering().getDwarfPubTypesSection());
3000 Asm->OutStreamer.AddComment("Length of Public Types Info");
3001 Asm->EmitLabelDifference(
3002 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
3003 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
3005 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3006 ModuleCU->getID()));
3008 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3009 Asm->EmitInt16(dwarf::DWARF_VERSION);
3011 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
3012 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3013 DwarfInfoSectionSym);
3015 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
3016 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
3017 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3020 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
3021 for (StringMap<DIE*>::const_iterator
3022 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3023 const char *Name = GI->getKeyData();
3024 DIE * Entity = GI->second;
3026 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3027 Asm->EmitInt32(Entity->getOffset());
3029 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3030 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3033 Asm->OutStreamer.AddComment("End Mark");
3035 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3036 ModuleCU->getID()));
3039 /// emitDebugStr - Emit visible names into a debug str section.
3041 void DwarfDebug::emitDebugStr() {
3042 // Check to see if it is worth the effort.
3043 if (StringPool.empty()) return;
3045 // Start the dwarf str section.
3046 Asm->OutStreamer.SwitchSection(
3047 Asm->getObjFileLowering().getDwarfStrSection());
3049 // Get all of the string pool entries and put them in an array by their ID so
3050 // we can sort them.
3051 SmallVector<std::pair<unsigned,
3052 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3054 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3055 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3056 Entries.push_back(std::make_pair(I->second.second, &*I));
3058 array_pod_sort(Entries.begin(), Entries.end());
3060 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3061 // Emit a label for reference from debug information entries.
3062 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3064 // Emit the string itself.
3065 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3069 /// emitDebugLoc - Emit visible names into a debug loc section.
3071 void DwarfDebug::emitDebugLoc() {
3072 // Start the dwarf loc section.
3073 Asm->OutStreamer.SwitchSection(
3074 Asm->getObjFileLowering().getDwarfLocSection());
3077 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3079 void DwarfDebug::EmitDebugARanges() {
3080 // Start the dwarf aranges section.
3081 Asm->OutStreamer.SwitchSection(
3082 Asm->getObjFileLowering().getDwarfARangesSection());
3085 /// emitDebugRanges - Emit visible names into a debug ranges section.
3087 void DwarfDebug::emitDebugRanges() {
3088 // Start the dwarf ranges section.
3089 Asm->OutStreamer.SwitchSection(
3090 Asm->getObjFileLowering().getDwarfRangesSection());
3093 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3095 void DwarfDebug::emitDebugMacInfo() {
3096 if (const MCSection *LineInfo =
3097 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3098 // Start the dwarf macinfo section.
3099 Asm->OutStreamer.SwitchSection(LineInfo);
3103 /// emitDebugInlineInfo - Emit inline info using following format.
3105 /// 1. length of section
3106 /// 2. Dwarf version number
3107 /// 3. address size.
3109 /// Entries (one "entry" for each function that was inlined):
3111 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3112 /// otherwise offset into __debug_str for regular function name.
3113 /// 2. offset into __debug_str section for regular function name.
3114 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3115 /// instances for the function.
3117 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3118 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3119 /// __debug_info section, and the low_pc is the starting address for the
3120 /// inlining instance.
3121 void DwarfDebug::emitDebugInlineInfo() {
3122 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3128 Asm->OutStreamer.SwitchSection(
3129 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3131 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3132 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3133 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3135 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3137 Asm->OutStreamer.AddComment("Dwarf Version");
3138 Asm->EmitInt16(dwarf::DWARF_VERSION);
3139 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3140 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3142 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3143 E = InlinedSPNodes.end(); I != E; ++I) {
3146 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3147 = InlineInfo.find(Node);
3148 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3149 DISubprogram SP(Node);
3150 StringRef LName = SP.getLinkageName();
3151 StringRef Name = SP.getName();
3153 Asm->OutStreamer.AddComment("MIPS linkage name");
3154 if (LName.empty()) {
3155 Asm->OutStreamer.EmitBytes(Name, 0);
3156 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3158 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3159 DwarfStrSectionSym);
3161 Asm->OutStreamer.AddComment("Function name");
3162 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3163 Asm->EmitULEB128(Labels.size(), "Inline count");
3165 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3166 LE = Labels.end(); LI != LE; ++LI) {
3167 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3168 Asm->EmitInt32(LI->second->getOffset());
3170 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3171 Asm->OutStreamer.EmitSymbolValue(LI->first,
3172 Asm->getTargetData().getPointerSize(),0);
3176 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));