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