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 //===----------------------------------------------------------------------===//
  43
  44 /// Configuration values for initial hash set sizes (log2).
  45 ///
  46 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
  47
  48 namespace llvm {
  49
  50 //===----------------------------------------------------------------------===//
  51 /// CompileUnit - This dwarf writer support class manages information associate
  52 /// with a source file.
  53 class CompileUnit {
  54   /// ID - File identifier for source.
  55   ///
  56   unsigned ID;
  57
  58   /// Die - Compile unit debug information entry.
  59   ///
  60   const OwningPtr<DIE> CUDie;
  61
  62   /// IndexTyDie - An anonymous type for index type.  Owned by CUDie.
  63   DIE *IndexTyDie;
  64
  65   /// GVToDieMap - Tracks the mapping of unit level debug informaton
  66   /// variables to debug information entries.
  67   /// FIXME : Rename GVToDieMap -> NodeToDieMap
  68   DenseMap<MDNode *, DIE *> GVToDieMap;
  69
  70   /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
  71   /// descriptors to debug information entries using a DIEEntry proxy.
  72   /// FIXME : Rename
  73   DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
  74
  75   /// Globals - A map of globally visible named entities for this unit.
  76   ///
  77   StringMap<DIE*> Globals;
  78
  79   /// GlobalTypes - A map of globally visible types for this unit.
  80   ///
  81   StringMap<DIE*> GlobalTypes;
  82
  83 public:
  84   CompileUnit(unsigned I, DIE *D)
  85     : ID(I), CUDie(D), IndexTyDie(0) {}
  86
  87   // Accessors.
  88   unsigned getID()                  const { return ID; }
  89   DIE* getCUDie()                   const { return CUDie.get(); }
  90   const StringMap<DIE*> &getGlobals()     const { return Globals; }
  91   const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
  92
  93   /// hasContent - Return true if this compile unit has something to write out.
  94   ///
  95   bool hasContent() const { return !CUDie->getChildren().empty(); }
  96
  97   /// addGlobal - Add a new global entity to the compile unit.
  98   ///
  99   void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
 100
 101   /// addGlobalType - Add a new global type to the compile unit.
 102   ///
 103   void addGlobalType(StringRef Name, DIE *Die) {
 104     GlobalTypes[Name] = Die;
 105   }
 106
 107   /// getDIE - Returns the debug information entry map slot for the
 108   /// specified debug variable.
 109   DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
 110
 111   /// insertDIE - Insert DIE into the map.
 112   void insertDIE(MDNode *N, DIE *D) {
 113     GVToDieMap.insert(std::make_pair(N, D));
 114   }
 115
 116   /// getDIEEntry - Returns the debug information entry for the speciefied
 117   /// debug variable.
 118   DIEEntry *getDIEEntry(MDNode *N) {
 119     DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
 120     if (I == GVToDIEEntryMap.end())
 121       return NULL;
 122     return I->second;
 123   }
 124
 125   /// insertDIEEntry - Insert debug information entry into the map.
 126   void insertDIEEntry(MDNode *N, DIEEntry *E) {
 127     GVToDIEEntryMap.insert(std::make_pair(N, E));
 128   }
 129
 130   /// addDie - Adds or interns the DIE to the compile unit.
 131   ///
 132   void addDie(DIE *Buffer) {
 133     this->CUDie->addChild(Buffer);
 134   }
 135
 136   // getIndexTyDie - Get an anonymous type for index type.
 137   DIE *getIndexTyDie() {
 138     return IndexTyDie;
 139   }
 140
 141   // setIndexTyDie - Set D as anonymous type for index which can be reused
 142   // later.
 143   void setIndexTyDie(DIE *D) {
 144     IndexTyDie = D;
 145   }
 146
 147 };
 148
 149 //===----------------------------------------------------------------------===//
 150 /// DbgVariable - This class is used to track local variable information.
 151 ///
 152 class DbgVariable {
 153   DIVariable Var;                    // Variable Descriptor.
 154   unsigned FrameIndex;               // Variable frame index.
 155   const MachineInstr *DbgValueMInsn; // DBG_VALUE
 156   // DbgValueLabel - DBG_VALUE is effective from this label.
 157   MCSymbol *DbgValueLabel;
 158   DbgVariable *const AbstractVar;    // Abstract variable for this variable.
 159   DIE *TheDIE;
 160 public:
 161   // AbsVar may be NULL.
 162   DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
 163     : Var(V), FrameIndex(I), DbgValueMInsn(0),
 164       DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
 165   DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
 166     : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
 167       AbstractVar(AbsVar), TheDIE(0)
 168     {}
 169
 170   // Accessors.
 171   DIVariable getVariable()           const { return Var; }
 172   unsigned getFrameIndex()           const { return FrameIndex; }
 173   const MachineInstr *getDbgValue()  const { return DbgValueMInsn; }
 174   MCSymbol *getDbgValueLabel()       const { return DbgValueLabel; }
 175   void setDbgValueLabel(MCSymbol *L)       { DbgValueLabel = L; }
 176   DbgVariable *getAbstractVariable() const { return AbstractVar; }
 177   void setDIE(DIE *D)                      { TheDIE = D; }
 178   DIE *getDIE()                      const { return TheDIE; }
 179 };
 180
 181 //===----------------------------------------------------------------------===//
 182 /// DbgScope - This class is used to track scope information.
 183 ///
 184 class DbgScope {
 185   DbgScope *Parent;                   // Parent to this scope.
 186   DIDescriptor Desc;                  // Debug info descriptor for scope.
 187   // Location at which this scope is inlined.
 188   AssertingVH<MDNode> InlinedAtLocation;
 189   bool AbstractScope;                 // Abstract Scope
 190   MCSymbol *StartLabel;               // Label ID of the beginning of scope.
 191   MCSymbol *EndLabel;                 // Label ID of the end of scope.
 192   const MachineInstr *LastInsn;       // Last instruction of this scope.
 193   const MachineInstr *FirstInsn;      // First instruction of this scope.
 194   // Scopes defined in scope.  Contents not owned.
 195   SmallVector<DbgScope *, 4> Scopes;
 196   // Variables declared in scope.  Contents owned.
 197   SmallVector<DbgVariable *, 8> Variables;
 198
 199   // Private state for dump()
 200   mutable unsigned IndentLevel;
 201 public:
 202   DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
 203     : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
 204       StartLabel(0), EndLabel(0),
 205       LastInsn(0), FirstInsn(0), IndentLevel(0) {}
 206   virtual ~DbgScope();
 207
 208   // Accessors.
 209   DbgScope *getParent()          const { return Parent; }
 210   void setParent(DbgScope *P)          { Parent = P; }
 211   DIDescriptor getDesc()         const { return Desc; }
 212   MDNode *getInlinedAt()         const { return InlinedAtLocation; }
 213   MDNode *getScopeNode()         const { return Desc.getNode(); }
 214   MCSymbol *getStartLabel()      const { return StartLabel; }
 215   MCSymbol *getEndLabel()        const { return EndLabel; }
 216   const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
 217   const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
 218   void setStartLabel(MCSymbol *S) { StartLabel = S; }
 219   void setEndLabel(MCSymbol *E)   { EndLabel = E; }
 220   void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
 221   const MachineInstr *getLastInsn()      { return LastInsn; }
 222   void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
 223   void setAbstractScope() { AbstractScope = true; }
 224   bool isAbstractScope() const { return AbstractScope; }
 225   const MachineInstr *getFirstInsn()      { return FirstInsn; }
 226
 227   /// addScope - Add a scope to the scope.
 228   ///
 229   void addScope(DbgScope *S) { Scopes.push_back(S); }
 230
 231   /// addVariable - Add a variable to the scope.
 232   ///
 233   void addVariable(DbgVariable *V) { Variables.push_back(V); }
 234
 235   void fixInstructionMarkers(DenseMap<const MachineInstr *,
 236                              unsigned> &MIIndexMap) {
 237     assert(getFirstInsn() && "First instruction is missing!");
 238
 239     // Use the end of last child scope as end of this scope.
 240     const SmallVector<DbgScope *, 4> &Scopes = getScopes();
 241     const MachineInstr *LastInsn = getFirstInsn();
 242     unsigned LIndex = 0;
 243     if (Scopes.empty()) {
 244       assert(getLastInsn() && "Inner most scope does not have last insn!");
 245       return;
 246     }
 247     for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
 248            SE = Scopes.end(); SI != SE; ++SI) {
 249       DbgScope *DS = *SI;
 250       DS->fixInstructionMarkers(MIIndexMap);
 251       const MachineInstr *DSLastInsn = DS->getLastInsn();
 252       unsigned DSI = MIIndexMap[DSLastInsn];
 253       if (DSI > LIndex) {
 254         LastInsn = DSLastInsn;
 255         LIndex = DSI;
 256       }
 257     }
 258
 259     unsigned CurrentLastInsnIndex = 0;
 260     if (const MachineInstr *CL = getLastInsn())
 261       CurrentLastInsnIndex = MIIndexMap[CL];
 262     unsigned FIndex = MIIndexMap[getFirstInsn()];
 263
 264     // Set LastInsn as the last instruction for this scope only if
 265     // it follows
 266     //  1) this scope's first instruction and
 267     //  2) current last instruction for this scope, if any.
 268     if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
 269       setLastInsn(LastInsn);
 270   }
 271
 272 #ifndef NDEBUG
 273   void dump() const;
 274 #endif
 275 };
 276
 277 } // end llvm namespace
 278
 279 #ifndef NDEBUG
 280 void DbgScope::dump() const {
 281   raw_ostream &err = dbgs();
 282   err.indent(IndentLevel);
 283   MDNode *N = Desc.getNode();
 284   N->dump();
 285   err << " [" << StartLabel << ", " << EndLabel << "]\n";
 286   if (AbstractScope)
 287     err << "Abstract Scope\n";
 288
 289   IndentLevel += 2;
 290   if (!Scopes.empty())
 291     err << "Children ...\n";
 292   for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
 293     if (Scopes[i] != this)
 294       Scopes[i]->dump();
 295
 296   IndentLevel -= 2;
 297 }
 298 #endif
 299
 300 DbgScope::~DbgScope() {
 301   for (unsigned j = 0, M = Variables.size(); j < M; ++j)
 302     delete Variables[j];
 303 }
 304
 305 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 306   : Asm(A), MMI(Asm->MMI), ModuleCU(0),
 307     AbbreviationsSet(InitAbbreviationsSetSize),
 308     CurrentFnDbgScope(0), DebugTimer(0) {
 309   NextStringPoolNumber = 0;
 310
 311   DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
 312   DwarfStrSectionSym = TextSectionSym = 0;
 313
 314   if (TimePassesIsEnabled)
 315     DebugTimer = new Timer("Dwarf Debug Writer");
 316
 317   beginModule(M);
 318 }
 319 DwarfDebug::~DwarfDebug() {
 320   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
 321     DIEBlocks[j]->~DIEBlock();
 322
 323   delete DebugTimer;
 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 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1336 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1337 /// If there are global variables in this scope then create and insert
1338 /// DIEs for these variables.
1339 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1340   DIE *SPDie = ModuleCU->getDIE(SPNode);
1341   assert(SPDie && "Unable to find subprogram DIE!");
1342   DISubprogram SP(SPNode);
1343
1344   // There is not any need to generate specification DIE for a function
1345   // defined at compile unit level. If a function is defined inside another
1346   // function then gdb prefers the definition at top level and but does not
1347   // expect specification DIE in parent function. So avoid creating
1348   // specification DIE for a function defined inside a function.
1349   if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1350       !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1351     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1352
1353     // Add arguments.
1354     DICompositeType SPTy = SP.getType();
1355     DIArray Args = SPTy.getTypeArray();
1356     unsigned SPTag = SPTy.getTag();
1357     if (SPTag == dwarf::DW_TAG_subroutine_type)
1358       for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1359         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1360         DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1361         addType(Arg, ATy);
1362         if (ATy.isArtificial())
1363           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1364         SPDie->addChild(Arg);
1365       }
1366     DIE *SPDeclDie = SPDie;
1367     SPDie = new DIE(dwarf::DW_TAG_subprogram);
1368     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1369                 SPDeclDie);
1370     ModuleCU->addDie(SPDie);
1371   }
1372
1373   addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1374            Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1375   addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1376            Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1377   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1378   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1379   addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1380
1381   if (!DISubprogram(SPNode).isLocalToUnit())
1382     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1383
1384   return SPDie;
1385 }
1386
1387 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1388 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1389 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1390   MCSymbol *Start = Scope->getStartLabel();
1391   MCSymbol *End = Scope->getEndLabel();
1392   if (Start == 0 || End == 0) return 0;
1393
1394   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1395   assert(End->isDefined() && "Invalid end label for an inlined scope!");
1396
1397   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1398   if (Scope->isAbstractScope())
1399     return ScopeDIE;
1400
1401   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1402            Start ? Start : Asm->GetTempSymbol("func_begin",
1403                                               Asm->getFunctionNumber()));
1404   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1405            End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1406
1407   return ScopeDIE;
1408 }
1409
1410 /// constructInlinedScopeDIE - This scope represents inlined body of
1411 /// a function. Construct DIE to represent this concrete inlined copy
1412 /// of the function.
1413 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1414   MCSymbol *StartLabel = Scope->getStartLabel();
1415   MCSymbol *EndLabel = Scope->getEndLabel();
1416   if (StartLabel == 0 || EndLabel == 0) return 0;
1417
1418   assert(StartLabel->isDefined() &&
1419          "Invalid starting label for an inlined scope!");
1420   assert(EndLabel->isDefined() &&
1421          "Invalid end label for an inlined scope!");
1422   if (!Scope->getScopeNode())
1423     return NULL;
1424   DIScope DS(Scope->getScopeNode());
1425   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1426
1427   DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1428   DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1429   assert(OriginDIE && "Unable to find Origin DIE!");
1430   addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1431               dwarf::DW_FORM_ref4, OriginDIE);
1432
1433   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1434   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1435
1436   InlinedSubprogramDIEs.insert(OriginDIE);
1437
1438   // Track the start label for this inlined function.
1439   DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1440     I = InlineInfo.find(InlinedSP.getNode());
1441
1442   if (I == InlineInfo.end()) {
1443     InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1444                                                              ScopeDIE));
1445     InlinedSPNodes.push_back(InlinedSP.getNode());
1446   } else
1447     I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1448
1449   DILocation DL(Scope->getInlinedAt());
1450   addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1451   addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1452
1453   return ScopeDIE;
1454 }
1455
1456
1457 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1458 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1459   // Get the descriptor.
1460   const DIVariable &VD = DV->getVariable();
1461   StringRef Name = VD.getName();
1462   if (Name.empty())
1463     return NULL;
1464
1465   // Translate tag to proper Dwarf tag.  The result variable is dropped for
1466   // now.
1467   unsigned Tag;
1468   switch (VD.getTag()) {
1469   case dwarf::DW_TAG_return_variable:
1470     return NULL;
1471   case dwarf::DW_TAG_arg_variable:
1472     Tag = dwarf::DW_TAG_formal_parameter;
1473     break;
1474   case dwarf::DW_TAG_auto_variable:    // fall thru
1475   default:
1476     Tag = dwarf::DW_TAG_variable;
1477     break;
1478   }
1479
1480   // Define variable debug information entry.
1481   DIE *VariableDie = new DIE(Tag);
1482
1483
1484   DIE *AbsDIE = NULL;
1485   if (DbgVariable *AV = DV->getAbstractVariable())
1486     AbsDIE = AV->getDIE();
1487
1488   if (AbsDIE) {
1489     DIScope DS(Scope->getScopeNode());
1490     DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1491     DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1492     (void) OriginSPDIE;
1493     assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1494     DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1495     assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1496     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1497                 dwarf::DW_FORM_ref4, AbsDIE);
1498   }
1499   else {
1500     addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1501     addSourceLine(VariableDie, &VD);
1502
1503     // Add variable type.
1504     // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1505     // addresses instead.
1506     if (VD.isBlockByrefVariable())
1507       addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1508     else
1509       addType(VariableDie, VD.getType());
1510   }
1511
1512   // Add variable address.
1513   if (!Scope->isAbstractScope()) {
1514     // Check if variable is described by DBG_VALUE instruction.
1515     if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1516       if (DbgValueInsn->getNumOperands() == 3) {
1517         // FIXME : Handle getNumOperands != 3
1518         if (DbgValueInsn->getOperand(0).getType()
1519             == MachineOperand::MO_Register
1520             && DbgValueInsn->getOperand(0).getReg()) {
1521           MachineLocation Location;
1522           Location.set(DbgValueInsn->getOperand(0).getReg());
1523           addAddress(VariableDie, dwarf::DW_AT_location, Location);
1524           if (MCSymbol *VS = DV->getDbgValueLabel())
1525             addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1526                      VS);
1527         } else if (DbgValueInsn->getOperand(0).getType() ==
1528                    MachineOperand::MO_Immediate) {
1529           DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1530           unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1531           addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1532           addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1533           if (MCSymbol *VS = DV->getDbgValueLabel())
1534             addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1535                      VS);
1536         } else if (DbgValueInsn->getOperand(0).getType() ==
1537                    MachineOperand::MO_FPImmediate) {
1538           DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1539           APFloat FPImm = DbgValueInsn->getOperand(0).getFPImm()->getValueAPF();
1540
1541           // Get the raw data form of the floating point.
1542           const APInt FltVal = FPImm.bitcastToAPInt();
1543           const char *FltPtr = (const char*)FltVal.getRawData();
1544
1545           unsigned NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
1546           bool LittleEndian = Asm->getTargetData().isLittleEndian();
1547           int Incr = (LittleEndian ? 1 : -1);
1548           int Start = (LittleEndian ? 0 : NumBytes - 1);
1549           int Stop = (LittleEndian ? NumBytes : -1);
1550
1551           // Output the constant to DWARF one byte at a time.
1552           for (; Start != Stop; Start += Incr)
1553             addUInt(Block, 0, dwarf::DW_FORM_data1,
1554                     (unsigned char)0xFF & FltPtr[Start]);
1555
1556           addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1557
1558           if (MCSymbol *VS = DV->getDbgValueLabel())
1559             addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1560                      VS);
1561         } else {
1562           //FIXME : Handle other operand types.
1563           delete VariableDie;
1564           return NULL;
1565         }
1566       }
1567     } else {
1568       MachineLocation Location;
1569       unsigned FrameReg;
1570       const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1571       int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1572                                               FrameReg);
1573       Location.set(FrameReg, Offset);
1574
1575       if (VD.hasComplexAddress())
1576         addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1577       else if (VD.isBlockByrefVariable())
1578         addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1579       else
1580         addAddress(VariableDie, dwarf::DW_AT_location, Location);
1581     }
1582   }
1583
1584   if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1585     addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1586   DV->setDIE(VariableDie);
1587   return VariableDie;
1588
1589 }
1590
1591 void DwarfDebug::addPubTypes(DISubprogram SP) {
1592   DICompositeType SPTy = SP.getType();
1593   unsigned SPTag = SPTy.getTag();
1594   if (SPTag != dwarf::DW_TAG_subroutine_type)
1595     return;
1596
1597   DIArray Args = SPTy.getTypeArray();
1598   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1599     DIType ATy(Args.getElement(i).getNode());
1600     if (!ATy.isValid())
1601       continue;
1602     DICompositeType CATy = getDICompositeType(ATy);
1603     if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1604       if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1605         ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1606     }
1607   }
1608 }
1609
1610 /// constructScopeDIE - Construct a DIE for this scope.
1611 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1612   if (!Scope || !Scope->getScopeNode())
1613     return NULL;
1614
1615   DIScope DS(Scope->getScopeNode());
1616   DIE *ScopeDIE = NULL;
1617   if (Scope->getInlinedAt())
1618     ScopeDIE = constructInlinedScopeDIE(Scope);
1619   else if (DS.isSubprogram()) {
1620     if (Scope->isAbstractScope())
1621       ScopeDIE = ModuleCU->getDIE(DS.getNode());
1622     else
1623       ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1624   }
1625   else
1626     ScopeDIE = constructLexicalScopeDIE(Scope);
1627   if (!ScopeDIE) return NULL;
1628
1629   // Add variables to scope.
1630   const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1631   for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1632     DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1633     if (VariableDIE)
1634       ScopeDIE->addChild(VariableDIE);
1635   }
1636
1637   // Add nested scopes.
1638   const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1639   for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1640     // Define the Scope debug information entry.
1641     DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1642     if (NestedDIE)
1643       ScopeDIE->addChild(NestedDIE);
1644   }
1645
1646   if (DS.isSubprogram())
1647     addPubTypes(DISubprogram(DS.getNode()));
1648
1649  return ScopeDIE;
1650 }
1651
1652 /// GetOrCreateSourceID - Look up the source id with the given directory and
1653 /// source file names. If none currently exists, create a new id and insert it
1654 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1655 /// maps as well.
1656 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1657   unsigned DId;
1658   StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1659   if (DI != DirectoryIdMap.end()) {
1660     DId = DI->getValue();
1661   } else {
1662     DId = DirectoryNames.size() + 1;
1663     DirectoryIdMap[DirName] = DId;
1664     DirectoryNames.push_back(DirName);
1665   }
1666
1667   unsigned FId;
1668   StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1669   if (FI != SourceFileIdMap.end()) {
1670     FId = FI->getValue();
1671   } else {
1672     FId = SourceFileNames.size() + 1;
1673     SourceFileIdMap[FileName] = FId;
1674     SourceFileNames.push_back(FileName);
1675   }
1676
1677   DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1678     SourceIdMap.find(std::make_pair(DId, FId));
1679   if (SI != SourceIdMap.end())
1680     return SI->second;
1681
1682   unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
1683   SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1684   SourceIds.push_back(std::make_pair(DId, FId));
1685
1686   return SrcId;
1687 }
1688
1689 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1690 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1691   DIE *NDie = ModuleCU->getDIE(NS.getNode());
1692   if (NDie)
1693     return NDie;
1694   NDie = new DIE(dwarf::DW_TAG_namespace);
1695   ModuleCU->insertDIE(NS.getNode(), NDie);
1696   if (!NS.getName().empty())
1697     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1698   addSourceLine(NDie, &NS);
1699   addToContextOwner(NDie, NS.getContext());
1700   return NDie;
1701 }
1702
1703 void DwarfDebug::constructCompileUnit(MDNode *N) {
1704   DICompileUnit DIUnit(N);
1705   // Use first compile unit marked as isMain as the compile unit for this
1706   // module.
1707   if (ModuleCU || !DIUnit.isMain())
1708     return;
1709   StringRef FN = DIUnit.getFilename();
1710   StringRef Dir = DIUnit.getDirectory();
1711   unsigned ID = GetOrCreateSourceID(Dir, FN);
1712
1713   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1714   addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1715             DIUnit.getProducer());
1716   addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1717           DIUnit.getLanguage());
1718   addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1719   addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1720   addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1721            Asm->GetTempSymbol("text_end"));
1722   // DW_AT_stmt_list is a offset of line number information for this
1723   // compile unit in debug_line section. It is always zero when only one
1724   // compile unit is emitted in one object file.
1725   addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1726
1727   if (!Dir.empty())
1728     addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1729   if (DIUnit.isOptimized())
1730     addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1731
1732   StringRef Flags = DIUnit.getFlags();
1733   if (!Flags.empty())
1734     addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1735
1736   unsigned RVer = DIUnit.getRunTimeVersion();
1737   if (RVer)
1738     addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1739             dwarf::DW_FORM_data1, RVer);
1740
1741   assert(!ModuleCU &&
1742          "ModuleCU assigned since the top of constructCompileUnit");
1743   ModuleCU = new CompileUnit(ID, Die);
1744 }
1745
1746 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1747   DIGlobalVariable DI_GV(N);
1748
1749   // If debug information is malformed then ignore it.
1750   if (DI_GV.Verify() == false)
1751     return;
1752
1753   // Check for pre-existence.
1754   if (ModuleCU->getDIE(DI_GV.getNode()))
1755     return;
1756
1757   DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1758   if (!VariableDie)
1759     return;
1760
1761   // Add to map.
1762   ModuleCU->insertDIE(N, VariableDie);
1763
1764   // Add to context owner.
1765   DIDescriptor GVContext = DI_GV.getContext();
1766   // Do not create specification DIE if context is either compile unit
1767   // or a subprogram.
1768   if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1769       !GVContext.isFile() && !GVContext.isSubprogram()) {
1770     // Create specification DIE.
1771     DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1772     addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1773                 dwarf::DW_FORM_ref4, VariableDie);
1774     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1775     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1776     addLabel(Block, 0, dwarf::DW_FORM_udata,
1777              Asm->Mang->getSymbol(DI_GV.getGlobal()));
1778     addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1779     addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1780     ModuleCU->addDie(VariableSpecDIE);
1781   } else {
1782     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1783     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1784     addLabel(Block, 0, dwarf::DW_FORM_udata,
1785              Asm->Mang->getSymbol(DI_GV.getGlobal()));
1786     addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1787   }
1788   addToContextOwner(VariableDie, GVContext);
1789
1790   // Expose as global. FIXME - need to check external flag.
1791   ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1792
1793   DIType GTy = DI_GV.getType();
1794   if (GTy.isCompositeType() && !GTy.getName().empty()) {
1795     DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1796     assert(Entry && "Missing global type!");
1797     ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1798   }
1799   return;
1800 }
1801
1802 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1803   DISubprogram SP(N);
1804
1805   // Check for pre-existence.
1806   if (ModuleCU->getDIE(N))
1807     return;
1808
1809   if (!SP.isDefinition())
1810     // This is a method declaration which will be handled while constructing
1811     // class type.
1812     return;
1813
1814   DIE *SubprogramDie = createSubprogramDIE(SP);
1815
1816   // Add to map.
1817   ModuleCU->insertDIE(N, SubprogramDie);
1818
1819   // Add to context owner.
1820   addToContextOwner(SubprogramDie, SP.getContext());
1821
1822   // Expose as global.
1823   ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1824
1825   return;
1826 }
1827
1828 /// beginModule - Emit all Dwarf sections that should come prior to the
1829 /// content. Create global DIEs and emit initial debug info sections.
1830 /// This is inovked by the target AsmPrinter.
1831 void DwarfDebug::beginModule(Module *M) {
1832   TimeRegion Timer(DebugTimer);
1833
1834   DebugInfoFinder DbgFinder;
1835   DbgFinder.processModule(*M);
1836
1837   bool HasDebugInfo = false;
1838
1839   // Scan all the compile-units to see if there are any marked as the main unit.
1840   // if not, we do not generate debug info.
1841   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1842        E = DbgFinder.compile_unit_end(); I != E; ++I) {
1843     if (DICompileUnit(*I).isMain()) {
1844       HasDebugInfo = true;
1845       break;
1846     }
1847   }
1848
1849   if (!HasDebugInfo) return;
1850
1851   // Tell MMI that we have debug info.
1852   MMI->setDebugInfoAvailability(true);
1853
1854   // Emit initial sections.
1855   EmitSectionLabels();
1856
1857   // Create all the compile unit DIEs.
1858   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1859          E = DbgFinder.compile_unit_end(); I != E; ++I)
1860     constructCompileUnit(*I);
1861
1862   // Create DIEs for each subprogram.
1863   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1864          E = DbgFinder.subprogram_end(); I != E; ++I)
1865     constructSubprogramDIE(*I);
1866
1867   // Create DIEs for each global variable.
1868   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1869          E = DbgFinder.global_variable_end(); I != E; ++I)
1870     constructGlobalVariableDIE(*I);
1871
1872   // Prime section data.
1873   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1874
1875   // Print out .file directives to specify files for .loc directives. These are
1876   // printed out early so that they precede any .loc directives.
1877   if (Asm->MAI->hasDotLocAndDotFile()) {
1878     for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1879       // Remember source id starts at 1.
1880       std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1881       // FIXME: don't use sys::path for this!  This should not depend on the
1882       // host.
1883       sys::Path FullPath(getSourceDirectoryName(Id.first));
1884       bool AppendOk =
1885         FullPath.appendComponent(getSourceFileName(Id.second));
1886       assert(AppendOk && "Could not append filename to directory!");
1887       AppendOk = false;
1888       Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1889     }
1890   }
1891 }
1892
1893 /// endModule - Emit all Dwarf sections that should come after the content.
1894 ///
1895 void DwarfDebug::endModule() {
1896   if (!ModuleCU)
1897     return;
1898
1899   TimeRegion Timer(DebugTimer);
1900
1901   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1902   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1903          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1904     DIE *ISP = *AI;
1905     addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1906   }
1907
1908   // Insert top level DIEs.
1909   for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1910          TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1911     ModuleCU->getCUDie()->addChild(*TI);
1912
1913   for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1914          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1915     DIE *SPDie = CI->first;
1916     MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1917     if (!N) continue;
1918     DIE *NDie = ModuleCU->getDIE(N);
1919     if (!NDie) continue;
1920     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1921     // FIXME - This is not the correct approach.
1922     //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
1923   }
1924
1925   // Standard sections final addresses.
1926   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1927   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1928   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1929   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1930
1931   // End text sections.
1932   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1933     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1934     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1935   }
1936
1937   // Emit common frame information.
1938   emitCommonDebugFrame();
1939
1940   // Emit function debug frame information
1941   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1942          E = DebugFrames.end(); I != E; ++I)
1943     emitFunctionDebugFrame(*I);
1944
1945   // Compute DIE offsets and sizes.
1946   computeSizeAndOffsets();
1947
1948   // Emit all the DIEs into a debug info section
1949   emitDebugInfo();
1950
1951   // Corresponding abbreviations into a abbrev section.
1952   emitAbbreviations();
1953
1954   // Emit source line correspondence into a debug line section.
1955   emitDebugLines();
1956
1957   // Emit info into a debug pubnames section.
1958   emitDebugPubNames();
1959
1960   // Emit info into a debug pubtypes section.
1961   emitDebugPubTypes();
1962
1963   // Emit info into a debug loc section.
1964   emitDebugLoc();
1965
1966   // Emit info into a debug aranges section.
1967   EmitDebugARanges();
1968
1969   // Emit info into a debug ranges section.
1970   emitDebugRanges();
1971
1972   // Emit info into a debug macinfo section.
1973   emitDebugMacInfo();
1974
1975   // Emit inline info.
1976   emitDebugInlineInfo();
1977
1978   // Emit info into a debug str section.
1979   emitDebugStr();
1980
1981   delete ModuleCU;
1982   ModuleCU = NULL;  // Reset for the next Module, if any.
1983 }
1984
1985 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1986 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1987                                               unsigned FrameIdx,
1988                                               DebugLoc ScopeLoc) {
1989
1990   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1991   if (AbsDbgVariable)
1992     return AbsDbgVariable;
1993
1994   LLVMContext &Ctx = Var.getNode()->getContext();
1995   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1996   if (!Scope)
1997     return NULL;
1998
1999   AbsDbgVariable = new DbgVariable(Var, FrameIdx,
2000                                    NULL /* No more-abstract variable*/);
2001   Scope->addVariable(AbsDbgVariable);
2002   AbstractVariables[Var.getNode()] = AbsDbgVariable;
2003   return AbsDbgVariable;
2004 }
2005
2006 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2007 /// FIXME : Refactor findAbstractVariable.
2008 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2009                                               const MachineInstr *MI,
2010                                               DebugLoc ScopeLoc) {
2011
2012   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
2013   if (AbsDbgVariable)
2014     return AbsDbgVariable;
2015
2016   LLVMContext &Ctx = Var.getNode()->getContext();
2017   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2018   if (!Scope)
2019     return NULL;
2020
2021   AbsDbgVariable = new DbgVariable(Var, MI,
2022                                    NULL /* No more-abstract variable*/);
2023   Scope->addVariable(AbsDbgVariable);
2024   AbstractVariables[Var.getNode()] = AbsDbgVariable;
2025   DbgValueStartMap[MI] = AbsDbgVariable;
2026   return AbsDbgVariable;
2027 }
2028
2029 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2030 void DwarfDebug::collectVariableInfo() {
2031   const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2032
2033   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2034   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2035          VE = VMap.end(); VI != VE; ++VI) {
2036     MDNode *Var = VI->first;
2037     if (!Var) continue;
2038     DIVariable DV(Var);
2039     const std::pair<unsigned, DebugLoc> &VP = VI->second;
2040
2041     DbgScope *Scope = 0;
2042     if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2043       Scope = ConcreteScopes.lookup(IA);
2044     if (Scope == 0)
2045       Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2046
2047     // If variable scope is not found then skip this variable.
2048     if (Scope == 0)
2049       continue;
2050
2051     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2052     DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2053     Scope->addVariable(RegVar);
2054   }
2055
2056   // Collect variable information from DBG_VALUE machine instructions;
2057   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2058        I != E; ++I) {
2059     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2060          II != IE; ++II) {
2061       const MachineInstr *MInsn = II;
2062       if (!MInsn->isDebugValue())
2063         continue;
2064
2065       // FIXME : Lift this restriction.
2066       if (MInsn->getNumOperands() != 3)
2067         continue;
2068       DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2069                                                 - 1).getMetadata()));
2070       if (DV.getTag() == dwarf::DW_TAG_arg_variable)  {
2071         // FIXME Handle inlined subroutine arguments.
2072         DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2073         CurrentFnDbgScope->addVariable(ArgVar);
2074         DbgValueStartMap[MInsn] = ArgVar;
2075         continue;
2076       }
2077
2078       DebugLoc DL = MInsn->getDebugLoc();
2079       if (DL.isUnknown()) continue;
2080       DbgScope *Scope = 0;
2081       if (MDNode *IA = DL.getInlinedAt(Ctx))
2082         Scope = ConcreteScopes.lookup(IA);
2083       if (Scope == 0)
2084         Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2085
2086       // If variable scope is not found then skip this variable.
2087       if (Scope == 0)
2088         continue;
2089
2090       DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2091       DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2092       DbgValueStartMap[MInsn] = RegVar;
2093       Scope->addVariable(RegVar);
2094     }
2095   }
2096 }
2097
2098 /// beginScope - Process beginning of a scope.
2099 void DwarfDebug::beginScope(const MachineInstr *MI) {
2100   // Check location.
2101   DebugLoc DL = MI->getDebugLoc();
2102   if (DL.isUnknown())
2103     return;
2104
2105   // Check and update last known location info.
2106   if (DL == PrevInstLoc)
2107     return;
2108
2109   MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2110
2111   // FIXME: Should only verify each scope once!
2112   if (!DIScope(Scope).Verify())
2113     return;
2114
2115   // DBG_VALUE instruction establishes new value.
2116   if (MI->isDebugValue()) {
2117     DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2118       = DbgValueStartMap.find(MI);
2119     if (DI != DbgValueStartMap.end()) {
2120       MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2121       PrevInstLoc = DL;
2122       DI->second->setDbgValueLabel(Label);
2123     }
2124     return;
2125   }
2126
2127   // Emit a label to indicate location change. This is used for line
2128   // table even if this instruction does start a new scope.
2129   MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2130   PrevInstLoc = DL;
2131
2132   // update DbgScope if this instruction starts a new scope.
2133   InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2134   if (I == DbgScopeBeginMap.end())
2135     return;
2136
2137   ScopeVector &SD = I->second;
2138   for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2139        SDI != SDE; ++SDI)
2140     (*SDI)->setStartLabel(Label);
2141 }
2142
2143 /// endScope - Process end of a scope.
2144 void DwarfDebug::endScope(const MachineInstr *MI) {
2145   // Ignore DBG_VALUE instruction.
2146   if (MI->isDebugValue())
2147     return;
2148
2149   // Check location.
2150   DebugLoc DL = MI->getDebugLoc();
2151   if (DL.isUnknown())
2152     return;
2153
2154   // Emit a label and update DbgScope if this instruction ends a scope.
2155   InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2156   if (I == DbgScopeEndMap.end())
2157     return;
2158
2159   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2160   Asm->OutStreamer.EmitLabel(Label);
2161
2162   SmallVector<DbgScope*, 2> &SD = I->second;
2163   for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2164        SDI != SDE; ++SDI)
2165     (*SDI)->setEndLabel(Label);
2166   return;
2167 }
2168
2169 /// createDbgScope - Create DbgScope for the scope.
2170 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2171   if (!InlinedAt) {
2172     DbgScope *WScope = DbgScopeMap.lookup(Scope);
2173     if (WScope)
2174       return;
2175     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2176     DbgScopeMap.insert(std::make_pair(Scope, WScope));
2177     if (DIDescriptor(Scope).isLexicalBlock())
2178       createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2179     return;
2180   }
2181
2182   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2183   if (WScope)
2184     return;
2185
2186   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2187   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2188   DILocation DL(InlinedAt);
2189   createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2190 }
2191
2192 /// extractScopeInformation - Scan machine instructions in this function
2193 /// and collect DbgScopes. Return true, if at least one scope was found.
2194 bool DwarfDebug::extractScopeInformation() {
2195   // If scope information was extracted using .dbg intrinsics then there is not
2196   // any need to extract these information by scanning each instruction.
2197   if (!DbgScopeMap.empty())
2198     return false;
2199
2200   DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2201   unsigned MIIndex = 0;
2202   LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2203
2204   // Scan each instruction and create scopes. First build working set of scopes.
2205   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2206        I != E; ++I) {
2207     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2208          II != IE; ++II) {
2209       const MachineInstr *MInsn = II;
2210       // FIXME : Remove DBG_VALUE check.
2211       if (MInsn->isDebugValue()) continue;
2212       MIIndexMap[MInsn] = MIIndex++;
2213
2214       DebugLoc DL = MInsn->getDebugLoc();
2215       if (DL.isUnknown()) continue;
2216
2217       MDNode *Scope = DL.getScope(Ctx);
2218
2219       // There is no need to create another DIE for compile unit. For all
2220       // other scopes, create one DbgScope now. This will be translated
2221       // into a scope DIE at the end.
2222       if (DIScope(Scope).isCompileUnit()) continue;
2223       createDbgScope(Scope, DL.getInlinedAt(Ctx));
2224     }
2225   }
2226
2227
2228   // Build scope hierarchy using working set of scopes.
2229   for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2230        I != E; ++I) {
2231     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2232          II != IE; ++II) {
2233       const MachineInstr *MInsn = II;
2234       // FIXME : Remove DBG_VALUE check.
2235       if (MInsn->isDebugValue()) continue;
2236       DebugLoc DL = MInsn->getDebugLoc();
2237       if (DL.isUnknown()) continue;
2238
2239       MDNode *Scope = DL.getScope(Ctx);
2240       if (Scope == 0) continue;
2241
2242       // There is no need to create another DIE for compile unit. For all
2243       // other scopes, create one DbgScope now. This will be translated
2244       // into a scope DIE at the end.
2245       if (DIScope(Scope).isCompileUnit()) continue;
2246       DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2247       DScope->setLastInsn(MInsn);
2248     }
2249   }
2250
2251   if (!CurrentFnDbgScope)
2252     return false;
2253
2254   CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2255
2256   // Each scope has first instruction and last instruction to mark beginning
2257   // and end of a scope respectively. Create an inverse map that list scopes
2258   // starts (and ends) with an instruction. One instruction may start (or end)
2259   // multiple scopes. Ignore scopes that are not reachable.
2260   SmallVector<DbgScope *, 4> WorkList;
2261   WorkList.push_back(CurrentFnDbgScope);
2262   while (!WorkList.empty()) {
2263     DbgScope *S = WorkList.pop_back_val();
2264
2265     const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2266     if (!Children.empty())
2267       for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2268              SE = Children.end(); SI != SE; ++SI)
2269         WorkList.push_back(*SI);
2270
2271     if (S->isAbstractScope())
2272       continue;
2273     const MachineInstr *MI = S->getFirstInsn();
2274     assert(MI && "DbgScope does not have first instruction!");
2275
2276     InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2277     if (IDI != DbgScopeBeginMap.end())
2278       IDI->second.push_back(S);
2279     else
2280       DbgScopeBeginMap[MI].push_back(S);
2281
2282     MI = S->getLastInsn();
2283     assert(MI && "DbgScope does not have last instruction!");
2284     IDI = DbgScopeEndMap.find(MI);
2285     if (IDI != DbgScopeEndMap.end())
2286       IDI->second.push_back(S);
2287     else
2288       DbgScopeEndMap[MI].push_back(S);
2289   }
2290
2291   return !DbgScopeMap.empty();
2292 }
2293
2294 /// beginFunction - Gather pre-function debug information.  Assumes being
2295 /// emitted immediately after the function entry point.
2296 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2297   if (!MMI->hasDebugInfo()) return;
2298
2299   TimeRegion Timer(DebugTimer);
2300   if (!extractScopeInformation())
2301     return;
2302
2303   collectVariableInfo();
2304
2305   // Assumes in correct section after the entry point.
2306   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2307                                                 Asm->getFunctionNumber()));
2308
2309   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2310   // function.
2311   DebugLoc FDL = MF->getDefaultDebugLoc();
2312   if (FDL.isUnknown()) return;
2313
2314   MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2315
2316   DISubprogram SP = getDISubprogram(Scope);
2317   unsigned Line, Col;
2318   if (SP.Verify()) {
2319     Line = SP.getLineNumber();
2320     Col = 0;
2321   } else {
2322     Line = FDL.getLine();
2323     Col = FDL.getCol();
2324   }
2325
2326   recordSourceLine(Line, Col, Scope);
2327 }
2328
2329 /// endFunction - Gather and emit post-function debug information.
2330 ///
2331 void DwarfDebug::endFunction(const MachineFunction *MF) {
2332   if (!MMI->hasDebugInfo() ||
2333       DbgScopeMap.empty()) return;
2334
2335   TimeRegion Timer(DebugTimer);
2336
2337   if (CurrentFnDbgScope) {
2338     // Define end label for subprogram.
2339     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2340                                                   Asm->getFunctionNumber()));
2341
2342     // Get function line info.
2343     if (!Lines.empty()) {
2344       // Get section line info.
2345       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2346       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2347       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2348       // Append the function info to section info.
2349       SectionLineInfos.insert(SectionLineInfos.end(),
2350                               Lines.begin(), Lines.end());
2351     }
2352
2353     // Construct abstract scopes.
2354     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2355            AE = AbstractScopesList.end(); AI != AE; ++AI)
2356       constructScopeDIE(*AI);
2357
2358     constructScopeDIE(CurrentFnDbgScope);
2359
2360     DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2361                                                  MMI->getFrameMoves()));
2362   }
2363
2364   // Clear debug info
2365   CurrentFnDbgScope = NULL;
2366   DeleteContainerSeconds(DbgScopeMap);
2367   DbgScopeBeginMap.clear();
2368   DbgScopeEndMap.clear();
2369   DbgValueStartMap.clear();
2370   ConcreteScopes.clear();
2371   DeleteContainerSeconds(AbstractScopes);
2372   AbstractScopesList.clear();
2373   AbstractVariables.clear();
2374   Lines.clear();
2375 }
2376
2377 /// recordSourceLine - Register a source line with debug info. Returns the
2378 /// unique label that was emitted and which provides correspondence to
2379 /// the source line list.
2380 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2381   TimeRegion Timer(DebugTimer);
2382
2383   StringRef Dir;
2384   StringRef Fn;
2385
2386   DIDescriptor Scope(S);
2387   if (Scope.isCompileUnit()) {
2388     DICompileUnit CU(S);
2389     Dir = CU.getDirectory();
2390     Fn = CU.getFilename();
2391   } else if (Scope.isSubprogram()) {
2392     DISubprogram SP(S);
2393     Dir = SP.getDirectory();
2394     Fn = SP.getFilename();
2395   } else if (Scope.isLexicalBlock()) {
2396     DILexicalBlock DB(S);
2397     Dir = DB.getDirectory();
2398     Fn = DB.getFilename();
2399   } else
2400     assert(0 && "Unexpected scope info");
2401
2402   unsigned Src = GetOrCreateSourceID(Dir, Fn);
2403   MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2404   Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2405
2406   Asm->OutStreamer.EmitLabel(Label);
2407   return Label;
2408 }
2409
2410 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2411 /// timed. Look up the source id with the given directory and source file
2412 /// names. If none currently exists, create a new id and insert it in the
2413 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2414 /// well.
2415 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2416                                          const std::string &FileName) {
2417   TimeRegion Timer(DebugTimer);
2418   return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2419 }
2420
2421 //===----------------------------------------------------------------------===//
2422 // Emit Methods
2423 //===----------------------------------------------------------------------===//
2424
2425 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2426 ///
2427 unsigned
2428 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2429   // Get the children.
2430   const std::vector<DIE *> &Children = Die->getChildren();
2431
2432   // If not last sibling and has children then add sibling offset attribute.
2433   if (!Last && !Children.empty())
2434     Die->addSiblingOffset(DIEValueAllocator);
2435
2436   // Record the abbreviation.
2437   assignAbbrevNumber(Die->getAbbrev());
2438
2439   // Get the abbreviation for this DIE.
2440   unsigned AbbrevNumber = Die->getAbbrevNumber();
2441   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2442
2443   // Set DIE offset
2444   Die->setOffset(Offset);
2445
2446   // Start the size with the size of abbreviation code.
2447   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2448
2449   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2450   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2451
2452   // Size the DIE attribute values.
2453   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2454     // Size attribute value.
2455     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2456
2457   // Size the DIE children if any.
2458   if (!Children.empty()) {
2459     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2460            "Children flag not set");
2461
2462     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2463       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2464
2465     // End of children marker.
2466     Offset += sizeof(int8_t);
2467   }
2468
2469   Die->setSize(Offset - Die->getOffset());
2470   return Offset;
2471 }
2472
2473 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2474 ///
2475 void DwarfDebug::computeSizeAndOffsets() {
2476   // Compute size of compile unit header.
2477   static unsigned Offset =
2478     sizeof(int32_t) + // Length of Compilation Unit Info
2479     sizeof(int16_t) + // DWARF version number
2480     sizeof(int32_t) + // Offset Into Abbrev. Section
2481     sizeof(int8_t);   // Pointer Size (in bytes)
2482
2483   computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2484   CompileUnitOffsets[ModuleCU] = 0;
2485 }
2486
2487 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2488 /// temporary label to it if SymbolStem is specified.
2489 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2490                                 const char *SymbolStem = 0) {
2491   Asm->OutStreamer.SwitchSection(Section);
2492   if (!SymbolStem) return 0;
2493
2494   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2495   Asm->OutStreamer.EmitLabel(TmpSym);
2496   return TmpSym;
2497 }
2498
2499 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2500 /// the start of each one.
2501 void DwarfDebug::EmitSectionLabels() {
2502   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2503
2504   // Dwarf sections base addresses.
2505   if (Asm->MAI->doesDwarfRequireFrameSection()) {
2506     DwarfFrameSectionSym =
2507       EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2508    }
2509
2510   DwarfInfoSectionSym =
2511     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2512   DwarfAbbrevSectionSym =
2513     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2514   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2515
2516   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2517     EmitSectionSym(Asm, MacroInfo);
2518
2519   EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2520   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2521   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2522   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2523   DwarfStrSectionSym =
2524     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2525   EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
2526
2527   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2528   EmitSectionSym(Asm, TLOF.getDataSection());
2529 }
2530
2531 /// emitDIE - Recusively Emits a debug information entry.
2532 ///
2533 void DwarfDebug::emitDIE(DIE *Die) {
2534   // Get the abbreviation for this DIE.
2535   unsigned AbbrevNumber = Die->getAbbrevNumber();
2536   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2537
2538   // Emit the code (index) for the abbreviation.
2539   if (Asm->isVerbose())
2540     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2541                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2542                                 Twine::utohexstr(Die->getSize()) + " " +
2543                                 dwarf::TagString(Abbrev->getTag()));
2544   Asm->EmitULEB128(AbbrevNumber);
2545
2546   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2547   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2548
2549   // Emit the DIE attribute values.
2550   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2551     unsigned Attr = AbbrevData[i].getAttribute();
2552     unsigned Form = AbbrevData[i].getForm();
2553     assert(Form && "Too many attributes for DIE (check abbreviation)");
2554
2555     if (Asm->isVerbose())
2556       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2557
2558     switch (Attr) {
2559     case dwarf::DW_AT_sibling:
2560       Asm->EmitInt32(Die->getSiblingOffset());
2561       break;
2562     case dwarf::DW_AT_abstract_origin: {
2563       DIEEntry *E = cast<DIEEntry>(Values[i]);
2564       DIE *Origin = E->getEntry();
2565       unsigned Addr = Origin->getOffset();
2566       Asm->EmitInt32(Addr);
2567       break;
2568     }
2569     default:
2570       // Emit an attribute using the defined form.
2571       Values[i]->EmitValue(Asm, Form);
2572       break;
2573     }
2574   }
2575
2576   // Emit the DIE children if any.
2577   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2578     const std::vector<DIE *> &Children = Die->getChildren();
2579
2580     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2581       emitDIE(Children[j]);
2582
2583     if (Asm->isVerbose())
2584       Asm->OutStreamer.AddComment("End Of Children Mark");
2585     Asm->EmitInt8(0);
2586   }
2587 }
2588
2589 /// emitDebugInfo - Emit the debug info section.
2590 ///
2591 void DwarfDebug::emitDebugInfo() {
2592   // Start debug info section.
2593   Asm->OutStreamer.SwitchSection(
2594                             Asm->getObjFileLowering().getDwarfInfoSection());
2595   DIE *Die = ModuleCU->getCUDie();
2596
2597   // Emit the compile units header.
2598   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2599                                                 ModuleCU->getID()));
2600
2601   // Emit size of content not including length itself
2602   unsigned ContentSize = Die->getSize() +
2603     sizeof(int16_t) + // DWARF version number
2604     sizeof(int32_t) + // Offset Into Abbrev. Section
2605     sizeof(int8_t) +  // Pointer Size (in bytes)
2606     sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2607
2608   Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2609   Asm->EmitInt32(ContentSize);
2610   Asm->OutStreamer.AddComment("DWARF version number");
2611   Asm->EmitInt16(dwarf::DWARF_VERSION);
2612   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2613   Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2614                          DwarfAbbrevSectionSym);
2615   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2616   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2617
2618   emitDIE(Die);
2619   // FIXME - extra padding for gdb bug.
2620   Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2621   Asm->EmitInt8(0);
2622   Asm->EmitInt8(0);
2623   Asm->EmitInt8(0);
2624   Asm->EmitInt8(0);
2625   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2626 }
2627
2628 /// emitAbbreviations - Emit the abbreviation section.
2629 ///
2630 void DwarfDebug::emitAbbreviations() const {
2631   // Check to see if it is worth the effort.
2632   if (!Abbreviations.empty()) {
2633     // Start the debug abbrev section.
2634     Asm->OutStreamer.SwitchSection(
2635                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2636
2637     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2638
2639     // For each abbrevation.
2640     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2641       // Get abbreviation data
2642       const DIEAbbrev *Abbrev = Abbreviations[i];
2643
2644       // Emit the abbrevations code (base 1 index.)
2645       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2646
2647       // Emit the abbreviations data.
2648       Abbrev->Emit(Asm);
2649     }
2650
2651     // Mark end of abbreviations.
2652     Asm->EmitULEB128(0, "EOM(3)");
2653
2654     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2655   }
2656 }
2657
2658 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2659 /// the line matrix.
2660 ///
2661 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2662   // Define last address of section.
2663   Asm->OutStreamer.AddComment("Extended Op");
2664   Asm->EmitInt8(0);
2665
2666   Asm->OutStreamer.AddComment("Op size");
2667   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2668   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2669   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2670
2671   Asm->OutStreamer.AddComment("Section end label");
2672
2673   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2674                                    Asm->getTargetData().getPointerSize(),
2675                                    0/*AddrSpace*/);
2676
2677   // Mark end of matrix.
2678   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2679   Asm->EmitInt8(0);
2680   Asm->EmitInt8(1);
2681   Asm->EmitInt8(1);
2682 }
2683
2684 /// emitDebugLines - Emit source line information.
2685 ///
2686 void DwarfDebug::emitDebugLines() {
2687   // If the target is using .loc/.file, the assembler will be emitting the
2688   // .debug_line table automatically.
2689   if (Asm->MAI->hasDotLocAndDotFile())
2690     return;
2691
2692   // Minimum line delta, thus ranging from -10..(255-10).
2693   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2694   // Maximum line delta, thus ranging from -10..(255-10).
2695   const int MaxLineDelta = 255 + MinLineDelta;
2696
2697   // Start the dwarf line section.
2698   Asm->OutStreamer.SwitchSection(
2699                             Asm->getObjFileLowering().getDwarfLineSection());
2700
2701   // Construct the section header.
2702   Asm->OutStreamer.AddComment("Length of Source Line Info");
2703   Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2704                            Asm->GetTempSymbol("line_begin"), 4);
2705   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2706
2707   Asm->OutStreamer.AddComment("DWARF version number");
2708   Asm->EmitInt16(dwarf::DWARF_VERSION);
2709
2710   Asm->OutStreamer.AddComment("Prolog Length");
2711   Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2712                            Asm->GetTempSymbol("line_prolog_begin"), 4);
2713   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2714
2715   Asm->OutStreamer.AddComment("Minimum Instruction Length");
2716   Asm->EmitInt8(1);
2717   Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2718   Asm->EmitInt8(1);
2719   Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2720   Asm->EmitInt8(MinLineDelta);
2721   Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2722   Asm->EmitInt8(MaxLineDelta);
2723   Asm->OutStreamer.AddComment("Special Opcode Base");
2724   Asm->EmitInt8(-MinLineDelta);
2725
2726   // Line number standard opcode encodings argument count
2727   Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2728   Asm->EmitInt8(0);
2729   Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2730   Asm->EmitInt8(1);
2731   Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2732   Asm->EmitInt8(1);
2733   Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2734   Asm->EmitInt8(1);
2735   Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2736   Asm->EmitInt8(1);
2737   Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2738   Asm->EmitInt8(0);
2739   Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2740   Asm->EmitInt8(0);
2741   Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2742   Asm->EmitInt8(0);
2743   Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2744   Asm->EmitInt8(1);
2745
2746   // Emit directories.
2747   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2748     const std::string &Dir = getSourceDirectoryName(DI);
2749     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2750     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2751   }
2752
2753   Asm->OutStreamer.AddComment("End of directories");
2754   Asm->EmitInt8(0);
2755
2756   // Emit files.
2757   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2758     // Remember source id starts at 1.
2759     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2760     const std::string &FN = getSourceFileName(Id.second);
2761     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2762     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2763
2764     Asm->EmitULEB128(Id.first, "Directory #");
2765     Asm->EmitULEB128(0, "Mod date");
2766     Asm->EmitULEB128(0, "File size");
2767   }
2768
2769   Asm->OutStreamer.AddComment("End of files");
2770   Asm->EmitInt8(0);
2771
2772   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2773
2774   // A sequence for each text section.
2775   unsigned SecSrcLinesSize = SectionSourceLines.size();
2776
2777   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2778     // Isolate current sections line info.
2779     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2780
2781     // Dwarf assumes we start with first line of first source file.
2782     unsigned Source = 1;
2783     unsigned Line = 1;
2784
2785     // Construct rows of the address, source, line, column matrix.
2786     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2787       const SrcLineInfo &LineInfo = LineInfos[i];
2788       MCSymbol *Label = LineInfo.getLabel();
2789       if (!Label->isDefined()) continue; // Not emitted, in dead code.
2790
2791       if (LineInfo.getLine() == 0) continue;
2792
2793       if (Asm->isVerbose()) {
2794         std::pair<unsigned, unsigned> SrcID =
2795           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2796         Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2797                                     "/" +
2798                                     Twine(getSourceFileName(SrcID.second)) +
2799                                     ":" + Twine(LineInfo.getLine()));
2800       }
2801
2802       // Define the line address.
2803       Asm->OutStreamer.AddComment("Extended Op");
2804       Asm->EmitInt8(0);
2805       Asm->OutStreamer.AddComment("Op size");
2806       Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2807
2808       Asm->OutStreamer.AddComment("DW_LNE_set_address");
2809       Asm->EmitInt8(dwarf::DW_LNE_set_address);
2810
2811       Asm->OutStreamer.AddComment("Location label");
2812       Asm->OutStreamer.EmitSymbolValue(Label,
2813                                        Asm->getTargetData().getPointerSize(),
2814                                        0/*AddrSpace*/);
2815
2816       // If change of source, then switch to the new source.
2817       if (Source != LineInfo.getSourceID()) {
2818         Source = LineInfo.getSourceID();
2819         Asm->OutStreamer.AddComment("DW_LNS_set_file");
2820         Asm->EmitInt8(dwarf::DW_LNS_set_file);
2821         Asm->EmitULEB128(Source, "New Source");
2822       }
2823
2824       // If change of line.
2825       if (Line != LineInfo.getLine()) {
2826         // Determine offset.
2827         int Offset = LineInfo.getLine() - Line;
2828         int Delta = Offset - MinLineDelta;
2829
2830         // Update line.
2831         Line = LineInfo.getLine();
2832
2833         // If delta is small enough and in range...
2834         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2835           // ... then use fast opcode.
2836           Asm->OutStreamer.AddComment("Line Delta");
2837           Asm->EmitInt8(Delta - MinLineDelta);
2838         } else {
2839           // ... otherwise use long hand.
2840           Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2841           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2842           Asm->EmitSLEB128(Offset, "Line Offset");
2843           Asm->OutStreamer.AddComment("DW_LNS_copy");
2844           Asm->EmitInt8(dwarf::DW_LNS_copy);
2845         }
2846       } else {
2847         // Copy the previous row (different address or source)
2848         Asm->OutStreamer.AddComment("DW_LNS_copy");
2849         Asm->EmitInt8(dwarf::DW_LNS_copy);
2850       }
2851     }
2852
2853     emitEndOfLineMatrix(j + 1);
2854   }
2855
2856   if (SecSrcLinesSize == 0)
2857     // Because we're emitting a debug_line section, we still need a line
2858     // table. The linker and friends expect it to exist. If there's nothing to
2859     // put into it, emit an empty table.
2860     emitEndOfLineMatrix(1);
2861
2862   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2863 }
2864
2865 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2866 ///
2867 void DwarfDebug::emitCommonDebugFrame() {
2868   if (!Asm->MAI->doesDwarfRequireFrameSection())
2869     return;
2870
2871   int stackGrowth = Asm->getTargetData().getPointerSize();
2872   if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2873       TargetFrameInfo::StackGrowsDown)
2874     stackGrowth *= -1;
2875
2876   // Start the dwarf frame section.
2877   Asm->OutStreamer.SwitchSection(
2878                               Asm->getObjFileLowering().getDwarfFrameSection());
2879
2880   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2881   Asm->OutStreamer.AddComment("Length of Common Information Entry");
2882   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2883                            Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2884
2885   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2886   Asm->OutStreamer.AddComment("CIE Identifier Tag");
2887   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2888   Asm->OutStreamer.AddComment("CIE Version");
2889   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2890   Asm->OutStreamer.AddComment("CIE Augmentation");
2891   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2892   Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2893   Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2894   Asm->OutStreamer.AddComment("CIE RA Column");
2895   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2896   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2897
2898   std::vector<MachineMove> Moves;
2899   RI->getInitialFrameState(Moves);
2900
2901   Asm->EmitFrameMoves(Moves, 0, false);
2902
2903   Asm->EmitAlignment(2, 0, 0, false);
2904   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2905 }
2906
2907 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2908 /// section.
2909 void DwarfDebug::
2910 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2911   if (!Asm->MAI->doesDwarfRequireFrameSection())
2912     return;
2913
2914   // Start the dwarf frame section.
2915   Asm->OutStreamer.SwitchSection(
2916                               Asm->getObjFileLowering().getDwarfFrameSection());
2917
2918   Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2919   MCSymbol *DebugFrameBegin =
2920     Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2921   MCSymbol *DebugFrameEnd =
2922     Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2923   Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2924
2925   Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2926
2927   Asm->OutStreamer.AddComment("FDE CIE offset");
2928   Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2929                          DwarfFrameSectionSym);
2930
2931   Asm->OutStreamer.AddComment("FDE initial location");
2932   MCSymbol *FuncBeginSym =
2933     Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2934   Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2935                                    Asm->getTargetData().getPointerSize(),
2936                                    0/*AddrSpace*/);
2937
2938
2939   Asm->OutStreamer.AddComment("FDE address range");
2940   Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2941                            FuncBeginSym, Asm->getTargetData().getPointerSize());
2942
2943   Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2944
2945   Asm->EmitAlignment(2, 0, 0, false);
2946   Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2947 }
2948
2949 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2950 ///
2951 void DwarfDebug::emitDebugPubNames() {
2952   // Start the dwarf pubnames section.
2953   Asm->OutStreamer.SwitchSection(
2954                           Asm->getObjFileLowering().getDwarfPubNamesSection());
2955
2956   Asm->OutStreamer.AddComment("Length of Public Names Info");
2957   Asm->EmitLabelDifference(
2958                  Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2959                  Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2960
2961   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2962                                                 ModuleCU->getID()));
2963
2964   Asm->OutStreamer.AddComment("DWARF Version");
2965   Asm->EmitInt16(dwarf::DWARF_VERSION);
2966
2967   Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2968   Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2969                          DwarfInfoSectionSym);
2970
2971   Asm->OutStreamer.AddComment("Compilation Unit Length");
2972   Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2973                            Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2974                            4);
2975
2976   const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2977   for (StringMap<DIE*>::const_iterator
2978          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2979     const char *Name = GI->getKeyData();
2980     DIE *Entity = GI->second;
2981
2982     Asm->OutStreamer.AddComment("DIE offset");
2983     Asm->EmitInt32(Entity->getOffset());
2984
2985     if (Asm->isVerbose())
2986       Asm->OutStreamer.AddComment("External Name");
2987     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2988   }
2989
2990   Asm->OutStreamer.AddComment("End Mark");
2991   Asm->EmitInt32(0);
2992   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2993                                                 ModuleCU->getID()));
2994 }
2995
2996 void DwarfDebug::emitDebugPubTypes() {
2997   // Start the dwarf pubnames section.
2998   Asm->OutStreamer.SwitchSection(
2999                           Asm->getObjFileLowering().getDwarfPubTypesSection());
3000   Asm->OutStreamer.AddComment("Length of Public Types Info");
3001   Asm->EmitLabelDifference(
3002                     Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
3003                     Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
3004
3005   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3006                                                 ModuleCU->getID()));
3007
3008   if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3009   Asm->EmitInt16(dwarf::DWARF_VERSION);
3010
3011   Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
3012   Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3013                          DwarfInfoSectionSym);
3014
3015   Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
3016   Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
3017                            Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
3018                            4);
3019
3020   const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
3021   for (StringMap<DIE*>::const_iterator
3022          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3023     const char *Name = GI->getKeyData();
3024     DIE * Entity = GI->second;
3025
3026     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3027     Asm->EmitInt32(Entity->getOffset());
3028
3029     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3030     Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3031   }
3032
3033   Asm->OutStreamer.AddComment("End Mark");
3034   Asm->EmitInt32(0);
3035   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3036                                                 ModuleCU->getID()));
3037 }
3038
3039 /// emitDebugStr - Emit visible names into a debug str section.
3040 ///
3041 void DwarfDebug::emitDebugStr() {
3042   // Check to see if it is worth the effort.
3043   if (StringPool.empty()) return;
3044
3045   // Start the dwarf str section.
3046   Asm->OutStreamer.SwitchSection(
3047                                 Asm->getObjFileLowering().getDwarfStrSection());
3048
3049   // Get all of the string pool entries and put them in an array by their ID so
3050   // we can sort them.
3051   SmallVector<std::pair<unsigned,
3052       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3053
3054   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3055        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3056     Entries.push_back(std::make_pair(I->second.second, &*I));
3057
3058   array_pod_sort(Entries.begin(), Entries.end());
3059
3060   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3061     // Emit a label for reference from debug information entries.
3062     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3063
3064     // Emit the string itself.
3065     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3066   }
3067 }
3068
3069 /// emitDebugLoc - Emit visible names into a debug loc section.
3070 ///
3071 void DwarfDebug::emitDebugLoc() {
3072   // Start the dwarf loc section.
3073   Asm->OutStreamer.SwitchSection(
3074                               Asm->getObjFileLowering().getDwarfLocSection());
3075 }
3076
3077 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3078 ///
3079 void DwarfDebug::EmitDebugARanges() {
3080   // Start the dwarf aranges section.
3081   Asm->OutStreamer.SwitchSection(
3082                           Asm->getObjFileLowering().getDwarfARangesSection());
3083 }
3084
3085 /// emitDebugRanges - Emit visible names into a debug ranges section.
3086 ///
3087 void DwarfDebug::emitDebugRanges() {
3088   // Start the dwarf ranges section.
3089   Asm->OutStreamer.SwitchSection(
3090                             Asm->getObjFileLowering().getDwarfRangesSection());
3091 }
3092
3093 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3094 ///
3095 void DwarfDebug::emitDebugMacInfo() {
3096   if (const MCSection *LineInfo =
3097       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3098     // Start the dwarf macinfo section.
3099     Asm->OutStreamer.SwitchSection(LineInfo);
3100   }
3101 }
3102
3103 /// emitDebugInlineInfo - Emit inline info using following format.
3104 /// Section Header:
3105 /// 1. length of section
3106 /// 2. Dwarf version number
3107 /// 3. address size.
3108 ///
3109 /// Entries (one "entry" for each function that was inlined):
3110 ///
3111 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3112 ///   otherwise offset into __debug_str for regular function name.
3113 /// 2. offset into __debug_str section for regular function name.
3114 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3115 /// instances for the function.
3116 ///
3117 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3118 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3119 /// __debug_info section, and the low_pc is the starting address for the
3120 /// inlining instance.
3121 void DwarfDebug::emitDebugInlineInfo() {
3122   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3123     return;
3124
3125   if (!ModuleCU)
3126     return;
3127
3128   Asm->OutStreamer.SwitchSection(
3129                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
3130
3131   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3132   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3133                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3134
3135   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3136
3137   Asm->OutStreamer.AddComment("Dwarf Version");
3138   Asm->EmitInt16(dwarf::DWARF_VERSION);
3139   Asm->OutStreamer.AddComment("Address Size (in bytes)");
3140   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3141
3142   for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3143          E = InlinedSPNodes.end(); I != E; ++I) {
3144
3145     MDNode *Node = *I;
3146     DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3147       = InlineInfo.find(Node);
3148     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3149     DISubprogram SP(Node);
3150     StringRef LName = SP.getLinkageName();
3151     StringRef Name = SP.getName();
3152
3153     Asm->OutStreamer.AddComment("MIPS linkage name");
3154     if (LName.empty()) {
3155       Asm->OutStreamer.EmitBytes(Name, 0);
3156       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3157     } else
3158       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3159                              DwarfStrSectionSym);
3160
3161     Asm->OutStreamer.AddComment("Function name");
3162     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3163     Asm->EmitULEB128(Labels.size(), "Inline count");
3164
3165     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3166            LE = Labels.end(); LI != LE; ++LI) {
3167       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3168       Asm->EmitInt32(LI->second->getOffset());
3169
3170       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3171       Asm->OutStreamer.EmitSymbolValue(LI->first,
3172                                        Asm->getTargetData().getPointerSize(),0);
3173     }
3174   }
3175
3176   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
3177 }