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