Asm

Browse Download file Permalink

/* $Id$ */

/* This file is part of DeforaOS Devel Asm */

/* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 3 of the License.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>. */

#include <System.h>

#define ELFSIZE 32

#include "elf.h"

#include "elf.c"

/* ELF32 */

static void _swap_32_ehdr(Elf_Ehdr * ehdr);

static void _swap_32_phdr(Elf_Phdr * phdr);

static void _swap_32_shdr(Elf_Shdr * shdr);

/* ELF32 */

/* elf32_detect */

char const * elf32_detect(AsmFormatPlugin * format, Elf_Ehdr * ehdr)

{

(void) format;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(ehdr->e_ident[EI_DATA] != elf_arch_native->endian)

_swap_32_ehdr(ehdr);

switch(ehdr->e_machine)

{

case EM_386:

case EM_486:

return "i686";

case EM_ALPHA:

return "alpha";

case EM_ARM:

return "arm";

case EM_MIPS:

return "mips";

case EM_SPARC:

return "sparc";

}

error_set_code(1, "%s: %s 0x%x", "elf", "Unsupported ELF architecture",

ehdr->e_machine);

return NULL;

}

/* destroy_32 */

static int _destroy_32_phdr(AsmFormatPlugin * format, Elf32_Off offset);

static int _destroy_32_shdr(AsmFormatPlugin * format, Elf32_Off offset);

int elf32_destroy(AsmFormatPlugin * format)

{

int ret = 0;

AsmFormatPluginHelper * helper = format->helper;

Elf * elf = format;

long offset;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(elf32_section(format, ".shstrtab") != 0)

ret = -1;

else if(helper->write(helper->format, elf->shstrtab.buf,

elf->shstrtab.cnt)

!= (ssize_t)elf->shstrtab.cnt)

ret = -1;

else if((offset = helper->seek(helper->format, 0, SEEK_CUR)) < 0)

ret = -1;

else if(_destroy_32_phdr(format, offset) != 0

|| _destroy_32_shdr(format, offset) != 0)

ret = -1;

free(elf->shstrtab.buf);

elf->shstrtab.buf = NULL;

elf->shstrtab.cnt = 0;

return ret;

}

static int _destroy_32_phdr(AsmFormatPlugin * format, Elf32_Off offset)

{

AsmFormatPluginHelper * helper = format->helper;

Elf * elf = format;

const ElfArch * ea = elf->arch;

Elf32_Ehdr hdr;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(elf->es32_cnt == 0)

return 0;

if(helper->seek(helper->format, 0, SEEK_SET) != 0)

return -1;

if(helper->read(helper->format, &hdr, sizeof(hdr)) != sizeof(hdr))

return elf_error(format);

if(ea->endian == ELFDATA2MSB)

{

hdr.e_shoff = _htob32(offset);

hdr.e_shnum = _htob16(elf->es32_cnt + 1);

hdr.e_shstrndx = _htob16(elf->es32_cnt);

}

else

{

hdr.e_shoff = _htol32(offset);

hdr.e_shnum = _htol16(elf->es32_cnt + 1);

hdr.e_shstrndx = _htol16(elf->es32_cnt);

}

if(helper->seek(helper->format, 0, SEEK_SET) != 0)

return -1;

if(helper->write(helper->format, &hdr, sizeof(hdr)) != sizeof(hdr))

return -1;

return 0;

}

static int _destroy_32_shdr(AsmFormatPlugin * format, Elf32_Off offset)

{

AsmFormatPluginHelper * helper = format->helper;

Elf * elf = format;

const ElfArch * ea = elf->arch;

Elf32_Word addralign = ea->addralign;

Elf32_Shdr * es32 = elf->es32;

Elf32_Shdr hdr;

int i;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(helper->seek(helper->format, 0, SEEK_END) < 0)

return elf_error(format);

/* write the undefined section reference */

memset(&hdr, 0, sizeof(hdr));

if(ea->endian == ELFDATA2MSB)

{

hdr.sh_type = _htob32(SHT_NULL);

hdr.sh_link = _htob32(SHN_UNDEF);

}

else

{

hdr.sh_type = _htol32(SHT_NULL);

hdr.sh_link = _htol32(SHN_UNDEF);

}

if(helper->write(helper->format, &hdr, sizeof(hdr)) != sizeof(hdr))

return -1;

/* write the sections */

for(i = 0; i < elf->es32_cnt; i++)

{

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s() %d\n", __func__, i);

#endif

if(i + 1 == elf->es32_cnt)

es32[i].sh_size = offset - es32[i].sh_offset;

else

es32[i].sh_size = es32[i + 1].sh_offset

- es32[i].sh_offset;

es32[i].sh_offset = (ea->endian == ELFDATA2MSB)

? _htob32(es32[i].sh_offset)

: _htol32(es32[i].sh_offset);

es32[i].sh_size = (ea->endian == ELFDATA2MSB)

? _htob32(es32[i].sh_size) : _htol32(es32[i].sh_size);

if(es32[i].sh_type == SHT_PROGBITS)

es32[i].sh_addralign = (ea->endian == ELFDATA2MSB)

? _htob32(addralign) : _htol32(addralign);

es32[i].sh_type = (ea->endian == ELFDATA2MSB)

? _htob32(es32[i].sh_type) : _htol32(es32[i].sh_type);

if(helper->write(helper->format, &es32[i], sizeof(Elf32_Shdr))

!= sizeof(Elf32_Shdr))

return -1;

}

return 0;

}

