580 lines
13 KiB
C
580 lines
13 KiB
C
/*
|
|
* aout2hux - convert a.out executable to Human68k .x format
|
|
*
|
|
* Read two a.out format executables with different load addresses
|
|
* and generate Human68k .x format executable.
|
|
*
|
|
* written by Yasha (ITOH Yasufumi)
|
|
* public domain
|
|
*
|
|
* usage:
|
|
* aout2hux [ -o output.x ] a.out1 loadaddr1 a.out2 loadaddr2
|
|
*
|
|
* The input a.out files must be static OMAGIC/NMAGIC m68k executables.
|
|
* Two a.out files 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,-T,0 -o aout1 *.o
|
|
* % cc -N -static -Wl,-T,10203040 -o aout2 *.o
|
|
* % aout2hux -o foo.x aout1 0 aout2 10203040
|
|
*
|
|
* $NetBSD: aout2hux.c,v 1.1 1998/09/01 19:51:08 itohy 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"
|
|
|
|
#ifndef DEFAULT_OUTPUT_FILE
|
|
# define DEFAULT_OUTPUT_FILE "out.x"
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
# define DPRINTF(x) printf x
|
|
#else
|
|
# define DPRINTF(x)
|
|
#endif
|
|
|
|
unsigned get_uint16 PROTO((be_uint16_t *be));
|
|
u_int32_t get_uint32 PROTO((be_uint32_t *be));
|
|
void put_uint16 PROTO((be_uint16_t *be, unsigned v));
|
|
void put_uint32 PROTO((be_uint32_t *be, u_int32_t v));
|
|
void *do_realloc PROTO((void *p, size_t s));
|
|
|
|
FILE *open_aout PROTO((const char *fn, struct aout_m68k *hdr));
|
|
int check_2_aout_hdrs PROTO((struct aout_m68k *h1, struct aout_m68k *h2));
|
|
int aout2hux PROTO((const char *fn1, const char *fn2,
|
|
u_int32_t loadadr1, u_int32_t loadadr2, const char *fnx));
|
|
int gethex PROTO((u_int32_t *pval, const char *str));
|
|
void usage PROTO((const char *name));
|
|
int main PROTO((int argc, char *argv[]));
|
|
|
|
#if !defined(bzero) && defined(__SVR4)
|
|
# define bzero(d, n) memset((d), 0, (n))
|
|
#endif
|
|
|
|
/*
|
|
* read/write big-endian integer
|
|
*/
|
|
|
|
unsigned
|
|
get_uint16(be)
|
|
be_uint16_t *be;
|
|
{
|
|
|
|
return be->val[0] << 8 | be->val[1];
|
|
}
|
|
|
|
u_int32_t
|
|
get_uint32(be)
|
|
be_uint32_t *be;
|
|
{
|
|
|
|
return be->val[0]<<24 | be->val[1]<<16 | be->val[2]<<8 | be->val[3];
|
|
}
|
|
|
|
void
|
|
put_uint16(be, v)
|
|
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, v)
|
|
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(p, s)
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* open an a.out and check the header
|
|
*/
|
|
FILE *
|
|
open_aout(fn, hdr)
|
|
const char *fn;
|
|
struct aout_m68k *hdr;
|
|
{
|
|
FILE *fp;
|
|
int i;
|
|
|
|
if (!(fp = fopen(fn, "r"))) {
|
|
perror(fn);
|
|
return (FILE *) NULL;
|
|
}
|
|
if (fread(hdr, 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(hdr)) != AOUT_OMAGIC && i != AOUT_NMAGIC) {
|
|
fprintf(stderr, "%s: not a OMAGIC or NMAGIC a.out\n", fn);
|
|
goto out;
|
|
}
|
|
|
|
if ((i = AOUT_GET_MID(hdr)) != AOUT_MID_M68K && i != AOUT_MID_M68K4K) {
|
|
fprintf(stderr, "%s: wrong architecture (mid %d)\n", fn, i);
|
|
goto out;
|
|
}
|
|
|
|
/* 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);
|
|
goto out;
|
|
}
|
|
|
|
if (AOUT_GET_FLAGS(hdr) & (AOUT_FLAG_PIC | AOUT_FLAG_DYNAMIC)) {
|
|
fprintf(stderr, "%s: PIC and DYNAMIC are not supported\n", fn);
|
|
goto out;
|
|
}
|
|
|
|
/* OK! */
|
|
return fp;
|
|
|
|
out: fclose(fp);
|
|
return (FILE *) NULL;
|
|
}
|
|
|
|
/*
|
|
* look at two a.out headers and check if they are compatible
|
|
*/
|
|
int
|
|
check_2_aout_hdrs(h1, h2)
|
|
struct aout_m68k *h1, *h2;
|
|
{
|
|
|
|
if (/* compare magic */
|
|
h1->a_magic.hostval != h2->a_magic.hostval ||
|
|
/* compare section size */
|
|
h1->a_text.hostval != h2->a_text.hostval ||
|
|
h1->a_data.hostval != h2->a_data.hostval ||
|
|
h1->a_bss.hostval != h2->a_bss.hostval)
|
|
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 a.out files 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(fn1, fn2, loadadr1, loadadr2, fnx)
|
|
const char *fn1, *fn2, *fnx;
|
|
u_int32_t loadadr1, loadadr2;
|
|
{
|
|
int status = 1; /* the default is "failed" */
|
|
FILE *fpa1 = NULL, *fpa2 = NULL;
|
|
struct aout_m68k hdr1, hdr2;
|
|
FILE *fpx = NULL;
|
|
struct huxhdr xhdr;
|
|
u_int32_t textsize, datasize, pagesize, 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 a.out files and check the headers
|
|
*/
|
|
if (!(fpa1 = open_aout(fn1, &hdr1)) || !(fpa2 = open_aout(fn2, &hdr2)))
|
|
goto out;
|
|
|
|
/*
|
|
* check for consistency
|
|
*/
|
|
if (check_2_aout_hdrs(&hdr1, &hdr2)) {
|
|
fprintf(stderr, "files %s and %s are incompatible\n",
|
|
fn1, fn2);
|
|
goto out;
|
|
}
|
|
/* check entry address */
|
|
if (get_uint32(&hdr1.a_entry) - loadadr1 !=
|
|
get_uint32(&hdr2.a_entry) - loadadr2) {
|
|
fprintf(stderr, "address of %s or %s may be incorrect\n",
|
|
fn1, fn2);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* get information from a.out header
|
|
*/
|
|
textsize = get_uint32(&hdr1.a_text);
|
|
pagesize = AOUT_PAGESIZE(&hdr1);
|
|
paddingsize = ((textsize + pagesize - 1) & ~(pagesize - 1)) - textsize;
|
|
datasize = get_uint32(&hdr1.a_data);
|
|
execoff = get_uint32(&hdr1.a_entry) - loadadr1;
|
|
|
|
DPRINTF(("text: %u, data: %u, page: %u, pad: %u, bss: %u, exec: %u\n",
|
|
textsize, datasize, pagesize, paddingsize,
|
|
get_uint32(&hdr1.a_bss), 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
|
|
*/
|
|
bzero((void *) &xhdr, sizeof xhdr);
|
|
put_uint16(&xhdr.x_magic, HUXMAGIC);
|
|
put_uint32(&xhdr.x_entry, execoff);
|
|
put_uint32(&xhdr.x_text, textsize + paddingsize);
|
|
xhdr.x_data.hostval = hdr1.a_data.hostval;
|
|
xhdr.x_bss.hostval = hdr1.a_bss.hostval;
|
|
|
|
/*
|
|
* create output file
|
|
*/
|
|
if (!(fpx = fopen(fnx, "w")) ||
|
|
fseek(fpx, (off_t) sizeof xhdr, SEEK_SET)) { /* skip header */
|
|
perror(fnx);
|
|
goto out;
|
|
}
|
|
|
|
addr = 0;
|
|
nbuf = 0;
|
|
|
|
relsize = relallocsize = 0;
|
|
reladdr = 0;
|
|
|
|
/*
|
|
* text segment
|
|
*/
|
|
CREATE_RELOCATION(textsize)
|
|
|
|
/*
|
|
* page boundary
|
|
*/
|
|
addr += paddingsize;
|
|
while (paddingsize--)
|
|
putc('\0', fpx);
|
|
|
|
/*
|
|
* data segment
|
|
*/
|
|
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, (off_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 PROTO((void));
|
|
|
|
/*
|
|
* built-in self test
|
|
*/
|
|
void
|
|
bist()
|
|
{
|
|
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 ||
|
|
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(pval, str)
|
|
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)
|
|
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(name)
|
|
const char *name;
|
|
{
|
|
|
|
fprintf(stderr, "\
|
|
usage: %s [ -o output.x ] a.out1 loadaddr1 a.out2 loadaddr2\n\n\
|
|
The input a.out files must be static OMAGIC/NMAGIC m68k executable.\n\
|
|
Two a.out files 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(argc, argv)
|
|
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);
|
|
}
|