8b495e5dad1ef4c0fa19ca53c9eb5d4659debfd7
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 -x generates the simulator code switch statement
27 default generates the opcode tables
45 {"add #<imm>,<REG_N>", "0111nnnni8*1....", "R[n] += SEXT(i);"},
46 {"add <REG_M>,<REG_N>", "0011nnnnmmmm1100", "R[n] += R[m];"},
47 {"addc <REG_M>,<REG_N>", "0011nnnnmmmm1110", "ult = R[n]; R[n] += (R[m]+T); T = ult>R[n];"},
48 {"addv <REG_M>,<REG_N>", "0011nnnnmmmm1111",
51 "T = ((~R[n] & R[m] & ans) | (R[n] & R[m] & ~ans)) >>31;",
54 {"and #<imm>,R0", "11001001i8*1....", "R0&=i;"},
55 {"and <REG_M>,<REG_N>", "0010nnnnmmmm1001", "R[n]&=R[m];"},
56 {"and.b #<imm>,@(R0,GBR)", "11001101i8*1....", "WBAT(GBR+R0, RBAT(GBR+R0) & i);"},
58 {"bf <bdisp8>", "10001011i8p1....", "if(T==0) {PC+=(SEXT(i)<<1)+2;C+=2;}"},
59 {"bra <bdisp12>", "1010i12.........", "ult = PC; PC=PC+(i<<1)+2;SL(ult+2);"},
60 {"bsr <bdisp12>", "1011i12.........", "PR = PC; PC=PC+(i<<1)+2;SL(PR+2);"},
61 {"bt <bdisp8>", "10001001i8p1....", "if(T==1) {PC+=(SEXT(i)<<1)+2;C+=2;}"},
62 {"clrmac", "0000000000101000", "MACH = MACL = 0;"},
63 {"clrt", "0000000000001000", "T= 0;"},
64 {"cmp/eq #<imm>,R0", "10001000i8*1....", "T = R0 == SEXT(i);"},
65 {"cmp/eq <REG_M>,<REG_N>", "0011nnnnmmmm0000", "T=R[n]==R[m];"},
66 {"cmp/ge <REG_M>,<REG_N>", "0011nnnnmmmm0011", "T=R[n]>=R[m];"},
67 {"cmp/gt <REG_M>,<REG_N>", "0011nnnnmmmm0111", "T=R[n]>R[m];"},
68 {"cmp/hi <REG_M>,<REG_N>", "0011nnnnmmmm0110", "T=UR[n]>UR[m];"},
69 {"cmp/hs <REG_M>,<REG_N>", "0011nnnnmmmm0010", "T=UR[n]>=UR[m];"},
70 {"cmp/pl <REG_N>", "0100nnnn00010101", "T = R[n]>0;"},
71 {"cmp/pz <REG_N>", "0100nnnn00010001", "T = R[n]>=0;"},
72 {"cmp/str <REG_M>,<REG_N>", "0010nnnnmmmm1100", "ult = R[n] ^ R[m]; T=((ult&0xff000000)==0) |((ult&0xff0000)==0) |((ult&0xff00)==0) |((ult&0xff)==0); "},
73 {"div0s <REG_M>,<REG_N>", "0010nnnnmmmm0111", "Q=R[n]<0; M=R[m]<0; T=M!=Q;;"},
74 {"div0u", "0000000000011001", "M=Q=T=0;"},
75 {"div1 <REG_M>,<REG_N>", "0011nnnnmmmm0100", "T=div1(R,n,m,T);"},
76 {"exts.b <REG_M>,<REG_N>", "0110nnnnmmmm1110", "R[n] = SEXT(R[m]);"},
77 {"exts.w <REG_M>,<REG_N>", "0110nnnnmmmm1111", "R[n] = SEXTW(R[m]);"},
78 {"extu.b <REG_M>,<REG_N>", "0110nnnnmmmm1100", "R[n] = R[m] & 0xff;"},
79 {"extu.w <REG_M>,<REG_N>", "0110nnnnmmmm1101", "R[n] = R[m] & 0xffff;"},
80 {"jmp @<REG_N>", "0100nnnn00101011", "ult = PC; PC=R[n]-2; SL(ult+2);"},
81 {"jsr @<REG_N>", "0100nnnn00001011", "PR = PC; PC=R[n]-2; SL(PR+2);"},
82 {"ldc <REG_N>,GBR", "0100nnnn00011110", "GBR=R[n];"},
83 {"ldc <REG_N>,SR", "0100nnnn00001110", "SET_SR(R[n]);"},
84 {"ldc <REG_N>,VBR", "0100nnnn00101110", "VBR=R[n];"},
85 {"ldc.l @<REG_N>+,GBR", "0100nnnn00010111", "GBR=RLAT(R[n]);R[n]+=4;;"},
86 {"ldc.l @<REG_N>+,SR", "0100nnnn00000111", "SET_SR(RLAT(R[n]));R[n]+=4;;"},
87 {"ldc.l @<REG_N>+,VBR", "0100nnnn00100111", "VBR=RLAT(R[n]);R[n]+=4;;"},
88 {"lds <REG_N>,MACH", "0100nnnn00001010", "MACH = SEXT(R[n]);"},
89 {"lds <REG_N>,MACL", "0100nnnn00011010", "MACL= R[n];"},
90 {"lds <REG_N>,PR", "0100nnnn00101010", "PR = R[n];"},
91 {"lds.l @<REG_N>+,MACH", "0100nnnn00000110", "MACH = SEXT(RLAT(R[n]));R[n]+=4;"},
92 {"lds.l @<REG_N>+,MACL", "0100nnnn00010110", "MACL = RLAT(R[n]);R[n]+=4;"},
93 {"lds.l @<REG_N>+,PR", "0100nnnn00100110", "PR = RLAT(R[n]);R[n]+=4;;"},
94 {"mac.w @<REG_M>+,@<REG_N>+", "0100nnnnmmmm1111", "abort();"},
95 {"mov #<imm>,<REG_N>", "1110nnnni8*1....", "R[n] = SEXT(i);"},
96 {"mov <REG_M>,<REG_N>", "0110nnnnmmmm0011", "R[n] = R[m];"},
97 {"mov.b <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0100", "WBAT(R[n]+R0, R[m]);"},
98 {"mov.b <REG_M>,@-<REG_N>", "0010nnnnmmmm0100", "R[n]--; WBAT(R[n], R[m]);"},
99 {"mov.b <REG_M>,@<REG_N>", "0010nnnnmmmm0000", "WBAT(R[n], R[m]);"},
100 {"mov.b @(<disp>,<REG_M>),R0", "10000100mmmmi4*1", "R0=RBAT(i+R[m]);"},
101 {"mov.b @(<disp>,GBR),R0", "11000100i8*1....", "R0=RBAT(i+GBR);"},
102 {"mov.b @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1100", "R[n]=RBAT(R0+R[m]);"},
103 {"mov.b @<REG_M>+,<REG_N>", "0110nnnnmmmm0100", "R[n] = RBAT(R[m]);R[m]++;"},
104 {"mov.b @<REG_M>,<REG_N>", "0110nnnnmmmm0000", "R[n]=RBAT(R[m]);"},
105 {"mov.b R0,@(<disp>,<REG_M>)", "10000000mmmmi4*1", "R0=RBAT(i+R[m]);"},
106 {"mov.b R0,@(<disp>,GBR)", "11000000i8*1....", "R0 = RBAT(i+GBR);"},
107 {"mov.l <REG_M>,@(<disp>,<REG_N>)", "0001nnnnmmmmi4*4", "WLAT(i+R[n],R[m]);"},
108 {"mov.l <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0110", "WLAT(R0+R[n],R[m]);"},
109 {"mov.l <REG_M>,@-<REG_N>", "0010nnnnmmmm0110", "R[n]-=4;WLAT(R[n],R[m]);"},
110 {"mov.l <REG_M>,@<REG_N>", "0010nnnnmmmm0010", "WLAT(R[n], R[m]);"},
111 {"mov.l @(<disp>,<REG_N>),<REG_M>", "0101nnnnmmmmi4*4", "R[m]=RLAT(i+R[n]);"},
112 {"mov.l @(<disp>,GBR),R0", "11000110i4*4", "R0=RLAT(i+GBR);"},
113 {"mov.l @(<disp>,PC),<REG_N>", "1101nnnni8p4....", "R[n]=RLAT(i+4+PC);"},
114 {"mov.l @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1110", "R[n]=RLAT(R0+R[m]);"},
115 {"mov.l @<REG_M>+,<REG_N>", "0110nnnnmmmm0110", "R[n]=RLAT(R[m]);R[m]+=4;"},
116 {"mov.l @<REG_M>,<REG_N>", "0110nnnnmmmm0010", "R[n]=RLAT(R[m]);"},
117 {"mov.l R0,@(<disp>,GBR)", "11000010i8*4....", "R0=RLAT(R0+GBR);"},
118 {"mov.w <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0101", "WWAT(R0+R[n],R[m]);"},
119 {"mov.w <REG_M>,@-<REG_N>", "0010nnnnmmmm0101", "R[n]-=2;WWAT(R[n],R[m]);"},
120 {"mov.w <REG_M>,@<REG_N>", "0010nnnnmmmm0001", "WWAT(R[n],R[m]);"},
121 {"mov.w @(<disp>,<REG_M>),R0", "10000101mmmmi4*2", "R0=RSWAT(i+R[m]);"},
122 {"mov.w @(<disp>,GBR),R0", "11000101i8*2....", "R0=RSWAT(i+GBR);"},
123 {"mov.w @(<disp>,PC),<REG_N>", "1001nnnni8p2....", "R[n]=RSWAT(PC+i+4);"},
124 {"mov.w @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1101", "R[n]=RSWAT(R0+R[m]);"},
125 {"mov.w @<REG_M>+,<REG_N>", "0110nnnnmmmm0101", "R[n]=RSWAT(R[m]);R[m]+=2;"},
126 {"mov.w @<REG_M>,<REG_N>", "0110nnnnmmmm0001", "R[n]=RSWAT(R[m]);"},
127 {"mov.w R0,@(<disp>,<REG_M>)", "10000001mmmmi4*2", "R0=RSWAT(i+R[m]);"},
128 {"mov.w R0,@(<disp>,GBR)", "11000001i8*2....", "R0=RSWAT(i+GBR);"},
129 {"mova @(<disp>,PC),R0", "11000111i8p4....", "R0=i+4+PC;"},
130 {"movt <REG_N>", "0000nnnn00101001", "R[n]=T;"},
131 {"muls <REG_M>,<REG_N>", "0010nnnnmmmm1111",
132 "MACL=((long)(short)R[n])*((long)(short)R[m]);"},
133 {"mulu <REG_M>,<REG_N>","0010nnnnmmmm1110", "MACL=((unsigned long)(unsigned short)R[n])*((unsigned long)(unsigned short)R[m]);"},
134 {"neg <REG_M>,<REG_N>", "0110nnnnmmmm1011", "R[n] = - R[m];"},
135 {"negc <REG_M>,<REG_N>", "0110nnnnmmmm1010", "ult=0-R[m];R[n]=ult-T;T=SBIT(R[n])!=SBIT(ult);"},
136 {"nop", "0000000000001001", ""},
137 {"not <REG_M>,<REG_N>", "0110nnnnmmmm0111", "R[n]=~R[m];"},
138 {"or #<imm>,R0", "11001011i8*1....", "R0|=i;"},
139 {"or <REG_M>,<REG_N>", "0010nnnnmmmm1011", "R[n]|=R[m];"},
140 {"or.b #<imm>,@(R0,GBR)", "11001111i8*1....", "WBAT(R0+GBR,RBAT(R0+GBR)|i);"},
141 {"rotcl <REG_N>", "0100nnnn00100100", "ult = R[n] <0;R[n] = (R[n]<<1)|T;T=ult;"},
142 {"rotcr <REG_N>", "0100nnnn00100101", "ult = R[n]&1;R[n]=(UR[n]>>1)|(T<<31);T=ult;"},
143 {"rotl <REG_N>", "0100nnnn00000100", "T=R[n]<0;R[n]<<=1;R[n]|=T;"},
144 {"rotr <REG_N>", "0100nnnn00000101", "T=R[n]&1;UR[n]>>=1;R[n]|=(T<<31);"},
145 {"rte", "0000000000101011", "abort();"},
146 {"rts", "0000000000001011", "ult=PC;PC=PR+2;SL(ult+2);"},
147 {"sett", "0000000000011000", "T=1;"},
148 {"shal <REG_N>", "0100nnnn00100000", "T=R[n]<0; R[n]<<=1;"},
149 {"shar <REG_N>", "0100nnnn00100001", "T=R[n]&1; R[n]>>=1;"},
150 {"shll <REG_N>", "0100nnnn00000000", "T=R[n]<0; R[n]<<=1;"},
151 {"shll16 <REG_N>", "0100nnnn00101000", "R[n]<<=16;"},
152 {"shll2 <REG_N>", "0100nnnn00001000", "R[n]<<=2;"},
153 {"shll8 <REG_N>", "0100nnnn00011000", "R[n]<<=8;"},
154 {"shlr <REG_N>", "0100nnnn00000001", "T=R[n]&1;R[n]=UR[n]>>1;"},
155 {"shlr16 <REG_N>", "0100nnnn00101001", "R[n]=UR[n]>>16;"},
156 {"shlr2 <REG_N>", "0100nnnn00001001", "R[n]=UR[n]>>2;"},
157 {"shlr8 <REG_N>", "0100nnnn00011001", "R[n]=UR[n]>>8;"},
158 {"sleep", "0000000000011011", "abort();"},
159 {"stc GBR,<REG_N>", "0000nnnn00010010", "R[n]=GBR;"},
160 {"stc SR,<REG_N>", "0000nnnn00000010", "R[n]=GET_SR();"},
161 {"stc VBR,<REG_N>", "0000nnnn00100010", "R[n]=VBR;"},
162 {"stc.l GBR,@-<REG_N>", "0100nnnn00010011", "R[n]-=4;WLAT(R[n],GBR);;"},
163 {"stc.l SR,@-<REG_N>", "0100nnnn00000011", "R[n]-=4;WLAT(R[n],GET_SR());"},
164 {"stc.l VBR,@-<REG_N>", "0100nnnn00100011", "R[n]-=4;WLAT(R[n],VBR);"},
165 {"sts MACH,<REG_N>", "0000nnnn00001010", "R[n]=MACH;"},
166 {"sts MACL,<REG_N>", "0000nnnn00011010", "R[n]=MACL;"},
167 {"sts PR,<REG_N>", "0000nnnn00101010", "R[n]=PR;"},
168 {"sts.l MACH,@-<REG_N>", "0100nnnn00000010", "R[n]-=4;WLAT(R[n],MACH);"},
169 {"sts.l MACL,@-<REG_N>", "0100nnnn00010010", "R[n]-=4;WLAT(R[n],MACL);"},
170 {"sts.l PR,@-<REG_N>", "0100nnnn00100010", "R[n]-=4;WLAT(R[n],PR);"},
171 {"sub <REG_M>,<REG_N>", "0011nnnnmmmm1000", "R[n]-=R[m];"},
172 {"subc <REG_M>,<REG_N>", "0011nnnnmmmm1010", "ult = R[n];R[n]-=R[m]+T;T=ult<UR[n];"},
173 {"subv <REG_M>,<REG_N>", "0011nnnnmmmm1011", "abort();"},
174 {"swap.b <REG_M>,<REG_N>", "0110nnnnmmmm1000", "R[n]=((R[m]<<8)&0xff00)|((R[m]>>8)&0x00ff);"},
175 {"swap.w <REG_M>,<REG_N>", "0110nnnnmmmm1001", "R[n]=((R[m]<<16)&0xffff0000)|((R[m]>>16)&0x00ffff);"},
176 {"tas.b @<REG_N>", "0100nnnn00011011", "ult=RBAT(R[n]);T=ult==0;WBAT(R[n],ult|0x80);"},
177 {"trapa #<imm>", "11000011i8*1....", "trap(i,R);"},
178 {"tst #<imm>,R0", "11001000i8*1....", "T=(R0&i)==0;"},
179 {"tst <REG_M>,<REG_N>", "0010nnnnmmmm1000", "T=(R[n]&R[m])==0;"},
180 {"tst.b #<imm>,@(R0,GBR)", "11001100i8*1....", "T=(RBAT(GBR+R0)&i)==0;"},
181 {"xor #<imm>,R0", "11001010i8*1....", "R0^=i;"},
182 {"xor <REG_M>,<REG_N>", "0010nnnnmmmm1010", "R[n]^=R[m];"},
183 {"xor.b #<imm>,@(R0,GBR)", "11001110i8*1....", "ult=RBAT(GBR+R0);ult^=i;WBAT(GBR+R0,ult);"},
184 {"xtrct <REG_M>,<REG_N>", "0010nnnnmmmm1101", "R[n]=((R[n]>>16)&0xffff)|((R[m]<<16)&0xffff0000);"},
187 {"mul.l <REG_M>,<REG_N>","0000nnnnmmmm0111","/* mull */"},
188 {"dmuls.l <REG_M>,<REG_N>","0011nnnnmmmm1101","/* dmuls.l */"},
189 {"dmulu.l <REG_M>,<REG_N>","0011nnnnmmmm0101",""},
190 {"mac.l @<REG_M>+,@<REG_N>+","0000nnnnmmmm1111",""},
191 {"bt/s <bdisp8>","10001101i8p1....",""},
192 {"bf/s <bdisp8>","10001111i8p1....",""},
193 {"dt <REG_N>","0100nnnn00010000",""},
194 {"braf @<REG_N>","0000nnnn00100011",""},
195 {"bsrf @<REG_N>","0000nnnn00000011",""},
196 {"mulu <REG_M>,<REG_N>","0010nnnnmmmm1110",""},
197 {"muls <REG_M>,<REG_N>","0010nnnnmmmm1111",""},
202 /* Tables of things to put into enums for sh-opc.h */
203 static char *nibble_type_list
[] =
238 char *arg_type_list
[] =
270 make_enum_list (name
, s
)
275 printf ("typedef enum {\n");
278 printf ("\t%s,\n", *s
, i
);
282 printf ("} %s;\n", name
);
290 for (p
= tab
; p
->name
; p
++)
292 printf ("%s %-30s\n", p
->code
, p
->name
);
303 make_enum_list ("sh_nibble_type", nibble_type_list
);
304 make_enum_list ("sh_arg_type", arg_type_list
);
306 printf ("typedef struct {\n");
307 printf ("char *name;\n");
308 printf ("sh_arg_type arg[3];\n");
309 printf ("sh_nibble_type nibbles[4];\n");
310 printf ("} sh_opcode_info;\n");
311 printf ("#ifdef DEFINE_TABLE\n");
312 printf ("sh_opcode_info sh_table[]={\n");
313 for (p
= tab
; p
->name
; p
++)
315 printf ("\n\/\* %s %-20s*/", p
->code
, p
->name
);
329 if (strncmp (*ptr
, a
, l
) == 0)
347 while (*n
&& *n
!= ' ')
362 while (*p
== ',' || *p
== ' ')
364 m (&p
, "#<imm>", "A_IMM");
365 m (&p
, "R0", "A_R0");
366 m (&p
, "<REG_N>", "A_REG_N");
367 m (&p
, "@<REG_N>+", "A_INC_N");
368 m (&p
, "@<REG_N>", "A_IND_N");
369 m (&p
, "@-<REG_N>", "A_DEC_N");
370 m (&p
, "<REG_M>", " A_REG_M");
371 m (&p
, "@<REG_M>+", "A_INC_M");
372 m (&p
, "@<REG_M>", "A_IND_M");
373 m (&p
, "@-<REG_M>", "A_DEC_M");
374 m (&p
, "@(<disp>,PC)", "A_DISP_PC");
375 m (&p
, "@(<disp>,<REG_M>)", "A_DISP_REG_M");
376 m (&p
, "@(<disp>,<REG_N>)", "A_DISP_REG_N");
377 m (&p
, "@(R0,<REG_N>)", "A_IND_R0_REG_N");
378 m (&p
, "@(R0,<REG_M>)", "A_IND_R0_REG_M");
379 m (&p
, "@(<disp>,GBR)", "A_DISP_GBR");
380 m (&p
, "@(R0,GBR)", "A_R0_GBR");
381 m (&p
, "<bdisp8>", "A_BDISP8");
382 m (&p
, "<bdisp12>", "A_BDISP12");
383 m (&p
, "SR", "A_SR");
384 m (&p
, "GBR", "A_GBR");
385 m (&p
, "VBR", "A_VBR");
386 m (&p
, "MACH", "A_MACH");
387 m (&p
, "MACL", "A_MACL");
388 m (&p
, "PR", "A_PR");
396 m (&p
, "0000", "HEX_0");
397 m (&p
, "0001", "HEX_1");
398 m (&p
, "0010", "HEX_2");
399 m (&p
, "0011", "HEX_3");
400 m (&p
, "0100", "HEX_4");
401 m (&p
, "0101", "HEX_5");
402 m (&p
, "0110", "HEX_6");
403 m (&p
, "0111", "HEX_7");
405 m (&p
, "1000", "HEX_8");
406 m (&p
, "1001", "HEX_9");
407 m (&p
, "1010", "HEX_A");
408 m (&p
, "1011", "HEX_B");
409 m (&p
, "1100", "HEX_C");
410 m (&p
, "1101", "HEX_D");
411 m (&p
, "1110", "HEX_E");
412 m (&p
, "1111", "HEX_F");
413 m (&p
, "i8*1....", "IMM_8");
414 m (&p
, "i4*1", "IMM_4");
415 m (&p
, "i8p4....", "PCRELIMM_8BY4");
416 m (&p
, "i8p2....", "PCRELIMM_8BY2");
417 m (&p
, "i8*2....", "IMM_8BY2");
418 m (&p
, "i4*2", "IMM_4BY2");
419 m (&p
, "i8*4....", "IMM_8BY4");
420 m (&p
, "i4*4", "IMM_4BY4");
421 m (&p
, "i12.........", "BRANCH_12");
422 m (&p
, "i8p1....", "BRANCH_8");
423 m (&p
, "nnnn", "REG_N");
424 m (&p
, "mmmm", "REG_M");
436 memcpy (bufa
, a
->code
, 4);
437 memcpy (bufa
+ 4, a
->code
+ 12, 4);
440 memcpy (bufb
, b
->code
, 4);
441 memcpy (bufb
+ 4, b
->code
+ 12, 4);
443 return (strcmp (bufa
, bufb
));
459 qsort (tab
, len
, sizeof (*p
), qfunc
);
463 /* Convert a string of 4 binary digits into an int */
483 static char table
[1 << 16];
485 /* Take an opcode expand all varying fields in it out and fill all the
486 right entries in 'table' with the opcode index*/
488 expand_opcode (shift
, val
, i
, s
)
509 expand_opcode (shift
- 4, val
| (n
<< shift
), i
, s
+ 4);
515 for (j
= 0; j
< 16; j
++)
517 expand_opcode (shift
- 4, val
| (j
<< shift
), i
, s
+ 4);
523 for (j
= 0; j
< (1 << (shift
+ 4)); j
++)
531 /* Print the jump table used to index an opcode into a switch
547 printf ("unsigned char sh_jump_table%x[%d]={\n", i
, lump
);
554 printf ("%2d", table
[i
+ j
+ k
]);
577 for (p
= tab
; p
->name
; p
++)
580 expand_opcode (12, 0, p
->index
, p
->code
);
591 printf ("switch (jump_table[iword]) {\n");
593 for (p
= tab
; p
->name
; p
++)
599 printf ("\/\* %s %s *\/\n", p
->name
, p
->code
);
600 printf ("case %d: \n", p
->index
);
613 printf ("int n = (iword >>8) & 0xf;\n");
617 printf ("int m = (iword >>4) & 0xf;\n");
623 printf ("int i = (iword & 0x");
658 printf("i = (i ^ (1<<%d))-(1<<%d);\n",sextbit
-1,sextbit
-1);
661 for (j
= 0; j
< 10; j
++)
665 printf ("%s\n", p
->stuff
[j
]);
668 printf ("break;\n", p
->stuff
);
682 if (strcmp (av
[1], "-t") == 0)
686 else if (strcmp (av
[1], "-s") == 0)
692 else if (strcmp (av
[1], "-x") == 0)
This page took 0.051154 seconds and 4 git commands to generate.