Index: source/Plugins/ObjectFile/ELF/ELFHeader.cpp
===================================================================
--- source/Plugins/ObjectFile/ELF/ELFHeader.cpp	(revision 0)
+++ source/Plugins/ObjectFile/ELF/ELFHeader.cpp	(revision 0)
@@ -0,0 +1,307 @@
+//===-- ELFHeader.cpp ----------------------------------------- -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstring>
+
+#include "lldb/Core/DataExtractor.h"
+
+#include "ELFHeader.h"
+
+using namespace elf;
+using namespace lldb;
+using namespace llvm::ELF;
+
+//------------------------------------------------------------------------------
+// Static utility functions.
+//
+// GetMaxU64 and GetMaxS64 wrap the similarly named methods from DataExtractor
+// with error handling code and provide for parsing a sequence of values.
+static bool
+GetMaxU64(const lldb_private::DataExtractor &data, 
+          uint32_t *offset, uint64_t *value, uint32_t byte_size) 
+{
+    const uint32_t saved_offset = *offset;
+    *value = data.GetMaxU64(offset, byte_size);
+    return *offset != saved_offset;
+}
+
+static bool
+GetMaxU64(const lldb_private::DataExtractor &data, 
+          uint32_t *offset, uint64_t *value, uint32_t byte_size, 
+          uint32_t count) 
+{
+    uint32_t saved_offset = *offset;
+
+    for (uint32_t i = 0; i < count; ++i, ++value)
+    {
+        if (GetMaxU64(data, offset, value, byte_size) == false) 
+        {
+            *offset = saved_offset;
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool
+GetMaxS64(const lldb_private::DataExtractor &data, 
+          uint32_t *offset, int64_t *value, uint32_t byte_size) 
+{
+    const uint32_t saved_offset = *offset;
+    *value = data.GetMaxS64(offset, byte_size);
+    return *offset != saved_offset;
+}
+
+static bool
+GetMaxS64(const lldb_private::DataExtractor &data, 
+          uint32_t *offset, int64_t *value, uint32_t byte_size, 
+          uint32_t count) 
+{
+    uint32_t saved_offset = *offset;
+
+    for (uint32_t i = 0; i < count; ++i, ++value)
+    {
+        if (GetMaxS64(data, offset, value, byte_size) == false) 
+        {
+            *offset = saved_offset;
+            return false;
+        }
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFHeader
+
+ELFHeader::ELFHeader()
+{
+    memset(this, 0, sizeof(ELFHeader)); 
+}
+
+ByteOrder
+ELFHeader::GetByteOrder() const 
+{
+    if (e_ident[EI_DATA] == ELFDATA2MSB)
+        return eByteOrderBig;
+    if (e_ident[EI_DATA] == ELFDATA2LSB)
+        return eByteOrderLittle;
+    return eByteOrderInvalid;
+}
+
+bool
+ELFHeader::Parse(lldb_private::DataExtractor &data, uint32_t *offset) 
+{
+    // Read e_ident.  This provides byte order and address size info.
+    if (data.GetU8(offset, &e_ident, EI_NIDENT) == NULL)
+        return false;
+
+    const unsigned byte_size = Is32Bit() ? 4 : 8;
+    data.SetByteOrder(GetByteOrder());
+    data.SetAddressByteSize(byte_size);
+
+    // Read e_type and e_machine.
+    if (data.GetU16(offset, &e_type, 2) == NULL)
+        return false;
+
+    // Read e_version.
+    if (data.GetU32(offset, &e_version, 1) == NULL)
+        return false;
+
+    // Read e_entry, e_phoff and e_shoff.
+    if (GetMaxU64(data, offset, &e_entry, byte_size, 3) == false)
+        return false;
+
+    // Read e_flags.
+    if (data.GetU32(offset, &e_flags, 1) == NULL)
+        return false;
+
+    // Read e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum and
+    // e_shstrndx.
+    if (data.GetU16(offset, &e_ehsize, 6) == NULL)
+        return false;
+
+    return true;
+}
+
+bool
+ELFHeader::MagicBytesMatch(const uint8_t *magic)
+{
+    if (magic != NULL)
+        return memcmp(magic, ElfMagic, strlen(ElfMagic)) == 0;
+    return false;
+}
+
+unsigned
+ELFHeader::AddressSizeInBytes(const uint8_t *magic)
+{
+    unsigned address_size = 0;
+
+    if (magic != NULL)
+    {
+        switch (magic[EI_CLASS]) 
+        {
+        case ELFCLASS32:
+            address_size = 4;
+            break;
+            
+        case ELFCLASS64:
+            address_size = 8;
+            break;
+        }
+    }
+    return address_size;
+}
+
+//------------------------------------------------------------------------------
+// ELFSectionHeader
+
+ELFSectionHeader::ELFSectionHeader() 
+{
+    memset(this, 0, sizeof(ELFSectionHeader));
+}
+
+bool
+ELFSectionHeader::Parse(const lldb_private::DataExtractor &data,
+                        uint32_t *offset) 
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+
+    // Read sh_name and sh_type.
+    if (data.GetU32(offset, &sh_name, 2) == NULL)
+        return false;
+
+    // Read sh_flags.
+    if (GetMaxU64(data, offset, &sh_flags, byte_size) == false)
+        return false;
+
+    // Read sh_addr, sh_off and sh_size.
+    if (GetMaxU64(data, offset, &sh_addr, byte_size, 3) == false)
+        return false;
+
+    // Read sh_link and sh_info.
+    if (data.GetU32(offset, &sh_link, 2) == NULL)
+        return false;
+
+    // Read sh_addralign and sh_entsize.
+    if (GetMaxU64(data, offset, &sh_addralign, byte_size, 2) == false)
+        return false;
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFSymbol
+
+ELFSymbol::ELFSymbol() 
+{
+    memset(this, 0, sizeof(ELFSymbol));
+}
+
+bool
+ELFSymbol::Parse(const lldb_private::DataExtractor &data, uint32_t *offset) 
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+    const bool parsing_32 = byte_size == 4;
+
+    // Read st_name.
+    if (data.GetU32(offset, &st_name, 1) == NULL)
+        return false;
+
+    if (parsing_32) 
+    {
+        // Read st_value and st_size.
+        if (GetMaxU64(data, offset, &st_value, byte_size, 2) == false)
+            return false;
+
+        // Read st_info and st_other.
+        if (data.GetU8(offset, &st_info, 2) == NULL)
+            return false;
+            
+        // Read st_shndx.
+        if (data.GetU16(offset, &st_shndx, 1) == NULL)
+            return false;
+    }
+    else 
+    {
+        // Read st_info and st_other.
+        if (data.GetU8(offset, &st_info, 2) == NULL)
+            return false;
+            
+        // Read st_shndx.
+        if (data.GetU16(offset, &st_shndx, 1) == NULL)
+            return false;
+
+        // Read st_value and st_size.
+        if (data.GetU64(offset, &st_value, 2) == NULL)
+            return false;
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFProgramHeader
+
+ELFProgramHeader::ELFProgramHeader() 
+{
+    memset(this, 0, sizeof(ELFProgramHeader));
+}
+
+bool
+ELFProgramHeader::Parse(const lldb_private::DataExtractor &data, 
+                        uint32_t *offset) 
+{
+    const uint32_t byte_size = data.GetAddressByteSize();
+    const bool parsing_32 = byte_size == 4;
+
+    // Read p_type;
+    if (data.GetU32(offset, &p_type, 1) == NULL)
+        return false;
+
+    if (parsing_32) {
+        // Read p_offset, p_vaddr, p_paddr, p_filesz and p_memsz.
+        if (GetMaxU64(data, offset, &p_offset, byte_size, 5) == false)
+            return false;
+
+        // Read p_flags.
+        if (data.GetU32(offset, &p_flags, 1) == NULL)
+            return false;
+
+        // Read p_align.
+        if (GetMaxU64(data, offset, &p_align, byte_size) == false)
+            return false;
+    }
+    else {
+        // Read p_flags.
+        if (data.GetU32(offset, &p_flags, 1) == NULL)
+            return false;
+
+        // Read p_offset, p_vaddr, p_paddr, p_filesz, p_memsz and p_align.
+        if (GetMaxU64(data, offset, &p_offset, byte_size, 6) == false)
+            return false;
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFDynamic
+
+ELFDynamic::ELFDynamic() 
+{ 
+    memset(this, 0, sizeof(ELFDynamic)); 
+}
+
+bool
+ELFDynamic::Parse(const lldb_private::DataExtractor &data, uint32_t *offset) 
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+    return GetMaxS64(data, offset, &d_tag, byte_size, 2);
+}
+
+
Index: source/Plugins/ObjectFile/ELF/ObjectFileELF.h
===================================================================
--- source/Plugins/ObjectFile/ELF/ObjectFileELF.h	(revision 108210)
+++ source/Plugins/ObjectFile/ELF/ObjectFileELF.h	(working copy)
@@ -1,4 +1,4 @@
-//===-- ObjectFileELF64.h ------------------------------------- -*- C++ -*-===//
+//===-- ObjectFileELF.h --------------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ObjectFileELF64_h_
-#define liblldb_ObjectFileELF64_h_
+#ifndef liblldb_ObjectFileELF_h_
+#define liblldb_ObjectFileELF_h_
 
 #include <stdint.h>
 #include <vector>
@@ -17,52 +17,26 @@
 #include "lldb/Core/FileSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 
-#include "elf.h"
+#include "ELFHeader.h"
 
-//----------------------------------------------------------------------
-// This class needs to be hidden as eventually belongs in a plugin that
-// will export the ObjectFile protocol
-//----------------------------------------------------------------------
-class ObjectFileELF64 : 
+namespace elf {
+
+//------------------------------------------------------------------------------
+/// @class ObjectFileELF
+/// @brief Generic ELF object file reader.
+///
+/// This class provides generic ELF reading services and implements the
+/// ObjectFile protocol.  It serves as a common base for the 32 and 64 bit ELF
+/// plugins.
+class ObjectFileELF :
     public lldb_private::ObjectFile
 {
 public:
     //------------------------------------------------------------------
-    // Static Functions
+    // ObjectFile Protocol.
     //------------------------------------------------------------------
-    static void
-    Initialize();
-
-    static void
-    Terminate();
-
-    static const char *
-    GetPluginNameStatic();
-
-    static const char *
-    GetPluginDescriptionStatic();
-
-    static lldb_private::ObjectFile *
-    CreateInstance(lldb_private::Module* module,
-                   lldb::DataBufferSP& dataSP,
-                   const lldb_private::FileSpec* file,
-                   lldb::addr_t offset,
-                   lldb::addr_t length);
-
-    static bool
-    MagicBytesMatch(lldb::DataBufferSP& dataSP);
-
-    //------------------------------------------------------------------
-    // Member Functions
-    //------------------------------------------------------------------
-    ObjectFileELF64(lldb_private::Module* module,
-                    lldb::DataBufferSP& dataSP,
-                    const lldb_private::FileSpec* file,
-                    lldb::addr_t offset,
-                    lldb::addr_t length);
-
     virtual
-    ~ObjectFileELF64();
+    ~ObjectFileELF();
 
     virtual bool
     ParseHeader();
@@ -91,119 +65,141 @@
     virtual uint32_t
     GetDependentModules(lldb_private::FileSpecList& files);
 
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    virtual const char *
-    GetPluginName();
-
-    virtual const char *
-    GetShortPluginName();
-
-    virtual uint32_t
-    GetPluginVersion();
-
-    virtual void
-    GetPluginCommandHelp(const char *command, lldb_private::Stream *strm);
-
-    virtual lldb_private::Error
-    ExecutePluginCommand(lldb_private::Args &command,
-                         lldb_private::Stream *strm);
-
-    virtual lldb_private::Log *
-    EnablePluginLogging(lldb_private::Stream *strm, 
-                        lldb_private::Args &command);
-
 protected:
-    typedef std::vector<Elf64_Phdr>             ProgramHeaderColl;
+    ObjectFileELF(lldb_private::Module* module,
+                  lldb::DataBufferSP& dataSP,
+                  const lldb_private::FileSpec* file,
+                  lldb::addr_t offset,
+                  lldb::addr_t length);
+
+    typedef std::vector<ELFProgramHeader>       ProgramHeaderColl;
     typedef ProgramHeaderColl::iterator         ProgramHeaderCollIter;
     typedef ProgramHeaderColl::const_iterator   ProgramHeaderCollConstIter;
 
-    typedef std::vector<Elf64_Shdr>             SectionHeaderColl;
+    typedef std::vector<ELFSectionHeader>       SectionHeaderColl;
     typedef SectionHeaderColl::iterator         SectionHeaderCollIter;
     typedef SectionHeaderColl::const_iterator   SectionHeaderCollConstIter;
 
-    Elf64_Ehdr m_header;
+    /// Version of this reader common to all plugins based on this class.
+    static const uint32_t m_plugin_version = 1;
+
+    /// ELF file header.
+    ELFHeader m_header;
+
+    /// Collection of program headers.
     ProgramHeaderColl m_program_headers;
+
+    /// Collection of section headers.
     SectionHeaderColl m_section_headers;
+
+    /// List of sections present in this ELF object file.
     mutable std::auto_ptr<lldb_private::SectionList> m_sections_ap;
+
+    /// Table of all non-dynamic symbols present in this object file.
     mutable std::auto_ptr<lldb_private::Symtab> m_symtab_ap;
+
+    /// List of file specifications corresponding to the modules (shared
+    /// libraries) on which this object file depends.
     mutable std::auto_ptr<lldb_private::FileSpecList> m_filespec_ap;
+
+    /// Data extractor holding the string table used to resolve section names.
     lldb_private::DataExtractor m_shstr_data;
 
-    size_t
-    ParseSections();
-
-    size_t
-    ParseSymtab(bool minimize);
-
-private:
-    // Returns the 1 based index of a section header.
+    /// Returns a 1 based index of the given section header.
     unsigned
     SectionIndex(const SectionHeaderCollIter &I);
 
+    /// Returns a 1 based index of the given section header.
     unsigned
     SectionIndex(const SectionHeaderCollConstIter &I) const;
 
-    // ELF header dump routines
+    /// Parses all section headers present in this object file and populates
+    /// m_program_headers.  This method will compute the header list only once.
+    /// Returns the number of headers parsed.
+    size_t
+    ParseProgramHeaders();
+
+    /// Parses all section headers present in this object file and populates
+    /// m_section_headers.  This method will compute the header list only once.
+    /// Returns the number of headers parsed.
+    size_t
+    ParseSectionHeaders();
+
+    /// Scans the dynamic section and locates all dependent modules (shared
+    /// libaries) populating m_filespec_ap.  This method will compute the
+    /// dependent module list only once.  Returns the number of dependent
+    /// modules parsed.
+    size_t
+    ParseDependentModules();
+
+    /// Populates m_symtab_ap will all non-dynamic linker symbols.  This method
+    /// will parse the symbols only once.  Returns the number of symbols parsed.
+    void
+    ParseSymbolTable(lldb_private::Symtab *symbol_table,
+                     const ELFSectionHeader &symtab_section,
+                     lldb::user_id_t symtab_id);
+
+    /// Loads the section name string table into m_shstr_data.  Returns the
+    /// number of bytes constituting the table.
+    size_t
+    GetSectionHeaderStringTable();
+
+    /// Utility method for looking up a section given its name.  Returns the
+    /// index of the corresponding section or zero if no section with the given
+    /// name can be found (note that section indices are always 1 based, and so
+    /// section index 0 is never valid).
+    lldb::user_id_t
+    GetSectionIndexByName(const char *name);
+
+    /// @name  ELF header dump routines
+    //@{
     static void
-    DumpELFHeader(lldb_private::Stream *s, const Elf64_Ehdr& header);
+    DumpELFHeader(lldb_private::Stream *s, const ELFHeader& header);
 
     static void
-    DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s, 
+    DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s,
                                   unsigned char ei_data);
 
     static void
-    DumpELFHeader_e_type(lldb_private::Stream *s, Elf64_Half e_type);
+    DumpELFHeader_e_type(lldb_private::Stream *s, elf_half e_type);
+    //@}
 
-    // ELF program header dump routines
+    /// @name ELF program header dump routines
+    //@{
     void
     DumpELFProgramHeaders(lldb_private::Stream *s);
 
     static void
-    DumpELFProgramHeader(lldb_private::Stream *s, const Elf64_Phdr &ph);
+    DumpELFProgramHeader(lldb_private::Stream *s, const ELFProgramHeader &ph);
 
     static void
-    DumpELFProgramHeader_p_type(lldb_private::Stream *s, Elf64_Word p_type);
+    DumpELFProgramHeader_p_type(lldb_private::Stream *s, elf_word p_type);
 
     static void
-    DumpELFProgramHeader_p_flags(lldb_private::Stream *s, Elf64_Word p_flags);
+    DumpELFProgramHeader_p_flags(lldb_private::Stream *s, elf_word p_flags);
+    //@}
 
-    // ELF section header dump routines
+    /// @name ELF section header dump routines
+    //@{
     void
     DumpELFSectionHeaders(lldb_private::Stream *s);
 
     static void
-    DumpELFSectionHeader(lldb_private::Stream *s, const Elf64_Shdr& sh);
+    DumpELFSectionHeader(lldb_private::Stream *s, const ELFSectionHeader& sh);
 
     static void
-    DumpELFSectionHeader_sh_type(lldb_private::Stream *s, Elf64_Word sh_type);
+    DumpELFSectionHeader_sh_type(lldb_private::Stream *s, elf_word sh_type);
 
     static void
-    DumpELFSectionHeader_sh_flags(lldb_private::Stream *s, Elf64_Word sh_flags);
+    DumpELFSectionHeader_sh_flags(lldb_private::Stream *s, elf_word sh_flags);
+    //@}
 
+    /// ELF dependent module dump routine.
     void
     DumpDependentModules(lldb_private::Stream *s);
 
-    size_t
-    ParseProgramHeaders();
-
-    size_t
-    ParseSectionHeaders();
-
-    size_t
-    ParseDependentModules();
-
-    void
-    ParseSymbolTable(lldb_private::Symtab *symbol_table, 
-                     const Elf64_Shdr &symtab_section,
-                     lldb::user_id_t symtab_id);
-
-    size_t
-    GetSectionHeaderStringTable();
-
-    uint32_t
-    GetSectionIndexByName(const char *name);
 };
 
-#endif // #ifndef liblldb_ObjectFileELF64_h_
+} // End elf namespace.
+
+#endif // #ifndef liblldb_ObjectFileELF_h_
Index: source/Plugins/ObjectFile/ELF/ObjectFileELF32.cpp
===================================================================
--- source/Plugins/ObjectFile/ELF/ObjectFileELF32.cpp	(revision 0)
+++ source/Plugins/ObjectFile/ELF/ObjectFileELF32.cpp	(revision 0)
@@ -0,0 +1,110 @@
+//===-- ObjectFileELF32.cpp ----------------------------------- -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/DataBuffer.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/PluginManager.h"
+
+#include "ObjectFileELF32.h"
+
+using namespace elf;
+using namespace lldb_private;
+using namespace lldb;
+
+ObjectFileELF32::~ObjectFileELF32()
+{
+}
+
+//------------------------------------------------------------------------------
+// Static methods.
+void
+ObjectFileELF32::Initialize()
+{
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(),
+                                  CreateInstance);
+}
+
+void
+ObjectFileELF32::Terminate()
+{
+    PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+const char *
+ObjectFileELF32::GetPluginNameStatic()
+{
+    return "object-file.elf32";
+}
+
+const char *
+ObjectFileELF32::GetPluginDescriptionStatic()
+{
+    return "ELF object file reader (32-bit).";
+}
+
+ObjectFile *
+ObjectFileELF32::CreateInstance(Module *module,
+                                DataBufferSP &data_sp,
+                                const FileSpec *file, addr_t offset,
+                                addr_t length)
+{
+    if (data_sp && data_sp->GetByteSize() > llvm::ELF::EI_NIDENT) {
+        const uint8_t *magic = data_sp->GetBytes() + offset;
+
+        if (ELFHeader::MagicBytesMatch(magic) &&
+            ELFHeader::AddressSizeInBytes(magic) == 4)
+        {
+            std::auto_ptr<ObjectFile> objfile_ap(
+                new ObjectFileELF32(module, data_sp, file, offset, length));
+            if (objfile_ap->ParseHeader())
+                return objfile_ap.release();
+        }
+    }
+    return NULL;
+}
+
+//------------------------------------------------------------------------------
+// PluginInterface protocol
+const char *
+ObjectFileELF32::GetPluginName()
+{
+    return "ObjectFileELF32";
+}
+
+const char *
+ObjectFileELF32::GetShortPluginName()
+{
+    return GetPluginNameStatic();
+}
+
+uint32_t
+ObjectFileELF32::GetPluginVersion()
+{
+    return m_plugin_version;
+}
+
+void
+ObjectFileELF32::GetPluginCommandHelp (const char *command, Stream *strm)
+{
+}
+
+Error
+ObjectFileELF32::ExecutePluginCommand (Args &command, Stream *strm)
+{
+    Error error;
+    error.SetErrorString("No plug-in commands are currently supported.");
+    return error;
+}
+
+Log *
+ObjectFileELF32::EnablePluginLogging (Stream *strm, Args &command)
+{
+    return NULL;
+}
Index: source/Plugins/ObjectFile/ELF/ELFHeader.h
===================================================================
--- source/Plugins/ObjectFile/ELF/ELFHeader.h	(revision 0)
+++ source/Plugins/ObjectFile/ELF/ELFHeader.h	(revision 0)
@@ -0,0 +1,295 @@
+//===-- ELFHeader.h ------------------------------------------- -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// @file
+/// @brief Generic structures and typedefs for ELF files.
+///
+/// This file provides definitions for the various entities comprising an ELF
+/// file.  The structures are generic in the sense that they do not correspond
+/// to the exact binary layout of an ELF, but can be used to hold the
+/// information present in both 32 and 64 bit variants of the format.  Each
+/// entity provides a \c Parse method which is capable of transparently reading
+/// both 32 and 64 bit instances of the object.
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_ELFHeader_h_
+#define liblldb_ELFHeader_h_
+
+#include "llvm/Support/ELF.h"
+
+#include "lldb/lldb-enumerations.h"
+
+namespace lldb_private
+{
+class DataExtractor;
+} // End namespace lldb_private.
+
+namespace elf 
+{
+
+//------------------------------------------------------------------------------
+/// @name ELF type definitions.
+///
+/// Types used to represent the various components of ELF structures.  All types
+/// are signed or unsigned integral types wide enough to hold values from both
+/// 32 and 64 bit ELF variants.
+//@{
+typedef uint64_t elf_addr;
+typedef uint64_t elf_off;
+typedef uint16_t elf_half;
+typedef uint32_t elf_word;
+typedef int32_t  elf_sword;
+typedef uint64_t elf_size;
+typedef uint64_t elf_xword;
+typedef int64_t  elf_sxword;
+//@}
+
+//------------------------------------------------------------------------------
+/// @class ELFHeader
+/// @brief Generic representation of an ELF file header.
+///
+/// This object is used to identify the general attributes on an ELF file and to
+/// locate additional sections within the file.
+struct ELFHeader 
+{
+    unsigned char e_ident[llvm::ELF::EI_NIDENT]; ///< ELF file identification.
+    elf_addr      e_entry;            ///< Virtual address program entry point.
+    elf_off       e_phoff;            ///< File offset of program header table.
+    elf_off       e_shoff;            ///< File offset of section header table.
+    elf_word      e_flags;            ///< Processor specific flags.
+    elf_word      e_version;          ///< Version of object file (always 1).
+    elf_half      e_type;             ///< Object file type.
+    elf_half      e_machine;          ///< Target architecture.
+    elf_half      e_ehsize;           ///< Byte size of the ELF header.
+    elf_half      e_phentsize;        ///< Size of a program header table entry.
+    elf_half      e_phnum;            ///< Number of program header entrys.
+    elf_half      e_shentsize;        ///< Size of a section header table entry.
+    elf_half      e_shnum;            ///< Number of section header entrys.
+    elf_half      e_shstrndx;         ///< String table section index.
+
+    ELFHeader();
+
+    //--------------------------------------------------------------------------
+    /// Returns true if this is a 32 bit ELF file header.
+    ///
+    /// @return
+    ///    True if this is a 32 bit ELF file header.
+    bool Is32Bit() const { 
+        return e_ident[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS32; 
+    }
+
+    //--------------------------------------------------------------------------
+    /// Returns true if this is a 64 bit ELF file header.
+    ///
+    /// @return
+    ///   True if this is a 64 bit ELF file header.
+    bool Is64Bit() const { 
+        return e_ident[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS64; 
+    }
+
+    //--------------------------------------------------------------------------
+    /// The byte order of this ELF file header.
+    ///
+    /// @return
+    ///    The byte order of this ELF file as described by the header.
+    lldb::ByteOrder
+    GetByteOrder() const;
+
+    //--------------------------------------------------------------------------
+    /// Parse an ELFSectionHeader entry starting at position \p offset and
+    /// update the data extractor with the address size and byte order
+    /// attributes as defined by the header.
+    ///
+    /// @param[in,out] data
+    ///    The DataExtractor to read from.  Updated with the address size and
+    ///    byte order attributes appropriate to this header.
+    ///
+    /// @param[in,out] offset
+    ///    Pointer to an offset in the data.  On return the offset will be
+    ///    advanced by the number of bytes read.
+    ///
+    /// @return
+    ///    True if the ELFSectionHeader was successfully read and false
+    ///    otherwise.
+    bool
+    Parse(lldb_private::DataExtractor &data, uint32_t *offset);
+
+    //--------------------------------------------------------------------------
+    /// Examines at most EI_NIDENT bytes starting from the given pointer and
+    /// determines if the magic ELF identification exists.
+    ///
+    /// @return
+    ///    True if the given sequence of bytes identifies an ELF file.
+    static bool
+    MagicBytesMatch(const uint8_t *magic);
+
+    //--------------------------------------------------------------------------
+    /// Examines at most EI_NIDENT bytes starting from the given address and
+    /// determines the address size of the underlying ELF file.  This function
+    /// should only be called on an pointer for which MagicBytesMatch returns
+    /// true.
+    ///
+    /// @return
+    ///    The number of bytes forming an address in the ELF file (either 4 or
+    ///    8), else zero if the address size could not be determined.
+    static unsigned
+    AddressSizeInBytes(const uint8_t *magic);
+};
+
+//------------------------------------------------------------------------------
+/// @class ELFSectionHeader
+/// @brief Generic representation of an ELF section header.
+struct ELFSectionHeader 
+{
+    elf_word  sh_name;          ///< Section name string index.
+    elf_word  sh_type;          ///< Section type.
+    elf_xword sh_flags;         ///< Section attributes. 
+    elf_addr  sh_addr;          ///< Virtual address of the section in memory.
+    elf_off   sh_offset;        ///< Start of section from beginning of file.
+    elf_xword sh_size;          ///< Number of bytes occupied in the file.
+    elf_word  sh_link;          ///< Index of associated section.
+    elf_word  sh_info;          ///< Extra section info (overloaded).
+    elf_xword sh_addralign;     ///< Power of two alignment constraint.
+    elf_xword sh_entsize;       ///< Byte size of each section entry.
+
+    ELFSectionHeader();
+
+    //--------------------------------------------------------------------------
+    /// Parse an ELFSectionHeader entry from the given DataExtracter starting at
+    /// position \p offset.
+    ///
+    /// @param[in] data
+    ///    The DataExtractor to read from.  The address size of the extractor
+    ///    determines if a 32 or 64 bit object should be read.
+    ///
+    /// @param[in,out] offset
+    ///    Pointer to an offset in the data.  On return the offset will be
+    ///    advanced by the number of bytes read.
+    ///
+    /// @return
+    ///    True if the ELFSectionHeader was successfully read and false
+    ///    otherwise.
+    bool
+    Parse(const lldb_private::DataExtractor &data, uint32_t *offset);
+};
+
+//------------------------------------------------------------------------------
+/// @class ELFProgramHeader
+/// @brief Generic representation of an ELF program header.
+struct ELFProgramHeader
+{
+    elf_word  p_type;           ///< Type of program segement.
+    elf_word  p_flags;          ///< Segement attibutes.
+    elf_off   p_offset;         ///< Start of segment from begining of file.
+    elf_addr  p_vaddr;          ///< Virtual address of segment in memory.
+    elf_addr  p_paddr;          ///< Physical address (for non-VM systems). 
+    elf_xword p_filesz;         ///< Byte size of the segment in file.
+    elf_xword p_memsz;          ///< Byte size of the segment in memory.
+    elf_xword p_align;          ///< Segement alignement constraint.
+
+    ELFProgramHeader();
+
+    /// Parse an ELFProgramHeader entry from the given DataExtracter starting at
+    /// position \p offset.  The address size of the DataExtracter determines if
+    /// a 32 or 64 bit object is to be parsed.
+    ///
+    /// @param[in] data
+    ///    The DataExtractor to read from.  The address size of the extractor
+    ///    determines if a 32 or 64 bit object should be read.
+    ///
+    /// @param[in,out] offset
+    ///    Pointer to an offset in the data.  On return the offset will be
+    ///    advanced by the number of bytes read.
+    ///
+    /// @return
+    ///    True if the ELFProgramHeader was successfully read and false
+    ///    otherwise.
+    bool
+    Parse(const lldb_private::DataExtractor &data, uint32_t *offset);
+};
+
+//------------------------------------------------------------------------------
+/// @class ELFSymbol
+/// @brief Represents a symbol within an ELF symbol table.
+struct ELFSymbol
+{
+    elf_addr      st_value;     ///< Absolute or relocatable address.
+    elf_xword     st_size;      ///< Size of the symbol or zero.
+    elf_word      st_name;      ///< Symbol name string index.
+    unsigned char st_info;      ///< Symbol type and binding attributes.
+    unsigned char st_other;     ///< Reserved for future use.
+    elf_half      st_shndx;     ///< Section to which this symbol applies.
+
+    ELFSymbol();
+
+    /// Returns the binding attribute of the st_info member.
+    unsigned char getBinding() const { return st_info >> 4; }
+
+    /// Returns the type attribute of the st_info member.
+    unsigned char getType() const { return st_info & 0x0F; }
+
+    /// Sets the bining and type of the st_info member.
+    void setBindingAndType(unsigned char binding, unsigned char type) {
+        st_info = (binding << 4) + (type & 0x0F);
+    }
+
+    /// Parse an ELFSymbol entry from the given DataExtracter starting at
+    /// position \p offset.  The address size of the DataExtracter determines if
+    /// a 32 or 64 bit object is to be parsed.
+    ///
+    /// @param[in] data
+    ///    The DataExtractor to read from.  The address size of the extractor
+    ///    determines if a 32 or 64 bit object should be read.
+    ///
+    /// @param[in,out] offset
+    ///    Pointer to an offset in the data.  On return the offset will be
+    ///    advanced by the number of bytes read.
+    ///
+    /// @return
+    ///    True if the ELFSymbol was successfully read and false otherwise.
+    bool
+    Parse(const lldb_private::DataExtractor &data, uint32_t *offset);
+};
+
+//------------------------------------------------------------------------------
+/// @class ELFDynamic
+/// @brief Represents an entry in an ELF dynamic table.
+struct ELFDynamic
+{
+    elf_sxword d_tag;           ///< Type of dynamic table entry.
+    union
+    {
+        elf_xword d_val;        ///< Integer value of the table entry.
+        elf_addr  d_ptr;        ///< Pointer value of the table entry.
+    };
+
+    ELFDynamic();
+
+    /// Parse an ELFDynamic entry from the given DataExtracter starting at
+    /// position \p offset.  The address size of the DataExtracter determines if
+    /// a 32 or 64 bit object is to be parsed.
+    ///
+    /// @param[in] data
+    ///    The DataExtractor to read from.  The address size of the extractor
+    ///    determines if a 32 or 64 bit object should be read.
+    ///
+    /// @param[in,out] offset
+    ///    Pointer to an offset in the data.  On return the offset will be
+    ///    advanced by the number of bytes read.
+    ///
+    /// @return
+    ///    True if the ELFDynamic entry was successfully read and false
+    ///    otherwise.
+    bool
+    Parse(const lldb_private::DataExtractor &data, uint32_t *offset);
+};
+
+} // End namespace elf.
+
+#endif // #ifndef liblldb_ELFHeader_h_
Index: source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp
===================================================================
--- source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp	(revision 108210)
+++ source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp	(working copy)
@@ -7,25 +7,23 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "ObjectFileELF64.h"
-
-#include <cassert>
-
-#include <algorithm>
-
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Section.h"
-#include "lldb/Core/Stream.h"
 
-#define CASE_AND_STREAM(s, def, width)                  \
-    case def: s->Printf("%-*s", width, #def); break;
+#include "ObjectFileELF64.h"
 
-using namespace lldb;
+using namespace elf;
 using namespace lldb_private;
+using namespace lldb;
 
+ObjectFileELF64::~ObjectFileELF64()
+{
+}
+
+//------------------------------------------------------------------
+// Static methods.
+//------------------------------------------------------------------
 void
 ObjectFileELF64::Initialize()
 {
@@ -54,928 +52,25 @@
 
 ObjectFile *
 ObjectFileELF64::CreateInstance(Module *module,
-                                DataBufferSP &dataSP,
+                                DataBufferSP &data_sp,
                                 const FileSpec *file, addr_t offset,
                                 addr_t length)
 {
-    if (ObjectFileELF64::MagicBytesMatch(dataSP))
-    {
-        std::auto_ptr<ObjectFile> objfile_ap(
-            new ObjectFileELF64(module, dataSP, file, offset, length));
-        if (objfile_ap->ParseHeader())
-            return objfile_ap.release();
-    }
-    return NULL;
-}
+    if (data_sp && data_sp->GetByteSize() > llvm::ELF::EI_NIDENT) {
+        const uint8_t *magic = data_sp->GetBytes() + offset;
 
-bool
-ObjectFileELF64::MagicBytesMatch(DataBufferSP& data_sp)
-{
-    if (data_sp && data_sp->GetByteSize() > EI_PAD)
-    {
-        const uint8_t* magic = data_sp->GetBytes();
-        if (magic != NULL)
+        if (ELFHeader::MagicBytesMatch(magic) &&
+            ELFHeader::AddressSizeInBytes(magic) == 8)
         {
-            bool have_magic = (magic[EI_MAG0] == 0x7f &&
-                               magic[EI_MAG1] == 'E'  &&
-                               magic[EI_MAG2] == 'L'  &&
-                               magic[EI_MAG3] == 'F');
-        
-            bool have_64bit = magic[EI_CLASS] == ELFCLASS64;
-        
-            return have_magic && have_64bit;
+            std::auto_ptr<ObjectFile> objfile_ap(
+                new ObjectFileELF64(module, data_sp, file, offset, length));
+            if (objfile_ap->ParseHeader())
+                return objfile_ap.release();
         }
     }
-    return false;
+    return NULL;
 }
 
-ObjectFileELF64::ObjectFileELF64(Module* module, DataBufferSP& dataSP,
-                                 const FileSpec* file, addr_t offset,
-                                 addr_t length)
-    : ObjectFile(module, file, offset, length, dataSP),
-      m_header(),
-      m_program_headers(),
-      m_section_headers(),
-      m_sections_ap(),
-      m_symtab_ap(),
-      m_filespec_ap(),
-      m_shstr_data()
-{
-    if (file)
-        m_file = *file;
-    ::memset(&m_header, 0, sizeof(m_header));
-}
-
-
-ObjectFileELF64::~ObjectFileELF64()
-{
-}
-
-ByteOrder
-ObjectFileELF64::GetByteOrder() const
-{
-    if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
-        return eByteOrderBig;
-    if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
-        return eByteOrderLittle;
-    return eByteOrderInvalid;
-}
-
-size_t
-ObjectFileELF64::GetAddressByteSize() const
-{
-    return m_data.GetAddressByteSize();
-}
-
-unsigned
-ObjectFileELF64::SectionIndex(const SectionHeaderCollIter &I)
-{
-    return std::distance(m_section_headers.begin(), I) + 1;
-}
-
-unsigned
-ObjectFileELF64::SectionIndex(const SectionHeaderCollConstIter &I) const
-{
-    return std::distance(m_section_headers.begin(), I) + 1;
-}
-
-bool
-ObjectFileELF64::ParseHeader()
-{
-    m_data.SetAddressByteSize(8);
-    uint32_t offset = GetOffset();
-    if (m_data.GetU8(&offset, m_header.e_ident, EI_NIDENT) == NULL)
-        return false;
-
-    m_data.SetByteOrder(GetByteOrder());
-
-    // Read e_type and e_machine.
-    if (m_data.GetU16(&offset, &m_header.e_type, 2) == NULL)
-        return false;
-
-    // Read e_version.
-    if (m_data.GetU32(&offset, &m_header.e_version, 1) == NULL)
-        return false;
-
-    // Read e_entry, e_phoff and e_shoff.
-    if (m_data.GetU64(&offset, &m_header.e_entry, 3) == NULL)
-        return false;
-
-    // Read e_flags.
-    if (m_data.GetU32(&offset, &m_header.e_flags, 1) == NULL)
-        return false;
-
-    // Read e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum and e_shstrndx.
-    if (m_data.GetU16(&offset, &m_header.e_ehsize, 6) == NULL)
-        return false;
-
-    return true;
-}
-
-bool
-ObjectFileELF64::GetUUID(UUID* uuid)
-{
-    // FIXME: Return MD5 sum here.  See comment in ObjectFile.h.
-    return false;
-}
-
-uint32_t
-ObjectFileELF64::GetDependentModules(FileSpecList &files)
-{
-    size_t num_modules = ParseDependentModules();
-    uint32_t num_specs = 0;
-
-    for (unsigned i = 0; i < num_modules; ++i)
-    {
-        if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i)))
-            num_specs++;
-    }
-
-    return num_specs;
-}
-
-//----------------------------------------------------------------------
-// ParseDependentModules
-//----------------------------------------------------------------------
-size_t
-ObjectFileELF64::ParseDependentModules()
-{
-    if (m_filespec_ap.get())
-        return m_filespec_ap->GetSize();
-
-    m_filespec_ap.reset(new FileSpecList());
-
-    if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
-        return 0;
-
-    // Locate the dynamic table.
-    user_id_t dynsym_id = 0;
-    user_id_t dynstr_id = 0;
-    for (SectionHeaderCollIter I = m_section_headers.begin();
-         I != m_section_headers.end(); ++I)
-    {
-        if (I->sh_type == SHT_DYNAMIC)
-        {
-            dynsym_id = SectionIndex(I);
-            dynstr_id = I->sh_link + 1; // Section ID's are 1 based.
-            break;
-        }
-    }
-
-    if (!(dynsym_id && dynstr_id))
-        return 0;
-
-    SectionList *section_list = GetSectionList();
-    if (!section_list)
-        return 0;
-
-    // Resolve and load the dynamic table entries and corresponding string
-    // table.
-    Section *dynsym = section_list->FindSectionByID(dynsym_id).get();
-    Section *dynstr = section_list->FindSectionByID(dynstr_id).get();
-    if (!(dynsym && dynstr))
-        return 0;
-
-    DataExtractor dynsym_data;
-    DataExtractor dynstr_data;
-    if (dynsym->ReadSectionDataFromObjectFile(this, dynsym_data) &&
-        dynstr->ReadSectionDataFromObjectFile(this, dynstr_data))
-    {
-        Elf64_Dyn symbol;
-        const unsigned num_syms = dynsym_data.GetByteSize() / sizeof(Elf64_Dyn);
-        unsigned offset = 0;
-
-        // The only type of entries we are concerned with are tagged DT_NEEDED,
-        // yielding the name of a required library.
-        for (unsigned i = 0; i < num_syms; ++i)
-        {
-            if (!dynsym_data.ValidOffsetForDataOfSize(offset, sizeof(Elf64_Dyn)))
-                break;
-
-            symbol.d_tag = dynsym_data.GetU64(&offset);
-            symbol.d_un.d_val = dynsym_data.GetU64(&offset);
-
-            if (symbol.d_tag != DT_NEEDED)
-                continue;
-
-            const char *lib_name = dynstr_data.PeekCStr(symbol.d_un.d_val);
-            m_filespec_ap->Append(FileSpec(lib_name));
-        }
-    }
-
-    return m_filespec_ap->GetSize();
-}
-
-//----------------------------------------------------------------------
-// ParseProgramHeaders
-//----------------------------------------------------------------------
-size_t
-ObjectFileELF64::ParseProgramHeaders()
-{
-    // We have already parsed the program headers
-    if (!m_program_headers.empty())
-        return m_program_headers.size();
-
-    // If there are no program headers to read we are done.
-    if (m_header.e_phnum == 0)
-        return 0;
-
-    m_program_headers.resize(m_header.e_phnum);
-    if (m_program_headers.size() != m_header.e_phnum)
-        return 0;
-
-    const size_t ph_size = m_header.e_phnum * m_header.e_phentsize;
-    const Elf64_Off ph_offset = m_offset + m_header.e_phoff;
-    DataBufferSP buffer_sp(m_file.ReadFileContents(ph_offset, ph_size));
-
-    if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != ph_size)
-        return 0;
-
-    DataExtractor data(buffer_sp, m_data.GetByteOrder(),
-                       m_data.GetAddressByteSize());
-
-    uint32_t idx;
-    uint32_t offset;
-    for (idx = 0, offset = 0; idx < m_header.e_phnum; ++idx)
-    {
-        if (data.GetU32(&offset, &m_program_headers[idx], 8) == NULL)
-            return 0;
-    }
-
-    if (idx < m_program_headers.size())
-        m_program_headers.resize(idx);
-
-    return m_program_headers.size();
-}
-
-//----------------------------------------------------------------------
-// ParseSectionHeaders
-//----------------------------------------------------------------------
-size_t
-ObjectFileELF64::ParseSectionHeaders()
-{
-    // We have already parsed the section headers
-    if (!m_section_headers.empty())
-        return m_section_headers.size();
-
-    // If there are no section headers we are done.
-    if (m_header.e_shnum == 0)
-        return 0;
-
-    m_section_headers.resize(m_header.e_shnum);
-    if (m_section_headers.size() != m_header.e_shnum)
-        return 0;
-
-    const size_t sh_size = m_header.e_shnum * m_header.e_shentsize;
-    const Elf64_Off sh_offset = m_offset + m_header.e_shoff;
-    DataBufferSP buffer_sp(m_file.ReadFileContents(sh_offset, sh_size));
-
-    if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != sh_size)
-        return 0;
-
-    DataExtractor data(buffer_sp,
-                       m_data.GetByteOrder(),
-                       m_data.GetAddressByteSize());
-
-    uint32_t idx;
-    uint32_t offset;
-    for (idx = 0, offset = 0; idx < m_header.e_shnum; ++idx)
-    {
-        // Read sh_name and sh_type.
-        if (data.GetU32(&offset, &m_section_headers[idx].sh_name, 2) == NULL)
-            break;
-
-        // Read sh_flags, sh_addr, sh_offset and sh_size.
-        if (data.GetU64(&offset, &m_section_headers[idx].sh_flags, 4) == NULL)
-            break;
-
-        // Read sh_link and sh_info.
-        if (data.GetU32(&offset, &m_section_headers[idx].sh_link, 2) == NULL)
-            break;
-
-        // Read sh_addralign and sh_entsize.
-        if (data.GetU64(&offset, &m_section_headers[idx].sh_addralign, 2) == NULL)
-            break;
-    }
-    if (idx < m_section_headers.size())
-        m_section_headers.resize(idx);
-
-    return m_section_headers.size();
-}
-
-size_t
-ObjectFileELF64::GetSectionHeaderStringTable()
-{
-    if (m_shstr_data.GetByteSize() == 0)
-    {
-        if (m_header.e_shstrndx && m_header.e_shstrndx < m_section_headers.size())
-        {
-            const Elf64_Shdr &sheader = m_section_headers[m_header.e_shstrndx];
-            const size_t byte_size = sheader.sh_size;
-            const Elf64_Off offset = m_offset + sheader.sh_offset;
-            DataBufferSP buffer_sp(m_file.ReadFileContents(offset, byte_size));
-
-            if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != byte_size)
-                return 0;
-
-            m_shstr_data.SetData(buffer_sp);
-        }
-    }
-    return m_shstr_data.GetByteSize();
-}
-
-uint32_t
-ObjectFileELF64::GetSectionIndexByName(const char *name)
-{
-    if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
-        return UINT32_MAX;
-
-    // Search the collection of section headers for one with a matching name.
-    for (SectionHeaderCollIter I = m_section_headers.begin();
-         I != m_section_headers.end(); ++I)
-    {
-        const char *sectionName = m_shstr_data.PeekCStr(I->sh_name);
-
-        if (!sectionName)
-            return UINT32_MAX;
-
-        if (strcmp(name, sectionName) != 0)
-            continue;
-
-        return SectionIndex(I);
-    }
-
-    return UINT32_MAX;
-}
-
-SectionList *
-ObjectFileELF64::GetSectionList()
-{
-    if (m_sections_ap.get())
-        return m_sections_ap.get();
-
-    if (ParseSectionHeaders() && GetSectionHeaderStringTable())
-    {
-        m_sections_ap.reset(new SectionList());
-
-        for (SectionHeaderCollIter I = m_section_headers.begin();
-             I != m_section_headers.end(); ++I)
-        {
-            const Elf64_Shdr &header = *I;
-
-            ConstString name(m_shstr_data.PeekCStr(header.sh_name));
-            uint64_t size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
-
-            SectionSP section(new Section(
-                0,                 // Parent section.
-                GetModule(),       // Module to which this section belongs.
-                SectionIndex(I),   // Section ID.
-                name,              // Section name.
-                eSectionTypeOther, // FIXME: Fill in as appropriate.
-                header.sh_addr,    // VM address.
-                header.sh_size,    // VM size in bytes of this section.
-                header.sh_offset,  // Offset of this section in the file.
-                size,              // Size of the section as found in the file.
-                header.sh_flags)); // Flags for this section.
-
-            m_sections_ap->AddSection(section);
-        }
-    }
-
-    return m_sections_ap.get();
-}
-
-static void
-ParseSymbols(Symtab *symtab, SectionList *section_list,
-             const Elf64_Shdr &symtab_shdr,
-             const DataExtractor &symtab_data,
-             const DataExtractor &strtab_data)
-{
-    assert (sizeof(Elf64_Sym) == symtab_shdr.sh_entsize);
-    const unsigned numSymbols = symtab_data.GetByteSize() / sizeof(Elf64_Sym);
-    unsigned offset = 0;
-    Elf64_Sym symbol;
-
-    static ConstString text_section_name(".text");
-    static ConstString init_section_name(".init");
-    static ConstString fini_section_name(".fini");
-    static ConstString ctors_section_name(".ctors");
-    static ConstString dtors_section_name(".dtors");
-
-    static ConstString data_section_name(".data");
-    static ConstString rodata_section_name(".rodata");
-    static ConstString rodata1_section_name(".rodata1");
-    static ConstString data2_section_name(".data1");
-    static ConstString bss_section_name(".bss");
-
-    for (unsigned i = 0; i < numSymbols; ++i)
-    {
-        if (!symtab_data.ValidOffsetForDataOfSize(offset, sizeof(Elf64_Sym)))
-            break;
-
-        symbol.st_name  = symtab_data.GetU32(&offset);
-        symbol.st_info  = symtab_data.GetU8(&offset);
-        symbol.st_other = symtab_data.GetU8(&offset);
-        symbol.st_shndx = symtab_data.GetU16(&offset);
-        symbol.st_value = symtab_data.GetU64(&offset);
-        symbol.st_size  = symtab_data.GetU64(&offset);
-
-        Section *symbol_section = NULL;
-        SymbolType symbol_type = eSymbolTypeInvalid;
-        Elf64_Half symbol_idx = symbol.st_shndx;
-
-        switch (symbol_idx)
-        {
-        case SHN_ABS:
-            symbol_type = eSymbolTypeAbsolute;
-            break;
-        case SHN_UNDEF:
-            symbol_type = eSymbolTypeUndefined;
-            break;
-        default:
-            symbol_section = section_list->GetSectionAtIndex(symbol_idx).get();
-            break;
-        }
-
-        switch (ELF_ST_TYPE(symbol.st_info))
-        {
-        default:
-        case STT_NOTYPE:
-            // The symbol's type is not specified.
-            break;
-
-        case STT_OBJECT:
-            // The symbol is associated with a data object, such as a variable,
-            // an array, etc.
-            symbol_type = eSymbolTypeData;
-            break;
-
-        case STT_FUNC:
-            // The symbol is associated with a function or other executable code.
-            symbol_type = eSymbolTypeCode;
-            break;
-
-        case STT_SECTION:
-            // The symbol is associated with a section. Symbol table entries of
-            // this type exist primarily for relocation and normally have
-            // STB_LOCAL binding.
-            break;
-
-        case STT_FILE:
-            // Conventionally, the symbol's name gives the name of the source
-            // file associated with the object file. A file symbol has STB_LOCAL
-            // binding, its section index is SHN_ABS, and it precedes the other
-            // STB_LOCAL symbols for the file, if it is present.
-            symbol_type = eSymbolTypeObjectFile;
-            break;
-        }
-
-        if (symbol_type == eSymbolTypeInvalid)
-        {
-            if (symbol_section)
-            {
-                const ConstString &sect_name = symbol_section->GetName();
-                if (sect_name == text_section_name ||
-                    sect_name == init_section_name ||
-                    sect_name == fini_section_name ||
-                    sect_name == ctors_section_name ||
-                    sect_name == dtors_section_name)
-                {
-                    symbol_type = eSymbolTypeCode;
-                }
-                else if (sect_name == data_section_name ||
-                         sect_name == data2_section_name ||
-                         sect_name == rodata_section_name ||
-                         sect_name == rodata1_section_name ||
-                         sect_name == bss_section_name)
-                {
-                    symbol_type = eSymbolTypeData;
-                }
-            }
-        }
-
-        uint64_t symbol_value = symbol.st_value;
-        if (symbol_section != NULL)
-            symbol_value -= symbol_section->GetFileAddress();
-        const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
-        bool is_global = ELF_ST_BIND(symbol.st_info) == STB_GLOBAL;
-        uint32_t flags = symbol.st_other << 8 | symbol.st_info;
-
-        Symbol dc_symbol(
-            i,               // ID is the original symbol table index.
-            symbol_name,     // symbol name.
-            false,           // Is the symbol name mangled?
-            symbol_type,     // type of this symbol
-            is_global,       // Is this globally visible?
-            false,           // Is this symbol debug info?
-            false,           // Is this symbol a trampoline?
-            false,           // Is this symbol artificial?
-            symbol_section,  // Section in which this symbol is defined or null.
-            symbol_value,    // Offset in section or symbol value.
-            symbol.st_size,  // size in bytes of this symbol.
-            flags);          // Symbol flags.
-        symtab->AddSymbol(dc_symbol);
-    }
-}
-
-void
-ObjectFileELF64::ParseSymbolTable(Symtab *symbol_table,
-                                  const Elf64_Shdr &symtab_hdr,
-                                  user_id_t symtab_id)
-{
-    assert(symtab_hdr.sh_type == SHT_SYMTAB || 
-           symtab_hdr.sh_type == SHT_DYNSYM);
-
-    // Parse in the section list if needed.
-    SectionList *section_list = GetSectionList();
-    if (!section_list)
-        return;
-
-    // Section ID's are ones based.
-    user_id_t strtab_id = symtab_hdr.sh_link + 1;
-
-    Section *symtab = section_list->FindSectionByID(symtab_id).get();
-    Section *strtab = section_list->FindSectionByID(strtab_id).get();
-    if (symtab && strtab)
-    {
-        DataExtractor symtab_data;
-        DataExtractor strtab_data;
-        if (symtab->ReadSectionDataFromObjectFile(this, symtab_data) &&
-            strtab->ReadSectionDataFromObjectFile(this, strtab_data))
-        {
-            ParseSymbols(symbol_table, section_list, symtab_hdr,
-                         symtab_data, strtab_data);
-        }
-    }
-}
-
-Symtab *
-ObjectFileELF64::GetSymtab()
-{
-    if (m_symtab_ap.get())
-        return m_symtab_ap.get();
-
-    Symtab *symbol_table = new Symtab(this);
-    m_symtab_ap.reset(symbol_table);
-
-    if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
-        return symbol_table;
-
-    // Locate and parse all linker symbol tables.
-    for (SectionHeaderCollIter I = m_section_headers.begin();
-         I != m_section_headers.end(); ++I)
-    {
-        if (I->sh_type == SHT_SYMTAB || I->sh_type == SHT_DYNSYM)
-        {
-            const Elf64_Shdr &symtab_section = *I;
-            user_id_t section_id = SectionIndex(I);
-            ParseSymbolTable(symbol_table, symtab_section, section_id);
-        }
-    }
-
-    return symbol_table;
-}
-
-//===----------------------------------------------------------------------===//
-// Dump
-//
-// Dump the specifics of the runtime file container (such as any headers
-// segments, sections, etc).
-// ----------------------------------------------------------------------
-void
-ObjectFileELF64::Dump(Stream *s)
-{
-    DumpELFHeader(s, m_header);
-    s->EOL();
-    DumpELFProgramHeaders(s);
-    s->EOL();
-    DumpELFSectionHeaders(s);
-    s->EOL();
-    SectionList *section_list = GetSectionList();
-    if (section_list)
-        section_list->Dump(s, NULL, true);
-    Symtab *symtab = GetSymtab();
-    if (symtab)
-        symtab->Dump(s, NULL);
-    s->EOL();
-    DumpDependentModules(s);
-    s->EOL();
-}
-
-//----------------------------------------------------------------------
-// DumpELFHeader
-//
-// Dump the ELF header to the specified output stream
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFHeader(Stream *s, const Elf64_Ehdr& header)
-{
-
-    s->PutCString("ELF Header\n");
-    s->Printf("e_ident[EI_MAG0   ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
-    s->Printf("e_ident[EI_MAG1   ] = 0x%2.2x '%c'\n",
-              header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]);
-    s->Printf("e_ident[EI_MAG2   ] = 0x%2.2x '%c'\n",
-              header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]);
-    s->Printf("e_ident[EI_MAG3   ] = 0x%2.2x '%c'\n",
-              header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]);
-
-    s->Printf("e_ident[EI_CLASS  ] = 0x%2.2x\n", header.e_ident[EI_CLASS]);
-    s->Printf("e_ident[EI_DATA   ] = 0x%2.2x ", header.e_ident[EI_DATA]);
-    DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]);
-    s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]);
-    s->Printf ("e_ident[EI_PAD    ] = 0x%2.2x\n", header.e_ident[EI_PAD]);
-
-    s->Printf("e_type      = 0x%4.4x ", header.e_type);
-    DumpELFHeader_e_type(s, header.e_type);
-    s->Printf("\ne_machine   = 0x%4.4x\n", header.e_machine);
-    s->Printf("e_version   = 0x%8.8x\n", header.e_version);
-    s->Printf("e_entry     = 0x%8.8x\n", header.e_entry);
-    s->Printf("e_phoff     = 0x%8.8x\n", header.e_phoff);
-    s->Printf("e_shoff     = 0x%8.8x\n", header.e_shoff);
-    s->Printf("e_flags     = 0x%8.8x\n", header.e_flags);
-    s->Printf("e_ehsize    = 0x%4.4x\n", header.e_ehsize);
-    s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
-    s->Printf("e_phnum     = 0x%4.4x\n", header.e_phnum);
-    s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
-    s->Printf("e_shnum     = 0x%4.4x\n", header.e_shnum);
-    s->Printf("e_shstrndx  = 0x%4.4x\n", header.e_shstrndx);
-}
-
-//----------------------------------------------------------------------
-// DumpELFHeader_e_type
-//
-// Dump an token value for the ELF header member e_type
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFHeader_e_type(Stream *s, Elf64_Half e_type)
-{
-    switch (e_type)
-    {
-    case ET_NONE:   *s << "ET_NONE"; break;
-    case ET_REL:    *s << "ET_REL"; break;
-    case ET_EXEC:   *s << "ET_EXEC"; break;
-    case ET_DYN:    *s << "ET_DYN"; break;
-    case ET_CORE:   *s << "ET_CORE"; break;
-    default:
-        break;
-    }
-}
-
-//----------------------------------------------------------------------
-// DumpELFHeader_e_ident_EI_DATA
-//
-// Dump an token value for the ELF header member e_ident[EI_DATA]
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data)
-{
-    switch (ei_data)
-    {
-    case ELFDATANONE:   *s << "ELFDATANONE"; break;
-    case ELFDATA2LSB:   *s << "ELFDATA2LSB - Little Endian"; break;
-    case ELFDATA2MSB:   *s << "ELFDATA2MSB - Big Endian"; break;
-    default:
-        break;
-    }
-}
-
-
-//----------------------------------------------------------------------
-// DumpELFProgramHeader
-//
-// Dump a single ELF program header to the specified output stream
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFProgramHeader(Stream *s, const Elf64_Phdr &ph)
-{
-    DumpELFProgramHeader_p_type(s, ph.p_type);
-    s->Printf(" %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x (",
-              ph.p_offset, ph.p_vaddr, ph.p_paddr, ph.p_filesz, ph.p_memsz,
-              ph.p_flags);
-    DumpELFProgramHeader_p_flags(s, ph.p_flags);
-    s->Printf(") %8.8x", ph.p_align);
-}
-
-//----------------------------------------------------------------------
-// DumpELFProgramHeader_p_type
-//
-// Dump an token value for the ELF program header member p_type which
-// describes the type of the program header
-// ----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFProgramHeader_p_type(Stream *s, Elf64_Word p_type)
-{
-    const int kStrWidth = 10;
-    switch (p_type)
-    {
-    CASE_AND_STREAM(s, PT_NULL      , kStrWidth);
-    CASE_AND_STREAM(s, PT_LOAD      , kStrWidth);
-    CASE_AND_STREAM(s, PT_DYNAMIC   , kStrWidth);
-    CASE_AND_STREAM(s, PT_INTERP    , kStrWidth);
-    CASE_AND_STREAM(s, PT_NOTE      , kStrWidth);
-    CASE_AND_STREAM(s, PT_SHLIB     , kStrWidth);
-    CASE_AND_STREAM(s, PT_PHDR      , kStrWidth);
-    default:
-        s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
-        break;
-    }
-}
-
-
-//----------------------------------------------------------------------
-// DumpELFProgramHeader_p_flags
-//
-// Dump an token value for the ELF program header member p_flags
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFProgramHeader_p_flags(Stream *s, Elf64_Word p_flags)
-{
-    *s  << ((p_flags & PF_X) ? "PF_X" : "    ")
-        << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
-        << ((p_flags & PF_W) ? "PF_W" : "    ")
-        << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ')
-        << ((p_flags & PF_R) ? "PF_R" : "    ");
-}
-
-//----------------------------------------------------------------------
-// DumpELFProgramHeaders
-//
-// Dump all of the ELF program header to the specified output stream
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFProgramHeaders(Stream *s)
-{
-    if (ParseProgramHeaders())
-    {
-        s->PutCString("Program Headers\n");
-        s->PutCString("IDX  p_type     p_offset p_vaddr  p_paddr  "
-                      "p_filesz p_memsz  p_flags                   p_align\n");
-        s->PutCString("==== ---------- -------- -------- -------- "
-                      "-------- -------- ------------------------- --------\n");
-
-        uint32_t idx = 0;
-        for (ProgramHeaderCollConstIter I = m_program_headers.begin();
-             I != m_program_headers.end(); ++I, ++idx)
-        {
-            s->Printf("[%2u] ", idx);
-            ObjectFileELF64::DumpELFProgramHeader(s, *I);
-            s->EOL();
-        }
-    }
-}
-
-//----------------------------------------------------------------------
-// DumpELFSectionHeader
-//
-// Dump a single ELF section header to the specified output stream
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFSectionHeader(Stream *s, const Elf64_Shdr &sh)
-{
-    s->Printf("%8.8x ", sh.sh_name);
-    DumpELFSectionHeader_sh_type(s, sh.sh_type);
-    s->Printf(" %8.8x (", sh.sh_flags);
-    DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
-    s->Printf(") %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x",
-              sh.sh_addr, sh.sh_offset, sh.sh_size, sh.sh_link, sh.sh_info,
-              sh.sh_addralign, sh.sh_entsize);
-}
-
-//----------------------------------------------------------------------
-// DumpELFSectionHeader_sh_type
-//
-// Dump an token value for the ELF section header member sh_type which
-// describes the type of the section
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFSectionHeader_sh_type(Stream *s, Elf64_Word sh_type)
-{
-    const int kStrWidth = 12;
-    switch (sh_type)
-    {
-    CASE_AND_STREAM(s, SHT_NULL     , kStrWidth);
-    CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth);
-    CASE_AND_STREAM(s, SHT_SYMTAB   , kStrWidth);
-    CASE_AND_STREAM(s, SHT_STRTAB   , kStrWidth);
-    CASE_AND_STREAM(s, SHT_RELA     , kStrWidth);
-    CASE_AND_STREAM(s, SHT_HASH     , kStrWidth);
-    CASE_AND_STREAM(s, SHT_DYNAMIC  , kStrWidth);
-    CASE_AND_STREAM(s, SHT_NOTE     , kStrWidth);
-    CASE_AND_STREAM(s, SHT_NOBITS   , kStrWidth);
-    CASE_AND_STREAM(s, SHT_REL      , kStrWidth);
-    CASE_AND_STREAM(s, SHT_SHLIB    , kStrWidth);
-    CASE_AND_STREAM(s, SHT_DYNSYM   , kStrWidth);
-    CASE_AND_STREAM(s, SHT_LOPROC   , kStrWidth);
-    CASE_AND_STREAM(s, SHT_HIPROC   , kStrWidth);
-    CASE_AND_STREAM(s, SHT_LOUSER   , kStrWidth);
-    CASE_AND_STREAM(s, SHT_HIUSER   , kStrWidth);
-    default:
-        s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
-        break;
-    }
-}
-
-//----------------------------------------------------------------------
-// DumpELFSectionHeader_sh_flags
-//
-// Dump an token value for the ELF section header member sh_flags
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFSectionHeader_sh_flags(Stream *s, Elf64_Word sh_flags)
-{
-    *s  << ((sh_flags & SHF_WRITE) ? "WRITE" : "     ")
-        << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
-        << ((sh_flags & SHF_ALLOC) ? "ALLOC" : "     ")
-        << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ')
-        << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : "         ");
-}
-
-//----------------------------------------------------------------------
-// DumpELFSectionHeaders
-//
-// Dump all of the ELF section header to the specified output stream
-//----------------------------------------------------------------------
-void
-ObjectFileELF64::DumpELFSectionHeaders(Stream *s)
-{
-    if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
-        return;
-
-    s->PutCString("Section Headers\n");
-    s->PutCString("IDX  name     type         flags                            "
-                  "addr     offset   size     link     info     addralgn "
-                  "entsize  Name\n");
-    s->PutCString("==== -------- ------------ -------------------------------- "
-                  "-------- -------- -------- -------- -------- -------- "
-                  "-------- ====================\n");
-
-    uint32_t idx = 0;
-    for (SectionHeaderCollConstIter I = m_section_headers.begin();
-         I != m_section_headers.end(); ++I, ++idx)
-    {
-        s->Printf("[%2u] ", idx);
-        ObjectFileELF64::DumpELFSectionHeader(s, *I);
-        const char* section_name = m_shstr_data.PeekCStr(I->sh_name);
-        if (section_name)
-            *s << ' ' << section_name << "\n";
-    }
-}
-
-void
-ObjectFileELF64::DumpDependentModules(lldb_private::Stream *s)
-{
-    size_t num_modules = ParseDependentModules();
-
-    if (num_modules > 0)
-    {
-        s->PutCString("Dependent Modules:\n");
-        for (unsigned i = 0; i < num_modules; ++i)
-        {
-            const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i);
-            s->Printf("   %s\n", spec.GetFilename().GetCString());
-        }
-    }
-}
-
-bool
-ObjectFileELF64::GetTargetTriple(ConstString &target_triple)
-{
-    static ConstString g_target_triple;
-
-    if (g_target_triple)
-    {
-        target_triple = g_target_triple;
-        return true;
-    }
-
-    std::string triple;
-    switch (m_header.e_machine)
-    {
-    default:
-        assert(false && "Unexpected machine type.");
-        break;
-    case EM_SPARC:  triple.assign("sparc-"); break;
-    case EM_386:    triple.assign("i386-"); break;
-    case EM_68K:    triple.assign("68k-"); break;
-    case EM_88K:    triple.assign("88k-"); break;
-    case EM_860:    triple.assign("i860-"); break;
-    case EM_MIPS:   triple.assign("mips-"); break;
-    case EM_PPC:    triple.assign("powerpc-"); break;
-    case EM_PPC64:  triple.assign("powerpc64-"); break;
-    case EM_ARM:    triple.assign("arm-"); break;
-    case EM_X86_64: triple.assign("x86_64-"); break;
-    }
-    // TODO: determine if there is a vendor in the ELF? Default to "linux" for now
-    triple += "linux-";
-    // TODO: determine if there is an OS in the ELF? Default to "gnu" for now
-    triple += "gnu";
-    g_target_triple.SetCString(triple.c_str());
-    target_triple = g_target_triple;
-
-    return true;
-}
-
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
@@ -994,16 +89,16 @@
 uint32_t
 ObjectFileELF64::GetPluginVersion()
 {
-    return 1;
+    return m_plugin_version;
 }
 
 void
