lib/CodeGen/DwarfWriter.cpp

   1 //===-- llvm/CodeGen/DwarfWriter.cpp - Dwarf Framework ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by James M. Laskey and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for writing dwarf debug info into asm files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/CodeGen/DwarfWriter.h"
  15
  16 #include "llvm/ADT/StringExtras.h"
  17 #include "llvm/Module.h"
  18 #include "llvm/Type.h"
  19 #include "llvm/CodeGen/AsmPrinter.h"
  20 #include "llvm/CodeGen/MachineDebugInfo.h"
  21 #include "llvm/Support/Dwarf.h"
  22 #include "llvm/Support/CommandLine.h"
  23 #include "llvm/Support/Mangler.h"
  24 #include "llvm/Target/TargetMachine.h"
  25
  26 #include <iostream>
  27
  28 using namespace llvm;
  29 using namespace llvm::dwarf;
  30
  31 static cl::opt<bool>
  32 DwarfVerbose("dwarf-verbose", cl::Hidden,
  33                                 cl::desc("Add comments to Dwarf directives."));
  34
  35 namespace llvm {
  36
  37 //===----------------------------------------------------------------------===//
  38 // Forward declarations.
  39 //
  40 class CompileUnit;
  41 class DIE;
  42
  43 //===----------------------------------------------------------------------===//
  44 class CompileUnit {
  45 private:
  46   CompileUnitDesc *Desc;                // Compile unit debug descriptor.
  47   unsigned ID;                          // File ID for source.
  48   DIE *Die;                             // Compile unit die.
  49   std::map<std::string, DIE *> Globals; // A map of globally visible named
  50                                         // entities for this unit.
  51
  52 public:
  53   CompileUnit(CompileUnitDesc *CUD, unsigned I, DIE *D)
  54   : Desc(CUD)
  55   , ID(I)
  56   , Die(D)
  57   , Globals()
  58   {}
  59
  60   ~CompileUnit();
  61
  62   // Accessors.
  63   CompileUnitDesc *getDesc() const { return Desc; }
  64   unsigned getID()           const { return ID; }
  65   DIE* getDie()              const { return Die; }
  66   std::map<std::string, DIE *> &getGlobals() { return Globals; }
  67
  68   /// hasContent - Return true if this compile unit has something to write out.
  69   ///
  70   bool hasContent() const;
  71
  72   /// AddGlobal - Add a new global entity to the compile unit.
  73   ///
  74   void AddGlobal(const std::string &Name, DIE *Die);
  75
  76 };
  77
  78 //===----------------------------------------------------------------------===//
  79 // DIEAbbrevData - Dwarf abbreviation data, describes the one attribute of a
  80 // Dwarf abbreviation.
  81 class DIEAbbrevData {
  82 private:
  83   unsigned Attribute;                 // Dwarf attribute code.
  84   unsigned Form;                      // Dwarf form code.
  85
  86 public:
  87   DIEAbbrevData(unsigned A, unsigned F)
  88   : Attribute(A)
  89   , Form(F)
  90   {}
  91
  92   // Accessors.
  93   unsigned getAttribute() const { return Attribute; }
  94   unsigned getForm()      const { return Form; }
  95
  96   /// operator== - Used by DIEAbbrev to locate entry.
  97   ///
  98   bool operator==(const DIEAbbrevData &DAD) const {
  99     return Attribute == DAD.Attribute && Form == DAD.Form;
 100   }
 101
 102   /// operator!= - Used by DIEAbbrev to locate entry.
 103   ///
 104   bool operator!=(const DIEAbbrevData &DAD) const {
 105     return Attribute != DAD.Attribute || Form != DAD.Form;
 106   }
 107
 108   /// operator< - Used by DIEAbbrev to locate entry.
 109   ///
 110   bool operator<(const DIEAbbrevData &DAD) const {
 111     return Attribute < DAD.Attribute ||
 112           (Attribute == DAD.Attribute && Form < DAD.Form);
 113   }
 114 };
 115
 116 //===----------------------------------------------------------------------===//
 117 // DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
 118 // information object.
 119 class DIEAbbrev {
 120 private:
 121   unsigned Tag;                       // Dwarf tag code.
 122   unsigned ChildrenFlag;              // Dwarf children flag.
 123   std::vector<DIEAbbrevData> Data;    // Raw data bytes for abbreviation.
 124
 125 public:
 126
 127   DIEAbbrev(unsigned T, unsigned C)
 128   : Tag(T)
 129   , ChildrenFlag(C)
 130   , Data()
 131   {}
 132   ~DIEAbbrev() {}
 133
 134   // Accessors.
 135   unsigned getTag()                           const { return Tag; }
 136   unsigned getChildrenFlag()                  const { return ChildrenFlag; }
 137   const std::vector<DIEAbbrevData> &getData() const { return Data; }
 138   void setChildrenFlag(unsigned CF)                 { ChildrenFlag = CF; }
 139
 140   /// operator== - Used by UniqueVector to locate entry.
 141   ///
 142   bool operator==(const DIEAbbrev &DA) const;
 143
 144   /// operator< - Used by UniqueVector to locate entry.
 145   ///
 146   bool operator<(const DIEAbbrev &DA) const;
 147
 148   /// AddAttribute - Adds another set of attribute information to the
 149   /// abbreviation.
 150   void AddAttribute(unsigned Attribute, unsigned Form) {
 151     Data.push_back(DIEAbbrevData(Attribute, Form));
 152   }
 153
 154   /// Emit - Print the abbreviation using the specified Dwarf writer.
 155   ///
 156   void Emit(const DwarfWriter &DW) const;
 157
 158 #ifndef NDEBUG
 159   void print(std::ostream &O);
 160   void dump();
 161 #endif
 162 };
 163
 164 //===----------------------------------------------------------------------===//
 165 // DIEValue - A debug information entry value.
 166 //
 167 class DIEValue {
 168 public:
 169   enum {
 170     isInteger,
 171     isString,
 172     isLabel,
 173     isAsIsLabel,
 174     isDelta,
 175     isEntry
 176   };
 177
 178   unsigned Type;                      // Type of the value
 179
 180   DIEValue(unsigned T) : Type(T) {}
 181   virtual ~DIEValue() {}
 182
 183   // Implement isa/cast/dyncast.
 184   static bool classof(const DIEValue *) { return true; }
 185
 186   /// EmitValue - Emit value via the Dwarf writer.
 187   ///
 188   virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const = 0;
 189
 190   /// SizeOf - Return the size of a value in bytes.
 191   ///
 192   virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const = 0;
 193 };
 194
 195 //===----------------------------------------------------------------------===//
 196 // DWInteger - An integer value DIE.
 197 //
 198 class DIEInteger : public DIEValue {
 199 private:
 200   uint64_t Integer;
 201
 202 public:
 203   DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
 204
 205   // Implement isa/cast/dyncast.
 206   static bool classof(const DIEInteger *) { return true; }
 207   static bool classof(const DIEValue *I)  { return I->Type == isInteger; }
 208
 209   /// EmitValue - Emit integer of appropriate size.
 210   ///
 211   virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
 212
 213   /// SizeOf - Determine size of integer value in bytes.
 214   ///
 215   virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
 216 };
 217
 218 //===----------------------------------------------------------------------===//
 219 // DIEString - A string value DIE.
 220 //
 221 struct DIEString : public DIEValue {
 222   const std::string String;
 223
 224   DIEString(const std::string &S) : DIEValue(isString), String(S) {}
 225
 226   // Implement isa/cast/dyncast.
 227   static bool classof(const DIEString *) { return true; }
 228   static bool classof(const DIEValue *S) { return S->Type == isString; }
 229
 230   /// EmitValue - Emit string value.
 231   ///
 232   virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
 233
 234   /// SizeOf - Determine size of string value in bytes.
 235   ///
 236   virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
 237 };
 238
 239 //===----------------------------------------------------------------------===//
 240 // DIEDwarfLabel - A Dwarf internal label expression DIE.
 241 //
 242 struct DIEDwarfLabel : public DIEValue {
 243   const DWLabel Label;
 244
 245   DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {}
 246
 247   // Implement isa/cast/dyncast.
 248   static bool classof(const DIEDwarfLabel *)  { return true; }
 249   static bool classof(const DIEValue *L) { return L->Type == isLabel; }
 250
 251   /// EmitValue - Emit label value.
 252   ///
 253   virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
 254
 255   /// SizeOf - Determine size of label value in bytes.
 256   ///
 257   virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
 258 };
 259
 260
 261 //===----------------------------------------------------------------------===//
 262 // DIEObjectLabel - A label to an object in code or data.
 263 //
 264 struct DIEObjectLabel : public DIEValue {
 265   const std::string Label;
 266
 267   DIEObjectLabel(const std::string &L) : DIEValue(isAsIsLabel), Label(L) {}
 268
 269   // Implement isa/cast/dyncast.
 270   static bool classof(const DIEObjectLabel *) { return true; }
 271   static bool classof(const DIEValue *L)    { return L->Type == isAsIsLabel; }
 272
 273   /// EmitValue - Emit label value.
 274   ///
 275   virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
 276
 277   /// SizeOf - Determine size of label value in bytes.
 278   ///
 279   virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
 280 };
 281
 282 //===----------------------------------------------------------------------===//
 283 // DIEDelta - A simple label difference DIE.
 284 //
 285 struct DIEDelta : public DIEValue {
 286   const DWLabel LabelHi;
 287   const DWLabel LabelLo;
 288
 289   DIEDelta(const DWLabel &Hi, const DWLabel &Lo)
 290   : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
 291
 292   // Implement isa/cast/dyncast.
 293   static bool classof(const DIEDelta *)  { return true; }
 294   static bool classof(const DIEValue *D) { return D->Type == isDelta; }
 295
 296   /// EmitValue - Emit delta value.
 297   ///
 298   virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
 299
 300   /// SizeOf - Determine size of delta value in bytes.
 301   ///
 302   virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
 303 };
 304
 305 //===----------------------------------------------------------------------===//
 306 // DIEntry - A pointer to a debug information entry.
 307 //
 308 struct DIEntry : public DIEValue {
 309   DIE *Entry;
 310
 311   DIEntry(DIE *E) : DIEValue(isEntry), Entry(E) {}
 312
 313   // Implement isa/cast/dyncast.
 314   static bool classof(const DIEntry *)   { return true; }
 315   static bool classof(const DIEValue *E) { return E->Type == isEntry; }
 316
 317   /// EmitValue - Emit delta value.
 318   ///
 319   virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
 320
 321   /// SizeOf - Determine size of delta value in bytes.
 322   ///
 323   virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
 324 };
 325
 326 //===----------------------------------------------------------------------===//
 327 // DIE - A structured debug information entry.  Has an abbreviation which
 328 // describes it's organization.
 329 class DIE {
 330 private:
 331   DIEAbbrev *Abbrev;                    // Temporary buffer for abbreviation.
 332   unsigned AbbrevID;                    // Decribing abbreviation ID.
 333   unsigned Offset;                      // Offset in debug info section.
 334   unsigned Size;                        // Size of instance + children.
 335   std::vector<DIE *> Children;          // Children DIEs.
 336   std::vector<DIEValue *> Values;       // Attributes values.
 337
 338 public:
 339   DIE(unsigned Tag);
 340   ~DIE();
 341
 342   // Accessors.
 343   unsigned   getAbbrevID()                   const { return AbbrevID; }
 344   unsigned   getOffset()                     const { return Offset; }
 345   unsigned   getSize()                       const { return Size; }
 346   const std::vector<DIE *> &getChildren()    const { return Children; }
 347   const std::vector<DIEValue *> &getValues() const { return Values; }
 348   void setOffset(unsigned O)                 { Offset = O; }
 349   void setSize(unsigned S)                   { Size = S; }
 350
 351   /// SiblingOffset - Return the offset of the debug information entry's
 352   /// sibling.
 353   unsigned SiblingOffset() const { return Offset + Size; }
 354
 355   /// AddUInt - Add an unsigned integer attribute data and value.
 356   ///
 357   void AddUInt(unsigned Attribute, unsigned Form, uint64_t Integer);
 358
 359   /// AddSInt - Add an signed integer attribute data and value.
 360   ///
 361   void AddSInt(unsigned Attribute, unsigned Form, int64_t Integer);
 362
 363   /// AddString - Add a std::string attribute data and value.
 364   ///
 365   void AddString(unsigned Attribute, unsigned Form,
 366                  const std::string &String);
 367
 368   /// AddLabel - Add a Dwarf label attribute data and value.
 369   ///
 370   void AddLabel(unsigned Attribute, unsigned Form, const DWLabel &Label);
 371
 372   /// AddObjectLabel - Add a non-Dwarf label attribute data and value.
 373   ///
 374   void AddObjectLabel(unsigned Attribute, unsigned Form,
 375                       const std::string &Label);
 376
 377   /// AddDelta - Add a label delta attribute data and value.
 378   ///
 379   void AddDelta(unsigned Attribute, unsigned Form,
 380                 const DWLabel &Hi, const DWLabel &Lo);
 381
 382   ///  AddDIEntry - Add a DIE attribute data and value.
 383   ///
 384   void AddDIEntry(unsigned Attribute, unsigned Form, DIE *Entry);
 385
 386   /// Complete - Indicate that all attributes have been added and
 387   /// ready to get an abbreviation ID.
 388   ///
 389   void Complete(DwarfWriter &DW);
 390
 391   /// AddChild - Add a child to the DIE.
 392   void AddChild(DIE *Child);
 393 };
 394
 395 } // End of namespace llvm
 396
 397 //===----------------------------------------------------------------------===//
 398
 399 CompileUnit::~CompileUnit() {
 400   delete Die;
 401 }
 402
 403 /// hasContent - Return true if this compile unit has something to write out.
 404 ///
 405 bool CompileUnit::hasContent() const {
 406   return !Die->getChildren().empty();
 407 }
 408
 409 /// AddGlobal - Add a new global entity to the compile unit.
 410 ///
 411 void CompileUnit::AddGlobal(const std::string &Name, DIE *Die) {
 412   Globals[Name] = Die;
 413 }
 414
 415 //===----------------------------------------------------------------------===//
 416
 417 /// operator== - Used by UniqueVector to locate entry.
 418 ///
 419 bool DIEAbbrev::operator==(const DIEAbbrev &DA) const {
 420   if (Tag != DA.Tag) return false;
 421   if (ChildrenFlag != DA.ChildrenFlag) return false;
 422   if (Data.size() != DA.Data.size()) return false;
 423
 424   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
 425     if (Data[i] != DA.Data[i]) return false;
 426   }
 427
 428   return true;
 429 }
 430
 431 /// operator< - Used by UniqueVector to locate entry.
 432 ///
 433 bool DIEAbbrev::operator<(const DIEAbbrev &DA) const {
 434   if (Tag != DA.Tag) return Tag < DA.Tag;
 435   if (ChildrenFlag != DA.ChildrenFlag) return ChildrenFlag < DA.ChildrenFlag;
 436   if (Data.size() != DA.Data.size()) return Data.size() < DA.Data.size();
 437
 438   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
 439     if (Data[i] != DA.Data[i]) return Data[i] < DA.Data[i];
 440   }
 441
 442   return false;
 443 }
 444
 445 /// Emit - Print the abbreviation using the specified Dwarf writer.
 446 ///
 447 void DIEAbbrev::Emit(const DwarfWriter &DW) const {
 448   // Emit its Dwarf tag type.
 449   DW.EmitULEB128Bytes(Tag);
 450   DW.EOL(TagString(Tag));
 451
 452   // Emit whether it has children DIEs.
 453   DW.EmitULEB128Bytes(ChildrenFlag);
 454   DW.EOL(ChildrenString(ChildrenFlag));
 455
 456   // For each attribute description.
 457   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
 458     const DIEAbbrevData &AttrData = Data[i];
 459
 460     // Emit attribute type.
 461     DW.EmitULEB128Bytes(AttrData.getAttribute());
 462     DW.EOL(AttributeString(AttrData.getAttribute()));
 463
 464     // Emit form type.
 465     DW.EmitULEB128Bytes(AttrData.getForm());
 466     DW.EOL(FormEncodingString(AttrData.getForm()));
 467   }
 468
 469   // Mark end of abbreviation.
 470   DW.EmitULEB128Bytes(0); DW.EOL("EOM(1)");
 471   DW.EmitULEB128Bytes(0); DW.EOL("EOM(2)");
 472 }
 473
 474 #ifndef NDEBUG
 475   void DIEAbbrev::print(std::ostream &O) {
 476     O << "Abbreviation @"
 477       << std::hex << (intptr_t)this << std::dec
 478       << "  "
 479       << TagString(Tag)
 480       << " "
 481       << ChildrenString(ChildrenFlag)
 482       << "\n";
 483
 484     for (unsigned i = 0, N = Data.size(); i < N; ++i) {
 485       O << "  "
 486         << AttributeString(Data[i].getAttribute())
 487         << "  "
 488         << FormEncodingString(Data[i].getForm())
 489         << "\n";
 490     }
 491   }
 492   void DIEAbbrev::dump() { print(std::cerr); }
 493 #endif
 494
 495 //===----------------------------------------------------------------------===//
 496
 497 /// EmitValue - Emit integer of appropriate size.
 498 ///
 499 void DIEInteger::EmitValue(const DwarfWriter &DW, unsigned Form) const {
 500   switch (Form) {
 501   case DW_FORM_flag:  // Fall thru
 502   case DW_FORM_data1: DW.EmitInt8(Integer);         break;
 503   case DW_FORM_data2: DW.EmitInt16(Integer);        break;
 504   case DW_FORM_data4: DW.EmitInt32(Integer);        break;
 505   case DW_FORM_data8: DW.EmitInt64(Integer);        break;
 506   case DW_FORM_udata: DW.EmitULEB128Bytes(Integer); break;
 507   case DW_FORM_sdata: DW.EmitSLEB128Bytes(Integer); break;
 508   default: assert(0 && "DIE Value form not supported yet"); break;
 509   }
 510 }
 511
 512 /// SizeOf - Determine size of integer value in bytes.
 513 ///
 514 unsigned DIEInteger::SizeOf(const DwarfWriter &DW, unsigned Form) const {
 515   switch (Form) {
 516   case DW_FORM_flag:  // Fall thru
 517   case DW_FORM_data1: return sizeof(int8_t);
 518   case DW_FORM_data2: return sizeof(int16_t);
 519   case DW_FORM_data4: return sizeof(int32_t);
 520   case DW_FORM_data8: return sizeof(int64_t);
 521   case DW_FORM_udata: return DW.SizeULEB128(Integer);
 522   case DW_FORM_sdata: return DW.SizeSLEB128(Integer);
 523   default: assert(0 && "DIE Value form not supported yet"); break;
 524   }
 525   return 0;
 526 }
 527
 528 //===----------------------------------------------------------------------===//
 529
 530 /// EmitValue - Emit string value.
 531 ///
 532 void DIEString::EmitValue(const DwarfWriter &DW, unsigned Form) const {
 533   DW.EmitString(String);
 534 }
 535
 536 /// SizeOf - Determine size of string value in bytes.
 537 ///
 538 unsigned DIEString::SizeOf(const DwarfWriter &DW, unsigned Form) const {
 539   return String.size() + sizeof(char); // sizeof('\0');
 540 }
 541
 542 //===----------------------------------------------------------------------===//
 543
 544 /// EmitValue - Emit label value.
 545 ///
 546 void DIEDwarfLabel::EmitValue(const DwarfWriter &DW, unsigned Form) const {
 547   DW.EmitReference(Label);
 548 }
 549
 550 /// SizeOf - Determine size of label value in bytes.
 551 ///
 552 unsigned DIEDwarfLabel::SizeOf(const DwarfWriter &DW, unsigned Form) const {
 553   return DW.getAddressSize();
 554 }
 555
 556 //===----------------------------------------------------------------------===//
 557
 558 /// EmitValue - Emit label value.
 559 ///
 560 void DIEObjectLabel::EmitValue(const DwarfWriter &DW, unsigned Form) const {
 561   DW.EmitInt8(sizeof(int8_t) + DW.getAddressSize());
 562   DW.EOL("DW_FORM_block1 length");
 563
 564   DW.EmitInt8(DW_OP_addr);
 565   DW.EOL("DW_OP_addr");
 566
 567   DW.EmitReference(Label);
 568 }
 569
 570 /// SizeOf - Determine size of label value in bytes.
 571 ///
 572 unsigned DIEObjectLabel::SizeOf(const DwarfWriter &DW, unsigned Form) const {
 573   return sizeof(int8_t) + sizeof(int8_t) + DW.getAddressSize();
 574 }
 575
 576 //===----------------------------------------------------------------------===//
 577
 578 /// EmitValue - Emit delta value.
 579 ///
 580 void DIEDelta::EmitValue(const DwarfWriter &DW, unsigned Form) const {
 581   DW.EmitDifference(LabelHi, LabelLo);
 582 }
 583
 584 /// SizeOf - Determine size of delta value in bytes.
 585 ///
 586 unsigned DIEDelta::SizeOf(const DwarfWriter &DW, unsigned Form) const {
 587   return DW.getAddressSize();
 588 }
 589
 590 //===----------------------------------------------------------------------===//
 591 /// EmitValue - Emit extry offset.
 592 ///
 593 void DIEntry::EmitValue(const DwarfWriter &DW, unsigned Form) const {
 594   DW.EmitInt32(Entry->getOffset());
 595 }
 596
 597 /// SizeOf - Determine size of label value in bytes.
 598 ///
 599 unsigned DIEntry::SizeOf(const DwarfWriter &DW, unsigned Form) const {
 600   return sizeof(int32_t);
 601 }
 602
 603 //===----------------------------------------------------------------------===//
 604
 605 DIE::DIE(unsigned Tag)
 606 : Abbrev(new DIEAbbrev(Tag, DW_CHILDREN_no))
 607 , AbbrevID(0)
 608 , Offset(0)
 609 , Size(0)
 610 , Children()
 611 , Values()
 612 {}
 613
 614 DIE::~DIE() {
 615   if (Abbrev) delete Abbrev;
 616
 617   for (unsigned i = 0, N = Children.size(); i < N; ++i) {
 618     delete Children[i];
 619   }
 620
 621   for (unsigned j = 0, M = Values.size(); j < M; ++j) {
 622     delete Values[j];
 623   }
 624 }
 625
 626 /// AddUInt - Add an unsigned integer attribute data and value.
 627 ///
 628 void DIE::AddUInt(unsigned Attribute, unsigned Form, uint64_t Integer) {
 629   if (Form == 0) {
 630       if ((unsigned char)Integer == Integer)       Form = DW_FORM_data1;
 631       else if ((unsigned short)Integer == Integer) Form = DW_FORM_data2;
 632       else if ((unsigned int)Integer == Integer)   Form = DW_FORM_data4;
 633       else                                         Form = DW_FORM_data8;
 634   }
 635   Abbrev->AddAttribute(Attribute, Form);
 636   Values.push_back(new DIEInteger(Integer));
 637 }
 638
 639 /// AddSInt - Add an signed integer attribute data and value.
 640 ///
 641 void DIE::AddSInt(unsigned Attribute, unsigned Form, int64_t Integer) {
 642   if (Form == 0) {
 643       if ((char)Integer == Integer)       Form = DW_FORM_data1;
 644       else if ((short)Integer == Integer) Form = DW_FORM_data2;
 645       else if ((int)Integer == Integer)   Form = DW_FORM_data4;
 646       else                                Form = DW_FORM_data8;
 647   }
 648   Abbrev->AddAttribute(Attribute, Form);
 649   Values.push_back(new DIEInteger(Integer));
 650 }
 651
 652 /// AddString - Add a std::string attribute data and value.
 653 ///
 654 void DIE::AddString(unsigned Attribute, unsigned Form,
 655                     const std::string &String) {
 656   Abbrev->AddAttribute(Attribute, Form);
 657   Values.push_back(new DIEString(String));
 658 }
 659
 660 /// AddLabel - Add a Dwarf label attribute data and value.
 661 ///
 662 void DIE::AddLabel(unsigned Attribute, unsigned Form,
 663                    const DWLabel &Label) {
 664   Abbrev->AddAttribute(Attribute, Form);
 665   Values.push_back(new DIEDwarfLabel(Label));
 666 }
 667
 668 /// AddObjectLabel - Add an non-Dwarf label attribute data and value.
 669 ///
 670 void DIE::AddObjectLabel(unsigned Attribute, unsigned Form,
 671                          const std::string &Label) {
 672   Abbrev->AddAttribute(Attribute, Form);
 673   Values.push_back(new DIEObjectLabel(Label));
 674 }
 675
 676 /// AddDelta - Add a label delta attribute data and value.
 677 ///
 678 void DIE::AddDelta(unsigned Attribute, unsigned Form,
 679                    const DWLabel &Hi, const DWLabel &Lo) {
 680   Abbrev->AddAttribute(Attribute, Form);
 681   Values.push_back(new DIEDelta(Hi, Lo));
 682 }
 683
 684 /// AddDIEntry - Add a DIE attribute data and value.
 685 ///
 686 void DIE::AddDIEntry(unsigned Attribute,
 687                      unsigned Form, DIE *Entry) {
 688   Abbrev->AddAttribute(Attribute, Form);
 689   Values.push_back(new DIEntry(Entry));
 690 }
 691
 692 /// Complete - Indicate that all attributes have been added and ready to get an
 693 /// abbreviation ID.
 694 void DIE::Complete(DwarfWriter &DW) {
 695   AbbrevID = DW.NewAbbreviation(Abbrev);
 696   delete Abbrev;
 697   Abbrev = NULL;
 698 }
 699
 700 /// AddChild - Add a child to the DIE.
 701 ///
 702 void DIE::AddChild(DIE *Child) {
 703   assert(Abbrev && "Adding children without an abbreviation");
 704   Abbrev->setChildrenFlag(DW_CHILDREN_yes);
 705   Children.push_back(Child);
 706 }
 707
 708 //===----------------------------------------------------------------------===//
 709
 710 /// DWContext
 711
 712 //===----------------------------------------------------------------------===//
 713
 714 /// PrintHex - Print a value as a hexidecimal value.
 715 ///
 716 void DwarfWriter::PrintHex(int Value) const {
 717   O << "0x" << std::hex << Value << std::dec;
 718 }
 719
 720 /// EOL - Print a newline character to asm stream.  If a comment is present
 721 /// then it will be printed first.  Comments should not contain '\n'.
 722 void DwarfWriter::EOL(const std::string &Comment) const {
 723   if (DwarfVerbose) {
 724     O << "\t"
 725       << Asm->CommentString
 726       << " "
 727       << Comment;
 728   }
 729   O << "\n";
 730 }
 731
 732 /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
 733 /// unsigned leb128 value.
 734 void DwarfWriter::EmitULEB128Bytes(unsigned Value) const {
 735   if (hasLEB128) {
 736     O << "\t.uleb128\t"
 737       << Value;
 738   } else {
 739     O << Asm->Data8bitsDirective;
 740     PrintULEB128(Value);
 741   }
 742 }
 743
 744 /// EmitSLEB128Bytes - Emit an assembler byte data directive to compose a
 745 /// signed leb128 value.
 746 void DwarfWriter::EmitSLEB128Bytes(int Value) const {
 747   if (hasLEB128) {
 748     O << "\t.sleb128\t"
 749       << Value;
 750   } else {
 751     O << Asm->Data8bitsDirective;
 752     PrintSLEB128(Value);
 753   }
 754 }
 755
 756 /// PrintULEB128 - Print a series of hexidecimal values (separated by commas)
 757 /// representing an unsigned leb128 value.
 758 void DwarfWriter::PrintULEB128(unsigned Value) const {
 759   do {
 760     unsigned Byte = Value & 0x7f;
 761     Value >>= 7;
 762     if (Value) Byte |= 0x80;
 763     PrintHex(Byte);
 764     if (Value) O << ", ";
 765   } while (Value);
 766 }
 767
 768 /// SizeULEB128 - Compute the number of bytes required for an unsigned leb128
 769 /// value.
 770 unsigned DwarfWriter::SizeULEB128(unsigned Value) {
 771   unsigned Size = 0;
 772   do {
 773     Value >>= 7;
 774     Size += sizeof(int8_t);
 775   } while (Value);
 776   return Size;
 777 }
 778
 779 /// PrintSLEB128 - Print a series of hexidecimal values (separated by commas)
 780 /// representing a signed leb128 value.
 781 void DwarfWriter::PrintSLEB128(int Value) const {
 782   int Sign = Value >> (8 * sizeof(Value) - 1);
 783   bool IsMore;
 784
 785   do {
 786     unsigned Byte = Value & 0x7f;
 787     Value >>= 7;
 788     IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
 789     if (IsMore) Byte |= 0x80;
 790     PrintHex(Byte);
 791     if (IsMore) O << ", ";
 792   } while (IsMore);
 793 }
 794
 795 /// SizeSLEB128 - Compute the number of bytes required for a signed leb128
 796 /// value.
 797 unsigned DwarfWriter::SizeSLEB128(int Value) {
 798   unsigned Size = 0;
 799   int Sign = Value >> (8 * sizeof(Value) - 1);
 800   bool IsMore;
 801
 802   do {
 803     unsigned Byte = Value & 0x7f;
 804     Value >>= 7;
 805     IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
 806     Size += sizeof(int8_t);
 807   } while (IsMore);
 808   return Size;
 809 }
 810
 811 /// EmitInt8 - Emit a byte directive and value.
 812 ///
 813 void DwarfWriter::EmitInt8(int Value) const {
 814   O << Asm->Data8bitsDirective;
 815   PrintHex(Value & 0xFF);
 816 }
 817
 818 /// EmitInt16 - Emit a short directive and value.
 819 ///
 820 void DwarfWriter::EmitInt16(int Value) const {
 821   O << Asm->Data16bitsDirective;
 822   PrintHex(Value & 0xFFFF);
 823 }
 824
 825 /// EmitInt32 - Emit a long directive and value.
 826 ///
 827 void DwarfWriter::EmitInt32(int Value) const {
 828   O << Asm->Data32bitsDirective;
 829   PrintHex(Value);
 830 }
 831
 832 /// EmitInt64 - Emit a long long directive and value.
 833 ///
 834 void DwarfWriter::EmitInt64(uint64_t Value) const {
 835   if (Asm->Data64bitsDirective) {
 836     O << Asm->Data64bitsDirective << "0x" << std::hex << Value << std::dec;
 837   } else {
 838     const TargetData &TD = Asm->TM.getTargetData();
 839
 840     if (TD.isBigEndian()) {
 841       EmitInt32(unsigned(Value >> 32)); O << "\n";
 842       EmitInt32(unsigned(Value));
 843     } else {
 844       EmitInt32(unsigned(Value)); O << "\n";
 845       EmitInt32(unsigned(Value >> 32));
 846     }
 847   }
 848 }
 849
 850 /// EmitString - Emit a string with quotes and a null terminator.
 851 /// Special characters are emitted properly. (Eg. '\t')
 852 void DwarfWriter::EmitString(const std::string &String) const {
 853   O << Asm->AsciiDirective
 854     << "\"";
 855   for (unsigned i = 0, N = String.size(); i < N; ++i) {
 856     unsigned char C = String[i];
 857
 858     if (!isascii(C) || iscntrl(C)) {
 859       switch(C) {
 860       case '\b': O << "\\b"; break;
 861       case '\f': O << "\\f"; break;
 862       case '\n': O << "\\n"; break;
 863       case '\r': O << "\\r"; break;
 864       case '\t': O << "\\t"; break;
 865       default:
 866         O << '\\';
 867         O << char('0' + (C >> 6));
 868         O << char('0' + (C >> 3));
 869         O << char('0' + (C >> 0));
 870         break;
 871       }
 872     } else if (C == '\"') {
 873       O << "\\\"";
 874     } else if (C == '\'') {
 875       O << "\\\'";
 876     } else {
 877      O << C;
 878     }
 879   }
 880   O << "\\0\"";
 881 }
 882
 883 /// PrintLabelName - Print label name in form used by Dwarf writer.
 884 ///
 885 void DwarfWriter::PrintLabelName(const char *Tag, unsigned Number) const {
 886   O << Asm->PrivateGlobalPrefix
 887     << "debug_"
 888     << Tag;
 889   if (Number) O << Number;
 890 }
 891
 892 /// EmitLabel - Emit location label for internal use by Dwarf.
 893 ///
 894 void DwarfWriter::EmitLabel(const char *Tag, unsigned Number) const {
 895   PrintLabelName(Tag, Number);
 896   O << ":\n";
 897 }
 898
 899 /// EmitReference - Emit a reference to a label.
 900 ///
 901 void DwarfWriter::EmitReference(const char *Tag, unsigned Number) const {
 902   if (AddressSize == 4)
 903     O << Asm->Data32bitsDirective;
 904   else
 905     O << Asm->Data64bitsDirective;
 906
 907   PrintLabelName(Tag, Number);
 908 }
 909 void DwarfWriter::EmitReference(const std::string &Name) const {
 910   if (AddressSize == 4)
 911     O << Asm->Data32bitsDirective;
 912   else
 913     O << Asm->Data64bitsDirective;
 914
 915   O << Name;
 916 }
 917
 918 /// EmitDifference - Emit an label difference as sizeof(pointer) value.  Some
 919 /// assemblers do not accept absolute expressions with data directives, so there
 920 /// is an option (needsSet) to use an intermediary 'set' expression.
 921 void DwarfWriter::EmitDifference(const char *TagHi, unsigned NumberHi,
 922                                  const char *TagLo, unsigned NumberLo) const {
 923   if (needsSet) {
 924     static unsigned SetCounter = 0;
 925
 926     O << "\t.set\t";
 927     PrintLabelName("set", SetCounter);
 928     O << ",";
 929     PrintLabelName(TagHi, NumberHi);
 930     O << "-";
 931     PrintLabelName(TagLo, NumberLo);
 932     O << "\n";
 933
 934     if (AddressSize == sizeof(int32_t))
 935       O << Asm->Data32bitsDirective;
 936     else
 937       O << Asm->Data64bitsDirective;
 938
 939     PrintLabelName("set", SetCounter);
 940
 941     ++SetCounter;
 942   } else {
 943     if (AddressSize == sizeof(int32_t))
 944       O << Asm->Data32bitsDirective;
 945     else
 946       O << Asm->Data64bitsDirective;
 947
 948     PrintLabelName(TagHi, NumberHi);
 949     O << "-";
 950     PrintLabelName(TagLo, NumberLo);
 951   }
 952 }
 953
 954 /// NewAbbreviation - Add the abbreviation to the Abbreviation vector.
 955 ///
 956 unsigned DwarfWriter::NewAbbreviation(DIEAbbrev *Abbrev) {
 957   return Abbreviations.insert(*Abbrev);
 958 }
 959
 960 /// NewString - Add a string to the constant pool and returns a label.
 961 ///
 962 DWLabel DwarfWriter::NewString(const std::string &String) {
 963   unsigned StringID = StringPool.insert(String);
 964   return DWLabel("string", StringID);
 965 }
 966
 967 /// NewBasicType - Creates a new basic type if necessary, then adds to the
 968 /// owner.
 969 /// FIXME - Should never be needed.
 970 DIE *DwarfWriter::NewBasicType(CompileUnit *Unit, Type *Ty) {
 971   DIE *&Slot = TypeToDieMap[Ty];
 972   if (Slot) return Slot;
 973
 974   const char *Name;
 975   unsigned Size;
 976   unsigned Encoding = 0;
 977
 978   switch (Ty->getTypeID()) {
 979   case Type::UByteTyID:
 980     Name = "unsigned char";
 981     Size = 1;
 982     Encoding = DW_ATE_unsigned_char;
 983     break;
 984   case Type::SByteTyID:
 985     Name = "char";
 986     Size = 1;
 987     Encoding = DW_ATE_signed_char;
 988     break;
 989   case Type::UShortTyID:
 990     Name = "unsigned short";
 991     Size = 2;
 992     Encoding = DW_ATE_unsigned;
 993     break;
 994   case Type::ShortTyID:
 995     Name = "short";
 996     Size = 2;
 997     Encoding = DW_ATE_signed;
 998     break;
 999   case Type::UIntTyID:
1000     Name = "unsigned int";
1001     Size = 4;
1002     Encoding = DW_ATE_unsigned;
1003     break;
1004   case Type::IntTyID:
1005     Name = "int";
1006     Size = 4;
1007     Encoding = DW_ATE_signed;
1008     break;
1009   case Type::ULongTyID:
1010     Name = "unsigned long long";
1011     Size = 7;
1012     Encoding = DW_ATE_unsigned;
1013     break;
1014   case Type::LongTyID:
1015     Name = "long long";
1016     Size = 7;
1017     Encoding = DW_ATE_signed;
1018     break;
1019   case Type::FloatTyID:
1020     Name = "float";
1021     Size = 4;
1022     Encoding = DW_ATE_float;
1023     break;
1024   case Type::DoubleTyID:
1025     Name = "double";
1026     Size = 8;
1027     Encoding = DW_ATE_float;
1028     break;
1029   default:
1030     // FIXME - handle more complex types.
1031     Name = "unknown";
1032     Size = 1;
1033     Encoding = DW_ATE_address;
1034     break;
1035   }
1036
1037   // construct the type DIE.
1038   Slot = new DIE(DW_TAG_base_type);
1039   Slot->AddString(DW_AT_name,      DW_FORM_string, Name);
1040   Slot->AddUInt  (DW_AT_byte_size, 0,              Size);
1041   Slot->AddUInt  (DW_AT_encoding,  DW_FORM_data1,  Encoding);
1042
1043   // Add to context owner.
1044   Unit->getDie()->AddChild(Slot);
1045
1046   return Slot;
1047 }
1048
1049 /// NewType - Create a new type DIE.
1050 ///
1051 DIE *DwarfWriter::NewType(CompileUnit *Unit, TypeDesc *TyDesc) {
1052   // FIXME - hack to get around NULL types short term.
1053   if (!TyDesc)  return NewBasicType(Unit, Type::IntTy);
1054
1055   // Check for pre-existence.
1056   DIE *&Slot = DescToDieMap[TyDesc];
1057   if (Slot) return Slot;
1058
1059   // Get core information.
1060   const std::string &Name = TyDesc->getName();
1061   uint64_t Size = TyDesc->getSize() >> 3;
1062
1063   DIE *Ty = NULL;
1064
1065   if (BasicTypeDesc *BasicTy = dyn_cast<BasicTypeDesc>(TyDesc)) {
1066     // Fundamental types like int, float, bool
1067     Slot = Ty = new DIE(DW_TAG_base_type);
1068     unsigned Encoding = BasicTy->getEncoding();
1069     Ty->AddUInt  (DW_AT_encoding,  DW_FORM_data1, Encoding);
1070   } else if (DerivedTypeDesc *DerivedTy = dyn_cast<DerivedTypeDesc>(TyDesc)) {
1071     // Determine which derived type.
1072     unsigned T = 0;
1073     switch (DerivedTy->getTag()) {
1074     case DI_TAG_typedef:   T = DW_TAG_typedef;         break;
1075     case DI_TAG_pointer:   T = DW_TAG_pointer_type;    break;
1076     case DI_TAG_reference: T = DW_TAG_reference_type;  break;
1077     case DI_TAG_const:     T = DW_TAG_const_type;      break;
1078     case DI_TAG_volatile:  T = DW_TAG_volatile_type;   break;
1079     case DI_TAG_restrict:  T = DW_TAG_restrict_type;   break;
1080     default: assert( 0 && "Unknown tag on derived type");
1081     }
1082
1083     // Create specific DIE.
1084     Slot = Ty = new DIE(T);
1085
1086     // Map to main type, void will not have a type.
1087     if (TypeDesc *FromTy = DerivedTy->getFromType()) {
1088        Ty->AddDIEntry(DW_AT_type, DW_FORM_ref4, NewType(Unit, FromTy));
1089     }
1090   } else if (CompositeTypeDesc *CompTy = dyn_cast<CompositeTypeDesc>(TyDesc)) {
1091     // Determine which composite type.
1092     unsigned T = 0;
1093     switch (CompTy->getTag()) {
1094     case DI_TAG_array:     T = DW_TAG_array_type;       break;
1095     case DI_TAG_struct:    T = DW_TAG_structure_type;   break;
1096     case DI_TAG_union:     T = DW_TAG_union_type;       break;
1097     case DI_TAG_enum:      T = DW_TAG_enumeration_type; break;
1098     default: assert( 0 && "Unknown tag on composite type");
1099     }
1100
1101     // Create specific DIE.
1102     Slot = Ty = new DIE(T);
1103     std::vector<DebugInfoDesc *> &Elements = CompTy->getElements();
1104
1105     switch (CompTy->getTag()) {
1106     case DI_TAG_array: {
1107       // Add element type.
1108       if (TypeDesc *FromTy = CompTy->getFromType()) {
1109          Ty->AddDIEntry(DW_AT_type, DW_FORM_ref4, NewType(Unit, FromTy));
1110       }
1111       // Don't emit size attribute.
1112       Size = 0;
1113
1114       // Construct an anonymous type for index type.
1115       DIE *IndexTy = new DIE(DW_TAG_base_type);
1116       IndexTy->AddUInt(DW_AT_byte_size, 0, 4);
1117       IndexTy->AddUInt(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
1118       // Add to context.
1119       Unit->getDie()->AddChild(IndexTy);
1120
1121       // Add subranges to array type.
1122       for(unsigned i = 0, N = Elements.size(); i < N; ++i) {
1123         SubrangeDesc *SRD = cast<SubrangeDesc>(Elements[i]);
1124         int64_t Lo = SRD->getLo();
1125         int64_t Hi = SRD->getHi();
1126         DIE *Subrange = new DIE(DW_TAG_subrange_type);
1127
1128         // If a range is available.
1129         if (Lo != Hi) {
1130           Subrange->AddDIEntry(DW_AT_type, DW_FORM_ref4, IndexTy);
1131           // Only add low if non-zero.
1132           if (Lo) Subrange->AddUInt(DW_AT_lower_bound, 0, Lo);
1133           Subrange->AddUInt(DW_AT_upper_bound, 0, Hi);
1134         }
1135         Ty->AddChild(Subrange);
1136       }
1137
1138       break;
1139     }
1140     case DI_TAG_struct: {
1141       break;
1142     }
1143     case DI_TAG_union: {
1144       break;
1145     }
1146     case DI_TAG_enum: {
1147       break;
1148     }
1149     default: break;
1150     }
1151   }
1152
1153   assert(Ty && "Type not supported yet");
1154
1155   // Add size if non-zero (derived types don't have a size.)
1156   if (Size) Ty->AddUInt(DW_AT_byte_size, 0, Size);
1157   // Add name if not anonymous or intermediate type.
1158   if (!Name.empty()) Ty->AddString(DW_AT_name, DW_FORM_string, Name);
1159   // Add source line info if present.
1160   if (CompileUnitDesc *File = TyDesc->getFile()) {
1161     CompileUnit *FileUnit = FindCompileUnit(File);
1162     unsigned FileID = FileUnit->getID();
1163     int Line = TyDesc->getLine();
1164     Ty->AddUInt(DW_AT_decl_file, 0, FileID);
1165     Ty->AddUInt(DW_AT_decl_line, 0, Line);
1166   }
1167
1168   // Add to context owner.
1169   Unit->getDie()->AddChild(Ty);
1170
1171   return Slot;
1172 }
1173
1174 /// NewCompileUnit - Create new compile unit and it's die.
1175 ///
1176 CompileUnit *DwarfWriter::NewCompileUnit(CompileUnitDesc *UnitDesc,
1177                                          unsigned ID) {
1178   // Construct debug information entry.
1179   DIE *Die = new DIE(DW_TAG_compile_unit);
1180   Die->AddLabel (DW_AT_stmt_list, DW_FORM_data4,  DWLabel("line", 0));
1181   Die->AddLabel (DW_AT_high_pc,   DW_FORM_addr,   DWLabel("text_end", 0));
1182   Die->AddLabel (DW_AT_low_pc,    DW_FORM_addr,   DWLabel("text_begin", 0));
1183   Die->AddString(DW_AT_producer,  DW_FORM_string, UnitDesc->getProducer());
1184   Die->AddUInt  (DW_AT_language,  DW_FORM_data1,  UnitDesc->getLanguage());
1185   Die->AddString(DW_AT_name,      DW_FORM_string, UnitDesc->getFileName());
1186   Die->AddString(DW_AT_comp_dir,  DW_FORM_string, UnitDesc->getDirectory());
1187
1188   // Add die to descriptor map.
1189   DescToDieMap[UnitDesc] = Die;
1190
1191   // Construct compile unit.
1192   CompileUnit *Unit = new CompileUnit(UnitDesc, ID, Die);
1193
1194   // Add Unit to compile unit map.
1195   DescToUnitMap[UnitDesc] = Unit;
1196
1197   return Unit;
1198 }
1199
1200 /// FindCompileUnit - Get the compile unit for the given descriptor.
1201 ///
1202 CompileUnit *DwarfWriter::FindCompileUnit(CompileUnitDesc *UnitDesc) {
1203   CompileUnit *Unit = DescToUnitMap[UnitDesc];
1204   assert(Unit && "Missing compile unit.");
1205   return Unit;
1206 }
1207
1208 /// NewGlobalVariable - Add a new global variable DIE.
1209 ///
1210 DIE *DwarfWriter::NewGlobalVariable(GlobalVariableDesc *GVD) {
1211   // Check for pre-existence.
1212   DIE *&Slot = DescToDieMap[GVD];
1213   if (Slot) return Slot;
1214
1215   // Get the compile unit context.
1216   CompileUnitDesc *UnitDesc = static_cast<CompileUnitDesc *>(GVD->getContext());
1217   CompileUnit *Unit = FindCompileUnit(UnitDesc);
1218   // Get the global variable itself.
1219   GlobalVariable *GV = GVD->getGlobalVariable();
1220   // Generate the mangled name.
1221   std::string MangledName = Asm->Mang->getValueName(GV);
1222
1223   // Gather the details (simplify add attribute code.)
1224   const std::string &Name = GVD->getName();
1225   unsigned FileID = Unit->getID();
1226   unsigned Line = GVD->getLine();
1227
1228   // Get the global's type.
1229   DIE *Type = NewType(Unit, GVD->getTypeDesc());
1230
1231   // Create the globale variable DIE.
1232   DIE *VariableDie = new DIE(DW_TAG_variable);
1233   VariableDie->AddString     (DW_AT_name,      DW_FORM_string, Name);
1234   VariableDie->AddUInt       (DW_AT_decl_file, 0,              FileID);
1235   VariableDie->AddUInt       (DW_AT_decl_line, 0,              Line);
1236   VariableDie->AddDIEntry    (DW_AT_type,      DW_FORM_ref4,   Type);
1237   VariableDie->AddUInt       (DW_AT_external,  DW_FORM_flag,   1);
1238   // FIXME - needs to be a proper expression.
1239   VariableDie->AddObjectLabel(DW_AT_location,  DW_FORM_block1, MangledName);
1240
1241   // Add to map.
1242   Slot = VariableDie;
1243
1244   // Add to context owner.
1245   Unit->getDie()->AddChild(VariableDie);
1246
1247   // Expose as global.
1248   // FIXME - need to check external flag.
1249   Unit->AddGlobal(Name, VariableDie);
1250
1251   return VariableDie;
1252 }
1253
1254 /// NewSubprogram - Add a new subprogram DIE.
1255 ///
1256 DIE *DwarfWriter::NewSubprogram(SubprogramDesc *SPD) {
1257   // Check for pre-existence.
1258   DIE *&Slot = DescToDieMap[SPD];
1259   if (Slot) return Slot;
1260
1261   // Get the compile unit context.
1262   CompileUnitDesc *UnitDesc = static_cast<CompileUnitDesc *>(SPD->getContext());
1263   CompileUnit *Unit = FindCompileUnit(UnitDesc);
1264
1265   // Gather the details (simplify add attribute code.)
1266   const std::string &Name = SPD->getName();
1267   unsigned FileID = Unit->getID();
1268   // FIXME - faking the line for the time being.
1269   unsigned Line = 1;
1270
1271   // FIXME - faking the type for the time being.
1272   DIE *Type = NewBasicType(Unit, Type::IntTy);
1273
1274   DIE *SubprogramDie = new DIE(DW_TAG_subprogram);
1275   SubprogramDie->AddString     (DW_AT_name,      DW_FORM_string, Name);
1276   SubprogramDie->AddUInt       (DW_AT_decl_file, 0,              FileID);
1277   SubprogramDie->AddUInt       (DW_AT_decl_line, 0,              Line);
1278   SubprogramDie->AddDIEntry    (DW_AT_type,      DW_FORM_ref4,   Type);
1279   SubprogramDie->AddUInt       (DW_AT_external,  DW_FORM_flag,   1);
1280
1281   // Add to map.
1282   Slot = SubprogramDie;
1283
1284   // Add to context owner.
1285   Unit->getDie()->AddChild(SubprogramDie);
1286
1287   // Expose as global.
1288   Unit->AddGlobal(Name, SubprogramDie);
1289
1290   return SubprogramDie;
1291 }
1292
1293 /// EmitInitial - Emit initial Dwarf declarations.  This is necessary for cc
1294 /// tools to recognize the object file contains Dwarf information.
1295 ///
1296 void DwarfWriter::EmitInitial() const {
1297   // Dwarf sections base addresses.
1298   Asm->SwitchSection(DwarfFrameSection, 0);
1299   EmitLabel("section_frame", 0);
1300   Asm->SwitchSection(DwarfInfoSection, 0);
1301   EmitLabel("section_info", 0);
1302   EmitLabel("info", 0);
1303   Asm->SwitchSection(DwarfAbbrevSection, 0);
1304   EmitLabel("section_abbrev", 0);
1305   EmitLabel("abbrev", 0);
1306   Asm->SwitchSection(DwarfARangesSection, 0);
1307   EmitLabel("section_aranges", 0);
1308   Asm->SwitchSection(DwarfMacInfoSection, 0);
1309   EmitLabel("section_macinfo", 0);
1310   Asm->SwitchSection(DwarfLineSection, 0);
1311   EmitLabel("section_line", 0);
1312   EmitLabel("line", 0);
1313   Asm->SwitchSection(DwarfLocSection, 0);
1314   EmitLabel("section_loc", 0);
1315   Asm->SwitchSection(DwarfPubNamesSection, 0);
1316   EmitLabel("section_pubnames", 0);
1317   Asm->SwitchSection(DwarfStrSection, 0);
1318   EmitLabel("section_str", 0);
1319   Asm->SwitchSection(DwarfRangesSection, 0);
1320   EmitLabel("section_ranges", 0);
1321
1322   Asm->SwitchSection(TextSection, 0);
1323   EmitLabel("text_begin", 0);
1324   Asm->SwitchSection(DataSection, 0);
1325   EmitLabel("data_begin", 0);
1326 }
1327
1328 /// EmitDIE - Recusively Emits a debug information entry.
1329 ///
1330 void DwarfWriter::EmitDIE(DIE *Die) const {
1331   // Get the abbreviation for this DIE.
1332   unsigned AbbrevID = Die->getAbbrevID();
1333   const DIEAbbrev &Abbrev = Abbreviations[AbbrevID];
1334
1335   O << "\n";
1336
1337   // Emit the code (index) for the abbreviation.
1338   EmitULEB128Bytes(AbbrevID);
1339   EOL(std::string("Abbrev [" +
1340       utostr(AbbrevID) +
1341       "] 0x" + utohexstr(Die->getOffset()) +
1342       ":0x" + utohexstr(Die->getSize()) + " " +
1343       TagString(Abbrev.getTag())));
1344
1345   const std::vector<DIEValue *> &Values = Die->getValues();
1346   const std::vector<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1347
1348   // Emit the DIE attribute values.
1349   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1350     unsigned Attr = AbbrevData[i].getAttribute();
1351     unsigned Form = AbbrevData[i].getForm();
1352     assert(Form && "Too many attributes for DIE (check abbreviation)");
1353
1354     switch (Attr) {
1355     case DW_AT_sibling: {
1356       EmitInt32(Die->SiblingOffset());
1357       break;
1358     }
1359     default: {
1360       // Emit an attribute using the defined form.
1361       Values[i]->EmitValue(*this, Form);
1362       break;
1363     }
1364     }
1365
1366     EOL(AttributeString(Attr));
1367   }
1368
1369   // Emit the DIE children if any.
1370   if (Abbrev.getChildrenFlag() == DW_CHILDREN_yes) {
1371     const std::vector<DIE *> &Children = Die->getChildren();
1372
1373     for (unsigned j = 0, M = Children.size(); j < M; ++j) {
1374       // FIXME - handle sibling offsets.
1375       // FIXME - handle all DIE types.
1376       EmitDIE(Children[j]);
1377     }
1378
1379     EmitInt8(0); EOL("End Of Children Mark");
1380   }
1381 }
1382
1383 /// SizeAndOffsetDie - Compute the size and offset of a DIE.
1384 ///
1385 unsigned DwarfWriter::SizeAndOffsetDie(DIE *Die, unsigned Offset) {
1386   // Record the abbreviation.
1387   Die->Complete(*this);
1388
1389   // Get the abbreviation for this DIE.
1390   unsigned AbbrevID = Die->getAbbrevID();
1391   const DIEAbbrev &Abbrev = Abbreviations[AbbrevID];
1392
1393   // Set DIE offset
1394   Die->setOffset(Offset);
1395
1396   // Start the size with the size of abbreviation code.
1397   Offset += SizeULEB128(AbbrevID);
1398
1399   const std::vector<DIEValue *> &Values = Die->getValues();
1400   const std::vector<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1401
1402   // Emit the DIE attribute values.
1403   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1404     // Size attribute value.
1405     Offset += Values[i]->SizeOf(*this, AbbrevData[i].getForm());
1406   }
1407
1408   // Emit the DIE children if any.
1409   if (Abbrev.getChildrenFlag() == DW_CHILDREN_yes) {
1410     const std::vector<DIE *> &Children = Die->getChildren();
1411
1412     for (unsigned j = 0, M = Children.size(); j < M; ++j) {
1413       // FIXME - handle sibling offsets.
1414       // FIXME - handle all DIE types.
1415       Offset = SizeAndOffsetDie(Children[j], Offset);
1416     }
1417
1418     // End of children marker.
1419     Offset += sizeof(int8_t);
1420   }
1421
1422   Die->setSize(Offset - Die->getOffset());
1423   return Offset;
1424 }
1425
1426 /// SizeAndOffsets - Compute the size and offset of all the DIEs.
1427 ///
1428 void DwarfWriter::SizeAndOffsets() {
1429
1430   // Process each compile unit.
1431   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1432     CompileUnit *Unit = CompileUnits[i];
1433     if (Unit->hasContent()) {
1434       // Compute size of compile unit header
1435       unsigned Offset = sizeof(int32_t) + // Length of Compilation Unit Info
1436                         sizeof(int16_t) + // DWARF version number
1437                         sizeof(int32_t) + // Offset Into Abbrev. Section
1438                         sizeof(int8_t);   // Pointer Size (in bytes)
1439
1440       SizeAndOffsetDie(Unit->getDie(), Offset);
1441     }
1442   }
1443 }
1444
1445 /// EmitDebugInfo - Emit the debug info section.
1446 ///
1447 void DwarfWriter::EmitDebugInfo() const {
1448   // Start debug info section.
1449   Asm->SwitchSection(DwarfInfoSection, 0);
1450
1451   // Process each compile unit.
1452   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1453     CompileUnit *Unit = CompileUnits[i];
1454
1455     if (Unit->hasContent()) {
1456       DIE *Die = Unit->getDie();
1457       // Emit the compile units header.
1458       EmitLabel("info_begin", Unit->getID());
1459       // Emit size of content not including length itself
1460       unsigned ContentSize = Die->getSize() +
1461                              sizeof(int16_t) + // DWARF version number
1462                              sizeof(int32_t) + // Offset Into Abbrev. Section
1463                              sizeof(int8_t);   // Pointer Size (in bytes)
1464
1465       EmitInt32(ContentSize);  EOL("Length of Compilation Unit Info");
1466       EmitInt16(DWARF_VERSION); EOL("DWARF version number");
1467       EmitReference("abbrev_begin", 0); EOL("Offset Into Abbrev. Section");
1468       EmitInt8(AddressSize); EOL("Address Size (in bytes)");
1469
1470       EmitDIE(Die);
1471       EmitLabel("info_end", Unit->getID());
1472     }
1473
1474     O << "\n";
1475   }
1476 }
1477
1478 /// EmitAbbreviations - Emit the abbreviation section.
1479 ///
1480 void DwarfWriter::EmitAbbreviations() const {
1481   // Check to see if it is worth the effort.
1482   if (!Abbreviations.empty()) {
1483     // Start the debug abbrev section.
1484     Asm->SwitchSection(DwarfAbbrevSection, 0);
1485
1486     EmitLabel("abbrev_begin", 0);
1487
1488     // For each abbrevation.
1489     for (unsigned AbbrevID = 1, NAID = Abbreviations.size();
1490                   AbbrevID <= NAID; ++AbbrevID) {
1491       // Get abbreviation data
1492       const DIEAbbrev &Abbrev = Abbreviations[AbbrevID];
1493
1494       // Emit the abbrevations code (base 1 index.)
1495       EmitULEB128Bytes(AbbrevID); EOL("Abbreviation Code");
1496
1497       // Emit the abbreviations data.
1498       Abbrev.Emit(*this);
1499
1500       O << "\n";
1501     }
1502
1503     EmitLabel("abbrev_end", 0);
1504
1505     O << "\n";
1506   }
1507 }
1508
1509 /// EmitDebugLines - Emit source line information.
1510 ///
1511 void DwarfWriter::EmitDebugLines() const {
1512   // Minimum line delta, thus ranging from -10..(255-10).
1513   const int MinLineDelta = -(DW_LNS_fixed_advance_pc + 1);
1514   // Maximum line delta, thus ranging from -10..(255-10).
1515   const int MaxLineDelta = 255 + MinLineDelta;
1516
1517   // Start the dwarf line section.
1518   Asm->SwitchSection(DwarfLineSection, 0);
1519
1520   // Construct the section header.
1521
1522   EmitDifference("line_end", 0, "line_begin", 0);
1523   EOL("Length of Source Line Info");
1524   EmitLabel("line_begin", 0);
1525
1526   EmitInt16(DWARF_VERSION); EOL("DWARF version number");
1527
1528   EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0);
1529   EOL("Prolog Length");
1530   EmitLabel("line_prolog_begin", 0);
1531
1532   EmitInt8(1); EOL("Minimum Instruction Length");
1533
1534   EmitInt8(1); EOL("Default is_stmt_start flag");
1535
1536   EmitInt8(MinLineDelta);  EOL("Line Base Value (Special Opcodes)");
1537
1538   EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
1539
1540   EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
1541
1542   // Line number standard opcode encodings argument count
1543   EmitInt8(0); EOL("DW_LNS_copy arg count");
1544   EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
1545   EmitInt8(1); EOL("DW_LNS_advance_line arg count");
1546   EmitInt8(1); EOL("DW_LNS_set_file arg count");
1547   EmitInt8(1); EOL("DW_LNS_set_column arg count");
1548   EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
1549   EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
1550   EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
1551   EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
1552
1553   const UniqueVector<std::string> &Directories = DebugInfo->getDirectories();
1554   const UniqueVector<SourceFileInfo> &SourceFiles = DebugInfo->getSourceFiles();
1555
1556   // Emit directories.
1557   for (unsigned DirectoryID = 1, NDID = Directories.size();
1558                 DirectoryID <= NDID; ++DirectoryID) {
1559     EmitString(Directories[DirectoryID]); EOL("Directory");
1560   }
1561   EmitInt8(0); EOL("End of directories");
1562
1563   // Emit files.
1564   for (unsigned SourceID = 1, NSID = SourceFiles.size();
1565                SourceID <= NSID; ++SourceID) {
1566     const SourceFileInfo &SourceFile = SourceFiles[SourceID];
1567     EmitString(SourceFile.getName()); EOL("Source");
1568     EmitULEB128Bytes(SourceFile.getDirectoryID());  EOL("Directory #");
1569     EmitULEB128Bytes(0);  EOL("Mod date");
1570     EmitULEB128Bytes(0);  EOL("File size");
1571   }
1572   EmitInt8(0); EOL("End of files");
1573
1574   EmitLabel("line_prolog_end", 0);
1575
1576   // Emit line information
1577   const std::vector<SourceLineInfo *> &LineInfos = DebugInfo->getSourceLines();
1578
1579   // Dwarf assumes we start with first line of first source file.
1580   unsigned Source = 1;
1581   unsigned Line = 1;
1582
1583   // Construct rows of the address, source, line, column matrix.
1584   for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
1585     SourceLineInfo *LineInfo = LineInfos[i];
1586
1587     if (DwarfVerbose) {
1588       unsigned SourceID = LineInfo->getSourceID();
1589       const SourceFileInfo &SourceFile = SourceFiles[SourceID];
1590       unsigned DirectoryID = SourceFile.getDirectoryID();
1591       O << "\t"
1592         << Asm->CommentString << " "
1593         << Directories[DirectoryID]
1594         << SourceFile.getName() << ":"
1595         << LineInfo->getLine() << "\n";
1596     }
1597
1598     // Define the line address.
1599     EmitInt8(0); EOL("Extended Op");
1600     EmitInt8(4 + 1); EOL("Op size");
1601     EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address");
1602     EmitReference("loc", i + 1); EOL("Location label");
1603
1604     // If change of source, then switch to the new source.
1605     if (Source != LineInfo->getSourceID()) {
1606       Source = LineInfo->getSourceID();
1607       EmitInt8(DW_LNS_set_file); EOL("DW_LNS_set_file");
1608       EmitULEB128Bytes(Source); EOL("New Source");
1609     }
1610
1611     // If change of line.
1612     if (Line != LineInfo->getLine()) {
1613       // Determine offset.
1614       int Offset = LineInfo->getLine() - Line;
1615       int Delta = Offset - MinLineDelta;
1616
1617       // Update line.
1618       Line = LineInfo->getLine();
1619
1620       // If delta is small enough and in range...
1621       if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
1622         // ... then use fast opcode.
1623         EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
1624       } else {
1625         // ... otherwise use long hand.
1626         EmitInt8(DW_LNS_advance_line); EOL("DW_LNS_advance_line");
1627         EmitSLEB128Bytes(Offset); EOL("Line Offset");
1628         EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy");
1629       }
1630     } else {
1631       // Copy the previous row (different address or source)
1632       EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy");
1633     }
1634   }
1635
1636   // Define last address.
1637   EmitInt8(0); EOL("Extended Op");
1638   EmitInt8(4 + 1); EOL("Op size");
1639   EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address");
1640   EmitReference("text_end", 0); EOL("Location label");
1641
1642   // Mark end of matrix.
1643   EmitInt8(0); EOL("DW_LNE_end_sequence");
1644   EmitULEB128Bytes(1);  O << "\n";
1645   EmitInt8(1); O << "\n";
1646
1647   EmitLabel("line_end", 0);
1648
1649   O << "\n";
1650 }
1651
1652 /// EmitDebugFrame - Emit visible names into a debug frame section.
1653 ///
1654 void DwarfWriter::EmitDebugFrame() {
1655   // FIXME - Should be per frame
1656 }
1657
1658 /// EmitDebugPubNames - Emit visible names into a debug pubnames section.
1659 ///
1660 void DwarfWriter::EmitDebugPubNames() {
1661   // Start the dwarf pubnames section.
1662   Asm->SwitchSection(DwarfPubNamesSection, 0);
1663
1664   // Process each compile unit.
1665   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1666     CompileUnit *Unit = CompileUnits[i];
1667
1668     if (Unit->hasContent()) {
1669       EmitDifference("pubnames_end", Unit->getID(),
1670                      "pubnames_begin", Unit->getID());
1671       EOL("Length of Public Names Info");
1672
1673       EmitLabel("pubnames_begin", Unit->getID());
1674
1675       EmitInt16(DWARF_VERSION); EOL("DWARF Version");
1676
1677       EmitReference("info_begin", Unit->getID());
1678       EOL("Offset of Compilation Unit Info");
1679
1680       EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID());
1681       EOL("Compilation Unit Length");
1682
1683       std::map<std::string, DIE *> &Globals = Unit->getGlobals();
1684
1685       for (std::map<std::string, DIE *>::iterator GI = Globals.begin(),
1686                                                   GE = Globals.end();
1687            GI != GE; ++GI) {
1688         const std::string &Name = GI->first;
1689         DIE * Entity = GI->second;
1690
1691         EmitInt32(Entity->getOffset()); EOL("DIE offset");
1692         EmitString(Name); EOL("External Name");
1693       }
1694
1695       EmitInt32(0); EOL("End Mark");
1696       EmitLabel("pubnames_end", Unit->getID());
1697
1698       O << "\n";
1699     }
1700   }
1701 }
1702
1703 /// EmitDebugStr - Emit visible names into a debug str section.
1704 ///
1705 void DwarfWriter::EmitDebugStr() {
1706   // Check to see if it is worth the effort.
1707   if (!StringPool.empty()) {
1708     // Start the dwarf str section.
1709     Asm->SwitchSection(DwarfStrSection, 0);
1710
1711     // For each of strings in teh string pool.
1712     for (unsigned StringID = 1, N = StringPool.size();
1713          StringID <= N; ++StringID) {
1714       // Emit a label for reference from debug information entries.
1715       EmitLabel("string", StringID);
1716       // Emit the string itself.
1717       const std::string &String = StringPool[StringID];
1718       EmitString(String); O << "\n";
1719     }
1720
1721     O << "\n";
1722   }
1723 }
1724
1725 /// EmitDebugLoc - Emit visible names into a debug loc section.
1726 ///
1727 void DwarfWriter::EmitDebugLoc() {
1728   // Start the dwarf loc section.
1729   Asm->SwitchSection(DwarfLocSection, 0);
1730
1731   O << "\n";
1732 }
1733
1734 /// EmitDebugARanges - Emit visible names into a debug aranges section.
1735 ///
1736 void DwarfWriter::EmitDebugARanges() {
1737   // Start the dwarf aranges section.
1738   Asm->SwitchSection(DwarfARangesSection, 0);
1739
1740   // FIXME - Mock up
1741 #if 0
1742   // Process each compile unit.
1743   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1744     CompileUnit *Unit = CompileUnits[i];
1745
1746     if (Unit->hasContent()) {
1747       // Don't include size of length
1748       EmitInt32(0x1c); EOL("Length of Address Ranges Info");
1749
1750       EmitInt16(DWARF_VERSION); EOL("Dwarf Version");
1751
1752       EmitReference("info_begin", Unit->getID());
1753       EOL("Offset of Compilation Unit Info");
1754
1755       EmitInt8(AddressSize); EOL("Size of Address");
1756
1757       EmitInt8(0); EOL("Size of Segment Descriptor");
1758
1759       EmitInt16(0);  EOL("Pad (1)");
1760       EmitInt16(0);  EOL("Pad (2)");
1761
1762       // Range 1
1763       EmitReference("text_begin", 0); EOL("Address");
1764       EmitDifference("text_end", 0, "text_begin", 0); EOL("Length");
1765
1766       EmitInt32(0); EOL("EOM (1)");
1767       EmitInt32(0); EOL("EOM (2)");
1768
1769       O << "\n";
1770     }
1771   }
1772 #endif
1773 }
1774
1775 /// EmitDebugRanges - Emit visible names into a debug ranges section.
1776 ///
1777 void DwarfWriter::EmitDebugRanges() {
1778   // Start the dwarf ranges section.
1779   Asm->SwitchSection(DwarfRangesSection, 0);
1780
1781   O << "\n";
1782 }
1783
1784 /// EmitDebugMacInfo - Emit visible names into a debug macinfo section.
1785 ///
1786 void DwarfWriter::EmitDebugMacInfo() {
1787   // Start the dwarf macinfo section.
1788   Asm->SwitchSection(DwarfMacInfoSection, 0);
1789
1790   O << "\n";
1791 }
1792
1793 /// ConstructCompileUnitDIEs - Create a compile unit DIE for each source and
1794 /// header file.
1795 void DwarfWriter::ConstructCompileUnitDIEs() {
1796   const UniqueVector<CompileUnitDesc *> CUW = DebugInfo->getCompileUnits();
1797
1798   for (unsigned i = 1, N = CUW.size(); i <= N; ++i) {
1799     CompileUnit *Unit = NewCompileUnit(CUW[i], i);
1800     CompileUnits.push_back(Unit);
1801   }
1802 }
1803
1804 /// ConstructGlobalDIEs - Create DIEs for each of the externally visible global
1805 /// variables.
1806 void DwarfWriter::ConstructGlobalDIEs(Module &M) {
1807   std::vector<GlobalVariableDesc *> GlobalVariables =
1808                        DebugInfo->getAnchoredDescriptors<GlobalVariableDesc>(M);
1809
1810   for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) {
1811     GlobalVariableDesc *GVD = GlobalVariables[i];
1812     NewGlobalVariable(GVD);
1813   }
1814 }
1815
1816 /// ConstructSubprogramDIEs - Create DIEs for each of the externally visible
1817 /// subprograms.
1818 void DwarfWriter::ConstructSubprogramDIEs(Module &M) {
1819   std::vector<SubprogramDesc *> Subprograms =
1820                            DebugInfo->getAnchoredDescriptors<SubprogramDesc>(M);
1821
1822   for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) {
1823     SubprogramDesc *SPD = Subprograms[i];
1824     NewSubprogram(SPD);
1825   }
1826 }
1827
1828 /// ShouldEmitDwarf - Determine if Dwarf declarations should be made.
1829 ///
1830 bool DwarfWriter::ShouldEmitDwarf() {
1831   // Check if debug info is present.
1832   if (!DebugInfo || !DebugInfo->hasInfo()) return false;
1833
1834   // Make sure initial declarations are made.
1835   if (!didInitial) {
1836     EmitInitial();
1837     didInitial = true;
1838   }
1839
1840   // Okay to emit.
1841   return true;
1842 }
1843
1844 //===----------------------------------------------------------------------===//
1845 // Main entry points.
1846 //
1847
1848 DwarfWriter::DwarfWriter(std::ostream &OS, AsmPrinter *A)
1849 : O(OS)
1850 , Asm(A)
1851 , DebugInfo(NULL)
1852 , didInitial(false)
1853 , CompileUnits()
1854 , Abbreviations()
1855 , StringPool()
1856 , DescToUnitMap()
1857 , DescToDieMap()
1858 , TypeToDieMap()
1859 , AddressSize(sizeof(int32_t))
1860 , hasLEB128(false)
1861 , hasDotLoc(false)
1862 , hasDotFile(false)
1863 , needsSet(false)
1864 , DwarfAbbrevSection(".debug_abbrev")
1865 , DwarfInfoSection(".debug_info")
1866 , DwarfLineSection(".debug_line")
1867 , DwarfFrameSection(".debug_frame")
1868 , DwarfPubNamesSection(".debug_pubnames")
1869 , DwarfPubTypesSection(".debug_pubtypes")
1870 , DwarfStrSection(".debug_str")
1871 , DwarfLocSection(".debug_loc")
1872 , DwarfARangesSection(".debug_aranges")
1873 , DwarfRangesSection(".debug_ranges")
1874 , DwarfMacInfoSection(".debug_macinfo")
1875 , TextSection(".text")
1876 , DataSection(".data")
1877 {}
1878 DwarfWriter::~DwarfWriter() {
1879   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1880     delete CompileUnits[i];
1881   }
1882 }
1883
1884 /// BeginModule - Emit all Dwarf sections that should come prior to the content.
1885 ///
1886 void DwarfWriter::BeginModule(Module &M) {
1887   if (!ShouldEmitDwarf()) return;
1888   EOL("Dwarf Begin Module");
1889 }
1890
1891 /// EndModule - Emit all Dwarf sections that should come after the content.
1892 ///
1893 void DwarfWriter::EndModule(Module &M) {
1894   if (!ShouldEmitDwarf()) return;
1895   EOL("Dwarf End Module");
1896
1897   // Standard sections final addresses.
1898   Asm->SwitchSection(TextSection, 0);
1899   EmitLabel("text_end", 0);
1900   Asm->SwitchSection(DataSection, 0);
1901   EmitLabel("data_end", 0);
1902
1903   // Create all the compile unit DIEs.
1904   ConstructCompileUnitDIEs();
1905
1906   // Create DIEs for each of the externally visible global variables.
1907   ConstructGlobalDIEs(M);
1908
1909   // Create DIEs for each of the externally visible subprograms.
1910   ConstructSubprogramDIEs(M);
1911
1912   // Compute DIE offsets and sizes.
1913   SizeAndOffsets();
1914
1915   // Emit all the DIEs into a debug info section
1916   EmitDebugInfo();
1917
1918   // Corresponding abbreviations into a abbrev section.
1919   EmitAbbreviations();
1920
1921   // Emit source line correspondence into a debug line section.
1922   EmitDebugLines();
1923
1924   // Emit info into a debug frame section.
1925   // EmitDebugFrame();
1926
1927   // Emit info into a debug pubnames section.
1928   EmitDebugPubNames();
1929
1930   // Emit info into a debug str section.
1931   EmitDebugStr();
1932
1933   // Emit info into a debug loc section.
1934   EmitDebugLoc();
1935
1936   // Emit info into a debug aranges section.
1937   EmitDebugARanges();
1938
1939   // Emit info into a debug ranges section.
1940   EmitDebugRanges();
1941
1942   // Emit info into a debug macinfo section.
1943   EmitDebugMacInfo();
1944 }
1945
1946 /// BeginFunction - Gather pre-function debug information.
1947 ///
1948 void DwarfWriter::BeginFunction(MachineFunction &MF) {
1949   if (!ShouldEmitDwarf()) return;
1950   EOL("Dwarf Begin Function");
1951 }
1952
1953 /// EndFunction - Gather and emit post-function debug information.
1954 ///
1955 void DwarfWriter::EndFunction(MachineFunction &MF) {
1956   if (!ShouldEmitDwarf()) return;
1957   EOL("Dwarf End Function");
1958 }