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