//===-- 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;
}
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.16" PRIx64 " 0x%16.16" PRIx64 " 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;
}