lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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