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