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 #define DEBUG_TYPE "dwarfdebug"
  14 #include "DwarfDebug.h"
  15 #include "llvm/Module.h"
  16 #include "llvm/CodeGen/MachineFunction.h"
  17 #include "llvm/CodeGen/MachineModuleInfo.h"
  18 #include "llvm/MC/MCExpr.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   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1409            getDWLabel("label", StartID));
1410   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1411            getDWLabel("label", EndID));
1412
1413   InlinedSubprogramDIEs.insert(OriginDIE);
1414
1415   // Track the start label for this inlined function.
1416   DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1417     I = InlineInfo.find(InlinedSP.getNode());
1418
1419   if (I == InlineInfo.end()) {
1420     InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1421                                                              ScopeDIE));
1422     InlinedSPNodes.push_back(InlinedSP.getNode());
1423   } else
1424     I->second.push_back(std::make_pair(StartID, ScopeDIE));
1425
1426   StringPool.insert(InlinedSP.getName());
1427   StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1428
1429   DILocation DL(Scope->getInlinedAt());
1430   addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1431   addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1432
1433   return ScopeDIE;
1434 }
1435
1436
1437 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1438 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1439   // Get the descriptor.
1440   const DIVariable &VD = DV->getVariable();
1441   StringRef Name = VD.getName();
1442   if (Name.empty())
1443     return NULL;
1444
1445   // Translate tag to proper Dwarf tag.  The result variable is dropped for
1446   // now.
1447   unsigned Tag;
1448   switch (VD.getTag()) {
1449   case dwarf::DW_TAG_return_variable:
1450     return NULL;
1451   case dwarf::DW_TAG_arg_variable:
1452     Tag = dwarf::DW_TAG_formal_parameter;
1453     break;
1454   case dwarf::DW_TAG_auto_variable:    // fall thru
1455   default:
1456     Tag = dwarf::DW_TAG_variable;
1457     break;
1458   }
1459
1460   // Define variable debug information entry.
1461   DIE *VariableDie = new DIE(Tag);
1462
1463
1464   DIE *AbsDIE = NULL;
1465   if (DbgVariable *AV = DV->getAbstractVariable())
1466     AbsDIE = AV->getDIE();
1467
1468   if (AbsDIE) {
1469     DIScope DS(Scope->getScopeNode());
1470     DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1471     DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1472     (void) OriginSPDIE;
1473     assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1474     DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1475     assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1476     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1477                 dwarf::DW_FORM_ref4, AbsDIE);
1478   }
1479   else {
1480     addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1481     addSourceLine(VariableDie, &VD);
1482
1483     // Add variable type.
1484     // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1485     // addresses instead.
1486     if (VD.isBlockByrefVariable())
1487       addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1488     else
1489       addType(VariableDie, VD.getType());
1490   }
1491
1492   // Add variable address.
1493   if (!Scope->isAbstractScope()) {
1494     MachineLocation Location;
1495     unsigned FrameReg;
1496     int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1497     Location.set(FrameReg, Offset);
1498
1499     if (VD.hasComplexAddress())
1500       addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1501     else if (VD.isBlockByrefVariable())
1502       addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1503     else
1504       addAddress(VariableDie, dwarf::DW_AT_location, Location);
1505   }
1506
1507   if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1508     addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1509   DV->setDIE(VariableDie);
1510   return VariableDie;
1511
1512 }
1513
1514 void DwarfDebug::addPubTypes(DISubprogram SP) {
1515   DICompositeType SPTy = SP.getType();
1516   unsigned SPTag = SPTy.getTag();
1517   if (SPTag != dwarf::DW_TAG_subroutine_type)
1518     return;
1519
1520   DIArray Args = SPTy.getTypeArray();
1521   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1522     DIType ATy(Args.getElement(i).getNode());
1523     if (!ATy.isValid())
1524       continue;
1525     DICompositeType CATy = getDICompositeType(ATy);
1526     if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1527       if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1528         ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1529     }
1530   }
1531 }
1532
1533 /// constructScopeDIE - Construct a DIE for this scope.
1534 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1535   if (!Scope || !Scope->getScopeNode())
1536     return NULL;
1537
1538   DIScope DS(Scope->getScopeNode());
1539   DIE *ScopeDIE = NULL;
1540   if (Scope->getInlinedAt())
1541     ScopeDIE = constructInlinedScopeDIE(Scope);
1542   else if (DS.isSubprogram()) {
1543     if (Scope->isAbstractScope())
1544       ScopeDIE = ModuleCU->getDIE(DS.getNode());
1545     else
1546       ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1547   }
1548   else {
1549     ScopeDIE = constructLexicalScopeDIE(Scope);
1550     if (!ScopeDIE) return NULL;
1551   }
1552
1553   // Add variables to scope.
1554   SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1555   for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1556     DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1557     if (VariableDIE)
1558       ScopeDIE->addChild(VariableDIE);
1559   }
1560
1561   // Add nested scopes.
1562   SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1563   for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1564     // Define the Scope debug information entry.
1565     DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1566     if (NestedDIE)
1567       ScopeDIE->addChild(NestedDIE);
1568   }
1569
1570   if (DS.isSubprogram())
1571     addPubTypes(DISubprogram(DS.getNode()));
1572
1573  return ScopeDIE;
1574 }
1575
1576 /// GetOrCreateSourceID - Look up the source id with the given directory and
1577 /// source file names. If none currently exists, create a new id and insert it
1578 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1579 /// maps as well.
1580 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1581   unsigned DId;
1582   StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1583   if (DI != DirectoryIdMap.end()) {
1584     DId = DI->getValue();
1585   } else {
1586     DId = DirectoryNames.size() + 1;
1587     DirectoryIdMap[DirName] = DId;
1588     DirectoryNames.push_back(DirName);
1589   }
1590
1591   unsigned FId;
1592   StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1593   if (FI != SourceFileIdMap.end()) {
1594     FId = FI->getValue();
1595   } else {
1596     FId = SourceFileNames.size() + 1;
1597     SourceFileIdMap[FileName] = FId;
1598     SourceFileNames.push_back(FileName);
1599   }
1600
1601   DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1602     SourceIdMap.find(std::make_pair(DId, FId));
1603   if (SI != SourceIdMap.end())
1604     return SI->second;
1605
1606   unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
1607   SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1608   SourceIds.push_back(std::make_pair(DId, FId));
1609
1610   return SrcId;
1611 }
1612
1613 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1614 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1615   DIE *NDie = ModuleCU->getDIE(NS.getNode());
1616   if (NDie)
1617     return NDie;
1618   NDie = new DIE(dwarf::DW_TAG_namespace);
1619   ModuleCU->insertDIE(NS.getNode(), NDie);
1620   if (!NS.getName().empty())
1621     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1622   addSourceLine(NDie, &NS);
1623   addToContextOwner(NDie, NS.getContext());
1624   return NDie;
1625 }
1626
1627 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1628   DICompileUnit DIUnit(N);
1629   StringRef FN = DIUnit.getFilename();
1630   StringRef Dir = DIUnit.getDirectory();
1631   unsigned ID = GetOrCreateSourceID(Dir, FN);
1632
1633   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1634   // FIXME: Why getting the delta between two identical labels??
1635   addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1636                    getTempLabel("section_line"), getTempLabel("section_line"),
1637                    false);
1638   addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1639             DIUnit.getProducer());
1640   addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1641           DIUnit.getLanguage());
1642   addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1643
1644   if (!Dir.empty())
1645     addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1646   if (DIUnit.isOptimized())
1647     addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1648
1649   StringRef Flags = DIUnit.getFlags();
1650   if (!Flags.empty())
1651     addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1652
1653   unsigned RVer = DIUnit.getRunTimeVersion();
1654   if (RVer)
1655     addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1656             dwarf::DW_FORM_data1, RVer);
1657
1658   CompileUnit *Unit = new CompileUnit(ID, Die);
1659   if (!ModuleCU && DIUnit.isMain()) {
1660     // Use first compile unit marked as isMain as the compile unit
1661     // for this module.
1662     ModuleCU = Unit;
1663   }
1664
1665   return Unit;
1666 }
1667
1668 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1669   DIGlobalVariable DI_GV(N);
1670
1671   // If debug information is malformed then ignore it.
1672   if (DI_GV.Verify() == false)
1673     return;
1674
1675   // Check for pre-existence.
1676   if (ModuleCU->getDIE(DI_GV.getNode()))
1677     return;
1678
1679   DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1680   if (!VariableDie)
1681     return;
1682
1683   // Add to map.
1684   ModuleCU->insertDIE(N, VariableDie);
1685
1686   // Add to context owner.
1687   DIDescriptor GVContext = DI_GV.getContext();
1688   // Do not create specification DIE if context is either compile unit
1689   // or a subprogram.
1690   if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1691       && !GVContext.isSubprogram()) {
1692     // Create specification DIE.
1693     DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1694     addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1695                 dwarf::DW_FORM_ref4, VariableDie);
1696     DIEBlock *Block = new DIEBlock();
1697     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1698     addLabel(Block, 0, dwarf::DW_FORM_udata,
1699              Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1700     addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1701     addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1702     ModuleCU->addDie(VariableSpecDIE);
1703   } else {
1704     DIEBlock *Block = new DIEBlock();
1705     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1706     addLabel(Block, 0, dwarf::DW_FORM_udata,
1707              Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1708     addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1709   }
1710   addToContextOwner(VariableDie, GVContext);
1711
1712   // Expose as global. FIXME - need to check external flag.
1713   ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1714
1715   DIType GTy = DI_GV.getType();
1716   if (GTy.isCompositeType() && !GTy.getName().empty()) {
1717     DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1718     assert (Entry && "Missing global type!");
1719     ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1720   }
1721   return;
1722 }
1723
1724 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1725   DISubprogram SP(N);
1726
1727   // Check for pre-existence.
1728   if (ModuleCU->getDIE(N))
1729     return;
1730
1731   if (!SP.isDefinition())
1732     // This is a method declaration which will be handled while constructing
1733     // class type.
1734     return;
1735
1736   DIE *SubprogramDie = createSubprogramDIE(SP);
1737
1738   // Add to map.
1739   ModuleCU->insertDIE(N, SubprogramDie);
1740
1741   // Add to context owner.
1742   addToContextOwner(SubprogramDie, SP.getContext());
1743
1744   // Expose as global.
1745   ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1746
1747   return;
1748 }
1749
1750 /// beginModule - Emit all Dwarf sections that should come prior to the
1751 /// content. Create global DIEs and emit initial debug info sections.
1752 /// This is inovked by the target AsmPrinter.
1753 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1754   this->M = M;
1755
1756   if (TimePassesIsEnabled)
1757     DebugTimer->startTimer();
1758
1759   if (!MAI->doesSupportDebugInformation())
1760     return;
1761
1762   DebugInfoFinder DbgFinder;
1763   DbgFinder.processModule(*M);
1764
1765   // Create all the compile unit DIEs.
1766   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1767          E = DbgFinder.compile_unit_end(); I != E; ++I)
1768     constructCompileUnit(*I);
1769
1770   if (!ModuleCU)
1771     return;
1772
1773   // Create DIEs for each subprogram.
1774   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1775          E = DbgFinder.subprogram_end(); I != E; ++I)
1776     constructSubprogramDIE(*I);
1777
1778   // Create DIEs for each global variable.
1779   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1780          E = DbgFinder.global_variable_end(); I != E; ++I)
1781     constructGlobalVariableDIE(*I);
1782
1783   MMI = mmi;
1784   shouldEmit = true;
1785   MMI->setDebugInfoAvailability(true);
1786
1787   // Prime section data.
1788   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1789
1790   // Print out .file directives to specify files for .loc directives. These are
1791   // printed out early so that they precede any .loc directives.
1792   if (MAI->hasDotLocAndDotFile()) {
1793     for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1794       // Remember source id starts at 1.
1795       std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1796       // FIXME: don't use sys::path for this!  This should not depend on the
1797       // host.
1798       sys::Path FullPath(getSourceDirectoryName(Id.first));
1799       bool AppendOk =
1800         FullPath.appendComponent(getSourceFileName(Id.second));
1801       assert(AppendOk && "Could not append filename to directory!");
1802       AppendOk = false;
1803       Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1804     }
1805   }
1806
1807   // Emit initial sections
1808   emitInitial();
1809
1810   if (TimePassesIsEnabled)
1811     DebugTimer->stopTimer();
1812 }
1813
1814 /// endModule - Emit all Dwarf sections that should come after the content.
1815 ///
1816 void DwarfDebug::endModule() {
1817   if (!ModuleCU)
1818     return;
1819
1820   if (TimePassesIsEnabled)
1821     DebugTimer->startTimer();
1822
1823   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1824   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1825          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1826     DIE *ISP = *AI;
1827     addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1828   }
1829
1830   // Insert top level DIEs.
1831   for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1832          TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1833     ModuleCU->getCUDie()->addChild(*TI);
1834
1835   for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1836          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1837     DIE *SPDie = CI->first;
1838     MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1839     if (!N) continue;
1840     DIE *NDie = ModuleCU->getDIE(N);
1841     if (!NDie) continue;
1842     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1843     // FIXME - This is not the correct approach.
1844     // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1845   }
1846
1847   // Standard sections final addresses.
1848   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1849   Asm->OutStreamer.EmitLabel(getTempLabel("text_end"));
1850   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1851   Asm->OutStreamer.EmitLabel(getTempLabel("data_end"));
1852
1853   // End text sections.
1854   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1855     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1856     Asm->OutStreamer.EmitLabel(getDWLabel("section_end", i));
1857   }
1858
1859   // Emit common frame information.
1860   emitCommonDebugFrame();
1861
1862   // Emit function debug frame information
1863   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1864          E = DebugFrames.end(); I != E; ++I)
1865     emitFunctionDebugFrame(*I);
1866
1867   // Compute DIE offsets and sizes.
1868   computeSizeAndOffsets();
1869
1870   // Emit all the DIEs into a debug info section
1871   emitDebugInfo();
1872
1873   // Corresponding abbreviations into a abbrev section.
1874   emitAbbreviations();
1875
1876   // Emit source line correspondence into a debug line section.
1877   emitDebugLines();
1878
1879   // Emit info into a debug pubnames section.
1880   emitDebugPubNames();
1881
1882   // Emit info into a debug pubtypes section.
1883   emitDebugPubTypes();
1884
1885   // Emit info into a debug str section.
1886   emitDebugStr();
1887
1888   // Emit info into a debug loc section.
1889   emitDebugLoc();
1890
1891   // Emit info into a debug aranges section.
1892   EmitDebugARanges();
1893
1894   // Emit info into a debug ranges section.
1895   emitDebugRanges();
1896
1897   // Emit info into a debug macinfo section.
1898   emitDebugMacInfo();
1899
1900   // Emit inline info.
1901   emitDebugInlineInfo();
1902
1903   if (TimePassesIsEnabled)
1904     DebugTimer->stopTimer();
1905 }
1906
1907 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1908 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1909                                               unsigned FrameIdx,
1910                                               DILocation &ScopeLoc) {
1911
1912   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1913   if (AbsDbgVariable)
1914     return AbsDbgVariable;
1915
1916   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1917   if (!Scope)
1918     return NULL;
1919
1920   AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1921   Scope->addVariable(AbsDbgVariable);
1922   AbstractVariables[Var.getNode()] = AbsDbgVariable;
1923   return AbsDbgVariable;
1924 }
1925
1926 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1927 void DwarfDebug::collectVariableInfo() {
1928   if (!MMI) return;
1929
1930   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1931   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1932          VE = VMap.end(); VI != VE; ++VI) {
1933     MDNode *Var = VI->first;
1934     if (!Var) continue;
1935     DIVariable DV (Var);
1936     std::pair< unsigned, MDNode *> VP = VI->second;
1937     DILocation ScopeLoc(VP.second);
1938
1939     DbgScope *Scope =
1940       ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1941     if (!Scope)
1942       Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1943     // If variable scope is not found then skip this variable.
1944     if (!Scope)
1945       continue;
1946
1947     DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1948     Scope->addVariable(RegVar);
1949     if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1950                                                            ScopeLoc))
1951       RegVar->setAbstractVariable(AbsDbgVariable);
1952   }
1953 }
1954
1955 /// beginScope - Process beginning of a scope starting at Label.
1956 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1957   InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1958   if (I == DbgScopeBeginMap.end())
1959     return;
1960   ScopeVector &SD = I->second;
1961   for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1962        SDI != SDE; ++SDI)
1963     (*SDI)->setStartLabelID(Label);
1964 }
1965
1966 /// endScope - Process end of a scope.
1967 void DwarfDebug::endScope(const MachineInstr *MI) {
1968   InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1969   if (I == DbgScopeEndMap.end())
1970     return;
1971
1972   unsigned Label = MMI->NextLabelID();
1973   Asm->printLabel(Label);
1974   O << '\n';
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     O << '\n';
2134   }
2135   if (TimePassesIsEnabled)
2136     DebugTimer->stopTimer();
2137 }
2138
2139 /// endFunction - Gather and emit post-function debug information.
2140 ///
2141 void DwarfDebug::endFunction(const MachineFunction *MF) {
2142   if (!ShouldEmitDwarfDebug()) return;
2143
2144   if (TimePassesIsEnabled)
2145     DebugTimer->startTimer();
2146
2147   if (DbgScopeMap.empty())
2148     return;
2149
2150   if (CurrentFnDbgScope) {
2151     // Define end label for subprogram.
2152     Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount));
2153
2154     // Get function line info.
2155     if (!Lines.empty()) {
2156       // Get section line info.
2157       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2158       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2159       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2160       // Append the function info to section info.
2161       SectionLineInfos.insert(SectionLineInfos.end(),
2162                               Lines.begin(), Lines.end());
2163     }
2164
2165     // Construct abstract scopes.
2166     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2167            AE = AbstractScopesList.end(); AI != AE; ++AI)
2168       constructScopeDIE(*AI);
2169
2170     constructScopeDIE(CurrentFnDbgScope);
2171
2172     DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2173                                                  MMI->getFrameMoves()));
2174   }
2175
2176   // Clear debug info
2177   CurrentFnDbgScope = NULL;
2178   DbgScopeMap.clear();
2179   DbgScopeBeginMap.clear();
2180   DbgScopeEndMap.clear();
2181   ConcreteScopes.clear();
2182   AbstractScopesList.clear();
2183   Lines.clear();
2184
2185   if (TimePassesIsEnabled)
2186     DebugTimer->stopTimer();
2187 }
2188
2189 /// recordSourceLine - Records location information and associates it with a
2190 /// label. Returns a unique label ID used to generate a label and provide
2191 /// correspondence to the source line list.
2192 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2193                                       MDNode *S) {
2194   if (!MMI)
2195     return 0;
2196
2197   if (TimePassesIsEnabled)
2198     DebugTimer->startTimer();
2199
2200   StringRef Dir;
2201   StringRef Fn;
2202
2203   DIDescriptor Scope(S);
2204   if (Scope.isCompileUnit()) {
2205     DICompileUnit CU(S);
2206     Dir = CU.getDirectory();
2207     Fn = CU.getFilename();
2208   } else if (Scope.isSubprogram()) {
2209     DISubprogram SP(S);
2210     Dir = SP.getDirectory();
2211     Fn = SP.getFilename();
2212   } else if (Scope.isLexicalBlock()) {
2213     DILexicalBlock DB(S);
2214     Dir = DB.getDirectory();
2215     Fn = DB.getFilename();
2216   } else
2217     assert (0 && "Unexpected scope info");
2218
2219   unsigned Src = GetOrCreateSourceID(Dir, Fn);
2220   unsigned ID = MMI->NextLabelID();
2221   Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2222
2223   if (TimePassesIsEnabled)
2224     DebugTimer->stopTimer();
2225
2226   return ID;
2227 }
2228
2229 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2230 /// timed. Look up the source id with the given directory and source file
2231 /// names. If none currently exists, create a new id and insert it in the
2232 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2233 /// well.
2234 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2235                                          const std::string &FileName) {
2236   if (TimePassesIsEnabled)
2237     DebugTimer->startTimer();
2238
2239   unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2240
2241   if (TimePassesIsEnabled)
2242     DebugTimer->stopTimer();
2243
2244   return SrcId;
2245 }
2246
2247 //===----------------------------------------------------------------------===//
2248 // Emit Methods
2249 //===----------------------------------------------------------------------===//
2250
2251 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2252 ///
2253 unsigned
2254 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2255   // Get the children.
2256   const std::vector<DIE *> &Children = Die->getChildren();
2257
2258   // If not last sibling and has children then add sibling offset attribute.
2259   if (!Last && !Children.empty()) Die->addSiblingOffset();
2260
2261   // Record the abbreviation.
2262   assignAbbrevNumber(Die->getAbbrev());
2263
2264   // Get the abbreviation for this DIE.
2265   unsigned AbbrevNumber = Die->getAbbrevNumber();
2266   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2267
2268   // Set DIE offset
2269   Die->setOffset(Offset);
2270
2271   // Start the size with the size of abbreviation code.
2272   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2273
2274   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2275   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2276
2277   // Size the DIE attribute values.
2278   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2279     // Size attribute value.
2280     Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2281
2282   // Size the DIE children if any.
2283   if (!Children.empty()) {
2284     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2285            "Children flag not set");
2286
2287     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2288       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2289
2290     // End of children marker.
2291     Offset += sizeof(int8_t);
2292   }
2293
2294   Die->setSize(Offset - Die->getOffset());
2295   return Offset;
2296 }
2297
2298 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2299 ///
2300 void DwarfDebug::computeSizeAndOffsets() {
2301   // Compute size of compile unit header.
2302   static unsigned Offset =
2303     sizeof(int32_t) + // Length of Compilation Unit Info
2304     sizeof(int16_t) + // DWARF version number
2305     sizeof(int32_t) + // Offset Into Abbrev. Section
2306     sizeof(int8_t);   // Pointer Size (in bytes)
2307
2308   computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2309   CompileUnitOffsets[ModuleCU] = 0;
2310 }
2311
2312 /// emitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2313 /// tools to recognize the object file contains Dwarf information.
2314 void DwarfDebug::emitInitial() {
2315   // Check to see if we already emitted intial headers.
2316   if (didInitial) return;
2317   didInitial = true;
2318
2319   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2320
2321   // Dwarf sections base addresses.
2322   if (MAI->doesDwarfRequireFrameSection()) {
2323     Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2324     Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame"));
2325   }
2326
2327   Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2328   Asm->OutStreamer.EmitLabel(getTempLabel("section_info"));
2329   Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2330   Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev"));
2331   Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2332   Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges"));
2333
2334   if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2335     Asm->OutStreamer.SwitchSection(LineInfoDirective);
2336     Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo"));
2337   }
2338
2339   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2340   Asm->OutStreamer.EmitLabel(getTempLabel("section_line"));
2341   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2342   Asm->OutStreamer.EmitLabel(getTempLabel("section_loc"));
2343   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2344   Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames"));
2345   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2346   Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes"));
2347   Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2348   Asm->OutStreamer.EmitLabel(getTempLabel("section_str"));
2349   Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2350   Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges"));
2351
2352   Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2353   Asm->OutStreamer.EmitLabel(getTempLabel("text_begin"));
2354   Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2355   Asm->OutStreamer.EmitLabel(getTempLabel("data_begin"));
2356 }
2357
2358 /// emitDIE - Recusively Emits a debug information entry.
2359 ///
2360 void DwarfDebug::emitDIE(DIE *Die) {
2361   // Get the abbreviation for this DIE.
2362   unsigned AbbrevNumber = Die->getAbbrevNumber();
2363   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2364
2365   Asm->O << '\n';
2366
2367   // Emit the code (index) for the abbreviation.
2368   if (Asm->VerboseAsm)
2369     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2370                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2371                                 Twine::utohexstr(Die->getSize()) + " " +
2372                                 dwarf::TagString(Abbrev->getTag()));
2373   EmitULEB128(AbbrevNumber);
2374
2375   SmallVector<DIEValue*, 32> &Values = Die->getValues();
2376   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2377
2378   // Emit the DIE attribute values.
2379   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2380     unsigned Attr = AbbrevData[i].getAttribute();
2381     unsigned Form = AbbrevData[i].getForm();
2382     assert(Form && "Too many attributes for DIE (check abbreviation)");
2383
2384     if (Asm->VerboseAsm)
2385       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2386
2387     switch (Attr) {
2388     case dwarf::DW_AT_sibling:
2389       Asm->EmitInt32(Die->getSiblingOffset());
2390       break;
2391     case dwarf::DW_AT_abstract_origin: {
2392       DIEEntry *E = cast<DIEEntry>(Values[i]);
2393       DIE *Origin = E->getEntry();
2394       unsigned Addr = Origin->getOffset();
2395       Asm->EmitInt32(Addr);
2396       break;
2397     }
2398     default:
2399       // Emit an attribute using the defined form.
2400       Values[i]->EmitValue(this, Form);
2401       O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2402       break;
2403     }
2404   }
2405
2406   // Emit the DIE children if any.
2407   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2408     const std::vector<DIE *> &Children = Die->getChildren();
2409
2410     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2411       emitDIE(Children[j]);
2412
2413     Asm->EmitInt8(0); EOL("End Of Children Mark");
2414   }
2415 }
2416
2417 /// emitDebugInfo - Emit the debug info section.
2418 ///
2419 void DwarfDebug::emitDebugInfo() {
2420   // Start debug info section.
2421   Asm->OutStreamer.SwitchSection(
2422                             Asm->getObjFileLowering().getDwarfInfoSection());
2423   DIE *Die = ModuleCU->getCUDie();
2424
2425   // Emit the compile units header.
2426   Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID()));
2427
2428   // Emit size of content not including length itself
2429   unsigned ContentSize = Die->getSize() +
2430     sizeof(int16_t) + // DWARF version number
2431     sizeof(int32_t) + // Offset Into Abbrev. Section
2432     sizeof(int8_t) +  // Pointer Size (in bytes)
2433     sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2434
2435   Asm->EmitInt32(ContentSize);  EOL("Length of Compilation Unit Info");
2436   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2437   EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"),
2438                     true, false);
2439   EOL("Offset Into Abbrev. Section");
2440   Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2441
2442   emitDIE(Die);
2443   // FIXME - extra padding for gdb bug.
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->EmitInt8(0); EOL("Extra Pad For GDB");
2448   Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID()));
2449   Asm->O << '\n';
2450 }
2451
2452 /// emitAbbreviations - Emit the abbreviation section.
2453 ///
2454 void DwarfDebug::emitAbbreviations() const {
2455   // Check to see if it is worth the effort.
2456   if (!Abbreviations.empty()) {
2457     // Start the debug abbrev section.
2458     Asm->OutStreamer.SwitchSection(
2459                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2460
2461     Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin"));
2462
2463     // For each abbrevation.
2464     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2465       // Get abbreviation data
2466       const DIEAbbrev *Abbrev = Abbreviations[i];
2467
2468       // Emit the abbrevations code (base 1 index.)
2469       EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2470
2471       // Emit the abbreviations data.
2472       Abbrev->Emit(this);
2473       Asm->O << '\n';
2474     }
2475
2476     // Mark end of abbreviations.
2477     EmitULEB128(0, "EOM(3)");
2478
2479     Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end"));
2480   }
2481 }
2482
2483 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2484 /// the line matrix.
2485 ///
2486 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2487   // Define last address of section.
2488   Asm->EmitInt8(0); EOL("Extended Op");
2489   Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2490   Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2491   EmitReference(getDWLabel("section_end", SectionEnd));
2492   EOL("Section end label");
2493
2494   // Mark end of matrix.
2495   Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2496   Asm->EmitInt8(1);
2497   Asm->EmitInt8(1);
2498 }
2499
2500 /// emitDebugLines - Emit source line information.
2501 ///
2502 void DwarfDebug::emitDebugLines() {
2503   // If the target is using .loc/.file, the assembler will be emitting the
2504   // .debug_line table automatically.
2505   if (MAI->hasDotLocAndDotFile())
2506     return;
2507
2508   // Minimum line delta, thus ranging from -10..(255-10).
2509   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2510   // Maximum line delta, thus ranging from -10..(255-10).
2511   const int MaxLineDelta = 255 + MinLineDelta;
2512
2513   // Start the dwarf line section.
2514   Asm->OutStreamer.SwitchSection(
2515                             Asm->getObjFileLowering().getDwarfLineSection());
2516
2517   // Construct the section header.
2518   EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true);
2519   EOL("Length of Source Line Info");
2520   Asm->OutStreamer.EmitLabel(getTempLabel("line_begin"));
2521
2522   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2523
2524   EmitDifference(getTempLabel("line_prolog_end"),
2525                  getTempLabel("line_prolog_begin"), true);
2526   EOL("Prolog Length");
2527   Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin"));
2528
2529   Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2530   Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2531   Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2532   Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2533   Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2534
2535   // Line number standard opcode encodings argument count
2536   Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2537   Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2538   Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2539   Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2540   Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2541   Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2542   Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2543   Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2544   Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2545
2546   // Emit directories.
2547   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2548     const std::string &Dir = getSourceDirectoryName(DI);
2549     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2550     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2551   }
2552
2553   Asm->EmitInt8(0); EOL("End of directories");
2554
2555   // Emit files.
2556   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2557     // Remember source id starts at 1.
2558     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2559     const std::string &FN = getSourceFileName(Id.second);
2560     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2561     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2562
2563     EmitULEB128(Id.first, "Directory #");
2564     EmitULEB128(0, "Mod date");
2565     EmitULEB128(0, "File size");
2566   }
2567
2568   Asm->EmitInt8(0); EOL("End of files");
2569
2570   Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end"));
2571
2572   // A sequence for each text section.
2573   unsigned SecSrcLinesSize = SectionSourceLines.size();
2574
2575   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2576     // Isolate current sections line info.
2577     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2578
2579     /*if (Asm->isVerbose()) {
2580       const MCSection *S = SectionMap[j + 1];
2581       O << '\t' << MAI->getCommentString() << " Section"
2582         << S->getName() << '\n';
2583     }*/
2584     Asm->O << '\n';
2585
2586     // Dwarf assumes we start with first line of first source file.
2587     unsigned Source = 1;
2588     unsigned Line = 1;
2589
2590     // Construct rows of the address, source, line, column matrix.
2591     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2592       const SrcLineInfo &LineInfo = LineInfos[i];
2593       unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2594       if (!LabelID) continue;
2595
2596       if (LineInfo.getLine() == 0) continue;
2597
2598       if (!Asm->isVerbose())
2599         Asm->O << '\n';
2600       else {
2601         std::pair<unsigned, unsigned> SourceID =
2602           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2603         O << '\t' << MAI->getCommentString() << ' '
2604           << getSourceDirectoryName(SourceID.first) << '/'
2605           << getSourceFileName(SourceID.second)
2606           << ':' << utostr_32(LineInfo.getLine()) << '\n';
2607       }
2608
2609       // Define the line address.
2610       Asm->EmitInt8(0); EOL("Extended Op");
2611       Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2612       Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2613       EmitReference(getDWLabel("label", LabelID)); EOL("Location label");
2614
2615       // If change of source, then switch to the new source.
2616       if (Source != LineInfo.getSourceID()) {
2617         Source = LineInfo.getSourceID();
2618         Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2619         EmitULEB128(Source, "New Source");
2620       }
2621
2622       // If change of line.
2623       if (Line != LineInfo.getLine()) {
2624         // Determine offset.
2625         int Offset = LineInfo.getLine() - Line;
2626         int Delta = Offset - MinLineDelta;
2627
2628         // Update line.
2629         Line = LineInfo.getLine();
2630
2631         // If delta is small enough and in range...
2632         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2633           // ... then use fast opcode.
2634           Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2635         } else {
2636           // ... otherwise use long hand.
2637           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2638           EOL("DW_LNS_advance_line");
2639           EmitSLEB128(Offset, "Line Offset");
2640           Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2641         }
2642       } else {
2643         // Copy the previous row (different address or source)
2644         Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2645       }
2646     }
2647
2648     emitEndOfLineMatrix(j + 1);
2649   }
2650
2651   if (SecSrcLinesSize == 0)
2652     // Because we're emitting a debug_line section, we still need a line
2653     // table. The linker and friends expect it to exist. If there's nothing to
2654     // put into it, emit an empty table.
2655     emitEndOfLineMatrix(1);
2656
2657   Asm->OutStreamer.EmitLabel(getTempLabel("line_end"));
2658 }
2659
2660 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2661 ///
2662 void DwarfDebug::emitCommonDebugFrame() {
2663   if (!MAI->doesDwarfRequireFrameSection())
2664     return;
2665
2666   int stackGrowth =
2667     Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2668       TargetFrameInfo::StackGrowsUp ?
2669     TD->getPointerSize() : -TD->getPointerSize();
2670
2671   // Start the dwarf frame section.
2672   Asm->OutStreamer.SwitchSection(
2673                               Asm->getObjFileLowering().getDwarfFrameSection());
2674
2675   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common"));
2676   EmitDifference(getTempLabel("debug_frame_common_end"),
2677                  getTempLabel("debug_frame_common_begin"), true);
2678   EOL("Length of Common Information Entry");
2679
2680   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin"));
2681   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2682   EOL("CIE Identifier Tag");
2683   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2684   EOL("CIE Version");
2685   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2686   EOL("CIE Augmentation");
2687   EmitULEB128(1, "CIE Code Alignment Factor");
2688   EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2689   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2690   EOL("CIE RA Column");
2691
2692   std::vector<MachineMove> Moves;
2693   RI->getInitialFrameState(Moves);
2694
2695   EmitFrameMoves(NULL, 0, Moves, false);
2696
2697   Asm->EmitAlignment(2, 0, 0, false);
2698   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end"));
2699 }
2700
2701 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2702 /// section.
2703 void
2704 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2705   if (!MAI->doesDwarfRequireFrameSection())
2706     return;
2707
2708   // Start the dwarf frame section.
2709   Asm->OutStreamer.SwitchSection(
2710                               Asm->getObjFileLowering().getDwarfFrameSection());
2711
2712   EmitDifference(getDWLabel("debug_frame_end", DebugFrameInfo.Number),
2713                  getDWLabel("debug_frame_begin", DebugFrameInfo.Number), true);
2714   EOL("Length of Frame Information Entry");
2715
2716   Asm->OutStreamer.EmitLabel(getDWLabel("debug_frame_begin",
2717                                         DebugFrameInfo.Number));
2718
2719   EmitSectionOffset(getTempLabel("debug_frame_common"),
2720                     getTempLabel("section_debug_frame"), true, false);
2721   EOL("FDE CIE offset");
2722
2723   EmitReference(getDWLabel("func_begin", DebugFrameInfo.Number));
2724   EOL("FDE initial location");
2725   EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number),
2726                  getDWLabel("func_begin", DebugFrameInfo.Number));
2727   EOL("FDE address range");
2728
2729   EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2730                  false);
2731
2732   Asm->EmitAlignment(2, 0, 0, false);
2733   Asm->OutStreamer.EmitLabel(getDWLabel("debug_frame_end",
2734                                         DebugFrameInfo.Number));
2735 }
2736
2737 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2738 ///
2739 void DwarfDebug::emitDebugPubNames() {
2740   // Start the dwarf pubnames section.
2741   Asm->OutStreamer.SwitchSection(
2742                           Asm->getObjFileLowering().getDwarfPubNamesSection());
2743
2744   EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()),
2745                  getDWLabel("pubnames_begin", ModuleCU->getID()), true);
2746   EOL("Length of Public Names Info");
2747
2748   Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID()));
2749
2750   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2751
2752   EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2753                     getTempLabel("section_info"),
2754                     true, false);
2755   EOL("Offset of Compilation Unit Info");
2756
2757   EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2758                  getDWLabel("info_begin", ModuleCU->getID()),
2759                  true);
2760   EOL("Compilation Unit Length");
2761
2762   const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2763   for (StringMap<DIE*>::const_iterator
2764          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2765     const char *Name = GI->getKeyData();
2766     DIE * Entity = GI->second;
2767
2768     Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2769
2770     if (Asm->VerboseAsm)
2771       Asm->OutStreamer.AddComment("External Name");
2772     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2773   }
2774
2775   Asm->EmitInt32(0); EOL("End Mark");
2776   Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID()));
2777 }
2778
2779 void DwarfDebug::emitDebugPubTypes() {
2780   // Start the dwarf pubnames section.
2781   Asm->OutStreamer.SwitchSection(
2782                           Asm->getObjFileLowering().getDwarfPubTypesSection());
2783   EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()),
2784                  getDWLabel("pubtypes_begin", ModuleCU->getID()), true);
2785   EOL("Length of Public Types Info");
2786
2787   Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID()));
2788
2789   if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2790   Asm->EmitInt16(dwarf::DWARF_VERSION);
2791
2792   EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2793                     getTempLabel("section_info"), true, false);
2794   EOL("Offset of Compilation ModuleCU Info");
2795
2796   EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2797                  getDWLabel("info_begin", ModuleCU->getID()),
2798                  true);
2799   EOL("Compilation ModuleCU Length");
2800
2801   const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2802   for (StringMap<DIE*>::const_iterator
2803          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2804     const char *Name = GI->getKeyData();
2805     DIE * Entity = GI->second;
2806
2807     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2808     Asm->EmitInt32(Entity->getOffset());
2809
2810     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2811     Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2812   }
2813
2814   Asm->EmitInt32(0); EOL("End Mark");
2815   Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID()));
2816 }
2817
2818 /// emitDebugStr - Emit visible names into a debug str section.
2819 ///
2820 void DwarfDebug::emitDebugStr() {
2821   // Check to see if it is worth the effort.
2822   if (!StringPool.empty()) {
2823     // Start the dwarf str section.
2824     Asm->OutStreamer.SwitchSection(
2825                                 Asm->getObjFileLowering().getDwarfStrSection());
2826
2827     // For each of strings in the string pool.
2828     for (unsigned StringID = 1, N = StringPool.size();
2829          StringID <= N; ++StringID) {
2830       // Emit a label for reference from debug information entries.
2831       Asm->OutStreamer.EmitLabel(getDWLabel("string", StringID));
2832
2833       // Emit the string itself.
2834       const std::string &String = StringPool[StringID];
2835       Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2836     }
2837
2838     Asm->O << '\n';
2839   }
2840 }
2841
2842 /// emitDebugLoc - Emit visible names into a debug loc section.
2843 ///
2844 void DwarfDebug::emitDebugLoc() {
2845   // Start the dwarf loc section.
2846   Asm->OutStreamer.SwitchSection(
2847                               Asm->getObjFileLowering().getDwarfLocSection());
2848 }
2849
2850 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2851 ///
2852 void DwarfDebug::EmitDebugARanges() {
2853   // Start the dwarf aranges section.
2854   Asm->OutStreamer.SwitchSection(
2855                           Asm->getObjFileLowering().getDwarfARangesSection());
2856
2857   // FIXME - Mock up
2858 #if 0
2859   CompileUnit *Unit = GetBaseCompileUnit();
2860
2861   // Don't include size of length
2862   Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2863
2864   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2865
2866   EmitReference("info_begin", Unit->getID());
2867   EOL("Offset of Compilation Unit Info");
2868
2869   Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2870
2871   Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2872
2873   Asm->EmitInt16(0);  EOL("Pad (1)");
2874   Asm->EmitInt16(0);  EOL("Pad (2)");
2875
2876   // Range 1
2877   EmitReference("text_begin", 0); EOL("Address");
2878   EmitDifference(getTempLabel("text_end"), getTempLabel("text_begin"),
2879                  true); EOL("Length");
2880
2881   Asm->EmitInt32(0); EOL("EOM (1)");
2882   Asm->EmitInt32(0); EOL("EOM (2)");
2883 #endif
2884 }
2885
2886 /// emitDebugRanges - Emit visible names into a debug ranges section.
2887 ///
2888 void DwarfDebug::emitDebugRanges() {
2889   // Start the dwarf ranges section.
2890   Asm->OutStreamer.SwitchSection(
2891                             Asm->getObjFileLowering().getDwarfRangesSection());
2892 }
2893
2894 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2895 ///
2896 void DwarfDebug::emitDebugMacInfo() {
2897   if (const MCSection *LineInfo =
2898       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2899     // Start the dwarf macinfo section.
2900     Asm->OutStreamer.SwitchSection(LineInfo);
2901   }
2902 }
2903
2904 /// emitDebugInlineInfo - Emit inline info using following format.
2905 /// Section Header:
2906 /// 1. length of section
2907 /// 2. Dwarf version number
2908 /// 3. address size.
2909 ///
2910 /// Entries (one "entry" for each function that was inlined):
2911 ///
2912 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2913 ///   otherwise offset into __debug_str for regular function name.
2914 /// 2. offset into __debug_str section for regular function name.
2915 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2916 /// instances for the function.
2917 ///
2918 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2919 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2920 /// __debug_info section, and the low_pc is the starting address for the
2921 /// inlining instance.
2922 void DwarfDebug::emitDebugInlineInfo() {
2923   if (!MAI->doesDwarfUsesInlineInfoSection())
2924     return;
2925
2926   if (!ModuleCU)
2927     return;
2928
2929   Asm->OutStreamer.SwitchSection(
2930                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2931
2932   EmitDifference(getDWLabel("debug_inlined_end", 1),
2933                  getDWLabel("debug_inlined_begin", 1), true);
2934   EOL("Length of Debug Inlined Information Entry");
2935
2936   Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1));
2937
2938   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2939   Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2940
2941   for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2942          E = InlinedSPNodes.end(); I != E; ++I) {
2943
2944     MDNode *Node = *I;
2945     DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2946       = InlineInfo.find(Node);
2947     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2948     DISubprogram SP(Node);
2949     StringRef LName = SP.getLinkageName();
2950     StringRef Name = SP.getName();
2951
2952     if (LName.empty()) {
2953       Asm->OutStreamer.EmitBytes(Name, 0);
2954       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2955     } else
2956       EmitSectionOffset(getDWLabel("string",
2957                                    StringPool.idFor(getRealLinkageName(LName))),
2958                         getTempLabel("section_str"), true);
2959
2960     EOL("MIPS linkage name");
2961     EmitSectionOffset(getDWLabel("string", StringPool.idFor(Name)),
2962                       getTempLabel("section_str"), false, true);
2963     EOL("Function name");
2964     EmitULEB128(Labels.size(), "Inline count");
2965
2966     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2967            LE = Labels.end(); LI != LE; ++LI) {
2968       DIE *SP = LI->second;
2969       Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2970
2971       // FIXME: "Labels" should hold MCSymbol*'s
2972       MCSymbol *L = getDWLabel("label", LI->first);
2973       if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("low_pc");
2974       Asm->OutStreamer.EmitValue(MCSymbolRefExpr::Create(L, Asm->OutContext),
2975                                  TD->getPointerSize(), 0/*AddrSpace*/);
2976     }
2977   }
2978
2979   Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1));
2980 }