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/TargetRegisterInfo.h"
28 #include "llvm/ADT/StringExtras.h"
29 #include "llvm/Support/Debug.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/ValueHandle.h"
32 #include "llvm/Support/FormattedStream.h"
33 #include "llvm/Support/Timer.h"
34 #include "llvm/System/Path.h"
37 //===----------------------------------------------------------------------===//
39 /// Configuration values for initial hash set sizes (log2).
41 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
45 //===----------------------------------------------------------------------===//
46 /// CompileUnit - This dwarf writer support class manages information associate
47 /// with a source file.
49 /// ID - File identifier for source.
53 /// Die - Compile unit debug information entry.
57 /// IndexTyDie - An anonymous type for index type.
60 /// GVToDieMap - Tracks the mapping of unit level debug informaton
61 /// variables to debug information entries.
62 /// FIXME : Rename GVToDieMap -> NodeToDieMap
63 DenseMap<MDNode *, DIE *> GVToDieMap;
65 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
66 /// descriptors to debug information entries using a DIEEntry proxy.
68 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
70 /// Globals - A map of globally visible named entities for this unit.
72 StringMap<DIE*> Globals;
74 /// GlobalTypes - A map of globally visible types for this unit.
76 StringMap<DIE*> GlobalTypes;
79 CompileUnit(unsigned I, DIE *D)
80 : ID(I), CUDie(D), IndexTyDie(0) {}
81 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
84 unsigned getID() const { return ID; }
85 DIE* getCUDie() const { return CUDie; }
86 const StringMap<DIE*> &getGlobals() const { return Globals; }
87 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
89 /// hasContent - Return true if this compile unit has something to write out.
91 bool hasContent() const { return !CUDie->getChildren().empty(); }
93 /// addGlobal - Add a new global entity to the compile unit.
95 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
97 /// addGlobalType - Add a new global type to the compile unit.
99 void addGlobalType(const std::string &Name, DIE *Die) {
100 GlobalTypes[Name] = Die;
103 /// getDIE - Returns the debug information entry map slot for the
104 /// specified debug variable.
105 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
107 /// insertDIE - Insert DIE into the map.
108 void insertDIE(MDNode *N, DIE *D) {
109 GVToDieMap.insert(std::make_pair(N, D));
112 /// getDIEEntry - Returns the debug information entry for the speciefied
114 DIEEntry *getDIEEntry(MDNode *N) {
115 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
116 if (I == GVToDIEEntryMap.end())
121 /// insertDIEEntry - Insert debug information entry into the map.
122 void insertDIEEntry(MDNode *N, DIEEntry *E) {
123 GVToDIEEntryMap.insert(std::make_pair(N, E));
126 /// addDie - Adds or interns the DIE to the compile unit.
128 void addDie(DIE *Buffer) {
129 this->CUDie->addChild(Buffer);
132 // getIndexTyDie - Get an anonymous type for index type.
133 DIE *getIndexTyDie() {
137 // setIndexTyDie - Set D as anonymous type for index which can be reused
139 void setIndexTyDie(DIE *D) {
145 //===----------------------------------------------------------------------===//
146 /// DbgVariable - This class is used to track local variable information.
149 DIVariable Var; // Variable Descriptor.
150 unsigned FrameIndex; // Variable frame index.
151 DbgVariable *AbstractVar; // Abstract variable for this variable.
154 DbgVariable(DIVariable V, unsigned I)
155 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
158 DIVariable getVariable() const { return Var; }
159 unsigned getFrameIndex() const { return FrameIndex; }
160 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
161 DbgVariable *getAbstractVariable() const { return AbstractVar; }
162 void setDIE(DIE *D) { TheDIE = D; }
163 DIE *getDIE() const { return TheDIE; }
166 //===----------------------------------------------------------------------===//
167 /// DbgScope - This class is used to track scope information.
170 DbgScope *Parent; // Parent to this scope.
171 DIDescriptor Desc; // Debug info descriptor for scope.
172 // Location at which this scope is inlined.
173 AssertingVH<MDNode> InlinedAtLocation;
174 bool AbstractScope; // Abstract Scope
175 MCSymbol *StartLabel; // Label ID of the beginning of scope.
176 MCSymbol *EndLabel; // Label ID of the end of scope.
177 const MachineInstr *LastInsn; // Last instruction of this scope.
178 const MachineInstr *FirstInsn; // First instruction of this scope.
179 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
180 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
182 // Private state for dump()
183 mutable unsigned IndentLevel;
185 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
186 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
187 StartLabel(0), EndLabel(0),
188 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
192 DbgScope *getParent() const { return Parent; }
193 void setParent(DbgScope *P) { Parent = P; }
194 DIDescriptor getDesc() const { return Desc; }
195 MDNode *getInlinedAt() const {
196 return InlinedAtLocation;
198 MDNode *getScopeNode() const { return Desc.getNode(); }
199 MCSymbol *getStartLabel() const { return StartLabel; }
200 MCSymbol *getEndLabel() const { return EndLabel; }
201 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
202 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
203 void setStartLabel(MCSymbol *S) { StartLabel = S; }
204 void setEndLabel(MCSymbol *E) { EndLabel = E; }
205 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
206 const MachineInstr *getLastInsn() { return LastInsn; }
207 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
208 void setAbstractScope() { AbstractScope = true; }
209 bool isAbstractScope() const { return AbstractScope; }
210 const MachineInstr *getFirstInsn() { return FirstInsn; }
212 /// addScope - Add a scope to the scope.
214 void addScope(DbgScope *S) { Scopes.push_back(S); }
216 /// addVariable - Add a variable to the scope.
218 void addVariable(DbgVariable *V) { Variables.push_back(V); }
220 void fixInstructionMarkers(DenseMap<const MachineInstr *,
221 unsigned> &MIIndexMap) {
222 assert (getFirstInsn() && "First instruction is missing!");
224 // Use the end of last child scope as end of this scope.
225 SmallVector<DbgScope *, 4> &Scopes = getScopes();
226 const MachineInstr *LastInsn = getFirstInsn();
228 if (Scopes.empty()) {
229 assert (getLastInsn() && "Inner most scope does not have last insn!");
232 for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
233 SE = Scopes.end(); SI != SE; ++SI) {
235 DS->fixInstructionMarkers(MIIndexMap);
236 const MachineInstr *DSLastInsn = DS->getLastInsn();
237 unsigned DSI = MIIndexMap[DSLastInsn];
239 LastInsn = DSLastInsn;
244 unsigned CurrentLastInsnIndex = 0;
245 if (const MachineInstr *CL = getLastInsn())
246 CurrentLastInsnIndex = MIIndexMap[CL];
247 unsigned FIndex = MIIndexMap[getFirstInsn()];
249 // Set LastInsn as the last instruction for this scope only if
251 // 1) this scope's first instruction and
252 // 2) current last instruction for this scope, if any.
253 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
254 setLastInsn(LastInsn);
263 void DbgScope::dump() const {
264 raw_ostream &err = dbgs();
265 err.indent(IndentLevel);
266 MDNode *N = Desc.getNode();
268 err << " [" << StartLabel << ", " << EndLabel << "]\n";
270 err << "Abstract Scope\n";
274 err << "Children ...\n";
275 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
276 if (Scopes[i] != this)
283 DbgScope::~DbgScope() {
284 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
286 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
290 } // end llvm namespace
292 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
293 : DwarfPrinter(OS, A, T), ModuleCU(0),
294 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
295 DIEValues(), StringPool(),
296 SectionSourceLines(), didInitial(false), shouldEmit(false),
297 CurrentFnDbgScope(0), DebugTimer(0) {
298 if (TimePassesIsEnabled)
299 DebugTimer = new Timer("Dwarf Debug Writer");
301 DwarfDebug::~DwarfDebug() {
302 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
308 /// assignAbbrevNumber - Define a unique number for the abbreviation.
310 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
311 // Profile the node so that we can make it unique.
315 // Check the set for priors.
316 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
318 // If it's newly added.
319 if (InSet == &Abbrev) {
320 // Add to abbreviation list.
321 Abbreviations.push_back(&Abbrev);
323 // Assign the vector position + 1 as its number.
324 Abbrev.setNumber(Abbreviations.size());
326 // Assign existing abbreviation number.
327 Abbrev.setNumber(InSet->getNumber());
331 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
332 /// information entry.
333 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
334 DIEEntry *Value = new DIEEntry(Entry);
335 DIEValues.push_back(Value);
339 /// addUInt - Add an unsigned integer attribute data and value.
341 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
342 unsigned Form, uint64_t Integer) {
343 if (!Form) Form = DIEInteger::BestForm(false, Integer);
344 DIEValue *Value = new DIEInteger(Integer);
345 DIEValues.push_back(Value);
346 Die->addValue(Attribute, Form, Value);
349 /// addSInt - Add an signed integer attribute data and value.
351 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
352 unsigned Form, int64_t Integer) {
353 if (!Form) Form = DIEInteger::BestForm(true, Integer);
354 DIEValue *Value = new DIEInteger(Integer);
355 DIEValues.push_back(Value);
356 Die->addValue(Attribute, Form, Value);
359 /// addString - Add a string attribute data and value. DIEString only
360 /// keeps string reference.
361 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
363 DIEValue *Value = new DIEString(String);
364 DIEValues.push_back(Value);
365 Die->addValue(Attribute, Form, Value);
368 /// addLabel - Add a Dwarf label attribute data and value.
370 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
371 const MCSymbol *Label) {
372 DIEValue *Value = new DIELabel(Label);
373 DIEValues.push_back(Value);
374 Die->addValue(Attribute, Form, Value);
377 /// addSectionOffset - Add a section offset label attribute data and value.
379 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
380 const MCSymbol *Label,const MCSymbol *Section,
382 DIEValue *Value = new DIESectionOffset(Label, Section, isEH);
383 DIEValues.push_back(Value);
384 Die->addValue(Attribute, Form, Value);
387 /// addDelta - Add a label delta attribute data and value.
389 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
390 const MCSymbol *Hi, const MCSymbol *Lo) {
391 DIEValue *Value = new DIEDelta(Hi, Lo);
392 DIEValues.push_back(Value);
393 Die->addValue(Attribute, Form, Value);
396 /// addBlock - Add block data.
398 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
400 Block->ComputeSize(TD);
401 DIEValues.push_back(Block);
402 Die->addValue(Attribute, Block->BestForm(), Block);
405 /// addSourceLine - Add location information to specified debug information
407 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
408 // If there is no compile unit specified, don't add a line #.
409 if (!V->getCompileUnit().Verify())
412 unsigned Line = V->getLineNumber();
413 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
414 V->getContext().getFilename());
415 assert(FileID && "Invalid file id");
416 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
417 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
420 /// addSourceLine - Add location information to specified debug information
422 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
423 // If there is no compile unit specified, don't add a line #.
424 if (!G->getCompileUnit().Verify())
427 unsigned Line = G->getLineNumber();
428 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
429 G->getContext().getFilename());
430 assert(FileID && "Invalid file id");
431 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
432 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
435 /// addSourceLine - Add location information to specified debug information
437 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
438 // If there is no compile unit specified, don't add a line #.
439 if (!SP->getCompileUnit().Verify())
441 // If the line number is 0, don't add it.
442 if (SP->getLineNumber() == 0)
445 unsigned Line = SP->getLineNumber();
446 if (!SP->getContext().Verify())
448 unsigned FileID = GetOrCreateSourceID(SP->getContext().getDirectory(),
449 SP->getContext().getFilename());
450 assert(FileID && "Invalid file id");
451 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
452 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
455 /// addSourceLine - Add location information to specified debug information
457 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
458 // If there is no compile unit specified, don't add a line #.
459 DICompileUnit CU = Ty->getCompileUnit();
463 unsigned Line = Ty->getLineNumber();
464 if (!Ty->getContext().Verify())
466 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
467 Ty->getContext().getFilename());
468 assert(FileID && "Invalid file id");
469 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
470 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
473 /// addSourceLine - Add location information to specified debug information
475 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
476 // If there is no compile unit specified, don't add a line #.
477 if (!NS->getCompileUnit().Verify())
480 unsigned Line = NS->getLineNumber();
481 StringRef FN = NS->getFilename();
482 StringRef Dir = NS->getDirectory();
484 unsigned FileID = GetOrCreateSourceID(Dir, FN);
485 assert(FileID && "Invalid file id");
486 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
487 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
490 /* Byref variables, in Blocks, are declared by the programmer as
491 "SomeType VarName;", but the compiler creates a
492 __Block_byref_x_VarName struct, and gives the variable VarName
493 either the struct, or a pointer to the struct, as its type. This
494 is necessary for various behind-the-scenes things the compiler
495 needs to do with by-reference variables in blocks.
497 However, as far as the original *programmer* is concerned, the
498 variable should still have type 'SomeType', as originally declared.
500 The following function dives into the __Block_byref_x_VarName
501 struct to find the original type of the variable. This will be
502 passed back to the code generating the type for the Debug
503 Information Entry for the variable 'VarName'. 'VarName' will then
504 have the original type 'SomeType' in its debug information.
506 The original type 'SomeType' will be the type of the field named
507 'VarName' inside the __Block_byref_x_VarName struct.
509 NOTE: In order for this to not completely fail on the debugger
510 side, the Debug Information Entry for the variable VarName needs to
511 have a DW_AT_location that tells the debugger how to unwind through
512 the pointers and __Block_byref_x_VarName struct to find the actual
513 value of the variable. The function addBlockByrefType does this. */
515 /// Find the type the programmer originally declared the variable to be
516 /// and return that type.
518 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
521 unsigned tag = Ty.getTag();
523 if (tag == dwarf::DW_TAG_pointer_type) {
524 DIDerivedType DTy = DIDerivedType(Ty.getNode());
525 subType = DTy.getTypeDerivedFrom();
528 DICompositeType blockStruct = DICompositeType(subType.getNode());
529 DIArray Elements = blockStruct.getTypeArray();
531 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
532 DIDescriptor Element = Elements.getElement(i);
533 DIDerivedType DT = DIDerivedType(Element.getNode());
534 if (Name == DT.getName())
535 return (DT.getTypeDerivedFrom());
541 /// addComplexAddress - Start with the address based on the location provided,
542 /// and generate the DWARF information necessary to find the actual variable
543 /// given the extra address information encoded in the DIVariable, starting from
544 /// the starting location. Add the DWARF information to the die.
546 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
548 const MachineLocation &Location) {
549 const DIVariable &VD = DV->getVariable();
550 DIType Ty = VD.getType();
552 // Decode the original location, and use that as the start of the byref
553 // variable's location.
554 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
555 DIEBlock *Block = new DIEBlock();
557 if (Location.isReg()) {
559 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
561 Reg = Reg - dwarf::DW_OP_reg0;
562 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
563 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
567 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
569 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
570 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
573 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
576 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
577 uint64_t Element = VD.getAddrElement(i);
579 if (Element == DIFactory::OpPlus) {
580 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
581 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
582 } else if (Element == DIFactory::OpDeref) {
583 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
584 } else llvm_unreachable("unknown DIFactory Opcode");
587 // Now attach the location information to the DIE.
588 addBlock(Die, Attribute, 0, Block);
591 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
592 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
593 gives the variable VarName either the struct, or a pointer to the struct, as
594 its type. This is necessary for various behind-the-scenes things the
595 compiler needs to do with by-reference variables in Blocks.
597 However, as far as the original *programmer* is concerned, the variable
598 should still have type 'SomeType', as originally declared.
600 The function getBlockByrefType dives into the __Block_byref_x_VarName
601 struct to find the original type of the variable, which is then assigned to
602 the variable's Debug Information Entry as its real type. So far, so good.
603 However now the debugger will expect the variable VarName to have the type
604 SomeType. So we need the location attribute for the variable to be an
605 expression that explains to the debugger how to navigate through the
606 pointers and struct to find the actual variable of type SomeType.
608 The following function does just that. We start by getting
609 the "normal" location for the variable. This will be the location
610 of either the struct __Block_byref_x_VarName or the pointer to the
611 struct __Block_byref_x_VarName.
613 The struct will look something like:
615 struct __Block_byref_x_VarName {
617 struct __Block_byref_x_VarName *forwarding;
618 ... <various other fields>
620 ... <maybe more fields>
623 If we are given the struct directly (as our starting point) we
624 need to tell the debugger to:
626 1). Add the offset of the forwarding field.
628 2). Follow that pointer to get the real __Block_byref_x_VarName
629 struct to use (the real one may have been copied onto the heap).
631 3). Add the offset for the field VarName, to find the actual variable.
633 If we started with a pointer to the struct, then we need to
634 dereference that pointer first, before the other steps.
635 Translating this into DWARF ops, we will need to append the following
636 to the current location description for the variable:
638 DW_OP_deref -- optional, if we start with a pointer
639 DW_OP_plus_uconst <forward_fld_offset>
641 DW_OP_plus_uconst <varName_fld_offset>
643 That is what this function does. */
645 /// addBlockByrefAddress - Start with the address based on the location
646 /// provided, and generate the DWARF information necessary to find the
647 /// actual Block variable (navigating the Block struct) based on the
648 /// starting location. Add the DWARF information to the die. For
649 /// more information, read large comment just above here.
651 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
653 const MachineLocation &Location) {
654 const DIVariable &VD = DV->getVariable();
655 DIType Ty = VD.getType();
657 unsigned Tag = Ty.getTag();
658 bool isPointer = false;
660 StringRef varName = VD.getName();
662 if (Tag == dwarf::DW_TAG_pointer_type) {
663 DIDerivedType DTy = DIDerivedType(Ty.getNode());
664 TmpTy = DTy.getTypeDerivedFrom();
668 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
670 // Find the __forwarding field and the variable field in the __Block_byref
672 DIArray Fields = blockStruct.getTypeArray();
673 DIDescriptor varField = DIDescriptor();
674 DIDescriptor forwardingField = DIDescriptor();
676 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
677 DIDescriptor Element = Fields.getElement(i);
678 DIDerivedType DT = DIDerivedType(Element.getNode());
679 StringRef fieldName = DT.getName();
680 if (fieldName == "__forwarding")
681 forwardingField = Element;
682 else if (fieldName == varName)
686 // Get the offsets for the forwarding field and the variable field.
687 unsigned int forwardingFieldOffset =
688 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
689 unsigned int varFieldOffset =
690 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
692 // Decode the original location, and use that as the start of the byref
693 // variable's location.
694 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
695 DIEBlock *Block = new DIEBlock();
697 if (Location.isReg()) {
699 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
701 Reg = Reg - dwarf::DW_OP_reg0;
702 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
703 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
707 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
709 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
710 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
713 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
716 // If we started with a pointer to the __Block_byref... struct, then
717 // the first thing we need to do is dereference the pointer (DW_OP_deref).
719 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
721 // Next add the offset for the '__forwarding' field:
722 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
723 // adding the offset if it's 0.
724 if (forwardingFieldOffset > 0) {
725 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
726 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
729 // Now dereference the __forwarding field to get to the real __Block_byref
730 // struct: DW_OP_deref.
731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
733 // Now that we've got the real __Block_byref... struct, add the offset
734 // for the variable's field to get to the location of the actual variable:
735 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
736 if (varFieldOffset > 0) {
737 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
738 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
741 // Now attach the location information to the DIE.
742 addBlock(Die, Attribute, 0, Block);
745 /// addAddress - Add an address attribute to a die based on the location
747 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
748 const MachineLocation &Location) {
749 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
750 DIEBlock *Block = new DIEBlock();
752 if (Location.isReg()) {
754 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
757 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
761 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
764 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
767 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
770 addBlock(Die, Attribute, 0, Block);
773 /// addToContextOwner - Add Die into the list of its context owner's children.
774 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
775 if (Context.isType()) {
776 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
777 ContextDIE->addChild(Die);
778 } else if (Context.isNameSpace()) {
779 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
780 ContextDIE->addChild(Die);
781 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
782 ContextDIE->addChild(Die);
784 ModuleCU->addDie(Die);
787 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
789 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
790 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
795 TyDIE = new DIE(dwarf::DW_TAG_base_type);
796 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
797 if (Ty.isBasicType())
798 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
799 else if (Ty.isCompositeType())
800 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
802 assert(Ty.isDerivedType() && "Unknown kind of DIType");
803 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
806 addToContextOwner(TyDIE, Ty.getContext());
810 /// addType - Add a new type attribute to the specified entity.
811 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
815 // Check for pre-existence.
816 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
817 // If it exists then use the existing value.
819 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
824 Entry = createDIEEntry();
825 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
828 DIE *Buffer = getOrCreateTypeDIE(Ty);
830 Entry->setEntry(Buffer);
831 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
834 /// constructTypeDIE - Construct basic type die from DIBasicType.
835 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
836 // Get core information.
837 StringRef Name = BTy.getName();
838 Buffer.setTag(dwarf::DW_TAG_base_type);
839 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
842 // Add name if not anonymous or intermediate type.
844 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
845 uint64_t Size = BTy.getSizeInBits() >> 3;
846 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
849 /// constructTypeDIE - Construct derived type die from DIDerivedType.
850 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
851 // Get core information.
852 StringRef Name = DTy.getName();
853 uint64_t Size = DTy.getSizeInBits() >> 3;
854 unsigned Tag = DTy.getTag();
856 // FIXME - Workaround for templates.
857 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
861 // Map to main type, void will not have a type.
862 DIType FromTy = DTy.getTypeDerivedFrom();
863 addType(&Buffer, FromTy);
865 // Add name if not anonymous or intermediate type.
867 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
869 // Add size if non-zero (derived types might be zero-sized.)
871 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
873 // Add source line info if available and TyDesc is not a forward declaration.
874 if (!DTy.isForwardDecl())
875 addSourceLine(&Buffer, &DTy);
878 /// constructTypeDIE - Construct type DIE from DICompositeType.
879 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
880 // Get core information.
881 StringRef Name = CTy.getName();
883 uint64_t Size = CTy.getSizeInBits() >> 3;
884 unsigned Tag = CTy.getTag();
888 case dwarf::DW_TAG_vector_type:
889 case dwarf::DW_TAG_array_type:
890 constructArrayTypeDIE(Buffer, &CTy);
892 case dwarf::DW_TAG_enumeration_type: {
893 DIArray Elements = CTy.getTypeArray();
895 // Add enumerators to enumeration type.
896 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
898 DIDescriptor Enum(Elements.getElement(i).getNode());
899 if (Enum.isEnumerator()) {
900 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
901 Buffer.addChild(ElemDie);
906 case dwarf::DW_TAG_subroutine_type: {
908 DIArray Elements = CTy.getTypeArray();
909 DIDescriptor RTy = Elements.getElement(0);
910 addType(&Buffer, DIType(RTy.getNode()));
912 // Add prototype flag.
913 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
916 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
917 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
918 DIDescriptor Ty = Elements.getElement(i);
919 addType(Arg, DIType(Ty.getNode()));
920 Buffer.addChild(Arg);
924 case dwarf::DW_TAG_structure_type:
925 case dwarf::DW_TAG_union_type:
926 case dwarf::DW_TAG_class_type: {
927 // Add elements to structure type.
928 DIArray Elements = CTy.getTypeArray();
930 // A forward struct declared type may not have elements available.
931 unsigned N = Elements.getNumElements();
935 // Add elements to structure type.
936 for (unsigned i = 0; i < N; ++i) {
937 DIDescriptor Element = Elements.getElement(i);
939 if (Element.isSubprogram())
940 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
941 else if (Element.isVariable()) {
942 DIVariable DV(Element.getNode());
943 ElemDie = new DIE(dwarf::DW_TAG_variable);
944 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
946 addType(ElemDie, DV.getType());
947 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
948 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
949 addSourceLine(ElemDie, &DV);
950 } else if (Element.isDerivedType())
951 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
954 Buffer.addChild(ElemDie);
957 if (CTy.isAppleBlockExtension())
958 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
960 unsigned RLang = CTy.getRunTimeLang();
962 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
963 dwarf::DW_FORM_data1, RLang);
965 DICompositeType ContainingType = CTy.getContainingType();
966 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
967 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
968 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
975 // Add name if not anonymous or intermediate type.
977 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
979 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
980 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
981 // Add size if non-zero (derived types might be zero-sized.)
983 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
985 // Add zero size if it is not a forward declaration.
986 if (CTy.isForwardDecl())
987 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
989 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
992 // Add source line info if available.
993 if (!CTy.isForwardDecl())
994 addSourceLine(&Buffer, &CTy);
998 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
999 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1000 int64_t L = SR.getLo();
1001 int64_t H = SR.getHi();
1002 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1004 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1006 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1007 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1009 Buffer.addChild(DW_Subrange);
1012 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1013 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1014 DICompositeType *CTy) {
1015 Buffer.setTag(dwarf::DW_TAG_array_type);
1016 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1017 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1019 // Emit derived type.
1020 addType(&Buffer, CTy->getTypeDerivedFrom());
1021 DIArray Elements = CTy->getTypeArray();
1023 // Get an anonymous type for index type.
1024 DIE *IdxTy = ModuleCU->getIndexTyDie();
1026 // Construct an anonymous type for index type.
1027 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1028 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1029 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1030 dwarf::DW_ATE_signed);
1031 ModuleCU->addDie(IdxTy);
1032 ModuleCU->setIndexTyDie(IdxTy);
1035 // Add subranges to array type.
1036 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1037 DIDescriptor Element = Elements.getElement(i);
1038 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1039 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1043 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1044 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1045 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1046 StringRef Name = ETy.getName();
1047 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1048 int64_t Value = ETy.getEnumValue();
1049 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1053 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1054 /// printer to not emit usual symbol prefix before the symbol name is used then
1055 /// return linkage name after skipping this special LLVM prefix.
1056 static StringRef getRealLinkageName(StringRef LinkageName) {
1058 if (LinkageName.startswith(StringRef(&One, 1)))
1059 return LinkageName.substr(1);
1063 /// createGlobalVariableDIE - Create new DIE using GV.
1064 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1065 // If the global variable was optmized out then no need to create debug info
1067 if (!GV.getGlobal()) return NULL;
1068 if (GV.getDisplayName().empty()) return NULL;
1070 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1071 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1072 GV.getDisplayName());
1074 StringRef LinkageName = GV.getLinkageName();
1075 if (!LinkageName.empty())
1076 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1077 getRealLinkageName(LinkageName));
1079 addType(GVDie, GV.getType());
1080 if (!GV.isLocalToUnit())
1081 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1082 addSourceLine(GVDie, &GV);
1087 /// createMemberDIE - Create new member DIE.
1088 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1089 DIE *MemberDie = new DIE(DT.getTag());
1090 StringRef Name = DT.getName();
1092 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1094 addType(MemberDie, DT.getTypeDerivedFrom());
1096 addSourceLine(MemberDie, &DT);
1098 DIEBlock *MemLocationDie = new DIEBlock();
1099 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1101 uint64_t Size = DT.getSizeInBits();
1102 uint64_t FieldSize = DT.getOriginalTypeSize();
1104 if (Size != FieldSize) {
1106 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1107 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1109 uint64_t Offset = DT.getOffsetInBits();
1110 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1111 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1112 uint64_t FieldOffset = (HiMark - FieldSize);
1113 Offset -= FieldOffset;
1115 // Maybe we need to work from the other end.
1116 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1117 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1119 // Here WD_AT_data_member_location points to the anonymous
1120 // field that includes this bit field.
1121 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1124 // This is not a bitfield.
1125 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1127 if (DT.getTag() == dwarf::DW_TAG_inheritance
1128 && DT.isVirtual()) {
1130 // For C++, virtual base classes are not at fixed offset. Use following
1131 // expression to extract appropriate offset from vtable.
1132 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1134 DIEBlock *VBaseLocationDie = new DIEBlock();
1135 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1136 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1137 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1138 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1139 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1140 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1141 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1143 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1146 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1148 if (DT.isProtected())
1149 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1150 dwarf::DW_ACCESS_protected);
1151 else if (DT.isPrivate())
1152 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1153 dwarf::DW_ACCESS_private);
1154 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1155 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1156 dwarf::DW_ACCESS_public);
1158 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1159 dwarf::DW_VIRTUALITY_virtual);
1163 /// createSubprogramDIE - Create new DIE using SP.
1164 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1165 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1169 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1170 // Constructors and operators for anonymous aggregates do not have names.
1171 if (!SP.getName().empty())
1172 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1174 StringRef LinkageName = SP.getLinkageName();
1175 if (!LinkageName.empty())
1176 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1177 getRealLinkageName(LinkageName));
1179 addSourceLine(SPDie, &SP);
1181 // Add prototyped tag, if C or ObjC.
1182 unsigned Lang = SP.getCompileUnit().getLanguage();
1183 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1184 Lang == dwarf::DW_LANG_ObjC)
1185 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1188 DICompositeType SPTy = SP.getType();
1189 DIArray Args = SPTy.getTypeArray();
1190 unsigned SPTag = SPTy.getTag();
1192 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1193 addType(SPDie, SPTy);
1195 addType(SPDie, DIType(Args.getElement(0).getNode()));
1197 unsigned VK = SP.getVirtuality();
1199 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1200 DIEBlock *Block = new DIEBlock();
1201 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1202 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1203 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1204 ContainingTypeMap.insert(std::make_pair(SPDie,
1205 SP.getContainingType().getNode()));
1208 if (MakeDecl || !SP.isDefinition()) {
1209 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1211 // Add arguments. Do not add arguments for subprogram definition. They will
1212 // be handled while processing variables.
1213 DICompositeType SPTy = SP.getType();
1214 DIArray Args = SPTy.getTypeArray();
1215 unsigned SPTag = SPTy.getTag();
1217 if (SPTag == dwarf::DW_TAG_subroutine_type)
1218 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1219 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1220 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1222 if (ATy.isArtificial())
1223 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1224 SPDie->addChild(Arg);
1228 if (SP.isArtificial())
1229 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1231 // DW_TAG_inlined_subroutine may refer to this DIE.
1232 ModuleCU->insertDIE(SP.getNode(), SPDie);
1236 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1237 /// Initialize scope and update scope hierarchy.
1238 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1239 MDNode *InlinedAt) {
1240 assert (N && "Invalid Scope encoding!");
1241 assert (MI && "Missing machine instruction!");
1242 bool GetConcreteScope = (MI && InlinedAt);
1244 DbgScope *NScope = NULL;
1247 NScope = DbgScopeMap.lookup(InlinedAt);
1249 NScope = DbgScopeMap.lookup(N);
1250 assert (NScope && "Unable to find working scope!");
1252 if (NScope->getFirstInsn())
1255 DbgScope *Parent = NULL;
1256 if (GetConcreteScope) {
1257 DILocation IL(InlinedAt);
1258 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1259 IL.getOrigLocation().getNode());
1260 assert (Parent && "Unable to find Parent scope!");
1261 NScope->setParent(Parent);
1262 Parent->addScope(NScope);
1263 } else if (DIDescriptor(N).isLexicalBlock()) {
1264 DILexicalBlock DB(N);
1265 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1266 NScope->setParent(Parent);
1267 Parent->addScope(NScope);
1270 NScope->setFirstInsn(MI);
1272 if (!Parent && !InlinedAt) {
1273 StringRef SPName = DISubprogram(N).getLinkageName();
1274 if (SPName == MF->getFunction()->getName())
1275 CurrentFnDbgScope = NScope;
1278 if (GetConcreteScope) {
1279 ConcreteScopes[InlinedAt] = NScope;
1280 getOrCreateAbstractScope(N);
1286 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1287 assert (N && "Invalid Scope encoding!");
1289 DbgScope *AScope = AbstractScopes.lookup(N);
1293 DbgScope *Parent = NULL;
1295 DIDescriptor Scope(N);
1296 if (Scope.isLexicalBlock()) {
1297 DILexicalBlock DB(N);
1298 DIDescriptor ParentDesc = DB.getContext();
1299 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1302 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1305 Parent->addScope(AScope);
1306 AScope->setAbstractScope();
1307 AbstractScopes[N] = AScope;
1308 if (DIDescriptor(N).isSubprogram())
1309 AbstractScopesList.push_back(AScope);
1313 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1314 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1315 /// If there are global variables in this scope then create and insert
1316 /// DIEs for these variables.
1317 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1319 DIE *SPDie = ModuleCU->getDIE(SPNode);
1320 assert (SPDie && "Unable to find subprogram DIE!");
1321 DISubprogram SP(SPNode);
1322 // There is not any need to generate specification DIE for a function
1323 // defined at compile unit level. If a function is defined inside another
1324 // function then gdb prefers the definition at top level and but does not
1325 // expect specification DIE in parent function. So avoid creating
1326 // specification DIE for a function defined inside a function.
1327 if (SP.isDefinition() && !SP.getContext().isCompileUnit()
1328 && !SP.getContext().isSubprogram()) {
1329 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1331 DICompositeType SPTy = SP.getType();
1332 DIArray Args = SPTy.getTypeArray();
1333 unsigned SPTag = SPTy.getTag();
1334 if (SPTag == dwarf::DW_TAG_subroutine_type)
1335 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1336 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1337 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1339 if (ATy.isArtificial())
1340 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1341 SPDie->addChild(Arg);
1343 DIE *SPDeclDie = SPDie;
1344 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1345 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1347 ModuleCU->addDie(SPDie);
1350 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1351 getDWLabel("func_begin", SubprogramCount));
1352 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1353 getDWLabel("func_end", SubprogramCount));
1354 MachineLocation Location(RI->getFrameRegister(*MF));
1355 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1357 if (!DISubprogram(SPNode).isLocalToUnit())
1358 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1363 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1364 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1365 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1366 MCSymbol *Start = Scope->getStartLabel();
1367 MCSymbol *End = Scope->getEndLabel();
1368 if (Start == 0) return 0;
1370 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1371 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1373 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1374 if (Scope->isAbstractScope())
1377 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1378 Start ? Start : getDWLabel("func_begin", SubprogramCount));
1379 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1380 End ? End : getDWLabel("func_end", SubprogramCount));
1385 /// constructInlinedScopeDIE - This scope represents inlined body of
1386 /// a function. Construct DIE to represent this concrete inlined copy
1387 /// of the function.
1388 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1389 MCSymbol *StartLabel = Scope->getStartLabel();
1390 MCSymbol *EndLabel = Scope->getEndLabel();
1391 if (StartLabel == 0) return 0;
1393 assert(StartLabel->isDefined() &&
1394 "Invalid starting label for an inlined scope!");
1395 assert(EndLabel->isDefined() &&
1396 "Invalid end label for an inlined scope!");
1397 if (!Scope->getScopeNode())
1399 DIScope DS(Scope->getScopeNode());
1400 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1402 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1403 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1404 assert (OriginDIE && "Unable to find Origin DIE!");
1405 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1406 dwarf::DW_FORM_ref4, OriginDIE);
1408 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1409 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1411 InlinedSubprogramDIEs.insert(OriginDIE);
1413 // Track the start label for this inlined function.
1414 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1415 I = InlineInfo.find(InlinedSP.getNode());
1417 if (I == InlineInfo.end()) {
1418 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1420 InlinedSPNodes.push_back(InlinedSP.getNode());
1422 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1424 StringPool.insert(InlinedSP.getName());
1425 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1427 DILocation DL(Scope->getInlinedAt());
1428 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1429 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1435 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1436 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1437 // Get the descriptor.
1438 const DIVariable &VD = DV->getVariable();
1439 StringRef Name = VD.getName();
1443 // Translate tag to proper Dwarf tag. The result variable is dropped for
1446 switch (VD.getTag()) {
1447 case dwarf::DW_TAG_return_variable:
1449 case dwarf::DW_TAG_arg_variable:
1450 Tag = dwarf::DW_TAG_formal_parameter;
1452 case dwarf::DW_TAG_auto_variable: // fall thru
1454 Tag = dwarf::DW_TAG_variable;
1458 // Define variable debug information entry.
1459 DIE *VariableDie = new DIE(Tag);
1463 if (DbgVariable *AV = DV->getAbstractVariable())
1464 AbsDIE = AV->getDIE();
1467 DIScope DS(Scope->getScopeNode());
1468 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1469 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1471 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1472 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1473 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1474 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1475 dwarf::DW_FORM_ref4, AbsDIE);
1478 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1479 addSourceLine(VariableDie, &VD);
1481 // Add variable type.
1482 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1483 // addresses instead.
1484 if (VD.isBlockByrefVariable())
1485 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1487 addType(VariableDie, VD.getType());
1490 // Add variable address.
1491 if (!Scope->isAbstractScope()) {
1492 MachineLocation Location;
1494 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1495 Location.set(FrameReg, Offset);
1497 if (VD.hasComplexAddress())
1498 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1499 else if (VD.isBlockByrefVariable())
1500 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1502 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1505 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1506 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1507 DV->setDIE(VariableDie);
1512 void DwarfDebug::addPubTypes(DISubprogram SP) {
1513 DICompositeType SPTy = SP.getType();
1514 unsigned SPTag = SPTy.getTag();
1515 if (SPTag != dwarf::DW_TAG_subroutine_type)
1518 DIArray Args = SPTy.getTypeArray();
1519 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1520 DIType ATy(Args.getElement(i).getNode());
1523 DICompositeType CATy = getDICompositeType(ATy);
1524 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1525 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1526 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1531 /// constructScopeDIE - Construct a DIE for this scope.
1532 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1533 if (!Scope || !Scope->getScopeNode())
1536 DIScope DS(Scope->getScopeNode());
1537 DIE *ScopeDIE = NULL;
1538 if (Scope->getInlinedAt())
1539 ScopeDIE = constructInlinedScopeDIE(Scope);
1540 else if (DS.isSubprogram()) {
1541 if (Scope->isAbstractScope())
1542 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1544 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1547 ScopeDIE = constructLexicalScopeDIE(Scope);
1548 if (!ScopeDIE) return NULL;
1551 // Add variables to scope.
1552 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1553 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1554 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1556 ScopeDIE->addChild(VariableDIE);
1559 // Add nested scopes.
1560 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1561 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1562 // Define the Scope debug information entry.
1563 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1565 ScopeDIE->addChild(NestedDIE);
1568 if (DS.isSubprogram())
1569 addPubTypes(DISubprogram(DS.getNode()));
1574 /// GetOrCreateSourceID - Look up the source id with the given directory and
1575 /// source file names. If none currently exists, create a new id and insert it
1576 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1578 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1580 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1581 if (DI != DirectoryIdMap.end()) {
1582 DId = DI->getValue();
1584 DId = DirectoryNames.size() + 1;
1585 DirectoryIdMap[DirName] = DId;
1586 DirectoryNames.push_back(DirName);
1590 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1591 if (FI != SourceFileIdMap.end()) {
1592 FId = FI->getValue();
1594 FId = SourceFileNames.size() + 1;
1595 SourceFileIdMap[FileName] = FId;
1596 SourceFileNames.push_back(FileName);
1599 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1600 SourceIdMap.find(std::make_pair(DId, FId));
1601 if (SI != SourceIdMap.end())
1604 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1605 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1606 SourceIds.push_back(std::make_pair(DId, FId));
1611 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1612 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1613 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1616 NDie = new DIE(dwarf::DW_TAG_namespace);
1617 ModuleCU->insertDIE(NS.getNode(), NDie);
1618 if (!NS.getName().empty())
1619 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1620 addSourceLine(NDie, &NS);
1621 addToContextOwner(NDie, NS.getContext());
1625 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1626 DICompileUnit DIUnit(N);
1627 StringRef FN = DIUnit.getFilename();
1628 StringRef Dir = DIUnit.getDirectory();
1629 unsigned ID = GetOrCreateSourceID(Dir, FN);
1631 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1632 // FIXME: Why getting the delta between two identical labels??
1633 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1634 getTempLabel("section_line"), getTempLabel("section_line"),
1636 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1637 DIUnit.getProducer());
1638 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1639 DIUnit.getLanguage());
1640 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1643 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1644 if (DIUnit.isOptimized())
1645 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1647 StringRef Flags = DIUnit.getFlags();
1649 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1651 unsigned RVer = DIUnit.getRunTimeVersion();
1653 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1654 dwarf::DW_FORM_data1, RVer);
1656 CompileUnit *Unit = new CompileUnit(ID, Die);
1657 if (!ModuleCU && DIUnit.isMain()) {
1658 // Use first compile unit marked as isMain as the compile unit
1666 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1667 DIGlobalVariable DI_GV(N);
1669 // If debug information is malformed then ignore it.
1670 if (DI_GV.Verify() == false)
1673 // Check for pre-existence.
1674 if (ModuleCU->getDIE(DI_GV.getNode()))
1677 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1682 ModuleCU->insertDIE(N, VariableDie);
1684 // Add to context owner.
1685 DIDescriptor GVContext = DI_GV.getContext();
1686 // Do not create specification DIE if context is either compile unit
1688 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1689 && !GVContext.isSubprogram()) {
1690 // Create specification DIE.
1691 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1692 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1693 dwarf::DW_FORM_ref4, VariableDie);
1694 DIEBlock *Block = new DIEBlock();
1695 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1696 addLabel(Block, 0, dwarf::DW_FORM_udata,
1697 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1698 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1699 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1700 ModuleCU->addDie(VariableSpecDIE);
1702 DIEBlock *Block = new DIEBlock();
1703 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1704 addLabel(Block, 0, dwarf::DW_FORM_udata,
1705 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1706 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1708 addToContextOwner(VariableDie, GVContext);
1710 // Expose as global. FIXME - need to check external flag.
1711 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1713 DIType GTy = DI_GV.getType();
1714 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1715 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1716 assert (Entry && "Missing global type!");
1717 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1722 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1725 // Check for pre-existence.
1726 if (ModuleCU->getDIE(N))
1729 if (!SP.isDefinition())
1730 // This is a method declaration which will be handled while constructing
1734 DIE *SubprogramDie = createSubprogramDIE(SP);
1737 ModuleCU->insertDIE(N, SubprogramDie);
1739 // Add to context owner.
1740 addToContextOwner(SubprogramDie, SP.getContext());
1742 // Expose as global.
1743 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1748 /// beginModule - Emit all Dwarf sections that should come prior to the
1749 /// content. Create global DIEs and emit initial debug info sections.
1750 /// This is inovked by the target AsmPrinter.
1751 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1754 if (TimePassesIsEnabled)
1755 DebugTimer->startTimer();
1757 if (!MAI->doesSupportDebugInformation())
1760 DebugInfoFinder DbgFinder;
1761 DbgFinder.processModule(*M);
1763 // Create all the compile unit DIEs.
1764 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1765 E = DbgFinder.compile_unit_end(); I != E; ++I)
1766 constructCompileUnit(*I);
1771 // Create DIEs for each subprogram.
1772 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1773 E = DbgFinder.subprogram_end(); I != E; ++I)
1774 constructSubprogramDIE(*I);
1776 // Create DIEs for each global variable.
1777 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1778 E = DbgFinder.global_variable_end(); I != E; ++I)
1779 constructGlobalVariableDIE(*I);
1783 MMI->setDebugInfoAvailability(true);
1785 // Prime section data.
1786 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1788 // Print out .file directives to specify files for .loc directives. These are
1789 // printed out early so that they precede any .loc directives.
1790 if (MAI->hasDotLocAndDotFile()) {
1791 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1792 // Remember source id starts at 1.
1793 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1794 // FIXME: don't use sys::path for this! This should not depend on the
1796 sys::Path FullPath(getSourceDirectoryName(Id.first));
1798 FullPath.appendComponent(getSourceFileName(Id.second));
1799 assert(AppendOk && "Could not append filename to directory!");
1801 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1805 // Emit initial sections
1808 if (TimePassesIsEnabled)
1809 DebugTimer->stopTimer();
1812 /// endModule - Emit all Dwarf sections that should come after the content.
1814 void DwarfDebug::endModule() {
1818 if (TimePassesIsEnabled)
1819 DebugTimer->startTimer();
1821 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1822 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1823 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1825 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1828 // Insert top level DIEs.
1829 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1830 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1831 ModuleCU->getCUDie()->addChild(*TI);
1833 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1834 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1835 DIE *SPDie = CI->first;
1836 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1838 DIE *NDie = ModuleCU->getDIE(N);
1839 if (!NDie) continue;
1840 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1841 // FIXME - This is not the correct approach.
1842 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1845 // Standard sections final addresses.
1846 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1847 Asm->OutStreamer.EmitLabel(getTempLabel("text_end"));
1848 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1849 Asm->OutStreamer.EmitLabel(getTempLabel("data_end"));
1851 // End text sections.
1852 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1853 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1854 Asm->OutStreamer.EmitLabel(getDWLabel("section_end", i));
1857 // Emit common frame information.
1858 emitCommonDebugFrame();
1860 // Emit function debug frame information
1861 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1862 E = DebugFrames.end(); I != E; ++I)
1863 emitFunctionDebugFrame(*I);
1865 // Compute DIE offsets and sizes.
1866 computeSizeAndOffsets();
1868 // Emit all the DIEs into a debug info section
1871 // Corresponding abbreviations into a abbrev section.
1872 emitAbbreviations();
1874 // Emit source line correspondence into a debug line section.
1877 // Emit info into a debug pubnames section.
1878 emitDebugPubNames();
1880 // Emit info into a debug pubtypes section.
1881 emitDebugPubTypes();
1883 // Emit info into a debug str section.
1886 // Emit info into a debug loc section.
1889 // Emit info into a debug aranges section.
1892 // Emit info into a debug ranges section.
1895 // Emit info into a debug macinfo section.
1898 // Emit inline info.
1899 emitDebugInlineInfo();
1901 if (TimePassesIsEnabled)
1902 DebugTimer->stopTimer();
1905 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1906 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1908 DILocation &ScopeLoc) {
1910 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1912 return AbsDbgVariable;
1914 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1918 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1919 Scope->addVariable(AbsDbgVariable);
1920 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1921 return AbsDbgVariable;
1924 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1925 void DwarfDebug::collectVariableInfo() {
1928 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1929 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1930 VE = VMap.end(); VI != VE; ++VI) {
1931 MDNode *Var = VI->first;
1933 DIVariable DV (Var);
1934 std::pair< unsigned, MDNode *> VP = VI->second;
1935 DILocation ScopeLoc(VP.second);
1938 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1940 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1941 // If variable scope is not found then skip this variable.
1945 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1946 Scope->addVariable(RegVar);
1947 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1949 RegVar->setAbstractVariable(AbsDbgVariable);
1953 /// beginScope - Process beginning of a scope starting at Label.
1954 void DwarfDebug::beginScope(const MachineInstr *MI, MCSymbol *Label) {
1955 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1956 if (I == DbgScopeBeginMap.end())
1958 ScopeVector &SD = I->second;
1959 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1961 (*SDI)->setStartLabel(Label);
1964 /// endScope - Process end of a scope.
1965 void DwarfDebug::endScope(const MachineInstr *MI) {
1966 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1967 if (I == DbgScopeEndMap.end())
1970 MCSymbol *Label = getDWLabel("label", MMI->NextLabelID());
1971 Asm->OutStreamer.EmitLabel(Label);
1973 SmallVector<DbgScope*, 2> &SD = I->second;
1974 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1976 (*SDI)->setEndLabel(Label);
1980 /// createDbgScope - Create DbgScope for the scope.
1981 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1984 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1987 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1988 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1989 if (DIDescriptor(Scope).isLexicalBlock())
1990 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1994 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1998 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1999 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2000 DILocation DL(InlinedAt);
2001 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2004 /// extractScopeInformation - Scan machine instructions in this function
2005 /// and collect DbgScopes. Return true, if atleast one scope was found.
2006 bool DwarfDebug::extractScopeInformation() {
2007 // If scope information was extracted using .dbg intrinsics then there is not
2008 // any need to extract these information by scanning each instruction.
2009 if (!DbgScopeMap.empty())
2012 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2013 unsigned MIIndex = 0;
2014 // Scan each instruction and create scopes. First build working set of scopes.
2015 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2017 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2019 const MachineInstr *MInsn = II;
2020 MIIndexMap[MInsn] = MIIndex++;
2021 DebugLoc DL = MInsn->getDebugLoc();
2022 if (DL.isUnknown()) continue;
2023 DILocation DLT = MF->getDILocation(DL);
2024 DIScope DLTScope = DLT.getScope();
2025 // There is no need to create another DIE for compile unit. For all
2026 // other scopes, create one DbgScope now. This will be translated
2027 // into a scope DIE at the end.
2028 if (DLTScope.isCompileUnit()) continue;
2029 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2034 // Build scope hierarchy using working set of scopes.
2035 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2037 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2039 const MachineInstr *MInsn = II;
2040 DebugLoc DL = MInsn->getDebugLoc();
2041 if (DL.isUnknown()) continue;
2042 DILocation DLT = MF->getDILocation(DL);
2043 DIScope DLTScope = DLT.getScope();
2044 // There is no need to create another DIE for compile unit. For all
2045 // other scopes, create one DbgScope now. This will be translated
2046 // into a scope DIE at the end.
2047 if (DLTScope.isCompileUnit()) continue;
2048 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2049 DLT.getOrigLocation().getNode());
2050 Scope->setLastInsn(MInsn);
2054 if (!CurrentFnDbgScope)
2057 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2059 // Each scope has first instruction and last instruction to mark beginning
2060 // and end of a scope respectively. Create an inverse map that list scopes
2061 // starts (and ends) with an instruction. One instruction may start (or end)
2062 // multiple scopes. Ignore scopes that are not reachable.
2063 SmallVector<DbgScope *, 4> WorkList;
2064 WorkList.push_back(CurrentFnDbgScope);
2065 while (!WorkList.empty()) {
2066 DbgScope *S = WorkList.back(); WorkList.pop_back();
2068 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2069 if (!Children.empty())
2070 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2071 SE = Children.end(); SI != SE; ++SI)
2072 WorkList.push_back(*SI);
2074 if (S->isAbstractScope())
2076 const MachineInstr *MI = S->getFirstInsn();
2077 assert (MI && "DbgScope does not have first instruction!");
2079 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2080 if (IDI != DbgScopeBeginMap.end())
2081 IDI->second.push_back(S);
2083 DbgScopeBeginMap[MI].push_back(S);
2085 MI = S->getLastInsn();
2086 assert (MI && "DbgScope does not have last instruction!");
2087 IDI = DbgScopeEndMap.find(MI);
2088 if (IDI != DbgScopeEndMap.end())
2089 IDI->second.push_back(S);
2091 DbgScopeEndMap[MI].push_back(S);
2094 return !DbgScopeMap.empty();
2097 /// beginFunction - Gather pre-function debug information. Assumes being
2098 /// emitted immediately after the function entry point.
2099 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2102 if (!ShouldEmitDwarfDebug()) return;
2104 if (TimePassesIsEnabled)
2105 DebugTimer->startTimer();
2107 if (!extractScopeInformation())
2110 collectVariableInfo();
2112 // Assumes in correct section after the entry point.
2113 Asm->OutStreamer.EmitLabel(getDWLabel("func_begin", ++SubprogramCount));
2115 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2117 DebugLoc FDL = MF->getDefaultDebugLoc();
2118 if (!FDL.isUnknown()) {
2119 DILocation DLT = MF->getDILocation(FDL);
2120 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2123 Line = SP.getLineNumber();
2126 Line = DLT.getLineNumber();
2127 Col = DLT.getColumnNumber();
2130 recordSourceLine(Line, Col, DLT.getScope().getNode());
2132 if (TimePassesIsEnabled)
2133 DebugTimer->stopTimer();
2136 /// endFunction - Gather and emit post-function debug information.
2138 void DwarfDebug::endFunction(const MachineFunction *MF) {
2139 if (!ShouldEmitDwarfDebug()) return;
2141 if (TimePassesIsEnabled)
2142 DebugTimer->startTimer();
2144 if (DbgScopeMap.empty())
2147 if (CurrentFnDbgScope) {
2148 // Define end label for subprogram.
2149 Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount));
2151 // Get function line info.
2152 if (!Lines.empty()) {
2153 // Get section line info.
2154 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2155 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2156 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2157 // Append the function info to section info.
2158 SectionLineInfos.insert(SectionLineInfos.end(),
2159 Lines.begin(), Lines.end());
2162 // Construct abstract scopes.
2163 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2164 AE = AbstractScopesList.end(); AI != AE; ++AI)
2165 constructScopeDIE(*AI);
2167 constructScopeDIE(CurrentFnDbgScope);
2169 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2170 MMI->getFrameMoves()));
2174 CurrentFnDbgScope = NULL;
2175 DbgScopeMap.clear();
2176 DbgScopeBeginMap.clear();
2177 DbgScopeEndMap.clear();
2178 ConcreteScopes.clear();
2179 AbstractScopesList.clear();
2182 if (TimePassesIsEnabled)
2183 DebugTimer->stopTimer();
2186 /// recordSourceLine - Register a source line with debug info. Returns the
2187 /// unique label that was emitted and which provides correspondence to
2188 /// the source line list.
2189 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2193 if (TimePassesIsEnabled)
2194 DebugTimer->startTimer();
2199 DIDescriptor Scope(S);
2200 if (Scope.isCompileUnit()) {
2201 DICompileUnit CU(S);
2202 Dir = CU.getDirectory();
2203 Fn = CU.getFilename();
2204 } else if (Scope.isSubprogram()) {
2206 Dir = SP.getDirectory();
2207 Fn = SP.getFilename();
2208 } else if (Scope.isLexicalBlock()) {
2209 DILexicalBlock DB(S);
2210 Dir = DB.getDirectory();
2211 Fn = DB.getFilename();
2213 assert (0 && "Unexpected scope info");
2215 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2216 unsigned ID = MMI->NextLabelID();
2217 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2219 if (TimePassesIsEnabled)
2220 DebugTimer->stopTimer();
2222 MCSymbol *Label = getDWLabel("label", ID);
2223 Asm->OutStreamer.EmitLabel(Label);
2227 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2228 /// timed. Look up the source id with the given directory and source file
2229 /// names. If none currently exists, create a new id and insert it in the
2230 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2232 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2233 const std::string &FileName) {
2234 if (TimePassesIsEnabled)
2235 DebugTimer->startTimer();
2237 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2239 if (TimePassesIsEnabled)
2240 DebugTimer->stopTimer();
2245 //===----------------------------------------------------------------------===//
2247 //===----------------------------------------------------------------------===//
2249 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2252 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2253 // Get the children.
2254 const std::vector<DIE *> &Children = Die->getChildren();
2256 // If not last sibling and has children then add sibling offset attribute.
2257 if (!Last && !Children.empty()) Die->addSiblingOffset();
2259 // Record the abbreviation.
2260 assignAbbrevNumber(Die->getAbbrev());
2262 // Get the abbreviation for this DIE.
2263 unsigned AbbrevNumber = Die->getAbbrevNumber();
2264 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2267 Die->setOffset(Offset);
2269 // Start the size with the size of abbreviation code.
2270 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2272 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2273 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2275 // Size the DIE attribute values.
2276 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2277 // Size attribute value.
2278 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2280 // Size the DIE children if any.
2281 if (!Children.empty()) {
2282 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2283 "Children flag not set");
2285 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2286 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2288 // End of children marker.
2289 Offset += sizeof(int8_t);
2292 Die->setSize(Offset - Die->getOffset());
2296 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2298 void DwarfDebug::computeSizeAndOffsets() {
2299 // Compute size of compile unit header.
2300 static unsigned Offset =
2301 sizeof(int32_t) + // Length of Compilation Unit Info
2302 sizeof(int16_t) + // DWARF version number
2303 sizeof(int32_t) + // Offset Into Abbrev. Section
2304 sizeof(int8_t); // Pointer Size (in bytes)
2306 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2307 CompileUnitOffsets[ModuleCU] = 0;
2310 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2311 /// tools to recognize the object file contains Dwarf information.
2312 void DwarfDebug::emitInitial() {
2313 // Check to see if we already emitted intial headers.
2314 if (didInitial) return;
2317 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2319 // Dwarf sections base addresses.
2320 if (MAI->doesDwarfRequireFrameSection()) {
2321 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2322 Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame"));
2325 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2326 Asm->OutStreamer.EmitLabel(getTempLabel("section_info"));
2327 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2328 Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev"));
2329 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2330 Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges"));
2332 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2333 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2334 Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo"));
2337 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2338 Asm->OutStreamer.EmitLabel(getTempLabel("section_line"));
2339 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2340 Asm->OutStreamer.EmitLabel(getTempLabel("section_loc"));
2341 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2342 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames"));
2343 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2344 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes"));
2345 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2346 Asm->OutStreamer.EmitLabel(getTempLabel("section_str"));
2347 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2348 Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges"));
2350 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2351 Asm->OutStreamer.EmitLabel(getTempLabel("text_begin"));
2352 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2353 Asm->OutStreamer.EmitLabel(getTempLabel("data_begin"));
2356 /// emitDIE - Recusively Emits a debug information entry.
2358 void DwarfDebug::emitDIE(DIE *Die) {
2359 // Get the abbreviation for this DIE.
2360 unsigned AbbrevNumber = Die->getAbbrevNumber();
2361 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2363 // Emit the code (index) for the abbreviation.
2364 if (Asm->VerboseAsm)
2365 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2366 Twine::utohexstr(Die->getOffset()) + ":0x" +
2367 Twine::utohexstr(Die->getSize()) + " " +
2368 dwarf::TagString(Abbrev->getTag()));
2369 EmitULEB128(AbbrevNumber);
2371 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2372 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2374 // Emit the DIE attribute values.
2375 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2376 unsigned Attr = AbbrevData[i].getAttribute();
2377 unsigned Form = AbbrevData[i].getForm();
2378 assert(Form && "Too many attributes for DIE (check abbreviation)");
2380 if (Asm->VerboseAsm)
2381 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2384 case dwarf::DW_AT_sibling:
2385 Asm->EmitInt32(Die->getSiblingOffset());
2387 case dwarf::DW_AT_abstract_origin: {
2388 DIEEntry *E = cast<DIEEntry>(Values[i]);
2389 DIE *Origin = E->getEntry();
2390 unsigned Addr = Origin->getOffset();
2391 Asm->EmitInt32(Addr);
2395 // Emit an attribute using the defined form.
2396 Values[i]->EmitValue(this, Form);
2401 // Emit the DIE children if any.
2402 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2403 const std::vector<DIE *> &Children = Die->getChildren();
2405 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2406 emitDIE(Children[j]);
2408 Asm->EmitInt8(0); EOL("End Of Children Mark");
2412 /// emitDebugInfo - Emit the debug info section.
2414 void DwarfDebug::emitDebugInfo() {
2415 // Start debug info section.
2416 Asm->OutStreamer.SwitchSection(
2417 Asm->getObjFileLowering().getDwarfInfoSection());
2418 DIE *Die = ModuleCU->getCUDie();
2420 // Emit the compile units header.
2421 Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID()));
2423 // Emit size of content not including length itself
2424 unsigned ContentSize = Die->getSize() +
2425 sizeof(int16_t) + // DWARF version number
2426 sizeof(int32_t) + // Offset Into Abbrev. Section
2427 sizeof(int8_t) + // Pointer Size (in bytes)
2428 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2430 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2431 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2432 EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"),
2434 EOL("Offset Into Abbrev. Section");
2435 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2438 // FIXME - extra padding for gdb bug.
2439 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2440 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2441 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2442 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2443 Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID()));
2446 /// emitAbbreviations - Emit the abbreviation section.
2448 void DwarfDebug::emitAbbreviations() const {
2449 // Check to see if it is worth the effort.
2450 if (!Abbreviations.empty()) {
2451 // Start the debug abbrev section.
2452 Asm->OutStreamer.SwitchSection(
2453 Asm->getObjFileLowering().getDwarfAbbrevSection());
2455 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin"));
2457 // For each abbrevation.
2458 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2459 // Get abbreviation data
2460 const DIEAbbrev *Abbrev = Abbreviations[i];
2462 // Emit the abbrevations code (base 1 index.)
2463 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2465 // Emit the abbreviations data.
2469 // Mark end of abbreviations.
2470 EmitULEB128(0, "EOM(3)");
2472 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end"));
2476 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2477 /// the line matrix.
2479 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2480 // Define last address of section.
2481 Asm->EmitInt8(0); EOL("Extended Op");
2482 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2483 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2484 EmitReference(getDWLabel("section_end", SectionEnd));
2485 EOL("Section end label");
2487 // Mark end of matrix.
2488 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2493 /// emitDebugLines - Emit source line information.
2495 void DwarfDebug::emitDebugLines() {
2496 // If the target is using .loc/.file, the assembler will be emitting the
2497 // .debug_line table automatically.
2498 if (MAI->hasDotLocAndDotFile())
2501 // Minimum line delta, thus ranging from -10..(255-10).
2502 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2503 // Maximum line delta, thus ranging from -10..(255-10).
2504 const int MaxLineDelta = 255 + MinLineDelta;
2506 // Start the dwarf line section.
2507 Asm->OutStreamer.SwitchSection(
2508 Asm->getObjFileLowering().getDwarfLineSection());
2510 // Construct the section header.
2511 EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true);
2512 EOL("Length of Source Line Info");
2513 Asm->OutStreamer.EmitLabel(getTempLabel("line_begin"));
2515 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2517 EmitDifference(getTempLabel("line_prolog_end"),
2518 getTempLabel("line_prolog_begin"), true);
2519 EOL("Prolog Length");
2520 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin"));
2522 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2523 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2524 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2525 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2526 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2528 // Line number standard opcode encodings argument count
2529 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2530 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2531 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2532 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2533 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2534 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2535 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2536 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2537 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2539 // Emit directories.
2540 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2541 const std::string &Dir = getSourceDirectoryName(DI);
2542 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2543 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2546 Asm->EmitInt8(0); EOL("End of directories");
2549 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2550 // Remember source id starts at 1.
2551 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2552 const std::string &FN = getSourceFileName(Id.second);
2553 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2554 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2556 EmitULEB128(Id.first, "Directory #");
2557 EmitULEB128(0, "Mod date");
2558 EmitULEB128(0, "File size");
2561 Asm->EmitInt8(0); EOL("End of files");
2563 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end"));
2565 // A sequence for each text section.
2566 unsigned SecSrcLinesSize = SectionSourceLines.size();
2568 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2569 // Isolate current sections line info.
2570 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2572 /*if (Asm->isVerbose()) {
2573 const MCSection *S = SectionMap[j + 1];
2574 O << '\t' << MAI->getCommentString() << " Section"
2575 << S->getName() << '\n';
2578 // Dwarf assumes we start with first line of first source file.
2579 unsigned Source = 1;
2582 // Construct rows of the address, source, line, column matrix.
2583 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2584 const SrcLineInfo &LineInfo = LineInfos[i];
2585 unsigned LabelID = LineInfo.getLabelID();
2586 if (MMI->isLabelDeleted(LabelID)) continue;
2588 if (LineInfo.getLine() == 0) continue;
2590 if (Asm->isVerbose()) {
2591 std::pair<unsigned, unsigned> SourceID =
2592 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2593 O << '\t' << MAI->getCommentString() << ' '
2594 << getSourceDirectoryName(SourceID.first) << '/'
2595 << getSourceFileName(SourceID.second)
2596 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2599 // Define the line address.
2600 Asm->EmitInt8(0); EOL("Extended Op");
2601 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2602 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2603 EmitReference(getDWLabel("label", LabelID)); EOL("Location label");
2605 // If change of source, then switch to the new source.
2606 if (Source != LineInfo.getSourceID()) {
2607 Source = LineInfo.getSourceID();
2608 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2609 EmitULEB128(Source, "New Source");
2612 // If change of line.
2613 if (Line != LineInfo.getLine()) {
2614 // Determine offset.
2615 int Offset = LineInfo.getLine() - Line;
2616 int Delta = Offset - MinLineDelta;
2619 Line = LineInfo.getLine();
2621 // If delta is small enough and in range...
2622 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2623 // ... then use fast opcode.
2624 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2626 // ... otherwise use long hand.
2627 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2628 EOL("DW_LNS_advance_line");
2629 EmitSLEB128(Offset, "Line Offset");
2630 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2633 // Copy the previous row (different address or source)
2634 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2638 emitEndOfLineMatrix(j + 1);
2641 if (SecSrcLinesSize == 0)
2642 // Because we're emitting a debug_line section, we still need a line
2643 // table. The linker and friends expect it to exist. If there's nothing to
2644 // put into it, emit an empty table.
2645 emitEndOfLineMatrix(1);
2647 Asm->OutStreamer.EmitLabel(getTempLabel("line_end"));
2650 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2652 void DwarfDebug::emitCommonDebugFrame() {
2653 if (!MAI->doesDwarfRequireFrameSection())
2657 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2658 TargetFrameInfo::StackGrowsUp ?
2659 TD->getPointerSize() : -TD->getPointerSize();
2661 // Start the dwarf frame section.
2662 Asm->OutStreamer.SwitchSection(
2663 Asm->getObjFileLowering().getDwarfFrameSection());
2665 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common"));
2666 EmitDifference(getTempLabel("debug_frame_common_end"),
2667 getTempLabel("debug_frame_common_begin"), true);
2668 EOL("Length of Common Information Entry");
2670 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin"));
2671 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2672 EOL("CIE Identifier Tag");
2673 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2675 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2676 EOL("CIE Augmentation");
2677 EmitULEB128(1, "CIE Code Alignment Factor");
2678 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2679 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2680 EOL("CIE RA Column");
2682 std::vector<MachineMove> Moves;
2683 RI->getInitialFrameState(Moves);
2685 EmitFrameMoves(NULL, 0, Moves, false);
2687 Asm->EmitAlignment(2, 0, 0, false);
2688 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end"));
2691 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2694 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2695 if (!MAI->doesDwarfRequireFrameSection())
2698 // Start the dwarf frame section.
2699 Asm->OutStreamer.SwitchSection(
2700 Asm->getObjFileLowering().getDwarfFrameSection());
2702 EmitDifference(getDWLabel("debug_frame_end", DebugFrameInfo.Number),
2703 getDWLabel("debug_frame_begin", DebugFrameInfo.Number), true);
2704 EOL("Length of Frame Information Entry");
2706 Asm->OutStreamer.EmitLabel(getDWLabel("debug_frame_begin",
2707 DebugFrameInfo.Number));
2709 EmitSectionOffset(getTempLabel("debug_frame_common"),
2710 getTempLabel("section_debug_frame"), true, false);
2711 EOL("FDE CIE offset");
2713 EmitReference(getDWLabel("func_begin", DebugFrameInfo.Number));
2714 EOL("FDE initial location");
2715 EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number),
2716 getDWLabel("func_begin", DebugFrameInfo.Number));
2717 EOL("FDE address range");
2719 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2722 Asm->EmitAlignment(2, 0, 0, false);
2723 Asm->OutStreamer.EmitLabel(getDWLabel("debug_frame_end",
2724 DebugFrameInfo.Number));
2727 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2729 void DwarfDebug::emitDebugPubNames() {
2730 // Start the dwarf pubnames section.
2731 Asm->OutStreamer.SwitchSection(
2732 Asm->getObjFileLowering().getDwarfPubNamesSection());
2734 EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()),
2735 getDWLabel("pubnames_begin", ModuleCU->getID()), true);
2736 EOL("Length of Public Names Info");
2738 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID()));
2740 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2742 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2743 getTempLabel("section_info"),
2745 EOL("Offset of Compilation Unit Info");
2747 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2748 getDWLabel("info_begin", ModuleCU->getID()),
2750 EOL("Compilation Unit Length");
2752 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2753 for (StringMap<DIE*>::const_iterator
2754 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2755 const char *Name = GI->getKeyData();
2756 DIE * Entity = GI->second;
2758 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2760 if (Asm->VerboseAsm)
2761 Asm->OutStreamer.AddComment("External Name");
2762 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2765 Asm->EmitInt32(0); EOL("End Mark");
2766 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID()));
2769 void DwarfDebug::emitDebugPubTypes() {
2770 // Start the dwarf pubnames section.
2771 Asm->OutStreamer.SwitchSection(
2772 Asm->getObjFileLowering().getDwarfPubTypesSection());
2773 EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()),
2774 getDWLabel("pubtypes_begin", ModuleCU->getID()), true);
2775 EOL("Length of Public Types Info");
2777 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID()));
2779 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2780 Asm->EmitInt16(dwarf::DWARF_VERSION);
2782 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2783 getTempLabel("section_info"), true, false);
2784 EOL("Offset of Compilation ModuleCU Info");
2786 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2787 getDWLabel("info_begin", ModuleCU->getID()),
2789 EOL("Compilation ModuleCU Length");
2791 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2792 for (StringMap<DIE*>::const_iterator
2793 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2794 const char *Name = GI->getKeyData();
2795 DIE * Entity = GI->second;
2797 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2798 Asm->EmitInt32(Entity->getOffset());
2800 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2801 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2804 Asm->EmitInt32(0); EOL("End Mark");
2805 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID()));
2808 /// emitDebugStr - Emit visible names into a debug str section.
2810 void DwarfDebug::emitDebugStr() {
2811 // Check to see if it is worth the effort.
2812 if (StringPool.empty()) return;
2814 // Start the dwarf str section.
2815 Asm->OutStreamer.SwitchSection(
2816 Asm->getObjFileLowering().getDwarfStrSection());
2818 // For each of strings in the string pool.
2819 for (unsigned StringID = 1, N = StringPool.size(); StringID <= N; ++StringID){
2820 // Emit a label for reference from debug information entries.
2821 Asm->OutStreamer.EmitLabel(getDWLabel("string", StringID));
2823 // Emit the string itself.
2824 const std::string &String = StringPool[StringID];
2825 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2829 /// emitDebugLoc - Emit visible names into a debug loc section.
2831 void DwarfDebug::emitDebugLoc() {
2832 // Start the dwarf loc section.
2833 Asm->OutStreamer.SwitchSection(
2834 Asm->getObjFileLowering().getDwarfLocSection());
2837 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2839 void DwarfDebug::EmitDebugARanges() {
2840 // Start the dwarf aranges section.
2841 Asm->OutStreamer.SwitchSection(
2842 Asm->getObjFileLowering().getDwarfARangesSection());
2846 CompileUnit *Unit = GetBaseCompileUnit();
2848 // Don't include size of length
2849 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2851 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2853 EmitReference("info_begin", Unit->getID());
2854 EOL("Offset of Compilation Unit Info");
2856 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2858 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2860 Asm->EmitInt16(0); EOL("Pad (1)");
2861 Asm->EmitInt16(0); EOL("Pad (2)");
2864 EmitReference("text_begin", 0); EOL("Address");
2865 EmitDifference(getTempLabel("text_end"), getTempLabel("text_begin"),
2866 true); EOL("Length");
2868 Asm->EmitInt32(0); EOL("EOM (1)");
2869 Asm->EmitInt32(0); EOL("EOM (2)");
2873 /// emitDebugRanges - Emit visible names into a debug ranges section.
2875 void DwarfDebug::emitDebugRanges() {
2876 // Start the dwarf ranges section.
2877 Asm->OutStreamer.SwitchSection(
2878 Asm->getObjFileLowering().getDwarfRangesSection());
2881 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2883 void DwarfDebug::emitDebugMacInfo() {
2884 if (const MCSection *LineInfo =
2885 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2886 // Start the dwarf macinfo section.
2887 Asm->OutStreamer.SwitchSection(LineInfo);
2891 /// emitDebugInlineInfo - Emit inline info using following format.
2893 /// 1. length of section
2894 /// 2. Dwarf version number
2895 /// 3. address size.
2897 /// Entries (one "entry" for each function that was inlined):
2899 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2900 /// otherwise offset into __debug_str for regular function name.
2901 /// 2. offset into __debug_str section for regular function name.
2902 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2903 /// instances for the function.
2905 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2906 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2907 /// __debug_info section, and the low_pc is the starting address for the
2908 /// inlining instance.
2909 void DwarfDebug::emitDebugInlineInfo() {
2910 if (!MAI->doesDwarfUsesInlineInfoSection())
2916 Asm->OutStreamer.SwitchSection(
2917 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2919 EmitDifference(getDWLabel("debug_inlined_end", 1),
2920 getDWLabel("debug_inlined_begin", 1), true);
2921 EOL("Length of Debug Inlined Information Entry");
2923 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1));
2925 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2926 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2928 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2929 E = InlinedSPNodes.end(); I != E; ++I) {
2932 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2933 = InlineInfo.find(Node);
2934 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2935 DISubprogram SP(Node);
2936 StringRef LName = SP.getLinkageName();
2937 StringRef Name = SP.getName();
2939 if (LName.empty()) {
2940 Asm->OutStreamer.EmitBytes(Name, 0);
2941 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2943 EmitSectionOffset(getDWLabel("string",
2944 StringPool.idFor(getRealLinkageName(LName))),
2945 getTempLabel("section_str"), true);
2947 EOL("MIPS linkage name");
2948 EmitSectionOffset(getDWLabel("string", StringPool.idFor(Name)),
2949 getTempLabel("section_str"), false, true);
2950 EOL("Function name");
2951 EmitULEB128(Labels.size(), "Inline count");
2953 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2954 LE = Labels.end(); LI != LE; ++LI) {
2955 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2956 Asm->EmitInt32(LI->second->getOffset());
2958 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("low_pc");
2959 Asm->OutStreamer.EmitSymbolValue(LI->first, TD->getPointerSize(), 0);
2963 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1));