lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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