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