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 "llvm/Module.h"
  17 #include "llvm/CodeGen/MachineFunction.h"
  18 #include "llvm/CodeGen/MachineModuleInfo.h"
  19 #include "llvm/MC/MCAsmInfo.h"
  20 #include "llvm/MC/MCSection.h"
  21 #include "llvm/MC/MCStreamer.h"
  22 #include "llvm/MC/MCSymbol.h"
  23 #include "llvm/Target/Mangler.h"
  24 #include "llvm/Target/TargetData.h"
  25 #include "llvm/Target/TargetFrameInfo.h"
  26 #include "llvm/Target/TargetLoweringObjectFile.h"
  27 #include "llvm/Target/TargetRegisterInfo.h"
  28 #include "llvm/ADT/STLExtras.h"
  29 #include "llvm/ADT/StringExtras.h"
  30 #include "llvm/Support/Debug.h"
  31 #include "llvm/Support/ErrorHandling.h"
  32 #include "llvm/Support/ValueHandle.h"
  33 #include "llvm/Support/FormattedStream.h"
  34 #include "llvm/Support/Timer.h"
  35 #include "llvm/System/Path.h"
  36 using namespace llvm;
  37
  38 //===----------------------------------------------------------------------===//
  39
  40 /// Configuration values for initial hash set sizes (log2).
  41 ///
  42 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
  43
  44 namespace llvm {
  45
  46 //===----------------------------------------------------------------------===//
  47 /// CompileUnit - This dwarf writer support class manages information associate
  48 /// with a source file.
  49 class CompileUnit {
  50   /// ID - File identifier for source.
  51   ///
  52   unsigned ID;
  53
  54   /// Die - Compile unit debug information entry.
  55   ///
  56   const OwningPtr<DIE> CUDie;
  57
  58   /// IndexTyDie - An anonymous type for index type.  Owned by CUDie.
  59   DIE *IndexTyDie;
  60
  61   /// GVToDieMap - Tracks the mapping of unit level debug informaton
  62   /// variables to debug information entries.
  63   /// FIXME : Rename GVToDieMap -> NodeToDieMap
  64   DenseMap<MDNode *, DIE *> GVToDieMap;
  65
  66   /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
  67   /// descriptors to debug information entries using a DIEEntry proxy.
  68   /// FIXME : Rename
  69   DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
  70
  71   /// Globals - A map of globally visible named entities for this unit.
  72   ///
  73   StringMap<DIE*> Globals;
  74
  75   /// GlobalTypes - A map of globally visible types for this unit.
  76   ///
  77   StringMap<DIE*> GlobalTypes;
  78
  79 public:
  80   CompileUnit(unsigned I, DIE *D)
  81     : ID(I), CUDie(D), IndexTyDie(0) {}
  82
  83   // Accessors.
  84   unsigned getID()                  const { return ID; }
  85   DIE* getCUDie()                   const { return CUDie.get(); }
  86   const StringMap<DIE*> &getGlobals()     const { return Globals; }
  87   const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
  88
  89   /// hasContent - Return true if this compile unit has something to write out.
  90   ///
  91   bool hasContent() const { return !CUDie->getChildren().empty(); }
  92
  93   /// addGlobal - Add a new global entity to the compile unit.
  94   ///
  95   void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
  96
  97   /// addGlobalType - Add a new global type to the compile unit.
  98   ///
  99   void addGlobalType(const std::string &Name, DIE *Die) {
 100     GlobalTypes[Name] = Die;
 101   }
 102
 103   /// getDIE - Returns the debug information entry map slot for the
 104   /// specified debug variable.
 105   DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
 106
 107   /// insertDIE - Insert DIE into the map.
 108   void insertDIE(MDNode *N, DIE *D) {
 109     GVToDieMap.insert(std::make_pair(N, D));
 110   }
 111
 112   /// getDIEEntry - Returns the debug information entry for the speciefied
 113   /// debug variable.
 114   DIEEntry *getDIEEntry(MDNode *N) {
 115     DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
 116     if (I == GVToDIEEntryMap.end())
 117       return NULL;
 118     return I->second;
 119   }
 120
 121   /// insertDIEEntry - Insert debug information entry into the map.
 122   void insertDIEEntry(MDNode *N, DIEEntry *E) {
 123     GVToDIEEntryMap.insert(std::make_pair(N, E));
 124   }
 125
 126   /// addDie - Adds or interns the DIE to the compile unit.
 127   ///
 128   void addDie(DIE *Buffer) {
 129     this->CUDie->addChild(Buffer);
 130   }
 131
 132   // getIndexTyDie - Get an anonymous type for index type.
 133   DIE *getIndexTyDie() {
 134     return IndexTyDie;
 135   }
 136
 137   // setIndexTyDie - Set D as anonymous type for index which can be reused
 138   // later.
 139   void setIndexTyDie(DIE *D) {
 140     IndexTyDie = D;
 141   }
 142
 143 };
 144
 145 //===----------------------------------------------------------------------===//
 146 /// DbgVariable - This class is used to track local variable information.
 147 ///
 148 class DbgVariable {
 149   DIVariable Var;                    // Variable Descriptor.
 150   unsigned FrameIndex;               // Variable frame index.
 151   const MachineInstr *DbgValueMInsn; // DBG_VALUE
 152   DbgVariable *const AbstractVar;    // Abstract variable for this variable.
 153   DIE *TheDIE;
 154 public:
 155   // AbsVar may be NULL.
 156   DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
 157     : Var(V), FrameIndex(I), DbgValueMInsn(0), AbstractVar(AbsVar), TheDIE(0) {}
 158   DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
 159     : Var(V), FrameIndex(0), DbgValueMInsn(MI), AbstractVar(AbsVar), TheDIE(0)
 160     {}
 161
 162   // Accessors.
 163   DIVariable getVariable()           const { return Var; }
 164   unsigned getFrameIndex()           const { return FrameIndex; }
 165   const MachineInstr *getDbgValue()  const { return DbgValueMInsn; }
 166   DbgVariable *getAbstractVariable() const { return AbstractVar; }
 167   void setDIE(DIE *D)                      { TheDIE = D; }
 168   DIE *getDIE()                      const { return TheDIE; }
 169 };
 170
 171 //===----------------------------------------------------------------------===//
 172 /// DbgScope - This class is used to track scope information.
 173 ///
 174 class DbgScope {
 175   DbgScope *Parent;                   // Parent to this scope.
 176   DIDescriptor Desc;                  // Debug info descriptor for scope.
 177   // Location at which this scope is inlined.
 178   AssertingVH<MDNode> InlinedAtLocation;
 179   bool AbstractScope;                 // Abstract Scope
 180   MCSymbol *StartLabel;               // Label ID of the beginning of scope.
 181   MCSymbol *EndLabel;                 // Label ID of the end of scope.
 182   const MachineInstr *LastInsn;       // Last instruction of this scope.
 183   const MachineInstr *FirstInsn;      // First instruction of this scope.
 184   // Scopes defined in scope.  Contents not owned.
 185   SmallVector<DbgScope *, 4> Scopes;
 186   // Variables declared in scope.  Contents owned.
 187   SmallVector<DbgVariable *, 8> Variables;
 188
 189   // Private state for dump()
 190   mutable unsigned IndentLevel;
 191 public:
 192   DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
 193     : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
 194       StartLabel(0), EndLabel(0),
 195       LastInsn(0), FirstInsn(0), IndentLevel(0) {}
 196   virtual ~DbgScope();
 197
 198   // Accessors.
 199   DbgScope *getParent()          const { return Parent; }
 200   void setParent(DbgScope *P)          { Parent = P; }
 201   DIDescriptor getDesc()         const { return Desc; }
 202   MDNode *getInlinedAt()         const { return InlinedAtLocation; }
 203   MDNode *getScopeNode()         const { return Desc.getNode(); }
 204   MCSymbol *getStartLabel()      const { return StartLabel; }
 205   MCSymbol *getEndLabel()        const { return EndLabel; }
 206   const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
 207   const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
 208   void setStartLabel(MCSymbol *S) { StartLabel = S; }
 209   void setEndLabel(MCSymbol *E)   { EndLabel = E; }
 210   void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
 211   const MachineInstr *getLastInsn()      { return LastInsn; }
 212   void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
 213   void setAbstractScope() { AbstractScope = true; }
 214   bool isAbstractScope() const { return AbstractScope; }
 215   const MachineInstr *getFirstInsn()      { return FirstInsn; }
 216
 217   /// addScope - Add a scope to the scope.
 218   ///
 219   void addScope(DbgScope *S) { Scopes.push_back(S); }
 220
 221   /// addVariable - Add a variable to the scope.
 222   ///
 223   void addVariable(DbgVariable *V) { Variables.push_back(V); }
 224
 225   void fixInstructionMarkers(DenseMap<const MachineInstr *,
 226                              unsigned> &MIIndexMap) {
 227     assert (getFirstInsn() && "First instruction is missing!");
 228
 229     // Use the end of last child scope as end of this scope.
 230     const SmallVector<DbgScope *, 4> &Scopes = getScopes();
 231     const MachineInstr *LastInsn = getFirstInsn();
 232     unsigned LIndex = 0;
 233     if (Scopes.empty()) {
 234       assert (getLastInsn() && "Inner most scope does not have last insn!");
 235       return;
 236     }
 237     for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
 238            SE = Scopes.end(); SI != SE; ++SI) {
 239       DbgScope *DS = *SI;
 240       DS->fixInstructionMarkers(MIIndexMap);
 241       const MachineInstr *DSLastInsn = DS->getLastInsn();
 242       unsigned DSI = MIIndexMap[DSLastInsn];
 243       if (DSI > LIndex) {
 244         LastInsn = DSLastInsn;
 245         LIndex = DSI;
 246       }
 247     }
 248
 249     unsigned CurrentLastInsnIndex = 0;
 250     if (const MachineInstr *CL = getLastInsn())
 251       CurrentLastInsnIndex = MIIndexMap[CL];
 252     unsigned FIndex = MIIndexMap[getFirstInsn()];
 253
 254     // Set LastInsn as the last instruction for this scope only if
 255     // it follows
 256     //  1) this scope's first instruction and
 257     //  2) current last instruction for this scope, if any.
 258     if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
 259       setLastInsn(LastInsn);
 260   }
 261
 262 #ifndef NDEBUG
 263   void dump() const;
 264 #endif
 265 };
 266
 267 #ifndef NDEBUG
 268 void DbgScope::dump() const {
 269   raw_ostream &err = dbgs();
 270   err.indent(IndentLevel);
 271   MDNode *N = Desc.getNode();
 272   N->dump();
 273   err << " [" << StartLabel << ", " << EndLabel << "]\n";
 274   if (AbstractScope)
 275     err << "Abstract Scope\n";
 276
 277   IndentLevel += 2;
 278   if (!Scopes.empty())
 279     err << "Children ...\n";
 280   for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
 281     if (Scopes[i] != this)
 282       Scopes[i]->dump();
 283
 284   IndentLevel -= 2;
 285 }
 286 #endif
 287
 288 DbgScope::~DbgScope() {
 289   for (unsigned j = 0, M = Variables.size(); j < M; ++j)
 290     delete Variables[j];
 291 }
 292
 293 } // end llvm namespace
 294
 295 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
 296   : DwarfPrinter(OS, A, T), ModuleCU(0),
 297     AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
 298     DIEValues(), SectionSourceLines(), didInitial(false), shouldEmit(false),
 299     CurrentFnDbgScope(0), PrevDILoc(0), DebugTimer(0) {
 300   NextStringPoolNumber = 0;
 301   if (TimePassesIsEnabled)
 302     DebugTimer = new Timer("Dwarf Debug Writer");
 303 }
 304 DwarfDebug::~DwarfDebug() {
 305   for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
 306     delete DIEValues[j];
 307
 308   delete DebugTimer;
 309 }
 310
 311 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
 312   std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
 313   if (Entry.first) return Entry.first;
 314
 315   Entry.second = NextStringPoolNumber++;
 316   return Entry.first = getDWLabel("string", Entry.second);
 317 }
 318
 319
 320 /// assignAbbrevNumber - Define a unique number for the abbreviation.
 321 ///
 322 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
 323   // Profile the node so that we can make it unique.
 324   FoldingSetNodeID ID;
 325   Abbrev.Profile(ID);
 326
 327   // Check the set for priors.
 328   DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
 329
 330   // If it's newly added.
 331   if (InSet == &Abbrev) {
 332     // Add to abbreviation list.
 333     Abbreviations.push_back(&Abbrev);
 334
 335     // Assign the vector position + 1 as its number.
 336     Abbrev.setNumber(Abbreviations.size());
 337   } else {
 338     // Assign existing abbreviation number.
 339     Abbrev.setNumber(InSet->getNumber());
 340   }
 341 }
 342
 343 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
 344 /// information entry.
 345 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
 346   DIEEntry *Value = new DIEEntry(Entry);
 347   DIEValues.push_back(Value);
 348   return Value;
 349 }
 350
 351 /// addUInt - Add an unsigned integer attribute data and value.
 352 ///
 353 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
 354                          unsigned Form, uint64_t Integer) {
 355   if (!Form) Form = DIEInteger::BestForm(false, Integer);
 356   DIEValue *Value = new DIEInteger(Integer);
 357   DIEValues.push_back(Value);
 358   Die->addValue(Attribute, Form, Value);
 359 }
 360
 361 /// addSInt - Add an signed integer attribute data and value.
 362 ///
 363 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
 364                          unsigned Form, int64_t Integer) {
 365   if (!Form) Form = DIEInteger::BestForm(true, Integer);
 366   DIEValue *Value = new DIEInteger(Integer);
 367   DIEValues.push_back(Value);
 368   Die->addValue(Attribute, Form, Value);
 369 }
 370
 371 /// addString - Add a string attribute data and value. DIEString only
 372 /// keeps string reference.
 373 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
 374                            StringRef String) {
 375   DIEValue *Value = new DIEString(String);
 376   DIEValues.push_back(Value);
 377   Die->addValue(Attribute, Form, Value);
 378 }
 379
 380 /// addLabel - Add a Dwarf label attribute data and value.
 381 ///
 382 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
 383                           const MCSymbol *Label) {
 384   DIEValue *Value = new DIELabel(Label);
 385   DIEValues.push_back(Value);
 386   Die->addValue(Attribute, Form, Value);
 387 }
 388
 389 /// addDelta - Add a label delta attribute data and value.
 390 ///
 391 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
 392                           const MCSymbol *Hi, const MCSymbol *Lo) {
 393   DIEValue *Value = new DIEDelta(Hi, Lo);
 394   DIEValues.push_back(Value);
 395   Die->addValue(Attribute, Form, Value);
 396 }
 397
 398 /// addBlock - Add block data.
 399 ///
 400 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
 401                           DIEBlock *Block) {
 402   Block->ComputeSize(TD);
 403   DIEValues.push_back(Block);
 404   Die->addValue(Attribute, Block->BestForm(), Block);
 405 }
 406
 407 /// addSourceLine - Add location information to specified debug information
 408 /// entry.
 409 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
 410   // If there is no compile unit specified, don't add a line #.
 411   if (!V->getCompileUnit().Verify())
 412     return;
 413
 414   unsigned Line = V->getLineNumber();
 415   unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
 416                                         V->getContext().getFilename());
 417   assert(FileID && "Invalid file id");
 418   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 419   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 420 }
 421
 422 /// addSourceLine - Add location information to specified debug information
 423 /// entry.
 424 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
 425   // If there is no compile unit specified, don't add a line #.
 426   if (!G->getCompileUnit().Verify())
 427     return;
 428
 429   unsigned Line = G->getLineNumber();
 430   unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
 431                                         G->getContext().getFilename());
 432   assert(FileID && "Invalid file id");
 433   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 434   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 435 }
 436
 437 /// addSourceLine - Add location information to specified debug information
 438 /// entry.
 439 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
 440   // If there is no compile unit specified, don't add a line #.
 441   if (!SP->getCompileUnit().Verify())
 442     return;
 443   // If the line number is 0, don't add it.
 444   if (SP->getLineNumber() == 0)
 445     return;
 446
 447   unsigned Line = SP->getLineNumber();
 448   if (!SP->getContext().Verify())
 449     return;
 450   unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
 451                                         SP->getFilename());
 452   assert(FileID && "Invalid file id");
 453   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 454   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 455 }
 456
 457 /// addSourceLine - Add location information to specified debug information
 458 /// entry.
 459 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
 460   // If there is no compile unit specified, don't add a line #.
 461   DICompileUnit CU = Ty->getCompileUnit();
 462   if (!CU.Verify())
 463     return;
 464
 465   unsigned Line = Ty->getLineNumber();
 466   if (!Ty->getContext().Verify())
 467     return;
 468   unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
 469                                         Ty->getContext().getFilename());
 470   assert(FileID && "Invalid file id");
 471   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 472   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 473 }
 474
 475 /// addSourceLine - Add location information to specified debug information
 476 /// entry.
 477 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
 478   // If there is no compile unit specified, don't add a line #.
 479   if (!NS->getCompileUnit().Verify())
 480     return;
 481
 482   unsigned Line = NS->getLineNumber();
 483   StringRef FN = NS->getFilename();
 484   StringRef Dir = NS->getDirectory();
 485
 486   unsigned FileID = GetOrCreateSourceID(Dir, FN);
 487   assert(FileID && "Invalid file id");
 488   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 489   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 490 }
 491
 492 /* Byref variables, in Blocks, are declared by the programmer as
 493    "SomeType VarName;", but the compiler creates a
 494    __Block_byref_x_VarName struct, and gives the variable VarName
 495    either the struct, or a pointer to the struct, as its type.  This
 496    is necessary for various behind-the-scenes things the compiler
 497    needs to do with by-reference variables in blocks.
 498
 499    However, as far as the original *programmer* is concerned, the
 500    variable should still have type 'SomeType', as originally declared.
 501
 502    The following function dives into the __Block_byref_x_VarName
 503    struct to find the original type of the variable.  This will be
 504    passed back to the code generating the type for the Debug
 505    Information Entry for the variable 'VarName'.  'VarName' will then
 506    have the original type 'SomeType' in its debug information.
 507
 508    The original type 'SomeType' will be the type of the field named
 509    'VarName' inside the __Block_byref_x_VarName struct.
 510
 511    NOTE: In order for this to not completely fail on the debugger
 512    side, the Debug Information Entry for the variable VarName needs to
 513    have a DW_AT_location that tells the debugger how to unwind through
 514    the pointers and __Block_byref_x_VarName struct to find the actual
 515    value of the variable.  The function addBlockByrefType does this.  */
 516
 517 /// Find the type the programmer originally declared the variable to be
 518 /// and return that type.
 519 ///
 520 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
 521
 522   DIType subType = Ty;
 523   unsigned tag = Ty.getTag();
 524
 525   if (tag == dwarf::DW_TAG_pointer_type) {
 526     DIDerivedType DTy = DIDerivedType(Ty.getNode());
 527     subType = DTy.getTypeDerivedFrom();
 528   }
 529
 530   DICompositeType blockStruct = DICompositeType(subType.getNode());
 531   DIArray Elements = blockStruct.getTypeArray();
 532
 533   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 534     DIDescriptor Element = Elements.getElement(i);
 535     DIDerivedType DT = DIDerivedType(Element.getNode());
 536     if (Name == DT.getName())
 537       return (DT.getTypeDerivedFrom());
 538   }
 539
 540   return Ty;
 541 }
 542
 543 /// addComplexAddress - Start with the address based on the location provided,
 544 /// and generate the DWARF information necessary to find the actual variable
 545 /// given the extra address information encoded in the DIVariable, starting from
 546 /// the starting location.  Add the DWARF information to the die.
 547 ///
 548 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
 549                                    unsigned Attribute,
 550                                    const MachineLocation &Location) {
 551   const DIVariable &VD = DV->getVariable();
 552   DIType Ty = VD.getType();
 553
 554   // Decode the original location, and use that as the start of the byref
 555   // variable's location.
 556   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 557   DIEBlock *Block = new DIEBlock();
 558
 559   if (Location.isReg()) {
 560     if (Reg < 32) {
 561       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 562     } else {
 563       Reg = Reg - dwarf::DW_OP_reg0;
 564       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 565       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 566     }
 567   } else {
 568     if (Reg < 32)
 569       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 570     else {
 571       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 572       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 573     }
 574
 575     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 576   }
 577
 578   for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
 579     uint64_t Element = VD.getAddrElement(i);
 580
 581     if (Element == DIFactory::OpPlus) {
 582       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 583       addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
 584     } else if (Element == DIFactory::OpDeref) {
 585       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 586     } else llvm_unreachable("unknown DIFactory Opcode");
 587   }
 588
 589   // Now attach the location information to the DIE.
 590   addBlock(Die, Attribute, 0, Block);
 591 }
 592
 593 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 594    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 595    gives the variable VarName either the struct, or a pointer to the struct, as
 596    its type.  This is necessary for various behind-the-scenes things the
 597    compiler needs to do with by-reference variables in Blocks.
 598
 599    However, as far as the original *programmer* is concerned, the variable
 600    should still have type 'SomeType', as originally declared.
 601
 602    The function getBlockByrefType dives into the __Block_byref_x_VarName
 603    struct to find the original type of the variable, which is then assigned to
 604    the variable's Debug Information Entry as its real type.  So far, so good.
 605    However now the debugger will expect the variable VarName to have the type
 606    SomeType.  So we need the location attribute for the variable to be an
 607    expression that explains to the debugger how to navigate through the
 608    pointers and struct to find the actual variable of type SomeType.
 609
 610    The following function does just that.  We start by getting
 611    the "normal" location for the variable. This will be the location
 612    of either the struct __Block_byref_x_VarName or the pointer to the
 613    struct __Block_byref_x_VarName.
 614
 615    The struct will look something like:
 616
 617    struct __Block_byref_x_VarName {
 618      ... <various fields>
 619      struct __Block_byref_x_VarName *forwarding;
 620      ... <various other fields>
 621      SomeType VarName;
 622      ... <maybe more fields>
 623    };
 624
 625    If we are given the struct directly (as our starting point) we
 626    need to tell the debugger to:
 627
 628    1).  Add the offset of the forwarding field.
 629
 630    2).  Follow that pointer to get the real __Block_byref_x_VarName
 631    struct to use (the real one may have been copied onto the heap).
 632
 633    3).  Add the offset for the field VarName, to find the actual variable.
 634
 635    If we started with a pointer to the struct, then we need to
 636    dereference that pointer first, before the other steps.
 637    Translating this into DWARF ops, we will need to append the following
 638    to the current location description for the variable:
 639
 640    DW_OP_deref                    -- optional, if we start with a pointer
 641    DW_OP_plus_uconst <forward_fld_offset>
 642    DW_OP_deref
 643    DW_OP_plus_uconst <varName_fld_offset>
 644
 645    That is what this function does.  */
 646
 647 /// addBlockByrefAddress - Start with the address based on the location
 648 /// provided, and generate the DWARF information necessary to find the
 649 /// actual Block variable (navigating the Block struct) based on the
 650 /// starting location.  Add the DWARF information to the die.  For
 651 /// more information, read large comment just above here.
 652 ///
 653 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
 654                                       unsigned Attribute,
 655                                       const MachineLocation &Location) {
 656   const DIVariable &VD = DV->getVariable();
 657   DIType Ty = VD.getType();
 658   DIType TmpTy = Ty;
 659   unsigned Tag = Ty.getTag();
 660   bool isPointer = false;
 661
 662   StringRef varName = VD.getName();
 663
 664   if (Tag == dwarf::DW_TAG_pointer_type) {
 665     DIDerivedType DTy = DIDerivedType(Ty.getNode());
 666     TmpTy = DTy.getTypeDerivedFrom();
 667     isPointer = true;
 668   }
 669
 670   DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
 671
 672   // Find the __forwarding field and the variable field in the __Block_byref
 673   // struct.
 674   DIArray Fields = blockStruct.getTypeArray();
 675   DIDescriptor varField = DIDescriptor();
 676   DIDescriptor forwardingField = DIDescriptor();
 677
 678   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
 679     DIDescriptor Element = Fields.getElement(i);
 680     DIDerivedType DT = DIDerivedType(Element.getNode());
 681     StringRef fieldName = DT.getName();
 682     if (fieldName == "__forwarding")
 683       forwardingField = Element;
 684     else if (fieldName == varName)
 685       varField = Element;
 686   }
 687
 688   // Get the offsets for the forwarding field and the variable field.
 689   unsigned int forwardingFieldOffset =
 690     DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
 691   unsigned int varFieldOffset =
 692     DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
 693
 694   // Decode the original location, and use that as the start of the byref
 695   // variable's location.
 696   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 697   DIEBlock *Block = new DIEBlock();
 698
 699   if (Location.isReg()) {
 700     if (Reg < 32)
 701       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 702     else {
 703       Reg = Reg - dwarf::DW_OP_reg0;
 704       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 705       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 706     }
 707   } else {
 708     if (Reg < 32)
 709       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 710     else {
 711       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 712       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 713     }
 714
 715     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 716   }
 717
 718   // If we started with a pointer to the __Block_byref... struct, then
 719   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 720   if (isPointer)
 721     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 722
 723   // Next add the offset for the '__forwarding' field:
 724   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 725   // adding the offset if it's 0.
 726   if (forwardingFieldOffset > 0) {
 727     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 728     addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
 729   }
 730
 731   // Now dereference the __forwarding field to get to the real __Block_byref
 732   // struct:  DW_OP_deref.
 733   addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 734
 735   // Now that we've got the real __Block_byref... struct, add the offset
 736   // for the variable's field to get to the location of the actual variable:
 737   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 738   if (varFieldOffset > 0) {
 739     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 740     addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
 741   }
 742
 743   // Now attach the location information to the DIE.
 744   addBlock(Die, Attribute, 0, Block);
 745 }
 746
 747 /// addAddress - Add an address attribute to a die based on the location
 748 /// provided.
 749 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
 750                             const MachineLocation &Location) {
 751   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 752   DIEBlock *Block = new DIEBlock();
 753
 754   if (Location.isReg()) {
 755     if (Reg < 32) {
 756       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 757     } else {
 758       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 759       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 760     }
 761   } else {
 762     if (Reg < 32) {
 763       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 764     } else {
 765       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 766       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 767     }
 768
 769     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 770   }
 771
 772   addBlock(Die, Attribute, 0, Block);
 773 }
 774
 775 /// addToContextOwner - Add Die into the list of its context owner's children.
 776 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
 777   if (Context.isType()) {
 778     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
 779     ContextDIE->addChild(Die);
 780   } else if (Context.isNameSpace()) {
 781     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
 782     ContextDIE->addChild(Die);
 783   } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
 784     ContextDIE->addChild(Die);
 785   else
 786     ModuleCU->addDie(Die);
 787 }
 788
 789 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 790 /// given DIType.
 791 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
 792   DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
 793   if (TyDIE)
 794     return TyDIE;
 795
 796   // Create new type.
 797   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 798   ModuleCU->insertDIE(Ty.getNode(), TyDIE);
 799   if (Ty.isBasicType())
 800     constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
 801   else if (Ty.isCompositeType())
 802     constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
 803   else {
 804     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 805     constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
 806   }
 807
 808   addToContextOwner(TyDIE, Ty.getContext());
 809   return TyDIE;
 810 }
 811
 812 /// addType - Add a new type attribute to the specified entity.
 813 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
 814   if (!Ty.isValid())
 815     return;
 816
 817   // Check for pre-existence.
 818   DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
 819   // If it exists then use the existing value.
 820   if (Entry) {
 821     Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 822     return;
 823   }
 824
 825   // Construct type.
 826   DIE *Buffer = getOrCreateTypeDIE(Ty);
 827
 828   // Set up proxy.
 829   Entry = createDIEEntry(Buffer);
 830   ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
 831
 832   Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 833 }
 834
 835 /// constructTypeDIE - Construct basic type die from DIBasicType.
 836 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 837   // Get core information.
 838   StringRef Name = BTy.getName();
 839   Buffer.setTag(dwarf::DW_TAG_base_type);
 840   addUInt(&Buffer, dwarf::DW_AT_encoding,  dwarf::DW_FORM_data1,
 841           BTy.getEncoding());
 842
 843   // Add name if not anonymous or intermediate type.
 844   if (!Name.empty())
 845     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 846   uint64_t Size = BTy.getSizeInBits() >> 3;
 847   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 848 }
 849
 850 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 851 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 852   // Get core information.
 853   StringRef Name = DTy.getName();
 854   uint64_t Size = DTy.getSizeInBits() >> 3;
 855   unsigned Tag = DTy.getTag();
 856
 857   // FIXME - Workaround for templates.
 858   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 859
 860   Buffer.setTag(Tag);
 861
 862   // Map to main type, void will not have a type.
 863   DIType FromTy = DTy.getTypeDerivedFrom();
 864   addType(&Buffer, FromTy);
 865
 866   // Add name if not anonymous or intermediate type.
 867   if (!Name.empty())
 868     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 869
 870   // Add size if non-zero (derived types might be zero-sized.)
 871   if (Size)
 872     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 873
 874   // Add source line info if available and TyDesc is not a forward declaration.
 875   if (!DTy.isForwardDecl())
 876     addSourceLine(&Buffer, &DTy);
 877 }
 878
 879 /// constructTypeDIE - Construct type DIE from DICompositeType.
 880 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 881   // Get core information.
 882   StringRef Name = CTy.getName();
 883
 884   uint64_t Size = CTy.getSizeInBits() >> 3;
 885   unsigned Tag = CTy.getTag();
 886   Buffer.setTag(Tag);
 887
 888   switch (Tag) {
 889   case dwarf::DW_TAG_vector_type:
 890   case dwarf::DW_TAG_array_type:
 891     constructArrayTypeDIE(Buffer, &CTy);
 892     break;
 893   case dwarf::DW_TAG_enumeration_type: {
 894     DIArray Elements = CTy.getTypeArray();
 895
 896     // Add enumerators to enumeration type.
 897     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 898       DIE *ElemDie = NULL;
 899       DIDescriptor Enum(Elements.getElement(i).getNode());
 900       if (Enum.isEnumerator()) {
 901         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
 902         Buffer.addChild(ElemDie);
 903       }
 904     }
 905   }
 906     break;
 907   case dwarf::DW_TAG_subroutine_type: {
 908     // Add return type.
 909     DIArray Elements = CTy.getTypeArray();
 910     DIDescriptor RTy = Elements.getElement(0);
 911     addType(&Buffer, DIType(RTy.getNode()));
 912
 913     // Add prototype flag.
 914     addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 915
 916     // Add arguments.
 917     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 918       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 919       DIDescriptor Ty = Elements.getElement(i);
 920       addType(Arg, DIType(Ty.getNode()));
 921       Buffer.addChild(Arg);
 922     }
 923   }
 924     break;
 925   case dwarf::DW_TAG_structure_type:
 926   case dwarf::DW_TAG_union_type:
 927   case dwarf::DW_TAG_class_type: {
 928     // Add elements to structure type.
 929     DIArray Elements = CTy.getTypeArray();
 930
 931     // A forward struct declared type may not have elements available.
 932     unsigned N = Elements.getNumElements();
 933     if (N == 0)
 934       break;
 935
 936     // Add elements to structure type.
 937     for (unsigned i = 0; i < N; ++i) {
 938       DIDescriptor Element = Elements.getElement(i);
 939       DIE *ElemDie = NULL;
 940       if (Element.isSubprogram())
 941         ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
 942       else if (Element.isVariable()) {
 943         DIVariable DV(Element.getNode());
 944         ElemDie = new DIE(dwarf::DW_TAG_variable);
 945         addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 946                   DV.getName());
 947         addType(ElemDie, DV.getType());
 948         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 949         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 950         addSourceLine(ElemDie, &DV);
 951       } else if (Element.isDerivedType())
 952         ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
 953       else
 954         continue;
 955       Buffer.addChild(ElemDie);
 956     }
 957
 958     if (CTy.isAppleBlockExtension())
 959       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
 960
 961     unsigned RLang = CTy.getRunTimeLang();
 962     if (RLang)
 963       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 964               dwarf::DW_FORM_data1, RLang);
 965
 966     DICompositeType ContainingType = CTy.getContainingType();
 967     if (DIDescriptor(ContainingType.getNode()).isCompositeType())
 968       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 969                   getOrCreateTypeDIE(DIType(ContainingType.getNode())));
 970     break;
 971   }
 972   default:
 973     break;
 974   }
 975
 976   // Add name if not anonymous or intermediate type.
 977   if (!Name.empty())
 978     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 979
 980   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
 981       Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
 982     // Add size if non-zero (derived types might be zero-sized.)
 983     if (Size)
 984       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 985     else {
 986       // Add zero size if it is not a forward declaration.
 987       if (CTy.isForwardDecl())
 988         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 989       else
 990         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 991     }
 992
 993     // Add source line info if available.
 994     if (!CTy.isForwardDecl())
 995       addSourceLine(&Buffer, &CTy);
 996   }
 997 }
 998
 999 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1000 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1001   int64_t L = SR.getLo();
