z8kgen.c

早期freebsd实现

}
func(a,b)
struct op *a;
struct op *b;
{
return strcmp((a)->name, (b)->name);


}

func1(a,b)
struct op *a;
struct op *b;
{
return strcmp((a)->bits, (b)->bits);


}

/* opcode 

 literal  0000 nnnn insert nnn into stream
 operand  0001 nnnn  insert operand reg nnn into stream
*/

typedef struct tok_struct 
{

char *match;
char *token;
int length;
};



struct tok_struct args[] =
{

{ "address(rs)", "CLASS_X+(ARG_RS)",},
{ "address(rd)", "CLASS_X+(ARG_RD)",},

{ "rs(disp16)","CLASS_BA+(ARG_RS)",},
{ "rd(disp16)","CLASS_BA+(ARG_RD)",},

{ "address", "CLASS_DA",},
{ "rd(rx)", "CLASS_BX+(ARG_RD)",},
{ "rs(rx)","CLASS_BX+(ARG_RS)",},
{ "disp16", "CLASS_DISP",},
{ "disp12", "CLASS_DISP",},
{ "disp7", "CLASS_DISP",},
{ "disp8", "CLASS_DISP",},
{ "flags","CLASS_FLAGS",},
{ "imm16", "CLASS_IMM+(ARG_IMM16)",},
{ "imm32", "CLASS_IMM+(ARG_IMM32)",},
{ "imm4", "CLASS_IMM +(ARG_IMM4)",},
{ "n", "CLASS_IMM + (ARG_IMMN)",},
{ "ctrl", "CLASS_CTRL",},
{ "rba", "CLASS_REG_BYTE+(ARG_RA)",},
{ "rbb", "CLASS_REG_BYTE+(ARG_RB)",},
{ "rbd", "CLASS_REG_BYTE+(ARG_RD)",},
{ "rbs", "CLASS_REG_BYTE+(ARG_RS)",},
{ "rbr", "CLASS_REG_BYTE+(ARG_RR)",},

{ "rrd","CLASS_REG_LONG+(ARG_RD)",},
{ "rrs","CLASS_REG_LONG+(ARG_RS)",},

{ "rqd", "CLASS_REG_QUAD+(ARG_RD)",},

{ "rd", "CLASS_REG_WORD+(ARG_RD)",},
{ "rs", "CLASS_REG_WORD+(ARG_RS)",},

{ "@rd", "CLASS_IR+(ARG_RD)",},
{ "@ra", "CLASS_IR+(ARG_RA)",},
{ "@rb", "CLASS_IR+(ARG_RB)",},
{ "@rs", "CLASS_IR+(ARG_RS)",},

{ "imm8", "CLASS_IMM+(ARG_IMM8)",},
{ "i2", "CLASS_IMM+(ARG_IMM2)",},
{ "cc", "CLASS_CC",},

{ "rr", "CLASS_REG_WORD+(ARG_RR)",},
{ "ra", "CLASS_REG_WORD+(ARG_RA)",},
{ "rs", "CLASS_REG_WORD+(ARG_RS)",},

{ "1", "CLASS_IMM+(ARG_IMM_1)",},
{ "2", "CLASS_IMM+(ARG_IMM_2)",},

 0,0
 };

struct tok_struct toks[] = 
{ 
 "0000", "CLASS_BIT+0",1,
 "0001", "CLASS_BIT+1",1,
 "0010", "CLASS_BIT+2",1,
 "0011", "CLASS_BIT+3",1,
 "0100", "CLASS_BIT+4",1,
 "0101", "CLASS_BIT+5",1,
 "0110", "CLASS_BIT+6",1,
 "0111", "CLASS_BIT+7",1,
 "1000", "CLASS_BIT+8",1,
 "1001", "CLASS_BIT+9",1,
 "1010", "CLASS_BIT+10",1,
 "1011", "CLASS_BIT+11",1,
 "1100", "CLASS_BIT+12",1,
 "1101", "CLASS_BIT+13",1,
 "1110", "CLASS_BIT+14",1,
 "1111", "CLASS_BIT+15",1,

 "ssss", "CLASS_REG+(ARG_RS)",1,
 "dddd", "CLASS_REG+(ARG_RD)",1,
 "aaaa", "CLASS_REG+(ARG_RA)",1,
 "bbbb", "CLASS_REG+(ARG_RB)",1,
 "rrrr", "CLASS_REG+(ARG_RR)",1,

 "ssN0", "CLASS_REGN0+(ARG_RS)",1,
 "ddN0", "CLASS_REGN0+(ARG_RD)",1,
 "aaN0", "CLASS_REGN0+(ARG_RA)",1,
 "bbN0", "CLASS_REGN0+(ARG_RB)",1,
 "rrN0", "CLASS_REGN0+(ARG_RR)",1,

