prime/tools/elf2dol.c

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>
#include <sys/param.h>

#ifndef MAX
//! Get the maximum of two values
#define MAX(a, b)	(((a) > (b)) ? (a) : (b))
#endif

#ifndef MIN
//! Get the minimum of two values
#define MIN(a, b)	(((a) < (b)) ? (a) : (b))
#endif

#define ARRAY_COUNT(arr) (sizeof(arr)/sizeof((arr)[0]))

#define EI_NIDENT       16

typedef struct {
	unsigned char	e_ident[EI_NIDENT];
	uint16_t		e_type;
	uint16_t		e_machine;
	uint32_t		e_version;
	uint32_t		e_entry;
	uint32_t		e_phoff;
	uint32_t		e_shoff;
	uint32_t		e_flags;
	uint16_t		e_ehsize;
	uint16_t		e_phentsize;
	uint16_t		e_phnum;
	uint16_t		e_shentsize;
	uint16_t		e_shnum;
	uint16_t		e_shstrndx;
} Elf32_Ehdr;

#define EI_CLASS	4
#define EI_DATA		5
#define EI_VERSION	6
#define EI_PAD		7
#define EI_NIDENT	16

#define ELFCLASS32	1
#define ELFDATA2MSB	2
#define EV_CURRENT	1

#define ET_EXEC		2
#define EM_PPC		20

typedef struct {
	uint32_t	p_type;
	uint32_t	p_offset;
	uint32_t	p_vaddr;
	uint32_t	p_paddr;
	uint32_t	p_filesz;
	uint32_t	p_memsz;
	uint32_t	p_flags;
	uint32_t	p_align;
} Elf32_Phdr;

#define PT_LOAD	1
#define PF_R	4
#define PF_W	2
#define PF_X	1

int verbosity = 0;

#if BYTE_ORDER == BIG_ENDIAN

#define swap32(x) (x)
#define swap16(x) (x)

#else

static inline uint32_t swap32(uint32_t v)
{
	return (v >> 24) |
	       ((v >> 8)  & 0x0000FF00) |
	       ((v << 8)  & 0x00FF0000) |
	       (v << 24);
}

static inline uint16_t swap16(uint16_t v)
{
	return (v >> 8) | (v << 8);
}

#endif /* BIG_ENDIAN */

typedef struct {

	uint32_t text_off[7];
	uint32_t data_off[11];
	uint32_t text_addr[7];
	uint32_t data_addr[11];
	uint32_t text_size[7];
	uint32_t data_size[11];
	uint32_t bss_addr;
	uint32_t bss_size;
	uint32_t entry;
	uint32_t pad[7];
} DOL_hdr;

#define HAVE_BSS 1

#define MAX_TEXT_SEGMENTS 7
#define MAX_DATA_SEGMENTS 11

#define DOL_ALIGNMENT 32

#define DOL_ALIGN(x) (((x) + DOL_ALIGNMENT - 1) & ~(DOL_ALIGNMENT - 1))

typedef struct {
	DOL_hdr header;
	int text_cnt;
	int data_cnt;
	uint32_t text_elf_off[7];
	uint32_t data_elf_off[11];
	uint32_t flags;
	FILE *elf;
} DOL_map;

void usage(const char *name)
{
	fprintf(stderr, "Usage: %s [-h] [-v] [--] elf-file dol-file\n", name);
	fprintf(stderr, " Convert an ELF file to a DOL file (by segments)\n");
	fprintf(stderr, " Options:\n");
	fprintf(stderr, "  -h    Show this help\n");
	fprintf(stderr, "  -v    Be more verbose (twice for even more)\n");
}

#define die(x) { fprintf(stderr, x "\n"); exit(1); }
#define perrordie(x) { perror(x); exit(1); }

void ferrordie(FILE *f, const char *str)
{
	if(ferror(f)) {
		fprintf(stderr, "Error while ");
		perrordie(str);
	} else if(feof(f)) {
		fprintf(stderr, "EOF while %s\n", str);
		exit(1);
	} else {
		fprintf(stderr, "Unknown error while %s\n", str);
		exit(1);
	}
}

