/*
 *      aout2hux - convert a.out/ELF executable to Human68k .x format
 *
 *      Read two a.out/ELF format executables with different load addresses
 *      and generate Human68k .x format executable.
 *
 *      written by ITOH Yasufumi
 *      public domain
 *
 * usage:
 *      aout2hux [ -o output.x ] a.out1 loadaddr1 a.out2 loadaddr2
 *
 *      The input files must be static OMAGIC/NMAGIC m68k a.out executables
 *      or m68k ELF executables.
 *      Two executables must have different loading addresses.
 *      Each of the load address must be a hexadecimal number.
 *      Load address shall be multiple of 4 for as / ld of NetBSD/m68k.
 *
 * example:
 *      % cc -N -static -Wl,-Ttext,0        -o aout1 *.o
 *      % cc -N -static -Wl,-Ttext,10203040 -o aout2 *.o
 *      % aout2hux -o foo.x aout1 0 aout2 10203040
 *
 *      $NetBSD: aout2hux.c,v 1.14 2024/01/07 07:58:33 isaki Exp $
 */

#include <sys/types.h>
#ifndef NO_UNISTD
# include <unistd.h>
#endif
#ifndef NO_STDLIB
# include <stdlib.h>
#endif
#include <stdio.h>
#include <string.h>

#include "type_local.h"
#include "aout68k.h"
#include "hux.h"

/* fseek() offset type */
typedef long    foff_t;

#ifndef DEFAULT_OUTPUT_FILE
# define DEFAULT_OUTPUT_FILE    "out.x"
#endif

#ifdef DEBUG
# define DPRINTF(x)     printf x
#else
# define DPRINTF(x)
#endif

struct exec_info {
        foff_t          text_off;       /* file offset of text section */
        foff_t          data_off;       /* file offset of data section */
        u_int32_t       text_size;      /* size of text section */
        u_int32_t       text_pad;       /* pad between text and data */
        u_int32_t       data_size;      /* size of data section */
        u_int32_t       bss_size;       /* size of bss */
        u_int32_t       entry_addr;     /* entry point address */
};

unsigned get_uint16(be_uint16_t *be);
u_int32_t get_uint32(be_uint32_t *be);
void put_uint16(be_uint16_t *be, unsigned v);
void put_uint32(be_uint32_t *be, u_int32_t v);
void *do_realloc(void *p, size_t s);

static int open_aout(const char *fn, struct aout_m68k *hdr,
                struct exec_info *inf);
static int open_elf(const char *fn, FILE *fp, struct elf_m68k_hdr *hdr,
                struct exec_info *inf);
FILE *open_exec(const char *fn, struct exec_info *inf);
int check_2_exec_inf(struct exec_info *inf1, struct exec_info *inf2);
int aout2hux(const char *fn1, const char *fn2,
                u_int32_t loadadr1, u_int32_t loadadr2, const char *fnx);
int gethex(u_int32_t *pval, const char *str);
void usage(const char *name);

#if !defined(bzero) && defined(__SVR4)
# define bzero(d, n)    memset((d), 0, (n))
#endif

/*
 * read/write big-endian integer
 */

unsigned
get_uint16(be_uint16_t *be)
{

        return be->val[0] << 8 | be->val[1];
}

u_int32_t
get_uint32(be_uint32_t *be)
{

        return be->val[0]<<24 | be->val[1]<<16 | be->val[2]<<8 | be->val[3];
}

void
put_uint16(be_uint16_t *be, unsigned v)
{

        be->val[0] = (u_int8_t) (v >> 8);
        be->val[1] = (u_int8_t) v;
}

void
put_uint32(be_uint32_t *be, u_int32_t v)
{

        be->val[0] = (u_int8_t) (v >> 24);
        be->val[1] = (u_int8_t) (v >> 16);
        be->val[2] = (u_int8_t) (v >> 8);
        be->val[3] = (u_int8_t) v;
}

void *
do_realloc(void *p, size_t s)
{

        p = p ? realloc(p, s) : malloc(s);      /* for portability */

        if (!p) {
                fprintf(stderr, "malloc failed\n");
                exit(1);
        }

        return p;
}