-ObjectFileELF64::GetPluginCommandHelp (const char *command, Stream *strm)
+ObjectFileELF64::GetPluginCommandHelp(const char *command, Stream *strm)
 {
 }
 
 Error
-ObjectFileELF64::ExecutePluginCommand (Args &command, Stream *strm)
+ObjectFileELF64::ExecutePluginCommand(Args &command, Stream *strm)
 {
     Error error;
     error.SetErrorString("No plug-in commands are currently supported.");
@@ -1011,7 +106,7 @@
 }
 
 Log *
-ObjectFileELF64::EnablePluginLogging (Stream *strm, Args &command)
+ObjectFileELF64::EnablePluginLogging(Stream *strm, Args &command)
 {
     return NULL;
 }
Index: source/Plugins/ObjectFile/ELF/ObjectFileELF32.h
===================================================================
--- source/Plugins/ObjectFile/ELF/ObjectFileELF32.h	(revision 0)
+++ source/Plugins/ObjectFile/ELF/ObjectFileELF32.h	(revision 0)
@@ -0,0 +1,79 @@
+//===-- ObjectFileELF32.h ------------------------------------- -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_ObjectFileELF32_h_
+#define liblldb_ObjectFileELF32_h_
+
+#include "ObjectFileELF.h"
+
+//------------------------------------------------------------------------------
+/// @class ObjectFileELF32
+/// @brief 32 bit ELF object file plugin.
+class ObjectFileELF32
+    : public elf::ObjectFileELF
+{
+public:
+    virtual
+    ~ObjectFileELF32();
+
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    static void
+    Initialize();
+
+    static void
+    Terminate();
+
+    static const char *
+    GetPluginNameStatic();
+
+    static const char *
+    GetPluginDescriptionStatic();
+
+    static lldb_private::ObjectFile *
+    CreateInstance(lldb_private::Module* module,
+                   lldb::DataBufferSP& dataSP,
+                   const lldb_private::FileSpec* file,
+                   lldb::addr_t offset,
+                   lldb::addr_t length);
+
+    //------------------------------------------------------------------
+    // PluginInterface protocol
+    //------------------------------------------------------------------
+    virtual const char *
+    GetPluginName();
+
+    virtual const char *
+    GetShortPluginName();
+
+    virtual uint32_t
+    GetPluginVersion();
+
+    virtual void
+    GetPluginCommandHelp(const char *command, lldb_private::Stream *strm);
+
+    virtual lldb_private::Error
+    ExecutePluginCommand(lldb_private::Args &command,
+                         lldb_private::Stream *strm);
+
+    virtual lldb_private::Log *
+    EnablePluginLogging(lldb_private::Stream *strm, 
+                        lldb_private::Args &command);
+
+private:
+    ObjectFileELF32(lldb_private::Module* module,
+                    lldb::DataBufferSP& dataSP,
+                    const lldb_private::FileSpec* file,
+                    lldb::addr_t offset,
+                    lldb::addr_t length)
+        : elf::ObjectFileELF(module, dataSP, file, offset, length) { }
+};
+
+#endif // #ifndef liblldb_ObjectFileELF32_h_
Index: source/Plugins/ObjectFile/ELF/ObjectFileELF64.h
===================================================================
--- source/Plugins/ObjectFile/ELF/ObjectFileELF64.h	(revision 108210)
+++ source/Plugins/ObjectFile/ELF/ObjectFileELF64.h	(working copy)
@@ -10,23 +10,18 @@
 #ifndef liblldb_ObjectFileELF64_h_
 #define liblldb_ObjectFileELF64_h_
 
