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