6502
/
xa65
mirror of https://github.com/fachat/xa65.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
xa65/xa/misc/ldo65.c

1451 lines
38 KiB
C
Raw Blame History

/* ldo65 -- A part of xa65 - 65xx/65816 cross-assembler and utility suite
* o65 relocatable object file linker
*
* A part of the xa65 - 65xx/65816 cross-assembler and utility suite
*
* Copyright (C) 1997-2023 André Fachat (fachat@web.de)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _MSC_VER
#include <unistd.h>
#endif
#include <sys/stat.h>
#include "version.h"
#define BUF (9*2+8) /* 16 bit header */
#define programname "ldo65"
#define progversion "v0.2.0"
#define author "Written by Andre Fachat"
#define copyright "Copyright (C) 1997-2023 Andre Fachat. Formerly ld65."
#undef DEBUG
/*
The process of linking works as follows:
1. Every file is loaded in turn via load_file()
2. Calculate new base addresses per segment
3. Merge all globals from all files into a single table, checking for duplicates
4. Resolve undefined labels, and merge remaining into global list
5. relocate all segments, create global relocation tables
6. verify undefined labels
7. write out target file
*/
/* o65 file format mode bits */
#define FM_OBJ 0x1000
#define FM_SIZE 0x2000
#define FM_RELOC 0x4000
#define FM_CPU 0x8000
#define FM_CPU2 0x00f0
#define FM_CPU2_6502 0x0000
#define FM_CPU2_65C02 0x0010
#define FM_CPU2_65SC02 0x0020
#define FM_CPU2_65CE02 0x0030
#define FM_CPU2_NMOS 0x0040
#define FM_CPU2_65816E 0x0050
typedef struct {
char *name;
int len;
int newidx; /* index in new global undef table (for reloc) */
int resolved; /* index in current global label table after resolve (-1 is not found) */
} undefs;
/* file information */
typedef struct {
char *fname; /* file name */
size_t fsize; /* length of file */
unsigned char *buf; /* file content */
int mode; /* mode value */
int align; /* align value */
int tbase; /* header: text base */
int tlen; /* text length */
int talign; /* insert to get correct alignment */
int dbase; /* data base */
int dlen; /* data length */
int dalign; /* insert to get correct alignment */
int bbase; /* bss base */
int blen; /* bss length */
int balign; /* insert to get correct alignment */
int zbase; /* zero base */
int zlen; /* zero length */
int tdiff; /* text segment relocation diff */
int ddiff; /* data segment relocation diff */
int bdiff; /* bss segment relocation diff */
int zdiff; /* zero segment relocation diff */
int tpos; /* position of text segment in file */
int dpos; /* position of data segment in file */
int upos; /* position of undef'd list in file */
int trpos; /* position of text reloc tab in file */
int drpos; /* position of data reloc tab in file */
int gpos; /* position of globals list in file */
int nundef; /* number of undefined labels */
undefs *ud; /* undefined labels list NULL if none */
} file65;
/* globally defined lables are stored in this struct */
typedef struct {
char *name;
int len; /* length of labelname */
int fl; /* 0=ok, 1=multiply defined */
int val; /* address value */
int seg; /* segment */
file65 *file; /* in which file is it? */
} glob;
file65 *load_file(char *fname);
int read_options(unsigned char *f);
int read_undef(unsigned char *f, file65 *fp);
int write_undef(FILE *f, file65 *fp);
int check_undef(file65 *fp, char *defined[], int ndefined);
int len_reloc_seg(unsigned char *buf, int ri);
int reloc_seg(unsigned char *buf, int pos, int addr, int rdiff, int ri, unsigned char *obuf, int *lastaddrp, int *rop, file65 *fp);
unsigned char *reloc_globals(unsigned char *, file65 *fp);
int read_globals(file65 *file);
int write_options(FILE *fp, file65 *file);
int write_reloc(file65 *fp[], int nfp, FILE *f);
int write_globals(FILE *fp);
int write_nglobals(FILE *fp, char **globdef, int nglobal);
int find_global(unsigned char *name);
int resolve_undef(file65 *file, int *remains);
file65 file;
unsigned char cmp[] = { 1, 0, 'o', '6', '5' };
unsigned char hdr[26] = { 1, 0, 'o', '6', '5', 0 };
const char *cpunames[16] = {
"documented 6502",
"65C02 (CMOS with BBR/BBS/RMB/SMB)",
"65SC02 (CMOS without BBR/BBS/RMB/SMB)",
"65CE02",
"6502 with undocumented opcodes",
"65816 in 6502 emulation mode",
"n/a", "n/a",
"6809?", "n/a", // 1000 -
"Z80?", "n/a", "n/a", // 1010 -
"8086?", // 1101 -
"80286?", // 1110 -
"n/a"
};
int verbose = 0;
void usage(FILE *fp)
{
fprintf(fp,
"Usage: %s [OPTION]... [FILE]...\n"
"Linker for o65 object files\n"
"\n"
" -b? addr relocates segment `?' (i.e. `t' for text segment,\n"
" `d' for data, `b' for bss, and `z' for zeropage) to the new\n"
" address `addr'\n"
" -o file uses `file' as output file. Default is `a.o65'\n"
" -G suppress writing of globals\n"
" -U accept any undef'd labels after linking\n"
" -L<name> accept specific given undef'd labels after linking\n"
" -g<name> only export the globals defined with (multiple) -g options\n"
" -v verbose output\n"
" --version output version information and exit\n"
" --help display this help and exit\n",
programname);
}
int main(int argc, char *argv[]) {
int noglob=0;
int undefok=0;
int i = 1;
// default output segment addresses, overwritten by cmdline params
int tbase = 0x0400, dbase = 0x1000, bbase = 0x4000, zbase = 0x0002;
int ttlen, tdlen, tblen, tzlen, routtlen, routdlen, tro, dro;
int lasttaddr, lastdaddr;
unsigned char *treloc, *dreloc;
char *outfile = "a.o65";
int j, jm;
file65 *file, **fp = NULL;
FILE *fd;
int nundef = 0; // counter/index in list of remaining undef'd labels
int maxalign; // maximum alignment over all files
char *alignfname; // (first) file that requires that alignment
int trgmode = 0; // mode for the output file
char alignbuf[256]; // to efficiently write align fillers
char *arg;
char **defined = NULL;
int ndefined = 0;
int ndefalloc = 0;
// globals allowed by -g
char **globdef = NULL;
int nglobal = 0;
int ngloballoc = 0;
if (argc <= 1) {
usage(stderr);
exit(1);
}
if (strstr(argv[1], "--help") || strstr(argv[1], "-?") || strstr(argv[1], "-h")) {
usage(stdout);
exit(0);
}
if (strstr(argv[1], "--version")) {
version(programname, progversion, author, copyright);
exit(0);
}
/* read options */
while(i<argc && argv[i][0]=='-') {
arg = NULL;
/* process options */
switch(argv[i][1]) {
case 'v':
j=1;
while (argv[i][j]=='v') {
verbose++;
j++;
}
break;
case 'G':
noglob=1;
break;
case 'U':
undefok=1;
break;
case 'o':
if(argv[i][2]) outfile=argv[i]+2;
else outfile=argv[++i];
break;
case 'g':
noglob=1;
if(argv[i][2]) arg=argv[i]+2;
else arg=argv[++i];
if (ngloballoc == 0) {
ngloballoc = 20;
globdef = malloc(ngloballoc * sizeof(char*));
} else
if (nglobal >= ngloballoc) {
ngloballoc *= 2;
globdef = realloc(globdef, ngloballoc * sizeof(char*));
}
globdef[nglobal++] = arg;
break;
case 'L':
if(argv[i][2]) arg=argv[i]+2;
else arg=argv[++i];
if (ndefalloc == 0) {
ndefalloc = 20;
defined = malloc(ndefalloc * sizeof(char*));
} else
if (ndefined >= ndefalloc) {
ndefalloc *= 2;
defined = realloc(defined, ndefalloc * sizeof(char*));
}
defined[ndefined++] = arg;
break;
case 'b':
switch(argv[i][2]) {
case 't':
if(argv[i][3]) tbase = atoi(argv[i]+3);
else tbase = atoi(argv[++i]);
break;
case 'd':
if(argv[i][3]) dbase = atoi(argv[i]+3);
else dbase = atoi(argv[++i]);
break;
case 'b':
if(argv[i][3]) bbase = atoi(argv[i]+3);
else bbase = atoi(argv[++i]);
break;
case 'z':
if(argv[i][3]) zbase = atoi(argv[i]+3);
else zbase = atoi(argv[++i]);
break;
default:
printf("Unknown segment type '%c' - ignored!\n", argv[i][2]);
break;
}
break;
default:
fprintf(stderr,"file65: %s unknown option, use '-h for help\n",argv[i]);
break;
}
i++;
}
// -------------------------------------------------------------------------
// step 1 - load files
/* each file is loaded first */
j=0; jm=0; fp=NULL;
while(i<argc) {
file65 *f;
f = load_file(argv[i]);
if(f) {
if(j>=jm) fp=realloc(fp, (jm=(jm?jm*2:10))*sizeof(file65*));
if(!fp) { fprintf(stderr,"Oops, no more memory\n"); exit(1); }
fp[j++] = f;
} else {
exit(1);
}
i++;
}
// -------------------------------------------------------------------------
// compute target file mode value
// compute target mode and max align value
trgmode = 0;
maxalign = 0;
alignfname = "<none>";
{
int er = 0;
int trgcpu = 0;
if (verbose) {
printf("Starting CPU type calculation with mode %s (%d) ...\n",
cpunames[trgcpu], trgcpu);
}
for(i=0;i<j;i++) {
int fcpu;
file = fp[i];
if (file->align > maxalign) {
maxalign = file->align;
alignfname = file->fname;
}
if (file->mode & 0x8000) {
// 65816
trgmode |= 0x8000;
if (trgcpu == 4) {
fprintf(stderr, "Error: file '%s' in 65816 CPU mode is incompatible with previous NMOS undocumented opcodes CPU mode\n",
file->fname);
er = 1;
}
}
if (file->mode & 0x0200) {
// zero out bss
trgmode |= 0x0200;
}
// CPU bits
fcpu = (file->mode & FM_CPU2) >> 4;
if (verbose) {
printf("Matching file %s with CPU %s (%d) to target %s (%d) ...\n",
file->fname, cpunames[fcpu], fcpu, cpunames[trgcpu], trgcpu);
}
switch (fcpu) {
case 0x0: // bare minimum documented 6502 is just fine
break;
case 0x1: // 65C02 - CMOS with BBR/BBS/RMB/SMB, incompatible with 65816
case 0x3: // 65CE02 - CMOS with BBR/... and add'l opcodes, incompatible w/ 65816
if (trgmode & 0x8000 || trgcpu == 5) {
fprintf(stderr, "Error: file '%s' in CPU mode %d (%s) "
"is incompatible with previous 65816 CPU mode\n",
file->fname, fcpu, cpunames[fcpu]);
er = 1;
}
// fall-through
case 0x2: // 65SC02 - CMOS without BBR/BBS/RMB/SMB, compatible with 65816
if (trgcpu == 4) {
// is incompatible with nmos6502 with undocumented opcodes
fprintf(stderr, "Error: file '%s' in CPU mode %d (%s) "
"is incompatible with previous files with mode %d (%s)\n",
file->fname, fcpu, cpunames[fcpu], trgcpu, cpunames[trgcpu]);
er = 1;
}
break;
case 0x5: // 65816 in 6502 emulation mode
if (trgcpu == 1 || trgcpu == 3) {
// 65C02 and 65CE02 are incompatible with nmos6502 with undocumented opcodes
fprintf(stderr, "Error: file '%s' in CPU mode %d (%s) is "
"incompatible with previous files with mode %d (%s)\n",
file->fname, fcpu, cpunames[fcpu], trgcpu, cpunames[trgcpu]);
er = 1;
}
break;
case 0x4: // NMOS 6502 with undocumented opcodes
if (trgcpu == 1 || trgcpu == 2 || trgcpu == 3 || trgcpu == 5) {
// is incompatible with nmos6502 with undocumented opcodes
fprintf(stderr, "Error: file '%s' in CPU mode %d (%s) is "
"incompatible with previous files with mode %d (%s)\n",
file->fname, fcpu, cpunames[fcpu], trgcpu, cpunames[trgcpu]);
er = 1;
}
if (trgmode & 0x8000) {
fprintf(stderr, "Error: file '%s' in mode %d (%s) is incompatible with previous 65816 CPU mode\n",
file->fname, 4, cpunames[4]);
er = 1;
}
break;
default:
if (fcpu > 5) {
printf("Warning: unknown CPU mode %d (%s) detected in file %s\n",
fcpu, cpunames[fcpu], file->fname);
}
break;
}
// setting the new mode
switch (fcpu) {
case 0x0: // compatible with everything, no change
break;
case 0x3: // 65CE02 -> supersedes 6502, 65SC02, and 65C02
if (trgcpu == 1) {
// 65C02
trgcpu = fcpu;
}
// fall-through
case 0x5: // 65816 in 6502 emu mode, supersedes documented NMOS and 65SC02
case 0x1: // CMOS w/ BBR.. -> supersedes documented NMOS and 65SC02
if (trgcpu == 2) {
// 65SC02
trgcpu = fcpu;
}
// fall-through
case 0x2: // 65SC02 -> supersedes only NMOS 6502
case 0x4: // NMOS 6502 w/ undocumented opcodes
default:
if (trgcpu == 0) {
// NMOS 6502
trgcpu = fcpu;
}
break;
}
if (verbose && !er) {
printf("... to new target %s (%d)\n",
cpunames[trgcpu], trgcpu);
}
}
if (er) {
exit(1);
}
trgmode |= trgcpu << 4;
}
if (maxalign) {
printf("Info: Alignment at %d-boundaries required\n", maxalign + 1);
}
switch (maxalign) {
case 0:
break;
case 1:
trgmode |= 1;
break;
case 3:
trgmode |= 2;
break;
case 255:
trgmode |= 3;
break;
}
// -------------------------------------------------------------------------
// step 2 - calculate new segment base addresses per file, by
// concatenating the segments per type
/* now [tdbz]base holds new segment base address */
/* set total length to zero */
ttlen = tdlen = tblen = tzlen = 0;
// then check start addresses
file = fp[0];
if (file->align != 0) {
int er = 0;
if (tbase & file->align) {
fprintf(stderr, "Error: text segment start address ($%04x) "
"not aligned as required by first file (at %d bytes)\n",
tbase, file->align + 1);
er = 1;
}
if (dbase & file->align) {
fprintf(stderr, "Error: data segment start address ($%04x) "
"not aligned as required by first file (at %d bytes)\n",
dbase, file->align + 1);
er = 1;
}
if (bbase & file->align) {
fprintf(stderr, "Error: bss segment start address ($%04x) "
"not aligned as required (by first file at %d bytes)\n",
bbase, file->align + 1);
er = 1;
}
if (er) {
exit(1);
}
}
/* find new addresses for the files and read globals */
for(i=0;i<j;i++) {
file = fp[i];
/* compute align fillers */
file->talign = 0;
file->dalign = 0;
file->balign = 0;
// filler only needed if align not zero ...
if (file->align) {
// ... and respective segment not empty
if (file->tlen) {
//file->talign = file->align + 1 - ((tbase + ttlen) & file->align);
file->talign = ( -((tbase + ttlen) & file->align) ) & file->align;
}
if (file->dlen) {
//file->dalign = file->align + 1 - ((dbase + tdlen) & file->align);
file->dalign = ( -((dbase + tdlen) & file->align) ) & file->align;
}
if (file->blen) {
//file->balign = file->align + 1 - ((bbase + tblen) & file->align);
file->balign = ( -((bbase + tblen) & file->align) ) & file->align;
}
}
/* insert align fillers */
ttlen += file->talign;
tdlen += file->dalign;
tblen += file->balign;
/* compute relocation differences */
file->tdiff = ((tbase + ttlen) - file->tbase);
file->ddiff = ((dbase + tdlen) - file->dbase);
file->bdiff = ((bbase + tblen) - file->bbase);
file->zdiff = ((zbase + tzlen) - file->zbase);
/*
printf("tbase=%04x+len=%04x->%04x, file->tbase=%04x, f.tlen=%04x -> tdiff=%04x\n",
tbase, ttlen, (tbase + ttlen), file->tbase, file->tlen, file->tdiff);
printf("zbase=%04x+len=%04x->%04x, file->zbase=%04x, f.zlen=%04x -> zdiff=%04x\n",
zbase, tzlen, (zbase + tzlen), file->zbase, file->zlen, file->zdiff);
*/
if (verbose > 0) {
printf("Relocating file: %s [CPU %s]\n", file->fname, cpunames[((file->mode & FM_CPU2) >> 4) & 0x0f]);
printf(" text: align fill %04x, relocate from %04x to %04x (diff is %04x, length is %04x)\n",
file->talign, file->tbase, file->tbase + file->tdiff, file->tdiff, file->tlen);
printf(" data: align fill %04x, relocate from %04x to %04x (diff is %04x, length is %04x)\n",
file->dalign, file->dbase, file->dbase + file->ddiff, file->ddiff, file->dlen);
printf(" bss: align fill %04x, relocate from %04x to %04x (diff is %04x, length is %04x)\n",
file->balign, file->bbase, file->bbase + file->bdiff, file->bdiff, file->blen);
printf(" zero: relocate from %02x to %02x (diff is %02x, length is %02x)\n",
file->zbase, file->zbase + file->zdiff, file->zdiff, file->zlen);
}
/* update globals (for result file) */
ttlen += file->tlen;
tdlen += file->dlen;
tblen += file->blen;
tzlen += file->zlen;
}
// validate various situations.
if (maxalign != 0) {
int er = 0;
if (tbase & maxalign) {
fprintf(stderr, "Error: text segment start address ($%04x) "
"not aligned as first required by file %s (at %d bytes)\n",
tbase, alignfname, maxalign + 1);
er = 1;
}
if (dbase & maxalign) {
fprintf(stderr, "Error: data segment start address ($%04x) "
"not aligned as first required by file %s (at %d bytes)\n",
dbase, alignfname, maxalign + 1);
er = 1;
}
if (bbase & maxalign) {
fprintf(stderr, "Error: bss segment start address ($%04x) "
"not aligned as first required (by file %s (at %d bytes)\n",
bbase, alignfname, maxalign + 1);
er = 1;
}
if (er) {
exit(1);
}
}
// validate various situations.
{
int er = 0;
if (tbase + ttlen > 0x10000) {
fprintf(stderr,
"Overflow in text segment: end at %06x behind 64k limit\n",
tbase + ttlen);
er = 1;
}
if (dbase + tdlen > 0x10000) {
fprintf(stderr,
"Overflow in data segment: end at %06x behind 64k limit\n",
dbase + tdlen);
er = 1;
}
if (bbase + tblen > 0x10000) {
fprintf(stderr,
"Overflow in bss segment: end at %06x behind 64k limit\n",
bbase + tblen);
er = 1;
}
if (zbase + tzlen > 0x100) {
fprintf(stderr,
"Overflow in zero segment: end at %04x behind 256 byte limit\n",
zbase + tzlen);
er = 1;
}
if (er) {
exit (1);
}
}
// -------------------------------------------------------------------------
// step 3 - merge globals from all files into single table
//
for(i=0;i<j;i++) {
file = fp[i];
// merge globals into single table
read_globals(file);
}
// -------------------------------------------------------------------------
// step 4 - for each file, resolve undefined lables, storing replacement info
// in the ud label table; merge remaining undefined labels into global
// undef list
for(i=0;i<j;i++) {
file = fp[i];
// merge globals into single table
resolve_undef(file, &nundef);
}
// -------------------------------------------------------------------------
// step 5 - relocate each text and data segment, replacing the resolved
// undefined labels and re-numbering the remaining ones
// reloc globals first, so reloc_seg has current info for resolved undef'd labels
routtlen = 1; // end-of-table byte
routdlen = 1; // end-of-table byte
for(i=0;i<j;i++) {
file = fp[i];
routtlen += (file->drpos - file->trpos);
routdlen += (file->gpos - file->drpos);
reloc_globals(file->buf+file->gpos, file);
}
// prep global reloc tables
treloc = malloc(routtlen);
dreloc = malloc(routdlen);
#ifdef DEBUG
printf("prep'd text reloc table at %p (%d bytes)\n", treloc, routtlen);
printf("prep'd data reloc table at %p (%d bytes)\n", dreloc, routdlen);
#endif
tro = 0;
dro = 0;
// segment position of last relocation entry to compute offsets across files
lasttaddr = tbase - 1;
lastdaddr = dbase - 1;
for(i=0;i<j;i++) {
file = fp[i];
reloc_seg(file->buf, // input buffer
file->tpos, // position of segment in input buffer
file->tbase, // segment base address
file->tdiff, // reloc difference
file->trpos, // position of reloc table in input
treloc, // output reloc buffer
&lasttaddr, // last relocated target address
&tro, // pointer in output reloc bufer
file);
reloc_seg(file->buf,
file->dpos,
file->dbase,
file->ddiff,
file->drpos,
dreloc,
&lastdaddr,
&dro,
file);
// change file information to relocated values
file->tbase += file->tdiff;
file->dbase += file->ddiff;
file->bbase += file->bdiff;
file->zbase += file->zdiff;
}
// finalize global reloc table
treloc[tro++] = 0;
dreloc[dro++] = 0;
// -------------------------------------------------------------------------
// step 6 - validate undefined labels
//
if (nundef > 0 && !undefok) {
int er = 0;
// we have undefined labels, but it's not ok (no -U)
// check -L defined labels
for(i=0;i<j;i++) {
if (check_undef(fp[i], defined, ndefined)) {
er = -1;
}
}
if (er) {
fprintf(stderr, "%d Undefined labels remain - aborting\n", nundef);
exit(1);
}
}
// -------------------------------------------------------------------------
// step 7 - write out the resulting o65 file
//
// prepare header
hdr[ 6] = trgmode & 255; hdr[ 7] = (trgmode>>8)& 255;
hdr[ 8] = tbase & 255; hdr[ 9] = (tbase>>8) & 255;
hdr[10] = ttlen & 255; hdr[11] = (ttlen >>8)& 255;
hdr[12] = dbase & 255; hdr[13] = (dbase>>8) & 255;
hdr[14] = tdlen & 255; hdr[15] = (tdlen >>8)& 255;
hdr[16] = bbase & 255; hdr[17] = (bbase>>8) & 255;
hdr[18] = tblen & 255; hdr[19] = (tblen >>8)& 255;
hdr[20] = zbase & 255; hdr[21] = (zbase>>8) & 255;
hdr[22] = tzlen & 255; hdr[23] = (tzlen >>8)& 255;
hdr[24] = 0; hdr[25] = 0;
// open file
fd = fopen(outfile, "wb");
if(!fd) {
fprintf(stderr,"Couldn't open output file %s (%s)\n",
outfile, strerror(errno));
exit(2);
}
// write header
fwrite(hdr, 1, 26, fd);
// write options - this writes _all_ options from _all_files!
for(i=0;i<j;i++) {
write_options(fd, fp[i]);
}
fputc(0,fd);
// align filler is NOP, just in case
memset(alignbuf, 0xea, sizeof(alignbuf));
// write text segment
for(i=0;i<j;i++) {
if (fp[i]->talign) {
fwrite(alignbuf, 1, fp[i]->talign, fd);
}
fwrite(fp[i]->buf + fp[i]->tpos, 1, fp[i]->tlen, fd);
}
// write data segment
for(i=0;i<j;i++) {
if (fp[i]->dalign) {
fwrite(alignbuf, 1, fp[i]->dalign, fd);
}
fwrite(fp[i]->buf + fp[i]->dpos, 1, fp[i]->dlen, fd);
}
// write list of undefined labels
fputc(nundef & 0xff,fd);
fputc((nundef >> 8) & 0xff,fd);
if (nundef > 0) {
for(i=0;i<j;i++) {
write_undef(fd, fp[i]);
}
}
// write relocation tables
fwrite(treloc, tro, 1, fd);
fwrite(dreloc, dro, 1, fd);
// write globals
if(!noglob) {
write_globals(fd);
} else {
if (nglobal > 0) {
write_nglobals(fd, globdef, nglobal);
} else {
fputc(0,fd);
fputc(0,fd);
}
}
fclose(fd);
return 0;
}
/***************************************************************************/
int write_options(FILE *fp, file65 *file) {
return fwrite(file->buf+BUF, 1, file->tpos-BUF-1, fp);
}
int read_options(unsigned char *buf) {
int c, l=0;
c=buf[0];
while(c && c!=EOF) {
c&=255;
l+=c;
c=buf[l];
}
return ++l;
}
/***************************************************************************/
int read_undef(unsigned char *buf, file65 *file) {
int bufp; // pointer in input buffer
int startp; // pointer to start of label name
int nlabels; // number of labels in file
undefs *current = NULL;
int i;
bufp = 0;
nlabels = buf[bufp] + 256*buf[bufp+1];
bufp += 2;
file->nundef = nlabels;
if (nlabels == 0) {
file->ud = NULL;
} else {
file->ud = malloc(nlabels*sizeof(undefs));
if(!file->ud) {
fprintf(stderr,"Oops, no more memory\n");
exit(1);
}
i=0;
while(i<nlabels){
// find length of label name
startp = bufp;
while(buf[bufp++]);
// store label info
current = &file->ud[i];
current->name = (char*) buf+startp;
current->len = bufp-startp-1;
current->resolved = -1;
/*printf("read undef '%s'(%p), len=%d, ll=%d, l=%d, buf[l]=%d\n",
file->ud[i].name, file->ud[i].name, file->ud[i].len,ll,l,buf[l]);*/
i++;
}
}
return bufp;
}
int resolve_undef(file65 *file, int *remains) {
int i;
undefs *current;
int nlabels = file->nundef;
#ifdef DEBUG
printf("resolved undef file %s (%d undef'd)\n", file->fname, nlabels);
#endif
if (nlabels == 0) {
return 0;
}
current = file->ud;
for (i = 0; i < nlabels; i++) {
// store pointer to global in label info
// if NULL is returned, is not resolved
current->resolved = find_global(current->name);
#ifdef DEBUG
printf("resolved undef label %s to: resolved=%d, newidx=%d\n", current->name, current->resolved, *remains);
#endif
if (current->resolved == -1) {
// keep in global undef list
current->newidx = *remains;
*remains += 1;
}
current++;
}
return 0;
}
int write_undef(FILE *f, file65 *fp) {
int i;
for (i = 0; i < fp->nundef; i++) {
undefs *current = &fp->ud[i];
if (current->resolved == -1) {
// only write unresolved entries
fprintf(f, "%s%c", current->name, 0);
}
}
return 0;
}
int check_undef(file65 *fp, char *defined[], int ndefined) {
int er = 0;
int i, j;
for (i = 0; i < fp->nundef; i++) {
undefs *current = &fp->ud[i];
if (current->resolved == -1) {
// only check unresolved entries
int found = 0;
for (j = 0; j < ndefined; j++) {
if (defined && !strcmp(defined[j], current->name)) {
// label is found, so it's ok
found = 1;
break;
}
}
if (!found) {
fprintf(stderr, "Unresolved label '%s' from file '%s'\n",
current->name, fp->fname);
er = -1;
}
}
}
return er;
}
/***************************************************************************/
/* compute and return the length of the relocation table */
int len_reloc_seg(unsigned char *buf, int ri) {
int type, seg;
while(buf[ri]) {
if((buf[ri] & 255) == 255) {
ri++;
} else {
ri++;
type = buf[ri] & 0xe0;
seg = buf[ri] & 0x07;
/*printf("reloc entry @ rtab=%p (offset=%d), adr=%04x, type=%02x, seg=%d\n",buf+ri-1, *(buf+ri-1), adr, type, seg);*/
ri++;
switch(type) {
case 0x80:
break;
case 0x40:
ri++;
break;
case 0x20:
break;
}
if(seg==0) ri+=2;
}
}
return ++ri;
}
#define reldiff(s) (((s)==2)?fp->tdiff:(((s)==3)?fp->ddiff:(((s)==4)?fp->bdiff:(((s)==5)?fp->zdiff:0))))
unsigned char *reloc_globals(unsigned char *buf, file65 *fp) {
int n, old, new, seg;
char *name;
n = buf[0] + 256*buf[1];
buf +=2;
while(n) {
name = buf;
while(*(buf++));
seg = *buf & 0x07;
old = buf[1] + 256*buf[2];
new = old + reldiff(seg);
if (verbose > 1) {
printf("%s:%s: old=%04x, seg=%d, rel=%04x, new=%04x\n",
fp->fname, name, old, seg, reldiff(seg), new);
}
buf[1] = new & 255;
buf[2] = (new>>8) & 255;
buf +=3;
n--;
}
return buf;
}
/***************************************************************************/
file65 *load_file(char *fname) {
file65 *file;
struct stat fs;
FILE *fp;
int mode, hlen;
int align;
size_t n;
file=malloc(sizeof(file65));
if(!file) {
fprintf(stderr,"Oops, not enough memory!\n");
exit(1);
}
/*printf("load_file(%s)\n",fname);*/
file->fname=fname;
if(stat(fname, &fs) < 0) {
perror("while opening file: stat");
exit(1);
}
file->fsize=fs.st_size;
file->buf=malloc(file->fsize);
if(!file->buf) {
fprintf(stderr,"Oops, no more memory!\n");
exit(1);
}
fp = fopen(fname,"rb");
if(fp) {
n = fread(file->buf, 1, file->fsize, fp);
fclose(fp);
if((n>=file->fsize) && (!memcmp(file->buf, cmp, 5))) {
mode=file->buf[7]*256+file->buf[6];
file->mode = mode;
if(mode & 0x2000) {
fprintf(stderr,"file65: %s: 32 bit size not supported\n", fname);
free(file->buf); free(file); file=NULL;
} else
if(mode & 0x4000) {
fprintf(stderr,"file65: %s: pagewise relocation not supported\n",
fname);
free(file->buf); free(file); file=NULL;
} else {
align = mode & 3;
switch(align) {
case 0:
align = 0;
break;
case 1:
// word align
align = 1;
break;
case 2:
// long align
align = 3;
break;
case 3:
// page align
align = 255;
break;
}
file->align = align;
hlen = BUF+read_options(file->buf+BUF);
file->tbase = file->buf[ 9]*256+file->buf[ 8];
file->tlen = file->buf[11]*256+file->buf[10];
file->talign= 0;
file->dbase = file->buf[13]*256+file->buf[12];
file->dlen = file->buf[15]*256+file->buf[14];
file->dalign= 0;
file->bbase = file->buf[17]*256+file->buf[16];
file->blen = file->buf[19]*256+file->buf[18];
file->balign= 0;
file->zbase = file->buf[21]*256+file->buf[20];
file->zlen = file->buf[23]*256+file->buf[22];
file->tpos = hlen;
file->dpos = hlen + file->tlen;
file->upos = file->dpos + file->dlen;
file->trpos= file->upos + read_undef(file->buf+file->upos, file);
file->drpos= len_reloc_seg(file->buf, file->trpos);
file->gpos = len_reloc_seg(file->buf, file->drpos);
}
} else {
fprintf(stderr,"Error: %s: not an o65 file\n", fname);
return NULL;
}
} else {
fprintf(stderr,"file65: %s: %s\n", fname, strerror(errno));
return NULL;
}
return file;
}
/***************************************************************************/
// global list of all global labels
glob *gp = NULL;
// number of global labels
int g=0;
// number of globals for which memory is already allocated
int gm=0;
int write_globals(FILE *fp) {
int i;
fputc(g&255, fp);
fputc((g>>8)&255, fp);
for(i=0;i<g;i++) {
fprintf(fp,"%s%c%c%c%c",gp[i].name,0,gp[i].seg,
gp[i].val & 255, (gp[i].val>>8)&255);
}
return 0;
}
int write_nglobals(FILE *fp, char **globdef, int nglobal) {
int i, j;
int newnum = 0;
// first check which defined globals are allowed to be exported
// and clear out the other ones
for (i = 0; i < g; i++) {
for (j = 0; j < nglobal; j++) {
if (!strcmp(gp[i].name, globdef[j])) {
// found
break;
}
}
if (j >= nglobal) {
// not found
gp[i].name = NULL;
} else {
// found, so we inc the counter
newnum++;
}
}
// then check which globals from the -g list are actually used, and warn about unused ones
for (j = 0; j < nglobal; j++) {
for (i = 0; i < g; i++) {
if (gp[i].name != NULL && !strcmp(gp[i].name, globdef[j])) {
// found
break;
}
}
if (i >= g) {
// not found
fprintf(stderr,"Warning: command line allowed global '%s' is not defined!\n", globdef[j]);
}
}
// write out only defined globals
fputc(newnum&255, fp);
fputc((newnum>>8)&255, fp);
for(i=0;i<g;i++) {
if (gp[i].name != NULL) {
fprintf(fp,"%s%c%c%c%c",gp[i].name,0,gp[i].seg,
gp[i].val & 255, (gp[i].val>>8)&255);
}
}
return 0;
}
int read_globals(file65 *fp) {
int i, l, n, old, new, seg, ll;
char *name;
unsigned char *buf = fp->buf + fp->gpos;
n = buf[0] + 256*buf[1];
buf +=2;
while(n) {
/*printf("reading %s, ", buf);*/
name = (char*) buf;
l=0;
while(buf[l++]);
buf+=l;
ll=l-1;
seg = *buf;
old = buf[1] + 256*buf[2];
new = old + reldiff(seg);
/*printf("old=%04x, seg=%d, rel=%04x, new=%04x\n", old, seg, reldiff(seg), new);*/
/* multiply defined? */
for(i=0;i<g;i++) {
if(ll==gp[i].len && !strcmp(name, gp[i].name)) {
fprintf(stderr,"Warning: label '%s' multiply defined (%s and %s)\n",
name, fp->fname, gp[i].file->fname);
gp[i].fl = 1;
break;
}
}
/* not already defined */
if(i>=g) {
if(g>=gm) {
gp = realloc(gp, (gm=(gm?2*gm:40))*sizeof(glob));
if(!gp) {
fprintf(stderr,"Oops, no more memory\n");
exit(1);
}
}
if(g>=0x10000) {
fprintf(stderr,"Outch, maximum number of labels (65536) exceeded!\n");
exit(3);
}
gp[g].name = name;
gp[g].len = ll;
gp[g].seg = seg;
gp[g].val = new;
gp[g].fl = 0;
gp[g].file = fp;
#ifdef DEBUG
printf("set global label '%s' (l=%d, seg=%d, val=%04x)\n", gp[g].name,
gp[g].len, gp[g].seg, gp[g].val);
#endif
g++;
}
buf +=3;
n--;
}
return 0;
}
int find_global(unsigned char *name) {
int i;
for (i = 0; i < g; i++) {
if (!strcmp(gp[i].name, name)) {
// found
return i;
}
}
return -1;
}
// searches for a global label in a file by name.
// returns the value of a found global value
int find_file_global(unsigned char *bp, file65 *fp, int *seg) {
int i,l;
char *n;
int nl = bp[0]+256*bp[1];
l=fp->ud[nl].len;
n=fp->ud[nl].name;
/*printf("find_global(%s (len=%d))\n",n,l);*/
for(i=0;i<g;i++) {
if(gp[i].len == l && !strcmp(gp[i].name, n)) {
*seg = gp[i].seg;
bp[0] = i & 255; bp[1] = (i>>8) & 255;
/*printf("return gp[%d]=%s (len=%d), val=%04x\n",i,gp[i].name,gp[i].len,gp[i].val);*/
return gp[i].val;
}
}
fprintf(stderr,"Warning: undefined label '%s' in file %s\n",
n, fp->fname);
return 0;
}
/***************************************************************************/
#define forwardpos() \
while(addr-lastaddr>254){obuf[ro++]=255;lastaddr+=254;}obuf[ro++]=addr-lastaddr;lastaddr=addr
int reloc_seg(unsigned char *buf, int pos, int addr, int rdiff, int ri,
unsigned char *obuf, int *lastaddrp, int *rop, file65 *fp) {
int type, seg, old, new, ro, lastaddr, diff;
int base;
/*
pos = address of current position
ri = position of relocation table in *buf for reading the reloc entries
ro(p) = position of relocation table entry for writing the modified entries
*/
base = addr;
addr--;
ro = *rop;
lastaddr = *lastaddrp - rdiff;
#ifdef DEBUG
printf("reloc_seg: %s: addr=%04x, pos=%04x, lastaddr=%04x (%04x - %04x)\n",
fp->fname, addr, pos, lastaddr, *lastaddrp, rdiff);
#endif
while(buf[ri]) {
// still reloc entry
if((buf[ri] & 255) == 255) {
addr += 254;
ri++;
} else {
addr += buf[ri] & 255;
type = buf[ri+1] & 0xe0;
seg = buf[ri+1] & 0x07;
#ifdef DEBUG
printf("reloc entry @ ri=%04x, pos=%04x, type=%02x, seg=%d, offset=%d, reldiff=%04x\n",
ri, pos, type, seg, addr-lastaddr, reldiff(seg));
#endif
switch(type) {
case 0x80:
// address (word) relocation
old = buf[addr-base+pos] + 256*buf[addr-base+pos+1];
if(seg) {
diff = reldiff(seg);
ri++; // skip position byte
forwardpos(); // re-write position offset
obuf[ro++] = buf[ri++]; // relocation byte ($8x for segments text, data, bss, zp)
} else {
// undefined
undefs *u = &fp->ud[buf[ri+2]+256*buf[ri+3]];
#ifdef DEBUG
printf("found undef'd label %s, resolved=%d, newidx=%d, (ri=%d, ro=%d)\n", u->name, u->resolved, u->newidx, ri, ro);
#endif
if (u->resolved == -1) {
// not resolved
diff = 0;
ri++; // skip position byte
forwardpos(); // re-write position offset
obuf[ro++] = buf[ri++]; // relocation byte ($8x for segments text, data, bss, zp)
obuf[ro++] = u->newidx & 0xff; // output label number lo/hi
obuf[ro++] = (u->newidx >> 8) & 0xff;
ri += 2; // acount for label number in input
} else {
// resolved from global list
glob *gl = &gp[u->resolved];
diff = gl->val;
seg = gl->seg;
if (seg != 1) {
// not an absolute value
forwardpos(); // re-write position offset
obuf[ro++] = 0x80 | seg;// relocation byte for new segment
} else {
// absolute value - do not write a new relocation entry
}
ri += 4; // account for position, segment byte, label number in reloc table
}
}
new = old + diff;
/*printf("old=%04x, new=%04x\n",old,new);*/
buf[addr-base+pos] = new & 255;
buf[addr-base+pos+1] = (new>>8)&255;
break;
case 0x40:
// high byte relocation
if(seg) {
old = buf[addr-base+pos]*256 + buf[ri+2];
diff = reldiff(seg);
forwardpos(); // re-write position offset
obuf[ro++] = buf[ri+1]; // relocation byte ($4x for segments text, data, bss, zp)
obuf[ro++] = (old + diff) & 255;
ri += 3; // skip position, segment, and low byte
} else {
undefs *u;
old = buf[addr-base+pos]*256 + buf[ri+4];
// undefined
u = &fp->ud[buf[ri+2]+256*buf[ri+3]];
if (u->resolved == -1) {
// not resolved
diff = 0;
forwardpos(); // re-write position offset
obuf[ro++] = buf[ri+1]; // relocation byte ($8x for segments text, data, bss, zp)
obuf[ro++] = u->newidx & 0xff; // output label number lo/hi
obuf[ro++] = (u->newidx >> 8) & 0xff;
obuf[ro++] = buf[ri+4]; // low byte for relocation
} else {
// resolved from global list
glob *gl = &gp[u->resolved];
diff = gl->val;
seg = gl->seg;
if (seg != 1) {
// not an absolute value
forwardpos(); // re-write position offset
obuf[ro++] = 0x40 | seg; // relocation byte for new segment
obuf[ro++] = (old + diff) & 0xff; // low byte for relocation
} else {
// absolute value - do not write a new relocation entry
}
}
ri += 5; // account for position, segment byte, label number in reloc table, low byte
}
new = old + diff;
buf[addr-base+pos] = (new>>8)&255;
break;
case 0x20:
// low byte relocation
old = buf[addr-base+pos];
diff = 0;
if(seg) {
diff = reldiff(seg);
forwardpos();
obuf[ro++] = buf[ri+1]; // relocation byte ($4x for segments text, data, bss, zp)
ri += 2; // account for position & segment
} else {
// undefined
undefs *u = &fp->ud[buf[ri+2]+256*buf[ri+3]];
if (u->resolved == -1) {
// not resolved
diff = 0;
forwardpos(); // re-write position offset
obuf[ro++] = buf[ri+1]; // relocation byte ($8x for segments text, data, bss, zp)
obuf[ro++] = u->newidx & 0xff; // output label number lo/hi
obuf[ro++] = (u->newidx >> 8) & 0xff;
} else {
// resolved from global list
glob *gl = &gp[u->resolved];
diff = gl->val;
seg = gl->seg;
if (seg != 1) {
// not an absolute value
forwardpos(); // re-write position offset
obuf[ro++] = 0x20 | seg; // relocation byte for new segment
} else {
// absolute value - do not write a new relocation entry
}
}
ri += 4;// account for position, segment byte, label number in reloc table
}
new = old + diff;
buf[addr-base+pos] = new & 255;
break;
}
}
}
*lastaddrp = lastaddr + rdiff;
*rop = ro;
#ifdef DEBUG
printf(" --> lastaddr=%04x (%04x - %04x), rop=%d\n", lastaddr, *lastaddrp, rdiff, ro);
#endif
return ++ri;
}
Reference in New Issue View Git Blame Copy Permalink