-#include <stdint.h>
-#include <vector>
+#include "ObjectFileELF.h"
 
-#include "lldb/lldb-private.h"
-#include "lldb/Core/FileSpec.h"
-#include "lldb/Symbol/ObjectFile.h"
-
-#include "elf.h"
-
-//----------------------------------------------------------------------
-// This class needs to be hidden as eventually belongs in a plugin that
-// will export the ObjectFile protocol
-//----------------------------------------------------------------------
-class ObjectFileELF64 : 
-    public lldb_private::ObjectFile
+//------------------------------------------------------------------------------
+/// @class ObjectFileELF64
+/// @brief 64 bit ELF object file plugin.
+class ObjectFileELF64
+    : public elf::ObjectFileELF
 {
 public:
+    virtual
+    ~ObjectFileELF64();
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
@@ -49,49 +44,7 @@
                    lldb::addr_t offset,
                    lldb::addr_t length);
 
-    static bool
-    MagicBytesMatch(lldb::DataBufferSP& dataSP);
-
     //------------------------------------------------------------------
-    // Member Functions
-    //------------------------------------------------------------------
-    ObjectFileELF64(lldb_private::Module* module,
-                    lldb::DataBufferSP& dataSP,
-                    const lldb_private::FileSpec* file,
-                    lldb::addr_t offset,
-                    lldb::addr_t length);
-
-    virtual
-    ~ObjectFileELF64();
-
-    virtual bool
-    ParseHeader();
-
-    virtual lldb::ByteOrder
-    GetByteOrder() const;
-
-    virtual size_t
-    GetAddressByteSize() const;
-
-    virtual lldb_private::Symtab *
-    GetSymtab();
-
-    virtual lldb_private::SectionList *
-    GetSectionList();
-
-    virtual void
-    Dump(lldb_private::Stream *s);
-
-    virtual bool
-    GetTargetTriple(lldb_private::ConstString &target_triple);
-
-    virtual bool
-    GetUUID(lldb_private::UUID* uuid);
-
-    virtual uint32_t
-    GetDependentModules(lldb_private::FileSpecList& files);
-
-    //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
     virtual const char *
