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