/*
* This program reads in the various data files, performs some checks,
* and spits out the tables needed for assembly and disassembly.
*
* The input files are:
* instr.set Instruction set
* instr.key Translation from one- or two-character keys to
* operand list types
* instr.ord Ordering relations to enforce on the operands
*
* The output tables are merged into the debug source file debug.a86.
*/
#ifndef DOS
#ifdef __MSDOS__
#define DOS 1
#else
#define DOS 0
#endif
#endif
#include <stdlib.h>
#if ! DOS
#include <unistd.h>
#endif
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#if DOS
#define CRLF "\n"
#define bzero(a, b) memset(a, 0, b)
#else
#define CRLF "\r\n"
#define cdecl
#endif
#define MARKLINE1 ";-@@-@@-@@-Do not edit these tables! " \
"They have been automatically generated." CRLF
#define MARKLINE2 ";-@@-@@-@@-End of auto-generated tables. " \
"You may edit below this point." CRLF
#define MAX_OL_TYPES 80
#define MAX_N_ORDS 30
#define LINELEN 132
#define MAX_ASM_TAB 2048
#define MAX_MNRECS 400
#define MAX_SAVED_MNEMS 10
#define MAX_SLASH_ENTRIES 20
#define MAX_STAR_ENTRIES 15
#define MAX_LOCKTAB_ENTRIES 50
#define MAX_AGROUP_ENTRIES 14
#define MSHIFT 12 /* number of bits below machine type */
typedef char Boolean;
#define True 1
#define False 0
#define NUMBER(x) (sizeof(x) / sizeof(*x))
char line[LINELEN];
const char *filename;
int lineno;
int n_keys = 0;
struct keytab {
short key;
short value;
short width;
};
int n_ol_types = 0;
struct keytab olkeydict[MAX_OL_TYPES];
char *olnames[MAX_OL_TYPES];
int oloffset[MAX_OL_TYPES];
int n_ords = 0;
struct keytab *keyord1[MAX_N_ORDS];
struct keytab *keyord2[MAX_N_ORDS];
Boolean ordsmall[MAX_OL_TYPES];
/*
* Equates for the assembler table.
* These should be the same as in debug.asm.
*/
#define ASM_END 0xff
#define ASM_DB 0xfe
#define ASM_DW 0xfd
#define ASM_DD 0xfc
#define ASM_ORG 0xfb
#define ASM_WAIT 0xfa
#define ASM_D32 0xf9
#define ASM_AAX 0xf8
#define ASM_SEG 0xf7
#define ASM_LOCKREP 0xf6
#define ASM_LOCKABLE 0xf5
#define ASM_MACH6 0xf4
#define ASM_MACH0 0xee
int n_asm_tab = 0;
unsigned char asmtab[MAX_ASM_TAB];
struct mnrec {
struct mnrec *next;
char *string;
short len;
short offset;
short asmoffset;
};
int num_mnrecs;
struct mnrec mnlist[MAX_MNRECS];
struct mnrec *mnhead;
int n_saved_mnems = 0;
int saved_mnem[MAX_SAVED_MNEMS];
int n_slash_entries;
int slashtab_seq[MAX_SLASH_ENTRIES];
int slashtab_mn[MAX_SLASH_ENTRIES];
int n_star_entries;
int startab_seq[MAX_STAR_ENTRIES];
int startab_mn[MAX_STAR_ENTRIES];
int n_locktab;
int locktab[MAX_LOCKTAB_ENTRIES];
int n_agroups;
int agroup_i[MAX_AGROUP_ENTRIES];
int agroup_inf[MAX_AGROUP_ENTRIES];
volatile void
fail(const char *message, ...)
{
va_list args;
va_start(args, message);
vfprintf(stderr, message, args);
va_end(args);
putc('\n', stderr);
exit(1);
}
FILE *
openread(const char *path)
{
FILE *f;
f = fopen(path, "r");
if (f == NULL) {
perror(path);
exit(1);
}
filename = path;
lineno = 0;
return f;
}
volatile void
linenofail(const char *message, ...)
{
va_list args;
fprintf(stderr, "Line %d of `%s': ", lineno, filename);
va_start(args, message);
vfprintf(stderr, message, args);
va_end(args);
putc('\n', stderr);
exit(1);
}
void *
xmalloc(unsigned int len, const char *why)
{
void *ptr = malloc(len);
if (ptr == NULL) fail("Cannot allocate %u bytes for %s", len, why);
return ptr;
}
Boolean
getline(FILE *ff)
{
int n;
for (;;) {
if (fgets(line, LINELEN, ff) == NULL) return False;
++lineno;
if (line[0] == '#') continue;
n = strlen(line) - 1;
if (n < 0 || line[n] != '\n')
linenofail("too long.");
if (n > 0 && line[n-1] == '\r') --n;
if (n == 0) continue;
line[n] = '\0';
return True;
}
}
short
getkey(char **pp)
{
short key;
char *p = *pp;
if (*p == ' ' || *p == '\t' || *p == ';' || *p == '\0')
linenofail("key expected");
key = *p++;
if (*p != ' ' && *p != '\t' && *p != ';' && *p != '\0') {
key = (key << 8) | *p++;
if (*p != ' ' && *p != '\t' && *p != ';' && *p != '\0')
linenofail("key too long");
}
*pp = p;
return key;
}
/*
* Mark the given key pointer as small, as well as anything smaller than
* it (according to instr.ord).
*/
void
marksmall(struct keytab *kp)
{
int i;
ordsmall[kp - olkeydict] = True;
for (i = 0; i < n_ords; ++i)
if (keyord2[i] == kp)
marksmall(keyord1[i]);
}
/*
* Add a byte to the assembler table (asmtab).
* The format of this table is described in a long comment in debug.asm,
* somewhere within the mini-assembler.
*/
void
add_to_asmtab(unsigned char byte)
{
if (n_asm_tab >= MAX_ASM_TAB)
linenofail("Assembler table overflow.");
asmtab[n_asm_tab++] = byte;
}
unsigned char
getmachine(char **pp)
{
char *p = *pp;
unsigned char value;
if (*p != ';') return 0;
++p;
if (*p < '0' || *p > '6')
linenofail("bad machine type");
value = *p++ - '0';
add_to_asmtab(ASM_MACH0 + value);
*pp = p;
return value;
}
struct keytab *
lookupkey(short key)
{
struct keytab *kp;
for (kp = olkeydict; kp < olkeydict + NUMBER(olkeydict); ++kp)
if (key == kp->key) return kp;
linenofail("can't find key");
}
char *
skipwhite(char *p)
{
while (*p == ' ' || *p == '\t') ++p;
return p;
}
/*
* Data and setup stuff for the disassembler processing.
*/
/* Data on coprocessor groups */
unsigned int fpgrouptab[] = {0xd9e8, 0xd9f0, 0xd9f8};
#define NGROUPS 9
#define GROUP(i) (256 + 8 * ((i) - 1))
#define COPR(i) (256 + 8 * NGROUPS + 16 * (i))
#define FPGROUP(i) (256 + 8 * NGROUPS + 16 * 8 + 8 * (i))
#define SPARSE_BASE (256 + 8 * NGROUPS + 16 * 8 \
+ 8 * NUMBER(fpgrouptab))
/* #define OPILLEGAL 0 */
#define OPTWOBYTE 2
#define OPGROUP 4
#define OPCOPR 6
#define OPFPGROUP 8
#define OPPREFIX 10
#define OPSIMPLE 12
#define OPTYPES 12 /* op types start here (includes simple ops) */
#define PRESEG 1 /* these should be the same as in debug.asm */
#define PREREP 2
#define PRELOCK 4
#define PRE32D 8
#define PRE32A 0x10
/*
* For sparsely filled parts of the opcode map, we have counterparts
* to the above, which are compressed in a simple way.
*/
/* Sparse coprocessor groups */
unsigned int sp_fpgrouptab[] = {0xd9d0, 0xd9e0, 0xdae8, 0xdbe0,
0xded8, 0xdfe0};
#define NSGROUPS 5
#define SGROUP(i) (SPARSE_BASE + 256 + 8 * ((i) - 1))
#define SFPGROUP(i) (SPARSE_BASE + 256 + 8 * NSGROUPS + 8 * (i))
#define NOPS (SPARSE_BASE + 256 + 8 * NSGROUPS \
+ 8 * NUMBER(sp_fpgrouptab))
int optype[NOPS];
int opinfo[NOPS];
unsigned char opmach[NOPS];
/*
* Here are the tables for the main processor groups.
*/
struct {
int seq; /* sequence number of the group */
int info; /* which group number it is */
}
grouptab[] = {
{0x80, GROUP(1)}, /* Intel group 1 */
{0x81, GROUP(1)},
{0x83, GROUP(2)},
{0xd0, GROUP(3)}, /* Intel group 2 */
{0xd1, GROUP(3)},
{0xd2, GROUP(4)},
{0xd3, GROUP(4)},
{0xc0, GROUP(5)}, /* Intel group 2a */
{0xc1, GROUP(5)},
{0xf6, GROUP(6)}, /* Intel group 3 */
{0xf7, GROUP(6)},
{0xff, GROUP(7)}, /* Intel group 5 */
{SPARSE_BASE + 0x00, GROUP(8)}, /* Intel group 6 */
{SPARSE_BASE + 0x01, GROUP(9)}}; /* Intel group 7 */
/* #define NGROUPS 9 (this was done above) */
struct { /* sparse groups */
int seq; /* sequence number of the group */
int info; /* which group number it is */
}
sp_grouptab[] = {
{0xfe, SGROUP(1)}, /* Intel group 4 */
{SPARSE_BASE+0xba, SGROUP(2)}, /* Intel group 8 */
{SPARSE_BASE+0xc7, SGROUP(3)}, /* Intel group 9 */
{0x8f, SGROUP(4)}, /* Not an Intel group */
{0xc6, SGROUP(5)}, /* Not an Intel group */
{0xc7, SGROUP(5)}};
/* #define NSGROUPS 5 (this was done above) */
/*
* Creates an entry in the disassembler lookup table
*/
void
entertable(int i, int type, int info)
{
if (optype[i] != 0)
linenofail("Duplicate information for index %d", i);
optype[i] = type;
opinfo[i] = info;
}
/*
* Get a hex nybble from the input line or fail.
*/
int
getnybble(char c)
{
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'a' && c <= 'f') return c - 'a' + 10;
linenofail("Hex digit expected instead of `%c'", c);
}
/*
* Get a hex byte from the input line and update the pointer accordingly.
*/
int
getbyte(char **pp)
{
char *p = *pp;
int answer;
answer = getnybble(*p++);
answer = (answer << 4) | getnybble(*p++);
*pp = p;
return answer;
}
/*
* Get a `/r' descriptor from the input line and update the pointer
* accordingly.
*/
int
getslash(char **pp)
{
char *p = *pp;
int answer;
if (*p != '/') linenofail("`/' expected");
++p;
if (*p < '0' || *p > '7') linenofail("Octal digit expected");
answer = *p - '0';
++p;
*pp = p;
return answer;
}
int
entermn(char *str, char *str_end)
{
char *p;
if (num_mnrecs >= MAX_MNRECS)
linenofail("Too many mnemonics");
if (*str == '+') {
if (n_saved_mnems >= MAX_SAVED_MNEMS)
linenofail("Too many mnemonics to save");
saved_mnem[n_saved_mnems++] = num_mnrecs;
++str;
}
p = xmalloc(str_end - str + 1, "mnemonic name");
mnlist[num_mnrecs].string = p;
mnlist[num_mnrecs].len = str_end - str;
while (str < str_end) *p++ = toupper(*str++);
*p = '\0';
mnlist[num_mnrecs].asmoffset = n_asm_tab;
return num_mnrecs++;
}
/*
* Merge sort the indicated range of mnemonic records.
*/
struct mnrec *
mn_sort(struct mnrec *start, int len)
{
struct mnrec *p1, *p2, *answer;
struct mnrec **headpp;
int i;
i = len / 2;
if (i == 0)
return start;
p1 = mn_sort(start, i);
p2 = mn_sort(start + i, len - i);
headpp = &answer;
for (;;)
if (strcmp(p1->string, p2->string) < 0) {
*headpp = p1;
headpp = &p1->next;
p1 = *headpp;
if (p1 == NULL) {
*headpp = p2;
break;
}
}
else {
*headpp = p2;
headpp = &p2->next;
p2 = *headpp;
if (p2 == NULL) {
*headpp = p1;
break;
}
}
return answer;
}
/*
* This reads the main file, "instr.set".
*/
void
read_is(FILE *f1)
{
int i;
entertable(0x0f, OPTWOBYTE, SPARSE_BASE);
entertable(0x26, OPPREFIX, PRESEG | (0 << 8)); /* seg es */
entertable(0x2e, OPPREFIX, PRESEG | (1 << 8)); /* seg cs */
entertable(0x36, OPPREFIX, PRESEG | (2 << 8)); /* seg ss */
entertable(0x3e, OPPREFIX, PRESEG | (3 << 8)); /* seg ds */
entertable(0x64, OPPREFIX, PRESEG | (4 << 8)); /* seg fs */
entertable(0x65, OPPREFIX, PRESEG | (5 << 8)); /* seg gs */
entertable(0xf2, OPPREFIX, PREREP); /* other prefixes */
entertable(0xf3, OPPREFIX, PREREP);
entertable(0xf0, OPPREFIX, PRELOCK);
entertable(0x66, OPPREFIX, PRE32D);
entertable(0x67, OPPREFIX, PRE32A);
opmach[0x64] = opmach[0x65] = opmach[0x66] = opmach[0x67] = 3;
for (i = 0; i < NUMBER(grouptab); ++i)
entertable(grouptab[i].seq, OPGROUP, grouptab[i].info);
for (i = 0; i < NUMBER(sp_grouptab); ++i)
entertable(sp_grouptab[i].seq, OPGROUP, sp_grouptab[i].info);
for (i = 0; i < 8; ++i)
entertable(0xd8 + i, OPCOPR, COPR(i));
for (i = 0; i < NUMBER(fpgrouptab); ++i) {
unsigned int j = fpgrouptab[i];
unsigned int k = (j >> 8) - 0xd8;
if (k > 8 || (j & 0xff) < 0xc0)
fail("Bad value for fpgrouptab[%d]", i);
entertable(COPR(k) + 8 + (((j & 0xff) - 0xc0) >> 3),
OPFPGROUP, FPGROUP(i));
}
for (i = 0; i < NUMBER(sp_fpgrouptab); ++i) {
unsigned int j = sp_fpgrouptab[i];
unsigned int k = (j >> 8) - 0xd8;
if (k > 8 || (j & 0xff) < 0xc0)
fail("Bad value for sp_fpgrouptab[%d]", i);
entertable(COPR(k) + 8 + (((j & 0xff) - 0xc0) >> 3),
OPFPGROUP, SFPGROUP(i));
}
while (getline(f1)) { /* loop over lines in the file */
int mnem;
int mn_alt;
char *p, *p0, *pslash, *pstar;
Boolean asm_only_line;
unsigned char atab_addendum;
asm_only_line = False;
p0 = line;
if (line[0] == '_') {
asm_only_line = True;
++p0;
}
atab_addendum = '\0';
if (*p0 == '^') {
static const unsigned char uptab[] =
{ASM_AAX, ASM_DB, ASM_DW,
ASM_DD, ASM_ORG, ASM_D32};
++p0;
atab_addendum = uptab[*p0++ - '0'];
}
p = strchr(p0, ' ');
if (p == NULL) p = p0 + strlen(p0);
pslash = memchr(p0, '/', p - p0);
if (pslash != NULL) {
mnem = entermn(p0, pslash);
++mnlist[mnem].asmoffset; /* this one isn't 32 bit */
++pslash;
mn_alt = entermn(pslash, p);
add_to_asmtab(ASM_D32);
}
else {
pstar = memchr(p0, '*', p - p0);
if (pstar != NULL) {
mn_alt = entermn(p0, pstar); /* note the reversal */
++pstar;
add_to_asmtab(ASM_WAIT);
mnem = entermn(pstar, p);
}
else
mnem = entermn(p0, p);
}
if (atab_addendum != '\0') add_to_asmtab(atab_addendum);
atab_addendum = ASM_END;
bzero(ordsmall, n_keys * sizeof(Boolean));
while (*p == ' ') { /* loop over instruction variants */
Boolean lockable;
Boolean asm_only;
Boolean dis_only;
unsigned char machine;
unsigned long atab_inf;
unsigned short atab_key;
unsigned char atab_xtra = 0;
while (*p == ' ') ++p;
asm_only = asm_only_line;
dis_only = False;
if (*p == '_') { /* if assembler only */
++p;
asm_only = True;
}
else if (*p == 'D') { /* if disassembler only */
++p;
dis_only = True;
}
lockable = False;
if (*p == 'L') {
++p;
lockable = True;
add_to_asmtab(ASM_LOCKABLE);
}
atab_inf = i = getbyte(&p);
if (i == 0x0f) {
i = getbyte(&p);
atab_inf = 256 + i;
i += SPARSE_BASE;
}
if (optype[i] == OPGROUP) {
int j = getslash(&p);
int k;
for (k = 0;; ++k) {
if (k >= n_agroups) {
if (++n_agroups > MAX_AGROUP_ENTRIES)
linenofail("Too many agroup entries");
agroup_i[k] = i;
agroup_inf[k] = atab_inf;
break;
}
if (agroup_i[k] == i)
break;
}
atab_inf = 256 + 256 + 64 + 8 * k + j;
i = opinfo[i] + j;
}
if (optype[i] == OPCOPR) {
if (*p == '/') {
int j = getslash(&p);
atab_inf = 256 + 256 + j * 8 + (i - 0xd8);
i = opinfo[i] + j;
}
else {
atab_xtra = getbyte(&p);
if (atab_xtra < 0xc0)
linenofail("Bad second escape byte");
i = opinfo[i] + 8 + ((atab_xtra - 0xc0) >> 3);
if (optype[i] == OPFPGROUP)
i = opinfo[i] + (atab_xtra & 7);
}
}
switch (*p++) {
case '.':
machine = getmachine(&p);
if (!asm_only) {
entertable(i, OPSIMPLE, mnem);
opmach[i] = machine;
}
atab_key = 0;
/* none of these are lockable */
break;
case '*': /* lock or rep... prefix */
add_to_asmtab(ASM_LOCKREP);
add_to_asmtab(atab_inf); /* special case */
atab_addendum = '\0';
break;
case '&': /* segment prefix */
add_to_asmtab(ASM_SEG);
add_to_asmtab(atab_inf); /* special case */
atab_addendum = '\0';
break;
case ':': {
struct keytab *kp = lookupkey(getkey(&p));
int width = kp->width;
int j;
machine = getmachine(&p);
if (dis_only)
atab_addendum = '\0';
else {
if (ordsmall[kp - olkeydict])
linenofail("Variants out of order.");
marksmall(kp);
}
atab_key = kp->value + 1;
if ((i >= 256 && i < SPARSE_BASE)
|| i >= SPARSE_BASE + 256) {
if (width > 2)
linenofail("width failure");
width = 1;
}
if (i & (width - 1))
linenofail("width alignment failure");
if (!asm_only)
for (j = (i == 0x90); j < width; ++j) {
/* ^^^^^^^^^ kludge for NOP instr. */
entertable(i|j, oloffset[kp->value], mnem);
opmach[i | j] = machine;
if (lockable) {
if (n_locktab >= MAX_LOCKTAB_ENTRIES)
linenofail("Too many lockable "
"instructions");
locktab[n_locktab] = i | j;
++n_locktab;
}
}
}
break;
default:
linenofail("Syntax error.");
}
if (atab_addendum != '\0') {
atab_inf = atab_inf * (unsigned short) (n_ol_types + 1)
+ atab_key;
add_to_asmtab(atab_inf >> 8);
if ((atab_inf >> 8) >= ASM_MACH0)
fail("Assembler table is too busy");
add_to_asmtab(atab_inf);
if (atab_xtra != 0)
add_to_asmtab(atab_xtra);
}
if (pslash != NULL) {
if (n_slash_entries >= MAX_SLASH_ENTRIES)
linenofail("Too many slash entries");
slashtab_seq[n_slash_entries] = i;
slashtab_mn[n_slash_entries] = mn_alt;
++n_slash_entries;
}
else if (pstar != NULL) {
if (n_star_entries >= MAX_STAR_ENTRIES)
linenofail("Too many star entries");
startab_seq[n_star_entries] = i;
startab_mn[n_star_entries] = mn_alt;
++n_star_entries;
}
}
if (*p != '\0')
linenofail("Syntax error.");
if (atab_addendum != '\0')
add_to_asmtab(atab_addendum); /* ASM_END, if applicable */
}
}
/*
* Print everything onto the file.
*/
struct inforec { /* strings to put into comment fields */
int seqno;
char *string;
}
tblcomments[] = {
{0, "main opcode part"},
{GROUP(1), "Intel group 1"},
{GROUP(3), "Intel group 2"},
{GROUP(5), "Intel group 2a"},
{GROUP(6), "Intel group 3"},
{GROUP(7), "Intel group 5"},
{GROUP(8), "Intel group 6"},
{GROUP(9), "Intel group 7"},
{COPR(0), "Coprocessor d8"},
{COPR(1), "Coprocessor d9"},
{COPR(2), "Coprocessor da"},
{COPR(3), "Coprocessor db"},
{COPR(4), "Coprocessor dc"},
{COPR(5), "Coprocessor dd"},
{COPR(6), "Coprocessor de"},
{COPR(7), "Coprocessor df"},
{FPGROUP(0), "Coprocessor groups"},
{-1, NULL}};
void
put_dw(FILE *f2, const char *label, int *datap, int n)
{
const char *initstr;
int i;
fputs(label,f2);
while (n > 0) {
initstr = "\tdw\t";
for (i = (n <= 8 ? n : 8); i > 0; --i) {
fputs(initstr, f2);
initstr = ",";
fprintf(f2, "%5d", *datap++);
}
fputs(CRLF, f2);
n -= 8;
}
}
void
dumptables(FILE *f2)
{
int offset;
struct mnrec *mnp;
int colsleft;
char *auxstr;
struct inforec *tblptr;
int i;
int j;
int k;
/*
* Dump out asmtab.
*/
auxstr = CRLF ";\tMain data table for the assembler." CRLF CRLF
"asmtab\tdb\t";
colsleft = 16;
for (i = 0; i < n_asm_tab; ++i) {
fprintf(f2, "%s%d", auxstr, asmtab[i]);
auxstr = ",";
if (--colsleft <= 0) {
auxstr = CRLF "\tdb\t";
colsleft = 16;
}
}
/*
* Dump out agroup_inf.
*/
auxstr = CRLF CRLF ";\tData on groups (for the assembler)." CRLF CRLF
"agroups\tdw\t";
for (i = 0; i < n_agroups; ++i) {
fprintf(f2, "%s%d", auxstr, agroup_inf[i]);
auxstr = ",";
}
/*
* Sort the mnemonics alphabetically, compute their offsets,
* and print out the table.
*/
if (num_mnrecs == 0)
fail("No assembler mnemonics!");
mnhead = mn_sort(mnlist, num_mnrecs);
offset = 0;
auxstr = CRLF CRLF ";\tThis is the list of assembler mnemonics." CRLF
CRLF "mnlist\tdb\t";
colsleft = 80 - 15;
for (mnp = mnhead; mnp != NULL; mnp = mnp->next) {
mnp->offset = offset + 2;
offset += mnp->len + 3;
if (colsleft < mnp->len + 13) {
auxstr = CRLF "\tdb\t";
colsleft = 80 - 15;
}
colsleft -= mnp->len + 13;
fprintf(f2, "%s%d,%d,\"%s\",0", auxstr, mnp->asmoffset / 255 + 1,
mnp->asmoffset % 255 + 1, mnp->string);
auxstr = ",";
}
fputs(CRLF "end_mnlist db" CRLF, f2);
if (offset >= (1 << MSHIFT)) {
fprintf(stderr, "%d bytes of mnemonics. That's too many.\n",
offset);
exit(1);
}
/*
* Print out mnemonics we want to refer to.
*/
fputs(CRLF ";\tThese are equates to refer to the above mnemonics."
CRLF CRLF, f2);
for (i = 0; i < n_saved_mnems; ++i) {
mnp = mnlist + saved_mnem[i];
fprintf(f2, "MNEM_%s\tEQU\t%d" CRLF, mnp->string, mnp->offset);
}
/*
* Print out ASMMOD and the opindex array.
*/
fprintf(f2, CRLF ";\tNumber of entries in the following array." CRLF
CRLF "ASMMOD\tEQU\t%d" CRLF, n_ol_types + 1);
auxstr = CRLF ";\tThis is an array of indices into the oplists array "
"(below)." CRLF
";\tIt is used by the assembler to save space." CRLF CRLF
"opindex\tdb\t0,";
colsleft = 16;
for (i = 0; i < n_ol_types; ++i) {
fprintf(f2, "%s%d", auxstr, oloffset[i] - OPTYPES);
auxstr = ",";
if (--colsleft <= 0) {
auxstr = CRLF "\tdb\t";
colsleft = 16;
}
}
/*
* Print out oplists[]
*/
fputs(CRLF CRLF ";\tThese are the lists of operands "
"for the various instruction types." CRLF CRLF
"oplists\tdb\t0\t;simple instruction" CRLF, f2);
for (i = 0; i < n_ol_types; ++i)
fprintf(f2, "\tdb\t%s, 0" CRLF, olnames[i]);
fprintf(f2, CRLF "OPTYPES_BASE\tEQU\t%d" CRLF, OPTYPES);
fprintf(f2, CRLF "OPLIST_Z\tEQU\t%d" CRLF,
oloffset[lookupkey('z')->value]);
fprintf(f2, "OPLIST_ES\tEQU\t%d" CRLF,
oloffset[lookupkey(('E' << 8) | 'S')->value]);
/*
* Print out optype[]
*/
auxstr = CRLF ";\tHere is the compressed table of the opcode types."
CRLF CRLF "optypes\tdb\t";
tblptr = tblcomments;
for (i = 0; i < SPARSE_BASE; i += 8) {
for (j = 0; j < 8; ++j) {
fputs(auxstr, f2);
fprintf(f2, "%3d", optype[i + j]);
auxstr = ",";
}
fprintf(f2, "\t; %02x - %02x", i, i + 7);
if (i == tblptr->seqno)
fprintf(f2, " (%s)", (tblptr++)->string);
auxstr = CRLF "\tdb\t";
}
auxstr = CRLF ";\tThe rest of these are squeezed." CRLF "\tdb\t 0,";
colsleft = 7;
for (i = SPARSE_BASE; i < NOPS; ++i)
if ((j = optype[i]) != 0) {
if (--colsleft < 0) {
colsleft = 7;
auxstr = CRLF "\tdb\t";
}
fputs(auxstr, f2);
fprintf(f2, "%3d", j);
auxstr = ",";
}
fputs(CRLF, f2);
/*
* Print out opinfo[]
*/
fputs(CRLF ";\tAnd here is the compressed table of additional "
"information." CRLF CRLF "opinfo", f2);
for (i = 0; i < SPARSE_BASE; i += 8) {
auxstr = "\tdw\t";
for (j = 0; j < 8; ++j) {
fputs(auxstr, f2);
k = opinfo[i + j];
if (optype[i + j] >= OPTYPES)
k = mnlist[k].offset;
fprintf(f2, "0%04xh", k | (opmach[i + j] << MSHIFT));
auxstr = ",";
}
fprintf(f2, "\t; %02x" CRLF, i);
}
auxstr = ";\tThe rest of these are squeezed." CRLF "\tdw\t 0,";
colsleft = 7;
for (i = SPARSE_BASE; i < NOPS; ++i)
if ((j = optype[i]) != 0) {
if (--colsleft < 0) {
colsleft = 7;
auxstr = CRLF "\tdw\t";
}
fputs(auxstr, f2);
k = opinfo[i];
if (j >= OPTYPES) k = mnlist[k].offset;
fprintf(f2, "0%04xh", k | (opmach[i] << MSHIFT));
auxstr = ",";
}
fputs(CRLF, f2);
/*
* Print out sqztab
*/
fputs(CRLF ";\tThis table converts unsqueezed numbers to squeezed."
CRLF CRLF "sqztab", f2);
k = 0;
for (i = SPARSE_BASE; i < NOPS; i += 8) {
auxstr = "\tdb\t";
for (j = 0; j < 8; ++j) {
fprintf(f2, "%s%3d", auxstr, optype[i + j] == 0 ? 0 : ++k);
auxstr = ",";
}
fputs(CRLF, f2);
}
/*
* Print out the cleanup tables.
*/
fputs(CRLF ";\tThis is the table of mnemonics that change in the "
"presence of a WAIT" CRLF ";\tinstruction." CRLF CRLF, f2);
put_dw(f2, "wtab1", startab_seq, n_star_entries);
for (i = 0; i < n_star_entries; ++i)
startab_mn[i] = mnlist[startab_mn[i]].offset;
put_dw(f2, "wtab2", startab_mn, n_star_entries);
fprintf(f2, "N_WTAB\tequ\t%d" CRLF, n_star_entries);
fputs(CRLF ";\tThis is the table for operands which have a different "
"mnemonic for" CRLF ";\ttheir 32 bit versions." CRLF CRLF, f2);
put_dw(f2, "ltab1", slashtab_seq, n_slash_entries);
for (i = 0; i < n_slash_entries; ++i)
slashtab_mn[i] = mnlist[slashtab_mn[i]].offset;
put_dw(f2, "ltab2", slashtab_mn, n_slash_entries);
fprintf(f2, "N_LTAB\tequ\t%d" CRLF, n_slash_entries);
fputs(CRLF ";\tThis is the table of lockable instructions" CRLF CRLF,
f2);
put_dw(f2, "locktab", locktab, n_locktab);
fprintf(f2, "N_LOCK\tequ\t%d" CRLF, n_locktab);
/*
* Print out miscellaneous equates.
*/
fprintf(f2, CRLF ";\tEquates used in the assembly-language code." CRLF
CRLF "SPARSE_BASE\tequ\t%d" CRLF
CRLF "SFPGROUP3\tequ\t%d" CRLF CRLF, SPARSE_BASE, SFPGROUP(3));
}
int cdecl
main() {
FILE *f1;
FILE *f2;
int offset;
/*
* Read in the key dictionary.
*/
f1 = openread("instr.key");
offset = OPTYPES + 1;
while (getline(f1)) {
char *p = line;
int i;
if (n_keys >= MAX_OL_TYPES)
fail("Too many keys.");
olkeydict[n_keys].key = getkey(&p);
p = skipwhite(p);
for (i = 0;; ++i) {
if (i >= n_ol_types) {
char *q = xmalloc(strlen(p) + 1, "operand type name");
strcpy(q, p);
if (n_ol_types >= MAX_OL_TYPES)
fail("Too many operand list types.");
olnames[n_ol_types] = q;
oloffset[n_ol_types] = offset;
for (;;) {
++offset;
q = strchr(q, ',');
if (q == NULL) break;
++q;
}
++offset;
++n_ol_types;
}
if (strcmp(p, olnames[i]) == 0)
break;
}
olkeydict[n_keys].value = i;
olkeydict[n_keys].width = 1;
if (strstr(p, "OP_ALL") != NULL)
olkeydict[n_keys].width = 2;
else if (strstr(p, "OP_R_ADD") != NULL)
olkeydict[n_keys].width = 8;
++n_keys;
}
fclose(f1);
if (offset >= 256) {
fprintf(stderr, "%d bytes of operand lists. That's too many.\n",
offset);
exit(1);
}
/*
* Read in the ordering relations.
*/
f1 = openread("instr.ord");
while (getline(f1)) {
char *p = line;
if (n_ords >= MAX_N_ORDS)
fail ("Too many ordering restrictions.");
keyord1[n_ords] = lookupkey(getkey(&p));
p = skipwhite(p);
keyord2[n_ords] = lookupkey(getkey(&p));
if (*p != '\0')
fail("Syntax error in ordering file.");
++n_ords;
}
fclose(f1);
/*
* Do the main processing.
*/
f1 = openread("instr.set");
read_is(f1);
fclose(f1);
/*
* Write the file.
*/
f1 = openread("debug.a86");
f2 = fopen("debug.tmp", "w");
if (f2 == NULL) {
perror("debug.tmp");
exit(1);
}
do {
if (fgets(line, LINELEN, f1) == NULL) {
fputs("Couldn't find beginning marker line\n", stderr);
exit(1);
}
fputs(line, f2);
}
while (strcmp(line, MARKLINE1) != 0);
dumptables(f2);
do {
if (fgets(line, LINELEN, f1) == NULL) {
fputs("Couldn't find ending marker line\n", stderr);
exit(1);
}
}
while (strcmp(line, MARKLINE2) != 0);
do
fputs(line, f2);
while (fgets(line, LINELEN, f1) != NULL);
fclose(f1);
fclose(f2);
/*
* Move the file to its original position.
*/
#if DOS
if (unlink("debug.old") == -1 && errno != ENOFILE) {
perror("delete debug.old");
return 1;
}
#endif
if (rename("debug.a86", "debug.old") == -1) {
perror("rename debug.a86 -> debug.old");
return 1;
}
if (rename("debug.tmp", "debug.a86") == -1) {
perror("rename debug.tmp -> debug.a86");
return 1;
}
puts("Done.");
return 0;
}
