lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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