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 = getDWLabel("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           getDWLabel("func_begin", SubprogramCount));
1355  addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1356           getDWLabel("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 : getDWLabel("func_begin", SubprogramCount));
1382   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1383            End ? End : getDWLabel("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            getTempLabel("text_begin"));
1673   addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1674            getTempLabel("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(getTempLabel("text_end"));
1876   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1877   Asm->OutStreamer.EmitLabel(getTempLabel("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(getDWLabel("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(getDWLabel("func_begin", ++SubprogramCount));
2259
2260   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2261   // function.
2262   DebugLoc FDL = MF->getDefaultDebugLoc();
2263   if (FDL.isUnknown()) return;
2264
2265   MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2266
2267   DISubprogram SP = getDISubprogram(Scope);
2268   unsigned Line, Col;
2269   if (SP.Verify()) {
2270     Line = SP.getLineNumber();
2271     Col = 0;
2272   } else {
2273     Line = FDL.getLine();
2274     Col = FDL.getCol();
2275   }
2276
2277   recordSourceLine(Line, Col, Scope);
2278 }
2279
2280 /// endFunction - Gather and emit post-function debug information.
2281 ///
2282 void DwarfDebug::endFunction(const MachineFunction *MF) {
2283   if (!ShouldEmitDwarfDebug()) return;
2284   if (DbgScopeMap.empty()) return;
2285
2286   TimeRegion Timer(DebugTimer);
2287
2288   if (CurrentFnDbgScope) {
2289     // Define end label for subprogram.
2290     Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount));
2291
2292     // Get function line info.
2293     if (!Lines.empty()) {
2294       // Get section line info.
2295       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2296       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2297       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2298       // Append the function info to section info.
2299       SectionLineInfos.insert(SectionLineInfos.end(),
2300                               Lines.begin(), Lines.end());
2301     }
2302
2303     // Construct abstract scopes.
2304     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2305            AE = AbstractScopesList.end(); AI != AE; ++AI)
2306       constructScopeDIE(*AI);
2307
2308     constructScopeDIE(CurrentFnDbgScope);
2309
2310     DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2311                                                  MMI->getFrameMoves()));
2312   }
2313
2314   // Clear debug info
2315   CurrentFnDbgScope = NULL;
2316   DeleteContainerSeconds(DbgScopeMap);
2317   DbgScopeBeginMap.clear();
2318   DbgScopeEndMap.clear();
2319   DbgValueStartMap.clear();
2320   ConcreteScopes.clear();
2321   DeleteContainerSeconds(AbstractScopes);
2322   AbstractScopesList.clear();
2323   AbstractVariables.clear();
2324   Lines.clear();
2325 }
2326
2327 /// recordSourceLine - Register a source line with debug info. Returns the
2328 /// unique label that was emitted and which provides correspondence to
2329 /// the source line list.
2330 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2331   if (!MMI)
2332     return 0;
2333
2334   TimeRegion Timer(DebugTimer);
2335
2336   StringRef Dir;
2337   StringRef Fn;
2338
2339   DIDescriptor Scope(S);
2340   if (Scope.isCompileUnit()) {
2341     DICompileUnit CU(S);
2342     Dir = CU.getDirectory();
2343     Fn = CU.getFilename();
2344   } else if (Scope.isSubprogram()) {
2345     DISubprogram SP(S);
2346     Dir = SP.getDirectory();
2347     Fn = SP.getFilename();
2348   } else if (Scope.isLexicalBlock()) {
2349     DILexicalBlock DB(S);
2350     Dir = DB.getDirectory();
2351     Fn = DB.getFilename();
2352   } else
2353     assert(0 && "Unexpected scope info");
2354
2355   unsigned Src = GetOrCreateSourceID(Dir, Fn);
2356   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2357   Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2358
2359   Asm->OutStreamer.EmitLabel(Label);
2360   return Label;
2361 }
2362
2363 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2364 /// timed. Look up the source id with the given directory and source file
2365 /// names. If none currently exists, create a new id and insert it in the
2366 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2367 /// well.
2368 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2369                                          const std::string &FileName) {
2370   TimeRegion Timer(DebugTimer);
2371   return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2372 }
2373
2374 //===----------------------------------------------------------------------===//
2375 // Emit Methods
2376 //===----------------------------------------------------------------------===//
2377
2378 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2379 ///
2380 unsigned
2381 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2382   // Get the children.
2383   const std::vector<DIE *> &Children = Die->getChildren();
2384
2385   // If not last sibling and has children then add sibling offset attribute.
2386   if (!Last && !Children.empty())
2387     Die->addSiblingOffset(DIEValueAllocator);
2388
2389   // Record the abbreviation.
2390   assignAbbrevNumber(Die->getAbbrev());
2391
2392   // Get the abbreviation for this DIE.
2393   unsigned AbbrevNumber = Die->getAbbrevNumber();
2394   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2395
2396   // Set DIE offset
2397   Die->setOffset(Offset);
2398
2399   // Start the size with the size of abbreviation code.
2400   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2401
2402   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2403   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2404
2405   // Size the DIE attribute values.
2406   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2407     // Size attribute value.
2408     Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2409
2410   // Size the DIE children if any.
2411   if (!Children.empty()) {
2412     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2413            "Children flag not set");
2414
2415     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2416       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2417
2418     // End of children marker.
2419     Offset += sizeof(int8_t);
2420   }
2421
2422   Die->setSize(Offset - Die->getOffset());
2423   return Offset;
2424 }
2425
2426 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2427 ///
2428 void DwarfDebug::computeSizeAndOffsets() {
2429   // Compute size of compile unit header.
2430   static unsigned Offset =
2431     sizeof(int32_t) + // Length of Compilation Unit Info
2432     sizeof(int16_t) + // DWARF version number
2433     sizeof(int32_t) + // Offset Into Abbrev. Section
2434     sizeof(int8_t);   // Pointer Size (in bytes)
2435
2436   computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2437   CompileUnitOffsets[ModuleCU] = 0;
2438 }
2439
2440 /// emitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2441 /// tools to recognize the object file contains Dwarf information.
2442 void DwarfDebug::emitInitial() {
2443   // Check to see if we already emitted intial headers.
2444   if (didInitial) return;
2445   didInitial = true;
2446
2447   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2448
2449   // Dwarf sections base addresses.
2450   if (MAI->doesDwarfRequireFrameSection()) {
2451     Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2452     Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame"));
2453   }
2454
2455   Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2456   Asm->OutStreamer.EmitLabel(getTempLabel("section_info"));
2457   Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2458   Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev"));
2459   Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2460   Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges"));
2461
2462   if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2463     Asm->OutStreamer.SwitchSection(LineInfoDirective);
2464     Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo"));
2465   }
2466
2467   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2468   Asm->OutStreamer.EmitLabel(getTempLabel("section_line"));
2469   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2470   Asm->OutStreamer.EmitLabel(getTempLabel("section_loc"));
2471   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2472   Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames"));
2473   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2474   Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes"));
2475   Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2476   Asm->OutStreamer.EmitLabel(getTempLabel("section_str"));
2477   Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2478   Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges"));
2479
2480   Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2481   Asm->OutStreamer.EmitLabel(getTempLabel("text_begin"));
2482   Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2483   Asm->OutStreamer.EmitLabel(getTempLabel("data_begin"));
2484 }
2485
2486 /// emitDIE - Recusively Emits a debug information entry.
2487 ///
2488 void DwarfDebug::emitDIE(DIE *Die) {
2489   // Get the abbreviation for this DIE.
2490   unsigned AbbrevNumber = Die->getAbbrevNumber();
2491   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2492
2493   // Emit the code (index) for the abbreviation.
2494   if (Asm->isVerbose())
2495     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2496                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2497                                 Twine::utohexstr(Die->getSize()) + " " +
2498                                 dwarf::TagString(Abbrev->getTag()));
2499   Asm->EmitULEB128(AbbrevNumber);
2500
2501   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2502   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2503
2504   // Emit the DIE attribute values.
2505   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2506     unsigned Attr = AbbrevData[i].getAttribute();
2507     unsigned Form = AbbrevData[i].getForm();
2508     assert(Form && "Too many attributes for DIE (check abbreviation)");
2509
2510     if (Asm->isVerbose())
2511       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2512
2513     switch (Attr) {
2514     case dwarf::DW_AT_sibling:
2515       Asm->EmitInt32(Die->getSiblingOffset());
2516       break;
2517     case dwarf::DW_AT_abstract_origin: {
2518       DIEEntry *E = cast<DIEEntry>(Values[i]);
2519       DIE *Origin = E->getEntry();
2520       unsigned Addr = Origin->getOffset();
2521       Asm->EmitInt32(Addr);
2522       break;
2523     }
2524     default:
2525       // Emit an attribute using the defined form.
2526       Values[i]->EmitValue(this, Form);
2527       break;
2528     }
2529   }
2530
2531   // Emit the DIE children if any.
2532   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2533     const std::vector<DIE *> &Children = Die->getChildren();
2534
2535     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2536       emitDIE(Children[j]);
2537
2538     if (Asm->isVerbose())
2539       Asm->OutStreamer.AddComment("End Of Children Mark");
2540     Asm->EmitInt8(0);
2541   }
2542 }
2543
2544 /// emitDebugInfo - Emit the debug info section.
2545 ///
2546 void DwarfDebug::emitDebugInfo() {
2547   // Start debug info section.
2548   Asm->OutStreamer.SwitchSection(
2549                             Asm->getObjFileLowering().getDwarfInfoSection());
2550   DIE *Die = ModuleCU->getCUDie();
2551
2552   // Emit the compile units header.
2553   Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID()));
2554
2555   // Emit size of content not including length itself
2556   unsigned ContentSize = Die->getSize() +
2557     sizeof(int16_t) + // DWARF version number
2558     sizeof(int32_t) + // Offset Into Abbrev. Section
2559     sizeof(int8_t) +  // Pointer Size (in bytes)
2560     sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2561
2562   Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2563   Asm->EmitInt32(ContentSize);
2564   Asm->OutStreamer.AddComment("DWARF version number");
2565   Asm->EmitInt16(dwarf::DWARF_VERSION);
2566   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2567   EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"),
2568                     true);
2569   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2570   Asm->EmitInt8(TD->getPointerSize());
2571
2572   emitDIE(Die);
2573   // FIXME - extra padding for gdb bug.
2574   Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2575   Asm->EmitInt8(0);
2576   Asm->EmitInt8(0);
2577   Asm->EmitInt8(0);
2578   Asm->EmitInt8(0);
2579   Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID()));
2580 }
2581
2582 /// emitAbbreviations - Emit the abbreviation section.
2583 ///
2584 void DwarfDebug::emitAbbreviations() const {
2585   // Check to see if it is worth the effort.
2586   if (!Abbreviations.empty()) {
2587     // Start the debug abbrev section.
2588     Asm->OutStreamer.SwitchSection(
2589                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2590
2591     Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin"));
2592
2593     // For each abbrevation.
2594     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2595       // Get abbreviation data
2596       const DIEAbbrev *Abbrev = Abbreviations[i];
2597
2598       // Emit the abbrevations code (base 1 index.)
2599       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2600
2601       // Emit the abbreviations data.
2602       Abbrev->Emit(this);
2603     }
2604
2605     // Mark end of abbreviations.
2606     Asm->EmitULEB128(0, "EOM(3)");
2607
2608     Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end"));
2609   }
2610 }
2611
2612 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2613 /// the line matrix.
2614 ///
2615 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2616   // Define last address of section.
2617   Asm->OutStreamer.AddComment("Extended Op");
2618   Asm->EmitInt8(0);
2619
2620   Asm->OutStreamer.AddComment("Op size");
2621   Asm->EmitInt8(TD->getPointerSize() + 1);
2622   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2623   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2624
2625   Asm->OutStreamer.AddComment("Section end label");
2626
2627   Asm->OutStreamer.EmitSymbolValue(getDWLabel("section_end", SectionEnd),
2628                                    TD->getPointerSize(), 0/*AddrSpace*/);
2629
2630   // Mark end of matrix.
2631   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2632   Asm->EmitInt8(0);
2633   Asm->EmitInt8(1);
2634   Asm->EmitInt8(1);
2635 }
2636
2637 /// emitDebugLines - Emit source line information.
2638 ///
2639 void DwarfDebug::emitDebugLines() {
2640   // If the target is using .loc/.file, the assembler will be emitting the
2641   // .debug_line table automatically.
2642   if (MAI->hasDotLocAndDotFile())
2643     return;
2644
2645   // Minimum line delta, thus ranging from -10..(255-10).
2646   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2647   // Maximum line delta, thus ranging from -10..(255-10).
2648   const int MaxLineDelta = 255 + MinLineDelta;
2649
2650   // Start the dwarf line section.
2651   Asm->OutStreamer.SwitchSection(
2652                             Asm->getObjFileLowering().getDwarfLineSection());
2653
2654   // Construct the section header.
2655   Asm->OutStreamer.AddComment("Length of Source Line Info");
2656   EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true);
2657   Asm->OutStreamer.EmitLabel(getTempLabel("line_begin"));
2658
2659   Asm->OutStreamer.AddComment("DWARF version number");
2660   Asm->EmitInt16(dwarf::DWARF_VERSION);
2661
2662   Asm->OutStreamer.AddComment("Prolog Length");
2663   EmitDifference(getTempLabel("line_prolog_end"),
2664                  getTempLabel("line_prolog_begin"), true);
2665   Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin"));
2666
2667   Asm->OutStreamer.AddComment("Minimum Instruction Length");
2668   Asm->EmitInt8(1);
2669   Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2670   Asm->EmitInt8(1);
2671   Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2672   Asm->EmitInt8(MinLineDelta);
2673   Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2674   Asm->EmitInt8(MaxLineDelta);
2675   Asm->OutStreamer.AddComment("Special Opcode Base");
2676   Asm->EmitInt8(-MinLineDelta);
2677
2678   // Line number standard opcode encodings argument count
2679   Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2680   Asm->EmitInt8(0);
2681   Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2682   Asm->EmitInt8(1);
2683   Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2684   Asm->EmitInt8(1);
2685   Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2686   Asm->EmitInt8(1);
2687   Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2688   Asm->EmitInt8(1);
2689   Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2690   Asm->EmitInt8(0);
2691   Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2692   Asm->EmitInt8(0);
2693   Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2694   Asm->EmitInt8(0);
2695   Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2696   Asm->EmitInt8(1);
2697
2698   // Emit directories.
2699   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2700     const std::string &Dir = getSourceDirectoryName(DI);
2701     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2702     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2703   }
2704
2705   Asm->OutStreamer.AddComment("End of directories");
2706   Asm->EmitInt8(0);
2707
2708   // Emit files.
2709   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2710     // Remember source id starts at 1.
2711     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2712     const std::string &FN = getSourceFileName(Id.second);
2713     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2714     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2715
2716     Asm->EmitULEB128(Id.first, "Directory #");
2717     Asm->EmitULEB128(0, "Mod date");
2718     Asm->EmitULEB128(0, "File size");
2719   }
2720
2721   Asm->OutStreamer.AddComment("End of files");
2722   Asm->EmitInt8(0);
2723
2724   Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end"));
2725
2726   // A sequence for each text section.
2727   unsigned SecSrcLinesSize = SectionSourceLines.size();
2728
2729   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2730     // Isolate current sections line info.
2731     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2732
2733     // Dwarf assumes we start with first line of first source file.
2734     unsigned Source = 1;
2735     unsigned Line = 1;
2736
2737     // Construct rows of the address, source, line, column matrix.
2738     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2739       const SrcLineInfo &LineInfo = LineInfos[i];
2740       MCSymbol *Label = LineInfo.getLabel();
2741       if (!Label->isDefined()) continue; // Not emitted, in dead code.
2742
2743       if (LineInfo.getLine() == 0) continue;
2744
2745       if (Asm->isVerbose()) {
2746         std::pair<unsigned, unsigned> SrcID =
2747           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2748         Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2749                                     "/" +
2750                                     Twine(getSourceFileName(SrcID.second)) +
2751                                     ":" + Twine(LineInfo.getLine()));
2752       }
2753
2754       // Define the line address.
2755       Asm->OutStreamer.AddComment("Extended Op");
2756       Asm->EmitInt8(0);
2757       Asm->OutStreamer.AddComment("Op size");
2758       Asm->EmitInt8(TD->getPointerSize() + 1);
2759
2760       Asm->OutStreamer.AddComment("DW_LNE_set_address");
2761       Asm->EmitInt8(dwarf::DW_LNE_set_address);
2762
2763       Asm->OutStreamer.AddComment("Location label");
2764       Asm->OutStreamer.EmitSymbolValue(Label, TD->getPointerSize(),
2765                                        0/*AddrSpace*/);
2766
2767       // If change of source, then switch to the new source.
2768       if (Source != LineInfo.getSourceID()) {
2769         Source = LineInfo.getSourceID();
2770         Asm->OutStreamer.AddComment("DW_LNS_set_file");
2771         Asm->EmitInt8(dwarf::DW_LNS_set_file);
2772         Asm->EmitULEB128(Source, "New Source");
2773       }
2774
2775       // If change of line.
2776       if (Line != LineInfo.getLine()) {
2777         // Determine offset.
2778         int Offset = LineInfo.getLine() - Line;
2779         int Delta = Offset - MinLineDelta;
2780
2781         // Update line.
2782         Line = LineInfo.getLine();
2783
2784         // If delta is small enough and in range...
2785         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2786           // ... then use fast opcode.
2787           Asm->OutStreamer.AddComment("Line Delta");
2788           Asm->EmitInt8(Delta - MinLineDelta);
2789         } else {
2790           // ... otherwise use long hand.
2791           Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2792           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2793           Asm->EmitSLEB128(Offset, "Line Offset");
2794           Asm->OutStreamer.AddComment("DW_LNS_copy");
2795           Asm->EmitInt8(dwarf::DW_LNS_copy);
2796         }
2797       } else {
2798         // Copy the previous row (different address or source)
2799         Asm->OutStreamer.AddComment("DW_LNS_copy");
2800         Asm->EmitInt8(dwarf::DW_LNS_copy);
2801       }
2802     }
2803
2804     emitEndOfLineMatrix(j + 1);
2805   }
2806
2807   if (SecSrcLinesSize == 0)
2808     // Because we're emitting a debug_line section, we still need a line
2809     // table. The linker and friends expect it to exist. If there's nothing to
2810     // put into it, emit an empty table.
2811     emitEndOfLineMatrix(1);
2812
2813   Asm->OutStreamer.EmitLabel(getTempLabel("line_end"));
2814 }
2815
2816 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2817 ///
2818 void DwarfDebug::emitCommonDebugFrame() {
2819   if (!MAI->doesDwarfRequireFrameSection())
2820     return;
2821
2822   int stackGrowth =
2823     Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2824       TargetFrameInfo::StackGrowsUp ?
2825     TD->getPointerSize() : -TD->getPointerSize();
2826
2827   // Start the dwarf frame section.
2828   Asm->OutStreamer.SwitchSection(
2829                               Asm->getObjFileLowering().getDwarfFrameSection());
2830
2831   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common"));
2832   Asm->OutStreamer.AddComment("Length of Common Information Entry");
2833   EmitDifference(getTempLabel("debug_frame_common_end"),
2834                  getTempLabel("debug_frame_common_begin"), true);
2835
2836   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin"));
2837   Asm->OutStreamer.AddComment("CIE Identifier Tag");
2838   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2839   Asm->OutStreamer.AddComment("CIE Version");
2840   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2841   Asm->OutStreamer.AddComment("CIE Augmentation");
2842   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2843   Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2844   Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2845   Asm->OutStreamer.AddComment("CIE RA Column");
2846   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2847
2848   std::vector<MachineMove> Moves;
2849   RI->getInitialFrameState(Moves);
2850
2851   EmitFrameMoves(0, Moves, false);
2852
2853   Asm->EmitAlignment(2, 0, 0, false);
2854   Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end"));
2855 }
2856
2857 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2858 /// section.
2859 void DwarfDebug::
2860 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2861   if (!MAI->doesDwarfRequireFrameSection())
2862     return;
2863
2864   // Start the dwarf frame section.
2865   Asm->OutStreamer.SwitchSection(
2866                               Asm->getObjFileLowering().getDwarfFrameSection());
2867
2868   Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2869   MCSymbol *DebugFrameBegin =
2870     getDWLabel("debug_frame_begin", DebugFrameInfo.Number);
2871   MCSymbol *DebugFrameEnd =
2872     getDWLabel("debug_frame_end", DebugFrameInfo.Number);
2873   EmitDifference(DebugFrameEnd, DebugFrameBegin, true);
2874
2875   Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2876
2877   Asm->OutStreamer.AddComment("FDE CIE offset");
2878   EmitSectionOffset(getTempLabel("debug_frame_common"),
2879                     getTempLabel("section_debug_frame"), true);
2880
2881   Asm->OutStreamer.AddComment("FDE initial location");
2882   MCSymbol *FuncBeginSym = getDWLabel("func_begin", DebugFrameInfo.Number);
2883   Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2884                                    TD->getPointerSize(), 0/*AddrSpace*/);
2885
2886
2887   Asm->OutStreamer.AddComment("FDE address range");
2888   EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number), FuncBeginSym);
2889
2890   EmitFrameMoves(FuncBeginSym, DebugFrameInfo.Moves, false);
2891
2892   Asm->EmitAlignment(2, 0, 0, false);
2893   Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2894 }
2895
2896 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2897 ///
2898 void DwarfDebug::emitDebugPubNames() {
2899   // Start the dwarf pubnames section.
2900   Asm->OutStreamer.SwitchSection(
2901                           Asm->getObjFileLowering().getDwarfPubNamesSection());
2902
2903   Asm->OutStreamer.AddComment("Length of Public Names Info");
2904   EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()),
2905                  getDWLabel("pubnames_begin", ModuleCU->getID()), true);
2906
2907   Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID()));
2908
2909   Asm->OutStreamer.AddComment("DWARF Version");
2910   Asm->EmitInt16(dwarf::DWARF_VERSION);
2911
2912   Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2913   EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2914                     getTempLabel("section_info"), true);
2915
2916   Asm->OutStreamer.AddComment("Compilation Unit Length");
2917   EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2918                  getDWLabel("info_begin", ModuleCU->getID()),
2919                  true);
2920
2921   const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2922   for (StringMap<DIE*>::const_iterator
2923          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2924     const char *Name = GI->getKeyData();
2925     DIE *Entity = GI->second;
2926
2927     Asm->OutStreamer.AddComment("DIE offset");
2928     Asm->EmitInt32(Entity->getOffset());
2929
2930     if (Asm->isVerbose())
2931       Asm->OutStreamer.AddComment("External Name");
2932     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2933   }
2934
2935   Asm->OutStreamer.AddComment("End Mark");
2936   Asm->EmitInt32(0);
2937   Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID()));
2938 }
2939
2940 void DwarfDebug::emitDebugPubTypes() {
2941   // Start the dwarf pubnames section.
2942   Asm->OutStreamer.SwitchSection(
2943                           Asm->getObjFileLowering().getDwarfPubTypesSection());
2944   Asm->OutStreamer.AddComment("Length of Public Types Info");
2945   EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()),
2946                  getDWLabel("pubtypes_begin", ModuleCU->getID()), true);
2947
2948   Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID()));
2949
2950   if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2951   Asm->EmitInt16(dwarf::DWARF_VERSION);
2952
2953   Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2954   EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2955                     getTempLabel("section_info"), true);
2956
2957   Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2958   EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2959                  getDWLabel("info_begin", ModuleCU->getID()),
2960                  true);
2961
2962   const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2963   for (StringMap<DIE*>::const_iterator
2964          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2965     const char *Name = GI->getKeyData();
2966     DIE * Entity = GI->second;
2967
2968     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2969     Asm->EmitInt32(Entity->getOffset());
2970
2971     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2972     Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2973   }
2974
2975   Asm->OutStreamer.AddComment("End Mark");
2976   Asm->EmitInt32(0);
2977   Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID()));
2978 }
2979
2980 /// emitDebugStr - Emit visible names into a debug str section.
2981 ///
2982 void DwarfDebug::emitDebugStr() {
2983   // Check to see if it is worth the effort.
2984   if (StringPool.empty()) return;
2985
2986   // Start the dwarf str section.
2987   Asm->OutStreamer.SwitchSection(
2988                                 Asm->getObjFileLowering().getDwarfStrSection());
2989
2990   // Get all of the string pool entries and put them in an array by their ID so
2991   // we can sort them.
2992   SmallVector<std::pair<unsigned,
2993       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2994
2995   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2996        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2997     Entries.push_back(std::make_pair(I->second.second, &*I));
2998
2999   array_pod_sort(Entries.begin(), Entries.end());
3000
3001   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3002     // Emit a label for reference from debug information entries.
3003     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3004
3005     // Emit the string itself.
3006     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3007   }
3008 }
3009
3010 /// emitDebugLoc - Emit visible names into a debug loc section.
3011 ///
3012 void DwarfDebug::emitDebugLoc() {
3013   // Start the dwarf loc section.
3014   Asm->OutStreamer.SwitchSection(
3015                               Asm->getObjFileLowering().getDwarfLocSection());
3016 }
3017
3018 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3019 ///
3020 void DwarfDebug::EmitDebugARanges() {
3021   // Start the dwarf aranges section.
3022   Asm->OutStreamer.SwitchSection(
3023                           Asm->getObjFileLowering().getDwarfARangesSection());
3024 }
3025
3026 /// emitDebugRanges - Emit visible names into a debug ranges section.
3027 ///
3028 void DwarfDebug::emitDebugRanges() {
3029   // Start the dwarf ranges section.
3030   Asm->OutStreamer.SwitchSection(
3031                             Asm->getObjFileLowering().getDwarfRangesSection());
3032 }
3033
3034 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3035 ///
3036 void DwarfDebug::emitDebugMacInfo() {
3037   if (const MCSection *LineInfo =
3038       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3039     // Start the dwarf macinfo section.
3040     Asm->OutStreamer.SwitchSection(LineInfo);
3041   }
3042 }
3043
3044 /// emitDebugInlineInfo - Emit inline info using following format.
3045 /// Section Header:
3046 /// 1. length of section
3047 /// 2. Dwarf version number
3048 /// 3. address size.
3049 ///
3050 /// Entries (one "entry" for each function that was inlined):
3051 ///
3052 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3053 ///   otherwise offset into __debug_str for regular function name.
3054 /// 2. offset into __debug_str section for regular function name.
3055 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3056 /// instances for the function.
3057 ///
3058 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3059 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3060 /// __debug_info section, and the low_pc is the starting address for the
3061 /// inlining instance.
3062 void DwarfDebug::emitDebugInlineInfo() {
3063   if (!MAI->doesDwarfUsesInlineInfoSection())
3064     return;
3065
3066   if (!ModuleCU)
3067     return;
3068
3069   Asm->OutStreamer.SwitchSection(
3070                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
3071
3072   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3073   EmitDifference(getDWLabel("debug_inlined_end", 1),
3074                  getDWLabel("debug_inlined_begin", 1), true);
3075
3076   Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1));
3077
3078   Asm->OutStreamer.AddComment("Dwarf Version");
3079   Asm->EmitInt16(dwarf::DWARF_VERSION);
3080   Asm->OutStreamer.AddComment("Address Size (in bytes)");
3081   Asm->EmitInt8(TD->getPointerSize());
3082
3083   for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3084          E = InlinedSPNodes.end(); I != E; ++I) {
3085
3086     MDNode *Node = *I;
3087     DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3088       = InlineInfo.find(Node);
3089     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3090     DISubprogram SP(Node);
3091     StringRef LName = SP.getLinkageName();
3092     StringRef Name = SP.getName();
3093
3094     Asm->OutStreamer.AddComment("MIPS linkage name");
3095     if (LName.empty()) {
3096       Asm->OutStreamer.EmitBytes(Name, 0);
3097       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3098     } else
3099       EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3100                         getTempLabel("section_str"), true);
3101
3102     Asm->OutStreamer.AddComment("Function name");
3103     EmitSectionOffset(getStringPoolEntry(Name), getTempLabel("section_str"),
3104                       true);
3105     Asm->EmitULEB128(Labels.size(), "Inline count");
3106
3107     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3108            LE = Labels.end(); LI != LE; ++LI) {
3109       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3110       Asm->EmitInt32(LI->second->getOffset());
3111
3112       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3113       Asm->OutStreamer.EmitSymbolValue(LI->first, TD->getPointerSize(), 0);
3114     }
3115   }
3116
3117   Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1));
3118 }