/*
 * check a.out header
 */
static int
open_aout(const char *fn, struct aout_m68k *hdr, struct exec_info *inf)
{
        int i;

        DPRINTF(("%s: is an a.out\n", fn));

        if ((i = AOUT_GET_MID(hdr)) != AOUT_MID_M68K && i != AOUT_MID_M68K4K) {
                fprintf(stderr, "%s: wrong architecture (mid %d)\n", fn, i);
                return 1;
        }

        /* if unsolved relocations exist, not an executable but an object */
        if (hdr->a_trsize.hostval || hdr->a_drsize.hostval) {
                fprintf(stderr, "%s: not an executable (object file?)\n", fn);
                return 1;
        }

        if (AOUT_GET_FLAGS(hdr) & (AOUT_FLAG_PIC | AOUT_FLAG_DYNAMIC)) {
                fprintf(stderr, "%s: PIC and DYNAMIC are not supported\n", fn);
                return 1;
        }

        inf->text_size = get_uint32(&hdr->a_text);
        inf->data_size = get_uint32(&hdr->a_data);
        inf->bss_size = get_uint32(&hdr->a_bss);
        inf->entry_addr = get_uint32(&hdr->a_entry);
        inf->text_off = sizeof(struct aout_m68k);
        inf->data_off = sizeof(struct aout_m68k) + inf->text_size;
        inf->text_pad = -inf->text_size & (AOUT_PAGESIZE(hdr) - 1);

        return 0;
}

/*
 * digest ELF structure
 */
