lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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