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     // FIXME - Dpatel - What is FunctionDbgScope ?
1326     if (!FunctionDbgScope)
1327       FunctionDbgScope = Slot;
1328
1329   return Slot;
1330 }
1331
1332
1333 /// getOrCreateScope - Returns the scope associated with the given descriptor.
1334 /// FIXME - Remove this method.
1335 DbgScope *DwarfDebug::getOrCreateScope(MDNode *N) {
1336   DbgScope *&Slot = DbgScopeMap[N];
1337   if (Slot) return Slot;
1338
1339   DbgScope *Parent = NULL;
1340   DILexicalBlock Block(N);
1341
1342   // Don't create a new scope if we already created one for an inlined function.
1343   DenseMap<const MDNode *, DbgScope *>::iterator
1344     II = AbstractInstanceRootMap.find(N);
1345   if (II != AbstractInstanceRootMap.end())
1346     return LexicalScopeStack.back();
1347
1348   if (!Block.isNull()) {
1349     DIDescriptor ParentDesc = Block.getContext();
1350     Parent =
1351       ParentDesc.isNull() ?  NULL : getOrCreateScope(ParentDesc.getNode());
1352   }
1353
1354   Slot = new DbgScope(Parent, DIDescriptor(N));
1355
1356   if (Parent)
1357     Parent->AddScope(Slot);
1358   else
1359     // First function is top level function.
1360     FunctionDbgScope = Slot;
1361
1362   return Slot;
1363 }
1364
1365 /// ConstructDbgScope - Construct the components of a scope.
1366 ///
1367 void DwarfDebug::ConstructDbgScope(DbgScope *ParentScope,
1368                                    unsigned ParentStartID,
1369                                    unsigned ParentEndID,
1370                                    DIE *ParentDie, CompileUnit *Unit) {
1371   // Add variables to scope.
1372   SmallVector<DbgVariable *, 8> &Variables = ParentScope->getVariables();
1373   for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1374     DIE *VariableDie = CreateDbgScopeVariable(Variables[i], Unit);
1375     if (VariableDie) ParentDie->AddChild(VariableDie);
1376   }
1377
1378   // Add concrete instances to scope.
1379   SmallVector<DbgConcreteScope *, 8> &ConcreteInsts =
1380     ParentScope->getConcreteInsts();
1381   for (unsigned i = 0, N = ConcreteInsts.size(); i < N; ++i) {
1382     DbgConcreteScope *ConcreteInst = ConcreteInsts[i];
1383     DIE *Die = ConcreteInst->getDie();
1384
1385     unsigned StartID = ConcreteInst->getStartLabelID();
1386     unsigned EndID = ConcreteInst->getEndLabelID();
1387
1388     // Add the scope bounds.
1389     if (StartID)
1390       AddLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1391                DWLabel("label", StartID));
1392     else
1393       AddLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1394                DWLabel("func_begin", SubprogramCount));
1395
1396     if (EndID)
1397       AddLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1398                DWLabel("label", EndID));
1399     else
1400       AddLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1401                DWLabel("func_end", SubprogramCount));
1402
1403     ParentDie->AddChild(Die);
1404   }
1405
1406   // Add nested scopes.
1407   SmallVector<DbgScope *, 4> &Scopes = ParentScope->getScopes();
1408   for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1409     // Define the Scope debug information entry.
1410     DbgScope *Scope = Scopes[j];
1411
1412     unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1413     unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1414
1415     // Ignore empty scopes.
1416     if (StartID == EndID && StartID != 0) continue;
1417
1418     // Do not ignore inlined scopes even if they don't have any variables or
1419     // scopes.
1420     if (Scope->getScopes().empty() && Scope->getVariables().empty() &&
1421         Scope->getConcreteInsts().empty())
1422       continue;
1423
1424     if (StartID == ParentStartID && EndID == ParentEndID) {
1425       // Just add stuff to the parent scope.
1426       ConstructDbgScope(Scope, ParentStartID, ParentEndID, ParentDie, Unit);
1427     } else {
1428       DIE *ScopeDie = new DIE(dwarf::DW_TAG_lexical_block);
1429
1430       // Add the scope bounds.
1431       if (StartID)
1432         AddLabel(ScopeDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1433                  DWLabel("label", StartID));
1434       else
1435         AddLabel(ScopeDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1436                  DWLabel("func_begin", SubprogramCount));
1437
1438       if (EndID)
1439         AddLabel(ScopeDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1440                  DWLabel("label", EndID));
1441       else
1442         AddLabel(ScopeDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1443                  DWLabel("func_end", SubprogramCount));
1444
1445       // Add the scope's contents.
1446       ConstructDbgScope(Scope, StartID, EndID, ScopeDie, Unit);
1447       ParentDie->AddChild(ScopeDie);
1448     }
1449   }
1450 }
1451
1452 /// ConstructFunctionDbgScope - Construct the scope for the subprogram.
1453 ///
1454 void DwarfDebug::ConstructFunctionDbgScope(DbgScope *RootScope,
1455                                            bool AbstractScope) {
1456   // Exit if there is no root scope.
1457   if (!RootScope) return;
1458   DIDescriptor Desc = RootScope->getDesc();
1459   if (Desc.isNull())
1460     return;
1461
1462   // Get the subprogram debug information entry.
1463   DISubprogram SPD(Desc.getNode());
1464
1465   // Get the subprogram die.
1466   DIE *SPDie = ModuleCU->getDieMapSlotFor(SPD.getNode());
1467   if (!SPDie) {
1468     ConstructSubprogram(SPD.getNode());
1469     SPDie = ModuleCU->getDieMapSlotFor(SPD.getNode());
1470   }
1471   assert(SPDie && "Missing subprogram descriptor");
1472
1473   if (!AbstractScope) {
1474     // Add the function bounds.
1475     AddLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1476              DWLabel("func_begin", SubprogramCount));
1477     AddLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1478              DWLabel("func_end", SubprogramCount));
1479     MachineLocation Location(RI->getFrameRegister(*MF));
1480     AddAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1481   }
1482
1483   ConstructDbgScope(RootScope, 0, 0, SPDie, ModuleCU);
1484   // If there are global variables at this scope then add their dies.
1485   for (SmallVector<WeakVH, 4>::iterator SGI = ScopedGVs.begin(),
1486        SGE = ScopedGVs.end(); SGI != SGE; ++SGI) {
1487     MDNode *N = dyn_cast_or_null<MDNode>(*SGI);
1488     if (!N) continue;
1489     DIGlobalVariable GV(N);
1490     if (GV.getContext().getNode() == RootScope->getDesc().getNode()) {
1491       DIE *ScopedGVDie = CreateGlobalVariableDIE(ModuleCU, GV);
1492       SPDie->AddChild(ScopedGVDie);
1493     }
1494   }
1495 }
1496
1497 /// ConstructDefaultDbgScope - Construct a default scope for the subprogram.
1498 ///
1499 void DwarfDebug::ConstructDefaultDbgScope(MachineFunction *MF) {
1500   StringMap<DIE*> &Globals = ModuleCU->getGlobals();
1501   StringMap<DIE*>::iterator GI = Globals.find(MF->getFunction()->getName());
1502   if (GI != Globals.end()) {
1503     DIE *SPDie = GI->second;
1504
1505     // Add the function bounds.
1506     AddLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1507              DWLabel("func_begin", SubprogramCount));
1508     AddLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1509              DWLabel("func_end", SubprogramCount));
1510
1511     MachineLocation Location(RI->getFrameRegister(*MF));
1512     AddAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1513   }
1514 }
1515
1516 /// GetOrCreateSourceID - Look up the source id with the given directory and
1517 /// source file names. If none currently exists, create a new id and insert it
1518 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1519 /// maps as well.
1520 unsigned DwarfDebug::GetOrCreateSourceID(const char *DirName,
1521                                          const char *FileName) {
1522   unsigned DId;
1523   StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1524   if (DI != DirectoryIdMap.end()) {
1525     DId = DI->getValue();
1526   } else {
1527     DId = DirectoryNames.size() + 1;
1528     DirectoryIdMap[DirName] = DId;
1529     DirectoryNames.push_back(DirName);
1530   }
1531
1532   unsigned FId;
1533   StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1534   if (FI != SourceFileIdMap.end()) {
1535     FId = FI->getValue();
1536   } else {
1537     FId = SourceFileNames.size() + 1;
1538     SourceFileIdMap[FileName] = FId;
1539     SourceFileNames.push_back(FileName);
1540   }
1541
1542   DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1543     SourceIdMap.find(std::make_pair(DId, FId));
1544   if (SI != SourceIdMap.end())
1545     return SI->second;
1546
1547   unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
1548   SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1549   SourceIds.push_back(std::make_pair(DId, FId));
1550
1551   return SrcId;
1552 }
1553
1554 void DwarfDebug::ConstructCompileUnit(MDNode *N) {
1555   DICompileUnit DIUnit(N);
1556   const char *FN = DIUnit.getFilename();
1557   const char *Dir = DIUnit.getDirectory();
1558   unsigned ID = GetOrCreateSourceID(Dir, FN);
1559
1560   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1561   AddSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1562                    DWLabel("section_line", 0), DWLabel("section_line", 0),
1563                    false);
1564   AddString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1565             DIUnit.getProducer());
1566   AddUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1567           DIUnit.getLanguage());
1568   AddString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1569
1570   if (Dir)
1571     AddString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1572   if (DIUnit.isOptimized())
1573     AddUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1574
1575   if (const char *Flags = DIUnit.getFlags())
1576     AddString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1577
1578   unsigned RVer = DIUnit.getRunTimeVersion();
1579   if (RVer)
1580     AddUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1581             dwarf::DW_FORM_data1, RVer);
1582
1583   CompileUnit *Unit = new CompileUnit(ID, Die);
1584   if (!ModuleCU && DIUnit.isMain()) {
1585     // Use first compile unit marked as isMain as the compile unit
1586     // for this module.
1587     ModuleCU = Unit;
1588   }
1589
1590   CompileUnitMap[DIUnit.getNode()] = Unit;
1591   CompileUnits.push_back(Unit);
1592 }
1593
1594 void DwarfDebug::ConstructGlobalVariableDIE(MDNode *N) {
1595   DIGlobalVariable DI_GV(N);
1596
1597   // If debug information is malformed then ignore it.
1598   if (DI_GV.Verify() == false)
1599     return;
1600
1601   // Check for pre-existence.
1602   DIE *&Slot = ModuleCU->getDieMapSlotFor(DI_GV.getNode());
1603   if (Slot)
1604     return;
1605
1606   DIE *VariableDie = CreateGlobalVariableDIE(ModuleCU, DI_GV);
1607
1608   // Add to map.
1609   Slot = VariableDie;
1610
1611   // Add to context owner.
1612   ModuleCU->getDie()->AddChild(VariableDie);
1613
1614   // Expose as global. FIXME - need to check external flag.
1615   ModuleCU->AddGlobal(DI_GV.getName(), VariableDie);
1616   return;
1617 }
1618
1619 void DwarfDebug::ConstructSubprogram(MDNode *N) {
1620   DISubprogram SP(N);
1621
1622   // Check for pre-existence.
1623   DIE *&Slot = ModuleCU->getDieMapSlotFor(N);
1624   if (Slot)
1625     return;
1626
1627   if (!SP.isDefinition())
1628     // This is a method declaration which will be handled while constructing
1629     // class type.
1630     return;
1631
1632   DIE *SubprogramDie = CreateSubprogramDIE(ModuleCU, SP);
1633
1634   // Add to map.
1635   Slot = SubprogramDie;
1636
1637   // Add to context owner.
1638   ModuleCU->getDie()->AddChild(SubprogramDie);
1639
1640   // Expose as global.
1641   ModuleCU->AddGlobal(SP.getName(), SubprogramDie);
1642   return;
1643 }
1644
1645 /// BeginModule - Emit all Dwarf sections that should come prior to the
1646 /// content. Create global DIEs and emit initial debug info sections.
1647 /// This is inovked by the target AsmPrinter.
1648 void DwarfDebug::BeginModule(Module *M, MachineModuleInfo *mmi) {
1649   this->M = M;
1650
1651   if (TimePassesIsEnabled)
1652     DebugTimer->startTimer();
1653
1654   DebugInfoFinder DbgFinder;
1655   DbgFinder.processModule(*M);
1656
1657   // Create all the compile unit DIEs.
1658   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1659          E = DbgFinder.compile_unit_end(); I != E; ++I)
1660     ConstructCompileUnit(*I);
1661
1662   if (CompileUnits.empty()) {
1663     if (TimePassesIsEnabled)
1664       DebugTimer->stopTimer();
1665
1666     return;
1667   }
1668
1669   // If main compile unit for this module is not seen than randomly
1670   // select first compile unit.
1671   if (!ModuleCU)
1672     ModuleCU = CompileUnits[0];
1673
1674   // Create DIEs for each of the externally visible global variables.
1675   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1676          E = DbgFinder.global_variable_end(); I != E; ++I) {
1677     DIGlobalVariable GV(*I);
1678     if (GV.getContext().getNode() != GV.getCompileUnit().getNode())
1679       ScopedGVs.push_back(*I);
1680     else
1681       ConstructGlobalVariableDIE(*I);
1682   }
1683
1684   // Create DIEs for each of the externally visible subprograms.
1685   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1686          E = DbgFinder.subprogram_end(); I != E; ++I)
1687     ConstructSubprogram(*I);
1688
1689   MMI = mmi;
1690   shouldEmit = true;
1691   MMI->setDebugInfoAvailability(true);
1692
1693   // Prime section data.
1694   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1695
1696   // Print out .file directives to specify files for .loc directives. These are
1697   // printed out early so that they precede any .loc directives.
1698   if (MAI->hasDotLocAndDotFile()) {
1699     for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1700       // Remember source id starts at 1.
1701       std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1702       sys::Path FullPath(getSourceDirectoryName(Id.first));
1703       bool AppendOk =
1704         FullPath.appendComponent(getSourceFileName(Id.second));
1705       assert(AppendOk && "Could not append filename to directory!");
1706       AppendOk = false;
1707       Asm->EmitFile(i, FullPath.str());
1708       Asm->EOL();
1709     }
1710   }
1711
1712   // Emit initial sections
1713   EmitInitial();
1714
1715   if (TimePassesIsEnabled)
1716     DebugTimer->stopTimer();
1717 }
1718
1719 /// EndModule - Emit all Dwarf sections that should come after the content.
1720 ///
1721 void DwarfDebug::EndModule() {
1722   if (!ModuleCU)
1723     return;
1724
1725   if (TimePassesIsEnabled)
1726     DebugTimer->startTimer();
1727
1728   // Standard sections final addresses.
1729   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1730   EmitLabel("text_end", 0);
1731   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1732   EmitLabel("data_end", 0);
1733
1734   // End text sections.
1735   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1736     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1737     EmitLabel("section_end", i);
1738   }
1739
1740   // Emit common frame information.
1741   EmitCommonDebugFrame();
1742
1743   // Emit function debug frame information
1744   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1745          E = DebugFrames.end(); I != E; ++I)
1746     EmitFunctionDebugFrame(*I);
1747
1748   // Compute DIE offsets and sizes.
1749   SizeAndOffsets();
1750
1751   // Emit all the DIEs into a debug info section
1752   EmitDebugInfo();
1753
1754   // Corresponding abbreviations into a abbrev section.
1755   EmitAbbreviations();
1756
1757   // Emit source line correspondence into a debug line section.
1758   EmitDebugLines();
1759
1760   // Emit info into a debug pubnames section.
1761   EmitDebugPubNames();
1762
1763   // Emit info into a debug str section.
1764   EmitDebugStr();
1765
1766   // Emit info into a debug loc section.
1767   EmitDebugLoc();
1768
1769   // Emit info into a debug aranges section.
1770   EmitDebugARanges();
1771
1772   // Emit info into a debug ranges section.
1773   EmitDebugRanges();
1774
1775   // Emit info into a debug macinfo section.
1776   EmitDebugMacInfo();
1777
1778   // Emit inline info.
1779   EmitDebugInlineInfo();
1780
1781   if (TimePassesIsEnabled)
1782     DebugTimer->stopTimer();
1783 }
1784
1785 /// CollectVariableInfo - Populate DbgScope entries with variables' info.
1786 void DwarfDebug::CollectVariableInfo() {
1787   if (!MMI) return;
1788   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1789   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1790          VE = VMap.end(); VI != VE; ++VI) {
1791     MDNode *Var = VI->first;
1792     DILocation VLoc(VI->second.first);
1793     unsigned VSlot = VI->second.second;
1794     DbgScope *Scope = getDbgScope(VLoc.getScope().getNode(), NULL);
1795     Scope->AddVariable(new DbgVariable(DIVariable(Var), VSlot, false));
1796   }
1797 }
1798
1799 /// SetDbgScopeBeginLabels - Update DbgScope begin labels for the scopes that
1800 /// start with this machine instruction.
1801 void DwarfDebug::SetDbgScopeBeginLabels(const MachineInstr *MI, unsigned Label) {
1802   InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1803   if (I == DbgScopeBeginMap.end())
1804     return;
1805   SmallVector<DbgScope *, 2> &SD = I->second;
1806   for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1807        SDI != SDE; ++SDI)
1808     (*SDI)->setStartLabelID(Label);
1809 }
1810
1811 /// SetDbgScopeEndLabels - Update DbgScope end labels for the scopes that
1812 /// end with this machine instruction.
1813 void DwarfDebug::SetDbgScopeEndLabels(const MachineInstr *MI, unsigned Label) {
1814   InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1815   if (I == DbgScopeBeginMap.end())
1816     return;
1817   SmallVector<DbgScope *, 2> &SD = I->second;
1818   for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1819        SDI != SDE; ++SDI)
1820     (*SDI)->setEndLabelID(Label);
1821 }
1822
1823 /// ExtractScopeInformation - Scan machine instructions in this function
1824 /// and collect DbgScopes. Return true, if atleast one scope was found.
1825 bool DwarfDebug::ExtractScopeInformation(MachineFunction *MF) {
1826   // If scope information was extracted using .dbg intrinsics then there is not
1827   // any need to extract these information by scanning each instruction.
1828   if (!DbgScopeMap.empty())
1829     return false;
1830
1831   // Scan each instruction and create scopes.
1832   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1833        I != E; ++I) {
1834     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1835          II != IE; ++II) {
1836       const MachineInstr *MInsn = II;
1837       DebugLoc DL = MInsn->getDebugLoc();
1838       if (DL.isUnknown())
1839         continue;
1840       DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1841       if (!DLT.CompileUnit)
1842         continue;
1843       // There is no need to create another DIE for compile unit. For all
1844       // other scopes, create one DbgScope now. This will be translated
1845       // into a scope DIE at the end.
1846       DIDescriptor D(DLT.CompileUnit);
1847       if (!D.isCompileUnit()) {
1848         DbgScope *Scope = getDbgScope(DLT.CompileUnit, MInsn);
1849         Scope->setLastInsn(MInsn);
1850       }
1851     }
1852   }
1853
1854   // If a scope's last instruction is not set then use its child scope's
1855   // last instruction as this scope's last instrunction.
1856   for (DenseMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1857          DE = DbgScopeMap.end(); DI != DE; ++DI) {
1858     assert (DI->second->getFirstInsn() && "Invalid first instruction!");
1859     DI->second->FixInstructionMarkers();
1860     assert (DI->second->getLastInsn() && "Invalid last instruction!");
1861   }
1862
1863   // Each scope has first instruction and last instruction to mark beginning
1864   // and end of a scope respectively. Create an inverse map that list scopes
1865   // starts (and ends) with an instruction. One instruction may start (or end)
1866   // multiple scopes.
1867   for (DenseMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1868          DE = DbgScopeMap.end(); DI != DE; ++DI) {
1869     DbgScope *S = DI->second;
1870     assert (S && "DbgScope is missing!");
1871     const MachineInstr *MI = S->getFirstInsn();
1872     assert (MI && "DbgScope does not have first instruction!");
1873
1874     InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
1875     if (IDI != DbgScopeBeginMap.end())
1876       IDI->second.push_back(S);
1877     else
1878       DbgScopeBeginMap.insert(std::make_pair(MI,
1879                                              SmallVector<DbgScope *, 2>(2, S)));
1880
1881     MI = S->getLastInsn();
1882     assert (MI && "DbgScope does not have last instruction!");
1883     IDI = DbgScopeEndMap.find(MI);
1884     if (IDI != DbgScopeEndMap.end())
1885       IDI->second.push_back(S);
1886     else
1887       DbgScopeEndMap.insert(std::make_pair(MI,
1888                                              SmallVector<DbgScope *, 2>(2, S)));
1889   }
1890
1891   return !DbgScopeMap.empty();
1892 }
1893
1894 /// BeginFunction - Gather pre-function debug information.  Assumes being
1895 /// emitted immediately after the function entry point.
1896 void DwarfDebug::BeginFunction(MachineFunction *MF) {
1897   this->MF = MF;
1898
1899   if (!ShouldEmitDwarfDebug()) return;
1900
1901   if (TimePassesIsEnabled)
1902     DebugTimer->startTimer();
1903
1904   // Begin accumulating function debug information.
1905   MMI->BeginFunction(MF);
1906
1907   // Assumes in correct section after the entry point.
1908   EmitLabel("func_begin", ++SubprogramCount);
1909
1910   // Emit label for the implicitly defined dbg.stoppoint at the start of the
1911   // function.
1912   DebugLoc FDL = MF->getDefaultDebugLoc();
1913   if (!FDL.isUnknown()) {
1914     DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
1915     unsigned LabelID = RecordSourceLine(DLT.Line, DLT.Col, DLT.CompileUnit);
1916     Asm->printLabel(LabelID);
1917     O << '\n';
1918   }
1919
1920   if (TimePassesIsEnabled)
1921     DebugTimer->stopTimer();
1922 }
1923
1924 /// EndFunction - Gather and emit post-function debug information.
1925 ///
1926 void DwarfDebug::EndFunction(MachineFunction *MF) {
1927   if (!ShouldEmitDwarfDebug()) return;
1928
1929   if (TimePassesIsEnabled)
1930     DebugTimer->startTimer();
1931
1932   // Define end label for subprogram.
1933   EmitLabel("func_end", SubprogramCount);
1934
1935   // Get function line info.
1936   if (!Lines.empty()) {
1937     // Get section line info.
1938     unsigned ID = SectionMap.insert(Asm->getCurrentSection());
1939     if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
1940     std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
1941     // Append the function info to section info.
1942     SectionLineInfos.insert(SectionLineInfos.end(),
1943                             Lines.begin(), Lines.end());
1944   }
1945
1946   // Construct the DbgScope for abstract instances.
1947   for (SmallVector<DbgScope *, 32>::iterator
1948          I = AbstractInstanceRootList.begin(),
1949          E = AbstractInstanceRootList.end(); I != E; ++I)
1950     ConstructFunctionDbgScope(*I);
1951
1952   // Construct scopes for subprogram.
1953   if (FunctionDbgScope)
1954     ConstructFunctionDbgScope(FunctionDbgScope);
1955   else
1956     // FIXME: This is wrong. We are essentially getting past a problem with
1957     // debug information not being able to handle unreachable blocks that have
1958     // debug information in them. In particular, those unreachable blocks that
1959     // have "region end" info in them. That situation results in the "root
1960     // scope" not being created. If that's the case, then emit a "default"
1961     // scope, i.e., one that encompasses the whole function. This isn't
1962     // desirable. And a better way of handling this (and all of the debugging
1963     // information) needs to be explored.
1964     ConstructDefaultDbgScope(MF);
1965
1966   DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
1967                                                MMI->getFrameMoves()));
1968
1969   // Clear debug info
1970   if (FunctionDbgScope) {
1971     delete FunctionDbgScope;
1972     DbgScopeMap.clear();
1973     DbgScopeBeginMap.clear();
1974     DbgScopeEndMap.clear();
1975     DbgAbstractScopeMap.clear();
1976     DbgConcreteScopeMap.clear();
1977     FunctionDbgScope = NULL;
1978     LexicalScopeStack.clear();
1979     AbstractInstanceRootList.clear();
1980     AbstractInstanceRootMap.clear();
1981   }
1982
1983   Lines.clear();
1984
1985   if (TimePassesIsEnabled)
1986     DebugTimer->stopTimer();
1987 }
1988
1989 /// RecordSourceLine - Records location information and associates it with a
1990 /// label. Returns a unique label ID used to generate a label and provide
1991 /// correspondence to the source line list.
1992 unsigned DwarfDebug::RecordSourceLine(unsigned Line, unsigned Col,
1993                                       MDNode *S) {
1994   if (!MMI)
1995     return 0;
1996
1997   if (TimePassesIsEnabled)
1998     DebugTimer->startTimer();
1999
2000   const char *Dir = NULL;
2001   const char *Fn = NULL;
2002
2003   DIDescriptor Scope(S);
2004   if (Scope.isCompileUnit()) {
2005     DICompileUnit CU(S);
2006     Dir = CU.getDirectory();
2007     Fn = CU.getFilename();
2008   } else if (Scope.isSubprogram()) {
2009     DISubprogram SP(S);
2010     Dir = SP.getDirectory();
2011     Fn = SP.getFilename();
2012   } else if (Scope.isLexicalBlock()) {
2013     DILexicalBlock DB(S);
2014     Dir = DB.getDirectory();
2015     Fn = DB.getFilename();
2016   } else
2017     assert (0 && "Unexpected scope info");
2018
2019   unsigned Src = GetOrCreateSourceID(Dir, Fn);
2020   unsigned ID = MMI->NextLabelID();
2021   Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2022
2023   if (TimePassesIsEnabled)
2024     DebugTimer->stopTimer();
2025
2026   return ID;
2027 }
2028
2029 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2030 /// timed. Look up the source id with the given directory and source file
2031 /// names. If none currently exists, create a new id and insert it in the
2032 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2033 /// well.
2034 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2035                                          const std::string &FileName) {
2036   if (TimePassesIsEnabled)
2037     DebugTimer->startTimer();
2038
2039   unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2040
2041   if (TimePassesIsEnabled)
2042     DebugTimer->stopTimer();
2043
2044   return SrcId;
2045 }
2046
2047 /// RecordRegionStart - Indicate the start of a region.
2048 unsigned DwarfDebug::RecordRegionStart(MDNode *N) {
2049   if (TimePassesIsEnabled)
2050     DebugTimer->startTimer();
2051
2052   DbgScope *Scope = getOrCreateScope(N);
2053   unsigned ID = MMI->NextLabelID();
2054   if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID);
2055   LexicalScopeStack.push_back(Scope);
2056
2057   if (TimePassesIsEnabled)
2058     DebugTimer->stopTimer();
2059
2060   return ID;
2061 }
2062
2063 /// RecordRegionEnd - Indicate the end of a region.
2064 unsigned DwarfDebug::RecordRegionEnd(MDNode *N) {
2065   if (TimePassesIsEnabled)
2066     DebugTimer->startTimer();
2067
2068   DbgScope *Scope = getOrCreateScope(N);
2069   unsigned ID = MMI->NextLabelID();
2070   Scope->setEndLabelID(ID);
2071   // FIXME : region.end() may not be in the last basic block.
2072   // For now, do not pop last lexical scope because next basic
2073   // block may start new inlined function's body.
2074   unsigned LSSize = LexicalScopeStack.size();
2075   if (LSSize != 0 && LSSize != 1)
2076     LexicalScopeStack.pop_back();
2077
2078   if (TimePassesIsEnabled)
2079     DebugTimer->stopTimer();
2080
2081   return ID;
2082 }
2083
2084 /// RecordVariable - Indicate the declaration of a local variable.
2085 void DwarfDebug::RecordVariable(MDNode *N, unsigned FrameIndex) {
2086   if (TimePassesIsEnabled)
2087     DebugTimer->startTimer();
2088
2089   DIDescriptor Desc(N);
2090   DbgScope *Scope = NULL;
2091   bool InlinedFnVar = false;
2092
2093   if (Desc.getTag() == dwarf::DW_TAG_variable)
2094     Scope = getOrCreateScope(DIGlobalVariable(N).getContext().getNode());
2095   else {
2096     bool InlinedVar = false;
2097     MDNode *Context = DIVariable(N).getContext().getNode();
2098     DISubprogram SP(Context);
2099     if (!SP.isNull()) {
2100       // SP is inserted into DbgAbstractScopeMap when inlined function
2101       // start was recorded by RecordInlineFnStart.
2102       DenseMap<MDNode *, DbgScope *>::iterator
2103         I = DbgAbstractScopeMap.find(SP.getNode());
2104       if (I != DbgAbstractScopeMap.end()) {
2105         InlinedVar = true;
2106         Scope = I->second;
2107       }
2108     }
2109     if (!InlinedVar)
2110       Scope = getOrCreateScope(Context);
2111   }
2112
2113   assert(Scope && "Unable to find the variable's scope");
2114   DbgVariable *DV = new DbgVariable(DIVariable(N), FrameIndex, InlinedFnVar);
2115   Scope->AddVariable(DV);
2116
2117   if (TimePassesIsEnabled)
2118     DebugTimer->stopTimer();
2119 }
2120
2121 //// RecordInlinedFnStart - Indicate the start of inlined subroutine.
2122 unsigned DwarfDebug::RecordInlinedFnStart(DISubprogram &SP, DICompileUnit CU,
2123                                           unsigned Line, unsigned Col) {
2124   unsigned LabelID = MMI->NextLabelID();
2125
2126   if (!MAI->doesDwarfUsesInlineInfoSection())
2127     return LabelID;
2128
2129   if (TimePassesIsEnabled)
2130     DebugTimer->startTimer();
2131
2132   MDNode *Node = SP.getNode();
2133   DenseMap<const MDNode *, DbgScope *>::iterator
2134     II = AbstractInstanceRootMap.find(Node);
2135
2136   if (II == AbstractInstanceRootMap.end()) {
2137     // Create an abstract instance entry for this inlined function if it doesn't
2138     // already exist.
2139     DbgScope *Scope = new DbgScope(NULL, DIDescriptor(Node));
2140
2141     // Get the compile unit context.
2142     DIE *SPDie = ModuleCU->getDieMapSlotFor(Node);
2143     if (!SPDie)
2144       SPDie = CreateSubprogramDIE(ModuleCU, SP, false, true);
2145
2146     // Mark as being inlined. This makes this subprogram entry an abstract
2147     // instance root.
2148     // FIXME: Our debugger doesn't care about the value of DW_AT_inline, only
2149     // that it's defined. That probably won't change in the future. However,
2150     // this could be more elegant.
2151     AddUInt(SPDie, dwarf::DW_AT_inline, 0, dwarf::DW_INL_declared_not_inlined);
2152
2153     // Keep track of the abstract scope for this function.
2154     DbgAbstractScopeMap[Node] = Scope;
2155
2156     AbstractInstanceRootMap[Node] = Scope;
2157     AbstractInstanceRootList.push_back(Scope);
2158   }
2159
2160   // Create a concrete inlined instance for this inlined function.
2161   DbgConcreteScope *ConcreteScope = new DbgConcreteScope(DIDescriptor(Node));
2162   DIE *ScopeDie = new DIE(dwarf::DW_TAG_inlined_subroutine);
2163   ScopeDie->setAbstractCompileUnit(ModuleCU);
2164
2165   DIE *Origin = ModuleCU->getDieMapSlotFor(Node);
2166   AddDIEEntry(ScopeDie, dwarf::DW_AT_abstract_origin,
2167               dwarf::DW_FORM_ref4, Origin);
2168   AddUInt(ScopeDie, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
2169   AddUInt(ScopeDie, dwarf::DW_AT_call_line, 0, Line);
2170   AddUInt(ScopeDie, dwarf::DW_AT_call_column, 0, Col);
2171
2172   ConcreteScope->setDie(ScopeDie);
2173   ConcreteScope->setStartLabelID(LabelID);
2174   MMI->RecordUsedDbgLabel(LabelID);
2175
2176   LexicalScopeStack.back()->AddConcreteInst(ConcreteScope);
2177
2178   // Keep track of the concrete scope that's inlined into this function.
2179   DenseMap<MDNode *, SmallVector<DbgScope *, 8> >::iterator
2180     SI = DbgConcreteScopeMap.find(Node);
2181
2182   if (SI == DbgConcreteScopeMap.end())
2183     DbgConcreteScopeMap[Node].push_back(ConcreteScope);
2184   else
2185     SI->second.push_back(ConcreteScope);
2186
2187   // Track the start label for this inlined function.
2188   DenseMap<MDNode *, SmallVector<unsigned, 4> >::iterator
2189     I = InlineInfo.find(Node);
2190
2191   if (I == InlineInfo.end())
2192     InlineInfo[Node].push_back(LabelID);
2193   else
2194     I->second.push_back(LabelID);
2195
2196   if (TimePassesIsEnabled)
2197     DebugTimer->stopTimer();
2198
2199   return LabelID;
2200 }
2201
2202 /// RecordInlinedFnEnd - Indicate the end of inlined subroutine.
2203 unsigned DwarfDebug::RecordInlinedFnEnd(DISubprogram &SP) {
2204   if (!MAI->doesDwarfUsesInlineInfoSection())
2205     return 0;
2206
2207   if (TimePassesIsEnabled)
2208     DebugTimer->startTimer();
2209
2210   MDNode *Node = SP.getNode();
2211   DenseMap<MDNode *, SmallVector<DbgScope *, 8> >::iterator
2212     I = DbgConcreteScopeMap.find(Node);
2213
2214   if (I == DbgConcreteScopeMap.end()) {
2215     // FIXME: Can this situation actually happen? And if so, should it?
2216     if (TimePassesIsEnabled)
2217       DebugTimer->stopTimer();
2218
2219     return 0;
2220   }
2221
2222   SmallVector<DbgScope *, 8> &Scopes = I->second;
2223   if (Scopes.empty()) {
2224     // Returned ID is 0 if this is unbalanced "end of inlined
2225     // scope". This could happen if optimizer eats dbg intrinsics
2226     // or "beginning of inlined scope" is not recoginized due to
2227     // missing location info. In such cases, ignore this region.end.
2228     return 0;
2229   }
2230
2231   DbgScope *Scope = Scopes.back(); Scopes.pop_back();
2232   unsigned ID = MMI->NextLabelID();
2233   MMI->RecordUsedDbgLabel(ID);
2234   Scope->setEndLabelID(ID);
2235
2236   if (TimePassesIsEnabled)
2237     DebugTimer->stopTimer();
2238
2239   return ID;
2240 }
2241
2242 //===----------------------------------------------------------------------===//
2243 // Emit Methods
2244 //===----------------------------------------------------------------------===//
2245
2246 /// SizeAndOffsetDie - Compute the size and offset of a DIE.
2247 ///
2248 unsigned DwarfDebug::SizeAndOffsetDie(DIE *Die, unsigned Offset, bool Last) {
2249   // Get the children.
2250   const std::vector<DIE *> &Children = Die->getChildren();
2251
2252   // If not last sibling and has children then add sibling offset attribute.
2253   if (!Last && !Children.empty()) Die->AddSiblingOffset();
2254
2255   // Record the abbreviation.
2256   AssignAbbrevNumber(Die->getAbbrev());
2257
2258   // Get the abbreviation for this DIE.
2259   unsigned AbbrevNumber = Die->getAbbrevNumber();
2260   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2261
2262   // Set DIE offset
2263   Die->setOffset(Offset);
2264
2265   // Start the size with the size of abbreviation code.
2266   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2267
2268   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2269   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2270
2271   // Size the DIE attribute values.
2272   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2273     // Size attribute value.
2274     Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2275
2276   // Size the DIE children if any.
2277   if (!Children.empty()) {
2278     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2279            "Children flag not set");
2280
2281     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2282       Offset = SizeAndOffsetDie(Children[j], Offset, (j + 1) == M);
2283
2284     // End of children marker.
2285     Offset += sizeof(int8_t);
2286   }
2287
2288   Die->setSize(Offset - Die->getOffset());
2289   return Offset;
2290 }
2291
2292 /// SizeAndOffsets - Compute the size and offset of all the DIEs.
2293 ///
2294 void DwarfDebug::SizeAndOffsets() {
2295   // Compute size of compile unit header.
2296   static unsigned Offset =
2297     sizeof(int32_t) + // Length of Compilation Unit Info
2298     sizeof(int16_t) + // DWARF version number
2299     sizeof(int32_t) + // Offset Into Abbrev. Section
2300     sizeof(int8_t);   // Pointer Size (in bytes)
2301
2302   SizeAndOffsetDie(ModuleCU->getDie(), Offset, true);
2303   CompileUnitOffsets[ModuleCU] = 0;
2304 }
2305
2306 /// EmitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2307 /// tools to recognize the object file contains Dwarf information.
2308 void DwarfDebug::EmitInitial() {
2309   // Check to see if we already emitted intial headers.
2310   if (didInitial) return;
2311   didInitial = true;
2312
2313   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2314
2315   // Dwarf sections base addresses.
2316   if (MAI->doesDwarfRequireFrameSection()) {
2317     Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2318     EmitLabel("section_debug_frame", 0);
2319   }
2320
2321   Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2322   EmitLabel("section_info", 0);
2323   Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2324   EmitLabel("section_abbrev", 0);
2325   Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2326   EmitLabel("section_aranges", 0);
2327
2328   if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2329     Asm->OutStreamer.SwitchSection(LineInfoDirective);
2330     EmitLabel("section_macinfo", 0);
2331   }
2332
2333   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2334   EmitLabel("section_line", 0);
2335   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2336   EmitLabel("section_loc", 0);
2337   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2338   EmitLabel("section_pubnames", 0);
2339   Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2340   EmitLabel("section_str", 0);
2341   Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2342   EmitLabel("section_ranges", 0);
2343
2344   Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2345   EmitLabel("text_begin", 0);
2346   Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2347   EmitLabel("data_begin", 0);
2348 }
2349
2350 /// EmitDIE - Recusively Emits a debug information entry.
2351 ///
2352 void DwarfDebug::EmitDIE(DIE *Die) {
2353   // Get the abbreviation for this DIE.
2354   unsigned AbbrevNumber = Die->getAbbrevNumber();
2355   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2356
2357   Asm->EOL();
2358
2359   // Emit the code (index) for the abbreviation.
2360   Asm->EmitULEB128Bytes(AbbrevNumber);
2361
2362   if (Asm->isVerbose())
2363     Asm->EOL(std::string("Abbrev [" +
2364                          utostr(AbbrevNumber) +
2365                          "] 0x" + utohexstr(Die->getOffset()) +
2366                          ":0x" + utohexstr(Die->getSize()) + " " +
2367                          dwarf::TagString(Abbrev->getTag())));
2368   else
2369     Asm->EOL();
2370
2371   SmallVector<DIEValue*, 32> &Values = Die->getValues();
2372   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2373
2374   // Emit the DIE attribute values.
2375   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2376     unsigned Attr = AbbrevData[i].getAttribute();
2377     unsigned Form = AbbrevData[i].getForm();
2378     assert(Form && "Too many attributes for DIE (check abbreviation)");
2379
2380     switch (Attr) {
2381     case dwarf::DW_AT_sibling:
2382       Asm->EmitInt32(Die->SiblingOffset());
2383       break;
2384     case dwarf::DW_AT_abstract_origin: {
2385       DIEEntry *E = cast<DIEEntry>(Values[i]);
2386       DIE *Origin = E->getEntry();
2387       unsigned Addr =
2388         CompileUnitOffsets[Die->getAbstractCompileUnit()] +
2389         Origin->getOffset();
2390
2391       Asm->EmitInt32(Addr);
2392       break;
2393     }
2394     default:
2395       // Emit an attribute using the defined form.
2396       Values[i]->EmitValue(this, Form);
2397       break;
2398     }
2399
2400     Asm->EOL(dwarf::AttributeString(Attr));
2401   }
2402
2403   // Emit the DIE children if any.
2404   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2405     const std::vector<DIE *> &Children = Die->getChildren();
2406
2407     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2408       EmitDIE(Children[j]);
2409
2410     Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2411   }
2412 }
2413
2414 /// EmitDebugInfo / EmitDebugInfoPerCU - Emit the debug info section.
2415 ///
2416 void DwarfDebug::EmitDebugInfoPerCU(CompileUnit *Unit) {
2417   DIE *Die = Unit->getDie();
2418
2419   // Emit the compile units header.
2420   EmitLabel("info_begin", Unit->getID());
2421
2422   // Emit size of content not including length itself
2423   unsigned ContentSize = Die->getSize() +
2424     sizeof(int16_t) + // DWARF version number
2425     sizeof(int32_t) + // Offset Into Abbrev. Section
2426     sizeof(int8_t) +  // Pointer Size (in bytes)
2427     sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2428
2429   Asm->EmitInt32(ContentSize);  Asm->EOL("Length of Compilation Unit Info");
2430   Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2431   EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2432   Asm->EOL("Offset Into Abbrev. Section");
2433   Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2434
2435   EmitDIE(Die);
2436   // FIXME - extra padding for gdb bug.
2437   Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2438   Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2439   Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2440   Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2441   EmitLabel("info_end", Unit->getID());
2442
2443   Asm->EOL();
2444 }
2445
2446 void DwarfDebug::EmitDebugInfo() {
2447   // Start debug info section.
2448   Asm->OutStreamer.SwitchSection(
2449                             Asm->getObjFileLowering().getDwarfInfoSection());
2450
2451   EmitDebugInfoPerCU(ModuleCU);
2452 }
2453
2454 /// EmitAbbreviations - Emit the abbreviation section.
2455 ///
2456 void DwarfDebug::EmitAbbreviations() const {
2457   // Check to see if it is worth the effort.
2458   if (!Abbreviations.empty()) {
2459     // Start the debug abbrev section.
2460     Asm->OutStreamer.SwitchSection(
2461                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2462
2463     EmitLabel("abbrev_begin", 0);
2464
2465     // For each abbrevation.
2466     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2467       // Get abbreviation data
2468       const DIEAbbrev *Abbrev = Abbreviations[i];
2469
2470       // Emit the abbrevations code (base 1 index.)
2471       Asm->EmitULEB128Bytes(Abbrev->getNumber());
2472       Asm->EOL("Abbreviation Code");
2473
2474       // Emit the abbreviations data.
2475       Abbrev->Emit(Asm);
2476
2477       Asm->EOL();
2478     }
2479
2480     // Mark end of abbreviations.
2481     Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2482
2483     EmitLabel("abbrev_end", 0);
2484     Asm->EOL();
2485   }
2486 }
2487
2488 /// EmitEndOfLineMatrix - Emit the last address of the section and the end of
2489 /// the line matrix.
2490 ///
2491 void DwarfDebug::EmitEndOfLineMatrix(unsigned SectionEnd) {
2492   // Define last address of section.
2493   Asm->EmitInt8(0); Asm->EOL("Extended Op");
2494   Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2495   Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2496   EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2497
2498   // Mark end of matrix.
2499   Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2500   Asm->EmitULEB128Bytes(1); Asm->EOL();
2501   Asm->EmitInt8(1); Asm->EOL();
2502 }
2503
2504 /// EmitDebugLines - Emit source line information.
2505 ///
2506 void DwarfDebug::EmitDebugLines() {
2507   // If the target is using .loc/.file, the assembler will be emitting the
2508   // .debug_line table automatically.
2509   if (MAI->hasDotLocAndDotFile())
2510     return;
2511
2512   // Minimum line delta, thus ranging from -10..(255-10).
2513   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2514   // Maximum line delta, thus ranging from -10..(255-10).
2515   const int MaxLineDelta = 255 + MinLineDelta;
2516
2517   // Start the dwarf line section.
2518   Asm->OutStreamer.SwitchSection(
2519                             Asm->getObjFileLowering().getDwarfLineSection());
2520
2521   // Construct the section header.
2522   EmitDifference("line_end", 0, "line_begin", 0, true);
2523   Asm->EOL("Length of Source Line Info");
2524   EmitLabel("line_begin", 0);
2525
2526   Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2527
2528   EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2529   Asm->EOL("Prolog Length");
2530   EmitLabel("line_prolog_begin", 0);
2531
2532   Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2533
2534   Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2535
2536   Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2537
2538   Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2539
2540   Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2541
2542   // Line number standard opcode encodings argument count
2543   Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2544   Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2545   Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2546   Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2547   Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2548   Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2549   Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2550   Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2551   Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2552
2553   // Emit directories.
2554   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2555     Asm->EmitString(getSourceDirectoryName(DI));
2556     Asm->EOL("Directory");
2557   }
2558
2559   Asm->EmitInt8(0); Asm->EOL("End of directories");
2560
2561   // Emit files.
2562   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2563     // Remember source id starts at 1.
2564     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2565     Asm->EmitString(getSourceFileName(Id.second));
2566     Asm->EOL("Source");
2567     Asm->EmitULEB128Bytes(Id.first);
2568     Asm->EOL("Directory #");
2569     Asm->EmitULEB128Bytes(0);
2570     Asm->EOL("Mod date");
2571     Asm->EmitULEB128Bytes(0);
2572     Asm->EOL("File size");
2573   }
2574
2575   Asm->EmitInt8(0); Asm->EOL("End of files");
2576
2577   EmitLabel("line_prolog_end", 0);
2578
2579   // A sequence for each text section.
2580   unsigned SecSrcLinesSize = SectionSourceLines.size();
2581
2582   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2583     // Isolate current sections line info.
2584     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2585
2586     /*if (Asm->isVerbose()) {
2587       const MCSection *S = SectionMap[j + 1];
2588       O << '\t' << MAI->getCommentString() << " Section"
2589         << S->getName() << '\n';
2590     }*/
2591     Asm->EOL();
2592
2593     // Dwarf assumes we start with first line of first source file.
2594     unsigned Source = 1;
2595     unsigned Line = 1;
2596
2597     // Construct rows of the address, source, line, column matrix.
2598     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2599       const SrcLineInfo &LineInfo = LineInfos[i];
2600       unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2601       if (!LabelID) continue;
2602
2603       if (LineInfo.getLine() == 0) continue;
2604
2605       if (!Asm->isVerbose())
2606         Asm->EOL();
2607       else {
2608         std::pair<unsigned, unsigned> SourceID =
2609           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2610         O << '\t' << MAI->getCommentString() << ' '
2611           << getSourceDirectoryName(SourceID.first) << ' '
2612           << getSourceFileName(SourceID.second)
2613           <<" :" << utostr_32(LineInfo.getLine()) << '\n';
2614       }
2615
2616       // Define the line address.
2617       Asm->EmitInt8(0); Asm->EOL("Extended Op");
2618       Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2619       Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2620       EmitReference("label",  LabelID); Asm->EOL("Location label");
2621
2622       // If change of source, then switch to the new source.
2623       if (Source != LineInfo.getSourceID()) {
2624         Source = LineInfo.getSourceID();
2625         Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2626         Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2627       }
2628
2629       // If change of line.
2630       if (Line != LineInfo.getLine()) {
2631         // Determine offset.
2632         int Offset = LineInfo.getLine() - Line;
2633         int Delta = Offset - MinLineDelta;
2634
2635         // Update line.
2636         Line = LineInfo.getLine();
2637
2638         // If delta is small enough and in range...
2639         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2640           // ... then use fast opcode.
2641           Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2642         } else {
2643           // ... otherwise use long hand.
2644           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2645           Asm->EOL("DW_LNS_advance_line");
2646           Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2647           Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2648         }
2649       } else {
2650         // Copy the previous row (different address or source)
2651         Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2652       }
2653     }
2654
2655     EmitEndOfLineMatrix(j + 1);
2656   }
2657
2658   if (SecSrcLinesSize == 0)
2659     // Because we're emitting a debug_line section, we still need a line
2660     // table. The linker and friends expect it to exist. If there's nothing to
2661     // put into it, emit an empty table.
2662     EmitEndOfLineMatrix(1);
2663
2664   EmitLabel("line_end", 0);
2665   Asm->EOL();
2666 }
2667
2668 /// EmitCommonDebugFrame - Emit common frame info into a debug frame section.
2669 ///
2670 void DwarfDebug::EmitCommonDebugFrame() {
2671   if (!MAI->doesDwarfRequireFrameSection())
2672     return;
2673
2674   int stackGrowth =
2675     Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2676       TargetFrameInfo::StackGrowsUp ?
2677     TD->getPointerSize() : -TD->getPointerSize();
2678
2679   // Start the dwarf frame section.
2680   Asm->OutStreamer.SwitchSection(
2681                               Asm->getObjFileLowering().getDwarfFrameSection());
2682
2683   EmitLabel("debug_frame_common", 0);
2684   EmitDifference("debug_frame_common_end", 0,
2685                  "debug_frame_common_begin", 0, true);
2686   Asm->EOL("Length of Common Information Entry");
2687
2688   EmitLabel("debug_frame_common_begin", 0);
2689   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2690   Asm->EOL("CIE Identifier Tag");
2691   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2692   Asm->EOL("CIE Version");
2693   Asm->EmitString("");
2694   Asm->EOL("CIE Augmentation");
2695   Asm->EmitULEB128Bytes(1);
2696   Asm->EOL("CIE Code Alignment Factor");
2697   Asm->EmitSLEB128Bytes(stackGrowth);
2698   Asm->EOL("CIE Data Alignment Factor");
2699   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2700   Asm->EOL("CIE RA Column");
2701
2702   std::vector<MachineMove> Moves;
2703   RI->getInitialFrameState(Moves);
2704
2705   EmitFrameMoves(NULL, 0, Moves, false);
2706
2707   Asm->EmitAlignment(2, 0, 0, false);
2708   EmitLabel("debug_frame_common_end", 0);
2709
2710   Asm->EOL();
2711 }
2712
2713 /// EmitFunctionDebugFrame - Emit per function frame info into a debug frame
2714 /// section.
2715 void
2716 DwarfDebug::EmitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2717   if (!MAI->doesDwarfRequireFrameSection())
2718     return;
2719
2720   // Start the dwarf frame section.
2721   Asm->OutStreamer.SwitchSection(
2722                               Asm->getObjFileLowering().getDwarfFrameSection());
2723
2724   EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2725                  "debug_frame_begin", DebugFrameInfo.Number, true);
2726   Asm->EOL("Length of Frame Information Entry");
2727
2728   EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2729
2730   EmitSectionOffset("debug_frame_common", "section_debug_frame",
2731                     0, 0, true, false);
2732   Asm->EOL("FDE CIE offset");
2733
2734   EmitReference("func_begin", DebugFrameInfo.Number);
2735   Asm->EOL("FDE initial location");
2736   EmitDifference("func_end", DebugFrameInfo.Number,
2737                  "func_begin", DebugFrameInfo.Number);
2738   Asm->EOL("FDE address range");
2739
2740   EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2741                  false);
2742
2743   Asm->EmitAlignment(2, 0, 0, false);
2744   EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2745
2746   Asm->EOL();
2747 }
2748
2749 void DwarfDebug::EmitDebugPubNamesPerCU(CompileUnit *Unit) {
2750   EmitDifference("pubnames_end", Unit->getID(),
2751                  "pubnames_begin", Unit->getID(), true);
2752   Asm->EOL("Length of Public Names Info");
2753
2754   EmitLabel("pubnames_begin", Unit->getID());
2755
2756   Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2757
2758   EmitSectionOffset("info_begin", "section_info",
2759                     Unit->getID(), 0, true, false);
2760   Asm->EOL("Offset of Compilation Unit Info");
2761
2762   EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),
2763                  true);
2764   Asm->EOL("Compilation Unit Length");
2765
2766   StringMap<DIE*> &Globals = Unit->getGlobals();
2767   for (StringMap<DIE*>::const_iterator
2768          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2769     const char *Name = GI->getKeyData();
2770     DIE * Entity = GI->second;
2771
2772     Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2773     Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2774   }
2775
2776   Asm->EmitInt32(0); Asm->EOL("End Mark");
2777   EmitLabel("pubnames_end", Unit->getID());
2778
2779   Asm->EOL();
2780 }
2781
2782 /// EmitDebugPubNames - Emit visible names into a debug pubnames section.
2783 ///
2784 void DwarfDebug::EmitDebugPubNames() {
2785   // Start the dwarf pubnames section.
2786   Asm->OutStreamer.SwitchSection(
2787                           Asm->getObjFileLowering().getDwarfPubNamesSection());
2788
2789   EmitDebugPubNamesPerCU(ModuleCU);
2790 }
2791
2792 /// EmitDebugStr - Emit visible names into a debug str section.
2793 ///
2794 void DwarfDebug::EmitDebugStr() {
2795   // Check to see if it is worth the effort.
2796   if (!StringPool.empty()) {
2797     // Start the dwarf str section.
2798     Asm->OutStreamer.SwitchSection(
2799                                 Asm->getObjFileLowering().getDwarfStrSection());
2800
2801     // For each of strings in the string pool.
2802     for (unsigned StringID = 1, N = StringPool.size();
2803          StringID <= N; ++StringID) {
2804       // Emit a label for reference from debug information entries.
2805       EmitLabel("string", StringID);
2806
2807       // Emit the string itself.
2808       const std::string &String = StringPool[StringID];
2809       Asm->EmitString(String); Asm->EOL();
2810     }
2811
2812     Asm->EOL();
2813   }
2814 }
2815
2816 /// EmitDebugLoc - Emit visible names into a debug loc section.
2817 ///
2818 void DwarfDebug::EmitDebugLoc() {
2819   // Start the dwarf loc section.
2820   Asm->OutStreamer.SwitchSection(
2821                               Asm->getObjFileLowering().getDwarfLocSection());
2822   Asm->EOL();
2823 }
2824
2825 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2826 ///
2827 void DwarfDebug::EmitDebugARanges() {
2828   // Start the dwarf aranges section.
2829   Asm->OutStreamer.SwitchSection(
2830                           Asm->getObjFileLowering().getDwarfARangesSection());
2831
2832   // FIXME - Mock up
2833 #if 0
2834   CompileUnit *Unit = GetBaseCompileUnit();
2835
2836   // Don't include size of length
2837   Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2838
2839   Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2840
2841   EmitReference("info_begin", Unit->getID());
2842   Asm->EOL("Offset of Compilation Unit Info");
2843
2844   Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2845
2846   Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2847
2848   Asm->EmitInt16(0);  Asm->EOL("Pad (1)");
2849   Asm->EmitInt16(0);  Asm->EOL("Pad (2)");
2850
2851   // Range 1
2852   EmitReference("text_begin", 0); Asm->EOL("Address");
2853   EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2854
2855   Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2856   Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2857 #endif
2858
2859   Asm->EOL();
2860 }
2861
2862 /// EmitDebugRanges - Emit visible names into a debug ranges section.
2863 ///
2864 void DwarfDebug::EmitDebugRanges() {
2865   // Start the dwarf ranges section.
2866   Asm->OutStreamer.SwitchSection(
2867                             Asm->getObjFileLowering().getDwarfRangesSection());
2868   Asm->EOL();
2869 }
2870
2871 /// EmitDebugMacInfo - Emit visible names into a debug macinfo section.
2872 ///
2873 void DwarfDebug::EmitDebugMacInfo() {
2874   if (const MCSection *LineInfo =
2875       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2876     // Start the dwarf macinfo section.
2877     Asm->OutStreamer.SwitchSection(LineInfo);
2878     Asm->EOL();
2879   }
2880 }
2881
2882 /// EmitDebugInlineInfo - Emit inline info using following format.
2883 /// Section Header:
2884 /// 1. length of section
2885 /// 2. Dwarf version number
2886 /// 3. address size.
2887 ///
2888 /// Entries (one "entry" for each function that was inlined):
2889 ///
2890 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2891 ///   otherwise offset into __debug_str for regular function name.
2892 /// 2. offset into __debug_str section for regular function name.
2893 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2894 /// instances for the function.
2895 ///
2896 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2897 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2898 /// __debug_info section, and the low_pc is the starting address for the
2899 /// inlining instance.
2900 void DwarfDebug::EmitDebugInlineInfo() {
2901   if (!MAI->doesDwarfUsesInlineInfoSection())
2902     return;
2903
2904   if (!ModuleCU)
2905     return;
2906
2907   Asm->OutStreamer.SwitchSection(
2908                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2909   Asm->EOL();
2910   EmitDifference("debug_inlined_end", 1,
2911                  "debug_inlined_begin", 1, true);
2912   Asm->EOL("Length of Debug Inlined Information Entry");
2913
2914   EmitLabel("debug_inlined_begin", 1);
2915
2916   Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2917   Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2918
2919   for (DenseMap<MDNode *, SmallVector<unsigned, 4> >::iterator
2920          I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2921     MDNode *Node = I->first;
2922     SmallVector<unsigned, 4> &Labels = I->second;
2923     DISubprogram SP(Node);
2924     const char *LName = SP.getLinkageName();
2925     const char *Name = SP.getName();
2926
2927     if (!LName)
2928       Asm->EmitString(Name);
2929     else {
2930       // Skip special LLVM prefix that is used to inform the asm printer to not
2931       // emit usual symbol prefix before the symbol name. This happens for
2932       // Objective-C symbol names and symbol whose name is replaced using GCC's
2933       // __asm__ attribute.
2934       if (LName[0] == 1)
2935         LName = &LName[1];
2936       Asm->EmitString(LName);
2937     }
2938     Asm->EOL("MIPS linkage name");
2939
2940     Asm->EmitString(Name); Asm->EOL("Function name");
2941
2942     Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2943
2944     for (SmallVector<unsigned, 4>::iterator LI = Labels.begin(),
2945            LE = Labels.end(); LI != LE; ++LI) {
2946       DIE *SP = ModuleCU->getDieMapSlotFor(Node);
2947       Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2948
2949       if (TD->getPointerSize() == sizeof(int32_t))
2950         O << MAI->getData32bitsDirective();
2951       else
2952         O << MAI->getData64bitsDirective();
2953
2954       PrintLabelName("label", *LI); Asm->EOL("low_pc");
2955     }
2956   }
2957
2958   EmitLabel("debug_inlined_end", 1);
2959   Asm->EOL();
2960 }