lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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