void add_bss(DOL_map *map, uint32_t paddr, uint32_t memsz)
{
	if(map->flags & HAVE_BSS) {
		uint32_t curr_start = swap32(map->header.bss_addr);
		uint32_t curr_size = swap32(map->header.bss_size);
		if (paddr < curr_start)
			map->header.bss_addr = swap32(paddr);
		// Total BSS size should be the end of the last bss section minus the
		// start of the first bss section.
		if (paddr + memsz > curr_start + curr_size)
			map->header.bss_size = swap32(paddr + memsz - curr_start);
	} else {
		map->header.bss_addr = swap32(paddr);
		map->header.bss_size = swap32(memsz);
		map->flags |= HAVE_BSS;
	}
}

void read_elf_segments(DOL_map *map, const char *elf)
{
	int read, i;
	Elf32_Ehdr ehdr;
	
	if(verbosity >= 2)
		fprintf(stderr, "Reading ELF file...\n");
	
	map->elf = fopen(elf, "rb");
	if(!map->elf)
		perrordie("Could not open ELF file");
	
	read = fread(&ehdr, sizeof(ehdr), 1, map->elf);
	if(read != 1)
		ferrordie(map->elf, "reading ELF header");
	
	if(memcmp(&ehdr.e_ident[0], "\177ELF", 4))
		die("Invalid ELF header");
	if(ehdr.e_ident[EI_CLASS] != ELFCLASS32)
		die("Invalid ELF class");
	if(ehdr.e_ident[EI_DATA] != ELFDATA2MSB)
		die("Invalid ELF byte order");
	if(ehdr.e_ident[EI_VERSION] != EV_CURRENT)
		die("Invalid ELF ident version");
	if(swap32(ehdr.e_version) != EV_CURRENT)
		die("Invalid ELF version");
	if(swap16(ehdr.e_type) != ET_EXEC)
		die("ELF is not an executable");
	if(swap16(ehdr.e_machine) != EM_PPC)
		die("Machine is not PowerPC");
	if(!swap32(ehdr.e_entry))
		die("ELF has no entrypoint");
		
	map->header.entry = ehdr.e_entry;
	
	if(verbosity >= 2)
		fprintf(stderr, "Valid ELF header found\n");
	
	uint16_t phnum = swap16(ehdr.e_phnum);
	uint32_t phoff = swap32(ehdr.e_phoff);
	Elf32_Phdr *phdrs;
	
	if(!phnum || !phoff)
		die("ELF has no program headers");
	
	if(swap16(ehdr.e_phentsize) != sizeof(Elf32_Phdr))
		die("Invalid program header entry size");
	
	phdrs = malloc(phnum * sizeof(Elf32_Phdr));
	
	if(fseek(map->elf, phoff, SEEK_SET) < 0)
		ferrordie(map->elf, "reading ELF program headers");
	read = fread(phdrs, sizeof(Elf32_Phdr), phnum, map->elf);
	if(read != phnum)
		ferrordie(map->elf, "reading ELF program headers");
	
	for(i=0; i<phnum; i++) {
		if(swap32(phdrs[i].p_type) == PT_LOAD) {
			uint32_t offset = swap32(phdrs[i].p_offset);
			uint32_t paddr = swap32(phdrs[i].p_vaddr);
			uint32_t filesz = swap32(phdrs[i].p_filesz);
			uint32_t memsz = swap32(phdrs[i].p_memsz);
			uint32_t flags = swap32(phdrs[i].p_flags);
			if(memsz) {
				if(verbosity >= 2)
					fprintf(stderr, "PHDR %d: 0x%x [0x%x] -> 0x%08x [0x%x] flags 0x%x\n",
					        i, offset, filesz, paddr, memsz, flags);
				if(flags & PF_X) {
					// TEXT segment
					if(!(flags & PF_R))
						fprintf(stderr, "Warning: non-readable segment %d\n", i);
					if(flags & PF_W)
						fprintf(stderr, "Warning: writable and executable segment %d\n", i);
					if(filesz > memsz) {
							fprintf(stderr, "Error: TEXT segment %d memory size (0x%x) smaller than file size (0x%x)\n",
							                i, memsz, filesz);
							exit(1);
					} else if (memsz > filesz) {
						add_bss(map, paddr + filesz, memsz - filesz);
					}
					if(map->text_cnt >= MAX_TEXT_SEGMENTS) {
						die("Error: Too many TEXT segments");
					}
					map->header.text_addr[map->text_cnt] = swap32(paddr);
					map->header.text_size[map->text_cnt] = swap32(filesz);
					map->text_elf_off[map->text_cnt] = offset;
					map->text_cnt++;
				} else {
					// DATA or BSS segment
					if(!(flags & PF_R))
						fprintf(stderr, "Warning: non-readable segment %d\n", i);
					if(filesz == 0) {
						// BSS segment
						add_bss(map, paddr, memsz);
					} else {
						// DATA segment
						if(filesz > memsz) {
							fprintf(stderr, "Error: segment %d memory size (0x%x) is smaller than file size (0x%x)\n",
							        i, memsz, filesz);
							exit(1);
						}
						if(map->data_cnt >= MAX_DATA_SEGMENTS) {
							die("Error: Too many DATA segments");
						}
						map->header.data_addr[map->data_cnt] = swap32(paddr);
						map->header.data_size[map->data_cnt] = swap32(filesz);
						map->data_elf_off[map->data_cnt] = offset;
						map->data_cnt++;
					}
				}
			
			} else {
				if(verbosity >= 1)
					fprintf(stderr, "Skipping empty program header %d\n", i);
			}
		} else if(verbosity >= 1) {
			fprintf(stderr, "Skipping program header %d of type %d\n", i, swap32(phdrs[i].p_type));
		}
	}
	if(verbosity >= 2) {
		fprintf(stderr, "Segments:\n");
		for(i=0; i<map->text_cnt; i++) {
			fprintf(stderr, " TEXT %d: 0x%08x [0x%x] from ELF offset 0x%x\n",
			        i, swap32(map->header.text_addr[i]), swap32(map->header.text_size[i]),
			        map->text_elf_off[i]);
		}
		for(i=0; i<map->data_cnt; i++) {
			fprintf(stderr, " DATA %d: 0x%08x [0x%x] from ELF offset 0x%x\n",
			        i, swap32(map->header.data_addr[i]), swap32(map->header.data_size[i]),
			        map->data_elf_off[i]);
		}
		if(map->flags & HAVE_BSS)
			fprintf(stderr, " BSS segment: 0x%08x [0x%x]\n", swap32(map->header.bss_addr),
			        swap32(map->header.bss_size));
	}
}

