bfd/
[binutils.git] / opcodes / rx-decode.c
blob8797b1baef28d0e15cde450e89575a59d0729aa8
1 #line 1 "rx-decode.opc"
2 /* -*- c -*- */
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
7 #include "config.h"
8 #include "ansidecl.h"
9 #include "opcode/rx.h"
11 #define RX_OPCODE_BIG_ENDIAN 0
13 typedef struct
15 RX_Opcode_Decoded * rx;
16 int (* getbyte)(void *);
17 void * ptr;
18 unsigned char * op;
19 } LocalData;
21 static int trace = 0;
23 #define BSIZE 0
24 #define WSIZE 1
25 #define LSIZE 2
27 /* These are for when the upper bits are "don't care" or "undefined". */
28 static int bwl[] =
30 RX_Byte,
31 RX_Word,
32 RX_Long
35 static int sbwl[] =
37 RX_SByte,
38 RX_SWord,
39 RX_Long
42 static int ubwl[] =
44 RX_UByte,
45 RX_UWord,
46 RX_Long
49 static int memex[] =
51 RX_SByte,
52 RX_SWord,
53 RX_Long,
54 RX_UWord
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 )
64 /* This is for the BWL and BW bitfields. */
65 static int SCALE[] = { 1, 2, 4 };
66 /* This is for the prefix size enum. */
67 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
69 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
70 16, 17, 0, 0, 0, 0, 0, 0 };
72 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
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. */
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)
91 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
92 #define SR(r) OP (1, RX_Operand_Register, r, 0)
93 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
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)
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)
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;
115 #define F(f) store_flags(rx, f)
117 #define AU ATTRIBUTE_UNUSED
118 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
120 #define SYNTAX(x) rx->syntax = x
122 #define UNSUPPORTED() \
123 rx->syntax = "*unknown*"
125 #define IMM(sf) immediate (sf, 0, ld)
126 #define IMMex(sf) immediate (sf, 1, ld)
128 static int
129 immediate (int sfield, int ex, LocalData * ld)
131 unsigned long i = 0, j;
133 switch (sfield)
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();
187 return i;
190 static void
191 rx_disp (int n, int type, int reg, int size, LocalData * ld)
193 int disp;
195 ld->rx->op[n].reg = reg;
196 switch (type)
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 ();
225 #define xO 8
226 #define xS 4
227 #define xZ 2
228 #define xC 1
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;
241 rx_decode_opcode (unsigned long pc AU,
242 RX_Opcode_Decoded * rx,
243 int (* getbyte)(void *),
244 void * ptr)
246 LocalData lds, * ld = &lds;
247 unsigned char op[20] = {0};
249 lds.rx = rx;
250 lds.getbyte = getbyte;
251 lds.ptr = ptr;
252 lds.op = op;
254 memset (rx, 0, sizeof (*rx));
255 BWL(LSIZE);
258 /*----------------------------------------------------------------------*/
259 /* MOV */
261 GETBYTE ();
262 switch (op[0] & 0xff)
264 case 0x00:
266 /** 0000 0000 brk */
267 if (trace)
269 printf ("\033[33m%s\033[0m %02x\n",
270 "/** 0000 0000 brk */",
271 op[0]);
273 SYNTAX("brk");
274 #line 941 "rx-decode.opc"
275 ID(brk);
278 break;
279 case 0x01:
281 /** 0000 0001 dbt */
282 if (trace)
284 printf ("\033[33m%s\033[0m %02x\n",
285 "/** 0000 0001 dbt */",
286 op[0]);
288 SYNTAX("dbt");
289 #line 944 "rx-decode.opc"
290 ID(dbt);
293 break;
294 case 0x02:
296 /** 0000 0010 rts */
297 if (trace)
299 printf ("\033[33m%s\033[0m %02x\n",
300 "/** 0000 0010 rts */",
301 op[0]);
303 SYNTAX("rts");
304 #line 730 "rx-decode.opc"
305 ID(rts);
307 /*----------------------------------------------------------------------*/
308 /* NOP */
311 break;
312 case 0x03:
314 /** 0000 0011 nop */
315 if (trace)
317 printf ("\033[33m%s\033[0m %02x\n",
318 "/** 0000 0011 nop */",
319 op[0]);
321 SYNTAX("nop");
322 #line 736 "rx-decode.opc"
323 ID(nop);
325 /*----------------------------------------------------------------------*/
326 /* STRING FUNCTIONS */
329 break;
330 case 0x04:
332 /** 0000 0100 bra.a %a0 */
333 if (trace)
335 printf ("\033[33m%s\033[0m %02x\n",
336 "/** 0000 0100 bra.a %a0 */",
337 op[0]);
339 SYNTAX("bra.a %a0");
340 #line 708 "rx-decode.opc"
341 ID(branch); DC(pc + IMMex(3));
344 break;
345 case 0x05:
347 /** 0000 0101 bsr.a %a0 */
348 if (trace)
350 printf ("\033[33m%s\033[0m %02x\n",
351 "/** 0000 0101 bsr.a %a0 */",
352 op[0]);
354 SYNTAX("bsr.a %a0");
355 #line 724 "rx-decode.opc"
356 ID(jsr); DC(pc + IMMex(3));
359 break;
360 case 0x06:
361 GETBYTE ();
362 switch (op[1] & 0xff)
364 case 0x00:
365 GETBYTE ();
366 switch (op[2] & 0x00)
368 case 0x00:
369 op_semantics_1:
371 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
372 #line 505 "rx-decode.opc"
373 int mx AU = (op[1] >> 6) & 0x03;
374 #line 505 "rx-decode.opc"
375 int ss AU = op[1] & 0x03;
376 #line 505 "rx-decode.opc"
377 int rsrc AU = (op[2] >> 4) & 0x0f;
378 #line 505 "rx-decode.opc"
379 int rdst AU = op[2] & 0x0f;
380 if (trace)
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);
390 SYNTAX("sub %2%S2, %1");
391 #line 505 "rx-decode.opc"
392 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
395 break;
397 break;
398 case 0x01:
399 GETBYTE ();
400 switch (op[2] & 0x00)
402 case 0x00:
403 goto op_semantics_1;
404 break;
406 break;
407 case 0x02:
408 GETBYTE ();
409 switch (op[2] & 0x00)
411 case 0x00:
412 goto op_semantics_1;
413 break;
415 break;
416 case 0x03:
417 GETBYTE ();
418 switch (op[2] & 0x00)
420 case 0x00:
421 goto op_semantics_1;
422 break;
424 break;
425 case 0x04:
426 GETBYTE ();
427 switch (op[2] & 0x00)
429 case 0x00:
430 op_semantics_2:
432 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
433 #line 493 "rx-decode.opc"
434 int mx AU = (op[1] >> 6) & 0x03;
435 #line 493 "rx-decode.opc"
436 int ss AU = op[1] & 0x03;
437 #line 493 "rx-decode.opc"
438 int rsrc AU = (op[2] >> 4) & 0x0f;
439 #line 493 "rx-decode.opc"
440 int rdst AU = op[2] & 0x0f;
441 if (trace)
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);
451 SYNTAX("cmp %2%S2, %1");
452 #line 493 "rx-decode.opc"
453 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
455 /*----------------------------------------------------------------------*/
456 /* SUB */
459 break;
461 break;
462 case 0x05:
463 GETBYTE ();
464 switch (op[2] & 0x00)
466 case 0x00:
467 goto op_semantics_2;
468 break;
470 break;
471 case 0x06:
472 GETBYTE ();
473 switch (op[2] & 0x00)
475 case 0x00:
476 goto op_semantics_2;
477 break;
479 break;
480 case 0x07:
481 GETBYTE ();
482 switch (op[2] & 0x00)
484 case 0x00:
485 goto op_semantics_2;
486 break;
488 break;
489 case 0x08:
490 GETBYTE ();
491 switch (op[2] & 0x00)
493 case 0x00:
494 op_semantics_3:
496 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
497 #line 469 "rx-decode.opc"
498 int mx AU = (op[1] >> 6) & 0x03;
499 #line 469 "rx-decode.opc"
500 int ss AU = op[1] & 0x03;
501 #line 469 "rx-decode.opc"
502 int rsrc AU = (op[2] >> 4) & 0x0f;
503 #line 469 "rx-decode.opc"
504 int rdst AU = op[2] & 0x0f;
505 if (trace)
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);
515 SYNTAX("add %1%S1, %0");
516 #line 469 "rx-decode.opc"
517 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
520 break;
522 break;
523 case 0x09:
524 GETBYTE ();
525 switch (op[2] & 0x00)
527 case 0x00:
528 goto op_semantics_3;
529 break;
531 break;
532 case 0x0a:
533 GETBYTE ();
534 switch (op[2] & 0x00)
536 case 0x00:
537 goto op_semantics_3;
538 break;
540 break;
541 case 0x0b:
542 GETBYTE ();
543 switch (op[2] & 0x00)
545 case 0x00:
546 goto op_semantics_3;
547 break;
549 break;
550 case 0x0c:
551 GETBYTE ();
552 switch (op[2] & 0x00)
554 case 0x00:
555 op_semantics_4:
557 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
558 #line 573 "rx-decode.opc"
559 int mx AU = (op[1] >> 6) & 0x03;
560 #line 573 "rx-decode.opc"
561 int ss AU = op[1] & 0x03;
562 #line 573 "rx-decode.opc"
563 int rsrc AU = (op[2] >> 4) & 0x0f;
564 #line 573 "rx-decode.opc"
565 int rdst AU = op[2] & 0x0f;
566 if (trace)
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);
576 SYNTAX("mul %1%S1, %0");
577 #line 573 "rx-decode.opc"
578 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
581 break;
583 break;
584 case 0x0d:
585 GETBYTE ();
586 switch (op[2] & 0x00)
588 case 0x00:
589 goto op_semantics_4;
590 break;
592 break;
593 case 0x0e:
594 GETBYTE ();
595 switch (op[2] & 0x00)
597 case 0x00:
598 goto op_semantics_4;
599 break;
601 break;
602 case 0x0f:
603 GETBYTE ();
604 switch (op[2] & 0x00)
606 case 0x00:
607 goto op_semantics_4;
608 break;
610 break;
611 case 0x10:
612 GETBYTE ();
613 switch (op[2] & 0x00)
615 case 0x00:
616 op_semantics_5:
618 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
619 #line 382 "rx-decode.opc"
620 int mx AU = (op[1] >> 6) & 0x03;
621 #line 382 "rx-decode.opc"
622 int ss AU = op[1] & 0x03;
623 #line 382 "rx-decode.opc"
624 int rsrc AU = (op[2] >> 4) & 0x0f;
625 #line 382 "rx-decode.opc"
626 int rdst AU = op[2] & 0x0f;
627 if (trace)
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);
637 SYNTAX("and %1%S1, %0");
638 #line 382 "rx-decode.opc"
639 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
642 break;
644 break;
645 case 0x11:
646 GETBYTE ();
647 switch (op[2] & 0x00)
649 case 0x00:
650 goto op_semantics_5;
651 break;
653 break;
654 case 0x12:
655 GETBYTE ();
656 switch (op[2] & 0x00)
658 case 0x00:
659 goto op_semantics_5;
660 break;
662 break;
663 case 0x13:
664 GETBYTE ();
665 switch (op[2] & 0x00)
667 case 0x00:
668 goto op_semantics_5;
669 break;
671 break;
672 case 0x14:
673 GETBYTE ();
674 switch (op[2] & 0x00)
676 case 0x00:
677 op_semantics_6:
679 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
680 #line 400 "rx-decode.opc"
681 int mx AU = (op[1] >> 6) & 0x03;
682 #line 400 "rx-decode.opc"
683 int ss AU = op[1] & 0x03;
684 #line 400 "rx-decode.opc"
685 int rsrc AU = (op[2] >> 4) & 0x0f;
686 #line 400 "rx-decode.opc"
687 int rdst AU = op[2] & 0x0f;
688 if (trace)
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);
698 SYNTAX("or %1%S1, %0");
699 #line 400 "rx-decode.opc"
700 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
703 break;
705 break;
706 case 0x15:
707 GETBYTE ();
708 switch (op[2] & 0x00)
710 case 0x00:
711 goto op_semantics_6;
712 break;
714 break;
715 case 0x16:
716 GETBYTE ();
717 switch (op[2] & 0x00)
719 case 0x00:
720 goto op_semantics_6;
721 break;
723 break;
724 case 0x17:
725 GETBYTE ();
726 switch (op[2] & 0x00)
728 case 0x00:
729 goto op_semantics_6;
730 break;
732 break;
733 case 0x20:
734 GETBYTE ();
735 switch (op[2] & 0xff)
737 case 0x00:
738 GETBYTE ();
739 switch (op[3] & 0x00)
741 case 0x00:
742 op_semantics_7:
744 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
745 #line 518 "rx-decode.opc"
746 int mx AU = (op[1] >> 6) & 0x03;
747 #line 518 "rx-decode.opc"
748 int sp AU = op[1] & 0x03;
749 #line 518 "rx-decode.opc"
750 int rsrc AU = (op[3] >> 4) & 0x0f;
751 #line 518 "rx-decode.opc"
752 int rdst AU = op[3] & 0x0f;
753 if (trace)
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);
763 SYNTAX("sbb %1%S1, %0");
764 #line 518 "rx-decode.opc"
765 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
767 /*----------------------------------------------------------------------*/
768 /* ABS */
771 break;
773 break;
774 case 0x04:
775 GETBYTE ();
776 switch (op[3] & 0x00)
778 case 0x00:
779 op_semantics_8:
781 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
782 #line 546 "rx-decode.opc"
783 int mx AU = (op[1] >> 6) & 0x03;
784 #line 546 "rx-decode.opc"
785 int ss AU = op[1] & 0x03;
786 #line 546 "rx-decode.opc"
787 int rsrc AU = (op[3] >> 4) & 0x0f;
788 #line 546 "rx-decode.opc"
789 int rdst AU = op[3] & 0x0f;
790 if (trace)
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);
800 SYNTAX("max %1%S1, %0");
801 #line 546 "rx-decode.opc"
802 ID(max); SPm(ss, rsrc, mx); DR(rdst);
804 /*----------------------------------------------------------------------*/
805 /* MIN */
808 break;
810 break;
811 case 0x05:
812 GETBYTE ();
813 switch (op[3] & 0x00)
815 case 0x00:
816 op_semantics_9:
818 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
819 #line 558 "rx-decode.opc"
820 int mx AU = (op[1] >> 6) & 0x03;
821 #line 558 "rx-decode.opc"
822 int ss AU = op[1] & 0x03;
823 #line 558 "rx-decode.opc"
824 int rsrc AU = (op[3] >> 4) & 0x0f;
825 #line 558 "rx-decode.opc"
826 int rdst AU = op[3] & 0x0f;
827 if (trace)
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);
837 SYNTAX("min %1%S1, %0");
838 #line 558 "rx-decode.opc"
839 ID(min); SPm(ss, rsrc, mx); DR(rdst);
841 /*----------------------------------------------------------------------*/
842 /* MUL */
845 break;
847 break;
848 case 0x06:
849 GETBYTE ();
850 switch (op[3] & 0x00)
852 case 0x00:
853 op_semantics_10:
855 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
856 #line 588 "rx-decode.opc"
857 int mx AU = (op[1] >> 6) & 0x03;
858 #line 588 "rx-decode.opc"
859 int ss AU = op[1] & 0x03;
860 #line 588 "rx-decode.opc"
861 int rsrc AU = (op[3] >> 4) & 0x0f;
862 #line 588 "rx-decode.opc"
863 int rdst AU = op[3] & 0x0f;
864 if (trace)
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);
874 SYNTAX("emul %1%S1, %0");
875 #line 588 "rx-decode.opc"
876 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
878 /*----------------------------------------------------------------------*/
879 /* EMULU */
882 break;
884 break;
885 case 0x07:
886 GETBYTE ();
887 switch (op[3] & 0x00)
889 case 0x00:
890 op_semantics_11:
892 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
893 #line 600 "rx-decode.opc"
894 int mx AU = (op[1] >> 6) & 0x03;
895 #line 600 "rx-decode.opc"
896 int ss AU = op[1] & 0x03;
897 #line 600 "rx-decode.opc"
898 int rsrc AU = (op[3] >> 4) & 0x0f;
899 #line 600 "rx-decode.opc"
900 int rdst AU = op[3] & 0x0f;
901 if (trace)
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);
911 SYNTAX("emulu %1%S1, %0");
912 #line 600 "rx-decode.opc"
913 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
915 /*----------------------------------------------------------------------*/
916 /* DIV */
919 break;
921 break;
922 case 0x08:
923 GETBYTE ();
924 switch (op[3] & 0x00)
926 case 0x00:
927 op_semantics_12:
929 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
930 #line 612 "rx-decode.opc"
931 int mx AU = (op[1] >> 6) & 0x03;
932 #line 612 "rx-decode.opc"
933 int ss AU = op[1] & 0x03;
934 #line 612 "rx-decode.opc"
935 int rsrc AU = (op[3] >> 4) & 0x0f;
936 #line 612 "rx-decode.opc"
937 int rdst AU = op[3] & 0x0f;
938 if (trace)
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);
948 SYNTAX("div %1%S1, %0");
949 #line 612 "rx-decode.opc"
950 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
952 /*----------------------------------------------------------------------*/
953 /* DIVU */
956 break;
958 break;
959 case 0x09:
960 GETBYTE ();
961 switch (op[3] & 0x00)
963 case 0x00:
964 op_semantics_13:
966 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
967 #line 624 "rx-decode.opc"
968 int mx AU = (op[1] >> 6) & 0x03;
969 #line 624 "rx-decode.opc"
970 int ss AU = op[1] & 0x03;
971 #line 624 "rx-decode.opc"
972 int rsrc AU = (op[3] >> 4) & 0x0f;
973 #line 624 "rx-decode.opc"
974 int rdst AU = op[3] & 0x0f;
975 if (trace)
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);
985 SYNTAX("divu %1%S1, %0");
986 #line 624 "rx-decode.opc"
987 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
989 /*----------------------------------------------------------------------*/
990 /* SHIFT */
993 break;
995 break;
996 case 0x0c:
997 GETBYTE ();
998 switch (op[3] & 0x00)
1000 case 0x00:
1001 op_semantics_14:
1003 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1004 #line 436 "rx-decode.opc"
1005 int mx AU = (op[1] >> 6) & 0x03;
1006 #line 436 "rx-decode.opc"
1007 int ss AU = op[1] & 0x03;
1008 #line 436 "rx-decode.opc"
1009 int rsrc AU = (op[3] >> 4) & 0x0f;
1010 #line 436 "rx-decode.opc"
1011 int rdst AU = op[3] & 0x0f;
1012 if (trace)
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);
1022 SYNTAX("tst %1%S1, %2");
1023 #line 436 "rx-decode.opc"
1024 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1026 /*----------------------------------------------------------------------*/
1027 /* NEG */
1030 break;
1032 break;
1033 case 0x0d:
1034 GETBYTE ();
1035 switch (op[3] & 0x00)
1037 case 0x00:
1038 op_semantics_15:
1040 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1041 #line 415 "rx-decode.opc"
1042 int mx AU = (op[1] >> 6) & 0x03;
1043 #line 415 "rx-decode.opc"
1044 int ss AU = op[1] & 0x03;
1045 #line 415 "rx-decode.opc"
1046 int rsrc AU = (op[3] >> 4) & 0x0f;
1047 #line 415 "rx-decode.opc"
1048 int rdst AU = op[3] & 0x0f;
1049 if (trace)
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);
1059 SYNTAX("xor %1%S1, %0");
1060 #line 415 "rx-decode.opc"
1061 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1063 /*----------------------------------------------------------------------*/
1064 /* NOT */
1067 break;
1069 break;
1070 case 0x10:
1071 GETBYTE ();
1072 switch (op[3] & 0x00)
1074 case 0x00:
1075 op_semantics_16:
1077 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1078 #line 349 "rx-decode.opc"
1079 int mx AU = (op[1] >> 6) & 0x03;
1080 #line 349 "rx-decode.opc"
1081 int ss AU = op[1] & 0x03;
1082 #line 349 "rx-decode.opc"
1083 int rsrc AU = (op[3] >> 4) & 0x0f;
1084 #line 349 "rx-decode.opc"
1085 int rdst AU = op[3] & 0x0f;
1086 if (trace)
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);
1096 SYNTAX("xchg %1%S1, %0");
1097 #line 349 "rx-decode.opc"
1098 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1100 /*----------------------------------------------------------------------*/
1101 /* STZ/STNZ */
1104 break;
1106 break;
1107 case 0x11:
1108 GETBYTE ();
1109 switch (op[3] & 0x00)
1111 case 0x00:
1112 op_semantics_17:
1114 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1115 #line 853 "rx-decode.opc"
1116 int mx AU = (op[1] >> 6) & 0x03;
1117 #line 853 "rx-decode.opc"
1118 int sd AU = op[1] & 0x03;
1119 #line 853 "rx-decode.opc"
1120 int rsrc AU = (op[3] >> 4) & 0x0f;
1121 #line 853 "rx-decode.opc"
1122 int rdst AU = op[3] & 0x0f;
1123 if (trace)
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);
1133 SYNTAX("itof %1%S1, %0");
1134 #line 853 "rx-decode.opc"
1135 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1137 /*----------------------------------------------------------------------*/
1138 /* BIT OPS */
1141 break;
1143 break;
1144 default: UNSUPPORTED(); break;
1146 break;
1147 case 0x21:
1148 GETBYTE ();
1149 switch (op[2] & 0xff)
1151 case 0x00:
1152 GETBYTE ();
1153 switch (op[3] & 0x00)
1155 case 0x00:
1156 goto op_semantics_7;
1157 break;
1159 break;
1160 case 0x04:
1161 GETBYTE ();
1162 switch (op[3] & 0x00)
1164 case 0x00:
1165 goto op_semantics_8;
1166 break;
1168 break;
1169 case 0x05:
1170 GETBYTE ();
1171 switch (op[3] & 0x00)
1173 case 0x00:
1174 goto op_semantics_9;
1175 break;
1177 break;
1178 case 0x06:
1179 GETBYTE ();
1180 switch (op[3] & 0x00)
1182 case 0x00:
1183 goto op_semantics_10;
1184 break;
1186 break;
1187 case 0x07:
1188 GETBYTE ();
1189 switch (op[3] & 0x00)
1191 case 0x00:
1192 goto op_semantics_11;
1193 break;
1195 break;
1196 case 0x08:
1197 GETBYTE ();
1198 switch (op[3] & 0x00)
1200 case 0x00:
1201 goto op_semantics_12;
1202 break;
1204 break;
1205 case 0x09:
1206 GETBYTE ();
1207 switch (op[3] & 0x00)
1209 case 0x00:
1210 goto op_semantics_13;
1211 break;
1213 break;
1214 case 0x0c:
1215 GETBYTE ();
1216 switch (op[3] & 0x00)
1218 case 0x00:
1219 goto op_semantics_14;
1220 break;
1222 break;
1223 case 0x0d:
1224 GETBYTE ();
1225 switch (op[3] & 0x00)
1227 case 0x00:
1228 goto op_semantics_15;
1229 break;
1231 break;
1232 case 0x10:
1233 GETBYTE ();
1234 switch (op[3] & 0x00)
1236 case 0x00:
1237 goto op_semantics_16;
1238 break;
1240 break;
1241 case 0x11:
1242 GETBYTE ();
1243 switch (op[3] & 0x00)
1245 case 0x00:
1246 goto op_semantics_17;
1247 break;
1249 break;
1250 default: UNSUPPORTED(); break;
1252 break;
1253 case 0x22:
1254 GETBYTE ();
1255 switch (op[2] & 0xff)
1257 case 0x00:
1258 GETBYTE ();
1259 switch (op[3] & 0x00)
1261 case 0x00:
1262 goto op_semantics_7;
1263 break;
1265 break;
1266 case 0x04:
1267 GETBYTE ();
1268 switch (op[3] & 0x00)
1270 case 0x00:
1271 goto op_semantics_8;
1272 break;
1274 break;
1275 case 0x05:
1276 GETBYTE ();
1277 switch (op[3] & 0x00)
1279 case 0x00:
1280 goto op_semantics_9;
1281 break;
1283 break;
1284 case 0x06:
1285 GETBYTE ();
1286 switch (op[3] & 0x00)
1288 case 0x00:
1289 goto op_semantics_10;
1290 break;
1292 break;
1293 case 0x07:
1294 GETBYTE ();
1295 switch (op[3] & 0x00)
1297 case 0x00:
1298 goto op_semantics_11;
1299 break;
1301 break;
1302 case 0x08:
1303 GETBYTE ();
1304 switch (op[3] & 0x00)
1306 case 0x00:
1307 goto op_semantics_12;
1308 break;
1310 break;
1311 case 0x09:
1312 GETBYTE ();
1313 switch (op[3] & 0x00)
1315 case 0x00:
1316 goto op_semantics_13;
1317 break;
1319 break;
1320 case 0x0c:
1321 GETBYTE ();
1322 switch (op[3] & 0x00)
1324 case 0x00:
1325 goto op_semantics_14;
1326 break;
1328 break;
1329 case 0x0d:
1330 GETBYTE ();
1331 switch (op[3] & 0x00)
1333 case 0x00:
1334 goto op_semantics_15;
1335 break;
1337 break;
1338 case 0x10:
1339 GETBYTE ();
1340 switch (op[3] & 0x00)
1342 case 0x00:
1343 goto op_semantics_16;
1344 break;
1346 break;
1347 case 0x11:
1348 GETBYTE ();
1349 switch (op[3] & 0x00)
1351 case 0x00:
1352 goto op_semantics_17;
1353 break;
1355 break;
1356 default: UNSUPPORTED(); break;
1358 break;
1359 case 0x23:
1360 GETBYTE ();
1361 switch (op[2] & 0xff)
1363 case 0x00:
1364 GETBYTE ();
1365 switch (op[3] & 0x00)
1367 case 0x00:
1368 goto op_semantics_7;
1369 break;
1371 break;
1372 case 0x04:
1373 GETBYTE ();
1374 switch (op[3] & 0x00)
1376 case 0x00:
1377 goto op_semantics_8;
1378 break;
1380 break;
1381 case 0x05:
1382 GETBYTE ();
1383 switch (op[3] & 0x00)
1385 case 0x00:
1386 goto op_semantics_9;
1387 break;
1389 break;
1390 case 0x06:
1391 GETBYTE ();
1392 switch (op[3] & 0x00)
1394 case 0x00:
1395 goto op_semantics_10;
1396 break;
1398 break;
1399 case 0x07:
1400 GETBYTE ();
1401 switch (op[3] & 0x00)
1403 case 0x00:
1404 goto op_semantics_11;
1405 break;
1407 break;
1408 case 0x08:
1409 GETBYTE ();
1410 switch (op[3] & 0x00)
1412 case 0x00:
1413 goto op_semantics_12;
1414 break;
1416 break;
1417 case 0x09:
1418 GETBYTE ();
1419 switch (op[3] & 0x00)
1421 case 0x00:
1422 goto op_semantics_13;
1423 break;
1425 break;
1426 case 0x0c:
1427 GETBYTE ();
1428 switch (op[3] & 0x00)
1430 case 0x00:
1431 goto op_semantics_14;
1432 break;
1434 break;
1435 case 0x0d:
1436 GETBYTE ();
1437 switch (op[3] & 0x00)
1439 case 0x00:
1440 goto op_semantics_15;
1441 break;
1443 break;
1444 case 0x10:
1445 GETBYTE ();
1446 switch (op[3] & 0x00)
1448 case 0x00:
1449 goto op_semantics_16;
1450 break;
1452 break;
1453 case 0x11:
1454 GETBYTE ();
1455 switch (op[3] & 0x00)
1457 case 0x00:
1458 goto op_semantics_17;
1459 break;
1461 break;
1462 default: UNSUPPORTED(); break;
1464 break;
1465 case 0x40:
1466 GETBYTE ();
1467 switch (op[2] & 0x00)
1469 case 0x00:
1470 goto op_semantics_1;
1471 break;
1473 break;
1474 case 0x41:
1475 GETBYTE ();
1476 switch (op[2] & 0x00)
1478 case 0x00:
1479 goto op_semantics_1;
1480 break;
1482 break;
1483 case 0x42:
1484 GETBYTE ();
1485 switch (op[2] & 0x00)
1487 case 0x00:
1488 goto op_semantics_1;
1489 break;
1491 break;
1492 case 0x43:
1493 GETBYTE ();
1494 switch (op[2] & 0x00)
1496 case 0x00:
1497 goto op_semantics_1;
1498 break;
1500 break;
1501 case 0x44:
1502 GETBYTE ();
1503 switch (op[2] & 0x00)
1505 case 0x00:
1506 goto op_semantics_2;
1507 break;
1509 break;
1510 case 0x45:
1511 GETBYTE ();
1512 switch (op[2] & 0x00)
1514 case 0x00:
1515 goto op_semantics_2;
1516 break;
1518 break;
1519 case 0x46:
1520 GETBYTE ();
1521 switch (op[2] & 0x00)
1523 case 0x00:
1524 goto op_semantics_2;
1525 break;
1527 break;
1528 case 0x47:
1529 GETBYTE ();
1530 switch (op[2] & 0x00)
1532 case 0x00:
1533 goto op_semantics_2;
1534 break;
1536 break;
1537 case 0x48:
1538 GETBYTE ();
1539 switch (op[2] & 0x00)
1541 case 0x00:
1542 goto op_semantics_3;
1543 break;
1545 break;
1546 case 0x49:
1547 GETBYTE ();
1548 switch (op[2] & 0x00)
1550 case 0x00:
1551 goto op_semantics_3;
1552 break;
1554 break;
1555 case 0x4a:
1556 GETBYTE ();
1557 switch (op[2] & 0x00)
1559 case 0x00:
1560 goto op_semantics_3;
1561 break;
1563 break;
1564 case 0x4b:
1565 GETBYTE ();
1566 switch (op[2] & 0x00)
1568 case 0x00:
1569 goto op_semantics_3;
1570 break;
1572 break;
1573 case 0x4c:
1574 GETBYTE ();
1575 switch (op[2] & 0x00)
1577 case 0x00:
1578 goto op_semantics_4;
1579 break;
1581 break;
1582 case 0x4d:
1583 GETBYTE ();
1584 switch (op[2] & 0x00)
1586 case 0x00:
1587 goto op_semantics_4;
1588 break;
1590 break;
1591 case 0x4e:
1592 GETBYTE ();
1593 switch (op[2] & 0x00)
1595 case 0x00:
1596 goto op_semantics_4;
1597 break;
1599 break;
1600 case 0x4f:
1601 GETBYTE ();
1602 switch (op[2] & 0x00)
1604 case 0x00:
1605 goto op_semantics_4;
1606 break;
1608 break;
1609 case 0x50:
1610 GETBYTE ();
1611 switch (op[2] & 0x00)
1613 case 0x00:
1614 goto op_semantics_5;
1615 break;
1617 break;
1618 case 0x51:
1619 GETBYTE ();
1620 switch (op[2] & 0x00)
1622 case 0x00:
1623 goto op_semantics_5;
1624 break;
1626 break;
1627 case 0x52:
1628 GETBYTE ();
1629 switch (op[2] & 0x00)
1631 case 0x00:
1632 goto op_semantics_5;
1633 break;
1635 break;
1636 case 0x53:
1637 GETBYTE ();
1638 switch (op[2] & 0x00)
1640 case 0x00:
1641 goto op_semantics_5;
1642 break;
1644 break;
1645 case 0x54:
1646 GETBYTE ();
1647 switch (op[2] & 0x00)
1649 case 0x00:
1650 goto op_semantics_6;
1651 break;
1653 break;
1654 case 0x55:
1655 GETBYTE ();
1656 switch (op[2] & 0x00)
1658 case 0x00:
1659 goto op_semantics_6;
1660 break;
1662 break;
1663 case 0x56:
1664 GETBYTE ();
1665 switch (op[2] & 0x00)
1667 case 0x00:
1668 goto op_semantics_6;
1669 break;
1671 break;
1672 case 0x57:
1673 GETBYTE ();
1674 switch (op[2] & 0x00)
1676 case 0x00:
1677 goto op_semantics_6;
1678 break;
1680 break;
1681 case 0x60:
1682 GETBYTE ();
1683 switch (op[2] & 0xff)
1685 case 0x00:
1686 GETBYTE ();
1687 switch (op[3] & 0x00)
1689 case 0x00:
1690 goto op_semantics_7;
1691 break;
1693 break;
1694 case 0x04:
1695 GETBYTE ();
1696 switch (op[3] & 0x00)
1698 case 0x00:
1699 goto op_semantics_8;
1700 break;
1702 break;
1703 case 0x05:
1704 GETBYTE ();
1705 switch (op[3] & 0x00)
1707 case 0x00:
1708 goto op_semantics_9;
1709 break;
1711 break;
1712 case 0x06:
1713 GETBYTE ();
1714 switch (op[3] & 0x00)
1716 case 0x00:
1717 goto op_semantics_10;
1718 break;
1720 break;
1721 case 0x07:
1722 GETBYTE ();
1723 switch (op[3] & 0x00)
1725 case 0x00:
1726 goto op_semantics_11;
1727 break;
1729 break;
1730 case 0x08:
1731 GETBYTE ();
1732 switch (op[3] & 0x00)
1734 case 0x00:
1735 goto op_semantics_12;
1736 break;
1738 break;
1739 case 0x09:
1740 GETBYTE ();
1741 switch (op[3] & 0x00)
1743 case 0x00:
1744 goto op_semantics_13;
1745 break;
1747 break;
1748 case 0x0c:
1749 GETBYTE ();
1750 switch (op[3] & 0x00)
1752 case 0x00:
1753 goto op_semantics_14;
1754 break;
1756 break;
1757 case 0x0d:
1758 GETBYTE ();
1759 switch (op[3] & 0x00)
1761 case 0x00:
1762 goto op_semantics_15;
1763 break;
1765 break;
1766 case 0x10:
1767 GETBYTE ();
1768 switch (op[3] & 0x00)
1770 case 0x00:
1771 goto op_semantics_16;
1772 break;
1774 break;
1775 case 0x11:
1776 GETBYTE ();
1777 switch (op[3] & 0x00)
1779 case 0x00:
1780 goto op_semantics_17;
1781 break;
1783 break;
1784 default: UNSUPPORTED(); break;
1786 break;
1787 case 0x61:
1788 GETBYTE ();
1789 switch (op[2] & 0xff)
1791 case 0x00:
1792 GETBYTE ();
1793 switch (op[3] & 0x00)
1795 case 0x00:
1796 goto op_semantics_7;
1797 break;
1799 break;
1800 case 0x04:
1801 GETBYTE ();
1802 switch (op[3] & 0x00)
1804 case 0x00:
1805 goto op_semantics_8;
1806 break;
1808 break;
1809 case 0x05:
1810 GETBYTE ();
1811 switch (op[3] & 0x00)
1813 case 0x00:
1814 goto op_semantics_9;
1815 break;
1817 break;
1818 case 0x06:
1819 GETBYTE ();
1820 switch (op[3] & 0x00)
1822 case 0x00:
1823 goto op_semantics_10;
1824 break;
1826 break;
1827 case 0x07:
1828 GETBYTE ();
1829 switch (op[3] & 0x00)
1831 case 0x00:
1832 goto op_semantics_11;
1833 break;
1835 break;
1836 case 0x08:
1837 GETBYTE ();
1838 switch (op[3] & 0x00)
1840 case 0x00:
1841 goto op_semantics_12;
1842 break;
1844 break;
1845 case 0x09:
1846 GETBYTE ();
1847 switch (op[3] & 0x00)
1849 case 0x00:
1850 goto op_semantics_13;
1851 break;
1853 break;
1854 case 0x0c:
1855 GETBYTE ();
1856 switch (op[3] & 0x00)
1858 case 0x00:
1859 goto op_semantics_14;
1860 break;
1862 break;
1863 case 0x0d:
1864 GETBYTE ();
1865 switch (op[3] & 0x00)
1867 case 0x00:
1868 goto op_semantics_15;
1869 break;
1871 break;
1872 case 0x10:
1873 GETBYTE ();
1874 switch (op[3] & 0x00)
1876 case 0x00:
1877 goto op_semantics_16;
1878 break;
1880 break;
1881 case 0x11:
1882 GETBYTE ();
1883 switch (op[3] & 0x00)
1885 case 0x00:
1886 goto op_semantics_17;
1887 break;
1889 break;
1890 default: UNSUPPORTED(); break;
1892 break;
1893 case 0x62:
1894 GETBYTE ();
1895 switch (op[2] & 0xff)
1897 case 0x00:
1898 GETBYTE ();
1899 switch (op[3] & 0x00)
1901 case 0x00:
1902 goto op_semantics_7;
1903 break;
1905 break;
1906 case 0x04:
1907 GETBYTE ();
1908 switch (op[3] & 0x00)
1910 case 0x00:
1911 goto op_semantics_8;
1912 break;
1914 break;
1915 case 0x05:
1916 GETBYTE ();
1917 switch (op[3] & 0x00)
1919 case 0x00:
1920 goto op_semantics_9;
1921 break;
1923 break;
1924 case 0x06:
1925 GETBYTE ();
1926 switch (op[3] & 0x00)
1928 case 0x00:
1929 goto op_semantics_10;
1930 break;
1932 break;
1933 case 0x07:
1934 GETBYTE ();
1935 switch (op[3] & 0x00)
1937 case 0x00:
1938 goto op_semantics_11;
1939 break;
1941 break;
1942 case 0x08:
1943 GETBYTE ();
1944 switch (op[3] & 0x00)
1946 case 0x00:
1947 goto op_semantics_12;
1948 break;
1950 break;
1951 case 0x09:
1952 GETBYTE ();
1953 switch (op[3] & 0x00)
1955 case 0x00:
1956 goto op_semantics_13;
1957 break;
1959 break;
1960 case 0x0c:
1961 GETBYTE ();
1962 switch (op[3] & 0x00)
1964 case 0x00:
1965 goto op_semantics_14;
1966 break;
1968 break;
1969 case 0x0d:
1970 GETBYTE ();
1971 switch (op[3] & 0x00)
1973 case 0x00:
1974 goto op_semantics_15;
1975 break;
1977 break;
1978 case 0x10:
1979 GETBYTE ();
1980 switch (op[3] & 0x00)
1982 case 0x00:
1983 goto op_semantics_16;
1984 break;
1986 break;
1987 case 0x11:
1988 GETBYTE ();
1989 switch (op[3] & 0x00)
1991 case 0x00:
1992 goto op_semantics_17;
1993 break;
1995 break;
1996 default: UNSUPPORTED(); break;
1998 break;
1999 case 0x63:
2000 GETBYTE ();
2001 switch (op[2] & 0xff)
2003 case 0x00:
2004 GETBYTE ();
2005 switch (op[3] & 0x00)
2007 case 0x00:
2008 goto op_semantics_7;
2009 break;
2011 break;
2012 case 0x04:
2013 GETBYTE ();
2014 switch (op[3] & 0x00)
2016 case 0x00:
2017 goto op_semantics_8;
2018 break;
2020 break;
2021 case 0x05:
2022 GETBYTE ();
2023 switch (op[3] & 0x00)
2025 case 0x00:
2026 goto op_semantics_9;
2027 break;
2029 break;
2030 case 0x06:
2031 GETBYTE ();
2032 switch (op[3] & 0x00)
2034 case 0x00:
2035 goto op_semantics_10;
2036 break;
2038 break;
2039 case 0x07:
2040 GETBYTE ();
2041 switch (op[3] & 0x00)
2043 case 0x00:
2044 goto op_semantics_11;
2045 break;
2047 break;
2048 case 0x08:
2049 GETBYTE ();
2050 switch (op[3] & 0x00)
2052 case 0x00:
2053 goto op_semantics_12;
2054 break;
2056 break;
2057 case 0x09:
2058 GETBYTE ();
2059 switch (op[3] & 0x00)
2061 case 0x00:
2062 goto op_semantics_13;
2063 break;
2065 break;
2066 case 0x0c:
2067 GETBYTE ();
2068 switch (op[3] & 0x00)
2070 case 0x00:
2071 goto op_semantics_14;
2072 break;
2074 break;
2075 case 0x0d:
2076 GETBYTE ();
2077 switch (op[3] & 0x00)
2079 case 0x00:
2080 goto op_semantics_15;
2081 break;
2083 break;
2084 case 0x10:
2085 GETBYTE ();
2086 switch (op[3] & 0x00)
2088 case 0x00:
2089 goto op_semantics_16;
2090 break;
2092 break;
2093 case 0x11:
2094 GETBYTE ();
2095 switch (op[3] & 0x00)
2097 case 0x00:
2098 goto op_semantics_17;
2099 break;
2101 break;
2102 default: UNSUPPORTED(); break;
2104 break;
2105 case 0x80:
2106 GETBYTE ();
2107 switch (op[2] & 0x00)
2109 case 0x00:
2110 goto op_semantics_1;
2111 break;
2113 break;
2114 case 0x81:
2115 GETBYTE ();
2116 switch (op[2] & 0x00)
2118 case 0x00:
2119 goto op_semantics_1;
2120 break;
2122 break;
2123 case 0x82:
2124 GETBYTE ();
2125 switch (op[2] & 0x00)
2127 case 0x00:
2128 goto op_semantics_1;
2129 break;
2131 break;
2132 case 0x83:
2133 GETBYTE ();
2134 switch (op[2] & 0x00)
2136 case 0x00:
2137 goto op_semantics_1;
2138 break;
2140 break;
2141 case 0x84:
2142 GETBYTE ();
2143 switch (op[2] & 0x00)
2145 case 0x00:
2146 goto op_semantics_2;
2147 break;
2149 break;
2150 case 0x85:
2151 GETBYTE ();
2152 switch (op[2] & 0x00)
2154 case 0x00:
2155 goto op_semantics_2;
2156 break;
2158 break;
2159 case 0x86:
2160 GETBYTE ();
2161 switch (op[2] & 0x00)
2163 case 0x00:
2164 goto op_semantics_2;
2165 break;
2167 break;
2168 case 0x87:
2169 GETBYTE ();
2170 switch (op[2] & 0x00)
2172 case 0x00:
2173 goto op_semantics_2;
2174 break;
2176 break;
2177 case 0x88:
2178 GETBYTE ();
2179 switch (op[2] & 0x00)
2181 case 0x00:
2182 goto op_semantics_3;
2183 break;
2185 break;
2186 case 0x89:
2187 GETBYTE ();
2188 switch (op[2] & 0x00)
2190 case 0x00:
2191 goto op_semantics_3;
2192 break;
2194 break;
2195 case 0x8a:
2196 GETBYTE ();
2197 switch (op[2] & 0x00)
2199 case 0x00:
2200 goto op_semantics_3;
2201 break;
2203 break;
2204 case 0x8b:
2205 GETBYTE ();
2206 switch (op[2] & 0x00)
2208 case 0x00:
2209 goto op_semantics_3;
2210 break;
2212 break;
2213 case 0x8c:
2214 GETBYTE ();
2215 switch (op[2] & 0x00)
2217 case 0x00:
2218 goto op_semantics_4;
2219 break;
2221 break;
2222 case 0x8d:
2223 GETBYTE ();
2224 switch (op[2] & 0x00)
2226 case 0x00:
2227 goto op_semantics_4;
2228 break;
2230 break;
2231 case 0x8e:
2232 GETBYTE ();
2233 switch (op[2] & 0x00)
2235 case 0x00:
2236 goto op_semantics_4;
2237 break;
2239 break;
2240 case 0x8f:
2241 GETBYTE ();
2242 switch (op[2] & 0x00)
2244 case 0x00:
2245 goto op_semantics_4;
2246 break;
2248 break;
2249 case 0x90:
2250 GETBYTE ();
2251 switch (op[2] & 0x00)
2253 case 0x00:
2254 goto op_semantics_5;
2255 break;
2257 break;
2258 case 0x91:
2259 GETBYTE ();
2260 switch (op[2] & 0x00)
2262 case 0x00:
2263 goto op_semantics_5;
2264 break;
2266 break;
2267 case 0x92:
2268 GETBYTE ();
2269 switch (op[2] & 0x00)
2271 case 0x00:
2272 goto op_semantics_5;
2273 break;
2275 break;
2276 case 0x93:
2277 GETBYTE ();
2278 switch (op[2] & 0x00)
2280 case 0x00:
2281 goto op_semantics_5;
2282 break;
2284 break;
2285 case 0x94:
2286 GETBYTE ();
2287 switch (op[2] & 0x00)
2289 case 0x00:
2290 goto op_semantics_6;
2291 break;
2293 break;
2294 case 0x95:
2295 GETBYTE ();
2296 switch (op[2] & 0x00)
2298 case 0x00:
2299 goto op_semantics_6;
2300 break;
2302 break;
2303 case 0x96:
2304 GETBYTE ();
2305 switch (op[2] & 0x00)
2307 case 0x00:
2308 goto op_semantics_6;
2309 break;
2311 break;
2312 case 0x97:
2313 GETBYTE ();
2314 switch (op[2] & 0x00)
2316 case 0x00:
2317 goto op_semantics_6;
2318 break;
2320 break;
2321 case 0xa0:
2322 GETBYTE ();
2323 switch (op[2] & 0xff)
2325 case 0x00:
2326 GETBYTE ();
2327 switch (op[3] & 0x00)
2329 case 0x00:
2330 goto op_semantics_7;
2331 break;
2333 break;
2334 case 0x02:
2335 GETBYTE ();
2336 switch (op[3] & 0x00)
2338 case 0x00:
2339 op_semantics_18:
2341 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2342 #line 457 "rx-decode.opc"
2343 int ss AU = op[1] & 0x03;
2344 #line 457 "rx-decode.opc"
2345 int rsrc AU = (op[3] >> 4) & 0x0f;
2346 #line 457 "rx-decode.opc"
2347 int rdst AU = op[3] & 0x0f;
2348 if (trace)
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);
2357 SYNTAX("adc %1%S1, %0");
2358 #line 457 "rx-decode.opc"
2359 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2361 /*----------------------------------------------------------------------*/
2362 /* ADD */
2365 break;
2367 break;
2368 case 0x04:
2369 GETBYTE ();
2370 switch (op[3] & 0x00)
2372 case 0x00:
2373 goto op_semantics_8;
2374 break;
2376 break;
2377 case 0x05:
2378 GETBYTE ();
2379 switch (op[3] & 0x00)
2381 case 0x00:
2382 goto op_semantics_9;
2383 break;
2385 break;
2386 case 0x06:
2387 GETBYTE ();
2388 switch (op[3] & 0x00)
2390 case 0x00:
2391 goto op_semantics_10;
2392 break;
2394 break;
2395 case 0x07:
2396 GETBYTE ();
2397 switch (op[3] & 0x00)
2399 case 0x00:
2400 goto op_semantics_11;
2401 break;
2403 break;
2404 case 0x08:
2405 GETBYTE ();
2406 switch (op[3] & 0x00)
2408 case 0x00:
2409 goto op_semantics_12;
2410 break;
2412 break;
2413 case 0x09:
2414 GETBYTE ();
2415 switch (op[3] & 0x00)
2417 case 0x00:
2418 goto op_semantics_13;
2419 break;
2421 break;
2422 case 0x0c:
2423 GETBYTE ();
2424 switch (op[3] & 0x00)
2426 case 0x00:
2427 goto op_semantics_14;
2428 break;
2430 break;
2431 case 0x0d:
2432 GETBYTE ();
2433 switch (op[3] & 0x00)
2435 case 0x00:
2436 goto op_semantics_15;
2437 break;
2439 break;
2440 case 0x10:
2441 GETBYTE ();
2442 switch (op[3] & 0x00)
2444 case 0x00:
2445 goto op_semantics_16;
2446 break;
2448 break;
2449 case 0x11:
2450 GETBYTE ();
2451 switch (op[3] & 0x00)
2453 case 0x00:
2454 goto op_semantics_17;
2455 break;
2457 break;
2458 default: UNSUPPORTED(); break;
2460 break;
2461 case 0xa1:
2462 GETBYTE ();
2463 switch (op[2] & 0xff)
2465 case 0x00:
2466 GETBYTE ();
2467 switch (op[3] & 0x00)
2469 case 0x00:
2470 goto op_semantics_7;
2471 break;
2473 break;
2474 case 0x02:
2475 GETBYTE ();
2476 switch (op[3] & 0x00)
2478 case 0x00:
2479 goto op_semantics_18;
2480 break;
2482 break;
2483 case 0x04:
2484 GETBYTE ();
2485 switch (op[3] & 0x00)
2487 case 0x00:
2488 goto op_semantics_8;
2489 break;
2491 break;
2492 case 0x05:
2493 GETBYTE ();
2494 switch (op[3] & 0x00)
2496 case 0x00:
2497 goto op_semantics_9;
2498 break;
2500 break;
2501 case 0x06:
2502 GETBYTE ();
2503 switch (op[3] & 0x00)
2505 case 0x00:
2506 goto op_semantics_10;
2507 break;
2509 break;
2510 case 0x07:
2511 GETBYTE ();
2512 switch (op[3] & 0x00)
2514 case 0x00:
2515 goto op_semantics_11;
2516 break;
2518 break;
2519 case 0x08:
2520 GETBYTE ();
2521 switch (op[3] & 0x00)
2523 case 0x00:
2524 goto op_semantics_12;
2525 break;
2527 break;
2528 case 0x09:
2529 GETBYTE ();
2530 switch (op[3] & 0x00)
2532 case 0x00:
2533 goto op_semantics_13;
2534 break;
2536 break;
2537 case 0x0c:
2538 GETBYTE ();
2539 switch (op[3] & 0x00)
2541 case 0x00:
2542 goto op_semantics_14;
2543 break;
2545 break;
2546 case 0x0d:
2547 GETBYTE ();
2548 switch (op[3] & 0x00)
2550 case 0x00:
2551 goto op_semantics_15;
2552 break;
2554 break;
2555 case 0x10:
2556 GETBYTE ();
2557 switch (op[3] & 0x00)
2559 case 0x00:
2560 goto op_semantics_16;
2561 break;
2563 break;
2564 case 0x11:
2565 GETBYTE ();
2566 switch (op[3] & 0x00)
2568 case 0x00:
2569 goto op_semantics_17;
2570 break;
2572 break;
2573 default: UNSUPPORTED(); break;
2575 break;
2576 case 0xa2:
2577 GETBYTE ();
2578 switch (op[2] & 0xff)
2580 case 0x00:
2581 GETBYTE ();
2582 switch (op[3] & 0x00)
2584 case 0x00:
2585 goto op_semantics_7;
2586 break;
2588 break;
2589 case 0x02:
2590 GETBYTE ();
2591 switch (op[3] & 0x00)
2593 case 0x00:
2594 goto op_semantics_18;
2595 break;
2597 break;
2598 case 0x04:
2599 GETBYTE ();
2600 switch (op[3] & 0x00)
2602 case 0x00:
2603 goto op_semantics_8;
2604 break;
2606 break;
2607 case 0x05:
2608 GETBYTE ();
2609 switch (op[3] & 0x00)
2611 case 0x00:
2612 goto op_semantics_9;
2613 break;
2615 break;
2616 case 0x06:
2617 GETBYTE ();
2618 switch (op[3] & 0x00)
2620 case 0x00:
2621 goto op_semantics_10;
2622 break;
2624 break;
2625 case 0x07:
2626 GETBYTE ();
2627 switch (op[3] & 0x00)
2629 case 0x00:
2630 goto op_semantics_11;
2631 break;
2633 break;
2634 case 0x08:
2635 GETBYTE ();
2636 switch (op[3] & 0x00)
2638 case 0x00:
2639 goto op_semantics_12;
2640 break;
2642 break;
2643 case 0x09:
2644 GETBYTE ();
2645 switch (op[3] & 0x00)
2647 case 0x00:
2648 goto op_semantics_13;
2649 break;
2651 break;
2652 case 0x0c:
2653 GETBYTE ();
2654 switch (op[3] & 0x00)
2656 case 0x00:
2657 goto op_semantics_14;
2658 break;
2660 break;
2661 case 0x0d:
2662 GETBYTE ();
2663 switch (op[3] & 0x00)
2665 case 0x00:
2666 goto op_semantics_15;
2667 break;
2669 break;
2670 case 0x10:
2671 GETBYTE ();
2672 switch (op[3] & 0x00)
2674 case 0x00:
2675 goto op_semantics_16;
2676 break;
2678 break;
2679 case 0x11:
2680 GETBYTE ();
2681 switch (op[3] & 0x00)
2683 case 0x00:
2684 goto op_semantics_17;
2685 break;
2687 break;
2688 default: UNSUPPORTED(); break;
2690 break;
2691 case 0xa3:
2692 GETBYTE ();
2693 switch (op[2] & 0xff)
2695 case 0x00:
2696 GETBYTE ();
2697 switch (op[3] & 0x00)
2699 case 0x00:
2700 goto op_semantics_7;
2701 break;
2703 break;
2704 case 0x02:
2705 GETBYTE ();
2706 switch (op[3] & 0x00)
2708 case 0x00:
2709 goto op_semantics_18;
2710 break;
2712 break;
2713 case 0x04:
2714 GETBYTE ();
2715 switch (op[3] & 0x00)
2717 case 0x00:
2718 goto op_semantics_8;
2719 break;
2721 break;
2722 case 0x05:
2723 GETBYTE ();
2724 switch (op[3] & 0x00)
2726 case 0x00:
2727 goto op_semantics_9;
2728 break;
2730 break;
2731 case 0x06:
2732 GETBYTE ();
2733 switch (op[3] & 0x00)
2735 case 0x00:
2736 goto op_semantics_10;
2737 break;
2739 break;
2740 case 0x07:
2741 GETBYTE ();
2742 switch (op[3] & 0x00)
2744 case 0x00:
2745 goto op_semantics_11;
2746 break;
2748 break;
2749 case 0x08:
2750 GETBYTE ();
2751 switch (op[3] & 0x00)
2753 case 0x00:
2754 goto op_semantics_12;
2755 break;
2757 break;
2758 case 0x09:
2759 GETBYTE ();
2760 switch (op[3] & 0x00)
2762 case 0x00:
2763 goto op_semantics_13;
2764 break;
2766 break;
2767 case 0x0c:
2768 GETBYTE ();
2769 switch (op[3] & 0x00)
2771 case 0x00:
2772 goto op_semantics_14;
2773 break;
2775 break;
2776 case 0x0d:
2777 GETBYTE ();
2778 switch (op[3] & 0x00)
2780 case 0x00:
2781 goto op_semantics_15;
2782 break;
2784 break;
2785 case 0x10:
2786 GETBYTE ();
2787 switch (op[3] & 0x00)
2789 case 0x00:
2790 goto op_semantics_16;
2791 break;
2793 break;
2794 case 0x11:
2795 GETBYTE ();
2796 switch (op[3] & 0x00)
2798 case 0x00:
2799 goto op_semantics_17;
2800 break;
2802 break;
2803 default: UNSUPPORTED(); break;
2805 break;
2806 case 0xc0:
2807 GETBYTE ();
2808 switch (op[2] & 0x00)
2810 case 0x00:
2811 goto op_semantics_1;
2812 break;
2814 break;
2815 case 0xc1:
2816 GETBYTE ();
2817 switch (op[2] & 0x00)
2819 case 0x00:
2820 goto op_semantics_1;
2821 break;
2823 break;
2824 case 0xc2:
2825 GETBYTE ();
2826 switch (op[2] & 0x00)
2828 case 0x00:
2829 goto op_semantics_1;
2830 break;
2832 break;
2833 case 0xc3:
2834 GETBYTE ();
2835 switch (op[2] & 0x00)
2837 case 0x00:
2838 goto op_semantics_1;
2839 break;
2841 break;
2842 case 0xc4:
2843 GETBYTE ();
2844 switch (op[2] & 0x00)
2846 case 0x00:
2847 goto op_semantics_2;
2848 break;
2850 break;
2851 case 0xc5:
2852 GETBYTE ();
2853 switch (op[2] & 0x00)
2855 case 0x00:
2856 goto op_semantics_2;
2857 break;
2859 break;
2860 case 0xc6:
2861 GETBYTE ();
2862 switch (op[2] & 0x00)
2864 case 0x00:
2865 goto op_semantics_2;
2866 break;
2868 break;
2869 case 0xc7:
2870 GETBYTE ();
2871 switch (op[2] & 0x00)
2873 case 0x00:
2874 goto op_semantics_2;
2875 break;
2877 break;
2878 case 0xc8:
2879 GETBYTE ();
2880 switch (op[2] & 0x00)
2882 case 0x00:
2883 goto op_semantics_3;
2884 break;
2886 break;
2887 case 0xc9:
2888 GETBYTE ();
2889 switch (op[2] & 0x00)
2891 case 0x00:
2892 goto op_semantics_3;
2893 break;
2895 break;
2896 case 0xca:
2897 GETBYTE ();
2898 switch (op[2] & 0x00)
2900 case 0x00:
2901 goto op_semantics_3;
2902 break;
2904 break;
2905 case 0xcb:
2906 GETBYTE ();
2907 switch (op[2] & 0x00)
2909 case 0x00:
2910 goto op_semantics_3;
2911 break;
2913 break;
2914 case 0xcc:
2915 GETBYTE ();
2916 switch (op[2] & 0x00)
2918 case 0x00:
2919 goto op_semantics_4;
2920 break;
2922 break;
2923 case 0xcd:
2924 GETBYTE ();
2925 switch (op[2] & 0x00)
2927 case 0x00:
2928 goto op_semantics_4;
2929 break;
2931 break;
2932 case 0xce:
2933 GETBYTE ();
2934 switch (op[2] & 0x00)
2936 case 0x00:
2937 goto op_semantics_4;
2938 break;
2940 break;
2941 case 0xcf:
2942 GETBYTE ();
2943 switch (op[2] & 0x00)
2945 case 0x00:
2946 goto op_semantics_4;
2947 break;
2949 break;
2950 case 0xd0:
2951 GETBYTE ();
2952 switch (op[2] & 0x00)
2954 case 0x00:
2955 goto op_semantics_5;
2956 break;
2958 break;
2959 case 0xd1:
2960 GETBYTE ();
2961 switch (op[2] & 0x00)
2963 case 0x00:
2964 goto op_semantics_5;
2965 break;
2967 break;
2968 case 0xd2:
2969 GETBYTE ();
2970 switch (op[2] & 0x00)
2972 case 0x00:
2973 goto op_semantics_5;
2974 break;
2976 break;
2977 case 0xd3:
2978 GETBYTE ();
2979 switch (op[2] & 0x00)
2981 case 0x00:
2982 goto op_semantics_5;
2983 break;
2985 break;
2986 case 0xd4:
2987 GETBYTE ();
2988 switch (op[2] & 0x00)
2990 case 0x00:
2991 goto op_semantics_6;
2992 break;
2994 break;
2995 case 0xd5:
2996 GETBYTE ();
2997 switch (op[2] & 0x00)
2999 case 0x00:
3000 goto op_semantics_6;
3001 break;
3003 break;
3004 case 0xd6:
3005 GETBYTE ();
3006 switch (op[2] & 0x00)
3008 case 0x00:
3009 goto op_semantics_6;
3010 break;
3012 break;
3013 case 0xd7:
3014 GETBYTE ();
3015 switch (op[2] & 0x00)
3017 case 0x00:
3018 goto op_semantics_6;
3019 break;
3021 break;
3022 case 0xe0:
3023 GETBYTE ();
3024 switch (op[2] & 0xff)
3026 case 0x00:
3027 GETBYTE ();
3028 switch (op[3] & 0x00)
3030 case 0x00:
3031 goto op_semantics_7;
3032 break;
3034 break;
3035 case 0x04:
3036 GETBYTE ();
3037 switch (op[3] & 0x00)
3039 case 0x00:
3040 goto op_semantics_8;
3041 break;
3043 break;
3044 case 0x05:
3045 GETBYTE ();
3046 switch (op[3] & 0x00)
3048 case 0x00:
3049 goto op_semantics_9;
3050 break;
3052 break;
3053 case 0x06:
3054 GETBYTE ();
3055 switch (op[3] & 0x00)
3057 case 0x00:
3058 goto op_semantics_10;
3059 break;
3061 break;
3062 case 0x07:
3063 GETBYTE ();
3064 switch (op[3] & 0x00)
3066 case 0x00:
3067 goto op_semantics_11;
3068 break;
3070 break;
3071 case 0x08:
3072 GETBYTE ();
3073 switch (op[3] & 0x00)
3075 case 0x00:
3076 goto op_semantics_12;
3077 break;
3079 break;
3080 case 0x09:
3081 GETBYTE ();
3082 switch (op[3] & 0x00)
3084 case 0x00:
3085 goto op_semantics_13;
3086 break;
3088 break;
3089 case 0x0c:
3090 GETBYTE ();
3091 switch (op[3] & 0x00)
3093 case 0x00:
3094 goto op_semantics_14;
3095 break;
3097 break;
3098 case 0x0d:
3099 GETBYTE ();
3100 switch (op[3] & 0x00)
3102 case 0x00:
3103 goto op_semantics_15;
3104 break;
3106 break;
3107 case 0x10:
3108 GETBYTE ();
3109 switch (op[3] & 0x00)
3111 case 0x00:
3112 goto op_semantics_16;
3113 break;
3115 break;
3116 case 0x11:
3117 GETBYTE ();
3118 switch (op[3] & 0x00)
3120 case 0x00:
3121 goto op_semantics_17;
3122 break;
3124 break;
3125 default: UNSUPPORTED(); break;
3127 break;
3128 case 0xe1:
3129 GETBYTE ();
3130 switch (op[2] & 0xff)
3132 case 0x00:
3133 GETBYTE ();
3134 switch (op[3] & 0x00)
3136 case 0x00:
3137 goto op_semantics_7;
3138 break;
3140 break;
3141 case 0x04:
3142 GETBYTE ();
3143 switch (op[3] & 0x00)
3145 case 0x00:
3146 goto op_semantics_8;
3147 break;
3149 break;
3150 case 0x05:
3151 GETBYTE ();
3152 switch (op[3] & 0x00)
3154 case 0x00:
3155 goto op_semantics_9;
3156 break;
3158 break;
3159 case 0x06:
3160 GETBYTE ();
3161 switch (op[3] & 0x00)
3163 case 0x00:
3164 goto op_semantics_10;
3165 break;
3167 break;
3168 case 0x07:
3169 GETBYTE ();
3170 switch (op[3] & 0x00)
3172 case 0x00:
3173 goto op_semantics_11;
3174 break;
3176 break;
3177 case 0x08:
3178 GETBYTE ();
3179 switch (op[3] & 0x00)
3181 case 0x00:
3182 goto op_semantics_12;
3183 break;
3185 break;
3186 case 0x09:
3187 GETBYTE ();
3188 switch (op[3] & 0x00)
3190 case 0x00:
3191 goto op_semantics_13;
3192 break;
3194 break;
3195 case 0x0c:
3196 GETBYTE ();
3197 switch (op[3] & 0x00)
3199 case 0x00:
3200 goto op_semantics_14;
3201 break;
3203 break;
3204 case 0x0d:
3205 GETBYTE ();
3206 switch (op[3] & 0x00)
3208 case 0x00:
3209 goto op_semantics_15;
3210 break;
3212 break;
3213 case 0x10:
3214 GETBYTE ();
3215 switch (op[3] & 0x00)
3217 case 0x00:
3218 goto op_semantics_16;
3219 break;
3221 break;
3222 case 0x11:
3223 GETBYTE ();
3224 switch (op[3] & 0x00)
3226 case 0x00:
3227 goto op_semantics_17;
3228 break;
3230 break;
3231 default: UNSUPPORTED(); break;
3233 break;
3234 case 0xe2:
3235 GETBYTE ();
3236 switch (op[2] & 0xff)
3238 case 0x00:
3239 GETBYTE ();
3240 switch (op[3] & 0x00)
3242 case 0x00:
3243 goto op_semantics_7;
3244 break;
3246 break;
3247 case 0x04:
3248 GETBYTE ();
3249 switch (op[3] & 0x00)
3251 case 0x00:
3252 goto op_semantics_8;
3253 break;
3255 break;
3256 case 0x05:
3257 GETBYTE ();
3258 switch (op[3] & 0x00)
3260 case 0x00:
3261 goto op_semantics_9;
3262 break;
3264 break;
3265 case 0x06:
3266 GETBYTE ();
3267 switch (op[3] & 0x00)
3269 case 0x00:
3270 goto op_semantics_10;
3271 break;
3273 break;
3274 case 0x07:
3275 GETBYTE ();
3276 switch (op[3] & 0x00)
3278 case 0x00:
3279 goto op_semantics_11;
3280 break;
3282 break;
3283 case 0x08:
3284 GETBYTE ();
3285 switch (op[3] & 0x00)
3287 case 0x00:
3288 goto op_semantics_12;
3289 break;
3291 break;
3292 case 0x09:
3293 GETBYTE ();
3294 switch (op[3] & 0x00)
3296 case 0x00:
3297 goto op_semantics_13;
3298 break;
3300 break;
3301 case 0x0c:
3302 GETBYTE ();
3303 switch (op[3] & 0x00)
3305 case 0x00:
3306 goto op_semantics_14;
3307 break;
3309 break;
3310 case 0x0d:
3311 GETBYTE ();
3312 switch (op[3] & 0x00)
3314 case 0x00:
3315 goto op_semantics_15;
3316 break;
3318 break;
3319 case 0x10:
3320 GETBYTE ();
3321 switch (op[3] & 0x00)
3323 case 0x00:
3324 goto op_semantics_16;
3325 break;
3327 break;
3328 case 0x11:
3329 GETBYTE ();
3330 switch (op[3] & 0x00)
3332 case 0x00:
3333 goto op_semantics_17;
3334 break;
3336 break;
3337 default: UNSUPPORTED(); break;
3339 break;
3340 case 0xe3:
3341 GETBYTE ();
3342 switch (op[2] & 0xff)
3344 case 0x00:
3345 GETBYTE ();
3346 switch (op[3] & 0x00)
3348 case 0x00:
3349 goto op_semantics_7;
3350 break;
3352 break;
3353 case 0x04:
3354 GETBYTE ();
3355 switch (op[3] & 0x00)
3357 case 0x00:
3358 goto op_semantics_8;
3359 break;
3361 break;
3362 case 0x05:
3363 GETBYTE ();
3364 switch (op[3] & 0x00)
3366 case 0x00:
3367 goto op_semantics_9;
3368 break;
3370 break;
3371 case 0x06:
3372 GETBYTE ();
3373 switch (op[3] & 0x00)
3375 case 0x00:
3376 goto op_semantics_10;
3377 break;
3379 break;
3380 case 0x07:
3381 GETBYTE ();
3382 switch (op[3] & 0x00)
3384 case 0x00:
3385 goto op_semantics_11;
3386 break;
3388 break;
3389 case 0x08:
3390 GETBYTE ();
3391 switch (op[3] & 0x00)
3393 case 0x00:
3394 goto op_semantics_12;
3395 break;
3397 break;
3398 case 0x09:
3399 GETBYTE ();
3400 switch (op[3] & 0x00)
3402 case 0x00:
3403 goto op_semantics_13;
3404 break;
3406 break;
3407 case 0x0c:
3408 GETBYTE ();
3409 switch (op[3] & 0x00)
3411 case 0x00:
3412 goto op_semantics_14;
3413 break;
3415 break;
3416 case 0x0d:
3417 GETBYTE ();
3418 switch (op[3] & 0x00)
3420 case 0x00:
3421 goto op_semantics_15;
3422 break;
3424 break;
3425 case 0x10:
3426 GETBYTE ();
3427 switch (op[3] & 0x00)
3429 case 0x00:
3430 goto op_semantics_16;
3431 break;
3433 break;
3434 case 0x11:
3435 GETBYTE ();
3436 switch (op[3] & 0x00)
3438 case 0x00:
3439 goto op_semantics_17;
3440 break;
3442 break;
3443 default: UNSUPPORTED(); break;
3445 break;
3446 default: UNSUPPORTED(); break;
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:
3458 /** 0000 1dsp bra.s %a0 */
3459 #line 699 "rx-decode.opc"
3460 int dsp AU = op[0] & 0x07;
3461 if (trace)
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);
3468 SYNTAX("bra.s %a0");
3469 #line 699 "rx-decode.opc"
3470 ID(branch); DC(pc + dsp3map[dsp]);
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:
3491 /** 0001 n dsp b%1.s %a0 */
3492 #line 689 "rx-decode.opc"
3493 int n AU = (op[0] >> 3) & 0x01;
3494 #line 689 "rx-decode.opc"
3495 int dsp AU = op[0] & 0x07;
3496 if (trace)
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);
3504 SYNTAX("b%1.s %a0");
3505 #line 689 "rx-decode.opc"
3506 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
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:
3526 /** 0010 cond b%1.b %a0 */
3527 #line 692 "rx-decode.opc"
3528 int cond AU = op[0] & 0x0f;
3529 if (trace)
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);
3536 SYNTAX("b%1.b %a0");
3537 #line 692 "rx-decode.opc"
3538 ID(branch); Scc(cond); DC(pc + IMMex (1));
3541 break;
3542 case 0x2e:
3544 /** 0010 1110 bra.b %a0 */
3545 if (trace)
3547 printf ("\033[33m%s\033[0m %02x\n",
3548 "/** 0010 1110 bra.b %a0 */",
3549 op[0]);
3551 SYNTAX("bra.b %a0");
3552 #line 702 "rx-decode.opc"
3553 ID(branch); DC(pc + IMMex(1));
3556 break;
3557 case 0x38:
3559 /** 0011 1000 bra.w %a0 */
3560 if (trace)
3562 printf ("\033[33m%s\033[0m %02x\n",
3563 "/** 0011 1000 bra.w %a0 */",
3564 op[0]);
3566 SYNTAX("bra.w %a0");
3567 #line 705 "rx-decode.opc"
3568 ID(branch); DC(pc + IMMex(2));
3571 break;
3572 case 0x39:
3574 /** 0011 1001 bsr.w %a0 */
3575 if (trace)
3577 printf ("\033[33m%s\033[0m %02x\n",
3578 "/** 0011 1001 bsr.w %a0 */",
3579 op[0]);
3581 SYNTAX("bsr.w %a0");
3582 #line 721 "rx-decode.opc"
3583 ID(jsr); DC(pc + IMMex(2));
3586 break;
3587 case 0x3a:
3588 case 0x3b:
3590 /** 0011 101c b%1.w %a0 */
3591 #line 695 "rx-decode.opc"
3592 int c AU = op[0] & 0x01;
3593 if (trace)
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);
3600 SYNTAX("b%1.w %a0");
3601 #line 695 "rx-decode.opc"
3602 ID(branch); Scc(c); DC(pc + IMMex (2));
3606 break;
3607 case 0x3c:
3608 GETBYTE ();
3609 switch (op[1] & 0x00)
3611 case 0x00:
3612 op_semantics_19:
3614 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3615 #line 271 "rx-decode.opc"
3616 int sz AU = op[0] & 0x03;
3617 #line 271 "rx-decode.opc"
3618 int d AU = (op[1] >> 7) & 0x01;
3619 #line 271 "rx-decode.opc"
3620 int dst AU = (op[1] >> 4) & 0x07;
3621 #line 271 "rx-decode.opc"
3622 int sppp AU = op[1] & 0x0f;
3623 if (trace)
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);
3633 SYNTAX("mov%s #%1, %0");
3634 #line 271 "rx-decode.opc"
3635 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3638 break;
3640 break;
3641 case 0x3d:
3642 GETBYTE ();
3643 switch (op[1] & 0x00)
3645 case 0x00:
3646 goto op_semantics_19;
3647 break;
3649 break;
3650 case 0x3e:
3651 GETBYTE ();
3652 switch (op[1] & 0x00)
3654 case 0x00:
3655 goto op_semantics_19;
3656 break;
3658 break;
3659 case 0x3f:
3660 GETBYTE ();
3661 switch (op[1] & 0x00)
3663 case 0x00:
3665 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3666 #line 367 "rx-decode.opc"
3667 int rega AU = (op[1] >> 4) & 0x0f;
3668 #line 367 "rx-decode.opc"
3669 int regb AU = op[1] & 0x0f;
3670 if (trace)
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);
3678 SYNTAX("rtsd #%1, %2-%0");
3679 #line 367 "rx-decode.opc"
3680 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3682 /*----------------------------------------------------------------------*/
3683 /* AND */
3686 break;
3688 break;
3689 case 0x40:
3690 GETBYTE ();
3691 switch (op[1] & 0x00)
3693 case 0x00:
3694 op_semantics_20:
3696 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3697 #line 502 "rx-decode.opc"
3698 int ss AU = op[0] & 0x03;
3699 #line 502 "rx-decode.opc"
3700 int rsrc AU = (op[1] >> 4) & 0x0f;
3701 #line 502 "rx-decode.opc"
3702 int rdst AU = op[1] & 0x0f;
3703 if (trace)
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);
3712 SYNTAX("sub %2%S2, %1");
3713 #line 502 "rx-decode.opc"
3714 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3717 break;
3719 break;
3720 case 0x41:
3721 GETBYTE ();
3722 switch (op[1] & 0x00)
3724 case 0x00:
3725 goto op_semantics_20;
3726 break;
3728 break;
3729 case 0x42:
3730 GETBYTE ();
3731 switch (op[1] & 0x00)
3733 case 0x00:
3734 goto op_semantics_20;
3735 break;
3737 break;
3738 case 0x43:
3739 GETBYTE ();
3740 switch (op[1] & 0x00)
3742 case 0x00:
3743 goto op_semantics_20;
3744 break;
3746 break;
3747 case 0x44:
3748 GETBYTE ();
3749 switch (op[1] & 0x00)
3751 case 0x00:
3752 op_semantics_21:
3754 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3755 #line 490 "rx-decode.opc"
3756 int ss AU = op[0] & 0x03;
3757 #line 490 "rx-decode.opc"
3758 int rsrc AU = (op[1] >> 4) & 0x0f;
3759 #line 490 "rx-decode.opc"
3760 int rdst AU = op[1] & 0x0f;
3761 if (trace)
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);
3770 SYNTAX("cmp %2%S2, %1");
3771 #line 490 "rx-decode.opc"
3772 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3775 break;
3777 break;
3778 case 0x45:
3779 GETBYTE ();
3780 switch (op[1] & 0x00)
3782 case 0x00:
3783 goto op_semantics_21;
3784 break;
3786 break;
3787 case 0x46:
3788 GETBYTE ();
3789 switch (op[1] & 0x00)
3791 case 0x00:
3792 goto op_semantics_21;
3793 break;
3795 break;
3796 case 0x47:
3797 GETBYTE ();
3798 switch (op[1] & 0x00)
3800 case 0x00:
3801 goto op_semantics_21;
3802 break;
3804 break;
3805 case 0x48:
3806 GETBYTE ();
3807 switch (op[1] & 0x00)
3809 case 0x00:
3810 op_semantics_22:
3812 /** 0100 10ss rsrc rdst add %1%S1, %0 */
3813 #line 466 "rx-decode.opc"
3814 int ss AU = op[0] & 0x03;
3815 #line 466 "rx-decode.opc"
3816 int rsrc AU = (op[1] >> 4) & 0x0f;
3817 #line 466 "rx-decode.opc"
3818 int rdst AU = op[1] & 0x0f;
3819 if (trace)
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);
3828 SYNTAX("add %1%S1, %0");
3829 #line 466 "rx-decode.opc"
3830 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
3833 break;
3835 break;
3836 case 0x49:
3837 GETBYTE ();
3838 switch (op[1] & 0x00)
3840 case 0x00:
3841 goto op_semantics_22;
3842 break;
3844 break;
3845 case 0x4a:
3846 GETBYTE ();
3847 switch (op[1] & 0x00)
3849 case 0x00:
3850 goto op_semantics_22;
3851 break;
3853 break;
3854 case 0x4b:
3855 GETBYTE ();
3856 switch (op[1] & 0x00)
3858 case 0x00:
3859 goto op_semantics_22;
3860 break;
3862 break;
3863 case 0x4c:
3864 GETBYTE ();
3865 switch (op[1] & 0x00)
3867 case 0x00:
3868 op_semantics_23:
3870 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
3871 #line 570 "rx-decode.opc"
3872 int ss AU = op[0] & 0x03;
3873 #line 570 "rx-decode.opc"
3874 int rsrc AU = (op[1] >> 4) & 0x0f;
3875 #line 570 "rx-decode.opc"
3876 int rdst AU = op[1] & 0x0f;
3877 if (trace)
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);
3886 SYNTAX("mul %1%S1, %0");
3887 #line 570 "rx-decode.opc"
3888 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
3891 break;
3893 break;
3894 case 0x4d:
3895 GETBYTE ();
3896 switch (op[1] & 0x00)
3898 case 0x00:
3899 goto op_semantics_23;
3900 break;
3902 break;
3903 case 0x4e:
3904 GETBYTE ();
3905 switch (op[1] & 0x00)
3907 case 0x00:
3908 goto op_semantics_23;
3909 break;
3911 break;
3912 case 0x4f:
3913 GETBYTE ();
3914 switch (op[1] & 0x00)
3916 case 0x00:
3917 goto op_semantics_23;
3918 break;
3920 break;
3921 case 0x50:
3922 GETBYTE ();
3923 switch (op[1] & 0x00)
3925 case 0x00:
3926 op_semantics_24:
3928 /** 0101 00ss rsrc rdst and %1%S1, %0 */
3929 #line 379 "rx-decode.opc"
3930 int ss AU = op[0] & 0x03;
3931 #line 379 "rx-decode.opc"
3932 int rsrc AU = (op[1] >> 4) & 0x0f;
3933 #line 379 "rx-decode.opc"
3934 int rdst AU = op[1] & 0x0f;
3935 if (trace)
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);
3944 SYNTAX("and %1%S1, %0");
3945 #line 379 "rx-decode.opc"
3946 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
3949 break;
3951 break;
3952 case 0x51:
3953 GETBYTE ();
3954 switch (op[1] & 0x00)
3956 case 0x00:
3957 goto op_semantics_24;
3958 break;
3960 break;
3961 case 0x52:
3962 GETBYTE ();
3963 switch (op[1] & 0x00)
3965 case 0x00:
3966 goto op_semantics_24;
3967 break;
3969 break;
3970 case 0x53:
3971 GETBYTE ();
3972 switch (op[1] & 0x00)
3974 case 0x00:
3975 goto op_semantics_24;
3976 break;
3978 break;
3979 case 0x54:
3980 GETBYTE ();
3981 switch (op[1] & 0x00)
3983 case 0x00:
3984 op_semantics_25:
3986 /** 0101 01ss rsrc rdst or %1%S1, %0 */
3987 #line 397 "rx-decode.opc"
3988 int ss AU = op[0] & 0x03;
3989 #line 397 "rx-decode.opc"
3990 int rsrc AU = (op[1] >> 4) & 0x0f;
3991 #line 397 "rx-decode.opc"
3992 int rdst AU = op[1] & 0x0f;
3993 if (trace)
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);
4002 SYNTAX("or %1%S1, %0");
4003 #line 397 "rx-decode.opc"
4004 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4007 break;
4009 break;
4010 case 0x55:
4011 GETBYTE ();
4012 switch (op[1] & 0x00)
4014 case 0x00:
4015 goto op_semantics_25;
4016 break;
4018 break;
4019 case 0x56:
4020 GETBYTE ();
4021 switch (op[1] & 0x00)
4023 case 0x00:
4024 goto op_semantics_25;
4025 break;
4027 break;
4028 case 0x57:
4029 GETBYTE ();
4030 switch (op[1] & 0x00)
4032 case 0x00:
4033 goto op_semantics_25;
4034 break;
4036 break;
4037 case 0x58:
4038 GETBYTE ();
4039 switch (op[1] & 0x00)
4041 case 0x00:
4042 op_semantics_26:
4044 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4045 #line 318 "rx-decode.opc"
4046 int s AU = (op[0] >> 2) & 0x01;
4047 #line 318 "rx-decode.opc"
4048 int ss AU = op[0] & 0x03;
4049 #line 318 "rx-decode.opc"
4050 int rsrc AU = (op[1] >> 4) & 0x0f;
4051 #line 318 "rx-decode.opc"
4052 int rdst AU = op[1] & 0x0f;
4053 if (trace)
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);
4063 SYNTAX("movu%s %1, %0");
4064 #line 318 "rx-decode.opc"
4065 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____;
4068 break;
4070 break;
4071 case 0x59:
4072 GETBYTE ();
4073 switch (op[1] & 0x00)
4075 case 0x00:
4076 goto op_semantics_26;
4077 break;
4079 break;
4080 case 0x5a:
4081 GETBYTE ();
4082 switch (op[1] & 0x00)
4084 case 0x00:
4085 goto op_semantics_26;
4086 break;
4088 break;
4089 case 0x5b:
4090 GETBYTE ();
4091 switch (op[1] & 0x00)
4093 case 0x00:
4094 goto op_semantics_26;
4095 break;
4097 break;
4098 case 0x5c:
4099 GETBYTE ();
4100 switch (op[1] & 0x00)
4102 case 0x00:
4103 goto op_semantics_26;
4104 break;
4106 break;
4107 case 0x5d:
4108 GETBYTE ();
4109 switch (op[1] & 0x00)
4111 case 0x00:
4112 goto op_semantics_26;
4113 break;
4115 break;
4116 case 0x5e:
4117 GETBYTE ();
4118 switch (op[1] & 0x00)
4120 case 0x00:
4121 goto op_semantics_26;
4122 break;
4124 break;
4125 case 0x5f:
4126 GETBYTE ();
4127 switch (op[1] & 0x00)
4129 case 0x00:
4130 goto op_semantics_26;
4131 break;
4133 break;
4134 case 0x60:
4135 GETBYTE ();
4136 switch (op[1] & 0x00)
4138 case 0x00:
4140 /** 0110 0000 immm rdst sub #%2, %0 */
4141 #line 499 "rx-decode.opc"
4142 int immm AU = (op[1] >> 4) & 0x0f;
4143 #line 499 "rx-decode.opc"
4144 int rdst AU = op[1] & 0x0f;
4145 if (trace)
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);
4153 SYNTAX("sub #%2, %0");
4154 #line 499 "rx-decode.opc"
4155 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4158 break;
4160 break;
4161 case 0x61:
4162 GETBYTE ();
4163 switch (op[1] & 0x00)
4165 case 0x00:
4167 /** 0110 0001 immm rdst cmp #%2, %1 */
4168 #line 481 "rx-decode.opc"
4169 int immm AU = (op[1] >> 4) & 0x0f;
4170 #line 481 "rx-decode.opc"
4171 int rdst AU = op[1] & 0x0f;
4172 if (trace)
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);
4180 SYNTAX("cmp #%2, %1");
4181 #line 481 "rx-decode.opc"
4182 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4185 break;
4187 break;
4188 case 0x62:
4189 GETBYTE ();
4190 switch (op[1] & 0x00)
4192 case 0x00:
4194 /** 0110 0010 immm rdst add #%1, %0 */
4195 #line 463 "rx-decode.opc"
4196 int immm AU = (op[1] >> 4) & 0x0f;
4197 #line 463 "rx-decode.opc"
4198 int rdst AU = op[1] & 0x0f;
4199 if (trace)
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);
4207 SYNTAX("add #%1, %0");
4208 #line 463 "rx-decode.opc"
4209 ID(add); SC(immm); DR(rdst); F_OSZC;
4212 break;
4214 break;
4215 case 0x63:
4216 GETBYTE ();
4217 switch (op[1] & 0x00)
4219 case 0x00:
4221 /** 0110 0011 immm rdst mul #%1, %0 */
4222 #line 564 "rx-decode.opc"
4223 int immm AU = (op[1] >> 4) & 0x0f;
4224 #line 564 "rx-decode.opc"
4225 int rdst AU = op[1] & 0x0f;
4226 if (trace)
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);
4234 SYNTAX("mul #%1, %0");
4235 #line 564 "rx-decode.opc"
4236 ID(mul); DR(rdst); SC(immm); F_____;
4239 break;
4241 break;
4242 case 0x64:
4243 GETBYTE ();
4244 switch (op[1] & 0x00)
4246 case 0x00:
4248 /** 0110 0100 immm rdst and #%1, %0 */
4249 #line 373 "rx-decode.opc"
4250 int immm AU = (op[1] >> 4) & 0x0f;
4251 #line 373 "rx-decode.opc"
4252 int rdst AU = op[1] & 0x0f;
4253 if (trace)
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);
4261 SYNTAX("and #%1, %0");
4262 #line 373 "rx-decode.opc"
4263 ID(and); SC(immm); DR(rdst); F__SZ_;
4266 break;
4268 break;
4269 case 0x65:
4270 GETBYTE ();
4271 switch (op[1] & 0x00)
4273 case 0x00:
4275 /** 0110 0101 immm rdst or #%1, %0 */
4276 #line 391 "rx-decode.opc"
4277 int immm AU = (op[1] >> 4) & 0x0f;
4278 #line 391 "rx-decode.opc"
4279 int rdst AU = op[1] & 0x0f;
4280 if (trace)
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);
4288 SYNTAX("or #%1, %0");
4289 #line 391 "rx-decode.opc"
4290 ID(or); SC(immm); DR(rdst); F__SZ_;
4293 break;
4295 break;
4296 case 0x66:
4297 GETBYTE ();
4298 switch (op[1] & 0x00)
4300 case 0x00:
4302 /** 0110 0110 immm rdst mov%s #%1, %0 */
4303 #line 268 "rx-decode.opc"
4304 int immm AU = (op[1] >> 4) & 0x0f;
4305 #line 268 "rx-decode.opc"
4306 int rdst AU = op[1] & 0x0f;
4307 if (trace)
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);
4315 SYNTAX("mov%s #%1, %0");
4316 #line 268 "rx-decode.opc"
4317 ID(mov); DR(rdst); SC(immm); F_____;
4320 break;
4322 break;
4323 case 0x67:
4325 /** 0110 0111 rtsd #%1 */
4326 if (trace)
4328 printf ("\033[33m%s\033[0m %02x\n",
4329 "/** 0110 0111 rtsd #%1 */",
4330 op[0]);
4332 SYNTAX("rtsd #%1");
4333 #line 364 "rx-decode.opc"
4334 ID(rtsd); SC(IMM(1) * 4);
4337 break;
4338 case 0x68:
4339 GETBYTE ();
4340 switch (op[1] & 0x00)
4342 case 0x00:
4343 op_semantics_27:
4345 /** 0110 100i mmmm rdst shlr #%2, %0 */
4346 #line 650 "rx-decode.opc"
4347 int i AU = op[0] & 0x01;
4348 #line 650 "rx-decode.opc"
4349 int mmmm AU = (op[1] >> 4) & 0x0f;
4350 #line 650 "rx-decode.opc"
4351 int rdst AU = op[1] & 0x0f;
4352 if (trace)
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);
4361 SYNTAX("shlr #%2, %0");
4362 #line 650 "rx-decode.opc"
4363 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4366 break;
4368 break;
4369 case 0x69:
4370 GETBYTE ();
4371 switch (op[1] & 0x00)
4373 case 0x00:
4374 goto op_semantics_27;
4375 break;
4377 break;
4378 case 0x6a:
4379 GETBYTE ();
4380 switch (op[1] & 0x00)
4382 case 0x00:
4383 op_semantics_28:
4385 /** 0110 101i mmmm rdst shar #%2, %0 */
4386 #line 640 "rx-decode.opc"
4387 int i AU = op[0] & 0x01;
4388 #line 640 "rx-decode.opc"
4389 int mmmm AU = (op[1] >> 4) & 0x0f;
4390 #line 640 "rx-decode.opc"
4391 int rdst AU = op[1] & 0x0f;
4392 if (trace)
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);
4401 SYNTAX("shar #%2, %0");
4402 #line 640 "rx-decode.opc"
4403 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4406 break;
4408 break;
4409 case 0x6b:
4410 GETBYTE ();
4411 switch (op[1] & 0x00)
4413 case 0x00:
4414 goto op_semantics_28;
4415 break;
4417 break;
4418 case 0x6c:
4419 GETBYTE ();
4420 switch (op[1] & 0x00)
4422 case 0x00:
4423 op_semantics_29:
4425 /** 0110 110i mmmm rdst shll #%2, %0 */
4426 #line 630 "rx-decode.opc"
4427 int i AU = op[0] & 0x01;
4428 #line 630 "rx-decode.opc"
4429 int mmmm AU = (op[1] >> 4) & 0x0f;
4430 #line 630 "rx-decode.opc"
4431 int rdst AU = op[1] & 0x0f;
4432 if (trace)
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);
4441 SYNTAX("shll #%2, %0");
4442 #line 630 "rx-decode.opc"
4443 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4446 break;
4448 break;
4449 case 0x6d:
4450 GETBYTE ();
4451 switch (op[1] & 0x00)
4453 case 0x00:
4454 goto op_semantics_29;
4455 break;
4457 break;
4458 case 0x6e:
4459 GETBYTE ();
4460 switch (op[1] & 0x00)
4462 case 0x00:
4464 /** 0110 1110 dsta dstb pushm %1-%2 */
4465 #line 331 "rx-decode.opc"
4466 int dsta AU = (op[1] >> 4) & 0x0f;
4467 #line 331 "rx-decode.opc"
4468 int dstb AU = op[1] & 0x0f;
4469 if (trace)
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);
4477 SYNTAX("pushm %1-%2");
4478 #line 331 "rx-decode.opc"
4479 ID(pushm); SR(dsta); S2R(dstb); F_____;
4482 break;
4484 break;
4485 case 0x6f:
4486 GETBYTE ();
4487 switch (op[1] & 0x00)
4489 case 0x00:
4491 /** 0110 1111 dsta dstb popm %1-%2 */
4492 #line 328 "rx-decode.opc"
4493 int dsta AU = (op[1] >> 4) & 0x0f;
4494 #line 328 "rx-decode.opc"
4495 int dstb AU = op[1] & 0x0f;
4496 if (trace)
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);
4504 SYNTAX("popm %1-%2");
4505 #line 328 "rx-decode.opc"
4506 ID(popm); SR(dsta); S2R(dstb); F_____;
4509 break;
4511 break;
4512 case 0x70:
4513 GETBYTE ();
4514 switch (op[1] & 0x00)
4516 case 0x00:
4517 op_semantics_30:
4519 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4520 #line 472 "rx-decode.opc"
4521 int im AU = op[0] & 0x03;
4522 #line 472 "rx-decode.opc"
4523 int rsrc AU = (op[1] >> 4) & 0x0f;
4524 #line 472 "rx-decode.opc"
4525 int rdst AU = op[1] & 0x0f;
4526 if (trace)
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);
4535 SYNTAX("add #%1, %2, %0");
4536 #line 472 "rx-decode.opc"
4537 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4540 break;
4542 break;
4543 case 0x71:
4544 GETBYTE ();
4545 switch (op[1] & 0x00)
4547 case 0x00:
4548 goto op_semantics_30;
4549 break;
4551 break;
4552 case 0x72:
4553 GETBYTE ();
4554 switch (op[1] & 0x00)
4556 case 0x00:
4557 goto op_semantics_30;
4558 break;
4560 break;
4561 case 0x73:
4562 GETBYTE ();
4563 switch (op[1] & 0x00)
4565 case 0x00:
4566 goto op_semantics_30;
4567 break;
4569 break;
4570 case 0x74:
4571 GETBYTE ();
4572 switch (op[1] & 0xf0)
4574 case 0x00:
4575 op_semantics_31:
4577 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4578 #line 484 "rx-decode.opc"
4579 int im AU = op[0] & 0x03;
4580 #line 484 "rx-decode.opc"
4581 int rsrc AU = op[1] & 0x0f;
4582 if (trace)
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);
4590 SYNTAX("cmp #%2, %1%S1");
4591 #line 484 "rx-decode.opc"
4592 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4595 break;
4596 case 0x10:
4597 op_semantics_32:
4599 /** 0111 01im 0001rdst mul #%1, %0 */
4600 #line 567 "rx-decode.opc"
4601 int im AU = op[0] & 0x03;
4602 #line 567 "rx-decode.opc"
4603 int rdst AU = op[1] & 0x0f;
4604 if (trace)
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);
4612 SYNTAX("mul #%1, %0");
4613 #line 567 "rx-decode.opc"
4614 ID(mul); DR(rdst); SC(IMMex(im)); F_____;
4617 break;
4618 case 0x20:
4619 op_semantics_33:
4621 /** 0111 01im 0010 rdst and #%1, %0 */
4622 #line 376 "rx-decode.opc"
4623 int im AU = op[0] & 0x03;
4624 #line 376 "rx-decode.opc"
4625 int rdst AU = op[1] & 0x0f;
4626 if (trace)
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);
4634 SYNTAX("and #%1, %0");
4635 #line 376 "rx-decode.opc"
4636 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4639 break;
4640 case 0x30:
4641 op_semantics_34:
4643 /** 0111 01im 0011 rdst or #%1, %0 */
4644 #line 394 "rx-decode.opc"
4645 int im AU = op[0] & 0x03;
4646 #line 394 "rx-decode.opc"
4647 int rdst AU = op[1] & 0x0f;
4648 if (trace)
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);
4656 SYNTAX("or #%1, %0");
4657 #line 394 "rx-decode.opc"
4658 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4661 break;
4662 default: UNSUPPORTED(); break;
4664 break;
4665 case 0x75:
4666 GETBYTE ();
4667 switch (op[1] & 0xff)
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:
4758 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4759 #line 262 "rx-decode.opc"
4760 int rdst AU = op[1] & 0x0f;
4761 if (trace)
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);
4768 SYNTAX("mov%s #%1, %0");
4769 #line 262 "rx-decode.opc"
4770 ID(mov); DR(rdst); SC(IMM (1)); F_____;
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:
4791 /** 0111 0101 0101 rsrc cmp #%2, %1 */
4792 #line 487 "rx-decode.opc"
4793 int rsrc AU = op[1] & 0x0f;
4794 if (trace)
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);
4801 SYNTAX("cmp #%2, %1");
4802 #line 487 "rx-decode.opc"
4803 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
4806 break;
4807 case 0x60:
4809 /** 0111 0101 0110 0000 int #%1 */
4810 if (trace)
4812 printf ("\033[33m%s\033[0m %02x %02x\n",
4813 "/** 0111 0101 0110 0000 int #%1 */",
4814 op[0], op[1]);
4816 SYNTAX("int #%1");
4817 #line 947 "rx-decode.opc"
4818 ID(int); SC(IMM(1));
4821 break;
4822 case 0x70:
4823 GETBYTE ();
4824 switch (op[2] & 0xf0)
4826 case 0x00:
4828 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
4829 #line 914 "rx-decode.opc"
4830 int immm AU = op[2] & 0x0f;
4831 if (trace)
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);
4838 SYNTAX("mvtipl #%1");
4839 #line 914 "rx-decode.opc"
4840 ID(mvtipl); SC(immm);
4843 break;
4844 default: UNSUPPORTED(); break;
4846 break;
4847 default: UNSUPPORTED(); break;
4849 break;
4850 case 0x76:
4851 GETBYTE ();
4852 switch (op[1] & 0xf0)
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;
4868 break;
4869 case 0x77:
4870 GETBYTE ();
4871 switch (op[1] & 0xf0)
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;
4887 break;
4888 case 0x78:
4889 GETBYTE ();
4890 switch (op[1] & 0x00)
4892 case 0x00:
4893 op_semantics_35:
4895 /** 0111 100b ittt rdst bset #%1, %0 */
4896 #line 865 "rx-decode.opc"
4897 int b AU = op[0] & 0x01;
4898 #line 865 "rx-decode.opc"
4899 int ittt AU = (op[1] >> 4) & 0x0f;
4900 #line 865 "rx-decode.opc"
4901 int rdst AU = op[1] & 0x0f;
4902 if (trace)
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);
4911 SYNTAX("bset #%1, %0");
4912 #line 865 "rx-decode.opc"
4913 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4917 break;
4919 break;
4920 case 0x79:
4921 GETBYTE ();
4922 switch (op[1] & 0x00)
4924 case 0x00:
4925 goto op_semantics_35;
4926 break;
4928 break;
4929 case 0x7a:
4930 GETBYTE ();
4931 switch (op[1] & 0x00)
4933 case 0x00:
4934 op_semantics_36:
4936 /** 0111 101b ittt rdst bclr #%1, %0 */
4937 #line 875 "rx-decode.opc"
4938 int b AU = op[0] & 0x01;
4939 #line 875 "rx-decode.opc"
4940 int ittt AU = (op[1] >> 4) & 0x0f;
4941 #line 875 "rx-decode.opc"
4942 int rdst AU = op[1] & 0x0f;
4943 if (trace)
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);
4952 SYNTAX("bclr #%1, %0");
4953 #line 875 "rx-decode.opc"
4954 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4958 break;
4960 break;
4961 case 0x7b:
4962 GETBYTE ();
4963 switch (op[1] & 0x00)
4965 case 0x00:
4966 goto op_semantics_36;
4967 break;
4969 break;
4970 case 0x7c:
4971 GETBYTE ();
4972 switch (op[1] & 0x00)
4974 case 0x00:
4975 op_semantics_37:
4977 /** 0111 110b ittt rdst btst #%2, %1 */
4978 #line 885 "rx-decode.opc"
4979 int b AU = op[0] & 0x01;
4980 #line 885 "rx-decode.opc"
4981 int ittt AU = (op[1] >> 4) & 0x0f;
4982 #line 885 "rx-decode.opc"
4983 int rdst AU = op[1] & 0x0f;
4984 if (trace)
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);
4993 SYNTAX("btst #%2, %1");
4994 #line 885 "rx-decode.opc"
4995 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
4999 break;
5001 break;
5002 case 0x7d:
5003 GETBYTE ();
5004 switch (op[1] & 0x00)
5006 case 0x00:
5007 goto op_semantics_37;
5008 break;
5010 break;
5011 case 0x7e:
5012 GETBYTE ();
5013 switch (op[1] & 0xf0)
5015 case 0x00:
5017 /** 0111 1110 0000 rdst not %0 */
5018 #line 421 "rx-decode.opc"
5019 int rdst AU = op[1] & 0x0f;
5020 if (trace)
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);
5027 SYNTAX("not %0");
5028 #line 421 "rx-decode.opc"
5029 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5032 break;
5033 case 0x10:
5035 /** 0111 1110 0001 rdst neg %0 */
5036 #line 442 "rx-decode.opc"
5037 int rdst AU = op[1] & 0x0f;
5038 if (trace)
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);
5045 SYNTAX("neg %0");
5046 #line 442 "rx-decode.opc"
5047 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5050 break;
5051 case 0x20:
5053 /** 0111 1110 0010 rdst abs %0 */
5054 #line 524 "rx-decode.opc"
5055 int rdst AU = op[1] & 0x0f;
5056 if (trace)
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);
5063 SYNTAX("abs %0");
5064 #line 524 "rx-decode.opc"
5065 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5068 break;
5069 case 0x30:
5071 /** 0111 1110 0011 rdst sat %0 */
5072 #line 805 "rx-decode.opc"
5073 int rdst AU = op[1] & 0x0f;
5074 if (trace)
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);
5081 SYNTAX("sat %0");
5082 #line 805 "rx-decode.opc"
5083 ID(sat); DR (rdst);
5086 break;
5087 case 0x40:
5089 /** 0111 1110 0100 rdst rorc %0 */
5090 #line 665 "rx-decode.opc"
5091 int rdst AU = op[1] & 0x0f;
5092 if (trace)
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);
5099 SYNTAX("rorc %0");
5100 #line 665 "rx-decode.opc"
5101 ID(rorc); DR(rdst); F__SZC;
5104 break;
5105 case 0x50:
5107 /** 0111 1110 0101 rdst rolc %0 */
5108 #line 662 "rx-decode.opc"
5109 int rdst AU = op[1] & 0x0f;
5110 if (trace)
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);
5117 SYNTAX("rolc %0");
5118 #line 662 "rx-decode.opc"
5119 ID(rolc); DR(rdst); F__SZC;
5122 break;
5123 case 0x80:
5124 case 0x90:
5125 case 0xa0:
5127 /** 0111 1110 10sz rsrc push%s %1 */
5128 #line 337 "rx-decode.opc"
5129 int sz AU = (op[1] >> 4) & 0x03;
5130 #line 337 "rx-decode.opc"
5131 int rsrc AU = op[1] & 0x0f;
5132 if (trace)
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);
5140 SYNTAX("push%s %1");
5141 #line 337 "rx-decode.opc"
5142 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5145 break;
5146 case 0xb0:
5148 /** 0111 1110 1011 rdst pop %0 */
5149 #line 334 "rx-decode.opc"
5150 int rdst AU = op[1] & 0x0f;
5151 if (trace)
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);
5158 SYNTAX("pop %0");
5159 #line 334 "rx-decode.opc"
5160 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5163 break;
5164 case 0xc0:
5165 case 0xd0:
5167 /** 0111 1110 110 crsrc pushc %1 */
5168 #line 920 "rx-decode.opc"
5169 int crsrc AU = op[1] & 0x1f;
5170 if (trace)
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);
5177 SYNTAX("pushc %1");
5178 #line 920 "rx-decode.opc"
5179 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5182 break;
5183 case 0xe0:
5184 case 0xf0:
5186 /** 0111 1110 111 crdst popc %0 */
5187 #line 917 "rx-decode.opc"
5188 int crdst AU = op[1] & 0x1f;
5189 if (trace)
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);
5196 SYNTAX("popc %0");
5197 #line 917 "rx-decode.opc"
5198 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5201 break;
5202 default: UNSUPPORTED(); break;
5204 break;
5205 case 0x7f:
5206 GETBYTE ();
5207 switch (op[1] & 0xff)
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:
5226 /** 0111 1111 0000 rsrc jmp %0 */
5227 #line 715 "rx-decode.opc"
5228 int rsrc AU = op[1] & 0x0f;
5229 if (trace)
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);
5236 SYNTAX("jmp %0");
5237 #line 715 "rx-decode.opc"
5238 ID(branch); DR(rsrc);
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:
5259 /** 0111 1111 0001 rsrc jsr %0 */
5260 #line 718 "rx-decode.opc"
5261 int rsrc AU = op[1] & 0x0f;
5262 if (trace)
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);
5269 SYNTAX("jsr %0");
5270 #line 718 "rx-decode.opc"
5271 ID(jsr); DR(rsrc);
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:
5292 /** 0111 1111 0100 rsrc bra.l %0 */
5293 #line 711 "rx-decode.opc"
5294 int rsrc AU = op[1] & 0x0f;
5295 if (trace)
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);
5302 SYNTAX("bra.l %0");
5303 #line 711 "rx-decode.opc"
5304 ID(branchrel); DR(rsrc);
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:
5326 /** 0111 1111 0101 rsrc bsr.l %0 */
5327 #line 727 "rx-decode.opc"
5328 int rsrc AU = op[1] & 0x0f;
5329 if (trace)
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);
5336 SYNTAX("bsr.l %0");
5337 #line 727 "rx-decode.opc"
5338 ID(jsrrel); DR(rsrc);
5341 break;
5342 case 0x80:
5343 case 0x81:
5344 case 0x82:
5346 /** 0111 1111 1000 00sz suntil%s */
5347 #line 751 "rx-decode.opc"
5348 int sz AU = op[1] & 0x03;
5349 if (trace)
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);
5356 SYNTAX("suntil%s");
5357 #line 751 "rx-decode.opc"
5358 ID(suntil); BWL(sz); F___ZC;
5361 break;
5362 case 0x83:
5364 /** 0111 1111 1000 0011 scmpu */
5365 if (trace)
5367 printf ("\033[33m%s\033[0m %02x %02x\n",
5368 "/** 0111 1111 1000 0011 scmpu */",
5369 op[0], op[1]);
5371 SYNTAX("scmpu");
5372 #line 742 "rx-decode.opc"
5373 ID(scmpu); F___ZC;
5376 break;
5377 case 0x84:
5378 case 0x85:
5379 case 0x86:
5381 /** 0111 1111 1000 01sz swhile%s */
5382 #line 754 "rx-decode.opc"
5383 int sz AU = op[1] & 0x03;
5384 if (trace)
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);
5391 SYNTAX("swhile%s");
5392 #line 754 "rx-decode.opc"
5393 ID(swhile); BWL(sz); F___ZC;
5396 break;
5397 case 0x87:
5399 /** 0111 1111 1000 0111 smovu */
5400 if (trace)
5402 printf ("\033[33m%s\033[0m %02x %02x\n",
5403 "/** 0111 1111 1000 0111 smovu */",
5404 op[0], op[1]);
5406 SYNTAX("smovu");
5407 #line 745 "rx-decode.opc"
5408 ID(smovu);
5411 break;
5412 case 0x88:
5413 case 0x89:
5414 case 0x8a:
5416 /** 0111 1111 1000 10sz sstr%s */
5417 #line 760 "rx-decode.opc"
5418 int sz AU = op[1] & 0x03;
5419 if (trace)
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);
5426 SYNTAX("sstr%s");
5427 #line 760 "rx-decode.opc"
5428 ID(sstr); BWL(sz);
5430 /*----------------------------------------------------------------------*/
5431 /* RMPA */
5434 break;
5435 case 0x8b:
5437 /** 0111 1111 1000 1011 smovb */
5438 if (trace)
5440 printf ("\033[33m%s\033[0m %02x %02x\n",
5441 "/** 0111 1111 1000 1011 smovb */",
5442 op[0], op[1]);
5444 SYNTAX("smovb");
5445 #line 748 "rx-decode.opc"
5446 ID(smovb);
5449 break;
5450 case 0x8c:
5451 case 0x8d:
5452 case 0x8e:
5454 /** 0111 1111 1000 11sz rmpa%s */
5455 #line 766 "rx-decode.opc"
5456 int sz AU = op[1] & 0x03;
5457 if (trace)
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);
5464 SYNTAX("rmpa%s");
5465 #line 766 "rx-decode.opc"
5466 ID(rmpa); BWL(sz); F_OS__;
5468 /*----------------------------------------------------------------------*/
5469 /* HI/LO stuff */
5472 break;
5473 case 0x8f:
5475 /** 0111 1111 1000 1111 smovf */
5476 if (trace)
5478 printf ("\033[33m%s\033[0m %02x %02x\n",
5479 "/** 0111 1111 1000 1111 smovf */",
5480 op[0], op[1]);
5482 SYNTAX("smovf");
5483 #line 757 "rx-decode.opc"
5484 ID(smovf);
5487 break;
5488 case 0x93:
5490 /** 0111 1111 1001 0011 satr */
5491 if (trace)
5493 printf ("\033[33m%s\033[0m %02x %02x\n",
5494 "/** 0111 1111 1001 0011 satr */",
5495 op[0], op[1]);
5497 SYNTAX("satr");
5498 #line 808 "rx-decode.opc"
5499 ID(satr);
5501 /*----------------------------------------------------------------------*/
5502 /* FLOAT */
5505 break;
5506 case 0x94:
5508 /** 0111 1111 1001 0100 rtfi */
5509 if (trace)
5511 printf ("\033[33m%s\033[0m %02x %02x\n",
5512 "/** 0111 1111 1001 0100 rtfi */",
5513 op[0], op[1]);
5515 SYNTAX("rtfi");
5516 #line 935 "rx-decode.opc"
5517 ID(rtfi);
5520 break;
5521 case 0x95:
5523 /** 0111 1111 1001 0101 rte */
5524 if (trace)
5526 printf ("\033[33m%s\033[0m %02x %02x\n",
5527 "/** 0111 1111 1001 0101 rte */",
5528 op[0], op[1]);
5530 SYNTAX("rte");
5531 #line 938 "rx-decode.opc"
5532 ID(rte);
5535 break;
5536 case 0x96:
5538 /** 0111 1111 1001 0110 wait */
5539 if (trace)
5541 printf ("\033[33m%s\033[0m %02x %02x\n",
5542 "/** 0111 1111 1001 0110 wait */",
5543 op[0], op[1]);
5545 SYNTAX("wait");
5546 #line 950 "rx-decode.opc"
5547 ID(wait);
5549 /*----------------------------------------------------------------------*/
5550 /* SCcnd */
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:
5571 /** 0111 1111 1010 rdst setpsw %0 */
5572 #line 911 "rx-decode.opc"
5573 int rdst AU = op[1] & 0x0f;
5574 if (trace)
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);
5581 SYNTAX("setpsw %0");
5582 #line 911 "rx-decode.opc"
5583 ID(setpsw); DF(rdst);
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:
5604 /** 0111 1111 1011 rdst clrpsw %0 */
5605 #line 908 "rx-decode.opc"
5606 int rdst AU = op[1] & 0x0f;
5607 if (trace)
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);
5614 SYNTAX("clrpsw %0");
5615 #line 908 "rx-decode.opc"
5616 ID(clrpsw); DF(rdst);
5619 break;
5620 default: UNSUPPORTED(); break;
5622 break;
5623 case 0x80:
5624 GETBYTE ();
5625 switch (op[1] & 0x00)
5627 case 0x00:
5628 op_semantics_38:
5630 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5631 #line 295 "rx-decode.opc"
5632 int sz AU = (op[0] >> 4) & 0x03;
5633 #line 295 "rx-decode.opc"
5634 int dsp AU = op[0] & 0x07;
5635 #line 295 "rx-decode.opc"
5636 int a AU = (op[1] >> 7) & 0x01;
5637 #line 295 "rx-decode.opc"
5638 int dst AU = (op[1] >> 4) & 0x07;
5639 #line 295 "rx-decode.opc"
5640 int b AU = (op[1] >> 3) & 0x01;
5641 #line 295 "rx-decode.opc"
5642 int src AU = op[1] & 0x07;
5643 if (trace)
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);
5655 SYNTAX("mov%s %1, %0");
5656 #line 295 "rx-decode.opc"
5657 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5660 break;
5662 break;
5663 case 0x81:
5664 GETBYTE ();
5665 switch (op[1] & 0x00)
5667 case 0x00:
5668 goto op_semantics_38;
5669 break;
5671 break;
5672 case 0x82:
5673 GETBYTE ();
5674 switch (op[1] & 0x00)
5676 case 0x00:
5677 goto op_semantics_38;
5678 break;
5680 break;
5681 case 0x83:
5682 GETBYTE ();
5683 switch (op[1] & 0x00)
5685 case 0x00:
5686 goto op_semantics_38;
5687 break;
5689 break;
5690 case 0x84:
5691 GETBYTE ();
5692 switch (op[1] & 0x00)
5694 case 0x00:
5695 goto op_semantics_38;
5696 break;
5698 break;
5699 case 0x85:
5700 GETBYTE ();
5701 switch (op[1] & 0x00)
5703 case 0x00:
5704 goto op_semantics_38;
5705 break;
5707 break;
5708 case 0x86:
5709 GETBYTE ();
5710 switch (op[1] & 0x00)
5712 case 0x00:
5713 goto op_semantics_38;
5714 break;
5716 break;
5717 case 0x87:
5718 GETBYTE ();
5719 switch (op[1] & 0x00)
5721 case 0x00:
5722 goto op_semantics_38;
5723 break;
5725 break;
5726 case 0x88:
5727 GETBYTE ();
5728 switch (op[1] & 0x00)
5730 case 0x00:
5731 op_semantics_39:
5733 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5734 #line 292 "rx-decode.opc"
5735 int sz AU = (op[0] >> 4) & 0x03;
5736 #line 292 "rx-decode.opc"
5737 int dsp AU = op[0] & 0x07;
5738 #line 292 "rx-decode.opc"
5739 int a AU = (op[1] >> 7) & 0x01;
5740 #line 292 "rx-decode.opc"
5741 int src AU = (op[1] >> 4) & 0x07;
5742 #line 292 "rx-decode.opc"
5743 int b AU = (op[1] >> 3) & 0x01;
5744 #line 292 "rx-decode.opc"
5745 int dst AU = op[1] & 0x07;
5746 if (trace)
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);
5758 SYNTAX("mov%s %1, %0");
5759 #line 292 "rx-decode.opc"
5760 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5763 break;
5765 break;
5766 case 0x89:
5767 GETBYTE ();
5768 switch (op[1] & 0x00)
5770 case 0x00:
5771 goto op_semantics_39;
5772 break;
5774 break;
5775 case 0x8a:
5776 GETBYTE ();
5777 switch (op[1] & 0x00)
5779 case 0x00:
5780 goto op_semantics_39;
5781 break;
5783 break;
5784 case 0x8b:
5785 GETBYTE ();
5786 switch (op[1] & 0x00)
5788 case 0x00:
5789 goto op_semantics_39;
5790 break;
5792 break;
5793 case 0x8c:
5794 GETBYTE ();
5795 switch (op[1] & 0x00)
5797 case 0x00:
5798 goto op_semantics_39;
5799 break;
5801 break;
5802 case 0x8d:
5803 GETBYTE ();
5804 switch (op[1] & 0x00)
5806 case 0x00:
5807 goto op_semantics_39;
5808 break;
5810 break;
5811 case 0x8e:
5812 GETBYTE ();
5813 switch (op[1] & 0x00)
5815 case 0x00:
5816 goto op_semantics_39;
5817 break;
5819 break;
5820 case 0x8f:
5821 GETBYTE ();
5822 switch (op[1] & 0x00)
5824 case 0x00:
5825 goto op_semantics_39;
5826 break;
5828 break;
5829 case 0x90:
5830 GETBYTE ();
5831 switch (op[1] & 0x00)
5833 case 0x00:
5834 goto op_semantics_38;
5835 break;
5837 break;
5838 case 0x91:
5839 GETBYTE ();
5840 switch (op[1] & 0x00)
5842 case 0x00:
5843 goto op_semantics_38;
5844 break;
5846 break;
5847 case 0x92:
5848 GETBYTE ();
5849 switch (op[1] & 0x00)
5851 case 0x00:
5852 goto op_semantics_38;
5853 break;
5855 break;
5856 case 0x93:
5857 GETBYTE ();
5858 switch (op[1] & 0x00)
5860 case 0x00:
5861 goto op_semantics_38;
5862 break;
5864 break;
5865 case 0x94:
5866 GETBYTE ();
5867 switch (op[1] & 0x00)
5869 case 0x00:
5870 goto op_semantics_38;
5871 break;
5873 break;
5874 case 0x95:
5875 GETBYTE ();
5876 switch (op[1] & 0x00)
5878 case 0x00:
5879 goto op_semantics_38;
5880 break;
5882 break;
5883 case 0x96:
5884 GETBYTE ();
5885 switch (op[1] & 0x00)
5887 case 0x00:
5888 goto op_semantics_38;
5889 break;
5891 break;
5892 case 0x97:
5893 GETBYTE ();
5894 switch (op[1] & 0x00)
5896 case 0x00:
5897 goto op_semantics_38;
5898 break;
5900 break;
5901 case 0x98:
5902 GETBYTE ();
5903 switch (op[1] & 0x00)
5905 case 0x00:
5906 goto op_semantics_39;
5907 break;
5909 break;
5910 case 0x99:
5911 GETBYTE ();
5912 switch (op[1] & 0x00)
5914 case 0x00:
5915 goto op_semantics_39;
5916 break;
5918 break;
5919 case 0x9a:
5920 GETBYTE ();
5921 switch (op[1] & 0x00)
5923 case 0x00:
5924 goto op_semantics_39;
5925 break;
5927 break;
5928 case 0x9b:
5929 GETBYTE ();
5930 switch (op[1] & 0x00)
5932 case 0x00:
5933 goto op_semantics_39;
5934 break;
5936 break;
5937 case 0x9c:
5938 GETBYTE ();
5939 switch (op[1] & 0x00)
5941 case 0x00:
5942 goto op_semantics_39;
5943 break;
5945 break;
5946 case 0x9d:
5947 GETBYTE ();
5948 switch (op[1] & 0x00)
5950 case 0x00:
5951 goto op_semantics_39;
5952 break;
5954 break;
5955 case 0x9e:
5956 GETBYTE ();
5957 switch (op[1] & 0x00)
5959 case 0x00:
5960 goto op_semantics_39;
5961 break;
5963 break;
5964 case 0x9f:
5965 GETBYTE ();
5966 switch (op[1] & 0x00)
5968 case 0x00:
5969 goto op_semantics_39;
5970 break;
5972 break;
5973 case 0xa0:
5974 GETBYTE ();
5975 switch (op[1] & 0x00)
5977 case 0x00:
5978 goto op_semantics_38;
5979 break;
5981 break;
5982 case 0xa1:
5983 GETBYTE ();
5984 switch (op[1] & 0x00)
5986 case 0x00:
5987 goto op_semantics_38;
5988 break;
5990 break;
5991 case 0xa2:
5992 GETBYTE ();
5993 switch (op[1] & 0x00)
5995 case 0x00:
5996 goto op_semantics_38;
5997 break;
5999 break;
6000 case 0xa3:
6001 GETBYTE ();
6002 switch (op[1] & 0x00)
6004 case 0x00:
6005 goto op_semantics_38;
6006 break;
6008 break;
6009 case 0xa4:
6010 GETBYTE ();
6011 switch (op[1] & 0x00)
6013 case 0x00:
6014 goto op_semantics_38;
6015 break;
6017 break;
6018 case 0xa5:
6019 GETBYTE ();
6020 switch (op[1] & 0x00)
6022 case 0x00:
6023 goto op_semantics_38;
6024 break;
6026 break;
6027 case 0xa6:
6028 GETBYTE ();
6029 switch (op[1] & 0x00)
6031 case 0x00:
6032 goto op_semantics_38;
6033 break;
6035 break;
6036 case 0xa7:
6037 GETBYTE ();
6038 switch (op[1] & 0x00)
6040 case 0x00:
6041 goto op_semantics_38;
6042 break;
6044 break;
6045 case 0xa8:
6046 GETBYTE ();
6047 switch (op[1] & 0x00)
6049 case 0x00:
6050 goto op_semantics_39;
6051 break;
6053 break;
6054 case 0xa9:
6055 GETBYTE ();
6056 switch (op[1] & 0x00)
6058 case 0x00:
6059 goto op_semantics_39;
6060 break;
6062 break;
6063 case 0xaa:
6064 GETBYTE ();
6065 switch (op[1] & 0x00)
6067 case 0x00:
6068 goto op_semantics_39;
6069 break;
6071 break;
6072 case 0xab:
6073 GETBYTE ();
6074 switch (op[1] & 0x00)
6076 case 0x00:
6077 goto op_semantics_39;
6078 break;
6080 break;
6081 case 0xac:
6082 GETBYTE ();
6083 switch (op[1] & 0x00)
6085 case 0x00:
6086 goto op_semantics_39;
6087 break;
6089 break;
6090 case 0xad:
6091 GETBYTE ();
6092 switch (op[1] & 0x00)
6094 case 0x00:
6095 goto op_semantics_39;
6096 break;
6098 break;
6099 case 0xae:
6100 GETBYTE ();
6101 switch (op[1] & 0x00)
6103 case 0x00:
6104 goto op_semantics_39;
6105 break;
6107 break;
6108 case 0xaf:
6109 GETBYTE ();
6110 switch (op[1] & 0x00)
6112 case 0x00:
6113 goto op_semantics_39;
6114 break;
6116 break;
6117 case 0xb0:
6118 GETBYTE ();
6119 switch (op[1] & 0x00)
6121 case 0x00:
6122 op_semantics_40:
6124 /** 1011 w dsp a src b dst movu%s %1, %0 */
6125 #line 315 "rx-decode.opc"
6126 int w AU = (op[0] >> 3) & 0x01;
6127 #line 315 "rx-decode.opc"
6128 int dsp AU = op[0] & 0x07;
6129 #line 315 "rx-decode.opc"
6130 int a AU = (op[1] >> 7) & 0x01;
6131 #line 315 "rx-decode.opc"
6132 int src AU = (op[1] >> 4) & 0x07;
6133 #line 315 "rx-decode.opc"
6134 int b AU = (op[1] >> 3) & 0x01;
6135 #line 315 "rx-decode.opc"
6136 int dst AU = op[1] & 0x07;
6137 if (trace)
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);
6149 SYNTAX("movu%s %1, %0");
6150 #line 315 "rx-decode.opc"
6151 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6154 break;
6156 break;
6157 case 0xb1:
6158 GETBYTE ();
6159 switch (op[1] & 0x00)
6161 case 0x00:
6162 goto op_semantics_40;
6163 break;
6165 break;
6166 case 0xb2:
6167 GETBYTE ();
6168 switch (op[1] & 0x00)
6170 case 0x00:
6171 goto op_semantics_40;
6172 break;
6174 break;
6175 case 0xb3:
6176 GETBYTE ();
6177 switch (op[1] & 0x00)
6179 case 0x00:
6180 goto op_semantics_40;
6181 break;
6183 break;
6184 case 0xb4:
6185 GETBYTE ();
6186 switch (op[1] & 0x00)
6188 case 0x00:
6189 goto op_semantics_40;
6190 break;
6192 break;
6193 case 0xb5:
6194 GETBYTE ();
6195 switch (op[1] & 0x00)
6197 case 0x00:
6198 goto op_semantics_40;
6199 break;
6201 break;
6202 case 0xb6:
6203 GETBYTE ();
6204 switch (op[1] & 0x00)
6206 case 0x00:
6207 goto op_semantics_40;
6208 break;
6210 break;
6211 case 0xb7:
6212 GETBYTE ();
6213 switch (op[1] & 0x00)
6215 case 0x00:
6216 goto op_semantics_40;
6217 break;
6219 break;
6220 case 0xb8:
6221 GETBYTE ();
6222 switch (op[1] & 0x00)
6224 case 0x00:
6225 goto op_semantics_40;
6226 break;
6228 break;
6229 case 0xb9:
6230 GETBYTE ();
6231 switch (op[1] & 0x00)
6233 case 0x00:
6234 goto op_semantics_40;
6235 break;
6237 break;
6238 case 0xba:
6239 GETBYTE ();
6240 switch (op[1] & 0x00)
6242 case 0x00:
6243 goto op_semantics_40;
6244 break;
6246 break;
6247 case 0xbb:
6248 GETBYTE ();
6249 switch (op[1] & 0x00)
6251 case 0x00:
6252 goto op_semantics_40;
6253 break;
6255 break;
6256 case 0xbc:
6257 GETBYTE ();
6258 switch (op[1] & 0x00)
6260 case 0x00:
6261 goto op_semantics_40;
6262 break;
6264 break;
6265 case 0xbd:
6266 GETBYTE ();
6267 switch (op[1] & 0x00)
6269 case 0x00:
6270 goto op_semantics_40;
6271 break;
6273 break;
6274 case 0xbe:
6275 GETBYTE ();
6276 switch (op[1] & 0x00)
6278 case 0x00:
6279 goto op_semantics_40;
6280 break;
6282 break;
6283 case 0xbf:
6284 GETBYTE ();
6285 switch (op[1] & 0x00)
6287 case 0x00:
6288 goto op_semantics_40;
6289 break;
6291 break;
6292 case 0xc0:
6293 GETBYTE ();
6294 switch (op[1] & 0x00)
6296 case 0x00:
6297 op_semantics_41:
6299 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6300 #line 274 "rx-decode.opc"
6301 int sz AU = (op[0] >> 4) & 0x03;
6302 #line 274 "rx-decode.opc"
6303 int sd AU = (op[0] >> 2) & 0x03;
6304 #line 274 "rx-decode.opc"
6305 int ss AU = op[0] & 0x03;
6306 #line 274 "rx-decode.opc"
6307 int rsrc AU = (op[1] >> 4) & 0x0f;
6308 #line 274 "rx-decode.opc"
6309 int rdst AU = op[1] & 0x0f;
6310 if (trace)
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);
6321 SYNTAX("mov%s %1, %0");
6322 #line 274 "rx-decode.opc"
6323 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6325 ID(nop2);
6327 else
6329 ID(mov); sBWL(sz); F_____;
6330 if ((ss == 3) && (sd != 3))
6332 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6334 else
6336 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6341 break;
6343 break;
6344 case 0xc1:
6345 GETBYTE ();
6346 switch (op[1] & 0x00)
6348 case 0x00:
6349 goto op_semantics_41;
6350 break;
6352 break;
6353 case 0xc2:
6354 GETBYTE ();
6355 switch (op[1] & 0x00)
6357 case 0x00:
6358 goto op_semantics_41;
6359 break;
6361 break;
6362 case 0xc3:
6363 GETBYTE ();
6364 switch (op[1] & 0x00)
6366 case 0x00:
6367 goto op_semantics_41;
6368 break;
6370 break;
6371 case 0xc4:
6372 GETBYTE ();
6373 switch (op[1] & 0x00)
6375 case 0x00:
6376 goto op_semantics_41;
6377 break;
6379 break;
6380 case 0xc5:
6381 GETBYTE ();
6382 switch (op[1] & 0x00)
6384 case 0x00:
6385 goto op_semantics_41;
6386 break;
6388 break;
6389 case 0xc6:
6390 GETBYTE ();
6391 switch (op[1] & 0x00)
6393 case 0x00:
6394 goto op_semantics_41;
6395 break;
6397 break;
6398 case 0xc7:
6399 GETBYTE ();
6400 switch (op[1] & 0x00)
6402 case 0x00:
6403 goto op_semantics_41;
6404 break;
6406 break;
6407 case 0xc8:
6408 GETBYTE ();
6409 switch (op[1] & 0x00)
6411 case 0x00:
6412 goto op_semantics_41;
6413 break;
6415 break;
6416 case 0xc9:
6417 GETBYTE ();
6418 switch (op[1] & 0x00)
6420 case 0x00:
6421 goto op_semantics_41;
6422 break;
6424 break;
6425 case 0xca:
6426 GETBYTE ();
6427 switch (op[1] & 0x00)
6429 case 0x00:
6430 goto op_semantics_41;
6431 break;
6433 break;
6434 case 0xcb:
6435 GETBYTE ();
6436 switch (op[1] & 0x00)
6438 case 0x00:
6439 goto op_semantics_41;
6440 break;
6442 break;
6443 case 0xcc:
6444 GETBYTE ();
6445 switch (op[1] & 0x00)
6447 case 0x00:
6448 goto op_semantics_41;
6449 break;
6451 break;
6452 case 0xcd:
6453 GETBYTE ();
6454 switch (op[1] & 0x00)
6456 case 0x00:
6457 goto op_semantics_41;
6458 break;
6460 break;
6461 case 0xce:
6462 GETBYTE ();
6463 switch (op[1] & 0x00)
6465 case 0x00:
6466 goto op_semantics_41;
6467 break;
6469 break;
6470 case 0xcf:
6471 GETBYTE ();
6472 switch (op[1] & 0x00)
6474 case 0x00:
6475 goto op_semantics_41;
6476 break;
6478 break;
6479 case 0xd0:
6480 GETBYTE ();
6481 switch (op[1] & 0x00)
6483 case 0x00:
6484 goto op_semantics_41;
6485 break;
6487 break;
6488 case 0xd1:
6489 GETBYTE ();
6490 switch (op[1] & 0x00)
6492 case 0x00:
6493 goto op_semantics_41;
6494 break;
6496 break;
6497 case 0xd2:
6498 GETBYTE ();
6499 switch (op[1] & 0x00)
6501 case 0x00:
6502 goto op_semantics_41;
6503 break;
6505 break;
6506 case 0xd3:
6507 GETBYTE ();
6508 switch (op[1] & 0x00)
6510 case 0x00:
6511 goto op_semantics_41;
6512 break;
6514 break;
6515 case 0xd4:
6516 GETBYTE ();
6517 switch (op[1] & 0x00)
6519 case 0x00:
6520 goto op_semantics_41;
6521 break;
6523 break;
6524 case 0xd5:
6525 GETBYTE ();
6526 switch (op[1] & 0x00)
6528 case 0x00:
6529 goto op_semantics_41;
6530 break;
6532 break;
6533 case 0xd6:
6534 GETBYTE ();
6535 switch (op[1] & 0x00)
6537 case 0x00:
6538 goto op_semantics_41;
6539 break;
6541 break;
6542 case 0xd7:
6543 GETBYTE ();
6544 switch (op[1] & 0x00)
6546 case 0x00:
6547 goto op_semantics_41;
6548 break;
6550 break;
6551 case 0xd8:
6552 GETBYTE ();
6553 switch (op[1] & 0x00)
6555 case 0x00:
6556 goto op_semantics_41;
6557 break;
6559 break;
6560 case 0xd9:
6561 GETBYTE ();
6562 switch (op[1] & 0x00)
6564 case 0x00:
6565 goto op_semantics_41;
6566 break;
6568 break;
6569 case 0xda:
6570 GETBYTE ();
6571 switch (op[1] & 0x00)
6573 case 0x00:
6574 goto op_semantics_41;
6575 break;
6577 break;
6578 case 0xdb:
6579 GETBYTE ();
6580 switch (op[1] & 0x00)
6582 case 0x00:
6583 goto op_semantics_41;
6584 break;
6586 break;
6587 case 0xdc:
6588 GETBYTE ();
6589 switch (op[1] & 0x00)
6591 case 0x00:
6592 goto op_semantics_41;
6593 break;
6595 break;
6596 case 0xdd:
6597 GETBYTE ();
6598 switch (op[1] & 0x00)
6600 case 0x00:
6601 goto op_semantics_41;
6602 break;
6604 break;
6605 case 0xde:
6606 GETBYTE ();
6607 switch (op[1] & 0x00)
6609 case 0x00:
6610 goto op_semantics_41;
6611 break;
6613 break;
6614 case 0xdf:
6615 GETBYTE ();
6616 switch (op[1] & 0x00)
6618 case 0x00:
6619 goto op_semantics_41;
6620 break;
6622 break;
6623 case 0xe0:
6624 GETBYTE ();
6625 switch (op[1] & 0x00)
6627 case 0x00:
6628 goto op_semantics_41;
6629 break;
6631 break;
6632 case 0xe1:
6633 GETBYTE ();
6634 switch (op[1] & 0x00)
6636 case 0x00:
6637 goto op_semantics_41;
6638 break;
6640 break;
6641 case 0xe2:
6642 GETBYTE ();
6643 switch (op[1] & 0x00)
6645 case 0x00:
6646 goto op_semantics_41;
6647 break;
6649 break;
6650 case 0xe3:
6651 GETBYTE ();
6652 switch (op[1] & 0x00)
6654 case 0x00:
6655 goto op_semantics_41;
6656 break;
6658 break;
6659 case 0xe4:
6660 GETBYTE ();
6661 switch (op[1] & 0x00)
6663 case 0x00:
6664 goto op_semantics_41;
6665 break;
6667 break;
6668 case 0xe5:
6669 GETBYTE ();
6670 switch (op[1] & 0x00)
6672 case 0x00:
6673 goto op_semantics_41;
6674 break;
6676 break;
6677 case 0xe6:
6678 GETBYTE ();
6679 switch (op[1] & 0x00)
6681 case 0x00:
6682 goto op_semantics_41;
6683 break;
6685 break;
6686 case 0xe7:
6687 GETBYTE ();
6688 switch (op[1] & 0x00)
6690 case 0x00:
6691 goto op_semantics_41;
6692 break;
6694 break;
6695 case 0xe8:
6696 GETBYTE ();
6697 switch (op[1] & 0x00)
6699 case 0x00:
6700 goto op_semantics_41;
6701 break;
6703 break;
6704 case 0xe9:
6705 GETBYTE ();
6706 switch (op[1] & 0x00)
6708 case 0x00:
6709 goto op_semantics_41;
6710 break;
6712 break;
6713 case 0xea:
6714 GETBYTE ();
6715 switch (op[1] & 0x00)
6717 case 0x00:
6718 goto op_semantics_41;
6719 break;
6721 break;
6722 case 0xeb:
6723 GETBYTE ();
6724 switch (op[1] & 0x00)
6726 case 0x00:
6727 goto op_semantics_41;
6728 break;
6730 break;
6731 case 0xec:
6732 GETBYTE ();
6733 switch (op[1] & 0x00)
6735 case 0x00:
6736 goto op_semantics_41;
6737 break;
6739 break;
6740 case 0xed:
6741 GETBYTE ();
6742 switch (op[1] & 0x00)
6744 case 0x00:
6745 goto op_semantics_41;
6746 break;
6748 break;
6749 case 0xee:
6750 GETBYTE ();
6751 switch (op[1] & 0x00)
6753 case 0x00:
6754 goto op_semantics_41;
6755 break;
6757 break;
6758 case 0xef:
6759 GETBYTE ();
6760 switch (op[1] & 0x00)
6762 case 0x00:
6763 goto op_semantics_41;
6764 break;
6766 break;
6767 case 0xf0:
6768 GETBYTE ();
6769 switch (op[1] & 0x08)
6771 case 0x00:
6772 op_semantics_42:
6774 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
6775 #line 859 "rx-decode.opc"
6776 int sd AU = op[0] & 0x03;
6777 #line 859 "rx-decode.opc"
6778 int rdst AU = (op[1] >> 4) & 0x0f;
6779 #line 859 "rx-decode.opc"
6780 int bit AU = op[1] & 0x07;
6781 if (trace)
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);
6790 SYNTAX("bset #%1, %0%S0");
6791 #line 859 "rx-decode.opc"
6792 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6795 break;
6796 case 0x08:
6797 op_semantics_43:
6799 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
6800 #line 869 "rx-decode.opc"
6801 int sd AU = op[0] & 0x03;
6802 #line 869 "rx-decode.opc"
6803 int rdst AU = (op[1] >> 4) & 0x0f;
6804 #line 869 "rx-decode.opc"
6805 int bit AU = op[1] & 0x07;
6806 if (trace)
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);
6815 SYNTAX("bclr #%1, %0%S0");
6816 #line 869 "rx-decode.opc"
6817 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6820 break;
6822 break;
6823 case 0xf1:
6824 GETBYTE ();
6825 switch (op[1] & 0x08)
6827 case 0x00:
6828 goto op_semantics_42;
6829 break;
6830 case 0x08:
6831 goto op_semantics_43;
6832 break;
6834 break;
6835 case 0xf2:
6836 GETBYTE ();
6837 switch (op[1] & 0x08)
6839 case 0x00:
6840 goto op_semantics_42;
6841 break;
6842 case 0x08:
6843 goto op_semantics_43;
6844 break;
6846 break;
6847 case 0xf3:
6848 GETBYTE ();
6849 switch (op[1] & 0x08)
6851 case 0x00:
6852 goto op_semantics_42;
6853 break;
6854 case 0x08:
6855 goto op_semantics_43;
6856 break;
6858 break;
6859 case 0xf4:
6860 GETBYTE ();
6861 switch (op[1] & 0x0c)
6863 case 0x00:
6864 case 0x04:
6865 op_semantics_44:
6867 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
6868 #line 879 "rx-decode.opc"
6869 int sd AU = op[0] & 0x03;
6870 #line 879 "rx-decode.opc"
6871 int rdst AU = (op[1] >> 4) & 0x0f;
6872 #line 879 "rx-decode.opc"
6873 int bit AU = op[1] & 0x07;
6874 if (trace)
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);
6883 SYNTAX("btst #%2, %1%S1");
6884 #line 879 "rx-decode.opc"
6885 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
6888 break;
6889 case 0x08:
6890 op_semantics_45:
6892 /** 1111 01ss rsrc 10sz push%s %1 */
6893 #line 340 "rx-decode.opc"
6894 int ss AU = op[0] & 0x03;
6895 #line 340 "rx-decode.opc"
6896 int rsrc AU = (op[1] >> 4) & 0x0f;
6897 #line 340 "rx-decode.opc"
6898 int sz AU = op[1] & 0x03;
6899 if (trace)
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);
6908 SYNTAX("push%s %1");
6909 #line 340 "rx-decode.opc"
6910 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
6912 /*----------------------------------------------------------------------*/
6913 /* XCHG */
6916 break;
6917 default: UNSUPPORTED(); break;
6919 break;
6920 case 0xf5:
6921 GETBYTE ();
6922 switch (op[1] & 0x0c)
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;
6933 break;
6934 case 0xf6:
6935 GETBYTE ();
6936 switch (op[1] & 0x0c)
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;
6947 break;
6948 case 0xf7:
6949 GETBYTE ();
6950 switch (op[1] & 0x0c)
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;
6961 break;
6962 case 0xf8:
6963 GETBYTE ();
6964 switch (op[1] & 0x00)
6966 case 0x00:
6967 op_semantics_46:
6969 /** 1111 10sd rdst im sz mov%s #%1, %0 */
6970 #line 265 "rx-decode.opc"
6971 int sd AU = op[0] & 0x03;
6972 #line 265 "rx-decode.opc"
6973 int rdst AU = (op[1] >> 4) & 0x0f;
6974 #line 265 "rx-decode.opc"
6975 int im AU = (op[1] >> 2) & 0x03;
6976 #line 265 "rx-decode.opc"
6977 int sz AU = op[1] & 0x03;
6978 if (trace)
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);
6988 SYNTAX("mov%s #%1, %0");
6989 #line 265 "rx-decode.opc"
6990 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F_____;
6993 break;
6995 break;
6996 case 0xf9:
6997 GETBYTE ();
6998 switch (op[1] & 0x00)
7000 case 0x00:
7001 goto op_semantics_46;
7002 break;
7004 break;
7005 case 0xfa:
7006 GETBYTE ();
7007 switch (op[1] & 0x00)
7009 case 0x00:
7010 goto op_semantics_46;
7011 break;
7013 break;
7014 case 0xfb:
7015 GETBYTE ();
7016 switch (op[1] & 0x00)
7018 case 0x00:
7019 goto op_semantics_46;
7020 break;
7022 break;
7023 case 0xfc:
7024 GETBYTE ();
7025 switch (op[1] & 0xff)
7027 case 0x03:
7028 GETBYTE ();
7029 switch (op[2] & 0x00)
7031 case 0x00:
7033 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7034 #line 514 "rx-decode.opc"
7035 int rsrc AU = (op[2] >> 4) & 0x0f;
7036 #line 514 "rx-decode.opc"
7037 int rdst AU = op[2] & 0x0f;
7038 if (trace)
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);
7046 SYNTAX("sbb %1, %0");
7047 #line 514 "rx-decode.opc"
7048 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7050 /* FIXME: only supports .L */
7052 break;
7054 break;
7055 case 0x07:
7056 GETBYTE ();
7057 switch (op[2] & 0x00)
7059 case 0x00:
7061 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7062 #line 445 "rx-decode.opc"
7063 int rsrc AU = (op[2] >> 4) & 0x0f;
7064 #line 445 "rx-decode.opc"
7065 int rdst AU = op[2] & 0x0f;
7066 if (trace)
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);
7074 SYNTAX("neg %2, %0");
7075 #line 445 "rx-decode.opc"
7076 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7078 /*----------------------------------------------------------------------*/
7079 /* ADC */
7082 break;
7084 break;
7085 case 0x0b:
7086 GETBYTE ();
7087 switch (op[2] & 0x00)
7089 case 0x00:
7091 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7092 #line 454 "rx-decode.opc"
7093 int rsrc AU = (op[2] >> 4) & 0x0f;
7094 #line 454 "rx-decode.opc"
7095 int rdst AU = op[2] & 0x0f;
7096 if (trace)
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);
7104 SYNTAX("adc %1, %0");
7105 #line 454 "rx-decode.opc"
7106 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7109 break;
7111 break;
7112 case 0x0f:
7113 GETBYTE ();
7114 switch (op[2] & 0x00)
7116 case 0x00:
7118 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7119 #line 527 "rx-decode.opc"
7120 int rsrc AU = (op[2] >> 4) & 0x0f;
7121 #line 527 "rx-decode.opc"
7122 int rdst AU = op[2] & 0x0f;
7123 if (trace)
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);
7131 SYNTAX("abs %1, %0");
7132 #line 527 "rx-decode.opc"
7133 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7135 /*----------------------------------------------------------------------*/
7136 /* MAX */
7139 break;
7141 break;
7142 case 0x10:
7143 GETBYTE ();
7144 switch (op[2] & 0x00)
7146 case 0x00:
7147 op_semantics_47:
7149 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7150 #line 536 "rx-decode.opc"
7151 int ss AU = op[1] & 0x03;
7152 #line 536 "rx-decode.opc"
7153 int rsrc AU = (op[2] >> 4) & 0x0f;
7154 #line 536 "rx-decode.opc"
7155 int rdst AU = op[2] & 0x0f;
7156 if (trace)
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);
7165 SYNTAX("max %1%S1, %0");
7166 #line 536 "rx-decode.opc"
7167 if (ss == 3 && rsrc == 0 && rdst == 0)
7169 ID(nop3);
7171 else
7173 ID(max); SP(ss, rsrc); DR(rdst);
7177 break;
7179 break;
7180 case 0x11:
7181 GETBYTE ();
7182 switch (op[2] & 0x00)
7184 case 0x00:
7185 goto op_semantics_47;
7186 break;
7188 break;
7189 case 0x12:
7190 GETBYTE ();
7191 switch (op[2] & 0x00)
7193 case 0x00:
7194 goto op_semantics_47;
7195 break;
7197 break;
7198 case 0x13:
7199 GETBYTE ();
7200 switch (op[2] & 0x00)
7202 case 0x00:
7203 goto op_semantics_47;
7204 break;
7206 break;
7207 case 0x14:
7208 GETBYTE ();
7209 switch (op[2] & 0x00)
7211 case 0x00:
7212 op_semantics_48:
7214 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7215 #line 555 "rx-decode.opc"
7216 int ss AU = op[1] & 0x03;
7217 #line 555 "rx-decode.opc"
7218 int rsrc AU = (op[2] >> 4) & 0x0f;
7219 #line 555 "rx-decode.opc"
7220 int rdst AU = op[2] & 0x0f;
7221 if (trace)
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);
7230 SYNTAX("min %1%S1, %0");
7231 #line 555 "rx-decode.opc"
7232 ID(min); SP(ss, rsrc); DR(rdst);
7235 break;
7237 break;
7238 case 0x15:
7239 GETBYTE ();
7240 switch (op[2] & 0x00)
7242 case 0x00:
7243 goto op_semantics_48;
7244 break;
7246 break;
7247 case 0x16:
7248 GETBYTE ();
7249 switch (op[2] & 0x00)
7251 case 0x00:
7252 goto op_semantics_48;
7253 break;
7255 break;
7256 case 0x17:
7257 GETBYTE ();
7258 switch (op[2] & 0x00)
7260 case 0x00:
7261 goto op_semantics_48;
7262 break;
7264 break;
7265 case 0x18:
7266 GETBYTE ();
7267 switch (op[2] & 0x00)
7269 case 0x00:
7270 op_semantics_49:
7272 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7273 #line 585 "rx-decode.opc"
7274 int ss AU = op[1] & 0x03;
7275 #line 585 "rx-decode.opc"
7276 int rsrc AU = (op[2] >> 4) & 0x0f;
7277 #line 585 "rx-decode.opc"
7278 int rdst AU = op[2] & 0x0f;
7279 if (trace)
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);
7288 SYNTAX("emul %1%S1, %0");
7289 #line 585 "rx-decode.opc"
7290 ID(emul); SP(ss, rsrc); DR(rdst);
7293 break;
7295 break;
7296 case 0x19:
7297 GETBYTE ();
7298 switch (op[2] & 0x00)
7300 case 0x00:
7301 goto op_semantics_49;
7302 break;
7304 break;
7305 case 0x1a:
7306 GETBYTE ();
7307 switch (op[2] & 0x00)
7309 case 0x00:
7310 goto op_semantics_49;
7311 break;
7313 break;
7314 case 0x1b:
7315 GETBYTE ();
7316 switch (op[2] & 0x00)
7318 case 0x00:
7319 goto op_semantics_49;
7320 break;
7322 break;
7323 case 0x1c:
7324 GETBYTE ();
7325 switch (op[2] & 0x00)
7327 case 0x00:
7328 op_semantics_50:
7330 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7331 #line 597 "rx-decode.opc"
7332 int ss AU = op[1] & 0x03;
7333 #line 597 "rx-decode.opc"
7334 int rsrc AU = (op[2] >> 4) & 0x0f;
7335 #line 597 "rx-decode.opc"
7336 int rdst AU = op[2] & 0x0f;
7337 if (trace)
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);
7346 SYNTAX("emulu %1%S1, %0");
7347 #line 597 "rx-decode.opc"
7348 ID(emulu); SP(ss, rsrc); DR(rdst);
7351 break;
7353 break;
7354 case 0x1d:
7355 GETBYTE ();
7356 switch (op[2] & 0x00)
7358 case 0x00:
7359 goto op_semantics_50;
7360 break;
7362 break;
7363 case 0x1e:
7364 GETBYTE ();
7365 switch (op[2] & 0x00)
7367 case 0x00:
7368 goto op_semantics_50;
7369 break;
7371 break;
7372 case 0x1f:
7373 GETBYTE ();
7374 switch (op[2] & 0x00)
7376 case 0x00:
7377 goto op_semantics_50;
7378 break;
7380 break;
7381 case 0x20:
7382 GETBYTE ();
7383 switch (op[2] & 0x00)
7385 case 0x00:
7386 op_semantics_51:
7388 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7389 #line 609 "rx-decode.opc"
7390 int ss AU = op[1] & 0x03;
7391 #line 609 "rx-decode.opc"
7392 int rsrc AU = (op[2] >> 4) & 0x0f;
7393 #line 609 "rx-decode.opc"
7394 int rdst AU = op[2] & 0x0f;
7395 if (trace)
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);
7404 SYNTAX("div %1%S1, %0");
7405 #line 609 "rx-decode.opc"
7406 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7409 break;
7411 break;
7412 case 0x21:
7413 GETBYTE ();
7414 switch (op[2] & 0x00)
7416 case 0x00:
7417 goto op_semantics_51;
7418 break;
7420 break;
7421 case 0x22:
7422 GETBYTE ();
7423 switch (op[2] & 0x00)
7425 case 0x00:
7426 goto op_semantics_51;
7427 break;
7429 break;
7430 case 0x23:
7431 GETBYTE ();
7432 switch (op[2] & 0x00)
7434 case 0x00:
7435 goto op_semantics_51;
7436 break;
7438 break;
7439 case 0x24:
7440 GETBYTE ();
7441 switch (op[2] & 0x00)
7443 case 0x00:
7444 op_semantics_52:
7446 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7447 #line 621 "rx-decode.opc"
7448 int ss AU = op[1] & 0x03;
7449 #line 621 "rx-decode.opc"
7450 int rsrc AU = (op[2] >> 4) & 0x0f;
7451 #line 621 "rx-decode.opc"
7452 int rdst AU = op[2] & 0x0f;
7453 if (trace)
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);
7462 SYNTAX("divu %1%S1, %0");
7463 #line 621 "rx-decode.opc"
7464 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7467 break;
7469 break;
7470 case 0x25:
7471 GETBYTE ();
7472 switch (op[2] & 0x00)
7474 case 0x00:
7475 goto op_semantics_52;
7476 break;
7478 break;
7479 case 0x26:
7480 GETBYTE ();
7481 switch (op[2] & 0x00)
7483 case 0x00:
7484 goto op_semantics_52;
7485 break;
7487 break;
7488 case 0x27:
7489 GETBYTE ();
7490 switch (op[2] & 0x00)
7492 case 0x00:
7493 goto op_semantics_52;
7494 break;
7496 break;
7497 case 0x30:
7498 GETBYTE ();
7499 switch (op[2] & 0x00)
7501 case 0x00:
7502 op_semantics_53:
7504 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7505 #line 433 "rx-decode.opc"
7506 int ss AU = op[1] & 0x03;
7507 #line 433 "rx-decode.opc"
7508 int rsrc AU = (op[2] >> 4) & 0x0f;
7509 #line 433 "rx-decode.opc"
7510 int rdst AU = op[2] & 0x0f;
7511 if (trace)
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);
7520 SYNTAX("tst %1%S1, %2");
7521 #line 433 "rx-decode.opc"
7522 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7525 break;
7527 break;
7528 case 0x31:
7529 GETBYTE ();
7530 switch (op[2] & 0x00)
7532 case 0x00:
7533 goto op_semantics_53;
7534 break;
7536 break;
7537 case 0x32:
7538 GETBYTE ();
7539 switch (op[2] & 0x00)
7541 case 0x00:
7542 goto op_semantics_53;
7543 break;
7545 break;
7546 case 0x33:
7547 GETBYTE ();
7548 switch (op[2] & 0x00)
7550 case 0x00:
7551 goto op_semantics_53;
7552 break;
7554 break;
7555 case 0x34:
7556 GETBYTE ();
7557 switch (op[2] & 0x00)
7559 case 0x00:
7560 op_semantics_54:
7562 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7563 #line 412 "rx-decode.opc"
7564 int ss AU = op[1] & 0x03;
7565 #line 412 "rx-decode.opc"
7566 int rsrc AU = (op[2] >> 4) & 0x0f;
7567 #line 412 "rx-decode.opc"
7568 int rdst AU = op[2] & 0x0f;
7569 if (trace)
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);
7578 SYNTAX("xor %1%S1, %0");
7579 #line 412 "rx-decode.opc"
7580 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7583 break;
7585 break;
7586 case 0x35:
7587 GETBYTE ();
7588 switch (op[2] & 0x00)
7590 case 0x00:
7591 goto op_semantics_54;
7592 break;
7594 break;
7595 case 0x36:
7596 GETBYTE ();
7597 switch (op[2] & 0x00)
7599 case 0x00:
7600 goto op_semantics_54;
7601 break;
7603 break;
7604 case 0x37:
7605 GETBYTE ();
7606 switch (op[2] & 0x00)
7608 case 0x00:
7609 goto op_semantics_54;
7610 break;
7612 break;
7613 case 0x3b:
7614 GETBYTE ();
7615 switch (op[2] & 0x00)
7617 case 0x00:
7619 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7620 #line 424 "rx-decode.opc"
7621 int rsrc AU = (op[2] >> 4) & 0x0f;
7622 #line 424 "rx-decode.opc"
7623 int rdst AU = op[2] & 0x0f;
7624 if (trace)
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);
7632 SYNTAX("not %1, %0");
7633 #line 424 "rx-decode.opc"
7634 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7636 /*----------------------------------------------------------------------*/
7637 /* TST */
7640 break;
7642 break;
7643 case 0x40:
7644 GETBYTE ();
7645 switch (op[2] & 0x00)
7647 case 0x00:
7648 op_semantics_55:
7650 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7651 #line 346 "rx-decode.opc"
7652 int ss AU = op[1] & 0x03;
7653 #line 346 "rx-decode.opc"
7654 int rsrc AU = (op[2] >> 4) & 0x0f;
7655 #line 346 "rx-decode.opc"
7656 int rdst AU = op[2] & 0x0f;
7657 if (trace)
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);
7666 SYNTAX("xchg %1%S1, %0");
7667 #line 346 "rx-decode.opc"
7668 ID(xchg); DR(rdst); SP(ss, rsrc);
7671 break;
7673 break;
7674 case 0x41:
7675 GETBYTE ();
7676 switch (op[2] & 0x00)
7678 case 0x00:
7679 goto op_semantics_55;
7680 break;
7682 break;
7683 case 0x42:
7684 GETBYTE ();
7685 switch (op[2] & 0x00)
7687 case 0x00:
7688 goto op_semantics_55;
7689 break;
7691 break;
7692 case 0x43:
7693 GETBYTE ();
7694 switch (op[2] & 0x00)
7696 case 0x00:
7697 goto op_semantics_55;
7698 break;
7700 break;
7701 case 0x44:
7702 GETBYTE ();
7703 switch (op[2] & 0x00)
7705 case 0x00:
7706 op_semantics_56:
7708 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7709 #line 850 "rx-decode.opc"
7710 int sd AU = op[1] & 0x03;
7711 #line 850 "rx-decode.opc"
7712 int rsrc AU = (op[2] >> 4) & 0x0f;
7713 #line 850 "rx-decode.opc"
7714 int rdst AU = op[2] & 0x0f;
7715 if (trace)
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);
7724 SYNTAX("itof %1%S1, %0");
7725 #line 850 "rx-decode.opc"
7726 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7729 break;
7731 break;
7732 case 0x45:
7733 GETBYTE ();
7734 switch (op[2] & 0x00)
7736 case 0x00:
7737 goto op_semantics_56;
7738 break;
7740 break;
7741 case 0x46:
7742 GETBYTE ();
7743 switch (op[2] & 0x00)
7745 case 0x00:
7746 goto op_semantics_56;
7747 break;
7749 break;
7750 case 0x47:
7751 GETBYTE ();
7752 switch (op[2] & 0x00)
7754 case 0x00:
7755 goto op_semantics_56;
7756 break;
7758 break;
7759 case 0x60:
7760 GETBYTE ();
7761 switch (op[2] & 0x00)
7763 case 0x00:
7764 op_semantics_57:
7766 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
7767 #line 862 "rx-decode.opc"
7768 int sd AU = op[1] & 0x03;
7769 #line 862 "rx-decode.opc"
7770 int rdst AU = (op[2] >> 4) & 0x0f;
7771 #line 862 "rx-decode.opc"
7772 int rsrc AU = op[2] & 0x0f;
7773 if (trace)
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);
7782 SYNTAX("bset %1, %0%S0");
7783 #line 862 "rx-decode.opc"
7784 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7787 break;
7789 break;
7790 case 0x61:
7791 GETBYTE ();
7792 switch (op[2] & 0x00)
7794 case 0x00:
7795 goto op_semantics_57;
7796 break;
7798 break;
7799 case 0x62:
7800 GETBYTE ();
7801 switch (op[2] & 0x00)
7803 case 0x00:
7804 goto op_semantics_57;
7805 break;
7807 break;
7808 case 0x63:
7809 GETBYTE ();
7810 switch (op[2] & 0x00)
7812 case 0x00:
7813 goto op_semantics_57;
7814 break;
7816 break;
7817 case 0x64:
7818 GETBYTE ();
7819 switch (op[2] & 0x00)
7821 case 0x00:
7822 op_semantics_58:
7824 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
7825 #line 872 "rx-decode.opc"
7826 int sd AU = op[1] & 0x03;
7827 #line 872 "rx-decode.opc"
7828 int rdst AU = (op[2] >> 4) & 0x0f;
7829 #line 872 "rx-decode.opc"
7830 int rsrc AU = op[2] & 0x0f;
7831 if (trace)
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);
7840 SYNTAX("bclr %1, %0%S0");
7841 #line 872 "rx-decode.opc"
7842 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7845 break;
7847 break;
7848 case 0x65:
7849 GETBYTE ();
7850 switch (op[2] & 0x00)
7852 case 0x00:
7853 goto op_semantics_58;
7854 break;
7856 break;
7857 case 0x66:
7858 GETBYTE ();
7859 switch (op[2] & 0x00)
7861 case 0x00:
7862 goto op_semantics_58;
7863 break;
7865 break;
7866 case 0x67:
7867 GETBYTE ();
7868 switch (op[2] & 0x00)
7870 case 0x00:
7871 goto op_semantics_58;
7872 break;
7874 break;
7875 case 0x68:
7876 GETBYTE ();
7877 switch (op[2] & 0x00)
7879 case 0x00:
7880 op_semantics_59:
7882 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
7883 #line 882 "rx-decode.opc"
7884 int sd AU = op[1] & 0x03;
7885 #line 882 "rx-decode.opc"
7886 int rdst AU = (op[2] >> 4) & 0x0f;
7887 #line 882 "rx-decode.opc"
7888 int rsrc AU = op[2] & 0x0f;
7889 if (trace)
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);
7898 SYNTAX("btst %2, %1%S1");
7899 #line 882 "rx-decode.opc"
7900 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
7903 break;
7905 break;
7906 case 0x69:
7907 GETBYTE ();
7908 switch (op[2] & 0x00)
7910 case 0x00:
7911 goto op_semantics_59;
7912 break;
7914 break;
7915 case 0x6a:
7916 GETBYTE ();
7917 switch (op[2] & 0x00)
7919 case 0x00:
7920 goto op_semantics_59;
7921 break;
7923 break;
7924 case 0x6b:
7925 GETBYTE ();
7926 switch (op[2] & 0x00)
7928 case 0x00:
7929 goto op_semantics_59;
7930 break;
7932 break;
7933 case 0x6c:
7934 GETBYTE ();
7935 switch (op[2] & 0x00)
7937 case 0x00:
7938 op_semantics_60:
7940 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
7941 #line 892 "rx-decode.opc"
7942 int sd AU = op[1] & 0x03;
7943 #line 892 "rx-decode.opc"
7944 int rdst AU = (op[2] >> 4) & 0x0f;
7945 #line 892 "rx-decode.opc"
7946 int rsrc AU = op[2] & 0x0f;
7947 if (trace)
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);
7956 SYNTAX("bnot %1, %0%S0");
7957 #line 892 "rx-decode.opc"
7958 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7961 break;
7963 break;
7964 case 0x6d:
7965 GETBYTE ();
7966 switch (op[2] & 0x00)
7968 case 0x00:
7969 goto op_semantics_60;
7970 break;
7972 break;
7973 case 0x6e:
7974 GETBYTE ();
7975 switch (op[2] & 0x00)
7977 case 0x00:
7978 goto op_semantics_60;
7979 break;
7981 break;
7982 case 0x6f:
7983 GETBYTE ();
7984 switch (op[2] & 0x00)
7986 case 0x00:
7987 goto op_semantics_60;
7988 break;
7990 break;
7991 case 0x80:
7992 GETBYTE ();
7993 switch (op[2] & 0x00)
7995 case 0x00:
7996 op_semantics_61:
7998 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
7999 #line 829 "rx-decode.opc"
8000 int sd AU = op[1] & 0x03;
8001 #line 829 "rx-decode.opc"
8002 int rsrc AU = (op[2] >> 4) & 0x0f;
8003 #line 829 "rx-decode.opc"
8004 int rdst AU = op[2] & 0x0f;
8005 if (trace)
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);
8014 SYNTAX("fsub %1%S1, %0");
8015 #line 829 "rx-decode.opc"
8016 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8019 break;
8021 break;
8022 case 0x81:
8023 GETBYTE ();
8024 switch (op[2] & 0x00)
8026 case 0x00:
8027 goto op_semantics_61;
8028 break;
8030 break;
8031 case 0x82:
8032 GETBYTE ();
8033 switch (op[2] & 0x00)
8035 case 0x00:
8036 goto op_semantics_61;
8037 break;
8039 break;
8040 case 0x83:
8041 GETBYTE ();
8042 switch (op[2] & 0x00)
8044 case 0x00:
8045 goto op_semantics_61;
8046 break;
8048 break;
8049 case 0x84:
8050 GETBYTE ();
8051 switch (op[2] & 0x00)
8053 case 0x00:
8054 op_semantics_62:
8056 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8057 #line 823 "rx-decode.opc"
8058 int sd AU = op[1] & 0x03;
8059 #line 823 "rx-decode.opc"
8060 int rsrc AU = (op[2] >> 4) & 0x0f;
8061 #line 823 "rx-decode.opc"
8062 int rdst AU = op[2] & 0x0f;
8063 if (trace)
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);
8072 SYNTAX("fcmp %1%S1, %0");
8073 #line 823 "rx-decode.opc"
8074 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8077 break;
8079 break;
8080 case 0x85:
8081 GETBYTE ();
8082 switch (op[2] & 0x00)
8084 case 0x00:
8085 goto op_semantics_62;
8086 break;
8088 break;
8089 case 0x86:
8090 GETBYTE ();
8091 switch (op[2] & 0x00)
8093 case 0x00:
8094 goto op_semantics_62;
8095 break;
8097 break;
8098 case 0x87:
8099 GETBYTE ();
8100 switch (op[2] & 0x00)
8102 case 0x00:
8103 goto op_semantics_62;
8104 break;
8106 break;
8107 case 0x88:
8108 GETBYTE ();
8109 switch (op[2] & 0x00)
8111 case 0x00:
8112 op_semantics_63:
8114 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8115 #line 817 "rx-decode.opc"
8116 int sd AU = op[1] & 0x03;
8117 #line 817 "rx-decode.opc"
8118 int rsrc AU = (op[2] >> 4) & 0x0f;
8119 #line 817 "rx-decode.opc"
8120 int rdst AU = op[2] & 0x0f;
8121 if (trace)
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);
8130 SYNTAX("fadd %1%S1, %0");
8131 #line 817 "rx-decode.opc"
8132 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8135 break;
8137 break;
8138 case 0x89:
8139 GETBYTE ();
8140 switch (op[2] & 0x00)
8142 case 0x00:
8143 goto op_semantics_63;
8144 break;
8146 break;
8147 case 0x8a:
8148 GETBYTE ();
8149 switch (op[2] & 0x00)
8151 case 0x00:
8152 goto op_semantics_63;
8153 break;
8155 break;
8156 case 0x8b:
8157 GETBYTE ();
8158 switch (op[2] & 0x00)
8160 case 0x00:
8161 goto op_semantics_63;
8162 break;
8164 break;
8165 case 0x8c:
8166 GETBYTE ();
8167 switch (op[2] & 0x00)
8169 case 0x00:
8170 op_semantics_64:
8172 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8173 #line 838 "rx-decode.opc"
8174 int sd AU = op[1] & 0x03;
8175 #line 838 "rx-decode.opc"
8176 int rsrc AU = (op[2] >> 4) & 0x0f;
8177 #line 838 "rx-decode.opc"
8178 int rdst AU = op[2] & 0x0f;
8179 if (trace)
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);
8188 SYNTAX("fmul %1%S1, %0");
8189 #line 838 "rx-decode.opc"
8190 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8193 break;
8195 break;
8196 case 0x8d:
8197 GETBYTE ();
8198 switch (op[2] & 0x00)
8200 case 0x00:
8201 goto op_semantics_64;
8202 break;
8204 break;
8205 case 0x8e:
8206 GETBYTE ();
8207 switch (op[2] & 0x00)
8209 case 0x00:
8210 goto op_semantics_64;
8211 break;
8213 break;
8214 case 0x8f:
8215 GETBYTE ();
8216 switch (op[2] & 0x00)
8218 case 0x00:
8219 goto op_semantics_64;
8220 break;
8222 break;
8223 case 0x90:
8224 GETBYTE ();
8225 switch (op[2] & 0x00)
8227 case 0x00:
8228 op_semantics_65:
8230 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8231 #line 844 "rx-decode.opc"
8232 int sd AU = op[1] & 0x03;
8233 #line 844 "rx-decode.opc"
8234 int rsrc AU = (op[2] >> 4) & 0x0f;
8235 #line 844 "rx-decode.opc"
8236 int rdst AU = op[2] & 0x0f;
8237 if (trace)
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);
8246 SYNTAX("fdiv %1%S1, %0");
8247 #line 844 "rx-decode.opc"
8248 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8251 break;
8253 break;
8254 case 0x91:
8255 GETBYTE ();
8256 switch (op[2] & 0x00)
8258 case 0x00:
8259 goto op_semantics_65;
8260 break;
8262 break;
8263 case 0x92:
8264 GETBYTE ();
8265 switch (op[2] & 0x00)
8267 case 0x00:
8268 goto op_semantics_65;
8269 break;
8271 break;
8272 case 0x93:
8273 GETBYTE ();
8274 switch (op[2] & 0x00)
8276 case 0x00:
8277 goto op_semantics_65;
8278 break;
8280 break;
8281 case 0x94:
8282 GETBYTE ();
8283 switch (op[2] & 0x00)
8285 case 0x00:
8286 op_semantics_66:
8288 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8289 #line 832 "rx-decode.opc"
8290 int sd AU = op[1] & 0x03;
8291 #line 832 "rx-decode.opc"
8292 int rsrc AU = (op[2] >> 4) & 0x0f;
8293 #line 832 "rx-decode.opc"
8294 int rdst AU = op[2] & 0x0f;
8295 if (trace)
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);
8304 SYNTAX("ftoi %1%S1, %0");
8305 #line 832 "rx-decode.opc"
8306 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8309 break;
8311 break;
8312 case 0x95:
8313 GETBYTE ();
8314 switch (op[2] & 0x00)
8316 case 0x00:
8317 goto op_semantics_66;
8318 break;
8320 break;
8321 case 0x96:
8322 GETBYTE ();
8323 switch (op[2] & 0x00)
8325 case 0x00:
8326 goto op_semantics_66;
8327 break;
8329 break;
8330 case 0x97:
8331 GETBYTE ();
8332 switch (op[2] & 0x00)
8334 case 0x00:
8335 goto op_semantics_66;
8336 break;
8338 break;
8339 case 0x98:
8340 GETBYTE ();
8341 switch (op[2] & 0x00)
8343 case 0x00:
8344 op_semantics_67:
8346 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8347 #line 847 "rx-decode.opc"
8348 int sd AU = op[1] & 0x03;
8349 #line 847 "rx-decode.opc"
8350 int rsrc AU = (op[2] >> 4) & 0x0f;
8351 #line 847 "rx-decode.opc"
8352 int rdst AU = op[2] & 0x0f;
8353 if (trace)
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);
8362 SYNTAX("round %1%S1, %0");
8363 #line 847 "rx-decode.opc"
8364 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8367 break;
8369 break;
8370 case 0x99:
8371 GETBYTE ();
8372 switch (op[2] & 0x00)
8374 case 0x00:
8375 goto op_semantics_67;
8376 break;
8378 break;
8379 case 0x9a:
8380 GETBYTE ();
8381 switch (op[2] & 0x00)
8383 case 0x00:
8384 goto op_semantics_67;
8385 break;
8387 break;
8388 case 0x9b:
8389 GETBYTE ();
8390 switch (op[2] & 0x00)
8392 case 0x00:
8393 goto op_semantics_67;
8394 break;
8396 break;
8397 case 0xd0:
8398 GETBYTE ();
8399 switch (op[2] & 0x00)
8401 case 0x00:
8402 op_semantics_68:
8404 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8405 #line 956 "rx-decode.opc"
8406 int sz AU = (op[1] >> 2) & 0x03;
8407 #line 956 "rx-decode.opc"
8408 int sd AU = op[1] & 0x03;
8409 #line 956 "rx-decode.opc"
8410 int rdst AU = (op[2] >> 4) & 0x0f;
8411 #line 956 "rx-decode.opc"
8412 int cond AU = op[2] & 0x0f;
8413 if (trace)
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);
8423 SYNTAX("sc%1%s %0");
8424 #line 956 "rx-decode.opc"
8425 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8428 break;
8430 break;
8431 case 0xd1:
8432 GETBYTE ();
8433 switch (op[2] & 0x00)
8435 case 0x00:
8436 goto op_semantics_68;
8437 break;
8439 break;
8440 case 0xd2:
8441 GETBYTE ();
8442 switch (op[2] & 0x00)
8444 case 0x00:
8445 goto op_semantics_68;
8446 break;
8448 break;
8449 case 0xd3:
8450 GETBYTE ();
8451 switch (op[2] & 0x00)
8453 case 0x00:
8454 goto op_semantics_68;
8455 break;
8457 break;
8458 case 0xd4:
8459 GETBYTE ();
8460 switch (op[2] & 0x00)
8462 case 0x00:
8463 goto op_semantics_68;
8464 break;
8466 break;
8467 case 0xd5:
8468 GETBYTE ();
8469 switch (op[2] & 0x00)
8471 case 0x00:
8472 goto op_semantics_68;
8473 break;
8475 break;
8476 case 0xd6:
8477 GETBYTE ();
8478 switch (op[2] & 0x00)
8480 case 0x00:
8481 goto op_semantics_68;
8482 break;
8484 break;
8485 case 0xd7:
8486 GETBYTE ();
8487 switch (op[2] & 0x00)
8489 case 0x00:
8490 goto op_semantics_68;
8491 break;
8493 break;
8494 case 0xd8:
8495 GETBYTE ();
8496 switch (op[2] & 0x00)
8498 case 0x00:
8499 goto op_semantics_68;
8500 break;
8502 break;
8503 case 0xd9:
8504 GETBYTE ();
8505 switch (op[2] & 0x00)
8507 case 0x00:
8508 goto op_semantics_68;
8509 break;
8511 break;
8512 case 0xda:
8513 GETBYTE ();
8514 switch (op[2] & 0x00)
8516 case 0x00:
8517 goto op_semantics_68;
8518 break;
8520 break;
8521 case 0xdb:
8522 GETBYTE ();
8523 switch (op[2] & 0x00)
8525 case 0x00:
8526 goto op_semantics_68;
8527 break;
8529 break;
8530 case 0xe0:
8531 GETBYTE ();
8532 switch (op[2] & 0x0f)
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:
8551 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
8552 #line 899 "rx-decode.opc"
8553 int bit AU = (op[1] >> 2) & 0x07;
8554 #line 899 "rx-decode.opc"
8555 int sd AU = op[1] & 0x03;
8556 #line 899 "rx-decode.opc"
8557 int rdst AU = (op[2] >> 4) & 0x0f;
8558 #line 899 "rx-decode.opc"
8559 int cond AU = op[2] & 0x0f;
8560 if (trace)
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);
8570 SYNTAX("bm%2 #%1, %0%S0");
8571 #line 899 "rx-decode.opc"
8572 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8575 break;
8576 case 0x0f:
8577 op_semantics_70:
8579 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
8580 #line 889 "rx-decode.opc"
8581 int bit AU = (op[1] >> 2) & 0x07;
8582 #line 889 "rx-decode.opc"
8583 int sd AU = op[1] & 0x03;
8584 #line 889 "rx-decode.opc"
8585 int rdst AU = (op[2] >> 4) & 0x0f;
8586 if (trace)
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);
8595 SYNTAX("bnot #%1, %0%S0");
8596 #line 889 "rx-decode.opc"
8597 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8600 break;
8602 break;
8603 case 0xe1:
8604 GETBYTE ();
8605 switch (op[2] & 0x0f)
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;
8628 break;
8629 case 0xe2:
8630 GETBYTE ();
8631 switch (op[2] & 0x0f)
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;
8654 break;
8655 case 0xe3:
8656 GETBYTE ();
8657 switch (op[2] & 0x0f)
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;
8680 break;
8681 case 0xe4:
8682 GETBYTE ();
8683 switch (op[2] & 0x0f)
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;
8706 break;
8707 case 0xe5:
8708 GETBYTE ();
8709 switch (op[2] & 0x0f)
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;
8732 break;
8733 case 0xe6:
8734 GETBYTE ();
8735 switch (op[2] & 0x0f)
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;
8758 break;
8759 case 0xe7:
8760 GETBYTE ();
8761 switch (op[2] & 0x0f)
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;
8784 break;
8785 case 0xe8:
8786 GETBYTE ();
8787 switch (op[2] & 0x0f)
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;
8810 break;
8811 case 0xe9:
8812 GETBYTE ();
8813 switch (op[2] & 0x0f)
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;
8836 break;
8837 case 0xea:
8838 GETBYTE ();
8839 switch (op[2] & 0x0f)
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;
8862 break;
8863 case 0xeb:
8864 GETBYTE ();
8865 switch (op[2] & 0x0f)
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;
8888 break;
8889 case 0xec:
8890 GETBYTE ();
8891 switch (op[2] & 0x0f)
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;
8914 break;
8915 case 0xed:
8916 GETBYTE ();
8917 switch (op[2] & 0x0f)
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;
8940 break;
8941 case 0xee:
8942 GETBYTE ();
8943 switch (op[2] & 0x0f)
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;
8966 break;
8967 case 0xef:
8968 GETBYTE ();
8969 switch (op[2] & 0x0f)
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;
8992 break;
8993 case 0xf0:
8994 GETBYTE ();
8995 switch (op[2] & 0x0f)
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;
9018 break;
9019 case 0xf1:
9020 GETBYTE ();
9021 switch (op[2] & 0x0f)
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;
9044 break;
9045 case 0xf2:
9046 GETBYTE ();
9047 switch (op[2] & 0x0f)
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;
9070 break;
9071 case 0xf3:
9072 GETBYTE ();
9073 switch (op[2] & 0x0f)
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;
9096 break;
9097 case 0xf4:
9098 GETBYTE ();
9099 switch (op[2] & 0x0f)
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;
9122 break;
9123 case 0xf5:
9124 GETBYTE ();
9125 switch (op[2] & 0x0f)
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;
9148 break;
9149 case 0xf6:
9150 GETBYTE ();
9151 switch (op[2] & 0x0f)
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;
9174 break;
9175 case 0xf7:
9176 GETBYTE ();
9177 switch (op[2] & 0x0f)
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;
9200 break;
9201 case 0xf8:
9202 GETBYTE ();
9203 switch (op[2] & 0x0f)
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;
9226 break;
9227 case 0xf9:
9228 GETBYTE ();
9229 switch (op[2] & 0x0f)
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;
9252 break;
9253 case 0xfa:
9254 GETBYTE ();
9255 switch (op[2] & 0x0f)
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;
9278 break;
9279 case 0xfb:
9280 GETBYTE ();
9281 switch (op[2] & 0x0f)
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;
9304 break;
9305 case 0xfc:
9306 GETBYTE ();
9307 switch (op[2] & 0x0f)
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;
9330 break;
9331 case 0xfd:
9332 GETBYTE ();
9333 switch (op[2] & 0x0f)
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;
9356 break;
9357 case 0xfe:
9358 GETBYTE ();
9359 switch (op[2] & 0x0f)
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;
9382 break;
9383 case 0xff:
9384 GETBYTE ();
9385 switch (op[2] & 0x0f)
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;
9408 break;
9409 default: UNSUPPORTED(); break;
9411 break;
9412 case 0xfd:
9413 GETBYTE ();
9414 switch (op[1] & 0xff)
9416 case 0x00:
9417 GETBYTE ();
9418 switch (op[2] & 0x00)
9420 case 0x00:
9422 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
9423 #line 772 "rx-decode.opc"
9424 int srca AU = (op[2] >> 4) & 0x0f;
9425 #line 772 "rx-decode.opc"
9426 int srcb AU = op[2] & 0x0f;
9427 if (trace)
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);
9435 SYNTAX("mulhi %1, %2");
9436 #line 772 "rx-decode.opc"
9437 ID(mulhi); SR(srca); S2R(srcb); F_____;
9440 break;
9442 break;
9443 case 0x01:
9444 GETBYTE ();
9445 switch (op[2] & 0x00)
9447 case 0x00:
9449 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
9450 #line 775 "rx-decode.opc"
9451 int srca AU = (op[2] >> 4) & 0x0f;
9452 #line 775 "rx-decode.opc"
9453 int srcb AU = op[2] & 0x0f;
9454 if (trace)
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);
9462 SYNTAX("mullo %1, %2");
9463 #line 775 "rx-decode.opc"
9464 ID(mullo); SR(srca); S2R(srcb); F_____;
9467 break;
9469 break;
9470 case 0x04:
9471 GETBYTE ();
9472 switch (op[2] & 0x00)
9474 case 0x00:
9476 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
9477 #line 778 "rx-decode.opc"
9478 int srca AU = (op[2] >> 4) & 0x0f;
9479 #line 778 "rx-decode.opc"
9480 int srcb AU = op[2] & 0x0f;
9481 if (trace)
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);
9489 SYNTAX("machi %1, %2");
9490 #line 778 "rx-decode.opc"
9491 ID(machi); SR(srca); S2R(srcb); F_____;
9494 break;
9496 break;
9497 case 0x05:
9498 GETBYTE ();
9499 switch (op[2] & 0x00)
9501 case 0x00:
9503 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
9504 #line 781 "rx-decode.opc"
9505 int srca AU = (op[2] >> 4) & 0x0f;
9506 #line 781 "rx-decode.opc"
9507 int srcb AU = op[2] & 0x0f;
9508 if (trace)
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);
9516 SYNTAX("maclo %1, %2");
9517 #line 781 "rx-decode.opc"
9518 ID(maclo); SR(srca); S2R(srcb); F_____;
9521 break;
9523 break;
9524 case 0x17:
9525 GETBYTE ();
9526 switch (op[2] & 0xf0)
9528 case 0x00:
9530 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9531 #line 784 "rx-decode.opc"
9532 int rsrc AU = op[2] & 0x0f;
9533 if (trace)
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);
9540 SYNTAX("mvtachi %1");
9541 #line 784 "rx-decode.opc"
9542 ID(mvtachi); SR(rsrc); F_____;
9545 break;
9546 case 0x10:
9548 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9549 #line 787 "rx-decode.opc"
9550 int rsrc AU = op[2] & 0x0f;
9551 if (trace)
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);
9558 SYNTAX("mvtaclo %1");
9559 #line 787 "rx-decode.opc"
9560 ID(mvtaclo); SR(rsrc); F_____;
9563 break;
9564 default: UNSUPPORTED(); break;
9566 break;
9567 case 0x18:
9568 GETBYTE ();
9569 switch (op[2] & 0xef)
9571 case 0x00:
9573 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
9574 #line 799 "rx-decode.opc"
9575 int i AU = (op[2] >> 4) & 0x01;
9576 if (trace)
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);
9583 SYNTAX("racw #%1");
9584 #line 799 "rx-decode.opc"
9585 ID(racw); SC(i+1); F_____;
9587 /*----------------------------------------------------------------------*/
9588 /* SAT */
9591 break;
9592 default: UNSUPPORTED(); break;
9594 break;
9595 case 0x1f:
9596 GETBYTE ();
9597 switch (op[2] & 0xf0)
9599 case 0x00:
9601 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9602 #line 790 "rx-decode.opc"
9603 int rdst AU = op[2] & 0x0f;
9604 if (trace)
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);
9611 SYNTAX("mvfachi %0");
9612 #line 790 "rx-decode.opc"
9613 ID(mvfachi); DR(rdst); F_____;
9616 break;
9617 case 0x10:
9619 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9620 #line 796 "rx-decode.opc"
9621 int rdst AU = op[2] & 0x0f;
9622 if (trace)
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);
9629 SYNTAX("mvfaclo %0");
9630 #line 796 "rx-decode.opc"
9631 ID(mvfaclo); DR(rdst); F_____;
9634 break;
9635 case 0x20:
9637 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9638 #line 793 "rx-decode.opc"
9639 int rdst AU = op[2] & 0x0f;
9640 if (trace)
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);
9647 SYNTAX("mvfacmi %0");
9648 #line 793 "rx-decode.opc"
9649 ID(mvfacmi); DR(rdst); F_____;
9652 break;
9653 default: UNSUPPORTED(); break;
9655 break;
9656 case 0x20:
9657 GETBYTE ();
9658 switch (op[2] & 0x00)
9660 case 0x00:
9661 op_semantics_71:
9663 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
9664 #line 307 "rx-decode.opc"
9665 int p AU = (op[1] >> 2) & 0x01;
9666 #line 307 "rx-decode.opc"
9667 int sz AU = op[1] & 0x03;
9668 #line 307 "rx-decode.opc"
9669 int rdst AU = (op[2] >> 4) & 0x0f;
9670 #line 307 "rx-decode.opc"
9671 int rsrc AU = op[2] & 0x0f;
9672 if (trace)
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);
9682 SYNTAX("mov%s %1, %0");
9683 #line 307 "rx-decode.opc"
9684 ID(mov); sBWL (sz); SR(rsrc); F_____;
9685 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9688 break;
9690 break;
9691 case 0x21:
9692 GETBYTE ();
9693 switch (op[2] & 0x00)
9695 case 0x00:
9696 goto op_semantics_71;
9697 break;
9699 break;
9700 case 0x22:
9701 GETBYTE ();
9702 switch (op[2] & 0x00)
9704 case 0x00:
9705 goto op_semantics_71;
9706 break;
9708 break;
9709 case 0x24:
9710 GETBYTE ();
9711 switch (op[2] & 0x00)
9713 case 0x00:
9714 goto op_semantics_71;
9715 break;
9717 break;
9718 case 0x25:
9719 GETBYTE ();
9720 switch (op[2] & 0x00)
9722 case 0x00:
9723 goto op_semantics_71;
9724 break;
9726 break;
9727 case 0x26:
9728 GETBYTE ();
9729 switch (op[2] & 0x00)
9731 case 0x00:
9732 goto op_semantics_71;
9733 break;
9735 break;
9736 case 0x28:
9737 GETBYTE ();
9738 switch (op[2] & 0x00)
9740 case 0x00:
9741 op_semantics_72:
9743 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
9744 #line 311 "rx-decode.opc"
9745 int p AU = (op[1] >> 2) & 0x01;
9746 #line 311 "rx-decode.opc"
9747 int sz AU = op[1] & 0x03;
9748 #line 311 "rx-decode.opc"
9749 int rsrc AU = (op[2] >> 4) & 0x0f;
9750 #line 311 "rx-decode.opc"
9751 int rdst AU = op[2] & 0x0f;
9752 if (trace)
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);
9762 SYNTAX("mov%s %1, %0");
9763 #line 311 "rx-decode.opc"
9764 ID(mov); sBWL (sz); DR(rdst); F_____;
9765 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9768 break;
9770 break;
9771 case 0x29:
9772 GETBYTE ();
9773 switch (op[2] & 0x00)
9775 case 0x00:
9776 goto op_semantics_72;
9777 break;
9779 break;
9780 case 0x2a:
9781 GETBYTE ();
9782 switch (op[2] & 0x00)
9784 case 0x00:
9785 goto op_semantics_72;
9786 break;
9788 break;
9789 case 0x2c:
9790 GETBYTE ();
9791 switch (op[2] & 0x00)
9793 case 0x00:
9794 goto op_semantics_72;
9795 break;
9797 break;
9798 case 0x2d:
9799 GETBYTE ();
9800 switch (op[2] & 0x00)
9802 case 0x00:
9803 goto op_semantics_72;
9804 break;
9806 break;
9807 case 0x2e:
9808 GETBYTE ();
9809 switch (op[2] & 0x00)
9811 case 0x00:
9812 goto op_semantics_72;
9813 break;
9815 break;
9816 case 0x38:
9817 GETBYTE ();
9818 switch (op[2] & 0x00)
9820 case 0x00:
9821 op_semantics_73:
9823 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
9824 #line 321 "rx-decode.opc"
9825 int p AU = (op[1] >> 2) & 0x01;
9826 #line 321 "rx-decode.opc"
9827 int sz AU = op[1] & 0x03;
9828 #line 321 "rx-decode.opc"
9829 int rsrc AU = (op[2] >> 4) & 0x0f;
9830 #line 321 "rx-decode.opc"
9831 int rdst AU = op[2] & 0x0f;
9832 if (trace)
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);
9842 SYNTAX("movu%s %1, %0");
9843 #line 321 "rx-decode.opc"
9844 ID(mov); uBWL (sz); DR(rdst); F_____;
9845 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9847 /*----------------------------------------------------------------------*/
9848 /* PUSH/POP */
9851 break;
9853 break;
9854 case 0x39:
9855 GETBYTE ();
9856 switch (op[2] & 0x00)
9858 case 0x00:
9859 goto op_semantics_73;
9860 break;
9862 break;
9863 case 0x3a:
9864 GETBYTE ();
9865 switch (op[2] & 0x00)
9867 case 0x00:
9868 goto op_semantics_73;
9869 break;
9871 break;
9872 case 0x3c:
9873 GETBYTE ();
9874 switch (op[2] & 0x00)
9876 case 0x00:
9877 goto op_semantics_73;
9878 break;
9880 break;
9881 case 0x3d:
9882 GETBYTE ();
9883 switch (op[2] & 0x00)
9885 case 0x00:
9886 goto op_semantics_73;
9887 break;
9889 break;
9890 case 0x3e:
9891 GETBYTE ();
9892 switch (op[2] & 0x00)
9894 case 0x00:
9895 goto op_semantics_73;
9896 break;
9898 break;
9899 case 0x60:
9900 GETBYTE ();
9901 switch (op[2] & 0x00)
9903 case 0x00:
9905 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
9906 #line 653 "rx-decode.opc"
9907 int rsrc AU = (op[2] >> 4) & 0x0f;
9908 #line 653 "rx-decode.opc"
9909 int rdst AU = op[2] & 0x0f;
9910 if (trace)
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);
9918 SYNTAX("shlr %2, %0");
9919 #line 653 "rx-decode.opc"
9920 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
9923 break;
9925 break;
9926 case 0x61:
9927 GETBYTE ();
9928 switch (op[2] & 0x00)
9930 case 0x00:
9932 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
9933 #line 643 "rx-decode.opc"
9934 int rsrc AU = (op[2] >> 4) & 0x0f;
9935 #line 643 "rx-decode.opc"
9936 int rdst AU = op[2] & 0x0f;
9937 if (trace)
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);
9945 SYNTAX("shar %2, %0");
9946 #line 643 "rx-decode.opc"
9947 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
9950 break;
9952 break;
9953 case 0x62:
9954 GETBYTE ();
9955 switch (op[2] & 0x00)
9957 case 0x00:
9959 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
9960 #line 633 "rx-decode.opc"
9961 int rsrc AU = (op[2] >> 4) & 0x0f;
9962 #line 633 "rx-decode.opc"
9963 int rdst AU = op[2] & 0x0f;
9964 if (trace)
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);
9972 SYNTAX("shll %2, %0");
9973 #line 633 "rx-decode.opc"
9974 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
9977 break;
9979 break;
9980 case 0x64:
9981 GETBYTE ();
9982 switch (op[2] & 0x00)
9984 case 0x00:
9986 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
9987 #line 677 "rx-decode.opc"
9988 int rsrc AU = (op[2] >> 4) & 0x0f;
9989 #line 677 "rx-decode.opc"
9990 int rdst AU = op[2] & 0x0f;
9991 if (trace)
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);
9999 SYNTAX("rotr %1, %0");
10000 #line 677 "rx-decode.opc"
10001 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
10004 break;
10006 break;
10007 case 0x65:
10008 GETBYTE ();
10009 switch (op[2] & 0x00)
10011 case 0x00:
10013 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
10014 #line 680 "rx-decode.opc"
10015 int rsrc AU = (op[2] >> 4) & 0x0f;
10016 #line 680 "rx-decode.opc"
10017 int rdst AU = op[2] & 0x0f;
10018 if (trace)
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);
10026 SYNTAX("revw %1, %0");
10027 #line 680 "rx-decode.opc"
10028 ID(revw); SR(rsrc); DR(rdst);
10031 break;
10033 break;
10034 case 0x66:
10035 GETBYTE ();
10036 switch (op[2] & 0x00)
10038 case 0x00:
10040 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
10041 #line 671 "rx-decode.opc"
10042 int rsrc AU = (op[2] >> 4) & 0x0f;
10043 #line 671 "rx-decode.opc"
10044 int rdst AU = op[2] & 0x0f;
10045 if (trace)
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);
10053 SYNTAX("rotl %1, %0");
10054 #line 671 "rx-decode.opc"
10055 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
10058 break;
10060 break;
10061 case 0x67:
10062 GETBYTE ();
10063 switch (op[2] & 0x00)
10065 case 0x00:
10067 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
10068 #line 683 "rx-decode.opc"
10069 int rsrc AU = (op[2] >> 4) & 0x0f;
10070 #line 683 "rx-decode.opc"
10071 int rdst AU = op[2] & 0x0f;
10072 if (trace)
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);
10080 SYNTAX("revl %1, %0");
10081 #line 683 "rx-decode.opc"
10082 ID(revl); SR(rsrc); DR(rdst);
10084 /*----------------------------------------------------------------------*/
10085 /* BRANCH */
10088 break;
10090 break;
10091 case 0x68:
10092 GETBYTE ();
10093 switch (op[2] & 0x00)
10095 case 0x00:
10096 op_semantics_74:
10098 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
10099 #line 926 "rx-decode.opc"
10100 int c AU = op[1] & 0x01;
10101 #line 926 "rx-decode.opc"
10102 int rsrc AU = (op[2] >> 4) & 0x0f;
10103 #line 926 "rx-decode.opc"
10104 int rdst AU = op[2] & 0x0f;
10105 if (trace)
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);
10114 SYNTAX("mvtc %1, %0");
10115 #line 926 "rx-decode.opc"
10116 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10119 break;
10121 break;
10122 case 0x69:
10123 GETBYTE ();
10124 switch (op[2] & 0x00)
10126 case 0x00:
10127 goto op_semantics_74;
10128 break;
10130 break;
10131 case 0x6a:
10132 GETBYTE ();
10133 switch (op[2] & 0x00)
10135 case 0x00:
10136 op_semantics_75:
10138 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
10139 #line 929 "rx-decode.opc"
10140 int s AU = op[1] & 0x01;
10141 #line 929 "rx-decode.opc"
10142 int rsrc AU = (op[2] >> 4) & 0x0f;
10143 #line 929 "rx-decode.opc"
10144 int rdst AU = op[2] & 0x0f;
10145 if (trace)
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);
10154 SYNTAX("mvfc %1, %0");
10155 #line 929 "rx-decode.opc"
10156 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10158 /*----------------------------------------------------------------------*/
10159 /* INTERRUPTS */
10162 break;
10164 break;
10165 case 0x6b:
10166 GETBYTE ();
10167 switch (op[2] & 0x00)
10169 case 0x00:
10170 goto op_semantics_75;
10171 break;
10173 break;
10174 case 0x6c:
10175 GETBYTE ();
10176 switch (op[2] & 0x00)
10178 case 0x00:
10179 op_semantics_76:
10181 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
10182 #line 674 "rx-decode.opc"
10183 int i AU = op[1] & 0x01;
10184 #line 674 "rx-decode.opc"
10185 int mmmm AU = (op[2] >> 4) & 0x0f;
10186 #line 674 "rx-decode.opc"
10187 int rdst AU = op[2] & 0x0f;
10188 if (trace)
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);
10197 SYNTAX("rotr #%1, %0");
10198 #line 674 "rx-decode.opc"
10199 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
10202 break;
10204 break;
10205 case 0x6d:
10206 GETBYTE ();
10207 switch (op[2] & 0x00)
10209 case 0x00:
10210 goto op_semantics_76;
10211 break;
10213 break;
10214 case 0x6e:
10215 GETBYTE ();
10216 switch (op[2] & 0x00)
10218 case 0x00:
10219 op_semantics_77:
10221 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
10222 #line 668 "rx-decode.opc"
10223 int i AU = op[1] & 0x01;
10224 #line 668 "rx-decode.opc"
10225 int mmmm AU = (op[2] >> 4) & 0x0f;
10226 #line 668 "rx-decode.opc"
10227 int rdst AU = op[2] & 0x0f;
10228 if (trace)
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);
10237 SYNTAX("rotl #%1, %0");
10238 #line 668 "rx-decode.opc"
10239 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
10242 break;
10244 break;
10245 case 0x6f:
10246 GETBYTE ();
10247 switch (op[2] & 0x00)
10249 case 0x00:
10250 goto op_semantics_77;
10251 break;
10253 break;
10254 case 0x70:
10255 GETBYTE ();
10256 switch (op[2] & 0xf0)
10258 case 0x20:
10259 op_semantics_78:
10261 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
10262 #line 451 "rx-decode.opc"
10263 int im AU = (op[1] >> 2) & 0x03;
10264 #line 451 "rx-decode.opc"
10265 int rdst AU = op[2] & 0x0f;
10266 if (trace)
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);
10274 SYNTAX("adc #%1, %0");
10275 #line 451 "rx-decode.opc"
10276 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
10279 break;
10280 case 0x40:
10281 op_semantics_79:
10283 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
10284 #line 533 "rx-decode.opc"
10285 int im AU = (op[1] >> 2) & 0x03;
10286 #line 533 "rx-decode.opc"
10287 int rdst AU = op[2] & 0x0f;
10288 if (trace)
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);
10296 SYNTAX("max #%1, %0");
10297 #line 533 "rx-decode.opc"
10298 ID(max); DR(rdst); SC(IMMex(im));
10301 break;
10302 case 0x50:
10303 op_semantics_80:
10305 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
10306 #line 552 "rx-decode.opc"
10307 int im AU = (op[1] >> 2) & 0x03;
10308 #line 552 "rx-decode.opc"
10309 int rdst AU = op[2] & 0x0f;
10310 if (trace)
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);
10318 SYNTAX("min #%1, %0");
10319 #line 552 "rx-decode.opc"
10320 ID(min); DR(rdst); SC(IMMex(im));
10323 break;
10324 case 0x60:
10325 op_semantics_81:
10327 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
10328 #line 582 "rx-decode.opc"
10329 int im AU = (op[1] >> 2) & 0x03;
10330 #line 582 "rx-decode.opc"
10331 int rdst AU = op[2] & 0x0f;
10332 if (trace)
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);
10340 SYNTAX("emul #%1, %0");
10341 #line 582 "rx-decode.opc"
10342 ID(emul); DR(rdst); SC(IMMex(im));
10345 break;
10346 case 0x70:
10347 op_semantics_82:
10349 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
10350 #line 594 "rx-decode.opc"
10351 int im AU = (op[1] >> 2) & 0x03;
10352 #line 594 "rx-decode.opc"
10353 int rdst AU = op[2] & 0x0f;
10354 if (trace)
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);
10362 SYNTAX("emulu #%1, %0");
10363 #line 594 "rx-decode.opc"
10364 ID(emulu); DR(rdst); SC(IMMex(im));
10367 break;
10368 case 0x80:
10369 op_semantics_83:
10371 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
10372 #line 606 "rx-decode.opc"
10373 int im AU = (op[1] >> 2) & 0x03;
10374 #line 606 "rx-decode.opc"
10375 int rdst AU = op[2] & 0x0f;
10376 if (trace)
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);
10384 SYNTAX("div #%1, %0");
10385 #line 606 "rx-decode.opc"
10386 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
10389 break;
10390 case 0x90:
10391 op_semantics_84:
10393 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
10394 #line 618 "rx-decode.opc"
10395 int im AU = (op[1] >> 2) & 0x03;
10396 #line 618 "rx-decode.opc"
10397 int rdst AU = op[2] & 0x0f;
10398 if (trace)
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);
10406 SYNTAX("divu #%1, %0");
10407 #line 618 "rx-decode.opc"
10408 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
10411 break;
10412 case 0xc0:
10413 op_semantics_85:
10415 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
10416 #line 430 "rx-decode.opc"
10417 int im AU = (op[1] >> 2) & 0x03;
10418 #line 430 "rx-decode.opc"
10419 int rdst AU = op[2] & 0x0f;
10420 if (trace)
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);
10428 SYNTAX("tst #%1, %2");
10429 #line 430 "rx-decode.opc"
10430 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
10433 break;
10434 case 0xd0:
10435 op_semantics_86:
10437 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
10438 #line 409 "rx-decode.opc"
10439 int im AU = (op[1] >> 2) & 0x03;
10440 #line 409 "rx-decode.opc"
10441 int rdst AU = op[2] & 0x0f;
10442 if (trace)
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);
10450 SYNTAX("xor #%1, %0");
10451 #line 409 "rx-decode.opc"
10452 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
10455 break;
10456 case 0xe0:
10457 op_semantics_87:
10459 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
10460 #line 355 "rx-decode.opc"
10461 int im AU = (op[1] >> 2) & 0x03;
10462 #line 355 "rx-decode.opc"
10463 int rdst AU = op[2] & 0x0f;
10464 if (trace)
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);
10472 SYNTAX("stz #%1, %0");
10473 #line 355 "rx-decode.opc"
10474 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10477 break;
10478 case 0xf0:
10479 op_semantics_88:
10481 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
10482 #line 358 "rx-decode.opc"
10483 int im AU = (op[1] >> 2) & 0x03;
10484 #line 358 "rx-decode.opc"
10485 int rdst AU = op[2] & 0x0f;
10486 if (trace)
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);
10494 SYNTAX("stnz #%1, %0");
10495 #line 358 "rx-decode.opc"
10496 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10498 /*----------------------------------------------------------------------*/
10499 /* RTSD */
10502 break;
10503 default: UNSUPPORTED(); break;
10505 break;
10506 case 0x72:
10507 GETBYTE ();
10508 switch (op[2] & 0xf0)
10510 case 0x00:
10512 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
10513 #line 826 "rx-decode.opc"
10514 int rdst AU = op[2] & 0x0f;
10515 if (trace)
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);
10522 SYNTAX("fsub #%1, %0");
10523 #line 826 "rx-decode.opc"
10524 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
10527 break;
10528 case 0x10:
10530 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
10531 #line 820 "rx-decode.opc"
10532 int rdst AU = op[2] & 0x0f;
10533 if (trace)
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);
10540 SYNTAX("fcmp #%1, %0");
10541 #line 820 "rx-decode.opc"
10542 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
10545 break;
10546 case 0x20:
10548 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
10549 #line 814 "rx-decode.opc"
10550 int rdst AU = op[2] & 0x0f;
10551 if (trace)
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);
10558 SYNTAX("fadd #%1, %0");
10559 #line 814 "rx-decode.opc"
10560 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
10563 break;
10564 case 0x30:
10566 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
10567 #line 835 "rx-decode.opc"
10568 int rdst AU = op[2] & 0x0f;
10569 if (trace)
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);
10576 SYNTAX("fmul #%1, %0");
10577 #line 835 "rx-decode.opc"
10578 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
10581 break;
10582 case 0x40:
10584 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
10585 #line 841 "rx-decode.opc"
10586 int rdst AU = op[2] & 0x0f;
10587 if (trace)
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);
10594 SYNTAX("fdiv #%1, %0");
10595 #line 841 "rx-decode.opc"
10596 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
10599 break;
10600 default: UNSUPPORTED(); break;
10602 break;
10603 case 0x73:
10604 GETBYTE ();
10605 switch (op[2] & 0xe0)
10607 case 0x00:
10608 op_semantics_89:
10610 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
10611 #line 923 "rx-decode.opc"
10612 int im AU = (op[1] >> 2) & 0x03;
10613 #line 923 "rx-decode.opc"
10614 int crdst AU = op[2] & 0x1f;
10615 if (trace)
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);
10623 SYNTAX("mvtc #%1, %0");
10624 #line 923 "rx-decode.opc"
10625 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10628 break;
10629 default: UNSUPPORTED(); break;
10631 break;
10632 case 0x74:
10633 GETBYTE ();
10634 switch (op[2] & 0xf0)
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;
10671 break;
10672 case 0x77:
10673 GETBYTE ();
10674 switch (op[2] & 0xe0)
10676 case 0x00:
10677 goto op_semantics_89;
10678 break;
10679 default: UNSUPPORTED(); break;
10681 break;
10682 case 0x78:
10683 GETBYTE ();
10684 switch (op[2] & 0xf0)
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;
10721 break;
10722 case 0x7b:
10723 GETBYTE ();
10724 switch (op[2] & 0xe0)
10726 case 0x00:
10727 goto op_semantics_89;
10728 break;
10729 default: UNSUPPORTED(); break;
10731 break;
10732 case 0x7c:
10733 GETBYTE ();
10734 switch (op[2] & 0xf0)
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;
10771 break;
10772 case 0x7f:
10773 GETBYTE ();
10774 switch (op[2] & 0xe0)
10776 case 0x00:
10777 goto op_semantics_89;
10778 break;
10779 default: UNSUPPORTED(); break;
10781 break;
10782 case 0x80:
10783 GETBYTE ();
10784 switch (op[2] & 0x00)
10786 case 0x00:
10787 op_semantics_90:
10789 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
10790 #line 656 "rx-decode.opc"
10791 int immmm AU = op[1] & 0x1f;
10792 #line 656 "rx-decode.opc"
10793 int rsrc AU = (op[2] >> 4) & 0x0f;
10794 #line 656 "rx-decode.opc"
10795 int rdst AU = op[2] & 0x0f;
10796 if (trace)
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);
10805 SYNTAX("shlr #%2, %1, %0");
10806 #line 656 "rx-decode.opc"
10807 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
10809 /*----------------------------------------------------------------------*/
10810 /* ROTATE */
10813 break;
10815 break;
10816 case 0x81:
10817 GETBYTE ();
10818 switch (op[2] & 0x00)
10820 case 0x00:
10821 goto op_semantics_90;
10822 break;
10824 break;
10825 case 0x82:
10826 GETBYTE ();
10827 switch (op[2] & 0x00)
10829 case 0x00:
10830 goto op_semantics_90;
10831 break;
10833 break;
10834 case 0x83:
10835 GETBYTE ();
10836 switch (op[2] & 0x00)
10838 case 0x00:
10839 goto op_semantics_90;
10840 break;
10842 break;
10843 case 0x84:
10844 GETBYTE ();
10845 switch (op[2] & 0x00)
10847 case 0x00:
10848 goto op_semantics_90;
10849 break;
10851 break;
10852 case 0x85:
10853 GETBYTE ();
10854 switch (op[2] & 0x00)
10856 case 0x00:
10857 goto op_semantics_90;
10858 break;
10860 break;
10861 case 0x86:
10862 GETBYTE ();
10863 switch (op[2] & 0x00)
10865 case 0x00:
10866 goto op_semantics_90;
10867 break;
10869 break;
10870 case 0x87:
10871 GETBYTE ();
10872 switch (op[2] & 0x00)
10874 case 0x00:
10875 goto op_semantics_90;
10876 break;
10878 break;
10879 case 0x88:
10880 GETBYTE ();
10881 switch (op[2] & 0x00)
10883 case 0x00:
10884 goto op_semantics_90;
10885 break;
10887 break;
10888 case 0x89:
10889 GETBYTE ();
10890 switch (op[2] & 0x00)
10892 case 0x00:
10893 goto op_semantics_90;
10894 break;
10896 break;
10897 case 0x8a:
10898 GETBYTE ();
10899 switch (op[2] & 0x00)
10901 case 0x00:
10902 goto op_semantics_90;
10903 break;
10905 break;
10906 case 0x8b:
10907 GETBYTE ();
10908 switch (op[2] & 0x00)
10910 case 0x00:
10911 goto op_semantics_90;
10912 break;
10914 break;
10915 case 0x8c:
10916 GETBYTE ();
10917 switch (op[2] & 0x00)
10919 case 0x00:
10920 goto op_semantics_90;
10921 break;
10923 break;
10924 case 0x8d:
10925 GETBYTE ();
10926 switch (op[2] & 0x00)
10928 case 0x00:
10929 goto op_semantics_90;
10930 break;
10932 break;
10933 case 0x8e:
10934 GETBYTE ();
10935 switch (op[2] & 0x00)
10937 case 0x00:
10938 goto op_semantics_90;
10939 break;
10941 break;
10942 case 0x8f:
10943 GETBYTE ();
10944 switch (op[2] & 0x00)
10946 case 0x00:
10947 goto op_semantics_90;
10948 break;
10950 break;
10951 case 0x90:
10952 GETBYTE ();
10953 switch (op[2] & 0x00)
10955 case 0x00:
10956 goto op_semantics_90;
10957 break;
10959 break;
10960 case 0x91:
10961 GETBYTE ();
10962 switch (op[2] & 0x00)
10964 case 0x00:
10965 goto op_semantics_90;
10966 break;
10968 break;
10969 case 0x92:
10970 GETBYTE ();
10971 switch (op[2] & 0x00)
10973 case 0x00:
10974 goto op_semantics_90;
10975 break;
10977 break;
10978 case 0x93:
10979 GETBYTE ();
10980 switch (op[2] & 0x00)
10982 case 0x00:
10983 goto op_semantics_90;
10984 break;
10986 break;
10987 case 0x94:
10988 GETBYTE ();
10989 switch (op[2] & 0x00)
10991 case 0x00:
10992 goto op_semantics_90;
10993 break;
10995 break;
10996 case 0x95:
10997 GETBYTE ();
10998 switch (op[2] & 0x00)
11000 case 0x00:
11001 goto op_semantics_90;
11002 break;
11004 break;
11005 case 0x96:
11006 GETBYTE ();
11007 switch (op[2] & 0x00)
11009 case 0x00:
11010 goto op_semantics_90;
11011 break;
11013 break;
11014 case 0x97:
11015 GETBYTE ();
11016 switch (op[2] & 0x00)
11018 case 0x00:
11019 goto op_semantics_90;
11020 break;
11022 break;
11023 case 0x98:
11024 GETBYTE ();
11025 switch (op[2] & 0x00)
11027 case 0x00:
11028 goto op_semantics_90;
11029 break;
11031 break;
11032 case 0x99:
11033 GETBYTE ();
11034 switch (op[2] & 0x00)
11036 case 0x00:
11037 goto op_semantics_90;
11038 break;
11040 break;
11041 case 0x9a:
11042 GETBYTE ();
11043 switch (op[2] & 0x00)
11045 case 0x00:
11046 goto op_semantics_90;
11047 break;
11049 break;
11050 case 0x9b:
11051 GETBYTE ();
11052 switch (op[2] & 0x00)
11054 case 0x00:
11055 goto op_semantics_90;
11056 break;
11058 break;
11059 case 0x9c:
11060 GETBYTE ();
11061 switch (op[2] & 0x00)
11063 case 0x00:
11064 goto op_semantics_90;
11065 break;
11067 break;
11068 case 0x9d:
11069 GETBYTE ();
11070 switch (op[2] & 0x00)
11072 case 0x00:
11073 goto op_semantics_90;
11074 break;
11076 break;
11077 case 0x9e:
11078 GETBYTE ();
11079 switch (op[2] & 0x00)
11081 case 0x00:
11082 goto op_semantics_90;
11083 break;
11085 break;
11086 case 0x9f:
11087 GETBYTE ();
11088 switch (op[2] & 0x00)
11090 case 0x00:
11091 goto op_semantics_90;
11092 break;
11094 break;
11095 case 0xa0:
11096 GETBYTE ();
11097 switch (op[2] & 0x00)
11099 case 0x00:
11100 op_semantics_91:
11102 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
11103 #line 646 "rx-decode.opc"
11104 int immmm AU = op[1] & 0x1f;
11105 #line 646 "rx-decode.opc"
11106 int rsrc AU = (op[2] >> 4) & 0x0f;
11107 #line 646 "rx-decode.opc"
11108 int rdst AU = op[2] & 0x0f;
11109 if (trace)
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);
11118 SYNTAX("shar #%2, %1, %0");
11119 #line 646 "rx-decode.opc"
11120 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
11124 break;
11126 break;
11127 case 0xa1:
11128 GETBYTE ();
11129 switch (op[2] & 0x00)
11131 case 0x00:
11132 goto op_semantics_91;
11133 break;
11135 break;
11136 case 0xa2:
11137 GETBYTE ();
11138 switch (op[2] & 0x00)
11140 case 0x00:
11141 goto op_semantics_91;
11142 break;
11144 break;
11145 case 0xa3:
11146 GETBYTE ();
11147 switch (op[2] & 0x00)
11149 case 0x00:
11150 goto op_semantics_91;
11151 break;
11153 break;
11154 case 0xa4:
11155 GETBYTE ();
11156 switch (op[2] & 0x00)
11158 case 0x00:
11159 goto op_semantics_91;
11160 break;
11162 break;
11163 case 0xa5:
11164 GETBYTE ();
11165 switch (op[2] & 0x00)
11167 case 0x00:
11168 goto op_semantics_91;
11169 break;
11171 break;
11172 case 0xa6:
11173 GETBYTE ();
11174 switch (op[2] & 0x00)
11176 case 0x00:
11177 goto op_semantics_91;
11178 break;
11180 break;
11181 case 0xa7:
11182 GETBYTE ();
11183 switch (op[2] & 0x00)
11185 case 0x00:
11186 goto op_semantics_91;
11187 break;
11189 break;
11190 case 0xa8:
11191 GETBYTE ();
11192 switch (op[2] & 0x00)
11194 case 0x00:
11195 goto op_semantics_91;
11196 break;
11198 break;
11199 case 0xa9:
11200 GETBYTE ();
11201 switch (op[2] & 0x00)
11203 case 0x00:
11204 goto op_semantics_91;
11205 break;
11207 break;
11208 case 0xaa:
11209 GETBYTE ();
11210 switch (op[2] & 0x00)
11212 case 0x00:
11213 goto op_semantics_91;
11214 break;
11216 break;
11217 case 0xab:
11218 GETBYTE ();
11219 switch (op[2] & 0x00)
11221 case 0x00:
11222 goto op_semantics_91;
11223 break;
11225 break;
11226 case 0xac:
11227 GETBYTE ();
11228 switch (op[2] & 0x00)
11230 case 0x00:
11231 goto op_semantics_91;
11232 break;
11234 break;
11235 case 0xad:
11236 GETBYTE ();
11237 switch (op[2] & 0x00)
11239 case 0x00:
11240 goto op_semantics_91;
11241 break;
11243 break;
11244 case 0xae:
11245 GETBYTE ();
11246 switch (op[2] & 0x00)
11248 case 0x00:
11249 goto op_semantics_91;
11250 break;
11252 break;
11253 case 0xaf:
11254 GETBYTE ();
11255 switch (op[2] & 0x00)
11257 case 0x00:
11258 goto op_semantics_91;
11259 break;
11261 break;
11262 case 0xb0:
11263 GETBYTE ();
11264 switch (op[2] & 0x00)
11266 case 0x00:
11267 goto op_semantics_91;
11268 break;
11270 break;
11271 case 0xb1:
11272 GETBYTE ();
11273 switch (op[2] & 0x00)
11275 case 0x00:
11276 goto op_semantics_91;
11277 break;
11279 break;
11280 case 0xb2:
11281 GETBYTE ();
11282 switch (op[2] & 0x00)
11284 case 0x00:
11285 goto op_semantics_91;
11286 break;
11288 break;
11289 case 0xb3:
11290 GETBYTE ();
11291 switch (op[2] & 0x00)
11293 case 0x00:
11294 goto op_semantics_91;
11295 break;
11297 break;
11298 case 0xb4:
11299 GETBYTE ();
11300 switch (op[2] & 0x00)
11302 case 0x00:
11303 goto op_semantics_91;
11304 break;
11306 break;
11307 case 0xb5:
11308 GETBYTE ();
11309 switch (op[2] & 0x00)
11311 case 0x00:
11312 goto op_semantics_91;
11313 break;
11315 break;
11316 case 0xb6:
11317 GETBYTE ();
11318 switch (op[2] & 0x00)
11320 case 0x00:
11321 goto op_semantics_91;
11322 break;
11324 break;
11325 case 0xb7:
11326 GETBYTE ();
11327 switch (op[2] & 0x00)
11329 case 0x00:
11330 goto op_semantics_91;
11331 break;
11333 break;
11334 case 0xb8:
11335 GETBYTE ();
11336 switch (op[2] & 0x00)
11338 case 0x00:
11339 goto op_semantics_91;
11340 break;
11342 break;
11343 case 0xb9:
11344 GETBYTE ();
11345 switch (op[2] & 0x00)
11347 case 0x00:
11348 goto op_semantics_91;
11349 break;
11351 break;
11352 case 0xba:
11353 GETBYTE ();
11354 switch (op[2] & 0x00)
11356 case 0x00:
11357 goto op_semantics_91;
11358 break;
11360 break;
11361 case 0xbb:
11362 GETBYTE ();
11363 switch (op[2] & 0x00)
11365 case 0x00:
11366 goto op_semantics_91;
11367 break;
11369 break;
11370 case 0xbc:
11371 GETBYTE ();
11372 switch (op[2] & 0x00)
11374 case 0x00:
11375 goto op_semantics_91;
11376 break;
11378 break;
11379 case 0xbd:
11380 GETBYTE ();
11381 switch (op[2] & 0x00)
11383 case 0x00:
11384 goto op_semantics_91;
11385 break;
11387 break;
11388 case 0xbe:
11389 GETBYTE ();
11390 switch (op[2] & 0x00)
11392 case 0x00:
11393 goto op_semantics_91;
11394 break;
11396 break;
11397 case 0xbf:
11398 GETBYTE ();
11399 switch (op[2] & 0x00)
11401 case 0x00:
11402 goto op_semantics_91;
11403 break;
11405 break;
11406 case 0xc0:
11407 GETBYTE ();
11408 switch (op[2] & 0x00)
11410 case 0x00:
11411 op_semantics_92:
11413 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
11414 #line 636 "rx-decode.opc"
11415 int immmm AU = op[1] & 0x1f;
11416 #line 636 "rx-decode.opc"
11417 int rsrc AU = (op[2] >> 4) & 0x0f;
11418 #line 636 "rx-decode.opc"
11419 int rdst AU = op[2] & 0x0f;
11420 if (trace)
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);
11429 SYNTAX("shll #%2, %1, %0");
11430 #line 636 "rx-decode.opc"
11431 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
11435 break;
11437 break;
11438 case 0xc1:
11439 GETBYTE ();
11440 switch (op[2] & 0x00)
11442 case 0x00:
11443 goto op_semantics_92;
11444 break;
11446 break;
11447 case 0xc2:
11448 GETBYTE ();
11449 switch (op[2] & 0x00)
11451 case 0x00:
11452 goto op_semantics_92;
11453 break;
11455 break;
11456 case 0xc3:
11457 GETBYTE ();
11458 switch (op[2] & 0x00)
11460 case 0x00:
11461 goto op_semantics_92;
11462 break;
11464 break;
11465 case 0xc4:
11466 GETBYTE ();
11467 switch (op[2] & 0x00)
11469 case 0x00:
11470 goto op_semantics_92;
11471 break;
11473 break;
11474 case 0xc5:
11475 GETBYTE ();
11476 switch (op[2] & 0x00)
11478 case 0x00:
11479 goto op_semantics_92;
11480 break;
11482 break;
11483 case 0xc6:
11484 GETBYTE ();
11485 switch (op[2] & 0x00)
11487 case 0x00:
11488 goto op_semantics_92;
11489 break;
11491 break;
11492 case 0xc7:
11493 GETBYTE ();
11494 switch (op[2] & 0x00)
11496 case 0x00:
11497 goto op_semantics_92;
11498 break;
11500 break;
11501 case 0xc8:
11502 GETBYTE ();
11503 switch (op[2] & 0x00)
11505 case 0x00:
11506 goto op_semantics_92;
11507 break;
11509 break;
11510 case 0xc9:
11511 GETBYTE ();
11512 switch (op[2] & 0x00)
11514 case 0x00:
11515 goto op_semantics_92;
11516 break;
11518 break;
11519 case 0xca:
11520 GETBYTE ();
11521 switch (op[2] & 0x00)
11523 case 0x00:
11524 goto op_semantics_92;
11525 break;
11527 break;
11528 case 0xcb:
11529 GETBYTE ();
11530 switch (op[2] & 0x00)
11532 case 0x00:
11533 goto op_semantics_92;
11534 break;
11536 break;
11537 case 0xcc:
11538 GETBYTE ();
11539 switch (op[2] & 0x00)
11541 case 0x00:
11542 goto op_semantics_92;
11543 break;
11545 break;
11546 case 0xcd:
11547 GETBYTE ();
11548 switch (op[2] & 0x00)
11550 case 0x00:
11551 goto op_semantics_92;
11552 break;
11554 break;
11555 case 0xce:
11556 GETBYTE ();
11557 switch (op[2] & 0x00)
11559 case 0x00:
11560 goto op_semantics_92;
11561 break;
11563 break;
11564 case 0xcf:
11565 GETBYTE ();
11566 switch (op[2] & 0x00)
11568 case 0x00:
11569 goto op_semantics_92;
11570 break;
11572 break;
11573 case 0xd0:
11574 GETBYTE ();
11575 switch (op[2] & 0x00)
11577 case 0x00:
11578 goto op_semantics_92;
11579 break;
11581 break;
11582 case 0xd1:
11583 GETBYTE ();
11584 switch (op[2] & 0x00)
11586 case 0x00:
11587 goto op_semantics_92;
11588 break;
11590 break;
11591 case 0xd2:
11592 GETBYTE ();
11593 switch (op[2] & 0x00)
11595 case 0x00:
11596 goto op_semantics_92;
11597 break;
11599 break;
11600 case 0xd3:
11601 GETBYTE ();
11602 switch (op[2] & 0x00)
11604 case 0x00:
11605 goto op_semantics_92;
11606 break;
11608 break;
11609 case 0xd4:
11610 GETBYTE ();
11611 switch (op[2] & 0x00)
11613 case 0x00:
11614 goto op_semantics_92;
11615 break;
11617 break;
11618 case 0xd5:
11619 GETBYTE ();
11620 switch (op[2] & 0x00)
11622 case 0x00:
11623 goto op_semantics_92;
11624 break;
11626 break;
11627 case 0xd6:
11628 GETBYTE ();
11629 switch (op[2] & 0x00)
11631 case 0x00:
11632 goto op_semantics_92;
11633 break;
11635 break;
11636 case 0xd7:
11637 GETBYTE ();
11638 switch (op[2] & 0x00)
11640 case 0x00:
11641 goto op_semantics_92;
11642 break;
11644 break;
11645 case 0xd8:
11646 GETBYTE ();
11647 switch (op[2] & 0x00)
11649 case 0x00:
11650 goto op_semantics_92;
11651 break;
11653 break;
11654 case 0xd9:
11655 GETBYTE ();
11656 switch (op[2] & 0x00)
11658 case 0x00:
11659 goto op_semantics_92;
11660 break;
11662 break;
11663 case 0xda:
11664 GETBYTE ();
11665 switch (op[2] & 0x00)
11667 case 0x00:
11668 goto op_semantics_92;
11669 break;
11671 break;
11672 case 0xdb:
11673 GETBYTE ();
11674 switch (op[2] & 0x00)
11676 case 0x00:
11677 goto op_semantics_92;
11678 break;
11680 break;
11681 case 0xdc:
11682 GETBYTE ();
11683 switch (op[2] & 0x00)
11685 case 0x00:
11686 goto op_semantics_92;
11687 break;
11689 break;
11690 case 0xdd:
11691 GETBYTE ();
11692 switch (op[2] & 0x00)
11694 case 0x00:
11695 goto op_semantics_92;
11696 break;
11698 break;
11699 case 0xde:
11700 GETBYTE ();
11701 switch (op[2] & 0x00)
11703 case 0x00:
11704 goto op_semantics_92;
11705 break;
11707 break;
11708 case 0xdf:
11709 GETBYTE ();
11710 switch (op[2] & 0x00)
11712 case 0x00:
11713 goto op_semantics_92;
11714 break;
11716 break;
11717 case 0xe0:
11718 GETBYTE ();
11719 switch (op[2] & 0xf0)
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:
11738 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
11739 #line 902 "rx-decode.opc"
11740 int bittt AU = op[1] & 0x1f;
11741 #line 902 "rx-decode.opc"
11742 int cond AU = (op[2] >> 4) & 0x0f;
11743 #line 902 "rx-decode.opc"
11744 int rdst AU = op[2] & 0x0f;
11745 if (trace)
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);
11754 SYNTAX("bm%2 #%1, %0%S0");
11755 #line 902 "rx-decode.opc"
11756 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11758 /*----------------------------------------------------------------------*/
11759 /* CONTROL REGISTERS */
11762 break;
11763 case 0xf0:
11764 op_semantics_94:
11766 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
11767 #line 895 "rx-decode.opc"
11768 int bittt AU = op[1] & 0x1f;
11769 #line 895 "rx-decode.opc"
11770 int rdst AU = op[2] & 0x0f;
11771 if (trace)
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);
11779 SYNTAX("bnot #%1, %0");
11780 #line 895 "rx-decode.opc"
11781 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11785 break;
11787 break;
11788 case 0xe1:
11789 GETBYTE ();
11790 switch (op[2] & 0xf0)
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;
11813 break;
11814 case 0xe2:
11815 GETBYTE ();
11816 switch (op[2] & 0xf0)
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;
11839 break;
11840 case 0xe3:
11841 GETBYTE ();
11842 switch (op[2] & 0xf0)
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;
11865 break;
11866 case 0xe4:
11867 GETBYTE ();
11868 switch (op[2] & 0xf0)
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;
11891 break;
11892 case 0xe5:
11893 GETBYTE ();
11894 switch (op[2] & 0xf0)
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;
11917 break;
11918 case 0xe6:
11919 GETBYTE ();
11920 switch (op[2] & 0xf0)
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;
11943 break;
11944 case 0xe7:
11945 GETBYTE ();
11946 switch (op[2] & 0xf0)
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;
11969 break;
11970 case 0xe8:
11971 GETBYTE ();
11972 switch (op[2] & 0xf0)
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;
11995 break;
11996 case 0xe9:
11997 GETBYTE ();
11998 switch (op[2] & 0xf0)
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;
12021 break;
12022 case 0xea:
12023 GETBYTE ();
12024 switch (op[2] & 0xf0)
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;
12047 break;
12048 case 0xeb:
12049 GETBYTE ();
12050 switch (op[2] & 0xf0)
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;
12073 break;
12074 case 0xec:
12075 GETBYTE ();
12076 switch (op[2] & 0xf0)
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;
12099 break;
12100 case 0xed:
12101 GETBYTE ();
12102 switch (op[2] & 0xf0)
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;
12125 break;
12126 case 0xee:
12127 GETBYTE ();
12128 switch (op[2] & 0xf0)
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;
12151 break;
12152 case 0xef:
12153 GETBYTE ();
12154 switch (op[2] & 0xf0)
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;
12177 break;
12178 case 0xf0:
12179 GETBYTE ();
12180 switch (op[2] & 0xf0)
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;
12203 break;
12204 case 0xf1:
12205 GETBYTE ();
12206 switch (op[2] & 0xf0)
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;
12229 break;
12230 case 0xf2:
12231 GETBYTE ();
12232 switch (op[2] & 0xf0)
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;
12255 break;
12256 case 0xf3:
12257 GETBYTE ();
12258 switch (op[2] & 0xf0)
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;
12281 break;
12282 case 0xf4:
12283 GETBYTE ();
12284 switch (op[2] & 0xf0)
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;
12307 break;
12308 case 0xf5:
12309 GETBYTE ();
12310 switch (op[2] & 0xf0)
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;
12333 break;
12334 case 0xf6:
12335 GETBYTE ();
12336 switch (op[2] & 0xf0)
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;
12359 break;
12360 case 0xf7:
12361 GETBYTE ();
12362 switch (op[2] & 0xf0)
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;
12385 break;
12386 case 0xf8:
12387 GETBYTE ();
12388 switch (op[2] & 0xf0)
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;
12411 break;
12412 case 0xf9:
12413 GETBYTE ();
12414 switch (op[2] & 0xf0)
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;
12437 break;
12438 case 0xfa:
12439 GETBYTE ();
12440 switch (op[2] & 0xf0)
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;
12463 break;
12464 case 0xfb:
12465 GETBYTE ();
12466 switch (op[2] & 0xf0)
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;
12489 break;
12490 case 0xfc:
12491 GETBYTE ();
12492 switch (op[2] & 0xf0)
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;
12515 break;
12516 case 0xfd:
12517 GETBYTE ();
12518 switch (op[2] & 0xf0)
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;
12541 break;
12542 case 0xfe:
12543 GETBYTE ();
12544 switch (op[2] & 0xf0)
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;
12567 break;
12568 case 0xff:
12569 GETBYTE ();
12570 switch (op[2] & 0xf0)
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;
12593 break;
12594 default: UNSUPPORTED(); break;
12596 break;
12597 case 0xfe:
12598 GETBYTE ();
12599 switch (op[1] & 0xff)
12601 case 0x00:
12602 GETBYTE ();
12603 switch (op[2] & 0x00)
12605 case 0x00:
12606 op_semantics_95:
12608 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
12609 #line 301 "rx-decode.opc"
12610 int sz AU = (op[1] >> 4) & 0x03;
12611 #line 301 "rx-decode.opc"
12612 int isrc AU = op[1] & 0x0f;
12613 #line 301 "rx-decode.opc"
12614 int bsrc AU = (op[2] >> 4) & 0x0f;
12615 #line 301 "rx-decode.opc"
12616 int rdst AU = op[2] & 0x0f;
12617 if (trace)
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);
12627 SYNTAX("mov%s %0, [%1, %2]");
12628 #line 301 "rx-decode.opc"
12629 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
12632 break;
12634 break;
12635 case 0x01:
12636 GETBYTE ();
12637 switch (op[2] & 0x00)
12639 case 0x00:
12640 goto op_semantics_95;
12641 break;
12643 break;
12644 case 0x02:
12645 GETBYTE ();
12646 switch (op[2] & 0x00)
12648 case 0x00:
12649 goto op_semantics_95;
12650 break;
12652 break;
12653 case 0x03:
12654 GETBYTE ();
12655 switch (op[2] & 0x00)
12657 case 0x00:
12658 goto op_semantics_95;
12659 break;
12661 break;
12662 case 0x04:
12663 GETBYTE ();
12664 switch (op[2] & 0x00)
12666 case 0x00:
12667 goto op_semantics_95;
12668 break;
12670 break;
12671 case 0x05:
12672 GETBYTE ();
12673 switch (op[2] & 0x00)
12675 case 0x00:
12676 goto op_semantics_95;
12677 break;
12679 break;
12680 case 0x06:
12681 GETBYTE ();
12682 switch (op[2] & 0x00)
12684 case 0x00:
12685 goto op_semantics_95;
12686 break;
12688 break;
12689 case 0x07:
12690 GETBYTE ();
12691 switch (op[2] & 0x00)
12693 case 0x00:
12694 goto op_semantics_95;
12695 break;
12697 break;
12698 case 0x08:
12699 GETBYTE ();
12700 switch (op[2] & 0x00)
12702 case 0x00:
12703 goto op_semantics_95;
12704 break;
12706 break;
12707 case 0x09:
12708 GETBYTE ();
12709 switch (op[2] & 0x00)
12711 case 0x00:
12712 goto op_semantics_95;
12713 break;
12715 break;
12716 case 0x0a:
12717 GETBYTE ();
12718 switch (op[2] & 0x00)
12720 case 0x00:
12721 goto op_semantics_95;
12722 break;
12724 break;
12725 case 0x0b:
12726 GETBYTE ();
12727 switch (op[2] & 0x00)
12729 case 0x00:
12730 goto op_semantics_95;
12731 break;
12733 break;
12734 case 0x0c:
12735 GETBYTE ();
12736 switch (op[2] & 0x00)
12738 case 0x00:
12739 goto op_semantics_95;
12740 break;
12742 break;
12743 case 0x0d:
12744 GETBYTE ();
12745 switch (op[2] & 0x00)
12747 case 0x00:
12748 goto op_semantics_95;
12749 break;
12751 break;
12752 case 0x0e:
12753 GETBYTE ();
12754 switch (op[2] & 0x00)
12756 case 0x00:
12757 goto op_semantics_95;
12758 break;
12760 break;
12761 case 0x0f:
12762 GETBYTE ();
12763 switch (op[2] & 0x00)
12765 case 0x00:
12766 goto op_semantics_95;
12767 break;
12769 break;
12770 case 0x10:
12771 GETBYTE ();
12772 switch (op[2] & 0x00)
12774 case 0x00:
12775 goto op_semantics_95;
12776 break;
12778 break;
12779 case 0x11:
12780 GETBYTE ();
12781 switch (op[2] & 0x00)
12783 case 0x00:
12784 goto op_semantics_95;
12785 break;
12787 break;
12788 case 0x12:
12789 GETBYTE ();
12790 switch (op[2] & 0x00)
12792 case 0x00:
12793 goto op_semantics_95;
12794 break;
12796 break;
12797 case 0x13:
12798 GETBYTE ();
12799 switch (op[2] & 0x00)
12801 case 0x00:
12802 goto op_semantics_95;
12803 break;
12805 break;
12806 case 0x14:
12807 GETBYTE ();
12808 switch (op[2] & 0x00)
12810 case 0x00:
12811 goto op_semantics_95;
12812 break;
12814 break;
12815 case 0x15:
12816 GETBYTE ();
12817 switch (op[2] & 0x00)
12819 case 0x00:
12820 goto op_semantics_95;
12821 break;
12823 break;
12824 case 0x16:
12825 GETBYTE ();
12826 switch (op[2] & 0x00)
12828 case 0x00:
12829 goto op_semantics_95;
12830 break;
12832 break;
12833 case 0x17:
12834 GETBYTE ();
12835 switch (op[2] & 0x00)
12837 case 0x00:
12838 goto op_semantics_95;
12839 break;
12841 break;
12842 case 0x18:
12843 GETBYTE ();
12844 switch (op[2] & 0x00)
12846 case 0x00:
12847 goto op_semantics_95;
12848 break;
12850 break;
12851 case 0x19:
12852 GETBYTE ();
12853 switch (op[2] & 0x00)
12855 case 0x00:
12856 goto op_semantics_95;
12857 break;
12859 break;
12860 case 0x1a:
12861 GETBYTE ();
12862 switch (op[2] & 0x00)
12864 case 0x00:
12865 goto op_semantics_95;
12866 break;
12868 break;
12869 case 0x1b:
12870 GETBYTE ();
12871 switch (op[2] & 0x00)
12873 case 0x00:
12874 goto op_semantics_95;
12875 break;
12877 break;
12878 case 0x1c:
12879 GETBYTE ();
12880 switch (op[2] & 0x00)
12882 case 0x00:
12883 goto op_semantics_95;
12884 break;
12886 break;
12887 case 0x1d:
12888 GETBYTE ();
12889 switch (op[2] & 0x00)
12891 case 0x00:
12892 goto op_semantics_95;
12893 break;
12895 break;
12896 case 0x1e:
12897 GETBYTE ();
12898 switch (op[2] & 0x00)
12900 case 0x00:
12901 goto op_semantics_95;
12902 break;
12904 break;
12905 case 0x1f:
12906 GETBYTE ();
12907 switch (op[2] & 0x00)
12909 case 0x00:
12910 goto op_semantics_95;
12911 break;
12913 break;
12914 case 0x20:
12915 GETBYTE ();
12916 switch (op[2] & 0x00)
12918 case 0x00:
12919 goto op_semantics_95;
12920 break;
12922 break;
12923 case 0x21:
12924 GETBYTE ();
12925 switch (op[2] & 0x00)
12927 case 0x00:
12928 goto op_semantics_95;
12929 break;
12931 break;
12932 case 0x22:
12933 GETBYTE ();
12934 switch (op[2] & 0x00)
12936 case 0x00:
12937 goto op_semantics_95;
12938 break;
12940 break;
12941 case 0x23:
12942 GETBYTE ();
12943 switch (op[2] & 0x00)
12945 case 0x00:
12946 goto op_semantics_95;
12947 break;
12949 break;
12950 case 0x24:
12951 GETBYTE ();
12952 switch (op[2] & 0x00)
12954 case 0x00:
12955 goto op_semantics_95;
12956 break;
12958 break;
12959 case 0x25:
12960 GETBYTE ();
12961 switch (op[2] & 0x00)
12963 case 0x00:
12964 goto op_semantics_95;
12965 break;
12967 break;
12968 case 0x26:
12969 GETBYTE ();
12970 switch (op[2] & 0x00)
12972 case 0x00:
12973 goto op_semantics_95;
12974 break;
12976 break;
12977 case 0x27:
12978 GETBYTE ();
12979 switch (op[2] & 0x00)
12981 case 0x00:
12982 goto op_semantics_95;
12983 break;
12985 break;
12986 case 0x28:
12987 GETBYTE ();
12988 switch (op[2] & 0x00)
12990 case 0x00:
12991 goto op_semantics_95;
12992 break;
12994 break;
12995 case 0x29:
12996 GETBYTE ();
12997 switch (op[2] & 0x00)
12999 case 0x00:
13000 goto op_semantics_95;
13001 break;
13003 break;
13004 case 0x2a:
13005 GETBYTE ();
13006 switch (op[2] & 0x00)
13008 case 0x00:
13009 goto op_semantics_95;
13010 break;
13012 break;
13013 case 0x2b:
13014 GETBYTE ();
13015 switch (op[2] & 0x00)
13017 case 0x00:
13018 goto op_semantics_95;
13019 break;
13021 break;
13022 case 0x2c:
13023 GETBYTE ();
13024 switch (op[2] & 0x00)
13026 case 0x00:
13027 goto op_semantics_95;
13028 break;
13030 break;
13031 case 0x2d:
13032 GETBYTE ();
13033 switch (op[2] & 0x00)
13035 case 0x00:
13036 goto op_semantics_95;
13037 break;
13039 break;
13040 case 0x2e:
13041 GETBYTE ();
13042 switch (op[2] & 0x00)
13044 case 0x00:
13045 goto op_semantics_95;
13046 break;
13048 break;
13049 case 0x2f:
13050 GETBYTE ();
13051 switch (op[2] & 0x00)
13053 case 0x00:
13054 goto op_semantics_95;
13055 break;
13057 break;
13058 case 0x40:
13059 GETBYTE ();
13060 switch (op[2] & 0x00)
13062 case 0x00:
13063 op_semantics_96:
13065 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
13066 #line 298 "rx-decode.opc"
13067 int sz AU = (op[1] >> 4) & 0x03;
13068 #line 298 "rx-decode.opc"
13069 int isrc AU = op[1] & 0x0f;
13070 #line 298 "rx-decode.opc"
13071 int bsrc AU = (op[2] >> 4) & 0x0f;
13072 #line 298 "rx-decode.opc"
13073 int rdst AU = op[2] & 0x0f;
13074 if (trace)
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);
13084 SYNTAX("mov%s [%1, %2], %0");
13085 #line 298 "rx-decode.opc"
13086 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13089 break;
13091 break;
13092 case 0x41:
13093 GETBYTE ();
13094 switch (op[2] & 0x00)
13096 case 0x00:
13097 goto op_semantics_96;
13098 break;
13100 break;
13101 case 0x42:
13102 GETBYTE ();
13103 switch (op[2] & 0x00)
13105 case 0x00:
13106 goto op_semantics_96;
13107 break;
13109 break;
13110 case 0x43:
13111 GETBYTE ();
13112 switch (op[2] & 0x00)
13114 case 0x00:
13115 goto op_semantics_96;
13116 break;
13118 break;
13119 case 0x44:
13120 GETBYTE ();
13121 switch (op[2] & 0x00)
13123 case 0x00:
13124 goto op_semantics_96;
13125 break;
13127 break;
13128 case 0x45:
13129 GETBYTE ();
13130 switch (op[2] & 0x00)
13132 case 0x00:
13133 goto op_semantics_96;
13134 break;
13136 break;
13137 case 0x46:
13138 GETBYTE ();
13139 switch (op[2] & 0x00)
13141 case 0x00:
13142 goto op_semantics_96;
13143 break;
13145 break;
13146 case 0x47:
13147 GETBYTE ();
13148 switch (op[2] & 0x00)
13150 case 0x00:
13151 goto op_semantics_96;
13152 break;
13154 break;
13155 case 0x48:
13156 GETBYTE ();
13157 switch (op[2] & 0x00)
13159 case 0x00:
13160 goto op_semantics_96;
13161 break;
13163 break;
13164 case 0x49:
13165 GETBYTE ();
13166 switch (op[2] & 0x00)
13168 case 0x00:
13169 goto op_semantics_96;
13170 break;
13172 break;
13173 case 0x4a:
13174 GETBYTE ();
13175 switch (op[2] & 0x00)
13177 case 0x00:
13178 goto op_semantics_96;
13179 break;
13181 break;
13182 case 0x4b:
13183 GETBYTE ();
13184 switch (op[2] & 0x00)
13186 case 0x00:
13187 goto op_semantics_96;
13188 break;
13190 break;
13191 case 0x4c:
13192 GETBYTE ();
13193 switch (op[2] & 0x00)
13195 case 0x00:
13196 goto op_semantics_96;
13197 break;
13199 break;
13200 case 0x4d:
13201 GETBYTE ();
13202 switch (op[2] & 0x00)
13204 case 0x00:
13205 goto op_semantics_96;
13206 break;
13208 break;
13209 case 0x4e:
13210 GETBYTE ();
13211 switch (op[2] & 0x00)
13213 case 0x00:
13214 goto op_semantics_96;
13215 break;
13217 break;
13218 case 0x4f:
13219 GETBYTE ();
13220 switch (op[2] & 0x00)
13222 case 0x00:
13223 goto op_semantics_96;
13224 break;
13226 break;
13227 case 0x50:
13228 GETBYTE ();
13229 switch (op[2] & 0x00)
13231 case 0x00:
13232 goto op_semantics_96;
13233 break;
13235 break;
13236 case 0x51:
13237 GETBYTE ();
13238 switch (op[2] & 0x00)
13240 case 0x00:
13241 goto op_semantics_96;
13242 break;
13244 break;
13245 case 0x52:
13246 GETBYTE ();
13247 switch (op[2] & 0x00)
13249 case 0x00:
13250 goto op_semantics_96;
13251 break;
13253 break;
13254 case 0x53:
13255 GETBYTE ();
13256 switch (op[2] & 0x00)
13258 case 0x00:
13259 goto op_semantics_96;
13260 break;
13262 break;
13263 case 0x54:
13264 GETBYTE ();
13265 switch (op[2] & 0x00)
13267 case 0x00:
13268 goto op_semantics_96;
13269 break;
13271 break;
13272 case 0x55:
13273 GETBYTE ();
13274 switch (op[2] & 0x00)
13276 case 0x00:
13277 goto op_semantics_96;
13278 break;
13280 break;
13281 case 0x56:
13282 GETBYTE ();
13283 switch (op[2] & 0x00)
13285 case 0x00:
13286 goto op_semantics_96;
13287 break;
13289 break;
13290 case 0x57:
13291 GETBYTE ();
13292 switch (op[2] & 0x00)
13294 case 0x00:
13295 goto op_semantics_96;
13296 break;
13298 break;
13299 case 0x58:
13300 GETBYTE ();
13301 switch (op[2] & 0x00)
13303 case 0x00:
13304 goto op_semantics_96;
13305 break;
13307 break;
13308 case 0x59:
13309 GETBYTE ();
13310 switch (op[2] & 0x00)
13312 case 0x00:
13313 goto op_semantics_96;
13314 break;
13316 break;
13317 case 0x5a:
13318 GETBYTE ();
13319 switch (op[2] & 0x00)
13321 case 0x00:
13322 goto op_semantics_96;
13323 break;
13325 break;
13326 case 0x5b:
13327 GETBYTE ();
13328 switch (op[2] & 0x00)
13330 case 0x00:
13331 goto op_semantics_96;
13332 break;
13334 break;
13335 case 0x5c:
13336 GETBYTE ();
13337 switch (op[2] & 0x00)
13339 case 0x00:
13340 goto op_semantics_96;
13341 break;
13343 break;
13344 case 0x5d:
13345 GETBYTE ();
13346 switch (op[2] & 0x00)
13348 case 0x00:
13349 goto op_semantics_96;
13350 break;
13352 break;
13353 case 0x5e:
13354 GETBYTE ();
13355 switch (op[2] & 0x00)
13357 case 0x00:
13358 goto op_semantics_96;
13359 break;
13361 break;
13362 case 0x5f:
13363 GETBYTE ();
13364 switch (op[2] & 0x00)
13366 case 0x00:
13367 goto op_semantics_96;
13368 break;
13370 break;
13371 case 0x60:
13372 GETBYTE ();
13373 switch (op[2] & 0x00)
13375 case 0x00:
13376 goto op_semantics_96;
13377 break;
13379 break;
13380 case 0x61:
13381 GETBYTE ();
13382 switch (op[2] & 0x00)
13384 case 0x00:
13385 goto op_semantics_96;
13386 break;
13388 break;
13389 case 0x62:
13390 GETBYTE ();
13391 switch (op[2] & 0x00)
13393 case 0x00:
13394 goto op_semantics_96;
13395 break;
13397 break;
13398 case 0x63:
13399 GETBYTE ();
13400 switch (op[2] & 0x00)
13402 case 0x00:
13403 goto op_semantics_96;
13404 break;
13406 break;
13407 case 0x64:
13408 GETBYTE ();
13409 switch (op[2] & 0x00)
13411 case 0x00:
13412 goto op_semantics_96;
13413 break;
13415 break;
13416 case 0x65:
13417 GETBYTE ();
13418 switch (op[2] & 0x00)
13420 case 0x00:
13421 goto op_semantics_96;
13422 break;
13424 break;
13425 case 0x66:
13426 GETBYTE ();
13427 switch (op[2] & 0x00)
13429 case 0x00:
13430 goto op_semantics_96;
13431 break;
13433 break;
13434 case 0x67:
13435 GETBYTE ();
13436 switch (op[2] & 0x00)
13438 case 0x00:
13439 goto op_semantics_96;
13440 break;
13442 break;
13443 case 0x68:
13444 GETBYTE ();
13445 switch (op[2] & 0x00)
13447 case 0x00:
13448 goto op_semantics_96;
13449 break;
13451 break;
13452 case 0x69:
13453 GETBYTE ();
13454 switch (op[2] & 0x00)
13456 case 0x00:
13457 goto op_semantics_96;
13458 break;
13460 break;
13461 case 0x6a:
13462 GETBYTE ();
13463 switch (op[2] & 0x00)
13465 case 0x00:
13466 goto op_semantics_96;
13467 break;
13469 break;
13470 case 0x6b:
13471 GETBYTE ();
13472 switch (op[2] & 0x00)
13474 case 0x00:
13475 goto op_semantics_96;
13476 break;
13478 break;
13479 case 0x6c:
13480 GETBYTE ();
13481 switch (op[2] & 0x00)
13483 case 0x00:
13484 goto op_semantics_96;
13485 break;
13487 break;
13488 case 0x6d:
13489 GETBYTE ();
13490 switch (op[2] & 0x00)
13492 case 0x00:
13493 goto op_semantics_96;
13494 break;
13496 break;
13497 case 0x6e:
13498 GETBYTE ();
13499 switch (op[2] & 0x00)
13501 case 0x00:
13502 goto op_semantics_96;
13503 break;
13505 break;
13506 case 0x6f:
13507 GETBYTE ();
13508 switch (op[2] & 0x00)
13510 case 0x00:
13511 goto op_semantics_96;
13512 break;
13514 break;
13515 case 0xc0:
13516 GETBYTE ();
13517 switch (op[2] & 0x00)
13519 case 0x00:
13520 op_semantics_97:
13522 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
13523 #line 304 "rx-decode.opc"
13524 int sz AU = (op[1] >> 4) & 0x03;
13525 #line 304 "rx-decode.opc"
13526 int isrc AU = op[1] & 0x0f;
13527 #line 304 "rx-decode.opc"
13528 int bsrc AU = (op[2] >> 4) & 0x0f;
13529 #line 304 "rx-decode.opc"
13530 int rdst AU = op[2] & 0x0f;
13531 if (trace)
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);
13541 SYNTAX("movu%s [%1, %2], %0");
13542 #line 304 "rx-decode.opc"
13543 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13546 break;
13548 break;
13549 case 0xc1:
13550 GETBYTE ();
13551 switch (op[2] & 0x00)
13553 case 0x00:
13554 goto op_semantics_97;
13555 break;
13557 break;
13558 case 0xc2:
13559 GETBYTE ();
13560 switch (op[2] & 0x00)
13562 case 0x00:
13563 goto op_semantics_97;
13564 break;
13566 break;
13567 case 0xc3:
13568 GETBYTE ();
13569 switch (op[2] & 0x00)
13571 case 0x00:
13572 goto op_semantics_97;
13573 break;
13575 break;
13576 case 0xc4:
13577 GETBYTE ();
13578 switch (op[2] & 0x00)
13580 case 0x00:
13581 goto op_semantics_97;
13582 break;
13584 break;
13585 case 0xc5:
13586 GETBYTE ();
13587 switch (op[2] & 0x00)
13589 case 0x00:
13590 goto op_semantics_97;
13591 break;
13593 break;
13594 case 0xc6:
13595 GETBYTE ();
13596 switch (op[2] & 0x00)
13598 case 0x00:
13599 goto op_semantics_97;
13600 break;
13602 break;
13603 case 0xc7:
13604 GETBYTE ();
13605 switch (op[2] & 0x00)
13607 case 0x00:
13608 goto op_semantics_97;
13609 break;
13611 break;
13612 case 0xc8:
13613 GETBYTE ();
13614 switch (op[2] & 0x00)
13616 case 0x00:
13617 goto op_semantics_97;
13618 break;
13620 break;
13621 case 0xc9:
13622 GETBYTE ();
13623 switch (op[2] & 0x00)
13625 case 0x00:
13626 goto op_semantics_97;
13627 break;
13629 break;
13630 case 0xca:
13631 GETBYTE ();
13632 switch (op[2] & 0x00)
13634 case 0x00:
13635 goto op_semantics_97;
13636 break;
13638 break;
13639 case 0xcb:
13640 GETBYTE ();
13641 switch (op[2] & 0x00)
13643 case 0x00:
13644 goto op_semantics_97;
13645 break;
13647 break;
13648 case 0xcc:
13649 GETBYTE ();
13650 switch (op[2] & 0x00)
13652 case 0x00:
13653 goto op_semantics_97;
13654 break;
13656 break;
13657 case 0xcd:
13658 GETBYTE ();
13659 switch (op[2] & 0x00)
13661 case 0x00:
13662 goto op_semantics_97;
13663 break;
13665 break;
13666 case 0xce:
13667 GETBYTE ();
13668 switch (op[2] & 0x00)
13670 case 0x00:
13671 goto op_semantics_97;
13672 break;
13674 break;
13675 case 0xcf:
13676 GETBYTE ();
13677 switch (op[2] & 0x00)
13679 case 0x00:
13680 goto op_semantics_97;
13681 break;
13683 break;
13684 case 0xd0:
13685 GETBYTE ();
13686 switch (op[2] & 0x00)
13688 case 0x00:
13689 goto op_semantics_97;
13690 break;
13692 break;
13693 case 0xd1:
13694 GETBYTE ();
13695 switch (op[2] & 0x00)
13697 case 0x00:
13698 goto op_semantics_97;
13699 break;
13701 break;
13702 case 0xd2:
13703 GETBYTE ();
13704 switch (op[2] & 0x00)
13706 case 0x00:
13707 goto op_semantics_97;
13708 break;
13710 break;
13711 case 0xd3:
13712 GETBYTE ();
13713 switch (op[2] & 0x00)
13715 case 0x00:
13716 goto op_semantics_97;
13717 break;
13719 break;
13720 case 0xd4:
13721 GETBYTE ();
13722 switch (op[2] & 0x00)
13724 case 0x00:
13725 goto op_semantics_97;
13726 break;
13728 break;
13729 case 0xd5:
13730 GETBYTE ();
13731 switch (op[2] & 0x00)
13733 case 0x00:
13734 goto op_semantics_97;
13735 break;
13737 break;
13738 case 0xd6:
13739 GETBYTE ();
13740 switch (op[2] & 0x00)
13742 case 0x00:
13743 goto op_semantics_97;
13744 break;
13746 break;
13747 case 0xd7:
13748 GETBYTE ();
13749 switch (op[2] & 0x00)
13751 case 0x00:
13752 goto op_semantics_97;
13753 break;
13755 break;
13756 case 0xd8:
13757 GETBYTE ();
13758 switch (op[2] & 0x00)
13760 case 0x00:
13761 goto op_semantics_97;
13762 break;
13764 break;
13765 case 0xd9:
13766 GETBYTE ();
13767 switch (op[2] & 0x00)
13769 case 0x00:
13770 goto op_semantics_97;
13771 break;
13773 break;
13774 case 0xda:
13775 GETBYTE ();
13776 switch (op[2] & 0x00)
13778 case 0x00:
13779 goto op_semantics_97;
13780 break;
13782 break;
13783 case 0xdb:
13784 GETBYTE ();
13785 switch (op[2] & 0x00)
13787 case 0x00:
13788 goto op_semantics_97;
13789 break;
13791 break;
13792 case 0xdc:
13793 GETBYTE ();
13794 switch (op[2] & 0x00)
13796 case 0x00:
13797 goto op_semantics_97;
13798 break;
13800 break;
13801 case 0xdd:
13802 GETBYTE ();
13803 switch (op[2] & 0x00)
13805 case 0x00:
13806 goto op_semantics_97;
13807 break;
13809 break;
13810 case 0xde:
13811 GETBYTE ();
13812 switch (op[2] & 0x00)
13814 case 0x00:
13815 goto op_semantics_97;
13816 break;
13818 break;
13819 case 0xdf:
13820 GETBYTE ();
13821 switch (op[2] & 0x00)
13823 case 0x00:
13824 goto op_semantics_97;
13825 break;
13827 break;
13828 case 0xe0:
13829 GETBYTE ();
13830 switch (op[2] & 0x00)
13832 case 0x00:
13833 goto op_semantics_97;
13834 break;
13836 break;
13837 case 0xe1:
13838 GETBYTE ();
13839 switch (op[2] & 0x00)
13841 case 0x00:
13842 goto op_semantics_97;
13843 break;
13845 break;
13846 case 0xe2:
13847 GETBYTE ();
13848 switch (op[2] & 0x00)
13850 case 0x00:
13851 goto op_semantics_97;
13852 break;
13854 break;
13855 case 0xe3:
13856 GETBYTE ();
13857 switch (op[2] & 0x00)
13859 case 0x00:
13860 goto op_semantics_97;
13861 break;
13863 break;
13864 case 0xe4:
13865 GETBYTE ();
13866 switch (op[2] & 0x00)
13868 case 0x00:
13869 goto op_semantics_97;
13870 break;
13872 break;
13873 case 0xe5:
13874 GETBYTE ();
13875 switch (op[2] & 0x00)
13877 case 0x00:
13878 goto op_semantics_97;
13879 break;
13881 break;
13882 case 0xe6:
13883 GETBYTE ();
13884 switch (op[2] & 0x00)
13886 case 0x00:
13887 goto op_semantics_97;
13888 break;
13890 break;
13891 case 0xe7:
13892 GETBYTE ();
13893 switch (op[2] & 0x00)
13895 case 0x00:
13896 goto op_semantics_97;
13897 break;
13899 break;
13900 case 0xe8:
13901 GETBYTE ();
13902 switch (op[2] & 0x00)
13904 case 0x00:
13905 goto op_semantics_97;
13906 break;
13908 break;
13909 case 0xe9:
13910 GETBYTE ();
13911 switch (op[2] & 0x00)
13913 case 0x00:
13914 goto op_semantics_97;
13915 break;
13917 break;
13918 case 0xea:
13919 GETBYTE ();
13920 switch (op[2] & 0x00)
13922 case 0x00:
13923 goto op_semantics_97;
13924 break;
13926 break;
13927 case 0xeb:
13928 GETBYTE ();
13929 switch (op[2] & 0x00)
13931 case 0x00:
13932 goto op_semantics_97;
13933 break;
13935 break;
13936 case 0xec:
13937 GETBYTE ();
13938 switch (op[2] & 0x00)
13940 case 0x00:
13941 goto op_semantics_97;
13942 break;
13944 break;
13945 case 0xed:
13946 GETBYTE ();
13947 switch (op[2] & 0x00)
13949 case 0x00:
13950 goto op_semantics_97;
13951 break;
13953 break;
13954 case 0xee:
13955 GETBYTE ();
13956 switch (op[2] & 0x00)
13958 case 0x00:
13959 goto op_semantics_97;
13960 break;
13962 break;
13963 case 0xef:
13964 GETBYTE ();
13965 switch (op[2] & 0x00)
13967 case 0x00:
13968 goto op_semantics_97;
13969 break;
13971 break;
13972 default: UNSUPPORTED(); break;
13974 break;
13975 case 0xff:
13976 GETBYTE ();
13977 switch (op[1] & 0xff)
13979 case 0x00:
13980 GETBYTE ();
13981 switch (op[2] & 0x00)
13983 case 0x00:
13984 op_semantics_98:
13986 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
13987 #line 508 "rx-decode.opc"
13988 int rdst AU = op[1] & 0x0f;
13989 #line 508 "rx-decode.opc"
13990 int srca AU = (op[2] >> 4) & 0x0f;
13991 #line 508 "rx-decode.opc"
13992 int srcb AU = op[2] & 0x0f;
13993 if (trace)
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);
14002 SYNTAX("sub %2, %1, %0");
14003 #line 508 "rx-decode.opc"
14004 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14006 /*----------------------------------------------------------------------*/
14007 /* SBB */
14010 break;
14012 break;
14013 case 0x01:
14014 GETBYTE ();
14015 switch (op[2] & 0x00)
14017 case 0x00:
14018 goto op_semantics_98;
14019 break;
14021 break;
14022 case 0x02:
14023 GETBYTE ();
14024 switch (op[2] & 0x00)
14026 case 0x00:
14027 goto op_semantics_98;
14028 break;
14030 break;
14031 case 0x03:
14032 GETBYTE ();
14033 switch (op[2] & 0x00)
14035 case 0x00:
14036 goto op_semantics_98;
14037 break;
14039 break;
14040 case 0x04:
14041 GETBYTE ();
14042 switch (op[2] & 0x00)
14044 case 0x00:
14045 goto op_semantics_98;
14046 break;
14048 break;
14049 case 0x05:
14050 GETBYTE ();
14051 switch (op[2] & 0x00)
14053 case 0x00:
14054 goto op_semantics_98;
14055 break;
14057 break;
14058 case 0x06:
14059 GETBYTE ();
14060 switch (op[2] & 0x00)
14062 case 0x00:
14063 goto op_semantics_98;
14064 break;
14066 break;
14067 case 0x07:
14068 GETBYTE ();
14069 switch (op[2] & 0x00)
14071 case 0x00:
14072 goto op_semantics_98;
14073 break;
14075 break;
14076 case 0x08:
14077 GETBYTE ();
14078 switch (op[2] & 0x00)
14080 case 0x00:
14081 goto op_semantics_98;
14082 break;
14084 break;
14085 case 0x09:
14086 GETBYTE ();
14087 switch (op[2] & 0x00)
14089 case 0x00:
14090 goto op_semantics_98;
14091 break;
14093 break;
14094 case 0x0a:
14095 GETBYTE ();
14096 switch (op[2] & 0x00)
14098 case 0x00:
14099 goto op_semantics_98;
14100 break;
14102 break;
14103 case 0x0b:
14104 GETBYTE ();
14105 switch (op[2] & 0x00)
14107 case 0x00:
14108 goto op_semantics_98;
14109 break;
14111 break;
14112 case 0x0c:
14113 GETBYTE ();
14114 switch (op[2] & 0x00)
14116 case 0x00:
14117 goto op_semantics_98;
14118 break;
14120 break;
14121 case 0x0d:
14122 GETBYTE ();
14123 switch (op[2] & 0x00)
14125 case 0x00:
14126 goto op_semantics_98;
14127 break;
14129 break;
14130 case 0x0e:
14131 GETBYTE ();
14132 switch (op[2] & 0x00)
14134 case 0x00:
14135 goto op_semantics_98;
14136 break;
14138 break;
14139 case 0x0f:
14140 GETBYTE ();
14141 switch (op[2] & 0x00)
14143 case 0x00:
14144 goto op_semantics_98;
14145 break;
14147 break;
14148 case 0x20:
14149 GETBYTE ();
14150 switch (op[2] & 0x00)
14152 case 0x00:
14153 op_semantics_99:
14155 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
14156 #line 475 "rx-decode.opc"
14157 int rdst AU = op[1] & 0x0f;
14158 #line 475 "rx-decode.opc"
14159 int srca AU = (op[2] >> 4) & 0x0f;
14160 #line 475 "rx-decode.opc"
14161 int srcb AU = op[2] & 0x0f;
14162 if (trace)
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);
14171 SYNTAX("add %2, %1, %0");
14172 #line 475 "rx-decode.opc"
14173 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14175 /*----------------------------------------------------------------------*/
14176 /* CMP */
14179 break;
14181 break;
14182 case 0x21:
14183 GETBYTE ();
14184 switch (op[2] & 0x00)
14186 case 0x00:
14187 goto op_semantics_99;
14188 break;
14190 break;
14191 case 0x22:
14192 GETBYTE ();
14193 switch (op[2] & 0x00)
14195 case 0x00:
14196 goto op_semantics_99;
14197 break;
14199 break;
14200 case 0x23:
14201 GETBYTE ();
14202 switch (op[2] & 0x00)
14204 case 0x00:
14205 goto op_semantics_99;
14206 break;
14208 break;
14209 case 0x24:
14210 GETBYTE ();
14211 switch (op[2] & 0x00)
14213 case 0x00:
14214 goto op_semantics_99;
14215 break;
14217 break;
14218 case 0x25:
14219 GETBYTE ();
14220 switch (op[2] & 0x00)
14222 case 0x00:
14223 goto op_semantics_99;
14224 break;
14226 break;
14227 case 0x26:
14228 GETBYTE ();
14229 switch (op[2] & 0x00)
14231 case 0x00:
14232 goto op_semantics_99;
14233 break;
14235 break;
14236 case 0x27:
14237 GETBYTE ();
14238 switch (op[2] & 0x00)
14240 case 0x00:
14241 goto op_semantics_99;
14242 break;
14244 break;
14245 case 0x28:
14246 GETBYTE ();
14247 switch (op[2] & 0x00)
14249 case 0x00:
14250 goto op_semantics_99;
14251 break;
14253 break;
14254 case 0x29:
14255 GETBYTE ();
14256 switch (op[2] & 0x00)
14258 case 0x00:
14259 goto op_semantics_99;
14260 break;
14262 break;
14263 case 0x2a:
14264 GETBYTE ();
14265 switch (op[2] & 0x00)
14267 case 0x00:
14268 goto op_semantics_99;
14269 break;
14271 break;
14272 case 0x2b:
14273 GETBYTE ();
14274 switch (op[2] & 0x00)
14276 case 0x00:
14277 goto op_semantics_99;
14278 break;
14280 break;
14281 case 0x2c:
14282 GETBYTE ();
14283 switch (op[2] & 0x00)
14285 case 0x00:
14286 goto op_semantics_99;
14287 break;
14289 break;
14290 case 0x2d:
14291 GETBYTE ();
14292 switch (op[2] & 0x00)
14294 case 0x00:
14295 goto op_semantics_99;
14296 break;
14298 break;
14299 case 0x2e:
14300 GETBYTE ();
14301 switch (op[2] & 0x00)
14303 case 0x00:
14304 goto op_semantics_99;
14305 break;
14307 break;
14308 case 0x2f:
14309 GETBYTE ();
14310 switch (op[2] & 0x00)
14312 case 0x00:
14313 goto op_semantics_99;
14314 break;
14316 break;
14317 case 0x30:
14318 GETBYTE ();
14319 switch (op[2] & 0x00)
14321 case 0x00:
14322 op_semantics_100:
14324 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
14325 #line 576 "rx-decode.opc"
14326 int rdst AU = op[1] & 0x0f;
14327 #line 576 "rx-decode.opc"
14328 int srca AU = (op[2] >> 4) & 0x0f;
14329 #line 576 "rx-decode.opc"
14330 int srcb AU = op[2] & 0x0f;
14331 if (trace)
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);
14340 SYNTAX("mul %2, %1, %0");
14341 #line 576 "rx-decode.opc"
14342 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
14344 /*----------------------------------------------------------------------*/
14345 /* EMUL */
14348 break;
14350 break;
14351 case 0x31:
14352 GETBYTE ();
14353 switch (op[2] & 0x00)
14355 case 0x00:
14356 goto op_semantics_100;
14357 break;
14359 break;
14360 case 0x32:
14361 GETBYTE ();
14362 switch (op[2] & 0x00)
14364 case 0x00:
14365 goto op_semantics_100;
14366 break;
14368 break;
14369 case 0x33:
14370 GETBYTE ();
14371 switch (op[2] & 0x00)
14373 case 0x00:
14374 goto op_semantics_100;
14375 break;
14377 break;
14378 case 0x34:
14379 GETBYTE ();
14380 switch (op[2] & 0x00)
14382 case 0x00:
14383 goto op_semantics_100;
14384 break;
14386 break;
14387 case 0x35:
14388 GETBYTE ();
14389 switch (op[2] & 0x00)
14391 case 0x00:
14392 goto op_semantics_100;
14393 break;
14395 break;
14396 case 0x36:
14397 GETBYTE ();
14398 switch (op[2] & 0x00)
14400 case 0x00:
14401 goto op_semantics_100;
14402 break;
14404 break;
14405 case 0x37:
14406 GETBYTE ();
14407 switch (op[2] & 0x00)
14409 case 0x00:
14410 goto op_semantics_100;
14411 break;
14413 break;
14414 case 0x38:
14415 GETBYTE ();
14416 switch (op[2] & 0x00)
14418 case 0x00:
14419 goto op_semantics_100;
14420 break;
14422 break;
14423 case 0x39:
14424 GETBYTE ();
14425 switch (op[2] & 0x00)
14427 case 0x00:
14428 goto op_semantics_100;
14429 break;
14431 break;
14432 case 0x3a:
14433 GETBYTE ();
14434 switch (op[2] & 0x00)
14436 case 0x00:
14437 goto op_semantics_100;
14438 break;
14440 break;
14441 case 0x3b:
14442 GETBYTE ();
14443 switch (op[2] & 0x00)
14445 case 0x00:
14446 goto op_semantics_100;
14447 break;
14449 break;
14450 case 0x3c:
14451 GETBYTE ();
14452 switch (op[2] & 0x00)
14454 case 0x00:
14455 goto op_semantics_100;
14456 break;
14458 break;
14459 case 0x3d:
14460 GETBYTE ();
14461 switch (op[2] & 0x00)
14463 case 0x00:
14464 goto op_semantics_100;
14465 break;
14467 break;
14468 case 0x3e:
14469 GETBYTE ();
14470 switch (op[2] & 0x00)
14472 case 0x00:
14473 goto op_semantics_100;
14474 break;
14476 break;
14477 case 0x3f:
14478 GETBYTE ();
14479 switch (op[2] & 0x00)
14481 case 0x00:
14482 goto op_semantics_100;
14483 break;
14485 break;
14486 case 0x40:
14487 GETBYTE ();
14488 switch (op[2] & 0x00)
14490 case 0x00:
14491 op_semantics_101:
14493 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
14494 #line 385 "rx-decode.opc"
14495 int rdst AU = op[1] & 0x0f;
14496 #line 385 "rx-decode.opc"
14497 int srca AU = (op[2] >> 4) & 0x0f;
14498 #line 385 "rx-decode.opc"
14499 int srcb AU = op[2] & 0x0f;
14500 if (trace)
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);
14509 SYNTAX("and %2, %1, %0");
14510 #line 385 "rx-decode.opc"
14511 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14513 /*----------------------------------------------------------------------*/
14514 /* OR */
14517 break;
14519 break;
14520 case 0x41:
14521 GETBYTE ();
14522 switch (op[2] & 0x00)
14524 case 0x00:
14525 goto op_semantics_101;
14526 break;
14528 break;
14529 case 0x42:
14530 GETBYTE ();
14531 switch (op[2] & 0x00)
14533 case 0x00:
14534 goto op_semantics_101;
14535 break;
14537 break;
14538 case 0x43:
14539 GETBYTE ();
14540 switch (op[2] & 0x00)
14542 case 0x00:
14543 goto op_semantics_101;
14544 break;
14546 break;
14547 case 0x44:
14548 GETBYTE ();
14549 switch (op[2] & 0x00)
14551 case 0x00:
14552 goto op_semantics_101;
14553 break;
14555 break;
14556 case 0x45:
14557 GETBYTE ();
14558 switch (op[2] & 0x00)
14560 case 0x00:
14561 goto op_semantics_101;
14562 break;
14564 break;
14565 case 0x46:
14566 GETBYTE ();
14567 switch (op[2] & 0x00)
14569 case 0x00:
14570 goto op_semantics_101;
14571 break;
14573 break;
14574 case 0x47:
14575 GETBYTE ();
14576 switch (op[2] & 0x00)
14578 case 0x00:
14579 goto op_semantics_101;
14580 break;
14582 break;
14583 case 0x48:
14584 GETBYTE ();
14585 switch (op[2] & 0x00)
14587 case 0x00:
14588 goto op_semantics_101;
14589 break;
14591 break;
14592 case 0x49:
14593 GETBYTE ();
14594 switch (op[2] & 0x00)
14596 case 0x00:
14597 goto op_semantics_101;
14598 break;
14600 break;
14601 case 0x4a:
14602 GETBYTE ();
14603 switch (op[2] & 0x00)
14605 case 0x00:
14606 goto op_semantics_101;
14607 break;
14609 break;
14610 case 0x4b:
14611 GETBYTE ();
14612 switch (op[2] & 0x00)
14614 case 0x00:
14615 goto op_semantics_101;
14616 break;
14618 break;
14619 case 0x4c:
14620 GETBYTE ();
14621 switch (op[2] & 0x00)
14623 case 0x00:
14624 goto op_semantics_101;
14625 break;
14627 break;
14628 case 0x4d:
14629 GETBYTE ();
14630 switch (op[2] & 0x00)
14632 case 0x00:
14633 goto op_semantics_101;
14634 break;
14636 break;
14637 case 0x4e:
14638 GETBYTE ();
14639 switch (op[2] & 0x00)
14641 case 0x00:
14642 goto op_semantics_101;
14643 break;
14645 break;
14646 case 0x4f:
14647 GETBYTE ();
14648 switch (op[2] & 0x00)
14650 case 0x00:
14651 goto op_semantics_101;
14652 break;
14654 break;
14655 case 0x50:
14656 GETBYTE ();
14657 switch (op[2] & 0x00)
14659 case 0x00:
14660 op_semantics_102:
14662 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
14663 #line 403 "rx-decode.opc"
14664 int rdst AU = op[1] & 0x0f;
14665 #line 403 "rx-decode.opc"
14666 int srca AU = (op[2] >> 4) & 0x0f;
14667 #line 403 "rx-decode.opc"
14668 int srcb AU = op[2] & 0x0f;
14669 if (trace)
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);
14678 SYNTAX("or %2, %1, %0");
14679 #line 403 "rx-decode.opc"
14680 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14682 /*----------------------------------------------------------------------*/
14683 /* XOR */
14686 break;
14688 break;
14689 case 0x51:
14690 GETBYTE ();
14691 switch (op[2] & 0x00)
14693 case 0x00:
14694 goto op_semantics_102;
14695 break;
14697 break;
14698 case 0x52:
14699 GETBYTE ();
14700 switch (op[2] & 0x00)
14702 case 0x00:
14703 goto op_semantics_102;
14704 break;
14706 break;
14707 case 0x53:
14708 GETBYTE ();
14709 switch (op[2] & 0x00)
14711 case 0x00:
14712 goto op_semantics_102;
14713 break;
14715 break;
14716 case 0x54:
14717 GETBYTE ();
14718 switch (op[2] & 0x00)
14720 case 0x00:
14721 goto op_semantics_102;
14722 break;
14724 break;
14725 case 0x55:
14726 GETBYTE ();
14727 switch (op[2] & 0x00)
14729 case 0x00:
14730 goto op_semantics_102;
14731 break;
14733 break;
14734 case 0x56:
14735 GETBYTE ();
14736 switch (op[2] & 0x00)
14738 case 0x00:
14739 goto op_semantics_102;
14740 break;
14742 break;
14743 case 0x57:
14744 GETBYTE ();
14745 switch (op[2] & 0x00)
14747 case 0x00:
14748 goto op_semantics_102;
14749 break;
14751 break;
14752 case 0x58:
14753 GETBYTE ();
14754 switch (op[2] & 0x00)
14756 case 0x00:
14757 goto op_semantics_102;
14758 break;
14760 break;
14761 case 0x59:
14762 GETBYTE ();
14763 switch (op[2] & 0x00)
14765 case 0x00:
14766 goto op_semantics_102;
14767 break;
14769 break;
14770 case 0x5a:
14771 GETBYTE ();
14772 switch (op[2] & 0x00)
14774 case 0x00:
14775 goto op_semantics_102;
14776 break;
14778 break;
14779 case 0x5b:
14780 GETBYTE ();
14781 switch (op[2] & 0x00)
14783 case 0x00:
14784 goto op_semantics_102;
14785 break;
14787 break;
14788 case 0x5c:
14789 GETBYTE ();
14790 switch (op[2] & 0x00)
14792 case 0x00:
14793 goto op_semantics_102;
14794 break;
14796 break;
14797 case 0x5d:
14798 GETBYTE ();
14799 switch (op[2] & 0x00)
14801 case 0x00:
14802 goto op_semantics_102;
14803 break;
14805 break;
14806 case 0x5e:
14807 GETBYTE ();
14808 switch (op[2] & 0x00)
14810 case 0x00:
14811 goto op_semantics_102;
14812 break;
14814 break;
14815 case 0x5f:
14816 GETBYTE ();
14817 switch (op[2] & 0x00)
14819 case 0x00:
14820 goto op_semantics_102;
14821 break;
14823 break;
14824 default: UNSUPPORTED(); break;
14826 break;
14827 default: UNSUPPORTED(); break;
14829 #line 959 "rx-decode.opc"
14831 return rx->n_bytes;