mirror of
https://github.com/zeldaret/oot.git
synced 2024-09-21 04:24:43 +00:00
* remove trailing whitespaces * minor docs tweaks * some more trailing whitespaces * few more tweaks
192 lines
4.7 KiB
C
192 lines
4.7 KiB
C
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "elf32.h"
|
|
|
|
static uint16_t read16_le(const uint8_t *data)
|
|
{
|
|
return data[0] << 0
|
|
| data[1] << 8;
|
|
}
|
|
|
|
static uint32_t read32_le(const uint8_t *data)
|
|
{
|
|
return data[0] << 0
|
|
| data[1] << 8
|
|
| data[2] << 16
|
|
| data[3] << 24;
|
|
}
|
|
|
|
static uint16_t read16_be(const uint8_t *data)
|
|
{
|
|
return data[0] << 8
|
|
| data[1] << 0;
|
|
}
|
|
|
|
static uint32_t read32_be(const uint8_t *data)
|
|
{
|
|
return data[0] << 24
|
|
| data[1] << 16
|
|
| data[2] << 8
|
|
| data[3] << 0;
|
|
}
|
|
|
|
static const void *get_section_header(struct Elf32 *e, int secnum)
|
|
{
|
|
size_t secoffset = e->shoff + secnum * 0x28;
|
|
|
|
if (secnum >= e->shnum || secoffset >= e->dataSize)
|
|
return NULL;
|
|
return e->data + secoffset;
|
|
}
|
|
|
|
static const void *get_section_contents(struct Elf32 *e, int secnum)
|
|
{
|
|
size_t secoffset = e->shoff + secnum * 0x28;
|
|
size_t dataoffset;
|
|
|
|
if (secnum >= e->shnum || secoffset >= e->dataSize)
|
|
return NULL;
|
|
dataoffset = e->read32(e->data + secoffset + 0x10);
|
|
return e->data + dataoffset;
|
|
}
|
|
|
|
static bool verify_magic(const uint8_t *data)
|
|
{
|
|
return (data[0] == 0x7F && data[1] == 'E' && data[2] == 'L' && data[3] == 'F');
|
|
}
|
|
|
|
bool elf32_init(struct Elf32 *e, const void *data, size_t size)
|
|
{
|
|
unsigned int i;
|
|
|
|
e->data = data;
|
|
e->dataSize = size;
|
|
|
|
if (size < 0x34)
|
|
return false; // not big enough for header
|
|
|
|
if (!verify_magic(e->data))
|
|
return false;
|
|
|
|
if (e->data[4] != 1)
|
|
return false; // must be 32-bit
|
|
|
|
e->endian = e->data[5];
|
|
|
|
switch (e->endian)
|
|
{
|
|
case 1:
|
|
e->read16 = read16_le;
|
|
e->read32 = read32_le;
|
|
break;
|
|
case 2:
|
|
e->read16 = read16_be;
|
|
e->read32 = read32_be;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
e->type = e->read16(e->data + 0x10);
|
|
e->machine = e->read16(e->data + 0x12);
|
|
e->version = e->data[6];
|
|
e->entry = e->read32(e->data + 0x18);
|
|
e->phoff = e->read32(e->data + 0x1C);
|
|
e->shoff = e->read32(e->data + 0x20);
|
|
e->ehsize = e->read16(e->data + 0x28);
|
|
e->phentsize = e->read16(e->data + 0x2A);
|
|
e->phnum = e->read16(e->data + 0x2C);
|
|
e->shentsize = e->read16(e->data + 0x2E);
|
|
e->shnum = e->read16(e->data + 0x30);
|
|
e->shstrndx = e->read16(e->data + 0x32);
|
|
|
|
// find symbol table section
|
|
e->symtabndx = -1;
|
|
for (i = 0; i < e->shnum; i++)
|
|
{
|
|
const uint8_t *sechdr = get_section_header(e, i);
|
|
uint32_t type = e->read32(sechdr + 0x04);
|
|
|
|
if (type == SHT_SYMTAB)
|
|
{
|
|
e->symtabndx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// find .strtab section
|
|
e->strtabndx = -1;
|
|
for (i = 0; i < e->shnum; i++)
|
|
{
|
|
const uint8_t *sechdr = get_section_header(e, i);
|
|
uint32_t type = e->read32(sechdr + 0x04);
|
|
|
|
if (type == SHT_STRTAB)
|
|
{
|
|
const char *strings = get_section_contents(e, e->shstrndx);
|
|
const char *secname = strings + e->read32(sechdr + 0);
|
|
|
|
if (strcmp(secname, ".strtab") == 0)
|
|
{
|
|
e->strtabndx = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
e->numsymbols = 0;
|
|
if (e->symtabndx != -1)
|
|
{
|
|
const uint8_t *sechdr = get_section_header(e, e->symtabndx);
|
|
//const uint8_t *symtab = get_section_contents(e, e->symtabndx);
|
|
|
|
e->numsymbols = e->read32(sechdr + 0x14) / e->read32(sechdr + 0x24);
|
|
}
|
|
|
|
if (e->shoff + e->shstrndx * 0x28 >= e->dataSize)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool elf32_get_section(struct Elf32 *e, struct Elf32_Section *sec, int secnum)
|
|
{
|
|
const uint8_t *sechdr = get_section_header(e, secnum);
|
|
const char *strings = get_section_contents(e, e->shstrndx);
|
|
|
|
sec->name = strings + e->read32(sechdr + 0);
|
|
sec->type = e->read32(sechdr + 0x04);
|
|
sec->flags = e->read32(sechdr + 0x08);
|
|
sec->addr = e->read32(sechdr + 0x0C);
|
|
sec->offset = e->read32(sechdr + 0x10);
|
|
sec->addralign = e->read32(sechdr + 0x20);
|
|
sec->entsize = e->read32(sechdr + 0x24);
|
|
return true;
|
|
}
|
|
|
|
bool elf32_get_symbol(struct Elf32 *e, struct Elf32_Symbol *sym, int symnum)
|
|
{
|
|
const uint8_t *sechdr;
|
|
const uint8_t *symtab;
|
|
const char *strings;
|
|
int symcount;
|
|
|
|
if (e->symtabndx == -1)
|
|
return false;
|
|
|
|
sechdr = get_section_header(e, e->symtabndx);
|
|
symtab = get_section_contents(e, e->symtabndx);
|
|
strings = get_section_contents(e, e->strtabndx);
|
|
|
|
symcount = e->read32(sechdr + 0x14) / e->read32(sechdr + 0x24);
|
|
if (symnum >= symcount)
|
|
return false;
|
|
|
|
sym->name = strings + e->read32(symtab + symnum * 0x10);
|
|
sym->value = e->read32(symtab + symnum * 0x10 + 4);
|
|
return true;
|
|
}
|