void map_dol(DOL_map *map)
{
	uint32_t fpos;
	int i;
	
	if(verbosity >= 2)
		fprintf(stderr, "Laying out DOL file...\n");
	
	fpos = DOL_ALIGN(sizeof(DOL_hdr));
	
	for(i=0; i<map->text_cnt; i++) {
		if(verbosity >= 2)
			fprintf(stderr, " TEXT segment %d at 0x%x\n", i, fpos);
		map->header.text_off[i] = swap32(fpos);
		fpos = DOL_ALIGN(fpos + swap32(map->header.text_size[i]));
	}
	for(i=0; i<map->data_cnt; i++) {
		if(verbosity >= 2)
			fprintf(stderr, " DATA segment %d at 0x%x\n", i, fpos);
		map->header.data_off[i] = swap32(fpos);
		fpos = DOL_ALIGN(fpos + swap32(map->header.data_size[i]));
	}
	
	if(map->text_cnt == 0) {
		if(verbosity >= 1)
			fprintf(stderr, "Note: adding dummy TEXT segment to work around IOS bug\n");
		map->header.text_off[0] = swap32(DOL_ALIGN(sizeof(DOL_hdr)));
	}
	if(map->data_cnt == 0) {
		if(verbosity >= 1)
			fprintf(stderr, "Note: adding dummy DATA segment to work around IOS bug\n");
		map->header.data_off[0] = swap32(DOL_ALIGN(sizeof(DOL_hdr)));
	}
}

#define BLOCK (1024*1024)

void fcpy(FILE *dst, FILE *src, uint32_t dst_off, uint32_t src_off, uint32_t size)
{
	int left = size;
	int read;
	int written;
	int block;
	void *blockbuf;

	if(fseek(src, src_off, SEEK_SET) < 0)
		ferrordie(src, "reading ELF segment data");
	if(fseek(dst, dst_off, SEEK_SET) < 0)
		ferrordie(dst, "writing DOL segment data");
	
	blockbuf = malloc(MIN(BLOCK, left));
	
	while(left) {
		block = MIN(BLOCK, left);
		read = fread(blockbuf, 1, block, src);
		if(read != block) {
			free(blockbuf);
			ferrordie(src, "reading ELF segment data");
		}
		written = fwrite(blockbuf, 1, block, dst);
		if(written != block) {
			free(blockbuf);
			ferrordie(dst, "writing DOL segment data");
		}
		left -= block;
	}
	free(blockbuf);
}

