64 bit ELF support from Stephen Wilson.
git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@107817 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp b/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp
new file mode 100644
index 0000000..df76488
--- /dev/null
+++ b/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp
@@ -0,0 +1,1017 @@
+//===-- ObjectFileELF64.cpp ----------------------------------- -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+
+using namespace lldb;
+using namespace lldb_private;
+
+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)
+ : 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 §_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
+//------------------------------------------------------------------
+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;
+}