 "cccc", "CLASS_CC",1,
 "nnnn", "CLASS_IMM+(ARG_IMMN)",1,
 "xxxx", "CLASS_REG+(ARG_RX)",1,
 "xxN0", "CLASS_REGN0+(ARG_RX)",1,
 "nminus1", "CLASS_IMM+(ARG_IMMNMINUS1)",1,

 "disp16", "CLASS_DISP+(ARG_DISP16)",4,
 "disp12", "CLASS_DISP+(ARG_DISP12)",3,
 "flags", "CLASS_FLAGS",1,
 "address", "CLASS_ADDRESS",4,
 "imm4", "CLASS_IMM+(ARG_IMM4)",1,
 "imm8", "CLASS_IMM+(ARG_IMM8)",2,
 "imm16", "CLASS_IMM+(ARG_IMM16)",4,
 "imm32", "CLASS_IMM+(ARG_IMM32)",8,
 "nim16", "CLASS_IMM+(ARG_NIM16)",4,
 "0ccc", "CLASS_0CCC",1,
 "1ccc", "CLASS_1CCC",1,
 "disp8", "CLASS_DISP8",2,
 "0disp7", "CLASS_0DISP7",2,
 "1disp7", "CLASS_1DISP7",2,
 "01ii", "CLASS_01II",1,
 "00ii", "CLASS_00II",1,
 0,0

 };


char *translate(table, x, length)
struct tok_struct *table;
char *x;
int *length;
{

 int found;
 found = 0;
 while (table->match) 
 {
 int l = strlen(table->match);
 if (strncmp(table->match, x, l) == 0) 
 {
 /* Got a hit */
 printf("%s", table->token);
 *length += table->length;
 return x + l;
 }

 table++;
 }
 fprintf(stderr,"Can't find %s\n", x);
 while (*x) 
 x++;
 return x;
}


void
 chewbits(bits, length)
char *bits;
int *length;
{
 int i;
 int found;
 
 int n = 0;
 *length = 0;
 printf("{");
 while (*bits) 
 {
 while (*bits == ' ') 
 {
 bits++;
 }
 bits = translate(toks, bits, length);
 n++;
 printf(",");

 }
 while (n < BYTE_INFO_LEN-1) {
 printf("0,");
 n++;
 }
 printf("}");
}