void fpad(FILE *dst, uint32_t dst_off, uint32_t size)
{
	uint32_t i;

	if(fseek(dst, dst_off, SEEK_SET) < 0)
		ferrordie(dst, "writing DOL segment data");
	for(i=0; i<size; i++)
		fputc(0, dst);
}

void write_dol(DOL_map *map, const char *dol)
{
	FILE *dolf;
	int written;
	int i;

	if(verbosity >= 2)
		fprintf(stderr, "Writing DOL file...\n");
		
	dolf = fopen(dol, "wb");
	if(!dolf)
		perrordie("Could not open DOL file");
	
	if(verbosity >= 2) {
		fprintf(stderr, "DOL header:\n");
		for(i=0; i<MAX(1,map->text_cnt); i++)
			fprintf(stderr, " TEXT %d @ 0x%08x [0x%x] off 0x%x\n", i,
			        swap32(map->header.text_addr[i]), swap32(map->header.text_size[i]),
			        swap32(map->header.text_off[i]));
		for(i=0; i<MAX(1,map->data_cnt); i++)
			fprintf(stderr, " DATA %d @ 0x%08x [0x%x] off 0x%x\n", i,
			        swap32(map->header.data_addr[i]), swap32(map->header.data_size[i]),
			        swap32(map->header.data_off[i]));
		if(swap32(map->header.bss_addr) && swap32(map->header.bss_size))
			fprintf(stderr, " BSS @ 0x%08x [0x%x]\n", swap32(map->header.bss_addr),
			        swap32(map->header.bss_size));
		fprintf(stderr, " Entry: 0x%08x\n", swap32(map->header.entry));
		fprintf(stderr, "Writing DOL header...\n");
	}
	
	// Write DOL header with aligned text and data section sizes
	DOL_hdr aligned_header = map->header;
	for(i=0; i<ARRAY_COUNT(aligned_header.text_size); i++)
		aligned_header.text_size[i] = swap32(DOL_ALIGN(swap32(aligned_header.text_size[i])));
	for(i=0; i<ARRAY_COUNT(aligned_header.data_size); i++)
		aligned_header.data_size[i] = swap32(DOL_ALIGN(swap32(aligned_header.data_size[i])));
	written = fwrite(&aligned_header, sizeof(DOL_hdr), 1, dolf);
	if(written != 1)
		ferrordie(dolf, "writing DOL header");
	
	for(i=0; i<map->text_cnt; i++) {
		uint32_t size = swap32(map->header.text_size[i]);
		uint32_t padded_size = DOL_ALIGN(size);
		if(verbosity >= 2)
			fprintf(stderr, "Writing TEXT segment %d...\n", i);
		fcpy(dolf, map->elf, swap32(map->header.text_off[i]), map->text_elf_off[i], size);
		if (padded_size > size)
			fpad(dolf, swap32(map->header.text_off[i]) + size, padded_size - size);
	}
	for(i=0; i<map->data_cnt; i++) {
		uint32_t size = swap32(map->header.data_size[i]);
		uint32_t padded_size = DOL_ALIGN(size);
		if(verbosity >= 2)
			fprintf(stderr, "Writing DATA segment %d...\n", i);
		fcpy(dolf, map->elf, swap32(map->header.data_off[i]), map->data_elf_off[i], size);
		if (padded_size > size)
			fpad(dolf, swap32(map->header.data_off[i]) + size, padded_size - size);
	}
	
	if(verbosity >= 2)
		fprintf(stderr, "All done!\n");
	
	fclose(map->elf);
	fclose(dolf);
}

int main(int argc, char **argv)
{
	char **arg;

	if(argc < 2) {
		usage(argv[0]);
		return 1;
	}
	arg = &argv[1];
	argc--;

	while(argc && *arg[0] == '-') {
		if(!strcmp(*arg, "-h")) {
			usage(argv[0]);
			return 1;
		} else if(!strcmp(*arg, "-v")) {
			verbosity++;
		} else if(!strcmp(*arg, "--")) {
			arg++;
			argc--;
			break;
		} else {
			fprintf(stderr, "Unrecognized option %s\n", *arg);
			usage(argv[0]);
			return 1;
		}
		arg++;
		argc--;
	}
	if(argc < 2) {
		usage(argv[0]);
		exit(1);
	}

	const char *elf_file = arg[0];
	const char *dol_file = arg[1];

	DOL_map map;

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

	read_elf_segments(&map, elf_file);
	map_dol(&map);
	write_dol(&map, dol_file);
	
	return 0;
}