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"
16 #include "llvm/Module.h"
17 #include "llvm/CodeGen/MachineFunction.h"
18 #include "llvm/CodeGen/MachineModuleInfo.h"
19 #include "llvm/MC/MCAsmInfo.h"
20 #include "llvm/MC/MCSection.h"
21 #include "llvm/MC/MCStreamer.h"
22 #include "llvm/MC/MCSymbol.h"
23 #include "llvm/Target/Mangler.h"
24 #include "llvm/Target/TargetData.h"
25 #include "llvm/Target/TargetFrameInfo.h"
26 #include "llvm/Target/TargetLoweringObjectFile.h"
27 #include "llvm/Target/TargetMachine.h"
28 #include "llvm/Target/TargetRegisterInfo.h"
29 #include "llvm/ADT/STLExtras.h"
30 #include "llvm/ADT/StringExtras.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/ValueHandle.h"
34 #include "llvm/Support/FormattedStream.h"
35 #include "llvm/Support/Timer.h"
36 #include "llvm/System/Path.h"
39 //===----------------------------------------------------------------------===//
41 /// Configuration values for initial hash set sizes (log2).
43 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
47 //===----------------------------------------------------------------------===//
48 /// CompileUnit - This dwarf writer support class manages information associate
49 /// with a source file.
51 /// ID - File identifier for source.
55 /// Die - Compile unit debug information entry.
57 const OwningPtr<DIE> CUDie;
59 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
62 /// GVToDieMap - Tracks the mapping of unit level debug informaton
63 /// variables to debug information entries.
64 /// FIXME : Rename GVToDieMap -> NodeToDieMap
65 DenseMap<MDNode *, DIE *> GVToDieMap;
67 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
68 /// descriptors to debug information entries using a DIEEntry proxy.
70 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
72 /// Globals - A map of globally visible named entities for this unit.
74 StringMap<DIE*> Globals;
76 /// GlobalTypes - A map of globally visible types for this unit.
78 StringMap<DIE*> GlobalTypes;
81 CompileUnit(unsigned I, DIE *D)
82 : ID(I), CUDie(D), IndexTyDie(0) {}
85 unsigned getID() const { return ID; }
86 DIE* getCUDie() const { return CUDie.get(); }
87 const StringMap<DIE*> &getGlobals() const { return Globals; }
88 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
90 /// hasContent - Return true if this compile unit has something to write out.
92 bool hasContent() const { return !CUDie->getChildren().empty(); }
94 /// addGlobal - Add a new global entity to the compile unit.
96 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
98 /// addGlobalType - Add a new global type to the compile unit.
100 void addGlobalType(StringRef Name, DIE *Die) {
101 GlobalTypes[Name] = Die;
104 /// getDIE - Returns the debug information entry map slot for the
105 /// specified debug variable.
106 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
108 /// insertDIE - Insert DIE into the map.
109 void insertDIE(MDNode *N, DIE *D) {
110 GVToDieMap.insert(std::make_pair(N, D));
113 /// getDIEEntry - Returns the debug information entry for the speciefied
115 DIEEntry *getDIEEntry(MDNode *N) {
116 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
117 if (I == GVToDIEEntryMap.end())
122 /// insertDIEEntry - Insert debug information entry into the map.
123 void insertDIEEntry(MDNode *N, DIEEntry *E) {
124 GVToDIEEntryMap.insert(std::make_pair(N, E));
127 /// addDie - Adds or interns the DIE to the compile unit.
129 void addDie(DIE *Buffer) {
130 this->CUDie->addChild(Buffer);
133 // getIndexTyDie - Get an anonymous type for index type.
134 DIE *getIndexTyDie() {
138 // setIndexTyDie - Set D as anonymous type for index which can be reused
140 void setIndexTyDie(DIE *D) {
146 //===----------------------------------------------------------------------===//
147 /// DbgVariable - This class is used to track local variable information.
150 DIVariable Var; // Variable Descriptor.
151 unsigned FrameIndex; // Variable frame index.
152 const MachineInstr *DbgValueMInsn; // DBG_VALUE
153 // DbgValueLabel - DBG_VALUE is effective from this label.
154 MCSymbol *DbgValueLabel;
155 DbgVariable *const AbstractVar; // Abstract variable for this variable.
158 // AbsVar may be NULL.
159 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
160 : Var(V), FrameIndex(I), DbgValueMInsn(0),
161 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
162 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
163 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
164 AbstractVar(AbsVar), TheDIE(0)
168 DIVariable getVariable() const { return Var; }
169 unsigned getFrameIndex() const { return FrameIndex; }
170 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
171 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
172 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
173 DbgVariable *getAbstractVariable() const { return AbstractVar; }
174 void setDIE(DIE *D) { TheDIE = D; }
175 DIE *getDIE() const { return TheDIE; }
178 //===----------------------------------------------------------------------===//
179 /// DbgScope - This class is used to track scope information.
182 DbgScope *Parent; // Parent to this scope.
183 DIDescriptor Desc; // Debug info descriptor for scope.
184 // Location at which this scope is inlined.
185 AssertingVH<MDNode> InlinedAtLocation;
186 bool AbstractScope; // Abstract Scope
187 MCSymbol *StartLabel; // Label ID of the beginning of scope.
188 MCSymbol *EndLabel; // Label ID of the end of scope.
189 const MachineInstr *LastInsn; // Last instruction of this scope.
190 const MachineInstr *FirstInsn; // First instruction of this scope.
191 // Scopes defined in scope. Contents not owned.
192 SmallVector<DbgScope *, 4> Scopes;
193 // Variables declared in scope. Contents owned.
194 SmallVector<DbgVariable *, 8> Variables;
196 // Private state for dump()
197 mutable unsigned IndentLevel;
199 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
200 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
201 StartLabel(0), EndLabel(0),
202 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
206 DbgScope *getParent() const { return Parent; }
207 void setParent(DbgScope *P) { Parent = P; }
208 DIDescriptor getDesc() const { return Desc; }
209 MDNode *getInlinedAt() const { return InlinedAtLocation; }
210 MDNode *getScopeNode() const { return Desc.getNode(); }
211 MCSymbol *getStartLabel() const { return StartLabel; }
212 MCSymbol *getEndLabel() const { return EndLabel; }
213 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
214 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
215 void setStartLabel(MCSymbol *S) { StartLabel = S; }
216 void setEndLabel(MCSymbol *E) { EndLabel = E; }
217 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
218 const MachineInstr *getLastInsn() { return LastInsn; }
219 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
220 void setAbstractScope() { AbstractScope = true; }
221 bool isAbstractScope() const { return AbstractScope; }
222 const MachineInstr *getFirstInsn() { return FirstInsn; }
224 /// addScope - Add a scope to the scope.
226 void addScope(DbgScope *S) { Scopes.push_back(S); }
228 /// addVariable - Add a variable to the scope.
230 void addVariable(DbgVariable *V) { Variables.push_back(V); }
232 void fixInstructionMarkers(DenseMap<const MachineInstr *,
233 unsigned> &MIIndexMap) {
234 assert(getFirstInsn() && "First instruction is missing!");
236 // Use the end of last child scope as end of this scope.
237 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
238 const MachineInstr *LastInsn = getFirstInsn();
240 if (Scopes.empty()) {
241 assert(getLastInsn() && "Inner most scope does not have last insn!");
244 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
245 SE = Scopes.end(); SI != SE; ++SI) {
247 DS->fixInstructionMarkers(MIIndexMap);
248 const MachineInstr *DSLastInsn = DS->getLastInsn();
249 unsigned DSI = MIIndexMap[DSLastInsn];
251 LastInsn = DSLastInsn;
256 unsigned CurrentLastInsnIndex = 0;
257 if (const MachineInstr *CL = getLastInsn())
258 CurrentLastInsnIndex = MIIndexMap[CL];
259 unsigned FIndex = MIIndexMap[getFirstInsn()];
261 // Set LastInsn as the last instruction for this scope only if
263 // 1) this scope's first instruction and
264 // 2) current last instruction for this scope, if any.
265 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
266 setLastInsn(LastInsn);
275 void DbgScope::dump() const {
276 raw_ostream &err = dbgs();
277 err.indent(IndentLevel);
278 MDNode *N = Desc.getNode();
280 err << " [" << StartLabel << ", " << EndLabel << "]\n";
282 err << "Abstract Scope\n";
286 err << "Children ...\n";
287 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
288 if (Scopes[i] != this)
295 DbgScope::~DbgScope() {
296 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
300 } // end llvm namespace
302 DwarfDebug::DwarfDebug(AsmPrinter *A)
303 : Asm(A), MMI(Asm->MMI), ModuleCU(0),
304 AbbreviationsSet(InitAbbreviationsSetSize),
305 CurrentFnDbgScope(0), DebugTimer(0) {
306 NextStringPoolNumber = 0;
308 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
309 DwarfStrSectionSym = TextSectionSym = 0;
311 if (TimePassesIsEnabled)
312 DebugTimer = new Timer("Dwarf Debug Writer");
314 DwarfDebug::~DwarfDebug() {
315 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
316 DIEBlocks[j]->~DIEBlock();
321 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
322 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
323 if (Entry.first) return Entry.first;
325 Entry.second = NextStringPoolNumber++;
326 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
330 /// assignAbbrevNumber - Define a unique number for the abbreviation.
332 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
333 // Profile the node so that we can make it unique.
337 // Check the set for priors.
338 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
340 // If it's newly added.
341 if (InSet == &Abbrev) {
342 // Add to abbreviation list.
343 Abbreviations.push_back(&Abbrev);
345 // Assign the vector position + 1 as its number.
346 Abbrev.setNumber(Abbreviations.size());
348 // Assign existing abbreviation number.
349 Abbrev.setNumber(InSet->getNumber());
353 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
354 /// information entry.
355 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
356 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
360 /// addUInt - Add an unsigned integer attribute data and value.
362 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
363 unsigned Form, uint64_t Integer) {
364 if (!Form) Form = DIEInteger::BestForm(false, Integer);
365 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
366 Die->addValue(Attribute, Form, Value);
369 /// addSInt - Add an signed integer attribute data and value.
371 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
372 unsigned Form, int64_t Integer) {
373 if (!Form) Form = DIEInteger::BestForm(true, Integer);
374 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
375 Die->addValue(Attribute, Form, Value);
378 /// addString - Add a string attribute data and value. DIEString only
379 /// keeps string reference.
380 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
382 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
383 Die->addValue(Attribute, Form, Value);
386 /// addLabel - Add a Dwarf label attribute data and value.
388 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
389 const MCSymbol *Label) {
390 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
391 Die->addValue(Attribute, Form, Value);
394 /// addDelta - Add a label delta attribute data and value.
396 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
397 const MCSymbol *Hi, const MCSymbol *Lo) {
398 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
399 Die->addValue(Attribute, Form, Value);
402 /// addBlock - Add block data.
404 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
406 Block->ComputeSize(Asm);
407 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
408 Die->addValue(Attribute, Block->BestForm(), Block);
411 /// addSourceLine - Add location information to specified debug information
413 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
414 // If there is no compile unit specified, don't add a line #.
415 if (!V->getCompileUnit().Verify())
418 unsigned Line = V->getLineNumber();
419 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
420 V->getContext().getFilename());
421 assert(FileID && "Invalid file id");
422 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
423 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
426 /// addSourceLine - Add location information to specified debug information
428 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
429 // If there is no compile unit specified, don't add a line #.
430 if (!G->getCompileUnit().Verify())
433 unsigned Line = G->getLineNumber();
434 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
435 G->getContext().getFilename());
436 assert(FileID && "Invalid file id");
437 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
438 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
441 /// addSourceLine - Add location information to specified debug information
443 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
444 // If there is no compile unit specified, don't add a line #.
445 if (!SP->getCompileUnit().Verify())
447 // If the line number is 0, don't add it.
448 if (SP->getLineNumber() == 0)
451 unsigned Line = SP->getLineNumber();
452 if (!SP->getContext().Verify())
454 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
456 assert(FileID && "Invalid file id");
457 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
458 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
461 /// addSourceLine - Add location information to specified debug information
463 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
464 // If there is no compile unit specified, don't add a line #.
465 DICompileUnit CU = Ty->getCompileUnit();
469 unsigned Line = Ty->getLineNumber();
470 if (!Ty->getContext().Verify())
472 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
473 Ty->getContext().getFilename());
474 assert(FileID && "Invalid file id");
475 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
476 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
479 /// addSourceLine - Add location information to specified debug information
481 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
482 // If there is no compile unit specified, don't add a line #.
483 if (!NS->getCompileUnit().Verify())
486 unsigned Line = NS->getLineNumber();
487 StringRef FN = NS->getFilename();
488 StringRef Dir = NS->getDirectory();
490 unsigned FileID = GetOrCreateSourceID(Dir, FN);
491 assert(FileID && "Invalid file id");
492 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
493 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
496 /* Byref variables, in Blocks, are declared by the programmer as
497 "SomeType VarName;", but the compiler creates a
498 __Block_byref_x_VarName struct, and gives the variable VarName
499 either the struct, or a pointer to the struct, as its type. This
500 is necessary for various behind-the-scenes things the compiler
501 needs to do with by-reference variables in blocks.
503 However, as far as the original *programmer* is concerned, the
504 variable should still have type 'SomeType', as originally declared.
506 The following function dives into the __Block_byref_x_VarName
507 struct to find the original type of the variable. This will be
508 passed back to the code generating the type for the Debug
509 Information Entry for the variable 'VarName'. 'VarName' will then
510 have the original type 'SomeType' in its debug information.
512 The original type 'SomeType' will be the type of the field named
513 'VarName' inside the __Block_byref_x_VarName struct.
515 NOTE: In order for this to not completely fail on the debugger
516 side, the Debug Information Entry for the variable VarName needs to
517 have a DW_AT_location that tells the debugger how to unwind through
518 the pointers and __Block_byref_x_VarName struct to find the actual
519 value of the variable. The function addBlockByrefType does this. */
521 /// Find the type the programmer originally declared the variable to be
522 /// and return that type.
524 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
527 unsigned tag = Ty.getTag();
529 if (tag == dwarf::DW_TAG_pointer_type) {
530 DIDerivedType DTy = DIDerivedType(Ty.getNode());
531 subType = DTy.getTypeDerivedFrom();
534 DICompositeType blockStruct = DICompositeType(subType.getNode());
535 DIArray Elements = blockStruct.getTypeArray();
537 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
538 DIDescriptor Element = Elements.getElement(i);
539 DIDerivedType DT = DIDerivedType(Element.getNode());
540 if (Name == DT.getName())
541 return (DT.getTypeDerivedFrom());
547 /// addComplexAddress - Start with the address based on the location provided,
548 /// and generate the DWARF information necessary to find the actual variable
549 /// given the extra address information encoded in the DIVariable, starting from
550 /// the starting location. Add the DWARF information to the die.
552 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
554 const MachineLocation &Location) {
555 const DIVariable &VD = DV->getVariable();
556 DIType Ty = VD.getType();
558 // Decode the original location, and use that as the start of the byref
559 // variable's location.
560 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
561 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
562 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
564 if (Location.isReg()) {
566 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
568 Reg = Reg - dwarf::DW_OP_reg0;
569 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
570 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
574 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
576 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
577 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
580 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
583 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
584 uint64_t Element = VD.getAddrElement(i);
586 if (Element == DIFactory::OpPlus) {
587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
588 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
589 } else if (Element == DIFactory::OpDeref) {
590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
591 } else llvm_unreachable("unknown DIFactory Opcode");
594 // Now attach the location information to the DIE.
595 addBlock(Die, Attribute, 0, Block);
598 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
599 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
600 gives the variable VarName either the struct, or a pointer to the struct, as
601 its type. This is necessary for various behind-the-scenes things the
602 compiler needs to do with by-reference variables in Blocks.
604 However, as far as the original *programmer* is concerned, the variable
605 should still have type 'SomeType', as originally declared.
607 The function getBlockByrefType dives into the __Block_byref_x_VarName
608 struct to find the original type of the variable, which is then assigned to
609 the variable's Debug Information Entry as its real type. So far, so good.
610 However now the debugger will expect the variable VarName to have the type
611 SomeType. So we need the location attribute for the variable to be an
612 expression that explains to the debugger how to navigate through the
613 pointers and struct to find the actual variable of type SomeType.
615 The following function does just that. We start by getting
616 the "normal" location for the variable. This will be the location
617 of either the struct __Block_byref_x_VarName or the pointer to the
618 struct __Block_byref_x_VarName.
620 The struct will look something like:
622 struct __Block_byref_x_VarName {
624 struct __Block_byref_x_VarName *forwarding;
625 ... <various other fields>
627 ... <maybe more fields>
630 If we are given the struct directly (as our starting point) we
631 need to tell the debugger to:
633 1). Add the offset of the forwarding field.
635 2). Follow that pointer to get the real __Block_byref_x_VarName
636 struct to use (the real one may have been copied onto the heap).
638 3). Add the offset for the field VarName, to find the actual variable.
640 If we started with a pointer to the struct, then we need to
641 dereference that pointer first, before the other steps.
642 Translating this into DWARF ops, we will need to append the following
643 to the current location description for the variable:
645 DW_OP_deref -- optional, if we start with a pointer
646 DW_OP_plus_uconst <forward_fld_offset>
648 DW_OP_plus_uconst <varName_fld_offset>
650 That is what this function does. */
652 /// addBlockByrefAddress - Start with the address based on the location
653 /// provided, and generate the DWARF information necessary to find the
654 /// actual Block variable (navigating the Block struct) based on the
655 /// starting location. Add the DWARF information to the die. For
656 /// more information, read large comment just above here.
658 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
660 const MachineLocation &Location) {
661 const DIVariable &VD = DV->getVariable();
662 DIType Ty = VD.getType();
664 unsigned Tag = Ty.getTag();
665 bool isPointer = false;
667 StringRef varName = VD.getName();
669 if (Tag == dwarf::DW_TAG_pointer_type) {
670 DIDerivedType DTy = DIDerivedType(Ty.getNode());
671 TmpTy = DTy.getTypeDerivedFrom();
675 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
677 // Find the __forwarding field and the variable field in the __Block_byref
679 DIArray Fields = blockStruct.getTypeArray();
680 DIDescriptor varField = DIDescriptor();
681 DIDescriptor forwardingField = DIDescriptor();
683 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
684 DIDescriptor Element = Fields.getElement(i);
685 DIDerivedType DT = DIDerivedType(Element.getNode());
686 StringRef fieldName = DT.getName();
687 if (fieldName == "__forwarding")
688 forwardingField = Element;
689 else if (fieldName == varName)
693 // Get the offsets for the forwarding field and the variable field.
694 unsigned forwardingFieldOffset =
695 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
696 unsigned varFieldOffset =
697 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
699 // Decode the original location, and use that as the start of the byref
700 // variable's location.
701 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
702 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
703 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
705 if (Location.isReg()) {
707 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
709 Reg = Reg - dwarf::DW_OP_reg0;
710 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
711 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
715 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
717 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
718 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
721 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
724 // If we started with a pointer to the __Block_byref... struct, then
725 // the first thing we need to do is dereference the pointer (DW_OP_deref).
727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
729 // Next add the offset for the '__forwarding' field:
730 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
731 // adding the offset if it's 0.
732 if (forwardingFieldOffset > 0) {
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
737 // Now dereference the __forwarding field to get to the real __Block_byref
738 // struct: DW_OP_deref.
739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
741 // Now that we've got the real __Block_byref... struct, add the offset
742 // for the variable's field to get to the location of the actual variable:
743 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
744 if (varFieldOffset > 0) {
745 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
746 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
749 // Now attach the location information to the DIE.
750 addBlock(Die, Attribute, 0, Block);
753 /// addAddress - Add an address attribute to a die based on the location
755 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
756 const MachineLocation &Location) {
757 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
758 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
759 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
761 if (Location.isReg()) {
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
766 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
773 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
776 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
779 addBlock(Die, Attribute, 0, Block);
782 /// addToContextOwner - Add Die into the list of its context owner's children.
783 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
784 if (Context.isType()) {
785 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
786 ContextDIE->addChild(Die);
787 } else if (Context.isNameSpace()) {
788 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
789 ContextDIE->addChild(Die);
790 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
791 ContextDIE->addChild(Die);
793 ModuleCU->addDie(Die);
796 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
798 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
799 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
804 TyDIE = new DIE(dwarf::DW_TAG_base_type);
805 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
806 if (Ty.isBasicType())
807 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
808 else if (Ty.isCompositeType())
809 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
811 assert(Ty.isDerivedType() && "Unknown kind of DIType");
812 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
815 addToContextOwner(TyDIE, Ty.getContext());
819 /// addType - Add a new type attribute to the specified entity.
820 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
824 // Check for pre-existence.
825 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
826 // If it exists then use the existing value.
828 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
833 DIE *Buffer = getOrCreateTypeDIE(Ty);
836 Entry = createDIEEntry(Buffer);
837 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
839 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
842 /// constructTypeDIE - Construct basic type die from DIBasicType.
843 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
844 // Get core information.
845 StringRef Name = BTy.getName();
846 Buffer.setTag(dwarf::DW_TAG_base_type);
847 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
850 // Add name if not anonymous or intermediate type.
852 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
853 uint64_t Size = BTy.getSizeInBits() >> 3;
854 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
857 /// constructTypeDIE - Construct derived type die from DIDerivedType.
858 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
859 // Get core information.
860 StringRef Name = DTy.getName();
861 uint64_t Size = DTy.getSizeInBits() >> 3;
862 unsigned Tag = DTy.getTag();
864 // FIXME - Workaround for templates.
865 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
869 // Map to main type, void will not have a type.
870 DIType FromTy = DTy.getTypeDerivedFrom();
871 addType(&Buffer, FromTy);
873 // Add name if not anonymous or intermediate type.
875 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
877 // Add size if non-zero (derived types might be zero-sized.)
879 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
881 // Add source line info if available and TyDesc is not a forward declaration.
882 if (!DTy.isForwardDecl())
883 addSourceLine(&Buffer, &DTy);
886 /// constructTypeDIE - Construct type DIE from DICompositeType.
887 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
888 // Get core information.
889 StringRef Name = CTy.getName();
891 uint64_t Size = CTy.getSizeInBits() >> 3;
892 unsigned Tag = CTy.getTag();
896 case dwarf::DW_TAG_vector_type:
897 case dwarf::DW_TAG_array_type:
898 constructArrayTypeDIE(Buffer, &CTy);
900 case dwarf::DW_TAG_enumeration_type: {
901 DIArray Elements = CTy.getTypeArray();
903 // Add enumerators to enumeration type.
904 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
906 DIDescriptor Enum(Elements.getElement(i).getNode());
907 if (Enum.isEnumerator()) {
908 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
909 Buffer.addChild(ElemDie);
914 case dwarf::DW_TAG_subroutine_type: {
916 DIArray Elements = CTy.getTypeArray();
917 DIDescriptor RTy = Elements.getElement(0);
918 addType(&Buffer, DIType(RTy.getNode()));
920 // Add prototype flag.
921 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
924 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
925 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
926 DIDescriptor Ty = Elements.getElement(i);
927 addType(Arg, DIType(Ty.getNode()));
928 Buffer.addChild(Arg);
932 case dwarf::DW_TAG_structure_type:
933 case dwarf::DW_TAG_union_type:
934 case dwarf::DW_TAG_class_type: {
935 // Add elements to structure type.
936 DIArray Elements = CTy.getTypeArray();
938 // A forward struct declared type may not have elements available.
939 unsigned N = Elements.getNumElements();
943 // Add elements to structure type.
944 for (unsigned i = 0; i < N; ++i) {
945 DIDescriptor Element = Elements.getElement(i);
947 if (Element.isSubprogram())
948 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
949 else if (Element.isVariable()) {
950 DIVariable DV(Element.getNode());
951 ElemDie = new DIE(dwarf::DW_TAG_variable);
952 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
954 addType(ElemDie, DV.getType());
955 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
956 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
957 addSourceLine(ElemDie, &DV);
958 } else if (Element.isDerivedType())
959 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
962 Buffer.addChild(ElemDie);
965 if (CTy.isAppleBlockExtension())
966 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
968 unsigned RLang = CTy.getRunTimeLang();
970 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
971 dwarf::DW_FORM_data1, RLang);
973 DICompositeType ContainingType = CTy.getContainingType();
974 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
975 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
976 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
983 // Add name if not anonymous or intermediate type.
985 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
987 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
988 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
989 // Add size if non-zero (derived types might be zero-sized.)
991 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
993 // Add zero size if it is not a forward declaration.
994 if (CTy.isForwardDecl())
995 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
997 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1000 // Add source line info if available.
1001 if (!CTy.isForwardDecl())
1002 addSourceLine(&Buffer, &CTy);
1006 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1007 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1008 int64_t L = SR.getLo();
1009 int64_t H = SR.getHi();
1010 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1012 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1014 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1015 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1017 Buffer.addChild(DW_Subrange);
1020 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1021 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1022 DICompositeType *CTy) {
1023 Buffer.setTag(dwarf::DW_TAG_array_type);
1024 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1025 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1027 // Emit derived type.
1028 addType(&Buffer, CTy->getTypeDerivedFrom());
1029 DIArray Elements = CTy->getTypeArray();
1031 // Get an anonymous type for index type.
1032 DIE *IdxTy = ModuleCU->getIndexTyDie();
1034 // Construct an anonymous type for index type.
1035 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1036 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1037 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1038 dwarf::DW_ATE_signed);
1039 ModuleCU->addDie(IdxTy);
1040 ModuleCU->setIndexTyDie(IdxTy);
1043 // Add subranges to array type.
1044 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1045 DIDescriptor Element = Elements.getElement(i);
1046 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1047 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1051 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1052 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1053 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1054 StringRef Name = ETy.getName();
1055 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1056 int64_t Value = ETy.getEnumValue();
1057 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1061 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1062 /// printer to not emit usual symbol prefix before the symbol name is used then
1063 /// return linkage name after skipping this special LLVM prefix.
1064 static StringRef getRealLinkageName(StringRef LinkageName) {
1066 if (LinkageName.startswith(StringRef(&One, 1)))
1067 return LinkageName.substr(1);
1071 /// createGlobalVariableDIE - Create new DIE using GV.
1072 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1073 // If the global variable was optmized out then no need to create debug info
1075 if (!GV.getGlobal()) return NULL;
1076 if (GV.getDisplayName().empty()) return NULL;
1078 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1079 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1080 GV.getDisplayName());
1082 StringRef LinkageName = GV.getLinkageName();
1083 if (!LinkageName.empty())
1084 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1085 getRealLinkageName(LinkageName));
1087 addType(GVDie, GV.getType());
1088 if (!GV.isLocalToUnit())
1089 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1090 addSourceLine(GVDie, &GV);
1095 /// createMemberDIE - Create new member DIE.
1096 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1097 DIE *MemberDie = new DIE(DT.getTag());
1098 StringRef Name = DT.getName();
1100 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1102 addType(MemberDie, DT.getTypeDerivedFrom());
1104 addSourceLine(MemberDie, &DT);
1106 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1107 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1109 uint64_t Size = DT.getSizeInBits();
1110 uint64_t FieldSize = DT.getOriginalTypeSize();
1112 if (Size != FieldSize) {
1114 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1115 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1117 uint64_t Offset = DT.getOffsetInBits();
1118 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1119 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1120 uint64_t FieldOffset = (HiMark - FieldSize);
1121 Offset -= FieldOffset;
1123 // Maybe we need to work from the other end.
1124 if (Asm->getTargetData().isLittleEndian())
1125 Offset = FieldSize - (Offset + Size);
1126 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1128 // Here WD_AT_data_member_location points to the anonymous
1129 // field that includes this bit field.
1130 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1133 // This is not a bitfield.
1134 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1136 if (DT.getTag() == dwarf::DW_TAG_inheritance
1137 && DT.isVirtual()) {
1139 // For C++, virtual base classes are not at fixed offset. Use following
1140 // expression to extract appropriate offset from vtable.
1141 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1143 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1144 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1145 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1146 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1147 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1148 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1149 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1150 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1152 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1155 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1157 if (DT.isProtected())
1158 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1159 dwarf::DW_ACCESS_protected);
1160 else if (DT.isPrivate())
1161 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1162 dwarf::DW_ACCESS_private);
1163 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1164 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1165 dwarf::DW_ACCESS_public);
1167 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1168 dwarf::DW_VIRTUALITY_virtual);
1172 /// createSubprogramDIE - Create new DIE using SP.
1173 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1174 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1178 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1179 // Constructors and operators for anonymous aggregates do not have names.
1180 if (!SP.getName().empty())
1181 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1183 StringRef LinkageName = SP.getLinkageName();
1184 if (!LinkageName.empty())
1185 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1186 getRealLinkageName(LinkageName));
1188 addSourceLine(SPDie, &SP);
1190 // Add prototyped tag, if C or ObjC.
1191 unsigned Lang = SP.getCompileUnit().getLanguage();
1192 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1193 Lang == dwarf::DW_LANG_ObjC)
1194 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1197 DICompositeType SPTy = SP.getType();
1198 DIArray Args = SPTy.getTypeArray();
1199 unsigned SPTag = SPTy.getTag();
1201 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1202 addType(SPDie, SPTy);
1204 addType(SPDie, DIType(Args.getElement(0).getNode()));
1206 unsigned VK = SP.getVirtuality();
1208 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1209 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1210 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1211 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1212 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1213 ContainingTypeMap.insert(std::make_pair(SPDie,
1214 SP.getContainingType().getNode()));
1217 if (MakeDecl || !SP.isDefinition()) {
1218 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1220 // Add arguments. Do not add arguments for subprogram definition. They will
1221 // be handled while processing variables.
1222 DICompositeType SPTy = SP.getType();
1223 DIArray Args = SPTy.getTypeArray();
1224 unsigned SPTag = SPTy.getTag();
1226 if (SPTag == dwarf::DW_TAG_subroutine_type)
1227 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1228 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1229 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1231 if (ATy.isArtificial())
1232 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1233 SPDie->addChild(Arg);
1237 if (SP.isArtificial())
1238 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1240 // DW_TAG_inlined_subroutine may refer to this DIE.
1241 ModuleCU->insertDIE(SP.getNode(), SPDie);
1245 /// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1246 /// Update scope hierarchy. Create abstract scope if required.
1247 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1248 MDNode *InlinedAt) {
1249 assert(N && "Invalid Scope encoding!");
1250 assert(MI && "Missing machine instruction!");
1251 bool isAConcreteScope = InlinedAt != 0;
1253 DbgScope *NScope = NULL;
1256 NScope = DbgScopeMap.lookup(InlinedAt);
1258 NScope = DbgScopeMap.lookup(N);
1259 assert(NScope && "Unable to find working scope!");
1261 if (NScope->getFirstInsn())
1264 DbgScope *Parent = NULL;
1265 if (isAConcreteScope) {
1266 DILocation IL(InlinedAt);
1267 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1268 IL.getOrigLocation().getNode());
1269 assert(Parent && "Unable to find Parent scope!");
1270 NScope->setParent(Parent);
1271 Parent->addScope(NScope);
1272 } else if (DIDescriptor(N).isLexicalBlock()) {
1273 DILexicalBlock DB(N);
1274 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1275 NScope->setParent(Parent);
1276 Parent->addScope(NScope);
1279 NScope->setFirstInsn(MI);
1281 if (!Parent && !InlinedAt) {
1282 StringRef SPName = DISubprogram(N).getLinkageName();
1283 if (SPName == Asm->MF->getFunction()->getName())
1284 CurrentFnDbgScope = NScope;
1287 if (isAConcreteScope) {
1288 ConcreteScopes[InlinedAt] = NScope;
1289 getOrCreateAbstractScope(N);
1295 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1296 assert(N && "Invalid Scope encoding!");
1298 DbgScope *AScope = AbstractScopes.lookup(N);
1302 DbgScope *Parent = NULL;
1304 DIDescriptor Scope(N);
1305 if (Scope.isLexicalBlock()) {
1306 DILexicalBlock DB(N);
1307 DIDescriptor ParentDesc = DB.getContext();
1308 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1311 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1314 Parent->addScope(AScope);
1315 AScope->setAbstractScope();
1316 AbstractScopes[N] = AScope;
1317 if (DIDescriptor(N).isSubprogram())
1318 AbstractScopesList.push_back(AScope);
1322 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1323 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1324 /// If there are global variables in this scope then create and insert
1325 /// DIEs for these variables.
1326 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1327 DIE *SPDie = ModuleCU->getDIE(SPNode);
1328 assert(SPDie && "Unable to find subprogram DIE!");
1329 DISubprogram SP(SPNode);
1331 // There is not any need to generate specification DIE for a function
1332 // defined at compile unit level. If a function is defined inside another
1333 // function then gdb prefers the definition at top level and but does not
1334 // expect specification DIE in parent function. So avoid creating
1335 // specification DIE for a function defined inside a function.
1336 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1337 !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1338 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1341 DICompositeType SPTy = SP.getType();
1342 DIArray Args = SPTy.getTypeArray();
1343 unsigned SPTag = SPTy.getTag();
1344 if (SPTag == dwarf::DW_TAG_subroutine_type)
1345 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1346 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1347 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1349 if (ATy.isArtificial())
1350 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1351 SPDie->addChild(Arg);
1353 DIE *SPDeclDie = SPDie;
1354 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1355 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1357 ModuleCU->addDie(SPDie);
1360 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1361 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1362 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1363 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1364 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1365 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1366 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1368 if (!DISubprogram(SPNode).isLocalToUnit())
1369 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1374 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1375 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1376 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1377 MCSymbol *Start = Scope->getStartLabel();
1378 MCSymbol *End = Scope->getEndLabel();
1379 if (Start == 0 || End == 0) return 0;
1381 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1382 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1384 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1385 if (Scope->isAbstractScope())
1388 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1389 Start ? Start : Asm->GetTempSymbol("func_begin",
1390 Asm->getFunctionNumber()));
1391 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1392 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1397 /// constructInlinedScopeDIE - This scope represents inlined body of
1398 /// a function. Construct DIE to represent this concrete inlined copy
1399 /// of the function.
1400 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1401 MCSymbol *StartLabel = Scope->getStartLabel();
1402 MCSymbol *EndLabel = Scope->getEndLabel();
1403 if (StartLabel == 0 || EndLabel == 0) return 0;
1405 assert(StartLabel->isDefined() &&
1406 "Invalid starting label for an inlined scope!");
1407 assert(EndLabel->isDefined() &&
1408 "Invalid end label for an inlined scope!");
1409 if (!Scope->getScopeNode())
1411 DIScope DS(Scope->getScopeNode());
1412 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1414 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1415 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1416 assert(OriginDIE && "Unable to find Origin DIE!");
1417 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1418 dwarf::DW_FORM_ref4, OriginDIE);
1420 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1421 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1423 InlinedSubprogramDIEs.insert(OriginDIE);
1425 // Track the start label for this inlined function.
1426 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1427 I = InlineInfo.find(InlinedSP.getNode());
1429 if (I == InlineInfo.end()) {
1430 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1432 InlinedSPNodes.push_back(InlinedSP.getNode());
1434 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1436 DILocation DL(Scope->getInlinedAt());
1437 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1438 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1444 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1445 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1446 // Get the descriptor.
1447 const DIVariable &VD = DV->getVariable();
1448 StringRef Name = VD.getName();
1452 // Translate tag to proper Dwarf tag. The result variable is dropped for
1455 switch (VD.getTag()) {
1456 case dwarf::DW_TAG_return_variable:
1458 case dwarf::DW_TAG_arg_variable:
1459 Tag = dwarf::DW_TAG_formal_parameter;
1461 case dwarf::DW_TAG_auto_variable: // fall thru
1463 Tag = dwarf::DW_TAG_variable;
1467 // Define variable debug information entry.
1468 DIE *VariableDie = new DIE(Tag);
1472 if (DbgVariable *AV = DV->getAbstractVariable())
1473 AbsDIE = AV->getDIE();
1476 DIScope DS(Scope->getScopeNode());
1477 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1478 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1480 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1481 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1482 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1483 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1484 dwarf::DW_FORM_ref4, AbsDIE);
1487 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1488 addSourceLine(VariableDie, &VD);
1490 // Add variable type.
1491 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1492 // addresses instead.
1493 if (VD.isBlockByrefVariable())
1494 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1496 addType(VariableDie, VD.getType());
1499 // Add variable address.
1500 if (!Scope->isAbstractScope()) {
1501 // Check if variable is described by DBG_VALUE instruction.
1502 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1503 if (DbgValueInsn->getNumOperands() == 3) {
1504 // FIXME : Handle getNumOperands != 3
1505 if (DbgValueInsn->getOperand(0).getType()
1506 == MachineOperand::MO_Register
1507 && DbgValueInsn->getOperand(0).getReg()) {
1508 MachineLocation Location;
1509 Location.set(DbgValueInsn->getOperand(0).getReg());
1510 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1511 if (MCSymbol *VS = DV->getDbgValueLabel())
1512 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1514 } else if (DbgValueInsn->getOperand(0).getType() ==
1515 MachineOperand::MO_Immediate) {
1516 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1517 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1518 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1519 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1520 if (MCSymbol *VS = DV->getDbgValueLabel())
1521 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1524 //FIXME : Handle other operand types.
1530 MachineLocation Location;
1532 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1533 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1535 Location.set(FrameReg, Offset);
1537 if (VD.hasComplexAddress())
1538 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1539 else if (VD.isBlockByrefVariable())
1540 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1542 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1546 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1547 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1548 DV->setDIE(VariableDie);
1553 void DwarfDebug::addPubTypes(DISubprogram SP) {
1554 DICompositeType SPTy = SP.getType();
1555 unsigned SPTag = SPTy.getTag();
1556 if (SPTag != dwarf::DW_TAG_subroutine_type)
1559 DIArray Args = SPTy.getTypeArray();
1560 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1561 DIType ATy(Args.getElement(i).getNode());
1564 DICompositeType CATy = getDICompositeType(ATy);
1565 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1566 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1567 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1572 /// constructScopeDIE - Construct a DIE for this scope.
1573 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1574 if (!Scope || !Scope->getScopeNode())
1577 DIScope DS(Scope->getScopeNode());
1578 DIE *ScopeDIE = NULL;
1579 if (Scope->getInlinedAt())
1580 ScopeDIE = constructInlinedScopeDIE(Scope);
1581 else if (DS.isSubprogram()) {
1582 if (Scope->isAbstractScope())
1583 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1585 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1588 ScopeDIE = constructLexicalScopeDIE(Scope);
1589 if (!ScopeDIE) return NULL;
1591 // Add variables to scope.
1592 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1593 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1594 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1596 ScopeDIE->addChild(VariableDIE);
1599 // Add nested scopes.
1600 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1601 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1602 // Define the Scope debug information entry.
1603 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1605 ScopeDIE->addChild(NestedDIE);
1608 if (DS.isSubprogram())
1609 addPubTypes(DISubprogram(DS.getNode()));
1614 /// GetOrCreateSourceID - Look up the source id with the given directory and
1615 /// source file names. If none currently exists, create a new id and insert it
1616 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1618 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1620 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1621 if (DI != DirectoryIdMap.end()) {
1622 DId = DI->getValue();
1624 DId = DirectoryNames.size() + 1;
1625 DirectoryIdMap[DirName] = DId;
1626 DirectoryNames.push_back(DirName);
1630 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1631 if (FI != SourceFileIdMap.end()) {
1632 FId = FI->getValue();
1634 FId = SourceFileNames.size() + 1;
1635 SourceFileIdMap[FileName] = FId;
1636 SourceFileNames.push_back(FileName);
1639 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1640 SourceIdMap.find(std::make_pair(DId, FId));
1641 if (SI != SourceIdMap.end())
1644 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1645 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1646 SourceIds.push_back(std::make_pair(DId, FId));
1651 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1652 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1653 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1656 NDie = new DIE(dwarf::DW_TAG_namespace);
1657 ModuleCU->insertDIE(NS.getNode(), NDie);
1658 if (!NS.getName().empty())
1659 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1660 addSourceLine(NDie, &NS);
1661 addToContextOwner(NDie, NS.getContext());
1665 void DwarfDebug::constructCompileUnit(MDNode *N) {
1666 DICompileUnit DIUnit(N);
1667 // Use first compile unit marked as isMain as the compile unit for this
1669 if (ModuleCU || !DIUnit.isMain())
1671 StringRef FN = DIUnit.getFilename();
1672 StringRef Dir = DIUnit.getDirectory();
1673 unsigned ID = GetOrCreateSourceID(Dir, FN);
1675 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1676 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1677 DIUnit.getProducer());
1678 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1679 DIUnit.getLanguage());
1680 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1681 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1682 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1683 Asm->GetTempSymbol("text_end"));
1684 // DW_AT_stmt_list is a offset of line number information for this
1685 // compile unit in debug_line section. It is always zero when only one
1686 // compile unit is emitted in one object file.
1687 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1690 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1691 if (DIUnit.isOptimized())
1692 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1694 StringRef Flags = DIUnit.getFlags();
1696 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1698 unsigned RVer = DIUnit.getRunTimeVersion();
1700 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1701 dwarf::DW_FORM_data1, RVer);
1704 "ModuleCU assigned since the top of constructCompileUnit");
1705 ModuleCU = new CompileUnit(ID, Die);
1708 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1709 DIGlobalVariable DI_GV(N);
1711 // If debug information is malformed then ignore it.
1712 if (DI_GV.Verify() == false)
1715 // Check for pre-existence.
1716 if (ModuleCU->getDIE(DI_GV.getNode()))
1719 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1724 ModuleCU->insertDIE(N, VariableDie);
1726 // Add to context owner.
1727 DIDescriptor GVContext = DI_GV.getContext();
1728 // Do not create specification DIE if context is either compile unit
1730 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1731 !GVContext.isFile() && !GVContext.isSubprogram()) {
1732 // Create specification DIE.
1733 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1734 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1735 dwarf::DW_FORM_ref4, VariableDie);
1736 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1737 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1738 addLabel(Block, 0, dwarf::DW_FORM_udata,
1739 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1740 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1741 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1742 ModuleCU->addDie(VariableSpecDIE);
1744 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1745 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1746 addLabel(Block, 0, dwarf::DW_FORM_udata,
1747 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1748 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1750 addToContextOwner(VariableDie, GVContext);
1752 // Expose as global. FIXME - need to check external flag.
1753 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1755 DIType GTy = DI_GV.getType();
1756 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1757 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1758 assert(Entry && "Missing global type!");
1759 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1764 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1767 // Check for pre-existence.
1768 if (ModuleCU->getDIE(N))
1771 if (!SP.isDefinition())
1772 // This is a method declaration which will be handled while constructing
1776 DIE *SubprogramDie = createSubprogramDIE(SP);
1779 ModuleCU->insertDIE(N, SubprogramDie);
1781 // Add to context owner.
1782 addToContextOwner(SubprogramDie, SP.getContext());
1784 // Expose as global.
1785 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1790 /// beginModule - Emit all Dwarf sections that should come prior to the
1791 /// content. Create global DIEs and emit initial debug info sections.
1792 /// This is inovked by the target AsmPrinter.
1793 void DwarfDebug::beginModule(Module *M) {
1794 if (!Asm->MAI->doesSupportDebugInformation())
1799 TimeRegion Timer(DebugTimer);
1801 DebugInfoFinder DbgFinder;
1802 DbgFinder.processModule(*M);
1804 bool HasDebugInfo = false;
1806 // Scan all the compile-units to see if there are any marked as the main unit.
1807 // if not, we do not generate debug info.
1808 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1809 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1810 if (DICompileUnit(*I).isMain()) {
1811 HasDebugInfo = true;
1816 if (!HasDebugInfo) return;
1818 // Tell MMI that we have debug info.
1819 MMI->setDebugInfoAvailability(true);
1821 // Emit initial sections.
1822 EmitSectionLabels();
1824 // Create all the compile unit DIEs.
1825 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1826 E = DbgFinder.compile_unit_end(); I != E; ++I)
1827 constructCompileUnit(*I);
1829 // Create DIEs for each subprogram.
1830 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1831 E = DbgFinder.subprogram_end(); I != E; ++I)
1832 constructSubprogramDIE(*I);
1834 // Create DIEs for each global variable.
1835 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1836 E = DbgFinder.global_variable_end(); I != E; ++I)
1837 constructGlobalVariableDIE(*I);
1839 // Prime section data.
1840 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1842 // Print out .file directives to specify files for .loc directives. These are
1843 // printed out early so that they precede any .loc directives.
1844 if (Asm->MAI->hasDotLocAndDotFile()) {
1845 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1846 // Remember source id starts at 1.
1847 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1848 // FIXME: don't use sys::path for this! This should not depend on the
1850 sys::Path FullPath(getSourceDirectoryName(Id.first));
1852 FullPath.appendComponent(getSourceFileName(Id.second));
1853 assert(AppendOk && "Could not append filename to directory!");
1855 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1860 /// endModule - Emit all Dwarf sections that should come after the content.
1862 void DwarfDebug::endModule() {
1866 TimeRegion Timer(DebugTimer);
1868 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1869 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1870 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1872 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1875 // Insert top level DIEs.
1876 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1877 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1878 ModuleCU->getCUDie()->addChild(*TI);
1880 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1881 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1882 DIE *SPDie = CI->first;
1883 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1885 DIE *NDie = ModuleCU->getDIE(N);
1886 if (!NDie) continue;
1887 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1888 // FIXME - This is not the correct approach.
1889 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
1892 // Standard sections final addresses.
1893 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1894 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1895 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1896 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1898 // End text sections.
1899 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1900 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1901 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1904 // Emit common frame information.
1905 emitCommonDebugFrame();
1907 // Emit function debug frame information
1908 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1909 E = DebugFrames.end(); I != E; ++I)
1910 emitFunctionDebugFrame(*I);
1912 // Compute DIE offsets and sizes.
1913 computeSizeAndOffsets();
1915 // Emit all the DIEs into a debug info section
1918 // Corresponding abbreviations into a abbrev section.
1919 emitAbbreviations();
1921 // Emit source line correspondence into a debug line section.
1924 // Emit info into a debug pubnames section.
1925 emitDebugPubNames();
1927 // Emit info into a debug pubtypes section.
1928 emitDebugPubTypes();
1930 // Emit info into a debug loc section.
1933 // Emit info into a debug aranges section.
1936 // Emit info into a debug ranges section.
1939 // Emit info into a debug macinfo section.
1942 // Emit inline info.
1943 emitDebugInlineInfo();
1945 // Emit info into a debug str section.
1949 ModuleCU = NULL; // Reset for the next Module, if any.
1952 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1953 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1955 DebugLoc ScopeLoc) {
1957 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1959 return AbsDbgVariable;
1961 LLVMContext &Ctx = Var.getNode()->getContext();
1962 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1966 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
1967 NULL /* No more-abstract variable*/);
1968 Scope->addVariable(AbsDbgVariable);
1969 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1970 return AbsDbgVariable;
1973 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1974 /// FIXME : Refactor findAbstractVariable.
1975 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1976 const MachineInstr *MI,
1977 DebugLoc ScopeLoc) {
1979 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1981 return AbsDbgVariable;
1983 LLVMContext &Ctx = Var.getNode()->getContext();
1984 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1988 AbsDbgVariable = new DbgVariable(Var, MI,
1989 NULL /* No more-abstract variable*/);
1990 Scope->addVariable(AbsDbgVariable);
1991 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1992 DbgValueStartMap[MI] = AbsDbgVariable;
1993 return AbsDbgVariable;
1996 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1997 void DwarfDebug::collectVariableInfo() {
2000 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2002 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2003 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2004 VE = VMap.end(); VI != VE; ++VI) {
2005 MDNode *Var = VI->first;
2008 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2010 DbgScope *Scope = 0;
2011 if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2012 Scope = ConcreteScopes.lookup(IA);
2014 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2016 // If variable scope is not found then skip this variable.
2020 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2021 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2022 Scope->addVariable(RegVar);
2025 // Collect variable information from DBG_VALUE machine instructions;
2026 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2028 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2030 const MachineInstr *MInsn = II;
2031 if (!MInsn->isDebugValue())
2034 // FIXME : Lift this restriction.
2035 if (MInsn->getNumOperands() != 3)
2037 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2038 - 1).getMetadata()));
2039 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2040 // FIXME Handle inlined subroutine arguments.
2041 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2042 CurrentFnDbgScope->addVariable(ArgVar);
2043 DbgValueStartMap[MInsn] = ArgVar;
2047 DebugLoc DL = MInsn->getDebugLoc();
2048 if (DL.isUnknown()) continue;
2049 DbgScope *Scope = 0;
2050 if (MDNode *IA = DL.getInlinedAt(Ctx))
2051 Scope = ConcreteScopes.lookup(IA);
2053 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2055 // If variable scope is not found then skip this variable.
2059 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2060 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2061 DbgValueStartMap[MInsn] = RegVar;
2062 Scope->addVariable(RegVar);
2067 /// beginScope - Process beginning of a scope.
2068 void DwarfDebug::beginScope(const MachineInstr *MI) {
2070 DebugLoc DL = MI->getDebugLoc();
2074 // Check and update last known location info.
2075 if (DL == PrevInstLoc)
2078 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2080 // FIXME: Should only verify each scope once!
2081 if (!DIScope(Scope).Verify())
2084 // DBG_VALUE instruction establishes new value.
2085 if (MI->isDebugValue()) {
2086 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2087 = DbgValueStartMap.find(MI);
2088 if (DI != DbgValueStartMap.end()) {
2089 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2091 DI->second->setDbgValueLabel(Label);
2096 // Emit a label to indicate location change. This is used for line
2097 // table even if this instruction does start a new scope.
2098 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2101 // update DbgScope if this instruction starts a new scope.
2102 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2103 if (I == DbgScopeBeginMap.end())
2106 ScopeVector &SD = I->second;
2107 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2109 (*SDI)->setStartLabel(Label);
2112 /// endScope - Process end of a scope.
2113 void DwarfDebug::endScope(const MachineInstr *MI) {
2114 // Ignore DBG_VALUE instruction.
2115 if (MI->isDebugValue())
2119 DebugLoc DL = MI->getDebugLoc();
2123 // Emit a label and update DbgScope if this instruction ends a scope.
2124 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2125 if (I == DbgScopeEndMap.end())
2128 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2129 Asm->OutStreamer.EmitLabel(Label);
2131 SmallVector<DbgScope*, 2> &SD = I->second;
2132 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2134 (*SDI)->setEndLabel(Label);
2138 /// createDbgScope - Create DbgScope for the scope.
2139 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2141 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2144 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2145 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2146 if (DIDescriptor(Scope).isLexicalBlock())
2147 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2151 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2155 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2156 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2157 DILocation DL(InlinedAt);
2158 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2161 /// extractScopeInformation - Scan machine instructions in this function
2162 /// and collect DbgScopes. Return true, if at least one scope was found.
2163 bool DwarfDebug::extractScopeInformation() {
2164 // If scope information was extracted using .dbg intrinsics then there is not
2165 // any need to extract these information by scanning each instruction.
2166 if (!DbgScopeMap.empty())
2169 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2170 unsigned MIIndex = 0;
2171 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2173 // Scan each instruction and create scopes. First build working set of scopes.
2174 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2176 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2178 const MachineInstr *MInsn = II;
2179 // FIXME : Remove DBG_VALUE check.
2180 if (MInsn->isDebugValue()) continue;
2181 MIIndexMap[MInsn] = MIIndex++;
2183 DebugLoc DL = MInsn->getDebugLoc();
2184 if (DL.isUnknown()) continue;
2186 MDNode *Scope = DL.getScope(Ctx);
2188 // There is no need to create another DIE for compile unit. For all
2189 // other scopes, create one DbgScope now. This will be translated
2190 // into a scope DIE at the end.
2191 if (DIScope(Scope).isCompileUnit()) continue;
2192 createDbgScope(Scope, DL.getInlinedAt(Ctx));
2197 // Build scope hierarchy using working set of scopes.
2198 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2200 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2202 const MachineInstr *MInsn = II;
2203 // FIXME : Remove DBG_VALUE check.
2204 if (MInsn->isDebugValue()) continue;
2205 DebugLoc DL = MInsn->getDebugLoc();
2206 if (DL.isUnknown()) continue;
2208 MDNode *Scope = DL.getScope(Ctx);
2209 if (Scope == 0) continue;
2211 // There is no need to create another DIE for compile unit. For all
2212 // other scopes, create one DbgScope now. This will be translated
2213 // into a scope DIE at the end.
2214 if (DIScope(Scope).isCompileUnit()) continue;
2215 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2216 DScope->setLastInsn(MInsn);
2220 if (!CurrentFnDbgScope)
2223 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2225 // Each scope has first instruction and last instruction to mark beginning
2226 // and end of a scope respectively. Create an inverse map that list scopes
2227 // starts (and ends) with an instruction. One instruction may start (or end)
2228 // multiple scopes. Ignore scopes that are not reachable.
2229 SmallVector<DbgScope *, 4> WorkList;
2230 WorkList.push_back(CurrentFnDbgScope);
2231 while (!WorkList.empty()) {
2232 DbgScope *S = WorkList.pop_back_val();
2234 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2235 if (!Children.empty())
2236 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2237 SE = Children.end(); SI != SE; ++SI)
2238 WorkList.push_back(*SI);
2240 if (S->isAbstractScope())
2242 const MachineInstr *MI = S->getFirstInsn();
2243 assert(MI && "DbgScope does not have first instruction!");
2245 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2246 if (IDI != DbgScopeBeginMap.end())
2247 IDI->second.push_back(S);
2249 DbgScopeBeginMap[MI].push_back(S);
2251 MI = S->getLastInsn();
2252 assert(MI && "DbgScope does not have last instruction!");
2253 IDI = DbgScopeEndMap.find(MI);
2254 if (IDI != DbgScopeEndMap.end())
2255 IDI->second.push_back(S);
2257 DbgScopeEndMap[MI].push_back(S);
2260 return !DbgScopeMap.empty();
2263 /// beginFunction - Gather pre-function debug information. Assumes being
2264 /// emitted immediately after the function entry point.
2265 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2266 if (!MMI->hasDebugInfo()) return;
2268 TimeRegion Timer(DebugTimer);
2269 if (!extractScopeInformation())
2272 collectVariableInfo();
2274 // Assumes in correct section after the entry point.
2275 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2276 Asm->getFunctionNumber()));
2278 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2280 DebugLoc FDL = MF->getDefaultDebugLoc();
2281 if (FDL.isUnknown()) return;
2283 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2285 DISubprogram SP = getDISubprogram(Scope);
2288 Line = SP.getLineNumber();
2291 Line = FDL.getLine();
2295 recordSourceLine(Line, Col, Scope);
2298 /// endFunction - Gather and emit post-function debug information.
2300 void DwarfDebug::endFunction(const MachineFunction *MF) {
2301 if (!MMI->hasDebugInfo()) return;
2302 if (DbgScopeMap.empty()) return;
2304 TimeRegion Timer(DebugTimer);
2306 if (CurrentFnDbgScope) {
2307 // Define end label for subprogram.
2308 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2309 Asm->getFunctionNumber()));
2311 // Get function line info.
2312 if (!Lines.empty()) {
2313 // Get section line info.
2314 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2315 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2316 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2317 // Append the function info to section info.
2318 SectionLineInfos.insert(SectionLineInfos.end(),
2319 Lines.begin(), Lines.end());
2322 // Construct abstract scopes.
2323 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2324 AE = AbstractScopesList.end(); AI != AE; ++AI)
2325 constructScopeDIE(*AI);
2327 constructScopeDIE(CurrentFnDbgScope);
2329 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2330 MMI->getFrameMoves()));
2334 CurrentFnDbgScope = NULL;
2335 DeleteContainerSeconds(DbgScopeMap);
2336 DbgScopeBeginMap.clear();
2337 DbgScopeEndMap.clear();
2338 DbgValueStartMap.clear();
2339 ConcreteScopes.clear();
2340 DeleteContainerSeconds(AbstractScopes);
2341 AbstractScopesList.clear();
2342 AbstractVariables.clear();
2346 /// recordSourceLine - Register a source line with debug info. Returns the
2347 /// unique label that was emitted and which provides correspondence to
2348 /// the source line list.
2349 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2353 TimeRegion Timer(DebugTimer);
2358 DIDescriptor Scope(S);
2359 if (Scope.isCompileUnit()) {
2360 DICompileUnit CU(S);
2361 Dir = CU.getDirectory();
2362 Fn = CU.getFilename();
2363 } else if (Scope.isSubprogram()) {
2365 Dir = SP.getDirectory();
2366 Fn = SP.getFilename();
2367 } else if (Scope.isLexicalBlock()) {
2368 DILexicalBlock DB(S);
2369 Dir = DB.getDirectory();
2370 Fn = DB.getFilename();
2372 assert(0 && "Unexpected scope info");
2374 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2375 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2376 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2378 Asm->OutStreamer.EmitLabel(Label);
2382 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2383 /// timed. Look up the source id with the given directory and source file
2384 /// names. If none currently exists, create a new id and insert it in the
2385 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2387 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2388 const std::string &FileName) {
2389 TimeRegion Timer(DebugTimer);
2390 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2393 //===----------------------------------------------------------------------===//
2395 //===----------------------------------------------------------------------===//
2397 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2400 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2401 // Get the children.
2402 const std::vector<DIE *> &Children = Die->getChildren();
2404 // If not last sibling and has children then add sibling offset attribute.
2405 if (!Last && !Children.empty())
2406 Die->addSiblingOffset(DIEValueAllocator);
2408 // Record the abbreviation.
2409 assignAbbrevNumber(Die->getAbbrev());
2411 // Get the abbreviation for this DIE.
2412 unsigned AbbrevNumber = Die->getAbbrevNumber();
2413 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2416 Die->setOffset(Offset);
2418 // Start the size with the size of abbreviation code.
2419 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2421 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2422 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2424 // Size the DIE attribute values.
2425 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2426 // Size attribute value.
2427 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2429 // Size the DIE children if any.
2430 if (!Children.empty()) {
2431 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2432 "Children flag not set");
2434 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2435 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2437 // End of children marker.
2438 Offset += sizeof(int8_t);
2441 Die->setSize(Offset - Die->getOffset());
2445 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2447 void DwarfDebug::computeSizeAndOffsets() {
2448 // Compute size of compile unit header.
2449 static unsigned Offset =
2450 sizeof(int32_t) + // Length of Compilation Unit Info
2451 sizeof(int16_t) + // DWARF version number
2452 sizeof(int32_t) + // Offset Into Abbrev. Section
2453 sizeof(int8_t); // Pointer Size (in bytes)
2455 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2456 CompileUnitOffsets[ModuleCU] = 0;
2459 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2460 /// temporary label to it if SymbolStem is specified.
2461 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2462 const char *SymbolStem = 0) {
2463 Asm->OutStreamer.SwitchSection(Section);
2464 if (!SymbolStem) return 0;
2466 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2467 Asm->OutStreamer.EmitLabel(TmpSym);
2471 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2472 /// the start of each one.
2473 void DwarfDebug::EmitSectionLabels() {
2474 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2476 // Dwarf sections base addresses.
2477 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2478 DwarfFrameSectionSym =
2479 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2482 DwarfInfoSectionSym =
2483 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2484 DwarfAbbrevSectionSym =
2485 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2486 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2488 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2489 EmitSectionSym(Asm, MacroInfo);
2491 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2492 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2493 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2494 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2495 DwarfStrSectionSym =
2496 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2497 EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
2499 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2500 EmitSectionSym(Asm, TLOF.getDataSection());
2503 /// emitDIE - Recusively Emits a debug information entry.
2505 void DwarfDebug::emitDIE(DIE *Die) {
2506 // Get the abbreviation for this DIE.
2507 unsigned AbbrevNumber = Die->getAbbrevNumber();
2508 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2510 // Emit the code (index) for the abbreviation.
2511 if (Asm->isVerbose())
2512 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2513 Twine::utohexstr(Die->getOffset()) + ":0x" +
2514 Twine::utohexstr(Die->getSize()) + " " +
2515 dwarf::TagString(Abbrev->getTag()));
2516 Asm->EmitULEB128(AbbrevNumber);
2518 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2519 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2521 // Emit the DIE attribute values.
2522 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2523 unsigned Attr = AbbrevData[i].getAttribute();
2524 unsigned Form = AbbrevData[i].getForm();
2525 assert(Form && "Too many attributes for DIE (check abbreviation)");
2527 if (Asm->isVerbose())
2528 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2531 case dwarf::DW_AT_sibling:
2532 Asm->EmitInt32(Die->getSiblingOffset());
2534 case dwarf::DW_AT_abstract_origin: {
2535 DIEEntry *E = cast<DIEEntry>(Values[i]);
2536 DIE *Origin = E->getEntry();
2537 unsigned Addr = Origin->getOffset();
2538 Asm->EmitInt32(Addr);
2542 // Emit an attribute using the defined form.
2543 Values[i]->EmitValue(Asm, Form);
2548 // Emit the DIE children if any.
2549 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2550 const std::vector<DIE *> &Children = Die->getChildren();
2552 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2553 emitDIE(Children[j]);
2555 if (Asm->isVerbose())
2556 Asm->OutStreamer.AddComment("End Of Children Mark");
2561 /// emitDebugInfo - Emit the debug info section.
2563 void DwarfDebug::emitDebugInfo() {
2564 // Start debug info section.
2565 Asm->OutStreamer.SwitchSection(
2566 Asm->getObjFileLowering().getDwarfInfoSection());
2567 DIE *Die = ModuleCU->getCUDie();
2569 // Emit the compile units header.
2570 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2571 ModuleCU->getID()));
2573 // Emit size of content not including length itself
2574 unsigned ContentSize = Die->getSize() +
2575 sizeof(int16_t) + // DWARF version number
2576 sizeof(int32_t) + // Offset Into Abbrev. Section
2577 sizeof(int8_t) + // Pointer Size (in bytes)
2578 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2580 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2581 Asm->EmitInt32(ContentSize);
2582 Asm->OutStreamer.AddComment("DWARF version number");
2583 Asm->EmitInt16(dwarf::DWARF_VERSION);
2584 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2585 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2586 DwarfAbbrevSectionSym);
2587 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2588 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2591 // FIXME - extra padding for gdb bug.
2592 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2597 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2600 /// emitAbbreviations - Emit the abbreviation section.
2602 void DwarfDebug::emitAbbreviations() const {
2603 // Check to see if it is worth the effort.
2604 if (!Abbreviations.empty()) {
2605 // Start the debug abbrev section.
2606 Asm->OutStreamer.SwitchSection(
2607 Asm->getObjFileLowering().getDwarfAbbrevSection());
2609 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2611 // For each abbrevation.
2612 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2613 // Get abbreviation data
2614 const DIEAbbrev *Abbrev = Abbreviations[i];
2616 // Emit the abbrevations code (base 1 index.)
2617 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2619 // Emit the abbreviations data.
2623 // Mark end of abbreviations.
2624 Asm->EmitULEB128(0, "EOM(3)");
2626 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2630 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2631 /// the line matrix.
2633 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2634 // Define last address of section.
2635 Asm->OutStreamer.AddComment("Extended Op");
2638 Asm->OutStreamer.AddComment("Op size");
2639 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2640 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2641 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2643 Asm->OutStreamer.AddComment("Section end label");
2645 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2646 Asm->getTargetData().getPointerSize(),
2649 // Mark end of matrix.
2650 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2656 /// emitDebugLines - Emit source line information.
2658 void DwarfDebug::emitDebugLines() {
2659 // If the target is using .loc/.file, the assembler will be emitting the
2660 // .debug_line table automatically.
2661 if (Asm->MAI->hasDotLocAndDotFile())
2664 // Minimum line delta, thus ranging from -10..(255-10).
2665 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2666 // Maximum line delta, thus ranging from -10..(255-10).
2667 const int MaxLineDelta = 255 + MinLineDelta;
2669 // Start the dwarf line section.
2670 Asm->OutStreamer.SwitchSection(
2671 Asm->getObjFileLowering().getDwarfLineSection());
2673 // Construct the section header.
2674 Asm->OutStreamer.AddComment("Length of Source Line Info");
2675 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2676 Asm->GetTempSymbol("line_begin"), 4);
2677 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2679 Asm->OutStreamer.AddComment("DWARF version number");
2680 Asm->EmitInt16(dwarf::DWARF_VERSION);
2682 Asm->OutStreamer.AddComment("Prolog Length");
2683 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2684 Asm->GetTempSymbol("line_prolog_begin"), 4);
2685 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2687 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2689 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2691 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2692 Asm->EmitInt8(MinLineDelta);
2693 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2694 Asm->EmitInt8(MaxLineDelta);
2695 Asm->OutStreamer.AddComment("Special Opcode Base");
2696 Asm->EmitInt8(-MinLineDelta);
2698 // Line number standard opcode encodings argument count
2699 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2701 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2703 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2705 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2707 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2709 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2711 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2713 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2715 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2718 // Emit directories.
2719 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2720 const std::string &Dir = getSourceDirectoryName(DI);
2721 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2722 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2725 Asm->OutStreamer.AddComment("End of directories");
2729 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2730 // Remember source id starts at 1.
2731 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2732 const std::string &FN = getSourceFileName(Id.second);
2733 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2734 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2736 Asm->EmitULEB128(Id.first, "Directory #");
2737 Asm->EmitULEB128(0, "Mod date");
2738 Asm->EmitULEB128(0, "File size");
2741 Asm->OutStreamer.AddComment("End of files");
2744 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2746 // A sequence for each text section.
2747 unsigned SecSrcLinesSize = SectionSourceLines.size();
2749 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2750 // Isolate current sections line info.
2751 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2753 // Dwarf assumes we start with first line of first source file.
2754 unsigned Source = 1;
2757 // Construct rows of the address, source, line, column matrix.
2758 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2759 const SrcLineInfo &LineInfo = LineInfos[i];
2760 MCSymbol *Label = LineInfo.getLabel();
2761 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2763 if (LineInfo.getLine() == 0) continue;
2765 if (Asm->isVerbose()) {
2766 std::pair<unsigned, unsigned> SrcID =
2767 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2768 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2770 Twine(getSourceFileName(SrcID.second)) +
2771 ":" + Twine(LineInfo.getLine()));
2774 // Define the line address.
2775 Asm->OutStreamer.AddComment("Extended Op");
2777 Asm->OutStreamer.AddComment("Op size");
2778 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2780 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2781 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2783 Asm->OutStreamer.AddComment("Location label");
2784 Asm->OutStreamer.EmitSymbolValue(Label,
2785 Asm->getTargetData().getPointerSize(),
2788 // If change of source, then switch to the new source.
2789 if (Source != LineInfo.getSourceID()) {
2790 Source = LineInfo.getSourceID();
2791 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2792 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2793 Asm->EmitULEB128(Source, "New Source");
2796 // If change of line.
2797 if (Line != LineInfo.getLine()) {
2798 // Determine offset.
2799 int Offset = LineInfo.getLine() - Line;
2800 int Delta = Offset - MinLineDelta;
2803 Line = LineInfo.getLine();
2805 // If delta is small enough and in range...
2806 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2807 // ... then use fast opcode.
2808 Asm->OutStreamer.AddComment("Line Delta");
2809 Asm->EmitInt8(Delta - MinLineDelta);
2811 // ... otherwise use long hand.
2812 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2813 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2814 Asm->EmitSLEB128(Offset, "Line Offset");
2815 Asm->OutStreamer.AddComment("DW_LNS_copy");
2816 Asm->EmitInt8(dwarf::DW_LNS_copy);
2819 // Copy the previous row (different address or source)
2820 Asm->OutStreamer.AddComment("DW_LNS_copy");
2821 Asm->EmitInt8(dwarf::DW_LNS_copy);
2825 emitEndOfLineMatrix(j + 1);
2828 if (SecSrcLinesSize == 0)
2829 // Because we're emitting a debug_line section, we still need a line
2830 // table. The linker and friends expect it to exist. If there's nothing to
2831 // put into it, emit an empty table.
2832 emitEndOfLineMatrix(1);
2834 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2837 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2839 void DwarfDebug::emitCommonDebugFrame() {
2840 if (!Asm->MAI->doesDwarfRequireFrameSection())
2843 int stackGrowth = Asm->getTargetData().getPointerSize();
2844 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2845 TargetFrameInfo::StackGrowsDown)
2848 // Start the dwarf frame section.
2849 Asm->OutStreamer.SwitchSection(
2850 Asm->getObjFileLowering().getDwarfFrameSection());
2852 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2853 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2854 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2855 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2857 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2858 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2859 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2860 Asm->OutStreamer.AddComment("CIE Version");
2861 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2862 Asm->OutStreamer.AddComment("CIE Augmentation");
2863 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2864 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2865 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2866 Asm->OutStreamer.AddComment("CIE RA Column");
2867 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2868 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2870 std::vector<MachineMove> Moves;
2871 RI->getInitialFrameState(Moves);
2873 Asm->EmitFrameMoves(Moves, 0, false);
2875 Asm->EmitAlignment(2, 0, 0, false);
2876 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2879 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2882 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2883 if (!Asm->MAI->doesDwarfRequireFrameSection())
2886 // Start the dwarf frame section.
2887 Asm->OutStreamer.SwitchSection(
2888 Asm->getObjFileLowering().getDwarfFrameSection());
2890 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2891 MCSymbol *DebugFrameBegin =
2892 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2893 MCSymbol *DebugFrameEnd =
2894 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2895 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2897 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2899 Asm->OutStreamer.AddComment("FDE CIE offset");
2900 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2901 DwarfFrameSectionSym);
2903 Asm->OutStreamer.AddComment("FDE initial location");
2904 MCSymbol *FuncBeginSym =
2905 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2906 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2907 Asm->getTargetData().getPointerSize(),
2911 Asm->OutStreamer.AddComment("FDE address range");
2912 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2913 FuncBeginSym, Asm->getTargetData().getPointerSize());
2915 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2917 Asm->EmitAlignment(2, 0, 0, false);
2918 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2921 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2923 void DwarfDebug::emitDebugPubNames() {
2924 // Start the dwarf pubnames section.
2925 Asm->OutStreamer.SwitchSection(
2926 Asm->getObjFileLowering().getDwarfPubNamesSection());
2928 Asm->OutStreamer.AddComment("Length of Public Names Info");
2929 Asm->EmitLabelDifference(
2930 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2931 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2933 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2934 ModuleCU->getID()));
2936 Asm->OutStreamer.AddComment("DWARF Version");
2937 Asm->EmitInt16(dwarf::DWARF_VERSION);
2939 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2940 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2941 DwarfInfoSectionSym);
2943 Asm->OutStreamer.AddComment("Compilation Unit Length");
2944 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2945 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2948 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2949 for (StringMap<DIE*>::const_iterator
2950 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2951 const char *Name = GI->getKeyData();
2952 DIE *Entity = GI->second;
2954 Asm->OutStreamer.AddComment("DIE offset");
2955 Asm->EmitInt32(Entity->getOffset());
2957 if (Asm->isVerbose())
2958 Asm->OutStreamer.AddComment("External Name");
2959 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2962 Asm->OutStreamer.AddComment("End Mark");
2964 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2965 ModuleCU->getID()));
2968 void DwarfDebug::emitDebugPubTypes() {
2969 // Start the dwarf pubnames section.
2970 Asm->OutStreamer.SwitchSection(
2971 Asm->getObjFileLowering().getDwarfPubTypesSection());
2972 Asm->OutStreamer.AddComment("Length of Public Types Info");
2973 Asm->EmitLabelDifference(
2974 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
2975 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
2977 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2978 ModuleCU->getID()));
2980 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2981 Asm->EmitInt16(dwarf::DWARF_VERSION);
2983 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2984 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2985 DwarfInfoSectionSym);
2987 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2988 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2989 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2992 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2993 for (StringMap<DIE*>::const_iterator
2994 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2995 const char *Name = GI->getKeyData();
2996 DIE * Entity = GI->second;
2998 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2999 Asm->EmitInt32(Entity->getOffset());
3001 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3002 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3005 Asm->OutStreamer.AddComment("End Mark");
3007 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3008 ModuleCU->getID()));
3011 /// emitDebugStr - Emit visible names into a debug str section.
3013 void DwarfDebug::emitDebugStr() {
3014 // Check to see if it is worth the effort.
3015 if (StringPool.empty()) return;
3017 // Start the dwarf str section.
3018 Asm->OutStreamer.SwitchSection(
3019 Asm->getObjFileLowering().getDwarfStrSection());
3021 // Get all of the string pool entries and put them in an array by their ID so
3022 // we can sort them.
3023 SmallVector<std::pair<unsigned,
3024 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3026 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3027 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3028 Entries.push_back(std::make_pair(I->second.second, &*I));
3030 array_pod_sort(Entries.begin(), Entries.end());
3032 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3033 // Emit a label for reference from debug information entries.
3034 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3036 // Emit the string itself.
3037 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3041 /// emitDebugLoc - Emit visible names into a debug loc section.
3043 void DwarfDebug::emitDebugLoc() {
3044 // Start the dwarf loc section.
3045 Asm->OutStreamer.SwitchSection(
3046 Asm->getObjFileLowering().getDwarfLocSection());
3049 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3051 void DwarfDebug::EmitDebugARanges() {
3052 // Start the dwarf aranges section.
3053 Asm->OutStreamer.SwitchSection(
3054 Asm->getObjFileLowering().getDwarfARangesSection());
3057 /// emitDebugRanges - Emit visible names into a debug ranges section.
3059 void DwarfDebug::emitDebugRanges() {
3060 // Start the dwarf ranges section.
3061 Asm->OutStreamer.SwitchSection(
3062 Asm->getObjFileLowering().getDwarfRangesSection());
3065 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3067 void DwarfDebug::emitDebugMacInfo() {
3068 if (const MCSection *LineInfo =
3069 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3070 // Start the dwarf macinfo section.
3071 Asm->OutStreamer.SwitchSection(LineInfo);
3075 /// emitDebugInlineInfo - Emit inline info using following format.
3077 /// 1. length of section
3078 /// 2. Dwarf version number
3079 /// 3. address size.
3081 /// Entries (one "entry" for each function that was inlined):
3083 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3084 /// otherwise offset into __debug_str for regular function name.
3085 /// 2. offset into __debug_str section for regular function name.
3086 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3087 /// instances for the function.
3089 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3090 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3091 /// __debug_info section, and the low_pc is the starting address for the
3092 /// inlining instance.
3093 void DwarfDebug::emitDebugInlineInfo() {
3094 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3100 Asm->OutStreamer.SwitchSection(
3101 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3103 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3104 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3105 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3107 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3109 Asm->OutStreamer.AddComment("Dwarf Version");
3110 Asm->EmitInt16(dwarf::DWARF_VERSION);
3111 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3112 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3114 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3115 E = InlinedSPNodes.end(); I != E; ++I) {
3118 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3119 = InlineInfo.find(Node);
3120 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3121 DISubprogram SP(Node);
3122 StringRef LName = SP.getLinkageName();
3123 StringRef Name = SP.getName();
3125 Asm->OutStreamer.AddComment("MIPS linkage name");
3126 if (LName.empty()) {
3127 Asm->OutStreamer.EmitBytes(Name, 0);
3128 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3130 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3131 DwarfStrSectionSym);
3133 Asm->OutStreamer.AddComment("Function name");
3134 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3135 Asm->EmitULEB128(Labels.size(), "Inline count");
3137 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3138 LE = Labels.end(); LI != LE; ++LI) {
3139 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3140 Asm->EmitInt32(LI->second->getOffset());
3142 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3143 Asm->OutStreamer.EmitSymbolValue(LI->first,
3144 Asm->getTargetData().getPointerSize(),0);
3148 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));