lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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