lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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