1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Analysis/DebugInfo.h"
32 #include "llvm/ADT/STLExtras.h"
33 #include "llvm/ADT/StringExtras.h"
34 #include "llvm/Support/Debug.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include "llvm/Support/ValueHandle.h"
37 #include "llvm/Support/FormattedStream.h"
38 #include "llvm/Support/Timer.h"
39 #include "llvm/System/Path.h"
43 const char *DWARFGroupName = "DWARF Emission";
44 const char *DbgTimerName = "DWARF Debug Writer";
45 } // end anonymous namespace
47 //===----------------------------------------------------------------------===//
49 /// Configuration values for initial hash set sizes (log2).
51 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
55 //===----------------------------------------------------------------------===//
56 /// CompileUnit - This dwarf writer support class manages information associate
57 /// with a source file.
59 /// ID - File identifier for source.
63 /// Die - Compile unit debug information entry.
65 const OwningPtr<DIE> CUDie;
67 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
70 /// GVToDieMap - Tracks the mapping of unit level debug informaton
71 /// variables to debug information entries.
72 /// FIXME : Rename GVToDieMap -> NodeToDieMap
73 DenseMap<MDNode *, DIE *> GVToDieMap;
75 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
76 /// descriptors to debug information entries using a DIEEntry proxy.
78 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
80 /// Globals - A map of globally visible named entities for this unit.
82 StringMap<DIE*> Globals;
84 /// GlobalTypes - A map of globally visible types for this unit.
86 StringMap<DIE*> GlobalTypes;
89 CompileUnit(unsigned I, DIE *D)
90 : ID(I), CUDie(D), IndexTyDie(0) {}
93 unsigned getID() const { return ID; }
94 DIE* getCUDie() const { return CUDie.get(); }
95 const StringMap<DIE*> &getGlobals() const { return Globals; }
96 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
98 /// hasContent - Return true if this compile unit has something to write out.
100 bool hasContent() const { return !CUDie->getChildren().empty(); }
102 /// addGlobal - Add a new global entity to the compile unit.
104 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
106 /// addGlobalType - Add a new global type to the compile unit.
108 void addGlobalType(StringRef Name, DIE *Die) {
109 GlobalTypes[Name] = Die;
112 /// getDIE - Returns the debug information entry map slot for the
113 /// specified debug variable.
114 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
116 /// insertDIE - Insert DIE into the map.
117 void insertDIE(MDNode *N, DIE *D) {
118 GVToDieMap.insert(std::make_pair(N, D));
121 /// getDIEEntry - Returns the debug information entry for the speciefied
123 DIEEntry *getDIEEntry(MDNode *N) {
124 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
125 if (I == GVToDIEEntryMap.end())
130 /// insertDIEEntry - Insert debug information entry into the map.
131 void insertDIEEntry(MDNode *N, DIEEntry *E) {
132 GVToDIEEntryMap.insert(std::make_pair(N, E));
135 /// addDie - Adds or interns the DIE to the compile unit.
137 void addDie(DIE *Buffer) {
138 this->CUDie->addChild(Buffer);
141 // getIndexTyDie - Get an anonymous type for index type.
142 DIE *getIndexTyDie() {
146 // setIndexTyDie - Set D as anonymous type for index which can be reused
148 void setIndexTyDie(DIE *D) {
154 //===----------------------------------------------------------------------===//
155 /// DbgVariable - This class is used to track local variable information.
158 DIVariable Var; // Variable Descriptor.
159 unsigned FrameIndex; // Variable frame index.
160 const MachineInstr *DbgValueMInsn; // DBG_VALUE
161 // DbgValueLabel - DBG_VALUE is effective from this label.
162 MCSymbol *DbgValueLabel;
163 DbgVariable *const AbstractVar; // Abstract variable for this variable.
166 // AbsVar may be NULL.
167 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
168 : Var(V), FrameIndex(I), DbgValueMInsn(0),
169 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
170 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
171 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
172 AbstractVar(AbsVar), TheDIE(0)
176 DIVariable getVariable() const { return Var; }
177 unsigned getFrameIndex() const { return FrameIndex; }
178 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
179 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
180 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
181 DbgVariable *getAbstractVariable() const { return AbstractVar; }
182 void setDIE(DIE *D) { TheDIE = D; }
183 DIE *getDIE() const { return TheDIE; }
186 //===----------------------------------------------------------------------===//
187 /// DbgScope - This class is used to track scope information.
190 DbgScope *Parent; // Parent to this scope.
191 DIDescriptor Desc; // Debug info descriptor for scope.
192 // Location at which this scope is inlined.
193 AssertingVH<MDNode> InlinedAtLocation;
194 bool AbstractScope; // Abstract Scope
195 const MachineInstr *LastInsn; // Last instruction of this scope.
196 const MachineInstr *FirstInsn; // First instruction of this scope.
197 // Scopes defined in scope. Contents not owned.
198 SmallVector<DbgScope *, 4> Scopes;
199 // Variables declared in scope. Contents owned.
200 SmallVector<DbgVariable *, 8> Variables;
202 // Private state for dump()
203 mutable unsigned IndentLevel;
205 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
206 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
207 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
211 DbgScope *getParent() const { return Parent; }
212 void setParent(DbgScope *P) { Parent = P; }
213 DIDescriptor getDesc() const { return Desc; }
214 MDNode *getInlinedAt() const { return InlinedAtLocation; }
215 MDNode *getScopeNode() const { return Desc.getNode(); }
216 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
217 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
218 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
219 const MachineInstr *getLastInsn() { return LastInsn; }
220 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
221 void setAbstractScope() { AbstractScope = true; }
222 bool isAbstractScope() const { return AbstractScope; }
223 const MachineInstr *getFirstInsn() { return FirstInsn; }
225 /// addScope - Add a scope to the scope.
227 void addScope(DbgScope *S) { Scopes.push_back(S); }
229 /// addVariable - Add a variable to the scope.
231 void addVariable(DbgVariable *V) { Variables.push_back(V); }
233 void fixInstructionMarkers(DenseMap<const MachineInstr *,
234 unsigned> &MIIndexMap) {
235 assert(getFirstInsn() && "First instruction is missing!");
237 // Use the end of last child scope as end of this scope.
238 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
239 const MachineInstr *LastInsn = getFirstInsn();
241 if (Scopes.empty()) {
242 assert(getLastInsn() && "Inner most scope does not have last insn!");
245 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
246 SE = Scopes.end(); SI != SE; ++SI) {
248 DS->fixInstructionMarkers(MIIndexMap);
249 const MachineInstr *DSLastInsn = DS->getLastInsn();
250 unsigned DSI = MIIndexMap[DSLastInsn];
252 LastInsn = DSLastInsn;
257 unsigned CurrentLastInsnIndex = 0;
258 if (const MachineInstr *CL = getLastInsn())
259 CurrentLastInsnIndex = MIIndexMap[CL];
260 unsigned FIndex = MIIndexMap[getFirstInsn()];
262 // Set LastInsn as the last instruction for this scope only if
264 // 1) this scope's first instruction and
265 // 2) current last instruction for this scope, if any.
266 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
267 setLastInsn(LastInsn);
275 } // end llvm namespace
278 void DbgScope::dump() const {
279 raw_ostream &err = dbgs();
280 err.indent(IndentLevel);
281 MDNode *N = Desc.getNode();
284 err << "Abstract Scope\n";
288 err << "Children ...\n";
289 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
290 if (Scopes[i] != this)
297 DbgScope::~DbgScope() {
298 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
302 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
303 : Asm(A), MMI(Asm->MMI), ModuleCU(0),
304 AbbreviationsSet(InitAbbreviationsSetSize),
305 CurrentFnDbgScope(0), PrevLabel(NULL) {
306 NextStringPoolNumber = 0;
308 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
309 DwarfStrSectionSym = TextSectionSym = 0;
311 if (TimePassesIsEnabled) {
312 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
318 DwarfDebug::~DwarfDebug() {
319 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
320 DIEBlocks[j]->~DIEBlock();
323 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
324 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
325 if (Entry.first) return Entry.first;
327 Entry.second = NextStringPoolNumber++;
328 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
332 /// assignAbbrevNumber - Define a unique number for the abbreviation.
334 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
335 // Profile the node so that we can make it unique.
339 // Check the set for priors.
340 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
342 // If it's newly added.
343 if (InSet == &Abbrev) {
344 // Add to abbreviation list.
345 Abbreviations.push_back(&Abbrev);
347 // Assign the vector position + 1 as its number.
348 Abbrev.setNumber(Abbreviations.size());
350 // Assign existing abbreviation number.
351 Abbrev.setNumber(InSet->getNumber());
355 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
356 /// information entry.
357 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
358 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
362 /// addUInt - Add an unsigned integer attribute data and value.
364 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
365 unsigned Form, uint64_t Integer) {
366 if (!Form) Form = DIEInteger::BestForm(false, Integer);
367 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
368 Die->addValue(Attribute, Form, Value);
371 /// addSInt - Add an signed integer attribute data and value.
373 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
374 unsigned Form, int64_t Integer) {
375 if (!Form) Form = DIEInteger::BestForm(true, Integer);
376 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
377 Die->addValue(Attribute, Form, Value);
380 /// addString - Add a string attribute data and value. DIEString only
381 /// keeps string reference.
382 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
384 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
385 Die->addValue(Attribute, Form, Value);
388 /// addLabel - Add a Dwarf label attribute data and value.
390 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
391 const MCSymbol *Label) {
392 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
393 Die->addValue(Attribute, Form, Value);
396 /// addDelta - Add a label delta attribute data and value.
398 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
399 const MCSymbol *Hi, const MCSymbol *Lo) {
400 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
401 Die->addValue(Attribute, Form, Value);
404 /// addDIEEntry - Add a DIE attribute data and value.
406 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
408 Die->addValue(Attribute, Form, createDIEEntry(Entry));
412 /// addBlock - Add block data.
414 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
416 Block->ComputeSize(Asm);
417 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
418 Die->addValue(Attribute, Block->BestForm(), Block);
421 /// addSourceLine - Add location information to specified debug information
423 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
424 // If there is no compile unit specified, don't add a line #.
425 if (!V->getCompileUnit().Verify())
428 unsigned Line = V->getLineNumber();
429 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
430 V->getContext().getFilename());
431 assert(FileID && "Invalid file id");
432 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
433 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
436 /// addSourceLine - Add location information to specified debug information
438 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
439 // If there is no compile unit specified, don't add a line #.
440 if (!G->getCompileUnit().Verify())
443 unsigned Line = G->getLineNumber();
444 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
445 G->getContext().getFilename());
446 assert(FileID && "Invalid file id");
447 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
448 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
451 /// addSourceLine - Add location information to specified debug information
453 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
454 // If there is no compile unit specified, don't add a line #.
455 if (!SP->getCompileUnit().Verify())
457 // If the line number is 0, don't add it.
458 if (SP->getLineNumber() == 0)
461 unsigned Line = SP->getLineNumber();
462 if (!SP->getContext().Verify())
464 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
466 assert(FileID && "Invalid file id");
467 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
468 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
471 /// addSourceLine - Add location information to specified debug information
473 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
474 // If there is no compile unit specified, don't add a line #.
475 DICompileUnit CU = Ty->getCompileUnit();
479 unsigned Line = Ty->getLineNumber();
480 if (!Ty->getContext().Verify())
482 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
483 Ty->getContext().getFilename());
484 assert(FileID && "Invalid file id");
485 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
486 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
489 /// addSourceLine - Add location information to specified debug information
491 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
492 // If there is no compile unit specified, don't add a line #.
493 if (!NS->getCompileUnit().Verify())
496 unsigned Line = NS->getLineNumber();
497 StringRef FN = NS->getFilename();
498 StringRef Dir = NS->getDirectory();
500 unsigned FileID = GetOrCreateSourceID(Dir, FN);
501 assert(FileID && "Invalid file id");
502 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
503 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
506 /* Byref variables, in Blocks, are declared by the programmer as
507 "SomeType VarName;", but the compiler creates a
508 __Block_byref_x_VarName struct, and gives the variable VarName
509 either the struct, or a pointer to the struct, as its type. This
510 is necessary for various behind-the-scenes things the compiler
511 needs to do with by-reference variables in blocks.
513 However, as far as the original *programmer* is concerned, the
514 variable should still have type 'SomeType', as originally declared.
516 The following function dives into the __Block_byref_x_VarName
517 struct to find the original type of the variable. This will be
518 passed back to the code generating the type for the Debug
519 Information Entry for the variable 'VarName'. 'VarName' will then
520 have the original type 'SomeType' in its debug information.
522 The original type 'SomeType' will be the type of the field named
523 'VarName' inside the __Block_byref_x_VarName struct.
525 NOTE: In order for this to not completely fail on the debugger
526 side, the Debug Information Entry for the variable VarName needs to
527 have a DW_AT_location that tells the debugger how to unwind through
528 the pointers and __Block_byref_x_VarName struct to find the actual
529 value of the variable. The function addBlockByrefType does this. */
531 /// Find the type the programmer originally declared the variable to be
532 /// and return that type.
534 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
537 unsigned tag = Ty.getTag();
539 if (tag == dwarf::DW_TAG_pointer_type) {
540 DIDerivedType DTy = DIDerivedType(Ty.getNode());
541 subType = DTy.getTypeDerivedFrom();
544 DICompositeType blockStruct = DICompositeType(subType.getNode());
545 DIArray Elements = blockStruct.getTypeArray();
547 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
548 DIDescriptor Element = Elements.getElement(i);
549 DIDerivedType DT = DIDerivedType(Element.getNode());
550 if (Name == DT.getName())
551 return (DT.getTypeDerivedFrom());
557 /// addComplexAddress - Start with the address based on the location provided,
558 /// and generate the DWARF information necessary to find the actual variable
559 /// given the extra address information encoded in the DIVariable, starting from
560 /// the starting location. Add the DWARF information to the die.
562 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
564 const MachineLocation &Location) {
565 const DIVariable &VD = DV->getVariable();
566 DIType Ty = VD.getType();
568 // Decode the original location, and use that as the start of the byref
569 // variable's location.
570 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
571 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
572 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
574 if (Location.isReg()) {
576 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
578 Reg = Reg - dwarf::DW_OP_reg0;
579 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
580 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
584 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
586 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
587 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
590 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
593 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
594 uint64_t Element = VD.getAddrElement(i);
596 if (Element == DIFactory::OpPlus) {
597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
598 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
599 } else if (Element == DIFactory::OpDeref) {
600 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
601 } else llvm_unreachable("unknown DIFactory Opcode");
604 // Now attach the location information to the DIE.
605 addBlock(Die, Attribute, 0, Block);
608 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
609 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
610 gives the variable VarName either the struct, or a pointer to the struct, as
611 its type. This is necessary for various behind-the-scenes things the
612 compiler needs to do with by-reference variables in Blocks.
614 However, as far as the original *programmer* is concerned, the variable
615 should still have type 'SomeType', as originally declared.
617 The function getBlockByrefType dives into the __Block_byref_x_VarName
618 struct to find the original type of the variable, which is then assigned to
619 the variable's Debug Information Entry as its real type. So far, so good.
620 However now the debugger will expect the variable VarName to have the type
621 SomeType. So we need the location attribute for the variable to be an
622 expression that explains to the debugger how to navigate through the
623 pointers and struct to find the actual variable of type SomeType.
625 The following function does just that. We start by getting
626 the "normal" location for the variable. This will be the location
627 of either the struct __Block_byref_x_VarName or the pointer to the
628 struct __Block_byref_x_VarName.
630 The struct will look something like:
632 struct __Block_byref_x_VarName {
634 struct __Block_byref_x_VarName *forwarding;
635 ... <various other fields>
637 ... <maybe more fields>
640 If we are given the struct directly (as our starting point) we
641 need to tell the debugger to:
643 1). Add the offset of the forwarding field.
645 2). Follow that pointer to get the real __Block_byref_x_VarName
646 struct to use (the real one may have been copied onto the heap).
648 3). Add the offset for the field VarName, to find the actual variable.
650 If we started with a pointer to the struct, then we need to
651 dereference that pointer first, before the other steps.
652 Translating this into DWARF ops, we will need to append the following
653 to the current location description for the variable:
655 DW_OP_deref -- optional, if we start with a pointer
656 DW_OP_plus_uconst <forward_fld_offset>
658 DW_OP_plus_uconst <varName_fld_offset>
660 That is what this function does. */
662 /// addBlockByrefAddress - Start with the address based on the location
663 /// provided, and generate the DWARF information necessary to find the
664 /// actual Block variable (navigating the Block struct) based on the
665 /// starting location. Add the DWARF information to the die. For
666 /// more information, read large comment just above here.
668 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
670 const MachineLocation &Location) {
671 const DIVariable &VD = DV->getVariable();
672 DIType Ty = VD.getType();
674 unsigned Tag = Ty.getTag();
675 bool isPointer = false;
677 StringRef varName = VD.getName();
679 if (Tag == dwarf::DW_TAG_pointer_type) {
680 DIDerivedType DTy = DIDerivedType(Ty.getNode());
681 TmpTy = DTy.getTypeDerivedFrom();
685 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
687 // Find the __forwarding field and the variable field in the __Block_byref
689 DIArray Fields = blockStruct.getTypeArray();
690 DIDescriptor varField = DIDescriptor();
691 DIDescriptor forwardingField = DIDescriptor();
693 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
694 DIDescriptor Element = Fields.getElement(i);
695 DIDerivedType DT = DIDerivedType(Element.getNode());
696 StringRef fieldName = DT.getName();
697 if (fieldName == "__forwarding")
698 forwardingField = Element;
699 else if (fieldName == varName)
703 // Get the offsets for the forwarding field and the variable field.
704 unsigned forwardingFieldOffset =
705 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
706 unsigned varFieldOffset =
707 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
709 // Decode the original location, and use that as the start of the byref
710 // variable's location.
711 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
712 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
713 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
715 if (Location.isReg()) {
717 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
719 Reg = Reg - dwarf::DW_OP_reg0;
720 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
721 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
725 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
728 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
731 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
734 // If we started with a pointer to the __Block_byref... struct, then
735 // the first thing we need to do is dereference the pointer (DW_OP_deref).
737 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
739 // Next add the offset for the '__forwarding' field:
740 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
741 // adding the offset if it's 0.
742 if (forwardingFieldOffset > 0) {
743 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
744 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
747 // Now dereference the __forwarding field to get to the real __Block_byref
748 // struct: DW_OP_deref.
749 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
751 // Now that we've got the real __Block_byref... struct, add the offset
752 // for the variable's field to get to the location of the actual variable:
753 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
754 if (varFieldOffset > 0) {
755 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
756 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
759 // Now attach the location information to the DIE.
760 addBlock(Die, Attribute, 0, Block);
763 /// addAddress - Add an address attribute to a die based on the location
765 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
766 const MachineLocation &Location) {
767 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
768 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
769 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
771 if (Location.isReg()) {
773 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
775 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
776 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
780 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
782 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
783 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
786 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
789 addBlock(Die, Attribute, 0, Block);
792 /// addToContextOwner - Add Die into the list of its context owner's children.
793 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
794 if (Context.isType()) {
795 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
796 ContextDIE->addChild(Die);
797 } else if (Context.isNameSpace()) {
798 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
799 ContextDIE->addChild(Die);
800 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
801 ContextDIE->addChild(Die);
803 ModuleCU->addDie(Die);
806 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
808 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
809 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
814 TyDIE = new DIE(dwarf::DW_TAG_base_type);
815 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
816 if (Ty.isBasicType())
817 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
818 else if (Ty.isCompositeType())
819 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
821 assert(Ty.isDerivedType() && "Unknown kind of DIType");
822 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
825 addToContextOwner(TyDIE, Ty.getContext());
829 /// addType - Add a new type attribute to the specified entity.
830 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
834 // Check for pre-existence.
835 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
836 // If it exists then use the existing value.
838 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
843 DIE *Buffer = getOrCreateTypeDIE(Ty);
846 Entry = createDIEEntry(Buffer);
847 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
849 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
852 /// constructTypeDIE - Construct basic type die from DIBasicType.
853 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
854 // Get core information.
855 StringRef Name = BTy.getName();
856 Buffer.setTag(dwarf::DW_TAG_base_type);
857 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
860 // Add name if not anonymous or intermediate type.
862 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
863 uint64_t Size = BTy.getSizeInBits() >> 3;
864 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
867 /// constructTypeDIE - Construct derived type die from DIDerivedType.
868 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
869 // Get core information.
870 StringRef Name = DTy.getName();
871 uint64_t Size = DTy.getSizeInBits() >> 3;
872 unsigned Tag = DTy.getTag();
874 // FIXME - Workaround for templates.
875 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
879 // Map to main type, void will not have a type.
880 DIType FromTy = DTy.getTypeDerivedFrom();
881 addType(&Buffer, FromTy);
883 // Add name if not anonymous or intermediate type.
885 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
887 // Add size if non-zero (derived types might be zero-sized.)
889 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
891 // Add source line info if available and TyDesc is not a forward declaration.
892 if (!DTy.isForwardDecl())
893 addSourceLine(&Buffer, &DTy);
896 /// constructTypeDIE - Construct type DIE from DICompositeType.
897 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
898 // Get core information.
899 StringRef Name = CTy.getName();
901 uint64_t Size = CTy.getSizeInBits() >> 3;
902 unsigned Tag = CTy.getTag();
906 case dwarf::DW_TAG_vector_type:
907 case dwarf::DW_TAG_array_type:
908 constructArrayTypeDIE(Buffer, &CTy);
910 case dwarf::DW_TAG_enumeration_type: {
911 DIArray Elements = CTy.getTypeArray();
913 // Add enumerators to enumeration type.
914 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
916 DIDescriptor Enum(Elements.getElement(i).getNode());
917 if (Enum.isEnumerator()) {
918 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
919 Buffer.addChild(ElemDie);
924 case dwarf::DW_TAG_subroutine_type: {
926 DIArray Elements = CTy.getTypeArray();
927 DIDescriptor RTy = Elements.getElement(0);
928 addType(&Buffer, DIType(RTy.getNode()));
930 // Add prototype flag.
931 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
934 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
935 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
936 DIDescriptor Ty = Elements.getElement(i);
937 addType(Arg, DIType(Ty.getNode()));
938 Buffer.addChild(Arg);
942 case dwarf::DW_TAG_structure_type:
943 case dwarf::DW_TAG_union_type:
944 case dwarf::DW_TAG_class_type: {
945 // Add elements to structure type.
946 DIArray Elements = CTy.getTypeArray();
948 // A forward struct declared type may not have elements available.
949 unsigned N = Elements.getNumElements();
953 // Add elements to structure type.
954 for (unsigned i = 0; i < N; ++i) {
955 DIDescriptor Element = Elements.getElement(i);
957 if (Element.isSubprogram())
958 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
959 else if (Element.isVariable()) {
960 DIVariable DV(Element.getNode());
961 ElemDie = new DIE(dwarf::DW_TAG_variable);
962 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
964 addType(ElemDie, DV.getType());
965 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
966 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
967 addSourceLine(ElemDie, &DV);
968 } else if (Element.isDerivedType())
969 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
972 Buffer.addChild(ElemDie);
975 if (CTy.isAppleBlockExtension())
976 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
978 unsigned RLang = CTy.getRunTimeLang();
980 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
981 dwarf::DW_FORM_data1, RLang);
983 DICompositeType ContainingType = CTy.getContainingType();
984 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
985 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
986 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
993 // Add name if not anonymous or intermediate type.
995 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
997 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
998 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
999 // Add size if non-zero (derived types might be zero-sized.)
1001 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1003 // Add zero size if it is not a forward declaration.
1004 if (CTy.isForwardDecl())
1005 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1007 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1010 // Add source line info if available.
1011 if (!CTy.isForwardDecl())
1012 addSourceLine(&Buffer, &CTy);
1016 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1017 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1018 int64_t L = SR.getLo();
1019 int64_t H = SR.getHi();
1020 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1022 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1024 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1025 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1027 Buffer.addChild(DW_Subrange);
1030 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1031 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1032 DICompositeType *CTy) {
1033 Buffer.setTag(dwarf::DW_TAG_array_type);
1034 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1035 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1037 // Emit derived type.
1038 addType(&Buffer, CTy->getTypeDerivedFrom());
1039 DIArray Elements = CTy->getTypeArray();
1041 // Get an anonymous type for index type.
1042 DIE *IdxTy = ModuleCU->getIndexTyDie();
1044 // Construct an anonymous type for index type.
1045 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1046 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1047 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1048 dwarf::DW_ATE_signed);
1049 ModuleCU->addDie(IdxTy);
1050 ModuleCU->setIndexTyDie(IdxTy);
1053 // Add subranges to array type.
1054 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1055 DIDescriptor Element = Elements.getElement(i);
1056 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1057 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1061 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1062 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1063 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1064 StringRef Name = ETy.getName();
1065 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1066 int64_t Value = ETy.getEnumValue();
1067 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1071 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1072 /// printer to not emit usual symbol prefix before the symbol name is used then
1073 /// return linkage name after skipping this special LLVM prefix.
1074 static StringRef getRealLinkageName(StringRef LinkageName) {
1076 if (LinkageName.startswith(StringRef(&One, 1)))
1077 return LinkageName.substr(1);
1081 /// createGlobalVariableDIE - Create new DIE using GV.
1082 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1083 // If the global variable was optmized out then no need to create debug info
1085 if (!GV.getGlobal()) return NULL;
1086 if (GV.getDisplayName().empty()) return NULL;
1088 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1089 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1090 GV.getDisplayName());
1092 StringRef LinkageName = GV.getLinkageName();
1093 if (!LinkageName.empty())
1094 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1095 getRealLinkageName(LinkageName));
1097 addType(GVDie, GV.getType());
1098 if (!GV.isLocalToUnit())
1099 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1100 addSourceLine(GVDie, &GV);
1105 /// createMemberDIE - Create new member DIE.
1106 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1107 DIE *MemberDie = new DIE(DT.getTag());
1108 StringRef Name = DT.getName();
1110 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1112 addType(MemberDie, DT.getTypeDerivedFrom());
1114 addSourceLine(MemberDie, &DT);
1116 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1117 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1119 uint64_t Size = DT.getSizeInBits();
1120 uint64_t FieldSize = DT.getOriginalTypeSize();
1122 if (Size != FieldSize) {
1124 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1125 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1127 uint64_t Offset = DT.getOffsetInBits();
1128 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1129 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1130 uint64_t FieldOffset = (HiMark - FieldSize);
1131 Offset -= FieldOffset;
1133 // Maybe we need to work from the other end.
1134 if (Asm->getTargetData().isLittleEndian())
1135 Offset = FieldSize - (Offset + Size);
1136 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1138 // Here WD_AT_data_member_location points to the anonymous
1139 // field that includes this bit field.
1140 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1143 // This is not a bitfield.
1144 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1146 if (DT.getTag() == dwarf::DW_TAG_inheritance
1147 && DT.isVirtual()) {
1149 // For C++, virtual base classes are not at fixed offset. Use following
1150 // expression to extract appropriate offset from vtable.
1151 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1153 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1154 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1155 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1156 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1157 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1158 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1159 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1160 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1162 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1165 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1167 if (DT.isProtected())
1168 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1169 dwarf::DW_ACCESS_protected);
1170 else if (DT.isPrivate())
1171 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1172 dwarf::DW_ACCESS_private);
1173 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1174 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1175 dwarf::DW_ACCESS_public);
1177 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1178 dwarf::DW_VIRTUALITY_virtual);
1182 /// createSubprogramDIE - Create new DIE using SP.
1183 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1184 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1188 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1189 // Constructors and operators for anonymous aggregates do not have names.
1190 if (!SP.getName().empty())
1191 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1193 StringRef LinkageName = SP.getLinkageName();
1194 if (!LinkageName.empty())
1195 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1196 getRealLinkageName(LinkageName));
1198 addSourceLine(SPDie, &SP);
1200 // Add prototyped tag, if C or ObjC.
1201 unsigned Lang = SP.getCompileUnit().getLanguage();
1202 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1203 Lang == dwarf::DW_LANG_ObjC)
1204 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1207 DICompositeType SPTy = SP.getType();
1208 DIArray Args = SPTy.getTypeArray();
1209 unsigned SPTag = SPTy.getTag();
1211 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1212 addType(SPDie, SPTy);
1214 addType(SPDie, DIType(Args.getElement(0).getNode()));
1216 unsigned VK = SP.getVirtuality();
1218 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1219 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1220 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1221 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1222 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1223 ContainingTypeMap.insert(std::make_pair(SPDie,
1224 SP.getContainingType().getNode()));
1227 if (MakeDecl || !SP.isDefinition()) {
1228 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1230 // Add arguments. Do not add arguments for subprogram definition. They will
1231 // be handled while processing variables.
1232 DICompositeType SPTy = SP.getType();
1233 DIArray Args = SPTy.getTypeArray();
1234 unsigned SPTag = SPTy.getTag();
1236 if (SPTag == dwarf::DW_TAG_subroutine_type)
1237 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1238 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1239 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1241 if (ATy.isArtificial())
1242 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1243 SPDie->addChild(Arg);
1247 if (SP.isArtificial())
1248 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1250 // DW_TAG_inlined_subroutine may refer to this DIE.
1251 ModuleCU->insertDIE(SP.getNode(), SPDie);
1255 /// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1256 /// Update scope hierarchy. Create abstract scope if required.
1257 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1258 MDNode *InlinedAt) {
1259 assert(N && "Invalid Scope encoding!");
1260 assert(MI && "Missing machine instruction!");
1261 bool isAConcreteScope = InlinedAt != 0;
1263 DbgScope *NScope = NULL;
1266 NScope = DbgScopeMap.lookup(InlinedAt);
1268 NScope = DbgScopeMap.lookup(N);
1269 assert(NScope && "Unable to find working scope!");
1271 if (NScope->getFirstInsn())
1274 DbgScope *Parent = NULL;
1275 if (isAConcreteScope) {
1276 DILocation IL(InlinedAt);
1277 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1278 IL.getOrigLocation().getNode());
1279 assert(Parent && "Unable to find Parent scope!");
1280 NScope->setParent(Parent);
1281 Parent->addScope(NScope);
1282 } else if (DIDescriptor(N).isLexicalBlock()) {
1283 DILexicalBlock DB(N);
1284 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1285 NScope->setParent(Parent);
1286 Parent->addScope(NScope);
1289 NScope->setFirstInsn(MI);
1291 if (!Parent && !InlinedAt) {
1292 StringRef SPName = DISubprogram(N).getLinkageName();
1293 if (SPName == Asm->MF->getFunction()->getName())
1294 CurrentFnDbgScope = NScope;
1297 if (isAConcreteScope) {
1298 ConcreteScopes[InlinedAt] = NScope;
1299 getOrCreateAbstractScope(N);
1305 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1306 assert(N && "Invalid Scope encoding!");
1308 DbgScope *AScope = AbstractScopes.lookup(N);
1312 DbgScope *Parent = NULL;
1314 DIDescriptor Scope(N);
1315 if (Scope.isLexicalBlock()) {
1316 DILexicalBlock DB(N);
1317 DIDescriptor ParentDesc = DB.getContext();
1318 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1321 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1324 Parent->addScope(AScope);
1325 AScope->setAbstractScope();
1326 AbstractScopes[N] = AScope;
1327 if (DIDescriptor(N).isSubprogram())
1328 AbstractScopesList.push_back(AScope);
1332 /// isSubprogramContext - Return true if Context is either a subprogram
1333 /// or another context nested inside a subprogram.
1334 static bool isSubprogramContext(MDNode *Context) {
1337 DIDescriptor D(Context);
1338 if (D.isSubprogram())
1341 return isSubprogramContext(DIType(Context).getContext().getNode());
1345 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1346 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1347 /// If there are global variables in this scope then create and insert
1348 /// DIEs for these variables.
1349 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1350 DIE *SPDie = ModuleCU->getDIE(SPNode);
1351 assert(SPDie && "Unable to find subprogram DIE!");
1352 DISubprogram SP(SPNode);
1354 // There is not any need to generate specification DIE for a function
1355 // defined at compile unit level. If a function is defined inside another
1356 // function then gdb prefers the definition at top level and but does not
1357 // expect specification DIE in parent function. So avoid creating
1358 // specification DIE for a function defined inside a function.
1359 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1360 !SP.getContext().isFile() &&
1361 !isSubprogramContext(SP.getContext().getNode())) {
1362 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1365 DICompositeType SPTy = SP.getType();
1366 DIArray Args = SPTy.getTypeArray();
1367 unsigned SPTag = SPTy.getTag();
1368 if (SPTag == dwarf::DW_TAG_subroutine_type)
1369 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1370 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1371 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1373 if (ATy.isArtificial())
1374 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1375 SPDie->addChild(Arg);
1377 DIE *SPDeclDie = SPDie;
1378 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1379 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1381 ModuleCU->addDie(SPDie);
1384 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1385 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1386 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1387 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1388 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1389 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1390 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1392 if (!DISubprogram(SPNode).isLocalToUnit())
1393 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1398 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1399 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1400 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1402 MCSymbol *Start = InsnBeforeLabelMap.lookup(Scope->getFirstInsn());
1403 MCSymbol *End = InsnAfterLabelMap.lookup(Scope->getLastInsn());
1404 if (Start == 0 || End == 0) return 0;
1406 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1407 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1409 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1410 if (Scope->isAbstractScope())
1413 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1414 Start ? Start : Asm->GetTempSymbol("func_begin",
1415 Asm->getFunctionNumber()));
1416 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1417 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1422 /// constructInlinedScopeDIE - This scope represents inlined body of
1423 /// a function. Construct DIE to represent this concrete inlined copy
1424 /// of the function.
1425 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1426 MCSymbol *StartLabel = InsnBeforeLabelMap.lookup(Scope->getFirstInsn());
1427 MCSymbol *EndLabel = InsnAfterLabelMap.lookup(Scope->getLastInsn());
1428 if (StartLabel == 0 || EndLabel == 0) return 0;
1430 assert(StartLabel->isDefined() &&
1431 "Invalid starting label for an inlined scope!");
1432 assert(EndLabel->isDefined() &&
1433 "Invalid end label for an inlined scope!");
1434 if (!Scope->getScopeNode())
1436 DIScope DS(Scope->getScopeNode());
1437 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1439 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1440 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1441 assert(OriginDIE && "Unable to find Origin DIE!");
1442 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1443 dwarf::DW_FORM_ref4, OriginDIE);
1445 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1446 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1448 InlinedSubprogramDIEs.insert(OriginDIE);
1450 // Track the start label for this inlined function.
1451 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1452 I = InlineInfo.find(InlinedSP.getNode());
1454 if (I == InlineInfo.end()) {
1455 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1457 InlinedSPNodes.push_back(InlinedSP.getNode());
1459 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1461 DILocation DL(Scope->getInlinedAt());
1462 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1463 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1469 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1470 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1471 // Get the descriptor.
1472 const DIVariable &VD = DV->getVariable();
1473 StringRef Name = VD.getName();
1477 // Translate tag to proper Dwarf tag. The result variable is dropped for
1480 switch (VD.getTag()) {
1481 case dwarf::DW_TAG_return_variable:
1483 case dwarf::DW_TAG_arg_variable:
1484 Tag = dwarf::DW_TAG_formal_parameter;
1486 case dwarf::DW_TAG_auto_variable: // fall thru
1488 Tag = dwarf::DW_TAG_variable;
1492 // Define variable debug information entry.
1493 DIE *VariableDie = new DIE(Tag);
1497 if (DbgVariable *AV = DV->getAbstractVariable())
1498 AbsDIE = AV->getDIE();
1501 DIScope DS(Scope->getScopeNode());
1502 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1503 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1505 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1506 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1507 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1508 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1509 dwarf::DW_FORM_ref4, AbsDIE);
1512 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1513 addSourceLine(VariableDie, &VD);
1515 // Add variable type.
1516 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1517 // addresses instead.
1518 if (VD.isBlockByrefVariable())
1519 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1521 addType(VariableDie, VD.getType());
1524 // Add variable address.
1525 if (!Scope->isAbstractScope()) {
1526 // Check if variable is described by DBG_VALUE instruction.
1527 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1528 if (DbgValueInsn->getNumOperands() == 3) {
1529 // FIXME : Handle getNumOperands != 3
1530 if (DbgValueInsn->getOperand(0).getType()
1531 == MachineOperand::MO_Register
1532 && DbgValueInsn->getOperand(0).getReg()) {
1533 MachineLocation Location;
1534 Location.set(DbgValueInsn->getOperand(0).getReg());
1535 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1536 if (MCSymbol *VS = DV->getDbgValueLabel())
1537 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1539 } else if (DbgValueInsn->getOperand(0).getType() ==
1540 MachineOperand::MO_Immediate) {
1541 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1542 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1543 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1544 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1545 if (MCSymbol *VS = DV->getDbgValueLabel())
1546 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1548 } else if (DbgValueInsn->getOperand(0).getType() ==
1549 MachineOperand::MO_FPImmediate) {
1550 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1551 APFloat FPImm = DbgValueInsn->getOperand(0).getFPImm()->getValueAPF();
1553 // Get the raw data form of the floating point.
1554 const APInt FltVal = FPImm.bitcastToAPInt();
1555 const char *FltPtr = (const char*)FltVal.getRawData();
1557 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
1558 bool LittleEndian = Asm->getTargetData().isLittleEndian();
1559 int Incr = (LittleEndian ? 1 : -1);
1560 int Start = (LittleEndian ? 0 : NumBytes - 1);
1561 int Stop = (LittleEndian ? NumBytes : -1);
1563 // Output the constant to DWARF one byte at a time.
1564 for (; Start != Stop; Start += Incr)
1565 addUInt(Block, 0, dwarf::DW_FORM_data1,
1566 (unsigned char)0xFF & FltPtr[Start]);
1568 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1570 if (MCSymbol *VS = DV->getDbgValueLabel())
1571 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1574 //FIXME : Handle other operand types.
1580 MachineLocation Location;
1582 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1583 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1585 Location.set(FrameReg, Offset);
1587 if (VD.hasComplexAddress())
1588 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1589 else if (VD.isBlockByrefVariable())
1590 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1592 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1596 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1597 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1598 DV->setDIE(VariableDie);
1603 void DwarfDebug::addPubTypes(DISubprogram SP) {
1604 DICompositeType SPTy = SP.getType();
1605 unsigned SPTag = SPTy.getTag();
1606 if (SPTag != dwarf::DW_TAG_subroutine_type)
1609 DIArray Args = SPTy.getTypeArray();
1610 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1611 DIType ATy(Args.getElement(i).getNode());
1614 DICompositeType CATy = getDICompositeType(ATy);
1615 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()
1616 && !CATy.isForwardDecl()) {
1617 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1618 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1623 /// constructScopeDIE - Construct a DIE for this scope.
1624 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1625 if (!Scope || !Scope->getScopeNode())
1628 DIScope DS(Scope->getScopeNode());
1629 DIE *ScopeDIE = NULL;
1630 if (Scope->getInlinedAt())
1631 ScopeDIE = constructInlinedScopeDIE(Scope);
1632 else if (DS.isSubprogram()) {
1633 if (Scope->isAbstractScope())
1634 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1636 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1639 ScopeDIE = constructLexicalScopeDIE(Scope);
1640 if (!ScopeDIE) return NULL;
1642 // Add variables to scope.
1643 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1644 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1645 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1647 ScopeDIE->addChild(VariableDIE);
1650 // Add nested scopes.
1651 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1652 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1653 // Define the Scope debug information entry.
1654 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1656 ScopeDIE->addChild(NestedDIE);
1659 if (DS.isSubprogram())
1660 addPubTypes(DISubprogram(DS.getNode()));
1665 /// GetOrCreateSourceID - Look up the source id with the given directory and
1666 /// source file names. If none currently exists, create a new id and insert it
1667 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1669 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1671 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1672 if (DI != DirectoryIdMap.end()) {
1673 DId = DI->getValue();
1675 DId = DirectoryNames.size() + 1;
1676 DirectoryIdMap[DirName] = DId;
1677 DirectoryNames.push_back(DirName);
1681 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1682 if (FI != SourceFileIdMap.end()) {
1683 FId = FI->getValue();
1685 FId = SourceFileNames.size() + 1;
1686 SourceFileIdMap[FileName] = FId;
1687 SourceFileNames.push_back(FileName);
1690 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1691 SourceIdMap.find(std::make_pair(DId, FId));
1692 if (SI != SourceIdMap.end())
1695 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1696 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1697 SourceIds.push_back(std::make_pair(DId, FId));
1702 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1703 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1704 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1707 NDie = new DIE(dwarf::DW_TAG_namespace);
1708 ModuleCU->insertDIE(NS.getNode(), NDie);
1709 if (!NS.getName().empty())
1710 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1711 addSourceLine(NDie, &NS);
1712 addToContextOwner(NDie, NS.getContext());
1716 void DwarfDebug::constructCompileUnit(MDNode *N) {
1717 DICompileUnit DIUnit(N);
1718 // Use first compile unit marked as isMain as the compile unit for this
1720 if (ModuleCU || !DIUnit.isMain())
1722 StringRef FN = DIUnit.getFilename();
1723 StringRef Dir = DIUnit.getDirectory();
1724 unsigned ID = GetOrCreateSourceID(Dir, FN);
1726 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1727 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1728 DIUnit.getProducer());
1729 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1730 DIUnit.getLanguage());
1731 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1732 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1733 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1734 Asm->GetTempSymbol("text_end"));
1735 // DW_AT_stmt_list is a offset of line number information for this
1736 // compile unit in debug_line section. It is always zero when only one
1737 // compile unit is emitted in one object file.
1738 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1741 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1742 if (DIUnit.isOptimized())
1743 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1745 StringRef Flags = DIUnit.getFlags();
1747 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1749 unsigned RVer = DIUnit.getRunTimeVersion();
1751 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1752 dwarf::DW_FORM_data1, RVer);
1755 "ModuleCU assigned since the top of constructCompileUnit");
1756 ModuleCU = new CompileUnit(ID, Die);
1759 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1760 DIGlobalVariable DI_GV(N);
1762 // If debug information is malformed then ignore it.
1763 if (DI_GV.Verify() == false)
1766 // Check for pre-existence.
1767 if (ModuleCU->getDIE(DI_GV.getNode()))
1770 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1775 ModuleCU->insertDIE(N, VariableDie);
1777 // Add to context owner.
1778 DIDescriptor GVContext = DI_GV.getContext();
1779 // Do not create specification DIE if context is either compile unit
1781 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1782 !GVContext.isFile() &&
1783 !isSubprogramContext(GVContext.getNode())) {
1784 // Create specification DIE.
1785 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1786 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1787 dwarf::DW_FORM_ref4, VariableDie);
1788 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1790 addLabel(Block, 0, dwarf::DW_FORM_udata,
1791 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1792 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1793 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1794 ModuleCU->addDie(VariableSpecDIE);
1796 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1797 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1798 addLabel(Block, 0, dwarf::DW_FORM_udata,
1799 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1800 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1802 addToContextOwner(VariableDie, GVContext);
1804 // Expose as global. FIXME - need to check external flag.
1805 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1807 DIType GTy = DI_GV.getType();
1808 if (GTy.isCompositeType() && !GTy.getName().empty()
1809 && !GTy.isForwardDecl()) {
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 DebugInfoFinder DbgFinder;
1848 DbgFinder.processModule(*M);
1850 bool HasDebugInfo = false;
1852 // Scan all the compile-units to see if there are any marked as the main unit.
1853 // if not, we do not generate debug info.
1854 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1855 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1856 if (DICompileUnit(*I).isMain()) {
1857 HasDebugInfo = true;
1862 if (!HasDebugInfo) return;
1864 // Tell MMI that we have debug info.
1865 MMI->setDebugInfoAvailability(true);
1867 // Emit initial sections.
1868 EmitSectionLabels();
1870 // Create all the compile unit DIEs.
1871 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1872 E = DbgFinder.compile_unit_end(); I != E; ++I)
1873 constructCompileUnit(*I);
1875 // Create DIEs for each subprogram.
1876 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1877 E = DbgFinder.subprogram_end(); I != E; ++I)
1878 constructSubprogramDIE(*I);
1880 // Create DIEs for each global variable.
1881 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1882 E = DbgFinder.global_variable_end(); I != E; ++I)
1883 constructGlobalVariableDIE(*I);
1885 // Prime section data.
1886 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1888 // Print out .file directives to specify files for .loc directives. These are
1889 // printed out early so that they precede any .loc directives.
1890 if (Asm->MAI->hasDotLocAndDotFile()) {
1891 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1892 // Remember source id starts at 1.
1893 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1894 // FIXME: don't use sys::path for this! This should not depend on the
1896 sys::Path FullPath(getSourceDirectoryName(Id.first));
1898 FullPath.appendComponent(getSourceFileName(Id.second));
1899 assert(AppendOk && "Could not append filename to directory!");
1901 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1906 /// endModule - Emit all Dwarf sections that should come after the content.
1908 void DwarfDebug::endModule() {
1909 if (!ModuleCU) return;
1911 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1912 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1913 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1915 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1918 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1919 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1920 DIE *SPDie = CI->first;
1921 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1923 DIE *NDie = ModuleCU->getDIE(N);
1924 if (!NDie) continue;
1925 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1928 // Standard sections final addresses.
1929 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1930 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1931 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1932 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1934 // End text sections.
1935 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1936 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1937 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1940 // Emit common frame information.
1941 emitCommonDebugFrame();
1943 // Emit function debug frame information
1944 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1945 E = DebugFrames.end(); I != E; ++I)
1946 emitFunctionDebugFrame(*I);
1948 // Compute DIE offsets and sizes.
1949 computeSizeAndOffsets();
1951 // Emit all the DIEs into a debug info section
1954 // Corresponding abbreviations into a abbrev section.
1955 emitAbbreviations();
1957 // Emit source line correspondence into a debug line section.
1960 // Emit info into a debug pubnames section.
1961 emitDebugPubNames();
1963 // Emit info into a debug pubtypes section.
1964 emitDebugPubTypes();
1966 // Emit info into a debug loc section.
1969 // Emit info into a debug aranges section.
1972 // Emit info into a debug ranges section.
1975 // Emit info into a debug macinfo section.
1978 // Emit inline info.
1979 emitDebugInlineInfo();
1981 // Emit info into a debug str section.
1985 ModuleCU = NULL; // Reset for the next Module, if any.
1988 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1989 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1991 DebugLoc ScopeLoc) {
1993 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1995 return AbsDbgVariable;
1997 LLVMContext &Ctx = Var.getNode()->getContext();
1998 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2002 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
2003 NULL /* No more-abstract variable*/);
2004 Scope->addVariable(AbsDbgVariable);
2005 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2006 return AbsDbgVariable;
2009 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2010 /// FIXME : Refactor findAbstractVariable.
2011 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2012 const MachineInstr *MI,
2013 DebugLoc ScopeLoc) {
2015 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
2017 return AbsDbgVariable;
2019 LLVMContext &Ctx = Var.getNode()->getContext();
2020 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2024 AbsDbgVariable = new DbgVariable(Var, MI,
2025 NULL /* No more-abstract variable*/);
2026 Scope->addVariable(AbsDbgVariable);
2027 AbstractVariables[Var.getNode()] = AbsDbgVariable;
2028 DbgValueStartMap[MI] = AbsDbgVariable;
2029 return AbsDbgVariable;
2032 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2033 void DwarfDebug::collectVariableInfo() {
2034 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2036 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2037 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2038 VE = VMap.end(); VI != VE; ++VI) {
2039 MDNode *Var = VI->first;
2042 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2044 DbgScope *Scope = 0;
2045 if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2046 Scope = ConcreteScopes.lookup(IA);
2048 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2050 // If variable scope is not found then skip this variable.
2054 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2055 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2056 Scope->addVariable(RegVar);
2059 // Collect variable information from DBG_VALUE machine instructions;
2060 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2062 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2064 const MachineInstr *MInsn = II;
2065 if (!MInsn->isDebugValue())
2068 // FIXME : Lift this restriction.
2069 if (MInsn->getNumOperands() != 3)
2071 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2072 - 1).getMetadata()));
2073 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2074 // FIXME Handle inlined subroutine arguments.
2075 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2076 CurrentFnDbgScope->addVariable(ArgVar);
2077 DbgValueStartMap[MInsn] = ArgVar;
2081 DebugLoc DL = MInsn->getDebugLoc();
2082 if (DL.isUnknown()) continue;
2083 DbgScope *Scope = 0;
2084 if (MDNode *IA = DL.getInlinedAt(Ctx))
2085 Scope = ConcreteScopes.lookup(IA);
2087 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2089 // If variable scope is not found then skip this variable.
2093 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2094 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2095 DbgValueStartMap[MInsn] = RegVar;
2096 Scope->addVariable(RegVar);
2101 /// beginScope - Process beginning of a scope.
2102 void DwarfDebug::beginScope(const MachineInstr *MI) {
2104 DebugLoc DL = MI->getDebugLoc();
2108 // Check and update last known location info.
2109 if (DL == PrevInstLoc)
2112 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2114 // FIXME: Should only verify each scope once!
2115 if (!DIScope(Scope).Verify())
2118 // DBG_VALUE instruction establishes new value.
2119 if (MI->isDebugValue()) {
2120 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2121 = DbgValueStartMap.find(MI);
2122 if (DI != DbgValueStartMap.end()) {
2123 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2125 DI->second->setDbgValueLabel(Label);
2130 // Emit a label to indicate location change. This is used for line
2131 // table even if this instruction does start a new scope.
2132 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2135 // If this instruction begins a scope then note down corresponding label.
2136 if (InsnsBeginScopeSet.count(MI) != 0)
2137 InsnBeforeLabelMap[MI] = Label;
2140 /// endScope - Process end of a scope.
2141 void DwarfDebug::endScope(const MachineInstr *MI) {
2142 // Ignore DBG_VALUE instruction.
2143 if (MI->isDebugValue())
2147 DebugLoc DL = MI->getDebugLoc();
2151 if (InsnsEndScopeSet.count(MI) != 0) {
2152 // Emit a label if this instruction ends a scope.
2153 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2154 Asm->OutStreamer.EmitLabel(Label);
2155 InsnAfterLabelMap[MI] = Label;
2159 /// createDbgScope - Create DbgScope for the scope.
2160 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2162 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2165 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2166 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2167 if (DIDescriptor(Scope).isLexicalBlock())
2168 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2172 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2176 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2177 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2178 DILocation DL(InlinedAt);
2179 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2182 /// extractScopeInformation - Scan machine instructions in this function
2183 /// and collect DbgScopes. Return true, if at least one scope was found.
2184 bool DwarfDebug::extractScopeInformation() {
2185 // If scope information was extracted using .dbg intrinsics then there is not
2186 // any need to extract these information by scanning each instruction.
2187 if (!DbgScopeMap.empty())
2190 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2191 unsigned MIIndex = 0;
2192 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2194 // Scan each instruction and create scopes. First build working set of scopes.
2195 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2197 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2199 const MachineInstr *MInsn = II;
2200 // FIXME : Remove DBG_VALUE check.
2201 if (MInsn->isDebugValue()) continue;
2202 MIIndexMap[MInsn] = MIIndex++;
2204 DebugLoc DL = MInsn->getDebugLoc();
2205 if (DL.isUnknown()) continue;
2207 MDNode *Scope = DL.getScope(Ctx);
2209 // There is no need to create another DIE for compile unit. For all
2210 // other scopes, create one DbgScope now. This will be translated
2211 // into a scope DIE at the end.
2212 if (DIScope(Scope).isCompileUnit()) continue;
2213 createDbgScope(Scope, DL.getInlinedAt(Ctx));
2218 // Build scope hierarchy using working set of scopes.
2219 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2221 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2223 const MachineInstr *MInsn = II;
2224 // FIXME : Remove DBG_VALUE check.
2225 if (MInsn->isDebugValue()) continue;
2226 DebugLoc DL = MInsn->getDebugLoc();
2227 if (DL.isUnknown()) continue;
2229 MDNode *Scope = DL.getScope(Ctx);
2230 if (Scope == 0) continue;
2232 // There is no need to create another DIE for compile unit. For all
2233 // other scopes, create one DbgScope now. This will be translated
2234 // into a scope DIE at the end.
2235 if (DIScope(Scope).isCompileUnit()) continue;
2236 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2237 DScope->setLastInsn(MInsn);
2241 if (!CurrentFnDbgScope)
2244 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2246 identifyScopeMarkers();
2248 return !DbgScopeMap.empty();
2251 /// identifyScopeMarkers() - Indentify instructions that are marking
2252 /// beginning of or end of a scope.
2253 void DwarfDebug::identifyScopeMarkers() {
2255 // Each scope has first instruction and last instruction to mark beginning
2256 // and end of a scope respectively. Create an inverse map that list scopes
2257 // starts (and ends) with an instruction. One instruction may start (or end)
2258 // multiple scopes. Ignore scopes that are not reachable.
2259 SmallVector<DbgScope *, 4> WorkList;
2260 WorkList.push_back(CurrentFnDbgScope);
2261 while (!WorkList.empty()) {
2262 DbgScope *S = WorkList.pop_back_val();
2264 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2265 if (!Children.empty())
2266 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2267 SE = Children.end(); SI != SE; ++SI)
2268 WorkList.push_back(*SI);
2270 if (S->isAbstractScope())
2272 assert(S->getFirstInsn() && "DbgScope does not have first instruction!");
2273 InsnsBeginScopeSet.insert(S->getFirstInsn());
2275 assert(S->getLastInsn() && "DbgScope does not have last instruction!");
2276 InsnsEndScopeSet.insert(S->getLastInsn());
2280 /// beginFunction - Gather pre-function debug information. Assumes being
2281 /// emitted immediately after the function entry point.
2282 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2283 if (!MMI->hasDebugInfo()) return;
2284 if (!extractScopeInformation()) return;
2286 collectVariableInfo();
2288 // Assumes in correct section after the entry point.
2289 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2290 Asm->getFunctionNumber()));
2292 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2294 DebugLoc FDL = MF->getDefaultDebugLoc();
2295 if (FDL.isUnknown()) return;
2297 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2299 DISubprogram SP = getDISubprogram(Scope);
2302 Line = SP.getLineNumber();
2305 Line = FDL.getLine();
2309 recordSourceLine(Line, Col, Scope);
2312 /// endFunction - Gather and emit post-function debug information.
2314 void DwarfDebug::endFunction(const MachineFunction *MF) {
2315 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2317 if (CurrentFnDbgScope) {
2318 // Define end label for subprogram.
2319 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2320 Asm->getFunctionNumber()));
2322 // Get function line info.
2323 if (!Lines.empty()) {
2324 // Get section line info.
2325 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2326 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2327 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2328 // Append the function info to section info.
2329 SectionLineInfos.insert(SectionLineInfos.end(),
2330 Lines.begin(), Lines.end());
2333 // Construct abstract scopes.
2334 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2335 AE = AbstractScopesList.end(); AI != AE; ++AI)
2336 constructScopeDIE(*AI);
2338 constructScopeDIE(CurrentFnDbgScope);
2340 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2341 MMI->getFrameMoves()));
2345 CurrentFnDbgScope = NULL;
2346 DeleteContainerSeconds(DbgScopeMap);
2347 InsnsBeginScopeSet.clear();
2348 InsnsEndScopeSet.clear();
2349 DbgValueStartMap.clear();
2350 ConcreteScopes.clear();
2351 DeleteContainerSeconds(AbstractScopes);
2352 AbstractScopesList.clear();
2353 AbstractVariables.clear();
2354 InsnBeforeLabelMap.clear();
2355 InsnAfterLabelMap.clear();
2360 /// recordSourceLine - Register a source line with debug info. Returns the
2361 /// unique label that was emitted and which provides correspondence to
2362 /// the source line list.
2363 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2367 DIDescriptor Scope(S);
2368 if (Scope.isCompileUnit()) {
2369 DICompileUnit CU(S);
2370 Dir = CU.getDirectory();
2371 Fn = CU.getFilename();
2372 } else if (Scope.isSubprogram()) {
2374 Dir = SP.getDirectory();
2375 Fn = SP.getFilename();
2376 } else if (Scope.isLexicalBlock()) {
2377 DILexicalBlock DB(S);
2378 Dir = DB.getDirectory();
2379 Fn = DB.getFilename();
2381 assert(0 && "Unexpected scope info");
2383 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2384 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2385 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2387 Asm->OutStreamer.EmitLabel(Label);
2391 //===----------------------------------------------------------------------===//
2393 //===----------------------------------------------------------------------===//
2395 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2398 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2399 // Get the children.
2400 const std::vector<DIE *> &Children = Die->getChildren();
2402 // If not last sibling and has children then add sibling offset attribute.
2403 if (!Last && !Children.empty())
2404 Die->addSiblingOffset(DIEValueAllocator);
2406 // Record the abbreviation.
2407 assignAbbrevNumber(Die->getAbbrev());
2409 // Get the abbreviation for this DIE.
2410 unsigned AbbrevNumber = Die->getAbbrevNumber();
2411 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2414 Die->setOffset(Offset);
2416 // Start the size with the size of abbreviation code.
2417 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2419 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2420 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2422 // Size the DIE attribute values.
2423 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2424 // Size attribute value.
2425 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2427 // Size the DIE children if any.
2428 if (!Children.empty()) {
2429 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2430 "Children flag not set");
2432 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2433 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2435 // End of children marker.
2436 Offset += sizeof(int8_t);
2439 Die->setSize(Offset - Die->getOffset());
2443 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2445 void DwarfDebug::computeSizeAndOffsets() {
2446 // Compute size of compile unit header.
2447 static unsigned Offset =
2448 sizeof(int32_t) + // Length of Compilation Unit Info
2449 sizeof(int16_t) + // DWARF version number
2450 sizeof(int32_t) + // Offset Into Abbrev. Section
2451 sizeof(int8_t); // Pointer Size (in bytes)
2453 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2456 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2457 /// temporary label to it if SymbolStem is specified.
2458 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2459 const char *SymbolStem = 0) {
2460 Asm->OutStreamer.SwitchSection(Section);
2461 if (!SymbolStem) return 0;
2463 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2464 Asm->OutStreamer.EmitLabel(TmpSym);
2468 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2469 /// the start of each one.
2470 void DwarfDebug::EmitSectionLabels() {
2471 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2473 // Dwarf sections base addresses.
2474 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2475 DwarfFrameSectionSym =
2476 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2479 DwarfInfoSectionSym =
2480 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2481 DwarfAbbrevSectionSym =
2482 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2483 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2485 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2486 EmitSectionSym(Asm, MacroInfo);
2488 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2489 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2490 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2491 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2492 DwarfStrSectionSym =
2493 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2494 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2497 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2498 EmitSectionSym(Asm, TLOF.getDataSection());
2501 /// emitDIE - Recusively Emits a debug information entry.
2503 void DwarfDebug::emitDIE(DIE *Die) {
2504 // Get the abbreviation for this DIE.
2505 unsigned AbbrevNumber = Die->getAbbrevNumber();
2506 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2508 // Emit the code (index) for the abbreviation.
2509 if (Asm->isVerbose())
2510 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2511 Twine::utohexstr(Die->getOffset()) + ":0x" +
2512 Twine::utohexstr(Die->getSize()) + " " +
2513 dwarf::TagString(Abbrev->getTag()));
2514 Asm->EmitULEB128(AbbrevNumber);
2516 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2517 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2519 // Emit the DIE attribute values.
2520 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2521 unsigned Attr = AbbrevData[i].getAttribute();
2522 unsigned Form = AbbrevData[i].getForm();
2523 assert(Form && "Too many attributes for DIE (check abbreviation)");
2525 if (Asm->isVerbose())
2526 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2529 case dwarf::DW_AT_sibling:
2530 Asm->EmitInt32(Die->getSiblingOffset());
2532 case dwarf::DW_AT_abstract_origin: {
2533 DIEEntry *E = cast<DIEEntry>(Values[i]);
2534 DIE *Origin = E->getEntry();
2535 unsigned Addr = Origin->getOffset();
2536 Asm->EmitInt32(Addr);
2539 case dwarf::DW_AT_ranges: {
2540 // DW_AT_range Value encodes offset in debug_range section.
2541 DIEInteger *V = cast<DIEInteger>(Values[i]);
2542 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2544 DwarfDebugRangeSectionSym,
2549 // Emit an attribute using the defined form.
2550 Values[i]->EmitValue(Asm, Form);
2555 // Emit the DIE children if any.
2556 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2557 const std::vector<DIE *> &Children = Die->getChildren();
2559 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2560 emitDIE(Children[j]);
2562 if (Asm->isVerbose())
2563 Asm->OutStreamer.AddComment("End Of Children Mark");
2568 /// emitDebugInfo - Emit the debug info section.
2570 void DwarfDebug::emitDebugInfo() {
2571 // Start debug info section.
2572 Asm->OutStreamer.SwitchSection(
2573 Asm->getObjFileLowering().getDwarfInfoSection());
2574 DIE *Die = ModuleCU->getCUDie();
2576 // Emit the compile units header.
2577 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2578 ModuleCU->getID()));
2580 // Emit size of content not including length itself
2581 unsigned ContentSize = Die->getSize() +
2582 sizeof(int16_t) + // DWARF version number
2583 sizeof(int32_t) + // Offset Into Abbrev. Section
2584 sizeof(int8_t) + // Pointer Size (in bytes)
2585 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2587 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2588 Asm->EmitInt32(ContentSize);
2589 Asm->OutStreamer.AddComment("DWARF version number");
2590 Asm->EmitInt16(dwarf::DWARF_VERSION);
2591 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2592 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2593 DwarfAbbrevSectionSym);
2594 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2595 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2598 // FIXME - extra padding for gdb bug.
2599 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2604 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2607 /// emitAbbreviations - Emit the abbreviation section.
2609 void DwarfDebug::emitAbbreviations() const {
2610 // Check to see if it is worth the effort.
2611 if (!Abbreviations.empty()) {
2612 // Start the debug abbrev section.
2613 Asm->OutStreamer.SwitchSection(
2614 Asm->getObjFileLowering().getDwarfAbbrevSection());
2616 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2618 // For each abbrevation.
2619 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2620 // Get abbreviation data
2621 const DIEAbbrev *Abbrev = Abbreviations[i];
2623 // Emit the abbrevations code (base 1 index.)
2624 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2626 // Emit the abbreviations data.
2630 // Mark end of abbreviations.
2631 Asm->EmitULEB128(0, "EOM(3)");
2633 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2637 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2638 /// the line matrix.
2640 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2641 // Define last address of section.
2642 Asm->OutStreamer.AddComment("Extended Op");
2645 Asm->OutStreamer.AddComment("Op size");
2646 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2647 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2648 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2650 Asm->OutStreamer.AddComment("Section end label");
2652 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2653 Asm->getTargetData().getPointerSize(),
2656 // Mark end of matrix.
2657 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2663 /// emitDebugLines - Emit source line information.
2665 void DwarfDebug::emitDebugLines() {
2666 // If the target is using .loc/.file, the assembler will be emitting the
2667 // .debug_line table automatically.
2668 if (Asm->MAI->hasDotLocAndDotFile())
2671 // Minimum line delta, thus ranging from -10..(255-10).
2672 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2673 // Maximum line delta, thus ranging from -10..(255-10).
2674 const int MaxLineDelta = 255 + MinLineDelta;
2676 // Start the dwarf line section.
2677 Asm->OutStreamer.SwitchSection(
2678 Asm->getObjFileLowering().getDwarfLineSection());
2680 // Construct the section header.
2681 Asm->OutStreamer.AddComment("Length of Source Line Info");
2682 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2683 Asm->GetTempSymbol("line_begin"), 4);
2684 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2686 Asm->OutStreamer.AddComment("DWARF version number");
2687 Asm->EmitInt16(dwarf::DWARF_VERSION);
2689 Asm->OutStreamer.AddComment("Prolog Length");
2690 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2691 Asm->GetTempSymbol("line_prolog_begin"), 4);
2692 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2694 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2696 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2698 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2699 Asm->EmitInt8(MinLineDelta);
2700 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2701 Asm->EmitInt8(MaxLineDelta);
2702 Asm->OutStreamer.AddComment("Special Opcode Base");
2703 Asm->EmitInt8(-MinLineDelta);
2705 // Line number standard opcode encodings argument count
2706 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2708 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2710 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2712 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2714 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2716 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2718 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2720 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2722 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2725 // Emit directories.
2726 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2727 const std::string &Dir = getSourceDirectoryName(DI);
2728 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2729 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2732 Asm->OutStreamer.AddComment("End of directories");
2736 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2737 // Remember source id starts at 1.
2738 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2739 const std::string &FN = getSourceFileName(Id.second);
2740 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2741 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2743 Asm->EmitULEB128(Id.first, "Directory #");
2744 Asm->EmitULEB128(0, "Mod date");
2745 Asm->EmitULEB128(0, "File size");
2748 Asm->OutStreamer.AddComment("End of files");
2751 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2753 // A sequence for each text section.
2754 unsigned SecSrcLinesSize = SectionSourceLines.size();
2756 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2757 // Isolate current sections line info.
2758 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2760 // Dwarf assumes we start with first line of first source file.
2761 unsigned Source = 1;
2764 // Construct rows of the address, source, line, column matrix.
2765 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2766 const SrcLineInfo &LineInfo = LineInfos[i];
2767 MCSymbol *Label = LineInfo.getLabel();
2768 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2770 if (LineInfo.getLine() == 0) continue;
2772 if (Asm->isVerbose()) {
2773 std::pair<unsigned, unsigned> SrcID =
2774 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2775 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2777 Twine(getSourceFileName(SrcID.second)) +
2778 ":" + Twine(LineInfo.getLine()));
2781 // Define the line address.
2782 Asm->OutStreamer.AddComment("Extended Op");
2784 Asm->OutStreamer.AddComment("Op size");
2785 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2787 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2788 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2790 Asm->OutStreamer.AddComment("Location label");
2791 Asm->OutStreamer.EmitSymbolValue(Label,
2792 Asm->getTargetData().getPointerSize(),
2795 // If change of source, then switch to the new source.
2796 if (Source != LineInfo.getSourceID()) {
2797 Source = LineInfo.getSourceID();
2798 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2799 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2800 Asm->EmitULEB128(Source, "New Source");
2803 // If change of line.
2804 if (Line != LineInfo.getLine()) {
2805 // Determine offset.
2806 int Offset = LineInfo.getLine() - Line;
2807 int Delta = Offset - MinLineDelta;
2810 Line = LineInfo.getLine();
2812 // If delta is small enough and in range...
2813 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2814 // ... then use fast opcode.
2815 Asm->OutStreamer.AddComment("Line Delta");
2816 Asm->EmitInt8(Delta - MinLineDelta);
2818 // ... otherwise use long hand.
2819 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2820 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2821 Asm->EmitSLEB128(Offset, "Line Offset");
2822 Asm->OutStreamer.AddComment("DW_LNS_copy");
2823 Asm->EmitInt8(dwarf::DW_LNS_copy);
2826 // Copy the previous row (different address or source)
2827 Asm->OutStreamer.AddComment("DW_LNS_copy");
2828 Asm->EmitInt8(dwarf::DW_LNS_copy);
2832 emitEndOfLineMatrix(j + 1);
2835 if (SecSrcLinesSize == 0)
2836 // Because we're emitting a debug_line section, we still need a line
2837 // table. The linker and friends expect it to exist. If there's nothing to
2838 // put into it, emit an empty table.
2839 emitEndOfLineMatrix(1);
2841 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2844 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2846 void DwarfDebug::emitCommonDebugFrame() {
2847 if (!Asm->MAI->doesDwarfRequireFrameSection())
2850 int stackGrowth = Asm->getTargetData().getPointerSize();
2851 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2852 TargetFrameInfo::StackGrowsDown)
2855 // Start the dwarf frame section.
2856 Asm->OutStreamer.SwitchSection(
2857 Asm->getObjFileLowering().getDwarfFrameSection());
2859 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2860 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2861 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2862 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2864 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2865 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2866 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2867 Asm->OutStreamer.AddComment("CIE Version");
2868 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2869 Asm->OutStreamer.AddComment("CIE Augmentation");
2870 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2871 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2872 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2873 Asm->OutStreamer.AddComment("CIE RA Column");
2874 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2875 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2877 std::vector<MachineMove> Moves;
2878 RI->getInitialFrameState(Moves);
2880 Asm->EmitFrameMoves(Moves, 0, false);
2882 Asm->EmitAlignment(2, 0, 0, false);
2883 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2886 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2889 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2890 if (!Asm->MAI->doesDwarfRequireFrameSection())
2893 // Start the dwarf frame section.
2894 Asm->OutStreamer.SwitchSection(
2895 Asm->getObjFileLowering().getDwarfFrameSection());
2897 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2898 MCSymbol *DebugFrameBegin =
2899 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2900 MCSymbol *DebugFrameEnd =
2901 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2902 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2904 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2906 Asm->OutStreamer.AddComment("FDE CIE offset");
2907 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2908 DwarfFrameSectionSym);
2910 Asm->OutStreamer.AddComment("FDE initial location");
2911 MCSymbol *FuncBeginSym =
2912 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2913 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2914 Asm->getTargetData().getPointerSize(),
2918 Asm->OutStreamer.AddComment("FDE address range");
2919 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2920 FuncBeginSym, Asm->getTargetData().getPointerSize());
2922 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2924 Asm->EmitAlignment(2, 0, 0, false);
2925 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2928 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2930 void DwarfDebug::emitDebugPubNames() {
2931 // Start the dwarf pubnames section.
2932 Asm->OutStreamer.SwitchSection(
2933 Asm->getObjFileLowering().getDwarfPubNamesSection());
2935 Asm->OutStreamer.AddComment("Length of Public Names Info");
2936 Asm->EmitLabelDifference(
2937 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2938 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2940 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2941 ModuleCU->getID()));
2943 Asm->OutStreamer.AddComment("DWARF Version");
2944 Asm->EmitInt16(dwarf::DWARF_VERSION);
2946 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2947 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2948 DwarfInfoSectionSym);
2950 Asm->OutStreamer.AddComment("Compilation Unit Length");
2951 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2952 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2955 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2956 for (StringMap<DIE*>::const_iterator
2957 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2958 const char *Name = GI->getKeyData();
2959 DIE *Entity = GI->second;
2961 Asm->OutStreamer.AddComment("DIE offset");
2962 Asm->EmitInt32(Entity->getOffset());
2964 if (Asm->isVerbose())
2965 Asm->OutStreamer.AddComment("External Name");
2966 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2969 Asm->OutStreamer.AddComment("End Mark");
2971 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2972 ModuleCU->getID()));
2975 void DwarfDebug::emitDebugPubTypes() {
2976 // Start the dwarf pubnames section.
2977 Asm->OutStreamer.SwitchSection(
2978 Asm->getObjFileLowering().getDwarfPubTypesSection());
2979 Asm->OutStreamer.AddComment("Length of Public Types Info");
2980 Asm->EmitLabelDifference(
2981 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
2982 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
2984 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2985 ModuleCU->getID()));
2987 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2988 Asm->EmitInt16(dwarf::DWARF_VERSION);
2990 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2991 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2992 DwarfInfoSectionSym);
2994 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2995 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2996 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2999 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
3000 for (StringMap<DIE*>::const_iterator
3001 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3002 const char *Name = GI->getKeyData();
3003 DIE * Entity = GI->second;
3005 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3006 Asm->EmitInt32(Entity->getOffset());
3008 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3009 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3012 Asm->OutStreamer.AddComment("End Mark");
3014 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3015 ModuleCU->getID()));
3018 /// emitDebugStr - Emit visible names into a debug str section.
3020 void DwarfDebug::emitDebugStr() {
3021 // Check to see if it is worth the effort.
3022 if (StringPool.empty()) return;
3024 // Start the dwarf str section.
3025 Asm->OutStreamer.SwitchSection(
3026 Asm->getObjFileLowering().getDwarfStrSection());
3028 // Get all of the string pool entries and put them in an array by their ID so
3029 // we can sort them.
3030 SmallVector<std::pair<unsigned,
3031 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3033 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3034 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3035 Entries.push_back(std::make_pair(I->second.second, &*I));
3037 array_pod_sort(Entries.begin(), Entries.end());
3039 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3040 // Emit a label for reference from debug information entries.
3041 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3043 // Emit the string itself.
3044 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3048 /// emitDebugLoc - Emit visible names into a debug loc section.
3050 void DwarfDebug::emitDebugLoc() {
3051 // Start the dwarf loc section.
3052 Asm->OutStreamer.SwitchSection(
3053 Asm->getObjFileLowering().getDwarfLocSection());
3056 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3058 void DwarfDebug::EmitDebugARanges() {
3059 // Start the dwarf aranges section.
3060 Asm->OutStreamer.SwitchSection(
3061 Asm->getObjFileLowering().getDwarfARangesSection());
3064 /// emitDebugRanges - Emit visible names into a debug ranges section.
3066 void DwarfDebug::emitDebugRanges() {
3067 // Start the dwarf ranges section.
3068 Asm->OutStreamer.SwitchSection(
3069 Asm->getObjFileLowering().getDwarfRangesSection());
3070 for (SmallVector<const MCSymbol *, 8>::const_iterator I = DebugRangeSymbols.begin(),
3071 E = DebugRangeSymbols.end(); I != E; ++I) {
3073 Asm->EmitLabelDifference(*I, TextSectionSym,
3074 Asm->getTargetData().getPointerSize());
3076 Asm->OutStreamer.EmitIntValue(0, Asm->getTargetData().getPointerSize(),
3081 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3083 void DwarfDebug::emitDebugMacInfo() {
3084 if (const MCSection *LineInfo =
3085 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3086 // Start the dwarf macinfo section.
3087 Asm->OutStreamer.SwitchSection(LineInfo);
3091 /// emitDebugInlineInfo - Emit inline info using following format.
3093 /// 1. length of section
3094 /// 2. Dwarf version number
3095 /// 3. address size.
3097 /// Entries (one "entry" for each function that was inlined):
3099 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3100 /// otherwise offset into __debug_str for regular function name.
3101 /// 2. offset into __debug_str section for regular function name.
3102 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3103 /// instances for the function.
3105 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3106 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3107 /// __debug_info section, and the low_pc is the starting address for the
3108 /// inlining instance.
3109 void DwarfDebug::emitDebugInlineInfo() {
3110 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3116 Asm->OutStreamer.SwitchSection(
3117 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3119 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3120 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3121 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3123 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3125 Asm->OutStreamer.AddComment("Dwarf Version");
3126 Asm->EmitInt16(dwarf::DWARF_VERSION);
3127 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3128 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3130 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3131 E = InlinedSPNodes.end(); I != E; ++I) {
3134 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3135 = InlineInfo.find(Node);
3136 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3137 DISubprogram SP(Node);
3138 StringRef LName = SP.getLinkageName();
3139 StringRef Name = SP.getName();
3141 Asm->OutStreamer.AddComment("MIPS linkage name");
3142 if (LName.empty()) {
3143 Asm->OutStreamer.EmitBytes(Name, 0);
3144 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3146 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3147 DwarfStrSectionSym);
3149 Asm->OutStreamer.AddComment("Function name");
3150 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3151 Asm->EmitULEB128(Labels.size(), "Inline count");
3153 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3154 LE = Labels.end(); LI != LE; ++LI) {
3155 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3156 Asm->EmitInt32(LI->second->getOffset());
3158 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3159 Asm->OutStreamer.EmitSymbolValue(LI->first,
3160 Asm->getTargetData().getPointerSize(),0);
3164 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));