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; 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 {"","","clrt", "0000000000001000", "T= 0;"},
68 {"","0","cmp/eq #<imm>,R0", "10001000i8*1....", ";T = R0 == SEXT(i);"},
69 {"","mn","cmp/eq <REG_M>,<REG_N>", "0011nnnnmmmm0000", "T=R[n]==R[m];"},
70 {"","mn","cmp/ge <REG_M>,<REG_N>", "0011nnnnmmmm0011", "T=R[n]>=R[m];"},
71 {"","mn","cmp/gt <REG_M>,<REG_N>", "0011nnnnmmmm0111", "T=R[n]>R[m];"},
72 {"","mn","cmp/hi <REG_M>,<REG_N>", "0011nnnnmmmm0110", "T=UR[n]>UR[m];"},
73 {"","mn","cmp/hs <REG_M>,<REG_N>", "0011nnnnmmmm0010", "T=UR[n]>=UR[m];"},
74 {"","n","cmp/pl <REG_N>", "0100nnnn00010101", "T = R[n]>0;"},
75 {"","n","cmp/pz <REG_N>", "0100nnnn00010001", "T = R[n]>=0;"},
76 {"","mn","cmp/str <REG_M>,<REG_N>", "0010nnnnmmmm1100",
77 "ult = R[n] ^ R[m]; T=((ult&0xff000000)==0) |((ult&0xff0000)==0) |((ult&0xff00)==0) |((ult&0xff)==0); "},
78 {"","mn","div0s <REG_M>,<REG_N>", "0010nnnnmmmm0111", "Q=(R[n]&sbit)!=0; M=(R[m]&sbit)!=0; T=M!=Q;;"},
79 {"","","div0u", "0000000000011001", "M=Q=T=0;"},
80 {"","","div1 <REG_M>,<REG_N>", "0011nnnnmmmm0100", "T=div1(R,m,n,T);"},
81 {"n","m","exts.b <REG_M>,<REG_N>", "0110nnnnmmmm1110", "R[n] = SEXT(R[m]);"},
82 {"n","m","exts.w <REG_M>,<REG_N>", "0110nnnnmmmm1111", "R[n] = SEXTW(R[m]);"},
83 {"n","m","extu.b <REG_M>,<REG_N>", "0110nnnnmmmm1100", "R[n] = R[m] & 0xff;"},
84 {"n","m","extu.w <REG_M>,<REG_N>", "0110nnnnmmmm1101", "R[n] = R[m] & 0xffff;"},
85 {"","n","jmp @<REG_N>", "0100nnnn00101011", "ult = PC; PC=R[n]-2; SL(ult+2);"},
86 {"","n","jsr @<REG_N>", "0100nnnn00001011", "PR = PC + 4; PC=R[n]-2; if (~doprofile) gotcall(PR,PC+2);SL(PR-2);"},
87 {"","n","ldc <REG_N>,GBR", "0100nnnn00011110", "GBR=R[n];"},
88 {"","n","ldc <REG_N>,SR", "0100nnnn00001110", "SET_SR(R[n]);"},
89 {"","n","ldc <REG_N>,VBR", "0100nnnn00101110", "VBR=R[n];"},
90 {"","n","ldc.l @<REG_N>+,GBR", "0100nnnn00010111", "GBR=RLAT(R[n]);R[n]+=4;;"},
91 {"","n","ldc.l @<REG_N>+,SR", "0100nnnn00000111", "SET_SR(RLAT(R[n]));R[n]+=4;;"},
92 {"","n","ldc.l @<REG_N>+,VBR", "0100nnnn00100111", "VBR=RLAT(R[n]);R[n]+=4;;"},
93 {"","n","lds <REG_N>,MACH", "0100nnnn00001010", "MACH = R[n];"},
94 {"","n","lds <REG_N>,MACL", "0100nnnn00011010", "MACL= R[n];"},
95 {"","n","lds <REG_N>,PR", "0100nnnn00101010", "PR = R[n];"},
96 {"","n","lds.l @<REG_N>+,MACH", "0100nnnn00000110", "MACH = SEXT(RLAT(R[n]));R[n]+=4;"},
97 {"","n","lds.l @<REG_N>+,MACL", "0100nnnn00010110", "MACL = RLAT(R[n]);R[n]+=4;"},
98 {"","n","lds.l @<REG_N>+,PR", "0100nnnn00100110", "PR = RLAT(R[n]);R[n]+=4;;"},
99 {"","n","mac.w @<REG_M>+,@<REG_N>+", "0100nnnnmmmm1111", "macw(R0,memory,n,m);"},
100 {"n","","mov #<imm>,<REG_N>", "1110nnnni8*1....", "R[n] = SEXT(i);"},
101 {"n","m","mov <REG_M>,<REG_N>", "0110nnnnmmmm0011", "R[n] = R[m];"},
102 {"","mn0","mov.b <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0100", "WBAT(R[n]+R0, R[m]);"},
103 {"","nm","mov.b <REG_M>,@-<REG_N>", "0010nnnnmmmm0100", "R[n]--; WBAT(R[n],R[m]);"},
104 {"","mn","mov.b <REG_M>,@<REG_N>", "0010nnnnmmmm0000", "WBAT(R[n], R[m]);"},
105 {"0","m","mov.b @(<disp>,<REG_M>),R0", "10000100mmmmi4*1", "R0=RSBAT(i+R[m]);L(0);"},
106 {"0","","mov.b @(<disp>,GBR),R0", "11000100i8*1....", "R0=RSBAT(i+GBR);L(0);"},
107 {"n","0m","mov.b @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1100", "R[n]=RSBAT(R0+R[m]);L(n);"},
108 {"n","m","mov.b @<REG_M>+,<REG_N>", "0110nnnnmmmm0100", "R[n] = RSBAT(R[m]);L(n);R[m]++;"},
109 {"n","m","mov.b @<REG_M>,<REG_N>", "0110nnnnmmmm0000", "R[n]=RSBAT(R[m]);L(n);"},
110 {"","m0","mov.b R0,@(<disp>,<REG_M>)", "10000000mmmmi4*1", "WBAT(i+R[m],R0);"},
111 {"","0","mov.b R0,@(<disp>,GBR)", "11000000i8*1....", "WBAT(i+GBR,R0);"},
112 {"","nm","mov.l <REG_M>,@(<disp>,<REG_N>)", "0001nnnnmmmmi4*4", "WLAT(i+R[n],R[m]);"},
113 {"","nm0","mov.l <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0110", "WLAT(R0+R[n],R[m]);"},
114 {"","nm","mov.l <REG_M>,@-<REG_N>", "0010nnnnmmmm0110", "R[n]-=4;WLAT(R[n],R[m]);"},
115 {"","nm","mov.l <REG_M>,@<REG_N>", "0010nnnnmmmm0010", "WLAT(R[n], R[m]);"},
116 {"n","m","mov.l @(<disp>,<REG_M>),<REG_N>","0101nnnnmmmmi4*4", "R[n]=RLAT(i+R[m]);L(n);"},
117 {"0","","mov.l @(<disp>,GBR),R0", "11000110i8*4....", "R0=RLAT(i+GBR);L(0);"},
118 {"n","","mov.l @(<disp>,PC),<REG_N>", "1101nnnni8p4....", "R[n]=RLAT((i+4+PC) & ~3);L(n);"},
119 {"n","m","mov.l @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1110", "R[n]=RLAT(R0+R[m]);L(n);"},
120 {"nm","m","mov.l @<REG_M>+,<REG_N>", "0110nnnnmmmm0110", "R[n]=RLAT(R[m]);R[m]+=4;L(n);"},
121 {"n","m","mov.l @<REG_M>,<REG_N>", "0110nnnnmmmm0010", "R[n]=RLAT(R[m]);L(n);"},
122 {"","0","mov.l R0,@(<disp>,GBR)", "11000010i8*4....", "WLAT(i+GBR,R0);"},
123 {"","m0n","mov.w <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0101", "WWAT(R0+R[n],R[m]);"},
124 {"n","mn","mov.w <REG_M>,@-<REG_N>", "0010nnnnmmmm0101", "R[n]-=2;WWAT(R[n],R[m]);"},
125 {"","nm","mov.w <REG_M>,@<REG_N>", "0010nnnnmmmm0001", "WWAT(R[n],R[m]);"},
126 {"0","m","mov.w @(<disp>,<REG_M>),R0", "10000101mmmmi4*2", "R0=RSWAT(i+R[m]);L(0);"},
127 {"0","","mov.w @(<disp>,GBR),R0", "11000101i8*2....", "R0=RSWAT(i+GBR);L(0);"},
128 {"n","","mov.w @(<disp>,PC),<REG_N>", "1001nnnni8p2....", "R[n]=RSWAT(PC+i+4);L(n);"},
129 {"n","m0","mov.w @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1101", "R[n]=RSWAT(R0+R[m]);L(n);"},
130 {"nm","n","mov.w @<REG_M>+,<REG_N>", "0110nnnnmmmm0101", "R[n]=RSWAT(R[m]);R[m]+=2;L(n);"},
131 {"n","m","mov.w @<REG_M>,<REG_N>", "0110nnnnmmmm0001", "R[n]=RSWAT(R[m]);L(n);"},
132 {"","0m","mov.w R0,@(<disp>,<REG_M>)", "10000001mmmmi4*2", "WWAT(i+R[m],R0);"},
133 {"","0","mov.w R0,@(<disp>,GBR)", "11000001i8*2....", "WWAT(i+GBR,R0);"},
134 {"0","","mova @(<disp>,PC),R0", "11000111i8p4....", "R0=((i+4+PC) & ~0x3);"},
135 {"n","","movt <REG_N>", "0000nnnn00101001", "R[n]=T;"},
136 {"","mn","muls <REG_M>,<REG_N>", "0010nnnnmmmm1111","MACL=((int)(short)R[n])*((int)(short)R[m]);"},
137 {"","mn","mul.l <REG_M>,<REG_N>","0000nnnnmmmm0111","MACL=((int)R[n])*((int)R[m]);"},
138 {"","mn","mulu <REG_M>,<REG_N>", "0010nnnnmmmm1110","MACL=((unsigned int)(unsigned short)R[n])*((unsigned int)(unsigned short)R[m]);"},
139 {"n","m","neg <REG_M>,<REG_N>", "0110nnnnmmmm1011", "R[n] = - R[m];"},
140 {"n","m","negc <REG_M>,<REG_N>", "0110nnnnmmmm1010", "ult=-T;T=ult>0;R[n]=ult-R[m];T|=R[n]>ult;"},
141 {"","","nop", "0000000000001001", ""},
142 {"n","m","not <REG_M>,<REG_N>", "0110nnnnmmmm0111", "R[n]=~R[m];"},
143 {"0","","or #<imm>,R0", "11001011i8*1....", "R0|=i;"},
144 {"n","m","or <REG_M>,<REG_N>", "0010nnnnmmmm1011", "R[n]|=R[m];"},
145 {"","0","or.b #<imm>,@(R0,GBR)", "11001111i8*1....", "WBAT(R0+GBR,RBAT(R0+GBR)|i);"},
146 {"n","n","rotcl <REG_N>", "0100nnnn00100100", "ult=R[n]<0;R[n]=(R[n]<<1)|T;T=ult;"},
147 {"n","n","rotcr <REG_N>", "0100nnnn00100101", "ult=R[n]&1;R[n]=(UR[n]>>1)|(T<<31);T=ult;"},
148 {"n","n","rotl <REG_N>", "0100nnnn00000100", "T=R[n]<0;R[n]<<=1;R[n]|=T;"},
149 {"n","n","rotr <REG_N>", "0100nnnn00000101", "T=R[n]&1;R[n] = UR[n]>> 1;R[n]|=(T<<31);"},
150 {"","","rte", "0000000000101011",
151 "{ int tmp = PC; PC=RLAT(R[15])+2;R[15]+=4;SET_SR(RLAT(R[15]) & 0x3f3);R[15]+=4;SL(tmp+2);}"},
152 {"","","rts", "0000000000001011", "ult=PC;PC=PR;SL(ult+2);"},
153 {"","","sett", "0000000000011000", "T=1;"},
154 {"n","mn","shad <REG_M>,<REG_N>", "0100nnnnmmmm1100",
155 "R[n] = (R[m] < 0) ? (((int)R[n]) >> -(R[m]&0x1f) ): (R[n] << ((R[m]) & 0x1f)) ;"},
156 {"n","mn","shld <REG_M>,<REG_N>", "0100nnnnmmmm1101",
157 "R[n] = (R[m] < 0) ? (((unsigned int)R[n]) >> -(R[m]&0x1f) ): (R[n] << ((R[m]) & 0x1f)) ;"},
158 {"n","n","shal <REG_N>", "0100nnnn00100000", "T=R[n]<0; R[n]<<=1;"},
159 {"n","n","shar <REG_N>", "0100nnnn00100001", "T=R[n]&1; R[n] = R[n] >> 1;"},
160 {"n","n","shll <REG_N>", "0100nnnn00000000", "T=R[n]<0; R[n]<<=1;"},
161 {"n","n","shll16 <REG_N>", "0100nnnn00101000", "R[n]<<=16;"},
162 {"n","n","shll2 <REG_N>", "0100nnnn00001000", "R[n]<<=2;"},
163 {"n","n","shll8 <REG_N>", "0100nnnn00011000", "R[n]<<=8;"},
164 {"n","n","shlr <REG_N>", "0100nnnn00000001", "T=R[n]&1;R[n]=UR[n]>>1;"},
165 {"n","n","shlr16 <REG_N>", "0100nnnn00101001", "R[n]=UR[n]>>16;"},
166 {"n","n","shlr2 <REG_N>", "0100nnnn00001001", "R[n]=UR[n]>>2;"},
167 {"n","n","shlr8 <REG_N>", "0100nnnn00011001", "R[n]=UR[n]>>8;"},
168 {"","","sleep", "0000000000011011", "trap(0xc3,R0,memory,maskl,maskw,little_endian);PC-=2;"},
169 {"n","","stc GBR,<REG_N>", "0000nnnn00010010", "R[n]=GBR;"},
170 {"n","","stc SR,<REG_N>", "0000nnnn00000010", "R[n]=GET_SR();"},
171 {"n","","stc VBR,<REG_N>", "0000nnnn00100010", "R[n]=VBR;"},
172 {"n","n","stc.l GBR,@-<REG_N>", "0100nnnn00010011", "R[n]-=4;WLAT(R[n],GBR);;"},
173 {"n","n","stc.l SR,@-<REG_N>", "0100nnnn00000011", "R[n]-=4;WLAT(R[n],GET_SR());"},
174 {"n","n","stc.l VBR,@-<REG_N>", "0100nnnn00100011", "R[n]-=4;WLAT(R[n],VBR);"},
175 {"n","","sts MACH,<REG_N>", "0000nnnn00001010", "R[n]=MACH;"},
176 {"n","","sts MACL,<REG_N>", "0000nnnn00011010", "R[n]=MACL;"},
177 {"n","","sts PR,<REG_N>", "0000nnnn00101010", "R[n]=PR;"},
178 {"n","n","sts.l MACH,@-<REG_N>", "0100nnnn00000010", "R[n]-=4;WLAT(R[n],MACH);"},
179 {"n","n","sts.l MACL,@-<REG_N>", "0100nnnn00010010", "R[n]-=4;WLAT(R[n],MACL);"},
180 {"n","n","sts.l PR,@-<REG_N>", "0100nnnn00100010", "R[n]-=4;WLAT(R[n],PR);"},
181 {"n","nm","sub <REG_M>,<REG_N>", "0011nnnnmmmm1000", "R[n]-=R[m];"},
182 {"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;"},
183 {"n","nm","subv <REG_M>,<REG_N>", "0011nnnnmmmm1011",
184 "ult = R[n] - R[m]; T = (((R[n] ^ R[m]) & (ult ^ R[n])) >> 31); R[n] = ult;"},
185 {"n","nm","swap.b <REG_M>,<REG_N>", "0110nnnnmmmm1000", "R[n]=((R[m]<<8)&0xff00)|((R[m]>>8)&0x00ff);"},
186 {"n","nm","swap.w <REG_M>,<REG_N>", "0110nnnnmmmm1001", "R[n]=((R[m]<<16)&0xffff0000)|((R[m]>>16)&0x00ffff);"},
187 {"","n","tas.b @<REG_N>", "0100nnnn00011011", "ult=RBAT(R[n]);T=ult==0;WBAT(R[n],ult|0x80);"},
188 {"0","","trapa #<imm>", "11000011i8*1....",
189 "{ 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;}}"},
190 {"","0","tst #<imm>,R0", "11001000i8*1....", "T=(R0&i)==0;"},
191 {"","mn","tst <REG_M>,<REG_N>", "0010nnnnmmmm1000", "T=(R[n]&R[m])==0;"},
192 {"","0","tst.b #<imm>,@(R0,GBR)", "11001100i8*1....", "T=(RBAT(GBR+R0)&i)==0;"},
193 {"","0","xor #<imm>,R0", "11001010i8*1....", "R0^=i;"},
194 {"n","mn","xor <REG_M>,<REG_N>", "0010nnnnmmmm1010", "R[n]^=R[m];"},
195 {"","0","xor.b #<imm>,@(R0,GBR)", "11001110i8*1....", "ult=RBAT(GBR+R0);ult^=i;WBAT(GBR+R0,ult);"},
196 {"n","nm","xtrct <REG_M>,<REG_N>", "0010nnnnmmmm1101", "R[n]=((R[n]>>16)&0xffff)|((R[m]<<16)&0xffff0000);"},
197 {"","nm","mul.l <REG_M>,<REG_N>", "0000nnnnmmmm0111", " MACL = R[n] * R[m];"},
198 {"n","n","dt <REG_N>", "0100nnnn00010000", "R[n]--; T=R[n] == 0;"},
199 {"","nm","dmuls.l <REG_M>,<REG_N>", "0011nnnnmmmm1101", "dmul(1,R[n],R[m]);"},
200 {"","nm","dmulu.l <REG_M>,<REG_N>", "0011nnnnmmmm0101", "dmul(0,R[n],R[m]);"},
201 {"","nm","mac.l @<REG_M>+,@<REG_N>+", "0000nnnnmmmm1111", "abort();"},
202 {"","n","braf <REG_N>", "0000nnnn00100011", "ult = PC; PC+=R[n]-2;SL(ult+2);"},
203 {"","n","bsrf <REG_N>", "0000nnnn00000011", "PR = PC; PC+=R[n]-2;SL(PR+2);"},
205 {"divs.l <REG_M>,<REG_N>", "0100nnnnmmmm1110", "divl(0,R[n],R[m]);"},
206 {"divu.l <REG_M>,<REG_N>", "0100nnnnmmmm1101", "divl(0,R[n],R[m]);"},
209 /* start-sanitize-sh3e */
210 {"", "", "fmov.s @<REG_M>,<FREG_N>", "1111nnnnmmmm1000", "*(int *)buf = RLAT(R[m]);F[n] = *(float *)buf;"},
211 {"", "", "fmov.s <FREG_M>,@<REG_N>", "1111nnnnmmmm1010", "*(float *)buf = F[m]; WLAT(R[n], *(int *)buf);"},
212 {"", "", "fmov.s @<REG_M>+,<FREG_N>", "1111nnnnmmmm1001", "*(int *)buf = RLAT(R[m]); F[n] = *(float *)buf; R[m] += 4;"},
213 {"", "", "fmov.s <FREG_M>,@-<REG_N>", "1111nnnnmmmm1011", "R[n] -= 4; *(float *)buf = F[m]; WLAT(R[n], *(int *)buf);"},
214 {"", "", "fmov.s @(R0,<REG_M>),<FREG_N>", "1111nnnnmmmm0110", "*(int *)buf = RLAT((R[0]+R[m]));F[n] = *(float *)buf;"},
215 {"", "", "fmov.s <FREG_M>,@(R0,<REG_N>)", "1111nnnnmmmm0111", "*(float *)buf = F[m]; WLAT((R[0]+R[n]), *(int *)buf);"},
216 {"", "", "fmov <FREG_M>,<FREG_N>", "1111nnnnmmmm1100", "F[n] = F[m];"},
217 {"", "", "fldi0 <FREG_N>", "1111nnnn10001101", "F[n] = (float)0.0;"},
218 {"", "", "fldi1 <FREG_N>", "1111nnnn10011101", "F[n] = (float)1.0;"},
219 {"", "", "fadd <FREG_M>,<FREG_N>", "1111nnnnmmmm0000","F[n] = F[n] + F[m];"},
220 {"", "", "fsub <FREG_M>,<FREG_N>", "1111nnnnmmmm0001","F[n] = F[n] - F[m];"},
221 {"", "", "fmul <FREG_M>,<FREG_N>", "1111nnnnmmmm0010","F[n] = F[n] * F[m];"},
222 {"", "", "fdiv <FREG_M>,<FREG_N>", "1111nnnnmmmm0011","F[n] = F[n] / F[m];"},
223 {"", "", "fmac <FREG_0>,<FREG_M>,<FREG_N>", "1111nnnnmmmm1110", "F[n] = F[m] * F[0] + F[n];"},
224 {"", "", "fcmp/eq <FREG_M>,<FREG_N>", "1111nnnnmmmm0100", "T = F[n] == F[m] ? 1 : 0;"},
225 {"", "", "fcmp/gt <FREG_M>,<FREG_N>", "1111nnnnmmmm0101", "T = F[n] > F[m] ? 1 : 0;"},
226 {"", "", "fneg <FREG_N>", "1111nnnn01001101", "F[n] = -F[n];"},
227 {"", "", "fabs <FREG_N>", "1111nnnn01011101", "F[n] = fabs (F[n]);"},
228 {"", "", "fsqrt <FREG_N>", "1111nnnn01101101", "F[n] = sqrt (F[n]);"},
229 {"", "", "float FPUL,<FREG_N>", "1111nnnn00101101", "F[n] = (float)FPUL;"},
230 {"", "", "ftrc <FREG_N>, FPUL", "1111nnnn00111101", "FPUL = (int)F[n];"},
231 {"", "", "ftst/nan <FREG_N>", "1111nnnn01111101", "T = isnan (F[n]);"},
232 {"", "", "fsts FPUL,<FREG_N>", "1111nnnn00001101", "*(int *)buf = FPUL; F[n] = *(float *)buf;"},
233 {"", "", "flds <FREG_N>,FPUL", "1111nnnn00011101", "*(float *)buf = F[n]; FPUL = *(int *)buf;"},
234 {"", "", "lds <REG_N>,FPUL", "0100nnnn01011010", "FPUL = R[n];"},
235 {"", "", "sts FPUL,<REG_N>", "0000nnnn01011010", "R[n] = FPUL;"},
236 {"", "", "lds <REG_N>,FPSCR", "0100nnnn01101010", "*(int *)buf = R[n]; FPSCR = *(float *)buf;"},
237 {"", "", "sts FPSCR,<REG_N>", "0000nnnn01101010", "*(float *)buf = FPSCR; R[n] = *(int *)buf;"},
238 {"","","lds.l @<REG_N>+,FPUL", "0100nnnn01010110", "FPUL = RLAT(R[n]);R[n]+=4;"},
239 {"","","lds.l @<REG_N>+,FPSCR", "0100nnnn01100110", "*(int *)buf = RLAT(R[n]); FPSCR = *(float *)buf; R[n]+=4;"},
240 {"","","sts.l FPUL,@-<REG_N>", "0100nnnn01010010", "R[n]-=4;WLAT(R[n],FPUL);"},
241 {"","","sts.l FPSCR,@-<REG_N>", "0100nnnn01100010", "R[n]-=4;*(float *)buf = FPSCR; WLAT(R[n],*(int *)buf);"},
242 /* end-sanitize-sh3e */
246 /* Tables of things to put into enums for sh-opc.h */
247 static char *nibble_type_list
[] =
282 char *arg_type_list
[] =
314 make_enum_list (name
, s
)
319 printf ("typedef enum {\n");
322 printf ("\t%s,\n", *s
);
326 printf ("} %s;\n", name
);
336 memcpy (bufa
, a
->code
, 4);
337 memcpy (bufa
+ 4, a
->code
+ 12, 4);
340 memcpy (bufb
, b
->code
, 4);
341 memcpy (bufb
+ 4, b
->code
+ 12, 4);
343 return (strcmp (bufa
, bufb
));
357 qsort (tab
, len
, sizeof (*p
), qfunc
);
361 printonmatch (ptr
, a
, rep
)
367 if (strncmp (*ptr
, a
, l
) == 0)
387 while (*n
&& *n
!= ' ')
402 while (*p
== ',' || *p
== ' ')
404 printonmatch (&p
, "#<imm>", "A_IMM");
405 printonmatch (&p
, "R0", "A_R0");
406 printonmatch (&p
, "<REG_N>", "A_REG_N");
407 printonmatch (&p
, "@<REG_N>+", "A_INC_N");
408 printonmatch (&p
, "@<REG_N>", "A_IND_N");
409 printonmatch (&p
, "@-<REG_N>", "A_DEC_N");
410 printonmatch (&p
, "<REG_M>", " A_REG_M");
411 printonmatch (&p
, "@<REG_M>+", "A_INC_M");
412 printonmatch (&p
, "@<REG_M>", "A_IND_M");
413 printonmatch (&p
, "@-<REG_M>", "A_DEC_M");
414 printonmatch (&p
, "@(<disp>,PC)", "A_DISP_PC");
415 printonmatch (&p
, "@(<disp>,<REG_M>)", "A_DISP_REG_M");
416 printonmatch (&p
, "@(<disp>,<REG_N>)", "A_DISP_REG_N");
417 printonmatch (&p
, "@(R0,<REG_N>)", "A_IND_R0_REG_N");
418 printonmatch (&p
, "@(R0,<REG_M>)", "A_IND_R0_REG_M");
419 printonmatch (&p
, "@(<disp>,GBR)", "A_DISP_GBR");
420 printonmatch (&p
, "@(R0,GBR)", "A_R0_GBR");
421 printonmatch (&p
, "<bdisp8>", "A_BDISP8");
422 printonmatch (&p
, "<bdisp12>", "A_BDISP12");
423 printonmatch (&p
, "SR", "A_SR");
424 printonmatch (&p
, "GBR", "A_GBR");
425 printonmatch (&p
, "VBR", "A_VBR");
426 printonmatch (&p
, "MACH", "A_MACH");
427 printonmatch (&p
, "MACL", "A_MACL");
428 printonmatch (&p
, "PR", "A_PR");
436 printonmatch (&p
, "0000", "HEX_0");
437 printonmatch (&p
, "0001", "HEX_1");
438 printonmatch (&p
, "0010", "HEX_2");
439 printonmatch (&p
, "0011", "HEX_3");
440 printonmatch (&p
, "0100", "HEX_4");
441 printonmatch (&p
, "0101", "HEX_5");
442 printonmatch (&p
, "0110", "HEX_6");
443 printonmatch (&p
, "0111", "HEX_7");
445 printonmatch (&p
, "1000", "HEX_8");
446 printonmatch (&p
, "1001", "HEX_9");
447 printonmatch (&p
, "1010", "HEX_A");
448 printonmatch (&p
, "1011", "HEX_B");
449 printonmatch (&p
, "1100", "HEX_C");
450 printonmatch (&p
, "1101", "HEX_D");
451 printonmatch (&p
, "1110", "HEX_E");
452 printonmatch (&p
, "1111", "HEX_F");
453 printonmatch (&p
, "i8*1....", "IMM_8");
454 printonmatch (&p
, "i4*1", "IMM_4");
455 printonmatch (&p
, "i8p4....", "PCRELIMM_8BY4");
456 printonmatch (&p
, "i8p2....", "PCRELIMM_8BY2");
457 printonmatch (&p
, "i8*2....", "IMM_8BY2");
458 printonmatch (&p
, "i4*2", "IMM_4BY2");
459 printonmatch (&p
, "i8*4....", "IMM_8BY4");
460 printonmatch (&p
, "i4*4", "IMM_4BY4");
461 printonmatch (&p
, "i12.........", "BRANCH_12");
462 printonmatch (&p
, "i8p1....", "BRANCH_8");
463 printonmatch (&p
, "nnnn", "REG_N");
464 printonmatch (&p
, "mmmm", "REG_M");
475 for (p
= tab
; p
->name
; p
++)
477 printf ("%s %-30s\n", p
->code
, p
->name
);
488 make_enum_list ("sh_nibble_type", nibble_type_list
);
489 make_enum_list ("sh_arg_type", arg_type_list
);
491 printf ("typedef struct {\n");
492 printf ("char *name;\n");
493 printf ("sh_arg_type arg[3];\n");
494 printf ("sh_nibble_type nibbles[4];\n");
495 printf ("} sh_opcode_info;\n");
496 printf ("#ifdef DEFINE_TABLE\n");
497 printf ("sh_opcode_info sh_table[]={\n");
498 for (p
= tab
; p
->name
; p
++)
500 printf ("\n/* %s %-20s*/", p
->code
, p
->name
);
512 /* Convert a string of 4 binary digits into an int */
532 static unsigned char table
[1 << 16];
534 /* Take an opcode expand all varying fields in it out and fill all the
535 right entries in 'table' with the opcode index*/
538 expand_opcode (shift
, val
, i
, s
)
562 expand_opcode (shift
- 4, val
| (n
<< shift
), i
, s
+ 4);
568 for (j
= 0; j
< 16; j
++)
570 expand_opcode (shift
- 4, val
| (j
<< shift
), i
, s
+ 4);
576 for (j
= 0; j
< (1 << (shift
+ 4)); j
++)
584 /* Print the jump table used to index an opcode into a switch
599 printf ("unsigned char sh_jump_table%x[%d]={\n", i
, lump
);
606 printf ("%2d", table
[i
+ j
+ k
]);
629 for (p
= tab
; p
->name
; p
++)
632 expand_opcode (12, 0, p
->index
, p
->code
);
643 /* start-sanitize-sh3e */
644 printf("char buf[4];\n");
645 /* end-sanitize-sh3e */
646 printf ("switch (jump_table[iword]) {\n");
648 for (p
= tab
; p
->name
; p
++)
656 printf ("/* %s %s */\n", p
->name
, p
->code
);
657 printf ("case %d: \n", p
->index
);
670 printf ("int n = (iword >>8) & 0xf;\n");
675 printf ("int m = (iword >>4) & 0xf;\n");
682 printf ("int i = (iword & 0x");
717 printf ("i = (i ^ (1<<%d))-(1<<%d);\n", sextbit
- 1, sextbit
- 1);
725 for (j
= 0; j
< 10; j
++)
729 printf ("%s\n", p
->stuff
[j
]);
735 /* Do the defs and refs */
737 for (r
= p
->refs
; *r
; r
++) {
738 if (*r
== '0') printf("CREF(0);\n");
739 if (*r
== 'n') printf("CREF(n);\n");
740 if (*r
== 'm') printf("CREF(m);\n");
743 for (r
= p
->defs
; *r
; r
++)
745 if (*r
== '0') printf("CDEF(0);\n");
746 if (*r
== 'n') printf("CDEF(n);\n");
747 if (*r
== 'm') printf("CDEF(m);\n");
755 printf("default:\n{\nsaved_state.asregs.exception = SIGILL;\n}\n");
765 for (p
= tab
; p
->name
; p
++)
768 printf ("#define OPC_");
772 if (isalpha(*s
)) printf("%c", *s
);
773 if (*s
== ' ') printf("_");
774 if (*s
== '@') printf("ind_");
775 if (*s
== ',') printf("_");
778 printf(" %d\n",p
->index
);
789 if (strcmp (av
[1], "-t") == 0)
793 else if (strcmp (av
[1], "-d") == 0)
797 else if (strcmp (av
[1], "-s") == 0)
803 else if (strcmp (av
[1], "-x") == 0)
This page took 0.218732 seconds and 5 git commands to generate.