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