lib/CodeGen/AsmPrinter/DwarfWriter.cpp

   1 //===-- llvm/CodeGen/DwarfWriter.cpp - Dwarf Framework ----------*- C++ -*-===//
   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 info into asm files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/CodeGen/DwarfWriter.h"
  15 #include "llvm/Module.h"
  16 #include "llvm/DerivedTypes.h"
  17 #include "llvm/Constants.h"
  18 #include "llvm/CodeGen/AsmPrinter.h"
  19 #include "llvm/CodeGen/MachineModuleInfo.h"
  20 #include "llvm/CodeGen/MachineFrameInfo.h"
  21 #include "llvm/CodeGen/MachineLocation.h"
  22 #include "llvm/Analysis/DebugInfo.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Support/Dwarf.h"
  25 #include "llvm/Support/CommandLine.h"
  26 #include "llvm/Support/DataTypes.h"
  27 #include "llvm/Support/Mangler.h"
  28 #include "llvm/Support/Timer.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 #include "llvm/System/Path.h"
  31 #include "llvm/Target/TargetAsmInfo.h"
  32 #include "llvm/Target/TargetRegisterInfo.h"
  33 #include "llvm/Target/TargetData.h"
  34 #include "llvm/Target/TargetFrameInfo.h"
  35 #include "llvm/Target/TargetInstrInfo.h"
  36 #include "llvm/Target/TargetMachine.h"
  37 #include "llvm/Target/TargetOptions.h"
  38 #include "llvm/ADT/DenseMap.h"
  39 #include "llvm/ADT/FoldingSet.h"
  40 #include "llvm/ADT/StringExtras.h"
  41 #include "llvm/ADT/StringMap.h"
  42 #include <ostream>
  43 #include <string>
  44 using namespace llvm;
  45 using namespace llvm::dwarf;
  46
  47 static RegisterPass<DwarfWriter>
  48 X("dwarfwriter", "DWARF Information Writer");
  49 char DwarfWriter::ID = 0;
  50
  51 static TimerGroup &getDwarfTimerGroup() {
  52   static TimerGroup DwarfTimerGroup("Dwarf Exception and Debugging");
  53   return DwarfTimerGroup;
  54 }
  55
  56 namespace llvm {
  57
  58 //===----------------------------------------------------------------------===//
  59
  60 /// Configuration values for initial hash set sizes (log2).
  61 ///
  62 static const unsigned InitDiesSetSize          = 9; // log2(512)
  63 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
  64 static const unsigned InitValuesSetSize        = 9; // log2(512)
  65
  66 //===----------------------------------------------------------------------===//
  67 /// Forward declarations.
  68 ///
  69 class DIE;
  70 class DIEValue;
  71
  72 //===----------------------------------------------------------------------===//
  73 /// DWLabel - Labels are used to track locations in the assembler file.
  74 /// Labels appear in the form @verbatim <prefix><Tag><Number> @endverbatim,
  75 /// where the tag is a category of label (Ex. location) and number is a value
  76 /// unique in that category.
  77 class DWLabel {
  78 public:
  79   /// Tag - Label category tag. Should always be a staticly declared C string.
  80   ///
  81   const char *Tag;
  82
  83   /// Number - Value to make label unique.
  84   ///
  85   unsigned    Number;
  86
  87   DWLabel(const char *T, unsigned N) : Tag(T), Number(N) {}
  88
  89   void Profile(FoldingSetNodeID &ID) const {
  90     ID.AddString(Tag);
  91     ID.AddInteger(Number);
  92   }
  93
  94 #ifndef NDEBUG
  95   void print(std::ostream *O) const {
  96     if (O) print(*O);
  97   }
  98   void print(std::ostream &O) const {
  99     O << "." << Tag;
 100     if (Number) O << Number;
 101   }
 102 #endif
 103 };
 104
 105 //===----------------------------------------------------------------------===//
 106 /// DIEAbbrevData - Dwarf abbreviation data, describes the one attribute of a
 107 /// Dwarf abbreviation.
 108 class DIEAbbrevData {
 109   /// Attribute - Dwarf attribute code.
 110   ///
 111   unsigned Attribute;
 112
 113   /// Form - Dwarf form code.
 114   ///
 115   unsigned Form;
 116 public:
 117   DIEAbbrevData(unsigned A, unsigned F) : Attribute(A), Form(F) {}
 118
 119   // Accessors.
 120   unsigned getAttribute() const { return Attribute; }
 121   unsigned getForm()      const { return Form; }
 122
 123   /// Profile - Used to gather unique data for the abbreviation folding set.
 124   ///
 125   void Profile(FoldingSetNodeID &ID)const  {
 126     ID.AddInteger(Attribute);
 127     ID.AddInteger(Form);
 128   }
 129 };
 130
 131 //===----------------------------------------------------------------------===//
 132 /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
 133 /// information object.
 134 class DIEAbbrev : public FoldingSetNode {
 135 private:
 136   /// Tag - Dwarf tag code.
 137   ///
 138   unsigned Tag;
 139
 140   /// Unique number for node.
 141   ///
 142   unsigned Number;
 143
 144   /// ChildrenFlag - Dwarf children flag.
 145   ///
 146   unsigned ChildrenFlag;
 147
 148   /// Data - Raw data bytes for abbreviation.
 149   ///
 150   SmallVector<DIEAbbrevData, 8> Data;
 151 public:
 152   DIEAbbrev(unsigned T, unsigned C) : Tag(T), ChildrenFlag(C), Data() {}
 153   virtual ~DIEAbbrev() {}
 154
 155   // Accessors.
 156   unsigned getTag()                           const { return Tag; }
 157   unsigned getNumber()                        const { return Number; }
 158   unsigned getChildrenFlag()                  const { return ChildrenFlag; }
 159   const SmallVector<DIEAbbrevData, 8> &getData() const { return Data; }
 160   void setTag(unsigned T)                           { Tag = T; }
 161   void setChildrenFlag(unsigned CF)                 { ChildrenFlag = CF; }
 162   void setNumber(unsigned N)                        { Number = N; }
 163
 164   /// AddAttribute - Adds another set of attribute information to the
 165   /// abbreviation.
 166   void AddAttribute(unsigned Attribute, unsigned Form) {
 167     Data.push_back(DIEAbbrevData(Attribute, Form));
 168   }
 169
 170   /// AddFirstAttribute - Adds a set of attribute information to the front
 171   /// of the abbreviation.
 172   void AddFirstAttribute(unsigned Attribute, unsigned Form) {
 173     Data.insert(Data.begin(), DIEAbbrevData(Attribute, Form));
 174   }
 175
 176   /// Profile - Used to gather unique data for the abbreviation folding set.
 177   ///
 178   void Profile(FoldingSetNodeID &ID) {
 179     ID.AddInteger(Tag);
 180     ID.AddInteger(ChildrenFlag);
 181
 182     // For each attribute description.
 183     for (unsigned i = 0, N = Data.size(); i < N; ++i)
 184       Data[i].Profile(ID);
 185   }
 186
 187   /// Emit - Print the abbreviation using the specified Dwarf writer.
 188   ///
 189   void Emit(const DwarfDebug &DD) const;
 190
 191 #ifndef NDEBUG
 192   void print(std::ostream *O) {
 193     if (O) print(*O);
 194   }
 195   void print(std::ostream &O);
 196   void dump();
 197 #endif
 198 };
 199
 200 //===----------------------------------------------------------------------===//
 201 /// DIE - A structured debug information entry.  Has an abbreviation which
 202 /// describes it's organization.
 203 class DIE : public FoldingSetNode {
 204 protected:
 205   /// Abbrev - Buffer for constructing abbreviation.
 206   ///
 207   DIEAbbrev Abbrev;
 208
 209   /// Offset - Offset in debug info section.
 210   ///
 211   unsigned Offset;
 212
 213   /// Size - Size of instance + children.
 214   ///
 215   unsigned Size;
 216
 217   /// Children DIEs.
 218   ///
 219   std::vector<DIE *> Children;
 220
 221   /// Attributes values.
 222   ///
 223   SmallVector<DIEValue*, 32> Values;
 224
 225 public:
 226   explicit DIE(unsigned Tag)
 227     : Abbrev(Tag, DW_CHILDREN_no), Offset(0), Size(0), Children(), Values() {}
 228   virtual ~DIE();
 229
 230   // Accessors.
 231   DIEAbbrev &getAbbrev()                           { return Abbrev; }
 232   unsigned   getAbbrevNumber()               const {
 233     return Abbrev.getNumber();
 234   }
 235   unsigned getTag()                          const { return Abbrev.getTag(); }
 236   unsigned getOffset()                       const { return Offset; }
 237   unsigned getSize()                         const { return Size; }
 238   const std::vector<DIE *> &getChildren()    const { return Children; }
 239   SmallVector<DIEValue*, 32> &getValues()       { return Values; }
 240   void setTag(unsigned Tag)                  { Abbrev.setTag(Tag); }
 241   void setOffset(unsigned O)                 { Offset = O; }
 242   void setSize(unsigned S)                   { Size = S; }
 243
 244   /// AddValue - Add a value and attributes to a DIE.
 245   ///
 246   void AddValue(unsigned Attribute, unsigned Form, DIEValue *Value) {
 247     Abbrev.AddAttribute(Attribute, Form);
 248     Values.push_back(Value);
 249   }
 250
 251   /// SiblingOffset - Return the offset of the debug information entry's
 252   /// sibling.
 253   unsigned SiblingOffset() const { return Offset + Size; }
 254
 255   /// AddSiblingOffset - Add a sibling offset field to the front of the DIE.
 256   ///
 257   void AddSiblingOffset();
 258
 259   /// AddChild - Add a child to the DIE.
 260   ///
 261   void AddChild(DIE *Child) {
 262     Abbrev.setChildrenFlag(DW_CHILDREN_yes);
 263     Children.push_back(Child);
 264   }
 265
 266   /// Detach - Detaches objects connected to it after copying.
 267   ///
 268   void Detach() {
 269     Children.clear();
 270   }
 271
 272   /// Profile - Used to gather unique data for the value folding set.
 273   ///
 274   void Profile(FoldingSetNodeID &ID) ;
 275
 276 #ifndef NDEBUG
 277   void print(std::ostream *O, unsigned IncIndent = 0) {
 278     if (O) print(*O, IncIndent);
 279   }
 280   void print(std::ostream &O, unsigned IncIndent = 0);
 281   void dump();
 282 #endif
 283 };
 284
 285 //===----------------------------------------------------------------------===//
 286 /// DIEValue - A debug information entry value.
 287 ///
 288 class DIEValue : public FoldingSetNode {
 289 public:
 290   enum {
 291     isInteger,
 292     isString,
 293     isLabel,
 294     isAsIsLabel,
 295     isSectionOffset,
 296     isDelta,
 297     isEntry,
 298     isBlock
 299   };
 300
 301   /// Type - Type of data stored in the value.
 302   ///
 303   unsigned Type;
 304
 305   explicit DIEValue(unsigned T) : Type(T) {}
 306   virtual ~DIEValue() {}
 307
 308   // Accessors
 309   unsigned getType()  const { return Type; }
 310
 311   // Implement isa/cast/dyncast.
 312   static bool classof(const DIEValue *) { return true; }
 313
 314   /// EmitValue - Emit value via the Dwarf writer.
 315   ///
 316   virtual void EmitValue(DwarfDebug &DD, unsigned Form) = 0;
 317
 318   /// SizeOf - Return the size of a value in bytes.
 319   ///
 320   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const = 0;
 321
 322   /// Profile - Used to gather unique data for the value folding set.
 323   ///
 324   virtual void Profile(FoldingSetNodeID &ID) = 0;
 325
 326 #ifndef NDEBUG
 327   void print(std::ostream *O) {
 328     if (O) print(*O);
 329   }
 330   virtual void print(std::ostream &O) = 0;
 331   void dump();
 332 #endif
 333 };
 334
 335 //===----------------------------------------------------------------------===//
 336 /// DWInteger - An integer value DIE.
 337 ///
 338 class DIEInteger : public DIEValue {
 339 private:
 340   uint64_t Integer;
 341
 342 public:
 343   explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
 344
 345   // Implement isa/cast/dyncast.
 346   static bool classof(const DIEInteger *) { return true; }
 347   static bool classof(const DIEValue *I)  { return I->Type == isInteger; }
 348
 349   /// BestForm - Choose the best form for integer.
 350   ///
 351   static unsigned BestForm(bool IsSigned, uint64_t Integer) {
 352     if (IsSigned) {
 353       if ((char)Integer == (signed)Integer)   return DW_FORM_data1;
 354       if ((short)Integer == (signed)Integer)  return DW_FORM_data2;
 355       if ((int)Integer == (signed)Integer)    return DW_FORM_data4;
 356     } else {
 357       if ((unsigned char)Integer == Integer)  return DW_FORM_data1;
 358       if ((unsigned short)Integer == Integer) return DW_FORM_data2;
 359       if ((unsigned int)Integer == Integer)   return DW_FORM_data4;
 360     }
 361     return DW_FORM_data8;
 362   }
 363
 364   /// EmitValue - Emit integer of appropriate size.
 365   ///
 366   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 367
 368   /// SizeOf - Determine size of integer value in bytes.
 369   ///
 370   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
 371
 372   /// Profile - Used to gather unique data for the value folding set.
 373   ///
 374   static void Profile(FoldingSetNodeID &ID, unsigned Integer) {
 375     ID.AddInteger(isInteger);
 376     ID.AddInteger(Integer);
 377   }
 378   virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Integer); }
 379
 380 #ifndef NDEBUG
 381   virtual void print(std::ostream &O) {
 382     O << "Int: " << (int64_t)Integer
 383       << "  0x" << std::hex << Integer << std::dec;
 384   }
 385 #endif
 386 };
 387
 388 //===----------------------------------------------------------------------===//
 389 /// DIEString - A string value DIE.
 390 ///
 391 class DIEString : public DIEValue {
 392   const std::string Str;
 393 public:
 394   explicit DIEString(const std::string &S) : DIEValue(isString), Str(S) {}
 395
 396   // Implement isa/cast/dyncast.
 397   static bool classof(const DIEString *) { return true; }
 398   static bool classof(const DIEValue *S) { return S->Type == isString; }
 399
 400   /// EmitValue - Emit string value.
 401   ///
 402   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 403
 404   /// SizeOf - Determine size of string value in bytes.
 405   ///
 406   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const {
 407     return Str.size() + sizeof(char); // sizeof('\0');
 408   }
 409
 410   /// Profile - Used to gather unique data for the value folding set.
 411   ///
 412   static void Profile(FoldingSetNodeID &ID, const std::string &Str) {
 413     ID.AddInteger(isString);
 414     ID.AddString(Str);
 415   }
 416   virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Str); }
 417
 418 #ifndef NDEBUG
 419   virtual void print(std::ostream &O) {
 420     O << "Str: \"" << Str << "\"";
 421   }
 422 #endif
 423 };
 424
 425 //===----------------------------------------------------------------------===//
 426 /// DIEDwarfLabel - A Dwarf internal label expression DIE.
 427 //
 428 class DIEDwarfLabel : public DIEValue {
 429   const DWLabel Label;
 430 public:
 431   explicit DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {}
 432
 433   // Implement isa/cast/dyncast.
 434   static bool classof(const DIEDwarfLabel *)  { return true; }
 435   static bool classof(const DIEValue *L) { return L->Type == isLabel; }
 436
 437   /// EmitValue - Emit label value.
 438   ///
 439   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 440
 441   /// SizeOf - Determine size of label value in bytes.
 442   ///
 443   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
 444
 445   /// Profile - Used to gather unique data for the value folding set.
 446   ///
 447   static void Profile(FoldingSetNodeID &ID, const DWLabel &Label) {
 448     ID.AddInteger(isLabel);
 449     Label.Profile(ID);
 450   }
 451   virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label); }
 452
 453 #ifndef NDEBUG
 454   virtual void print(std::ostream &O) {
 455     O << "Lbl: ";
 456     Label.print(O);
 457   }
 458 #endif
 459 };
 460
 461 //===----------------------------------------------------------------------===//
 462 /// DIEObjectLabel - A label to an object in code or data.
 463 //
 464 class DIEObjectLabel : public DIEValue {
 465   const std::string Label;
 466 public:
 467   explicit DIEObjectLabel(const std::string &L)
 468   : DIEValue(isAsIsLabel), Label(L) {}
 469
 470   // Implement isa/cast/dyncast.
 471   static bool classof(const DIEObjectLabel *) { return true; }
 472   static bool classof(const DIEValue *L)    { return L->Type == isAsIsLabel; }
 473
 474   /// EmitValue - Emit label value.
 475   ///
 476   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 477
 478   /// SizeOf - Determine size of label value in bytes.
 479   ///
 480   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
 481
 482   /// Profile - Used to gather unique data for the value folding set.
 483   ///
 484   static void Profile(FoldingSetNodeID &ID, const std::string &Label) {
 485     ID.AddInteger(isAsIsLabel);
 486     ID.AddString(Label);
 487   }
 488   virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label.c_str()); }
 489
 490 #ifndef NDEBUG
 491   virtual void print(std::ostream &O) {
 492     O << "Obj: " << Label;
 493   }
 494 #endif
 495 };
 496
 497 //===----------------------------------------------------------------------===//
 498 /// DIESectionOffset - A section offset DIE.
 499 //
 500 class DIESectionOffset : public DIEValue {
 501   const DWLabel Label;
 502   const DWLabel Section;
 503   bool IsEH : 1;
 504   bool UseSet : 1;
 505 public:
 506   DIESectionOffset(const DWLabel &Lab, const DWLabel &Sec,
 507                    bool isEH = false, bool useSet = true)
 508     : DIEValue(isSectionOffset), Label(Lab), Section(Sec),
 509       IsEH(isEH), UseSet(useSet) {}
 510
 511   // Implement isa/cast/dyncast.
 512   static bool classof(const DIESectionOffset *)  { return true; }
 513   static bool classof(const DIEValue *D) { return D->Type == isSectionOffset; }
 514
 515   /// EmitValue - Emit section offset.
 516   ///
 517   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 518
 519   /// SizeOf - Determine size of section offset value in bytes.
 520   ///
 521   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
 522
 523   /// Profile - Used to gather unique data for the value folding set.
 524   ///
 525   static void Profile(FoldingSetNodeID &ID, const DWLabel &Label,
 526                                             const DWLabel &Section) {
 527     ID.AddInteger(isSectionOffset);
 528     Label.Profile(ID);
 529     Section.Profile(ID);
 530     // IsEH and UseSet are specific to the Label/Section that we will emit
 531     // the offset for; so Label/Section are enough for uniqueness.
 532   }
 533   virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label, Section); }
 534
 535 #ifndef NDEBUG
 536   virtual void print(std::ostream &O) {
 537     O << "Off: ";
 538     Label.print(O);
 539     O << "-";
 540     Section.print(O);
 541     O << "-" << IsEH << "-" << UseSet;
 542   }
 543 #endif
 544 };
 545
 546 //===----------------------------------------------------------------------===//
 547 /// DIEDelta - A simple label difference DIE.
 548 ///
 549 class DIEDelta : public DIEValue {
 550   const DWLabel LabelHi;
 551   const DWLabel LabelLo;
 552 public:
 553   DIEDelta(const DWLabel &Hi, const DWLabel &Lo)
 554     : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
 555
 556   // Implement isa/cast/dyncast.
 557   static bool classof(const DIEDelta *)  { return true; }
 558   static bool classof(const DIEValue *D) { return D->Type == isDelta; }
 559
 560   /// EmitValue - Emit delta value.
 561   ///
 562   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 563
 564   /// SizeOf - Determine size of delta value in bytes.
 565   ///
 566   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
 567
 568   /// Profile - Used to gather unique data for the value folding set.
 569   ///
 570   static void Profile(FoldingSetNodeID &ID, const DWLabel &LabelHi,
 571                                             const DWLabel &LabelLo) {
 572     ID.AddInteger(isDelta);
 573     LabelHi.Profile(ID);
 574     LabelLo.Profile(ID);
 575   }
 576   virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, LabelHi, LabelLo); }
 577
 578 #ifndef NDEBUG
 579   virtual void print(std::ostream &O) {
 580     O << "Del: ";
 581     LabelHi.print(O);
 582     O << "-";
 583     LabelLo.print(O);
 584   }
 585 #endif
 586 };
 587
 588 //===----------------------------------------------------------------------===//
 589 /// DIEntry - A pointer to another debug information entry.  An instance of this
 590 /// class can also be used as a proxy for a debug information entry not yet
 591 /// defined (ie. types.)
 592 class DIEntry : public DIEValue {
 593   DIE *Entry;
 594 public:
 595   explicit DIEntry(DIE *E) : DIEValue(isEntry), Entry(E) {}
 596
 597   void setEntry(DIE *E) { Entry = E; }
 598
 599   // Implement isa/cast/dyncast.
 600   static bool classof(const DIEntry *)   { return true; }
 601   static bool classof(const DIEValue *E) { return E->Type == isEntry; }
 602
 603   /// EmitValue - Emit debug information entry offset.
 604   ///
 605   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 606
 607   /// SizeOf - Determine size of debug information entry in bytes.
 608   ///
 609   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const {
 610     return sizeof(int32_t);
 611   }
 612
 613   /// Profile - Used to gather unique data for the value folding set.
 614   ///
 615   static void Profile(FoldingSetNodeID &ID, DIE *Entry) {
 616     ID.AddInteger(isEntry);
 617     ID.AddPointer(Entry);
 618   }
 619   virtual void Profile(FoldingSetNodeID &ID) {
 620     ID.AddInteger(isEntry);
 621
 622     if (Entry) {
 623       ID.AddPointer(Entry);
 624     } else {
 625       ID.AddPointer(this);
 626     }
 627   }
 628
 629 #ifndef NDEBUG
 630   virtual void print(std::ostream &O) {
 631     O << "Die: 0x" << std::hex << (intptr_t)Entry << std::dec;
 632   }
 633 #endif
 634 };
 635
 636 //===----------------------------------------------------------------------===//
 637 /// DIEBlock - A block of values.  Primarily used for location expressions.
 638 //
 639 class DIEBlock : public DIEValue, public DIE {
 640   unsigned Size;                // Size in bytes excluding size header.
 641 public:
 642   DIEBlock()
 643     : DIEValue(isBlock), DIE(0), Size(0) {}
 644   virtual ~DIEBlock() {}
 645
 646   // Implement isa/cast/dyncast.
 647   static bool classof(const DIEBlock *)  { return true; }
 648   static bool classof(const DIEValue *E) { return E->Type == isBlock; }
 649
 650   /// ComputeSize - calculate the size of the block.
 651   ///
 652   unsigned ComputeSize(DwarfDebug &DD);
 653
 654   /// BestForm - Choose the best form for data.
 655   ///
 656   unsigned BestForm() const {
 657     if ((unsigned char)Size == Size)  return DW_FORM_block1;
 658     if ((unsigned short)Size == Size) return DW_FORM_block2;
 659     if ((unsigned int)Size == Size)   return DW_FORM_block4;
 660     return DW_FORM_block;
 661   }
 662
 663   /// EmitValue - Emit block data.
 664   ///
 665   virtual void EmitValue(DwarfDebug &DD, unsigned Form);
 666
 667   /// SizeOf - Determine size of block data in bytes.
 668   ///
 669   virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
 670
 671   /// Profile - Used to gather unique data for the value folding set.
 672   ///
 673   virtual void Profile(FoldingSetNodeID &ID) {
 674     ID.AddInteger(isBlock);
 675     DIE::Profile(ID);
 676   }
 677
 678 #ifndef NDEBUG
 679   virtual void print(std::ostream &O) {
 680     O << "Blk: ";
 681     DIE::print(O, 5);
 682   }
 683 #endif
 684 };
 685
 686 //===----------------------------------------------------------------------===//
 687 /// CompileUnit - This dwarf writer support class manages information associate
 688 /// with a source file.
 689 class CompileUnit {
 690   /// ID - File identifier for source.
 691   ///
 692   unsigned ID;
 693
 694   /// Die - Compile unit debug information entry.
 695   ///
 696   DIE *Die;
 697
 698   /// GVToDieMap - Tracks the mapping of unit level debug informaton
 699   /// variables to debug information entries.
 700   std::map<GlobalVariable *, DIE *> GVToDieMap;
 701
 702   /// GVToDIEntryMap - Tracks the mapping of unit level debug informaton
 703   /// descriptors to debug information entries using a DIEntry proxy.
 704   std::map<GlobalVariable *, DIEntry *> GVToDIEntryMap;
 705
 706   /// Globals - A map of globally visible named entities for this unit.
 707   ///
 708   StringMap<DIE*> Globals;
 709
 710   /// DiesSet - Used to uniquely define dies within the compile unit.
 711   ///
 712   FoldingSet<DIE> DiesSet;
 713 public:
 714   CompileUnit(unsigned I, DIE *D)
 715     : ID(I), Die(D), GVToDieMap(),
 716       GVToDIEntryMap(), Globals(), DiesSet(InitDiesSetSize)
 717   {}
 718
 719   ~CompileUnit() {
 720     delete Die;
 721   }
 722
 723   // Accessors.
 724   unsigned getID()           const { return ID; }
 725   DIE* getDie()              const { return Die; }
 726   StringMap<DIE*> &getGlobals() { return Globals; }
 727
 728   /// hasContent - Return true if this compile unit has something to write out.
 729   ///
 730   bool hasContent() const {
 731     return !Die->getChildren().empty();
 732   }
 733
 734   /// AddGlobal - Add a new global entity to the compile unit.
 735   ///
 736   void AddGlobal(const std::string &Name, DIE *Die) {
 737     Globals[Name] = Die;
 738   }
 739
 740   /// getDieMapSlotFor - Returns the debug information entry map slot for the
 741   /// specified debug variable.
 742   DIE *&getDieMapSlotFor(GlobalVariable *GV) {
 743     return GVToDieMap[GV];
 744   }
 745
 746   /// getDIEntrySlotFor - Returns the debug information entry proxy slot for the
 747   /// specified debug variable.
 748   DIEntry *&getDIEntrySlotFor(GlobalVariable *GV) {
 749     return GVToDIEntryMap[GV];
 750   }
 751
 752   /// AddDie - Adds or interns the DIE to the compile unit.
 753   ///
 754   DIE *AddDie(DIE &Buffer) {
 755     FoldingSetNodeID ID;
 756     Buffer.Profile(ID);
 757     void *Where;
 758     DIE *Die = DiesSet.FindNodeOrInsertPos(ID, Where);
 759
 760     if (!Die) {
 761       Die = new DIE(Buffer);
 762       DiesSet.InsertNode(Die, Where);
 763       this->Die->AddChild(Die);
 764       Buffer.Detach();
 765     }
 766
 767     return Die;
 768   }
 769 };
 770
 771 //===----------------------------------------------------------------------===//
 772 /// Dwarf - Emits general Dwarf directives.
 773 ///
 774 class Dwarf {
 775 protected:
 776   //===--------------------------------------------------------------------===//
 777   // Core attributes used by the Dwarf writer.
 778   //
 779
 780   //
 781   /// O - Stream to .s file.
 782   ///
 783   raw_ostream &O;
 784
 785   /// Asm - Target of Dwarf emission.
 786   ///
 787   AsmPrinter *Asm;
 788
 789   /// TAI - Target asm information.
 790   const TargetAsmInfo *TAI;
 791
 792   /// TD - Target data.
 793   const TargetData *TD;
 794
 795   /// RI - Register Information.
 796   const TargetRegisterInfo *RI;
 797
 798   /// M - Current module.
 799   ///
 800   Module *M;
 801
 802   /// MF - Current machine function.
 803   ///
 804   MachineFunction *MF;
 805
 806   /// MMI - Collected machine module information.
 807   ///
 808   MachineModuleInfo *MMI;
 809
 810   /// SubprogramCount - The running count of functions being compiled.
 811   ///
 812   unsigned SubprogramCount;
 813
 814   /// Flavor - A unique string indicating what dwarf producer this is, used to
 815   /// unique labels.
 816   const char * const Flavor;
 817
 818   unsigned SetCounter;
 819   Dwarf(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T,
 820         const char *flavor)
 821   : O(OS)
 822   , Asm(A)
 823   , TAI(T)
 824   , TD(Asm->TM.getTargetData())
 825   , RI(Asm->TM.getRegisterInfo())
 826   , M(NULL)
 827   , MF(NULL)
 828   , MMI(NULL)
 829   , SubprogramCount(0)
 830   , Flavor(flavor)
 831   , SetCounter(1)
 832   {
 833   }
 834
 835 public:
 836   //===--------------------------------------------------------------------===//
 837   // Accessors.
 838   //
 839   const AsmPrinter *getAsm() const { return Asm; }
 840   MachineModuleInfo *getMMI() const { return MMI; }
 841   const TargetAsmInfo *getTargetAsmInfo() const { return TAI; }
 842   const TargetData *getTargetData() const { return TD; }
 843
 844   void PrintRelDirective(bool Force32Bit = false, bool isInSection = false)
 845                                                                          const {
 846     if (isInSection && TAI->getDwarfSectionOffsetDirective())
 847       O << TAI->getDwarfSectionOffsetDirective();
 848     else if (Force32Bit || TD->getPointerSize() == sizeof(int32_t))
 849       O << TAI->getData32bitsDirective();
 850     else
 851       O << TAI->getData64bitsDirective();
 852   }
 853
 854   /// PrintLabelName - Print label name in form used by Dwarf writer.
 855   ///
 856   void PrintLabelName(DWLabel Label) const {
 857     PrintLabelName(Label.Tag, Label.Number);
 858   }
 859   void PrintLabelName(const char *Tag, unsigned Number) const {
 860     O << TAI->getPrivateGlobalPrefix() << Tag;
 861     if (Number) O << Number;
 862   }
 863
 864   void PrintLabelName(const char *Tag, unsigned Number,
 865                       const char *Suffix) const {
 866     O << TAI->getPrivateGlobalPrefix() << Tag;
 867     if (Number) O << Number;
 868     O << Suffix;
 869   }
 870
 871   /// EmitLabel - Emit location label for internal use by Dwarf.
 872   ///
 873   void EmitLabel(DWLabel Label) const {
 874     EmitLabel(Label.Tag, Label.Number);
 875   }
 876   void EmitLabel(const char *Tag, unsigned Number) const {
 877     PrintLabelName(Tag, Number);
 878     O << ":\n";
 879   }
 880
 881   /// EmitReference - Emit a reference to a label.
 882   ///
 883   void EmitReference(DWLabel Label, bool IsPCRelative = false,
 884                      bool Force32Bit = false) const {
 885     EmitReference(Label.Tag, Label.Number, IsPCRelative, Force32Bit);
 886   }
 887   void EmitReference(const char *Tag, unsigned Number,
 888                      bool IsPCRelative = false, bool Force32Bit = false) const {
 889     PrintRelDirective(Force32Bit);
 890     PrintLabelName(Tag, Number);
 891
 892     if (IsPCRelative) O << "-" << TAI->getPCSymbol();
 893   }
 894   void EmitReference(const std::string &Name, bool IsPCRelative = false,
 895                      bool Force32Bit = false) const {
 896     PrintRelDirective(Force32Bit);
 897
 898     O << Name;
 899
 900     if (IsPCRelative) O << "-" << TAI->getPCSymbol();
 901   }
 902
 903   /// EmitDifference - Emit the difference between two labels.  Some
 904   /// assemblers do not behave with absolute expressions with data directives,
 905   /// so there is an option (needsSet) to use an intermediary set expression.
 906   void EmitDifference(DWLabel LabelHi, DWLabel LabelLo,
 907                       bool IsSmall = false) {
 908     EmitDifference(LabelHi.Tag, LabelHi.Number,
 909                    LabelLo.Tag, LabelLo.Number,
 910                    IsSmall);
 911   }
 912   void EmitDifference(const char *TagHi, unsigned NumberHi,
 913                       const char *TagLo, unsigned NumberLo,
 914                       bool IsSmall = false) {
 915     if (TAI->needsSet()) {
 916       O << "\t.set\t";
 917       PrintLabelName("set", SetCounter, Flavor);
 918       O << ",";
 919       PrintLabelName(TagHi, NumberHi);
 920       O << "-";
 921       PrintLabelName(TagLo, NumberLo);
 922       O << "\n";
 923
 924       PrintRelDirective(IsSmall);
 925       PrintLabelName("set", SetCounter, Flavor);
 926       ++SetCounter;
 927     } else {
 928       PrintRelDirective(IsSmall);
 929
 930       PrintLabelName(TagHi, NumberHi);
 931       O << "-";
 932       PrintLabelName(TagLo, NumberLo);
 933     }
 934   }
 935
 936   void EmitSectionOffset(const char* Label, const char* Section,
 937                          unsigned LabelNumber, unsigned SectionNumber,
 938                          bool IsSmall = false, bool isEH = false,
 939                          bool useSet = true) {
 940     bool printAbsolute = false;
 941     if (isEH)
 942       printAbsolute = TAI->isAbsoluteEHSectionOffsets();
 943     else
 944       printAbsolute = TAI->isAbsoluteDebugSectionOffsets();
 945
 946     if (TAI->needsSet() && useSet) {
 947       O << "\t.set\t";
 948       PrintLabelName("set", SetCounter, Flavor);
 949       O << ",";
 950       PrintLabelName(Label, LabelNumber);
 951
 952       if (!printAbsolute) {
 953         O << "-";
 954         PrintLabelName(Section, SectionNumber);
 955       }
 956       O << "\n";
 957
 958       PrintRelDirective(IsSmall);
 959
 960       PrintLabelName("set", SetCounter, Flavor);
 961       ++SetCounter;
 962     } else {
 963       PrintRelDirective(IsSmall, true);
 964
 965       PrintLabelName(Label, LabelNumber);
 966
 967       if (!printAbsolute) {
 968         O << "-";
 969         PrintLabelName(Section, SectionNumber);
 970       }
 971     }
 972   }
 973
 974   /// EmitFrameMoves - Emit frame instructions to describe the layout of the
 975   /// frame.
 976   void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID,
 977                       const std::vector<MachineMove> &Moves, bool isEH) {
 978     int stackGrowth =
 979         Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
 980           TargetFrameInfo::StackGrowsUp ?
 981             TD->getPointerSize() : -TD->getPointerSize();
 982     bool IsLocal = BaseLabel && strcmp(BaseLabel, "label") == 0;
 983
 984     for (unsigned i = 0, N = Moves.size(); i < N; ++i) {
 985       const MachineMove &Move = Moves[i];
 986       unsigned LabelID = Move.getLabelID();
 987
 988       if (LabelID) {
 989         LabelID = MMI->MappedLabel(LabelID);
 990
 991         // Throw out move if the label is invalid.
 992         if (!LabelID) continue;
 993       }
 994
 995       const MachineLocation &Dst = Move.getDestination();
 996       const MachineLocation &Src = Move.getSource();
 997
 998       // Advance row if new location.
 999       if (BaseLabel && LabelID && (BaseLabelID != LabelID || !IsLocal)) {
1000         Asm->EmitInt8(DW_CFA_advance_loc4);
1001         Asm->EOL("DW_CFA_advance_loc4");
1002         EmitDifference("label", LabelID, BaseLabel, BaseLabelID, true);
1003         Asm->EOL();
1004
1005         BaseLabelID = LabelID;
1006         BaseLabel = "label";
1007         IsLocal = true;
1008       }
1009
1010       // If advancing cfa.
1011       if (Dst.isReg() && Dst.getReg() == MachineLocation::VirtualFP) {
1012         if (!Src.isReg()) {
1013           if (Src.getReg() == MachineLocation::VirtualFP) {
1014             Asm->EmitInt8(DW_CFA_def_cfa_offset);
1015             Asm->EOL("DW_CFA_def_cfa_offset");
1016           } else {
1017             Asm->EmitInt8(DW_CFA_def_cfa);
1018             Asm->EOL("DW_CFA_def_cfa");
1019             Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Src.getReg(), isEH));
1020             Asm->EOL("Register");
1021           }
1022
1023           int Offset = -Src.getOffset();
1024
1025           Asm->EmitULEB128Bytes(Offset);
1026           Asm->EOL("Offset");
1027         } else {
1028           assert(0 && "Machine move no supported yet.");
1029         }
1030       } else if (Src.isReg() &&
1031         Src.getReg() == MachineLocation::VirtualFP) {
1032         if (Dst.isReg()) {
1033           Asm->EmitInt8(DW_CFA_def_cfa_register);
1034           Asm->EOL("DW_CFA_def_cfa_register");
1035           Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getReg(), isEH));
1036           Asm->EOL("Register");
1037         } else {
1038           assert(0 && "Machine move no supported yet.");
1039         }
1040       } else {
1041         unsigned Reg = RI->getDwarfRegNum(Src.getReg(), isEH);
1042         int Offset = Dst.getOffset() / stackGrowth;
1043
1044         if (Offset < 0) {
1045           Asm->EmitInt8(DW_CFA_offset_extended_sf);
1046           Asm->EOL("DW_CFA_offset_extended_sf");
1047           Asm->EmitULEB128Bytes(Reg);
1048           Asm->EOL("Reg");
1049           Asm->EmitSLEB128Bytes(Offset);
1050           Asm->EOL("Offset");
1051         } else if (Reg < 64) {
1052           Asm->EmitInt8(DW_CFA_offset + Reg);
1053           if (Asm->isVerbose())
1054             Asm->EOL("DW_CFA_offset + Reg (" + utostr(Reg) + ")");
1055           else
1056             Asm->EOL();
1057           Asm->EmitULEB128Bytes(Offset);
1058           Asm->EOL("Offset");
1059         } else {
1060           Asm->EmitInt8(DW_CFA_offset_extended);
1061           Asm->EOL("DW_CFA_offset_extended");
1062           Asm->EmitULEB128Bytes(Reg);
1063           Asm->EOL("Reg");
1064           Asm->EmitULEB128Bytes(Offset);
1065           Asm->EOL("Offset");
1066         }
1067       }
1068     }
1069   }
1070
1071 };
1072
1073 //===----------------------------------------------------------------------===//
1074 /// SrcLineInfo - This class is used to record source line correspondence.
1075 ///
1076 class SrcLineInfo {
1077   unsigned Line;                        // Source line number.
1078   unsigned Column;                      // Source column.
1079   unsigned SourceID;                    // Source ID number.
1080   unsigned LabelID;                     // Label in code ID number.
1081 public:
1082   SrcLineInfo(unsigned L, unsigned C, unsigned S, unsigned I)
1083     : Line(L), Column(C), SourceID(S), LabelID(I) {}
1084
1085   // Accessors
1086   unsigned getLine()     const { return Line; }
1087   unsigned getColumn()   const { return Column; }
1088   unsigned getSourceID() const { return SourceID; }
1089   unsigned getLabelID()  const { return LabelID; }
1090 };
1091
1092 //===----------------------------------------------------------------------===//
1093 /// DbgVariable - This class is used to track local variable information.
1094 ///
1095 class DbgVariable {
1096   DIVariable Var;                   // Variable Descriptor.
1097   unsigned FrameIndex;              // Variable frame index.
1098 public:
1099   DbgVariable(DIVariable V, unsigned I) : Var(V), FrameIndex(I)  {}
1100
1101   // Accessors.
1102   DIVariable getVariable()  const { return Var; }
1103   unsigned getFrameIndex() const { return FrameIndex; }
1104 };
1105
1106 //===----------------------------------------------------------------------===//
1107 /// DbgScope - This class is used to track scope information.
1108 ///
1109 class DbgScope {
1110   DbgScope *Parent;                   // Parent to this scope.
1111   DIDescriptor Desc;                  // Debug info descriptor for scope.
1112                                       // Either subprogram or block.
1113   unsigned StartLabelID;              // Label ID of the beginning of scope.
1114   unsigned EndLabelID;                // Label ID of the end of scope.
1115   SmallVector<DbgScope *, 4> Scopes;  // Scopes defined in scope.
1116   SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
1117 public:
1118   DbgScope(DbgScope *P, DIDescriptor D)
1119   : Parent(P), Desc(D), StartLabelID(0), EndLabelID(0), Scopes(), Variables()
1120   {}
1121   virtual ~DbgScope() {
1122     for (unsigned i = 0, N = Scopes.size(); i < N; ++i) delete Scopes[i];
1123     for (unsigned j = 0, M = Variables.size(); j < M; ++j) delete Variables[j];
1124   }
1125
1126   // Accessors.
1127   DbgScope *getParent()          const { return Parent; }
1128   DIDescriptor getDesc()         const { return Desc; }
1129   unsigned getStartLabelID()     const { return StartLabelID; }
1130   unsigned getEndLabelID()       const { return EndLabelID; }
1131   SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
1132   SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
1133   void setStartLabelID(unsigned S) { StartLabelID = S; }
1134   void setEndLabelID(unsigned E)   { EndLabelID = E; }
1135
1136   /// AddScope - Add a scope to the scope.
1137   ///
1138   void AddScope(DbgScope *S) { Scopes.push_back(S); }
1139
1140   /// AddVariable - Add a variable to the scope.
1141   ///
1142   void AddVariable(DbgVariable *V) { Variables.push_back(V); }
1143
1144   virtual bool isInlinedSubroutine() { return false; }
1145   virtual unsigned getLine()   { assert ( 0 && "Unexpected scope!"); return 0; }
1146   virtual unsigned getColumn() { assert ( 0 && "Unexpected scope!"); return 0; }
1147   virtual unsigned getFile()   { assert ( 0 && "Unexpected scope!"); return 0; }
1148
1149 #ifndef NDEBUG
1150   void dump() const;
1151 #endif
1152 };
1153
1154 #ifndef NDEBUG
1155 void DbgScope::dump() const {
1156   static unsigned IndentLevel = 0;
1157   std::string Indent(IndentLevel, ' ');
1158
1159   cerr << Indent; Desc.dump();
1160   cerr << " [" << StartLabelID << ", " << EndLabelID << "]\n";
1161
1162   IndentLevel += 2;
1163
1164   for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
1165     if (Scopes[i] != this)
1166       Scopes[i]->dump();
1167
1168   IndentLevel -= 2;
1169 }
1170 #endif
1171
1172 //===----------------------------------------------------------------------===//
1173 /// DbgInlinedSubroutineScope - This class is used to track inlined subroutine
1174 /// scope information.
1175 ///
1176 class DbgInlinedSubroutineScope : public DbgScope {
1177   unsigned Src;
1178   unsigned Line;
1179   unsigned Col;
1180 public:
1181   DbgInlinedSubroutineScope(DbgScope *P, DIDescriptor D,
1182                             unsigned S, unsigned L, unsigned C)
1183     : DbgScope(P, D), Src(S), Line(L), Col(C)
1184   {}
1185
1186   unsigned getLine()         { return Line; }
1187   unsigned getColumn()       { return Col; }
1188   unsigned getFile()         { return Src; }
1189   bool isInlinedSubroutine() { return true; }
1190 };
1191
1192 //===----------------------------------------------------------------------===//
1193 /// DwarfDebug - Emits Dwarf debug directives.
1194 ///
1195 class DwarfDebug : public Dwarf {
1196   //===--------------------------------------------------------------------===//
1197   // Attributes used to construct specific Dwarf sections.
1198   //
1199
1200   /// CompileUnitMap - A map of global variables representing compile units to
1201   /// compile units.
1202   DenseMap<Value *, CompileUnit *> CompileUnitMap;
1203
1204   /// CompileUnits - All the compile units in this module.
1205   ///
1206   SmallVector<CompileUnit *, 8> CompileUnits;
1207
1208   /// MainCU - Some platform prefers one compile unit per .o file. In such
1209   /// cases, all dies are inserted in MainCU.
1210   CompileUnit *MainCU;
1211
1212   /// AbbreviationsSet - Used to uniquely define abbreviations.
1213   ///
1214   FoldingSet<DIEAbbrev> AbbreviationsSet;
1215
1216   /// Abbreviations - A list of all the unique abbreviations in use.
1217   ///
1218   std::vector<DIEAbbrev *> Abbreviations;
1219
1220   /// DirectoryIdMap - Directory name to directory id map.
1221   ///
1222   StringMap<unsigned> DirectoryIdMap;
1223
1224   /// DirectoryNames - A list of directory names.
1225   SmallVector<std::string, 8> DirectoryNames;
1226
1227   /// SourceFileIdMap - Source file name to source file id map.
1228   ///
1229   StringMap<unsigned> SourceFileIdMap;
1230
1231   /// SourceFileNames - A list of source file names.
1232   SmallVector<std::string, 8> SourceFileNames;
1233
1234   /// SourceIdMap - Source id map, i.e. pair of directory id and source file
1235   /// id mapped to a unique id.
1236   DenseMap<std::pair<unsigned, unsigned>, unsigned> SourceIdMap;
1237
1238   /// SourceIds - Reverse map from source id to directory id + file id pair.
1239   ///
1240   SmallVector<std::pair<unsigned, unsigned>, 8> SourceIds;
1241
1242   /// Lines - List of of source line correspondence.
1243   std::vector<SrcLineInfo> Lines;
1244
1245   /// ValuesSet - Used to uniquely define values.
1246   ///
1247   FoldingSet<DIEValue> ValuesSet;
1248
1249   /// Values - A list of all the unique values in use.
1250   ///
1251   std::vector<DIEValue *> Values;
1252
1253   /// StringPool - A UniqueVector of strings used by indirect references.
1254   ///
1255   UniqueVector<std::string> StringPool;
1256
1257   /// SectionMap - Provides a unique id per text section.
1258   ///
1259   UniqueVector<const Section*> SectionMap;
1260
1261   /// SectionSourceLines - Tracks line numbers per text section.
1262   ///
1263   std::vector<std::vector<SrcLineInfo> > SectionSourceLines;
1264
1265   /// didInitial - Flag to indicate if initial emission has been done.
1266   ///
1267   bool didInitial;
1268
1269   /// shouldEmit - Flag to indicate if debug information should be emitted.
1270   ///
1271   bool shouldEmit;
1272
1273   // FunctionDbgScope - Top level scope for the current function.
1274   //
1275   DbgScope *FunctionDbgScope;
1276
1277   /// DbgScopeMap - Tracks the scopes in the current function.
1278   DenseMap<GlobalVariable *, DbgScope *> DbgScopeMap;
1279
1280   /// DbgInlinedScopeMap - Tracks inlined scopes in the current function.
1281   DenseMap<GlobalVariable *, SmallVector<DbgScope *, 2> > DbgInlinedScopeMap;
1282
1283   /// InlineInfo - Keep track of inlined functions and their location. This
1284   /// information is used to populate debug_inlined section.
1285   DenseMap<GlobalVariable *, SmallVector<unsigned, 4> > InlineInfo;
1286
1287   /// InlinedVariableScopes - Scopes information for the inlined subroutine
1288   /// variables.
1289   DenseMap<const MachineInstr *, DbgScope *> InlinedVariableScopes;
1290
1291   /// AbstractInstanceRootMap - Map of abstract instance roots of inlined
1292   /// functions. These are subroutine entries that contain a DW_AT_inline
1293   /// attribute.
1294   DenseMap<const GlobalVariable *, DbgScope *> AbstractInstanceRootMap;
1295
1296   /// AbstractInstanceRootList - List of abstract instance roots of inlined
1297   /// functions. These are subroutine entries that contain a DW_AT_inline
1298   /// attribute.
1299   SmallVector<DbgScope *, 32> AbstractInstanceRootList;
1300
1301   /// LexicalScopeToConcreteInstMap - Map a concrete instance's DIE to the
1302   /// lexical scope it's in.
1303   DenseMap<DbgScope *, DIE *> LexicalScopeToConcreteInstMap;
1304
1305   /// LexicalScopeStack - A stack of lexical scopes. The top one is the current
1306   /// scope.
1307   SmallVector<DbgScope *, 16> LexicalScopeStack;
1308
1309   /// DebugTimer - Timer for the Dwarf debug writer.
1310   Timer *DebugTimer;
1311
1312   struct FunctionDebugFrameInfo {
1313     unsigned Number;
1314     std::vector<MachineMove> Moves;
1315
1316     FunctionDebugFrameInfo(unsigned Num, const std::vector<MachineMove> &M):
1317       Number(Num), Moves(M) { }
1318   };
1319
1320   std::vector<FunctionDebugFrameInfo> DebugFrames;
1321
1322 private:
1323   /// getSourceDirectoryAndFileIds - Return the directory and file ids that
1324   /// maps to the source id. Source id starts at 1.
1325   std::pair<unsigned, unsigned>
1326   getSourceDirectoryAndFileIds(unsigned SId) const {
1327     return SourceIds[SId-1];
1328   }
1329
1330   /// getNumSourceDirectories - Return the number of source directories in the
1331   /// debug info.
1332   unsigned getNumSourceDirectories() const {
1333     return DirectoryNames.size();
1334   }
1335
1336   /// getSourceDirectoryName - Return the name of the directory corresponding
1337   /// to the id.
1338   const std::string &getSourceDirectoryName(unsigned Id) const {
1339     return DirectoryNames[Id - 1];
1340   }
1341
1342   /// getSourceFileName - Return the name of the source file corresponding
1343   /// to the id.
1344   const std::string &getSourceFileName(unsigned Id) const {
1345     return SourceFileNames[Id - 1];
1346   }
1347
1348   /// getNumSourceIds - Return the number of unique source ids.
1349   unsigned getNumSourceIds() const {
1350     return SourceIds.size();
1351   }
1352
1353   /// AssignAbbrevNumber - Define a unique number for the abbreviation.
1354   ///
1355   void AssignAbbrevNumber(DIEAbbrev &Abbrev) {
1356     // Profile the node so that we can make it unique.
1357     FoldingSetNodeID ID;
1358     Abbrev.Profile(ID);
1359
1360     // Check the set for priors.
1361     DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
1362
1363     // If it's newly added.
1364     if (InSet == &Abbrev) {
1365       // Add to abbreviation list.
1366       Abbreviations.push_back(&Abbrev);
1367       // Assign the vector position + 1 as its number.
1368       Abbrev.setNumber(Abbreviations.size());
1369     } else {
1370       // Assign existing abbreviation number.
1371       Abbrev.setNumber(InSet->getNumber());
1372     }
1373   }
1374
1375   /// NewString - Add a string to the constant pool and returns a label.
1376   ///
1377   DWLabel NewString(const std::string &String) {
1378     unsigned StringID = StringPool.insert(String);
1379     return DWLabel("string", StringID);
1380   }
1381
1382   /// NewDIEntry - Creates a new DIEntry to be a proxy for a debug information
1383   /// entry.
1384   DIEntry *NewDIEntry(DIE *Entry = NULL) {
1385     DIEntry *Value;
1386
1387     if (Entry) {
1388       FoldingSetNodeID ID;
1389       DIEntry::Profile(ID, Entry);
1390       void *Where;
1391       Value = static_cast<DIEntry *>(ValuesSet.FindNodeOrInsertPos(ID, Where));
1392
1393       if (Value) return Value;
1394
1395       Value = new DIEntry(Entry);
1396       ValuesSet.InsertNode(Value, Where);
1397     } else {
1398       Value = new DIEntry(Entry);
1399     }
1400
1401     Values.push_back(Value);
1402     return Value;
1403   }
1404
1405   /// SetDIEntry - Set a DIEntry once the debug information entry is defined.
1406   ///
1407   void SetDIEntry(DIEntry *Value, DIE *Entry) {
1408     Value->setEntry(Entry);
1409     // Add to values set if not already there.  If it is, we merely have a
1410     // duplicate in the values list (no harm.)
1411     ValuesSet.GetOrInsertNode(Value);
1412   }
1413
1414   /// AddUInt - Add an unsigned integer attribute data and value.
1415   ///
1416   void AddUInt(DIE *Die, unsigned Attribute, unsigned Form, uint64_t Integer) {
1417     if (!Form) Form = DIEInteger::BestForm(false, Integer);
1418
1419     FoldingSetNodeID ID;
1420     DIEInteger::Profile(ID, Integer);
1421     void *Where;
1422     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1423     if (!Value) {
1424       Value = new DIEInteger(Integer);
1425       ValuesSet.InsertNode(Value, Where);
1426       Values.push_back(Value);
1427     }
1428
1429     Die->AddValue(Attribute, Form, Value);
1430   }
1431
1432   /// AddSInt - Add an signed integer attribute data and value.
1433   ///
1434   void AddSInt(DIE *Die, unsigned Attribute, unsigned Form, int64_t Integer) {
1435     if (!Form) Form = DIEInteger::BestForm(true, Integer);
1436
1437     FoldingSetNodeID ID;
1438     DIEInteger::Profile(ID, (uint64_t)Integer);
1439     void *Where;
1440     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1441     if (!Value) {
1442       Value = new DIEInteger(Integer);
1443       ValuesSet.InsertNode(Value, Where);
1444       Values.push_back(Value);
1445     }
1446
1447     Die->AddValue(Attribute, Form, Value);
1448   }
1449
1450   /// AddString - Add a string attribute data and value.
1451   ///
1452   void AddString(DIE *Die, unsigned Attribute, unsigned Form,
1453                  const std::string &String) {
1454     FoldingSetNodeID ID;
1455     DIEString::Profile(ID, String);
1456     void *Where;
1457     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1458     if (!Value) {
1459       Value = new DIEString(String);
1460       ValuesSet.InsertNode(Value, Where);
1461       Values.push_back(Value);
1462     }
1463
1464     Die->AddValue(Attribute, Form, Value);
1465   }
1466
1467   /// AddLabel - Add a Dwarf label attribute data and value.
1468   ///
1469   void AddLabel(DIE *Die, unsigned Attribute, unsigned Form,
1470                      const DWLabel &Label) {
1471     FoldingSetNodeID ID;
1472     DIEDwarfLabel::Profile(ID, Label);
1473     void *Where;
1474     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1475     if (!Value) {
1476       Value = new DIEDwarfLabel(Label);
1477       ValuesSet.InsertNode(Value, Where);
1478       Values.push_back(Value);
1479     }
1480
1481     Die->AddValue(Attribute, Form, Value);
1482   }
1483
1484   /// AddObjectLabel - Add an non-Dwarf label attribute data and value.
1485   ///
1486   void AddObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
1487                       const std::string &Label) {
1488     FoldingSetNodeID ID;
1489     DIEObjectLabel::Profile(ID, Label);
1490     void *Where;
1491     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1492     if (!Value) {
1493       Value = new DIEObjectLabel(Label);
1494       ValuesSet.InsertNode(Value, Where);
1495       Values.push_back(Value);
1496     }
1497
1498     Die->AddValue(Attribute, Form, Value);
1499   }
1500
1501   /// AddSectionOffset - Add a section offset label attribute data and value.
1502   ///
1503   void AddSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
1504                         const DWLabel &Label, const DWLabel &Section,
1505                         bool isEH = false, bool useSet = true) {
1506     FoldingSetNodeID ID;
1507     DIESectionOffset::Profile(ID, Label, Section);
1508     void *Where;
1509     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1510     if (!Value) {
1511       Value = new DIESectionOffset(Label, Section, isEH, useSet);
1512       ValuesSet.InsertNode(Value, Where);
1513       Values.push_back(Value);
1514     }
1515
1516     Die->AddValue(Attribute, Form, Value);
1517   }
1518
1519   /// AddDelta - Add a label delta attribute data and value.
1520   ///
1521   void AddDelta(DIE *Die, unsigned Attribute, unsigned Form,
1522                 const DWLabel &Hi, const DWLabel &Lo) {
1523     FoldingSetNodeID ID;
1524     DIEDelta::Profile(ID, Hi, Lo);
1525     void *Where;
1526     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1527     if (!Value) {
1528       Value = new DIEDelta(Hi, Lo);
1529       ValuesSet.InsertNode(Value, Where);
1530       Values.push_back(Value);
1531     }
1532
1533     Die->AddValue(Attribute, Form, Value);
1534   }
1535
1536   /// AddDIEntry - Add a DIE attribute data and value.
1537   ///
1538   void AddDIEntry(DIE *Die, unsigned Attribute, unsigned Form, DIE *Entry) {
1539     Die->AddValue(Attribute, Form, NewDIEntry(Entry));
1540   }
1541
1542   /// AddBlock - Add block data.
1543   ///
1544   void AddBlock(DIE *Die, unsigned Attribute, unsigned Form, DIEBlock *Block) {
1545     Block->ComputeSize(*this);
1546     FoldingSetNodeID ID;
1547     Block->Profile(ID);
1548     void *Where;
1549     DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
1550     if (!Value) {
1551       Value = Block;
1552       ValuesSet.InsertNode(Value, Where);
1553       Values.push_back(Value);
1554     } else {
1555       // Already exists, reuse the previous one.
1556       delete Block;
1557       Block = cast<DIEBlock>(Value);
1558     }
1559
1560     Die->AddValue(Attribute, Block->BestForm(), Value);
1561   }
1562
1563   /// AddSourceLine - Add location information to specified debug information
1564   /// entry.
1565   void AddSourceLine(DIE *Die, const DIVariable *V) {
1566     // If there is no compile unit specified, don't add a line #.
1567     if (V->getCompileUnit().isNull())
1568       return;
1569
1570     unsigned Line = V->getLineNumber();
1571     unsigned FileID = FindCompileUnit(V->getCompileUnit()).getID();
1572     assert(FileID && "Invalid file id");
1573     AddUInt(Die, DW_AT_decl_file, 0, FileID);
1574     AddUInt(Die, DW_AT_decl_line, 0, Line);
1575   }
1576
1577   /// AddSourceLine - Add location information to specified debug information
1578   /// entry.
1579   void AddSourceLine(DIE *Die, const DIGlobal *G) {
1580     // If there is no compile unit specified, don't add a line #.
1581     if (G->getCompileUnit().isNull())
1582       return;
1583     unsigned Line = G->getLineNumber();
1584     unsigned FileID = FindCompileUnit(G->getCompileUnit()).getID();
1585     assert(FileID && "Invalid file id");
1586     AddUInt(Die, DW_AT_decl_file, 0, FileID);
1587     AddUInt(Die, DW_AT_decl_line, 0, Line);
1588   }
1589
1590   void AddSourceLine(DIE *Die, const DIType *Ty) {
1591     // If there is no compile unit specified, don't add a line #.
1592     DICompileUnit CU = Ty->getCompileUnit();
1593     if (CU.isNull())
1594       return;
1595
1596     unsigned Line = Ty->getLineNumber();
1597     unsigned FileID = FindCompileUnit(CU).getID();
1598     assert(FileID && "Invalid file id");
1599     AddUInt(Die, DW_AT_decl_file, 0, FileID);
1600     AddUInt(Die, DW_AT_decl_line, 0, Line);
1601   }
1602
1603   /// AddAddress - Add an address attribute to a die based on the location
1604   /// provided.
1605   void AddAddress(DIE *Die, unsigned Attribute,
1606                   const MachineLocation &Location) {
1607     unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
1608     DIEBlock *Block = new DIEBlock();
1609
1610     if (Location.isReg()) {
1611       if (Reg < 32) {
1612         AddUInt(Block, 0, DW_FORM_data1, DW_OP_reg0 + Reg);
1613       } else {
1614         AddUInt(Block, 0, DW_FORM_data1, DW_OP_regx);
1615         AddUInt(Block, 0, DW_FORM_udata, Reg);
1616       }
1617     } else {
1618       if (Reg < 32) {
1619         AddUInt(Block, 0, DW_FORM_data1, DW_OP_breg0 + Reg);
1620       } else {
1621         AddUInt(Block, 0, DW_FORM_data1, DW_OP_bregx);
1622         AddUInt(Block, 0, DW_FORM_udata, Reg);
1623       }
1624       AddUInt(Block, 0, DW_FORM_sdata, Location.getOffset());
1625     }
1626
1627     AddBlock(Die, Attribute, 0, Block);
1628   }
1629
1630   /// AddType - Add a new type attribute to the specified entity.
1631   void AddType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty) {
1632     if (Ty.isNull())
1633       return;
1634
1635     // Check for pre-existence.
1636     DIEntry *&Slot = DW_Unit->getDIEntrySlotFor(Ty.getGV());
1637     // If it exists then use the existing value.
1638     if (Slot) {
1639       Entity->AddValue(DW_AT_type, DW_FORM_ref4, Slot);
1640       return;
1641     }
1642
1643     // Set up proxy.
1644     Slot = NewDIEntry();
1645
1646     // Construct type.
1647     DIE Buffer(DW_TAG_base_type);
1648     if (Ty.isBasicType(Ty.getTag()))
1649       ConstructTypeDIE(DW_Unit, Buffer, DIBasicType(Ty.getGV()));
1650     else if (Ty.isDerivedType(Ty.getTag()))
1651       ConstructTypeDIE(DW_Unit, Buffer, DIDerivedType(Ty.getGV()));
1652     else {
1653       assert(Ty.isCompositeType(Ty.getTag()) && "Unknown kind of DIType");
1654       ConstructTypeDIE(DW_Unit, Buffer, DICompositeType(Ty.getGV()));
1655     }
1656
1657     // Add debug information entry to entity and appropriate context.
1658     DIE *Die = NULL;
1659     DIDescriptor Context = Ty.getContext();
1660     if (!Context.isNull())
1661       Die = DW_Unit->getDieMapSlotFor(Context.getGV());
1662
1663     if (Die) {
1664       DIE *Child = new DIE(Buffer);
1665       Die->AddChild(Child);
1666       Buffer.Detach();
1667       SetDIEntry(Slot, Child);
1668     } else {
1669       Die = DW_Unit->AddDie(Buffer);
1670       SetDIEntry(Slot, Die);
1671     }
1672
1673     Entity->AddValue(DW_AT_type, DW_FORM_ref4, Slot);
1674   }
1675
1676   /// ConstructTypeDIE - Construct basic type die from DIBasicType.
1677   void ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
1678                         DIBasicType BTy) {
1679
1680     // Get core information.
1681     std::string Name;
1682     BTy.getName(Name);
1683     Buffer.setTag(DW_TAG_base_type);
1684     AddUInt(&Buffer, DW_AT_encoding,  DW_FORM_data1, BTy.getEncoding());
1685     // Add name if not anonymous or intermediate type.
1686     if (!Name.empty())
1687       AddString(&Buffer, DW_AT_name, DW_FORM_string, Name);
1688     uint64_t Size = BTy.getSizeInBits() >> 3;
1689     AddUInt(&Buffer, DW_AT_byte_size, 0, Size);
1690   }
1691
1692   /// ConstructTypeDIE - Construct derived type die from DIDerivedType.
1693   void ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
1694                         DIDerivedType DTy) {
1695
1696     // Get core information.
1697     std::string Name;
1698     DTy.getName(Name);
1699     uint64_t Size = DTy.getSizeInBits() >> 3;
1700     unsigned Tag = DTy.getTag();
1701
1702     // FIXME - Workaround for templates.
1703     if (Tag == DW_TAG_inheritance) Tag = DW_TAG_reference_type;
1704
1705     Buffer.setTag(Tag);
1706
1707     // Map to main type, void will not have a type.
1708     DIType FromTy = DTy.getTypeDerivedFrom();
1709     AddType(DW_Unit, &Buffer, FromTy);
1710
1711     // Add name if not anonymous or intermediate type.
1712     if (!Name.empty())
1713       AddString(&Buffer, DW_AT_name, DW_FORM_string, Name);
1714
1715     // Add size if non-zero (derived types might be zero-sized.)
1716     if (Size)
1717       AddUInt(&Buffer, DW_AT_byte_size, 0, Size);
1718
1719     // Add source line info if available and TyDesc is not a forward
1720     // declaration.
1721     if (!DTy.isForwardDecl())
1722       AddSourceLine(&Buffer, &DTy);
1723   }
1724
1725   /// ConstructTypeDIE - Construct type DIE from DICompositeType.
1726   void ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
1727                         DICompositeType CTy) {
1728     // Get core information.
1729     std::string Name;
1730     CTy.getName(Name);
1731
1732     uint64_t Size = CTy.getSizeInBits() >> 3;
1733     unsigned Tag = CTy.getTag();
1734     Buffer.setTag(Tag);
1735
1736     switch (Tag) {
1737     case DW_TAG_vector_type:
1738     case DW_TAG_array_type:
1739       ConstructArrayTypeDIE(DW_Unit, Buffer, &CTy);
1740       break;
1741     case DW_TAG_enumeration_type:
1742       {
1743         DIArray Elements = CTy.getTypeArray();
1744         // Add enumerators to enumeration type.
1745         for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1746           DIE *ElemDie = NULL;
1747           DIEnumerator Enum(Elements.getElement(i).getGV());
1748           ElemDie = ConstructEnumTypeDIE(DW_Unit, &Enum);
1749           Buffer.AddChild(ElemDie);
1750         }
1751       }
1752       break;
1753     case DW_TAG_subroutine_type:
1754       {
1755         // Add return type.
1756         DIArray Elements = CTy.getTypeArray();
1757         DIDescriptor RTy = Elements.getElement(0);
1758         AddType(DW_Unit, &Buffer, DIType(RTy.getGV()));
1759
1760         // Add prototype flag.
1761         AddUInt(&Buffer, DW_AT_prototyped, DW_FORM_flag, 1);
1762
1763         // Add arguments.
1764         for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1765           DIE *Arg = new DIE(DW_TAG_formal_parameter);
1766           DIDescriptor Ty = Elements.getElement(i);
1767           AddType(DW_Unit, Arg, DIType(Ty.getGV()));
1768           Buffer.AddChild(Arg);
1769         }
1770       }
1771       break;
1772     case DW_TAG_structure_type:
1773     case DW_TAG_union_type:
1774     case DW_TAG_class_type:
1775       {
1776         // Add elements to structure type.
1777         DIArray Elements = CTy.getTypeArray();
1778
1779         // A forward struct declared type may not have elements available.
1780         if (Elements.isNull())
1781           break;
1782
1783         // Add elements to structure type.
1784         for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1785           DIDescriptor Element = Elements.getElement(i);
1786           DIE *ElemDie = NULL;
1787           if (Element.getTag() == dwarf::DW_TAG_subprogram)
1788             ElemDie = CreateSubprogramDIE(DW_Unit,
1789                                           DISubprogram(Element.getGV()));
1790           else if (Element.getTag() == dwarf::DW_TAG_variable) // ??
1791             ElemDie = CreateGlobalVariableDIE(DW_Unit,
1792                                               DIGlobalVariable(Element.getGV()));
1793           else
1794             ElemDie = CreateMemberDIE(DW_Unit,
1795                                       DIDerivedType(Element.getGV()));
1796           Buffer.AddChild(ElemDie);
1797         }
1798         unsigned RLang = CTy.getRunTimeLang();
1799         if (RLang)
1800           AddUInt(&Buffer, DW_AT_APPLE_runtime_class, DW_FORM_data1, RLang);
1801       }
1802       break;
1803     default:
1804       break;
1805     }
1806
1807     // Add name if not anonymous or intermediate type.
1808     if (!Name.empty())
1809       AddString(&Buffer, DW_AT_name, DW_FORM_string, Name);
1810
1811     if (Tag == DW_TAG_enumeration_type || Tag == DW_TAG_structure_type
1812         || Tag == DW_TAG_union_type) {
1813       // Add size if non-zero (derived types might be zero-sized.)
1814       if (Size)
1815         AddUInt(&Buffer, DW_AT_byte_size, 0, Size);
1816       else {
1817         // Add zero size if it is not a forward declaration.
1818         if (CTy.isForwardDecl())
1819           AddUInt(&Buffer, DW_AT_declaration, DW_FORM_flag, 1);
1820         else
1821           AddUInt(&Buffer, DW_AT_byte_size, 0, 0);
1822       }
1823
1824       // Add source line info if available.
1825       if (!CTy.isForwardDecl())
1826         AddSourceLine(&Buffer, &CTy);
1827     }
1828   }
1829
1830   /// ConstructSubrangeDIE - Construct subrange DIE from DISubrange.
1831   void ConstructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1832     int64_t L = SR.getLo();
1833     int64_t H = SR.getHi();
1834     DIE *DW_Subrange = new DIE(DW_TAG_subrange_type);
1835     if (L != H) {
1836       AddDIEntry(DW_Subrange, DW_AT_type, DW_FORM_ref4, IndexTy);
1837       if (L)
1838         AddSInt(DW_Subrange, DW_AT_lower_bound, 0, L);
1839       AddSInt(DW_Subrange, DW_AT_upper_bound, 0, H);
1840     }
1841     Buffer.AddChild(DW_Subrange);
1842   }
1843
1844   /// ConstructArrayTypeDIE - Construct array type DIE from DICompositeType.
1845   void ConstructArrayTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
1846                              DICompositeType *CTy) {
1847     Buffer.setTag(DW_TAG_array_type);
1848     if (CTy->getTag() == DW_TAG_vector_type)
1849       AddUInt(&Buffer, DW_AT_GNU_vector, DW_FORM_flag, 1);
1850
1851     // Emit derived type.
1852     AddType(DW_Unit, &Buffer, CTy->getTypeDerivedFrom());
1853     DIArray Elements = CTy->getTypeArray();
1854
1855     // Construct an anonymous type for index type.
1856     DIE IdxBuffer(DW_TAG_base_type);
1857     AddUInt(&IdxBuffer, DW_AT_byte_size, 0, sizeof(int32_t));
1858     AddUInt(&IdxBuffer, DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
1859     DIE *IndexTy = DW_Unit->AddDie(IdxBuffer);
1860
1861     // Add subranges to array type.
1862     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1863       DIDescriptor Element = Elements.getElement(i);
1864       if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1865         ConstructSubrangeDIE(Buffer, DISubrange(Element.getGV()), IndexTy);
1866     }
1867   }
1868
1869   /// ConstructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1870   DIE *ConstructEnumTypeDIE(CompileUnit *DW_Unit, DIEnumerator *ETy) {
1871
1872     DIE *Enumerator = new DIE(DW_TAG_enumerator);
1873     std::string Name;
1874     ETy->getName(Name);
1875     AddString(Enumerator, DW_AT_name, DW_FORM_string, Name);
1876     int64_t Value = ETy->getEnumValue();
1877     AddSInt(Enumerator, DW_AT_const_value, DW_FORM_sdata, Value);
1878     return Enumerator;
1879   }
1880
1881   /// CreateGlobalVariableDIE - Create new DIE using GV.
1882   DIE *CreateGlobalVariableDIE(CompileUnit *DW_Unit, const DIGlobalVariable &GV)
1883   {
1884     DIE *GVDie = new DIE(DW_TAG_variable);
1885     std::string Name;
1886     GV.getDisplayName(Name);
1887     AddString(GVDie, DW_AT_name, DW_FORM_string, Name);
1888     std::string LinkageName;
1889     GV.getLinkageName(LinkageName);
1890     if (!LinkageName.empty())
1891       AddString(GVDie, DW_AT_MIPS_linkage_name, DW_FORM_string, LinkageName);
1892     AddType(DW_Unit, GVDie, GV.getType());
1893     if (!GV.isLocalToUnit())
1894       AddUInt(GVDie, DW_AT_external, DW_FORM_flag, 1);
1895     AddSourceLine(GVDie, &GV);
1896     return GVDie;
1897   }
1898
1899   /// CreateMemberDIE - Create new member DIE.
1900   DIE *CreateMemberDIE(CompileUnit *DW_Unit, const DIDerivedType &DT) {
1901     DIE *MemberDie = new DIE(DT.getTag());
1902     std::string Name;
1903     DT.getName(Name);
1904     if (!Name.empty())
1905       AddString(MemberDie, DW_AT_name, DW_FORM_string, Name);
1906
1907     AddType(DW_Unit, MemberDie, DT.getTypeDerivedFrom());
1908
1909     AddSourceLine(MemberDie, &DT);
1910
1911     uint64_t Size = DT.getSizeInBits();
1912     uint64_t FieldSize = DT.getOriginalTypeSize();
1913
1914     if (Size != FieldSize) {
1915       // Handle bitfield.
1916       AddUInt(MemberDie, DW_AT_byte_size, 0, DT.getOriginalTypeSize() >> 3);
1917       AddUInt(MemberDie, DW_AT_bit_size, 0, DT.getSizeInBits());
1918
1919       uint64_t Offset = DT.getOffsetInBits();
1920       uint64_t FieldOffset = Offset;
1921       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1922       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1923       FieldOffset = (HiMark - FieldSize);
1924       Offset -= FieldOffset;
1925       // Maybe we need to work from the other end.
1926       if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1927       AddUInt(MemberDie, DW_AT_bit_offset, 0, Offset);
1928     }
1929     DIEBlock *Block = new DIEBlock();
1930     AddUInt(Block, 0, DW_FORM_data1, DW_OP_plus_uconst);
1931     AddUInt(Block, 0, DW_FORM_udata, DT.getOffsetInBits() >> 3);
1932     AddBlock(MemberDie, DW_AT_data_member_location, 0, Block);
1933
1934     if (DT.isProtected())
1935       AddUInt(MemberDie, DW_AT_accessibility, 0, DW_ACCESS_protected);
1936     else if (DT.isPrivate())
1937       AddUInt(MemberDie, DW_AT_accessibility, 0, DW_ACCESS_private);
1938
1939     return MemberDie;
1940   }
1941
1942   /// CreateSubprogramDIE - Create new DIE using SP.
1943   DIE *CreateSubprogramDIE(CompileUnit *DW_Unit,
1944                            const DISubprogram &SP,
1945                            bool IsConstructor = false) {
1946     DIE *SPDie = new DIE(DW_TAG_subprogram);
1947
1948     std::string Name;
1949     SP.getName(Name);
1950     AddString(SPDie, DW_AT_name, DW_FORM_string, Name);
1951
1952     std::string LinkageName;
1953     SP.getLinkageName(LinkageName);
1954
1955     if (!LinkageName.empty())
1956       AddString(SPDie, DW_AT_MIPS_linkage_name, DW_FORM_string, LinkageName);
1957
1958     AddSourceLine(SPDie, &SP);
1959
1960     DICompositeType SPTy = SP.getType();
1961     DIArray Args = SPTy.getTypeArray();
1962
1963     // Add prototyped tag, if C or ObjC.
1964     unsigned Lang = SP.getCompileUnit().getLanguage();
1965     if (Lang == DW_LANG_C99 || Lang == DW_LANG_C89 || Lang == DW_LANG_ObjC)
1966       AddUInt(SPDie, DW_AT_prototyped, DW_FORM_flag, 1);
1967
1968     // Add Return Type.
1969     unsigned SPTag = SPTy.getTag();
1970     if (!IsConstructor) {
1971       if (Args.isNull() || SPTag != DW_TAG_subroutine_type)
1972         AddType(DW_Unit, SPDie, SPTy);
1973       else
1974         AddType(DW_Unit, SPDie, DIType(Args.getElement(0).getGV()));
1975     }
1976
1977     if (!SP.isDefinition()) {
1978       AddUInt(SPDie, DW_AT_declaration, DW_FORM_flag, 1);
1979
1980       // Add arguments. Do not add arguments for subprogram definition. They
1981       // will be handled through RecordVariable.
1982       if (SPTag == DW_TAG_subroutine_type)
1983         for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1984           DIE *Arg = new DIE(DW_TAG_formal_parameter);
1985           AddType(DW_Unit, Arg, DIType(Args.getElement(i).getGV()));
1986           AddUInt(Arg, DW_AT_artificial, DW_FORM_flag, 1); // ??
1987           SPDie->AddChild(Arg);
1988         }
1989     }
1990
1991     if (!SP.isLocalToUnit())
1992       AddUInt(SPDie, DW_AT_external, DW_FORM_flag, 1);
1993
1994     // DW_TAG_inlined_subroutine may refer to this DIE.
1995     DIE *&Slot = DW_Unit->getDieMapSlotFor(SP.getGV());
1996     Slot = SPDie;
1997     return SPDie;
1998   }
1999
2000   /// FindCompileUnit - Get the compile unit for the given descriptor.
2001   ///
2002   CompileUnit &FindCompileUnit(DICompileUnit Unit) const {
2003     DenseMap<Value *, CompileUnit *>::const_iterator I =
2004       CompileUnitMap.find(Unit.getGV());
2005     assert(I != CompileUnitMap.end() && "Missing compile unit.");
2006     return *I->second;
2007   }
2008
2009   /// NewDbgScopeVariable - Create a new scope variable.
2010   ///
2011   DIE *NewDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit) {
2012     // Get the descriptor.
2013     const DIVariable &VD = DV->getVariable();
2014
2015     // Translate tag to proper Dwarf tag.  The result variable is dropped for
2016     // now.
2017     unsigned Tag;
2018     switch (VD.getTag()) {
2019     case DW_TAG_return_variable:  return NULL;
2020     case DW_TAG_arg_variable:     Tag = DW_TAG_formal_parameter; break;
2021     case DW_TAG_auto_variable:    // fall thru
2022     default:                      Tag = DW_TAG_variable; break;
2023     }
2024
2025     // Define variable debug information entry.
2026     DIE *VariableDie = new DIE(Tag);
2027     std::string Name;
2028     VD.getName(Name);
2029     AddString(VariableDie, DW_AT_name, DW_FORM_string, Name);
2030
2031     // Add source line info if available.
2032     AddSourceLine(VariableDie, &VD);
2033
2034     // Add variable type.
2035     AddType(Unit, VariableDie, VD.getType());
2036
2037     // Add variable address.
2038     MachineLocation Location;
2039     Location.set(RI->getFrameRegister(*MF),
2040                  RI->getFrameIndexOffset(*MF, DV->getFrameIndex()));
2041     AddAddress(VariableDie, DW_AT_location, Location);
2042
2043     return VariableDie;
2044   }
2045
2046   /// getOrCreateScope - Returns the scope associated with the given descriptor.
2047   ///
2048   DbgScope *getOrCreateScope(GlobalVariable *V) {
2049     DbgScope *&Slot = DbgScopeMap[V];
2050     if (Slot) return Slot;
2051
2052     // Don't create a new scope if we already created one for an inlined
2053     // function.
2054     DenseMap<const GlobalVariable *, DbgScope *>::iterator
2055       II = AbstractInstanceRootMap.find(V);
2056     if (II != AbstractInstanceRootMap.end())
2057       return LexicalScopeStack.back();
2058
2059     DbgScope *Parent = NULL;
2060     DIBlock Block(V);
2061
2062     if (!Block.isNull()) {
2063       DIDescriptor ParentDesc = Block.getContext();
2064       Parent =
2065         ParentDesc.isNull() ?  NULL : getOrCreateScope(ParentDesc.getGV());
2066     }
2067
2068     Slot = new DbgScope(Parent, DIDescriptor(V));
2069
2070     if (Parent)
2071       Parent->AddScope(Slot);
2072     else
2073       // First function is top level function.
2074       FunctionDbgScope = Slot;
2075
2076     return Slot;
2077   }
2078
2079   /// ConstructDbgScope - Construct the components of a scope.
2080   ///
2081   void ConstructDbgScope(DbgScope *ParentScope,
2082                          unsigned ParentStartID, unsigned ParentEndID,
2083                          DIE *ParentDie, CompileUnit *Unit) {
2084     if (LexicalScopeToConcreteInstMap.find(ParentScope) ==
2085         LexicalScopeToConcreteInstMap.end()) {
2086       // Add variables to scope.
2087       SmallVector<DbgVariable *, 8> &Variables = ParentScope->getVariables();
2088       for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2089         DIE *VariableDie = NewDbgScopeVariable(Variables[i], Unit);
2090         if (VariableDie) ParentDie->AddChild(VariableDie);
2091       }
2092     }
2093
2094     // Add nested scopes.
2095     SmallVector<DbgScope *, 4> &Scopes = ParentScope->getScopes();
2096     for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
2097       // Define the Scope debug information entry.
2098       DbgScope *Scope = Scopes[j];
2099
2100       unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
2101       unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
2102
2103       // Ignore empty scopes.
2104       // Do not ignore inlined scope even if it does not have any
2105       // variables or scopes.
2106       if (StartID == EndID && StartID != 0) continue;
2107       if (!Scope->isInlinedSubroutine()
2108           && Scope->getScopes().empty() && Scope->getVariables().empty())
2109         continue;
2110
2111       if (StartID == ParentStartID && EndID == ParentEndID) {
2112         // Just add stuff to the parent scope.
2113         ConstructDbgScope(Scope, ParentStartID, ParentEndID, ParentDie, Unit);
2114       } else {
2115         DIE *ScopeDie = NULL;
2116
2117         DenseMap<DbgScope *, DIE *>::iterator I =
2118           LexicalScopeToConcreteInstMap.find(Scope);
2119
2120         if (I != LexicalScopeToConcreteInstMap.end())
2121           ScopeDie = I->second;
2122         else
2123           ScopeDie = new DIE(DW_TAG_lexical_block);
2124
2125         // Add the scope bounds.
2126         if (StartID)
2127           AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr,
2128                    DWLabel("label", StartID));
2129         else
2130           AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr,
2131                    DWLabel("func_begin", SubprogramCount));
2132
2133         if (EndID)
2134           AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr,
2135                    DWLabel("label", EndID));
2136         else
2137           AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr,
2138                    DWLabel("func_end", SubprogramCount));
2139
2140         // Add the scope contents.
2141         ConstructDbgScope(Scope, StartID, EndID, ScopeDie, Unit);
2142         ParentDie->AddChild(ScopeDie);
2143       }
2144     }
2145   }
2146
2147   /// ConstructFunctionDbgScope - Construct the scope for the subprogram.
2148   ///
2149   void ConstructFunctionDbgScope(DbgScope *RootScope) {
2150     // Exit if there is no root scope.
2151     if (!RootScope) return;
2152     DIDescriptor Desc = RootScope->getDesc();
2153     if (Desc.isNull())
2154       return;
2155
2156     // Get the subprogram debug information entry.
2157     DISubprogram SPD(Desc.getGV());
2158
2159     // Get the compile unit context.
2160     CompileUnit *Unit = MainCU;
2161     if (!Unit)
2162       Unit = &FindCompileUnit(SPD.getCompileUnit());
2163
2164     // Get the subprogram die.
2165     DIE *SPDie = Unit->getDieMapSlotFor(SPD.getGV());
2166     assert(SPDie && "Missing subprogram descriptor");
2167
2168     // Add the function bounds.
2169     AddLabel(SPDie, DW_AT_low_pc, DW_FORM_addr,
2170                     DWLabel("func_begin", SubprogramCount));
2171     AddLabel(SPDie, DW_AT_high_pc, DW_FORM_addr,
2172                     DWLabel("func_end", SubprogramCount));
2173     MachineLocation Location(RI->getFrameRegister(*MF));
2174     AddAddress(SPDie, DW_AT_frame_base, Location);
2175
2176     ConstructDbgScope(RootScope, 0, 0, SPDie, Unit);
2177   }
2178
2179   void ConstructAbstractDbgScope(DbgScope *AbsScope) {
2180     // Exit if there is no root scope.
2181     if (!AbsScope) return;
2182
2183     DIDescriptor Desc = AbsScope->getDesc();
2184     if (Desc.isNull())
2185       return;
2186
2187     // Get the subprogram debug information entry.
2188     DISubprogram SPD(Desc.getGV());
2189
2190     // Get the compile unit context.
2191     CompileUnit *Unit = MainCU;
2192     if (!Unit)
2193       Unit = &FindCompileUnit(SPD.getCompileUnit());
2194
2195     // Get the subprogram die.
2196     DIE *SPDie = Unit->getDieMapSlotFor(SPD.getGV());
2197     assert(SPDie && "Missing subprogram descriptor");
2198
2199     ConstructDbgScope(AbsScope, 0, 0, SPDie, Unit);
2200   }
2201
2202   /// ConstructDefaultDbgScope - Construct a default scope for the subprogram.
2203   ///
2204   void ConstructDefaultDbgScope(MachineFunction *MF) {
2205     const char *FnName = MF->getFunction()->getNameStart();
2206     if (MainCU) {
2207       StringMap<DIE*> &Globals = MainCU->getGlobals();
2208       StringMap<DIE*>::iterator GI = Globals.find(FnName);
2209       if (GI != Globals.end()) {
2210         DIE *SPDie = GI->second;
2211
2212         // Add the function bounds.
2213         AddLabel(SPDie, DW_AT_low_pc, DW_FORM_addr,
2214                  DWLabel("func_begin", SubprogramCount));
2215         AddLabel(SPDie, DW_AT_high_pc, DW_FORM_addr,
2216                  DWLabel("func_end", SubprogramCount));
2217
2218         MachineLocation Location(RI->getFrameRegister(*MF));
2219         AddAddress(SPDie, DW_AT_frame_base, Location);
2220         return;
2221       }
2222     } else {
2223       for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i) {
2224         CompileUnit *Unit = CompileUnits[i];
2225         StringMap<DIE*> &Globals = Unit->getGlobals();
2226         StringMap<DIE*>::iterator GI = Globals.find(FnName);
2227         if (GI != Globals.end()) {
2228           DIE *SPDie = GI->second;
2229
2230           // Add the function bounds.
2231           AddLabel(SPDie, DW_AT_low_pc, DW_FORM_addr,
2232                    DWLabel("func_begin", SubprogramCount));
2233           AddLabel(SPDie, DW_AT_high_pc, DW_FORM_addr,
2234                    DWLabel("func_end", SubprogramCount));
2235
2236           MachineLocation Location(RI->getFrameRegister(*MF));
2237           AddAddress(SPDie, DW_AT_frame_base, Location);
2238           return;
2239         }
2240       }
2241     }
2242
2243 #if 0
2244     // FIXME: This is causing an abort because C++ mangled names are compared
2245     // with their unmangled counterparts. See PR2885. Don't do this assert.
2246     assert(0 && "Couldn't find DIE for machine function!");
2247 #endif
2248     return;
2249   }
2250
2251   /// EmitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2252   /// tools to recognize the object file contains Dwarf information.
2253   void EmitInitial() {
2254     // Check to see if we already emitted intial headers.
2255     if (didInitial) return;
2256     didInitial = true;
2257
2258     // Dwarf sections base addresses.
2259     if (TAI->doesDwarfRequireFrameSection()) {
2260       Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
2261       EmitLabel("section_debug_frame", 0);
2262     }
2263     Asm->SwitchToDataSection(TAI->getDwarfInfoSection());
2264     EmitLabel("section_info", 0);
2265     Asm->SwitchToDataSection(TAI->getDwarfAbbrevSection());
2266     EmitLabel("section_abbrev", 0);
2267     Asm->SwitchToDataSection(TAI->getDwarfARangesSection());
2268     EmitLabel("section_aranges", 0);
2269     if (TAI->doesSupportMacInfoSection()) {
2270       Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection());
2271       EmitLabel("section_macinfo", 0);
2272     }
2273     Asm->SwitchToDataSection(TAI->getDwarfLineSection());
2274     EmitLabel("section_line", 0);
2275     Asm->SwitchToDataSection(TAI->getDwarfLocSection());
2276     EmitLabel("section_loc", 0);
2277     Asm->SwitchToDataSection(TAI->getDwarfPubNamesSection());
2278     EmitLabel("section_pubnames", 0);
2279     Asm->SwitchToDataSection(TAI->getDwarfStrSection());
2280     EmitLabel("section_str", 0);
2281     Asm->SwitchToDataSection(TAI->getDwarfRangesSection());
2282     EmitLabel("section_ranges", 0);
2283
2284     Asm->SwitchToSection(TAI->getTextSection());
2285     EmitLabel("text_begin", 0);
2286     Asm->SwitchToSection(TAI->getDataSection());
2287     EmitLabel("data_begin", 0);
2288   }
2289
2290   /// EmitDIE - Recusively Emits a debug information entry.
2291   ///
2292   void EmitDIE(DIE *Die) {
2293     // Get the abbreviation for this DIE.
2294     unsigned AbbrevNumber = Die->getAbbrevNumber();
2295     const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2296
2297     Asm->EOL();
2298
2299     // Emit the code (index) for the abbreviation.
2300     Asm->EmitULEB128Bytes(AbbrevNumber);
2301
2302     if (Asm->isVerbose())
2303       Asm->EOL(std::string("Abbrev [" +
2304                            utostr(AbbrevNumber) +
2305                            "] 0x" + utohexstr(Die->getOffset()) +
2306                            ":0x" + utohexstr(Die->getSize()) + " " +
2307                            TagString(Abbrev->getTag())));
2308     else
2309       Asm->EOL();
2310
2311     SmallVector<DIEValue*, 32> &Values = Die->getValues();
2312     const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2313
2314     // Emit the DIE attribute values.
2315     for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2316       unsigned Attr = AbbrevData[i].getAttribute();
2317       unsigned Form = AbbrevData[i].getForm();
2318       assert(Form && "Too many attributes for DIE (check abbreviation)");
2319
2320       switch (Attr) {
2321       case DW_AT_sibling: {
2322         Asm->EmitInt32(Die->SiblingOffset());
2323         break;
2324       }
2325       default: {
2326         // Emit an attribute using the defined form.
2327         Values[i]->EmitValue(*this, Form);
2328         break;
2329       }
2330       }
2331
2332       Asm->EOL(AttributeString(Attr));
2333     }
2334
2335     // Emit the DIE children if any.
2336     if (Abbrev->getChildrenFlag() == DW_CHILDREN_yes) {
2337       const std::vector<DIE *> &Children = Die->getChildren();
2338
2339       for (unsigned j = 0, M = Children.size(); j < M; ++j) {
2340         EmitDIE(Children[j]);
2341       }
2342
2343       Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2344     }
2345   }
2346
2347   /// SizeAndOffsetDie - Compute the size and offset of a DIE.
2348   ///
2349   unsigned SizeAndOffsetDie(DIE *Die, unsigned Offset, bool Last) {
2350     // Get the children.
2351     const std::vector<DIE *> &Children = Die->getChildren();
2352
2353     // If not last sibling and has children then add sibling offset attribute.
2354     if (!Last && !Children.empty()) Die->AddSiblingOffset();
2355
2356     // Record the abbreviation.
2357     AssignAbbrevNumber(Die->getAbbrev());
2358
2359     // Get the abbreviation for this DIE.
2360     unsigned AbbrevNumber = Die->getAbbrevNumber();
2361     const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2362
2363     // Set DIE offset
2364     Die->setOffset(Offset);
2365
2366     // Start the size with the size of abbreviation code.
2367     Offset += TargetAsmInfo::getULEB128Size(AbbrevNumber);
2368
2369     const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2370     const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2371
2372     // Size the DIE attribute values.
2373     for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2374       // Size attribute value.
2375       Offset += Values[i]->SizeOf(*this, AbbrevData[i].getForm());
2376     }
2377
2378     // Size the DIE children if any.
2379     if (!Children.empty()) {
2380       assert(Abbrev->getChildrenFlag() == DW_CHILDREN_yes &&
2381              "Children flag not set");
2382
2383       for (unsigned j = 0, M = Children.size(); j < M; ++j) {
2384         Offset = SizeAndOffsetDie(Children[j], Offset, (j + 1) == M);
2385       }
2386
2387       // End of children marker.
2388       Offset += sizeof(int8_t);
2389     }
2390
2391     Die->setSize(Offset - Die->getOffset());
2392     return Offset;
2393   }
2394
2395   /// SizeAndOffsets - Compute the size and offset of all the DIEs.
2396   ///
2397   void SizeAndOffsets() {
2398     // Process base compile unit.
2399     if (MainCU) {
2400       // Compute size of compile unit header
2401       unsigned Offset = sizeof(int32_t) + // Length of Compilation Unit Info
2402         sizeof(int16_t) + // DWARF version number
2403         sizeof(int32_t) + // Offset Into Abbrev. Section
2404         sizeof(int8_t);   // Pointer Size (in bytes)
2405       SizeAndOffsetDie(MainCU->getDie(), Offset, true);
2406       return;
2407     }
2408     for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i) {
2409       CompileUnit *Unit = CompileUnits[i];
2410       // Compute size of compile unit header
2411       unsigned Offset = sizeof(int32_t) + // Length of Compilation Unit Info
2412         sizeof(int16_t) + // DWARF version number
2413         sizeof(int32_t) + // Offset Into Abbrev. Section
2414         sizeof(int8_t);   // Pointer Size (in bytes)
2415       SizeAndOffsetDie(Unit->getDie(), Offset, true);
2416     }
2417   }
2418
2419   /// EmitDebugInfo / EmitDebugInfoPerCU - Emit the debug info section.
2420   ///
2421   void EmitDebugInfoPerCU(CompileUnit *Unit) {
2422     DIE *Die = Unit->getDie();
2423     // Emit the compile units header.
2424     EmitLabel("info_begin", Unit->getID());
2425     // Emit size of content not including length itself
2426     unsigned ContentSize = Die->getSize() +
2427       sizeof(int16_t) + // DWARF version number
2428       sizeof(int32_t) + // Offset Into Abbrev. Section
2429       sizeof(int8_t) +  // Pointer Size (in bytes)
2430       sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2431
2432     Asm->EmitInt32(ContentSize);  Asm->EOL("Length of Compilation Unit Info");
2433     Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number");
2434     EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2435     Asm->EOL("Offset Into Abbrev. Section");
2436     Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2437
2438     EmitDIE(Die);
2439     // FIXME - extra padding for gdb bug.
2440     Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2441     Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2442     Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2443     Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2444     EmitLabel("info_end", Unit->getID());
2445
2446     Asm->EOL();
2447   }
2448
2449   void EmitDebugInfo() {
2450     // Start debug info section.
2451     Asm->SwitchToDataSection(TAI->getDwarfInfoSection());
2452
2453     if (MainCU) {
2454       EmitDebugInfoPerCU(MainCU);
2455       return;
2456     }
2457
2458     for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i)
2459       EmitDebugInfoPerCU(CompileUnits[i]);
2460   }
2461
2462   /// EmitAbbreviations - Emit the abbreviation section.
2463   ///
2464   void EmitAbbreviations() const {
2465     // Check to see if it is worth the effort.
2466     if (!Abbreviations.empty()) {
2467       // Start the debug abbrev section.
2468       Asm->SwitchToDataSection(TAI->getDwarfAbbrevSection());
2469
2470       EmitLabel("abbrev_begin", 0);
2471
2472       // For each abbrevation.
2473       for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2474         // Get abbreviation data
2475         const DIEAbbrev *Abbrev = Abbreviations[i];
2476
2477         // Emit the abbrevations code (base 1 index.)
2478         Asm->EmitULEB128Bytes(Abbrev->getNumber());
2479         Asm->EOL("Abbreviation Code");
2480
2481         // Emit the abbreviations data.
2482         Abbrev->Emit(*this);
2483
2484         Asm->EOL();
2485       }
2486
2487       // Mark end of abbreviations.
2488       Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2489
2490       EmitLabel("abbrev_end", 0);
2491
2492       Asm->EOL();
2493     }
2494   }
2495
2496   /// EmitEndOfLineMatrix - Emit the last address of the section and the end of
2497   /// the line matrix.
2498   ///
2499   void EmitEndOfLineMatrix(unsigned SectionEnd) {
2500     // Define last address of section.
2501     Asm->EmitInt8(0); Asm->EOL("Extended Op");
2502     Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2503     Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2504     EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2505
2506     // Mark end of matrix.
2507     Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2508     Asm->EmitULEB128Bytes(1); Asm->EOL();
2509     Asm->EmitInt8(1); Asm->EOL();
2510   }
2511
2512   /// EmitDebugLines - Emit source line information.
2513   ///
2514   void EmitDebugLines() {
2515     // If the target is using .loc/.file, the assembler will be emitting the
2516     // .debug_line table automatically.
2517     if (TAI->hasDotLocAndDotFile())
2518       return;
2519
2520     // Minimum line delta, thus ranging from -10..(255-10).
2521     const int MinLineDelta = -(DW_LNS_fixed_advance_pc + 1);
2522     // Maximum line delta, thus ranging from -10..(255-10).
2523     const int MaxLineDelta = 255 + MinLineDelta;
2524
2525     // Start the dwarf line section.
2526     Asm->SwitchToDataSection(TAI->getDwarfLineSection());
2527
2528     // Construct the section header.
2529
2530     EmitDifference("line_end", 0, "line_begin", 0, true);
2531     Asm->EOL("Length of Source Line Info");
2532     EmitLabel("line_begin", 0);
2533
2534     Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number");
2535
2536     EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2537     Asm->EOL("Prolog Length");
2538     EmitLabel("line_prolog_begin", 0);
2539
2540     Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2541
2542     Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2543
2544     Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2545
2546     Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2547
2548     Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2549
2550     // Line number standard opcode encodings argument count
2551     Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2552     Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2553     Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2554     Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2555     Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2556     Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2557     Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2558     Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2559     Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2560
2561     // Emit directories.
2562     for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2563       Asm->EmitString(getSourceDirectoryName(DI));
2564       Asm->EOL("Directory");
2565     }
2566     Asm->EmitInt8(0); Asm->EOL("End of directories");
2567
2568     // Emit files.
2569     for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2570       // Remember source id starts at 1.
2571       std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2572       Asm->EmitString(getSourceFileName(Id.second));
2573       Asm->EOL("Source");
2574       Asm->EmitULEB128Bytes(Id.first);
2575       Asm->EOL("Directory #");
2576       Asm->EmitULEB128Bytes(0);
2577       Asm->EOL("Mod date");
2578       Asm->EmitULEB128Bytes(0);
2579       Asm->EOL("File size");
2580     }
2581     Asm->EmitInt8(0); Asm->EOL("End of files");
2582
2583     EmitLabel("line_prolog_end", 0);
2584
2585     // A sequence for each text section.
2586     unsigned SecSrcLinesSize = SectionSourceLines.size();
2587
2588     for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2589       // Isolate current sections line info.
2590       const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2591
2592       if (Asm->isVerbose()) {
2593         const Section* S = SectionMap[j + 1];
2594         O << '\t' << TAI->getCommentString() << " Section"
2595           << S->getName() << '\n';
2596       } else
2597         Asm->EOL();
2598
2599       // Dwarf assumes we start with first line of first source file.
2600       unsigned Source = 1;
2601       unsigned Line = 1;
2602
2603       // Construct rows of the address, source, line, column matrix.
2604       for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2605         const SrcLineInfo &LineInfo = LineInfos[i];
2606         unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2607         if (!LabelID) continue;
2608
2609         if (!Asm->isVerbose())
2610           Asm->EOL();
2611         else {
2612           std::pair<unsigned, unsigned> SourceID =
2613             getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2614           O << '\t' << TAI->getCommentString() << ' '
2615             << getSourceDirectoryName(SourceID.first) << ' '
2616             << getSourceFileName(SourceID.second)
2617             <<" :" << utostr_32(LineInfo.getLine()) << '\n';
2618         }
2619
2620         // Define the line address.
2621         Asm->EmitInt8(0); Asm->EOL("Extended Op");
2622         Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2623         Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2624         EmitReference("label",  LabelID); Asm->EOL("Location label");
2625
2626         // If change of source, then switch to the new source.
2627         if (Source != LineInfo.getSourceID()) {
2628           Source = LineInfo.getSourceID();
2629           Asm->EmitInt8(DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2630           Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2631         }
2632
2633         // If change of line.
2634         if (Line != LineInfo.getLine()) {
2635           // Determine offset.
2636           int Offset = LineInfo.getLine() - Line;
2637           int Delta = Offset - MinLineDelta;
2638
2639           // Update line.
2640           Line = LineInfo.getLine();
2641
2642           // If delta is small enough and in range...
2643           if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2644             // ... then use fast opcode.
2645             Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2646           } else {
2647             // ... otherwise use long hand.
2648             Asm->EmitInt8(DW_LNS_advance_line); Asm->EOL("DW_LNS_advance_line");
2649             Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2650             Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2651           }
2652         } else {
2653           // Copy the previous row (different address or source)
2654           Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2655         }
2656       }
2657
2658       EmitEndOfLineMatrix(j + 1);
2659     }
2660
2661     if (SecSrcLinesSize == 0)
2662       // Because we're emitting a debug_line section, we still need a line
2663       // table. The linker and friends expect it to exist. If there's nothing to
2664       // put into it, emit an empty table.
2665       EmitEndOfLineMatrix(1);
2666
2667     EmitLabel("line_end", 0);
2668
2669     Asm->EOL();
2670   }
2671
2672   /// EmitCommonDebugFrame - Emit common frame info into a debug frame section.
2673   ///
2674   void EmitCommonDebugFrame() {
2675     if (!TAI->doesDwarfRequireFrameSection())
2676       return;
2677
2678     int stackGrowth =
2679         Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2680           TargetFrameInfo::StackGrowsUp ?
2681         TD->getPointerSize() : -TD->getPointerSize();
2682
2683     // Start the dwarf frame section.
2684     Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
2685
2686     EmitLabel("debug_frame_common", 0);
2687     EmitDifference("debug_frame_common_end", 0,
2688                    "debug_frame_common_begin", 0, true);
2689     Asm->EOL("Length of Common Information Entry");
2690
2691     EmitLabel("debug_frame_common_begin", 0);
2692     Asm->EmitInt32((int)DW_CIE_ID);
2693     Asm->EOL("CIE Identifier Tag");
2694     Asm->EmitInt8(DW_CIE_VERSION);
2695     Asm->EOL("CIE Version");
2696     Asm->EmitString("");
2697     Asm->EOL("CIE Augmentation");
2698     Asm->EmitULEB128Bytes(1);
2699     Asm->EOL("CIE Code Alignment Factor");
2700     Asm->EmitSLEB128Bytes(stackGrowth);
2701     Asm->EOL("CIE Data Alignment Factor");
2702     Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2703     Asm->EOL("CIE RA Column");
2704
2705     std::vector<MachineMove> Moves;
2706     RI->getInitialFrameState(Moves);
2707
2708     EmitFrameMoves(NULL, 0, Moves, false);
2709
2710     Asm->EmitAlignment(2, 0, 0, false);
2711     EmitLabel("debug_frame_common_end", 0);
2712
2713     Asm->EOL();
2714   }
2715
2716   /// EmitFunctionDebugFrame - Emit per function frame info into a debug frame
2717   /// section.
2718   void EmitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2719     if (!TAI->doesDwarfRequireFrameSection())
2720       return;
2721
2722     // Start the dwarf frame section.
2723     Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
2724
2725     EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2726                    "debug_frame_begin", DebugFrameInfo.Number, true);
2727     Asm->EOL("Length of Frame Information Entry");
2728
2729     EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2730
2731     EmitSectionOffset("debug_frame_common", "section_debug_frame",
2732                       0, 0, true, false);
2733     Asm->EOL("FDE CIE offset");
2734
2735     EmitReference("func_begin", DebugFrameInfo.Number);
2736     Asm->EOL("FDE initial location");
2737     EmitDifference("func_end", DebugFrameInfo.Number,
2738                    "func_begin", DebugFrameInfo.Number);
2739     Asm->EOL("FDE address range");
2740
2741     EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2742                    false);
2743
2744     Asm->EmitAlignment(2, 0, 0, false);
2745     EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2746
2747     Asm->EOL();
2748   }
2749
2750   void EmitDebugPubNamesPerCU(CompileUnit *Unit) {
2751     EmitDifference("pubnames_end", Unit->getID(),
2752                    "pubnames_begin", Unit->getID(), true);
2753     Asm->EOL("Length of Public Names Info");
2754
2755     EmitLabel("pubnames_begin", Unit->getID());
2756
2757     Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF Version");
2758
2759     EmitSectionOffset("info_begin", "section_info",
2760                       Unit->getID(), 0, true, false);
2761     Asm->EOL("Offset of Compilation Unit Info");
2762
2763     EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),
2764                    true);
2765     Asm->EOL("Compilation Unit Length");
2766
2767     StringMap<DIE*> &Globals = Unit->getGlobals();
2768     for (StringMap<DIE*>::const_iterator
2769            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2770       const char *Name = GI->getKeyData();
2771       DIE * Entity = GI->second;
2772
2773       Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2774       Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2775     }
2776
2777     Asm->EmitInt32(0); Asm->EOL("End Mark");
2778     EmitLabel("pubnames_end", Unit->getID());
2779
2780     Asm->EOL();
2781   }
2782
2783   /// EmitDebugPubNames - Emit visible names into a debug pubnames section.
2784   ///
2785   void EmitDebugPubNames() {
2786     // Start the dwarf pubnames section.
2787     Asm->SwitchToDataSection(TAI->getDwarfPubNamesSection());
2788
2789     if (MainCU) {
2790       EmitDebugPubNamesPerCU(MainCU);
2791       return;
2792     }
2793
2794     for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i)
2795       EmitDebugPubNamesPerCU(CompileUnits[i]);
2796   }
2797
2798   /// EmitDebugStr - Emit visible names into a debug str section.
2799   ///
2800   void EmitDebugStr() {
2801     // Check to see if it is worth the effort.
2802     if (!StringPool.empty()) {
2803       // Start the dwarf str section.
2804       Asm->SwitchToDataSection(TAI->getDwarfStrSection());
2805
2806       // For each of strings in the string pool.
2807       for (unsigned StringID = 1, N = StringPool.size();
2808            StringID <= N; ++StringID) {
2809         // Emit a label for reference from debug information entries.
2810         EmitLabel("string", StringID);
2811         // Emit the string itself.
2812         const std::string &String = StringPool[StringID];
2813         Asm->EmitString(String); Asm->EOL();
2814       }
2815
2816       Asm->EOL();
2817     }
2818   }
2819
2820   /// EmitDebugLoc - Emit visible names into a debug loc section.
2821   ///
2822   void EmitDebugLoc() {
2823     // Start the dwarf loc section.
2824     Asm->SwitchToDataSection(TAI->getDwarfLocSection());
2825
2826     Asm->EOL();
2827   }
2828
2829   /// EmitDebugARanges - Emit visible names into a debug aranges section.
2830   ///
2831   void EmitDebugARanges() {
2832     // Start the dwarf aranges section.
2833     Asm->SwitchToDataSection(TAI->getDwarfARangesSection());
2834
2835     // FIXME - Mock up
2836 #if 0
2837     CompileUnit *Unit = GetBaseCompileUnit();
2838
2839     // Don't include size of length
2840     Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2841
2842     Asm->EmitInt16(DWARF_VERSION); Asm->EOL("Dwarf Version");
2843
2844     EmitReference("info_begin", Unit->getID());
2845     Asm->EOL("Offset of Compilation Unit Info");
2846
2847     Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2848
2849     Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2850
2851     Asm->EmitInt16(0);  Asm->EOL("Pad (1)");
2852     Asm->EmitInt16(0);  Asm->EOL("Pad (2)");
2853
2854     // Range 1
2855     EmitReference("text_begin", 0); Asm->EOL("Address");
2856     EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2857
2858     Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2859     Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2860 #endif
2861
2862     Asm->EOL();
2863   }
2864
2865   /// EmitDebugRanges - Emit visible names into a debug ranges section.
2866   ///
2867   void EmitDebugRanges() {
2868     // Start the dwarf ranges section.
2869     Asm->SwitchToDataSection(TAI->getDwarfRangesSection());
2870
2871     Asm->EOL();
2872   }
2873
2874   /// EmitDebugMacInfo - Emit visible names into a debug macinfo section.
2875   ///
2876   void EmitDebugMacInfo() {
2877     if (TAI->doesSupportMacInfoSection()) {
2878       // Start the dwarf macinfo section.
2879       Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection());
2880
2881       Asm->EOL();
2882     }
2883   }
2884
2885   /// EmitDebugInlineInfo - Emit inline info using following format.
2886   /// Section Header:
2887   /// 1. length of section
2888   /// 2. Dwarf version number
2889   /// 3. address size.
2890   ///
2891   /// Entries (one "entry" for each function that was inlined):
2892   ///
2893   /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2894   ///   otherwise offset into __debug_str for regular function name.
2895   /// 2. offset into __debug_str section for regular function name.
2896   /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2897   /// instances for the function.
2898   ///
2899   /// The rest of the entry consists of a {die_offset, low_pc}  pair for each
2900   /// inlined instance; the die_offset points to the inlined_subroutine die in
2901   /// the __debug_info section, and the low_pc is the starting address  for the
2902   ///  inlining instance.
2903   void EmitDebugInlineInfo() {
2904     if (!TAI->doesDwarfUsesInlineInfoSection())
2905       return;
2906
2907     if (!MainCU)
2908       return;
2909
2910     Asm->SwitchToDataSection(TAI->getDwarfDebugInlineSection());
2911     Asm->EOL();
2912     EmitDifference("debug_inlined_end", 1,
2913                    "debug_inlined_begin", 1, true);
2914     Asm->EOL("Length of Debug Inlined Information Entry");
2915
2916     EmitLabel("debug_inlined_begin", 1);
2917
2918     Asm->EmitInt16(DWARF_VERSION); Asm->EOL("Dwarf Version");
2919     Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2920
2921     for (DenseMap<GlobalVariable *, SmallVector<unsigned, 4> >::iterator
2922            I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2923       GlobalVariable *GV = I->first;
2924       SmallVector<unsigned, 4> &Labels = I->second;
2925       DISubprogram SP(GV);
2926       std::string Name;
2927       std::string LName;
2928       SP.getLinkageName(LName);
2929       SP.getName(Name);
2930
2931       Asm->EmitString(LName.empty() ? Name : LName);
2932       Asm->EOL("MIPS linkage name");
2933
2934       Asm->EmitString(Name); Asm->EOL("Function name");
2935
2936       Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2937
2938       for (SmallVector<unsigned, 4>::iterator LI = Labels.begin(),
2939              LE = Labels.end(); LI != LE; ++LI) {
2940         DIE *SP = MainCU->getDieMapSlotFor(GV);
2941         Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2942
2943         if (TD->getPointerSize() == sizeof(int32_t))
2944           O << TAI->getData32bitsDirective();
2945         else
2946           O << TAI->getData64bitsDirective();
2947         PrintLabelName("label", *LI); Asm->EOL("low_pc");
2948       }
2949     }
2950
2951     EmitLabel("debug_inlined_end", 1);
2952     Asm->EOL();
2953   }
2954
2955   /// GetOrCreateSourceID - Look up the source id with the given directory and
2956   /// source file names. If none currently exists, create a new id and insert it
2957   /// in the SourceIds map. This can update DirectoryNames and SourceFileNames maps
2958   /// as well.
2959   unsigned GetOrCreateSourceID(const std::string &DirName,
2960                                const std::string &FileName) {
2961     unsigned DId;
2962     StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
2963     if (DI != DirectoryIdMap.end()) {
2964       DId = DI->getValue();
2965     } else {
2966       DId = DirectoryNames.size() + 1;
2967       DirectoryIdMap[DirName] = DId;
2968       DirectoryNames.push_back(DirName);
2969     }
2970
2971     unsigned FId;
2972     StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
2973     if (FI != SourceFileIdMap.end()) {
2974       FId = FI->getValue();
2975     } else {
2976       FId = SourceFileNames.size() + 1;
2977       SourceFileIdMap[FileName] = FId;
2978       SourceFileNames.push_back(FileName);
2979     }
2980
2981     DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
2982       SourceIdMap.find(std::make_pair(DId, FId));
2983     if (SI != SourceIdMap.end())
2984       return SI->second;
2985
2986     unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
2987     SourceIdMap[std::make_pair(DId, FId)] = SrcId;
2988     SourceIds.push_back(std::make_pair(DId, FId));
2989
2990     return SrcId;
2991   }
2992
2993   void ConstructCompileUnit(GlobalVariable *GV) {
2994     DICompileUnit DIUnit(GV);
2995     std::string Dir, FN, Prod;
2996     unsigned ID = GetOrCreateSourceID(DIUnit.getDirectory(Dir),
2997                                       DIUnit.getFilename(FN));
2998
2999     DIE *Die = new DIE(DW_TAG_compile_unit);
3000     AddSectionOffset(Die, DW_AT_stmt_list, DW_FORM_data4,
3001                      DWLabel("section_line", 0), DWLabel("section_line", 0),
3002                      false);
3003     AddString(Die, DW_AT_producer, DW_FORM_string, DIUnit.getProducer(Prod));
3004     AddUInt(Die, DW_AT_language, DW_FORM_data1, DIUnit.getLanguage());
3005     AddString(Die, DW_AT_name, DW_FORM_string, FN);
3006     if (!Dir.empty())
3007       AddString(Die, DW_AT_comp_dir, DW_FORM_string, Dir);
3008     if (DIUnit.isOptimized())
3009       AddUInt(Die, DW_AT_APPLE_optimized, DW_FORM_flag, 1);
3010     std::string Flags;
3011     DIUnit.getFlags(Flags);
3012     if (!Flags.empty())
3013       AddString(Die, DW_AT_APPLE_flags, DW_FORM_string, Flags);
3014     unsigned RVer = DIUnit.getRunTimeVersion();
3015     if (RVer)
3016       AddUInt(Die, DW_AT_APPLE_major_runtime_vers, DW_FORM_data1, RVer);
3017
3018     CompileUnit *Unit = new CompileUnit(ID, Die);
3019     if (DIUnit.isMain()) {
3020       assert(!MainCU && "Multiple main compile units are found!");
3021       MainCU = Unit;
3022     }
3023     CompileUnitMap[DIUnit.getGV()] = Unit;
3024     CompileUnits.push_back(Unit);
3025   }
3026
3027   /// ConstructCompileUnits - Create a compile unit DIEs.
3028   void ConstructCompileUnits() {
3029     GlobalVariable *Root = M->getGlobalVariable("llvm.dbg.compile_units");
3030     if (!Root)
3031       return;
3032     assert(Root->hasLinkOnceLinkage() && Root->hasOneUse() &&
3033            "Malformed compile unit descriptor anchor type");
3034     Constant *RootC = cast<Constant>(*Root->use_begin());
3035     assert(RootC->hasNUsesOrMore(1) &&
3036            "Malformed compile unit descriptor anchor type");
3037     for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
3038          UI != UE; ++UI)
3039       for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
3040            UUI != UUE; ++UUI) {
3041         GlobalVariable *GV = cast<GlobalVariable>(*UUI);
3042         ConstructCompileUnit(GV);
3043       }
3044   }
3045
3046   bool ConstructGlobalVariableDIE(GlobalVariable *GV) {
3047     DIGlobalVariable DI_GV(GV);
3048     CompileUnit *DW_Unit = MainCU;
3049     if (!DW_Unit)
3050       DW_Unit = &FindCompileUnit(DI_GV.getCompileUnit());
3051
3052     // Check for pre-existence.
3053     DIE *&Slot = DW_Unit->getDieMapSlotFor(DI_GV.getGV());
3054     if (Slot)
3055       return false;
3056
3057     DIE *VariableDie = CreateGlobalVariableDIE(DW_Unit, DI_GV);
3058
3059     // Add address.
3060     DIEBlock *Block = new DIEBlock();
3061     AddUInt(Block, 0, DW_FORM_data1, DW_OP_addr);
3062     std::string GLN;
3063     AddObjectLabel(Block, 0, DW_FORM_udata,
3064                    Asm->getGlobalLinkName(DI_GV.getGlobal(), GLN));
3065     AddBlock(VariableDie, DW_AT_location, 0, Block);
3066
3067     // Add to map.
3068     Slot = VariableDie;
3069
3070     // Add to context owner.
3071     DW_Unit->getDie()->AddChild(VariableDie);
3072
3073     // Expose as global. FIXME - need to check external flag.
3074     std::string Name;
3075     DW_Unit->AddGlobal(DI_GV.getName(Name), VariableDie);
3076     return true;
3077   }
3078
3079   /// ConstructGlobalVariableDIEs - Create DIEs for each of the externally
3080   /// visible global variables. Return true if at least one global DIE is
3081   /// created.
3082   bool ConstructGlobalVariableDIEs() {
3083     GlobalVariable *Root = M->getGlobalVariable("llvm.dbg.global_variables");
3084     if (!Root)
3085       return false;
3086
3087     assert(Root->hasLinkOnceLinkage() && Root->hasOneUse() &&
3088            "Malformed global variable descriptor anchor type");
3089     Constant *RootC = cast<Constant>(*Root->use_begin());
3090     assert(RootC->hasNUsesOrMore(1) &&
3091            "Malformed global variable descriptor anchor type");
3092
3093     bool Result = false;
3094     for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
3095          UI != UE; ++UI)
3096       for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
3097            UUI != UUE; ++UUI)
3098         Result |= ConstructGlobalVariableDIE(cast<GlobalVariable>(*UUI));
3099
3100     return Result;
3101   }
3102
3103   bool ConstructSubprogram(GlobalVariable *GV) {
3104     DISubprogram SP(GV);
3105     CompileUnit *Unit = MainCU;
3106     if (!Unit)
3107       Unit = &FindCompileUnit(SP.getCompileUnit());
3108
3109     // Check for pre-existence.
3110     DIE *&Slot = Unit->getDieMapSlotFor(GV);
3111     if (Slot)
3112       return false;
3113
3114     if (!SP.isDefinition())
3115       // This is a method declaration which will be handled while
3116       // constructing class type.
3117       return false;
3118
3119     DIE *SubprogramDie = CreateSubprogramDIE(Unit, SP);
3120
3121     // Add to map.
3122     Slot = SubprogramDie;
3123
3124     // Add to context owner.
3125     Unit->getDie()->AddChild(SubprogramDie);
3126
3127     // Expose as global.
3128     std::string Name;
3129     Unit->AddGlobal(SP.getName(Name), SubprogramDie);
3130     return true;
3131   }
3132
3133   /// ConstructSubprograms - Create DIEs for each of the externally visible
3134   /// subprograms. Return true if at least one subprogram DIE is created.
3135   bool ConstructSubprograms() {
3136     GlobalVariable *Root = M->getGlobalVariable("llvm.dbg.subprograms");
3137     if (!Root)
3138       return false;
3139
3140     assert(Root->hasLinkOnceLinkage() && Root->hasOneUse() &&
3141            "Malformed subprogram descriptor anchor type");
3142     Constant *RootC = cast<Constant>(*Root->use_begin());
3143     assert(RootC->hasNUsesOrMore(1) &&
3144            "Malformed subprogram descriptor anchor type");
3145
3146     bool Result = false;
3147     for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
3148          UI != UE; ++UI)
3149       for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
3150            UUI != UUE; ++UUI)
3151         Result |= ConstructSubprogram(cast<GlobalVariable>(*UUI));
3152
3153     return Result;
3154   }
3155
3156 public:
3157   //===--------------------------------------------------------------------===//
3158   // Main entry points.
3159   //
3160   DwarfDebug(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
3161     : Dwarf(OS, A, T, "dbg"), MainCU(0),
3162       AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
3163       ValuesSet(InitValuesSetSize), Values(), StringPool(), SectionMap(),
3164       SectionSourceLines(), didInitial(false), shouldEmit(false),
3165       FunctionDbgScope(0), DebugTimer(0) {
3166     if (TimePassesIsEnabled)
3167       DebugTimer = new Timer("Dwarf Debug Writer",
3168                              getDwarfTimerGroup());
3169   }
3170   virtual ~DwarfDebug() {
3171     for (unsigned j = 0, M = Values.size(); j < M; ++j)
3172       delete Values[j];
3173
3174     for (DenseMap<const GlobalVariable *, DbgScope *>::iterator
3175            I = AbstractInstanceRootMap.begin(),
3176            E = AbstractInstanceRootMap.end(); I != E;++I)
3177       delete I->second;
3178
3179     delete DebugTimer;
3180   }
3181
3182   /// ShouldEmitDwarfDebug - Returns true if Dwarf debugging declarations should
3183   /// be emitted.
3184   bool ShouldEmitDwarfDebug() const { return shouldEmit; }
3185
3186   /// SetDebugInfo - Create global DIEs and emit initial debug info sections.
3187   /// This is inovked by the target AsmPrinter.
3188   void SetDebugInfo(MachineModuleInfo *mmi) {
3189     if (TimePassesIsEnabled)
3190       DebugTimer->startTimer();
3191
3192     // Create all the compile unit DIEs.
3193     ConstructCompileUnits();
3194
3195     if (CompileUnits.empty()) {
3196       if (TimePassesIsEnabled)
3197         DebugTimer->stopTimer();
3198
3199       return;
3200     }
3201
3202     // Create DIEs for each of the externally visible global variables.
3203     bool globalDIEs = ConstructGlobalVariableDIEs();
3204
3205     // Create DIEs for each of the externally visible subprograms.
3206     bool subprogramDIEs = ConstructSubprograms();
3207
3208     // If there is not any debug info available for any global variables
3209     // and any subprograms then there is not any debug info to emit.
3210     if (!globalDIEs && !subprogramDIEs) {
3211       if (TimePassesIsEnabled)
3212         DebugTimer->stopTimer();
3213
3214       return;
3215     }
3216
3217     MMI = mmi;
3218     shouldEmit = true;
3219     MMI->setDebugInfoAvailability(true);
3220
3221     // Prime section data.
3222     SectionMap.insert(TAI->getTextSection());
3223
3224     // Print out .file directives to specify files for .loc directives. These
3225     // are printed out early so that they precede any .loc directives.
3226     if (TAI->hasDotLocAndDotFile()) {
3227       for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
3228         // Remember source id starts at 1.
3229         std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
3230         sys::Path FullPath(getSourceDirectoryName(Id.first));
3231         bool AppendOk =
3232           FullPath.appendComponent(getSourceFileName(Id.second));
3233         assert(AppendOk && "Could not append filename to directory!");
3234         AppendOk = false;
3235         Asm->EmitFile(i, FullPath.toString());
3236         Asm->EOL();
3237       }
3238     }
3239
3240     // Emit initial sections
3241     EmitInitial();
3242
3243     if (TimePassesIsEnabled)
3244       DebugTimer->stopTimer();
3245   }
3246
3247   /// BeginModule - Emit all Dwarf sections that should come prior to the
3248   /// content.
3249   void BeginModule(Module *M) {
3250     this->M = M;
3251   }
3252
3253   /// EndModule - Emit all Dwarf sections that should come after the content.
3254   ///
3255   void EndModule() {
3256     if (!ShouldEmitDwarfDebug())
3257       return;
3258
3259     if (TimePassesIsEnabled)
3260       DebugTimer->startTimer();
3261
3262     // Standard sections final addresses.
3263     Asm->SwitchToSection(TAI->getTextSection());
3264     EmitLabel("text_end", 0);
3265     Asm->SwitchToSection(TAI->getDataSection());
3266     EmitLabel("data_end", 0);
3267
3268     // End text sections.
3269     for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
3270       Asm->SwitchToSection(SectionMap[i]);
3271       EmitLabel("section_end", i);
3272     }
3273
3274     // Emit common frame information.
3275     EmitCommonDebugFrame();
3276
3277     // Emit function debug frame information
3278     for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
3279            E = DebugFrames.end(); I != E; ++I)
3280       EmitFunctionDebugFrame(*I);
3281
3282     // Compute DIE offsets and sizes.
3283     SizeAndOffsets();
3284
3285     // Emit all the DIEs into a debug info section
3286     EmitDebugInfo();
3287
3288     // Corresponding abbreviations into a abbrev section.
3289     EmitAbbreviations();
3290
3291     // Emit source line correspondence into a debug line section.
3292     EmitDebugLines();
3293
3294     // Emit info into a debug pubnames section.
3295     EmitDebugPubNames();
3296
3297     // Emit info into a debug str section.
3298     EmitDebugStr();
3299
3300     // Emit info into a debug loc section.
3301     EmitDebugLoc();
3302
3303     // Emit info into a debug aranges section.
3304     EmitDebugARanges();
3305
3306     // Emit info into a debug ranges section.
3307     EmitDebugRanges();
3308
3309     // Emit info into a debug macinfo section.
3310     EmitDebugMacInfo();
3311
3312     // Emit inline info.
3313     EmitDebugInlineInfo();
3314
3315     if (TimePassesIsEnabled)
3316       DebugTimer->stopTimer();
3317   }
3318
3319   /// BeginFunction - Gather pre-function debug information.  Assumes being
3320   /// emitted immediately after the function entry point.
3321   void BeginFunction(MachineFunction *MF) {
3322     this->MF = MF;
3323
3324     if (!ShouldEmitDwarfDebug()) return;
3325
3326     if (TimePassesIsEnabled)
3327       DebugTimer->startTimer();
3328
3329     // Begin accumulating function debug information.
3330     MMI->BeginFunction(MF);
3331
3332     // Assumes in correct section after the entry point.
3333     EmitLabel("func_begin", ++SubprogramCount);
3334
3335     // Emit label for the implicitly defined dbg.stoppoint at the start of
3336     // the function.
3337     DebugLoc FDL = MF->getDefaultDebugLoc();
3338     if (!FDL.isUnknown()) {
3339       DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
3340       unsigned LabelID = RecordSourceLine(DLT.Line, DLT.Col,
3341                                           DICompileUnit(DLT.CompileUnit));
3342       Asm->printLabel(LabelID);
3343     }
3344
3345     if (TimePassesIsEnabled)
3346       DebugTimer->stopTimer();
3347   }
3348
3349   /// EndFunction - Gather and emit post-function debug information.
3350   ///
3351   void EndFunction(MachineFunction *MF) {
3352     if (!ShouldEmitDwarfDebug()) return;
3353
3354     if (TimePassesIsEnabled)
3355       DebugTimer->startTimer();
3356
3357     // Define end label for subprogram.
3358     EmitLabel("func_end", SubprogramCount);
3359
3360     // Get function line info.
3361     if (!Lines.empty()) {
3362       // Get section line info.
3363       unsigned ID = SectionMap.insert(Asm->CurrentSection_);
3364       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
3365       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
3366       // Append the function info to section info.
3367       SectionLineInfos.insert(SectionLineInfos.end(),
3368                               Lines.begin(), Lines.end());
3369     }
3370
3371     // Construct scopes for subprogram.
3372     if (FunctionDbgScope)
3373       ConstructFunctionDbgScope(FunctionDbgScope);
3374     else
3375       // FIXME: This is wrong. We are essentially getting past a problem with
3376       // debug information not being able to handle unreachable blocks that have
3377       // debug information in them. In particular, those unreachable blocks that
3378       // have "region end" info in them. That situation results in the "root
3379       // scope" not being created. If that's the case, then emit a "default"
3380       // scope, i.e., one that encompasses the whole function. This isn't
3381       // desirable. And a better way of handling this (and all of the debugging
3382       // information) needs to be explored.
3383       ConstructDefaultDbgScope(MF);
3384
3385     // Construct the DbgScope for abstract instances.
3386     for (SmallVector<DbgScope *, 32>::iterator
3387            I = AbstractInstanceRootList.begin(),
3388            E = AbstractInstanceRootList.end(); I != E; ++I)
3389       ConstructAbstractDbgScope(*I);
3390
3391     DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
3392                                                  MMI->getFrameMoves()));
3393
3394     // Clear debug info
3395     if (FunctionDbgScope) {
3396       delete FunctionDbgScope;
3397       DbgScopeMap.clear();
3398       DbgInlinedScopeMap.clear();
3399       InlinedVariableScopes.clear();
3400       FunctionDbgScope = NULL;
3401       LexicalScopeStack.clear();
3402       AbstractInstanceRootList.clear();
3403       LexicalScopeToConcreteInstMap.clear();
3404     }
3405
3406     Lines.clear();
3407
3408     if (TimePassesIsEnabled)
3409       DebugTimer->stopTimer();
3410   }
3411
3412   /// RecordSourceLine - Records location information and associates it with a
3413   /// label. Returns a unique label ID used to generate a label and provide
3414   /// correspondence to the source line list.
3415   unsigned RecordSourceLine(Value *V, unsigned Line, unsigned Col) {
3416     if (TimePassesIsEnabled)
3417       DebugTimer->startTimer();
3418
3419     CompileUnit *Unit = CompileUnitMap[V];
3420     assert(Unit && "Unable to find CompileUnit");
3421     unsigned ID = MMI->NextLabelID();
3422     Lines.push_back(SrcLineInfo(Line, Col, Unit->getID(), ID));
3423
3424     if (TimePassesIsEnabled)
3425       DebugTimer->stopTimer();
3426
3427     return ID;
3428   }
3429
3430   /// RecordSourceLine - Records location information and associates it with a
3431   /// label. Returns a unique label ID used to generate a label and provide
3432   /// correspondence to the source line list.
3433   unsigned RecordSourceLine(unsigned Line, unsigned Col, DICompileUnit CU) {
3434     if (TimePassesIsEnabled)
3435       DebugTimer->startTimer();
3436
3437     std::string Dir, Fn;
3438     unsigned Src = GetOrCreateSourceID(CU.getDirectory(Dir),
3439                                        CU.getFilename(Fn));
3440     unsigned ID = MMI->NextLabelID();
3441     Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
3442
3443     if (TimePassesIsEnabled)
3444       DebugTimer->stopTimer();
3445
3446     return ID;
3447   }
3448
3449   /// getRecordSourceLineCount - Return the number of source lines in the debug
3450   /// info.
3451   unsigned getRecordSourceLineCount() const {
3452     return Lines.size();
3453   }
3454
3455   /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
3456   /// timed. Look up the source id with the given directory and source file
3457   /// names. If none currently exists, create a new id and insert it in the
3458   /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
3459   /// well.
3460   unsigned getOrCreateSourceID(const std::string &DirName,
3461                                const std::string &FileName) {
3462     if (TimePassesIsEnabled)
3463       DebugTimer->startTimer();
3464
3465     unsigned SrcId = GetOrCreateSourceID(DirName, FileName);
3466
3467     if (TimePassesIsEnabled)
3468       DebugTimer->stopTimer();
3469
3470     return SrcId;
3471   }
3472
3473   /// RecordRegionStart - Indicate the start of a region.
3474   unsigned RecordRegionStart(GlobalVariable *V) {
3475     if (TimePassesIsEnabled)
3476       DebugTimer->startTimer();
3477
3478     DbgScope *Scope = getOrCreateScope(V);
3479     unsigned ID = MMI->NextLabelID();
3480     if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID);
3481     LexicalScopeStack.push_back(Scope);
3482
3483     if (TimePassesIsEnabled)
3484       DebugTimer->stopTimer();
3485
3486     return ID;
3487   }
3488
3489   /// RecordRegionEnd - Indicate the end of a region.
3490   unsigned RecordRegionEnd(GlobalVariable *V, DISubprogram &SP) {
3491     if (TimePassesIsEnabled)
3492       DebugTimer->startTimer();
3493
3494     unsigned ID = MMI->NextLabelID();
3495     DbgScope *Scope = getOrCreateScope(V);
3496     Scope->setEndLabelID(ID);
3497     LexicalScopeStack.pop_back();
3498
3499     if (TimePassesIsEnabled)
3500       DebugTimer->stopTimer();
3501
3502     return ID;
3503   }
3504
3505   /// RecordVariable - Indicate the declaration of  a local variable.
3506   void RecordVariable(GlobalVariable *GV, unsigned FrameIndex,
3507                       const MachineInstr *MI) {
3508     if (TimePassesIsEnabled)
3509       DebugTimer->startTimer();
3510
3511     DIDescriptor Desc(GV);
3512     DbgScope *Scope = NULL;
3513
3514     if (Desc.getTag() == DW_TAG_variable) {
3515       // GV is a global variable.
3516       DIGlobalVariable DG(GV);
3517       Scope = getOrCreateScope(DG.getContext().getGV());
3518     } else {
3519       DenseMap<const MachineInstr *, DbgScope *>::iterator
3520         SI = InlinedVariableScopes.find(MI);
3521
3522       if (SI != InlinedVariableScopes.end())  {
3523         // or GV is an inlined local variable.
3524         Scope = SI->second;
3525       } else {
3526       // or GV is a local variable.
3527         DIVariable DV(GV);
3528         Scope = getOrCreateScope(DV.getContext().getGV());
3529       }
3530     }
3531
3532     assert(Scope && "Unable to find variable' scope");
3533     DbgVariable *DV = new DbgVariable(DIVariable(GV), FrameIndex);
3534     Scope->AddVariable(DV);
3535
3536     if (TimePassesIsEnabled)
3537       DebugTimer->stopTimer();
3538   }
3539
3540   //// RecordInlinedFnStart - Indicate the start of inlined subroutine.
3541   unsigned RecordInlinedFnStart(DISubprogram &SP, DICompileUnit CU,
3542                                 unsigned Line, unsigned Col) {
3543     unsigned LabelID = MMI->NextLabelID();
3544
3545     if (!TAI->doesDwarfUsesInlineInfoSection())
3546       return LabelID;
3547
3548     if (TimePassesIsEnabled)
3549       DebugTimer->startTimer();
3550
3551     GlobalVariable *GV = SP.getGV();
3552     DenseMap<const GlobalVariable *, DbgScope *>::iterator
3553       II = AbstractInstanceRootMap.find(GV);
3554
3555     if (II == AbstractInstanceRootMap.end()) {
3556       // Create an abstract instance entry for this inlined function if it
3557       // doesn't already exist.
3558       DbgScope *Scope = new DbgScope(NULL, DIDescriptor(GV));
3559
3560       // Get the compile unit context.
3561       CompileUnit *Unit = &FindCompileUnit(SP.getCompileUnit());
3562       DIE *SPDie = Unit->getDieMapSlotFor(GV);
3563       assert(SPDie && "Missing subprogram descriptor!");
3564
3565       // Mark as being inlined. This makes this subprogram entry an abstract
3566       // instance root.
3567       // FIXME: Our debugger doesn't care about the value of DW_AT_inline, only
3568       // that it's defined. It probably won't change in the future, but this
3569       // could be more elegant.
3570       AddUInt(SPDie, DW_AT_inline, 0, DW_INL_declared_not_inlined);
3571
3572       // Keep track of the scope that's inlined into this function.
3573       DenseMap<GlobalVariable *, SmallVector<DbgScope *, 2> >::iterator
3574         SI = DbgInlinedScopeMap.find(GV);
3575
3576       if (SI == DbgInlinedScopeMap.end())
3577         DbgInlinedScopeMap[GV].push_back(Scope);
3578       else
3579         SI->second.push_back(Scope);
3580
3581       // Track the start label for this inlined function.
3582       DenseMap<GlobalVariable *, SmallVector<unsigned, 4> >::iterator
3583         I = InlineInfo.find(GV);
3584
3585       if (I == InlineInfo.end())
3586         InlineInfo[GV].push_back(LabelID);
3587       else
3588         I->second.push_back(LabelID);
3589
3590       AbstractInstanceRootMap[GV] = Scope;
3591       AbstractInstanceRootList.push_back(Scope);
3592     }
3593
3594     // Create a concrete inlined instance for this inlined function.
3595     DIE *ScopeDie = new DIE(DW_TAG_inlined_subroutine);
3596     CompileUnit *Unit = &FindCompileUnit(SP.getCompileUnit());
3597     DIE *Origin = Unit->getDieMapSlotFor(GV);
3598     AddDIEntry(ScopeDie, DW_AT_abstract_origin, DW_FORM_ref4, Origin);
3599     AddUInt(ScopeDie, DW_AT_call_file, 0, Unit->getID());
3600     AddUInt(ScopeDie, DW_AT_call_line, 0, Line);
3601     AddUInt(ScopeDie, DW_AT_call_column, 0, Col);
3602
3603     LexicalScopeToConcreteInstMap[LexicalScopeStack.back()] = ScopeDie;
3604
3605     if (TimePassesIsEnabled)
3606       DebugTimer->stopTimer();
3607
3608     return LabelID;
3609   }
3610
3611   /// RecordInlinedFnEnd - Indicate the end of inlined subroutine.
3612   unsigned RecordInlinedFnEnd(DISubprogram &SP) {
3613     // FIXME: This function never seems to be called!!
3614     if (!TAI->doesDwarfUsesInlineInfoSection())
3615       return 0;
3616
3617     if (TimePassesIsEnabled)
3618       DebugTimer->startTimer();
3619
3620     GlobalVariable *GV = SP.getGV();
3621     DenseMap<GlobalVariable *, SmallVector<DbgScope *, 2> >::iterator
3622       I = DbgInlinedScopeMap.find(GV);
3623
3624     if (I == DbgInlinedScopeMap.end()) {
3625       if (TimePassesIsEnabled)
3626         DebugTimer->stopTimer();
3627
3628       return 0;
3629     }
3630
3631     SmallVector<DbgScope *, 2> &Scopes = I->second;
3632     assert(!Scopes.empty() && "We should have at least one debug scope!");
3633     DbgScope *Scope = Scopes.back(); Scopes.pop_back();
3634     unsigned ID = MMI->NextLabelID();
3635
3636     MMI->RecordUsedDbgLabel(ID);
3637     Scope->setEndLabelID(ID);
3638
3639     if (TimePassesIsEnabled)
3640       DebugTimer->stopTimer();
3641
3642     return ID;
3643   }
3644
3645   /// RecordVariableScope - Record scope for the variable declared by
3646   /// DeclareMI. DeclareMI must describe TargetInstrInfo::DECLARE.
3647   /// Record scopes for only inlined subroutine variables. Other
3648   /// variables' scopes are determined during RecordVariable().
3649   void RecordVariableScope(DIVariable &DV, const MachineInstr *DeclareMI) {
3650     if (TimePassesIsEnabled)
3651       DebugTimer->startTimer();
3652
3653     DISubprogram SP(DV.getContext().getGV());
3654
3655     if (SP.isNull()) {
3656       if (TimePassesIsEnabled)
3657         DebugTimer->stopTimer();
3658
3659       return;
3660     }
3661
3662     DenseMap<GlobalVariable *, SmallVector<DbgScope *, 2> >::iterator
3663       I = DbgInlinedScopeMap.find(SP.getGV());
3664     if (I != DbgInlinedScopeMap.end())
3665       InlinedVariableScopes[DeclareMI] = I->second.back();
3666
3667     if (TimePassesIsEnabled)
3668       DebugTimer->stopTimer();
3669   }
3670 };
3671
3672 //===----------------------------------------------------------------------===//
3673 /// DwarfException - Emits Dwarf exception handling directives.
3674 ///
3675 class DwarfException : public Dwarf  {
3676   struct FunctionEHFrameInfo {
3677     std::string FnName;
3678     unsigned Number;
3679     unsigned PersonalityIndex;
3680     bool hasCalls;
3681     bool hasLandingPads;
3682     std::vector<MachineMove> Moves;
3683     const Function * function;
3684
3685     FunctionEHFrameInfo(const std::string &FN, unsigned Num, unsigned P,
3686                         bool hC, bool hL,
3687                         const std::vector<MachineMove> &M,
3688                         const Function *f):
3689       FnName(FN), Number(Num), PersonalityIndex(P),
3690       hasCalls(hC), hasLandingPads(hL), Moves(M), function (f) { }
3691   };
3692
3693   std::vector<FunctionEHFrameInfo> EHFrames;
3694
3695   /// shouldEmitTable - Per-function flag to indicate if EH tables should
3696   /// be emitted.
3697   bool shouldEmitTable;
3698
3699   /// shouldEmitMoves - Per-function flag to indicate if frame moves info
3700   /// should be emitted.
3701   bool shouldEmitMoves;
3702
3703   /// shouldEmitTableModule - Per-module flag to indicate if EH tables
3704   /// should be emitted.
3705   bool shouldEmitTableModule;
3706
3707   /// shouldEmitFrameModule - Per-module flag to indicate if frame moves
3708   /// should be emitted.
3709   bool shouldEmitMovesModule;
3710
3711   /// ExceptionTimer - Timer for the Dwarf exception writer.
3712   Timer *ExceptionTimer;
3713
3714   /// EmitCommonEHFrame - Emit the common eh unwind frame.
3715   ///
3716   void EmitCommonEHFrame(const Function *Personality, unsigned Index) {
3717     // Size and sign of stack growth.
3718     int stackGrowth =
3719         Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3720           TargetFrameInfo::StackGrowsUp ?
3721         TD->getPointerSize() : -TD->getPointerSize();
3722
3723     // Begin eh frame section.
3724     Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
3725
3726     if (!TAI->doesRequireNonLocalEHFrameLabel())
3727       O << TAI->getEHGlobalPrefix();
3728     O << "EH_frame" << Index << ":\n";
3729     EmitLabel("section_eh_frame", Index);
3730
3731     // Define base labels.
3732     EmitLabel("eh_frame_common", Index);
3733
3734     // Define the eh frame length.
3735     EmitDifference("eh_frame_common_end", Index,
3736                    "eh_frame_common_begin", Index, true);
3737     Asm->EOL("Length of Common Information Entry");
3738
3739     // EH frame header.
3740     EmitLabel("eh_frame_common_begin", Index);
3741     Asm->EmitInt32((int)0);
3742     Asm->EOL("CIE Identifier Tag");
3743     Asm->EmitInt8(DW_CIE_VERSION);
3744     Asm->EOL("CIE Version");
3745
3746     // The personality presence indicates that language specific information
3747     // will show up in the eh frame.
3748     Asm->EmitString(Personality ? "zPLR" : "zR");
3749     Asm->EOL("CIE Augmentation");
3750
3751     // Round out reader.
3752     Asm->EmitULEB128Bytes(1);
3753     Asm->EOL("CIE Code Alignment Factor");
3754     Asm->EmitSLEB128Bytes(stackGrowth);
3755     Asm->EOL("CIE Data Alignment Factor");
3756     Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), true));
3757     Asm->EOL("CIE Return Address Column");
3758
3759     // If there is a personality, we need to indicate the functions location.
3760     if (Personality) {
3761       Asm->EmitULEB128Bytes(7);
3762       Asm->EOL("Augmentation Size");
3763
3764       if (TAI->getNeedsIndirectEncoding()) {
3765         Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect);
3766         Asm->EOL("Personality (pcrel sdata4 indirect)");
3767       } else {
3768         Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
3769         Asm->EOL("Personality (pcrel sdata4)");
3770       }
3771
3772       PrintRelDirective(true);
3773       O << TAI->getPersonalityPrefix();
3774       Asm->EmitExternalGlobal((const GlobalVariable *)(Personality));
3775       O << TAI->getPersonalitySuffix();
3776       if (strcmp(TAI->getPersonalitySuffix(), "+4@GOTPCREL"))
3777         O << "-" << TAI->getPCSymbol();
3778       Asm->EOL("Personality");
3779
3780       Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
3781       Asm->EOL("LSDA Encoding (pcrel sdata4)");
3782
3783       Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
3784       Asm->EOL("FDE Encoding (pcrel sdata4)");
3785    } else {
3786       Asm->EmitULEB128Bytes(1);
3787       Asm->EOL("Augmentation Size");
3788
3789       Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
3790       Asm->EOL("FDE Encoding (pcrel sdata4)");
3791     }
3792
3793     // Indicate locations of general callee saved registers in frame.
3794     std::vector<MachineMove> Moves;
3795     RI->getInitialFrameState(Moves);
3796     EmitFrameMoves(NULL, 0, Moves, true);
3797
3798     // On Darwin the linker honors the alignment of eh_frame, which means it
3799     // must be 8-byte on 64-bit targets to match what gcc does.  Otherwise
3800     // you get holes which confuse readers of eh_frame.
3801     Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
3802                        0, 0, false);
3803     EmitLabel("eh_frame_common_end", Index);
3804
3805     Asm->EOL();
3806   }
3807
3808   /// EmitEHFrame - Emit function exception frame information.
3809   ///
3810   void EmitEHFrame(const FunctionEHFrameInfo &EHFrameInfo) {
3811     Function::LinkageTypes linkage = EHFrameInfo.function->getLinkage();
3812
3813     assert(!EHFrameInfo.function->hasAvailableExternallyLinkage() &&
3814            "Should not emit 'available externally' functions at all");
3815
3816     Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
3817
3818     // Externally visible entry into the functions eh frame info.
3819     // If the corresponding function is static, this should not be
3820     // externally visible.
3821     if (linkage != Function::InternalLinkage &&
3822         linkage != Function::PrivateLinkage) {
3823       if (const char *GlobalEHDirective = TAI->getGlobalEHDirective())
3824         O << GlobalEHDirective << EHFrameInfo.FnName << "\n";
3825     }
3826
3827     // If corresponding function is weak definition, this should be too.
3828     if ((linkage == Function::WeakAnyLinkage ||
3829          linkage == Function::WeakODRLinkage ||
3830          linkage == Function::LinkOnceAnyLinkage ||
3831          linkage == Function::LinkOnceODRLinkage) &&
3832         TAI->getWeakDefDirective())
3833       O << TAI->getWeakDefDirective() << EHFrameInfo.FnName << "\n";
3834
3835     // If there are no calls then you can't unwind.  This may mean we can
3836     // omit the EH Frame, but some environments do not handle weak absolute
3837     // symbols.
3838     // If UnwindTablesMandatory is set we cannot do this optimization; the
3839     // unwind info is to be available for non-EH uses.
3840     if (!EHFrameInfo.hasCalls &&
3841         !UnwindTablesMandatory &&
3842         ((linkage != Function::WeakAnyLinkage &&
3843           linkage != Function::WeakODRLinkage &&
3844           linkage != Function::LinkOnceAnyLinkage &&
3845           linkage != Function::LinkOnceODRLinkage) ||
3846          !TAI->getWeakDefDirective() ||
3847          TAI->getSupportsWeakOmittedEHFrame()))
3848     {
3849       O << EHFrameInfo.FnName << " = 0\n";
3850       // This name has no connection to the function, so it might get
3851       // dead-stripped when the function is not, erroneously.  Prohibit
3852       // dead-stripping unconditionally.
3853       if (const char *UsedDirective = TAI->getUsedDirective())
3854         O << UsedDirective << EHFrameInfo.FnName << "\n\n";
3855     } else {
3856       O << EHFrameInfo.FnName << ":\n";
3857
3858       // EH frame header.
3859       EmitDifference("eh_frame_end", EHFrameInfo.Number,
3860                      "eh_frame_begin", EHFrameInfo.Number, true);
3861       Asm->EOL("Length of Frame Information Entry");
3862
3863       EmitLabel("eh_frame_begin", EHFrameInfo.Number);
3864
3865       if (TAI->doesRequireNonLocalEHFrameLabel()) {
3866         PrintRelDirective(true, true);
3867         PrintLabelName("eh_frame_begin", EHFrameInfo.Number);
3868
3869         if (!TAI->isAbsoluteEHSectionOffsets())
3870           O << "-EH_frame" << EHFrameInfo.PersonalityIndex;
3871       } else {
3872         EmitSectionOffset("eh_frame_begin", "eh_frame_common",
3873                           EHFrameInfo.Number, EHFrameInfo.PersonalityIndex,
3874                           true, true, false);
3875       }
3876
3877       Asm->EOL("FDE CIE offset");
3878
3879       EmitReference("eh_func_begin", EHFrameInfo.Number, true, true);
3880       Asm->EOL("FDE initial location");
3881       EmitDifference("eh_func_end", EHFrameInfo.Number,
3882                      "eh_func_begin", EHFrameInfo.Number, true);
3883       Asm->EOL("FDE address range");
3884
3885       // If there is a personality and landing pads then point to the language
3886       // specific data area in the exception table.
3887       if (EHFrameInfo.PersonalityIndex) {
3888         Asm->EmitULEB128Bytes(4);
3889         Asm->EOL("Augmentation size");
3890
3891         if (EHFrameInfo.hasLandingPads)
3892           EmitReference("exception", EHFrameInfo.Number, true, true);
3893         else
3894           Asm->EmitInt32((int)0);
3895         Asm->EOL("Language Specific Data Area");
3896       } else {
3897         Asm->EmitULEB128Bytes(0);
3898         Asm->EOL("Augmentation size");
3899       }
3900
3901       // Indicate locations of function specific  callee saved registers in
3902       // frame.
3903       EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves,
3904                      true);
3905
3906       // On Darwin the linker honors the alignment of eh_frame, which means it
3907       // must be 8-byte on 64-bit targets to match what gcc does.  Otherwise
3908       // you get holes which confuse readers of eh_frame.
3909       Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
3910                          0, 0, false);
3911       EmitLabel("eh_frame_end", EHFrameInfo.Number);
3912
3913       // If the function is marked used, this table should be also.  We cannot
3914       // make the mark unconditional in this case, since retaining the table
3915       // also retains the function in this case, and there is code around
3916       // that depends on unused functions (calling undefined externals) being
3917       // dead-stripped to link correctly.  Yes, there really is.
3918       if (MMI->getUsedFunctions().count(EHFrameInfo.function))
3919         if (const char *UsedDirective = TAI->getUsedDirective())
3920           O << UsedDirective << EHFrameInfo.FnName << "\n\n";
3921     }
3922   }
3923
3924   /// EmitExceptionTable - Emit landing pads and actions.
3925   ///
3926   /// The general organization of the table is complex, but the basic concepts
3927   /// are easy.  First there is a header which describes the location and
3928   /// organization of the three components that follow.
3929   ///  1. The landing pad site information describes the range of code covered
3930   ///     by the try.  In our case it's an accumulation of the ranges covered
3931   ///     by the invokes in the try.  There is also a reference to the landing
3932   ///     pad that handles the exception once processed.  Finally an index into
3933   ///     the actions table.
3934   ///  2. The action table, in our case, is composed of pairs of type ids
3935   ///     and next action offset.  Starting with the action index from the
3936   ///     landing pad site, each type Id is checked for a match to the current
3937   ///     exception.  If it matches then the exception and type id are passed
3938   ///     on to the landing pad.  Otherwise the next action is looked up.  This
3939   ///     chain is terminated with a next action of zero.  If no type id is
3940   ///     found the the frame is unwound and handling continues.
3941   ///  3. Type id table contains references to all the C++ typeinfo for all
3942   ///     catches in the function.  This tables is reversed indexed base 1.
3943
3944   /// SharedTypeIds - How many leading type ids two landing pads have in common.
3945   static unsigned SharedTypeIds(const LandingPadInfo *L,
3946                                 const LandingPadInfo *R) {
3947     const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
3948     unsigned LSize = LIds.size(), RSize = RIds.size();
3949     unsigned MinSize = LSize < RSize ? LSize : RSize;
3950     unsigned Count = 0;
3951
3952     for (; Count != MinSize; ++Count)
3953       if (LIds[Count] != RIds[Count])
3954         return Count;
3955
3956     return Count;
3957   }
3958
3959   /// PadLT - Order landing pads lexicographically by type id.
3960   static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R) {
3961     const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
3962     unsigned LSize = LIds.size(), RSize = RIds.size();
3963     unsigned MinSize = LSize < RSize ? LSize : RSize;
3964
3965     for (unsigned i = 0; i != MinSize; ++i)
3966       if (LIds[i] != RIds[i])
3967         return LIds[i] < RIds[i];
3968
3969     return LSize < RSize;
3970   }
3971
3972   struct KeyInfo {
3973     static inline unsigned getEmptyKey() { return -1U; }
3974     static inline unsigned getTombstoneKey() { return -2U; }
3975     static unsigned getHashValue(const unsigned &Key) { return Key; }
3976     static bool isEqual(unsigned LHS, unsigned RHS) { return LHS == RHS; }
3977     static bool isPod() { return true; }
3978   };
3979
3980   /// ActionEntry - Structure describing an entry in the actions table.
3981   struct ActionEntry {
3982     int ValueForTypeID; // The value to write - may not be equal to the type id.
3983     int NextAction;
3984     struct ActionEntry *Previous;
3985   };
3986
3987   /// PadRange - Structure holding a try-range and the associated landing pad.
3988   struct PadRange {
3989     // The index of the landing pad.
3990     unsigned PadIndex;
3991     // The index of the begin and end labels in the landing pad's label lists.
3992     unsigned RangeIndex;
3993   };
3994
3995   typedef DenseMap<unsigned, PadRange, KeyInfo> RangeMapType;
3996
3997   /// CallSiteEntry - Structure describing an entry in the call-site table.
3998   struct CallSiteEntry {
3999     // The 'try-range' is BeginLabel .. EndLabel.
4000     unsigned BeginLabel; // zero indicates the start of the function.
4001     unsigned EndLabel;   // zero indicates the end of the function.
4002     // The landing pad starts at PadLabel.
4003     unsigned PadLabel;   // zero indicates that there is no landing pad.
4004     unsigned Action;
4005   };
4006
4007   void EmitExceptionTable() {
4008     const std::vector<GlobalVariable *> &TypeInfos = MMI->getTypeInfos();
4009     const std::vector<unsigned> &FilterIds = MMI->getFilterIds();
4010     const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
4011     if (PadInfos.empty()) return;
4012
4013     // Sort the landing pads in order of their type ids.  This is used to fold
4014     // duplicate actions.
4015     SmallVector<const LandingPadInfo *, 64> LandingPads;
4016     LandingPads.reserve(PadInfos.size());
4017     for (unsigned i = 0, N = PadInfos.size(); i != N; ++i)
4018       LandingPads.push_back(&PadInfos[i]);
4019     std::sort(LandingPads.begin(), LandingPads.end(), PadLT);
4020
4021     // Negative type ids index into FilterIds, positive type ids index into
4022     // TypeInfos.  The value written for a positive type id is just the type
4023     // id itself.  For a negative type id, however, the value written is the
4024     // (negative) byte offset of the corresponding FilterIds entry.  The byte
4025     // offset is usually equal to the type id, because the FilterIds entries
4026     // are written using a variable width encoding which outputs one byte per
4027     // entry as long as the value written is not too large, but can differ.
4028     // This kind of complication does not occur for positive type ids because
4029     // type infos are output using a fixed width encoding.
4030     // FilterOffsets[i] holds the byte offset corresponding to FilterIds[i].
4031     SmallVector<int, 16> FilterOffsets;
4032     FilterOffsets.reserve(FilterIds.size());
4033     int Offset = -1;
4034     for(std::vector<unsigned>::const_iterator I = FilterIds.begin(),
4035         E = FilterIds.end(); I != E; ++I) {
4036       FilterOffsets.push_back(Offset);
4037       Offset -= TargetAsmInfo::getULEB128Size(*I);
4038     }
4039
4040     // Compute the actions table and gather the first action index for each
4041     // landing pad site.
4042     SmallVector<ActionEntry, 32> Actions;
4043     SmallVector<unsigned, 64> FirstActions;
4044     FirstActions.reserve(LandingPads.size());
4045
4046     int FirstAction = 0;
4047     unsigned SizeActions = 0;
4048     for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
4049       const LandingPadInfo *LP = LandingPads[i];
4050       const std::vector<int> &TypeIds = LP->TypeIds;
4051       const unsigned NumShared = i ? SharedTypeIds(LP, LandingPads[i-1]) : 0;
4052       unsigned SizeSiteActions = 0;
4053
4054       if (NumShared < TypeIds.size()) {
4055         unsigned SizeAction = 0;
4056         ActionEntry *PrevAction = 0;
4057
4058         if (NumShared) {
4059           const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size();
4060           assert(Actions.size());
4061           PrevAction = &Actions.back();
4062           SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) +
4063             TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
4064           for (unsigned j = NumShared; j != SizePrevIds; ++j) {
4065             SizeAction -=
4066               TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
4067             SizeAction += -PrevAction->NextAction;
4068             PrevAction = PrevAction->Previous;
4069           }
4070         }
4071
4072         // Compute the actions.
4073         for (unsigned I = NumShared, M = TypeIds.size(); I != M; ++I) {
4074           int TypeID = TypeIds[I];
4075           assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!");
4076           int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID;
4077           unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID);
4078
4079           int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0;
4080           SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction);
4081           SizeSiteActions += SizeAction;
4082
4083           ActionEntry Action = {ValueForTypeID, NextAction, PrevAction};
4084           Actions.push_back(Action);
4085
4086           PrevAction = &Actions.back();
4087         }
4088
4089         // Record the first action of the landing pad site.
4090         FirstAction = SizeActions + SizeSiteActions - SizeAction + 1;
4091       } // else identical - re-use previous FirstAction
4092
4093       FirstActions.push_back(FirstAction);
4094
4095       // Compute this sites contribution to size.
4096       SizeActions += SizeSiteActions;
4097     }
4098
4099     // Compute the call-site table.  The entry for an invoke has a try-range
4100     // containing the call, a non-zero landing pad and an appropriate action.
4101     // The entry for an ordinary call has a try-range containing the call and
4102     // zero for the landing pad and the action.  Calls marked 'nounwind' have
4103     // no entry and must not be contained in the try-range of any entry - they
4104     // form gaps in the table.  Entries must be ordered by try-range address.
4105     SmallVector<CallSiteEntry, 64> CallSites;
4106
4107     RangeMapType PadMap;
4108     // Invokes and nounwind calls have entries in PadMap (due to being bracketed
4109     // by try-range labels when lowered).  Ordinary calls do not, so appropriate
4110     // try-ranges for them need be deduced.
4111     for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
4112       const LandingPadInfo *LandingPad = LandingPads[i];
4113       for (unsigned j = 0, E = LandingPad->BeginLabels.size(); j != E; ++j) {
4114         unsigned BeginLabel = LandingPad->BeginLabels[j];
4115         assert(!PadMap.count(BeginLabel) && "Duplicate landing pad labels!");
4116         PadRange P = { i, j };
4117         PadMap[BeginLabel] = P;
4118       }
4119     }
4120
4121     // The end label of the previous invoke or nounwind try-range.
4122     unsigned LastLabel = 0;
4123
4124     // Whether there is a potentially throwing instruction (currently this means
4125     // an ordinary call) between the end of the previous try-range and now.
4126     bool SawPotentiallyThrowing = false;
4127
4128     // Whether the last callsite entry was for an invoke.
4129     bool PreviousIsInvoke = false;
4130
4131     // Visit all instructions in order of address.
4132     for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
4133          I != E; ++I) {
4134       for (MachineBasicBlock::const_iterator MI = I->begin(), E = I->end();
4135            MI != E; ++MI) {
4136         if (!MI->isLabel()) {
4137           SawPotentiallyThrowing |= MI->getDesc().isCall();
4138           continue;
4139         }
4140
4141         unsigned BeginLabel = MI->getOperand(0).getImm();
4142         assert(BeginLabel && "Invalid label!");
4143
4144         // End of the previous try-range?
4145         if (BeginLabel == LastLabel)
4146           SawPotentiallyThrowing = false;
4147
4148         // Beginning of a new try-range?
4149         RangeMapType::iterator L = PadMap.find(BeginLabel);
4150         if (L == PadMap.end())
4151           // Nope, it was just some random label.
4152           continue;
4153
4154         PadRange P = L->second;
4155         const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
4156
4157         assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
4158                "Inconsistent landing pad map!");
4159
4160         // If some instruction between the previous try-range and this one may
4161         // throw, create a call-site entry with no landing pad for the region
4162         // between the try-ranges.
4163         if (SawPotentiallyThrowing) {
4164           CallSiteEntry Site = {LastLabel, BeginLabel, 0, 0};
4165           CallSites.push_back(Site);
4166           PreviousIsInvoke = false;
4167         }
4168
4169         LastLabel = LandingPad->EndLabels[P.RangeIndex];
4170         assert(BeginLabel && LastLabel && "Invalid landing pad!");
4171
4172         if (LandingPad->LandingPadLabel) {
4173           // This try-range is for an invoke.
4174           CallSiteEntry Site = {BeginLabel, LastLabel,
4175             LandingPad->LandingPadLabel, FirstActions[P.PadIndex]};
4176
4177           // Try to merge with the previous call-site.
4178           if (PreviousIsInvoke) {
4179             CallSiteEntry &Prev = CallSites.back();
4180             if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) {
4181               // Extend the range of the previous entry.
4182               Prev.EndLabel = Site.EndLabel;
4183               continue;
4184             }
4185           }
4186
4187           // Otherwise, create a new call-site.
4188           CallSites.push_back(Site);
4189           PreviousIsInvoke = true;
4190         } else {
4191           // Create a gap.
4192           PreviousIsInvoke = false;
4193         }
4194       }
4195     }
4196     // If some instruction between the previous try-range and the end of the
4197     // function may throw, create a call-site entry with no landing pad for the
4198     // region following the try-range.
4199     if (SawPotentiallyThrowing) {
4200       CallSiteEntry Site = {LastLabel, 0, 0, 0};
4201       CallSites.push_back(Site);
4202     }
4203
4204     // Final tallies.
4205
4206     // Call sites.
4207     const unsigned SiteStartSize  = sizeof(int32_t); // DW_EH_PE_udata4
4208     const unsigned SiteLengthSize = sizeof(int32_t); // DW_EH_PE_udata4
4209     const unsigned LandingPadSize = sizeof(int32_t); // DW_EH_PE_udata4
4210     unsigned SizeSites = CallSites.size() * (SiteStartSize +
4211                                              SiteLengthSize +
4212                                              LandingPadSize);
4213     for (unsigned i = 0, e = CallSites.size(); i < e; ++i)
4214       SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action);
4215
4216     // Type infos.
4217     const unsigned TypeInfoSize = TD->getPointerSize(); // DW_EH_PE_absptr
4218     unsigned SizeTypes = TypeInfos.size() * TypeInfoSize;
4219
4220     unsigned TypeOffset = sizeof(int8_t) + // Call site format
4221            TargetAsmInfo::getULEB128Size(SizeSites) + // Call-site table length
4222                           SizeSites + SizeActions + SizeTypes;
4223
4224     unsigned TotalSize = sizeof(int8_t) + // LPStart format
4225                          sizeof(int8_t) + // TType format
4226            TargetAsmInfo::getULEB128Size(TypeOffset) + // TType base offset
4227                          TypeOffset;
4228
4229     unsigned SizeAlign = (4 - TotalSize) & 3;
4230
4231     // Begin the exception table.
4232     Asm->SwitchToDataSection(TAI->getDwarfExceptionSection());
4233     Asm->EmitAlignment(2, 0, 0, false);
4234     O << "GCC_except_table" << SubprogramCount << ":\n";
4235     for (unsigned i = 0; i != SizeAlign; ++i) {
4236       Asm->EmitInt8(0);
4237       Asm->EOL("Padding");
4238     }
4239     EmitLabel("exception", SubprogramCount);
4240
4241     // Emit the header.
4242     Asm->EmitInt8(DW_EH_PE_omit);
4243     Asm->EOL("LPStart format (DW_EH_PE_omit)");
4244     Asm->EmitInt8(DW_EH_PE_absptr);
4245     Asm->EOL("TType format (DW_EH_PE_absptr)");
4246     Asm->EmitULEB128Bytes(TypeOffset);
4247     Asm->EOL("TType base offset");
4248     Asm->EmitInt8(DW_EH_PE_udata4);
4249     Asm->EOL("Call site format (DW_EH_PE_udata4)");
4250     Asm->EmitULEB128Bytes(SizeSites);
4251     Asm->EOL("Call-site table length");
4252
4253     // Emit the landing pad site information.
4254     for (unsigned i = 0; i < CallSites.size(); ++i) {
4255       CallSiteEntry &S = CallSites[i];
4256       const char *BeginTag;
4257       unsigned BeginNumber;
4258
4259       if (!S.BeginLabel) {
4260         BeginTag = "eh_func_begin";
4261         BeginNumber = SubprogramCount;
4262       } else {
4263         BeginTag = "label";
4264         BeginNumber = S.BeginLabel;
4265       }
4266
4267       EmitSectionOffset(BeginTag, "eh_func_begin", BeginNumber, SubprogramCount,
4268                         true, true);
4269       Asm->EOL("Region start");
4270
4271       if (!S.EndLabel) {
4272         EmitDifference("eh_func_end", SubprogramCount, BeginTag, BeginNumber,
4273                        true);
4274       } else {
4275         EmitDifference("label", S.EndLabel, BeginTag, BeginNumber, true);
4276       }
4277       Asm->EOL("Region length");
4278
4279       if (!S.PadLabel)
4280         Asm->EmitInt32(0);
4281       else
4282         EmitSectionOffset("label", "eh_func_begin", S.PadLabel, SubprogramCount,
4283                           true, true);
4284       Asm->EOL("Landing pad");
4285
4286       Asm->EmitULEB128Bytes(S.Action);
4287       Asm->EOL("Action");
4288     }
4289
4290     // Emit the actions.
4291     for (unsigned I = 0, N = Actions.size(); I != N; ++I) {
4292       ActionEntry &Action = Actions[I];
4293
4294       Asm->EmitSLEB128Bytes(Action.ValueForTypeID);
4295       Asm->EOL("TypeInfo index");
4296       Asm->EmitSLEB128Bytes(Action.NextAction);
4297       Asm->EOL("Next action");
4298     }
4299
4300     // Emit the type ids.
4301     for (unsigned M = TypeInfos.size(); M; --M) {
4302       GlobalVariable *GV = TypeInfos[M - 1];
4303
4304       PrintRelDirective();
4305
4306       if (GV) {
4307         std::string GLN;
4308         O << Asm->getGlobalLinkName(GV, GLN);
4309       } else {
4310         O << "0";
4311       }
4312
4313       Asm->EOL("TypeInfo");
4314     }
4315
4316     // Emit the filter typeids.
4317     for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) {
4318       unsigned TypeID = FilterIds[j];
4319       Asm->EmitULEB128Bytes(TypeID);
4320       Asm->EOL("Filter TypeInfo index");
4321     }
4322
4323     Asm->EmitAlignment(2, 0, 0, false);
4324   }
4325
4326 public:
4327   //===--------------------------------------------------------------------===//
4328   // Main entry points.
4329   //
4330   DwarfException(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
4331   : Dwarf(OS, A, T, "eh"), shouldEmitTable(false), shouldEmitMoves(false),
4332     shouldEmitTableModule(false), shouldEmitMovesModule(false),
4333     ExceptionTimer(0) {
4334     if (TimePassesIsEnabled)
4335       ExceptionTimer = new Timer("Dwarf Exception Writer",
4336                                  getDwarfTimerGroup());
4337   }
4338
4339   virtual ~DwarfException() {
4340     delete ExceptionTimer;
4341   }
4342
4343   /// SetModuleInfo - Set machine module information when it's known that pass
4344   /// manager has created it.  Set by the target AsmPrinter.
4345   void SetModuleInfo(MachineModuleInfo *mmi) {
4346     MMI = mmi;
4347   }
4348
4349   /// BeginModule - Emit all exception information that should come prior to the
4350   /// content.
4351   void BeginModule(Module *M) {
4352     this->M = M;
4353   }
4354
4355   /// EndModule - Emit all exception information that should come after the
4356   /// content.
4357   void EndModule() {
4358     if (TimePassesIsEnabled)
4359       ExceptionTimer->startTimer();
4360
4361     if (shouldEmitMovesModule || shouldEmitTableModule) {
4362       const std::vector<Function *> Personalities = MMI->getPersonalities();
4363       for (unsigned i = 0; i < Personalities.size(); ++i)
4364         EmitCommonEHFrame(Personalities[i], i);
4365
4366       for (std::vector<FunctionEHFrameInfo>::iterator I = EHFrames.begin(),
4367              E = EHFrames.end(); I != E; ++I)
4368         EmitEHFrame(*I);
4369     }
4370
4371     if (TimePassesIsEnabled)
4372       ExceptionTimer->stopTimer();
4373   }
4374
4375   /// BeginFunction - Gather pre-function exception information.  Assumes being
4376   /// emitted immediately after the function entry point.
4377   void BeginFunction(MachineFunction *MF) {
4378     if (TimePassesIsEnabled)
4379       ExceptionTimer->startTimer();
4380
4381     this->MF = MF;
4382     shouldEmitTable = shouldEmitMoves = false;
4383
4384     if (MMI && TAI->doesSupportExceptionHandling()) {
4385       // Map all labels and get rid of any dead landing pads.
4386       MMI->TidyLandingPads();
4387
4388       // If any landing pads survive, we need an EH table.
4389       if (MMI->getLandingPads().size())
4390         shouldEmitTable = true;
4391
4392       // See if we need frame move info.
4393       if (!MF->getFunction()->doesNotThrow() || UnwindTablesMandatory)
4394         shouldEmitMoves = true;
4395
4396       if (shouldEmitMoves || shouldEmitTable)
4397         // Assumes in correct section after the entry point.
4398         EmitLabel("eh_func_begin", ++SubprogramCount);
4399     }
4400
4401     shouldEmitTableModule |= shouldEmitTable;
4402     shouldEmitMovesModule |= shouldEmitMoves;
4403
4404     if (TimePassesIsEnabled)
4405       ExceptionTimer->stopTimer();
4406   }
4407
4408   /// EndFunction - Gather and emit post-function exception information.
4409   ///
4410   void EndFunction() {
4411     if (TimePassesIsEnabled)
4412       ExceptionTimer->startTimer();
4413
4414     if (shouldEmitMoves || shouldEmitTable) {
4415       EmitLabel("eh_func_end", SubprogramCount);
4416       EmitExceptionTable();
4417
4418       // Save EH frame information
4419       std::string Name;
4420       EHFrames.push_back(
4421         FunctionEHFrameInfo(getAsm()->getCurrentFunctionEHName(MF, Name),
4422                             SubprogramCount,
4423                             MMI->getPersonalityIndex(),
4424                             MF->getFrameInfo()->hasCalls(),
4425                             !MMI->getLandingPads().empty(),
4426                             MMI->getFrameMoves(),
4427                             MF->getFunction()));
4428     }
4429
4430     if (TimePassesIsEnabled)
4431       ExceptionTimer->stopTimer();
4432   }
4433 };
4434
4435 } // End of namespace llvm
4436
4437 //===----------------------------------------------------------------------===//
4438
4439 /// Emit - Print the abbreviation using the specified Dwarf writer.
4440 ///
4441 void DIEAbbrev::Emit(const DwarfDebug &DD) const {
4442   // Emit its Dwarf tag type.
4443   DD.getAsm()->EmitULEB128Bytes(Tag);
4444   DD.getAsm()->EOL(TagString(Tag));
4445
4446   // Emit whether it has children DIEs.
4447   DD.getAsm()->EmitULEB128Bytes(ChildrenFlag);
4448   DD.getAsm()->EOL(ChildrenString(ChildrenFlag));
4449
4450   // For each attribute description.
4451   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
4452     const DIEAbbrevData &AttrData = Data[i];
4453
4454     // Emit attribute type.
4455     DD.getAsm()->EmitULEB128Bytes(AttrData.getAttribute());
4456     DD.getAsm()->EOL(AttributeString(AttrData.getAttribute()));
4457
4458     // Emit form type.
4459     DD.getAsm()->EmitULEB128Bytes(AttrData.getForm());
4460     DD.getAsm()->EOL(FormEncodingString(AttrData.getForm()));
4461   }
4462
4463   // Mark end of abbreviation.
4464   DD.getAsm()->EmitULEB128Bytes(0); DD.getAsm()->EOL("EOM(1)");
4465   DD.getAsm()->EmitULEB128Bytes(0); DD.getAsm()->EOL("EOM(2)");
4466 }
4467
4468 #ifndef NDEBUG
4469 void DIEAbbrev::print(std::ostream &O) {
4470   O << "Abbreviation @"
4471     << std::hex << (intptr_t)this << std::dec
4472     << "  "
4473     << TagString(Tag)
4474     << " "
4475     << ChildrenString(ChildrenFlag)
4476     << "\n";
4477
4478   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
4479     O << "  "
4480       << AttributeString(Data[i].getAttribute())
4481       << "  "
4482       << FormEncodingString(Data[i].getForm())
4483       << "\n";
4484   }
4485 }
4486 void DIEAbbrev::dump() { print(cerr); }
4487 #endif
4488
4489 //===----------------------------------------------------------------------===//
4490
4491 #ifndef NDEBUG
4492 void DIEValue::dump() {
4493   print(cerr);
4494 }
4495 #endif
4496
4497 //===----------------------------------------------------------------------===//
4498
4499 /// EmitValue - Emit integer of appropriate size.
4500 ///
4501 void DIEInteger::EmitValue(DwarfDebug &DD, unsigned Form) {
4502   switch (Form) {
4503   case DW_FORM_flag:  // Fall thru
4504   case DW_FORM_ref1:  // Fall thru
4505   case DW_FORM_data1: DD.getAsm()->EmitInt8(Integer);         break;
4506   case DW_FORM_ref2:  // Fall thru
4507   case DW_FORM_data2: DD.getAsm()->EmitInt16(Integer);        break;
4508   case DW_FORM_ref4:  // Fall thru
4509   case DW_FORM_data4: DD.getAsm()->EmitInt32(Integer);        break;
4510   case DW_FORM_ref8:  // Fall thru
4511   case DW_FORM_data8: DD.getAsm()->EmitInt64(Integer);        break;
4512   case DW_FORM_udata: DD.getAsm()->EmitULEB128Bytes(Integer); break;
4513   case DW_FORM_sdata: DD.getAsm()->EmitSLEB128Bytes(Integer); break;
4514   default: assert(0 && "DIE Value form not supported yet");   break;
4515   }
4516 }
4517
4518 /// SizeOf - Determine size of integer value in bytes.
4519 ///
4520 unsigned DIEInteger::SizeOf(const DwarfDebug &DD, unsigned Form) const {
4521   switch (Form) {
4522   case DW_FORM_flag:  // Fall thru
4523   case DW_FORM_ref1:  // Fall thru
4524   case DW_FORM_data1: return sizeof(int8_t);
4525   case DW_FORM_ref2:  // Fall thru
4526   case DW_FORM_data2: return sizeof(int16_t);
4527   case DW_FORM_ref4:  // Fall thru
4528   case DW_FORM_data4: return sizeof(int32_t);
4529   case DW_FORM_ref8:  // Fall thru
4530   case DW_FORM_data8: return sizeof(int64_t);
4531   case DW_FORM_udata: return TargetAsmInfo::getULEB128Size(Integer);
4532   case DW_FORM_sdata: return TargetAsmInfo::getSLEB128Size(Integer);
4533   default: assert(0 && "DIE Value form not supported yet"); break;
4534   }
4535   return 0;
4536 }
4537
4538 //===----------------------------------------------------------------------===//
4539
4540 /// EmitValue - Emit string value.
4541 ///
4542 void DIEString::EmitValue(DwarfDebug &DD, unsigned Form) {
4543   DD.getAsm()->EmitString(Str);
4544 }
4545
4546 //===----------------------------------------------------------------------===//
4547
4548 /// EmitValue - Emit label value.
4549 ///
4550 void DIEDwarfLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
4551   bool IsSmall = Form == DW_FORM_data4;
4552   DD.EmitReference(Label, false, IsSmall);
4553 }
4554
4555 /// SizeOf - Determine size of label value in bytes.
4556 ///
4557 unsigned DIEDwarfLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const {
4558   if (Form == DW_FORM_data4) return 4;
4559   return DD.getTargetData()->getPointerSize();
4560 }
4561
4562 //===----------------------------------------------------------------------===//
4563
4564 /// EmitValue - Emit label value.
4565 ///
4566 void DIEObjectLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
4567   bool IsSmall = Form == DW_FORM_data4;
4568   DD.EmitReference(Label, false, IsSmall);
4569 }
4570
4571 /// SizeOf - Determine size of label value in bytes.
4572 ///
4573 unsigned DIEObjectLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const {
4574   if (Form == DW_FORM_data4) return 4;
4575   return DD.getTargetData()->getPointerSize();
4576 }
4577
4578 //===----------------------------------------------------------------------===//
4579
4580 /// EmitValue - Emit delta value.
4581 ///
4582 void DIESectionOffset::EmitValue(DwarfDebug &DD, unsigned Form) {
4583   bool IsSmall = Form == DW_FORM_data4;
4584   DD.EmitSectionOffset(Label.Tag, Section.Tag,
4585                        Label.Number, Section.Number, IsSmall, IsEH, UseSet);
4586 }
4587
4588 /// SizeOf - Determine size of delta value in bytes.
4589 ///
4590 unsigned DIESectionOffset::SizeOf(const DwarfDebug &DD, unsigned Form) const {
4591   if (Form == DW_FORM_data4) return 4;
4592   return DD.getTargetData()->getPointerSize();
4593 }
4594
4595 //===----------------------------------------------------------------------===//
4596
4597 /// EmitValue - Emit delta value.
4598 ///
4599 void DIEDelta::EmitValue(DwarfDebug &DD, unsigned Form) {
4600   bool IsSmall = Form == DW_FORM_data4;
4601   DD.EmitDifference(LabelHi, LabelLo, IsSmall);
4602 }
4603
4604 /// SizeOf - Determine size of delta value in bytes.
4605 ///
4606 unsigned DIEDelta::SizeOf(const DwarfDebug &DD, unsigned Form) const {
4607   if (Form == DW_FORM_data4) return 4;
4608   return DD.getTargetData()->getPointerSize();
4609 }
4610
4611 //===----------------------------------------------------------------------===//
4612
4613 /// EmitValue - Emit debug information entry offset.
4614 ///
4615 void DIEntry::EmitValue(DwarfDebug &DD, unsigned Form) {
4616   DD.getAsm()->EmitInt32(Entry->getOffset());
4617 }
4618
4619 //===----------------------------------------------------------------------===//
4620
4621 /// ComputeSize - calculate the size of the block.
4622 ///
4623 unsigned DIEBlock::ComputeSize(DwarfDebug &DD) {
4624   if (!Size) {
4625     const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
4626
4627     for (unsigned i = 0, N = Values.size(); i < N; ++i) {
4628       Size += Values[i]->SizeOf(DD, AbbrevData[i].getForm());
4629     }
4630   }
4631   return Size;
4632 }
4633
4634 /// EmitValue - Emit block data.
4635 ///
4636 void DIEBlock::EmitValue(DwarfDebug &DD, unsigned Form) {
4637   switch (Form) {
4638   case DW_FORM_block1: DD.getAsm()->EmitInt8(Size);         break;
4639   case DW_FORM_block2: DD.getAsm()->EmitInt16(Size);        break;
4640   case DW_FORM_block4: DD.getAsm()->EmitInt32(Size);        break;
4641   case DW_FORM_block:  DD.getAsm()->EmitULEB128Bytes(Size); break;
4642   default: assert(0 && "Improper form for block");          break;
4643   }
4644
4645   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
4646
4647   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
4648     DD.getAsm()->EOL();
4649     Values[i]->EmitValue(DD, AbbrevData[i].getForm());
4650   }
4651 }
4652
4653 /// SizeOf - Determine size of block data in bytes.
4654 ///
4655 unsigned DIEBlock::SizeOf(const DwarfDebug &DD, unsigned Form) const {
4656   switch (Form) {
4657   case DW_FORM_block1: return Size + sizeof(int8_t);
4658   case DW_FORM_block2: return Size + sizeof(int16_t);
4659   case DW_FORM_block4: return Size + sizeof(int32_t);
4660   case DW_FORM_block: return Size + TargetAsmInfo::getULEB128Size(Size);
4661   default: assert(0 && "Improper form for block"); break;
4662   }
4663   return 0;
4664 }
4665
4666 //===----------------------------------------------------------------------===//
4667 /// DIE Implementation
4668
4669 DIE::~DIE() {
4670   for (unsigned i = 0, N = Children.size(); i < N; ++i)
4671     delete Children[i];
4672 }
4673
4674 /// AddSiblingOffset - Add a sibling offset field to the front of the DIE.
4675 ///
4676 void DIE::AddSiblingOffset() {
4677   DIEInteger *DI = new DIEInteger(0);
4678   Values.insert(Values.begin(), DI);
4679   Abbrev.AddFirstAttribute(DW_AT_sibling, DW_FORM_ref4);
4680 }
4681
4682 /// Profile - Used to gather unique data for the value folding set.
4683 ///
4684 void DIE::Profile(FoldingSetNodeID &ID) {
4685   Abbrev.Profile(ID);
4686
4687   for (unsigned i = 0, N = Children.size(); i < N; ++i)
4688     ID.AddPointer(Children[i]);
4689
4690   for (unsigned j = 0, M = Values.size(); j < M; ++j)
4691     ID.AddPointer(Values[j]);
4692 }
4693
4694 #ifndef NDEBUG
4695 void DIE::print(std::ostream &O, unsigned IncIndent) {
4696   static unsigned IndentCount = 0;
4697   IndentCount += IncIndent;
4698   const std::string Indent(IndentCount, ' ');
4699   bool isBlock = Abbrev.getTag() == 0;
4700
4701   if (!isBlock) {
4702     O << Indent
4703       << "Die: "
4704       << "0x" << std::hex << (intptr_t)this << std::dec
4705       << ", Offset: " << Offset
4706       << ", Size: " << Size
4707       << "\n";
4708
4709     O << Indent
4710       << TagString(Abbrev.getTag())
4711       << " "
4712       << ChildrenString(Abbrev.getChildrenFlag());
4713   } else {
4714     O << "Size: " << Size;
4715   }
4716   O << "\n";
4717
4718   const SmallVector<DIEAbbrevData, 8> &Data = Abbrev.getData();
4719
4720   IndentCount += 2;
4721   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
4722     O << Indent;
4723
4724     if (!isBlock)
4725       O << AttributeString(Data[i].getAttribute());
4726     else
4727       O << "Blk[" << i << "]";
4728
4729     O <<  "  "
4730       << FormEncodingString(Data[i].getForm())
4731       << " ";
4732     Values[i]->print(O);
4733     O << "\n";
4734   }
4735   IndentCount -= 2;
4736
4737   for (unsigned j = 0, M = Children.size(); j < M; ++j) {
4738     Children[j]->print(O, 4);
4739   }
4740
4741   if (!isBlock) O << "\n";
4742   IndentCount -= IncIndent;
4743 }
4744
4745 void DIE::dump() {
4746   print(cerr);
4747 }
4748 #endif
4749
4750 //===----------------------------------------------------------------------===//
4751 /// DwarfWriter Implementation
4752 ///
4753
4754 DwarfWriter::DwarfWriter()
4755   : ImmutablePass(&ID), DD(0), DE(0) {}
4756
4757 DwarfWriter::~DwarfWriter() {
4758   delete DE;
4759   delete DD;
4760 }
4761
4762 /// BeginModule - Emit all Dwarf sections that should come prior to the
4763 /// content.
4764 void DwarfWriter::BeginModule(Module *M,
4765                               MachineModuleInfo *MMI,
4766                               raw_ostream &OS, AsmPrinter *A,
4767                               const TargetAsmInfo *T) {
4768   DE = new DwarfException(OS, A, T);
4769   DD = new DwarfDebug(OS, A, T);
4770   DE->BeginModule(M);
4771   DD->BeginModule(M);
4772   DD->SetDebugInfo(MMI);
4773   DE->SetModuleInfo(MMI);
4774 }
4775
4776 /// EndModule - Emit all Dwarf sections that should come after the content.
4777 ///
4778 void DwarfWriter::EndModule() {
4779   DE->EndModule();
4780   DD->EndModule();
4781 }
4782
4783 /// BeginFunction - Gather pre-function debug information.  Assumes being
4784 /// emitted immediately after the function entry point.
4785 void DwarfWriter::BeginFunction(MachineFunction *MF) {
4786   DE->BeginFunction(MF);
4787   DD->BeginFunction(MF);
4788 }
4789
4790 /// EndFunction - Gather and emit post-function debug information.
4791 ///
4792 void DwarfWriter::EndFunction(MachineFunction *MF) {
4793   DD->EndFunction(MF);
4794   DE->EndFunction();
4795
4796   if (MachineModuleInfo *MMI = DD->getMMI() ? DD->getMMI() : DE->getMMI())
4797     // Clear function debug information.
4798     MMI->EndFunction();
4799 }
4800
4801 /// RecordSourceLine - Records location information and associates it with a
4802 /// label. Returns a unique label ID used to generate a label and provide
4803 /// correspondence to the source line list.
4804 unsigned DwarfWriter::RecordSourceLine(unsigned Line, unsigned Col,
4805                                        DICompileUnit CU) {
4806   return DD->RecordSourceLine(Line, Col, CU);
4807 }
4808
4809 /// RecordRegionStart - Indicate the start of a region.
4810 unsigned DwarfWriter::RecordRegionStart(GlobalVariable *V) {
4811   return DD->RecordRegionStart(V);
4812 }
4813
4814 /// RecordRegionEnd - Indicate the end of a region.
4815 unsigned DwarfWriter::RecordRegionEnd(GlobalVariable *V, DISubprogram &SP) {
4816   return DD->RecordRegionEnd(V, SP);
4817 }
4818
4819 /// getRecordSourceLineCount - Count source lines.
4820 unsigned DwarfWriter::getRecordSourceLineCount() {
4821   return DD->getRecordSourceLineCount();
4822 }
4823
4824 /// RecordVariable - Indicate the declaration of  a local variable.
4825 ///
4826 void DwarfWriter::RecordVariable(GlobalVariable *GV, unsigned FrameIndex,
4827                                  const MachineInstr *MI) {
4828   DD->RecordVariable(GV, FrameIndex, MI);
4829 }
4830
4831 /// ShouldEmitDwarfDebug - Returns true if Dwarf debugging declarations should
4832 /// be emitted.
4833 bool DwarfWriter::ShouldEmitDwarfDebug() const {
4834   return DD && DD->ShouldEmitDwarfDebug();
4835 }
4836
4837 //// RecordInlinedFnStart - Global variable GV is inlined at the location marked
4838 //// by LabelID label.
4839 unsigned DwarfWriter::RecordInlinedFnStart(DISubprogram SP, DICompileUnit CU,
4840                                            unsigned Line, unsigned Col) {
4841   return DD->RecordInlinedFnStart(SP, CU, Line, Col);
4842 }
4843
4844 /// RecordInlinedFnEnd - Indicate the end of inlined subroutine.
4845 unsigned DwarfWriter::RecordInlinedFnEnd(DISubprogram SP) {
4846   return DD->RecordInlinedFnEnd(SP);
4847 }
4848
4849 /// RecordVariableScope - Record scope for the variable declared by
4850 /// DeclareMI. DeclareMI must describe TargetInstrInfo::DECLARE.
4851 void DwarfWriter::RecordVariableScope(DIVariable &DV,
4852                                       const MachineInstr *DeclareMI) {
4853   DD->RecordVariableScope(DV, DeclareMI);
4854 }