* read.c (cons_worker): Detect and reject unexpected string argument.
[binutils/dougsmingw.git] / opcodes / rx-decode.c
blob7b25ea7dca53d78b45ab3a7b14c254b5159e205f
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 SI(r,a) OP (1, RX_Operand_Indirect, r, a)
94 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
95 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
96 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
97 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
98 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
100 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
101 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
102 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
103 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
104 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
105 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
106 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
107 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
109 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
110 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
111 #define uBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
112 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
114 #define F(f) store_flags(rx, f)
116 #define AU ATTRIBUTE_UNUSED
117 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
119 #define SYNTAX(x) rx->syntax = x
121 #define UNSUPPORTED() \
122 rx->syntax = "*unknown*"
124 #define IMM(sf) immediate (sf, 0, ld)
125 #define IMMex(sf) immediate (sf, 1, ld)
127 static int
128 immediate (int sfield, int ex, LocalData * ld)
130 unsigned long i = 0, j;
132 switch (sfield)
134 #define B ((unsigned long) GETBYTE())
135 case 0:
136 #if RX_OPCODE_BIG_ENDIAN
137 i = B;
138 if (ex && (i & 0x80))
139 i -= 0x100;
140 i <<= 24;
141 i |= B << 16;
142 i |= B << 8;
143 i |= B;
144 #else
145 i = B;
146 i |= B << 8;
147 i |= B << 16;
148 j = B;
149 if (ex && (j & 0x80))
150 j -= 0x100;
151 i |= j << 24;
152 #endif
153 break;
154 case 3:
155 #if RX_OPCODE_BIG_ENDIAN
156 i = B << 16;
157 i |= B << 8;
158 i |= B;
159 #else
160 i = B;
161 i |= B << 8;
162 i |= B << 16;
163 #endif
164 if (ex && (i & 0x800000))
165 i -= 0x1000000;
166 break;
167 case 2:
168 #if RX_OPCODE_BIG_ENDIAN
169 i |= B << 8;
170 i |= B;
171 #else
172 i |= B;
173 i |= B << 8;
174 #endif
175 if (ex && (i & 0x8000))
176 i -= 0x10000;
177 break;
178 case 1:
179 i |= B;
180 if (ex && (i & 0x80))
181 i -= 0x100;
182 break;
183 default:
184 abort();
186 return i;
189 static void
190 rx_disp (int n, int type, int reg, int size, LocalData * ld)
192 int disp;
194 ld->rx->op[n].reg = reg;
195 switch (type)
197 case 3:
198 ld->rx->op[n].type = RX_Operand_Register;
199 break;
200 case 0:
201 ld->rx->op[n].type = RX_Operand_Indirect;
202 ld->rx->op[n].addend = 0;
203 break;
204 case 1:
205 ld->rx->op[n].type = RX_Operand_Indirect;
206 disp = GETBYTE ();
207 ld->rx->op[n].addend = disp * PSCALE[size];
208 break;
209 case 2:
210 ld->rx->op[n].type = RX_Operand_Indirect;
211 disp = GETBYTE ();
212 #if RX_OPCODE_BIG_ENDIAN
213 disp = disp * 256 + GETBYTE ();
214 #else
215 disp = disp + GETBYTE () * 256;
216 #endif
217 ld->rx->op[n].addend = disp * PSCALE[size];
218 break;
219 default:
220 abort ();
224 /* The syntax is "OSZC" where each character is one of the following:
225 - = flag unchanged
226 0 = flag cleared
227 1 = flag set
228 ? = flag undefined
229 x = flag set (any letter will do, use it for hints :). */
231 static void
232 store_flags (RX_Opcode_Decoded * rx, char * str)
234 int i, mask;
235 rx->flags_0 = 0;
236 rx->flags_1 = 0;
237 rx->flags_s = 0;
239 for (i = 0; i < 4; i++)
241 mask = 8 >> i;
242 switch (str[i])
244 case 0:
245 abort ();
246 case '-':
247 break;
248 case '0':
249 rx->flags_0 |= mask;
250 break;
251 case '1':
252 rx->flags_1 |= mask;
253 break;
254 case '?':
255 break;
256 default:
257 rx->flags_0 |= mask;
258 rx->flags_s |= mask;
259 break;
265 rx_decode_opcode (unsigned long pc AU,
266 RX_Opcode_Decoded * rx,
267 int (* getbyte)(void *),
268 void * ptr)
270 LocalData lds, * ld = &lds;
271 unsigned char op[20] = {0};
273 lds.rx = rx;
274 lds.getbyte = getbyte;
275 lds.ptr = ptr;
276 lds.op = op;
278 memset (rx, 0, sizeof (*rx));
279 BWL(LSIZE);
282 /*----------------------------------------------------------------------*/
283 /* MOV */
285 GETBYTE ();
286 switch (op[0] & 0xff)
288 case 0x00:
290 /** 0000 0000 brk */
291 if (trace)
293 printf ("\033[33m%s\033[0m %02x\n",
294 "/** 0000 0000 brk */",
295 op[0]);
297 SYNTAX("brk");
298 #line 951 "rx-decode.opc"
299 ID(brk);
302 break;
303 case 0x01:
305 /** 0000 0001 dbt */
306 if (trace)
308 printf ("\033[33m%s\033[0m %02x\n",
309 "/** 0000 0001 dbt */",
310 op[0]);
312 SYNTAX("dbt");
313 #line 954 "rx-decode.opc"
314 ID(dbt);
317 break;
318 case 0x02:
320 /** 0000 0010 rts */
321 if (trace)
323 printf ("\033[33m%s\033[0m %02x\n",
324 "/** 0000 0010 rts */",
325 op[0]);
327 SYNTAX("rts");
328 #line 740 "rx-decode.opc"
329 ID(rts);
331 /*----------------------------------------------------------------------*/
332 /* NOP */
335 break;
336 case 0x03:
338 /** 0000 0011 nop */
339 if (trace)
341 printf ("\033[33m%s\033[0m %02x\n",
342 "/** 0000 0011 nop */",
343 op[0]);
345 SYNTAX("nop");
346 #line 746 "rx-decode.opc"
347 ID(nop);
349 /*----------------------------------------------------------------------*/
350 /* STRING FUNCTIONS */
353 break;
354 case 0x04:
356 /** 0000 0100 bra.a %a0 */
357 if (trace)
359 printf ("\033[33m%s\033[0m %02x\n",
360 "/** 0000 0100 bra.a %a0 */",
361 op[0]);
363 SYNTAX("bra.a %a0");
364 #line 718 "rx-decode.opc"
365 ID(branch); Scc(RXC_always); DC(pc + IMMex(3));
368 break;
369 case 0x05:
371 /** 0000 0101 bsr.a %a0 */
372 if (trace)
374 printf ("\033[33m%s\033[0m %02x\n",
375 "/** 0000 0101 bsr.a %a0 */",
376 op[0]);
378 SYNTAX("bsr.a %a0");
379 #line 734 "rx-decode.opc"
380 ID(jsr); DC(pc + IMMex(3));
383 break;
384 case 0x06:
385 GETBYTE ();
386 switch (op[1] & 0xff)
388 case 0x00:
389 GETBYTE ();
390 switch (op[2] & 0x00)
392 case 0x00:
393 op_semantics_1:
395 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
396 #line 522 "rx-decode.opc"
397 int mx AU = (op[1] >> 6) & 0x03;
398 #line 522 "rx-decode.opc"
399 int ss AU = op[1] & 0x03;
400 #line 522 "rx-decode.opc"
401 int rsrc AU = (op[2] >> 4) & 0x0f;
402 #line 522 "rx-decode.opc"
403 int rdst AU = op[2] & 0x0f;
404 if (trace)
406 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
407 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
408 op[0], op[1], op[2]);
409 printf (" mx = 0x%x,", mx);
410 printf (" ss = 0x%x,", ss);
411 printf (" rsrc = 0x%x,", rsrc);
412 printf (" rdst = 0x%x\n", rdst);
414 SYNTAX("sub %2%S2, %1");
415 #line 522 "rx-decode.opc"
416 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F("OSZC");
419 break;
421 break;
422 case 0x01:
423 GETBYTE ();
424 switch (op[2] & 0x00)
426 case 0x00:
427 goto op_semantics_1;
428 break;
430 break;
431 case 0x02:
432 GETBYTE ();
433 switch (op[2] & 0x00)
435 case 0x00:
436 goto op_semantics_1;
437 break;
439 break;
440 case 0x03:
441 GETBYTE ();
442 switch (op[2] & 0x00)
444 case 0x00:
445 goto op_semantics_1;
446 break;
448 break;
449 case 0x04:
450 GETBYTE ();
451 switch (op[2] & 0x00)
453 case 0x00:
454 op_semantics_2:
456 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
457 #line 510 "rx-decode.opc"
458 int mx AU = (op[1] >> 6) & 0x03;
459 #line 510 "rx-decode.opc"
460 int ss AU = op[1] & 0x03;
461 #line 510 "rx-decode.opc"
462 int rsrc AU = (op[2] >> 4) & 0x0f;
463 #line 510 "rx-decode.opc"
464 int rdst AU = op[2] & 0x0f;
465 if (trace)
467 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
468 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
469 op[0], op[1], op[2]);
470 printf (" mx = 0x%x,", mx);
471 printf (" ss = 0x%x,", ss);
472 printf (" rsrc = 0x%x,", rsrc);
473 printf (" rdst = 0x%x\n", rdst);
475 SYNTAX("cmp %2%S2, %1");
476 #line 510 "rx-decode.opc"
477 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F("OSZC");
479 /*----------------------------------------------------------------------*/
480 /* SUB */
483 break;
485 break;
486 case 0x05:
487 GETBYTE ();
488 switch (op[2] & 0x00)
490 case 0x00:
491 goto op_semantics_2;
492 break;
494 break;
495 case 0x06:
496 GETBYTE ();
497 switch (op[2] & 0x00)
499 case 0x00:
500 goto op_semantics_2;
501 break;
503 break;
504 case 0x07:
505 GETBYTE ();
506 switch (op[2] & 0x00)
508 case 0x00:
509 goto op_semantics_2;
510 break;
512 break;
513 case 0x08:
514 GETBYTE ();
515 switch (op[2] & 0x00)
517 case 0x00:
518 op_semantics_3:
520 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
521 #line 486 "rx-decode.opc"
522 int mx AU = (op[1] >> 6) & 0x03;
523 #line 486 "rx-decode.opc"
524 int ss AU = op[1] & 0x03;
525 #line 486 "rx-decode.opc"
526 int rsrc AU = (op[2] >> 4) & 0x0f;
527 #line 486 "rx-decode.opc"
528 int rdst AU = op[2] & 0x0f;
529 if (trace)
531 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
532 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
533 op[0], op[1], op[2]);
534 printf (" mx = 0x%x,", mx);
535 printf (" ss = 0x%x,", ss);
536 printf (" rsrc = 0x%x,", rsrc);
537 printf (" rdst = 0x%x\n", rdst);
539 SYNTAX("add %1%S1, %0");
540 #line 486 "rx-decode.opc"
541 ID(add); SPm(ss, rsrc, mx); DR(rdst); F("OSZC");
544 break;
546 break;
547 case 0x09:
548 GETBYTE ();
549 switch (op[2] & 0x00)
551 case 0x00:
552 goto op_semantics_3;
553 break;
555 break;
556 case 0x0a:
557 GETBYTE ();
558 switch (op[2] & 0x00)
560 case 0x00:
561 goto op_semantics_3;
562 break;
564 break;
565 case 0x0b:
566 GETBYTE ();
567 switch (op[2] & 0x00)
569 case 0x00:
570 goto op_semantics_3;
571 break;
573 break;
574 case 0x0c:
575 GETBYTE ();
576 switch (op[2] & 0x00)
578 case 0x00:
579 op_semantics_4:
581 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
582 #line 583 "rx-decode.opc"
583 int mx AU = (op[1] >> 6) & 0x03;
584 #line 583 "rx-decode.opc"
585 int ss AU = op[1] & 0x03;
586 #line 583 "rx-decode.opc"
587 int rsrc AU = (op[2] >> 4) & 0x0f;
588 #line 583 "rx-decode.opc"
589 int rdst AU = op[2] & 0x0f;
590 if (trace)
592 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
593 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
594 op[0], op[1], op[2]);
595 printf (" mx = 0x%x,", mx);
596 printf (" ss = 0x%x,", ss);
597 printf (" rsrc = 0x%x,", rsrc);
598 printf (" rdst = 0x%x\n", rdst);
600 SYNTAX("mul %1%S1, %0");
601 #line 583 "rx-decode.opc"
602 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F("----");
605 break;
607 break;
608 case 0x0d:
609 GETBYTE ();
610 switch (op[2] & 0x00)
612 case 0x00:
613 goto op_semantics_4;
614 break;
616 break;
617 case 0x0e:
618 GETBYTE ();
619 switch (op[2] & 0x00)
621 case 0x00:
622 goto op_semantics_4;
623 break;
625 break;
626 case 0x0f:
627 GETBYTE ();
628 switch (op[2] & 0x00)
630 case 0x00:
631 goto op_semantics_4;
632 break;
634 break;
635 case 0x10:
636 GETBYTE ();
637 switch (op[2] & 0x00)
639 case 0x00:
640 op_semantics_5:
642 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
643 #line 399 "rx-decode.opc"
644 int mx AU = (op[1] >> 6) & 0x03;
645 #line 399 "rx-decode.opc"
646 int ss AU = op[1] & 0x03;
647 #line 399 "rx-decode.opc"
648 int rsrc AU = (op[2] >> 4) & 0x0f;
649 #line 399 "rx-decode.opc"
650 int rdst AU = op[2] & 0x0f;
651 if (trace)
653 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
654 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
655 op[0], op[1], op[2]);
656 printf (" mx = 0x%x,", mx);
657 printf (" ss = 0x%x,", ss);
658 printf (" rsrc = 0x%x,", rsrc);
659 printf (" rdst = 0x%x\n", rdst);
661 SYNTAX("and %1%S1, %0");
662 #line 399 "rx-decode.opc"
663 ID(and); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
666 break;
668 break;
669 case 0x11:
670 GETBYTE ();
671 switch (op[2] & 0x00)
673 case 0x00:
674 goto op_semantics_5;
675 break;
677 break;
678 case 0x12:
679 GETBYTE ();
680 switch (op[2] & 0x00)
682 case 0x00:
683 goto op_semantics_5;
684 break;
686 break;
687 case 0x13:
688 GETBYTE ();
689 switch (op[2] & 0x00)
691 case 0x00:
692 goto op_semantics_5;
693 break;
695 break;
696 case 0x14:
697 GETBYTE ();
698 switch (op[2] & 0x00)
700 case 0x00:
701 op_semantics_6:
703 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
704 #line 417 "rx-decode.opc"
705 int mx AU = (op[1] >> 6) & 0x03;
706 #line 417 "rx-decode.opc"
707 int ss AU = op[1] & 0x03;
708 #line 417 "rx-decode.opc"
709 int rsrc AU = (op[2] >> 4) & 0x0f;
710 #line 417 "rx-decode.opc"
711 int rdst AU = op[2] & 0x0f;
712 if (trace)
714 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
715 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
716 op[0], op[1], op[2]);
717 printf (" mx = 0x%x,", mx);
718 printf (" ss = 0x%x,", ss);
719 printf (" rsrc = 0x%x,", rsrc);
720 printf (" rdst = 0x%x\n", rdst);
722 SYNTAX("or %1%S1, %0");
723 #line 417 "rx-decode.opc"
724 ID(or); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
727 break;
729 break;
730 case 0x15:
731 GETBYTE ();
732 switch (op[2] & 0x00)
734 case 0x00:
735 goto op_semantics_6;
736 break;
738 break;
739 case 0x16:
740 GETBYTE ();
741 switch (op[2] & 0x00)
743 case 0x00:
744 goto op_semantics_6;
745 break;
747 break;
748 case 0x17:
749 GETBYTE ();
750 switch (op[2] & 0x00)
752 case 0x00:
753 goto op_semantics_6;
754 break;
756 break;
757 case 0x20:
758 GETBYTE ();
759 switch (op[2] & 0xff)
761 case 0x00:
762 GETBYTE ();
763 switch (op[3] & 0x00)
765 case 0x00:
766 op_semantics_7:
768 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
769 #line 535 "rx-decode.opc"
770 int mx AU = (op[1] >> 6) & 0x03;
771 #line 535 "rx-decode.opc"
772 int sp AU = op[1] & 0x03;
773 #line 535 "rx-decode.opc"
774 int rsrc AU = (op[3] >> 4) & 0x0f;
775 #line 535 "rx-decode.opc"
776 int rdst AU = op[3] & 0x0f;
777 if (trace)
779 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
780 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
781 op[0], op[1], op[2], op[3]);
782 printf (" mx = 0x%x,", mx);
783 printf (" sp = 0x%x,", sp);
784 printf (" rsrc = 0x%x,", rsrc);
785 printf (" rdst = 0x%x\n", rdst);
787 SYNTAX("sbb %1%S1, %0");
788 #line 535 "rx-decode.opc"
789 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F("OSZC");
791 /*----------------------------------------------------------------------*/
792 /* ABS */
795 break;
797 break;
798 case 0x04:
799 GETBYTE ();
800 switch (op[3] & 0x00)
802 case 0x00:
803 op_semantics_8:
805 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
806 #line 556 "rx-decode.opc"
807 int mx AU = (op[1] >> 6) & 0x03;
808 #line 556 "rx-decode.opc"
809 int ss AU = op[1] & 0x03;
810 #line 556 "rx-decode.opc"
811 int rsrc AU = (op[3] >> 4) & 0x0f;
812 #line 556 "rx-decode.opc"
813 int rdst AU = op[3] & 0x0f;
814 if (trace)
816 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
817 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
818 op[0], op[1], op[2], op[3]);
819 printf (" mx = 0x%x,", mx);
820 printf (" ss = 0x%x,", ss);
821 printf (" rsrc = 0x%x,", rsrc);
822 printf (" rdst = 0x%x\n", rdst);
824 SYNTAX("max %1%S1, %0");
825 #line 556 "rx-decode.opc"
826 ID(max); SPm(ss, rsrc, mx); DR(rdst);
828 /*----------------------------------------------------------------------*/
829 /* MIN */
832 break;
834 break;
835 case 0x05:
836 GETBYTE ();
837 switch (op[3] & 0x00)
839 case 0x00:
840 op_semantics_9:
842 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
843 #line 568 "rx-decode.opc"
844 int mx AU = (op[1] >> 6) & 0x03;
845 #line 568 "rx-decode.opc"
846 int ss AU = op[1] & 0x03;
847 #line 568 "rx-decode.opc"
848 int rsrc AU = (op[3] >> 4) & 0x0f;
849 #line 568 "rx-decode.opc"
850 int rdst AU = op[3] & 0x0f;
851 if (trace)
853 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
854 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
855 op[0], op[1], op[2], op[3]);
856 printf (" mx = 0x%x,", mx);
857 printf (" ss = 0x%x,", ss);
858 printf (" rsrc = 0x%x,", rsrc);
859 printf (" rdst = 0x%x\n", rdst);
861 SYNTAX("min %1%S1, %0");
862 #line 568 "rx-decode.opc"
863 ID(min); SPm(ss, rsrc, mx); DR(rdst);
865 /*----------------------------------------------------------------------*/
866 /* MUL */
869 break;
871 break;
872 case 0x06:
873 GETBYTE ();
874 switch (op[3] & 0x00)
876 case 0x00:
877 op_semantics_10:
879 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
880 #line 598 "rx-decode.opc"
881 int mx AU = (op[1] >> 6) & 0x03;
882 #line 598 "rx-decode.opc"
883 int ss AU = op[1] & 0x03;
884 #line 598 "rx-decode.opc"
885 int rsrc AU = (op[3] >> 4) & 0x0f;
886 #line 598 "rx-decode.opc"
887 int rdst AU = op[3] & 0x0f;
888 if (trace)
890 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
891 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
892 op[0], op[1], op[2], op[3]);
893 printf (" mx = 0x%x,", mx);
894 printf (" ss = 0x%x,", ss);
895 printf (" rsrc = 0x%x,", rsrc);
896 printf (" rdst = 0x%x\n", rdst);
898 SYNTAX("emul %1%S1, %0");
899 #line 598 "rx-decode.opc"
900 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
902 /*----------------------------------------------------------------------*/
903 /* EMULU */
906 break;
908 break;
909 case 0x07:
910 GETBYTE ();
911 switch (op[3] & 0x00)
913 case 0x00:
914 op_semantics_11:
916 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
917 #line 610 "rx-decode.opc"
918 int mx AU = (op[1] >> 6) & 0x03;
919 #line 610 "rx-decode.opc"
920 int ss AU = op[1] & 0x03;
921 #line 610 "rx-decode.opc"
922 int rsrc AU = (op[3] >> 4) & 0x0f;
923 #line 610 "rx-decode.opc"
924 int rdst AU = op[3] & 0x0f;
925 if (trace)
927 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
928 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
929 op[0], op[1], op[2], op[3]);
930 printf (" mx = 0x%x,", mx);
931 printf (" ss = 0x%x,", ss);
932 printf (" rsrc = 0x%x,", rsrc);
933 printf (" rdst = 0x%x\n", rdst);
935 SYNTAX("emulu %1%S1, %0");
936 #line 610 "rx-decode.opc"
937 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
939 /*----------------------------------------------------------------------*/
940 /* DIV */
943 break;
945 break;
946 case 0x08:
947 GETBYTE ();
948 switch (op[3] & 0x00)
950 case 0x00:
951 op_semantics_12:
953 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
954 #line 622 "rx-decode.opc"
955 int mx AU = (op[1] >> 6) & 0x03;
956 #line 622 "rx-decode.opc"
957 int ss AU = op[1] & 0x03;
958 #line 622 "rx-decode.opc"
959 int rsrc AU = (op[3] >> 4) & 0x0f;
960 #line 622 "rx-decode.opc"
961 int rdst AU = op[3] & 0x0f;
962 if (trace)
964 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
965 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
966 op[0], op[1], op[2], op[3]);
967 printf (" mx = 0x%x,", mx);
968 printf (" ss = 0x%x,", ss);
969 printf (" rsrc = 0x%x,", rsrc);
970 printf (" rdst = 0x%x\n", rdst);
972 SYNTAX("div %1%S1, %0");
973 #line 622 "rx-decode.opc"
974 ID(div); SPm(ss, rsrc, mx); DR(rdst); F("O---");
976 /*----------------------------------------------------------------------*/
977 /* DIVU */
980 break;
982 break;
983 case 0x09:
984 GETBYTE ();
985 switch (op[3] & 0x00)
987 case 0x00:
988 op_semantics_13:
990 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
991 #line 634 "rx-decode.opc"
992 int mx AU = (op[1] >> 6) & 0x03;
993 #line 634 "rx-decode.opc"
994 int ss AU = op[1] & 0x03;
995 #line 634 "rx-decode.opc"
996 int rsrc AU = (op[3] >> 4) & 0x0f;
997 #line 634 "rx-decode.opc"
998 int rdst AU = op[3] & 0x0f;
999 if (trace)
1001 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1002 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1003 op[0], op[1], op[2], op[3]);
1004 printf (" mx = 0x%x,", mx);
1005 printf (" ss = 0x%x,", ss);
1006 printf (" rsrc = 0x%x,", rsrc);
1007 printf (" rdst = 0x%x\n", rdst);
1009 SYNTAX("divu %1%S1, %0");
1010 #line 634 "rx-decode.opc"
1011 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F("O---");
1013 /*----------------------------------------------------------------------*/
1014 /* SHIFT */
1017 break;
1019 break;
1020 case 0x0c:
1021 GETBYTE ();
1022 switch (op[3] & 0x00)
1024 case 0x00:
1025 op_semantics_14:
1027 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1028 #line 453 "rx-decode.opc"
1029 int mx AU = (op[1] >> 6) & 0x03;
1030 #line 453 "rx-decode.opc"
1031 int ss AU = op[1] & 0x03;
1032 #line 453 "rx-decode.opc"
1033 int rsrc AU = (op[3] >> 4) & 0x0f;
1034 #line 453 "rx-decode.opc"
1035 int rdst AU = op[3] & 0x0f;
1036 if (trace)
1038 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1039 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1040 op[0], op[1], op[2], op[3]);
1041 printf (" mx = 0x%x,", mx);
1042 printf (" ss = 0x%x,", ss);
1043 printf (" rsrc = 0x%x,", rsrc);
1044 printf (" rdst = 0x%x\n", rdst);
1046 SYNTAX("tst %1%S1, %2");
1047 #line 453 "rx-decode.opc"
1048 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F("-SZ-");
1050 /*----------------------------------------------------------------------*/
1051 /* NEG */
1054 break;
1056 break;
1057 case 0x0d:
1058 GETBYTE ();
1059 switch (op[3] & 0x00)
1061 case 0x00:
1062 op_semantics_15:
1064 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1065 #line 432 "rx-decode.opc"
1066 int mx AU = (op[1] >> 6) & 0x03;
1067 #line 432 "rx-decode.opc"
1068 int ss AU = op[1] & 0x03;
1069 #line 432 "rx-decode.opc"
1070 int rsrc AU = (op[3] >> 4) & 0x0f;
1071 #line 432 "rx-decode.opc"
1072 int rdst AU = op[3] & 0x0f;
1073 if (trace)
1075 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1076 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1077 op[0], op[1], op[2], op[3]);
1078 printf (" mx = 0x%x,", mx);
1079 printf (" ss = 0x%x,", ss);
1080 printf (" rsrc = 0x%x,", rsrc);
1081 printf (" rdst = 0x%x\n", rdst);
1083 SYNTAX("xor %1%S1, %0");
1084 #line 432 "rx-decode.opc"
1085 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
1087 /*----------------------------------------------------------------------*/
1088 /* NOT */
1091 break;
1093 break;
1094 case 0x10:
1095 GETBYTE ();
1096 switch (op[3] & 0x00)
1098 case 0x00:
1099 op_semantics_16:
1101 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1102 #line 366 "rx-decode.opc"
1103 int mx AU = (op[1] >> 6) & 0x03;
1104 #line 366 "rx-decode.opc"
1105 int ss AU = op[1] & 0x03;
1106 #line 366 "rx-decode.opc"
1107 int rsrc AU = (op[3] >> 4) & 0x0f;
1108 #line 366 "rx-decode.opc"
1109 int rdst AU = op[3] & 0x0f;
1110 if (trace)
1112 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1113 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1114 op[0], op[1], op[2], op[3]);
1115 printf (" mx = 0x%x,", mx);
1116 printf (" ss = 0x%x,", ss);
1117 printf (" rsrc = 0x%x,", rsrc);
1118 printf (" rdst = 0x%x\n", rdst);
1120 SYNTAX("xchg %1%S1, %0");
1121 #line 366 "rx-decode.opc"
1122 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1124 /*----------------------------------------------------------------------*/
1125 /* STZ/STNZ */
1128 break;
1130 break;
1131 case 0x11:
1132 GETBYTE ();
1133 switch (op[3] & 0x00)
1135 case 0x00:
1136 op_semantics_17:
1138 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1139 #line 863 "rx-decode.opc"
1140 int mx AU = (op[1] >> 6) & 0x03;
1141 #line 863 "rx-decode.opc"
1142 int sd AU = op[1] & 0x03;
1143 #line 863 "rx-decode.opc"
1144 int rsrc AU = (op[3] >> 4) & 0x0f;
1145 #line 863 "rx-decode.opc"
1146 int rdst AU = op[3] & 0x0f;
1147 if (trace)
1149 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1150 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1151 op[0], op[1], op[2], op[3]);
1152 printf (" mx = 0x%x,", mx);
1153 printf (" sd = 0x%x,", sd);
1154 printf (" rsrc = 0x%x,", rsrc);
1155 printf (" rdst = 0x%x\n", rdst);
1157 SYNTAX("itof %1%S1, %0");
1158 #line 863 "rx-decode.opc"
1159 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F("-SZ-");
1161 /*----------------------------------------------------------------------*/
1162 /* BIT OPS */
1165 break;
1167 break;
1168 default: UNSUPPORTED(); break;
1170 break;
1171 case 0x21:
1172 GETBYTE ();
1173 switch (op[2] & 0xff)
1175 case 0x00:
1176 GETBYTE ();
1177 switch (op[3] & 0x00)
1179 case 0x00:
1180 goto op_semantics_7;
1181 break;
1183 break;
1184 case 0x04:
1185 GETBYTE ();
1186 switch (op[3] & 0x00)
1188 case 0x00:
1189 goto op_semantics_8;
1190 break;
1192 break;
1193 case 0x05:
1194 GETBYTE ();
1195 switch (op[3] & 0x00)
1197 case 0x00:
1198 goto op_semantics_9;
1199 break;
1201 break;
1202 case 0x06:
1203 GETBYTE ();
1204 switch (op[3] & 0x00)
1206 case 0x00:
1207 goto op_semantics_10;
1208 break;
1210 break;
1211 case 0x07:
1212 GETBYTE ();
1213 switch (op[3] & 0x00)
1215 case 0x00:
1216 goto op_semantics_11;
1217 break;
1219 break;
1220 case 0x08:
1221 GETBYTE ();
1222 switch (op[3] & 0x00)
1224 case 0x00:
1225 goto op_semantics_12;
1226 break;
1228 break;
1229 case 0x09:
1230 GETBYTE ();
1231 switch (op[3] & 0x00)
1233 case 0x00:
1234 goto op_semantics_13;
1235 break;
1237 break;
1238 case 0x0c:
1239 GETBYTE ();
1240 switch (op[3] & 0x00)
1242 case 0x00:
1243 goto op_semantics_14;
1244 break;
1246 break;
1247 case 0x0d:
1248 GETBYTE ();
1249 switch (op[3] & 0x00)
1251 case 0x00:
1252 goto op_semantics_15;
1253 break;
1255 break;
1256 case 0x10:
1257 GETBYTE ();
1258 switch (op[3] & 0x00)
1260 case 0x00:
1261 goto op_semantics_16;
1262 break;
1264 break;
1265 case 0x11:
1266 GETBYTE ();
1267 switch (op[3] & 0x00)
1269 case 0x00:
1270 goto op_semantics_17;
1271 break;
1273 break;
1274 default: UNSUPPORTED(); break;
1276 break;
1277 case 0x22:
1278 GETBYTE ();
1279 switch (op[2] & 0xff)
1281 case 0x00:
1282 GETBYTE ();
1283 switch (op[3] & 0x00)
1285 case 0x00:
1286 goto op_semantics_7;
1287 break;
1289 break;
1290 case 0x04:
1291 GETBYTE ();
1292 switch (op[3] & 0x00)
1294 case 0x00:
1295 goto op_semantics_8;
1296 break;
1298 break;
1299 case 0x05:
1300 GETBYTE ();
1301 switch (op[3] & 0x00)
1303 case 0x00:
1304 goto op_semantics_9;
1305 break;
1307 break;
1308 case 0x06:
1309 GETBYTE ();
1310 switch (op[3] & 0x00)
1312 case 0x00:
1313 goto op_semantics_10;
1314 break;
1316 break;
1317 case 0x07:
1318 GETBYTE ();
1319 switch (op[3] & 0x00)
1321 case 0x00:
1322 goto op_semantics_11;
1323 break;
1325 break;
1326 case 0x08:
1327 GETBYTE ();
1328 switch (op[3] & 0x00)
1330 case 0x00:
1331 goto op_semantics_12;
1332 break;
1334 break;
1335 case 0x09:
1336 GETBYTE ();
1337 switch (op[3] & 0x00)
1339 case 0x00:
1340 goto op_semantics_13;
1341 break;
1343 break;
1344 case 0x0c:
1345 GETBYTE ();
1346 switch (op[3] & 0x00)
1348 case 0x00:
1349 goto op_semantics_14;
1350 break;
1352 break;
1353 case 0x0d:
1354 GETBYTE ();
1355 switch (op[3] & 0x00)
1357 case 0x00:
1358 goto op_semantics_15;
1359 break;
1361 break;
1362 case 0x10:
1363 GETBYTE ();
1364 switch (op[3] & 0x00)
1366 case 0x00:
1367 goto op_semantics_16;
1368 break;
1370 break;
1371 case 0x11:
1372 GETBYTE ();
1373 switch (op[3] & 0x00)
1375 case 0x00:
1376 goto op_semantics_17;
1377 break;
1379 break;
1380 default: UNSUPPORTED(); break;
1382 break;
1383 case 0x23:
1384 GETBYTE ();
1385 switch (op[2] & 0xff)
1387 case 0x00:
1388 GETBYTE ();
1389 switch (op[3] & 0x00)
1391 case 0x00:
1392 goto op_semantics_7;
1393 break;
1395 break;
1396 case 0x04:
1397 GETBYTE ();
1398 switch (op[3] & 0x00)
1400 case 0x00:
1401 goto op_semantics_8;
1402 break;
1404 break;
1405 case 0x05:
1406 GETBYTE ();
1407 switch (op[3] & 0x00)
1409 case 0x00:
1410 goto op_semantics_9;
1411 break;
1413 break;
1414 case 0x06:
1415 GETBYTE ();
1416 switch (op[3] & 0x00)
1418 case 0x00:
1419 goto op_semantics_10;
1420 break;
1422 break;
1423 case 0x07:
1424 GETBYTE ();
1425 switch (op[3] & 0x00)
1427 case 0x00:
1428 goto op_semantics_11;
1429 break;
1431 break;
1432 case 0x08:
1433 GETBYTE ();
1434 switch (op[3] & 0x00)
1436 case 0x00:
1437 goto op_semantics_12;
1438 break;
1440 break;
1441 case 0x09:
1442 GETBYTE ();
1443 switch (op[3] & 0x00)
1445 case 0x00:
1446 goto op_semantics_13;
1447 break;
1449 break;
1450 case 0x0c:
1451 GETBYTE ();
1452 switch (op[3] & 0x00)
1454 case 0x00:
1455 goto op_semantics_14;
1456 break;
1458 break;
1459 case 0x0d:
1460 GETBYTE ();
1461 switch (op[3] & 0x00)
1463 case 0x00:
1464 goto op_semantics_15;
1465 break;
1467 break;
1468 case 0x10:
1469 GETBYTE ();
1470 switch (op[3] & 0x00)
1472 case 0x00:
1473 goto op_semantics_16;
1474 break;
1476 break;
1477 case 0x11:
1478 GETBYTE ();
1479 switch (op[3] & 0x00)
1481 case 0x00:
1482 goto op_semantics_17;
1483 break;
1485 break;
1486 default: UNSUPPORTED(); break;
1488 break;
1489 case 0x40:
1490 GETBYTE ();
1491 switch (op[2] & 0x00)
1493 case 0x00:
1494 goto op_semantics_1;
1495 break;
1497 break;
1498 case 0x41:
1499 GETBYTE ();
1500 switch (op[2] & 0x00)
1502 case 0x00:
1503 goto op_semantics_1;
1504 break;
1506 break;
1507 case 0x42:
1508 GETBYTE ();
1509 switch (op[2] & 0x00)
1511 case 0x00:
1512 goto op_semantics_1;
1513 break;
1515 break;
1516 case 0x43:
1517 GETBYTE ();
1518 switch (op[2] & 0x00)
1520 case 0x00:
1521 goto op_semantics_1;
1522 break;
1524 break;
1525 case 0x44:
1526 GETBYTE ();
1527 switch (op[2] & 0x00)
1529 case 0x00:
1530 goto op_semantics_2;
1531 break;
1533 break;
1534 case 0x45:
1535 GETBYTE ();
1536 switch (op[2] & 0x00)
1538 case 0x00:
1539 goto op_semantics_2;
1540 break;
1542 break;
1543 case 0x46:
1544 GETBYTE ();
1545 switch (op[2] & 0x00)
1547 case 0x00:
1548 goto op_semantics_2;
1549 break;
1551 break;
1552 case 0x47:
1553 GETBYTE ();
1554 switch (op[2] & 0x00)
1556 case 0x00:
1557 goto op_semantics_2;
1558 break;
1560 break;
1561 case 0x48:
1562 GETBYTE ();
1563 switch (op[2] & 0x00)
1565 case 0x00:
1566 goto op_semantics_3;
1567 break;
1569 break;
1570 case 0x49:
1571 GETBYTE ();
1572 switch (op[2] & 0x00)
1574 case 0x00:
1575 goto op_semantics_3;
1576 break;
1578 break;
1579 case 0x4a:
1580 GETBYTE ();
1581 switch (op[2] & 0x00)
1583 case 0x00:
1584 goto op_semantics_3;
1585 break;
1587 break;
1588 case 0x4b:
1589 GETBYTE ();
1590 switch (op[2] & 0x00)
1592 case 0x00:
1593 goto op_semantics_3;
1594 break;
1596 break;
1597 case 0x4c:
1598 GETBYTE ();
1599 switch (op[2] & 0x00)
1601 case 0x00:
1602 goto op_semantics_4;
1603 break;
1605 break;
1606 case 0x4d:
1607 GETBYTE ();
1608 switch (op[2] & 0x00)
1610 case 0x00:
1611 goto op_semantics_4;
1612 break;
1614 break;
1615 case 0x4e:
1616 GETBYTE ();
1617 switch (op[2] & 0x00)
1619 case 0x00:
1620 goto op_semantics_4;
1621 break;
1623 break;
1624 case 0x4f:
1625 GETBYTE ();
1626 switch (op[2] & 0x00)
1628 case 0x00:
1629 goto op_semantics_4;
1630 break;
1632 break;
1633 case 0x50:
1634 GETBYTE ();
1635 switch (op[2] & 0x00)
1637 case 0x00:
1638 goto op_semantics_5;
1639 break;
1641 break;
1642 case 0x51:
1643 GETBYTE ();
1644 switch (op[2] & 0x00)
1646 case 0x00:
1647 goto op_semantics_5;
1648 break;
1650 break;
1651 case 0x52:
1652 GETBYTE ();
1653 switch (op[2] & 0x00)
1655 case 0x00:
1656 goto op_semantics_5;
1657 break;
1659 break;
1660 case 0x53:
1661 GETBYTE ();
1662 switch (op[2] & 0x00)
1664 case 0x00:
1665 goto op_semantics_5;
1666 break;
1668 break;
1669 case 0x54:
1670 GETBYTE ();
1671 switch (op[2] & 0x00)
1673 case 0x00:
1674 goto op_semantics_6;
1675 break;
1677 break;
1678 case 0x55:
1679 GETBYTE ();
1680 switch (op[2] & 0x00)
1682 case 0x00:
1683 goto op_semantics_6;
1684 break;
1686 break;
1687 case 0x56:
1688 GETBYTE ();
1689 switch (op[2] & 0x00)
1691 case 0x00:
1692 goto op_semantics_6;
1693 break;
1695 break;
1696 case 0x57:
1697 GETBYTE ();
1698 switch (op[2] & 0x00)
1700 case 0x00:
1701 goto op_semantics_6;
1702 break;
1704 break;
1705 case 0x60:
1706 GETBYTE ();
1707 switch (op[2] & 0xff)
1709 case 0x00:
1710 GETBYTE ();
1711 switch (op[3] & 0x00)
1713 case 0x00:
1714 goto op_semantics_7;
1715 break;
1717 break;
1718 case 0x04:
1719 GETBYTE ();
1720 switch (op[3] & 0x00)
1722 case 0x00:
1723 goto op_semantics_8;
1724 break;
1726 break;
1727 case 0x05:
1728 GETBYTE ();
1729 switch (op[3] & 0x00)
1731 case 0x00:
1732 goto op_semantics_9;
1733 break;
1735 break;
1736 case 0x06:
1737 GETBYTE ();
1738 switch (op[3] & 0x00)
1740 case 0x00:
1741 goto op_semantics_10;
1742 break;
1744 break;
1745 case 0x07:
1746 GETBYTE ();
1747 switch (op[3] & 0x00)
1749 case 0x00:
1750 goto op_semantics_11;
1751 break;
1753 break;
1754 case 0x08:
1755 GETBYTE ();
1756 switch (op[3] & 0x00)
1758 case 0x00:
1759 goto op_semantics_12;
1760 break;
1762 break;
1763 case 0x09:
1764 GETBYTE ();
1765 switch (op[3] & 0x00)
1767 case 0x00:
1768 goto op_semantics_13;
1769 break;
1771 break;
1772 case 0x0c:
1773 GETBYTE ();
1774 switch (op[3] & 0x00)
1776 case 0x00:
1777 goto op_semantics_14;
1778 break;
1780 break;
1781 case 0x0d:
1782 GETBYTE ();
1783 switch (op[3] & 0x00)
1785 case 0x00:
1786 goto op_semantics_15;
1787 break;
1789 break;
1790 case 0x10:
1791 GETBYTE ();
1792 switch (op[3] & 0x00)
1794 case 0x00:
1795 goto op_semantics_16;
1796 break;
1798 break;
1799 case 0x11:
1800 GETBYTE ();
1801 switch (op[3] & 0x00)
1803 case 0x00:
1804 goto op_semantics_17;
1805 break;
1807 break;
1808 default: UNSUPPORTED(); break;
1810 break;
1811 case 0x61:
1812 GETBYTE ();
1813 switch (op[2] & 0xff)
1815 case 0x00:
1816 GETBYTE ();
1817 switch (op[3] & 0x00)
1819 case 0x00:
1820 goto op_semantics_7;
1821 break;
1823 break;
1824 case 0x04:
1825 GETBYTE ();
1826 switch (op[3] & 0x00)
1828 case 0x00:
1829 goto op_semantics_8;
1830 break;
1832 break;
1833 case 0x05:
1834 GETBYTE ();
1835 switch (op[3] & 0x00)
1837 case 0x00:
1838 goto op_semantics_9;
1839 break;
1841 break;
1842 case 0x06:
1843 GETBYTE ();
1844 switch (op[3] & 0x00)
1846 case 0x00:
1847 goto op_semantics_10;
1848 break;
1850 break;
1851 case 0x07:
1852 GETBYTE ();
1853 switch (op[3] & 0x00)
1855 case 0x00:
1856 goto op_semantics_11;
1857 break;
1859 break;
1860 case 0x08:
1861 GETBYTE ();
1862 switch (op[3] & 0x00)
1864 case 0x00:
1865 goto op_semantics_12;
1866 break;
1868 break;
1869 case 0x09:
1870 GETBYTE ();
1871 switch (op[3] & 0x00)
1873 case 0x00:
1874 goto op_semantics_13;
1875 break;
1877 break;
1878 case 0x0c:
1879 GETBYTE ();
1880 switch (op[3] & 0x00)
1882 case 0x00:
1883 goto op_semantics_14;
1884 break;
1886 break;
1887 case 0x0d:
1888 GETBYTE ();
1889 switch (op[3] & 0x00)
1891 case 0x00:
1892 goto op_semantics_15;
1893 break;
1895 break;
1896 case 0x10:
1897 GETBYTE ();
1898 switch (op[3] & 0x00)
1900 case 0x00:
1901 goto op_semantics_16;
1902 break;
1904 break;
1905 case 0x11:
1906 GETBYTE ();
1907 switch (op[3] & 0x00)
1909 case 0x00:
1910 goto op_semantics_17;
1911 break;
1913 break;
1914 default: UNSUPPORTED(); break;
1916 break;
1917 case 0x62:
1918 GETBYTE ();
1919 switch (op[2] & 0xff)
1921 case 0x00:
1922 GETBYTE ();
1923 switch (op[3] & 0x00)
1925 case 0x00:
1926 goto op_semantics_7;
1927 break;
1929 break;
1930 case 0x04:
1931 GETBYTE ();
1932 switch (op[3] & 0x00)
1934 case 0x00:
1935 goto op_semantics_8;
1936 break;
1938 break;
1939 case 0x05:
1940 GETBYTE ();
1941 switch (op[3] & 0x00)
1943 case 0x00:
1944 goto op_semantics_9;
1945 break;
1947 break;
1948 case 0x06:
1949 GETBYTE ();
1950 switch (op[3] & 0x00)
1952 case 0x00:
1953 goto op_semantics_10;
1954 break;
1956 break;
1957 case 0x07:
1958 GETBYTE ();
1959 switch (op[3] & 0x00)
1961 case 0x00:
1962 goto op_semantics_11;
1963 break;
1965 break;
1966 case 0x08:
1967 GETBYTE ();
1968 switch (op[3] & 0x00)
1970 case 0x00:
1971 goto op_semantics_12;
1972 break;
1974 break;
1975 case 0x09:
1976 GETBYTE ();
1977 switch (op[3] & 0x00)
1979 case 0x00:
1980 goto op_semantics_13;
1981 break;
1983 break;
1984 case 0x0c:
1985 GETBYTE ();
1986 switch (op[3] & 0x00)
1988 case 0x00:
1989 goto op_semantics_14;
1990 break;
1992 break;
1993 case 0x0d:
1994 GETBYTE ();
1995 switch (op[3] & 0x00)
1997 case 0x00:
1998 goto op_semantics_15;
1999 break;
2001 break;
2002 case 0x10:
2003 GETBYTE ();
2004 switch (op[3] & 0x00)
2006 case 0x00:
2007 goto op_semantics_16;
2008 break;
2010 break;
2011 case 0x11:
2012 GETBYTE ();
2013 switch (op[3] & 0x00)
2015 case 0x00:
2016 goto op_semantics_17;
2017 break;
2019 break;
2020 default: UNSUPPORTED(); break;
2022 break;
2023 case 0x63:
2024 GETBYTE ();
2025 switch (op[2] & 0xff)
2027 case 0x00:
2028 GETBYTE ();
2029 switch (op[3] & 0x00)
2031 case 0x00:
2032 goto op_semantics_7;
2033 break;
2035 break;
2036 case 0x04:
2037 GETBYTE ();
2038 switch (op[3] & 0x00)
2040 case 0x00:
2041 goto op_semantics_8;
2042 break;
2044 break;
2045 case 0x05:
2046 GETBYTE ();
2047 switch (op[3] & 0x00)
2049 case 0x00:
2050 goto op_semantics_9;
2051 break;
2053 break;
2054 case 0x06:
2055 GETBYTE ();
2056 switch (op[3] & 0x00)
2058 case 0x00:
2059 goto op_semantics_10;
2060 break;
2062 break;
2063 case 0x07:
2064 GETBYTE ();
2065 switch (op[3] & 0x00)
2067 case 0x00:
2068 goto op_semantics_11;
2069 break;
2071 break;
2072 case 0x08:
2073 GETBYTE ();
2074 switch (op[3] & 0x00)
2076 case 0x00:
2077 goto op_semantics_12;
2078 break;
2080 break;
2081 case 0x09:
2082 GETBYTE ();
2083 switch (op[3] & 0x00)
2085 case 0x00:
2086 goto op_semantics_13;
2087 break;
2089 break;
2090 case 0x0c:
2091 GETBYTE ();
2092 switch (op[3] & 0x00)
2094 case 0x00:
2095 goto op_semantics_14;
2096 break;
2098 break;
2099 case 0x0d:
2100 GETBYTE ();
2101 switch (op[3] & 0x00)
2103 case 0x00:
2104 goto op_semantics_15;
2105 break;
2107 break;
2108 case 0x10:
2109 GETBYTE ();
2110 switch (op[3] & 0x00)
2112 case 0x00:
2113 goto op_semantics_16;
2114 break;
2116 break;
2117 case 0x11:
2118 GETBYTE ();
2119 switch (op[3] & 0x00)
2121 case 0x00:
2122 goto op_semantics_17;
2123 break;
2125 break;
2126 default: UNSUPPORTED(); break;
2128 break;
2129 case 0x80:
2130 GETBYTE ();
2131 switch (op[2] & 0x00)
2133 case 0x00:
2134 goto op_semantics_1;
2135 break;
2137 break;
2138 case 0x81:
2139 GETBYTE ();
2140 switch (op[2] & 0x00)
2142 case 0x00:
2143 goto op_semantics_1;
2144 break;
2146 break;
2147 case 0x82:
2148 GETBYTE ();
2149 switch (op[2] & 0x00)
2151 case 0x00:
2152 goto op_semantics_1;
2153 break;
2155 break;
2156 case 0x83:
2157 GETBYTE ();
2158 switch (op[2] & 0x00)
2160 case 0x00:
2161 goto op_semantics_1;
2162 break;
2164 break;
2165 case 0x84:
2166 GETBYTE ();
2167 switch (op[2] & 0x00)
2169 case 0x00:
2170 goto op_semantics_2;
2171 break;
2173 break;
2174 case 0x85:
2175 GETBYTE ();
2176 switch (op[2] & 0x00)
2178 case 0x00:
2179 goto op_semantics_2;
2180 break;
2182 break;
2183 case 0x86:
2184 GETBYTE ();
2185 switch (op[2] & 0x00)
2187 case 0x00:
2188 goto op_semantics_2;
2189 break;
2191 break;
2192 case 0x87:
2193 GETBYTE ();
2194 switch (op[2] & 0x00)
2196 case 0x00:
2197 goto op_semantics_2;
2198 break;
2200 break;
2201 case 0x88:
2202 GETBYTE ();
2203 switch (op[2] & 0x00)
2205 case 0x00:
2206 goto op_semantics_3;
2207 break;
2209 break;
2210 case 0x89:
2211 GETBYTE ();
2212 switch (op[2] & 0x00)
2214 case 0x00:
2215 goto op_semantics_3;
2216 break;
2218 break;
2219 case 0x8a:
2220 GETBYTE ();
2221 switch (op[2] & 0x00)
2223 case 0x00:
2224 goto op_semantics_3;
2225 break;
2227 break;
2228 case 0x8b:
2229 GETBYTE ();
2230 switch (op[2] & 0x00)
2232 case 0x00:
2233 goto op_semantics_3;
2234 break;
2236 break;
2237 case 0x8c:
2238 GETBYTE ();
2239 switch (op[2] & 0x00)
2241 case 0x00:
2242 goto op_semantics_4;
2243 break;
2245 break;
2246 case 0x8d:
2247 GETBYTE ();
2248 switch (op[2] & 0x00)
2250 case 0x00:
2251 goto op_semantics_4;
2252 break;
2254 break;
2255 case 0x8e:
2256 GETBYTE ();
2257 switch (op[2] & 0x00)
2259 case 0x00:
2260 goto op_semantics_4;
2261 break;
2263 break;
2264 case 0x8f:
2265 GETBYTE ();
2266 switch (op[2] & 0x00)
2268 case 0x00:
2269 goto op_semantics_4;
2270 break;
2272 break;
2273 case 0x90:
2274 GETBYTE ();
2275 switch (op[2] & 0x00)
2277 case 0x00:
2278 goto op_semantics_5;
2279 break;
2281 break;
2282 case 0x91:
2283 GETBYTE ();
2284 switch (op[2] & 0x00)
2286 case 0x00:
2287 goto op_semantics_5;
2288 break;
2290 break;
2291 case 0x92:
2292 GETBYTE ();
2293 switch (op[2] & 0x00)
2295 case 0x00:
2296 goto op_semantics_5;
2297 break;
2299 break;
2300 case 0x93:
2301 GETBYTE ();
2302 switch (op[2] & 0x00)
2304 case 0x00:
2305 goto op_semantics_5;
2306 break;
2308 break;
2309 case 0x94:
2310 GETBYTE ();
2311 switch (op[2] & 0x00)
2313 case 0x00:
2314 goto op_semantics_6;
2315 break;
2317 break;
2318 case 0x95:
2319 GETBYTE ();
2320 switch (op[2] & 0x00)
2322 case 0x00:
2323 goto op_semantics_6;
2324 break;
2326 break;
2327 case 0x96:
2328 GETBYTE ();
2329 switch (op[2] & 0x00)
2331 case 0x00:
2332 goto op_semantics_6;
2333 break;
2335 break;
2336 case 0x97:
2337 GETBYTE ();
2338 switch (op[2] & 0x00)
2340 case 0x00:
2341 goto op_semantics_6;
2342 break;
2344 break;
2345 case 0xa0:
2346 GETBYTE ();
2347 switch (op[2] & 0xff)
2349 case 0x00:
2350 GETBYTE ();
2351 switch (op[3] & 0x00)
2353 case 0x00:
2354 goto op_semantics_7;
2355 break;
2357 break;
2358 case 0x02:
2359 GETBYTE ();
2360 switch (op[3] & 0x00)
2362 case 0x00:
2363 op_semantics_18:
2365 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2366 #line 474 "rx-decode.opc"
2367 int ss AU = op[1] & 0x03;
2368 #line 474 "rx-decode.opc"
2369 int rsrc AU = (op[3] >> 4) & 0x0f;
2370 #line 474 "rx-decode.opc"
2371 int rdst AU = op[3] & 0x0f;
2372 if (trace)
2374 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2375 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2376 op[0], op[1], op[2], op[3]);
2377 printf (" ss = 0x%x,", ss);
2378 printf (" rsrc = 0x%x,", rsrc);
2379 printf (" rdst = 0x%x\n", rdst);
2381 SYNTAX("adc %1%S1, %0");
2382 #line 474 "rx-decode.opc"
2383 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F("OSZC");
2385 /*----------------------------------------------------------------------*/
2386 /* ADD */
2389 break;
2391 break;
2392 case 0x04:
2393 GETBYTE ();
2394 switch (op[3] & 0x00)
2396 case 0x00:
2397 goto op_semantics_8;
2398 break;
2400 break;
2401 case 0x05:
2402 GETBYTE ();
2403 switch (op[3] & 0x00)
2405 case 0x00:
2406 goto op_semantics_9;
2407 break;
2409 break;
2410 case 0x06:
2411 GETBYTE ();
2412 switch (op[3] & 0x00)
2414 case 0x00:
2415 goto op_semantics_10;
2416 break;
2418 break;
2419 case 0x07:
2420 GETBYTE ();
2421 switch (op[3] & 0x00)
2423 case 0x00:
2424 goto op_semantics_11;
2425 break;
2427 break;
2428 case 0x08:
2429 GETBYTE ();
2430 switch (op[3] & 0x00)
2432 case 0x00:
2433 goto op_semantics_12;
2434 break;
2436 break;
2437 case 0x09:
2438 GETBYTE ();
2439 switch (op[3] & 0x00)
2441 case 0x00:
2442 goto op_semantics_13;
2443 break;
2445 break;
2446 case 0x0c:
2447 GETBYTE ();
2448 switch (op[3] & 0x00)
2450 case 0x00:
2451 goto op_semantics_14;
2452 break;
2454 break;
2455 case 0x0d:
2456 GETBYTE ();
2457 switch (op[3] & 0x00)
2459 case 0x00:
2460 goto op_semantics_15;
2461 break;
2463 break;
2464 case 0x10:
2465 GETBYTE ();
2466 switch (op[3] & 0x00)
2468 case 0x00:
2469 goto op_semantics_16;
2470 break;
2472 break;
2473 case 0x11:
2474 GETBYTE ();
2475 switch (op[3] & 0x00)
2477 case 0x00:
2478 goto op_semantics_17;
2479 break;
2481 break;
2482 default: UNSUPPORTED(); break;
2484 break;
2485 case 0xa1:
2486 GETBYTE ();
2487 switch (op[2] & 0xff)
2489 case 0x00:
2490 GETBYTE ();
2491 switch (op[3] & 0x00)
2493 case 0x00:
2494 goto op_semantics_7;
2495 break;
2497 break;
2498 case 0x02:
2499 GETBYTE ();
2500 switch (op[3] & 0x00)
2502 case 0x00:
2503 goto op_semantics_18;
2504 break;
2506 break;
2507 case 0x04:
2508 GETBYTE ();
2509 switch (op[3] & 0x00)
2511 case 0x00:
2512 goto op_semantics_8;
2513 break;
2515 break;
2516 case 0x05:
2517 GETBYTE ();
2518 switch (op[3] & 0x00)
2520 case 0x00:
2521 goto op_semantics_9;
2522 break;
2524 break;
2525 case 0x06:
2526 GETBYTE ();
2527 switch (op[3] & 0x00)
2529 case 0x00:
2530 goto op_semantics_10;
2531 break;
2533 break;
2534 case 0x07:
2535 GETBYTE ();
2536 switch (op[3] & 0x00)
2538 case 0x00:
2539 goto op_semantics_11;
2540 break;
2542 break;
2543 case 0x08:
2544 GETBYTE ();
2545 switch (op[3] & 0x00)
2547 case 0x00:
2548 goto op_semantics_12;
2549 break;
2551 break;
2552 case 0x09:
2553 GETBYTE ();
2554 switch (op[3] & 0x00)
2556 case 0x00:
2557 goto op_semantics_13;
2558 break;
2560 break;
2561 case 0x0c:
2562 GETBYTE ();
2563 switch (op[3] & 0x00)
2565 case 0x00:
2566 goto op_semantics_14;
2567 break;
2569 break;
2570 case 0x0d:
2571 GETBYTE ();
2572 switch (op[3] & 0x00)
2574 case 0x00:
2575 goto op_semantics_15;
2576 break;
2578 break;
2579 case 0x10:
2580 GETBYTE ();
2581 switch (op[3] & 0x00)
2583 case 0x00:
2584 goto op_semantics_16;
2585 break;
2587 break;
2588 case 0x11:
2589 GETBYTE ();
2590 switch (op[3] & 0x00)
2592 case 0x00:
2593 goto op_semantics_17;
2594 break;
2596 break;
2597 default: UNSUPPORTED(); break;
2599 break;
2600 case 0xa2:
2601 GETBYTE ();
2602 switch (op[2] & 0xff)
2604 case 0x00:
2605 GETBYTE ();
2606 switch (op[3] & 0x00)
2608 case 0x00:
2609 goto op_semantics_7;
2610 break;
2612 break;
2613 case 0x02:
2614 GETBYTE ();
2615 switch (op[3] & 0x00)
2617 case 0x00:
2618 goto op_semantics_18;
2619 break;
2621 break;
2622 case 0x04:
2623 GETBYTE ();
2624 switch (op[3] & 0x00)
2626 case 0x00:
2627 goto op_semantics_8;
2628 break;
2630 break;
2631 case 0x05:
2632 GETBYTE ();
2633 switch (op[3] & 0x00)
2635 case 0x00:
2636 goto op_semantics_9;
2637 break;
2639 break;
2640 case 0x06:
2641 GETBYTE ();
2642 switch (op[3] & 0x00)
2644 case 0x00:
2645 goto op_semantics_10;
2646 break;
2648 break;
2649 case 0x07:
2650 GETBYTE ();
2651 switch (op[3] & 0x00)
2653 case 0x00:
2654 goto op_semantics_11;
2655 break;
2657 break;
2658 case 0x08:
2659 GETBYTE ();
2660 switch (op[3] & 0x00)
2662 case 0x00:
2663 goto op_semantics_12;
2664 break;
2666 break;
2667 case 0x09:
2668 GETBYTE ();
2669 switch (op[3] & 0x00)
2671 case 0x00:
2672 goto op_semantics_13;
2673 break;
2675 break;
2676 case 0x0c:
2677 GETBYTE ();
2678 switch (op[3] & 0x00)
2680 case 0x00:
2681 goto op_semantics_14;
2682 break;
2684 break;
2685 case 0x0d:
2686 GETBYTE ();
2687 switch (op[3] & 0x00)
2689 case 0x00:
2690 goto op_semantics_15;
2691 break;
2693 break;
2694 case 0x10:
2695 GETBYTE ();
2696 switch (op[3] & 0x00)
2698 case 0x00:
2699 goto op_semantics_16;
2700 break;
2702 break;
2703 case 0x11:
2704 GETBYTE ();
2705 switch (op[3] & 0x00)
2707 case 0x00:
2708 goto op_semantics_17;
2709 break;
2711 break;
2712 default: UNSUPPORTED(); break;
2714 break;
2715 case 0xa3:
2716 GETBYTE ();
2717 switch (op[2] & 0xff)
2719 case 0x00:
2720 GETBYTE ();
2721 switch (op[3] & 0x00)
2723 case 0x00:
2724 goto op_semantics_7;
2725 break;
2727 break;
2728 case 0x02:
2729 GETBYTE ();
2730 switch (op[3] & 0x00)
2732 case 0x00:
2733 goto op_semantics_18;
2734 break;
2736 break;
2737 case 0x04:
2738 GETBYTE ();
2739 switch (op[3] & 0x00)
2741 case 0x00:
2742 goto op_semantics_8;
2743 break;
2745 break;
2746 case 0x05:
2747 GETBYTE ();
2748 switch (op[3] & 0x00)
2750 case 0x00:
2751 goto op_semantics_9;
2752 break;
2754 break;
2755 case 0x06:
2756 GETBYTE ();
2757 switch (op[3] & 0x00)
2759 case 0x00:
2760 goto op_semantics_10;
2761 break;
2763 break;
2764 case 0x07:
2765 GETBYTE ();
2766 switch (op[3] & 0x00)
2768 case 0x00:
2769 goto op_semantics_11;
2770 break;
2772 break;
2773 case 0x08:
2774 GETBYTE ();
2775 switch (op[3] & 0x00)
2777 case 0x00:
2778 goto op_semantics_12;
2779 break;
2781 break;
2782 case 0x09:
2783 GETBYTE ();
2784 switch (op[3] & 0x00)
2786 case 0x00:
2787 goto op_semantics_13;
2788 break;
2790 break;
2791 case 0x0c:
2792 GETBYTE ();
2793 switch (op[3] & 0x00)
2795 case 0x00:
2796 goto op_semantics_14;
2797 break;
2799 break;
2800 case 0x0d:
2801 GETBYTE ();
2802 switch (op[3] & 0x00)
2804 case 0x00:
2805 goto op_semantics_15;
2806 break;
2808 break;
2809 case 0x10:
2810 GETBYTE ();
2811 switch (op[3] & 0x00)
2813 case 0x00:
2814 goto op_semantics_16;
2815 break;
2817 break;
2818 case 0x11:
2819 GETBYTE ();
2820 switch (op[3] & 0x00)
2822 case 0x00:
2823 goto op_semantics_17;
2824 break;
2826 break;
2827 default: UNSUPPORTED(); break;
2829 break;
2830 case 0xc0:
2831 GETBYTE ();
2832 switch (op[2] & 0x00)
2834 case 0x00:
2835 goto op_semantics_1;
2836 break;
2838 break;
2839 case 0xc1:
2840 GETBYTE ();
2841 switch (op[2] & 0x00)
2843 case 0x00:
2844 goto op_semantics_1;
2845 break;
2847 break;
2848 case 0xc2:
2849 GETBYTE ();
2850 switch (op[2] & 0x00)
2852 case 0x00:
2853 goto op_semantics_1;
2854 break;
2856 break;
2857 case 0xc3:
2858 GETBYTE ();
2859 switch (op[2] & 0x00)
2861 case 0x00:
2862 goto op_semantics_1;
2863 break;
2865 break;
2866 case 0xc4:
2867 GETBYTE ();
2868 switch (op[2] & 0x00)
2870 case 0x00:
2871 goto op_semantics_2;
2872 break;
2874 break;
2875 case 0xc5:
2876 GETBYTE ();
2877 switch (op[2] & 0x00)
2879 case 0x00:
2880 goto op_semantics_2;
2881 break;
2883 break;
2884 case 0xc6:
2885 GETBYTE ();
2886 switch (op[2] & 0x00)
2888 case 0x00:
2889 goto op_semantics_2;
2890 break;
2892 break;
2893 case 0xc7:
2894 GETBYTE ();
2895 switch (op[2] & 0x00)
2897 case 0x00:
2898 goto op_semantics_2;
2899 break;
2901 break;
2902 case 0xc8:
2903 GETBYTE ();
2904 switch (op[2] & 0x00)
2906 case 0x00:
2907 goto op_semantics_3;
2908 break;
2910 break;
2911 case 0xc9:
2912 GETBYTE ();
2913 switch (op[2] & 0x00)
2915 case 0x00:
2916 goto op_semantics_3;
2917 break;
2919 break;
2920 case 0xca:
2921 GETBYTE ();
2922 switch (op[2] & 0x00)
2924 case 0x00:
2925 goto op_semantics_3;
2926 break;
2928 break;
2929 case 0xcb:
2930 GETBYTE ();
2931 switch (op[2] & 0x00)
2933 case 0x00:
2934 goto op_semantics_3;
2935 break;
2937 break;
2938 case 0xcc:
2939 GETBYTE ();
2940 switch (op[2] & 0x00)
2942 case 0x00:
2943 goto op_semantics_4;
2944 break;
2946 break;
2947 case 0xcd:
2948 GETBYTE ();
2949 switch (op[2] & 0x00)
2951 case 0x00:
2952 goto op_semantics_4;
2953 break;
2955 break;
2956 case 0xce:
2957 GETBYTE ();
2958 switch (op[2] & 0x00)
2960 case 0x00:
2961 goto op_semantics_4;
2962 break;
2964 break;
2965 case 0xcf:
2966 GETBYTE ();
2967 switch (op[2] & 0x00)
2969 case 0x00:
2970 goto op_semantics_4;
2971 break;
2973 break;
2974 case 0xd0:
2975 GETBYTE ();
2976 switch (op[2] & 0x00)
2978 case 0x00:
2979 goto op_semantics_5;
2980 break;
2982 break;
2983 case 0xd1:
2984 GETBYTE ();
2985 switch (op[2] & 0x00)
2987 case 0x00:
2988 goto op_semantics_5;
2989 break;
2991 break;
2992 case 0xd2:
2993 GETBYTE ();
2994 switch (op[2] & 0x00)
2996 case 0x00:
2997 goto op_semantics_5;
2998 break;
3000 break;
3001 case 0xd3:
3002 GETBYTE ();
3003 switch (op[2] & 0x00)
3005 case 0x00:
3006 goto op_semantics_5;
3007 break;
3009 break;
3010 case 0xd4:
3011 GETBYTE ();
3012 switch (op[2] & 0x00)
3014 case 0x00:
3015 goto op_semantics_6;
3016 break;
3018 break;
3019 case 0xd5:
3020 GETBYTE ();
3021 switch (op[2] & 0x00)
3023 case 0x00:
3024 goto op_semantics_6;
3025 break;
3027 break;
3028 case 0xd6:
3029 GETBYTE ();
3030 switch (op[2] & 0x00)
3032 case 0x00:
3033 goto op_semantics_6;
3034 break;
3036 break;
3037 case 0xd7:
3038 GETBYTE ();
3039 switch (op[2] & 0x00)
3041 case 0x00:
3042 goto op_semantics_6;
3043 break;
3045 break;
3046 case 0xe0:
3047 GETBYTE ();
3048 switch (op[2] & 0xff)
3050 case 0x00:
3051 GETBYTE ();
3052 switch (op[3] & 0x00)
3054 case 0x00:
3055 goto op_semantics_7;
3056 break;
3058 break;
3059 case 0x04:
3060 GETBYTE ();
3061 switch (op[3] & 0x00)
3063 case 0x00:
3064 goto op_semantics_8;
3065 break;
3067 break;
3068 case 0x05:
3069 GETBYTE ();
3070 switch (op[3] & 0x00)
3072 case 0x00:
3073 goto op_semantics_9;
3074 break;
3076 break;
3077 case 0x06:
3078 GETBYTE ();
3079 switch (op[3] & 0x00)
3081 case 0x00:
3082 goto op_semantics_10;
3083 break;
3085 break;
3086 case 0x07:
3087 GETBYTE ();
3088 switch (op[3] & 0x00)
3090 case 0x00:
3091 goto op_semantics_11;
3092 break;
3094 break;
3095 case 0x08:
3096 GETBYTE ();
3097 switch (op[3] & 0x00)
3099 case 0x00:
3100 goto op_semantics_12;
3101 break;
3103 break;
3104 case 0x09:
3105 GETBYTE ();
3106 switch (op[3] & 0x00)
3108 case 0x00:
3109 goto op_semantics_13;
3110 break;
3112 break;
3113 case 0x0c:
3114 GETBYTE ();
3115 switch (op[3] & 0x00)
3117 case 0x00:
3118 goto op_semantics_14;
3119 break;
3121 break;
3122 case 0x0d:
3123 GETBYTE ();
3124 switch (op[3] & 0x00)
3126 case 0x00:
3127 goto op_semantics_15;
3128 break;
3130 break;
3131 case 0x10:
3132 GETBYTE ();
3133 switch (op[3] & 0x00)
3135 case 0x00:
3136 goto op_semantics_16;
3137 break;
3139 break;
3140 case 0x11:
3141 GETBYTE ();
3142 switch (op[3] & 0x00)
3144 case 0x00:
3145 goto op_semantics_17;
3146 break;
3148 break;
3149 default: UNSUPPORTED(); break;
3151 break;
3152 case 0xe1:
3153 GETBYTE ();
3154 switch (op[2] & 0xff)
3156 case 0x00:
3157 GETBYTE ();
3158 switch (op[3] & 0x00)
3160 case 0x00:
3161 goto op_semantics_7;
3162 break;
3164 break;
3165 case 0x04:
3166 GETBYTE ();
3167 switch (op[3] & 0x00)
3169 case 0x00:
3170 goto op_semantics_8;
3171 break;
3173 break;
3174 case 0x05:
3175 GETBYTE ();
3176 switch (op[3] & 0x00)
3178 case 0x00:
3179 goto op_semantics_9;
3180 break;
3182 break;
3183 case 0x06:
3184 GETBYTE ();
3185 switch (op[3] & 0x00)
3187 case 0x00:
3188 goto op_semantics_10;
3189 break;
3191 break;
3192 case 0x07:
3193 GETBYTE ();
3194 switch (op[3] & 0x00)
3196 case 0x00:
3197 goto op_semantics_11;
3198 break;
3200 break;
3201 case 0x08:
3202 GETBYTE ();
3203 switch (op[3] & 0x00)
3205 case 0x00:
3206 goto op_semantics_12;
3207 break;
3209 break;
3210 case 0x09:
3211 GETBYTE ();
3212 switch (op[3] & 0x00)
3214 case 0x00:
3215 goto op_semantics_13;
3216 break;
3218 break;
3219 case 0x0c:
3220 GETBYTE ();
3221 switch (op[3] & 0x00)
3223 case 0x00:
3224 goto op_semantics_14;
3225 break;
3227 break;
3228 case 0x0d:
3229 GETBYTE ();
3230 switch (op[3] & 0x00)
3232 case 0x00:
3233 goto op_semantics_15;
3234 break;
3236 break;
3237 case 0x10:
3238 GETBYTE ();
3239 switch (op[3] & 0x00)
3241 case 0x00:
3242 goto op_semantics_16;
3243 break;
3245 break;
3246 case 0x11:
3247 GETBYTE ();
3248 switch (op[3] & 0x00)
3250 case 0x00:
3251 goto op_semantics_17;
3252 break;
3254 break;
3255 default: UNSUPPORTED(); break;
3257 break;
3258 case 0xe2:
3259 GETBYTE ();
3260 switch (op[2] & 0xff)
3262 case 0x00:
3263 GETBYTE ();
3264 switch (op[3] & 0x00)
3266 case 0x00:
3267 goto op_semantics_7;
3268 break;
3270 break;
3271 case 0x04:
3272 GETBYTE ();
3273 switch (op[3] & 0x00)
3275 case 0x00:
3276 goto op_semantics_8;
3277 break;
3279 break;
3280 case 0x05:
3281 GETBYTE ();
3282 switch (op[3] & 0x00)
3284 case 0x00:
3285 goto op_semantics_9;
3286 break;
3288 break;
3289 case 0x06:
3290 GETBYTE ();
3291 switch (op[3] & 0x00)
3293 case 0x00:
3294 goto op_semantics_10;
3295 break;
3297 break;
3298 case 0x07:
3299 GETBYTE ();
3300 switch (op[3] & 0x00)
3302 case 0x00:
3303 goto op_semantics_11;
3304 break;
3306 break;
3307 case 0x08:
3308 GETBYTE ();
3309 switch (op[3] & 0x00)
3311 case 0x00:
3312 goto op_semantics_12;
3313 break;
3315 break;
3316 case 0x09:
3317 GETBYTE ();
3318 switch (op[3] & 0x00)
3320 case 0x00:
3321 goto op_semantics_13;
3322 break;
3324 break;
3325 case 0x0c:
3326 GETBYTE ();
3327 switch (op[3] & 0x00)
3329 case 0x00:
3330 goto op_semantics_14;
3331 break;
3333 break;
3334 case 0x0d:
3335 GETBYTE ();
3336 switch (op[3] & 0x00)
3338 case 0x00:
3339 goto op_semantics_15;
3340 break;
3342 break;
3343 case 0x10:
3344 GETBYTE ();
3345 switch (op[3] & 0x00)
3347 case 0x00:
3348 goto op_semantics_16;
3349 break;
3351 break;
3352 case 0x11:
3353 GETBYTE ();
3354 switch (op[3] & 0x00)
3356 case 0x00:
3357 goto op_semantics_17;
3358 break;
3360 break;
3361 default: UNSUPPORTED(); break;
3363 break;
3364 case 0xe3:
3365 GETBYTE ();
3366 switch (op[2] & 0xff)
3368 case 0x00:
3369 GETBYTE ();
3370 switch (op[3] & 0x00)
3372 case 0x00:
3373 goto op_semantics_7;
3374 break;
3376 break;
3377 case 0x04:
3378 GETBYTE ();
3379 switch (op[3] & 0x00)
3381 case 0x00:
3382 goto op_semantics_8;
3383 break;
3385 break;
3386 case 0x05:
3387 GETBYTE ();
3388 switch (op[3] & 0x00)
3390 case 0x00:
3391 goto op_semantics_9;
3392 break;
3394 break;
3395 case 0x06:
3396 GETBYTE ();
3397 switch (op[3] & 0x00)
3399 case 0x00:
3400 goto op_semantics_10;
3401 break;
3403 break;
3404 case 0x07:
3405 GETBYTE ();
3406 switch (op[3] & 0x00)
3408 case 0x00:
3409 goto op_semantics_11;
3410 break;
3412 break;
3413 case 0x08:
3414 GETBYTE ();
3415 switch (op[3] & 0x00)
3417 case 0x00:
3418 goto op_semantics_12;
3419 break;
3421 break;
3422 case 0x09:
3423 GETBYTE ();
3424 switch (op[3] & 0x00)
3426 case 0x00:
3427 goto op_semantics_13;
3428 break;
3430 break;
3431 case 0x0c:
3432 GETBYTE ();
3433 switch (op[3] & 0x00)
3435 case 0x00:
3436 goto op_semantics_14;
3437 break;
3439 break;
3440 case 0x0d:
3441 GETBYTE ();
3442 switch (op[3] & 0x00)
3444 case 0x00:
3445 goto op_semantics_15;
3446 break;
3448 break;
3449 case 0x10:
3450 GETBYTE ();
3451 switch (op[3] & 0x00)
3453 case 0x00:
3454 goto op_semantics_16;
3455 break;
3457 break;
3458 case 0x11:
3459 GETBYTE ();
3460 switch (op[3] & 0x00)
3462 case 0x00:
3463 goto op_semantics_17;
3464 break;
3466 break;
3467 default: UNSUPPORTED(); break;
3469 break;
3470 default: UNSUPPORTED(); break;
3472 break;
3473 case 0x08:
3474 case 0x09:
3475 case 0x0a:
3476 case 0x0b:
3477 case 0x0c:
3478 case 0x0d:
3479 case 0x0e:
3480 case 0x0f:
3482 /** 0000 1dsp bra.s %a0 */
3483 #line 709 "rx-decode.opc"
3484 int dsp AU = op[0] & 0x07;
3485 if (trace)
3487 printf ("\033[33m%s\033[0m %02x\n",
3488 "/** 0000 1dsp bra.s %a0 */",
3489 op[0]);
3490 printf (" dsp = 0x%x\n", dsp);
3492 SYNTAX("bra.s %a0");
3493 #line 709 "rx-decode.opc"
3494 ID(branch); Scc(RXC_always); DC(pc + dsp3map[dsp]);
3497 break;
3498 case 0x10:
3499 case 0x11:
3500 case 0x12:
3501 case 0x13:
3502 case 0x14:
3503 case 0x15:
3504 case 0x16:
3505 case 0x17:
3506 case 0x18:
3507 case 0x19:
3508 case 0x1a:
3509 case 0x1b:
3510 case 0x1c:
3511 case 0x1d:
3512 case 0x1e:
3513 case 0x1f:
3515 /** 0001 n dsp b%1.s %a0 */
3516 #line 699 "rx-decode.opc"
3517 int n AU = (op[0] >> 3) & 0x01;
3518 #line 699 "rx-decode.opc"
3519 int dsp AU = op[0] & 0x07;
3520 if (trace)
3522 printf ("\033[33m%s\033[0m %02x\n",
3523 "/** 0001 n dsp b%1.s %a0 */",
3524 op[0]);
3525 printf (" n = 0x%x,", n);
3526 printf (" dsp = 0x%x\n", dsp);
3528 SYNTAX("b%1.s %a0");
3529 #line 699 "rx-decode.opc"
3530 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3533 break;
3534 case 0x20:
3535 case 0x21:
3536 case 0x22:
3537 case 0x23:
3538 case 0x24:
3539 case 0x25:
3540 case 0x26:
3541 case 0x27:
3542 case 0x28:
3543 case 0x29:
3544 case 0x2a:
3545 case 0x2b:
3546 case 0x2c:
3547 case 0x2d:
3548 case 0x2f:
3550 /** 0010 cond b%1.b %a0 */
3551 #line 702 "rx-decode.opc"
3552 int cond AU = op[0] & 0x0f;
3553 if (trace)
3555 printf ("\033[33m%s\033[0m %02x\n",
3556 "/** 0010 cond b%1.b %a0 */",
3557 op[0]);
3558 printf (" cond = 0x%x\n", cond);
3560 SYNTAX("b%1.b %a0");
3561 #line 702 "rx-decode.opc"
3562 ID(branch); Scc(cond); DC(pc + IMMex (1));
3565 break;
3566 case 0x2e:
3568 /** 0010 1110 bra.b %a0 */
3569 if (trace)
3571 printf ("\033[33m%s\033[0m %02x\n",
3572 "/** 0010 1110 bra.b %a0 */",
3573 op[0]);
3575 SYNTAX("bra.b %a0");
3576 #line 712 "rx-decode.opc"
3577 ID(branch); Scc(RXC_always); DC(pc + IMMex(1));
3580 break;
3581 case 0x38:
3583 /** 0011 1000 bra.w %a0 */
3584 if (trace)
3586 printf ("\033[33m%s\033[0m %02x\n",
3587 "/** 0011 1000 bra.w %a0 */",
3588 op[0]);
3590 SYNTAX("bra.w %a0");
3591 #line 715 "rx-decode.opc"
3592 ID(branch); Scc(RXC_always); DC(pc + IMMex(2));
3595 break;
3596 case 0x39:
3598 /** 0011 1001 bsr.w %a0 */
3599 if (trace)
3601 printf ("\033[33m%s\033[0m %02x\n",
3602 "/** 0011 1001 bsr.w %a0 */",
3603 op[0]);
3605 SYNTAX("bsr.w %a0");
3606 #line 731 "rx-decode.opc"
3607 ID(jsr); DC(pc + IMMex(2));
3610 break;
3611 case 0x3a:
3612 case 0x3b:
3614 /** 0011 101c b%1.w %a0 */
3615 #line 705 "rx-decode.opc"
3616 int c AU = op[0] & 0x01;
3617 if (trace)
3619 printf ("\033[33m%s\033[0m %02x\n",
3620 "/** 0011 101c b%1.w %a0 */",
3621 op[0]);
3622 printf (" c = 0x%x\n", c);
3624 SYNTAX("b%1.w %a0");
3625 #line 705 "rx-decode.opc"
3626 ID(branch); Scc(c); DC(pc + IMMex (2));
3630 break;
3631 case 0x3c:
3632 GETBYTE ();
3633 switch (op[1] & 0x00)
3635 case 0x00:
3636 op_semantics_19:
3638 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3639 #line 295 "rx-decode.opc"
3640 int sz AU = op[0] & 0x03;
3641 #line 295 "rx-decode.opc"
3642 int d AU = (op[1] >> 7) & 0x01;
3643 #line 295 "rx-decode.opc"
3644 int dst AU = (op[1] >> 4) & 0x07;
3645 #line 295 "rx-decode.opc"
3646 int sppp AU = op[1] & 0x0f;
3647 if (trace)
3649 printf ("\033[33m%s\033[0m %02x %02x\n",
3650 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3651 op[0], op[1]);
3652 printf (" sz = 0x%x,", sz);
3653 printf (" d = 0x%x,", d);
3654 printf (" dst = 0x%x,", dst);
3655 printf (" sppp = 0x%x\n", sppp);
3657 SYNTAX("mov%s #%1, %0");
3658 #line 295 "rx-decode.opc"
3659 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F("----");
3662 break;
3664 break;
3665 case 0x3d:
3666 GETBYTE ();
3667 switch (op[1] & 0x00)
3669 case 0x00:
3670 goto op_semantics_19;
3671 break;
3673 break;
3674 case 0x3e:
3675 GETBYTE ();
3676 switch (op[1] & 0x00)
3678 case 0x00:
3679 goto op_semantics_19;
3680 break;
3682 break;
3683 case 0x3f:
3684 GETBYTE ();
3685 switch (op[1] & 0x00)
3687 case 0x00:
3689 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3690 #line 384 "rx-decode.opc"
3691 int rega AU = (op[1] >> 4) & 0x0f;
3692 #line 384 "rx-decode.opc"
3693 int regb AU = op[1] & 0x0f;
3694 if (trace)
3696 printf ("\033[33m%s\033[0m %02x %02x\n",
3697 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3698 op[0], op[1]);
3699 printf (" rega = 0x%x,", rega);
3700 printf (" regb = 0x%x\n", regb);
3702 SYNTAX("rtsd #%1, %2-%0");
3703 #line 384 "rx-decode.opc"
3704 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3706 /*----------------------------------------------------------------------*/
3707 /* AND */
3710 break;
3712 break;
3713 case 0x40:
3714 GETBYTE ();
3715 switch (op[1] & 0x00)
3717 case 0x00:
3718 op_semantics_20:
3720 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3721 #line 519 "rx-decode.opc"
3722 int ss AU = op[0] & 0x03;
3723 #line 519 "rx-decode.opc"
3724 int rsrc AU = (op[1] >> 4) & 0x0f;
3725 #line 519 "rx-decode.opc"
3726 int rdst AU = op[1] & 0x0f;
3727 if (trace)
3729 printf ("\033[33m%s\033[0m %02x %02x\n",
3730 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3731 op[0], op[1]);
3732 printf (" ss = 0x%x,", ss);
3733 printf (" rsrc = 0x%x,", rsrc);
3734 printf (" rdst = 0x%x\n", rdst);
3736 SYNTAX("sub %2%S2, %1");
3737 #line 519 "rx-decode.opc"
3738 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F("OSZC");
3741 break;
3743 break;
3744 case 0x41:
3745 GETBYTE ();
3746 switch (op[1] & 0x00)
3748 case 0x00:
3749 goto op_semantics_20;
3750 break;
3752 break;
3753 case 0x42:
3754 GETBYTE ();
3755 switch (op[1] & 0x00)
3757 case 0x00:
3758 goto op_semantics_20;
3759 break;
3761 break;
3762 case 0x43:
3763 GETBYTE ();
3764 switch (op[1] & 0x00)
3766 case 0x00:
3767 goto op_semantics_20;
3768 break;
3770 break;
3771 case 0x44:
3772 GETBYTE ();
3773 switch (op[1] & 0x00)
3775 case 0x00:
3776 op_semantics_21:
3778 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3779 #line 507 "rx-decode.opc"
3780 int ss AU = op[0] & 0x03;
3781 #line 507 "rx-decode.opc"
3782 int rsrc AU = (op[1] >> 4) & 0x0f;
3783 #line 507 "rx-decode.opc"
3784 int rdst AU = op[1] & 0x0f;
3785 if (trace)
3787 printf ("\033[33m%s\033[0m %02x %02x\n",
3788 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3789 op[0], op[1]);
3790 printf (" ss = 0x%x,", ss);
3791 printf (" rsrc = 0x%x,", rsrc);
3792 printf (" rdst = 0x%x\n", rdst);
3794 SYNTAX("cmp %2%S2, %1");
3795 #line 507 "rx-decode.opc"
3796 ID(sub); S2P(ss, rsrc); SR(rdst); F("OSZC");
3799 break;
3801 break;
3802 case 0x45:
3803 GETBYTE ();
3804 switch (op[1] & 0x00)
3806 case 0x00:
3807 goto op_semantics_21;
3808 break;
3810 break;
3811 case 0x46:
3812 GETBYTE ();
3813 switch (op[1] & 0x00)
3815 case 0x00:
3816 goto op_semantics_21;
3817 break;
3819 break;
3820 case 0x47:
3821 GETBYTE ();
3822 switch (op[1] & 0x00)
3824 case 0x00:
3825 goto op_semantics_21;
3826 break;
3828 break;
3829 case 0x48:
3830 GETBYTE ();
3831 switch (op[1] & 0x00)
3833 case 0x00:
3834 op_semantics_22:
3836 /** 0100 10ss rsrc rdst add %1%S1, %0 */
3837 #line 483 "rx-decode.opc"
3838 int ss AU = op[0] & 0x03;
3839 #line 483 "rx-decode.opc"
3840 int rsrc AU = (op[1] >> 4) & 0x0f;
3841 #line 483 "rx-decode.opc"
3842 int rdst AU = op[1] & 0x0f;
3843 if (trace)
3845 printf ("\033[33m%s\033[0m %02x %02x\n",
3846 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3847 op[0], op[1]);
3848 printf (" ss = 0x%x,", ss);
3849 printf (" rsrc = 0x%x,", rsrc);
3850 printf (" rdst = 0x%x\n", rdst);
3852 SYNTAX("add %1%S1, %0");
3853 #line 483 "rx-decode.opc"
3854 ID(add); SP(ss, rsrc); DR(rdst); F("OSZC");
3857 break;
3859 break;
3860 case 0x49:
3861 GETBYTE ();
3862 switch (op[1] & 0x00)
3864 case 0x00:
3865 goto op_semantics_22;
3866 break;
3868 break;
3869 case 0x4a:
3870 GETBYTE ();
3871 switch (op[1] & 0x00)
3873 case 0x00:
3874 goto op_semantics_22;
3875 break;
3877 break;
3878 case 0x4b:
3879 GETBYTE ();
3880 switch (op[1] & 0x00)
3882 case 0x00:
3883 goto op_semantics_22;
3884 break;
3886 break;
3887 case 0x4c:
3888 GETBYTE ();
3889 switch (op[1] & 0x00)
3891 case 0x00:
3892 op_semantics_23:
3894 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
3895 #line 580 "rx-decode.opc"
3896 int ss AU = op[0] & 0x03;
3897 #line 580 "rx-decode.opc"
3898 int rsrc AU = (op[1] >> 4) & 0x0f;
3899 #line 580 "rx-decode.opc"
3900 int rdst AU = op[1] & 0x0f;
3901 if (trace)
3903 printf ("\033[33m%s\033[0m %02x %02x\n",
3904 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3905 op[0], op[1]);
3906 printf (" ss = 0x%x,", ss);
3907 printf (" rsrc = 0x%x,", rsrc);
3908 printf (" rdst = 0x%x\n", rdst);
3910 SYNTAX("mul %1%S1, %0");
3911 #line 580 "rx-decode.opc"
3912 ID(mul); SP(ss, rsrc); DR(rdst); F("----");
3915 break;
3917 break;
3918 case 0x4d:
3919 GETBYTE ();
3920 switch (op[1] & 0x00)
3922 case 0x00:
3923 goto op_semantics_23;
3924 break;
3926 break;
3927 case 0x4e:
3928 GETBYTE ();
3929 switch (op[1] & 0x00)
3931 case 0x00:
3932 goto op_semantics_23;
3933 break;
3935 break;
3936 case 0x4f:
3937 GETBYTE ();
3938 switch (op[1] & 0x00)
3940 case 0x00:
3941 goto op_semantics_23;
3942 break;
3944 break;
3945 case 0x50:
3946 GETBYTE ();
3947 switch (op[1] & 0x00)
3949 case 0x00:
3950 op_semantics_24:
3952 /** 0101 00ss rsrc rdst and %1%S1, %0 */
3953 #line 396 "rx-decode.opc"
3954 int ss AU = op[0] & 0x03;
3955 #line 396 "rx-decode.opc"
3956 int rsrc AU = (op[1] >> 4) & 0x0f;
3957 #line 396 "rx-decode.opc"
3958 int rdst AU = op[1] & 0x0f;
3959 if (trace)
3961 printf ("\033[33m%s\033[0m %02x %02x\n",
3962 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3963 op[0], op[1]);
3964 printf (" ss = 0x%x,", ss);
3965 printf (" rsrc = 0x%x,", rsrc);
3966 printf (" rdst = 0x%x\n", rdst);
3968 SYNTAX("and %1%S1, %0");
3969 #line 396 "rx-decode.opc"
3970 ID(and); SP(ss, rsrc); DR(rdst); F("-SZ-");
3973 break;
3975 break;
3976 case 0x51:
3977 GETBYTE ();
3978 switch (op[1] & 0x00)
3980 case 0x00:
3981 goto op_semantics_24;
3982 break;
3984 break;
3985 case 0x52:
3986 GETBYTE ();
3987 switch (op[1] & 0x00)
3989 case 0x00:
3990 goto op_semantics_24;
3991 break;
3993 break;
3994 case 0x53:
3995 GETBYTE ();
3996 switch (op[1] & 0x00)
3998 case 0x00:
3999 goto op_semantics_24;
4000 break;
4002 break;
4003 case 0x54:
4004 GETBYTE ();
4005 switch (op[1] & 0x00)
4007 case 0x00:
4008 op_semantics_25:
4010 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4011 #line 414 "rx-decode.opc"
4012 int ss AU = op[0] & 0x03;
4013 #line 414 "rx-decode.opc"
4014 int rsrc AU = (op[1] >> 4) & 0x0f;
4015 #line 414 "rx-decode.opc"
4016 int rdst AU = op[1] & 0x0f;
4017 if (trace)
4019 printf ("\033[33m%s\033[0m %02x %02x\n",
4020 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4021 op[0], op[1]);
4022 printf (" ss = 0x%x,", ss);
4023 printf (" rsrc = 0x%x,", rsrc);
4024 printf (" rdst = 0x%x\n", rdst);
4026 SYNTAX("or %1%S1, %0");
4027 #line 414 "rx-decode.opc"
4028 ID(or); SP(ss, rsrc); DR(rdst); F("-SZ-");
4031 break;
4033 break;
4034 case 0x55:
4035 GETBYTE ();
4036 switch (op[1] & 0x00)
4038 case 0x00:
4039 goto op_semantics_25;
4040 break;
4042 break;
4043 case 0x56:
4044 GETBYTE ();
4045 switch (op[1] & 0x00)
4047 case 0x00:
4048 goto op_semantics_25;
4049 break;
4051 break;
4052 case 0x57:
4053 GETBYTE ();
4054 switch (op[1] & 0x00)
4056 case 0x00:
4057 goto op_semantics_25;
4058 break;
4060 break;
4061 case 0x58:
4062 GETBYTE ();
4063 switch (op[1] & 0x00)
4065 case 0x00:
4066 op_semantics_26:
4068 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4069 #line 335 "rx-decode.opc"
4070 int s AU = (op[0] >> 2) & 0x01;
4071 #line 335 "rx-decode.opc"
4072 int ss AU = op[0] & 0x03;
4073 #line 335 "rx-decode.opc"
4074 int rsrc AU = (op[1] >> 4) & 0x0f;
4075 #line 335 "rx-decode.opc"
4076 int rdst AU = op[1] & 0x0f;
4077 if (trace)
4079 printf ("\033[33m%s\033[0m %02x %02x\n",
4080 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4081 op[0], op[1]);
4082 printf (" s = 0x%x,", s);
4083 printf (" ss = 0x%x,", ss);
4084 printf (" rsrc = 0x%x,", rsrc);
4085 printf (" rdst = 0x%x\n", rdst);
4087 SYNTAX("movu%s %1, %0");
4088 #line 335 "rx-decode.opc"
4089 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F("----");
4092 break;
4094 break;
4095 case 0x59:
4096 GETBYTE ();
4097 switch (op[1] & 0x00)
4099 case 0x00:
4100 goto op_semantics_26;
4101 break;
4103 break;
4104 case 0x5a:
4105 GETBYTE ();
4106 switch (op[1] & 0x00)
4108 case 0x00:
4109 goto op_semantics_26;
4110 break;
4112 break;
4113 case 0x5b:
4114 GETBYTE ();
4115 switch (op[1] & 0x00)
4117 case 0x00:
4118 goto op_semantics_26;
4119 break;
4121 break;
4122 case 0x5c:
4123 GETBYTE ();
4124 switch (op[1] & 0x00)
4126 case 0x00:
4127 goto op_semantics_26;
4128 break;
4130 break;
4131 case 0x5d:
4132 GETBYTE ();
4133 switch (op[1] & 0x00)
4135 case 0x00:
4136 goto op_semantics_26;
4137 break;
4139 break;
4140 case 0x5e:
4141 GETBYTE ();
4142 switch (op[1] & 0x00)
4144 case 0x00:
4145 goto op_semantics_26;
4146 break;
4148 break;
4149 case 0x5f:
4150 GETBYTE ();
4151 switch (op[1] & 0x00)
4153 case 0x00:
4154 goto op_semantics_26;
4155 break;
4157 break;
4158 case 0x60:
4159 GETBYTE ();
4160 switch (op[1] & 0x00)
4162 case 0x00:
4164 /** 0110 0000 immm rdst sub #%2, %0 */
4165 #line 516 "rx-decode.opc"
4166 int immm AU = (op[1] >> 4) & 0x0f;
4167 #line 516 "rx-decode.opc"
4168 int rdst AU = op[1] & 0x0f;
4169 if (trace)
4171 printf ("\033[33m%s\033[0m %02x %02x\n",
4172 "/** 0110 0000 immm rdst sub #%2, %0 */",
4173 op[0], op[1]);
4174 printf (" immm = 0x%x,", immm);
4175 printf (" rdst = 0x%x\n", rdst);
4177 SYNTAX("sub #%2, %0");
4178 #line 516 "rx-decode.opc"
4179 ID(sub); S2C(immm); SR(rdst); DR(rdst); F("OSZC");
4182 break;
4184 break;
4185 case 0x61:
4186 GETBYTE ();
4187 switch (op[1] & 0x00)
4189 case 0x00:
4191 /** 0110 0001 immm rdst cmp #%2, %1 */
4192 #line 498 "rx-decode.opc"
4193 int immm AU = (op[1] >> 4) & 0x0f;
4194 #line 498 "rx-decode.opc"
4195 int rdst AU = op[1] & 0x0f;
4196 if (trace)
4198 printf ("\033[33m%s\033[0m %02x %02x\n",
4199 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4200 op[0], op[1]);
4201 printf (" immm = 0x%x,", immm);
4202 printf (" rdst = 0x%x\n", rdst);
4204 SYNTAX("cmp #%2, %1");
4205 #line 498 "rx-decode.opc"
4206 ID(sub); S2C(immm); SR(rdst); F("OSZC");
4209 break;
4211 break;
4212 case 0x62:
4213 GETBYTE ();
4214 switch (op[1] & 0x00)
4216 case 0x00:
4218 /** 0110 0010 immm rdst add #%1, %0 */
4219 #line 480 "rx-decode.opc"
4220 int immm AU = (op[1] >> 4) & 0x0f;
4221 #line 480 "rx-decode.opc"
4222 int rdst AU = op[1] & 0x0f;
4223 if (trace)
4225 printf ("\033[33m%s\033[0m %02x %02x\n",
4226 "/** 0110 0010 immm rdst add #%1, %0 */",
4227 op[0], op[1]);
4228 printf (" immm = 0x%x,", immm);
4229 printf (" rdst = 0x%x\n", rdst);
4231 SYNTAX("add #%1, %0");
4232 #line 480 "rx-decode.opc"
4233 ID(add); SC(immm); DR(rdst); F("OSZC");
4236 break;
4238 break;
4239 case 0x63:
4240 GETBYTE ();
4241 switch (op[1] & 0x00)
4243 case 0x00:
4245 /** 0110 0011 immm rdst mul #%1, %0 */
4246 #line 574 "rx-decode.opc"
4247 int immm AU = (op[1] >> 4) & 0x0f;
4248 #line 574 "rx-decode.opc"
4249 int rdst AU = op[1] & 0x0f;
4250 if (trace)
4252 printf ("\033[33m%s\033[0m %02x %02x\n",
4253 "/** 0110 0011 immm rdst mul #%1, %0 */",
4254 op[0], op[1]);
4255 printf (" immm = 0x%x,", immm);
4256 printf (" rdst = 0x%x\n", rdst);
4258 SYNTAX("mul #%1, %0");
4259 #line 574 "rx-decode.opc"
4260 ID(mul); DR(rdst); SC(immm); F("----");
4263 break;
4265 break;
4266 case 0x64:
4267 GETBYTE ();
4268 switch (op[1] & 0x00)
4270 case 0x00:
4272 /** 0110 0100 immm rdst and #%1, %0 */
4273 #line 390 "rx-decode.opc"
4274 int immm AU = (op[1] >> 4) & 0x0f;
4275 #line 390 "rx-decode.opc"
4276 int rdst AU = op[1] & 0x0f;
4277 if (trace)
4279 printf ("\033[33m%s\033[0m %02x %02x\n",
4280 "/** 0110 0100 immm rdst and #%1, %0 */",
4281 op[0], op[1]);
4282 printf (" immm = 0x%x,", immm);
4283 printf (" rdst = 0x%x\n", rdst);
4285 SYNTAX("and #%1, %0");
4286 #line 390 "rx-decode.opc"
4287 ID(and); SC(immm); DR(rdst); F("-SZ-");
4290 break;
4292 break;
4293 case 0x65:
4294 GETBYTE ();
4295 switch (op[1] & 0x00)
4297 case 0x00:
4299 /** 0110 0101 immm rdst or #%1, %0 */
4300 #line 408 "rx-decode.opc"
4301 int immm AU = (op[1] >> 4) & 0x0f;
4302 #line 408 "rx-decode.opc"
4303 int rdst AU = op[1] & 0x0f;
4304 if (trace)
4306 printf ("\033[33m%s\033[0m %02x %02x\n",
4307 "/** 0110 0101 immm rdst or #%1, %0 */",
4308 op[0], op[1]);
4309 printf (" immm = 0x%x,", immm);
4310 printf (" rdst = 0x%x\n", rdst);
4312 SYNTAX("or #%1, %0");
4313 #line 408 "rx-decode.opc"
4314 ID(or); SC(immm); DR(rdst); F("-SZ-");
4317 break;
4319 break;
4320 case 0x66:
4321 GETBYTE ();
4322 switch (op[1] & 0x00)
4324 case 0x00:
4326 /** 0110 0110 immm rdst mov%s #%1, %0 */
4327 #line 292 "rx-decode.opc"
4328 int immm AU = (op[1] >> 4) & 0x0f;
4329 #line 292 "rx-decode.opc"
4330 int rdst AU = op[1] & 0x0f;
4331 if (trace)
4333 printf ("\033[33m%s\033[0m %02x %02x\n",
4334 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4335 op[0], op[1]);
4336 printf (" immm = 0x%x,", immm);
4337 printf (" rdst = 0x%x\n", rdst);
4339 SYNTAX("mov%s #%1, %0");
4340 #line 292 "rx-decode.opc"
4341 ID(mov); DR(rdst); SC(immm); F("----");
4344 break;
4346 break;
4347 case 0x67:
4349 /** 0110 0111 rtsd #%1 */
4350 if (trace)
4352 printf ("\033[33m%s\033[0m %02x\n",
4353 "/** 0110 0111 rtsd #%1 */",
4354 op[0]);
4356 SYNTAX("rtsd #%1");
4357 #line 381 "rx-decode.opc"
4358 ID(rtsd); SC(IMM(1) * 4);
4361 break;
4362 case 0x68:
4363 GETBYTE ();
4364 switch (op[1] & 0x00)
4366 case 0x00:
4367 op_semantics_27:
4369 /** 0110 100i mmmm rdst shlr #%2, %0 */
4370 #line 660 "rx-decode.opc"
4371 int i AU = op[0] & 0x01;
4372 #line 660 "rx-decode.opc"
4373 int mmmm AU = (op[1] >> 4) & 0x0f;
4374 #line 660 "rx-decode.opc"
4375 int rdst AU = op[1] & 0x0f;
4376 if (trace)
4378 printf ("\033[33m%s\033[0m %02x %02x\n",
4379 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4380 op[0], op[1]);
4381 printf (" i = 0x%x,", i);
4382 printf (" mmmm = 0x%x,", mmmm);
4383 printf (" rdst = 0x%x\n", rdst);
4385 SYNTAX("shlr #%2, %0");
4386 #line 660 "rx-decode.opc"
4387 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("-SZC");
4390 break;
4392 break;
4393 case 0x69:
4394 GETBYTE ();
4395 switch (op[1] & 0x00)
4397 case 0x00:
4398 goto op_semantics_27;
4399 break;
4401 break;
4402 case 0x6a:
4403 GETBYTE ();
4404 switch (op[1] & 0x00)
4406 case 0x00:
4407 op_semantics_28:
4409 /** 0110 101i mmmm rdst shar #%2, %0 */
4410 #line 650 "rx-decode.opc"
4411 int i AU = op[0] & 0x01;
4412 #line 650 "rx-decode.opc"
4413 int mmmm AU = (op[1] >> 4) & 0x0f;
4414 #line 650 "rx-decode.opc"
4415 int rdst AU = op[1] & 0x0f;
4416 if (trace)
4418 printf ("\033[33m%s\033[0m %02x %02x\n",
4419 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4420 op[0], op[1]);
4421 printf (" i = 0x%x,", i);
4422 printf (" mmmm = 0x%x,", mmmm);
4423 printf (" rdst = 0x%x\n", rdst);
4425 SYNTAX("shar #%2, %0");
4426 #line 650 "rx-decode.opc"
4427 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("0SZC");
4430 break;
4432 break;
4433 case 0x6b:
4434 GETBYTE ();
4435 switch (op[1] & 0x00)
4437 case 0x00:
4438 goto op_semantics_28;
4439 break;
4441 break;
4442 case 0x6c:
4443 GETBYTE ();
4444 switch (op[1] & 0x00)
4446 case 0x00:
4447 op_semantics_29:
4449 /** 0110 110i mmmm rdst shll #%2, %0 */
4450 #line 640 "rx-decode.opc"
4451 int i AU = op[0] & 0x01;
4452 #line 640 "rx-decode.opc"
4453 int mmmm AU = (op[1] >> 4) & 0x0f;
4454 #line 640 "rx-decode.opc"
4455 int rdst AU = op[1] & 0x0f;
4456 if (trace)
4458 printf ("\033[33m%s\033[0m %02x %02x\n",
4459 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4460 op[0], op[1]);
4461 printf (" i = 0x%x,", i);
4462 printf (" mmmm = 0x%x,", mmmm);
4463 printf (" rdst = 0x%x\n", rdst);
4465 SYNTAX("shll #%2, %0");
4466 #line 640 "rx-decode.opc"
4467 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("OSZC");
4470 break;
4472 break;
4473 case 0x6d:
4474 GETBYTE ();
4475 switch (op[1] & 0x00)
4477 case 0x00:
4478 goto op_semantics_29;
4479 break;
4481 break;
4482 case 0x6e:
4483 GETBYTE ();
4484 switch (op[1] & 0x00)
4486 case 0x00:
4488 /** 0110 1110 dsta dstb pushm %1-%2 */
4489 #line 348 "rx-decode.opc"
4490 int dsta AU = (op[1] >> 4) & 0x0f;
4491 #line 348 "rx-decode.opc"
4492 int dstb AU = op[1] & 0x0f;
4493 if (trace)
4495 printf ("\033[33m%s\033[0m %02x %02x\n",
4496 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4497 op[0], op[1]);
4498 printf (" dsta = 0x%x,", dsta);
4499 printf (" dstb = 0x%x\n", dstb);
4501 SYNTAX("pushm %1-%2");
4502 #line 348 "rx-decode.opc"
4503 ID(pushm); SR(dsta); S2R(dstb); F("----");
4506 break;
4508 break;
4509 case 0x6f:
4510 GETBYTE ();
4511 switch (op[1] & 0x00)
4513 case 0x00:
4515 /** 0110 1111 dsta dstb popm %1-%2 */
4516 #line 345 "rx-decode.opc"
4517 int dsta AU = (op[1] >> 4) & 0x0f;
4518 #line 345 "rx-decode.opc"
4519 int dstb AU = op[1] & 0x0f;
4520 if (trace)
4522 printf ("\033[33m%s\033[0m %02x %02x\n",
4523 "/** 0110 1111 dsta dstb popm %1-%2 */",
4524 op[0], op[1]);
4525 printf (" dsta = 0x%x,", dsta);
4526 printf (" dstb = 0x%x\n", dstb);
4528 SYNTAX("popm %1-%2");
4529 #line 345 "rx-decode.opc"
4530 ID(popm); SR(dsta); S2R(dstb); F("----");
4533 break;
4535 break;
4536 case 0x70:
4537 GETBYTE ();
4538 switch (op[1] & 0x00)
4540 case 0x00:
4541 op_semantics_30:
4543 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4544 #line 489 "rx-decode.opc"
4545 int im AU = op[0] & 0x03;
4546 #line 489 "rx-decode.opc"
4547 int rsrc AU = (op[1] >> 4) & 0x0f;
4548 #line 489 "rx-decode.opc"
4549 int rdst AU = op[1] & 0x0f;
4550 if (trace)
4552 printf ("\033[33m%s\033[0m %02x %02x\n",
4553 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4554 op[0], op[1]);
4555 printf (" im = 0x%x,", im);
4556 printf (" rsrc = 0x%x,", rsrc);
4557 printf (" rdst = 0x%x\n", rdst);
4559 SYNTAX("add #%1, %2, %0");
4560 #line 489 "rx-decode.opc"
4561 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F("OSZC");
4564 break;
4566 break;
4567 case 0x71:
4568 GETBYTE ();
4569 switch (op[1] & 0x00)
4571 case 0x00:
4572 goto op_semantics_30;
4573 break;
4575 break;
4576 case 0x72:
4577 GETBYTE ();
4578 switch (op[1] & 0x00)
4580 case 0x00:
4581 goto op_semantics_30;
4582 break;
4584 break;
4585 case 0x73:
4586 GETBYTE ();
4587 switch (op[1] & 0x00)
4589 case 0x00:
4590 goto op_semantics_30;
4591 break;
4593 break;
4594 case 0x74:
4595 GETBYTE ();
4596 switch (op[1] & 0xf0)
4598 case 0x00:
4599 op_semantics_31:
4601 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4602 #line 501 "rx-decode.opc"
4603 int im AU = op[0] & 0x03;
4604 #line 501 "rx-decode.opc"
4605 int rsrc AU = op[1] & 0x0f;
4606 if (trace)
4608 printf ("\033[33m%s\033[0m %02x %02x\n",
4609 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4610 op[0], op[1]);
4611 printf (" im = 0x%x,", im);
4612 printf (" rsrc = 0x%x\n", rsrc);
4614 SYNTAX("cmp #%2, %1%S1");
4615 #line 501 "rx-decode.opc"
4616 ID(sub); SR(rsrc); S2C(IMMex(im)); F("OSZC");
4619 break;
4620 case 0x10:
4621 op_semantics_32:
4623 /** 0111 01im 0001rdst mul #%1, %0 */
4624 #line 577 "rx-decode.opc"
4625 int im AU = op[0] & 0x03;
4626 #line 577 "rx-decode.opc"
4627 int rdst AU = op[1] & 0x0f;
4628 if (trace)
4630 printf ("\033[33m%s\033[0m %02x %02x\n",
4631 "/** 0111 01im 0001rdst mul #%1, %0 */",
4632 op[0], op[1]);
4633 printf (" im = 0x%x,", im);
4634 printf (" rdst = 0x%x\n", rdst);
4636 SYNTAX("mul #%1, %0");
4637 #line 577 "rx-decode.opc"
4638 ID(mul); DR(rdst); SC(IMMex(im)); F("----");
4641 break;
4642 case 0x20:
4643 op_semantics_33:
4645 /** 0111 01im 0010 rdst and #%1, %0 */
4646 #line 393 "rx-decode.opc"
4647 int im AU = op[0] & 0x03;
4648 #line 393 "rx-decode.opc"
4649 int rdst AU = op[1] & 0x0f;
4650 if (trace)
4652 printf ("\033[33m%s\033[0m %02x %02x\n",
4653 "/** 0111 01im 0010 rdst and #%1, %0 */",
4654 op[0], op[1]);
4655 printf (" im = 0x%x,", im);
4656 printf (" rdst = 0x%x\n", rdst);
4658 SYNTAX("and #%1, %0");
4659 #line 393 "rx-decode.opc"
4660 ID(and); SC(IMMex(im)); DR(rdst); F("-SZ-");
4663 break;
4664 case 0x30:
4665 op_semantics_34:
4667 /** 0111 01im 0011 rdst or #%1, %0 */
4668 #line 411 "rx-decode.opc"
4669 int im AU = op[0] & 0x03;
4670 #line 411 "rx-decode.opc"
4671 int rdst AU = op[1] & 0x0f;
4672 if (trace)
4674 printf ("\033[33m%s\033[0m %02x %02x\n",
4675 "/** 0111 01im 0011 rdst or #%1, %0 */",
4676 op[0], op[1]);
4677 printf (" im = 0x%x,", im);
4678 printf (" rdst = 0x%x\n", rdst);
4680 SYNTAX("or #%1, %0");
4681 #line 411 "rx-decode.opc"
4682 ID(or); SC(IMMex(im)); DR(rdst); F("-SZ-");
4685 break;
4686 default: UNSUPPORTED(); break;
4688 break;
4689 case 0x75:
4690 GETBYTE ();
4691 switch (op[1] & 0xff)
4693 case 0x00:
4694 case 0x01:
4695 case 0x02:
4696 case 0x03:
4697 case 0x04:
4698 case 0x05:
4699 case 0x06:
4700 case 0x07:
4701 case 0x08:
4702 case 0x09:
4703 case 0x0a:
4704 case 0x0b:
4705 case 0x0c:
4706 case 0x0d:
4707 case 0x0e:
4708 case 0x0f:
4709 goto op_semantics_31;
4710 break;
4711 case 0x10:
4712 case 0x11:
4713 case 0x12:
4714 case 0x13:
4715 case 0x14:
4716 case 0x15:
4717 case 0x16:
4718 case 0x17:
4719 case 0x18:
4720 case 0x19:
4721 case 0x1a:
4722 case 0x1b:
4723 case 0x1c:
4724 case 0x1d:
4725 case 0x1e:
4726 case 0x1f:
4727 goto op_semantics_32;
4728 break;
4729 case 0x20:
4730 case 0x21:
4731 case 0x22:
4732 case 0x23:
4733 case 0x24:
4734 case 0x25:
4735 case 0x26:
4736 case 0x27:
4737 case 0x28:
4738 case 0x29:
4739 case 0x2a:
4740 case 0x2b:
4741 case 0x2c:
4742 case 0x2d:
4743 case 0x2e:
4744 case 0x2f:
4745 goto op_semantics_33;
4746 break;
4747 case 0x30:
4748 case 0x31:
4749 case 0x32:
4750 case 0x33:
4751 case 0x34:
4752 case 0x35:
4753 case 0x36:
4754 case 0x37:
4755 case 0x38:
4756 case 0x39:
4757 case 0x3a:
4758 case 0x3b:
4759 case 0x3c:
4760 case 0x3d:
4761 case 0x3e:
4762 case 0x3f:
4763 goto op_semantics_34;
4764 break;
4765 case 0x40:
4766 case 0x41:
4767 case 0x42:
4768 case 0x43:
4769 case 0x44:
4770 case 0x45:
4771 case 0x46:
4772 case 0x47:
4773 case 0x48:
4774 case 0x49:
4775 case 0x4a:
4776 case 0x4b:
4777 case 0x4c:
4778 case 0x4d:
4779 case 0x4e:
4780 case 0x4f:
4782 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4783 #line 286 "rx-decode.opc"
4784 int rdst AU = op[1] & 0x0f;
4785 if (trace)
4787 printf ("\033[33m%s\033[0m %02x %02x\n",
4788 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4789 op[0], op[1]);
4790 printf (" rdst = 0x%x\n", rdst);
4792 SYNTAX("mov%s #%1, %0");
4793 #line 286 "rx-decode.opc"
4794 ID(mov); DR(rdst); SC(IMM (1)); F("----");
4797 break;
4798 case 0x50:
4799 case 0x51:
4800 case 0x52:
4801 case 0x53:
4802 case 0x54:
4803 case 0x55:
4804 case 0x56:
4805 case 0x57:
4806 case 0x58:
4807 case 0x59:
4808 case 0x5a:
4809 case 0x5b:
4810 case 0x5c:
4811 case 0x5d:
4812 case 0x5e:
4813 case 0x5f:
4815 /** 0111 0101 0101 rsrc cmp #%2, %1 */
4816 #line 504 "rx-decode.opc"
4817 int rsrc AU = op[1] & 0x0f;
4818 if (trace)
4820 printf ("\033[33m%s\033[0m %02x %02x\n",
4821 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4822 op[0], op[1]);
4823 printf (" rsrc = 0x%x\n", rsrc);
4825 SYNTAX("cmp #%2, %1");
4826 #line 504 "rx-decode.opc"
4827 ID(sub); SR(rsrc); S2C(IMM(1)); F("OSZC");
4830 break;
4831 case 0x60:
4833 /** 0111 0101 0110 0000 int #%1 */
4834 if (trace)
4836 printf ("\033[33m%s\033[0m %02x %02x\n",
4837 "/** 0111 0101 0110 0000 int #%1 */",
4838 op[0], op[1]);
4840 SYNTAX("int #%1");
4841 #line 957 "rx-decode.opc"
4842 ID(int); SC(IMM(1));
4845 break;
4846 case 0x70:
4847 GETBYTE ();
4848 switch (op[2] & 0xf0)
4850 case 0x00:
4852 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
4853 #line 924 "rx-decode.opc"
4854 int immm AU = op[2] & 0x0f;
4855 if (trace)
4857 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4858 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
4859 op[0], op[1], op[2]);
4860 printf (" immm = 0x%x\n", immm);
4862 SYNTAX("mvtipl #%1");
4863 #line 924 "rx-decode.opc"
4864 ID(mvtipl); SC(immm);
4867 break;
4868 default: UNSUPPORTED(); break;
4870 break;
4871 default: UNSUPPORTED(); break;
4873 break;
4874 case 0x76:
4875 GETBYTE ();
4876 switch (op[1] & 0xf0)
4878 case 0x00:
4879 goto op_semantics_31;
4880 break;
4881 case 0x10:
4882 goto op_semantics_32;
4883 break;
4884 case 0x20:
4885 goto op_semantics_33;
4886 break;
4887 case 0x30:
4888 goto op_semantics_34;
4889 break;
4890 default: UNSUPPORTED(); break;
4892 break;
4893 case 0x77:
4894 GETBYTE ();
4895 switch (op[1] & 0xf0)
4897 case 0x00:
4898 goto op_semantics_31;
4899 break;
4900 case 0x10:
4901 goto op_semantics_32;
4902 break;
4903 case 0x20:
4904 goto op_semantics_33;
4905 break;
4906 case 0x30:
4907 goto op_semantics_34;
4908 break;
4909 default: UNSUPPORTED(); break;
4911 break;
4912 case 0x78:
4913 GETBYTE ();
4914 switch (op[1] & 0x00)
4916 case 0x00:
4917 op_semantics_35:
4919 /** 0111 100b ittt rdst bset #%1, %0 */
4920 #line 875 "rx-decode.opc"
4921 int b AU = op[0] & 0x01;
4922 #line 875 "rx-decode.opc"
4923 int ittt AU = (op[1] >> 4) & 0x0f;
4924 #line 875 "rx-decode.opc"
4925 int rdst AU = op[1] & 0x0f;
4926 if (trace)
4928 printf ("\033[33m%s\033[0m %02x %02x\n",
4929 "/** 0111 100b ittt rdst bset #%1, %0 */",
4930 op[0], op[1]);
4931 printf (" b = 0x%x,", b);
4932 printf (" ittt = 0x%x,", ittt);
4933 printf (" rdst = 0x%x\n", rdst);
4935 SYNTAX("bset #%1, %0");
4936 #line 875 "rx-decode.opc"
4937 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4941 break;
4943 break;
4944 case 0x79:
4945 GETBYTE ();
4946 switch (op[1] & 0x00)
4948 case 0x00:
4949 goto op_semantics_35;
4950 break;
4952 break;
4953 case 0x7a:
4954 GETBYTE ();
4955 switch (op[1] & 0x00)
4957 case 0x00:
4958 op_semantics_36:
4960 /** 0111 101b ittt rdst bclr #%1, %0 */
4961 #line 885 "rx-decode.opc"
4962 int b AU = op[0] & 0x01;
4963 #line 885 "rx-decode.opc"
4964 int ittt AU = (op[1] >> 4) & 0x0f;
4965 #line 885 "rx-decode.opc"
4966 int rdst AU = op[1] & 0x0f;
4967 if (trace)
4969 printf ("\033[33m%s\033[0m %02x %02x\n",
4970 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4971 op[0], op[1]);
4972 printf (" b = 0x%x,", b);
4973 printf (" ittt = 0x%x,", ittt);
4974 printf (" rdst = 0x%x\n", rdst);
4976 SYNTAX("bclr #%1, %0");
4977 #line 885 "rx-decode.opc"
4978 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4982 break;
4984 break;
4985 case 0x7b:
4986 GETBYTE ();
4987 switch (op[1] & 0x00)
4989 case 0x00:
4990 goto op_semantics_36;
4991 break;
4993 break;
4994 case 0x7c:
4995 GETBYTE ();
4996 switch (op[1] & 0x00)
4998 case 0x00:
4999 op_semantics_37:
5001 /** 0111 110b ittt rdst btst #%2, %1 */
5002 #line 895 "rx-decode.opc"
5003 int b AU = op[0] & 0x01;
5004 #line 895 "rx-decode.opc"
5005 int ittt AU = (op[1] >> 4) & 0x0f;
5006 #line 895 "rx-decode.opc"
5007 int rdst AU = op[1] & 0x0f;
5008 if (trace)
5010 printf ("\033[33m%s\033[0m %02x %02x\n",
5011 "/** 0111 110b ittt rdst btst #%2, %1 */",
5012 op[0], op[1]);
5013 printf (" b = 0x%x,", b);
5014 printf (" ittt = 0x%x,", ittt);
5015 printf (" rdst = 0x%x\n", rdst);
5017 SYNTAX("btst #%2, %1");
5018 #line 895 "rx-decode.opc"
5019 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F("--ZC");
5023 break;
5025 break;
5026 case 0x7d:
5027 GETBYTE ();
5028 switch (op[1] & 0x00)
5030 case 0x00:
5031 goto op_semantics_37;
5032 break;
5034 break;
5035 case 0x7e:
5036 GETBYTE ();
5037 switch (op[1] & 0xf0)
5039 case 0x00:
5041 /** 0111 1110 0000 rdst not %0 */
5042 #line 438 "rx-decode.opc"
5043 int rdst AU = op[1] & 0x0f;
5044 if (trace)
5046 printf ("\033[33m%s\033[0m %02x %02x\n",
5047 "/** 0111 1110 0000 rdst not %0 */",
5048 op[0], op[1]);
5049 printf (" rdst = 0x%x\n", rdst);
5051 SYNTAX("not %0");
5052 #line 438 "rx-decode.opc"
5053 ID(xor); DR(rdst); SR(rdst); S2C(~0); F("-SZ-");
5056 break;
5057 case 0x10:
5059 /** 0111 1110 0001 rdst neg %0 */
5060 #line 459 "rx-decode.opc"
5061 int rdst AU = op[1] & 0x0f;
5062 if (trace)
5064 printf ("\033[33m%s\033[0m %02x %02x\n",
5065 "/** 0111 1110 0001 rdst neg %0 */",
5066 op[0], op[1]);
5067 printf (" rdst = 0x%x\n", rdst);
5069 SYNTAX("neg %0");
5070 #line 459 "rx-decode.opc"
5071 ID(sub); DR(rdst); SC(0); S2R(rdst); F("OSZC");
5074 break;
5075 case 0x20:
5077 /** 0111 1110 0010 rdst abs %0 */
5078 #line 541 "rx-decode.opc"
5079 int rdst AU = op[1] & 0x0f;
5080 if (trace)
5082 printf ("\033[33m%s\033[0m %02x %02x\n",
5083 "/** 0111 1110 0010 rdst abs %0 */",
5084 op[0], op[1]);
5085 printf (" rdst = 0x%x\n", rdst);
5087 SYNTAX("abs %0");
5088 #line 541 "rx-decode.opc"
5089 ID(abs); DR(rdst); SR(rdst); F("OSZ-");
5092 break;
5093 case 0x30:
5095 /** 0111 1110 0011 rdst sat %0 */
5096 #line 815 "rx-decode.opc"
5097 int rdst AU = op[1] & 0x0f;
5098 if (trace)
5100 printf ("\033[33m%s\033[0m %02x %02x\n",
5101 "/** 0111 1110 0011 rdst sat %0 */",
5102 op[0], op[1]);
5103 printf (" rdst = 0x%x\n", rdst);
5105 SYNTAX("sat %0");
5106 #line 815 "rx-decode.opc"
5107 ID(sat); DR (rdst);
5110 break;
5111 case 0x40:
5113 /** 0111 1110 0100 rdst rorc %0 */
5114 #line 675 "rx-decode.opc"
5115 int rdst AU = op[1] & 0x0f;
5116 if (trace)
5118 printf ("\033[33m%s\033[0m %02x %02x\n",
5119 "/** 0111 1110 0100 rdst rorc %0 */",
5120 op[0], op[1]);
5121 printf (" rdst = 0x%x\n", rdst);
5123 SYNTAX("rorc %0");
5124 #line 675 "rx-decode.opc"
5125 ID(rorc); DR(rdst); F("-SZC");
5128 break;
5129 case 0x50:
5131 /** 0111 1110 0101 rdst rolc %0 */
5132 #line 672 "rx-decode.opc"
5133 int rdst AU = op[1] & 0x0f;
5134 if (trace)
5136 printf ("\033[33m%s\033[0m %02x %02x\n",
5137 "/** 0111 1110 0101 rdst rolc %0 */",
5138 op[0], op[1]);
5139 printf (" rdst = 0x%x\n", rdst);
5141 SYNTAX("rolc %0");
5142 #line 672 "rx-decode.opc"
5143 ID(rolc); DR(rdst); F("-SZC");
5146 break;
5147 case 0x80:
5148 case 0x90:
5149 case 0xa0:
5151 /** 0111 1110 10sz rsrc push%s %1 */
5152 #line 354 "rx-decode.opc"
5153 int sz AU = (op[1] >> 4) & 0x03;
5154 #line 354 "rx-decode.opc"
5155 int rsrc AU = op[1] & 0x0f;
5156 if (trace)
5158 printf ("\033[33m%s\033[0m %02x %02x\n",
5159 "/** 0111 1110 10sz rsrc push%s %1 */",
5160 op[0], op[1]);
5161 printf (" sz = 0x%x,", sz);
5162 printf (" rsrc = 0x%x\n", rsrc);
5164 SYNTAX("push%s %1");
5165 #line 354 "rx-decode.opc"
5166 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F("----");
5169 break;
5170 case 0xb0:
5172 /** 0111 1110 1011 rdst pop %0 */
5173 #line 351 "rx-decode.opc"
5174 int rdst AU = op[1] & 0x0f;
5175 if (trace)
5177 printf ("\033[33m%s\033[0m %02x %02x\n",
5178 "/** 0111 1110 1011 rdst pop %0 */",
5179 op[0], op[1]);
5180 printf (" rdst = 0x%x\n", rdst);
5182 SYNTAX("pop %0");
5183 #line 351 "rx-decode.opc"
5184 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F("----");
5187 break;
5188 case 0xc0:
5189 case 0xd0:
5191 /** 0111 1110 110 crsrc pushc %1 */
5192 #line 930 "rx-decode.opc"
5193 int crsrc AU = op[1] & 0x1f;
5194 if (trace)
5196 printf ("\033[33m%s\033[0m %02x %02x\n",
5197 "/** 0111 1110 110 crsrc pushc %1 */",
5198 op[0], op[1]);
5199 printf (" crsrc = 0x%x\n", crsrc);
5201 SYNTAX("pushc %1");
5202 #line 930 "rx-decode.opc"
5203 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5206 break;
5207 case 0xe0:
5208 case 0xf0:
5210 /** 0111 1110 111 crdst popc %0 */
5211 #line 927 "rx-decode.opc"
5212 int crdst AU = op[1] & 0x1f;
5213 if (trace)
5215 printf ("\033[33m%s\033[0m %02x %02x\n",
5216 "/** 0111 1110 111 crdst popc %0 */",
5217 op[0], op[1]);
5218 printf (" crdst = 0x%x\n", crdst);
5220 SYNTAX("popc %0");
5221 #line 927 "rx-decode.opc"
5222 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5225 break;
5226 default: UNSUPPORTED(); break;
5228 break;
5229 case 0x7f:
5230 GETBYTE ();
5231 switch (op[1] & 0xff)
5233 case 0x00:
5234 case 0x01:
5235 case 0x02:
5236 case 0x03:
5237 case 0x04:
5238 case 0x05:
5239 case 0x06:
5240 case 0x07:
5241 case 0x08:
5242 case 0x09:
5243 case 0x0a:
5244 case 0x0b:
5245 case 0x0c:
5246 case 0x0d:
5247 case 0x0e:
5248 case 0x0f:
5250 /** 0111 1111 0000 rsrc jmp %0 */
5251 #line 725 "rx-decode.opc"
5252 int rsrc AU = op[1] & 0x0f;
5253 if (trace)
5255 printf ("\033[33m%s\033[0m %02x %02x\n",
5256 "/** 0111 1111 0000 rsrc jmp %0 */",
5257 op[0], op[1]);
5258 printf (" rsrc = 0x%x\n", rsrc);
5260 SYNTAX("jmp %0");
5261 #line 725 "rx-decode.opc"
5262 ID(branch); Scc(RXC_always); DR(rsrc);
5265 break;
5266 case 0x10:
5267 case 0x11:
5268 case 0x12:
5269 case 0x13:
5270 case 0x14:
5271 case 0x15:
5272 case 0x16:
5273 case 0x17:
5274 case 0x18:
5275 case 0x19:
5276 case 0x1a:
5277 case 0x1b:
5278 case 0x1c:
5279 case 0x1d:
5280 case 0x1e:
5281 case 0x1f:
5283 /** 0111 1111 0001 rsrc jsr %0 */
5284 #line 728 "rx-decode.opc"
5285 int rsrc AU = op[1] & 0x0f;
5286 if (trace)
5288 printf ("\033[33m%s\033[0m %02x %02x\n",
5289 "/** 0111 1111 0001 rsrc jsr %0 */",
5290 op[0], op[1]);
5291 printf (" rsrc = 0x%x\n", rsrc);
5293 SYNTAX("jsr %0");
5294 #line 728 "rx-decode.opc"
5295 ID(jsr); DR(rsrc);
5298 break;
5299 case 0x40:
5300 case 0x41:
5301 case 0x42:
5302 case 0x43:
5303 case 0x44:
5304 case 0x45:
5305 case 0x46:
5306 case 0x47:
5307 case 0x48:
5308 case 0x49:
5309 case 0x4a:
5310 case 0x4b:
5311 case 0x4c:
5312 case 0x4d:
5313 case 0x4e:
5314 case 0x4f:
5316 /** 0111 1111 0100 rsrc bra.l %0 */
5317 #line 721 "rx-decode.opc"
5318 int rsrc AU = op[1] & 0x0f;
5319 if (trace)
5321 printf ("\033[33m%s\033[0m %02x %02x\n",
5322 "/** 0111 1111 0100 rsrc bra.l %0 */",
5323 op[0], op[1]);
5324 printf (" rsrc = 0x%x\n", rsrc);
5326 SYNTAX("bra.l %0");
5327 #line 721 "rx-decode.opc"
5328 ID(branchrel); Scc(RXC_always); DR(rsrc);
5332 break;
5333 case 0x50:
5334 case 0x51:
5335 case 0x52:
5336 case 0x53:
5337 case 0x54:
5338 case 0x55:
5339 case 0x56:
5340 case 0x57:
5341 case 0x58:
5342 case 0x59:
5343 case 0x5a:
5344 case 0x5b:
5345 case 0x5c:
5346 case 0x5d:
5347 case 0x5e:
5348 case 0x5f:
5350 /** 0111 1111 0101 rsrc bsr.l %0 */
5351 #line 737 "rx-decode.opc"
5352 int rsrc AU = op[1] & 0x0f;
5353 if (trace)
5355 printf ("\033[33m%s\033[0m %02x %02x\n",
5356 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5357 op[0], op[1]);
5358 printf (" rsrc = 0x%x\n", rsrc);
5360 SYNTAX("bsr.l %0");
5361 #line 737 "rx-decode.opc"
5362 ID(jsrrel); DR(rsrc);
5365 break;
5366 case 0x80:
5367 case 0x81:
5368 case 0x82:
5370 /** 0111 1111 1000 00sz suntil%s */
5371 #line 761 "rx-decode.opc"
5372 int sz AU = op[1] & 0x03;
5373 if (trace)
5375 printf ("\033[33m%s\033[0m %02x %02x\n",
5376 "/** 0111 1111 1000 00sz suntil%s */",
5377 op[0], op[1]);
5378 printf (" sz = 0x%x\n", sz);
5380 SYNTAX("suntil%s");
5381 #line 761 "rx-decode.opc"
5382 ID(suntil); BWL(sz); F("--ZC");
5385 break;
5386 case 0x83:
5388 /** 0111 1111 1000 0011 scmpu */
5389 if (trace)
5391 printf ("\033[33m%s\033[0m %02x %02x\n",
5392 "/** 0111 1111 1000 0011 scmpu */",
5393 op[0], op[1]);
5395 SYNTAX("scmpu");
5396 #line 752 "rx-decode.opc"
5397 ID(scmpu); F("--ZC");
5400 break;
5401 case 0x84:
5402 case 0x85:
5403 case 0x86:
5405 /** 0111 1111 1000 01sz swhile%s */
5406 #line 764 "rx-decode.opc"
5407 int sz AU = op[1] & 0x03;
5408 if (trace)
5410 printf ("\033[33m%s\033[0m %02x %02x\n",
5411 "/** 0111 1111 1000 01sz swhile%s */",
5412 op[0], op[1]);
5413 printf (" sz = 0x%x\n", sz);
5415 SYNTAX("swhile%s");
5416 #line 764 "rx-decode.opc"
5417 ID(swhile); BWL(sz); F("--ZC");
5420 break;
5421 case 0x87:
5423 /** 0111 1111 1000 0111 smovu */
5424 if (trace)
5426 printf ("\033[33m%s\033[0m %02x %02x\n",
5427 "/** 0111 1111 1000 0111 smovu */",
5428 op[0], op[1]);
5430 SYNTAX("smovu");
5431 #line 755 "rx-decode.opc"
5432 ID(smovu);
5435 break;
5436 case 0x88:
5437 case 0x89:
5438 case 0x8a:
5440 /** 0111 1111 1000 10sz sstr%s */
5441 #line 770 "rx-decode.opc"
5442 int sz AU = op[1] & 0x03;
5443 if (trace)
5445 printf ("\033[33m%s\033[0m %02x %02x\n",
5446 "/** 0111 1111 1000 10sz sstr%s */",
5447 op[0], op[1]);
5448 printf (" sz = 0x%x\n", sz);
5450 SYNTAX("sstr%s");
5451 #line 770 "rx-decode.opc"
5452 ID(sstr); BWL(sz);
5454 /*----------------------------------------------------------------------*/
5455 /* RMPA */
5458 break;
5459 case 0x8b:
5461 /** 0111 1111 1000 1011 smovb */
5462 if (trace)
5464 printf ("\033[33m%s\033[0m %02x %02x\n",
5465 "/** 0111 1111 1000 1011 smovb */",
5466 op[0], op[1]);
5468 SYNTAX("smovb");
5469 #line 758 "rx-decode.opc"
5470 ID(smovb);
5473 break;
5474 case 0x8c:
5475 case 0x8d:
5476 case 0x8e:
5478 /** 0111 1111 1000 11sz rmpa%s */
5479 #line 776 "rx-decode.opc"
5480 int sz AU = op[1] & 0x03;
5481 if (trace)
5483 printf ("\033[33m%s\033[0m %02x %02x\n",
5484 "/** 0111 1111 1000 11sz rmpa%s */",
5485 op[0], op[1]);
5486 printf (" sz = 0x%x\n", sz);
5488 SYNTAX("rmpa%s");
5489 #line 776 "rx-decode.opc"
5490 ID(rmpa); BWL(sz); F("OS--");
5492 /*----------------------------------------------------------------------*/
5493 /* HI/LO stuff */
5496 break;
5497 case 0x8f:
5499 /** 0111 1111 1000 1111 smovf */
5500 if (trace)
5502 printf ("\033[33m%s\033[0m %02x %02x\n",
5503 "/** 0111 1111 1000 1111 smovf */",
5504 op[0], op[1]);
5506 SYNTAX("smovf");
5507 #line 767 "rx-decode.opc"
5508 ID(smovf);
5511 break;
5512 case 0x93:
5514 /** 0111 1111 1001 0011 satr */
5515 if (trace)
5517 printf ("\033[33m%s\033[0m %02x %02x\n",
5518 "/** 0111 1111 1001 0011 satr */",
5519 op[0], op[1]);
5521 SYNTAX("satr");
5522 #line 818 "rx-decode.opc"
5523 ID(satr);
5525 /*----------------------------------------------------------------------*/
5526 /* FLOAT */
5529 break;
5530 case 0x94:
5532 /** 0111 1111 1001 0100 rtfi */
5533 if (trace)
5535 printf ("\033[33m%s\033[0m %02x %02x\n",
5536 "/** 0111 1111 1001 0100 rtfi */",
5537 op[0], op[1]);
5539 SYNTAX("rtfi");
5540 #line 945 "rx-decode.opc"
5541 ID(rtfi);
5544 break;
5545 case 0x95:
5547 /** 0111 1111 1001 0101 rte */
5548 if (trace)
5550 printf ("\033[33m%s\033[0m %02x %02x\n",
5551 "/** 0111 1111 1001 0101 rte */",
5552 op[0], op[1]);
5554 SYNTAX("rte");
5555 #line 948 "rx-decode.opc"
5556 ID(rte);
5559 break;
5560 case 0x96:
5562 /** 0111 1111 1001 0110 wait */
5563 if (trace)
5565 printf ("\033[33m%s\033[0m %02x %02x\n",
5566 "/** 0111 1111 1001 0110 wait */",
5567 op[0], op[1]);
5569 SYNTAX("wait");
5570 #line 960 "rx-decode.opc"
5571 ID(wait);
5573 /*----------------------------------------------------------------------*/
5574 /* SCcnd */
5577 break;
5578 case 0xa0:
5579 case 0xa1:
5580 case 0xa2:
5581 case 0xa3:
5582 case 0xa4:
5583 case 0xa5:
5584 case 0xa6:
5585 case 0xa7:
5586 case 0xa8:
5587 case 0xa9:
5588 case 0xaa:
5589 case 0xab:
5590 case 0xac:
5591 case 0xad:
5592 case 0xae:
5593 case 0xaf:
5595 /** 0111 1111 1010 rdst setpsw %0 */
5596 #line 921 "rx-decode.opc"
5597 int rdst AU = op[1] & 0x0f;
5598 if (trace)
5600 printf ("\033[33m%s\033[0m %02x %02x\n",
5601 "/** 0111 1111 1010 rdst setpsw %0 */",
5602 op[0], op[1]);
5603 printf (" rdst = 0x%x\n", rdst);
5605 SYNTAX("setpsw %0");
5606 #line 921 "rx-decode.opc"
5607 ID(setpsw); DF(rdst);
5610 break;
5611 case 0xb0:
5612 case 0xb1:
5613 case 0xb2:
5614 case 0xb3:
5615 case 0xb4:
5616 case 0xb5:
5617 case 0xb6:
5618 case 0xb7:
5619 case 0xb8:
5620 case 0xb9:
5621 case 0xba:
5622 case 0xbb:
5623 case 0xbc:
5624 case 0xbd:
5625 case 0xbe:
5626 case 0xbf:
5628 /** 0111 1111 1011 rdst clrpsw %0 */
5629 #line 918 "rx-decode.opc"
5630 int rdst AU = op[1] & 0x0f;
5631 if (trace)
5633 printf ("\033[33m%s\033[0m %02x %02x\n",
5634 "/** 0111 1111 1011 rdst clrpsw %0 */",
5635 op[0], op[1]);
5636 printf (" rdst = 0x%x\n", rdst);
5638 SYNTAX("clrpsw %0");
5639 #line 918 "rx-decode.opc"
5640 ID(clrpsw); DF(rdst);
5643 break;
5644 default: UNSUPPORTED(); break;
5646 break;
5647 case 0x80:
5648 GETBYTE ();
5649 switch (op[1] & 0x00)
5651 case 0x00:
5652 op_semantics_38:
5654 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5655 #line 312 "rx-decode.opc"
5656 int sz AU = (op[0] >> 4) & 0x03;
5657 #line 312 "rx-decode.opc"
5658 int dsp AU = op[0] & 0x07;
5659 #line 312 "rx-decode.opc"
5660 int a AU = (op[1] >> 7) & 0x01;
5661 #line 312 "rx-decode.opc"
5662 int dst AU = (op[1] >> 4) & 0x07;
5663 #line 312 "rx-decode.opc"
5664 int b AU = (op[1] >> 3) & 0x01;
5665 #line 312 "rx-decode.opc"
5666 int src AU = op[1] & 0x07;
5667 if (trace)
5669 printf ("\033[33m%s\033[0m %02x %02x\n",
5670 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5671 op[0], op[1]);
5672 printf (" sz = 0x%x,", sz);
5673 printf (" dsp = 0x%x,", dsp);
5674 printf (" a = 0x%x,", a);
5675 printf (" dst = 0x%x,", dst);
5676 printf (" b = 0x%x,", b);
5677 printf (" src = 0x%x\n", src);
5679 SYNTAX("mov%s %1, %0");
5680 #line 312 "rx-decode.opc"
5681 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F("----");
5684 break;
5686 break;
5687 case 0x81:
5688 GETBYTE ();
5689 switch (op[1] & 0x00)
5691 case 0x00:
5692 goto op_semantics_38;
5693 break;
5695 break;
5696 case 0x82:
5697 GETBYTE ();
5698 switch (op[1] & 0x00)
5700 case 0x00:
5701 goto op_semantics_38;
5702 break;
5704 break;
5705 case 0x83:
5706 GETBYTE ();
5707 switch (op[1] & 0x00)
5709 case 0x00:
5710 goto op_semantics_38;
5711 break;
5713 break;
5714 case 0x84:
5715 GETBYTE ();
5716 switch (op[1] & 0x00)
5718 case 0x00:
5719 goto op_semantics_38;
5720 break;
5722 break;
5723 case 0x85:
5724 GETBYTE ();
5725 switch (op[1] & 0x00)
5727 case 0x00:
5728 goto op_semantics_38;
5729 break;
5731 break;
5732 case 0x86:
5733 GETBYTE ();
5734 switch (op[1] & 0x00)
5736 case 0x00:
5737 goto op_semantics_38;
5738 break;
5740 break;
5741 case 0x87:
5742 GETBYTE ();
5743 switch (op[1] & 0x00)
5745 case 0x00:
5746 goto op_semantics_38;
5747 break;
5749 break;
5750 case 0x88:
5751 GETBYTE ();
5752 switch (op[1] & 0x00)
5754 case 0x00:
5755 op_semantics_39:
5757 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5758 #line 309 "rx-decode.opc"
5759 int sz AU = (op[0] >> 4) & 0x03;
5760 #line 309 "rx-decode.opc"
5761 int dsp AU = op[0] & 0x07;
5762 #line 309 "rx-decode.opc"
5763 int a AU = (op[1] >> 7) & 0x01;
5764 #line 309 "rx-decode.opc"
5765 int src AU = (op[1] >> 4) & 0x07;
5766 #line 309 "rx-decode.opc"
5767 int b AU = (op[1] >> 3) & 0x01;
5768 #line 309 "rx-decode.opc"
5769 int dst AU = op[1] & 0x07;
5770 if (trace)
5772 printf ("\033[33m%s\033[0m %02x %02x\n",
5773 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5774 op[0], op[1]);
5775 printf (" sz = 0x%x,", sz);
5776 printf (" dsp = 0x%x,", dsp);
5777 printf (" a = 0x%x,", a);
5778 printf (" src = 0x%x,", src);
5779 printf (" b = 0x%x,", b);
5780 printf (" dst = 0x%x\n", dst);
5782 SYNTAX("mov%s %1, %0");
5783 #line 309 "rx-decode.opc"
5784 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F("----");
5787 break;
5789 break;
5790 case 0x89:
5791 GETBYTE ();
5792 switch (op[1] & 0x00)
5794 case 0x00:
5795 goto op_semantics_39;
5796 break;
5798 break;
5799 case 0x8a:
5800 GETBYTE ();
5801 switch (op[1] & 0x00)
5803 case 0x00:
5804 goto op_semantics_39;
5805 break;
5807 break;
5808 case 0x8b:
5809 GETBYTE ();
5810 switch (op[1] & 0x00)
5812 case 0x00:
5813 goto op_semantics_39;
5814 break;
5816 break;
5817 case 0x8c:
5818 GETBYTE ();
5819 switch (op[1] & 0x00)
5821 case 0x00:
5822 goto op_semantics_39;
5823 break;
5825 break;
5826 case 0x8d:
5827 GETBYTE ();
5828 switch (op[1] & 0x00)
5830 case 0x00:
5831 goto op_semantics_39;
5832 break;
5834 break;
5835 case 0x8e:
5836 GETBYTE ();
5837 switch (op[1] & 0x00)
5839 case 0x00:
5840 goto op_semantics_39;
5841 break;
5843 break;
5844 case 0x8f:
5845 GETBYTE ();
5846 switch (op[1] & 0x00)
5848 case 0x00:
5849 goto op_semantics_39;
5850 break;
5852 break;
5853 case 0x90:
5854 GETBYTE ();
5855 switch (op[1] & 0x00)
5857 case 0x00:
5858 goto op_semantics_38;
5859 break;
5861 break;
5862 case 0x91:
5863 GETBYTE ();
5864 switch (op[1] & 0x00)
5866 case 0x00:
5867 goto op_semantics_38;
5868 break;
5870 break;
5871 case 0x92:
5872 GETBYTE ();
5873 switch (op[1] & 0x00)
5875 case 0x00:
5876 goto op_semantics_38;
5877 break;
5879 break;
5880 case 0x93:
5881 GETBYTE ();
5882 switch (op[1] & 0x00)
5884 case 0x00:
5885 goto op_semantics_38;
5886 break;
5888 break;
5889 case 0x94:
5890 GETBYTE ();
5891 switch (op[1] & 0x00)
5893 case 0x00:
5894 goto op_semantics_38;
5895 break;
5897 break;
5898 case 0x95:
5899 GETBYTE ();
5900 switch (op[1] & 0x00)
5902 case 0x00:
5903 goto op_semantics_38;
5904 break;
5906 break;
5907 case 0x96:
5908 GETBYTE ();
5909 switch (op[1] & 0x00)
5911 case 0x00:
5912 goto op_semantics_38;
5913 break;
5915 break;
5916 case 0x97:
5917 GETBYTE ();
5918 switch (op[1] & 0x00)
5920 case 0x00:
5921 goto op_semantics_38;
5922 break;
5924 break;
5925 case 0x98:
5926 GETBYTE ();
5927 switch (op[1] & 0x00)
5929 case 0x00:
5930 goto op_semantics_39;
5931 break;
5933 break;
5934 case 0x99:
5935 GETBYTE ();
5936 switch (op[1] & 0x00)
5938 case 0x00:
5939 goto op_semantics_39;
5940 break;
5942 break;
5943 case 0x9a:
5944 GETBYTE ();
5945 switch (op[1] & 0x00)
5947 case 0x00:
5948 goto op_semantics_39;
5949 break;
5951 break;
5952 case 0x9b:
5953 GETBYTE ();
5954 switch (op[1] & 0x00)
5956 case 0x00:
5957 goto op_semantics_39;
5958 break;
5960 break;
5961 case 0x9c:
5962 GETBYTE ();
5963 switch (op[1] & 0x00)
5965 case 0x00:
5966 goto op_semantics_39;
5967 break;
5969 break;
5970 case 0x9d:
5971 GETBYTE ();
5972 switch (op[1] & 0x00)
5974 case 0x00:
5975 goto op_semantics_39;
5976 break;
5978 break;
5979 case 0x9e:
5980 GETBYTE ();
5981 switch (op[1] & 0x00)
5983 case 0x00:
5984 goto op_semantics_39;
5985 break;
5987 break;
5988 case 0x9f:
5989 GETBYTE ();
5990 switch (op[1] & 0x00)
5992 case 0x00:
5993 goto op_semantics_39;
5994 break;
5996 break;
5997 case 0xa0:
5998 GETBYTE ();
5999 switch (op[1] & 0x00)
6001 case 0x00:
6002 goto op_semantics_38;
6003 break;
6005 break;
6006 case 0xa1:
6007 GETBYTE ();
6008 switch (op[1] & 0x00)
6010 case 0x00:
6011 goto op_semantics_38;
6012 break;
6014 break;
6015 case 0xa2:
6016 GETBYTE ();
6017 switch (op[1] & 0x00)
6019 case 0x00:
6020 goto op_semantics_38;
6021 break;
6023 break;
6024 case 0xa3:
6025 GETBYTE ();
6026 switch (op[1] & 0x00)
6028 case 0x00:
6029 goto op_semantics_38;
6030 break;
6032 break;
6033 case 0xa4:
6034 GETBYTE ();
6035 switch (op[1] & 0x00)
6037 case 0x00:
6038 goto op_semantics_38;
6039 break;
6041 break;
6042 case 0xa5:
6043 GETBYTE ();
6044 switch (op[1] & 0x00)
6046 case 0x00:
6047 goto op_semantics_38;
6048 break;
6050 break;
6051 case 0xa6:
6052 GETBYTE ();
6053 switch (op[1] & 0x00)
6055 case 0x00:
6056 goto op_semantics_38;
6057 break;
6059 break;
6060 case 0xa7:
6061 GETBYTE ();
6062 switch (op[1] & 0x00)
6064 case 0x00:
6065 goto op_semantics_38;
6066 break;
6068 break;
6069 case 0xa8:
6070 GETBYTE ();
6071 switch (op[1] & 0x00)
6073 case 0x00:
6074 goto op_semantics_39;
6075 break;
6077 break;
6078 case 0xa9:
6079 GETBYTE ();
6080 switch (op[1] & 0x00)
6082 case 0x00:
6083 goto op_semantics_39;
6084 break;
6086 break;
6087 case 0xaa:
6088 GETBYTE ();
6089 switch (op[1] & 0x00)
6091 case 0x00:
6092 goto op_semantics_39;
6093 break;
6095 break;
6096 case 0xab:
6097 GETBYTE ();
6098 switch (op[1] & 0x00)
6100 case 0x00:
6101 goto op_semantics_39;
6102 break;
6104 break;
6105 case 0xac:
6106 GETBYTE ();
6107 switch (op[1] & 0x00)
6109 case 0x00:
6110 goto op_semantics_39;
6111 break;
6113 break;
6114 case 0xad:
6115 GETBYTE ();
6116 switch (op[1] & 0x00)
6118 case 0x00:
6119 goto op_semantics_39;
6120 break;
6122 break;
6123 case 0xae:
6124 GETBYTE ();
6125 switch (op[1] & 0x00)
6127 case 0x00:
6128 goto op_semantics_39;
6129 break;
6131 break;
6132 case 0xaf:
6133 GETBYTE ();
6134 switch (op[1] & 0x00)
6136 case 0x00:
6137 goto op_semantics_39;
6138 break;
6140 break;
6141 case 0xb0:
6142 GETBYTE ();
6143 switch (op[1] & 0x00)
6145 case 0x00:
6146 op_semantics_40:
6148 /** 1011 w dsp a src b dst movu%s %1, %0 */
6149 #line 332 "rx-decode.opc"
6150 int w AU = (op[0] >> 3) & 0x01;
6151 #line 332 "rx-decode.opc"
6152 int dsp AU = op[0] & 0x07;
6153 #line 332 "rx-decode.opc"
6154 int a AU = (op[1] >> 7) & 0x01;
6155 #line 332 "rx-decode.opc"
6156 int src AU = (op[1] >> 4) & 0x07;
6157 #line 332 "rx-decode.opc"
6158 int b AU = (op[1] >> 3) & 0x01;
6159 #line 332 "rx-decode.opc"
6160 int dst AU = op[1] & 0x07;
6161 if (trace)
6163 printf ("\033[33m%s\033[0m %02x %02x\n",
6164 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6165 op[0], op[1]);
6166 printf (" w = 0x%x,", w);
6167 printf (" dsp = 0x%x,", dsp);
6168 printf (" a = 0x%x,", a);
6169 printf (" src = 0x%x,", src);
6170 printf (" b = 0x%x,", b);
6171 printf (" dst = 0x%x\n", dst);
6173 SYNTAX("movu%s %1, %0");
6174 #line 332 "rx-decode.opc"
6175 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F("----");
6178 break;
6180 break;
6181 case 0xb1:
6182 GETBYTE ();
6183 switch (op[1] & 0x00)
6185 case 0x00:
6186 goto op_semantics_40;
6187 break;
6189 break;
6190 case 0xb2:
6191 GETBYTE ();
6192 switch (op[1] & 0x00)
6194 case 0x00:
6195 goto op_semantics_40;
6196 break;
6198 break;
6199 case 0xb3:
6200 GETBYTE ();
6201 switch (op[1] & 0x00)
6203 case 0x00:
6204 goto op_semantics_40;
6205 break;
6207 break;
6208 case 0xb4:
6209 GETBYTE ();
6210 switch (op[1] & 0x00)
6212 case 0x00:
6213 goto op_semantics_40;
6214 break;
6216 break;
6217 case 0xb5:
6218 GETBYTE ();
6219 switch (op[1] & 0x00)
6221 case 0x00:
6222 goto op_semantics_40;
6223 break;
6225 break;
6226 case 0xb6:
6227 GETBYTE ();
6228 switch (op[1] & 0x00)
6230 case 0x00:
6231 goto op_semantics_40;
6232 break;
6234 break;
6235 case 0xb7:
6236 GETBYTE ();
6237 switch (op[1] & 0x00)
6239 case 0x00:
6240 goto op_semantics_40;
6241 break;
6243 break;
6244 case 0xb8:
6245 GETBYTE ();
6246 switch (op[1] & 0x00)
6248 case 0x00:
6249 goto op_semantics_40;
6250 break;
6252 break;
6253 case 0xb9:
6254 GETBYTE ();
6255 switch (op[1] & 0x00)
6257 case 0x00:
6258 goto op_semantics_40;
6259 break;
6261 break;
6262 case 0xba:
6263 GETBYTE ();
6264 switch (op[1] & 0x00)
6266 case 0x00:
6267 goto op_semantics_40;
6268 break;
6270 break;
6271 case 0xbb:
6272 GETBYTE ();
6273 switch (op[1] & 0x00)
6275 case 0x00:
6276 goto op_semantics_40;
6277 break;
6279 break;
6280 case 0xbc:
6281 GETBYTE ();
6282 switch (op[1] & 0x00)
6284 case 0x00:
6285 goto op_semantics_40;
6286 break;
6288 break;
6289 case 0xbd:
6290 GETBYTE ();
6291 switch (op[1] & 0x00)
6293 case 0x00:
6294 goto op_semantics_40;
6295 break;
6297 break;
6298 case 0xbe:
6299 GETBYTE ();
6300 switch (op[1] & 0x00)
6302 case 0x00:
6303 goto op_semantics_40;
6304 break;
6306 break;
6307 case 0xbf:
6308 GETBYTE ();
6309 switch (op[1] & 0x00)
6311 case 0x00:
6312 goto op_semantics_40;
6313 break;
6315 break;
6316 case 0xc0:
6317 GETBYTE ();
6318 switch (op[1] & 0x00)
6320 case 0x00:
6321 op_semantics_41:
6323 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6324 #line 298 "rx-decode.opc"
6325 int sz AU = (op[0] >> 4) & 0x03;
6326 #line 298 "rx-decode.opc"
6327 int sd AU = (op[0] >> 2) & 0x03;
6328 #line 298 "rx-decode.opc"
6329 int ss AU = op[0] & 0x03;
6330 #line 298 "rx-decode.opc"
6331 int rsrc AU = (op[1] >> 4) & 0x0f;
6332 #line 298 "rx-decode.opc"
6333 int rdst AU = op[1] & 0x0f;
6334 if (trace)
6336 printf ("\033[33m%s\033[0m %02x %02x\n",
6337 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6338 op[0], op[1]);
6339 printf (" sz = 0x%x,", sz);
6340 printf (" sd = 0x%x,", sd);
6341 printf (" ss = 0x%x,", ss);
6342 printf (" rsrc = 0x%x,", rsrc);
6343 printf (" rdst = 0x%x\n", rdst);
6345 SYNTAX("mov%s %1, %0");
6346 #line 298 "rx-decode.opc"
6347 ID(mov); sBWL(sz); F("----");
6348 if ((ss == 3) && (sd != 3))
6350 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6352 else
6354 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6358 break;
6360 break;
6361 case 0xc1:
6362 GETBYTE ();
6363 switch (op[1] & 0x00)
6365 case 0x00:
6366 goto op_semantics_41;
6367 break;
6369 break;
6370 case 0xc2:
6371 GETBYTE ();
6372 switch (op[1] & 0x00)
6374 case 0x00:
6375 goto op_semantics_41;
6376 break;
6378 break;
6379 case 0xc3:
6380 GETBYTE ();
6381 switch (op[1] & 0x00)
6383 case 0x00:
6384 goto op_semantics_41;
6385 break;
6387 break;
6388 case 0xc4:
6389 GETBYTE ();
6390 switch (op[1] & 0x00)
6392 case 0x00:
6393 goto op_semantics_41;
6394 break;
6396 break;
6397 case 0xc5:
6398 GETBYTE ();
6399 switch (op[1] & 0x00)
6401 case 0x00:
6402 goto op_semantics_41;
6403 break;
6405 break;
6406 case 0xc6:
6407 GETBYTE ();
6408 switch (op[1] & 0x00)
6410 case 0x00:
6411 goto op_semantics_41;
6412 break;
6414 break;
6415 case 0xc7:
6416 GETBYTE ();
6417 switch (op[1] & 0x00)
6419 case 0x00:
6420 goto op_semantics_41;
6421 break;
6423 break;
6424 case 0xc8:
6425 GETBYTE ();
6426 switch (op[1] & 0x00)
6428 case 0x00:
6429 goto op_semantics_41;
6430 break;
6432 break;
6433 case 0xc9:
6434 GETBYTE ();
6435 switch (op[1] & 0x00)
6437 case 0x00:
6438 goto op_semantics_41;
6439 break;
6441 break;
6442 case 0xca:
6443 GETBYTE ();
6444 switch (op[1] & 0x00)
6446 case 0x00:
6447 goto op_semantics_41;
6448 break;
6450 break;
6451 case 0xcb:
6452 GETBYTE ();
6453 switch (op[1] & 0x00)
6455 case 0x00:
6456 goto op_semantics_41;
6457 break;
6459 break;
6460 case 0xcc:
6461 GETBYTE ();
6462 switch (op[1] & 0x00)
6464 case 0x00:
6465 goto op_semantics_41;
6466 break;
6468 break;
6469 case 0xcd:
6470 GETBYTE ();
6471 switch (op[1] & 0x00)
6473 case 0x00:
6474 goto op_semantics_41;
6475 break;
6477 break;
6478 case 0xce:
6479 GETBYTE ();
6480 switch (op[1] & 0x00)
6482 case 0x00:
6483 goto op_semantics_41;
6484 break;
6486 break;
6487 case 0xcf:
6488 GETBYTE ();
6489 switch (op[1] & 0x00)
6491 case 0x00:
6492 goto op_semantics_41;
6493 break;
6495 break;
6496 case 0xd0:
6497 GETBYTE ();
6498 switch (op[1] & 0x00)
6500 case 0x00:
6501 goto op_semantics_41;
6502 break;
6504 break;
6505 case 0xd1:
6506 GETBYTE ();
6507 switch (op[1] & 0x00)
6509 case 0x00:
6510 goto op_semantics_41;
6511 break;
6513 break;
6514 case 0xd2:
6515 GETBYTE ();
6516 switch (op[1] & 0x00)
6518 case 0x00:
6519 goto op_semantics_41;
6520 break;
6522 break;
6523 case 0xd3:
6524 GETBYTE ();
6525 switch (op[1] & 0x00)
6527 case 0x00:
6528 goto op_semantics_41;
6529 break;
6531 break;
6532 case 0xd4:
6533 GETBYTE ();
6534 switch (op[1] & 0x00)
6536 case 0x00:
6537 goto op_semantics_41;
6538 break;
6540 break;
6541 case 0xd5:
6542 GETBYTE ();
6543 switch (op[1] & 0x00)
6545 case 0x00:
6546 goto op_semantics_41;
6547 break;
6549 break;
6550 case 0xd6:
6551 GETBYTE ();
6552 switch (op[1] & 0x00)
6554 case 0x00:
6555 goto op_semantics_41;
6556 break;
6558 break;
6559 case 0xd7:
6560 GETBYTE ();
6561 switch (op[1] & 0x00)
6563 case 0x00:
6564 goto op_semantics_41;
6565 break;
6567 break;
6568 case 0xd8:
6569 GETBYTE ();
6570 switch (op[1] & 0x00)
6572 case 0x00:
6573 goto op_semantics_41;
6574 break;
6576 break;
6577 case 0xd9:
6578 GETBYTE ();
6579 switch (op[1] & 0x00)
6581 case 0x00:
6582 goto op_semantics_41;
6583 break;
6585 break;
6586 case 0xda:
6587 GETBYTE ();
6588 switch (op[1] & 0x00)
6590 case 0x00:
6591 goto op_semantics_41;
6592 break;
6594 break;
6595 case 0xdb:
6596 GETBYTE ();
6597 switch (op[1] & 0x00)
6599 case 0x00:
6600 goto op_semantics_41;
6601 break;
6603 break;
6604 case 0xdc:
6605 GETBYTE ();
6606 switch (op[1] & 0x00)
6608 case 0x00:
6609 goto op_semantics_41;
6610 break;
6612 break;
6613 case 0xdd:
6614 GETBYTE ();
6615 switch (op[1] & 0x00)
6617 case 0x00:
6618 goto op_semantics_41;
6619 break;
6621 break;
6622 case 0xde:
6623 GETBYTE ();
6624 switch (op[1] & 0x00)
6626 case 0x00:
6627 goto op_semantics_41;
6628 break;
6630 break;
6631 case 0xdf:
6632 GETBYTE ();
6633 switch (op[1] & 0x00)
6635 case 0x00:
6636 goto op_semantics_41;
6637 break;
6639 break;
6640 case 0xe0:
6641 GETBYTE ();
6642 switch (op[1] & 0x00)
6644 case 0x00:
6645 goto op_semantics_41;
6646 break;
6648 break;
6649 case 0xe1:
6650 GETBYTE ();
6651 switch (op[1] & 0x00)
6653 case 0x00:
6654 goto op_semantics_41;
6655 break;
6657 break;
6658 case 0xe2:
6659 GETBYTE ();
6660 switch (op[1] & 0x00)
6662 case 0x00:
6663 goto op_semantics_41;
6664 break;
6666 break;
6667 case 0xe3:
6668 GETBYTE ();
6669 switch (op[1] & 0x00)
6671 case 0x00:
6672 goto op_semantics_41;
6673 break;
6675 break;
6676 case 0xe4:
6677 GETBYTE ();
6678 switch (op[1] & 0x00)
6680 case 0x00:
6681 goto op_semantics_41;
6682 break;
6684 break;
6685 case 0xe5:
6686 GETBYTE ();
6687 switch (op[1] & 0x00)
6689 case 0x00:
6690 goto op_semantics_41;
6691 break;
6693 break;
6694 case 0xe6:
6695 GETBYTE ();
6696 switch (op[1] & 0x00)
6698 case 0x00:
6699 goto op_semantics_41;
6700 break;
6702 break;
6703 case 0xe7:
6704 GETBYTE ();
6705 switch (op[1] & 0x00)
6707 case 0x00:
6708 goto op_semantics_41;
6709 break;
6711 break;
6712 case 0xe8:
6713 GETBYTE ();
6714 switch (op[1] & 0x00)
6716 case 0x00:
6717 goto op_semantics_41;
6718 break;
6720 break;
6721 case 0xe9:
6722 GETBYTE ();
6723 switch (op[1] & 0x00)
6725 case 0x00:
6726 goto op_semantics_41;
6727 break;
6729 break;
6730 case 0xea:
6731 GETBYTE ();
6732 switch (op[1] & 0x00)
6734 case 0x00:
6735 goto op_semantics_41;
6736 break;
6738 break;
6739 case 0xeb:
6740 GETBYTE ();
6741 switch (op[1] & 0x00)
6743 case 0x00:
6744 goto op_semantics_41;
6745 break;
6747 break;
6748 case 0xec:
6749 GETBYTE ();
6750 switch (op[1] & 0x00)
6752 case 0x00:
6753 goto op_semantics_41;
6754 break;
6756 break;
6757 case 0xed:
6758 GETBYTE ();
6759 switch (op[1] & 0x00)
6761 case 0x00:
6762 goto op_semantics_41;
6763 break;
6765 break;
6766 case 0xee:
6767 GETBYTE ();
6768 switch (op[1] & 0x00)
6770 case 0x00:
6771 goto op_semantics_41;
6772 break;
6774 break;
6775 case 0xef:
6776 GETBYTE ();
6777 switch (op[1] & 0x00)
6779 case 0x00:
6780 goto op_semantics_41;
6781 break;
6783 break;
6784 case 0xf0:
6785 GETBYTE ();
6786 switch (op[1] & 0x08)
6788 case 0x00:
6789 op_semantics_42:
6791 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
6792 #line 869 "rx-decode.opc"
6793 int sd AU = op[0] & 0x03;
6794 #line 869 "rx-decode.opc"
6795 int rdst AU = (op[1] >> 4) & 0x0f;
6796 #line 869 "rx-decode.opc"
6797 int bit AU = op[1] & 0x07;
6798 if (trace)
6800 printf ("\033[33m%s\033[0m %02x %02x\n",
6801 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6802 op[0], op[1]);
6803 printf (" sd = 0x%x,", sd);
6804 printf (" rdst = 0x%x,", rdst);
6805 printf (" bit = 0x%x\n", bit);
6807 SYNTAX("bset #%1, %0%S0");
6808 #line 869 "rx-decode.opc"
6809 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6812 break;
6813 case 0x08:
6814 op_semantics_43:
6816 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
6817 #line 879 "rx-decode.opc"
6818 int sd AU = op[0] & 0x03;
6819 #line 879 "rx-decode.opc"
6820 int rdst AU = (op[1] >> 4) & 0x0f;
6821 #line 879 "rx-decode.opc"
6822 int bit AU = op[1] & 0x07;
6823 if (trace)
6825 printf ("\033[33m%s\033[0m %02x %02x\n",
6826 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6827 op[0], op[1]);
6828 printf (" sd = 0x%x,", sd);
6829 printf (" rdst = 0x%x,", rdst);
6830 printf (" bit = 0x%x\n", bit);
6832 SYNTAX("bclr #%1, %0%S0");
6833 #line 879 "rx-decode.opc"
6834 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6837 break;
6839 break;
6840 case 0xf1:
6841 GETBYTE ();
6842 switch (op[1] & 0x08)
6844 case 0x00:
6845 goto op_semantics_42;
6846 break;
6847 case 0x08:
6848 goto op_semantics_43;
6849 break;
6851 break;
6852 case 0xf2:
6853 GETBYTE ();
6854 switch (op[1] & 0x08)
6856 case 0x00:
6857 goto op_semantics_42;
6858 break;
6859 case 0x08:
6860 goto op_semantics_43;
6861 break;
6863 break;
6864 case 0xf3:
6865 GETBYTE ();
6866 switch (op[1] & 0x08)
6868 case 0x00:
6869 goto op_semantics_42;
6870 break;
6871 case 0x08:
6872 goto op_semantics_43;
6873 break;
6875 break;
6876 case 0xf4:
6877 GETBYTE ();
6878 switch (op[1] & 0x0c)
6880 case 0x00:
6881 case 0x04:
6882 op_semantics_44:
6884 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
6885 #line 889 "rx-decode.opc"
6886 int sd AU = op[0] & 0x03;
6887 #line 889 "rx-decode.opc"
6888 int rdst AU = (op[1] >> 4) & 0x0f;
6889 #line 889 "rx-decode.opc"
6890 int bit AU = op[1] & 0x07;
6891 if (trace)
6893 printf ("\033[33m%s\033[0m %02x %02x\n",
6894 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6895 op[0], op[1]);
6896 printf (" sd = 0x%x,", sd);
6897 printf (" rdst = 0x%x,", rdst);
6898 printf (" bit = 0x%x\n", bit);
6900 SYNTAX("btst #%2, %1%S1");
6901 #line 889 "rx-decode.opc"
6902 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F("--ZC");
6905 break;
6906 case 0x08:
6907 op_semantics_45:
6909 /** 1111 01ss rsrc 10sz push%s %1 */
6910 #line 357 "rx-decode.opc"
6911 int ss AU = op[0] & 0x03;
6912 #line 357 "rx-decode.opc"
6913 int rsrc AU = (op[1] >> 4) & 0x0f;
6914 #line 357 "rx-decode.opc"
6915 int sz AU = op[1] & 0x03;
6916 if (trace)
6918 printf ("\033[33m%s\033[0m %02x %02x\n",
6919 "/** 1111 01ss rsrc 10sz push%s %1 */",
6920 op[0], op[1]);
6921 printf (" ss = 0x%x,", ss);
6922 printf (" rsrc = 0x%x,", rsrc);
6923 printf (" sz = 0x%x\n", sz);
6925 SYNTAX("push%s %1");
6926 #line 357 "rx-decode.opc"
6927 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F("----");
6929 /*----------------------------------------------------------------------*/
6930 /* XCHG */
6933 break;
6934 default: UNSUPPORTED(); break;
6936 break;
6937 case 0xf5:
6938 GETBYTE ();
6939 switch (op[1] & 0x0c)
6941 case 0x00:
6942 case 0x04:
6943 goto op_semantics_44;
6944 break;
6945 case 0x08:
6946 goto op_semantics_45;
6947 break;
6948 default: UNSUPPORTED(); break;
6950 break;
6951 case 0xf6:
6952 GETBYTE ();
6953 switch (op[1] & 0x0c)
6955 case 0x00:
6956 case 0x04:
6957 goto op_semantics_44;
6958 break;
6959 case 0x08:
6960 goto op_semantics_45;
6961 break;
6962 default: UNSUPPORTED(); break;
6964 break;
6965 case 0xf7:
6966 GETBYTE ();
6967 switch (op[1] & 0x0c)
6969 case 0x00:
6970 case 0x04:
6971 goto op_semantics_44;
6972 break;
6973 case 0x08:
6974 goto op_semantics_45;
6975 break;
6976 default: UNSUPPORTED(); break;
6978 break;
6979 case 0xf8:
6980 GETBYTE ();
6981 switch (op[1] & 0x00)
6983 case 0x00:
6984 op_semantics_46:
6986 /** 1111 10sd rdst im sz mov%s #%1, %0 */
6987 #line 289 "rx-decode.opc"
6988 int sd AU = op[0] & 0x03;
6989 #line 289 "rx-decode.opc"
6990 int rdst AU = (op[1] >> 4) & 0x0f;
6991 #line 289 "rx-decode.opc"
6992 int im AU = (op[1] >> 2) & 0x03;
6993 #line 289 "rx-decode.opc"
6994 int sz AU = op[1] & 0x03;
6995 if (trace)
6997 printf ("\033[33m%s\033[0m %02x %02x\n",
6998 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
6999 op[0], op[1]);
7000 printf (" sd = 0x%x,", sd);
7001 printf (" rdst = 0x%x,", rdst);
7002 printf (" im = 0x%x,", im);
7003 printf (" sz = 0x%x\n", sz);
7005 SYNTAX("mov%s #%1, %0");
7006 #line 289 "rx-decode.opc"
7007 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F("----");
7010 break;
7012 break;
7013 case 0xf9:
7014 GETBYTE ();
7015 switch (op[1] & 0x00)
7017 case 0x00:
7018 goto op_semantics_46;
7019 break;
7021 break;
7022 case 0xfa:
7023 GETBYTE ();
7024 switch (op[1] & 0x00)
7026 case 0x00:
7027 goto op_semantics_46;
7028 break;
7030 break;
7031 case 0xfb:
7032 GETBYTE ();
7033 switch (op[1] & 0x00)
7035 case 0x00:
7036 goto op_semantics_46;
7037 break;
7039 break;
7040 case 0xfc:
7041 GETBYTE ();
7042 switch (op[1] & 0xff)
7044 case 0x03:
7045 GETBYTE ();
7046 switch (op[2] & 0x00)
7048 case 0x00:
7050 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7051 #line 531 "rx-decode.opc"
7052 int rsrc AU = (op[2] >> 4) & 0x0f;
7053 #line 531 "rx-decode.opc"
7054 int rdst AU = op[2] & 0x0f;
7055 if (trace)
7057 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7058 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7059 op[0], op[1], op[2]);
7060 printf (" rsrc = 0x%x,", rsrc);
7061 printf (" rdst = 0x%x\n", rdst);
7063 SYNTAX("sbb %1, %0");
7064 #line 531 "rx-decode.opc"
7065 ID(sbb); SR (rsrc); DR(rdst); F("OSZC");
7067 /* FIXME: only supports .L */
7069 break;
7071 break;
7072 case 0x07:
7073 GETBYTE ();
7074 switch (op[2] & 0x00)
7076 case 0x00:
7078 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7079 #line 462 "rx-decode.opc"
7080 int rsrc AU = (op[2] >> 4) & 0x0f;
7081 #line 462 "rx-decode.opc"
7082 int rdst AU = op[2] & 0x0f;
7083 if (trace)
7085 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7086 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7087 op[0], op[1], op[2]);
7088 printf (" rsrc = 0x%x,", rsrc);
7089 printf (" rdst = 0x%x\n", rdst);
7091 SYNTAX("neg %2, %0");
7092 #line 462 "rx-decode.opc"
7093 ID(sub); DR(rdst); SC(0); S2R(rsrc); F("OSZC");
7095 /*----------------------------------------------------------------------*/
7096 /* ADC */
7099 break;
7101 break;
7102 case 0x0b:
7103 GETBYTE ();
7104 switch (op[2] & 0x00)
7106 case 0x00:
7108 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7109 #line 471 "rx-decode.opc"
7110 int rsrc AU = (op[2] >> 4) & 0x0f;
7111 #line 471 "rx-decode.opc"
7112 int rdst AU = op[2] & 0x0f;
7113 if (trace)
7115 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7116 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7117 op[0], op[1], op[2]);
7118 printf (" rsrc = 0x%x,", rsrc);
7119 printf (" rdst = 0x%x\n", rdst);
7121 SYNTAX("adc %1, %0");
7122 #line 471 "rx-decode.opc"
7123 ID(adc); SR(rsrc); DR(rdst); F("OSZC");
7126 break;
7128 break;
7129 case 0x0f:
7130 GETBYTE ();
7131 switch (op[2] & 0x00)
7133 case 0x00:
7135 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7136 #line 544 "rx-decode.opc"
7137 int rsrc AU = (op[2] >> 4) & 0x0f;
7138 #line 544 "rx-decode.opc"
7139 int rdst AU = op[2] & 0x0f;
7140 if (trace)
7142 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7143 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7144 op[0], op[1], op[2]);
7145 printf (" rsrc = 0x%x,", rsrc);
7146 printf (" rdst = 0x%x\n", rdst);
7148 SYNTAX("abs %1, %0");
7149 #line 544 "rx-decode.opc"
7150 ID(abs); DR(rdst); SR(rsrc); F("OSZ-");
7152 /*----------------------------------------------------------------------*/
7153 /* MAX */
7156 break;
7158 break;
7159 case 0x10:
7160 GETBYTE ();
7161 switch (op[2] & 0x00)
7163 case 0x00:
7164 op_semantics_47:
7166 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7167 #line 553 "rx-decode.opc"
7168 int ss AU = op[1] & 0x03;
7169 #line 553 "rx-decode.opc"
7170 int rsrc AU = (op[2] >> 4) & 0x0f;
7171 #line 553 "rx-decode.opc"
7172 int rdst AU = op[2] & 0x0f;
7173 if (trace)
7175 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7176 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7177 op[0], op[1], op[2]);
7178 printf (" ss = 0x%x,", ss);
7179 printf (" rsrc = 0x%x,", rsrc);
7180 printf (" rdst = 0x%x\n", rdst);
7182 SYNTAX("max %1%S1, %0");
7183 #line 553 "rx-decode.opc"
7184 ID(max); SP(ss, rsrc); DR(rdst);
7187 break;
7189 break;
7190 case 0x11:
7191 GETBYTE ();
7192 switch (op[2] & 0x00)
7194 case 0x00:
7195 goto op_semantics_47;
7196 break;
7198 break;
7199 case 0x12:
7200 GETBYTE ();
7201 switch (op[2] & 0x00)
7203 case 0x00:
7204 goto op_semantics_47;
7205 break;
7207 break;
7208 case 0x13:
7209 GETBYTE ();
7210 switch (op[2] & 0x00)
7212 case 0x00:
7213 goto op_semantics_47;
7214 break;
7216 break;
7217 case 0x14:
7218 GETBYTE ();
7219 switch (op[2] & 0x00)
7221 case 0x00:
7222 op_semantics_48:
7224 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7225 #line 565 "rx-decode.opc"
7226 int ss AU = op[1] & 0x03;
7227 #line 565 "rx-decode.opc"
7228 int rsrc AU = (op[2] >> 4) & 0x0f;
7229 #line 565 "rx-decode.opc"
7230 int rdst AU = op[2] & 0x0f;
7231 if (trace)
7233 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7234 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7235 op[0], op[1], op[2]);
7236 printf (" ss = 0x%x,", ss);
7237 printf (" rsrc = 0x%x,", rsrc);
7238 printf (" rdst = 0x%x\n", rdst);
7240 SYNTAX("min %1%S1, %0");
7241 #line 565 "rx-decode.opc"
7242 ID(min); SP(ss, rsrc); DR(rdst);
7245 break;
7247 break;
7248 case 0x15:
7249 GETBYTE ();
7250 switch (op[2] & 0x00)
7252 case 0x00:
7253 goto op_semantics_48;
7254 break;
7256 break;
7257 case 0x16:
7258 GETBYTE ();
7259 switch (op[2] & 0x00)
7261 case 0x00:
7262 goto op_semantics_48;
7263 break;
7265 break;
7266 case 0x17:
7267 GETBYTE ();
7268 switch (op[2] & 0x00)
7270 case 0x00:
7271 goto op_semantics_48;
7272 break;
7274 break;
7275 case 0x18:
7276 GETBYTE ();
7277 switch (op[2] & 0x00)
7279 case 0x00:
7280 op_semantics_49:
7282 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7283 #line 595 "rx-decode.opc"
7284 int ss AU = op[1] & 0x03;
7285 #line 595 "rx-decode.opc"
7286 int rsrc AU = (op[2] >> 4) & 0x0f;
7287 #line 595 "rx-decode.opc"
7288 int rdst AU = op[2] & 0x0f;
7289 if (trace)
7291 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7292 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7293 op[0], op[1], op[2]);
7294 printf (" ss = 0x%x,", ss);
7295 printf (" rsrc = 0x%x,", rsrc);
7296 printf (" rdst = 0x%x\n", rdst);
7298 SYNTAX("emul %1%S1, %0");
7299 #line 595 "rx-decode.opc"
7300 ID(emul); SP(ss, rsrc); DR(rdst);
7303 break;
7305 break;
7306 case 0x19:
7307 GETBYTE ();
7308 switch (op[2] & 0x00)
7310 case 0x00:
7311 goto op_semantics_49;
7312 break;
7314 break;
7315 case 0x1a:
7316 GETBYTE ();
7317 switch (op[2] & 0x00)
7319 case 0x00:
7320 goto op_semantics_49;
7321 break;
7323 break;
7324 case 0x1b:
7325 GETBYTE ();
7326 switch (op[2] & 0x00)
7328 case 0x00:
7329 goto op_semantics_49;
7330 break;
7332 break;
7333 case 0x1c:
7334 GETBYTE ();
7335 switch (op[2] & 0x00)
7337 case 0x00:
7338 op_semantics_50:
7340 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7341 #line 607 "rx-decode.opc"
7342 int ss AU = op[1] & 0x03;
7343 #line 607 "rx-decode.opc"
7344 int rsrc AU = (op[2] >> 4) & 0x0f;
7345 #line 607 "rx-decode.opc"
7346 int rdst AU = op[2] & 0x0f;
7347 if (trace)
7349 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7350 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7351 op[0], op[1], op[2]);
7352 printf (" ss = 0x%x,", ss);
7353 printf (" rsrc = 0x%x,", rsrc);
7354 printf (" rdst = 0x%x\n", rdst);
7356 SYNTAX("emulu %1%S1, %0");
7357 #line 607 "rx-decode.opc"
7358 ID(emulu); SP(ss, rsrc); DR(rdst);
7361 break;
7363 break;
7364 case 0x1d:
7365 GETBYTE ();
7366 switch (op[2] & 0x00)
7368 case 0x00:
7369 goto op_semantics_50;
7370 break;
7372 break;
7373 case 0x1e:
7374 GETBYTE ();
7375 switch (op[2] & 0x00)
7377 case 0x00:
7378 goto op_semantics_50;
7379 break;
7381 break;
7382 case 0x1f:
7383 GETBYTE ();
7384 switch (op[2] & 0x00)
7386 case 0x00:
7387 goto op_semantics_50;
7388 break;
7390 break;
7391 case 0x20:
7392 GETBYTE ();
7393 switch (op[2] & 0x00)
7395 case 0x00:
7396 op_semantics_51:
7398 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7399 #line 619 "rx-decode.opc"
7400 int ss AU = op[1] & 0x03;
7401 #line 619 "rx-decode.opc"
7402 int rsrc AU = (op[2] >> 4) & 0x0f;
7403 #line 619 "rx-decode.opc"
7404 int rdst AU = op[2] & 0x0f;
7405 if (trace)
7407 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7408 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7409 op[0], op[1], op[2]);
7410 printf (" ss = 0x%x,", ss);
7411 printf (" rsrc = 0x%x,", rsrc);
7412 printf (" rdst = 0x%x\n", rdst);
7414 SYNTAX("div %1%S1, %0");
7415 #line 619 "rx-decode.opc"
7416 ID(div); SP(ss, rsrc); DR(rdst); F("O---");
7419 break;
7421 break;
7422 case 0x21:
7423 GETBYTE ();
7424 switch (op[2] & 0x00)
7426 case 0x00:
7427 goto op_semantics_51;
7428 break;
7430 break;
7431 case 0x22:
7432 GETBYTE ();
7433 switch (op[2] & 0x00)
7435 case 0x00:
7436 goto op_semantics_51;
7437 break;
7439 break;
7440 case 0x23:
7441 GETBYTE ();
7442 switch (op[2] & 0x00)
7444 case 0x00:
7445 goto op_semantics_51;
7446 break;
7448 break;
7449 case 0x24:
7450 GETBYTE ();
7451 switch (op[2] & 0x00)
7453 case 0x00:
7454 op_semantics_52:
7456 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7457 #line 631 "rx-decode.opc"
7458 int ss AU = op[1] & 0x03;
7459 #line 631 "rx-decode.opc"
7460 int rsrc AU = (op[2] >> 4) & 0x0f;
7461 #line 631 "rx-decode.opc"
7462 int rdst AU = op[2] & 0x0f;
7463 if (trace)
7465 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7466 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7467 op[0], op[1], op[2]);
7468 printf (" ss = 0x%x,", ss);
7469 printf (" rsrc = 0x%x,", rsrc);
7470 printf (" rdst = 0x%x\n", rdst);
7472 SYNTAX("divu %1%S1, %0");
7473 #line 631 "rx-decode.opc"
7474 ID(divu); SP(ss, rsrc); DR(rdst); F("O---");
7477 break;
7479 break;
7480 case 0x25:
7481 GETBYTE ();
7482 switch (op[2] & 0x00)
7484 case 0x00:
7485 goto op_semantics_52;
7486 break;
7488 break;
7489 case 0x26:
7490 GETBYTE ();
7491 switch (op[2] & 0x00)
7493 case 0x00:
7494 goto op_semantics_52;
7495 break;
7497 break;
7498 case 0x27:
7499 GETBYTE ();
7500 switch (op[2] & 0x00)
7502 case 0x00:
7503 goto op_semantics_52;
7504 break;
7506 break;
7507 case 0x30:
7508 GETBYTE ();
7509 switch (op[2] & 0x00)
7511 case 0x00:
7512 op_semantics_53:
7514 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7515 #line 450 "rx-decode.opc"
7516 int ss AU = op[1] & 0x03;
7517 #line 450 "rx-decode.opc"
7518 int rsrc AU = (op[2] >> 4) & 0x0f;
7519 #line 450 "rx-decode.opc"
7520 int rdst AU = op[2] & 0x0f;
7521 if (trace)
7523 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7524 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7525 op[0], op[1], op[2]);
7526 printf (" ss = 0x%x,", ss);
7527 printf (" rsrc = 0x%x,", rsrc);
7528 printf (" rdst = 0x%x\n", rdst);
7530 SYNTAX("tst %1%S1, %2");
7531 #line 450 "rx-decode.opc"
7532 ID(and); SP(ss, rsrc); S2R(rdst); F("-SZ-");
7535 break;
7537 break;
7538 case 0x31:
7539 GETBYTE ();
7540 switch (op[2] & 0x00)
7542 case 0x00:
7543 goto op_semantics_53;
7544 break;
7546 break;
7547 case 0x32:
7548 GETBYTE ();
7549 switch (op[2] & 0x00)
7551 case 0x00:
7552 goto op_semantics_53;
7553 break;
7555 break;
7556 case 0x33:
7557 GETBYTE ();
7558 switch (op[2] & 0x00)
7560 case 0x00:
7561 goto op_semantics_53;
7562 break;
7564 break;
7565 case 0x34:
7566 GETBYTE ();
7567 switch (op[2] & 0x00)
7569 case 0x00:
7570 op_semantics_54:
7572 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7573 #line 429 "rx-decode.opc"
7574 int ss AU = op[1] & 0x03;
7575 #line 429 "rx-decode.opc"
7576 int rsrc AU = (op[2] >> 4) & 0x0f;
7577 #line 429 "rx-decode.opc"
7578 int rdst AU = op[2] & 0x0f;
7579 if (trace)
7581 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7582 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7583 op[0], op[1], op[2]);
7584 printf (" ss = 0x%x,", ss);
7585 printf (" rsrc = 0x%x,", rsrc);
7586 printf (" rdst = 0x%x\n", rdst);
7588 SYNTAX("xor %1%S1, %0");
7589 #line 429 "rx-decode.opc"
7590 ID(xor); SP(ss, rsrc); DR(rdst); F("-SZ-");
7593 break;
7595 break;
7596 case 0x35:
7597 GETBYTE ();
7598 switch (op[2] & 0x00)
7600 case 0x00:
7601 goto op_semantics_54;
7602 break;
7604 break;
7605 case 0x36:
7606 GETBYTE ();
7607 switch (op[2] & 0x00)
7609 case 0x00:
7610 goto op_semantics_54;
7611 break;
7613 break;
7614 case 0x37:
7615 GETBYTE ();
7616 switch (op[2] & 0x00)
7618 case 0x00:
7619 goto op_semantics_54;
7620 break;
7622 break;
7623 case 0x3b:
7624 GETBYTE ();
7625 switch (op[2] & 0x00)
7627 case 0x00:
7629 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7630 #line 441 "rx-decode.opc"
7631 int rsrc AU = (op[2] >> 4) & 0x0f;
7632 #line 441 "rx-decode.opc"
7633 int rdst AU = op[2] & 0x0f;
7634 if (trace)
7636 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7637 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7638 op[0], op[1], op[2]);
7639 printf (" rsrc = 0x%x,", rsrc);
7640 printf (" rdst = 0x%x\n", rdst);
7642 SYNTAX("not %1, %0");
7643 #line 441 "rx-decode.opc"
7644 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F("-SZ-");
7646 /*----------------------------------------------------------------------*/
7647 /* TST */
7650 break;
7652 break;
7653 case 0x40:
7654 GETBYTE ();
7655 switch (op[2] & 0x00)
7657 case 0x00:
7658 op_semantics_55:
7660 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7661 #line 363 "rx-decode.opc"
7662 int ss AU = op[1] & 0x03;
7663 #line 363 "rx-decode.opc"
7664 int rsrc AU = (op[2] >> 4) & 0x0f;
7665 #line 363 "rx-decode.opc"
7666 int rdst AU = op[2] & 0x0f;
7667 if (trace)
7669 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7670 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7671 op[0], op[1], op[2]);
7672 printf (" ss = 0x%x,", ss);
7673 printf (" rsrc = 0x%x,", rsrc);
7674 printf (" rdst = 0x%x\n", rdst);
7676 SYNTAX("xchg %1%S1, %0");
7677 #line 363 "rx-decode.opc"
7678 ID(xchg); DR(rdst); SP(ss, rsrc);
7681 break;
7683 break;
7684 case 0x41:
7685 GETBYTE ();
7686 switch (op[2] & 0x00)
7688 case 0x00:
7689 goto op_semantics_55;
7690 break;
7692 break;
7693 case 0x42:
7694 GETBYTE ();
7695 switch (op[2] & 0x00)
7697 case 0x00:
7698 goto op_semantics_55;
7699 break;
7701 break;
7702 case 0x43:
7703 GETBYTE ();
7704 switch (op[2] & 0x00)
7706 case 0x00:
7707 goto op_semantics_55;
7708 break;
7710 break;
7711 case 0x44:
7712 GETBYTE ();
7713 switch (op[2] & 0x00)
7715 case 0x00:
7716 op_semantics_56:
7718 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7719 #line 860 "rx-decode.opc"
7720 int sd AU = op[1] & 0x03;
7721 #line 860 "rx-decode.opc"
7722 int rsrc AU = (op[2] >> 4) & 0x0f;
7723 #line 860 "rx-decode.opc"
7724 int rdst AU = op[2] & 0x0f;
7725 if (trace)
7727 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7728 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7729 op[0], op[1], op[2]);
7730 printf (" sd = 0x%x,", sd);
7731 printf (" rsrc = 0x%x,", rsrc);
7732 printf (" rdst = 0x%x\n", rdst);
7734 SYNTAX("itof %1%S1, %0");
7735 #line 860 "rx-decode.opc"
7736 ID(itof); DR (rdst); SP(sd, rsrc); F("-SZ-");
7739 break;
7741 break;
7742 case 0x45:
7743 GETBYTE ();
7744 switch (op[2] & 0x00)
7746 case 0x00:
7747 goto op_semantics_56;
7748 break;
7750 break;
7751 case 0x46:
7752 GETBYTE ();
7753 switch (op[2] & 0x00)
7755 case 0x00:
7756 goto op_semantics_56;
7757 break;
7759 break;
7760 case 0x47:
7761 GETBYTE ();
7762 switch (op[2] & 0x00)
7764 case 0x00:
7765 goto op_semantics_56;
7766 break;
7768 break;
7769 case 0x60:
7770 GETBYTE ();
7771 switch (op[2] & 0x00)
7773 case 0x00:
7774 op_semantics_57:
7776 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
7777 #line 872 "rx-decode.opc"
7778 int sd AU = op[1] & 0x03;
7779 #line 872 "rx-decode.opc"
7780 int rdst AU = (op[2] >> 4) & 0x0f;
7781 #line 872 "rx-decode.opc"
7782 int rsrc AU = op[2] & 0x0f;
7783 if (trace)
7785 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7786 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7787 op[0], op[1], op[2]);
7788 printf (" sd = 0x%x,", sd);
7789 printf (" rdst = 0x%x,", rdst);
7790 printf (" rsrc = 0x%x\n", rsrc);
7792 SYNTAX("bset %1, %0%S0");
7793 #line 872 "rx-decode.opc"
7794 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7797 break;
7799 break;
7800 case 0x61:
7801 GETBYTE ();
7802 switch (op[2] & 0x00)
7804 case 0x00:
7805 goto op_semantics_57;
7806 break;
7808 break;
7809 case 0x62:
7810 GETBYTE ();
7811 switch (op[2] & 0x00)
7813 case 0x00:
7814 goto op_semantics_57;
7815 break;
7817 break;
7818 case 0x63:
7819 GETBYTE ();
7820 switch (op[2] & 0x00)
7822 case 0x00:
7823 goto op_semantics_57;
7824 break;
7826 break;
7827 case 0x64:
7828 GETBYTE ();
7829 switch (op[2] & 0x00)
7831 case 0x00:
7832 op_semantics_58:
7834 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
7835 #line 882 "rx-decode.opc"
7836 int sd AU = op[1] & 0x03;
7837 #line 882 "rx-decode.opc"
7838 int rdst AU = (op[2] >> 4) & 0x0f;
7839 #line 882 "rx-decode.opc"
7840 int rsrc AU = op[2] & 0x0f;
7841 if (trace)
7843 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7844 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7845 op[0], op[1], op[2]);
7846 printf (" sd = 0x%x,", sd);
7847 printf (" rdst = 0x%x,", rdst);
7848 printf (" rsrc = 0x%x\n", rsrc);
7850 SYNTAX("bclr %1, %0%S0");
7851 #line 882 "rx-decode.opc"
7852 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7855 break;
7857 break;
7858 case 0x65:
7859 GETBYTE ();
7860 switch (op[2] & 0x00)
7862 case 0x00:
7863 goto op_semantics_58;
7864 break;
7866 break;
7867 case 0x66:
7868 GETBYTE ();
7869 switch (op[2] & 0x00)
7871 case 0x00:
7872 goto op_semantics_58;
7873 break;
7875 break;
7876 case 0x67:
7877 GETBYTE ();
7878 switch (op[2] & 0x00)
7880 case 0x00:
7881 goto op_semantics_58;
7882 break;
7884 break;
7885 case 0x68:
7886 GETBYTE ();
7887 switch (op[2] & 0x00)
7889 case 0x00:
7890 op_semantics_59:
7892 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
7893 #line 892 "rx-decode.opc"
7894 int sd AU = op[1] & 0x03;
7895 #line 892 "rx-decode.opc"
7896 int rdst AU = (op[2] >> 4) & 0x0f;
7897 #line 892 "rx-decode.opc"
7898 int rsrc AU = op[2] & 0x0f;
7899 if (trace)
7901 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7902 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7903 op[0], op[1], op[2]);
7904 printf (" sd = 0x%x,", sd);
7905 printf (" rdst = 0x%x,", rdst);
7906 printf (" rsrc = 0x%x\n", rsrc);
7908 SYNTAX("btst %2, %1%S1");
7909 #line 892 "rx-decode.opc"
7910 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F("--ZC");
7913 break;
7915 break;
7916 case 0x69:
7917 GETBYTE ();
7918 switch (op[2] & 0x00)
7920 case 0x00:
7921 goto op_semantics_59;
7922 break;
7924 break;
7925 case 0x6a:
7926 GETBYTE ();
7927 switch (op[2] & 0x00)
7929 case 0x00:
7930 goto op_semantics_59;
7931 break;
7933 break;
7934 case 0x6b:
7935 GETBYTE ();
7936 switch (op[2] & 0x00)
7938 case 0x00:
7939 goto op_semantics_59;
7940 break;
7942 break;
7943 case 0x6c:
7944 GETBYTE ();
7945 switch (op[2] & 0x00)
7947 case 0x00:
7948 op_semantics_60:
7950 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
7951 #line 902 "rx-decode.opc"
7952 int sd AU = op[1] & 0x03;
7953 #line 902 "rx-decode.opc"
7954 int rdst AU = (op[2] >> 4) & 0x0f;
7955 #line 902 "rx-decode.opc"
7956 int rsrc AU = op[2] & 0x0f;
7957 if (trace)
7959 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7960 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
7961 op[0], op[1], op[2]);
7962 printf (" sd = 0x%x,", sd);
7963 printf (" rdst = 0x%x,", rdst);
7964 printf (" rsrc = 0x%x\n", rsrc);
7966 SYNTAX("bnot %1, %0%S0");
7967 #line 902 "rx-decode.opc"
7968 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7971 break;
7973 break;
7974 case 0x6d:
7975 GETBYTE ();
7976 switch (op[2] & 0x00)
7978 case 0x00:
7979 goto op_semantics_60;
7980 break;
7982 break;
7983 case 0x6e:
7984 GETBYTE ();
7985 switch (op[2] & 0x00)
7987 case 0x00:
7988 goto op_semantics_60;
7989 break;
7991 break;
7992 case 0x6f:
7993 GETBYTE ();
7994 switch (op[2] & 0x00)
7996 case 0x00:
7997 goto op_semantics_60;
7998 break;
8000 break;
8001 case 0x80:
8002 GETBYTE ();
8003 switch (op[2] & 0x00)
8005 case 0x00:
8006 op_semantics_61:
8008 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8009 #line 839 "rx-decode.opc"
8010 int sd AU = op[1] & 0x03;
8011 #line 839 "rx-decode.opc"
8012 int rsrc AU = (op[2] >> 4) & 0x0f;
8013 #line 839 "rx-decode.opc"
8014 int rdst AU = op[2] & 0x0f;
8015 if (trace)
8017 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8018 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8019 op[0], op[1], op[2]);
8020 printf (" sd = 0x%x,", sd);
8021 printf (" rsrc = 0x%x,", rsrc);
8022 printf (" rdst = 0x%x\n", rdst);
8024 SYNTAX("fsub %1%S1, %0");
8025 #line 839 "rx-decode.opc"
8026 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8029 break;
8031 break;
8032 case 0x81:
8033 GETBYTE ();
8034 switch (op[2] & 0x00)
8036 case 0x00:
8037 goto op_semantics_61;
8038 break;
8040 break;
8041 case 0x82:
8042 GETBYTE ();
8043 switch (op[2] & 0x00)
8045 case 0x00:
8046 goto op_semantics_61;
8047 break;
8049 break;
8050 case 0x83:
8051 GETBYTE ();
8052 switch (op[2] & 0x00)
8054 case 0x00:
8055 goto op_semantics_61;
8056 break;
8058 break;
8059 case 0x84:
8060 GETBYTE ();
8061 switch (op[2] & 0x00)
8063 case 0x00:
8064 op_semantics_62:
8066 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8067 #line 833 "rx-decode.opc"
8068 int sd AU = op[1] & 0x03;
8069 #line 833 "rx-decode.opc"
8070 int rsrc AU = (op[2] >> 4) & 0x0f;
8071 #line 833 "rx-decode.opc"
8072 int rdst AU = op[2] & 0x0f;
8073 if (trace)
8075 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8076 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8077 op[0], op[1], op[2]);
8078 printf (" sd = 0x%x,", sd);
8079 printf (" rsrc = 0x%x,", rsrc);
8080 printf (" rdst = 0x%x\n", rdst);
8082 SYNTAX("fcmp %1%S1, %0");
8083 #line 833 "rx-decode.opc"
8084 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F("OSZ-");
8087 break;
8089 break;
8090 case 0x85:
8091 GETBYTE ();
8092 switch (op[2] & 0x00)
8094 case 0x00:
8095 goto op_semantics_62;
8096 break;
8098 break;
8099 case 0x86:
8100 GETBYTE ();
8101 switch (op[2] & 0x00)
8103 case 0x00:
8104 goto op_semantics_62;
8105 break;
8107 break;
8108 case 0x87:
8109 GETBYTE ();
8110 switch (op[2] & 0x00)
8112 case 0x00:
8113 goto op_semantics_62;
8114 break;
8116 break;
8117 case 0x88:
8118 GETBYTE ();
8119 switch (op[2] & 0x00)
8121 case 0x00:
8122 op_semantics_63:
8124 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8125 #line 827 "rx-decode.opc"
8126 int sd AU = op[1] & 0x03;
8127 #line 827 "rx-decode.opc"
8128 int rsrc AU = (op[2] >> 4) & 0x0f;
8129 #line 827 "rx-decode.opc"
8130 int rdst AU = op[2] & 0x0f;
8131 if (trace)
8133 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8134 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8135 op[0], op[1], op[2]);
8136 printf (" sd = 0x%x,", sd);
8137 printf (" rsrc = 0x%x,", rsrc);
8138 printf (" rdst = 0x%x\n", rdst);
8140 SYNTAX("fadd %1%S1, %0");
8141 #line 827 "rx-decode.opc"
8142 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8145 break;
8147 break;
8148 case 0x89:
8149 GETBYTE ();
8150 switch (op[2] & 0x00)
8152 case 0x00:
8153 goto op_semantics_63;
8154 break;
8156 break;
8157 case 0x8a:
8158 GETBYTE ();
8159 switch (op[2] & 0x00)
8161 case 0x00:
8162 goto op_semantics_63;
8163 break;
8165 break;
8166 case 0x8b:
8167 GETBYTE ();
8168 switch (op[2] & 0x00)
8170 case 0x00:
8171 goto op_semantics_63;
8172 break;
8174 break;
8175 case 0x8c:
8176 GETBYTE ();
8177 switch (op[2] & 0x00)
8179 case 0x00:
8180 op_semantics_64:
8182 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8183 #line 848 "rx-decode.opc"
8184 int sd AU = op[1] & 0x03;
8185 #line 848 "rx-decode.opc"
8186 int rsrc AU = (op[2] >> 4) & 0x0f;
8187 #line 848 "rx-decode.opc"
8188 int rdst AU = op[2] & 0x0f;
8189 if (trace)
8191 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8192 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8193 op[0], op[1], op[2]);
8194 printf (" sd = 0x%x,", sd);
8195 printf (" rsrc = 0x%x,", rsrc);
8196 printf (" rdst = 0x%x\n", rdst);
8198 SYNTAX("fmul %1%S1, %0");
8199 #line 848 "rx-decode.opc"
8200 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8203 break;
8205 break;
8206 case 0x8d:
8207 GETBYTE ();
8208 switch (op[2] & 0x00)
8210 case 0x00:
8211 goto op_semantics_64;
8212 break;
8214 break;
8215 case 0x8e:
8216 GETBYTE ();
8217 switch (op[2] & 0x00)
8219 case 0x00:
8220 goto op_semantics_64;
8221 break;
8223 break;
8224 case 0x8f:
8225 GETBYTE ();
8226 switch (op[2] & 0x00)
8228 case 0x00:
8229 goto op_semantics_64;
8230 break;
8232 break;
8233 case 0x90:
8234 GETBYTE ();
8235 switch (op[2] & 0x00)
8237 case 0x00:
8238 op_semantics_65:
8240 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8241 #line 854 "rx-decode.opc"
8242 int sd AU = op[1] & 0x03;
8243 #line 854 "rx-decode.opc"
8244 int rsrc AU = (op[2] >> 4) & 0x0f;
8245 #line 854 "rx-decode.opc"
8246 int rdst AU = op[2] & 0x0f;
8247 if (trace)
8249 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8250 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8251 op[0], op[1], op[2]);
8252 printf (" sd = 0x%x,", sd);
8253 printf (" rsrc = 0x%x,", rsrc);
8254 printf (" rdst = 0x%x\n", rdst);
8256 SYNTAX("fdiv %1%S1, %0");
8257 #line 854 "rx-decode.opc"
8258 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8261 break;
8263 break;
8264 case 0x91:
8265 GETBYTE ();
8266 switch (op[2] & 0x00)
8268 case 0x00:
8269 goto op_semantics_65;
8270 break;
8272 break;
8273 case 0x92:
8274 GETBYTE ();
8275 switch (op[2] & 0x00)
8277 case 0x00:
8278 goto op_semantics_65;
8279 break;
8281 break;
8282 case 0x93:
8283 GETBYTE ();
8284 switch (op[2] & 0x00)
8286 case 0x00:
8287 goto op_semantics_65;
8288 break;
8290 break;
8291 case 0x94:
8292 GETBYTE ();
8293 switch (op[2] & 0x00)
8295 case 0x00:
8296 op_semantics_66:
8298 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8299 #line 842 "rx-decode.opc"
8300 int sd AU = op[1] & 0x03;
8301 #line 842 "rx-decode.opc"
8302 int rsrc AU = (op[2] >> 4) & 0x0f;
8303 #line 842 "rx-decode.opc"
8304 int rdst AU = op[2] & 0x0f;
8305 if (trace)
8307 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8308 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8309 op[0], op[1], op[2]);
8310 printf (" sd = 0x%x,", sd);
8311 printf (" rsrc = 0x%x,", rsrc);
8312 printf (" rdst = 0x%x\n", rdst);
8314 SYNTAX("ftoi %1%S1, %0");
8315 #line 842 "rx-decode.opc"
8316 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8319 break;
8321 break;
8322 case 0x95:
8323 GETBYTE ();
8324 switch (op[2] & 0x00)
8326 case 0x00:
8327 goto op_semantics_66;
8328 break;
8330 break;
8331 case 0x96:
8332 GETBYTE ();
8333 switch (op[2] & 0x00)
8335 case 0x00:
8336 goto op_semantics_66;
8337 break;
8339 break;
8340 case 0x97:
8341 GETBYTE ();
8342 switch (op[2] & 0x00)
8344 case 0x00:
8345 goto op_semantics_66;
8346 break;
8348 break;
8349 case 0x98:
8350 GETBYTE ();
8351 switch (op[2] & 0x00)
8353 case 0x00:
8354 op_semantics_67:
8356 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8357 #line 857 "rx-decode.opc"
8358 int sd AU = op[1] & 0x03;
8359 #line 857 "rx-decode.opc"
8360 int rsrc AU = (op[2] >> 4) & 0x0f;
8361 #line 857 "rx-decode.opc"
8362 int rdst AU = op[2] & 0x0f;
8363 if (trace)
8365 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8366 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8367 op[0], op[1], op[2]);
8368 printf (" sd = 0x%x,", sd);
8369 printf (" rsrc = 0x%x,", rsrc);
8370 printf (" rdst = 0x%x\n", rdst);
8372 SYNTAX("round %1%S1, %0");
8373 #line 857 "rx-decode.opc"
8374 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8377 break;
8379 break;
8380 case 0x99:
8381 GETBYTE ();
8382 switch (op[2] & 0x00)
8384 case 0x00:
8385 goto op_semantics_67;
8386 break;
8388 break;
8389 case 0x9a:
8390 GETBYTE ();
8391 switch (op[2] & 0x00)
8393 case 0x00:
8394 goto op_semantics_67;
8395 break;
8397 break;
8398 case 0x9b:
8399 GETBYTE ();
8400 switch (op[2] & 0x00)
8402 case 0x00:
8403 goto op_semantics_67;
8404 break;
8406 break;
8407 case 0xd0:
8408 GETBYTE ();
8409 switch (op[2] & 0x00)
8411 case 0x00:
8412 op_semantics_68:
8414 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8415 #line 966 "rx-decode.opc"
8416 int sz AU = (op[1] >> 2) & 0x03;
8417 #line 966 "rx-decode.opc"
8418 int sd AU = op[1] & 0x03;
8419 #line 966 "rx-decode.opc"
8420 int rdst AU = (op[2] >> 4) & 0x0f;
8421 #line 966 "rx-decode.opc"
8422 int cond AU = op[2] & 0x0f;
8423 if (trace)
8425 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8426 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8427 op[0], op[1], op[2]);
8428 printf (" sz = 0x%x,", sz);
8429 printf (" sd = 0x%x,", sd);
8430 printf (" rdst = 0x%x,", rdst);
8431 printf (" cond = 0x%x\n", cond);
8433 SYNTAX("sc%1%s %0");
8434 #line 966 "rx-decode.opc"
8435 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8438 break;
8440 break;
8441 case 0xd1:
8442 GETBYTE ();
8443 switch (op[2] & 0x00)
8445 case 0x00:
8446 goto op_semantics_68;
8447 break;
8449 break;
8450 case 0xd2:
8451 GETBYTE ();
8452 switch (op[2] & 0x00)
8454 case 0x00:
8455 goto op_semantics_68;
8456 break;
8458 break;
8459 case 0xd3:
8460 GETBYTE ();
8461 switch (op[2] & 0x00)
8463 case 0x00:
8464 goto op_semantics_68;
8465 break;
8467 break;
8468 case 0xd4:
8469 GETBYTE ();
8470 switch (op[2] & 0x00)
8472 case 0x00:
8473 goto op_semantics_68;
8474 break;
8476 break;
8477 case 0xd5:
8478 GETBYTE ();
8479 switch (op[2] & 0x00)
8481 case 0x00:
8482 goto op_semantics_68;
8483 break;
8485 break;
8486 case 0xd6:
8487 GETBYTE ();
8488 switch (op[2] & 0x00)
8490 case 0x00:
8491 goto op_semantics_68;
8492 break;
8494 break;
8495 case 0xd7:
8496 GETBYTE ();
8497 switch (op[2] & 0x00)
8499 case 0x00:
8500 goto op_semantics_68;
8501 break;
8503 break;
8504 case 0xd8:
8505 GETBYTE ();
8506 switch (op[2] & 0x00)
8508 case 0x00:
8509 goto op_semantics_68;
8510 break;
8512 break;
8513 case 0xd9:
8514 GETBYTE ();
8515 switch (op[2] & 0x00)
8517 case 0x00:
8518 goto op_semantics_68;
8519 break;
8521 break;
8522 case 0xda:
8523 GETBYTE ();
8524 switch (op[2] & 0x00)
8526 case 0x00:
8527 goto op_semantics_68;
8528 break;
8530 break;
8531 case 0xdb:
8532 GETBYTE ();
8533 switch (op[2] & 0x00)
8535 case 0x00:
8536 goto op_semantics_68;
8537 break;
8539 break;
8540 case 0xe0:
8541 GETBYTE ();
8542 switch (op[2] & 0x0f)
8544 case 0x00:
8545 case 0x01:
8546 case 0x02:
8547 case 0x03:
8548 case 0x04:
8549 case 0x05:
8550 case 0x06:
8551 case 0x07:
8552 case 0x08:
8553 case 0x09:
8554 case 0x0a:
8555 case 0x0b:
8556 case 0x0c:
8557 case 0x0d:
8558 case 0x0e:
8559 op_semantics_69:
8561 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
8562 #line 909 "rx-decode.opc"
8563 int bit AU = (op[1] >> 2) & 0x07;
8564 #line 909 "rx-decode.opc"
8565 int sd AU = op[1] & 0x03;
8566 #line 909 "rx-decode.opc"
8567 int rdst AU = (op[2] >> 4) & 0x0f;
8568 #line 909 "rx-decode.opc"
8569 int cond AU = op[2] & 0x0f;
8570 if (trace)
8572 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8573 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8574 op[0], op[1], op[2]);
8575 printf (" bit = 0x%x,", bit);
8576 printf (" sd = 0x%x,", sd);
8577 printf (" rdst = 0x%x,", rdst);
8578 printf (" cond = 0x%x\n", cond);
8580 SYNTAX("bm%2 #%1, %0%S0");
8581 #line 909 "rx-decode.opc"
8582 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8585 break;
8586 case 0x0f:
8587 op_semantics_70:
8589 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
8590 #line 899 "rx-decode.opc"
8591 int bit AU = (op[1] >> 2) & 0x07;
8592 #line 899 "rx-decode.opc"
8593 int sd AU = op[1] & 0x03;
8594 #line 899 "rx-decode.opc"
8595 int rdst AU = (op[2] >> 4) & 0x0f;
8596 if (trace)
8598 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8599 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8600 op[0], op[1], op[2]);
8601 printf (" bit = 0x%x,", bit);
8602 printf (" sd = 0x%x,", sd);
8603 printf (" rdst = 0x%x\n", rdst);
8605 SYNTAX("bnot #%1, %0%S0");
8606 #line 899 "rx-decode.opc"
8607 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8610 break;
8612 break;
8613 case 0xe1:
8614 GETBYTE ();
8615 switch (op[2] & 0x0f)
8617 case 0x00:
8618 case 0x01:
8619 case 0x02:
8620 case 0x03:
8621 case 0x04:
8622 case 0x05:
8623 case 0x06:
8624 case 0x07:
8625 case 0x08:
8626 case 0x09:
8627 case 0x0a:
8628 case 0x0b:
8629 case 0x0c:
8630 case 0x0d:
8631 case 0x0e:
8632 goto op_semantics_69;
8633 break;
8634 case 0x0f:
8635 goto op_semantics_70;
8636 break;
8638 break;
8639 case 0xe2:
8640 GETBYTE ();
8641 switch (op[2] & 0x0f)
8643 case 0x00:
8644 case 0x01:
8645 case 0x02:
8646 case 0x03:
8647 case 0x04:
8648 case 0x05:
8649 case 0x06:
8650 case 0x07:
8651 case 0x08:
8652 case 0x09:
8653 case 0x0a:
8654 case 0x0b:
8655 case 0x0c:
8656 case 0x0d:
8657 case 0x0e:
8658 goto op_semantics_69;
8659 break;
8660 case 0x0f:
8661 goto op_semantics_70;
8662 break;
8664 break;
8665 case 0xe3:
8666 GETBYTE ();
8667 switch (op[2] & 0x0f)
8669 case 0x00:
8670 case 0x01:
8671 case 0x02:
8672 case 0x03:
8673 case 0x04:
8674 case 0x05:
8675 case 0x06:
8676 case 0x07:
8677 case 0x08:
8678 case 0x09:
8679 case 0x0a:
8680 case 0x0b:
8681 case 0x0c:
8682 case 0x0d:
8683 case 0x0e:
8684 goto op_semantics_69;
8685 break;
8686 case 0x0f:
8687 goto op_semantics_70;
8688 break;
8690 break;
8691 case 0xe4:
8692 GETBYTE ();
8693 switch (op[2] & 0x0f)
8695 case 0x00:
8696 case 0x01:
8697 case 0x02:
8698 case 0x03:
8699 case 0x04:
8700 case 0x05:
8701 case 0x06:
8702 case 0x07:
8703 case 0x08:
8704 case 0x09:
8705 case 0x0a:
8706 case 0x0b:
8707 case 0x0c:
8708 case 0x0d:
8709 case 0x0e:
8710 goto op_semantics_69;
8711 break;
8712 case 0x0f:
8713 goto op_semantics_70;
8714 break;
8716 break;
8717 case 0xe5:
8718 GETBYTE ();
8719 switch (op[2] & 0x0f)
8721 case 0x00:
8722 case 0x01:
8723 case 0x02:
8724 case 0x03:
8725 case 0x04:
8726 case 0x05:
8727 case 0x06:
8728 case 0x07:
8729 case 0x08:
8730 case 0x09:
8731 case 0x0a:
8732 case 0x0b:
8733 case 0x0c:
8734 case 0x0d:
8735 case 0x0e:
8736 goto op_semantics_69;
8737 break;
8738 case 0x0f:
8739 goto op_semantics_70;
8740 break;
8742 break;
8743 case 0xe6:
8744 GETBYTE ();
8745 switch (op[2] & 0x0f)
8747 case 0x00:
8748 case 0x01:
8749 case 0x02:
8750 case 0x03:
8751 case 0x04:
8752 case 0x05:
8753 case 0x06:
8754 case 0x07:
8755 case 0x08:
8756 case 0x09:
8757 case 0x0a:
8758 case 0x0b:
8759 case 0x0c:
8760 case 0x0d:
8761 case 0x0e:
8762 goto op_semantics_69;
8763 break;
8764 case 0x0f:
8765 goto op_semantics_70;
8766 break;
8768 break;
8769 case 0xe7:
8770 GETBYTE ();
8771 switch (op[2] & 0x0f)
8773 case 0x00:
8774 case 0x01:
8775 case 0x02:
8776 case 0x03:
8777 case 0x04:
8778 case 0x05:
8779 case 0x06:
8780 case 0x07:
8781 case 0x08:
8782 case 0x09:
8783 case 0x0a:
8784 case 0x0b:
8785 case 0x0c:
8786 case 0x0d:
8787 case 0x0e:
8788 goto op_semantics_69;
8789 break;
8790 case 0x0f:
8791 goto op_semantics_70;
8792 break;
8794 break;
8795 case 0xe8:
8796 GETBYTE ();
8797 switch (op[2] & 0x0f)
8799 case 0x00:
8800 case 0x01:
8801 case 0x02:
8802 case 0x03:
8803 case 0x04:
8804 case 0x05:
8805 case 0x06:
8806 case 0x07:
8807 case 0x08:
8808 case 0x09:
8809 case 0x0a:
8810 case 0x0b:
8811 case 0x0c:
8812 case 0x0d:
8813 case 0x0e:
8814 goto op_semantics_69;
8815 break;
8816 case 0x0f:
8817 goto op_semantics_70;
8818 break;
8820 break;
8821 case 0xe9:
8822 GETBYTE ();
8823 switch (op[2] & 0x0f)
8825 case 0x00:
8826 case 0x01:
8827 case 0x02:
8828 case 0x03:
8829 case 0x04:
8830 case 0x05:
8831 case 0x06:
8832 case 0x07:
8833 case 0x08:
8834 case 0x09:
8835 case 0x0a:
8836 case 0x0b:
8837 case 0x0c:
8838 case 0x0d:
8839 case 0x0e:
8840 goto op_semantics_69;
8841 break;
8842 case 0x0f:
8843 goto op_semantics_70;
8844 break;
8846 break;
8847 case 0xea:
8848 GETBYTE ();
8849 switch (op[2] & 0x0f)
8851 case 0x00:
8852 case 0x01:
8853 case 0x02:
8854 case 0x03:
8855 case 0x04:
8856 case 0x05:
8857 case 0x06:
8858 case 0x07:
8859 case 0x08:
8860 case 0x09:
8861 case 0x0a:
8862 case 0x0b:
8863 case 0x0c:
8864 case 0x0d:
8865 case 0x0e:
8866 goto op_semantics_69;
8867 break;
8868 case 0x0f:
8869 goto op_semantics_70;
8870 break;
8872 break;
8873 case 0xeb:
8874 GETBYTE ();
8875 switch (op[2] & 0x0f)
8877 case 0x00:
8878 case 0x01:
8879 case 0x02:
8880 case 0x03:
8881 case 0x04:
8882 case 0x05:
8883 case 0x06:
8884 case 0x07:
8885 case 0x08:
8886 case 0x09:
8887 case 0x0a:
8888 case 0x0b:
8889 case 0x0c:
8890 case 0x0d:
8891 case 0x0e:
8892 goto op_semantics_69;
8893 break;
8894 case 0x0f:
8895 goto op_semantics_70;
8896 break;
8898 break;
8899 case 0xec:
8900 GETBYTE ();
8901 switch (op[2] & 0x0f)
8903 case 0x00:
8904 case 0x01:
8905 case 0x02:
8906 case 0x03:
8907 case 0x04:
8908 case 0x05:
8909 case 0x06:
8910 case 0x07:
8911 case 0x08:
8912 case 0x09:
8913 case 0x0a:
8914 case 0x0b:
8915 case 0x0c:
8916 case 0x0d:
8917 case 0x0e:
8918 goto op_semantics_69;
8919 break;
8920 case 0x0f:
8921 goto op_semantics_70;
8922 break;
8924 break;
8925 case 0xed:
8926 GETBYTE ();
8927 switch (op[2] & 0x0f)
8929 case 0x00:
8930 case 0x01:
8931 case 0x02:
8932 case 0x03:
8933 case 0x04:
8934 case 0x05:
8935 case 0x06:
8936 case 0x07:
8937 case 0x08:
8938 case 0x09:
8939 case 0x0a:
8940 case 0x0b:
8941 case 0x0c:
8942 case 0x0d:
8943 case 0x0e:
8944 goto op_semantics_69;
8945 break;
8946 case 0x0f:
8947 goto op_semantics_70;
8948 break;
8950 break;
8951 case 0xee:
8952 GETBYTE ();
8953 switch (op[2] & 0x0f)
8955 case 0x00:
8956 case 0x01:
8957 case 0x02:
8958 case 0x03:
8959 case 0x04:
8960 case 0x05:
8961 case 0x06:
8962 case 0x07:
8963 case 0x08:
8964 case 0x09:
8965 case 0x0a:
8966 case 0x0b:
8967 case 0x0c:
8968 case 0x0d:
8969 case 0x0e:
8970 goto op_semantics_69;
8971 break;
8972 case 0x0f:
8973 goto op_semantics_70;
8974 break;
8976 break;
8977 case 0xef:
8978 GETBYTE ();
8979 switch (op[2] & 0x0f)
8981 case 0x00:
8982 case 0x01:
8983 case 0x02:
8984 case 0x03:
8985 case 0x04:
8986 case 0x05:
8987 case 0x06:
8988 case 0x07:
8989 case 0x08:
8990 case 0x09:
8991 case 0x0a:
8992 case 0x0b:
8993 case 0x0c:
8994 case 0x0d:
8995 case 0x0e:
8996 goto op_semantics_69;
8997 break;
8998 case 0x0f:
8999 goto op_semantics_70;
9000 break;
9002 break;
9003 case 0xf0:
9004 GETBYTE ();
9005 switch (op[2] & 0x0f)
9007 case 0x00:
9008 case 0x01:
9009 case 0x02:
9010 case 0x03:
9011 case 0x04:
9012 case 0x05:
9013 case 0x06:
9014 case 0x07:
9015 case 0x08:
9016 case 0x09:
9017 case 0x0a:
9018 case 0x0b:
9019 case 0x0c:
9020 case 0x0d:
9021 case 0x0e:
9022 goto op_semantics_69;
9023 break;
9024 case 0x0f:
9025 goto op_semantics_70;
9026 break;
9028 break;
9029 case 0xf1:
9030 GETBYTE ();
9031 switch (op[2] & 0x0f)
9033 case 0x00:
9034 case 0x01:
9035 case 0x02:
9036 case 0x03:
9037 case 0x04:
9038 case 0x05:
9039 case 0x06:
9040 case 0x07:
9041 case 0x08:
9042 case 0x09:
9043 case 0x0a:
9044 case 0x0b:
9045 case 0x0c:
9046 case 0x0d:
9047 case 0x0e:
9048 goto op_semantics_69;
9049 break;
9050 case 0x0f:
9051 goto op_semantics_70;
9052 break;
9054 break;
9055 case 0xf2:
9056 GETBYTE ();
9057 switch (op[2] & 0x0f)
9059 case 0x00:
9060 case 0x01:
9061 case 0x02:
9062 case 0x03:
9063 case 0x04:
9064 case 0x05:
9065 case 0x06:
9066 case 0x07:
9067 case 0x08:
9068 case 0x09:
9069 case 0x0a:
9070 case 0x0b:
9071 case 0x0c:
9072 case 0x0d:
9073 case 0x0e:
9074 goto op_semantics_69;
9075 break;
9076 case 0x0f:
9077 goto op_semantics_70;
9078 break;
9080 break;
9081 case 0xf3:
9082 GETBYTE ();
9083 switch (op[2] & 0x0f)
9085 case 0x00:
9086 case 0x01:
9087 case 0x02:
9088 case 0x03:
9089 case 0x04:
9090 case 0x05:
9091 case 0x06:
9092 case 0x07:
9093 case 0x08:
9094 case 0x09:
9095 case 0x0a:
9096 case 0x0b:
9097 case 0x0c:
9098 case 0x0d:
9099 case 0x0e:
9100 goto op_semantics_69;
9101 break;
9102 case 0x0f:
9103 goto op_semantics_70;
9104 break;
9106 break;
9107 case 0xf4:
9108 GETBYTE ();
9109 switch (op[2] & 0x0f)
9111 case 0x00:
9112 case 0x01:
9113 case 0x02:
9114 case 0x03:
9115 case 0x04:
9116 case 0x05:
9117 case 0x06:
9118 case 0x07:
9119 case 0x08:
9120 case 0x09:
9121 case 0x0a:
9122 case 0x0b:
9123 case 0x0c:
9124 case 0x0d:
9125 case 0x0e:
9126 goto op_semantics_69;
9127 break;
9128 case 0x0f:
9129 goto op_semantics_70;
9130 break;
9132 break;
9133 case 0xf5:
9134 GETBYTE ();
9135 switch (op[2] & 0x0f)
9137 case 0x00:
9138 case 0x01:
9139 case 0x02:
9140 case 0x03:
9141 case 0x04:
9142 case 0x05:
9143 case 0x06:
9144 case 0x07:
9145 case 0x08:
9146 case 0x09:
9147 case 0x0a:
9148 case 0x0b:
9149 case 0x0c:
9150 case 0x0d:
9151 case 0x0e:
9152 goto op_semantics_69;
9153 break;
9154 case 0x0f:
9155 goto op_semantics_70;
9156 break;
9158 break;
9159 case 0xf6:
9160 GETBYTE ();
9161 switch (op[2] & 0x0f)
9163 case 0x00:
9164 case 0x01:
9165 case 0x02:
9166 case 0x03:
9167 case 0x04:
9168 case 0x05:
9169 case 0x06:
9170 case 0x07:
9171 case 0x08:
9172 case 0x09:
9173 case 0x0a:
9174 case 0x0b:
9175 case 0x0c:
9176 case 0x0d:
9177 case 0x0e:
9178 goto op_semantics_69;
9179 break;
9180 case 0x0f:
9181 goto op_semantics_70;
9182 break;
9184 break;
9185 case 0xf7:
9186 GETBYTE ();
9187 switch (op[2] & 0x0f)
9189 case 0x00:
9190 case 0x01:
9191 case 0x02:
9192 case 0x03:
9193 case 0x04:
9194 case 0x05:
9195 case 0x06:
9196 case 0x07:
9197 case 0x08:
9198 case 0x09:
9199 case 0x0a:
9200 case 0x0b:
9201 case 0x0c:
9202 case 0x0d:
9203 case 0x0e:
9204 goto op_semantics_69;
9205 break;
9206 case 0x0f:
9207 goto op_semantics_70;
9208 break;
9210 break;
9211 case 0xf8:
9212 GETBYTE ();
9213 switch (op[2] & 0x0f)
9215 case 0x00:
9216 case 0x01:
9217 case 0x02:
9218 case 0x03:
9219 case 0x04:
9220 case 0x05:
9221 case 0x06:
9222 case 0x07:
9223 case 0x08:
9224 case 0x09:
9225 case 0x0a:
9226 case 0x0b:
9227 case 0x0c:
9228 case 0x0d:
9229 case 0x0e:
9230 goto op_semantics_69;
9231 break;
9232 case 0x0f:
9233 goto op_semantics_70;
9234 break;
9236 break;
9237 case 0xf9:
9238 GETBYTE ();
9239 switch (op[2] & 0x0f)
9241 case 0x00:
9242 case 0x01:
9243 case 0x02:
9244 case 0x03:
9245 case 0x04:
9246 case 0x05:
9247 case 0x06:
9248 case 0x07:
9249 case 0x08:
9250 case 0x09:
9251 case 0x0a:
9252 case 0x0b:
9253 case 0x0c:
9254 case 0x0d:
9255 case 0x0e:
9256 goto op_semantics_69;
9257 break;
9258 case 0x0f:
9259 goto op_semantics_70;
9260 break;
9262 break;
9263 case 0xfa:
9264 GETBYTE ();
9265 switch (op[2] & 0x0f)
9267 case 0x00:
9268 case 0x01:
9269 case 0x02:
9270 case 0x03:
9271 case 0x04:
9272 case 0x05:
9273 case 0x06:
9274 case 0x07:
9275 case 0x08:
9276 case 0x09:
9277 case 0x0a:
9278 case 0x0b:
9279 case 0x0c:
9280 case 0x0d:
9281 case 0x0e:
9282 goto op_semantics_69;
9283 break;
9284 case 0x0f:
9285 goto op_semantics_70;
9286 break;
9288 break;
9289 case 0xfb:
9290 GETBYTE ();
9291 switch (op[2] & 0x0f)
9293 case 0x00:
9294 case 0x01:
9295 case 0x02:
9296 case 0x03:
9297 case 0x04:
9298 case 0x05:
9299 case 0x06:
9300 case 0x07:
9301 case 0x08:
9302 case 0x09:
9303 case 0x0a:
9304 case 0x0b:
9305 case 0x0c:
9306 case 0x0d:
9307 case 0x0e:
9308 goto op_semantics_69;
9309 break;
9310 case 0x0f:
9311 goto op_semantics_70;
9312 break;
9314 break;
9315 case 0xfc:
9316 GETBYTE ();
9317 switch (op[2] & 0x0f)
9319 case 0x00:
9320 case 0x01:
9321 case 0x02:
9322 case 0x03:
9323 case 0x04:
9324 case 0x05:
9325 case 0x06:
9326 case 0x07:
9327 case 0x08:
9328 case 0x09:
9329 case 0x0a:
9330 case 0x0b:
9331 case 0x0c:
9332 case 0x0d:
9333 case 0x0e:
9334 goto op_semantics_69;
9335 break;
9336 case 0x0f:
9337 goto op_semantics_70;
9338 break;
9340 break;
9341 case 0xfd:
9342 GETBYTE ();
9343 switch (op[2] & 0x0f)
9345 case 0x00:
9346 case 0x01:
9347 case 0x02:
9348 case 0x03:
9349 case 0x04:
9350 case 0x05:
9351 case 0x06:
9352 case 0x07:
9353 case 0x08:
9354 case 0x09:
9355 case 0x0a:
9356 case 0x0b:
9357 case 0x0c:
9358 case 0x0d:
9359 case 0x0e:
9360 goto op_semantics_69;
9361 break;
9362 case 0x0f:
9363 goto op_semantics_70;
9364 break;
9366 break;
9367 case 0xfe:
9368 GETBYTE ();
9369 switch (op[2] & 0x0f)
9371 case 0x00:
9372 case 0x01:
9373 case 0x02:
9374 case 0x03:
9375 case 0x04:
9376 case 0x05:
9377 case 0x06:
9378 case 0x07:
9379 case 0x08:
9380 case 0x09:
9381 case 0x0a:
9382 case 0x0b:
9383 case 0x0c:
9384 case 0x0d:
9385 case 0x0e:
9386 goto op_semantics_69;
9387 break;
9388 case 0x0f:
9389 goto op_semantics_70;
9390 break;
9392 break;
9393 case 0xff:
9394 GETBYTE ();
9395 switch (op[2] & 0x0f)
9397 case 0x00:
9398 case 0x01:
9399 case 0x02:
9400 case 0x03:
9401 case 0x04:
9402 case 0x05:
9403 case 0x06:
9404 case 0x07:
9405 case 0x08:
9406 case 0x09:
9407 case 0x0a:
9408 case 0x0b:
9409 case 0x0c:
9410 case 0x0d:
9411 case 0x0e:
9412 goto op_semantics_69;
9413 break;
9414 case 0x0f:
9415 goto op_semantics_70;
9416 break;
9418 break;
9419 default: UNSUPPORTED(); break;
9421 break;
9422 case 0xfd:
9423 GETBYTE ();
9424 switch (op[1] & 0xff)
9426 case 0x00:
9427 GETBYTE ();
9428 switch (op[2] & 0x00)
9430 case 0x00:
9432 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
9433 #line 782 "rx-decode.opc"
9434 int srca AU = (op[2] >> 4) & 0x0f;
9435 #line 782 "rx-decode.opc"
9436 int srcb AU = op[2] & 0x0f;
9437 if (trace)
9439 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9440 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9441 op[0], op[1], op[2]);
9442 printf (" srca = 0x%x,", srca);
9443 printf (" srcb = 0x%x\n", srcb);
9445 SYNTAX("mulhi %1, %2");
9446 #line 782 "rx-decode.opc"
9447 ID(mulhi); SR(srca); S2R(srcb); F("----");
9450 break;
9452 break;
9453 case 0x01:
9454 GETBYTE ();
9455 switch (op[2] & 0x00)
9457 case 0x00:
9459 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
9460 #line 785 "rx-decode.opc"
9461 int srca AU = (op[2] >> 4) & 0x0f;
9462 #line 785 "rx-decode.opc"
9463 int srcb AU = op[2] & 0x0f;
9464 if (trace)
9466 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9467 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9468 op[0], op[1], op[2]);
9469 printf (" srca = 0x%x,", srca);
9470 printf (" srcb = 0x%x\n", srcb);
9472 SYNTAX("mullo %1, %2");
9473 #line 785 "rx-decode.opc"
9474 ID(mullo); SR(srca); S2R(srcb); F("----");
9477 break;
9479 break;
9480 case 0x04:
9481 GETBYTE ();
9482 switch (op[2] & 0x00)
9484 case 0x00:
9486 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
9487 #line 788 "rx-decode.opc"
9488 int srca AU = (op[2] >> 4) & 0x0f;
9489 #line 788 "rx-decode.opc"
9490 int srcb AU = op[2] & 0x0f;
9491 if (trace)
9493 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9494 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9495 op[0], op[1], op[2]);
9496 printf (" srca = 0x%x,", srca);
9497 printf (" srcb = 0x%x\n", srcb);
9499 SYNTAX("machi %1, %2");
9500 #line 788 "rx-decode.opc"
9501 ID(machi); SR(srca); S2R(srcb); F("----");
9504 break;
9506 break;
9507 case 0x05:
9508 GETBYTE ();
9509 switch (op[2] & 0x00)
9511 case 0x00:
9513 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
9514 #line 791 "rx-decode.opc"
9515 int srca AU = (op[2] >> 4) & 0x0f;
9516 #line 791 "rx-decode.opc"
9517 int srcb AU = op[2] & 0x0f;
9518 if (trace)
9520 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9521 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9522 op[0], op[1], op[2]);
9523 printf (" srca = 0x%x,", srca);
9524 printf (" srcb = 0x%x\n", srcb);
9526 SYNTAX("maclo %1, %2");
9527 #line 791 "rx-decode.opc"
9528 ID(maclo); SR(srca); S2R(srcb); F("----");
9531 break;
9533 break;
9534 case 0x17:
9535 GETBYTE ();
9536 switch (op[2] & 0xf0)
9538 case 0x00:
9540 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9541 #line 794 "rx-decode.opc"
9542 int rsrc AU = op[2] & 0x0f;
9543 if (trace)
9545 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9546 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9547 op[0], op[1], op[2]);
9548 printf (" rsrc = 0x%x\n", rsrc);
9550 SYNTAX("mvtachi %1");
9551 #line 794 "rx-decode.opc"
9552 ID(mvtachi); SR(rsrc); F("----");
9555 break;
9556 case 0x10:
9558 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9559 #line 797 "rx-decode.opc"
9560 int rsrc AU = op[2] & 0x0f;
9561 if (trace)
9563 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9564 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9565 op[0], op[1], op[2]);
9566 printf (" rsrc = 0x%x\n", rsrc);
9568 SYNTAX("mvtaclo %1");
9569 #line 797 "rx-decode.opc"
9570 ID(mvtaclo); SR(rsrc); F("----");
9573 break;
9574 default: UNSUPPORTED(); break;
9576 break;
9577 case 0x18:
9578 GETBYTE ();
9579 switch (op[2] & 0xef)
9581 case 0x00:
9583 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
9584 #line 809 "rx-decode.opc"
9585 int i AU = (op[2] >> 4) & 0x01;
9586 if (trace)
9588 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9589 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9590 op[0], op[1], op[2]);
9591 printf (" i = 0x%x\n", i);
9593 SYNTAX("racw #%1");
9594 #line 809 "rx-decode.opc"
9595 ID(racw); SC(i+1); F("----");
9597 /*----------------------------------------------------------------------*/
9598 /* SAT */
9601 break;
9602 default: UNSUPPORTED(); break;
9604 break;
9605 case 0x1f:
9606 GETBYTE ();
9607 switch (op[2] & 0xf0)
9609 case 0x00:
9611 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9612 #line 800 "rx-decode.opc"
9613 int rdst AU = op[2] & 0x0f;
9614 if (trace)
9616 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9617 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9618 op[0], op[1], op[2]);
9619 printf (" rdst = 0x%x\n", rdst);
9621 SYNTAX("mvfachi %0");
9622 #line 800 "rx-decode.opc"
9623 ID(mvfachi); DR(rdst); F("----");
9626 break;
9627 case 0x10:
9629 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9630 #line 806 "rx-decode.opc"
9631 int rdst AU = op[2] & 0x0f;
9632 if (trace)
9634 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9635 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9636 op[0], op[1], op[2]);
9637 printf (" rdst = 0x%x\n", rdst);
9639 SYNTAX("mvfaclo %0");
9640 #line 806 "rx-decode.opc"
9641 ID(mvfaclo); DR(rdst); F("----");
9644 break;
9645 case 0x20:
9647 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9648 #line 803 "rx-decode.opc"
9649 int rdst AU = op[2] & 0x0f;
9650 if (trace)
9652 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9653 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9654 op[0], op[1], op[2]);
9655 printf (" rdst = 0x%x\n", rdst);
9657 SYNTAX("mvfacmi %0");
9658 #line 803 "rx-decode.opc"
9659 ID(mvfacmi); DR(rdst); F("----");
9662 break;
9663 default: UNSUPPORTED(); break;
9665 break;
9666 case 0x20:
9667 GETBYTE ();
9668 switch (op[2] & 0x00)
9670 case 0x00:
9671 op_semantics_71:
9673 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
9674 #line 324 "rx-decode.opc"
9675 int p AU = (op[1] >> 2) & 0x01;
9676 #line 324 "rx-decode.opc"
9677 int sz AU = op[1] & 0x03;
9678 #line 324 "rx-decode.opc"
9679 int rdst AU = (op[2] >> 4) & 0x0f;
9680 #line 324 "rx-decode.opc"
9681 int rsrc AU = op[2] & 0x0f;
9682 if (trace)
9684 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9685 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9686 op[0], op[1], op[2]);
9687 printf (" p = 0x%x,", p);
9688 printf (" sz = 0x%x,", sz);
9689 printf (" rdst = 0x%x,", rdst);
9690 printf (" rsrc = 0x%x\n", rsrc);
9692 SYNTAX("mov%s %1, %0");
9693 #line 324 "rx-decode.opc"
9694 ID(mov); sBWL (sz); SR(rsrc); F("----");
9695 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9698 break;
9700 break;
9701 case 0x21:
9702 GETBYTE ();
9703 switch (op[2] & 0x00)
9705 case 0x00:
9706 goto op_semantics_71;
9707 break;
9709 break;
9710 case 0x22:
9711 GETBYTE ();
9712 switch (op[2] & 0x00)
9714 case 0x00:
9715 goto op_semantics_71;
9716 break;
9718 break;
9719 case 0x24:
9720 GETBYTE ();
9721 switch (op[2] & 0x00)
9723 case 0x00:
9724 goto op_semantics_71;
9725 break;
9727 break;
9728 case 0x25:
9729 GETBYTE ();
9730 switch (op[2] & 0x00)
9732 case 0x00:
9733 goto op_semantics_71;
9734 break;
9736 break;
9737 case 0x26:
9738 GETBYTE ();
9739 switch (op[2] & 0x00)
9741 case 0x00:
9742 goto op_semantics_71;
9743 break;
9745 break;
9746 case 0x28:
9747 GETBYTE ();
9748 switch (op[2] & 0x00)
9750 case 0x00:
9751 op_semantics_72:
9753 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
9754 #line 328 "rx-decode.opc"
9755 int p AU = (op[1] >> 2) & 0x01;
9756 #line 328 "rx-decode.opc"
9757 int sz AU = op[1] & 0x03;
9758 #line 328 "rx-decode.opc"
9759 int rsrc AU = (op[2] >> 4) & 0x0f;
9760 #line 328 "rx-decode.opc"
9761 int rdst AU = op[2] & 0x0f;
9762 if (trace)
9764 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9765 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9766 op[0], op[1], op[2]);
9767 printf (" p = 0x%x,", p);
9768 printf (" sz = 0x%x,", sz);
9769 printf (" rsrc = 0x%x,", rsrc);
9770 printf (" rdst = 0x%x\n", rdst);
9772 SYNTAX("mov%s %1, %0");
9773 #line 328 "rx-decode.opc"
9774 ID(mov); sBWL (sz); DR(rdst); F("----");
9775 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9778 break;
9780 break;
9781 case 0x29:
9782 GETBYTE ();
9783 switch (op[2] & 0x00)
9785 case 0x00:
9786 goto op_semantics_72;
9787 break;
9789 break;
9790 case 0x2a:
9791 GETBYTE ();
9792 switch (op[2] & 0x00)
9794 case 0x00:
9795 goto op_semantics_72;
9796 break;
9798 break;
9799 case 0x2c:
9800 GETBYTE ();
9801 switch (op[2] & 0x00)
9803 case 0x00:
9804 goto op_semantics_72;
9805 break;
9807 break;
9808 case 0x2d:
9809 GETBYTE ();
9810 switch (op[2] & 0x00)
9812 case 0x00:
9813 goto op_semantics_72;
9814 break;
9816 break;
9817 case 0x2e:
9818 GETBYTE ();
9819 switch (op[2] & 0x00)
9821 case 0x00:
9822 goto op_semantics_72;
9823 break;
9825 break;
9826 case 0x38:
9827 GETBYTE ();
9828 switch (op[2] & 0x00)
9830 case 0x00:
9831 op_semantics_73:
9833 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
9834 #line 338 "rx-decode.opc"
9835 int p AU = (op[1] >> 2) & 0x01;
9836 #line 338 "rx-decode.opc"
9837 int sz AU = op[1] & 0x03;
9838 #line 338 "rx-decode.opc"
9839 int rsrc AU = (op[2] >> 4) & 0x0f;
9840 #line 338 "rx-decode.opc"
9841 int rdst AU = op[2] & 0x0f;
9842 if (trace)
9844 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9845 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9846 op[0], op[1], op[2]);
9847 printf (" p = 0x%x,", p);
9848 printf (" sz = 0x%x,", sz);
9849 printf (" rsrc = 0x%x,", rsrc);
9850 printf (" rdst = 0x%x\n", rdst);
9852 SYNTAX("movu%s %1, %0");
9853 #line 338 "rx-decode.opc"
9854 ID(mov); uBWL (sz); DR(rdst); F("----");
9855 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9857 /*----------------------------------------------------------------------*/
9858 /* PUSH/POP */
9861 break;
9863 break;
9864 case 0x39:
9865 GETBYTE ();
9866 switch (op[2] & 0x00)
9868 case 0x00:
9869 goto op_semantics_73;
9870 break;
9872 break;
9873 case 0x3a:
9874 GETBYTE ();
9875 switch (op[2] & 0x00)
9877 case 0x00:
9878 goto op_semantics_73;
9879 break;
9881 break;
9882 case 0x3c:
9883 GETBYTE ();
9884 switch (op[2] & 0x00)
9886 case 0x00:
9887 goto op_semantics_73;
9888 break;
9890 break;
9891 case 0x3d:
9892 GETBYTE ();
9893 switch (op[2] & 0x00)
9895 case 0x00:
9896 goto op_semantics_73;
9897 break;
9899 break;
9900 case 0x3e:
9901 GETBYTE ();
9902 switch (op[2] & 0x00)
9904 case 0x00:
9905 goto op_semantics_73;
9906 break;
9908 break;
9909 case 0x60:
9910 GETBYTE ();
9911 switch (op[2] & 0x00)
9913 case 0x00:
9915 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
9916 #line 663 "rx-decode.opc"
9917 int rsrc AU = (op[2] >> 4) & 0x0f;
9918 #line 663 "rx-decode.opc"
9919 int rdst AU = op[2] & 0x0f;
9920 if (trace)
9922 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9923 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9924 op[0], op[1], op[2]);
9925 printf (" rsrc = 0x%x,", rsrc);
9926 printf (" rdst = 0x%x\n", rdst);
9928 SYNTAX("shlr %2, %0");
9929 #line 663 "rx-decode.opc"
9930 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F("-SZC");
9933 break;
9935 break;
9936 case 0x61:
9937 GETBYTE ();
9938 switch (op[2] & 0x00)
9940 case 0x00:
9942 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
9943 #line 653 "rx-decode.opc"
9944 int rsrc AU = (op[2] >> 4) & 0x0f;
9945 #line 653 "rx-decode.opc"
9946 int rdst AU = op[2] & 0x0f;
9947 if (trace)
9949 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9950 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
9951 op[0], op[1], op[2]);
9952 printf (" rsrc = 0x%x,", rsrc);
9953 printf (" rdst = 0x%x\n", rdst);
9955 SYNTAX("shar %2, %0");
9956 #line 653 "rx-decode.opc"
9957 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F("0SZC");
9960 break;
9962 break;
9963 case 0x62:
9964 GETBYTE ();
9965 switch (op[2] & 0x00)
9967 case 0x00:
9969 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
9970 #line 643 "rx-decode.opc"
9971 int rsrc AU = (op[2] >> 4) & 0x0f;
9972 #line 643 "rx-decode.opc"
9973 int rdst AU = op[2] & 0x0f;
9974 if (trace)
9976 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9977 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
9978 op[0], op[1], op[2]);
9979 printf (" rsrc = 0x%x,", rsrc);
9980 printf (" rdst = 0x%x\n", rdst);
9982 SYNTAX("shll %2, %0");
9983 #line 643 "rx-decode.opc"
9984 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F("OSZC");
9987 break;
9989 break;
9990 case 0x64:
9991 GETBYTE ();
9992 switch (op[2] & 0x00)
9994 case 0x00:
9996 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
9997 #line 687 "rx-decode.opc"
9998 int rsrc AU = (op[2] >> 4) & 0x0f;
9999 #line 687 "rx-decode.opc"
10000 int rdst AU = op[2] & 0x0f;
10001 if (trace)
10003 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10004 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
10005 op[0], op[1], op[2]);
10006 printf (" rsrc = 0x%x,", rsrc);
10007 printf (" rdst = 0x%x\n", rdst);
10009 SYNTAX("rotr %1, %0");
10010 #line 687 "rx-decode.opc"
10011 ID(rotr); SR(rsrc); DR(rdst); F("-SZC");
10014 break;
10016 break;
10017 case 0x65:
10018 GETBYTE ();
10019 switch (op[2] & 0x00)
10021 case 0x00:
10023 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
10024 #line 690 "rx-decode.opc"
10025 int rsrc AU = (op[2] >> 4) & 0x0f;
10026 #line 690 "rx-decode.opc"
10027 int rdst AU = op[2] & 0x0f;
10028 if (trace)
10030 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10031 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10032 op[0], op[1], op[2]);
10033 printf (" rsrc = 0x%x,", rsrc);
10034 printf (" rdst = 0x%x\n", rdst);
10036 SYNTAX("revw %1, %0");
10037 #line 690 "rx-decode.opc"
10038 ID(revw); SR(rsrc); DR(rdst);
10041 break;
10043 break;
10044 case 0x66:
10045 GETBYTE ();
10046 switch (op[2] & 0x00)
10048 case 0x00:
10050 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
10051 #line 681 "rx-decode.opc"
10052 int rsrc AU = (op[2] >> 4) & 0x0f;
10053 #line 681 "rx-decode.opc"
10054 int rdst AU = op[2] & 0x0f;
10055 if (trace)
10057 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10058 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10059 op[0], op[1], op[2]);
10060 printf (" rsrc = 0x%x,", rsrc);
10061 printf (" rdst = 0x%x\n", rdst);
10063 SYNTAX("rotl %1, %0");
10064 #line 681 "rx-decode.opc"
10065 ID(rotl); SR(rsrc); DR(rdst); F("-SZC");
10068 break;
10070 break;
10071 case 0x67:
10072 GETBYTE ();
10073 switch (op[2] & 0x00)
10075 case 0x00:
10077 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
10078 #line 693 "rx-decode.opc"
10079 int rsrc AU = (op[2] >> 4) & 0x0f;
10080 #line 693 "rx-decode.opc"
10081 int rdst AU = op[2] & 0x0f;
10082 if (trace)
10084 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10085 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10086 op[0], op[1], op[2]);
10087 printf (" rsrc = 0x%x,", rsrc);
10088 printf (" rdst = 0x%x\n", rdst);
10090 SYNTAX("revl %1, %0");
10091 #line 693 "rx-decode.opc"
10092 ID(revl); SR(rsrc); DR(rdst);
10094 /*----------------------------------------------------------------------*/
10095 /* BRANCH */
10098 break;
10100 break;
10101 case 0x68:
10102 GETBYTE ();
10103 switch (op[2] & 0x00)
10105 case 0x00:
10106 op_semantics_74:
10108 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
10109 #line 936 "rx-decode.opc"
10110 int c AU = op[1] & 0x01;
10111 #line 936 "rx-decode.opc"
10112 int rsrc AU = (op[2] >> 4) & 0x0f;
10113 #line 936 "rx-decode.opc"
10114 int rdst AU = op[2] & 0x0f;
10115 if (trace)
10117 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10118 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10119 op[0], op[1], op[2]);
10120 printf (" c = 0x%x,", c);
10121 printf (" rsrc = 0x%x,", rsrc);
10122 printf (" rdst = 0x%x\n", rdst);
10124 SYNTAX("mvtc %1, %0");
10125 #line 936 "rx-decode.opc"
10126 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10129 break;
10131 break;
10132 case 0x69:
10133 GETBYTE ();
10134 switch (op[2] & 0x00)
10136 case 0x00:
10137 goto op_semantics_74;
10138 break;
10140 break;
10141 case 0x6a:
10142 GETBYTE ();
10143 switch (op[2] & 0x00)
10145 case 0x00:
10146 op_semantics_75:
10148 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
10149 #line 939 "rx-decode.opc"
10150 int s AU = op[1] & 0x01;
10151 #line 939 "rx-decode.opc"
10152 int rsrc AU = (op[2] >> 4) & 0x0f;
10153 #line 939 "rx-decode.opc"
10154 int rdst AU = op[2] & 0x0f;
10155 if (trace)
10157 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10158 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10159 op[0], op[1], op[2]);
10160 printf (" s = 0x%x,", s);
10161 printf (" rsrc = 0x%x,", rsrc);
10162 printf (" rdst = 0x%x\n", rdst);
10164 SYNTAX("mvfc %1, %0");
10165 #line 939 "rx-decode.opc"
10166 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10168 /*----------------------------------------------------------------------*/
10169 /* INTERRUPTS */
10172 break;
10174 break;
10175 case 0x6b:
10176 GETBYTE ();
10177 switch (op[2] & 0x00)
10179 case 0x00:
10180 goto op_semantics_75;
10181 break;
10183 break;
10184 case 0x6c:
10185 GETBYTE ();
10186 switch (op[2] & 0x00)
10188 case 0x00:
10189 op_semantics_76:
10191 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
10192 #line 684 "rx-decode.opc"
10193 int i AU = op[1] & 0x01;
10194 #line 684 "rx-decode.opc"
10195 int mmmm AU = (op[2] >> 4) & 0x0f;
10196 #line 684 "rx-decode.opc"
10197 int rdst AU = op[2] & 0x0f;
10198 if (trace)
10200 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10201 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10202 op[0], op[1], op[2]);
10203 printf (" i = 0x%x,", i);
10204 printf (" mmmm = 0x%x,", mmmm);
10205 printf (" rdst = 0x%x\n", rdst);
10207 SYNTAX("rotr #%1, %0");
10208 #line 684 "rx-decode.opc"
10209 ID(rotr); SC(i*16+mmmm); DR(rdst); F("-SZC");
10212 break;
10214 break;
10215 case 0x6d:
10216 GETBYTE ();
10217 switch (op[2] & 0x00)
10219 case 0x00:
10220 goto op_semantics_76;
10221 break;
10223 break;
10224 case 0x6e:
10225 GETBYTE ();
10226 switch (op[2] & 0x00)
10228 case 0x00:
10229 op_semantics_77:
10231 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
10232 #line 678 "rx-decode.opc"
10233 int i AU = op[1] & 0x01;
10234 #line 678 "rx-decode.opc"
10235 int mmmm AU = (op[2] >> 4) & 0x0f;
10236 #line 678 "rx-decode.opc"
10237 int rdst AU = op[2] & 0x0f;
10238 if (trace)
10240 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10241 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10242 op[0], op[1], op[2]);
10243 printf (" i = 0x%x,", i);
10244 printf (" mmmm = 0x%x,", mmmm);
10245 printf (" rdst = 0x%x\n", rdst);
10247 SYNTAX("rotl #%1, %0");
10248 #line 678 "rx-decode.opc"
10249 ID(rotl); SC(i*16+mmmm); DR(rdst); F("-SZC");
10252 break;
10254 break;
10255 case 0x6f:
10256 GETBYTE ();
10257 switch (op[2] & 0x00)
10259 case 0x00:
10260 goto op_semantics_77;
10261 break;
10263 break;
10264 case 0x70:
10265 GETBYTE ();
10266 switch (op[2] & 0xf0)
10268 case 0x20:
10269 op_semantics_78:
10271 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
10272 #line 468 "rx-decode.opc"
10273 int im AU = (op[1] >> 2) & 0x03;
10274 #line 468 "rx-decode.opc"
10275 int rdst AU = op[2] & 0x0f;
10276 if (trace)
10278 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10279 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10280 op[0], op[1], op[2]);
10281 printf (" im = 0x%x,", im);
10282 printf (" rdst = 0x%x\n", rdst);
10284 SYNTAX("adc #%1, %0");
10285 #line 468 "rx-decode.opc"
10286 ID(adc); SC(IMMex(im)); DR(rdst); F("OSZC");
10289 break;
10290 case 0x40:
10291 op_semantics_79:
10293 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
10294 #line 550 "rx-decode.opc"
10295 int im AU = (op[1] >> 2) & 0x03;
10296 #line 550 "rx-decode.opc"
10297 int rdst AU = op[2] & 0x0f;
10298 if (trace)
10300 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10301 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10302 op[0], op[1], op[2]);
10303 printf (" im = 0x%x,", im);
10304 printf (" rdst = 0x%x\n", rdst);
10306 SYNTAX("max #%1, %0");
10307 #line 550 "rx-decode.opc"
10308 ID(max); DR(rdst); SC(IMMex(im));
10311 break;
10312 case 0x50:
10313 op_semantics_80:
10315 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
10316 #line 562 "rx-decode.opc"
10317 int im AU = (op[1] >> 2) & 0x03;
10318 #line 562 "rx-decode.opc"
10319 int rdst AU = op[2] & 0x0f;
10320 if (trace)
10322 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10323 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10324 op[0], op[1], op[2]);
10325 printf (" im = 0x%x,", im);
10326 printf (" rdst = 0x%x\n", rdst);
10328 SYNTAX("min #%1, %0");
10329 #line 562 "rx-decode.opc"
10330 ID(min); DR(rdst); SC(IMMex(im));
10333 break;
10334 case 0x60:
10335 op_semantics_81:
10337 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
10338 #line 592 "rx-decode.opc"
10339 int im AU = (op[1] >> 2) & 0x03;
10340 #line 592 "rx-decode.opc"
10341 int rdst AU = op[2] & 0x0f;
10342 if (trace)
10344 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10345 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10346 op[0], op[1], op[2]);
10347 printf (" im = 0x%x,", im);
10348 printf (" rdst = 0x%x\n", rdst);
10350 SYNTAX("emul #%1, %0");
10351 #line 592 "rx-decode.opc"
10352 ID(emul); DR(rdst); SC(IMMex(im));
10355 break;
10356 case 0x70:
10357 op_semantics_82:
10359 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
10360 #line 604 "rx-decode.opc"
10361 int im AU = (op[1] >> 2) & 0x03;
10362 #line 604 "rx-decode.opc"
10363 int rdst AU = op[2] & 0x0f;
10364 if (trace)
10366 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10367 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10368 op[0], op[1], op[2]);
10369 printf (" im = 0x%x,", im);
10370 printf (" rdst = 0x%x\n", rdst);
10372 SYNTAX("emulu #%1, %0");
10373 #line 604 "rx-decode.opc"
10374 ID(emulu); DR(rdst); SC(IMMex(im));
10377 break;
10378 case 0x80:
10379 op_semantics_83:
10381 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
10382 #line 616 "rx-decode.opc"
10383 int im AU = (op[1] >> 2) & 0x03;
10384 #line 616 "rx-decode.opc"
10385 int rdst AU = op[2] & 0x0f;
10386 if (trace)
10388 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10389 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10390 op[0], op[1], op[2]);
10391 printf (" im = 0x%x,", im);
10392 printf (" rdst = 0x%x\n", rdst);
10394 SYNTAX("div #%1, %0");
10395 #line 616 "rx-decode.opc"
10396 ID(div); DR(rdst); SC(IMMex(im)); F("O---");
10399 break;
10400 case 0x90:
10401 op_semantics_84:
10403 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
10404 #line 628 "rx-decode.opc"
10405 int im AU = (op[1] >> 2) & 0x03;
10406 #line 628 "rx-decode.opc"
10407 int rdst AU = op[2] & 0x0f;
10408 if (trace)
10410 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10411 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10412 op[0], op[1], op[2]);
10413 printf (" im = 0x%x,", im);
10414 printf (" rdst = 0x%x\n", rdst);
10416 SYNTAX("divu #%1, %0");
10417 #line 628 "rx-decode.opc"
10418 ID(divu); DR(rdst); SC(IMMex(im)); F("O---");
10421 break;
10422 case 0xc0:
10423 op_semantics_85:
10425 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
10426 #line 447 "rx-decode.opc"
10427 int im AU = (op[1] >> 2) & 0x03;
10428 #line 447 "rx-decode.opc"
10429 int rdst AU = op[2] & 0x0f;
10430 if (trace)
10432 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10433 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
10434 op[0], op[1], op[2]);
10435 printf (" im = 0x%x,", im);
10436 printf (" rdst = 0x%x\n", rdst);
10438 SYNTAX("tst #%1, %2");
10439 #line 447 "rx-decode.opc"
10440 ID(and); SC(IMMex(im)); S2R(rdst); F("-SZ-");
10443 break;
10444 case 0xd0:
10445 op_semantics_86:
10447 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
10448 #line 426 "rx-decode.opc"
10449 int im AU = (op[1] >> 2) & 0x03;
10450 #line 426 "rx-decode.opc"
10451 int rdst AU = op[2] & 0x0f;
10452 if (trace)
10454 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10455 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10456 op[0], op[1], op[2]);
10457 printf (" im = 0x%x,", im);
10458 printf (" rdst = 0x%x\n", rdst);
10460 SYNTAX("xor #%1, %0");
10461 #line 426 "rx-decode.opc"
10462 ID(xor); SC(IMMex(im)); DR(rdst); F("-SZ-");
10465 break;
10466 case 0xe0:
10467 op_semantics_87:
10469 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
10470 #line 372 "rx-decode.opc"
10471 int im AU = (op[1] >> 2) & 0x03;
10472 #line 372 "rx-decode.opc"
10473 int rdst AU = op[2] & 0x0f;
10474 if (trace)
10476 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10477 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10478 op[0], op[1], op[2]);
10479 printf (" im = 0x%x,", im);
10480 printf (" rdst = 0x%x\n", rdst);
10482 SYNTAX("stz #%1, %0");
10483 #line 372 "rx-decode.opc"
10484 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10487 break;
10488 case 0xf0:
10489 op_semantics_88:
10491 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
10492 #line 375 "rx-decode.opc"
10493 int im AU = (op[1] >> 2) & 0x03;
10494 #line 375 "rx-decode.opc"
10495 int rdst AU = op[2] & 0x0f;
10496 if (trace)
10498 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10499 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10500 op[0], op[1], op[2]);
10501 printf (" im = 0x%x,", im);
10502 printf (" rdst = 0x%x\n", rdst);
10504 SYNTAX("stnz #%1, %0");
10505 #line 375 "rx-decode.opc"
10506 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10508 /*----------------------------------------------------------------------*/
10509 /* RTSD */
10512 break;
10513 default: UNSUPPORTED(); break;
10515 break;
10516 case 0x72:
10517 GETBYTE ();
10518 switch (op[2] & 0xf0)
10520 case 0x00:
10522 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
10523 #line 836 "rx-decode.opc"
10524 int rdst AU = op[2] & 0x0f;
10525 if (trace)
10527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10528 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
10529 op[0], op[1], op[2]);
10530 printf (" rdst = 0x%x\n", rdst);
10532 SYNTAX("fsub #%1, %0");
10533 #line 836 "rx-decode.opc"
10534 ID(fsub); DR(rdst); SC(IMM(0)); F("-SZ-");
10537 break;
10538 case 0x10:
10540 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
10541 #line 830 "rx-decode.opc"
10542 int rdst AU = op[2] & 0x0f;
10543 if (trace)
10545 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10546 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10547 op[0], op[1], op[2]);
10548 printf (" rdst = 0x%x\n", rdst);
10550 SYNTAX("fcmp #%1, %0");
10551 #line 830 "rx-decode.opc"
10552 ID(fcmp); DR(rdst); SC(IMM(0)); F("OSZ-");
10555 break;
10556 case 0x20:
10558 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
10559 #line 824 "rx-decode.opc"
10560 int rdst AU = op[2] & 0x0f;
10561 if (trace)
10563 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10564 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10565 op[0], op[1], op[2]);
10566 printf (" rdst = 0x%x\n", rdst);
10568 SYNTAX("fadd #%1, %0");
10569 #line 824 "rx-decode.opc"
10570 ID(fadd); DR(rdst); SC(IMM(0)); F("-SZ-");
10573 break;
10574 case 0x30:
10576 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
10577 #line 845 "rx-decode.opc"
10578 int rdst AU = op[2] & 0x0f;
10579 if (trace)
10581 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10582 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10583 op[0], op[1], op[2]);
10584 printf (" rdst = 0x%x\n", rdst);
10586 SYNTAX("fmul #%1, %0");
10587 #line 845 "rx-decode.opc"
10588 ID(fmul); DR(rdst); SC(IMM(0)); F("-SZ-");
10591 break;
10592 case 0x40:
10594 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
10595 #line 851 "rx-decode.opc"
10596 int rdst AU = op[2] & 0x0f;
10597 if (trace)
10599 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10600 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10601 op[0], op[1], op[2]);
10602 printf (" rdst = 0x%x\n", rdst);
10604 SYNTAX("fdiv #%1, %0");
10605 #line 851 "rx-decode.opc"
10606 ID(fdiv); DR(rdst); SC(IMM(0)); F("-SZ-");
10609 break;
10610 default: UNSUPPORTED(); break;
10612 break;
10613 case 0x73:
10614 GETBYTE ();
10615 switch (op[2] & 0xe0)
10617 case 0x00:
10618 op_semantics_89:
10620 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
10621 #line 933 "rx-decode.opc"
10622 int im AU = (op[1] >> 2) & 0x03;
10623 #line 933 "rx-decode.opc"
10624 int crdst AU = op[2] & 0x1f;
10625 if (trace)
10627 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10628 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10629 op[0], op[1], op[2]);
10630 printf (" im = 0x%x,", im);
10631 printf (" crdst = 0x%x\n", crdst);
10633 SYNTAX("mvtc #%1, %0");
10634 #line 933 "rx-decode.opc"
10635 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10638 break;
10639 default: UNSUPPORTED(); break;
10641 break;
10642 case 0x74:
10643 GETBYTE ();
10644 switch (op[2] & 0xf0)
10646 case 0x20:
10647 goto op_semantics_78;
10648 break;
10649 case 0x40:
10650 goto op_semantics_79;
10651 break;
10652 case 0x50:
10653 goto op_semantics_80;
10654 break;
10655 case 0x60:
10656 goto op_semantics_81;
10657 break;
10658 case 0x70:
10659 goto op_semantics_82;
10660 break;
10661 case 0x80:
10662 goto op_semantics_83;
10663 break;
10664 case 0x90:
10665 goto op_semantics_84;
10666 break;
10667 case 0xc0:
10668 goto op_semantics_85;
10669 break;
10670 case 0xd0:
10671 goto op_semantics_86;
10672 break;
10673 case 0xe0:
10674 goto op_semantics_87;
10675 break;
10676 case 0xf0:
10677 goto op_semantics_88;
10678 break;
10679 default: UNSUPPORTED(); break;
10681 break;
10682 case 0x77:
10683 GETBYTE ();
10684 switch (op[2] & 0xe0)
10686 case 0x00:
10687 goto op_semantics_89;
10688 break;
10689 default: UNSUPPORTED(); break;
10691 break;
10692 case 0x78:
10693 GETBYTE ();
10694 switch (op[2] & 0xf0)
10696 case 0x20:
10697 goto op_semantics_78;
10698 break;
10699 case 0x40:
10700 goto op_semantics_79;
10701 break;
10702 case 0x50:
10703 goto op_semantics_80;
10704 break;
10705 case 0x60:
10706 goto op_semantics_81;
10707 break;
10708 case 0x70:
10709 goto op_semantics_82;
10710 break;
10711 case 0x80:
10712 goto op_semantics_83;
10713 break;
10714 case 0x90:
10715 goto op_semantics_84;
10716 break;
10717 case 0xc0:
10718 goto op_semantics_85;
10719 break;
10720 case 0xd0:
10721 goto op_semantics_86;
10722 break;
10723 case 0xe0:
10724 goto op_semantics_87;
10725 break;
10726 case 0xf0:
10727 goto op_semantics_88;
10728 break;
10729 default: UNSUPPORTED(); break;
10731 break;
10732 case 0x7b:
10733 GETBYTE ();
10734 switch (op[2] & 0xe0)
10736 case 0x00:
10737 goto op_semantics_89;
10738 break;
10739 default: UNSUPPORTED(); break;
10741 break;
10742 case 0x7c:
10743 GETBYTE ();
10744 switch (op[2] & 0xf0)
10746 case 0x20:
10747 goto op_semantics_78;
10748 break;
10749 case 0x40:
10750 goto op_semantics_79;
10751 break;
10752 case 0x50:
10753 goto op_semantics_80;
10754 break;
10755 case 0x60:
10756 goto op_semantics_81;
10757 break;
10758 case 0x70:
10759 goto op_semantics_82;
10760 break;
10761 case 0x80:
10762 goto op_semantics_83;
10763 break;
10764 case 0x90:
10765 goto op_semantics_84;
10766 break;
10767 case 0xc0:
10768 goto op_semantics_85;
10769 break;
10770 case 0xd0:
10771 goto op_semantics_86;
10772 break;
10773 case 0xe0:
10774 goto op_semantics_87;
10775 break;
10776 case 0xf0:
10777 goto op_semantics_88;
10778 break;
10779 default: UNSUPPORTED(); break;
10781 break;
10782 case 0x7f:
10783 GETBYTE ();
10784 switch (op[2] & 0xe0)
10786 case 0x00:
10787 goto op_semantics_89;
10788 break;
10789 default: UNSUPPORTED(); break;
10791 break;
10792 case 0x80:
10793 GETBYTE ();
10794 switch (op[2] & 0x00)
10796 case 0x00:
10797 op_semantics_90:
10799 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
10800 #line 666 "rx-decode.opc"
10801 int immmm AU = op[1] & 0x1f;
10802 #line 666 "rx-decode.opc"
10803 int rsrc AU = (op[2] >> 4) & 0x0f;
10804 #line 666 "rx-decode.opc"
10805 int rdst AU = op[2] & 0x0f;
10806 if (trace)
10808 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10809 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10810 op[0], op[1], op[2]);
10811 printf (" immmm = 0x%x,", immmm);
10812 printf (" rsrc = 0x%x,", rsrc);
10813 printf (" rdst = 0x%x\n", rdst);
10815 SYNTAX("shlr #%2, %1, %0");
10816 #line 666 "rx-decode.opc"
10817 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F("-SZC");
10819 /*----------------------------------------------------------------------*/
10820 /* ROTATE */
10823 break;
10825 break;
10826 case 0x81:
10827 GETBYTE ();
10828 switch (op[2] & 0x00)
10830 case 0x00:
10831 goto op_semantics_90;
10832 break;
10834 break;
10835 case 0x82:
10836 GETBYTE ();
10837 switch (op[2] & 0x00)
10839 case 0x00:
10840 goto op_semantics_90;
10841 break;
10843 break;
10844 case 0x83:
10845 GETBYTE ();
10846 switch (op[2] & 0x00)
10848 case 0x00:
10849 goto op_semantics_90;
10850 break;
10852 break;
10853 case 0x84:
10854 GETBYTE ();
10855 switch (op[2] & 0x00)
10857 case 0x00:
10858 goto op_semantics_90;
10859 break;
10861 break;
10862 case 0x85:
10863 GETBYTE ();
10864 switch (op[2] & 0x00)
10866 case 0x00:
10867 goto op_semantics_90;
10868 break;
10870 break;
10871 case 0x86:
10872 GETBYTE ();
10873 switch (op[2] & 0x00)
10875 case 0x00:
10876 goto op_semantics_90;
10877 break;
10879 break;
10880 case 0x87:
10881 GETBYTE ();
10882 switch (op[2] & 0x00)
10884 case 0x00:
10885 goto op_semantics_90;
10886 break;
10888 break;
10889 case 0x88:
10890 GETBYTE ();
10891 switch (op[2] & 0x00)
10893 case 0x00:
10894 goto op_semantics_90;
10895 break;
10897 break;
10898 case 0x89:
10899 GETBYTE ();
10900 switch (op[2] & 0x00)
10902 case 0x00:
10903 goto op_semantics_90;
10904 break;
10906 break;
10907 case 0x8a:
10908 GETBYTE ();
10909 switch (op[2] & 0x00)
10911 case 0x00:
10912 goto op_semantics_90;
10913 break;
10915 break;
10916 case 0x8b:
10917 GETBYTE ();
10918 switch (op[2] & 0x00)
10920 case 0x00:
10921 goto op_semantics_90;
10922 break;
10924 break;
10925 case 0x8c:
10926 GETBYTE ();
10927 switch (op[2] & 0x00)
10929 case 0x00:
10930 goto op_semantics_90;
10931 break;
10933 break;
10934 case 0x8d:
10935 GETBYTE ();
10936 switch (op[2] & 0x00)
10938 case 0x00:
10939 goto op_semantics_90;
10940 break;
10942 break;
10943 case 0x8e:
10944 GETBYTE ();
10945 switch (op[2] & 0x00)
10947 case 0x00:
10948 goto op_semantics_90;
10949 break;
10951 break;
10952 case 0x8f:
10953 GETBYTE ();
10954 switch (op[2] & 0x00)
10956 case 0x00:
10957 goto op_semantics_90;
10958 break;
10960 break;
10961 case 0x90:
10962 GETBYTE ();
10963 switch (op[2] & 0x00)
10965 case 0x00:
10966 goto op_semantics_90;
10967 break;
10969 break;
10970 case 0x91:
10971 GETBYTE ();
10972 switch (op[2] & 0x00)
10974 case 0x00:
10975 goto op_semantics_90;
10976 break;
10978 break;
10979 case 0x92:
10980 GETBYTE ();
10981 switch (op[2] & 0x00)
10983 case 0x00:
10984 goto op_semantics_90;
10985 break;
10987 break;
10988 case 0x93:
10989 GETBYTE ();
10990 switch (op[2] & 0x00)
10992 case 0x00:
10993 goto op_semantics_90;
10994 break;
10996 break;
10997 case 0x94:
10998 GETBYTE ();
10999 switch (op[2] & 0x00)
11001 case 0x00:
11002 goto op_semantics_90;
11003 break;
11005 break;
11006 case 0x95:
11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11010 case 0x00:
11011 goto op_semantics_90;
11012 break;
11014 break;
11015 case 0x96:
11016 GETBYTE ();
11017 switch (op[2] & 0x00)
11019 case 0x00:
11020 goto op_semantics_90;
11021 break;
11023 break;
11024 case 0x97:
11025 GETBYTE ();
11026 switch (op[2] & 0x00)
11028 case 0x00:
11029 goto op_semantics_90;
11030 break;
11032 break;
11033 case 0x98:
11034 GETBYTE ();
11035 switch (op[2] & 0x00)
11037 case 0x00:
11038 goto op_semantics_90;
11039 break;
11041 break;
11042 case 0x99:
11043 GETBYTE ();
11044 switch (op[2] & 0x00)
11046 case 0x00:
11047 goto op_semantics_90;
11048 break;
11050 break;
11051 case 0x9a:
11052 GETBYTE ();
11053 switch (op[2] & 0x00)
11055 case 0x00:
11056 goto op_semantics_90;
11057 break;
11059 break;
11060 case 0x9b:
11061 GETBYTE ();
11062 switch (op[2] & 0x00)
11064 case 0x00:
11065 goto op_semantics_90;
11066 break;
11068 break;
11069 case 0x9c:
11070 GETBYTE ();
11071 switch (op[2] & 0x00)
11073 case 0x00:
11074 goto op_semantics_90;
11075 break;
11077 break;
11078 case 0x9d:
11079 GETBYTE ();
11080 switch (op[2] & 0x00)
11082 case 0x00:
11083 goto op_semantics_90;
11084 break;
11086 break;
11087 case 0x9e:
11088 GETBYTE ();
11089 switch (op[2] & 0x00)
11091 case 0x00:
11092 goto op_semantics_90;
11093 break;
11095 break;
11096 case 0x9f:
11097 GETBYTE ();
11098 switch (op[2] & 0x00)
11100 case 0x00:
11101 goto op_semantics_90;
11102 break;
11104 break;
11105 case 0xa0:
11106 GETBYTE ();
11107 switch (op[2] & 0x00)
11109 case 0x00:
11110 op_semantics_91:
11112 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
11113 #line 656 "rx-decode.opc"
11114 int immmm AU = op[1] & 0x1f;
11115 #line 656 "rx-decode.opc"
11116 int rsrc AU = (op[2] >> 4) & 0x0f;
11117 #line 656 "rx-decode.opc"
11118 int rdst AU = op[2] & 0x0f;
11119 if (trace)
11121 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11122 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11123 op[0], op[1], op[2]);
11124 printf (" immmm = 0x%x,", immmm);
11125 printf (" rsrc = 0x%x,", rsrc);
11126 printf (" rdst = 0x%x\n", rdst);
11128 SYNTAX("shar #%2, %1, %0");
11129 #line 656 "rx-decode.opc"
11130 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F("0SZC");
11134 break;
11136 break;
11137 case 0xa1:
11138 GETBYTE ();
11139 switch (op[2] & 0x00)
11141 case 0x00:
11142 goto op_semantics_91;
11143 break;
11145 break;
11146 case 0xa2:
11147 GETBYTE ();
11148 switch (op[2] & 0x00)
11150 case 0x00:
11151 goto op_semantics_91;
11152 break;
11154 break;
11155 case 0xa3:
11156 GETBYTE ();
11157 switch (op[2] & 0x00)
11159 case 0x00:
11160 goto op_semantics_91;
11161 break;
11163 break;
11164 case 0xa4:
11165 GETBYTE ();
11166 switch (op[2] & 0x00)
11168 case 0x00:
11169 goto op_semantics_91;
11170 break;
11172 break;
11173 case 0xa5:
11174 GETBYTE ();
11175 switch (op[2] & 0x00)
11177 case 0x00:
11178 goto op_semantics_91;
11179 break;
11181 break;
11182 case 0xa6:
11183 GETBYTE ();
11184 switch (op[2] & 0x00)
11186 case 0x00:
11187 goto op_semantics_91;
11188 break;
11190 break;
11191 case 0xa7:
11192 GETBYTE ();
11193 switch (op[2] & 0x00)
11195 case 0x00:
11196 goto op_semantics_91;
11197 break;
11199 break;
11200 case 0xa8:
11201 GETBYTE ();
11202 switch (op[2] & 0x00)
11204 case 0x00:
11205 goto op_semantics_91;
11206 break;
11208 break;
11209 case 0xa9:
11210 GETBYTE ();
11211 switch (op[2] & 0x00)
11213 case 0x00:
11214 goto op_semantics_91;
11215 break;
11217 break;
11218 case 0xaa:
11219 GETBYTE ();
11220 switch (op[2] & 0x00)
11222 case 0x00:
11223 goto op_semantics_91;
11224 break;
11226 break;
11227 case 0xab:
11228 GETBYTE ();
11229 switch (op[2] & 0x00)
11231 case 0x00:
11232 goto op_semantics_91;
11233 break;
11235 break;
11236 case 0xac:
11237 GETBYTE ();
11238 switch (op[2] & 0x00)
11240 case 0x00:
11241 goto op_semantics_91;
11242 break;
11244 break;
11245 case 0xad:
11246 GETBYTE ();
11247 switch (op[2] & 0x00)
11249 case 0x00:
11250 goto op_semantics_91;
11251 break;
11253 break;
11254 case 0xae:
11255 GETBYTE ();
11256 switch (op[2] & 0x00)
11258 case 0x00:
11259 goto op_semantics_91;
11260 break;
11262 break;
11263 case 0xaf:
11264 GETBYTE ();
11265 switch (op[2] & 0x00)
11267 case 0x00:
11268 goto op_semantics_91;
11269 break;
11271 break;
11272 case 0xb0:
11273 GETBYTE ();
11274 switch (op[2] & 0x00)
11276 case 0x00:
11277 goto op_semantics_91;
11278 break;
11280 break;
11281 case 0xb1:
11282 GETBYTE ();
11283 switch (op[2] & 0x00)
11285 case 0x00:
11286 goto op_semantics_91;
11287 break;
11289 break;
11290 case 0xb2:
11291 GETBYTE ();
11292 switch (op[2] & 0x00)
11294 case 0x00:
11295 goto op_semantics_91;
11296 break;
11298 break;
11299 case 0xb3:
11300 GETBYTE ();
11301 switch (op[2] & 0x00)
11303 case 0x00:
11304 goto op_semantics_91;
11305 break;
11307 break;
11308 case 0xb4:
11309 GETBYTE ();
11310 switch (op[2] & 0x00)
11312 case 0x00:
11313 goto op_semantics_91;
11314 break;
11316 break;
11317 case 0xb5:
11318 GETBYTE ();
11319 switch (op[2] & 0x00)
11321 case 0x00:
11322 goto op_semantics_91;
11323 break;
11325 break;
11326 case 0xb6:
11327 GETBYTE ();
11328 switch (op[2] & 0x00)
11330 case 0x00:
11331 goto op_semantics_91;
11332 break;
11334 break;
11335 case 0xb7:
11336 GETBYTE ();
11337 switch (op[2] & 0x00)
11339 case 0x00:
11340 goto op_semantics_91;
11341 break;
11343 break;
11344 case 0xb8:
11345 GETBYTE ();
11346 switch (op[2] & 0x00)
11348 case 0x00:
11349 goto op_semantics_91;
11350 break;
11352 break;
11353 case 0xb9:
11354 GETBYTE ();
11355 switch (op[2] & 0x00)
11357 case 0x00:
11358 goto op_semantics_91;
11359 break;
11361 break;
11362 case 0xba:
11363 GETBYTE ();
11364 switch (op[2] & 0x00)
11366 case 0x00:
11367 goto op_semantics_91;
11368 break;
11370 break;
11371 case 0xbb:
11372 GETBYTE ();
11373 switch (op[2] & 0x00)
11375 case 0x00:
11376 goto op_semantics_91;
11377 break;
11379 break;
11380 case 0xbc:
11381 GETBYTE ();
11382 switch (op[2] & 0x00)
11384 case 0x00:
11385 goto op_semantics_91;
11386 break;
11388 break;
11389 case 0xbd:
11390 GETBYTE ();
11391 switch (op[2] & 0x00)
11393 case 0x00:
11394 goto op_semantics_91;
11395 break;
11397 break;
11398 case 0xbe:
11399 GETBYTE ();
11400 switch (op[2] & 0x00)
11402 case 0x00:
11403 goto op_semantics_91;
11404 break;
11406 break;
11407 case 0xbf:
11408 GETBYTE ();
11409 switch (op[2] & 0x00)
11411 case 0x00:
11412 goto op_semantics_91;
11413 break;
11415 break;
11416 case 0xc0:
11417 GETBYTE ();
11418 switch (op[2] & 0x00)
11420 case 0x00:
11421 op_semantics_92:
11423 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
11424 #line 646 "rx-decode.opc"
11425 int immmm AU = op[1] & 0x1f;
11426 #line 646 "rx-decode.opc"
11427 int rsrc AU = (op[2] >> 4) & 0x0f;
11428 #line 646 "rx-decode.opc"
11429 int rdst AU = op[2] & 0x0f;
11430 if (trace)
11432 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11433 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11434 op[0], op[1], op[2]);
11435 printf (" immmm = 0x%x,", immmm);
11436 printf (" rsrc = 0x%x,", rsrc);
11437 printf (" rdst = 0x%x\n", rdst);
11439 SYNTAX("shll #%2, %1, %0");
11440 #line 646 "rx-decode.opc"
11441 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F("OSZC");
11445 break;
11447 break;
11448 case 0xc1:
11449 GETBYTE ();
11450 switch (op[2] & 0x00)
11452 case 0x00:
11453 goto op_semantics_92;
11454 break;
11456 break;
11457 case 0xc2:
11458 GETBYTE ();
11459 switch (op[2] & 0x00)
11461 case 0x00:
11462 goto op_semantics_92;
11463 break;
11465 break;
11466 case 0xc3:
11467 GETBYTE ();
11468 switch (op[2] & 0x00)
11470 case 0x00:
11471 goto op_semantics_92;
11472 break;
11474 break;
11475 case 0xc4:
11476 GETBYTE ();
11477 switch (op[2] & 0x00)
11479 case 0x00:
11480 goto op_semantics_92;
11481 break;
11483 break;
11484 case 0xc5:
11485 GETBYTE ();
11486 switch (op[2] & 0x00)
11488 case 0x00:
11489 goto op_semantics_92;
11490 break;
11492 break;
11493 case 0xc6:
11494 GETBYTE ();
11495 switch (op[2] & 0x00)
11497 case 0x00:
11498 goto op_semantics_92;
11499 break;
11501 break;
11502 case 0xc7:
11503 GETBYTE ();
11504 switch (op[2] & 0x00)
11506 case 0x00:
11507 goto op_semantics_92;
11508 break;
11510 break;
11511 case 0xc8:
11512 GETBYTE ();
11513 switch (op[2] & 0x00)
11515 case 0x00:
11516 goto op_semantics_92;
11517 break;
11519 break;
11520 case 0xc9:
11521 GETBYTE ();
11522 switch (op[2] & 0x00)
11524 case 0x00:
11525 goto op_semantics_92;
11526 break;
11528 break;
11529 case 0xca:
11530 GETBYTE ();
11531 switch (op[2] & 0x00)
11533 case 0x00:
11534 goto op_semantics_92;
11535 break;
11537 break;
11538 case 0xcb:
11539 GETBYTE ();
11540 switch (op[2] & 0x00)
11542 case 0x00:
11543 goto op_semantics_92;
11544 break;
11546 break;
11547 case 0xcc:
11548 GETBYTE ();
11549 switch (op[2] & 0x00)
11551 case 0x00:
11552 goto op_semantics_92;
11553 break;
11555 break;
11556 case 0xcd:
11557 GETBYTE ();
11558 switch (op[2] & 0x00)
11560 case 0x00:
11561 goto op_semantics_92;
11562 break;
11564 break;
11565 case 0xce:
11566 GETBYTE ();
11567 switch (op[2] & 0x00)
11569 case 0x00:
11570 goto op_semantics_92;
11571 break;
11573 break;
11574 case 0xcf:
11575 GETBYTE ();
11576 switch (op[2] & 0x00)
11578 case 0x00:
11579 goto op_semantics_92;
11580 break;
11582 break;
11583 case 0xd0:
11584 GETBYTE ();
11585 switch (op[2] & 0x00)
11587 case 0x00:
11588 goto op_semantics_92;
11589 break;
11591 break;
11592 case 0xd1:
11593 GETBYTE ();
11594 switch (op[2] & 0x00)
11596 case 0x00:
11597 goto op_semantics_92;
11598 break;
11600 break;
11601 case 0xd2:
11602 GETBYTE ();
11603 switch (op[2] & 0x00)
11605 case 0x00:
11606 goto op_semantics_92;
11607 break;
11609 break;
11610 case 0xd3:
11611 GETBYTE ();
11612 switch (op[2] & 0x00)
11614 case 0x00:
11615 goto op_semantics_92;
11616 break;
11618 break;
11619 case 0xd4:
11620 GETBYTE ();
11621 switch (op[2] & 0x00)
11623 case 0x00:
11624 goto op_semantics_92;
11625 break;
11627 break;
11628 case 0xd5:
11629 GETBYTE ();
11630 switch (op[2] & 0x00)
11632 case 0x00:
11633 goto op_semantics_92;
11634 break;
11636 break;
11637 case 0xd6:
11638 GETBYTE ();
11639 switch (op[2] & 0x00)
11641 case 0x00:
11642 goto op_semantics_92;
11643 break;
11645 break;
11646 case 0xd7:
11647 GETBYTE ();
11648 switch (op[2] & 0x00)
11650 case 0x00:
11651 goto op_semantics_92;
11652 break;
11654 break;
11655 case 0xd8:
11656 GETBYTE ();
11657 switch (op[2] & 0x00)
11659 case 0x00:
11660 goto op_semantics_92;
11661 break;
11663 break;
11664 case 0xd9:
11665 GETBYTE ();
11666 switch (op[2] & 0x00)
11668 case 0x00:
11669 goto op_semantics_92;
11670 break;
11672 break;
11673 case 0xda:
11674 GETBYTE ();
11675 switch (op[2] & 0x00)
11677 case 0x00:
11678 goto op_semantics_92;
11679 break;
11681 break;
11682 case 0xdb:
11683 GETBYTE ();
11684 switch (op[2] & 0x00)
11686 case 0x00:
11687 goto op_semantics_92;
11688 break;
11690 break;
11691 case 0xdc:
11692 GETBYTE ();
11693 switch (op[2] & 0x00)
11695 case 0x00:
11696 goto op_semantics_92;
11697 break;
11699 break;
11700 case 0xdd:
11701 GETBYTE ();
11702 switch (op[2] & 0x00)
11704 case 0x00:
11705 goto op_semantics_92;
11706 break;
11708 break;
11709 case 0xde:
11710 GETBYTE ();
11711 switch (op[2] & 0x00)
11713 case 0x00:
11714 goto op_semantics_92;
11715 break;
11717 break;
11718 case 0xdf:
11719 GETBYTE ();
11720 switch (op[2] & 0x00)
11722 case 0x00:
11723 goto op_semantics_92;
11724 break;
11726 break;
11727 case 0xe0:
11728 GETBYTE ();
11729 switch (op[2] & 0xf0)
11731 case 0x00:
11732 case 0x10:
11733 case 0x20:
11734 case 0x30:
11735 case 0x40:
11736 case 0x50:
11737 case 0x60:
11738 case 0x70:
11739 case 0x80:
11740 case 0x90:
11741 case 0xa0:
11742 case 0xb0:
11743 case 0xc0:
11744 case 0xd0:
11745 case 0xe0:
11746 op_semantics_93:
11748 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
11749 #line 912 "rx-decode.opc"
11750 int bittt AU = op[1] & 0x1f;
11751 #line 912 "rx-decode.opc"
11752 int cond AU = (op[2] >> 4) & 0x0f;
11753 #line 912 "rx-decode.opc"
11754 int rdst AU = op[2] & 0x0f;
11755 if (trace)
11757 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11758 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11759 op[0], op[1], op[2]);
11760 printf (" bittt = 0x%x,", bittt);
11761 printf (" cond = 0x%x,", cond);
11762 printf (" rdst = 0x%x\n", rdst);
11764 SYNTAX("bm%2 #%1, %0%S0");
11765 #line 912 "rx-decode.opc"
11766 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11768 /*----------------------------------------------------------------------*/
11769 /* CONTROL REGISTERS */
11772 break;
11773 case 0xf0:
11774 op_semantics_94:
11776 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
11777 #line 905 "rx-decode.opc"
11778 int bittt AU = op[1] & 0x1f;
11779 #line 905 "rx-decode.opc"
11780 int rdst AU = op[2] & 0x0f;
11781 if (trace)
11783 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11784 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11785 op[0], op[1], op[2]);
11786 printf (" bittt = 0x%x,", bittt);
11787 printf (" rdst = 0x%x\n", rdst);
11789 SYNTAX("bnot #%1, %0");
11790 #line 905 "rx-decode.opc"
11791 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11795 break;
11797 break;
11798 case 0xe1:
11799 GETBYTE ();
11800 switch (op[2] & 0xf0)
11802 case 0x00:
11803 case 0x10:
11804 case 0x20:
11805 case 0x30:
11806 case 0x40:
11807 case 0x50:
11808 case 0x60:
11809 case 0x70:
11810 case 0x80:
11811 case 0x90:
11812 case 0xa0:
11813 case 0xb0:
11814 case 0xc0:
11815 case 0xd0:
11816 case 0xe0:
11817 goto op_semantics_93;
11818 break;
11819 case 0xf0:
11820 goto op_semantics_94;
11821 break;
11823 break;
11824 case 0xe2:
11825 GETBYTE ();
11826 switch (op[2] & 0xf0)
11828 case 0x00:
11829 case 0x10:
11830 case 0x20:
11831 case 0x30:
11832 case 0x40:
11833 case 0x50:
11834 case 0x60:
11835 case 0x70:
11836 case 0x80:
11837 case 0x90:
11838 case 0xa0:
11839 case 0xb0:
11840 case 0xc0:
11841 case 0xd0:
11842 case 0xe0:
11843 goto op_semantics_93;
11844 break;
11845 case 0xf0:
11846 goto op_semantics_94;
11847 break;
11849 break;
11850 case 0xe3:
11851 GETBYTE ();
11852 switch (op[2] & 0xf0)
11854 case 0x00:
11855 case 0x10:
11856 case 0x20:
11857 case 0x30:
11858 case 0x40:
11859 case 0x50:
11860 case 0x60:
11861 case 0x70:
11862 case 0x80:
11863 case 0x90:
11864 case 0xa0:
11865 case 0xb0:
11866 case 0xc0:
11867 case 0xd0:
11868 case 0xe0:
11869 goto op_semantics_93;
11870 break;
11871 case 0xf0:
11872 goto op_semantics_94;
11873 break;
11875 break;
11876 case 0xe4:
11877 GETBYTE ();
11878 switch (op[2] & 0xf0)
11880 case 0x00:
11881 case 0x10:
11882 case 0x20:
11883 case 0x30:
11884 case 0x40:
11885 case 0x50:
11886 case 0x60:
11887 case 0x70:
11888 case 0x80:
11889 case 0x90:
11890 case 0xa0:
11891 case 0xb0:
11892 case 0xc0:
11893 case 0xd0:
11894 case 0xe0:
11895 goto op_semantics_93;
11896 break;
11897 case 0xf0:
11898 goto op_semantics_94;
11899 break;
11901 break;
11902 case 0xe5:
11903 GETBYTE ();
11904 switch (op[2] & 0xf0)
11906 case 0x00:
11907 case 0x10:
11908 case 0x20:
11909 case 0x30:
11910 case 0x40:
11911 case 0x50:
11912 case 0x60:
11913 case 0x70:
11914 case 0x80:
11915 case 0x90:
11916 case 0xa0:
11917 case 0xb0:
11918 case 0xc0:
11919 case 0xd0:
11920 case 0xe0:
11921 goto op_semantics_93;
11922 break;
11923 case 0xf0:
11924 goto op_semantics_94;
11925 break;
11927 break;
11928 case 0xe6:
11929 GETBYTE ();
11930 switch (op[2] & 0xf0)
11932 case 0x00:
11933 case 0x10:
11934 case 0x20:
11935 case 0x30:
11936 case 0x40:
11937 case 0x50:
11938 case 0x60:
11939 case 0x70:
11940 case 0x80:
11941 case 0x90:
11942 case 0xa0:
11943 case 0xb0:
11944 case 0xc0:
11945 case 0xd0:
11946 case 0xe0:
11947 goto op_semantics_93;
11948 break;
11949 case 0xf0:
11950 goto op_semantics_94;
11951 break;
11953 break;
11954 case 0xe7:
11955 GETBYTE ();
11956 switch (op[2] & 0xf0)
11958 case 0x00:
11959 case 0x10:
11960 case 0x20:
11961 case 0x30:
11962 case 0x40:
11963 case 0x50:
11964 case 0x60:
11965 case 0x70:
11966 case 0x80:
11967 case 0x90:
11968 case 0xa0:
11969 case 0xb0:
11970 case 0xc0:
11971 case 0xd0:
11972 case 0xe0:
11973 goto op_semantics_93;
11974 break;
11975 case 0xf0:
11976 goto op_semantics_94;
11977 break;
11979 break;
11980 case 0xe8:
11981 GETBYTE ();
11982 switch (op[2] & 0xf0)
11984 case 0x00:
11985 case 0x10:
11986 case 0x20:
11987 case 0x30:
11988 case 0x40:
11989 case 0x50:
11990 case 0x60:
11991 case 0x70:
11992 case 0x80:
11993 case 0x90:
11994 case 0xa0:
11995 case 0xb0:
11996 case 0xc0:
11997 case 0xd0:
11998 case 0xe0:
11999 goto op_semantics_93;
12000 break;
12001 case 0xf0:
12002 goto op_semantics_94;
12003 break;
12005 break;
12006 case 0xe9:
12007 GETBYTE ();
12008 switch (op[2] & 0xf0)
12010 case 0x00:
12011 case 0x10:
12012 case 0x20:
12013 case 0x30:
12014 case 0x40:
12015 case 0x50:
12016 case 0x60:
12017 case 0x70:
12018 case 0x80:
12019 case 0x90:
12020 case 0xa0:
12021 case 0xb0:
12022 case 0xc0:
12023 case 0xd0:
12024 case 0xe0:
12025 goto op_semantics_93;
12026 break;
12027 case 0xf0:
12028 goto op_semantics_94;
12029 break;
12031 break;
12032 case 0xea:
12033 GETBYTE ();
12034 switch (op[2] & 0xf0)
12036 case 0x00:
12037 case 0x10:
12038 case 0x20:
12039 case 0x30:
12040 case 0x40:
12041 case 0x50:
12042 case 0x60:
12043 case 0x70:
12044 case 0x80:
12045 case 0x90:
12046 case 0xa0:
12047 case 0xb0:
12048 case 0xc0:
12049 case 0xd0:
12050 case 0xe0:
12051 goto op_semantics_93;
12052 break;
12053 case 0xf0:
12054 goto op_semantics_94;
12055 break;
12057 break;
12058 case 0xeb:
12059 GETBYTE ();
12060 switch (op[2] & 0xf0)
12062 case 0x00:
12063 case 0x10:
12064 case 0x20:
12065 case 0x30:
12066 case 0x40:
12067 case 0x50:
12068 case 0x60:
12069 case 0x70:
12070 case 0x80:
12071 case 0x90:
12072 case 0xa0:
12073 case 0xb0:
12074 case 0xc0:
12075 case 0xd0:
12076 case 0xe0:
12077 goto op_semantics_93;
12078 break;
12079 case 0xf0:
12080 goto op_semantics_94;
12081 break;
12083 break;
12084 case 0xec:
12085 GETBYTE ();
12086 switch (op[2] & 0xf0)
12088 case 0x00:
12089 case 0x10:
12090 case 0x20:
12091 case 0x30:
12092 case 0x40:
12093 case 0x50:
12094 case 0x60:
12095 case 0x70:
12096 case 0x80:
12097 case 0x90:
12098 case 0xa0:
12099 case 0xb0:
12100 case 0xc0:
12101 case 0xd0:
12102 case 0xe0:
12103 goto op_semantics_93;
12104 break;
12105 case 0xf0:
12106 goto op_semantics_94;
12107 break;
12109 break;
12110 case 0xed:
12111 GETBYTE ();
12112 switch (op[2] & 0xf0)
12114 case 0x00:
12115 case 0x10:
12116 case 0x20:
12117 case 0x30:
12118 case 0x40:
12119 case 0x50:
12120 case 0x60:
12121 case 0x70:
12122 case 0x80:
12123 case 0x90:
12124 case 0xa0:
12125 case 0xb0:
12126 case 0xc0:
12127 case 0xd0:
12128 case 0xe0:
12129 goto op_semantics_93;
12130 break;
12131 case 0xf0:
12132 goto op_semantics_94;
12133 break;
12135 break;
12136 case 0xee:
12137 GETBYTE ();
12138 switch (op[2] & 0xf0)
12140 case 0x00:
12141 case 0x10:
12142 case 0x20:
12143 case 0x30:
12144 case 0x40:
12145 case 0x50:
12146 case 0x60:
12147 case 0x70:
12148 case 0x80:
12149 case 0x90:
12150 case 0xa0:
12151 case 0xb0:
12152 case 0xc0:
12153 case 0xd0:
12154 case 0xe0:
12155 goto op_semantics_93;
12156 break;
12157 case 0xf0:
12158 goto op_semantics_94;
12159 break;
12161 break;
12162 case 0xef:
12163 GETBYTE ();
12164 switch (op[2] & 0xf0)
12166 case 0x00:
12167 case 0x10:
12168 case 0x20:
12169 case 0x30:
12170 case 0x40:
12171 case 0x50:
12172 case 0x60:
12173 case 0x70:
12174 case 0x80:
12175 case 0x90:
12176 case 0xa0:
12177 case 0xb0:
12178 case 0xc0:
12179 case 0xd0:
12180 case 0xe0:
12181 goto op_semantics_93;
12182 break;
12183 case 0xf0:
12184 goto op_semantics_94;
12185 break;
12187 break;
12188 case 0xf0:
12189 GETBYTE ();
12190 switch (op[2] & 0xf0)
12192 case 0x00:
12193 case 0x10:
12194 case 0x20:
12195 case 0x30:
12196 case 0x40:
12197 case 0x50:
12198 case 0x60:
12199 case 0x70:
12200 case 0x80:
12201 case 0x90:
12202 case 0xa0:
12203 case 0xb0:
12204 case 0xc0:
12205 case 0xd0:
12206 case 0xe0:
12207 goto op_semantics_93;
12208 break;
12209 case 0xf0:
12210 goto op_semantics_94;
12211 break;
12213 break;
12214 case 0xf1:
12215 GETBYTE ();
12216 switch (op[2] & 0xf0)
12218 case 0x00:
12219 case 0x10:
12220 case 0x20:
12221 case 0x30:
12222 case 0x40:
12223 case 0x50:
12224 case 0x60:
12225 case 0x70:
12226 case 0x80:
12227 case 0x90:
12228 case 0xa0:
12229 case 0xb0:
12230 case 0xc0:
12231 case 0xd0:
12232 case 0xe0:
12233 goto op_semantics_93;
12234 break;
12235 case 0xf0:
12236 goto op_semantics_94;
12237 break;
12239 break;
12240 case 0xf2:
12241 GETBYTE ();
12242 switch (op[2] & 0xf0)
12244 case 0x00:
12245 case 0x10:
12246 case 0x20:
12247 case 0x30:
12248 case 0x40:
12249 case 0x50:
12250 case 0x60:
12251 case 0x70:
12252 case 0x80:
12253 case 0x90:
12254 case 0xa0:
12255 case 0xb0:
12256 case 0xc0:
12257 case 0xd0:
12258 case 0xe0:
12259 goto op_semantics_93;
12260 break;
12261 case 0xf0:
12262 goto op_semantics_94;
12263 break;
12265 break;
12266 case 0xf3:
12267 GETBYTE ();
12268 switch (op[2] & 0xf0)
12270 case 0x00:
12271 case 0x10:
12272 case 0x20:
12273 case 0x30:
12274 case 0x40:
12275 case 0x50:
12276 case 0x60:
12277 case 0x70:
12278 case 0x80:
12279 case 0x90:
12280 case 0xa0:
12281 case 0xb0:
12282 case 0xc0:
12283 case 0xd0:
12284 case 0xe0:
12285 goto op_semantics_93;
12286 break;
12287 case 0xf0:
12288 goto op_semantics_94;
12289 break;
12291 break;
12292 case 0xf4:
12293 GETBYTE ();
12294 switch (op[2] & 0xf0)
12296 case 0x00:
12297 case 0x10:
12298 case 0x20:
12299 case 0x30:
12300 case 0x40:
12301 case 0x50:
12302 case 0x60:
12303 case 0x70:
12304 case 0x80:
12305 case 0x90:
12306 case 0xa0:
12307 case 0xb0:
12308 case 0xc0:
12309 case 0xd0:
12310 case 0xe0:
12311 goto op_semantics_93;
12312 break;
12313 case 0xf0:
12314 goto op_semantics_94;
12315 break;
12317 break;
12318 case 0xf5:
12319 GETBYTE ();
12320 switch (op[2] & 0xf0)
12322 case 0x00:
12323 case 0x10:
12324 case 0x20:
12325 case 0x30:
12326 case 0x40:
12327 case 0x50:
12328 case 0x60:
12329 case 0x70:
12330 case 0x80:
12331 case 0x90:
12332 case 0xa0:
12333 case 0xb0:
12334 case 0xc0:
12335 case 0xd0:
12336 case 0xe0:
12337 goto op_semantics_93;
12338 break;
12339 case 0xf0:
12340 goto op_semantics_94;
12341 break;
12343 break;
12344 case 0xf6:
12345 GETBYTE ();
12346 switch (op[2] & 0xf0)
12348 case 0x00:
12349 case 0x10:
12350 case 0x20:
12351 case 0x30:
12352 case 0x40:
12353 case 0x50:
12354 case 0x60:
12355 case 0x70:
12356 case 0x80:
12357 case 0x90:
12358 case 0xa0:
12359 case 0xb0:
12360 case 0xc0:
12361 case 0xd0:
12362 case 0xe0:
12363 goto op_semantics_93;
12364 break;
12365 case 0xf0:
12366 goto op_semantics_94;
12367 break;
12369 break;
12370 case 0xf7:
12371 GETBYTE ();
12372 switch (op[2] & 0xf0)
12374 case 0x00:
12375 case 0x10:
12376 case 0x20:
12377 case 0x30:
12378 case 0x40:
12379 case 0x50:
12380 case 0x60:
12381 case 0x70:
12382 case 0x80:
12383 case 0x90:
12384 case 0xa0:
12385 case 0xb0:
12386 case 0xc0:
12387 case 0xd0:
12388 case 0xe0:
12389 goto op_semantics_93;
12390 break;
12391 case 0xf0:
12392 goto op_semantics_94;
12393 break;
12395 break;
12396 case 0xf8:
12397 GETBYTE ();
12398 switch (op[2] & 0xf0)
12400 case 0x00:
12401 case 0x10:
12402 case 0x20:
12403 case 0x30:
12404 case 0x40:
12405 case 0x50:
12406 case 0x60:
12407 case 0x70:
12408 case 0x80:
12409 case 0x90:
12410 case 0xa0:
12411 case 0xb0:
12412 case 0xc0:
12413 case 0xd0:
12414 case 0xe0:
12415 goto op_semantics_93;
12416 break;
12417 case 0xf0:
12418 goto op_semantics_94;
12419 break;
12421 break;
12422 case 0xf9:
12423 GETBYTE ();
12424 switch (op[2] & 0xf0)
12426 case 0x00:
12427 case 0x10:
12428 case 0x20:
12429 case 0x30:
12430 case 0x40:
12431 case 0x50:
12432 case 0x60:
12433 case 0x70:
12434 case 0x80:
12435 case 0x90:
12436 case 0xa0:
12437 case 0xb0:
12438 case 0xc0:
12439 case 0xd0:
12440 case 0xe0:
12441 goto op_semantics_93;
12442 break;
12443 case 0xf0:
12444 goto op_semantics_94;
12445 break;
12447 break;
12448 case 0xfa:
12449 GETBYTE ();
12450 switch (op[2] & 0xf0)
12452 case 0x00:
12453 case 0x10:
12454 case 0x20:
12455 case 0x30:
12456 case 0x40:
12457 case 0x50:
12458 case 0x60:
12459 case 0x70:
12460 case 0x80:
12461 case 0x90:
12462 case 0xa0:
12463 case 0xb0:
12464 case 0xc0:
12465 case 0xd0:
12466 case 0xe0:
12467 goto op_semantics_93;
12468 break;
12469 case 0xf0:
12470 goto op_semantics_94;
12471 break;
12473 break;
12474 case 0xfb:
12475 GETBYTE ();
12476 switch (op[2] & 0xf0)
12478 case 0x00:
12479 case 0x10:
12480 case 0x20:
12481 case 0x30:
12482 case 0x40:
12483 case 0x50:
12484 case 0x60:
12485 case 0x70:
12486 case 0x80:
12487 case 0x90:
12488 case 0xa0:
12489 case 0xb0:
12490 case 0xc0:
12491 case 0xd0:
12492 case 0xe0:
12493 goto op_semantics_93;
12494 break;
12495 case 0xf0:
12496 goto op_semantics_94;
12497 break;
12499 break;
12500 case 0xfc:
12501 GETBYTE ();
12502 switch (op[2] & 0xf0)
12504 case 0x00:
12505 case 0x10:
12506 case 0x20:
12507 case 0x30:
12508 case 0x40:
12509 case 0x50:
12510 case 0x60:
12511 case 0x70:
12512 case 0x80:
12513 case 0x90:
12514 case 0xa0:
12515 case 0xb0:
12516 case 0xc0:
12517 case 0xd0:
12518 case 0xe0:
12519 goto op_semantics_93;
12520 break;
12521 case 0xf0:
12522 goto op_semantics_94;
12523 break;
12525 break;
12526 case 0xfd:
12527 GETBYTE ();
12528 switch (op[2] & 0xf0)
12530 case 0x00:
12531 case 0x10:
12532 case 0x20:
12533 case 0x30:
12534 case 0x40:
12535 case 0x50:
12536 case 0x60:
12537 case 0x70:
12538 case 0x80:
12539 case 0x90:
12540 case 0xa0:
12541 case 0xb0:
12542 case 0xc0:
12543 case 0xd0:
12544 case 0xe0:
12545 goto op_semantics_93;
12546 break;
12547 case 0xf0:
12548 goto op_semantics_94;
12549 break;
12551 break;
12552 case 0xfe:
12553 GETBYTE ();
12554 switch (op[2] & 0xf0)
12556 case 0x00:
12557 case 0x10:
12558 case 0x20:
12559 case 0x30:
12560 case 0x40:
12561 case 0x50:
12562 case 0x60:
12563 case 0x70:
12564 case 0x80:
12565 case 0x90:
12566 case 0xa0:
12567 case 0xb0:
12568 case 0xc0:
12569 case 0xd0:
12570 case 0xe0:
12571 goto op_semantics_93;
12572 break;
12573 case 0xf0:
12574 goto op_semantics_94;
12575 break;
12577 break;
12578 case 0xff:
12579 GETBYTE ();
12580 switch (op[2] & 0xf0)
12582 case 0x00:
12583 case 0x10:
12584 case 0x20:
12585 case 0x30:
12586 case 0x40:
12587 case 0x50:
12588 case 0x60:
12589 case 0x70:
12590 case 0x80:
12591 case 0x90:
12592 case 0xa0:
12593 case 0xb0:
12594 case 0xc0:
12595 case 0xd0:
12596 case 0xe0:
12597 goto op_semantics_93;
12598 break;
12599 case 0xf0:
12600 goto op_semantics_94;
12601 break;
12603 break;
12604 default: UNSUPPORTED(); break;
12606 break;
12607 case 0xfe:
12608 GETBYTE ();
12609 switch (op[1] & 0xff)
12611 case 0x00:
12612 GETBYTE ();
12613 switch (op[2] & 0x00)
12615 case 0x00:
12616 op_semantics_95:
12618 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
12619 #line 318 "rx-decode.opc"
12620 int sz AU = (op[1] >> 4) & 0x03;
12621 #line 318 "rx-decode.opc"
12622 int isrc AU = op[1] & 0x0f;
12623 #line 318 "rx-decode.opc"
12624 int bsrc AU = (op[2] >> 4) & 0x0f;
12625 #line 318 "rx-decode.opc"
12626 int rdst AU = op[2] & 0x0f;
12627 if (trace)
12629 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12630 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12631 op[0], op[1], op[2]);
12632 printf (" sz = 0x%x,", sz);
12633 printf (" isrc = 0x%x,", isrc);
12634 printf (" bsrc = 0x%x,", bsrc);
12635 printf (" rdst = 0x%x\n", rdst);
12637 SYNTAX("mov%s %0, [%1, %2]");
12638 #line 318 "rx-decode.opc"
12639 ID(movbir); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
12642 break;
12644 break;
12645 case 0x01:
12646 GETBYTE ();
12647 switch (op[2] & 0x00)
12649 case 0x00:
12650 goto op_semantics_95;
12651 break;
12653 break;
12654 case 0x02:
12655 GETBYTE ();
12656 switch (op[2] & 0x00)
12658 case 0x00:
12659 goto op_semantics_95;
12660 break;
12662 break;
12663 case 0x03:
12664 GETBYTE ();
12665 switch (op[2] & 0x00)
12667 case 0x00:
12668 goto op_semantics_95;
12669 break;
12671 break;
12672 case 0x04:
12673 GETBYTE ();
12674 switch (op[2] & 0x00)
12676 case 0x00:
12677 goto op_semantics_95;
12678 break;
12680 break;
12681 case 0x05:
12682 GETBYTE ();
12683 switch (op[2] & 0x00)
12685 case 0x00:
12686 goto op_semantics_95;
12687 break;
12689 break;
12690 case 0x06:
12691 GETBYTE ();
12692 switch (op[2] & 0x00)
12694 case 0x00:
12695 goto op_semantics_95;
12696 break;
12698 break;
12699 case 0x07:
12700 GETBYTE ();
12701 switch (op[2] & 0x00)
12703 case 0x00:
12704 goto op_semantics_95;
12705 break;
12707 break;
12708 case 0x08:
12709 GETBYTE ();
12710 switch (op[2] & 0x00)
12712 case 0x00:
12713 goto op_semantics_95;
12714 break;
12716 break;
12717 case 0x09:
12718 GETBYTE ();
12719 switch (op[2] & 0x00)
12721 case 0x00:
12722 goto op_semantics_95;
12723 break;
12725 break;
12726 case 0x0a:
12727 GETBYTE ();
12728 switch (op[2] & 0x00)
12730 case 0x00:
12731 goto op_semantics_95;
12732 break;
12734 break;
12735 case 0x0b:
12736 GETBYTE ();
12737 switch (op[2] & 0x00)
12739 case 0x00:
12740 goto op_semantics_95;
12741 break;
12743 break;
12744 case 0x0c:
12745 GETBYTE ();
12746 switch (op[2] & 0x00)
12748 case 0x00:
12749 goto op_semantics_95;
12750 break;
12752 break;
12753 case 0x0d:
12754 GETBYTE ();
12755 switch (op[2] & 0x00)
12757 case 0x00:
12758 goto op_semantics_95;
12759 break;
12761 break;
12762 case 0x0e:
12763 GETBYTE ();
12764 switch (op[2] & 0x00)
12766 case 0x00:
12767 goto op_semantics_95;
12768 break;
12770 break;
12771 case 0x0f:
12772 GETBYTE ();
12773 switch (op[2] & 0x00)
12775 case 0x00:
12776 goto op_semantics_95;
12777 break;
12779 break;
12780 case 0x10:
12781 GETBYTE ();
12782 switch (op[2] & 0x00)
12784 case 0x00:
12785 goto op_semantics_95;
12786 break;
12788 break;
12789 case 0x11:
12790 GETBYTE ();
12791 switch (op[2] & 0x00)
12793 case 0x00:
12794 goto op_semantics_95;
12795 break;
12797 break;
12798 case 0x12:
12799 GETBYTE ();
12800 switch (op[2] & 0x00)
12802 case 0x00:
12803 goto op_semantics_95;
12804 break;
12806 break;
12807 case 0x13:
12808 GETBYTE ();
12809 switch (op[2] & 0x00)
12811 case 0x00:
12812 goto op_semantics_95;
12813 break;
12815 break;
12816 case 0x14:
12817 GETBYTE ();
12818 switch (op[2] & 0x00)
12820 case 0x00:
12821 goto op_semantics_95;
12822 break;
12824 break;
12825 case 0x15:
12826 GETBYTE ();
12827 switch (op[2] & 0x00)
12829 case 0x00:
12830 goto op_semantics_95;
12831 break;
12833 break;
12834 case 0x16:
12835 GETBYTE ();
12836 switch (op[2] & 0x00)
12838 case 0x00:
12839 goto op_semantics_95;
12840 break;
12842 break;
12843 case 0x17:
12844 GETBYTE ();
12845 switch (op[2] & 0x00)
12847 case 0x00:
12848 goto op_semantics_95;
12849 break;
12851 break;
12852 case 0x18:
12853 GETBYTE ();
12854 switch (op[2] & 0x00)
12856 case 0x00:
12857 goto op_semantics_95;
12858 break;
12860 break;
12861 case 0x19:
12862 GETBYTE ();
12863 switch (op[2] & 0x00)
12865 case 0x00:
12866 goto op_semantics_95;
12867 break;
12869 break;
12870 case 0x1a:
12871 GETBYTE ();
12872 switch (op[2] & 0x00)
12874 case 0x00:
12875 goto op_semantics_95;
12876 break;
12878 break;
12879 case 0x1b:
12880 GETBYTE ();
12881 switch (op[2] & 0x00)
12883 case 0x00:
12884 goto op_semantics_95;
12885 break;
12887 break;
12888 case 0x1c:
12889 GETBYTE ();
12890 switch (op[2] & 0x00)
12892 case 0x00:
12893 goto op_semantics_95;
12894 break;
12896 break;
12897 case 0x1d:
12898 GETBYTE ();
12899 switch (op[2] & 0x00)
12901 case 0x00:
12902 goto op_semantics_95;
12903 break;
12905 break;
12906 case 0x1e:
12907 GETBYTE ();
12908 switch (op[2] & 0x00)
12910 case 0x00:
12911 goto op_semantics_95;
12912 break;
12914 break;
12915 case 0x1f:
12916 GETBYTE ();
12917 switch (op[2] & 0x00)
12919 case 0x00:
12920 goto op_semantics_95;
12921 break;
12923 break;
12924 case 0x20:
12925 GETBYTE ();
12926 switch (op[2] & 0x00)
12928 case 0x00:
12929 goto op_semantics_95;
12930 break;
12932 break;
12933 case 0x21:
12934 GETBYTE ();
12935 switch (op[2] & 0x00)
12937 case 0x00:
12938 goto op_semantics_95;
12939 break;
12941 break;
12942 case 0x22:
12943 GETBYTE ();
12944 switch (op[2] & 0x00)
12946 case 0x00:
12947 goto op_semantics_95;
12948 break;
12950 break;
12951 case 0x23:
12952 GETBYTE ();
12953 switch (op[2] & 0x00)
12955 case 0x00:
12956 goto op_semantics_95;
12957 break;
12959 break;
12960 case 0x24:
12961 GETBYTE ();
12962 switch (op[2] & 0x00)
12964 case 0x00:
12965 goto op_semantics_95;
12966 break;
12968 break;
12969 case 0x25:
12970 GETBYTE ();
12971 switch (op[2] & 0x00)
12973 case 0x00:
12974 goto op_semantics_95;
12975 break;
12977 break;
12978 case 0x26:
12979 GETBYTE ();
12980 switch (op[2] & 0x00)
12982 case 0x00:
12983 goto op_semantics_95;
12984 break;
12986 break;
12987 case 0x27:
12988 GETBYTE ();
12989 switch (op[2] & 0x00)
12991 case 0x00:
12992 goto op_semantics_95;
12993 break;
12995 break;
12996 case 0x28:
12997 GETBYTE ();
12998 switch (op[2] & 0x00)
13000 case 0x00:
13001 goto op_semantics_95;
13002 break;
13004 break;
13005 case 0x29:
13006 GETBYTE ();
13007 switch (op[2] & 0x00)
13009 case 0x00:
13010 goto op_semantics_95;
13011 break;
13013 break;
13014 case 0x2a:
13015 GETBYTE ();
13016 switch (op[2] & 0x00)
13018 case 0x00:
13019 goto op_semantics_95;
13020 break;
13022 break;
13023 case 0x2b:
13024 GETBYTE ();
13025 switch (op[2] & 0x00)
13027 case 0x00:
13028 goto op_semantics_95;
13029 break;
13031 break;
13032 case 0x2c:
13033 GETBYTE ();
13034 switch (op[2] & 0x00)
13036 case 0x00:
13037 goto op_semantics_95;
13038 break;
13040 break;
13041 case 0x2d:
13042 GETBYTE ();
13043 switch (op[2] & 0x00)
13045 case 0x00:
13046 goto op_semantics_95;
13047 break;
13049 break;
13050 case 0x2e:
13051 GETBYTE ();
13052 switch (op[2] & 0x00)
13054 case 0x00:
13055 goto op_semantics_95;
13056 break;
13058 break;
13059 case 0x2f:
13060 GETBYTE ();
13061 switch (op[2] & 0x00)
13063 case 0x00:
13064 goto op_semantics_95;
13065 break;
13067 break;
13068 case 0x40:
13069 GETBYTE ();
13070 switch (op[2] & 0x00)
13072 case 0x00:
13073 op_semantics_96:
13075 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
13076 #line 315 "rx-decode.opc"
13077 int sz AU = (op[1] >> 4) & 0x03;
13078 #line 315 "rx-decode.opc"
13079 int isrc AU = op[1] & 0x0f;
13080 #line 315 "rx-decode.opc"
13081 int bsrc AU = (op[2] >> 4) & 0x0f;
13082 #line 315 "rx-decode.opc"
13083 int rdst AU = op[2] & 0x0f;
13084 if (trace)
13086 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13087 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13088 op[0], op[1], op[2]);
13089 printf (" sz = 0x%x,", sz);
13090 printf (" isrc = 0x%x,", isrc);
13091 printf (" bsrc = 0x%x,", bsrc);
13092 printf (" rdst = 0x%x\n", rdst);
13094 SYNTAX("mov%s [%1, %2], %0");
13095 #line 315 "rx-decode.opc"
13096 ID(movbi); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13099 break;
13101 break;
13102 case 0x41:
13103 GETBYTE ();
13104 switch (op[2] & 0x00)
13106 case 0x00:
13107 goto op_semantics_96;
13108 break;
13110 break;
13111 case 0x42:
13112 GETBYTE ();
13113 switch (op[2] & 0x00)
13115 case 0x00:
13116 goto op_semantics_96;
13117 break;
13119 break;
13120 case 0x43:
13121 GETBYTE ();
13122 switch (op[2] & 0x00)
13124 case 0x00:
13125 goto op_semantics_96;
13126 break;
13128 break;
13129 case 0x44:
13130 GETBYTE ();
13131 switch (op[2] & 0x00)
13133 case 0x00:
13134 goto op_semantics_96;
13135 break;
13137 break;
13138 case 0x45:
13139 GETBYTE ();
13140 switch (op[2] & 0x00)
13142 case 0x00:
13143 goto op_semantics_96;
13144 break;
13146 break;
13147 case 0x46:
13148 GETBYTE ();
13149 switch (op[2] & 0x00)
13151 case 0x00:
13152 goto op_semantics_96;
13153 break;
13155 break;
13156 case 0x47:
13157 GETBYTE ();
13158 switch (op[2] & 0x00)
13160 case 0x00:
13161 goto op_semantics_96;
13162 break;
13164 break;
13165 case 0x48:
13166 GETBYTE ();
13167 switch (op[2] & 0x00)
13169 case 0x00:
13170 goto op_semantics_96;
13171 break;
13173 break;
13174 case 0x49:
13175 GETBYTE ();
13176 switch (op[2] & 0x00)
13178 case 0x00:
13179 goto op_semantics_96;
13180 break;
13182 break;
13183 case 0x4a:
13184 GETBYTE ();
13185 switch (op[2] & 0x00)
13187 case 0x00:
13188 goto op_semantics_96;
13189 break;
13191 break;
13192 case 0x4b:
13193 GETBYTE ();
13194 switch (op[2] & 0x00)
13196 case 0x00:
13197 goto op_semantics_96;
13198 break;
13200 break;
13201 case 0x4c:
13202 GETBYTE ();
13203 switch (op[2] & 0x00)
13205 case 0x00:
13206 goto op_semantics_96;
13207 break;
13209 break;
13210 case 0x4d:
13211 GETBYTE ();
13212 switch (op[2] & 0x00)
13214 case 0x00:
13215 goto op_semantics_96;
13216 break;
13218 break;
13219 case 0x4e:
13220 GETBYTE ();
13221 switch (op[2] & 0x00)
13223 case 0x00:
13224 goto op_semantics_96;
13225 break;
13227 break;
13228 case 0x4f:
13229 GETBYTE ();
13230 switch (op[2] & 0x00)
13232 case 0x00:
13233 goto op_semantics_96;
13234 break;
13236 break;
13237 case 0x50:
13238 GETBYTE ();
13239 switch (op[2] & 0x00)
13241 case 0x00:
13242 goto op_semantics_96;
13243 break;
13245 break;
13246 case 0x51:
13247 GETBYTE ();
13248 switch (op[2] & 0x00)
13250 case 0x00:
13251 goto op_semantics_96;
13252 break;
13254 break;
13255 case 0x52:
13256 GETBYTE ();
13257 switch (op[2] & 0x00)
13259 case 0x00:
13260 goto op_semantics_96;
13261 break;
13263 break;
13264 case 0x53:
13265 GETBYTE ();
13266 switch (op[2] & 0x00)
13268 case 0x00:
13269 goto op_semantics_96;
13270 break;
13272 break;
13273 case 0x54:
13274 GETBYTE ();
13275 switch (op[2] & 0x00)
13277 case 0x00:
13278 goto op_semantics_96;
13279 break;
13281 break;
13282 case 0x55:
13283 GETBYTE ();
13284 switch (op[2] & 0x00)
13286 case 0x00:
13287 goto op_semantics_96;
13288 break;
13290 break;
13291 case 0x56:
13292 GETBYTE ();
13293 switch (op[2] & 0x00)
13295 case 0x00:
13296 goto op_semantics_96;
13297 break;
13299 break;
13300 case 0x57:
13301 GETBYTE ();
13302 switch (op[2] & 0x00)
13304 case 0x00:
13305 goto op_semantics_96;
13306 break;
13308 break;
13309 case 0x58:
13310 GETBYTE ();
13311 switch (op[2] & 0x00)
13313 case 0x00:
13314 goto op_semantics_96;
13315 break;
13317 break;
13318 case 0x59:
13319 GETBYTE ();
13320 switch (op[2] & 0x00)
13322 case 0x00:
13323 goto op_semantics_96;
13324 break;
13326 break;
13327 case 0x5a:
13328 GETBYTE ();
13329 switch (op[2] & 0x00)
13331 case 0x00:
13332 goto op_semantics_96;
13333 break;
13335 break;
13336 case 0x5b:
13337 GETBYTE ();
13338 switch (op[2] & 0x00)
13340 case 0x00:
13341 goto op_semantics_96;
13342 break;
13344 break;
13345 case 0x5c:
13346 GETBYTE ();
13347 switch (op[2] & 0x00)
13349 case 0x00:
13350 goto op_semantics_96;
13351 break;
13353 break;
13354 case 0x5d:
13355 GETBYTE ();
13356 switch (op[2] & 0x00)
13358 case 0x00:
13359 goto op_semantics_96;
13360 break;
13362 break;
13363 case 0x5e:
13364 GETBYTE ();
13365 switch (op[2] & 0x00)
13367 case 0x00:
13368 goto op_semantics_96;
13369 break;
13371 break;
13372 case 0x5f:
13373 GETBYTE ();
13374 switch (op[2] & 0x00)
13376 case 0x00:
13377 goto op_semantics_96;
13378 break;
13380 break;
13381 case 0x60:
13382 GETBYTE ();
13383 switch (op[2] & 0x00)
13385 case 0x00:
13386 goto op_semantics_96;
13387 break;
13389 break;
13390 case 0x61:
13391 GETBYTE ();
13392 switch (op[2] & 0x00)
13394 case 0x00:
13395 goto op_semantics_96;
13396 break;
13398 break;
13399 case 0x62:
13400 GETBYTE ();
13401 switch (op[2] & 0x00)
13403 case 0x00:
13404 goto op_semantics_96;
13405 break;
13407 break;
13408 case 0x63:
13409 GETBYTE ();
13410 switch (op[2] & 0x00)
13412 case 0x00:
13413 goto op_semantics_96;
13414 break;
13416 break;
13417 case 0x64:
13418 GETBYTE ();
13419 switch (op[2] & 0x00)
13421 case 0x00:
13422 goto op_semantics_96;
13423 break;
13425 break;
13426 case 0x65:
13427 GETBYTE ();
13428 switch (op[2] & 0x00)
13430 case 0x00:
13431 goto op_semantics_96;
13432 break;
13434 break;
13435 case 0x66:
13436 GETBYTE ();
13437 switch (op[2] & 0x00)
13439 case 0x00:
13440 goto op_semantics_96;
13441 break;
13443 break;
13444 case 0x67:
13445 GETBYTE ();
13446 switch (op[2] & 0x00)
13448 case 0x00:
13449 goto op_semantics_96;
13450 break;
13452 break;
13453 case 0x68:
13454 GETBYTE ();
13455 switch (op[2] & 0x00)
13457 case 0x00:
13458 goto op_semantics_96;
13459 break;
13461 break;
13462 case 0x69:
13463 GETBYTE ();
13464 switch (op[2] & 0x00)
13466 case 0x00:
13467 goto op_semantics_96;
13468 break;
13470 break;
13471 case 0x6a:
13472 GETBYTE ();
13473 switch (op[2] & 0x00)
13475 case 0x00:
13476 goto op_semantics_96;
13477 break;
13479 break;
13480 case 0x6b:
13481 GETBYTE ();
13482 switch (op[2] & 0x00)
13484 case 0x00:
13485 goto op_semantics_96;
13486 break;
13488 break;
13489 case 0x6c:
13490 GETBYTE ();
13491 switch (op[2] & 0x00)
13493 case 0x00:
13494 goto op_semantics_96;
13495 break;
13497 break;
13498 case 0x6d:
13499 GETBYTE ();
13500 switch (op[2] & 0x00)
13502 case 0x00:
13503 goto op_semantics_96;
13504 break;
13506 break;
13507 case 0x6e:
13508 GETBYTE ();
13509 switch (op[2] & 0x00)
13511 case 0x00:
13512 goto op_semantics_96;
13513 break;
13515 break;
13516 case 0x6f:
13517 GETBYTE ();
13518 switch (op[2] & 0x00)
13520 case 0x00:
13521 goto op_semantics_96;
13522 break;
13524 break;
13525 case 0xc0:
13526 GETBYTE ();
13527 switch (op[2] & 0x00)
13529 case 0x00:
13530 op_semantics_97:
13532 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
13533 #line 321 "rx-decode.opc"
13534 int sz AU = (op[1] >> 4) & 0x03;
13535 #line 321 "rx-decode.opc"
13536 int isrc AU = op[1] & 0x0f;
13537 #line 321 "rx-decode.opc"
13538 int bsrc AU = (op[2] >> 4) & 0x0f;
13539 #line 321 "rx-decode.opc"
13540 int rdst AU = op[2] & 0x0f;
13541 if (trace)
13543 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13544 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13545 op[0], op[1], op[2]);
13546 printf (" sz = 0x%x,", sz);
13547 printf (" isrc = 0x%x,", isrc);
13548 printf (" bsrc = 0x%x,", bsrc);
13549 printf (" rdst = 0x%x\n", rdst);
13551 SYNTAX("movu%s [%1, %2], %0");
13552 #line 321 "rx-decode.opc"
13553 ID(movbi); uBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13556 break;
13558 break;
13559 case 0xc1:
13560 GETBYTE ();
13561 switch (op[2] & 0x00)
13563 case 0x00:
13564 goto op_semantics_97;
13565 break;
13567 break;
13568 case 0xc2:
13569 GETBYTE ();
13570 switch (op[2] & 0x00)
13572 case 0x00:
13573 goto op_semantics_97;
13574 break;
13576 break;
13577 case 0xc3:
13578 GETBYTE ();
13579 switch (op[2] & 0x00)
13581 case 0x00:
13582 goto op_semantics_97;
13583 break;
13585 break;
13586 case 0xc4:
13587 GETBYTE ();
13588 switch (op[2] & 0x00)
13590 case 0x00:
13591 goto op_semantics_97;
13592 break;
13594 break;
13595 case 0xc5:
13596 GETBYTE ();
13597 switch (op[2] & 0x00)
13599 case 0x00:
13600 goto op_semantics_97;
13601 break;
13603 break;
13604 case 0xc6:
13605 GETBYTE ();
13606 switch (op[2] & 0x00)
13608 case 0x00:
13609 goto op_semantics_97;
13610 break;
13612 break;
13613 case 0xc7:
13614 GETBYTE ();
13615 switch (op[2] & 0x00)
13617 case 0x00:
13618 goto op_semantics_97;
13619 break;
13621 break;
13622 case 0xc8:
13623 GETBYTE ();
13624 switch (op[2] & 0x00)
13626 case 0x00:
13627 goto op_semantics_97;
13628 break;
13630 break;
13631 case 0xc9:
13632 GETBYTE ();
13633 switch (op[2] & 0x00)
13635 case 0x00:
13636 goto op_semantics_97;
13637 break;
13639 break;
13640 case 0xca:
13641 GETBYTE ();
13642 switch (op[2] & 0x00)
13644 case 0x00:
13645 goto op_semantics_97;
13646 break;
13648 break;
13649 case 0xcb:
13650 GETBYTE ();
13651 switch (op[2] & 0x00)
13653 case 0x00:
13654 goto op_semantics_97;
13655 break;
13657 break;
13658 case 0xcc:
13659 GETBYTE ();
13660 switch (op[2] & 0x00)
13662 case 0x00:
13663 goto op_semantics_97;
13664 break;
13666 break;
13667 case 0xcd:
13668 GETBYTE ();
13669 switch (op[2] & 0x00)
13671 case 0x00:
13672 goto op_semantics_97;
13673 break;
13675 break;
13676 case 0xce:
13677 GETBYTE ();
13678 switch (op[2] & 0x00)
13680 case 0x00:
13681 goto op_semantics_97;
13682 break;
13684 break;
13685 case 0xcf:
13686 GETBYTE ();
13687 switch (op[2] & 0x00)
13689 case 0x00:
13690 goto op_semantics_97;
13691 break;
13693 break;
13694 case 0xd0:
13695 GETBYTE ();
13696 switch (op[2] & 0x00)
13698 case 0x00:
13699 goto op_semantics_97;
13700 break;
13702 break;
13703 case 0xd1:
13704 GETBYTE ();
13705 switch (op[2] & 0x00)
13707 case 0x00:
13708 goto op_semantics_97;
13709 break;
13711 break;
13712 case 0xd2:
13713 GETBYTE ();
13714 switch (op[2] & 0x00)
13716 case 0x00:
13717 goto op_semantics_97;
13718 break;
13720 break;
13721 case 0xd3:
13722 GETBYTE ();
13723 switch (op[2] & 0x00)
13725 case 0x00:
13726 goto op_semantics_97;
13727 break;
13729 break;
13730 case 0xd4:
13731 GETBYTE ();
13732 switch (op[2] & 0x00)
13734 case 0x00:
13735 goto op_semantics_97;
13736 break;
13738 break;
13739 case 0xd5:
13740 GETBYTE ();
13741 switch (op[2] & 0x00)
13743 case 0x00:
13744 goto op_semantics_97;
13745 break;
13747 break;
13748 case 0xd6:
13749 GETBYTE ();
13750 switch (op[2] & 0x00)
13752 case 0x00:
13753 goto op_semantics_97;
13754 break;
13756 break;
13757 case 0xd7:
13758 GETBYTE ();
13759 switch (op[2] & 0x00)
13761 case 0x00:
13762 goto op_semantics_97;
13763 break;
13765 break;
13766 case 0xd8:
13767 GETBYTE ();
13768 switch (op[2] & 0x00)
13770 case 0x00:
13771 goto op_semantics_97;
13772 break;
13774 break;
13775 case 0xd9:
13776 GETBYTE ();
13777 switch (op[2] & 0x00)
13779 case 0x00:
13780 goto op_semantics_97;
13781 break;
13783 break;
13784 case 0xda:
13785 GETBYTE ();
13786 switch (op[2] & 0x00)
13788 case 0x00:
13789 goto op_semantics_97;
13790 break;
13792 break;
13793 case 0xdb:
13794 GETBYTE ();
13795 switch (op[2] & 0x00)
13797 case 0x00:
13798 goto op_semantics_97;
13799 break;
13801 break;
13802 case 0xdc:
13803 GETBYTE ();
13804 switch (op[2] & 0x00)
13806 case 0x00:
13807 goto op_semantics_97;
13808 break;
13810 break;
13811 case 0xdd:
13812 GETBYTE ();
13813 switch (op[2] & 0x00)
13815 case 0x00:
13816 goto op_semantics_97;
13817 break;
13819 break;
13820 case 0xde:
13821 GETBYTE ();
13822 switch (op[2] & 0x00)
13824 case 0x00:
13825 goto op_semantics_97;
13826 break;
13828 break;
13829 case 0xdf:
13830 GETBYTE ();
13831 switch (op[2] & 0x00)
13833 case 0x00:
13834 goto op_semantics_97;
13835 break;
13837 break;
13838 case 0xe0:
13839 GETBYTE ();
13840 switch (op[2] & 0x00)
13842 case 0x00:
13843 goto op_semantics_97;
13844 break;
13846 break;
13847 case 0xe1:
13848 GETBYTE ();
13849 switch (op[2] & 0x00)
13851 case 0x00:
13852 goto op_semantics_97;
13853 break;
13855 break;
13856 case 0xe2:
13857 GETBYTE ();
13858 switch (op[2] & 0x00)
13860 case 0x00:
13861 goto op_semantics_97;
13862 break;
13864 break;
13865 case 0xe3:
13866 GETBYTE ();
13867 switch (op[2] & 0x00)
13869 case 0x00:
13870 goto op_semantics_97;
13871 break;
13873 break;
13874 case 0xe4:
13875 GETBYTE ();
13876 switch (op[2] & 0x00)
13878 case 0x00:
13879 goto op_semantics_97;
13880 break;
13882 break;
13883 case 0xe5:
13884 GETBYTE ();
13885 switch (op[2] & 0x00)
13887 case 0x00:
13888 goto op_semantics_97;
13889 break;
13891 break;
13892 case 0xe6:
13893 GETBYTE ();
13894 switch (op[2] & 0x00)
13896 case 0x00:
13897 goto op_semantics_97;
13898 break;
13900 break;
13901 case 0xe7:
13902 GETBYTE ();
13903 switch (op[2] & 0x00)
13905 case 0x00:
13906 goto op_semantics_97;
13907 break;
13909 break;
13910 case 0xe8:
13911 GETBYTE ();
13912 switch (op[2] & 0x00)
13914 case 0x00:
13915 goto op_semantics_97;
13916 break;
13918 break;
13919 case 0xe9:
13920 GETBYTE ();
13921 switch (op[2] & 0x00)
13923 case 0x00:
13924 goto op_semantics_97;
13925 break;
13927 break;
13928 case 0xea:
13929 GETBYTE ();
13930 switch (op[2] & 0x00)
13932 case 0x00:
13933 goto op_semantics_97;
13934 break;
13936 break;
13937 case 0xeb:
13938 GETBYTE ();
13939 switch (op[2] & 0x00)
13941 case 0x00:
13942 goto op_semantics_97;
13943 break;
13945 break;
13946 case 0xec:
13947 GETBYTE ();
13948 switch (op[2] & 0x00)
13950 case 0x00:
13951 goto op_semantics_97;
13952 break;
13954 break;
13955 case 0xed:
13956 GETBYTE ();
13957 switch (op[2] & 0x00)
13959 case 0x00:
13960 goto op_semantics_97;
13961 break;
13963 break;
13964 case 0xee:
13965 GETBYTE ();
13966 switch (op[2] & 0x00)
13968 case 0x00:
13969 goto op_semantics_97;
13970 break;
13972 break;
13973 case 0xef:
13974 GETBYTE ();
13975 switch (op[2] & 0x00)
13977 case 0x00:
13978 goto op_semantics_97;
13979 break;
13981 break;
13982 default: UNSUPPORTED(); break;
13984 break;
13985 case 0xff:
13986 GETBYTE ();
13987 switch (op[1] & 0xff)
13989 case 0x00:
13990 GETBYTE ();
13991 switch (op[2] & 0x00)
13993 case 0x00:
13994 op_semantics_98:
13996 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
13997 #line 525 "rx-decode.opc"
13998 int rdst AU = op[1] & 0x0f;
13999 #line 525 "rx-decode.opc"
14000 int srca AU = (op[2] >> 4) & 0x0f;
14001 #line 525 "rx-decode.opc"
14002 int srcb AU = op[2] & 0x0f;
14003 if (trace)
14005 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14006 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
14007 op[0], op[1], op[2]);
14008 printf (" rdst = 0x%x,", rdst);
14009 printf (" srca = 0x%x,", srca);
14010 printf (" srcb = 0x%x\n", srcb);
14012 SYNTAX("sub %2, %1, %0");
14013 #line 525 "rx-decode.opc"
14014 ID(sub); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14016 /*----------------------------------------------------------------------*/
14017 /* SBB */
14020 break;
14022 break;
14023 case 0x01:
14024 GETBYTE ();
14025 switch (op[2] & 0x00)
14027 case 0x00:
14028 goto op_semantics_98;
14029 break;
14031 break;
14032 case 0x02:
14033 GETBYTE ();
14034 switch (op[2] & 0x00)
14036 case 0x00:
14037 goto op_semantics_98;
14038 break;
14040 break;
14041 case 0x03:
14042 GETBYTE ();
14043 switch (op[2] & 0x00)
14045 case 0x00:
14046 goto op_semantics_98;
14047 break;
14049 break;
14050 case 0x04:
14051 GETBYTE ();
14052 switch (op[2] & 0x00)
14054 case 0x00:
14055 goto op_semantics_98;
14056 break;
14058 break;
14059 case 0x05:
14060 GETBYTE ();
14061 switch (op[2] & 0x00)
14063 case 0x00:
14064 goto op_semantics_98;
14065 break;
14067 break;
14068 case 0x06:
14069 GETBYTE ();
14070 switch (op[2] & 0x00)
14072 case 0x00:
14073 goto op_semantics_98;
14074 break;
14076 break;
14077 case 0x07:
14078 GETBYTE ();
14079 switch (op[2] & 0x00)
14081 case 0x00:
14082 goto op_semantics_98;
14083 break;
14085 break;
14086 case 0x08:
14087 GETBYTE ();
14088 switch (op[2] & 0x00)
14090 case 0x00:
14091 goto op_semantics_98;
14092 break;
14094 break;
14095 case 0x09:
14096 GETBYTE ();
14097 switch (op[2] & 0x00)
14099 case 0x00:
14100 goto op_semantics_98;
14101 break;
14103 break;
14104 case 0x0a:
14105 GETBYTE ();
14106 switch (op[2] & 0x00)
14108 case 0x00:
14109 goto op_semantics_98;
14110 break;
14112 break;
14113 case 0x0b:
14114 GETBYTE ();
14115 switch (op[2] & 0x00)
14117 case 0x00:
14118 goto op_semantics_98;
14119 break;
14121 break;
14122 case 0x0c:
14123 GETBYTE ();
14124 switch (op[2] & 0x00)
14126 case 0x00:
14127 goto op_semantics_98;
14128 break;
14130 break;
14131 case 0x0d:
14132 GETBYTE ();
14133 switch (op[2] & 0x00)
14135 case 0x00:
14136 goto op_semantics_98;
14137 break;
14139 break;
14140 case 0x0e:
14141 GETBYTE ();
14142 switch (op[2] & 0x00)
14144 case 0x00:
14145 goto op_semantics_98;
14146 break;
14148 break;
14149 case 0x0f:
14150 GETBYTE ();
14151 switch (op[2] & 0x00)
14153 case 0x00:
14154 goto op_semantics_98;
14155 break;
14157 break;
14158 case 0x20:
14159 GETBYTE ();
14160 switch (op[2] & 0x00)
14162 case 0x00:
14163 op_semantics_99:
14165 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
14166 #line 492 "rx-decode.opc"
14167 int rdst AU = op[1] & 0x0f;
14168 #line 492 "rx-decode.opc"
14169 int srca AU = (op[2] >> 4) & 0x0f;
14170 #line 492 "rx-decode.opc"
14171 int srcb AU = op[2] & 0x0f;
14172 if (trace)
14174 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14175 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14176 op[0], op[1], op[2]);
14177 printf (" rdst = 0x%x,", rdst);
14178 printf (" srca = 0x%x,", srca);
14179 printf (" srcb = 0x%x\n", srcb);
14181 SYNTAX("add %2, %1, %0");
14182 #line 492 "rx-decode.opc"
14183 ID(add); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14185 /*----------------------------------------------------------------------*/
14186 /* CMP */
14189 break;
14191 break;
14192 case 0x21:
14193 GETBYTE ();
14194 switch (op[2] & 0x00)
14196 case 0x00:
14197 goto op_semantics_99;
14198 break;
14200 break;
14201 case 0x22:
14202 GETBYTE ();
14203 switch (op[2] & 0x00)
14205 case 0x00:
14206 goto op_semantics_99;
14207 break;
14209 break;
14210 case 0x23:
14211 GETBYTE ();
14212 switch (op[2] & 0x00)
14214 case 0x00:
14215 goto op_semantics_99;
14216 break;
14218 break;
14219 case 0x24:
14220 GETBYTE ();
14221 switch (op[2] & 0x00)
14223 case 0x00:
14224 goto op_semantics_99;
14225 break;
14227 break;
14228 case 0x25:
14229 GETBYTE ();
14230 switch (op[2] & 0x00)
14232 case 0x00:
14233 goto op_semantics_99;
14234 break;
14236 break;
14237 case 0x26:
14238 GETBYTE ();
14239 switch (op[2] & 0x00)
14241 case 0x00:
14242 goto op_semantics_99;
14243 break;
14245 break;
14246 case 0x27:
14247 GETBYTE ();
14248 switch (op[2] & 0x00)
14250 case 0x00:
14251 goto op_semantics_99;
14252 break;
14254 break;
14255 case 0x28:
14256 GETBYTE ();
14257 switch (op[2] & 0x00)
14259 case 0x00:
14260 goto op_semantics_99;
14261 break;
14263 break;
14264 case 0x29:
14265 GETBYTE ();
14266 switch (op[2] & 0x00)
14268 case 0x00:
14269 goto op_semantics_99;
14270 break;
14272 break;
14273 case 0x2a:
14274 GETBYTE ();
14275 switch (op[2] & 0x00)
14277 case 0x00:
14278 goto op_semantics_99;
14279 break;
14281 break;
14282 case 0x2b:
14283 GETBYTE ();
14284 switch (op[2] & 0x00)
14286 case 0x00:
14287 goto op_semantics_99;
14288 break;
14290 break;
14291 case 0x2c:
14292 GETBYTE ();
14293 switch (op[2] & 0x00)
14295 case 0x00:
14296 goto op_semantics_99;
14297 break;
14299 break;
14300 case 0x2d:
14301 GETBYTE ();
14302 switch (op[2] & 0x00)
14304 case 0x00:
14305 goto op_semantics_99;
14306 break;
14308 break;
14309 case 0x2e:
14310 GETBYTE ();
14311 switch (op[2] & 0x00)
14313 case 0x00:
14314 goto op_semantics_99;
14315 break;
14317 break;
14318 case 0x2f:
14319 GETBYTE ();
14320 switch (op[2] & 0x00)
14322 case 0x00:
14323 goto op_semantics_99;
14324 break;
14326 break;
14327 case 0x30:
14328 GETBYTE ();
14329 switch (op[2] & 0x00)
14331 case 0x00:
14332 op_semantics_100:
14334 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
14335 #line 586 "rx-decode.opc"
14336 int rdst AU = op[1] & 0x0f;
14337 #line 586 "rx-decode.opc"
14338 int srca AU = (op[2] >> 4) & 0x0f;
14339 #line 586 "rx-decode.opc"
14340 int srcb AU = op[2] & 0x0f;
14341 if (trace)
14343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14344 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14345 op[0], op[1], op[2]);
14346 printf (" rdst = 0x%x,", rdst);
14347 printf (" srca = 0x%x,", srca);
14348 printf (" srcb = 0x%x\n", srcb);
14350 SYNTAX("mul %2, %1, %0");
14351 #line 586 "rx-decode.opc"
14352 ID(mul); DR(rdst); SR(srcb); S2R(srca); F("----");
14354 /*----------------------------------------------------------------------*/
14355 /* EMUL */
14358 break;
14360 break;
14361 case 0x31:
14362 GETBYTE ();
14363 switch (op[2] & 0x00)
14365 case 0x00:
14366 goto op_semantics_100;
14367 break;
14369 break;
14370 case 0x32:
14371 GETBYTE ();
14372 switch (op[2] & 0x00)
14374 case 0x00:
14375 goto op_semantics_100;
14376 break;
14378 break;
14379 case 0x33:
14380 GETBYTE ();
14381 switch (op[2] & 0x00)
14383 case 0x00:
14384 goto op_semantics_100;
14385 break;
14387 break;
14388 case 0x34:
14389 GETBYTE ();
14390 switch (op[2] & 0x00)
14392 case 0x00:
14393 goto op_semantics_100;
14394 break;
14396 break;
14397 case 0x35:
14398 GETBYTE ();
14399 switch (op[2] & 0x00)
14401 case 0x00:
14402 goto op_semantics_100;
14403 break;
14405 break;
14406 case 0x36:
14407 GETBYTE ();
14408 switch (op[2] & 0x00)
14410 case 0x00:
14411 goto op_semantics_100;
14412 break;
14414 break;
14415 case 0x37:
14416 GETBYTE ();
14417 switch (op[2] & 0x00)
14419 case 0x00:
14420 goto op_semantics_100;
14421 break;
14423 break;
14424 case 0x38:
14425 GETBYTE ();
14426 switch (op[2] & 0x00)
14428 case 0x00:
14429 goto op_semantics_100;
14430 break;
14432 break;
14433 case 0x39:
14434 GETBYTE ();
14435 switch (op[2] & 0x00)
14437 case 0x00:
14438 goto op_semantics_100;
14439 break;
14441 break;
14442 case 0x3a:
14443 GETBYTE ();
14444 switch (op[2] & 0x00)
14446 case 0x00:
14447 goto op_semantics_100;
14448 break;
14450 break;
14451 case 0x3b:
14452 GETBYTE ();
14453 switch (op[2] & 0x00)
14455 case 0x00:
14456 goto op_semantics_100;
14457 break;
14459 break;
14460 case 0x3c:
14461 GETBYTE ();
14462 switch (op[2] & 0x00)
14464 case 0x00:
14465 goto op_semantics_100;
14466 break;
14468 break;
14469 case 0x3d:
14470 GETBYTE ();
14471 switch (op[2] & 0x00)
14473 case 0x00:
14474 goto op_semantics_100;
14475 break;
14477 break;
14478 case 0x3e:
14479 GETBYTE ();
14480 switch (op[2] & 0x00)
14482 case 0x00:
14483 goto op_semantics_100;
14484 break;
14486 break;
14487 case 0x3f:
14488 GETBYTE ();
14489 switch (op[2] & 0x00)
14491 case 0x00:
14492 goto op_semantics_100;
14493 break;
14495 break;
14496 case 0x40:
14497 GETBYTE ();
14498 switch (op[2] & 0x00)
14500 case 0x00:
14501 op_semantics_101:
14503 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
14504 #line 402 "rx-decode.opc"
14505 int rdst AU = op[1] & 0x0f;
14506 #line 402 "rx-decode.opc"
14507 int srca AU = (op[2] >> 4) & 0x0f;
14508 #line 402 "rx-decode.opc"
14509 int srcb AU = op[2] & 0x0f;
14510 if (trace)
14512 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14513 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14514 op[0], op[1], op[2]);
14515 printf (" rdst = 0x%x,", rdst);
14516 printf (" srca = 0x%x,", srca);
14517 printf (" srcb = 0x%x\n", srcb);
14519 SYNTAX("and %2, %1, %0");
14520 #line 402 "rx-decode.opc"
14521 ID(and); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14523 /*----------------------------------------------------------------------*/
14524 /* OR */
14527 break;
14529 break;
14530 case 0x41:
14531 GETBYTE ();
14532 switch (op[2] & 0x00)
14534 case 0x00:
14535 goto op_semantics_101;
14536 break;
14538 break;
14539 case 0x42:
14540 GETBYTE ();
14541 switch (op[2] & 0x00)
14543 case 0x00:
14544 goto op_semantics_101;
14545 break;
14547 break;
14548 case 0x43:
14549 GETBYTE ();
14550 switch (op[2] & 0x00)
14552 case 0x00:
14553 goto op_semantics_101;
14554 break;
14556 break;
14557 case 0x44:
14558 GETBYTE ();
14559 switch (op[2] & 0x00)
14561 case 0x00:
14562 goto op_semantics_101;
14563 break;
14565 break;
14566 case 0x45:
14567 GETBYTE ();
14568 switch (op[2] & 0x00)
14570 case 0x00:
14571 goto op_semantics_101;
14572 break;
14574 break;
14575 case 0x46:
14576 GETBYTE ();
14577 switch (op[2] & 0x00)
14579 case 0x00:
14580 goto op_semantics_101;
14581 break;
14583 break;
14584 case 0x47:
14585 GETBYTE ();
14586 switch (op[2] & 0x00)
14588 case 0x00:
14589 goto op_semantics_101;
14590 break;
14592 break;
14593 case 0x48:
14594 GETBYTE ();
14595 switch (op[2] & 0x00)
14597 case 0x00:
14598 goto op_semantics_101;
14599 break;
14601 break;
14602 case 0x49:
14603 GETBYTE ();
14604 switch (op[2] & 0x00)
14606 case 0x00:
14607 goto op_semantics_101;
14608 break;
14610 break;
14611 case 0x4a:
14612 GETBYTE ();
14613 switch (op[2] & 0x00)
14615 case 0x00:
14616 goto op_semantics_101;
14617 break;
14619 break;
14620 case 0x4b:
14621 GETBYTE ();
14622 switch (op[2] & 0x00)
14624 case 0x00:
14625 goto op_semantics_101;
14626 break;
14628 break;
14629 case 0x4c:
14630 GETBYTE ();
14631 switch (op[2] & 0x00)
14633 case 0x00:
14634 goto op_semantics_101;
14635 break;
14637 break;
14638 case 0x4d:
14639 GETBYTE ();
14640 switch (op[2] & 0x00)
14642 case 0x00:
14643 goto op_semantics_101;
14644 break;
14646 break;
14647 case 0x4e:
14648 GETBYTE ();
14649 switch (op[2] & 0x00)
14651 case 0x00:
14652 goto op_semantics_101;
14653 break;
14655 break;
14656 case 0x4f:
14657 GETBYTE ();
14658 switch (op[2] & 0x00)
14660 case 0x00:
14661 goto op_semantics_101;
14662 break;
14664 break;
14665 case 0x50:
14666 GETBYTE ();
14667 switch (op[2] & 0x00)
14669 case 0x00:
14670 op_semantics_102:
14672 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
14673 #line 420 "rx-decode.opc"
14674 int rdst AU = op[1] & 0x0f;
14675 #line 420 "rx-decode.opc"
14676 int srca AU = (op[2] >> 4) & 0x0f;
14677 #line 420 "rx-decode.opc"
14678 int srcb AU = op[2] & 0x0f;
14679 if (trace)
14681 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14682 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14683 op[0], op[1], op[2]);
14684 printf (" rdst = 0x%x,", rdst);
14685 printf (" srca = 0x%x,", srca);
14686 printf (" srcb = 0x%x\n", srcb);
14688 SYNTAX("or %2, %1, %0");
14689 #line 420 "rx-decode.opc"
14690 ID(or); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14692 /*----------------------------------------------------------------------*/
14693 /* XOR */
14696 break;
14698 break;
14699 case 0x51:
14700 GETBYTE ();
14701 switch (op[2] & 0x00)
14703 case 0x00:
14704 goto op_semantics_102;
14705 break;
14707 break;
14708 case 0x52:
14709 GETBYTE ();
14710 switch (op[2] & 0x00)
14712 case 0x00:
14713 goto op_semantics_102;
14714 break;
14716 break;
14717 case 0x53:
14718 GETBYTE ();
14719 switch (op[2] & 0x00)
14721 case 0x00:
14722 goto op_semantics_102;
14723 break;
14725 break;
14726 case 0x54:
14727 GETBYTE ();
14728 switch (op[2] & 0x00)
14730 case 0x00:
14731 goto op_semantics_102;
14732 break;
14734 break;
14735 case 0x55:
14736 GETBYTE ();
14737 switch (op[2] & 0x00)
14739 case 0x00:
14740 goto op_semantics_102;
14741 break;
14743 break;
14744 case 0x56:
14745 GETBYTE ();
14746 switch (op[2] & 0x00)
14748 case 0x00:
14749 goto op_semantics_102;
14750 break;
14752 break;
14753 case 0x57:
14754 GETBYTE ();
14755 switch (op[2] & 0x00)
14757 case 0x00:
14758 goto op_semantics_102;
14759 break;
14761 break;
14762 case 0x58:
14763 GETBYTE ();
14764 switch (op[2] & 0x00)
14766 case 0x00:
14767 goto op_semantics_102;
14768 break;
14770 break;
14771 case 0x59:
14772 GETBYTE ();
14773 switch (op[2] & 0x00)
14775 case 0x00:
14776 goto op_semantics_102;
14777 break;
14779 break;
14780 case 0x5a:
14781 GETBYTE ();
14782 switch (op[2] & 0x00)
14784 case 0x00:
14785 goto op_semantics_102;
14786 break;
14788 break;
14789 case 0x5b:
14790 GETBYTE ();
14791 switch (op[2] & 0x00)
14793 case 0x00:
14794 goto op_semantics_102;
14795 break;
14797 break;
14798 case 0x5c:
14799 GETBYTE ();
14800 switch (op[2] & 0x00)
14802 case 0x00:
14803 goto op_semantics_102;
14804 break;
14806 break;
14807 case 0x5d:
14808 GETBYTE ();
14809 switch (op[2] & 0x00)
14811 case 0x00:
14812 goto op_semantics_102;
14813 break;
14815 break;
14816 case 0x5e:
14817 GETBYTE ();
14818 switch (op[2] & 0x00)
14820 case 0x00:
14821 goto op_semantics_102;
14822 break;
14824 break;
14825 case 0x5f:
14826 GETBYTE ();
14827 switch (op[2] & 0x00)
14829 case 0x00:
14830 goto op_semantics_102;
14831 break;
14833 break;
14834 default: UNSUPPORTED(); break;
14836 break;
14837 default: UNSUPPORTED(); break;
14839 #line 969 "rx-decode.opc"
14841 return rx->n_bytes;