lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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