static int
open_elf(const char *fn, FILE *fp, struct elf_m68k_hdr *hdr, struct exec_info *inf)
{
        int i;
        size_t nphdr;
        struct elf_m68k_phdr phdr[2];

        DPRINTF(("%s: is an ELF\n", fn));

        if (hdr->e_ident[EI_VERSION] != EV_CURRENT ||
            get_uint32(&hdr->e_version) != EV_CURRENT) {
                fprintf(stderr, "%s: unknown ELF version\n", fn);
                return 1;
        }

        if (get_uint16(&hdr->e_type) != ET_EXEC) {
                fprintf(stderr, "%s: not an executable\n", fn);
                return 1;
        }

        if ((i = get_uint16(&hdr->e_machine)) != EM_68K) {
                fprintf(stderr, "%s: wrong architecture (%d)\n", fn, i);
                return 1;
        }

        if ((i = get_uint16(&hdr->e_shentsize)) != SIZE_ELF68K_SHDR) {
                fprintf(stderr, "%s: size shdr %d should be %d\n", fn, i,
                        (int)SIZE_ELF68K_SHDR);
                return 1;
        }

        if ((i = get_uint16(&hdr->e_phentsize)) != SIZE_ELF68K_PHDR) {
                fprintf(stderr, "%s: size phdr %d should be %d\n", fn, i,
                        (int)SIZE_ELF68K_PHDR);
                return 1;
        }

        if ((nphdr = get_uint16(&hdr->e_phnum)) != 1 && nphdr != 2) {
                fprintf(stderr,
                        "%s: has %lu loadable segments (should be 1 or 2)\n",
                        fn, (unsigned long)nphdr);
                return 1;
        }

        /* Read ELF program header table. */
        if (fseek(fp, (foff_t) get_uint32(&hdr->e_phoff), SEEK_SET)) {
                perror(fn);
                return 1;
        }
        if (fread(phdr, sizeof phdr[0], nphdr, fp) != nphdr) {
                fprintf(stderr, "%s: can't read ELF program header\n", fn);
                return 1;
        }

        /* Just error checking. */
        for (i = 0; i < (int) nphdr; i++) {
                if (get_uint32(&phdr[i].p_type) != PT_LOAD) {
                        fprintf(stderr,
                                "%s: program header #%d is not loadable\n",
                                fn, i);
                        return 1;
                }
        }

        if (nphdr == 1 && (get_uint32(&phdr[0].p_flags) & PF_W)) {
                /*
                 * Only one writable section --- probably "ld -N" executable.
                 * Find out the start of data segment.
                 */
                struct elf_m68k_shdr shdr;
                int nshdr;

                nshdr = get_uint16(&hdr->e_shnum);

                /* section #0 always exists and reserved --- skip */
                if (nshdr > 1 &&
                    fseek(fp,
                          (foff_t) (get_uint32(&hdr->e_shoff) + sizeof shdr),
                          SEEK_SET)) {
                        perror(fn);
                        return 1;
                }
                for (i = 1; i < nshdr; i++) {
                        if (fread(&shdr, sizeof shdr, 1, fp) != 1) {
                                fprintf(stderr,
                                        "%s: can't read ELF section header\n",
                                        fn);
                                return 1;
                        }

                        DPRINTF(("%s: section header #%d: flags 0x%x\n",
                                fn, i, get_uint32(&shdr.sh_flags)));

                        if (ELF68K_ISDATASEG(&shdr)) {
                                /*
                                 * data section is found.
                                 */
                                DPRINTF(("%s: one section, data found\n", fn));
                                inf->text_off = get_uint32(&phdr[0].p_offset);
                                inf->text_size = get_uint32(&shdr.sh_offset) -
                                                 inf->text_off;
                                inf->text_pad = 0;
                                inf->data_off = inf->text_off + inf->text_size;
                                inf->data_size = get_uint32(&phdr[0].p_filesz) -
                                                 inf->text_size;
                                inf->bss_size = get_uint32(&phdr[0].p_memsz) -
                                                get_uint32(&phdr[0].p_filesz);
                                inf->entry_addr = get_uint32(&hdr->e_entry);
                                goto data_found;
                        }
                }
                /*
                 * No data section found --- probably text + bss.
                 */
                DPRINTF(("%s: one section, no data section\n", fn));
                inf->text_size = get_uint32(&phdr[0].p_filesz);
                inf->data_size = 0;
                inf->bss_size = get_uint32(&phdr[0].p_memsz) - inf->text_size;
                inf->entry_addr = get_uint32(&hdr->e_entry);
                inf->text_off = get_uint32(&phdr[0].p_offset);
                inf->data_off = 0;
                inf->text_pad = 0;
data_found:;
        } else if (nphdr == 1) {
                /*
                 * Only one non-writable section --- pure text program?
                 */
                DPRINTF(("%s: one RO section\n", fn));
                inf->text_size = get_uint32(&phdr[0].p_filesz);
                inf->data_size = 0;
                inf->bss_size = 0;
                inf->entry_addr = get_uint32(&hdr->e_entry);
                inf->text_off = get_uint32(&phdr[0].p_offset);
                inf->data_off = 0;
                inf->text_pad = get_uint32(&phdr[0].p_memsz) - inf->text_size;
        } else {
                /*
                 * two sections
                 * text + data assumed.
                 */
                int t = 0, d = 1, tmp;  /* first guess */
#define SWAP_T_D        tmp = t, t = d, d = tmp

                DPRINTF(("%s: two sections\n", fn));

                /* Find out text and data. */
                if (get_uint32(&phdr[t].p_vaddr) > get_uint32(&phdr[d].p_vaddr))
                        SWAP_T_D;

                if ((get_uint32(&phdr[t].p_flags) & PF_X) == 0 &&
                    get_uint32(&phdr[d].p_flags) & PF_X)
                        SWAP_T_D;

                if ((get_uint32(&phdr[d].p_flags) & PF_W) == 0 &&
                    get_uint32(&phdr[t].p_flags) & PF_W)
                        SWAP_T_D;
#undef SWAP_T_D

                /* Are the text/data sections correctly detected? */
                if (get_uint32(&phdr[t].p_vaddr) >
                    get_uint32(&phdr[d].p_vaddr)) {
                        fprintf(stderr, "%s: program sections not in order\n",
                                fn);
                        return 1;
                }

                if ((get_uint32(&phdr[t].p_flags) & PF_X) == 0)
                        fprintf(stderr, "%s: warning: text is not executable\n",
                                fn);

                if ((get_uint32(&phdr[d].p_flags) & PF_W) == 0)
                        fprintf(stderr, "%s: warning: data is not writable\n",
                                fn);

                inf->text_size = get_uint32(&phdr[t].p_filesz);
                inf->data_size = get_uint32(&phdr[d].p_filesz);
                inf->bss_size = get_uint32(&phdr[d].p_memsz) - inf->data_size;
                inf->entry_addr = get_uint32(&hdr->e_entry);
                inf->text_off = get_uint32(&phdr[t].p_offset);
                inf->data_off = get_uint32(&phdr[d].p_offset);
                inf->text_pad = get_uint32(&phdr[d].p_vaddr) -
                        (get_uint32(&phdr[t].p_vaddr) + inf->text_size);
        }

        return 0;
}

