DwarfDebug.cpp revision d8cc5d5256e79a74188dfef5a12d43127330dad3
1//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for writing dwarf debug info into asm files.
11//
12//===----------------------------------------------------------------------===//
13#define DEBUG_TYPE "dwarfdebug"
14#include "DwarfDebug.h"
15#include "llvm/Module.h"
16#include "llvm/CodeGen/MachineFunction.h"
17#include "llvm/CodeGen/MachineModuleInfo.h"
18#include "llvm/MC/MCSection.h"
19#include "llvm/MC/MCStreamer.h"
20#include "llvm/MC/MCAsmInfo.h"
21#include "llvm/Target/Mangler.h"
22#include "llvm/Target/TargetData.h"
23#include "llvm/Target/TargetFrameInfo.h"
24#include "llvm/Target/TargetLoweringObjectFile.h"
25#include "llvm/Target/TargetRegisterInfo.h"
26#include "llvm/ADT/StringExtras.h"
27#include "llvm/Support/Debug.h"
28#include "llvm/Support/ErrorHandling.h"
29#include "llvm/Support/ValueHandle.h"
30#include "llvm/Support/FormattedStream.h"
31#include "llvm/Support/Timer.h"
32#include "llvm/System/Path.h"
33using namespace llvm;
34
35//===----------------------------------------------------------------------===//
36
37/// Configuration values for initial hash set sizes (log2).
38///
39static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
40
41namespace llvm {
42
43//===----------------------------------------------------------------------===//
44/// CompileUnit - This dwarf writer support class manages information associate
45/// with a source file.
46class CompileUnit {
47  /// ID - File identifier for source.
48  ///
49  unsigned ID;
50
51  /// Die - Compile unit debug information entry.
52  ///
53  DIE *CUDie;
54
55  /// IndexTyDie - An anonymous type for index type.
56  DIE *IndexTyDie;
57
58  /// GVToDieMap - Tracks the mapping of unit level debug informaton
59  /// variables to debug information entries.
60  /// FIXME : Rename GVToDieMap -> NodeToDieMap
61  DenseMap<MDNode *, DIE *> GVToDieMap;
62
63  /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
64  /// descriptors to debug information entries using a DIEEntry proxy.
65  /// FIXME : Rename
66  DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
67
68  /// Globals - A map of globally visible named entities for this unit.
69  ///
70  StringMap<DIE*> Globals;
71
72  /// GlobalTypes - A map of globally visible types for this unit.
73  ///
74  StringMap<DIE*> GlobalTypes;
75
76public:
77  CompileUnit(unsigned I, DIE *D)
78    : ID(I), CUDie(D), IndexTyDie(0) {}
79  ~CompileUnit() { delete CUDie; delete IndexTyDie; }
80
81  // Accessors.
82  unsigned getID()                  const { return ID; }
83  DIE* getCUDie()                   const { return CUDie; }
84  const StringMap<DIE*> &getGlobals()     const { return Globals; }
85  const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
86
87  /// hasContent - Return true if this compile unit has something to write out.
88  ///
89  bool hasContent() const { return !CUDie->getChildren().empty(); }
90
91  /// addGlobal - Add a new global entity to the compile unit.
92  ///
93  void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
94
95  /// addGlobalType - Add a new global type to the compile unit.
96  ///
97  void addGlobalType(const std::string &Name, DIE *Die) {
98    GlobalTypes[Name] = Die;
99  }
100
101  /// getDIE - Returns the debug information entry map slot for the
102  /// specified debug variable.
103  DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
104
105  /// insertDIE - Insert DIE into the map.
106  void insertDIE(MDNode *N, DIE *D) {
107    GVToDieMap.insert(std::make_pair(N, D));
108  }
109
110  /// getDIEEntry - Returns the debug information entry for the speciefied
111  /// debug variable.
112  DIEEntry *getDIEEntry(MDNode *N) {
113    DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
114    if (I == GVToDIEEntryMap.end())
115      return NULL;
116    return I->second;
117  }
118
119  /// insertDIEEntry - Insert debug information entry into the map.
120  void insertDIEEntry(MDNode *N, DIEEntry *E) {
121    GVToDIEEntryMap.insert(std::make_pair(N, E));
122  }
123
124  /// addDie - Adds or interns the DIE to the compile unit.
125  ///
126  void addDie(DIE *Buffer) {
127    this->CUDie->addChild(Buffer);
128  }
129
130  // getIndexTyDie - Get an anonymous type for index type.
131  DIE *getIndexTyDie() {
132    return IndexTyDie;
133  }
134
135  // setIndexTyDie - Set D as anonymous type for index which can be reused
136  // later.
137  void setIndexTyDie(DIE *D) {
138    IndexTyDie = D;
139  }
140
141};
142
143//===----------------------------------------------------------------------===//
144/// DbgVariable - This class is used to track local variable information.
145///
146class DbgVariable {
147  DIVariable Var;                    // Variable Descriptor.
148  unsigned FrameIndex;               // Variable frame index.
149  DbgVariable *AbstractVar;          // Abstract variable for this variable.
150  DIE *TheDIE;
151public:
152  DbgVariable(DIVariable V, unsigned I)
153    : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0)  {}
154
155  // Accessors.
156  DIVariable getVariable()           const { return Var; }
157  unsigned getFrameIndex()           const { return FrameIndex; }
158  void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
159  DbgVariable *getAbstractVariable() const { return AbstractVar; }
160  void setDIE(DIE *D)                      { TheDIE = D; }
161  DIE *getDIE()                      const { return TheDIE; }
162};
163
164//===----------------------------------------------------------------------===//
165/// DbgScope - This class is used to track scope information.
166///
167class DbgScope {
168  DbgScope *Parent;                   // Parent to this scope.
169  DIDescriptor Desc;                  // Debug info descriptor for scope.
170  // Location at which this scope is inlined.
171  AssertingVH<MDNode> InlinedAtLocation;
172  bool AbstractScope;                 // Abstract Scope
173  unsigned StartLabelID;              // Label ID of the beginning of scope.
174  unsigned EndLabelID;                // Label ID of the end of scope.
175  const MachineInstr *LastInsn;       // Last instruction of this scope.
176  const MachineInstr *FirstInsn;      // First instruction of this scope.
177  SmallVector<DbgScope *, 4> Scopes;  // Scopes defined in scope.
178  SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
179
180  // Private state for dump()
181  mutable unsigned IndentLevel;
182public:
183  DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
184    : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
185      StartLabelID(0), EndLabelID(0),
186      LastInsn(0), FirstInsn(0), IndentLevel(0) {}
187  virtual ~DbgScope();
188
189  // Accessors.
190  DbgScope *getParent()          const { return Parent; }
191  void setParent(DbgScope *P)          { Parent = P; }
192  DIDescriptor getDesc()         const { return Desc; }
193  MDNode *getInlinedAt()         const {
194    return InlinedAtLocation;
195  }
196  MDNode *getScopeNode()         const { return Desc.getNode(); }
197  unsigned getStartLabelID()     const { return StartLabelID; }
198  unsigned getEndLabelID()       const { return EndLabelID; }
199  SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
200  SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
201  void setStartLabelID(unsigned S) { StartLabelID = S; }
202  void setEndLabelID(unsigned E)   { EndLabelID = E; }
203  void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
204  const MachineInstr *getLastInsn()      { return LastInsn; }
205  void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
206  void setAbstractScope() { AbstractScope = true; }
207  bool isAbstractScope() const { return AbstractScope; }
208  const MachineInstr *getFirstInsn()      { return FirstInsn; }
209
210  /// addScope - Add a scope to the scope.
211  ///
212  void addScope(DbgScope *S) { Scopes.push_back(S); }
213
214  /// addVariable - Add a variable to the scope.
215  ///
216  void addVariable(DbgVariable *V) { Variables.push_back(V); }
217
218  void fixInstructionMarkers(DenseMap<const MachineInstr *,
219                             unsigned> &MIIndexMap) {
220    assert (getFirstInsn() && "First instruction is missing!");
221
222    // Use the end of last child scope as end of this scope.
223    SmallVector<DbgScope *, 4> &Scopes = getScopes();
224    const MachineInstr *LastInsn = getFirstInsn();
225    unsigned LIndex = 0;
226    if (Scopes.empty()) {
227      assert (getLastInsn() && "Inner most scope does not have last insn!");
228      return;
229    }
230    for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
231           SE = Scopes.end(); SI != SE; ++SI) {
232      DbgScope *DS = *SI;
233      DS->fixInstructionMarkers(MIIndexMap);
234      const MachineInstr *DSLastInsn = DS->getLastInsn();
235      unsigned DSI = MIIndexMap[DSLastInsn];
236      if (DSI > LIndex) {
237        LastInsn = DSLastInsn;
238        LIndex = DSI;
239      }
240    }
241
242    unsigned CurrentLastInsnIndex = 0;
243    if (const MachineInstr *CL = getLastInsn())
244      CurrentLastInsnIndex = MIIndexMap[CL];
245    unsigned FIndex = MIIndexMap[getFirstInsn()];
246
247    // Set LastInsn as the last instruction for this scope only if
248    // it follows
249    //  1) this scope's first instruction and
250    //  2) current last instruction for this scope, if any.
251    if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
252      setLastInsn(LastInsn);
253  }
254
255#ifndef NDEBUG
256  void dump() const;
257#endif
258};
259
260#ifndef NDEBUG
261void DbgScope::dump() const {
262  raw_ostream &err = dbgs();
263  err.indent(IndentLevel);
264  MDNode *N = Desc.getNode();
265  N->dump();
266  err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
267  if (AbstractScope)
268    err << "Abstract Scope\n";
269
270  IndentLevel += 2;
271  if (!Scopes.empty())
272    err << "Children ...\n";
273  for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
274    if (Scopes[i] != this)
275      Scopes[i]->dump();
276
277  IndentLevel -= 2;
278}
279#endif
280
281DbgScope::~DbgScope() {
282  for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
283    delete Scopes[i];
284  for (unsigned j = 0, M = Variables.size(); j < M; ++j)
285    delete Variables[j];
286}
287
288} // end llvm namespace
289
290DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
291  : DwarfPrinter(OS, A, T, "dbg"), ModuleCU(0),
292    AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
293    DIEValues(), StringPool(),
294    SectionSourceLines(), didInitial(false), shouldEmit(false),
295    CurrentFnDbgScope(0), DebugTimer(0) {
296  if (TimePassesIsEnabled)
297    DebugTimer = new Timer("Dwarf Debug Writer");
298}
299DwarfDebug::~DwarfDebug() {
300  for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
301    delete DIEValues[j];
302
303  delete DebugTimer;
304}
305
306/// assignAbbrevNumber - Define a unique number for the abbreviation.
307///
308void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
309  // Profile the node so that we can make it unique.
310  FoldingSetNodeID ID;
311  Abbrev.Profile(ID);
312
313  // Check the set for priors.
314  DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
315
316  // If it's newly added.
317  if (InSet == &Abbrev) {
318    // Add to abbreviation list.
319    Abbreviations.push_back(&Abbrev);
320
321    // Assign the vector position + 1 as its number.
322    Abbrev.setNumber(Abbreviations.size());
323  } else {
324    // Assign existing abbreviation number.
325    Abbrev.setNumber(InSet->getNumber());
326  }
327}
328
329/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
330/// information entry.
331DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
332  DIEEntry *Value = new DIEEntry(Entry);
333  DIEValues.push_back(Value);
334  return Value;
335}
336
337/// addUInt - Add an unsigned integer attribute data and value.
338///
339void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
340                         unsigned Form, uint64_t Integer) {
341  if (!Form) Form = DIEInteger::BestForm(false, Integer);
342  DIEValue *Value = new DIEInteger(Integer);
343  DIEValues.push_back(Value);
344  Die->addValue(Attribute, Form, Value);
345}
346
347/// addSInt - Add an signed integer attribute data and value.
348///
349void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
350                         unsigned Form, int64_t Integer) {
351  if (!Form) Form = DIEInteger::BestForm(true, Integer);
352  DIEValue *Value = new DIEInteger(Integer);
353  DIEValues.push_back(Value);
354  Die->addValue(Attribute, Form, Value);
355}
356
357/// addString - Add a string attribute data and value. DIEString only
358/// keeps string reference.
359void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
360                           StringRef String) {
361  DIEValue *Value = new DIEString(String);
362  DIEValues.push_back(Value);
363  Die->addValue(Attribute, Form, Value);
364}
365
366/// addLabel - Add a Dwarf label attribute data and value.
367///
368void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
369                          const DWLabel &Label) {
370  DIEValue *Value = new DIEDwarfLabel(Label);
371  DIEValues.push_back(Value);
372  Die->addValue(Attribute, Form, Value);
373}
374
375/// addObjectLabel - Add an non-Dwarf label attribute data and value.
376///
377void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
378                                const MCSymbol *Sym) {
379  DIEValue *Value = new DIEObjectLabel(Sym);
380  DIEValues.push_back(Value);
381  Die->addValue(Attribute, Form, Value);
382}
383
384/// addSectionOffset - Add a section offset label attribute data and value.
385///
386void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
387                                  const DWLabel &Label, const DWLabel &Section,
388                                  bool isEH, bool useSet) {
389  DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
390  DIEValues.push_back(Value);
391  Die->addValue(Attribute, Form, Value);
392}
393
394/// addDelta - Add a label delta attribute data and value.
395///
396void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
397                          const DWLabel &Hi, const DWLabel &Lo) {
398  DIEValue *Value = new DIEDelta(Hi, Lo);
399  DIEValues.push_back(Value);
400  Die->addValue(Attribute, Form, Value);
401}
402
403/// addBlock - Add block data.
404///
405void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
406                          DIEBlock *Block) {
407  Block->ComputeSize(TD);
408  DIEValues.push_back(Block);
409  Die->addValue(Attribute, Block->BestForm(), Block);
410}
411
412/// addSourceLine - Add location information to specified debug information
413/// entry.
414void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
415  // If there is no compile unit specified, don't add a line #.
416  if (!V->getCompileUnit().Verify())
417    return;
418
419  unsigned Line = V->getLineNumber();
420  unsigned FileID = findCompileUnit(V->getCompileUnit())->getID();
421  assert(FileID && "Invalid file id");
422  addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
423  addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
424}
425
426/// addSourceLine - Add location information to specified debug information
427/// entry.
428void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
429  // If there is no compile unit specified, don't add a line #.
430  if (!G->getCompileUnit().Verify())
431    return;
432
433  unsigned Line = G->getLineNumber();
434  unsigned FileID = findCompileUnit(G->getCompileUnit())->getID();
435  assert(FileID && "Invalid file id");
436  addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
437  addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
438}
439
440/// addSourceLine - Add location information to specified debug information
441/// entry.
442void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
443  // If there is no compile unit specified, don't add a line #.
444  if (!SP->getCompileUnit().Verify())
445    return;
446  // If the line number is 0, don't add it.
447  if (SP->getLineNumber() == 0)
448    return;
449
450
451  unsigned Line = SP->getLineNumber();
452  unsigned FileID = findCompileUnit(SP->getCompileUnit())->getID();
453  assert(FileID && "Invalid file id");
454  addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
455  addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
456}
457
458/// addSourceLine - Add location information to specified debug information
459/// entry.
460void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
461  // If there is no compile unit specified, don't add a line #.
462  DICompileUnit CU = Ty->getCompileUnit();
463  if (!CU.Verify())
464    return;
465
466  unsigned Line = Ty->getLineNumber();
467  unsigned FileID = findCompileUnit(CU)->getID();
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);
471}
472
473/// addSourceLine - Add location information to specified debug information
474/// entry.
475void 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())
478    return;
479
480  unsigned Line = NS->getLineNumber();
481  StringRef FN = NS->getFilename();
482  StringRef Dir = NS->getDirectory();
483
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);
488}
489
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.
496
497   However, as far as the original *programmer* is concerned, the
498   variable should still have type 'SomeType', as originally declared.
499
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.
505
506   The original type 'SomeType' will be the type of the field named
507   'VarName' inside the __Block_byref_x_VarName struct.
508
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.  */
514
515/// Find the type the programmer originally declared the variable to be
516/// and return that type.
517///
518DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
519
520  DIType subType = Ty;
521  unsigned tag = Ty.getTag();
522
523  if (tag == dwarf::DW_TAG_pointer_type) {
524    DIDerivedType DTy = DIDerivedType(Ty.getNode());
525    subType = DTy.getTypeDerivedFrom();
526  }
527
528  DICompositeType blockStruct = DICompositeType(subType.getNode());
529  DIArray Elements = blockStruct.getTypeArray();
530
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());
536  }
537
538  return Ty;
539}
540
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.
545///
546void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
547                                   unsigned Attribute,
548                                   const MachineLocation &Location) {
549  const DIVariable &VD = DV->getVariable();
550  DIType Ty = VD.getType();
551
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();
556
557  if (Location.isReg()) {
558    if (Reg < 32) {
559      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
560    } else {
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);
564    }
565  } else {
566    if (Reg < 32)
567      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
568    else {
569      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
570      addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
571    }
572
573    addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
574  }
575
576  for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
577    uint64_t Element = VD.getAddrElement(i);
578
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");
585  }
586
587  // Now attach the location information to the DIE.
588  addBlock(Die, Attribute, 0, Block);
589}
590
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.
596
597   However, as far as the original *programmer* is concerned, the variable
598   should still have type 'SomeType', as originally declared.
599
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.
607
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.
612
613   The struct will look something like:
614
615   struct __Block_byref_x_VarName {
616     ... <various fields>
617     struct __Block_byref_x_VarName *forwarding;
618     ... <various other fields>
619     SomeType VarName;
620     ... <maybe more fields>
621   };
622
623   If we are given the struct directly (as our starting point) we
624   need to tell the debugger to:
625
626   1).  Add the offset of the forwarding field.
627
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).
630
631   3).  Add the offset for the field VarName, to find the actual variable.
632
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:
637
638   DW_OP_deref                    -- optional, if we start with a pointer
639   DW_OP_plus_uconst <forward_fld_offset>
640   DW_OP_deref
641   DW_OP_plus_uconst <varName_fld_offset>
642
643   That is what this function does.  */
644
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.
650///
651void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
652                                      unsigned Attribute,
653                                      const MachineLocation &Location) {
654  const DIVariable &VD = DV->getVariable();
655  DIType Ty = VD.getType();
656  DIType TmpTy = Ty;
657  unsigned Tag = Ty.getTag();
658  bool isPointer = false;
659
660  StringRef varName = VD.getName();
661
662  if (Tag == dwarf::DW_TAG_pointer_type) {
663    DIDerivedType DTy = DIDerivedType(Ty.getNode());
664    TmpTy = DTy.getTypeDerivedFrom();
665    isPointer = true;
666  }
667
668  DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
669
670  // Find the __forwarding field and the variable field in the __Block_byref
671  // struct.
672  DIArray Fields = blockStruct.getTypeArray();
673  DIDescriptor varField = DIDescriptor();
674  DIDescriptor forwardingField = DIDescriptor();
675
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)
683      varField = Element;
684  }
685
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;
691
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();
696
697  if (Location.isReg()) {
698    if (Reg < 32)
699      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
700    else {
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);
704    }
705  } else {
706    if (Reg < 32)
707      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
708    else {
709      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
710      addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
711    }
712
713    addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
714  }
715
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).
718  if (isPointer)
719    addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
720
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);
727  }
728
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);
732
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);
739  }
740
741  // Now attach the location information to the DIE.
742  addBlock(Die, Attribute, 0, Block);
743}
744
745/// addAddress - Add an address attribute to a die based on the location
746/// provided.
747void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
748                            const MachineLocation &Location) {
749  unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
750  DIEBlock *Block = new DIEBlock();
751
752  if (Location.isReg()) {
753    if (Reg < 32) {
754      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
755    } else {
756      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
757      addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
758    }
759  } else {
760    if (Reg < 32) {
761      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
762    } else {
763      addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
764      addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
765    }
766
767    addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
768  }
769
770  addBlock(Die, Attribute, 0, Block);
771}
772
773/// addToContextOwner - Add Die into the list of its context owner's children.
774void 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);
783  else
784    ModuleCU->addDie(Die);
785}
786
787/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
788/// given DIType.
789DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
790  DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
791  if (TyDIE)
792    return TyDIE;
793
794  // Create new type.
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()));
801  else {
802    assert(Ty.isDerivedType() && "Unknown kind of DIType");
803    constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
804  }
805
806  addToContextOwner(TyDIE, Ty.getContext());
807  return TyDIE;
808}
809
810/// addType - Add a new type attribute to the specified entity.
811void DwarfDebug::addType(DIE *Entity, DIType Ty) {
812  if (!Ty.isValid())
813    return;
814
815  // Check for pre-existence.
816  DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
817  // If it exists then use the existing value.
818  if (Entry) {
819    Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
820    return;
821  }
822
823  // Set up proxy.
824  Entry = createDIEEntry();
825  ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
826
827  // Construct type.
828  DIE *Buffer = getOrCreateTypeDIE(Ty);
829
830  Entry->setEntry(Buffer);
831  Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
832}
833
834/// constructTypeDIE - Construct basic type die from DIBasicType.
835void 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,
840          BTy.getEncoding());
841
842  // Add name if not anonymous or intermediate type.
843  if (!Name.empty())
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);
847}
848
849/// constructTypeDIE - Construct derived type die from DIDerivedType.
850void 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();
855
856  // FIXME - Workaround for templates.
857  if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
858
859  Buffer.setTag(Tag);
860
861  // Map to main type, void will not have a type.
862  DIType FromTy = DTy.getTypeDerivedFrom();
863  addType(&Buffer, FromTy);
864
865  // Add name if not anonymous or intermediate type.
866  if (!Name.empty())
867    addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
868
869  // Add size if non-zero (derived types might be zero-sized.)
870  if (Size)
871    addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
872
873  // Add source line info if available and TyDesc is not a forward declaration.
874  if (!DTy.isForwardDecl())
875    addSourceLine(&Buffer, &DTy);
876}
877
878/// constructTypeDIE - Construct type DIE from DICompositeType.
879void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
880  // Get core information.
881  StringRef Name = CTy.getName();
882
883  uint64_t Size = CTy.getSizeInBits() >> 3;
884  unsigned Tag = CTy.getTag();
885  Buffer.setTag(Tag);
886
887  switch (Tag) {
888  case dwarf::DW_TAG_vector_type:
889  case dwarf::DW_TAG_array_type:
890    constructArrayTypeDIE(Buffer, &CTy);
891    break;
892  case dwarf::DW_TAG_enumeration_type: {
893    DIArray Elements = CTy.getTypeArray();
894
895    // Add enumerators to enumeration type.
896    for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
897      DIE *ElemDie = NULL;
898      DIDescriptor Enum(Elements.getElement(i).getNode());
899      if (Enum.isEnumerator()) {
900        ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
901        Buffer.addChild(ElemDie);
902      }
903    }
904  }
905    break;
906  case dwarf::DW_TAG_subroutine_type: {
907    // Add return type.
908    DIArray Elements = CTy.getTypeArray();
909    DIDescriptor RTy = Elements.getElement(0);
910    addType(&Buffer, DIType(RTy.getNode()));
911
912    // Add prototype flag.
913    addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
914
915    // Add arguments.
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);
921    }
922  }
923    break;
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();
929
930    // A forward struct declared type may not have elements available.
931    unsigned N = Elements.getNumElements();
932    if (N == 0)
933      break;
934
935    // Add elements to structure type.
936    for (unsigned i = 0; i < N; ++i) {
937      DIDescriptor Element = Elements.getElement(i);
938      DIE *ElemDie = NULL;
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,
945                  DV.getName());
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()));
952      else
953        continue;
954      Buffer.addChild(ElemDie);
955    }
956
957    if (CTy.isAppleBlockExtension())
958      addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
959
960    unsigned RLang = CTy.getRunTimeLang();
961    if (RLang)
962      addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
963              dwarf::DW_FORM_data1, RLang);
964
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())));
969    break;
970  }
971  default:
972    break;
973  }
974
975  // Add name if not anonymous or intermediate type.
976  if (!Name.empty())
977    addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
978
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.)
982    if (Size)
983      addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
984    else {
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);
988      else
989        addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
990    }
991
992    // Add source line info if available.
993    if (!CTy.isForwardDecl())
994      addSourceLine(&Buffer, &CTy);
995  }
996}
997
998/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
999void 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);
1003
1004  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1005  if (L)
1006    addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1007  addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1008
1009  Buffer.addChild(DW_Subrange);
1010}
1011
1012/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1013void 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);
1018
1019  // Emit derived type.
1020  addType(&Buffer, CTy->getTypeDerivedFrom());
1021  DIArray Elements = CTy->getTypeArray();
1022
1023  // Get an anonymous type for index type.
1024  DIE *IdxTy = ModuleCU->getIndexTyDie();
1025  if (!IdxTy) {
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);
1033  }
1034
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);
1040  }
1041}
1042
1043/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1044DIE *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);
1050  return Enumerator;
1051}
1052
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.
1056static StringRef getRealLinkageName(StringRef LinkageName) {
1057  char One = '\1';
1058  if (LinkageName.startswith(StringRef(&One, 1)))
1059    return LinkageName.substr(1);
1060  return LinkageName;
1061}
1062
1063/// createGlobalVariableDIE - Create new DIE using GV.
1064DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1065  // If the global variable was optmized out then no need to create debug info
1066  // entry.
1067  if (!GV.getGlobal()) return NULL;
1068  if (GV.getDisplayName().empty()) return NULL;
1069
1070  DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1071  addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1072            GV.getDisplayName());
1073
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));
1078
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);
1083
1084  return GVDie;
1085}
1086
1087/// createMemberDIE - Create new member DIE.
1088DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1089  DIE *MemberDie = new DIE(DT.getTag());
1090  StringRef Name = DT.getName();
1091  if (!Name.empty())
1092    addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1093
1094  addType(MemberDie, DT.getTypeDerivedFrom());
1095
1096  addSourceLine(MemberDie, &DT);
1097
1098  DIEBlock *MemLocationDie = new DIEBlock();
1099  addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1100
1101  uint64_t Size = DT.getSizeInBits();
1102  uint64_t FieldSize = DT.getOriginalTypeSize();
1103
1104  if (Size != FieldSize) {
1105    // Handle bitfield.
1106    addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1107    addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1108
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;
1114
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);
1118
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);
1122
1123  } else
1124    // This is not a bitfield.
1125    addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1126
1127  if (DT.getTag() == dwarf::DW_TAG_inheritance
1128      && DT.isVirtual()) {
1129
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)
1133
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);
1142
1143    addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1144             VBaseLocationDie);
1145  } else
1146    addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1147
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);
1157  if (DT.isVirtual())
1158    addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1159            dwarf::DW_VIRTUALITY_virtual);
1160  return MemberDie;
1161}
1162
1163/// createSubprogramDIE - Create new DIE using SP.
1164DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1165  DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1166  if (SPDie)
1167    return SPDie;
1168
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());
1173
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));
1178
1179  addSourceLine(SPDie, &SP);
1180
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);
1186
1187  // Add Return Type.
1188  DICompositeType SPTy = SP.getType();
1189  DIArray Args = SPTy.getTypeArray();
1190  unsigned SPTag = SPTy.getTag();
1191
1192  if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1193    addType(SPDie, SPTy);
1194  else
1195    addType(SPDie, DIType(Args.getElement(0).getNode()));
1196
1197  unsigned VK = SP.getVirtuality();
1198  if (VK) {
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()));
1206  }
1207
1208  if (MakeDecl || !SP.isDefinition()) {
1209    addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1210
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();
1216
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()));
1221        addType(Arg, ATy);
1222        if (ATy.isArtificial())
1223          addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1224        SPDie->addChild(Arg);
1225      }
1226  }
1227
1228  if (SP.isArtificial())
1229    addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1230
1231  // DW_TAG_inlined_subroutine may refer to this DIE.
1232  ModuleCU->insertDIE(SP.getNode(), SPDie);
1233  return SPDie;
1234}
1235
1236/// findCompileUnit - Get the compile unit for the given descriptor.
1237///
1238CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1239  DenseMap<Value *, CompileUnit *>::const_iterator I =
1240    CompileUnitMap.find(Unit.getNode());
1241  if (I == CompileUnitMap.end())
1242    return constructCompileUnit(Unit.getNode());
1243  return I->second;
1244}
1245
1246/// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1247/// Initialize scope and update scope hierarchy.
1248DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1249  MDNode *InlinedAt) {
1250  assert (N && "Invalid Scope encoding!");
1251  assert (MI && "Missing machine instruction!");
1252  bool GetConcreteScope = (MI && InlinedAt);
1253
1254  DbgScope *NScope = NULL;
1255
1256  if (InlinedAt)
1257    NScope = DbgScopeMap.lookup(InlinedAt);
1258  else
1259    NScope = DbgScopeMap.lookup(N);
1260  assert (NScope && "Unable to find working scope!");
1261
1262  if (NScope->getFirstInsn())
1263    return NScope;
1264
1265  DbgScope *Parent = NULL;
1266  if (GetConcreteScope) {
1267    DILocation IL(InlinedAt);
1268    Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1269                         IL.getOrigLocation().getNode());
1270    assert (Parent && "Unable to find Parent scope!");
1271    NScope->setParent(Parent);
1272    Parent->addScope(NScope);
1273  } else if (DIDescriptor(N).isLexicalBlock()) {
1274    DILexicalBlock DB(N);
1275    Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1276    NScope->setParent(Parent);
1277    Parent->addScope(NScope);
1278  }
1279
1280  NScope->setFirstInsn(MI);
1281
1282  if (!Parent && !InlinedAt) {
1283    StringRef SPName = DISubprogram(N).getLinkageName();
1284    if (SPName == MF->getFunction()->getName())
1285      CurrentFnDbgScope = NScope;
1286  }
1287
1288  if (GetConcreteScope) {
1289    ConcreteScopes[InlinedAt] = NScope;
1290    getOrCreateAbstractScope(N);
1291  }
1292
1293  return NScope;
1294}
1295
1296DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1297  assert (N && "Invalid Scope encoding!");
1298
1299  DbgScope *AScope = AbstractScopes.lookup(N);
1300  if (AScope)
1301    return AScope;
1302
1303  DbgScope *Parent = NULL;
1304
1305  DIDescriptor Scope(N);
1306  if (Scope.isLexicalBlock()) {
1307    DILexicalBlock DB(N);
1308    DIDescriptor ParentDesc = DB.getContext();
1309    Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1310  }
1311
1312  AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1313
1314  if (Parent)
1315    Parent->addScope(AScope);
1316  AScope->setAbstractScope();
1317  AbstractScopes[N] = AScope;
1318  if (DIDescriptor(N).isSubprogram())
1319    AbstractScopesList.push_back(AScope);
1320  return AScope;
1321}
1322
1323/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1324/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1325/// If there are global variables in this scope then create and insert
1326/// DIEs for these variables.
1327DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1328
1329 DIE *SPDie = ModuleCU->getDIE(SPNode);
1330 assert (SPDie && "Unable to find subprogram DIE!");
1331 DISubprogram SP(SPNode);
1332 // There is not any need to generate specification DIE for a function
1333 // defined at compile unit level. If a function is defined inside another
1334 // function then gdb prefers the definition at top level and but does not
1335 // expect specification DIE in parent function. So avoid creating
1336 // specification DIE for a function defined inside a function.
1337 if (SP.isDefinition() && !SP.getContext().isCompileUnit()
1338     && !SP.getContext().isSubprogram()) {
1339   addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1340  // Add arguments.
1341   DICompositeType SPTy = SP.getType();
1342   DIArray Args = SPTy.getTypeArray();
1343   unsigned SPTag = SPTy.getTag();
1344   if (SPTag == dwarf::DW_TAG_subroutine_type)
1345     for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1346       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1347       DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1348       addType(Arg, ATy);
1349       if (ATy.isArtificial())
1350         addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1351       SPDie->addChild(Arg);
1352     }
1353   DIE *SPDeclDie = SPDie;
1354   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1355   addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1356               SPDeclDie);
1357   ModuleCU->addDie(SPDie);
1358 }
1359
1360 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1361          DWLabel("func_begin", SubprogramCount));
1362 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1363          DWLabel("func_end", SubprogramCount));
1364 MachineLocation Location(RI->getFrameRegister(*MF));
1365 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1366
1367 if (!DISubprogram(SPNode).isLocalToUnit())
1368   addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1369
1370 return SPDie;
1371}
1372
1373/// constructLexicalScope - Construct new DW_TAG_lexical_block
1374/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1375DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1376  unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1377  unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1378
1379  // Ignore empty scopes.
1380  if (StartID == EndID && StartID != 0)
1381    return NULL;
1382
1383  DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1384  if (Scope->isAbstractScope())
1385    return ScopeDIE;
1386
1387  addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1388           StartID ?
1389             DWLabel("label", StartID)
1390           : DWLabel("func_begin", SubprogramCount));
1391  addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1392           EndID ?
1393             DWLabel("label", EndID)
1394           : DWLabel("func_end", SubprogramCount));
1395
1396
1397
1398  return ScopeDIE;
1399}
1400
1401/// constructInlinedScopeDIE - This scope represents inlined body of
1402/// a function. Construct DIE to represent this concrete inlined copy
1403/// of the function.
1404DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1405  unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1406  unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1407  assert (StartID && "Invalid starting label for an inlined scope!");
1408  assert (EndID && "Invalid end label for an inlined scope!");
1409  // Ignore empty scopes.
1410  if (StartID == EndID && StartID != 0)
1411    return NULL;
1412  if (!Scope->getScopeNode())
1413    return NULL;
1414  DIScope DS(Scope->getScopeNode());
1415  DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1416
1417  DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1418  DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1419  assert (OriginDIE && "Unable to find Origin DIE!");
1420  addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1421              dwarf::DW_FORM_ref4, OriginDIE);
1422
1423  addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1424           DWLabel("label", StartID));
1425  addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1426           DWLabel("label", EndID));
1427
1428  InlinedSubprogramDIEs.insert(OriginDIE);
1429
1430  // Track the start label for this inlined function.
1431  DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1432    I = InlineInfo.find(InlinedSP.getNode());
1433
1434  if (I == InlineInfo.end()) {
1435    InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1436                                                             ScopeDIE));
1437    InlinedSPNodes.push_back(InlinedSP.getNode());
1438  } else
1439    I->second.push_back(std::make_pair(StartID, ScopeDIE));
1440
1441  StringPool.insert(InlinedSP.getName());
1442  StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1443
1444  DILocation DL(Scope->getInlinedAt());
1445  addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1446  addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1447
1448  return ScopeDIE;
1449}
1450
1451
1452/// constructVariableDIE - Construct a DIE for the given DbgVariable.
1453DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1454  // Get the descriptor.
1455  const DIVariable &VD = DV->getVariable();
1456  StringRef Name = VD.getName();
1457  if (Name.empty())
1458    return NULL;
1459
1460  // Translate tag to proper Dwarf tag.  The result variable is dropped for
1461  // now.
1462  unsigned Tag;
1463  switch (VD.getTag()) {
1464  case dwarf::DW_TAG_return_variable:
1465    return NULL;
1466  case dwarf::DW_TAG_arg_variable:
1467    Tag = dwarf::DW_TAG_formal_parameter;
1468    break;
1469  case dwarf::DW_TAG_auto_variable:    // fall thru
1470  default:
1471    Tag = dwarf::DW_TAG_variable;
1472    break;
1473  }
1474
1475  // Define variable debug information entry.
1476  DIE *VariableDie = new DIE(Tag);
1477
1478
1479  DIE *AbsDIE = NULL;
1480  if (DbgVariable *AV = DV->getAbstractVariable())
1481    AbsDIE = AV->getDIE();
1482
1483  if (AbsDIE) {
1484    DIScope DS(Scope->getScopeNode());
1485    DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1486    DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1487    (void) OriginSPDIE;
1488    assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1489    DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1490    assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1491    addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1492                dwarf::DW_FORM_ref4, AbsDIE);
1493  }
1494  else {
1495    addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1496    addSourceLine(VariableDie, &VD);
1497
1498    // Add variable type.
1499    // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1500    // addresses instead.
1501    if (VD.isBlockByrefVariable())
1502      addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1503    else
1504      addType(VariableDie, VD.getType());
1505  }
1506
1507  // Add variable address.
1508  if (!Scope->isAbstractScope()) {
1509    MachineLocation Location;
1510    unsigned FrameReg;
1511    int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1512    Location.set(FrameReg, Offset);
1513
1514    if (VD.hasComplexAddress())
1515      addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1516    else if (VD.isBlockByrefVariable())
1517      addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1518    else
1519      addAddress(VariableDie, dwarf::DW_AT_location, Location);
1520  }
1521
1522  if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1523    addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1524  DV->setDIE(VariableDie);
1525  return VariableDie;
1526
1527}
1528
1529void DwarfDebug::addPubTypes(DISubprogram SP) {
1530  DICompositeType SPTy = SP.getType();
1531  unsigned SPTag = SPTy.getTag();
1532  if (SPTag != dwarf::DW_TAG_subroutine_type)
1533    return;
1534
1535  DIArray Args = SPTy.getTypeArray();
1536  for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1537    DIType ATy(Args.getElement(i).getNode());
1538    if (!ATy.isValid())
1539      continue;
1540    DICompositeType CATy = getDICompositeType(ATy);
1541    if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1542      if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1543        ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1544    }
1545  }
1546}
1547
1548/// constructScopeDIE - Construct a DIE for this scope.
1549DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1550  if (!Scope || !Scope->getScopeNode())
1551    return NULL;
1552
1553  DIScope DS(Scope->getScopeNode());
1554  DIE *ScopeDIE = NULL;
1555  if (Scope->getInlinedAt())
1556    ScopeDIE = constructInlinedScopeDIE(Scope);
1557  else if (DS.isSubprogram()) {
1558    if (Scope->isAbstractScope())
1559      ScopeDIE = ModuleCU->getDIE(DS.getNode());
1560    else
1561      ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1562  }
1563  else {
1564    ScopeDIE = constructLexicalScopeDIE(Scope);
1565    if (!ScopeDIE) return NULL;
1566  }
1567
1568  // Add variables to scope.
1569  SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1570  for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1571    DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1572    if (VariableDIE)
1573      ScopeDIE->addChild(VariableDIE);
1574  }
1575
1576  // Add nested scopes.
1577  SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1578  for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1579    // Define the Scope debug information entry.
1580    DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1581    if (NestedDIE)
1582      ScopeDIE->addChild(NestedDIE);
1583  }
1584
1585  if (DS.isSubprogram())
1586    addPubTypes(DISubprogram(DS.getNode()));
1587
1588 return ScopeDIE;
1589}
1590
1591/// GetOrCreateSourceID - Look up the source id with the given directory and
1592/// source file names. If none currently exists, create a new id and insert it
1593/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1594/// maps as well.
1595unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1596  unsigned DId;
1597  StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1598  if (DI != DirectoryIdMap.end()) {
1599    DId = DI->getValue();
1600  } else {
1601    DId = DirectoryNames.size() + 1;
1602    DirectoryIdMap[DirName] = DId;
1603    DirectoryNames.push_back(DirName);
1604  }
1605
1606  unsigned FId;
1607  StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1608  if (FI != SourceFileIdMap.end()) {
1609    FId = FI->getValue();
1610  } else {
1611    FId = SourceFileNames.size() + 1;
1612    SourceFileIdMap[FileName] = FId;
1613    SourceFileNames.push_back(FileName);
1614  }
1615
1616  DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1617    SourceIdMap.find(std::make_pair(DId, FId));
1618  if (SI != SourceIdMap.end())
1619    return SI->second;
1620
1621  unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
1622  SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1623  SourceIds.push_back(std::make_pair(DId, FId));
1624
1625  return SrcId;
1626}
1627
1628/// getOrCreateNameSpace - Create a DIE for DINameSpace.
1629DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1630  DIE *NDie = ModuleCU->getDIE(NS.getNode());
1631  if (NDie)
1632    return NDie;
1633  NDie = new DIE(dwarf::DW_TAG_namespace);
1634  ModuleCU->insertDIE(NS.getNode(), NDie);
1635  if (!NS.getName().empty())
1636    addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1637  addSourceLine(NDie, &NS);
1638  addToContextOwner(NDie, NS.getContext());
1639  return NDie;
1640}
1641
1642CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1643  DICompileUnit DIUnit(N);
1644  StringRef FN = DIUnit.getFilename();
1645  StringRef Dir = DIUnit.getDirectory();
1646  unsigned ID = GetOrCreateSourceID(Dir, FN);
1647
1648  DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1649  addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1650                   DWLabel("section_line", 0), DWLabel("section_line", 0),
1651                   false);
1652  addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1653            DIUnit.getProducer());
1654  addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1655          DIUnit.getLanguage());
1656  addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1657
1658  if (!Dir.empty())
1659    addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1660  if (DIUnit.isOptimized())
1661    addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1662
1663  StringRef Flags = DIUnit.getFlags();
1664  if (!Flags.empty())
1665    addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1666
1667  unsigned RVer = DIUnit.getRunTimeVersion();
1668  if (RVer)
1669    addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1670            dwarf::DW_FORM_data1, RVer);
1671
1672  CompileUnit *Unit = new CompileUnit(ID, Die);
1673  if (!ModuleCU && DIUnit.isMain()) {
1674    // Use first compile unit marked as isMain as the compile unit
1675    // for this module.
1676    ModuleCU = Unit;
1677  }
1678
1679  CompileUnitMap[DIUnit.getNode()] = Unit;
1680  CompileUnits.push_back(Unit);
1681  return Unit;
1682}
1683
1684void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1685  DIGlobalVariable DI_GV(N);
1686
1687  // If debug information is malformed then ignore it.
1688  if (DI_GV.Verify() == false)
1689    return;
1690
1691  // Check for pre-existence.
1692  if (ModuleCU->getDIE(DI_GV.getNode()))
1693    return;
1694
1695  DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1696  if (!VariableDie)
1697    return;
1698
1699  // Add to map.
1700  ModuleCU->insertDIE(N, VariableDie);
1701
1702  // Add to context owner.
1703  DIDescriptor GVContext = DI_GV.getContext();
1704  // Do not create specification DIE if context is either compile unit
1705  // or a subprogram.
1706  if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1707      && !GVContext.isSubprogram()) {
1708    // Create specification DIE.
1709    DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1710    addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1711                dwarf::DW_FORM_ref4, VariableDie);
1712    DIEBlock *Block = new DIEBlock();
1713    addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1714    addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1715                   Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1716    addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1717    addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1718    ModuleCU->addDie(VariableSpecDIE);
1719  } else {
1720    DIEBlock *Block = new DIEBlock();
1721    addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1722    addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1723                   Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1724    addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1725  }
1726  addToContextOwner(VariableDie, GVContext);
1727
1728  // Expose as global. FIXME - need to check external flag.
1729  ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1730
1731  DIType GTy = DI_GV.getType();
1732  if (GTy.isCompositeType() && !GTy.getName().empty()) {
1733    DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1734    assert (Entry && "Missing global type!");
1735    ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1736  }
1737  return;
1738}
1739
1740void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1741  DISubprogram SP(N);
1742
1743  // Check for pre-existence.
1744  if (ModuleCU->getDIE(N))
1745    return;
1746
1747  if (!SP.isDefinition())
1748    // This is a method declaration which will be handled while constructing
1749    // class type.
1750    return;
1751
1752  DIE *SubprogramDie = createSubprogramDIE(SP);
1753
1754  // Add to map.
1755  ModuleCU->insertDIE(N, SubprogramDie);
1756
1757  // Add to context owner.
1758  addToContextOwner(SubprogramDie, SP.getContext());
1759
1760  // Expose as global.
1761  ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1762
1763  return;
1764}
1765
1766/// beginModule - Emit all Dwarf sections that should come prior to the
1767/// content. Create global DIEs and emit initial debug info sections.
1768/// This is inovked by the target AsmPrinter.
1769void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1770  this->M = M;
1771
1772  if (TimePassesIsEnabled)
1773    DebugTimer->startTimer();
1774
1775  if (!MAI->doesSupportDebugInformation())
1776    return;
1777
1778  DebugInfoFinder DbgFinder;
1779  DbgFinder.processModule(*M);
1780
1781  // Create all the compile unit DIEs.
1782  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1783         E = DbgFinder.compile_unit_end(); I != E; ++I)
1784    constructCompileUnit(*I);
1785
1786  if (CompileUnits.empty()) {
1787    if (TimePassesIsEnabled)
1788      DebugTimer->stopTimer();
1789
1790    return;
1791  }
1792
1793  // If main compile unit for this module is not seen than randomly
1794  // select first compile unit.
1795  if (!ModuleCU)
1796    ModuleCU = CompileUnits[0];
1797
1798  // Create DIEs for each subprogram.
1799  for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1800         E = DbgFinder.subprogram_end(); I != E; ++I)
1801    constructSubprogramDIE(*I);
1802
1803  // Create DIEs for each global variable.
1804  for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1805         E = DbgFinder.global_variable_end(); I != E; ++I)
1806    constructGlobalVariableDIE(*I);
1807
1808  MMI = mmi;
1809  shouldEmit = true;
1810  MMI->setDebugInfoAvailability(true);
1811
1812  // Prime section data.
1813  SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1814
1815  // Print out .file directives to specify files for .loc directives. These are
1816  // printed out early so that they precede any .loc directives.
1817  if (MAI->hasDotLocAndDotFile()) {
1818    for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1819      // Remember source id starts at 1.
1820      std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1821      // FIXME: don't use sys::path for this!  This should not depend on the
1822      // host.
1823      sys::Path FullPath(getSourceDirectoryName(Id.first));
1824      bool AppendOk =
1825        FullPath.appendComponent(getSourceFileName(Id.second));
1826      assert(AppendOk && "Could not append filename to directory!");
1827      AppendOk = false;
1828      Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1829    }
1830  }
1831
1832  // Emit initial sections
1833  emitInitial();
1834
1835  if (TimePassesIsEnabled)
1836    DebugTimer->stopTimer();
1837}
1838
1839/// endModule - Emit all Dwarf sections that should come after the content.
1840///
1841void DwarfDebug::endModule() {
1842  if (!ModuleCU)
1843    return;
1844
1845  if (TimePassesIsEnabled)
1846    DebugTimer->startTimer();
1847
1848  // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1849  for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1850         AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1851    DIE *ISP = *AI;
1852    addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1853  }
1854
1855  // Insert top level DIEs.
1856  for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1857         TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1858    ModuleCU->getCUDie()->addChild(*TI);
1859
1860  for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1861         CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1862    DIE *SPDie = CI->first;
1863    MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1864    if (!N) continue;
1865    DIE *NDie = ModuleCU->getDIE(N);
1866    if (!NDie) continue;
1867    addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1868    // FIXME - This is not the correct approach.
1869    // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1870  }
1871
1872  // Standard sections final addresses.
1873  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1874  EmitLabel("text_end", 0);
1875  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1876  EmitLabel("data_end", 0);
1877
1878  // End text sections.
1879  for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1880    Asm->OutStreamer.SwitchSection(SectionMap[i]);
1881    EmitLabel("section_end", i);
1882  }
1883
1884  // Emit common frame information.
1885  emitCommonDebugFrame();
1886
1887  // Emit function debug frame information
1888  for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1889         E = DebugFrames.end(); I != E; ++I)
1890    emitFunctionDebugFrame(*I);
1891
1892  // Compute DIE offsets and sizes.
1893  computeSizeAndOffsets();
1894
1895  // Emit all the DIEs into a debug info section
1896  emitDebugInfo();
1897
1898  // Corresponding abbreviations into a abbrev section.
1899  emitAbbreviations();
1900
1901  // Emit source line correspondence into a debug line section.
1902  emitDebugLines();
1903
1904  // Emit info into a debug pubnames section.
1905  emitDebugPubNames();
1906
1907  // Emit info into a debug pubtypes section.
1908  emitDebugPubTypes();
1909
1910  // Emit info into a debug str section.
1911  emitDebugStr();
1912
1913  // Emit info into a debug loc section.
1914  emitDebugLoc();
1915
1916  // Emit info into a debug aranges section.
1917  EmitDebugARanges();
1918
1919  // Emit info into a debug ranges section.
1920  emitDebugRanges();
1921
1922  // Emit info into a debug macinfo section.
1923  emitDebugMacInfo();
1924
1925  // Emit inline info.
1926  emitDebugInlineInfo();
1927
1928  if (TimePassesIsEnabled)
1929    DebugTimer->stopTimer();
1930}
1931
1932/// findAbstractVariable - Find abstract variable, if any, associated with Var.
1933DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1934                                              unsigned FrameIdx,
1935                                              DILocation &ScopeLoc) {
1936
1937  DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1938  if (AbsDbgVariable)
1939    return AbsDbgVariable;
1940
1941  DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1942  if (!Scope)
1943    return NULL;
1944
1945  AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1946  Scope->addVariable(AbsDbgVariable);
1947  AbstractVariables[Var.getNode()] = AbsDbgVariable;
1948  return AbsDbgVariable;
1949}
1950
1951/// collectVariableInfo - Populate DbgScope entries with variables' info.
1952void DwarfDebug::collectVariableInfo() {
1953  if (!MMI) return;
1954
1955  MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1956  for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1957         VE = VMap.end(); VI != VE; ++VI) {
1958    MDNode *Var = VI->first;
1959    if (!Var) continue;
1960    DIVariable DV (Var);
1961    std::pair< unsigned, MDNode *> VP = VI->second;
1962    DILocation ScopeLoc(VP.second);
1963
1964    DbgScope *Scope =
1965      ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1966    if (!Scope)
1967      Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1968    // If variable scope is not found then skip this variable.
1969    if (!Scope)
1970      continue;
1971
1972    DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1973    Scope->addVariable(RegVar);
1974    if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1975                                                           ScopeLoc))
1976      RegVar->setAbstractVariable(AbsDbgVariable);
1977  }
1978}
1979
1980/// beginScope - Process beginning of a scope starting at Label.
1981void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1982  InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1983  if (I == DbgScopeBeginMap.end())
1984    return;
1985  ScopeVector &SD = I->second;
1986  for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1987       SDI != SDE; ++SDI)
1988    (*SDI)->setStartLabelID(Label);
1989}
1990
1991/// endScope - Process end of a scope.
1992void DwarfDebug::endScope(const MachineInstr *MI) {
1993  InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1994  if (I == DbgScopeEndMap.end())
1995    return;
1996
1997  unsigned Label = MMI->NextLabelID();
1998  Asm->printLabel(Label);
1999  O << '\n';
2000
2001  SmallVector<DbgScope *, 2> &SD = I->second;
2002  for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2003       SDI != SDE; ++SDI)
2004    (*SDI)->setEndLabelID(Label);
2005  return;
2006}
2007
2008/// createDbgScope - Create DbgScope for the scope.
2009void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2010
2011  if (!InlinedAt) {
2012    DbgScope *WScope = DbgScopeMap.lookup(Scope);
2013    if (WScope)
2014      return;
2015    WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2016    DbgScopeMap.insert(std::make_pair(Scope, WScope));
2017    if (DIDescriptor(Scope).isLexicalBlock())
2018      createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2019    return;
2020  }
2021
2022  DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2023  if (WScope)
2024    return;
2025
2026  WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2027  DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2028  DILocation DL(InlinedAt);
2029  createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2030}
2031
2032/// extractScopeInformation - Scan machine instructions in this function
2033/// and collect DbgScopes. Return true, if atleast one scope was found.
2034bool DwarfDebug::extractScopeInformation() {
2035  // If scope information was extracted using .dbg intrinsics then there is not
2036  // any need to extract these information by scanning each instruction.
2037  if (!DbgScopeMap.empty())
2038    return false;
2039
2040  DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2041  unsigned MIIndex = 0;
2042  // Scan each instruction and create scopes. First build working set of scopes.
2043  for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2044       I != E; ++I) {
2045    for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2046         II != IE; ++II) {
2047      const MachineInstr *MInsn = II;
2048      MIIndexMap[MInsn] = MIIndex++;
2049      DebugLoc DL = MInsn->getDebugLoc();
2050      if (DL.isUnknown()) continue;
2051      DILocation DLT = MF->getDILocation(DL);
2052      DIScope DLTScope = DLT.getScope();
2053      // There is no need to create another DIE for compile unit. For all
2054      // other scopes, create one DbgScope now. This will be translated
2055      // into a scope DIE at the end.
2056      if (DLTScope.isCompileUnit()) continue;
2057      createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2058    }
2059  }
2060
2061
2062  // Build scope hierarchy using working set of scopes.
2063  for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2064       I != E; ++I) {
2065    for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2066         II != IE; ++II) {
2067      const MachineInstr *MInsn = II;
2068      DebugLoc DL = MInsn->getDebugLoc();
2069      if (DL.isUnknown())  continue;
2070      DILocation DLT = MF->getDILocation(DL);
2071      DIScope DLTScope = DLT.getScope();
2072      // There is no need to create another DIE for compile unit. For all
2073      // other scopes, create one DbgScope now. This will be translated
2074      // into a scope DIE at the end.
2075      if (DLTScope.isCompileUnit()) continue;
2076      DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2077                                           DLT.getOrigLocation().getNode());
2078      Scope->setLastInsn(MInsn);
2079    }
2080  }
2081
2082  if (!CurrentFnDbgScope)
2083    return false;
2084
2085  CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2086
2087  // Each scope has first instruction and last instruction to mark beginning
2088  // and end of a scope respectively. Create an inverse map that list scopes
2089  // starts (and ends) with an instruction. One instruction may start (or end)
2090  // multiple scopes. Ignore scopes that are not reachable.
2091  SmallVector<DbgScope *, 4> WorkList;
2092  WorkList.push_back(CurrentFnDbgScope);
2093  while (!WorkList.empty()) {
2094    DbgScope *S = WorkList.back(); WorkList.pop_back();
2095
2096    SmallVector<DbgScope *, 4> &Children = S->getScopes();
2097    if (!Children.empty())
2098      for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2099             SE = Children.end(); SI != SE; ++SI)
2100        WorkList.push_back(*SI);
2101
2102    if (S->isAbstractScope())
2103      continue;
2104    const MachineInstr *MI = S->getFirstInsn();
2105    assert (MI && "DbgScope does not have first instruction!");
2106
2107    InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2108    if (IDI != DbgScopeBeginMap.end())
2109      IDI->second.push_back(S);
2110    else
2111      DbgScopeBeginMap[MI].push_back(S);
2112
2113    MI = S->getLastInsn();
2114    assert (MI && "DbgScope does not have last instruction!");
2115    IDI = DbgScopeEndMap.find(MI);
2116    if (IDI != DbgScopeEndMap.end())
2117      IDI->second.push_back(S);
2118    else
2119      DbgScopeEndMap[MI].push_back(S);
2120  }
2121
2122  return !DbgScopeMap.empty();
2123}
2124
2125/// beginFunction - Gather pre-function debug information.  Assumes being
2126/// emitted immediately after the function entry point.
2127void DwarfDebug::beginFunction(const MachineFunction *MF) {
2128  this->MF = MF;
2129
2130  if (!ShouldEmitDwarfDebug()) return;
2131
2132  if (TimePassesIsEnabled)
2133    DebugTimer->startTimer();
2134
2135  if (!extractScopeInformation())
2136    return;
2137
2138  collectVariableInfo();
2139
2140  // Assumes in correct section after the entry point.
2141  EmitLabel("func_begin", ++SubprogramCount);
2142
2143  // Emit label for the implicitly defined dbg.stoppoint at the start of the
2144  // function.
2145  DebugLoc FDL = MF->getDefaultDebugLoc();
2146  if (!FDL.isUnknown()) {
2147    DILocation DLT = MF->getDILocation(FDL);
2148    unsigned LabelID = 0;
2149    DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2150    if (SP.Verify())
2151      LabelID = recordSourceLine(SP.getLineNumber(), 0,
2152                                 DLT.getScope().getNode());
2153    else
2154      LabelID = recordSourceLine(DLT.getLineNumber(),
2155                                 DLT.getColumnNumber(),
2156                                 DLT.getScope().getNode());
2157    Asm->printLabel(LabelID);
2158    O << '\n';
2159  }
2160  if (TimePassesIsEnabled)
2161    DebugTimer->stopTimer();
2162}
2163
2164/// endFunction - Gather and emit post-function debug information.
2165///
2166void DwarfDebug::endFunction(const MachineFunction *MF) {
2167  if (!ShouldEmitDwarfDebug()) return;
2168
2169  if (TimePassesIsEnabled)
2170    DebugTimer->startTimer();
2171
2172  if (DbgScopeMap.empty())
2173    return;
2174
2175  if (CurrentFnDbgScope) {
2176    // Define end label for subprogram.
2177    EmitLabel("func_end", SubprogramCount);
2178
2179    // Get function line info.
2180    if (!Lines.empty()) {
2181      // Get section line info.
2182      unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2183      if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2184      std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2185      // Append the function info to section info.
2186      SectionLineInfos.insert(SectionLineInfos.end(),
2187                              Lines.begin(), Lines.end());
2188    }
2189
2190    // Construct abstract scopes.
2191    for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2192           AE = AbstractScopesList.end(); AI != AE; ++AI)
2193      constructScopeDIE(*AI);
2194
2195    constructScopeDIE(CurrentFnDbgScope);
2196
2197    DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2198                                                 MMI->getFrameMoves()));
2199  }
2200
2201  // Clear debug info
2202  CurrentFnDbgScope = NULL;
2203  DbgScopeMap.clear();
2204  DbgScopeBeginMap.clear();
2205  DbgScopeEndMap.clear();
2206  ConcreteScopes.clear();
2207  AbstractScopesList.clear();
2208  Lines.clear();
2209
2210  if (TimePassesIsEnabled)
2211    DebugTimer->stopTimer();
2212}
2213
2214/// recordSourceLine - Records location information and associates it with a
2215/// label. Returns a unique label ID used to generate a label and provide
2216/// correspondence to the source line list.
2217unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2218                                      MDNode *S) {
2219  if (!MMI)
2220    return 0;
2221
2222  if (TimePassesIsEnabled)
2223    DebugTimer->startTimer();
2224
2225  StringRef Dir;
2226  StringRef Fn;
2227
2228  DIDescriptor Scope(S);
2229  if (Scope.isCompileUnit()) {
2230    DICompileUnit CU(S);
2231    Dir = CU.getDirectory();
2232    Fn = CU.getFilename();
2233  } else if (Scope.isSubprogram()) {
2234    DISubprogram SP(S);
2235    Dir = SP.getDirectory();
2236    Fn = SP.getFilename();
2237  } else if (Scope.isLexicalBlock()) {
2238    DILexicalBlock DB(S);
2239    Dir = DB.getDirectory();
2240    Fn = DB.getFilename();
2241  } else
2242    assert (0 && "Unexpected scope info");
2243
2244  unsigned Src = GetOrCreateSourceID(Dir, Fn);
2245  unsigned ID = MMI->NextLabelID();
2246  Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2247
2248  if (TimePassesIsEnabled)
2249    DebugTimer->stopTimer();
2250
2251  return ID;
2252}
2253
2254/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2255/// timed. Look up the source id with the given directory and source file
2256/// names. If none currently exists, create a new id and insert it in the
2257/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2258/// well.
2259unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2260                                         const std::string &FileName) {
2261  if (TimePassesIsEnabled)
2262    DebugTimer->startTimer();
2263
2264  unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2265
2266  if (TimePassesIsEnabled)
2267    DebugTimer->stopTimer();
2268
2269  return SrcId;
2270}
2271
2272//===----------------------------------------------------------------------===//
2273// Emit Methods
2274//===----------------------------------------------------------------------===//
2275
2276/// computeSizeAndOffset - Compute the size and offset of a DIE.
2277///
2278unsigned
2279DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2280  // Get the children.
2281  const std::vector<DIE *> &Children = Die->getChildren();
2282
2283  // If not last sibling and has children then add sibling offset attribute.
2284  if (!Last && !Children.empty()) Die->addSiblingOffset();
2285
2286  // Record the abbreviation.
2287  assignAbbrevNumber(Die->getAbbrev());
2288
2289  // Get the abbreviation for this DIE.
2290  unsigned AbbrevNumber = Die->getAbbrevNumber();
2291  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2292
2293  // Set DIE offset
2294  Die->setOffset(Offset);
2295
2296  // Start the size with the size of abbreviation code.
2297  Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2298
2299  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2300  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2301
2302  // Size the DIE attribute values.
2303  for (unsigned i = 0, N = Values.size(); i < N; ++i)
2304    // Size attribute value.
2305    Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2306
2307  // Size the DIE children if any.
2308  if (!Children.empty()) {
2309    assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2310           "Children flag not set");
2311
2312    for (unsigned j = 0, M = Children.size(); j < M; ++j)
2313      Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2314
2315    // End of children marker.
2316    Offset += sizeof(int8_t);
2317  }
2318
2319  Die->setSize(Offset - Die->getOffset());
2320  return Offset;
2321}
2322
2323/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2324///
2325void DwarfDebug::computeSizeAndOffsets() {
2326  // Compute size of compile unit header.
2327  static unsigned Offset =
2328    sizeof(int32_t) + // Length of Compilation Unit Info
2329    sizeof(int16_t) + // DWARF version number
2330    sizeof(int32_t) + // Offset Into Abbrev. Section
2331    sizeof(int8_t);   // Pointer Size (in bytes)
2332
2333  computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2334  CompileUnitOffsets[ModuleCU] = 0;
2335}
2336
2337/// emitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2338/// tools to recognize the object file contains Dwarf information.
2339void DwarfDebug::emitInitial() {
2340  // Check to see if we already emitted intial headers.
2341  if (didInitial) return;
2342  didInitial = true;
2343
2344  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2345
2346  // Dwarf sections base addresses.
2347  if (MAI->doesDwarfRequireFrameSection()) {
2348    Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2349    EmitLabel("section_debug_frame", 0);
2350  }
2351
2352  Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2353  EmitLabel("section_info", 0);
2354  Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2355  EmitLabel("section_abbrev", 0);
2356  Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2357  EmitLabel("section_aranges", 0);
2358
2359  if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2360    Asm->OutStreamer.SwitchSection(LineInfoDirective);
2361    EmitLabel("section_macinfo", 0);
2362  }
2363
2364  Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2365  EmitLabel("section_line", 0);
2366  Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2367  EmitLabel("section_loc", 0);
2368  Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2369  EmitLabel("section_pubnames", 0);
2370  Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2371  EmitLabel("section_pubtypes", 0);
2372  Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2373  EmitLabel("section_str", 0);
2374  Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2375  EmitLabel("section_ranges", 0);
2376
2377  Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2378  EmitLabel("text_begin", 0);
2379  Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2380  EmitLabel("data_begin", 0);
2381}
2382
2383/// emitDIE - Recusively Emits a debug information entry.
2384///
2385void DwarfDebug::emitDIE(DIE *Die) {
2386  // Get the abbreviation for this DIE.
2387  unsigned AbbrevNumber = Die->getAbbrevNumber();
2388  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2389
2390  Asm->O << '\n';
2391
2392  // Emit the code (index) for the abbreviation.
2393  if (Asm->VerboseAsm)
2394    Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2395                                Twine::utohexstr(Die->getOffset()) + ":0x" +
2396                                Twine::utohexstr(Die->getSize()) + " " +
2397                                dwarf::TagString(Abbrev->getTag()));
2398  EmitULEB128(AbbrevNumber);
2399
2400  SmallVector<DIEValue*, 32> &Values = Die->getValues();
2401  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2402
2403  // Emit the DIE attribute values.
2404  for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2405    unsigned Attr = AbbrevData[i].getAttribute();
2406    unsigned Form = AbbrevData[i].getForm();
2407    assert(Form && "Too many attributes for DIE (check abbreviation)");
2408
2409    if (Asm->VerboseAsm)
2410      Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2411
2412    switch (Attr) {
2413    case dwarf::DW_AT_sibling:
2414      Asm->EmitInt32(Die->getSiblingOffset());
2415      break;
2416    case dwarf::DW_AT_abstract_origin: {
2417      DIEEntry *E = cast<DIEEntry>(Values[i]);
2418      DIE *Origin = E->getEntry();
2419      unsigned Addr = Origin->getOffset();
2420      Asm->EmitInt32(Addr);
2421      break;
2422    }
2423    default:
2424      // Emit an attribute using the defined form.
2425      Values[i]->EmitValue(this, Form);
2426      O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2427      break;
2428    }
2429  }
2430
2431  // Emit the DIE children if any.
2432  if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2433    const std::vector<DIE *> &Children = Die->getChildren();
2434
2435    for (unsigned j = 0, M = Children.size(); j < M; ++j)
2436      emitDIE(Children[j]);
2437
2438    Asm->EmitInt8(0); EOL("End Of Children Mark");
2439  }
2440}
2441
2442/// emitDebugInfo - Emit the debug info section.
2443///
2444void DwarfDebug::emitDebugInfo() {
2445  // Start debug info section.
2446  Asm->OutStreamer.SwitchSection(
2447                            Asm->getObjFileLowering().getDwarfInfoSection());
2448  DIE *Die = ModuleCU->getCUDie();
2449
2450  // Emit the compile units header.
2451  EmitLabel("info_begin", ModuleCU->getID());
2452
2453  // Emit size of content not including length itself
2454  unsigned ContentSize = Die->getSize() +
2455    sizeof(int16_t) + // DWARF version number
2456    sizeof(int32_t) + // Offset Into Abbrev. Section
2457    sizeof(int8_t) +  // Pointer Size (in bytes)
2458    sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2459
2460  Asm->EmitInt32(ContentSize);  EOL("Length of Compilation Unit Info");
2461  Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2462  EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2463  EOL("Offset Into Abbrev. Section");
2464  Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2465
2466  emitDIE(Die);
2467  // FIXME - extra padding for gdb bug.
2468  Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2469  Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2470  Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2471  Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2472  EmitLabel("info_end", ModuleCU->getID());
2473  Asm->O << '\n';
2474}
2475
2476/// emitAbbreviations - Emit the abbreviation section.
2477///
2478void DwarfDebug::emitAbbreviations() const {
2479  // Check to see if it is worth the effort.
2480  if (!Abbreviations.empty()) {
2481    // Start the debug abbrev section.
2482    Asm->OutStreamer.SwitchSection(
2483                            Asm->getObjFileLowering().getDwarfAbbrevSection());
2484
2485    EmitLabel("abbrev_begin", 0);
2486
2487    // For each abbrevation.
2488    for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2489      // Get abbreviation data
2490      const DIEAbbrev *Abbrev = Abbreviations[i];
2491
2492      // Emit the abbrevations code (base 1 index.)
2493      EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2494
2495      // Emit the abbreviations data.
2496      Abbrev->Emit(this);
2497      Asm->O << '\n';
2498    }
2499
2500    // Mark end of abbreviations.
2501    EmitULEB128(0, "EOM(3)");
2502
2503    EmitLabel("abbrev_end", 0);
2504    Asm->O << '\n';
2505  }
2506}
2507
2508/// emitEndOfLineMatrix - Emit the last address of the section and the end of
2509/// the line matrix.
2510///
2511void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2512  // Define last address of section.
2513  Asm->EmitInt8(0); EOL("Extended Op");
2514  Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2515  Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2516  EmitReference("section_end", SectionEnd); EOL("Section end label");
2517
2518  // Mark end of matrix.
2519  Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2520  Asm->EmitInt8(1);
2521  Asm->EmitInt8(1);
2522}
2523
2524/// emitDebugLines - Emit source line information.
2525///
2526void DwarfDebug::emitDebugLines() {
2527  // If the target is using .loc/.file, the assembler will be emitting the
2528  // .debug_line table automatically.
2529  if (MAI->hasDotLocAndDotFile())
2530    return;
2531
2532  // Minimum line delta, thus ranging from -10..(255-10).
2533  const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2534  // Maximum line delta, thus ranging from -10..(255-10).
2535  const int MaxLineDelta = 255 + MinLineDelta;
2536
2537  // Start the dwarf line section.
2538  Asm->OutStreamer.SwitchSection(
2539                            Asm->getObjFileLowering().getDwarfLineSection());
2540
2541  // Construct the section header.
2542  EmitDifference("line_end", 0, "line_begin", 0, true);
2543  EOL("Length of Source Line Info");
2544  EmitLabel("line_begin", 0);
2545
2546  Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2547
2548  EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2549  EOL("Prolog Length");
2550  EmitLabel("line_prolog_begin", 0);
2551
2552  Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2553  Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2554  Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2555  Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2556  Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2557
2558  // Line number standard opcode encodings argument count
2559  Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2560  Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2561  Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2562  Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2563  Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2564  Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2565  Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2566  Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2567  Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2568
2569  // Emit directories.
2570  for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2571    const std::string &Dir = getSourceDirectoryName(DI);
2572    if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2573    Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2574  }
2575
2576  Asm->EmitInt8(0); EOL("End of directories");
2577
2578  // Emit files.
2579  for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2580    // Remember source id starts at 1.
2581    std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2582    const std::string &FN = getSourceFileName(Id.second);
2583    if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2584    Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2585
2586    EmitULEB128(Id.first, "Directory #");
2587    EmitULEB128(0, "Mod date");
2588    EmitULEB128(0, "File size");
2589  }
2590
2591  Asm->EmitInt8(0); EOL("End of files");
2592
2593  EmitLabel("line_prolog_end", 0);
2594
2595  // A sequence for each text section.
2596  unsigned SecSrcLinesSize = SectionSourceLines.size();
2597
2598  for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2599    // Isolate current sections line info.
2600    const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2601
2602    /*if (Asm->isVerbose()) {
2603      const MCSection *S = SectionMap[j + 1];
2604      O << '\t' << MAI->getCommentString() << " Section"
2605        << S->getName() << '\n';
2606    }*/
2607    Asm->O << '\n';
2608
2609    // Dwarf assumes we start with first line of first source file.
2610    unsigned Source = 1;
2611    unsigned Line = 1;
2612
2613    // Construct rows of the address, source, line, column matrix.
2614    for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2615      const SrcLineInfo &LineInfo = LineInfos[i];
2616      unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2617      if (!LabelID) continue;
2618
2619      if (LineInfo.getLine() == 0) continue;
2620
2621      if (!Asm->isVerbose())
2622        Asm->O << '\n';
2623      else {
2624        std::pair<unsigned, unsigned> SourceID =
2625          getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2626        O << '\t' << MAI->getCommentString() << ' '
2627          << getSourceDirectoryName(SourceID.first) << '/'
2628          << getSourceFileName(SourceID.second)
2629          << ':' << utostr_32(LineInfo.getLine()) << '\n';
2630      }
2631
2632      // Define the line address.
2633      Asm->EmitInt8(0); EOL("Extended Op");
2634      Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2635      Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2636      EmitReference("label",  LabelID); EOL("Location label");
2637
2638      // If change of source, then switch to the new source.
2639      if (Source != LineInfo.getSourceID()) {
2640        Source = LineInfo.getSourceID();
2641        Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2642        EmitULEB128(Source, "New Source");
2643      }
2644
2645      // If change of line.
2646      if (Line != LineInfo.getLine()) {
2647        // Determine offset.
2648        int Offset = LineInfo.getLine() - Line;
2649        int Delta = Offset - MinLineDelta;
2650
2651        // Update line.
2652        Line = LineInfo.getLine();
2653
2654        // If delta is small enough and in range...
2655        if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2656          // ... then use fast opcode.
2657          Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2658        } else {
2659          // ... otherwise use long hand.
2660          Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2661          EOL("DW_LNS_advance_line");
2662          EmitSLEB128(Offset, "Line Offset");
2663          Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2664        }
2665      } else {
2666        // Copy the previous row (different address or source)
2667        Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2668      }
2669    }
2670
2671    emitEndOfLineMatrix(j + 1);
2672  }
2673
2674  if (SecSrcLinesSize == 0)
2675    // Because we're emitting a debug_line section, we still need a line
2676    // table. The linker and friends expect it to exist. If there's nothing to
2677    // put into it, emit an empty table.
2678    emitEndOfLineMatrix(1);
2679
2680  EmitLabel("line_end", 0);
2681  Asm->O << '\n';
2682}
2683
2684/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2685///
2686void DwarfDebug::emitCommonDebugFrame() {
2687  if (!MAI->doesDwarfRequireFrameSection())
2688    return;
2689
2690  int stackGrowth =
2691    Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2692      TargetFrameInfo::StackGrowsUp ?
2693    TD->getPointerSize() : -TD->getPointerSize();
2694
2695  // Start the dwarf frame section.
2696  Asm->OutStreamer.SwitchSection(
2697                              Asm->getObjFileLowering().getDwarfFrameSection());
2698
2699  EmitLabel("debug_frame_common", 0);
2700  EmitDifference("debug_frame_common_end", 0,
2701                 "debug_frame_common_begin", 0, true);
2702  EOL("Length of Common Information Entry");
2703
2704  EmitLabel("debug_frame_common_begin", 0);
2705  Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2706  EOL("CIE Identifier Tag");
2707  Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2708  EOL("CIE Version");
2709  Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2710  EOL("CIE Augmentation");
2711  EmitULEB128(1, "CIE Code Alignment Factor");
2712  EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2713  Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2714  EOL("CIE RA Column");
2715
2716  std::vector<MachineMove> Moves;
2717  RI->getInitialFrameState(Moves);
2718
2719  EmitFrameMoves(NULL, 0, Moves, false);
2720
2721  Asm->EmitAlignment(2, 0, 0, false);
2722  EmitLabel("debug_frame_common_end", 0);
2723  Asm->O << '\n';
2724}
2725
2726/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2727/// section.
2728void
2729DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2730  if (!MAI->doesDwarfRequireFrameSection())
2731    return;
2732
2733  // Start the dwarf frame section.
2734  Asm->OutStreamer.SwitchSection(
2735                              Asm->getObjFileLowering().getDwarfFrameSection());
2736
2737  EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2738                 "debug_frame_begin", DebugFrameInfo.Number, true);
2739  EOL("Length of Frame Information Entry");
2740
2741  EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2742
2743  EmitSectionOffset("debug_frame_common", "section_debug_frame",
2744                    0, 0, true, false);
2745  EOL("FDE CIE offset");
2746
2747  EmitReference("func_begin", DebugFrameInfo.Number);
2748  EOL("FDE initial location");
2749  EmitDifference("func_end", DebugFrameInfo.Number,
2750                 "func_begin", DebugFrameInfo.Number);
2751  EOL("FDE address range");
2752
2753  EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2754                 false);
2755
2756  Asm->EmitAlignment(2, 0, 0, false);
2757  EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2758  Asm->O << '\n';
2759}
2760
2761/// emitDebugPubNames - Emit visible names into a debug pubnames section.
2762///
2763void DwarfDebug::emitDebugPubNames() {
2764  // Start the dwarf pubnames section.
2765  Asm->OutStreamer.SwitchSection(
2766                          Asm->getObjFileLowering().getDwarfPubNamesSection());
2767
2768  EmitDifference("pubnames_end", ModuleCU->getID(),
2769                 "pubnames_begin", ModuleCU->getID(), true);
2770  EOL("Length of Public Names Info");
2771
2772  EmitLabel("pubnames_begin", ModuleCU->getID());
2773
2774  Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2775
2776  EmitSectionOffset("info_begin", "section_info",
2777                    ModuleCU->getID(), 0, true, false);
2778  EOL("Offset of Compilation Unit Info");
2779
2780  EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2781                 true);
2782  EOL("Compilation Unit Length");
2783
2784  const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2785  for (StringMap<DIE*>::const_iterator
2786         GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2787    const char *Name = GI->getKeyData();
2788    DIE * Entity = GI->second;
2789
2790    Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2791
2792    if (Asm->VerboseAsm)
2793      Asm->OutStreamer.AddComment("External Name");
2794    Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2795  }
2796
2797  Asm->EmitInt32(0); EOL("End Mark");
2798  EmitLabel("pubnames_end", ModuleCU->getID());
2799  Asm->O << '\n';
2800}
2801
2802void DwarfDebug::emitDebugPubTypes() {
2803  // Start the dwarf pubnames section.
2804  Asm->OutStreamer.SwitchSection(
2805                          Asm->getObjFileLowering().getDwarfPubTypesSection());
2806  EmitDifference("pubtypes_end", ModuleCU->getID(),
2807                 "pubtypes_begin", ModuleCU->getID(), true);
2808  EOL("Length of Public Types Info");
2809
2810  EmitLabel("pubtypes_begin", ModuleCU->getID());
2811
2812  if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2813  Asm->EmitInt16(dwarf::DWARF_VERSION);
2814
2815  EmitSectionOffset("info_begin", "section_info",
2816                    ModuleCU->getID(), 0, true, false);
2817  EOL("Offset of Compilation ModuleCU Info");
2818
2819  EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2820                 true);
2821  EOL("Compilation ModuleCU Length");
2822
2823  const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2824  for (StringMap<DIE*>::const_iterator
2825         GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2826    const char *Name = GI->getKeyData();
2827    DIE * Entity = GI->second;
2828
2829    if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2830    Asm->EmitInt32(Entity->getOffset());
2831
2832    if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2833    Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2834  }
2835
2836  Asm->EmitInt32(0); EOL("End Mark");
2837  EmitLabel("pubtypes_end", ModuleCU->getID());
2838  Asm->O << '\n';
2839}
2840
2841/// emitDebugStr - Emit visible names into a debug str section.
2842///
2843void DwarfDebug::emitDebugStr() {
2844  // Check to see if it is worth the effort.
2845  if (!StringPool.empty()) {
2846    // Start the dwarf str section.
2847    Asm->OutStreamer.SwitchSection(
2848                                Asm->getObjFileLowering().getDwarfStrSection());
2849
2850    // For each of strings in the string pool.
2851    for (unsigned StringID = 1, N = StringPool.size();
2852         StringID <= N; ++StringID) {
2853      // Emit a label for reference from debug information entries.
2854      EmitLabel("string", StringID);
2855
2856      // Emit the string itself.
2857      const std::string &String = StringPool[StringID];
2858      Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2859    }
2860
2861    Asm->O << '\n';
2862  }
2863}
2864
2865/// emitDebugLoc - Emit visible names into a debug loc section.
2866///
2867void DwarfDebug::emitDebugLoc() {
2868  // Start the dwarf loc section.
2869  Asm->OutStreamer.SwitchSection(
2870                              Asm->getObjFileLowering().getDwarfLocSection());
2871}
2872
2873/// EmitDebugARanges - Emit visible names into a debug aranges section.
2874///
2875void DwarfDebug::EmitDebugARanges() {
2876  // Start the dwarf aranges section.
2877  Asm->OutStreamer.SwitchSection(
2878                          Asm->getObjFileLowering().getDwarfARangesSection());
2879
2880  // FIXME - Mock up
2881#if 0
2882  CompileUnit *Unit = GetBaseCompileUnit();
2883
2884  // Don't include size of length
2885  Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2886
2887  Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2888
2889  EmitReference("info_begin", Unit->getID());
2890  EOL("Offset of Compilation Unit Info");
2891
2892  Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2893
2894  Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2895
2896  Asm->EmitInt16(0);  EOL("Pad (1)");
2897  Asm->EmitInt16(0);  EOL("Pad (2)");
2898
2899  // Range 1
2900  EmitReference("text_begin", 0); EOL("Address");
2901  EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2902
2903  Asm->EmitInt32(0); EOL("EOM (1)");
2904  Asm->EmitInt32(0); EOL("EOM (2)");
2905#endif
2906}
2907
2908/// emitDebugRanges - Emit visible names into a debug ranges section.
2909///
2910void DwarfDebug::emitDebugRanges() {
2911  // Start the dwarf ranges section.
2912  Asm->OutStreamer.SwitchSection(
2913                            Asm->getObjFileLowering().getDwarfRangesSection());
2914}
2915
2916/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2917///
2918void DwarfDebug::emitDebugMacInfo() {
2919  if (const MCSection *LineInfo =
2920      Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2921    // Start the dwarf macinfo section.
2922    Asm->OutStreamer.SwitchSection(LineInfo);
2923  }
2924}
2925
2926/// emitDebugInlineInfo - Emit inline info using following format.
2927/// Section Header:
2928/// 1. length of section
2929/// 2. Dwarf version number
2930/// 3. address size.
2931///
2932/// Entries (one "entry" for each function that was inlined):
2933///
2934/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2935///   otherwise offset into __debug_str for regular function name.
2936/// 2. offset into __debug_str section for regular function name.
2937/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2938/// instances for the function.
2939///
2940/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2941/// inlined instance; the die_offset points to the inlined_subroutine die in the
2942/// __debug_info section, and the low_pc is the starting address for the
2943/// inlining instance.
2944void DwarfDebug::emitDebugInlineInfo() {
2945  if (!MAI->doesDwarfUsesInlineInfoSection())
2946    return;
2947
2948  if (!ModuleCU)
2949    return;
2950
2951  Asm->OutStreamer.SwitchSection(
2952                        Asm->getObjFileLowering().getDwarfDebugInlineSection());
2953
2954  EmitDifference("debug_inlined_end", 1,
2955                 "debug_inlined_begin", 1, true);
2956  EOL("Length of Debug Inlined Information Entry");
2957
2958  EmitLabel("debug_inlined_begin", 1);
2959
2960  Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2961  Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2962
2963  for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2964         E = InlinedSPNodes.end(); I != E; ++I) {
2965
2966    MDNode *Node = *I;
2967    DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2968      = InlineInfo.find(Node);
2969    SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2970    DISubprogram SP(Node);
2971    StringRef LName = SP.getLinkageName();
2972    StringRef Name = SP.getName();
2973
2974    if (LName.empty()) {
2975      Asm->OutStreamer.EmitBytes(Name, 0);
2976      Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2977    } else
2978      EmitSectionOffset("string", "section_str",
2979                      StringPool.idFor(getRealLinkageName(LName)), false, true);
2980
2981    EOL("MIPS linkage name");
2982    EmitSectionOffset("string", "section_str",
2983                      StringPool.idFor(Name), false, true);
2984    EOL("Function name");
2985    EmitULEB128(Labels.size(), "Inline count");
2986
2987    for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2988           LE = Labels.end(); LI != LE; ++LI) {
2989      DIE *SP = LI->second;
2990      Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2991
2992      if (TD->getPointerSize() == sizeof(int32_t))
2993        O << MAI->getData32bitsDirective();
2994      else
2995        O << MAI->getData64bitsDirective();
2996
2997      PrintLabelName("label", LI->first); EOL("low_pc");
2998    }
2999  }
3000
3001  EmitLabel("debug_inlined_end", 1);
3002  Asm->O << '\n';
3003}
3004