@@ -114,96 +67,13 @@
     EnablePluginLogging(lldb_private::Stream *strm, 
                         lldb_private::Args &command);
 
-protected:
-    typedef std::vector<Elf64_Phdr>             ProgramHeaderColl;
-    typedef ProgramHeaderColl::iterator         ProgramHeaderCollIter;
-    typedef ProgramHeaderColl::const_iterator   ProgramHeaderCollConstIter;
-
-    typedef std::vector<Elf64_Shdr>             SectionHeaderColl;
-    typedef SectionHeaderColl::iterator         SectionHeaderCollIter;
-    typedef SectionHeaderColl::const_iterator   SectionHeaderCollConstIter;
-
-    Elf64_Ehdr m_header;
-    ProgramHeaderColl m_program_headers;
-    SectionHeaderColl m_section_headers;
-    mutable std::auto_ptr<lldb_private::SectionList> m_sections_ap;
-    mutable std::auto_ptr<lldb_private::Symtab> m_symtab_ap;
-    mutable std::auto_ptr<lldb_private::FileSpecList> m_filespec_ap;
-    lldb_private::DataExtractor m_shstr_data;
-
-    size_t
-    ParseSections();
-
-    size_t
-    ParseSymtab(bool minimize);
-
 private:
-    // Returns the 1 based index of a section header.
-    unsigned
-    SectionIndex(const SectionHeaderCollIter &I);
-
-    unsigned
-    SectionIndex(const SectionHeaderCollConstIter &I) const;
-
-    // ELF header dump routines
-    static void
-    DumpELFHeader(lldb_private::Stream *s, const Elf64_Ehdr& header);
-
-    static void
-    DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s, 
-                                  unsigned char ei_data);
-
-    static void
-    DumpELFHeader_e_type(lldb_private::Stream *s, Elf64_Half e_type);
-
-    // ELF program header dump routines
-    void
-    DumpELFProgramHeaders(lldb_private::Stream *s);
-
-    static void
-    DumpELFProgramHeader(lldb_private::Stream *s, const Elf64_Phdr &ph);
-
-    static void
-    DumpELFProgramHeader_p_type(lldb_private::Stream *s, Elf64_Word p_type);
-
-    static void
-    DumpELFProgramHeader_p_flags(lldb_private::Stream *s, Elf64_Word p_flags);
-
-    // ELF section header dump routines
-    void
-    DumpELFSectionHeaders(lldb_private::Stream *s);
-
-    static void
-    DumpELFSectionHeader(lldb_private::Stream *s, const Elf64_Shdr& sh);
-
-    static void
-    DumpELFSectionHeader_sh_type(lldb_private::Stream *s, Elf64_Word sh_type);
-
-    static void
-    DumpELFSectionHeader_sh_flags(lldb_private::Stream *s, Elf64_Word sh_flags);
-
-    void
-    DumpDependentModules(lldb_private::Stream *s);
-
-    size_t
-    ParseProgramHeaders();
-
-    size_t
-    ParseSectionHeaders();
-
-    size_t
-    ParseDependentModules();
-
-    void
-    ParseSymbolTable(lldb_private::Symtab *symbol_table, 
-                     const Elf64_Shdr &symtab_section,
-                     lldb::user_id_t symtab_id);
-
-    size_t
-    GetSectionHeaderStringTable();
-
-    uint32_t
-    GetSectionIndexByName(const char *name);
+    ObjectFileELF64(lldb_private::Module* module,
+                    lldb::DataBufferSP& dataSP,
+                    const lldb_private::FileSpec* file,
+                    lldb::addr_t offset,
+                    lldb::addr_t length)
+        : elf::ObjectFileELF(module, dataSP, file, offset, length) { }
 };
 
 #endif // #ifndef liblldb_ObjectFileELF64_h_