1002   int64_t H = SR.getHi();
1003   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1004
1005   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1006   if (L)
1007     addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1008   addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1009
1010   Buffer.addChild(DW_Subrange);
1011 }
1012
1013 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1014 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1015                                        DICompositeType *CTy) {
1016   Buffer.setTag(dwarf::DW_TAG_array_type);
1017   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1018     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1019
1020   // Emit derived type.
1021   addType(&Buffer, CTy->getTypeDerivedFrom());
1022   DIArray Elements = CTy->getTypeArray();
1023
1024   // Get an anonymous type for index type.
1025   DIE *IdxTy = ModuleCU->getIndexTyDie();
1026   if (!IdxTy) {
1027     // Construct an anonymous type for index type.
1028     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1029     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1030     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1031             dwarf::DW_ATE_signed);
1032     ModuleCU->addDie(IdxTy);
1033     ModuleCU->setIndexTyDie(IdxTy);
1034   }
1035
1036   // Add subranges to array type.
1037   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1038     DIDescriptor Element = Elements.getElement(i);
1039     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1040       constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1041   }
1042 }
1043
1044 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1045 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1046   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1047   StringRef Name = ETy.getName();
1048   addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1049   int64_t Value = ETy.getEnumValue();
1050   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1051   return Enumerator;
1052 }
1053
1054 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1055 /// printer to not emit usual symbol prefix before the symbol name is used then
1056 /// return linkage name after skipping this special LLVM prefix.
1057 static StringRef getRealLinkageName(StringRef LinkageName) {
1058   char One = '\1';
1059   if (LinkageName.startswith(StringRef(&One, 1)))
1060     return LinkageName.substr(1);
1061   return LinkageName;
1062 }
1063
1064 /// createGlobalVariableDIE - Create new DIE using GV.
1065 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1066   // If the global variable was optmized out then no need to create debug info
1067   // entry.
1068   if (!GV.getGlobal()) return NULL;
1069   if (GV.getDisplayName().empty()) return NULL;
1070
1071   DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1072   addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1073             GV.getDisplayName());
1074
1075   StringRef LinkageName = GV.getLinkageName();
1076   if (!LinkageName.empty())
1077     addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1078               getRealLinkageName(LinkageName));
1079
1080   addType(GVDie, GV.getType());
1081   if (!GV.isLocalToUnit())
1082     addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1083   addSourceLine(GVDie, &GV);
1084
1085   return GVDie;
1086 }
1087
1088 /// createMemberDIE - Create new member DIE.
1089 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1090   DIE *MemberDie = new DIE(DT.getTag());
1091   StringRef Name = DT.getName();
1092   if (!Name.empty())
1093     addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1094
1095   addType(MemberDie, DT.getTypeDerivedFrom());
1096
1097   addSourceLine(MemberDie, &DT);
1098
1099   DIEBlock *MemLocationDie = new DIEBlock();
1100   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1101
1102   uint64_t Size = DT.getSizeInBits();
1103   uint64_t FieldSize = DT.getOriginalTypeSize();
1104
1105   if (Size != FieldSize) {
1106     // Handle bitfield.
1107     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1108     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1109
1110     uint64_t Offset = DT.getOffsetInBits();
1111     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1112     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1113     uint64_t FieldOffset = (HiMark - FieldSize);
1114     Offset -= FieldOffset;
1115
1116     // Maybe we need to work from the other end.
1117     if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1118     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1119
1120     // Here WD_AT_data_member_location points to the anonymous
1121     // field that includes this bit field.
1122     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1123
1124   } else
1125     // This is not a bitfield.
1126     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1127
1128   if (DT.getTag() == dwarf::DW_TAG_inheritance
1129       && DT.isVirtual()) {
1130
1131     // For C++, virtual base classes are not at fixed offset. Use following
1132     // expression to extract appropriate offset from vtable.
1133     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1134
1135     DIEBlock *VBaseLocationDie = new DIEBlock();
1136     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1137     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1138     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1139     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1140     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1141     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1142     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1143
1144     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1145              VBaseLocationDie);
1146   } else
1147     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1148
1149   if (DT.isProtected())
1150     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1151             dwarf::DW_ACCESS_protected);
1152   else if (DT.isPrivate())
1153     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1154             dwarf::DW_ACCESS_private);
1155   else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1156     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1157             dwarf::DW_ACCESS_public);
1158   if (DT.isVirtual())
1159     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1160             dwarf::DW_VIRTUALITY_virtual);
1161   return MemberDie;
1162 }
1163
1164 /// createSubprogramDIE - Create new DIE using SP.
1165 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1166   DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1167   if (SPDie)
1168     return SPDie;
1169
1170   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1171   // Constructors and operators for anonymous aggregates do not have names.
1172   if (!SP.getName().empty())
1173     addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1174
1175   StringRef LinkageName = SP.getLinkageName();
1176   if (!LinkageName.empty())
1177     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1178               getRealLinkageName(LinkageName));
1179
1180   addSourceLine(SPDie, &SP);
1181
1182   // Add prototyped tag, if C or ObjC.
1183   unsigned Lang = SP.getCompileUnit().getLanguage();
1184   if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1185       Lang == dwarf::DW_LANG_ObjC)
1186     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1187
1188   // Add Return Type.
1189   DICompositeType SPTy = SP.getType();
1190   DIArray Args = SPTy.getTypeArray();
1191   unsigned SPTag = SPTy.getTag();
1192
1193   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1194     addType(SPDie, SPTy);
1195   else
1196     addType(SPDie, DIType(Args.getElement(0).getNode()));
1197
1198   unsigned VK = SP.getVirtuality();
1199   if (VK) {
1200     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1201     DIEBlock *Block = new DIEBlock();
1202     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1203     addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1204     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1205     ContainingTypeMap.insert(std::make_pair(SPDie,
1206                                             SP.getContainingType().getNode()));
1207   }
1208
1209   if (MakeDecl || !SP.isDefinition()) {
1210     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1211
1212     // Add arguments. Do not add arguments for subprogram definition. They will
1213     // be handled while processing variables.
1214     DICompositeType SPTy = SP.getType();
1215     DIArray Args = SPTy.getTypeArray();
1216     unsigned SPTag = SPTy.getTag();
1217
1218     if (SPTag == dwarf::DW_TAG_subroutine_type)
1219       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1220         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1221         DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1222         addType(Arg, ATy);
1223         if (ATy.isArtificial())
1224           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1225         SPDie->addChild(Arg);
1226       }
1227   }
1228
1229   if (SP.isArtificial())
1230     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1231
1232   // DW_TAG_inlined_subroutine may refer to this DIE.
1233   ModuleCU->insertDIE(SP.getNode(), SPDie);
1234   return SPDie;
1235 }
1236
1237 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1238 /// Initialize scope and update scope hierarchy.
1239 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1240   MDNode *InlinedAt) {
1241   assert (N && "Invalid Scope encoding!");
1242   assert (MI && "Missing machine instruction!");
1243   bool GetConcreteScope = (MI && InlinedAt);
1244
1245   DbgScope *NScope = NULL;
1246
1247   if (InlinedAt)
1248     NScope = DbgScopeMap.lookup(InlinedAt);
1249   else
1250     NScope = DbgScopeMap.lookup(N);
1251   assert (NScope && "Unable to find working scope!");
1252
1253   if (NScope->getFirstInsn())
1254     return NScope;
1255
1256   DbgScope *Parent = NULL;
1257   if (GetConcreteScope) {
1258     DILocation IL(InlinedAt);
1259     Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1260                          IL.getOrigLocation().getNode());
1261     assert (Parent && "Unable to find Parent scope!");
1262     NScope->setParent(Parent);
1263     Parent->addScope(NScope);
1264   } else if (DIDescriptor(N).isLexicalBlock()) {
1265     DILexicalBlock DB(N);
1266     Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1267     NScope->setParent(Parent);
1268     Parent->addScope(NScope);
1269   }
1270
1271   NScope->setFirstInsn(MI);
1272
1273   if (!Parent && !InlinedAt) {
1274     StringRef SPName = DISubprogram(N).getLinkageName();
1275     if (SPName == MF->getFunction()->getName())
1276       CurrentFnDbgScope = NScope;
1277   }
1278
1279   if (GetConcreteScope) {
1280     ConcreteScopes[InlinedAt] = NScope;
1281     getOrCreateAbstractScope(N);
1282   }
1283
1284   return NScope;
1285 }
1286
1287 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1288   assert (N && "Invalid Scope encoding!");
1289
1290   DbgScope *AScope = AbstractScopes.lookup(N);
1291   if (AScope)
1292     return AScope;
1293
1294   DbgScope *Parent = NULL;
1295
1296   DIDescriptor Scope(N);
1297   if (Scope.isLexicalBlock()) {
1298     DILexicalBlock DB(N);
1299     DIDescriptor ParentDesc = DB.getContext();
1300     Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1301   }
1302
1303   AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1304
1305   if (Parent)
1306     Parent->addScope(AScope);
1307   AScope->setAbstractScope();
1308   AbstractScopes[N] = AScope;
1309   if (DIDescriptor(N).isSubprogram())
1310     AbstractScopesList.push_back(AScope);
1311   return AScope;
1312 }
1313
1314 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1315 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1316 /// If there are global variables in this scope then create and insert
1317 /// DIEs for these variables.
1318 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1319  DIE *SPDie = ModuleCU->getDIE(SPNode);
1320  assert(SPDie && "Unable to find subprogram DIE!");
1321  DISubprogram SP(SPNode);
1322
1323  // There is not any need to generate specification DIE for a function
1324  // defined at compile unit level. If a function is defined inside another
1325  // function then gdb prefers the definition at top level and but does not
1326  // expect specification DIE in parent function. So avoid creating
1327  // specification DIE for a function defined inside a function.
1328  if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1329      !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1330    addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1331
1332    // Add arguments.
1333    DICompositeType SPTy = SP.getType();
1334    DIArray Args = SPTy.getTypeArray();
1335    unsigned SPTag = SPTy.getTag();
1336    if (SPTag == dwarf::DW_TAG_subroutine_type)
1337      for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1338        DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1339        DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1340        addType(Arg, ATy);
1341        if (ATy.isArtificial())
1342          addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1343        SPDie->addChild(Arg);
1344      }
1345    DIE *SPDeclDie = SPDie;
1346    SPDie = new DIE(dwarf::DW_TAG_subprogram);
1347    addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1348                SPDeclDie);
1349    ModuleCU->addDie(SPDie);
1350  }
1351
1352  addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1353           getDWLabel("func_begin", SubprogramCount));
1354  addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1355           getDWLabel("func_end", SubprogramCount));
1356  MachineLocation Location(RI->getFrameRegister(*MF));
1357  addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1358
1359  if (!DISubprogram(SPNode).isLocalToUnit())
1360    addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1361
1362  return SPDie;
1363 }
1364
1365 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1366 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1367 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1368   MCSymbol *Start = Scope->getStartLabel();
1369   MCSymbol *End = Scope->getEndLabel();
1370   if (Start == 0) return 0;
1371
1372   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1373   assert(End->isDefined() && "Invalid end label for an inlined scope!");
1374
1375   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1376   if (Scope->isAbstractScope())
1377     return ScopeDIE;
1378
1379   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1380            Start ? Start : getDWLabel("func_begin", SubprogramCount));
1381   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1382            End ? End : getDWLabel("func_end", SubprogramCount));
1383
1384   return ScopeDIE;
1385 }
1386
1387 /// constructInlinedScopeDIE - This scope represents inlined body of
1388 /// a function. Construct DIE to represent this concrete inlined copy
1389 /// of the function.
1390 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1391   MCSymbol *StartLabel = Scope->getStartLabel();
1392   MCSymbol *EndLabel = Scope->getEndLabel();
1393   if (StartLabel == 0) return 0;
1394
1395   assert(StartLabel->isDefined() &&
1396          "Invalid starting label for an inlined scope!");
1397   assert(EndLabel->isDefined() &&
1398          "Invalid end label for an inlined scope!");
1399   if (!Scope->getScopeNode())
1400     return NULL;
1401   DIScope DS(Scope->getScopeNode());
1402   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1403
1404   DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1405   DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1406   assert (OriginDIE && "Unable to find Origin DIE!");
1407   addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1408               dwarf::DW_FORM_ref4, OriginDIE);
1409
1410   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1411   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1412
1413   InlinedSubprogramDIEs.insert(OriginDIE);
1414
1415   // Track the start label for this inlined function.
1416   DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1417     I = InlineInfo.find(InlinedSP.getNode());
1418
1419   if (I == InlineInfo.end()) {
1420     InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1421                                                              ScopeDIE));
1422     InlinedSPNodes.push_back(InlinedSP.getNode());
1423   } else
1424     I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1425
1426   DILocation DL(Scope->getInlinedAt());
1427   addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1428   addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1429
1430   return ScopeDIE;
1431 }
1432
1433
1434 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1435 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1436   // Get the descriptor.
1437   const DIVariable &VD = DV->getVariable();
1438   StringRef Name = VD.getName();
1439   if (Name.empty())
1440     return NULL;
1441
1442   // Translate tag to proper Dwarf tag.  The result variable is dropped for
1443   // now.
1444   unsigned Tag;
1445   switch (VD.getTag()) {
1446   case dwarf::DW_TAG_return_variable:
1447     return NULL;
1448   case dwarf::DW_TAG_arg_variable:
1449     Tag = dwarf::DW_TAG_formal_parameter;
1450     break;
1451   case dwarf::DW_TAG_auto_variable:    // fall thru
1452   default:
1453     Tag = dwarf::DW_TAG_variable;
1454     break;
1455   }
1456
1457   // Define variable debug information entry.
1458   DIE *VariableDie = new DIE(Tag);
1459
1460
1461   DIE *AbsDIE = NULL;
1462   if (DbgVariable *AV = DV->getAbstractVariable())
1463     AbsDIE = AV->getDIE();
1464
1465   if (AbsDIE) {
1466     DIScope DS(Scope->getScopeNode());
1467     DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1468     DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1469     (void) OriginSPDIE;
1470     assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1471     DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1472     assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1473     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1474                 dwarf::DW_FORM_ref4, AbsDIE);
1475   }
1476   else {
1477     addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1478     addSourceLine(VariableDie, &VD);
1479
1480     // Add variable type.
1481     // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1482     // addresses instead.
1483     if (VD.isBlockByrefVariable())
1484       addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1485     else
1486       addType(VariableDie, VD.getType());
1487   }
1488
1489   // Add variable address.
1490   if (!Scope->isAbstractScope()) {
1491     // Check if variable is described by DBG_VALUE instruction.
1492     if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1493       if (DbgValueInsn->getNumOperands() == 3) {
1494         // FIXME : Handle getNumOperands != 3
1495         if (DbgValueInsn->getOperand(0).getType()
1496             == MachineOperand::MO_Register
1497             && DbgValueInsn->getOperand(0).getReg()) {
1498           MachineLocation Location;
1499           Location.set(DbgValueInsn->getOperand(0).getReg());
1500           addAddress(VariableDie, dwarf::DW_AT_location, Location);
1501         } else if (DbgValueInsn->getOperand(0).getType() ==
1502                    MachineOperand::MO_Immediate) {
1503           DIEBlock *Block = new DIEBlock();
1504           unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1505           addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1506           addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1507         } else {
1508           //FIXME : Handle other operand types.
1509           delete VariableDie;
1510           return NULL;
1511         }
1512       }
1513     } else {
1514       MachineLocation Location;
1515       unsigned FrameReg;
1516       int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1517       Location.set(FrameReg, Offset);
1518
1519       if (VD.hasComplexAddress())
1520         addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1521       else if (VD.isBlockByrefVariable())
1522         addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1523       else
1524         addAddress(VariableDie, dwarf::DW_AT_location, Location);
1525     }
1526   }
1527
1528   if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1529     addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1530   DV->setDIE(VariableDie);
1531   return VariableDie;
1532
1533 }
1534
1535 void DwarfDebug::addPubTypes(DISubprogram SP) {
1536   DICompositeType SPTy = SP.getType();
1537   unsigned SPTag = SPTy.getTag();
1538   if (SPTag != dwarf::DW_TAG_subroutine_type)
1539     return;
1540
1541   DIArray Args = SPTy.getTypeArray();
1542   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1543     DIType ATy(Args.getElement(i).getNode());
1544     if (!ATy.isValid())
1545       continue;
1546     DICompositeType CATy = getDICompositeType(ATy);
1547     if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1548       if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1549         ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1550     }
1551   }
1552 }
1553
1554 /// constructScopeDIE - Construct a DIE for this scope.
1555 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1556   if (!Scope || !Scope->getScopeNode())
1557     return NULL;
1558
1559   DIScope DS(Scope->getScopeNode());
1560   DIE *ScopeDIE = NULL;
1561   if (Scope->getInlinedAt())
1562     ScopeDIE = constructInlinedScopeDIE(Scope);
1563   else if (DS.isSubprogram()) {
1564     if (Scope->isAbstractScope())
1565       ScopeDIE = ModuleCU->getDIE(DS.getNode());
1566     else
1567       ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1568   }
1569   else {
1570     ScopeDIE = constructLexicalScopeDIE(Scope);
1571     if (!ScopeDIE) return NULL;
1572   }
1573
1574   // Add variables to scope.
1575   const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1576   for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1577     DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1578     if (VariableDIE)
1579       ScopeDIE->addChild(VariableDIE);
1580   }
1581
1582   // Add nested scopes.
1583   const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1584   for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1585     // Define the Scope debug information entry.
1586     DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1587     if (NestedDIE)
1588       ScopeDIE->addChild(NestedDIE);
1589   }
1590
1591   if (DS.isSubprogram())
1592     addPubTypes(DISubprogram(DS.getNode()));
1593
1594  return ScopeDIE;
1595 }
1596
1597 /// GetOrCreateSourceID - Look up the source id with the given directory and
1598 /// source file names. If none currently exists, create a new id and insert it
1599 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1600 /// maps as well.
1601 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1602   unsigned DId;
1603   StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1604   if (DI != DirectoryIdMap.end()) {
1605     DId = DI->getValue();
1606   } else {
1607     DId = DirectoryNames.size() + 1;
1608     DirectoryIdMap[DirName] = DId;
1609     DirectoryNames.push_back(DirName);
1610   }
1611
1612   unsigned FId;
1613   StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1614   if (FI != SourceFileIdMap.end()) {
1615     FId = FI->getValue();
1616   } else {
1617     FId = SourceFileNames.size() + 1;
1618     SourceFileIdMap[FileName] = FId;
1619     SourceFileNames.push_back(FileName);
1620   }
1621
1622   DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1623     SourceIdMap.find(std::make_pair(DId, FId));
1624   if (SI != SourceIdMap.end())
1625     return SI->second;
1626
1627   unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
1628   SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1629   SourceIds.push_back(std::make_pair(DId, FId));
1630
1631   return SrcId;
1632 }
1633
1634 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1635 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1636   DIE *NDie = ModuleCU->getDIE(NS.getNode());
1637   if (NDie)
1638     return NDie;
1639   NDie = new DIE(dwarf::DW_TAG_namespace);
1640   ModuleCU->insertDIE(NS.getNode(), NDie);
1641   if (!NS.getName().empty())
1642     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1643   addSourceLine(NDie, &NS);
1644   addToContextOwner(NDie, NS.getContext());
1645   return NDie;
1646 }
1647
1648 void DwarfDebug::constructCompileUnit(MDNode *N) {
1649   DICompileUnit DIUnit(N);
1650   // Use first compile unit marked as isMain as the compile unit for this
1651   // module.
1652   if (ModuleCU || !DIUnit.isMain())
1653     return;
1654   StringRef FN = DIUnit.getFilename();
1655   StringRef Dir = DIUnit.getDirectory();
1656   unsigned ID = GetOrCreateSourceID(Dir, FN);
1657
1658   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1659   addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1660             DIUnit.getProducer());
1661   addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1662           DIUnit.getLanguage());
1663   addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1664   addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1665            getTempLabel("text_begin"));
1666   addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1667            getTempLabel("text_end"));
1668   // DW_AT_stmt_list is a offset of line number information for this
1669   // compile unit in debug_line section. It is always zero when only one
1670   // compile unit is emitted in one object file.
1671   addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1672
1673   if (!Dir.empty())
1674     addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1675   if (DIUnit.isOptimized())
1676     addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1677
1678   StringRef Flags = DIUnit.getFlags();
1679   if (!Flags.empty())
1680     addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1681
1682   unsigned RVer = DIUnit.getRunTimeVersion();
1683   if (RVer)
1684     addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1685             dwarf::DW_FORM_data1, RVer);
1686
1687   assert(!ModuleCU &&
1688          "ModuleCU assigned since the top of constructCompileUnit");
1689   ModuleCU = new CompileUnit(ID, Die);
1690 }
1691
1692 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1693   DIGlobalVariable DI_GV(N);
1694
1695   // If debug information is malformed then ignore it.
1696   if (DI_GV.Verify() == false)
1697     return;
1698
1699   // Check for pre-existence.
1700   if (ModuleCU->getDIE(DI_GV.getNode()))
1701     return;
1702
1703   DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1704   if (!VariableDie)
1705     return;
1706
1707   // Add to map.
1708   ModuleCU->insertDIE(N, VariableDie);
1709
1710   // Add to context owner.
1711   DIDescriptor GVContext = DI_GV.getContext();
1712   // Do not create specification DIE if context is either compile unit
1713   // or a subprogram.
1714   if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1715       && !GVContext.isFile() && !GVContext.isSubprogram()) {
1716     // Create specification DIE.
1717     DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1718     addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1719                 dwarf::DW_FORM_ref4, VariableDie);
1720     DIEBlock *Block = new DIEBlock();
1721     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1722     addLabel(Block, 0, dwarf::DW_FORM_udata,
1723              Asm->Mang->getSymbol(DI_GV.getGlobal()));
1724     addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1725     addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1726     ModuleCU->addDie(VariableSpecDIE);
1727   } else {
1728     DIEBlock *Block = new DIEBlock();
1729     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1730     addLabel(Block, 0, dwarf::DW_FORM_udata,
1731              Asm->Mang->getSymbol(DI_GV.getGlobal()));
1732     addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1733   }
1734   addToContextOwner(VariableDie, GVContext);
1735
1736   // Expose as global. FIXME - need to check external flag.
1737   ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1738
1739   DIType GTy = DI_GV.getType();
1740   if (GTy.isCompositeType() && !GTy.getName().empty()) {
1741     DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1742     assert (Entry && "Missing global type!");
1743     ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1744   }
1745   return;
1746 }
1747
1748 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1749   DISubprogram SP(N);
1750
1751   // Check for pre-existence.
1752   if (ModuleCU->getDIE(N))
1753     return;
1754
1755   if (!SP.isDefinition())
1756     // This is a method declaration which will be handled while constructing
1757     // class type.
1758     return;
1759
1760   DIE *SubprogramDie = createSubprogramDIE(SP);
1761
1762   // Add to map.
1763   ModuleCU->insertDIE(N, SubprogramDie);
1764
1765   // Add to context owner.
1766   addToContextOwner(SubprogramDie, SP.getContext());
1767
1768   // Expose as global.
1769   ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1770
1771   return;
1772 }
1773
1774 /// beginModule - Emit all Dwarf sections that should come prior to the
1775 /// content. Create global DIEs and emit initial debug info sections.
1776 /// This is inovked by the target AsmPrinter.
1777 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1778   this->M = M;
1779
1780   if (TimePassesIsEnabled)
1781     DebugTimer->startTimer();
1782
1783   if (!MAI->doesSupportDebugInformation())
1784     return;
1785
1786   DebugInfoFinder DbgFinder;
1787   DbgFinder.processModule(*M);
1788
1789   // Create all the compile unit DIEs.
1790   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1791          E = DbgFinder.compile_unit_end(); I != E; ++I)
1792     constructCompileUnit(*I);
1793
1794   if (!ModuleCU)
1795     return;
1796
1797   // Create DIEs for each subprogram.
1798   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1799          E = DbgFinder.subprogram_end(); I != E; ++I)
1800     constructSubprogramDIE(*I);
1801
1802   // Create DIEs for each global variable.
1803   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1804          E = DbgFinder.global_variable_end(); I != E; ++I)
1805     constructGlobalVariableDIE(*I);
1806
1807   MMI = mmi;
1808   shouldEmit = true;
1809   MMI->setDebugInfoAvailability(true);
1810
1811   // Prime section data.
1812   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1813
1814   // Print out .file directives to specify files for .loc directives. These are
1815   // printed out early so that they precede any .loc directives.
1816   if (MAI->hasDotLocAndDotFile()) {
1817     for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1818       // Remember source id starts at 1.
1819       std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1820       // FIXME: don't use sys::path for this!  This should not depend on the
1821       // host.
1822       sys::Path FullPath(getSourceDirectoryName(Id.first));
1823       bool AppendOk =
1824         FullPath.appendComponent(getSourceFileName(Id.second));
1825       assert(AppendOk && "Could not append filename to directory!");
1826       AppendOk = false;
1827       Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1828     }
1829   }
1830
1831   // Emit initial sections
1832   emitInitial();
1833
1834   if (TimePassesIsEnabled)
1835     DebugTimer->stopTimer();
1836 }
1837
1838 /// endModule - Emit all Dwarf sections that should come after the content.
1839 ///
1840 void DwarfDebug::endModule() {
1841   if (!ModuleCU)
1842     return;
1843
1844   if (TimePassesIsEnabled)
1845     DebugTimer->startTimer();
1846
1847   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1848   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1849          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1850     DIE *ISP = *AI;
1851     addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1852   }
1853
1854   // Insert top level DIEs.
1855   for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1856          TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1857     ModuleCU->getCUDie()->addChild(*TI);
1858
1859   for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1860          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1861     DIE *SPDie = CI->first;
1862     MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1863     if (!N) continue;
1864     DIE *NDie = ModuleCU->getDIE(N);
1865     if (!NDie) continue;
1866     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1867     // FIXME - This is not the correct approach.
1868     // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1869   }
1870
1871   // Standard sections final addresses.
1872   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1873   Asm->OutStreamer.EmitLabel(getTempLabel("text_end"));
1874   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1875   Asm->OutStreamer.EmitLabel(getTempLabel("data_end"));
1876
1877   // End text sections.
1878   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1879     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1880     Asm->OutStreamer.EmitLabel(getDWLabel("section_end", i));
1881   }
1882
1883   // Emit common frame information.
1884   emitCommonDebugFrame();
1885
1886   // Emit function debug frame information
1887   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1888          E = DebugFrames.end(); I != E; ++I)
1889     emitFunctionDebugFrame(*I);
1890
1891   // Compute DIE offsets and sizes.
1892   computeSizeAndOffsets();
1893
1894   // Emit all the DIEs into a debug info section
1895   emitDebugInfo();
1896
1897   // Corresponding abbreviations into a abbrev section.
1898   emitAbbreviations();
1899
1900   // Emit source line correspondence into a debug line section.
1901   emitDebugLines();
1902
1903   // Emit info into a debug pubnames section.
1904   emitDebugPubNames();
1905
1906   // Emit info into a debug pubtypes section.
1907   emitDebugPubTypes();
1908
1909   // Emit info into a debug loc section.
1910   emitDebugLoc();
1911
1912   // Emit info into a debug aranges section.
1913   EmitDebugARanges();
1914
1915   // Emit info into a debug ranges section.
1916   emitDebugRanges();
1917
1918   // Emit info into a debug macinfo section.
1919   emitDebugMacInfo();
1920
1921   // Emit inline info.
1922   emitDebugInlineInfo();
1923
1924   // Emit info into a debug str section.
1925   emitDebugStr();
1926
1927   delete ModuleCU;
1928   ModuleCU = NULL;  // Reset for the next Module, if any.
1929
1930   if (TimePassesIsEnabled)
1931     DebugTimer->stopTimer();
1932 }
1933
1934 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1935 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1936                                               unsigned FrameIdx,
1937                                               DILocation &ScopeLoc) {
1938
1939   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1940   if (AbsDbgVariable)
1941     return AbsDbgVariable;
1942
1943   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1944   if (!Scope)
1945     return NULL;
1946
1947   AbsDbgVariable = new DbgVariable(Var, FrameIdx,
1948                                    NULL /* No more-abstract variable*/);
1949   Scope->addVariable(AbsDbgVariable);
1950   AbstractVariables[Var.getNode()] = AbsDbgVariable;
1951   return AbsDbgVariable;
1952 }
1953
1954 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1955 /// FIXME : Refactor findAbstractVariable.
1956 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1957                                               const MachineInstr *MI,
1958                                               DILocation &ScopeLoc) {
1959
1960   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1961   if (AbsDbgVariable)
1962     return AbsDbgVariable;
1963
1964   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1965   if (!Scope)
1966     return NULL;
1967
1968   AbsDbgVariable = new DbgVariable(Var, MI,
1969                                    NULL /* No more-abstract variable*/);
1970   Scope->addVariable(AbsDbgVariable);
1971   AbstractVariables[Var.getNode()] = AbsDbgVariable;
1972   return AbsDbgVariable;
1973 }
1974
1975 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1976 void DwarfDebug::collectVariableInfo() {
1977   if (!MMI) return;
1978
1979   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1980   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1981          VE = VMap.end(); VI != VE; ++VI) {
1982     MDNode *Var = VI->first;
1983     if (!Var) continue;
1984     DIVariable DV (Var);
1985     std::pair< unsigned, MDNode *> VP = VI->second;
1986     DILocation ScopeLoc(VP.second);
1987
1988     DbgScope *Scope =
1989       ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1990     if (!Scope)
1991       Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1992     // If variable scope is not found then skip this variable.
1993     if (!Scope)
1994       continue;
1995
1996     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, ScopeLoc);
1997     DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
1998     Scope->addVariable(RegVar);
1999   }
2000
2001   // Collect variable information from DBG_VALUE machine instructions;
2002   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2003        I != E; ++I) {
2004     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2005          II != IE; ++II) {
2006       const MachineInstr *MInsn = II;
2007       if (MInsn->getOpcode() != TargetOpcode::DBG_VALUE)
2008         continue;
2009       // FIXME : Lift this restriction.
2010       if (MInsn->getNumOperands() != 3)
2011         continue;
2012       DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata()));
2013       if (DV.getTag() == dwarf::DW_TAG_arg_variable)  {
2014         // FIXME Handle inlined subroutine arguments.
2015         DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2016         CurrentFnDbgScope->addVariable(ArgVar);
2017         continue;
2018       }
2019
2020       DebugLoc DL = MInsn->getDebugLoc();
2021       if (DL.isUnknown()) continue;
2022       DILocation ScopeLoc = MF->getDILocation(DL);
2023       DbgScope *Scope =
2024         ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
2025       if (!Scope)
2026         Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
2027       // If variable scope is not found then skip this variable.
2028       if (!Scope)
2029         continue;
2030
2031       DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn,
2032                                                          ScopeLoc);
2033       DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2034       Scope->addVariable(RegVar);
2035     }
2036   }
2037 }
2038
2039 /// beginScope - Process beginning of a scope.
2040 void DwarfDebug::beginScope(const MachineInstr *MI) {
2041   // Ignore DBG_VALUE instructions.
2042   if (MI->getOpcode() == TargetOpcode::DBG_VALUE)
2043     return;
2044
2045   // Check location.
2046   DebugLoc DL = MI->getDebugLoc();
2047   if (DL.isUnknown())
2048     return;
2049   DILocation DILoc = MF->getDILocation(DL);
2050   if (!DILoc.getScope().Verify())
2051     return;
2052
2053   // Check and update last known location info.
2054   if(DILoc.getNode() == PrevDILoc)
2055     return;
2056   PrevDILoc = DILoc.getNode();
2057
2058   // Emit a label to indicate location change. This is used for line
2059   // table even if this instruction does start a new scope.
2060   MCSymbol *Label = recordSourceLine(DILoc.getLineNumber(),
2061                                      DILoc.getColumnNumber(),
2062                                      DILoc.getScope().getNode());
2063
2064   // update DbgScope if this instruction starts a new scope.
2065   InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2066   if (I == DbgScopeBeginMap.end())
2067     return;
2068
2069   ScopeVector &SD = I->second;
2070   for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2071        SDI != SDE; ++SDI)
2072     (*SDI)->setStartLabel(Label);
2073
2074 }
2075
2076 /// endScope - Process end of a scope.
2077 void DwarfDebug::endScope(const MachineInstr *MI) {
2078   // Ignore DBG_VALUE instruction.
2079   if (MI->getOpcode() == TargetOpcode::DBG_VALUE)
2080     return;
2081
2082   // Check location.
2083   DebugLoc DL = MI->getDebugLoc();
2084   if (DL.isUnknown())
2085     return;
2086   DILocation DILoc = MF->getDILocation(DL);
2087   if (!DILoc.getScope().Verify())
2088     return;
2089
2090   // Emit a label and update DbgScope if this instruction ends a scope.
2091   InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2092   if (I == DbgScopeEndMap.end())
2093     return;
2094
2095   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2096   Asm->OutStreamer.EmitLabel(Label);
2097
2098   SmallVector<DbgScope*, 2> &SD = I->second;
2099   for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2100        SDI != SDE; ++SDI)
2101     (*SDI)->setEndLabel(Label);
2102   return;
2103 }
2104
2105 /// createDbgScope - Create DbgScope for the scope.
2106 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2107
2108   if (!InlinedAt) {
2109     DbgScope *WScope = DbgScopeMap.lookup(Scope);
2110     if (WScope)
2111       return;
2112     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2113     DbgScopeMap.insert(std::make_pair(Scope, WScope));
2114     if (DIDescriptor(Scope).isLexicalBlock())
2115       createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2116     return;
2117   }
2118
2119   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2120   if (WScope)
2121     return;
2122
2123   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2124   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2125   DILocation DL(InlinedAt);
2126   createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2127 }
2128
2129 /// extractScopeInformation - Scan machine instructions in this function
2130 /// and collect DbgScopes. Return true, if atleast one scope was found.
2131 bool DwarfDebug::extractScopeInformation() {
2132   // If scope information was extracted using .dbg intrinsics then there is not
2133   // any need to extract these information by scanning each instruction.
2134   if (!DbgScopeMap.empty())
2135     return false;
2136
2137   DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2138   unsigned MIIndex = 0;
2139   // Scan each instruction and create scopes. First build working set of scopes.
2140   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2141        I != E; ++I) {
2142     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2143          II != IE; ++II) {
2144       const MachineInstr *MInsn = II;
2145       // FIXME : Remove DBG_VALUE check.
2146       if (MInsn->getOpcode() == TargetOpcode::DBG_VALUE) continue;
2147       MIIndexMap[MInsn] = MIIndex++;
2148       DebugLoc DL = MInsn->getDebugLoc();
2149       if (DL.isUnknown()) continue;
2150       DILocation DLT = MF->getDILocation(DL);
2151       DIScope DLTScope = DLT.getScope();
2152       // There is no need to create another DIE for compile unit. For all
2153       // other scopes, create one DbgScope now. This will be translated
2154       // into a scope DIE at the end.
2155       if (DLTScope.isCompileUnit()) continue;
2156       createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2157     }
2158   }
2159
2160
2161   // Build scope hierarchy using working set of scopes.
2162   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2163        I != E; ++I) {
2164     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2165          II != IE; ++II) {
2166       const MachineInstr *MInsn = II;
2167       // FIXME : Remove DBG_VALUE check.
2168       if (MInsn->getOpcode() == TargetOpcode::DBG_VALUE) continue;
2169       DebugLoc DL = MInsn->getDebugLoc();
2170       if (DL.isUnknown())  continue;
2171       DILocation DLT = MF->getDILocation(DL);
2172       DIScope DLTScope = DLT.getScope();
2173       // There is no need to create another DIE for compile unit. For all
2174       // other scopes, create one DbgScope now. This will be translated
2175       // into a scope DIE at the end.
2176       if (DLTScope.isCompileUnit()) continue;
2177       DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2178                                            DLT.getOrigLocation().getNode());
2179       Scope->setLastInsn(MInsn);
2180     }
2181   }
2182
2183   if (!CurrentFnDbgScope)
2184     return false;
2185
2186   CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2187
2188   // Each scope has first instruction and last instruction to mark beginning
2189   // and end of a scope respectively. Create an inverse map that list scopes
2190   // starts (and ends) with an instruction. One instruction may start (or end)
2191   // multiple scopes. Ignore scopes that are not reachable.
2192   SmallVector<DbgScope *, 4> WorkList;
2193   WorkList.push_back(CurrentFnDbgScope);
2194   while (!WorkList.empty()) {
2195     DbgScope *S = WorkList.back(); WorkList.pop_back();
2196
2197     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2198     if (!Children.empty())
2199       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2200              SE = Children.end(); SI != SE; ++SI)
2201         WorkList.push_back(*SI);
2202
2203     if (S->isAbstractScope())
2204       continue;
2205     const MachineInstr *MI = S->getFirstInsn();
2206     assert (MI && "DbgScope does not have first instruction!");
2207
2208     InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2209     if (IDI != DbgScopeBeginMap.end())
2210       IDI->second.push_back(S);
2211     else
2212       DbgScopeBeginMap[MI].push_back(S);
2213
2214     MI = S->getLastInsn();
2215     assert (MI && "DbgScope does not have last instruction!");
2216     IDI = DbgScopeEndMap.find(MI);
2217     if (IDI != DbgScopeEndMap.end())
2218       IDI->second.push_back(S);
2219     else
2220       DbgScopeEndMap[MI].push_back(S);
2221   }
2222
2223   return !DbgScopeMap.empty();
2224 }
2225
2226 /// beginFunction - Gather pre-function debug information.  Assumes being
2227 /// emitted immediately after the function entry point.
2228 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2229   this->MF = MF;
2230
2231   if (!ShouldEmitDwarfDebug()) return;
2232
2233   if (TimePassesIsEnabled)
2234     DebugTimer->startTimer();
2235
2236   if (!extractScopeInformation())
2237     return;
2238
2239   collectVariableInfo();
2240
2241   // Assumes in correct section after the entry point.
2242   Asm->OutStreamer.EmitLabel(getDWLabel("func_begin", ++SubprogramCount));
2243
2244   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2245   // function.
2246   DebugLoc FDL = MF->getDefaultDebugLoc();
2247   if (!FDL.isUnknown()) {
2248     DILocation DLT = MF->getDILocation(FDL);
2249     DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2250     unsigned Line, Col;
2251     if (SP.Verify()) {
2252       Line = SP.getLineNumber();
2253       Col = 0;
2254     } else {
2255       Line = DLT.getLineNumber();
2256       Col = DLT.getColumnNumber();
2257     }
2258
2259     recordSourceLine(Line, Col, DLT.getScope().getNode());
2260   }
2261   if (TimePassesIsEnabled)
2262     DebugTimer->stopTimer();
2263 }
2264
2265 /// endFunction - Gather and emit post-function debug information.
2266 ///
2267 void DwarfDebug::endFunction(const MachineFunction *MF) {
2268   if (!ShouldEmitDwarfDebug()) return;
2269
2270   if (TimePassesIsEnabled)
2271     DebugTimer->startTimer();
2272
2273   if (DbgScopeMap.empty())
2274     return;
2275
2276   if (CurrentFnDbgScope) {
2277     // Define end label for subprogram.
2278     Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount));
2279
2280     // Get function line info.
2281     if (!Lines.empty()) {
2282       // Get section line info.
2283       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2284       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2285       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2286       // Append the function info to section info.
2287       SectionLineInfos.insert(SectionLineInfos.end(),
2288                               Lines.begin(), Lines.end());
2289     }
2290
2291     // Construct abstract scopes.
2292     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2293            AE = AbstractScopesList.end(); AI != AE; ++AI)
2294       constructScopeDIE(*AI);
2295
2296     constructScopeDIE(CurrentFnDbgScope);
2297
2298     DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2299                                                  MMI->getFrameMoves()));
2300   }
2301
2302   // Clear debug info
2303   CurrentFnDbgScope = NULL;
2304   DeleteContainerSeconds(DbgScopeMap);
2305   DbgScopeBeginMap.clear();
2306   DbgScopeEndMap.clear();
2307   ConcreteScopes.clear();
2308   DeleteContainerSeconds(AbstractScopes);
2309   AbstractScopesList.clear();
2310   AbstractVariables.clear();
2311   Lines.clear();
2312
2313   if (TimePassesIsEnabled)
2314     DebugTimer->stopTimer();
2315 }
2316
2317 /// recordSourceLine - Register a source line with debug info. Returns the
2318 /// unique label that was emitted and which provides correspondence to
2319 /// the source line list.
2320 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2321   if (!MMI)
2322     return 0;
2323
2324   if (TimePassesIsEnabled)
2325     DebugTimer->startTimer();
2326
2327   StringRef Dir;
2328   StringRef Fn;
2329
2330   DIDescriptor Scope(S);
2331   if (Scope.isCompileUnit()) {
2332     DICompileUnit CU(S);
2333     Dir = CU.getDirectory();
2334     Fn = CU.getFilename();
2335   } else if (Scope.isSubprogram()) {
2336     DISubprogram SP(S);
2337     Dir = SP.getDirectory();
2338     Fn = SP.getFilename();
2339   } else if (Scope.isLexicalBlock()) {
2340     DILexicalBlock DB(S);
2341     Dir = DB.getDirectory();
2342     Fn = DB.getFilename();
2343   } else
2344     assert(0 && "Unexpected scope info");
2345
2346   unsigned Src = GetOrCreateSourceID(Dir, Fn);
2347   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2348   Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2349
2350   if (TimePassesIsEnabled)
2351     DebugTimer->stopTimer();
2352
2353   Asm->OutStreamer.EmitLabel(Label);
2354   return Label;
2355 }
2356
2357 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2358 /// timed. Look up the source id with the given directory and source file
2359 /// names. If none currently exists, create a new id and insert it in the
2360 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2361 /// well.
2362 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2363                                          const std::string &FileName) {
2364   if (TimePassesIsEnabled)
2365     DebugTimer->startTimer();
2366
2367   unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2368
2369   if (TimePassesIsEnabled)
2370     DebugTimer->stopTimer();
2371
2372   return SrcId;
2373 }
2374
2375 //===----------------------------------------------------------------------===//
2376 // Emit Methods
2377 //===----------------------------------------------------------------------===//
2378
2379 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2380 ///
2381 unsigned
2382 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2383   // Get the children.
2384   const std::vector<DIE *> &Children = Die->getChildren();
2385
2386   // If not last sibling and has children then add sibling offset attribute.
2387   if (!Last && !Children.empty())
2388     DIEValues.push_back(Die->addSiblingOffset());
2389
2390   // Record the abbreviation.
2391   assignAbbrevNumber(Die->getAbbrev());
2392
2393   // Get the abbreviation for this DIE.
2394   unsigned AbbrevNumber = Die->getAbbrevNumber();
2395   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2396
2397   // Set DIE offset
2398   Die->setOffset(Offset);
2399
2400   // Start the size with the size of abbreviation code.
2401   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2402
2403   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2404   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2405
2406   // Size the DIE attribute values.
2407   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2408     // Size attribute value.
2409     Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2410
2411   // Size the DIE children if any.
2412   if (!Children.empty()) {
2413     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2414            "Children flag not set");
2415
2416     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2417       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2418
2419     // End of children marker.
2420     Offset += sizeof(int8_t);
2421   }
2422
2423   Die->setSize(Offset - Die->getOffset());
2424   return Offset;
2425 }
2426
2427 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2428 ///
2429 void DwarfDebug::computeSizeAndOffsets() {
2430   // Compute size of compile unit header.
2431   static unsigned Offset =
2432     sizeof(int32_t) + // Length of Compilation Unit Info
2433     sizeof(int16_t) + // DWARF version number
2434     sizeof(int32_t) + // Offset Into Abbrev. Section
2435     sizeof(int8_t);   // Pointer Size (in bytes)
2436
2437   computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2438   CompileUnitOffsets[ModuleCU] = 0;
2439 }
2440
2441 /// emitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2442 /// tools to recognize the object file contains Dwarf information.
2443 void DwarfDebug::emitInitial() {
2444   // Check to see if we already emitted intial headers.
2445   if (didInitial) return;
2446   didInitial = true;
2447
2448   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2449
2450   // Dwarf sections base addresses.
2451   if (MAI->doesDwarfRequireFrameSection()) {
2452     Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2453     Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame"));
2454   }
2455
2456   Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2457   Asm->OutStreamer.EmitLabel(getTempLabel("section_info"));
2458   Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2459   Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev"));
2460   Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2461   Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges"));
2462
2463   if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2464     Asm->OutStreamer.SwitchSection(LineInfoDirective);
2465     Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo"));
2466   }
2467
2468   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2469   Asm->OutStreamer.EmitLabel(getTempLabel("section_line"));
2470   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2471   Asm->OutStreamer.EmitLabel(getTempLabel("section_loc"));
2472   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2473   Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames"));
2474   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2475   Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes"));
2476   Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2477   Asm->OutStreamer.EmitLabel(getTempLabel("section_str"));
2478   Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2479   Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges"));
2480
2481   Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2482   Asm->OutStreamer.EmitLabel(getTempLabel("text_begin"));
2483   Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2484   Asm->OutStreamer.EmitLabel(getTempLabel("data_begin"));
2485 }
2486
2487 /// emitDIE - Recusively Emits a debug information entry.
2488 ///
2489 void DwarfDebug::emitDIE(DIE *Die) {
2490   // Get the abbreviation for this DIE.
2491   unsigned AbbrevNumber = Die->getAbbrevNumber();
2492   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2493
2494   // Emit the code (index) for the abbreviation.
2495   if (Asm->VerboseAsm)
2496     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2497                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2498                                 Twine::utohexstr(Die->getSize()) + " " +
2499                                 dwarf::TagString(Abbrev->getTag()));
2500   EmitULEB128(AbbrevNumber);
2501
2502   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2503   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2504
2505   // Emit the DIE attribute values.
2506   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2507     unsigned Attr = AbbrevData[i].getAttribute();
2508     unsigned Form = AbbrevData[i].getForm();
2509     assert(Form && "Too many attributes for DIE (check abbreviation)");
2510
2511     if (Asm->VerboseAsm)
2512       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2513
2514     switch (Attr) {
2515     case dwarf::DW_AT_sibling:
2516       Asm->EmitInt32(Die->getSiblingOffset());
2517       break;
2518     case dwarf::DW_AT_abstract_origin: {
2519       DIEEntry *E = cast<DIEEntry>(Values[i]);
2520       DIE *Origin = E->getEntry();
2521       unsigned Addr = Origin->getOffset();
2522       Asm->EmitInt32(Addr);
2523       break;
2524     }
2525     default:
2526       // Emit an attribute using the defined form.
2527       Values[i]->EmitValue(this, Form);
2528       break;
2529     }
2530   }
2531
2532   // Emit the DIE children if any.
2533   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2534     const std::vector<DIE *> &Children = Die->getChildren();
2535
2536     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2537       emitDIE(Children[j]);
2538
2539     if (Asm->VerboseAsm)
2540       Asm->OutStreamer.AddComment("End Of Children Mark");
2541     Asm->EmitInt8(0);
2542   }
2543 }
2544
2545 /// emitDebugInfo - Emit the debug info section.
2546 ///
2547 void DwarfDebug::emitDebugInfo() {
2548   // Start debug info section.
2549   Asm->OutStreamer.SwitchSection(
2550                             Asm->getObjFileLowering().getDwarfInfoSection());
2551   DIE *Die = ModuleCU->getCUDie();
2552
2553   // Emit the compile units header.
2554   Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID()));
2555
2556   // Emit size of content not including length itself
2557   unsigned ContentSize = Die->getSize() +
2558     sizeof(int16_t) + // DWARF version number
2559     sizeof(int32_t) + // Offset Into Abbrev. Section
2560     sizeof(int8_t) +  // Pointer Size (in bytes)
2561     sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2562
2563   Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2564   Asm->EmitInt32(ContentSize);
2565   Asm->OutStreamer.AddComment("DWARF version number");
2566   Asm->EmitInt16(dwarf::DWARF_VERSION);
2567   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2568   EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"),
2569                     true);
2570   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2571   Asm->EmitInt8(TD->getPointerSize());
2572
2573   emitDIE(Die);
2574   // FIXME - extra padding for gdb bug.
2575   Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2576   Asm->EmitInt8(0);
2577   Asm->EmitInt8(0);
2578   Asm->EmitInt8(0);
2579   Asm->EmitInt8(0);
2580   Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID()));
2581 }
2582
2583 /// emitAbbreviations - Emit the abbreviation section.
2584 ///
2585 void DwarfDebug::emitAbbreviations() const {
2586   // Check to see if it is worth the effort.
2587   if (!Abbreviations.empty()) {
2588     // Start the debug abbrev section.
2589     Asm->OutStreamer.SwitchSection(
2590                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2591
2592     Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin"));
2593
2594     // For each abbrevation.
2595     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2596       // Get abbreviation data
2597       const DIEAbbrev *Abbrev = Abbreviations[i];
2598
2599       // Emit the abbrevations code (base 1 index.)
2600       EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2601
2602       // Emit the abbreviations data.
2603       Abbrev->Emit(this);
2604     }
2605
2606     // Mark end of abbreviations.
2607     EmitULEB128(0, "EOM(3)");
2608
2609     Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end"));
2610   }
2611 }
2612
2613 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2614 /// the line matrix.
2615 ///
2616 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2617   // Define last address of section.
2618   Asm->OutStreamer.AddComment("Extended Op");
2619   Asm->EmitInt8(0);
2620
2621   Asm->OutStreamer.AddComment("Op size");
2622   Asm->EmitInt8(TD->getPointerSize() + 1);
2623   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2624   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2625
2626   Asm->OutStreamer.AddComment("Section end label");
2627
2628   Asm->OutStreamer.EmitSymbolValue(getDWLabel("section_end", SectionEnd),
2629                                    TD->getPointerSize(), 0/*AddrSpace*/);
2630
2631   // Mark end of matrix.
2632   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2633   Asm->EmitInt8(0);
2634   Asm->EmitInt8(1);
2635   Asm->EmitInt8(1);
2636 }
2637
2638 /// emitDebugLines - Emit source line information.
2639 ///
2640 void DwarfDebug::emitDebugLines() {
2641   // If the target is using .loc/.file, the assembler will be emitting the
2642   // .debug_line table automatically.
2643   if (MAI->hasDotLocAndDotFile())
2644     return;
2645
2646   // Minimum line delta, thus ranging from -10..(255-10).
2647   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2648   // Maximum line delta, thus ranging from -10..(255-10).
2649   const int MaxLineDelta = 255 + MinLineDelta;
2650
2651   // Start the dwarf line section.
2652   Asm->OutStreamer.SwitchSection(
2653                             Asm->getObjFileLowering().getDwarfLineSection());
2654
2655   // Construct the section header.
2656   Asm->OutStreamer.AddComment("Length of Source Line Info");
2657   EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true);
2658   Asm->OutStreamer.EmitLabel(getTempLabel("line_begin"));
2659
2660   Asm->OutStreamer.AddComment("DWARF version number");
2661   Asm->EmitInt16(dwarf::DWARF_VERSION);
2662
2663   Asm->OutStreamer.AddComment("Prolog Length");
2664   EmitDifference(getTempLabel("line_prolog_end"),
2665                  getTempLabel("line_prolog_begin"), true);
2666   Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin"));
2667
2668   Asm->OutStreamer.AddComment("Minimum Instruction Length");
2669   Asm->EmitInt8(1);
2670   Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2671   Asm->EmitInt8(1);
2672   Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2673   Asm->EmitInt8(MinLineDelta);
2674   Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2675   Asm->EmitInt8(MaxLineDelta);
2676   Asm->OutStreamer.AddComment("Special Opcode Base");
2677   Asm->EmitInt8(-MinLineDelta);
2678
2679   // Line number standard opcode encodings argument count
2680   Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2681   Asm->EmitInt8(0);
2682   Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2683   Asm->EmitInt8(1);
2684   Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2685   Asm->EmitInt8(1);
2686   Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2687   Asm->EmitInt8(1);
2688   Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2689   Asm->EmitInt8(1);
2690   Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2691   Asm->EmitInt8(0);
2692   Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2693   Asm->EmitInt8(0);
2694   Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2695   Asm->EmitInt8(0);
2696   Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2697   Asm->EmitInt8(1);
2698
2699   // Emit directories.
2700   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2701     const std::string &Dir = getSourceDirectoryName(DI);
2702     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2703     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2704   }
2705
2706   Asm->OutStreamer.AddComment("End of directories");
2707   Asm->EmitInt8(0);
2708
2709   // Emit files.
2710   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2711     // Remember source id starts at 1.
2712     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2713     const std::string &FN = getSourceFileName(Id.second);
2714     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2715     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2716
2717     EmitULEB128(Id.first, "Directory #");
2718     EmitULEB128(0, "Mod date");
2719     EmitULEB128(0, "File size");
2720   }
2721
2722   Asm->OutStreamer.AddComment("End of files");
2723   Asm->EmitInt8(0);
2724
2725   Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end"));
2726
2727   // A sequence for each text section.
2728   unsigned SecSrcLinesSize = SectionSourceLines.size();
2729
2730   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2731     // Isolate current sections line info.
2732     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2733
2734     // Dwarf assumes we start with first line of first source file.
2735     unsigned Source = 1;
2736     unsigned Line = 1;
2737
2738     // Construct rows of the address, source, line, column matrix.
2739     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2740       const SrcLineInfo &LineInfo = LineInfos[i];
2741       MCSymbol *Label = LineInfo.getLabel();
2742       if (!Label->isDefined()) continue; // Not emitted, in dead code.
2743
2744       if (LineInfo.getLine() == 0) continue;
2745
2746       if (Asm->isVerbose()) {
2747         std::pair<unsigned, unsigned> SrcID =
2748           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2749         Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2750                                     "/" +
2751                                     Twine(getSourceFileName(SrcID.second)) +
2752                                     ":" + Twine(LineInfo.getLine()));
2753       }
2754
2755       // Define the line address.
2756       Asm->OutStreamer.AddComment("Extended Op");
2757       Asm->EmitInt8(0);
2758       Asm->OutStreamer.AddComment("Op size");
2759       Asm->EmitInt8(TD->getPointerSize() + 1);
2760
2761       Asm->OutStreamer.AddComment("DW_LNE_set_address");
2762       Asm->EmitInt8(dwarf::DW_LNE_set_address);
2763
2764       Asm->OutStreamer.AddComment("Location label");
2765       Asm->OutStreamer.EmitSymbolValue(Label, TD->getPointerSize(),
2766                                        0/*AddrSpace*/);
2767
2768       // If change of source, then switch to the new source.
2769       if (Source != LineInfo.getSourceID()) {
2770         Source = LineInfo.getSourceID();
2771         Asm->OutStreamer.AddComment("DW_LNS_set_file");
2772         Asm->EmitInt8(dwarf::DW_LNS_set_file);
2773         EmitULEB128(Source, "New Source");
2774       }
2775
2776       // If change of line.
2777       if (Line != LineInfo.getLine()) {
2778         // Determine offset.
2779         int Offset = LineInfo.getLine() - Line;
2780         int Delta = Offset - MinLineDelta;
2781
2782         // Update line.
2783         Line = LineInfo.getLine();
2784
2785         // If delta is small enough and in range...
2786         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2787           // ... then use fast opcode.
2788           Asm->OutStreamer.AddComment("Line Delta");
2789           Asm->EmitInt8(Delta - MinLineDelta);
2790         } else {
2791           // ... otherwise use long hand.
2792           Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2793           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2794           EmitSLEB128(Offset, "Line Offset");
2795           Asm->OutStreamer.AddComment("DW_LNS_copy");
2796           Asm->EmitInt8(dwarf::DW_LNS_copy);
2797         }
2798       } else {
2799         // Copy the previous row (different address or source)
2800         Asm->OutStreamer.AddComment("DW_LNS_copy");
2801         Asm->EmitInt8(dwarf::DW_LNS_copy);
2802       }
2803     }
2804
2805     emitEndOfLineMatrix(j + 1);
2806   }
2807
2808   if (SecSrcLinesSize == 0)
2809     // Because we're emitting a debug_line section, we still need a line
2810     // table. The linker and friends expect it to exist. If there's nothing to
2811     // put into it, emit an empty table.
2812     emitEndOfLineMatrix(1);
2813
2814   Asm->OutStreamer.EmitLabel(getTempLabel("line_end"));
2815 }
2816
2817 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2818 ///
2819 void DwarfDebug::emitCommonDebugFrame() {
2820   if (!MAI->doesDwarfRequireFrameSection())
2821     return;
2822
2823   int stackGrowth =
2824     Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2825       TargetFrameInfo::StackGrowsUp ?
2826     TD->getPointerSize() : -TD->getPointerSize();
2827
2828   // Start the dwarf frame section.
2829   Asm->OutStreamer.SwitchSection(
2830                               Asm->getObjFileLowering().getDwarfFrameSection());
2831
2832   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common"));
2833   Asm->OutStreamer.AddComment("Length of Common Information Entry");
2834   EmitDifference(getTempLabel("debug_frame_common_end"),
2835                  getTempLabel("debug_frame_common_begin"), true);
2836
2837   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin"));
2838   Asm->OutStreamer.AddComment("CIE Identifier Tag");
2839   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2840   Asm->OutStreamer.AddComment("CIE Version");
2841   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2842   Asm->OutStreamer.AddComment("CIE Augmentation");
2843   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2844   EmitULEB128(1, "CIE Code Alignment Factor");
2845   EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2846   Asm->OutStreamer.AddComment("CIE RA Column");
2847   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2848
2849   std::vector<MachineMove> Moves;
2850   RI->getInitialFrameState(Moves);
2851
2852   EmitFrameMoves(0, Moves, false);
2853
2854   Asm->EmitAlignment(2, 0, 0, false);
2855   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end"));
2856 }
2857
2858 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2859 /// section.
2860 void DwarfDebug::
2861 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2862   if (!MAI->doesDwarfRequireFrameSection())
2863     return;
2864
2865   // Start the dwarf frame section.
2866   Asm->OutStreamer.SwitchSection(
2867                               Asm->getObjFileLowering().getDwarfFrameSection());
2868
2869   Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2870   MCSymbol *DebugFrameBegin =
2871     getDWLabel("debug_frame_begin", DebugFrameInfo.Number);
2872   MCSymbol *DebugFrameEnd =
2873     getDWLabel("debug_frame_end", DebugFrameInfo.Number);
2874   EmitDifference(DebugFrameEnd, DebugFrameBegin, true);
2875
2876   Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2877
2878   Asm->OutStreamer.AddComment("FDE CIE offset");
2879   EmitSectionOffset(getTempLabel("debug_frame_common"),
2880                     getTempLabel("section_debug_frame"), true);
2881
2882   Asm->OutStreamer.AddComment("FDE initial location");
2883   MCSymbol *FuncBeginSym = getDWLabel("func_begin", DebugFrameInfo.Number);
2884   Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2885                                    TD->getPointerSize(), 0/*AddrSpace*/);
2886
2887
2888   Asm->OutStreamer.AddComment("FDE address range");
2889   EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number), FuncBeginSym);
2890
2891   EmitFrameMoves(FuncBeginSym, DebugFrameInfo.Moves, false);
2892
2893   Asm->EmitAlignment(2, 0, 0, false);
2894   Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2895 }
2896
2897 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2898 ///
2899 void DwarfDebug::emitDebugPubNames() {
2900   // Start the dwarf pubnames section.
2901   Asm->OutStreamer.SwitchSection(
2902                           Asm->getObjFileLowering().getDwarfPubNamesSection());
2903
2904   Asm->OutStreamer.AddComment("Length of Public Names Info");
2905   EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()),
2906                  getDWLabel("pubnames_begin", ModuleCU->getID()), true);
2907
2908   Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID()));
2909
2910   Asm->OutStreamer.AddComment("DWARF Version");
2911   Asm->EmitInt16(dwarf::DWARF_VERSION);
2912
2913   Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2914   EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2915                     getTempLabel("section_info"), true);
2916
2917   Asm->OutStreamer.AddComment("Compilation Unit Length");
2918   EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2919                  getDWLabel("info_begin", ModuleCU->getID()),
2920                  true);
2921
2922   const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2923   for (StringMap<DIE*>::const_iterator
2924          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2925     const char *Name = GI->getKeyData();
2926     DIE *Entity = GI->second;
2927
2928     Asm->OutStreamer.AddComment("DIE offset");
2929     Asm->EmitInt32(Entity->getOffset());
2930
2931     if (Asm->VerboseAsm)
2932       Asm->OutStreamer.AddComment("External Name");
2933     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2934   }
2935
2936   Asm->OutStreamer.AddComment("End Mark");
2937   Asm->EmitInt32(0);
2938   Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID()));
2939 }
2940
2941 void DwarfDebug::emitDebugPubTypes() {
2942   // Start the dwarf pubnames section.
2943   Asm->OutStreamer.SwitchSection(
2944                           Asm->getObjFileLowering().getDwarfPubTypesSection());
2945   Asm->OutStreamer.AddComment("Length of Public Types Info");
2946   EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()),
2947                  getDWLabel("pubtypes_begin", ModuleCU->getID()), true);
2948
2949   Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID()));
2950
2951   if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2952   Asm->EmitInt16(dwarf::DWARF_VERSION);
2953
2954   Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2955   EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2956                     getTempLabel("section_info"), true);
2957
2958   Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2959   EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2960                  getDWLabel("info_begin", ModuleCU->getID()),
2961                  true);
2962
2963   const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2964   for (StringMap<DIE*>::const_iterator
2965          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2966     const char *Name = GI->getKeyData();
2967     DIE * Entity = GI->second;
2968
2969     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2970     Asm->EmitInt32(Entity->getOffset());
2971
2972     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2973     Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2974   }
2975
2976   Asm->OutStreamer.AddComment("End Mark");
2977   Asm->EmitInt32(0);
2978   Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID()));
2979 }
2980
2981 /// emitDebugStr - Emit visible names into a debug str section.
2982 ///
2983 void DwarfDebug::emitDebugStr() {
2984   // Check to see if it is worth the effort.
2985   if (StringPool.empty()) return;
2986
2987   // Start the dwarf str section.
2988   Asm->OutStreamer.SwitchSection(
2989                                 Asm->getObjFileLowering().getDwarfStrSection());
2990
2991   // Get all of the string pool entries and put them in an array by their ID so
2992   // we can sort them.
2993   SmallVector<std::pair<unsigned,
2994       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2995
2996   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2997        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2998     Entries.push_back(std::make_pair(I->second.second, &*I));
2999
3000   array_pod_sort(Entries.begin(), Entries.end());
3001
3002   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3003     // Emit a label for reference from debug information entries.
3004     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3005
3006     // Emit the string itself.
3007     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3008   }
3009 }
3010
3011 /// emitDebugLoc - Emit visible names into a debug loc section.
3012 ///
3013 void DwarfDebug::emitDebugLoc() {
3014   // Start the dwarf loc section.
3015   Asm->OutStreamer.SwitchSection(
3016                               Asm->getObjFileLowering().getDwarfLocSection());
3017 }
3018
3019 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3020 ///
3021 void DwarfDebug::EmitDebugARanges() {
3022   // Start the dwarf aranges section.
3023   Asm->OutStreamer.SwitchSection(
3024                           Asm->getObjFileLowering().getDwarfARangesSection());
3025 }
3026
3027 /// emitDebugRanges - Emit visible names into a debug ranges section.
3028 ///
3029 void DwarfDebug::emitDebugRanges() {
3030   // Start the dwarf ranges section.
3031   Asm->OutStreamer.SwitchSection(
3032                             Asm->getObjFileLowering().getDwarfRangesSection());
3033 }
3034
3035 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3036 ///
3037 void DwarfDebug::emitDebugMacInfo() {
3038   if (const MCSection *LineInfo =
3039       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3040     // Start the dwarf macinfo section.
3041     Asm->OutStreamer.SwitchSection(LineInfo);
3042   }
3043 }
3044
3045 /// emitDebugInlineInfo - Emit inline info using following format.
3046 /// Section Header:
3047 /// 1. length of section
3048 /// 2. Dwarf version number
3049 /// 3. address size.
3050 ///
3051 /// Entries (one "entry" for each function that was inlined):
3052 ///
3053 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3054 ///   otherwise offset into __debug_str for regular function name.
3055 /// 2. offset into __debug_str section for regular function name.
3056 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3057 /// instances for the function.
3058 ///
3059 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3060 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3061 /// __debug_info section, and the low_pc is the starting address for the
3062 /// inlining instance.
3063 void DwarfDebug::emitDebugInlineInfo() {
3064   if (!MAI->doesDwarfUsesInlineInfoSection())
3065     return;
3066
3067   if (!ModuleCU)
3068     return;
3069
3070   Asm->OutStreamer.SwitchSection(
3071                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
3072
3073   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3074   EmitDifference(getDWLabel("debug_inlined_end", 1),
3075                  getDWLabel("debug_inlined_begin", 1), true);
3076
3077   Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1));
3078
3079   Asm->OutStreamer.AddComment("Dwarf Version");
3080   Asm->EmitInt16(dwarf::DWARF_VERSION);
3081   Asm->OutStreamer.AddComment("Address Size (in bytes)");
3082   Asm->EmitInt8(TD->getPointerSize());
3083
3084   for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3085          E = InlinedSPNodes.end(); I != E; ++I) {
3086
3087     MDNode *Node = *I;
3088     DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3089       = InlineInfo.find(Node);
3090     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3091     DISubprogram SP(Node);
3092     StringRef LName = SP.getLinkageName();
3093     StringRef Name = SP.getName();
3094
3095     Asm->OutStreamer.AddComment("MIPS linkage name");
3096     if (LName.empty()) {
3097       Asm->OutStreamer.EmitBytes(Name, 0);
3098       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3099     } else
3100       EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3101                         getTempLabel("section_str"), true);
3102
3103     Asm->OutStreamer.AddComment("Function name");
3104     EmitSectionOffset(getStringPoolEntry(Name), getTempLabel("section_str"),
3105                       true);
3106     EmitULEB128(Labels.size(), "Inline count");
3107
3108     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3109            LE = Labels.end(); LI != LE; ++LI) {
3110       if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
3111       Asm->EmitInt32(LI->second->getOffset());
3112
3113       if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("low_pc");
3114       Asm->OutStreamer.EmitSymbolValue(LI->first, TD->getPointerSize(), 0);
3115     }
3116   }
3117
3118   Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1));
3119 }