/*
 * open an executable
 */
FILE *
open_exec(const char *fn, struct exec_info *inf)
{
        FILE *fp;
        int i;
        union {
                struct aout_m68k        u_aout;
                struct elf_m68k_hdr     u_elf;
        } buf;
#define hdra    (&buf.u_aout)
#define hdre    (&buf.u_elf)

        if (!(fp = fopen(fn, "r"))) {
                perror(fn);
                return (FILE *) NULL;
        }

        /*
         * Check for a.out.
         */

        if (fread(hdra, sizeof(struct aout_m68k), 1, fp) != 1) {
                fprintf(stderr, "%s: can't read a.out header\n", fn);
                goto out;
        }

        if ((i = AOUT_GET_MAGIC(hdra)) != AOUT_OMAGIC && i != AOUT_NMAGIC)
                goto notaout;

        if (open_aout(fn, hdra, inf))
                goto out;

        /* OK! */
        return fp;

notaout:
        /*
         * Check for ELF.
         */

        if (hdre->e_ident[EI_MAG0] != ELFMAG0 ||
            hdre->e_ident[EI_MAG1] != ELFMAG1 ||
            hdre->e_ident[EI_MAG2] != ELFMAG2 ||
            hdre->e_ident[EI_MAG3] != ELFMAG3 ||
            hdre->e_ident[EI_CLASS] != ELFCLASS32 ||
            hdre->e_ident[EI_DATA] != ELFDATA2MSB) {
                fprintf(stderr,
                    "%s: not an OMAGIC or NMAGIC a.out, or a 32bit BE ELF\n",
                    fn);
                goto out;
        }

        /* ELF header is longer than a.out header.  Read the rest. */
        if (fread(hdra + 1,
                  sizeof(struct elf_m68k_hdr) - sizeof(struct aout_m68k),
                  1, fp) != 1) {
                fprintf(stderr, "%s: can't read ELF header\n", fn);
                goto out;
        }

        if (open_elf(fn, fp, hdre, inf))
                goto out;

        /* OK! */
        return fp;

out:    fclose(fp);
        return (FILE *) NULL;
#undef hdra
#undef hdre
}

/*
 * compare two executables and check if they are compatible
 */
int
check_2_exec_inf(struct exec_info *inf1, struct exec_info *inf2)
{

        if (inf1->text_size != inf2->text_size ||
            inf1->text_pad != inf2->text_pad ||
            inf1->data_size != inf2->data_size ||
            inf1->bss_size != inf2->bss_size)
                return -1;

        return 0;
}

/* allocation unit (in bytes) of relocation table */
#define RELTBL_CHUNK    8192

/*
 * add an entry to the relocation table
 */
