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