/*      $NetBSD: elf2bb.c,v 1.30 2022/04/29 07:12:42 rin Exp $  */

/*-
 * Copyright (c) 1996,2006 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Ignatios Souvatzis.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif

#include <sys/param.h>
#include <sys/types.h>

#include <err.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/mman.h>           /* of the machine we're running on */

#ifndef HAVE_NBTOOL_CONFIG_H
#include <sys/endian.h>         /* of the machine we're running on */
#endif

#include <sys/exec_elf.h>       /* TARGET */
#ifndef R_68K_32                /* XXX host not m68k XXX */
#define R_68K_32        1
#define R_68K_PC32      4
#define R_68K_PC16      5
#endif

#include "elf2bb.h"
#include "chksum.h"

static void usage(void);
static int intcmp(const void *, const void *);
static int eval(Elf32_Sym *, uint32_t *);

#ifdef DEBUG
#define dprintf(x) if (debug) printf x
#else
#define dprintf(x)
#endif
int debug;

#define BBSIZE 8192

char *progname;
int bbsize = BBSIZE;
uint8_t *buffer;
uint32_t *relbuf;
        /* can't have more relocs than that */

static int
intcmp(const void *i, const void *j)
{
        int r;

        r = (*(uint32_t *)i) < (*(uint32_t *)j);
        
        return 2 * r - 1;
}

