Revert patch.

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

16 files changed, 338 insertions, 603 deletions

diff --git a/include/llvm/CodeGen/ELFWriter.h b/include/llvm/CodeGen/ELFWriter.h
index 7b7a91c8d1..b3914794f0 100644
--- a/include/llvm/CodeGen/ELFWriter.h
+++ b/include/llvm/CodeGen/ELFWriter.h
@@ -22,7 +22,6 @@ namespace llvm {
   class Mangler;
   class MachineCodeEmitter;
   class ELFCodeEmitter;
-  class TargetObjInfo;
 
   /// ELFWriter - This class implements the common target-independent code for
   /// writing ELF files.  Targets should derive a class from this to
@@ -50,10 +49,6 @@ namespace llvm {
     ///
     TargetMachine &TM;
 
-    /// Target object writer info.
-    ///
-    const TargetObjInfo *TOI;
-
     /// Mang - The object used to perform name mangling for this module.
     ///
     Mangler *Mang;
@@ -219,6 +214,102 @@ namespace llvm {
     unsigned ELFHeader_e_shoff_Offset;     // e_shoff    in ELF header.
     unsigned ELFHeader_e_shstrndx_Offset;  // e_shstrndx in ELF header.
     unsigned ELFHeader_e_shnum_Offset;     // e_shnum    in ELF header.
+
+
+    // align - Emit padding into the file until the current output position is
+    // aligned to the specified power of two boundary.
+    static void align(DataBuffer &Output, unsigned Boundary) {
+      assert(Boundary && (Boundary & (Boundary-1)) == 0 &&
+             "Must align to 2^k boundary");
+      size_t Size = Output.size();
+      if (Size & (Boundary-1)) {
+        // Add padding to get alignment to the correct place.
+        size_t Pad = Boundary-(Size & (Boundary-1));
+        Output.resize(Size+Pad);
+      }
+    }
+
+    static void outbyte(DataBuffer &Output, unsigned char X) {
+      Output.push_back(X);
+    }
+    void outhalf(DataBuffer &Output, unsigned short X) {
+      if (isLittleEndian) {
+        Output.push_back(X&255);
+        Output.push_back(X >> 8);
+      } else {
+        Output.push_back(X >> 8);
+        Output.push_back(X&255);
+      }
+    }
+    void outword(DataBuffer &Output, unsigned X) {
+      if (isLittleEndian) {
+        Output.push_back((X >>  0) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >> 24) & 255);
+      } else {
+        Output.push_back((X >> 24) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >>  0) & 255);
+      }
+    }
+    void outxword(DataBuffer &Output, uint64_t X) {
+      if (isLittleEndian) {
+        Output.push_back(unsigned(X >>  0) & 255);
+        Output.push_back(unsigned(X >>  8) & 255);
+        Output.push_back(unsigned(X >> 16) & 255);
+        Output.push_back(unsigned(X >> 24) & 255);
+        Output.push_back(unsigned(X >> 32) & 255);
+        Output.push_back(unsigned(X >> 40) & 255);
+        Output.push_back(unsigned(X >> 48) & 255);
+        Output.push_back(unsigned(X >> 56) & 255);
+      } else {
+        Output.push_back(unsigned(X >> 56) & 255);
+        Output.push_back(unsigned(X >> 48) & 255);
+        Output.push_back(unsigned(X >> 40) & 255);
+        Output.push_back(unsigned(X >> 32) & 255);
+        Output.push_back(unsigned(X >> 24) & 255);
+        Output.push_back(unsigned(X >> 16) & 255);
+        Output.push_back(unsigned(X >>  8) & 255);
+        Output.push_back(unsigned(X >>  0) & 255);
+      }
+    }
+    void outaddr32(DataBuffer &Output, unsigned X) {
+      outword(Output, X);
+    }
+    void outaddr64(DataBuffer &Output, uint64_t X) {
+      outxword(Output, X);
+    }
+    void outaddr(DataBuffer &Output, uint64_t X) {
+      if (!is64Bit)
+        outword(Output, (unsigned)X);
+      else
+        outxword(Output, X);
+    }
+
+    // fix functions - Replace an existing entry at an offset.
+    void fixhalf(DataBuffer &Output, unsigned short X, unsigned Offset) {
+      unsigned char *P = &Output[Offset];
+      P[0] = (X >> (isLittleEndian ?  0 : 8)) & 255;
+      P[1] = (X >> (isLittleEndian ?  8 : 0)) & 255;
+    }
+
+    void fixword(DataBuffer &Output, unsigned X, unsigned Offset) {
+      unsigned char *P = &Output[Offset];
+      P[0] = (X >> (isLittleEndian ?  0 : 24)) & 255;
+      P[1] = (X >> (isLittleEndian ?  8 : 16)) & 255;
+      P[2] = (X >> (isLittleEndian ? 16 :  8)) & 255;
+      P[3] = (X >> (isLittleEndian ? 24 :  0)) & 255;
+    }
+
+    void fixaddr(DataBuffer &Output, uint64_t X, unsigned Offset) {
+      if (!is64Bit)
+        fixword(Output, (unsigned)X, Offset);
+      else
+        assert(0 && "Emission of 64-bit data not implemented yet!");
+    }
+
   private:
     void EmitGlobal(GlobalVariable *GV);
 
diff --git a/include/llvm/CodeGen/MachOWriter.h b/include/llvm/CodeGen/MachOWriter.h
index 0b33c04bd5..cf5390717c 100644
--- a/include/llvm/CodeGen/MachOWriter.h
+++ b/include/llvm/CodeGen/MachOWriter.h
@@ -25,7 +25,6 @@ namespace llvm {
   class Mangler;
   class MachineCodeEmitter;
   class MachOCodeEmitter;
-  class TargetObjInfo;
 
   /// MachOSym - This struct contains information about each symbol that is
   /// added to logical symbol table for the module.  This is eventually
@@ -101,10 +100,6 @@ namespace llvm {
     ///
     TargetMachine &TM;
 
-    /// Target object writer info.
-    ///
-    const TargetObjInfo *TOI;
-
     /// Mang - The object used to perform name mangling for this module.
     ///
     Mangler *Mang;
@@ -664,6 +659,101 @@ namespace llvm {
     /// SymbolTable to aid in emitting the DYSYMTAB load command.
     std::vector<unsigned> DynamicSymbolTable;
     
+    // align - Emit padding into the file until the current output position is
+    // aligned to the specified power of two boundary.
+    static void align(DataBuffer &Output, unsigned Boundary) {
+      assert(Boundary && (Boundary & (Boundary-1)) == 0 &&
+             "Must align to 2^k boundary");
+      size_t Size = Output.size();
+      if (Size & (Boundary-1)) {
+        // Add padding to get alignment to the correct place.
+        size_t Pad = Boundary-(Size & (Boundary-1));
+        Output.resize(Size+Pad);
+      }
+    }
+
+    void outbyte(DataBuffer &Output, unsigned char X) {
+      Output.push_back(X);
+    }
+    void outhalf(DataBuffer &Output, unsigned short X) {
+      if (isLittleEndian) {
+        Output.push_back(X&255);
+        Output.push_back(X >> 8);
+      } else {
+        Output.push_back(X >> 8);
+        Output.push_back(X&255);
+      }
+    }
+    void outword(DataBuffer &Output, unsigned X) {
+      if (isLittleEndian) {
+        Output.push_back((X >>  0) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >> 24) & 255);
+      } else {
+        Output.push_back((X >> 24) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >>  0) & 255);
+      }
+    }
+    void outxword(DataBuffer &Output, uint64_t X) {
+      if (isLittleEndian) {
+        Output.push_back(unsigned(X >>  0) & 255);
+        Output.push_back(unsigned(X >>  8) & 255);
+        Output.push_back(unsigned(X >> 16) & 255);
+        Output.push_back(unsigned(X >> 24) & 255);
+        Output.push_back(unsigned(X >> 32) & 255);
+        Output.push_back(unsigned(X >> 40) & 255);
+        Output.push_back(unsigned(X >> 48) & 255);
+        Output.push_back(unsigned(X >> 56) & 255);
+      } else {
+        Output.push_back(unsigned(X >> 56) & 255);
+        Output.push_back(unsigned(X >> 48) & 255);
+        Output.push_back(unsigned(X >> 40) & 255);
+        Output.push_back(unsigned(X >> 32) & 255);
+        Output.push_back(unsigned(X >> 24) & 255);
+        Output.push_back(unsigned(X >> 16) & 255);
+        Output.push_back(unsigned(X >>  8) & 255);
+        Output.push_back(unsigned(X >>  0) & 255);
+      }
+    }
+    void outaddr32(DataBuffer &Output, unsigned X) {
+      outword(Output, X);
+    }
+    void outaddr64(DataBuffer &Output, uint64_t X) {
+      outxword(Output, X);
+    }
+    void outaddr(DataBuffer &Output, uint64_t X) {
+      if (!is64Bit)
+        outword(Output, (unsigned)X);
+      else
+        outxword(Output, X);
+    }
+    void outstring(DataBuffer &Output, std::string &S, unsigned Length) {
+      unsigned len_to_copy = S.length() < Length ? S.length() : Length;
+      unsigned len_to_fill = S.length() < Length ? Length-S.length() : 0;
+      
+      for (unsigned i = 0; i < len_to_copy; ++i)
+        outbyte(Output, S[i]);
+
+      for (unsigned i = 0; i < len_to_fill; ++i)
+        outbyte(Output, 0);
+      
+    }
+    void fixhalf(DataBuffer &Output, unsigned short X, unsigned Offset) {
+      unsigned char *P = &Output[Offset];
+      P[0] = (X >> (isLittleEndian ?  0 : 8)) & 255;
+      P[1] = (X >> (isLittleEndian ?  8 : 0)) & 255;
+    }
+    void fixword(DataBuffer &Output, unsigned X, unsigned Offset) {
+      unsigned char *P = &Output[Offset];
+      P[0] = (X >> (isLittleEndian ?  0 : 24)) & 255;
+      P[1] = (X >> (isLittleEndian ?  8 : 16)) & 255;
+      P[2] = (X >> (isLittleEndian ? 16 :  8)) & 255;
+      P[3] = (X >> (isLittleEndian ? 24 :  0)) & 255;
+    }
+    
     static void InitMem(const Constant *C, void *Addr, intptr_t Offset,
                         const TargetData *TD, 
                         std::vector<MachineRelocation> &MRs);
diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h
index f69751d22f..13b0d37d5b 100644
--- a/include/llvm/Target/TargetMachine.h
+++ b/include/llvm/Target/TargetMachine.h
@@ -21,7 +21,6 @@
 namespace llvm {
 
 class TargetAsmInfo;
-class TargetObjInfo;
 class TargetData;
 class TargetSubtarget;
 class TargetInstrInfo;
@@ -67,7 +66,7 @@ class TargetMachine {
   TargetMachine(const TargetMachine &);   // DO NOT IMPLEMENT
   void operator=(const TargetMachine &);  // DO NOT IMPLEMENT
 protected: // Can only create subclasses.
-  TargetMachine() : AsmInfo(NULL), ObjInfo(NULL) { }
+  TargetMachine() : AsmInfo(NULL) { }
 
   /// getSubtargetImpl - virtual method implemented by subclasses that returns
   /// a reference to that target's TargetSubtarget-derived member variable.
@@ -76,19 +75,11 @@ protected: // Can only create subclasses.
   /// AsmInfo - Contains target specific asm information.
   ///
   mutable const TargetAsmInfo *AsmInfo;
-
+  
   /// createTargetAsmInfo - Create a new instance of target specific asm
   /// information.
   virtual const TargetAsmInfo *createTargetAsmInfo() const { return NULL; }
 
-  /// ObjInfo - Contains target specific object file information.
-  /// 
-  mutable const TargetObjInfo *ObjInfo;
-  
-  /// createTargetObjInfo - Create a new instance of target specific object
-  /// information.
-  virtual const TargetObjInfo *createTargetObjInfo() const { return NULL; }
-
 public:
   virtual ~TargetMachine();
 
@@ -116,6 +107,7 @@ public:
   virtual       TargetLowering    *getTargetLowering() const { return 0; }
   virtual const TargetData            *getTargetData() const { return 0; }
   
+  
   /// getTargetAsmInfo - Return target specific asm information.
   ///
   const TargetAsmInfo *getTargetAsmInfo() const {
@@ -123,13 +115,6 @@ public:
     return AsmInfo;
   }
   
-  /// getTargetObjInfo - Return target specific object information.
-  ///
-  const TargetObjInfo *getTargetObjInfo() const {
-    if (!ObjInfo) ObjInfo = createTargetObjInfo();
-    return ObjInfo;
-  }
-  
   /// getSubtarget - This method returns a pointer to the specified type of
   /// TargetSubtarget.  In debug builds, it verifies that the object being
   /// returned is of the correct type.
diff --git a/include/llvm/Target/TargetObjInfo.h b/include/llvm/Target/TargetObjInfo.h
deleted file mode 100644
index ffad3543ba..0000000000
--- a/include/llvm/Target/TargetObjInfo.h
+++ /dev/null
@@ -1,57 +0,0 @@
-//===-- llvm/Target/TargetObjInfo.h - Object File Info ----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by Bill Wendling and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains a class to be used as the basis for target specific object
-// writers.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TARGET_OBJ_INFO_H
-#define LLVM_TARGET_OBJ_INFO_H
-
-#include <string>
-#include <vector>
-
-namespace llvm {
-
-  struct TargetObjInfo {
-    TargetObjInfo() {}
-    virtual ~TargetObjInfo() {}
-
-    typedef std::vector<unsigned char> DataBuffer;
-
-    virtual void align(DataBuffer &Output, unsigned Boundary) const = 0;
-
-    //===------------------------------------------------------------------===//
-    // Out Functions - Output the specified value to the data buffer.
-
-    virtual void outbyte(DataBuffer &Output, unsigned char X) const = 0;
-    virtual void outhalf(DataBuffer &Output, unsigned short X) const = 0;
-    virtual void outword(DataBuffer &Output, unsigned X) const = 0;
-    virtual void outxword(DataBuffer &Output, uint64_t X) const = 0;
-    virtual void outaddr32(DataBuffer &Output, unsigned X) const = 0;
-    virtual void outaddr64(DataBuffer &Output, uint64_t X) const = 0;
-    virtual void outaddr(DataBuffer &Output, uint64_t X) const = 0;
-    virtual void outstring(DataBuffer &Output, std::string &S,
-                           unsigned Length) const = 0;
-
-    //===------------------------------------------------------------------===//
-    // Fix Functions - Replace an existing entry at an offset.
-
-    virtual void fixhalf(DataBuffer &Output, unsigned short X,
-                         unsigned Offset) const = 0;
-    virtual void fixword(DataBuffer &Output, unsigned X,
-                         unsigned Offset) const = 0;
-    virtual void fixaddr(DataBuffer &Output, uint64_t X,
-                         unsigned Offset) const = 0;
-  };
-
-} // end llvm namespace
-
-#endif // LLVM_TARGET_OBJ_INFO_H
diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp
index 0beda80ca1..ee9cecd579 100644
--- a/lib/CodeGen/ELFWriter.cpp
+++ b/lib/CodeGen/ELFWriter.cpp
@@ -37,7 +37,6 @@
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetObjInfo.h"
 #include "llvm/Support/Mangler.h"
 #include "llvm/Support/Streams.h"
 using namespace llvm;
@@ -54,20 +53,8 @@ namespace llvm {
     ELFWriter::ELFSection *ES;  // Section to write to.
     std::vector<unsigned char> *OutBuffer;
     size_t FnStart;
-
-    /// Target machine description.
-    ///
-    TargetMachine &TM;
-
-    /// Target object writer info.
-    ///
-    const TargetObjInfo *TOI;
   public:
-    ELFCodeEmitter(ELFWriter &ew, TargetMachine &tm)
-      : EW(ew), OutBuffer(0), TM(tm) {
-      // Create the target object info object for this target.
-      TOI = TM.getTargetObjInfo();
-    }
+    ELFCodeEmitter(ELFWriter &ew) : EW(ew), OutBuffer(0) {}
 
     void startFunction(MachineFunction &F);
     bool finishFunction(MachineFunction &F);
@@ -126,7 +113,7 @@ void ELFCodeEmitter::startFunction(MachineFunction &F) {
 
   // Add padding zeros to the end of the buffer to make sure that the
   // function will start on the correct byte alignment within the section.
-  TOI->align(*OutBuffer, Align);
+  ELFWriter::align(*OutBuffer, Align);
 
   FnStart = OutBuffer->size();
 }
@@ -178,11 +165,8 @@ ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) {
   isLittleEndian = TM.getTargetData()->isLittleEndian();
 
   // Create the machine code emitter object for this target.
-  MCE = new ELFCodeEmitter(*this, TM);
+  MCE = new ELFCodeEmitter(*this);
   NumSections = 0;
-
-  // Create the target object info object for this target.
-  TOI = TM.getTargetObjInfo();
 }
 
 ELFWriter::~ELFWriter() {
@@ -197,36 +181,36 @@ bool ELFWriter::doInitialization(Module &M) {
   // Local alias to shortenify coming code.
   std::vector<unsigned char> &FH = FileHeader;
 
-  TOI->outbyte(FH, 0x7F);                     // EI_MAG0
-  TOI->outbyte(FH, 'E');                      // EI_MAG1
-  TOI->outbyte(FH, 'L');                      // EI_MAG2
-  TOI->outbyte(FH, 'F');                      // EI_MAG3
-  TOI->outbyte(FH, is64Bit ? 2 : 1);          // EI_CLASS
-  TOI->outbyte(FH, isLittleEndian ? 1 : 2);   // EI_DATA
-  TOI->outbyte(FH, 1);                        // EI_VERSION
-  FH.resize(16);                              // EI_PAD up to 16 bytes.
+  outbyte(FH, 0x7F);                     // EI_MAG0
+  outbyte(FH, 'E');                      // EI_MAG1
+  outbyte(FH, 'L');                      // EI_MAG2
+  outbyte(FH, 'F');                      // EI_MAG3
+  outbyte(FH, is64Bit ? 2 : 1);          // EI_CLASS
+  outbyte(FH, isLittleEndian ? 1 : 2);   // EI_DATA
+  outbyte(FH, 1);                        // EI_VERSION
+  FH.resize(16);                         // EI_PAD up to 16 bytes.
 
   // This should change for shared objects.
-  TOI->outhalf(FH, 1);               // e_type = ET_REL
-  TOI->outhalf(FH, e_machine);       // e_machine = whatever the target wants
-  TOI->outword(FH, 1);               // e_version = 1
-  TOI->outaddr(FH, 0);               // e_entry = 0 -> no entry point in .o file
-  TOI->outaddr(FH, 0);               // e_phoff = 0 -> no program header for .o
+  outhalf(FH, 1);                 // e_type = ET_REL
+  outhalf(FH, e_machine);         // e_machine = whatever the target wants
+  outword(FH, 1);                 // e_version = 1
+  outaddr(FH, 0);                 // e_entry = 0 -> no entry point in .o file
+  outaddr(FH, 0);                 // e_phoff = 0 -> no program header for .o
 
   ELFHeader_e_shoff_Offset = FH.size();
-  TOI->outaddr(FH, 0);                 // e_shoff
-  TOI->outword(FH, e_flags);           // e_flags = whatever the target wants
+  outaddr(FH, 0);                 // e_shoff
+  outword(FH, e_flags);           // e_flags = whatever the target wants
 
-  TOI->outhalf(FH, is64Bit ? 64 : 52); // e_ehsize = ELF header size
-  TOI->outhalf(FH, 0);                 // e_phentsize = prog header entry size
-  TOI->outhalf(FH, 0);                 // e_phnum     = # prog header entries=0
-  TOI->outhalf(FH, is64Bit ? 64 : 40); // e_shentsize = sect hdr entry size
+  outhalf(FH, is64Bit ? 64 : 52); // e_ehsize = ELF header size
+  outhalf(FH, 0);                 // e_phentsize = prog header entry size
+  outhalf(FH, 0);                 // e_phnum     = # prog header entries = 0
+  outhalf(FH, is64Bit ? 64 : 40); // e_shentsize = sect hdr entry size
 
 
   ELFHeader_e_shnum_Offset = FH.size();
-  TOI->outhalf(FH, 0);                 // e_shnum     = # of section header ents
+  outhalf(FH, 0);                 // e_shnum     = # of section header ents
   ELFHeader_e_shstrndx_Offset = FH.size();
-  TOI->outhalf(FH, 0);                 // e_shstrndx  = Section # of '.shstrtab'
+  outhalf(FH, 0);                 // e_shstrndx  = Section # of '.shstrtab'
 
   // Add the null section, which is required to be first in the file.
   getSection("", 0, 0);
@@ -368,7 +352,7 @@ void ELFWriter::EmitSymbolTable() {
   DataBuffer &StrTabBuf = StrTab.SectionData;
 
   // Set the zero'th symbol to a null byte, as required.
-  TOI->outbyte(StrTabBuf, 0);
+  outbyte(StrTabBuf, 0);
   SymbolTable[0].NameIdx = 0;
   unsigned Index = 1;
   for (unsigned i = 1, e = SymbolTable.size(); i != e; ++i) {
@@ -405,22 +389,22 @@ void ELFWriter::EmitSymbolTable() {
   if (!is64Bit) {   // 32-bit and 64-bit formats are shuffled a bit.
     for (unsigned i = 0, e = SymbolTable.size(); i != e; ++i) {
       ELFSym &Sym = SymbolTable[i];
-      TOI->outword(SymTabBuf, Sym.NameIdx);
-      TOI->outaddr32(SymTabBuf, Sym.Value);
-      TOI->outword(SymTabBuf, Sym.Size);
-      TOI->outbyte(SymTabBuf, Sym.Info);
-      TOI->outbyte(SymTabBuf, Sym.Other);
-      TOI->outhalf(SymTabBuf, Sym.SectionIdx);
+      outword(SymTabBuf, Sym.NameIdx);
+      outaddr32(SymTabBuf, Sym.Value);
+      outword(SymTabBuf, Sym.Size);
+      outbyte(SymTabBuf, Sym.Info);
+      outbyte(SymTabBuf, Sym.Other);
+      outhalf(SymTabBuf, Sym.SectionIdx);
     }
   } else {
     for (unsigned i = 0, e = SymbolTable.size(); i != e; ++i) {
       ELFSym &Sym = SymbolTable[i];
-      TOI->outword(SymTabBuf, Sym.NameIdx);
-      TOI->outbyte(SymTabBuf, Sym.Info);
-      TOI->outbyte(SymTabBuf, Sym.Other);
-      TOI->outhalf(SymTabBuf, Sym.SectionIdx);
-      TOI->outaddr64(SymTabBuf, Sym.Value);
-      TOI->outxword(SymTabBuf, Sym.Size);
+      outword(SymTabBuf, Sym.NameIdx);
+      outbyte(SymTabBuf, Sym.Info);
+      outbyte(SymTabBuf, Sym.Other);
+      outhalf(SymTabBuf, Sym.SectionIdx);
+      outaddr64(SymTabBuf, Sym.Value);
+      outxword(SymTabBuf, Sym.Size);
     }
   }
 
@@ -436,7 +420,7 @@ void ELFWriter::EmitSectionTableStringTable() {
 
   // Now that we know which section number is the .shstrtab section, update the
   // e_shstrndx entry in the ELF header.
-  TOI->fixhalf(FileHeader, SHStrTab.SectionIdx, ELFHeader_e_shstrndx_Offset);
+  fixhalf(FileHeader, SHStrTab.SectionIdx, ELFHeader_e_shstrndx_Offset);
 
   // Set the NameIdx of each section in the string table and emit the bytes for
   // the string table.
@@ -487,11 +471,11 @@ void ELFWriter::OutputSectionsAndSectionTable() {
 
   // Now that we know where all of the sections will be emitted, set the e_shnum
   // entry in the ELF header.
-  TOI->fixhalf(FileHeader, NumSections, ELFHeader_e_shnum_Offset);
+  fixhalf(FileHeader, NumSections, ELFHeader_e_shnum_Offset);
 
   // Now that we know the offset in the file of the section table, update the
   // e_shoff address in the ELF header.
-  TOI->fixaddr(FileHeader, FileOff, ELFHeader_e_shoff_Offset);
+  fixaddr(FileHeader, FileOff, ELFHeader_e_shoff_Offset);
 
   // Now that we know all of the data in the file header, emit it and all of the
   // sections!
@@ -513,16 +497,16 @@ void ELFWriter::OutputSectionsAndSectionTable() {
     O.write((char*)&S.SectionData[0], S.SectionData.size());
     FileOff += S.SectionData.size();
 
-    TOI->outword(Table, S.NameIdx); // sh_name - Symbol table name idx
-    TOI->outword(Table, S.Type);    // sh_type - Section contents & semantics
-    TOI->outword(Table, S.Flags);   // sh_flags - Section flags
-    TOI->outaddr(Table, S.Addr);    // sh_addr - The mem addr this section is in
-    TOI->outaddr(Table, S.Offset);  // sh_offset - Offset from the file start
-    TOI->outword(Table, S.Size);    // sh_size - The section size
-    TOI->outword(Table, S.Link);    // sh_link - Section header table index link
-    TOI->outword(Table, S.Info);    // sh_info - Auxillary information
-    TOI->outword(Table, S.Align);   // sh_addralign - Alignment of section
-    TOI->outword(Table, S.EntSize); // sh_entsize - Size of entries in the sect
+    outword(Table, S.NameIdx);  // sh_name - Symbol table name idx
+    outword(Table, S.Type);     // sh_type - Section contents & semantics
+    outword(Table, S.Flags);    // sh_flags - Section flags.
+    outaddr(Table, S.Addr);     // sh_addr - The mem addr this section is in.
+    outaddr(Table, S.Offset);   // sh_offset - Offset from the file start.
+    outword(Table, S.Size);     // sh_size - The section size.
+    outword(Table, S.Link);     // sh_link - Section header table index link.
+    outword(Table, S.Info);     // sh_info - Auxillary information.
+    outword(Table, S.Align);    // sh_addralign - Alignment of section.
+    outword(Table, S.EntSize);  // sh_entsize - Size of entries in the section.
 
     SectionList.pop_front();
   }
diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp
index 0a8825a4e4..49c7457e41 100644
--- a/lib/CodeGen/MachOWriter.cpp
+++ b/lib/CodeGen/MachOWriter.cpp
@@ -32,11 +32,11 @@
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/Target/TargetAsmInfo.h"
 #include "llvm/Target/TargetJITInfo.h"
-#include "llvm/Target/TargetObjInfo.h"
 #include "llvm/Support/Mangler.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Streams.h"
 #include <algorithm>
+
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
@@ -49,14 +49,6 @@ namespace llvm {
   class MachOCodeEmitter : public MachineCodeEmitter {
     MachOWriter &MOW;
 
-    /// Target machine description.
-    ///
-    TargetMachine &TM;
-
-    /// Target object writer info.
-    ///
-    const TargetObjInfo *TOI;
-
     /// Relocations - These are the relocations that the function needs, as
     /// emitted.
     std::vector<MachineRelocation> Relocations;
@@ -79,10 +71,7 @@ namespace llvm {
     std::vector<intptr_t> MBBLocations;
     
   public:
-    MachOCodeEmitter(MachOWriter &mow, TargetMachine &tm) : MOW(mow), TM(tm) {
-      // Create the target object info object for this target.
-      TOI = TM.getTargetObjInfo();
-    }
+    MachOCodeEmitter(MachOWriter &mow) : MOW(mow) {}
 
     virtual void startFunction(MachineFunction &F);
     virtual bool finishFunction(MachineFunction &F);
@@ -174,7 +163,7 @@ bool MachOCodeEmitter::finishFunction(MachineFunction &F) {
   
   // Get a symbol for the function to add to the symbol table
   const GlobalValue *FuncV = F.getFunction();
-  MachOSym FnSym(FuncV, MOW.Mang->getValueName(FuncV), MOS->Index, TM);
+  MachOSym FnSym(FuncV, MOW.Mang->getValueName(FuncV), MOS->Index, MOW.TM);
 
   // Emit constant pool to appropriate section(s)
   emitConstantPool(F.getConstantPool());
@@ -222,7 +211,7 @@ void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
   if (CP.empty()) return;
 
   // FIXME: handle PIC codegen
-  bool isPIC = TM.getRelocationModel() == Reloc::PIC_;
+  bool isPIC = MOW.TM.getRelocationModel() == Reloc::PIC_;
   assert(!isPIC && "PIC codegen not yet handled for mach-o jump tables!");
 
   // Although there is no strict necessity that I am aware of, we will do what
@@ -234,7 +223,7 @@ void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
   // "giant object for PIC" optimization.
   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
     const Type *Ty = CP[i].getType();
-    unsigned Size = TM.getTargetData()->getTypeSize(Ty);
+    unsigned Size = MOW.TM.getTargetData()->getTypeSize(Ty);
 
     MachOWriter::MachOSection *Sec = MOW.getConstSection(Ty);
     CPLocations.push_back(Sec->SectionData.size());
@@ -247,10 +236,10 @@ void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
     // FIXME: need alignment?
     // FIXME: share between here and AddSymbolToSection?
     for (unsigned j = 0; j < Size; ++j)
-      TOI->outbyte(Sec->SectionData, 0);
+      MOW.outbyte(Sec->SectionData, 0);
 
     MOW.InitMem(CP[i].Val.ConstVal, &Sec->SectionData[0], CPLocations[i],
-                TM.getTargetData(), Sec->Relocations);
+                MOW.TM.getTargetData(), Sec->Relocations);
   }
 }
 
@@ -261,7 +250,7 @@ void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) {
   if (JT.empty()) return;
 
   // FIXME: handle PIC codegen
-  bool isPIC = TM.getRelocationModel() == Reloc::PIC_;
+  bool isPIC = MOW.TM.getRelocationModel() == Reloc::PIC_;
   assert(!isPIC && "PIC codegen not yet handled for mach-o jump tables!");
 
   MachOWriter::MachOSection *Sec = MOW.getJumpTableSection();
@@ -278,7 +267,7 @@ void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) {
       MR.setResultPointer((void *)JTLocations[i]);
       MR.setConstantVal(TextSecIndex);
       Sec->Relocations.push_back(MR);
-      TOI->outaddr(Sec->SectionData, 0);
+      MOW.outaddr(Sec->SectionData, 0);
     }
   }
   // FIXME: remove when we have unified size + output buffer
@@ -294,10 +283,7 @@ MachOWriter::MachOWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) {
   isLittleEndian = TM.getTargetData()->isLittleEndian();
 
   // Create the machine code emitter object for this target.
-  MCE = new MachOCodeEmitter(*this, tm);
-
-  // Create the target object info object for this target.
-  TOI = TM.getTargetObjInfo();
+  MCE = new MachOCodeEmitter(*this);
 }
 
 MachOWriter::~MachOWriter() {
@@ -326,7 +312,7 @@ void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) {
     // FIXME: remove when we have unified size + output buffer
     unsigned AlignedSize = Sec->size - OrigSize;
     for (unsigned i = 0; i < AlignedSize; ++i)
-      TOI->outbyte(Sec->SectionData, 0);
+      outbyte(Sec->SectionData, 0);
   }
   // Record the offset of the symbol, and then allocate space for it.
   // FIXME: remove when we have unified size + output buffer
@@ -343,7 +329,7 @@ void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) {
   
   // Allocate space in the section for the global.
   for (unsigned i = 0; i < Size; ++i)
-    TOI->outbyte(Sec->SectionData, 0);
+    outbyte(Sec->SectionData, 0);
 }
 
 void MachOWriter::EmitGlobal(GlobalVariable *GV) {
@@ -456,15 +442,15 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
   // Step #3: write the header to the file
   // Local alias to shortenify coming code.
   DataBuffer &FH = Header.HeaderData;
-  TOI->outword(FH, Header.magic);
-  TOI->outword(FH, Header.cputype);
-  TOI->outword(FH, Header.cpusubtype);
-  TOI->outword(FH, Header.filetype);
-  TOI->outword(FH, Header.ncmds);
-  TOI->outword(FH, Header.sizeofcmds);
-  TOI->outword(FH, Header.flags);
+  outword(FH, Header.magic);
+  outword(FH, Header.cputype);
+  outword(FH, Header.cpusubtype);
+  outword(FH, Header.filetype);
+  outword(FH, Header.ncmds);
+  outword(FH, Header.sizeofcmds);
+  outword(FH, Header.flags);
   if (is64Bit)
-    TOI->outword(FH, Header.reserved);
+    outword(FH, Header.reserved);
   
   // Step #4: Finish filling in the segment load command and write it out
   for (std::vector<MachOSection*>::iterator I = SectionList.begin(),
@@ -474,17 +460,17 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
   SEG.vmsize = SEG.filesize;
   SEG.fileoff = Header.cmdSize(is64Bit) + Header.sizeofcmds;
   
-  TOI->outword(FH, SEG.cmd);
-  TOI->outword(FH, SEG.cmdsize);
-  TOI->outstring(FH, SEG.segname, 16);
-  TOI->outaddr(FH, SEG.vmaddr);
-  TOI->outaddr(FH, SEG.vmsize);
-  TOI->outaddr(FH, SEG.fileoff);
-  TOI->outaddr(FH, SEG.filesize);
-  TOI->outword(FH, SEG.maxprot);
-  TOI->outword(FH, SEG.initprot);
-  TOI->outword(FH, SEG.nsects);
-  TOI->outword(FH, SEG.flags);
+  outword(FH, SEG.cmd);
+  outword(FH, SEG.cmdsize);
+  outstring(FH, SEG.segname, 16);
+  outaddr(FH, SEG.vmaddr);
+  outaddr(FH, SEG.vmsize);
+  outaddr(FH, SEG.fileoff);
+  outaddr(FH, SEG.filesize);
+  outword(FH, SEG.maxprot);
+  outword(FH, SEG.initprot);
+  outword(FH, SEG.nsects);
+  outword(FH, SEG.flags);
   
   // Step #5: Finish filling in the fields of the MachOSections 
   uint64_t currentAddr = 0;
@@ -511,19 +497,19 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
     currentAddr += MOS->nreloc * 8;
     
     // write the finalized section command to the output buffer
-    TOI->outstring(FH, MOS->sectname, 16);
-    TOI->outstring(FH, MOS->segname, 16);
-    TOI->outaddr(FH, MOS->addr);
-    TOI->outaddr(FH, MOS->size);
-    TOI->outword(FH, MOS->offset);
-    TOI->outword(FH, MOS->align);
-    TOI->outword(FH, MOS->reloff);
-    TOI->outword(FH, MOS->nreloc);
-    TOI->outword(FH, MOS->flags);
-    TOI->outword(FH, MOS->reserved1);
-    TOI->outword(FH, MOS->reserved2);
+    outstring(FH, MOS->sectname, 16);
+    outstring(FH, MOS->segname, 16);
+    outaddr(FH, MOS->addr);
+    outaddr(FH, MOS->size);
+    outword(FH, MOS->offset);
+    outword(FH, MOS->align);
+    outword(FH, MOS->reloff);
+    outword(FH, MOS->nreloc);
+    outword(FH, MOS->flags);
+    outword(FH, MOS->reserved1);
+    outword(FH, MOS->reserved2);
     if (is64Bit)
-      TOI->outword(FH, MOS->reserved3);
+      outword(FH, MOS->reserved3);
   }
   
   // Step #7: Emit the symbol table to temporary buffers, so that we know the
@@ -535,36 +521,36 @@ void MachOWriter::Emit