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