/* decode_32 */

static int _decode32_shdr(AsmFormatPlugin * format, Elf32_Ehdr * ehdr,

Elf32_Shdr ** shdr);

static int _decode32_addr(AsmFormatPlugin * format, Elf32_Ehdr * ehdr,

Elf32_Addr * addr);

static int _decode32_strtab(AsmFormatPlugin * format, Elf32_Shdr * shdr,

size_t shdr_cnt, uint16_t ndx, char ** strtab,

size_t * strtab_cnt);

static int _decode32_symtab(AsmFormatPlugin * format, Elf32_Ehdr * ehdr,

Elf32_Shdr * shdr, size_t shdr_cnt, uint16_t ndx);

int elf32_decode(AsmFormatPlugin * format, int raw)

{

AsmFormatPluginHelper * helper = format->helper;

Elf32_Ehdr ehdr;

Elf32_Shdr * shdr = NULL;

Elf32_Addr base = 0x0;

char * shstrtab = NULL;

size_t shstrtab_cnt = 0;

size_t i;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s() \"%s\"\n", __func__,

helper->get_filename(helper->format));

#endif

if(helper->seek(helper->format, 0, SEEK_SET) != 0

|| helper->read(helper->format, &ehdr, sizeof(ehdr))

!= sizeof(ehdr))

return -1;

if(ehdr.e_ident[EI_DATA] != elf_arch_native->endian)

_swap_32_ehdr(&ehdr);

if(_decode32_shdr(format, &ehdr, &shdr) != 0)

return -1;

if(_decode32_addr(format, &ehdr, &base) != 0

|| _decode32_strtab(format, shdr, ehdr.e_shnum,

ehdr.e_shstrndx, &shstrtab, &shstrtab_cnt)

!= 0)

{

free(shdr);

return -1;

}

for(i = 0; i < ehdr.e_shnum; i++)

if(shdr[i].sh_type == SHT_SYMTAB)

{

/* XXX ignore errors? */

_decode32_symtab(format, &ehdr, shdr, ehdr.e_shnum, i);

break;

}

for(i = 0; i < ehdr.e_shnum; i++)

{

if(shdr[i].sh_name >= shstrtab_cnt)

continue;

if((raw || (shdr[i].sh_type == SHT_PROGBITS && shdr[i].sh_flags

& SHF_EXECINSTR))

&& helper->set_section(helper->format, i, 0,

&shstrtab[shdr[i].sh_name],

shdr[i].sh_offset, shdr[i].sh_size,

base + shdr[i].sh_offset) == NULL)

break;

}

free(shstrtab);

free(shdr);

return (i == ehdr.e_shnum) ? 0 : -1;

}

static int _decode32_shdr(AsmFormatPlugin * format, Elf32_Ehdr * ehdr,

Elf32_Shdr ** shdr)

{

AsmFormatPluginHelper * helper = format->helper;

ssize_t size;

size_t i;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(ehdr->e_shentsize == 0)

{

*shdr = NULL;

return 0;

}

if(ehdr->e_shentsize != sizeof(**shdr))

return -error_set_code(1, "%s: %s",

helper->get_filename(helper->format),

"Invalid section header size");

if(helper->seek(helper->format, ehdr->e_shoff, SEEK_SET) < 0)

return -1;

size = sizeof(**shdr) * ehdr->e_shnum;

if((*shdr = malloc(size)) == NULL)

return -elf_error(format);

if(helper->read(helper->format, *shdr, size) != size)

{

free(*shdr);

return -1;

}

if(ehdr->e_ident[EI_DATA] != elf_arch_native->endian)

for(i = 0; i < ehdr->e_shnum; i++)

_swap_32_shdr(*shdr + i);

return 0;

}

static int _decode32_addr(AsmFormatPlugin * format, Elf32_Ehdr * ehdr,

Elf32_Addr * addr)

