9594f4c818
- Do not add symbols with no names - Make sure that symbols from ELF symbol tables know that the byte size is correct. Previously the symbols would calculate their sizes by looking for the next symbol and take symbols that had zero size and make them have invalid sizes. - Added the ability to dump raw ELF symbols by adding a Dump method to ELFSymbol Also removed some unused code from lldb_private::Symtab. llvm-svn: 179466
468 lines
11 KiB
C++
468 lines
11 KiB
C++
//===-- 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 "lldb/Core/Section.h"
|
|
#include "lldb/Core/Stream.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,
|
|
lldb::offset_t *offset,
|
|
uint64_t *value,
|
|
uint32_t byte_size)
|
|
{
|
|
const lldb::offset_t saved_offset = *offset;
|
|
*value = data.GetMaxU64(offset, byte_size);
|
|
return *offset != saved_offset;
|
|
}
|
|
|
|
static bool
|
|
GetMaxU64(const lldb_private::DataExtractor &data,
|
|
lldb::offset_t *offset,
|
|
uint64_t *value,
|
|
uint32_t byte_size,
|
|
uint32_t count)
|
|
{
|
|
lldb::offset_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,
|
|
lldb::offset_t *offset,
|
|
int64_t *value,
|
|
uint32_t byte_size)
|
|
{
|
|
const lldb::offset_t saved_offset = *offset;
|
|
*value = data.GetMaxS64(offset, byte_size);
|
|
return *offset != saved_offset;
|
|
}
|
|
|
|
static bool
|
|
GetMaxS64(const lldb_private::DataExtractor &data,
|
|
lldb::offset_t *offset,
|
|
int64_t *value,
|
|
uint32_t byte_size,
|
|
uint32_t count)
|
|
{
|
|
lldb::offset_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, lldb::offset_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)
|
|
{
|
|
return memcmp(magic, ElfMagic, strlen(ElfMagic)) == 0;
|
|
}
|
|
|
|
unsigned
|
|
ELFHeader::AddressSizeInBytes(const uint8_t *magic)
|
|
{
|
|
unsigned address_size = 0;
|
|
|
|
switch (magic[EI_CLASS])
|
|
{
|
|
case ELFCLASS32:
|
|
address_size = 4;
|
|
break;
|
|
|
|
case ELFCLASS64:
|
|
address_size = 8;
|
|
break;
|
|
}
|
|
return address_size;
|
|
}
|
|
|
|
unsigned
|
|
ELFHeader::GetRelocationJumpSlotType() const
|
|
{
|
|
unsigned slot = 0;
|
|
|
|
switch (e_machine)
|
|
{
|
|
default:
|
|
assert(false && "architecture not supported");
|
|
break;
|
|
case EM_386:
|
|
case EM_486:
|
|
slot = R_386_JUMP_SLOT;
|
|
break;
|
|
case EM_X86_64:
|
|
slot = R_X86_64_JUMP_SLOT;
|
|
break;
|
|
case EM_ARM:
|
|
slot = R_ARM_JUMP_SLOT;
|
|
break;
|
|
case EM_MBLAZE:
|
|
slot = R_MICROBLAZE_JUMP_SLOT;
|
|
}
|
|
|
|
return slot;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ELFSectionHeader
|
|
|
|
ELFSectionHeader::ELFSectionHeader()
|
|
{
|
|
memset(this, 0, sizeof(ELFSectionHeader));
|
|
}
|
|
|
|
bool
|
|
ELFSectionHeader::Parse(const lldb_private::DataExtractor &data,
|
|
lldb::offset_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));
|
|
}
|
|
|
|
#define ENUM_TO_CSTR(e) case e: return #e
|
|
|
|
const char *
|
|
ELFSymbol::bindingToCString(unsigned char binding)
|
|
{
|
|
switch (binding)
|
|
{
|
|
ENUM_TO_CSTR(STB_LOCAL);
|
|
ENUM_TO_CSTR(STB_GLOBAL);
|
|
ENUM_TO_CSTR(STB_WEAK);
|
|
ENUM_TO_CSTR(STB_LOOS);
|
|
ENUM_TO_CSTR(STB_HIOS);
|
|
ENUM_TO_CSTR(STB_LOPROC);
|
|
ENUM_TO_CSTR(STB_HIPROC);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
const char *
|
|
ELFSymbol::typeToCString(unsigned char type)
|
|
{
|
|
switch (type)
|
|
{
|
|
ENUM_TO_CSTR(STT_NOTYPE);
|
|
ENUM_TO_CSTR(STT_OBJECT);
|
|
ENUM_TO_CSTR(STT_FUNC);
|
|
ENUM_TO_CSTR(STT_SECTION);
|
|
ENUM_TO_CSTR(STT_FILE);
|
|
ENUM_TO_CSTR(STT_COMMON);
|
|
ENUM_TO_CSTR(STT_TLS);
|
|
ENUM_TO_CSTR(STT_LOOS);
|
|
ENUM_TO_CSTR(STT_HIOS);
|
|
ENUM_TO_CSTR(STT_GNU_IFUNC);
|
|
ENUM_TO_CSTR(STT_LOPROC);
|
|
ENUM_TO_CSTR(STT_HIPROC);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
const char *
|
|
ELFSymbol::sectionIndexToCString (elf_half shndx,
|
|
const lldb_private::SectionList *section_list)
|
|
{
|
|
switch (shndx)
|
|
{
|
|
ENUM_TO_CSTR(SHN_UNDEF);
|
|
ENUM_TO_CSTR(SHN_LOPROC);
|
|
ENUM_TO_CSTR(SHN_HIPROC);
|
|
ENUM_TO_CSTR(SHN_LOOS);
|
|
ENUM_TO_CSTR(SHN_HIOS);
|
|
ENUM_TO_CSTR(SHN_ABS);
|
|
ENUM_TO_CSTR(SHN_COMMON);
|
|
ENUM_TO_CSTR(SHN_XINDEX);
|
|
default:
|
|
{
|
|
const lldb_private::Section *section = section_list->GetSectionAtIndex(shndx).get();
|
|
if (section)
|
|
return section->GetName().AsCString("");
|
|
}
|
|
break;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void
|
|
ELFSymbol::Dump (lldb_private::Stream *s,
|
|
uint32_t idx,
|
|
const lldb_private::DataExtractor *strtab_data,
|
|
const lldb_private::SectionList *section_list)
|
|
{
|
|
s->Printf("[%3u] 0x%16.16llx 0x%16.16llx 0x%8.8x 0x%2.2x (%-10s %-13s) 0x%2.2x 0x%4.4x (%-10s) %s\n",
|
|
idx,
|
|
st_value,
|
|
st_size,
|
|
st_name,
|
|
st_info,
|
|
bindingToCString (getBinding()),
|
|
typeToCString (getType()),
|
|
st_other,
|
|
st_shndx,
|
|
sectionIndexToCString (st_shndx, section_list),
|
|
strtab_data ? strtab_data->PeekCStr(st_name) : "");
|
|
}
|
|
|
|
bool
|
|
ELFSymbol::Parse(const lldb_private::DataExtractor &data, lldb::offset_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,
|
|
lldb::offset_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, lldb::offset_t *offset)
|
|
{
|
|
const unsigned byte_size = data.GetAddressByteSize();
|
|
return GetMaxS64(data, offset, &d_tag, byte_size, 2);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ELFRel
|
|
|
|
ELFRel::ELFRel()
|
|
{
|
|
memset(this, 0, sizeof(ELFRel));
|
|
}
|
|
|
|
bool
|
|
ELFRel::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
|
|
{
|
|
const unsigned byte_size = data.GetAddressByteSize();
|
|
|
|
// Read r_offset and r_info.
|
|
if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ELFRela
|
|
|
|
ELFRela::ELFRela()
|
|
{
|
|
memset(this, 0, sizeof(ELFRela));
|
|
}
|
|
|
|
bool
|
|
ELFRela::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
|
|
{
|
|
const unsigned byte_size = data.GetAddressByteSize();
|
|
|
|
// Read r_offset and r_info.
|
|
if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false)
|
|
return false;
|
|
|
|
// Read r_addend;
|
|
if (GetMaxS64(data, offset, &r_addend, byte_size) == false)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|