home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / sim / sh / gencode.c < prev    next >
C/C++ Source or Header  |  1996-01-16  |  27KB  |  826 lines
  1. /* Simulator/Opcode generator for the Hitachi Super-H architecture.
  2.  
  3.    Written by Steve Chamberlain of Cygnus Support.
  4.    sac@cygnus.com
  5.  
  6.    This file is part of SH sim
  7.  
  8.  
  9.         THIS SOFTWARE IS NOT COPYRIGHTED
  10.  
  11.    Cygnus offers the following for use in the public domain.  Cygnus
  12.    makes no warranty with regard to the software or it's performance
  13.    and the user accepts the software "AS IS" with all faults.
  14.  
  15.    CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
  16.    THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17.    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18.  
  19. */
  20.  
  21. /* This program generates the opcode table for the assembler and
  22.    the simulator code
  23.  
  24.    -t        prints a pretty table for the assembler manual
  25.    -s        generates the simulator code jump table
  26.    -d        generates a define table
  27.    -x        generates the simulator code switch statement
  28.    default     generates the opcode tables
  29.  
  30. */
  31.  
  32. #include <stdio.h>
  33.  
  34. typedef struct
  35. {
  36. char *defs;
  37. char *refs;
  38.   char *name;
  39.   char *code;
  40.   char *stuff[10];
  41.   int index;
  42. }
  43.  
  44. op;
  45.  
  46.  
  47. op tab[] =
  48. {
  49.  
  50.   {"n","","add #<imm>,<REG_N>", "0111nnnni8*1....", "R[n] += SEXT(i);if (i == 0) { UNDEF(n); break; } "},
  51.   {"n","mn","add <REG_M>,<REG_N>", "0011nnnnmmmm1100", "R[n] += R[m];"},
  52.   {"n","mn","addc <REG_M>,<REG_N>", "0011nnnnmmmm1110",
  53.      "ult=R[n]+T;T=ult<R[n];R[n]=ult+R[m];T|=R[n]<ult;"},
  54.   {"n","mn","addv <REG_M>,<REG_N>", "0011nnnnmmmm1111",
  55.      "ult = R[n] + R[m]; T = ((~(R[n] ^ R[m]) & (ult ^ R[n])) >> 31); R[n] = ult;"},
  56.   {"0","","and #<imm>,R0", "11001001i8*1....", ";R0&=i;"},
  57.   {"n","nm","and <REG_M>,<REG_N>", "0010nnnnmmmm1001", " R[n]&=R[m];"},
  58.   {"","0","and.b #<imm>,@(R0,GBR)", "11001101i8*1....", ";WBAT(GBR+R0, RBAT(GBR+R0) & i);"},
  59.  
  60.   {"","","bra <bdisp12>", "1010i12.........", "ult = PC; PC=PC+(i<<1)+2;SL(ult+2);"},
  61.   {"","","bsr <bdisp12>", "1011i12.........", "PR = PC + 4; PC=PC+(i<<1)+2;SL(PR-2);"},
  62.   {"","","bt <bdisp8>", "10001001i8p1....", "if(T) {PC+=(SEXT(i)<<1)+2;C+=2;}"},
  63.   {"","","bf <bdisp8>", "10001011i8p1....", "if(T==0) {PC+=(SEXT(i)<<1)+2;C+=2;}"},
  64.   {"","","bt.s <bdisp8>", "10001101i8p1....","if(T) {ult = PC; PC+=(SEXT(i)<<1)+2;C+=2;SL(ult+2);}"},
  65.   {"","","bf.s <bdisp8>", "10001111i8p1....","if(!T) {ult = PC; PC+=(SEXT(i)<<1)+2;C+=2;SL(ult+2);}"},
  66.   {"","","clrmac", "0000000000101000", "MACH = MACL = 0;"},
  67.   {"","","clrs", "0000000001001000", "S= 0;"},
  68.   {"","","clrt", "0000000000001000", "T= 0;"},
  69.   {"","0","cmp/eq #<imm>,R0", "10001000i8*1....", ";T = R0 == SEXT(i);"},
  70.   {"","mn","cmp/eq <REG_M>,<REG_N>", "0011nnnnmmmm0000", "T=R[n]==R[m];"},
  71.   {"","mn","cmp/ge <REG_M>,<REG_N>", "0011nnnnmmmm0011", "T=R[n]>=R[m];"},
  72.   {"","mn","cmp/gt <REG_M>,<REG_N>", "0011nnnnmmmm0111", "T=R[n]>R[m];"},
  73.   {"","mn","cmp/hi <REG_M>,<REG_N>", "0011nnnnmmmm0110", "T=UR[n]>UR[m];"},
  74.   {"","mn","cmp/hs <REG_M>,<REG_N>", "0011nnnnmmmm0010", "T=UR[n]>=UR[m];"},
  75.   {"","n","cmp/pl <REG_N>", "0100nnnn00010101", "T = R[n]>0;"},
  76.   {"","n","cmp/pz <REG_N>", "0100nnnn00010001", "T = R[n]>=0;"},
  77.   {"","mn","cmp/str <REG_M>,<REG_N>", "0010nnnnmmmm1100",
  78.    "ult = R[n] ^ R[m]; T=((ult&0xff000000)==0) |((ult&0xff0000)==0) |((ult&0xff00)==0) |((ult&0xff)==0); "},
  79.   {"","mn","div0s <REG_M>,<REG_N>", "0010nnnnmmmm0111", "Q=(R[n]&sbit)!=0; M=(R[m]&sbit)!=0; T=M!=Q;;"},
  80.   {"","","div0u", "0000000000011001", "M=Q=T=0;"},
  81.   {"","","div1 <REG_M>,<REG_N>", "0011nnnnmmmm0100", "T=div1(R,m,n,T);"},
  82.   {"n","m","exts.b <REG_M>,<REG_N>", "0110nnnnmmmm1110", "R[n] = SEXT(R[m]);"},
  83.   {"n","m","exts.w <REG_M>,<REG_N>", "0110nnnnmmmm1111", "R[n] = SEXTW(R[m]);"},
  84.   {"n","m","extu.b <REG_M>,<REG_N>", "0110nnnnmmmm1100", "R[n] = R[m] & 0xff;"},
  85.   {"n","m","extu.w <REG_M>,<REG_N>", "0110nnnnmmmm1101", "R[n] = R[m] & 0xffff;"},
  86.   {"","n","jmp @<REG_N>", "0100nnnn00101011", "ult = PC; PC=R[n]-2; SL(ult+2);"},
  87.   {"","n","jsr @<REG_N>", "0100nnnn00001011", "PR = PC + 4; PC=R[n]-2; if (~doprofile) gotcall(PR,PC+2);SL(PR-2);"},
  88.   {"","n","ldc <REG_N>,SR", "0100nnnn00001110", "SET_SR(R[n]);"},
  89.   {"","n","ldc <REG_N>,GBR", "0100nnnn00011110", "GBR=R[n];"},
  90.   {"","n","ldc <REG_N>,VBR", "0100nnnn00101110", "VBR=R[n];"},
  91.   {"","n","ldc <REG_N>,SSR", "0100nnnn00111110", "SSR=R[n];"},
  92.   {"","n","ldc <REG_N>,SPC", "0100nnnn01001110", "SPC=R[n];"},
  93.   {"","n","ldc.l @<REG_N>+,SR", "0100nnnn00000111", "SET_SR(RLAT(R[n]));R[n]+=4;;"},
  94.   {"","n","ldc.l @<REG_N>+,GBR", "0100nnnn00010111", "GBR=RLAT(R[n]);R[n]+=4;;"},
  95.   {"","n","ldc.l @<REG_N>+,VBR", "0100nnnn00100111", "VBR=RLAT(R[n]);R[n]+=4;;"},
  96.   {"","n","ldc.l @<REG_N>+,SSR", "0100nnnn00110111", "SSR=RLAT(R[n]);R[n]+=4;;"},
  97.   {"","n","ldc.l @<REG_N>+,SPC", "0100nnnn01000111", "SPC=RLAT(R[n]);R[n]+=4;;"},
  98.   {"","n","lds <REG_N>,MACH", "0100nnnn00001010", "MACH = R[n];"},
  99.   {"","n","lds <REG_N>,MACL", "0100nnnn00011010", "MACL= R[n];"},
  100.   {"","n","lds <REG_N>,PR", "0100nnnn00101010", "PR = R[n];"},
  101.   {"","n","lds.l @<REG_N>+,MACH", "0100nnnn00000110", "MACH = SEXT(RLAT(R[n]));R[n]+=4;"},
  102.   {"","n","lds.l @<REG_N>+,MACL", "0100nnnn00010110", "MACL = RLAT(R[n]);R[n]+=4;"},
  103.   {"","n","lds.l @<REG_N>+,PR", "0100nnnn00100110", "PR = RLAT(R[n]);R[n]+=4;;"},
  104.   {"","","ldtlb", "0000000000111000", "/*XXX*/ abort();"},
  105.   {"","n","mac.w @<REG_M>+,@<REG_N>+", "0100nnnnmmmm1111", "macw(R0,memory,n,m);"},
  106.   {"n","","mov #<imm>,<REG_N>", "1110nnnni8*1....", "R[n] = SEXT(i);"},
  107.   {"n","m","mov <REG_M>,<REG_N>", "0110nnnnmmmm0011", "R[n] = R[m];"},
  108.   {"","mn0","mov.b <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0100", "WBAT(R[n]+R0, R[m]);"},
  109.   {"","nm","mov.b <REG_M>,@-<REG_N>", "0010nnnnmmmm0100", "R[n]--; WBAT(R[n],R[m]);"},
  110.   {"","mn","mov.b <REG_M>,@<REG_N>", "0010nnnnmmmm0000", "WBAT(R[n], R[m]);"},
  111.   {"0","m","mov.b @(<disp>,<REG_M>),R0", "10000100mmmmi4*1", "R0=RSBAT(i+R[m]);L(0);"},
  112.   {"0","","mov.b @(<disp>,GBR),R0", "11000100i8*1....", "R0=RSBAT(i+GBR);L(0);"},
  113.   {"n","0m","mov.b @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1100", "R[n]=RSBAT(R0+R[m]);L(n);"},
  114.   {"n","m","mov.b @<REG_M>+,<REG_N>", "0110nnnnmmmm0100", "R[n] = RSBAT(R[m]);L(n);R[m]++;"},
  115.   {"n","m","mov.b @<REG_M>,<REG_N>", "0110nnnnmmmm0000", "R[n]=RSBAT(R[m]);L(n);"},
  116.   {"","m0","mov.b R0,@(<disp>,<REG_M>)", "10000000mmmmi4*1", "WBAT(i+R[m],R0);"},
  117.   {"","0","mov.b R0,@(<disp>,GBR)", "11000000i8*1....", "WBAT(i+GBR,R0);"},
  118.   {"","nm","mov.l <REG_M>,@(<disp>,<REG_N>)", "0001nnnnmmmmi4*4",   "WLAT(i+R[n],R[m]);"},
  119.   {"","nm0","mov.l <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0110", "WLAT(R0+R[n],R[m]);"},
  120.   {"","nm","mov.l <REG_M>,@-<REG_N>", "0010nnnnmmmm0110", "R[n]-=4;WLAT(R[n],R[m]);"},
  121.   {"","nm","mov.l <REG_M>,@<REG_N>", "0010nnnnmmmm0010", "WLAT(R[n], R[m]);"},
  122.   {"n","m","mov.l @(<disp>,<REG_M>),<REG_N>","0101nnnnmmmmi4*4", "R[n]=RLAT(i+R[m]);L(n);"},
  123.   {"0","","mov.l @(<disp>,GBR),R0", "11000110i8*4....", "R0=RLAT(i+GBR);L(0);"},
  124.   {"n","","mov.l @(<disp>,PC),<REG_N>", "1101nnnni8p4....", "R[n]=RLAT((i+4+PC) & ~3);L(n);"},
  125.   {"n","m","mov.l @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1110", "R[n]=RLAT(R0+R[m]);L(n);"},
  126. {"nm","m","mov.l @<REG_M>+,<REG_N>", "0110nnnnmmmm0110", "R[n]=RLAT(R[m]);R[m]+=4;L(n);"},
  127.   {"n","m","mov.l @<REG_M>,<REG_N>", "0110nnnnmmmm0010", "R[n]=RLAT(R[m]);L(n);"},
  128.   {"","0","mov.l R0,@(<disp>,GBR)", "11000010i8*4....", "WLAT(i+GBR,R0);"},
  129.   {"","m0n","mov.w <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0101", "WWAT(R0+R[n],R[m]);"},
  130. {"n","mn","mov.w <REG_M>,@-<REG_N>", "0010nnnnmmmm0101", "R[n]-=2;WWAT(R[n],R[m]);"},
  131.   {"","nm","mov.w <REG_M>,@<REG_N>", "0010nnnnmmmm0001", "WWAT(R[n],R[m]);"},
  132.   {"0","m","mov.w @(<disp>,<REG_M>),R0", "10000101mmmmi4*2", "R0=RSWAT(i+R[m]);L(0);"},
  133.   {"0","","mov.w @(<disp>,GBR),R0", "11000101i8*2....", "R0=RSWAT(i+GBR);L(0);"},
  134.   {"n","","mov.w @(<disp>,PC),<REG_N>", "1001nnnni8p2....", "R[n]=RSWAT(PC+i+4);L(n);"},
  135. {"n","m0","mov.w @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1101", "R[n]=RSWAT(R0+R[m]);L(n);"},
  136. {"nm","n","mov.w @<REG_M>+,<REG_N>", "0110nnnnmmmm0101", "R[n]=RSWAT(R[m]);R[m]+=2;L(n);"},
  137.   {"n","m","mov.w @<REG_M>,<REG_N>", "0110nnnnmmmm0001", "R[n]=RSWAT(R[m]);L(n);"},
  138.   {"","0m","mov.w R0,@(<disp>,<REG_M>)", "10000001mmmmi4*2",   "WWAT(i+R[m],R0);"},
  139.   {"","0","mov.w R0,@(<disp>,GBR)", "11000001i8*2....", "WWAT(i+GBR,R0);"},
  140.   {"0","","mova @(<disp>,PC),R0", "11000111i8p4....", "R0=((i+4+PC) & ~0x3);"},
  141.   {"n","","movt <REG_N>", "0000nnnn00101001", "R[n]=T;"},
  142.   {"","mn","muls <REG_M>,<REG_N>", "0010nnnnmmmm1111","MACL=((int)(short)R[n])*((int)(short)R[m]);"},
  143.   {"","mn","mul.l <REG_M>,<REG_N>","0000nnnnmmmm0111","MACL=((int)R[n])*((int)R[m]);"},
  144.   {"","mn","mulu <REG_M>,<REG_N>", "0010nnnnmmmm1110","MACL=((unsigned int)(unsigned short)R[n])*((unsigned int)(unsigned short)R[m]);"},
  145.   {"n","m","neg <REG_M>,<REG_N>", "0110nnnnmmmm1011", "R[n] = - R[m];"},
  146.   {"n","m","negc <REG_M>,<REG_N>", "0110nnnnmmmm1010", "ult=-T;T=ult>0;R[n]=ult-R[m];T|=R[n]>ult;"},
  147.   {"","","nop", "0000000000001001", ""},
  148.   {"n","m","not <REG_M>,<REG_N>", "0110nnnnmmmm0111", "R[n]=~R[m];"},
  149.   {"0","","or #<imm>,R0", "11001011i8*1....", "R0|=i;"},
  150.   {"n","m","or <REG_M>,<REG_N>", "0010nnnnmmmm1011", "R[n]|=R[m];"},
  151.   {"","0","or.b #<imm>,@(R0,GBR)", "11001111i8*1....", "WBAT(R0+GBR,RBAT(R0+GBR)|i);"},
  152. {"n","n","rotcl <REG_N>", "0100nnnn00100100", "ult=R[n]<0;R[n]=(R[n]<<1)|T;T=ult;"},
  153.   {"n","n","rotcr <REG_N>", "0100nnnn00100101", "ult=R[n]&1;R[n]=(UR[n]>>1)|(T<<31);T=ult;"},
  154.   {"n","n","rotl <REG_N>", "0100nnnn00000100", "T=R[n]<0;R[n]<<=1;R[n]|=T;"},
  155.   {"n","n","rotr <REG_N>", "0100nnnn00000101", "T=R[n]&1;R[n] = UR[n]>> 1;R[n]|=(T<<31);"},
  156.   {"","","rte", "0000000000101011", 
  157.     "{ int tmp = PC; PC=RLAT(R[15])+2;R[15]+=4;SET_SR(RLAT(R[15]) & 0x3f3);R[15]+=4;SL(tmp+2);}"},
  158.   {"","","rts", "0000000000001011", "ult=PC;PC=PR-2;SL(ult+2);"},
  159.   {"","","sets", "0000000001011000", "S=1;"},
  160.   {"","","sett", "0000000000011000", "T=1;"},
  161.   {"n","mn","shad <REG_M>,<REG_N>", "0100nnnnmmmm1100",
  162.     "R[n] = (R[m] < 0) ? (R[n] >> ((-R[m])&0x1f)) : (R[n] << (R[m] & 0x1f));"},
  163.   {"n","mn","shld <REG_M>,<REG_N>", "0100nnnnmmmm1101",
  164.     "R[n] = (R[m] < 0) ? (UR[n] >> ((-R[m])&0x1f)): (R[n] << (R[m] & 0x1f));"},
  165.   {"n","n","shal <REG_N>", "0100nnnn00100000", "T=R[n]<0; R[n]<<=1;"},
  166.   {"n","n","shar <REG_N>", "0100nnnn00100001", "T=R[n]&1; R[n] = R[n] >> 1;"},
  167.   {"n","n","shll <REG_N>", "0100nnnn00000000", "T=R[n]<0; R[n]<<=1;"},
  168.   {"n","n","shll16 <REG_N>", "0100nnnn00101000", "R[n]<<=16;"},
  169.   {"n","n","shll2 <REG_N>", "0100nnnn00001000", "R[n]<<=2;"},
  170.   {"n","n","shll8 <REG_N>", "0100nnnn00011000", "R[n]<<=8;"},
  171.   {"n","n","shlr <REG_N>", "0100nnnn00000001", "T=R[n]&1;R[n]=UR[n]>>1;"},
  172.   {"n","n","shlr16 <REG_N>", "0100nnnn00101001", "R[n]=UR[n]>>16;"},
  173.   {"n","n","shlr2 <REG_N>", "0100nnnn00001001", "R[n]=UR[n]>>2;"},
  174.   {"n","n","shlr8 <REG_N>", "0100nnnn00011001", "R[n]=UR[n]>>8;"},
  175.   {"","","sleep", "0000000000011011", "trap(0xc3,R0,memory,maskl,maskw,little_endian);PC-=2;"},
  176.   {"n","","stc SR,<REG_N>",  "0000nnnn00000010", "R[n]=GET_SR();"},
  177.   {"n","","stc GBR,<REG_N>", "0000nnnn00010010", "R[n]=GBR;"},
  178.   {"n","","stc VBR,<REG_N>", "0000nnnn00100010", "R[n]=VBR;"},
  179.   {"n","","stc SSR,<REG_N>", "0000nnnn00110010", "R[n]=SSR;"},
  180.   {"n","","stc SPC,<REG_N>", "0000nnnn01000010", "R[n]=SPC;"},
  181.   {"n","n","stc.l SR,@-<REG_N>",  "0100nnnn00000011", "R[n]-=4;WLAT(R[n],GET_SR());"},
  182.   {"n","n","stc.l GBR,@-<REG_N>", "0100nnnn00010011", "R[n]-=4;WLAT(R[n],GBR);;"},
  183.   {"n","n","stc.l VBR,@-<REG_N>", "0100nnnn00100011", "R[n]-=4;WLAT(R[n],VBR);"},
  184.   {"n","n","stc.l SSR,@-<REG_N>", "0100nnnn00110011", "R[n]-=4;WLAT(R[n],SSR);"},
  185.   {"n","n","stc.l SPC,@-<REG_N>", "0100nnnn01000011", "R[n]-=4;WLAT(R[n],SPC);"},
  186.   {"n","","sts MACH,<REG_N>", "0000nnnn00001010", "R[n]=MACH;"},
  187.   {"n","","sts MACL,<REG_N>", "0000nnnn00011010", "R[n]=MACL;"},
  188.   {"n","","sts PR,<REG_N>", "0000nnnn00101010", "R[n]=PR;"},
  189.   {"n","n","sts.l MACH,@-<REG_N>", "0100nnnn00000010", "R[n]-=4;WLAT(R[n],MACH);"},
  190.   {"n","n","sts.l MACL,@-<REG_N>", "0100nnnn00010010", "R[n]-=4;WLAT(R[n],MACL);"},
  191.   {"n","n","sts.l PR,@-<REG_N>", "0100nnnn00100010", "R[n]-=4;WLAT(R[n],PR);"},
  192.   {"n","nm","sub <REG_M>,<REG_N>", "0011nnnnmmmm1000", "R[n]-=R[m];"},
  193. {"n","nm","subc <REG_M>,<REG_N>", "0011nnnnmmmm1010", "ult=R[n]-T;T=ult>R[n];R[n]=ult-R[m];T|=R[n]>ult;"},
  194.   {"n","nm","subv <REG_M>,<REG_N>", "0011nnnnmmmm1011",
  195.      "ult = R[n] - R[m]; T = (((R[n] ^ R[m]) & (ult ^ R[n])) >> 31); R[n] = ult;"},
  196.   {"n","nm","swap.b <REG_M>,<REG_N>", "0110nnnnmmmm1000", "R[n]=((R[m]<<8)&0xff00)|((R[m]>>8)&0x00ff);"},
  197.   {"n","nm","swap.w <REG_M>,<REG_N>", "0110nnnnmmmm1001", "R[n]=((R[m]<<16)&0xffff0000)|((R[m]>>16)&0x00ffff);"},
  198.   {"","n","tas.b @<REG_N>", "0100nnnn00011011", "ult=RBAT(R[n]);T=ult==0;WBAT(R[n],ult|0x80);"},
  199.   {"0","","trapa #<imm>", "11000011i8*1....", 
  200.      "{ long imm = 0xff & i; if (i==0xc3) PC-=2; if (i<20||i==34||i==0xc3) trap(i,R,memory,maskl,maskw,little_endian); else { R[15]-=4; WLAT(R[15],GET_SR()); R[15]-=4;WLAT(R[15],PC+2); PC=RLAT(VBR+(imm<<2))-2;}}"},
  201.   {"","0","tst #<imm>,R0", "11001000i8*1....", "T=(R0&i)==0;"},
  202.   {"","mn","tst <REG_M>,<REG_N>", "0010nnnnmmmm1000", "T=(R[n]&R[m])==0;"},
  203.   {"","0","tst.b #<imm>,@(R0,GBR)", "11001100i8*1....", "T=(RBAT(GBR+R0)&i)==0;"},
  204.   {"","0","xor #<imm>,R0", "11001010i8*1....", "R0^=i;"},
  205.   {"n","mn","xor <REG_M>,<REG_N>", "0010nnnnmmmm1010", "R[n]^=R[m];"},
  206.   {"","0","xor.b #<imm>,@(R0,GBR)", "11001110i8*1....", "ult=RBAT(GBR+R0);ult^=i;WBAT(GBR+R0,ult);"},
  207.   {"n","nm","xtrct <REG_M>,<REG_N>", "0010nnnnmmmm1101", "R[n]=((R[n]>>16)&0xffff)|((R[m]<<16)&0xffff0000);"},
  208.   {"","nm","mul.l <REG_M>,<REG_N>", "0000nnnnmmmm0111", " MACL = R[n] * R[m];"},
  209.   {"n","n","dt <REG_N>", "0100nnnn00010000", "R[n]--; T=R[n] == 0;"},
  210.   {"","nm","dmuls.l <REG_M>,<REG_N>", "0011nnnnmmmm1101", "dmul(1,R[n],R[m]);"},
  211.   {"","nm","dmulu.l <REG_M>,<REG_N>", "0011nnnnmmmm0101", "dmul(0,R[n],R[m]);"},
  212.   {"","nm","mac.l @<REG_M>+,@<REG_N>+", "0000nnnnmmmm1111", "trap(255,R0,memory,maskl,maskw,little_endian);"},
  213.   {"","n","braf <REG_N>", "0000nnnn00100011", "ult = PC; PC+=R[n]-2;SL(ult+2);"},
  214.   {"","n","bsrf <REG_N>", "0000nnnn00000011", "PR = PC + 4; PC+=R[n]-2;SL(PR-2);"},
  215. #if 0
  216.   {"divs.l <REG_M>,<REG_N>", "0100nnnnmmmm1110", "divl(0,R[n],R[m]);"},
  217.   {"divu.l <REG_M>,<REG_N>", "0100nnnnmmmm1101", "divl(0,R[n],R[m]);"},
  218. #endif
  219.  
  220.   {"", "", "fmov.s @<REG_M>,<FREG_N>", "1111nnnnmmmm1000", "*(int *)buf = RLAT(R[m]);F[n] = *(float *)buf;"},
  221.   {"", "", "fmov.s <FREG_M>,@<REG_N>", "1111nnnnmmmm1010", "*(float *)buf = F[m]; WLAT(R[n], *(int *)buf);"},
  222.   {"", "", "fmov.s @<REG_M>+,<FREG_N>", "1111nnnnmmmm1001", "*(int *)buf = RLAT(R[m]); F[n] = *(float *)buf; R[m] += 4;"},
  223.   {"", "", "fmov.s <FREG_M>,@-<REG_N>", "1111nnnnmmmm1011", "R[n] -= 4; *(float *)buf = F[m]; WLAT(R[n], *(int *)buf);"},
  224.   {"", "", "fmov.s @(R0,<REG_M>),<FREG_N>", "1111nnnnmmmm0110", "*(int *)buf = RLAT((R[0]+R[m]));F[n] = *(float *)buf;"},
  225.   {"", "", "fmov.s <FREG_M>,@(R0,<REG_N>)", "1111nnnnmmmm0111", "*(float *)buf = F[m]; WLAT((R[0]+R[n]), *(int *)buf);"},
  226.   {"", "", "fmov <FREG_M>,<FREG_N>", "1111nnnnmmmm1100", "F[n] = F[m];"},
  227.   {"", "", "fldi0 <FREG_N>", "1111nnnn10001101", "F[n] = (float)0.0;"},
  228.   {"", "", "fldi1 <FREG_N>", "1111nnnn10011101", "F[n] = (float)1.0;"},
  229.   {"", "", "fadd <FREG_M>,<FREG_N>", "1111nnnnmmmm0000","F[n] = F[n] + F[m];"},
  230.   {"", "", "fsub <FREG_M>,<FREG_N>", "1111nnnnmmmm0001","F[n] = F[n] - F[m];"},
  231.   {"", "", "fmul <FREG_M>,<FREG_N>", "1111nnnnmmmm0010","F[n] = F[n] * F[m];"},
  232.   {"", "", "fdiv <FREG_M>,<FREG_N>", "1111nnnnmmmm0011","F[n] = F[n] / F[m];"},
  233.   {"", "", "fmac <FREG_0>,<FREG_M>,<FREG_N>", "1111nnnnmmmm1110", "F[n] = F[m] * F[0] + F[n];"},
  234.   {"", "", "fcmp/eq <FREG_M>,<FREG_N>", "1111nnnnmmmm0100", "T = F[n] == F[m] ? 1 : 0;"},
  235.   {"", "", "fcmp/gt <FREG_M>,<FREG_N>", "1111nnnnmmmm0101", "T = F[n] > F[m] ? 1 : 0;"},
  236.   {"", "", "fneg <FREG_N>", "1111nnnn01001101", "F[n] = -F[n];"},
  237.   {"", "", "fabs <FREG_N>", "1111nnnn01011101", "F[n] = fabs (F[n]);"},
  238.   {"", "", "fsqrt <FREG_N>", "1111nnnn01101101", "F[n] = sqrt (F[n]);"},
  239.   {"", "", "float FPUL,<FREG_N>", "1111nnnn00101101", "F[n] = (float)FPUL;"},
  240.   {"", "", "ftrc <FREG_N>, FPUL", "1111nnnn00111101", "if (F[n] != F[n]) /* NaN */ FPUL = 0x80000000; else FPUL = (int)F[n];"},
  241.   {"", "", "ftst/nan <FREG_N>", "1111nnnn01111101", "T = isnan (F[n]);"},
  242.   {"", "", "fsts FPUL,<FREG_N>", "1111nnnn00001101", "*(int *)buf = FPUL; F[n] = *(float *)buf;"},
  243.   {"", "", "flds <FREG_N>,FPUL", "1111nnnn00011101", "*(float *)buf = F[n]; FPUL = *(int *)buf;"},
  244.   {"", "", "lds <REG_N>,FPUL", "0100nnnn01011010", "FPUL = R[n];"},
  245.   {"", "", "sts FPUL,<REG_N>", "0000nnnn01011010", "R[n] = FPUL;"},
  246.   {"", "", "lds <REG_N>,FPSCR", "0100nnnn01101010", "*(int *)buf = R[n]; FPSCR = *(float *)buf;"},
  247.   {"", "", "sts FPSCR,<REG_N>", "0000nnnn01101010", "*(float *)buf = FPSCR; R[n] = *(int *)buf;"},
  248.   {"","","lds.l @<REG_N>+,FPUL", "0100nnnn01010110", "FPUL = RLAT(R[n]);R[n]+=4;"},
  249.   {"","","lds.l @<REG_N>+,FPSCR", "0100nnnn01100110", "*(int *)buf = RLAT(R[n]); FPSCR = *(float *)buf; R[n]+=4;"},
  250.   {"","","sts.l FPUL,@-<REG_N>", "0100nnnn01010010", "R[n]-=4;WLAT(R[n],FPUL);"},
  251.   {"","","sts.l FPSCR,@-<REG_N>", "0100nnnn01100010", "R[n]-=4;*(float *)buf = FPSCR; WLAT(R[n],*(int *)buf);"},
  252.  
  253.   {0, 0}};
  254.  
  255. /* Tables of things to put into enums for sh-opc.h */
  256. static char *nibble_type_list[] =
  257. {
  258.   "HEX_0",
  259.   "HEX_1",
  260.   "HEX_2",
  261.   "HEX_3",
  262.   "HEX_4",
  263.   "HEX_5",
  264.   "HEX_6",
  265.   "HEX_7",
  266.   "HEX_8",
  267.   "HEX_9",
  268.   "HEX_A",
  269.   "HEX_B",
  270.   "HEX_C",
  271.   "HEX_D",
  272.   "HEX_E",
  273.   "HEX_F",
  274.   "REG_N",
  275.   "REG_M",
  276.   "BRANCH_12",
  277.   "BRANCH_8",
  278.   "DISP_8",
  279.   "DISP_4",
  280.   "IMM_4",
  281.   "IMM_4BY2",
  282.   "IMM_4BY4",
  283.   "PCRELIMM_8BY2",
  284.   "PCRELIMM_8BY4",
  285.   "IMM_8",
  286.   "IMM_8BY2",
  287.   "IMM_8BY4",
  288.   0
  289. };
  290. static
  291. char *arg_type_list[] =
  292. {
  293.   "A_END",
  294.   "A_BDISP12",
  295.   "A_BDISP8",
  296.   "A_DEC_M",
  297.   "A_DEC_N",
  298.   "A_DISP_GBR",
  299.   "A_DISP_PC",
  300.   "A_DISP_REG_M",
  301.   "A_DISP_REG_N",
  302.   "A_GBR",
  303.   "A_IMM",
  304.   "A_INC_M",
  305.   "A_INC_N",
  306.   "A_IND_M",
  307.   "A_IND_N",
  308.   "A_IND_R0_REG_M",
  309.   "A_IND_R0_REG_N",
  310.   "A_MACH",
  311.   "A_MACL",
  312.   "A_PR",
  313.   "A_R0",
  314.   "A_R0_GBR",
  315.   "A_REG_M",
  316.   "A_REG_N",
  317.   "A_SR",
  318.   "A_VBR",
  319.   "A_SSR",
  320.   "A_SPC",
  321.   0,
  322. };
  323.  
  324. static void
  325. make_enum_list (name, s)
  326.      char *name;
  327.      char **s;
  328. {
  329.   int i = 1;
  330.   printf ("typedef enum {\n");
  331.   while (*s)
  332.     {
  333.       printf ("\t%s,\n", *s);
  334.       s++;
  335.       i++;
  336.     }
  337.   printf ("} %s;\n", name);
  338. }
  339.  
  340. static int
  341. qfunc (a, b)
  342.      op *a;
  343.      op *b;
  344. {
  345.   char bufa[9];
  346.   char bufb[9];
  347.   memcpy (bufa, a->code, 4);
  348.   memcpy (bufa + 4, a->code + 12, 4);
  349.   bufa[8] = 0;
  350.  
  351.   memcpy (bufb, b->code, 4);
  352.   memcpy (bufb + 4, b->code + 12, 4);
  353.   bufb[8] = 0;
  354.   return (strcmp (bufa, bufb));
  355. }
  356.  
  357. static void
  358. sorttab ()
  359. {
  360.   op *p = tab;
  361.   int len = 0;
  362.  
  363.   while (p->name)
  364.     {
  365.       p++;
  366.       len++;
  367.     }
  368.   qsort (tab, len, sizeof (*p), qfunc);
  369. }
  370.  
  371. static void
  372. printonmatch (ptr, a, rep)
  373.      char **ptr;
  374.      char *a;
  375.      char *rep;
  376. {
  377.   int l = strlen (a);
  378.   if (strncmp (*ptr, a, l) == 0)
  379.     {
  380.       printf ("%s", rep);
  381.       *ptr += l;
  382.       if (**ptr)
  383.     printf (",");
  384.     }
  385. }
  386.  
  387.  
  388. static 
  389. void
  390. think (o)
  391.      op *o;
  392. {
  393.   char *n;
  394.   char *p;
  395.  
  396.   printf ("{\"");
  397.   n = o->name;
  398.   while (*n && *n != ' ')
  399.     {
  400.       printf ("%c", *n);
  401.       n++;
  402.     }
  403.   printf ("\",{");
  404.  
  405.   p = n;
  406.  
  407.   if (!*p)
  408.     {
  409.       printf ("0");
  410.     }
  411.   while (*p)
  412.     {
  413.       while (*p == ',' || *p == ' ')
  414.     p++;
  415.       printonmatch (&p, "#<imm>", "A_IMM");
  416.       printonmatch (&p, "R0", "A_R0");
  417.       printonmatch (&p, "<REG_N>", "A_REG_N");
  418.       printonmatch (&p, "@<REG_N>+", "A_INC_N");
  419.       printonmatch (&p, "@<REG_N>", "A_IND_N");
  420.       printonmatch (&p, "@-<REG_N>", "A_DEC_N");
  421.       printonmatch (&p, "<REG_M>", " A_REG_M");
  422.       printonmatch (&p, "@<REG_M>+", "A_INC_M");
  423.       printonmatch (&p, "@<REG_M>", "A_IND_M");
  424.       printonmatch (&p, "@-<REG_M>", "A_DEC_M");
  425.       printonmatch (&p, "@(<disp>,PC)", "A_DISP_PC");
  426.       printonmatch (&p, "@(<disp>,<REG_M>)", "A_DISP_REG_M");
  427.       printonmatch (&p, "@(<disp>,<REG_N>)", "A_DISP_REG_N");
  428.       printonmatch (&p, "@(R0,<REG_N>)", "A_IND_R0_REG_N");
  429.       printonmatch (&p, "@(R0,<REG_M>)", "A_IND_R0_REG_M");
  430.       printonmatch (&p, "@(<disp>,GBR)", "A_DISP_GBR");
  431.       printonmatch (&p, "@(R0,GBR)", "A_R0_GBR");
  432.       printonmatch (&p, "<bdisp8>", "A_BDISP8");
  433.       printonmatch (&p, "<bdisp12>", "A_BDISP12");
  434.       printonmatch (&p, "SR", "A_SR");
  435.       printonmatch (&p, "GBR", "A_GBR");
  436.       printonmatch (&p, "VBR", "A_VBR");
  437.       printonmatch (&p, "SSR", "A_SSR");
  438.       printonmatch (&p, "SPC", "A_SPC");
  439.       printonmatch (&p, "MACH", "A_MACH");
  440.       printonmatch (&p, "MACL", "A_MACL");
  441.       printonmatch (&p, "PR", "A_PR");
  442.  
  443.     }
  444.   printf ("},{");
  445.  
  446.   p = o->code;
  447.   while (*p)
  448.     {
  449.       printonmatch (&p, "0000", "HEX_0");
  450.       printonmatch (&p, "0001", "HEX_1");
  451.       printonmatch (&p, "0010", "HEX_2");
  452.       printonmatch (&p, "0011", "HEX_3");
  453.       printonmatch (&p, "0100", "HEX_4");
  454.       printonmatch (&p, "0101", "HEX_5");
  455.       printonmatch (&p, "0110", "HEX_6");
  456.       printonmatch (&p, "0111", "HEX_7");
  457.  
  458.       printonmatch (&p, "1000", "HEX_8");
  459.       printonmatch (&p, "1001", "HEX_9");
  460.       printonmatch (&p, "1010", "HEX_A");
  461.       printonmatch (&p, "1011", "HEX_B");
  462.       printonmatch (&p, "1100", "HEX_C");
  463.       printonmatch (&p, "1101", "HEX_D");
  464.       printonmatch (&p, "1110", "HEX_E");
  465.       printonmatch (&p, "1111", "HEX_F");
  466.       printonmatch (&p, "i8*1....", "IMM_8");
  467.       printonmatch (&p, "i4*1", "IMM_4");
  468.       printonmatch (&p, "i8p4....", "PCRELIMM_8BY4");
  469.       printonmatch (&p, "i8p2....", "PCRELIMM_8BY2");
  470.       printonmatch (&p, "i8*2....", "IMM_8BY2");
  471.       printonmatch (&p, "i4*2", "IMM_4BY2");
  472.       printonmatch (&p, "i8*4....", "IMM_8BY4");
  473.       printonmatch (&p, "i4*4", "IMM_4BY4");
  474.       printonmatch (&p, "i12.........", "BRANCH_12");
  475.       printonmatch (&p, "i8p1....", "BRANCH_8");
  476.       printonmatch (&p, "nnnn", "REG_N");
  477.       printonmatch (&p, "mmmm", "REG_M");
  478.  
  479.     }
  480.   printf ("}},\n");
  481. }
  482.  
  483. static void
  484. gengastab ()
  485. {
  486.   op *p;
  487.   sorttab ();
  488.   for (p = tab; p->name; p++)
  489.     {
  490.       printf ("%s %-30s\n", p->code, p->name);
  491.     }
  492.  
  493.  
  494. }
  495.  
  496.  
  497. static void
  498. genopc ()
  499. {
  500.   op *p;
  501.   make_enum_list ("sh_nibble_type", nibble_type_list);
  502.   make_enum_list ("sh_arg_type", arg_type_list);
  503.  
  504.   printf ("typedef struct {\n");
  505.   printf ("char *name;\n");
  506.   printf ("sh_arg_type arg[3];\n");
  507.   printf ("sh_nibble_type nibbles[4];\n");
  508.   printf ("} sh_opcode_info;\n");
  509.   printf ("#ifdef DEFINE_TABLE\n");
  510.   printf ("sh_opcode_info sh_table[]={\n");
  511.   for (p = tab; p->name; p++)
  512.     {
  513.       printf ("\n/* %s %-20s*/", p->code, p->name);
  514.       think (p);
  515.     }
  516.   printf ("0};\n");
  517.   printf ("#endif\n");
  518. }
  519.  
  520.  
  521.  
  522.  
  523.  
  524.  
  525. /* Convert a string of 4 binary digits into an int */
  526.  
  527. static
  528. int
  529. bton (s)
  530.      char *s;
  531.  
  532. {
  533.   int n = 0;
  534.   int v = 8;
  535.   while (v)
  536.     {
  537.       if (*s == '1')
  538.     n |= v;
  539.       v >>= 1;
  540.       s++;
  541.     }
  542.   return n;
  543. }
  544.  
  545. static unsigned char table[1 << 16];
  546.  
  547. /* Take an opcode expand all varying fields in it out and fill all the
  548.   right entries in 'table' with the opcode index*/
  549.  
  550. static void
  551. expand_opcode (shift, val, i, s)
  552.      int shift;
  553.      int val;
  554.      int i;
  555.      char *s;
  556. {
  557.   int j;
  558.  
  559.   if (*s == 0)
  560.     {
  561.       table[val] = i;
  562.     }
  563.   else
  564.     {
  565.       switch (s[0])
  566.     {
  567.  
  568.     case '0':
  569.     case '1':
  570.       {
  571.  
  572.         int n = bton (s);
  573.         if (n >= 0)
  574.           {
  575.         expand_opcode (shift - 4, val | (n << shift), i, s + 4);
  576.           }
  577.         break;
  578.       }
  579.     case 'n':
  580.     case 'm':
  581.       for (j = 0; j < 16; j++)
  582.         {
  583.           expand_opcode (shift - 4, val | (j << shift), i, s + 4);
  584.  
  585.         }
  586.       break;
  587.  
  588.     default:
  589.       for (j = 0; j < (1 << (shift + 4)); j++)
  590.         {
  591.           table[val | j] = i;
  592.         }
  593.     }
  594.     }
  595. }
  596.  
  597. /* Print the jump table used to index an opcode into a switch
  598.    statement entry. */
  599.  
  600. static void
  601. dumptable ()
  602. {
  603.   int lump = 256;
  604.   int online = 16;
  605.  
  606.   int i = 0;
  607.  
  608.   while (i < 1 << 16)
  609.     {
  610.       int j = 0;
  611.  
  612.       printf ("unsigned char sh_jump_table%x[%d]={\n", i, lump);
  613.  
  614.       while (j < lump)
  615.     {
  616.       int k = 0;
  617.       while (k < online)
  618.         {
  619.           printf ("%2d", table[i + j + k]);
  620.           if (j + k < lump)
  621.         printf (",");
  622.  
  623.           k++;
  624.         }
  625.       j += k;
  626.       printf ("\n");
  627.     }
  628.       i += j;
  629.       printf ("};\n");
  630.     }
  631.  
  632. }
  633.  
  634.  
  635. static void
  636. filltable ()
  637. {
  638.   op *p;
  639.   int index = 1;
  640.  
  641.   sorttab ();
  642.   for (p = tab; p->name; p++)
  643.     {
  644.       p->index = index++;
  645.       expand_opcode (12, 0, p->index, p->code);
  646.     }
  647. }
  648.  
  649. static void
  650. gensim ()
  651. {
  652.   op *p;
  653.   int j;
  654.  
  655.   printf ("{\n");
  656.   printf("char buf[4];\n");
  657.   printf ("switch (jump_table[iword]) {\n");
  658.  
  659.   for (p = tab; p->name; p++)
  660.     {
  661.       int sextbit = -1;
  662.       int needm = 0;
  663.       int needn = 0;
  664.       
  665.       char *s = p->code;
  666.  
  667.       printf ("/* %s %s */\n", p->name, p->code);
  668.       printf ("case %d:      \n", p->index);
  669.  
  670.       printf ("{\n");
  671.       while (*s)
  672.     {
  673.       switch (*s)
  674.         {
  675.         case '0':
  676.         case '1':
  677.         case '.':
  678.           s += 4;
  679.           break;
  680.         case 'n':
  681.           printf ("int n =  (iword >>8) & 0xf;\n");
  682.           needn = 1;
  683.           s += 4;
  684.           break;
  685.         case 'm':
  686.           printf ("int m =  (iword >>4) & 0xf;\n");
  687.           needm = 1;
  688.           s += 4;
  689.  
  690.           break;
  691.  
  692.         case 'i':
  693.           printf ("int i = (iword & 0x");
  694.  
  695.           switch (s[1])
  696.         {
  697.         case '4':
  698.           printf ("f");
  699.           break;
  700.         case '8':
  701.           printf ("ff");
  702.           break;
  703.         case '1':
  704.           sextbit = 12;
  705.  
  706.           printf ("fff");
  707.           break;
  708.         }
  709.           printf (")");
  710.  
  711.           switch (s[3])
  712.         {
  713.         case '1':
  714.           break;
  715.         case '2':
  716.           printf ("<<1");
  717.           break;
  718.         case '4':
  719.           printf ("<<2");
  720.           break;
  721.         }
  722.           printf (";\n");
  723.           s += 4;
  724.         }
  725.     }
  726.       if (sextbit > 0)
  727.     {
  728.       printf ("i = (i ^ (1<<%d))-(1<<%d);\n", sextbit - 1, sextbit - 1);
  729.     }
  730.       if (needm && needn)
  731.     printf("TB(m,n);");  
  732.       else if (needm)
  733.     printf("TL(m);");
  734.       else if (needn)
  735.     printf("TL(n);");
  736.       for (j = 0; j < 10; j++)
  737.     {
  738.       if (p->stuff[j])
  739.         {
  740.           printf ("%s\n", p->stuff[j]);
  741.         }
  742.     }
  743.  
  744.       
  745.       {
  746.     /* Do the defs and refs */
  747.     char *r;
  748.     for (r = p->refs; *r; r++) {
  749.      if (*r == '0') printf("CREF(0);\n"); 
  750.      if (*r == 'n') printf("CREF(n);\n"); 
  751.      if (*r == 'm') printf("CREF(m);\n"); 
  752.      
  753.     }
  754.     for (r = p->defs; *r; r++) 
  755.       {
  756.      if (*r == '0') printf("CDEF(0);\n"); 
  757.      if (*r == 'n') printf("CDEF(n);\n"); 
  758.      if (*r == 'm') printf("CDEF(m);\n"); 
  759.      
  760.     }
  761.  
  762.       }
  763.       printf ("break;\n");
  764.       printf ("}\n");
  765.     }
  766.   printf("default:\n{\nsaved_state.asregs.exception = SIGILL;\n}\n");
  767.   printf ("}\n}\n");
  768. }
  769.  
  770.  
  771. static void
  772. gendefines ()
  773. {
  774.   op *p;
  775.   filltable();
  776.   for (p = tab; p->name; p++)
  777.     {
  778.       char *s = p->name;
  779.       printf ("#define OPC_");
  780.       while (*s) {
  781.     if (isupper(*s)) 
  782.       *s = tolower(*s);
  783.     if (isalpha(*s)) printf("%c", *s);
  784.     if (*s == ' ') printf("_");
  785.     if (*s == '@') printf("ind_");
  786.     if (*s == ',') printf("_");
  787.     s++;
  788.       }
  789.       printf(" %d\n",p->index);
  790.     }
  791. }
  792.  
  793. int
  794. main (ac, av)
  795.      int ac;
  796.      char **av;
  797. {
  798.   if (ac > 1)
  799.     {
  800.       if (strcmp (av[1], "-t") == 0)
  801.     {
  802.       gengastab ();
  803.     }
  804.       else if (strcmp (av[1], "-d") == 0)
  805.     {
  806.       gendefines ();
  807.     }
  808.       else if (strcmp (av[1], "-s") == 0)
  809.     {
  810.       filltable ();
  811.       dumptable ();
  812.  
  813.     }
  814.       else if (strcmp (av[1], "-x") == 0)
  815.     {
  816.       filltable ();
  817.       gensim ();
  818.     }
  819.     }
  820.   else
  821.     {
  822.       genopc ();
  823.     }
  824.   return 0;
  825. }
  826.