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