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->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1783     }
1784   }
1785
1786   // Emit initial sections
1787   emitInitial();
1788
1789   if (TimePassesIsEnabled)
1790     DebugTimer->stopTimer();
1791 }
1792
1793 /// endModule - Emit all Dwarf sections that should come after the content.
1794 ///
1795 void DwarfDebug::endModule() {
1796   if (!ModuleCU)
1797     return;
1798
1799   if (TimePassesIsEnabled)
1800     DebugTimer->startTimer();
1801
1802   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1803   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1804          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1805     DIE *ISP = *AI;
1806     addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1807   }
1808
1809   // Insert top level DIEs.
1810   for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1811          TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1812     ModuleCU->getCUDie()->addChild(*TI);
1813
1814   for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1815          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1816     DIE *SPDie = CI->first;
1817     MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1818     if (!N) continue;
1819     DIE *NDie = ModuleCU->getDIE(N);
1820     if (!NDie) continue;
1821     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1822     // FIXME - This is not the correct approach.
1823     // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1824   }
1825
1826   // Standard sections final addresses.
1827   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1828   EmitLabel("text_end", 0);
1829   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1830   EmitLabel("data_end", 0);
1831
1832   // End text sections.
1833   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1834     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1835     EmitLabel("section_end", i);
1836   }
1837
1838   // Emit common frame information.
1839   emitCommonDebugFrame();
1840
1841   // Emit function debug frame information
1842   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1843          E = DebugFrames.end(); I != E; ++I)
1844     emitFunctionDebugFrame(*I);
1845
1846   // Compute DIE offsets and sizes.
1847   computeSizeAndOffsets();
1848
1849   // Emit all the DIEs into a debug info section
1850   emitDebugInfo();
1851
1852   // Corresponding abbreviations into a abbrev section.
1853   emitAbbreviations();
1854
1855   // Emit source line correspondence into a debug line section.
1856   emitDebugLines();
1857
1858   // Emit info into a debug pubnames section.
1859   emitDebugPubNames();
1860
1861   // Emit info into a debug pubtypes section.
1862   emitDebugPubTypes();
1863
1864   // Emit info into a debug str section.
1865   emitDebugStr();
1866
1867   // Emit info into a debug loc section.
1868   emitDebugLoc();
1869
1870   // Emit info into a debug aranges section.
1871   EmitDebugARanges();
1872
1873   // Emit info into a debug ranges section.
1874   emitDebugRanges();
1875
1876   // Emit info into a debug macinfo section.
1877   emitDebugMacInfo();
1878
1879   // Emit inline info.
1880   emitDebugInlineInfo();
1881
1882   if (TimePassesIsEnabled)
1883     DebugTimer->stopTimer();
1884 }
1885
1886 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1887 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1888                                               unsigned FrameIdx,
1889                                               DILocation &ScopeLoc) {
1890
1891   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1892   if (AbsDbgVariable)
1893     return AbsDbgVariable;
1894
1895   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1896   if (!Scope)
1897     return NULL;
1898
1899   AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1900   Scope->addVariable(AbsDbgVariable);
1901   AbstractVariables[Var.getNode()] = AbsDbgVariable;
1902   return AbsDbgVariable;
1903 }
1904
1905 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1906 void DwarfDebug::collectVariableInfo() {
1907   if (!MMI) return;
1908
1909   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1910   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1911          VE = VMap.end(); VI != VE; ++VI) {
1912     MDNode *Var = VI->first;
1913     if (!Var) continue;
1914     DIVariable DV (Var);
1915     std::pair< unsigned, MDNode *> VP = VI->second;
1916     DILocation ScopeLoc(VP.second);
1917
1918     DbgScope *Scope =
1919       ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1920     if (!Scope)
1921       Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1922     // If variable scope is not found then skip this variable.
1923     if (!Scope)
1924       continue;
1925
1926     DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1927     Scope->addVariable(RegVar);
1928     if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1929                                                            ScopeLoc))
1930       RegVar->setAbstractVariable(AbsDbgVariable);
1931   }
1932 }
1933
1934 /// beginScope - Process beginning of a scope starting at Label.
1935 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1936   InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1937   if (I == DbgScopeBeginMap.end())
1938     return;
1939   ScopeVector &SD = I->second;
1940   for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1941        SDI != SDE; ++SDI)
1942     (*SDI)->setStartLabelID(Label);
1943 }
1944
1945 /// endScope - Process end of a scope.
1946 void DwarfDebug::endScope(const MachineInstr *MI) {
1947   InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1948   if (I == DbgScopeEndMap.end())
1949     return;
1950
1951   unsigned Label = MMI->NextLabelID();
1952   Asm->printLabel(Label);
1953   O << '\n';
1954
1955   SmallVector<DbgScope *, 2> &SD = I->second;
1956   for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1957        SDI != SDE; ++SDI)
1958     (*SDI)->setEndLabelID(Label);
1959   return;
1960 }
1961
1962 /// createDbgScope - Create DbgScope for the scope.
1963 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1964
1965   if (!InlinedAt) {
1966     DbgScope *WScope = DbgScopeMap.lookup(Scope);
1967     if (WScope)
1968       return;
1969     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1970     DbgScopeMap.insert(std::make_pair(Scope, WScope));
1971     if (DIDescriptor(Scope).isLexicalBlock())
1972       createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1973     return;
1974   }
1975
1976   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1977   if (WScope)
1978     return;
1979
1980   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1981   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1982   DILocation DL(InlinedAt);
1983   createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1984 }
1985
1986 /// extractScopeInformation - Scan machine instructions in this function
1987 /// and collect DbgScopes. Return true, if atleast one scope was found.
1988 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1989   // If scope information was extracted using .dbg intrinsics then there is not
1990   // any need to extract these information by scanning each instruction.
1991   if (!DbgScopeMap.empty())
1992     return false;
1993
1994   DenseMap<const MachineInstr *, unsigned> MIIndexMap;
1995   unsigned MIIndex = 0;
1996   // Scan each instruction and create scopes. First build working set of scopes.
1997   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1998        I != E; ++I) {
1999     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2000          II != IE; ++II) {
2001       const MachineInstr *MInsn = II;
2002       MIIndexMap[MInsn] = MIIndex++;
2003       DebugLoc DL = MInsn->getDebugLoc();
2004       if (DL.isUnknown()) continue;
2005       DILocation DLT = MF->getDILocation(DL);
2006       DIScope DLTScope = DLT.getScope();
2007       if (DLTScope.isNull()) continue;
2008       // There is no need to create another DIE for compile unit. For all
2009       // other scopes, create one DbgScope now. This will be translated
2010       // into a scope DIE at the end.
2011       if (DLTScope.isCompileUnit()) continue;
2012       createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2013     }
2014   }
2015
2016
2017   // Build scope hierarchy using working set of scopes.
2018   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2019        I != E; ++I) {
2020     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2021          II != IE; ++II) {
2022       const MachineInstr *MInsn = II;
2023       DebugLoc DL = MInsn->getDebugLoc();
2024       if (DL.isUnknown())  continue;
2025       DILocation DLT = MF->getDILocation(DL);
2026       DIScope DLTScope = DLT.getScope();
2027       if (DLTScope.isNull())  continue;
2028       // There is no need to create another DIE for compile unit. For all
2029       // other scopes, create one DbgScope now. This will be translated
2030       // into a scope DIE at the end.
2031       if (DLTScope.isCompileUnit()) continue;
2032       DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2033                                            DLT.getOrigLocation().getNode());
2034       Scope->setLastInsn(MInsn);
2035     }
2036   }
2037
2038   if (!CurrentFnDbgScope)
2039     return false;
2040
2041   CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2042
2043   // Each scope has first instruction and last instruction to mark beginning
2044   // and end of a scope respectively. Create an inverse map that list scopes
2045   // starts (and ends) with an instruction. One instruction may start (or end)
2046   // multiple scopes. Ignore scopes that are not reachable.
2047   SmallVector<DbgScope *, 4> WorkList;
2048   WorkList.push_back(CurrentFnDbgScope);
2049   while (!WorkList.empty()) {
2050     DbgScope *S = WorkList.back(); WorkList.pop_back();
2051
2052     SmallVector<DbgScope *, 4> &Children = S->getScopes();
2053     if (!Children.empty())
2054       for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2055              SE = Children.end(); SI != SE; ++SI)
2056         WorkList.push_back(*SI);
2057
2058     if (S->isAbstractScope())
2059       continue;
2060     const MachineInstr *MI = S->getFirstInsn();
2061     assert (MI && "DbgScope does not have first instruction!");
2062
2063     InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2064     if (IDI != DbgScopeBeginMap.end())
2065       IDI->second.push_back(S);
2066     else
2067       DbgScopeBeginMap[MI].push_back(S);
2068
2069     MI = S->getLastInsn();
2070     assert (MI && "DbgScope does not have last instruction!");
2071     IDI = DbgScopeEndMap.find(MI);
2072     if (IDI != DbgScopeEndMap.end())
2073       IDI->second.push_back(S);
2074     else
2075       DbgScopeEndMap[MI].push_back(S);
2076   }
2077
2078   return !DbgScopeMap.empty();
2079 }
2080
2081 /// beginFunction - Gather pre-function debug information.  Assumes being
2082 /// emitted immediately after the function entry point.
2083 void DwarfDebug::beginFunction(MachineFunction *MF) {
2084   this->MF = MF;
2085
2086   if (!ShouldEmitDwarfDebug()) return;
2087
2088   if (TimePassesIsEnabled)
2089     DebugTimer->startTimer();
2090
2091   if (!extractScopeInformation(MF))
2092     return;
2093
2094   collectVariableInfo();
2095
2096   // Begin accumulating function debug information.
2097   MMI->BeginFunction(MF);
2098
2099   // Assumes in correct section after the entry point.
2100   EmitLabel("func_begin", ++SubprogramCount);
2101
2102   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2103   // function.
2104   DebugLoc FDL = MF->getDefaultDebugLoc();
2105   if (!FDL.isUnknown()) {
2106     DILocation DLT = MF->getDILocation(FDL);
2107     unsigned LabelID = 0;
2108     DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2109     if (!SP.isNull())
2110       LabelID = recordSourceLine(SP.getLineNumber(), 0,
2111                                  DLT.getScope().getNode());
2112     else
2113       LabelID = recordSourceLine(DLT.getLineNumber(),
2114                                  DLT.getColumnNumber(),
2115                                  DLT.getScope().getNode());
2116     Asm->printLabel(LabelID);
2117     O << '\n';
2118   }
2119   if (TimePassesIsEnabled)
2120     DebugTimer->stopTimer();
2121 }
2122
2123 /// endFunction - Gather and emit post-function debug information.
2124 ///
2125 void DwarfDebug::endFunction(MachineFunction *MF) {
2126   if (!ShouldEmitDwarfDebug()) return;
2127
2128   if (TimePassesIsEnabled)
2129     DebugTimer->startTimer();
2130
2131   if (DbgScopeMap.empty())
2132     return;
2133
2134   if (CurrentFnDbgScope) {
2135     // Define end label for subprogram.
2136     EmitLabel("func_end", SubprogramCount);
2137
2138     // Get function line info.
2139     if (!Lines.empty()) {
2140       // Get section line info.
2141       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2142       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2143       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2144       // Append the function info to section info.
2145       SectionLineInfos.insert(SectionLineInfos.end(),
2146                               Lines.begin(), Lines.end());
2147     }
2148
2149     // Construct abstract scopes.
2150     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2151            AE = AbstractScopesList.end(); AI != AE; ++AI)
2152       constructScopeDIE(*AI);
2153
2154     constructScopeDIE(CurrentFnDbgScope);
2155
2156     DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2157                                                  MMI->getFrameMoves()));
2158   }
2159
2160   // Clear debug info
2161   CurrentFnDbgScope = NULL;
2162   DbgScopeMap.clear();
2163   DbgScopeBeginMap.clear();
2164   DbgScopeEndMap.clear();
2165   ConcreteScopes.clear();
2166   AbstractScopesList.clear();
2167   Lines.clear();
2168
2169   if (TimePassesIsEnabled)
2170     DebugTimer->stopTimer();
2171 }
2172
2173 /// recordSourceLine - Records location information and associates it with a
2174 /// label. Returns a unique label ID used to generate a label and provide
2175 /// correspondence to the source line list.
2176 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2177                                       MDNode *S) {
2178   if (!MMI)
2179     return 0;
2180
2181   if (TimePassesIsEnabled)
2182     DebugTimer->startTimer();
2183
2184   StringRef Dir;
2185   StringRef Fn;
2186
2187   DIDescriptor Scope(S);
2188   if (Scope.isCompileUnit()) {
2189     DICompileUnit CU(S);
2190     Dir = CU.getDirectory();
2191     Fn = CU.getFilename();
2192   } else if (Scope.isSubprogram()) {
2193     DISubprogram SP(S);
2194     Dir = SP.getDirectory();
2195     Fn = SP.getFilename();
2196   } else if (Scope.isLexicalBlock()) {
2197     DILexicalBlock DB(S);
2198     Dir = DB.getDirectory();
2199     Fn = DB.getFilename();
2200   } else
2201     assert (0 && "Unexpected scope info");
2202
2203   unsigned Src = GetOrCreateSourceID(Dir, Fn);
2204   unsigned ID = MMI->NextLabelID();
2205   Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2206
2207   if (TimePassesIsEnabled)
2208     DebugTimer->stopTimer();
2209
2210   return ID;
2211 }
2212
2213 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2214 /// timed. Look up the source id with the given directory and source file
2215 /// names. If none currently exists, create a new id and insert it in the
2216 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2217 /// well.
2218 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2219                                          const std::string &FileName) {
2220   if (TimePassesIsEnabled)
2221     DebugTimer->startTimer();
2222
2223   unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2224
2225   if (TimePassesIsEnabled)
2226     DebugTimer->stopTimer();
2227
2228   return SrcId;
2229 }
2230
2231 //===----------------------------------------------------------------------===//
2232 // Emit Methods
2233 //===----------------------------------------------------------------------===//
2234
2235 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2236 ///
2237 unsigned
2238 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2239   // Get the children.
2240   const std::vector<DIE *> &Children = Die->getChildren();
2241
2242   // If not last sibling and has children then add sibling offset attribute.
2243   if (!Last && !Children.empty()) Die->addSiblingOffset();
2244
2245   // Record the abbreviation.
2246   assignAbbrevNumber(Die->getAbbrev());
2247
2248   // Get the abbreviation for this DIE.
2249   unsigned AbbrevNumber = Die->getAbbrevNumber();
2250   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2251
2252   // Set DIE offset
2253   Die->setOffset(Offset);
2254
2255   // Start the size with the size of abbreviation code.
2256   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2257
2258   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2259   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2260
2261   // Size the DIE attribute values.
2262   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2263     // Size attribute value.
2264     Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2265
2266   // Size the DIE children if any.
2267   if (!Children.empty()) {
2268     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2269            "Children flag not set");
2270
2271     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2272       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2273
2274     // End of children marker.
2275     Offset += sizeof(int8_t);
2276   }
2277
2278   Die->setSize(Offset - Die->getOffset());
2279   return Offset;
2280 }
2281
2282 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2283 ///
2284 void DwarfDebug::computeSizeAndOffsets() {
2285   // Compute size of compile unit header.
2286   static unsigned Offset =
2287     sizeof(int32_t) + // Length of Compilation Unit Info
2288     sizeof(int16_t) + // DWARF version number
2289     sizeof(int32_t) + // Offset Into Abbrev. Section
2290     sizeof(int8_t);   // Pointer Size (in bytes)
2291
2292   computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2293   CompileUnitOffsets[ModuleCU] = 0;
2294 }
2295
2296 /// emitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2297 /// tools to recognize the object file contains Dwarf information.
2298 void DwarfDebug::emitInitial() {
2299   // Check to see if we already emitted intial headers.
2300   if (didInitial) return;
2301   didInitial = true;
2302
2303   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2304
2305   // Dwarf sections base addresses.
2306   if (MAI->doesDwarfRequireFrameSection()) {
2307     Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2308     EmitLabel("section_debug_frame", 0);
2309   }
2310
2311   Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2312   EmitLabel("section_info", 0);
2313   Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2314   EmitLabel("section_abbrev", 0);
2315   Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2316   EmitLabel("section_aranges", 0);
2317
2318   if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2319     Asm->OutStreamer.SwitchSection(LineInfoDirective);
2320     EmitLabel("section_macinfo", 0);
2321   }
2322
2323   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2324   EmitLabel("section_line", 0);
2325   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2326   EmitLabel("section_loc", 0);
2327   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2328   EmitLabel("section_pubnames", 0);
2329   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2330   EmitLabel("section_pubtypes", 0);
2331   Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2332   EmitLabel("section_str", 0);
2333   Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2334   EmitLabel("section_ranges", 0);
2335
2336   Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2337   EmitLabel("text_begin", 0);
2338   Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2339   EmitLabel("data_begin", 0);
2340 }
2341
2342 /// emitDIE - Recusively Emits a debug information entry.
2343 ///
2344 void DwarfDebug::emitDIE(DIE *Die) {
2345   // Get the abbreviation for this DIE.
2346   unsigned AbbrevNumber = Die->getAbbrevNumber();
2347   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2348
2349   Asm->O << '\n';
2350
2351   // Emit the code (index) for the abbreviation.
2352   if (Asm->VerboseAsm)
2353     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2354                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2355                                 Twine::utohexstr(Die->getSize()) + " " +
2356                                 dwarf::TagString(Abbrev->getTag()));
2357   EmitULEB128(AbbrevNumber);
2358
2359   SmallVector<DIEValue*, 32> &Values = Die->getValues();
2360   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2361
2362   // Emit the DIE attribute values.
2363   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2364     unsigned Attr = AbbrevData[i].getAttribute();
2365     unsigned Form = AbbrevData[i].getForm();
2366     assert(Form && "Too many attributes for DIE (check abbreviation)");
2367
2368     if (Asm->VerboseAsm)
2369       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2370
2371     switch (Attr) {
2372     case dwarf::DW_AT_sibling:
2373       Asm->EmitInt32(Die->getSiblingOffset());
2374       break;
2375     case dwarf::DW_AT_abstract_origin: {
2376       DIEEntry *E = cast<DIEEntry>(Values[i]);
2377       DIE *Origin = E->getEntry();
2378       unsigned Addr = Origin->getOffset();
2379       Asm->EmitInt32(Addr);
2380       break;
2381     }
2382     default:
2383       // Emit an attribute using the defined form.
2384       Values[i]->EmitValue(this, Form);
2385       O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2386       break;
2387     }
2388   }
2389
2390   // Emit the DIE children if any.
2391   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2392     const std::vector<DIE *> &Children = Die->getChildren();
2393
2394     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2395       emitDIE(Children[j]);
2396
2397     Asm->EmitInt8(0); EOL("End Of Children Mark");
2398   }
2399 }
2400
2401 /// emitDebugInfo - Emit the debug info section.
2402 ///
2403 void DwarfDebug::emitDebugInfo() {
2404   // Start debug info section.
2405   Asm->OutStreamer.SwitchSection(
2406                             Asm->getObjFileLowering().getDwarfInfoSection());
2407   DIE *Die = ModuleCU->getCUDie();
2408
2409   // Emit the compile units header.
2410   EmitLabel("info_begin", ModuleCU->getID());
2411
2412   // Emit size of content not including length itself
2413   unsigned ContentSize = Die->getSize() +
2414     sizeof(int16_t) + // DWARF version number
2415     sizeof(int32_t) + // Offset Into Abbrev. Section
2416     sizeof(int8_t) +  // Pointer Size (in bytes)
2417     sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2418
2419   Asm->EmitInt32(ContentSize);  EOL("Length of Compilation Unit Info");
2420   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2421   EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2422   EOL("Offset Into Abbrev. Section");
2423   Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2424
2425   emitDIE(Die);
2426   // FIXME - extra padding for gdb bug.
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   Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2431   EmitLabel("info_end", ModuleCU->getID());
2432   Asm->O << '\n';
2433 }
2434
2435 /// emitAbbreviations - Emit the abbreviation section.
2436 ///
2437 void DwarfDebug::emitAbbreviations() const {
2438   // Check to see if it is worth the effort.
2439   if (!Abbreviations.empty()) {
2440     // Start the debug abbrev section.
2441     Asm->OutStreamer.SwitchSection(
2442                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2443
2444     EmitLabel("abbrev_begin", 0);
2445
2446     // For each abbrevation.
2447     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2448       // Get abbreviation data
2449       const DIEAbbrev *Abbrev = Abbreviations[i];
2450
2451       // Emit the abbrevations code (base 1 index.)
2452       EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2453
2454       // Emit the abbreviations data.
2455       Abbrev->Emit(this);
2456       Asm->O << '\n';
2457     }
2458
2459     // Mark end of abbreviations.
2460     EmitULEB128(0, "EOM(3)");
2461
2462     EmitLabel("abbrev_end", 0);
2463     Asm->O << '\n';
2464   }
2465 }
2466
2467 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2468 /// the line matrix.
2469 ///
2470 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2471   // Define last address of section.
2472   Asm->EmitInt8(0); EOL("Extended Op");
2473   Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2474   Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2475   EmitReference("section_end", SectionEnd); EOL("Section end label");
2476
2477   // Mark end of matrix.
2478   Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2479   Asm->EmitInt8(1);
2480   Asm->EmitInt8(1);
2481 }
2482
2483 /// emitDebugLines - Emit source line information.
2484 ///
2485 void DwarfDebug::emitDebugLines() {
2486   // If the target is using .loc/.file, the assembler will be emitting the
2487   // .debug_line table automatically.
2488   if (MAI->hasDotLocAndDotFile())
2489     return;
2490
2491   // Minimum line delta, thus ranging from -10..(255-10).
2492   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2493   // Maximum line delta, thus ranging from -10..(255-10).
2494   const int MaxLineDelta = 255 + MinLineDelta;
2495
2496   // Start the dwarf line section.
2497   Asm->OutStreamer.SwitchSection(
2498                             Asm->getObjFileLowering().getDwarfLineSection());
2499
2500   // Construct the section header.
2501   EmitDifference("line_end", 0, "line_begin", 0, true);
2502   EOL("Length of Source Line Info");
2503   EmitLabel("line_begin", 0);
2504
2505   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2506
2507   EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2508   EOL("Prolog Length");
2509   EmitLabel("line_prolog_begin", 0);
2510
2511   Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2512   Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2513   Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2514   Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2515   Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2516
2517   // Line number standard opcode encodings argument count
2518   Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2519   Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2520   Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2521   Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2522   Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2523   Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2524   Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2525   Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2526   Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2527
2528   // Emit directories.
2529   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2530     const std::string &Dir = getSourceDirectoryName(DI);
2531     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2532     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2533   }
2534
2535   Asm->EmitInt8(0); EOL("End of directories");
2536
2537   // Emit files.
2538   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2539     // Remember source id starts at 1.
2540     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2541     const std::string &FN = getSourceFileName(Id.second);
2542     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2543     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2544
2545     EmitULEB128(Id.first, "Directory #");
2546     EmitULEB128(0, "Mod date");
2547     EmitULEB128(0, "File size");
2548   }
2549
2550   Asm->EmitInt8(0); EOL("End of files");
2551
2552   EmitLabel("line_prolog_end", 0);
2553
2554   // A sequence for each text section.
2555   unsigned SecSrcLinesSize = SectionSourceLines.size();
2556
2557   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2558     // Isolate current sections line info.
2559     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2560
2561     /*if (Asm->isVerbose()) {
2562       const MCSection *S = SectionMap[j + 1];
2563       O << '\t' << MAI->getCommentString() << " Section"
2564         << S->getName() << '\n';
2565     }*/
2566     Asm->O << '\n';
2567
2568     // Dwarf assumes we start with first line of first source file.
2569     unsigned Source = 1;
2570     unsigned Line = 1;
2571
2572     // Construct rows of the address, source, line, column matrix.
2573     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2574       const SrcLineInfo &LineInfo = LineInfos[i];
2575       unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2576       if (!LabelID) continue;
2577
2578       if (LineInfo.getLine() == 0) continue;
2579
2580       if (!Asm->isVerbose())
2581         Asm->O << '\n';
2582       else {
2583         std::pair<unsigned, unsigned> SourceID =
2584           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2585         O << '\t' << MAI->getCommentString() << ' '
2586           << getSourceDirectoryName(SourceID.first) << '/'
2587           << getSourceFileName(SourceID.second)
2588           << ':' << utostr_32(LineInfo.getLine()) << '\n';
2589       }
2590
2591       // Define the line address.
2592       Asm->EmitInt8(0); EOL("Extended Op");
2593       Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2594       Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2595       EmitReference("label",  LabelID); EOL("Location label");
2596
2597       // If change of source, then switch to the new source.
2598       if (Source != LineInfo.getSourceID()) {
2599         Source = LineInfo.getSourceID();
2600         Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2601         EmitULEB128(Source, "New Source");
2602       }
2603
2604       // If change of line.
2605       if (Line != LineInfo.getLine()) {
2606         // Determine offset.
2607         int Offset = LineInfo.getLine() - Line;
2608         int Delta = Offset - MinLineDelta;
2609
2610         // Update line.
2611         Line = LineInfo.getLine();
2612
2613         // If delta is small enough and in range...
2614         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2615           // ... then use fast opcode.
2616           Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2617         } else {
2618           // ... otherwise use long hand.
2619           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2620           EOL("DW_LNS_advance_line");
2621           EmitSLEB128(Offset, "Line Offset");
2622           Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2623         }
2624       } else {
2625         // Copy the previous row (different address or source)
2626         Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2627       }
2628     }
2629
2630     emitEndOfLineMatrix(j + 1);
2631   }
2632
2633   if (SecSrcLinesSize == 0)
2634     // Because we're emitting a debug_line section, we still need a line
2635     // table. The linker and friends expect it to exist. If there's nothing to
2636     // put into it, emit an empty table.
2637     emitEndOfLineMatrix(1);
2638
2639   EmitLabel("line_end", 0);
2640   Asm->O << '\n';
2641 }
2642
2643 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2644 ///
2645 void DwarfDebug::emitCommonDebugFrame() {
2646   if (!MAI->doesDwarfRequireFrameSection())
2647     return;
2648
2649   int stackGrowth =
2650     Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2651       TargetFrameInfo::StackGrowsUp ?
2652     TD->getPointerSize() : -TD->getPointerSize();
2653
2654   // Start the dwarf frame section.
2655   Asm->OutStreamer.SwitchSection(
2656                               Asm->getObjFileLowering().getDwarfFrameSection());
2657
2658   EmitLabel("debug_frame_common", 0);
2659   EmitDifference("debug_frame_common_end", 0,
2660                  "debug_frame_common_begin", 0, true);
2661   EOL("Length of Common Information Entry");
2662
2663   EmitLabel("debug_frame_common_begin", 0);
2664   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2665   EOL("CIE Identifier Tag");
2666   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2667   EOL("CIE Version");
2668   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2669   EOL("CIE Augmentation");
2670   EmitULEB128(1, "CIE Code Alignment Factor");
2671   EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2672   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2673   EOL("CIE RA Column");
2674
2675   std::vector<MachineMove> Moves;
2676   RI->getInitialFrameState(Moves);
2677
2678   EmitFrameMoves(NULL, 0, Moves, false);
2679
2680   Asm->EmitAlignment(2, 0, 0, false);
2681   EmitLabel("debug_frame_common_end", 0);
2682   Asm->O << '\n';
2683 }
2684
2685 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2686 /// section.
2687 void
2688 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2689   if (!MAI->doesDwarfRequireFrameSection())
2690     return;
2691
2692   // Start the dwarf frame section.
2693   Asm->OutStreamer.SwitchSection(
2694                               Asm->getObjFileLowering().getDwarfFrameSection());
2695
2696   EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2697                  "debug_frame_begin", DebugFrameInfo.Number, true);
2698   EOL("Length of Frame Information Entry");
2699
2700   EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2701
2702   EmitSectionOffset("debug_frame_common", "section_debug_frame",
2703                     0, 0, true, false);
2704   EOL("FDE CIE offset");
2705
2706   EmitReference("func_begin", DebugFrameInfo.Number);
2707   EOL("FDE initial location");
2708   EmitDifference("func_end", DebugFrameInfo.Number,
2709                  "func_begin", DebugFrameInfo.Number);
2710   EOL("FDE address range");
2711
2712   EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2713                  false);
2714
2715   Asm->EmitAlignment(2, 0, 0, false);
2716   EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2717   Asm->O << '\n';
2718 }
2719
2720 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2721 ///
2722 void DwarfDebug::emitDebugPubNames() {
2723   // Start the dwarf pubnames section.
2724   Asm->OutStreamer.SwitchSection(
2725                           Asm->getObjFileLowering().getDwarfPubNamesSection());
2726
2727   EmitDifference("pubnames_end", ModuleCU->getID(),
2728                  "pubnames_begin", ModuleCU->getID(), true);
2729   EOL("Length of Public Names Info");
2730
2731   EmitLabel("pubnames_begin", ModuleCU->getID());
2732
2733   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2734
2735   EmitSectionOffset("info_begin", "section_info",
2736                     ModuleCU->getID(), 0, true, false);
2737   EOL("Offset of Compilation Unit Info");
2738
2739   EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2740                  true);
2741   EOL("Compilation Unit Length");
2742
2743   const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2744   for (StringMap<DIE*>::const_iterator
2745          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2746     const char *Name = GI->getKeyData();
2747     DIE * Entity = GI->second;
2748
2749     Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2750
2751     if (Asm->VerboseAsm)
2752       Asm->OutStreamer.AddComment("External Name");
2753     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2754   }
2755
2756   Asm->EmitInt32(0); EOL("End Mark");
2757   EmitLabel("pubnames_end", ModuleCU->getID());
2758   Asm->O << '\n';
2759 }
2760
2761 void DwarfDebug::emitDebugPubTypes() {
2762   // Start the dwarf pubnames section.
2763   Asm->OutStreamer.SwitchSection(
2764                           Asm->getObjFileLowering().getDwarfPubTypesSection());
2765   EmitDifference("pubtypes_end", ModuleCU->getID(),
2766                  "pubtypes_begin", ModuleCU->getID(), true);
2767   EOL("Length of Public Types Info");
2768
2769   EmitLabel("pubtypes_begin", ModuleCU->getID());
2770
2771   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2772
2773   EmitSectionOffset("info_begin", "section_info",
2774                     ModuleCU->getID(), 0, true, false);
2775   EOL("Offset of Compilation ModuleCU Info");
2776
2777   EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2778                  true);
2779   EOL("Compilation ModuleCU Length");
2780
2781   const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2782   for (StringMap<DIE*>::const_iterator
2783          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2784     const char *Name = GI->getKeyData();
2785     DIE * Entity = GI->second;
2786
2787     Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2788
2789     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2790     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)), 0);
2791   }
2792
2793   Asm->EmitInt32(0); EOL("End Mark");
2794   EmitLabel("pubtypes_end", ModuleCU->getID());
2795   Asm->O << '\n';
2796 }
2797
2798 /// emitDebugStr - Emit visible names into a debug str section.
2799 ///
2800 void DwarfDebug::emitDebugStr() {
2801   // Check to see if it is worth the effort.
2802   if (!StringPool.empty()) {
2803     // Start the dwarf str section.
2804     Asm->OutStreamer.SwitchSection(
2805                                 Asm->getObjFileLowering().getDwarfStrSection());
2806
2807     // For each of strings in the string pool.
2808     for (unsigned StringID = 1, N = StringPool.size();
2809          StringID <= N; ++StringID) {
2810       // Emit a label for reference from debug information entries.
2811       EmitLabel("string", StringID);
2812
2813       // Emit the string itself.
2814       const std::string &String = StringPool[StringID];
2815       Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2816     }
2817
2818     Asm->O << '\n';
2819   }
2820 }
2821
2822 /// emitDebugLoc - Emit visible names into a debug loc section.
2823 ///
2824 void DwarfDebug::emitDebugLoc() {
2825   // Start the dwarf loc section.
2826   Asm->OutStreamer.SwitchSection(
2827                               Asm->getObjFileLowering().getDwarfLocSection());
2828 }
2829
2830 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2831 ///
2832 void DwarfDebug::EmitDebugARanges() {
2833   // Start the dwarf aranges section.
2834   Asm->OutStreamer.SwitchSection(
2835                           Asm->getObjFileLowering().getDwarfARangesSection());
2836
2837   // FIXME - Mock up
2838 #if 0
2839   CompileUnit *Unit = GetBaseCompileUnit();
2840
2841   // Don't include size of length
2842   Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2843
2844   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2845
2846   EmitReference("info_begin", Unit->getID());
2847   EOL("Offset of Compilation Unit Info");
2848
2849   Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2850
2851   Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2852
2853   Asm->EmitInt16(0);  EOL("Pad (1)");
2854   Asm->EmitInt16(0);  EOL("Pad (2)");
2855
2856   // Range 1
2857   EmitReference("text_begin", 0); EOL("Address");
2858   EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2859
2860   Asm->EmitInt32(0); EOL("EOM (1)");
2861   Asm->EmitInt32(0); EOL("EOM (2)");
2862 #endif
2863 }
2864
2865 /// emitDebugRanges - Emit visible names into a debug ranges section.
2866 ///
2867 void DwarfDebug::emitDebugRanges() {
2868   // Start the dwarf ranges section.
2869   Asm->OutStreamer.SwitchSection(
2870                             Asm->getObjFileLowering().getDwarfRangesSection());
2871 }
2872
2873 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2874 ///
2875 void DwarfDebug::emitDebugMacInfo() {
2876   if (const MCSection *LineInfo =
2877       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2878     // Start the dwarf macinfo section.
2879     Asm->OutStreamer.SwitchSection(LineInfo);
2880   }
2881 }
2882
2883 /// emitDebugInlineInfo - Emit inline info using following format.
2884 /// Section Header:
2885 /// 1. length of section
2886 /// 2. Dwarf version number
2887 /// 3. address size.
2888 ///
2889 /// Entries (one "entry" for each function that was inlined):
2890 ///
2891 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2892 ///   otherwise offset into __debug_str for regular function name.
2893 /// 2. offset into __debug_str section for regular function name.
2894 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2895 /// instances for the function.
2896 ///
2897 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2898 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2899 /// __debug_info section, and the low_pc is the starting address for the
2900 /// inlining instance.
2901 void DwarfDebug::emitDebugInlineInfo() {
2902   if (!MAI->doesDwarfUsesInlineInfoSection())
2903     return;
2904
2905   if (!ModuleCU)
2906     return;
2907
2908   Asm->OutStreamer.SwitchSection(
2909                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2910
2911   EmitDifference("debug_inlined_end", 1,
2912                  "debug_inlined_begin", 1, true);
2913   EOL("Length of Debug Inlined Information Entry");
2914
2915   EmitLabel("debug_inlined_begin", 1);
2916
2917   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2918   Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2919
2920   for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2921          E = InlinedSPNodes.end(); I != E; ++I) {
2922
2923     MDNode *Node = *I;
2924     DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2925       = InlineInfo.find(Node);
2926     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2927     DISubprogram SP(Node);
2928     StringRef LName = SP.getLinkageName();
2929     StringRef Name = SP.getName();
2930
2931     if (LName.empty()) {
2932       Asm->OutStreamer.EmitBytes(Name, 0);
2933       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2934     } else
2935       EmitSectionOffset("string", "section_str",
2936                       StringPool.idFor(getRealLinkageName(LName)), false, true);
2937
2938     EOL("MIPS linkage name");
2939     EmitSectionOffset("string", "section_str",
2940                       StringPool.idFor(Name), false, true);
2941     EOL("Function name");
2942     EmitULEB128(Labels.size(), "Inline count");
2943
2944     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2945            LE = Labels.end(); LI != LE; ++LI) {
2946       DIE *SP = LI->second;
2947       Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2948
2949       if (TD->getPointerSize() == sizeof(int32_t))
2950         O << MAI->getData32bitsDirective();
2951       else
2952         O << MAI->getData64bitsDirective();
2953
2954       PrintLabelName("label", LI->first); EOL("low_pc");
2955     }
2956   }
2957
2958   EmitLabel("debug_inlined_end", 1);
2959   Asm->O << '\n';
2960 }