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