#define ADD_RELTBL(adr) \
        if (relsize + sizeof(struct relinf_l) > relallocsize)               \
                reltbl = do_realloc(reltbl, relallocsize += RELTBL_CHUNK);  \
        if ((adr) < reladdr + HUX_MINLREL) {                                \
                struct relinf_s *r = (struct relinf_s *)(reltbl + relsize); \
                put_uint16(&r->locoff_s, (unsigned)((adr) - reladdr));      \
                relsize += sizeof(struct relinf_s);                         \
                DPRINTF(("short"));                                         \
        } else {                                                            \
                struct relinf_l *r = (struct relinf_l *)(reltbl + relsize); \
                put_uint16(&r->lrelmag, HUXLRELMAGIC);                      \
                put_uint32((be_uint32_t *)r->locoff_l, (adr) - reladdr);    \
                relsize += sizeof(struct relinf_l);                         \
                DPRINTF(("long "));                                         \
        }                                                                   \
        DPRINTF((" reloc 0x%06x", (adr)));                                  \
        reladdr = (adr);

#define ERR1    { if (ferror(fpa1)) perror(fn1);                        \
                  else fprintf(stderr, "%s: unexpected EOF\n", fn1);    \
                  goto out; }
#define ERR2    { if (ferror(fpa2)) perror(fn2);                        \
                  else fprintf(stderr, "%s: unexpected EOF\n", fn2);    \
                  goto out; }
#define ERRC    { fprintf(stderr, "files %s and %s are inconsistent\n", \
                                  fn1, fn2);                            \
                  goto out; }

/*
 * read input executables and output .x body
 * and create relocation table
 */
#define CREATE_RELOCATION(segsize)      \
        while (segsize > 0 || nbuf) {                                   \
                if (nbuf == 0) {                                        \
                        if (fread(&b1.half[0], SIZE_16, 1, fpa1) != 1)  \
                                ERR1                                    \
                        if (fread(&b2.half[0], SIZE_16, 1, fpa2) != 1)  \
                                ERR2                                    \
                        nbuf = 1;                                       \
                        segsize -= SIZE_16;                             \
                } else if (nbuf == 1) {                                 \
                        if (segsize == 0) {                             \
                                if (b1.half[0].hostval != b2.half[0].hostval) \
                                        ERRC                            \
                                fwrite(&b1.half[0], SIZE_16, 1, fpx);   \
                                nbuf = 0;                               \
                                addr += SIZE_16;                        \
                        } else {                                        \
                                if (fread(&b1.half[1], SIZE_16, 1, fpa1) != 1)\
                                        ERR1                            \
                                if (fread(&b2.half[1], SIZE_16, 1, fpa2) != 1)\
                                        ERR2                            \
                                nbuf = 2;                               \
                                segsize -= SIZE_16;                     \
                        }                                               \
                } else /* if (nbuf == 2) */ {                           \
                        if (b1.hostval != b2.hostval &&                 \
                            get_uint32(&b1) - loadadr1                  \
                                        == get_uint32(&b2) - loadadr2) {\
                                /* do relocation */                     \
                                ADD_RELTBL(addr)                        \
                                                                        \
                                put_uint32(&b1, get_uint32(&b1) - loadadr1);  \
                                DPRINTF((" v 0x%08x\t", get_uint32(&b1)));    \
                                fwrite(&b1, SIZE_32, 1, fpx);           \
                                nbuf = 0;                               \
                                addr += SIZE_32;                        \
                        } else if (b1.half[0].hostval == b2.half[0].hostval) {\
                                fwrite(&b1.half[0], SIZE_16, 1, fpx);   \
                                addr += SIZE_16;                        \
                                b1.half[0] = b1.half[1];                \
                                b2.half[0] = b2.half[1];                \
                                nbuf = 1;                               \
                        } else                                          \
                                ERRC                                    \
                }                                                       \
        }

