Re-add support for lbarx, lharx, stbcx. and sthcx. insns back to the E6500 cpu.
[binutils-gdb.git] / opcodes / rx-decode.c
blobe96c2f0b40d6f50c818e129a0009f88ec87ad07c
1 #line 1 "rx-decode.opc"
2 /* -*- c -*- */
3 /* Copyright (C) 2012-2016 Free Software Foundation, Inc.
4 Contributed by Red Hat.
5 Written by DJ Delorie.
7 This file is part of the GNU opcodes library.
9 This library is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
14 It is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
17 License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 #include "sysdep.h"
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include "ansidecl.h"
29 #include "opcode/rx.h"
31 #define RX_OPCODE_BIG_ENDIAN 0
33 typedef struct
35 RX_Opcode_Decoded * rx;
36 int (* getbyte)(void *);
37 void * ptr;
38 unsigned char * op;
39 } LocalData;
41 static int trace = 0;
43 #define BSIZE 0
44 #define WSIZE 1
45 #define LSIZE 2
47 /* These are for when the upper bits are "don't care" or "undefined". */
48 static int bwl[] =
50 RX_Byte,
51 RX_Word,
52 RX_Long,
53 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
56 static int sbwl[] =
58 RX_SByte,
59 RX_SWord,
60 RX_Long,
61 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
64 static int ubw[] =
66 RX_UByte,
67 RX_UWord,
68 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
69 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
72 static int memex[] =
74 RX_SByte,
75 RX_SWord,
76 RX_Long,
77 RX_UWord
80 #define ID(x) rx->id = RXO_##x
81 #define OP(n,t,r,a) (rx->op[n].type = t, \
82 rx->op[n].reg = r, \
83 rx->op[n].addend = a )
84 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
85 rx->op[n].size = s )
87 /* This is for the BWL and BW bitfields. */
88 static int SCALE[] = { 1, 2, 4, 0 };
89 /* This is for the prefix size enum. */
90 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
92 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
93 16, 17, 0, 0, 0, 0, 0, 0 };
95 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
98 *C a constant (immediate) c
99 *R A register
100 *I Register indirect, no offset
101 *Is Register indirect, with offset
102 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
103 *P standard displacement: type (r,[r]), reg, assumes UByte
104 *Pm memex displacement: type (r,[r]), reg, memex code
105 *cc condition code. */
107 #define DC(c) OP (0, RX_Operand_Immediate, 0, c)
108 #define DR(r) OP (0, RX_Operand_Register, r, 0)
109 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
110 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
111 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
112 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
114 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
115 #define SR(r) OP (1, RX_Operand_Register, r, 0)
116 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
117 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
118 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
119 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
120 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
121 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
122 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
124 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
125 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
126 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
127 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
128 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
129 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
130 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
131 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
133 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
134 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
135 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
136 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
138 #define F(f) store_flags(rx, f)
140 #define AU ATTRIBUTE_UNUSED
141 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
143 #define SYNTAX(x) rx->syntax = x
145 #define UNSUPPORTED() \
146 rx->syntax = "*unknown*"
148 #define IMM(sf) immediate (sf, 0, ld)
149 #define IMMex(sf) immediate (sf, 1, ld)
151 static int
152 immediate (int sfield, int ex, LocalData * ld)
154 unsigned long i = 0, j;
156 switch (sfield)
158 #define B ((unsigned long) GETBYTE())
159 case 0:
160 #if RX_OPCODE_BIG_ENDIAN
161 i = B;
162 if (ex && (i & 0x80))
163 i -= 0x100;
164 i <<= 24;
165 i |= B << 16;
166 i |= B << 8;
167 i |= B;
168 #else
169 i = B;
170 i |= B << 8;
171 i |= B << 16;
172 j = B;
173 if (ex && (j & 0x80))
174 j -= 0x100;
175 i |= j << 24;
176 #endif
177 break;
178 case 3:
179 #if RX_OPCODE_BIG_ENDIAN
180 i = B << 16;
181 i |= B << 8;
182 i |= B;
183 #else
184 i = B;
185 i |= B << 8;
186 i |= B << 16;
187 #endif
188 if (ex && (i & 0x800000))
189 i -= 0x1000000;
190 break;
191 case 2:
192 #if RX_OPCODE_BIG_ENDIAN
193 i |= B << 8;
194 i |= B;
195 #else
196 i |= B;
197 i |= B << 8;
198 #endif
199 if (ex && (i & 0x8000))
200 i -= 0x10000;
201 break;
202 case 1:
203 i |= B;
204 if (ex && (i & 0x80))
205 i -= 0x100;
206 break;
207 default:
208 abort();
210 return i;
213 static void
214 rx_disp (int n, int type, int reg, int size, LocalData * ld)
216 int disp;
218 ld->rx->op[n].reg = reg;
219 switch (type)
221 case 3:
222 ld->rx->op[n].type = RX_Operand_Register;
223 break;
224 case 0:
225 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
226 ld->rx->op[n].addend = 0;
227 break;
228 case 1:
229 ld->rx->op[n].type = RX_Operand_Indirect;
230 disp = GETBYTE ();
231 ld->rx->op[n].addend = disp * PSCALE[size];
232 break;
233 case 2:
234 ld->rx->op[n].type = RX_Operand_Indirect;
235 disp = GETBYTE ();
236 #if RX_OPCODE_BIG_ENDIAN
237 disp = disp * 256 + GETBYTE ();
238 #else
239 disp = disp + GETBYTE () * 256;
240 #endif
241 ld->rx->op[n].addend = disp * PSCALE[size];
242 break;
243 default:
244 abort ();
248 #define xO 8
249 #define xS 4
250 #define xZ 2
251 #define xC 1
253 #define F_____
254 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
255 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
256 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
257 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
258 #define F_O___ rx->flags_0 = rx->flags_s = xO;
259 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
260 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
261 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
264 rx_decode_opcode (unsigned long pc AU,
265 RX_Opcode_Decoded * rx,
266 int (* getbyte)(void *),
267 void * ptr)
269 LocalData lds, * ld = &lds;
270 unsigned char op[20] = {0};
272 lds.rx = rx;
273 lds.getbyte = getbyte;
274 lds.ptr = ptr;
275 lds.op = op;
277 memset (rx, 0, sizeof (*rx));
278 BWL(LSIZE);
281 /*----------------------------------------------------------------------*/
282 /* MOV */
284 GETBYTE ();
285 switch (op[0] & 0xff)
287 case 0x00:
289 /** 0000 0000 brk */
290 if (trace)
292 printf ("\033[33m%s\033[0m %02x\n",
293 "/** 0000 0000 brk */",
294 op[0]);
296 SYNTAX("brk");
297 #line 1025 "rx-decode.opc"
298 ID(brk);
301 break;
302 case 0x01:
304 /** 0000 0001 dbt */
305 if (trace)
307 printf ("\033[33m%s\033[0m %02x\n",
308 "/** 0000 0001 dbt */",
309 op[0]);
311 SYNTAX("dbt");
312 #line 1028 "rx-decode.opc"
313 ID(dbt);
316 break;
317 case 0x02:
319 /** 0000 0010 rts */
320 if (trace)
322 printf ("\033[33m%s\033[0m %02x\n",
323 "/** 0000 0010 rts */",
324 op[0]);
326 SYNTAX("rts");
327 #line 806 "rx-decode.opc"
328 ID(rts);
330 /*----------------------------------------------------------------------*/
331 /* NOP */
334 break;
335 case 0x03:
337 /** 0000 0011 nop */
338 if (trace)
340 printf ("\033[33m%s\033[0m %02x\n",
341 "/** 0000 0011 nop */",
342 op[0]);
344 SYNTAX("nop");
345 #line 812 "rx-decode.opc"
346 ID(nop);
348 /*----------------------------------------------------------------------*/
349 /* STRING FUNCTIONS */
352 break;
353 case 0x04:
355 /** 0000 0100 bra.a %a0 */
356 if (trace)
358 printf ("\033[33m%s\033[0m %02x\n",
359 "/** 0000 0100 bra.a %a0 */",
360 op[0]);
362 SYNTAX("bra.a %a0");
363 #line 784 "rx-decode.opc"
364 ID(branch); DC(pc + IMMex(3));
367 break;
368 case 0x05:
370 /** 0000 0101 bsr.a %a0 */
371 if (trace)
373 printf ("\033[33m%s\033[0m %02x\n",
374 "/** 0000 0101 bsr.a %a0 */",
375 op[0]);
377 SYNTAX("bsr.a %a0");
378 #line 800 "rx-decode.opc"
379 ID(jsr); DC(pc + IMMex(3));
382 break;
383 case 0x06:
384 GETBYTE ();
385 switch (op[1] & 0xff)
387 case 0x00:
388 GETBYTE ();
389 switch (op[2] & 0x00)
391 case 0x00:
392 op_semantics_1:
394 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
395 #line 542 "rx-decode.opc"
396 int mx AU = (op[1] >> 6) & 0x03;
397 #line 542 "rx-decode.opc"
398 int ss AU = op[1] & 0x03;
399 #line 542 "rx-decode.opc"
400 int rsrc AU = (op[2] >> 4) & 0x0f;
401 #line 542 "rx-decode.opc"
402 int rdst AU = op[2] & 0x0f;
403 if (trace)
405 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
406 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
407 op[0], op[1], op[2]);
408 printf (" mx = 0x%x,", mx);
409 printf (" ss = 0x%x,", ss);
410 printf (" rsrc = 0x%x,", rsrc);
411 printf (" rdst = 0x%x\n", rdst);
413 SYNTAX("sub %2%S2, %1");
414 #line 542 "rx-decode.opc"
415 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
418 break;
420 break;
421 case 0x01:
422 GETBYTE ();
423 switch (op[2] & 0x00)
425 case 0x00:
426 goto op_semantics_1;
427 break;
429 break;
430 case 0x02:
431 GETBYTE ();
432 switch (op[2] & 0x00)
434 case 0x00:
435 goto op_semantics_1;
436 break;
438 break;
439 case 0x03:
440 GETBYTE ();
441 switch (op[2] & 0x00)
443 case 0x00:
444 goto op_semantics_1;
445 break;
447 break;
448 case 0x04:
449 GETBYTE ();
450 switch (op[2] & 0x00)
452 case 0x00:
453 op_semantics_2:
455 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
456 #line 530 "rx-decode.opc"
457 int mx AU = (op[1] >> 6) & 0x03;
458 #line 530 "rx-decode.opc"
459 int ss AU = op[1] & 0x03;
460 #line 530 "rx-decode.opc"
461 int rsrc AU = (op[2] >> 4) & 0x0f;
462 #line 530 "rx-decode.opc"
463 int rdst AU = op[2] & 0x0f;
464 if (trace)
466 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
467 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
468 op[0], op[1], op[2]);
469 printf (" mx = 0x%x,", mx);
470 printf (" ss = 0x%x,", ss);
471 printf (" rsrc = 0x%x,", rsrc);
472 printf (" rdst = 0x%x\n", rdst);
474 SYNTAX("cmp %2%S2, %1");
475 #line 530 "rx-decode.opc"
476 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
478 /*----------------------------------------------------------------------*/
479 /* SUB */
482 break;
484 break;
485 case 0x05:
486 GETBYTE ();
487 switch (op[2] & 0x00)
489 case 0x00:
490 goto op_semantics_2;
491 break;
493 break;
494 case 0x06:
495 GETBYTE ();
496 switch (op[2] & 0x00)
498 case 0x00:
499 goto op_semantics_2;
500 break;
502 break;
503 case 0x07:
504 GETBYTE ();
505 switch (op[2] & 0x00)
507 case 0x00:
508 goto op_semantics_2;
509 break;
511 break;
512 case 0x08:
513 GETBYTE ();
514 switch (op[2] & 0x00)
516 case 0x00:
517 op_semantics_3:
519 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
520 #line 506 "rx-decode.opc"
521 int mx AU = (op[1] >> 6) & 0x03;
522 #line 506 "rx-decode.opc"
523 int ss AU = op[1] & 0x03;
524 #line 506 "rx-decode.opc"
525 int rsrc AU = (op[2] >> 4) & 0x0f;
526 #line 506 "rx-decode.opc"
527 int rdst AU = op[2] & 0x0f;
528 if (trace)
530 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
531 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
532 op[0], op[1], op[2]);
533 printf (" mx = 0x%x,", mx);
534 printf (" ss = 0x%x,", ss);
535 printf (" rsrc = 0x%x,", rsrc);
536 printf (" rdst = 0x%x\n", rdst);
538 SYNTAX("add %1%S1, %0");
539 #line 506 "rx-decode.opc"
540 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
543 break;
545 break;
546 case 0x09:
547 GETBYTE ();
548 switch (op[2] & 0x00)
550 case 0x00:
551 goto op_semantics_3;
552 break;
554 break;
555 case 0x0a:
556 GETBYTE ();
557 switch (op[2] & 0x00)
559 case 0x00:
560 goto op_semantics_3;
561 break;
563 break;
564 case 0x0b:
565 GETBYTE ();
566 switch (op[2] & 0x00)
568 case 0x00:
569 goto op_semantics_3;
570 break;
572 break;
573 case 0x0c:
574 GETBYTE ();
575 switch (op[2] & 0x00)
577 case 0x00:
578 op_semantics_4:
580 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
581 #line 649 "rx-decode.opc"
582 int mx AU = (op[1] >> 6) & 0x03;
583 #line 649 "rx-decode.opc"
584 int ss AU = op[1] & 0x03;
585 #line 649 "rx-decode.opc"
586 int rsrc AU = (op[2] >> 4) & 0x0f;
587 #line 649 "rx-decode.opc"
588 int rdst AU = op[2] & 0x0f;
589 if (trace)
591 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
592 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
593 op[0], op[1], op[2]);
594 printf (" mx = 0x%x,", mx);
595 printf (" ss = 0x%x,", ss);
596 printf (" rsrc = 0x%x,", rsrc);
597 printf (" rdst = 0x%x\n", rdst);
599 SYNTAX("mul %1%S1, %0");
600 #line 649 "rx-decode.opc"
601 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
604 break;
606 break;
607 case 0x0d:
608 GETBYTE ();
609 switch (op[2] & 0x00)
611 case 0x00:
612 goto op_semantics_4;
613 break;
615 break;
616 case 0x0e:
617 GETBYTE ();
618 switch (op[2] & 0x00)
620 case 0x00:
621 goto op_semantics_4;
622 break;
624 break;
625 case 0x0f:
626 GETBYTE ();
627 switch (op[2] & 0x00)
629 case 0x00:
630 goto op_semantics_4;
631 break;
633 break;
634 case 0x10:
635 GETBYTE ();
636 switch (op[2] & 0x00)
638 case 0x00:
639 op_semantics_5:
641 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
642 #line 419 "rx-decode.opc"
643 int mx AU = (op[1] >> 6) & 0x03;
644 #line 419 "rx-decode.opc"
645 int ss AU = op[1] & 0x03;
646 #line 419 "rx-decode.opc"
647 int rsrc AU = (op[2] >> 4) & 0x0f;
648 #line 419 "rx-decode.opc"
649 int rdst AU = op[2] & 0x0f;
650 if (trace)
652 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
653 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
654 op[0], op[1], op[2]);
655 printf (" mx = 0x%x,", mx);
656 printf (" ss = 0x%x,", ss);
657 printf (" rsrc = 0x%x,", rsrc);
658 printf (" rdst = 0x%x\n", rdst);
660 SYNTAX("and %1%S1, %0");
661 #line 419 "rx-decode.opc"
662 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
665 break;
667 break;
668 case 0x11:
669 GETBYTE ();
670 switch (op[2] & 0x00)
672 case 0x00:
673 goto op_semantics_5;
674 break;
676 break;
677 case 0x12:
678 GETBYTE ();
679 switch (op[2] & 0x00)
681 case 0x00:
682 goto op_semantics_5;
683 break;
685 break;
686 case 0x13:
687 GETBYTE ();
688 switch (op[2] & 0x00)
690 case 0x00:
691 goto op_semantics_5;
692 break;
694 break;
695 case 0x14:
696 GETBYTE ();
697 switch (op[2] & 0x00)
699 case 0x00:
700 op_semantics_6:
702 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
703 #line 437 "rx-decode.opc"
704 int mx AU = (op[1] >> 6) & 0x03;
705 #line 437 "rx-decode.opc"
706 int ss AU = op[1] & 0x03;
707 #line 437 "rx-decode.opc"
708 int rsrc AU = (op[2] >> 4) & 0x0f;
709 #line 437 "rx-decode.opc"
710 int rdst AU = op[2] & 0x0f;
711 if (trace)
713 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
714 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
715 op[0], op[1], op[2]);
716 printf (" mx = 0x%x,", mx);
717 printf (" ss = 0x%x,", ss);
718 printf (" rsrc = 0x%x,", rsrc);
719 printf (" rdst = 0x%x\n", rdst);
721 SYNTAX("or %1%S1, %0");
722 #line 437 "rx-decode.opc"
723 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
726 break;
728 break;
729 case 0x15:
730 GETBYTE ();
731 switch (op[2] & 0x00)
733 case 0x00:
734 goto op_semantics_6;
735 break;
737 break;
738 case 0x16:
739 GETBYTE ();
740 switch (op[2] & 0x00)
742 case 0x00:
743 goto op_semantics_6;
744 break;
746 break;
747 case 0x17:
748 GETBYTE ();
749 switch (op[2] & 0x00)
751 case 0x00:
752 goto op_semantics_6;
753 break;
755 break;
756 case 0x20:
757 GETBYTE ();
758 switch (op[2] & 0xff)
760 case 0x00:
761 GETBYTE ();
762 switch (op[3] & 0x00)
764 case 0x00:
765 op_semantics_7:
767 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
768 #line 555 "rx-decode.opc"
769 int mx AU = (op[1] >> 6) & 0x03;
770 #line 555 "rx-decode.opc"
771 int sp AU = op[1] & 0x03;
772 #line 555 "rx-decode.opc"
773 int rsrc AU = (op[3] >> 4) & 0x0f;
774 #line 555 "rx-decode.opc"
775 int rdst AU = op[3] & 0x0f;
776 if (trace)
778 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
779 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
780 op[0], op[1], op[2], op[3]);
781 printf (" mx = 0x%x,", mx);
782 printf (" sp = 0x%x,", sp);
783 printf (" rsrc = 0x%x,", rsrc);
784 printf (" rdst = 0x%x\n", rdst);
786 SYNTAX("sbb %1%S1, %0");
787 #line 555 "rx-decode.opc"
788 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
790 /*----------------------------------------------------------------------*/
791 /* ABS */
794 break;
796 break;
797 case 0x04:
798 GETBYTE ();
799 switch (op[3] & 0x00)
801 case 0x00:
802 op_semantics_8:
804 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
805 #line 594 "rx-decode.opc"
806 int mx AU = (op[1] >> 6) & 0x03;
807 #line 594 "rx-decode.opc"
808 int ss AU = op[1] & 0x03;
809 #line 594 "rx-decode.opc"
810 int rsrc AU = (op[3] >> 4) & 0x0f;
811 #line 594 "rx-decode.opc"
812 int rdst AU = op[3] & 0x0f;
813 if (trace)
815 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
816 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
817 op[0], op[1], op[2], op[3]);
818 printf (" mx = 0x%x,", mx);
819 printf (" ss = 0x%x,", ss);
820 printf (" rsrc = 0x%x,", rsrc);
821 printf (" rdst = 0x%x\n", rdst);
823 SYNTAX("max %1%S1, %0");
824 #line 594 "rx-decode.opc"
825 ID(max); SPm(ss, rsrc, mx); DR(rdst);
827 /*----------------------------------------------------------------------*/
828 /* MIN */
831 break;
833 break;
834 case 0x05:
835 GETBYTE ();
836 switch (op[3] & 0x00)
838 case 0x00:
839 op_semantics_9:
841 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
842 #line 606 "rx-decode.opc"
843 int mx AU = (op[1] >> 6) & 0x03;
844 #line 606 "rx-decode.opc"
845 int ss AU = op[1] & 0x03;
846 #line 606 "rx-decode.opc"
847 int rsrc AU = (op[3] >> 4) & 0x0f;
848 #line 606 "rx-decode.opc"
849 int rdst AU = op[3] & 0x0f;
850 if (trace)
852 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
853 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
854 op[0], op[1], op[2], op[3]);
855 printf (" mx = 0x%x,", mx);
856 printf (" ss = 0x%x,", ss);
857 printf (" rsrc = 0x%x,", rsrc);
858 printf (" rdst = 0x%x\n", rdst);
860 SYNTAX("min %1%S1, %0");
861 #line 606 "rx-decode.opc"
862 ID(min); SPm(ss, rsrc, mx); DR(rdst);
864 /*----------------------------------------------------------------------*/
865 /* MUL */
868 break;
870 break;
871 case 0x06:
872 GETBYTE ();
873 switch (op[3] & 0x00)
875 case 0x00:
876 op_semantics_10:
878 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
879 #line 664 "rx-decode.opc"
880 int mx AU = (op[1] >> 6) & 0x03;
881 #line 664 "rx-decode.opc"
882 int ss AU = op[1] & 0x03;
883 #line 664 "rx-decode.opc"
884 int rsrc AU = (op[3] >> 4) & 0x0f;
885 #line 664 "rx-decode.opc"
886 int rdst AU = op[3] & 0x0f;
887 if (trace)
889 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
890 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
891 op[0], op[1], op[2], op[3]);
892 printf (" mx = 0x%x,", mx);
893 printf (" ss = 0x%x,", ss);
894 printf (" rsrc = 0x%x,", rsrc);
895 printf (" rdst = 0x%x\n", rdst);
897 SYNTAX("emul %1%S1, %0");
898 #line 664 "rx-decode.opc"
899 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
901 /*----------------------------------------------------------------------*/
902 /* EMULU */
905 break;
907 break;
908 case 0x07:
909 GETBYTE ();
910 switch (op[3] & 0x00)
912 case 0x00:
913 op_semantics_11:
915 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
916 #line 676 "rx-decode.opc"
917 int mx AU = (op[1] >> 6) & 0x03;
918 #line 676 "rx-decode.opc"
919 int ss AU = op[1] & 0x03;
920 #line 676 "rx-decode.opc"
921 int rsrc AU = (op[3] >> 4) & 0x0f;
922 #line 676 "rx-decode.opc"
923 int rdst AU = op[3] & 0x0f;
924 if (trace)
926 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
927 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
928 op[0], op[1], op[2], op[3]);
929 printf (" mx = 0x%x,", mx);
930 printf (" ss = 0x%x,", ss);
931 printf (" rsrc = 0x%x,", rsrc);
932 printf (" rdst = 0x%x\n", rdst);
934 SYNTAX("emulu %1%S1, %0");
935 #line 676 "rx-decode.opc"
936 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
938 /*----------------------------------------------------------------------*/
939 /* DIV */
942 break;
944 break;
945 case 0x08:
946 GETBYTE ();
947 switch (op[3] & 0x00)
949 case 0x00:
950 op_semantics_12:
952 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
953 #line 688 "rx-decode.opc"
954 int mx AU = (op[1] >> 6) & 0x03;
955 #line 688 "rx-decode.opc"
956 int ss AU = op[1] & 0x03;
957 #line 688 "rx-decode.opc"
958 int rsrc AU = (op[3] >> 4) & 0x0f;
959 #line 688 "rx-decode.opc"
960 int rdst AU = op[3] & 0x0f;
961 if (trace)
963 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
964 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
965 op[0], op[1], op[2], op[3]);
966 printf (" mx = 0x%x,", mx);
967 printf (" ss = 0x%x,", ss);
968 printf (" rsrc = 0x%x,", rsrc);
969 printf (" rdst = 0x%x\n", rdst);
971 SYNTAX("div %1%S1, %0");
972 #line 688 "rx-decode.opc"
973 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
975 /*----------------------------------------------------------------------*/
976 /* DIVU */
979 break;
981 break;
982 case 0x09:
983 GETBYTE ();
984 switch (op[3] & 0x00)
986 case 0x00:
987 op_semantics_13:
989 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
990 #line 700 "rx-decode.opc"
991 int mx AU = (op[1] >> 6) & 0x03;
992 #line 700 "rx-decode.opc"
993 int ss AU = op[1] & 0x03;
994 #line 700 "rx-decode.opc"
995 int rsrc AU = (op[3] >> 4) & 0x0f;
996 #line 700 "rx-decode.opc"
997 int rdst AU = op[3] & 0x0f;
998 if (trace)
1000 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1001 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1002 op[0], op[1], op[2], op[3]);
1003 printf (" mx = 0x%x,", mx);
1004 printf (" ss = 0x%x,", ss);
1005 printf (" rsrc = 0x%x,", rsrc);
1006 printf (" rdst = 0x%x\n", rdst);
1008 SYNTAX("divu %1%S1, %0");
1009 #line 700 "rx-decode.opc"
1010 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1012 /*----------------------------------------------------------------------*/
1013 /* SHIFT */
1016 break;
1018 break;
1019 case 0x0c:
1020 GETBYTE ();
1021 switch (op[3] & 0x00)
1023 case 0x00:
1024 op_semantics_14:
1026 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1027 #line 473 "rx-decode.opc"
1028 int mx AU = (op[1] >> 6) & 0x03;
1029 #line 473 "rx-decode.opc"
1030 int ss AU = op[1] & 0x03;
1031 #line 473 "rx-decode.opc"
1032 int rsrc AU = (op[3] >> 4) & 0x0f;
1033 #line 473 "rx-decode.opc"
1034 int rdst AU = op[3] & 0x0f;
1035 if (trace)
1037 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1038 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1039 op[0], op[1], op[2], op[3]);
1040 printf (" mx = 0x%x,", mx);
1041 printf (" ss = 0x%x,", ss);
1042 printf (" rsrc = 0x%x,", rsrc);
1043 printf (" rdst = 0x%x\n", rdst);
1045 SYNTAX("tst %1%S1, %2");
1046 #line 473 "rx-decode.opc"
1047 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1049 /*----------------------------------------------------------------------*/
1050 /* NEG */
1053 break;
1055 break;
1056 case 0x0d:
1057 GETBYTE ();
1058 switch (op[3] & 0x00)
1060 case 0x00:
1061 op_semantics_15:
1063 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1064 #line 452 "rx-decode.opc"
1065 int mx AU = (op[1] >> 6) & 0x03;
1066 #line 452 "rx-decode.opc"
1067 int ss AU = op[1] & 0x03;
1068 #line 452 "rx-decode.opc"
1069 int rsrc AU = (op[3] >> 4) & 0x0f;
1070 #line 452 "rx-decode.opc"
1071 int rdst AU = op[3] & 0x0f;
1072 if (trace)
1074 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1075 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1076 op[0], op[1], op[2], op[3]);
1077 printf (" mx = 0x%x,", mx);
1078 printf (" ss = 0x%x,", ss);
1079 printf (" rsrc = 0x%x,", rsrc);
1080 printf (" rdst = 0x%x\n", rdst);
1082 SYNTAX("xor %1%S1, %0");
1083 #line 452 "rx-decode.opc"
1084 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1086 /*----------------------------------------------------------------------*/
1087 /* NOT */
1090 break;
1092 break;
1093 case 0x10:
1094 GETBYTE ();
1095 switch (op[3] & 0x00)
1097 case 0x00:
1098 op_semantics_16:
1100 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1101 #line 386 "rx-decode.opc"
1102 int mx AU = (op[1] >> 6) & 0x03;
1103 #line 386 "rx-decode.opc"
1104 int ss AU = op[1] & 0x03;
1105 #line 386 "rx-decode.opc"
1106 int rsrc AU = (op[3] >> 4) & 0x0f;
1107 #line 386 "rx-decode.opc"
1108 int rdst AU = op[3] & 0x0f;
1109 if (trace)
1111 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1112 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1113 op[0], op[1], op[2], op[3]);
1114 printf (" mx = 0x%x,", mx);
1115 printf (" ss = 0x%x,", ss);
1116 printf (" rsrc = 0x%x,", rsrc);
1117 printf (" rdst = 0x%x\n", rdst);
1119 SYNTAX("xchg %1%S1, %0");
1120 #line 386 "rx-decode.opc"
1121 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1123 /*----------------------------------------------------------------------*/
1124 /* STZ/STNZ */
1127 break;
1129 break;
1130 case 0x11:
1131 GETBYTE ();
1132 switch (op[3] & 0x00)
1134 case 0x00:
1135 op_semantics_17:
1137 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1138 #line 929 "rx-decode.opc"
1139 int mx AU = (op[1] >> 6) & 0x03;
1140 #line 929 "rx-decode.opc"
1141 int sd AU = op[1] & 0x03;
1142 #line 929 "rx-decode.opc"
1143 int rsrc AU = (op[3] >> 4) & 0x0f;
1144 #line 929 "rx-decode.opc"
1145 int rdst AU = op[3] & 0x0f;
1146 if (trace)
1148 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1149 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1150 op[0], op[1], op[2], op[3]);
1151 printf (" mx = 0x%x,", mx);
1152 printf (" sd = 0x%x,", sd);
1153 printf (" rsrc = 0x%x,", rsrc);
1154 printf (" rdst = 0x%x\n", rdst);
1156 SYNTAX("itof %1%S1, %0");
1157 #line 929 "rx-decode.opc"
1158 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1160 /*----------------------------------------------------------------------*/
1161 /* BIT OPS */
1164 break;
1166 break;
1167 case 0x15:
1168 GETBYTE ();
1169 switch (op[3] & 0x00)
1171 case 0x00:
1172 op_semantics_18:
1174 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
1175 #line 1115 "rx-decode.opc"
1176 int mx AU = (op[1] >> 6) & 0x03;
1177 #line 1115 "rx-decode.opc"
1178 int sd AU = op[1] & 0x03;
1179 #line 1115 "rx-decode.opc"
1180 int rsrc AU = (op[3] >> 4) & 0x0f;
1181 #line 1115 "rx-decode.opc"
1182 int rdst AU = op[3] & 0x0f;
1183 if (trace)
1185 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1186 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1187 op[0], op[1], op[2], op[3]);
1188 printf (" mx = 0x%x,", mx);
1189 printf (" sd = 0x%x,", sd);
1190 printf (" rsrc = 0x%x,", rsrc);
1191 printf (" rdst = 0x%x\n", rdst);
1193 SYNTAX("utof %1%S1, %0");
1194 #line 1115 "rx-decode.opc"
1195 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1198 break;
1200 break;
1201 default: UNSUPPORTED(); break;
1203 break;
1204 case 0x21:
1205 GETBYTE ();
1206 switch (op[2] & 0xff)
1208 case 0x00:
1209 GETBYTE ();
1210 switch (op[3] & 0x00)
1212 case 0x00:
1213 goto op_semantics_7;
1214 break;
1216 break;
1217 case 0x04:
1218 GETBYTE ();
1219 switch (op[3] & 0x00)
1221 case 0x00:
1222 goto op_semantics_8;
1223 break;
1225 break;
1226 case 0x05:
1227 GETBYTE ();
1228 switch (op[3] & 0x00)
1230 case 0x00:
1231 goto op_semantics_9;
1232 break;
1234 break;
1235 case 0x06:
1236 GETBYTE ();
1237 switch (op[3] & 0x00)
1239 case 0x00:
1240 goto op_semantics_10;
1241 break;
1243 break;
1244 case 0x07:
1245 GETBYTE ();
1246 switch (op[3] & 0x00)
1248 case 0x00:
1249 goto op_semantics_11;
1250 break;
1252 break;
1253 case 0x08:
1254 GETBYTE ();
1255 switch (op[3] & 0x00)
1257 case 0x00:
1258 goto op_semantics_12;
1259 break;
1261 break;
1262 case 0x09:
1263 GETBYTE ();
1264 switch (op[3] & 0x00)
1266 case 0x00:
1267 goto op_semantics_13;
1268 break;
1270 break;
1271 case 0x0c:
1272 GETBYTE ();
1273 switch (op[3] & 0x00)
1275 case 0x00:
1276 goto op_semantics_14;
1277 break;
1279 break;
1280 case 0x0d:
1281 GETBYTE ();
1282 switch (op[3] & 0x00)
1284 case 0x00:
1285 goto op_semantics_15;
1286 break;
1288 break;
1289 case 0x10:
1290 GETBYTE ();
1291 switch (op[3] & 0x00)
1293 case 0x00:
1294 goto op_semantics_16;
1295 break;
1297 break;
1298 case 0x11:
1299 GETBYTE ();
1300 switch (op[3] & 0x00)
1302 case 0x00:
1303 goto op_semantics_17;
1304 break;
1306 break;
1307 case 0x15:
1308 GETBYTE ();
1309 switch (op[3] & 0x00)
1311 case 0x00:
1312 goto op_semantics_18;
1313 break;
1315 break;
1316 default: UNSUPPORTED(); break;
1318 break;
1319 case 0x22:
1320 GETBYTE ();
1321 switch (op[2] & 0xff)
1323 case 0x00:
1324 GETBYTE ();
1325 switch (op[3] & 0x00)
1327 case 0x00:
1328 goto op_semantics_7;
1329 break;
1331 break;
1332 case 0x04:
1333 GETBYTE ();
1334 switch (op[3] & 0x00)
1336 case 0x00:
1337 goto op_semantics_8;
1338 break;
1340 break;
1341 case 0x05:
1342 GETBYTE ();
1343 switch (op[3] & 0x00)
1345 case 0x00:
1346 goto op_semantics_9;
1347 break;
1349 break;
1350 case 0x06:
1351 GETBYTE ();
1352 switch (op[3] & 0x00)
1354 case 0x00:
1355 goto op_semantics_10;
1356 break;
1358 break;
1359 case 0x07:
1360 GETBYTE ();
1361 switch (op[3] & 0x00)
1363 case 0x00:
1364 goto op_semantics_11;
1365 break;
1367 break;
1368 case 0x08:
1369 GETBYTE ();
1370 switch (op[3] & 0x00)
1372 case 0x00:
1373 goto op_semantics_12;
1374 break;
1376 break;
1377 case 0x09:
1378 GETBYTE ();
1379 switch (op[3] & 0x00)
1381 case 0x00:
1382 goto op_semantics_13;
1383 break;
1385 break;
1386 case 0x0c:
1387 GETBYTE ();
1388 switch (op[3] & 0x00)
1390 case 0x00:
1391 goto op_semantics_14;
1392 break;
1394 break;
1395 case 0x0d:
1396 GETBYTE ();
1397 switch (op[3] & 0x00)
1399 case 0x00:
1400 goto op_semantics_15;
1401 break;
1403 break;
1404 case 0x10:
1405 GETBYTE ();
1406 switch (op[3] & 0x00)
1408 case 0x00:
1409 goto op_semantics_16;
1410 break;
1412 break;
1413 case 0x11:
1414 GETBYTE ();
1415 switch (op[3] & 0x00)
1417 case 0x00:
1418 goto op_semantics_17;
1419 break;
1421 break;
1422 case 0x15:
1423 GETBYTE ();
1424 switch (op[3] & 0x00)
1426 case 0x00:
1427 goto op_semantics_18;
1428 break;
1430 break;
1431 default: UNSUPPORTED(); break;
1433 break;
1434 case 0x23:
1435 GETBYTE ();
1436 switch (op[2] & 0xff)
1438 case 0x00:
1439 GETBYTE ();
1440 switch (op[3] & 0x00)
1442 case 0x00:
1443 goto op_semantics_7;
1444 break;
1446 break;
1447 case 0x04:
1448 GETBYTE ();
1449 switch (op[3] & 0x00)
1451 case 0x00:
1452 goto op_semantics_8;
1453 break;
1455 break;
1456 case 0x05:
1457 GETBYTE ();
1458 switch (op[3] & 0x00)
1460 case 0x00:
1461 goto op_semantics_9;
1462 break;
1464 break;
1465 case 0x06:
1466 GETBYTE ();
1467 switch (op[3] & 0x00)
1469 case 0x00:
1470 goto op_semantics_10;
1471 break;
1473 break;
1474 case 0x07:
1475 GETBYTE ();
1476 switch (op[3] & 0x00)
1478 case 0x00:
1479 goto op_semantics_11;
1480 break;
1482 break;
1483 case 0x08:
1484 GETBYTE ();
1485 switch (op[3] & 0x00)
1487 case 0x00:
1488 goto op_semantics_12;
1489 break;
1491 break;
1492 case 0x09:
1493 GETBYTE ();
1494 switch (op[3] & 0x00)
1496 case 0x00:
1497 goto op_semantics_13;
1498 break;
1500 break;
1501 case 0x0c:
1502 GETBYTE ();
1503 switch (op[3] & 0x00)
1505 case 0x00:
1506 goto op_semantics_14;
1507 break;
1509 break;
1510 case 0x0d:
1511 GETBYTE ();
1512 switch (op[3] & 0x00)
1514 case 0x00:
1515 goto op_semantics_15;
1516 break;
1518 break;
1519 case 0x10:
1520 GETBYTE ();
1521 switch (op[3] & 0x00)
1523 case 0x00:
1524 goto op_semantics_16;
1525 break;
1527 break;
1528 case 0x11:
1529 GETBYTE ();
1530 switch (op[3] & 0x00)
1532 case 0x00:
1533 goto op_semantics_17;
1534 break;
1536 break;
1537 case 0x15:
1538 GETBYTE ();
1539 switch (op[3] & 0x00)
1541 case 0x00:
1542 goto op_semantics_18;
1543 break;
1545 break;
1546 default: UNSUPPORTED(); break;
1548 break;
1549 case 0x40:
1550 GETBYTE ();
1551 switch (op[2] & 0x00)
1553 case 0x00:
1554 goto op_semantics_1;
1555 break;
1557 break;
1558 case 0x41:
1559 GETBYTE ();
1560 switch (op[2] & 0x00)
1562 case 0x00:
1563 goto op_semantics_1;
1564 break;
1566 break;
1567 case 0x42:
1568 GETBYTE ();
1569 switch (op[2] & 0x00)
1571 case 0x00:
1572 goto op_semantics_1;
1573 break;
1575 break;
1576 case 0x43:
1577 GETBYTE ();
1578 switch (op[2] & 0x00)
1580 case 0x00:
1581 goto op_semantics_1;
1582 break;
1584 break;
1585 case 0x44:
1586 GETBYTE ();
1587 switch (op[2] & 0x00)
1589 case 0x00:
1590 goto op_semantics_2;
1591 break;
1593 break;
1594 case 0x45:
1595 GETBYTE ();
1596 switch (op[2] & 0x00)
1598 case 0x00:
1599 goto op_semantics_2;
1600 break;
1602 break;
1603 case 0x46:
1604 GETBYTE ();
1605 switch (op[2] & 0x00)
1607 case 0x00:
1608 goto op_semantics_2;
1609 break;
1611 break;
1612 case 0x47:
1613 GETBYTE ();
1614 switch (op[2] & 0x00)
1616 case 0x00:
1617 goto op_semantics_2;
1618 break;
1620 break;
1621 case 0x48:
1622 GETBYTE ();
1623 switch (op[2] & 0x00)
1625 case 0x00:
1626 goto op_semantics_3;
1627 break;
1629 break;
1630 case 0x49:
1631 GETBYTE ();
1632 switch (op[2] & 0x00)
1634 case 0x00:
1635 goto op_semantics_3;
1636 break;
1638 break;
1639 case 0x4a:
1640 GETBYTE ();
1641 switch (op[2] & 0x00)
1643 case 0x00:
1644 goto op_semantics_3;
1645 break;
1647 break;
1648 case 0x4b:
1649 GETBYTE ();
1650 switch (op[2] & 0x00)
1652 case 0x00:
1653 goto op_semantics_3;
1654 break;
1656 break;
1657 case 0x4c:
1658 GETBYTE ();
1659 switch (op[2] & 0x00)
1661 case 0x00:
1662 goto op_semantics_4;
1663 break;
1665 break;
1666 case 0x4d:
1667 GETBYTE ();
1668 switch (op[2] & 0x00)
1670 case 0x00:
1671 goto op_semantics_4;
1672 break;
1674 break;
1675 case 0x4e:
1676 GETBYTE ();
1677 switch (op[2] & 0x00)
1679 case 0x00:
1680 goto op_semantics_4;
1681 break;
1683 break;
1684 case 0x4f:
1685 GETBYTE ();
1686 switch (op[2] & 0x00)
1688 case 0x00:
1689 goto op_semantics_4;
1690 break;
1692 break;
1693 case 0x50:
1694 GETBYTE ();
1695 switch (op[2] & 0x00)
1697 case 0x00:
1698 goto op_semantics_5;
1699 break;
1701 break;
1702 case 0x51:
1703 GETBYTE ();
1704 switch (op[2] & 0x00)
1706 case 0x00:
1707 goto op_semantics_5;
1708 break;
1710 break;
1711 case 0x52:
1712 GETBYTE ();
1713 switch (op[2] & 0x00)
1715 case 0x00:
1716 goto op_semantics_5;
1717 break;
1719 break;
1720 case 0x53:
1721 GETBYTE ();
1722 switch (op[2] & 0x00)
1724 case 0x00:
1725 goto op_semantics_5;
1726 break;
1728 break;
1729 case 0x54:
1730 GETBYTE ();
1731 switch (op[2] & 0x00)
1733 case 0x00:
1734 goto op_semantics_6;
1735 break;
1737 break;
1738 case 0x55:
1739 GETBYTE ();
1740 switch (op[2] & 0x00)
1742 case 0x00:
1743 goto op_semantics_6;
1744 break;
1746 break;
1747 case 0x56:
1748 GETBYTE ();
1749 switch (op[2] & 0x00)
1751 case 0x00:
1752 goto op_semantics_6;
1753 break;
1755 break;
1756 case 0x57:
1757 GETBYTE ();
1758 switch (op[2] & 0x00)
1760 case 0x00:
1761 goto op_semantics_6;
1762 break;
1764 break;
1765 case 0x60:
1766 GETBYTE ();
1767 switch (op[2] & 0xff)
1769 case 0x00:
1770 GETBYTE ();
1771 switch (op[3] & 0x00)
1773 case 0x00:
1774 goto op_semantics_7;
1775 break;
1777 break;
1778 case 0x04:
1779 GETBYTE ();
1780 switch (op[3] & 0x00)
1782 case 0x00:
1783 goto op_semantics_8;
1784 break;
1786 break;
1787 case 0x05:
1788 GETBYTE ();
1789 switch (op[3] & 0x00)
1791 case 0x00:
1792 goto op_semantics_9;
1793 break;
1795 break;
1796 case 0x06:
1797 GETBYTE ();
1798 switch (op[3] & 0x00)
1800 case 0x00:
1801 goto op_semantics_10;
1802 break;
1804 break;
1805 case 0x07:
1806 GETBYTE ();
1807 switch (op[3] & 0x00)
1809 case 0x00:
1810 goto op_semantics_11;
1811 break;
1813 break;
1814 case 0x08:
1815 GETBYTE ();
1816 switch (op[3] & 0x00)
1818 case 0x00:
1819 goto op_semantics_12;
1820 break;
1822 break;
1823 case 0x09:
1824 GETBYTE ();
1825 switch (op[3] & 0x00)
1827 case 0x00:
1828 goto op_semantics_13;
1829 break;
1831 break;
1832 case 0x0c:
1833 GETBYTE ();
1834 switch (op[3] & 0x00)
1836 case 0x00:
1837 goto op_semantics_14;
1838 break;
1840 break;
1841 case 0x0d:
1842 GETBYTE ();
1843 switch (op[3] & 0x00)
1845 case 0x00:
1846 goto op_semantics_15;
1847 break;
1849 break;
1850 case 0x10:
1851 GETBYTE ();
1852 switch (op[3] & 0x00)
1854 case 0x00:
1855 goto op_semantics_16;
1856 break;
1858 break;
1859 case 0x11:
1860 GETBYTE ();
1861 switch (op[3] & 0x00)
1863 case 0x00:
1864 goto op_semantics_17;
1865 break;
1867 break;
1868 case 0x15:
1869 GETBYTE ();
1870 switch (op[3] & 0x00)
1872 case 0x00:
1873 goto op_semantics_18;
1874 break;
1876 break;
1877 default: UNSUPPORTED(); break;
1879 break;
1880 case 0x61:
1881 GETBYTE ();
1882 switch (op[2] & 0xff)
1884 case 0x00:
1885 GETBYTE ();
1886 switch (op[3] & 0x00)
1888 case 0x00:
1889 goto op_semantics_7;
1890 break;
1892 break;
1893 case 0x04:
1894 GETBYTE ();
1895 switch (op[3] & 0x00)
1897 case 0x00:
1898 goto op_semantics_8;
1899 break;
1901 break;
1902 case 0x05:
1903 GETBYTE ();
1904 switch (op[3] & 0x00)
1906 case 0x00:
1907 goto op_semantics_9;
1908 break;
1910 break;
1911 case 0x06:
1912 GETBYTE ();
1913 switch (op[3] & 0x00)
1915 case 0x00:
1916 goto op_semantics_10;
1917 break;
1919 break;
1920 case 0x07:
1921 GETBYTE ();
1922 switch (op[3] & 0x00)
1924 case 0x00:
1925 goto op_semantics_11;
1926 break;
1928 break;
1929 case 0x08:
1930 GETBYTE ();
1931 switch (op[3] & 0x00)
1933 case 0x00:
1934 goto op_semantics_12;
1935 break;
1937 break;
1938 case 0x09:
1939 GETBYTE ();
1940 switch (op[3] & 0x00)
1942 case 0x00:
1943 goto op_semantics_13;
1944 break;
1946 break;
1947 case 0x0c:
1948 GETBYTE ();
1949 switch (op[3] & 0x00)
1951 case 0x00:
1952 goto op_semantics_14;
1953 break;
1955 break;
1956 case 0x0d:
1957 GETBYTE ();
1958 switch (op[3] & 0x00)
1960 case 0x00:
1961 goto op_semantics_15;
1962 break;
1964 break;
1965 case 0x10:
1966 GETBYTE ();
1967 switch (op[3] & 0x00)
1969 case 0x00:
1970 goto op_semantics_16;
1971 break;
1973 break;
1974 case 0x11:
1975 GETBYTE ();
1976 switch (op[3] & 0x00)
1978 case 0x00:
1979 goto op_semantics_17;
1980 break;
1982 break;
1983 case 0x15:
1984 GETBYTE ();
1985 switch (op[3] & 0x00)
1987 case 0x00:
1988 goto op_semantics_18;
1989 break;
1991 break;
1992 default: UNSUPPORTED(); break;
1994 break;
1995 case 0x62:
1996 GETBYTE ();
1997 switch (op[2] & 0xff)
1999 case 0x00:
2000 GETBYTE ();
2001 switch (op[3] & 0x00)
2003 case 0x00:
2004 goto op_semantics_7;
2005 break;
2007 break;
2008 case 0x04:
2009 GETBYTE ();
2010 switch (op[3] & 0x00)
2012 case 0x00:
2013 goto op_semantics_8;
2014 break;
2016 break;
2017 case 0x05:
2018 GETBYTE ();
2019 switch (op[3] & 0x00)
2021 case 0x00:
2022 goto op_semantics_9;
2023 break;
2025 break;
2026 case 0x06:
2027 GETBYTE ();
2028 switch (op[3] & 0x00)
2030 case 0x00:
2031 goto op_semantics_10;
2032 break;
2034 break;
2035 case 0x07:
2036 GETBYTE ();
2037 switch (op[3] & 0x00)
2039 case 0x00:
2040 goto op_semantics_11;
2041 break;
2043 break;
2044 case 0x08:
2045 GETBYTE ();
2046 switch (op[3] & 0x00)
2048 case 0x00:
2049 goto op_semantics_12;
2050 break;
2052 break;
2053 case 0x09:
2054 GETBYTE ();
2055 switch (op[3] & 0x00)
2057 case 0x00:
2058 goto op_semantics_13;
2059 break;
2061 break;
2062 case 0x0c:
2063 GETBYTE ();
2064 switch (op[3] & 0x00)
2066 case 0x00:
2067 goto op_semantics_14;
2068 break;
2070 break;
2071 case 0x0d:
2072 GETBYTE ();
2073 switch (op[3] & 0x00)
2075 case 0x00:
2076 goto op_semantics_15;
2077 break;
2079 break;
2080 case 0x10:
2081 GETBYTE ();
2082 switch (op[3] & 0x00)
2084 case 0x00:
2085 goto op_semantics_16;
2086 break;
2088 break;
2089 case 0x11:
2090 GETBYTE ();
2091 switch (op[3] & 0x00)
2093 case 0x00:
2094 goto op_semantics_17;
2095 break;
2097 break;
2098 case 0x15:
2099 GETBYTE ();
2100 switch (op[3] & 0x00)
2102 case 0x00:
2103 goto op_semantics_18;
2104 break;
2106 break;
2107 default: UNSUPPORTED(); break;
2109 break;
2110 case 0x63:
2111 GETBYTE ();
2112 switch (op[2] & 0xff)
2114 case 0x00:
2115 GETBYTE ();
2116 switch (op[3] & 0x00)
2118 case 0x00:
2119 goto op_semantics_7;
2120 break;
2122 break;
2123 case 0x04:
2124 GETBYTE ();
2125 switch (op[3] & 0x00)
2127 case 0x00:
2128 goto op_semantics_8;
2129 break;
2131 break;
2132 case 0x05:
2133 GETBYTE ();
2134 switch (op[3] & 0x00)
2136 case 0x00:
2137 goto op_semantics_9;
2138 break;
2140 break;
2141 case 0x06:
2142 GETBYTE ();
2143 switch (op[3] & 0x00)
2145 case 0x00:
2146 goto op_semantics_10;
2147 break;
2149 break;
2150 case 0x07:
2151 GETBYTE ();
2152 switch (op[3] & 0x00)
2154 case 0x00:
2155 goto op_semantics_11;
2156 break;
2158 break;
2159 case 0x08:
2160 GETBYTE ();
2161 switch (op[3] & 0x00)
2163 case 0x00:
2164 goto op_semantics_12;
2165 break;
2167 break;
2168 case 0x09:
2169 GETBYTE ();
2170 switch (op[3] & 0x00)
2172 case 0x00:
2173 goto op_semantics_13;
2174 break;
2176 break;
2177 case 0x0c:
2178 GETBYTE ();
2179 switch (op[3] & 0x00)
2181 case 0x00:
2182 goto op_semantics_14;
2183 break;
2185 break;
2186 case 0x0d:
2187 GETBYTE ();
2188 switch (op[3] & 0x00)
2190 case 0x00:
2191 goto op_semantics_15;
2192 break;
2194 break;
2195 case 0x10:
2196 GETBYTE ();
2197 switch (op[3] & 0x00)
2199 case 0x00:
2200 goto op_semantics_16;
2201 break;
2203 break;
2204 case 0x11:
2205 GETBYTE ();
2206 switch (op[3] & 0x00)
2208 case 0x00:
2209 goto op_semantics_17;
2210 break;
2212 break;
2213 case 0x15:
2214 GETBYTE ();
2215 switch (op[3] & 0x00)
2217 case 0x00:
2218 goto op_semantics_18;
2219 break;
2221 break;
2222 default: UNSUPPORTED(); break;
2224 break;
2225 case 0x80:
2226 GETBYTE ();
2227 switch (op[2] & 0x00)
2229 case 0x00:
2230 goto op_semantics_1;
2231 break;
2233 break;
2234 case 0x81:
2235 GETBYTE ();
2236 switch (op[2] & 0x00)
2238 case 0x00:
2239 goto op_semantics_1;
2240 break;
2242 break;
2243 case 0x82:
2244 GETBYTE ();
2245 switch (op[2] & 0x00)
2247 case 0x00:
2248 goto op_semantics_1;
2249 break;
2251 break;
2252 case 0x83:
2253 GETBYTE ();
2254 switch (op[2] & 0x00)
2256 case 0x00:
2257 goto op_semantics_1;
2258 break;
2260 break;
2261 case 0x84:
2262 GETBYTE ();
2263 switch (op[2] & 0x00)
2265 case 0x00:
2266 goto op_semantics_2;
2267 break;
2269 break;
2270 case 0x85:
2271 GETBYTE ();
2272 switch (op[2] & 0x00)
2274 case 0x00:
2275 goto op_semantics_2;
2276 break;
2278 break;
2279 case 0x86:
2280 GETBYTE ();
2281 switch (op[2] & 0x00)
2283 case 0x00:
2284 goto op_semantics_2;
2285 break;
2287 break;
2288 case 0x87:
2289 GETBYTE ();
2290 switch (op[2] & 0x00)
2292 case 0x00:
2293 goto op_semantics_2;
2294 break;
2296 break;
2297 case 0x88:
2298 GETBYTE ();
2299 switch (op[2] & 0x00)
2301 case 0x00:
2302 goto op_semantics_3;
2303 break;
2305 break;
2306 case 0x89:
2307 GETBYTE ();
2308 switch (op[2] & 0x00)
2310 case 0x00:
2311 goto op_semantics_3;
2312 break;
2314 break;
2315 case 0x8a:
2316 GETBYTE ();
2317 switch (op[2] & 0x00)
2319 case 0x00:
2320 goto op_semantics_3;
2321 break;
2323 break;
2324 case 0x8b:
2325 GETBYTE ();
2326 switch (op[2] & 0x00)
2328 case 0x00:
2329 goto op_semantics_3;
2330 break;
2332 break;
2333 case 0x8c:
2334 GETBYTE ();
2335 switch (op[2] & 0x00)
2337 case 0x00:
2338 goto op_semantics_4;
2339 break;
2341 break;
2342 case 0x8d:
2343 GETBYTE ();
2344 switch (op[2] & 0x00)
2346 case 0x00:
2347 goto op_semantics_4;
2348 break;
2350 break;
2351 case 0x8e:
2352 GETBYTE ();
2353 switch (op[2] & 0x00)
2355 case 0x00:
2356 goto op_semantics_4;
2357 break;
2359 break;
2360 case 0x8f:
2361 GETBYTE ();
2362 switch (op[2] & 0x00)
2364 case 0x00:
2365 goto op_semantics_4;
2366 break;
2368 break;
2369 case 0x90:
2370 GETBYTE ();
2371 switch (op[2] & 0x00)
2373 case 0x00:
2374 goto op_semantics_5;
2375 break;
2377 break;
2378 case 0x91:
2379 GETBYTE ();
2380 switch (op[2] & 0x00)
2382 case 0x00:
2383 goto op_semantics_5;
2384 break;
2386 break;
2387 case 0x92:
2388 GETBYTE ();
2389 switch (op[2] & 0x00)
2391 case 0x00:
2392 goto op_semantics_5;
2393 break;
2395 break;
2396 case 0x93:
2397 GETBYTE ();
2398 switch (op[2] & 0x00)
2400 case 0x00:
2401 goto op_semantics_5;
2402 break;
2404 break;
2405 case 0x94:
2406 GETBYTE ();
2407 switch (op[2] & 0x00)
2409 case 0x00:
2410 goto op_semantics_6;
2411 break;
2413 break;
2414 case 0x95:
2415 GETBYTE ();
2416 switch (op[2] & 0x00)
2418 case 0x00:
2419 goto op_semantics_6;
2420 break;
2422 break;
2423 case 0x96:
2424 GETBYTE ();
2425 switch (op[2] & 0x00)
2427 case 0x00:
2428 goto op_semantics_6;
2429 break;
2431 break;
2432 case 0x97:
2433 GETBYTE ();
2434 switch (op[2] & 0x00)
2436 case 0x00:
2437 goto op_semantics_6;
2438 break;
2440 break;
2441 case 0xa0:
2442 GETBYTE ();
2443 switch (op[2] & 0xff)
2445 case 0x00:
2446 GETBYTE ();
2447 switch (op[3] & 0x00)
2449 case 0x00:
2450 goto op_semantics_7;
2451 break;
2453 break;
2454 case 0x02:
2455 GETBYTE ();
2456 switch (op[3] & 0x00)
2458 case 0x00:
2459 op_semantics_19:
2461 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2462 #line 494 "rx-decode.opc"
2463 int ss AU = op[1] & 0x03;
2464 #line 494 "rx-decode.opc"
2465 int rsrc AU = (op[3] >> 4) & 0x0f;
2466 #line 494 "rx-decode.opc"
2467 int rdst AU = op[3] & 0x0f;
2468 if (trace)
2470 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2471 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2472 op[0], op[1], op[2], op[3]);
2473 printf (" ss = 0x%x,", ss);
2474 printf (" rsrc = 0x%x,", rsrc);
2475 printf (" rdst = 0x%x\n", rdst);
2477 SYNTAX("adc %1%S1, %0");
2478 #line 494 "rx-decode.opc"
2479 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2481 /*----------------------------------------------------------------------*/
2482 /* ADD */
2485 break;
2487 break;
2488 case 0x04:
2489 GETBYTE ();
2490 switch (op[3] & 0x00)
2492 case 0x00:
2493 goto op_semantics_8;
2494 break;
2496 break;
2497 case 0x05:
2498 GETBYTE ();
2499 switch (op[3] & 0x00)
2501 case 0x00:
2502 goto op_semantics_9;
2503 break;
2505 break;
2506 case 0x06:
2507 GETBYTE ();
2508 switch (op[3] & 0x00)
2510 case 0x00:
2511 goto op_semantics_10;
2512 break;
2514 break;
2515 case 0x07:
2516 GETBYTE ();
2517 switch (op[3] & 0x00)
2519 case 0x00:
2520 goto op_semantics_11;
2521 break;
2523 break;
2524 case 0x08:
2525 GETBYTE ();
2526 switch (op[3] & 0x00)
2528 case 0x00:
2529 goto op_semantics_12;
2530 break;
2532 break;
2533 case 0x09:
2534 GETBYTE ();
2535 switch (op[3] & 0x00)
2537 case 0x00:
2538 goto op_semantics_13;
2539 break;
2541 break;
2542 case 0x0c:
2543 GETBYTE ();
2544 switch (op[3] & 0x00)
2546 case 0x00:
2547 goto op_semantics_14;
2548 break;
2550 break;
2551 case 0x0d:
2552 GETBYTE ();
2553 switch (op[3] & 0x00)
2555 case 0x00:
2556 goto op_semantics_15;
2557 break;
2559 break;
2560 case 0x10:
2561 GETBYTE ();
2562 switch (op[3] & 0x00)
2564 case 0x00:
2565 goto op_semantics_16;
2566 break;
2568 break;
2569 case 0x11:
2570 GETBYTE ();
2571 switch (op[3] & 0x00)
2573 case 0x00:
2574 goto op_semantics_17;
2575 break;
2577 break;
2578 case 0x15:
2579 GETBYTE ();
2580 switch (op[3] & 0x00)
2582 case 0x00:
2583 goto op_semantics_18;
2584 break;
2586 break;
2587 default: UNSUPPORTED(); break;
2589 break;
2590 case 0xa1:
2591 GETBYTE ();
2592 switch (op[2] & 0xff)
2594 case 0x00:
2595 GETBYTE ();
2596 switch (op[3] & 0x00)
2598 case 0x00:
2599 goto op_semantics_7;
2600 break;
2602 break;
2603 case 0x02:
2604 GETBYTE ();
2605 switch (op[3] & 0x00)
2607 case 0x00:
2608 goto op_semantics_19;
2609 break;
2611 break;
2612 case 0x04:
2613 GETBYTE ();
2614 switch (op[3] & 0x00)
2616 case 0x00:
2617 goto op_semantics_8;
2618 break;
2620 break;
2621 case 0x05:
2622 GETBYTE ();
2623 switch (op[3] & 0x00)
2625 case 0x00:
2626 goto op_semantics_9;
2627 break;
2629 break;
2630 case 0x06:
2631 GETBYTE ();
2632 switch (op[3] & 0x00)
2634 case 0x00:
2635 goto op_semantics_10;
2636 break;
2638 break;
2639 case 0x07:
2640 GETBYTE ();
2641 switch (op[3] & 0x00)
2643 case 0x00:
2644 goto op_semantics_11;
2645 break;
2647 break;
2648 case 0x08:
2649 GETBYTE ();
2650 switch (op[3] & 0x00)
2652 case 0x00:
2653 goto op_semantics_12;
2654 break;
2656 break;
2657 case 0x09:
2658 GETBYTE ();
2659 switch (op[3] & 0x00)
2661 case 0x00:
2662 goto op_semantics_13;
2663 break;
2665 break;
2666 case 0x0c:
2667 GETBYTE ();
2668 switch (op[3] & 0x00)
2670 case 0x00:
2671 goto op_semantics_14;
2672 break;
2674 break;
2675 case 0x0d:
2676 GETBYTE ();
2677 switch (op[3] & 0x00)
2679 case 0x00:
2680 goto op_semantics_15;
2681 break;
2683 break;
2684 case 0x10:
2685 GETBYTE ();
2686 switch (op[3] & 0x00)
2688 case 0x00:
2689 goto op_semantics_16;
2690 break;
2692 break;
2693 case 0x11:
2694 GETBYTE ();
2695 switch (op[3] & 0x00)
2697 case 0x00:
2698 goto op_semantics_17;
2699 break;
2701 break;
2702 case 0x15:
2703 GETBYTE ();
2704 switch (op[3] & 0x00)
2706 case 0x00:
2707 goto op_semantics_18;
2708 break;
2710 break;
2711 default: UNSUPPORTED(); break;
2713 break;
2714 case 0xa2:
2715 GETBYTE ();
2716 switch (op[2] & 0xff)
2718 case 0x00:
2719 GETBYTE ();
2720 switch (op[3] & 0x00)
2722 case 0x00:
2723 goto op_semantics_7;
2724 break;
2726 break;
2727 case 0x02:
2728 GETBYTE ();
2729 switch (op[3] & 0x00)
2731 case 0x00:
2732 goto op_semantics_19;
2733 break;
2735 break;
2736 case 0x04:
2737 GETBYTE ();
2738 switch (op[3] & 0x00)
2740 case 0x00:
2741 goto op_semantics_8;
2742 break;
2744 break;
2745 case 0x05:
2746 GETBYTE ();
2747 switch (op[3] & 0x00)
2749 case 0x00:
2750 goto op_semantics_9;
2751 break;
2753 break;
2754 case 0x06:
2755 GETBYTE ();
2756 switch (op[3] & 0x00)
2758 case 0x00:
2759 goto op_semantics_10;
2760 break;
2762 break;
2763 case 0x07:
2764 GETBYTE ();
2765 switch (op[3] & 0x00)
2767 case 0x00:
2768 goto op_semantics_11;
2769 break;
2771 break;
2772 case 0x08:
2773 GETBYTE ();
2774 switch (op[3] & 0x00)
2776 case 0x00:
2777 goto op_semantics_12;
2778 break;
2780 break;
2781 case 0x09:
2782 GETBYTE ();
2783 switch (op[3] & 0x00)
2785 case 0x00:
2786 goto op_semantics_13;
2787 break;
2789 break;
2790 case 0x0c:
2791 GETBYTE ();
2792 switch (op[3] & 0x00)
2794 case 0x00:
2795 goto op_semantics_14;
2796 break;
2798 break;
2799 case 0x0d:
2800 GETBYTE ();
2801 switch (op[3] & 0x00)
2803 case 0x00:
2804 goto op_semantics_15;
2805 break;
2807 break;
2808 case 0x10:
2809 GETBYTE ();
2810 switch (op[3] & 0x00)
2812 case 0x00:
2813 goto op_semantics_16;
2814 break;
2816 break;
2817 case 0x11:
2818 GETBYTE ();
2819 switch (op[3] & 0x00)
2821 case 0x00:
2822 goto op_semantics_17;
2823 break;
2825 break;
2826 case 0x15:
2827 GETBYTE ();
2828 switch (op[3] & 0x00)
2830 case 0x00:
2831 goto op_semantics_18;
2832 break;
2834 break;
2835 default: UNSUPPORTED(); break;
2837 break;
2838 case 0xa3:
2839 GETBYTE ();
2840 switch (op[2] & 0xff)
2842 case 0x00:
2843 GETBYTE ();
2844 switch (op[3] & 0x00)
2846 case 0x00:
2847 goto op_semantics_7;
2848 break;
2850 break;
2851 case 0x02:
2852 GETBYTE ();
2853 switch (op[3] & 0x00)
2855 case 0x00:
2856 goto op_semantics_19;
2857 break;
2859 break;
2860 case 0x04:
2861 GETBYTE ();
2862 switch (op[3] & 0x00)
2864 case 0x00:
2865 goto op_semantics_8;
2866 break;
2868 break;
2869 case 0x05:
2870 GETBYTE ();
2871 switch (op[3] & 0x00)
2873 case 0x00:
2874 goto op_semantics_9;
2875 break;
2877 break;
2878 case 0x06:
2879 GETBYTE ();
2880 switch (op[3] & 0x00)
2882 case 0x00:
2883 goto op_semantics_10;
2884 break;
2886 break;
2887 case 0x07:
2888 GETBYTE ();
2889 switch (op[3] & 0x00)
2891 case 0x00:
2892 goto op_semantics_11;
2893 break;
2895 break;
2896 case 0x08:
2897 GETBYTE ();
2898 switch (op[3] & 0x00)
2900 case 0x00:
2901 goto op_semantics_12;
2902 break;
2904 break;
2905 case 0x09:
2906 GETBYTE ();
2907 switch (op[3] & 0x00)
2909 case 0x00:
2910 goto op_semantics_13;
2911 break;
2913 break;
2914 case 0x0c:
2915 GETBYTE ();
2916 switch (op[3] & 0x00)
2918 case 0x00:
2919 goto op_semantics_14;
2920 break;
2922 break;
2923 case 0x0d:
2924 GETBYTE ();
2925 switch (op[3] & 0x00)
2927 case 0x00:
2928 goto op_semantics_15;
2929 break;
2931 break;
2932 case 0x10:
2933 GETBYTE ();
2934 switch (op[3] & 0x00)
2936 case 0x00:
2937 goto op_semantics_16;
2938 break;
2940 break;
2941 case 0x11:
2942 GETBYTE ();
2943 switch (op[3] & 0x00)
2945 case 0x00:
2946 goto op_semantics_17;
2947 break;
2949 break;
2950 case 0x15:
2951 GETBYTE ();
2952 switch (op[3] & 0x00)
2954 case 0x00:
2955 goto op_semantics_18;
2956 break;
2958 break;
2959 default: UNSUPPORTED(); break;
2961 break;
2962 case 0xc0:
2963 GETBYTE ();
2964 switch (op[2] & 0x00)
2966 case 0x00:
2967 goto op_semantics_1;
2968 break;
2970 break;
2971 case 0xc1:
2972 GETBYTE ();
2973 switch (op[2] & 0x00)
2975 case 0x00:
2976 goto op_semantics_1;
2977 break;
2979 break;
2980 case 0xc2:
2981 GETBYTE ();
2982 switch (op[2] & 0x00)
2984 case 0x00:
2985 goto op_semantics_1;
2986 break;
2988 break;
2989 case 0xc3:
2990 GETBYTE ();
2991 switch (op[2] & 0x00)
2993 case 0x00:
2994 goto op_semantics_1;
2995 break;
2997 break;
2998 case 0xc4:
2999 GETBYTE ();
3000 switch (op[2] & 0x00)
3002 case 0x00:
3003 goto op_semantics_2;
3004 break;
3006 break;
3007 case 0xc5:
3008 GETBYTE ();
3009 switch (op[2] & 0x00)
3011 case 0x00:
3012 goto op_semantics_2;
3013 break;
3015 break;
3016 case 0xc6:
3017 GETBYTE ();
3018 switch (op[2] & 0x00)
3020 case 0x00:
3021 goto op_semantics_2;
3022 break;
3024 break;
3025 case 0xc7:
3026 GETBYTE ();
3027 switch (op[2] & 0x00)
3029 case 0x00:
3030 goto op_semantics_2;
3031 break;
3033 break;
3034 case 0xc8:
3035 GETBYTE ();
3036 switch (op[2] & 0x00)
3038 case 0x00:
3039 goto op_semantics_3;
3040 break;
3042 break;
3043 case 0xc9:
3044 GETBYTE ();
3045 switch (op[2] & 0x00)
3047 case 0x00:
3048 goto op_semantics_3;
3049 break;
3051 break;
3052 case 0xca:
3053 GETBYTE ();
3054 switch (op[2] & 0x00)
3056 case 0x00:
3057 goto op_semantics_3;
3058 break;
3060 break;
3061 case 0xcb:
3062 GETBYTE ();
3063 switch (op[2] & 0x00)
3065 case 0x00:
3066 goto op_semantics_3;
3067 break;
3069 break;
3070 case 0xcc:
3071 GETBYTE ();
3072 switch (op[2] & 0x00)
3074 case 0x00:
3075 goto op_semantics_4;
3076 break;
3078 break;
3079 case 0xcd:
3080 GETBYTE ();
3081 switch (op[2] & 0x00)
3083 case 0x00:
3084 goto op_semantics_4;
3085 break;
3087 break;
3088 case 0xce:
3089 GETBYTE ();
3090 switch (op[2] & 0x00)
3092 case 0x00:
3093 goto op_semantics_4;
3094 break;
3096 break;
3097 case 0xcf:
3098 GETBYTE ();
3099 switch (op[2] & 0x00)
3101 case 0x00:
3102 goto op_semantics_4;
3103 break;
3105 break;
3106 case 0xd0:
3107 GETBYTE ();
3108 switch (op[2] & 0x00)
3110 case 0x00:
3111 goto op_semantics_5;
3112 break;
3114 break;
3115 case 0xd1:
3116 GETBYTE ();
3117 switch (op[2] & 0x00)
3119 case 0x00:
3120 goto op_semantics_5;
3121 break;
3123 break;
3124 case 0xd2:
3125 GETBYTE ();
3126 switch (op[2] & 0x00)
3128 case 0x00:
3129 goto op_semantics_5;
3130 break;
3132 break;
3133 case 0xd3:
3134 GETBYTE ();
3135 switch (op[2] & 0x00)
3137 case 0x00:
3138 goto op_semantics_5;
3139 break;
3141 break;
3142 case 0xd4:
3143 GETBYTE ();
3144 switch (op[2] & 0x00)
3146 case 0x00:
3147 goto op_semantics_6;
3148 break;
3150 break;
3151 case 0xd5:
3152 GETBYTE ();
3153 switch (op[2] & 0x00)
3155 case 0x00:
3156 goto op_semantics_6;
3157 break;
3159 break;
3160 case 0xd6:
3161 GETBYTE ();
3162 switch (op[2] & 0x00)
3164 case 0x00:
3165 goto op_semantics_6;
3166 break;
3168 break;
3169 case 0xd7:
3170 GETBYTE ();
3171 switch (op[2] & 0x00)
3173 case 0x00:
3174 goto op_semantics_6;
3175 break;
3177 break;
3178 case 0xe0:
3179 GETBYTE ();
3180 switch (op[2] & 0xff)
3182 case 0x00:
3183 GETBYTE ();
3184 switch (op[3] & 0x00)
3186 case 0x00:
3187 goto op_semantics_7;
3188 break;
3190 break;
3191 case 0x04:
3192 GETBYTE ();
3193 switch (op[3] & 0x00)
3195 case 0x00:
3196 goto op_semantics_8;
3197 break;
3199 break;
3200 case 0x05:
3201 GETBYTE ();
3202 switch (op[3] & 0x00)
3204 case 0x00:
3205 goto op_semantics_9;
3206 break;
3208 break;
3209 case 0x06:
3210 GETBYTE ();
3211 switch (op[3] & 0x00)
3213 case 0x00:
3214 goto op_semantics_10;
3215 break;
3217 break;
3218 case 0x07:
3219 GETBYTE ();
3220 switch (op[3] & 0x00)
3222 case 0x00:
3223 goto op_semantics_11;
3224 break;
3226 break;
3227 case 0x08:
3228 GETBYTE ();
3229 switch (op[3] & 0x00)
3231 case 0x00:
3232 goto op_semantics_12;
3233 break;
3235 break;
3236 case 0x09:
3237 GETBYTE ();
3238 switch (op[3] & 0x00)
3240 case 0x00:
3241 goto op_semantics_13;
3242 break;
3244 break;
3245 case 0x0c:
3246 GETBYTE ();
3247 switch (op[3] & 0x00)
3249 case 0x00:
3250 goto op_semantics_14;
3251 break;
3253 break;
3254 case 0x0d:
3255 GETBYTE ();
3256 switch (op[3] & 0x00)
3258 case 0x00:
3259 goto op_semantics_15;
3260 break;
3262 break;
3263 case 0x10:
3264 GETBYTE ();
3265 switch (op[3] & 0x00)
3267 case 0x00:
3268 goto op_semantics_16;
3269 break;
3271 break;
3272 case 0x11:
3273 GETBYTE ();
3274 switch (op[3] & 0x00)
3276 case 0x00:
3277 goto op_semantics_17;
3278 break;
3280 break;
3281 case 0x15:
3282 GETBYTE ();
3283 switch (op[3] & 0x00)
3285 case 0x00:
3286 goto op_semantics_18;
3287 break;
3289 break;
3290 default: UNSUPPORTED(); break;
3292 break;
3293 case 0xe1:
3294 GETBYTE ();
3295 switch (op[2] & 0xff)
3297 case 0x00:
3298 GETBYTE ();
3299 switch (op[3] & 0x00)
3301 case 0x00:
3302 goto op_semantics_7;
3303 break;
3305 break;
3306 case 0x04:
3307 GETBYTE ();
3308 switch (op[3] & 0x00)
3310 case 0x00:
3311 goto op_semantics_8;
3312 break;
3314 break;
3315 case 0x05:
3316 GETBYTE ();
3317 switch (op[3] & 0x00)
3319 case 0x00:
3320 goto op_semantics_9;
3321 break;
3323 break;
3324 case 0x06:
3325 GETBYTE ();
3326 switch (op[3] & 0x00)
3328 case 0x00:
3329 goto op_semantics_10;
3330 break;
3332 break;
3333 case 0x07:
3334 GETBYTE ();
3335 switch (op[3] & 0x00)
3337 case 0x00:
3338 goto op_semantics_11;
3339 break;
3341 break;
3342 case 0x08:
3343 GETBYTE ();
3344 switch (op[3] & 0x00)
3346 case 0x00:
3347 goto op_semantics_12;
3348 break;
3350 break;
3351 case 0x09:
3352 GETBYTE ();
3353 switch (op[3] & 0x00)
3355 case 0x00:
3356 goto op_semantics_13;
3357 break;
3359 break;
3360 case 0x0c:
3361 GETBYTE ();
3362 switch (op[3] & 0x00)
3364 case 0x00:
3365 goto op_semantics_14;
3366 break;
3368 break;
3369 case 0x0d:
3370 GETBYTE ();
3371 switch (op[3] & 0x00)
3373 case 0x00:
3374 goto op_semantics_15;
3375 break;
3377 break;
3378 case 0x10:
3379 GETBYTE ();
3380 switch (op[3] & 0x00)
3382 case 0x00:
3383 goto op_semantics_16;
3384 break;
3386 break;
3387 case 0x11:
3388 GETBYTE ();
3389 switch (op[3] & 0x00)
3391 case 0x00:
3392 goto op_semantics_17;
3393 break;
3395 break;
3396 case 0x15:
3397 GETBYTE ();
3398 switch (op[3] & 0x00)
3400 case 0x00:
3401 goto op_semantics_18;
3402 break;
3404 break;
3405 default: UNSUPPORTED(); break;
3407 break;
3408 case 0xe2:
3409 GETBYTE ();
3410 switch (op[2] & 0xff)
3412 case 0x00:
3413 GETBYTE ();
3414 switch (op[3] & 0x00)
3416 case 0x00:
3417 goto op_semantics_7;
3418 break;
3420 break;
3421 case 0x04:
3422 GETBYTE ();
3423 switch (op[3] & 0x00)
3425 case 0x00:
3426 goto op_semantics_8;
3427 break;
3429 break;
3430 case 0x05:
3431 GETBYTE ();
3432 switch (op[3] & 0x00)
3434 case 0x00:
3435 goto op_semantics_9;
3436 break;
3438 break;
3439 case 0x06:
3440 GETBYTE ();
3441 switch (op[3] & 0x00)
3443 case 0x00:
3444 goto op_semantics_10;
3445 break;
3447 break;
3448 case 0x07:
3449 GETBYTE ();
3450 switch (op[3] & 0x00)
3452 case 0x00:
3453 goto op_semantics_11;
3454 break;
3456 break;
3457 case 0x08:
3458 GETBYTE ();
3459 switch (op[3] & 0x00)
3461 case 0x00:
3462 goto op_semantics_12;
3463 break;
3465 break;
3466 case 0x09:
3467 GETBYTE ();
3468 switch (op[3] & 0x00)
3470 case 0x00:
3471 goto op_semantics_13;
3472 break;
3474 break;
3475 case 0x0c:
3476 GETBYTE ();
3477 switch (op[3] & 0x00)
3479 case 0x00:
3480 goto op_semantics_14;
3481 break;
3483 break;
3484 case 0x0d:
3485 GETBYTE ();
3486 switch (op[3] & 0x00)
3488 case 0x00:
3489 goto op_semantics_15;
3490 break;
3492 break;
3493 case 0x10:
3494 GETBYTE ();
3495 switch (op[3] & 0x00)
3497 case 0x00:
3498 goto op_semantics_16;
3499 break;
3501 break;
3502 case 0x11:
3503 GETBYTE ();
3504 switch (op[3] & 0x00)
3506 case 0x00:
3507 goto op_semantics_17;
3508 break;
3510 break;
3511 case 0x15:
3512 GETBYTE ();
3513 switch (op[3] & 0x00)
3515 case 0x00:
3516 goto op_semantics_18;
3517 break;
3519 break;
3520 default: UNSUPPORTED(); break;
3522 break;
3523 case 0xe3:
3524 GETBYTE ();
3525 switch (op[2] & 0xff)
3527 case 0x00:
3528 GETBYTE ();
3529 switch (op[3] & 0x00)
3531 case 0x00:
3532 goto op_semantics_7;
3533 break;
3535 break;
3536 case 0x04:
3537 GETBYTE ();
3538 switch (op[3] & 0x00)
3540 case 0x00:
3541 goto op_semantics_8;
3542 break;
3544 break;
3545 case 0x05:
3546 GETBYTE ();
3547 switch (op[3] & 0x00)
3549 case 0x00:
3550 goto op_semantics_9;
3551 break;
3553 break;
3554 case 0x06:
3555 GETBYTE ();
3556 switch (op[3] & 0x00)
3558 case 0x00:
3559 goto op_semantics_10;
3560 break;
3562 break;
3563 case 0x07:
3564 GETBYTE ();
3565 switch (op[3] & 0x00)
3567 case 0x00:
3568 goto op_semantics_11;
3569 break;
3571 break;
3572 case 0x08:
3573 GETBYTE ();
3574 switch (op[3] & 0x00)
3576 case 0x00:
3577 goto op_semantics_12;
3578 break;
3580 break;
3581 case 0x09:
3582 GETBYTE ();
3583 switch (op[3] & 0x00)
3585 case 0x00:
3586 goto op_semantics_13;
3587 break;
3589 break;
3590 case 0x0c:
3591 GETBYTE ();
3592 switch (op[3] & 0x00)
3594 case 0x00:
3595 goto op_semantics_14;
3596 break;
3598 break;
3599 case 0x0d:
3600 GETBYTE ();
3601 switch (op[3] & 0x00)
3603 case 0x00:
3604 goto op_semantics_15;
3605 break;
3607 break;
3608 case 0x10:
3609 GETBYTE ();
3610 switch (op[3] & 0x00)
3612 case 0x00:
3613 goto op_semantics_16;
3614 break;
3616 break;
3617 case 0x11:
3618 GETBYTE ();
3619 switch (op[3] & 0x00)
3621 case 0x00:
3622 goto op_semantics_17;
3623 break;
3625 break;
3626 case 0x15:
3627 GETBYTE ();
3628 switch (op[3] & 0x00)
3630 case 0x00:
3631 goto op_semantics_18;
3632 break;
3634 break;
3635 default: UNSUPPORTED(); break;
3637 break;
3638 default: UNSUPPORTED(); break;
3640 break;
3641 case 0x08:
3642 case 0x09:
3643 case 0x0a:
3644 case 0x0b:
3645 case 0x0c:
3646 case 0x0d:
3647 case 0x0e:
3648 case 0x0f:
3650 /** 0000 1dsp bra.s %a0 */
3651 #line 775 "rx-decode.opc"
3652 int dsp AU = op[0] & 0x07;
3653 if (trace)
3655 printf ("\033[33m%s\033[0m %02x\n",
3656 "/** 0000 1dsp bra.s %a0 */",
3657 op[0]);
3658 printf (" dsp = 0x%x\n", dsp);
3660 SYNTAX("bra.s %a0");
3661 #line 775 "rx-decode.opc"
3662 ID(branch); DC(pc + dsp3map[dsp]);
3665 break;
3666 case 0x10:
3667 case 0x11:
3668 case 0x12:
3669 case 0x13:
3670 case 0x14:
3671 case 0x15:
3672 case 0x16:
3673 case 0x17:
3674 case 0x18:
3675 case 0x19:
3676 case 0x1a:
3677 case 0x1b:
3678 case 0x1c:
3679 case 0x1d:
3680 case 0x1e:
3681 case 0x1f:
3683 /** 0001 n dsp b%1.s %a0 */
3684 #line 765 "rx-decode.opc"
3685 int n AU = (op[0] >> 3) & 0x01;
3686 #line 765 "rx-decode.opc"
3687 int dsp AU = op[0] & 0x07;
3688 if (trace)
3690 printf ("\033[33m%s\033[0m %02x\n",
3691 "/** 0001 n dsp b%1.s %a0 */",
3692 op[0]);
3693 printf (" n = 0x%x,", n);
3694 printf (" dsp = 0x%x\n", dsp);
3696 SYNTAX("b%1.s %a0");
3697 #line 765 "rx-decode.opc"
3698 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3701 break;
3702 case 0x20:
3703 case 0x21:
3704 case 0x22:
3705 case 0x23:
3706 case 0x24:
3707 case 0x25:
3708 case 0x26:
3709 case 0x27:
3710 case 0x28:
3711 case 0x29:
3712 case 0x2a:
3713 case 0x2b:
3714 case 0x2c:
3715 case 0x2d:
3716 case 0x2f:
3718 /** 0010 cond b%1.b %a0 */
3719 #line 768 "rx-decode.opc"
3720 int cond AU = op[0] & 0x0f;
3721 if (trace)
3723 printf ("\033[33m%s\033[0m %02x\n",
3724 "/** 0010 cond b%1.b %a0 */",
3725 op[0]);
3726 printf (" cond = 0x%x\n", cond);
3728 SYNTAX("b%1.b %a0");
3729 #line 768 "rx-decode.opc"
3730 ID(branch); Scc(cond); DC(pc + IMMex (1));
3733 break;
3734 case 0x2e:
3736 /** 0010 1110 bra.b %a0 */
3737 if (trace)
3739 printf ("\033[33m%s\033[0m %02x\n",
3740 "/** 0010 1110 bra.b %a0 */",
3741 op[0]);
3743 SYNTAX("bra.b %a0");
3744 #line 778 "rx-decode.opc"
3745 ID(branch); DC(pc + IMMex(1));
3748 break;
3749 case 0x38:
3751 /** 0011 1000 bra.w %a0 */
3752 if (trace)
3754 printf ("\033[33m%s\033[0m %02x\n",
3755 "/** 0011 1000 bra.w %a0 */",
3756 op[0]);
3758 SYNTAX("bra.w %a0");
3759 #line 781 "rx-decode.opc"
3760 ID(branch); DC(pc + IMMex(2));
3763 break;
3764 case 0x39:
3766 /** 0011 1001 bsr.w %a0 */
3767 if (trace)
3769 printf ("\033[33m%s\033[0m %02x\n",
3770 "/** 0011 1001 bsr.w %a0 */",
3771 op[0]);
3773 SYNTAX("bsr.w %a0");
3774 #line 797 "rx-decode.opc"
3775 ID(jsr); DC(pc + IMMex(2));
3778 break;
3779 case 0x3a:
3780 case 0x3b:
3782 /** 0011 101c b%1.w %a0 */
3783 #line 771 "rx-decode.opc"
3784 int c AU = op[0] & 0x01;
3785 if (trace)
3787 printf ("\033[33m%s\033[0m %02x\n",
3788 "/** 0011 101c b%1.w %a0 */",
3789 op[0]);
3790 printf (" c = 0x%x\n", c);
3792 SYNTAX("b%1.w %a0");
3793 #line 771 "rx-decode.opc"
3794 ID(branch); Scc(c); DC(pc + IMMex (2));
3798 break;
3799 case 0x3c:
3800 GETBYTE ();
3801 switch (op[1] & 0x00)
3803 case 0x00:
3804 op_semantics_20:
3806 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3807 #line 307 "rx-decode.opc"
3808 int sz AU = op[0] & 0x03;
3809 #line 307 "rx-decode.opc"
3810 int d AU = (op[1] >> 7) & 0x01;
3811 #line 307 "rx-decode.opc"
3812 int dst AU = (op[1] >> 4) & 0x07;
3813 #line 307 "rx-decode.opc"
3814 int sppp AU = op[1] & 0x0f;
3815 if (trace)
3817 printf ("\033[33m%s\033[0m %02x %02x\n",
3818 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3819 op[0], op[1]);
3820 printf (" sz = 0x%x,", sz);
3821 printf (" d = 0x%x,", d);
3822 printf (" dst = 0x%x,", dst);
3823 printf (" sppp = 0x%x\n", sppp);
3825 SYNTAX("mov%s #%1, %0");
3826 #line 307 "rx-decode.opc"
3827 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3830 break;
3832 break;
3833 case 0x3d:
3834 GETBYTE ();
3835 switch (op[1] & 0x00)
3837 case 0x00:
3838 goto op_semantics_20;
3839 break;
3841 break;
3842 case 0x3e:
3843 GETBYTE ();
3844 switch (op[1] & 0x00)
3846 case 0x00:
3847 goto op_semantics_20;
3848 break;
3850 break;
3851 case 0x3f:
3852 GETBYTE ();
3853 switch (op[1] & 0x00)
3855 case 0x00:
3857 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3858 #line 404 "rx-decode.opc"
3859 int rega AU = (op[1] >> 4) & 0x0f;
3860 #line 404 "rx-decode.opc"
3861 int regb AU = op[1] & 0x0f;
3862 if (trace)
3864 printf ("\033[33m%s\033[0m %02x %02x\n",
3865 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3866 op[0], op[1]);
3867 printf (" rega = 0x%x,", rega);
3868 printf (" regb = 0x%x\n", regb);
3870 SYNTAX("rtsd #%1, %2-%0");
3871 #line 404 "rx-decode.opc"
3872 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3874 /*----------------------------------------------------------------------*/
3875 /* AND */
3878 break;
3880 break;
3881 case 0x40:
3882 GETBYTE ();
3883 switch (op[1] & 0x00)
3885 case 0x00:
3886 op_semantics_21:
3888 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3889 #line 539 "rx-decode.opc"
3890 int ss AU = op[0] & 0x03;
3891 #line 539 "rx-decode.opc"
3892 int rsrc AU = (op[1] >> 4) & 0x0f;
3893 #line 539 "rx-decode.opc"
3894 int rdst AU = op[1] & 0x0f;
3895 if (trace)
3897 printf ("\033[33m%s\033[0m %02x %02x\n",
3898 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3899 op[0], op[1]);
3900 printf (" ss = 0x%x,", ss);
3901 printf (" rsrc = 0x%x,", rsrc);
3902 printf (" rdst = 0x%x\n", rdst);
3904 SYNTAX("sub %2%S2, %1");
3905 #line 539 "rx-decode.opc"
3906 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3909 break;
3911 break;
3912 case 0x41:
3913 GETBYTE ();
3914 switch (op[1] & 0x00)
3916 case 0x00:
3917 goto op_semantics_21;
3918 break;
3920 break;
3921 case 0x42:
3922 GETBYTE ();
3923 switch (op[1] & 0x00)
3925 case 0x00:
3926 goto op_semantics_21;
3927 break;
3929 break;
3930 case 0x43:
3931 GETBYTE ();
3932 switch (op[1] & 0x00)
3934 case 0x00:
3935 goto op_semantics_21;
3936 break;
3938 break;
3939 case 0x44:
3940 GETBYTE ();
3941 switch (op[1] & 0x00)
3943 case 0x00:
3944 op_semantics_22:
3946 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3947 #line 527 "rx-decode.opc"
3948 int ss AU = op[0] & 0x03;
3949 #line 527 "rx-decode.opc"
3950 int rsrc AU = (op[1] >> 4) & 0x0f;
3951 #line 527 "rx-decode.opc"
3952 int rdst AU = op[1] & 0x0f;
3953 if (trace)
3955 printf ("\033[33m%s\033[0m %02x %02x\n",
3956 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3957 op[0], op[1]);
3958 printf (" ss = 0x%x,", ss);
3959 printf (" rsrc = 0x%x,", rsrc);
3960 printf (" rdst = 0x%x\n", rdst);
3962 SYNTAX("cmp %2%S2, %1");
3963 #line 527 "rx-decode.opc"
3964 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3967 break;
3969 break;
3970 case 0x45:
3971 GETBYTE ();
3972 switch (op[1] & 0x00)
3974 case 0x00:
3975 goto op_semantics_22;
3976 break;
3978 break;
3979 case 0x46:
3980 GETBYTE ();
3981 switch (op[1] & 0x00)
3983 case 0x00:
3984 goto op_semantics_22;
3985 break;
3987 break;
3988 case 0x47:
3989 GETBYTE ();
3990 switch (op[1] & 0x00)
3992 case 0x00:
3993 goto op_semantics_22;
3994 break;
3996 break;
3997 case 0x48:
3998 GETBYTE ();
3999 switch (op[1] & 0x00)
4001 case 0x00:
4002 op_semantics_23:
4004 /** 0100 10ss rsrc rdst add %1%S1, %0 */
4005 #line 503 "rx-decode.opc"
4006 int ss AU = op[0] & 0x03;
4007 #line 503 "rx-decode.opc"
4008 int rsrc AU = (op[1] >> 4) & 0x0f;
4009 #line 503 "rx-decode.opc"
4010 int rdst AU = op[1] & 0x0f;
4011 if (trace)
4013 printf ("\033[33m%s\033[0m %02x %02x\n",
4014 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4015 op[0], op[1]);
4016 printf (" ss = 0x%x,", ss);
4017 printf (" rsrc = 0x%x,", rsrc);
4018 printf (" rdst = 0x%x\n", rdst);
4020 SYNTAX("add %1%S1, %0");
4021 #line 503 "rx-decode.opc"
4022 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4025 break;
4027 break;
4028 case 0x49:
4029 GETBYTE ();
4030 switch (op[1] & 0x00)
4032 case 0x00:
4033 goto op_semantics_23;
4034 break;
4036 break;
4037 case 0x4a:
4038 GETBYTE ();
4039 switch (op[1] & 0x00)
4041 case 0x00:
4042 goto op_semantics_23;
4043 break;
4045 break;
4046 case 0x4b:
4047 GETBYTE ();
4048 switch (op[1] & 0x00)
4050 case 0x00:
4051 goto op_semantics_23;
4052 break;
4054 break;
4055 case 0x4c:
4056 GETBYTE ();
4057 switch (op[1] & 0x00)
4059 case 0x00:
4060 op_semantics_24:
4062 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
4063 #line 646 "rx-decode.opc"
4064 int ss AU = op[0] & 0x03;
4065 #line 646 "rx-decode.opc"
4066 int rsrc AU = (op[1] >> 4) & 0x0f;
4067 #line 646 "rx-decode.opc"
4068 int rdst AU = op[1] & 0x0f;
4069 if (trace)
4071 printf ("\033[33m%s\033[0m %02x %02x\n",
4072 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4073 op[0], op[1]);
4074 printf (" ss = 0x%x,", ss);
4075 printf (" rsrc = 0x%x,", rsrc);
4076 printf (" rdst = 0x%x\n", rdst);
4078 SYNTAX("mul %1%S1, %0");
4079 #line 646 "rx-decode.opc"
4080 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4083 break;
4085 break;
4086 case 0x4d:
4087 GETBYTE ();
4088 switch (op[1] & 0x00)
4090 case 0x00:
4091 goto op_semantics_24;
4092 break;
4094 break;
4095 case 0x4e:
4096 GETBYTE ();
4097 switch (op[1] & 0x00)
4099 case 0x00:
4100 goto op_semantics_24;
4101 break;
4103 break;
4104 case 0x4f:
4105 GETBYTE ();
4106 switch (op[1] & 0x00)
4108 case 0x00:
4109 goto op_semantics_24;
4110 break;
4112 break;
4113 case 0x50:
4114 GETBYTE ();
4115 switch (op[1] & 0x00)
4117 case 0x00:
4118 op_semantics_25:
4120 /** 0101 00ss rsrc rdst and %1%S1, %0 */
4121 #line 416 "rx-decode.opc"
4122 int ss AU = op[0] & 0x03;
4123 #line 416 "rx-decode.opc"
4124 int rsrc AU = (op[1] >> 4) & 0x0f;
4125 #line 416 "rx-decode.opc"
4126 int rdst AU = op[1] & 0x0f;
4127 if (trace)
4129 printf ("\033[33m%s\033[0m %02x %02x\n",
4130 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4131 op[0], op[1]);
4132 printf (" ss = 0x%x,", ss);
4133 printf (" rsrc = 0x%x,", rsrc);
4134 printf (" rdst = 0x%x\n", rdst);
4136 SYNTAX("and %1%S1, %0");
4137 #line 416 "rx-decode.opc"
4138 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4141 break;
4143 break;
4144 case 0x51:
4145 GETBYTE ();
4146 switch (op[1] & 0x00)
4148 case 0x00:
4149 goto op_semantics_25;
4150 break;
4152 break;
4153 case 0x52:
4154 GETBYTE ();
4155 switch (op[1] & 0x00)
4157 case 0x00:
4158 goto op_semantics_25;
4159 break;
4161 break;
4162 case 0x53:
4163 GETBYTE ();
4164 switch (op[1] & 0x00)
4166 case 0x00:
4167 goto op_semantics_25;
4168 break;
4170 break;
4171 case 0x54:
4172 GETBYTE ();
4173 switch (op[1] & 0x00)
4175 case 0x00:
4176 op_semantics_26:
4178 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4179 #line 434 "rx-decode.opc"
4180 int ss AU = op[0] & 0x03;
4181 #line 434 "rx-decode.opc"
4182 int rsrc AU = (op[1] >> 4) & 0x0f;
4183 #line 434 "rx-decode.opc"
4184 int rdst AU = op[1] & 0x0f;
4185 if (trace)
4187 printf ("\033[33m%s\033[0m %02x %02x\n",
4188 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4189 op[0], op[1]);
4190 printf (" ss = 0x%x,", ss);
4191 printf (" rsrc = 0x%x,", rsrc);
4192 printf (" rdst = 0x%x\n", rdst);
4194 SYNTAX("or %1%S1, %0");
4195 #line 434 "rx-decode.opc"
4196 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4199 break;
4201 break;
4202 case 0x55:
4203 GETBYTE ();
4204 switch (op[1] & 0x00)
4206 case 0x00:
4207 goto op_semantics_26;
4208 break;
4210 break;
4211 case 0x56:
4212 GETBYTE ();
4213 switch (op[1] & 0x00)
4215 case 0x00:
4216 goto op_semantics_26;
4217 break;
4219 break;
4220 case 0x57:
4221 GETBYTE ();
4222 switch (op[1] & 0x00)
4224 case 0x00:
4225 goto op_semantics_26;
4226 break;
4228 break;
4229 case 0x58:
4230 GETBYTE ();
4231 switch (op[1] & 0x00)
4233 case 0x00:
4234 op_semantics_27:
4236 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4237 #line 355 "rx-decode.opc"
4238 int s AU = (op[0] >> 2) & 0x01;
4239 #line 355 "rx-decode.opc"
4240 int ss AU = op[0] & 0x03;
4241 #line 355 "rx-decode.opc"
4242 int rsrc AU = (op[1] >> 4) & 0x0f;
4243 #line 355 "rx-decode.opc"
4244 int rdst AU = op[1] & 0x0f;
4245 if (trace)
4247 printf ("\033[33m%s\033[0m %02x %02x\n",
4248 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4249 op[0], op[1]);
4250 printf (" s = 0x%x,", s);
4251 printf (" ss = 0x%x,", ss);
4252 printf (" rsrc = 0x%x,", rsrc);
4253 printf (" rdst = 0x%x\n", rdst);
4255 SYNTAX("movu%s %1, %0");
4256 #line 355 "rx-decode.opc"
4257 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4260 break;
4262 break;
4263 case 0x59:
4264 GETBYTE ();
4265 switch (op[1] & 0x00)
4267 case 0x00:
4268 goto op_semantics_27;
4269 break;
4271 break;
4272 case 0x5a:
4273 GETBYTE ();
4274 switch (op[1] & 0x00)
4276 case 0x00:
4277 goto op_semantics_27;
4278 break;
4280 break;
4281 case 0x5b:
4282 GETBYTE ();
4283 switch (op[1] & 0x00)
4285 case 0x00:
4286 goto op_semantics_27;
4287 break;
4289 break;
4290 case 0x5c:
4291 GETBYTE ();
4292 switch (op[1] & 0x00)
4294 case 0x00:
4295 goto op_semantics_27;
4296 break;
4298 break;
4299 case 0x5d:
4300 GETBYTE ();
4301 switch (op[1] & 0x00)
4303 case 0x00:
4304 goto op_semantics_27;
4305 break;
4307 break;
4308 case 0x5e:
4309 GETBYTE ();
4310 switch (op[1] & 0x00)
4312 case 0x00:
4313 goto op_semantics_27;
4314 break;
4316 break;
4317 case 0x5f:
4318 GETBYTE ();
4319 switch (op[1] & 0x00)
4321 case 0x00:
4322 goto op_semantics_27;
4323 break;
4325 break;
4326 case 0x60:
4327 GETBYTE ();
4328 switch (op[1] & 0x00)
4330 case 0x00:
4332 /** 0110 0000 immm rdst sub #%2, %0 */
4333 #line 536 "rx-decode.opc"
4334 int immm AU = (op[1] >> 4) & 0x0f;
4335 #line 536 "rx-decode.opc"
4336 int rdst AU = op[1] & 0x0f;
4337 if (trace)
4339 printf ("\033[33m%s\033[0m %02x %02x\n",
4340 "/** 0110 0000 immm rdst sub #%2, %0 */",
4341 op[0], op[1]);
4342 printf (" immm = 0x%x,", immm);
4343 printf (" rdst = 0x%x\n", rdst);
4345 SYNTAX("sub #%2, %0");
4346 #line 536 "rx-decode.opc"
4347 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4350 break;
4352 break;
4353 case 0x61:
4354 GETBYTE ();
4355 switch (op[1] & 0x00)
4357 case 0x00:
4359 /** 0110 0001 immm rdst cmp #%2, %1 */
4360 #line 518 "rx-decode.opc"
4361 int immm AU = (op[1] >> 4) & 0x0f;
4362 #line 518 "rx-decode.opc"
4363 int rdst AU = op[1] & 0x0f;
4364 if (trace)
4366 printf ("\033[33m%s\033[0m %02x %02x\n",
4367 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4368 op[0], op[1]);
4369 printf (" immm = 0x%x,", immm);
4370 printf (" rdst = 0x%x\n", rdst);
4372 SYNTAX("cmp #%2, %1");
4373 #line 518 "rx-decode.opc"
4374 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4377 break;
4379 break;
4380 case 0x62:
4381 GETBYTE ();
4382 switch (op[1] & 0x00)
4384 case 0x00:
4386 /** 0110 0010 immm rdst add #%1, %0 */
4387 #line 500 "rx-decode.opc"
4388 int immm AU = (op[1] >> 4) & 0x0f;
4389 #line 500 "rx-decode.opc"
4390 int rdst AU = op[1] & 0x0f;
4391 if (trace)
4393 printf ("\033[33m%s\033[0m %02x %02x\n",
4394 "/** 0110 0010 immm rdst add #%1, %0 */",
4395 op[0], op[1]);
4396 printf (" immm = 0x%x,", immm);
4397 printf (" rdst = 0x%x\n", rdst);
4399 SYNTAX("add #%1, %0");
4400 #line 500 "rx-decode.opc"
4401 ID(add); SC(immm); DR(rdst); F_OSZC;
4404 break;
4406 break;
4407 case 0x63:
4408 GETBYTE ();
4409 switch (op[1] & 0x00)
4411 case 0x00:
4413 /** 0110 0011 immm rdst mul #%1, %0 */
4414 #line 612 "rx-decode.opc"
4415 int immm AU = (op[1] >> 4) & 0x0f;
4416 #line 612 "rx-decode.opc"
4417 int rdst AU = op[1] & 0x0f;
4418 if (trace)
4420 printf ("\033[33m%s\033[0m %02x %02x\n",
4421 "/** 0110 0011 immm rdst mul #%1, %0 */",
4422 op[0], op[1]);
4423 printf (" immm = 0x%x,", immm);
4424 printf (" rdst = 0x%x\n", rdst);
4426 SYNTAX("mul #%1, %0");
4427 #line 612 "rx-decode.opc"
4428 if (immm == 1 && rdst == 0)
4430 ID(nop2);
4431 SYNTAX ("nop\t; mul\t#1, r0");
4433 else
4435 ID(mul);
4437 DR(rdst); SC(immm); F_____;
4440 break;
4442 break;
4443 case 0x64:
4444 GETBYTE ();
4445 switch (op[1] & 0x00)
4447 case 0x00:
4449 /** 0110 0100 immm rdst and #%1, %0 */
4450 #line 410 "rx-decode.opc"
4451 int immm AU = (op[1] >> 4) & 0x0f;
4452 #line 410 "rx-decode.opc"
4453 int rdst AU = op[1] & 0x0f;
4454 if (trace)
4456 printf ("\033[33m%s\033[0m %02x %02x\n",
4457 "/** 0110 0100 immm rdst and #%1, %0 */",
4458 op[0], op[1]);
4459 printf (" immm = 0x%x,", immm);
4460 printf (" rdst = 0x%x\n", rdst);
4462 SYNTAX("and #%1, %0");
4463 #line 410 "rx-decode.opc"
4464 ID(and); SC(immm); DR(rdst); F__SZ_;
4467 break;
4469 break;
4470 case 0x65:
4471 GETBYTE ();
4472 switch (op[1] & 0x00)
4474 case 0x00:
4476 /** 0110 0101 immm rdst or #%1, %0 */
4477 #line 428 "rx-decode.opc"
4478 int immm AU = (op[1] >> 4) & 0x0f;
4479 #line 428 "rx-decode.opc"
4480 int rdst AU = op[1] & 0x0f;
4481 if (trace)
4483 printf ("\033[33m%s\033[0m %02x %02x\n",
4484 "/** 0110 0101 immm rdst or #%1, %0 */",
4485 op[0], op[1]);
4486 printf (" immm = 0x%x,", immm);
4487 printf (" rdst = 0x%x\n", rdst);
4489 SYNTAX("or #%1, %0");
4490 #line 428 "rx-decode.opc"
4491 ID(or); SC(immm); DR(rdst); F__SZ_;
4494 break;
4496 break;
4497 case 0x66:
4498 GETBYTE ();
4499 switch (op[1] & 0x00)
4501 case 0x00:
4503 /** 0110 0110 immm rdst mov%s #%1, %0 */
4504 #line 304 "rx-decode.opc"
4505 int immm AU = (op[1] >> 4) & 0x0f;
4506 #line 304 "rx-decode.opc"
4507 int rdst AU = op[1] & 0x0f;
4508 if (trace)
4510 printf ("\033[33m%s\033[0m %02x %02x\n",
4511 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4512 op[0], op[1]);
4513 printf (" immm = 0x%x,", immm);
4514 printf (" rdst = 0x%x\n", rdst);
4516 SYNTAX("mov%s #%1, %0");
4517 #line 304 "rx-decode.opc"
4518 ID(mov); DR(rdst); SC(immm); F_____;
4521 break;
4523 break;
4524 case 0x67:
4526 /** 0110 0111 rtsd #%1 */
4527 if (trace)
4529 printf ("\033[33m%s\033[0m %02x\n",
4530 "/** 0110 0111 rtsd #%1 */",
4531 op[0]);
4533 SYNTAX("rtsd #%1");
4534 #line 401 "rx-decode.opc"
4535 ID(rtsd); SC(IMM(1) * 4);
4538 break;
4539 case 0x68:
4540 GETBYTE ();
4541 switch (op[1] & 0x00)
4543 case 0x00:
4544 op_semantics_28:
4546 /** 0110 100i mmmm rdst shlr #%2, %0 */
4547 #line 726 "rx-decode.opc"
4548 int i AU = op[0] & 0x01;
4549 #line 726 "rx-decode.opc"
4550 int mmmm AU = (op[1] >> 4) & 0x0f;
4551 #line 726 "rx-decode.opc"
4552 int rdst AU = op[1] & 0x0f;
4553 if (trace)
4555 printf ("\033[33m%s\033[0m %02x %02x\n",
4556 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4557 op[0], op[1]);
4558 printf (" i = 0x%x,", i);
4559 printf (" mmmm = 0x%x,", mmmm);
4560 printf (" rdst = 0x%x\n", rdst);
4562 SYNTAX("shlr #%2, %0");
4563 #line 726 "rx-decode.opc"
4564 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4567 break;
4569 break;
4570 case 0x69:
4571 GETBYTE ();
4572 switch (op[1] & 0x00)
4574 case 0x00:
4575 goto op_semantics_28;
4576 break;
4578 break;
4579 case 0x6a:
4580 GETBYTE ();
4581 switch (op[1] & 0x00)
4583 case 0x00:
4584 op_semantics_29:
4586 /** 0110 101i mmmm rdst shar #%2, %0 */
4587 #line 716 "rx-decode.opc"
4588 int i AU = op[0] & 0x01;
4589 #line 716 "rx-decode.opc"
4590 int mmmm AU = (op[1] >> 4) & 0x0f;
4591 #line 716 "rx-decode.opc"
4592 int rdst AU = op[1] & 0x0f;
4593 if (trace)
4595 printf ("\033[33m%s\033[0m %02x %02x\n",
4596 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4597 op[0], op[1]);
4598 printf (" i = 0x%x,", i);
4599 printf (" mmmm = 0x%x,", mmmm);
4600 printf (" rdst = 0x%x\n", rdst);
4602 SYNTAX("shar #%2, %0");
4603 #line 716 "rx-decode.opc"
4604 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4607 break;
4609 break;
4610 case 0x6b:
4611 GETBYTE ();
4612 switch (op[1] & 0x00)
4614 case 0x00:
4615 goto op_semantics_29;
4616 break;
4618 break;
4619 case 0x6c:
4620 GETBYTE ();
4621 switch (op[1] & 0x00)
4623 case 0x00:
4624 op_semantics_30:
4626 /** 0110 110i mmmm rdst shll #%2, %0 */
4627 #line 706 "rx-decode.opc"
4628 int i AU = op[0] & 0x01;
4629 #line 706 "rx-decode.opc"
4630 int mmmm AU = (op[1] >> 4) & 0x0f;
4631 #line 706 "rx-decode.opc"
4632 int rdst AU = op[1] & 0x0f;
4633 if (trace)
4635 printf ("\033[33m%s\033[0m %02x %02x\n",
4636 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4637 op[0], op[1]);
4638 printf (" i = 0x%x,", i);
4639 printf (" mmmm = 0x%x,", mmmm);
4640 printf (" rdst = 0x%x\n", rdst);
4642 SYNTAX("shll #%2, %0");
4643 #line 706 "rx-decode.opc"
4644 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4647 break;
4649 break;
4650 case 0x6d:
4651 GETBYTE ();
4652 switch (op[1] & 0x00)
4654 case 0x00:
4655 goto op_semantics_30;
4656 break;
4658 break;
4659 case 0x6e:
4660 GETBYTE ();
4661 switch (op[1] & 0x00)
4663 case 0x00:
4665 /** 0110 1110 dsta dstb pushm %1-%2 */
4666 #line 368 "rx-decode.opc"
4667 int dsta AU = (op[1] >> 4) & 0x0f;
4668 #line 368 "rx-decode.opc"
4669 int dstb AU = op[1] & 0x0f;
4670 if (trace)
4672 printf ("\033[33m%s\033[0m %02x %02x\n",
4673 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4674 op[0], op[1]);
4675 printf (" dsta = 0x%x,", dsta);
4676 printf (" dstb = 0x%x\n", dstb);
4678 SYNTAX("pushm %1-%2");
4679 #line 368 "rx-decode.opc"
4680 ID(pushm); SR(dsta); S2R(dstb); F_____;
4683 break;
4685 break;
4686 case 0x6f:
4687 GETBYTE ();
4688 switch (op[1] & 0x00)
4690 case 0x00:
4692 /** 0110 1111 dsta dstb popm %1-%2 */
4693 #line 365 "rx-decode.opc"
4694 int dsta AU = (op[1] >> 4) & 0x0f;
4695 #line 365 "rx-decode.opc"
4696 int dstb AU = op[1] & 0x0f;
4697 if (trace)
4699 printf ("\033[33m%s\033[0m %02x %02x\n",
4700 "/** 0110 1111 dsta dstb popm %1-%2 */",
4701 op[0], op[1]);
4702 printf (" dsta = 0x%x,", dsta);
4703 printf (" dstb = 0x%x\n", dstb);
4705 SYNTAX("popm %1-%2");
4706 #line 365 "rx-decode.opc"
4707 ID(popm); SR(dsta); S2R(dstb); F_____;
4710 break;
4712 break;
4713 case 0x70:
4714 GETBYTE ();
4715 switch (op[1] & 0x00)
4717 case 0x00:
4718 op_semantics_31:
4720 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4721 #line 509 "rx-decode.opc"
4722 int im AU = op[0] & 0x03;
4723 #line 509 "rx-decode.opc"
4724 int rsrc AU = (op[1] >> 4) & 0x0f;
4725 #line 509 "rx-decode.opc"
4726 int rdst AU = op[1] & 0x0f;
4727 if (trace)
4729 printf ("\033[33m%s\033[0m %02x %02x\n",
4730 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4731 op[0], op[1]);
4732 printf (" im = 0x%x,", im);
4733 printf (" rsrc = 0x%x,", rsrc);
4734 printf (" rdst = 0x%x\n", rdst);
4736 SYNTAX("add #%1, %2, %0");
4737 #line 509 "rx-decode.opc"
4738 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4741 break;
4743 break;
4744 case 0x71:
4745 GETBYTE ();
4746 switch (op[1] & 0x00)
4748 case 0x00:
4749 goto op_semantics_31;
4750 break;
4752 break;
4753 case 0x72:
4754 GETBYTE ();
4755 switch (op[1] & 0x00)
4757 case 0x00:
4758 goto op_semantics_31;
4759 break;
4761 break;
4762 case 0x73:
4763 GETBYTE ();
4764 switch (op[1] & 0x00)
4766 case 0x00:
4767 goto op_semantics_31;
4768 break;
4770 break;
4771 case 0x74:
4772 GETBYTE ();
4773 switch (op[1] & 0xf0)
4775 case 0x00:
4776 op_semantics_32:
4778 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4779 #line 521 "rx-decode.opc"
4780 int im AU = op[0] & 0x03;
4781 #line 521 "rx-decode.opc"
4782 int rsrc AU = op[1] & 0x0f;
4783 if (trace)
4785 printf ("\033[33m%s\033[0m %02x %02x\n",
4786 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4787 op[0], op[1]);
4788 printf (" im = 0x%x,", im);
4789 printf (" rsrc = 0x%x\n", rsrc);
4791 SYNTAX("cmp #%2, %1%S1");
4792 #line 521 "rx-decode.opc"
4793 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4796 break;
4797 case 0x10:
4798 op_semantics_33:
4800 /** 0111 01im 0001rdst mul #%1, %0 */
4801 #line 624 "rx-decode.opc"
4802 int im AU = op[0] & 0x03;
4803 #line 624 "rx-decode.opc"
4804 int rdst AU = op[1] & 0x0f;
4805 if (trace)
4807 printf ("\033[33m%s\033[0m %02x %02x\n",
4808 "/** 0111 01im 0001rdst mul #%1, %0 */",
4809 op[0], op[1]);
4810 printf (" im = 0x%x,", im);
4811 printf (" rdst = 0x%x\n", rdst);
4813 SYNTAX("mul #%1, %0");
4814 #line 624 "rx-decode.opc"
4815 int val = IMMex(im);
4816 if (val == 1 && rdst == 0)
4818 SYNTAX("nop\t; mul\t#1, r0");
4819 switch (im)
4821 case 2: ID(nop4); break;
4822 case 3: ID(nop5); break;
4823 case 0: ID(nop6); break;
4824 default:
4825 ID(mul);
4826 SYNTAX("mul #%1, %0");
4827 break;
4830 else
4832 ID(mul);
4834 DR(rdst); SC(val); F_____;
4837 break;
4838 case 0x20:
4839 op_semantics_34:
4841 /** 0111 01im 0010 rdst and #%1, %0 */
4842 #line 413 "rx-decode.opc"
4843 int im AU = op[0] & 0x03;
4844 #line 413 "rx-decode.opc"
4845 int rdst AU = op[1] & 0x0f;
4846 if (trace)
4848 printf ("\033[33m%s\033[0m %02x %02x\n",
4849 "/** 0111 01im 0010 rdst and #%1, %0 */",
4850 op[0], op[1]);
4851 printf (" im = 0x%x,", im);
4852 printf (" rdst = 0x%x\n", rdst);
4854 SYNTAX("and #%1, %0");
4855 #line 413 "rx-decode.opc"
4856 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4859 break;
4860 case 0x30:
4861 op_semantics_35:
4863 /** 0111 01im 0011 rdst or #%1, %0 */
4864 #line 431 "rx-decode.opc"
4865 int im AU = op[0] & 0x03;
4866 #line 431 "rx-decode.opc"
4867 int rdst AU = op[1] & 0x0f;
4868 if (trace)
4870 printf ("\033[33m%s\033[0m %02x %02x\n",
4871 "/** 0111 01im 0011 rdst or #%1, %0 */",
4872 op[0], op[1]);
4873 printf (" im = 0x%x,", im);
4874 printf (" rdst = 0x%x\n", rdst);
4876 SYNTAX("or #%1, %0");
4877 #line 431 "rx-decode.opc"
4878 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4881 break;
4882 default: UNSUPPORTED(); break;
4884 break;
4885 case 0x75:
4886 GETBYTE ();
4887 switch (op[1] & 0xff)
4889 case 0x00:
4890 case 0x01:
4891 case 0x02:
4892 case 0x03:
4893 case 0x04:
4894 case 0x05:
4895 case 0x06:
4896 case 0x07:
4897 case 0x08:
4898 case 0x09:
4899 case 0x0a:
4900 case 0x0b:
4901 case 0x0c:
4902 case 0x0d:
4903 case 0x0e:
4904 case 0x0f:
4905 goto op_semantics_32;
4906 break;
4907 case 0x10:
4908 case 0x11:
4909 case 0x12:
4910 case 0x13:
4911 case 0x14:
4912 case 0x15:
4913 case 0x16:
4914 case 0x17:
4915 case 0x18:
4916 case 0x19:
4917 case 0x1a:
4918 case 0x1b:
4919 case 0x1c:
4920 case 0x1d:
4921 case 0x1e:
4922 case 0x1f:
4923 goto op_semantics_33;
4924 break;
4925 case 0x20:
4926 case 0x21:
4927 case 0x22:
4928 case 0x23:
4929 case 0x24:
4930 case 0x25:
4931 case 0x26:
4932 case 0x27:
4933 case 0x28:
4934 case 0x29:
4935 case 0x2a:
4936 case 0x2b:
4937 case 0x2c:
4938 case 0x2d:
4939 case 0x2e:
4940 case 0x2f:
4941 goto op_semantics_34;
4942 break;
4943 case 0x30:
4944 case 0x31:
4945 case 0x32:
4946 case 0x33:
4947 case 0x34:
4948 case 0x35:
4949 case 0x36:
4950 case 0x37:
4951 case 0x38:
4952 case 0x39:
4953 case 0x3a:
4954 case 0x3b:
4955 case 0x3c:
4956 case 0x3d:
4957 case 0x3e:
4958 case 0x3f:
4959 goto op_semantics_35;
4960 break;
4961 case 0x40:
4962 case 0x41:
4963 case 0x42:
4964 case 0x43:
4965 case 0x44:
4966 case 0x45:
4967 case 0x46:
4968 case 0x47:
4969 case 0x48:
4970 case 0x49:
4971 case 0x4a:
4972 case 0x4b:
4973 case 0x4c:
4974 case 0x4d:
4975 case 0x4e:
4976 case 0x4f:
4978 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4979 #line 285 "rx-decode.opc"
4980 int rdst AU = op[1] & 0x0f;
4981 if (trace)
4983 printf ("\033[33m%s\033[0m %02x %02x\n",
4984 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4985 op[0], op[1]);
4986 printf (" rdst = 0x%x\n", rdst);
4988 SYNTAX("mov%s #%1, %0");
4989 #line 285 "rx-decode.opc"
4990 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4993 break;
4994 case 0x50:
4995 case 0x51:
4996 case 0x52:
4997 case 0x53:
4998 case 0x54:
4999 case 0x55:
5000 case 0x56:
5001 case 0x57:
5002 case 0x58:
5003 case 0x59:
5004 case 0x5a:
5005 case 0x5b:
5006 case 0x5c:
5007 case 0x5d:
5008 case 0x5e:
5009 case 0x5f:
5011 /** 0111 0101 0101 rsrc cmp #%2, %1 */
5012 #line 524 "rx-decode.opc"
5013 int rsrc AU = op[1] & 0x0f;
5014 if (trace)
5016 printf ("\033[33m%s\033[0m %02x %02x\n",
5017 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5018 op[0], op[1]);
5019 printf (" rsrc = 0x%x\n", rsrc);
5021 SYNTAX("cmp #%2, %1");
5022 #line 524 "rx-decode.opc"
5023 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5026 break;
5027 case 0x60:
5029 /** 0111 0101 0110 0000 int #%1 */
5030 if (trace)
5032 printf ("\033[33m%s\033[0m %02x %02x\n",
5033 "/** 0111 0101 0110 0000 int #%1 */",
5034 op[0], op[1]);
5036 SYNTAX("int #%1");
5037 #line 1031 "rx-decode.opc"
5038 ID(int); SC(IMM(1));
5041 break;
5042 case 0x70:
5043 GETBYTE ();
5044 switch (op[2] & 0xf0)
5046 case 0x00:
5048 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
5049 #line 998 "rx-decode.opc"
5050 int immm AU = op[2] & 0x0f;
5051 if (trace)
5053 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5054 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5055 op[0], op[1], op[2]);
5056 printf (" immm = 0x%x\n", immm);
5058 SYNTAX("mvtipl #%1");
5059 #line 998 "rx-decode.opc"
5060 ID(mvtipl); SC(immm);
5063 break;
5064 default: UNSUPPORTED(); break;
5066 break;
5067 default: UNSUPPORTED(); break;
5069 break;
5070 case 0x76:
5071 GETBYTE ();
5072 switch (op[1] & 0xf0)
5074 case 0x00:
5075 goto op_semantics_32;
5076 break;
5077 case 0x10:
5078 goto op_semantics_33;
5079 break;
5080 case 0x20:
5081 goto op_semantics_34;
5082 break;
5083 case 0x30:
5084 goto op_semantics_35;
5085 break;
5086 default: UNSUPPORTED(); break;
5088 break;
5089 case 0x77:
5090 GETBYTE ();
5091 switch (op[1] & 0xf0)
5093 case 0x00:
5094 goto op_semantics_32;
5095 break;
5096 case 0x10:
5097 goto op_semantics_33;
5098 break;
5099 case 0x20:
5100 goto op_semantics_34;
5101 break;
5102 case 0x30:
5103 goto op_semantics_35;
5104 break;
5105 default: UNSUPPORTED(); break;
5107 break;
5108 case 0x78:
5109 GETBYTE ();
5110 switch (op[1] & 0x00)
5112 case 0x00:
5113 op_semantics_36:
5115 /** 0111 100b ittt rdst bset #%1, %0 */
5116 #line 943 "rx-decode.opc"
5117 int b AU = op[0] & 0x01;
5118 #line 943 "rx-decode.opc"
5119 int ittt AU = (op[1] >> 4) & 0x0f;
5120 #line 943 "rx-decode.opc"
5121 int rdst AU = op[1] & 0x0f;
5122 if (trace)
5124 printf ("\033[33m%s\033[0m %02x %02x\n",
5125 "/** 0111 100b ittt rdst bset #%1, %0 */",
5126 op[0], op[1]);
5127 printf (" b = 0x%x,", b);
5128 printf (" ittt = 0x%x,", ittt);
5129 printf (" rdst = 0x%x\n", rdst);
5131 SYNTAX("bset #%1, %0");
5132 #line 943 "rx-decode.opc"
5133 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5137 break;
5139 break;
5140 case 0x79:
5141 GETBYTE ();
5142 switch (op[1] & 0x00)
5144 case 0x00:
5145 goto op_semantics_36;
5146 break;
5148 break;
5149 case 0x7a:
5150 GETBYTE ();
5151 switch (op[1] & 0x00)
5153 case 0x00:
5154 op_semantics_37:
5156 /** 0111 101b ittt rdst bclr #%1, %0 */
5157 #line 955 "rx-decode.opc"
5158 int b AU = op[0] & 0x01;
5159 #line 955 "rx-decode.opc"
5160 int ittt AU = (op[1] >> 4) & 0x0f;
5161 #line 955 "rx-decode.opc"
5162 int rdst AU = op[1] & 0x0f;
5163 if (trace)
5165 printf ("\033[33m%s\033[0m %02x %02x\n",
5166 "/** 0111 101b ittt rdst bclr #%1, %0 */",
5167 op[0], op[1]);
5168 printf (" b = 0x%x,", b);
5169 printf (" ittt = 0x%x,", ittt);
5170 printf (" rdst = 0x%x\n", rdst);
5172 SYNTAX("bclr #%1, %0");
5173 #line 955 "rx-decode.opc"
5174 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5178 break;
5180 break;
5181 case 0x7b:
5182 GETBYTE ();
5183 switch (op[1] & 0x00)
5185 case 0x00:
5186 goto op_semantics_37;
5187 break;
5189 break;
5190 case 0x7c:
5191 GETBYTE ();
5192 switch (op[1] & 0x00)
5194 case 0x00:
5195 op_semantics_38:
5197 /** 0111 110b ittt rdst btst #%2, %1 */
5198 #line 967 "rx-decode.opc"
5199 int b AU = op[0] & 0x01;
5200 #line 967 "rx-decode.opc"
5201 int ittt AU = (op[1] >> 4) & 0x0f;
5202 #line 967 "rx-decode.opc"
5203 int rdst AU = op[1] & 0x0f;
5204 if (trace)
5206 printf ("\033[33m%s\033[0m %02x %02x\n",
5207 "/** 0111 110b ittt rdst btst #%2, %1 */",
5208 op[0], op[1]);
5209 printf (" b = 0x%x,", b);
5210 printf (" ittt = 0x%x,", ittt);
5211 printf (" rdst = 0x%x\n", rdst);
5213 SYNTAX("btst #%2, %1");
5214 #line 967 "rx-decode.opc"
5215 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5219 break;
5221 break;
5222 case 0x7d:
5223 GETBYTE ();
5224 switch (op[1] & 0x00)
5226 case 0x00:
5227 goto op_semantics_38;
5228 break;
5230 break;
5231 case 0x7e:
5232 GETBYTE ();
5233 switch (op[1] & 0xf0)
5235 case 0x00:
5237 /** 0111 1110 0000 rdst not %0 */
5238 #line 458 "rx-decode.opc"
5239 int rdst AU = op[1] & 0x0f;
5240 if (trace)
5242 printf ("\033[33m%s\033[0m %02x %02x\n",
5243 "/** 0111 1110 0000 rdst not %0 */",
5244 op[0], op[1]);
5245 printf (" rdst = 0x%x\n", rdst);
5247 SYNTAX("not %0");
5248 #line 458 "rx-decode.opc"
5249 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5252 break;
5253 case 0x10:
5255 /** 0111 1110 0001 rdst neg %0 */
5256 #line 479 "rx-decode.opc"
5257 int rdst AU = op[1] & 0x0f;
5258 if (trace)
5260 printf ("\033[33m%s\033[0m %02x %02x\n",
5261 "/** 0111 1110 0001 rdst neg %0 */",
5262 op[0], op[1]);
5263 printf (" rdst = 0x%x\n", rdst);
5265 SYNTAX("neg %0");
5266 #line 479 "rx-decode.opc"
5267 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5270 break;
5271 case 0x20:
5273 /** 0111 1110 0010 rdst abs %0 */
5274 #line 561 "rx-decode.opc"
5275 int rdst AU = op[1] & 0x0f;
5276 if (trace)
5278 printf ("\033[33m%s\033[0m %02x %02x\n",
5279 "/** 0111 1110 0010 rdst abs %0 */",
5280 op[0], op[1]);
5281 printf (" rdst = 0x%x\n", rdst);
5283 SYNTAX("abs %0");
5284 #line 561 "rx-decode.opc"
5285 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5288 break;
5289 case 0x30:
5291 /** 0111 1110 0011 rdst sat %0 */
5292 #line 881 "rx-decode.opc"
5293 int rdst AU = op[1] & 0x0f;
5294 if (trace)
5296 printf ("\033[33m%s\033[0m %02x %02x\n",
5297 "/** 0111 1110 0011 rdst sat %0 */",
5298 op[0], op[1]);
5299 printf (" rdst = 0x%x\n", rdst);
5301 SYNTAX("sat %0");
5302 #line 881 "rx-decode.opc"
5303 ID(sat); DR (rdst);
5306 break;
5307 case 0x40:
5309 /** 0111 1110 0100 rdst rorc %0 */
5310 #line 741 "rx-decode.opc"
5311 int rdst AU = op[1] & 0x0f;
5312 if (trace)
5314 printf ("\033[33m%s\033[0m %02x %02x\n",
5315 "/** 0111 1110 0100 rdst rorc %0 */",
5316 op[0], op[1]);
5317 printf (" rdst = 0x%x\n", rdst);
5319 SYNTAX("rorc %0");
5320 #line 741 "rx-decode.opc"
5321 ID(rorc); DR(rdst); F__SZC;
5324 break;
5325 case 0x50:
5327 /** 0111 1110 0101 rdst rolc %0 */
5328 #line 738 "rx-decode.opc"
5329 int rdst AU = op[1] & 0x0f;
5330 if (trace)
5332 printf ("\033[33m%s\033[0m %02x %02x\n",
5333 "/** 0111 1110 0101 rdst rolc %0 */",
5334 op[0], op[1]);
5335 printf (" rdst = 0x%x\n", rdst);
5337 SYNTAX("rolc %0");
5338 #line 738 "rx-decode.opc"
5339 ID(rolc); DR(rdst); F__SZC;
5342 break;
5343 case 0x80:
5344 case 0x90:
5345 case 0xa0:
5347 /** 0111 1110 10sz rsrc push%s %1 */
5348 #line 374 "rx-decode.opc"
5349 int sz AU = (op[1] >> 4) & 0x03;
5350 #line 374 "rx-decode.opc"
5351 int rsrc AU = op[1] & 0x0f;
5352 if (trace)
5354 printf ("\033[33m%s\033[0m %02x %02x\n",
5355 "/** 0111 1110 10sz rsrc push%s %1 */",
5356 op[0], op[1]);
5357 printf (" sz = 0x%x,", sz);
5358 printf (" rsrc = 0x%x\n", rsrc);
5360 SYNTAX("push%s %1");
5361 #line 374 "rx-decode.opc"
5362 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5365 break;
5366 case 0xb0:
5368 /** 0111 1110 1011 rdst pop %0 */
5369 #line 371 "rx-decode.opc"
5370 int rdst AU = op[1] & 0x0f;
5371 if (trace)
5373 printf ("\033[33m%s\033[0m %02x %02x\n",
5374 "/** 0111 1110 1011 rdst pop %0 */",
5375 op[0], op[1]);
5376 printf (" rdst = 0x%x\n", rdst);
5378 SYNTAX("pop %0");
5379 #line 371 "rx-decode.opc"
5380 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5383 break;
5384 case 0xc0:
5385 case 0xd0:
5387 /** 0111 1110 110 crsrc pushc %1 */
5388 #line 1004 "rx-decode.opc"
5389 int crsrc AU = op[1] & 0x1f;
5390 if (trace)
5392 printf ("\033[33m%s\033[0m %02x %02x\n",
5393 "/** 0111 1110 110 crsrc pushc %1 */",
5394 op[0], op[1]);
5395 printf (" crsrc = 0x%x\n", crsrc);
5397 SYNTAX("pushc %1");
5398 #line 1004 "rx-decode.opc"
5399 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5402 break;
5403 case 0xe0:
5404 case 0xf0:
5406 /** 0111 1110 111 crdst popc %0 */
5407 #line 1001 "rx-decode.opc"
5408 int crdst AU = op[1] & 0x1f;
5409 if (trace)
5411 printf ("\033[33m%s\033[0m %02x %02x\n",
5412 "/** 0111 1110 111 crdst popc %0 */",
5413 op[0], op[1]);
5414 printf (" crdst = 0x%x\n", crdst);
5416 SYNTAX("popc %0");
5417 #line 1001 "rx-decode.opc"
5418 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5421 break;
5422 default: UNSUPPORTED(); break;
5424 break;
5425 case 0x7f:
5426 GETBYTE ();
5427 switch (op[1] & 0xff)
5429 case 0x00:
5430 case 0x01:
5431 case 0x02:
5432 case 0x03:
5433 case 0x04:
5434 case 0x05:
5435 case 0x06:
5436 case 0x07:
5437 case 0x08:
5438 case 0x09:
5439 case 0x0a:
5440 case 0x0b:
5441 case 0x0c:
5442 case 0x0d:
5443 case 0x0e:
5444 case 0x0f:
5446 /** 0111 1111 0000 rsrc jmp %0 */
5447 #line 791 "rx-decode.opc"
5448 int rsrc AU = op[1] & 0x0f;
5449 if (trace)
5451 printf ("\033[33m%s\033[0m %02x %02x\n",
5452 "/** 0111 1111 0000 rsrc jmp %0 */",
5453 op[0], op[1]);
5454 printf (" rsrc = 0x%x\n", rsrc);
5456 SYNTAX("jmp %0");
5457 #line 791 "rx-decode.opc"
5458 ID(branch); DR(rsrc);
5461 break;
5462 case 0x10:
5463 case 0x11:
5464 case 0x12:
5465 case 0x13:
5466 case 0x14:
5467 case 0x15:
5468 case 0x16:
5469 case 0x17:
5470 case 0x18:
5471 case 0x19:
5472 case 0x1a:
5473 case 0x1b:
5474 case 0x1c:
5475 case 0x1d:
5476 case 0x1e:
5477 case 0x1f:
5479 /** 0111 1111 0001 rsrc jsr %0 */
5480 #line 794 "rx-decode.opc"
5481 int rsrc AU = op[1] & 0x0f;
5482 if (trace)
5484 printf ("\033[33m%s\033[0m %02x %02x\n",
5485 "/** 0111 1111 0001 rsrc jsr %0 */",
5486 op[0], op[1]);
5487 printf (" rsrc = 0x%x\n", rsrc);
5489 SYNTAX("jsr %0");
5490 #line 794 "rx-decode.opc"
5491 ID(jsr); DR(rsrc);
5494 break;
5495 case 0x40:
5496 case 0x41:
5497 case 0x42:
5498 case 0x43:
5499 case 0x44:
5500 case 0x45:
5501 case 0x46:
5502 case 0x47:
5503 case 0x48:
5504 case 0x49:
5505 case 0x4a:
5506 case 0x4b:
5507 case 0x4c:
5508 case 0x4d:
5509 case 0x4e:
5510 case 0x4f:
5512 /** 0111 1111 0100 rsrc bra.l %0 */
5513 #line 787 "rx-decode.opc"
5514 int rsrc AU = op[1] & 0x0f;
5515 if (trace)
5517 printf ("\033[33m%s\033[0m %02x %02x\n",
5518 "/** 0111 1111 0100 rsrc bra.l %0 */",
5519 op[0], op[1]);
5520 printf (" rsrc = 0x%x\n", rsrc);
5522 SYNTAX("bra.l %0");
5523 #line 787 "rx-decode.opc"
5524 ID(branchrel); DR(rsrc);
5528 break;
5529 case 0x50:
5530 case 0x51:
5531 case 0x52:
5532 case 0x53:
5533 case 0x54:
5534 case 0x55:
5535 case 0x56:
5536 case 0x57:
5537 case 0x58:
5538 case 0x59:
5539 case 0x5a:
5540 case 0x5b:
5541 case 0x5c:
5542 case 0x5d:
5543 case 0x5e:
5544 case 0x5f:
5546 /** 0111 1111 0101 rsrc bsr.l %0 */
5547 #line 803 "rx-decode.opc"
5548 int rsrc AU = op[1] & 0x0f;
5549 if (trace)
5551 printf ("\033[33m%s\033[0m %02x %02x\n",
5552 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5553 op[0], op[1]);
5554 printf (" rsrc = 0x%x\n", rsrc);
5556 SYNTAX("bsr.l %0");
5557 #line 803 "rx-decode.opc"
5558 ID(jsrrel); DR(rsrc);
5561 break;
5562 case 0x80:
5563 case 0x81:
5564 case 0x82:
5566 /** 0111 1111 1000 00sz suntil%s */
5567 #line 827 "rx-decode.opc"
5568 int sz AU = op[1] & 0x03;
5569 if (trace)
5571 printf ("\033[33m%s\033[0m %02x %02x\n",
5572 "/** 0111 1111 1000 00sz suntil%s */",
5573 op[0], op[1]);
5574 printf (" sz = 0x%x\n", sz);
5576 SYNTAX("suntil%s");
5577 #line 827 "rx-decode.opc"
5578 ID(suntil); BWL(sz); F___ZC;
5581 break;
5582 case 0x83:
5584 /** 0111 1111 1000 0011 scmpu */
5585 if (trace)
5587 printf ("\033[33m%s\033[0m %02x %02x\n",
5588 "/** 0111 1111 1000 0011 scmpu */",
5589 op[0], op[1]);
5591 SYNTAX("scmpu");
5592 #line 818 "rx-decode.opc"
5593 ID(scmpu); F___ZC;
5596 break;
5597 case 0x84:
5598 case 0x85:
5599 case 0x86:
5601 /** 0111 1111 1000 01sz swhile%s */
5602 #line 830 "rx-decode.opc"
5603 int sz AU = op[1] & 0x03;
5604 if (trace)
5606 printf ("\033[33m%s\033[0m %02x %02x\n",
5607 "/** 0111 1111 1000 01sz swhile%s */",
5608 op[0], op[1]);
5609 printf (" sz = 0x%x\n", sz);
5611 SYNTAX("swhile%s");
5612 #line 830 "rx-decode.opc"
5613 ID(swhile); BWL(sz); F___ZC;
5616 break;
5617 case 0x87:
5619 /** 0111 1111 1000 0111 smovu */
5620 if (trace)
5622 printf ("\033[33m%s\033[0m %02x %02x\n",
5623 "/** 0111 1111 1000 0111 smovu */",
5624 op[0], op[1]);
5626 SYNTAX("smovu");
5627 #line 821 "rx-decode.opc"
5628 ID(smovu);
5631 break;
5632 case 0x88:
5633 case 0x89:
5634 case 0x8a:
5636 /** 0111 1111 1000 10sz sstr%s */
5637 #line 836 "rx-decode.opc"
5638 int sz AU = op[1] & 0x03;
5639 if (trace)
5641 printf ("\033[33m%s\033[0m %02x %02x\n",
5642 "/** 0111 1111 1000 10sz sstr%s */",
5643 op[0], op[1]);
5644 printf (" sz = 0x%x\n", sz);
5646 SYNTAX("sstr%s");
5647 #line 836 "rx-decode.opc"
5648 ID(sstr); BWL(sz);
5650 /*----------------------------------------------------------------------*/
5651 /* RMPA */
5654 break;
5655 case 0x8b:
5657 /** 0111 1111 1000 1011 smovb */
5658 if (trace)
5660 printf ("\033[33m%s\033[0m %02x %02x\n",
5661 "/** 0111 1111 1000 1011 smovb */",
5662 op[0], op[1]);
5664 SYNTAX("smovb");
5665 #line 824 "rx-decode.opc"
5666 ID(smovb);
5669 break;
5670 case 0x8c:
5671 case 0x8d:
5672 case 0x8e:
5674 /** 0111 1111 1000 11sz rmpa%s */
5675 #line 842 "rx-decode.opc"
5676 int sz AU = op[1] & 0x03;
5677 if (trace)
5679 printf ("\033[33m%s\033[0m %02x %02x\n",
5680 "/** 0111 1111 1000 11sz rmpa%s */",
5681 op[0], op[1]);
5682 printf (" sz = 0x%x\n", sz);
5684 SYNTAX("rmpa%s");
5685 #line 842 "rx-decode.opc"
5686 ID(rmpa); BWL(sz); F_OS__;
5688 /*----------------------------------------------------------------------*/
5689 /* HI/LO stuff */
5692 break;
5693 case 0x8f:
5695 /** 0111 1111 1000 1111 smovf */
5696 if (trace)
5698 printf ("\033[33m%s\033[0m %02x %02x\n",
5699 "/** 0111 1111 1000 1111 smovf */",
5700 op[0], op[1]);
5702 SYNTAX("smovf");
5703 #line 833 "rx-decode.opc"
5704 ID(smovf);
5707 break;
5708 case 0x93:
5710 /** 0111 1111 1001 0011 satr */
5711 if (trace)
5713 printf ("\033[33m%s\033[0m %02x %02x\n",
5714 "/** 0111 1111 1001 0011 satr */",
5715 op[0], op[1]);
5717 SYNTAX("satr");
5718 #line 884 "rx-decode.opc"
5719 ID(satr);
5721 /*----------------------------------------------------------------------*/
5722 /* FLOAT */
5725 break;
5726 case 0x94:
5728 /** 0111 1111 1001 0100 rtfi */
5729 if (trace)
5731 printf ("\033[33m%s\033[0m %02x %02x\n",
5732 "/** 0111 1111 1001 0100 rtfi */",
5733 op[0], op[1]);
5735 SYNTAX("rtfi");
5736 #line 1019 "rx-decode.opc"
5737 ID(rtfi);
5740 break;
5741 case 0x95:
5743 /** 0111 1111 1001 0101 rte */
5744 if (trace)
5746 printf ("\033[33m%s\033[0m %02x %02x\n",
5747 "/** 0111 1111 1001 0101 rte */",
5748 op[0], op[1]);
5750 SYNTAX("rte");
5751 #line 1022 "rx-decode.opc"
5752 ID(rte);
5755 break;
5756 case 0x96:
5758 /** 0111 1111 1001 0110 wait */
5759 if (trace)
5761 printf ("\033[33m%s\033[0m %02x %02x\n",
5762 "/** 0111 1111 1001 0110 wait */",
5763 op[0], op[1]);
5765 SYNTAX("wait");
5766 #line 1034 "rx-decode.opc"
5767 ID(wait);
5769 /*----------------------------------------------------------------------*/
5770 /* SCcnd */
5773 break;
5774 case 0xa0:
5775 case 0xa1:
5776 case 0xa2:
5777 case 0xa3:
5778 case 0xa4:
5779 case 0xa5:
5780 case 0xa6:
5781 case 0xa7:
5782 case 0xa8:
5783 case 0xa9:
5784 case 0xaa:
5785 case 0xab:
5786 case 0xac:
5787 case 0xad:
5788 case 0xae:
5789 case 0xaf:
5791 /** 0111 1111 1010 rdst setpsw %0 */
5792 #line 995 "rx-decode.opc"
5793 int rdst AU = op[1] & 0x0f;
5794 if (trace)
5796 printf ("\033[33m%s\033[0m %02x %02x\n",
5797 "/** 0111 1111 1010 rdst setpsw %0 */",
5798 op[0], op[1]);
5799 printf (" rdst = 0x%x\n", rdst);
5801 SYNTAX("setpsw %0");
5802 #line 995 "rx-decode.opc"
5803 ID(setpsw); DF(rdst);
5806 break;
5807 case 0xb0:
5808 case 0xb1:
5809 case 0xb2:
5810 case 0xb3:
5811 case 0xb4:
5812 case 0xb5:
5813 case 0xb6:
5814 case 0xb7:
5815 case 0xb8:
5816 case 0xb9:
5817 case 0xba:
5818 case 0xbb:
5819 case 0xbc:
5820 case 0xbd:
5821 case 0xbe:
5822 case 0xbf:
5824 /** 0111 1111 1011 rdst clrpsw %0 */
5825 #line 992 "rx-decode.opc"
5826 int rdst AU = op[1] & 0x0f;
5827 if (trace)
5829 printf ("\033[33m%s\033[0m %02x %02x\n",
5830 "/** 0111 1111 1011 rdst clrpsw %0 */",
5831 op[0], op[1]);
5832 printf (" rdst = 0x%x\n", rdst);
5834 SYNTAX("clrpsw %0");
5835 #line 992 "rx-decode.opc"
5836 ID(clrpsw); DF(rdst);
5839 break;
5840 default: UNSUPPORTED(); break;
5842 break;
5843 case 0x80:
5844 GETBYTE ();
5845 switch (op[1] & 0x00)
5847 case 0x00:
5848 op_semantics_39:
5850 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5851 #line 332 "rx-decode.opc"
5852 int sz AU = (op[0] >> 4) & 0x03;
5853 #line 332 "rx-decode.opc"
5854 int dsp AU = op[0] & 0x07;
5855 #line 332 "rx-decode.opc"
5856 int a AU = (op[1] >> 7) & 0x01;
5857 #line 332 "rx-decode.opc"
5858 int dst AU = (op[1] >> 4) & 0x07;
5859 #line 332 "rx-decode.opc"
5860 int b AU = (op[1] >> 3) & 0x01;
5861 #line 332 "rx-decode.opc"
5862 int src AU = op[1] & 0x07;
5863 if (trace)
5865 printf ("\033[33m%s\033[0m %02x %02x\n",
5866 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5867 op[0], op[1]);
5868 printf (" sz = 0x%x,", sz);
5869 printf (" dsp = 0x%x,", dsp);
5870 printf (" a = 0x%x,", a);
5871 printf (" dst = 0x%x,", dst);
5872 printf (" b = 0x%x,", b);
5873 printf (" src = 0x%x\n", src);
5875 SYNTAX("mov%s %1, %0");
5876 #line 332 "rx-decode.opc"
5877 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5880 break;
5882 break;
5883 case 0x81:
5884 GETBYTE ();
5885 switch (op[1] & 0x00)
5887 case 0x00:
5888 goto op_semantics_39;
5889 break;
5891 break;
5892 case 0x82:
5893 GETBYTE ();
5894 switch (op[1] & 0x00)
5896 case 0x00:
5897 goto op_semantics_39;
5898 break;
5900 break;
5901 case 0x83:
5902 GETBYTE ();
5903 switch (op[1] & 0x00)
5905 case 0x00:
5906 goto op_semantics_39;
5907 break;
5909 break;
5910 case 0x84:
5911 GETBYTE ();
5912 switch (op[1] & 0x00)
5914 case 0x00:
5915 goto op_semantics_39;
5916 break;
5918 break;
5919 case 0x85:
5920 GETBYTE ();
5921 switch (op[1] & 0x00)
5923 case 0x00:
5924 goto op_semantics_39;
5925 break;
5927 break;
5928 case 0x86:
5929 GETBYTE ();
5930 switch (op[1] & 0x00)
5932 case 0x00:
5933 goto op_semantics_39;
5934 break;
5936 break;
5937 case 0x87:
5938 GETBYTE ();
5939 switch (op[1] & 0x00)
5941 case 0x00:
5942 goto op_semantics_39;
5943 break;
5945 break;
5946 case 0x88:
5947 GETBYTE ();
5948 switch (op[1] & 0x00)
5950 case 0x00:
5951 op_semantics_40:
5953 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5954 #line 329 "rx-decode.opc"
5955 int sz AU = (op[0] >> 4) & 0x03;
5956 #line 329 "rx-decode.opc"
5957 int dsp AU = op[0] & 0x07;
5958 #line 329 "rx-decode.opc"
5959 int a AU = (op[1] >> 7) & 0x01;
5960 #line 329 "rx-decode.opc"
5961 int src AU = (op[1] >> 4) & 0x07;
5962 #line 329 "rx-decode.opc"
5963 int b AU = (op[1] >> 3) & 0x01;
5964 #line 329 "rx-decode.opc"
5965 int dst AU = op[1] & 0x07;
5966 if (trace)
5968 printf ("\033[33m%s\033[0m %02x %02x\n",
5969 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5970 op[0], op[1]);
5971 printf (" sz = 0x%x,", sz);
5972 printf (" dsp = 0x%x,", dsp);
5973 printf (" a = 0x%x,", a);
5974 printf (" src = 0x%x,", src);
5975 printf (" b = 0x%x,", b);
5976 printf (" dst = 0x%x\n", dst);
5978 SYNTAX("mov%s %1, %0");
5979 #line 329 "rx-decode.opc"
5980 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5983 break;
5985 break;
5986 case 0x89:
5987 GETBYTE ();
5988 switch (op[1] & 0x00)
5990 case 0x00:
5991 goto op_semantics_40;
5992 break;
5994 break;
5995 case 0x8a:
5996 GETBYTE ();
5997 switch (op[1] & 0x00)
5999 case 0x00:
6000 goto op_semantics_40;
6001 break;
6003 break;
6004 case 0x8b:
6005 GETBYTE ();
6006 switch (op[1] & 0x00)
6008 case 0x00:
6009 goto op_semantics_40;
6010 break;
6012 break;
6013 case 0x8c:
6014 GETBYTE ();
6015 switch (op[1] & 0x00)
6017 case 0x00:
6018 goto op_semantics_40;
6019 break;
6021 break;
6022 case 0x8d:
6023 GETBYTE ();
6024 switch (op[1] & 0x00)
6026 case 0x00:
6027 goto op_semantics_40;
6028 break;
6030 break;
6031 case 0x8e:
6032 GETBYTE ();
6033 switch (op[1] & 0x00)
6035 case 0x00:
6036 goto op_semantics_40;
6037 break;
6039 break;
6040 case 0x8f:
6041 GETBYTE ();
6042 switch (op[1] & 0x00)
6044 case 0x00:
6045 goto op_semantics_40;
6046 break;
6048 break;
6049 case 0x90:
6050 GETBYTE ();
6051 switch (op[1] & 0x00)
6053 case 0x00:
6054 goto op_semantics_39;
6055 break;
6057 break;
6058 case 0x91:
6059 GETBYTE ();
6060 switch (op[1] & 0x00)
6062 case 0x00:
6063 goto op_semantics_39;
6064 break;
6066 break;
6067 case 0x92:
6068 GETBYTE ();
6069 switch (op[1] & 0x00)
6071 case 0x00:
6072 goto op_semantics_39;
6073 break;
6075 break;
6076 case 0x93:
6077 GETBYTE ();
6078 switch (op[1] & 0x00)
6080 case 0x00:
6081 goto op_semantics_39;
6082 break;
6084 break;
6085 case 0x94:
6086 GETBYTE ();
6087 switch (op[1] & 0x00)
6089 case 0x00:
6090 goto op_semantics_39;
6091 break;
6093 break;
6094 case 0x95:
6095 GETBYTE ();
6096 switch (op[1] & 0x00)
6098 case 0x00:
6099 goto op_semantics_39;
6100 break;
6102 break;
6103 case 0x96:
6104 GETBYTE ();
6105 switch (op[1] & 0x00)
6107 case 0x00:
6108 goto op_semantics_39;
6109 break;
6111 break;
6112 case 0x97:
6113 GETBYTE ();
6114 switch (op[1] & 0x00)
6116 case 0x00:
6117 goto op_semantics_39;
6118 break;
6120 break;
6121 case 0x98:
6122 GETBYTE ();
6123 switch (op[1] & 0x00)
6125 case 0x00:
6126 goto op_semantics_40;
6127 break;
6129 break;
6130 case 0x99:
6131 GETBYTE ();
6132 switch (op[1] & 0x00)
6134 case 0x00:
6135 goto op_semantics_40;
6136 break;
6138 break;
6139 case 0x9a:
6140 GETBYTE ();
6141 switch (op[1] & 0x00)
6143 case 0x00:
6144 goto op_semantics_40;
6145 break;
6147 break;
6148 case 0x9b:
6149 GETBYTE ();
6150 switch (op[1] & 0x00)
6152 case 0x00:
6153 goto op_semantics_40;
6154 break;
6156 break;
6157 case 0x9c:
6158 GETBYTE ();
6159 switch (op[1] & 0x00)
6161 case 0x00:
6162 goto op_semantics_40;
6163 break;
6165 break;
6166 case 0x9d:
6167 GETBYTE ();
6168 switch (op[1] & 0x00)
6170 case 0x00:
6171 goto op_semantics_40;
6172 break;
6174 break;
6175 case 0x9e:
6176 GETBYTE ();
6177 switch (op[1] & 0x00)
6179 case 0x00:
6180 goto op_semantics_40;
6181 break;
6183 break;
6184 case 0x9f:
6185 GETBYTE ();
6186 switch (op[1] & 0x00)
6188 case 0x00:
6189 goto op_semantics_40;
6190 break;
6192 break;
6193 case 0xa0:
6194 GETBYTE ();
6195 switch (op[1] & 0x00)
6197 case 0x00:
6198 goto op_semantics_39;
6199 break;
6201 break;
6202 case 0xa1:
6203 GETBYTE ();
6204 switch (op[1] & 0x00)
6206 case 0x00:
6207 goto op_semantics_39;
6208 break;
6210 break;
6211 case 0xa2:
6212 GETBYTE ();
6213 switch (op[1] & 0x00)
6215 case 0x00:
6216 goto op_semantics_39;
6217 break;
6219 break;
6220 case 0xa3:
6221 GETBYTE ();
6222 switch (op[1] & 0x00)
6224 case 0x00:
6225 goto op_semantics_39;
6226 break;
6228 break;
6229 case 0xa4:
6230 GETBYTE ();
6231 switch (op[1] & 0x00)
6233 case 0x00:
6234 goto op_semantics_39;
6235 break;
6237 break;
6238 case 0xa5:
6239 GETBYTE ();
6240 switch (op[1] & 0x00)
6242 case 0x00:
6243 goto op_semantics_39;
6244 break;
6246 break;
6247 case 0xa6:
6248 GETBYTE ();
6249 switch (op[1] & 0x00)
6251 case 0x00:
6252 goto op_semantics_39;
6253 break;
6255 break;
6256 case 0xa7:
6257 GETBYTE ();
6258 switch (op[1] & 0x00)
6260 case 0x00:
6261 goto op_semantics_39;
6262 break;
6264 break;
6265 case 0xa8:
6266 GETBYTE ();
6267 switch (op[1] & 0x00)
6269 case 0x00:
6270 goto op_semantics_40;
6271 break;
6273 break;
6274 case 0xa9:
6275 GETBYTE ();
6276 switch (op[1] & 0x00)
6278 case 0x00:
6279 goto op_semantics_40;
6280 break;
6282 break;
6283 case 0xaa:
6284 GETBYTE ();
6285 switch (op[1] & 0x00)
6287 case 0x00:
6288 goto op_semantics_40;
6289 break;
6291 break;
6292 case 0xab:
6293 GETBYTE ();
6294 switch (op[1] & 0x00)
6296 case 0x00:
6297 goto op_semantics_40;
6298 break;
6300 break;
6301 case 0xac:
6302 GETBYTE ();
6303 switch (op[1] & 0x00)
6305 case 0x00:
6306 goto op_semantics_40;
6307 break;
6309 break;
6310 case 0xad:
6311 GETBYTE ();
6312 switch (op[1] & 0x00)
6314 case 0x00:
6315 goto op_semantics_40;
6316 break;
6318 break;
6319 case 0xae:
6320 GETBYTE ();
6321 switch (op[1] & 0x00)
6323 case 0x00:
6324 goto op_semantics_40;
6325 break;
6327 break;
6328 case 0xaf:
6329 GETBYTE ();
6330 switch (op[1] & 0x00)
6332 case 0x00:
6333 goto op_semantics_40;
6334 break;
6336 break;
6337 case 0xb0:
6338 GETBYTE ();
6339 switch (op[1] & 0x00)
6341 case 0x00:
6342 op_semantics_41:
6344 /** 1011 w dsp a src b dst movu%s %1, %0 */
6345 #line 352 "rx-decode.opc"
6346 int w AU = (op[0] >> 3) & 0x01;
6347 #line 352 "rx-decode.opc"
6348 int dsp AU = op[0] & 0x07;
6349 #line 352 "rx-decode.opc"
6350 int a AU = (op[1] >> 7) & 0x01;
6351 #line 352 "rx-decode.opc"
6352 int src AU = (op[1] >> 4) & 0x07;
6353 #line 352 "rx-decode.opc"
6354 int b AU = (op[1] >> 3) & 0x01;
6355 #line 352 "rx-decode.opc"
6356 int dst AU = op[1] & 0x07;
6357 if (trace)
6359 printf ("\033[33m%s\033[0m %02x %02x\n",
6360 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6361 op[0], op[1]);
6362 printf (" w = 0x%x,", w);
6363 printf (" dsp = 0x%x,", dsp);
6364 printf (" a = 0x%x,", a);
6365 printf (" src = 0x%x,", src);
6366 printf (" b = 0x%x,", b);
6367 printf (" dst = 0x%x\n", dst);
6369 SYNTAX("movu%s %1, %0");
6370 #line 352 "rx-decode.opc"
6371 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6374 break;
6376 break;
6377 case 0xb1:
6378 GETBYTE ();
6379 switch (op[1] & 0x00)
6381 case 0x00:
6382 goto op_semantics_41;
6383 break;
6385 break;
6386 case 0xb2:
6387 GETBYTE ();
6388 switch (op[1] & 0x00)
6390 case 0x00:
6391 goto op_semantics_41;
6392 break;
6394 break;
6395 case 0xb3:
6396 GETBYTE ();
6397 switch (op[1] & 0x00)
6399 case 0x00:
6400 goto op_semantics_41;
6401 break;
6403 break;
6404 case 0xb4:
6405 GETBYTE ();
6406 switch (op[1] & 0x00)
6408 case 0x00:
6409 goto op_semantics_41;
6410 break;
6412 break;
6413 case 0xb5:
6414 GETBYTE ();
6415 switch (op[1] & 0x00)
6417 case 0x00:
6418 goto op_semantics_41;
6419 break;
6421 break;
6422 case 0xb6:
6423 GETBYTE ();
6424 switch (op[1] & 0x00)
6426 case 0x00:
6427 goto op_semantics_41;
6428 break;
6430 break;
6431 case 0xb7:
6432 GETBYTE ();
6433 switch (op[1] & 0x00)
6435 case 0x00:
6436 goto op_semantics_41;
6437 break;
6439 break;
6440 case 0xb8:
6441 GETBYTE ();
6442 switch (op[1] & 0x00)
6444 case 0x00:
6445 goto op_semantics_41;
6446 break;
6448 break;
6449 case 0xb9:
6450 GETBYTE ();
6451 switch (op[1] & 0x00)
6453 case 0x00:
6454 goto op_semantics_41;
6455 break;
6457 break;
6458 case 0xba:
6459 GETBYTE ();
6460 switch (op[1] & 0x00)
6462 case 0x00:
6463 goto op_semantics_41;
6464 break;
6466 break;
6467 case 0xbb:
6468 GETBYTE ();
6469 switch (op[1] & 0x00)
6471 case 0x00:
6472 goto op_semantics_41;
6473 break;
6475 break;
6476 case 0xbc:
6477 GETBYTE ();
6478 switch (op[1] & 0x00)
6480 case 0x00:
6481 goto op_semantics_41;
6482 break;
6484 break;
6485 case 0xbd:
6486 GETBYTE ();
6487 switch (op[1] & 0x00)
6489 case 0x00:
6490 goto op_semantics_41;
6491 break;
6493 break;
6494 case 0xbe:
6495 GETBYTE ();
6496 switch (op[1] & 0x00)
6498 case 0x00:
6499 goto op_semantics_41;
6500 break;
6502 break;
6503 case 0xbf:
6504 GETBYTE ();
6505 switch (op[1] & 0x00)
6507 case 0x00:
6508 goto op_semantics_41;
6509 break;
6511 break;
6512 case 0xc0:
6513 GETBYTE ();
6514 switch (op[1] & 0x00)
6516 case 0x00:
6517 op_semantics_42:
6519 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6520 #line 310 "rx-decode.opc"
6521 int sz AU = (op[0] >> 4) & 0x03;
6522 #line 310 "rx-decode.opc"
6523 int sd AU = (op[0] >> 2) & 0x03;
6524 #line 310 "rx-decode.opc"
6525 int ss AU = op[0] & 0x03;
6526 #line 310 "rx-decode.opc"
6527 int rsrc AU = (op[1] >> 4) & 0x0f;
6528 #line 310 "rx-decode.opc"
6529 int rdst AU = op[1] & 0x0f;
6530 if (trace)
6532 printf ("\033[33m%s\033[0m %02x %02x\n",
6533 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6534 op[0], op[1]);
6535 printf (" sz = 0x%x,", sz);
6536 printf (" sd = 0x%x,", sd);
6537 printf (" ss = 0x%x,", ss);
6538 printf (" rsrc = 0x%x,", rsrc);
6539 printf (" rdst = 0x%x\n", rdst);
6541 SYNTAX("mov%s %1, %0");
6542 #line 310 "rx-decode.opc"
6543 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6545 ID(nop2);
6546 SYNTAX ("nop\t; mov.l\tr0, r0");
6548 else
6550 ID(mov); sBWL(sz); F_____;
6551 if ((ss == 3) && (sd != 3))
6553 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6555 else
6557 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6562 break;
6564 break;
6565 case 0xc1:
6566 GETBYTE ();
6567 switch (op[1] & 0x00)
6569 case 0x00:
6570 goto op_semantics_42;
6571 break;
6573 break;
6574 case 0xc2:
6575 GETBYTE ();
6576 switch (op[1] & 0x00)
6578 case 0x00:
6579 goto op_semantics_42;
6580 break;
6582 break;
6583 case 0xc3:
6584 GETBYTE ();
6585 switch (op[1] & 0x00)
6587 case 0x00:
6588 goto op_semantics_42;
6589 break;
6591 break;
6592 case 0xc4:
6593 GETBYTE ();
6594 switch (op[1] & 0x00)
6596 case 0x00:
6597 goto op_semantics_42;
6598 break;
6600 break;
6601 case 0xc5:
6602 GETBYTE ();
6603 switch (op[1] & 0x00)
6605 case 0x00:
6606 goto op_semantics_42;
6607 break;
6609 break;
6610 case 0xc6:
6611 GETBYTE ();
6612 switch (op[1] & 0x00)
6614 case 0x00:
6615 goto op_semantics_42;
6616 break;
6618 break;
6619 case 0xc7:
6620 GETBYTE ();
6621 switch (op[1] & 0x00)
6623 case 0x00:
6624 goto op_semantics_42;
6625 break;
6627 break;
6628 case 0xc8:
6629 GETBYTE ();
6630 switch (op[1] & 0x00)
6632 case 0x00:
6633 goto op_semantics_42;
6634 break;
6636 break;
6637 case 0xc9:
6638 GETBYTE ();
6639 switch (op[1] & 0x00)
6641 case 0x00:
6642 goto op_semantics_42;
6643 break;
6645 break;
6646 case 0xca:
6647 GETBYTE ();
6648 switch (op[1] & 0x00)
6650 case 0x00:
6651 goto op_semantics_42;
6652 break;
6654 break;
6655 case 0xcb:
6656 GETBYTE ();
6657 switch (op[1] & 0x00)
6659 case 0x00:
6660 goto op_semantics_42;
6661 break;
6663 break;
6664 case 0xcc:
6665 GETBYTE ();
6666 switch (op[1] & 0x00)
6668 case 0x00:
6669 goto op_semantics_42;
6670 break;
6672 break;
6673 case 0xcd:
6674 GETBYTE ();
6675 switch (op[1] & 0x00)
6677 case 0x00:
6678 goto op_semantics_42;
6679 break;
6681 break;
6682 case 0xce:
6683 GETBYTE ();
6684 switch (op[1] & 0x00)
6686 case 0x00:
6687 goto op_semantics_42;
6688 break;
6690 break;
6691 case 0xcf:
6692 GETBYTE ();
6693 switch (op[1] & 0x00)
6695 case 0x00:
6696 goto op_semantics_42;
6697 break;
6699 break;
6700 case 0xd0:
6701 GETBYTE ();
6702 switch (op[1] & 0x00)
6704 case 0x00:
6705 goto op_semantics_42;
6706 break;
6708 break;
6709 case 0xd1:
6710 GETBYTE ();
6711 switch (op[1] & 0x00)
6713 case 0x00:
6714 goto op_semantics_42;
6715 break;
6717 break;
6718 case 0xd2:
6719 GETBYTE ();
6720 switch (op[1] & 0x00)
6722 case 0x00:
6723 goto op_semantics_42;
6724 break;
6726 break;
6727 case 0xd3:
6728 GETBYTE ();
6729 switch (op[1] & 0x00)
6731 case 0x00:
6732 goto op_semantics_42;
6733 break;
6735 break;
6736 case 0xd4:
6737 GETBYTE ();
6738 switch (op[1] & 0x00)
6740 case 0x00:
6741 goto op_semantics_42;
6742 break;
6744 break;
6745 case 0xd5:
6746 GETBYTE ();
6747 switch (op[1] & 0x00)
6749 case 0x00:
6750 goto op_semantics_42;
6751 break;
6753 break;
6754 case 0xd6:
6755 GETBYTE ();
6756 switch (op[1] & 0x00)
6758 case 0x00:
6759 goto op_semantics_42;
6760 break;
6762 break;
6763 case 0xd7:
6764 GETBYTE ();
6765 switch (op[1] & 0x00)
6767 case 0x00:
6768 goto op_semantics_42;
6769 break;
6771 break;
6772 case 0xd8:
6773 GETBYTE ();
6774 switch (op[1] & 0x00)
6776 case 0x00:
6777 goto op_semantics_42;
6778 break;
6780 break;
6781 case 0xd9:
6782 GETBYTE ();
6783 switch (op[1] & 0x00)
6785 case 0x00:
6786 goto op_semantics_42;
6787 break;
6789 break;
6790 case 0xda:
6791 GETBYTE ();
6792 switch (op[1] & 0x00)
6794 case 0x00:
6795 goto op_semantics_42;
6796 break;
6798 break;
6799 case 0xdb:
6800 GETBYTE ();
6801 switch (op[1] & 0x00)
6803 case 0x00:
6804 goto op_semantics_42;
6805 break;
6807 break;
6808 case 0xdc:
6809 GETBYTE ();
6810 switch (op[1] & 0x00)
6812 case 0x00:
6813 goto op_semantics_42;
6814 break;
6816 break;
6817 case 0xdd:
6818 GETBYTE ();
6819 switch (op[1] & 0x00)
6821 case 0x00:
6822 goto op_semantics_42;
6823 break;
6825 break;
6826 case 0xde:
6827 GETBYTE ();
6828 switch (op[1] & 0x00)
6830 case 0x00:
6831 goto op_semantics_42;
6832 break;
6834 break;
6835 case 0xdf:
6836 GETBYTE ();
6837 switch (op[1] & 0x00)
6839 case 0x00:
6840 goto op_semantics_42;
6841 break;
6843 break;
6844 case 0xe0:
6845 GETBYTE ();
6846 switch (op[1] & 0x00)
6848 case 0x00:
6849 goto op_semantics_42;
6850 break;
6852 break;
6853 case 0xe1:
6854 GETBYTE ();
6855 switch (op[1] & 0x00)
6857 case 0x00:
6858 goto op_semantics_42;
6859 break;
6861 break;
6862 case 0xe2:
6863 GETBYTE ();
6864 switch (op[1] & 0x00)
6866 case 0x00:
6867 goto op_semantics_42;
6868 break;
6870 break;
6871 case 0xe3:
6872 GETBYTE ();
6873 switch (op[1] & 0x00)
6875 case 0x00:
6876 goto op_semantics_42;
6877 break;
6879 break;
6880 case 0xe4:
6881 GETBYTE ();
6882 switch (op[1] & 0x00)
6884 case 0x00:
6885 goto op_semantics_42;
6886 break;
6888 break;
6889 case 0xe5:
6890 GETBYTE ();
6891 switch (op[1] & 0x00)
6893 case 0x00:
6894 goto op_semantics_42;
6895 break;
6897 break;
6898 case 0xe6:
6899 GETBYTE ();
6900 switch (op[1] & 0x00)
6902 case 0x00:
6903 goto op_semantics_42;
6904 break;
6906 break;
6907 case 0xe7:
6908 GETBYTE ();
6909 switch (op[1] & 0x00)
6911 case 0x00:
6912 goto op_semantics_42;
6913 break;
6915 break;
6916 case 0xe8:
6917 GETBYTE ();
6918 switch (op[1] & 0x00)
6920 case 0x00:
6921 goto op_semantics_42;
6922 break;
6924 break;
6925 case 0xe9:
6926 GETBYTE ();
6927 switch (op[1] & 0x00)
6929 case 0x00:
6930 goto op_semantics_42;
6931 break;
6933 break;
6934 case 0xea:
6935 GETBYTE ();
6936 switch (op[1] & 0x00)
6938 case 0x00:
6939 goto op_semantics_42;
6940 break;
6942 break;
6943 case 0xeb:
6944 GETBYTE ();
6945 switch (op[1] & 0x00)
6947 case 0x00:
6948 goto op_semantics_42;
6949 break;
6951 break;
6952 case 0xec:
6953 GETBYTE ();
6954 switch (op[1] & 0x00)
6956 case 0x00:
6957 goto op_semantics_42;
6958 break;
6960 break;
6961 case 0xed:
6962 GETBYTE ();
6963 switch (op[1] & 0x00)
6965 case 0x00:
6966 goto op_semantics_42;
6967 break;
6969 break;
6970 case 0xee:
6971 GETBYTE ();
6972 switch (op[1] & 0x00)
6974 case 0x00:
6975 goto op_semantics_42;
6976 break;
6978 break;
6979 case 0xef:
6980 GETBYTE ();
6981 switch (op[1] & 0x00)
6983 case 0x00:
6984 goto op_semantics_42;
6985 break;
6987 break;
6988 case 0xf0:
6989 GETBYTE ();
6990 switch (op[1] & 0x08)
6992 case 0x00:
6993 op_semantics_43:
6995 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
6996 #line 935 "rx-decode.opc"
6997 int sd AU = op[0] & 0x03;
6998 #line 935 "rx-decode.opc"
6999 int rdst AU = (op[1] >> 4) & 0x0f;
7000 #line 935 "rx-decode.opc"
7001 int bit AU = op[1] & 0x07;
7002 if (trace)
7004 printf ("\033[33m%s\033[0m %02x %02x\n",
7005 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
7006 op[0], op[1]);
7007 printf (" sd = 0x%x,", sd);
7008 printf (" rdst = 0x%x,", rdst);
7009 printf (" bit = 0x%x\n", bit);
7011 SYNTAX("bset #%1, %0%S0");
7012 #line 935 "rx-decode.opc"
7013 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7016 break;
7017 case 0x08:
7018 op_semantics_44:
7020 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
7021 #line 947 "rx-decode.opc"
7022 int sd AU = op[0] & 0x03;
7023 #line 947 "rx-decode.opc"
7024 int rdst AU = (op[1] >> 4) & 0x0f;
7025 #line 947 "rx-decode.opc"
7026 int bit AU = op[1] & 0x07;
7027 if (trace)
7029 printf ("\033[33m%s\033[0m %02x %02x\n",
7030 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
7031 op[0], op[1]);
7032 printf (" sd = 0x%x,", sd);
7033 printf (" rdst = 0x%x,", rdst);
7034 printf (" bit = 0x%x\n", bit);
7036 SYNTAX("bclr #%1, %0%S0");
7037 #line 947 "rx-decode.opc"
7038 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7041 break;
7043 break;
7044 case 0xf1:
7045 GETBYTE ();
7046 switch (op[1] & 0x08)
7048 case 0x00:
7049 goto op_semantics_43;
7050 break;
7051 case 0x08:
7052 goto op_semantics_44;
7053 break;
7055 break;
7056 case 0xf2:
7057 GETBYTE ();
7058 switch (op[1] & 0x08)
7060 case 0x00:
7061 goto op_semantics_43;
7062 break;
7063 case 0x08:
7064 goto op_semantics_44;
7065 break;
7067 break;
7068 case 0xf3:
7069 GETBYTE ();
7070 switch (op[1] & 0x08)
7072 case 0x00:
7073 goto op_semantics_43;
7074 break;
7075 case 0x08:
7076 goto op_semantics_44;
7077 break;
7079 break;
7080 case 0xf4:
7081 GETBYTE ();
7082 switch (op[1] & 0x0c)
7084 case 0x00:
7085 case 0x04:
7086 op_semantics_45:
7088 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
7089 #line 959 "rx-decode.opc"
7090 int sd AU = op[0] & 0x03;
7091 #line 959 "rx-decode.opc"
7092 int rdst AU = (op[1] >> 4) & 0x0f;
7093 #line 959 "rx-decode.opc"
7094 int bit AU = op[1] & 0x07;
7095 if (trace)
7097 printf ("\033[33m%s\033[0m %02x %02x\n",
7098 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
7099 op[0], op[1]);
7100 printf (" sd = 0x%x,", sd);
7101 printf (" rdst = 0x%x,", rdst);
7102 printf (" bit = 0x%x\n", bit);
7104 SYNTAX("btst #%2, %1%S1");
7105 #line 959 "rx-decode.opc"
7106 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
7109 break;
7110 case 0x08:
7111 op_semantics_46:
7113 /** 1111 01ss rsrc 10sz push%s %1 */
7114 #line 377 "rx-decode.opc"
7115 int ss AU = op[0] & 0x03;
7116 #line 377 "rx-decode.opc"
7117 int rsrc AU = (op[1] >> 4) & 0x0f;
7118 #line 377 "rx-decode.opc"
7119 int sz AU = op[1] & 0x03;
7120 if (trace)
7122 printf ("\033[33m%s\033[0m %02x %02x\n",
7123 "/** 1111 01ss rsrc 10sz push%s %1 */",
7124 op[0], op[1]);
7125 printf (" ss = 0x%x,", ss);
7126 printf (" rsrc = 0x%x,", rsrc);
7127 printf (" sz = 0x%x\n", sz);
7129 SYNTAX("push%s %1");
7130 #line 377 "rx-decode.opc"
7131 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
7133 /*----------------------------------------------------------------------*/
7134 /* XCHG */
7137 break;
7138 default: UNSUPPORTED(); break;
7140 break;
7141 case 0xf5:
7142 GETBYTE ();
7143 switch (op[1] & 0x0c)
7145 case 0x00:
7146 case 0x04:
7147 goto op_semantics_45;
7148 break;
7149 case 0x08:
7150 goto op_semantics_46;
7151 break;
7152 default: UNSUPPORTED(); break;
7154 break;
7155 case 0xf6:
7156 GETBYTE ();
7157 switch (op[1] & 0x0c)
7159 case 0x00:
7160 case 0x04:
7161 goto op_semantics_45;
7162 break;
7163 case 0x08:
7164 goto op_semantics_46;
7165 break;
7166 default: UNSUPPORTED(); break;
7168 break;
7169 case 0xf7:
7170 GETBYTE ();
7171 switch (op[1] & 0x0c)
7173 case 0x00:
7174 case 0x04:
7175 goto op_semantics_45;
7176 break;
7177 case 0x08:
7178 goto op_semantics_46;
7179 break;
7180 default: UNSUPPORTED(); break;
7182 break;
7183 case 0xf8:
7184 GETBYTE ();
7185 switch (op[1] & 0x00)
7187 case 0x00:
7188 op_semantics_47:
7190 /** 1111 10sd rdst im sz mov%s #%1, %0 */
7191 #line 288 "rx-decode.opc"
7192 int sd AU = op[0] & 0x03;
7193 #line 288 "rx-decode.opc"
7194 int rdst AU = (op[1] >> 4) & 0x0f;
7195 #line 288 "rx-decode.opc"
7196 int im AU = (op[1] >> 2) & 0x03;
7197 #line 288 "rx-decode.opc"
7198 int sz AU = op[1] & 0x03;
7199 if (trace)
7201 printf ("\033[33m%s\033[0m %02x %02x\n",
7202 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
7203 op[0], op[1]);
7204 printf (" sd = 0x%x,", sd);
7205 printf (" rdst = 0x%x,", rdst);
7206 printf (" im = 0x%x,", im);
7207 printf (" sz = 0x%x\n", sz);
7209 SYNTAX("mov%s #%1, %0");
7210 #line 288 "rx-decode.opc"
7211 ID(mov); DD(sd, rdst, sz);
7212 if ((im == 1 && sz == 0)
7213 || (im == 2 && sz == 1)
7214 || (im == 0 && sz == 2))
7216 BWL (sz);
7217 SC(IMM(im));
7219 else
7221 sBWL (sz);
7222 SC(IMMex(im));
7224 F_____;
7227 break;
7229 break;
7230 case 0xf9:
7231 GETBYTE ();
7232 switch (op[1] & 0x00)
7234 case 0x00:
7235 goto op_semantics_47;
7236 break;
7238 break;
7239 case 0xfa:
7240 GETBYTE ();
7241 switch (op[1] & 0x00)
7243 case 0x00:
7244 goto op_semantics_47;
7245 break;
7247 break;
7248 case 0xfb:
7249 GETBYTE ();
7250 switch (op[1] & 0x00)
7252 case 0x00:
7253 goto op_semantics_47;
7254 break;
7256 break;
7257 case 0xfc:
7258 GETBYTE ();
7259 switch (op[1] & 0xff)
7261 case 0x03:
7262 GETBYTE ();
7263 switch (op[2] & 0x00)
7265 case 0x00:
7267 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7268 #line 551 "rx-decode.opc"
7269 int rsrc AU = (op[2] >> 4) & 0x0f;
7270 #line 551 "rx-decode.opc"
7271 int rdst AU = op[2] & 0x0f;
7272 if (trace)
7274 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7275 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7276 op[0], op[1], op[2]);
7277 printf (" rsrc = 0x%x,", rsrc);
7278 printf (" rdst = 0x%x\n", rdst);
7280 SYNTAX("sbb %1, %0");
7281 #line 551 "rx-decode.opc"
7282 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7284 /* FIXME: only supports .L */
7286 break;
7288 break;
7289 case 0x07:
7290 GETBYTE ();
7291 switch (op[2] & 0x00)
7293 case 0x00:
7295 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7296 #line 482 "rx-decode.opc"
7297 int rsrc AU = (op[2] >> 4) & 0x0f;
7298 #line 482 "rx-decode.opc"
7299 int rdst AU = op[2] & 0x0f;
7300 if (trace)
7302 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7303 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7304 op[0], op[1], op[2]);
7305 printf (" rsrc = 0x%x,", rsrc);
7306 printf (" rdst = 0x%x\n", rdst);
7308 SYNTAX("neg %2, %0");
7309 #line 482 "rx-decode.opc"
7310 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7312 /*----------------------------------------------------------------------*/
7313 /* ADC */
7316 break;
7318 break;
7319 case 0x0b:
7320 GETBYTE ();
7321 switch (op[2] & 0x00)
7323 case 0x00:
7325 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7326 #line 491 "rx-decode.opc"
7327 int rsrc AU = (op[2] >> 4) & 0x0f;
7328 #line 491 "rx-decode.opc"
7329 int rdst AU = op[2] & 0x0f;
7330 if (trace)
7332 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7333 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7334 op[0], op[1], op[2]);
7335 printf (" rsrc = 0x%x,", rsrc);
7336 printf (" rdst = 0x%x\n", rdst);
7338 SYNTAX("adc %1, %0");
7339 #line 491 "rx-decode.opc"
7340 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7343 break;
7345 break;
7346 case 0x0f:
7347 GETBYTE ();
7348 switch (op[2] & 0x00)
7350 case 0x00:
7352 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7353 #line 564 "rx-decode.opc"
7354 int rsrc AU = (op[2] >> 4) & 0x0f;
7355 #line 564 "rx-decode.opc"
7356 int rdst AU = op[2] & 0x0f;
7357 if (trace)
7359 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7360 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7361 op[0], op[1], op[2]);
7362 printf (" rsrc = 0x%x,", rsrc);
7363 printf (" rdst = 0x%x\n", rdst);
7365 SYNTAX("abs %1, %0");
7366 #line 564 "rx-decode.opc"
7367 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7369 /*----------------------------------------------------------------------*/
7370 /* MAX */
7373 break;
7375 break;
7376 case 0x10:
7377 GETBYTE ();
7378 switch (op[2] & 0x00)
7380 case 0x00:
7381 op_semantics_48:
7383 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7384 #line 583 "rx-decode.opc"
7385 int ss AU = op[1] & 0x03;
7386 #line 583 "rx-decode.opc"
7387 int rsrc AU = (op[2] >> 4) & 0x0f;
7388 #line 583 "rx-decode.opc"
7389 int rdst AU = op[2] & 0x0f;
7390 if (trace)
7392 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7393 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7394 op[0], op[1], op[2]);
7395 printf (" ss = 0x%x,", ss);
7396 printf (" rsrc = 0x%x,", rsrc);
7397 printf (" rdst = 0x%x\n", rdst);
7399 SYNTAX("max %1%S1, %0");
7400 #line 583 "rx-decode.opc"
7401 if (ss == 3 && rsrc == 0 && rdst == 0)
7403 ID(nop3);
7404 SYNTAX("nop\t; max\tr0, r0");
7406 else
7408 ID(max); SP(ss, rsrc); DR(rdst);
7412 break;
7414 break;
7415 case 0x11:
7416 GETBYTE ();
7417 switch (op[2] & 0x00)
7419 case 0x00:
7420 goto op_semantics_48;
7421 break;
7423 break;
7424 case 0x12:
7425 GETBYTE ();
7426 switch (op[2] & 0x00)
7428 case 0x00:
7429 goto op_semantics_48;
7430 break;
7432 break;
7433 case 0x13:
7434 GETBYTE ();
7435 switch (op[2] & 0x00)
7437 case 0x00:
7438 goto op_semantics_48;
7439 break;
7441 break;
7442 case 0x14:
7443 GETBYTE ();
7444 switch (op[2] & 0x00)
7446 case 0x00:
7447 op_semantics_49:
7449 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7450 #line 603 "rx-decode.opc"
7451 int ss AU = op[1] & 0x03;
7452 #line 603 "rx-decode.opc"
7453 int rsrc AU = (op[2] >> 4) & 0x0f;
7454 #line 603 "rx-decode.opc"
7455 int rdst AU = op[2] & 0x0f;
7456 if (trace)
7458 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7459 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7460 op[0], op[1], op[2]);
7461 printf (" ss = 0x%x,", ss);
7462 printf (" rsrc = 0x%x,", rsrc);
7463 printf (" rdst = 0x%x\n", rdst);
7465 SYNTAX("min %1%S1, %0");
7466 #line 603 "rx-decode.opc"
7467 ID(min); SP(ss, rsrc); DR(rdst);
7470 break;
7472 break;
7473 case 0x15:
7474 GETBYTE ();
7475 switch (op[2] & 0x00)
7477 case 0x00:
7478 goto op_semantics_49;
7479 break;
7481 break;
7482 case 0x16:
7483 GETBYTE ();
7484 switch (op[2] & 0x00)
7486 case 0x00:
7487 goto op_semantics_49;
7488 break;
7490 break;
7491 case 0x17:
7492 GETBYTE ();
7493 switch (op[2] & 0x00)
7495 case 0x00:
7496 goto op_semantics_49;
7497 break;
7499 break;
7500 case 0x18:
7501 GETBYTE ();
7502 switch (op[2] & 0x00)
7504 case 0x00:
7505 op_semantics_50:
7507 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7508 #line 661 "rx-decode.opc"
7509 int ss AU = op[1] & 0x03;
7510 #line 661 "rx-decode.opc"
7511 int rsrc AU = (op[2] >> 4) & 0x0f;
7512 #line 661 "rx-decode.opc"
7513 int rdst AU = op[2] & 0x0f;
7514 if (trace)
7516 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7517 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7518 op[0], op[1], op[2]);
7519 printf (" ss = 0x%x,", ss);
7520 printf (" rsrc = 0x%x,", rsrc);
7521 printf (" rdst = 0x%x\n", rdst);
7523 SYNTAX("emul %1%S1, %0");
7524 #line 661 "rx-decode.opc"
7525 ID(emul); SP(ss, rsrc); DR(rdst);
7528 break;
7530 break;
7531 case 0x19:
7532 GETBYTE ();
7533 switch (op[2] & 0x00)
7535 case 0x00:
7536 goto op_semantics_50;
7537 break;
7539 break;
7540 case 0x1a:
7541 GETBYTE ();
7542 switch (op[2] & 0x00)
7544 case 0x00:
7545 goto op_semantics_50;
7546 break;
7548 break;
7549 case 0x1b:
7550 GETBYTE ();
7551 switch (op[2] & 0x00)
7553 case 0x00:
7554 goto op_semantics_50;
7555 break;
7557 break;
7558 case 0x1c:
7559 GETBYTE ();
7560 switch (op[2] & 0x00)
7562 case 0x00:
7563 op_semantics_51:
7565 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7566 #line 673 "rx-decode.opc"
7567 int ss AU = op[1] & 0x03;
7568 #line 673 "rx-decode.opc"
7569 int rsrc AU = (op[2] >> 4) & 0x0f;
7570 #line 673 "rx-decode.opc"
7571 int rdst AU = op[2] & 0x0f;
7572 if (trace)
7574 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7575 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7576 op[0], op[1], op[2]);
7577 printf (" ss = 0x%x,", ss);
7578 printf (" rsrc = 0x%x,", rsrc);
7579 printf (" rdst = 0x%x\n", rdst);
7581 SYNTAX("emulu %1%S1, %0");
7582 #line 673 "rx-decode.opc"
7583 ID(emulu); SP(ss, rsrc); DR(rdst);
7586 break;
7588 break;
7589 case 0x1d:
7590 GETBYTE ();
7591 switch (op[2] & 0x00)
7593 case 0x00:
7594 goto op_semantics_51;
7595 break;
7597 break;
7598 case 0x1e:
7599 GETBYTE ();
7600 switch (op[2] & 0x00)
7602 case 0x00:
7603 goto op_semantics_51;
7604 break;
7606 break;
7607 case 0x1f:
7608 GETBYTE ();
7609 switch (op[2] & 0x00)
7611 case 0x00:
7612 goto op_semantics_51;
7613 break;
7615 break;
7616 case 0x20:
7617 GETBYTE ();
7618 switch (op[2] & 0x00)
7620 case 0x00:
7621 op_semantics_52:
7623 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7624 #line 685 "rx-decode.opc"
7625 int ss AU = op[1] & 0x03;
7626 #line 685 "rx-decode.opc"
7627 int rsrc AU = (op[2] >> 4) & 0x0f;
7628 #line 685 "rx-decode.opc"
7629 int rdst AU = op[2] & 0x0f;
7630 if (trace)
7632 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7633 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7634 op[0], op[1], op[2]);
7635 printf (" ss = 0x%x,", ss);
7636 printf (" rsrc = 0x%x,", rsrc);
7637 printf (" rdst = 0x%x\n", rdst);
7639 SYNTAX("div %1%S1, %0");
7640 #line 685 "rx-decode.opc"
7641 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7644 break;
7646 break;
7647 case 0x21:
7648 GETBYTE ();
7649 switch (op[2] & 0x00)
7651 case 0x00:
7652 goto op_semantics_52;
7653 break;
7655 break;
7656 case 0x22:
7657 GETBYTE ();
7658 switch (op[2] & 0x00)
7660 case 0x00:
7661 goto op_semantics_52;
7662 break;
7664 break;
7665 case 0x23:
7666 GETBYTE ();
7667 switch (op[2] & 0x00)
7669 case 0x00:
7670 goto op_semantics_52;
7671 break;
7673 break;
7674 case 0x24:
7675 GETBYTE ();
7676 switch (op[2] & 0x00)
7678 case 0x00:
7679 op_semantics_53:
7681 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7682 #line 697 "rx-decode.opc"
7683 int ss AU = op[1] & 0x03;
7684 #line 697 "rx-decode.opc"
7685 int rsrc AU = (op[2] >> 4) & 0x0f;
7686 #line 697 "rx-decode.opc"
7687 int rdst AU = op[2] & 0x0f;
7688 if (trace)
7690 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7691 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7692 op[0], op[1], op[2]);
7693 printf (" ss = 0x%x,", ss);
7694 printf (" rsrc = 0x%x,", rsrc);
7695 printf (" rdst = 0x%x\n", rdst);
7697 SYNTAX("divu %1%S1, %0");
7698 #line 697 "rx-decode.opc"
7699 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7702 break;
7704 break;
7705 case 0x25:
7706 GETBYTE ();
7707 switch (op[2] & 0x00)
7709 case 0x00:
7710 goto op_semantics_53;
7711 break;
7713 break;
7714 case 0x26:
7715 GETBYTE ();
7716 switch (op[2] & 0x00)
7718 case 0x00:
7719 goto op_semantics_53;
7720 break;
7722 break;
7723 case 0x27:
7724 GETBYTE ();
7725 switch (op[2] & 0x00)
7727 case 0x00:
7728 goto op_semantics_53;
7729 break;
7731 break;
7732 case 0x30:
7733 GETBYTE ();
7734 switch (op[2] & 0x00)
7736 case 0x00:
7737 op_semantics_54:
7739 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7740 #line 470 "rx-decode.opc"
7741 int ss AU = op[1] & 0x03;
7742 #line 470 "rx-decode.opc"
7743 int rsrc AU = (op[2] >> 4) & 0x0f;
7744 #line 470 "rx-decode.opc"
7745 int rdst AU = op[2] & 0x0f;
7746 if (trace)
7748 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7749 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7750 op[0], op[1], op[2]);
7751 printf (" ss = 0x%x,", ss);
7752 printf (" rsrc = 0x%x,", rsrc);
7753 printf (" rdst = 0x%x\n", rdst);
7755 SYNTAX("tst %1%S1, %2");
7756 #line 470 "rx-decode.opc"
7757 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7760 break;
7762 break;
7763 case 0x31:
7764 GETBYTE ();
7765 switch (op[2] & 0x00)
7767 case 0x00:
7768 goto op_semantics_54;
7769 break;
7771 break;
7772 case 0x32:
7773 GETBYTE ();
7774 switch (op[2] & 0x00)
7776 case 0x00:
7777 goto op_semantics_54;
7778 break;
7780 break;
7781 case 0x33:
7782 GETBYTE ();
7783 switch (op[2] & 0x00)
7785 case 0x00:
7786 goto op_semantics_54;
7787 break;
7789 break;
7790 case 0x34:
7791 GETBYTE ();
7792 switch (op[2] & 0x00)
7794 case 0x00:
7795 op_semantics_55:
7797 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7798 #line 449 "rx-decode.opc"
7799 int ss AU = op[1] & 0x03;
7800 #line 449 "rx-decode.opc"
7801 int rsrc AU = (op[2] >> 4) & 0x0f;
7802 #line 449 "rx-decode.opc"
7803 int rdst AU = op[2] & 0x0f;
7804 if (trace)
7806 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7807 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7808 op[0], op[1], op[2]);
7809 printf (" ss = 0x%x,", ss);
7810 printf (" rsrc = 0x%x,", rsrc);
7811 printf (" rdst = 0x%x\n", rdst);
7813 SYNTAX("xor %1%S1, %0");
7814 #line 449 "rx-decode.opc"
7815 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7818 break;
7820 break;
7821 case 0x35:
7822 GETBYTE ();
7823 switch (op[2] & 0x00)
7825 case 0x00:
7826 goto op_semantics_55;
7827 break;
7829 break;
7830 case 0x36:
7831 GETBYTE ();
7832 switch (op[2] & 0x00)
7834 case 0x00:
7835 goto op_semantics_55;
7836 break;
7838 break;
7839 case 0x37:
7840 GETBYTE ();
7841 switch (op[2] & 0x00)
7843 case 0x00:
7844 goto op_semantics_55;
7845 break;
7847 break;
7848 case 0x3b:
7849 GETBYTE ();
7850 switch (op[2] & 0x00)
7852 case 0x00:
7854 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7855 #line 461 "rx-decode.opc"
7856 int rsrc AU = (op[2] >> 4) & 0x0f;
7857 #line 461 "rx-decode.opc"
7858 int rdst AU = op[2] & 0x0f;
7859 if (trace)
7861 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7862 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7863 op[0], op[1], op[2]);
7864 printf (" rsrc = 0x%x,", rsrc);
7865 printf (" rdst = 0x%x\n", rdst);
7867 SYNTAX("not %1, %0");
7868 #line 461 "rx-decode.opc"
7869 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7871 /*----------------------------------------------------------------------*/
7872 /* TST */
7875 break;
7877 break;
7878 case 0x40:
7879 GETBYTE ();
7880 switch (op[2] & 0x00)
7882 case 0x00:
7883 op_semantics_56:
7885 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7886 #line 383 "rx-decode.opc"
7887 int ss AU = op[1] & 0x03;
7888 #line 383 "rx-decode.opc"
7889 int rsrc AU = (op[2] >> 4) & 0x0f;
7890 #line 383 "rx-decode.opc"
7891 int rdst AU = op[2] & 0x0f;
7892 if (trace)
7894 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7895 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7896 op[0], op[1], op[2]);
7897 printf (" ss = 0x%x,", ss);
7898 printf (" rsrc = 0x%x,", rsrc);
7899 printf (" rdst = 0x%x\n", rdst);
7901 SYNTAX("xchg %1%S1, %0");
7902 #line 383 "rx-decode.opc"
7903 ID(xchg); DR(rdst); SP(ss, rsrc);
7906 break;
7908 break;
7909 case 0x41:
7910 GETBYTE ();
7911 switch (op[2] & 0x00)
7913 case 0x00:
7914 goto op_semantics_56;
7915 break;
7917 break;
7918 case 0x42:
7919 GETBYTE ();
7920 switch (op[2] & 0x00)
7922 case 0x00:
7923 goto op_semantics_56;
7924 break;
7926 break;
7927 case 0x43:
7928 GETBYTE ();
7929 switch (op[2] & 0x00)
7931 case 0x00:
7932 goto op_semantics_56;
7933 break;
7935 break;
7936 case 0x44:
7937 GETBYTE ();
7938 switch (op[2] & 0x00)
7940 case 0x00:
7941 op_semantics_57:
7943 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7944 #line 926 "rx-decode.opc"
7945 int sd AU = op[1] & 0x03;
7946 #line 926 "rx-decode.opc"
7947 int rsrc AU = (op[2] >> 4) & 0x0f;
7948 #line 926 "rx-decode.opc"
7949 int rdst AU = op[2] & 0x0f;
7950 if (trace)
7952 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7953 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7954 op[0], op[1], op[2]);
7955 printf (" sd = 0x%x,", sd);
7956 printf (" rsrc = 0x%x,", rsrc);
7957 printf (" rdst = 0x%x\n", rdst);
7959 SYNTAX("itof %1%S1, %0");
7960 #line 926 "rx-decode.opc"
7961 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7964 break;
7966 break;
7967 case 0x45:
7968 GETBYTE ();
7969 switch (op[2] & 0x00)
7971 case 0x00:
7972 goto op_semantics_57;
7973 break;
7975 break;
7976 case 0x46:
7977 GETBYTE ();
7978 switch (op[2] & 0x00)
7980 case 0x00:
7981 goto op_semantics_57;
7982 break;
7984 break;
7985 case 0x47:
7986 GETBYTE ();
7987 switch (op[2] & 0x00)
7989 case 0x00:
7990 goto op_semantics_57;
7991 break;
7993 break;
7994 case 0x4b:
7995 GETBYTE ();
7996 switch (op[2] & 0x00)
7998 case 0x00:
8000 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
8001 #line 1052 "rx-decode.opc"
8002 int rsrc AU = (op[2] >> 4) & 0x0f;
8003 #line 1052 "rx-decode.opc"
8004 int rdst AU = op[2] & 0x0f;
8005 if (trace)
8007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8008 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
8009 op[0], op[1], op[2]);
8010 printf (" rsrc = 0x%x,", rsrc);
8011 printf (" rdst = 0x%x\n", rdst);
8013 SYNTAX("stz %1, %0");
8014 #line 1052 "rx-decode.opc"
8015 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
8018 break;
8020 break;
8021 case 0x4f:
8022 GETBYTE ();
8023 switch (op[2] & 0x00)
8025 case 0x00:
8027 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
8028 #line 1055 "rx-decode.opc"
8029 int rsrc AU = (op[2] >> 4) & 0x0f;
8030 #line 1055 "rx-decode.opc"
8031 int rdst AU = op[2] & 0x0f;
8032 if (trace)
8034 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8035 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
8036 op[0], op[1], op[2]);
8037 printf (" rsrc = 0x%x,", rsrc);
8038 printf (" rdst = 0x%x\n", rdst);
8040 SYNTAX("stnz %1, %0");
8041 #line 1055 "rx-decode.opc"
8042 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
8045 break;
8047 break;
8048 case 0x54:
8049 GETBYTE ();
8050 switch (op[2] & 0x00)
8052 case 0x00:
8053 op_semantics_58:
8055 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
8056 #line 1112 "rx-decode.opc"
8057 int sd AU = op[1] & 0x03;
8058 #line 1112 "rx-decode.opc"
8059 int rsrc AU = (op[2] >> 4) & 0x0f;
8060 #line 1112 "rx-decode.opc"
8061 int rdst AU = op[2] & 0x0f;
8062 if (trace)
8064 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8065 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
8066 op[0], op[1], op[2]);
8067 printf (" sd = 0x%x,", sd);
8068 printf (" rsrc = 0x%x,", rsrc);
8069 printf (" rdst = 0x%x\n", rdst);
8071 SYNTAX("utof %1%S1, %0");
8072 #line 1112 "rx-decode.opc"
8073 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
8076 break;
8078 break;
8079 case 0x55:
8080 GETBYTE ();
8081 switch (op[2] & 0x00)
8083 case 0x00:
8084 goto op_semantics_58;
8085 break;
8087 break;
8088 case 0x56:
8089 GETBYTE ();
8090 switch (op[2] & 0x00)
8092 case 0x00:
8093 goto op_semantics_58;
8094 break;
8096 break;
8097 case 0x57:
8098 GETBYTE ();
8099 switch (op[2] & 0x00)
8101 case 0x00:
8102 goto op_semantics_58;
8103 break;
8105 break;
8106 case 0x60:
8107 GETBYTE ();
8108 switch (op[2] & 0x00)
8110 case 0x00:
8111 op_semantics_59:
8113 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
8114 #line 938 "rx-decode.opc"
8115 int sd AU = op[1] & 0x03;
8116 #line 938 "rx-decode.opc"
8117 int rdst AU = (op[2] >> 4) & 0x0f;
8118 #line 938 "rx-decode.opc"
8119 int rsrc AU = op[2] & 0x0f;
8120 if (trace)
8122 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8123 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
8124 op[0], op[1], op[2]);
8125 printf (" sd = 0x%x,", sd);
8126 printf (" rdst = 0x%x,", rdst);
8127 printf (" rsrc = 0x%x\n", rsrc);
8129 SYNTAX("bset %1, %0%S0");
8130 #line 938 "rx-decode.opc"
8131 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8132 if (sd == 3) /* bset reg,reg */
8133 BWL(LSIZE);
8136 break;
8138 break;
8139 case 0x61:
8140 GETBYTE ();
8141 switch (op[2] & 0x00)
8143 case 0x00:
8144 goto op_semantics_59;
8145 break;
8147 break;
8148 case 0x62:
8149 GETBYTE ();
8150 switch (op[2] & 0x00)
8152 case 0x00:
8153 goto op_semantics_59;
8154 break;
8156 break;
8157 case 0x63:
8158 GETBYTE ();
8159 switch (op[2] & 0x00)
8161 case 0x00:
8162 goto op_semantics_59;
8163 break;
8165 break;
8166 case 0x64:
8167 GETBYTE ();
8168 switch (op[2] & 0x00)
8170 case 0x00:
8171 op_semantics_60:
8173 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
8174 #line 950 "rx-decode.opc"
8175 int sd AU = op[1] & 0x03;
8176 #line 950 "rx-decode.opc"
8177 int rdst AU = (op[2] >> 4) & 0x0f;
8178 #line 950 "rx-decode.opc"
8179 int rsrc AU = op[2] & 0x0f;
8180 if (trace)
8182 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8183 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
8184 op[0], op[1], op[2]);
8185 printf (" sd = 0x%x,", sd);
8186 printf (" rdst = 0x%x,", rdst);
8187 printf (" rsrc = 0x%x\n", rsrc);
8189 SYNTAX("bclr %1, %0%S0");
8190 #line 950 "rx-decode.opc"
8191 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8192 if (sd == 3) /* bset reg,reg */
8193 BWL(LSIZE);
8196 break;
8198 break;
8199 case 0x65:
8200 GETBYTE ();
8201 switch (op[2] & 0x00)
8203 case 0x00:
8204 goto op_semantics_60;
8205 break;
8207 break;
8208 case 0x66:
8209 GETBYTE ();
8210 switch (op[2] & 0x00)
8212 case 0x00:
8213 goto op_semantics_60;
8214 break;
8216 break;
8217 case 0x67:
8218 GETBYTE ();
8219 switch (op[2] & 0x00)
8221 case 0x00:
8222 goto op_semantics_60;
8223 break;
8225 break;
8226 case 0x68:
8227 GETBYTE ();
8228 switch (op[2] & 0x00)
8230 case 0x00:
8231 op_semantics_61:
8233 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
8234 #line 962 "rx-decode.opc"
8235 int sd AU = op[1] & 0x03;
8236 #line 962 "rx-decode.opc"
8237 int rdst AU = (op[2] >> 4) & 0x0f;
8238 #line 962 "rx-decode.opc"
8239 int rsrc AU = op[2] & 0x0f;
8240 if (trace)
8242 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8243 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
8244 op[0], op[1], op[2]);
8245 printf (" sd = 0x%x,", sd);
8246 printf (" rdst = 0x%x,", rdst);
8247 printf (" rsrc = 0x%x\n", rsrc);
8249 SYNTAX("btst %2, %1%S1");
8250 #line 962 "rx-decode.opc"
8251 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8252 if (sd == 3) /* bset reg,reg */
8253 BWL(LSIZE);
8256 break;
8258 break;
8259 case 0x69:
8260 GETBYTE ();
8261 switch (op[2] & 0x00)
8263 case 0x00:
8264 goto op_semantics_61;
8265 break;
8267 break;
8268 case 0x6a:
8269 GETBYTE ();
8270 switch (op[2] & 0x00)
8272 case 0x00:
8273 goto op_semantics_61;
8274 break;
8276 break;
8277 case 0x6b:
8278 GETBYTE ();
8279 switch (op[2] & 0x00)
8281 case 0x00:
8282 goto op_semantics_61;
8283 break;
8285 break;
8286 case 0x6c:
8287 GETBYTE ();
8288 switch (op[2] & 0x00)
8290 case 0x00:
8291 op_semantics_62:
8293 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
8294 #line 974 "rx-decode.opc"
8295 int sd AU = op[1] & 0x03;
8296 #line 974 "rx-decode.opc"
8297 int rdst AU = (op[2] >> 4) & 0x0f;
8298 #line 974 "rx-decode.opc"
8299 int rsrc AU = op[2] & 0x0f;
8300 if (trace)
8302 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8303 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
8304 op[0], op[1], op[2]);
8305 printf (" sd = 0x%x,", sd);
8306 printf (" rdst = 0x%x,", rdst);
8307 printf (" rsrc = 0x%x\n", rsrc);
8309 SYNTAX("bnot %1, %0%S0");
8310 #line 974 "rx-decode.opc"
8311 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8312 if (sd == 3) /* bset reg,reg */
8313 BWL(LSIZE);
8316 break;
8318 break;
8319 case 0x6d:
8320 GETBYTE ();
8321 switch (op[2] & 0x00)
8323 case 0x00:
8324 goto op_semantics_62;
8325 break;
8327 break;
8328 case 0x6e:
8329 GETBYTE ();
8330 switch (op[2] & 0x00)
8332 case 0x00:
8333 goto op_semantics_62;
8334 break;
8336 break;
8337 case 0x6f:
8338 GETBYTE ();
8339 switch (op[2] & 0x00)
8341 case 0x00:
8342 goto op_semantics_62;
8343 break;
8345 break;
8346 case 0x80:
8347 GETBYTE ();
8348 switch (op[2] & 0x00)
8350 case 0x00:
8351 op_semantics_63:
8353 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8354 #line 905 "rx-decode.opc"
8355 int sd AU = op[1] & 0x03;
8356 #line 905 "rx-decode.opc"
8357 int rsrc AU = (op[2] >> 4) & 0x0f;
8358 #line 905 "rx-decode.opc"
8359 int rdst AU = op[2] & 0x0f;
8360 if (trace)
8362 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8363 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8364 op[0], op[1], op[2]);
8365 printf (" sd = 0x%x,", sd);
8366 printf (" rsrc = 0x%x,", rsrc);
8367 printf (" rdst = 0x%x\n", rdst);
8369 SYNTAX("fsub %1%S1, %0");
8370 #line 905 "rx-decode.opc"
8371 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8374 break;
8376 break;
8377 case 0x81:
8378 GETBYTE ();
8379 switch (op[2] & 0x00)
8381 case 0x00:
8382 goto op_semantics_63;
8383 break;
8385 break;
8386 case 0x82:
8387 GETBYTE ();
8388 switch (op[2] & 0x00)
8390 case 0x00:
8391 goto op_semantics_63;
8392 break;
8394 break;
8395 case 0x83:
8396 GETBYTE ();
8397 switch (op[2] & 0x00)
8399 case 0x00:
8400 goto op_semantics_63;
8401 break;
8403 break;
8404 case 0x84:
8405 GETBYTE ();
8406 switch (op[2] & 0x00)
8408 case 0x00:
8409 op_semantics_64:
8411 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8412 #line 899 "rx-decode.opc"
8413 int sd AU = op[1] & 0x03;
8414 #line 899 "rx-decode.opc"
8415 int rsrc AU = (op[2] >> 4) & 0x0f;
8416 #line 899 "rx-decode.opc"
8417 int rdst AU = op[2] & 0x0f;
8418 if (trace)
8420 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8421 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8422 op[0], op[1], op[2]);
8423 printf (" sd = 0x%x,", sd);
8424 printf (" rsrc = 0x%x,", rsrc);
8425 printf (" rdst = 0x%x\n", rdst);
8427 SYNTAX("fcmp %1%S1, %0");
8428 #line 899 "rx-decode.opc"
8429 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8432 break;
8434 break;
8435 case 0x85:
8436 GETBYTE ();
8437 switch (op[2] & 0x00)
8439 case 0x00:
8440 goto op_semantics_64;
8441 break;
8443 break;
8444 case 0x86:
8445 GETBYTE ();
8446 switch (op[2] & 0x00)
8448 case 0x00:
8449 goto op_semantics_64;
8450 break;
8452 break;
8453 case 0x87:
8454 GETBYTE ();
8455 switch (op[2] & 0x00)
8457 case 0x00:
8458 goto op_semantics_64;
8459 break;
8461 break;
8462 case 0x88:
8463 GETBYTE ();
8464 switch (op[2] & 0x00)
8466 case 0x00:
8467 op_semantics_65:
8469 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8470 #line 893 "rx-decode.opc"
8471 int sd AU = op[1] & 0x03;
8472 #line 893 "rx-decode.opc"
8473 int rsrc AU = (op[2] >> 4) & 0x0f;
8474 #line 893 "rx-decode.opc"
8475 int rdst AU = op[2] & 0x0f;
8476 if (trace)
8478 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8479 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8480 op[0], op[1], op[2]);
8481 printf (" sd = 0x%x,", sd);
8482 printf (" rsrc = 0x%x,", rsrc);
8483 printf (" rdst = 0x%x\n", rdst);
8485 SYNTAX("fadd %1%S1, %0");
8486 #line 893 "rx-decode.opc"
8487 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8490 break;
8492 break;
8493 case 0x89:
8494 GETBYTE ();
8495 switch (op[2] & 0x00)
8497 case 0x00:
8498 goto op_semantics_65;
8499 break;
8501 break;
8502 case 0x8a:
8503 GETBYTE ();
8504 switch (op[2] & 0x00)
8506 case 0x00:
8507 goto op_semantics_65;
8508 break;
8510 break;
8511 case 0x8b:
8512 GETBYTE ();
8513 switch (op[2] & 0x00)
8515 case 0x00:
8516 goto op_semantics_65;
8517 break;
8519 break;
8520 case 0x8c:
8521 GETBYTE ();
8522 switch (op[2] & 0x00)
8524 case 0x00:
8525 op_semantics_66:
8527 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8528 #line 914 "rx-decode.opc"
8529 int sd AU = op[1] & 0x03;
8530 #line 914 "rx-decode.opc"
8531 int rsrc AU = (op[2] >> 4) & 0x0f;
8532 #line 914 "rx-decode.opc"
8533 int rdst AU = op[2] & 0x0f;
8534 if (trace)
8536 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8537 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8538 op[0], op[1], op[2]);
8539 printf (" sd = 0x%x,", sd);
8540 printf (" rsrc = 0x%x,", rsrc);
8541 printf (" rdst = 0x%x\n", rdst);
8543 SYNTAX("fmul %1%S1, %0");
8544 #line 914 "rx-decode.opc"
8545 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8548 break;
8550 break;
8551 case 0x8d:
8552 GETBYTE ();
8553 switch (op[2] & 0x00)
8555 case 0x00:
8556 goto op_semantics_66;
8557 break;
8559 break;
8560 case 0x8e:
8561 GETBYTE ();
8562 switch (op[2] & 0x00)
8564 case 0x00:
8565 goto op_semantics_66;
8566 break;
8568 break;
8569 case 0x8f:
8570 GETBYTE ();
8571 switch (op[2] & 0x00)
8573 case 0x00:
8574 goto op_semantics_66;
8575 break;
8577 break;
8578 case 0x90:
8579 GETBYTE ();
8580 switch (op[2] & 0x00)
8582 case 0x00:
8583 op_semantics_67:
8585 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8586 #line 920 "rx-decode.opc"
8587 int sd AU = op[1] & 0x03;
8588 #line 920 "rx-decode.opc"
8589 int rsrc AU = (op[2] >> 4) & 0x0f;
8590 #line 920 "rx-decode.opc"
8591 int rdst AU = op[2] & 0x0f;
8592 if (trace)
8594 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8595 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8596 op[0], op[1], op[2]);
8597 printf (" sd = 0x%x,", sd);
8598 printf (" rsrc = 0x%x,", rsrc);
8599 printf (" rdst = 0x%x\n", rdst);
8601 SYNTAX("fdiv %1%S1, %0");
8602 #line 920 "rx-decode.opc"
8603 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8606 break;
8608 break;
8609 case 0x91:
8610 GETBYTE ();
8611 switch (op[2] & 0x00)
8613 case 0x00:
8614 goto op_semantics_67;
8615 break;
8617 break;
8618 case 0x92:
8619 GETBYTE ();
8620 switch (op[2] & 0x00)
8622 case 0x00:
8623 goto op_semantics_67;
8624 break;
8626 break;
8627 case 0x93:
8628 GETBYTE ();
8629 switch (op[2] & 0x00)
8631 case 0x00:
8632 goto op_semantics_67;
8633 break;
8635 break;
8636 case 0x94:
8637 GETBYTE ();
8638 switch (op[2] & 0x00)
8640 case 0x00:
8641 op_semantics_68:
8643 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8644 #line 908 "rx-decode.opc"
8645 int sd AU = op[1] & 0x03;
8646 #line 908 "rx-decode.opc"
8647 int rsrc AU = (op[2] >> 4) & 0x0f;
8648 #line 908 "rx-decode.opc"
8649 int rdst AU = op[2] & 0x0f;
8650 if (trace)
8652 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8653 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8654 op[0], op[1], op[2]);
8655 printf (" sd = 0x%x,", sd);
8656 printf (" rsrc = 0x%x,", rsrc);
8657 printf (" rdst = 0x%x\n", rdst);
8659 SYNTAX("ftoi %1%S1, %0");
8660 #line 908 "rx-decode.opc"
8661 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8664 break;
8666 break;
8667 case 0x95:
8668 GETBYTE ();
8669 switch (op[2] & 0x00)
8671 case 0x00:
8672 goto op_semantics_68;
8673 break;
8675 break;
8676 case 0x96:
8677 GETBYTE ();
8678 switch (op[2] & 0x00)
8680 case 0x00:
8681 goto op_semantics_68;
8682 break;
8684 break;
8685 case 0x97:
8686 GETBYTE ();
8687 switch (op[2] & 0x00)
8689 case 0x00:
8690 goto op_semantics_68;
8691 break;
8693 break;
8694 case 0x98:
8695 GETBYTE ();
8696 switch (op[2] & 0x00)
8698 case 0x00:
8699 op_semantics_69:
8701 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8702 #line 923 "rx-decode.opc"
8703 int sd AU = op[1] & 0x03;
8704 #line 923 "rx-decode.opc"
8705 int rsrc AU = (op[2] >> 4) & 0x0f;
8706 #line 923 "rx-decode.opc"
8707 int rdst AU = op[2] & 0x0f;
8708 if (trace)
8710 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8711 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8712 op[0], op[1], op[2]);
8713 printf (" sd = 0x%x,", sd);
8714 printf (" rsrc = 0x%x,", rsrc);
8715 printf (" rdst = 0x%x\n", rdst);
8717 SYNTAX("round %1%S1, %0");
8718 #line 923 "rx-decode.opc"
8719 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8722 break;
8724 break;
8725 case 0x99:
8726 GETBYTE ();
8727 switch (op[2] & 0x00)
8729 case 0x00:
8730 goto op_semantics_69;
8731 break;
8733 break;
8734 case 0x9a:
8735 GETBYTE ();
8736 switch (op[2] & 0x00)
8738 case 0x00:
8739 goto op_semantics_69;
8740 break;
8742 break;
8743 case 0x9b:
8744 GETBYTE ();
8745 switch (op[2] & 0x00)
8747 case 0x00:
8748 goto op_semantics_69;
8749 break;
8751 break;
8752 case 0xa0:
8753 GETBYTE ();
8754 switch (op[2] & 0x00)
8756 case 0x00:
8757 op_semantics_70:
8759 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
8760 #line 1106 "rx-decode.opc"
8761 int sd AU = op[1] & 0x03;
8762 #line 1106 "rx-decode.opc"
8763 int rsrc AU = (op[2] >> 4) & 0x0f;
8764 #line 1106 "rx-decode.opc"
8765 int rdst AU = op[2] & 0x0f;
8766 if (trace)
8768 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8769 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
8770 op[0], op[1], op[2]);
8771 printf (" sd = 0x%x,", sd);
8772 printf (" rsrc = 0x%x,", rsrc);
8773 printf (" rdst = 0x%x\n", rdst);
8775 SYNTAX("fsqrt %1%S1, %0");
8776 #line 1106 "rx-decode.opc"
8777 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8780 break;
8782 break;
8783 case 0xa1:
8784 GETBYTE ();
8785 switch (op[2] & 0x00)
8787 case 0x00:
8788 goto op_semantics_70;
8789 break;
8791 break;
8792 case 0xa2:
8793 GETBYTE ();
8794 switch (op[2] & 0x00)
8796 case 0x00:
8797 goto op_semantics_70;
8798 break;
8800 break;
8801 case 0xa3:
8802 GETBYTE ();
8803 switch (op[2] & 0x00)
8805 case 0x00:
8806 goto op_semantics_70;
8807 break;
8809 break;
8810 case 0xa4:
8811 GETBYTE ();
8812 switch (op[2] & 0x00)
8814 case 0x00:
8815 op_semantics_71:
8817 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
8818 #line 1109 "rx-decode.opc"
8819 int sd AU = op[1] & 0x03;
8820 #line 1109 "rx-decode.opc"
8821 int rsrc AU = (op[2] >> 4) & 0x0f;
8822 #line 1109 "rx-decode.opc"
8823 int rdst AU = op[2] & 0x0f;
8824 if (trace)
8826 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8827 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
8828 op[0], op[1], op[2]);
8829 printf (" sd = 0x%x,", sd);
8830 printf (" rsrc = 0x%x,", rsrc);
8831 printf (" rdst = 0x%x\n", rdst);
8833 SYNTAX("ftou %1%S1, %0");
8834 #line 1109 "rx-decode.opc"
8835 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8838 break;
8840 break;
8841 case 0xa5:
8842 GETBYTE ();
8843 switch (op[2] & 0x00)
8845 case 0x00:
8846 goto op_semantics_71;
8847 break;
8849 break;
8850 case 0xa6:
8851 GETBYTE ();
8852 switch (op[2] & 0x00)
8854 case 0x00:
8855 goto op_semantics_71;
8856 break;
8858 break;
8859 case 0xa7:
8860 GETBYTE ();
8861 switch (op[2] & 0x00)
8863 case 0x00:
8864 goto op_semantics_71;
8865 break;
8867 break;
8868 case 0xd0:
8869 GETBYTE ();
8870 switch (op[2] & 0x00)
8872 case 0x00:
8873 op_semantics_72:
8875 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8876 #line 1040 "rx-decode.opc"
8877 int sz AU = (op[1] >> 2) & 0x03;
8878 #line 1040 "rx-decode.opc"
8879 int sd AU = op[1] & 0x03;
8880 #line 1040 "rx-decode.opc"
8881 int rdst AU = (op[2] >> 4) & 0x0f;
8882 #line 1040 "rx-decode.opc"
8883 int cond AU = op[2] & 0x0f;
8884 if (trace)
8886 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8887 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8888 op[0], op[1], op[2]);
8889 printf (" sz = 0x%x,", sz);
8890 printf (" sd = 0x%x,", sd);
8891 printf (" rdst = 0x%x,", rdst);
8892 printf (" cond = 0x%x\n", cond);
8894 SYNTAX("sc%1%s %0");
8895 #line 1040 "rx-decode.opc"
8896 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8898 /*----------------------------------------------------------------------*/
8899 /* RXv2 enhanced */
8902 break;
8904 break;
8905 case 0xd1:
8906 GETBYTE ();
8907 switch (op[2] & 0x00)
8909 case 0x00:
8910 goto op_semantics_72;
8911 break;
8913 break;
8914 case 0xd2:
8915 GETBYTE ();
8916 switch (op[2] & 0x00)
8918 case 0x00:
8919 goto op_semantics_72;
8920 break;
8922 break;
8923 case 0xd3:
8924 GETBYTE ();
8925 switch (op[2] & 0x00)
8927 case 0x00:
8928 goto op_semantics_72;
8929 break;
8931 break;
8932 case 0xd4:
8933 GETBYTE ();
8934 switch (op[2] & 0x00)
8936 case 0x00:
8937 goto op_semantics_72;
8938 break;
8940 break;
8941 case 0xd5:
8942 GETBYTE ();
8943 switch (op[2] & 0x00)
8945 case 0x00:
8946 goto op_semantics_72;
8947 break;
8949 break;
8950 case 0xd6:
8951 GETBYTE ();
8952 switch (op[2] & 0x00)
8954 case 0x00:
8955 goto op_semantics_72;
8956 break;
8958 break;
8959 case 0xd7:
8960 GETBYTE ();
8961 switch (op[2] & 0x00)
8963 case 0x00:
8964 goto op_semantics_72;
8965 break;
8967 break;
8968 case 0xd8:
8969 GETBYTE ();
8970 switch (op[2] & 0x00)
8972 case 0x00:
8973 goto op_semantics_72;
8974 break;
8976 break;
8977 case 0xd9:
8978 GETBYTE ();
8979 switch (op[2] & 0x00)
8981 case 0x00:
8982 goto op_semantics_72;
8983 break;
8985 break;
8986 case 0xda:
8987 GETBYTE ();
8988 switch (op[2] & 0x00)
8990 case 0x00:
8991 goto op_semantics_72;
8992 break;
8994 break;
8995 case 0xdb:
8996 GETBYTE ();
8997 switch (op[2] & 0x00)
8999 case 0x00:
9000 goto op_semantics_72;
9001 break;
9003 break;
9004 case 0xe0:
9005 GETBYTE ();
9006 switch (op[2] & 0x0f)
9008 case 0x00:
9009 case 0x01:
9010 case 0x02:
9011 case 0x03:
9012 case 0x04:
9013 case 0x05:
9014 case 0x06:
9015 case 0x07:
9016 case 0x08:
9017 case 0x09:
9018 case 0x0a:
9019 case 0x0b:
9020 case 0x0c:
9021 case 0x0d:
9022 case 0x0e:
9023 op_semantics_73:
9025 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
9026 #line 983 "rx-decode.opc"
9027 int bit AU = (op[1] >> 2) & 0x07;
9028 #line 983 "rx-decode.opc"
9029 int sd AU = op[1] & 0x03;
9030 #line 983 "rx-decode.opc"
9031 int rdst AU = (op[2] >> 4) & 0x0f;
9032 #line 983 "rx-decode.opc"
9033 int cond AU = op[2] & 0x0f;
9034 if (trace)
9036 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9037 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
9038 op[0], op[1], op[2]);
9039 printf (" bit = 0x%x,", bit);
9040 printf (" sd = 0x%x,", sd);
9041 printf (" rdst = 0x%x,", rdst);
9042 printf (" cond = 0x%x\n", cond);
9044 SYNTAX("bm%2 #%1, %0%S0");
9045 #line 983 "rx-decode.opc"
9046 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
9049 break;
9050 case 0x0f:
9051 op_semantics_74:
9053 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
9054 #line 971 "rx-decode.opc"
9055 int bit AU = (op[1] >> 2) & 0x07;
9056 #line 971 "rx-decode.opc"
9057 int sd AU = op[1] & 0x03;
9058 #line 971 "rx-decode.opc"
9059 int rdst AU = (op[2] >> 4) & 0x0f;
9060 if (trace)
9062 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9063 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
9064 op[0], op[1], op[2]);
9065 printf (" bit = 0x%x,", bit);
9066 printf (" sd = 0x%x,", sd);
9067 printf (" rdst = 0x%x\n", rdst);
9069 SYNTAX("bnot #%1, %0%S0");
9070 #line 971 "rx-decode.opc"
9071 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
9074 break;
9076 break;
9077 case 0xe1:
9078 GETBYTE ();
9079 switch (op[2] & 0x0f)
9081 case 0x00:
9082 case 0x01:
9083 case 0x02:
9084 case 0x03:
9085 case 0x04:
9086 case 0x05:
9087 case 0x06:
9088 case 0x07:
9089 case 0x08:
9090 case 0x09:
9091 case 0x0a:
9092 case 0x0b:
9093 case 0x0c:
9094 case 0x0d:
9095 case 0x0e:
9096 goto op_semantics_73;
9097 break;
9098 case 0x0f:
9099 goto op_semantics_74;
9100 break;
9102 break;
9103 case 0xe2:
9104 GETBYTE ();
9105 switch (op[2] & 0x0f)
9107 case 0x00:
9108 case 0x01:
9109 case 0x02:
9110 case 0x03:
9111 case 0x04:
9112 case 0x05:
9113 case 0x06:
9114 case 0x07:
9115 case 0x08:
9116 case 0x09:
9117 case 0x0a:
9118 case 0x0b:
9119 case 0x0c:
9120 case 0x0d:
9121 case 0x0e:
9122 goto op_semantics_73;
9123 break;
9124 case 0x0f:
9125 goto op_semantics_74;
9126 break;
9128 break;
9129 case 0xe3:
9130 GETBYTE ();
9131 switch (op[2] & 0x0f)
9133 case 0x00:
9134 case 0x01:
9135 case 0x02:
9136 case 0x03:
9137 case 0x04:
9138 case 0x05:
9139 case 0x06:
9140 case 0x07:
9141 case 0x08:
9142 case 0x09:
9143 case 0x0a:
9144 case 0x0b:
9145 case 0x0c:
9146 case 0x0d:
9147 case 0x0e:
9148 goto op_semantics_73;
9149 break;
9150 case 0x0f:
9151 goto op_semantics_74;
9152 break;
9154 break;
9155 case 0xe4:
9156 GETBYTE ();
9157 switch (op[2] & 0x0f)
9159 case 0x00:
9160 case 0x01:
9161 case 0x02:
9162 case 0x03:
9163 case 0x04:
9164 case 0x05:
9165 case 0x06:
9166 case 0x07:
9167 case 0x08:
9168 case 0x09:
9169 case 0x0a:
9170 case 0x0b:
9171 case 0x0c:
9172 case 0x0d:
9173 case 0x0e:
9174 goto op_semantics_73;
9175 break;
9176 case 0x0f:
9177 goto op_semantics_74;
9178 break;
9180 break;
9181 case 0xe5:
9182 GETBYTE ();
9183 switch (op[2] & 0x0f)
9185 case 0x00:
9186 case 0x01:
9187 case 0x02:
9188 case 0x03:
9189 case 0x04:
9190 case 0x05:
9191 case 0x06:
9192 case 0x07:
9193 case 0x08:
9194 case 0x09:
9195 case 0x0a:
9196 case 0x0b:
9197 case 0x0c:
9198 case 0x0d:
9199 case 0x0e:
9200 goto op_semantics_73;
9201 break;
9202 case 0x0f:
9203 goto op_semantics_74;
9204 break;
9206 break;
9207 case 0xe6:
9208 GETBYTE ();
9209 switch (op[2] & 0x0f)
9211 case 0x00:
9212 case 0x01:
9213 case 0x02:
9214 case 0x03:
9215 case 0x04:
9216 case 0x05:
9217 case 0x06:
9218 case 0x07:
9219 case 0x08:
9220 case 0x09:
9221 case 0x0a:
9222 case 0x0b:
9223 case 0x0c:
9224 case 0x0d:
9225 case 0x0e:
9226 goto op_semantics_73;
9227 break;
9228 case 0x0f:
9229 goto op_semantics_74;
9230 break;
9232 break;
9233 case 0xe7:
9234 GETBYTE ();
9235 switch (op[2] & 0x0f)
9237 case 0x00:
9238 case 0x01:
9239 case 0x02:
9240 case 0x03:
9241 case 0x04:
9242 case 0x05:
9243 case 0x06:
9244 case 0x07:
9245 case 0x08:
9246 case 0x09:
9247 case 0x0a:
9248 case 0x0b:
9249 case 0x0c:
9250 case 0x0d:
9251 case 0x0e:
9252 goto op_semantics_73;
9253 break;
9254 case 0x0f:
9255 goto op_semantics_74;
9256 break;
9258 break;
9259 case 0xe8:
9260 GETBYTE ();
9261 switch (op[2] & 0x0f)
9263 case 0x00:
9264 case 0x01:
9265 case 0x02:
9266 case 0x03:
9267 case 0x04:
9268 case 0x05:
9269 case 0x06:
9270 case 0x07:
9271 case 0x08:
9272 case 0x09:
9273 case 0x0a:
9274 case 0x0b:
9275 case 0x0c:
9276 case 0x0d:
9277 case 0x0e:
9278 goto op_semantics_73;
9279 break;
9280 case 0x0f:
9281 goto op_semantics_74;
9282 break;
9284 break;
9285 case 0xe9:
9286 GETBYTE ();
9287 switch (op[2] & 0x0f)
9289 case 0x00:
9290 case 0x01:
9291 case 0x02:
9292 case 0x03:
9293 case 0x04:
9294 case 0x05:
9295 case 0x06:
9296 case 0x07:
9297 case 0x08:
9298 case 0x09:
9299 case 0x0a:
9300 case 0x0b:
9301 case 0x0c:
9302 case 0x0d:
9303 case 0x0e:
9304 goto op_semantics_73;
9305 break;
9306 case 0x0f:
9307 goto op_semantics_74;
9308 break;
9310 break;
9311 case 0xea:
9312 GETBYTE ();
9313 switch (op[2] & 0x0f)
9315 case 0x00:
9316 case 0x01:
9317 case 0x02:
9318 case 0x03:
9319 case 0x04:
9320 case 0x05:
9321 case 0x06:
9322 case 0x07:
9323 case 0x08:
9324 case 0x09:
9325 case 0x0a:
9326 case 0x0b:
9327 case 0x0c:
9328 case 0x0d:
9329 case 0x0e:
9330 goto op_semantics_73;
9331 break;
9332 case 0x0f:
9333 goto op_semantics_74;
9334 break;
9336 break;
9337 case 0xeb:
9338 GETBYTE ();
9339 switch (op[2] & 0x0f)
9341 case 0x00:
9342 case 0x01:
9343 case 0x02:
9344 case 0x03:
9345 case 0x04:
9346 case 0x05:
9347 case 0x06:
9348 case 0x07:
9349 case 0x08:
9350 case 0x09:
9351 case 0x0a:
9352 case 0x0b:
9353 case 0x0c:
9354 case 0x0d:
9355 case 0x0e:
9356 goto op_semantics_73;
9357 break;
9358 case 0x0f:
9359 goto op_semantics_74;
9360 break;
9362 break;
9363 case 0xec:
9364 GETBYTE ();
9365 switch (op[2] & 0x0f)
9367 case 0x00:
9368 case 0x01:
9369 case 0x02:
9370 case 0x03:
9371 case 0x04:
9372 case 0x05:
9373 case 0x06:
9374 case 0x07:
9375 case 0x08:
9376 case 0x09:
9377 case 0x0a:
9378 case 0x0b:
9379 case 0x0c:
9380 case 0x0d:
9381 case 0x0e:
9382 goto op_semantics_73;
9383 break;
9384 case 0x0f:
9385 goto op_semantics_74;
9386 break;
9388 break;
9389 case 0xed:
9390 GETBYTE ();
9391 switch (op[2] & 0x0f)
9393 case 0x00:
9394 case 0x01:
9395 case 0x02:
9396 case 0x03:
9397 case 0x04:
9398 case 0x05:
9399 case 0x06:
9400 case 0x07:
9401 case 0x08:
9402 case 0x09:
9403 case 0x0a:
9404 case 0x0b:
9405 case 0x0c:
9406 case 0x0d:
9407 case 0x0e:
9408 goto op_semantics_73;
9409 break;
9410 case 0x0f:
9411 goto op_semantics_74;
9412 break;
9414 break;
9415 case 0xee:
9416 GETBYTE ();
9417 switch (op[2] & 0x0f)
9419 case 0x00:
9420 case 0x01:
9421 case 0x02:
9422 case 0x03:
9423 case 0x04:
9424 case 0x05:
9425 case 0x06:
9426 case 0x07:
9427 case 0x08:
9428 case 0x09:
9429 case 0x0a:
9430 case 0x0b:
9431 case 0x0c:
9432 case 0x0d:
9433 case 0x0e:
9434 goto op_semantics_73;
9435 break;
9436 case 0x0f:
9437 goto op_semantics_74;
9438 break;
9440 break;
9441 case 0xef:
9442 GETBYTE ();
9443 switch (op[2] & 0x0f)
9445 case 0x00:
9446 case 0x01:
9447 case 0x02:
9448 case 0x03:
9449 case 0x04:
9450 case 0x05:
9451 case 0x06:
9452 case 0x07:
9453 case 0x08:
9454 case 0x09:
9455 case 0x0a:
9456 case 0x0b:
9457 case 0x0c:
9458 case 0x0d:
9459 case 0x0e:
9460 goto op_semantics_73;
9461 break;
9462 case 0x0f:
9463 goto op_semantics_74;
9464 break;
9466 break;
9467 case 0xf0:
9468 GETBYTE ();
9469 switch (op[2] & 0x0f)
9471 case 0x00:
9472 case 0x01:
9473 case 0x02:
9474 case 0x03:
9475 case 0x04:
9476 case 0x05:
9477 case 0x06:
9478 case 0x07:
9479 case 0x08:
9480 case 0x09:
9481 case 0x0a:
9482 case 0x0b:
9483 case 0x0c:
9484 case 0x0d:
9485 case 0x0e:
9486 goto op_semantics_73;
9487 break;
9488 case 0x0f:
9489 goto op_semantics_74;
9490 break;
9492 break;
9493 case 0xf1:
9494 GETBYTE ();
9495 switch (op[2] & 0x0f)
9497 case 0x00:
9498 case 0x01:
9499 case 0x02:
9500 case 0x03:
9501 case 0x04:
9502 case 0x05:
9503 case 0x06:
9504 case 0x07:
9505 case 0x08:
9506 case 0x09:
9507 case 0x0a:
9508 case 0x0b:
9509 case 0x0c:
9510 case 0x0d:
9511 case 0x0e:
9512 goto op_semantics_73;
9513 break;
9514 case 0x0f:
9515 goto op_semantics_74;
9516 break;
9518 break;
9519 case 0xf2:
9520 GETBYTE ();
9521 switch (op[2] & 0x0f)
9523 case 0x00:
9524 case 0x01:
9525 case 0x02:
9526 case 0x03:
9527 case 0x04:
9528 case 0x05:
9529 case 0x06:
9530 case 0x07:
9531 case 0x08:
9532 case 0x09:
9533 case 0x0a:
9534 case 0x0b:
9535 case 0x0c:
9536 case 0x0d:
9537 case 0x0e:
9538 goto op_semantics_73;
9539 break;
9540 case 0x0f:
9541 goto op_semantics_74;
9542 break;
9544 break;
9545 case 0xf3:
9546 GETBYTE ();
9547 switch (op[2] & 0x0f)
9549 case 0x00:
9550 case 0x01:
9551 case 0x02:
9552 case 0x03:
9553 case 0x04:
9554 case 0x05:
9555 case 0x06:
9556 case 0x07:
9557 case 0x08:
9558 case 0x09:
9559 case 0x0a:
9560 case 0x0b:
9561 case 0x0c:
9562 case 0x0d:
9563 case 0x0e:
9564 goto op_semantics_73;
9565 break;
9566 case 0x0f:
9567 goto op_semantics_74;
9568 break;
9570 break;
9571 case 0xf4:
9572 GETBYTE ();
9573 switch (op[2] & 0x0f)
9575 case 0x00:
9576 case 0x01:
9577 case 0x02:
9578 case 0x03:
9579 case 0x04:
9580 case 0x05:
9581 case 0x06:
9582 case 0x07:
9583 case 0x08:
9584 case 0x09:
9585 case 0x0a:
9586 case 0x0b:
9587 case 0x0c:
9588 case 0x0d:
9589 case 0x0e:
9590 goto op_semantics_73;
9591 break;
9592 case 0x0f:
9593 goto op_semantics_74;
9594 break;
9596 break;
9597 case 0xf5:
9598 GETBYTE ();
9599 switch (op[2] & 0x0f)
9601 case 0x00:
9602 case 0x01:
9603 case 0x02:
9604 case 0x03:
9605 case 0x04:
9606 case 0x05:
9607 case 0x06:
9608 case 0x07:
9609 case 0x08:
9610 case 0x09:
9611 case 0x0a:
9612 case 0x0b:
9613 case 0x0c:
9614 case 0x0d:
9615 case 0x0e:
9616 goto op_semantics_73;
9617 break;
9618 case 0x0f:
9619 goto op_semantics_74;
9620 break;
9622 break;
9623 case 0xf6:
9624 GETBYTE ();
9625 switch (op[2] & 0x0f)
9627 case 0x00:
9628 case 0x01:
9629 case 0x02:
9630 case 0x03:
9631 case 0x04:
9632 case 0x05:
9633 case 0x06:
9634 case 0x07:
9635 case 0x08:
9636 case 0x09:
9637 case 0x0a:
9638 case 0x0b:
9639 case 0x0c:
9640 case 0x0d:
9641 case 0x0e:
9642 goto op_semantics_73;
9643 break;
9644 case 0x0f:
9645 goto op_semantics_74;
9646 break;
9648 break;
9649 case 0xf7:
9650 GETBYTE ();
9651 switch (op[2] & 0x0f)
9653 case 0x00:
9654 case 0x01:
9655 case 0x02:
9656 case 0x03:
9657 case 0x04:
9658 case 0x05:
9659 case 0x06:
9660 case 0x07:
9661 case 0x08:
9662 case 0x09:
9663 case 0x0a:
9664 case 0x0b:
9665 case 0x0c:
9666 case 0x0d:
9667 case 0x0e:
9668 goto op_semantics_73;
9669 break;
9670 case 0x0f:
9671 goto op_semantics_74;
9672 break;
9674 break;
9675 case 0xf8:
9676 GETBYTE ();
9677 switch (op[2] & 0x0f)
9679 case 0x00:
9680 case 0x01:
9681 case 0x02:
9682 case 0x03:
9683 case 0x04:
9684 case 0x05:
9685 case 0x06:
9686 case 0x07:
9687 case 0x08:
9688 case 0x09:
9689 case 0x0a:
9690 case 0x0b:
9691 case 0x0c:
9692 case 0x0d:
9693 case 0x0e:
9694 goto op_semantics_73;
9695 break;
9696 case 0x0f:
9697 goto op_semantics_74;
9698 break;
9700 break;
9701 case 0xf9:
9702 GETBYTE ();
9703 switch (op[2] & 0x0f)
9705 case 0x00:
9706 case 0x01:
9707 case 0x02:
9708 case 0x03:
9709 case 0x04:
9710 case 0x05:
9711 case 0x06:
9712 case 0x07:
9713 case 0x08:
9714 case 0x09:
9715 case 0x0a:
9716 case 0x0b:
9717 case 0x0c:
9718 case 0x0d:
9719 case 0x0e:
9720 goto op_semantics_73;
9721 break;
9722 case 0x0f:
9723 goto op_semantics_74;
9724 break;
9726 break;
9727 case 0xfa:
9728 GETBYTE ();
9729 switch (op[2] & 0x0f)
9731 case 0x00:
9732 case 0x01:
9733 case 0x02:
9734 case 0x03:
9735 case 0x04:
9736 case 0x05:
9737 case 0x06:
9738 case 0x07:
9739 case 0x08:
9740 case 0x09:
9741 case 0x0a:
9742 case 0x0b:
9743 case 0x0c:
9744 case 0x0d:
9745 case 0x0e:
9746 goto op_semantics_73;
9747 break;
9748 case 0x0f:
9749 goto op_semantics_74;
9750 break;
9752 break;
9753 case 0xfb:
9754 GETBYTE ();
9755 switch (op[2] & 0x0f)
9757 case 0x00:
9758 case 0x01:
9759 case 0x02:
9760 case 0x03:
9761 case 0x04:
9762 case 0x05:
9763 case 0x06:
9764 case 0x07:
9765 case 0x08:
9766 case 0x09:
9767 case 0x0a:
9768 case 0x0b:
9769 case 0x0c:
9770 case 0x0d:
9771 case 0x0e:
9772 goto op_semantics_73;
9773 break;
9774 case 0x0f:
9775 goto op_semantics_74;
9776 break;
9778 break;
9779 case 0xfc:
9780 GETBYTE ();
9781 switch (op[2] & 0x0f)
9783 case 0x00:
9784 case 0x01:
9785 case 0x02:
9786 case 0x03:
9787 case 0x04:
9788 case 0x05:
9789 case 0x06:
9790 case 0x07:
9791 case 0x08:
9792 case 0x09:
9793 case 0x0a:
9794 case 0x0b:
9795 case 0x0c:
9796 case 0x0d:
9797 case 0x0e:
9798 goto op_semantics_73;
9799 break;
9800 case 0x0f:
9801 goto op_semantics_74;
9802 break;
9804 break;
9805 case 0xfd:
9806 GETBYTE ();
9807 switch (op[2] & 0x0f)
9809 case 0x00:
9810 case 0x01:
9811 case 0x02:
9812 case 0x03:
9813 case 0x04:
9814 case 0x05:
9815 case 0x06:
9816 case 0x07:
9817 case 0x08:
9818 case 0x09:
9819 case 0x0a:
9820 case 0x0b:
9821 case 0x0c:
9822 case 0x0d:
9823 case 0x0e:
9824 goto op_semantics_73;
9825 break;
9826 case 0x0f:
9827 goto op_semantics_74;
9828 break;
9830 break;
9831 case 0xfe:
9832 GETBYTE ();
9833 switch (op[2] & 0x0f)
9835 case 0x00:
9836 case 0x01:
9837 case 0x02:
9838 case 0x03:
9839 case 0x04:
9840 case 0x05:
9841 case 0x06:
9842 case 0x07:
9843 case 0x08:
9844 case 0x09:
9845 case 0x0a:
9846 case 0x0b:
9847 case 0x0c:
9848 case 0x0d:
9849 case 0x0e:
9850 goto op_semantics_73;
9851 break;
9852 case 0x0f:
9853 goto op_semantics_74;
9854 break;
9856 break;
9857 case 0xff:
9858 GETBYTE ();
9859 switch (op[2] & 0x0f)
9861 case 0x00:
9862 case 0x01:
9863 case 0x02:
9864 case 0x03:
9865 case 0x04:
9866 case 0x05:
9867 case 0x06:
9868 case 0x07:
9869 case 0x08:
9870 case 0x09:
9871 case 0x0a:
9872 case 0x0b:
9873 case 0x0c:
9874 case 0x0d:
9875 case 0x0e:
9876 goto op_semantics_73;
9877 break;
9878 case 0x0f:
9879 goto op_semantics_74;
9880 break;
9882 break;
9883 default: UNSUPPORTED(); break;
9885 break;
9886 case 0xfd:
9887 GETBYTE ();
9888 switch (op[1] & 0xff)
9890 case 0x00:
9891 GETBYTE ();
9892 switch (op[2] & 0x00)
9894 case 0x00:
9895 op_semantics_75:
9897 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
9898 #line 848 "rx-decode.opc"
9899 int a AU = (op[1] >> 3) & 0x01;
9900 #line 848 "rx-decode.opc"
9901 int srca AU = (op[2] >> 4) & 0x0f;
9902 #line 848 "rx-decode.opc"
9903 int srcb AU = op[2] & 0x0f;
9904 if (trace)
9906 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9907 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
9908 op[0], op[1], op[2]);
9909 printf (" a = 0x%x,", a);
9910 printf (" srca = 0x%x,", srca);
9911 printf (" srcb = 0x%x\n", srcb);
9913 SYNTAX("mulhi %1, %2, %0");
9914 #line 848 "rx-decode.opc"
9915 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
9918 break;
9920 break;
9921 case 0x01:
9922 GETBYTE ();
9923 switch (op[2] & 0x00)
9925 case 0x00:
9926 op_semantics_76:
9928 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
9929 #line 851 "rx-decode.opc"
9930 int a AU = (op[1] >> 3) & 0x01;
9931 #line 851 "rx-decode.opc"
9932 int srca AU = (op[2] >> 4) & 0x0f;
9933 #line 851 "rx-decode.opc"
9934 int srcb AU = op[2] & 0x0f;
9935 if (trace)
9937 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9938 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
9939 op[0], op[1], op[2]);
9940 printf (" a = 0x%x,", a);
9941 printf (" srca = 0x%x,", srca);
9942 printf (" srcb = 0x%x\n", srcb);
9944 SYNTAX("mullo %1, %2, %0");
9945 #line 851 "rx-decode.opc"
9946 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
9949 break;
9951 break;
9952 case 0x02:
9953 GETBYTE ();
9954 switch (op[2] & 0x00)
9956 case 0x00:
9957 op_semantics_77:
9959 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
9960 #line 1079 "rx-decode.opc"
9961 int a AU = (op[1] >> 3) & 0x01;
9962 #line 1079 "rx-decode.opc"
9963 int srca AU = (op[2] >> 4) & 0x0f;
9964 #line 1079 "rx-decode.opc"
9965 int srcb AU = op[2] & 0x0f;
9966 if (trace)
9968 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9969 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
9970 op[0], op[1], op[2]);
9971 printf (" a = 0x%x,", a);
9972 printf (" srca = 0x%x,", srca);
9973 printf (" srcb = 0x%x\n", srcb);
9975 SYNTAX("mullh %1, %2, %0");
9976 #line 1079 "rx-decode.opc"
9977 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
9980 break;
9982 break;
9983 case 0x03:
9984 GETBYTE ();
9985 switch (op[2] & 0x00)
9987 case 0x00:
9988 op_semantics_78:
9990 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
9991 #line 1064 "rx-decode.opc"
9992 int a AU = (op[1] >> 3) & 0x01;
9993 #line 1064 "rx-decode.opc"
9994 int srca AU = (op[2] >> 4) & 0x0f;
9995 #line 1064 "rx-decode.opc"
9996 int srcb AU = op[2] & 0x0f;
9997 if (trace)
9999 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10000 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
10001 op[0], op[1], op[2]);
10002 printf (" a = 0x%x,", a);
10003 printf (" srca = 0x%x,", srca);
10004 printf (" srcb = 0x%x\n", srcb);
10006 SYNTAX("emula %1, %2, %0");
10007 #line 1064 "rx-decode.opc"
10008 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
10011 break;
10013 break;
10014 case 0x04:
10015 GETBYTE ();
10016 switch (op[2] & 0x00)
10018 case 0x00:
10019 op_semantics_79:
10021 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
10022 #line 854 "rx-decode.opc"
10023 int a AU = (op[1] >> 3) & 0x01;
10024 #line 854 "rx-decode.opc"
10025 int srca AU = (op[2] >> 4) & 0x0f;
10026 #line 854 "rx-decode.opc"
10027 int srcb AU = op[2] & 0x0f;
10028 if (trace)
10030 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10031 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
10032 op[0], op[1], op[2]);
10033 printf (" a = 0x%x,", a);
10034 printf (" srca = 0x%x,", srca);
10035 printf (" srcb = 0x%x\n", srcb);
10037 SYNTAX("machi %1, %2, %0");
10038 #line 854 "rx-decode.opc"
10039 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
10042 break;
10044 break;
10045 case 0x05:
10046 GETBYTE ();
10047 switch (op[2] & 0x00)
10049 case 0x00:
10050 op_semantics_80:
10052 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
10053 #line 857 "rx-decode.opc"
10054 int a AU = (op[1] >> 3) & 0x01;
10055 #line 857 "rx-decode.opc"
10056 int srca AU = (op[2] >> 4) & 0x0f;
10057 #line 857 "rx-decode.opc"
10058 int srcb AU = op[2] & 0x0f;
10059 if (trace)
10061 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10062 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
10063 op[0], op[1], op[2]);
10064 printf (" a = 0x%x,", a);
10065 printf (" srca = 0x%x,", srca);
10066 printf (" srcb = 0x%x\n", srcb);
10068 SYNTAX("maclo %1, %2, %0");
10069 #line 857 "rx-decode.opc"
10070 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
10073 break;
10075 break;
10076 case 0x06:
10077 GETBYTE ();
10078 switch (op[2] & 0x00)
10080 case 0x00:
10081 op_semantics_81:
10083 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
10084 #line 1067 "rx-decode.opc"
10085 int a AU = (op[1] >> 3) & 0x01;
10086 #line 1067 "rx-decode.opc"
10087 int srca AU = (op[2] >> 4) & 0x0f;
10088 #line 1067 "rx-decode.opc"
10089 int srcb AU = op[2] & 0x0f;
10090 if (trace)
10092 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10093 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
10094 op[0], op[1], op[2]);
10095 printf (" a = 0x%x,", a);
10096 printf (" srca = 0x%x,", srca);
10097 printf (" srcb = 0x%x\n", srcb);
10099 SYNTAX("maclh %1, %2, %0");
10100 #line 1067 "rx-decode.opc"
10101 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
10104 break;
10106 break;
10107 case 0x07:
10108 GETBYTE ();
10109 switch (op[2] & 0x00)
10111 case 0x00:
10112 op_semantics_82:
10114 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
10115 #line 1058 "rx-decode.opc"
10116 int a AU = (op[1] >> 3) & 0x01;
10117 #line 1058 "rx-decode.opc"
10118 int srca AU = (op[2] >> 4) & 0x0f;
10119 #line 1058 "rx-decode.opc"
10120 int srcb AU = op[2] & 0x0f;
10121 if (trace)
10123 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10124 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
10125 op[0], op[1], op[2]);
10126 printf (" a = 0x%x,", a);
10127 printf (" srca = 0x%x,", srca);
10128 printf (" srcb = 0x%x\n", srcb);
10130 SYNTAX("emaca %1, %2, %0");
10131 #line 1058 "rx-decode.opc"
10132 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
10135 break;
10137 break;
10138 case 0x08:
10139 GETBYTE ();
10140 switch (op[2] & 0x00)
10142 case 0x00:
10143 goto op_semantics_75;
10144 break;
10146 break;
10147 case 0x09:
10148 GETBYTE ();
10149 switch (op[2] & 0x00)
10151 case 0x00:
10152 goto op_semantics_76;
10153 break;
10155 break;
10156 case 0x0a:
10157 GETBYTE ();
10158 switch (op[2] & 0x00)
10160 case 0x00:
10161 goto op_semantics_77;
10162 break;
10164 break;
10165 case 0x0b:
10166 GETBYTE ();
10167 switch (op[2] & 0x00)
10169 case 0x00:
10170 goto op_semantics_78;
10171 break;
10173 break;
10174 case 0x0c:
10175 GETBYTE ();
10176 switch (op[2] & 0x00)
10178 case 0x00:
10179 goto op_semantics_79;
10180 break;
10182 break;
10183 case 0x0d:
10184 GETBYTE ();
10185 switch (op[2] & 0x00)
10187 case 0x00:
10188 goto op_semantics_80;
10189 break;
10191 break;
10192 case 0x0e:
10193 GETBYTE ();
10194 switch (op[2] & 0x00)
10196 case 0x00:
10197 goto op_semantics_81;
10198 break;
10200 break;
10201 case 0x0f:
10202 GETBYTE ();
10203 switch (op[2] & 0x00)
10205 case 0x00:
10206 goto op_semantics_82;
10207 break;
10209 break;
10210 case 0x17:
10211 GETBYTE ();
10212 switch (op[2] & 0x70)
10214 case 0x00:
10216 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10217 #line 860 "rx-decode.opc"
10218 int a AU = (op[2] >> 7) & 0x01;
10219 #line 860 "rx-decode.opc"
10220 int rsrc AU = op[2] & 0x0f;
10221 if (trace)
10223 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10224 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
10225 op[0], op[1], op[2]);
10226 printf (" a = 0x%x,", a);
10227 printf (" rsrc = 0x%x\n", rsrc);
10229 SYNTAX("mvtachi %1, %0");
10230 #line 860 "rx-decode.opc"
10231 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10234 break;
10235 case 0x10:
10237 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10238 #line 863 "rx-decode.opc"
10239 int a AU = (op[2] >> 7) & 0x01;
10240 #line 863 "rx-decode.opc"
10241 int rsrc AU = op[2] & 0x0f;
10242 if (trace)
10244 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10245 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
10246 op[0], op[1], op[2]);
10247 printf (" a = 0x%x,", a);
10248 printf (" rsrc = 0x%x\n", rsrc);
10250 SYNTAX("mvtaclo %1, %0");
10251 #line 863 "rx-decode.opc"
10252 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10255 break;
10256 case 0x30:
10258 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10259 #line 1085 "rx-decode.opc"
10260 int a AU = (op[2] >> 7) & 0x01;
10261 #line 1085 "rx-decode.opc"
10262 int rdst AU = op[2] & 0x0f;
10263 if (trace)
10265 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10266 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
10267 op[0], op[1], op[2]);
10268 printf (" a = 0x%x,", a);
10269 printf (" rdst = 0x%x\n", rdst);
10271 SYNTAX("mvtacgu %0, %1");
10272 #line 1085 "rx-decode.opc"
10273 ID(mvtacgu); DR(a+32); SR(rdst); F_____;
10276 break;
10277 default: UNSUPPORTED(); break;
10279 break;
10280 case 0x18:
10281 GETBYTE ();
10282 switch (op[2] & 0x6f)
10284 case 0x00:
10286 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
10287 #line 875 "rx-decode.opc"
10288 int a AU = (op[2] >> 7) & 0x01;
10289 #line 875 "rx-decode.opc"
10290 int i AU = (op[2] >> 4) & 0x01;
10291 if (trace)
10293 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10294 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
10295 op[0], op[1], op[2]);
10296 printf (" a = 0x%x,", a);
10297 printf (" i = 0x%x\n", i);
10299 SYNTAX("racw #%1, %0");
10300 #line 875 "rx-decode.opc"
10301 ID(racw); SC(i+1); DR(a+32); F_____;
10303 /*----------------------------------------------------------------------*/
10304 /* SAT */
10307 break;
10308 case 0x40:
10310 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
10311 #line 1094 "rx-decode.opc"
10312 int a AU = (op[2] >> 7) & 0x01;
10313 #line 1094 "rx-decode.opc"
10314 int i AU = (op[2] >> 4) & 0x01;
10315 if (trace)
10317 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10318 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
10319 op[0], op[1], op[2]);
10320 printf (" a = 0x%x,", a);
10321 printf (" i = 0x%x\n", i);
10323 SYNTAX("rdacw #%1, %0");
10324 #line 1094 "rx-decode.opc"
10325 ID(rdacw); SC(i+1); DR(a+32); F_____;
10328 break;
10329 default: UNSUPPORTED(); break;
10331 break;
10332 case 0x19:
10333 GETBYTE ();
10334 switch (op[2] & 0x6f)
10336 case 0x00:
10338 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
10339 #line 1088 "rx-decode.opc"
10340 int a AU = (op[2] >> 7) & 0x01;
10341 #line 1088 "rx-decode.opc"
10342 int i AU = (op[2] >> 4) & 0x01;
10343 if (trace)
10345 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10346 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
10347 op[0], op[1], op[2]);
10348 printf (" a = 0x%x,", a);
10349 printf (" i = 0x%x\n", i);
10351 SYNTAX("racl #%1, %0");
10352 #line 1088 "rx-decode.opc"
10353 ID(racl); SC(i+1); DR(a+32); F_____;
10356 break;
10357 case 0x40:
10359 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
10360 #line 1091 "rx-decode.opc"
10361 int a AU = (op[2] >> 7) & 0x01;
10362 #line 1091 "rx-decode.opc"
10363 int i AU = (op[2] >> 4) & 0x01;
10364 if (trace)
10366 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10367 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
10368 op[0], op[1], op[2]);
10369 printf (" a = 0x%x,", a);
10370 printf (" i = 0x%x\n", i);
10372 SYNTAX("rdacl #%1, %0");
10373 #line 1091 "rx-decode.opc"
10374 ID(rdacl); SC(i+1); DR(a+32); F_____;
10377 break;
10378 default: UNSUPPORTED(); break;
10380 break;
10381 case 0x1e:
10382 GETBYTE ();
10383 switch (op[2] & 0x30)
10385 case 0x00:
10386 op_semantics_83:
10388 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
10389 #line 866 "rx-decode.opc"
10390 int i AU = op[1] & 0x01;
10391 #line 866 "rx-decode.opc"
10392 int a AU = (op[2] >> 7) & 0x01;
10393 #line 866 "rx-decode.opc"
10394 int m AU = (op[2] >> 6) & 0x01;
10395 #line 866 "rx-decode.opc"
10396 int rdst AU = op[2] & 0x0f;
10397 if (trace)
10399 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10400 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
10401 op[0], op[1], op[2]);
10402 printf (" i = 0x%x,", i);
10403 printf (" a = 0x%x,", a);
10404 printf (" m = 0x%x,", m);
10405 printf (" rdst = 0x%x\n", rdst);
10407 SYNTAX("mvfachi #%2, %1, %0");
10408 #line 866 "rx-decode.opc"
10409 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10412 break;
10413 case 0x10:
10414 op_semantics_84:
10416 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
10417 #line 872 "rx-decode.opc"
10418 int i AU = op[1] & 0x01;
10419 #line 872 "rx-decode.opc"
10420 int a AU = (op[2] >> 7) & 0x01;
10421 #line 872 "rx-decode.opc"
10422 int m AU = (op[2] >> 6) & 0x01;
10423 #line 872 "rx-decode.opc"
10424 int rdst AU = op[2] & 0x0f;
10425 if (trace)
10427 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10428 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
10429 op[0], op[1], op[2]);
10430 printf (" i = 0x%x,", i);
10431 printf (" a = 0x%x,", a);
10432 printf (" m = 0x%x,", m);
10433 printf (" rdst = 0x%x\n", rdst);
10435 SYNTAX("mvfaclo #%2, %1, %0");
10436 #line 872 "rx-decode.opc"
10437 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10440 break;
10441 case 0x20:
10442 op_semantics_85:
10444 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
10445 #line 869 "rx-decode.opc"
10446 int i AU = op[1] & 0x01;
10447 #line 869 "rx-decode.opc"
10448 int a AU = (op[2] >> 7) & 0x01;
10449 #line 869 "rx-decode.opc"
10450 int m AU = (op[2] >> 6) & 0x01;
10451 #line 869 "rx-decode.opc"
10452 int rdst AU = op[2] & 0x0f;
10453 if (trace)
10455 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10456 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
10457 op[0], op[1], op[2]);
10458 printf (" i = 0x%x,", i);
10459 printf (" a = 0x%x,", a);
10460 printf (" m = 0x%x,", m);
10461 printf (" rdst = 0x%x\n", rdst);
10463 SYNTAX("mvfacmi #%2, %1, %0");
10464 #line 869 "rx-decode.opc"
10465 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10468 break;
10469 case 0x30:
10470 op_semantics_86:
10472 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
10473 #line 1082 "rx-decode.opc"
10474 int i AU = op[1] & 0x01;
10475 #line 1082 "rx-decode.opc"
10476 int a AU = (op[2] >> 7) & 0x01;
10477 #line 1082 "rx-decode.opc"
10478 int m AU = (op[2] >> 6) & 0x01;
10479 #line 1082 "rx-decode.opc"
10480 int rdst AU = op[2] & 0x0f;
10481 if (trace)
10483 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10484 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
10485 op[0], op[1], op[2]);
10486 printf (" i = 0x%x,", i);
10487 printf (" a = 0x%x,", a);
10488 printf (" m = 0x%x,", m);
10489 printf (" rdst = 0x%x\n", rdst);
10491 SYNTAX("mvfacgu #%2, %1, %0");
10492 #line 1082 "rx-decode.opc"
10493 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10496 break;
10498 break;
10499 case 0x1f:
10500 GETBYTE ();
10501 switch (op[2] & 0x30)
10503 case 0x00:
10504 goto op_semantics_83;
10505 break;
10506 case 0x10:
10507 goto op_semantics_84;
10508 break;
10509 case 0x20:
10510 goto op_semantics_85;
10511 break;
10512 case 0x30:
10513 goto op_semantics_86;
10514 break;
10516 break;
10517 case 0x20:
10518 GETBYTE ();
10519 switch (op[2] & 0x00)
10521 case 0x00:
10522 op_semantics_87:
10524 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
10525 #line 344 "rx-decode.opc"
10526 int p AU = (op[1] >> 2) & 0x01;
10527 #line 344 "rx-decode.opc"
10528 int sz AU = op[1] & 0x03;
10529 #line 344 "rx-decode.opc"
10530 int rdst AU = (op[2] >> 4) & 0x0f;
10531 #line 344 "rx-decode.opc"
10532 int rsrc AU = op[2] & 0x0f;
10533 if (trace)
10535 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10536 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
10537 op[0], op[1], op[2]);
10538 printf (" p = 0x%x,", p);
10539 printf (" sz = 0x%x,", sz);
10540 printf (" rdst = 0x%x,", rdst);
10541 printf (" rsrc = 0x%x\n", rsrc);
10543 SYNTAX("mov%s %1, %0");
10544 #line 344 "rx-decode.opc"
10545 ID(mov); sBWL (sz); SR(rsrc); F_____;
10546 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
10549 break;
10551 break;
10552 case 0x21:
10553 GETBYTE ();
10554 switch (op[2] & 0x00)
10556 case 0x00:
10557 goto op_semantics_87;
10558 break;
10560 break;
10561 case 0x22:
10562 GETBYTE ();
10563 switch (op[2] & 0x00)
10565 case 0x00:
10566 goto op_semantics_87;
10567 break;
10569 break;
10570 case 0x24:
10571 GETBYTE ();
10572 switch (op[2] & 0x00)
10574 case 0x00:
10575 goto op_semantics_87;
10576 break;
10578 break;
10579 case 0x25:
10580 GETBYTE ();
10581 switch (op[2] & 0x00)
10583 case 0x00:
10584 goto op_semantics_87;
10585 break;
10587 break;
10588 case 0x26:
10589 GETBYTE ();
10590 switch (op[2] & 0x00)
10592 case 0x00:
10593 goto op_semantics_87;
10594 break;
10596 break;
10597 case 0x27:
10598 GETBYTE ();
10599 switch (op[2] & 0x00)
10601 case 0x00:
10603 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
10604 #line 1046 "rx-decode.opc"
10605 int rdst AU = (op[2] >> 4) & 0x0f;
10606 #line 1046 "rx-decode.opc"
10607 int rsrc AU = op[2] & 0x0f;
10608 if (trace)
10610 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10611 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
10612 op[0], op[1], op[2]);
10613 printf (" rdst = 0x%x,", rdst);
10614 printf (" rsrc = 0x%x\n", rsrc);
10616 SYNTAX("movco %1, [%0]");
10617 #line 1046 "rx-decode.opc"
10618 ID(movco); SR(rsrc); DR(rdst); F_____;
10621 break;
10623 break;
10624 case 0x28:
10625 GETBYTE ();
10626 switch (op[2] & 0x00)
10628 case 0x00:
10629 op_semantics_88:
10631 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
10632 #line 348 "rx-decode.opc"
10633 int p AU = (op[1] >> 2) & 0x01;
10634 #line 348 "rx-decode.opc"
10635 int sz AU = op[1] & 0x03;
10636 #line 348 "rx-decode.opc"
10637 int rsrc AU = (op[2] >> 4) & 0x0f;
10638 #line 348 "rx-decode.opc"
10639 int rdst AU = op[2] & 0x0f;
10640 if (trace)
10642 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10643 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
10644 op[0], op[1], op[2]);
10645 printf (" p = 0x%x,", p);
10646 printf (" sz = 0x%x,", sz);
10647 printf (" rsrc = 0x%x,", rsrc);
10648 printf (" rdst = 0x%x\n", rdst);
10650 SYNTAX("mov%s %1, %0");
10651 #line 348 "rx-decode.opc"
10652 ID(mov); sBWL (sz); DR(rdst); F_____;
10653 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10656 break;
10658 break;
10659 case 0x29:
10660 GETBYTE ();
10661 switch (op[2] & 0x00)
10663 case 0x00:
10664 goto op_semantics_88;
10665 break;
10667 break;
10668 case 0x2a:
10669 GETBYTE ();
10670 switch (op[2] & 0x00)
10672 case 0x00:
10673 goto op_semantics_88;
10674 break;
10676 break;
10677 case 0x2c:
10678 GETBYTE ();
10679 switch (op[2] & 0x00)
10681 case 0x00:
10682 goto op_semantics_88;
10683 break;
10685 break;
10686 case 0x2d:
10687 GETBYTE ();
10688 switch (op[2] & 0x00)
10690 case 0x00:
10691 goto op_semantics_88;
10692 break;
10694 break;
10695 case 0x2e:
10696 GETBYTE ();
10697 switch (op[2] & 0x00)
10699 case 0x00:
10700 goto op_semantics_88;
10701 break;
10703 break;
10704 case 0x2f:
10705 GETBYTE ();
10706 switch (op[2] & 0x00)
10708 case 0x00:
10710 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
10711 #line 1049 "rx-decode.opc"
10712 int rsrc AU = (op[2] >> 4) & 0x0f;
10713 #line 1049 "rx-decode.opc"
10714 int rdst AU = op[2] & 0x0f;
10715 if (trace)
10717 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10718 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
10719 op[0], op[1], op[2]);
10720 printf (" rsrc = 0x%x,", rsrc);
10721 printf (" rdst = 0x%x\n", rdst);
10723 SYNTAX("movli [%1], %0");
10724 #line 1049 "rx-decode.opc"
10725 ID(movli); SR(rsrc); DR(rdst); F_____;
10728 break;
10730 break;
10731 case 0x38:
10732 GETBYTE ();
10733 switch (op[2] & 0x00)
10735 case 0x00:
10736 op_semantics_89:
10738 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
10739 #line 358 "rx-decode.opc"
10740 int p AU = (op[1] >> 2) & 0x01;
10741 #line 358 "rx-decode.opc"
10742 int sz AU = op[1] & 0x03;
10743 #line 358 "rx-decode.opc"
10744 int rsrc AU = (op[2] >> 4) & 0x0f;
10745 #line 358 "rx-decode.opc"
10746 int rdst AU = op[2] & 0x0f;
10747 if (trace)
10749 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10750 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
10751 op[0], op[1], op[2]);
10752 printf (" p = 0x%x,", p);
10753 printf (" sz = 0x%x,", sz);
10754 printf (" rsrc = 0x%x,", rsrc);
10755 printf (" rdst = 0x%x\n", rdst);
10757 SYNTAX("movu%s %1, %0");
10758 #line 358 "rx-decode.opc"
10759 ID(mov); uBW (sz); DR(rdst); F_____;
10760 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10762 /*----------------------------------------------------------------------*/
10763 /* PUSH/POP */
10766 break;
10768 break;
10769 case 0x39:
10770 GETBYTE ();
10771 switch (op[2] & 0x00)
10773 case 0x00:
10774 goto op_semantics_89;
10775 break;
10777 break;
10778 case 0x3a:
10779 GETBYTE ();
10780 switch (op[2] & 0x00)
10782 case 0x00:
10783 goto op_semantics_89;
10784 break;
10786 break;
10787 case 0x3c:
10788 GETBYTE ();
10789 switch (op[2] & 0x00)
10791 case 0x00:
10792 goto op_semantics_89;
10793 break;
10795 break;
10796 case 0x3d:
10797 GETBYTE ();
10798 switch (op[2] & 0x00)
10800 case 0x00:
10801 goto op_semantics_89;
10802 break;
10804 break;
10805 case 0x3e:
10806 GETBYTE ();
10807 switch (op[2] & 0x00)
10809 case 0x00:
10810 goto op_semantics_89;
10811 break;
10813 break;
10814 case 0x44:
10815 GETBYTE ();
10816 switch (op[2] & 0x00)
10818 case 0x00:
10819 op_semantics_90:
10821 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
10822 #line 1070 "rx-decode.opc"
10823 int a AU = (op[1] >> 3) & 0x01;
10824 #line 1070 "rx-decode.opc"
10825 int srca AU = (op[2] >> 4) & 0x0f;
10826 #line 1070 "rx-decode.opc"
10827 int srcb AU = op[2] & 0x0f;
10828 if (trace)
10830 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10831 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
10832 op[0], op[1], op[2]);
10833 printf (" a = 0x%x,", a);
10834 printf (" srca = 0x%x,", srca);
10835 printf (" srcb = 0x%x\n", srcb);
10837 SYNTAX("msbhi %1, %2, %0");
10838 #line 1070 "rx-decode.opc"
10839 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
10842 break;
10844 break;
10845 case 0x45:
10846 GETBYTE ();
10847 switch (op[2] & 0x00)
10849 case 0x00:
10850 op_semantics_91:
10852 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
10853 #line 1076 "rx-decode.opc"
10854 int a AU = (op[1] >> 3) & 0x01;
10855 #line 1076 "rx-decode.opc"
10856 int srca AU = (op[2] >> 4) & 0x0f;
10857 #line 1076 "rx-decode.opc"
10858 int srcb AU = op[2] & 0x0f;
10859 if (trace)
10861 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10862 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
10863 op[0], op[1], op[2]);
10864 printf (" a = 0x%x,", a);
10865 printf (" srca = 0x%x,", srca);
10866 printf (" srcb = 0x%x\n", srcb);
10868 SYNTAX("msblo %1, %2, %0");
10869 #line 1076 "rx-decode.opc"
10870 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
10873 break;
10875 break;
10876 case 0x46:
10877 GETBYTE ();
10878 switch (op[2] & 0x00)
10880 case 0x00:
10881 op_semantics_92:
10883 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
10884 #line 1073 "rx-decode.opc"
10885 int a AU = (op[1] >> 3) & 0x01;
10886 #line 1073 "rx-decode.opc"
10887 int srca AU = (op[2] >> 4) & 0x0f;
10888 #line 1073 "rx-decode.opc"
10889 int srcb AU = op[2] & 0x0f;
10890 if (trace)
10892 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10893 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
10894 op[0], op[1], op[2]);
10895 printf (" a = 0x%x,", a);
10896 printf (" srca = 0x%x,", srca);
10897 printf (" srcb = 0x%x\n", srcb);
10899 SYNTAX("msblh %1, %2, %0");
10900 #line 1073 "rx-decode.opc"
10901 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
10904 break;
10906 break;
10907 case 0x47:
10908 GETBYTE ();
10909 switch (op[2] & 0x00)
10911 case 0x00:
10912 op_semantics_93:
10914 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
10915 #line 1061 "rx-decode.opc"
10916 int a AU = (op[1] >> 3) & 0x01;
10917 #line 1061 "rx-decode.opc"
10918 int srca AU = (op[2] >> 4) & 0x0f;
10919 #line 1061 "rx-decode.opc"
10920 int srcb AU = op[2] & 0x0f;
10921 if (trace)
10923 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10924 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
10925 op[0], op[1], op[2]);
10926 printf (" a = 0x%x,", a);
10927 printf (" srca = 0x%x,", srca);
10928 printf (" srcb = 0x%x\n", srcb);
10930 SYNTAX("emsba %1, %2, %0");
10931 #line 1061 "rx-decode.opc"
10932 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
10935 break;
10937 break;
10938 case 0x4c:
10939 GETBYTE ();
10940 switch (op[2] & 0x00)
10942 case 0x00:
10943 goto op_semantics_90;
10944 break;
10946 break;
10947 case 0x4d:
10948 GETBYTE ();
10949 switch (op[2] & 0x00)
10951 case 0x00:
10952 goto op_semantics_91;
10953 break;
10955 break;
10956 case 0x4e:
10957 GETBYTE ();
10958 switch (op[2] & 0x00)
10960 case 0x00:
10961 goto op_semantics_92;
10962 break;
10964 break;
10965 case 0x4f:
10966 GETBYTE ();
10967 switch (op[2] & 0x00)
10969 case 0x00:
10970 goto op_semantics_93;
10971 break;
10973 break;
10974 case 0x60:
10975 GETBYTE ();
10976 switch (op[2] & 0x00)
10978 case 0x00:
10980 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
10981 #line 729 "rx-decode.opc"
10982 int rsrc AU = (op[2] >> 4) & 0x0f;
10983 #line 729 "rx-decode.opc"
10984 int rdst AU = op[2] & 0x0f;
10985 if (trace)
10987 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10988 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
10989 op[0], op[1], op[2]);
10990 printf (" rsrc = 0x%x,", rsrc);
10991 printf (" rdst = 0x%x\n", rdst);
10993 SYNTAX("shlr %2, %0");
10994 #line 729 "rx-decode.opc"
10995 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
10998 break;
11000 break;
11001 case 0x61:
11002 GETBYTE ();
11003 switch (op[2] & 0x00)
11005 case 0x00:
11007 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
11008 #line 719 "rx-decode.opc"
11009 int rsrc AU = (op[2] >> 4) & 0x0f;
11010 #line 719 "rx-decode.opc"
11011 int rdst AU = op[2] & 0x0f;
11012 if (trace)
11014 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11015 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
11016 op[0], op[1], op[2]);
11017 printf (" rsrc = 0x%x,", rsrc);
11018 printf (" rdst = 0x%x\n", rdst);
11020 SYNTAX("shar %2, %0");
11021 #line 719 "rx-decode.opc"
11022 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
11025 break;
11027 break;
11028 case 0x62:
11029 GETBYTE ();
11030 switch (op[2] & 0x00)
11032 case 0x00:
11034 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
11035 #line 709 "rx-decode.opc"
11036 int rsrc AU = (op[2] >> 4) & 0x0f;
11037 #line 709 "rx-decode.opc"
11038 int rdst AU = op[2] & 0x0f;
11039 if (trace)
11041 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11042 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
11043 op[0], op[1], op[2]);
11044 printf (" rsrc = 0x%x,", rsrc);
11045 printf (" rdst = 0x%x\n", rdst);
11047 SYNTAX("shll %2, %0");
11048 #line 709 "rx-decode.opc"
11049 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
11052 break;
11054 break;
11055 case 0x64:
11056 GETBYTE ();
11057 switch (op[2] & 0x00)
11059 case 0x00:
11061 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
11062 #line 753 "rx-decode.opc"
11063 int rsrc AU = (op[2] >> 4) & 0x0f;
11064 #line 753 "rx-decode.opc"
11065 int rdst AU = op[2] & 0x0f;
11066 if (trace)
11068 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11069 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
11070 op[0], op[1], op[2]);
11071 printf (" rsrc = 0x%x,", rsrc);
11072 printf (" rdst = 0x%x\n", rdst);
11074 SYNTAX("rotr %1, %0");
11075 #line 753 "rx-decode.opc"
11076 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
11079 break;
11081 break;
11082 case 0x65:
11083 GETBYTE ();
11084 switch (op[2] & 0x00)
11086 case 0x00:
11088 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
11089 #line 756 "rx-decode.opc"
11090 int rsrc AU = (op[2] >> 4) & 0x0f;
11091 #line 756 "rx-decode.opc"
11092 int rdst AU = op[2] & 0x0f;
11093 if (trace)
11095 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11096 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
11097 op[0], op[1], op[2]);
11098 printf (" rsrc = 0x%x,", rsrc);
11099 printf (" rdst = 0x%x\n", rdst);
11101 SYNTAX("revw %1, %0");
11102 #line 756 "rx-decode.opc"
11103 ID(revw); SR(rsrc); DR(rdst);
11106 break;
11108 break;
11109 case 0x66:
11110 GETBYTE ();
11111 switch (op[2] & 0x00)
11113 case 0x00:
11115 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
11116 #line 747 "rx-decode.opc"
11117 int rsrc AU = (op[2] >> 4) & 0x0f;
11118 #line 747 "rx-decode.opc"
11119 int rdst AU = op[2] & 0x0f;
11120 if (trace)
11122 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11123 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
11124 op[0], op[1], op[2]);
11125 printf (" rsrc = 0x%x,", rsrc);
11126 printf (" rdst = 0x%x\n", rdst);
11128 SYNTAX("rotl %1, %0");
11129 #line 747 "rx-decode.opc"
11130 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
11133 break;
11135 break;
11136 case 0x67:
11137 GETBYTE ();
11138 switch (op[2] & 0x00)
11140 case 0x00:
11142 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
11143 #line 759 "rx-decode.opc"
11144 int rsrc AU = (op[2] >> 4) & 0x0f;
11145 #line 759 "rx-decode.opc"
11146 int rdst AU = op[2] & 0x0f;
11147 if (trace)
11149 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11150 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
11151 op[0], op[1], op[2]);
11152 printf (" rsrc = 0x%x,", rsrc);
11153 printf (" rdst = 0x%x\n", rdst);
11155 SYNTAX("revl %1, %0");
11156 #line 759 "rx-decode.opc"
11157 ID(revl); SR(rsrc); DR(rdst);
11159 /*----------------------------------------------------------------------*/
11160 /* BRANCH */
11163 break;
11165 break;
11166 case 0x68:
11167 GETBYTE ();
11168 switch (op[2] & 0x00)
11170 case 0x00:
11171 op_semantics_94:
11173 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
11174 #line 1010 "rx-decode.opc"
11175 int c AU = op[1] & 0x01;
11176 #line 1010 "rx-decode.opc"
11177 int rsrc AU = (op[2] >> 4) & 0x0f;
11178 #line 1010 "rx-decode.opc"
11179 int rdst AU = op[2] & 0x0f;
11180 if (trace)
11182 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11183 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
11184 op[0], op[1], op[2]);
11185 printf (" c = 0x%x,", c);
11186 printf (" rsrc = 0x%x,", rsrc);
11187 printf (" rdst = 0x%x\n", rdst);
11189 SYNTAX("mvtc %1, %0");
11190 #line 1010 "rx-decode.opc"
11191 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
11194 break;
11196 break;
11197 case 0x69:
11198 GETBYTE ();
11199 switch (op[2] & 0x00)
11201 case 0x00:
11202 goto op_semantics_94;
11203 break;
11205 break;
11206 case 0x6a:
11207 GETBYTE ();
11208 switch (op[2] & 0x00)
11210 case 0x00:
11211 op_semantics_95:
11213 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
11214 #line 1013 "rx-decode.opc"
11215 int s AU = op[1] & 0x01;
11216 #line 1013 "rx-decode.opc"
11217 int rsrc AU = (op[2] >> 4) & 0x0f;
11218 #line 1013 "rx-decode.opc"
11219 int rdst AU = op[2] & 0x0f;
11220 if (trace)
11222 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11223 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
11224 op[0], op[1], op[2]);
11225 printf (" s = 0x%x,", s);
11226 printf (" rsrc = 0x%x,", rsrc);
11227 printf (" rdst = 0x%x\n", rdst);
11229 SYNTAX("mvfc %1, %0");
11230 #line 1013 "rx-decode.opc"
11231 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11233 /*----------------------------------------------------------------------*/
11234 /* INTERRUPTS */
11237 break;
11239 break;
11240 case 0x6b:
11241 GETBYTE ();
11242 switch (op[2] & 0x00)
11244 case 0x00:
11245 goto op_semantics_95;
11246 break;
11248 break;
11249 case 0x6c:
11250 GETBYTE ();
11251 switch (op[2] & 0x00)
11253 case 0x00:
11254 op_semantics_96:
11256 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
11257 #line 750 "rx-decode.opc"
11258 int i AU = op[1] & 0x01;
11259 #line 750 "rx-decode.opc"
11260 int mmmm AU = (op[2] >> 4) & 0x0f;
11261 #line 750 "rx-decode.opc"
11262 int rdst AU = op[2] & 0x0f;
11263 if (trace)
11265 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11266 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
11267 op[0], op[1], op[2]);
11268 printf (" i = 0x%x,", i);
11269 printf (" mmmm = 0x%x,", mmmm);
11270 printf (" rdst = 0x%x\n", rdst);
11272 SYNTAX("rotr #%1, %0");
11273 #line 750 "rx-decode.opc"
11274 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11277 break;
11279 break;
11280 case 0x6d:
11281 GETBYTE ();
11282 switch (op[2] & 0x00)
11284 case 0x00:
11285 goto op_semantics_96;
11286 break;
11288 break;
11289 case 0x6e:
11290 GETBYTE ();
11291 switch (op[2] & 0x00)
11293 case 0x00:
11294 op_semantics_97:
11296 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
11297 #line 744 "rx-decode.opc"
11298 int i AU = op[1] & 0x01;
11299 #line 744 "rx-decode.opc"
11300 int mmmm AU = (op[2] >> 4) & 0x0f;
11301 #line 744 "rx-decode.opc"
11302 int rdst AU = op[2] & 0x0f;
11303 if (trace)
11305 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11306 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
11307 op[0], op[1], op[2]);
11308 printf (" i = 0x%x,", i);
11309 printf (" mmmm = 0x%x,", mmmm);
11310 printf (" rdst = 0x%x\n", rdst);
11312 SYNTAX("rotl #%1, %0");
11313 #line 744 "rx-decode.opc"
11314 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11317 break;
11319 break;
11320 case 0x6f:
11321 GETBYTE ();
11322 switch (op[2] & 0x00)
11324 case 0x00:
11325 goto op_semantics_97;
11326 break;
11328 break;
11329 case 0x70:
11330 GETBYTE ();
11331 switch (op[2] & 0xf0)
11333 case 0x20:
11334 op_semantics_98:
11336 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
11337 #line 488 "rx-decode.opc"
11338 int im AU = (op[1] >> 2) & 0x03;
11339 #line 488 "rx-decode.opc"
11340 int rdst AU = op[2] & 0x0f;
11341 if (trace)
11343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11344 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
11345 op[0], op[1], op[2]);
11346 printf (" im = 0x%x,", im);
11347 printf (" rdst = 0x%x\n", rdst);
11349 SYNTAX("adc #%1, %0");
11350 #line 488 "rx-decode.opc"
11351 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11354 break;
11355 case 0x40:
11356 op_semantics_99:
11358 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
11359 #line 570 "rx-decode.opc"
11360 int im AU = (op[1] >> 2) & 0x03;
11361 #line 570 "rx-decode.opc"
11362 int rdst AU = op[2] & 0x0f;
11363 if (trace)
11365 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11366 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
11367 op[0], op[1], op[2]);
11368 printf (" im = 0x%x,", im);
11369 printf (" rdst = 0x%x\n", rdst);
11371 SYNTAX("max #%1, %0");
11372 #line 570 "rx-decode.opc"
11373 int val = IMMex (im);
11374 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11376 ID (nop7);
11377 SYNTAX("nop\t; max\t#0x80000000, r0");
11379 else
11381 ID(max);
11383 DR(rdst); SC(val);
11386 break;
11387 case 0x50:
11388 op_semantics_100:
11390 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
11391 #line 600 "rx-decode.opc"
11392 int im AU = (op[1] >> 2) & 0x03;
11393 #line 600 "rx-decode.opc"
11394 int rdst AU = op[2] & 0x0f;
11395 if (trace)
11397 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11398 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
11399 op[0], op[1], op[2]);
11400 printf (" im = 0x%x,", im);
11401 printf (" rdst = 0x%x\n", rdst);
11403 SYNTAX("min #%1, %0");
11404 #line 600 "rx-decode.opc"
11405 ID(min); DR(rdst); SC(IMMex(im));
11408 break;
11409 case 0x60:
11410 op_semantics_101:
11412 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
11413 #line 658 "rx-decode.opc"
11414 int im AU = (op[1] >> 2) & 0x03;
11415 #line 658 "rx-decode.opc"
11416 int rdst AU = op[2] & 0x0f;
11417 if (trace)
11419 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11420 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
11421 op[0], op[1], op[2]);
11422 printf (" im = 0x%x,", im);
11423 printf (" rdst = 0x%x\n", rdst);
11425 SYNTAX("emul #%1, %0");
11426 #line 658 "rx-decode.opc"
11427 ID(emul); DR(rdst); SC(IMMex(im));
11430 break;
11431 case 0x70:
11432 op_semantics_102:
11434 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
11435 #line 670 "rx-decode.opc"
11436 int im AU = (op[1] >> 2) & 0x03;
11437 #line 670 "rx-decode.opc"
11438 int rdst AU = op[2] & 0x0f;
11439 if (trace)
11441 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11442 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
11443 op[0], op[1], op[2]);
11444 printf (" im = 0x%x,", im);
11445 printf (" rdst = 0x%x\n", rdst);
11447 SYNTAX("emulu #%1, %0");
11448 #line 670 "rx-decode.opc"
11449 ID(emulu); DR(rdst); SC(IMMex(im));
11452 break;
11453 case 0x80:
11454 op_semantics_103:
11456 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
11457 #line 682 "rx-decode.opc"
11458 int im AU = (op[1] >> 2) & 0x03;
11459 #line 682 "rx-decode.opc"
11460 int rdst AU = op[2] & 0x0f;
11461 if (trace)
11463 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11464 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
11465 op[0], op[1], op[2]);
11466 printf (" im = 0x%x,", im);
11467 printf (" rdst = 0x%x\n", rdst);
11469 SYNTAX("div #%1, %0");
11470 #line 682 "rx-decode.opc"
11471 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11474 break;
11475 case 0x90:
11476 op_semantics_104:
11478 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
11479 #line 694 "rx-decode.opc"
11480 int im AU = (op[1] >> 2) & 0x03;
11481 #line 694 "rx-decode.opc"
11482 int rdst AU = op[2] & 0x0f;
11483 if (trace)
11485 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11486 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
11487 op[0], op[1], op[2]);
11488 printf (" im = 0x%x,", im);
11489 printf (" rdst = 0x%x\n", rdst);
11491 SYNTAX("divu #%1, %0");
11492 #line 694 "rx-decode.opc"
11493 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11496 break;
11497 case 0xc0:
11498 op_semantics_105:
11500 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
11501 #line 467 "rx-decode.opc"
11502 int im AU = (op[1] >> 2) & 0x03;
11503 #line 467 "rx-decode.opc"
11504 int rdst AU = op[2] & 0x0f;
11505 if (trace)
11507 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11508 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
11509 op[0], op[1], op[2]);
11510 printf (" im = 0x%x,", im);
11511 printf (" rdst = 0x%x\n", rdst);
11513 SYNTAX("tst #%1, %2");
11514 #line 467 "rx-decode.opc"
11515 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11518 break;
11519 case 0xd0:
11520 op_semantics_106:
11522 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
11523 #line 446 "rx-decode.opc"
11524 int im AU = (op[1] >> 2) & 0x03;
11525 #line 446 "rx-decode.opc"
11526 int rdst AU = op[2] & 0x0f;
11527 if (trace)
11529 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11530 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
11531 op[0], op[1], op[2]);
11532 printf (" im = 0x%x,", im);
11533 printf (" rdst = 0x%x\n", rdst);
11535 SYNTAX("xor #%1, %0");
11536 #line 446 "rx-decode.opc"
11537 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11540 break;
11541 case 0xe0:
11542 op_semantics_107:
11544 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
11545 #line 392 "rx-decode.opc"
11546 int im AU = (op[1] >> 2) & 0x03;
11547 #line 392 "rx-decode.opc"
11548 int rdst AU = op[2] & 0x0f;
11549 if (trace)
11551 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11552 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
11553 op[0], op[1], op[2]);
11554 printf (" im = 0x%x,", im);
11555 printf (" rdst = 0x%x\n", rdst);
11557 SYNTAX("stz #%1, %0");
11558 #line 392 "rx-decode.opc"
11559 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11562 break;
11563 case 0xf0:
11564 op_semantics_108:
11566 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
11567 #line 395 "rx-decode.opc"
11568 int im AU = (op[1] >> 2) & 0x03;
11569 #line 395 "rx-decode.opc"
11570 int rdst AU = op[2] & 0x0f;
11571 if (trace)
11573 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11574 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
11575 op[0], op[1], op[2]);
11576 printf (" im = 0x%x,", im);
11577 printf (" rdst = 0x%x\n", rdst);
11579 SYNTAX("stnz #%1, %0");
11580 #line 395 "rx-decode.opc"
11581 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11583 /*----------------------------------------------------------------------*/
11584 /* RTSD */
11587 break;
11588 default: UNSUPPORTED(); break;
11590 break;
11591 case 0x72:
11592 GETBYTE ();
11593 switch (op[2] & 0xf0)
11595 case 0x00:
11597 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
11598 #line 902 "rx-decode.opc"
11599 int rdst AU = op[2] & 0x0f;
11600 if (trace)
11602 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11603 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
11604 op[0], op[1], op[2]);
11605 printf (" rdst = 0x%x\n", rdst);
11607 SYNTAX("fsub #%1, %0");
11608 #line 902 "rx-decode.opc"
11609 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11612 break;
11613 case 0x10:
11615 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
11616 #line 896 "rx-decode.opc"
11617 int rdst AU = op[2] & 0x0f;
11618 if (trace)
11620 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11621 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
11622 op[0], op[1], op[2]);
11623 printf (" rdst = 0x%x\n", rdst);
11625 SYNTAX("fcmp #%1, %0");
11626 #line 896 "rx-decode.opc"
11627 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11630 break;
11631 case 0x20:
11633 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
11634 #line 890 "rx-decode.opc"
11635 int rdst AU = op[2] & 0x0f;
11636 if (trace)
11638 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11639 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
11640 op[0], op[1], op[2]);
11641 printf (" rdst = 0x%x\n", rdst);
11643 SYNTAX("fadd #%1, %0");
11644 #line 890 "rx-decode.opc"
11645 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11648 break;
11649 case 0x30:
11651 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
11652 #line 911 "rx-decode.opc"
11653 int rdst AU = op[2] & 0x0f;
11654 if (trace)
11656 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11657 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
11658 op[0], op[1], op[2]);
11659 printf (" rdst = 0x%x\n", rdst);
11661 SYNTAX("fmul #%1, %0");
11662 #line 911 "rx-decode.opc"
11663 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
11666 break;
11667 case 0x40:
11669 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
11670 #line 917 "rx-decode.opc"
11671 int rdst AU = op[2] & 0x0f;
11672 if (trace)
11674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11675 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
11676 op[0], op[1], op[2]);
11677 printf (" rdst = 0x%x\n", rdst);
11679 SYNTAX("fdiv #%1, %0");
11680 #line 917 "rx-decode.opc"
11681 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
11684 break;
11685 default: UNSUPPORTED(); break;
11687 break;
11688 case 0x73:
11689 GETBYTE ();
11690 switch (op[2] & 0xe0)
11692 case 0x00:
11693 op_semantics_109:
11695 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
11696 #line 1007 "rx-decode.opc"
11697 int im AU = (op[1] >> 2) & 0x03;
11698 #line 1007 "rx-decode.opc"
11699 int crdst AU = op[2] & 0x1f;
11700 if (trace)
11702 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11703 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
11704 op[0], op[1], op[2]);
11705 printf (" im = 0x%x,", im);
11706 printf (" crdst = 0x%x\n", crdst);
11708 SYNTAX("mvtc #%1, %0");
11709 #line 1007 "rx-decode.opc"
11710 ID(mov); SC(IMMex(im)); DR(crdst + 16);
11713 break;
11714 default: UNSUPPORTED(); break;
11716 break;
11717 case 0x74:
11718 GETBYTE ();
11719 switch (op[2] & 0xf0)
11721 case 0x20:
11722 goto op_semantics_98;
11723 break;
11724 case 0x40:
11725 goto op_semantics_99;
11726 break;
11727 case 0x50:
11728 goto op_semantics_100;
11729 break;
11730 case 0x60:
11731 goto op_semantics_101;
11732 break;
11733 case 0x70:
11734 goto op_semantics_102;
11735 break;
11736 case 0x80:
11737 goto op_semantics_103;
11738 break;
11739 case 0x90:
11740 goto op_semantics_104;
11741 break;
11742 case 0xc0:
11743 goto op_semantics_105;
11744 break;
11745 case 0xd0:
11746 goto op_semantics_106;
11747 break;
11748 case 0xe0:
11749 goto op_semantics_107;
11750 break;
11751 case 0xf0:
11752 goto op_semantics_108;
11753 break;
11754 default: UNSUPPORTED(); break;
11756 break;
11757 case 0x77:
11758 GETBYTE ();
11759 switch (op[2] & 0xe0)
11761 case 0x00:
11762 goto op_semantics_109;
11763 break;
11764 default: UNSUPPORTED(); break;
11766 break;
11767 case 0x78:
11768 GETBYTE ();
11769 switch (op[2] & 0xf0)
11771 case 0x20:
11772 goto op_semantics_98;
11773 break;
11774 case 0x40:
11775 goto op_semantics_99;
11776 break;
11777 case 0x50:
11778 goto op_semantics_100;
11779 break;
11780 case 0x60:
11781 goto op_semantics_101;
11782 break;
11783 case 0x70:
11784 goto op_semantics_102;
11785 break;
11786 case 0x80:
11787 goto op_semantics_103;
11788 break;
11789 case 0x90:
11790 goto op_semantics_104;
11791 break;
11792 case 0xc0:
11793 goto op_semantics_105;
11794 break;
11795 case 0xd0:
11796 goto op_semantics_106;
11797 break;
11798 case 0xe0:
11799 goto op_semantics_107;
11800 break;
11801 case 0xf0:
11802 goto op_semantics_108;
11803 break;
11804 default: UNSUPPORTED(); break;
11806 break;
11807 case 0x7b:
11808 GETBYTE ();
11809 switch (op[2] & 0xe0)
11811 case 0x00:
11812 goto op_semantics_109;
11813 break;
11814 default: UNSUPPORTED(); break;
11816 break;
11817 case 0x7c:
11818 GETBYTE ();
11819 switch (op[2] & 0xf0)
11821 case 0x20:
11822 goto op_semantics_98;
11823 break;
11824 case 0x40:
11825 goto op_semantics_99;
11826 break;
11827 case 0x50:
11828 goto op_semantics_100;
11829 break;
11830 case 0x60:
11831 goto op_semantics_101;
11832 break;
11833 case 0x70:
11834 goto op_semantics_102;
11835 break;
11836 case 0x80:
11837 goto op_semantics_103;
11838 break;
11839 case 0x90:
11840 goto op_semantics_104;
11841 break;
11842 case 0xc0:
11843 goto op_semantics_105;
11844 break;
11845 case 0xd0:
11846 goto op_semantics_106;
11847 break;
11848 case 0xe0:
11849 goto op_semantics_107;
11850 break;
11851 case 0xf0:
11852 goto op_semantics_108;
11853 break;
11854 default: UNSUPPORTED(); break;
11856 break;
11857 case 0x7f:
11858 GETBYTE ();
11859 switch (op[2] & 0xe0)
11861 case 0x00:
11862 goto op_semantics_109;
11863 break;
11864 default: UNSUPPORTED(); break;
11866 break;
11867 case 0x80:
11868 GETBYTE ();
11869 switch (op[2] & 0x00)
11871 case 0x00:
11872 op_semantics_110:
11874 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
11875 #line 732 "rx-decode.opc"
11876 int immmm AU = op[1] & 0x1f;
11877 #line 732 "rx-decode.opc"
11878 int rsrc AU = (op[2] >> 4) & 0x0f;
11879 #line 732 "rx-decode.opc"
11880 int rdst AU = op[2] & 0x0f;
11881 if (trace)
11883 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11884 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
11885 op[0], op[1], op[2]);
11886 printf (" immmm = 0x%x,", immmm);
11887 printf (" rsrc = 0x%x,", rsrc);
11888 printf (" rdst = 0x%x\n", rdst);
11890 SYNTAX("shlr #%2, %1, %0");
11891 #line 732 "rx-decode.opc"
11892 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
11894 /*----------------------------------------------------------------------*/
11895 /* ROTATE */
11898 break;
11900 break;
11901 case 0x81:
11902 GETBYTE ();
11903 switch (op[2] & 0x00)
11905 case 0x00:
11906 goto op_semantics_110;
11907 break;
11909 break;
11910 case 0x82:
11911 GETBYTE ();
11912 switch (op[2] & 0x00)
11914 case 0x00:
11915 goto op_semantics_110;
11916 break;
11918 break;
11919 case 0x83:
11920 GETBYTE ();
11921 switch (op[2] & 0x00)
11923 case 0x00:
11924 goto op_semantics_110;
11925 break;
11927 break;
11928 case 0x84:
11929 GETBYTE ();
11930 switch (op[2] & 0x00)
11932 case 0x00:
11933 goto op_semantics_110;
11934 break;
11936 break;
11937 case 0x85:
11938 GETBYTE ();
11939 switch (op[2] & 0x00)
11941 case 0x00:
11942 goto op_semantics_110;
11943 break;
11945 break;
11946 case 0x86:
11947 GETBYTE ();
11948 switch (op[2] & 0x00)
11950 case 0x00:
11951 goto op_semantics_110;
11952 break;
11954 break;
11955 case 0x87:
11956 GETBYTE ();
11957 switch (op[2] & 0x00)
11959 case 0x00:
11960 goto op_semantics_110;
11961 break;
11963 break;
11964 case 0x88:
11965 GETBYTE ();
11966 switch (op[2] & 0x00)
11968 case 0x00:
11969 goto op_semantics_110;
11970 break;
11972 break;
11973 case 0x89:
11974 GETBYTE ();
11975 switch (op[2] & 0x00)
11977 case 0x00:
11978 goto op_semantics_110;
11979 break;
11981 break;
11982 case 0x8a:
11983 GETBYTE ();
11984 switch (op[2] & 0x00)
11986 case 0x00:
11987 goto op_semantics_110;
11988 break;
11990 break;
11991 case 0x8b:
11992 GETBYTE ();
11993 switch (op[2] & 0x00)
11995 case 0x00:
11996 goto op_semantics_110;
11997 break;
11999 break;
12000 case 0x8c:
12001 GETBYTE ();
12002 switch (op[2] & 0x00)
12004 case 0x00:
12005 goto op_semantics_110;
12006 break;
12008 break;
12009 case 0x8d:
12010 GETBYTE ();
12011 switch (op[2] & 0x00)
12013 case 0x00:
12014 goto op_semantics_110;
12015 break;
12017 break;
12018 case 0x8e:
12019 GETBYTE ();
12020 switch (op[2] & 0x00)
12022 case 0x00:
12023 goto op_semantics_110;
12024 break;
12026 break;
12027 case 0x8f:
12028 GETBYTE ();
12029 switch (op[2] & 0x00)
12031 case 0x00:
12032 goto op_semantics_110;
12033 break;
12035 break;
12036 case 0x90:
12037 GETBYTE ();
12038 switch (op[2] & 0x00)
12040 case 0x00:
12041 goto op_semantics_110;
12042 break;
12044 break;
12045 case 0x91:
12046 GETBYTE ();
12047 switch (op[2] & 0x00)
12049 case 0x00:
12050 goto op_semantics_110;
12051 break;
12053 break;
12054 case 0x92:
12055 GETBYTE ();
12056 switch (op[2] & 0x00)
12058 case 0x00:
12059 goto op_semantics_110;
12060 break;
12062 break;
12063 case 0x93:
12064 GETBYTE ();
12065 switch (op[2] & 0x00)
12067 case 0x00:
12068 goto op_semantics_110;
12069 break;
12071 break;
12072 case 0x94:
12073 GETBYTE ();
12074 switch (op[2] & 0x00)
12076 case 0x00:
12077 goto op_semantics_110;
12078 break;
12080 break;
12081 case 0x95:
12082 GETBYTE ();
12083 switch (op[2] & 0x00)
12085 case 0x00:
12086 goto op_semantics_110;
12087 break;
12089 break;
12090 case 0x96:
12091 GETBYTE ();
12092 switch (op[2] & 0x00)
12094 case 0x00:
12095 goto op_semantics_110;
12096 break;
12098 break;
12099 case 0x97:
12100 GETBYTE ();
12101 switch (op[2] & 0x00)
12103 case 0x00:
12104 goto op_semantics_110;
12105 break;
12107 break;
12108 case 0x98:
12109 GETBYTE ();
12110 switch (op[2] & 0x00)
12112 case 0x00:
12113 goto op_semantics_110;
12114 break;
12116 break;
12117 case 0x99:
12118 GETBYTE ();
12119 switch (op[2] & 0x00)
12121 case 0x00:
12122 goto op_semantics_110;
12123 break;
12125 break;
12126 case 0x9a:
12127 GETBYTE ();
12128 switch (op[2] & 0x00)
12130 case 0x00:
12131 goto op_semantics_110;
12132 break;
12134 break;
12135 case 0x9b:
12136 GETBYTE ();
12137 switch (op[2] & 0x00)
12139 case 0x00:
12140 goto op_semantics_110;
12141 break;
12143 break;
12144 case 0x9c:
12145 GETBYTE ();
12146 switch (op[2] & 0x00)
12148 case 0x00:
12149 goto op_semantics_110;
12150 break;
12152 break;
12153 case 0x9d:
12154 GETBYTE ();
12155 switch (op[2] & 0x00)
12157 case 0x00:
12158 goto op_semantics_110;
12159 break;
12161 break;
12162 case 0x9e:
12163 GETBYTE ();
12164 switch (op[2] & 0x00)
12166 case 0x00:
12167 goto op_semantics_110;
12168 break;
12170 break;
12171 case 0x9f:
12172 GETBYTE ();
12173 switch (op[2] & 0x00)
12175 case 0x00:
12176 goto op_semantics_110;
12177 break;
12179 break;
12180 case 0xa0:
12181 GETBYTE ();
12182 switch (op[2] & 0x00)
12184 case 0x00:
12185 op_semantics_111:
12187 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
12188 #line 722 "rx-decode.opc"
12189 int immmm AU = op[1] & 0x1f;
12190 #line 722 "rx-decode.opc"
12191 int rsrc AU = (op[2] >> 4) & 0x0f;
12192 #line 722 "rx-decode.opc"
12193 int rdst AU = op[2] & 0x0f;
12194 if (trace)
12196 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12197 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
12198 op[0], op[1], op[2]);
12199 printf (" immmm = 0x%x,", immmm);
12200 printf (" rsrc = 0x%x,", rsrc);
12201 printf (" rdst = 0x%x\n", rdst);
12203 SYNTAX("shar #%2, %1, %0");
12204 #line 722 "rx-decode.opc"
12205 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
12209 break;
12211 break;
12212 case 0xa1:
12213 GETBYTE ();
12214 switch (op[2] & 0x00)
12216 case 0x00:
12217 goto op_semantics_111;
12218 break;
12220 break;
12221 case 0xa2:
12222 GETBYTE ();
12223 switch (op[2] & 0x00)
12225 case 0x00:
12226 goto op_semantics_111;
12227 break;
12229 break;
12230 case 0xa3:
12231 GETBYTE ();
12232 switch (op[2] & 0x00)
12234 case 0x00:
12235 goto op_semantics_111;
12236 break;
12238 break;
12239 case 0xa4:
12240 GETBYTE ();
12241 switch (op[2] & 0x00)
12243 case 0x00:
12244 goto op_semantics_111;
12245 break;
12247 break;
12248 case 0xa5:
12249 GETBYTE ();
12250 switch (op[2] & 0x00)
12252 case 0x00:
12253 goto op_semantics_111;
12254 break;
12256 break;
12257 case 0xa6:
12258 GETBYTE ();
12259 switch (op[2] & 0x00)
12261 case 0x00:
12262 goto op_semantics_111;
12263 break;
12265 break;
12266 case 0xa7:
12267 GETBYTE ();
12268 switch (op[2] & 0x00)
12270 case 0x00:
12271 goto op_semantics_111;
12272 break;
12274 break;
12275 case 0xa8:
12276 GETBYTE ();
12277 switch (op[2] & 0x00)
12279 case 0x00:
12280 goto op_semantics_111;
12281 break;
12283 break;
12284 case 0xa9:
12285 GETBYTE ();
12286 switch (op[2] & 0x00)
12288 case 0x00:
12289 goto op_semantics_111;
12290 break;
12292 break;
12293 case 0xaa:
12294 GETBYTE ();
12295 switch (op[2] & 0x00)
12297 case 0x00:
12298 goto op_semantics_111;
12299 break;
12301 break;
12302 case 0xab:
12303 GETBYTE ();
12304 switch (op[2] & 0x00)
12306 case 0x00:
12307 goto op_semantics_111;
12308 break;
12310 break;
12311 case 0xac:
12312 GETBYTE ();
12313 switch (op[2] & 0x00)
12315 case 0x00:
12316 goto op_semantics_111;
12317 break;
12319 break;
12320 case 0xad:
12321 GETBYTE ();
12322 switch (op[2] & 0x00)
12324 case 0x00:
12325 goto op_semantics_111;
12326 break;
12328 break;
12329 case 0xae:
12330 GETBYTE ();
12331 switch (op[2] & 0x00)
12333 case 0x00:
12334 goto op_semantics_111;
12335 break;
12337 break;
12338 case 0xaf:
12339 GETBYTE ();
12340 switch (op[2] & 0x00)
12342 case 0x00:
12343 goto op_semantics_111;
12344 break;
12346 break;
12347 case 0xb0:
12348 GETBYTE ();
12349 switch (op[2] & 0x00)
12351 case 0x00:
12352 goto op_semantics_111;
12353 break;
12355 break;
12356 case 0xb1:
12357 GETBYTE ();
12358 switch (op[2] & 0x00)
12360 case 0x00:
12361 goto op_semantics_111;
12362 break;
12364 break;
12365 case 0xb2:
12366 GETBYTE ();
12367 switch (op[2] & 0x00)
12369 case 0x00:
12370 goto op_semantics_111;
12371 break;
12373 break;
12374 case 0xb3:
12375 GETBYTE ();
12376 switch (op[2] & 0x00)
12378 case 0x00:
12379 goto op_semantics_111;
12380 break;
12382 break;
12383 case 0xb4:
12384 GETBYTE ();
12385 switch (op[2] & 0x00)
12387 case 0x00:
12388 goto op_semantics_111;
12389 break;
12391 break;
12392 case 0xb5:
12393 GETBYTE ();
12394 switch (op[2] & 0x00)
12396 case 0x00:
12397 goto op_semantics_111;
12398 break;
12400 break;
12401 case 0xb6:
12402 GETBYTE ();
12403 switch (op[2] & 0x00)
12405 case 0x00:
12406 goto op_semantics_111;
12407 break;
12409 break;
12410 case 0xb7:
12411 GETBYTE ();
12412 switch (op[2] & 0x00)
12414 case 0x00:
12415 goto op_semantics_111;
12416 break;
12418 break;
12419 case 0xb8:
12420 GETBYTE ();
12421 switch (op[2] & 0x00)
12423 case 0x00:
12424 goto op_semantics_111;
12425 break;
12427 break;
12428 case 0xb9:
12429 GETBYTE ();
12430 switch (op[2] & 0x00)
12432 case 0x00:
12433 goto op_semantics_111;
12434 break;
12436 break;
12437 case 0xba:
12438 GETBYTE ();
12439 switch (op[2] & 0x00)
12441 case 0x00:
12442 goto op_semantics_111;
12443 break;
12445 break;
12446 case 0xbb:
12447 GETBYTE ();
12448 switch (op[2] & 0x00)
12450 case 0x00:
12451 goto op_semantics_111;
12452 break;
12454 break;
12455 case 0xbc:
12456 GETBYTE ();
12457 switch (op[2] & 0x00)
12459 case 0x00:
12460 goto op_semantics_111;
12461 break;
12463 break;
12464 case 0xbd:
12465 GETBYTE ();
12466 switch (op[2] & 0x00)
12468 case 0x00:
12469 goto op_semantics_111;
12470 break;
12472 break;
12473 case 0xbe:
12474 GETBYTE ();
12475 switch (op[2] & 0x00)
12477 case 0x00:
12478 goto op_semantics_111;
12479 break;
12481 break;
12482 case 0xbf:
12483 GETBYTE ();
12484 switch (op[2] & 0x00)
12486 case 0x00:
12487 goto op_semantics_111;
12488 break;
12490 break;
12491 case 0xc0:
12492 GETBYTE ();
12493 switch (op[2] & 0x00)
12495 case 0x00:
12496 op_semantics_112:
12498 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
12499 #line 712 "rx-decode.opc"
12500 int immmm AU = op[1] & 0x1f;
12501 #line 712 "rx-decode.opc"
12502 int rsrc AU = (op[2] >> 4) & 0x0f;
12503 #line 712 "rx-decode.opc"
12504 int rdst AU = op[2] & 0x0f;
12505 if (trace)
12507 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12508 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
12509 op[0], op[1], op[2]);
12510 printf (" immmm = 0x%x,", immmm);
12511 printf (" rsrc = 0x%x,", rsrc);
12512 printf (" rdst = 0x%x\n", rdst);
12514 SYNTAX("shll #%2, %1, %0");
12515 #line 712 "rx-decode.opc"
12516 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
12520 break;
12522 break;
12523 case 0xc1:
12524 GETBYTE ();
12525 switch (op[2] & 0x00)
12527 case 0x00:
12528 goto op_semantics_112;
12529 break;
12531 break;
12532 case 0xc2:
12533 GETBYTE ();
12534 switch (op[2] & 0x00)
12536 case 0x00:
12537 goto op_semantics_112;
12538 break;
12540 break;
12541 case 0xc3:
12542 GETBYTE ();
12543 switch (op[2] & 0x00)
12545 case 0x00:
12546 goto op_semantics_112;
12547 break;
12549 break;
12550 case 0xc4:
12551 GETBYTE ();
12552 switch (op[2] & 0x00)
12554 case 0x00:
12555 goto op_semantics_112;
12556 break;
12558 break;
12559 case 0xc5:
12560 GETBYTE ();
12561 switch (op[2] & 0x00)
12563 case 0x00:
12564 goto op_semantics_112;
12565 break;
12567 break;
12568 case 0xc6:
12569 GETBYTE ();
12570 switch (op[2] & 0x00)
12572 case 0x00:
12573 goto op_semantics_112;
12574 break;
12576 break;
12577 case 0xc7:
12578 GETBYTE ();
12579 switch (op[2] & 0x00)
12581 case 0x00:
12582 goto op_semantics_112;
12583 break;
12585 break;
12586 case 0xc8:
12587 GETBYTE ();
12588 switch (op[2] & 0x00)
12590 case 0x00:
12591 goto op_semantics_112;
12592 break;
12594 break;
12595 case 0xc9:
12596 GETBYTE ();
12597 switch (op[2] & 0x00)
12599 case 0x00:
12600 goto op_semantics_112;
12601 break;
12603 break;
12604 case 0xca:
12605 GETBYTE ();
12606 switch (op[2] & 0x00)
12608 case 0x00:
12609 goto op_semantics_112;
12610 break;
12612 break;
12613 case 0xcb:
12614 GETBYTE ();
12615 switch (op[2] & 0x00)
12617 case 0x00:
12618 goto op_semantics_112;
12619 break;
12621 break;
12622 case 0xcc:
12623 GETBYTE ();
12624 switch (op[2] & 0x00)
12626 case 0x00:
12627 goto op_semantics_112;
12628 break;
12630 break;
12631 case 0xcd:
12632 GETBYTE ();
12633 switch (op[2] & 0x00)
12635 case 0x00:
12636 goto op_semantics_112;
12637 break;
12639 break;
12640 case 0xce:
12641 GETBYTE ();
12642 switch (op[2] & 0x00)
12644 case 0x00:
12645 goto op_semantics_112;
12646 break;
12648 break;
12649 case 0xcf:
12650 GETBYTE ();
12651 switch (op[2] & 0x00)
12653 case 0x00:
12654 goto op_semantics_112;
12655 break;
12657 break;
12658 case 0xd0:
12659 GETBYTE ();
12660 switch (op[2] & 0x00)
12662 case 0x00:
12663 goto op_semantics_112;
12664 break;
12666 break;
12667 case 0xd1:
12668 GETBYTE ();
12669 switch (op[2] & 0x00)
12671 case 0x00:
12672 goto op_semantics_112;
12673 break;
12675 break;
12676 case 0xd2:
12677 GETBYTE ();
12678 switch (op[2] & 0x00)
12680 case 0x00:
12681 goto op_semantics_112;
12682 break;
12684 break;
12685 case 0xd3:
12686 GETBYTE ();
12687 switch (op[2] & 0x00)
12689 case 0x00:
12690 goto op_semantics_112;
12691 break;
12693 break;
12694 case 0xd4:
12695 GETBYTE ();
12696 switch (op[2] & 0x00)
12698 case 0x00:
12699 goto op_semantics_112;
12700 break;
12702 break;
12703 case 0xd5:
12704 GETBYTE ();
12705 switch (op[2] & 0x00)
12707 case 0x00:
12708 goto op_semantics_112;
12709 break;
12711 break;
12712 case 0xd6:
12713 GETBYTE ();
12714 switch (op[2] & 0x00)
12716 case 0x00:
12717 goto op_semantics_112;
12718 break;
12720 break;
12721 case 0xd7:
12722 GETBYTE ();
12723 switch (op[2] & 0x00)
12725 case 0x00:
12726 goto op_semantics_112;
12727 break;
12729 break;
12730 case 0xd8:
12731 GETBYTE ();
12732 switch (op[2] & 0x00)
12734 case 0x00:
12735 goto op_semantics_112;
12736 break;
12738 break;
12739 case 0xd9:
12740 GETBYTE ();
12741 switch (op[2] & 0x00)
12743 case 0x00:
12744 goto op_semantics_112;
12745 break;
12747 break;
12748 case 0xda:
12749 GETBYTE ();
12750 switch (op[2] & 0x00)
12752 case 0x00:
12753 goto op_semantics_112;
12754 break;
12756 break;
12757 case 0xdb:
12758 GETBYTE ();
12759 switch (op[2] & 0x00)
12761 case 0x00:
12762 goto op_semantics_112;
12763 break;
12765 break;
12766 case 0xdc:
12767 GETBYTE ();
12768 switch (op[2] & 0x00)
12770 case 0x00:
12771 goto op_semantics_112;
12772 break;
12774 break;
12775 case 0xdd:
12776 GETBYTE ();
12777 switch (op[2] & 0x00)
12779 case 0x00:
12780 goto op_semantics_112;
12781 break;
12783 break;
12784 case 0xde:
12785 GETBYTE ();
12786 switch (op[2] & 0x00)
12788 case 0x00:
12789 goto op_semantics_112;
12790 break;
12792 break;
12793 case 0xdf:
12794 GETBYTE ();
12795 switch (op[2] & 0x00)
12797 case 0x00:
12798 goto op_semantics_112;
12799 break;
12801 break;
12802 case 0xe0:
12803 GETBYTE ();
12804 switch (op[2] & 0xf0)
12806 case 0x00:
12807 case 0x10:
12808 case 0x20:
12809 case 0x30:
12810 case 0x40:
12811 case 0x50:
12812 case 0x60:
12813 case 0x70:
12814 case 0x80:
12815 case 0x90:
12816 case 0xa0:
12817 case 0xb0:
12818 case 0xc0:
12819 case 0xd0:
12820 case 0xe0:
12821 op_semantics_113:
12823 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
12824 #line 986 "rx-decode.opc"
12825 int bittt AU = op[1] & 0x1f;
12826 #line 986 "rx-decode.opc"
12827 int cond AU = (op[2] >> 4) & 0x0f;
12828 #line 986 "rx-decode.opc"
12829 int rdst AU = op[2] & 0x0f;
12830 if (trace)
12832 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12833 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
12834 op[0], op[1], op[2]);
12835 printf (" bittt = 0x%x,", bittt);
12836 printf (" cond = 0x%x,", cond);
12837 printf (" rdst = 0x%x\n", rdst);
12839 SYNTAX("bm%2 #%1, %0%S0");
12840 #line 986 "rx-decode.opc"
12841 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12843 /*----------------------------------------------------------------------*/
12844 /* CONTROL REGISTERS */
12847 break;
12848 case 0xf0:
12849 op_semantics_114:
12851 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
12852 #line 979 "rx-decode.opc"
12853 int bittt AU = op[1] & 0x1f;
12854 #line 979 "rx-decode.opc"
12855 int rdst AU = op[2] & 0x0f;
12856 if (trace)
12858 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12859 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
12860 op[0], op[1], op[2]);
12861 printf (" bittt = 0x%x,", bittt);
12862 printf (" rdst = 0x%x\n", rdst);
12864 SYNTAX("bnot #%1, %0");
12865 #line 979 "rx-decode.opc"
12866 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12870 break;
12872 break;
12873 case 0xe1:
12874 GETBYTE ();
12875 switch (op[2] & 0xf0)
12877 case 0x00:
12878 case 0x10:
12879 case 0x20:
12880 case 0x30:
12881 case 0x40:
12882 case 0x50:
12883 case 0x60:
12884 case 0x70:
12885 case 0x80:
12886 case 0x90:
12887 case 0xa0:
12888 case 0xb0:
12889 case 0xc0:
12890 case 0xd0:
12891 case 0xe0:
12892 goto op_semantics_113;
12893 break;
12894 case 0xf0:
12895 goto op_semantics_114;
12896 break;
12898 break;
12899 case 0xe2:
12900 GETBYTE ();
12901 switch (op[2] & 0xf0)
12903 case 0x00:
12904 case 0x10:
12905 case 0x20:
12906 case 0x30:
12907 case 0x40:
12908 case 0x50:
12909 case 0x60:
12910 case 0x70:
12911 case 0x80:
12912 case 0x90:
12913 case 0xa0:
12914 case 0xb0:
12915 case 0xc0:
12916 case 0xd0:
12917 case 0xe0:
12918 goto op_semantics_113;
12919 break;
12920 case 0xf0:
12921 goto op_semantics_114;
12922 break;
12924 break;
12925 case 0xe3:
12926 GETBYTE ();
12927 switch (op[2] & 0xf0)
12929 case 0x00:
12930 case 0x10:
12931 case 0x20:
12932 case 0x30:
12933 case 0x40:
12934 case 0x50:
12935 case 0x60:
12936 case 0x70:
12937 case 0x80:
12938 case 0x90:
12939 case 0xa0:
12940 case 0xb0:
12941 case 0xc0:
12942 case 0xd0:
12943 case 0xe0:
12944 goto op_semantics_113;
12945 break;
12946 case 0xf0:
12947 goto op_semantics_114;
12948 break;
12950 break;
12951 case 0xe4:
12952 GETBYTE ();
12953 switch (op[2] & 0xf0)
12955 case 0x00:
12956 case 0x10:
12957 case 0x20:
12958 case 0x30:
12959 case 0x40:
12960 case 0x50:
12961 case 0x60:
12962 case 0x70:
12963 case 0x80:
12964 case 0x90:
12965 case 0xa0:
12966 case 0xb0:
12967 case 0xc0:
12968 case 0xd0:
12969 case 0xe0:
12970 goto op_semantics_113;
12971 break;
12972 case 0xf0:
12973 goto op_semantics_114;
12974 break;
12976 break;
12977 case 0xe5:
12978 GETBYTE ();
12979 switch (op[2] & 0xf0)
12981 case 0x00:
12982 case 0x10:
12983 case 0x20:
12984 case 0x30:
12985 case 0x40:
12986 case 0x50:
12987 case 0x60:
12988 case 0x70:
12989 case 0x80:
12990 case 0x90:
12991 case 0xa0:
12992 case 0xb0:
12993 case 0xc0:
12994 case 0xd0:
12995 case 0xe0:
12996 goto op_semantics_113;
12997 break;
12998 case 0xf0:
12999 goto op_semantics_114;
13000 break;
13002 break;
13003 case 0xe6:
13004 GETBYTE ();
13005 switch (op[2] & 0xf0)
13007 case 0x00:
13008 case 0x10:
13009 case 0x20:
13010 case 0x30:
13011 case 0x40:
13012 case 0x50:
13013 case 0x60:
13014 case 0x70:
13015 case 0x80:
13016 case 0x90:
13017 case 0xa0:
13018 case 0xb0:
13019 case 0xc0:
13020 case 0xd0:
13021 case 0xe0:
13022 goto op_semantics_113;
13023 break;
13024 case 0xf0:
13025 goto op_semantics_114;
13026 break;
13028 break;
13029 case 0xe7:
13030 GETBYTE ();
13031 switch (op[2] & 0xf0)
13033 case 0x00:
13034 case 0x10:
13035 case 0x20:
13036 case 0x30:
13037 case 0x40:
13038 case 0x50:
13039 case 0x60:
13040 case 0x70:
13041 case 0x80:
13042 case 0x90:
13043 case 0xa0:
13044 case 0xb0:
13045 case 0xc0:
13046 case 0xd0:
13047 case 0xe0:
13048 goto op_semantics_113;
13049 break;
13050 case 0xf0:
13051 goto op_semantics_114;
13052 break;
13054 break;
13055 case 0xe8:
13056 GETBYTE ();
13057 switch (op[2] & 0xf0)
13059 case 0x00:
13060 case 0x10:
13061 case 0x20:
13062 case 0x30:
13063 case 0x40:
13064 case 0x50:
13065 case 0x60:
13066 case 0x70:
13067 case 0x80:
13068 case 0x90:
13069 case 0xa0:
13070 case 0xb0:
13071 case 0xc0:
13072 case 0xd0:
13073 case 0xe0:
13074 goto op_semantics_113;
13075 break;
13076 case 0xf0:
13077 goto op_semantics_114;
13078 break;
13080 break;
13081 case 0xe9:
13082 GETBYTE ();
13083 switch (op[2] & 0xf0)
13085 case 0x00:
13086 case 0x10:
13087 case 0x20:
13088 case 0x30:
13089 case 0x40:
13090 case 0x50:
13091 case 0x60:
13092 case 0x70:
13093 case 0x80:
13094 case 0x90:
13095 case 0xa0:
13096 case 0xb0:
13097 case 0xc0:
13098 case 0xd0:
13099 case 0xe0:
13100 goto op_semantics_113;
13101 break;
13102 case 0xf0:
13103 goto op_semantics_114;
13104 break;
13106 break;
13107 case 0xea:
13108 GETBYTE ();
13109 switch (op[2] & 0xf0)
13111 case 0x00:
13112 case 0x10:
13113 case 0x20:
13114 case 0x30:
13115 case 0x40:
13116 case 0x50:
13117 case 0x60:
13118 case 0x70:
13119 case 0x80:
13120 case 0x90:
13121 case 0xa0:
13122 case 0xb0:
13123 case 0xc0:
13124 case 0xd0:
13125 case 0xe0:
13126 goto op_semantics_113;
13127 break;
13128 case 0xf0:
13129 goto op_semantics_114;
13130 break;
13132 break;
13133 case 0xeb:
13134 GETBYTE ();
13135 switch (op[2] & 0xf0)
13137 case 0x00:
13138 case 0x10:
13139 case 0x20:
13140 case 0x30:
13141 case 0x40:
13142 case 0x50:
13143 case 0x60:
13144 case 0x70:
13145 case 0x80:
13146 case 0x90:
13147 case 0xa0:
13148 case 0xb0:
13149 case 0xc0:
13150 case 0xd0:
13151 case 0xe0:
13152 goto op_semantics_113;
13153 break;
13154 case 0xf0:
13155 goto op_semantics_114;
13156 break;
13158 break;
13159 case 0xec:
13160 GETBYTE ();
13161 switch (op[2] & 0xf0)
13163 case 0x00:
13164 case 0x10:
13165 case 0x20:
13166 case 0x30:
13167 case 0x40:
13168 case 0x50:
13169 case 0x60:
13170 case 0x70:
13171 case 0x80:
13172 case 0x90:
13173 case 0xa0:
13174 case 0xb0:
13175 case 0xc0:
13176 case 0xd0:
13177 case 0xe0:
13178 goto op_semantics_113;
13179 break;
13180 case 0xf0:
13181 goto op_semantics_114;
13182 break;
13184 break;
13185 case 0xed:
13186 GETBYTE ();
13187 switch (op[2] & 0xf0)
13189 case 0x00:
13190 case 0x10:
13191 case 0x20:
13192 case 0x30:
13193 case 0x40:
13194 case 0x50:
13195 case 0x60:
13196 case 0x70:
13197 case 0x80:
13198 case 0x90:
13199 case 0xa0:
13200 case 0xb0:
13201 case 0xc0:
13202 case 0xd0:
13203 case 0xe0:
13204 goto op_semantics_113;
13205 break;
13206 case 0xf0:
13207 goto op_semantics_114;
13208 break;
13210 break;
13211 case 0xee:
13212 GETBYTE ();
13213 switch (op[2] & 0xf0)
13215 case 0x00:
13216 case 0x10:
13217 case 0x20:
13218 case 0x30:
13219 case 0x40:
13220 case 0x50:
13221 case 0x60:
13222 case 0x70:
13223 case 0x80:
13224 case 0x90:
13225 case 0xa0:
13226 case 0xb0:
13227 case 0xc0:
13228 case 0xd0:
13229 case 0xe0:
13230 goto op_semantics_113;
13231 break;
13232 case 0xf0:
13233 goto op_semantics_114;
13234 break;
13236 break;
13237 case 0xef:
13238 GETBYTE ();
13239 switch (op[2] & 0xf0)
13241 case 0x00:
13242 case 0x10:
13243 case 0x20:
13244 case 0x30:
13245 case 0x40:
13246 case 0x50:
13247 case 0x60:
13248 case 0x70:
13249 case 0x80:
13250 case 0x90:
13251 case 0xa0:
13252 case 0xb0:
13253 case 0xc0:
13254 case 0xd0:
13255 case 0xe0:
13256 goto op_semantics_113;
13257 break;
13258 case 0xf0:
13259 goto op_semantics_114;
13260 break;
13262 break;
13263 case 0xf0:
13264 GETBYTE ();
13265 switch (op[2] & 0xf0)
13267 case 0x00:
13268 case 0x10:
13269 case 0x20:
13270 case 0x30:
13271 case 0x40:
13272 case 0x50:
13273 case 0x60:
13274 case 0x70:
13275 case 0x80:
13276 case 0x90:
13277 case 0xa0:
13278 case 0xb0:
13279 case 0xc0:
13280 case 0xd0:
13281 case 0xe0:
13282 goto op_semantics_113;
13283 break;
13284 case 0xf0:
13285 goto op_semantics_114;
13286 break;
13288 break;
13289 case 0xf1:
13290 GETBYTE ();
13291 switch (op[2] & 0xf0)
13293 case 0x00:
13294 case 0x10:
13295 case 0x20:
13296 case 0x30:
13297 case 0x40:
13298 case 0x50:
13299 case 0x60:
13300 case 0x70:
13301 case 0x80:
13302 case 0x90:
13303 case 0xa0:
13304 case 0xb0:
13305 case 0xc0:
13306 case 0xd0:
13307 case 0xe0:
13308 goto op_semantics_113;
13309 break;
13310 case 0xf0:
13311 goto op_semantics_114;
13312 break;
13314 break;
13315 case 0xf2:
13316 GETBYTE ();
13317 switch (op[2] & 0xf0)
13319 case 0x00:
13320 case 0x10:
13321 case 0x20:
13322 case 0x30:
13323 case 0x40:
13324 case 0x50:
13325 case 0x60:
13326 case 0x70:
13327 case 0x80:
13328 case 0x90:
13329 case 0xa0:
13330 case 0xb0:
13331 case 0xc0:
13332 case 0xd0:
13333 case 0xe0:
13334 goto op_semantics_113;
13335 break;
13336 case 0xf0:
13337 goto op_semantics_114;
13338 break;
13340 break;
13341 case 0xf3:
13342 GETBYTE ();
13343 switch (op[2] & 0xf0)
13345 case 0x00:
13346 case 0x10:
13347 case 0x20:
13348 case 0x30:
13349 case 0x40:
13350 case 0x50:
13351 case 0x60:
13352 case 0x70:
13353 case 0x80:
13354 case 0x90:
13355 case 0xa0:
13356 case 0xb0:
13357 case 0xc0:
13358 case 0xd0:
13359 case 0xe0:
13360 goto op_semantics_113;
13361 break;
13362 case 0xf0:
13363 goto op_semantics_114;
13364 break;
13366 break;
13367 case 0xf4:
13368 GETBYTE ();
13369 switch (op[2] & 0xf0)
13371 case 0x00:
13372 case 0x10:
13373 case 0x20:
13374 case 0x30:
13375 case 0x40:
13376 case 0x50:
13377 case 0x60:
13378 case 0x70:
13379 case 0x80:
13380 case 0x90:
13381 case 0xa0:
13382 case 0xb0:
13383 case 0xc0:
13384 case 0xd0:
13385 case 0xe0:
13386 goto op_semantics_113;
13387 break;
13388 case 0xf0:
13389 goto op_semantics_114;
13390 break;
13392 break;
13393 case 0xf5:
13394 GETBYTE ();
13395 switch (op[2] & 0xf0)
13397 case 0x00:
13398 case 0x10:
13399 case 0x20:
13400 case 0x30:
13401 case 0x40:
13402 case 0x50:
13403 case 0x60:
13404 case 0x70:
13405 case 0x80:
13406 case 0x90:
13407 case 0xa0:
13408 case 0xb0:
13409 case 0xc0:
13410 case 0xd0:
13411 case 0xe0:
13412 goto op_semantics_113;
13413 break;
13414 case 0xf0:
13415 goto op_semantics_114;
13416 break;
13418 break;
13419 case 0xf6:
13420 GETBYTE ();
13421 switch (op[2] & 0xf0)
13423 case 0x00:
13424 case 0x10:
13425 case 0x20:
13426 case 0x30:
13427 case 0x40:
13428 case 0x50:
13429 case 0x60:
13430 case 0x70:
13431 case 0x80:
13432 case 0x90:
13433 case 0xa0:
13434 case 0xb0:
13435 case 0xc0:
13436 case 0xd0:
13437 case 0xe0:
13438 goto op_semantics_113;
13439 break;
13440 case 0xf0:
13441 goto op_semantics_114;
13442 break;
13444 break;
13445 case 0xf7:
13446 GETBYTE ();
13447 switch (op[2] & 0xf0)
13449 case 0x00:
13450 case 0x10:
13451 case 0x20:
13452 case 0x30:
13453 case 0x40:
13454 case 0x50:
13455 case 0x60:
13456 case 0x70:
13457 case 0x80:
13458 case 0x90:
13459 case 0xa0:
13460 case 0xb0:
13461 case 0xc0:
13462 case 0xd0:
13463 case 0xe0:
13464 goto op_semantics_113;
13465 break;
13466 case 0xf0:
13467 goto op_semantics_114;
13468 break;
13470 break;
13471 case 0xf8:
13472 GETBYTE ();
13473 switch (op[2] & 0xf0)
13475 case 0x00:
13476 case 0x10:
13477 case 0x20:
13478 case 0x30:
13479 case 0x40:
13480 case 0x50:
13481 case 0x60:
13482 case 0x70:
13483 case 0x80:
13484 case 0x90:
13485 case 0xa0:
13486 case 0xb0:
13487 case 0xc0:
13488 case 0xd0:
13489 case 0xe0:
13490 goto op_semantics_113;
13491 break;
13492 case 0xf0:
13493 goto op_semantics_114;
13494 break;
13496 break;
13497 case 0xf9:
13498 GETBYTE ();
13499 switch (op[2] & 0xf0)
13501 case 0x00:
13502 case 0x10:
13503 case 0x20:
13504 case 0x30:
13505 case 0x40:
13506 case 0x50:
13507 case 0x60:
13508 case 0x70:
13509 case 0x80:
13510 case 0x90:
13511 case 0xa0:
13512 case 0xb0:
13513 case 0xc0:
13514 case 0xd0:
13515 case 0xe0:
13516 goto op_semantics_113;
13517 break;
13518 case 0xf0:
13519 goto op_semantics_114;
13520 break;
13522 break;
13523 case 0xfa:
13524 GETBYTE ();
13525 switch (op[2] & 0xf0)
13527 case 0x00:
13528 case 0x10:
13529 case 0x20:
13530 case 0x30:
13531 case 0x40:
13532 case 0x50:
13533 case 0x60:
13534 case 0x70:
13535 case 0x80:
13536 case 0x90:
13537 case 0xa0:
13538 case 0xb0:
13539 case 0xc0:
13540 case 0xd0:
13541 case 0xe0:
13542 goto op_semantics_113;
13543 break;
13544 case 0xf0:
13545 goto op_semantics_114;
13546 break;
13548 break;
13549 case 0xfb:
13550 GETBYTE ();
13551 switch (op[2] & 0xf0)
13553 case 0x00:
13554 case 0x10:
13555 case 0x20:
13556 case 0x30:
13557 case 0x40:
13558 case 0x50:
13559 case 0x60:
13560 case 0x70:
13561 case 0x80:
13562 case 0x90:
13563 case 0xa0:
13564 case 0xb0:
13565 case 0xc0:
13566 case 0xd0:
13567 case 0xe0:
13568 goto op_semantics_113;
13569 break;
13570 case 0xf0:
13571 goto op_semantics_114;
13572 break;
13574 break;
13575 case 0xfc:
13576 GETBYTE ();
13577 switch (op[2] & 0xf0)
13579 case 0x00:
13580 case 0x10:
13581 case 0x20:
13582 case 0x30:
13583 case 0x40:
13584 case 0x50:
13585 case 0x60:
13586 case 0x70:
13587 case 0x80:
13588 case 0x90:
13589 case 0xa0:
13590 case 0xb0:
13591 case 0xc0:
13592 case 0xd0:
13593 case 0xe0:
13594 goto op_semantics_113;
13595 break;
13596 case 0xf0:
13597 goto op_semantics_114;
13598 break;
13600 break;
13601 case 0xfd:
13602 GETBYTE ();
13603 switch (op[2] & 0xf0)
13605 case 0x00:
13606 case 0x10:
13607 case 0x20:
13608 case 0x30:
13609 case 0x40:
13610 case 0x50:
13611 case 0x60:
13612 case 0x70:
13613 case 0x80:
13614 case 0x90:
13615 case 0xa0:
13616 case 0xb0:
13617 case 0xc0:
13618 case 0xd0:
13619 case 0xe0:
13620 goto op_semantics_113;
13621 break;
13622 case 0xf0:
13623 goto op_semantics_114;
13624 break;
13626 break;
13627 case 0xfe:
13628 GETBYTE ();
13629 switch (op[2] & 0xf0)
13631 case 0x00:
13632 case 0x10:
13633 case 0x20:
13634 case 0x30:
13635 case 0x40:
13636 case 0x50:
13637 case 0x60:
13638 case 0x70:
13639 case 0x80:
13640 case 0x90:
13641 case 0xa0:
13642 case 0xb0:
13643 case 0xc0:
13644 case 0xd0:
13645 case 0xe0:
13646 goto op_semantics_113;
13647 break;
13648 case 0xf0:
13649 goto op_semantics_114;
13650 break;
13652 break;
13653 case 0xff:
13654 GETBYTE ();
13655 switch (op[2] & 0xf0)
13657 case 0x00:
13658 case 0x10:
13659 case 0x20:
13660 case 0x30:
13661 case 0x40:
13662 case 0x50:
13663 case 0x60:
13664 case 0x70:
13665 case 0x80:
13666 case 0x90:
13667 case 0xa0:
13668 case 0xb0:
13669 case 0xc0:
13670 case 0xd0:
13671 case 0xe0:
13672 goto op_semantics_113;
13673 break;
13674 case 0xf0:
13675 goto op_semantics_114;
13676 break;
13678 break;
13679 default: UNSUPPORTED(); break;
13681 break;
13682 case 0xfe:
13683 GETBYTE ();
13684 switch (op[1] & 0xff)
13686 case 0x00:
13687 GETBYTE ();
13688 switch (op[2] & 0x00)
13690 case 0x00:
13691 op_semantics_115:
13693 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
13694 #line 338 "rx-decode.opc"
13695 int sz AU = (op[1] >> 4) & 0x03;
13696 #line 338 "rx-decode.opc"
13697 int isrc AU = op[1] & 0x0f;
13698 #line 338 "rx-decode.opc"
13699 int bsrc AU = (op[2] >> 4) & 0x0f;
13700 #line 338 "rx-decode.opc"
13701 int rdst AU = op[2] & 0x0f;
13702 if (trace)
13704 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13705 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
13706 op[0], op[1], op[2]);
13707 printf (" sz = 0x%x,", sz);
13708 printf (" isrc = 0x%x,", isrc);
13709 printf (" bsrc = 0x%x,", bsrc);
13710 printf (" rdst = 0x%x\n", rdst);
13712 SYNTAX("mov%s %0, [%1, %2]");
13713 #line 338 "rx-decode.opc"
13714 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13717 break;
13719 break;
13720 case 0x01:
13721 GETBYTE ();
13722 switch (op[2] & 0x00)
13724 case 0x00:
13725 goto op_semantics_115;
13726 break;
13728 break;
13729 case 0x02:
13730 GETBYTE ();
13731 switch (op[2] & 0x00)
13733 case 0x00:
13734 goto op_semantics_115;
13735 break;
13737 break;
13738 case 0x03:
13739 GETBYTE ();
13740 switch (op[2] & 0x00)
13742 case 0x00:
13743 goto op_semantics_115;
13744 break;
13746 break;
13747 case 0x04:
13748 GETBYTE ();
13749 switch (op[2] & 0x00)
13751 case 0x00:
13752 goto op_semantics_115;
13753 break;
13755 break;
13756 case 0x05:
13757 GETBYTE ();
13758 switch (op[2] & 0x00)
13760 case 0x00:
13761 goto op_semantics_115;
13762 break;
13764 break;
13765 case 0x06:
13766 GETBYTE ();
13767 switch (op[2] & 0x00)
13769 case 0x00:
13770 goto op_semantics_115;
13771 break;
13773 break;
13774 case 0x07:
13775 GETBYTE ();
13776 switch (op[2] & 0x00)
13778 case 0x00:
13779 goto op_semantics_115;
13780 break;
13782 break;
13783 case 0x08:
13784 GETBYTE ();
13785 switch (op[2] & 0x00)
13787 case 0x00:
13788 goto op_semantics_115;
13789 break;
13791 break;
13792 case 0x09:
13793 GETBYTE ();
13794 switch (op[2] & 0x00)
13796 case 0x00:
13797 goto op_semantics_115;
13798 break;
13800 break;
13801 case 0x0a:
13802 GETBYTE ();
13803 switch (op[2] & 0x00)
13805 case 0x00:
13806 goto op_semantics_115;
13807 break;
13809 break;
13810 case 0x0b:
13811 GETBYTE ();
13812 switch (op[2] & 0x00)
13814 case 0x00:
13815 goto op_semantics_115;
13816 break;
13818 break;
13819 case 0x0c:
13820 GETBYTE ();
13821 switch (op[2] & 0x00)
13823 case 0x00:
13824 goto op_semantics_115;
13825 break;
13827 break;
13828 case 0x0d:
13829 GETBYTE ();
13830 switch (op[2] & 0x00)
13832 case 0x00:
13833 goto op_semantics_115;
13834 break;
13836 break;
13837 case 0x0e:
13838 GETBYTE ();
13839 switch (op[2] & 0x00)
13841 case 0x00:
13842 goto op_semantics_115;
13843 break;
13845 break;
13846 case 0x0f:
13847 GETBYTE ();
13848 switch (op[2] & 0x00)
13850 case 0x00:
13851 goto op_semantics_115;
13852 break;
13854 break;
13855 case 0x10:
13856 GETBYTE ();
13857 switch (op[2] & 0x00)
13859 case 0x00:
13860 goto op_semantics_115;
13861 break;
13863 break;
13864 case 0x11:
13865 GETBYTE ();
13866 switch (op[2] & 0x00)
13868 case 0x00:
13869 goto op_semantics_115;
13870 break;
13872 break;
13873 case 0x12:
13874 GETBYTE ();
13875 switch (op[2] & 0x00)
13877 case 0x00:
13878 goto op_semantics_115;
13879 break;
13881 break;
13882 case 0x13:
13883 GETBYTE ();
13884 switch (op[2] & 0x00)
13886 case 0x00:
13887 goto op_semantics_115;
13888 break;
13890 break;
13891 case 0x14:
13892 GETBYTE ();
13893 switch (op[2] & 0x00)
13895 case 0x00:
13896 goto op_semantics_115;
13897 break;
13899 break;
13900 case 0x15:
13901 GETBYTE ();
13902 switch (op[2] & 0x00)
13904 case 0x00:
13905 goto op_semantics_115;
13906 break;
13908 break;
13909 case 0x16:
13910 GETBYTE ();
13911 switch (op[2] & 0x00)
13913 case 0x00:
13914 goto op_semantics_115;
13915 break;
13917 break;
13918 case 0x17:
13919 GETBYTE ();
13920 switch (op[2] & 0x00)
13922 case 0x00:
13923 goto op_semantics_115;
13924 break;
13926 break;
13927 case 0x18:
13928 GETBYTE ();
13929 switch (op[2] & 0x00)
13931 case 0x00:
13932 goto op_semantics_115;
13933 break;
13935 break;
13936 case 0x19:
13937 GETBYTE ();
13938 switch (op[2] & 0x00)
13940 case 0x00:
13941 goto op_semantics_115;
13942 break;
13944 break;
13945 case 0x1a:
13946 GETBYTE ();
13947 switch (op[2] & 0x00)
13949 case 0x00:
13950 goto op_semantics_115;
13951 break;
13953 break;
13954 case 0x1b:
13955 GETBYTE ();
13956 switch (op[2] & 0x00)
13958 case 0x00:
13959 goto op_semantics_115;
13960 break;
13962 break;
13963 case 0x1c:
13964 GETBYTE ();
13965 switch (op[2] & 0x00)
13967 case 0x00:
13968 goto op_semantics_115;
13969 break;
13971 break;
13972 case 0x1d:
13973 GETBYTE ();
13974 switch (op[2] & 0x00)
13976 case 0x00:
13977 goto op_semantics_115;
13978 break;
13980 break;
13981 case 0x1e:
13982 GETBYTE ();
13983 switch (op[2] & 0x00)
13985 case 0x00:
13986 goto op_semantics_115;
13987 break;
13989 break;
13990 case 0x1f:
13991 GETBYTE ();
13992 switch (op[2] & 0x00)
13994 case 0x00:
13995 goto op_semantics_115;
13996 break;
13998 break;
13999 case 0x20:
14000 GETBYTE ();
14001 switch (op[2] & 0x00)
14003 case 0x00:
14004 goto op_semantics_115;
14005 break;
14007 break;
14008 case 0x21:
14009 GETBYTE ();
14010 switch (op[2] & 0x00)
14012 case 0x00:
14013 goto op_semantics_115;
14014 break;
14016 break;
14017 case 0x22:
14018 GETBYTE ();
14019 switch (op[2] & 0x00)
14021 case 0x00:
14022 goto op_semantics_115;
14023 break;
14025 break;
14026 case 0x23:
14027 GETBYTE ();
14028 switch (op[2] & 0x00)
14030 case 0x00:
14031 goto op_semantics_115;
14032 break;
14034 break;
14035 case 0x24:
14036 GETBYTE ();
14037 switch (op[2] & 0x00)
14039 case 0x00:
14040 goto op_semantics_115;
14041 break;
14043 break;
14044 case 0x25:
14045 GETBYTE ();
14046 switch (op[2] & 0x00)
14048 case 0x00:
14049 goto op_semantics_115;
14050 break;
14052 break;
14053 case 0x26:
14054 GETBYTE ();
14055 switch (op[2] & 0x00)
14057 case 0x00:
14058 goto op_semantics_115;
14059 break;
14061 break;
14062 case 0x27:
14063 GETBYTE ();
14064 switch (op[2] & 0x00)
14066 case 0x00:
14067 goto op_semantics_115;
14068 break;
14070 break;
14071 case 0x28:
14072 GETBYTE ();
14073 switch (op[2] & 0x00)
14075 case 0x00:
14076 goto op_semantics_115;
14077 break;
14079 break;
14080 case 0x29:
14081 GETBYTE ();
14082 switch (op[2] & 0x00)
14084 case 0x00:
14085 goto op_semantics_115;
14086 break;
14088 break;
14089 case 0x2a:
14090 GETBYTE ();
14091 switch (op[2] & 0x00)
14093 case 0x00:
14094 goto op_semantics_115;
14095 break;
14097 break;
14098 case 0x2b:
14099 GETBYTE ();
14100 switch (op[2] & 0x00)
14102 case 0x00:
14103 goto op_semantics_115;
14104 break;
14106 break;
14107 case 0x2c:
14108 GETBYTE ();
14109 switch (op[2] & 0x00)
14111 case 0x00:
14112 goto op_semantics_115;
14113 break;
14115 break;
14116 case 0x2d:
14117 GETBYTE ();
14118 switch (op[2] & 0x00)
14120 case 0x00:
14121 goto op_semantics_115;
14122 break;
14124 break;
14125 case 0x2e:
14126 GETBYTE ();
14127 switch (op[2] & 0x00)
14129 case 0x00:
14130 goto op_semantics_115;
14131 break;
14133 break;
14134 case 0x2f:
14135 GETBYTE ();
14136 switch (op[2] & 0x00)
14138 case 0x00:
14139 goto op_semantics_115;
14140 break;
14142 break;
14143 case 0x40:
14144 GETBYTE ();
14145 switch (op[2] & 0x00)
14147 case 0x00:
14148 op_semantics_116:
14150 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
14151 #line 335 "rx-decode.opc"
14152 int sz AU = (op[1] >> 4) & 0x03;
14153 #line 335 "rx-decode.opc"
14154 int isrc AU = op[1] & 0x0f;
14155 #line 335 "rx-decode.opc"
14156 int bsrc AU = (op[2] >> 4) & 0x0f;
14157 #line 335 "rx-decode.opc"
14158 int rdst AU = op[2] & 0x0f;
14159 if (trace)
14161 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14162 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
14163 op[0], op[1], op[2]);
14164 printf (" sz = 0x%x,", sz);
14165 printf (" isrc = 0x%x,", isrc);
14166 printf (" bsrc = 0x%x,", bsrc);
14167 printf (" rdst = 0x%x\n", rdst);
14169 SYNTAX("mov%s [%1, %2], %0");
14170 #line 335 "rx-decode.opc"
14171 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14174 break;
14176 break;
14177 case 0x41:
14178 GETBYTE ();
14179 switch (op[2] & 0x00)
14181 case 0x00:
14182 goto op_semantics_116;
14183 break;
14185 break;
14186 case 0x42:
14187 GETBYTE ();
14188 switch (op[2] & 0x00)
14190 case 0x00:
14191 goto op_semantics_116;
14192 break;
14194 break;
14195 case 0x43:
14196 GETBYTE ();
14197 switch (op[2] & 0x00)
14199 case 0x00:
14200 goto op_semantics_116;
14201 break;
14203 break;
14204 case 0x44:
14205 GETBYTE ();
14206 switch (op[2] & 0x00)
14208 case 0x00:
14209 goto op_semantics_116;
14210 break;
14212 break;
14213 case 0x45:
14214 GETBYTE ();
14215 switch (op[2] & 0x00)
14217 case 0x00:
14218 goto op_semantics_116;
14219 break;
14221 break;
14222 case 0x46:
14223 GETBYTE ();
14224 switch (op[2] & 0x00)
14226 case 0x00:
14227 goto op_semantics_116;
14228 break;
14230 break;
14231 case 0x47:
14232 GETBYTE ();
14233 switch (op[2] & 0x00)
14235 case 0x00:
14236 goto op_semantics_116;
14237 break;
14239 break;
14240 case 0x48:
14241 GETBYTE ();
14242 switch (op[2] & 0x00)
14244 case 0x00:
14245 goto op_semantics_116;
14246 break;
14248 break;
14249 case 0x49:
14250 GETBYTE ();
14251 switch (op[2] & 0x00)
14253 case 0x00:
14254 goto op_semantics_116;
14255 break;
14257 break;
14258 case 0x4a:
14259 GETBYTE ();
14260 switch (op[2] & 0x00)
14262 case 0x00:
14263 goto op_semantics_116;
14264 break;
14266 break;
14267 case 0x4b:
14268 GETBYTE ();
14269 switch (op[2] & 0x00)
14271 case 0x00:
14272 goto op_semantics_116;
14273 break;
14275 break;
14276 case 0x4c:
14277 GETBYTE ();
14278 switch (op[2] & 0x00)
14280 case 0x00:
14281 goto op_semantics_116;
14282 break;
14284 break;
14285 case 0x4d:
14286 GETBYTE ();
14287 switch (op[2] & 0x00)
14289 case 0x00:
14290 goto op_semantics_116;
14291 break;
14293 break;
14294 case 0x4e:
14295 GETBYTE ();
14296 switch (op[2] & 0x00)
14298 case 0x00:
14299 goto op_semantics_116;
14300 break;
14302 break;
14303 case 0x4f:
14304 GETBYTE ();
14305 switch (op[2] & 0x00)
14307 case 0x00:
14308 goto op_semantics_116;
14309 break;
14311 break;
14312 case 0x50:
14313 GETBYTE ();
14314 switch (op[2] & 0x00)
14316 case 0x00:
14317 goto op_semantics_116;
14318 break;
14320 break;
14321 case 0x51:
14322 GETBYTE ();
14323 switch (op[2] & 0x00)
14325 case 0x00:
14326 goto op_semantics_116;
14327 break;
14329 break;
14330 case 0x52:
14331 GETBYTE ();
14332 switch (op[2] & 0x00)
14334 case 0x00:
14335 goto op_semantics_116;
14336 break;
14338 break;
14339 case 0x53:
14340 GETBYTE ();
14341 switch (op[2] & 0x00)
14343 case 0x00:
14344 goto op_semantics_116;
14345 break;
14347 break;
14348 case 0x54:
14349 GETBYTE ();
14350 switch (op[2] & 0x00)
14352 case 0x00:
14353 goto op_semantics_116;
14354 break;
14356 break;
14357 case 0x55:
14358 GETBYTE ();
14359 switch (op[2] & 0x00)
14361 case 0x00:
14362 goto op_semantics_116;
14363 break;
14365 break;
14366 case 0x56:
14367 GETBYTE ();
14368 switch (op[2] & 0x00)
14370 case 0x00:
14371 goto op_semantics_116;
14372 break;
14374 break;
14375 case 0x57:
14376 GETBYTE ();
14377 switch (op[2] & 0x00)
14379 case 0x00:
14380 goto op_semantics_116;
14381 break;
14383 break;
14384 case 0x58:
14385 GETBYTE ();
14386 switch (op[2] & 0x00)
14388 case 0x00:
14389 goto op_semantics_116;
14390 break;
14392 break;
14393 case 0x59:
14394 GETBYTE ();
14395 switch (op[2] & 0x00)
14397 case 0x00:
14398 goto op_semantics_116;
14399 break;
14401 break;
14402 case 0x5a:
14403 GETBYTE ();
14404 switch (op[2] & 0x00)
14406 case 0x00:
14407 goto op_semantics_116;
14408 break;
14410 break;
14411 case 0x5b:
14412 GETBYTE ();
14413 switch (op[2] & 0x00)
14415 case 0x00:
14416 goto op_semantics_116;
14417 break;
14419 break;
14420 case 0x5c:
14421 GETBYTE ();
14422 switch (op[2] & 0x00)
14424 case 0x00:
14425 goto op_semantics_116;
14426 break;
14428 break;
14429 case 0x5d:
14430 GETBYTE ();
14431 switch (op[2] & 0x00)
14433 case 0x00:
14434 goto op_semantics_116;
14435 break;
14437 break;
14438 case 0x5e:
14439 GETBYTE ();
14440 switch (op[2] & 0x00)
14442 case 0x00:
14443 goto op_semantics_116;
14444 break;
14446 break;
14447 case 0x5f:
14448 GETBYTE ();
14449 switch (op[2] & 0x00)
14451 case 0x00:
14452 goto op_semantics_116;
14453 break;
14455 break;
14456 case 0x60:
14457 GETBYTE ();
14458 switch (op[2] & 0x00)
14460 case 0x00:
14461 goto op_semantics_116;
14462 break;
14464 break;
14465 case 0x61:
14466 GETBYTE ();
14467 switch (op[2] & 0x00)
14469 case 0x00:
14470 goto op_semantics_116;
14471 break;
14473 break;
14474 case 0x62:
14475 GETBYTE ();
14476 switch (op[2] & 0x00)
14478 case 0x00:
14479 goto op_semantics_116;
14480 break;
14482 break;
14483 case 0x63:
14484 GETBYTE ();
14485 switch (op[2] & 0x00)
14487 case 0x00:
14488 goto op_semantics_116;
14489 break;
14491 break;
14492 case 0x64:
14493 GETBYTE ();
14494 switch (op[2] & 0x00)
14496 case 0x00:
14497 goto op_semantics_116;
14498 break;
14500 break;
14501 case 0x65:
14502 GETBYTE ();
14503 switch (op[2] & 0x00)
14505 case 0x00:
14506 goto op_semantics_116;
14507 break;
14509 break;
14510 case 0x66:
14511 GETBYTE ();
14512 switch (op[2] & 0x00)
14514 case 0x00:
14515 goto op_semantics_116;
14516 break;
14518 break;
14519 case 0x67:
14520 GETBYTE ();
14521 switch (op[2] & 0x00)
14523 case 0x00:
14524 goto op_semantics_116;
14525 break;
14527 break;
14528 case 0x68:
14529 GETBYTE ();
14530 switch (op[2] & 0x00)
14532 case 0x00:
14533 goto op_semantics_116;
14534 break;
14536 break;
14537 case 0x69:
14538 GETBYTE ();
14539 switch (op[2] & 0x00)
14541 case 0x00:
14542 goto op_semantics_116;
14543 break;
14545 break;
14546 case 0x6a:
14547 GETBYTE ();
14548 switch (op[2] & 0x00)
14550 case 0x00:
14551 goto op_semantics_116;
14552 break;
14554 break;
14555 case 0x6b:
14556 GETBYTE ();
14557 switch (op[2] & 0x00)
14559 case 0x00:
14560 goto op_semantics_116;
14561 break;
14563 break;
14564 case 0x6c:
14565 GETBYTE ();
14566 switch (op[2] & 0x00)
14568 case 0x00:
14569 goto op_semantics_116;
14570 break;
14572 break;
14573 case 0x6d:
14574 GETBYTE ();
14575 switch (op[2] & 0x00)
14577 case 0x00:
14578 goto op_semantics_116;
14579 break;
14581 break;
14582 case 0x6e:
14583 GETBYTE ();
14584 switch (op[2] & 0x00)
14586 case 0x00:
14587 goto op_semantics_116;
14588 break;
14590 break;
14591 case 0x6f:
14592 GETBYTE ();
14593 switch (op[2] & 0x00)
14595 case 0x00:
14596 goto op_semantics_116;
14597 break;
14599 break;
14600 case 0xc0:
14601 GETBYTE ();
14602 switch (op[2] & 0x00)
14604 case 0x00:
14605 op_semantics_117:
14607 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
14608 #line 341 "rx-decode.opc"
14609 int sz AU = (op[1] >> 4) & 0x03;
14610 #line 341 "rx-decode.opc"
14611 int isrc AU = op[1] & 0x0f;
14612 #line 341 "rx-decode.opc"
14613 int bsrc AU = (op[2] >> 4) & 0x0f;
14614 #line 341 "rx-decode.opc"
14615 int rdst AU = op[2] & 0x0f;
14616 if (trace)
14618 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14619 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
14620 op[0], op[1], op[2]);
14621 printf (" sz = 0x%x,", sz);
14622 printf (" isrc = 0x%x,", isrc);
14623 printf (" bsrc = 0x%x,", bsrc);
14624 printf (" rdst = 0x%x\n", rdst);
14626 SYNTAX("movu%s [%1, %2], %0");
14627 #line 341 "rx-decode.opc"
14628 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14631 break;
14633 break;
14634 case 0xc1:
14635 GETBYTE ();
14636 switch (op[2] & 0x00)
14638 case 0x00:
14639 goto op_semantics_117;
14640 break;
14642 break;
14643 case 0xc2:
14644 GETBYTE ();
14645 switch (op[2] & 0x00)
14647 case 0x00:
14648 goto op_semantics_117;
14649 break;
14651 break;
14652 case 0xc3:
14653 GETBYTE ();
14654 switch (op[2] & 0x00)
14656 case 0x00:
14657 goto op_semantics_117;
14658 break;
14660 break;
14661 case 0xc4:
14662 GETBYTE ();
14663 switch (op[2] & 0x00)
14665 case 0x00:
14666 goto op_semantics_117;
14667 break;
14669 break;
14670 case 0xc5:
14671 GETBYTE ();
14672 switch (op[2] & 0x00)
14674 case 0x00:
14675 goto op_semantics_117;
14676 break;
14678 break;
14679 case 0xc6:
14680 GETBYTE ();
14681 switch (op[2] & 0x00)
14683 case 0x00:
14684 goto op_semantics_117;
14685 break;
14687 break;
14688 case 0xc7:
14689 GETBYTE ();
14690 switch (op[2] & 0x00)
14692 case 0x00:
14693 goto op_semantics_117;
14694 break;
14696 break;
14697 case 0xc8:
14698 GETBYTE ();
14699 switch (op[2] & 0x00)
14701 case 0x00:
14702 goto op_semantics_117;
14703 break;
14705 break;
14706 case 0xc9:
14707 GETBYTE ();
14708 switch (op[2] & 0x00)
14710 case 0x00:
14711 goto op_semantics_117;
14712 break;
14714 break;
14715 case 0xca:
14716 GETBYTE ();
14717 switch (op[2] & 0x00)
14719 case 0x00:
14720 goto op_semantics_117;
14721 break;
14723 break;
14724 case 0xcb:
14725 GETBYTE ();
14726 switch (op[2] & 0x00)
14728 case 0x00:
14729 goto op_semantics_117;
14730 break;
14732 break;
14733 case 0xcc:
14734 GETBYTE ();
14735 switch (op[2] & 0x00)
14737 case 0x00:
14738 goto op_semantics_117;
14739 break;
14741 break;
14742 case 0xcd:
14743 GETBYTE ();
14744 switch (op[2] & 0x00)
14746 case 0x00:
14747 goto op_semantics_117;
14748 break;
14750 break;
14751 case 0xce:
14752 GETBYTE ();
14753 switch (op[2] & 0x00)
14755 case 0x00:
14756 goto op_semantics_117;
14757 break;
14759 break;
14760 case 0xcf:
14761 GETBYTE ();
14762 switch (op[2] & 0x00)
14764 case 0x00:
14765 goto op_semantics_117;
14766 break;
14768 break;
14769 case 0xd0:
14770 GETBYTE ();
14771 switch (op[2] & 0x00)
14773 case 0x00:
14774 goto op_semantics_117;
14775 break;
14777 break;
14778 case 0xd1:
14779 GETBYTE ();
14780 switch (op[2] & 0x00)
14782 case 0x00:
14783 goto op_semantics_117;
14784 break;
14786 break;
14787 case 0xd2:
14788 GETBYTE ();
14789 switch (op[2] & 0x00)
14791 case 0x00:
14792 goto op_semantics_117;
14793 break;
14795 break;
14796 case 0xd3:
14797 GETBYTE ();
14798 switch (op[2] & 0x00)
14800 case 0x00:
14801 goto op_semantics_117;
14802 break;
14804 break;
14805 case 0xd4:
14806 GETBYTE ();
14807 switch (op[2] & 0x00)
14809 case 0x00:
14810 goto op_semantics_117;
14811 break;
14813 break;
14814 case 0xd5:
14815 GETBYTE ();
14816 switch (op[2] & 0x00)
14818 case 0x00:
14819 goto op_semantics_117;
14820 break;
14822 break;
14823 case 0xd6:
14824 GETBYTE ();
14825 switch (op[2] & 0x00)
14827 case 0x00:
14828 goto op_semantics_117;
14829 break;
14831 break;
14832 case 0xd7:
14833 GETBYTE ();
14834 switch (op[2] & 0x00)
14836 case 0x00:
14837 goto op_semantics_117;
14838 break;
14840 break;
14841 case 0xd8:
14842 GETBYTE ();
14843 switch (op[2] & 0x00)
14845 case 0x00:
14846 goto op_semantics_117;
14847 break;
14849 break;
14850 case 0xd9:
14851 GETBYTE ();
14852 switch (op[2] & 0x00)
14854 case 0x00:
14855 goto op_semantics_117;
14856 break;
14858 break;
14859 case 0xda:
14860 GETBYTE ();
14861 switch (op[2] & 0x00)
14863 case 0x00:
14864 goto op_semantics_117;
14865 break;
14867 break;
14868 case 0xdb:
14869 GETBYTE ();
14870 switch (op[2] & 0x00)
14872 case 0x00:
14873 goto op_semantics_117;
14874 break;
14876 break;
14877 case 0xdc:
14878 GETBYTE ();
14879 switch (op[2] & 0x00)
14881 case 0x00:
14882 goto op_semantics_117;
14883 break;
14885 break;
14886 case 0xdd:
14887 GETBYTE ();
14888 switch (op[2] & 0x00)
14890 case 0x00:
14891 goto op_semantics_117;
14892 break;
14894 break;
14895 case 0xde:
14896 GETBYTE ();
14897 switch (op[2] & 0x00)
14899 case 0x00:
14900 goto op_semantics_117;
14901 break;
14903 break;
14904 case 0xdf:
14905 GETBYTE ();
14906 switch (op[2] & 0x00)
14908 case 0x00:
14909 goto op_semantics_117;
14910 break;
14912 break;
14913 case 0xe0:
14914 GETBYTE ();
14915 switch (op[2] & 0x00)
14917 case 0x00:
14918 goto op_semantics_117;
14919 break;
14921 break;
14922 case 0xe1:
14923 GETBYTE ();
14924 switch (op[2] & 0x00)
14926 case 0x00:
14927 goto op_semantics_117;
14928 break;
14930 break;
14931 case 0xe2:
14932 GETBYTE ();
14933 switch (op[2] & 0x00)
14935 case 0x00:
14936 goto op_semantics_117;
14937 break;
14939 break;
14940 case 0xe3:
14941 GETBYTE ();
14942 switch (op[2] & 0x00)
14944 case 0x00:
14945 goto op_semantics_117;
14946 break;
14948 break;
14949 case 0xe4:
14950 GETBYTE ();
14951 switch (op[2] & 0x00)
14953 case 0x00:
14954 goto op_semantics_117;
14955 break;
14957 break;
14958 case 0xe5:
14959 GETBYTE ();
14960 switch (op[2] & 0x00)
14962 case 0x00:
14963 goto op_semantics_117;
14964 break;
14966 break;
14967 case 0xe6:
14968 GETBYTE ();
14969 switch (op[2] & 0x00)
14971 case 0x00:
14972 goto op_semantics_117;
14973 break;
14975 break;
14976 case 0xe7:
14977 GETBYTE ();
14978 switch (op[2] & 0x00)
14980 case 0x00:
14981 goto op_semantics_117;
14982 break;
14984 break;
14985 case 0xe8:
14986 GETBYTE ();
14987 switch (op[2] & 0x00)
14989 case 0x00:
14990 goto op_semantics_117;
14991 break;
14993 break;
14994 case 0xe9:
14995 GETBYTE ();
14996 switch (op[2] & 0x00)
14998 case 0x00:
14999 goto op_semantics_117;
15000 break;
15002 break;
15003 case 0xea:
15004 GETBYTE ();
15005 switch (op[2] & 0x00)
15007 case 0x00:
15008 goto op_semantics_117;
15009 break;
15011 break;
15012 case 0xeb:
15013 GETBYTE ();
15014 switch (op[2] & 0x00)
15016 case 0x00:
15017 goto op_semantics_117;
15018 break;
15020 break;
15021 case 0xec:
15022 GETBYTE ();
15023 switch (op[2] & 0x00)
15025 case 0x00:
15026 goto op_semantics_117;
15027 break;
15029 break;
15030 case 0xed:
15031 GETBYTE ();
15032 switch (op[2] & 0x00)
15034 case 0x00:
15035 goto op_semantics_117;
15036 break;
15038 break;
15039 case 0xee:
15040 GETBYTE ();
15041 switch (op[2] & 0x00)
15043 case 0x00:
15044 goto op_semantics_117;
15045 break;
15047 break;
15048 case 0xef:
15049 GETBYTE ();
15050 switch (op[2] & 0x00)
15052 case 0x00:
15053 goto op_semantics_117;
15054 break;
15056 break;
15057 default: UNSUPPORTED(); break;
15059 break;
15060 case 0xff:
15061 GETBYTE ();
15062 switch (op[1] & 0xff)
15064 case 0x00:
15065 GETBYTE ();
15066 switch (op[2] & 0x00)
15068 case 0x00:
15069 op_semantics_118:
15071 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
15072 #line 545 "rx-decode.opc"
15073 int rdst AU = op[1] & 0x0f;
15074 #line 545 "rx-decode.opc"
15075 int srca AU = (op[2] >> 4) & 0x0f;
15076 #line 545 "rx-decode.opc"
15077 int srcb AU = op[2] & 0x0f;
15078 if (trace)
15080 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15081 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
15082 op[0], op[1], op[2]);
15083 printf (" rdst = 0x%x,", rdst);
15084 printf (" srca = 0x%x,", srca);
15085 printf (" srcb = 0x%x\n", srcb);
15087 SYNTAX("sub %2, %1, %0");
15088 #line 545 "rx-decode.opc"
15089 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15091 /*----------------------------------------------------------------------*/
15092 /* SBB */
15095 break;
15097 break;
15098 case 0x01:
15099 GETBYTE ();
15100 switch (op[2] & 0x00)
15102 case 0x00:
15103 goto op_semantics_118;
15104 break;
15106 break;
15107 case 0x02:
15108 GETBYTE ();
15109 switch (op[2] & 0x00)
15111 case 0x00:
15112 goto op_semantics_118;
15113 break;
15115 break;
15116 case 0x03:
15117 GETBYTE ();
15118 switch (op[2] & 0x00)
15120 case 0x00:
15121 goto op_semantics_118;
15122 break;
15124 break;
15125 case 0x04:
15126 GETBYTE ();
15127 switch (op[2] & 0x00)
15129 case 0x00:
15130 goto op_semantics_118;
15131 break;
15133 break;
15134 case 0x05:
15135 GETBYTE ();
15136 switch (op[2] & 0x00)
15138 case 0x00:
15139 goto op_semantics_118;
15140 break;
15142 break;
15143 case 0x06:
15144 GETBYTE ();
15145 switch (op[2] & 0x00)
15147 case 0x00:
15148 goto op_semantics_118;
15149 break;
15151 break;
15152 case 0x07:
15153 GETBYTE ();
15154 switch (op[2] & 0x00)
15156 case 0x00:
15157 goto op_semantics_118;
15158 break;
15160 break;
15161 case 0x08:
15162 GETBYTE ();
15163 switch (op[2] & 0x00)
15165 case 0x00:
15166 goto op_semantics_118;
15167 break;
15169 break;
15170 case 0x09:
15171 GETBYTE ();
15172 switch (op[2] & 0x00)
15174 case 0x00:
15175 goto op_semantics_118;
15176 break;
15178 break;
15179 case 0x0a:
15180 GETBYTE ();
15181 switch (op[2] & 0x00)
15183 case 0x00:
15184 goto op_semantics_118;
15185 break;
15187 break;
15188 case 0x0b:
15189 GETBYTE ();
15190 switch (op[2] & 0x00)
15192 case 0x00:
15193 goto op_semantics_118;
15194 break;
15196 break;
15197 case 0x0c:
15198 GETBYTE ();
15199 switch (op[2] & 0x00)
15201 case 0x00:
15202 goto op_semantics_118;
15203 break;
15205 break;
15206 case 0x0d:
15207 GETBYTE ();
15208 switch (op[2] & 0x00)
15210 case 0x00:
15211 goto op_semantics_118;
15212 break;
15214 break;
15215 case 0x0e:
15216 GETBYTE ();
15217 switch (op[2] & 0x00)
15219 case 0x00:
15220 goto op_semantics_118;
15221 break;
15223 break;
15224 case 0x0f:
15225 GETBYTE ();
15226 switch (op[2] & 0x00)
15228 case 0x00:
15229 goto op_semantics_118;
15230 break;
15232 break;
15233 case 0x20:
15234 GETBYTE ();
15235 switch (op[2] & 0x00)
15237 case 0x00:
15238 op_semantics_119:
15240 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
15241 #line 512 "rx-decode.opc"
15242 int rdst AU = op[1] & 0x0f;
15243 #line 512 "rx-decode.opc"
15244 int srca AU = (op[2] >> 4) & 0x0f;
15245 #line 512 "rx-decode.opc"
15246 int srcb AU = op[2] & 0x0f;
15247 if (trace)
15249 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15250 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
15251 op[0], op[1], op[2]);
15252 printf (" rdst = 0x%x,", rdst);
15253 printf (" srca = 0x%x,", srca);
15254 printf (" srcb = 0x%x\n", srcb);
15256 SYNTAX("add %2, %1, %0");
15257 #line 512 "rx-decode.opc"
15258 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15260 /*----------------------------------------------------------------------*/
15261 /* CMP */
15264 break;
15266 break;
15267 case 0x21:
15268 GETBYTE ();
15269 switch (op[2] & 0x00)
15271 case 0x00:
15272 goto op_semantics_119;
15273 break;
15275 break;
15276 case 0x22:
15277 GETBYTE ();
15278 switch (op[2] & 0x00)
15280 case 0x00:
15281 goto op_semantics_119;
15282 break;
15284 break;
15285 case 0x23:
15286 GETBYTE ();
15287 switch (op[2] & 0x00)
15289 case 0x00:
15290 goto op_semantics_119;
15291 break;
15293 break;
15294 case 0x24:
15295 GETBYTE ();
15296 switch (op[2] & 0x00)
15298 case 0x00:
15299 goto op_semantics_119;
15300 break;
15302 break;
15303 case 0x25:
15304 GETBYTE ();
15305 switch (op[2] & 0x00)
15307 case 0x00:
15308 goto op_semantics_119;
15309 break;
15311 break;
15312 case 0x26:
15313 GETBYTE ();
15314 switch (op[2] & 0x00)
15316 case 0x00:
15317 goto op_semantics_119;
15318 break;
15320 break;
15321 case 0x27:
15322 GETBYTE ();
15323 switch (op[2] & 0x00)
15325 case 0x00:
15326 goto op_semantics_119;
15327 break;
15329 break;
15330 case 0x28:
15331 GETBYTE ();
15332 switch (op[2] & 0x00)
15334 case 0x00:
15335 goto op_semantics_119;
15336 break;
15338 break;
15339 case 0x29:
15340 GETBYTE ();
15341 switch (op[2] & 0x00)
15343 case 0x00:
15344 goto op_semantics_119;
15345 break;
15347 break;
15348 case 0x2a:
15349 GETBYTE ();
15350 switch (op[2] & 0x00)
15352 case 0x00:
15353 goto op_semantics_119;
15354 break;
15356 break;
15357 case 0x2b:
15358 GETBYTE ();
15359 switch (op[2] & 0x00)
15361 case 0x00:
15362 goto op_semantics_119;
15363 break;
15365 break;
15366 case 0x2c:
15367 GETBYTE ();
15368 switch (op[2] & 0x00)
15370 case 0x00:
15371 goto op_semantics_119;
15372 break;
15374 break;
15375 case 0x2d:
15376 GETBYTE ();
15377 switch (op[2] & 0x00)
15379 case 0x00:
15380 goto op_semantics_119;
15381 break;
15383 break;
15384 case 0x2e:
15385 GETBYTE ();
15386 switch (op[2] & 0x00)
15388 case 0x00:
15389 goto op_semantics_119;
15390 break;
15392 break;
15393 case 0x2f:
15394 GETBYTE ();
15395 switch (op[2] & 0x00)
15397 case 0x00:
15398 goto op_semantics_119;
15399 break;
15401 break;
15402 case 0x30:
15403 GETBYTE ();
15404 switch (op[2] & 0x00)
15406 case 0x00:
15407 op_semantics_120:
15409 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
15410 #line 652 "rx-decode.opc"
15411 int rdst AU = op[1] & 0x0f;
15412 #line 652 "rx-decode.opc"
15413 int srca AU = (op[2] >> 4) & 0x0f;
15414 #line 652 "rx-decode.opc"
15415 int srcb AU = op[2] & 0x0f;
15416 if (trace)
15418 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15419 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
15420 op[0], op[1], op[2]);
15421 printf (" rdst = 0x%x,", rdst);
15422 printf (" srca = 0x%x,", srca);
15423 printf (" srcb = 0x%x\n", srcb);
15425 SYNTAX("mul %2, %1, %0");
15426 #line 652 "rx-decode.opc"
15427 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15429 /*----------------------------------------------------------------------*/
15430 /* EMUL */
15433 break;
15435 break;
15436 case 0x31:
15437 GETBYTE ();
15438 switch (op[2] & 0x00)
15440 case 0x00:
15441 goto op_semantics_120;
15442 break;
15444 break;
15445 case 0x32:
15446 GETBYTE ();
15447 switch (op[2] & 0x00)
15449 case 0x00:
15450 goto op_semantics_120;
15451 break;
15453 break;
15454 case 0x33:
15455 GETBYTE ();
15456 switch (op[2] & 0x00)
15458 case 0x00:
15459 goto op_semantics_120;
15460 break;
15462 break;
15463 case 0x34:
15464 GETBYTE ();
15465 switch (op[2] & 0x00)
15467 case 0x00:
15468 goto op_semantics_120;
15469 break;
15471 break;
15472 case 0x35:
15473 GETBYTE ();
15474 switch (op[2] & 0x00)
15476 case 0x00:
15477 goto op_semantics_120;
15478 break;
15480 break;
15481 case 0x36:
15482 GETBYTE ();
15483 switch (op[2] & 0x00)
15485 case 0x00:
15486 goto op_semantics_120;
15487 break;
15489 break;
15490 case 0x37:
15491 GETBYTE ();
15492 switch (op[2] & 0x00)
15494 case 0x00:
15495 goto op_semantics_120;
15496 break;
15498 break;
15499 case 0x38:
15500 GETBYTE ();
15501 switch (op[2] & 0x00)
15503 case 0x00:
15504 goto op_semantics_120;
15505 break;
15507 break;
15508 case 0x39:
15509 GETBYTE ();
15510 switch (op[2] & 0x00)
15512 case 0x00:
15513 goto op_semantics_120;
15514 break;
15516 break;
15517 case 0x3a:
15518 GETBYTE ();
15519 switch (op[2] & 0x00)
15521 case 0x00:
15522 goto op_semantics_120;
15523 break;
15525 break;
15526 case 0x3b:
15527 GETBYTE ();
15528 switch (op[2] & 0x00)
15530 case 0x00:
15531 goto op_semantics_120;
15532 break;
15534 break;
15535 case 0x3c:
15536 GETBYTE ();
15537 switch (op[2] & 0x00)
15539 case 0x00:
15540 goto op_semantics_120;
15541 break;
15543 break;
15544 case 0x3d:
15545 GETBYTE ();
15546 switch (op[2] & 0x00)
15548 case 0x00:
15549 goto op_semantics_120;
15550 break;
15552 break;
15553 case 0x3e:
15554 GETBYTE ();
15555 switch (op[2] & 0x00)
15557 case 0x00:
15558 goto op_semantics_120;
15559 break;
15561 break;
15562 case 0x3f:
15563 GETBYTE ();
15564 switch (op[2] & 0x00)
15566 case 0x00:
15567 goto op_semantics_120;
15568 break;
15570 break;
15571 case 0x40:
15572 GETBYTE ();
15573 switch (op[2] & 0x00)
15575 case 0x00:
15576 op_semantics_121:
15578 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
15579 #line 422 "rx-decode.opc"
15580 int rdst AU = op[1] & 0x0f;
15581 #line 422 "rx-decode.opc"
15582 int srca AU = (op[2] >> 4) & 0x0f;
15583 #line 422 "rx-decode.opc"
15584 int srcb AU = op[2] & 0x0f;
15585 if (trace)
15587 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15588 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
15589 op[0], op[1], op[2]);
15590 printf (" rdst = 0x%x,", rdst);
15591 printf (" srca = 0x%x,", srca);
15592 printf (" srcb = 0x%x\n", srcb);
15594 SYNTAX("and %2, %1, %0");
15595 #line 422 "rx-decode.opc"
15596 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15598 /*----------------------------------------------------------------------*/
15599 /* OR */
15602 break;
15604 break;
15605 case 0x41:
15606 GETBYTE ();
15607 switch (op[2] & 0x00)
15609 case 0x00:
15610 goto op_semantics_121;
15611 break;
15613 break;
15614 case 0x42:
15615 GETBYTE ();
15616 switch (op[2] & 0x00)
15618 case 0x00:
15619 goto op_semantics_121;
15620 break;
15622 break;
15623 case 0x43:
15624 GETBYTE ();
15625 switch (op[2] & 0x00)
15627 case 0x00:
15628 goto op_semantics_121;
15629 break;
15631 break;
15632 case 0x44:
15633 GETBYTE ();
15634 switch (op[2] & 0x00)
15636 case 0x00:
15637 goto op_semantics_121;
15638 break;
15640 break;
15641 case 0x45:
15642 GETBYTE ();
15643 switch (op[2] & 0x00)
15645 case 0x00:
15646 goto op_semantics_121;
15647 break;
15649 break;
15650 case 0x46:
15651 GETBYTE ();
15652 switch (op[2] & 0x00)
15654 case 0x00:
15655 goto op_semantics_121;
15656 break;
15658 break;
15659 case 0x47:
15660 GETBYTE ();
15661 switch (op[2] & 0x00)
15663 case 0x00:
15664 goto op_semantics_121;
15665 break;
15667 break;
15668 case 0x48:
15669 GETBYTE ();
15670 switch (op[2] & 0x00)
15672 case 0x00:
15673 goto op_semantics_121;
15674 break;
15676 break;
15677 case 0x49:
15678 GETBYTE ();
15679 switch (op[2] & 0x00)
15681 case 0x00:
15682 goto op_semantics_121;
15683 break;
15685 break;
15686 case 0x4a:
15687 GETBYTE ();
15688 switch (op[2] & 0x00)
15690 case 0x00:
15691 goto op_semantics_121;
15692 break;
15694 break;
15695 case 0x4b:
15696 GETBYTE ();
15697 switch (op[2] & 0x00)
15699 case 0x00:
15700 goto op_semantics_121;
15701 break;
15703 break;
15704 case 0x4c:
15705 GETBYTE ();
15706 switch (op[2] & 0x00)
15708 case 0x00:
15709 goto op_semantics_121;
15710 break;
15712 break;
15713 case 0x4d:
15714 GETBYTE ();
15715 switch (op[2] & 0x00)
15717 case 0x00:
15718 goto op_semantics_121;
15719 break;
15721 break;
15722 case 0x4e:
15723 GETBYTE ();
15724 switch (op[2] & 0x00)
15726 case 0x00:
15727 goto op_semantics_121;
15728 break;
15730 break;
15731 case 0x4f:
15732 GETBYTE ();
15733 switch (op[2] & 0x00)
15735 case 0x00:
15736 goto op_semantics_121;
15737 break;
15739 break;
15740 case 0x50:
15741 GETBYTE ();
15742 switch (op[2] & 0x00)
15744 case 0x00:
15745 op_semantics_122:
15747 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
15748 #line 440 "rx-decode.opc"
15749 int rdst AU = op[1] & 0x0f;
15750 #line 440 "rx-decode.opc"
15751 int srca AU = (op[2] >> 4) & 0x0f;
15752 #line 440 "rx-decode.opc"
15753 int srcb AU = op[2] & 0x0f;
15754 if (trace)
15756 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15757 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
15758 op[0], op[1], op[2]);
15759 printf (" rdst = 0x%x,", rdst);
15760 printf (" srca = 0x%x,", srca);
15761 printf (" srcb = 0x%x\n", srcb);
15763 SYNTAX("or %2, %1, %0");
15764 #line 440 "rx-decode.opc"
15765 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15767 /*----------------------------------------------------------------------*/
15768 /* XOR */
15771 break;
15773 break;
15774 case 0x51:
15775 GETBYTE ();
15776 switch (op[2] & 0x00)
15778 case 0x00:
15779 goto op_semantics_122;
15780 break;
15782 break;
15783 case 0x52:
15784 GETBYTE ();
15785 switch (op[2] & 0x00)
15787 case 0x00:
15788 goto op_semantics_122;
15789 break;
15791 break;
15792 case 0x53:
15793 GETBYTE ();
15794 switch (op[2] & 0x00)
15796 case 0x00:
15797 goto op_semantics_122;
15798 break;
15800 break;
15801 case 0x54:
15802 GETBYTE ();
15803 switch (op[2] & 0x00)
15805 case 0x00:
15806 goto op_semantics_122;
15807 break;
15809 break;
15810 case 0x55:
15811 GETBYTE ();
15812 switch (op[2] & 0x00)
15814 case 0x00:
15815 goto op_semantics_122;
15816 break;
15818 break;
15819 case 0x56:
15820 GETBYTE ();
15821 switch (op[2] & 0x00)
15823 case 0x00:
15824 goto op_semantics_122;
15825 break;
15827 break;
15828 case 0x57:
15829 GETBYTE ();
15830 switch (op[2] & 0x00)
15832 case 0x00:
15833 goto op_semantics_122;
15834 break;
15836 break;
15837 case 0x58:
15838 GETBYTE ();
15839 switch (op[2] & 0x00)
15841 case 0x00:
15842 goto op_semantics_122;
15843 break;
15845 break;
15846 case 0x59:
15847 GETBYTE ();
15848 switch (op[2] & 0x00)
15850 case 0x00:
15851 goto op_semantics_122;
15852 break;
15854 break;
15855 case 0x5a:
15856 GETBYTE ();
15857 switch (op[2] & 0x00)
15859 case 0x00:
15860 goto op_semantics_122;
15861 break;
15863 break;
15864 case 0x5b:
15865 GETBYTE ();
15866 switch (op[2] & 0x00)
15868 case 0x00:
15869 goto op_semantics_122;
15870 break;
15872 break;
15873 case 0x5c:
15874 GETBYTE ();
15875 switch (op[2] & 0x00)
15877 case 0x00:
15878 goto op_semantics_122;
15879 break;
15881 break;
15882 case 0x5d:
15883 GETBYTE ();
15884 switch (op[2] & 0x00)
15886 case 0x00:
15887 goto op_semantics_122;
15888 break;
15890 break;
15891 case 0x5e:
15892 GETBYTE ();
15893 switch (op[2] & 0x00)
15895 case 0x00:
15896 goto op_semantics_122;
15897 break;
15899 break;
15900 case 0x5f:
15901 GETBYTE ();
15902 switch (op[2] & 0x00)
15904 case 0x00:
15905 goto op_semantics_122;
15906 break;
15908 break;
15909 case 0x80:
15910 GETBYTE ();
15911 switch (op[2] & 0x00)
15913 case 0x00:
15914 op_semantics_123:
15916 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
15917 #line 1100 "rx-decode.opc"
15918 int rdst AU = op[1] & 0x0f;
15919 #line 1100 "rx-decode.opc"
15920 int srca AU = (op[2] >> 4) & 0x0f;
15921 #line 1100 "rx-decode.opc"
15922 int srcb AU = op[2] & 0x0f;
15923 if (trace)
15925 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15926 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
15927 op[0], op[1], op[2]);
15928 printf (" rdst = 0x%x,", rdst);
15929 printf (" srca = 0x%x,", srca);
15930 printf (" srcb = 0x%x\n", srcb);
15932 SYNTAX("fsub %2, %1, %0");
15933 #line 1100 "rx-decode.opc"
15934 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15937 break;
15939 break;
15940 case 0x81:
15941 GETBYTE ();
15942 switch (op[2] & 0x00)
15944 case 0x00:
15945 goto op_semantics_123;
15946 break;
15948 break;
15949 case 0x82:
15950 GETBYTE ();
15951 switch (op[2] & 0x00)
15953 case 0x00:
15954 goto op_semantics_123;
15955 break;
15957 break;
15958 case 0x83:
15959 GETBYTE ();
15960 switch (op[2] & 0x00)
15962 case 0x00:
15963 goto op_semantics_123;
15964 break;
15966 break;
15967 case 0x84:
15968 GETBYTE ();
15969 switch (op[2] & 0x00)
15971 case 0x00:
15972 goto op_semantics_123;
15973 break;
15975 break;
15976 case 0x85:
15977 GETBYTE ();
15978 switch (op[2] & 0x00)
15980 case 0x00:
15981 goto op_semantics_123;
15982 break;
15984 break;
15985 case 0x86:
15986 GETBYTE ();
15987 switch (op[2] & 0x00)
15989 case 0x00:
15990 goto op_semantics_123;
15991 break;
15993 break;
15994 case 0x87:
15995 GETBYTE ();
15996 switch (op[2] & 0x00)
15998 case 0x00:
15999 goto op_semantics_123;
16000 break;
16002 break;
16003 case 0x88:
16004 GETBYTE ();
16005 switch (op[2] & 0x00)
16007 case 0x00:
16008 goto op_semantics_123;
16009 break;
16011 break;
16012 case 0x89:
16013 GETBYTE ();
16014 switch (op[2] & 0x00)
16016 case 0x00:
16017 goto op_semantics_123;
16018 break;
16020 break;
16021 case 0x8a:
16022 GETBYTE ();
16023 switch (op[2] & 0x00)
16025 case 0x00:
16026 goto op_semantics_123;
16027 break;
16029 break;
16030 case 0x8b:
16031 GETBYTE ();
16032 switch (op[2] & 0x00)
16034 case 0x00:
16035 goto op_semantics_123;
16036 break;
16038 break;
16039 case 0x8c:
16040 GETBYTE ();
16041 switch (op[2] & 0x00)
16043 case 0x00:
16044 goto op_semantics_123;
16045 break;
16047 break;
16048 case 0x8d:
16049 GETBYTE ();
16050 switch (op[2] & 0x00)
16052 case 0x00:
16053 goto op_semantics_123;
16054 break;
16056 break;
16057 case 0x8e:
16058 GETBYTE ();
16059 switch (op[2] & 0x00)
16061 case 0x00:
16062 goto op_semantics_123;
16063 break;
16065 break;
16066 case 0x8f:
16067 GETBYTE ();
16068 switch (op[2] & 0x00)
16070 case 0x00:
16071 goto op_semantics_123;
16072 break;
16074 break;
16075 case 0xa0:
16076 GETBYTE ();
16077 switch (op[2] & 0x00)
16079 case 0x00:
16080 op_semantics_124:
16082 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
16083 #line 1097 "rx-decode.opc"
16084 int rdst AU = op[1] & 0x0f;
16085 #line 1097 "rx-decode.opc"
16086 int srca AU = (op[2] >> 4) & 0x0f;
16087 #line 1097 "rx-decode.opc"
16088 int srcb AU = op[2] & 0x0f;
16089 if (trace)
16091 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16092 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
16093 op[0], op[1], op[2]);
16094 printf (" rdst = 0x%x,", rdst);
16095 printf (" srca = 0x%x,", srca);
16096 printf (" srcb = 0x%x\n", srcb);
16098 SYNTAX("fadd %2, %1, %0");
16099 #line 1097 "rx-decode.opc"
16100 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16103 break;
16105 break;
16106 case 0xa1:
16107 GETBYTE ();
16108 switch (op[2] & 0x00)
16110 case 0x00:
16111 goto op_semantics_124;
16112 break;
16114 break;
16115 case 0xa2:
16116 GETBYTE ();
16117 switch (op[2] & 0x00)
16119 case 0x00:
16120 goto op_semantics_124;
16121 break;
16123 break;
16124 case 0xa3:
16125 GETBYTE ();
16126 switch (op[2] & 0x00)
16128 case 0x00:
16129 goto op_semantics_124;
16130 break;
16132 break;
16133 case 0xa4:
16134 GETBYTE ();
16135 switch (op[2] & 0x00)
16137 case 0x00:
16138 goto op_semantics_124;
16139 break;
16141 break;
16142 case 0xa5:
16143 GETBYTE ();
16144 switch (op[2] & 0x00)
16146 case 0x00:
16147 goto op_semantics_124;
16148 break;
16150 break;
16151 case 0xa6:
16152 GETBYTE ();
16153 switch (op[2] & 0x00)
16155 case 0x00:
16156 goto op_semantics_124;
16157 break;
16159 break;
16160 case 0xa7:
16161 GETBYTE ();
16162 switch (op[2] & 0x00)
16164 case 0x00:
16165 goto op_semantics_124;
16166 break;
16168 break;
16169 case 0xa8:
16170 GETBYTE ();
16171 switch (op[2] & 0x00)
16173 case 0x00:
16174 goto op_semantics_124;
16175 break;
16177 break;
16178 case 0xa9:
16179 GETBYTE ();
16180 switch (op[2] & 0x00)
16182 case 0x00:
16183 goto op_semantics_124;
16184 break;
16186 break;
16187 case 0xaa:
16188 GETBYTE ();
16189 switch (op[2] & 0x00)
16191 case 0x00:
16192 goto op_semantics_124;
16193 break;
16195 break;
16196 case 0xab:
16197 GETBYTE ();
16198 switch (op[2] & 0x00)
16200 case 0x00:
16201 goto op_semantics_124;
16202 break;
16204 break;
16205 case 0xac:
16206 GETBYTE ();
16207 switch (op[2] & 0x00)
16209 case 0x00:
16210 goto op_semantics_124;
16211 break;
16213 break;
16214 case 0xad:
16215 GETBYTE ();
16216 switch (op[2] & 0x00)
16218 case 0x00:
16219 goto op_semantics_124;
16220 break;
16222 break;
16223 case 0xae:
16224 GETBYTE ();
16225 switch (op[2] & 0x00)
16227 case 0x00:
16228 goto op_semantics_124;
16229 break;
16231 break;
16232 case 0xaf:
16233 GETBYTE ();
16234 switch (op[2] & 0x00)
16236 case 0x00:
16237 goto op_semantics_124;
16238 break;
16240 break;
16241 case 0xb0:
16242 GETBYTE ();
16243 switch (op[2] & 0x00)
16245 case 0x00:
16246 op_semantics_125:
16248 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
16249 #line 1103 "rx-decode.opc"
16250 int rdst AU = op[1] & 0x0f;
16251 #line 1103 "rx-decode.opc"
16252 int srca AU = (op[2] >> 4) & 0x0f;
16253 #line 1103 "rx-decode.opc"
16254 int srcb AU = op[2] & 0x0f;
16255 if (trace)
16257 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16258 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
16259 op[0], op[1], op[2]);
16260 printf (" rdst = 0x%x,", rdst);
16261 printf (" srca = 0x%x,", srca);
16262 printf (" srcb = 0x%x\n", srcb);
16264 SYNTAX("fmul %2, %1, %0");
16265 #line 1103 "rx-decode.opc"
16266 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16269 break;
16271 break;
16272 case 0xb1:
16273 GETBYTE ();
16274 switch (op[2] & 0x00)
16276 case 0x00:
16277 goto op_semantics_125;
16278 break;
16280 break;
16281 case 0xb2:
16282 GETBYTE ();
16283 switch (op[2] & 0x00)
16285 case 0x00:
16286 goto op_semantics_125;
16287 break;
16289 break;
16290 case 0xb3:
16291 GETBYTE ();
16292 switch (op[2] & 0x00)
16294 case 0x00:
16295 goto op_semantics_125;
16296 break;
16298 break;
16299 case 0xb4:
16300 GETBYTE ();
16301 switch (op[2] & 0x00)
16303 case 0x00:
16304 goto op_semantics_125;
16305 break;
16307 break;
16308 case 0xb5:
16309 GETBYTE ();
16310 switch (op[2] & 0x00)
16312 case 0x00:
16313 goto op_semantics_125;
16314 break;
16316 break;
16317 case 0xb6:
16318 GETBYTE ();
16319 switch (op[2] & 0x00)
16321 case 0x00:
16322 goto op_semantics_125;
16323 break;
16325 break;
16326 case 0xb7:
16327 GETBYTE ();
16328 switch (op[2] & 0x00)
16330 case 0x00:
16331 goto op_semantics_125;
16332 break;
16334 break;
16335 case 0xb8:
16336 GETBYTE ();
16337 switch (op[2] & 0x00)
16339 case 0x00:
16340 goto op_semantics_125;
16341 break;
16343 break;
16344 case 0xb9:
16345 GETBYTE ();
16346 switch (op[2] & 0x00)
16348 case 0x00:
16349 goto op_semantics_125;
16350 break;
16352 break;
16353 case 0xba:
16354 GETBYTE ();
16355 switch (op[2] & 0x00)
16357 case 0x00:
16358 goto op_semantics_125;
16359 break;
16361 break;
16362 case 0xbb:
16363 GETBYTE ();
16364 switch (op[2] & 0x00)
16366 case 0x00:
16367 goto op_semantics_125;
16368 break;
16370 break;
16371 case 0xbc:
16372 GETBYTE ();
16373 switch (op[2] & 0x00)
16375 case 0x00:
16376 goto op_semantics_125;
16377 break;
16379 break;
16380 case 0xbd:
16381 GETBYTE ();
16382 switch (op[2] & 0x00)
16384 case 0x00:
16385 goto op_semantics_125;
16386 break;
16388 break;
16389 case 0xbe:
16390 GETBYTE ();
16391 switch (op[2] & 0x00)
16393 case 0x00:
16394 goto op_semantics_125;
16395 break;
16397 break;
16398 case 0xbf:
16399 GETBYTE ();
16400 switch (op[2] & 0x00)
16402 case 0x00:
16403 goto op_semantics_125;
16404 break;
16406 break;
16407 default: UNSUPPORTED(); break;
16409 break;
16410 default: UNSUPPORTED(); break;
16412 #line 1118 "rx-decode.opc"
16414 return rx->n_bytes;