Re-orging file.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26401 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 1804 insertions, 1664 deletions

diff --git a/include/llvm/CodeGen/DwarfWriter.h b/include/llvm/CodeGen/DwarfWriter.h
index b9953004df..1a1a29096a 100644
--- a/include/llvm/CodeGen/DwarfWriter.h
+++ b/include/llvm/CodeGen/DwarfWriter.h
@@ -28,728 +28,411 @@
 
 
 namespace llvm {
+
+// Forward declarations.
+
+class AsmPrinter;
+class CompileUnitDesc;
+class DebugInfoDesc;
+class DIE;
+class DIEAbbrev;
+class GlobalVariableDesc;
+class MachineDebugInfo;
+class MachineFunction;
+class Module;
+class SubprogramDesc;
+class Type;
+class TypeDesc;
+
   
+//===----------------------------------------------------------------------===//
+// DWLabel - Labels are used to track locations in the assembler file.
+// Labels appear in the form <prefix>debug_<Tag><Number>, where the tag is a
+// category of label (Ex. location) and number is a value unique in that
+// category.
+class DWLabel {
+public:
+  const char *Tag;                    // Label category tag. Should always be
+                                      // a staticly declared C string.
+  unsigned    Number;                 // Unique number.
+
+  DWLabel(const char *T, unsigned N) : Tag(T), Number(N) {}
+};
+
+//===----------------------------------------------------------------------===//
+// DwarfWriter - Emits Dwarf debug and exception handling directives.
+//
+class DwarfWriter {
+protected:
+
   //===--------------------------------------------------------------------===//
-  // Forward declarations.
+  // Core attributes used by the Dwarf  writer.
   //
-  class AsmPrinter;
-  class CompileUnitDesc;
-  class DebugInfoDesc;
-  class DIE;
-  class DwarfWriter;
-  class GlobalVariableDesc;
-  class MachineDebugInfo;
-  class MachineFunction;
-  class Module;
-  class SubprogramDesc;
-  class Type;
-  class TypeDesc;
   
-  //===--------------------------------------------------------------------===//
-  // DWLabel - Labels are used to track locations in the assembler file.
-  // Labels appear in the form <prefix>debug_<Tag><Number>, where the tag is a
-  // category of label (Ex. location) and number is a value unique in that
-  // category.
-  class DWLabel {
-  public:
-    const char *Tag;                    // Label category tag. Should always be
-                                        // a staticly declared C string.
-    unsigned    Number;                 // Unique number.
-
-    DWLabel(const char *T, unsigned N) : Tag(T), Number(N) {}
-  };
+  //
+  /// O - Stream to .s file.
+  ///
+  std::ostream &O;
+
+  /// Asm - Target of Dwarf emission.
+  ///
+  AsmPrinter *Asm;
   
-  //===--------------------------------------------------------------------===//
-  // DIEAbbrevData - Dwarf abbreviation data, describes the one attribute of a
-  // Dwarf abbreviation.
-  class DIEAbbrevData {
-  private:
-    unsigned Attribute;                 // Dwarf attribute code.
-    unsigned Form;                      // Dwarf form code.
-    
-  public:
-    DIEAbbrevData(unsigned A, unsigned F)
-    : Attribute(A)
-    , Form(F)
-    {}
-    
-    // Accessors
-    unsigned getAttribute() const { return Attribute; }
-    unsigned getForm()      const { return Form; }
-    
-    /// operator== - Used by DIEAbbrev to locate entry.
-    ///
-    bool operator==(const DIEAbbrevData &DAD) const {
-      return Attribute == DAD.Attribute && Form == DAD.Form;
-    }
-
-    /// operator!= - Used by DIEAbbrev to locate entry.
-    ///
-    bool operator!=(const DIEAbbrevData &DAD) const {
-      return Attribute != DAD.Attribute || Form != DAD.Form;
-    }
-    
-    /// operator< - Used by DIEAbbrev to locate entry.
-    ///
-    bool operator<(const DIEAbbrevData &DAD) const {
-      return Attribute < DAD.Attribute ||
-            (Attribute == DAD.Attribute && Form < DAD.Form);
-    }
-  };
+  /// DebugInfo - Collected debug information.
+  ///
+  MachineDebugInfo *DebugInfo;
+  
+  /// didInitial - Flag to indicate if initial emission has been done.
+  ///
+  bool didInitial;
   
   //===--------------------------------------------------------------------===//
-  // DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
-  // information object.
-  class DIEAbbrev {
-  private:
-    unsigned Tag;                       // Dwarf tag code.
-    unsigned ChildrenFlag;              // Dwarf children flag.
-    std::vector<DIEAbbrevData> Data;    // Raw data bytes for abbreviation.
-
-  public:
-  
-    DIEAbbrev(unsigned T, unsigned C)
-    : Tag(T)
-    , ChildrenFlag(C)
-    , Data()
-    {}
-    ~DIEAbbrev() {}
-    
-    // Accessors
-    unsigned getTag()                           const { return Tag; }
-    unsigned getChildrenFlag()                  const { return ChildrenFlag; }
-    const std::vector<DIEAbbrevData> &getData() const { return Data; }
-    void setChildrenFlag(unsigned CF)                 { ChildrenFlag = CF; }
-
-    /// operator== - Used by UniqueVector to locate entry.
-    ///
-    bool operator==(const DIEAbbrev &DA) const;
-
-    /// operator< - Used by UniqueVector to locate entry.
-    ///
-    bool operator<(const DIEAbbrev &DA) const;
-
-    /// AddAttribute - Adds another set of attribute information to the
-    /// abbreviation.
-    void AddAttribute(unsigned Attribute, unsigned Form) {
-      Data.push_back(DIEAbbrevData(Attribute, Form));
-    }
-    
-    /// Emit - Print the abbreviation using the specified Dwarf writer.
-    ///
-    void Emit(const DwarfWriter &DW) const; 
-        
-#ifndef NDEBUG
-    void print(std::ostream &O);
-    void dump();
-#endif
-  };
+  // Attributes used to construct specific Dwarf sections.
+  //
+  
+  /// CompileUnits - All the compile units involved in this build.  The index
+  /// of each entry in this vector corresponds to the sources in DebugInfo.
+  std::vector<DIE *> CompileUnits;
 
+  /// Abbreviations - A UniqueVector of TAG structure abbreviations.
+  ///
+  UniqueVector<DIEAbbrev> Abbreviations;
+  
+  /// GlobalTypes - A map of globally visible named types.
+  ///
+  std::map<std::string, DIE *> GlobalTypes;
+  
+  /// GlobalEntities - A map of globally visible named entities.
+  ///
+  std::map<std::string, DIE *> GlobalEntities;
+   
+  /// StringPool - A UniqueVector of strings used by indirect references.
+  ///
+  UniqueVector<std::string> StringPool;
+  
+  /// DescToDieMap - Tracks the mapping of debug informaton descriptors to
+  /// DIES.
+  std::map<DebugInfoDesc *, DIE *> DescToDieMap;
+  
+  /// TypeToDieMap - Type to DIEType map.
+  ///
+  // FIXME - Should not be needed.
+  std::map<Type *, DIE *> TypeToDieMap;
+  
   //===--------------------------------------------------------------------===//
-  // DIEValue - A debug information entry value.
+  // Properties to be set by the derived class ctor, used to configure the
+  // Dwarf writer.
   //
-  class DIEValue {
-  public:
-    enum {
-      isInteger,
-      isString,
-      isLabel,
-      isAsIsLabel,
-      isDelta,
-      isEntry
-    };
-    
-    unsigned Type;                      // Type of the value
-    
-    DIEValue(unsigned T) : Type(T) {}
-    virtual ~DIEValue() {}
-    
-    // Implement isa/cast/dyncast.
-    static bool classof(const DIEValue *) { return true; }
-    
-    /// EmitValue - Emit value via the Dwarf writer.
-    ///
-    virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const = 0;
-    
-    /// SizeOf - Return the size of a value in bytes.
-    ///
-    virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const = 0;
-  };
+  
+  /// AddressSize - Size of addresses used in file.
+  ///
+  unsigned AddressSize;
 
-  //===--------------------------------------------------------------------===//
-  // DWInteger - An integer value DIE.
-  // 
-  class DIEInteger : public DIEValue {
-  private:
-    uint64_t Integer;
-    
-  public:
-    DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
-
-    // Implement isa/cast/dyncast.
-    static bool classof(const DIEInteger *) { return true; }
-    static bool classof(const DIEValue *I)  { return I->Type == isInteger; }
-    
-    /// EmitValue - Emit integer of appropriate size.
-    ///
-    virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
-    
-    /// SizeOf - Determine size of integer value in bytes.
-    ///
-    virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
-  };
+  /// hasLEB128 - True if target asm supports leb128 directives.
+  ///
+  bool hasLEB128; /// Defaults to false.
+  
+  /// hasDotLoc - True if target asm supports .loc directives.
+  ///
+  bool hasDotLoc; /// Defaults to false.
+  
+  /// hasDotFile - True if target asm supports .file directives.
+  ///
+  bool hasDotFile; /// Defaults to false.
+  
+  /// needsSet - True if target asm can't compute addresses on data
+  /// directives.
+  bool needsSet; /// Defaults to false.
+  
+  /// DwarfAbbrevSection - Section directive for Dwarf abbrev.
+  ///
+  const char *DwarfAbbrevSection; /// Defaults to ".debug_abbrev".
 
-  //===--------------------------------------------------------------------===//
-  // DIEString - A string value DIE.
-  // 
-  struct DIEString : public DIEValue {
-    const std::string String;
-    
-    DIEString(const std::string &S) : DIEValue(isString), String(S) {}
-
-    // Implement isa/cast/dyncast.
-    static bool classof(const DIEString *) { return true; }
-    static bool classof(const DIEValue *S) { return S->Type == isString; }
-    
-    /// EmitValue - Emit string value.
-    ///
-    virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
-    
-    /// SizeOf - Determine size of string value in bytes.
-    ///
-    virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
-  };
+  /// DwarfInfoSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfInfoSection; /// Defaults to ".debug_info".
 
-  //===--------------------------------------------------------------------===//
-  // DIEDwarfLabel - A Dwarf internal label expression DIE.
-  //
-  struct DIEDwarfLabel : public DIEValue {
-    const DWLabel Label;
-    
-    DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {}
-
-    // Implement isa/cast/dyncast.
-    static bool classof(const DIEDwarfLabel *)  { return true; }
-    static bool classof(const DIEValue *L) { return L->Type == isLabel; }
-    
-    /// EmitValue - Emit label value.
-    ///
-    virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
-    
-    /// SizeOf - Determine size of label value in bytes.
-    ///
-    virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
-  };
+  /// DwarfLineSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfLineSection; /// Defaults to ".debug_line".
+  
+  /// DwarfFrameSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfFrameSection; /// Defaults to ".debug_frame".
+  
+  /// DwarfPubNamesSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfPubNamesSection; /// Defaults to ".debug_pubnames".
+  
+  /// DwarfPubTypesSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfPubTypesSection; /// Defaults to ".debug_pubtypes".
+  
+  /// DwarfStrSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfStrSection; /// Defaults to ".debug_str".
 
+  /// DwarfLocSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfLocSection; /// Defaults to ".debug_loc".
+
+  /// DwarfARangesSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfARangesSection; /// Defaults to ".debug_aranges".
+
+  /// DwarfRangesSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfRangesSection; /// Defaults to ".debug_ranges".
+
+  /// DwarfMacInfoSection - Section directive for Dwarf info.
+  ///
+  const char *DwarfMacInfoSection; /// Defaults to ".debug_macinfo".
+
+  /// TextSection - Section directive for standard text.
+  ///
+  const char *TextSection; /// Defaults to ".text".
+  
+  /// DataSection - Section directive for standard data.
+  ///
+  const char *DataSection; /// Defaults to ".data".
 
   //===--------------------------------------------------------------------===//
-  // DIEObjectLabel - A label to an object in code or data.
+  // Emission and print routines
   //
-  struct DIEObjectLabel : public DIEValue {
-    const std::string Label;
-    
-    DIEObjectLabel(const std::string &L) : DIEValue(isAsIsLabel), Label(L) {}
-
-    // Implement isa/cast/dyncast.
-    static bool classof(const DIEObjectLabel *) { return true; }
-    static bool classof(const DIEValue *L)    { return L->Type == isAsIsLabel; }
-    
-    /// EmitValue - Emit label value.
-    ///
-    virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
-    
-    /// SizeOf - Determine size of label value in bytes.
-    ///
-    virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
-  };
 
-  //===--------------------------------------------------------------------===//
-  // DIEDelta - A simple label difference DIE.
-  // 
-  struct DIEDelta : public DIEValue {
-    const DWLabel LabelHi;
-    const DWLabel LabelLo;
-    
-    DIEDelta(const DWLabel &Hi, const DWLabel &Lo)
-    : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
-
-    // Implement isa/cast/dyncast.
-    static bool classof(const DIEDelta *)  { return true; }
-    static bool classof(const DIEValue *D) { return D->Type == isDelta; }
-    
-    /// EmitValue - Emit delta value.
-    ///
-    virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
-    
-    /// SizeOf - Determine size of delta value in bytes.
-    ///
-    virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
-  };
+public:
+  /// getAddressSize - Return the size of a target address in bytes.
+  ///
+  unsigned getAddressSize() const { return AddressSize; }
+
+  /// PrintHex - Print a value as a hexidecimal value.
+  ///
+  void PrintHex(int Value) const;
+
+  /// EOL - Print a newline character to asm stream.  If a comment is present
+  /// then it will be printed first.  Comments should not contain '\n'.
+  void EOL(const std::string &Comment) const;
+                                        
+  /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
+  /// unsigned leb128 value.
+  void EmitULEB128Bytes(unsigned Value) const;
   
-  //===--------------------------------------------------------------------===//
-  // DIEntry - A pointer to a debug information entry.
-  // 
-  struct DIEntry : public DIEValue {
-    DIE *Entry;
-    
-    DIEntry(DIE *E) : DIEValue(isEntry), Entry(E) {}
-
-    // Implement isa/cast/dyncast.
-    static bool classof(const DIEntry *)   { return true; }
-    static bool classof(const DIEValue *E) { return E->Type == isEntry; }
-    
-    /// EmitValue - Emit delta value.
-    ///
-    virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const;
-    
-    /// SizeOf - Determine size of delta value in bytes.
-    ///
-    virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const;
-  };
+  /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
+  /// signed leb128 value.
+  void EmitSLEB128Bytes(int Value) const;
   
-  //===--------------------------------------------------------------------===//
-  // DIE - A structured debug information entry.  Has an abbreviation which
-  // describes it's organization.
-  class DIE {
-  private:
-    DIEAbbrev *Abbrev;                    // Temporary buffer for abbreviation.
-    unsigned AbbrevID;                    // Decribing abbreviation ID.
-    unsigned Offset;                      // Offset in debug info section.
-    unsigned Size;                        // Size of instance + children.
-    std::vector<DIE *> Children;          // Children DIEs.
-    std::vector<DIEValue *> Values;       // Attributes values.
-    
-  public:
-    DIE(unsigned Tag);
-    ~DIE();
-    
-    // Accessors
-    unsigned   getAbbrevID()                   const { return AbbrevID; }
-    unsigned   getOffset()                     const { return Offset; }
-    unsigned   getSize()                       const { return Size; }
-    const std::vector<DIE *> &getChildren()    const { return Children; }
-    const std::vector<DIEValue *> &getValues() const { return Values; }
-    void setOffset(unsigned O)                 { Offset = O; }
-    void setSize(unsigned S)                   { Size = S; }
-    
-    /// SiblingOffset - Return the offset of the debug information entry's
-    /// sibling.
-    unsigned SiblingOffset() const { return Offset + Size; }
-
-    /// AddUInt - Add an unsigned integer attribute data and value.
-    ///
-    void AddUInt(unsigned Attribute, unsigned Form, uint64_t Integer);
-
-    /// AddSInt - Add an signed integer attribute data and value.
-    ///
-    void AddSInt(unsigned Attribute, unsigned Form, int64_t Integer);
-        
-    /// AddString - Add a std::string attribute data and value.
-    ///
-    void AddString(unsigned Attribute, unsigned Form,
-                   const std::string &String);
-        
-    /// AddLabel - Add a Dwarf label attribute data and value.
-    ///
-    void AddLabel(unsigned Attribute, unsigned Form, const DWLabel &Label);
-        
-    /// AddObjectLabel - Add a non-Dwarf label attribute data and value.
-    ///
-    void AddObjectLabel(unsigned Attribute, unsigned Form,
-                        const std::string &Label);
-        
-    /// AddDelta - Add a label delta attribute data and value.
-    ///
-    void AddDelta(unsigned Attribute, unsigned Form,
-                  const DWLabel &Hi, const DWLabel &Lo);
-        
-    ///  AddDIEntry - Add a DIE attribute data and value.
-    ///
-    void AddDIEntry(unsigned Attribute, unsigned Form, DIE *Entry);
-
-    /// Complete - Indicate that all attributes have been added and
-    /// ready to get an abbreviation ID.
-    ///
-    void Complete(DwarfWriter &DW);
-    
-    /// AddChild - Add a child to the DIE.
-    void AddChild(DIE *Child);
-  };
+  /// PrintULEB128 - Print a series of hexidecimal values (separated by
+  /// commas) representing an unsigned leb128 value.
+  void PrintULEB128(unsigned Value) const;
+
+  /// SizeULEB128 - Compute the number of bytes required for an unsigned
+  /// leb128 value.
+  static unsigned SizeULEB128(unsigned Value);
   
-  //===--------------------------------------------------------------------===//
-  // DwarfWriter - Emits Dwarf debug and exception handling directives.
-  //
-  class DwarfWriter {
-  protected:
-  
-    //===------------------------------------------------------------------===//
-    // Core attributes used by the Dwarf  writer.
-    //
-    
-    //
-    /// O - Stream to .s file.
-    ///
-    std::ostream &O;
-
-    /// Asm - Target of Dwarf emission.
-    ///
-    AsmPrinter *Asm;
-    
-    /// DebugInfo - Collected debug information.
-    ///
-    MachineDebugInfo *DebugInfo;
-    
-    /// didInitial - Flag to indicate if initial emission has been done.
-    ///
-    bool didInitial;
-    
-    //===------------------------------------------------------------------===//
-    // Attributes used to construct specific Dwarf sections.
-    //
-    
-    /// CompileUnits - All the compile units involved in this build.  The index
-    /// of each entry in this vector corresponds to the sources in DebugInfo.
-    std::vector<DIE *> CompileUnits;
-
-    /// Abbreviations - A UniqueVector of TAG structure abbreviations.
-    ///
-    UniqueVector<DIEAbbrev> Abbreviations;
-    
-    /// GlobalTypes - A map of globally visible named types.
-    ///
-    std::map<std::string, DIE *> GlobalTypes;
-    
-    /// GlobalEntities - A map of globally visible named entities.
-    ///
-    std::map<std::string, DIE *> GlobalEntities;
-     
-    /// StringPool - A UniqueVector of strings used by indirect references.
-    ///
-    UniqueVector<std::string> StringPool;
-    
-    /// DescToDieMap - Tracks the mapping of debug informaton descriptors to
-    /// DIES.
-    std::map<DebugInfoDesc *, DIE *> DescToDieMap;
-    
-    /// TypeToDieMap - Type to DIEType map.
-    ///
-    // FIXME - Should not be needed.
-    std::map<Type *, DIE *> TypeToDieMap;
-    
-    //===------------------------------------------------------------------===//
-    // Properties to be set by the derived class ctor, used to configure the
-    // Dwarf writer.
-    //
-    
-    /// AddressSize - Size of addresses used in file.
-    ///
-    unsigned AddressSize;
-
-    /// hasLEB128 - True if target asm supports leb128 directives.
-    ///
-    bool hasLEB128; /// Defaults to false.
-    
-    /// hasDotLoc - True if target asm supports .loc directives.
-    ///
-    bool hasDotLoc; /// Defaults to false.
-    
-    /// hasDotFile - True if target asm supports .file directives.
-    ///
-    bool hasDotFile; /// Defaults to false.
-    
-    /// needsSet - True if target asm can't compute addresses on data
-    /// directives.
-    bool needsSet; /// Defaults to false.
-    
-    /// DwarfAbbrevSection - Section directive for Dwarf abbrev.
-    ///
-    const char *DwarfAbbrevSection; /// Defaults to ".debug_abbrev".
-
-    /// DwarfInfoSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfInfoSection; /// Defaults to ".debug_info".
-
-    /// DwarfLineSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfLineSection; /// Defaults to ".debug_line".
-    
-    /// DwarfFrameSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfFrameSection; /// Defaults to ".debug_frame".
-    
-    /// DwarfPubNamesSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfPubNamesSection; /// Defaults to ".debug_pubnames".
-    
-    /// DwarfPubTypesSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfPubTypesSection; /// Defaults to ".debug_pubtypes".
-    
-    /// DwarfStrSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfStrSection; /// Defaults to ".debug_str".
-
-    /// DwarfLocSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfLocSection; /// Defaults to ".debug_loc".
-
-    /// DwarfARangesSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfARangesSection; /// Defaults to ".debug_aranges".
-
-    /// DwarfRangesSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfRangesSection; /// Defaults to ".debug_ranges".
-
-    /// DwarfMacInfoSection - Section directive for Dwarf info.
-    ///
-    const char *DwarfMacInfoSection; /// Defaults to ".debug_macinfo".
-
-    /// TextSection - Section directive for standard text.
-    ///
-    const char *TextSection; /// Defaults to ".text".
-    
-    /// DataSection - Section directive for standard data.
-    ///
-    const char *DataSection; /// Defaults to ".data".
-
-    //===------------------------------------------------------------------===//
-    // Emission and print routines
-    //
+  /// PrintSLEB128 - Print a series of hexidecimal values (separated by
+  /// commas) representing a signed leb128 value.
+  void PrintSLEB128(int Value) const;
+  
+  /// SizeSLEB128 - Compute the number of bytes required for a signed leb128
+  /// value.
+  static unsigned SizeSLEB128(int Value);
+  
+  /// EmitInt8 - Emit a byte directive and value.
+  ///
+  void EmitInt8(int Value) const;
 
-public:
-    /// getAddressSize - Return the size of a target address in bytes.
-    ///
-    unsigned getAddressSize() const { return AddressSize; }
-
-    /// PrintHex - Print a value as a hexidecimal value.
-    ///
-    void PrintHex(int Value) const;
-
-    /// EOL - Print a newline character to asm stream.  If a comment is present
-    /// then it will be printed first.  Comments should not contain '\n'.
-    void EOL(const std::string &Comment) const;
-                                          
-    /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
-    /// unsigned leb128 value.
-    void EmitULEB128Bytes(unsigned Value) const;
-    
-    /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
-    /// signed leb128 value.
-    void EmitSLEB128Bytes(int Value) const;
-    
-    /// PrintULEB128 - Print a series of hexidecimal values (separated by
-    /// commas) representing an unsigned leb128 value.
-    void PrintULEB128(unsigned Value) const;
-
-    /// SizeULEB128 - Compute the number of bytes required for an unsigned
-    /// leb128 value.
-    static unsigned SizeULEB128(unsigned Value);
-    
-    /// PrintSLEB128 - Print a series of hexidecimal values (separated by
-    /// commas) representing a signed leb128 value.
-    void PrintSLEB128(int Value) const;
-    
-    /// SizeSLEB128 - Compute the number of bytes required for a signed leb128
-    /// value.
-    static unsigned SizeSLEB128(int Value);
-    
-    /// EmitInt8 - Emit a byte directive and value.
-    ///
-    void EmitInt8(int Value) const;
-
-    /// EmitInt16 - Emit a short directive and value.
-    ///
-    void EmitInt16(int Value) const;
-
-    /// EmitInt32 - Emit a long directive and value.
-    ///
-    void EmitInt32(int Value) const;
-    
-    /// EmitInt64 - Emit a long long directive and value.
-    ///
-    void EmitInt64(uint64_t Value) const;
-    
-    /// EmitString - Emit a string with quotes and a null terminator.
-    /// Special characters are emitted properly. (Eg. '\t')
-    void EmitString(const std::string &String) const;
-
-    /// PrintLabelName - Print label name in form used by Dwarf writer.
-    ///
-    void PrintLabelName(DWLabel Label) const {
-      PrintLabelName(Label.Tag, Label.Number);
-    }
-    void PrintLabelName(const char *Tag, unsigned Number) const;
-    
-    /// EmitLabel - Emit location label for internal use by Dwarf.
-    ///
-    void EmitLabel(DWLabel Label) const {
-      EmitLabel(Label.Tag, Label.Number);
-    }
-    void EmitLabel(const char *Tag, unsigned Number) const;
-    
-    /// EmitReference - Emit a reference to a label.
-    ///
-    void EmitReference(DWLabel Label) const {
-      EmitReference(Label.Tag, Label.Number);
-    }
-    void EmitReference(const char *Tag, unsigned Number) const;
-    void EmitReference(const std::string &Name) const;
-
-    /// EmitDifference - Emit the difference between two labels.  Some
-    /// assemblers do not behave with absolute expressions with data directives,
-    /// so there is an option (needsSet) to use an intermediary set expression.
-    void EmitDifference(DWLabel LabelHi, DWLabel LabelLo) const {
-      EmitDifference(LabelHi.Tag, LabelHi.Number, LabelLo.Tag, LabelLo.Number);
-    }
-    void EmitDifference(const char *TagHi, unsigned NumberHi,
-                        const char *TagLo, unsigned NumberLo) const;
-                                   
-    /// NewAbbreviation - Add the abbreviation to the Abbreviation vector.
-    ///  
-    unsigned NewAbbreviation(DIEAbbrev *Abbrev);
-    
-    /// NewString - Add a string to the constant pool and returns a label.
-    ///
-    DWLabel NewString(const std::string &String);
-    
-    /// NewBasicType - Creates a new basic type if necessary, then adds to the
-    /// owner.
-    /// FIXME - Should never be needed.
-    DIE *NewBasicType(DIE *Owner, Type *Ty);
-
-    /// NewGlobalType - Make the type visible globally using the given name.
-    ///
-    void NewGlobalType(const std::string &Name, DIE *Type);
-    
-    /// NewGlobalEntity - Make the entity visible globally using the given name.
-    ///
-    void NewGlobalEntity(const std::string &Name, DIE *Entity);
+  /// EmitInt16 - Emit a short directive and value.
+  ///
+  void EmitInt16(int Value) const;
+
+  /// EmitInt32 - Emit a long directive and value.
+  ///
+  void EmitInt32(int Value) const;
+  
+  /// EmitInt64 - Emit a long long directive and value.
+  ///
+  void EmitInt64(uint64_t Value) const;
+  
+  /// EmitString - Emit a string with quotes and a null terminator.
+  /// Special characters are emitted properly. (Eg. '\t')
+  void EmitString(const std::string &String) const;
+
+  /// PrintLabelName - Print label name in form used by Dwarf writer.
+  ///
+  void PrintLabelName(DWLabel Label) const {
+    PrintLabelName(Label.Tag, Label.Number);
+  }
+  void PrintLabelName(const char *Tag, unsigned Number) const;
+  
+  /// EmitLabel - Emit location label for internal use by Dwarf.
+  ///
+  void EmitLabel(DWLabel Label) const {
+    EmitLabel(Label.Tag, Label.Number);
+  }
+  void EmitLabel(const char *Tag, unsigned Number) const;
+  
+  /// EmitReference - Emit a reference to a label.
+  ///
+  void EmitReference(DWLabel Label) const {
+    EmitReference(Label.Tag, Label.Number);
+  }
+  void EmitReference(const char *Tag, unsigned Number) const;
+  void EmitReference(const std::string &Name) const;
+
+  /// EmitDifference - Emit the difference between two labels.  Some
+  /// assemblers do not behave with absolute expressions with data directives,
+  /// so there is an option (needsSet) to use an intermediary set expression.
+  void EmitDifference(DWLabel LabelHi, DWLabel LabelLo) const {
+    EmitDifference(LabelHi.Tag, LabelHi.Number, LabelLo.Tag, LabelLo.Number);
+  }
+  void EmitDifference(const char *TagHi, unsigned NumberHi,
+                      const char *TagLo, unsigned NumberLo) const;
+                                 
+  /// NewAbbreviation - Add the abbreviation to the Abbreviation vector.
+  ///  
+  unsigned NewAbbreviation(DIEAbbrev *Abbrev);
+  
+  /// NewString - Add a string to the constant pool and returns a label.
+  ///
+  DWLabel NewString(const std::string &String);
+  
+  /// NewBasicType - Creates a new basic type if necessary, then adds to the
+  /// owner.
+  /// FIXME - Should never be needed.
+  DIE *NewBasicType(DIE *Owner, Type *Ty);
+
+  /// NewGlobalType - Make the type visible globally using the given name.
+  ///
+  void NewGlobalType(const std::string &Name, DIE *Type);
+  
+  /// NewGlobalEntity - Make the entity visible globally using the given name.
+  ///
+  void NewGlobalEntity(const std::string &Name, DIE *Entity);
 
 private:
 
-    /// NewType - Create a new type DIE.
-    ///
-    DIE *NewType(DIE *Unit, TypeDesc *TyDesc);
-    
-    /// NewCompileUnit - Create new compile unit DIE.
-    ///
-    DIE *NewCompileUnit(CompileUnitDesc *CompileUnit);
-    
-    /// NewGlobalVariable - Make a new global variable DIE.
-    ///
-    DIE *NewGlobalVariable(GlobalVariableDesc *GVD);
-
-    /// NewSubprogram - Add a new subprogram DIE.
-    ///
-    DIE *NewSubprogram(SubprogramDesc *SPD);
-
-    /// EmitInitial - Emit initial Dwarf declarations.
-    ///
-    void EmitInitial() const;
-    
-    /// EmitDIE - Recusively Emits a debug information entry.
-    ///
-    void EmitDIE(DIE *Die) const;
-    
-    /// SizeAndOffsetDie - Compute the size and offset of a DIE.
-    ///
-    unsigned SizeAndOffsetDie(DIE *Die, unsigned Offset);
-
-    /// SizeAndOffsets - Compute the size and offset of all the DIEs.
-    ///
-    void SizeAndOffsets();
-    
-    /// EmitDebugInfo - Emit the debug info section.
-    ///
-    void EmitDebugInfo() const;
-    
-    /// EmitAbbreviations - Emit the abbreviation section.
-    ///
-    void EmitAbbreviations() const;
-    
-    /// EmitDebugLines - Emit source line information.
-    ///
-    void EmitDebugLines() const;
-
-    /// EmitDebugFrame - Emit info into a debug frame section.
-    ///
-    void EmitDebugFrame();
-    
-    /// EmitDebugPubNames - Emit info into a debug pubnames section.
-    ///
-    void EmitDebugPubNames();
-    
-    /// EmitDebugPubTypes - Emit info into a debug pubtypes section.
-    ///
-    void EmitDebugPubTypes();
-    
-    /// EmitDebugStr - Emit info into a debug str section.
-    ///
-    void EmitDebugStr();
-    
-    /// EmitDebugLoc - Emit info into a debug loc section.
-    ///
-    void EmitDebugLoc();
-    
-    /// EmitDebugARanges - Emit info into a debug aranges section.
-    ///
-    void EmitDebugARanges();
-    
-    /// EmitDebugRanges - Emit info into a debug ranges section.
-    ///
-    void EmitDebugRanges();
-    
-    /// EmitDebugMacInfo - Emit info into a debug macinfo section.
-    ///
-    void EmitDebugMacInfo();
-    
-    /// ConstructCompileUnitDIEs - Create a compile unit DIE for each source and
-    /// header file.
-    void ConstructCompileUnitDIEs();
-    
-    /// ConstructGlobalDIEs - Create DIEs for each of the externally visible
-    /// global variables.
-    void ConstructGlobalDIEs(Module &M);
-
-    /// ConstructSubprogramDIEs - Create DIEs for each of the externally visible
-    /// subprograms.
-    void ConstructSubprogramDIEs(Module &M);
-
-    /// ShouldEmitDwarf - Returns true if Dwarf declarations should be made.
-    /// When called it also checks to see if debug info is newly available.  if
-    /// so the initial Dwarf headers are emitted.
-    bool ShouldEmitDwarf();
-  
-  public:
-    
-    DwarfWriter(std::ostream &OS, AsmPrinter *A);
-    virtual ~DwarfWriter();
-    
-    /// SetDebugInfo - Set DebugInfo when it's known that pass manager has
-    /// created it.  Set by the target AsmPrinter.
-    void SetDebugInfo(MachineDebugInfo *DI) { DebugInfo = DI; }
-
-    //===------------------------------------------------------------------===//
-    // Main entry points.
-    //
-    
-    /// BeginModule - Emit all Dwarf sections that should come prior to the
-    /// content.
-    void BeginModule(Module &M);
-    
-    /// EndModule - Emit all Dwarf sections that should come after the content.
-    ///
-    void EndModule(Module &M);
-    
-    /// BeginFunction - Gather pre-function debug information.
-    ///
-    void BeginFunction(MachineFunction &MF);
-    
-    /// EndFunction - Gather and emit post-function debug information.
-    ///
-    void EndFunction(MachineFunction &MF);
-  };
+  /// NewType - Create a new type DIE.
+  ///
+  DIE *NewType(DIE *Unit, TypeDesc *TyDesc);
+  
+  /// NewCompileUnit - Create new compile unit DIE.
+  ///
+  DIE *NewCompileUnit(CompileUnitDesc *CompileUnit);
+  
+  /// NewGlobalVariable - Make a new global variable DIE.
+  ///
+  DIE *NewGlobalVariable(GlobalVariableDesc *GV