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