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