falso
/
oot
mirror of https://github.com/zeldaret/oot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove unused files

This commit is contained in:
Tharo 2025-09-08 23:37:21 +01:00
parent 819f133636
commit 881030ec90
3 changed files with 0 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
linker_scripts/segment.ld
View File

@ -1,22 +0,0 @@
OUTPUT_ARCH (mips)
/* Pass through all sections for partial linking of overlays. Also performs constant merging for GCC. */
SECTIONS {
.rodata :
{
*(*.rodata.cst4)
*(*.rodata.cst8)
*(*.rodata.*)
}
/DISCARD/ :
{
/* GNU ld assumes that the linker script always combines .gptab.data and
* .gptab.sdata into .gptab.sdata, and likewise for .gptab.bss and .gptab.sbss.
* To avoid dealing with this, we just discard all .gptab sections.
*/
*(.gptab.*)
}
}

191
tools/elf32.c
View File

@ -1,191 +0,0 @@
#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;
}

74
tools/elf32.h
View File

@ -1,74 +0,0 @@
#ifndef ELF_H
#define ELF_H
#include <stddef.h>
enum
{
ELF_MACHINE_NONE = 0,
ELF_MACHINE_MIPS = 8,
};
enum
{
ELF_TYPE_RELOC = 1,
ELF_TYPE_EXEC,
ELF_TYPE_SHARED,
ELF_TYPE_CORE,
};
struct Elf32
{
uint8_t endian;
uint16_t type;
uint16_t machine;
uint32_t version;
uint32_t entry;
uint32_t phoff;
uint32_t shoff;
uint16_t ehsize;
uint16_t phentsize;
uint16_t phnum;
uint16_t shentsize;
uint16_t shnum;
uint16_t shstrndx;
int symtabndx;
int strtabndx;
int numsymbols;
const uint8_t *data;
size_t dataSize;
uint16_t (*read16)(const uint8_t *);
uint32_t (*read32)(const uint8_t *);
};
enum
{
SHT_NULL = 0,
SHT_PROGBITS,
SHT_SYMTAB,
SHT_STRTAB,
};
struct Elf32_Section
{
const char *name;
uint32_t type;
uint32_t flags;
uint32_t addr;
uint32_t offset;
uint32_t addralign;
uint32_t entsize;
};
struct Elf32_Symbol
{
const char *name;
uint32_t value;
};
bool elf32_init(struct Elf32 *e, const void *data, size_t size);
bool elf32_get_section(struct Elf32 *e, struct Elf32_Section *sec, int secnum);
bool elf32_get_symbol(struct Elf32 *e, struct Elf32_Symbol *sym, int symnum);
#endif