{

AsmFormatPluginHelper * helper = format->helper;

Elf32_Half i;

Elf32_Phdr phdr;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(helper->seek(helper->format, ehdr->e_phoff, SEEK_SET) < 0)

return -1;

for(i = 0; i < ehdr->e_phnum; i++)

{

if(helper->read(helper->format, &phdr, sizeof(phdr))

!= sizeof(phdr))

return -1;

if(ehdr->e_ident[EI_DATA] != elf_arch_native->endian)

_swap_32_phdr(&phdr);

if(phdr.p_type == PT_LOAD && phdr.p_flags & (PF_R | PF_X))

{

*addr = phdr.p_vaddr;

return 0;

}

*addr = 0x0;

return 0;

}

static int _decode32_strtab(AsmFormatPlugin * format, Elf32_Shdr * shdr,

size_t shdr_cnt, uint16_t ndx, char ** strtab,

size_t * strtab_cnt)

{

AsmFormatPluginHelper * helper = format->helper;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(ndx >= shdr_cnt)

return -error_set_code(1, "%s: %s",

helper->get_filename(helper->format),

"Unable to read the string table");

shdr = &shdr[ndx];

if(shdr->sh_size == 0)

{

*strtab = NULL;

*strtab_cnt = 0;

return 0;

}

if(helper->seek(helper->format, shdr->sh_offset, SEEK_SET) < 0)

return -1;

if((*strtab = malloc(shdr->sh_size)) == NULL)

return -elf_error(format);

if(helper->read(helper->format, *strtab, shdr->sh_size)

!= shdr->sh_size)

{

free(*strtab);

return -1;

}

*strtab_cnt = shdr->sh_size;

return 0;

}

static int _decode32_symtab(AsmFormatPlugin * format, Elf32_Ehdr * ehdr,

Elf32_Shdr * shdr, size_t shdr_cnt, uint16_t ndx)

{

AsmFormatPluginHelper * helper = format->helper;

char * strtab = NULL;

size_t strtab_cnt = 0;

Elf32_Sym sym;

size_t i;

off_t offset;

#ifdef DEBUG

fprintf(stderr, "DEBUG: %s()\n", __func__);

#endif

if(ndx >= shdr_cnt || shdr[ndx].sh_entsize != sizeof(sym))

return -1;

if(_decode32_strtab(format, shdr, shdr_cnt, shdr[ndx].sh_link, &strtab,

&strtab_cnt) != 0)

return -1;

/* read and process symbols */

if((offset = helper->seek(helper->format, shdr[ndx].sh_offset,

SEEK_SET)) < 0

|| (unsigned long)offset != shdr[ndx].sh_offset)

{

free(strtab);

return -1;

}

for(i = 0; i * sizeof(sym) < shdr[ndx].sh_size; i++)

if(helper->read(helper->format, &sym, sizeof(sym))

!= sizeof(sym))

break;

else if(sym.st_name >= strtab_cnt)

break;

else if(ELF32_ST_TYPE(sym.st_info) == STT_FUNC)

{

offset = -1;

if(ehdr->e_type == ET_REL || ehdr->e_type == ET_EXEC

|| ehdr->e_type == ET_DYN)

offset = sym.st_value;

/* record the function */

helper->set_function(helper->format, i,

&strtab[sym.st_name], sym.st_value,

sym.st_size);

}

if(i * sizeof(sym) != shdr[ndx].sh_size)

{

free(strtab);

return -1;

}

return 0;

}

/* swap_32_ehdr */

static void _swap_32_ehdr(Elf_Ehdr * ehdr)

{

ehdr->e_type = _bswap16(ehdr->e_type);

ehdr->e_machine = _bswap16(ehdr->e_machine);

ehdr->e_version = _bswap32(ehdr->e_version);

ehdr->e_entry = _bswap32(ehdr->e_entry);

ehdr->e_phoff = _bswap32(ehdr->e_phoff);

ehdr->e_shoff = _bswap32(ehdr->e_shoff);

ehdr->e_flags = _bswap32(ehdr->e_flags);

ehdr->e_ehsize = _bswap16(ehdr->e_ehsize);

ehdr->e_phentsize = _bswap16(ehdr->e_phentsize);

ehdr->e_phnum = _bswap16(ehdr->e_phnum);

ehdr->e_shentsize = _bswap16(ehdr->e_shentsize);

ehdr->e_shnum = _bswap16(ehdr->e_shnum);

ehdr->e_shstrndx = _bswap16(ehdr->e_shstrndx);

}

/* swap_32_phdr */

static void _swap_32_phdr(Elf_Phdr * phdr)

{

phdr->p_type = _bswap32(phdr->p_type);

phdr->p_offset = _bswap32(phdr->p_offset);

phdr->p_vaddr = _bswap32(phdr->p_vaddr);

phdr->p_paddr = _bswap32(phdr->p_paddr);

phdr->p_filesz = _bswap32(phdr->p_filesz);

phdr->p_memsz = _bswap32(phdr->p_memsz);

phdr->p_flags = _bswap32(phdr->p_flags);

phdr->p_align = _bswap32(phdr->p_align);

}

/* swap_32_shdr */

static void _swap_32_shdr(Elf_Shdr * shdr)

{

shdr->sh_name = _bswap32(shdr->sh_name);

shdr->sh_type = _bswap32(shdr->sh_type);

shdr->sh_flags = _bswap32(shdr->sh_flags);

shdr->sh_addr = _bswap32(shdr->sh_addr);

shdr->sh_offset = _bswap32(shdr->sh_offset);

shdr->sh_size = _bswap32(shdr->sh_size);

shdr->sh_link = _bswap32(shdr->sh_link);

shdr->sh_info = _bswap32(shdr->sh_info);

shdr->sh_addralign = _bswap32(shdr->sh_addralign);

shdr->sh_entsize = _bswap32(shdr->sh_entsize);

}