lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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