projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[include/opcode]
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
CommitLineData
f282425e 1#line 1 "rx-decode.opc"
c7927a3c
NC		 2/* -*- c -*- */
3#include <stdio.h>
4#include <stdlib.h>
5#include <string.h>
6
7#include "config.h"
8#include "ansidecl.h"
9#include "opcode/rx.h"
10
11#define RX_OPCODE_BIG_ENDIAN 0
12
13typedef struct
14{
15 RX_Opcode_Decoded * rx;
16 int (* getbyte)(void *);
17 void * ptr;
18 unsigned char * op;
19} LocalData;
20
21static int trace = 0;
22
23#define BSIZE 0
24#define WSIZE 1
25#define LSIZE 2
26
27/* These are for when the upper bits are "don't care" or "undefined". */
28static int bwl[] =
29{
30 RX_Byte,
31 RX_Word,
32 RX_Long
33};
34
35static int sbwl[] =
36{
37 RX_SByte,
38 RX_SWord,
39 RX_Long
40};
41
42static int ubwl[] =
43{
44 RX_UByte,
45 RX_UWord,
46 RX_Long
47};
48
49static int memex[] =
50{
51 RX_SByte,
52 RX_SWord,
53 RX_Long,
54 RX_UWord
55};
56
57#define ID(x) rx->id = RXO_##x
58#define OP(n,t,r,a) (rx->op[n].type = t, \
59 rx->op[n].reg = r, \
60 rx->op[n].addend = a )
61#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
62 rx->op[n].size = s )
63
64/* This is for the BWL and BW bitfields. */
65static int SCALE[] = { 1, 2, 4 };
66/* This is for the prefix size enum. */
67static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
68
69static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
70 16, 17, 0, 0, 0, 0, 0, 0 };
71
72static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
73
74/*
75 *C a constant (immediate) c
76 *R A register
77 *I Register indirect, no offset
78 *Is Register indirect, with offset
79 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
80 *P standard displacement: type (r,[r]), reg, assumes UByte
81 *Pm memex displacement: type (r,[r]), reg, memex code
82 *cc condition code. */
83
84#define DC(c) OP (0, RX_Operand_Immediate, 0, c)
85#define DR(r) OP (0, RX_Operand_Register, r, 0)
86#define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
87#define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
88#define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
89#define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
90
91#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
92#define SR(r) OP (1, RX_Operand_Register, r, 0)
f9c7014e 93#define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
c7927a3c
NC		 94#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
95#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
96#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
97#define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
98#define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
99#define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
100
101#define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
102#define S2R(r) OP (2, RX_Operand_Register, r, 0)
103#define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
104#define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
105#define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
106#define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
107#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
108#define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
109
110#define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
111#define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
112#define uBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
113#define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
114
115#define F(f) store_flags(rx, f)
116
117#define AU ATTRIBUTE_UNUSED
118#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
119
120#define SYNTAX(x) rx->syntax = x
121
122#define UNSUPPORTED() \
123 rx->syntax = "*unknown*"
124
125#define IMM(sf) immediate (sf, 0, ld)
126#define IMMex(sf) immediate (sf, 1, ld)
127
128static int
129immediate (int sfield, int ex, LocalData * ld)
130{
131 unsigned long i = 0, j;
132
133 switch (sfield)
134 {
135#define B ((unsigned long) GETBYTE())
136 case 0:
137#if RX_OPCODE_BIG_ENDIAN
138 i = B;
139 if (ex && (i & 0x80))
140 i -= 0x100;
141 i <<= 24;
142 i |= B << 16;
143 i |= B << 8;
144 i |= B;
145#else
146 i = B;
147 i |= B << 8;
148 i |= B << 16;
149 j = B;
150 if (ex && (j & 0x80))
151 j -= 0x100;
152 i |= j << 24;
153#endif
154 break;
155 case 3:
156#if RX_OPCODE_BIG_ENDIAN
157 i = B << 16;
158 i |= B << 8;
159 i |= B;
160#else
161 i = B;
162 i |= B << 8;
163 i |= B << 16;
164#endif
165 if (ex && (i & 0x800000))
166 i -= 0x1000000;
167 break;
168 case 2:
169#if RX_OPCODE_BIG_ENDIAN
170 i |= B << 8;
171 i |= B;
172#else
173 i |= B;
174 i |= B << 8;
175#endif
176 if (ex && (i & 0x8000))
177 i -= 0x10000;
178 break;
179 case 1:
180 i |= B;
181 if (ex && (i & 0x80))
182 i -= 0x100;
183 break;
184 default:
185 abort();
186 }
187 return i;
188}
189
190static void
191rx_disp (int n, int type, int reg, int size, LocalData * ld)
192{
193 int disp;
194
195 ld->rx->op[n].reg = reg;
196 switch (type)
197 {
198 case 3:
199 ld->rx->op[n].type = RX_Operand_Register;
200 break;
201 case 0:
202 ld->rx->op[n].type = RX_Operand_Indirect;
203 ld->rx->op[n].addend = 0;
204 break;
205 case 1:
206 ld->rx->op[n].type = RX_Operand_Indirect;
207 disp = GETBYTE ();
208 ld->rx->op[n].addend = disp * PSCALE[size];
209 break;
210 case 2:
211 ld->rx->op[n].type = RX_Operand_Indirect;
212 disp = GETBYTE ();
213#if RX_OPCODE_BIG_ENDIAN
214 disp = disp * 256 + GETBYTE ();
215#else
216 disp = disp + GETBYTE () * 256;
217#endif
218 ld->rx->op[n].addend = disp * PSCALE[size];
219 break;
220 default:
221 abort ();
222 }
223}
224
3cf79a01
DD		 225#define xO 8
226#define xS 4
227#define xZ 2
228#define xC 1
c7927a3c 229
3cf79a01
DD		 230#define F_____
231#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
232#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
233#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
234#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
235#define F_O___ rx->flags_0 = rx->flags_s = xO;
236#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
237#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
238#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
c7927a3c
NC		 239
240int
241rx_decode_opcode (unsigned long pc AU,
242 RX_Opcode_Decoded * rx,
243 int (* getbyte)(void *),
244 void * ptr)
245{
246 LocalData lds, * ld = &lds;
247 unsigned char op[20] = {0};
248
249 lds.rx = rx;
250 lds.getbyte = getbyte;
251 lds.ptr = ptr;
252 lds.op = op;
253
254 memset (rx, 0, sizeof (*rx));
255 BWL(LSIZE);
256
257
258/*----------------------------------------------------------------------*/
259/* MOV */
260
261 GETBYTE ();
262 switch (op[0] & 0xff)
263 {
264 case 0x00:
265 {
266 /** 0000 0000 brk */
267 if (trace)
268 {
269 printf ("\033[33m%s\033[0m %02x\n",
270 "/** 0000 0000 brk */",
271 op[0]);
272 }
273 SYNTAX("brk");
f9c7014e 274#line 941 "rx-decode.opc"
c7927a3c
NC		 275 ID(brk);
276
277 }
278 break;
279 case 0x01:
280 {
281 /** 0000 0001 dbt */
282 if (trace)
283 {
284 printf ("\033[33m%s\033[0m %02x\n",
285 "/** 0000 0001 dbt */",
286 op[0]);
287 }
288 SYNTAX("dbt");
f9c7014e 289#line 944 "rx-decode.opc"
c7927a3c
NC		 290 ID(dbt);
291
292 }
293 break;
294 case 0x02:
295 {
296 /** 0000 0010 rts */
297 if (trace)
298 {
299 printf ("\033[33m%s\033[0m %02x\n",
300 "/** 0000 0010 rts */",
301 op[0]);
302 }
303 SYNTAX("rts");
f9c7014e 304#line 730 "rx-decode.opc"
c7927a3c
NC		 305 ID(rts);
306
307 /*----------------------------------------------------------------------*/
308 /* NOP */
309
310 }
311 break;
312 case 0x03:
313 {
314 /** 0000 0011 nop */
315 if (trace)
316 {
317 printf ("\033[33m%s\033[0m %02x\n",
318 "/** 0000 0011 nop */",
319 op[0]);
320 }
321 SYNTAX("nop");
f9c7014e 322#line 736 "rx-decode.opc"
c7927a3c
NC		 323 ID(nop);
324
325 /*----------------------------------------------------------------------*/
326 /* STRING FUNCTIONS */
327
328 }
329 break;
330 case 0x04:
331 {
332 /** 0000 0100 bra.a %a0 */
333 if (trace)
334 {
335 printf ("\033[33m%s\033[0m %02x\n",
336 "/** 0000 0100 bra.a %a0 */",
337 op[0]);
338 }
339 SYNTAX("bra.a %a0");
f9c7014e
DD		 340#line 708 "rx-decode.opc"
341 ID(branch); DC(pc + IMMex(3));
c7927a3c
NC		 342
343 }
344 break;
345 case 0x05:
346 {
347 /** 0000 0101 bsr.a %a0 */
348 if (trace)
349 {
350 printf ("\033[33m%s\033[0m %02x\n",
351 "/** 0000 0101 bsr.a %a0 */",
352 op[0]);
353 }
354 SYNTAX("bsr.a %a0");
f9c7014e 355#line 724 "rx-decode.opc"
c7927a3c
NC		 356 ID(jsr); DC(pc + IMMex(3));
357
358 }
359 break;
360 case 0x06:
361 GETBYTE ();
362 switch (op[1] & 0xff)
363 {
364 case 0x00:
365 GETBYTE ();
366 switch (op[2] & 0x00)
367 {
368 case 0x00:
369 op_semantics_1:
370 {
371 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
f9c7014e 372#line 505 "rx-decode.opc"
c7927a3c 373 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 374#line 505 "rx-decode.opc"
c7927a3c 375 int ss AU = op[1] & 0x03;
f9c7014e 376#line 505 "rx-decode.opc"
c7927a3c 377 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 378#line 505 "rx-decode.opc"
c7927a3c
NC		 379 int rdst AU = op[2] & 0x0f;
380 if (trace)
381 {
382 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
383 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
384 op[0], op[1], op[2]);
385 printf (" mx = 0x%x,", mx);
386 printf (" ss = 0x%x,", ss);
387 printf (" rsrc = 0x%x,", rsrc);
388 printf (" rdst = 0x%x\n", rdst);
389 }
390 SYNTAX("sub %2%S2, %1");
f9c7014e 391#line 505 "rx-decode.opc"
3cf79a01 392 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 393
394 }
395 break;
396 }
397 break;
398 case 0x01:
399 GETBYTE ();
400 switch (op[2] & 0x00)
401 {
402 case 0x00:
403 goto op_semantics_1;
404 break;
405 }
406 break;
407 case 0x02:
408 GETBYTE ();
409 switch (op[2] & 0x00)
410 {
411 case 0x00:
412 goto op_semantics_1;
413 break;
414 }
415 break;
416 case 0x03:
417 GETBYTE ();
418 switch (op[2] & 0x00)
419 {
420 case 0x00:
421 goto op_semantics_1;
422 break;
423 }
424 break;
425 case 0x04:
426 GETBYTE ();
427 switch (op[2] & 0x00)
428 {
429 case 0x00:
430 op_semantics_2:
431 {
432 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
f9c7014e 433#line 493 "rx-decode.opc"
c7927a3c 434 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 435#line 493 "rx-decode.opc"
c7927a3c 436 int ss AU = op[1] & 0x03;
f9c7014e 437#line 493 "rx-decode.opc"
c7927a3c 438 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 439#line 493 "rx-decode.opc"
c7927a3c
NC		 440 int rdst AU = op[2] & 0x0f;
441 if (trace)
442 {
443 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
444 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
445 op[0], op[1], op[2]);
446 printf (" mx = 0x%x,", mx);
447 printf (" ss = 0x%x,", ss);
448 printf (" rsrc = 0x%x,", rsrc);
449 printf (" rdst = 0x%x\n", rdst);
450 }
451 SYNTAX("cmp %2%S2, %1");
f9c7014e 452#line 493 "rx-decode.opc"
3cf79a01 453 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
c7927a3c
NC		 454
455 /*----------------------------------------------------------------------*/
456 /* SUB */
457
458 }
459 break;
460 }
461 break;
462 case 0x05:
463 GETBYTE ();
464 switch (op[2] & 0x00)
465 {
466 case 0x00:
467 goto op_semantics_2;
468 break;
469 }
470 break;
471 case 0x06:
472 GETBYTE ();
473 switch (op[2] & 0x00)
474 {
475 case 0x00:
476 goto op_semantics_2;
477 break;
478 }
479 break;
480 case 0x07:
481 GETBYTE ();
482 switch (op[2] & 0x00)
483 {
484 case 0x00:
485 goto op_semantics_2;
486 break;
487 }
488 break;
489 case 0x08:
490 GETBYTE ();
491 switch (op[2] & 0x00)
492 {
493 case 0x00:
494 op_semantics_3:
495 {
496 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
f9c7014e 497#line 469 "rx-decode.opc"
c7927a3c 498 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 499#line 469 "rx-decode.opc"
c7927a3c 500 int ss AU = op[1] & 0x03;
f9c7014e 501#line 469 "rx-decode.opc"
c7927a3c 502 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 503#line 469 "rx-decode.opc"
c7927a3c
NC		 504 int rdst AU = op[2] & 0x0f;
505 if (trace)
506 {
507 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
508 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
509 op[0], op[1], op[2]);
510 printf (" mx = 0x%x,", mx);
511 printf (" ss = 0x%x,", ss);
512 printf (" rsrc = 0x%x,", rsrc);
513 printf (" rdst = 0x%x\n", rdst);
514 }
515 SYNTAX("add %1%S1, %0");
f9c7014e 516#line 469 "rx-decode.opc"
3cf79a01 517 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
c7927a3c
NC		 518
519 }
520 break;
521 }
522 break;
523 case 0x09:
524 GETBYTE ();
525 switch (op[2] & 0x00)
526 {
527 case 0x00:
528 goto op_semantics_3;
529 break;
530 }
531 break;
532 case 0x0a:
533 GETBYTE ();
534 switch (op[2] & 0x00)
535 {
536 case 0x00:
537 goto op_semantics_3;
538 break;
539 }
540 break;
541 case 0x0b:
542 GETBYTE ();
543 switch (op[2] & 0x00)
544 {
545 case 0x00:
546 goto op_semantics_3;
547 break;
548 }
549 break;
550 case 0x0c:
551 GETBYTE ();
552 switch (op[2] & 0x00)
553 {
554 case 0x00:
555 op_semantics_4:
556 {
557 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
f9c7014e 558#line 573 "rx-decode.opc"
c7927a3c 559 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 560#line 573 "rx-decode.opc"
c7927a3c 561 int ss AU = op[1] & 0x03;
f9c7014e 562#line 573 "rx-decode.opc"
c7927a3c 563 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 564#line 573 "rx-decode.opc"
c7927a3c
NC		 565 int rdst AU = op[2] & 0x0f;
566 if (trace)
567 {
568 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
569 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
570 op[0], op[1], op[2]);
571 printf (" mx = 0x%x,", mx);
572 printf (" ss = 0x%x,", ss);
573 printf (" rsrc = 0x%x,", rsrc);
574 printf (" rdst = 0x%x\n", rdst);
575 }
576 SYNTAX("mul %1%S1, %0");
f9c7014e 577#line 573 "rx-decode.opc"
3cf79a01 578 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
c7927a3c
NC		 579
580 }
581 break;
582 }
583 break;
584 case 0x0d:
585 GETBYTE ();
586 switch (op[2] & 0x00)
587 {
588 case 0x00:
589 goto op_semantics_4;
590 break;
591 }
592 break;
593 case 0x0e:
594 GETBYTE ();
595 switch (op[2] & 0x00)
596 {
597 case 0x00:
598 goto op_semantics_4;
599 break;
600 }
601 break;
602 case 0x0f:
603 GETBYTE ();
604 switch (op[2] & 0x00)
605 {
606 case 0x00:
607 goto op_semantics_4;
608 break;
609 }
610 break;
611 case 0x10:
612 GETBYTE ();
613 switch (op[2] & 0x00)
614 {
615 case 0x00:
616 op_semantics_5:
617 {
618 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
f9c7014e 619#line 382 "rx-decode.opc"
c7927a3c 620 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 621#line 382 "rx-decode.opc"
c7927a3c 622 int ss AU = op[1] & 0x03;
f9c7014e 623#line 382 "rx-decode.opc"
c7927a3c 624 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 625#line 382 "rx-decode.opc"
c7927a3c
NC		 626 int rdst AU = op[2] & 0x0f;
627 if (trace)
628 {
629 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
630 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
631 op[0], op[1], op[2]);
632 printf (" mx = 0x%x,", mx);
633 printf (" ss = 0x%x,", ss);
634 printf (" rsrc = 0x%x,", rsrc);
635 printf (" rdst = 0x%x\n", rdst);
636 }
637 SYNTAX("and %1%S1, %0");
f9c7014e 638#line 382 "rx-decode.opc"
3cf79a01 639 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
c7927a3c
NC		 640
641 }
642 break;
643 }
644 break;
645 case 0x11:
646 GETBYTE ();
647 switch (op[2] & 0x00)
648 {
649 case 0x00:
650 goto op_semantics_5;
651 break;
652 }
653 break;
654 case 0x12:
655 GETBYTE ();
656 switch (op[2] & 0x00)
657 {
658 case 0x00:
659 goto op_semantics_5;
660 break;
661 }
662 break;
663 case 0x13:
664 GETBYTE ();
665 switch (op[2] & 0x00)
666 {
667 case 0x00:
668 goto op_semantics_5;
669 break;
670 }
671 break;
672 case 0x14:
673 GETBYTE ();
674 switch (op[2] & 0x00)
675 {
676 case 0x00:
677 op_semantics_6:
678 {
679 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
f9c7014e 680#line 400 "rx-decode.opc"
c7927a3c 681 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 682#line 400 "rx-decode.opc"
c7927a3c 683 int ss AU = op[1] & 0x03;
f9c7014e 684#line 400 "rx-decode.opc"
c7927a3c 685 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 686#line 400 "rx-decode.opc"
c7927a3c
NC		 687 int rdst AU = op[2] & 0x0f;
688 if (trace)
689 {
690 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
691 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
692 op[0], op[1], op[2]);
693 printf (" mx = 0x%x,", mx);
694 printf (" ss = 0x%x,", ss);
695 printf (" rsrc = 0x%x,", rsrc);
696 printf (" rdst = 0x%x\n", rdst);
697 }
698 SYNTAX("or %1%S1, %0");
f9c7014e 699#line 400 "rx-decode.opc"
3cf79a01 700 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
c7927a3c
NC		 701
702 }
703 break;
704 }
705 break;
706 case 0x15:
707 GETBYTE ();
708 switch (op[2] & 0x00)
709 {
710 case 0x00:
711 goto op_semantics_6;
712 break;
713 }
714 break;
715 case 0x16:
716 GETBYTE ();
717 switch (op[2] & 0x00)
718 {
719 case 0x00:
720 goto op_semantics_6;
721 break;
722 }
723 break;
724 case 0x17:
725 GETBYTE ();
726 switch (op[2] & 0x00)
727 {
728 case 0x00:
729 goto op_semantics_6;
730 break;
731 }
732 break;
733 case 0x20:
734 GETBYTE ();
735 switch (op[2] & 0xff)
736 {
737 case 0x00:
738 GETBYTE ();
739 switch (op[3] & 0x00)
740 {
741 case 0x00:
742 op_semantics_7:
743 {
744 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
f9c7014e 745#line 518 "rx-decode.opc"
c7927a3c 746 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 747#line 518 "rx-decode.opc"
c7927a3c 748 int sp AU = op[1] & 0x03;
f9c7014e 749#line 518 "rx-decode.opc"
c7927a3c 750 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 751#line 518 "rx-decode.opc"
c7927a3c
NC		 752 int rdst AU = op[3] & 0x0f;
753 if (trace)
754 {
755 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
756 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
757 op[0], op[1], op[2], op[3]);
758 printf (" mx = 0x%x,", mx);
759 printf (" sp = 0x%x,", sp);
760 printf (" rsrc = 0x%x,", rsrc);
761 printf (" rdst = 0x%x\n", rdst);
762 }
763 SYNTAX("sbb %1%S1, %0");
f9c7014e 764#line 518 "rx-decode.opc"
3cf79a01 765 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
c7927a3c
NC		 766
767 /*----------------------------------------------------------------------*/
768 /* ABS */
769
770 }
771 break;
772 }
773 break;
774 case 0x04:
775 GETBYTE ();
776 switch (op[3] & 0x00)
777 {
778 case 0x00:
779 op_semantics_8:
780 {
781 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
f9c7014e 782#line 546 "rx-decode.opc"
c7927a3c 783 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 784#line 546 "rx-decode.opc"
c7927a3c 785 int ss AU = op[1] & 0x03;
f9c7014e 786#line 546 "rx-decode.opc"
c7927a3c 787 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 788#line 546 "rx-decode.opc"
c7927a3c
NC		 789 int rdst AU = op[3] & 0x0f;
790 if (trace)
791 {
792 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
793 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
794 op[0], op[1], op[2], op[3]);
795 printf (" mx = 0x%x,", mx);
796 printf (" ss = 0x%x,", ss);
797 printf (" rsrc = 0x%x,", rsrc);
798 printf (" rdst = 0x%x\n", rdst);
799 }
800 SYNTAX("max %1%S1, %0");
f9c7014e 801#line 546 "rx-decode.opc"
c7927a3c
NC		 802 ID(max); SPm(ss, rsrc, mx); DR(rdst);
803
804 /*----------------------------------------------------------------------*/
805 /* MIN */
806
807 }
808 break;
809 }
810 break;
811 case 0x05:
812 GETBYTE ();
813 switch (op[3] & 0x00)
814 {
815 case 0x00:
816 op_semantics_9:
817 {
818 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
f9c7014e 819#line 558 "rx-decode.opc"
c7927a3c 820 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 821#line 558 "rx-decode.opc"
c7927a3c 822 int ss AU = op[1] & 0x03;
f9c7014e 823#line 558 "rx-decode.opc"
c7927a3c 824 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 825#line 558 "rx-decode.opc"
c7927a3c
NC		 826 int rdst AU = op[3] & 0x0f;
827 if (trace)
828 {
829 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
830 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
831 op[0], op[1], op[2], op[3]);
832 printf (" mx = 0x%x,", mx);
833 printf (" ss = 0x%x,", ss);
834 printf (" rsrc = 0x%x,", rsrc);
835 printf (" rdst = 0x%x\n", rdst);
836 }
837 SYNTAX("min %1%S1, %0");
f9c7014e 838#line 558 "rx-decode.opc"
c7927a3c
NC		 839 ID(min); SPm(ss, rsrc, mx); DR(rdst);
840
841 /*----------------------------------------------------------------------*/
842 /* MUL */
843
844 }
845 break;
846 }
847 break;
848 case 0x06:
849 GETBYTE ();
850 switch (op[3] & 0x00)
851 {
852 case 0x00:
853 op_semantics_10:
854 {
855 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
f9c7014e 856#line 588 "rx-decode.opc"
c7927a3c 857 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 858#line 588 "rx-decode.opc"
c7927a3c 859 int ss AU = op[1] & 0x03;
f9c7014e 860#line 588 "rx-decode.opc"
c7927a3c 861 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 862#line 588 "rx-decode.opc"
c7927a3c
NC		 863 int rdst AU = op[3] & 0x0f;
864 if (trace)
865 {
866 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
867 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
868 op[0], op[1], op[2], op[3]);
869 printf (" mx = 0x%x,", mx);
870 printf (" ss = 0x%x,", ss);
871 printf (" rsrc = 0x%x,", rsrc);
872 printf (" rdst = 0x%x\n", rdst);
873 }
874 SYNTAX("emul %1%S1, %0");
f9c7014e 875#line 588 "rx-decode.opc"
c7927a3c
NC		 876 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
877
878 /*----------------------------------------------------------------------*/
879 /* EMULU */
880
881 }
882 break;
883 }
884 break;
885 case 0x07:
886 GETBYTE ();
887 switch (op[3] & 0x00)
888 {
889 case 0x00:
890 op_semantics_11:
891 {
892 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
f9c7014e 893#line 600 "rx-decode.opc"
c7927a3c 894 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 895#line 600 "rx-decode.opc"
c7927a3c 896 int ss AU = op[1] & 0x03;
f9c7014e 897#line 600 "rx-decode.opc"
c7927a3c 898 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 899#line 600 "rx-decode.opc"
c7927a3c
NC		 900 int rdst AU = op[3] & 0x0f;
901 if (trace)
902 {
903 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
904 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
905 op[0], op[1], op[2], op[3]);
906 printf (" mx = 0x%x,", mx);
907 printf (" ss = 0x%x,", ss);
908 printf (" rsrc = 0x%x,", rsrc);
909 printf (" rdst = 0x%x\n", rdst);
910 }
911 SYNTAX("emulu %1%S1, %0");
f9c7014e 912#line 600 "rx-decode.opc"
c7927a3c
NC		 913 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
914
915 /*----------------------------------------------------------------------*/
916 /* DIV */
917
918 }
919 break;
920 }
921 break;
922 case 0x08:
923 GETBYTE ();
924 switch (op[3] & 0x00)
925 {
926 case 0x00:
927 op_semantics_12:
928 {
929 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
f9c7014e 930#line 612 "rx-decode.opc"
c7927a3c 931 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 932#line 612 "rx-decode.opc"
c7927a3c 933 int ss AU = op[1] & 0x03;
f9c7014e 934#line 612 "rx-decode.opc"
c7927a3c 935 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 936#line 612 "rx-decode.opc"
c7927a3c
NC		 937 int rdst AU = op[3] & 0x0f;
938 if (trace)
939 {
940 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
941 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
942 op[0], op[1], op[2], op[3]);
943 printf (" mx = 0x%x,", mx);
944 printf (" ss = 0x%x,", ss);
945 printf (" rsrc = 0x%x,", rsrc);
946 printf (" rdst = 0x%x\n", rdst);
947 }
948 SYNTAX("div %1%S1, %0");
f9c7014e 949#line 612 "rx-decode.opc"
3cf79a01 950 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
c7927a3c
NC		 951
952 /*----------------------------------------------------------------------*/
953 /* DIVU */
954
955 }
956 break;
957 }
958 break;
959 case 0x09:
960 GETBYTE ();
961 switch (op[3] & 0x00)
962 {
963 case 0x00:
964 op_semantics_13:
965 {
966 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
f9c7014e 967#line 624 "rx-decode.opc"
c7927a3c 968 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 969#line 624 "rx-decode.opc"
c7927a3c 970 int ss AU = op[1] & 0x03;
f9c7014e 971#line 624 "rx-decode.opc"
c7927a3c 972 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 973#line 624 "rx-decode.opc"
c7927a3c
NC		 974 int rdst AU = op[3] & 0x0f;
975 if (trace)
976 {
977 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
978 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
979 op[0], op[1], op[2], op[3]);
980 printf (" mx = 0x%x,", mx);
981 printf (" ss = 0x%x,", ss);
982 printf (" rsrc = 0x%x,", rsrc);
983 printf (" rdst = 0x%x\n", rdst);
984 }
985 SYNTAX("divu %1%S1, %0");
f9c7014e 986#line 624 "rx-decode.opc"
3cf79a01 987 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
c7927a3c
NC		 988
989 /*----------------------------------------------------------------------*/
990 /* SHIFT */
991
992 }
993 break;
994 }
995 break;
996 case 0x0c:
997 GETBYTE ();
998 switch (op[3] & 0x00)
999 {
1000 case 0x00:
1001 op_semantics_14:
1002 {
1003 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
f9c7014e 1004#line 436 "rx-decode.opc"
c7927a3c 1005 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 1006#line 436 "rx-decode.opc"
c7927a3c 1007 int ss AU = op[1] & 0x03;
f9c7014e 1008#line 436 "rx-decode.opc"
c7927a3c 1009 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 1010#line 436 "rx-decode.opc"
c7927a3c
NC		 1011 int rdst AU = op[3] & 0x0f;
1012 if (trace)
1013 {
1014 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1015 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1016 op[0], op[1], op[2], op[3]);
1017 printf (" mx = 0x%x,", mx);
1018 printf (" ss = 0x%x,", ss);
1019 printf (" rsrc = 0x%x,", rsrc);
1020 printf (" rdst = 0x%x\n", rdst);
1021 }
1022 SYNTAX("tst %1%S1, %2");
f9c7014e 1023#line 436 "rx-decode.opc"
3cf79a01 1024 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
c7927a3c
NC		 1025
1026 /*----------------------------------------------------------------------*/
1027 /* NEG */
1028
1029 }
1030 break;
1031 }
1032 break;
1033 case 0x0d:
1034 GETBYTE ();
1035 switch (op[3] & 0x00)
1036 {
1037 case 0x00:
1038 op_semantics_15:
1039 {
1040 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
f9c7014e 1041#line 415 "rx-decode.opc"
c7927a3c 1042 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 1043#line 415 "rx-decode.opc"
c7927a3c 1044 int ss AU = op[1] & 0x03;
f9c7014e 1045#line 415 "rx-decode.opc"
c7927a3c 1046 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 1047#line 415 "rx-decode.opc"
c7927a3c
NC		 1048 int rdst AU = op[3] & 0x0f;
1049 if (trace)
1050 {
1051 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1052 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1053 op[0], op[1], op[2], op[3]);
1054 printf (" mx = 0x%x,", mx);
1055 printf (" ss = 0x%x,", ss);
1056 printf (" rsrc = 0x%x,", rsrc);
1057 printf (" rdst = 0x%x\n", rdst);
1058 }
1059 SYNTAX("xor %1%S1, %0");
f9c7014e 1060#line 415 "rx-decode.opc"
3cf79a01 1061 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
c7927a3c
NC		 1062
1063 /*----------------------------------------------------------------------*/
1064 /* NOT */
1065
1066 }
1067 break;
1068 }
1069 break;
1070 case 0x10:
1071 GETBYTE ();
1072 switch (op[3] & 0x00)
1073 {
1074 case 0x00:
1075 op_semantics_16:
1076 {
1077 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
f9c7014e 1078#line 349 "rx-decode.opc"
c7927a3c 1079 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 1080#line 349 "rx-decode.opc"
c7927a3c 1081 int ss AU = op[1] & 0x03;
f9c7014e 1082#line 349 "rx-decode.opc"
c7927a3c 1083 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 1084#line 349 "rx-decode.opc"
c7927a3c
NC		 1085 int rdst AU = op[3] & 0x0f;
1086 if (trace)
1087 {
1088 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1089 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1090 op[0], op[1], op[2], op[3]);
1091 printf (" mx = 0x%x,", mx);
1092 printf (" ss = 0x%x,", ss);
1093 printf (" rsrc = 0x%x,", rsrc);
1094 printf (" rdst = 0x%x\n", rdst);
1095 }
1096 SYNTAX("xchg %1%S1, %0");
f9c7014e 1097#line 349 "rx-decode.opc"
c7927a3c
NC		 1098 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1099
1100 /*----------------------------------------------------------------------*/
1101 /* STZ/STNZ */
1102
1103 }
1104 break;
1105 }
1106 break;
1107 case 0x11:
1108 GETBYTE ();
1109 switch (op[3] & 0x00)
1110 {
1111 case 0x00:
1112 op_semantics_17:
1113 {
1114 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
f9c7014e 1115#line 853 "rx-decode.opc"
c7927a3c 1116 int mx AU = (op[1] >> 6) & 0x03;
f9c7014e 1117#line 853 "rx-decode.opc"
c7927a3c 1118 int sd AU = op[1] & 0x03;
f9c7014e 1119#line 853 "rx-decode.opc"
c7927a3c 1120 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 1121#line 853 "rx-decode.opc"
c7927a3c
NC		 1122 int rdst AU = op[3] & 0x0f;
1123 if (trace)
1124 {
1125 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1126 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1127 op[0], op[1], op[2], op[3]);
1128 printf (" mx = 0x%x,", mx);
1129 printf (" sd = 0x%x,", sd);
1130 printf (" rsrc = 0x%x,", rsrc);
1131 printf (" rdst = 0x%x\n", rdst);
1132 }
1133 SYNTAX("itof %1%S1, %0");
f9c7014e 1134#line 853 "rx-decode.opc"
3cf79a01 1135 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
c7927a3c
NC		 1136
1137 /*----------------------------------------------------------------------*/
1138 /* BIT OPS */
1139
1140 }
1141 break;
1142 }
1143 break;
1144 default: UNSUPPORTED(); break;
1145 }
1146 break;
1147 case 0x21:
1148 GETBYTE ();
1149 switch (op[2] & 0xff)
1150 {
1151 case 0x00:
1152 GETBYTE ();
1153 switch (op[3] & 0x00)
1154 {
1155 case 0x00:
1156 goto op_semantics_7;
1157 break;
1158 }
1159 break;
1160 case 0x04:
1161 GETBYTE ();
1162 switch (op[3] & 0x00)
1163 {
1164 case 0x00:
1165 goto op_semantics_8;
1166 break;
1167 }
1168 break;
1169 case 0x05:
1170 GETBYTE ();
1171 switch (op[3] & 0x00)
1172 {
1173 case 0x00:
1174 goto op_semantics_9;
1175 break;
1176 }
1177 break;
1178 case 0x06:
1179 GETBYTE ();
1180 switch (op[3] & 0x00)
1181 {
1182 case 0x00:
1183 goto op_semantics_10;
1184 break;
1185 }
1186 break;
1187 case 0x07:
1188 GETBYTE ();
1189 switch (op[3] & 0x00)
1190 {
1191 case 0x00:
1192 goto op_semantics_11;
1193 break;
1194 }
1195 break;
1196 case 0x08:
1197 GETBYTE ();
1198 switch (op[3] & 0x00)
1199 {
1200 case 0x00:
1201 goto op_semantics_12;
1202 break;
1203 }
1204 break;
1205 case 0x09:
1206 GETBYTE ();
1207 switch (op[3] & 0x00)
1208 {
1209 case 0x00:
1210 goto op_semantics_13;
1211 break;
1212 }
1213 break;
1214 case 0x0c:
1215 GETBYTE ();
1216 switch (op[3] & 0x00)
1217 {
1218 case 0x00:
1219 goto op_semantics_14;
1220 break;
1221 }
1222 break;
1223 case 0x0d:
1224 GETBYTE ();
1225 switch (op[3] & 0x00)
1226 {
1227 case 0x00:
1228 goto op_semantics_15;
1229 break;
1230 }
1231 break;
1232 case 0x10:
1233 GETBYTE ();
1234 switch (op[3] & 0x00)
1235 {
1236 case 0x00:
1237 goto op_semantics_16;
1238 break;
1239 }
1240 break;
1241 case 0x11:
1242 GETBYTE ();
1243 switch (op[3] & 0x00)
1244 {
1245 case 0x00:
1246 goto op_semantics_17;
1247 break;
1248 }
1249 break;
1250 default: UNSUPPORTED(); break;
1251 }
1252 break;
1253 case 0x22:
1254 GETBYTE ();
1255 switch (op[2] & 0xff)
1256 {
1257 case 0x00:
1258 GETBYTE ();
1259 switch (op[3] & 0x00)
1260 {
1261 case 0x00:
1262 goto op_semantics_7;
1263 break;
1264 }
1265 break;
1266 case 0x04:
1267 GETBYTE ();
1268 switch (op[3] & 0x00)
1269 {
1270 case 0x00:
1271 goto op_semantics_8;
1272 break;
1273 }
1274 break;
1275 case 0x05:
1276 GETBYTE ();
1277 switch (op[3] & 0x00)
1278 {
1279 case 0x00:
1280 goto op_semantics_9;
1281 break;
1282 }
1283 break;
1284 case 0x06:
1285 GETBYTE ();
1286 switch (op[3] & 0x00)
1287 {
1288 case 0x00:
1289 goto op_semantics_10;
1290 break;
1291 }
1292 break;
1293 case 0x07:
1294 GETBYTE ();
1295 switch (op[3] & 0x00)
1296 {
1297 case 0x00:
1298 goto op_semantics_11;
1299 break;
1300 }
1301 break;
1302 case 0x08:
1303 GETBYTE ();
1304 switch (op[3] & 0x00)
1305 {
1306 case 0x00:
1307 goto op_semantics_12;
1308 break;
1309 }
1310 break;
1311 case 0x09:
1312 GETBYTE ();
1313 switch (op[3] & 0x00)
1314 {
1315 case 0x00:
1316 goto op_semantics_13;
1317 break;
1318 }
1319 break;
1320 case 0x0c:
1321 GETBYTE ();
1322 switch (op[3] & 0x00)
1323 {
1324 case 0x00:
1325 goto op_semantics_14;
1326 break;
1327 }
1328 break;
1329 case 0x0d:
1330 GETBYTE ();
1331 switch (op[3] & 0x00)
1332 {
1333 case 0x00:
1334 goto op_semantics_15;
1335 break;
1336 }
1337 break;
1338 case 0x10:
1339 GETBYTE ();
1340 switch (op[3] & 0x00)
1341 {
1342 case 0x00:
1343 goto op_semantics_16;
1344 break;
1345 }
1346 break;
1347 case 0x11:
1348 GETBYTE ();
1349 switch (op[3] & 0x00)
1350 {
1351 case 0x00:
1352 goto op_semantics_17;
1353 break;
1354 }
1355 break;
1356 default: UNSUPPORTED(); break;
1357 }
1358 break;
1359 case 0x23:
1360 GETBYTE ();
1361 switch (op[2] & 0xff)
1362 {
1363 case 0x00:
1364 GETBYTE ();
1365 switch (op[3] & 0x00)
1366 {
1367 case 0x00:
1368 goto op_semantics_7;
1369 break;
1370 }
1371 break;
1372 case 0x04:
1373 GETBYTE ();
1374 switch (op[3] & 0x00)
1375 {
1376 case 0x00:
1377 goto op_semantics_8;
1378 break;
1379 }
1380 break;
1381 case 0x05:
1382 GETBYTE ();
1383 switch (op[3] & 0x00)
1384 {
1385 case 0x00:
1386 goto op_semantics_9;
1387 break;
1388 }
1389 break;
1390 case 0x06:
1391 GETBYTE ();
1392 switch (op[3] & 0x00)
1393 {
1394 case 0x00:
1395 goto op_semantics_10;
1396 break;
1397 }
1398 break;
1399 case 0x07:
1400 GETBYTE ();
1401 switch (op[3] & 0x00)
1402 {
1403 case 0x00:
1404 goto op_semantics_11;
1405 break;
1406 }
1407 break;
1408 case 0x08:
1409 GETBYTE ();
1410 switch (op[3] & 0x00)
1411 {
1412 case 0x00:
1413 goto op_semantics_12;
1414 break;
1415 }
1416 break;
1417 case 0x09:
1418 GETBYTE ();
1419 switch (op[3] & 0x00)
1420 {
1421 case 0x00:
1422 goto op_semantics_13;
1423 break;
1424 }
1425 break;
1426 case 0x0c:
1427 GETBYTE ();
1428 switch (op[3] & 0x00)
1429 {
1430 case 0x00:
1431 goto op_semantics_14;
1432 break;
1433 }
1434 break;
1435 case 0x0d:
1436 GETBYTE ();
1437 switch (op[3] & 0x00)
1438 {
1439 case 0x00:
1440 goto op_semantics_15;
1441 break;
1442 }
1443 break;
1444 case 0x10:
1445 GETBYTE ();
1446 switch (op[3] & 0x00)
1447 {
1448 case 0x00:
1449 goto op_semantics_16;
1450 break;
1451 }
1452 break;
1453 case 0x11:
1454 GETBYTE ();
1455 switch (op[3] & 0x00)
1456 {
1457 case 0x00:
1458 goto op_semantics_17;
1459 break;
1460 }
1461 break;
1462 default: UNSUPPORTED(); break;
1463 }
1464 break;
1465 case 0x40:
1466 GETBYTE ();
1467 switch (op[2] & 0x00)
1468 {
1469 case 0x00:
1470 goto op_semantics_1;
1471 break;
1472 }
1473 break;
1474 case 0x41:
1475 GETBYTE ();
1476 switch (op[2] & 0x00)
1477 {
1478 case 0x00:
1479 goto op_semantics_1;
1480 break;
1481 }
1482 break;
1483 case 0x42:
1484 GETBYTE ();
1485 switch (op[2] & 0x00)
1486 {
1487 case 0x00:
1488 goto op_semantics_1;
1489 break;
1490 }
1491 break;
1492 case 0x43:
1493 GETBYTE ();
1494 switch (op[2] & 0x00)
1495 {
1496 case 0x00:
1497 goto op_semantics_1;
1498 break;
1499 }
1500 break;
1501 case 0x44:
1502 GETBYTE ();
1503 switch (op[2] & 0x00)
1504 {
1505 case 0x00:
1506 goto op_semantics_2;
1507 break;
1508 }
1509 break;
1510 case 0x45:
1511 GETBYTE ();
1512 switch (op[2] & 0x00)
1513 {
1514 case 0x00:
1515 goto op_semantics_2;
1516 break;
1517 }
1518 break;
1519 case 0x46:
1520 GETBYTE ();
1521 switch (op[2] & 0x00)
1522 {
1523 case 0x00:
1524 goto op_semantics_2;
1525 break;
1526 }
1527 break;
1528 case 0x47:
1529 GETBYTE ();
1530 switch (op[2] & 0x00)
1531 {
1532 case 0x00:
1533 goto op_semantics_2;
1534 break;
1535 }
1536 break;
1537 case 0x48:
1538 GETBYTE ();
1539 switch (op[2] & 0x00)
1540 {
1541 case 0x00:
1542 goto op_semantics_3;
1543 break;
1544 }
1545 break;
1546 case 0x49:
1547 GETBYTE ();
1548 switch (op[2] & 0x00)
1549 {
1550 case 0x00:
1551 goto op_semantics_3;
1552 break;
1553 }
1554 break;
1555 case 0x4a:
1556 GETBYTE ();
1557 switch (op[2] & 0x00)
1558 {
1559 case 0x00:
1560 goto op_semantics_3;
1561 break;
1562 }
1563 break;
1564 case 0x4b:
1565 GETBYTE ();
1566 switch (op[2] & 0x00)
1567 {
1568 case 0x00:
1569 goto op_semantics_3;
1570 break;
1571 }
1572 break;
1573 case 0x4c:
1574 GETBYTE ();
1575 switch (op[2] & 0x00)
1576 {
1577 case 0x00:
1578 goto op_semantics_4;
1579 break;
1580 }
1581 break;
1582 case 0x4d:
1583 GETBYTE ();
1584 switch (op[2] & 0x00)
1585 {
1586 case 0x00:
1587 goto op_semantics_4;
1588 break;
1589 }
1590 break;
1591 case 0x4e:
1592 GETBYTE ();
1593 switch (op[2] & 0x00)
1594 {
1595 case 0x00:
1596 goto op_semantics_4;
1597 break;
1598 }
1599 break;
1600 case 0x4f:
1601 GETBYTE ();
1602 switch (op[2] & 0x00)
1603 {
1604 case 0x00:
1605 goto op_semantics_4;
1606 break;
1607 }
1608 break;
1609 case 0x50:
1610 GETBYTE ();
1611 switch (op[2] & 0x00)
1612 {
1613 case 0x00:
1614 goto op_semantics_5;
1615 break;
1616 }
1617 break;
1618 case 0x51:
1619 GETBYTE ();
1620 switch (op[2] & 0x00)
1621 {
1622 case 0x00:
1623 goto op_semantics_5;
1624 break;
1625 }
1626 break;
1627 case 0x52:
1628 GETBYTE ();
1629 switch (op[2] & 0x00)
1630 {
1631 case 0x00:
1632 goto op_semantics_5;
1633 break;
1634 }
1635 break;
1636 case 0x53:
1637 GETBYTE ();
1638 switch (op[2] & 0x00)
1639 {
1640 case 0x00:
1641 goto op_semantics_5;
1642 break;
1643 }
1644 break;
1645 case 0x54:
1646 GETBYTE ();
1647 switch (op[2] & 0x00)
1648 {
1649 case 0x00:
1650 goto op_semantics_6;
1651 break;
1652 }
1653 break;
1654 case 0x55:
1655 GETBYTE ();
1656 switch (op[2] & 0x00)
1657 {
1658 case 0x00:
1659 goto op_semantics_6;
1660 break;
1661 }
1662 break;
1663 case 0x56:
1664 GETBYTE ();
1665 switch (op[2] & 0x00)
1666 {
1667 case 0x00:
1668 goto op_semantics_6;
1669 break;
1670 }
1671 break;
1672 case 0x57:
1673 GETBYTE ();
1674 switch (op[2] & 0x00)
1675 {
1676 case 0x00:
1677 goto op_semantics_6;
1678 break;
1679 }
1680 break;
1681 case 0x60:
1682 GETBYTE ();
1683 switch (op[2] & 0xff)
1684 {
1685 case 0x00:
1686 GETBYTE ();
1687 switch (op[3] & 0x00)
1688 {
1689 case 0x00:
1690 goto op_semantics_7;
1691 break;
1692 }
1693 break;
1694 case 0x04:
1695 GETBYTE ();
1696 switch (op[3] & 0x00)
1697 {
1698 case 0x00:
1699 goto op_semantics_8;
1700 break;
1701 }
1702 break;
1703 case 0x05:
1704 GETBYTE ();
1705 switch (op[3] & 0x00)
1706 {
1707 case 0x00:
1708 goto op_semantics_9;
1709 break;
1710 }
1711 break;
1712 case 0x06:
1713 GETBYTE ();
1714 switch (op[3] & 0x00)
1715 {
1716 case 0x00:
1717 goto op_semantics_10;
1718 break;
1719 }
1720 break;
1721 case 0x07:
1722 GETBYTE ();
1723 switch (op[3] & 0x00)
1724 {
1725 case 0x00:
1726 goto op_semantics_11;
1727 break;
1728 }
1729 break;
1730 case 0x08:
1731 GETBYTE ();
1732 switch (op[3] & 0x00)
1733 {
1734 case 0x00:
1735 goto op_semantics_12;
1736 break;
1737 }
1738 break;
1739 case 0x09:
1740 GETBYTE ();
1741 switch (op[3] & 0x00)
1742 {
1743 case 0x00:
1744 goto op_semantics_13;
1745 break;
1746 }
1747 break;
1748 case 0x0c:
1749 GETBYTE ();
1750 switch (op[3] & 0x00)
1751 {
1752 case 0x00:
1753 goto op_semantics_14;
1754 break;
1755 }
1756 break;
1757 case 0x0d:
1758 GETBYTE ();
1759 switch (op[3] & 0x00)
1760 {
1761 case 0x00:
1762 goto op_semantics_15;
1763 break;
1764 }
1765 break;
1766 case 0x10:
1767 GETBYTE ();
1768 switch (op[3] & 0x00)
1769 {
1770 case 0x00:
1771 goto op_semantics_16;
1772 break;
1773 }
1774 break;
1775 case 0x11:
1776 GETBYTE ();
1777 switch (op[3] & 0x00)
1778 {
1779 case 0x00:
1780 goto op_semantics_17;
1781 break;
1782 }
1783 break;
1784 default: UNSUPPORTED(); break;
1785 }
1786 break;
1787 case 0x61:
1788 GETBYTE ();
1789 switch (op[2] & 0xff)
1790 {
1791 case 0x00:
1792 GETBYTE ();
1793 switch (op[3] & 0x00)
1794 {
1795 case 0x00:
1796 goto op_semantics_7;
1797 break;
1798 }
1799 break;
1800 case 0x04:
1801 GETBYTE ();
1802 switch (op[3] & 0x00)
1803 {
1804 case 0x00:
1805 goto op_semantics_8;
1806 break;
1807 }
1808 break;
1809 case 0x05:
1810 GETBYTE ();
1811 switch (op[3] & 0x00)
1812 {
1813 case 0x00:
1814 goto op_semantics_9;
1815 break;
1816 }
1817 break;
1818 case 0x06:
1819 GETBYTE ();
1820 switch (op[3] & 0x00)
1821 {
1822 case 0x00:
1823 goto op_semantics_10;
1824 break;
1825 }
1826 break;
1827 case 0x07:
1828 GETBYTE ();
1829 switch (op[3] & 0x00)
1830 {
1831 case 0x00:
1832 goto op_semantics_11;
1833 break;
1834 }
1835 break;
1836 case 0x08:
1837 GETBYTE ();
1838 switch (op[3] & 0x00)
1839 {
1840 case 0x00:
1841 goto op_semantics_12;
1842 break;
1843 }
1844 break;
1845 case 0x09:
1846 GETBYTE ();
1847 switch (op[3] & 0x00)
1848 {
1849 case 0x00:
1850 goto op_semantics_13;
1851 break;
1852 }
1853 break;
1854 case 0x0c:
1855 GETBYTE ();
1856 switch (op[3] & 0x00)
1857 {
1858 case 0x00:
1859 goto op_semantics_14;
1860 break;
1861 }
1862 break;
1863 case 0x0d:
1864 GETBYTE ();
1865 switch (op[3] & 0x00)
1866 {
1867 case 0x00:
1868 goto op_semantics_15;
1869 break;
1870 }
1871 break;
1872 case 0x10:
1873 GETBYTE ();
1874 switch (op[3] & 0x00)
1875 {
1876 case 0x00:
1877 goto op_semantics_16;
1878 break;
1879 }
1880 break;
1881 case 0x11:
1882 GETBYTE ();
1883 switch (op[3] & 0x00)
1884 {
1885 case 0x00:
1886 goto op_semantics_17;
1887 break;
1888 }
1889 break;
1890 default: UNSUPPORTED(); break;
1891 }
1892 break;
1893 case 0x62:
1894 GETBYTE ();
1895 switch (op[2] & 0xff)
1896 {
1897 case 0x00:
1898 GETBYTE ();
1899 switch (op[3] & 0x00)
1900 {
1901 case 0x00:
1902 goto op_semantics_7;
1903 break;
1904 }
1905 break;
1906 case 0x04:
1907 GETBYTE ();
1908 switch (op[3] & 0x00)
1909 {
1910 case 0x00:
1911 goto op_semantics_8;
1912 break;
1913 }
1914 break;
1915 case 0x05:
1916 GETBYTE ();
1917 switch (op[3] & 0x00)
1918 {
1919 case 0x00:
1920 goto op_semantics_9;
1921 break;
1922 }
1923 break;
1924 case 0x06:
1925 GETBYTE ();
1926 switch (op[3] & 0x00)
1927 {
1928 case 0x00:
1929 goto op_semantics_10;
1930 break;
1931 }
1932 break;
1933 case 0x07:
1934 GETBYTE ();
1935 switch (op[3] & 0x00)
1936 {
1937 case 0x00:
1938 goto op_semantics_11;
1939 break;
1940 }
1941 break;
1942 case 0x08:
1943 GETBYTE ();
1944 switch (op[3] & 0x00)
1945 {
1946 case 0x00:
1947 goto op_semantics_12;
1948 break;
1949 }
1950 break;
1951 case 0x09:
1952 GETBYTE ();
1953 switch (op[3] & 0x00)
1954 {
1955 case 0x00:
1956 goto op_semantics_13;
1957 break;
1958 }
1959 break;
1960 case 0x0c:
1961 GETBYTE ();
1962 switch (op[3] & 0x00)
1963 {
1964 case 0x00:
1965 goto op_semantics_14;
1966 break;
1967 }
1968 break;
1969 case 0x0d:
1970 GETBYTE ();
1971 switch (op[3] & 0x00)
1972 {
1973 case 0x00:
1974 goto op_semantics_15;
1975 break;
1976 }
1977 break;
1978 case 0x10:
1979 GETBYTE ();
1980 switch (op[3] & 0x00)
1981 {
1982 case 0x00:
1983 goto op_semantics_16;
1984 break;
1985 }
1986 break;
1987 case 0x11:
1988 GETBYTE ();
1989 switch (op[3] & 0x00)
1990 {
1991 case 0x00:
1992 goto op_semantics_17;
1993 break;
1994 }
1995 break;
1996 default: UNSUPPORTED(); break;
1997 }
1998 break;
1999 case 0x63:
2000 GETBYTE ();
2001 switch (op[2] & 0xff)
2002 {
2003 case 0x00:
2004 GETBYTE ();
2005 switch (op[3] & 0x00)
2006 {
2007 case 0x00:
2008 goto op_semantics_7;
2009 break;
2010 }
2011 break;
2012 case 0x04:
2013 GETBYTE ();
2014 switch (op[3] & 0x00)
2015 {
2016 case 0x00:
2017 goto op_semantics_8;
2018 break;
2019 }
2020 break;
2021 case 0x05:
2022 GETBYTE ();
2023 switch (op[3] & 0x00)
2024 {
2025 case 0x00:
2026 goto op_semantics_9;
2027 break;
2028 }
2029 break;
2030 case 0x06:
2031 GETBYTE ();
2032 switch (op[3] & 0x00)
2033 {
2034 case 0x00:
2035 goto op_semantics_10;
2036 break;
2037 }
2038 break;
2039 case 0x07:
2040 GETBYTE ();
2041 switch (op[3] & 0x00)
2042 {
2043 case 0x00:
2044 goto op_semantics_11;
2045 break;
2046 }
2047 break;
2048 case 0x08:
2049 GETBYTE ();
2050 switch (op[3] & 0x00)
2051 {
2052 case 0x00:
2053 goto op_semantics_12;
2054 break;
2055 }
2056 break;
2057 case 0x09:
2058 GETBYTE ();
2059 switch (op[3] & 0x00)
2060 {
2061 case 0x00:
2062 goto op_semantics_13;
2063 break;
2064 }
2065 break;
2066 case 0x0c:
2067 GETBYTE ();
2068 switch (op[3] & 0x00)
2069 {
2070 case 0x00:
2071 goto op_semantics_14;
2072 break;
2073 }
2074 break;
2075 case 0x0d:
2076 GETBYTE ();
2077 switch (op[3] & 0x00)
2078 {
2079 case 0x00:
2080 goto op_semantics_15;
2081 break;
2082 }
2083 break;
2084 case 0x10:
2085 GETBYTE ();
2086 switch (op[3] & 0x00)
2087 {
2088 case 0x00:
2089 goto op_semantics_16;
2090 break;
2091 }
2092 break;
2093 case 0x11:
2094 GETBYTE ();
2095 switch (op[3] & 0x00)
2096 {
2097 case 0x00:
2098 goto op_semantics_17;
2099 break;
2100 }
2101 break;
2102 default: UNSUPPORTED(); break;
2103 }
2104 break;
2105 case 0x80:
2106 GETBYTE ();
2107 switch (op[2] & 0x00)
2108 {
2109 case 0x00:
2110 goto op_semantics_1;
2111 break;
2112 }
2113 break;
2114 case 0x81:
2115 GETBYTE ();
2116 switch (op[2] & 0x00)
2117 {
2118 case 0x00:
2119 goto op_semantics_1;
2120 break;
2121 }
2122 break;
2123 case 0x82:
2124 GETBYTE ();
2125 switch (op[2] & 0x00)
2126 {
2127 case 0x00:
2128 goto op_semantics_1;
2129 break;
2130 }
2131 break;
2132 case 0x83:
2133 GETBYTE ();
2134 switch (op[2] & 0x00)
2135 {
2136 case 0x00:
2137 goto op_semantics_1;
2138 break;
2139 }
2140 break;
2141 case 0x84:
2142 GETBYTE ();
2143 switch (op[2] & 0x00)
2144 {
2145 case 0x00:
2146 goto op_semantics_2;
2147 break;
2148 }
2149 break;
2150 case 0x85:
2151 GETBYTE ();
2152 switch (op[2] & 0x00)
2153 {
2154 case 0x00:
2155 goto op_semantics_2;
2156 break;
2157 }
2158 break;
2159 case 0x86:
2160 GETBYTE ();
2161 switch (op[2] & 0x00)
2162 {
2163 case 0x00:
2164 goto op_semantics_2;
2165 break;
2166 }
2167 break;
2168 case 0x87:
2169 GETBYTE ();
2170 switch (op[2] & 0x00)
2171 {
2172 case 0x00:
2173 goto op_semantics_2;
2174 break;
2175 }
2176 break;
2177 case 0x88:
2178 GETBYTE ();
2179 switch (op[2] & 0x00)
2180 {
2181 case 0x00:
2182 goto op_semantics_3;
2183 break;
2184 }
2185 break;
2186 case 0x89:
2187 GETBYTE ();
2188 switch (op[2] & 0x00)
2189 {
2190 case 0x00:
2191 goto op_semantics_3;
2192 break;
2193 }
2194 break;
2195 case 0x8a:
2196 GETBYTE ();
2197 switch (op[2] & 0x00)
2198 {
2199 case 0x00:
2200 goto op_semantics_3;
2201 break;
2202 }
2203 break;
2204 case 0x8b:
2205 GETBYTE ();
2206 switch (op[2] & 0x00)
2207 {
2208 case 0x00:
2209 goto op_semantics_3;
2210 break;
2211 }
2212 break;
2213 case 0x8c:
2214 GETBYTE ();
2215 switch (op[2] & 0x00)
2216 {
2217 case 0x00:
2218 goto op_semantics_4;
2219 break;
2220 }
2221 break;
2222 case 0x8d:
2223 GETBYTE ();
2224 switch (op[2] & 0x00)
2225 {
2226 case 0x00:
2227 goto op_semantics_4;
2228 break;
2229 }
2230 break;
2231 case 0x8e:
2232 GETBYTE ();
2233 switch (op[2] & 0x00)
2234 {
2235 case 0x00:
2236 goto op_semantics_4;
2237 break;
2238 }
2239 break;
2240 case 0x8f:
2241 GETBYTE ();
2242 switch (op[2] & 0x00)
2243 {
2244 case 0x00:
2245 goto op_semantics_4;
2246 break;
2247 }
2248 break;
2249 case 0x90:
2250 GETBYTE ();
2251 switch (op[2] & 0x00)
2252 {
2253 case 0x00:
2254 goto op_semantics_5;
2255 break;
2256 }
2257 break;
2258 case 0x91:
2259 GETBYTE ();
2260 switch (op[2] & 0x00)
2261 {
2262 case 0x00:
2263 goto op_semantics_5;
2264 break;
2265 }
2266 break;
2267 case 0x92:
2268 GETBYTE ();
2269 switch (op[2] & 0x00)
2270 {
2271 case 0x00:
2272 goto op_semantics_5;
2273 break;
2274 }
2275 break;
2276 case 0x93:
2277 GETBYTE ();
2278 switch (op[2] & 0x00)
2279 {
2280 case 0x00:
2281 goto op_semantics_5;
2282 break;
2283 }
2284 break;
2285 case 0x94:
2286 GETBYTE ();
2287 switch (op[2] & 0x00)
2288 {
2289 case 0x00:
2290 goto op_semantics_6;
2291 break;
2292 }
2293 break;
2294 case 0x95:
2295 GETBYTE ();
2296 switch (op[2] & 0x00)
2297 {
2298 case 0x00:
2299 goto op_semantics_6;
2300 break;
2301 }
2302 break;
2303 case 0x96:
2304 GETBYTE ();
2305 switch (op[2] & 0x00)
2306 {
2307 case 0x00:
2308 goto op_semantics_6;
2309 break;
2310 }
2311 break;
2312 case 0x97:
2313 GETBYTE ();
2314 switch (op[2] & 0x00)
2315 {
2316 case 0x00:
2317 goto op_semantics_6;
2318 break;
2319 }
2320 break;
2321 case 0xa0:
2322 GETBYTE ();
2323 switch (op[2] & 0xff)
2324 {
2325 case 0x00:
2326 GETBYTE ();
2327 switch (op[3] & 0x00)
2328 {
2329 case 0x00:
2330 goto op_semantics_7;
2331 break;
2332 }
2333 break;
2334 case 0x02:
2335 GETBYTE ();
2336 switch (op[3] & 0x00)
2337 {
2338 case 0x00:
2339 op_semantics_18:
2340 {
2341 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
f9c7014e 2342#line 457 "rx-decode.opc"
c7927a3c 2343 int ss AU = op[1] & 0x03;
f9c7014e 2344#line 457 "rx-decode.opc"
c7927a3c 2345 int rsrc AU = (op[3] >> 4) & 0x0f;
f9c7014e 2346#line 457 "rx-decode.opc"
c7927a3c
NC		 2347 int rdst AU = op[3] & 0x0f;
2348 if (trace)
2349 {
2350 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2351 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2352 op[0], op[1], op[2], op[3]);
2353 printf (" ss = 0x%x,", ss);
2354 printf (" rsrc = 0x%x,", rsrc);
2355 printf (" rdst = 0x%x\n", rdst);
2356 }
2357 SYNTAX("adc %1%S1, %0");
f9c7014e 2358#line 457 "rx-decode.opc"
3cf79a01 2359 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
c7927a3c
NC		 2360
2361 /*----------------------------------------------------------------------*/
2362 /* ADD */
2363
2364 }
2365 break;
2366 }
2367 break;
2368 case 0x04:
2369 GETBYTE ();
2370 switch (op[3] & 0x00)
2371 {
2372 case 0x00:
2373 goto op_semantics_8;
2374 break;
2375 }
2376 break;
2377 case 0x05:
2378 GETBYTE ();
2379 switch (op[3] & 0x00)
2380 {
2381 case 0x00:
2382 goto op_semantics_9;
2383 break;
2384 }
2385 break;
2386 case 0x06:
2387 GETBYTE ();
2388 switch (op[3] & 0x00)
2389 {
2390 case 0x00:
2391 goto op_semantics_10;
2392 break;
2393 }
2394 break;
2395 case 0x07:
2396 GETBYTE ();
2397 switch (op[3] & 0x00)
2398 {
2399 case 0x00:
2400 goto op_semantics_11;
2401 break;
2402 }
2403 break;
2404 case 0x08:
2405 GETBYTE ();
2406 switch (op[3] & 0x00)
2407 {
2408 case 0x00:
2409 goto op_semantics_12;
2410 break;
2411 }
2412 break;
2413 case 0x09:
2414 GETBYTE ();
2415 switch (op[3] & 0x00)
2416 {
2417 case 0x00:
2418 goto op_semantics_13;
2419 break;
2420 }
2421 break;
2422 case 0x0c:
2423 GETBYTE ();
2424 switch (op[3] & 0x00)
2425 {
2426 case 0x00:
2427 goto op_semantics_14;
2428 break;
2429 }
2430 break;
2431 case 0x0d:
2432 GETBYTE ();
2433 switch (op[3] & 0x00)
2434 {
2435 case 0x00:
2436 goto op_semantics_15;
2437 break;
2438 }
2439 break;
2440 case 0x10:
2441 GETBYTE ();
2442 switch (op[3] & 0x00)
2443 {
2444 case 0x00:
2445 goto op_semantics_16;
2446 break;
2447 }
2448 break;
2449 case 0x11:
2450 GETBYTE ();
2451 switch (op[3] & 0x00)
2452 {
2453 case 0x00:
2454 goto op_semantics_17;
2455 break;
2456 }
2457 break;
2458 default: UNSUPPORTED(); break;
2459 }
2460 break;
2461 case 0xa1:
2462 GETBYTE ();
2463 switch (op[2] & 0xff)
2464 {
2465 case 0x00:
2466 GETBYTE ();
2467 switch (op[3] & 0x00)
2468 {
2469 case 0x00:
2470 goto op_semantics_7;
2471 break;
2472 }
2473 break;
2474 case 0x02:
2475 GETBYTE ();
2476 switch (op[3] & 0x00)
2477 {
2478 case 0x00:
2479 goto op_semantics_18;
2480 break;
2481 }
2482 break;
2483 case 0x04:
2484 GETBYTE ();
2485 switch (op[3] & 0x00)
2486 {
2487 case 0x00:
2488 goto op_semantics_8;
2489 break;
2490 }
2491 break;
2492 case 0x05:
2493 GETBYTE ();
2494 switch (op[3] & 0x00)
2495 {
2496 case 0x00:
2497 goto op_semantics_9;
2498 break;
2499 }
2500 break;
2501 case 0x06:
2502 GETBYTE ();
2503 switch (op[3] & 0x00)
2504 {
2505 case 0x00:
2506 goto op_semantics_10;
2507 break;
2508 }
2509 break;
2510 case 0x07:
2511 GETBYTE ();
2512 switch (op[3] & 0x00)
2513 {
2514 case 0x00:
2515 goto op_semantics_11;
2516 break;
2517 }
2518 break;
2519 case 0x08:
2520 GETBYTE ();
2521 switch (op[3] & 0x00)
2522 {
2523 case 0x00:
2524 goto op_semantics_12;
2525 break;
2526 }
2527 break;
2528 case 0x09:
2529 GETBYTE ();
2530 switch (op[3] & 0x00)
2531 {
2532 case 0x00:
2533 goto op_semantics_13;
2534 break;
2535 }
2536 break;
2537 case 0x0c:
2538 GETBYTE ();
2539 switch (op[3] & 0x00)
2540 {
2541 case 0x00:
2542 goto op_semantics_14;
2543 break;
2544 }
2545 break;
2546 case 0x0d:
2547 GETBYTE ();
2548 switch (op[3] & 0x00)
2549 {
2550 case 0x00:
2551 goto op_semantics_15;
2552 break;
2553 }
2554 break;
2555 case 0x10:
2556 GETBYTE ();
2557 switch (op[3] & 0x00)
2558 {
2559 case 0x00:
2560 goto op_semantics_16;
2561 break;
2562 }
2563 break;
2564 case 0x11:
2565 GETBYTE ();
2566 switch (op[3] & 0x00)
2567 {
2568 case 0x00:
2569 goto op_semantics_17;
2570 break;
2571 }
2572 break;
2573 default: UNSUPPORTED(); break;
2574 }
2575 break;
2576 case 0xa2:
2577 GETBYTE ();
2578 switch (op[2] & 0xff)
2579 {
2580 case 0x00:
2581 GETBYTE ();
2582 switch (op[3] & 0x00)
2583 {
2584 case 0x00:
2585 goto op_semantics_7;
2586 break;
2587 }
2588 break;
2589 case 0x02:
2590 GETBYTE ();
2591 switch (op[3] & 0x00)
2592 {
2593 case 0x00:
2594 goto op_semantics_18;
2595 break;
2596 }
2597 break;
2598 case 0x04:
2599 GETBYTE ();
2600 switch (op[3] & 0x00)
2601 {
2602 case 0x00:
2603 goto op_semantics_8;
2604 break;
2605 }
2606 break;
2607 case 0x05:
2608 GETBYTE ();
2609 switch (op[3] & 0x00)
2610 {
2611 case 0x00:
2612 goto op_semantics_9;
2613 break;
2614 }
2615 break;
2616 case 0x06:
2617 GETBYTE ();
2618 switch (op[3] & 0x00)
2619 {
2620 case 0x00:
2621 goto op_semantics_10;
2622 break;
2623 }
2624 break;
2625 case 0x07:
2626 GETBYTE ();
2627 switch (op[3] & 0x00)
2628 {
2629 case 0x00:
2630 goto op_semantics_11;
2631 break;
2632 }
2633 break;
2634 case 0x08:
2635 GETBYTE ();
2636 switch (op[3] & 0x00)
2637 {
2638 case 0x00:
2639 goto op_semantics_12;
2640 break;
2641 }
2642 break;
2643 case 0x09:
2644 GETBYTE ();
2645 switch (op[3] & 0x00)
2646 {
2647 case 0x00:
2648 goto op_semantics_13;
2649 break;
2650 }
2651 break;
2652 case 0x0c:
2653 GETBYTE ();
2654 switch (op[3] & 0x00)
2655 {
2656 case 0x00:
2657 goto op_semantics_14;
2658 break;
2659 }
2660 break;
2661 case 0x0d:
2662 GETBYTE ();
2663 switch (op[3] & 0x00)
2664 {
2665 case 0x00:
2666 goto op_semantics_15;
2667 break;
2668 }
2669 break;
2670 case 0x10:
2671 GETBYTE ();
2672 switch (op[3] & 0x00)
2673 {
2674 case 0x00:
2675 goto op_semantics_16;
2676 break;
2677 }
2678 break;
2679 case 0x11:
2680 GETBYTE ();
2681 switch (op[3] & 0x00)
2682 {
2683 case 0x00:
2684 goto op_semantics_17;
2685 break;
2686 }
2687 break;
2688 default: UNSUPPORTED(); break;
2689 }
2690 break;
2691 case 0xa3:
2692 GETBYTE ();
2693 switch (op[2] & 0xff)
2694 {
2695 case 0x00:
2696 GETBYTE ();
2697 switch (op[3] & 0x00)
2698 {
2699 case 0x00:
2700 goto op_semantics_7;
2701 break;
2702 }
2703 break;
2704 case 0x02:
2705 GETBYTE ();
2706 switch (op[3] & 0x00)
2707 {
2708 case 0x00:
2709 goto op_semantics_18;
2710 break;
2711 }
2712 break;
2713 case 0x04:
2714 GETBYTE ();
2715 switch (op[3] & 0x00)
2716 {
2717 case 0x00:
2718 goto op_semantics_8;
2719 break;
2720 }
2721 break;
2722 case 0x05:
2723 GETBYTE ();
2724 switch (op[3] & 0x00)
2725 {
2726 case 0x00:
2727 goto op_semantics_9;
2728 break;
2729 }
2730 break;
2731 case 0x06:
2732 GETBYTE ();
2733 switch (op[3] & 0x00)
2734 {
2735 case 0x00:
2736 goto op_semantics_10;
2737 break;
2738 }
2739 break;
2740 case 0x07:
2741 GETBYTE ();
2742 switch (op[3] & 0x00)
2743 {
2744 case 0x00:
2745 goto op_semantics_11;
2746 break;
2747 }
2748 break;
2749 case 0x08:
2750 GETBYTE ();
2751 switch (op[3] & 0x00)
2752 {
2753 case 0x00:
2754 goto op_semantics_12;
2755 break;
2756 }
2757 break;
2758 case 0x09:
2759 GETBYTE ();
2760 switch (op[3] & 0x00)
2761 {
2762 case 0x00:
2763 goto op_semantics_13;
2764 break;
2765 }
2766 break;
2767 case 0x0c:
2768 GETBYTE ();
2769 switch (op[3] & 0x00)
2770 {
2771 case 0x00:
2772 goto op_semantics_14;
2773 break;
2774 }
2775 break;
2776 case 0x0d:
2777 GETBYTE ();
2778 switch (op[3] & 0x00)
2779 {
2780 case 0x00:
2781 goto op_semantics_15;
2782 break;
2783 }
2784 break;
2785 case 0x10:
2786 GETBYTE ();
2787 switch (op[3] & 0x00)
2788 {
2789 case 0x00:
2790 goto op_semantics_16;
2791 break;
2792 }
2793 break;
2794 case 0x11:
2795 GETBYTE ();
2796 switch (op[3] & 0x00)
2797 {
2798 case 0x00:
2799 goto op_semantics_17;
2800 break;
2801 }
2802 break;
2803 default: UNSUPPORTED(); break;
2804 }
2805 break;
2806 case 0xc0:
2807 GETBYTE ();
2808 switch (op[2] & 0x00)
2809 {
2810 case 0x00:
2811 goto op_semantics_1;
2812 break;
2813 }
2814 break;
2815 case 0xc1:
2816 GETBYTE ();
2817 switch (op[2] & 0x00)
2818 {
2819 case 0x00:
2820 goto op_semantics_1;
2821 break;
2822 }
2823 break;
2824 case 0xc2:
2825 GETBYTE ();
2826 switch (op[2] & 0x00)
2827 {
2828 case 0x00:
2829 goto op_semantics_1;
2830 break;
2831 }
2832 break;
2833 case 0xc3:
2834 GETBYTE ();
2835 switch (op[2] & 0x00)
2836 {
2837 case 0x00:
2838 goto op_semantics_1;
2839 break;
2840 }
2841 break;
2842 case 0xc4:
2843 GETBYTE ();
2844 switch (op[2] & 0x00)
2845 {
2846 case 0x00:
2847 goto op_semantics_2;
2848 break;
2849 }
2850 break;
2851 case 0xc5:
2852 GETBYTE ();
2853 switch (op[2] & 0x00)
2854 {
2855 case 0x00:
2856 goto op_semantics_2;
2857 break;
2858 }
2859 break;
2860 case 0xc6:
2861 GETBYTE ();
2862 switch (op[2] & 0x00)
2863 {
2864 case 0x00:
2865 goto op_semantics_2;
2866 break;
2867 }
2868 break;
2869 case 0xc7:
2870 GETBYTE ();
2871 switch (op[2] & 0x00)
2872 {
2873 case 0x00:
2874 goto op_semantics_2;
2875 break;
2876 }
2877 break;
2878 case 0xc8:
2879 GETBYTE ();
2880 switch (op[2] & 0x00)
2881 {
2882 case 0x00:
2883 goto op_semantics_3;
2884 break;
2885 }
2886 break;
2887 case 0xc9:
2888 GETBYTE ();
2889 switch (op[2] & 0x00)
2890 {
2891 case 0x00:
2892 goto op_semantics_3;
2893 break;
2894 }
2895 break;
2896 case 0xca:
2897 GETBYTE ();
2898 switch (op[2] & 0x00)
2899 {
2900 case 0x00:
2901 goto op_semantics_3;
2902 break;
2903 }
2904 break;
2905 case 0xcb:
2906 GETBYTE ();
2907 switch (op[2] & 0x00)
2908 {
2909 case 0x00:
2910 goto op_semantics_3;
2911 break;
2912 }
2913 break;
2914 case 0xcc:
2915 GETBYTE ();
2916 switch (op[2] & 0x00)
2917 {
2918 case 0x00:
2919 goto op_semantics_4;
2920 break;
2921 }
2922 break;
2923 case 0xcd:
2924 GETBYTE ();
2925 switch (op[2] & 0x00)
2926 {
2927 case 0x00:
2928 goto op_semantics_4;
2929 break;
2930 }
2931 break;
2932 case 0xce:
2933 GETBYTE ();
2934 switch (op[2] & 0x00)
2935 {
2936 case 0x00:
2937 goto op_semantics_4;
2938 break;
2939 }
2940 break;
2941 case 0xcf:
2942 GETBYTE ();
2943 switch (op[2] & 0x00)
2944 {
2945 case 0x00:
2946 goto op_semantics_4;
2947 break;
2948 }
2949 break;
2950 case 0xd0:
2951 GETBYTE ();
2952 switch (op[2] & 0x00)
2953 {
2954 case 0x00:
2955 goto op_semantics_5;
2956 break;
2957 }
2958 break;
2959 case 0xd1:
2960 GETBYTE ();
2961 switch (op[2] & 0x00)
2962 {
2963 case 0x00:
2964 goto op_semantics_5;
2965 break;
2966 }
2967 break;
2968 case 0xd2:
2969 GETBYTE ();
2970 switch (op[2] & 0x00)
2971 {
2972 case 0x00:
2973 goto op_semantics_5;
2974 break;
2975 }
2976 break;
2977 case 0xd3:
2978 GETBYTE ();
2979 switch (op[2] & 0x00)
2980 {
2981 case 0x00:
2982 goto op_semantics_5;
2983 break;
2984 }
2985 break;
2986 case 0xd4:
2987 GETBYTE ();
2988 switch (op[2] & 0x00)
2989 {
2990 case 0x00:
2991 goto op_semantics_6;
2992 break;
2993 }
2994 break;
2995 case 0xd5:
2996 GETBYTE ();
2997 switch (op[2] & 0x00)
2998 {
2999 case 0x00:
3000 goto op_semantics_6;
3001 break;
3002 }
3003 break;
3004 case 0xd6:
3005 GETBYTE ();
3006 switch (op[2] & 0x00)
3007 {
3008 case 0x00:
3009 goto op_semantics_6;
3010 break;
3011 }
3012 break;
3013 case 0xd7:
3014 GETBYTE ();
3015 switch (op[2] & 0x00)
3016 {
3017 case 0x00:
3018 goto op_semantics_6;
3019 break;
3020 }
3021 break;
3022 case 0xe0:
3023 GETBYTE ();
3024 switch (op[2] & 0xff)
3025 {
3026 case 0x00:
3027 GETBYTE ();
3028 switch (op[3] & 0x00)
3029 {
3030 case 0x00:
3031 goto op_semantics_7;
3032 break;
3033 }
3034 break;
3035 case 0x04:
3036 GETBYTE ();
3037 switch (op[3] & 0x00)
3038 {
3039 case 0x00:
3040 goto op_semantics_8;
3041 break;
3042 }
3043 break;
3044 case 0x05:
3045 GETBYTE ();
3046 switch (op[3] & 0x00)
3047 {
3048 case 0x00:
3049 goto op_semantics_9;
3050 break;
3051 }
3052 break;
3053 case 0x06:
3054 GETBYTE ();
3055 switch (op[3] & 0x00)
3056 {
3057 case 0x00:
3058 goto op_semantics_10;
3059 break;
3060 }
3061 break;
3062 case 0x07:
3063 GETBYTE ();
3064 switch (op[3] & 0x00)
3065 {
3066 case 0x00:
3067 goto op_semantics_11;
3068 break;
3069 }
3070 break;
3071 case 0x08:
3072 GETBYTE ();
3073 switch (op[3] & 0x00)
3074 {
3075 case 0x00:
3076 goto op_semantics_12;
3077 break;
3078 }
3079 break;
3080 case 0x09:
3081 GETBYTE ();
3082 switch (op[3] & 0x00)
3083 {
3084 case 0x00:
3085 goto op_semantics_13;
3086 break;
3087 }
3088 break;
3089 case 0x0c:
3090 GETBYTE ();
3091 switch (op[3] & 0x00)
3092 {
3093 case 0x00:
3094 goto op_semantics_14;
3095 break;
3096 }
3097 break;
3098 case 0x0d:
3099 GETBYTE ();
3100 switch (op[3] & 0x00)
3101 {
3102 case 0x00:
3103 goto op_semantics_15;
3104 break;
3105 }
3106 break;
3107 case 0x10:
3108 GETBYTE ();
3109 switch (op[3] & 0x00)
3110 {
3111 case 0x00:
3112 goto op_semantics_16;
3113 break;
3114 }
3115 break;
3116 case 0x11:
3117 GETBYTE ();
3118 switch (op[3] & 0x00)
3119 {
3120 case 0x00:
3121 goto op_semantics_17;
3122 break;
3123 }
3124 break;
3125 default: UNSUPPORTED(); break;
3126 }
3127 break;
3128 case 0xe1:
3129 GETBYTE ();
3130 switch (op[2] & 0xff)
3131 {
3132 case 0x00:
3133 GETBYTE ();
3134 switch (op[3] & 0x00)
3135 {
3136 case 0x00:
3137 goto op_semantics_7;
3138 break;
3139 }
3140 break;
3141 case 0x04:
3142 GETBYTE ();
3143 switch (op[3] & 0x00)
3144 {
3145 case 0x00:
3146 goto op_semantics_8;
3147 break;
3148 }
3149 break;
3150 case 0x05:
3151 GETBYTE ();
3152 switch (op[3] & 0x00)
3153 {
3154 case 0x00:
3155 goto op_semantics_9;
3156 break;
3157 }
3158 break;
3159 case 0x06:
3160 GETBYTE ();
3161 switch (op[3] & 0x00)
3162 {
3163 case 0x00:
3164 goto op_semantics_10;
3165 break;
3166 }
3167 break;
3168 case 0x07:
3169 GETBYTE ();
3170 switch (op[3] & 0x00)
3171 {
3172 case 0x00:
3173 goto op_semantics_11;
3174 break;
3175 }
3176 break;
3177 case 0x08:
3178 GETBYTE ();
3179 switch (op[3] & 0x00)
3180 {
3181 case 0x00:
3182 goto op_semantics_12;
3183 break;
3184 }
3185 break;
3186 case 0x09:
3187 GETBYTE ();
3188 switch (op[3] & 0x00)
3189 {
3190 case 0x00:
3191 goto op_semantics_13;
3192 break;
3193 }
3194 break;
3195 case 0x0c:
3196 GETBYTE ();
3197 switch (op[3] & 0x00)
3198 {
3199 case 0x00:
3200 goto op_semantics_14;
3201 break;
3202 }
3203 break;
3204 case 0x0d:
3205 GETBYTE ();
3206 switch (op[3] & 0x00)
3207 {
3208 case 0x00:
3209 goto op_semantics_15;
3210 break;
3211 }
3212 break;
3213 case 0x10:
3214 GETBYTE ();
3215 switch (op[3] & 0x00)
3216 {
3217 case 0x00:
3218 goto op_semantics_16;
3219 break;
3220 }
3221 break;
3222 case 0x11:
3223 GETBYTE ();
3224 switch (op[3] & 0x00)
3225 {
3226 case 0x00:
3227 goto op_semantics_17;
3228 break;
3229 }
3230 break;
3231 default: UNSUPPORTED(); break;
3232 }
3233 break;
3234 case 0xe2:
3235 GETBYTE ();
3236 switch (op[2] & 0xff)
3237 {
3238 case 0x00:
3239 GETBYTE ();
3240 switch (op[3] & 0x00)
3241 {
3242 case 0x00:
3243 goto op_semantics_7;
3244 break;
3245 }
3246 break;
3247 case 0x04:
3248 GETBYTE ();
3249 switch (op[3] & 0x00)
3250 {
3251 case 0x00:
3252 goto op_semantics_8;
3253 break;
3254 }
3255 break;
3256 case 0x05:
3257 GETBYTE ();
3258 switch (op[3] & 0x00)
3259 {
3260 case 0x00:
3261 goto op_semantics_9;
3262 break;
3263 }
3264 break;
3265 case 0x06:
3266 GETBYTE ();
3267 switch (op[3] & 0x00)
3268 {
3269 case 0x00:
3270 goto op_semantics_10;
3271 break;
3272 }
3273 break;
3274 case 0x07:
3275 GETBYTE ();
3276 switch (op[3] & 0x00)
3277 {
3278 case 0x00:
3279 goto op_semantics_11;
3280 break;
3281 }
3282 break;
3283 case 0x08:
3284 GETBYTE ();
3285 switch (op[3] & 0x00)
3286 {
3287 case 0x00:
3288 goto op_semantics_12;
3289 break;
3290 }
3291 break;
3292 case 0x09:
3293 GETBYTE ();
3294 switch (op[3] & 0x00)
3295 {
3296 case 0x00:
3297 goto op_semantics_13;
3298 break;
3299 }
3300 break;
3301 case 0x0c:
3302 GETBYTE ();
3303 switch (op[3] & 0x00)
3304 {
3305 case 0x00:
3306 goto op_semantics_14;
3307 break;
3308 }
3309 break;
3310 case 0x0d:
3311 GETBYTE ();
3312 switch (op[3] & 0x00)
3313 {
3314 case 0x00:
3315 goto op_semantics_15;
3316 break;
3317 }
3318 break;
3319 case 0x10:
3320 GETBYTE ();
3321 switch (op[3] & 0x00)
3322 {
3323 case 0x00:
3324 goto op_semantics_16;
3325 break;
3326 }
3327 break;
3328 case 0x11:
3329 GETBYTE ();
3330 switch (op[3] & 0x00)
3331 {
3332 case 0x00:
3333 goto op_semantics_17;
3334 break;
3335 }
3336 break;
3337 default: UNSUPPORTED(); break;
3338 }
3339 break;
3340 case 0xe3:
3341 GETBYTE ();
3342 switch (op[2] & 0xff)
3343 {
3344 case 0x00:
3345 GETBYTE ();
3346 switch (op[3] & 0x00)
3347 {
3348 case 0x00:
3349 goto op_semantics_7;
3350 break;
3351 }
3352 break;
3353 case 0x04:
3354 GETBYTE ();
3355 switch (op[3] & 0x00)
3356 {
3357 case 0x00:
3358 goto op_semantics_8;
3359 break;
3360 }
3361 break;
3362 case 0x05:
3363 GETBYTE ();
3364 switch (op[3] & 0x00)
3365 {
3366 case 0x00:
3367 goto op_semantics_9;
3368 break;
3369 }
3370 break;
3371 case 0x06:
3372 GETBYTE ();
3373 switch (op[3] & 0x00)
3374 {
3375 case 0x00:
3376 goto op_semantics_10;
3377 break;
3378 }
3379 break;
3380 case 0x07:
3381 GETBYTE ();
3382 switch (op[3] & 0x00)
3383 {
3384 case 0x00:
3385 goto op_semantics_11;
3386 break;
3387 }
3388 break;
3389 case 0x08:
3390 GETBYTE ();
3391 switch (op[3] & 0x00)
3392 {
3393 case 0x00:
3394 goto op_semantics_12;
3395 break;
3396 }
3397 break;
3398 case 0x09:
3399 GETBYTE ();
3400 switch (op[3] & 0x00)
3401 {
3402 case 0x00:
3403 goto op_semantics_13;
3404 break;
3405 }
3406 break;
3407 case 0x0c:
3408 GETBYTE ();
3409 switch (op[3] & 0x00)
3410 {
3411 case 0x00:
3412 goto op_semantics_14;
3413 break;
3414 }
3415 break;
3416 case 0x0d:
3417 GETBYTE ();
3418 switch (op[3] & 0x00)
3419 {
3420 case 0x00:
3421 goto op_semantics_15;
3422 break;
3423 }
3424 break;
3425 case 0x10:
3426 GETBYTE ();
3427 switch (op[3] & 0x00)
3428 {
3429 case 0x00:
3430 goto op_semantics_16;
3431 break;
3432 }
3433 break;
3434 case 0x11:
3435 GETBYTE ();
3436 switch (op[3] & 0x00)
3437 {
3438 case 0x00:
3439 goto op_semantics_17;
3440 break;
3441 }
3442 break;
3443 default: UNSUPPORTED(); break;
3444 }
3445 break;
3446 default: UNSUPPORTED(); break;
3447 }
3448 break;
3449 case 0x08:
3450 case 0x09:
3451 case 0x0a:
3452 case 0x0b:
3453 case 0x0c:
3454 case 0x0d:
3455 case 0x0e:
3456 case 0x0f:
3457 {
3458 /** 0000 1dsp bra.s %a0 */
f9c7014e 3459#line 699 "rx-decode.opc"
c7927a3c
NC		 3460 int dsp AU = op[0] & 0x07;
3461 if (trace)
3462 {
3463 printf ("\033[33m%s\033[0m %02x\n",
3464 "/** 0000 1dsp bra.s %a0 */",
3465 op[0]);
3466 printf (" dsp = 0x%x\n", dsp);
3467 }
3468 SYNTAX("bra.s %a0");
f9c7014e
DD		 3469#line 699 "rx-decode.opc"
3470 ID(branch); DC(pc + dsp3map[dsp]);
c7927a3c
NC		 3471
3472 }
3473 break;
3474 case 0x10:
3475 case 0x11:
3476 case 0x12:
3477 case 0x13:
3478 case 0x14:
3479 case 0x15:
3480 case 0x16:
3481 case 0x17:
3482 case 0x18:
3483 case 0x19:
3484 case 0x1a:
3485 case 0x1b:
3486 case 0x1c:
3487 case 0x1d:
3488 case 0x1e:
3489 case 0x1f:
3490 {
3491 /** 0001 n dsp b%1.s %a0 */
f9c7014e 3492#line 689 "rx-decode.opc"
c7927a3c 3493 int n AU = (op[0] >> 3) & 0x01;
f9c7014e 3494#line 689 "rx-decode.opc"
c7927a3c
NC		 3495 int dsp AU = op[0] & 0x07;
3496 if (trace)
3497 {
3498 printf ("\033[33m%s\033[0m %02x\n",
3499 "/** 0001 n dsp b%1.s %a0 */",
3500 op[0]);
3501 printf (" n = 0x%x,", n);
3502 printf (" dsp = 0x%x\n", dsp);
3503 }
3504 SYNTAX("b%1.s %a0");
f9c7014e 3505#line 689 "rx-decode.opc"
c7927a3c
NC		 3506 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3507
3508 }
3509 break;
3510 case 0x20:
3511 case 0x21:
3512 case 0x22:
3513 case 0x23:
3514 case 0x24:
3515 case 0x25:
3516 case 0x26:
3517 case 0x27:
3518 case 0x28:
3519 case 0x29:
3520 case 0x2a:
3521 case 0x2b:
3522 case 0x2c:
3523 case 0x2d:
3524 case 0x2f:
3525 {
3526 /** 0010 cond b%1.b %a0 */
f9c7014e 3527#line 692 "rx-decode.opc"
c7927a3c
NC		 3528 int cond AU = op[0] & 0x0f;
3529 if (trace)
3530 {
3531 printf ("\033[33m%s\033[0m %02x\n",
3532 "/** 0010 cond b%1.b %a0 */",
3533 op[0]);
3534 printf (" cond = 0x%x\n", cond);
3535 }
3536 SYNTAX("b%1.b %a0");
f9c7014e 3537#line 692 "rx-decode.opc"
c7927a3c
NC		 3538 ID(branch); Scc(cond); DC(pc + IMMex (1));
3539
3540 }
3541 break;
3542 case 0x2e:
3543 {
3544 /** 0010 1110 bra.b %a0 */
3545 if (trace)
3546 {
3547 printf ("\033[33m%s\033[0m %02x\n",
3548 "/** 0010 1110 bra.b %a0 */",
3549 op[0]);
3550 }
3551 SYNTAX("bra.b %a0");
f9c7014e
DD		 3552#line 702 "rx-decode.opc"
3553 ID(branch); DC(pc + IMMex(1));
c7927a3c
NC		 3554
3555 }
3556 break;
3557 case 0x38:
3558 {
3559 /** 0011 1000 bra.w %a0 */
3560 if (trace)
3561 {
3562 printf ("\033[33m%s\033[0m %02x\n",
3563 "/** 0011 1000 bra.w %a0 */",
3564 op[0]);
3565 }
3566 SYNTAX("bra.w %a0");
f9c7014e
DD		 3567#line 705 "rx-decode.opc"
3568 ID(branch); DC(pc + IMMex(2));
c7927a3c
NC		 3569
3570 }
3571 break;
3572 case 0x39:
3573 {
3574 /** 0011 1001 bsr.w %a0 */
3575 if (trace)
3576 {
3577 printf ("\033[33m%s\033[0m %02x\n",
3578 "/** 0011 1001 bsr.w %a0 */",
3579 op[0]);
3580 }
3581 SYNTAX("bsr.w %a0");
f9c7014e 3582#line 721 "rx-decode.opc"
c7927a3c
NC		 3583 ID(jsr); DC(pc + IMMex(2));
3584
3585 }
3586 break;
3587 case 0x3a:
3588 case 0x3b:
3589 {
3590 /** 0011 101c b%1.w %a0 */
f9c7014e 3591#line 695 "rx-decode.opc"
c7927a3c
NC		 3592 int c AU = op[0] & 0x01;
3593 if (trace)
3594 {
3595 printf ("\033[33m%s\033[0m %02x\n",
3596 "/** 0011 101c b%1.w %a0 */",
3597 op[0]);
3598 printf (" c = 0x%x\n", c);
3599 }
3600 SYNTAX("b%1.w %a0");
f9c7014e 3601#line 695 "rx-decode.opc"
c7927a3c
NC		 3602 ID(branch); Scc(c); DC(pc + IMMex (2));
3603
3604
3605 }
3606 break;
3607 case 0x3c:
3608 GETBYTE ();
3609 switch (op[1] & 0x00)
3610 {
3611 case 0x00:
3612 op_semantics_19:
3613 {
3614 /** 0011 11sz d dst sppp mov%s #%1, %0 */
f9c7014e 3615#line 271 "rx-decode.opc"
c7927a3c 3616 int sz AU = op[0] & 0x03;
f9c7014e 3617#line 271 "rx-decode.opc"
c7927a3c 3618 int d AU = (op[1] >> 7) & 0x01;
f9c7014e 3619#line 271 "rx-decode.opc"
c7927a3c 3620 int dst AU = (op[1] >> 4) & 0x07;
f9c7014e 3621#line 271 "rx-decode.opc"
c7927a3c
NC		 3622 int sppp AU = op[1] & 0x0f;
3623 if (trace)
3624 {
3625 printf ("\033[33m%s\033[0m %02x %02x\n",
3626 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3627 op[0], op[1]);
3628 printf (" sz = 0x%x,", sz);
3629 printf (" d = 0x%x,", d);
3630 printf (" dst = 0x%x,", dst);
3631 printf (" sppp = 0x%x\n", sppp);
3632 }
3633 SYNTAX("mov%s #%1, %0");
f9c7014e 3634#line 271 "rx-decode.opc"
3cf79a01 3635 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
c7927a3c
NC		 3636
3637 }
3638 break;
3639 }
3640 break;
3641 case 0x3d:
3642 GETBYTE ();
3643 switch (op[1] & 0x00)
3644 {
3645 case 0x00:
3646 goto op_semantics_19;
3647 break;
3648 }
3649 break;
3650 case 0x3e:
3651 GETBYTE ();
3652 switch (op[1] & 0x00)
3653 {
3654 case 0x00:
3655 goto op_semantics_19;
3656 break;
3657 }
3658 break;
3659 case 0x3f:
3660 GETBYTE ();
3661 switch (op[1] & 0x00)
3662 {
3663 case 0x00:
3664 {
3665 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
f9c7014e 3666#line 367 "rx-decode.opc"
c7927a3c 3667 int rega AU = (op[1] >> 4) & 0x0f;
f9c7014e 3668#line 367 "rx-decode.opc"
c7927a3c
NC		 3669 int regb AU = op[1] & 0x0f;
3670 if (trace)
3671 {
3672 printf ("\033[33m%s\033[0m %02x %02x\n",
3673 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3674 op[0], op[1]);
3675 printf (" rega = 0x%x,", rega);
3676 printf (" regb = 0x%x\n", regb);
3677 }
3678 SYNTAX("rtsd #%1, %2-%0");
f9c7014e 3679#line 367 "rx-decode.opc"
c7927a3c
NC		 3680 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3681
3682 /*----------------------------------------------------------------------*/
3683 /* AND */
3684
3685 }
3686 break;
3687 }
3688 break;
3689 case 0x40:
3690 GETBYTE ();
3691 switch (op[1] & 0x00)
3692 {
3693 case 0x00:
3694 op_semantics_20:
3695 {
3696 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
f9c7014e 3697#line 502 "rx-decode.opc"
c7927a3c 3698 int ss AU = op[0] & 0x03;
f9c7014e 3699#line 502 "rx-decode.opc"
c7927a3c 3700 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 3701#line 502 "rx-decode.opc"
c7927a3c
NC		 3702 int rdst AU = op[1] & 0x0f;
3703 if (trace)
3704 {
3705 printf ("\033[33m%s\033[0m %02x %02x\n",
3706 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3707 op[0], op[1]);
3708 printf (" ss = 0x%x,", ss);
3709 printf (" rsrc = 0x%x,", rsrc);
3710 printf (" rdst = 0x%x\n", rdst);
3711 }
3712 SYNTAX("sub %2%S2, %1");
f9c7014e 3713#line 502 "rx-decode.opc"
3cf79a01 3714 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 3715
3716 }
3717 break;
3718 }
3719 break;
3720 case 0x41:
3721 GETBYTE ();
3722 switch (op[1] & 0x00)
3723 {
3724 case 0x00:
3725 goto op_semantics_20;
3726 break;
3727 }
3728 break;
3729 case 0x42:
3730 GETBYTE ();
3731 switch (op[1] & 0x00)
3732 {
3733 case 0x00:
3734 goto op_semantics_20;
3735 break;
3736 }
3737 break;
3738 case 0x43:
3739 GETBYTE ();
3740 switch (op[1] & 0x00)
3741 {
3742 case 0x00:
3743 goto op_semantics_20;
3744 break;
3745 }
3746 break;
3747 case 0x44:
3748 GETBYTE ();
3749 switch (op[1] & 0x00)
3750 {
3751 case 0x00:
3752 op_semantics_21:
3753 {
3754 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
f9c7014e 3755#line 490 "rx-decode.opc"
c7927a3c 3756 int ss AU = op[0] & 0x03;
f9c7014e 3757#line 490 "rx-decode.opc"
c7927a3c 3758 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 3759#line 490 "rx-decode.opc"
c7927a3c
NC		 3760 int rdst AU = op[1] & 0x0f;
3761 if (trace)
3762 {
3763 printf ("\033[33m%s\033[0m %02x %02x\n",
3764 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3765 op[0], op[1]);
3766 printf (" ss = 0x%x,", ss);
3767 printf (" rsrc = 0x%x,", rsrc);
3768 printf (" rdst = 0x%x\n", rdst);
3769 }
3770 SYNTAX("cmp %2%S2, %1");
f9c7014e 3771#line 490 "rx-decode.opc"
3cf79a01 3772 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
c7927a3c
NC		 3773
3774 }
3775 break;
3776 }
3777 break;
3778 case 0x45:
3779 GETBYTE ();
3780 switch (op[1] & 0x00)
3781 {
3782 case 0x00:
3783 goto op_semantics_21;
3784 break;
3785 }
3786 break;
3787 case 0x46:
3788 GETBYTE ();
3789 switch (op[1] & 0x00)
3790 {
3791 case 0x00:
3792 goto op_semantics_21;
3793 break;
3794 }
3795 break;
3796 case 0x47:
3797 GETBYTE ();
3798 switch (op[1] & 0x00)
3799 {
3800 case 0x00:
3801 goto op_semantics_21;
3802 break;
3803 }
3804 break;
3805 case 0x48:
3806 GETBYTE ();
3807 switch (op[1] & 0x00)
3808 {
3809 case 0x00:
3810 op_semantics_22:
3811 {
3812 /** 0100 10ss rsrc rdst add %1%S1, %0 */
f9c7014e 3813#line 466 "rx-decode.opc"
c7927a3c 3814 int ss AU = op[0] & 0x03;
f9c7014e 3815#line 466 "rx-decode.opc"
c7927a3c 3816 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 3817#line 466 "rx-decode.opc"
c7927a3c
NC		 3818 int rdst AU = op[1] & 0x0f;
3819 if (trace)
3820 {
3821 printf ("\033[33m%s\033[0m %02x %02x\n",
3822 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3823 op[0], op[1]);
3824 printf (" ss = 0x%x,", ss);
3825 printf (" rsrc = 0x%x,", rsrc);
3826 printf (" rdst = 0x%x\n", rdst);
3827 }
3828 SYNTAX("add %1%S1, %0");
f9c7014e 3829#line 466 "rx-decode.opc"
3cf79a01 3830 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 3831
3832 }
3833 break;
3834 }
3835 break;
3836 case 0x49:
3837 GETBYTE ();
3838 switch (op[1] & 0x00)
3839 {
3840 case 0x00:
3841 goto op_semantics_22;
3842 break;
3843 }
3844 break;
3845 case 0x4a:
3846 GETBYTE ();
3847 switch (op[1] & 0x00)
3848 {
3849 case 0x00:
3850 goto op_semantics_22;
3851 break;
3852 }
3853 break;
3854 case 0x4b:
3855 GETBYTE ();
3856 switch (op[1] & 0x00)
3857 {
3858 case 0x00:
3859 goto op_semantics_22;
3860 break;
3861 }
3862 break;
3863 case 0x4c:
3864 GETBYTE ();
3865 switch (op[1] & 0x00)
3866 {
3867 case 0x00:
3868 op_semantics_23:
3869 {
3870 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
f9c7014e 3871#line 570 "rx-decode.opc"
c7927a3c 3872 int ss AU = op[0] & 0x03;
f9c7014e 3873#line 570 "rx-decode.opc"
c7927a3c 3874 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 3875#line 570 "rx-decode.opc"
c7927a3c
NC		 3876 int rdst AU = op[1] & 0x0f;
3877 if (trace)
3878 {
3879 printf ("\033[33m%s\033[0m %02x %02x\n",
3880 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3881 op[0], op[1]);
3882 printf (" ss = 0x%x,", ss);
3883 printf (" rsrc = 0x%x,", rsrc);
3884 printf (" rdst = 0x%x\n", rdst);
3885 }
3886 SYNTAX("mul %1%S1, %0");
f9c7014e 3887#line 570 "rx-decode.opc"
3cf79a01 3888 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
c7927a3c
NC		 3889
3890 }
3891 break;
3892 }
3893 break;
3894 case 0x4d:
3895 GETBYTE ();
3896 switch (op[1] & 0x00)
3897 {
3898 case 0x00:
3899 goto op_semantics_23;
3900 break;
3901 }
3902 break;
3903 case 0x4e:
3904 GETBYTE ();
3905 switch (op[1] & 0x00)
3906 {
3907 case 0x00:
3908 goto op_semantics_23;
3909 break;
3910 }
3911 break;
3912 case 0x4f:
3913 GETBYTE ();
3914 switch (op[1] & 0x00)
3915 {
3916 case 0x00:
3917 goto op_semantics_23;
3918 break;
3919 }
3920 break;
3921 case 0x50:
3922 GETBYTE ();
3923 switch (op[1] & 0x00)
3924 {
3925 case 0x00:
3926 op_semantics_24:
3927 {
3928 /** 0101 00ss rsrc rdst and %1%S1, %0 */
f9c7014e 3929#line 379 "rx-decode.opc"
c7927a3c 3930 int ss AU = op[0] & 0x03;
f9c7014e 3931#line 379 "rx-decode.opc"
c7927a3c 3932 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 3933#line 379 "rx-decode.opc"
c7927a3c
NC		 3934 int rdst AU = op[1] & 0x0f;
3935 if (trace)
3936 {
3937 printf ("\033[33m%s\033[0m %02x %02x\n",
3938 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3939 op[0], op[1]);
3940 printf (" ss = 0x%x,", ss);
3941 printf (" rsrc = 0x%x,", rsrc);
3942 printf (" rdst = 0x%x\n", rdst);
3943 }
3944 SYNTAX("and %1%S1, %0");
f9c7014e 3945#line 379 "rx-decode.opc"
3cf79a01 3946 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
c7927a3c
NC		 3947
3948 }
3949 break;
3950 }
3951 break;
3952 case 0x51:
3953 GETBYTE ();
3954 switch (op[1] & 0x00)
3955 {
3956 case 0x00:
3957 goto op_semantics_24;
3958 break;
3959 }
3960 break;
3961 case 0x52:
3962 GETBYTE ();
3963 switch (op[1] & 0x00)
3964 {
3965 case 0x00:
3966 goto op_semantics_24;
3967 break;
3968 }
3969 break;
3970 case 0x53:
3971 GETBYTE ();
3972 switch (op[1] & 0x00)
3973 {
3974 case 0x00:
3975 goto op_semantics_24;
3976 break;
3977 }
3978 break;
3979 case 0x54:
3980 GETBYTE ();
3981 switch (op[1] & 0x00)
3982 {
3983 case 0x00:
3984 op_semantics_25:
3985 {
3986 /** 0101 01ss rsrc rdst or %1%S1, %0 */
f9c7014e 3987#line 397 "rx-decode.opc"
c7927a3c 3988 int ss AU = op[0] & 0x03;
f9c7014e 3989#line 397 "rx-decode.opc"
c7927a3c 3990 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 3991#line 397 "rx-decode.opc"
c7927a3c
NC		 3992 int rdst AU = op[1] & 0x0f;
3993 if (trace)
3994 {
3995 printf ("\033[33m%s\033[0m %02x %02x\n",
3996 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
3997 op[0], op[1]);
3998 printf (" ss = 0x%x,", ss);
3999 printf (" rsrc = 0x%x,", rsrc);
4000 printf (" rdst = 0x%x\n", rdst);
4001 }
4002 SYNTAX("or %1%S1, %0");
f9c7014e 4003#line 397 "rx-decode.opc"
3cf79a01 4004 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
c7927a3c
NC		 4005
4006 }
4007 break;
4008 }
4009 break;
4010 case 0x55:
4011 GETBYTE ();
4012 switch (op[1] & 0x00)
4013 {
4014 case 0x00:
4015 goto op_semantics_25;
4016 break;
4017 }
4018 break;
4019 case 0x56:
4020 GETBYTE ();
4021 switch (op[1] & 0x00)
4022 {
4023 case 0x00:
4024 goto op_semantics_25;
4025 break;
4026 }
4027 break;
4028 case 0x57:
4029 GETBYTE ();
4030 switch (op[1] & 0x00)
4031 {
4032 case 0x00:
4033 goto op_semantics_25;
4034 break;
4035 }
4036 break;
4037 case 0x58:
4038 GETBYTE ();
4039 switch (op[1] & 0x00)
4040 {
4041 case 0x00:
4042 op_semantics_26:
4043 {
4044 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
f9c7014e 4045#line 318 "rx-decode.opc"
c7927a3c 4046 int s AU = (op[0] >> 2) & 0x01;
f9c7014e 4047#line 318 "rx-decode.opc"
c7927a3c 4048 int ss AU = op[0] & 0x03;
f9c7014e 4049#line 318 "rx-decode.opc"
c7927a3c 4050 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 4051#line 318 "rx-decode.opc"
c7927a3c
NC		 4052 int rdst AU = op[1] & 0x0f;
4053 if (trace)
4054 {
4055 printf ("\033[33m%s\033[0m %02x %02x\n",
4056 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4057 op[0], op[1]);
4058 printf (" s = 0x%x,", s);
4059 printf (" ss = 0x%x,", ss);
4060 printf (" rsrc = 0x%x,", rsrc);
4061 printf (" rdst = 0x%x\n", rdst);
4062 }
4063 SYNTAX("movu%s %1, %0");
f9c7014e 4064#line 318 "rx-decode.opc"
3cf79a01 4065 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____;
c7927a3c
NC		 4066
4067 }
4068 break;
4069 }
4070 break;
4071 case 0x59:
4072 GETBYTE ();
4073 switch (op[1] & 0x00)
4074 {
4075 case 0x00:
4076 goto op_semantics_26;
4077 break;
4078 }
4079 break;
4080 case 0x5a:
4081 GETBYTE ();
4082 switch (op[1] & 0x00)
4083 {
4084 case 0x00:
4085 goto op_semantics_26;
4086 break;
4087 }
4088 break;
4089 case 0x5b:
4090 GETBYTE ();
4091 switch (op[1] & 0x00)
4092 {
4093 case 0x00:
4094 goto op_semantics_26;
4095 break;
4096 }
4097 break;
4098 case 0x5c:
4099 GETBYTE ();
4100 switch (op[1] & 0x00)
4101 {
4102 case 0x00:
4103 goto op_semantics_26;
4104 break;
4105 }
4106 break;
4107 case 0x5d:
4108 GETBYTE ();
4109 switch (op[1] & 0x00)
4110 {
4111 case 0x00:
4112 goto op_semantics_26;
4113 break;
4114 }
4115 break;
4116 case 0x5e:
4117 GETBYTE ();
4118 switch (op[1] & 0x00)
4119 {
4120 case 0x00:
4121 goto op_semantics_26;
4122 break;
4123 }
4124 break;
4125 case 0x5f:
4126 GETBYTE ();
4127 switch (op[1] & 0x00)
4128 {
4129 case 0x00:
4130 goto op_semantics_26;
4131 break;
4132 }
4133 break;
4134 case 0x60:
4135 GETBYTE ();
4136 switch (op[1] & 0x00)
4137 {
4138 case 0x00:
4139 {
4140 /** 0110 0000 immm rdst sub #%2, %0 */
f9c7014e 4141#line 499 "rx-decode.opc"
c7927a3c 4142 int immm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4143#line 499 "rx-decode.opc"
c7927a3c
NC		 4144 int rdst AU = op[1] & 0x0f;
4145 if (trace)
4146 {
4147 printf ("\033[33m%s\033[0m %02x %02x\n",
4148 "/** 0110 0000 immm rdst sub #%2, %0 */",
4149 op[0], op[1]);
4150 printf (" immm = 0x%x,", immm);
4151 printf (" rdst = 0x%x\n", rdst);
4152 }
4153 SYNTAX("sub #%2, %0");
f9c7014e 4154#line 499 "rx-decode.opc"
3cf79a01 4155 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 4156
4157 }
4158 break;
4159 }
4160 break;
4161 case 0x61:
4162 GETBYTE ();
4163 switch (op[1] & 0x00)
4164 {
4165 case 0x00:
4166 {
4167 /** 0110 0001 immm rdst cmp #%2, %1 */
f9c7014e 4168#line 481 "rx-decode.opc"
c7927a3c 4169 int immm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4170#line 481 "rx-decode.opc"
c7927a3c
NC		 4171 int rdst AU = op[1] & 0x0f;
4172 if (trace)
4173 {
4174 printf ("\033[33m%s\033[0m %02x %02x\n",
4175 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4176 op[0], op[1]);
4177 printf (" immm = 0x%x,", immm);
4178 printf (" rdst = 0x%x\n", rdst);
4179 }
4180 SYNTAX("cmp #%2, %1");
f9c7014e 4181#line 481 "rx-decode.opc"
3cf79a01 4182 ID(sub); S2C(immm); SR(rdst); F_OSZC;
c7927a3c
NC		 4183
4184 }
4185 break;
4186 }
4187 break;
4188 case 0x62:
4189 GETBYTE ();
4190 switch (op[1] & 0x00)
4191 {
4192 case 0x00:
4193 {
4194 /** 0110 0010 immm rdst add #%1, %0 */
f9c7014e 4195#line 463 "rx-decode.opc"
c7927a3c 4196 int immm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4197#line 463 "rx-decode.opc"
c7927a3c
NC		 4198 int rdst AU = op[1] & 0x0f;
4199 if (trace)
4200 {
4201 printf ("\033[33m%s\033[0m %02x %02x\n",
4202 "/** 0110 0010 immm rdst add #%1, %0 */",
4203 op[0], op[1]);
4204 printf (" immm = 0x%x,", immm);
4205 printf (" rdst = 0x%x\n", rdst);
4206 }
4207 SYNTAX("add #%1, %0");
f9c7014e 4208#line 463 "rx-decode.opc"
3cf79a01 4209 ID(add); SC(immm); DR(rdst); F_OSZC;
c7927a3c
NC		 4210
4211 }
4212 break;
4213 }
4214 break;
4215 case 0x63:
4216 GETBYTE ();
4217 switch (op[1] & 0x00)
4218 {
4219 case 0x00:
4220 {
4221 /** 0110 0011 immm rdst mul #%1, %0 */
f9c7014e 4222#line 564 "rx-decode.opc"
c7927a3c 4223 int immm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4224#line 564 "rx-decode.opc"
c7927a3c
NC		 4225 int rdst AU = op[1] & 0x0f;
4226 if (trace)
4227 {
4228 printf ("\033[33m%s\033[0m %02x %02x\n",
4229 "/** 0110 0011 immm rdst mul #%1, %0 */",
4230 op[0], op[1]);
4231 printf (" immm = 0x%x,", immm);
4232 printf (" rdst = 0x%x\n", rdst);
4233 }
4234 SYNTAX("mul #%1, %0");
f9c7014e 4235#line 564 "rx-decode.opc"
3cf79a01 4236 ID(mul); DR(rdst); SC(immm); F_____;
c7927a3c
NC		 4237
4238 }
4239 break;
4240 }
4241 break;
4242 case 0x64:
4243 GETBYTE ();
4244 switch (op[1] & 0x00)
4245 {
4246 case 0x00:
4247 {
4248 /** 0110 0100 immm rdst and #%1, %0 */
f9c7014e 4249#line 373 "rx-decode.opc"
c7927a3c 4250 int immm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4251#line 373 "rx-decode.opc"
c7927a3c
NC		 4252 int rdst AU = op[1] & 0x0f;
4253 if (trace)
4254 {
4255 printf ("\033[33m%s\033[0m %02x %02x\n",
4256 "/** 0110 0100 immm rdst and #%1, %0 */",
4257 op[0], op[1]);
4258 printf (" immm = 0x%x,", immm);
4259 printf (" rdst = 0x%x\n", rdst);
4260 }
4261 SYNTAX("and #%1, %0");
f9c7014e 4262#line 373 "rx-decode.opc"
3cf79a01 4263 ID(and); SC(immm); DR(rdst); F__SZ_;
c7927a3c
NC		 4264
4265 }
4266 break;
4267 }
4268 break;
4269 case 0x65:
4270 GETBYTE ();
4271 switch (op[1] & 0x00)
4272 {
4273 case 0x00:
4274 {
4275 /** 0110 0101 immm rdst or #%1, %0 */
f9c7014e 4276#line 391 "rx-decode.opc"
c7927a3c 4277 int immm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4278#line 391 "rx-decode.opc"
c7927a3c
NC		 4279 int rdst AU = op[1] & 0x0f;
4280 if (trace)
4281 {
4282 printf ("\033[33m%s\033[0m %02x %02x\n",
4283 "/** 0110 0101 immm rdst or #%1, %0 */",
4284 op[0], op[1]);
4285 printf (" immm = 0x%x,", immm);
4286 printf (" rdst = 0x%x\n", rdst);
4287 }
4288 SYNTAX("or #%1, %0");
f9c7014e 4289#line 391 "rx-decode.opc"
3cf79a01 4290 ID(or); SC(immm); DR(rdst); F__SZ_;
c7927a3c
NC		 4291
4292 }
4293 break;
4294 }
4295 break;
4296 case 0x66:
4297 GETBYTE ();
4298 switch (op[1] & 0x00)
4299 {
4300 case 0x00:
4301 {
4302 /** 0110 0110 immm rdst mov%s #%1, %0 */
f9c7014e 4303#line 268 "rx-decode.opc"
c7927a3c 4304 int immm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4305#line 268 "rx-decode.opc"
c7927a3c
NC		 4306 int rdst AU = op[1] & 0x0f;
4307 if (trace)
4308 {
4309 printf ("\033[33m%s\033[0m %02x %02x\n",
4310 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4311 op[0], op[1]);
4312 printf (" immm = 0x%x,", immm);
4313 printf (" rdst = 0x%x\n", rdst);
4314 }
4315 SYNTAX("mov%s #%1, %0");
f9c7014e 4316#line 268 "rx-decode.opc"
3cf79a01 4317 ID(mov); DR(rdst); SC(immm); F_____;
c7927a3c
NC		 4318
4319 }
4320 break;
4321 }
4322 break;
4323 case 0x67:
4324 {
4325 /** 0110 0111 rtsd #%1 */
4326 if (trace)
4327 {
4328 printf ("\033[33m%s\033[0m %02x\n",
4329 "/** 0110 0111 rtsd #%1 */",
4330 op[0]);
4331 }
4332 SYNTAX("rtsd #%1");
f9c7014e 4333#line 364 "rx-decode.opc"
c7927a3c
NC		 4334 ID(rtsd); SC(IMM(1) * 4);
4335
4336 }
4337 break;
4338 case 0x68:
4339 GETBYTE ();
4340 switch (op[1] & 0x00)
4341 {
4342 case 0x00:
4343 op_semantics_27:
4344 {
4345 /** 0110 100i mmmm rdst shlr #%2, %0 */
f9c7014e 4346#line 650 "rx-decode.opc"
c7927a3c 4347 int i AU = op[0] & 0x01;
f9c7014e 4348#line 650 "rx-decode.opc"
c7927a3c 4349 int mmmm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4350#line 650 "rx-decode.opc"
c7927a3c
NC		 4351 int rdst AU = op[1] & 0x0f;
4352 if (trace)
4353 {
4354 printf ("\033[33m%s\033[0m %02x %02x\n",
4355 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4356 op[0], op[1]);
4357 printf (" i = 0x%x,", i);
4358 printf (" mmmm = 0x%x,", mmmm);
4359 printf (" rdst = 0x%x\n", rdst);
4360 }
4361 SYNTAX("shlr #%2, %0");
f9c7014e 4362#line 650 "rx-decode.opc"
3cf79a01 4363 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
c7927a3c
NC		 4364
4365 }
4366 break;
4367 }
4368 break;
4369 case 0x69:
4370 GETBYTE ();
4371 switch (op[1] & 0x00)
4372 {
4373 case 0x00:
4374 goto op_semantics_27;
4375 break;
4376 }
4377 break;
4378 case 0x6a:
4379 GETBYTE ();
4380 switch (op[1] & 0x00)
4381 {
4382 case 0x00:
4383 op_semantics_28:
4384 {
4385 /** 0110 101i mmmm rdst shar #%2, %0 */
f9c7014e 4386#line 640 "rx-decode.opc"
c7927a3c 4387 int i AU = op[0] & 0x01;
f9c7014e 4388#line 640 "rx-decode.opc"
c7927a3c 4389 int mmmm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4390#line 640 "rx-decode.opc"
c7927a3c
NC		 4391 int rdst AU = op[1] & 0x0f;
4392 if (trace)
4393 {
4394 printf ("\033[33m%s\033[0m %02x %02x\n",
4395 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4396 op[0], op[1]);
4397 printf (" i = 0x%x,", i);
4398 printf (" mmmm = 0x%x,", mmmm);
4399 printf (" rdst = 0x%x\n", rdst);
4400 }
4401 SYNTAX("shar #%2, %0");
f9c7014e 4402#line 640 "rx-decode.opc"
3cf79a01 4403 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
c7927a3c
NC		 4404
4405 }
4406 break;
4407 }
4408 break;
4409 case 0x6b:
4410 GETBYTE ();
4411 switch (op[1] & 0x00)
4412 {
4413 case 0x00:
4414 goto op_semantics_28;
4415 break;
4416 }
4417 break;
4418 case 0x6c:
4419 GETBYTE ();
4420 switch (op[1] & 0x00)
4421 {
4422 case 0x00:
4423 op_semantics_29:
4424 {
4425 /** 0110 110i mmmm rdst shll #%2, %0 */
f9c7014e 4426#line 630 "rx-decode.opc"
c7927a3c 4427 int i AU = op[0] & 0x01;
f9c7014e 4428#line 630 "rx-decode.opc"
c7927a3c 4429 int mmmm AU = (op[1] >> 4) & 0x0f;
f9c7014e 4430#line 630 "rx-decode.opc"
c7927a3c
NC		 4431 int rdst AU = op[1] & 0x0f;
4432 if (trace)
4433 {
4434 printf ("\033[33m%s\033[0m %02x %02x\n",
4435 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4436 op[0], op[1]);
4437 printf (" i = 0x%x,", i);
4438 printf (" mmmm = 0x%x,", mmmm);
4439 printf (" rdst = 0x%x\n", rdst);
4440 }
4441 SYNTAX("shll #%2, %0");
f9c7014e 4442#line 630 "rx-decode.opc"
3cf79a01 4443 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 4444
4445 }
4446 break;
4447 }
4448 break;
4449 case 0x6d:
4450 GETBYTE ();
4451 switch (op[1] & 0x00)
4452 {
4453 case 0x00:
4454 goto op_semantics_29;
4455 break;
4456 }
4457 break;
4458 case 0x6e:
4459 GETBYTE ();
4460 switch (op[1] & 0x00)
4461 {
4462 case 0x00:
4463 {
4464 /** 0110 1110 dsta dstb pushm %1-%2 */
f9c7014e 4465#line 331 "rx-decode.opc"
c7927a3c 4466 int dsta AU = (op[1] >> 4) & 0x0f;
f9c7014e 4467#line 331 "rx-decode.opc"
c7927a3c
NC		 4468 int dstb AU = op[1] & 0x0f;
4469 if (trace)
4470 {
4471 printf ("\033[33m%s\033[0m %02x %02x\n",
4472 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4473 op[0], op[1]);
4474 printf (" dsta = 0x%x,", dsta);
4475 printf (" dstb = 0x%x\n", dstb);
4476 }
4477 SYNTAX("pushm %1-%2");
f9c7014e 4478#line 331 "rx-decode.opc"
3cf79a01 4479 ID(pushm); SR(dsta); S2R(dstb); F_____;
c7927a3c
NC		 4480
4481 }
4482 break;
4483 }
4484 break;
4485 case 0x6f:
4486 GETBYTE ();
4487 switch (op[1] & 0x00)
4488 {
4489 case 0x00:
4490 {
4491 /** 0110 1111 dsta dstb popm %1-%2 */
f9c7014e 4492#line 328 "rx-decode.opc"
c7927a3c 4493 int dsta AU = (op[1] >> 4) & 0x0f;
f9c7014e 4494#line 328 "rx-decode.opc"
c7927a3c
NC		 4495 int dstb AU = op[1] & 0x0f;
4496 if (trace)
4497 {
4498 printf ("\033[33m%s\033[0m %02x %02x\n",
4499 "/** 0110 1111 dsta dstb popm %1-%2 */",
4500 op[0], op[1]);
4501 printf (" dsta = 0x%x,", dsta);
4502 printf (" dstb = 0x%x\n", dstb);
4503 }
4504 SYNTAX("popm %1-%2");
f9c7014e 4505#line 328 "rx-decode.opc"
3cf79a01 4506 ID(popm); SR(dsta); S2R(dstb); F_____;
c7927a3c
NC		 4507
4508 }
4509 break;
4510 }
4511 break;
4512 case 0x70:
4513 GETBYTE ();
4514 switch (op[1] & 0x00)
4515 {
4516 case 0x00:
4517 op_semantics_30:
4518 {
4519 /** 0111 00im rsrc rdst add #%1, %2, %0 */
f9c7014e 4520#line 472 "rx-decode.opc"
c7927a3c 4521 int im AU = op[0] & 0x03;
f9c7014e 4522#line 472 "rx-decode.opc"
c7927a3c 4523 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 4524#line 472 "rx-decode.opc"
c7927a3c
NC		 4525 int rdst AU = op[1] & 0x0f;
4526 if (trace)
4527 {
4528 printf ("\033[33m%s\033[0m %02x %02x\n",
4529 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4530 op[0], op[1]);
4531 printf (" im = 0x%x,", im);
4532 printf (" rsrc = 0x%x,", rsrc);
4533 printf (" rdst = 0x%x\n", rdst);
4534 }
4535 SYNTAX("add #%1, %2, %0");
f9c7014e 4536#line 472 "rx-decode.opc"
3cf79a01 4537 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 4538
4539 }
4540 break;
4541 }
4542 break;
4543 case 0x71:
4544 GETBYTE ();
4545 switch (op[1] & 0x00)
4546 {
4547 case 0x00:
4548 goto op_semantics_30;
4549 break;
4550 }
4551 break;
4552 case 0x72:
4553 GETBYTE ();
4554 switch (op[1] & 0x00)
4555 {
4556 case 0x00:
4557 goto op_semantics_30;
4558 break;
4559 }
4560 break;
4561 case 0x73:
4562 GETBYTE ();
4563 switch (op[1] & 0x00)
4564 {
4565 case 0x00:
4566 goto op_semantics_30;
4567 break;
4568 }
4569 break;
4570 case 0x74:
4571 GETBYTE ();
4572 switch (op[1] & 0xf0)
4573 {
4574 case 0x00:
4575 op_semantics_31:
4576 {
4577 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
f9c7014e 4578#line 484 "rx-decode.opc"
c7927a3c 4579 int im AU = op[0] & 0x03;
f9c7014e 4580#line 484 "rx-decode.opc"
c7927a3c
NC		 4581 int rsrc AU = op[1] & 0x0f;
4582 if (trace)
4583 {
4584 printf ("\033[33m%s\033[0m %02x %02x\n",
4585 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4586 op[0], op[1]);
4587 printf (" im = 0x%x,", im);
4588 printf (" rsrc = 0x%x\n", rsrc);
4589 }
4590 SYNTAX("cmp #%2, %1%S1");
f9c7014e 4591#line 484 "rx-decode.opc"
3cf79a01 4592 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
c7927a3c
NC		 4593
4594 }
4595 break;
4596 case 0x10:
4597 op_semantics_32:
4598 {
4599 /** 0111 01im 0001rdst mul #%1, %0 */
f9c7014e 4600#line 567 "rx-decode.opc"
c7927a3c 4601 int im AU = op[0] & 0x03;
f9c7014e 4602#line 567 "rx-decode.opc"
c7927a3c
NC		 4603 int rdst AU = op[1] & 0x0f;
4604 if (trace)
4605 {
4606 printf ("\033[33m%s\033[0m %02x %02x\n",
4607 "/** 0111 01im 0001rdst mul #%1, %0 */",
4608 op[0], op[1]);
4609 printf (" im = 0x%x,", im);
4610 printf (" rdst = 0x%x\n", rdst);
4611 }
4612 SYNTAX("mul #%1, %0");
f9c7014e 4613#line 567 "rx-decode.opc"
3cf79a01 4614 ID(mul); DR(rdst); SC(IMMex(im)); F_____;
c7927a3c
NC		 4615
4616 }
4617 break;
4618 case 0x20:
4619 op_semantics_33:
4620 {
4621 /** 0111 01im 0010 rdst and #%1, %0 */
f9c7014e 4622#line 376 "rx-decode.opc"
c7927a3c 4623 int im AU = op[0] & 0x03;
f9c7014e 4624#line 376 "rx-decode.opc"
c7927a3c
NC		 4625 int rdst AU = op[1] & 0x0f;
4626 if (trace)
4627 {
4628 printf ("\033[33m%s\033[0m %02x %02x\n",
4629 "/** 0111 01im 0010 rdst and #%1, %0 */",
4630 op[0], op[1]);
4631 printf (" im = 0x%x,", im);
4632 printf (" rdst = 0x%x\n", rdst);
4633 }
4634 SYNTAX("and #%1, %0");
f9c7014e 4635#line 376 "rx-decode.opc"
3cf79a01 4636 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
c7927a3c
NC		 4637
4638 }
4639 break;
4640 case 0x30:
4641 op_semantics_34:
4642 {
4643 /** 0111 01im 0011 rdst or #%1, %0 */
f9c7014e 4644#line 394 "rx-decode.opc"
c7927a3c 4645 int im AU = op[0] & 0x03;
f9c7014e 4646#line 394 "rx-decode.opc"
c7927a3c
NC		 4647 int rdst AU = op[1] & 0x0f;
4648 if (trace)
4649 {
4650 printf ("\033[33m%s\033[0m %02x %02x\n",
4651 "/** 0111 01im 0011 rdst or #%1, %0 */",
4652 op[0], op[1]);
4653 printf (" im = 0x%x,", im);
4654 printf (" rdst = 0x%x\n", rdst);
4655 }
4656 SYNTAX("or #%1, %0");
f9c7014e 4657#line 394 "rx-decode.opc"
3cf79a01 4658 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
c7927a3c
NC		 4659
4660 }
4661 break;
4662 default: UNSUPPORTED(); break;
4663 }
4664 break;
4665 case 0x75:
4666 GETBYTE ();
4667 switch (op[1] & 0xff)
4668 {
4669 case 0x00:
4670 case 0x01:
4671 case 0x02:
4672 case 0x03:
4673 case 0x04:
4674 case 0x05:
4675 case 0x06:
4676 case 0x07:
4677 case 0x08:
4678 case 0x09:
4679 case 0x0a:
4680 case 0x0b:
4681 case 0x0c:
4682 case 0x0d:
4683 case 0x0e:
4684 case 0x0f:
4685 goto op_semantics_31;
4686 break;
4687 case 0x10:
4688 case 0x11:
4689 case 0x12:
4690 case 0x13:
4691 case 0x14:
4692 case 0x15:
4693 case 0x16:
4694 case 0x17:
4695 case 0x18:
4696 case 0x19:
4697 case 0x1a:
4698 case 0x1b:
4699 case 0x1c:
4700 case 0x1d:
4701 case 0x1e:
4702 case 0x1f:
4703 goto op_semantics_32;
4704 break;
4705 case 0x20:
4706 case 0x21:
4707 case 0x22:
4708 case 0x23:
4709 case 0x24:
4710 case 0x25:
4711 case 0x26:
4712 case 0x27:
4713 case 0x28:
4714 case 0x29:
4715 case 0x2a:
4716 case 0x2b:
4717 case 0x2c:
4718 case 0x2d:
4719 case 0x2e:
4720 case 0x2f:
4721 goto op_semantics_33;
4722 break;
4723 case 0x30:
4724 case 0x31:
4725 case 0x32:
4726 case 0x33:
4727 case 0x34:
4728 case 0x35:
4729 case 0x36:
4730 case 0x37:
4731 case 0x38:
4732 case 0x39:
4733 case 0x3a:
4734 case 0x3b:
4735 case 0x3c:
4736 case 0x3d:
4737 case 0x3e:
4738 case 0x3f:
4739 goto op_semantics_34;
4740 break;
4741 case 0x40:
4742 case 0x41:
4743 case 0x42:
4744 case 0x43:
4745 case 0x44:
4746 case 0x45:
4747 case 0x46:
4748 case 0x47:
4749 case 0x48:
4750 case 0x49:
4751 case 0x4a:
4752 case 0x4b:
4753 case 0x4c:
4754 case 0x4d:
4755 case 0x4e:
4756 case 0x4f:
4757 {
4758 /** 0111 0101 0100 rdst mov%s #%1, %0 */
f9c7014e 4759#line 262 "rx-decode.opc"
c7927a3c
NC		 4760 int rdst AU = op[1] & 0x0f;
4761 if (trace)
4762 {
4763 printf ("\033[33m%s\033[0m %02x %02x\n",
4764 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4765 op[0], op[1]);
4766 printf (" rdst = 0x%x\n", rdst);
4767 }
4768 SYNTAX("mov%s #%1, %0");
f9c7014e 4769#line 262 "rx-decode.opc"
3cf79a01 4770 ID(mov); DR(rdst); SC(IMM (1)); F_____;
c7927a3c
NC		 4771
4772 }
4773 break;
4774 case 0x50:
4775 case 0x51:
4776 case 0x52:
4777 case 0x53:
4778 case 0x54:
4779 case 0x55:
4780 case 0x56:
4781 case 0x57:
4782 case 0x58:
4783 case 0x59:
4784 case 0x5a:
4785 case 0x5b:
4786 case 0x5c:
4787 case 0x5d:
4788 case 0x5e:
4789 case 0x5f:
4790 {
4791 /** 0111 0101 0101 rsrc cmp #%2, %1 */
f9c7014e 4792#line 487 "rx-decode.opc"
c7927a3c
NC		 4793 int rsrc AU = op[1] & 0x0f;
4794 if (trace)
4795 {
4796 printf ("\033[33m%s\033[0m %02x %02x\n",
4797 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4798 op[0], op[1]);
4799 printf (" rsrc = 0x%x\n", rsrc);
4800 }
4801 SYNTAX("cmp #%2, %1");
f9c7014e 4802#line 487 "rx-decode.opc"
3cf79a01 4803 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
c7927a3c
NC		 4804
4805 }
4806 break;
4807 case 0x60:
4808 {
4809 /** 0111 0101 0110 0000 int #%1 */
4810 if (trace)
4811 {
4812 printf ("\033[33m%s\033[0m %02x %02x\n",
4813 "/** 0111 0101 0110 0000 int #%1 */",
4814 op[0], op[1]);
4815 }
4816 SYNTAX("int #%1");
f9c7014e 4817#line 947 "rx-decode.opc"
c7927a3c
NC		 4818 ID(int); SC(IMM(1));
4819
4820 }
4821 break;
946ef196
DD		 4822 case 0x70:
4823 GETBYTE ();
4824 switch (op[2] & 0xf0)
4825 {
4826 case 0x00:
4827 {
4828 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
f9c7014e 4829#line 914 "rx-decode.opc"
946ef196
DD		 4830 int immm AU = op[2] & 0x0f;
4831 if (trace)
4832 {
4833 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4834 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
4835 op[0], op[1], op[2]);
4836 printf (" immm = 0x%x\n", immm);
4837 }
4838 SYNTAX("mvtipl #%1");
f9c7014e 4839#line 914 "rx-decode.opc"
946ef196
DD		 4840 ID(mvtipl); SC(immm);
4841
4842 }
4843 break;
4844 default: UNSUPPORTED(); break;
4845 }
4846 break;
c7927a3c
NC		 4847 default: UNSUPPORTED(); break;
4848 }
4849 break;
4850 case 0x76:
4851 GETBYTE ();
4852 switch (op[1] & 0xf0)
4853 {
4854 case 0x00:
4855 goto op_semantics_31;
4856 break;
4857 case 0x10:
4858 goto op_semantics_32;
4859 break;
4860 case 0x20:
4861 goto op_semantics_33;
4862 break;
4863 case 0x30:
4864 goto op_semantics_34;
4865 break;
4866 default: UNSUPPORTED(); break;
4867 }
4868 break;
4869 case 0x77:
4870 GETBYTE ();
4871 switch (op[1] & 0xf0)
4872 {
4873 case 0x00:
4874 goto op_semantics_31;
4875 break;
4876 case 0x10:
4877 goto op_semantics_32;
4878 break;
4879 case 0x20:
4880 goto op_semantics_33;
4881 break;
4882 case 0x30:
4883 goto op_semantics_34;
4884 break;
4885 default: UNSUPPORTED(); break;
4886 }
4887 break;
4888 case 0x78:
4889 GETBYTE ();
4890 switch (op[1] & 0x00)
4891 {
4892 case 0x00:
4893 op_semantics_35:
4894 {
4895 /** 0111 100b ittt rdst bset #%1, %0 */
f9c7014e 4896#line 865 "rx-decode.opc"
c7927a3c 4897 int b AU = op[0] & 0x01;
f9c7014e 4898#line 865 "rx-decode.opc"
c7927a3c 4899 int ittt AU = (op[1] >> 4) & 0x0f;
f9c7014e 4900#line 865 "rx-decode.opc"
c7927a3c
NC		 4901 int rdst AU = op[1] & 0x0f;
4902 if (trace)
4903 {
4904 printf ("\033[33m%s\033[0m %02x %02x\n",
4905 "/** 0111 100b ittt rdst bset #%1, %0 */",
4906 op[0], op[1]);
4907 printf (" b = 0x%x,", b);
4908 printf (" ittt = 0x%x,", ittt);
4909 printf (" rdst = 0x%x\n", rdst);
4910 }
4911 SYNTAX("bset #%1, %0");
f9c7014e 4912#line 865 "rx-decode.opc"
3cf79a01 4913 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
c7927a3c
NC		 4914
4915
4916 }
4917 break;
4918 }
4919 break;
4920 case 0x79:
4921 GETBYTE ();
4922 switch (op[1] & 0x00)
4923 {
4924 case 0x00:
4925 goto op_semantics_35;
4926 break;
4927 }
4928 break;
4929 case 0x7a:
4930 GETBYTE ();
4931 switch (op[1] & 0x00)
4932 {
4933 case 0x00:
4934 op_semantics_36:
4935 {
4936 /** 0111 101b ittt rdst bclr #%1, %0 */
f9c7014e 4937#line 875 "rx-decode.opc"
c7927a3c 4938 int b AU = op[0] & 0x01;
f9c7014e 4939#line 875 "rx-decode.opc"
c7927a3c 4940 int ittt AU = (op[1] >> 4) & 0x0f;
f9c7014e 4941#line 875 "rx-decode.opc"
c7927a3c
NC		 4942 int rdst AU = op[1] & 0x0f;
4943 if (trace)
4944 {
4945 printf ("\033[33m%s\033[0m %02x %02x\n",
4946 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4947 op[0], op[1]);
4948 printf (" b = 0x%x,", b);
4949 printf (" ittt = 0x%x,", ittt);
4950 printf (" rdst = 0x%x\n", rdst);
4951 }
4952 SYNTAX("bclr #%1, %0");
f9c7014e 4953#line 875 "rx-decode.opc"
3cf79a01 4954 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
c7927a3c
NC		 4955
4956
4957 }
4958 break;
4959 }
4960 break;
4961 case 0x7b:
4962 GETBYTE ();
4963 switch (op[1] & 0x00)
4964 {
4965 case 0x00:
4966 goto op_semantics_36;
4967 break;
4968 }
4969 break;
4970 case 0x7c:
4971 GETBYTE ();
4972 switch (op[1] & 0x00)
4973 {
4974 case 0x00:
4975 op_semantics_37:
4976 {
4977 /** 0111 110b ittt rdst btst #%2, %1 */
f9c7014e 4978#line 885 "rx-decode.opc"
c7927a3c 4979 int b AU = op[0] & 0x01;
f9c7014e 4980#line 885 "rx-decode.opc"
c7927a3c 4981 int ittt AU = (op[1] >> 4) & 0x0f;
f9c7014e 4982#line 885 "rx-decode.opc"
c7927a3c
NC		 4983 int rdst AU = op[1] & 0x0f;
4984 if (trace)
4985 {
4986 printf ("\033[33m%s\033[0m %02x %02x\n",
4987 "/** 0111 110b ittt rdst btst #%2, %1 */",
4988 op[0], op[1]);
4989 printf (" b = 0x%x,", b);
4990 printf (" ittt = 0x%x,", ittt);
4991 printf (" rdst = 0x%x\n", rdst);
4992 }
4993 SYNTAX("btst #%2, %1");
f9c7014e 4994#line 885 "rx-decode.opc"
3cf79a01 4995 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
c7927a3c
NC		 4996
4997
4998 }
4999 break;
5000 }
5001 break;
5002 case 0x7d:
5003 GETBYTE ();
5004 switch (op[1] & 0x00)
5005 {
5006 case 0x00:
5007 goto op_semantics_37;
5008 break;
5009 }
5010 break;
5011 case 0x7e:
5012 GETBYTE ();
5013 switch (op[1] & 0xf0)
5014 {
5015 case 0x00:
5016 {
5017 /** 0111 1110 0000 rdst not %0 */
f9c7014e 5018#line 421 "rx-decode.opc"
c7927a3c
NC		 5019 int rdst AU = op[1] & 0x0f;
5020 if (trace)
5021 {
5022 printf ("\033[33m%s\033[0m %02x %02x\n",
5023 "/** 0111 1110 0000 rdst not %0 */",
5024 op[0], op[1]);
5025 printf (" rdst = 0x%x\n", rdst);
5026 }
5027 SYNTAX("not %0");
f9c7014e 5028#line 421 "rx-decode.opc"
3cf79a01 5029 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
c7927a3c
NC		 5030
5031 }
5032 break;
5033 case 0x10:
5034 {
5035 /** 0111 1110 0001 rdst neg %0 */
f9c7014e 5036#line 442 "rx-decode.opc"
c7927a3c
NC		 5037 int rdst AU = op[1] & 0x0f;
5038 if (trace)
5039 {
5040 printf ("\033[33m%s\033[0m %02x %02x\n",
5041 "/** 0111 1110 0001 rdst neg %0 */",
5042 op[0], op[1]);
5043 printf (" rdst = 0x%x\n", rdst);
5044 }
5045 SYNTAX("neg %0");
f9c7014e 5046#line 442 "rx-decode.opc"
3cf79a01 5047 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
c7927a3c
NC		 5048
5049 }
5050 break;
5051 case 0x20:
5052 {
5053 /** 0111 1110 0010 rdst abs %0 */
f9c7014e 5054#line 524 "rx-decode.opc"
c7927a3c
NC		 5055 int rdst AU = op[1] & 0x0f;
5056 if (trace)
5057 {
5058 printf ("\033[33m%s\033[0m %02x %02x\n",
5059 "/** 0111 1110 0010 rdst abs %0 */",
5060 op[0], op[1]);
5061 printf (" rdst = 0x%x\n", rdst);
5062 }
5063 SYNTAX("abs %0");
f9c7014e 5064#line 524 "rx-decode.opc"
3cf79a01 5065 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
c7927a3c
NC		 5066
5067 }
5068 break;
5069 case 0x30:
5070 {
5071 /** 0111 1110 0011 rdst sat %0 */
f9c7014e 5072#line 805 "rx-decode.opc"
c7927a3c
NC		 5073 int rdst AU = op[1] & 0x0f;
5074 if (trace)
5075 {
5076 printf ("\033[33m%s\033[0m %02x %02x\n",
5077 "/** 0111 1110 0011 rdst sat %0 */",
5078 op[0], op[1]);
5079 printf (" rdst = 0x%x\n", rdst);
5080 }
5081 SYNTAX("sat %0");
f9c7014e 5082#line 805 "rx-decode.opc"
c7927a3c
NC		 5083 ID(sat); DR (rdst);
5084
5085 }
5086 break;
5087 case 0x40:
5088 {
5089 /** 0111 1110 0100 rdst rorc %0 */
f9c7014e 5090#line 665 "rx-decode.opc"
c7927a3c
NC		 5091 int rdst AU = op[1] & 0x0f;
5092 if (trace)
5093 {
5094 printf ("\033[33m%s\033[0m %02x %02x\n",
5095 "/** 0111 1110 0100 rdst rorc %0 */",
5096 op[0], op[1]);
5097 printf (" rdst = 0x%x\n", rdst);
5098 }
5099 SYNTAX("rorc %0");
f9c7014e 5100#line 665 "rx-decode.opc"
3cf79a01 5101 ID(rorc); DR(rdst); F__SZC;
c7927a3c
NC		 5102
5103 }
5104 break;
5105 case 0x50:
5106 {
5107 /** 0111 1110 0101 rdst rolc %0 */
f9c7014e 5108#line 662 "rx-decode.opc"
c7927a3c
NC		 5109 int rdst AU = op[1] & 0x0f;
5110 if (trace)
5111 {
5112 printf ("\033[33m%s\033[0m %02x %02x\n",
5113 "/** 0111 1110 0101 rdst rolc %0 */",
5114 op[0], op[1]);
5115 printf (" rdst = 0x%x\n", rdst);
5116 }
5117 SYNTAX("rolc %0");
f9c7014e 5118#line 662 "rx-decode.opc"
3cf79a01 5119 ID(rolc); DR(rdst); F__SZC;
c7927a3c
NC		 5120
5121 }
5122 break;
5123 case 0x80:
5124 case 0x90:
5125 case 0xa0:
5126 {
5127 /** 0111 1110 10sz rsrc push%s %1 */
f9c7014e 5128#line 337 "rx-decode.opc"
c7927a3c 5129 int sz AU = (op[1] >> 4) & 0x03;
f9c7014e 5130#line 337 "rx-decode.opc"
c7927a3c
NC		 5131 int rsrc AU = op[1] & 0x0f;
5132 if (trace)
5133 {
5134 printf ("\033[33m%s\033[0m %02x %02x\n",
5135 "/** 0111 1110 10sz rsrc push%s %1 */",
5136 op[0], op[1]);
5137 printf (" sz = 0x%x,", sz);
5138 printf (" rsrc = 0x%x\n", rsrc);
5139 }
5140 SYNTAX("push%s %1");
f9c7014e 5141#line 337 "rx-decode.opc"
3cf79a01 5142 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
c7927a3c
NC		 5143
5144 }
5145 break;
5146 case 0xb0:
5147 {
5148 /** 0111 1110 1011 rdst pop %0 */
f9c7014e 5149#line 334 "rx-decode.opc"
c7927a3c
NC		 5150 int rdst AU = op[1] & 0x0f;
5151 if (trace)
5152 {
5153 printf ("\033[33m%s\033[0m %02x %02x\n",
5154 "/** 0111 1110 1011 rdst pop %0 */",
5155 op[0], op[1]);
5156 printf (" rdst = 0x%x\n", rdst);
5157 }
5158 SYNTAX("pop %0");
f9c7014e 5159#line 334 "rx-decode.opc"
3cf79a01 5160 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
c7927a3c
NC		 5161
5162 }
5163 break;
5164 case 0xc0:
5165 case 0xd0:
5166 {
5167 /** 0111 1110 110 crsrc pushc %1 */
f9c7014e 5168#line 920 "rx-decode.opc"
c7927a3c
NC		 5169 int crsrc AU = op[1] & 0x1f;
5170 if (trace)
5171 {
5172 printf ("\033[33m%s\033[0m %02x %02x\n",
5173 "/** 0111 1110 110 crsrc pushc %1 */",
5174 op[0], op[1]);
5175 printf (" crsrc = 0x%x\n", crsrc);
5176 }
5177 SYNTAX("pushc %1");
f9c7014e 5178#line 920 "rx-decode.opc"
c7927a3c
NC		 5179 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5180
5181 }
5182 break;
5183 case 0xe0:
5184 case 0xf0:
5185 {
5186 /** 0111 1110 111 crdst popc %0 */
f9c7014e 5187#line 917 "rx-decode.opc"
c7927a3c
NC		 5188 int crdst AU = op[1] & 0x1f;
5189 if (trace)
5190 {
5191 printf ("\033[33m%s\033[0m %02x %02x\n",
5192 "/** 0111 1110 111 crdst popc %0 */",
5193 op[0], op[1]);
5194 printf (" crdst = 0x%x\n", crdst);
5195 }
5196 SYNTAX("popc %0");
f9c7014e 5197#line 917 "rx-decode.opc"
c7927a3c
NC		 5198 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5199
5200 }
5201 break;
5202 default: UNSUPPORTED(); break;
5203 }
5204 break;
5205 case 0x7f:
5206 GETBYTE ();
5207 switch (op[1] & 0xff)
5208 {
5209 case 0x00:
5210 case 0x01:
5211 case 0x02:
5212 case 0x03:
5213 case 0x04:
5214 case 0x05:
5215 case 0x06:
5216 case 0x07:
5217 case 0x08:
5218 case 0x09:
5219 case 0x0a:
5220 case 0x0b:
5221 case 0x0c:
5222 case 0x0d:
5223 case 0x0e:
5224 case 0x0f:
5225 {
5226 /** 0111 1111 0000 rsrc jmp %0 */
f9c7014e 5227#line 715 "rx-decode.opc"
c7927a3c
NC		 5228 int rsrc AU = op[1] & 0x0f;
5229 if (trace)
5230 {
5231 printf ("\033[33m%s\033[0m %02x %02x\n",
5232 "/** 0111 1111 0000 rsrc jmp %0 */",
5233 op[0], op[1]);
5234 printf (" rsrc = 0x%x\n", rsrc);
5235 }
5236 SYNTAX("jmp %0");
f9c7014e
DD		 5237#line 715 "rx-decode.opc"
5238 ID(branch); DR(rsrc);
c7927a3c
NC		 5239
5240 }
5241 break;
5242 case 0x10:
5243 case 0x11:
5244 case 0x12:
5245 case 0x13:
5246 case 0x14:
5247 case 0x15:
5248 case 0x16:
5249 case 0x17:
5250 case 0x18:
5251 case 0x19:
5252 case 0x1a:
5253 case 0x1b:
5254 case 0x1c:
5255 case 0x1d:
5256 case 0x1e:
5257 case 0x1f:
5258 {
5259 /** 0111 1111 0001 rsrc jsr %0 */
f9c7014e 5260#line 718 "rx-decode.opc"
c7927a3c
NC		 5261 int rsrc AU = op[1] & 0x0f;
5262 if (trace)
5263 {
5264 printf ("\033[33m%s\033[0m %02x %02x\n",
5265 "/** 0111 1111 0001 rsrc jsr %0 */",
5266 op[0], op[1]);
5267 printf (" rsrc = 0x%x\n", rsrc);
5268 }
5269 SYNTAX("jsr %0");
f9c7014e 5270#line 718 "rx-decode.opc"
c7927a3c
NC		 5271 ID(jsr); DR(rsrc);
5272
5273 }
5274 break;
5275 case 0x40:
5276 case 0x41:
5277 case 0x42:
5278 case 0x43:
5279 case 0x44:
5280 case 0x45:
5281 case 0x46:
5282 case 0x47:
5283 case 0x48:
5284 case 0x49:
5285 case 0x4a:
5286 case 0x4b:
5287 case 0x4c:
5288 case 0x4d:
5289 case 0x4e:
5290 case 0x4f:
5291 {
5292 /** 0111 1111 0100 rsrc bra.l %0 */
f9c7014e 5293#line 711 "rx-decode.opc"
c7927a3c
NC		 5294 int rsrc AU = op[1] & 0x0f;
5295 if (trace)
5296 {
5297 printf ("\033[33m%s\033[0m %02x %02x\n",
5298 "/** 0111 1111 0100 rsrc bra.l %0 */",
5299 op[0], op[1]);
5300 printf (" rsrc = 0x%x\n", rsrc);
5301 }
5302 SYNTAX("bra.l %0");
f9c7014e
DD		 5303#line 711 "rx-decode.opc"
5304 ID(branchrel); DR(rsrc);
c7927a3c
NC		 5305
5306
5307 }
5308 break;
5309 case 0x50:
5310 case 0x51:
5311 case 0x52:
5312 case 0x53:
5313 case 0x54:
5314 case 0x55:
5315 case 0x56:
5316 case 0x57:
5317 case 0x58:
5318 case 0x59:
5319 case 0x5a:
5320 case 0x5b:
5321 case 0x5c:
5322 case 0x5d:
5323 case 0x5e:
5324 case 0x5f:
5325 {
5326 /** 0111 1111 0101 rsrc bsr.l %0 */
f9c7014e 5327#line 727 "rx-decode.opc"
c7927a3c
NC		 5328 int rsrc AU = op[1] & 0x0f;
5329 if (trace)
5330 {
5331 printf ("\033[33m%s\033[0m %02x %02x\n",
5332 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5333 op[0], op[1]);
5334 printf (" rsrc = 0x%x\n", rsrc);
5335 }
5336 SYNTAX("bsr.l %0");
f9c7014e 5337#line 727 "rx-decode.opc"
c7927a3c
NC		 5338 ID(jsrrel); DR(rsrc);
5339
5340 }
5341 break;
5342 case 0x80:
5343 case 0x81:
5344 case 0x82:
5345 {
5346 /** 0111 1111 1000 00sz suntil%s */
f9c7014e 5347#line 751 "rx-decode.opc"
c7927a3c
NC		 5348 int sz AU = op[1] & 0x03;
5349 if (trace)
5350 {
5351 printf ("\033[33m%s\033[0m %02x %02x\n",
5352 "/** 0111 1111 1000 00sz suntil%s */",
5353 op[0], op[1]);
5354 printf (" sz = 0x%x\n", sz);
5355 }
5356 SYNTAX("suntil%s");
f9c7014e 5357#line 751 "rx-decode.opc"
3cf79a01 5358 ID(suntil); BWL(sz); F___ZC;
c7927a3c
NC		 5359
5360 }
5361 break;
5362 case 0x83:
5363 {
5364 /** 0111 1111 1000 0011 scmpu */
5365 if (trace)
5366 {
5367 printf ("\033[33m%s\033[0m %02x %02x\n",
5368 "/** 0111 1111 1000 0011 scmpu */",
5369 op[0], op[1]);
5370 }
5371 SYNTAX("scmpu");
f9c7014e 5372#line 742 "rx-decode.opc"
3cf79a01 5373 ID(scmpu); F___ZC;
c7927a3c
NC		 5374
5375 }
5376 break;
5377 case 0x84:
5378 case 0x85:
5379 case 0x86:
5380 {
5381 /** 0111 1111 1000 01sz swhile%s */
f9c7014e 5382#line 754 "rx-decode.opc"
c7927a3c
NC		 5383 int sz AU = op[1] & 0x03;
5384 if (trace)
5385 {
5386 printf ("\033[33m%s\033[0m %02x %02x\n",
5387 "/** 0111 1111 1000 01sz swhile%s */",
5388 op[0], op[1]);
5389 printf (" sz = 0x%x\n", sz);
5390 }
5391 SYNTAX("swhile%s");
f9c7014e 5392#line 754 "rx-decode.opc"
3cf79a01 5393 ID(swhile); BWL(sz); F___ZC;
c7927a3c
NC		 5394
5395 }
5396 break;
5397 case 0x87:
5398 {
5399 /** 0111 1111 1000 0111 smovu */
5400 if (trace)
5401 {
5402 printf ("\033[33m%s\033[0m %02x %02x\n",
5403 "/** 0111 1111 1000 0111 smovu */",
5404 op[0], op[1]);
5405 }
5406 SYNTAX("smovu");
f9c7014e 5407#line 745 "rx-decode.opc"
c7927a3c
NC		 5408 ID(smovu);
5409
5410 }
5411 break;
5412 case 0x88:
5413 case 0x89:
5414 case 0x8a:
5415 {
5416 /** 0111 1111 1000 10sz sstr%s */
f9c7014e 5417#line 760 "rx-decode.opc"
c7927a3c
NC		 5418 int sz AU = op[1] & 0x03;
5419 if (trace)
5420 {
5421 printf ("\033[33m%s\033[0m %02x %02x\n",
5422 "/** 0111 1111 1000 10sz sstr%s */",
5423 op[0], op[1]);
5424 printf (" sz = 0x%x\n", sz);
5425 }
5426 SYNTAX("sstr%s");
f9c7014e 5427#line 760 "rx-decode.opc"
c7927a3c
NC		 5428 ID(sstr); BWL(sz);
5429
5430 /*----------------------------------------------------------------------*/
5431 /* RMPA */
5432
5433 }
5434 break;
5435 case 0x8b:
5436 {
5437 /** 0111 1111 1000 1011 smovb */
5438 if (trace)
5439 {
5440 printf ("\033[33m%s\033[0m %02x %02x\n",
5441 "/** 0111 1111 1000 1011 smovb */",
5442 op[0], op[1]);
5443 }
5444 SYNTAX("smovb");
f9c7014e 5445#line 748 "rx-decode.opc"
c7927a3c
NC		 5446 ID(smovb);
5447
5448 }
5449 break;
5450 case 0x8c:
5451 case 0x8d:
5452 case 0x8e:
5453 {
5454 /** 0111 1111 1000 11sz rmpa%s */
f9c7014e 5455#line 766 "rx-decode.opc"
c7927a3c
NC		 5456 int sz AU = op[1] & 0x03;
5457 if (trace)
5458 {
5459 printf ("\033[33m%s\033[0m %02x %02x\n",
5460 "/** 0111 1111 1000 11sz rmpa%s */",
5461 op[0], op[1]);
5462 printf (" sz = 0x%x\n", sz);
5463 }
5464 SYNTAX("rmpa%s");
f9c7014e 5465#line 766 "rx-decode.opc"
3cf79a01 5466 ID(rmpa); BWL(sz); F_OS__;
c7927a3c
NC		 5467
5468 /*----------------------------------------------------------------------*/
5469 /* HI/LO stuff */
5470
5471 }
5472 break;
5473 case 0x8f:
5474 {
5475 /** 0111 1111 1000 1111 smovf */
5476 if (trace)
5477 {
5478 printf ("\033[33m%s\033[0m %02x %02x\n",
5479 "/** 0111 1111 1000 1111 smovf */",
5480 op[0], op[1]);
5481 }
5482 SYNTAX("smovf");
f9c7014e 5483#line 757 "rx-decode.opc"
c7927a3c
NC		 5484 ID(smovf);
5485
5486 }
5487 break;
5488 case 0x93:
5489 {
5490 /** 0111 1111 1001 0011 satr */
5491 if (trace)
5492 {
5493 printf ("\033[33m%s\033[0m %02x %02x\n",
5494 "/** 0111 1111 1001 0011 satr */",
5495 op[0], op[1]);
5496 }
5497 SYNTAX("satr");
f9c7014e 5498#line 808 "rx-decode.opc"
c7927a3c
NC		 5499 ID(satr);
5500
5501 /*----------------------------------------------------------------------*/
5502 /* FLOAT */
5503
5504 }
5505 break;
5506 case 0x94:
5507 {
5508 /** 0111 1111 1001 0100 rtfi */
5509 if (trace)
5510 {
5511 printf ("\033[33m%s\033[0m %02x %02x\n",
5512 "/** 0111 1111 1001 0100 rtfi */",
5513 op[0], op[1]);
5514 }
5515 SYNTAX("rtfi");
f9c7014e 5516#line 935 "rx-decode.opc"
c7927a3c
NC		 5517 ID(rtfi);
5518
5519 }
5520 break;
5521 case 0x95:
5522 {
5523 /** 0111 1111 1001 0101 rte */
5524 if (trace)
5525 {
5526 printf ("\033[33m%s\033[0m %02x %02x\n",
5527 "/** 0111 1111 1001 0101 rte */",
5528 op[0], op[1]);
5529 }
5530 SYNTAX("rte");
f9c7014e 5531#line 938 "rx-decode.opc"
c7927a3c
NC		 5532 ID(rte);
5533
5534 }
5535 break;
5536 case 0x96:
5537 {
5538 /** 0111 1111 1001 0110 wait */
5539 if (trace)
5540 {
5541 printf ("\033[33m%s\033[0m %02x %02x\n",
5542 "/** 0111 1111 1001 0110 wait */",
5543 op[0], op[1]);
5544 }
5545 SYNTAX("wait");
f9c7014e 5546#line 950 "rx-decode.opc"
c7927a3c
NC		 5547 ID(wait);
5548
5549 /*----------------------------------------------------------------------*/
5550 /* SCcnd */
5551
5552 }
5553 break;
5554 case 0xa0:
5555 case 0xa1:
5556 case 0xa2:
5557 case 0xa3:
5558 case 0xa4:
5559 case 0xa5:
5560 case 0xa6:
5561 case 0xa7:
5562 case 0xa8:
5563 case 0xa9:
5564 case 0xaa:
5565 case 0xab:
5566 case 0xac:
5567 case 0xad:
5568 case 0xae:
5569 case 0xaf:
5570 {
5571 /** 0111 1111 1010 rdst setpsw %0 */
f9c7014e 5572#line 911 "rx-decode.opc"
c7927a3c
NC		 5573 int rdst AU = op[1] & 0x0f;
5574 if (trace)
5575 {
5576 printf ("\033[33m%s\033[0m %02x %02x\n",
5577 "/** 0111 1111 1010 rdst setpsw %0 */",
5578 op[0], op[1]);
5579 printf (" rdst = 0x%x\n", rdst);
5580 }
5581 SYNTAX("setpsw %0");
f9c7014e 5582#line 911 "rx-decode.opc"
c7927a3c
NC		 5583 ID(setpsw); DF(rdst);
5584
5585 }
5586 break;
5587 case 0xb0:
5588 case 0xb1:
5589 case 0xb2:
5590 case 0xb3:
5591 case 0xb4:
5592 case 0xb5:
5593 case 0xb6:
5594 case 0xb7:
5595 case 0xb8:
5596 case 0xb9:
5597 case 0xba:
5598 case 0xbb:
5599 case 0xbc:
5600 case 0xbd:
5601 case 0xbe:
5602 case 0xbf:
5603 {
5604 /** 0111 1111 1011 rdst clrpsw %0 */
f9c7014e 5605#line 908 "rx-decode.opc"
c7927a3c
NC		 5606 int rdst AU = op[1] & 0x0f;
5607 if (trace)
5608 {
5609 printf ("\033[33m%s\033[0m %02x %02x\n",
5610 "/** 0111 1111 1011 rdst clrpsw %0 */",
5611 op[0], op[1]);
5612 printf (" rdst = 0x%x\n", rdst);
5613 }
5614 SYNTAX("clrpsw %0");
f9c7014e 5615#line 908 "rx-decode.opc"
c7927a3c
NC		 5616 ID(clrpsw); DF(rdst);
5617
5618 }
5619 break;
5620 default: UNSUPPORTED(); break;
5621 }
5622 break;
5623 case 0x80:
5624 GETBYTE ();
5625 switch (op[1] & 0x00)
5626 {
5627 case 0x00:
5628 op_semantics_38:
5629 {
5630 /** 10sz 0dsp a dst b src mov%s %1, %0 */
f9c7014e 5631#line 295 "rx-decode.opc"
c7927a3c 5632 int sz AU = (op[0] >> 4) & 0x03;
f9c7014e 5633#line 295 "rx-decode.opc"
c7927a3c 5634 int dsp AU = op[0] & 0x07;
f9c7014e 5635#line 295 "rx-decode.opc"
c7927a3c 5636 int a AU = (op[1] >> 7) & 0x01;
f9c7014e 5637#line 295 "rx-decode.opc"
c7927a3c 5638 int dst AU = (op[1] >> 4) & 0x07;
f9c7014e 5639#line 295 "rx-decode.opc"
c7927a3c 5640 int b AU = (op[1] >> 3) & 0x01;
f9c7014e 5641#line 295 "rx-decode.opc"
c7927a3c
NC		 5642 int src AU = op[1] & 0x07;
5643 if (trace)
5644 {
5645 printf ("\033[33m%s\033[0m %02x %02x\n",
5646 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5647 op[0], op[1]);
5648 printf (" sz = 0x%x,", sz);
5649 printf (" dsp = 0x%x,", dsp);
5650 printf (" a = 0x%x,", a);
5651 printf (" dst = 0x%x,", dst);
5652 printf (" b = 0x%x,", b);
5653 printf (" src = 0x%x\n", src);
5654 }
5655 SYNTAX("mov%s %1, %0");
f9c7014e 5656#line 295 "rx-decode.opc"
3cf79a01 5657 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
c7927a3c
NC		 5658
5659 }
5660 break;
5661 }
5662 break;
5663 case 0x81:
5664 GETBYTE ();
5665 switch (op[1] & 0x00)
5666 {
5667 case 0x00:
5668 goto op_semantics_38;
5669 break;
5670 }
5671 break;
5672 case 0x82:
5673 GETBYTE ();
5674 switch (op[1] & 0x00)
5675 {
5676 case 0x00:
5677 goto op_semantics_38;
5678 break;
5679 }
5680 break;
5681 case 0x83:
5682 GETBYTE ();
5683 switch (op[1] & 0x00)
5684 {
5685 case 0x00:
5686 goto op_semantics_38;
5687 break;
5688 }
5689 break;
5690 case 0x84:
5691 GETBYTE ();
5692 switch (op[1] & 0x00)
5693 {
5694 case 0x00:
5695 goto op_semantics_38;
5696 break;
5697 }
5698 break;
5699 case 0x85:
5700 GETBYTE ();
5701 switch (op[1] & 0x00)
5702 {
5703 case 0x00:
5704 goto op_semantics_38;
5705 break;
5706 }
5707 break;
5708 case 0x86:
5709 GETBYTE ();
5710 switch (op[1] & 0x00)
5711 {
5712 case 0x00:
5713 goto op_semantics_38;
5714 break;
5715 }
5716 break;
5717 case 0x87:
5718 GETBYTE ();
5719 switch (op[1] & 0x00)
5720 {
5721 case 0x00:
5722 goto op_semantics_38;
5723 break;
5724 }
5725 break;
5726 case 0x88:
5727 GETBYTE ();
5728 switch (op[1] & 0x00)
5729 {
5730 case 0x00:
5731 op_semantics_39:
5732 {
5733 /** 10sz 1dsp a src b dst mov%s %1, %0 */
f9c7014e 5734#line 292 "rx-decode.opc"
c7927a3c 5735 int sz AU = (op[0] >> 4) & 0x03;
f9c7014e 5736#line 292 "rx-decode.opc"
c7927a3c 5737 int dsp AU = op[0] & 0x07;
f9c7014e 5738#line 292 "rx-decode.opc"
c7927a3c 5739 int a AU = (op[1] >> 7) & 0x01;
f9c7014e 5740#line 292 "rx-decode.opc"
c7927a3c 5741 int src AU = (op[1] >> 4) & 0x07;
f9c7014e 5742#line 292 "rx-decode.opc"
c7927a3c 5743 int b AU = (op[1] >> 3) & 0x01;
f9c7014e 5744#line 292 "rx-decode.opc"
c7927a3c
NC		 5745 int dst AU = op[1] & 0x07;
5746 if (trace)
5747 {
5748 printf ("\033[33m%s\033[0m %02x %02x\n",
5749 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5750 op[0], op[1]);
5751 printf (" sz = 0x%x,", sz);
5752 printf (" dsp = 0x%x,", dsp);
5753 printf (" a = 0x%x,", a);
5754 printf (" src = 0x%x,", src);
5755 printf (" b = 0x%x,", b);
5756 printf (" dst = 0x%x\n", dst);
5757 }
5758 SYNTAX("mov%s %1, %0");
f9c7014e 5759#line 292 "rx-decode.opc"
3cf79a01 5760 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
c7927a3c
NC		 5761
5762 }
5763 break;
5764 }
5765 break;
5766 case 0x89:
5767 GETBYTE ();
5768 switch (op[1] & 0x00)
5769 {
5770 case 0x00:
5771 goto op_semantics_39;
5772 break;
5773 }
5774 break;
5775 case 0x8a:
5776 GETBYTE ();
5777 switch (op[1] & 0x00)
5778 {
5779 case 0x00:
5780 goto op_semantics_39;
5781 break;
5782 }
5783 break;
5784 case 0x8b:
5785 GETBYTE ();
5786 switch (op[1] & 0x00)
5787 {
5788 case 0x00:
5789 goto op_semantics_39;
5790 break;
5791 }
5792 break;
5793 case 0x8c:
5794 GETBYTE ();
5795 switch (op[1] & 0x00)
5796 {
5797 case 0x00:
5798 goto op_semantics_39;
5799 break;
5800 }
5801 break;
5802 case 0x8d:
5803 GETBYTE ();
5804 switch (op[1] & 0x00)
5805 {
5806 case 0x00:
5807 goto op_semantics_39;
5808 break;
5809 }
5810 break;
5811 case 0x8e:
5812 GETBYTE ();
5813 switch (op[1] & 0x00)
5814 {
5815 case 0x00:
5816 goto op_semantics_39;
5817 break;
5818 }
5819 break;
5820 case 0x8f:
5821 GETBYTE ();
5822 switch (op[1] & 0x00)
5823 {
5824 case 0x00:
5825 goto op_semantics_39;
5826 break;
5827 }
5828 break;
5829 case 0x90:
5830 GETBYTE ();
5831 switch (op[1] & 0x00)
5832 {
5833 case 0x00:
5834 goto op_semantics_38;
5835 break;
5836 }
5837 break;
5838 case 0x91:
5839 GETBYTE ();
5840 switch (op[1] & 0x00)
5841 {
5842 case 0x00:
5843 goto op_semantics_38;
5844 break;
5845 }
5846 break;
5847 case 0x92:
5848 GETBYTE ();
5849 switch (op[1] & 0x00)
5850 {
5851 case 0x00:
5852 goto op_semantics_38;
5853 break;
5854 }
5855 break;
5856 case 0x93:
5857 GETBYTE ();
5858 switch (op[1] & 0x00)
5859 {
5860 case 0x00:
5861 goto op_semantics_38;
5862 break;
5863 }
5864 break;
5865 case 0x94:
5866 GETBYTE ();
5867 switch (op[1] & 0x00)
5868 {
5869 case 0x00:
5870 goto op_semantics_38;
5871 break;
5872 }
5873 break;
5874 case 0x95:
5875 GETBYTE ();
5876 switch (op[1] & 0x00)
5877 {
5878 case 0x00:
5879 goto op_semantics_38;
5880 break;
5881 }
5882 break;
5883 case 0x96:
5884 GETBYTE ();
5885 switch (op[1] & 0x00)
5886 {
5887 case 0x00:
5888 goto op_semantics_38;
5889 break;
5890 }
5891 break;
5892 case 0x97:
5893 GETBYTE ();
5894 switch (op[1] & 0x00)
5895 {
5896 case 0x00:
5897 goto op_semantics_38;
5898 break;
5899 }
5900 break;
5901 case 0x98:
5902 GETBYTE ();
5903 switch (op[1] & 0x00)
5904 {
5905 case 0x00:
5906 goto op_semantics_39;
5907 break;
5908 }
5909 break;
5910 case 0x99:
5911 GETBYTE ();
5912 switch (op[1] & 0x00)
5913 {
5914 case 0x00:
5915 goto op_semantics_39;
5916 break;
5917 }
5918 break;
5919 case 0x9a:
5920 GETBYTE ();
5921 switch (op[1] & 0x00)
5922 {
5923 case 0x00:
5924 goto op_semantics_39;
5925 break;
5926 }
5927 break;
5928 case 0x9b:
5929 GETBYTE ();
5930 switch (op[1] & 0x00)
5931 {
5932 case 0x00:
5933 goto op_semantics_39;
5934 break;
5935 }
5936 break;
5937 case 0x9c:
5938 GETBYTE ();
5939 switch (op[1] & 0x00)
5940 {
5941 case 0x00:
5942 goto op_semantics_39;
5943 break;
5944 }
5945 break;
5946 case 0x9d:
5947 GETBYTE ();
5948 switch (op[1] & 0x00)
5949 {
5950 case 0x00:
5951 goto op_semantics_39;
5952 break;
5953 }
5954 break;
5955 case 0x9e:
5956 GETBYTE ();
5957 switch (op[1] & 0x00)
5958 {
5959 case 0x00:
5960 goto op_semantics_39;
5961 break;
5962 }
5963 break;
5964 case 0x9f:
5965 GETBYTE ();
5966 switch (op[1] & 0x00)
5967 {
5968 case 0x00:
5969 goto op_semantics_39;
5970 break;
5971 }
5972 break;
5973 case 0xa0:
5974 GETBYTE ();
5975 switch (op[1] & 0x00)
5976 {
5977 case 0x00:
5978 goto op_semantics_38;
5979 break;
5980 }
5981 break;
5982 case 0xa1:
5983 GETBYTE ();
5984 switch (op[1] & 0x00)
5985 {
5986 case 0x00:
5987 goto op_semantics_38;
5988 break;
5989 }
5990 break;
5991 case 0xa2:
5992 GETBYTE ();
5993 switch (op[1] & 0x00)
5994 {
5995 case 0x00:
5996 goto op_semantics_38;
5997 break;
5998 }
5999 break;
6000 case 0xa3:
6001 GETBYTE ();
6002 switch (op[1] & 0x00)
6003 {
6004 case 0x00:
6005 goto op_semantics_38;
6006 break;
6007 }
6008 break;
6009 case 0xa4:
6010 GETBYTE ();
6011 switch (op[1] & 0x00)
6012 {
6013 case 0x00:
6014 goto op_semantics_38;
6015 break;
6016 }
6017 break;
6018 case 0xa5:
6019 GETBYTE ();
6020 switch (op[1] & 0x00)
6021 {
6022 case 0x00:
6023 goto op_semantics_38;
6024 break;
6025 }
6026 break;
6027 case 0xa6:
6028 GETBYTE ();
6029 switch (op[1] & 0x00)
6030 {
6031 case 0x00:
6032 goto op_semantics_38;
6033 break;
6034 }
6035 break;
6036 case 0xa7:
6037 GETBYTE ();
6038 switch (op[1] & 0x00)
6039 {
6040 case 0x00:
6041 goto op_semantics_38;
6042 break;
6043 }
6044 break;
6045 case 0xa8:
6046 GETBYTE ();
6047 switch (op[1] & 0x00)
6048 {
6049 case 0x00:
6050 goto op_semantics_39;
6051 break;
6052 }
6053 break;
6054 case 0xa9:
6055 GETBYTE ();
6056 switch (op[1] & 0x00)
6057 {
6058 case 0x00:
6059 goto op_semantics_39;
6060 break;
6061 }
6062 break;
6063 case 0xaa:
6064 GETBYTE ();
6065 switch (op[1] & 0x00)
6066 {
6067 case 0x00:
6068 goto op_semantics_39;
6069 break;
6070 }
6071 break;
6072 case 0xab:
6073 GETBYTE ();
6074 switch (op[1] & 0x00)
6075 {
6076 case 0x00:
6077 goto op_semantics_39;
6078 break;
6079 }
6080 break;
6081 case 0xac:
6082 GETBYTE ();
6083 switch (op[1] & 0x00)
6084 {
6085 case 0x00:
6086 goto op_semantics_39;
6087 break;
6088 }
6089 break;
6090 case 0xad:
6091 GETBYTE ();
6092 switch (op[1] & 0x00)
6093 {
6094 case 0x00:
6095 goto op_semantics_39;
6096 break;
6097 }
6098 break;
6099 case 0xae:
6100 GETBYTE ();
6101 switch (op[1] & 0x00)
6102 {
6103 case 0x00:
6104 goto op_semantics_39;
6105 break;
6106 }
6107 break;
6108 case 0xaf:
6109 GETBYTE ();
6110 switch (op[1] & 0x00)
6111 {
6112 case 0x00:
6113 goto op_semantics_39;
6114 break;
6115 }
6116 break;
6117 case 0xb0:
6118 GETBYTE ();
6119 switch (op[1] & 0x00)
6120 {
6121 case 0x00:
6122 op_semantics_40:
6123 {
6124 /** 1011 w dsp a src b dst movu%s %1, %0 */
f9c7014e 6125#line 315 "rx-decode.opc"
c7927a3c 6126 int w AU = (op[0] >> 3) & 0x01;
f9c7014e 6127#line 315 "rx-decode.opc"
c7927a3c 6128 int dsp AU = op[0] & 0x07;
f9c7014e 6129#line 315 "rx-decode.opc"
c7927a3c 6130 int a AU = (op[1] >> 7) & 0x01;
f9c7014e 6131#line 315 "rx-decode.opc"
c7927a3c 6132 int src AU = (op[1] >> 4) & 0x07;
f9c7014e 6133#line 315 "rx-decode.opc"
c7927a3c 6134 int b AU = (op[1] >> 3) & 0x01;
f9c7014e 6135#line 315 "rx-decode.opc"
c7927a3c
NC		 6136 int dst AU = op[1] & 0x07;
6137 if (trace)
6138 {
6139 printf ("\033[33m%s\033[0m %02x %02x\n",
6140 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6141 op[0], op[1]);
6142 printf (" w = 0x%x,", w);
6143 printf (" dsp = 0x%x,", dsp);
6144 printf (" a = 0x%x,", a);
6145 printf (" src = 0x%x,", src);
6146 printf (" b = 0x%x,", b);
6147 printf (" dst = 0x%x\n", dst);
6148 }
6149 SYNTAX("movu%s %1, %0");
f9c7014e 6150#line 315 "rx-decode.opc"
3cf79a01 6151 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
c7927a3c
NC		 6152
6153 }
6154 break;
6155 }
6156 break;
6157 case 0xb1:
6158 GETBYTE ();
6159 switch (op[1] & 0x00)
6160 {
6161 case 0x00:
6162 goto op_semantics_40;
6163 break;
6164 }
6165 break;
6166 case 0xb2:
6167 GETBYTE ();
6168 switch (op[1] & 0x00)
6169 {
6170 case 0x00:
6171 goto op_semantics_40;
6172 break;
6173 }
6174 break;
6175 case 0xb3:
6176 GETBYTE ();
6177 switch (op[1] & 0x00)
6178 {
6179 case 0x00:
6180 goto op_semantics_40;
6181 break;
6182 }
6183 break;
6184 case 0xb4:
6185 GETBYTE ();
6186 switch (op[1] & 0x00)
6187 {
6188 case 0x00:
6189 goto op_semantics_40;
6190 break;
6191 }
6192 break;
6193 case 0xb5:
6194 GETBYTE ();
6195 switch (op[1] & 0x00)
6196 {
6197 case 0x00:
6198 goto op_semantics_40;
6199 break;
6200 }
6201 break;
6202 case 0xb6:
6203 GETBYTE ();
6204 switch (op[1] & 0x00)
6205 {
6206 case 0x00:
6207 goto op_semantics_40;
6208 break;
6209 }
6210 break;
6211 case 0xb7:
6212 GETBYTE ();
6213 switch (op[1] & 0x00)
6214 {
6215 case 0x00:
6216 goto op_semantics_40;
6217 break;
6218 }
6219 break;
6220 case 0xb8:
6221 GETBYTE ();
6222 switch (op[1] & 0x00)
6223 {
6224 case 0x00:
6225 goto op_semantics_40;
6226 break;
6227 }
6228 break;
6229 case 0xb9:
6230 GETBYTE ();
6231 switch (op[1] & 0x00)
6232 {
6233 case 0x00:
6234 goto op_semantics_40;
6235 break;
6236 }
6237 break;
6238 case 0xba:
6239 GETBYTE ();
6240 switch (op[1] & 0x00)
6241 {
6242 case 0x00:
6243 goto op_semantics_40;
6244 break;
6245 }
6246 break;
6247 case 0xbb:
6248 GETBYTE ();
6249 switch (op[1] & 0x00)
6250 {
6251 case 0x00:
6252 goto op_semantics_40;
6253 break;
6254 }
6255 break;
6256 case 0xbc:
6257 GETBYTE ();
6258 switch (op[1] & 0x00)
6259 {
6260 case 0x00:
6261 goto op_semantics_40;
6262 break;
6263 }
6264 break;
6265 case 0xbd:
6266 GETBYTE ();
6267 switch (op[1] & 0x00)
6268 {
6269 case 0x00:
6270 goto op_semantics_40;
6271 break;
6272 }
6273 break;
6274 case 0xbe:
6275 GETBYTE ();
6276 switch (op[1] & 0x00)
6277 {
6278 case 0x00:
6279 goto op_semantics_40;
6280 break;
6281 }
6282 break;
6283 case 0xbf:
6284 GETBYTE ();
6285 switch (op[1] & 0x00)
6286 {
6287 case 0x00:
6288 goto op_semantics_40;
6289 break;
6290 }
6291 break;
6292 case 0xc0:
6293 GETBYTE ();
6294 switch (op[1] & 0x00)
6295 {
6296 case 0x00:
6297 op_semantics_41:
6298 {
6299 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
f9c7014e 6300#line 274 "rx-decode.opc"
c7927a3c 6301 int sz AU = (op[0] >> 4) & 0x03;
f9c7014e 6302#line 274 "rx-decode.opc"
c7927a3c 6303 int sd AU = (op[0] >> 2) & 0x03;
f9c7014e 6304#line 274 "rx-decode.opc"
c7927a3c 6305 int ss AU = op[0] & 0x03;
f9c7014e 6306#line 274 "rx-decode.opc"
c7927a3c 6307 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 6308#line 274 "rx-decode.opc"
c7927a3c
NC		 6309 int rdst AU = op[1] & 0x0f;
6310 if (trace)
6311 {
6312 printf ("\033[33m%s\033[0m %02x %02x\n",
6313 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6314 op[0], op[1]);
6315 printf (" sz = 0x%x,", sz);
6316 printf (" sd = 0x%x,", sd);
6317 printf (" ss = 0x%x,", ss);
6318 printf (" rsrc = 0x%x,", rsrc);
6319 printf (" rdst = 0x%x\n", rdst);
6320 }
6321 SYNTAX("mov%s %1, %0");
f9c7014e
DD		 6322#line 274 "rx-decode.opc"
6323 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
c7927a3c 6324 {
f9c7014e 6325 ID(nop2);
c7927a3c
NC		 6326 }
6327 else
6328 {
f9c7014e
DD		 6329 ID(mov); sBWL(sz); F_____;
6330 if ((ss == 3) && (sd != 3))
6331 {
6332 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6333 }
6334 else
6335 {
6336 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6337 }
c7927a3c
NC		 6338 }
6339
6340 }
6341 break;
6342 }
6343 break;
6344 case 0xc1:
6345 GETBYTE ();
6346 switch (op[1] & 0x00)
6347 {
6348 case 0x00:
6349 goto op_semantics_41;
6350 break;
6351 }
6352 break;
6353 case 0xc2:
6354 GETBYTE ();
6355 switch (op[1] & 0x00)
6356 {
6357 case 0x00:
6358 goto op_semantics_41;
6359 break;
6360 }
6361 break;
6362 case 0xc3:
6363 GETBYTE ();
6364 switch (op[1] & 0x00)
6365 {
6366 case 0x00:
6367 goto op_semantics_41;
6368 break;
6369 }
6370 break;
6371 case 0xc4:
6372 GETBYTE ();
6373 switch (op[1] & 0x00)
6374 {
6375 case 0x00:
6376 goto op_semantics_41;
6377 break;
6378 }
6379 break;
6380 case 0xc5:
6381 GETBYTE ();
6382 switch (op[1] & 0x00)
6383 {
6384 case 0x00:
6385 goto op_semantics_41;
6386 break;
6387 }
6388 break;
6389 case 0xc6:
6390 GETBYTE ();
6391 switch (op[1] & 0x00)
6392 {
6393 case 0x00:
6394 goto op_semantics_41;
6395 break;
6396 }
6397 break;
6398 case 0xc7:
6399 GETBYTE ();
6400 switch (op[1] & 0x00)
6401 {
6402 case 0x00:
6403 goto op_semantics_41;
6404 break;
6405 }
6406 break;
6407 case 0xc8:
6408 GETBYTE ();
6409 switch (op[1] & 0x00)
6410 {
6411 case 0x00:
6412 goto op_semantics_41;
6413 break;
6414 }
6415 break;
6416 case 0xc9:
6417 GETBYTE ();
6418 switch (op[1] & 0x00)
6419 {
6420 case 0x00:
6421 goto op_semantics_41;
6422 break;
6423 }
6424 break;
6425 case 0xca:
6426 GETBYTE ();
6427 switch (op[1] & 0x00)
6428 {
6429 case 0x00:
6430 goto op_semantics_41;
6431 break;
6432 }
6433 break;
6434 case 0xcb:
6435 GETBYTE ();
6436 switch (op[1] & 0x00)
6437 {
6438 case 0x00:
6439 goto op_semantics_41;
6440 break;
6441 }
6442 break;
6443 case 0xcc:
6444 GETBYTE ();
6445 switch (op[1] & 0x00)
6446 {
6447 case 0x00:
6448 goto op_semantics_41;
6449 break;
6450 }
6451 break;
6452 case 0xcd:
6453 GETBYTE ();
6454 switch (op[1] & 0x00)
6455 {
6456 case 0x00:
6457 goto op_semantics_41;
6458 break;
6459 }
6460 break;
6461 case 0xce:
6462 GETBYTE ();
6463 switch (op[1] & 0x00)
6464 {
6465 case 0x00:
6466 goto op_semantics_41;
6467 break;
6468 }
6469 break;
6470 case 0xcf:
6471 GETBYTE ();
6472 switch (op[1] & 0x00)
6473 {
6474 case 0x00:
6475 goto op_semantics_41;
6476 break;
6477 }
6478 break;
6479 case 0xd0:
6480 GETBYTE ();
6481 switch (op[1] & 0x00)
6482 {
6483 case 0x00:
6484 goto op_semantics_41;
6485 break;
6486 }
6487 break;
6488 case 0xd1:
6489 GETBYTE ();
6490 switch (op[1] & 0x00)
6491 {
6492 case 0x00:
6493 goto op_semantics_41;
6494 break;
6495 }
6496 break;
6497 case 0xd2:
6498 GETBYTE ();
6499 switch (op[1] & 0x00)
6500 {
6501 case 0x00:
6502 goto op_semantics_41;
6503 break;
6504 }
6505 break;
6506 case 0xd3:
6507 GETBYTE ();
6508 switch (op[1] & 0x00)
6509 {
6510 case 0x00:
6511 goto op_semantics_41;
6512 break;
6513 }
6514 break;
6515 case 0xd4:
6516 GETBYTE ();
6517 switch (op[1] & 0x00)
6518 {
6519 case 0x00:
6520 goto op_semantics_41;
6521 break;
6522 }
6523 break;
6524 case 0xd5:
6525 GETBYTE ();
6526 switch (op[1] & 0x00)
6527 {
6528 case 0x00:
6529 goto op_semantics_41;
6530 break;
6531 }
6532 break;
6533 case 0xd6:
6534 GETBYTE ();
6535 switch (op[1] & 0x00)
6536 {
6537 case 0x00:
6538 goto op_semantics_41;
6539 break;
6540 }
6541 break;
6542 case 0xd7:
6543 GETBYTE ();
6544 switch (op[1] & 0x00)
6545 {
6546 case 0x00:
6547 goto op_semantics_41;
6548 break;
6549 }
6550 break;
6551 case 0xd8:
6552 GETBYTE ();
6553 switch (op[1] & 0x00)
6554 {
6555 case 0x00:
6556 goto op_semantics_41;
6557 break;
6558 }
6559 break;
6560 case 0xd9:
6561 GETBYTE ();
6562 switch (op[1] & 0x00)
6563 {
6564 case 0x00:
6565 goto op_semantics_41;
6566 break;
6567 }
6568 break;
6569 case 0xda:
6570 GETBYTE ();
6571 switch (op[1] & 0x00)
6572 {
6573 case 0x00:
6574 goto op_semantics_41;
6575 break;
6576 }
6577 break;
6578 case 0xdb:
6579 GETBYTE ();
6580 switch (op[1] & 0x00)
6581 {
6582 case 0x00:
6583 goto op_semantics_41;
6584 break;
6585 }
6586 break;
6587 case 0xdc:
6588 GETBYTE ();
6589 switch (op[1] & 0x00)
6590 {
6591 case 0x00:
6592 goto op_semantics_41;
6593 break;
6594 }
6595 break;
6596 case 0xdd:
6597 GETBYTE ();
6598 switch (op[1] & 0x00)
6599 {
6600 case 0x00:
6601 goto op_semantics_41;
6602 break;
6603 }
6604 break;
6605 case 0xde:
6606 GETBYTE ();
6607 switch (op[1] & 0x00)
6608 {
6609 case 0x00:
6610 goto op_semantics_41;
6611 break;
6612 }
6613 break;
6614 case 0xdf:
6615 GETBYTE ();
6616 switch (op[1] & 0x00)
6617 {
6618 case 0x00:
6619 goto op_semantics_41;
6620 break;
6621 }
6622 break;
6623 case 0xe0:
6624 GETBYTE ();
6625 switch (op[1] & 0x00)
6626 {
6627 case 0x00:
6628 goto op_semantics_41;
6629 break;
6630 }
6631 break;
6632 case 0xe1:
6633 GETBYTE ();
6634 switch (op[1] & 0x00)
6635 {
6636 case 0x00:
6637 goto op_semantics_41;
6638 break;
6639 }
6640 break;
6641 case 0xe2:
6642 GETBYTE ();
6643 switch (op[1] & 0x00)
6644 {
6645 case 0x00:
6646 goto op_semantics_41;
6647 break;
6648 }
6649 break;
6650 case 0xe3:
6651 GETBYTE ();
6652 switch (op[1] & 0x00)
6653 {
6654 case 0x00:
6655 goto op_semantics_41;
6656 break;
6657 }
6658 break;
6659 case 0xe4:
6660 GETBYTE ();
6661 switch (op[1] & 0x00)
6662 {
6663 case 0x00:
6664 goto op_semantics_41;
6665 break;
6666 }
6667 break;
6668 case 0xe5:
6669 GETBYTE ();
6670 switch (op[1] & 0x00)
6671 {
6672 case 0x00:
6673 goto op_semantics_41;
6674 break;
6675 }
6676 break;
6677 case 0xe6:
6678 GETBYTE ();
6679 switch (op[1] & 0x00)
6680 {
6681 case 0x00:
6682 goto op_semantics_41;
6683 break;
6684 }
6685 break;
6686 case 0xe7:
6687 GETBYTE ();
6688 switch (op[1] & 0x00)
6689 {
6690 case 0x00:
6691 goto op_semantics_41;
6692 break;
6693 }
6694 break;
6695 case 0xe8:
6696 GETBYTE ();
6697 switch (op[1] & 0x00)
6698 {
6699 case 0x00:
6700 goto op_semantics_41;
6701 break;
6702 }
6703 break;
6704 case 0xe9:
6705 GETBYTE ();
6706 switch (op[1] & 0x00)
6707 {
6708 case 0x00:
6709 goto op_semantics_41;
6710 break;
6711 }
6712 break;
6713 case 0xea:
6714 GETBYTE ();
6715 switch (op[1] & 0x00)
6716 {
6717 case 0x00:
6718 goto op_semantics_41;
6719 break;
6720 }
6721 break;
6722 case 0xeb:
6723 GETBYTE ();
6724 switch (op[1] & 0x00)
6725 {
6726 case 0x00:
6727 goto op_semantics_41;
6728 break;
6729 }
6730 break;
6731 case 0xec:
6732 GETBYTE ();
6733 switch (op[1] & 0x00)
6734 {
6735 case 0x00:
6736 goto op_semantics_41;
6737 break;
6738 }
6739 break;
6740 case 0xed:
6741 GETBYTE ();
6742 switch (op[1] & 0x00)
6743 {
6744 case 0x00:
6745 goto op_semantics_41;
6746 break;
6747 }
6748 break;
6749 case 0xee:
6750 GETBYTE ();
6751 switch (op[1] & 0x00)
6752 {
6753 case 0x00:
6754 goto op_semantics_41;
6755 break;
6756 }
6757 break;
6758 case 0xef:
6759 GETBYTE ();
6760 switch (op[1] & 0x00)
6761 {
6762 case 0x00:
6763 goto op_semantics_41;
6764 break;
6765 }
6766 break;
6767 case 0xf0:
6768 GETBYTE ();
6769 switch (op[1] & 0x08)
6770 {
6771 case 0x00:
6772 op_semantics_42:
6773 {
6774 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
f9c7014e 6775#line 859 "rx-decode.opc"
c7927a3c 6776 int sd AU = op[0] & 0x03;
f9c7014e 6777#line 859 "rx-decode.opc"
c7927a3c 6778 int rdst AU = (op[1] >> 4) & 0x0f;
f9c7014e 6779#line 859 "rx-decode.opc"
c7927a3c
NC		 6780 int bit AU = op[1] & 0x07;
6781 if (trace)
6782 {
6783 printf ("\033[33m%s\033[0m %02x %02x\n",
6784 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6785 op[0], op[1]);
6786 printf (" sd = 0x%x,", sd);
6787 printf (" rdst = 0x%x,", rdst);
6788 printf (" bit = 0x%x\n", bit);
6789 }
6790 SYNTAX("bset #%1, %0%S0");
f9c7014e 6791#line 859 "rx-decode.opc"
3cf79a01 6792 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 6793
6794 }
6795 break;
6796 case 0x08:
6797 op_semantics_43:
6798 {
6799 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
f9c7014e 6800#line 869 "rx-decode.opc"
c7927a3c 6801 int sd AU = op[0] & 0x03;
f9c7014e 6802#line 869 "rx-decode.opc"
c7927a3c 6803 int rdst AU = (op[1] >> 4) & 0x0f;
f9c7014e 6804#line 869 "rx-decode.opc"
c7927a3c
NC		 6805 int bit AU = op[1] & 0x07;
6806 if (trace)
6807 {
6808 printf ("\033[33m%s\033[0m %02x %02x\n",
6809 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6810 op[0], op[1]);
6811 printf (" sd = 0x%x,", sd);
6812 printf (" rdst = 0x%x,", rdst);
6813 printf (" bit = 0x%x\n", bit);
6814 }
6815 SYNTAX("bclr #%1, %0%S0");
f9c7014e 6816#line 869 "rx-decode.opc"
3cf79a01 6817 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 6818
6819 }
6820 break;
6821 }
6822 break;
6823 case 0xf1:
6824 GETBYTE ();
6825 switch (op[1] & 0x08)
6826 {
6827 case 0x00:
6828 goto op_semantics_42;
6829 break;
6830 case 0x08:
6831 goto op_semantics_43;
6832 break;
6833 }
6834 break;
6835 case 0xf2:
6836 GETBYTE ();
6837 switch (op[1] & 0x08)
6838 {
6839 case 0x00:
6840 goto op_semantics_42;
6841 break;
6842 case 0x08:
6843 goto op_semantics_43;
6844 break;
6845 }
6846 break;
6847 case 0xf3:
6848 GETBYTE ();
6849 switch (op[1] & 0x08)
6850 {
6851 case 0x00:
6852 goto op_semantics_42;
6853 break;
6854 case 0x08:
6855 goto op_semantics_43;
6856 break;
6857 }
6858 break;
6859 case 0xf4:
6860 GETBYTE ();
6861 switch (op[1] & 0x0c)
6862 {
6863 case 0x00:
6864 case 0x04:
6865 op_semantics_44:
6866 {
6867 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
f9c7014e 6868#line 879 "rx-decode.opc"
c7927a3c 6869 int sd AU = op[0] & 0x03;
f9c7014e 6870#line 879 "rx-decode.opc"
c7927a3c 6871 int rdst AU = (op[1] >> 4) & 0x0f;
f9c7014e 6872#line 879 "rx-decode.opc"
c7927a3c
NC		 6873 int bit AU = op[1] & 0x07;
6874 if (trace)
6875 {
6876 printf ("\033[33m%s\033[0m %02x %02x\n",
6877 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6878 op[0], op[1]);
6879 printf (" sd = 0x%x,", sd);
6880 printf (" rdst = 0x%x,", rdst);
6881 printf (" bit = 0x%x\n", bit);
6882 }
6883 SYNTAX("btst #%2, %1%S1");
f9c7014e 6884#line 879 "rx-decode.opc"
3cf79a01 6885 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
c7927a3c
NC		 6886
6887 }
6888 break;
6889 case 0x08:
6890 op_semantics_45:
6891 {
6892 /** 1111 01ss rsrc 10sz push%s %1 */
f9c7014e 6893#line 340 "rx-decode.opc"
c7927a3c 6894 int ss AU = op[0] & 0x03;
f9c7014e 6895#line 340 "rx-decode.opc"
c7927a3c 6896 int rsrc AU = (op[1] >> 4) & 0x0f;
f9c7014e 6897#line 340 "rx-decode.opc"
c7927a3c
NC		 6898 int sz AU = op[1] & 0x03;
6899 if (trace)
6900 {
6901 printf ("\033[33m%s\033[0m %02x %02x\n",
6902 "/** 1111 01ss rsrc 10sz push%s %1 */",
6903 op[0], op[1]);
6904 printf (" ss = 0x%x,", ss);
6905 printf (" rsrc = 0x%x,", rsrc);
6906 printf (" sz = 0x%x\n", sz);
6907 }
6908 SYNTAX("push%s %1");
f9c7014e 6909#line 340 "rx-decode.opc"
3cf79a01 6910 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
c7927a3c
NC		 6911
6912 /*----------------------------------------------------------------------*/
6913 /* XCHG */
6914
6915 }
6916 break;
6917 default: UNSUPPORTED(); break;
6918 }
6919 break;
6920 case 0xf5:
6921 GETBYTE ();
6922 switch (op[1] & 0x0c)
6923 {
6924 case 0x00:
6925 case 0x04:
6926 goto op_semantics_44;
6927 break;
6928 case 0x08:
6929 goto op_semantics_45;
6930 break;
6931 default: UNSUPPORTED(); break;
6932 }
6933 break;
6934 case 0xf6:
6935 GETBYTE ();
6936 switch (op[1] & 0x0c)
6937 {
6938 case 0x00:
6939 case 0x04:
6940 goto op_semantics_44;
6941 break;
6942 case 0x08:
6943 goto op_semantics_45;
6944 break;
6945 default: UNSUPPORTED(); break;
6946 }
6947 break;
6948 case 0xf7:
6949 GETBYTE ();
6950 switch (op[1] & 0x0c)
6951 {
6952 case 0x00:
6953 case 0x04:
6954 goto op_semantics_44;
6955 break;
6956 case 0x08:
6957 goto op_semantics_45;
6958 break;
6959 default: UNSUPPORTED(); break;
6960 }
6961 break;
6962 case 0xf8:
6963 GETBYTE ();
6964 switch (op[1] & 0x00)
6965 {
6966 case 0x00:
6967 op_semantics_46:
6968 {
6969 /** 1111 10sd rdst im sz mov%s #%1, %0 */
f9c7014e 6970#line 265 "rx-decode.opc"
c7927a3c 6971 int sd AU = op[0] & 0x03;
f9c7014e 6972#line 265 "rx-decode.opc"
c7927a3c 6973 int rdst AU = (op[1] >> 4) & 0x0f;
f9c7014e 6974#line 265 "rx-decode.opc"
c7927a3c 6975 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 6976#line 265 "rx-decode.opc"
c7927a3c
NC		 6977 int sz AU = op[1] & 0x03;
6978 if (trace)
6979 {
6980 printf ("\033[33m%s\033[0m %02x %02x\n",
6981 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
6982 op[0], op[1]);
6983 printf (" sd = 0x%x,", sd);
6984 printf (" rdst = 0x%x,", rdst);
6985 printf (" im = 0x%x,", im);
6986 printf (" sz = 0x%x\n", sz);
6987 }
6988 SYNTAX("mov%s #%1, %0");
f9c7014e 6989#line 265 "rx-decode.opc"
3cf79a01 6990 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F_____;
c7927a3c
NC		 6991
6992 }
6993 break;
6994 }
6995 break;
6996 case 0xf9:
6997 GETBYTE ();
6998 switch (op[1] & 0x00)
6999 {
7000 case 0x00:
7001 goto op_semantics_46;
7002 break;
7003 }
7004 break;
7005 case 0xfa:
7006 GETBYTE ();
7007 switch (op[1] & 0x00)
7008 {
7009 case 0x00:
7010 goto op_semantics_46;
7011 break;
7012 }
7013 break;
7014 case 0xfb:
7015 GETBYTE ();
7016 switch (op[1] & 0x00)
7017 {
7018 case 0x00:
7019 goto op_semantics_46;
7020 break;
7021 }
7022 break;
7023 case 0xfc:
7024 GETBYTE ();
7025 switch (op[1] & 0xff)
7026 {
7027 case 0x03:
7028 GETBYTE ();
7029 switch (op[2] & 0x00)
7030 {
7031 case 0x00:
7032 {
7033 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
f9c7014e 7034#line 514 "rx-decode.opc"
c7927a3c 7035 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7036#line 514 "rx-decode.opc"
c7927a3c
NC		 7037 int rdst AU = op[2] & 0x0f;
7038 if (trace)
7039 {
7040 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7041 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7042 op[0], op[1], op[2]);
7043 printf (" rsrc = 0x%x,", rsrc);
7044 printf (" rdst = 0x%x\n", rdst);
7045 }
7046 SYNTAX("sbb %1, %0");
f9c7014e 7047#line 514 "rx-decode.opc"
3cf79a01 7048 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 7049
7050 /* FIXME: only supports .L */
7051 }
7052 break;
7053 }
7054 break;
7055 case 0x07:
7056 GETBYTE ();
7057 switch (op[2] & 0x00)
7058 {
7059 case 0x00:
7060 {
7061 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
f9c7014e 7062#line 445 "rx-decode.opc"
c7927a3c 7063 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7064#line 445 "rx-decode.opc"
c7927a3c
NC		 7065 int rdst AU = op[2] & 0x0f;
7066 if (trace)
7067 {
7068 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7069 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7070 op[0], op[1], op[2]);
7071 printf (" rsrc = 0x%x,", rsrc);
7072 printf (" rdst = 0x%x\n", rdst);
7073 }
7074 SYNTAX("neg %2, %0");
f9c7014e 7075#line 445 "rx-decode.opc"
3cf79a01 7076 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
c7927a3c
NC		 7077
7078 /*----------------------------------------------------------------------*/
7079 /* ADC */
7080
7081 }
7082 break;
7083 }
7084 break;
7085 case 0x0b:
7086 GETBYTE ();
7087 switch (op[2] & 0x00)
7088 {
7089 case 0x00:
7090 {
7091 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
f9c7014e 7092#line 454 "rx-decode.opc"
c7927a3c 7093 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7094#line 454 "rx-decode.opc"
c7927a3c
NC		 7095 int rdst AU = op[2] & 0x0f;
7096 if (trace)
7097 {
7098 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7099 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7100 op[0], op[1], op[2]);
7101 printf (" rsrc = 0x%x,", rsrc);
7102 printf (" rdst = 0x%x\n", rdst);
7103 }
7104 SYNTAX("adc %1, %0");
f9c7014e 7105#line 454 "rx-decode.opc"
3cf79a01 7106 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 7107
7108 }
7109 break;
7110 }
7111 break;
7112 case 0x0f:
7113 GETBYTE ();
7114 switch (op[2] & 0x00)
7115 {
7116 case 0x00:
7117 {
7118 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
f9c7014e 7119#line 527 "rx-decode.opc"
c7927a3c 7120 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7121#line 527 "rx-decode.opc"
c7927a3c
NC		 7122 int rdst AU = op[2] & 0x0f;
7123 if (trace)
7124 {
7125 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7126 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7127 op[0], op[1], op[2]);
7128 printf (" rsrc = 0x%x,", rsrc);
7129 printf (" rdst = 0x%x\n", rdst);
7130 }
7131 SYNTAX("abs %1, %0");
f9c7014e 7132#line 527 "rx-decode.opc"
3cf79a01 7133 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
c7927a3c
NC		 7134
7135 /*----------------------------------------------------------------------*/
7136 /* MAX */
7137
7138 }
7139 break;
7140 }
7141 break;
7142 case 0x10:
7143 GETBYTE ();
7144 switch (op[2] & 0x00)
7145 {
7146 case 0x00:
7147 op_semantics_47:
7148 {
7149 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
f9c7014e 7150#line 536 "rx-decode.opc"
c7927a3c 7151 int ss AU = op[1] & 0x03;
f9c7014e 7152#line 536 "rx-decode.opc"
c7927a3c 7153 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7154#line 536 "rx-decode.opc"
c7927a3c
NC		 7155 int rdst AU = op[2] & 0x0f;
7156 if (trace)
7157 {
7158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7159 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7160 op[0], op[1], op[2]);
7161 printf (" ss = 0x%x,", ss);
7162 printf (" rsrc = 0x%x,", rsrc);
7163 printf (" rdst = 0x%x\n", rdst);
7164 }
7165 SYNTAX("max %1%S1, %0");
f9c7014e
DD		 7166#line 536 "rx-decode.opc"
7167 if (ss == 3 && rsrc == 0 && rdst == 0)
7168 {
7169 ID(nop3);
7170 }
7171 else
7172 {
7173 ID(max); SP(ss, rsrc); DR(rdst);
7174 }
c7927a3c
NC		 7175
7176 }
7177 break;
7178 }
7179 break;
7180 case 0x11:
7181 GETBYTE ();
7182 switch (op[2] & 0x00)
7183 {
7184 case 0x00:
7185 goto op_semantics_47;
7186 break;
7187 }
7188 break;
7189 case 0x12:
7190 GETBYTE ();
7191 switch (op[2] & 0x00)
7192 {
7193 case 0x00:
7194 goto op_semantics_47;
7195 break;
7196 }
7197 break;
7198 case 0x13:
7199 GETBYTE ();
7200 switch (op[2] & 0x00)
7201 {
7202 case 0x00:
7203 goto op_semantics_47;
7204 break;
7205 }
7206 break;
7207 case 0x14:
7208 GETBYTE ();
7209 switch (op[2] & 0x00)
7210 {
7211 case 0x00:
7212 op_semantics_48:
7213 {
7214 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
f9c7014e 7215#line 555 "rx-decode.opc"
c7927a3c 7216 int ss AU = op[1] & 0x03;
f9c7014e 7217#line 555 "rx-decode.opc"
c7927a3c 7218 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7219#line 555 "rx-decode.opc"
c7927a3c
NC		 7220 int rdst AU = op[2] & 0x0f;
7221 if (trace)
7222 {
7223 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7224 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7225 op[0], op[1], op[2]);
7226 printf (" ss = 0x%x,", ss);
7227 printf (" rsrc = 0x%x,", rsrc);
7228 printf (" rdst = 0x%x\n", rdst);
7229 }
7230 SYNTAX("min %1%S1, %0");
f9c7014e 7231#line 555 "rx-decode.opc"
c7927a3c
NC		 7232 ID(min); SP(ss, rsrc); DR(rdst);
7233
7234 }
7235 break;
7236 }
7237 break;
7238 case 0x15:
7239 GETBYTE ();
7240 switch (op[2] & 0x00)
7241 {
7242 case 0x00:
7243 goto op_semantics_48;
7244 break;
7245 }
7246 break;
7247 case 0x16:
7248 GETBYTE ();
7249 switch (op[2] & 0x00)
7250 {
7251 case 0x00:
7252 goto op_semantics_48;
7253 break;
7254 }
7255 break;
7256 case 0x17:
7257 GETBYTE ();
7258 switch (op[2] & 0x00)
7259 {
7260 case 0x00:
7261 goto op_semantics_48;
7262 break;
7263 }
7264 break;
7265 case 0x18:
7266 GETBYTE ();
7267 switch (op[2] & 0x00)
7268 {
7269 case 0x00:
7270 op_semantics_49:
7271 {
7272 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
f9c7014e 7273#line 585 "rx-decode.opc"
c7927a3c 7274 int ss AU = op[1] & 0x03;
f9c7014e 7275#line 585 "rx-decode.opc"
c7927a3c 7276 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7277#line 585 "rx-decode.opc"
c7927a3c
NC		 7278 int rdst AU = op[2] & 0x0f;
7279 if (trace)
7280 {
7281 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7282 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7283 op[0], op[1], op[2]);
7284 printf (" ss = 0x%x,", ss);
7285 printf (" rsrc = 0x%x,", rsrc);
7286 printf (" rdst = 0x%x\n", rdst);
7287 }
7288 SYNTAX("emul %1%S1, %0");
f9c7014e 7289#line 585 "rx-decode.opc"
c7927a3c
NC		 7290 ID(emul); SP(ss, rsrc); DR(rdst);
7291
7292 }
7293 break;
7294 }
7295 break;
7296 case 0x19:
7297 GETBYTE ();
7298 switch (op[2] & 0x00)
7299 {
7300 case 0x00:
7301 goto op_semantics_49;
7302 break;
7303 }
7304 break;
7305 case 0x1a:
7306 GETBYTE ();
7307 switch (op[2] & 0x00)
7308 {
7309 case 0x00:
7310 goto op_semantics_49;
7311 break;
7312 }
7313 break;
7314 case 0x1b:
7315 GETBYTE ();
7316 switch (op[2] & 0x00)
7317 {
7318 case 0x00:
7319 goto op_semantics_49;
7320 break;
7321 }
7322 break;
7323 case 0x1c:
7324 GETBYTE ();
7325 switch (op[2] & 0x00)
7326 {
7327 case 0x00:
7328 op_semantics_50:
7329 {
7330 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
f9c7014e 7331#line 597 "rx-decode.opc"
c7927a3c 7332 int ss AU = op[1] & 0x03;
f9c7014e 7333#line 597 "rx-decode.opc"
c7927a3c 7334 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7335#line 597 "rx-decode.opc"
c7927a3c
NC		 7336 int rdst AU = op[2] & 0x0f;
7337 if (trace)
7338 {
7339 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7340 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7341 op[0], op[1], op[2]);
7342 printf (" ss = 0x%x,", ss);
7343 printf (" rsrc = 0x%x,", rsrc);
7344 printf (" rdst = 0x%x\n", rdst);
7345 }
7346 SYNTAX("emulu %1%S1, %0");
f9c7014e 7347#line 597 "rx-decode.opc"
c7927a3c
NC		 7348 ID(emulu); SP(ss, rsrc); DR(rdst);
7349
7350 }
7351 break;
7352 }
7353 break;
7354 case 0x1d:
7355 GETBYTE ();
7356 switch (op[2] & 0x00)
7357 {
7358 case 0x00:
7359 goto op_semantics_50;
7360 break;
7361 }
7362 break;
7363 case 0x1e:
7364 GETBYTE ();
7365 switch (op[2] & 0x00)
7366 {
7367 case 0x00:
7368 goto op_semantics_50;
7369 break;
7370 }
7371 break;
7372 case 0x1f:
7373 GETBYTE ();
7374 switch (op[2] & 0x00)
7375 {
7376 case 0x00:
7377 goto op_semantics_50;
7378 break;
7379 }
7380 break;
7381 case 0x20:
7382 GETBYTE ();
7383 switch (op[2] & 0x00)
7384 {
7385 case 0x00:
7386 op_semantics_51:
7387 {
7388 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
f9c7014e 7389#line 609 "rx-decode.opc"
c7927a3c 7390 int ss AU = op[1] & 0x03;
f9c7014e 7391#line 609 "rx-decode.opc"
c7927a3c 7392 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7393#line 609 "rx-decode.opc"
c7927a3c
NC		 7394 int rdst AU = op[2] & 0x0f;
7395 if (trace)
7396 {
7397 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7398 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7399 op[0], op[1], op[2]);
7400 printf (" ss = 0x%x,", ss);
7401 printf (" rsrc = 0x%x,", rsrc);
7402 printf (" rdst = 0x%x\n", rdst);
7403 }
7404 SYNTAX("div %1%S1, %0");
f9c7014e 7405#line 609 "rx-decode.opc"
3cf79a01 7406 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
c7927a3c
NC		 7407
7408 }
7409 break;
7410 }
7411 break;
7412 case 0x21:
7413 GETBYTE ();
7414 switch (op[2] & 0x00)
7415 {
7416 case 0x00:
7417 goto op_semantics_51;
7418 break;
7419 }
7420 break;
7421 case 0x22:
7422 GETBYTE ();
7423 switch (op[2] & 0x00)
7424 {
7425 case 0x00:
7426 goto op_semantics_51;
7427 break;
7428 }
7429 break;
7430 case 0x23:
7431 GETBYTE ();
7432 switch (op[2] & 0x00)
7433 {
7434 case 0x00:
7435 goto op_semantics_51;
7436 break;
7437 }
7438 break;
7439 case 0x24:
7440 GETBYTE ();
7441 switch (op[2] & 0x00)
7442 {
7443 case 0x00:
7444 op_semantics_52:
7445 {
7446 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
f9c7014e 7447#line 621 "rx-decode.opc"
c7927a3c 7448 int ss AU = op[1] & 0x03;
f9c7014e 7449#line 621 "rx-decode.opc"
c7927a3c 7450 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7451#line 621 "rx-decode.opc"
c7927a3c
NC		 7452 int rdst AU = op[2] & 0x0f;
7453 if (trace)
7454 {
7455 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7456 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7457 op[0], op[1], op[2]);
7458 printf (" ss = 0x%x,", ss);
7459 printf (" rsrc = 0x%x,", rsrc);
7460 printf (" rdst = 0x%x\n", rdst);
7461 }
7462 SYNTAX("divu %1%S1, %0");
f9c7014e 7463#line 621 "rx-decode.opc"
3cf79a01 7464 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
c7927a3c
NC		 7465
7466 }
7467 break;
7468 }
7469 break;
7470 case 0x25:
7471 GETBYTE ();
7472 switch (op[2] & 0x00)
7473 {
7474 case 0x00:
7475 goto op_semantics_52;
7476 break;
7477 }
7478 break;
7479 case 0x26:
7480 GETBYTE ();
7481 switch (op[2] & 0x00)
7482 {
7483 case 0x00:
7484 goto op_semantics_52;
7485 break;
7486 }
7487 break;
7488 case 0x27:
7489 GETBYTE ();
7490 switch (op[2] & 0x00)
7491 {
7492 case 0x00:
7493 goto op_semantics_52;
7494 break;
7495 }
7496 break;
7497 case 0x30:
7498 GETBYTE ();
7499 switch (op[2] & 0x00)
7500 {
7501 case 0x00:
7502 op_semantics_53:
7503 {
7504 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
f9c7014e 7505#line 433 "rx-decode.opc"
c7927a3c 7506 int ss AU = op[1] & 0x03;
f9c7014e 7507#line 433 "rx-decode.opc"
c7927a3c 7508 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7509#line 433 "rx-decode.opc"
c7927a3c
NC		 7510 int rdst AU = op[2] & 0x0f;
7511 if (trace)
7512 {
7513 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7514 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7515 op[0], op[1], op[2]);
7516 printf (" ss = 0x%x,", ss);
7517 printf (" rsrc = 0x%x,", rsrc);
7518 printf (" rdst = 0x%x\n", rdst);
7519 }
7520 SYNTAX("tst %1%S1, %2");
f9c7014e 7521#line 433 "rx-decode.opc"
3cf79a01 7522 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
c7927a3c
NC		 7523
7524 }
7525 break;
7526 }
7527 break;
7528 case 0x31:
7529 GETBYTE ();
7530 switch (op[2] & 0x00)
7531 {
7532 case 0x00:
7533 goto op_semantics_53;
7534 break;
7535 }
7536 break;
7537 case 0x32:
7538 GETBYTE ();
7539 switch (op[2] & 0x00)
7540 {
7541 case 0x00:
7542 goto op_semantics_53;
7543 break;
7544 }
7545 break;
7546 case 0x33:
7547 GETBYTE ();
7548 switch (op[2] & 0x00)
7549 {
7550 case 0x00:
7551 goto op_semantics_53;
7552 break;
7553 }
7554 break;
7555 case 0x34:
7556 GETBYTE ();
7557 switch (op[2] & 0x00)
7558 {
7559 case 0x00:
7560 op_semantics_54:
7561 {
7562 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
f9c7014e 7563#line 412 "rx-decode.opc"
c7927a3c 7564 int ss AU = op[1] & 0x03;
f9c7014e 7565#line 412 "rx-decode.opc"
c7927a3c 7566 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7567#line 412 "rx-decode.opc"
c7927a3c
NC		 7568 int rdst AU = op[2] & 0x0f;
7569 if (trace)
7570 {
7571 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7572 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7573 op[0], op[1], op[2]);
7574 printf (" ss = 0x%x,", ss);
7575 printf (" rsrc = 0x%x,", rsrc);
7576 printf (" rdst = 0x%x\n", rdst);
7577 }
7578 SYNTAX("xor %1%S1, %0");
f9c7014e 7579#line 412 "rx-decode.opc"
3cf79a01 7580 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
c7927a3c
NC		 7581
7582 }
7583 break;
7584 }
7585 break;
7586 case 0x35:
7587 GETBYTE ();
7588 switch (op[2] & 0x00)
7589 {
7590 case 0x00:
7591 goto op_semantics_54;
7592 break;
7593 }
7594 break;
7595 case 0x36:
7596 GETBYTE ();
7597 switch (op[2] & 0x00)
7598 {
7599 case 0x00:
7600 goto op_semantics_54;
7601 break;
7602 }
7603 break;
7604 case 0x37:
7605 GETBYTE ();
7606 switch (op[2] & 0x00)
7607 {
7608 case 0x00:
7609 goto op_semantics_54;
7610 break;
7611 }
7612 break;
7613 case 0x3b:
7614 GETBYTE ();
7615 switch (op[2] & 0x00)
7616 {
7617 case 0x00:
7618 {
7619 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
f9c7014e 7620#line 424 "rx-decode.opc"
c7927a3c 7621 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7622#line 424 "rx-decode.opc"
c7927a3c
NC		 7623 int rdst AU = op[2] & 0x0f;
7624 if (trace)
7625 {
7626 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7627 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7628 op[0], op[1], op[2]);
7629 printf (" rsrc = 0x%x,", rsrc);
7630 printf (" rdst = 0x%x\n", rdst);
7631 }
7632 SYNTAX("not %1, %0");
f9c7014e 7633#line 424 "rx-decode.opc"
3cf79a01 7634 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
c7927a3c
NC		 7635
7636 /*----------------------------------------------------------------------*/
7637 /* TST */
7638
7639 }
7640 break;
7641 }
7642 break;
7643 case 0x40:
7644 GETBYTE ();
7645 switch (op[2] & 0x00)
7646 {
7647 case 0x00:
7648 op_semantics_55:
7649 {
7650 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
f9c7014e 7651#line 346 "rx-decode.opc"
c7927a3c 7652 int ss AU = op[1] & 0x03;
f9c7014e 7653#line 346 "rx-decode.opc"
c7927a3c 7654 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7655#line 346 "rx-decode.opc"
c7927a3c
NC		 7656 int rdst AU = op[2] & 0x0f;
7657 if (trace)
7658 {
7659 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7660 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7661 op[0], op[1], op[2]);
7662 printf (" ss = 0x%x,", ss);
7663 printf (" rsrc = 0x%x,", rsrc);
7664 printf (" rdst = 0x%x\n", rdst);
7665 }
7666 SYNTAX("xchg %1%S1, %0");
f9c7014e 7667#line 346 "rx-decode.opc"
c7927a3c
NC		 7668 ID(xchg); DR(rdst); SP(ss, rsrc);
7669
7670 }
7671 break;
7672 }
7673 break;
7674 case 0x41:
7675 GETBYTE ();
7676 switch (op[2] & 0x00)
7677 {
7678 case 0x00:
7679 goto op_semantics_55;
7680 break;
7681 }
7682 break;
7683 case 0x42:
7684 GETBYTE ();
7685 switch (op[2] & 0x00)
7686 {
7687 case 0x00:
7688 goto op_semantics_55;
7689 break;
7690 }
7691 break;
7692 case 0x43:
7693 GETBYTE ();
7694 switch (op[2] & 0x00)
7695 {
7696 case 0x00:
7697 goto op_semantics_55;
7698 break;
7699 }
7700 break;
7701 case 0x44:
7702 GETBYTE ();
7703 switch (op[2] & 0x00)
7704 {
7705 case 0x00:
7706 op_semantics_56:
7707 {
7708 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
f9c7014e 7709#line 850 "rx-decode.opc"
c7927a3c 7710 int sd AU = op[1] & 0x03;
f9c7014e 7711#line 850 "rx-decode.opc"
c7927a3c 7712 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 7713#line 850 "rx-decode.opc"
c7927a3c
NC		 7714 int rdst AU = op[2] & 0x0f;
7715 if (trace)
7716 {
7717 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7718 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7719 op[0], op[1], op[2]);
7720 printf (" sd = 0x%x,", sd);
7721 printf (" rsrc = 0x%x,", rsrc);
7722 printf (" rdst = 0x%x\n", rdst);
7723 }
7724 SYNTAX("itof %1%S1, %0");
f9c7014e 7725#line 850 "rx-decode.opc"
3cf79a01 7726 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
c7927a3c
NC		 7727
7728 }
7729 break;
7730 }
7731 break;
7732 case 0x45:
7733 GETBYTE ();
7734 switch (op[2] & 0x00)
7735 {
7736 case 0x00:
7737 goto op_semantics_56;
7738 break;
7739 }
7740 break;
7741 case 0x46:
7742 GETBYTE ();
7743 switch (op[2] & 0x00)
7744 {
7745 case 0x00:
7746 goto op_semantics_56;
7747 break;
7748 }
7749 break;
7750 case 0x47:
7751 GETBYTE ();
7752 switch (op[2] & 0x00)
7753 {
7754 case 0x00:
7755 goto op_semantics_56;
7756 break;
7757 }
7758 break;
7759 case 0x60:
7760 GETBYTE ();
7761 switch (op[2] & 0x00)
7762 {
7763 case 0x00:
7764 op_semantics_57:
7765 {
7766 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
f9c7014e 7767#line 862 "rx-decode.opc"
c7927a3c 7768 int sd AU = op[1] & 0x03;
f9c7014e 7769#line 862 "rx-decode.opc"
c7927a3c 7770 int rdst AU = (op[2] >> 4) & 0x0f;
f9c7014e 7771#line 862 "rx-decode.opc"
c7927a3c
NC		 7772 int rsrc AU = op[2] & 0x0f;
7773 if (trace)
7774 {
7775 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7776 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7777 op[0], op[1], op[2]);
7778 printf (" sd = 0x%x,", sd);
7779 printf (" rdst = 0x%x,", rdst);
7780 printf (" rsrc = 0x%x\n", rsrc);
7781 }
7782 SYNTAX("bset %1, %0%S0");
f9c7014e 7783#line 862 "rx-decode.opc"
3cf79a01 7784 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 7785
7786 }
7787 break;
7788 }
7789 break;
7790 case 0x61:
7791 GETBYTE ();
7792 switch (op[2] & 0x00)
7793 {
7794 case 0x00:
7795 goto op_semantics_57;
7796 break;
7797 }
7798 break;
7799 case 0x62:
7800 GETBYTE ();
7801 switch (op[2] & 0x00)
7802 {
7803 case 0x00:
7804 goto op_semantics_57;
7805 break;
7806 }
7807 break;
7808 case 0x63:
7809 GETBYTE ();
7810 switch (op[2] & 0x00)
7811 {
7812 case 0x00:
7813 goto op_semantics_57;
7814 break;
7815 }
7816 break;
7817 case 0x64:
7818 GETBYTE ();
7819 switch (op[2] & 0x00)
7820 {
7821 case 0x00:
7822 op_semantics_58:
7823 {
7824 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
f9c7014e 7825#line 872 "rx-decode.opc"
c7927a3c 7826 int sd AU = op[1] & 0x03;
f9c7014e 7827#line 872 "rx-decode.opc"
c7927a3c 7828 int rdst AU = (op[2] >> 4) & 0x0f;
f9c7014e 7829#line 872 "rx-decode.opc"
c7927a3c
NC		 7830 int rsrc AU = op[2] & 0x0f;
7831 if (trace)
7832 {
7833 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7834 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7835 op[0], op[1], op[2]);
7836 printf (" sd = 0x%x,", sd);
7837 printf (" rdst = 0x%x,", rdst);
7838 printf (" rsrc = 0x%x\n", rsrc);
7839 }
7840 SYNTAX("bclr %1, %0%S0");
f9c7014e 7841#line 872 "rx-decode.opc"
3cf79a01 7842 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 7843
7844 }
7845 break;
7846 }
7847 break;
7848 case 0x65:
7849 GETBYTE ();
7850 switch (op[2] & 0x00)
7851 {
7852 case 0x00:
7853 goto op_semantics_58;
7854 break;
7855 }
7856 break;
7857 case 0x66:
7858 GETBYTE ();
7859 switch (op[2] & 0x00)
7860 {
7861 case 0x00:
7862 goto op_semantics_58;
7863 break;
7864 }
7865 break;
7866 case 0x67:
7867 GETBYTE ();
7868 switch (op[2] & 0x00)
7869 {
7870 case 0x00:
7871 goto op_semantics_58;
7872 break;
7873 }
7874 break;
7875 case 0x68:
7876 GETBYTE ();
7877 switch (op[2] & 0x00)
7878 {
7879 case 0x00:
7880 op_semantics_59:
7881 {
7882 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
f9c7014e 7883#line 882 "rx-decode.opc"
c7927a3c 7884 int sd AU = op[1] & 0x03;
f9c7014e 7885#line 882 "rx-decode.opc"
c7927a3c 7886 int rdst AU = (op[2] >> 4) & 0x0f;
f9c7014e 7887#line 882 "rx-decode.opc"
c7927a3c
NC		 7888 int rsrc AU = op[2] & 0x0f;
7889 if (trace)
7890 {
7891 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7892 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7893 op[0], op[1], op[2]);
7894 printf (" sd = 0x%x,", sd);
7895 printf (" rdst = 0x%x,", rdst);
7896 printf (" rsrc = 0x%x\n", rsrc);
7897 }
7898 SYNTAX("btst %2, %1%S1");
f9c7014e 7899#line 882 "rx-decode.opc"
3cf79a01 7900 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
c7927a3c
NC		 7901
7902 }
7903 break;
7904 }
7905 break;
7906 case 0x69:
7907 GETBYTE ();
7908 switch (op[2] & 0x00)
7909 {
7910 case 0x00:
7911 goto op_semantics_59;
7912 break;
7913 }
7914 break;
7915 case 0x6a:
7916 GETBYTE ();
7917 switch (op[2] & 0x00)
7918 {
7919 case 0x00:
7920 goto op_semantics_59;
7921 break;
7922 }
7923 break;
7924 case 0x6b:
7925 GETBYTE ();
7926 switch (op[2] & 0x00)
7927 {
7928 case 0x00:
7929 goto op_semantics_59;
7930 break;
7931 }
7932 break;
7933 case 0x6c:
7934 GETBYTE ();
7935 switch (op[2] & 0x00)
7936 {
7937 case 0x00:
7938 op_semantics_60:
7939 {
7940 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
f9c7014e 7941#line 892 "rx-decode.opc"
c7927a3c 7942 int sd AU = op[1] & 0x03;
f9c7014e 7943#line 892 "rx-decode.opc"
c7927a3c 7944 int rdst AU = (op[2] >> 4) & 0x0f;
f9c7014e 7945#line 892 "rx-decode.opc"
c7927a3c
NC		 7946 int rsrc AU = op[2] & 0x0f;
7947 if (trace)
7948 {
7949 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7950 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
7951 op[0], op[1], op[2]);
7952 printf (" sd = 0x%x,", sd);
7953 printf (" rdst = 0x%x,", rdst);
7954 printf (" rsrc = 0x%x\n", rsrc);
7955 }
7956 SYNTAX("bnot %1, %0%S0");
f9c7014e 7957#line 892 "rx-decode.opc"
c7927a3c
NC		 7958 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7959
7960 }
7961 break;
7962 }
7963 break;
7964 case 0x6d:
7965 GETBYTE ();
7966 switch (op[2] & 0x00)
7967 {
7968 case 0x00:
7969 goto op_semantics_60;
7970 break;
7971 }
7972 break;
7973 case 0x6e:
7974 GETBYTE ();
7975 switch (op[2] & 0x00)
7976 {
7977 case 0x00:
7978 goto op_semantics_60;
7979 break;
7980 }
7981 break;
7982 case 0x6f:
7983 GETBYTE ();
7984 switch (op[2] & 0x00)
7985 {
7986 case 0x00:
7987 goto op_semantics_60;
7988 break;
7989 }
7990 break;
7991 case 0x80:
7992 GETBYTE ();
7993 switch (op[2] & 0x00)
7994 {
7995 case 0x00:
7996 op_semantics_61:
7997 {
7998 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
f9c7014e 7999#line 829 "rx-decode.opc"
c7927a3c 8000 int sd AU = op[1] & 0x03;
f9c7014e 8001#line 829 "rx-decode.opc"
c7927a3c 8002 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 8003#line 829 "rx-decode.opc"
c7927a3c
NC		 8004 int rdst AU = op[2] & 0x0f;
8005 if (trace)
8006 {
8007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8008 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8009 op[0], op[1], op[2]);
8010 printf (" sd = 0x%x,", sd);
8011 printf (" rsrc = 0x%x,", rsrc);
8012 printf (" rdst = 0x%x\n", rdst);
8013 }
8014 SYNTAX("fsub %1%S1, %0");
f9c7014e 8015#line 829 "rx-decode.opc"
3cf79a01 8016 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8017
8018 }
8019 break;
8020 }
8021 break;
8022 case 0x81:
8023 GETBYTE ();
8024 switch (op[2] & 0x00)
8025 {
8026 case 0x00:
8027 goto op_semantics_61;
8028 break;
8029 }
8030 break;
8031 case 0x82:
8032 GETBYTE ();
8033 switch (op[2] & 0x00)
8034 {
8035 case 0x00:
8036 goto op_semantics_61;
8037 break;
8038 }
8039 break;
8040 case 0x83:
8041 GETBYTE ();
8042 switch (op[2] & 0x00)
8043 {
8044 case 0x00:
8045 goto op_semantics_61;
8046 break;
8047 }
8048 break;
8049 case 0x84:
8050 GETBYTE ();
8051 switch (op[2] & 0x00)
8052 {
8053 case 0x00:
8054 op_semantics_62:
8055 {
8056 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
f9c7014e 8057#line 823 "rx-decode.opc"
c7927a3c 8058 int sd AU = op[1] & 0x03;
f9c7014e 8059#line 823 "rx-decode.opc"
c7927a3c 8060 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 8061#line 823 "rx-decode.opc"
c7927a3c
NC		 8062 int rdst AU = op[2] & 0x0f;
8063 if (trace)
8064 {
8065 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8066 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8067 op[0], op[1], op[2]);
8068 printf (" sd = 0x%x,", sd);
8069 printf (" rsrc = 0x%x,", rsrc);
8070 printf (" rdst = 0x%x\n", rdst);
8071 }
8072 SYNTAX("fcmp %1%S1, %0");
f9c7014e 8073#line 823 "rx-decode.opc"
3cf79a01 8074 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
c7927a3c
NC		 8075
8076 }
8077 break;
8078 }
8079 break;
8080 case 0x85:
8081 GETBYTE ();
8082 switch (op[2] & 0x00)
8083 {
8084 case 0x00:
8085 goto op_semantics_62;
8086 break;
8087 }
8088 break;
8089 case 0x86:
8090 GETBYTE ();
8091 switch (op[2] & 0x00)
8092 {
8093 case 0x00:
8094 goto op_semantics_62;
8095 break;
8096 }
8097 break;
8098 case 0x87:
8099 GETBYTE ();
8100 switch (op[2] & 0x00)
8101 {
8102 case 0x00:
8103 goto op_semantics_62;
8104 break;
8105 }
8106 break;
8107 case 0x88:
8108 GETBYTE ();
8109 switch (op[2] & 0x00)
8110 {
8111 case 0x00:
8112 op_semantics_63:
8113 {
8114 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
f9c7014e 8115#line 817 "rx-decode.opc"
c7927a3c 8116 int sd AU = op[1] & 0x03;
f9c7014e 8117#line 817 "rx-decode.opc"
c7927a3c 8118 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 8119#line 817 "rx-decode.opc"
c7927a3c
NC		 8120 int rdst AU = op[2] & 0x0f;
8121 if (trace)
8122 {
8123 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8124 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8125 op[0], op[1], op[2]);
8126 printf (" sd = 0x%x,", sd);
8127 printf (" rsrc = 0x%x,", rsrc);
8128 printf (" rdst = 0x%x\n", rdst);
8129 }
8130 SYNTAX("fadd %1%S1, %0");
f9c7014e 8131#line 817 "rx-decode.opc"
3cf79a01 8132 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8133
8134 }
8135 break;
8136 }
8137 break;
8138 case 0x89:
8139 GETBYTE ();
8140 switch (op[2] & 0x00)
8141 {
8142 case 0x00:
8143 goto op_semantics_63;
8144 break;
8145 }
8146 break;
8147 case 0x8a:
8148 GETBYTE ();
8149 switch (op[2] & 0x00)
8150 {
8151 case 0x00:
8152 goto op_semantics_63;
8153 break;
8154 }
8155 break;
8156 case 0x8b:
8157 GETBYTE ();
8158 switch (op[2] & 0x00)
8159 {
8160 case 0x00:
8161 goto op_semantics_63;
8162 break;
8163 }
8164 break;
8165 case 0x8c:
8166 GETBYTE ();
8167 switch (op[2] & 0x00)
8168 {
8169 case 0x00:
8170 op_semantics_64:
8171 {
8172 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
f9c7014e 8173#line 838 "rx-decode.opc"
c7927a3c 8174 int sd AU = op[1] & 0x03;
f9c7014e 8175#line 838 "rx-decode.opc"
c7927a3c 8176 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 8177#line 838 "rx-decode.opc"
c7927a3c
NC		 8178 int rdst AU = op[2] & 0x0f;
8179 if (trace)
8180 {
8181 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8182 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8183 op[0], op[1], op[2]);
8184 printf (" sd = 0x%x,", sd);
8185 printf (" rsrc = 0x%x,", rsrc);
8186 printf (" rdst = 0x%x\n", rdst);
8187 }
8188 SYNTAX("fmul %1%S1, %0");
f9c7014e 8189#line 838 "rx-decode.opc"
3cf79a01 8190 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8191
8192 }
8193 break;
8194 }
8195 break;
8196 case 0x8d:
8197 GETBYTE ();
8198 switch (op[2] & 0x00)
8199 {
8200 case 0x00:
8201 goto op_semantics_64;
8202 break;
8203 }
8204 break;
8205 case 0x8e:
8206 GETBYTE ();
8207 switch (op[2] & 0x00)
8208 {
8209 case 0x00:
8210 goto op_semantics_64;
8211 break;
8212 }
8213 break;
8214 case 0x8f:
8215 GETBYTE ();
8216 switch (op[2] & 0x00)
8217 {
8218 case 0x00:
8219 goto op_semantics_64;
8220 break;
8221 }
8222 break;
8223 case 0x90:
8224 GETBYTE ();
8225 switch (op[2] & 0x00)
8226 {
8227 case 0x00:
8228 op_semantics_65:
8229 {
8230 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
f9c7014e 8231#line 844 "rx-decode.opc"
c7927a3c 8232 int sd AU = op[1] & 0x03;
f9c7014e 8233#line 844 "rx-decode.opc"
c7927a3c 8234 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 8235#line 844 "rx-decode.opc"
c7927a3c
NC		 8236 int rdst AU = op[2] & 0x0f;
8237 if (trace)
8238 {
8239 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8240 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8241 op[0], op[1], op[2]);
8242 printf (" sd = 0x%x,", sd);
8243 printf (" rsrc = 0x%x,", rsrc);
8244 printf (" rdst = 0x%x\n", rdst);
8245 }
8246 SYNTAX("fdiv %1%S1, %0");
f9c7014e 8247#line 844 "rx-decode.opc"
3cf79a01 8248 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8249
8250 }
8251 break;
8252 }
8253 break;
8254 case 0x91:
8255 GETBYTE ();
8256 switch (op[2] & 0x00)
8257 {
8258 case 0x00:
8259 goto op_semantics_65;
8260 break;
8261 }
8262 break;
8263 case 0x92:
8264 GETBYTE ();
8265 switch (op[2] & 0x00)
8266 {
8267 case 0x00:
8268 goto op_semantics_65;
8269 break;
8270 }
8271 break;
8272 case 0x93:
8273 GETBYTE ();
8274 switch (op[2] & 0x00)
8275 {
8276 case 0x00:
8277 goto op_semantics_65;
8278 break;
8279 }
8280 break;
8281 case 0x94:
8282 GETBYTE ();
8283 switch (op[2] & 0x00)
8284 {
8285 case 0x00:
8286 op_semantics_66:
8287 {
8288 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
f9c7014e 8289#line 832 "rx-decode.opc"
c7927a3c 8290 int sd AU = op[1] & 0x03;
f9c7014e 8291#line 832 "rx-decode.opc"
c7927a3c 8292 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 8293#line 832 "rx-decode.opc"
c7927a3c
NC		 8294 int rdst AU = op[2] & 0x0f;
8295 if (trace)
8296 {
8297 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8298 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8299 op[0], op[1], op[2]);
8300 printf (" sd = 0x%x,", sd);
8301 printf (" rsrc = 0x%x,", rsrc);
8302 printf (" rdst = 0x%x\n", rdst);
8303 }
8304 SYNTAX("ftoi %1%S1, %0");
f9c7014e 8305#line 832 "rx-decode.opc"
3cf79a01 8306 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8307
8308 }
8309 break;
8310 }
8311 break;
8312 case 0x95:
8313 GETBYTE ();
8314 switch (op[2] & 0x00)
8315 {
8316 case 0x00:
8317 goto op_semantics_66;
8318 break;
8319 }
8320 break;
8321 case 0x96:
8322 GETBYTE ();
8323 switch (op[2] & 0x00)
8324 {
8325 case 0x00:
8326 goto op_semantics_66;
8327 break;
8328 }
8329 break;
8330 case 0x97:
8331 GETBYTE ();
8332 switch (op[2] & 0x00)
8333 {
8334 case 0x00:
8335 goto op_semantics_66;
8336 break;
8337 }
8338 break;
8339 case 0x98:
8340 GETBYTE ();
8341 switch (op[2] & 0x00)
8342 {
8343 case 0x00:
8344 op_semantics_67:
8345 {
8346 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
f9c7014e 8347#line 847 "rx-decode.opc"
c7927a3c 8348 int sd AU = op[1] & 0x03;
f9c7014e 8349#line 847 "rx-decode.opc"
c7927a3c 8350 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 8351#line 847 "rx-decode.opc"
c7927a3c
NC		 8352 int rdst AU = op[2] & 0x0f;
8353 if (trace)
8354 {
8355 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8356 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8357 op[0], op[1], op[2]);
8358 printf (" sd = 0x%x,", sd);
8359 printf (" rsrc = 0x%x,", rsrc);
8360 printf (" rdst = 0x%x\n", rdst);
8361 }
8362 SYNTAX("round %1%S1, %0");
f9c7014e 8363#line 847 "rx-decode.opc"
3cf79a01 8364 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8365
8366 }
8367 break;
8368 }
8369 break;
8370 case 0x99:
8371 GETBYTE ();
8372 switch (op[2] & 0x00)
8373 {
8374 case 0x00:
8375 goto op_semantics_67;
8376 break;
8377 }
8378 break;
8379 case 0x9a:
8380 GETBYTE ();
8381 switch (op[2] & 0x00)
8382 {
8383 case 0x00:
8384 goto op_semantics_67;
8385 break;
8386 }
8387 break;
8388 case 0x9b:
8389 GETBYTE ();
8390 switch (op[2] & 0x00)
8391 {
8392 case 0x00:
8393 goto op_semantics_67;
8394 break;
8395 }
8396 break;
8397 case 0xd0:
8398 GETBYTE ();
8399 switch (op[2] & 0x00)
8400 {
8401 case 0x00:
8402 op_semantics_68:
8403 {
8404 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
f9c7014e 8405#line 956 "rx-decode.opc"
c7927a3c 8406 int sz AU = (op[1] >> 2) & 0x03;
f9c7014e 8407#line 956 "rx-decode.opc"
c7927a3c 8408 int sd AU = op[1] & 0x03;
f9c7014e 8409#line 956 "rx-decode.opc"
c7927a3c 8410 int rdst AU = (op[2] >> 4) & 0x0f;
f9c7014e 8411#line 956 "rx-decode.opc"
c7927a3c
NC		 8412 int cond AU = op[2] & 0x0f;
8413 if (trace)
8414 {
8415 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8416 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8417 op[0], op[1], op[2]);
8418 printf (" sz = 0x%x,", sz);
8419 printf (" sd = 0x%x,", sd);
8420 printf (" rdst = 0x%x,", rdst);
8421 printf (" cond = 0x%x\n", cond);
8422 }
8423 SYNTAX("sc%1%s %0");
f9c7014e 8424#line 956 "rx-decode.opc"
c7927a3c
NC		 8425 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8426
8427 }
8428 break;
8429 }
8430 break;
8431 case 0xd1:
8432 GETBYTE ();
8433 switch (op[2] & 0x00)
8434 {
8435 case 0x00:
8436 goto op_semantics_68;
8437 break;
8438 }
8439 break;
8440 case 0xd2:
8441 GETBYTE ();
8442 switch (op[2] & 0x00)
8443 {
8444 case 0x00:
8445 goto op_semantics_68;
8446 break;
8447 }
8448 break;
8449 case 0xd3:
8450 GETBYTE ();
8451 switch (op[2] & 0x00)
8452 {
8453 case 0x00:
8454 goto op_semantics_68;
8455 break;
8456 }
8457 break;
8458 case 0xd4:
8459 GETBYTE ();
8460 switch (op[2] & 0x00)
8461 {
8462 case 0x00:
8463 goto op_semantics_68;
8464 break;
8465 }
8466 break;
8467 case 0xd5:
8468 GETBYTE ();
8469 switch (op[2] & 0x00)
8470 {
8471 case 0x00:
8472 goto op_semantics_68;
8473 break;
8474 }
8475 break;
8476 case 0xd6:
8477 GETBYTE ();
8478 switch (op[2] & 0x00)
8479 {
8480 case 0x00:
8481 goto op_semantics_68;
8482 break;
8483 }
8484 break;
8485 case 0xd7:
8486 GETBYTE ();
8487 switch (op[2] & 0x00)
8488 {
8489 case 0x00:
8490 goto op_semantics_68;
8491 break;
8492 }
8493 break;
8494 case 0xd8:
8495 GETBYTE ();
8496 switch (op[2] & 0x00)
8497 {
8498 case 0x00:
8499 goto op_semantics_68;
8500 break;
8501 }
8502 break;
8503 case 0xd9:
8504 GETBYTE ();
8505 switch (op[2] & 0x00)
8506 {
8507 case 0x00:
8508 goto op_semantics_68;
8509 break;
8510 }
8511 break;
8512 case 0xda:
8513 GETBYTE ();
8514 switch (op[2] & 0x00)
8515 {
8516 case 0x00:
8517 goto op_semantics_68;
8518 break;
8519 }
8520 break;
8521 case 0xdb:
8522 GETBYTE ();
8523 switch (op[2] & 0x00)
8524 {
8525 case 0x00:
8526 goto op_semantics_68;
8527 break;
8528 }
8529 break;
8530 case 0xe0:
8531 GETBYTE ();
8532 switch (op[2] & 0x0f)
8533 {
8534 case 0x00:
8535 case 0x01:
8536 case 0x02:
8537 case 0x03:
8538 case 0x04:
8539 case 0x05:
8540 case 0x06:
8541 case 0x07:
8542 case 0x08:
8543 case 0x09:
8544 case 0x0a:
8545 case 0x0b:
8546 case 0x0c:
8547 case 0x0d:
8548 case 0x0e:
8549 op_semantics_69:
8550 {
8551 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
f9c7014e 8552#line 899 "rx-decode.opc"
c7927a3c 8553 int bit AU = (op[1] >> 2) & 0x07;
f9c7014e 8554#line 899 "rx-decode.opc"
c7927a3c 8555 int sd AU = op[1] & 0x03;
f9c7014e 8556#line 899 "rx-decode.opc"
c7927a3c 8557 int rdst AU = (op[2] >> 4) & 0x0f;
f9c7014e 8558#line 899 "rx-decode.opc"
c7927a3c
NC		 8559 int cond AU = op[2] & 0x0f;
8560 if (trace)
8561 {
8562 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8563 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8564 op[0], op[1], op[2]);
8565 printf (" bit = 0x%x,", bit);
8566 printf (" sd = 0x%x,", sd);
8567 printf (" rdst = 0x%x,", rdst);
8568 printf (" cond = 0x%x\n", cond);
8569 }
8570 SYNTAX("bm%2 #%1, %0%S0");
f9c7014e 8571#line 899 "rx-decode.opc"
c7927a3c
NC		 8572 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8573
8574 }
8575 break;
8576 case 0x0f:
8577 op_semantics_70:
8578 {
8579 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
f9c7014e 8580#line 889 "rx-decode.opc"
c7927a3c 8581 int bit AU = (op[1] >> 2) & 0x07;
f9c7014e 8582#line 889 "rx-decode.opc"
c7927a3c 8583 int sd AU = op[1] & 0x03;
f9c7014e 8584#line 889 "rx-decode.opc"
c7927a3c
NC		 8585 int rdst AU = (op[2] >> 4) & 0x0f;
8586 if (trace)
8587 {
8588 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8589 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8590 op[0], op[1], op[2]);
8591 printf (" bit = 0x%x,", bit);
8592 printf (" sd = 0x%x,", sd);
8593 printf (" rdst = 0x%x\n", rdst);
8594 }
8595 SYNTAX("bnot #%1, %0%S0");
f9c7014e 8596#line 889 "rx-decode.opc"
c7927a3c
NC		 8597 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8598
8599 }
8600 break;
8601 }
8602 break;
8603 case 0xe1:
8604 GETBYTE ();
8605 switch (op[2] & 0x0f)
8606 {
8607 case 0x00:
8608 case 0x01:
8609 case 0x02:
8610 case 0x03:
8611 case 0x04:
8612 case 0x05:
8613 case 0x06:
8614 case 0x07:
8615 case 0x08:
8616 case 0x09:
8617 case 0x0a:
8618 case 0x0b:
8619 case 0x0c:
8620 case 0x0d:
8621 case 0x0e:
8622 goto op_semantics_69;
8623 break;
8624 case 0x0f:
8625 goto op_semantics_70;
8626 break;
8627 }
8628 break;
8629 case 0xe2:
8630 GETBYTE ();
8631 switch (op[2] & 0x0f)
8632 {
8633 case 0x00:
8634 case 0x01:
8635 case 0x02:
8636 case 0x03:
8637 case 0x04:
8638 case 0x05:
8639 case 0x06:
8640 case 0x07:
8641 case 0x08:
8642 case 0x09:
8643 case 0x0a:
8644 case 0x0b:
8645 case 0x0c:
8646 case 0x0d:
8647 case 0x0e:
8648 goto op_semantics_69;
8649 break;
8650 case 0x0f:
8651 goto op_semantics_70;
8652 break;
8653 }
8654 break;
8655 case 0xe3:
8656 GETBYTE ();
8657 switch (op[2] & 0x0f)
8658 {
8659 case 0x00:
8660 case 0x01:
8661 case 0x02:
8662 case 0x03:
8663 case 0x04:
8664 case 0x05:
8665 case 0x06:
8666 case 0x07:
8667 case 0x08:
8668 case 0x09:
8669 case 0x0a:
8670 case 0x0b:
8671 case 0x0c:
8672 case 0x0d:
8673 case 0x0e:
8674 goto op_semantics_69;
8675 break;
8676 case 0x0f:
8677 goto op_semantics_70;
8678 break;
8679 }
8680 break;
8681 case 0xe4:
8682 GETBYTE ();
8683 switch (op[2] & 0x0f)
8684 {
8685 case 0x00:
8686 case 0x01:
8687 case 0x02:
8688 case 0x03:
8689 case 0x04:
8690 case 0x05:
8691 case 0x06:
8692 case 0x07:
8693 case 0x08:
8694 case 0x09:
8695 case 0x0a:
8696 case 0x0b:
8697 case 0x0c:
8698 case 0x0d:
8699 case 0x0e:
8700 goto op_semantics_69;
8701 break;
8702 case 0x0f:
8703 goto op_semantics_70;
8704 break;
8705 }
8706 break;
8707 case 0xe5:
8708 GETBYTE ();
8709 switch (op[2] & 0x0f)
8710 {
8711 case 0x00:
8712 case 0x01:
8713 case 0x02:
8714 case 0x03:
8715 case 0x04:
8716 case 0x05:
8717 case 0x06:
8718 case 0x07:
8719 case 0x08:
8720 case 0x09:
8721 case 0x0a:
8722 case 0x0b:
8723 case 0x0c:
8724 case 0x0d:
8725 case 0x0e:
8726 goto op_semantics_69;
8727 break;
8728 case 0x0f:
8729 goto op_semantics_70;
8730 break;
8731 }
8732 break;
8733 case 0xe6:
8734 GETBYTE ();
8735 switch (op[2] & 0x0f)
8736 {
8737 case 0x00:
8738 case 0x01:
8739 case 0x02:
8740 case 0x03:
8741 case 0x04:
8742 case 0x05:
8743 case 0x06:
8744 case 0x07:
8745 case 0x08:
8746 case 0x09:
8747 case 0x0a:
8748 case 0x0b:
8749 case 0x0c:
8750 case 0x0d:
8751 case 0x0e:
8752 goto op_semantics_69;
8753 break;
8754 case 0x0f:
8755 goto op_semantics_70;
8756 break;
8757 }
8758 break;
8759 case 0xe7:
8760 GETBYTE ();
8761 switch (op[2] & 0x0f)
8762 {
8763 case 0x00:
8764 case 0x01:
8765 case 0x02:
8766 case 0x03:
8767 case 0x04:
8768 case 0x05:
8769 case 0x06:
8770 case 0x07:
8771 case 0x08:
8772 case 0x09:
8773 case 0x0a:
8774 case 0x0b:
8775 case 0x0c:
8776 case 0x0d:
8777 case 0x0e:
8778 goto op_semantics_69;
8779 break;
8780 case 0x0f:
8781 goto op_semantics_70;
8782 break;
8783 }
8784 break;
8785 case 0xe8:
8786 GETBYTE ();
8787 switch (op[2] & 0x0f)
8788 {
8789 case 0x00:
8790 case 0x01:
8791 case 0x02:
8792 case 0x03:
8793 case 0x04:
8794 case 0x05:
8795 case 0x06:
8796 case 0x07:
8797 case 0x08:
8798 case 0x09:
8799 case 0x0a:
8800 case 0x0b:
8801 case 0x0c:
8802 case 0x0d:
8803 case 0x0e:
8804 goto op_semantics_69;
8805 break;
8806 case 0x0f:
8807 goto op_semantics_70;
8808 break;
8809 }
8810 break;
8811 case 0xe9:
8812 GETBYTE ();
8813 switch (op[2] & 0x0f)
8814 {
8815 case 0x00:
8816 case 0x01:
8817 case 0x02:
8818 case 0x03:
8819 case 0x04:
8820 case 0x05:
8821 case 0x06:
8822 case 0x07:
8823 case 0x08:
8824 case 0x09:
8825 case 0x0a:
8826 case 0x0b:
8827 case 0x0c:
8828 case 0x0d:
8829 case 0x0e:
8830 goto op_semantics_69;
8831 break;
8832 case 0x0f:
8833 goto op_semantics_70;
8834 break;
8835 }
8836 break;
8837 case 0xea:
8838 GETBYTE ();
8839 switch (op[2] & 0x0f)
8840 {
8841 case 0x00:
8842 case 0x01:
8843 case 0x02:
8844 case 0x03:
8845 case 0x04:
8846 case 0x05:
8847 case 0x06:
8848 case 0x07:
8849 case 0x08:
8850 case 0x09:
8851 case 0x0a:
8852 case 0x0b:
8853 case 0x0c:
8854 case 0x0d:
8855 case 0x0e:
8856 goto op_semantics_69;
8857 break;
8858 case 0x0f:
8859 goto op_semantics_70;
8860 break;
8861 }
8862 break;
8863 case 0xeb:
8864 GETBYTE ();
8865 switch (op[2] & 0x0f)
8866 {
8867 case 0x00:
8868 case 0x01:
8869 case 0x02:
8870 case 0x03:
8871 case 0x04:
8872 case 0x05:
8873 case 0x06:
8874 case 0x07:
8875 case 0x08:
8876 case 0x09:
8877 case 0x0a:
8878 case 0x0b:
8879 case 0x0c:
8880 case 0x0d:
8881 case 0x0e:
8882 goto op_semantics_69;
8883 break;
8884 case 0x0f:
8885 goto op_semantics_70;
8886 break;
8887 }
8888 break;
8889 case 0xec:
8890 GETBYTE ();
8891 switch (op[2] & 0x0f)
8892 {
8893 case 0x00:
8894 case 0x01:
8895 case 0x02:
8896 case 0x03:
8897 case 0x04:
8898 case 0x05:
8899 case 0x06:
8900 case 0x07:
8901 case 0x08:
8902 case 0x09:
8903 case 0x0a:
8904 case 0x0b:
8905 case 0x0c:
8906 case 0x0d:
8907 case 0x0e:
8908 goto op_semantics_69;
8909 break;
8910 case 0x0f:
8911 goto op_semantics_70;
8912 break;
8913 }
8914 break;
8915 case 0xed:
8916 GETBYTE ();
8917 switch (op[2] & 0x0f)
8918 {
8919 case 0x00:
8920 case 0x01:
8921 case 0x02:
8922 case 0x03:
8923 case 0x04:
8924 case 0x05:
8925 case 0x06:
8926 case 0x07:
8927 case 0x08:
8928 case 0x09:
8929 case 0x0a:
8930 case 0x0b:
8931 case 0x0c:
8932 case 0x0d:
8933 case 0x0e:
8934 goto op_semantics_69;
8935 break;
8936 case 0x0f:
8937 goto op_semantics_70;
8938 break;
8939 }
8940 break;
8941 case 0xee:
8942 GETBYTE ();
8943 switch (op[2] & 0x0f)
8944 {
8945 case 0x00:
8946 case 0x01:
8947 case 0x02:
8948 case 0x03:
8949 case 0x04:
8950 case 0x05:
8951 case 0x06:
8952 case 0x07:
8953 case 0x08:
8954 case 0x09:
8955 case 0x0a:
8956 case 0x0b:
8957 case 0x0c:
8958 case 0x0d:
8959 case 0x0e:
8960 goto op_semantics_69;
8961 break;
8962 case 0x0f:
8963 goto op_semantics_70;
8964 break;
8965 }
8966 break;
8967 case 0xef:
8968 GETBYTE ();
8969 switch (op[2] & 0x0f)
8970 {
8971 case 0x00:
8972 case 0x01:
8973 case 0x02:
8974 case 0x03:
8975 case 0x04:
8976 case 0x05:
8977 case 0x06:
8978 case 0x07:
8979 case 0x08:
8980 case 0x09:
8981 case 0x0a:
8982 case 0x0b:
8983 case 0x0c:
8984 case 0x0d:
8985 case 0x0e:
8986 goto op_semantics_69;
8987 break;
8988 case 0x0f:
8989 goto op_semantics_70;
8990 break;
8991 }
8992 break;
8993 case 0xf0:
8994 GETBYTE ();
8995 switch (op[2] & 0x0f)
8996 {
8997 case 0x00:
8998 case 0x01:
8999 case 0x02:
9000 case 0x03:
9001 case 0x04:
9002 case 0x05:
9003 case 0x06:
9004 case 0x07:
9005 case 0x08:
9006 case 0x09:
9007 case 0x0a:
9008 case 0x0b:
9009 case 0x0c:
9010 case 0x0d:
9011 case 0x0e:
9012 goto op_semantics_69;
9013 break;
9014 case 0x0f:
9015 goto op_semantics_70;
9016 break;
9017 }
9018 break;
9019 case 0xf1:
9020 GETBYTE ();
9021 switch (op[2] & 0x0f)
9022 {
9023 case 0x00:
9024 case 0x01:
9025 case 0x02:
9026 case 0x03:
9027 case 0x04:
9028 case 0x05:
9029 case 0x06:
9030 case 0x07:
9031 case 0x08:
9032 case 0x09:
9033 case 0x0a:
9034 case 0x0b:
9035 case 0x0c:
9036 case 0x0d:
9037 case 0x0e:
9038 goto op_semantics_69;
9039 break;
9040 case 0x0f:
9041 goto op_semantics_70;
9042 break;
9043 }
9044 break;
9045 case 0xf2:
9046 GETBYTE ();
9047 switch (op[2] & 0x0f)
9048 {
9049 case 0x00:
9050 case 0x01:
9051 case 0x02:
9052 case 0x03:
9053 case 0x04:
9054 case 0x05:
9055 case 0x06:
9056 case 0x07:
9057 case 0x08:
9058 case 0x09:
9059 case 0x0a:
9060 case 0x0b:
9061 case 0x0c:
9062 case 0x0d:
9063 case 0x0e:
9064 goto op_semantics_69;
9065 break;
9066 case 0x0f:
9067 goto op_semantics_70;
9068 break;
9069 }
9070 break;
9071 case 0xf3:
9072 GETBYTE ();
9073 switch (op[2] & 0x0f)
9074 {
9075 case 0x00:
9076 case 0x01:
9077 case 0x02:
9078 case 0x03:
9079 case 0x04:
9080 case 0x05:
9081 case 0x06:
9082 case 0x07:
9083 case 0x08:
9084 case 0x09:
9085 case 0x0a:
9086 case 0x0b:
9087 case 0x0c:
9088 case 0x0d:
9089 case 0x0e:
9090 goto op_semantics_69;
9091 break;
9092 case 0x0f:
9093 goto op_semantics_70;
9094 break;
9095 }
9096 break;
9097 case 0xf4:
9098 GETBYTE ();
9099 switch (op[2] & 0x0f)
9100 {
9101 case 0x00:
9102 case 0x01:
9103 case 0x02:
9104 case 0x03:
9105 case 0x04:
9106 case 0x05:
9107 case 0x06:
9108 case 0x07:
9109 case 0x08:
9110 case 0x09:
9111 case 0x0a:
9112 case 0x0b:
9113 case 0x0c:
9114 case 0x0d:
9115 case 0x0e:
9116 goto op_semantics_69;
9117 break;
9118 case 0x0f:
9119 goto op_semantics_70;
9120 break;
9121 }
9122 break;
9123 case 0xf5:
9124 GETBYTE ();
9125 switch (op[2] & 0x0f)
9126 {
9127 case 0x00:
9128 case 0x01:
9129 case 0x02:
9130 case 0x03:
9131 case 0x04:
9132 case 0x05:
9133 case 0x06:
9134 case 0x07:
9135 case 0x08:
9136 case 0x09:
9137 case 0x0a:
9138 case 0x0b:
9139 case 0x0c:
9140 case 0x0d:
9141 case 0x0e:
9142 goto op_semantics_69;
9143 break;
9144 case 0x0f:
9145 goto op_semantics_70;
9146 break;
9147 }
9148 break;
9149 case 0xf6:
9150 GETBYTE ();
9151 switch (op[2] & 0x0f)
9152 {
9153 case 0x00:
9154 case 0x01:
9155 case 0x02:
9156 case 0x03:
9157 case 0x04:
9158 case 0x05:
9159 case 0x06:
9160 case 0x07:
9161 case 0x08:
9162 case 0x09:
9163 case 0x0a:
9164 case 0x0b:
9165 case 0x0c:
9166 case 0x0d:
9167 case 0x0e:
9168 goto op_semantics_69;
9169 break;
9170 case 0x0f:
9171 goto op_semantics_70;
9172 break;
9173 }
9174 break;
9175 case 0xf7:
9176 GETBYTE ();
9177 switch (op[2] & 0x0f)
9178 {
9179 case 0x00:
9180 case 0x01:
9181 case 0x02:
9182 case 0x03:
9183 case 0x04:
9184 case 0x05:
9185 case 0x06:
9186 case 0x07:
9187 case 0x08:
9188 case 0x09:
9189 case 0x0a:
9190 case 0x0b:
9191 case 0x0c:
9192 case 0x0d:
9193 case 0x0e:
9194 goto op_semantics_69;
9195 break;
9196 case 0x0f:
9197 goto op_semantics_70;
9198 break;
9199 }
9200 break;
9201 case 0xf8:
9202 GETBYTE ();
9203 switch (op[2] & 0x0f)
9204 {
9205 case 0x00:
9206 case 0x01:
9207 case 0x02:
9208 case 0x03:
9209 case 0x04:
9210 case 0x05:
9211 case 0x06:
9212 case 0x07:
9213 case 0x08:
9214 case 0x09:
9215 case 0x0a:
9216 case 0x0b:
9217 case 0x0c:
9218 case 0x0d:
9219 case 0x0e:
9220 goto op_semantics_69;
9221 break;
9222 case 0x0f:
9223 goto op_semantics_70;
9224 break;
9225 }
9226 break;
9227 case 0xf9:
9228 GETBYTE ();
9229 switch (op[2] & 0x0f)
9230 {
9231 case 0x00:
9232 case 0x01:
9233 case 0x02:
9234 case 0x03:
9235 case 0x04:
9236 case 0x05:
9237 case 0x06:
9238 case 0x07:
9239 case 0x08:
9240 case 0x09:
9241 case 0x0a:
9242 case 0x0b:
9243 case 0x0c:
9244 case 0x0d:
9245 case 0x0e:
9246 goto op_semantics_69;
9247 break;
9248 case 0x0f:
9249 goto op_semantics_70;
9250 break;
9251 }
9252 break;
9253 case 0xfa:
9254 GETBYTE ();
9255 switch (op[2] & 0x0f)
9256 {
9257 case 0x00:
9258 case 0x01:
9259 case 0x02:
9260 case 0x03:
9261 case 0x04:
9262 case 0x05:
9263 case 0x06:
9264 case 0x07:
9265 case 0x08:
9266 case 0x09:
9267 case 0x0a:
9268 case 0x0b:
9269 case 0x0c:
9270 case 0x0d:
9271 case 0x0e:
9272 goto op_semantics_69;
9273 break;
9274 case 0x0f:
9275 goto op_semantics_70;
9276 break;
9277 }
9278 break;
9279 case 0xfb:
9280 GETBYTE ();
9281 switch (op[2] & 0x0f)
9282 {
9283 case 0x00:
9284 case 0x01:
9285 case 0x02:
9286 case 0x03:
9287 case 0x04:
9288 case 0x05:
9289 case 0x06:
9290 case 0x07:
9291 case 0x08:
9292 case 0x09:
9293 case 0x0a:
9294 case 0x0b:
9295 case 0x0c:
9296 case 0x0d:
9297 case 0x0e:
9298 goto op_semantics_69;
9299 break;
9300 case 0x0f:
9301 goto op_semantics_70;
9302 break;
9303 }
9304 break;
9305 case 0xfc:
9306 GETBYTE ();
9307 switch (op[2] & 0x0f)
9308 {
9309 case 0x00:
9310 case 0x01:
9311 case 0x02:
9312 case 0x03:
9313 case 0x04:
9314 case 0x05:
9315 case 0x06:
9316 case 0x07:
9317 case 0x08:
9318 case 0x09:
9319 case 0x0a:
9320 case 0x0b:
9321 case 0x0c:
9322 case 0x0d:
9323 case 0x0e:
9324 goto op_semantics_69;
9325 break;
9326 case 0x0f:
9327 goto op_semantics_70;
9328 break;
9329 }
9330 break;
9331 case 0xfd:
9332 GETBYTE ();
9333 switch (op[2] & 0x0f)
9334 {
9335 case 0x00:
9336 case 0x01:
9337 case 0x02:
9338 case 0x03:
9339 case 0x04:
9340 case 0x05:
9341 case 0x06:
9342 case 0x07:
9343 case 0x08:
9344 case 0x09:
9345 case 0x0a:
9346 case 0x0b:
9347 case 0x0c:
9348 case 0x0d:
9349 case 0x0e:
9350 goto op_semantics_69;
9351 break;
9352 case 0x0f:
9353 goto op_semantics_70;
9354 break;
9355 }
9356 break;
9357 case 0xfe:
9358 GETBYTE ();
9359 switch (op[2] & 0x0f)
9360 {
9361 case 0x00:
9362 case 0x01:
9363 case 0x02:
9364 case 0x03:
9365 case 0x04:
9366 case 0x05:
9367 case 0x06:
9368 case 0x07:
9369 case 0x08:
9370 case 0x09:
9371 case 0x0a:
9372 case 0x0b:
9373 case 0x0c:
9374 case 0x0d:
9375 case 0x0e:
9376 goto op_semantics_69;
9377 break;
9378 case 0x0f:
9379 goto op_semantics_70;
9380 break;
9381 }
9382 break;
9383 case 0xff:
9384 GETBYTE ();
9385 switch (op[2] & 0x0f)
9386 {
9387 case 0x00:
9388 case 0x01:
9389 case 0x02:
9390 case 0x03:
9391 case 0x04:
9392 case 0x05:
9393 case 0x06:
9394 case 0x07:
9395 case 0x08:
9396 case 0x09:
9397 case 0x0a:
9398 case 0x0b:
9399 case 0x0c:
9400 case 0x0d:
9401 case 0x0e:
9402 goto op_semantics_69;
9403 break;
9404 case 0x0f:
9405 goto op_semantics_70;
9406 break;
9407 }
9408 break;
9409 default: UNSUPPORTED(); break;
9410 }
9411 break;
9412 case 0xfd:
9413 GETBYTE ();
9414 switch (op[1] & 0xff)
9415 {
9416 case 0x00:
9417 GETBYTE ();
9418 switch (op[2] & 0x00)
9419 {
9420 case 0x00:
9421 {
9422 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
f9c7014e 9423#line 772 "rx-decode.opc"
c7927a3c 9424 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 9425#line 772 "rx-decode.opc"
c7927a3c
NC		 9426 int srcb AU = op[2] & 0x0f;
9427 if (trace)
9428 {
9429 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9430 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9431 op[0], op[1], op[2]);
9432 printf (" srca = 0x%x,", srca);
9433 printf (" srcb = 0x%x\n", srcb);
9434 }
9435 SYNTAX("mulhi %1, %2");
f9c7014e 9436#line 772 "rx-decode.opc"
3cf79a01 9437 ID(mulhi); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9438
9439 }
9440 break;
9441 }
9442 break;
9443 case 0x01:
9444 GETBYTE ();
9445 switch (op[2] & 0x00)
9446 {
9447 case 0x00:
9448 {
9449 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
f9c7014e 9450#line 775 "rx-decode.opc"
c7927a3c 9451 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 9452#line 775 "rx-decode.opc"
c7927a3c
NC		 9453 int srcb AU = op[2] & 0x0f;
9454 if (trace)
9455 {
9456 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9457 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9458 op[0], op[1], op[2]);
9459 printf (" srca = 0x%x,", srca);
9460 printf (" srcb = 0x%x\n", srcb);
9461 }
9462 SYNTAX("mullo %1, %2");
f9c7014e 9463#line 775 "rx-decode.opc"
3cf79a01 9464 ID(mullo); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9465
9466 }
9467 break;
9468 }
9469 break;
9470 case 0x04:
9471 GETBYTE ();
9472 switch (op[2] & 0x00)
9473 {
9474 case 0x00:
9475 {
9476 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
f9c7014e 9477#line 778 "rx-decode.opc"
c7927a3c 9478 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 9479#line 778 "rx-decode.opc"
c7927a3c
NC		 9480 int srcb AU = op[2] & 0x0f;
9481 if (trace)
9482 {
9483 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9484 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9485 op[0], op[1], op[2]);
9486 printf (" srca = 0x%x,", srca);
9487 printf (" srcb = 0x%x\n", srcb);
9488 }
9489 SYNTAX("machi %1, %2");
f9c7014e 9490#line 778 "rx-decode.opc"
3cf79a01 9491 ID(machi); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9492
9493 }
9494 break;
9495 }
9496 break;
9497 case 0x05:
9498 GETBYTE ();
9499 switch (op[2] & 0x00)
9500 {
9501 case 0x00:
9502 {
9503 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
f9c7014e 9504#line 781 "rx-decode.opc"
c7927a3c 9505 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 9506#line 781 "rx-decode.opc"
c7927a3c
NC		 9507 int srcb AU = op[2] & 0x0f;
9508 if (trace)
9509 {
9510 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9511 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9512 op[0], op[1], op[2]);
9513 printf (" srca = 0x%x,", srca);
9514 printf (" srcb = 0x%x\n", srcb);
9515 }
9516 SYNTAX("maclo %1, %2");
f9c7014e 9517#line 781 "rx-decode.opc"
3cf79a01 9518 ID(maclo); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9519
9520 }
9521 break;
9522 }
9523 break;
9524 case 0x17:
9525 GETBYTE ();
9526 switch (op[2] & 0xf0)
9527 {
9528 case 0x00:
9529 {
9530 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
f9c7014e 9531#line 784 "rx-decode.opc"
c7927a3c
NC		 9532 int rsrc AU = op[2] & 0x0f;
9533 if (trace)
9534 {
9535 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9536 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9537 op[0], op[1], op[2]);
9538 printf (" rsrc = 0x%x\n", rsrc);
9539 }
9540 SYNTAX("mvtachi %1");
f9c7014e 9541#line 784 "rx-decode.opc"
3cf79a01 9542 ID(mvtachi); SR(rsrc); F_____;
c7927a3c
NC		 9543
9544 }
9545 break;
9546 case 0x10:
9547 {
9548 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
f9c7014e 9549#line 787 "rx-decode.opc"
c7927a3c
NC		 9550 int rsrc AU = op[2] & 0x0f;
9551 if (trace)
9552 {
9553 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9554 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9555 op[0], op[1], op[2]);
9556 printf (" rsrc = 0x%x\n", rsrc);
9557 }
9558 SYNTAX("mvtaclo %1");
f9c7014e 9559#line 787 "rx-decode.opc"
3cf79a01 9560 ID(mvtaclo); SR(rsrc); F_____;
c7927a3c
NC		 9561
9562 }
9563 break;
9564 default: UNSUPPORTED(); break;
9565 }
9566 break;
9567 case 0x18:
9568 GETBYTE ();
9569 switch (op[2] & 0xef)
9570 {
9571 case 0x00:
9572 {
9573 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
f9c7014e 9574#line 799 "rx-decode.opc"
c7927a3c
NC		 9575 int i AU = (op[2] >> 4) & 0x01;
9576 if (trace)
9577 {
9578 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9579 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9580 op[0], op[1], op[2]);
9581 printf (" i = 0x%x\n", i);
9582 }
9583 SYNTAX("racw #%1");
f9c7014e 9584#line 799 "rx-decode.opc"
3cf79a01 9585 ID(racw); SC(i+1); F_____;
c7927a3c
NC		 9586
9587 /*----------------------------------------------------------------------*/
9588 /* SAT */
9589
9590 }
9591 break;
9592 default: UNSUPPORTED(); break;
9593 }
9594 break;
9595 case 0x1f:
9596 GETBYTE ();
9597 switch (op[2] & 0xf0)
9598 {
9599 case 0x00:
9600 {
9601 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
f9c7014e 9602#line 790 "rx-decode.opc"
c7927a3c
NC		 9603 int rdst AU = op[2] & 0x0f;
9604 if (trace)
9605 {
9606 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9607 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9608 op[0], op[1], op[2]);
9609 printf (" rdst = 0x%x\n", rdst);
9610 }
9611 SYNTAX("mvfachi %0");
f9c7014e 9612#line 790 "rx-decode.opc"
3cf79a01 9613 ID(mvfachi); DR(rdst); F_____;
c7927a3c
NC		 9614
9615 }
9616 break;
9617 case 0x10:
9618 {
9619 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
f9c7014e 9620#line 796 "rx-decode.opc"
c7927a3c
NC		 9621 int rdst AU = op[2] & 0x0f;
9622 if (trace)
9623 {
9624 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9625 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9626 op[0], op[1], op[2]);
9627 printf (" rdst = 0x%x\n", rdst);
9628 }
9629 SYNTAX("mvfaclo %0");
f9c7014e 9630#line 796 "rx-decode.opc"
3cf79a01 9631 ID(mvfaclo); DR(rdst); F_____;
c7927a3c
NC		 9632
9633 }
9634 break;
9635 case 0x20:
9636 {
9637 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
f9c7014e 9638#line 793 "rx-decode.opc"
c7927a3c
NC		 9639 int rdst AU = op[2] & 0x0f;
9640 if (trace)
9641 {
9642 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9643 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9644 op[0], op[1], op[2]);
9645 printf (" rdst = 0x%x\n", rdst);
9646 }
9647 SYNTAX("mvfacmi %0");
f9c7014e 9648#line 793 "rx-decode.opc"
3cf79a01 9649 ID(mvfacmi); DR(rdst); F_____;
c7927a3c
NC		 9650
9651 }
9652 break;
9653 default: UNSUPPORTED(); break;
9654 }
9655 break;
9656 case 0x20:
9657 GETBYTE ();
9658 switch (op[2] & 0x00)
9659 {
9660 case 0x00:
9661 op_semantics_71:
9662 {
9663 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
f9c7014e 9664#line 307 "rx-decode.opc"
c7927a3c 9665 int p AU = (op[1] >> 2) & 0x01;
f9c7014e 9666#line 307 "rx-decode.opc"
c7927a3c 9667 int sz AU = op[1] & 0x03;
f9c7014e 9668#line 307 "rx-decode.opc"
c7927a3c 9669 int rdst AU = (op[2] >> 4) & 0x0f;
f9c7014e 9670#line 307 "rx-decode.opc"
c7927a3c
NC		 9671 int rsrc AU = op[2] & 0x0f;
9672 if (trace)
9673 {
9674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9675 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9676 op[0], op[1], op[2]);
9677 printf (" p = 0x%x,", p);
9678 printf (" sz = 0x%x,", sz);
9679 printf (" rdst = 0x%x,", rdst);
9680 printf (" rsrc = 0x%x\n", rsrc);
9681 }
9682 SYNTAX("mov%s %1, %0");
f9c7014e 9683#line 307 "rx-decode.opc"
3cf79a01 9684 ID(mov); sBWL (sz); SR(rsrc); F_____;
c7927a3c
NC		 9685 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9686
9687 }
9688 break;
9689 }
9690 break;
9691 case 0x21:
9692 GETBYTE ();
9693 switch (op[2] & 0x00)
9694 {
9695 case 0x00:
9696 goto op_semantics_71;
9697 break;
9698 }
9699 break;
9700 case 0x22:
9701 GETBYTE ();
9702 switch (op[2] & 0x00)
9703 {
9704 case 0x00:
9705 goto op_semantics_71;
9706 break;
9707 }
9708 break;
9709 case 0x24:
9710 GETBYTE ();
9711 switch (op[2] & 0x00)
9712 {
9713 case 0x00:
9714 goto op_semantics_71;
9715 break;
9716 }
9717 break;
9718 case 0x25:
9719 GETBYTE ();
9720 switch (op[2] & 0x00)
9721 {
9722 case 0x00:
9723 goto op_semantics_71;
9724 break;
9725 }
9726 break;
9727 case 0x26:
9728 GETBYTE ();
9729 switch (op[2] & 0x00)
9730 {
9731 case 0x00:
9732 goto op_semantics_71;
9733 break;
9734 }
9735 break;
9736 case 0x28:
9737 GETBYTE ();
9738 switch (op[2] & 0x00)
9739 {
9740 case 0x00:
9741 op_semantics_72:
9742 {
9743 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
f9c7014e 9744#line 311 "rx-decode.opc"
c7927a3c 9745 int p AU = (op[1] >> 2) & 0x01;
f9c7014e 9746#line 311 "rx-decode.opc"
c7927a3c 9747 int sz AU = op[1] & 0x03;
f9c7014e 9748#line 311 "rx-decode.opc"
c7927a3c 9749 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 9750#line 311 "rx-decode.opc"
c7927a3c
NC		 9751 int rdst AU = op[2] & 0x0f;
9752 if (trace)
9753 {
9754 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9755 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9756 op[0], op[1], op[2]);
9757 printf (" p = 0x%x,", p);
9758 printf (" sz = 0x%x,", sz);
9759 printf (" rsrc = 0x%x,", rsrc);
9760 printf (" rdst = 0x%x\n", rdst);
9761 }
9762 SYNTAX("mov%s %1, %0");
f9c7014e 9763#line 311 "rx-decode.opc"
3cf79a01 9764 ID(mov); sBWL (sz); DR(rdst); F_____;
c7927a3c
NC		 9765 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9766
9767 }
9768 break;
9769 }
9770 break;
9771 case 0x29:
9772 GETBYTE ();
9773 switch (op[2] & 0x00)
9774 {
9775 case 0x00:
9776 goto op_semantics_72;
9777 break;
9778 }
9779 break;
9780 case 0x2a:
9781 GETBYTE ();
9782 switch (op[2] & 0x00)
9783 {
9784 case 0x00:
9785 goto op_semantics_72;
9786 break;
9787 }
9788 break;
9789 case 0x2c:
9790 GETBYTE ();
9791 switch (op[2] & 0x00)
9792 {
9793 case 0x00:
9794 goto op_semantics_72;
9795 break;
9796 }
9797 break;
9798 case 0x2d:
9799 GETBYTE ();
9800 switch (op[2] & 0x00)
9801 {
9802 case 0x00:
9803 goto op_semantics_72;
9804 break;
9805 }
9806 break;
9807 case 0x2e:
9808 GETBYTE ();
9809 switch (op[2] & 0x00)
9810 {
9811 case 0x00:
9812 goto op_semantics_72;
9813 break;
9814 }
9815 break;
9816 case 0x38:
9817 GETBYTE ();
9818 switch (op[2] & 0x00)
9819 {
9820 case 0x00:
9821 op_semantics_73:
9822 {
9823 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
f9c7014e 9824#line 321 "rx-decode.opc"
c7927a3c 9825 int p AU = (op[1] >> 2) & 0x01;
f9c7014e 9826#line 321 "rx-decode.opc"
c7927a3c 9827 int sz AU = op[1] & 0x03;
f9c7014e 9828#line 321 "rx-decode.opc"
c7927a3c 9829 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 9830#line 321 "rx-decode.opc"
c7927a3c
NC		 9831 int rdst AU = op[2] & 0x0f;
9832 if (trace)
9833 {
9834 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9835 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9836 op[0], op[1], op[2]);
9837 printf (" p = 0x%x,", p);
9838 printf (" sz = 0x%x,", sz);
9839 printf (" rsrc = 0x%x,", rsrc);
9840 printf (" rdst = 0x%x\n", rdst);
9841 }
9842 SYNTAX("movu%s %1, %0");
f9c7014e 9843#line 321 "rx-decode.opc"
3cf79a01 9844 ID(mov); uBWL (sz); DR(rdst); F_____;
c7927a3c
NC		 9845 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9846
9847 /*----------------------------------------------------------------------*/
9848 /* PUSH/POP */
9849
9850 }
9851 break;
9852 }
9853 break;
9854 case 0x39:
9855 GETBYTE ();
9856 switch (op[2] & 0x00)
9857 {
9858 case 0x00:
9859 goto op_semantics_73;
9860 break;
9861 }
9862 break;
9863 case 0x3a:
9864 GETBYTE ();
9865 switch (op[2] & 0x00)
9866 {
9867 case 0x00:
9868 goto op_semantics_73;
9869 break;
9870 }
9871 break;
9872 case 0x3c:
9873 GETBYTE ();
9874 switch (op[2] & 0x00)
9875 {
9876 case 0x00:
9877 goto op_semantics_73;
9878 break;
9879 }
9880 break;
9881 case 0x3d:
9882 GETBYTE ();
9883 switch (op[2] & 0x00)
9884 {
9885 case 0x00:
9886 goto op_semantics_73;
9887 break;
9888 }
9889 break;
9890 case 0x3e:
9891 GETBYTE ();
9892 switch (op[2] & 0x00)
9893 {
9894 case 0x00:
9895 goto op_semantics_73;
9896 break;
9897 }
9898 break;
9899 case 0x60:
9900 GETBYTE ();
9901 switch (op[2] & 0x00)
9902 {
9903 case 0x00:
9904 {
9905 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
f9c7014e 9906#line 653 "rx-decode.opc"
c7927a3c 9907 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 9908#line 653 "rx-decode.opc"
c7927a3c
NC		 9909 int rdst AU = op[2] & 0x0f;
9910 if (trace)
9911 {
9912 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9913 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9914 op[0], op[1], op[2]);
9915 printf (" rsrc = 0x%x,", rsrc);
9916 printf (" rdst = 0x%x\n", rdst);
9917 }
9918 SYNTAX("shlr %2, %0");
f9c7014e 9919#line 653 "rx-decode.opc"
3cf79a01 9920 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
c7927a3c
NC		 9921
9922 }
9923 break;
9924 }
9925 break;
9926 case 0x61:
9927 GETBYTE ();
9928 switch (op[2] & 0x00)
9929 {
9930 case 0x00:
9931 {
9932 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
f9c7014e 9933#line 643 "rx-decode.opc"
c7927a3c 9934 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 9935#line 643 "rx-decode.opc"
c7927a3c
NC		 9936 int rdst AU = op[2] & 0x0f;
9937 if (trace)
9938 {
9939 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9940 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
9941 op[0], op[1], op[2]);
9942 printf (" rsrc = 0x%x,", rsrc);
9943 printf (" rdst = 0x%x\n", rdst);
9944 }
9945 SYNTAX("shar %2, %0");
f9c7014e 9946#line 643 "rx-decode.opc"
3cf79a01 9947 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
c7927a3c
NC		 9948
9949 }
9950 break;
9951 }
9952 break;
9953 case 0x62:
9954 GETBYTE ();
9955 switch (op[2] & 0x00)
9956 {
9957 case 0x00:
9958 {
9959 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
f9c7014e 9960#line 633 "rx-decode.opc"
c7927a3c 9961 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 9962#line 633 "rx-decode.opc"
c7927a3c
NC		 9963 int rdst AU = op[2] & 0x0f;
9964 if (trace)
9965 {
9966 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9967 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
9968 op[0], op[1], op[2]);
9969 printf (" rsrc = 0x%x,", rsrc);
9970 printf (" rdst = 0x%x\n", rdst);
9971 }
9972 SYNTAX("shll %2, %0");
f9c7014e 9973#line 633 "rx-decode.opc"
3cf79a01 9974 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 9975
9976 }
9977 break;
9978 }
9979 break;
9980 case 0x64:
9981 GETBYTE ();
9982 switch (op[2] & 0x00)
9983 {
9984 case 0x00:
9985 {
9986 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
f9c7014e 9987#line 677 "rx-decode.opc"
c7927a3c 9988 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 9989#line 677 "rx-decode.opc"
c7927a3c
NC		 9990 int rdst AU = op[2] & 0x0f;
9991 if (trace)
9992 {
9993 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9994 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
9995 op[0], op[1], op[2]);
9996 printf (" rsrc = 0x%x,", rsrc);
9997 printf (" rdst = 0x%x\n", rdst);
9998 }
9999 SYNTAX("rotr %1, %0");
f9c7014e 10000#line 677 "rx-decode.opc"
3cf79a01 10001 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
c7927a3c
NC		 10002
10003 }
10004 break;
10005 }
10006 break;
10007 case 0x65:
10008 GETBYTE ();
10009 switch (op[2] & 0x00)
10010 {
10011 case 0x00:
10012 {
10013 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
f9c7014e 10014#line 680 "rx-decode.opc"
c7927a3c 10015 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 10016#line 680 "rx-decode.opc"
c7927a3c
NC		 10017 int rdst AU = op[2] & 0x0f;
10018 if (trace)
10019 {
10020 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10021 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10022 op[0], op[1], op[2]);
10023 printf (" rsrc = 0x%x,", rsrc);
10024 printf (" rdst = 0x%x\n", rdst);
10025 }
10026 SYNTAX("revw %1, %0");
f9c7014e 10027#line 680 "rx-decode.opc"
c7927a3c
NC		 10028 ID(revw); SR(rsrc); DR(rdst);
10029
10030 }
10031 break;
10032 }
10033 break;
10034 case 0x66:
10035 GETBYTE ();
10036 switch (op[2] & 0x00)
10037 {
10038 case 0x00:
10039 {
10040 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
f9c7014e 10041#line 671 "rx-decode.opc"
c7927a3c 10042 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 10043#line 671 "rx-decode.opc"
c7927a3c
NC		 10044 int rdst AU = op[2] & 0x0f;
10045 if (trace)
10046 {
10047 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10048 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10049 op[0], op[1], op[2]);
10050 printf (" rsrc = 0x%x,", rsrc);
10051 printf (" rdst = 0x%x\n", rdst);
10052 }
10053 SYNTAX("rotl %1, %0");
f9c7014e 10054#line 671 "rx-decode.opc"
3cf79a01 10055 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
c7927a3c
NC		 10056
10057 }
10058 break;
10059 }
10060 break;
10061 case 0x67:
10062 GETBYTE ();
10063 switch (op[2] & 0x00)
10064 {
10065 case 0x00:
10066 {
10067 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
f9c7014e 10068#line 683 "rx-decode.opc"
c7927a3c 10069 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 10070#line 683 "rx-decode.opc"
c7927a3c
NC		 10071 int rdst AU = op[2] & 0x0f;
10072 if (trace)
10073 {
10074 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10075 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10076 op[0], op[1], op[2]);
10077 printf (" rsrc = 0x%x,", rsrc);
10078 printf (" rdst = 0x%x\n", rdst);
10079 }
10080 SYNTAX("revl %1, %0");
f9c7014e 10081#line 683 "rx-decode.opc"
c7927a3c
NC		 10082 ID(revl); SR(rsrc); DR(rdst);
10083
10084 /*----------------------------------------------------------------------*/
10085 /* BRANCH */
10086
10087 }
10088 break;
10089 }
10090 break;
10091 case 0x68:
10092 GETBYTE ();
10093 switch (op[2] & 0x00)
10094 {
10095 case 0x00:
10096 op_semantics_74:
10097 {
10098 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
f9c7014e 10099#line 926 "rx-decode.opc"
c7927a3c 10100 int c AU = op[1] & 0x01;
f9c7014e 10101#line 926 "rx-decode.opc"
c7927a3c 10102 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 10103#line 926 "rx-decode.opc"
c7927a3c
NC		 10104 int rdst AU = op[2] & 0x0f;
10105 if (trace)
10106 {
10107 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10108 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10109 op[0], op[1], op[2]);
10110 printf (" c = 0x%x,", c);
10111 printf (" rsrc = 0x%x,", rsrc);
10112 printf (" rdst = 0x%x\n", rdst);
10113 }
10114 SYNTAX("mvtc %1, %0");
f9c7014e 10115#line 926 "rx-decode.opc"
c7927a3c
NC		 10116 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10117
10118 }
10119 break;
10120 }
10121 break;
10122 case 0x69:
10123 GETBYTE ();
10124 switch (op[2] & 0x00)
10125 {
10126 case 0x00:
10127 goto op_semantics_74;
10128 break;
10129 }
10130 break;
10131 case 0x6a:
10132 GETBYTE ();
10133 switch (op[2] & 0x00)
10134 {
10135 case 0x00:
10136 op_semantics_75:
10137 {
10138 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
f9c7014e 10139#line 929 "rx-decode.opc"
c7927a3c 10140 int s AU = op[1] & 0x01;
f9c7014e 10141#line 929 "rx-decode.opc"
c7927a3c 10142 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 10143#line 929 "rx-decode.opc"
c7927a3c
NC		 10144 int rdst AU = op[2] & 0x0f;
10145 if (trace)
10146 {
10147 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10148 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10149 op[0], op[1], op[2]);
10150 printf (" s = 0x%x,", s);
10151 printf (" rsrc = 0x%x,", rsrc);
10152 printf (" rdst = 0x%x\n", rdst);
10153 }
10154 SYNTAX("mvfc %1, %0");
f9c7014e 10155#line 929 "rx-decode.opc"
c7927a3c
NC		 10156 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10157
946ef196
DD		 10158 /*----------------------------------------------------------------------*/
10159 /* INTERRUPTS */
10160
c7927a3c
NC		 10161 }
10162 break;
10163 }
10164 break;
10165 case 0x6b:
10166 GETBYTE ();
10167 switch (op[2] & 0x00)
10168 {
10169 case 0x00:
10170 goto op_semantics_75;
10171 break;
10172 }
10173 break;
10174 case 0x6c:
10175 GETBYTE ();
10176 switch (op[2] & 0x00)
10177 {
10178 case 0x00:
10179 op_semantics_76:
10180 {
10181 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
f9c7014e 10182#line 674 "rx-decode.opc"
c7927a3c 10183 int i AU = op[1] & 0x01;
f9c7014e 10184#line 674 "rx-decode.opc"
c7927a3c 10185 int mmmm AU = (op[2] >> 4) & 0x0f;
f9c7014e 10186#line 674 "rx-decode.opc"
c7927a3c
NC		 10187 int rdst AU = op[2] & 0x0f;
10188 if (trace)
10189 {
10190 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10191 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10192 op[0], op[1], op[2]);
10193 printf (" i = 0x%x,", i);
10194 printf (" mmmm = 0x%x,", mmmm);
10195 printf (" rdst = 0x%x\n", rdst);
10196 }
10197 SYNTAX("rotr #%1, %0");
f9c7014e 10198#line 674 "rx-decode.opc"
3cf79a01 10199 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
c7927a3c
NC		 10200
10201 }
10202 break;
10203 }
10204 break;
10205 case 0x6d:
10206 GETBYTE ();
10207 switch (op[2] & 0x00)
10208 {
10209 case 0x00:
10210 goto op_semantics_76;
10211 break;
10212 }
10213 break;
10214 case 0x6e:
10215 GETBYTE ();
10216 switch (op[2] & 0x00)
10217 {
10218 case 0x00:
10219 op_semantics_77:
10220 {
10221 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
f9c7014e 10222#line 668 "rx-decode.opc"
c7927a3c 10223 int i AU = op[1] & 0x01;
f9c7014e 10224#line 668 "rx-decode.opc"
c7927a3c 10225 int mmmm AU = (op[2] >> 4) & 0x0f;
f9c7014e 10226#line 668 "rx-decode.opc"
c7927a3c
NC		 10227 int rdst AU = op[2] & 0x0f;
10228 if (trace)
10229 {
10230 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10231 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10232 op[0], op[1], op[2]);
10233 printf (" i = 0x%x,", i);
10234 printf (" mmmm = 0x%x,", mmmm);
10235 printf (" rdst = 0x%x\n", rdst);
10236 }
10237 SYNTAX("rotl #%1, %0");
f9c7014e 10238#line 668 "rx-decode.opc"
3cf79a01 10239 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
c7927a3c
NC		 10240
10241 }
10242 break;
10243 }
10244 break;
10245 case 0x6f:
10246 GETBYTE ();
10247 switch (op[2] & 0x00)
10248 {
10249 case 0x00:
10250 goto op_semantics_77;
10251 break;
10252 }
10253 break;
10254 case 0x70:
10255 GETBYTE ();
10256 switch (op[2] & 0xf0)
10257 {
10258 case 0x20:
10259 op_semantics_78:
10260 {
10261 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
f9c7014e 10262#line 451 "rx-decode.opc"
c7927a3c 10263 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10264#line 451 "rx-decode.opc"
c7927a3c
NC		 10265 int rdst AU = op[2] & 0x0f;
10266 if (trace)
10267 {
10268 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10269 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10270 op[0], op[1], op[2]);
10271 printf (" im = 0x%x,", im);
10272 printf (" rdst = 0x%x\n", rdst);
10273 }
10274 SYNTAX("adc #%1, %0");
f9c7014e 10275#line 451 "rx-decode.opc"
3cf79a01 10276 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
c7927a3c
NC		 10277
10278 }
10279 break;
10280 case 0x40:
10281 op_semantics_79:
10282 {
10283 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
f9c7014e 10284#line 533 "rx-decode.opc"
c7927a3c 10285 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10286#line 533 "rx-decode.opc"
c7927a3c
NC		 10287 int rdst AU = op[2] & 0x0f;
10288 if (trace)
10289 {
10290 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10291 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10292 op[0], op[1], op[2]);
10293 printf (" im = 0x%x,", im);
10294 printf (" rdst = 0x%x\n", rdst);
10295 }
10296 SYNTAX("max #%1, %0");
f9c7014e 10297#line 533 "rx-decode.opc"
c7927a3c
NC		 10298 ID(max); DR(rdst); SC(IMMex(im));
10299
10300 }
10301 break;
10302 case 0x50:
10303 op_semantics_80:
10304 {
10305 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
f9c7014e 10306#line 552 "rx-decode.opc"
c7927a3c 10307 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10308#line 552 "rx-decode.opc"
c7927a3c
NC		 10309 int rdst AU = op[2] & 0x0f;
10310 if (trace)
10311 {
10312 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10313 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10314 op[0], op[1], op[2]);
10315 printf (" im = 0x%x,", im);
10316 printf (" rdst = 0x%x\n", rdst);
10317 }
10318 SYNTAX("min #%1, %0");
f9c7014e 10319#line 552 "rx-decode.opc"
c7927a3c
NC		 10320 ID(min); DR(rdst); SC(IMMex(im));
10321
10322 }
10323 break;
10324 case 0x60:
10325 op_semantics_81:
10326 {
10327 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
f9c7014e 10328#line 582 "rx-decode.opc"
c7927a3c 10329 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10330#line 582 "rx-decode.opc"
c7927a3c
NC		 10331 int rdst AU = op[2] & 0x0f;
10332 if (trace)
10333 {
10334 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10335 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10336 op[0], op[1], op[2]);
10337 printf (" im = 0x%x,", im);
10338 printf (" rdst = 0x%x\n", rdst);
10339 }
10340 SYNTAX("emul #%1, %0");
f9c7014e 10341#line 582 "rx-decode.opc"
c7927a3c
NC		 10342 ID(emul); DR(rdst); SC(IMMex(im));
10343
10344 }
10345 break;
10346 case 0x70:
10347 op_semantics_82:
10348 {
10349 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
f9c7014e 10350#line 594 "rx-decode.opc"
c7927a3c 10351 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10352#line 594 "rx-decode.opc"
c7927a3c
NC		 10353 int rdst AU = op[2] & 0x0f;
10354 if (trace)
10355 {
10356 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10357 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10358 op[0], op[1], op[2]);
10359 printf (" im = 0x%x,", im);
10360 printf (" rdst = 0x%x\n", rdst);
10361 }
10362 SYNTAX("emulu #%1, %0");
f9c7014e 10363#line 594 "rx-decode.opc"
c7927a3c
NC		 10364 ID(emulu); DR(rdst); SC(IMMex(im));
10365
10366 }
10367 break;
10368 case 0x80:
10369 op_semantics_83:
10370 {
10371 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
f9c7014e 10372#line 606 "rx-decode.opc"
c7927a3c 10373 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10374#line 606 "rx-decode.opc"
c7927a3c
NC		 10375 int rdst AU = op[2] & 0x0f;
10376 if (trace)
10377 {
10378 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10379 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10380 op[0], op[1], op[2]);
10381 printf (" im = 0x%x,", im);
10382 printf (" rdst = 0x%x\n", rdst);
10383 }
10384 SYNTAX("div #%1, %0");
f9c7014e 10385#line 606 "rx-decode.opc"
3cf79a01 10386 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
c7927a3c
NC		 10387
10388 }
10389 break;
10390 case 0x90:
10391 op_semantics_84:
10392 {
10393 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
f9c7014e 10394#line 618 "rx-decode.opc"
c7927a3c 10395 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10396#line 618 "rx-decode.opc"
c7927a3c
NC		 10397 int rdst AU = op[2] & 0x0f;
10398 if (trace)
10399 {
10400 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10401 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10402 op[0], op[1], op[2]);
10403 printf (" im = 0x%x,", im);
10404 printf (" rdst = 0x%x\n", rdst);
10405 }
10406 SYNTAX("divu #%1, %0");
f9c7014e 10407#line 618 "rx-decode.opc"
3cf79a01 10408 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
c7927a3c
NC		 10409
10410 }
10411 break;
10412 case 0xc0:
10413 op_semantics_85:
10414 {
10415 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
f9c7014e 10416#line 430 "rx-decode.opc"
c7927a3c 10417 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10418#line 430 "rx-decode.opc"
c7927a3c
NC		 10419 int rdst AU = op[2] & 0x0f;
10420 if (trace)
10421 {
10422 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10423 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
10424 op[0], op[1], op[2]);
10425 printf (" im = 0x%x,", im);
10426 printf (" rdst = 0x%x\n", rdst);
10427 }
10428 SYNTAX("tst #%1, %2");
f9c7014e 10429#line 430 "rx-decode.opc"
3cf79a01 10430 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
c7927a3c
NC		 10431
10432 }
10433 break;
10434 case 0xd0:
10435 op_semantics_86:
10436 {
10437 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
f9c7014e 10438#line 409 "rx-decode.opc"
c7927a3c 10439 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10440#line 409 "rx-decode.opc"
c7927a3c
NC		 10441 int rdst AU = op[2] & 0x0f;
10442 if (trace)
10443 {
10444 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10445 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10446 op[0], op[1], op[2]);
10447 printf (" im = 0x%x,", im);
10448 printf (" rdst = 0x%x\n", rdst);
10449 }
10450 SYNTAX("xor #%1, %0");
f9c7014e 10451#line 409 "rx-decode.opc"
3cf79a01 10452 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
c7927a3c
NC		 10453
10454 }
10455 break;
10456 case 0xe0:
10457 op_semantics_87:
10458 {
10459 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
f9c7014e 10460#line 355 "rx-decode.opc"
c7927a3c 10461 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10462#line 355 "rx-decode.opc"
c7927a3c
NC		 10463 int rdst AU = op[2] & 0x0f;
10464 if (trace)
10465 {
10466 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10467 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10468 op[0], op[1], op[2]);
10469 printf (" im = 0x%x,", im);
10470 printf (" rdst = 0x%x\n", rdst);
10471 }
10472 SYNTAX("stz #%1, %0");
f9c7014e 10473#line 355 "rx-decode.opc"
c7927a3c
NC		 10474 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10475
10476 }
10477 break;
10478 case 0xf0:
10479 op_semantics_88:
10480 {
10481 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
f9c7014e 10482#line 358 "rx-decode.opc"
c7927a3c 10483 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10484#line 358 "rx-decode.opc"
c7927a3c
NC		 10485 int rdst AU = op[2] & 0x0f;
10486 if (trace)
10487 {
10488 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10489 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10490 op[0], op[1], op[2]);
10491 printf (" im = 0x%x,", im);
10492 printf (" rdst = 0x%x\n", rdst);
10493 }
10494 SYNTAX("stnz #%1, %0");
f9c7014e 10495#line 358 "rx-decode.opc"
c7927a3c
NC		 10496 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10497
10498 /*----------------------------------------------------------------------*/
10499 /* RTSD */
10500
10501 }
10502 break;
10503 default: UNSUPPORTED(); break;
10504 }
10505 break;
10506 case 0x72:
10507 GETBYTE ();
10508 switch (op[2] & 0xf0)
10509 {
10510 case 0x00:
10511 {
10512 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
f9c7014e 10513#line 826 "rx-decode.opc"
c7927a3c
NC		 10514 int rdst AU = op[2] & 0x0f;
10515 if (trace)
10516 {
10517 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10518 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
10519 op[0], op[1], op[2]);
10520 printf (" rdst = 0x%x\n", rdst);
10521 }
10522 SYNTAX("fsub #%1, %0");
f9c7014e 10523#line 826 "rx-decode.opc"
3cf79a01 10524 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10525
10526 }
10527 break;
10528 case 0x10:
10529 {
10530 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
f9c7014e 10531#line 820 "rx-decode.opc"
c7927a3c
NC		 10532 int rdst AU = op[2] & 0x0f;
10533 if (trace)
10534 {
10535 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10536 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10537 op[0], op[1], op[2]);
10538 printf (" rdst = 0x%x\n", rdst);
10539 }
10540 SYNTAX("fcmp #%1, %0");
f9c7014e 10541#line 820 "rx-decode.opc"
3cf79a01 10542 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
c7927a3c
NC		 10543
10544 }
10545 break;
10546 case 0x20:
10547 {
10548 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
f9c7014e 10549#line 814 "rx-decode.opc"
c7927a3c
NC		 10550 int rdst AU = op[2] & 0x0f;
10551 if (trace)
10552 {
10553 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10554 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10555 op[0], op[1], op[2]);
10556 printf (" rdst = 0x%x\n", rdst);
10557 }
10558 SYNTAX("fadd #%1, %0");
f9c7014e 10559#line 814 "rx-decode.opc"
3cf79a01 10560 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10561
10562 }
10563 break;
10564 case 0x30:
10565 {
10566 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
f9c7014e 10567#line 835 "rx-decode.opc"
c7927a3c
NC		 10568 int rdst AU = op[2] & 0x0f;
10569 if (trace)
10570 {
10571 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10572 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10573 op[0], op[1], op[2]);
10574 printf (" rdst = 0x%x\n", rdst);
10575 }
10576 SYNTAX("fmul #%1, %0");
f9c7014e 10577#line 835 "rx-decode.opc"
3cf79a01 10578 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10579
10580 }
10581 break;
10582 case 0x40:
10583 {
10584 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
f9c7014e 10585#line 841 "rx-decode.opc"
c7927a3c
NC		 10586 int rdst AU = op[2] & 0x0f;
10587 if (trace)
10588 {
10589 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10590 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10591 op[0], op[1], op[2]);
10592 printf (" rdst = 0x%x\n", rdst);
10593 }
10594 SYNTAX("fdiv #%1, %0");
f9c7014e 10595#line 841 "rx-decode.opc"
3cf79a01 10596 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10597
10598 }
10599 break;
10600 default: UNSUPPORTED(); break;
10601 }
10602 break;
10603 case 0x73:
10604 GETBYTE ();
10605 switch (op[2] & 0xe0)
10606 {
10607 case 0x00:
10608 op_semantics_89:
10609 {
10610 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
f9c7014e 10611#line 923 "rx-decode.opc"
c7927a3c 10612 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 10613#line 923 "rx-decode.opc"
c7927a3c
NC		 10614 int crdst AU = op[2] & 0x1f;
10615 if (trace)
10616 {
10617 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10618 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10619 op[0], op[1], op[2]);
10620 printf (" im = 0x%x,", im);
10621 printf (" crdst = 0x%x\n", crdst);
10622 }
10623 SYNTAX("mvtc #%1, %0");
f9c7014e 10624#line 923 "rx-decode.opc"
c7927a3c
NC		 10625 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10626
10627 }
10628 break;
10629 default: UNSUPPORTED(); break;
10630 }
10631 break;
10632 case 0x74:
10633 GETBYTE ();
10634 switch (op[2] & 0xf0)
10635 {
10636 case 0x20:
10637 goto op_semantics_78;
10638 break;
10639 case 0x40:
10640 goto op_semantics_79;
10641 break;
10642 case 0x50:
10643 goto op_semantics_80;
10644 break;
10645 case 0x60:
10646 goto op_semantics_81;
10647 break;
10648 case 0x70:
10649 goto op_semantics_82;
10650 break;
10651 case 0x80:
10652 goto op_semantics_83;
10653 break;
10654 case 0x90:
10655 goto op_semantics_84;
10656 break;
10657 case 0xc0:
10658 goto op_semantics_85;
10659 break;
10660 case 0xd0:
10661 goto op_semantics_86;
10662 break;
10663 case 0xe0:
10664 goto op_semantics_87;
10665 break;
10666 case 0xf0:
10667 goto op_semantics_88;
10668 break;
10669 default: UNSUPPORTED(); break;
10670 }
10671 break;
10672 case 0x77:
10673 GETBYTE ();
10674 switch (op[2] & 0xe0)
10675 {
10676 case 0x00:
10677 goto op_semantics_89;
10678 break;
10679 default: UNSUPPORTED(); break;
10680 }
10681 break;
10682 case 0x78:
10683 GETBYTE ();
10684 switch (op[2] & 0xf0)
10685 {
10686 case 0x20:
10687 goto op_semantics_78;
10688 break;
10689 case 0x40:
10690 goto op_semantics_79;
10691 break;
10692 case 0x50:
10693 goto op_semantics_80;
10694 break;
10695 case 0x60:
10696 goto op_semantics_81;
10697 break;
10698 case 0x70:
10699 goto op_semantics_82;
10700 break;
10701 case 0x80:
10702 goto op_semantics_83;
10703 break;
10704 case 0x90:
10705 goto op_semantics_84;
10706 break;
10707 case 0xc0:
10708 goto op_semantics_85;
10709 break;
10710 case 0xd0:
10711 goto op_semantics_86;
10712 break;
10713 case 0xe0:
10714 goto op_semantics_87;
10715 break;
10716 case 0xf0:
10717 goto op_semantics_88;
10718 break;
10719 default: UNSUPPORTED(); break;
10720 }
10721 break;
10722 case 0x7b:
10723 GETBYTE ();
10724 switch (op[2] & 0xe0)
10725 {
10726 case 0x00:
10727 goto op_semantics_89;
10728 break;
10729 default: UNSUPPORTED(); break;
10730 }
10731 break;
10732 case 0x7c:
10733 GETBYTE ();
10734 switch (op[2] & 0xf0)
10735 {
10736 case 0x20:
10737 goto op_semantics_78;
10738 break;
10739 case 0x40:
10740 goto op_semantics_79;
10741 break;
10742 case 0x50:
10743 goto op_semantics_80;
10744 break;
10745 case 0x60:
10746 goto op_semantics_81;
10747 break;
10748 case 0x70:
10749 goto op_semantics_82;
10750 break;
10751 case 0x80:
10752 goto op_semantics_83;
10753 break;
10754 case 0x90:
10755 goto op_semantics_84;
10756 break;
10757 case 0xc0:
10758 goto op_semantics_85;
10759 break;
10760 case 0xd0:
10761 goto op_semantics_86;
10762 break;
10763 case 0xe0:
10764 goto op_semantics_87;
10765 break;
10766 case 0xf0:
10767 goto op_semantics_88;
10768 break;
10769 default: UNSUPPORTED(); break;
10770 }
10771 break;
10772 case 0x7f:
10773 GETBYTE ();
10774 switch (op[2] & 0xe0)
10775 {
10776 case 0x00:
10777 goto op_semantics_89;
10778 break;
10779 default: UNSUPPORTED(); break;
10780 }
10781 break;
10782 case 0x80:
10783 GETBYTE ();
10784 switch (op[2] & 0x00)
10785 {
10786 case 0x00:
10787 op_semantics_90:
10788 {
10789 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
f9c7014e 10790#line 656 "rx-decode.opc"
c7927a3c 10791 int immmm AU = op[1] & 0x1f;
f9c7014e 10792#line 656 "rx-decode.opc"
c7927a3c 10793 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 10794#line 656 "rx-decode.opc"
c7927a3c
NC		 10795 int rdst AU = op[2] & 0x0f;
10796 if (trace)
10797 {
10798 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10799 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10800 op[0], op[1], op[2]);
10801 printf (" immmm = 0x%x,", immmm);
10802 printf (" rsrc = 0x%x,", rsrc);
10803 printf (" rdst = 0x%x\n", rdst);
10804 }
10805 SYNTAX("shlr #%2, %1, %0");
f9c7014e 10806#line 656 "rx-decode.opc"
3cf79a01 10807 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
c7927a3c
NC		 10808
10809 /*----------------------------------------------------------------------*/
10810 /* ROTATE */
10811
10812 }
10813 break;
10814 }
10815 break;
10816 case 0x81:
10817 GETBYTE ();
10818 switch (op[2] & 0x00)
10819 {
10820 case 0x00:
10821 goto op_semantics_90;
10822 break;
10823 }
10824 break;
10825 case 0x82:
10826 GETBYTE ();
10827 switch (op[2] & 0x00)
10828 {
10829 case 0x00:
10830 goto op_semantics_90;
10831 break;
10832 }
10833 break;
10834 case 0x83:
10835 GETBYTE ();
10836 switch (op[2] & 0x00)
10837 {
10838 case 0x00:
10839 goto op_semantics_90;
10840 break;
10841 }
10842 break;
10843 case 0x84:
10844 GETBYTE ();
10845 switch (op[2] & 0x00)
10846 {
10847 case 0x00:
10848 goto op_semantics_90;
10849 break;
10850 }
10851 break;
10852 case 0x85:
10853 GETBYTE ();
10854 switch (op[2] & 0x00)
10855 {
10856 case 0x00:
10857 goto op_semantics_90;
10858 break;
10859 }
10860 break;
10861 case 0x86:
10862 GETBYTE ();
10863 switch (op[2] & 0x00)
10864 {
10865 case 0x00:
10866 goto op_semantics_90;
10867 break;
10868 }
10869 break;
10870 case 0x87:
10871 GETBYTE ();
10872 switch (op[2] & 0x00)
10873 {
10874 case 0x00:
10875 goto op_semantics_90;
10876 break;
10877 }
10878 break;
10879 case 0x88:
10880 GETBYTE ();
10881 switch (op[2] & 0x00)
10882 {
10883 case 0x00:
10884 goto op_semantics_90;
10885 break;
10886 }
10887 break;
10888 case 0x89:
10889 GETBYTE ();
10890 switch (op[2] & 0x00)
10891 {
10892 case 0x00:
10893 goto op_semantics_90;
10894 break;
10895 }
10896 break;
10897 case 0x8a:
10898 GETBYTE ();
10899 switch (op[2] & 0x00)
10900 {
10901 case 0x00:
10902 goto op_semantics_90;
10903 break;
10904 }
10905 break;
10906 case 0x8b:
10907 GETBYTE ();
10908 switch (op[2] & 0x00)
10909 {
10910 case 0x00:
10911 goto op_semantics_90;
10912 break;
10913 }
10914 break;
10915 case 0x8c:
10916 GETBYTE ();
10917 switch (op[2] & 0x00)
10918 {
10919 case 0x00:
10920 goto op_semantics_90;
10921 break;
10922 }
10923 break;
10924 case 0x8d:
10925 GETBYTE ();
10926 switch (op[2] & 0x00)
10927 {
10928 case 0x00:
10929 goto op_semantics_90;
10930 break;
10931 }
10932 break;
10933 case 0x8e:
10934 GETBYTE ();
10935 switch (op[2] & 0x00)
10936 {
10937 case 0x00:
10938 goto op_semantics_90;
10939 break;
10940 }
10941 break;
10942 case 0x8f:
10943 GETBYTE ();
10944 switch (op[2] & 0x00)
10945 {
10946 case 0x00:
10947 goto op_semantics_90;
10948 break;
10949 }
10950 break;
10951 case 0x90:
10952 GETBYTE ();
10953 switch (op[2] & 0x00)
10954 {
10955 case 0x00:
10956 goto op_semantics_90;
10957 break;
10958 }
10959 break;
10960 case 0x91:
10961 GETBYTE ();
10962 switch (op[2] & 0x00)
10963 {
10964 case 0x00:
10965 goto op_semantics_90;
10966 break;
10967 }
10968 break;
10969 case 0x92:
10970 GETBYTE ();
10971 switch (op[2] & 0x00)
10972 {
10973 case 0x00:
10974 goto op_semantics_90;
10975 break;
10976 }
10977 break;
10978 case 0x93:
10979 GETBYTE ();
10980 switch (op[2] & 0x00)
10981 {
10982 case 0x00:
10983 goto op_semantics_90;
10984 break;
10985 }
10986 break;
10987 case 0x94:
10988 GETBYTE ();
10989 switch (op[2] & 0x00)
10990 {
10991 case 0x00:
10992 goto op_semantics_90;
10993 break;
10994 }
10995 break;
10996 case 0x95:
10997 GETBYTE ();
10998 switch (op[2] & 0x00)
10999 {
11000 case 0x00:
11001 goto op_semantics_90;
11002 break;
11003 }
11004 break;
11005 case 0x96:
11006 GETBYTE ();
11007 switch (op[2] & 0x00)
11008 {
11009 case 0x00:
11010 goto op_semantics_90;
11011 break;
11012 }
11013 break;
11014 case 0x97:
11015 GETBYTE ();
11016 switch (op[2] & 0x00)
11017 {
11018 case 0x00:
11019 goto op_semantics_90;
11020 break;
11021 }
11022 break;
11023 case 0x98:
11024 GETBYTE ();
11025 switch (op[2] & 0x00)
11026 {
11027 case 0x00:
11028 goto op_semantics_90;
11029 break;
11030 }
11031 break;
11032 case 0x99:
11033 GETBYTE ();
11034 switch (op[2] & 0x00)
11035 {
11036 case 0x00:
11037 goto op_semantics_90;
11038 break;
11039 }
11040 break;
11041 case 0x9a:
11042 GETBYTE ();
11043 switch (op[2] & 0x00)
11044 {
11045 case 0x00:
11046 goto op_semantics_90;
11047 break;
11048 }
11049 break;
11050 case 0x9b:
11051 GETBYTE ();
11052 switch (op[2] & 0x00)
11053 {
11054 case 0x00:
11055 goto op_semantics_90;
11056 break;
11057 }
11058 break;
11059 case 0x9c:
11060 GETBYTE ();
11061 switch (op[2] & 0x00)
11062 {
11063 case 0x00:
11064 goto op_semantics_90;
11065 break;
11066 }
11067 break;
11068 case 0x9d:
11069 GETBYTE ();
11070 switch (op[2] & 0x00)
11071 {
11072 case 0x00:
11073 goto op_semantics_90;
11074 break;
11075 }
11076 break;
11077 case 0x9e:
11078 GETBYTE ();
11079 switch (op[2] & 0x00)
11080 {
11081 case 0x00:
11082 goto op_semantics_90;
11083 break;
11084 }
11085 break;
11086 case 0x9f:
11087 GETBYTE ();
11088 switch (op[2] & 0x00)
11089 {
11090 case 0x00:
11091 goto op_semantics_90;
11092 break;
11093 }
11094 break;
11095 case 0xa0:
11096 GETBYTE ();
11097 switch (op[2] & 0x00)
11098 {
11099 case 0x00:
11100 op_semantics_91:
11101 {
11102 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
f9c7014e 11103#line 646 "rx-decode.opc"
c7927a3c 11104 int immmm AU = op[1] & 0x1f;
f9c7014e 11105#line 646 "rx-decode.opc"
c7927a3c 11106 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 11107#line 646 "rx-decode.opc"
c7927a3c
NC		 11108 int rdst AU = op[2] & 0x0f;
11109 if (trace)
11110 {
11111 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11112 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11113 op[0], op[1], op[2]);
11114 printf (" immmm = 0x%x,", immmm);
11115 printf (" rsrc = 0x%x,", rsrc);
11116 printf (" rdst = 0x%x\n", rdst);
11117 }
11118 SYNTAX("shar #%2, %1, %0");
f9c7014e 11119#line 646 "rx-decode.opc"
3cf79a01 11120 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
c7927a3c
NC		 11121
11122
11123 }
11124 break;
11125 }
11126 break;
11127 case 0xa1:
11128 GETBYTE ();
11129 switch (op[2] & 0x00)
11130 {
11131 case 0x00:
11132 goto op_semantics_91;
11133 break;
11134 }
11135 break;
11136 case 0xa2:
11137 GETBYTE ();
11138 switch (op[2] & 0x00)
11139 {
11140 case 0x00:
11141 goto op_semantics_91;
11142 break;
11143 }
11144 break;
11145 case 0xa3:
11146 GETBYTE ();
11147 switch (op[2] & 0x00)
11148 {
11149 case 0x00:
11150 goto op_semantics_91;
11151 break;
11152 }
11153 break;
11154 case 0xa4:
11155 GETBYTE ();
11156 switch (op[2] & 0x00)
11157 {
11158 case 0x00:
11159 goto op_semantics_91;
11160 break;
11161 }
11162 break;
11163 case 0xa5:
11164 GETBYTE ();
11165 switch (op[2] & 0x00)
11166 {
11167 case 0x00:
11168 goto op_semantics_91;
11169 break;
11170 }
11171 break;
11172 case 0xa6:
11173 GETBYTE ();
11174 switch (op[2] & 0x00)
11175 {
11176 case 0x00:
11177 goto op_semantics_91;
11178 break;
11179 }
11180 break;
11181 case 0xa7:
11182 GETBYTE ();
11183 switch (op[2] & 0x00)
11184 {
11185 case 0x00:
11186 goto op_semantics_91;
11187 break;
11188 }
11189 break;
11190 case 0xa8:
11191 GETBYTE ();
11192 switch (op[2] & 0x00)
11193 {
11194 case 0x00:
11195 goto op_semantics_91;
11196 break;
11197 }
11198 break;
11199 case 0xa9:
11200 GETBYTE ();
11201 switch (op[2] & 0x00)
11202 {
11203 case 0x00:
11204 goto op_semantics_91;
11205 break;
11206 }
11207 break;
11208 case 0xaa:
11209 GETBYTE ();
11210 switch (op[2] & 0x00)
11211 {
11212 case 0x00:
11213 goto op_semantics_91;
11214 break;
11215 }
11216 break;
11217 case 0xab:
11218 GETBYTE ();
11219 switch (op[2] & 0x00)
11220 {
11221 case 0x00:
11222 goto op_semantics_91;
11223 break;
11224 }
11225 break;
11226 case 0xac:
11227 GETBYTE ();
11228 switch (op[2] & 0x00)
11229 {
11230 case 0x00:
11231 goto op_semantics_91;
11232 break;
11233 }
11234 break;
11235 case 0xad:
11236 GETBYTE ();
11237 switch (op[2] & 0x00)
11238 {
11239 case 0x00:
11240 goto op_semantics_91;
11241 break;
11242 }
11243 break;
11244 case 0xae:
11245 GETBYTE ();
11246 switch (op[2] & 0x00)
11247 {
11248 case 0x00:
11249 goto op_semantics_91;
11250 break;
11251 }
11252 break;
11253 case 0xaf:
11254 GETBYTE ();
11255 switch (op[2] & 0x00)
11256 {
11257 case 0x00:
11258 goto op_semantics_91;
11259 break;
11260 }
11261 break;
11262 case 0xb0:
11263 GETBYTE ();
11264 switch (op[2] & 0x00)
11265 {
11266 case 0x00:
11267 goto op_semantics_91;
11268 break;
11269 }
11270 break;
11271 case 0xb1:
11272 GETBYTE ();
11273 switch (op[2] & 0x00)
11274 {
11275 case 0x00:
11276 goto op_semantics_91;
11277 break;
11278 }
11279 break;
11280 case 0xb2:
11281 GETBYTE ();
11282 switch (op[2] & 0x00)
11283 {
11284 case 0x00:
11285 goto op_semantics_91;
11286 break;
11287 }
11288 break;
11289 case 0xb3:
11290 GETBYTE ();
11291 switch (op[2] & 0x00)
11292 {
11293 case 0x00:
11294 goto op_semantics_91;
11295 break;
11296 }
11297 break;
11298 case 0xb4:
11299 GETBYTE ();
11300 switch (op[2] & 0x00)
11301 {
11302 case 0x00:
11303 goto op_semantics_91;
11304 break;
11305 }
11306 break;
11307 case 0xb5:
11308 GETBYTE ();
11309 switch (op[2] & 0x00)
11310 {
11311 case 0x00:
11312 goto op_semantics_91;
11313 break;
11314 }
11315 break;
11316 case 0xb6:
11317 GETBYTE ();
11318 switch (op[2] & 0x00)
11319 {
11320 case 0x00:
11321 goto op_semantics_91;
11322 break;
11323 }
11324 break;
11325 case 0xb7:
11326 GETBYTE ();
11327 switch (op[2] & 0x00)
11328 {
11329 case 0x00:
11330 goto op_semantics_91;
11331 break;
11332 }
11333 break;
11334 case 0xb8:
11335 GETBYTE ();
11336 switch (op[2] & 0x00)
11337 {
11338 case 0x00:
11339 goto op_semantics_91;
11340 break;
11341 }
11342 break;
11343 case 0xb9:
11344 GETBYTE ();
11345 switch (op[2] & 0x00)
11346 {
11347 case 0x00:
11348 goto op_semantics_91;
11349 break;
11350 }
11351 break;
11352 case 0xba:
11353 GETBYTE ();
11354 switch (op[2] & 0x00)
11355 {
11356 case 0x00:
11357 goto op_semantics_91;
11358 break;
11359 }
11360 break;
11361 case 0xbb:
11362 GETBYTE ();
11363 switch (op[2] & 0x00)
11364 {
11365 case 0x00:
11366 goto op_semantics_91;
11367 break;
11368 }
11369 break;
11370 case 0xbc:
11371 GETBYTE ();
11372 switch (op[2] & 0x00)
11373 {
11374 case 0x00:
11375 goto op_semantics_91;
11376 break;
11377 }
11378 break;
11379 case 0xbd:
11380 GETBYTE ();
11381 switch (op[2] & 0x00)
11382 {
11383 case 0x00:
11384 goto op_semantics_91;
11385 break;
11386 }
11387 break;
11388 case 0xbe:
11389 GETBYTE ();
11390 switch (op[2] & 0x00)
11391 {
11392 case 0x00:
11393 goto op_semantics_91;
11394 break;
11395 }
11396 break;
11397 case 0xbf:
11398 GETBYTE ();
11399 switch (op[2] & 0x00)
11400 {
11401 case 0x00:
11402 goto op_semantics_91;
11403 break;
11404 }
11405 break;
11406 case 0xc0:
11407 GETBYTE ();
11408 switch (op[2] & 0x00)
11409 {
11410 case 0x00:
11411 op_semantics_92:
11412 {
11413 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
f9c7014e 11414#line 636 "rx-decode.opc"
c7927a3c 11415 int immmm AU = op[1] & 0x1f;
f9c7014e 11416#line 636 "rx-decode.opc"
c7927a3c 11417 int rsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 11418#line 636 "rx-decode.opc"
c7927a3c
NC		 11419 int rdst AU = op[2] & 0x0f;
11420 if (trace)
11421 {
11422 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11423 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11424 op[0], op[1], op[2]);
11425 printf (" immmm = 0x%x,", immmm);
11426 printf (" rsrc = 0x%x,", rsrc);
11427 printf (" rdst = 0x%x\n", rdst);
11428 }
11429 SYNTAX("shll #%2, %1, %0");
f9c7014e 11430#line 636 "rx-decode.opc"
3cf79a01 11431 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 11432
11433
11434 }
11435 break;
11436 }
11437 break;
11438 case 0xc1:
11439 GETBYTE ();
11440 switch (op[2] & 0x00)
11441 {
11442 case 0x00:
11443 goto op_semantics_92;
11444 break;
11445 }
11446 break;
11447 case 0xc2:
11448 GETBYTE ();
11449 switch (op[2] & 0x00)
11450 {
11451 case 0x00:
11452 goto op_semantics_92;
11453 break;
11454 }
11455 break;
11456 case 0xc3:
11457 GETBYTE ();
11458 switch (op[2] & 0x00)
11459 {
11460 case 0x00:
11461 goto op_semantics_92;
11462 break;
11463 }
11464 break;
11465 case 0xc4:
11466 GETBYTE ();
11467 switch (op[2] & 0x00)
11468 {
11469 case 0x00:
11470 goto op_semantics_92;
11471 break;
11472 }
11473 break;
11474 case 0xc5:
11475 GETBYTE ();
11476 switch (op[2] & 0x00)
11477 {
11478 case 0x00:
11479 goto op_semantics_92;
11480 break;
11481 }
11482 break;
11483 case 0xc6:
11484 GETBYTE ();
11485 switch (op[2] & 0x00)
11486 {
11487 case 0x00:
11488 goto op_semantics_92;
11489 break;
11490 }
11491 break;
11492 case 0xc7:
11493 GETBYTE ();
11494 switch (op[2] & 0x00)
11495 {
11496 case 0x00:
11497 goto op_semantics_92;
11498 break;
11499 }
11500 break;
11501 case 0xc8:
11502 GETBYTE ();
11503 switch (op[2] & 0x00)
11504 {
11505 case 0x00:
11506 goto op_semantics_92;
11507 break;
11508 }
11509 break;
11510 case 0xc9:
11511 GETBYTE ();
11512 switch (op[2] & 0x00)
11513 {
11514 case 0x00:
11515 goto op_semantics_92;
11516 break;
11517 }
11518 break;
11519 case 0xca:
11520 GETBYTE ();
11521 switch (op[2] & 0x00)
11522 {
11523 case 0x00:
11524 goto op_semantics_92;
11525 break;
11526 }
11527 break;
11528 case 0xcb:
11529 GETBYTE ();
11530 switch (op[2] & 0x00)
11531 {
11532 case 0x00:
11533 goto op_semantics_92;
11534 break;
11535 }
11536 break;
11537 case 0xcc:
11538 GETBYTE ();
11539 switch (op[2] & 0x00)
11540 {
11541 case 0x00:
11542 goto op_semantics_92;
11543 break;
11544 }
11545 break;
11546 case 0xcd:
11547 GETBYTE ();
11548 switch (op[2] & 0x00)
11549 {
11550 case 0x00:
11551 goto op_semantics_92;
11552 break;
11553 }
11554 break;
11555 case 0xce:
11556 GETBYTE ();
11557 switch (op[2] & 0x00)
11558 {
11559 case 0x00:
11560 goto op_semantics_92;
11561 break;
11562 }
11563 break;
11564 case 0xcf:
11565 GETBYTE ();
11566 switch (op[2] & 0x00)
11567 {
11568 case 0x00:
11569 goto op_semantics_92;
11570 break;
11571 }
11572 break;
11573 case 0xd0:
11574 GETBYTE ();
11575 switch (op[2] & 0x00)
11576 {
11577 case 0x00:
11578 goto op_semantics_92;
11579 break;
11580 }
11581 break;
11582 case 0xd1:
11583 GETBYTE ();
11584 switch (op[2] & 0x00)
11585 {
11586 case 0x00:
11587 goto op_semantics_92;
11588 break;
11589 }
11590 break;
11591 case 0xd2:
11592 GETBYTE ();
11593 switch (op[2] & 0x00)
11594 {
11595 case 0x00:
11596 goto op_semantics_92;
11597 break;
11598 }
11599 break;
11600 case 0xd3:
11601 GETBYTE ();
11602 switch (op[2] & 0x00)
11603 {
11604 case 0x00:
11605 goto op_semantics_92;
11606 break;
11607 }
11608 break;
11609 case 0xd4:
11610 GETBYTE ();
11611 switch (op[2] & 0x00)
11612 {
11613 case 0x00:
11614 goto op_semantics_92;
11615 break;
11616 }
11617 break;
11618 case 0xd5:
11619 GETBYTE ();
11620 switch (op[2] & 0x00)
11621 {
11622 case 0x00:
11623 goto op_semantics_92;
11624 break;
11625 }
11626 break;
11627 case 0xd6:
11628 GETBYTE ();
11629 switch (op[2] & 0x00)
11630 {
11631 case 0x00:
11632 goto op_semantics_92;
11633 break;
11634 }
11635 break;
11636 case 0xd7:
11637 GETBYTE ();
11638 switch (op[2] & 0x00)
11639 {
11640 case 0x00:
11641 goto op_semantics_92;
11642 break;
11643 }
11644 break;
11645 case 0xd8:
11646 GETBYTE ();
11647 switch (op[2] & 0x00)
11648 {
11649 case 0x00:
11650 goto op_semantics_92;
11651 break;
11652 }
11653 break;
11654 case 0xd9:
11655 GETBYTE ();
11656 switch (op[2] & 0x00)
11657 {
11658 case 0x00:
11659 goto op_semantics_92;
11660 break;
11661 }
11662 break;
11663 case 0xda:
11664 GETBYTE ();
11665 switch (op[2] & 0x00)
11666 {
11667 case 0x00:
11668 goto op_semantics_92;
11669 break;
11670 }
11671 break;
11672 case 0xdb:
11673 GETBYTE ();
11674 switch (op[2] & 0x00)
11675 {
11676 case 0x00:
11677 goto op_semantics_92;
11678 break;
11679 }
11680 break;
11681 case 0xdc:
11682 GETBYTE ();
11683 switch (op[2] & 0x00)
11684 {
11685 case 0x00:
11686 goto op_semantics_92;
11687 break;
11688 }
11689 break;
11690 case 0xdd:
11691 GETBYTE ();
11692 switch (op[2] & 0x00)
11693 {
11694 case 0x00:
11695 goto op_semantics_92;
11696 break;
11697 }
11698 break;
11699 case 0xde:
11700 GETBYTE ();
11701 switch (op[2] & 0x00)
11702 {
11703 case 0x00:
11704 goto op_semantics_92;
11705 break;
11706 }
11707 break;
11708 case 0xdf:
11709 GETBYTE ();
11710 switch (op[2] & 0x00)
11711 {
11712 case 0x00:
11713 goto op_semantics_92;
11714 break;
11715 }
11716 break;
11717 case 0xe0:
11718 GETBYTE ();
11719 switch (op[2] & 0xf0)
11720 {
11721 case 0x00:
11722 case 0x10:
11723 case 0x20:
11724 case 0x30:
11725 case 0x40:
11726 case 0x50:
11727 case 0x60:
11728 case 0x70:
11729 case 0x80:
11730 case 0x90:
11731 case 0xa0:
11732 case 0xb0:
11733 case 0xc0:
11734 case 0xd0:
11735 case 0xe0:
11736 op_semantics_93:
11737 {
11738 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
f9c7014e 11739#line 902 "rx-decode.opc"
c7927a3c 11740 int bittt AU = op[1] & 0x1f;
f9c7014e 11741#line 902 "rx-decode.opc"
c7927a3c 11742 int cond AU = (op[2] >> 4) & 0x0f;
f9c7014e 11743#line 902 "rx-decode.opc"
c7927a3c
NC		 11744 int rdst AU = op[2] & 0x0f;
11745 if (trace)
11746 {
11747 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11748 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11749 op[0], op[1], op[2]);
11750 printf (" bittt = 0x%x,", bittt);
11751 printf (" cond = 0x%x,", cond);
11752 printf (" rdst = 0x%x\n", rdst);
11753 }
11754 SYNTAX("bm%2 #%1, %0%S0");
f9c7014e 11755#line 902 "rx-decode.opc"
c7927a3c
NC		 11756 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11757
11758 /*----------------------------------------------------------------------*/
11759 /* CONTROL REGISTERS */
11760
11761 }
11762 break;
11763 case 0xf0:
11764 op_semantics_94:
11765 {
11766 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
f9c7014e 11767#line 895 "rx-decode.opc"
c7927a3c 11768 int bittt AU = op[1] & 0x1f;
f9c7014e 11769#line 895 "rx-decode.opc"
c7927a3c
NC		 11770 int rdst AU = op[2] & 0x0f;
11771 if (trace)
11772 {
11773 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11774 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11775 op[0], op[1], op[2]);
11776 printf (" bittt = 0x%x,", bittt);
11777 printf (" rdst = 0x%x\n", rdst);
11778 }
11779 SYNTAX("bnot #%1, %0");
f9c7014e 11780#line 895 "rx-decode.opc"
c7927a3c
NC		 11781 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11782
11783
11784 }
11785 break;
11786 }
11787 break;
11788 case 0xe1:
11789 GETBYTE ();
11790 switch (op[2] & 0xf0)
11791 {
11792 case 0x00:
11793 case 0x10:
11794 case 0x20:
11795 case 0x30:
11796 case 0x40:
11797 case 0x50:
11798 case 0x60:
11799 case 0x70:
11800 case 0x80:
11801 case 0x90:
11802 case 0xa0:
11803 case 0xb0:
11804 case 0xc0:
11805 case 0xd0:
11806 case 0xe0:
11807 goto op_semantics_93;
11808 break;
11809 case 0xf0:
11810 goto op_semantics_94;
11811 break;
11812 }
11813 break;
11814 case 0xe2:
11815 GETBYTE ();
11816 switch (op[2] & 0xf0)
11817 {
11818 case 0x00:
11819 case 0x10:
11820 case 0x20:
11821 case 0x30:
11822 case 0x40:
11823 case 0x50:
11824 case 0x60:
11825 case 0x70:
11826 case 0x80:
11827 case 0x90:
11828 case 0xa0:
11829 case 0xb0:
11830 case 0xc0:
11831 case 0xd0:
11832 case 0xe0:
11833 goto op_semantics_93;
11834 break;
11835 case 0xf0:
11836 goto op_semantics_94;
11837 break;
11838 }
11839 break;
11840 case 0xe3:
11841 GETBYTE ();
11842 switch (op[2] & 0xf0)
11843 {
11844 case 0x00:
11845 case 0x10:
11846 case 0x20:
11847 case 0x30:
11848 case 0x40:
11849 case 0x50:
11850 case 0x60:
11851 case 0x70:
11852 case 0x80:
11853 case 0x90:
11854 case 0xa0:
11855 case 0xb0:
11856 case 0xc0:
11857 case 0xd0:
11858 case 0xe0:
11859 goto op_semantics_93;
11860 break;
11861 case 0xf0:
11862 goto op_semantics_94;
11863 break;
11864 }
11865 break;
11866 case 0xe4:
11867 GETBYTE ();
11868 switch (op[2] & 0xf0)
11869 {
11870 case 0x00:
11871 case 0x10:
11872 case 0x20:
11873 case 0x30:
11874 case 0x40:
11875 case 0x50:
11876 case 0x60:
11877 case 0x70:
11878 case 0x80:
11879 case 0x90:
11880 case 0xa0:
11881 case 0xb0:
11882 case 0xc0:
11883 case 0xd0:
11884 case 0xe0:
11885 goto op_semantics_93;
11886 break;
11887 case 0xf0:
11888 goto op_semantics_94;
11889 break;
11890 }
11891 break;
11892 case 0xe5:
11893 GETBYTE ();
11894 switch (op[2] & 0xf0)
11895 {
11896 case 0x00:
11897 case 0x10:
11898 case 0x20:
11899 case 0x30:
11900 case 0x40:
11901 case 0x50:
11902 case 0x60:
11903 case 0x70:
11904 case 0x80:
11905 case 0x90:
11906 case 0xa0:
11907 case 0xb0:
11908 case 0xc0:
11909 case 0xd0:
11910 case 0xe0:
11911 goto op_semantics_93;
11912 break;
11913 case 0xf0:
11914 goto op_semantics_94;
11915 break;
11916 }
11917 break;
11918 case 0xe6:
11919 GETBYTE ();
11920 switch (op[2] & 0xf0)
11921 {
11922 case 0x00:
11923 case 0x10:
11924 case 0x20:
11925 case 0x30:
11926 case 0x40:
11927 case 0x50:
11928 case 0x60:
11929 case 0x70:
11930 case 0x80:
11931 case 0x90:
11932 case 0xa0:
11933 case 0xb0:
11934 case 0xc0:
11935 case 0xd0:
11936 case 0xe0:
11937 goto op_semantics_93;
11938 break;
11939 case 0xf0:
11940 goto op_semantics_94;
11941 break;
11942 }
11943 break;
11944 case 0xe7:
11945 GETBYTE ();
11946 switch (op[2] & 0xf0)
11947 {
11948 case 0x00:
11949 case 0x10:
11950 case 0x20:
11951 case 0x30:
11952 case 0x40:
11953 case 0x50:
11954 case 0x60:
11955 case 0x70:
11956 case 0x80:
11957 case 0x90:
11958 case 0xa0:
11959 case 0xb0:
11960 case 0xc0:
11961 case 0xd0:
11962 case 0xe0:
11963 goto op_semantics_93;
11964 break;
11965 case 0xf0:
11966 goto op_semantics_94;
11967 break;
11968 }
11969 break;
11970 case 0xe8:
11971 GETBYTE ();
11972 switch (op[2] & 0xf0)
11973 {
11974 case 0x00:
11975 case 0x10:
11976 case 0x20:
11977 case 0x30:
11978 case 0x40:
11979 case 0x50:
11980 case 0x60:
11981 case 0x70:
11982 case 0x80:
11983 case 0x90:
11984 case 0xa0:
11985 case 0xb0:
11986 case 0xc0:
11987 case 0xd0:
11988 case 0xe0:
11989 goto op_semantics_93;
11990 break;
11991 case 0xf0:
11992 goto op_semantics_94;
11993 break;
11994 }
11995 break;
11996 case 0xe9:
11997 GETBYTE ();
11998 switch (op[2] & 0xf0)
11999 {
12000 case 0x00:
12001 case 0x10:
12002 case 0x20:
12003 case 0x30:
12004 case 0x40:
12005 case 0x50:
12006 case 0x60:
12007 case 0x70:
12008 case 0x80:
12009 case 0x90:
12010 case 0xa0:
12011 case 0xb0:
12012 case 0xc0:
12013 case 0xd0:
12014 case 0xe0:
12015 goto op_semantics_93;
12016 break;
12017 case 0xf0:
12018 goto op_semantics_94;
12019 break;
12020 }
12021 break;
12022 case 0xea:
12023 GETBYTE ();
12024 switch (op[2] & 0xf0)
12025 {
12026 case 0x00:
12027 case 0x10:
12028 case 0x20:
12029 case 0x30:
12030 case 0x40:
12031 case 0x50:
12032 case 0x60:
12033 case 0x70:
12034 case 0x80:
12035 case 0x90:
12036 case 0xa0:
12037 case 0xb0:
12038 case 0xc0:
12039 case 0xd0:
12040 case 0xe0:
12041 goto op_semantics_93;
12042 break;
12043 case 0xf0:
12044 goto op_semantics_94;
12045 break;
12046 }
12047 break;
12048 case 0xeb:
12049 GETBYTE ();
12050 switch (op[2] & 0xf0)
12051 {
12052 case 0x00:
12053 case 0x10:
12054 case 0x20:
12055 case 0x30:
12056 case 0x40:
12057 case 0x50:
12058 case 0x60:
12059 case 0x70:
12060 case 0x80:
12061 case 0x90:
12062 case 0xa0:
12063 case 0xb0:
12064 case 0xc0:
12065 case 0xd0:
12066 case 0xe0:
12067 goto op_semantics_93;
12068 break;
12069 case 0xf0:
12070 goto op_semantics_94;
12071 break;
12072 }
12073 break;
12074 case 0xec:
12075 GETBYTE ();
12076 switch (op[2] & 0xf0)
12077 {
12078 case 0x00:
12079 case 0x10:
12080 case 0x20:
12081 case 0x30:
12082 case 0x40:
12083 case 0x50:
12084 case 0x60:
12085 case 0x70:
12086 case 0x80:
12087 case 0x90:
12088 case 0xa0:
12089 case 0xb0:
12090 case 0xc0:
12091 case 0xd0:
12092 case 0xe0:
12093 goto op_semantics_93;
12094 break;
12095 case 0xf0:
12096 goto op_semantics_94;
12097 break;
12098 }
12099 break;
12100 case 0xed:
12101 GETBYTE ();
12102 switch (op[2] & 0xf0)
12103 {
12104 case 0x00:
12105 case 0x10:
12106 case 0x20:
12107 case 0x30:
12108 case 0x40:
12109 case 0x50:
12110 case 0x60:
12111 case 0x70:
12112 case 0x80:
12113 case 0x90:
12114 case 0xa0:
12115 case 0xb0:
12116 case 0xc0:
12117 case 0xd0:
12118 case 0xe0:
12119 goto op_semantics_93;
12120 break;
12121 case 0xf0:
12122 goto op_semantics_94;
12123 break;
12124 }
12125 break;
12126 case 0xee:
12127 GETBYTE ();
12128 switch (op[2] & 0xf0)
12129 {
12130 case 0x00:
12131 case 0x10:
12132 case 0x20:
12133 case 0x30:
12134 case 0x40:
12135 case 0x50:
12136 case 0x60:
12137 case 0x70:
12138 case 0x80:
12139 case 0x90:
12140 case 0xa0:
12141 case 0xb0:
12142 case 0xc0:
12143 case 0xd0:
12144 case 0xe0:
12145 goto op_semantics_93;
12146 break;
12147 case 0xf0:
12148 goto op_semantics_94;
12149 break;
12150 }
12151 break;
12152 case 0xef:
12153 GETBYTE ();
12154 switch (op[2] & 0xf0)
12155 {
12156 case 0x00:
12157 case 0x10:
12158 case 0x20:
12159 case 0x30:
12160 case 0x40:
12161 case 0x50:
12162 case 0x60:
12163 case 0x70:
12164 case 0x80:
12165 case 0x90:
12166 case 0xa0:
12167 case 0xb0:
12168 case 0xc0:
12169 case 0xd0:
12170 case 0xe0:
12171 goto op_semantics_93;
12172 break;
12173 case 0xf0:
12174 goto op_semantics_94;
12175 break;
12176 }
12177 break;
12178 case 0xf0:
12179 GETBYTE ();
12180 switch (op[2] & 0xf0)
12181 {
12182 case 0x00:
12183 case 0x10:
12184 case 0x20:
12185 case 0x30:
12186 case 0x40:
12187 case 0x50:
12188 case 0x60:
12189 case 0x70:
12190 case 0x80:
12191 case 0x90:
12192 case 0xa0:
12193 case 0xb0:
12194 case 0xc0:
12195 case 0xd0:
12196 case 0xe0:
12197 goto op_semantics_93;
12198 break;
12199 case 0xf0:
12200 goto op_semantics_94;
12201 break;
12202 }
12203 break;
12204 case 0xf1:
12205 GETBYTE ();
12206 switch (op[2] & 0xf0)
12207 {
12208 case 0x00:
12209 case 0x10:
12210 case 0x20:
12211 case 0x30:
12212 case 0x40:
12213 case 0x50:
12214 case 0x60:
12215 case 0x70:
12216 case 0x80:
12217 case 0x90:
12218 case 0xa0:
12219 case 0xb0:
12220 case 0xc0:
12221 case 0xd0:
12222 case 0xe0:
12223 goto op_semantics_93;
12224 break;
12225 case 0xf0:
12226 goto op_semantics_94;
12227 break;
12228 }
12229 break;
12230 case 0xf2:
12231 GETBYTE ();
12232 switch (op[2] & 0xf0)
12233 {
12234 case 0x00:
12235 case 0x10:
12236 case 0x20:
12237 case 0x30:
12238 case 0x40:
12239 case 0x50:
12240 case 0x60:
12241 case 0x70:
12242 case 0x80:
12243 case 0x90:
12244 case 0xa0:
12245 case 0xb0:
12246 case 0xc0:
12247 case 0xd0:
12248 case 0xe0:
12249 goto op_semantics_93;
12250 break;
12251 case 0xf0:
12252 goto op_semantics_94;
12253 break;
12254 }
12255 break;
12256 case 0xf3:
12257 GETBYTE ();
12258 switch (op[2] & 0xf0)
12259 {
12260 case 0x00:
12261 case 0x10:
12262 case 0x20:
12263 case 0x30:
12264 case 0x40:
12265 case 0x50:
12266 case 0x60:
12267 case 0x70:
12268 case 0x80:
12269 case 0x90:
12270 case 0xa0:
12271 case 0xb0:
12272 case 0xc0:
12273 case 0xd0:
12274 case 0xe0:
12275 goto op_semantics_93;
12276 break;
12277 case 0xf0:
12278 goto op_semantics_94;
12279 break;
12280 }
12281 break;
12282 case 0xf4:
12283 GETBYTE ();
12284 switch (op[2] & 0xf0)
12285 {
12286 case 0x00:
12287 case 0x10:
12288 case 0x20:
12289 case 0x30:
12290 case 0x40:
12291 case 0x50:
12292 case 0x60:
12293 case 0x70:
12294 case 0x80:
12295 case 0x90:
12296 case 0xa0:
12297 case 0xb0:
12298 case 0xc0:
12299 case 0xd0:
12300 case 0xe0:
12301 goto op_semantics_93;
12302 break;
12303 case 0xf0:
12304 goto op_semantics_94;
12305 break;
12306 }
12307 break;
12308 case 0xf5:
12309 GETBYTE ();
12310 switch (op[2] & 0xf0)
12311 {
12312 case 0x00:
12313 case 0x10:
12314 case 0x20:
12315 case 0x30:
12316 case 0x40:
12317 case 0x50:
12318 case 0x60:
12319 case 0x70:
12320 case 0x80:
12321 case 0x90:
12322 case 0xa0:
12323 case 0xb0:
12324 case 0xc0:
12325 case 0xd0:
12326 case 0xe0:
12327 goto op_semantics_93;
12328 break;
12329 case 0xf0:
12330 goto op_semantics_94;
12331 break;
12332 }
12333 break;
12334 case 0xf6:
12335 GETBYTE ();
12336 switch (op[2] & 0xf0)
12337 {
12338 case 0x00:
12339 case 0x10:
12340 case 0x20:
12341 case 0x30:
12342 case 0x40:
12343 case 0x50:
12344 case 0x60:
12345 case 0x70:
12346 case 0x80:
12347 case 0x90:
12348 case 0xa0:
12349 case 0xb0:
12350 case 0xc0:
12351 case 0xd0:
12352 case 0xe0:
12353 goto op_semantics_93;
12354 break;
12355 case 0xf0:
12356 goto op_semantics_94;
12357 break;
12358 }
12359 break;
12360 case 0xf7:
12361 GETBYTE ();
12362 switch (op[2] & 0xf0)
12363 {
12364 case 0x00:
12365 case 0x10:
12366 case 0x20:
12367 case 0x30:
12368 case 0x40:
12369 case 0x50:
12370 case 0x60:
12371 case 0x70:
12372 case 0x80:
12373 case 0x90:
12374 case 0xa0:
12375 case 0xb0:
12376 case 0xc0:
12377 case 0xd0:
12378 case 0xe0:
12379 goto op_semantics_93;
12380 break;
12381 case 0xf0:
12382 goto op_semantics_94;
12383 break;
12384 }
12385 break;
12386 case 0xf8:
12387 GETBYTE ();
12388 switch (op[2] & 0xf0)
12389 {
12390 case 0x00:
12391 case 0x10:
12392 case 0x20:
12393 case 0x30:
12394 case 0x40:
12395 case 0x50:
12396 case 0x60:
12397 case 0x70:
12398 case 0x80:
12399 case 0x90:
12400 case 0xa0:
12401 case 0xb0:
12402 case 0xc0:
12403 case 0xd0:
12404 case 0xe0:
12405 goto op_semantics_93;
12406 break;
12407 case 0xf0:
12408 goto op_semantics_94;
12409 break;
12410 }
12411 break;
12412 case 0xf9:
12413 GETBYTE ();
12414 switch (op[2] & 0xf0)
12415 {
12416 case 0x00:
12417 case 0x10:
12418 case 0x20:
12419 case 0x30:
12420 case 0x40:
12421 case 0x50:
12422 case 0x60:
12423 case 0x70:
12424 case 0x80:
12425 case 0x90:
12426 case 0xa0:
12427 case 0xb0:
12428 case 0xc0:
12429 case 0xd0:
12430 case 0xe0:
12431 goto op_semantics_93;
12432 break;
12433 case 0xf0:
12434 goto op_semantics_94;
12435 break;
12436 }
12437 break;
12438 case 0xfa:
12439 GETBYTE ();
12440 switch (op[2] & 0xf0)
12441 {
12442 case 0x00:
12443 case 0x10:
12444 case 0x20:
12445 case 0x30:
12446 case 0x40:
12447 case 0x50:
12448 case 0x60:
12449 case 0x70:
12450 case 0x80:
12451 case 0x90:
12452 case 0xa0:
12453 case 0xb0:
12454 case 0xc0:
12455 case 0xd0:
12456 case 0xe0:
12457 goto op_semantics_93;
12458 break;
12459 case 0xf0:
12460 goto op_semantics_94;
12461 break;
12462 }
12463 break;
12464 case 0xfb:
12465 GETBYTE ();
12466 switch (op[2] & 0xf0)
12467 {
12468 case 0x00:
12469 case 0x10:
12470 case 0x20:
12471 case 0x30:
12472 case 0x40:
12473 case 0x50:
12474 case 0x60:
12475 case 0x70:
12476 case 0x80:
12477 case 0x90:
12478 case 0xa0:
12479 case 0xb0:
12480 case 0xc0:
12481 case 0xd0:
12482 case 0xe0:
12483 goto op_semantics_93;
12484 break;
12485 case 0xf0:
12486 goto op_semantics_94;
12487 break;
12488 }
12489 break;
12490 case 0xfc:
12491 GETBYTE ();
12492 switch (op[2] & 0xf0)
12493 {
12494 case 0x00:
12495 case 0x10:
12496 case 0x20:
12497 case 0x30:
12498 case 0x40:
12499 case 0x50:
12500 case 0x60:
12501 case 0x70:
12502 case 0x80:
12503 case 0x90:
12504 case 0xa0:
12505 case 0xb0:
12506 case 0xc0:
12507 case 0xd0:
12508 case 0xe0:
12509 goto op_semantics_93;
12510 break;
12511 case 0xf0:
12512 goto op_semantics_94;
12513 break;
12514 }
12515 break;
12516 case 0xfd:
12517 GETBYTE ();
12518 switch (op[2] & 0xf0)
12519 {
12520 case 0x00:
12521 case 0x10:
12522 case 0x20:
12523 case 0x30:
12524 case 0x40:
12525 case 0x50:
12526 case 0x60:
12527 case 0x70:
12528 case 0x80:
12529 case 0x90:
12530 case 0xa0:
12531 case 0xb0:
12532 case 0xc0:
12533 case 0xd0:
12534 case 0xe0:
12535 goto op_semantics_93;
12536 break;
12537 case 0xf0:
12538 goto op_semantics_94;
12539 break;
12540 }
12541 break;
12542 case 0xfe:
12543 GETBYTE ();
12544 switch (op[2] & 0xf0)
12545 {
12546 case 0x00:
12547 case 0x10:
12548 case 0x20:
12549 case 0x30:
12550 case 0x40:
12551 case 0x50:
12552 case 0x60:
12553 case 0x70:
12554 case 0x80:
12555 case 0x90:
12556 case 0xa0:
12557 case 0xb0:
12558 case 0xc0:
12559 case 0xd0:
12560 case 0xe0:
12561 goto op_semantics_93;
12562 break;
12563 case 0xf0:
12564 goto op_semantics_94;
12565 break;
12566 }
12567 break;
12568 case 0xff:
12569 GETBYTE ();
12570 switch (op[2] & 0xf0)
12571 {
12572 case 0x00:
12573 case 0x10:
12574 case 0x20:
12575 case 0x30:
12576 case 0x40:
12577 case 0x50:
12578 case 0x60:
12579 case 0x70:
12580 case 0x80:
12581 case 0x90:
12582 case 0xa0:
12583 case 0xb0:
12584 case 0xc0:
12585 case 0xd0:
12586 case 0xe0:
12587 goto op_semantics_93;
12588 break;
12589 case 0xf0:
12590 goto op_semantics_94;
12591 break;
12592 }
12593 break;
12594 default: UNSUPPORTED(); break;
12595 }
12596 break;
12597 case 0xfe:
12598 GETBYTE ();
12599 switch (op[1] & 0xff)
12600 {
12601 case 0x00:
12602 GETBYTE ();
12603 switch (op[2] & 0x00)
12604 {
12605 case 0x00:
12606 op_semantics_95:
12607 {
12608 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
f9c7014e 12609#line 301 "rx-decode.opc"
c7927a3c 12610 int sz AU = (op[1] >> 4) & 0x03;
f9c7014e 12611#line 301 "rx-decode.opc"
c7927a3c 12612 int isrc AU = op[1] & 0x0f;
f9c7014e 12613#line 301 "rx-decode.opc"
c7927a3c 12614 int bsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 12615#line 301 "rx-decode.opc"
c7927a3c
NC		 12616 int rdst AU = op[2] & 0x0f;
12617 if (trace)
12618 {
12619 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12620 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12621 op[0], op[1], op[2]);
12622 printf (" sz = 0x%x,", sz);
12623 printf (" isrc = 0x%x,", isrc);
12624 printf (" bsrc = 0x%x,", bsrc);
12625 printf (" rdst = 0x%x\n", rdst);
12626 }
12627 SYNTAX("mov%s %0, [%1, %2]");
f9c7014e
DD		 12628#line 301 "rx-decode.opc"
12629 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
c7927a3c
NC		 12630
12631 }
12632 break;
12633 }
12634 break;
12635 case 0x01:
12636 GETBYTE ();
12637 switch (op[2] & 0x00)
12638 {
12639 case 0x00:
12640 goto op_semantics_95;
12641 break;
12642 }
12643 break;
12644 case 0x02:
12645 GETBYTE ();
12646 switch (op[2] & 0x00)
12647 {
12648 case 0x00:
12649 goto op_semantics_95;
12650 break;
12651 }
12652 break;
12653 case 0x03:
12654 GETBYTE ();
12655 switch (op[2] & 0x00)
12656 {
12657 case 0x00:
12658 goto op_semantics_95;
12659 break;
12660 }
12661 break;
12662 case 0x04:
12663 GETBYTE ();
12664 switch (op[2] & 0x00)
12665 {
12666 case 0x00:
12667 goto op_semantics_95;
12668 break;
12669 }
12670 break;
12671 case 0x05:
12672 GETBYTE ();
12673 switch (op[2] & 0x00)
12674 {
12675 case 0x00:
12676 goto op_semantics_95;
12677 break;
12678 }
12679 break;
12680 case 0x06:
12681 GETBYTE ();
12682 switch (op[2] & 0x00)
12683 {
12684 case 0x00:
12685 goto op_semantics_95;
12686 break;
12687 }
12688 break;
12689 case 0x07:
12690 GETBYTE ();
12691 switch (op[2] & 0x00)
12692 {
12693 case 0x00:
12694 goto op_semantics_95;
12695 break;
12696 }
12697 break;
12698 case 0x08:
12699 GETBYTE ();
12700 switch (op[2] & 0x00)
12701 {
12702 case 0x00:
12703 goto op_semantics_95;
12704 break;
12705 }
12706 break;
12707 case 0x09:
12708 GETBYTE ();
12709 switch (op[2] & 0x00)
12710 {
12711 case 0x00:
12712 goto op_semantics_95;
12713 break;
12714 }
12715 break;
12716 case 0x0a:
12717 GETBYTE ();
12718 switch (op[2] & 0x00)
12719 {
12720 case 0x00:
12721 goto op_semantics_95;
12722 break;
12723 }
12724 break;
12725 case 0x0b:
12726 GETBYTE ();
12727 switch (op[2] & 0x00)
12728 {
12729 case 0x00:
12730 goto op_semantics_95;
12731 break;
12732 }
12733 break;
12734 case 0x0c:
12735 GETBYTE ();
12736 switch (op[2] & 0x00)
12737 {
12738 case 0x00:
12739 goto op_semantics_95;
12740 break;
12741 }
12742 break;
12743 case 0x0d:
12744 GETBYTE ();
12745 switch (op[2] & 0x00)
12746 {
12747 case 0x00:
12748 goto op_semantics_95;
12749 break;
12750 }
12751 break;
12752 case 0x0e:
12753 GETBYTE ();
12754 switch (op[2] & 0x00)
12755 {
12756 case 0x00:
12757 goto op_semantics_95;
12758 break;
12759 }
12760 break;
12761 case 0x0f:
12762 GETBYTE ();
12763 switch (op[2] & 0x00)
12764 {
12765 case 0x00:
12766 goto op_semantics_95;
12767 break;
12768 }
12769 break;
12770 case 0x10:
12771 GETBYTE ();
12772 switch (op[2] & 0x00)
12773 {
12774 case 0x00:
12775 goto op_semantics_95;
12776 break;
12777 }
12778 break;
12779 case 0x11:
12780 GETBYTE ();
12781 switch (op[2] & 0x00)
12782 {
12783 case 0x00:
12784 goto op_semantics_95;
12785 break;
12786 }
12787 break;
12788 case 0x12:
12789 GETBYTE ();
12790 switch (op[2] & 0x00)
12791 {
12792 case 0x00:
12793 goto op_semantics_95;
12794 break;
12795 }
12796 break;
12797 case 0x13:
12798 GETBYTE ();
12799 switch (op[2] & 0x00)
12800 {
12801 case 0x00:
12802 goto op_semantics_95;
12803 break;
12804 }
12805 break;
12806 case 0x14:
12807 GETBYTE ();
12808 switch (op[2] & 0x00)
12809 {
12810 case 0x00:
12811 goto op_semantics_95;
12812 break;
12813 }
12814 break;
12815 case 0x15:
12816 GETBYTE ();
12817 switch (op[2] & 0x00)
12818 {
12819 case 0x00:
12820 goto op_semantics_95;
12821 break;
12822 }
12823 break;
12824 case 0x16:
12825 GETBYTE ();
12826 switch (op[2] & 0x00)
12827 {
12828 case 0x00:
12829 goto op_semantics_95;
12830 break;
12831 }
12832 break;
12833 case 0x17:
12834 GETBYTE ();
12835 switch (op[2] & 0x00)
12836 {
12837 case 0x00:
12838 goto op_semantics_95;
12839 break;
12840 }
12841 break;
12842 case 0x18:
12843 GETBYTE ();
12844 switch (op[2] & 0x00)
12845 {
12846 case 0x00:
12847 goto op_semantics_95;
12848 break;
12849 }
12850 break;
12851 case 0x19:
12852 GETBYTE ();
12853 switch (op[2] & 0x00)
12854 {
12855 case 0x00:
12856 goto op_semantics_95;
12857 break;
12858 }
12859 break;
12860 case 0x1a:
12861 GETBYTE ();
12862 switch (op[2] & 0x00)
12863 {
12864 case 0x00:
12865 goto op_semantics_95;
12866 break;
12867 }
12868 break;
12869 case 0x1b:
12870 GETBYTE ();
12871 switch (op[2] & 0x00)
12872 {
12873 case 0x00:
12874 goto op_semantics_95;
12875 break;
12876 }
12877 break;
12878 case 0x1c:
12879 GETBYTE ();
12880 switch (op[2] & 0x00)
12881 {
12882 case 0x00:
12883 goto op_semantics_95;
12884 break;
12885 }
12886 break;
12887 case 0x1d:
12888 GETBYTE ();
12889 switch (op[2] & 0x00)
12890 {
12891 case 0x00:
12892 goto op_semantics_95;
12893 break;
12894 }
12895 break;
12896 case 0x1e:
12897 GETBYTE ();
12898 switch (op[2] & 0x00)
12899 {
12900 case 0x00:
12901 goto op_semantics_95;
12902 break;
12903 }
12904 break;
12905 case 0x1f:
12906 GETBYTE ();
12907 switch (op[2] & 0x00)
12908 {
12909 case 0x00:
12910 goto op_semantics_95;
12911 break;
12912 }
12913 break;
12914 case 0x20:
12915 GETBYTE ();
12916 switch (op[2] & 0x00)
12917 {
12918 case 0x00:
12919 goto op_semantics_95;
12920 break;
12921 }
12922 break;
12923 case 0x21:
12924 GETBYTE ();
12925 switch (op[2] & 0x00)
12926 {
12927 case 0x00:
12928 goto op_semantics_95;
12929 break;
12930 }
12931 break;
12932 case 0x22:
12933 GETBYTE ();
12934 switch (op[2] & 0x00)
12935 {
12936 case 0x00:
12937 goto op_semantics_95;
12938 break;
12939 }
12940 break;
12941 case 0x23:
12942 GETBYTE ();
12943 switch (op[2] & 0x00)
12944 {
12945 case 0x00:
12946 goto op_semantics_95;
12947 break;
12948 }
12949 break;
12950 case 0x24:
12951 GETBYTE ();
12952 switch (op[2] & 0x00)
12953 {
12954 case 0x00:
12955 goto op_semantics_95;
12956 break;
12957 }
12958 break;
12959 case 0x25:
12960 GETBYTE ();
12961 switch (op[2] & 0x00)
12962 {
12963 case 0x00:
12964 goto op_semantics_95;
12965 break;
12966 }
12967 break;
12968 case 0x26:
12969 GETBYTE ();
12970 switch (op[2] & 0x00)
12971 {
12972 case 0x00:
12973 goto op_semantics_95;
12974 break;
12975 }
12976 break;
12977 case 0x27:
12978 GETBYTE ();
12979 switch (op[2] & 0x00)
12980 {
12981 case 0x00:
12982 goto op_semantics_95;
12983 break;
12984 }
12985 break;
12986 case 0x28:
12987 GETBYTE ();
12988 switch (op[2] & 0x00)
12989 {
12990 case 0x00:
12991 goto op_semantics_95;
12992 break;
12993 }
12994 break;
12995 case 0x29:
12996 GETBYTE ();
12997 switch (op[2] & 0x00)
12998 {
12999 case 0x00:
13000 goto op_semantics_95;
13001 break;
13002 }
13003 break;
13004 case 0x2a:
13005 GETBYTE ();
13006 switch (op[2] & 0x00)
13007 {
13008 case 0x00:
13009 goto op_semantics_95;
13010 break;
13011 }
13012 break;
13013 case 0x2b:
13014 GETBYTE ();
13015 switch (op[2] & 0x00)
13016 {
13017 case 0x00:
13018 goto op_semantics_95;
13019 break;
13020 }
13021 break;
13022 case 0x2c:
13023 GETBYTE ();
13024 switch (op[2] & 0x00)
13025 {
13026 case 0x00:
13027 goto op_semantics_95;
13028 break;
13029 }
13030 break;
13031 case 0x2d:
13032 GETBYTE ();
13033 switch (op[2] & 0x00)
13034 {
13035 case 0x00:
13036 goto op_semantics_95;
13037 break;
13038 }
13039 break;
13040 case 0x2e:
13041 GETBYTE ();
13042 switch (op[2] & 0x00)
13043 {
13044 case 0x00:
13045 goto op_semantics_95;
13046 break;
13047 }
13048 break;
13049 case 0x2f:
13050 GETBYTE ();
13051 switch (op[2] & 0x00)
13052 {
13053 case 0x00:
13054 goto op_semantics_95;
13055 break;
13056 }
13057 break;
13058 case 0x40:
13059 GETBYTE ();
13060 switch (op[2] & 0x00)
13061 {
13062 case 0x00:
13063 op_semantics_96:
13064 {
13065 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
f9c7014e 13066#line 298 "rx-decode.opc"
c7927a3c 13067 int sz AU = (op[1] >> 4) & 0x03;
f9c7014e 13068#line 298 "rx-decode.opc"
c7927a3c 13069 int isrc AU = op[1] & 0x0f;
f9c7014e 13070#line 298 "rx-decode.opc"
c7927a3c 13071 int bsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 13072#line 298 "rx-decode.opc"
c7927a3c
NC		 13073 int rdst AU = op[2] & 0x0f;
13074 if (trace)
13075 {
13076 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13077 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13078 op[0], op[1], op[2]);
13079 printf (" sz = 0x%x,", sz);
13080 printf (" isrc = 0x%x,", isrc);
13081 printf (" bsrc = 0x%x,", bsrc);
13082 printf (" rdst = 0x%x\n", rdst);
13083 }
13084 SYNTAX("mov%s [%1, %2], %0");
f9c7014e
DD		 13085#line 298 "rx-decode.opc"
13086 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
c7927a3c
NC		 13087
13088 }
13089 break;
13090 }
13091 break;
13092 case 0x41:
13093 GETBYTE ();
13094 switch (op[2] & 0x00)
13095 {
13096 case 0x00:
13097 goto op_semantics_96;
13098 break;
13099 }
13100 break;
13101 case 0x42:
13102 GETBYTE ();
13103 switch (op[2] & 0x00)
13104 {
13105 case 0x00:
13106 goto op_semantics_96;
13107 break;
13108 }
13109 break;
13110 case 0x43:
13111 GETBYTE ();
13112 switch (op[2] & 0x00)
13113 {
13114 case 0x00:
13115 goto op_semantics_96;
13116 break;
13117 }
13118 break;
13119 case 0x44:
13120 GETBYTE ();
13121 switch (op[2] & 0x00)
13122 {
13123 case 0x00:
13124 goto op_semantics_96;
13125 break;
13126 }
13127 break;
13128 case 0x45:
13129 GETBYTE ();
13130 switch (op[2] & 0x00)
13131 {
13132 case 0x00:
13133 goto op_semantics_96;
13134 break;
13135 }
13136 break;
13137 case 0x46:
13138 GETBYTE ();
13139 switch (op[2] & 0x00)
13140 {
13141 case 0x00:
13142 goto op_semantics_96;
13143 break;
13144 }
13145 break;
13146 case 0x47:
13147 GETBYTE ();
13148 switch (op[2] & 0x00)
13149 {
13150 case 0x00:
13151 goto op_semantics_96;
13152 break;
13153 }
13154 break;
13155 case 0x48:
13156 GETBYTE ();
13157 switch (op[2] & 0x00)
13158 {
13159 case 0x00:
13160 goto op_semantics_96;
13161 break;
13162 }
13163 break;
13164 case 0x49:
13165 GETBYTE ();
13166 switch (op[2] & 0x00)
13167 {
13168 case 0x00:
13169 goto op_semantics_96;
13170 break;
13171 }
13172 break;
13173 case 0x4a:
13174 GETBYTE ();
13175 switch (op[2] & 0x00)
13176 {
13177 case 0x00:
13178 goto op_semantics_96;
13179 break;
13180 }
13181 break;
13182 case 0x4b:
13183 GETBYTE ();
13184 switch (op[2] & 0x00)
13185 {
13186 case 0x00:
13187 goto op_semantics_96;
13188 break;
13189 }
13190 break;
13191 case 0x4c:
13192 GETBYTE ();
13193 switch (op[2] & 0x00)
13194 {
13195 case 0x00:
13196 goto op_semantics_96;
13197 break;
13198 }
13199 break;
13200 case 0x4d:
13201 GETBYTE ();
13202 switch (op[2] & 0x00)
13203 {
13204 case 0x00:
13205 goto op_semantics_96;
13206 break;
13207 }
13208 break;
13209 case 0x4e:
13210 GETBYTE ();
13211 switch (op[2] & 0x00)
13212 {
13213 case 0x00:
13214 goto op_semantics_96;
13215 break;
13216 }
13217 break;
13218 case 0x4f:
13219 GETBYTE ();
13220 switch (op[2] & 0x00)
13221 {
13222 case 0x00:
13223 goto op_semantics_96;
13224 break;
13225 }
13226 break;
13227 case 0x50:
13228 GETBYTE ();
13229 switch (op[2] & 0x00)
13230 {
13231 case 0x00:
13232 goto op_semantics_96;
13233 break;
13234 }
13235 break;
13236 case 0x51:
13237 GETBYTE ();
13238 switch (op[2] & 0x00)
13239 {
13240 case 0x00:
13241 goto op_semantics_96;
13242 break;
13243 }
13244 break;
13245 case 0x52:
13246 GETBYTE ();
13247 switch (op[2] & 0x00)
13248 {
13249 case 0x00:
13250 goto op_semantics_96;
13251 break;
13252 }
13253 break;
13254 case 0x53:
13255 GETBYTE ();
13256 switch (op[2] & 0x00)
13257 {
13258 case 0x00:
13259 goto op_semantics_96;
13260 break;
13261 }
13262 break;
13263 case 0x54:
13264 GETBYTE ();
13265 switch (op[2] & 0x00)
13266 {
13267 case 0x00:
13268 goto op_semantics_96;
13269 break;
13270 }
13271 break;
13272 case 0x55:
13273 GETBYTE ();
13274 switch (op[2] & 0x00)
13275 {
13276 case 0x00:
13277 goto op_semantics_96;
13278 break;
13279 }
13280 break;
13281 case 0x56:
13282 GETBYTE ();
13283 switch (op[2] & 0x00)
13284 {
13285 case 0x00:
13286 goto op_semantics_96;
13287 break;
13288 }
13289 break;
13290 case 0x57:
13291 GETBYTE ();
13292 switch (op[2] & 0x00)
13293 {
13294 case 0x00:
13295 goto op_semantics_96;
13296 break;
13297 }
13298 break;
13299 case 0x58:
13300 GETBYTE ();
13301 switch (op[2] & 0x00)
13302 {
13303 case 0x00:
13304 goto op_semantics_96;
13305 break;
13306 }
13307 break;
13308 case 0x59:
13309 GETBYTE ();
13310 switch (op[2] & 0x00)
13311 {
13312 case 0x00:
13313 goto op_semantics_96;
13314 break;
13315 }
13316 break;
13317 case 0x5a:
13318 GETBYTE ();
13319 switch (op[2] & 0x00)
13320 {
13321 case 0x00:
13322 goto op_semantics_96;
13323 break;
13324 }
13325 break;
13326 case 0x5b:
13327 GETBYTE ();
13328 switch (op[2] & 0x00)
13329 {
13330 case 0x00:
13331 goto op_semantics_96;
13332 break;
13333 }
13334 break;
13335 case 0x5c:
13336 GETBYTE ();
13337 switch (op[2] & 0x00)
13338 {
13339 case 0x00:
13340 goto op_semantics_96;
13341 break;
13342 }
13343 break;
13344 case 0x5d:
13345 GETBYTE ();
13346 switch (op[2] & 0x00)
13347 {
13348 case 0x00:
13349 goto op_semantics_96;
13350 break;
13351 }
13352 break;
13353 case 0x5e:
13354 GETBYTE ();
13355 switch (op[2] & 0x00)
13356 {
13357 case 0x00:
13358 goto op_semantics_96;
13359 break;
13360 }
13361 break;
13362 case 0x5f:
13363 GETBYTE ();
13364 switch (op[2] & 0x00)
13365 {
13366 case 0x00:
13367 goto op_semantics_96;
13368 break;
13369 }
13370 break;
13371 case 0x60:
13372 GETBYTE ();
13373 switch (op[2] & 0x00)
13374 {
13375 case 0x00:
13376 goto op_semantics_96;
13377 break;
13378 }
13379 break;
13380 case 0x61:
13381 GETBYTE ();
13382 switch (op[2] & 0x00)
13383 {
13384 case 0x00:
13385 goto op_semantics_96;
13386 break;
13387 }
13388 break;
13389 case 0x62:
13390 GETBYTE ();
13391 switch (op[2] & 0x00)
13392 {
13393 case 0x00:
13394 goto op_semantics_96;
13395 break;
13396 }
13397 break;
13398 case 0x63:
13399 GETBYTE ();
13400 switch (op[2] & 0x00)
13401 {
13402 case 0x00:
13403 goto op_semantics_96;
13404 break;
13405 }
13406 break;
13407 case 0x64:
13408 GETBYTE ();
13409 switch (op[2] & 0x00)
13410 {
13411 case 0x00:
13412 goto op_semantics_96;
13413 break;
13414 }
13415 break;
13416 case 0x65:
13417 GETBYTE ();
13418 switch (op[2] & 0x00)
13419 {
13420 case 0x00:
13421 goto op_semantics_96;
13422 break;
13423 }
13424 break;
13425 case 0x66:
13426 GETBYTE ();
13427 switch (op[2] & 0x00)
13428 {
13429 case 0x00:
13430 goto op_semantics_96;
13431 break;
13432 }
13433 break;
13434 case 0x67:
13435 GETBYTE ();
13436 switch (op[2] & 0x00)
13437 {
13438 case 0x00:
13439 goto op_semantics_96;
13440 break;
13441 }
13442 break;
13443 case 0x68:
13444 GETBYTE ();
13445 switch (op[2] & 0x00)
13446 {
13447 case 0x00:
13448 goto op_semantics_96;
13449 break;
13450 }
13451 break;
13452 case 0x69:
13453 GETBYTE ();
13454 switch (op[2] & 0x00)
13455 {
13456 case 0x00:
13457 goto op_semantics_96;
13458 break;
13459 }
13460 break;
13461 case 0x6a:
13462 GETBYTE ();
13463 switch (op[2] & 0x00)
13464 {
13465 case 0x00:
13466 goto op_semantics_96;
13467 break;
13468 }
13469 break;
13470 case 0x6b:
13471 GETBYTE ();
13472 switch (op[2] & 0x00)
13473 {
13474 case 0x00:
13475 goto op_semantics_96;
13476 break;
13477 }
13478 break;
13479 case 0x6c:
13480 GETBYTE ();
13481 switch (op[2] & 0x00)
13482 {
13483 case 0x00:
13484 goto op_semantics_96;
13485 break;
13486 }
13487 break;
13488 case 0x6d:
13489 GETBYTE ();
13490 switch (op[2] & 0x00)
13491 {
13492 case 0x00:
13493 goto op_semantics_96;
13494 break;
13495 }
13496 break;
13497 case 0x6e:
13498 GETBYTE ();
13499 switch (op[2] & 0x00)
13500 {
13501 case 0x00:
13502 goto op_semantics_96;
13503 break;
13504 }
13505 break;
13506 case 0x6f:
13507 GETBYTE ();
13508 switch (op[2] & 0x00)
13509 {
13510 case 0x00:
13511 goto op_semantics_96;
13512 break;
13513 }
13514 break;
13515 case 0xc0:
13516 GETBYTE ();
13517 switch (op[2] & 0x00)
13518 {
13519 case 0x00:
13520 op_semantics_97:
13521 {
13522 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
f9c7014e 13523#line 304 "rx-decode.opc"
c7927a3c 13524 int sz AU = (op[1] >> 4) & 0x03;
f9c7014e 13525#line 304 "rx-decode.opc"
c7927a3c 13526 int isrc AU = op[1] & 0x0f;
f9c7014e 13527#line 304 "rx-decode.opc"
c7927a3c 13528 int bsrc AU = (op[2] >> 4) & 0x0f;
f9c7014e 13529#line 304 "rx-decode.opc"
c7927a3c
NC		 13530 int rdst AU = op[2] & 0x0f;
13531 if (trace)
13532 {
13533 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13534 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13535 op[0], op[1], op[2]);
13536 printf (" sz = 0x%x,", sz);
13537 printf (" isrc = 0x%x,", isrc);
13538 printf (" bsrc = 0x%x,", bsrc);
13539 printf (" rdst = 0x%x\n", rdst);
13540 }
13541 SYNTAX("movu%s [%1, %2], %0");
f9c7014e
DD		 13542#line 304 "rx-decode.opc"
13543 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
c7927a3c
NC		 13544
13545 }
13546 break;
13547 }
13548 break;
13549 case 0xc1:
13550 GETBYTE ();
13551 switch (op[2] & 0x00)
13552 {
13553 case 0x00:
13554 goto op_semantics_97;
13555 break;
13556 }
13557 break;
13558 case 0xc2:
13559 GETBYTE ();
13560 switch (op[2] & 0x00)
13561 {
13562 case 0x00:
13563 goto op_semantics_97;
13564 break;
13565 }
13566 break;
13567 case 0xc3:
13568 GETBYTE ();
13569 switch (op[2] & 0x00)
13570 {
13571 case 0x00:
13572 goto op_semantics_97;
13573 break;
13574 }
13575 break;
13576 case 0xc4:
13577 GETBYTE ();
13578 switch (op[2] & 0x00)
13579 {
13580 case 0x00:
13581 goto op_semantics_97;
13582 break;
13583 }
13584 break;
13585 case 0xc5:
13586 GETBYTE ();
13587 switch (op[2] & 0x00)
13588 {
13589 case 0x00:
13590 goto op_semantics_97;
13591 break;
13592 }
13593 break;
13594 case 0xc6:
13595 GETBYTE ();
13596 switch (op[2] & 0x00)
13597 {
13598 case 0x00:
13599 goto op_semantics_97;
13600 break;
13601 }
13602 break;
13603 case 0xc7:
13604 GETBYTE ();
13605 switch (op[2] & 0x00)
13606 {
13607 case 0x00:
13608 goto op_semantics_97;
13609 break;
13610 }
13611 break;
13612 case 0xc8:
13613 GETBYTE ();
13614 switch (op[2] & 0x00)
13615 {
13616 case 0x00:
13617 goto op_semantics_97;
13618 break;
13619 }
13620 break;
13621 case 0xc9:
13622 GETBYTE ();
13623 switch (op[2] & 0x00)
13624 {
13625 case 0x00:
13626 goto op_semantics_97;
13627 break;
13628 }
13629 break;
13630 case 0xca:
13631 GETBYTE ();
13632 switch (op[2] & 0x00)
13633 {
13634 case 0x00:
13635 goto op_semantics_97;
13636 break;
13637 }
13638 break;
13639 case 0xcb:
13640 GETBYTE ();
13641 switch (op[2] & 0x00)
13642 {
13643 case 0x00:
13644 goto op_semantics_97;
13645 break;
13646 }
13647 break;
13648 case 0xcc:
13649 GETBYTE ();
13650 switch (op[2] & 0x00)
13651 {
13652 case 0x00:
13653 goto op_semantics_97;
13654 break;
13655 }
13656 break;
13657 case 0xcd:
13658 GETBYTE ();
13659 switch (op[2] & 0x00)
13660 {
13661 case 0x00:
13662 goto op_semantics_97;
13663 break;
13664 }
13665 break;
13666 case 0xce:
13667 GETBYTE ();
13668 switch (op[2] & 0x00)
13669 {
13670 case 0x00:
13671 goto op_semantics_97;
13672 break;
13673 }
13674 break;
13675 case 0xcf:
13676 GETBYTE ();
13677 switch (op[2] & 0x00)
13678 {
13679 case 0x00:
13680 goto op_semantics_97;
13681 break;
13682 }
13683 break;
13684 case 0xd0:
13685 GETBYTE ();
13686 switch (op[2] & 0x00)
13687 {
13688 case 0x00:
13689 goto op_semantics_97;
13690 break;
13691 }
13692 break;
13693 case 0xd1:
13694 GETBYTE ();
13695 switch (op[2] & 0x00)
13696 {
13697 case 0x00:
13698 goto op_semantics_97;
13699 break;
13700 }
13701 break;
13702 case 0xd2:
13703 GETBYTE ();
13704 switch (op[2] & 0x00)
13705 {
13706 case 0x00:
13707 goto op_semantics_97;
13708 break;
13709 }
13710 break;
13711 case 0xd3:
13712 GETBYTE ();
13713 switch (op[2] & 0x00)
13714 {
13715 case 0x00:
13716 goto op_semantics_97;
13717 break;
13718 }
13719 break;
13720 case 0xd4:
13721 GETBYTE ();
13722 switch (op[2] & 0x00)
13723 {
13724 case 0x00:
13725 goto op_semantics_97;
13726 break;
13727 }
13728 break;
13729 case 0xd5:
13730 GETBYTE ();
13731 switch (op[2] & 0x00)
13732 {
13733 case 0x00:
13734 goto op_semantics_97;
13735 break;
13736 }
13737 break;
13738 case 0xd6:
13739 GETBYTE ();
13740 switch (op[2] & 0x00)
13741 {
13742 case 0x00:
13743 goto op_semantics_97;
13744 break;
13745 }
13746 break;
13747 case 0xd7:
13748 GETBYTE ();
13749 switch (op[2] & 0x00)
13750 {
13751 case 0x00:
13752 goto op_semantics_97;
13753 break;
13754 }
13755 break;
13756 case 0xd8:
13757 GETBYTE ();
13758 switch (op[2] & 0x00)
13759 {
13760 case 0x00:
13761 goto op_semantics_97;
13762 break;
13763 }
13764 break;
13765 case 0xd9:
13766 GETBYTE ();
13767 switch (op[2] & 0x00)
13768 {
13769 case 0x00:
13770 goto op_semantics_97;
13771 break;
13772 }
13773 break;
13774 case 0xda:
13775 GETBYTE ();
13776 switch (op[2] & 0x00)
13777 {
13778 case 0x00:
13779 goto op_semantics_97;
13780 break;
13781 }
13782 break;
13783 case 0xdb:
13784 GETBYTE ();
13785 switch (op[2] & 0x00)
13786 {
13787 case 0x00:
13788 goto op_semantics_97;
13789 break;
13790 }
13791 break;
13792 case 0xdc:
13793 GETBYTE ();
13794 switch (op[2] & 0x00)
13795 {
13796 case 0x00:
13797 goto op_semantics_97;
13798 break;
13799 }
13800 break;
13801 case 0xdd:
13802 GETBYTE ();
13803 switch (op[2] & 0x00)
13804 {
13805 case 0x00:
13806 goto op_semantics_97;
13807 break;
13808 }
13809 break;
13810 case 0xde:
13811 GETBYTE ();
13812 switch (op[2] & 0x00)
13813 {
13814 case 0x00:
13815 goto op_semantics_97;
13816 break;
13817 }
13818 break;
13819 case 0xdf:
13820 GETBYTE ();
13821 switch (op[2] & 0x00)
13822 {
13823 case 0x00:
13824 goto op_semantics_97;
13825 break;
13826 }
13827 break;
13828 case 0xe0:
13829 GETBYTE ();
13830 switch (op[2] & 0x00)
13831 {
13832 case 0x00:
13833 goto op_semantics_97;
13834 break;
13835 }
13836 break;
13837 case 0xe1:
13838 GETBYTE ();
13839 switch (op[2] & 0x00)
13840 {
13841 case 0x00:
13842 goto op_semantics_97;
13843 break;
13844 }
13845 break;
13846 case 0xe2:
13847 GETBYTE ();
13848 switch (op[2] & 0x00)
13849 {
13850 case 0x00:
13851 goto op_semantics_97;
13852 break;
13853 }
13854 break;
13855 case 0xe3:
13856 GETBYTE ();
13857 switch (op[2] & 0x00)
13858 {
13859 case 0x00:
13860 goto op_semantics_97;
13861 break;
13862 }
13863 break;
13864 case 0xe4:
13865 GETBYTE ();
13866 switch (op[2] & 0x00)
13867 {
13868 case 0x00:
13869 goto op_semantics_97;
13870 break;
13871 }
13872 break;
13873 case 0xe5:
13874 GETBYTE ();
13875 switch (op[2] & 0x00)
13876 {
13877 case 0x00:
13878 goto op_semantics_97;
13879 break;
13880 }
13881 break;
13882 case 0xe6:
13883 GETBYTE ();
13884 switch (op[2] & 0x00)
13885 {
13886 case 0x00:
13887 goto op_semantics_97;
13888 break;
13889 }
13890 break;
13891 case 0xe7:
13892 GETBYTE ();
13893 switch (op[2] & 0x00)
13894 {
13895 case 0x00:
13896 goto op_semantics_97;
13897 break;
13898 }
13899 break;
13900 case 0xe8:
13901 GETBYTE ();
13902 switch (op[2] & 0x00)
13903 {
13904 case 0x00:
13905 goto op_semantics_97;
13906 break;
13907 }
13908 break;
13909 case 0xe9:
13910 GETBYTE ();
13911 switch (op[2] & 0x00)
13912 {
13913 case 0x00:
13914 goto op_semantics_97;
13915 break;
13916 }
13917 break;
13918 case 0xea:
13919 GETBYTE ();
13920 switch (op[2] & 0x00)
13921 {
13922 case 0x00:
13923 goto op_semantics_97;
13924 break;
13925 }
13926 break;
13927 case 0xeb:
13928 GETBYTE ();
13929 switch (op[2] & 0x00)
13930 {
13931 case 0x00:
13932 goto op_semantics_97;
13933 break;
13934 }
13935 break;
13936 case 0xec:
13937 GETBYTE ();
13938 switch (op[2] & 0x00)
13939 {
13940 case 0x00:
13941 goto op_semantics_97;
13942 break;
13943 }
13944 break;
13945 case 0xed:
13946 GETBYTE ();
13947 switch (op[2] & 0x00)
13948 {
13949 case 0x00:
13950 goto op_semantics_97;
13951 break;
13952 }
13953 break;
13954 case 0xee:
13955 GETBYTE ();
13956 switch (op[2] & 0x00)
13957 {
13958 case 0x00:
13959 goto op_semantics_97;
13960 break;
13961 }
13962 break;
13963 case 0xef:
13964 GETBYTE ();
13965 switch (op[2] & 0x00)
13966 {
13967 case 0x00:
13968 goto op_semantics_97;
13969 break;
13970 }
13971 break;
13972 default: UNSUPPORTED(); break;
13973 }
13974 break;
13975 case 0xff:
13976 GETBYTE ();
13977 switch (op[1] & 0xff)
13978 {
13979 case 0x00:
13980 GETBYTE ();
13981 switch (op[2] & 0x00)
13982 {
13983 case 0x00:
13984 op_semantics_98:
13985 {
13986 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
f9c7014e 13987#line 508 "rx-decode.opc"
c7927a3c 13988 int rdst AU = op[1] & 0x0f;
f9c7014e 13989#line 508 "rx-decode.opc"
c7927a3c 13990 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 13991#line 508 "rx-decode.opc"
c7927a3c
NC		 13992 int srcb AU = op[2] & 0x0f;
13993 if (trace)
13994 {
13995 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13996 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
13997 op[0], op[1], op[2]);
13998 printf (" rdst = 0x%x,", rdst);
13999 printf (" srca = 0x%x,", srca);
14000 printf (" srcb = 0x%x\n", srcb);
14001 }
14002 SYNTAX("sub %2, %1, %0");
f9c7014e 14003#line 508 "rx-decode.opc"
3cf79a01 14004 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
c7927a3c
NC		 14005
14006 /*----------------------------------------------------------------------*/
14007 /* SBB */
14008
14009 }
14010 break;
14011 }
14012 break;
14013 case 0x01:
14014 GETBYTE ();
14015 switch (op[2] & 0x00)
14016 {
14017 case 0x00:
14018 goto op_semantics_98;
14019 break;
14020 }
14021 break;
14022 case 0x02:
14023 GETBYTE ();
14024 switch (op[2] & 0x00)
14025 {
14026 case 0x00:
14027 goto op_semantics_98;
14028 break;
14029 }
14030 break;
14031 case 0x03:
14032 GETBYTE ();
14033 switch (op[2] & 0x00)
14034 {
14035 case 0x00:
14036 goto op_semantics_98;
14037 break;
14038 }
14039 break;
14040 case 0x04:
14041 GETBYTE ();
14042 switch (op[2] & 0x00)
14043 {
14044 case 0x00:
14045 goto op_semantics_98;
14046 break;
14047 }
14048 break;
14049 case 0x05:
14050 GETBYTE ();
14051 switch (op[2] & 0x00)
14052 {
14053 case 0x00:
14054 goto op_semantics_98;
14055 break;
14056 }
14057 break;
14058 case 0x06:
14059 GETBYTE ();
14060 switch (op[2] & 0x00)
14061 {
14062 case 0x00:
14063 goto op_semantics_98;
14064 break;
14065 }
14066 break;
14067 case 0x07:
14068 GETBYTE ();
14069 switch (op[2] & 0x00)
14070 {
14071 case 0x00:
14072 goto op_semantics_98;
14073 break;
14074 }
14075 break;
14076 case 0x08:
14077 GETBYTE ();
14078 switch (op[2] & 0x00)
14079 {
14080 case 0x00:
14081 goto op_semantics_98;
14082 break;
14083 }
14084 break;
14085 case 0x09:
14086 GETBYTE ();
14087 switch (op[2] & 0x00)
14088 {
14089 case 0x00:
14090 goto op_semantics_98;
14091 break;
14092 }
14093 break;
14094 case 0x0a:
14095 GETBYTE ();
14096 switch (op[2] & 0x00)
14097 {
14098 case 0x00:
14099 goto op_semantics_98;
14100 break;
14101 }
14102 break;
14103 case 0x0b:
14104 GETBYTE ();
14105 switch (op[2] & 0x00)
14106 {
14107 case 0x00:
14108 goto op_semantics_98;
14109 break;
14110 }
14111 break;
14112 case 0x0c:
14113 GETBYTE ();
14114 switch (op[2] & 0x00)
14115 {
14116 case 0x00:
14117 goto op_semantics_98;
14118 break;
14119 }
14120 break;
14121 case 0x0d:
14122 GETBYTE ();
14123 switch (op[2] & 0x00)
14124 {
14125 case 0x00:
14126 goto op_semantics_98;
14127 break;
14128 }
14129 break;
14130 case 0x0e:
14131 GETBYTE ();
14132 switch (op[2] & 0x00)
14133 {
14134 case 0x00:
14135 goto op_semantics_98;
14136 break;
14137 }
14138 break;
14139 case 0x0f:
14140 GETBYTE ();
14141 switch (op[2] & 0x00)
14142 {
14143 case 0x00:
14144 goto op_semantics_98;
14145 break;
14146 }
14147 break;
14148 case 0x20:
14149 GETBYTE ();
14150 switch (op[2] & 0x00)
14151 {
14152 case 0x00:
14153 op_semantics_99:
14154 {
14155 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
f9c7014e 14156#line 475 "rx-decode.opc"
c7927a3c 14157 int rdst AU = op[1] & 0x0f;
f9c7014e 14158#line 475 "rx-decode.opc"
c7927a3c 14159 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 14160#line 475 "rx-decode.opc"
c7927a3c
NC		 14161 int srcb AU = op[2] & 0x0f;
14162 if (trace)
14163 {
14164 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14165 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14166 op[0], op[1], op[2]);
14167 printf (" rdst = 0x%x,", rdst);
14168 printf (" srca = 0x%x,", srca);
14169 printf (" srcb = 0x%x\n", srcb);
14170 }
14171 SYNTAX("add %2, %1, %0");
f9c7014e 14172#line 475 "rx-decode.opc"
3cf79a01 14173 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
c7927a3c
NC		 14174
14175 /*----------------------------------------------------------------------*/
14176 /* CMP */
14177
14178 }
14179 break;
14180 }
14181 break;
14182 case 0x21:
14183 GETBYTE ();
14184 switch (op[2] & 0x00)
14185 {
14186 case 0x00:
14187 goto op_semantics_99;
14188 break;
14189 }
14190 break;
14191 case 0x22:
14192 GETBYTE ();
14193 switch (op[2] & 0x00)
14194 {
14195 case 0x00:
14196 goto op_semantics_99;
14197 break;
14198 }
14199 break;
14200 case 0x23:
14201 GETBYTE ();
14202 switch (op[2] & 0x00)
14203 {
14204 case 0x00:
14205 goto op_semantics_99;
14206 break;
14207 }
14208 break;
14209 case 0x24:
14210 GETBYTE ();
14211 switch (op[2] & 0x00)
14212 {
14213 case 0x00:
14214 goto op_semantics_99;
14215 break;
14216 }
14217 break;
14218 case 0x25:
14219 GETBYTE ();
14220 switch (op[2] & 0x00)
14221 {
14222 case 0x00:
14223 goto op_semantics_99;
14224 break;
14225 }
14226 break;
14227 case 0x26:
14228 GETBYTE ();
14229 switch (op[2] & 0x00)
14230 {
14231 case 0x00:
14232 goto op_semantics_99;
14233 break;
14234 }
14235 break;
14236 case 0x27:
14237 GETBYTE ();
14238 switch (op[2] & 0x00)
14239 {
14240 case 0x00:
14241 goto op_semantics_99;
14242 break;
14243 }
14244 break;
14245 case 0x28:
14246 GETBYTE ();
14247 switch (op[2] & 0x00)
14248 {
14249 case 0x00:
14250 goto op_semantics_99;
14251 break;
14252 }
14253 break;
14254 case 0x29:
14255 GETBYTE ();
14256 switch (op[2] & 0x00)
14257 {
14258 case 0x00:
14259 goto op_semantics_99;
14260 break;
14261 }
14262 break;
14263 case 0x2a:
14264 GETBYTE ();
14265 switch (op[2] & 0x00)
14266 {
14267 case 0x00:
14268 goto op_semantics_99;
14269 break;
14270 }
14271 break;
14272 case 0x2b:
14273 GETBYTE ();
14274 switch (op[2] & 0x00)
14275 {
14276 case 0x00:
14277 goto op_semantics_99;
14278 break;
14279 }
14280 break;
14281 case 0x2c:
14282 GETBYTE ();
14283 switch (op[2] & 0x00)
14284 {
14285 case 0x00:
14286 goto op_semantics_99;
14287 break;
14288 }
14289 break;
14290 case 0x2d:
14291 GETBYTE ();
14292 switch (op[2] & 0x00)
14293 {
14294 case 0x00:
14295 goto op_semantics_99;
14296 break;
14297 }
14298 break;
14299 case 0x2e:
14300 GETBYTE ();
14301 switch (op[2] & 0x00)
14302 {
14303 case 0x00:
14304 goto op_semantics_99;
14305 break;
14306 }
14307 break;
14308 case 0x2f:
14309 GETBYTE ();
14310 switch (op[2] & 0x00)
14311 {
14312 case 0x00:
14313 goto op_semantics_99;
14314 break;
14315 }
14316 break;
14317 case 0x30:
14318 GETBYTE ();
14319 switch (op[2] & 0x00)
14320 {
14321 case 0x00:
14322 op_semantics_100:
14323 {
14324 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
f9c7014e 14325#line 576 "rx-decode.opc"
c7927a3c 14326 int rdst AU = op[1] & 0x0f;
f9c7014e 14327#line 576 "rx-decode.opc"
c7927a3c 14328 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 14329#line 576 "rx-decode.opc"
c7927a3c
NC		 14330 int srcb AU = op[2] & 0x0f;
14331 if (trace)
14332 {
14333 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14334 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14335 op[0], op[1], op[2]);
14336 printf (" rdst = 0x%x,", rdst);
14337 printf (" srca = 0x%x,", srca);
14338 printf (" srcb = 0x%x\n", srcb);
14339 }
14340 SYNTAX("mul %2, %1, %0");
f9c7014e 14341#line 576 "rx-decode.opc"
3cf79a01 14342 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
c7927a3c
NC		 14343
14344 /*----------------------------------------------------------------------*/
14345 /* EMUL */
14346
14347 }
14348 break;
14349 }
14350 break;
14351 case 0x31:
14352 GETBYTE ();
14353 switch (op[2] & 0x00)
14354 {
14355 case 0x00:
14356 goto op_semantics_100;
14357 break;
14358 }
14359 break;
14360 case 0x32:
14361 GETBYTE ();
14362 switch (op[2] & 0x00)
14363 {
14364 case 0x00:
14365 goto op_semantics_100;
14366 break;
14367 }
14368 break;
14369 case 0x33:
14370 GETBYTE ();
14371 switch (op[2] & 0x00)
14372 {
14373 case 0x00:
14374 goto op_semantics_100;
14375 break;
14376 }
14377 break;
14378 case 0x34:
14379 GETBYTE ();
14380 switch (op[2] & 0x00)
14381 {
14382 case 0x00:
14383 goto op_semantics_100;
14384 break;
14385 }
14386 break;
14387 case 0x35:
14388 GETBYTE ();
14389 switch (op[2] & 0x00)
14390 {
14391 case 0x00:
14392 goto op_semantics_100;
14393 break;
14394 }
14395 break;
14396 case 0x36:
14397 GETBYTE ();
14398 switch (op[2] & 0x00)
14399 {
14400 case 0x00:
14401 goto op_semantics_100;
14402 break;
14403 }
14404 break;
14405 case 0x37:
14406 GETBYTE ();
14407 switch (op[2] & 0x00)
14408 {
14409 case 0x00:
14410 goto op_semantics_100;
14411 break;
14412 }
14413 break;
14414 case 0x38:
14415 GETBYTE ();
14416 switch (op[2] & 0x00)
14417 {
14418 case 0x00:
14419 goto op_semantics_100;
14420 break;
14421 }
14422 break;
14423 case 0x39:
14424 GETBYTE ();
14425 switch (op[2] & 0x00)
14426 {
14427 case 0x00:
14428 goto op_semantics_100;
14429 break;
14430 }
14431 break;
14432 case 0x3a:
14433 GETBYTE ();
14434 switch (op[2] & 0x00)
14435 {
14436 case 0x00:
14437 goto op_semantics_100;
14438 break;
14439 }
14440 break;
14441 case 0x3b:
14442 GETBYTE ();
14443 switch (op[2] & 0x00)
14444 {
14445 case 0x00:
14446 goto op_semantics_100;
14447 break;
14448 }
14449 break;
14450 case 0x3c:
14451 GETBYTE ();
14452 switch (op[2] & 0x00)
14453 {
14454 case 0x00:
14455 goto op_semantics_100;
14456 break;
14457 }
14458 break;
14459 case 0x3d:
14460 GETBYTE ();
14461 switch (op[2] & 0x00)
14462 {
14463 case 0x00:
14464 goto op_semantics_100;
14465 break;
14466 }
14467 break;
14468 case 0x3e:
14469 GETBYTE ();
14470 switch (op[2] & 0x00)
14471 {
14472 case 0x00:
14473 goto op_semantics_100;
14474 break;
14475 }
14476 break;
14477 case 0x3f:
14478 GETBYTE ();
14479 switch (op[2] & 0x00)
14480 {
14481 case 0x00:
14482 goto op_semantics_100;
14483 break;
14484 }
14485 break;
14486 case 0x40:
14487 GETBYTE ();
14488 switch (op[2] & 0x00)
14489 {
14490 case 0x00:
14491 op_semantics_101:
14492 {
14493 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
f9c7014e 14494#line 385 "rx-decode.opc"
c7927a3c 14495 int rdst AU = op[1] & 0x0f;
f9c7014e 14496#line 385 "rx-decode.opc"
c7927a3c 14497 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 14498#line 385 "rx-decode.opc"
c7927a3c
NC		 14499 int srcb AU = op[2] & 0x0f;
14500 if (trace)
14501 {
14502 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14503 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14504 op[0], op[1], op[2]);
14505 printf (" rdst = 0x%x,", rdst);
14506 printf (" srca = 0x%x,", srca);
14507 printf (" srcb = 0x%x\n", srcb);
14508 }
14509 SYNTAX("and %2, %1, %0");
f9c7014e 14510#line 385 "rx-decode.opc"
3cf79a01 14511 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
c7927a3c
NC		 14512
14513 /*----------------------------------------------------------------------*/
14514 /* OR */
14515
14516 }
14517 break;
14518 }
14519 break;
14520 case 0x41:
14521 GETBYTE ();
14522 switch (op[2] & 0x00)
14523 {
14524 case 0x00:
14525 goto op_semantics_101;
14526 break;
14527 }
14528 break;
14529 case 0x42:
14530 GETBYTE ();
14531 switch (op[2] & 0x00)
14532 {
14533 case 0x00:
14534 goto op_semantics_101;
14535 break;
14536 }
14537 break;
14538 case 0x43:
14539 GETBYTE ();
14540 switch (op[2] & 0x00)
14541 {
14542 case 0x00:
14543 goto op_semantics_101;
14544 break;
14545 }
14546 break;
14547 case 0x44:
14548 GETBYTE ();
14549 switch (op[2] & 0x00)
14550 {
14551 case 0x00:
14552 goto op_semantics_101;
14553 break;
14554 }
14555 break;
14556 case 0x45:
14557 GETBYTE ();
14558 switch (op[2] & 0x00)
14559 {
14560 case 0x00:
14561 goto op_semantics_101;
14562 break;
14563 }
14564 break;
14565 case 0x46:
14566 GETBYTE ();
14567 switch (op[2] & 0x00)
14568 {
14569 case 0x00:
14570 goto op_semantics_101;
14571 break;
14572 }
14573 break;
14574 case 0x47:
14575 GETBYTE ();
14576 switch (op[2] & 0x00)
14577 {
14578 case 0x00:
14579 goto op_semantics_101;
14580 break;
14581 }
14582 break;
14583 case 0x48:
14584 GETBYTE ();
14585 switch (op[2] & 0x00)
14586 {
14587 case 0x00:
14588 goto op_semantics_101;
14589 break;
14590 }
14591 break;
14592 case 0x49:
14593 GETBYTE ();
14594 switch (op[2] & 0x00)
14595 {
14596 case 0x00:
14597 goto op_semantics_101;
14598 break;
14599 }
14600 break;
14601 case 0x4a:
14602 GETBYTE ();
14603 switch (op[2] & 0x00)
14604 {
14605 case 0x00:
14606 goto op_semantics_101;
14607 break;
14608 }
14609 break;
14610 case 0x4b:
14611 GETBYTE ();
14612 switch (op[2] & 0x00)
14613 {
14614 case 0x00:
14615 goto op_semantics_101;
14616 break;
14617 }
14618 break;
14619 case 0x4c:
14620 GETBYTE ();
14621 switch (op[2] & 0x00)
14622 {
14623 case 0x00:
14624 goto op_semantics_101;
14625 break;
14626 }
14627 break;
14628 case 0x4d:
14629 GETBYTE ();
14630 switch (op[2] & 0x00)
14631 {
14632 case 0x00:
14633 goto op_semantics_101;
14634 break;
14635 }
14636 break;
14637 case 0x4e:
14638 GETBYTE ();
14639 switch (op[2] & 0x00)
14640 {
14641 case 0x00:
14642 goto op_semantics_101;
14643 break;
14644 }
14645 break;
14646 case 0x4f:
14647 GETBYTE ();
14648 switch (op[2] & 0x00)
14649 {
14650 case 0x00:
14651 goto op_semantics_101;
14652 break;
14653 }
14654 break;
14655 case 0x50:
14656 GETBYTE ();
14657 switch (op[2] & 0x00)
14658 {
14659 case 0x00:
14660 op_semantics_102:
14661 {
14662 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
f9c7014e 14663#line 403 "rx-decode.opc"
c7927a3c 14664 int rdst AU = op[1] & 0x0f;
f9c7014e 14665#line 403 "rx-decode.opc"
c7927a3c 14666 int srca AU = (op[2] >> 4) & 0x0f;
f9c7014e 14667#line 403 "rx-decode.opc"
c7927a3c
NC		 14668 int srcb AU = op[2] & 0x0f;
14669 if (trace)
14670 {
14671 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14672 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14673 op[0], op[1], op[2]);
14674 printf (" rdst = 0x%x,", rdst);
14675 printf (" srca = 0x%x,", srca);
14676 printf (" srcb = 0x%x\n", srcb);
14677 }
14678 SYNTAX("or %2, %1, %0");
f9c7014e 14679#line 403 "rx-decode.opc"
3cf79a01 14680 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
c7927a3c
NC		 14681
14682 /*----------------------------------------------------------------------*/
14683 /* XOR */
14684
14685 }
14686 break;
14687 }
14688 break;
14689 case 0x51:
14690 GETBYTE ();
14691 switch (op[2] & 0x00)
14692 {
14693 case 0x00:
14694 goto op_semantics_102;
14695 break;
14696 }
14697 break;
14698 case 0x52:
14699 GETBYTE ();
14700 switch (op[2] & 0x00)
14701 {
14702 case 0x00:
14703 goto op_semantics_102;
14704 break;
14705 }
14706 break;
14707 case 0x53:
14708 GETBYTE ();
14709 switch (op[2] & 0x00)
14710 {
14711 case 0x00:
14712 goto op_semantics_102;
14713 break;
14714 }
14715 break;
14716 case 0x54:
14717 GETBYTE ();
14718 switch (op[2] & 0x00)
14719 {
14720 case 0x00:
14721 goto op_semantics_102;
14722 break;
14723 }
14724 break;
14725 case 0x55:
14726 GETBYTE ();
14727 switch (op[2] & 0x00)
14728 {
14729 case 0x00:
14730 goto op_semantics_102;
14731 break;
14732 }
14733 break;
14734 case 0x56:
14735 GETBYTE ();
14736 switch (op[2] & 0x00)
14737 {
14738 case 0x00:
14739 goto op_semantics_102;
14740 break;
14741 }
14742 break;
14743 case 0x57:
14744 GETBYTE ();
14745 switch (op[2] & 0x00)
14746 {
14747 case 0x00:
14748 goto op_semantics_102;
14749 break;
14750 }
14751 break;
14752 case 0x58:
14753 GETBYTE ();
14754 switch (op[2] & 0x00)
14755 {
14756 case 0x00:
14757 goto op_semantics_102;
14758 break;
14759 }
14760 break;
14761 case 0x59:
14762 GETBYTE ();
14763 switch (op[2] & 0x00)
14764 {
14765 case 0x00:
14766 goto op_semantics_102;
14767 break;
14768 }
14769 break;
14770 case 0x5a:
14771 GETBYTE ();
14772 switch (op[2] & 0x00)
14773 {
14774 case 0x00:
14775 goto op_semantics_102;
14776 break;
14777 }
14778 break;
14779 case 0x5b:
14780 GETBYTE ();
14781 switch (op[2] & 0x00)
14782 {
14783 case 0x00:
14784 goto op_semantics_102;
14785 break;
14786 }
14787 break;
14788 case 0x5c:
14789 GETBYTE ();
14790 switch (op[2] & 0x00)
14791 {
14792 case 0x00:
14793 goto op_semantics_102;
14794 break;
14795 }
14796 break;
14797 case 0x5d:
14798 GETBYTE ();
14799 switch (op[2] & 0x00)
14800 {
14801 case 0x00:
14802 goto op_semantics_102;
14803 break;
14804 }
14805 break;
14806 case 0x5e:
14807 GETBYTE ();
14808 switch (op[2] & 0x00)
14809 {
14810 case 0x00:
14811 goto op_semantics_102;
14812 break;
14813 }
14814 break;
14815 case 0x5f:
14816 GETBYTE ();
14817 switch (op[2] & 0x00)
14818 {
14819 case 0x00:
14820 goto op_semantics_102;
14821 break;
14822 }
14823 break;
14824 default: UNSUPPORTED(); break;
14825 }
14826 break;
14827 default: UNSUPPORTED(); break;
14828 }
f9c7014e 14829#line 959 "rx-decode.opc"
c7927a3c
NC		 14830
14831 return rx->n_bytes;
14832}
GDB Binutils - Deliverables
This page took 0.742451 seconds and 4 git commands to generate.