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