1 /* Simulator/Opcode generator for the Hitachi Super-H architecture.
3 Written by Steve Chamberlain of Cygnus Support.
6 This file is part of SH sim
9 THIS SOFTWARE IS NOT COPYRIGHTED
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.
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.
21 /* This program generates the opcode table for the assembler and
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
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);"},
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", "abort();"},
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);"},
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]);"},
220 /* start-sanitize-sh3e */
221 {"", "", "fmov.s @<REG_M>,<FREG_N>", "1111nnnnmmmm1000", "*(int *)buf = RLAT(R[m]);F[n] = *(float *)buf;"},
222 {"", "", "fmov.s <FREG_M>,@<REG_N>", "1111nnnnmmmm1010", "*(float *)buf = F[m]; WLAT(R[n], *(int *)buf);"},
223 {"", "", "fmov.s @<REG_M>+,<FREG_N>", "1111nnnnmmmm1001", "*(int *)buf = RLAT(R[m]); F[n] = *(float *)buf; R[m] += 4;"},
224 {"", "", "fmov.s <FREG_M>,@-<REG_N>", "1111nnnnmmmm1011", "R[n] -= 4; *(float *)buf = F[m]; WLAT(R[n], *(int *)buf);"},
225 {"", "", "fmov.s @(R0,<REG_M>),<FREG_N>", "1111nnnnmmmm0110", "*(int *)buf = RLAT((R[0]+R[m]));F[n] = *(float *)buf;"},
226 {"", "", "fmov.s <FREG_M>,@(R0,<REG_N>)", "1111nnnnmmmm0111", "*(float *)buf = F[m]; WLAT((R[0]+R[n]), *(int *)buf);"},
227 {"", "", "fmov <FREG_M>,<FREG_N>", "1111nnnnmmmm1100", "F[n] = F[m];"},
228 {"", "", "fldi0 <FREG_N>", "1111nnnn10001101", "F[n] = (float)0.0;"},
229 {"", "", "fldi1 <FREG_N>", "1111nnnn10011101", "F[n] = (float)1.0;"},
230 {"", "", "fadd <FREG_M>,<FREG_N>", "1111nnnnmmmm0000","F[n] = F[n] + F[m];"},
231 {"", "", "fsub <FREG_M>,<FREG_N>", "1111nnnnmmmm0001","F[n] = F[n] - F[m];"},
232 {"", "", "fmul <FREG_M>,<FREG_N>", "1111nnnnmmmm0010","F[n] = F[n] * F[m];"},
233 {"", "", "fdiv <FREG_M>,<FREG_N>", "1111nnnnmmmm0011","F[n] = F[n] / F[m];"},
234 {"", "", "fmac <FREG_0>,<FREG_M>,<FREG_N>", "1111nnnnmmmm1110", "F[n] = F[m] * F[0] + F[n];"},
235 {"", "", "fcmp/eq <FREG_M>,<FREG_N>", "1111nnnnmmmm0100", "T = F[n] == F[m] ? 1 : 0;"},
236 {"", "", "fcmp/gt <FREG_M>,<FREG_N>", "1111nnnnmmmm0101", "T = F[n] > F[m] ? 1 : 0;"},
237 {"", "", "fneg <FREG_N>", "1111nnnn01001101", "F[n] = -F[n];"},
238 {"", "", "fabs <FREG_N>", "1111nnnn01011101", "F[n] = fabs (F[n]);"},
239 {"", "", "fsqrt <FREG_N>", "1111nnnn01101101", "F[n] = sqrt (F[n]);"},
240 {"", "", "float FPUL,<FREG_N>", "1111nnnn00101101", "F[n] = (float)FPUL;"},
241 {"", "", "ftrc <FREG_N>, FPUL", "1111nnnn00111101", "if (F[n] != F[n]) /* NaN */ FPUL = 0x80000000; else FPUL = (int)F[n];"},
242 {"", "", "ftst/nan <FREG_N>", "1111nnnn01111101", "T = isnan (F[n]);"},
243 {"", "", "fsts FPUL,<FREG_N>", "1111nnnn00001101", "*(int *)buf = FPUL; F[n] = *(float *)buf;"},
244 {"", "", "flds <FREG_N>,FPUL", "1111nnnn00011101", "*(float *)buf = F[n]; FPUL = *(int *)buf;"},
245 {"", "", "lds <REG_N>,FPUL", "0100nnnn01011010", "FPUL = R[n];"},
246 {"", "", "sts FPUL,<REG_N>", "0000nnnn01011010", "R[n] = FPUL;"},
247 {"", "", "lds <REG_N>,FPSCR", "0100nnnn01101010", "*(int *)buf = R[n]; FPSCR = *(float *)buf;"},
248 {"", "", "sts FPSCR,<REG_N>", "0000nnnn01101010", "*(float *)buf = FPSCR; R[n] = *(int *)buf;"},
249 {"","","lds.l @<REG_N>+,FPUL", "0100nnnn01010110", "FPUL = RLAT(R[n]);R[n]+=4;"},
250 {"","","lds.l @<REG_N>+,FPSCR", "0100nnnn01100110", "*(int *)buf = RLAT(R[n]); FPSCR = *(float *)buf; R[n]+=4;"},
251 {"","","sts.l FPUL,@-<REG_N>", "0100nnnn01010010", "R[n]-=4;WLAT(R[n],FPUL);"},
252 {"","","sts.l FPSCR,@-<REG_N>", "0100nnnn01100010", "R[n]-=4;*(float *)buf = FPSCR; WLAT(R[n],*(int *)buf);"},
253 /* end-sanitize-sh3e */
257 /* Tables of things to put into enums for sh-opc.h */
258 static char *nibble_type_list[] =
293 char *arg_type_list[] =
327 make_enum_list (name, s)
332 printf ("typedef enum {\n");
335 printf ("\t%s,\n", *s);
339 printf ("} %s;\n", name);
349 memcpy (bufa, a->code, 4);
350 memcpy (bufa + 4, a->code + 12, 4);
353 memcpy (bufb, b->code, 4);
354 memcpy (bufb + 4, b->code + 12, 4);
356 return (strcmp (bufa, bufb));
370 qsort (tab, len, sizeof (*p), qfunc);
374 printonmatch (ptr, a, rep)
380 if (strncmp (*ptr, a, l) == 0)
400 while (*n && *n != ' ')
415 while (*p == ',' || *p == ' ')
417 printonmatch (&p, "#<imm>", "A_IMM");
418 printonmatch (&p, "R0", "A_R0");
419 printonmatch (&p, "<REG_N>", "A_REG_N");
420 printonmatch (&p, "@<REG_N>+", "A_INC_N");
421 printonmatch (&p, "@<REG_N>", "A_IND_N");
422 printonmatch (&p, "@-<REG_N>", "A_DEC_N");
423 printonmatch (&p, "<REG_M>", " A_REG_M");
424 printonmatch (&p, "@<REG_M>+", "A_INC_M");
425 printonmatch (&p, "@<REG_M>", "A_IND_M");
426 printonmatch (&p, "@-<REG_M>", "A_DEC_M");
427 printonmatch (&p, "@(<disp>,PC)", "A_DISP_PC");
428 printonmatch (&p, "@(<disp>,<REG_M>)", "A_DISP_REG_M");
429 printonmatch (&p, "@(<disp>,<REG_N>)", "A_DISP_REG_N");
430 printonmatch (&p, "@(R0,<REG_N>)", "A_IND_R0_REG_N");
431 printonmatch (&p, "@(R0,<REG_M>)", "A_IND_R0_REG_M");
432 printonmatch (&p, "@(<disp>,GBR)", "A_DISP_GBR");
433 printonmatch (&p, "@(R0,GBR)", "A_R0_GBR");
434 printonmatch (&p, "<bdisp8>", "A_BDISP8");
435 printonmatch (&p, "<bdisp12>", "A_BDISP12");
436 printonmatch (&p, "SR", "A_SR");
437 printonmatch (&p, "GBR", "A_GBR");
438 printonmatch (&p, "VBR", "A_VBR");
439 printonmatch (&p, "SSR", "A_SSR");
440 printonmatch (&p, "SPC", "A_SPC");
441 printonmatch (&p, "MACH", "A_MACH");
442 printonmatch (&p, "MACL", "A_MACL");
443 printonmatch (&p, "PR", "A_PR");
451 printonmatch (&p, "0000", "HEX_0");
452 printonmatch (&p, "0001", "HEX_1");
453 printonmatch (&p, "0010", "HEX_2");
454 printonmatch (&p, "0011", "HEX_3");
455 printonmatch (&p, "0100", "HEX_4");
456 printonmatch (&p, "0101", "HEX_5");
457 printonmatch (&p, "0110", "HEX_6");
458 printonmatch (&p, "0111", "HEX_7");
460 printonmatch (&p, "1000", "HEX_8");
461 printonmatch (&p, "1001", "HEX_9");
462 printonmatch (&p, "1010", "HEX_A");
463 printonmatch (&p, "1011", "HEX_B");
464 printonmatch (&p, "1100", "HEX_C");
465 printonmatch (&p, "1101", "HEX_D");
466 printonmatch (&p, "1110", "HEX_E");
467 printonmatch (&p, "1111", "HEX_F");
468 printonmatch (&p, "i8*1....", "IMM_8");
469 printonmatch (&p, "i4*1", "IMM_4");
470 printonmatch (&p, "i8p4....", "PCRELIMM_8BY4");
471 printonmatch (&p, "i8p2....", "PCRELIMM_8BY2");
472 printonmatch (&p, "i8*2....", "IMM_8BY2");
473 printonmatch (&p, "i4*2", "IMM_4BY2");
474 printonmatch (&p, "i8*4....", "IMM_8BY4");
475 printonmatch (&p, "i4*4", "IMM_4BY4");
476 printonmatch (&p, "i12.........", "BRANCH_12");
477 printonmatch (&p, "i8p1....", "BRANCH_8");
478 printonmatch (&p, "nnnn", "REG_N");
479 printonmatch (&p, "mmmm", "REG_M");
490 for (p = tab; p->name; p++)
492 printf ("%s %-30s\n", p->code, p->name);
503 make_enum_list ("sh_nibble_type", nibble_type_list);
504 make_enum_list ("sh_arg_type", arg_type_list);
506 printf ("typedef struct {\n");
507 printf ("char *name;\n");
508 printf ("sh_arg_type arg[3];\n");
509 printf ("sh_nibble_type nibbles[4];\n");
510 printf ("} sh_opcode_info;\n");
511 printf ("#ifdef DEFINE_TABLE\n");
512 printf ("sh_opcode_info sh_table[]={\n");
513 for (p = tab; p->name; p++)
515 printf ("\n/* %s %-20s*/", p->code, p->name);
527 /* Convert a string of 4 binary digits into an int */
547 static unsigned char table[1 << 16];
549 /* Take an opcode expand all varying fields in it out and fill all the
550 right entries in 'table' with the opcode index*/
553 expand_opcode (shift, val, i, s)
577 expand_opcode (shift - 4, val | (n << shift), i, s + 4);
583 for (j = 0; j < 16; j++)
585 expand_opcode (shift - 4, val | (j << shift), i, s + 4);
591 for (j = 0; j < (1 << (shift + 4)); j++)
599 /* Print the jump table used to index an opcode into a switch
614 printf ("unsigned char sh_jump_table%x[%d]={\n", i, lump);
621 printf ("%2d", table[i + j + k]);
644 for (p = tab; p->name; p++)
647 expand_opcode (12, 0, p->index, p->code);
658 /* start-sanitize-sh3e */
659 printf("char buf[4];\n");
660 /* end-sanitize-sh3e */
661 printf ("switch (jump_table[iword]) {\n");
663 for (p = tab; p->name; p++)
671 printf ("/* %s %s */\n", p->name, p->code);
672 printf ("case %d: \n", p->index);
685 printf ("int n = (iword >>8) & 0xf;\n");
690 printf ("int m = (iword >>4) & 0xf;\n");
697 printf ("int i = (iword & 0x");
732 printf ("i = (i ^ (1<<%d))-(1<<%d);\n", sextbit - 1, sextbit - 1);
740 for (j = 0; j < 10; j++)
744 printf ("%s\n", p->stuff[j]);
750 /* Do the defs and refs */
752 for (r = p->refs; *r; r++) {
753 if (*r == '0') printf("CREF(0);\n");
754 if (*r == 'n') printf("CREF(n);\n");
755 if (*r == 'm') printf("CREF(m);\n");
758 for (r = p->defs; *r; r++)
760 if (*r == '0') printf("CDEF(0);\n");
761 if (*r == 'n') printf("CDEF(n);\n");
762 if (*r == 'm') printf("CDEF(m);\n");
770 printf("default:\n{\nsaved_state.asregs.exception = SIGILL;\n}\n");
780 for (p = tab; p->name; p++)
783 printf ("#define OPC_");
787 if (isalpha(*s)) printf("%c", *s);
788 if (*s == ' ') printf("_");
789 if (*s == '@') printf("ind_");
790 if (*s == ',') printf("_");
793 printf(" %d\n",p->index);
804 if (strcmp (av[1], "-t") == 0)
808 else if (strcmp (av[1], "-d") == 0)
812 else if (strcmp (av[1], "-s") == 0)
818 else if (strcmp (av[1], "-x") == 0)