Index: source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
===================================================================
--- source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp	(revision 108210)
+++ source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp	(working copy)
@@ -1,4 +1,4 @@
-//===-- ObjectFileELF64.cpp ----------------------------------- -*- C++ -*-===//
+//===-- ObjectFileELF.cpp ------------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,10 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "ObjectFileELF64.h"
+#include "ObjectFileELF.h"
 
 #include <cassert>
-
 #include <algorithm>
 
 #include "lldb/Core/DataBuffer.h"
@@ -25,73 +24,12 @@
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace elf;
+using namespace llvm::ELF;
 
-void
-ObjectFileELF64::Initialize()
-{
-    PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                  GetPluginDescriptionStatic(),
-                                  CreateInstance);
-}
-
-void
-ObjectFileELF64::Terminate()
-{
-    PluginManager::UnregisterPlugin(CreateInstance);
-}
-
-const char *
-ObjectFileELF64::GetPluginNameStatic()
-{
-    return "object-file.elf64";
-}
-
-const char *
-ObjectFileELF64::GetPluginDescriptionStatic()
-{
-    return "ELF object file reader (64-bit).";
-}
-
-ObjectFile *
-ObjectFileELF64::CreateInstance(Module *module,
-                                DataBufferSP &dataSP,
-                                const FileSpec *file, addr_t offset,
-                                addr_t length)
-{
-    if (ObjectFileELF64::MagicBytesMatch(dataSP))
-    {
-        std::auto_ptr<ObjectFile> objfile_ap(
-            new ObjectFileELF64(module, dataSP, file, offset, length));
-        if (objfile_ap->ParseHeader())
-            return objfile_ap.release();
-    }
-    return NULL;
-}
-
-bool
-ObjectFileELF64::MagicBytesMatch(DataBufferSP& data_sp)
-{
-    if (data_sp && data_sp->GetByteSize() > EI_PAD)
-    {
-        const uint8_t* magic = data_sp->GetBytes();
-        if (magic != NULL)
-        {
-            bool have_magic = (magic[EI_MAG0] == 0x7f &&
-                               magic[EI_MAG1] == 'E'  &&
-                               magic[EI_MAG2] == 'L'  &&
-                               magic[EI_MAG3] == 'F');
-        
-            bool have_64bit = magic[EI_CLASS] == ELFCLASS64;
-        
-            return have_magic && have_64bit;
-        }
-    }
-    return false;
-}
-
-ObjectFileELF64::ObjectFileELF64(Module* module, DataBufferSP& dataSP,
-                                 const FileSpec* file, addr_t offset,
-                                 addr_t length)
+ObjectFileELF::ObjectFileELF(Module* module, DataBufferSP& dataSP,
+                             const FileSpec* file, addr_t offset,
+                             addr_t length)
     : ObjectFile(module, file, offset, length, dataSP),
       m_header(),
       m_program_headers(),
