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
1806   // Collect arguments for current function.
1807   if (Scope == CurrentFnDbgScope)
1808     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
1809       if (DbgVariable *ArgDV = CurrentFnArguments[i])
1810         if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
1811           Children.push_back(Arg);
1812
1813   // Collect lexical scope childrens first.
1814   const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1815   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
1816     if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
1817       Children.push_back(Variable);
1818   const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1819   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
1820     if (DIE *Nested = constructScopeDIE(Scopes[j]))
1821       Children.push_back(Nested);
1822   DIScope DS(Scope->getScopeNode());
1823   DIE *ScopeDIE = NULL;
1824   if (Scope->getInlinedAt())
1825     ScopeDIE = constructInlinedScopeDIE(Scope);
1826   else if (DS.isSubprogram()) {
1827     ProcessedSPNodes.insert(DS);
1828     if (Scope->isAbstractScope()) {
1829       ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1830       // Note down abstract DIE.
1831       if (ScopeDIE)
1832         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1833     }
1834     else
1835       ScopeDIE = updateSubprogramScopeDIE(DS);
1836   }
1837   else {
1838     // There is no need to emit empty lexical block DIE.
1839     if (Children.empty())
1840       return NULL;
1841     ScopeDIE = constructLexicalScopeDIE(Scope);
1842   }
1843
1844   if (!ScopeDIE) return NULL;
1845
1846   // Add children
1847   for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
1848          E = Children.end(); I != E; ++I)
1849     ScopeDIE->addChild(*I);
1850
1851   if (DS.isSubprogram())
1852     addPubTypes(DISubprogram(DS));
1853
1854  return ScopeDIE;
1855 }
1856
1857 /// GetOrCreateSourceID - Look up the source id with the given directory and
1858 /// source file names. If none currently exists, create a new id and insert it
1859 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1860 /// maps as well.
1861
1862 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName){
1863   // If FE did not provide a file name, then assume stdin.
1864   if (FileName.empty())
1865     return GetOrCreateSourceID("<stdin>");
1866
1867   StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
1868   if (Entry.getValue())
1869     return Entry.getValue();
1870
1871   unsigned SrcId = SourceIdMap.size();
1872   Entry.setValue(SrcId);
1873
1874   // Print out a .file directive to specify files for .loc directives.
1875   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, FileName);
1876
1877   return SrcId;
1878 }
1879
1880 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1881 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1882   CompileUnit *TheCU = getCompileUnit(NS);
1883   DIE *NDie = TheCU->getDIE(NS);
1884   if (NDie)
1885     return NDie;
1886   NDie = new DIE(dwarf::DW_TAG_namespace);
1887   TheCU->insertDIE(NS, NDie);
1888   if (!NS.getName().empty())
1889     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1890   addSourceLine(NDie, NS);
1891   addToContextOwner(NDie, NS.getContext());
1892   return NDie;
1893 }
1894
1895 /// constructCompileUnit - Create new CompileUnit for the given
1896 /// metadata node with tag DW_TAG_compile_unit.
1897 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1898   DICompileUnit DIUnit(N);
1899   StringRef FN = DIUnit.getFilename();
1900   StringRef Dir = DIUnit.getDirectory();
1901   unsigned ID = GetOrCreateSourceID(FN);
1902
1903   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1904   addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1905             DIUnit.getProducer());
1906   addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1907           DIUnit.getLanguage());
1908   addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1909   // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1910   // simplifies debug range entries.
1911   addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1912   // DW_AT_stmt_list is a offset of line number information for this
1913   // compile unit in debug_line section.
1914   if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1915     addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1916              Asm->GetTempSymbol("section_line"));
1917   else
1918     addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1919
1920   if (!Dir.empty())
1921     addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1922   if (DIUnit.isOptimized())
1923     addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1924
1925   StringRef Flags = DIUnit.getFlags();
1926   if (!Flags.empty())
1927     addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1928
1929   unsigned RVer = DIUnit.getRunTimeVersion();
1930   if (RVer)
1931     addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1932             dwarf::DW_FORM_data1, RVer);
1933
1934   CompileUnit *NewCU = new CompileUnit(ID, Die);
1935   if (!FirstCU)
1936     FirstCU = NewCU;
1937   CUMap.insert(std::make_pair(N, NewCU));
1938 }
1939
1940 /// getCompielUnit - Get CompileUnit DIE.
1941 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1942   assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1943   DIDescriptor D(N);
1944   const MDNode *CUNode = NULL;
1945   if (D.isCompileUnit())
1946     CUNode = N;
1947   else if (D.isSubprogram())
1948     CUNode = DISubprogram(N).getCompileUnit();
1949   else if (D.isType())
1950     CUNode = DIType(N).getCompileUnit();
1951   else if (D.isGlobalVariable())
1952     CUNode = DIGlobalVariable(N).getCompileUnit();
1953   else if (D.isVariable())
1954     CUNode = DIVariable(N).getCompileUnit();
1955   else if (D.isNameSpace())
1956     CUNode = DINameSpace(N).getCompileUnit();
1957   else if (D.isFile())
1958     CUNode = DIFile(N).getCompileUnit();
1959   else
1960     return FirstCU;
1961
1962   DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1963     = CUMap.find(CUNode);
1964   if (I == CUMap.end())
1965     return FirstCU;
1966   return I->second;
1967 }
1968
1969 /// isUnsignedDIType - Return true if type encoding is unsigned.
1970 static bool isUnsignedDIType(DIType Ty) {
1971   DIDerivedType DTy(Ty);
1972   if (DTy.Verify())
1973     return isUnsignedDIType(DTy.getTypeDerivedFrom());
1974
1975   DIBasicType BTy(Ty);
1976   if (BTy.Verify()) {
1977     unsigned Encoding = BTy.getEncoding();
1978     if (Encoding == dwarf::DW_ATE_unsigned ||
1979         Encoding == dwarf::DW_ATE_unsigned_char)
1980       return true;
1981   }
1982   return false;
1983 }
1984
1985 // Return const exprssion if value is a GEP to access merged global
1986 // constant. e.g.
1987 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1988 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1989   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1990   if (!CE || CE->getNumOperands() != 3 ||
1991       CE->getOpcode() != Instruction::GetElementPtr)
1992     return NULL;
1993
1994   // First operand points to a global value.
1995   if (!isa<GlobalValue>(CE->getOperand(0)))
1996     return NULL;
1997
1998   // Second operand is zero.
1999   const ConstantInt *CI =
2000     dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
2001   if (!CI || !CI->isZero())
2002     return NULL;
2003
2004   // Third operand is offset.
2005   if (!isa<ConstantInt>(CE->getOperand(2)))
2006     return NULL;
2007
2008   return CE;
2009 }
2010
2011 /// constructGlobalVariableDIE - Construct global variable DIE.
2012 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
2013   DIGlobalVariable GV(N);
2014
2015   // If debug information is malformed then ignore it.
2016   if (GV.Verify() == false)
2017     return;
2018
2019   // Check for pre-existence.
2020   CompileUnit *TheCU = getCompileUnit(N);
2021   if (TheCU->getDIE(GV))
2022     return;
2023
2024   DIType GTy = GV.getType();
2025   DIE *VariableDIE = new DIE(GV.getTag());
2026
2027   bool isGlobalVariable = GV.getGlobal() != NULL;
2028
2029   // Add name.
2030   addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
2031             GV.getDisplayName());
2032   StringRef LinkageName = GV.getLinkageName();
2033   if (!LinkageName.empty() && isGlobalVariable)
2034     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
2035               getRealLinkageName(LinkageName));
2036   // Add type.
2037   addType(VariableDIE, GTy);
2038   if (GTy.isCompositeType() && !GTy.getName().empty()
2039       && !GTy.isForwardDecl()) {
2040     DIEEntry *Entry = TheCU->getDIEEntry(GTy);
2041     assert(Entry && "Missing global type!");
2042     TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
2043   }
2044   // Add scoping info.
2045   if (!GV.isLocalToUnit()) {
2046     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
2047     // Expose as global.
2048     TheCU->addGlobal(GV.getName(), VariableDIE);
2049   }
2050   // Add line number info.
2051   addSourceLine(VariableDIE, GV);
2052   // Add to map.
2053   TheCU->insertDIE(N, VariableDIE);
2054   // Add to context owner.
2055   DIDescriptor GVContext = GV.getContext();
2056   addToContextOwner(VariableDIE, GVContext);
2057   // Add location.
2058   if (isGlobalVariable) {
2059     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2060     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2061     addLabel(Block, 0, dwarf::DW_FORM_udata,
2062              Asm->Mang->getSymbol(GV.getGlobal()));
2063     // Do not create specification DIE if context is either compile unit
2064     // or a subprogram.
2065     if (GV.isDefinition() && !GVContext.isCompileUnit() &&
2066         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
2067       // Create specification DIE.
2068       DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
2069       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
2070                   dwarf::DW_FORM_ref4, VariableDIE);
2071       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
2072       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
2073       TheCU->addDie(VariableSpecDIE);
2074     } else {
2075       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2076     }
2077   } else if (ConstantInt *CI =
2078              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
2079     addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
2080   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
2081     // GV is a merged global.
2082     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2083     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2084     addLabel(Block, 0, dwarf::DW_FORM_udata,
2085              Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
2086     ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
2087     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
2088     addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
2089     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
2090     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2091   }
2092
2093   return;
2094 }
2095
2096 /// construct SubprogramDIE - Construct subprogram DIE.
2097 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2098   DISubprogram SP(N);
2099
2100   // Check for pre-existence.
2101   CompileUnit *TheCU = getCompileUnit(N);
2102   if (TheCU->getDIE(N))
2103     return;
2104
2105   if (!SP.isDefinition())
2106     // This is a method declaration which will be handled while constructing
2107     // class type.
2108     return;
2109
2110   DIE *SubprogramDie = createSubprogramDIE(SP);
2111
2112   // Add to map.
2113   TheCU->insertDIE(N, SubprogramDie);
2114
2115   // Add to context owner.
2116   addToContextOwner(SubprogramDie, SP.getContext());
2117
2118   // Expose as global.
2119   TheCU->addGlobal(SP.getName(), SubprogramDie);
2120
2121   return;
2122 }
2123
2124 /// beginModule - Emit all Dwarf sections that should come prior to the
2125 /// content. Create global DIEs and emit initial debug info sections.
2126 /// This is inovked by the target AsmPrinter.
2127 void DwarfDebug::beginModule(Module *M) {
2128   if (DisableDebugInfoPrinting)
2129     return;
2130
2131   DebugInfoFinder DbgFinder;
2132   DbgFinder.processModule(*M);
2133
2134   bool HasDebugInfo = false;
2135
2136   // Scan all the compile-units to see if there are any marked as the main unit.
2137   // if not, we do not generate debug info.
2138   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2139        E = DbgFinder.compile_unit_end(); I != E; ++I) {
2140     if (DICompileUnit(*I).isMain()) {
2141       HasDebugInfo = true;
2142       break;
2143     }
2144   }
2145
2146   if (!HasDebugInfo) return;
2147
2148   // Tell MMI that we have debug info.
2149   MMI->setDebugInfoAvailability(true);
2150
2151   // Emit initial sections.
2152   EmitSectionLabels();
2153
2154   // Create all the compile unit DIEs.
2155   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2156          E = DbgFinder.compile_unit_end(); I != E; ++I)
2157     constructCompileUnit(*I);
2158
2159   // Create DIEs for each subprogram.
2160   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2161          E = DbgFinder.subprogram_end(); I != E; ++I)
2162     constructSubprogramDIE(*I);
2163
2164   // Create DIEs for each global variable.
2165   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2166          E = DbgFinder.global_variable_end(); I != E; ++I)
2167     constructGlobalVariableDIE(*I);
2168
2169   //getOrCreateTypeDIE
2170   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2171     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2172       getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2173
2174   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2175     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2176       getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2177
2178   // Prime section data.
2179   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2180 }
2181
2182 /// endModule - Emit all Dwarf sections that should come after the content.
2183 ///
2184 void DwarfDebug::endModule() {
2185   if (!FirstCU) return;
2186   const Module *M = MMI->getModule();
2187   DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2188   if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2189     for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2190       if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2191       DISubprogram SP(AllSPs->getOperand(SI));
2192       if (!SP.Verify()) continue;
2193
2194       // Collect info for variables that were optimized out.
2195       if (!SP.isDefinition()) continue;
2196       StringRef FName = SP.getLinkageName();
2197       if (FName.empty())
2198         FName = SP.getName();
2199       NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
2200       if (!NMD) continue;
2201       unsigned E = NMD->getNumOperands();
2202       if (!E) continue;
2203       DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2204       DeadFnScopeMap[SP] = Scope;
2205       for (unsigned I = 0; I != E; ++I) {
2206         DIVariable DV(NMD->getOperand(I));
2207         if (!DV.Verify()) continue;
2208         Scope->addVariable(new DbgVariable(DV));
2209       }
2210
2211       // Construct subprogram DIE and add variables DIEs.
2212       constructSubprogramDIE(SP);
2213       DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2214       const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2215       for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2216         DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2217         if (VariableDIE)
2218           ScopeDIE->addChild(VariableDIE);
2219       }
2220     }
2221   }
2222
2223   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2224   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2225          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2226     DIE *ISP = *AI;
2227     addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2228   }
2229
2230   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2231          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2232     DIE *SPDie = CI->first;
2233     const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2234     if (!N) continue;
2235     DIE *NDie = getCompileUnit(N)->getDIE(N);
2236     if (!NDie) continue;
2237     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2238   }
2239
2240   // Standard sections final addresses.
2241   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2242   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2243   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2244   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2245
2246   // End text sections.
2247   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2248     Asm->OutStreamer.SwitchSection(SectionMap[i]);
2249     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2250   }
2251
2252   // Emit common frame information.
2253   emitCommonDebugFrame();
2254
2255   // Emit function debug frame information
2256   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2257          E = DebugFrames.end(); I != E; ++I)
2258     emitFunctionDebugFrame(*I);
2259
2260   // Compute DIE offsets and sizes.
2261   computeSizeAndOffsets();
2262
2263   // Emit all the DIEs into a debug info section
2264   emitDebugInfo();
2265
2266   // Corresponding abbreviations into a abbrev section.
2267   emitAbbreviations();
2268
2269   // Emit info into a debug pubnames section.
2270   emitDebugPubNames();
2271
2272   // Emit info into a debug pubtypes section.
2273   emitDebugPubTypes();
2274
2275   // Emit info into a debug loc section.
2276   emitDebugLoc();
2277
2278   // Emit info into a debug aranges section.
2279   EmitDebugARanges();
2280
2281   // Emit info into a debug ranges section.
2282   emitDebugRanges();
2283
2284   // Emit info into a debug macinfo section.
2285   emitDebugMacInfo();
2286
2287   // Emit inline info.
2288   emitDebugInlineInfo();
2289
2290   // Emit info into a debug str section.
2291   emitDebugStr();
2292
2293   // clean up.
2294   DeleteContainerSeconds(DeadFnScopeMap);
2295   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2296          E = CUMap.end(); I != E; ++I)
2297     delete I->second;
2298   FirstCU = NULL;  // Reset for the next Module, if any.
2299 }
2300
2301 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2302 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2303                                               DebugLoc ScopeLoc) {
2304
2305   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2306   if (AbsDbgVariable)
2307     return AbsDbgVariable;
2308
2309   LLVMContext &Ctx = Var->getContext();
2310   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2311   if (!Scope)
2312     return NULL;
2313
2314   AbsDbgVariable = new DbgVariable(Var);
2315   Scope->addVariable(AbsDbgVariable);
2316   AbstractVariables[Var] = AbsDbgVariable;
2317   return AbsDbgVariable;
2318 }
2319
2320 /// addCurrentFnArgument - If Var is an current function argument that add
2321 /// it in CurrentFnArguments list.
2322 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
2323                                       DbgVariable *Var, DbgScope *Scope) {
2324   if (Scope != CurrentFnDbgScope)
2325     return false;
2326   DIVariable DV = Var->getVariable();
2327   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2328     return false;
2329   unsigned ArgNo = DV.getArgNumber();
2330   if (ArgNo == 0)
2331     return false;
2332
2333   size_t Size = CurrentFnArguments.size();
2334   if (Size == 0)
2335     CurrentFnArguments.resize(MF->getFunction()->arg_size());
2336   // llvm::Function argument size is not good indicator of how many
2337   // arguments does the function have at source level.
2338   if (ArgNo > Size)
2339     CurrentFnArguments.resize(ArgNo * 2);
2340   CurrentFnArguments[ArgNo - 1] = Var;
2341   return true;
2342 }
2343
2344 /// collectVariableInfoFromMMITable - Collect variable information from
2345 /// side table maintained by MMI.
2346 void
2347 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2348                                    SmallPtrSet<const MDNode *, 16> &Processed) {
2349   const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2350   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2351   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2352          VE = VMap.end(); VI != VE; ++VI) {
2353     const MDNode *Var = VI->first;
2354     if (!Var) continue;
2355     Processed.insert(Var);
2356     DIVariable DV(Var);
2357     const std::pair<unsigned, DebugLoc> &VP = VI->second;
2358
2359     DbgScope *Scope = 0;
2360     if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2361       Scope = ConcreteScopes.lookup(IA);
2362     if (Scope == 0)
2363       Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2364
2365     // If variable scope is not found then skip this variable.
2366     if (Scope == 0)
2367       continue;
2368
2369     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2370     DbgVariable *RegVar = new DbgVariable(DV);
2371     recordVariableFrameIndex(RegVar, VP.first);
2372     if (!addCurrentFnArgument(MF, RegVar, Scope))
2373       Scope->addVariable(RegVar);
2374     if (AbsDbgVariable) {
2375       recordVariableFrameIndex(AbsDbgVariable, VP.first);
2376       VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2377     }
2378   }
2379 }
2380
2381 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2382 /// DBG_VALUE instruction, is in a defined reg.
2383 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2384   assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2385   if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2386     return true;
2387   return false;
2388 }
2389
2390 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2391 void
2392 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2393                                 SmallPtrSet<const MDNode *, 16> &Processed) {
2394
2395   /// collection info from MMI table.
2396   collectVariableInfoFromMMITable(MF, Processed);
2397
2398   SmallVector<const MachineInstr *, 8> DbgValues;
2399   // Collect variable information from DBG_VALUE machine instructions;
2400   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2401        I != E; ++I)
2402     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2403          II != IE; ++II) {
2404       const MachineInstr *MInsn = II;
2405       if (!MInsn->isDebugValue())
2406         continue;
2407       DbgValues.push_back(MInsn);
2408     }
2409
2410   // This is a collection of DBV_VALUE instructions describing same variable.
2411   SmallVector<const MachineInstr *, 4> MultipleValues;
2412   for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2413         E = DbgValues.end(); I != E; ++I) {
2414     const MachineInstr *MInsn = *I;
2415     MultipleValues.clear();
2416     if (isDbgValueInDefinedReg(MInsn))
2417       MultipleValues.push_back(MInsn);
2418     DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2419     if (Processed.count(DV) != 0)
2420       continue;
2421
2422     const MachineInstr *PrevMI = MInsn;
2423     for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2424            ME = DbgValues.end(); MI != ME; ++MI) {
2425       const MDNode *Var =
2426         (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2427       if (Var == DV &&
2428           !PrevMI->isIdenticalTo(*MI))
2429         MultipleValues.push_back(*MI);
2430       PrevMI = *MI;
2431     }
2432
2433     DbgScope *Scope = NULL;
2434     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2435         DISubprogram(DV.getContext()).describes(MF->getFunction()))
2436       Scope = CurrentFnDbgScope;
2437     else
2438       Scope = findDbgScope(MInsn);
2439     // If variable scope is not found then skip this variable.
2440     if (!Scope)
2441       continue;
2442
2443     Processed.insert(DV);
2444     DbgVariable *RegVar = new DbgVariable(DV);
2445     if (!addCurrentFnArgument(MF, RegVar, Scope))
2446       Scope->addVariable(RegVar);
2447     if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2448       DbgVariableToDbgInstMap[AbsVar] = MInsn;
2449       VarToAbstractVarMap[RegVar] = AbsVar;
2450     }
2451     if (MultipleValues.size() <= 1) {
2452       DbgVariableToDbgInstMap[RegVar] = MInsn;
2453       continue;
2454     }
2455
2456     // handle multiple DBG_VALUE instructions describing one variable.
2457     if (DotDebugLocEntries.empty())
2458       RegVar->setDotDebugLocOffset(0);
2459     else
2460       RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2461     const MachineInstr *Begin = NULL;
2462     const MachineInstr *End = NULL;
2463     for (SmallVector<const MachineInstr *, 4>::iterator
2464            MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2465          MVI != MVE; ++MVI) {
2466       if (!Begin) {
2467         Begin = *MVI;
2468         continue;
2469       }
2470       End = *MVI;
2471       MachineLocation MLoc;
2472       if (Begin->getNumOperands() == 3) {
2473         if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2474           MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2475       } else
2476         MLoc = Asm->getDebugValueLocation(Begin);
2477
2478       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2479       const MCSymbol *SLabel = getLabelBeforeInsn(End);
2480       if (MLoc.getReg())
2481         DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2482
2483       Begin = End;
2484       if (MVI + 1 == MVE) {
2485         // If End is the last instruction then its value is valid
2486         // until the end of the funtion.
2487         MachineLocation EMLoc;
2488         if (End->getNumOperands() == 3) {
2489           if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2490           EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2491         } else
2492           EMLoc = Asm->getDebugValueLocation(End);
2493         if (EMLoc.getReg())
2494           DotDebugLocEntries.
2495             push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2496       }
2497     }
2498     DotDebugLocEntries.push_back(DotDebugLocEntry());
2499   }
2500
2501   // Collect info for variables that were optimized out.
2502   const Function *F = MF->getFunction();
2503   if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
2504     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2505       DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2506       if (!DV || !Processed.insert(DV))
2507         continue;
2508       DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2509       if (Scope)
2510         Scope->addVariable(new DbgVariable(DV));
2511     }
2512   }
2513 }
2514
2515 /// getLabelBeforeInsn - Return Label preceding the instruction.
2516 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2517   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2518     LabelsBeforeInsn.find(MI);
2519   if (I == LabelsBeforeInsn.end())
2520     // FunctionBeginSym always preceeds all the instruction in current function.
2521     return FunctionBeginSym;
2522   return I->second;
2523 }
2524
2525 /// getLabelAfterInsn - Return Label immediately following the instruction.
2526 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2527   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2528     LabelsAfterInsn.find(MI);
2529   if (I == LabelsAfterInsn.end())
2530     return NULL;
2531   return I->second;
2532 }
2533
2534 /// beginInstruction - Process beginning of an instruction.
2535 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
2536   if (InsnNeedsLabel.count(MI) == 0) {
2537     LabelsBeforeInsn[MI] = PrevLabel;
2538     return;
2539   }
2540
2541   // Check location.
2542   DebugLoc DL = MI->getDebugLoc();
2543   if (!DL.isUnknown()) {
2544     const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2545     PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2546     PrevInstLoc = DL;
2547     LabelsBeforeInsn[MI] = PrevLabel;
2548     return;
2549   }
2550
2551   // If location is unknown then use temp label for this DBG_VALUE
2552   // instruction.
2553   if (MI->isDebugValue()) {
2554     PrevLabel = MMI->getContext().CreateTempSymbol();
2555     Asm->OutStreamer.EmitLabel(PrevLabel);
2556     LabelsBeforeInsn[MI] = PrevLabel;
2557     return;
2558   }
2559
2560   if (UnknownLocations) {
2561     PrevLabel = recordSourceLine(0, 0, 0);
2562     LabelsBeforeInsn[MI] = PrevLabel;
2563     return;
2564   }
2565
2566   assert (0 && "Instruction is not processed!");
2567 }
2568
2569 /// endInstruction - Process end of an instruction.
2570 void DwarfDebug::endInstruction(const MachineInstr *MI) {
2571   if (InsnsEndScopeSet.count(MI) != 0) {
2572     // Emit a label if this instruction ends a scope.
2573     MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2574     Asm->OutStreamer.EmitLabel(Label);
2575     LabelsAfterInsn[MI] = Label;
2576   }
2577 }
2578
2579 /// getOrCreateDbgScope - Create DbgScope for the scope.
2580 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2581                                           const MDNode *InlinedAt) {
2582   if (!InlinedAt) {
2583     DbgScope *WScope = DbgScopeMap.lookup(Scope);
2584     if (WScope)
2585       return WScope;
2586     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2587     DbgScopeMap.insert(std::make_pair(Scope, WScope));
2588     if (DIDescriptor(Scope).isLexicalBlock()) {
2589       DbgScope *Parent =
2590         getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2591       WScope->setParent(Parent);
2592       Parent->addScope(WScope);
2593     }
2594
2595     if (!WScope->getParent()) {
2596       StringRef SPName = DISubprogram(Scope).getLinkageName();
2597       // We used to check only for a linkage name, but that fails
2598       // since we began omitting the linkage name for private
2599       // functions.  The new way is to check for the name in metadata,
2600       // but that's not supported in old .ll test cases.  Ergo, we
2601       // check both.
2602       if (SPName == Asm->MF->getFunction()->getName() ||
2603           DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2604         CurrentFnDbgScope = WScope;
2605     }
2606
2607     return WScope;
2608   }
2609
2610   getOrCreateAbstractScope(Scope);
2611   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2612   if (WScope)
2613     return WScope;
2614
2615   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2616   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2617   DILocation DL(InlinedAt);
2618   DbgScope *Parent =
2619     getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2620   WScope->setParent(Parent);
2621   Parent->addScope(WScope);
2622
2623   ConcreteScopes[InlinedAt] = WScope;
2624
2625   return WScope;
2626 }
2627
2628 /// hasValidLocation - Return true if debug location entry attached with
2629 /// machine instruction encodes valid location info.
2630 static bool hasValidLocation(LLVMContext &Ctx,
2631                              const MachineInstr *MInsn,
2632                              const MDNode *&Scope, const MDNode *&InlinedAt) {
2633   DebugLoc DL = MInsn->getDebugLoc();
2634   if (DL.isUnknown()) return false;
2635
2636   const MDNode *S = DL.getScope(Ctx);
2637
2638   // There is no need to create another DIE for compile unit. For all
2639   // other scopes, create one DbgScope now. This will be translated
2640   // into a scope DIE at the end.
2641   if (DIScope(S).isCompileUnit()) return false;
2642
2643   Scope = S;
2644   InlinedAt = DL.getInlinedAt(Ctx);
2645   return true;
2646 }
2647
2648 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2649 /// hierarchy.
2650 static void calculateDominanceGraph(DbgScope *Scope) {
2651   assert (Scope && "Unable to calculate scop edominance graph!");
2652   SmallVector<DbgScope *, 4> WorkStack;
2653   WorkStack.push_back(Scope);
2654   unsigned Counter = 0;
2655   while (!WorkStack.empty()) {
2656     DbgScope *WS = WorkStack.back();
2657     const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2658     bool visitedChildren = false;
2659     for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2660            SE = Children.end(); SI != SE; ++SI) {
2661       DbgScope *ChildScope = *SI;
2662       if (!ChildScope->getDFSOut()) {
2663         WorkStack.push_back(ChildScope);
2664         visitedChildren = true;
2665         ChildScope->setDFSIn(++Counter);
2666         break;
2667       }
2668     }
2669     if (!visitedChildren) {
2670       WorkStack.pop_back();
2671       WS->setDFSOut(++Counter);
2672     }
2673   }
2674 }
2675
2676 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2677 static
2678 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2679                        DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2680 {
2681 #ifndef NDEBUG
2682   unsigned PrevDFSIn = 0;
2683   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2684        I != E; ++I) {
2685     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2686          II != IE; ++II) {
2687       const MachineInstr *MInsn = II;
2688       const MDNode *Scope = NULL;
2689       const MDNode *InlinedAt = NULL;
2690
2691       // Check if instruction has valid location information.
2692       if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2693         dbgs() << " [ ";
2694         if (InlinedAt)
2695           dbgs() << "*";
2696         DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2697           MI2ScopeMap.find(MInsn);
2698         if (DI != MI2ScopeMap.end()) {
2699           DbgScope *S = DI->second;
2700           dbgs() << S->getDFSIn();
2701           PrevDFSIn = S->getDFSIn();
2702         } else
2703           dbgs() << PrevDFSIn;
2704       } else
2705         dbgs() << " [ x" << PrevDFSIn;
2706       dbgs() << " ]";
2707       MInsn->dump();
2708     }
2709     dbgs() << "\n";
2710   }
2711 #endif
2712 }
2713 /// extractScopeInformation - Scan machine instructions in this function
2714 /// and collect DbgScopes. Return true, if at least one scope was found.
2715 bool DwarfDebug::extractScopeInformation() {
2716   // If scope information was extracted using .dbg intrinsics then there is not
2717   // any need to extract these information by scanning each instruction.
2718   if (!DbgScopeMap.empty())
2719     return false;
2720
2721   // Scan each instruction and create scopes. First build working set of scopes.
2722   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2723   SmallVector<DbgRange, 4> MIRanges;
2724   DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2725   const MDNode *PrevScope = NULL;
2726   const MDNode *PrevInlinedAt = NULL;
2727   const MachineInstr *RangeBeginMI = NULL;
2728   const MachineInstr *PrevMI = NULL;
2729   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2730        I != E; ++I) {
2731     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2732          II != IE; ++II) {
2733       const MachineInstr *MInsn = II;
2734       const MDNode *Scope = NULL;
2735       const MDNode *InlinedAt = NULL;
2736
2737       // Check if instruction has valid location information.
2738       if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2739         PrevMI = MInsn;
2740         continue;
2741       }
2742
2743       // If scope has not changed then skip this instruction.
2744       if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2745         PrevMI = MInsn;
2746         continue;
2747       }
2748
2749       // Ignore DBG_VALUE. It does not contribute any instruction in output.
2750       if (MInsn->isDebugValue())
2751         continue;
2752
2753       if (RangeBeginMI) {
2754         // If we have alread seen a beginning of a instruction range and
2755         // current instruction scope does not match scope of first instruction
2756         // in this range then create a new instruction range.
2757         DbgRange R(RangeBeginMI, PrevMI);
2758         MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2759                                                         PrevInlinedAt);
2760         MIRanges.push_back(R);
2761       }
2762
2763       // This is a beginning of a new instruction range.
2764       RangeBeginMI = MInsn;
2765
2766       // Reset previous markers.
2767       PrevMI = MInsn;
2768       PrevScope = Scope;
2769       PrevInlinedAt = InlinedAt;
2770     }
2771   }
2772
2773   // Create last instruction range.
2774   if (RangeBeginMI && PrevMI && PrevScope) {
2775     DbgRange R(RangeBeginMI, PrevMI);
2776     MIRanges.push_back(R);
2777     MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2778   }
2779
2780   if (!CurrentFnDbgScope)
2781     return false;
2782
2783   calculateDominanceGraph(CurrentFnDbgScope);
2784   if (PrintDbgScope)
2785     printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2786
2787   // Find ranges of instructions covered by each DbgScope;
2788   DbgScope *PrevDbgScope = NULL;
2789   for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2790          RE = MIRanges.end(); RI != RE; ++RI) {
2791     const DbgRange &R = *RI;
2792     DbgScope *S = MI2ScopeMap.lookup(R.first);
2793     assert (S && "Lost DbgScope for a machine instruction!");
2794     if (PrevDbgScope && !PrevDbgScope->dominates(S))
2795       PrevDbgScope->closeInsnRange(S);
2796     S->openInsnRange(R.first);
2797     S->extendInsnRange(R.second);
2798     PrevDbgScope = S;
2799   }
2800
2801   if (PrevDbgScope)
2802     PrevDbgScope->closeInsnRange();
2803
2804   identifyScopeMarkers();
2805
2806   return !DbgScopeMap.empty();
2807 }
2808
2809 /// identifyScopeMarkers() -
2810 /// Each DbgScope has first instruction and last instruction to mark beginning
2811 /// and end of a scope respectively. Create an inverse map that list scopes
2812 /// starts (and ends) with an instruction. One instruction may start (or end)
2813 /// multiple scopes. Ignore scopes that are not reachable.
2814 void DwarfDebug::identifyScopeMarkers() {
2815   SmallVector<DbgScope *, 4> WorkList;
2816   WorkList.push_back(CurrentFnDbgScope);
2817   while (!WorkList.empty()) {
2818     DbgScope *S = WorkList.pop_back_val();
2819
2820     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2821     if (!Children.empty())
2822       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2823              SE = Children.end(); SI != SE; ++SI)
2824         WorkList.push_back(*SI);
2825
2826     if (S->isAbstractScope())
2827       continue;
2828
2829     const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2830     if (Ranges.empty())
2831       continue;
2832     for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2833            RE = Ranges.end(); RI != RE; ++RI) {
2834       assert(RI->first && "DbgRange does not have first instruction!");
2835       assert(RI->second && "DbgRange does not have second instruction!");
2836       InsnsEndScopeSet.insert(RI->second);
2837     }
2838   }
2839 }
2840
2841 /// FindFirstDebugLoc - Find the first debug location in the function. This
2842 /// is intended to be an approximation for the source position of the
2843 /// beginning of the function.
2844 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2845   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2846        I != E; ++I)
2847     for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2848          MBBI != MBBE; ++MBBI) {
2849       DebugLoc DL = MBBI->getDebugLoc();
2850       if (!DL.isUnknown())
2851         return DL;
2852     }
2853   return DebugLoc();
2854 }
2855
2856 #ifndef NDEBUG
2857 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2858 /// line number information.
2859 static void CheckLineNumbers(const MachineFunction *MF) {
2860   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2861        I != E; ++I) {
2862     bool FoundLineNo = false;
2863     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2864          II != IE; ++II) {
2865       const MachineInstr *MI = II;
2866       if (!MI->getDebugLoc().isUnknown()) {
2867         FoundLineNo = true;
2868         break;
2869       }
2870     }
2871     if (!FoundLineNo && I->size())
2872       ++BlocksWithoutLineNo;
2873   }
2874 }
2875 #endif
2876
2877 /// beginFunction - Gather pre-function debug information.  Assumes being
2878 /// emitted immediately after the function entry point.
2879 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2880   if (!MMI->hasDebugInfo()) return;
2881   if (!extractScopeInformation()) return;
2882
2883 #ifndef NDEBUG
2884   CheckLineNumbers(MF);
2885 #endif
2886
2887   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2888                                         Asm->getFunctionNumber());
2889   // Assumes in correct section after the entry point.
2890   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2891
2892   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2893   // function.
2894   DebugLoc FDL = FindFirstDebugLoc(MF);
2895   if (FDL.isUnknown()) return;
2896
2897   const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2898   const MDNode *TheScope = 0;
2899
2900   DISubprogram SP = getDISubprogram(Scope);
2901   unsigned Line, Col;
2902   if (SP.Verify()) {
2903     Line = SP.getLineNumber();
2904     Col = 0;
2905     TheScope = SP;
2906   } else {
2907     Line = FDL.getLine();
2908     Col = FDL.getCol();
2909     TheScope = Scope;
2910   }
2911
2912   recordSourceLine(Line, Col, TheScope);
2913
2914   /// ProcessedArgs - Collection of arguments already processed.
2915   SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2916
2917   DebugLoc PrevLoc;
2918   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2919        I != E; ++I)
2920     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2921          II != IE; ++II) {
2922       const MachineInstr *MI = II;
2923       DebugLoc DL = MI->getDebugLoc();
2924       if (MI->isDebugValue()) {
2925         assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2926         DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2927         if (!DV.Verify()) continue;
2928         // If DBG_VALUE is for a local variable then it needs a label.
2929         if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2930           InsnNeedsLabel.insert(MI);
2931         // DBG_VALUE for inlined functions argument needs a label.
2932         else if (!DISubprogram(getDISubprogram(DV.getContext())).
2933                  describes(MF->getFunction()))
2934           InsnNeedsLabel.insert(MI);
2935         // DBG_VALUE indicating argument location change needs a label.
2936         else if (!ProcessedArgs.insert(DV))
2937           InsnNeedsLabel.insert(MI);
2938       } else {
2939         // If location is unknown then instruction needs a location only if
2940         // UnknownLocations flag is set.
2941         if (DL.isUnknown()) {
2942           if (UnknownLocations && !PrevLoc.isUnknown())
2943             InsnNeedsLabel.insert(MI);
2944         } else if (DL != PrevLoc)
2945           // Otherwise, instruction needs a location only if it is new location.
2946           InsnNeedsLabel.insert(MI);
2947       }
2948
2949       if (!DL.isUnknown() || UnknownLocations)
2950         PrevLoc = DL;
2951     }
2952
2953   PrevLabel = FunctionBeginSym;
2954 }
2955
2956 /// endFunction - Gather and emit post-function debug information.
2957 ///
2958 void DwarfDebug::endFunction(const MachineFunction *MF) {
2959   if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2960
2961   if (CurrentFnDbgScope) {
2962
2963     // Define end label for subprogram.
2964     FunctionEndSym = Asm->GetTempSymbol("func_end",
2965                                         Asm->getFunctionNumber());
2966     // Assumes in correct section after the entry point.
2967     Asm->OutStreamer.EmitLabel(FunctionEndSym);
2968
2969     SmallPtrSet<const MDNode *, 16> ProcessedVars;
2970     collectVariableInfo(MF, ProcessedVars);
2971
2972     // Construct abstract scopes.
2973     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2974            AE = AbstractScopesList.end(); AI != AE; ++AI) {
2975       DISubprogram SP((*AI)->getScopeNode());
2976       if (SP.Verify()) {
2977         // Collect info for variables that were optimized out.
2978         StringRef FName = SP.getLinkageName();
2979         if (FName.empty())
2980           FName = SP.getName();
2981         if (NamedMDNode *NMD =
2982             getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2983           for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2984           DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2985           if (!DV || !ProcessedVars.insert(DV))
2986             continue;
2987           DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2988           if (Scope)
2989             Scope->addVariable(new DbgVariable(DV));
2990           }
2991         }
2992       }
2993       if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2994         constructScopeDIE(*AI);
2995     }
2996
2997     DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2998
2999     if (!DisableFramePointerElim(*MF))
3000       addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
3001               dwarf::DW_FORM_flag, 1);
3002
3003
3004     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
3005                                                  MMI->getFrameMoves()));
3006   }
3007
3008   // Clear debug info
3009   CurrentFnDbgScope = NULL;
3010   CurrentFnArguments.clear();
3011   InsnNeedsLabel.clear();
3012   DbgVariableToFrameIndexMap.clear();
3013   VarToAbstractVarMap.clear();
3014   DbgVariableToDbgInstMap.clear();
3015   DeleteContainerSeconds(DbgScopeMap);
3016   InsnsEndScopeSet.clear();
3017   ConcreteScopes.clear();
3018   DeleteContainerSeconds(AbstractScopes);
3019   AbstractScopesList.clear();
3020   AbstractVariables.clear();
3021   LabelsBeforeInsn.clear();
3022   LabelsAfterInsn.clear();
3023   PrevLabel = NULL;
3024 }
3025
3026 /// recordVariableFrameIndex - Record a variable's index.
3027 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
3028   assert (V && "Invalid DbgVariable!");
3029   DbgVariableToFrameIndexMap[V] = Index;
3030 }
3031
3032 /// findVariableFrameIndex - Return true if frame index for the variable
3033 /// is found. Update FI to hold value of the index.
3034 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
3035   assert (V && "Invalid DbgVariable!");
3036   DenseMap<const DbgVariable *, int>::iterator I =
3037     DbgVariableToFrameIndexMap.find(V);
3038   if (I == DbgVariableToFrameIndexMap.end())
3039     return false;
3040   *FI = I->second;
3041   return true;
3042 }
3043
3044 /// findDbgScope - Find DbgScope for the debug loc attached with an
3045 /// instruction.
3046 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
3047   DbgScope *Scope = NULL;
3048   LLVMContext &Ctx =
3049     MInsn->getParent()->getParent()->getFunction()->getContext();
3050   DebugLoc DL = MInsn->getDebugLoc();
3051
3052   if (DL.isUnknown())
3053     return Scope;
3054
3055   if (const MDNode *IA = DL.getInlinedAt(Ctx))
3056     Scope = ConcreteScopes.lookup(IA);
3057   if (Scope == 0)
3058     Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
3059
3060   return Scope;
3061 }
3062
3063
3064 /// recordSourceLine - Register a source line with debug info. Returns the
3065 /// unique label that was emitted and which provides correspondence to
3066 /// the source line list.
3067 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
3068                                        const MDNode *S) {
3069   StringRef Fn;
3070
3071   unsigned Src = 1;
3072   if (S) {
3073     DIDescriptor Scope(S);
3074
3075     if (Scope.isCompileUnit()) {
3076       DICompileUnit CU(S);
3077       Fn = CU.getFilename();
3078     } else if (Scope.isFile()) {
3079       DIFile F(S);
3080       Fn = F.getFilename();
3081     } else if (Scope.isSubprogram()) {
3082       DISubprogram SP(S);
3083       Fn = SP.getFilename();
3084     } else if (Scope.isLexicalBlock()) {
3085       DILexicalBlock DB(S);
3086       Fn = DB.getFilename();
3087     } else
3088       assert(0 && "Unexpected scope info");
3089
3090     Src = GetOrCreateSourceID(Fn);
3091   }
3092
3093   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
3094                                          0, 0);
3095
3096   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
3097   Asm->OutStreamer.EmitLabel(Label);
3098   return Label;
3099 }
3100
3101 //===----------------------------------------------------------------------===//
3102 // Emit Methods
3103 //===----------------------------------------------------------------------===//
3104
3105 /// computeSizeAndOffset - Compute the size and offset of a DIE.
3106 ///
3107 unsigned
3108 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
3109   // Get the children.
3110   const std::vector<DIE *> &Children = Die->getChildren();
3111
3112   // If not last sibling and has children then add sibling offset attribute.
3113   if (!Last && !Children.empty())
3114     Die->addSiblingOffset(DIEValueAllocator);
3115
3116   // Record the abbreviation.
3117   assignAbbrevNumber(Die->getAbbrev());
3118
3119   // Get the abbreviation for this DIE.
3120   unsigned AbbrevNumber = Die->getAbbrevNumber();
3121   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3122
3123   // Set DIE offset
3124   Die->setOffset(Offset);
3125
3126   // Start the size with the size of abbreviation code.
3127   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3128
3129   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3130   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3131
3132   // Size the DIE attribute values.
3133   for (unsigned i = 0, N = Values.size(); i < N; ++i)
3134     // Size attribute value.
3135     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3136
3137   // Size the DIE children if any.
3138   if (!Children.empty()) {
3139     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3140            "Children flag not set");
3141
3142     for (unsigned j = 0, M = Children.size(); j < M; ++j)
3143       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3144
3145     // End of children marker.
3146     Offset += sizeof(int8_t);
3147   }
3148
3149   Die->setSize(Offset - Die->getOffset());
3150   return Offset;
3151 }
3152
3153 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3154 ///
3155 void DwarfDebug::computeSizeAndOffsets() {
3156   unsigned PrevOffset = 0;
3157   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3158          E = CUMap.end(); I != E; ++I) {
3159     // Compute size of compile unit header.
3160     static unsigned Offset = PrevOffset +
3161       sizeof(int32_t) + // Length of Compilation Unit Info
3162       sizeof(int16_t) + // DWARF version number
3163       sizeof(int32_t) + // Offset Into Abbrev. Section
3164       sizeof(int8_t);   // Pointer Size (in bytes)
3165     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3166     PrevOffset = Offset;
3167   }
3168 }
3169
3170 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3171 /// temporary label to it if SymbolStem is specified.
3172 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3173                                 const char *SymbolStem = 0) {
3174   Asm->OutStreamer.SwitchSection(Section);
3175   if (!SymbolStem) return 0;
3176
3177   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3178   Asm->OutStreamer.EmitLabel(TmpSym);
3179   return TmpSym;
3180 }
3181
3182 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3183 /// the start of each one.
3184 void DwarfDebug::EmitSectionLabels() {
3185   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3186
3187   // Dwarf sections base addresses.
3188   if (Asm->MAI->doesDwarfRequireFrameSection()) {
3189     DwarfFrameSectionSym =
3190       EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3191    }
3192
3193   DwarfInfoSectionSym =
3194     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3195   DwarfAbbrevSectionSym =
3196     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3197   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3198
3199   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3200     EmitSectionSym(Asm, MacroInfo);
3201
3202   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3203   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3204   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3205   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3206   DwarfStrSectionSym =
3207     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3208   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3209                                              "debug_range");
3210
3211   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3212                                            "section_debug_loc");
3213
3214   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3215   EmitSectionSym(Asm, TLOF.getDataSection());
3216 }
3217
3218 /// emitDIE - Recusively Emits a debug information entry.
3219 ///
3220 void DwarfDebug::emitDIE(DIE *Die) {
3221   // Get the abbreviation for this DIE.
3222   unsigned AbbrevNumber = Die->getAbbrevNumber();
3223   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3224
3225   // Emit the code (index) for the abbreviation.
3226   if (Asm->isVerbose())
3227     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3228                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
3229                                 Twine::utohexstr(Die->getSize()) + " " +
3230                                 dwarf::TagString(Abbrev->getTag()));
3231   Asm->EmitULEB128(AbbrevNumber);
3232
3233   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3234   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3235
3236   // Emit the DIE attribute values.
3237   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3238     unsigned Attr = AbbrevData[i].getAttribute();
3239     unsigned Form = AbbrevData[i].getForm();
3240     assert(Form && "Too many attributes for DIE (check abbreviation)");
3241
3242     if (Asm->isVerbose())
3243       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3244
3245     switch (Attr) {
3246     case dwarf::DW_AT_sibling:
3247       Asm->EmitInt32(Die->getSiblingOffset());
3248       break;
3249     case dwarf::DW_AT_abstract_origin: {
3250       DIEEntry *E = cast<DIEEntry>(Values[i]);
3251       DIE *Origin = E->getEntry();
3252       unsigned Addr = Origin->getOffset();
3253       Asm->EmitInt32(Addr);
3254       break;
3255     }
3256     case dwarf::DW_AT_ranges: {
3257       // DW_AT_range Value encodes offset in debug_range section.
3258       DIEInteger *V = cast<DIEInteger>(Values[i]);
3259
3260       if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3261         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3262                                  V->getValue(),
3263                                  4);
3264       } else {
3265         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3266                                        V->getValue(),
3267                                        DwarfDebugRangeSectionSym,
3268                                        4);
3269       }
3270       break;
3271     }
3272     case dwarf::DW_AT_location: {
3273       if (UseDotDebugLocEntry.count(Die) != 0) {
3274         DIELabel *L = cast<DIELabel>(Values[i]);
3275         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3276       } else
3277         Values[i]->EmitValue(Asm, Form);
3278       break;
3279     }
3280     case dwarf::DW_AT_accessibility: {
3281       if (Asm->isVerbose()) {
3282         DIEInteger *V = cast<DIEInteger>(Values[i]);
3283         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3284       }
3285       Values[i]->EmitValue(Asm, Form);
3286       break;
3287     }
3288     default:
3289       // Emit an attribute using the defined form.
3290       Values[i]->EmitValue(Asm, Form);
3291       break;
3292     }
3293   }
3294
3295   // Emit the DIE children if any.
3296   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3297     const std::vector<DIE *> &Children = Die->getChildren();
3298
3299     for (unsigned j = 0, M = Children.size(); j < M; ++j)
3300       emitDIE(Children[j]);
3301
3302     if (Asm->isVerbose())
3303       Asm->OutStreamer.AddComment("End Of Children Mark");
3304     Asm->EmitInt8(0);
3305   }
3306 }
3307
3308 /// emitDebugInfo - Emit the debug info section.
3309 ///
3310 void DwarfDebug::emitDebugInfo() {
3311   // Start debug info section.
3312   Asm->OutStreamer.SwitchSection(
3313                             Asm->getObjFileLowering().getDwarfInfoSection());
3314   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3315          E = CUMap.end(); I != E; ++I) {
3316     CompileUnit *TheCU = I->second;
3317     DIE *Die = TheCU->getCUDie();
3318
3319     // Emit the compile units header.
3320     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3321                                                   TheCU->getID()));
3322
3323     // Emit size of content not including length itself
3324     unsigned ContentSize = Die->getSize() +
3325       sizeof(int16_t) + // DWARF version number
3326       sizeof(int32_t) + // Offset Into Abbrev. Section
3327       sizeof(int8_t) +  // Pointer Size (in bytes)
3328       sizeof(int32_t);  // FIXME - extra pad for gdb bug.
3329
3330     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3331     Asm->EmitInt32(ContentSize);
3332     Asm->OutStreamer.AddComment("DWARF version number");
3333     Asm->EmitInt16(dwarf::DWARF_VERSION);
3334     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3335     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3336                            DwarfAbbrevSectionSym);
3337     Asm->OutStreamer.AddComment("Address Size (in bytes)");
3338     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3339
3340     emitDIE(Die);
3341     // FIXME - extra padding for gdb bug.
3342     Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3343     Asm->EmitInt8(0);
3344     Asm->EmitInt8(0);
3345     Asm->EmitInt8(0);
3346     Asm->EmitInt8(0);
3347     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3348   }
3349 }
3350
3351 /// emitAbbreviations - Emit the abbreviation section.
3352 ///
3353 void DwarfDebug::emitAbbreviations() const {
3354   // Check to see if it is worth the effort.
3355   if (!Abbreviations.empty()) {
3356     // Start the debug abbrev section.
3357     Asm->OutStreamer.SwitchSection(
3358                             Asm->getObjFileLowering().getDwarfAbbrevSection());
3359
3360     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3361
3362     // For each abbrevation.
3363     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3364       // Get abbreviation data
3365       const DIEAbbrev *Abbrev = Abbreviations[i];
3366
3367       // Emit the abbrevations code (base 1 index.)
3368       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3369
3370       // Emit the abbreviations data.
3371       Abbrev->Emit(Asm);
3372     }
3373
3374     // Mark end of abbreviations.
3375     Asm->EmitULEB128(0, "EOM(3)");
3376
3377     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3378   }
3379 }
3380
3381 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3382 /// the line matrix.
3383 ///
3384 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3385   // Define last address of section.
3386   Asm->OutStreamer.AddComment("Extended Op");
3387   Asm->EmitInt8(0);
3388
3389   Asm->OutStreamer.AddComment("Op size");
3390   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3391   Asm->OutStreamer.AddComment("DW_LNE_set_address");
3392   Asm->EmitInt8(dwarf::DW_LNE_set_address);
3393
3394   Asm->OutStreamer.AddComment("Section end label");
3395
3396   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3397                                    Asm->getTargetData().getPointerSize(),
3398                                    0/*AddrSpace*/);
3399
3400   // Mark end of matrix.
3401   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3402   Asm->EmitInt8(0);
3403   Asm->EmitInt8(1);
3404   Asm->EmitInt8(1);
3405 }
3406
3407 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3408 ///
3409 void DwarfDebug::emitCommonDebugFrame() {
3410   if (!Asm->MAI->doesDwarfRequireFrameSection())
3411     return;
3412
3413   int stackGrowth = Asm->getTargetData().getPointerSize();
3414   if (Asm->TM.getFrameLowering()->getStackGrowthDirection() ==
3415       TargetFrameLowering::StackGrowsDown)
3416     stackGrowth *= -1;
3417
3418   // Start the dwarf frame section.
3419   Asm->OutStreamer.SwitchSection(
3420                               Asm->getObjFileLowering().getDwarfFrameSection());
3421
3422   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3423   Asm->OutStreamer.AddComment("Length of Common Information Entry");
3424   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3425                            Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3426
3427   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3428   Asm->OutStreamer.AddComment("CIE Identifier Tag");
3429   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3430   Asm->OutStreamer.AddComment("CIE Version");
3431   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3432   Asm->OutStreamer.AddComment("CIE Augmentation");
3433   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3434   Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3435   Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3436   Asm->OutStreamer.AddComment("CIE RA Column");
3437   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3438   const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
3439   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3440
3441   std::vector<MachineMove> Moves;
3442   TFI->getInitialFrameState(Moves);
3443
3444   Asm->EmitFrameMoves(Moves, 0, false);
3445
3446   Asm->EmitAlignment(2);
3447   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3448 }
3449
3450 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3451 /// section.
3452 void DwarfDebug::
3453 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3454   if (!Asm->MAI->doesDwarfRequireFrameSection())
3455     return;
3456
3457   // Start the dwarf frame section.
3458   Asm->OutStreamer.SwitchSection(
3459                               Asm->getObjFileLowering().getDwarfFrameSection());
3460
3461   Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3462   MCSymbol *DebugFrameBegin =
3463     Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3464   MCSymbol *DebugFrameEnd =
3465     Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3466   Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3467
3468   Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3469
3470   Asm->OutStreamer.AddComment("FDE CIE offset");
3471   Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3472                          DwarfFrameSectionSym);
3473
3474   Asm->OutStreamer.AddComment("FDE initial location");
3475   MCSymbol *FuncBeginSym =
3476     Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3477   Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3478                                    Asm->getTargetData().getPointerSize(),
3479                                    0/*AddrSpace*/);
3480
3481
3482   Asm->OutStreamer.AddComment("FDE address range");
3483   Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3484                            FuncBeginSym, Asm->getTargetData().getPointerSize());
3485
3486   Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3487
3488   Asm->EmitAlignment(2);
3489   Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3490 }
3491
3492 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3493 ///
3494 void DwarfDebug::emitDebugPubNames() {
3495   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3496          E = CUMap.end(); I != E; ++I) {
3497     CompileUnit *TheCU = I->second;
3498     // Start the dwarf pubnames section.
3499     Asm->OutStreamer.SwitchSection(
3500       Asm->getObjFileLowering().getDwarfPubNamesSection());
3501
3502     Asm->OutStreamer.AddComment("Length of Public Names Info");
3503     Asm->EmitLabelDifference(
3504       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3505       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3506
3507     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3508                                                   TheCU->getID()));
3509
3510     Asm->OutStreamer.AddComment("DWARF Version");
3511     Asm->EmitInt16(dwarf::DWARF_VERSION);
3512
3513     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3514     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3515                            DwarfInfoSectionSym);
3516
3517     Asm->OutStreamer.AddComment("Compilation Unit Length");
3518     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3519                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
3520                              4);
3521
3522     const StringMap<DIE*> &Globals = TheCU->getGlobals();
3523     for (StringMap<DIE*>::const_iterator
3524            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3525       const char *Name = GI->getKeyData();
3526       DIE *Entity = GI->second;
3527
3528       Asm->OutStreamer.AddComment("DIE offset");
3529       Asm->EmitInt32(Entity->getOffset());
3530
3531       if (Asm->isVerbose())
3532         Asm->OutStreamer.AddComment("External Name");
3533       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3534     }
3535
3536     Asm->OutStreamer.AddComment("End Mark");
3537     Asm->EmitInt32(0);
3538     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3539                                                 TheCU->getID()));
3540   }
3541 }
3542
3543 void DwarfDebug::emitDebugPubTypes() {
3544   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3545          E = CUMap.end(); I != E; ++I) {
3546     CompileUnit *TheCU = I->second;
3547     // Start the dwarf pubnames section.
3548     Asm->OutStreamer.SwitchSection(
3549       Asm->getObjFileLowering().getDwarfPubTypesSection());
3550     Asm->OutStreamer.AddComment("Length of Public Types Info");
3551     Asm->EmitLabelDifference(
3552       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3553       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3554
3555     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3556                                                   TheCU->getID()));
3557
3558     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3559     Asm->EmitInt16(dwarf::DWARF_VERSION);
3560
3561     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3562     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3563                            DwarfInfoSectionSym);
3564
3565     Asm->OutStreamer.AddComment("Compilation Unit Length");
3566     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3567                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
3568                              4);
3569
3570     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3571     for (StringMap<DIE*>::const_iterator
3572            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3573       const char *Name = GI->getKeyData();
3574       DIE * Entity = GI->second;
3575
3576       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3577       Asm->EmitInt32(Entity->getOffset());
3578
3579       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3580       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3581     }
3582
3583     Asm->OutStreamer.AddComment("End Mark");
3584     Asm->EmitInt32(0);
3585     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3586                                                   TheCU->getID()));
3587   }
3588 }
3589
3590 /// emitDebugStr - Emit visible names into a debug str section.
3591 ///
3592 void DwarfDebug::emitDebugStr() {
3593   // Check to see if it is worth the effort.
3594   if (StringPool.empty()) return;
3595
3596   // Start the dwarf str section.
3597   Asm->OutStreamer.SwitchSection(
3598                                 Asm->getObjFileLowering().getDwarfStrSection());
3599
3600   // Get all of the string pool entries and put them in an array by their ID so
3601   // we can sort them.
3602   SmallVector<std::pair<unsigned,
3603       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3604
3605   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3606        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3607     Entries.push_back(std::make_pair(I->second.second, &*I));
3608
3609   array_pod_sort(Entries.begin(), Entries.end());
3610
3611   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3612     // Emit a label for reference from debug information entries.
3613     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3614
3615     // Emit the string itself.
3616     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3617   }
3618 }
3619
3620 /// emitDebugLoc - Emit visible names into a debug loc section.
3621 ///
3622 void DwarfDebug::emitDebugLoc() {
3623   if (DotDebugLocEntries.empty())
3624     return;
3625
3626   for (SmallVector<DotDebugLocEntry, 4>::iterator
3627          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3628        I != E; ++I) {
3629     DotDebugLocEntry &Entry = *I;
3630     if (I + 1 != DotDebugLocEntries.end())
3631       Entry.Merge(I+1);
3632   }
3633
3634   // Start the dwarf loc section.
3635   Asm->OutStreamer.SwitchSection(
3636     Asm->getObjFileLowering().getDwarfLocSection());
3637   unsigned char Size = Asm->getTargetData().getPointerSize();
3638   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3639   unsigned index = 1;
3640   for (SmallVector<DotDebugLocEntry, 4>::iterator
3641          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3642        I != E; ++I, ++index) {
3643     DotDebugLocEntry &Entry = *I;
3644     if (Entry.isMerged()) continue;
3645     if (Entry.isEmpty()) {
3646       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3647       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3648       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3649     } else {
3650       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3651       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3652       const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3653       unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3654       if (int Offset =  Entry.Loc.getOffset()) {
3655         // If the value is at a certain offset from frame register then
3656         // use DW_OP_fbreg.
3657         unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3658         Asm->OutStreamer.AddComment("Loc expr size");
3659         Asm->EmitInt16(1 + OffsetSize);
3660         Asm->OutStreamer.AddComment(
3661           dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3662         Asm->EmitInt8(dwarf::DW_OP_fbreg);
3663         Asm->OutStreamer.AddComment("Offset");
3664         Asm->EmitSLEB128(Offset);
3665       } else {
3666         if (Reg < 32) {
3667           Asm->OutStreamer.AddComment("Loc expr size");
3668           Asm->EmitInt16(1);
3669           Asm->OutStreamer.AddComment(
3670             dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3671           Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3672         } else {
3673           Asm->OutStreamer.AddComment("Loc expr size");
3674           Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3675           Asm->EmitInt8(dwarf::DW_OP_regx);
3676           Asm->EmitULEB128(Reg);
3677         }
3678       }
3679     }
3680   }
3681 }
3682
3683 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3684 ///
3685 void DwarfDebug::EmitDebugARanges() {
3686   // Start the dwarf aranges section.
3687   Asm->OutStreamer.SwitchSection(
3688                           Asm->getObjFileLowering().getDwarfARangesSection());
3689 }
3690
3691 /// emitDebugRanges - Emit visible names into a debug ranges section.
3692 ///
3693 void DwarfDebug::emitDebugRanges() {
3694   // Start the dwarf ranges section.
3695   Asm->OutStreamer.SwitchSection(
3696     Asm->getObjFileLowering().getDwarfRangesSection());
3697   unsigned char Size = Asm->getTargetData().getPointerSize();
3698   for (SmallVector<const MCSymbol *, 8>::iterator
3699          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3700        I != E; ++I) {
3701     if (*I)
3702       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3703     else
3704       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3705   }
3706 }
3707
3708 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3709 ///
3710 void DwarfDebug::emitDebugMacInfo() {
3711   if (const MCSection *LineInfo =
3712       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3713     // Start the dwarf macinfo section.
3714     Asm->OutStreamer.SwitchSection(LineInfo);
3715   }
3716 }
3717
3718 /// emitDebugInlineInfo - Emit inline info using following format.
3719 /// Section Header:
3720 /// 1. length of section
3721 /// 2. Dwarf version number
3722 /// 3. address size.
3723 ///
3724 /// Entries (one "entry" for each function that was inlined):
3725 ///
3726 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3727 ///   otherwise offset into __debug_str for regular function name.
3728 /// 2. offset into __debug_str section for regular function name.
3729 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3730 /// instances for the function.
3731 ///
3732 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3733 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3734 /// __debug_info section, and the low_pc is the starting address for the
3735 /// inlining instance.
3736 void DwarfDebug::emitDebugInlineInfo() {
3737   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3738     return;
3739
3740   if (!FirstCU)
3741     return;
3742
3743   Asm->OutStreamer.SwitchSection(
3744                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
3745
3746   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3747   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3748                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3749
3750   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3751
3752   Asm->OutStreamer.AddComment("Dwarf Version");
3753   Asm->EmitInt16(dwarf::DWARF_VERSION);
3754   Asm->OutStreamer.AddComment("Address Size (in bytes)");
3755   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3756
3757   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3758          E = InlinedSPNodes.end(); I != E; ++I) {
3759
3760     const MDNode *Node = *I;
3761     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3762       = InlineInfo.find(Node);
3763     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3764     DISubprogram SP(Node);
3765     StringRef LName = SP.getLinkageName();
3766     StringRef Name = SP.getName();
3767
3768     Asm->OutStreamer.AddComment("MIPS linkage name");
3769     if (LName.empty()) {
3770       Asm->OutStreamer.EmitBytes(Name, 0);
3771       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3772     } else
3773       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3774                              DwarfStrSectionSym);
3775
3776     Asm->OutStreamer.AddComment("Function name");
3777     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3778     Asm->EmitULEB128(Labels.size(), "Inline count");
3779
3780     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3781            LE = Labels.end(); LI != LE; ++LI) {
3782       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3783       Asm->EmitInt32(LI->second->getOffset());
3784
3785       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3786       Asm->OutStreamer.EmitSymbolValue(LI->first,
3787                                        Asm->getTargetData().getPointerSize(),0);
3788     }
3789   }
3790
3791   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
3792 }