int
aout2hux(const char *fn1, const char *fn2, u_int32_t loadadr1, u_int32_t loadadr2, const char *fnx)
{
        int status = 1;                 /* the default is "failed" */
        FILE *fpa1 = NULL, *fpa2 = NULL;
        struct exec_info inf1, inf2;
        FILE *fpx = NULL;
        struct huxhdr xhdr;
        u_int32_t textsize, datasize, paddingsize, execoff;

        /* for relocation */
        be_uint32_t b1, b2;
        int nbuf;
        u_int32_t addr;

        /* for relocation table */
        size_t relsize, relallocsize;
        u_int32_t reladdr;
        char *reltbl = NULL;


        /*
         * check load addresses
         */
        if (loadadr1 == loadadr2) {
                fprintf(stderr, "two load addresses must be different\n");
                return 1;
        }

        /*
         * open input executables and check them
         */
        if (!(fpa1 = open_exec(fn1, &inf1)) || !(fpa2 = open_exec(fn2, &inf2)))
                goto out;

        /*
         * check for consistency
         */
        if (check_2_exec_inf(&inf1, &inf2)) {
                fprintf(stderr, "files %s and %s are incompatible\n",
                                fn1, fn2);
                goto out;
        }
        /* check entry address */
        if (inf1.entry_addr - loadadr1 != inf2.entry_addr - loadadr2) {
                fprintf(stderr, "address of %s or %s may be incorrect\n",
                                fn1, fn2);
                goto out;
        }

        /*
         * get information of the executables
         */
        textsize = inf1.text_size;
        paddingsize = inf1.text_pad;
        datasize = inf1.data_size;
        execoff = inf1.entry_addr - loadadr1;

        DPRINTF(("text: %u, data: %u, pad: %u, bss: %u, exec: %u\n",
                textsize, datasize, paddingsize, inf1.bss_size, execoff));

        if (textsize & 1) {
                fprintf(stderr, "text size is not even\n");
                goto out;
        }
        if (datasize & 1) {
                fprintf(stderr, "data size is not even\n");
                goto out;
        }
        if (execoff >= textsize &&
            (execoff < textsize + paddingsize ||
             execoff >= textsize + paddingsize + datasize)) {
                fprintf(stderr, "exec addr is not in text or data segment\n");
                goto out;
        }

        /*
         * prepare for .x header
         */
        memset((void *) &xhdr, 0, sizeof xhdr);
        put_uint16(&xhdr.x_magic, HUXMAGIC);
        put_uint32(&xhdr.x_entry, execoff);
        put_uint32(&xhdr.x_text, textsize + paddingsize);
        put_uint32(&xhdr.x_data, inf1.data_size);
        put_uint32(&xhdr.x_bss, inf1.bss_size);

        /*
         * create output file
         */
        if (!(fpx = fopen(fnx, "w")) ||
            fseek(fpx, (foff_t) sizeof xhdr, SEEK_SET)) { /* skip header */
                perror(fnx);
                goto out;
        }

        addr = 0;
        nbuf = 0;

        relsize = relallocsize = 0;
        reladdr = 0;

        /*
         * text segment
         */
        if (fseek(fpa1, inf1.text_off, SEEK_SET)) {
                perror(fn1);
                goto out;
        }
        if (fseek(fpa2, inf2.text_off, SEEK_SET)) {
                perror(fn2);
                goto out;
        }
        CREATE_RELOCATION(textsize)

        /*
         * page boundary
         */
        addr += paddingsize;
        while (paddingsize--)
                putc('\0', fpx);

        /*
         * data segment
         */
        if (fseek(fpa1, inf1.data_off, SEEK_SET)) {
                perror(fn1);
                goto out;
        }
        if (fseek(fpa2, inf2.data_off, SEEK_SET)) {
                perror(fn2);
                goto out;
        }
        CREATE_RELOCATION(datasize)

        /*
         * error check of the above
         */
        if (ferror(fpx)) {
                fprintf(stderr, "%s: write failure\n", fnx);
                goto out;
        }

        /*
         * write relocation table
         */
        if (relsize > 0) {
                DPRINTF(("\n"));
                if (fwrite(reltbl, 1, relsize, fpx) != relsize) {
                        perror(fnx);
                        goto out;
                }
        }

        /*
         * write .x header at the top of the output file
         */
        put_uint32(&xhdr.x_rsize, relsize);
        if (fseek(fpx, (foff_t) 0, SEEK_SET) ||
            fwrite(&xhdr, sizeof xhdr, 1, fpx) != 1) {
                perror(fnx);
                goto out;
        }

        status = 0;     /* all OK */

out:    /*
         * cleanup
         */
        if (fpa1)
                fclose(fpa1);
        if (fpa2)
                fclose(fpa2);
        if (fpx) {
                if (fclose(fpx) && status == 0) {
                        /* Alas, final flush failed! */
                        perror(fnx);
                        status = 1;
                }
                if (status)
                        remove(fnx);
        }
        if (reltbl)
                free(reltbl);

        return status;
}