@@ -107,12 +45,12 @@
 }
 
 
-ObjectFileELF64::~ObjectFileELF64()
+ObjectFileELF::~ObjectFileELF()
 {
 }
 
 ByteOrder
-ObjectFileELF64::GetByteOrder() const
+ObjectFileELF::GetByteOrder() const
 {
     if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
         return eByteOrderBig;
@@ -122,65 +60,39 @@
 }
 
 size_t
-ObjectFileELF64::GetAddressByteSize() const
+ObjectFileELF::GetAddressByteSize() const
 {
     return m_data.GetAddressByteSize();
 }
 
 unsigned
-ObjectFileELF64::SectionIndex(const SectionHeaderCollIter &I)
+ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I)
 {
     return std::distance(m_section_headers.begin(), I) + 1;
 }
 
 unsigned
-ObjectFileELF64::SectionIndex(const SectionHeaderCollConstIter &I) const
+ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const
 {
     return std::distance(m_section_headers.begin(), I) + 1;
 }
 
 bool
-ObjectFileELF64::ParseHeader()
+ObjectFileELF::ParseHeader()
 {
-    m_data.SetAddressByteSize(8);
     uint32_t offset = GetOffset();
-    if (m_data.GetU8(&offset, m_header.e_ident, EI_NIDENT) == NULL)
-        return false;
-
-    m_data.SetByteOrder(GetByteOrder());
-
-    // Read e_type and e_machine.
-    if (m_data.GetU16(&offset, &m_header.e_type, 2) == NULL)
-        return false;
-
-    // Read e_version.
-    if (m_data.GetU32(&offset, &m_header.e_version, 1) == NULL)
-        return false;
-
-    // Read e_entry, e_phoff and e_shoff.
-    if (m_data.GetU64(&offset, &m_header.e_entry, 3) == NULL)
-        return false;
-
-    // Read e_flags.
-    if (m_data.GetU32(&offset, &m_header.e_flags, 1) == NULL)
-        return false;
-
-    // Read e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum and e_shstrndx.
-    if (m_data.GetU16(&offset, &m_header.e_ehsize, 6) == NULL)
-        return false;
-
-    return true;
+    return m_header.Parse(m_data, &offset);
 }
 
 bool
