prime/tools/elf2dol.c

#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.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;
}