/*      $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;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.