-ObjectFileELF64::GetUUID(UUID* uuid)
+ObjectFileELF::GetUUID(UUID* uuid)
 {
     // FIXME: Return MD5 sum here.  See comment in ObjectFile.h.
     return false;
 }
 
 uint32_t
-ObjectFileELF64::GetDependentModules(FileSpecList &files)
+ObjectFileELF::GetDependentModules(FileSpecList &files)
 {
     size_t num_modules = ParseDependentModules();
     uint32_t num_specs = 0;
@@ -198,7 +110,7 @@
 // ParseDependentModules
 //----------------------------------------------------------------------
 size_t
-ObjectFileELF64::ParseDependentModules()
+ObjectFileELF::ParseDependentModules()
 {
     if (m_filespec_ap.get())
         return m_filespec_ap->GetSize();
@@ -241,24 +153,22 @@
     if (dynsym->ReadSectionDataFromObjectFile(this, dynsym_data) &&
         dynstr->ReadSectionDataFromObjectFile(this, dynstr_data))
     {
-        Elf64_Dyn symbol;
-        const unsigned num_syms = dynsym_data.GetByteSize() / sizeof(Elf64_Dyn);
+        ELFDynamic symbol;
+        const unsigned section_size = dynsym_data.GetByteSize();
         unsigned offset = 0;
 
         // The only type of entries we are concerned with are tagged DT_NEEDED,
         // yielding the name of a required library.
-        for (unsigned i = 0; i < num_syms; ++i)
+        while (offset < section_size)
         {
-            if (!dynsym_data.ValidOffsetForDataOfSize(offset, sizeof(Elf64_Dyn)))
+            if (!symbol.Parse(dynsym_data, &offset))
                 break;
 
-            symbol.d_tag = dynsym_data.GetU64(&offset);
-            symbol.d_un.d_val = dynsym_data.GetU64(&offset);
-
             if (symbol.d_tag != DT_NEEDED)
                 continue;
 
-            const char *lib_name = dynstr_data.PeekCStr(symbol.d_un.d_val);
+            uint32_t str_index = static_cast<uint32_t>(symbol.d_val);
+            const char *lib_name = dynstr_data.PeekCStr(str_index);
             m_filespec_ap->Append(FileSpec(lib_name));
         }
     }
@@ -270,7 +180,7 @@
 // ParseProgramHeaders
 //----------------------------------------------------------------------
 size_t
-ObjectFileELF64::ParseProgramHeaders()
+ObjectFileELF::ParseProgramHeaders()
 {
     // We have already parsed the program headers
     if (!m_program_headers.empty())
@@ -285,7 +195,7 @@
         return 0;
 
     const size_t ph_size = m_header.e_phnum * m_header.e_phentsize;
-    const Elf64_Off ph_offset = m_offset + m_header.e_phoff;
+    const elf_off ph_offset = m_offset + m_header.e_phoff;
     DataBufferSP buffer_sp(m_file.ReadFileContents(ph_offset, ph_size));
 
     if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != ph_size)
@@ -298,8 +208,8 @@
     uint32_t offset;
     for (idx = 0, offset = 0; idx < m_header.e_phnum; ++idx)
     {
-        if (data.GetU32(&offset, &m_program_headers[idx], 8) == NULL)
-            return 0;
+        if (m_program_headers[idx].Parse(data, &offset) == false)
+            break;
     }
 
     if (idx < m_program_headers.size())
@@ -312,7 +222,7 @@
 // ParseSectionHeaders
 //----------------------------------------------------------------------
 size_t
-ObjectFileELF64::ParseSectionHeaders()
+ObjectFileELF::ParseSectionHeaders()
 {
     // We have already parsed the section headers
     if (!m_section_headers.empty())
@@ -327,7 +237,7 @@
         return 0;
 
     const size_t sh_size = m_header.e_shnum * m_header.e_shentsize;
-    const Elf64_Off sh_offset = m_offset + m_header.e_shoff;
+    const elf_off sh_offset = m_offset + m_header.e_shoff;
     DataBufferSP buffer_sp(m_file.ReadFileContents(sh_offset, sh_size));
 
     if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != sh_size)
@@ -341,21 +251,8 @@
     uint32_t offset;
     for (idx = 0, offset = 0; idx < m_header.e_shnum; ++idx)
     {
-        // Read sh_name and sh_type.
-        if (data.GetU32(&offset, &m_section_headers[idx].sh_name, 2) == NULL)
+        if (m_section_headers[idx].Parse(data, &offset) == false)
             break;
-
-        // Read sh_flags, sh_addr, sh_offset and sh_size.
-        if (data.GetU64(&offset, &m_section_headers[idx].sh_flags, 4) == NULL)
-            break;
-
-        // Read sh_link and sh_info.
-        if (data.GetU32(&offset, &m_section_headers[idx].sh_link, 2) == NULL)
-            break;
-
-        // Read sh_addralign and sh_entsize.
-        if (data.GetU64(&offset, &m_section_headers[idx].sh_addralign, 2) == NULL)
-            break;
     }
     if (idx < m_section_headers.size())
         m_section_headers.resize(idx);
@@ -364,13 +261,15 @@
 }
 
 size_t
-ObjectFileELF64::GetSectionHeaderStringTable()
+ObjectFileELF::GetSectionHeaderStringTable()
 {
     if (m_shstr_data.GetByteSize() == 0)
     {
-        if (m_header.e_shstrndx && m_header.e_shstrndx < m_section_headers.size())
+        const unsigned strtab_idx = m_header.e_shstrndx;
+
+        if (strtab_idx && strtab_idx < m_section_headers.size())
         {
-            const Elf64_Shdr &sheader = m_section_headers[m_header.e_shstrndx];
+            const ELFSectionHeader &sheader = m_section_headers[strtab_idx];
             const size_t byte_size = sheader.sh_size;
             const Elf64_Off offset = m_offset + sheader.sh_offset;
             DataBufferSP buffer_sp(m_file.ReadFileContents(offset, byte_size));
@@ -384,11 +283,11 @@
     return m_shstr_data.GetByteSize();
 }
 
-uint32_t
-ObjectFileELF64::GetSectionIndexByName(const char *name)
+lldb::user_id_t
+ObjectFileELF::GetSectionIndexByName(const char *name)
 {
     if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
-        return UINT32_MAX;
+        return 0;
 
     // Search the collection of section headers for one with a matching name.
     for (SectionHeaderCollIter I = m_section_headers.begin();
@@ -397,7 +296,7 @@
         const char *sectionName = m_shstr_data.PeekCStr(I->sh_name);
 
         if (!sectionName)
-            return UINT32_MAX;
+            return 0;
 
         if (strcmp(name, sectionName) != 0)
             continue;
@@ -405,11 +304,11 @@
         return SectionIndex(I);
     }
 
-    return UINT32_MAX;
+    return 0;
 }
 
 SectionList *
-ObjectFileELF64::GetSectionList()
+ObjectFileELF::GetSectionList()
 {
     if (m_sections_ap.get())
         return m_sections_ap.get();
@@ -421,7 +320,7 @@
         for (SectionHeaderCollIter I = m_section_headers.begin();
              I != m_section_headers.end(); ++I)
         {
-            const Elf64_Shdr &header = *I;
+            const ELFSectionHeader &header = *I;
 
             ConstString name(m_shstr_data.PeekCStr(header.sh_name));
             uint64_t size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
@@ -447,14 +346,14 @@
 
 static void
 ParseSymbols(Symtab *symtab, SectionList *section_list,
-             const Elf64_Shdr &symtab_shdr,
+             const ELFSectionHeader &symtab_shdr,
              const DataExtractor &symtab_data,
              const DataExtractor &strtab_data)
 {
-    assert (sizeof(Elf64_Sym) == symtab_shdr.sh_entsize);
-    const unsigned numSymbols = symtab_data.GetByteSize() / sizeof(Elf64_Sym);
-    unsigned offset = 0;
-    Elf64_Sym symbol;
+    ELFSymbol symbol;
+    uint32_t offset = 0;
+    const unsigned numSymbols = 
+        symtab_data.GetByteSize() / symtab_shdr.sh_entsize;
 
     static ConstString text_section_name(".text");
     static ConstString init_section_name(".init");
@@ -470,16 +369,9 @@
 
     for (unsigned i = 0; i < numSymbols; ++i)
     {
-        if (!symtab_data.ValidOffsetForDataOfSize(offset, sizeof(Elf64_Sym)))
+        if (symbol.Parse(symtab_data, &offset) == false)
             break;
 
-        symbol.st_name  = symtab_data.GetU32(&offset);
-        symbol.st_info  = symtab_data.GetU8(&offset);
-        symbol.st_other = symtab_data.GetU8(&offset);
-        symbol.st_shndx = symtab_data.GetU16(&offset);
-        symbol.st_value = symtab_data.GetU64(&offset);
-        symbol.st_size  = symtab_data.GetU64(&offset);
-
         Section *symbol_section = NULL;
         SymbolType symbol_type = eSymbolTypeInvalid;
         Elf64_Half symbol_idx = symbol.st_shndx;
@@ -497,7 +389,7 @@
             break;
         }
 
-        switch (ELF_ST_TYPE(symbol.st_info))
+        switch (symbol.getType())
         {
         default:
         case STT_NOTYPE:
@@ -558,30 +450,30 @@
         if (symbol_section != NULL)
             symbol_value -= symbol_section->GetFileAddress();
         const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
-        bool is_global = ELF_ST_BIND(symbol.st_info) == STB_GLOBAL;
+        bool is_global = symbol.getBinding() == STB_GLOBAL;
         uint32_t flags = symbol.st_other << 8 | symbol.st_info;
 
         Symbol dc_symbol(
             i,               // ID is the original symbol table index.
-            symbol_name,     // symbol name.
+            symbol_name,     // Symbol name.
             false,           // Is the symbol name mangled?
-            symbol_type,     // type of this symbol
+            symbol_type,     // Type of this symbol
             is_global,       // Is this globally visible?
             false,           // Is this symbol debug info?
             false,           // Is this symbol a trampoline?
             false,           // Is this symbol artificial?
             symbol_section,  // Section in which this symbol is defined or null.
             symbol_value,    // Offset in section or symbol value.
-            symbol.st_size,  // size in bytes of this symbol.
+            symbol.st_size,  // Size in bytes of this symbol.
             flags);          // Symbol flags.
         symtab->AddSymbol(dc_symbol);
     }
 }
 
 void
-ObjectFileELF64::ParseSymbolTable(Symtab *symbol_table,
-                                  const Elf64_Shdr &symtab_hdr,
-                                  user_id_t symtab_id)
+ObjectFileELF::ParseSymbolTable(Symtab *symbol_table,
+                                const ELFSectionHeader &symtab_hdr,
+                                user_id_t symtab_id)
 {
     assert(symtab_hdr.sh_type == SHT_SYMTAB || 
            symtab_hdr.sh_type == SHT_DYNSYM);
@@ -610,7 +502,7 @@
 }
 
 Symtab *
-ObjectFileELF64::GetSymtab()
+ObjectFileELF::GetSymtab()
 {
     if (m_symtab_ap.get())
         return m_symtab_ap.get();
@@ -625,9 +517,9 @@
     for (SectionHeaderCollIter I = m_section_headers.begin();
          I != m_section_headers.end(); ++I)
     {
-        if (I->sh_type == SHT_SYMTAB || I->sh_type == SHT_DYNSYM)
+        if (I->sh_type == SHT_SYMTAB)
         {
-            const Elf64_Shdr &symtab_section = *I;
+            const ELFSectionHeader &symtab_section = *I;
             user_id_t section_id = SectionIndex(I);
             ParseSymbolTable(symbol_table, symtab_section, section_id);
         }
@@ -641,9 +533,9 @@
 //
 // Dump the specifics of the runtime file container (such as any headers
 // segments, sections, etc).
-// ----------------------------------------------------------------------
+//----------------------------------------------------------------------
 void
-ObjectFileELF64::Dump(Stream *s)
+ObjectFileELF::Dump(Stream *s)
 {
     DumpELFHeader(s, m_header);
     s->EOL();
@@ -668,9 +560,8 @@
 // Dump the ELF header to the specified output stream
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFHeader(Stream *s, const Elf64_Ehdr& header)
+ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header)
 {
-
     s->PutCString("ELF Header\n");
     s->Printf("e_ident[EI_MAG0   ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
     s->Printf("e_ident[EI_MAG1   ] = 0x%2.2x '%c'\n",
@@ -690,9 +581,9 @@
     DumpELFHeader_e_type(s, header.e_type);
     s->Printf("\ne_machine   = 0x%4.4x\n", header.e_machine);
     s->Printf("e_version   = 0x%8.8x\n", header.e_version);
-    s->Printf("e_entry     = 0x%8.8x\n", header.e_entry);
-    s->Printf("e_phoff     = 0x%8.8x\n", header.e_phoff);
-    s->Printf("e_shoff     = 0x%8.8x\n", header.e_shoff);
+    s->Printf("e_entry     = 0x%8.8lx\n", header.e_entry);
+    s->Printf("e_phoff     = 0x%8.8lx\n", header.e_phoff);
+    s->Printf("e_shoff     = 0x%8.8lx\n", header.e_shoff);
     s->Printf("e_flags     = 0x%8.8x\n", header.e_flags);
     s->Printf("e_ehsize    = 0x%4.4x\n", header.e_ehsize);
     s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
@@ -708,7 +599,7 @@
 // Dump an token value for the ELF header member e_type
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFHeader_e_type(Stream *s, Elf64_Half e_type)
+ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type)
 {
     switch (e_type)
     {
@@ -728,7 +619,7 @@
 // Dump an token value for the ELF header member e_ident[EI_DATA]
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data)
+ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data)
 {
     switch (ei_data)
     {
@@ -747,12 +638,12 @@
 // Dump a single ELF program header to the specified output stream
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFProgramHeader(Stream *s, const Elf64_Phdr &ph)
+ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph)
 {
     DumpELFProgramHeader_p_type(s, ph.p_type);
-    s->Printf(" %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x (",
-              ph.p_offset, ph.p_vaddr, ph.p_paddr, ph.p_filesz, ph.p_memsz,
-              ph.p_flags);
+    s->Printf(" %8.8lx %8.8lx %8.8lx", ph.p_offset, ph.p_vaddr, ph.p_paddr);
+    s->Printf(" %8.8lx %8.8lx %8.8lx (", ph.p_filesz, ph.p_memsz, ph.p_flags);
+
     DumpELFProgramHeader_p_flags(s, ph.p_flags);
     s->Printf(") %8.8x", ph.p_align);
 }
@@ -764,7 +655,7 @@
 // describes the type of the program header
 // ----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFProgramHeader_p_type(Stream *s, Elf64_Word p_type)
+ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type)
 {
     const int kStrWidth = 10;
     switch (p_type)
@@ -789,7 +680,7 @@
 // Dump an token value for the ELF program header member p_flags
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFProgramHeader_p_flags(Stream *s, Elf64_Word p_flags)
+ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags)
 {
     *s  << ((p_flags & PF_X) ? "PF_X" : "    ")
         << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
@@ -804,7 +695,7 @@
 // Dump all of the ELF program header to the specified output stream
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFProgramHeaders(Stream *s)
+ObjectFileELF::DumpELFProgramHeaders(Stream *s)
 {
     if (ParseProgramHeaders())
     {
@@ -819,7 +710,7 @@
              I != m_program_headers.end(); ++I, ++idx)
         {
             s->Printf("[%2u] ", idx);
-            ObjectFileELF64::DumpELFProgramHeader(s, *I);
+            ObjectFileELF::DumpELFProgramHeader(s, *I);
             s->EOL();
         }
     }
@@ -831,15 +722,15 @@
 // Dump a single ELF section header to the specified output stream
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFSectionHeader(Stream *s, const Elf64_Shdr &sh)
+ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeader &sh)
 {
     s->Printf("%8.8x ", sh.sh_name);
     DumpELFSectionHeader_sh_type(s, sh.sh_type);
-    s->Printf(" %8.8x (", sh.sh_flags);
+    s->Printf(" %8.8lx (", sh.sh_flags);
     DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
-    s->Printf(") %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x",
-              sh.sh_addr, sh.sh_offset, sh.sh_size, sh.sh_link, sh.sh_info,
-              sh.sh_addralign, sh.sh_entsize);
+    s->Printf(") %8.8lx %8.8lx %8.8lx", sh.sh_addr, sh.sh_offset, sh.sh_size);
+    s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info);
+    s->Printf(" %8.8lx %8.8lx", sh.sh_addralign, sh.sh_entsize);
 }
 
 //----------------------------------------------------------------------
@@ -849,7 +740,7 @@
 // describes the type of the section
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFSectionHeader_sh_type(Stream *s, Elf64_Word sh_type)
+ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type)
 {
     const int kStrWidth = 12;
     switch (sh_type)
@@ -882,7 +773,7 @@
 // Dump an token value for the ELF section header member sh_flags
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFSectionHeader_sh_flags(Stream *s, Elf64_Word sh_flags)
+ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_word sh_flags)
 {
     *s  << ((sh_flags & SHF_WRITE) ? "WRITE" : "     ")
         << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
@@ -897,7 +788,7 @@
 // Dump all of the ELF section header to the specified output stream
 //----------------------------------------------------------------------
 void
-ObjectFileELF64::DumpELFSectionHeaders(Stream *s)
+ObjectFileELF::DumpELFSectionHeaders(Stream *s)
 {
     if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
         return;
@@ -915,7 +806,7 @@
          I != m_section_headers.end(); ++I, ++idx)
     {
         s->Printf("[%2u] ", idx);
-        ObjectFileELF64::DumpELFSectionHeader(s, *I);
+        ObjectFileELF::DumpELFSectionHeader(s, *I);
         const char* section_name = m_shstr_data.PeekCStr(I->sh_name);
         if (section_name)
             *s << ' ' << section_name << "\n";
@@ -923,7 +814,7 @@
 }
 
 void
-ObjectFileELF64::DumpDependentModules(lldb_private::Stream *s)
+ObjectFileELF::DumpDependentModules(lldb_private::Stream *s)
 {
     size_t num_modules = ParseDependentModules();
 
@@ -939,7 +830,7 @@
 }
 
 bool
-ObjectFileELF64::GetTargetTriple(ConstString &target_triple)
+ObjectFileELF::GetTargetTriple(ConstString &target_triple)
 {
     static ConstString g_target_triple;
 
@@ -976,42 +867,3 @@
     return true;
 }
 
-//------------------------------------------------------------------
-// PluginInterface protocol
-//------------------------------------------------------------------
-const char *
-ObjectFileELF64::GetPluginName()
-{
-    return "ObjectFileELF64";
-}
-
-const char *
-ObjectFileELF64::GetShortPluginName()
-{
-    return GetPluginNameStatic();
-}
-
-uint32_t
-ObjectFileELF64::GetPluginVersion()
-{
-    return 1;
-}
-
-void
-ObjectFileELF64::GetPluginCommandHelp (const char *command, Stream *strm)
-{
-}
-
-Error
-ObjectFileELF64::ExecutePluginCommand (Args &command, Stream *strm)
-{
-    Error error;
-    error.SetErrorString("No plug-in commands are currently supported.");
-    return error;
-}
-
-Log *
-ObjectFileELF64::EnablePluginLogging (Stream *strm, Args &command)
-{
-    return NULL;
-}
Index: source/lldb.cpp
===================================================================
--- source/lldb.cpp	(revision 108210)
+++ source/lldb.cpp	(working copy)
@@ -18,7 +18,7 @@
 #include "Plugins/Disassembler/llvm/DisassemblerLLVM.h"
 #include "Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h"
 #include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h"
-#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
+#include "Plugins/ObjectFile/ELF/ObjectFileELF32.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF64.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
@@ -55,7 +55,7 @@
         Log::RegisterLogChannel ("lldb", log_callbacks);
         DisassemblerLLVM::Initialize();
         ObjectContainerBSDArchive::Initialize();
-        ObjectFileELF::Initialize();
+        ObjectFileELF32::Initialize();
         ObjectFileELF64::Initialize();
         SymbolVendorMacOSX::Initialize();
         SymbolFileDWARF::Initialize();
@@ -85,7 +85,7 @@
     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
     DisassemblerLLVM::Terminate();
     ObjectContainerBSDArchive::Terminate();
-    ObjectFileELF::Terminate();
+    ObjectFileELF32::Terminate();
     ObjectFileELF64::Terminate();
     SymbolVendorMacOSX::Terminate();
     SymbolFileDWARF::Terminate();
