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