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