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 /// isSubprogramContext - Return true if Context is either a subprogram
1336 /// or another context nested inside a subprogram.
1337 bool isSubprogramContext(MDNode *Context) {
1340 DIDescriptor D(Context);
1341 if (D.isSubprogram())
1344 return isSubprogramContext(DIType(Context).getContext().getNode());
1348 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1349 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1350 /// If there are global variables in this scope then create and insert
1351 /// DIEs for these variables.
1352 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1353 DIE *SPDie = ModuleCU->getDIE(SPNode);
1354 assert(SPDie && "Unable to find subprogram DIE!");
1355 DISubprogram SP(SPNode);
1357 // There is not any need to generate specification DIE for a function
1358 // defined at compile unit level. If a function is defined inside another
1359 // function then gdb prefers the definition at top level and but does not
1360 // expect specification DIE in parent function. So avoid creating
1361 // specification DIE for a function defined inside a function.
1362 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1363 !SP.getContext().isFile() &&
1364 !isSubprogramContext(SP.getContext().getNode())) {
1365 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1368 DICompositeType SPTy = SP.getType();
1369 DIArray Args = SPTy.getTypeArray();
1370 unsigned SPTag = SPTy.getTag();
1371 if (SPTag == dwarf::DW_TAG_subroutine_type)
1372 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1373 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1374 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1376 if (ATy.isArtificial())
1377 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1378 SPDie->addChild(Arg);
1380 DIE *SPDeclDie = SPDie;
1381 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1382 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1384 ModuleCU->addDie(SPDie);
1387 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1388 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1389 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1390 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1391 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1392 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1393 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1395 if (!DISubprogram(SPNode).isLocalToUnit())
1396 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1401 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1402 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1403 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1404 MCSymbol *Start = Scope->getStartLabel();
1405 MCSymbol *End = Scope->getEndLabel();
1406 if (Start == 0 || End == 0) return 0;
1408 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1409 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1411 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1412 if (Scope->isAbstractScope())
1415 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1416 Start ? Start : Asm->GetTempSymbol("func_begin",
1417 Asm->getFunctionNumber()));
1418 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1419 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1424 /// constructInlinedScopeDIE - This scope represents inlined body of
1425 /// a function. Construct DIE to represent this concrete inlined copy
1426 /// of the function.
1427 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1428 MCSymbol *StartLabel = Scope->getStartLabel();
1429 MCSymbol *EndLabel = Scope->getEndLabel();
1430 if (StartLabel == 0 || EndLabel == 0) return 0;
1432 assert(StartLabel->isDefined() &&
1433 "Invalid starting label for an inlined scope!");
1434 assert(EndLabel->isDefined() &&
1435 "Invalid end label for an inlined scope!");
1436 if (!Scope->getScopeNode())
1438 DIScope DS(Scope->getScopeNode());
1439 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1441 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1442 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1443 assert(OriginDIE && "Unable to find Origin DIE!");
1444 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1445 dwarf::DW_FORM_ref4, OriginDIE);
1447 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1448 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1450 InlinedSubprogramDIEs.insert(OriginDIE);
1452 // Track the start label for this inlined function.
1453 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1454 I = InlineInfo.find(InlinedSP.getNode());
1456 if (I == InlineInfo.end()) {
1457 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1459 InlinedSPNodes.push_back(InlinedSP.getNode());
1461 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1463 DILocation DL(Scope->getInlinedAt());
1464 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1465 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1471 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1472 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1473 // Get the descriptor.
1474 const DIVariable &VD = DV->getVariable();
1475 StringRef Name = VD.getName();
1479 // Translate tag to proper Dwarf tag. The result variable is dropped for
1482 switch (VD.getTag()) {
1483 case dwarf::DW_TAG_return_variable:
1485 case dwarf::DW_TAG_arg_variable:
1486 Tag = dwarf::DW_TAG_formal_parameter;
1488 case dwarf::DW_TAG_auto_variable: // fall thru
1490 Tag = dwarf::DW_TAG_variable;
1494 // Define variable debug information entry.
1495 DIE *VariableDie = new DIE(Tag);
1499 if (DbgVariable *AV = DV->getAbstractVariable())
1500 AbsDIE = AV->getDIE();
1503 DIScope DS(Scope->getScopeNode());
1504 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1505 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1507 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1508 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1509 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1510 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1511 dwarf::DW_FORM_ref4, AbsDIE);
1514 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1515 addSourceLine(VariableDie, &VD);
1517 // Add variable type.
1518 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1519 // addresses instead.
1520 if (VD.isBlockByrefVariable())
1521 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1523 addType(VariableDie, VD.getType());
1526 // Add variable address.
1527 if (!Scope->isAbstractScope()) {
1528 // Check if variable is described by DBG_VALUE instruction.
1529 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1530 if (DbgValueInsn->getNumOperands() == 3) {
1531 // FIXME : Handle getNumOperands != 3
1532 if (DbgValueInsn->getOperand(0).getType()
1533 == MachineOperand::MO_Register
1534 && DbgValueInsn->getOperand(0).getReg()) {
1535 MachineLocation Location;
1536 Location.set(DbgValueInsn->getOperand(0).getReg());
1537 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1538 if (MCSymbol *VS = DV->getDbgValueLabel())
1539 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1541 } else if (DbgValueInsn->getOperand(0).getType() ==
1542 MachineOperand::MO_Immediate) {
1543 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1544 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1545 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1546 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1547 if (MCSymbol *VS = DV->getDbgValueLabel())
1548 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1550 } else if (DbgValueInsn->getOperand(0).getType() ==
1551 MachineOperand::MO_FPImmediate) {
1552 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1553 APFloat FPImm = DbgValueInsn->getOperand(0).getFPImm()->getValueAPF();
1555 // Get the raw data form of the floating point.
1556 const APInt FltVal = FPImm.bitcastToAPInt();
1557 const char *FltPtr = (const char*)FltVal.getRawData();
1559 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
1560 bool LittleEndian = Asm->getTargetData().isLittleEndian();
1561 int Incr = (LittleEndian ? 1 : -1);
1562 int Start = (LittleEndian ? 0 : NumBytes - 1);
1563 int Stop = (LittleEndian ? NumBytes : -1);
1565 // Output the constant to DWARF one byte at a time.
1566 for (; Start != Stop; Start += Incr)
1567 addUInt(Block, 0, dwarf::DW_FORM_data1,
1568 (unsigned char)0xFF & FltPtr[Start]);
1570 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1572 if (MCSymbol *VS = DV->getDbgValueLabel())
1573 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1576 //FIXME : Handle other operand types.
1582 MachineLocation Location;
1584 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1585 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1587 Location.set(FrameReg, Offset);
1589 if (VD.hasComplexAddress())
1590 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1591 else if (VD.isBlockByrefVariable())
1592 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1594 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1598 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1599 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1600 DV->setDIE(VariableDie);
1605 void DwarfDebug::addPubTypes(DISubprogram SP) {
1606 DICompositeType SPTy = SP.getType();
1607 unsigned SPTag = SPTy.getTag();
1608 if (SPTag != dwarf::DW_TAG_subroutine_type)
1611 DIArray Args = SPTy.getTypeArray();
1612 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1613 DIType ATy(Args.getElement(i).getNode());
1616 DICompositeType CATy = getDICompositeType(ATy);
1617 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1618 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1619 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1624 /// constructScopeDIE - Construct a DIE for this scope.
1625 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1626 if (!Scope || !Scope->getScopeNode())
1629 DIScope DS(Scope->getScopeNode());
1630 DIE *ScopeDIE = NULL;
1631 if (Scope->getInlinedAt())
1632 ScopeDIE = constructInlinedScopeDIE(Scope);
1633 else if (DS.isSubprogram()) {
1634 if (Scope->isAbstractScope())
1635 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1637 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1640 ScopeDIE = constructLexicalScopeDIE(Scope);
1641 if (!ScopeDIE) return NULL;
1643 // Add variables to scope.
1644 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1645 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1646 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1648 ScopeDIE->addChild(VariableDIE);
1651 // Add nested scopes.
1652 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1653 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1654 // Define the Scope debug information entry.
1655 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1657 ScopeDIE->addChild(NestedDIE);
1660 if (DS.isSubprogram())
1661 addPubTypes(DISubprogram(DS.getNode()));
1666 /// GetOrCreateSourceID - Look up the source id with the given directory and
1667 /// source file names. If none currently exists, create a new id and insert it
1668 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1670 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1672 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1673 if (DI != DirectoryIdMap.end()) {
1674 DId = DI->getValue();
1676 DId = DirectoryNames.size() + 1;
1677 DirectoryIdMap[DirName] = DId;
1678 DirectoryNames.push_back(DirName);
1682 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1683 if (FI != SourceFileIdMap.end()) {
1684 FId = FI->getValue();
1686 FId = SourceFileNames.size() + 1;
1687 SourceFileIdMap[FileName] = FId;
1688 SourceFileNames.push_back(FileName);
1691 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1692 SourceIdMap.find(std::make_pair(DId, FId));
1693 if (SI != SourceIdMap.end())
1696 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1697 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1698 SourceIds.push_back(std::make_pair(DId, FId));
1703 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1704 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1705 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1708 NDie = new DIE(dwarf::DW_TAG_namespace);
1709 ModuleCU->insertDIE(NS.getNode(), NDie);
1710 if (!NS.getName().empty())
1711 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1712 addSourceLine(NDie, &NS);
1713 addToContextOwner(NDie, NS.getContext());
1717 void DwarfDebug::constructCompileUnit(MDNode *N) {
1718 DICompileUnit DIUnit(N);
1719 // Use first compile unit marked as isMain as the compile unit for this
1721 if (ModuleCU || !DIUnit.isMain())
1723 StringRef FN = DIUnit.getFilename();
1724 StringRef Dir = DIUnit.getDirectory();
1725 unsigned ID = GetOrCreateSourceID(Dir, FN);
1727 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1728 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1729 DIUnit.getProducer());
1730 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1731 DIUnit.getLanguage());
1732 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1733 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1734 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1735 Asm->GetTempSymbol("text_end"));
1736 // DW_AT_stmt_list is a offset of line number information for this
1737 // compile unit in debug_line section. It is always zero when only one
1738 // compile unit is emitted in one object file.
1739 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1742 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1743 if (DIUnit.isOptimized())
1744 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1746 StringRef Flags = DIUnit.getFlags();
1748 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1750 unsigned RVer = DIUnit.getRunTimeVersion();
1752 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1753 dwarf::DW_FORM_data1, RVer);
1756 "ModuleCU assigned since the top of constructCompileUnit");
1757 ModuleCU = new CompileUnit(ID, Die);
1760 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1761 DIGlobalVariable DI_GV(N);
1763 // If debug information is malformed then ignore it.
1764 if (DI_GV.Verify() == false)
1767 // Check for pre-existence.
1768 if (ModuleCU->getDIE(DI_GV.getNode()))
1771 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1776 ModuleCU->insertDIE(N, VariableDie);
1778 // Add to context owner.
1779 DIDescriptor GVContext = DI_GV.getContext();
1780 // Do not create specification DIE if context is either compile unit
1782 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1783 !GVContext.isFile() &&
1784 !isSubprogramContext(GVContext.getNode())) {
1785 // Create specification DIE.
1786 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1787 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1788 dwarf::DW_FORM_ref4, VariableDie);
1789 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1790 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1791 addLabel(Block, 0, dwarf::DW_FORM_udata,
1792 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1793 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1794 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1795 ModuleCU->addDie(VariableSpecDIE);
1797 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1798 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1799 addLabel(Block, 0, dwarf::DW_FORM_udata,
1800 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1801 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1803 addToContextOwner(VariableDie, GVContext);
1805 // Expose as global. FIXME - need to check external flag.
1806 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1808 DIType GTy = DI_GV.getType();
1809 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1810 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1811 assert(Entry && "Missing global type!");
1812 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1817 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1820 // Check for pre-existence.
1821 if (ModuleCU->getDIE(N))
1824 if (!SP.isDefinition())
1825 // This is a method declaration which will be handled while constructing
1829 DIE *SubprogramDie = createSubprogramDIE(SP);
1832 ModuleCU->insertDIE(N, SubprogramDie);
1834 // Add to context owner.
1835 addToContextOwner(SubprogramDie, SP.getContext());
1837 // Expose as global.
1838 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1843 /// beginModule - Emit all Dwarf sections that should come prior to the
1844 /// content. Create global DIEs and emit initial debug info sections.
1845 /// This is inovked by the target AsmPrinter.
1846 void DwarfDebug::beginModule(Module *M) {
1847 TimeRegion Timer(DebugTimer);
1849 DebugInfoFinder DbgFinder;
1850 DbgFinder.processModule(*M);
1852 bool HasDebugInfo = false;
1854 // Scan all the compile-units to see if there are any marked as the main unit.
1855 // if not, we do not generate debug info.
1856 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1857 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1858 if (DICompileUnit(*I).isMain()) {
1859 HasDebugInfo = true;
1864 if (!HasDebugInfo) return;
1866 // Tell MMI that we have debug info.
1867 MMI->setDebugInfoAvailability(true);
1869 // Emit initial sections.
1870 EmitSectionLabels();
1872 // Create all the compile unit DIEs.
1873 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1874 E = DbgFinder.compile_unit_end(); I != E; ++I)
1875 constructCompileUnit(*I);
1877 // Create DIEs for each subprogram.
1878 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1879 E = DbgFinder.subprogram_end(); I != E; ++I)
1880 constructSubprogramDIE(*I);
1882 // Create DIEs for each global variable.
1883 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1884 E = DbgFinder.global_variable_end(); I != E; ++I)
1885 constructGlobalVariableDIE(*I);
1887 // Prime section data.
1888 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1890 // Print out .file directives to specify files for .loc directives. These are
1891 // printed out early so that they precede any .loc directives.
1892 if (Asm->MAI->hasDotLocAndDotFile()) {
1893 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1894 // Remember source id starts at 1.
1895 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1896 // FIXME: don't use sys::path for this! This should not depend on the
1898 sys::Path FullPath(getSourceDirectoryName(Id.first));
1900 FullPath.appendComponent(getSourceFileName(Id.second));
1901 assert(AppendOk && "Could not append filename to directory!");
1903 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1908 /// endModule - Emit all Dwarf sections that should come after the content.
1910 void DwarfDebug::endModule() {
1914 TimeRegion Timer(DebugTimer);
1916 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1917 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1918 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1920 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1923 // Insert top level DIEs.
1924 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1925 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1926 ModuleCU->getCUDie()->addChild(*TI);
1928 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1929 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1930 DIE *SPDie = CI->first;
1931 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1933 DIE *NDie = ModuleCU->getDIE(N);
1934 if (!NDie) continue;
1935 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1936 // FIXME - This is not the correct approach.
1937 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
1940 // Standard sections final addresses.
1941 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1942 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1943 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1944 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1946 // End text sections.
1947 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1948 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1949 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1952 // Emit common frame information.
1953 emitCommonDebugFrame();
1955 // Emit function debug frame information
1956 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1957 E = DebugFrames.end(); I != E; ++I)
1958 emitFunctionDebugFrame(*I);
1960 // Compute DIE offsets and sizes.
1961 computeSizeAndOffsets();
1963 // Emit all the DIEs into a debug info section
1966 // Corresponding abbreviations into a abbrev section.
1967 emitAbbreviations();
1969 // Emit source line correspondence into a debug line section.
1972 // Emit info into a debug pubnames section.
1973 emitDebugPubNames();
1975 // Emit info into a debug pubtypes section.
1976 emitDebugPubTypes();
1978 // Emit info into a debug loc section.
1981 // Emit info into a debug aranges section.
1984 // Emit info into a debug ranges section.
1987 // Emit info into a debug macinfo section.
1990 // Emit inline info.
1991 emitDebugInlineInfo();
1993 // Emit info into a debug str section.
1997 ModuleCU = NULL; // Reset for the next Module, if any.
2000 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2001 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2003 DebugLoc ScopeLoc) {
2005 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
2007 return AbsDbgVariable;
2009 LLVMContext &Ctx = Var.getNode()->getContext();
2010 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2014 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
2015 NULL /* No more-abstract variable*/);
2016 Scope->addVariable(AbsDbgVariable);
2017 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2018 return AbsDbgVariable;
2021 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2022 /// FIXME : Refactor findAbstractVariable.
2023 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2024 const MachineInstr *MI,
2025 DebugLoc ScopeLoc) {
2027 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
2029 return AbsDbgVariable;
2031 LLVMContext &Ctx = Var.getNode()->getContext();
2032 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2036 AbsDbgVariable = new DbgVariable(Var, MI,
2037 NULL /* No more-abstract variable*/);
2038 Scope->addVariable(AbsDbgVariable);
2039 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2040 DbgValueStartMap[MI] = AbsDbgVariable;
2041 return AbsDbgVariable;
2044 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2045 void DwarfDebug::collectVariableInfo() {
2046 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2048 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2049 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2050 VE = VMap.end(); VI != VE; ++VI) {
2051 MDNode *Var = VI->first;
2054 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2056 DbgScope *Scope = 0;
2057 if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2058 Scope = ConcreteScopes.lookup(IA);
2060 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2062 // If variable scope is not found then skip this variable.
2066 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2067 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2068 Scope->addVariable(RegVar);
2071 // Collect variable information from DBG_VALUE machine instructions;
2072 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2074 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2076 const MachineInstr *MInsn = II;
2077 if (!MInsn->isDebugValue())
2080 // FIXME : Lift this restriction.
2081 if (MInsn->getNumOperands() != 3)
2083 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2084 - 1).getMetadata()));
2085 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2086 // FIXME Handle inlined subroutine arguments.
2087 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2088 CurrentFnDbgScope->addVariable(ArgVar);
2089 DbgValueStartMap[MInsn] = ArgVar;
2093 DebugLoc DL = MInsn->getDebugLoc();
2094 if (DL.isUnknown()) continue;
2095 DbgScope *Scope = 0;
2096 if (MDNode *IA = DL.getInlinedAt(Ctx))
2097 Scope = ConcreteScopes.lookup(IA);
2099 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2101 // If variable scope is not found then skip this variable.
2105 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2106 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2107 DbgValueStartMap[MInsn] = RegVar;
2108 Scope->addVariable(RegVar);
2113 /// beginScope - Process beginning of a scope.
2114 void DwarfDebug::beginScope(const MachineInstr *MI) {
2116 DebugLoc DL = MI->getDebugLoc();
2120 // Check and update last known location info.
2121 if (DL == PrevInstLoc)
2124 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2126 // FIXME: Should only verify each scope once!
2127 if (!DIScope(Scope).Verify())
2130 // DBG_VALUE instruction establishes new value.
2131 if (MI->isDebugValue()) {
2132 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2133 = DbgValueStartMap.find(MI);
2134 if (DI != DbgValueStartMap.end()) {
2135 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2137 DI->second->setDbgValueLabel(Label);
2142 // Emit a label to indicate location change. This is used for line
2143 // table even if this instruction does start a new scope.
2144 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2147 // update DbgScope if this instruction starts a new scope.
2148 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2149 if (I == DbgScopeBeginMap.end())
2152 ScopeVector &SD = I->second;
2153 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2155 (*SDI)->setStartLabel(Label);
2158 /// endScope - Process end of a scope.
2159 void DwarfDebug::endScope(const MachineInstr *MI) {
2160 // Ignore DBG_VALUE instruction.
2161 if (MI->isDebugValue())
2165 DebugLoc DL = MI->getDebugLoc();
2169 // Emit a label and update DbgScope if this instruction ends a scope.
2170 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2171 if (I == DbgScopeEndMap.end())
2174 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2175 Asm->OutStreamer.EmitLabel(Label);
2177 SmallVector<DbgScope*, 2> &SD = I->second;
2178 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2180 (*SDI)->setEndLabel(Label);
2184 /// createDbgScope - Create DbgScope for the scope.
2185 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2187 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2190 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2191 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2192 if (DIDescriptor(Scope).isLexicalBlock())
2193 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2197 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2201 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2202 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2203 DILocation DL(InlinedAt);
2204 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2207 /// extractScopeInformation - Scan machine instructions in this function
2208 /// and collect DbgScopes. Return true, if at least one scope was found.
2209 bool DwarfDebug::extractScopeInformation() {
2210 // If scope information was extracted using .dbg intrinsics then there is not
2211 // any need to extract these information by scanning each instruction.
2212 if (!DbgScopeMap.empty())
2215 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2216 unsigned MIIndex = 0;
2217 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2219 // Scan each instruction and create scopes. First build working set of scopes.
2220 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2222 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2224 const MachineInstr *MInsn = II;
2225 // FIXME : Remove DBG_VALUE check.
2226 if (MInsn->isDebugValue()) continue;
2227 MIIndexMap[MInsn] = MIIndex++;
2229 DebugLoc DL = MInsn->getDebugLoc();
2230 if (DL.isUnknown()) continue;
2232 MDNode *Scope = DL.getScope(Ctx);
2234 // There is no need to create another DIE for compile unit. For all
2235 // other scopes, create one DbgScope now. This will be translated
2236 // into a scope DIE at the end.
2237 if (DIScope(Scope).isCompileUnit()) continue;
2238 createDbgScope(Scope, DL.getInlinedAt(Ctx));
2243 // Build scope hierarchy using working set of scopes.
2244 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2246 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2248 const MachineInstr *MInsn = II;
2249 // FIXME : Remove DBG_VALUE check.
2250 if (MInsn->isDebugValue()) continue;
2251 DebugLoc DL = MInsn->getDebugLoc();
2252 if (DL.isUnknown()) continue;
2254 MDNode *Scope = DL.getScope(Ctx);
2255 if (Scope == 0) continue;
2257 // There is no need to create another DIE for compile unit. For all
2258 // other scopes, create one DbgScope now. This will be translated
2259 // into a scope DIE at the end.
2260 if (DIScope(Scope).isCompileUnit()) continue;
2261 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2262 DScope->setLastInsn(MInsn);
2266 if (!CurrentFnDbgScope)
2269 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2271 // Each scope has first instruction and last instruction to mark beginning
2272 // and end of a scope respectively. Create an inverse map that list scopes
2273 // starts (and ends) with an instruction. One instruction may start (or end)
2274 // multiple scopes. Ignore scopes that are not reachable.
2275 SmallVector<DbgScope *, 4> WorkList;
2276 WorkList.push_back(CurrentFnDbgScope);
2277 while (!WorkList.empty()) {
2278 DbgScope *S = WorkList.pop_back_val();
2280 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2281 if (!Children.empty())
2282 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2283 SE = Children.end(); SI != SE; ++SI)
2284 WorkList.push_back(*SI);
2286 if (S->isAbstractScope())
2288 const MachineInstr *MI = S->getFirstInsn();
2289 assert(MI && "DbgScope does not have first instruction!");
2291 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2292 if (IDI != DbgScopeBeginMap.end())
2293 IDI->second.push_back(S);
2295 DbgScopeBeginMap[MI].push_back(S);
2297 MI = S->getLastInsn();
2298 assert(MI && "DbgScope does not have last instruction!");
2299 IDI = DbgScopeEndMap.find(MI);
2300 if (IDI != DbgScopeEndMap.end())
2301 IDI->second.push_back(S);
2303 DbgScopeEndMap[MI].push_back(S);
2306 return !DbgScopeMap.empty();
2309 /// beginFunction - Gather pre-function debug information. Assumes being
2310 /// emitted immediately after the function entry point.
2311 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2312 if (!MMI->hasDebugInfo()) return;
2314 TimeRegion Timer(DebugTimer);
2315 if (!extractScopeInformation())
2318 collectVariableInfo();
2320 // Assumes in correct section after the entry point.
2321 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2322 Asm->getFunctionNumber()));
2324 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2326 DebugLoc FDL = MF->getDefaultDebugLoc();
2327 if (FDL.isUnknown()) return;
2329 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2331 DISubprogram SP = getDISubprogram(Scope);
2334 Line = SP.getLineNumber();
2337 Line = FDL.getLine();
2341 recordSourceLine(Line, Col, Scope);
2344 /// endFunction - Gather and emit post-function debug information.
2346 void DwarfDebug::endFunction(const MachineFunction *MF) {
2347 if (!MMI->hasDebugInfo() ||
2348 DbgScopeMap.empty()) return;
2350 TimeRegion Timer(DebugTimer);
2352 if (CurrentFnDbgScope) {
2353 // Define end label for subprogram.
2354 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2355 Asm->getFunctionNumber()));
2357 // Get function line info.
2358 if (!Lines.empty()) {
2359 // Get section line info.
2360 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2361 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2362 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2363 // Append the function info to section info.
2364 SectionLineInfos.insert(SectionLineInfos.end(),
2365 Lines.begin(), Lines.end());
2368 // Construct abstract scopes.
2369 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2370 AE = AbstractScopesList.end(); AI != AE; ++AI)
2371 constructScopeDIE(*AI);
2373 constructScopeDIE(CurrentFnDbgScope);
2375 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2376 MMI->getFrameMoves()));
2380 CurrentFnDbgScope = NULL;
2381 DeleteContainerSeconds(DbgScopeMap);
2382 DbgScopeBeginMap.clear();
2383 DbgScopeEndMap.clear();
2384 DbgValueStartMap.clear();
2385 ConcreteScopes.clear();
2386 DeleteContainerSeconds(AbstractScopes);
2387 AbstractScopesList.clear();
2388 AbstractVariables.clear();
2392 /// recordSourceLine - Register a source line with debug info. Returns the
2393 /// unique label that was emitted and which provides correspondence to
2394 /// the source line list.
2395 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2396 TimeRegion Timer(DebugTimer);
2401 DIDescriptor Scope(S);
2402 if (Scope.isCompileUnit()) {
2403 DICompileUnit CU(S);
2404 Dir = CU.getDirectory();
2405 Fn = CU.getFilename();
2406 } else if (Scope.isSubprogram()) {
2408 Dir = SP.getDirectory();
2409 Fn = SP.getFilename();
2410 } else if (Scope.isLexicalBlock()) {
2411 DILexicalBlock DB(S);
2412 Dir = DB.getDirectory();
2413 Fn = DB.getFilename();
2415 assert(0 && "Unexpected scope info");
2417 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2418 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2419 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2421 Asm->OutStreamer.EmitLabel(Label);
2425 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2426 /// timed. Look up the source id with the given directory and source file
2427 /// names. If none currently exists, create a new id and insert it in the
2428 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2430 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2431 const std::string &FileName) {
2432 TimeRegion Timer(DebugTimer);
2433 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2436 //===----------------------------------------------------------------------===//
2438 //===----------------------------------------------------------------------===//
2440 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2443 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2444 // Get the children.
2445 const std::vector<DIE *> &Children = Die->getChildren();
2447 // If not last sibling and has children then add sibling offset attribute.
2448 if (!Last && !Children.empty())
2449 Die->addSiblingOffset(DIEValueAllocator);
2451 // Record the abbreviation.
2452 assignAbbrevNumber(Die->getAbbrev());
2454 // Get the abbreviation for this DIE.
2455 unsigned AbbrevNumber = Die->getAbbrevNumber();
2456 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2459 Die->setOffset(Offset);
2461 // Start the size with the size of abbreviation code.
2462 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2464 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2465 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2467 // Size the DIE attribute values.
2468 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2469 // Size attribute value.
2470 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2472 // Size the DIE children if any.
2473 if (!Children.empty()) {
2474 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2475 "Children flag not set");
2477 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2478 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2480 // End of children marker.
2481 Offset += sizeof(int8_t);
2484 Die->setSize(Offset - Die->getOffset());
2488 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2490 void DwarfDebug::computeSizeAndOffsets() {
2491 // Compute size of compile unit header.
2492 static unsigned Offset =
2493 sizeof(int32_t) + // Length of Compilation Unit Info
2494 sizeof(int16_t) + // DWARF version number
2495 sizeof(int32_t) + // Offset Into Abbrev. Section
2496 sizeof(int8_t); // Pointer Size (in bytes)
2498 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2499 CompileUnitOffsets[ModuleCU] = 0;
2502 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2503 /// temporary label to it if SymbolStem is specified.
2504 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2505 const char *SymbolStem = 0) {
2506 Asm->OutStreamer.SwitchSection(Section);
2507 if (!SymbolStem) return 0;
2509 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2510 Asm->OutStreamer.EmitLabel(TmpSym);
2514 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2515 /// the start of each one.
2516 void DwarfDebug::EmitSectionLabels() {
2517 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2519 // Dwarf sections base addresses.
2520 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2521 DwarfFrameSectionSym =
2522 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2525 DwarfInfoSectionSym =
2526 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2527 DwarfAbbrevSectionSym =
2528 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2529 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2531 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2532 EmitSectionSym(Asm, MacroInfo);
2534 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2535 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2536 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2537 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2538 DwarfStrSectionSym =
2539 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2540 EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
2542 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2543 EmitSectionSym(Asm, TLOF.getDataSection());
2546 /// emitDIE - Recusively Emits a debug information entry.
2548 void DwarfDebug::emitDIE(DIE *Die) {
2549 // Get the abbreviation for this DIE.
2550 unsigned AbbrevNumber = Die->getAbbrevNumber();
2551 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2553 // Emit the code (index) for the abbreviation.
2554 if (Asm->isVerbose())
2555 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2556 Twine::utohexstr(Die->getOffset()) + ":0x" +
2557 Twine::utohexstr(Die->getSize()) + " " +
2558 dwarf::TagString(Abbrev->getTag()));
2559 Asm->EmitULEB128(AbbrevNumber);
2561 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2562 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2564 // Emit the DIE attribute values.
2565 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2566 unsigned Attr = AbbrevData[i].getAttribute();
2567 unsigned Form = AbbrevData[i].getForm();
2568 assert(Form && "Too many attributes for DIE (check abbreviation)");
2570 if (Asm->isVerbose())
2571 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2574 case dwarf::DW_AT_sibling:
2575 Asm->EmitInt32(Die->getSiblingOffset());
2577 case dwarf::DW_AT_abstract_origin: {
2578 DIEEntry *E = cast<DIEEntry>(Values[i]);
2579 DIE *Origin = E->getEntry();
2580 unsigned Addr = Origin->getOffset();
2581 Asm->EmitInt32(Addr);
2585 // Emit an attribute using the defined form.
2586 Values[i]->EmitValue(Asm, Form);
2591 // Emit the DIE children if any.
2592 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2593 const std::vector<DIE *> &Children = Die->getChildren();
2595 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2596 emitDIE(Children[j]);
2598 if (Asm->isVerbose())
2599 Asm->OutStreamer.AddComment("End Of Children Mark");
2604 /// emitDebugInfo - Emit the debug info section.
2606 void DwarfDebug::emitDebugInfo() {
2607 // Start debug info section.
2608 Asm->OutStreamer.SwitchSection(
2609 Asm->getObjFileLowering().getDwarfInfoSection());
2610 DIE *Die = ModuleCU->getCUDie();
2612 // Emit the compile units header.
2613 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2614 ModuleCU->getID()));
2616 // Emit size of content not including length itself
2617 unsigned ContentSize = Die->getSize() +
2618 sizeof(int16_t) + // DWARF version number
2619 sizeof(int32_t) + // Offset Into Abbrev. Section
2620 sizeof(int8_t) + // Pointer Size (in bytes)
2621 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2623 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2624 Asm->EmitInt32(ContentSize);
2625 Asm->OutStreamer.AddComment("DWARF version number");
2626 Asm->EmitInt16(dwarf::DWARF_VERSION);
2627 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2628 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2629 DwarfAbbrevSectionSym);
2630 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2631 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2634 // FIXME - extra padding for gdb bug.
2635 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2640 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2643 /// emitAbbreviations - Emit the abbreviation section.
2645 void DwarfDebug::emitAbbreviations() const {
2646 // Check to see if it is worth the effort.
2647 if (!Abbreviations.empty()) {
2648 // Start the debug abbrev section.
2649 Asm->OutStreamer.SwitchSection(
2650 Asm->getObjFileLowering().getDwarfAbbrevSection());
2652 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2654 // For each abbrevation.
2655 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2656 // Get abbreviation data
2657 const DIEAbbrev *Abbrev = Abbreviations[i];
2659 // Emit the abbrevations code (base 1 index.)
2660 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2662 // Emit the abbreviations data.
2666 // Mark end of abbreviations.
2667 Asm->EmitULEB128(0, "EOM(3)");
2669 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2673 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2674 /// the line matrix.
2676 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2677 // Define last address of section.
2678 Asm->OutStreamer.AddComment("Extended Op");
2681 Asm->OutStreamer.AddComment("Op size");
2682 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2683 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2684 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2686 Asm->OutStreamer.AddComment("Section end label");
2688 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2689 Asm->getTargetData().getPointerSize(),
2692 // Mark end of matrix.
2693 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2699 /// emitDebugLines - Emit source line information.
2701 void DwarfDebug::emitDebugLines() {
2702 // If the target is using .loc/.file, the assembler will be emitting the
2703 // .debug_line table automatically.
2704 if (Asm->MAI->hasDotLocAndDotFile())
2707 // Minimum line delta, thus ranging from -10..(255-10).
2708 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2709 // Maximum line delta, thus ranging from -10..(255-10).
2710 const int MaxLineDelta = 255 + MinLineDelta;
2712 // Start the dwarf line section.
2713 Asm->OutStreamer.SwitchSection(
2714 Asm->getObjFileLowering().getDwarfLineSection());
2716 // Construct the section header.
2717 Asm->OutStreamer.AddComment("Length of Source Line Info");
2718 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2719 Asm->GetTempSymbol("line_begin"), 4);
2720 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2722 Asm->OutStreamer.AddComment("DWARF version number");
2723 Asm->EmitInt16(dwarf::DWARF_VERSION);
2725 Asm->OutStreamer.AddComment("Prolog Length");
2726 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2727 Asm->GetTempSymbol("line_prolog_begin"), 4);
2728 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2730 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2732 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2734 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2735 Asm->EmitInt8(MinLineDelta);
2736 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2737 Asm->EmitInt8(MaxLineDelta);
2738 Asm->OutStreamer.AddComment("Special Opcode Base");
2739 Asm->EmitInt8(-MinLineDelta);
2741 // Line number standard opcode encodings argument count
2742 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2744 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2746 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2748 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2750 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2752 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2754 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2756 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2758 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2761 // Emit directories.
2762 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2763 const std::string &Dir = getSourceDirectoryName(DI);
2764 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2765 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2768 Asm->OutStreamer.AddComment("End of directories");
2772 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2773 // Remember source id starts at 1.
2774 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2775 const std::string &FN = getSourceFileName(Id.second);
2776 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2777 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2779 Asm->EmitULEB128(Id.first, "Directory #");
2780 Asm->EmitULEB128(0, "Mod date");
2781 Asm->EmitULEB128(0, "File size");
2784 Asm->OutStreamer.AddComment("End of files");
2787 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2789 // A sequence for each text section.
2790 unsigned SecSrcLinesSize = SectionSourceLines.size();
2792 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2793 // Isolate current sections line info.
2794 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2796 // Dwarf assumes we start with first line of first source file.
2797 unsigned Source = 1;
2800 // Construct rows of the address, source, line, column matrix.
2801 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2802 const SrcLineInfo &LineInfo = LineInfos[i];
2803 MCSymbol *Label = LineInfo.getLabel();
2804 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2806 if (LineInfo.getLine() == 0) continue;
2808 if (Asm->isVerbose()) {
2809 std::pair<unsigned, unsigned> SrcID =
2810 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2811 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2813 Twine(getSourceFileName(SrcID.second)) +
2814 ":" + Twine(LineInfo.getLine()));
2817 // Define the line address.
2818 Asm->OutStreamer.AddComment("Extended Op");
2820 Asm->OutStreamer.AddComment("Op size");
2821 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2823 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2824 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2826 Asm->OutStreamer.AddComment("Location label");
2827 Asm->OutStreamer.EmitSymbolValue(Label,
2828 Asm->getTargetData().getPointerSize(),
2831 // If change of source, then switch to the new source.
2832 if (Source != LineInfo.getSourceID()) {
2833 Source = LineInfo.getSourceID();
2834 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2835 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2836 Asm->EmitULEB128(Source, "New Source");
2839 // If change of line.
2840 if (Line != LineInfo.getLine()) {
2841 // Determine offset.
2842 int Offset = LineInfo.getLine() - Line;
2843 int Delta = Offset - MinLineDelta;
2846 Line = LineInfo.getLine();
2848 // If delta is small enough and in range...
2849 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2850 // ... then use fast opcode.
2851 Asm->OutStreamer.AddComment("Line Delta");
2852 Asm->EmitInt8(Delta - MinLineDelta);
2854 // ... otherwise use long hand.
2855 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2856 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2857 Asm->EmitSLEB128(Offset, "Line Offset");
2858 Asm->OutStreamer.AddComment("DW_LNS_copy");
2859 Asm->EmitInt8(dwarf::DW_LNS_copy);
2862 // Copy the previous row (different address or source)
2863 Asm->OutStreamer.AddComment("DW_LNS_copy");
2864 Asm->EmitInt8(dwarf::DW_LNS_copy);
2868 emitEndOfLineMatrix(j + 1);
2871 if (SecSrcLinesSize == 0)
2872 // Because we're emitting a debug_line section, we still need a line
2873 // table. The linker and friends expect it to exist. If there's nothing to
2874 // put into it, emit an empty table.
2875 emitEndOfLineMatrix(1);
2877 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2880 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2882 void DwarfDebug::emitCommonDebugFrame() {
2883 if (!Asm->MAI->doesDwarfRequireFrameSection())
2886 int stackGrowth = Asm->getTargetData().getPointerSize();
2887 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2888 TargetFrameInfo::StackGrowsDown)
2891 // Start the dwarf frame section.
2892 Asm->OutStreamer.SwitchSection(
2893 Asm->getObjFileLowering().getDwarfFrameSection());
2895 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2896 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2897 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2898 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2900 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2901 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2902 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2903 Asm->OutStreamer.AddComment("CIE Version");
2904 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2905 Asm->OutStreamer.AddComment("CIE Augmentation");
2906 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2907 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2908 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2909 Asm->OutStreamer.AddComment("CIE RA Column");
2910 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2911 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2913 std::vector<MachineMove> Moves;
2914 RI->getInitialFrameState(Moves);
2916 Asm->EmitFrameMoves(Moves, 0, false);
2918 Asm->EmitAlignment(2, 0, 0, false);
2919 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2922 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2925 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2926 if (!Asm->MAI->doesDwarfRequireFrameSection())
2929 // Start the dwarf frame section.
2930 Asm->OutStreamer.SwitchSection(
2931 Asm->getObjFileLowering().getDwarfFrameSection());
2933 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2934 MCSymbol *DebugFrameBegin =
2935 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2936 MCSymbol *DebugFrameEnd =
2937 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2938 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2940 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2942 Asm->OutStreamer.AddComment("FDE CIE offset");
2943 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2944 DwarfFrameSectionSym);
2946 Asm->OutStreamer.AddComment("FDE initial location");
2947 MCSymbol *FuncBeginSym =
2948 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2949 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2950 Asm->getTargetData().getPointerSize(),
2954 Asm->OutStreamer.AddComment("FDE address range");
2955 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2956 FuncBeginSym, Asm->getTargetData().getPointerSize());
2958 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2960 Asm->EmitAlignment(2, 0, 0, false);
2961 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2964 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2966 void DwarfDebug::emitDebugPubNames() {
2967 // Start the dwarf pubnames section.
2968 Asm->OutStreamer.SwitchSection(
2969 Asm->getObjFileLowering().getDwarfPubNamesSection());
2971 Asm->OutStreamer.AddComment("Length of Public Names Info");
2972 Asm->EmitLabelDifference(
2973 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2974 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2976 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2977 ModuleCU->getID()));
2979 Asm->OutStreamer.AddComment("DWARF Version");
2980 Asm->EmitInt16(dwarf::DWARF_VERSION);
2982 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2983 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2984 DwarfInfoSectionSym);
2986 Asm->OutStreamer.AddComment("Compilation Unit Length");
2987 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2988 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2991 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2992 for (StringMap<DIE*>::const_iterator
2993 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2994 const char *Name = GI->getKeyData();
2995 DIE *Entity = GI->second;
2997 Asm->OutStreamer.AddComment("DIE offset");
2998 Asm->EmitInt32(Entity->getOffset());
3000 if (Asm->isVerbose())
3001 Asm->OutStreamer.AddComment("External Name");
3002 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3005 Asm->OutStreamer.AddComment("End Mark");
3007 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3008 ModuleCU->getID()));
3011 void DwarfDebug::emitDebugPubTypes() {
3012 // Start the dwarf pubnames section.
3013 Asm->OutStreamer.SwitchSection(
3014 Asm->getObjFileLowering().getDwarfPubTypesSection());
3015 Asm->OutStreamer.AddComment("Length of Public Types Info");
3016 Asm->EmitLabelDifference(
3017 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
3018 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
3020 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3021 ModuleCU->getID()));
3023 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3024 Asm->EmitInt16(dwarf::DWARF_VERSION);
3026 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
3027 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3028 DwarfInfoSectionSym);
3030 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
3031 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
3032 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3035 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
3036 for (StringMap<DIE*>::const_iterator
3037 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3038 const char *Name = GI->getKeyData();
3039 DIE * Entity = GI->second;
3041 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3042 Asm->EmitInt32(Entity->getOffset());
3044 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3045 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3048 Asm->OutStreamer.AddComment("End Mark");
3050 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3051 ModuleCU->getID()));
3054 /// emitDebugStr - Emit visible names into a debug str section.
3056 void DwarfDebug::emitDebugStr() {
3057 // Check to see if it is worth the effort.
3058 if (StringPool.empty()) return;
3060 // Start the dwarf str section.
3061 Asm->OutStreamer.SwitchSection(
3062 Asm->getObjFileLowering().getDwarfStrSection());
3064 // Get all of the string pool entries and put them in an array by their ID so
3065 // we can sort them.
3066 SmallVector<std::pair<unsigned,
3067 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3069 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3070 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3071 Entries.push_back(std::make_pair(I->second.second, &*I));
3073 array_pod_sort(Entries.begin(), Entries.end());
3075 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3076 // Emit a label for reference from debug information entries.
3077 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3079 // Emit the string itself.
3080 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3084 /// emitDebugLoc - Emit visible names into a debug loc section.
3086 void DwarfDebug::emitDebugLoc() {
3087 // Start the dwarf loc section.
3088 Asm->OutStreamer.SwitchSection(
3089 Asm->getObjFileLowering().getDwarfLocSection());
3092 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3094 void DwarfDebug::EmitDebugARanges() {
3095 // Start the dwarf aranges section.
3096 Asm->OutStreamer.SwitchSection(
3097 Asm->getObjFileLowering().getDwarfARangesSection());
3100 /// emitDebugRanges - Emit visible names into a debug ranges section.
3102 void DwarfDebug::emitDebugRanges() {
3103 // Start the dwarf ranges section.
3104 Asm->OutStreamer.SwitchSection(
3105 Asm->getObjFileLowering().getDwarfRangesSection());
3108 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3110 void DwarfDebug::emitDebugMacInfo() {
3111 if (const MCSection *LineInfo =
3112 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3113 // Start the dwarf macinfo section.
3114 Asm->OutStreamer.SwitchSection(LineInfo);
3118 /// emitDebugInlineInfo - Emit inline info using following format.
3120 /// 1. length of section
3121 /// 2. Dwarf version number
3122 /// 3. address size.
3124 /// Entries (one "entry" for each function that was inlined):
3126 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3127 /// otherwise offset into __debug_str for regular function name.
3128 /// 2. offset into __debug_str section for regular function name.
3129 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3130 /// instances for the function.
3132 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3133 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3134 /// __debug_info section, and the low_pc is the starting address for the
3135 /// inlining instance.
3136 void DwarfDebug::emitDebugInlineInfo() {
3137 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3143 Asm->OutStreamer.SwitchSection(
3144 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3146 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3147 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3148 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3150 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3152 Asm->OutStreamer.AddComment("Dwarf Version");
3153 Asm->EmitInt16(dwarf::DWARF_VERSION);
3154 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3155 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3157 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3158 E = InlinedSPNodes.end(); I != E; ++I) {
3161 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3162 = InlineInfo.find(Node);
3163 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3164 DISubprogram SP(Node);
3165 StringRef LName = SP.getLinkageName();
3166 StringRef Name = SP.getName();
3168 Asm->OutStreamer.AddComment("MIPS linkage name");
3169 if (LName.empty()) {
3170 Asm->OutStreamer.EmitBytes(Name, 0);
3171 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3173 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3174 DwarfStrSectionSym);
3176 Asm->OutStreamer.AddComment("Function name");
3177 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3178 Asm->EmitULEB128(Labels.size(), "Inline count");
3180 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3181 LE = Labels.end(); LI != LE; ++LI) {
3182 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3183 Asm->EmitInt32(LI->second->getOffset());
3185 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3186 Asm->OutStreamer.EmitSymbolValue(LI->first,
3187 Asm->getTargetData().getPointerSize(),0);
3191 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));