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)
2072 const_cast<MDNode *>(MInsn->getOperand(MInsn->getNumOperands() - 1)
2074 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2075 // FIXME Handle inlined subroutine arguments.
2076 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2077 CurrentFnDbgScope->addVariable(ArgVar);
2078 DbgValueStartMap[MInsn] = ArgVar;
2082 DebugLoc DL = MInsn->getDebugLoc();
2083 if (DL.isUnknown()) continue;
2084 DbgScope *Scope = 0;
2085 if (MDNode *IA = DL.getInlinedAt(Ctx))
2086 Scope = ConcreteScopes.lookup(IA);
2088 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2090 // If variable scope is not found then skip this variable.
2094 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2095 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2096 DbgValueStartMap[MInsn] = RegVar;
2097 Scope->addVariable(RegVar);
2102 /// beginScope - Process beginning of a scope.
2103 void DwarfDebug::beginScope(const MachineInstr *MI) {
2105 DebugLoc DL = MI->getDebugLoc();
2109 // Check and update last known location info.
2110 if (DL == PrevInstLoc)
2113 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2115 // FIXME: Should only verify each scope once!
2116 if (!DIScope(Scope).Verify())
2119 // DBG_VALUE instruction establishes new value.
2120 if (MI->isDebugValue()) {
2121 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2122 = DbgValueStartMap.find(MI);
2123 if (DI != DbgValueStartMap.end()) {
2124 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2126 DI->second->setDbgValueLabel(Label);
2131 // Emit a label to indicate location change. This is used for line
2132 // table even if this instruction does start a new scope.
2133 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2136 // If this instruction begins a scope then note down corresponding label.
2137 if (InsnsBeginScopeSet.count(MI) != 0)
2138 InsnBeforeLabelMap[MI] = Label;
2141 /// endScope - Process end of a scope.
2142 void DwarfDebug::endScope(const MachineInstr *MI) {
2143 // Ignore DBG_VALUE instruction.
2144 if (MI->isDebugValue())
2148 DebugLoc DL = MI->getDebugLoc();
2152 if (InsnsEndScopeSet.count(MI) != 0) {
2153 // Emit a label if this instruction ends a scope.
2154 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2155 Asm->OutStreamer.EmitLabel(Label);
2156 InsnAfterLabelMap[MI] = Label;
2160 /// createDbgScope - Create DbgScope for the scope.
2161 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2163 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2166 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2167 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2168 if (DIDescriptor(Scope).isLexicalBlock())
2169 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2173 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2177 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2178 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2179 DILocation DL(InlinedAt);
2180 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2183 /// extractScopeInformation - Scan machine instructions in this function
2184 /// and collect DbgScopes. Return true, if at least one scope was found.
2185 bool DwarfDebug::extractScopeInformation() {
2186 // If scope information was extracted using .dbg intrinsics then there is not
2187 // any need to extract these information by scanning each instruction.
2188 if (!DbgScopeMap.empty())
2191 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2192 unsigned MIIndex = 0;
2193 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2195 // Scan each instruction and create scopes. First build working set of scopes.
2196 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2198 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2200 const MachineInstr *MInsn = II;
2201 // FIXME : Remove DBG_VALUE check.
2202 if (MInsn->isDebugValue()) continue;
2203 MIIndexMap[MInsn] = MIIndex++;
2205 DebugLoc DL = MInsn->getDebugLoc();
2206 if (DL.isUnknown()) continue;
2208 MDNode *Scope = DL.getScope(Ctx);
2210 // There is no need to create another DIE for compile unit. For all
2211 // other scopes, create one DbgScope now. This will be translated
2212 // into a scope DIE at the end.
2213 if (DIScope(Scope).isCompileUnit()) continue;
2214 createDbgScope(Scope, DL.getInlinedAt(Ctx));
2219 // Build scope hierarchy using working set of scopes.
2220 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2222 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2224 const MachineInstr *MInsn = II;
2225 // FIXME : Remove DBG_VALUE check.
2226 if (MInsn->isDebugValue()) continue;
2227 DebugLoc DL = MInsn->getDebugLoc();
2228 if (DL.isUnknown()) continue;
2230 MDNode *Scope = DL.getScope(Ctx);
2231 if (Scope == 0) continue;
2233 // There is no need to create another DIE for compile unit. For all
2234 // other scopes, create one DbgScope now. This will be translated
2235 // into a scope DIE at the end.
2236 if (DIScope(Scope).isCompileUnit()) continue;
2237 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2238 DScope->setLastInsn(MInsn);
2242 if (!CurrentFnDbgScope)
2245 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2247 identifyScopeMarkers();
2249 return !DbgScopeMap.empty();
2252 /// identifyScopeMarkers() - Indentify instructions that are marking
2253 /// beginning of or end of a scope.
2254 void DwarfDebug::identifyScopeMarkers() {
2256 // Each scope has first instruction and last instruction to mark beginning
2257 // and end of a scope respectively. Create an inverse map that list scopes
2258 // starts (and ends) with an instruction. One instruction may start (or end)
2259 // multiple scopes. Ignore scopes that are not reachable.
2260 SmallVector<DbgScope *, 4> WorkList;
2261 WorkList.push_back(CurrentFnDbgScope);
2262 while (!WorkList.empty()) {
2263 DbgScope *S = WorkList.pop_back_val();
2265 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2266 if (!Children.empty())
2267 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2268 SE = Children.end(); SI != SE; ++SI)
2269 WorkList.push_back(*SI);
2271 if (S->isAbstractScope())
2273 assert(S->getFirstInsn() && "DbgScope does not have first instruction!");
2274 InsnsBeginScopeSet.insert(S->getFirstInsn());
2276 assert(S->getLastInsn() && "DbgScope does not have last instruction!");
2277 InsnsEndScopeSet.insert(S->getLastInsn());
2281 /// beginFunction - Gather pre-function debug information. Assumes being
2282 /// emitted immediately after the function entry point.
2283 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2284 if (!MMI->hasDebugInfo()) return;
2285 if (!extractScopeInformation()) return;
2287 collectVariableInfo();
2289 // Assumes in correct section after the entry point.
2290 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2291 Asm->getFunctionNumber()));
2293 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2295 DebugLoc FDL = MF->getDefaultDebugLoc();
2296 if (FDL.isUnknown()) return;
2298 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2300 DISubprogram SP = getDISubprogram(Scope);
2303 Line = SP.getLineNumber();
2306 Line = FDL.getLine();
2310 recordSourceLine(Line, Col, Scope);
2313 /// endFunction - Gather and emit post-function debug information.
2315 void DwarfDebug::endFunction(const MachineFunction *MF) {
2316 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2318 if (CurrentFnDbgScope) {
2319 // Define end label for subprogram.
2320 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2321 Asm->getFunctionNumber()));
2323 // Get function line info.
2324 if (!Lines.empty()) {
2325 // Get section line info.
2326 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2327 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2328 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2329 // Append the function info to section info.
2330 SectionLineInfos.insert(SectionLineInfos.end(),
2331 Lines.begin(), Lines.end());
2334 // Construct abstract scopes.
2335 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2336 AE = AbstractScopesList.end(); AI != AE; ++AI)
2337 constructScopeDIE(*AI);
2339 constructScopeDIE(CurrentFnDbgScope);
2341 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2342 MMI->getFrameMoves()));
2346 CurrentFnDbgScope = NULL;
2347 DeleteContainerSeconds(DbgScopeMap);
2348 InsnsBeginScopeSet.clear();
2349 InsnsEndScopeSet.clear();
2350 DbgValueStartMap.clear();
2351 ConcreteScopes.clear();
2352 DeleteContainerSeconds(AbstractScopes);
2353 AbstractScopesList.clear();
2354 AbstractVariables.clear();
2355 InsnBeforeLabelMap.clear();
2356 InsnAfterLabelMap.clear();
2361 /// recordSourceLine - Register a source line with debug info. Returns the
2362 /// unique label that was emitted and which provides correspondence to
2363 /// the source line list.
2364 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2368 DIDescriptor Scope(S);
2369 if (Scope.isCompileUnit()) {
2370 DICompileUnit CU(S);
2371 Dir = CU.getDirectory();
2372 Fn = CU.getFilename();
2373 } else if (Scope.isSubprogram()) {
2375 Dir = SP.getDirectory();
2376 Fn = SP.getFilename();
2377 } else if (Scope.isLexicalBlock()) {
2378 DILexicalBlock DB(S);
2379 Dir = DB.getDirectory();
2380 Fn = DB.getFilename();
2382 assert(0 && "Unexpected scope info");
2384 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2385 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2386 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2388 Asm->OutStreamer.EmitLabel(Label);
2392 //===----------------------------------------------------------------------===//
2394 //===----------------------------------------------------------------------===//
2396 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2399 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2400 // Get the children.
2401 const std::vector<DIE *> &Children = Die->getChildren();
2403 // If not last sibling and has children then add sibling offset attribute.
2404 if (!Last && !Children.empty())
2405 Die->addSiblingOffset(DIEValueAllocator);
2407 // Record the abbreviation.
2408 assignAbbrevNumber(Die->getAbbrev());
2410 // Get the abbreviation for this DIE.
2411 unsigned AbbrevNumber = Die->getAbbrevNumber();
2412 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2415 Die->setOffset(Offset);
2417 // Start the size with the size of abbreviation code.
2418 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2420 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2421 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2423 // Size the DIE attribute values.
2424 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2425 // Size attribute value.
2426 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2428 // Size the DIE children if any.
2429 if (!Children.empty()) {
2430 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2431 "Children flag not set");
2433 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2434 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2436 // End of children marker.
2437 Offset += sizeof(int8_t);
2440 Die->setSize(Offset - Die->getOffset());
2444 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2446 void DwarfDebug::computeSizeAndOffsets() {
2447 // Compute size of compile unit header.
2448 static unsigned Offset =
2449 sizeof(int32_t) + // Length of Compilation Unit Info
2450 sizeof(int16_t) + // DWARF version number
2451 sizeof(int32_t) + // Offset Into Abbrev. Section
2452 sizeof(int8_t); // Pointer Size (in bytes)
2454 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2457 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2458 /// temporary label to it if SymbolStem is specified.
2459 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2460 const char *SymbolStem = 0) {
2461 Asm->OutStreamer.SwitchSection(Section);
2462 if (!SymbolStem) return 0;
2464 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2465 Asm->OutStreamer.EmitLabel(TmpSym);
2469 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2470 /// the start of each one.
2471 void DwarfDebug::EmitSectionLabels() {
2472 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2474 // Dwarf sections base addresses.
2475 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2476 DwarfFrameSectionSym =
2477 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2480 DwarfInfoSectionSym =
2481 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2482 DwarfAbbrevSectionSym =
2483 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2484 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2486 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2487 EmitSectionSym(Asm, MacroInfo);
2489 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2490 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2491 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2492 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2493 DwarfStrSectionSym =
2494 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2495 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2498 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2499 EmitSectionSym(Asm, TLOF.getDataSection());
2502 /// emitDIE - Recusively Emits a debug information entry.
2504 void DwarfDebug::emitDIE(DIE *Die) {
2505 // Get the abbreviation for this DIE.
2506 unsigned AbbrevNumber = Die->getAbbrevNumber();
2507 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2509 // Emit the code (index) for the abbreviation.
2510 if (Asm->isVerbose())
2511 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2512 Twine::utohexstr(Die->getOffset()) + ":0x" +
2513 Twine::utohexstr(Die->getSize()) + " " +
2514 dwarf::TagString(Abbrev->getTag()));
2515 Asm->EmitULEB128(AbbrevNumber);
2517 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2518 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2520 // Emit the DIE attribute values.
2521 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2522 unsigned Attr = AbbrevData[i].getAttribute();
2523 unsigned Form = AbbrevData[i].getForm();
2524 assert(Form && "Too many attributes for DIE (check abbreviation)");
2526 if (Asm->isVerbose())
2527 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2530 case dwarf::DW_AT_sibling:
2531 Asm->EmitInt32(Die->getSiblingOffset());
2533 case dwarf::DW_AT_abstract_origin: {
2534 DIEEntry *E = cast<DIEEntry>(Values[i]);
2535 DIE *Origin = E->getEntry();
2536 unsigned Addr = Origin->getOffset();
2537 Asm->EmitInt32(Addr);
2540 case dwarf::DW_AT_ranges: {
2541 // DW_AT_range Value encodes offset in debug_range section.
2542 DIEInteger *V = cast<DIEInteger>(Values[i]);
2543 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2545 DwarfDebugRangeSectionSym,
2550 // Emit an attribute using the defined form.
2551 Values[i]->EmitValue(Asm, Form);
2556 // Emit the DIE children if any.
2557 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2558 const std::vector<DIE *> &Children = Die->getChildren();
2560 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2561 emitDIE(Children[j]);
2563 if (Asm->isVerbose())
2564 Asm->OutStreamer.AddComment("End Of Children Mark");
2569 /// emitDebugInfo - Emit the debug info section.
2571 void DwarfDebug::emitDebugInfo() {
2572 // Start debug info section.
2573 Asm->OutStreamer.SwitchSection(
2574 Asm->getObjFileLowering().getDwarfInfoSection());
2575 DIE *Die = ModuleCU->getCUDie();
2577 // Emit the compile units header.
2578 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2579 ModuleCU->getID()));
2581 // Emit size of content not including length itself
2582 unsigned ContentSize = Die->getSize() +
2583 sizeof(int16_t) + // DWARF version number
2584 sizeof(int32_t) + // Offset Into Abbrev. Section
2585 sizeof(int8_t) + // Pointer Size (in bytes)
2586 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2588 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2589 Asm->EmitInt32(ContentSize);
2590 Asm->OutStreamer.AddComment("DWARF version number");
2591 Asm->EmitInt16(dwarf::DWARF_VERSION);
2592 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2593 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2594 DwarfAbbrevSectionSym);
2595 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2596 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2599 // FIXME - extra padding for gdb bug.
2600 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2605 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2608 /// emitAbbreviations - Emit the abbreviation section.
2610 void DwarfDebug::emitAbbreviations() const {
2611 // Check to see if it is worth the effort.
2612 if (!Abbreviations.empty()) {
2613 // Start the debug abbrev section.
2614 Asm->OutStreamer.SwitchSection(
2615 Asm->getObjFileLowering().getDwarfAbbrevSection());
2617 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2619 // For each abbrevation.
2620 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2621 // Get abbreviation data
2622 const DIEAbbrev *Abbrev = Abbreviations[i];
2624 // Emit the abbrevations code (base 1 index.)
2625 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2627 // Emit the abbreviations data.
2631 // Mark end of abbreviations.
2632 Asm->EmitULEB128(0, "EOM(3)");
2634 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2638 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2639 /// the line matrix.
2641 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2642 // Define last address of section.
2643 Asm->OutStreamer.AddComment("Extended Op");
2646 Asm->OutStreamer.AddComment("Op size");
2647 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2648 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2649 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2651 Asm->OutStreamer.AddComment("Section end label");
2653 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2654 Asm->getTargetData().getPointerSize(),
2657 // Mark end of matrix.
2658 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2664 /// emitDebugLines - Emit source line information.
2666 void DwarfDebug::emitDebugLines() {
2667 // If the target is using .loc/.file, the assembler will be emitting the
2668 // .debug_line table automatically.
2669 if (Asm->MAI->hasDotLocAndDotFile())
2672 // Minimum line delta, thus ranging from -10..(255-10).
2673 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2674 // Maximum line delta, thus ranging from -10..(255-10).
2675 const int MaxLineDelta = 255 + MinLineDelta;
2677 // Start the dwarf line section.
2678 Asm->OutStreamer.SwitchSection(
2679 Asm->getObjFileLowering().getDwarfLineSection());
2681 // Construct the section header.
2682 Asm->OutStreamer.AddComment("Length of Source Line Info");
2683 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2684 Asm->GetTempSymbol("line_begin"), 4);
2685 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2687 Asm->OutStreamer.AddComment("DWARF version number");
2688 Asm->EmitInt16(dwarf::DWARF_VERSION);
2690 Asm->OutStreamer.AddComment("Prolog Length");
2691 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2692 Asm->GetTempSymbol("line_prolog_begin"), 4);
2693 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2695 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2697 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2699 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2700 Asm->EmitInt8(MinLineDelta);
2701 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2702 Asm->EmitInt8(MaxLineDelta);
2703 Asm->OutStreamer.AddComment("Special Opcode Base");
2704 Asm->EmitInt8(-MinLineDelta);
2706 // Line number standard opcode encodings argument count
2707 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2709 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2711 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2713 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2715 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2717 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2719 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2721 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2723 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2726 // Emit directories.
2727 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2728 const std::string &Dir = getSourceDirectoryName(DI);
2729 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2730 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2733 Asm->OutStreamer.AddComment("End of directories");
2737 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2738 // Remember source id starts at 1.
2739 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2740 const std::string &FN = getSourceFileName(Id.second);
2741 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2742 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2744 Asm->EmitULEB128(Id.first, "Directory #");
2745 Asm->EmitULEB128(0, "Mod date");
2746 Asm->EmitULEB128(0, "File size");
2749 Asm->OutStreamer.AddComment("End of files");
2752 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2754 // A sequence for each text section.
2755 unsigned SecSrcLinesSize = SectionSourceLines.size();
2757 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2758 // Isolate current sections line info.
2759 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2761 // Dwarf assumes we start with first line of first source file.
2762 unsigned Source = 1;
2765 // Construct rows of the address, source, line, column matrix.
2766 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2767 const SrcLineInfo &LineInfo = LineInfos[i];
2768 MCSymbol *Label = LineInfo.getLabel();
2769 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2771 if (LineInfo.getLine() == 0) continue;
2773 if (Asm->isVerbose()) {
2774 std::pair<unsigned, unsigned> SrcID =
2775 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2776 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2778 Twine(getSourceFileName(SrcID.second)) +
2779 ":" + Twine(LineInfo.getLine()));
2782 // Define the line address.
2783 Asm->OutStreamer.AddComment("Extended Op");
2785 Asm->OutStreamer.AddComment("Op size");
2786 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2788 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2789 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2791 Asm->OutStreamer.AddComment("Location label");
2792 Asm->OutStreamer.EmitSymbolValue(Label,
2793 Asm->getTargetData().getPointerSize(),
2796 // If change of source, then switch to the new source.
2797 if (Source != LineInfo.getSourceID()) {
2798 Source = LineInfo.getSourceID();
2799 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2800 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2801 Asm->EmitULEB128(Source, "New Source");
2804 // If change of line.
2805 if (Line != LineInfo.getLine()) {
2806 // Determine offset.
2807 int Offset = LineInfo.getLine() - Line;
2808 int Delta = Offset - MinLineDelta;
2811 Line = LineInfo.getLine();
2813 // If delta is small enough and in range...
2814 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2815 // ... then use fast opcode.
2816 Asm->OutStreamer.AddComment("Line Delta");
2817 Asm->EmitInt8(Delta - MinLineDelta);
2819 // ... otherwise use long hand.
2820 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2821 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2822 Asm->EmitSLEB128(Offset, "Line Offset");
2823 Asm->OutStreamer.AddComment("DW_LNS_copy");
2824 Asm->EmitInt8(dwarf::DW_LNS_copy);
2827 // Copy the previous row (different address or source)
2828 Asm->OutStreamer.AddComment("DW_LNS_copy");
2829 Asm->EmitInt8(dwarf::DW_LNS_copy);
2833 emitEndOfLineMatrix(j + 1);
2836 if (SecSrcLinesSize == 0)
2837 // Because we're emitting a debug_line section, we still need a line
2838 // table. The linker and friends expect it to exist. If there's nothing to
2839 // put into it, emit an empty table.
2840 emitEndOfLineMatrix(1);
2842 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2845 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2847 void DwarfDebug::emitCommonDebugFrame() {
2848 if (!Asm->MAI->doesDwarfRequireFrameSection())
2851 int stackGrowth = Asm->getTargetData().getPointerSize();
2852 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2853 TargetFrameInfo::StackGrowsDown)
2856 // Start the dwarf frame section.
2857 Asm->OutStreamer.SwitchSection(
2858 Asm->getObjFileLowering().getDwarfFrameSection());
2860 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2861 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2862 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2863 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2865 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2866 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2867 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2868 Asm->OutStreamer.AddComment("CIE Version");
2869 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2870 Asm->OutStreamer.AddComment("CIE Augmentation");
2871 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2872 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2873 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2874 Asm->OutStreamer.AddComment("CIE RA Column");
2875 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2876 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2878 std::vector<MachineMove> Moves;
2879 RI->getInitialFrameState(Moves);
2881 Asm->EmitFrameMoves(Moves, 0, false);
2883 Asm->EmitAlignment(2, 0, 0, false);
2884 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2887 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2890 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2891 if (!Asm->MAI->doesDwarfRequireFrameSection())
2894 // Start the dwarf frame section.
2895 Asm->OutStreamer.SwitchSection(
2896 Asm->getObjFileLowering().getDwarfFrameSection());
2898 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2899 MCSymbol *DebugFrameBegin =
2900 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2901 MCSymbol *DebugFrameEnd =
2902 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2903 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2905 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2907 Asm->OutStreamer.AddComment("FDE CIE offset");
2908 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2909 DwarfFrameSectionSym);
2911 Asm->OutStreamer.AddComment("FDE initial location");
2912 MCSymbol *FuncBeginSym =
2913 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2914 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2915 Asm->getTargetData().getPointerSize(),
2919 Asm->OutStreamer.AddComment("FDE address range");
2920 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2921 FuncBeginSym, Asm->getTargetData().getPointerSize());
2923 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2925 Asm->EmitAlignment(2, 0, 0, false);
2926 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2929 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2931 void DwarfDebug::emitDebugPubNames() {
2932 // Start the dwarf pubnames section.
2933 Asm->OutStreamer.SwitchSection(
2934 Asm->getObjFileLowering().getDwarfPubNamesSection());
2936 Asm->OutStreamer.AddComment("Length of Public Names Info");
2937 Asm->EmitLabelDifference(
2938 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2939 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2941 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2942 ModuleCU->getID()));
2944 Asm->OutStreamer.AddComment("DWARF Version");
2945 Asm->EmitInt16(dwarf::DWARF_VERSION);
2947 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2948 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2949 DwarfInfoSectionSym);
2951 Asm->OutStreamer.AddComment("Compilation Unit Length");
2952 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2953 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2956 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2957 for (StringMap<DIE*>::const_iterator
2958 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2959 const char *Name = GI->getKeyData();
2960 DIE *Entity = GI->second;
2962 Asm->OutStreamer.AddComment("DIE offset");
2963 Asm->EmitInt32(Entity->getOffset());
2965 if (Asm->isVerbose())
2966 Asm->OutStreamer.AddComment("External Name");
2967 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2970 Asm->OutStreamer.AddComment("End Mark");
2972 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2973 ModuleCU->getID()));
2976 void DwarfDebug::emitDebugPubTypes() {
2977 // Start the dwarf pubnames section.
2978 Asm->OutStreamer.SwitchSection(
2979 Asm->getObjFileLowering().getDwarfPubTypesSection());
2980 Asm->OutStreamer.AddComment("Length of Public Types Info");
2981 Asm->EmitLabelDifference(
2982 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
2983 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
2985 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2986 ModuleCU->getID()));
2988 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2989 Asm->EmitInt16(dwarf::DWARF_VERSION);
2991 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2992 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2993 DwarfInfoSectionSym);
2995 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2996 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2997 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3000 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
3001 for (StringMap<DIE*>::const_iterator
3002 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3003 const char *Name = GI->getKeyData();
3004 DIE * Entity = GI->second;
3006 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3007 Asm->EmitInt32(Entity->getOffset());
3009 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3010 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3013 Asm->OutStreamer.AddComment("End Mark");
3015 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3016 ModuleCU->getID()));
3019 /// emitDebugStr - Emit visible names into a debug str section.
3021 void DwarfDebug::emitDebugStr() {
3022 // Check to see if it is worth the effort.
3023 if (StringPool.empty()) return;
3025 // Start the dwarf str section.
3026 Asm->OutStreamer.SwitchSection(
3027 Asm->getObjFileLowering().getDwarfStrSection());
3029 // Get all of the string pool entries and put them in an array by their ID so
3030 // we can sort them.
3031 SmallVector<std::pair<unsigned,
3032 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3034 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3035 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3036 Entries.push_back(std::make_pair(I->second.second, &*I));
3038 array_pod_sort(Entries.begin(), Entries.end());
3040 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3041 // Emit a label for reference from debug information entries.
3042 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3044 // Emit the string itself.
3045 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3049 /// emitDebugLoc - Emit visible names into a debug loc section.
3051 void DwarfDebug::emitDebugLoc() {
3052 // Start the dwarf loc section.
3053 Asm->OutStreamer.SwitchSection(
3054 Asm->getObjFileLowering().getDwarfLocSection());
3057 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3059 void DwarfDebug::EmitDebugARanges() {
3060 // Start the dwarf aranges section.
3061 Asm->OutStreamer.SwitchSection(
3062 Asm->getObjFileLowering().getDwarfARangesSection());
3065 /// emitDebugRanges - Emit visible names into a debug ranges section.
3067 void DwarfDebug::emitDebugRanges() {
3068 // Start the dwarf ranges section.
3069 Asm->OutStreamer.SwitchSection(
3070 Asm->getObjFileLowering().getDwarfRangesSection());
3071 for (SmallVector<const MCSymbol *, 8>::const_iterator I = DebugRangeSymbols.begin(),
3072 E = DebugRangeSymbols.end(); I != E; ++I) {
3074 Asm->EmitLabelDifference(*I, TextSectionSym,
3075 Asm->getTargetData().getPointerSize());
3077 Asm->OutStreamer.EmitIntValue(0, Asm->getTargetData().getPointerSize(),
3082 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3084 void DwarfDebug::emitDebugMacInfo() {
3085 if (const MCSection *LineInfo =
3086 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3087 // Start the dwarf macinfo section.
3088 Asm->OutStreamer.SwitchSection(LineInfo);
3092 /// emitDebugInlineInfo - Emit inline info using following format.
3094 /// 1. length of section
3095 /// 2. Dwarf version number
3096 /// 3. address size.
3098 /// Entries (one "entry" for each function that was inlined):
3100 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3101 /// otherwise offset into __debug_str for regular function name.
3102 /// 2. offset into __debug_str section for regular function name.
3103 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3104 /// instances for the function.
3106 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3107 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3108 /// __debug_info section, and the low_pc is the starting address for the
3109 /// inlining instance.
3110 void DwarfDebug::emitDebugInlineInfo() {
3111 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3117 Asm->OutStreamer.SwitchSection(
3118 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3120 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3121 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3122 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3124 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3126 Asm->OutStreamer.AddComment("Dwarf Version");
3127 Asm->EmitInt16(dwarf::DWARF_VERSION);
3128 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3129 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3131 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3132 E = InlinedSPNodes.end(); I != E; ++I) {
3135 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3136 = InlineInfo.find(Node);
3137 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3138 DISubprogram SP(Node);
3139 StringRef LName = SP.getLinkageName();
3140 StringRef Name = SP.getName();
3142 Asm->OutStreamer.AddComment("MIPS linkage name");
3143 if (LName.empty()) {
3144 Asm->OutStreamer.EmitBytes(Name, 0);
3145 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3147 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3148 DwarfStrSectionSym);
3150 Asm->OutStreamer.AddComment("Function name");
3151 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3152 Asm->EmitULEB128(Labels.size(), "Inline count");
3154 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3155 LE = Labels.end(); LI != LE; ++LI) {
3156 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3157 Asm->EmitInt32(LI->second->getOffset());
3159 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3160 Asm->OutStreamer.EmitSymbolValue(LI->first,
3161 Asm->getTargetData().getPointerSize(),0);
3165 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));