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(DIE *Context, 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.
1044   Context->AddChild(Slot);
1045
1046   return Slot;
1047 }
1048
1049 /// NewType - Create a new type DIE.
1050 ///
1051 DIE *DwarfWriter::NewType(DIE *Context, TypeDesc *TyDesc) {
1052   // FIXME - hack to get around NULL types short term.
1053   if (!TyDesc)  return NewBasicType(Context, Type::IntTy);
1054
1055   // FIXME - Should handle other contexts that compile units.
1056
1057   // Check for pre-existence.
1058   DIE *&Slot = DescToDieMap[TyDesc];
1059   if (Slot) return Slot;
1060
1061   // Get core information.
1062   const std::string &Name = TyDesc->getName();
1063   uint64_t Size = TyDesc->getSize() >> 3;
1064
1065   DIE *Ty = NULL;
1066
1067   if (BasicTypeDesc *BasicTy = dyn_cast<BasicTypeDesc>(TyDesc)) {
1068     // Fundamental types like int, float, bool
1069     Slot = Ty = new DIE(DW_TAG_base_type);
1070     unsigned Encoding = BasicTy->getEncoding();
1071     Ty->AddUInt  (DW_AT_encoding,  DW_FORM_data1, Encoding);
1072   } else if (DerivedTypeDesc *DerivedTy = dyn_cast<DerivedTypeDesc>(TyDesc)) {
1073     // Determine which derived type.
1074     unsigned T = 0;
1075     switch (DerivedTy->getTag()) {
1076     case DI_TAG_typedef:   T = DW_TAG_typedef;         break;
1077     case DI_TAG_pointer:   T = DW_TAG_pointer_type;    break;
1078     case DI_TAG_reference: T = DW_TAG_reference_type;  break;
1079     case DI_TAG_const:     T = DW_TAG_const_type;      break;
1080     case DI_TAG_volatile:  T = DW_TAG_volatile_type;   break;
1081     case DI_TAG_restrict:  T = DW_TAG_restrict_type;   break;
1082     default: assert( 0 && "Unknown tag on derived type");
1083     }
1084
1085     // Create specific DIE.
1086     Slot = Ty = new DIE(T);
1087
1088     // Map to main type, void will not have a type.
1089     if (TypeDesc *FromTy = DerivedTy->getFromType()) {
1090        Ty->AddDIEntry(DW_AT_type, DW_FORM_ref4, NewType(Context, FromTy));
1091     }
1092   } else if (CompositeTypeDesc *CompTy = dyn_cast<CompositeTypeDesc>(TyDesc)) {
1093     // Determine which composite type.
1094     unsigned T = 0;
1095     switch (CompTy->getTag()) {
1096     case DI_TAG_array:     T = DW_TAG_array_type;       break;
1097     case DI_TAG_struct:    T = DW_TAG_structure_type;   break;
1098     case DI_TAG_union:     T = DW_TAG_union_type;       break;
1099     case DI_TAG_enum:      T = DW_TAG_enumeration_type; break;
1100     default: assert( 0 && "Unknown tag on composite type");
1101     }
1102
1103     // Create specific DIE.
1104     Slot = Ty = new DIE(T);
1105     std::vector<DebugInfoDesc *> &Elements = CompTy->getElements();
1106
1107     switch (CompTy->getTag()) {
1108     case DI_TAG_array: {
1109       // Add element type.
1110       if (TypeDesc *FromTy = CompTy->getFromType()) {
1111          Ty->AddDIEntry(DW_AT_type, DW_FORM_ref4, NewType(Context, FromTy));
1112       }
1113       // Don't emit size attribute.
1114       Size = 0;
1115
1116       // Construct an anonymous type for index type.
1117       DIE *IndexTy = new DIE(DW_TAG_base_type);
1118       IndexTy->AddUInt(DW_AT_byte_size, 0, 4);
1119       IndexTy->AddUInt(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
1120       // Add to context.
1121       Context->AddChild(IndexTy);
1122
1123       // Add subranges to array type.
1124       for(unsigned i = 0, N = Elements.size(); i < N; ++i) {
1125         SubrangeDesc *SRD = cast<SubrangeDesc>(Elements[i]);
1126         int64_t Lo = SRD->getLo();
1127         int64_t Hi = SRD->getHi();
1128         DIE *Subrange = new DIE(DW_TAG_subrange_type);
1129
1130         // If a range is available.
1131         if (Lo != Hi) {
1132           Subrange->AddDIEntry(DW_AT_type, DW_FORM_ref4, IndexTy);
1133           // Only add low if non-zero.
1134           if (Lo) Subrange->AddUInt(DW_AT_lower_bound, 0, Lo);
1135           Subrange->AddUInt(DW_AT_upper_bound, 0, Hi);
1136         }
1137         Ty->AddChild(Subrange);
1138       }
1139
1140       break;
1141     }
1142     case DI_TAG_struct: {
1143       break;
1144     }
1145     case DI_TAG_union: {
1146       break;
1147     }
1148     case DI_TAG_enum: {
1149       break;
1150     }
1151     default: break;
1152     }
1153   }
1154
1155   assert(Ty && "Type not supported yet");
1156
1157   // Add size if non-zero (derived types don't have a size.)
1158   if (Size) Ty->AddUInt(DW_AT_byte_size, 0, Size);
1159   // Add name if not anonymous or intermediate type.
1160   if (!Name.empty()) Ty->AddString(DW_AT_name, DW_FORM_string, Name);
1161   // Add source line info if present.
1162   if (CompileUnitDesc *File = TyDesc->getFile()) {
1163     CompileUnit *FileUnit = FindCompileUnit(File);
1164     unsigned FileID = FileUnit->getID();
1165     int Line = TyDesc->getLine();
1166     Ty->AddUInt(DW_AT_decl_file, 0, FileID);
1167     Ty->AddUInt(DW_AT_decl_line, 0, Line);
1168   }
1169
1170   // Add to context owner.
1171   Context->AddChild(Ty);
1172
1173   return Slot;
1174 }
1175
1176 /// NewCompileUnit - Create new compile unit and it's die.
1177 ///
1178 CompileUnit *DwarfWriter::NewCompileUnit(CompileUnitDesc *UnitDesc,
1179                                          unsigned ID) {
1180   // Construct debug information entry.
1181   DIE *Die = new DIE(DW_TAG_compile_unit);
1182   Die->AddLabel (DW_AT_stmt_list, DW_FORM_data4,  DWLabel("line", 0));
1183   Die->AddLabel (DW_AT_high_pc,   DW_FORM_addr,   DWLabel("text_end", 0));
1184   Die->AddLabel (DW_AT_low_pc,    DW_FORM_addr,   DWLabel("text_begin", 0));
1185   Die->AddString(DW_AT_producer,  DW_FORM_string, UnitDesc->getProducer());
1186   Die->AddUInt  (DW_AT_language,  DW_FORM_data1,  UnitDesc->getLanguage());
1187   Die->AddString(DW_AT_name,      DW_FORM_string, UnitDesc->getFileName());
1188   Die->AddString(DW_AT_comp_dir,  DW_FORM_string, UnitDesc->getDirectory());
1189
1190   // Add die to descriptor map.
1191   DescToDieMap[UnitDesc] = Die;
1192
1193   // Construct compile unit.
1194   CompileUnit *Unit = new CompileUnit(UnitDesc, ID, Die);
1195
1196   // Add Unit to compile unit map.
1197   DescToUnitMap[UnitDesc] = Unit;
1198
1199   return Unit;
1200 }
1201
1202 /// FindCompileUnit - Get the compile unit for the given descriptor.
1203 ///
1204 CompileUnit *DwarfWriter::FindCompileUnit(CompileUnitDesc *UnitDesc) {
1205   CompileUnit *Unit = DescToUnitMap[UnitDesc];
1206   assert(Unit && "Missing compile unit.");
1207   return Unit;
1208 }
1209
1210 /// NewGlobalVariable - Add a new global variable DIE.
1211 ///
1212 DIE *DwarfWriter::NewGlobalVariable(GlobalVariableDesc *GVD) {
1213   // Check for pre-existence.
1214   DIE *&Slot = DescToDieMap[GVD];
1215   if (Slot) return Slot;
1216
1217   // Get the compile unit context.
1218   CompileUnitDesc *UnitDesc = static_cast<CompileUnitDesc *>(GVD->getContext());
1219   CompileUnit *Unit = FindCompileUnit(UnitDesc);
1220   // Get the global variable itself.
1221   GlobalVariable *GV = GVD->getGlobalVariable();
1222   // Generate the mangled name.
1223   std::string MangledName = Asm->Mang->getValueName(GV);
1224
1225   // Gather the details (simplify add attribute code.)
1226   const std::string &Name = GVD->getName();
1227   unsigned FileID = Unit->getID();
1228   unsigned Line = GVD->getLine();
1229
1230   // Get the global's type.
1231   DIE *Type = NewType(Unit->getDie(), GVD->getTypeDesc());
1232
1233   // Create the globale variable DIE.
1234   DIE *VariableDie = new DIE(DW_TAG_variable);
1235   VariableDie->AddString     (DW_AT_name,      DW_FORM_string, Name);
1236   VariableDie->AddUInt       (DW_AT_decl_file, 0,              FileID);
1237   VariableDie->AddUInt       (DW_AT_decl_line, 0,              Line);
1238   VariableDie->AddDIEntry    (DW_AT_type,      DW_FORM_ref4,   Type);
1239   VariableDie->AddUInt       (DW_AT_external,  DW_FORM_flag,   1);
1240   // FIXME - needs to be a proper expression.
1241   VariableDie->AddObjectLabel(DW_AT_location,  DW_FORM_block1, MangledName);
1242
1243   // Add to map.
1244   Slot = VariableDie;
1245
1246   // Add to context owner.
1247   Unit->getDie()->AddChild(VariableDie);
1248
1249   // Expose as global.
1250   // FIXME - need to check external flag.
1251   Unit->AddGlobal(Name, VariableDie);
1252
1253   return VariableDie;
1254 }
1255
1256 /// NewSubprogram - Add a new subprogram DIE.
1257 ///
1258 DIE *DwarfWriter::NewSubprogram(SubprogramDesc *SPD) {
1259   // Check for pre-existence.
1260   DIE *&Slot = DescToDieMap[SPD];
1261   if (Slot) return Slot;
1262
1263   // Get the compile unit context.
1264   CompileUnitDesc *UnitDesc = static_cast<CompileUnitDesc *>(SPD->getContext());
1265   CompileUnit *Unit = FindCompileUnit(UnitDesc);
1266
1267   // Gather the details (simplify add attribute code.)
1268   const std::string &Name = SPD->getName();
1269   unsigned FileID = Unit->getID();
1270   // FIXME - faking the line for the time being.
1271   unsigned Line = 1;
1272
1273   // FIXME - faking the type for the time being.
1274   DIE *Type = NewBasicType(Unit->getDie(), Type::IntTy);
1275
1276   DIE *SubprogramDie = new DIE(DW_TAG_subprogram);
1277   SubprogramDie->AddString     (DW_AT_name,      DW_FORM_string, Name);
1278   SubprogramDie->AddUInt       (DW_AT_decl_file, 0,              FileID);
1279   SubprogramDie->AddUInt       (DW_AT_decl_line, 0,              Line);
1280   SubprogramDie->AddDIEntry    (DW_AT_type,      DW_FORM_ref4,   Type);
1281   SubprogramDie->AddUInt       (DW_AT_external,  DW_FORM_flag,   1);
1282
1283   // Add to map.
1284   Slot = SubprogramDie;
1285
1286   // Add to context owner.
1287   Unit->getDie()->AddChild(SubprogramDie);
1288
1289   // Expose as global.
1290   Unit->AddGlobal(Name, SubprogramDie);
1291
1292   return SubprogramDie;
1293 }
1294
1295 /// EmitInitial - Emit initial Dwarf declarations.  This is necessary for cc
1296 /// tools to recognize the object file contains Dwarf information.
1297 ///
1298 void DwarfWriter::EmitInitial() const {
1299   // Dwarf sections base addresses.
1300   Asm->SwitchSection(DwarfFrameSection, 0);
1301   EmitLabel("section_frame", 0);
1302   Asm->SwitchSection(DwarfInfoSection, 0);
1303   EmitLabel("section_info", 0);
1304   EmitLabel("info", 0);
1305   Asm->SwitchSection(DwarfAbbrevSection, 0);
1306   EmitLabel("section_abbrev", 0);
1307   EmitLabel("abbrev", 0);
1308   Asm->SwitchSection(DwarfARangesSection, 0);
1309   EmitLabel("section_aranges", 0);
1310   Asm->SwitchSection(DwarfMacInfoSection, 0);
1311   EmitLabel("section_macinfo", 0);
1312   Asm->SwitchSection(DwarfLineSection, 0);
1313   EmitLabel("section_line", 0);
1314   EmitLabel("line", 0);
1315   Asm->SwitchSection(DwarfLocSection, 0);
1316   EmitLabel("section_loc", 0);
1317   Asm->SwitchSection(DwarfPubNamesSection, 0);
1318   EmitLabel("section_pubnames", 0);
1319   Asm->SwitchSection(DwarfStrSection, 0);
1320   EmitLabel("section_str", 0);
1321   Asm->SwitchSection(DwarfRangesSection, 0);
1322   EmitLabel("section_ranges", 0);
1323
1324   Asm->SwitchSection(TextSection, 0);
1325   EmitLabel("text_begin", 0);
1326   Asm->SwitchSection(DataSection, 0);
1327   EmitLabel("data_begin", 0);
1328 }
1329
1330 /// EmitDIE - Recusively Emits a debug information entry.
1331 ///
1332 void DwarfWriter::EmitDIE(DIE *Die) const {
1333   // Get the abbreviation for this DIE.
1334   unsigned AbbrevID = Die->getAbbrevID();
1335   const DIEAbbrev &Abbrev = Abbreviations[AbbrevID];
1336
1337   O << "\n";
1338
1339   // Emit the code (index) for the abbreviation.
1340   EmitULEB128Bytes(AbbrevID);
1341   EOL(std::string("Abbrev [" +
1342       utostr(AbbrevID) +
1343       "] 0x" + utohexstr(Die->getOffset()) +
1344       ":0x" + utohexstr(Die->getSize()) + " " +
1345       TagString(Abbrev.getTag())));
1346
1347   const std::vector<DIEValue *> &Values = Die->getValues();
1348   const std::vector<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1349
1350   // Emit the DIE attribute values.
1351   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1352     unsigned Attr = AbbrevData[i].getAttribute();
1353     unsigned Form = AbbrevData[i].getForm();
1354     assert(Form && "Too many attributes for DIE (check abbreviation)");
1355
1356     switch (Attr) {
1357     case DW_AT_sibling: {
1358       EmitInt32(Die->SiblingOffset());
1359       break;
1360     }
1361     default: {
1362       // Emit an attribute using the defined form.
1363       Values[i]->EmitValue(*this, Form);
1364       break;
1365     }
1366     }
1367
1368     EOL(AttributeString(Attr));
1369   }
1370
1371   // Emit the DIE children if any.
1372   if (Abbrev.getChildrenFlag() == DW_CHILDREN_yes) {
1373     const std::vector<DIE *> &Children = Die->getChildren();
1374
1375     for (unsigned j = 0, M = Children.size(); j < M; ++j) {
1376       // FIXME - handle sibling offsets.
1377       // FIXME - handle all DIE types.
1378       EmitDIE(Children[j]);
1379     }
1380
1381     EmitInt8(0); EOL("End Of Children Mark");
1382   }
1383 }
1384
1385 /// SizeAndOffsetDie - Compute the size and offset of a DIE.
1386 ///
1387 unsigned DwarfWriter::SizeAndOffsetDie(DIE *Die, unsigned Offset) {
1388   // Record the abbreviation.
1389   Die->Complete(*this);
1390
1391   // Get the abbreviation for this DIE.
1392   unsigned AbbrevID = Die->getAbbrevID();
1393   const DIEAbbrev &Abbrev = Abbreviations[AbbrevID];
1394
1395   // Set DIE offset
1396   Die->setOffset(Offset);
1397
1398   // Start the size with the size of abbreviation code.
1399   Offset += SizeULEB128(AbbrevID);
1400
1401   const std::vector<DIEValue *> &Values = Die->getValues();
1402   const std::vector<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1403
1404   // Emit the DIE attribute values.
1405   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1406     // Size attribute value.
1407     Offset += Values[i]->SizeOf(*this, AbbrevData[i].getForm());
1408   }
1409
1410   // Emit the DIE children if any.
1411   if (Abbrev.getChildrenFlag() == DW_CHILDREN_yes) {
1412     const std::vector<DIE *> &Children = Die->getChildren();
1413
1414     for (unsigned j = 0, M = Children.size(); j < M; ++j) {
1415       // FIXME - handle sibling offsets.
1416       // FIXME - handle all DIE types.
1417       Offset = SizeAndOffsetDie(Children[j], Offset);
1418     }
1419
1420     // End of children marker.
1421     Offset += sizeof(int8_t);
1422   }
1423
1424   Die->setSize(Offset - Die->getOffset());
1425   return Offset;
1426 }
1427
1428 /// SizeAndOffsets - Compute the size and offset of all the DIEs.
1429 ///
1430 void DwarfWriter::SizeAndOffsets() {
1431
1432   // Process each compile unit.
1433   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1434     CompileUnit *Unit = CompileUnits[i];
1435     if (Unit->hasContent()) {
1436       // Compute size of compile unit header
1437       unsigned Offset = sizeof(int32_t) + // Length of Compilation Unit Info
1438                         sizeof(int16_t) + // DWARF version number
1439                         sizeof(int32_t) + // Offset Into Abbrev. Section
1440                         sizeof(int8_t);   // Pointer Size (in bytes)
1441
1442       SizeAndOffsetDie(Unit->getDie(), Offset);
1443     }
1444   }
1445 }
1446
1447 /// EmitDebugInfo - Emit the debug info section.
1448 ///
1449 void DwarfWriter::EmitDebugInfo() const {
1450   // Start debug info section.
1451   Asm->SwitchSection(DwarfInfoSection, 0);
1452
1453   // Process each compile unit.
1454   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1455     CompileUnit *Unit = CompileUnits[i];
1456
1457     if (Unit->hasContent()) {
1458       DIE *Die = Unit->getDie();
1459       // Emit the compile units header.
1460       EmitLabel("info_begin", Unit->getID());
1461       // Emit size of content not including length itself
1462       unsigned ContentSize = Die->getSize() +
1463                              sizeof(int16_t) + // DWARF version number
1464                              sizeof(int32_t) + // Offset Into Abbrev. Section
1465                              sizeof(int8_t);   // Pointer Size (in bytes)
1466
1467       EmitInt32(ContentSize);  EOL("Length of Compilation Unit Info");
1468       EmitInt16(DWARF_VERSION); EOL("DWARF version number");
1469       EmitReference("abbrev_begin", 0); EOL("Offset Into Abbrev. Section");
1470       EmitInt8(AddressSize); EOL("Address Size (in bytes)");
1471
1472       EmitDIE(Die);
1473       EmitLabel("info_end", Unit->getID());
1474     }
1475
1476     O << "\n";
1477   }
1478 }
1479
1480 /// EmitAbbreviations - Emit the abbreviation section.
1481 ///
1482 void DwarfWriter::EmitAbbreviations() const {
1483   // Check to see if it is worth the effort.
1484   if (!Abbreviations.empty()) {
1485     // Start the debug abbrev section.
1486     Asm->SwitchSection(DwarfAbbrevSection, 0);
1487
1488     EmitLabel("abbrev_begin", 0);
1489
1490     // For each abbrevation.
1491     for (unsigned AbbrevID = 1, NAID = Abbreviations.size();
1492                   AbbrevID <= NAID; ++AbbrevID) {
1493       // Get abbreviation data
1494       const DIEAbbrev &Abbrev = Abbreviations[AbbrevID];
1495
1496       // Emit the abbrevations code (base 1 index.)
1497       EmitULEB128Bytes(AbbrevID); EOL("Abbreviation Code");
1498
1499       // Emit the abbreviations data.
1500       Abbrev.Emit(*this);
1501
1502       O << "\n";
1503     }
1504
1505     EmitLabel("abbrev_end", 0);
1506
1507     O << "\n";
1508   }
1509 }
1510
1511 /// EmitDebugLines - Emit source line information.
1512 ///
1513 void DwarfWriter::EmitDebugLines() const {
1514   // Minimum line delta, thus ranging from -10..(255-10).
1515   const int MinLineDelta = -(DW_LNS_fixed_advance_pc + 1);
1516   // Maximum line delta, thus ranging from -10..(255-10).
1517   const int MaxLineDelta = 255 + MinLineDelta;
1518
1519   // Start the dwarf line section.
1520   Asm->SwitchSection(DwarfLineSection, 0);
1521
1522   // Construct the section header.
1523
1524   EmitDifference("line_end", 0, "line_begin", 0);
1525   EOL("Length of Source Line Info");
1526   EmitLabel("line_begin", 0);
1527
1528   EmitInt16(DWARF_VERSION); EOL("DWARF version number");
1529
1530   EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0);
1531   EOL("Prolog Length");
1532   EmitLabel("line_prolog_begin", 0);
1533
1534   EmitInt8(1); EOL("Minimum Instruction Length");
1535
1536   EmitInt8(1); EOL("Default is_stmt_start flag");
1537
1538   EmitInt8(MinLineDelta);  EOL("Line Base Value (Special Opcodes)");
1539
1540   EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
1541
1542   EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
1543
1544   // Line number standard opcode encodings argument count
1545   EmitInt8(0); EOL("DW_LNS_copy arg count");
1546   EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
1547   EmitInt8(1); EOL("DW_LNS_advance_line arg count");
1548   EmitInt8(1); EOL("DW_LNS_set_file arg count");
1549   EmitInt8(1); EOL("DW_LNS_set_column arg count");
1550   EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
1551   EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
1552   EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
1553   EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
1554
1555   const UniqueVector<std::string> &Directories = DebugInfo->getDirectories();
1556   const UniqueVector<SourceFileInfo> &SourceFiles = DebugInfo->getSourceFiles();
1557
1558   // Emit directories.
1559   for (unsigned DirectoryID = 1, NDID = Directories.size();
1560                 DirectoryID <= NDID; ++DirectoryID) {
1561     EmitString(Directories[DirectoryID]); EOL("Directory");
1562   }
1563   EmitInt8(0); EOL("End of directories");
1564
1565   // Emit files.
1566   for (unsigned SourceID = 1, NSID = SourceFiles.size();
1567                SourceID <= NSID; ++SourceID) {
1568     const SourceFileInfo &SourceFile = SourceFiles[SourceID];
1569     EmitString(SourceFile.getName()); EOL("Source");
1570     EmitULEB128Bytes(SourceFile.getDirectoryID());  EOL("Directory #");
1571     EmitULEB128Bytes(0);  EOL("Mod date");
1572     EmitULEB128Bytes(0);  EOL("File size");
1573   }
1574   EmitInt8(0); EOL("End of files");
1575
1576   EmitLabel("line_prolog_end", 0);
1577
1578   // Emit line information
1579   const std::vector<SourceLineInfo *> &LineInfos = DebugInfo->getSourceLines();
1580
1581   // Dwarf assumes we start with first line of first source file.
1582   unsigned Source = 1;
1583   unsigned Line = 1;
1584
1585   // Construct rows of the address, source, line, column matrix.
1586   for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
1587     SourceLineInfo *LineInfo = LineInfos[i];
1588
1589     if (DwarfVerbose) {
1590       unsigned SourceID = LineInfo->getSourceID();
1591       const SourceFileInfo &SourceFile = SourceFiles[SourceID];
1592       unsigned DirectoryID = SourceFile.getDirectoryID();
1593       O << "\t"
1594         << Asm->CommentString << " "
1595         << Directories[DirectoryID]
1596         << SourceFile.getName() << ":"
1597         << LineInfo->getLine() << "\n";
1598     }
1599
1600     // Define the line address.
1601     EmitInt8(0); EOL("Extended Op");
1602     EmitInt8(4 + 1); EOL("Op size");
1603     EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address");
1604     EmitReference("loc", i + 1); EOL("Location label");
1605
1606     // If change of source, then switch to the new source.
1607     if (Source != LineInfo->getSourceID()) {
1608       Source = LineInfo->getSourceID();
1609       EmitInt8(DW_LNS_set_file); EOL("DW_LNS_set_file");
1610       EmitULEB128Bytes(Source); EOL("New Source");
1611     }
1612
1613     // If change of line.
1614     if (Line != LineInfo->getLine()) {
1615       // Determine offset.
1616       int Offset = LineInfo->getLine() - Line;
1617       int Delta = Offset - MinLineDelta;
1618
1619       // Update line.
1620       Line = LineInfo->getLine();
1621
1622       // If delta is small enough and in range...
1623       if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
1624         // ... then use fast opcode.
1625         EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
1626       } else {
1627         // ... otherwise use long hand.
1628         EmitInt8(DW_LNS_advance_line); EOL("DW_LNS_advance_line");
1629         EmitSLEB128Bytes(Offset); EOL("Line Offset");
1630         EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy");
1631       }
1632     } else {
1633       // Copy the previous row (different address or source)
1634       EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy");
1635     }
1636   }
1637
1638   // Define last address.
1639   EmitInt8(0); EOL("Extended Op");
1640   EmitInt8(4 + 1); EOL("Op size");
1641   EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address");
1642   EmitReference("text_end", 0); EOL("Location label");
1643
1644   // Mark end of matrix.
1645   EmitInt8(0); EOL("DW_LNE_end_sequence");
1646   EmitULEB128Bytes(1);  O << "\n";
1647   EmitInt8(1); O << "\n";
1648
1649   EmitLabel("line_end", 0);
1650
1651   O << "\n";
1652 }
1653
1654 /// EmitDebugFrame - Emit visible names into a debug frame section.
1655 ///
1656 void DwarfWriter::EmitDebugFrame() {
1657   // FIXME - Should be per frame
1658 }
1659
1660 /// EmitDebugPubNames - Emit visible names into a debug pubnames section.
1661 ///
1662 void DwarfWriter::EmitDebugPubNames() {
1663   // Start the dwarf pubnames section.
1664   Asm->SwitchSection(DwarfPubNamesSection, 0);
1665
1666   // Process each compile unit.
1667   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1668     CompileUnit *Unit = CompileUnits[i];
1669
1670     if (Unit->hasContent()) {
1671       EmitDifference("pubnames_end", Unit->getID(),
1672                      "pubnames_begin", Unit->getID());
1673       EOL("Length of Public Names Info");
1674
1675       EmitLabel("pubnames_begin", Unit->getID());
1676
1677       EmitInt16(DWARF_VERSION); EOL("DWARF Version");
1678
1679       EmitReference("info_begin", Unit->getID());
1680       EOL("Offset of Compilation Unit Info");
1681
1682       EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID());
1683       EOL("Compilation Unit Length");
1684
1685       std::map<std::string, DIE *> &Globals = Unit->getGlobals();
1686
1687       for (std::map<std::string, DIE *>::iterator GI = Globals.begin(),
1688                                                   GE = Globals.end();
1689            GI != GE; ++GI) {
1690         const std::string &Name = GI->first;
1691         DIE * Entity = GI->second;
1692
1693         EmitInt32(Entity->getOffset()); EOL("DIE offset");
1694         EmitString(Name); EOL("External Name");
1695       }
1696
1697       EmitInt32(0); EOL("End Mark");
1698       EmitLabel("pubnames_end", Unit->getID());
1699
1700       O << "\n";
1701     }
1702   }
1703 }
1704
1705 /// EmitDebugStr - Emit visible names into a debug str section.
1706 ///
1707 void DwarfWriter::EmitDebugStr() {
1708   // Check to see if it is worth the effort.
1709   if (!StringPool.empty()) {
1710     // Start the dwarf str section.
1711     Asm->SwitchSection(DwarfStrSection, 0);
1712
1713     // For each of strings in teh string pool.
1714     for (unsigned StringID = 1, N = StringPool.size();
1715          StringID <= N; ++StringID) {
1716       // Emit a label for reference from debug information entries.
1717       EmitLabel("string", StringID);
1718       // Emit the string itself.
1719       const std::string &String = StringPool[StringID];
1720       EmitString(String); O << "\n";
1721     }
1722
1723     O << "\n";
1724   }
1725 }
1726
1727 /// EmitDebugLoc - Emit visible names into a debug loc section.
1728 ///
1729 void DwarfWriter::EmitDebugLoc() {
1730   // Start the dwarf loc section.
1731   Asm->SwitchSection(DwarfLocSection, 0);
1732
1733   O << "\n";
1734 }
1735
1736 /// EmitDebugARanges - Emit visible names into a debug aranges section.
1737 ///
1738 void DwarfWriter::EmitDebugARanges() {
1739   // Start the dwarf aranges section.
1740   Asm->SwitchSection(DwarfARangesSection, 0);
1741
1742   // FIXME - Mock up
1743 #if 0
1744   // Process each compile unit.
1745   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1746     CompileUnit *Unit = CompileUnits[i];
1747
1748     if (Unit->hasContent()) {
1749       // Don't include size of length
1750       EmitInt32(0x1c); EOL("Length of Address Ranges Info");
1751
1752       EmitInt16(DWARF_VERSION); EOL("Dwarf Version");
1753
1754       EmitReference("info_begin", Unit->getID());
1755       EOL("Offset of Compilation Unit Info");
1756
1757       EmitInt8(AddressSize); EOL("Size of Address");
1758
1759       EmitInt8(0); EOL("Size of Segment Descriptor");
1760
1761       EmitInt16(0);  EOL("Pad (1)");
1762       EmitInt16(0);  EOL("Pad (2)");
1763
1764       // Range 1
1765       EmitReference("text_begin", 0); EOL("Address");
1766       EmitDifference("text_end", 0, "text_begin", 0); EOL("Length");
1767
1768       EmitInt32(0); EOL("EOM (1)");
1769       EmitInt32(0); EOL("EOM (2)");
1770
1771       O << "\n";
1772     }
1773   }
1774 #endif
1775 }
1776
1777 /// EmitDebugRanges - Emit visible names into a debug ranges section.
1778 ///
1779 void DwarfWriter::EmitDebugRanges() {
1780   // Start the dwarf ranges section.
1781   Asm->SwitchSection(DwarfRangesSection, 0);
1782
1783   O << "\n";
1784 }
1785
1786 /// EmitDebugMacInfo - Emit visible names into a debug macinfo section.
1787 ///
1788 void DwarfWriter::EmitDebugMacInfo() {
1789   // Start the dwarf macinfo section.
1790   Asm->SwitchSection(DwarfMacInfoSection, 0);
1791
1792   O << "\n";
1793 }
1794
1795 /// ConstructCompileUnitDIEs - Create a compile unit DIE for each source and
1796 /// header file.
1797 void DwarfWriter::ConstructCompileUnitDIEs() {
1798   const UniqueVector<CompileUnitDesc *> CUW = DebugInfo->getCompileUnits();
1799
1800   for (unsigned i = 1, N = CUW.size(); i <= N; ++i) {
1801     CompileUnit *Unit = NewCompileUnit(CUW[i], i);
1802     CompileUnits.push_back(Unit);
1803   }
1804 }
1805
1806 /// ConstructGlobalDIEs - Create DIEs for each of the externally visible global
1807 /// variables.
1808 void DwarfWriter::ConstructGlobalDIEs(Module &M) {
1809   std::vector<GlobalVariableDesc *> GlobalVariables =
1810                        DebugInfo->getAnchoredDescriptors<GlobalVariableDesc>(M);
1811
1812   for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) {
1813     GlobalVariableDesc *GVD = GlobalVariables[i];
1814     NewGlobalVariable(GVD);
1815   }
1816 }
1817
1818 /// ConstructSubprogramDIEs - Create DIEs for each of the externally visible
1819 /// subprograms.
1820 void DwarfWriter::ConstructSubprogramDIEs(Module &M) {
1821   std::vector<SubprogramDesc *> Subprograms =
1822                            DebugInfo->getAnchoredDescriptors<SubprogramDesc>(M);
1823
1824   for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) {
1825     SubprogramDesc *SPD = Subprograms[i];
1826     NewSubprogram(SPD);
1827   }
1828 }
1829
1830 /// ShouldEmitDwarf - Determine if Dwarf declarations should be made.
1831 ///
1832 bool DwarfWriter::ShouldEmitDwarf() {
1833   // Check if debug info is present.
1834   if (!DebugInfo || !DebugInfo->hasInfo()) return false;
1835
1836   // Make sure initial declarations are made.
1837   if (!didInitial) {
1838     EmitInitial();
1839     didInitial = true;
1840   }
1841
1842   // Okay to emit.
1843   return true;
1844 }
1845
1846 //===----------------------------------------------------------------------===//
1847 // Main entry points.
1848 //
1849
1850 DwarfWriter::DwarfWriter(std::ostream &OS, AsmPrinter *A)
1851 : O(OS)
1852 , Asm(A)
1853 , DebugInfo(NULL)
1854 , didInitial(false)
1855 , CompileUnits()
1856 , Abbreviations()
1857 , StringPool()
1858 , DescToUnitMap()
1859 , DescToDieMap()
1860 , TypeToDieMap()
1861 , AddressSize(sizeof(int32_t))
1862 , hasLEB128(false)
1863 , hasDotLoc(false)
1864 , hasDotFile(false)
1865 , needsSet(false)
1866 , DwarfAbbrevSection(".debug_abbrev")
1867 , DwarfInfoSection(".debug_info")
1868 , DwarfLineSection(".debug_line")
1869 , DwarfFrameSection(".debug_frame")
1870 , DwarfPubNamesSection(".debug_pubnames")
1871 , DwarfPubTypesSection(".debug_pubtypes")
1872 , DwarfStrSection(".debug_str")
1873 , DwarfLocSection(".debug_loc")
1874 , DwarfARangesSection(".debug_aranges")
1875 , DwarfRangesSection(".debug_ranges")
1876 , DwarfMacInfoSection(".debug_macinfo")
1877 , TextSection(".text")
1878 , DataSection(".data")
1879 {}
1880 DwarfWriter::~DwarfWriter() {
1881   for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) {
1882     delete CompileUnits[i];
1883   }
1884 }
1885
1886 /// BeginModule - Emit all Dwarf sections that should come prior to the content.
1887 ///
1888 void DwarfWriter::BeginModule(Module &M) {
1889   if (!ShouldEmitDwarf()) return;
1890   EOL("Dwarf Begin Module");
1891 }
1892
1893 /// EndModule - Emit all Dwarf sections that should come after the content.
1894 ///
1895 void DwarfWriter::EndModule(Module &M) {
1896   if (!ShouldEmitDwarf()) return;
1897   EOL("Dwarf End Module");
1898
1899   // Standard sections final addresses.
1900   Asm->SwitchSection(TextSection, 0);
1901   EmitLabel("text_end", 0);
1902   Asm->SwitchSection(DataSection, 0);
1903   EmitLabel("data_end", 0);
1904
1905   // Create all the compile unit DIEs.
1906   ConstructCompileUnitDIEs();
1907
1908   // Create DIEs for each of the externally visible global variables.
1909   ConstructGlobalDIEs(M);
1910
1911   // Create DIEs for each of the externally visible subprograms.
1912   ConstructSubprogramDIEs(M);
1913
1914   // Compute DIE offsets and sizes.
1915   SizeAndOffsets();
1916
1917   // Emit all the DIEs into a debug info section
1918   EmitDebugInfo();
1919
1920   // Corresponding abbreviations into a abbrev section.
1921   EmitAbbreviations();
1922
1923   // Emit source line correspondence into a debug line section.
1924   EmitDebugLines();
1925
1926   // Emit info into a debug frame section.
1927   // EmitDebugFrame();
1928
1929   // Emit info into a debug pubnames section.
1930   EmitDebugPubNames();
1931
1932   // Emit info into a debug str section.
1933   EmitDebugStr();
1934
1935   // Emit info into a debug loc section.
1936   EmitDebugLoc();
1937
1938   // Emit info into a debug aranges section.
1939   EmitDebugARanges();
1940
1941   // Emit info into a debug ranges section.
1942   EmitDebugRanges();
1943
1944   // Emit info into a debug macinfo section.
1945   EmitDebugMacInfo();
1946 }
1947
1948 /// BeginFunction - Gather pre-function debug information.
1949 ///
1950 void DwarfWriter::BeginFunction(MachineFunction &MF) {
1951   if (!ShouldEmitDwarf()) return;
1952   EOL("Dwarf Begin Function");
1953 }
1954
1955 /// EndFunction - Gather and emit post-function debug information.
1956 ///
1957 void DwarfWriter::EndFunction(MachineFunction &MF) {
1958   if (!ShouldEmitDwarf()) return;
1959   EOL("Dwarf End Function");
1960 }