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