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