#ifndef NO_BIST
void bist(void);

/*
 * built-in self test
 */
void
bist(void)
{
        be_uint16_t be16;
        be_uint32_t be32;
        be_uint32_t be32x2[2];

        be16.val[0] = 0x12; be16.val[1] = 0x34;
        be32.val[0] = 0xfe; be32.val[1] = 0xdc;
        be32.val[2] = 0xba; be32.val[3] = 0x98;

        put_uint16(&be32x2[0].half[1], 0x4567);
        put_uint32(&be32x2[1], 0xa9876543);

        if (sizeof(u_int8_t) != 1 || sizeof(u_int16_t) != 2 ||
            sizeof(u_int32_t) != 4 ||
            SIZE_16 != 2 || SIZE_32 != 4 || sizeof be32x2 != 8 ||
            sizeof(struct relinf_s) != 2 || sizeof(struct relinf_l) != 6 ||
            SIZE_ELF68K_HDR != 52 || SIZE_ELF68K_SHDR != 40 ||
            SIZE_ELF68K_PHDR != 32 ||
            get_uint16(&be16) != 0x1234 || get_uint32(&be32) != 0xfedcba98 ||
            get_uint16(&be32x2[0].half[1]) != 0x4567 ||
            get_uint32(&be32x2[1]) != 0xa9876543) {
                fprintf(stderr, "BIST failed\n");
                exit(1);
        }
}
#endif

int
gethex(u_int32_t *pval, const char *str)
{
        const unsigned char *p = (const unsigned char *) str;
        u_int32_t val;
        int over;

        /* skip leading "0x" if exists */
        if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
                p += 2;

        if (!*p)
                goto bad;

        for (val = 0, over = 0; *p; p++) {
                int digit;

                switch (*p) {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                        digit = *p - '0';
                        break;
                case 'a': case 'A':     digit = 10; break;
                case 'b': case 'B':     digit = 11; break;
                case 'c': case 'C':     digit = 12; break;
                case 'd': case 'D':     digit = 13; break;
                case 'e': case 'E':     digit = 14; break;
                case 'f': case 'F':     digit = 15; break;
                default:
                        goto bad;
                }
                if (val >= 0x10000000)
                        over = 1;
                val = (val << 4) | digit;
        }

        if (over)
                fprintf(stderr, "warning: %s: constant overflow\n", str);

        *pval = val;

        DPRINTF(("gethex: %s -> 0x%x\n", str, val));

        return 0;

bad:
        fprintf(stderr, "%s: not a hexadecimal number\n", str);
        return 1;
}

void
usage(const char *name)
{

        fprintf(stderr, "\
usage: %s [ -o output.x ] a.out1 loadaddr1 a.out2 loadaddr2\n\n\
The input files must be static OMAGIC/NMAGIC m68k a.out executables\n\
or m68k ELF executables.\n\
Two executables must have different loading addresses.\n\
Each of the load address must be a hexadecimal number.\n\
The default output filename is \"%s\".\n" ,name, DEFAULT_OUTPUT_FILE);

        exit(1);
}

int
main(int argc, char *argv[])
{
        const char *outfile = DEFAULT_OUTPUT_FILE;
        u_int32_t adr1, adr2;

#ifndef NO_BIST
        bist();
#endif

        if (argc > 2 && argv[1][0] == '-' && argv[1][1] == 'o' && !argv[1][2]) {
                outfile = argv[2];
                argv += 2;
                argc -= 2;
        }

        if (argc != 5)
                usage(argv[0]);

        if (gethex(&adr1, argv[2]) || gethex(&adr2, argv[4]))
                usage(argv[0]);

        return aout2hux(argv[1], argv[3], adr1, adr2, outfile);
}