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