diff options
Diffstat (limited to 'lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp')
| -rw-r--r-- | lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp | 1017 |
1 files changed, 0 insertions, 1017 deletions
diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp deleted file mode 100644 index df764889a13..00000000000 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp +++ /dev/null @@ -1,1017 +0,0 @@ -//===-- 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; -} |