int
main(int argc, char *argv[])
{
        int ifd, ofd;
        void *image;
        Elf32_Ehdr *eh;
        Elf32_Shdr *sh;
        char *shstrtab;
        Elf32_Sym *symtab;
        char *strtab;
        uint32_t *lptr;
        int i, l, delta;
        uint8_t *rpo;
        uint32_t oldaddr, addrdiff;
        uint32_t tsz, dsz, bsz, trsz, relver;
        uint32_t pcrelsz, r32sz;
        int sumsize = 16;
        int c;
        uint32_t *sect_offset;
        int undefsyms;
        uint32_t tmp32;
        uint16_t tmp16;
        int Sflag = 0;

        progname = argv[0];

        /* insert getopt here, if needed */
        while ((c = getopt(argc, argv, "dFS")) != -1)
        switch(c) {
        case 'F':
                sumsize = 2;
                break;
        case 'S':
                /* Dynamically size second-stage boot */
                Sflag = 1;
                break;
        case 'd':
                debug = 1;
                break;
        default:
                usage();
        }
        argv += optind;
        argc -= optind;

        if (argc < 2)
                usage();

        ifd = open(argv[0], O_RDONLY, 0);
        if (ifd < 0)
                err(1, "Can't open %s", argv[0]);

        image = mmap(0, 65536, PROT_READ, MAP_FILE|MAP_PRIVATE, ifd, 0);
        if (image == MAP_FAILED)
                err(1, "Can't mmap %s", argv[1]);

        eh = (Elf32_Ehdr *)image; /* XXX endianness */

        dprintf(("%04x sections, offset %08x\n", be16toh(eh->e_shnum),
            be32toh(eh->e_shoff)));
        if (be16toh(eh->e_type) != ET_REL)
                errx(1, "%s isn't a relocatable file, type=%d",
                    argv[0], be16toh(eh->e_type));
        if (be16toh(eh->e_machine) != EM_68K)
                errx(1, "%s isn't M68K, machine=%d", argv[0],
                    be16toh(eh->e_machine));

        /* Calculate sizes from section headers. */
        tsz = dsz = bsz = trsz = 0;
        sh = (Elf32_Shdr *)(image + be32toh(eh->e_shoff));
        shstrtab = (char *)(image +
            be32toh(sh[be16toh(eh->e_shstrndx)].sh_offset));
        symtab = NULL;  /* XXX */
        strtab = NULL;  /* XXX */
        dprintf(("    name                      type     flags"
                 "    addr     offset   size     align\n"));
        for (i = 0; i < be16toh(eh->e_shnum); ++i) {
                uint32_t sh_size;

                dprintf(("%2d: %08x %-16s %08x %08x %08x %08x %08x %08x\n", i,
                    be32toh(sh[i].sh_name), shstrtab + be32toh(sh[i].sh_name),
                    be32toh(sh[i].sh_type), be32toh(sh[i].sh_flags),
                    be32toh(sh[i].sh_addr), be32toh(sh[i].sh_offset),
                    be32toh(sh[i].sh_size), be32toh(sh[i].sh_addralign)));
                sh_size = (be32toh(sh[i].sh_size) +
                    be32toh(sh[i].sh_addralign) - 1) &
                    (- be32toh(sh[i].sh_addralign));
                /*
                 * If section allocates memory, add to text, data,
                 * or bss size.
                 */
                if (be32toh(sh[i].sh_flags) & SHF_ALLOC) {
                        if (be32toh(sh[i].sh_type) == SHT_PROGBITS) {
                                if (be32toh(sh[i].sh_flags) & SHF_WRITE)
                                        dsz += sh_size;
                                else
                                        tsz += sh_size;
                        } else
                                bsz += sh_size;
                /* If it's relocations, add to relocation count */
                } else if (be32toh(sh[i].sh_type) == SHT_RELA) {
                        trsz += be32toh(sh[i].sh_size);
                }
                /* Check for SHT_REL? */
                /* Get symbol table location. */
                else if (be32toh(sh[i].sh_type) == SHT_SYMTAB) {
                        symtab = (Elf32_Sym *)(image +
                            be32toh(sh[i].sh_offset));
                } else if (strcmp(".strtab", shstrtab +
                    be32toh(sh[i].sh_name)) == 0) {
                        strtab = image + be32toh(sh[i].sh_offset);
                }
        }
        dprintf(("tsz = 0x%x, dsz = 0x%x, bsz = 0x%x, total 0x%x\n",
            tsz, dsz, bsz, tsz + dsz + bsz));

        if (trsz == 0)
                errx(1, "%s has no relocation records.", argv[0]);

        dprintf(("%d relocs\n", trsz / 12));

        if (Sflag) {
                /*
                 * For second-stage boot, there's no limit for binary size,
                 * and we dynamically scale it. However, it should be small
                 * enough so that
                 *
                 *  (1) all R_68K_PC16 symbols get relocated, and
                 *
                 *  (2) all values in our relocation table for R_68K_32
                 *      symbols fit within 16-bit integer.
                 *
                 * Both will be checked by codes below.
                 *
                 * At the moment, (2) is satisfied with sufficient margin.
                 * But if it is not the case in the future, format for
                 * relocation table should be modified.
                 */
                bbsize = roundup(tsz + dsz, 512);
                sumsize = bbsize / 512;
        } else {
                /*
                 * We have one contiguous area allocated by the ROM to us.
                 */
                if (tsz + dsz + bsz > bbsize)
                        errx(1, "%s: resulting image too big %d+%d+%d=%d",
                            argv[0], tsz, dsz, bsz, tsz + dsz + bsz);
        }

        buffer = NULL;
        relbuf = NULL;

 retry:
        pcrelsz = r32sz = 0;

        buffer = realloc(buffer, bbsize);
        relbuf = realloc(relbuf, bbsize);
        if (buffer == NULL || relbuf == NULL)
                err(1, "Unable to allocate memory\n");

        memset(buffer, 0, bbsize);

        /* Allocate and load loadable sections */
        sect_offset = malloc(be16toh(eh->e_shnum) * sizeof(uint32_t));
        for (i = 0, l = 0; i < be16toh(eh->e_shnum); ++i) {
                if (be32toh(sh[i].sh_flags) & SHF_ALLOC) {
                        dprintf(("vaddr 0x%04x size 0x%04x offset 0x%04x section %s\n",
                            l, be32toh(sh[i].sh_size), be32toh(sh[i].sh_offset),
                            shstrtab + be32toh(sh[i].sh_name)));
                        if (be32toh(sh[i].sh_type) == SHT_PROGBITS)
                                memcpy(buffer + l,
                                    image + be32toh(sh[i].sh_offset),
                                    be32toh(sh[i].sh_size));
                        sect_offset[i] = l;
                        l += (be32toh(sh[i].sh_size) +
                            be32toh(sh[i].sh_addralign) - 1) &
                            (- be32toh(sh[i].sh_addralign));
                }
        }

        /*
         * Hm. This tool REALLY should understand more than one
         * relocator version. For now, check that the relocator at
         * the image start does understand what we output.
         */
        relver = be32toh(*(uint32_t *)(buffer + 4));
        switch (relver) {
        default:
                errx(1, "%s: unrecognized relocator version %d",
                        argv[0], relver);
                /* NOTREACHED */

        case RELVER_RELATIVE_BYTES:
                rpo = buffer + bbsize - 1;
                delta = -1;
                break;

        case RELVER_RELATIVE_BYTES_FORWARD:
                rpo = buffer + tsz + dsz;
                delta = +1;
                *(uint16_t *)(buffer + 14) /* reltab */ = htobe16(tsz + dsz);
                break;
        }

        if (symtab == NULL)
                errx(1, "No symbol table found");
        /*
         * Link sections and generate relocation data
         * Nasty:  .text, .rodata, .data, .bss sections are not linked
         *         Symbol table values relative to start of sections.
         * For each relocation entry:
         *    Symbol value needs to be calculated: value + section offset
         *    Image data adjusted to calculated value of symbol + addend
         *    Add relocation table entry for 32-bit relocatable values
         *    PC-relative entries will be absolute and don't need relocation
         */
        undefsyms = 0;
        for (i = 0; i < be16toh(eh->e_shnum); ++i) {
                int n;
                Elf32_Rela *ra;
                uint8_t *base;

                if (be32toh(sh[i].sh_type) != SHT_RELA)
                        continue;
                base = NULL;
                if (strncmp(shstrtab + be32toh(sh[i].sh_name), ".rela", 5) != 0)
                        err(1, "bad relocation section name %s",
                            shstrtab + be32toh(sh[i].sh_name));
                for (n = 0; n < be16toh(eh->e_shnum); ++n) {
                        if (strcmp(shstrtab + be32toh(sh[i].sh_name) + 5,
                            shstrtab + be32toh(sh[n].sh_name)) != 0)
                                continue;
                        base = buffer + sect_offset[n];
                        break;
                }
                if (base == NULL)
                        errx(1, "Can't find section for reloc %s",
                            shstrtab + be32toh(sh[i].sh_name));
                ra = (Elf32_Rela *)(image + be32toh(sh[i].sh_offset));
                for (n = 0; n < be32toh(sh[i].sh_size);
                    n += sizeof(Elf32_Rela), ++ra) {
                        Elf32_Sym *s;
                        int value;

                        s = &symtab[ELF32_R_SYM(be32toh(ra->r_info))];
                        if (s->st_shndx == ELF_SYM_UNDEFINED) {
                                fprintf(stderr, "Undefined symbol: %s\n",
                                    strtab + be32toh(s->st_name));
                                ++undefsyms;
                        }
                        value = be32toh(ra->r_addend) + eval(s, sect_offset);
                        dprintf(("reloc %04x info %04x (type %d sym %d) add 0x%x val %x\n",
                            be32toh(ra->r_offset), be32toh(ra->r_info),
                            ELF32_R_TYPE(be32toh(ra->r_info)),
                            ELF32_R_SYM(be32toh(ra->r_info)),
                            be32toh(ra->r_addend), value));
                        switch (ELF32_R_TYPE(be32toh(ra->r_info))) {
                        case R_68K_32:
                                tmp32 = htobe32(value);
                                memcpy(base + be32toh(ra->r_offset), &tmp32,
                                       sizeof(tmp32));
                                relbuf[r32sz++] = (base - buffer) +
                                    be32toh(ra->r_offset);
                                break;
                        case R_68K_PC32:
                                ++pcrelsz;
                                tmp32 = htobe32(value - be32toh(ra->r_offset));
                                memcpy(base + be32toh(ra->r_offset), &tmp32,
                                       sizeof(tmp32));
                                break;
                        case R_68K_PC16:
                                ++pcrelsz;
                                value -= be32toh(ra->r_offset);
                                if (value < -0x8000 || value > 0x7fff)
                                        errx(1, "PC-relative offset out of range: %x\n",
                                            value);
                                tmp16 = htobe16(value);
                                memcpy(base + be32toh(ra->r_offset), &tmp16,
                                       sizeof(tmp16));
                                break;
                        default:
                                errx(1, "Relocation type %d not supported",
                                    ELF32_R_TYPE(be32toh(ra->r_info)));
                        }
                }
        }
        dprintf(("%d PC-relative relocations, %d 32-bit relocations\n",
            pcrelsz, r32sz));
        printf("%d absolute reloc%s found, ", r32sz, r32sz == 1 ? "" : "s");
        
        i = r32sz;
        if (i > 1)
                heapsort(relbuf, r32sz, 4, intcmp);

        oldaddr = 0;
        
        for (--i; i >= 0; --i) {
                dprintf(("0x%04x: ", relbuf[i]));
                lptr = (uint32_t *)&buffer[relbuf[i]];
                addrdiff = relbuf[i] - oldaddr;
                dprintf(("(0x%04x, 0x%04x): ", *lptr, addrdiff));
                if (addrdiff > 0xffff) {
                        errx(1, "addrdiff overflows: relbuf = 0x%08x, "
                            "oldaddr = 0x%08x, abort.\n", relbuf[i], oldaddr);
                } else if (addrdiff > 0xff) {
                        *rpo = 0;
                        tmp16 = htobe16(addrdiff);
                        if (delta > 0) {
                                ++rpo;
                                memcpy(rpo, &tmp16, sizeof(tmp16));
                                rpo += sizeof(tmp16);
                                dprintf(("%02x%02x%02x\n",
                                    rpo[-3], rpo[-2], rpo[-1]));
                        } else {
                                rpo -= sizeof(tmp16);
                                memcpy(rpo, &tmp16, sizeof(tmp16));
                                --rpo;
                                dprintf(("%02x%02x%02x\n",
                                    rpo[0], rpo[1], rpo[2]));
                        }
                } else {
                        *rpo = addrdiff;
                        dprintf(("%02x\n", *rpo));
                        rpo += delta;
                }

                oldaddr = relbuf[i];

                if (delta < 0 ?
                    rpo <= buffer + tsz + dsz : rpo >= buffer + bbsize) {
                        printf("relocs don't fit, ");
                        if (Sflag) {
                                printf("retry.\n");
                                bbsize += 512;
                                sumsize++;
                                goto retry;
                        } else
                                errx(1, "abort.");
                }
        }
        *rpo = 0; rpo += delta;
        *rpo = 0; rpo += delta;
        *rpo = 0; rpo += delta;

        printf("using %td bytes, %td bytes remaining.\n",
            delta > 0 ? rpo - buffer - tsz - dsz : buffer + bbsize - rpo,
            delta > 0 ? buffer + bbsize - rpo : rpo - buffer - tsz - dsz);
        /*
         * RELOCs must fit into the bss area.
         */
        if (delta < 0 ?
            rpo <= buffer + tsz + dsz : rpo >= buffer + bbsize) {
                printf("relocs don't fit, ");
                if (Sflag) {
                        printf("retry.\n");
                        bbsize += 512;
                        sumsize++;
                        goto retry;
                } else
                        errx(1, "abort.");
        }

        if (undefsyms > 0)
                errx(1, "Undefined symbols referenced");

        ((uint32_t *)buffer)[1] = 0;
        ((uint32_t *)buffer)[1] = htobe32((0xffffffff -
            chksum((uint32_t *)buffer, sumsize * 512 / 4)));

        ofd = open(argv[1], O_CREAT|O_WRONLY, 0644);
        if (ofd < 0)
                err(1, "Can't open %s", argv[1]);

        if (write(ofd, buffer, bbsize) != bbsize)
                err(1, "Writing output file");

        exit(0);
}

static void
usage(void)
{
        fprintf(stderr, "Usage: %s [-F] bootprog bootprog.bin\n",
            progname);
        exit(1);
        /* NOTREACHED */
}

static int
eval(Elf32_Sym *s, uint32_t *o)
{
        int value;

        value = be32toh(s->st_value);
        if (be16toh(s->st_shndx) < 0xf000)
                value += o[be16toh(s->st_shndx)];
        else
                printf("eval: %x\n", be16toh(s->st_shndx));
        return value;
}