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