doreg(x)
char *x;
{
printf("REGH %c ", x[0]);

}
int chewname(name)
char *name;
{
 char *n;
 int nargs = 0;
 int nbytes= 0;
 n = name;
 printf("\"");
 while (*n && !iswhite(*n)) {
   printf("%c", *n );
   n++;
 }
 printf("\",{");
 /* Scan the operands and make entires for them -remember indirect things */
 while (*n) {
 int d;
 while (*n == ',' || iswhite(*n))
     n++;
 nargs++;
 n= translate(args, n, &d);
 printf(",");
 }
 if (nargs == 0) {
 printf("0");
 }
 printf("},");
 return nargs;
}
sub(x,c)
char *x;
char c;
{
 while (*x) 
 {
 if (x[0] == c 
 && x[1] == c 
 && x[2] == c 
 && x[3] == c) {
 x[2] = 'N';
 x[3] = '0';
 }
 x++;
 }
}
internal()
{
 int c = count();
 struct op *new = malloc(sizeof(struct op) * c);
 struct op *p = opt;
 memcpy(new, p, c * sizeof(struct op));

 /* sort all names in table alphabetically */
 qsort(new, c, sizeof(struct op), func);
 p = new;
 while (p->name) {
 /* If there are any @rs, sub the ssss into a ssn0,
 (rs), (ssn0)
 */
 int loop = 1;
 while (loop) {
 char *s = p->name;
 loop = 0;
 while (*s) {
 if(s[0] == '@') {
  char c ;
  /* skip the r and sub the string */
  s++;
  c = s[1];
  sub(p->bits,c);
 }
 if (s[0] == '(' && s[3] == ')')
 {
  sub(p->bits, s[2]);
 }
 if (s[0] == '(')
 {
  sub(p->bits, s[-1]);
 }

 s++;
 }
  
 }
 printf("\"%s\",\"%s\",\n", p->bits, p->name);
 p++;
 }
}
gas()
{

 int c = count();
 int i;
 struct op *p = opt;
 int idx = 0;
 char *oldname = "";
 struct op *new = malloc(sizeof(struct op) * c);

 memcpy(new, p, c * sizeof(struct op));

 /* sort all names in table alphabetically */
 qsort(new, c, sizeof(struct op), func);

 printf("   /* THIS FILE IS AUTOMAGICALLY GENERATED, DON'T EDIT IT */\n");

 printf("#define ARG_MASK 0x0f\n"); 
 printf("#define ARG_RS 0x01\n");
 printf("#define ARG_RD 0x02\n");
 printf("#define ARG_RA 0x03\n");
 printf("#define ARG_RB 0x04\n");
 printf("#define ARG_RR 0x05\n");
 printf("#define ARG_RX 0x06\n");
 printf("#define ARG_IMM4 0x01\n");
 printf("#define ARG_IMM8 0x02\n");
 printf("#define ARG_IMM16 0x03\n");
 printf("#define ARG_IMM32 0x04\n");
 printf("#define ARG_IMMN 0x05\n");
 printf("#define ARG_IMMNMINUS1 0x05\n");
 printf("#define ARG_IMM_1 0x06\n");
 printf("#define ARG_IMM_2 0x07\n");
 printf("#define ARG_DISP16 0x08\n");
 printf("#define ARG_NIM16 0x09\n");
 printf("#define ARG_IMM2 0x0a\n");
 printf("#define ARG_DISP12 0x0b\n");
 printf("#define ARG_DISP8 0x0c\n");

 printf("#define CLASS_MASK 0xfff0\n");
 printf("#define CLASS_X 0x10\n");
 printf("#define CLASS_BA 0x20\n");
 printf("#define CLASS_DA 0x30\n");
 printf("#define CLASS_BX 0x40\n");
 printf("#define CLASS_DISP 0x50\n");
 printf("#define CLASS_IMM 0x60\n");
 printf("#define CLASS_CC 0x70\n");
 printf("#define CLASS_CTRL 0x80\n");
 printf("#define CLASS_ADDRESS 0xd0\n");
 printf("#define CLASS_0CCC 0xe0\n");
 printf("#define CLASS_1CCC 0xf0\n");
 printf("#define CLASS_0DISP7 0x100\n");
 printf("#define CLASS_1DISP7 0x200\n");
 printf("#define CLASS_01II 0x300\n");
 printf("#define CLASS_00II 0x400\n");
 printf("#define CLASS_BIT 0x500\n");
 printf("#define CLASS_FLAGS 0x600\n");
 printf("#define CLASS_IR 0x700\n");
 printf("#define CLASS_DISP8 0x800\n");


 printf("#define CLASS_REG 0x7000\n");
 printf("#define CLASS_REG_BYTE 0x2000\n");
 printf("#define CLASS_REG_WORD 0x3000\n");
 printf("#define CLASS_REG_QUAD 0x4000\n");
 printf("#define CLASS_REG_LONG 0x5000\n");
 printf("#define CLASS_REGN0 0x8000\n");



#if 0
 for (i = 0; toks[i].token; i++)
 printf("#define %s\t0x%x\n",toks[i].token,i*16);
#endif
 printf("typedef struct {\n");
 printf("char *name;\n");
 printf("unsigned short arg_info[4];\n");
 printf("unsigned short byte_info[%d];\n", BYTE_INFO_LEN);
 printf("int noperands;\n");
 printf("int length;\n");
 printf("int idx;\n");
 printf("} opcode_entry_type;\n");
 printf("#ifdef DEFINE_TABLE\n");
 printf("opcode_entry_type z8k_table[] = {\n");

 while (new->name) {
 int nargs;
 int length;
 printf("{");
 nargs = chewname(new->name);

printf("\n\t");
 chewbits(new->bits, &length);
 length /=2;
 if (length &1) fail();

 printf(",%d,%d,%d", nargs, length, idx);
 if(strcmp(oldname, new->name)) 
 {
 idx++;
 oldname = new->name;
 }
 printf("},\n");
 new++;
 }
 printf("0,0};\n");
 printf("#endif\n");
}
main(ac,av)
int ac;
char **av;
{
 struct op *p = opt;

 if (ac == 2 && strcmp(av[1],"-t")==0) 
 {
 internal();
 }
else if (ac == 2 && strcmp(av[1],"-h")==0) 
 {
 while (p->name) {
 printf("%-25s\t%s\n", p->name, p->bits);
 p++;
 }
 }

 else if (ac== 2 && strcmp(av[1], "-a") == 0)
 {
 gas();
 }
 else if (ac== 2 && strcmp(av[1], "-d") == 0)
 {
 /*dis();*/
 }
 else {
 printf("Usage: %s -t\n", av[0]);
 printf("-t : generate new z8.c internal table\n");
 printf("-a : generate new table for gas\n");
 printf("-d : generate new table for disassemble\n");
 printf("-h : generate new table for humans\n");
 }


}

fail()
{
}