Automatic date update in version.in
[binutils-gdb.git] / opcodes / rx-decode.c
blob13b9af549dec5247f276b3b0f462ce4904ac363d
1 /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
2 #line 1 "rx-decode.opc"
3 /* -*- c -*- */
4 /* Copyright (C) 2012-2024 Free Software Foundation, Inc.
5 Contributed by Red Hat.
6 Written by DJ Delorie.
8 This file is part of the GNU opcodes library.
10 This library is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
15 It is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
18 License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
25 #include "sysdep.h"
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include "ansidecl.h"
30 #include "opcode/rx.h"
31 #include "libiberty.h"
33 #define RX_OPCODE_BIG_ENDIAN 0
35 typedef struct
37 RX_Opcode_Decoded * rx;
38 int (* getbyte)(void *);
39 void * ptr;
40 unsigned char * op;
41 } LocalData;
43 static int trace = 0;
45 #define BSIZE 0
46 #define WSIZE 1
47 #define LSIZE 2
48 #define DSIZE 3
50 /* These are for when the upper bits are "don't care" or "undefined". */
51 static int bwl[4] =
53 RX_Byte,
54 RX_Word,
55 RX_Long,
56 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
59 static int sbwl[4] =
61 RX_SByte,
62 RX_SWord,
63 RX_Long,
64 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
67 static int ubw[4] =
69 RX_UByte,
70 RX_UWord,
71 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
72 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
75 static int memex[4] =
77 RX_SByte,
78 RX_SWord,
79 RX_Long,
80 RX_UWord
83 static int _ld[2] =
85 RX_Long,
86 RX_Double
89 #define ID(x) rx->id = RXO_##x
90 #define OP(n,t,r,a) (rx->op[n].type = t, \
91 rx->op[n].reg = r, \
92 rx->op[n].addend = a )
93 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
94 rx->op[n].size = s )
96 /* This is for the BWL and BW bitfields. */
97 static int SCALE[] = { 1, 2, 4, 0 };
98 /* This is for the prefix size enum. */
99 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4, 8 };
101 #define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
102 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
104 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
105 16, 17, 0, 0, 0, 0, 0, 0 };
107 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
110 *C a constant (immediate) c
111 *R A register
112 *I Register indirect, no offset
113 *Is Register indirect, with offset
114 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
115 *P standard displacement: type (r,[r]), reg, assumes UByte
116 *Pm memex displacement: type (r,[r]), reg, memex code
117 *cc condition code. */
119 #define DC(c) OP (0, RX_Operand_Immediate, 0, c)
120 #define DR(r) OP (0, RX_Operand_Register, r, 0)
121 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
122 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
123 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
124 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
125 #define DCR(r) OP (0, RX_Operand_DoubleCReg, r, 0)
126 #define DDR(r) OP (0, RX_Operand_DoubleReg, r, 0)
127 #define DDRH(r) OP (0, RX_Operand_DoubleRegH, r, 0)
128 #define DDRL(r) OP (0, RX_Operand_DoubleRegL, r, 0)
129 #define DCND(r) OP (0, RX_Operand_DoubleCond, r, 0)
131 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
132 #define SR(r) OP (1, RX_Operand_Register, r, 0)
133 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
134 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
135 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
136 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
137 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
138 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
139 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
140 #define SCR(r) OP (1, RX_Operand_DoubleCReg, r, 0)
141 #define SDR(r) OP (1, RX_Operand_DoubleReg, r, 0)
142 #define SDRH(r) OP (1, RX_Operand_DoubleRegH, r, 0)
143 #define SDRL(r) OP (1, RX_Operand_DoubleRegL, r, 0)
145 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
146 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
147 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
148 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
149 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
150 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
151 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
152 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
153 #define S2DR(r) OP (2, RX_Operand_DoubleReg, r, 0)
154 #define S2CR(r) OP (2, RX_Operand_DoubleCReg, r, 0)
156 #define SDD(t,r,s) rx_disp (1, t, r, bwl, ld);
158 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
159 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
160 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
161 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
162 #define DL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz]
164 #define F(f) store_flags(rx, f)
166 #define AU ATTRIBUTE_UNUSED
167 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
169 #define SYNTAX(x) rx->syntax = x
171 #define UNSUPPORTED() \
172 rx->syntax = "*unknown*"
174 #define IMM(sf) immediate (sf, 0, ld)
175 #define IMMex(sf) immediate (sf, 1, ld)
177 static int
178 immediate (int sfield, int ex, LocalData * ld)
180 unsigned long i = 0, j;
182 switch (sfield)
184 #define B ((unsigned long) GETBYTE())
185 case 0:
186 #if RX_OPCODE_BIG_ENDIAN
187 i = B;
188 if (ex && (i & 0x80))
189 i -= 0x100;
190 i <<= 24;
191 i |= B << 16;
192 i |= B << 8;
193 i |= B;
194 #else
195 i = B;
196 i |= B << 8;
197 i |= B << 16;
198 j = B;
199 if (ex && (j & 0x80))
200 j -= 0x100;
201 i |= j << 24;
202 #endif
203 break;
204 case 3:
205 #if RX_OPCODE_BIG_ENDIAN
206 i = B << 16;
207 i |= B << 8;
208 i |= B;
209 #else
210 i = B;
211 i |= B << 8;
212 i |= B << 16;
213 #endif
214 if (ex && (i & 0x800000))
215 i -= 0x1000000;
216 break;
217 case 2:
218 #if RX_OPCODE_BIG_ENDIAN
219 i |= B << 8;
220 i |= B;
221 #else
222 i |= B;
223 i |= B << 8;
224 #endif
225 if (ex && (i & 0x8000))
226 i -= 0x10000;
227 break;
228 case 1:
229 i |= B;
230 if (ex && (i & 0x80))
231 i -= 0x100;
232 break;
233 default:
234 abort();
236 return i;
239 static void
240 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
242 int disp;
244 ld->rx->op[n].reg = reg;
245 switch (type)
247 case 3:
248 ld->rx->op[n].type = RX_Operand_Register;
249 break;
250 case 0:
251 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
252 ld->rx->op[n].addend = 0;
253 break;
254 case 1:
255 ld->rx->op[n].type = RX_Operand_Indirect;
256 disp = GETBYTE ();
257 ld->rx->op[n].addend = disp * GET_PSCALE (size);
258 break;
259 case 2:
260 ld->rx->op[n].type = RX_Operand_Indirect;
261 disp = GETBYTE ();
262 #if RX_OPCODE_BIG_ENDIAN
263 disp = disp * 256 + GETBYTE ();
264 #else
265 disp = disp + GETBYTE () * 256;
266 #endif
267 ld->rx->op[n].addend = disp * GET_PSCALE (size);
268 break;
269 default:
270 abort ();
274 #define xO 8
275 #define xS 4
276 #define xZ 2
277 #define xC 1
279 #define F_____
280 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
281 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
282 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
283 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
284 #define F_O___ rx->flags_0 = rx->flags_s = xO;
285 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
286 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
287 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
290 rx_decode_opcode (unsigned long pc AU,
291 RX_Opcode_Decoded * rx,
292 int (* getbyte)(void *),
293 void * ptr)
295 LocalData lds, * ld = &lds;
296 unsigned char op[20] = {0};
298 lds.rx = rx;
299 lds.getbyte = getbyte;
300 lds.ptr = ptr;
301 lds.op = op;
303 memset (rx, 0, sizeof (*rx));
304 BWL(LSIZE);
307 /*----------------------------------------------------------------------*/
308 /* MOV */
310 GETBYTE ();
311 switch (op[0] & 0xff)
313 case 0x00:
315 /** 0000 0000 brk */
316 if (trace)
318 printf ("\033[33m%s\033[0m %02x\n",
319 "/** 0000 0000 brk */",
320 op[0]);
322 SYNTAX("brk");
323 #line 1050 "rx-decode.opc"
324 ID(brk);
327 break;
328 case 0x01:
330 /** 0000 0001 dbt */
331 if (trace)
333 printf ("\033[33m%s\033[0m %02x\n",
334 "/** 0000 0001 dbt */",
335 op[0]);
337 SYNTAX("dbt");
338 #line 1053 "rx-decode.opc"
339 ID(dbt);
342 break;
343 case 0x02:
345 /** 0000 0010 rts */
346 if (trace)
348 printf ("\033[33m%s\033[0m %02x\n",
349 "/** 0000 0010 rts */",
350 op[0]);
352 SYNTAX("rts");
353 #line 831 "rx-decode.opc"
354 ID(rts);
356 /*----------------------------------------------------------------------*/
357 /* NOP */
360 break;
361 case 0x03:
363 /** 0000 0011 nop */
364 if (trace)
366 printf ("\033[33m%s\033[0m %02x\n",
367 "/** 0000 0011 nop */",
368 op[0]);
370 SYNTAX("nop");
371 #line 837 "rx-decode.opc"
372 ID(nop);
374 /*----------------------------------------------------------------------*/
375 /* STRING FUNCTIONS */
378 break;
379 case 0x04:
381 /** 0000 0100 bra.a %a0 */
382 if (trace)
384 printf ("\033[33m%s\033[0m %02x\n",
385 "/** 0000 0100 bra.a %a0 */",
386 op[0]);
388 SYNTAX("bra.a %a0");
389 #line 809 "rx-decode.opc"
390 ID(branch); DC(pc + IMMex(3));
393 break;
394 case 0x05:
396 /** 0000 0101 bsr.a %a0 */
397 if (trace)
399 printf ("\033[33m%s\033[0m %02x\n",
400 "/** 0000 0101 bsr.a %a0 */",
401 op[0]);
403 SYNTAX("bsr.a %a0");
404 #line 825 "rx-decode.opc"
405 ID(jsr); DC(pc + IMMex(3));
408 break;
409 case 0x06:
410 GETBYTE ();
411 switch (op[1] & 0xff)
413 case 0x00:
414 GETBYTE ();
415 switch (op[2] & 0x00)
417 case 0x00:
418 op_semantics_1:
420 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
421 #line 567 "rx-decode.opc"
422 int mx AU = (op[1] >> 6) & 0x03;
423 #line 567 "rx-decode.opc"
424 int ss AU = op[1] & 0x03;
425 #line 567 "rx-decode.opc"
426 int rsrc AU = (op[2] >> 4) & 0x0f;
427 #line 567 "rx-decode.opc"
428 int rdst AU = op[2] & 0x0f;
429 if (trace)
431 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
432 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
433 op[0], op[1], op[2]);
434 printf (" mx = 0x%x,", mx);
435 printf (" ss = 0x%x,", ss);
436 printf (" rsrc = 0x%x,", rsrc);
437 printf (" rdst = 0x%x\n", rdst);
439 SYNTAX("sub %2%S2, %1");
440 #line 567 "rx-decode.opc"
441 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
444 break;
446 break;
447 case 0x01:
448 GETBYTE ();
449 switch (op[2] & 0x00)
451 case 0x00:
452 goto op_semantics_1;
453 break;
455 break;
456 case 0x02:
457 GETBYTE ();
458 switch (op[2] & 0x00)
460 case 0x00:
461 goto op_semantics_1;
462 break;
464 break;
465 case 0x03:
466 GETBYTE ();
467 switch (op[2] & 0x00)
469 case 0x00:
470 goto op_semantics_1;
471 break;
473 break;
474 case 0x04:
475 GETBYTE ();
476 switch (op[2] & 0x00)
478 case 0x00:
479 op_semantics_2:
481 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
482 #line 555 "rx-decode.opc"
483 int mx AU = (op[1] >> 6) & 0x03;
484 #line 555 "rx-decode.opc"
485 int ss AU = op[1] & 0x03;
486 #line 555 "rx-decode.opc"
487 int rsrc AU = (op[2] >> 4) & 0x0f;
488 #line 555 "rx-decode.opc"
489 int rdst AU = op[2] & 0x0f;
490 if (trace)
492 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
493 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
494 op[0], op[1], op[2]);
495 printf (" mx = 0x%x,", mx);
496 printf (" ss = 0x%x,", ss);
497 printf (" rsrc = 0x%x,", rsrc);
498 printf (" rdst = 0x%x\n", rdst);
500 SYNTAX("cmp %2%S2, %1");
501 #line 555 "rx-decode.opc"
502 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
504 /*----------------------------------------------------------------------*/
505 /* SUB */
508 break;
510 break;
511 case 0x05:
512 GETBYTE ();
513 switch (op[2] & 0x00)
515 case 0x00:
516 goto op_semantics_2;
517 break;
519 break;
520 case 0x06:
521 GETBYTE ();
522 switch (op[2] & 0x00)
524 case 0x00:
525 goto op_semantics_2;
526 break;
528 break;
529 case 0x07:
530 GETBYTE ();
531 switch (op[2] & 0x00)
533 case 0x00:
534 goto op_semantics_2;
535 break;
537 break;
538 case 0x08:
539 GETBYTE ();
540 switch (op[2] & 0x00)
542 case 0x00:
543 op_semantics_3:
545 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
546 #line 531 "rx-decode.opc"
547 int mx AU = (op[1] >> 6) & 0x03;
548 #line 531 "rx-decode.opc"
549 int ss AU = op[1] & 0x03;
550 #line 531 "rx-decode.opc"
551 int rsrc AU = (op[2] >> 4) & 0x0f;
552 #line 531 "rx-decode.opc"
553 int rdst AU = op[2] & 0x0f;
554 if (trace)
556 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
557 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
558 op[0], op[1], op[2]);
559 printf (" mx = 0x%x,", mx);
560 printf (" ss = 0x%x,", ss);
561 printf (" rsrc = 0x%x,", rsrc);
562 printf (" rdst = 0x%x\n", rdst);
564 SYNTAX("add %1%S1, %0");
565 #line 531 "rx-decode.opc"
566 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
569 break;
571 break;
572 case 0x09:
573 GETBYTE ();
574 switch (op[2] & 0x00)
576 case 0x00:
577 goto op_semantics_3;
578 break;
580 break;
581 case 0x0a:
582 GETBYTE ();
583 switch (op[2] & 0x00)
585 case 0x00:
586 goto op_semantics_3;
587 break;
589 break;
590 case 0x0b:
591 GETBYTE ();
592 switch (op[2] & 0x00)
594 case 0x00:
595 goto op_semantics_3;
596 break;
598 break;
599 case 0x0c:
600 GETBYTE ();
601 switch (op[2] & 0x00)
603 case 0x00:
604 op_semantics_4:
606 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
607 #line 674 "rx-decode.opc"
608 int mx AU = (op[1] >> 6) & 0x03;
609 #line 674 "rx-decode.opc"
610 int ss AU = op[1] & 0x03;
611 #line 674 "rx-decode.opc"
612 int rsrc AU = (op[2] >> 4) & 0x0f;
613 #line 674 "rx-decode.opc"
614 int rdst AU = op[2] & 0x0f;
615 if (trace)
617 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
618 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
619 op[0], op[1], op[2]);
620 printf (" mx = 0x%x,", mx);
621 printf (" ss = 0x%x,", ss);
622 printf (" rsrc = 0x%x,", rsrc);
623 printf (" rdst = 0x%x\n", rdst);
625 SYNTAX("mul %1%S1, %0");
626 #line 674 "rx-decode.opc"
627 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
630 break;
632 break;
633 case 0x0d:
634 GETBYTE ();
635 switch (op[2] & 0x00)
637 case 0x00:
638 goto op_semantics_4;
639 break;
641 break;
642 case 0x0e:
643 GETBYTE ();
644 switch (op[2] & 0x00)
646 case 0x00:
647 goto op_semantics_4;
648 break;
650 break;
651 case 0x0f:
652 GETBYTE ();
653 switch (op[2] & 0x00)
655 case 0x00:
656 goto op_semantics_4;
657 break;
659 break;
660 case 0x10:
661 GETBYTE ();
662 switch (op[2] & 0x00)
664 case 0x00:
665 op_semantics_5:
667 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
668 #line 444 "rx-decode.opc"
669 int mx AU = (op[1] >> 6) & 0x03;
670 #line 444 "rx-decode.opc"
671 int ss AU = op[1] & 0x03;
672 #line 444 "rx-decode.opc"
673 int rsrc AU = (op[2] >> 4) & 0x0f;
674 #line 444 "rx-decode.opc"
675 int rdst AU = op[2] & 0x0f;
676 if (trace)
678 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
679 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
680 op[0], op[1], op[2]);
681 printf (" mx = 0x%x,", mx);
682 printf (" ss = 0x%x,", ss);
683 printf (" rsrc = 0x%x,", rsrc);
684 printf (" rdst = 0x%x\n", rdst);
686 SYNTAX("and %1%S1, %0");
687 #line 444 "rx-decode.opc"
688 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
691 break;
693 break;
694 case 0x11:
695 GETBYTE ();
696 switch (op[2] & 0x00)
698 case 0x00:
699 goto op_semantics_5;
700 break;
702 break;
703 case 0x12:
704 GETBYTE ();
705 switch (op[2] & 0x00)
707 case 0x00:
708 goto op_semantics_5;
709 break;
711 break;
712 case 0x13:
713 GETBYTE ();
714 switch (op[2] & 0x00)
716 case 0x00:
717 goto op_semantics_5;
718 break;
720 break;
721 case 0x14:
722 GETBYTE ();
723 switch (op[2] & 0x00)
725 case 0x00:
726 op_semantics_6:
728 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
729 #line 462 "rx-decode.opc"
730 int mx AU = (op[1] >> 6) & 0x03;
731 #line 462 "rx-decode.opc"
732 int ss AU = op[1] & 0x03;
733 #line 462 "rx-decode.opc"
734 int rsrc AU = (op[2] >> 4) & 0x0f;
735 #line 462 "rx-decode.opc"
736 int rdst AU = op[2] & 0x0f;
737 if (trace)
739 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
740 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
741 op[0], op[1], op[2]);
742 printf (" mx = 0x%x,", mx);
743 printf (" ss = 0x%x,", ss);
744 printf (" rsrc = 0x%x,", rsrc);
745 printf (" rdst = 0x%x\n", rdst);
747 SYNTAX("or %1%S1, %0");
748 #line 462 "rx-decode.opc"
749 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
752 break;
754 break;
755 case 0x15:
756 GETBYTE ();
757 switch (op[2] & 0x00)
759 case 0x00:
760 goto op_semantics_6;
761 break;
763 break;
764 case 0x16:
765 GETBYTE ();
766 switch (op[2] & 0x00)
768 case 0x00:
769 goto op_semantics_6;
770 break;
772 break;
773 case 0x17:
774 GETBYTE ();
775 switch (op[2] & 0x00)
777 case 0x00:
778 goto op_semantics_6;
779 break;
781 break;
782 case 0x20:
783 GETBYTE ();
784 switch (op[2] & 0xff)
786 case 0x00:
787 GETBYTE ();
788 switch (op[3] & 0x00)
790 case 0x00:
791 op_semantics_7:
793 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
794 #line 580 "rx-decode.opc"
795 int mx AU = (op[1] >> 6) & 0x03;
796 #line 580 "rx-decode.opc"
797 int sp AU = op[1] & 0x03;
798 #line 580 "rx-decode.opc"
799 int rsrc AU = (op[3] >> 4) & 0x0f;
800 #line 580 "rx-decode.opc"
801 int rdst AU = op[3] & 0x0f;
802 if (trace)
804 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
805 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
806 op[0], op[1], op[2], op[3]);
807 printf (" mx = 0x%x,", mx);
808 printf (" sp = 0x%x,", sp);
809 printf (" rsrc = 0x%x,", rsrc);
810 printf (" rdst = 0x%x\n", rdst);
812 SYNTAX("sbb %1%S1, %0");
813 #line 580 "rx-decode.opc"
814 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
816 /*----------------------------------------------------------------------*/
817 /* ABS */
820 break;
822 break;
823 case 0x04:
824 GETBYTE ();
825 switch (op[3] & 0x00)
827 case 0x00:
828 op_semantics_8:
830 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
831 #line 619 "rx-decode.opc"
832 int mx AU = (op[1] >> 6) & 0x03;
833 #line 619 "rx-decode.opc"
834 int ss AU = op[1] & 0x03;
835 #line 619 "rx-decode.opc"
836 int rsrc AU = (op[3] >> 4) & 0x0f;
837 #line 619 "rx-decode.opc"
838 int rdst AU = op[3] & 0x0f;
839 if (trace)
841 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
842 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
843 op[0], op[1], op[2], op[3]);
844 printf (" mx = 0x%x,", mx);
845 printf (" ss = 0x%x,", ss);
846 printf (" rsrc = 0x%x,", rsrc);
847 printf (" rdst = 0x%x\n", rdst);
849 SYNTAX("max %1%S1, %0");
850 #line 619 "rx-decode.opc"
851 ID(max); SPm(ss, rsrc, mx); DR(rdst);
853 /*----------------------------------------------------------------------*/
854 /* MIN */
857 break;
859 break;
860 case 0x05:
861 GETBYTE ();
862 switch (op[3] & 0x00)
864 case 0x00:
865 op_semantics_9:
867 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
868 #line 631 "rx-decode.opc"
869 int mx AU = (op[1] >> 6) & 0x03;
870 #line 631 "rx-decode.opc"
871 int ss AU = op[1] & 0x03;
872 #line 631 "rx-decode.opc"
873 int rsrc AU = (op[3] >> 4) & 0x0f;
874 #line 631 "rx-decode.opc"
875 int rdst AU = op[3] & 0x0f;
876 if (trace)
878 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
879 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
880 op[0], op[1], op[2], op[3]);
881 printf (" mx = 0x%x,", mx);
882 printf (" ss = 0x%x,", ss);
883 printf (" rsrc = 0x%x,", rsrc);
884 printf (" rdst = 0x%x\n", rdst);
886 SYNTAX("min %1%S1, %0");
887 #line 631 "rx-decode.opc"
888 ID(min); SPm(ss, rsrc, mx); DR(rdst);
890 /*----------------------------------------------------------------------*/
891 /* MUL */
894 break;
896 break;
897 case 0x06:
898 GETBYTE ();
899 switch (op[3] & 0x00)
901 case 0x00:
902 op_semantics_10:
904 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
905 #line 689 "rx-decode.opc"
906 int mx AU = (op[1] >> 6) & 0x03;
907 #line 689 "rx-decode.opc"
908 int ss AU = op[1] & 0x03;
909 #line 689 "rx-decode.opc"
910 int rsrc AU = (op[3] >> 4) & 0x0f;
911 #line 689 "rx-decode.opc"
912 int rdst AU = op[3] & 0x0f;
913 if (trace)
915 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
916 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
917 op[0], op[1], op[2], op[3]);
918 printf (" mx = 0x%x,", mx);
919 printf (" ss = 0x%x,", ss);
920 printf (" rsrc = 0x%x,", rsrc);
921 printf (" rdst = 0x%x\n", rdst);
923 SYNTAX("emul %1%S1, %0");
924 #line 689 "rx-decode.opc"
925 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
927 /*----------------------------------------------------------------------*/
928 /* EMULU */
931 break;
933 break;
934 case 0x07:
935 GETBYTE ();
936 switch (op[3] & 0x00)
938 case 0x00:
939 op_semantics_11:
941 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
942 #line 701 "rx-decode.opc"
943 int mx AU = (op[1] >> 6) & 0x03;
944 #line 701 "rx-decode.opc"
945 int ss AU = op[1] & 0x03;
946 #line 701 "rx-decode.opc"
947 int rsrc AU = (op[3] >> 4) & 0x0f;
948 #line 701 "rx-decode.opc"
949 int rdst AU = op[3] & 0x0f;
950 if (trace)
952 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
953 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
954 op[0], op[1], op[2], op[3]);
955 printf (" mx = 0x%x,", mx);
956 printf (" ss = 0x%x,", ss);
957 printf (" rsrc = 0x%x,", rsrc);
958 printf (" rdst = 0x%x\n", rdst);
960 SYNTAX("emulu %1%S1, %0");
961 #line 701 "rx-decode.opc"
962 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
964 /*----------------------------------------------------------------------*/
965 /* DIV */
968 break;
970 break;
971 case 0x08:
972 GETBYTE ();
973 switch (op[3] & 0x00)
975 case 0x00:
976 op_semantics_12:
978 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
979 #line 713 "rx-decode.opc"
980 int mx AU = (op[1] >> 6) & 0x03;
981 #line 713 "rx-decode.opc"
982 int ss AU = op[1] & 0x03;
983 #line 713 "rx-decode.opc"
984 int rsrc AU = (op[3] >> 4) & 0x0f;
985 #line 713 "rx-decode.opc"
986 int rdst AU = op[3] & 0x0f;
987 if (trace)
989 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
990 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
991 op[0], op[1], op[2], op[3]);
992 printf (" mx = 0x%x,", mx);
993 printf (" ss = 0x%x,", ss);
994 printf (" rsrc = 0x%x,", rsrc);
995 printf (" rdst = 0x%x\n", rdst);
997 SYNTAX("div %1%S1, %0");
998 #line 713 "rx-decode.opc"
999 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1001 /*----------------------------------------------------------------------*/
1002 /* DIVU */
1005 break;
1007 break;
1008 case 0x09:
1009 GETBYTE ();
1010 switch (op[3] & 0x00)
1012 case 0x00:
1013 op_semantics_13:
1015 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
1016 #line 725 "rx-decode.opc"
1017 int mx AU = (op[1] >> 6) & 0x03;
1018 #line 725 "rx-decode.opc"
1019 int ss AU = op[1] & 0x03;
1020 #line 725 "rx-decode.opc"
1021 int rsrc AU = (op[3] >> 4) & 0x0f;
1022 #line 725 "rx-decode.opc"
1023 int rdst AU = op[3] & 0x0f;
1024 if (trace)
1026 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1027 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1028 op[0], op[1], op[2], op[3]);
1029 printf (" mx = 0x%x,", mx);
1030 printf (" ss = 0x%x,", ss);
1031 printf (" rsrc = 0x%x,", rsrc);
1032 printf (" rdst = 0x%x\n", rdst);
1034 SYNTAX("divu %1%S1, %0");
1035 #line 725 "rx-decode.opc"
1036 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1038 /*----------------------------------------------------------------------*/
1039 /* SHIFT */
1042 break;
1044 break;
1045 case 0x0c:
1046 GETBYTE ();
1047 switch (op[3] & 0x00)
1049 case 0x00:
1050 op_semantics_14:
1052 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1053 #line 498 "rx-decode.opc"
1054 int mx AU = (op[1] >> 6) & 0x03;
1055 #line 498 "rx-decode.opc"
1056 int ss AU = op[1] & 0x03;
1057 #line 498 "rx-decode.opc"
1058 int rsrc AU = (op[3] >> 4) & 0x0f;
1059 #line 498 "rx-decode.opc"
1060 int rdst AU = op[3] & 0x0f;
1061 if (trace)
1063 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1064 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1065 op[0], op[1], op[2], op[3]);
1066 printf (" mx = 0x%x,", mx);
1067 printf (" ss = 0x%x,", ss);
1068 printf (" rsrc = 0x%x,", rsrc);
1069 printf (" rdst = 0x%x\n", rdst);
1071 SYNTAX("tst %1%S1, %2");
1072 #line 498 "rx-decode.opc"
1073 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1075 /*----------------------------------------------------------------------*/
1076 /* NEG */
1079 break;
1081 break;
1082 case 0x0d:
1083 GETBYTE ();
1084 switch (op[3] & 0x00)
1086 case 0x00:
1087 op_semantics_15:
1089 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1090 #line 477 "rx-decode.opc"
1091 int mx AU = (op[1] >> 6) & 0x03;
1092 #line 477 "rx-decode.opc"
1093 int ss AU = op[1] & 0x03;
1094 #line 477 "rx-decode.opc"
1095 int rsrc AU = (op[3] >> 4) & 0x0f;
1096 #line 477 "rx-decode.opc"
1097 int rdst AU = op[3] & 0x0f;
1098 if (trace)
1100 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1101 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1102 op[0], op[1], op[2], op[3]);
1103 printf (" mx = 0x%x,", mx);
1104 printf (" ss = 0x%x,", ss);
1105 printf (" rsrc = 0x%x,", rsrc);
1106 printf (" rdst = 0x%x\n", rdst);
1108 SYNTAX("xor %1%S1, %0");
1109 #line 477 "rx-decode.opc"
1110 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1112 /*----------------------------------------------------------------------*/
1113 /* NOT */
1116 break;
1118 break;
1119 case 0x10:
1120 GETBYTE ();
1121 switch (op[3] & 0x00)
1123 case 0x00:
1124 op_semantics_16:
1126 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1127 #line 411 "rx-decode.opc"
1128 int mx AU = (op[1] >> 6) & 0x03;
1129 #line 411 "rx-decode.opc"
1130 int ss AU = op[1] & 0x03;
1131 #line 411 "rx-decode.opc"
1132 int rsrc AU = (op[3] >> 4) & 0x0f;
1133 #line 411 "rx-decode.opc"
1134 int rdst AU = op[3] & 0x0f;
1135 if (trace)
1137 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1138 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1139 op[0], op[1], op[2], op[3]);
1140 printf (" mx = 0x%x,", mx);
1141 printf (" ss = 0x%x,", ss);
1142 printf (" rsrc = 0x%x,", rsrc);
1143 printf (" rdst = 0x%x\n", rdst);
1145 SYNTAX("xchg %1%S1, %0");
1146 #line 411 "rx-decode.opc"
1147 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1149 /*----------------------------------------------------------------------*/
1150 /* STZ/STNZ */
1153 break;
1155 break;
1156 case 0x11:
1157 GETBYTE ();
1158 switch (op[3] & 0x00)
1160 case 0x00:
1161 op_semantics_17:
1163 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1164 #line 954 "rx-decode.opc"
1165 int mx AU = (op[1] >> 6) & 0x03;
1166 #line 954 "rx-decode.opc"
1167 int sd AU = op[1] & 0x03;
1168 #line 954 "rx-decode.opc"
1169 int rsrc AU = (op[3] >> 4) & 0x0f;
1170 #line 954 "rx-decode.opc"
1171 int rdst AU = op[3] & 0x0f;
1172 if (trace)
1174 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1175 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1176 op[0], op[1], op[2], op[3]);
1177 printf (" mx = 0x%x,", mx);
1178 printf (" sd = 0x%x,", sd);
1179 printf (" rsrc = 0x%x,", rsrc);
1180 printf (" rdst = 0x%x\n", rdst);
1182 SYNTAX("itof %1%S1, %0");
1183 #line 954 "rx-decode.opc"
1184 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1186 /*----------------------------------------------------------------------*/
1187 /* BIT OPS */
1190 break;
1192 break;
1193 case 0x15:
1194 GETBYTE ();
1195 switch (op[3] & 0x00)
1197 case 0x00:
1198 op_semantics_18:
1200 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
1201 #line 1140 "rx-decode.opc"
1202 int mx AU = (op[1] >> 6) & 0x03;
1203 #line 1140 "rx-decode.opc"
1204 int sd AU = op[1] & 0x03;
1205 #line 1140 "rx-decode.opc"
1206 int rsrc AU = (op[3] >> 4) & 0x0f;
1207 #line 1140 "rx-decode.opc"
1208 int rdst AU = op[3] & 0x0f;
1209 if (trace)
1211 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1212 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1213 op[0], op[1], op[2], op[3]);
1214 printf (" mx = 0x%x,", mx);
1215 printf (" sd = 0x%x,", sd);
1216 printf (" rsrc = 0x%x,", rsrc);
1217 printf (" rdst = 0x%x\n", rdst);
1219 SYNTAX("utof %1%S1, %0");
1220 #line 1140 "rx-decode.opc"
1221 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1223 /*----------------------------------------------------------------------*/
1224 /* RXv3 enhanced */
1227 break;
1229 break;
1230 default: UNSUPPORTED(); break;
1232 break;
1233 case 0x21:
1234 GETBYTE ();
1235 switch (op[2] & 0xff)
1237 case 0x00:
1238 GETBYTE ();
1239 switch (op[3] & 0x00)
1241 case 0x00:
1242 goto op_semantics_7;
1243 break;
1245 break;
1246 case 0x04:
1247 GETBYTE ();
1248 switch (op[3] & 0x00)
1250 case 0x00:
1251 goto op_semantics_8;
1252 break;
1254 break;
1255 case 0x05:
1256 GETBYTE ();
1257 switch (op[3] & 0x00)
1259 case 0x00:
1260 goto op_semantics_9;
1261 break;
1263 break;
1264 case 0x06:
1265 GETBYTE ();
1266 switch (op[3] & 0x00)
1268 case 0x00:
1269 goto op_semantics_10;
1270 break;
1272 break;
1273 case 0x07:
1274 GETBYTE ();
1275 switch (op[3] & 0x00)
1277 case 0x00:
1278 goto op_semantics_11;
1279 break;
1281 break;
1282 case 0x08:
1283 GETBYTE ();
1284 switch (op[3] & 0x00)
1286 case 0x00:
1287 goto op_semantics_12;
1288 break;
1290 break;
1291 case 0x09:
1292 GETBYTE ();
1293 switch (op[3] & 0x00)
1295 case 0x00:
1296 goto op_semantics_13;
1297 break;
1299 break;
1300 case 0x0c:
1301 GETBYTE ();
1302 switch (op[3] & 0x00)
1304 case 0x00:
1305 goto op_semantics_14;
1306 break;
1308 break;
1309 case 0x0d:
1310 GETBYTE ();
1311 switch (op[3] & 0x00)
1313 case 0x00:
1314 goto op_semantics_15;
1315 break;
1317 break;
1318 case 0x10:
1319 GETBYTE ();
1320 switch (op[3] & 0x00)
1322 case 0x00:
1323 goto op_semantics_16;
1324 break;
1326 break;
1327 case 0x11:
1328 GETBYTE ();
1329 switch (op[3] & 0x00)
1331 case 0x00:
1332 goto op_semantics_17;
1333 break;
1335 break;
1336 case 0x15:
1337 GETBYTE ();
1338 switch (op[3] & 0x00)
1340 case 0x00:
1341 goto op_semantics_18;
1342 break;
1344 break;
1345 default: UNSUPPORTED(); break;
1347 break;
1348 case 0x22:
1349 GETBYTE ();
1350 switch (op[2] & 0xff)
1352 case 0x00:
1353 GETBYTE ();
1354 switch (op[3] & 0x00)
1356 case 0x00:
1357 goto op_semantics_7;
1358 break;
1360 break;
1361 case 0x04:
1362 GETBYTE ();
1363 switch (op[3] & 0x00)
1365 case 0x00:
1366 goto op_semantics_8;
1367 break;
1369 break;
1370 case 0x05:
1371 GETBYTE ();
1372 switch (op[3] & 0x00)
1374 case 0x00:
1375 goto op_semantics_9;
1376 break;
1378 break;
1379 case 0x06:
1380 GETBYTE ();
1381 switch (op[3] & 0x00)
1383 case 0x00:
1384 goto op_semantics_10;
1385 break;
1387 break;
1388 case 0x07:
1389 GETBYTE ();
1390 switch (op[3] & 0x00)
1392 case 0x00:
1393 goto op_semantics_11;
1394 break;
1396 break;
1397 case 0x08:
1398 GETBYTE ();
1399 switch (op[3] & 0x00)
1401 case 0x00:
1402 goto op_semantics_12;
1403 break;
1405 break;
1406 case 0x09:
1407 GETBYTE ();
1408 switch (op[3] & 0x00)
1410 case 0x00:
1411 goto op_semantics_13;
1412 break;
1414 break;
1415 case 0x0c:
1416 GETBYTE ();
1417 switch (op[3] & 0x00)
1419 case 0x00:
1420 goto op_semantics_14;
1421 break;
1423 break;
1424 case 0x0d:
1425 GETBYTE ();
1426 switch (op[3] & 0x00)
1428 case 0x00:
1429 goto op_semantics_15;
1430 break;
1432 break;
1433 case 0x10:
1434 GETBYTE ();
1435 switch (op[3] & 0x00)
1437 case 0x00:
1438 goto op_semantics_16;
1439 break;
1441 break;
1442 case 0x11:
1443 GETBYTE ();
1444 switch (op[3] & 0x00)
1446 case 0x00:
1447 goto op_semantics_17;
1448 break;
1450 break;
1451 case 0x15:
1452 GETBYTE ();
1453 switch (op[3] & 0x00)
1455 case 0x00:
1456 goto op_semantics_18;
1457 break;
1459 break;
1460 default: UNSUPPORTED(); break;
1462 break;
1463 case 0x23:
1464 GETBYTE ();
1465 switch (op[2] & 0xff)
1467 case 0x00:
1468 GETBYTE ();
1469 switch (op[3] & 0x00)
1471 case 0x00:
1472 goto op_semantics_7;
1473 break;
1475 break;
1476 case 0x04:
1477 GETBYTE ();
1478 switch (op[3] & 0x00)
1480 case 0x00:
1481 goto op_semantics_8;
1482 break;
1484 break;
1485 case 0x05:
1486 GETBYTE ();
1487 switch (op[3] & 0x00)
1489 case 0x00:
1490 goto op_semantics_9;
1491 break;
1493 break;
1494 case 0x06:
1495 GETBYTE ();
1496 switch (op[3] & 0x00)
1498 case 0x00:
1499 goto op_semantics_10;
1500 break;
1502 break;
1503 case 0x07:
1504 GETBYTE ();
1505 switch (op[3] & 0x00)
1507 case 0x00:
1508 goto op_semantics_11;
1509 break;
1511 break;
1512 case 0x08:
1513 GETBYTE ();
1514 switch (op[3] & 0x00)
1516 case 0x00:
1517 goto op_semantics_12;
1518 break;
1520 break;
1521 case 0x09:
1522 GETBYTE ();
1523 switch (op[3] & 0x00)
1525 case 0x00:
1526 goto op_semantics_13;
1527 break;
1529 break;
1530 case 0x0c:
1531 GETBYTE ();
1532 switch (op[3] & 0x00)
1534 case 0x00:
1535 goto op_semantics_14;
1536 break;
1538 break;
1539 case 0x0d:
1540 GETBYTE ();
1541 switch (op[3] & 0x00)
1543 case 0x00:
1544 goto op_semantics_15;
1545 break;
1547 break;
1548 case 0x10:
1549 GETBYTE ();
1550 switch (op[3] & 0x00)
1552 case 0x00:
1553 goto op_semantics_16;
1554 break;
1556 break;
1557 case 0x11:
1558 GETBYTE ();
1559 switch (op[3] & 0x00)
1561 case 0x00:
1562 goto op_semantics_17;
1563 break;
1565 break;
1566 case 0x15:
1567 GETBYTE ();
1568 switch (op[3] & 0x00)
1570 case 0x00:
1571 goto op_semantics_18;
1572 break;
1574 break;
1575 default: UNSUPPORTED(); break;
1577 break;
1578 case 0x40:
1579 GETBYTE ();
1580 switch (op[2] & 0x00)
1582 case 0x00:
1583 goto op_semantics_1;
1584 break;
1586 break;
1587 case 0x41:
1588 GETBYTE ();
1589 switch (op[2] & 0x00)
1591 case 0x00:
1592 goto op_semantics_1;
1593 break;
1595 break;
1596 case 0x42:
1597 GETBYTE ();
1598 switch (op[2] & 0x00)
1600 case 0x00:
1601 goto op_semantics_1;
1602 break;
1604 break;
1605 case 0x43:
1606 GETBYTE ();
1607 switch (op[2] & 0x00)
1609 case 0x00:
1610 goto op_semantics_1;
1611 break;
1613 break;
1614 case 0x44:
1615 GETBYTE ();
1616 switch (op[2] & 0x00)
1618 case 0x00:
1619 goto op_semantics_2;
1620 break;
1622 break;
1623 case 0x45:
1624 GETBYTE ();
1625 switch (op[2] & 0x00)
1627 case 0x00:
1628 goto op_semantics_2;
1629 break;
1631 break;
1632 case 0x46:
1633 GETBYTE ();
1634 switch (op[2] & 0x00)
1636 case 0x00:
1637 goto op_semantics_2;
1638 break;
1640 break;
1641 case 0x47:
1642 GETBYTE ();
1643 switch (op[2] & 0x00)
1645 case 0x00:
1646 goto op_semantics_2;
1647 break;
1649 break;
1650 case 0x48:
1651 GETBYTE ();
1652 switch (op[2] & 0x00)
1654 case 0x00:
1655 goto op_semantics_3;
1656 break;
1658 break;
1659 case 0x49:
1660 GETBYTE ();
1661 switch (op[2] & 0x00)
1663 case 0x00:
1664 goto op_semantics_3;
1665 break;
1667 break;
1668 case 0x4a:
1669 GETBYTE ();
1670 switch (op[2] & 0x00)
1672 case 0x00:
1673 goto op_semantics_3;
1674 break;
1676 break;
1677 case 0x4b:
1678 GETBYTE ();
1679 switch (op[2] & 0x00)
1681 case 0x00:
1682 goto op_semantics_3;
1683 break;
1685 break;
1686 case 0x4c:
1687 GETBYTE ();
1688 switch (op[2] & 0x00)
1690 case 0x00:
1691 goto op_semantics_4;
1692 break;
1694 break;
1695 case 0x4d:
1696 GETBYTE ();
1697 switch (op[2] & 0x00)
1699 case 0x00:
1700 goto op_semantics_4;
1701 break;
1703 break;
1704 case 0x4e:
1705 GETBYTE ();
1706 switch (op[2] & 0x00)
1708 case 0x00:
1709 goto op_semantics_4;
1710 break;
1712 break;
1713 case 0x4f:
1714 GETBYTE ();
1715 switch (op[2] & 0x00)
1717 case 0x00:
1718 goto op_semantics_4;
1719 break;
1721 break;
1722 case 0x50:
1723 GETBYTE ();
1724 switch (op[2] & 0x00)
1726 case 0x00:
1727 goto op_semantics_5;
1728 break;
1730 break;
1731 case 0x51:
1732 GETBYTE ();
1733 switch (op[2] & 0x00)
1735 case 0x00:
1736 goto op_semantics_5;
1737 break;
1739 break;
1740 case 0x52:
1741 GETBYTE ();
1742 switch (op[2] & 0x00)
1744 case 0x00:
1745 goto op_semantics_5;
1746 break;
1748 break;
1749 case 0x53:
1750 GETBYTE ();
1751 switch (op[2] & 0x00)
1753 case 0x00:
1754 goto op_semantics_5;
1755 break;
1757 break;
1758 case 0x54:
1759 GETBYTE ();
1760 switch (op[2] & 0x00)
1762 case 0x00:
1763 goto op_semantics_6;
1764 break;
1766 break;
1767 case 0x55:
1768 GETBYTE ();
1769 switch (op[2] & 0x00)
1771 case 0x00:
1772 goto op_semantics_6;
1773 break;
1775 break;
1776 case 0x56:
1777 GETBYTE ();
1778 switch (op[2] & 0x00)
1780 case 0x00:
1781 goto op_semantics_6;
1782 break;
1784 break;
1785 case 0x57:
1786 GETBYTE ();
1787 switch (op[2] & 0x00)
1789 case 0x00:
1790 goto op_semantics_6;
1791 break;
1793 break;
1794 case 0x60:
1795 GETBYTE ();
1796 switch (op[2] & 0xff)
1798 case 0x00:
1799 GETBYTE ();
1800 switch (op[3] & 0x00)
1802 case 0x00:
1803 goto op_semantics_7;
1804 break;
1806 break;
1807 case 0x04:
1808 GETBYTE ();
1809 switch (op[3] & 0x00)
1811 case 0x00:
1812 goto op_semantics_8;
1813 break;
1815 break;
1816 case 0x05:
1817 GETBYTE ();
1818 switch (op[3] & 0x00)
1820 case 0x00:
1821 goto op_semantics_9;
1822 break;
1824 break;
1825 case 0x06:
1826 GETBYTE ();
1827 switch (op[3] & 0x00)
1829 case 0x00:
1830 goto op_semantics_10;
1831 break;
1833 break;
1834 case 0x07:
1835 GETBYTE ();
1836 switch (op[3] & 0x00)
1838 case 0x00:
1839 goto op_semantics_11;
1840 break;
1842 break;
1843 case 0x08:
1844 GETBYTE ();
1845 switch (op[3] & 0x00)
1847 case 0x00:
1848 goto op_semantics_12;
1849 break;
1851 break;
1852 case 0x09:
1853 GETBYTE ();
1854 switch (op[3] & 0x00)
1856 case 0x00:
1857 goto op_semantics_13;
1858 break;
1860 break;
1861 case 0x0c:
1862 GETBYTE ();
1863 switch (op[3] & 0x00)
1865 case 0x00:
1866 goto op_semantics_14;
1867 break;
1869 break;
1870 case 0x0d:
1871 GETBYTE ();
1872 switch (op[3] & 0x00)
1874 case 0x00:
1875 goto op_semantics_15;
1876 break;
1878 break;
1879 case 0x10:
1880 GETBYTE ();
1881 switch (op[3] & 0x00)
1883 case 0x00:
1884 goto op_semantics_16;
1885 break;
1887 break;
1888 case 0x11:
1889 GETBYTE ();
1890 switch (op[3] & 0x00)
1892 case 0x00:
1893 goto op_semantics_17;
1894 break;
1896 break;
1897 case 0x15:
1898 GETBYTE ();
1899 switch (op[3] & 0x00)
1901 case 0x00:
1902 goto op_semantics_18;
1903 break;
1905 break;
1906 default: UNSUPPORTED(); break;
1908 break;
1909 case 0x61:
1910 GETBYTE ();
1911 switch (op[2] & 0xff)
1913 case 0x00:
1914 GETBYTE ();
1915 switch (op[3] & 0x00)
1917 case 0x00:
1918 goto op_semantics_7;
1919 break;
1921 break;
1922 case 0x04:
1923 GETBYTE ();
1924 switch (op[3] & 0x00)
1926 case 0x00:
1927 goto op_semantics_8;
1928 break;
1930 break;
1931 case 0x05:
1932 GETBYTE ();
1933 switch (op[3] & 0x00)
1935 case 0x00:
1936 goto op_semantics_9;
1937 break;
1939 break;
1940 case 0x06:
1941 GETBYTE ();
1942 switch (op[3] & 0x00)
1944 case 0x00:
1945 goto op_semantics_10;
1946 break;
1948 break;
1949 case 0x07:
1950 GETBYTE ();
1951 switch (op[3] & 0x00)
1953 case 0x00:
1954 goto op_semantics_11;
1955 break;
1957 break;
1958 case 0x08:
1959 GETBYTE ();
1960 switch (op[3] & 0x00)
1962 case 0x00:
1963 goto op_semantics_12;
1964 break;
1966 break;
1967 case 0x09:
1968 GETBYTE ();
1969 switch (op[3] & 0x00)
1971 case 0x00:
1972 goto op_semantics_13;
1973 break;
1975 break;
1976 case 0x0c:
1977 GETBYTE ();
1978 switch (op[3] & 0x00)
1980 case 0x00:
1981 goto op_semantics_14;
1982 break;
1984 break;
1985 case 0x0d:
1986 GETBYTE ();
1987 switch (op[3] & 0x00)
1989 case 0x00:
1990 goto op_semantics_15;
1991 break;
1993 break;
1994 case 0x10:
1995 GETBYTE ();
1996 switch (op[3] & 0x00)
1998 case 0x00:
1999 goto op_semantics_16;
2000 break;
2002 break;
2003 case 0x11:
2004 GETBYTE ();
2005 switch (op[3] & 0x00)
2007 case 0x00:
2008 goto op_semantics_17;
2009 break;
2011 break;
2012 case 0x15:
2013 GETBYTE ();
2014 switch (op[3] & 0x00)
2016 case 0x00:
2017 goto op_semantics_18;
2018 break;
2020 break;
2021 default: UNSUPPORTED(); break;
2023 break;
2024 case 0x62:
2025 GETBYTE ();
2026 switch (op[2] & 0xff)
2028 case 0x00:
2029 GETBYTE ();
2030 switch (op[3] & 0x00)
2032 case 0x00:
2033 goto op_semantics_7;
2034 break;
2036 break;
2037 case 0x04:
2038 GETBYTE ();
2039 switch (op[3] & 0x00)
2041 case 0x00:
2042 goto op_semantics_8;
2043 break;
2045 break;
2046 case 0x05:
2047 GETBYTE ();
2048 switch (op[3] & 0x00)
2050 case 0x00:
2051 goto op_semantics_9;
2052 break;
2054 break;
2055 case 0x06:
2056 GETBYTE ();
2057 switch (op[3] & 0x00)
2059 case 0x00:
2060 goto op_semantics_10;
2061 break;
2063 break;
2064 case 0x07:
2065 GETBYTE ();
2066 switch (op[3] & 0x00)
2068 case 0x00:
2069 goto op_semantics_11;
2070 break;
2072 break;
2073 case 0x08:
2074 GETBYTE ();
2075 switch (op[3] & 0x00)
2077 case 0x00:
2078 goto op_semantics_12;
2079 break;
2081 break;
2082 case 0x09:
2083 GETBYTE ();
2084 switch (op[3] & 0x00)
2086 case 0x00:
2087 goto op_semantics_13;
2088 break;
2090 break;
2091 case 0x0c:
2092 GETBYTE ();
2093 switch (op[3] & 0x00)
2095 case 0x00:
2096 goto op_semantics_14;
2097 break;
2099 break;
2100 case 0x0d:
2101 GETBYTE ();
2102 switch (op[3] & 0x00)
2104 case 0x00:
2105 goto op_semantics_15;
2106 break;
2108 break;
2109 case 0x10:
2110 GETBYTE ();
2111 switch (op[3] & 0x00)
2113 case 0x00:
2114 goto op_semantics_16;
2115 break;
2117 break;
2118 case 0x11:
2119 GETBYTE ();
2120 switch (op[3] & 0x00)
2122 case 0x00:
2123 goto op_semantics_17;
2124 break;
2126 break;
2127 case 0x15:
2128 GETBYTE ();
2129 switch (op[3] & 0x00)
2131 case 0x00:
2132 goto op_semantics_18;
2133 break;
2135 break;
2136 default: UNSUPPORTED(); break;
2138 break;
2139 case 0x63:
2140 GETBYTE ();
2141 switch (op[2] & 0xff)
2143 case 0x00:
2144 GETBYTE ();
2145 switch (op[3] & 0x00)
2147 case 0x00:
2148 goto op_semantics_7;
2149 break;
2151 break;
2152 case 0x04:
2153 GETBYTE ();
2154 switch (op[3] & 0x00)
2156 case 0x00:
2157 goto op_semantics_8;
2158 break;
2160 break;
2161 case 0x05:
2162 GETBYTE ();
2163 switch (op[3] & 0x00)
2165 case 0x00:
2166 goto op_semantics_9;
2167 break;
2169 break;
2170 case 0x06:
2171 GETBYTE ();
2172 switch (op[3] & 0x00)
2174 case 0x00:
2175 goto op_semantics_10;
2176 break;
2178 break;
2179 case 0x07:
2180 GETBYTE ();
2181 switch (op[3] & 0x00)
2183 case 0x00:
2184 goto op_semantics_11;
2185 break;
2187 break;
2188 case 0x08:
2189 GETBYTE ();
2190 switch (op[3] & 0x00)
2192 case 0x00:
2193 goto op_semantics_12;
2194 break;
2196 break;
2197 case 0x09:
2198 GETBYTE ();
2199 switch (op[3] & 0x00)
2201 case 0x00:
2202 goto op_semantics_13;
2203 break;
2205 break;
2206 case 0x0c:
2207 GETBYTE ();
2208 switch (op[3] & 0x00)
2210 case 0x00:
2211 goto op_semantics_14;
2212 break;
2214 break;
2215 case 0x0d:
2216 GETBYTE ();
2217 switch (op[3] & 0x00)
2219 case 0x00:
2220 goto op_semantics_15;
2221 break;
2223 break;
2224 case 0x10:
2225 GETBYTE ();
2226 switch (op[3] & 0x00)
2228 case 0x00:
2229 goto op_semantics_16;
2230 break;
2232 break;
2233 case 0x11:
2234 GETBYTE ();
2235 switch (op[3] & 0x00)
2237 case 0x00:
2238 goto op_semantics_17;
2239 break;
2241 break;
2242 case 0x15:
2243 GETBYTE ();
2244 switch (op[3] & 0x00)
2246 case 0x00:
2247 goto op_semantics_18;
2248 break;
2250 break;
2251 default: UNSUPPORTED(); break;
2253 break;
2254 case 0x80:
2255 GETBYTE ();
2256 switch (op[2] & 0x00)
2258 case 0x00:
2259 goto op_semantics_1;
2260 break;
2262 break;
2263 case 0x81:
2264 GETBYTE ();
2265 switch (op[2] & 0x00)
2267 case 0x00:
2268 goto op_semantics_1;
2269 break;
2271 break;
2272 case 0x82:
2273 GETBYTE ();
2274 switch (op[2] & 0x00)
2276 case 0x00:
2277 goto op_semantics_1;
2278 break;
2280 break;
2281 case 0x83:
2282 GETBYTE ();
2283 switch (op[2] & 0x00)
2285 case 0x00:
2286 goto op_semantics_1;
2287 break;
2289 break;
2290 case 0x84:
2291 GETBYTE ();
2292 switch (op[2] & 0x00)
2294 case 0x00:
2295 goto op_semantics_2;
2296 break;
2298 break;
2299 case 0x85:
2300 GETBYTE ();
2301 switch (op[2] & 0x00)
2303 case 0x00:
2304 goto op_semantics_2;
2305 break;
2307 break;
2308 case 0x86:
2309 GETBYTE ();
2310 switch (op[2] & 0x00)
2312 case 0x00:
2313 goto op_semantics_2;
2314 break;
2316 break;
2317 case 0x87:
2318 GETBYTE ();
2319 switch (op[2] & 0x00)
2321 case 0x00:
2322 goto op_semantics_2;
2323 break;
2325 break;
2326 case 0x88:
2327 GETBYTE ();
2328 switch (op[2] & 0x00)
2330 case 0x00:
2331 goto op_semantics_3;
2332 break;
2334 break;
2335 case 0x89:
2336 GETBYTE ();
2337 switch (op[2] & 0x00)
2339 case 0x00:
2340 goto op_semantics_3;
2341 break;
2343 break;
2344 case 0x8a:
2345 GETBYTE ();
2346 switch (op[2] & 0x00)
2348 case 0x00:
2349 goto op_semantics_3;
2350 break;
2352 break;
2353 case 0x8b:
2354 GETBYTE ();
2355 switch (op[2] & 0x00)
2357 case 0x00:
2358 goto op_semantics_3;
2359 break;
2361 break;
2362 case 0x8c:
2363 GETBYTE ();
2364 switch (op[2] & 0x00)
2366 case 0x00:
2367 goto op_semantics_4;
2368 break;
2370 break;
2371 case 0x8d:
2372 GETBYTE ();
2373 switch (op[2] & 0x00)
2375 case 0x00:
2376 goto op_semantics_4;
2377 break;
2379 break;
2380 case 0x8e:
2381 GETBYTE ();
2382 switch (op[2] & 0x00)
2384 case 0x00:
2385 goto op_semantics_4;
2386 break;
2388 break;
2389 case 0x8f:
2390 GETBYTE ();
2391 switch (op[2] & 0x00)
2393 case 0x00:
2394 goto op_semantics_4;
2395 break;
2397 break;
2398 case 0x90:
2399 GETBYTE ();
2400 switch (op[2] & 0x00)
2402 case 0x00:
2403 goto op_semantics_5;
2404 break;
2406 break;
2407 case 0x91:
2408 GETBYTE ();
2409 switch (op[2] & 0x00)
2411 case 0x00:
2412 goto op_semantics_5;
2413 break;
2415 break;
2416 case 0x92:
2417 GETBYTE ();
2418 switch (op[2] & 0x00)
2420 case 0x00:
2421 goto op_semantics_5;
2422 break;
2424 break;
2425 case 0x93:
2426 GETBYTE ();
2427 switch (op[2] & 0x00)
2429 case 0x00:
2430 goto op_semantics_5;
2431 break;
2433 break;
2434 case 0x94:
2435 GETBYTE ();
2436 switch (op[2] & 0x00)
2438 case 0x00:
2439 goto op_semantics_6;
2440 break;
2442 break;
2443 case 0x95:
2444 GETBYTE ();
2445 switch (op[2] & 0x00)
2447 case 0x00:
2448 goto op_semantics_6;
2449 break;
2451 break;
2452 case 0x96:
2453 GETBYTE ();
2454 switch (op[2] & 0x00)
2456 case 0x00:
2457 goto op_semantics_6;
2458 break;
2460 break;
2461 case 0x97:
2462 GETBYTE ();
2463 switch (op[2] & 0x00)
2465 case 0x00:
2466 goto op_semantics_6;
2467 break;
2469 break;
2470 case 0xa0:
2471 GETBYTE ();
2472 switch (op[2] & 0xff)
2474 case 0x00:
2475 GETBYTE ();
2476 switch (op[3] & 0x00)
2478 case 0x00:
2479 goto op_semantics_7;
2480 break;
2482 break;
2483 case 0x02:
2484 GETBYTE ();
2485 switch (op[3] & 0x00)
2487 case 0x00:
2488 op_semantics_19:
2490 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2491 #line 519 "rx-decode.opc"
2492 int ss AU = op[1] & 0x03;
2493 #line 519 "rx-decode.opc"
2494 int rsrc AU = (op[3] >> 4) & 0x0f;
2495 #line 519 "rx-decode.opc"
2496 int rdst AU = op[3] & 0x0f;
2497 if (trace)
2499 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2500 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2501 op[0], op[1], op[2], op[3]);
2502 printf (" ss = 0x%x,", ss);
2503 printf (" rsrc = 0x%x,", rsrc);
2504 printf (" rdst = 0x%x\n", rdst);
2506 SYNTAX("adc %1%S1, %0");
2507 #line 519 "rx-decode.opc"
2508 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2510 /*----------------------------------------------------------------------*/
2511 /* ADD */
2514 break;
2516 break;
2517 case 0x04:
2518 GETBYTE ();
2519 switch (op[3] & 0x00)
2521 case 0x00:
2522 goto op_semantics_8;
2523 break;
2525 break;
2526 case 0x05:
2527 GETBYTE ();
2528 switch (op[3] & 0x00)
2530 case 0x00:
2531 goto op_semantics_9;
2532 break;
2534 break;
2535 case 0x06:
2536 GETBYTE ();
2537 switch (op[3] & 0x00)
2539 case 0x00:
2540 goto op_semantics_10;
2541 break;
2543 break;
2544 case 0x07:
2545 GETBYTE ();
2546 switch (op[3] & 0x00)
2548 case 0x00:
2549 goto op_semantics_11;
2550 break;
2552 break;
2553 case 0x08:
2554 GETBYTE ();
2555 switch (op[3] & 0x00)
2557 case 0x00:
2558 goto op_semantics_12;
2559 break;
2561 break;
2562 case 0x09:
2563 GETBYTE ();
2564 switch (op[3] & 0x00)
2566 case 0x00:
2567 goto op_semantics_13;
2568 break;
2570 break;
2571 case 0x0c:
2572 GETBYTE ();
2573 switch (op[3] & 0x00)
2575 case 0x00:
2576 goto op_semantics_14;
2577 break;
2579 break;
2580 case 0x0d:
2581 GETBYTE ();
2582 switch (op[3] & 0x00)
2584 case 0x00:
2585 goto op_semantics_15;
2586 break;
2588 break;
2589 case 0x10:
2590 GETBYTE ();
2591 switch (op[3] & 0x00)
2593 case 0x00:
2594 goto op_semantics_16;
2595 break;
2597 break;
2598 case 0x11:
2599 GETBYTE ();
2600 switch (op[3] & 0x00)
2602 case 0x00:
2603 goto op_semantics_17;
2604 break;
2606 break;
2607 case 0x15:
2608 GETBYTE ();
2609 switch (op[3] & 0x00)
2611 case 0x00:
2612 goto op_semantics_18;
2613 break;
2615 break;
2616 default: UNSUPPORTED(); break;
2618 break;
2619 case 0xa1:
2620 GETBYTE ();
2621 switch (op[2] & 0xff)
2623 case 0x00:
2624 GETBYTE ();
2625 switch (op[3] & 0x00)
2627 case 0x00:
2628 goto op_semantics_7;
2629 break;
2631 break;
2632 case 0x02:
2633 GETBYTE ();
2634 switch (op[3] & 0x00)
2636 case 0x00:
2637 goto op_semantics_19;
2638 break;
2640 break;
2641 case 0x04:
2642 GETBYTE ();
2643 switch (op[3] & 0x00)
2645 case 0x00:
2646 goto op_semantics_8;
2647 break;
2649 break;
2650 case 0x05:
2651 GETBYTE ();
2652 switch (op[3] & 0x00)
2654 case 0x00:
2655 goto op_semantics_9;
2656 break;
2658 break;
2659 case 0x06:
2660 GETBYTE ();
2661 switch (op[3] & 0x00)
2663 case 0x00:
2664 goto op_semantics_10;
2665 break;
2667 break;
2668 case 0x07:
2669 GETBYTE ();
2670 switch (op[3] & 0x00)
2672 case 0x00:
2673 goto op_semantics_11;
2674 break;
2676 break;
2677 case 0x08:
2678 GETBYTE ();
2679 switch (op[3] & 0x00)
2681 case 0x00:
2682 goto op_semantics_12;
2683 break;
2685 break;
2686 case 0x09:
2687 GETBYTE ();
2688 switch (op[3] & 0x00)
2690 case 0x00:
2691 goto op_semantics_13;
2692 break;
2694 break;
2695 case 0x0c:
2696 GETBYTE ();
2697 switch (op[3] & 0x00)
2699 case 0x00:
2700 goto op_semantics_14;
2701 break;
2703 break;
2704 case 0x0d:
2705 GETBYTE ();
2706 switch (op[3] & 0x00)
2708 case 0x00:
2709 goto op_semantics_15;
2710 break;
2712 break;
2713 case 0x10:
2714 GETBYTE ();
2715 switch (op[3] & 0x00)
2717 case 0x00:
2718 goto op_semantics_16;
2719 break;
2721 break;
2722 case 0x11:
2723 GETBYTE ();
2724 switch (op[3] & 0x00)
2726 case 0x00:
2727 goto op_semantics_17;
2728 break;
2730 break;
2731 case 0x15:
2732 GETBYTE ();
2733 switch (op[3] & 0x00)
2735 case 0x00:
2736 goto op_semantics_18;
2737 break;
2739 break;
2740 default: UNSUPPORTED(); break;
2742 break;
2743 case 0xa2:
2744 GETBYTE ();
2745 switch (op[2] & 0xff)
2747 case 0x00:
2748 GETBYTE ();
2749 switch (op[3] & 0x00)
2751 case 0x00:
2752 goto op_semantics_7;
2753 break;
2755 break;
2756 case 0x02:
2757 GETBYTE ();
2758 switch (op[3] & 0x00)
2760 case 0x00:
2761 goto op_semantics_19;
2762 break;
2764 break;
2765 case 0x04:
2766 GETBYTE ();
2767 switch (op[3] & 0x00)
2769 case 0x00:
2770 goto op_semantics_8;
2771 break;
2773 break;
2774 case 0x05:
2775 GETBYTE ();
2776 switch (op[3] & 0x00)
2778 case 0x00:
2779 goto op_semantics_9;
2780 break;
2782 break;
2783 case 0x06:
2784 GETBYTE ();
2785 switch (op[3] & 0x00)
2787 case 0x00:
2788 goto op_semantics_10;
2789 break;
2791 break;
2792 case 0x07:
2793 GETBYTE ();
2794 switch (op[3] & 0x00)
2796 case 0x00:
2797 goto op_semantics_11;
2798 break;
2800 break;
2801 case 0x08:
2802 GETBYTE ();
2803 switch (op[3] & 0x00)
2805 case 0x00:
2806 goto op_semantics_12;
2807 break;
2809 break;
2810 case 0x09:
2811 GETBYTE ();
2812 switch (op[3] & 0x00)
2814 case 0x00:
2815 goto op_semantics_13;
2816 break;
2818 break;
2819 case 0x0c:
2820 GETBYTE ();
2821 switch (op[3] & 0x00)
2823 case 0x00:
2824 goto op_semantics_14;
2825 break;
2827 break;
2828 case 0x0d:
2829 GETBYTE ();
2830 switch (op[3] & 0x00)
2832 case 0x00:
2833 goto op_semantics_15;
2834 break;
2836 break;
2837 case 0x10:
2838 GETBYTE ();
2839 switch (op[3] & 0x00)
2841 case 0x00:
2842 goto op_semantics_16;
2843 break;
2845 break;
2846 case 0x11:
2847 GETBYTE ();
2848 switch (op[3] & 0x00)
2850 case 0x00:
2851 goto op_semantics_17;
2852 break;
2854 break;
2855 case 0x15:
2856 GETBYTE ();
2857 switch (op[3] & 0x00)
2859 case 0x00:
2860 goto op_semantics_18;
2861 break;
2863 break;
2864 default: UNSUPPORTED(); break;
2866 break;
2867 case 0xa3:
2868 GETBYTE ();
2869 switch (op[2] & 0xff)
2871 case 0x00:
2872 GETBYTE ();
2873 switch (op[3] & 0x00)
2875 case 0x00:
2876 goto op_semantics_7;
2877 break;
2879 break;
2880 case 0x02:
2881 GETBYTE ();
2882 switch (op[3] & 0x00)
2884 case 0x00:
2885 goto op_semantics_19;
2886 break;
2888 break;
2889 case 0x04:
2890 GETBYTE ();
2891 switch (op[3] & 0x00)
2893 case 0x00:
2894 goto op_semantics_8;
2895 break;
2897 break;
2898 case 0x05:
2899 GETBYTE ();
2900 switch (op[3] & 0x00)
2902 case 0x00:
2903 goto op_semantics_9;
2904 break;
2906 break;
2907 case 0x06:
2908 GETBYTE ();
2909 switch (op[3] & 0x00)
2911 case 0x00:
2912 goto op_semantics_10;
2913 break;
2915 break;
2916 case 0x07:
2917 GETBYTE ();
2918 switch (op[3] & 0x00)
2920 case 0x00:
2921 goto op_semantics_11;
2922 break;
2924 break;
2925 case 0x08:
2926 GETBYTE ();
2927 switch (op[3] & 0x00)
2929 case 0x00:
2930 goto op_semantics_12;
2931 break;
2933 break;
2934 case 0x09:
2935 GETBYTE ();
2936 switch (op[3] & 0x00)
2938 case 0x00:
2939 goto op_semantics_13;
2940 break;
2942 break;
2943 case 0x0c:
2944 GETBYTE ();
2945 switch (op[3] & 0x00)
2947 case 0x00:
2948 goto op_semantics_14;
2949 break;
2951 break;
2952 case 0x0d:
2953 GETBYTE ();
2954 switch (op[3] & 0x00)
2956 case 0x00:
2957 goto op_semantics_15;
2958 break;
2960 break;
2961 case 0x10:
2962 GETBYTE ();
2963 switch (op[3] & 0x00)
2965 case 0x00:
2966 goto op_semantics_16;
2967 break;
2969 break;
2970 case 0x11:
2971 GETBYTE ();
2972 switch (op[3] & 0x00)
2974 case 0x00:
2975 goto op_semantics_17;
2976 break;
2978 break;
2979 case 0x15:
2980 GETBYTE ();
2981 switch (op[3] & 0x00)
2983 case 0x00:
2984 goto op_semantics_18;
2985 break;
2987 break;
2988 default: UNSUPPORTED(); break;
2990 break;
2991 case 0xc0:
2992 GETBYTE ();
2993 switch (op[2] & 0x00)
2995 case 0x00:
2996 goto op_semantics_1;
2997 break;
2999 break;
3000 case 0xc1:
3001 GETBYTE ();
3002 switch (op[2] & 0x00)
3004 case 0x00:
3005 goto op_semantics_1;
3006 break;
3008 break;
3009 case 0xc2:
3010 GETBYTE ();
3011 switch (op[2] & 0x00)
3013 case 0x00:
3014 goto op_semantics_1;
3015 break;
3017 break;
3018 case 0xc3:
3019 GETBYTE ();
3020 switch (op[2] & 0x00)
3022 case 0x00:
3023 goto op_semantics_1;
3024 break;
3026 break;
3027 case 0xc4:
3028 GETBYTE ();
3029 switch (op[2] & 0x00)
3031 case 0x00:
3032 goto op_semantics_2;
3033 break;
3035 break;
3036 case 0xc5:
3037 GETBYTE ();
3038 switch (op[2] & 0x00)
3040 case 0x00:
3041 goto op_semantics_2;
3042 break;
3044 break;
3045 case 0xc6:
3046 GETBYTE ();
3047 switch (op[2] & 0x00)
3049 case 0x00:
3050 goto op_semantics_2;
3051 break;
3053 break;
3054 case 0xc7:
3055 GETBYTE ();
3056 switch (op[2] & 0x00)
3058 case 0x00:
3059 goto op_semantics_2;
3060 break;
3062 break;
3063 case 0xc8:
3064 GETBYTE ();
3065 switch (op[2] & 0x00)
3067 case 0x00:
3068 goto op_semantics_3;
3069 break;
3071 break;
3072 case 0xc9:
3073 GETBYTE ();
3074 switch (op[2] & 0x00)
3076 case 0x00:
3077 goto op_semantics_3;
3078 break;
3080 break;
3081 case 0xca:
3082 GETBYTE ();
3083 switch (op[2] & 0x00)
3085 case 0x00:
3086 goto op_semantics_3;
3087 break;
3089 break;
3090 case 0xcb:
3091 GETBYTE ();
3092 switch (op[2] & 0x00)
3094 case 0x00:
3095 goto op_semantics_3;
3096 break;
3098 break;
3099 case 0xcc:
3100 GETBYTE ();
3101 switch (op[2] & 0x00)
3103 case 0x00:
3104 goto op_semantics_4;
3105 break;
3107 break;
3108 case 0xcd:
3109 GETBYTE ();
3110 switch (op[2] & 0x00)
3112 case 0x00:
3113 goto op_semantics_4;
3114 break;
3116 break;
3117 case 0xce:
3118 GETBYTE ();
3119 switch (op[2] & 0x00)
3121 case 0x00:
3122 goto op_semantics_4;
3123 break;
3125 break;
3126 case 0xcf:
3127 GETBYTE ();
3128 switch (op[2] & 0x00)
3130 case 0x00:
3131 goto op_semantics_4;
3132 break;
3134 break;
3135 case 0xd0:
3136 GETBYTE ();
3137 switch (op[2] & 0x00)
3139 case 0x00:
3140 goto op_semantics_5;
3141 break;
3143 break;
3144 case 0xd1:
3145 GETBYTE ();
3146 switch (op[2] & 0x00)
3148 case 0x00:
3149 goto op_semantics_5;
3150 break;
3152 break;
3153 case 0xd2:
3154 GETBYTE ();
3155 switch (op[2] & 0x00)
3157 case 0x00:
3158 goto op_semantics_5;
3159 break;
3161 break;
3162 case 0xd3:
3163 GETBYTE ();
3164 switch (op[2] & 0x00)
3166 case 0x00:
3167 goto op_semantics_5;
3168 break;
3170 break;
3171 case 0xd4:
3172 GETBYTE ();
3173 switch (op[2] & 0x00)
3175 case 0x00:
3176 goto op_semantics_6;
3177 break;
3179 break;
3180 case 0xd5:
3181 GETBYTE ();
3182 switch (op[2] & 0x00)
3184 case 0x00:
3185 goto op_semantics_6;
3186 break;
3188 break;
3189 case 0xd6:
3190 GETBYTE ();
3191 switch (op[2] & 0x00)
3193 case 0x00:
3194 goto op_semantics_6;
3195 break;
3197 break;
3198 case 0xd7:
3199 GETBYTE ();
3200 switch (op[2] & 0x00)
3202 case 0x00:
3203 goto op_semantics_6;
3204 break;
3206 break;
3207 case 0xe0:
3208 GETBYTE ();
3209 switch (op[2] & 0xff)
3211 case 0x00:
3212 GETBYTE ();
3213 switch (op[3] & 0x00)
3215 case 0x00:
3216 goto op_semantics_7;
3217 break;
3219 break;
3220 case 0x04:
3221 GETBYTE ();
3222 switch (op[3] & 0x00)
3224 case 0x00:
3225 goto op_semantics_8;
3226 break;
3228 break;
3229 case 0x05:
3230 GETBYTE ();
3231 switch (op[3] & 0x00)
3233 case 0x00:
3234 goto op_semantics_9;
3235 break;
3237 break;
3238 case 0x06:
3239 GETBYTE ();
3240 switch (op[3] & 0x00)
3242 case 0x00:
3243 goto op_semantics_10;
3244 break;
3246 break;
3247 case 0x07:
3248 GETBYTE ();
3249 switch (op[3] & 0x00)
3251 case 0x00:
3252 goto op_semantics_11;
3253 break;
3255 break;
3256 case 0x08:
3257 GETBYTE ();
3258 switch (op[3] & 0x00)
3260 case 0x00:
3261 goto op_semantics_12;
3262 break;
3264 break;
3265 case 0x09:
3266 GETBYTE ();
3267 switch (op[3] & 0x00)
3269 case 0x00:
3270 goto op_semantics_13;
3271 break;
3273 break;
3274 case 0x0c:
3275 GETBYTE ();
3276 switch (op[3] & 0x00)
3278 case 0x00:
3279 goto op_semantics_14;
3280 break;
3282 break;
3283 case 0x0d:
3284 GETBYTE ();
3285 switch (op[3] & 0x00)
3287 case 0x00:
3288 goto op_semantics_15;
3289 break;
3291 break;
3292 case 0x10:
3293 GETBYTE ();
3294 switch (op[3] & 0x00)
3296 case 0x00:
3297 goto op_semantics_16;
3298 break;
3300 break;
3301 case 0x11:
3302 GETBYTE ();
3303 switch (op[3] & 0x00)
3305 case 0x00:
3306 goto op_semantics_17;
3307 break;
3309 break;
3310 case 0x15:
3311 GETBYTE ();
3312 switch (op[3] & 0x00)
3314 case 0x00:
3315 goto op_semantics_18;
3316 break;
3318 break;
3319 default: UNSUPPORTED(); break;
3321 break;
3322 case 0xe1:
3323 GETBYTE ();
3324 switch (op[2] & 0xff)
3326 case 0x00:
3327 GETBYTE ();
3328 switch (op[3] & 0x00)
3330 case 0x00:
3331 goto op_semantics_7;
3332 break;
3334 break;
3335 case 0x04:
3336 GETBYTE ();
3337 switch (op[3] & 0x00)
3339 case 0x00:
3340 goto op_semantics_8;
3341 break;
3343 break;
3344 case 0x05:
3345 GETBYTE ();
3346 switch (op[3] & 0x00)
3348 case 0x00:
3349 goto op_semantics_9;
3350 break;
3352 break;
3353 case 0x06:
3354 GETBYTE ();
3355 switch (op[3] & 0x00)
3357 case 0x00:
3358 goto op_semantics_10;
3359 break;
3361 break;
3362 case 0x07:
3363 GETBYTE ();
3364 switch (op[3] & 0x00)
3366 case 0x00:
3367 goto op_semantics_11;
3368 break;
3370 break;
3371 case 0x08:
3372 GETBYTE ();
3373 switch (op[3] & 0x00)
3375 case 0x00:
3376 goto op_semantics_12;
3377 break;
3379 break;
3380 case 0x09:
3381 GETBYTE ();
3382 switch (op[3] & 0x00)
3384 case 0x00:
3385 goto op_semantics_13;
3386 break;
3388 break;
3389 case 0x0c:
3390 GETBYTE ();
3391 switch (op[3] & 0x00)
3393 case 0x00:
3394 goto op_semantics_14;
3395 break;
3397 break;
3398 case 0x0d:
3399 GETBYTE ();
3400 switch (op[3] & 0x00)
3402 case 0x00:
3403 goto op_semantics_15;
3404 break;
3406 break;
3407 case 0x10:
3408 GETBYTE ();
3409 switch (op[3] & 0x00)
3411 case 0x00:
3412 goto op_semantics_16;
3413 break;
3415 break;
3416 case 0x11:
3417 GETBYTE ();
3418 switch (op[3] & 0x00)
3420 case 0x00:
3421 goto op_semantics_17;
3422 break;
3424 break;
3425 case 0x15:
3426 GETBYTE ();
3427 switch (op[3] & 0x00)
3429 case 0x00:
3430 goto op_semantics_18;
3431 break;
3433 break;
3434 default: UNSUPPORTED(); break;
3436 break;
3437 case 0xe2:
3438 GETBYTE ();
3439 switch (op[2] & 0xff)
3441 case 0x00:
3442 GETBYTE ();
3443 switch (op[3] & 0x00)
3445 case 0x00:
3446 goto op_semantics_7;
3447 break;
3449 break;
3450 case 0x04:
3451 GETBYTE ();
3452 switch (op[3] & 0x00)
3454 case 0x00:
3455 goto op_semantics_8;
3456 break;
3458 break;
3459 case 0x05:
3460 GETBYTE ();
3461 switch (op[3] & 0x00)
3463 case 0x00:
3464 goto op_semantics_9;
3465 break;
3467 break;
3468 case 0x06:
3469 GETBYTE ();
3470 switch (op[3] & 0x00)
3472 case 0x00:
3473 goto op_semantics_10;
3474 break;
3476 break;
3477 case 0x07:
3478 GETBYTE ();
3479 switch (op[3] & 0x00)
3481 case 0x00:
3482 goto op_semantics_11;
3483 break;
3485 break;
3486 case 0x08:
3487 GETBYTE ();
3488 switch (op[3] & 0x00)
3490 case 0x00:
3491 goto op_semantics_12;
3492 break;
3494 break;
3495 case 0x09:
3496 GETBYTE ();
3497 switch (op[3] & 0x00)
3499 case 0x00:
3500 goto op_semantics_13;
3501 break;
3503 break;
3504 case 0x0c:
3505 GETBYTE ();
3506 switch (op[3] & 0x00)
3508 case 0x00:
3509 goto op_semantics_14;
3510 break;
3512 break;
3513 case 0x0d:
3514 GETBYTE ();
3515 switch (op[3] & 0x00)
3517 case 0x00:
3518 goto op_semantics_15;
3519 break;
3521 break;
3522 case 0x10:
3523 GETBYTE ();
3524 switch (op[3] & 0x00)
3526 case 0x00:
3527 goto op_semantics_16;
3528 break;
3530 break;
3531 case 0x11:
3532 GETBYTE ();
3533 switch (op[3] & 0x00)
3535 case 0x00:
3536 goto op_semantics_17;
3537 break;
3539 break;
3540 case 0x15:
3541 GETBYTE ();
3542 switch (op[3] & 0x00)
3544 case 0x00:
3545 goto op_semantics_18;
3546 break;
3548 break;
3549 default: UNSUPPORTED(); break;
3551 break;
3552 case 0xe3:
3553 GETBYTE ();
3554 switch (op[2] & 0xff)
3556 case 0x00:
3557 GETBYTE ();
3558 switch (op[3] & 0x00)
3560 case 0x00:
3561 goto op_semantics_7;
3562 break;
3564 break;
3565 case 0x04:
3566 GETBYTE ();
3567 switch (op[3] & 0x00)
3569 case 0x00:
3570 goto op_semantics_8;
3571 break;
3573 break;
3574 case 0x05:
3575 GETBYTE ();
3576 switch (op[3] & 0x00)
3578 case 0x00:
3579 goto op_semantics_9;
3580 break;
3582 break;
3583 case 0x06:
3584 GETBYTE ();
3585 switch (op[3] & 0x00)
3587 case 0x00:
3588 goto op_semantics_10;
3589 break;
3591 break;
3592 case 0x07:
3593 GETBYTE ();
3594 switch (op[3] & 0x00)
3596 case 0x00:
3597 goto op_semantics_11;
3598 break;
3600 break;
3601 case 0x08:
3602 GETBYTE ();
3603 switch (op[3] & 0x00)
3605 case 0x00:
3606 goto op_semantics_12;
3607 break;
3609 break;
3610 case 0x09:
3611 GETBYTE ();
3612 switch (op[3] & 0x00)
3614 case 0x00:
3615 goto op_semantics_13;
3616 break;
3618 break;
3619 case 0x0c:
3620 GETBYTE ();
3621 switch (op[3] & 0x00)
3623 case 0x00:
3624 goto op_semantics_14;
3625 break;
3627 break;
3628 case 0x0d:
3629 GETBYTE ();
3630 switch (op[3] & 0x00)
3632 case 0x00:
3633 goto op_semantics_15;
3634 break;
3636 break;
3637 case 0x10:
3638 GETBYTE ();
3639 switch (op[3] & 0x00)
3641 case 0x00:
3642 goto op_semantics_16;
3643 break;
3645 break;
3646 case 0x11:
3647 GETBYTE ();
3648 switch (op[3] & 0x00)
3650 case 0x00:
3651 goto op_semantics_17;
3652 break;
3654 break;
3655 case 0x15:
3656 GETBYTE ();
3657 switch (op[3] & 0x00)
3659 case 0x00:
3660 goto op_semantics_18;
3661 break;
3663 break;
3664 default: UNSUPPORTED(); break;
3666 break;
3667 default: UNSUPPORTED(); break;
3669 break;
3670 case 0x08:
3671 case 0x09:
3672 case 0x0a:
3673 case 0x0b:
3674 case 0x0c:
3675 case 0x0d:
3676 case 0x0e:
3677 case 0x0f:
3679 /** 0000 1dsp bra.s %a0 */
3680 #line 800 "rx-decode.opc"
3681 int dsp AU = op[0] & 0x07;
3682 if (trace)
3684 printf ("\033[33m%s\033[0m %02x\n",
3685 "/** 0000 1dsp bra.s %a0 */",
3686 op[0]);
3687 printf (" dsp = 0x%x\n", dsp);
3689 SYNTAX("bra.s %a0");
3690 #line 800 "rx-decode.opc"
3691 ID(branch); DC(pc + dsp3map[dsp]);
3694 break;
3695 case 0x10:
3696 case 0x11:
3697 case 0x12:
3698 case 0x13:
3699 case 0x14:
3700 case 0x15:
3701 case 0x16:
3702 case 0x17:
3703 case 0x18:
3704 case 0x19:
3705 case 0x1a:
3706 case 0x1b:
3707 case 0x1c:
3708 case 0x1d:
3709 case 0x1e:
3710 case 0x1f:
3712 /** 0001 n dsp b%1.s %a0 */
3713 #line 790 "rx-decode.opc"
3714 int n AU = (op[0] >> 3) & 0x01;
3715 #line 790 "rx-decode.opc"
3716 int dsp AU = op[0] & 0x07;
3717 if (trace)
3719 printf ("\033[33m%s\033[0m %02x\n",
3720 "/** 0001 n dsp b%1.s %a0 */",
3721 op[0]);
3722 printf (" n = 0x%x,", n);
3723 printf (" dsp = 0x%x\n", dsp);
3725 SYNTAX("b%1.s %a0");
3726 #line 790 "rx-decode.opc"
3727 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3730 break;
3731 case 0x20:
3732 case 0x21:
3733 case 0x22:
3734 case 0x23:
3735 case 0x24:
3736 case 0x25:
3737 case 0x26:
3738 case 0x27:
3739 case 0x28:
3740 case 0x29:
3741 case 0x2a:
3742 case 0x2b:
3743 case 0x2c:
3744 case 0x2d:
3745 case 0x2f:
3747 /** 0010 cond b%1.b %a0 */
3748 #line 793 "rx-decode.opc"
3749 int cond AU = op[0] & 0x0f;
3750 if (trace)
3752 printf ("\033[33m%s\033[0m %02x\n",
3753 "/** 0010 cond b%1.b %a0 */",
3754 op[0]);
3755 printf (" cond = 0x%x\n", cond);
3757 SYNTAX("b%1.b %a0");
3758 #line 793 "rx-decode.opc"
3759 ID(branch); Scc(cond); DC(pc + IMMex (1));
3762 break;
3763 case 0x2e:
3765 /** 0010 1110 bra.b %a0 */
3766 if (trace)
3768 printf ("\033[33m%s\033[0m %02x\n",
3769 "/** 0010 1110 bra.b %a0 */",
3770 op[0]);
3772 SYNTAX("bra.b %a0");
3773 #line 803 "rx-decode.opc"
3774 ID(branch); DC(pc + IMMex(1));
3777 break;
3778 case 0x38:
3780 /** 0011 1000 bra.w %a0 */
3781 if (trace)
3783 printf ("\033[33m%s\033[0m %02x\n",
3784 "/** 0011 1000 bra.w %a0 */",
3785 op[0]);
3787 SYNTAX("bra.w %a0");
3788 #line 806 "rx-decode.opc"
3789 ID(branch); DC(pc + IMMex(2));
3792 break;
3793 case 0x39:
3795 /** 0011 1001 bsr.w %a0 */
3796 if (trace)
3798 printf ("\033[33m%s\033[0m %02x\n",
3799 "/** 0011 1001 bsr.w %a0 */",
3800 op[0]);
3802 SYNTAX("bsr.w %a0");
3803 #line 822 "rx-decode.opc"
3804 ID(jsr); DC(pc + IMMex(2));
3807 break;
3808 case 0x3a:
3809 case 0x3b:
3811 /** 0011 101c b%1.w %a0 */
3812 #line 796 "rx-decode.opc"
3813 int c AU = op[0] & 0x01;
3814 if (trace)
3816 printf ("\033[33m%s\033[0m %02x\n",
3817 "/** 0011 101c b%1.w %a0 */",
3818 op[0]);
3819 printf (" c = 0x%x\n", c);
3821 SYNTAX("b%1.w %a0");
3822 #line 796 "rx-decode.opc"
3823 ID(branch); Scc(c); DC(pc + IMMex (2));
3827 break;
3828 case 0x3c:
3829 GETBYTE ();
3830 switch (op[1] & 0x00)
3832 case 0x00:
3833 op_semantics_20:
3835 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3836 #line 332 "rx-decode.opc"
3837 int sz AU = op[0] & 0x03;
3838 #line 332 "rx-decode.opc"
3839 int d AU = (op[1] >> 7) & 0x01;
3840 #line 332 "rx-decode.opc"
3841 int dst AU = (op[1] >> 4) & 0x07;
3842 #line 332 "rx-decode.opc"
3843 int sppp AU = op[1] & 0x0f;
3844 if (trace)
3846 printf ("\033[33m%s\033[0m %02x %02x\n",
3847 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3848 op[0], op[1]);
3849 printf (" sz = 0x%x,", sz);
3850 printf (" d = 0x%x,", d);
3851 printf (" dst = 0x%x,", dst);
3852 printf (" sppp = 0x%x\n", sppp);
3854 SYNTAX("mov%s #%1, %0");
3855 #line 332 "rx-decode.opc"
3856 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3859 break;
3861 break;
3862 case 0x3d:
3863 GETBYTE ();
3864 switch (op[1] & 0x00)
3866 case 0x00:
3867 goto op_semantics_20;
3868 break;
3870 break;
3871 case 0x3e:
3872 GETBYTE ();
3873 switch (op[1] & 0x00)
3875 case 0x00:
3876 goto op_semantics_20;
3877 break;
3879 break;
3880 case 0x3f:
3881 GETBYTE ();
3882 switch (op[1] & 0x00)
3884 case 0x00:
3886 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3887 #line 429 "rx-decode.opc"
3888 int rega AU = (op[1] >> 4) & 0x0f;
3889 #line 429 "rx-decode.opc"
3890 int regb AU = op[1] & 0x0f;
3891 if (trace)
3893 printf ("\033[33m%s\033[0m %02x %02x\n",
3894 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3895 op[0], op[1]);
3896 printf (" rega = 0x%x,", rega);
3897 printf (" regb = 0x%x\n", regb);
3899 SYNTAX("rtsd #%1, %2-%0");
3900 #line 429 "rx-decode.opc"
3901 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3903 /*----------------------------------------------------------------------*/
3904 /* AND */
3907 break;
3909 break;
3910 case 0x40:
3911 GETBYTE ();
3912 switch (op[1] & 0x00)
3914 case 0x00:
3915 op_semantics_21:
3917 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3918 #line 564 "rx-decode.opc"
3919 int ss AU = op[0] & 0x03;
3920 #line 564 "rx-decode.opc"
3921 int rsrc AU = (op[1] >> 4) & 0x0f;
3922 #line 564 "rx-decode.opc"
3923 int rdst AU = op[1] & 0x0f;
3924 if (trace)
3926 printf ("\033[33m%s\033[0m %02x %02x\n",
3927 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3928 op[0], op[1]);
3929 printf (" ss = 0x%x,", ss);
3930 printf (" rsrc = 0x%x,", rsrc);
3931 printf (" rdst = 0x%x\n", rdst);
3933 SYNTAX("sub %2%S2, %1");
3934 #line 564 "rx-decode.opc"
3935 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3938 break;
3940 break;
3941 case 0x41:
3942 GETBYTE ();
3943 switch (op[1] & 0x00)
3945 case 0x00:
3946 goto op_semantics_21;
3947 break;
3949 break;
3950 case 0x42:
3951 GETBYTE ();
3952 switch (op[1] & 0x00)
3954 case 0x00:
3955 goto op_semantics_21;
3956 break;
3958 break;
3959 case 0x43:
3960 GETBYTE ();
3961 switch (op[1] & 0x00)
3963 case 0x00:
3964 goto op_semantics_21;
3965 break;
3967 break;
3968 case 0x44:
3969 GETBYTE ();
3970 switch (op[1] & 0x00)
3972 case 0x00:
3973 op_semantics_22:
3975 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3976 #line 552 "rx-decode.opc"
3977 int ss AU = op[0] & 0x03;
3978 #line 552 "rx-decode.opc"
3979 int rsrc AU = (op[1] >> 4) & 0x0f;
3980 #line 552 "rx-decode.opc"
3981 int rdst AU = op[1] & 0x0f;
3982 if (trace)
3984 printf ("\033[33m%s\033[0m %02x %02x\n",
3985 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3986 op[0], op[1]);
3987 printf (" ss = 0x%x,", ss);
3988 printf (" rsrc = 0x%x,", rsrc);
3989 printf (" rdst = 0x%x\n", rdst);
3991 SYNTAX("cmp %2%S2, %1");
3992 #line 552 "rx-decode.opc"
3993 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3996 break;
3998 break;
3999 case 0x45:
4000 GETBYTE ();
4001 switch (op[1] & 0x00)
4003 case 0x00:
4004 goto op_semantics_22;
4005 break;
4007 break;
4008 case 0x46:
4009 GETBYTE ();
4010 switch (op[1] & 0x00)
4012 case 0x00:
4013 goto op_semantics_22;
4014 break;
4016 break;
4017 case 0x47:
4018 GETBYTE ();
4019 switch (op[1] & 0x00)
4021 case 0x00:
4022 goto op_semantics_22;
4023 break;
4025 break;
4026 case 0x48:
4027 GETBYTE ();
4028 switch (op[1] & 0x00)
4030 case 0x00:
4031 op_semantics_23:
4033 /** 0100 10ss rsrc rdst add %1%S1, %0 */
4034 #line 528 "rx-decode.opc"
4035 int ss AU = op[0] & 0x03;
4036 #line 528 "rx-decode.opc"
4037 int rsrc AU = (op[1] >> 4) & 0x0f;
4038 #line 528 "rx-decode.opc"
4039 int rdst AU = op[1] & 0x0f;
4040 if (trace)
4042 printf ("\033[33m%s\033[0m %02x %02x\n",
4043 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4044 op[0], op[1]);
4045 printf (" ss = 0x%x,", ss);
4046 printf (" rsrc = 0x%x,", rsrc);
4047 printf (" rdst = 0x%x\n", rdst);
4049 SYNTAX("add %1%S1, %0");
4050 #line 528 "rx-decode.opc"
4051 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4054 break;
4056 break;
4057 case 0x49:
4058 GETBYTE ();
4059 switch (op[1] & 0x00)
4061 case 0x00:
4062 goto op_semantics_23;
4063 break;
4065 break;
4066 case 0x4a:
4067 GETBYTE ();
4068 switch (op[1] & 0x00)
4070 case 0x00:
4071 goto op_semantics_23;
4072 break;
4074 break;
4075 case 0x4b:
4076 GETBYTE ();
4077 switch (op[1] & 0x00)
4079 case 0x00:
4080 goto op_semantics_23;
4081 break;
4083 break;
4084 case 0x4c:
4085 GETBYTE ();
4086 switch (op[1] & 0x00)
4088 case 0x00:
4089 op_semantics_24:
4091 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
4092 #line 671 "rx-decode.opc"
4093 int ss AU = op[0] & 0x03;
4094 #line 671 "rx-decode.opc"
4095 int rsrc AU = (op[1] >> 4) & 0x0f;
4096 #line 671 "rx-decode.opc"
4097 int rdst AU = op[1] & 0x0f;
4098 if (trace)
4100 printf ("\033[33m%s\033[0m %02x %02x\n",
4101 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4102 op[0], op[1]);
4103 printf (" ss = 0x%x,", ss);
4104 printf (" rsrc = 0x%x,", rsrc);
4105 printf (" rdst = 0x%x\n", rdst);
4107 SYNTAX("mul %1%S1, %0");
4108 #line 671 "rx-decode.opc"
4109 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4112 break;
4114 break;
4115 case 0x4d:
4116 GETBYTE ();
4117 switch (op[1] & 0x00)
4119 case 0x00:
4120 goto op_semantics_24;
4121 break;
4123 break;
4124 case 0x4e:
4125 GETBYTE ();
4126 switch (op[1] & 0x00)
4128 case 0x00:
4129 goto op_semantics_24;
4130 break;
4132 break;
4133 case 0x4f:
4134 GETBYTE ();
4135 switch (op[1] & 0x00)
4137 case 0x00:
4138 goto op_semantics_24;
4139 break;
4141 break;
4142 case 0x50:
4143 GETBYTE ();
4144 switch (op[1] & 0x00)
4146 case 0x00:
4147 op_semantics_25:
4149 /** 0101 00ss rsrc rdst and %1%S1, %0 */
4150 #line 441 "rx-decode.opc"
4151 int ss AU = op[0] & 0x03;
4152 #line 441 "rx-decode.opc"
4153 int rsrc AU = (op[1] >> 4) & 0x0f;
4154 #line 441 "rx-decode.opc"
4155 int rdst AU = op[1] & 0x0f;
4156 if (trace)
4158 printf ("\033[33m%s\033[0m %02x %02x\n",
4159 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4160 op[0], op[1]);
4161 printf (" ss = 0x%x,", ss);
4162 printf (" rsrc = 0x%x,", rsrc);
4163 printf (" rdst = 0x%x\n", rdst);
4165 SYNTAX("and %1%S1, %0");
4166 #line 441 "rx-decode.opc"
4167 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4170 break;
4172 break;
4173 case 0x51:
4174 GETBYTE ();
4175 switch (op[1] & 0x00)
4177 case 0x00:
4178 goto op_semantics_25;
4179 break;
4181 break;
4182 case 0x52:
4183 GETBYTE ();
4184 switch (op[1] & 0x00)
4186 case 0x00:
4187 goto op_semantics_25;
4188 break;
4190 break;
4191 case 0x53:
4192 GETBYTE ();
4193 switch (op[1] & 0x00)
4195 case 0x00:
4196 goto op_semantics_25;
4197 break;
4199 break;
4200 case 0x54:
4201 GETBYTE ();
4202 switch (op[1] & 0x00)
4204 case 0x00:
4205 op_semantics_26:
4207 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4208 #line 459 "rx-decode.opc"
4209 int ss AU = op[0] & 0x03;
4210 #line 459 "rx-decode.opc"
4211 int rsrc AU = (op[1] >> 4) & 0x0f;
4212 #line 459 "rx-decode.opc"
4213 int rdst AU = op[1] & 0x0f;
4214 if (trace)
4216 printf ("\033[33m%s\033[0m %02x %02x\n",
4217 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4218 op[0], op[1]);
4219 printf (" ss = 0x%x,", ss);
4220 printf (" rsrc = 0x%x,", rsrc);
4221 printf (" rdst = 0x%x\n", rdst);
4223 SYNTAX("or %1%S1, %0");
4224 #line 459 "rx-decode.opc"
4225 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4228 break;
4230 break;
4231 case 0x55:
4232 GETBYTE ();
4233 switch (op[1] & 0x00)
4235 case 0x00:
4236 goto op_semantics_26;
4237 break;
4239 break;
4240 case 0x56:
4241 GETBYTE ();
4242 switch (op[1] & 0x00)
4244 case 0x00:
4245 goto op_semantics_26;
4246 break;
4248 break;
4249 case 0x57:
4250 GETBYTE ();
4251 switch (op[1] & 0x00)
4253 case 0x00:
4254 goto op_semantics_26;
4255 break;
4257 break;
4258 case 0x58:
4259 GETBYTE ();
4260 switch (op[1] & 0x00)
4262 case 0x00:
4263 op_semantics_27:
4265 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4266 #line 380 "rx-decode.opc"
4267 int s AU = (op[0] >> 2) & 0x01;
4268 #line 380 "rx-decode.opc"
4269 int ss AU = op[0] & 0x03;
4270 #line 380 "rx-decode.opc"
4271 int rsrc AU = (op[1] >> 4) & 0x0f;
4272 #line 380 "rx-decode.opc"
4273 int rdst AU = op[1] & 0x0f;
4274 if (trace)
4276 printf ("\033[33m%s\033[0m %02x %02x\n",
4277 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4278 op[0], op[1]);
4279 printf (" s = 0x%x,", s);
4280 printf (" ss = 0x%x,", ss);
4281 printf (" rsrc = 0x%x,", rsrc);
4282 printf (" rdst = 0x%x\n", rdst);
4284 SYNTAX("movu%s %1, %0");
4285 #line 380 "rx-decode.opc"
4286 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4289 break;
4291 break;
4292 case 0x59:
4293 GETBYTE ();
4294 switch (op[1] & 0x00)
4296 case 0x00:
4297 goto op_semantics_27;
4298 break;
4300 break;
4301 case 0x5a:
4302 GETBYTE ();
4303 switch (op[1] & 0x00)
4305 case 0x00:
4306 goto op_semantics_27;
4307 break;
4309 break;
4310 case 0x5b:
4311 GETBYTE ();
4312 switch (op[1] & 0x00)
4314 case 0x00:
4315 goto op_semantics_27;
4316 break;
4318 break;
4319 case 0x5c:
4320 GETBYTE ();
4321 switch (op[1] & 0x00)
4323 case 0x00:
4324 goto op_semantics_27;
4325 break;
4327 break;
4328 case 0x5d:
4329 GETBYTE ();
4330 switch (op[1] & 0x00)
4332 case 0x00:
4333 goto op_semantics_27;
4334 break;
4336 break;
4337 case 0x5e:
4338 GETBYTE ();
4339 switch (op[1] & 0x00)
4341 case 0x00:
4342 goto op_semantics_27;
4343 break;
4345 break;
4346 case 0x5f:
4347 GETBYTE ();
4348 switch (op[1] & 0x00)
4350 case 0x00:
4351 goto op_semantics_27;
4352 break;
4354 break;
4355 case 0x60:
4356 GETBYTE ();
4357 switch (op[1] & 0x00)
4359 case 0x00:
4361 /** 0110 0000 immm rdst sub #%2, %0 */
4362 #line 561 "rx-decode.opc"
4363 int immm AU = (op[1] >> 4) & 0x0f;
4364 #line 561 "rx-decode.opc"
4365 int rdst AU = op[1] & 0x0f;
4366 if (trace)
4368 printf ("\033[33m%s\033[0m %02x %02x\n",
4369 "/** 0110 0000 immm rdst sub #%2, %0 */",
4370 op[0], op[1]);
4371 printf (" immm = 0x%x,", immm);
4372 printf (" rdst = 0x%x\n", rdst);
4374 SYNTAX("sub #%2, %0");
4375 #line 561 "rx-decode.opc"
4376 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4379 break;
4381 break;
4382 case 0x61:
4383 GETBYTE ();
4384 switch (op[1] & 0x00)
4386 case 0x00:
4388 /** 0110 0001 immm rdst cmp #%2, %1 */
4389 #line 543 "rx-decode.opc"
4390 int immm AU = (op[1] >> 4) & 0x0f;
4391 #line 543 "rx-decode.opc"
4392 int rdst AU = op[1] & 0x0f;
4393 if (trace)
4395 printf ("\033[33m%s\033[0m %02x %02x\n",
4396 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4397 op[0], op[1]);
4398 printf (" immm = 0x%x,", immm);
4399 printf (" rdst = 0x%x\n", rdst);
4401 SYNTAX("cmp #%2, %1");
4402 #line 543 "rx-decode.opc"
4403 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4406 break;
4408 break;
4409 case 0x62:
4410 GETBYTE ();
4411 switch (op[1] & 0x00)
4413 case 0x00:
4415 /** 0110 0010 immm rdst add #%1, %0 */
4416 #line 525 "rx-decode.opc"
4417 int immm AU = (op[1] >> 4) & 0x0f;
4418 #line 525 "rx-decode.opc"
4419 int rdst AU = op[1] & 0x0f;
4420 if (trace)
4422 printf ("\033[33m%s\033[0m %02x %02x\n",
4423 "/** 0110 0010 immm rdst add #%1, %0 */",
4424 op[0], op[1]);
4425 printf (" immm = 0x%x,", immm);
4426 printf (" rdst = 0x%x\n", rdst);
4428 SYNTAX("add #%1, %0");
4429 #line 525 "rx-decode.opc"
4430 ID(add); SC(immm); DR(rdst); F_OSZC;
4433 break;
4435 break;
4436 case 0x63:
4437 GETBYTE ();
4438 switch (op[1] & 0x00)
4440 case 0x00:
4442 /** 0110 0011 immm rdst mul #%1, %0 */
4443 #line 637 "rx-decode.opc"
4444 int immm AU = (op[1] >> 4) & 0x0f;
4445 #line 637 "rx-decode.opc"
4446 int rdst AU = op[1] & 0x0f;
4447 if (trace)
4449 printf ("\033[33m%s\033[0m %02x %02x\n",
4450 "/** 0110 0011 immm rdst mul #%1, %0 */",
4451 op[0], op[1]);
4452 printf (" immm = 0x%x,", immm);
4453 printf (" rdst = 0x%x\n", rdst);
4455 SYNTAX("mul #%1, %0");
4456 #line 637 "rx-decode.opc"
4457 if (immm == 1 && rdst == 0)
4459 ID(nop2);
4460 SYNTAX ("nop\t; mul\t#1, r0");
4462 else
4464 ID(mul);
4466 DR(rdst); SC(immm); F_____;
4469 break;
4471 break;
4472 case 0x64:
4473 GETBYTE ();
4474 switch (op[1] & 0x00)
4476 case 0x00:
4478 /** 0110 0100 immm rdst and #%1, %0 */
4479 #line 435 "rx-decode.opc"
4480 int immm AU = (op[1] >> 4) & 0x0f;
4481 #line 435 "rx-decode.opc"
4482 int rdst AU = op[1] & 0x0f;
4483 if (trace)
4485 printf ("\033[33m%s\033[0m %02x %02x\n",
4486 "/** 0110 0100 immm rdst and #%1, %0 */",
4487 op[0], op[1]);
4488 printf (" immm = 0x%x,", immm);
4489 printf (" rdst = 0x%x\n", rdst);
4491 SYNTAX("and #%1, %0");
4492 #line 435 "rx-decode.opc"
4493 ID(and); SC(immm); DR(rdst); F__SZ_;
4496 break;
4498 break;
4499 case 0x65:
4500 GETBYTE ();
4501 switch (op[1] & 0x00)
4503 case 0x00:
4505 /** 0110 0101 immm rdst or #%1, %0 */
4506 #line 453 "rx-decode.opc"
4507 int immm AU = (op[1] >> 4) & 0x0f;
4508 #line 453 "rx-decode.opc"
4509 int rdst AU = op[1] & 0x0f;
4510 if (trace)
4512 printf ("\033[33m%s\033[0m %02x %02x\n",
4513 "/** 0110 0101 immm rdst or #%1, %0 */",
4514 op[0], op[1]);
4515 printf (" immm = 0x%x,", immm);
4516 printf (" rdst = 0x%x\n", rdst);
4518 SYNTAX("or #%1, %0");
4519 #line 453 "rx-decode.opc"
4520 ID(or); SC(immm); DR(rdst); F__SZ_;
4523 break;
4525 break;
4526 case 0x66:
4527 GETBYTE ();
4528 switch (op[1] & 0x00)
4530 case 0x00:
4532 /** 0110 0110 immm rdst mov%s #%1, %0 */
4533 #line 329 "rx-decode.opc"
4534 int immm AU = (op[1] >> 4) & 0x0f;
4535 #line 329 "rx-decode.opc"
4536 int rdst AU = op[1] & 0x0f;
4537 if (trace)
4539 printf ("\033[33m%s\033[0m %02x %02x\n",
4540 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4541 op[0], op[1]);
4542 printf (" immm = 0x%x,", immm);
4543 printf (" rdst = 0x%x\n", rdst);
4545 SYNTAX("mov%s #%1, %0");
4546 #line 329 "rx-decode.opc"
4547 ID(mov); DR(rdst); SC(immm); F_____;
4550 break;
4552 break;
4553 case 0x67:
4555 /** 0110 0111 rtsd #%1 */
4556 if (trace)
4558 printf ("\033[33m%s\033[0m %02x\n",
4559 "/** 0110 0111 rtsd #%1 */",
4560 op[0]);
4562 SYNTAX("rtsd #%1");
4563 #line 426 "rx-decode.opc"
4564 ID(rtsd); SC(IMM(1) * 4);
4567 break;
4568 case 0x68:
4569 GETBYTE ();
4570 switch (op[1] & 0x00)
4572 case 0x00:
4573 op_semantics_28:
4575 /** 0110 100i mmmm rdst shlr #%2, %0 */
4576 #line 751 "rx-decode.opc"
4577 int i AU = op[0] & 0x01;
4578 #line 751 "rx-decode.opc"
4579 int mmmm AU = (op[1] >> 4) & 0x0f;
4580 #line 751 "rx-decode.opc"
4581 int rdst AU = op[1] & 0x0f;
4582 if (trace)
4584 printf ("\033[33m%s\033[0m %02x %02x\n",
4585 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4586 op[0], op[1]);
4587 printf (" i = 0x%x,", i);
4588 printf (" mmmm = 0x%x,", mmmm);
4589 printf (" rdst = 0x%x\n", rdst);
4591 SYNTAX("shlr #%2, %0");
4592 #line 751 "rx-decode.opc"
4593 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4596 break;
4598 break;
4599 case 0x69:
4600 GETBYTE ();
4601 switch (op[1] & 0x00)
4603 case 0x00:
4604 goto op_semantics_28;
4605 break;
4607 break;
4608 case 0x6a:
4609 GETBYTE ();
4610 switch (op[1] & 0x00)
4612 case 0x00:
4613 op_semantics_29:
4615 /** 0110 101i mmmm rdst shar #%2, %0 */
4616 #line 741 "rx-decode.opc"
4617 int i AU = op[0] & 0x01;
4618 #line 741 "rx-decode.opc"
4619 int mmmm AU = (op[1] >> 4) & 0x0f;
4620 #line 741 "rx-decode.opc"
4621 int rdst AU = op[1] & 0x0f;
4622 if (trace)
4624 printf ("\033[33m%s\033[0m %02x %02x\n",
4625 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4626 op[0], op[1]);
4627 printf (" i = 0x%x,", i);
4628 printf (" mmmm = 0x%x,", mmmm);
4629 printf (" rdst = 0x%x\n", rdst);
4631 SYNTAX("shar #%2, %0");
4632 #line 741 "rx-decode.opc"
4633 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4636 break;
4638 break;
4639 case 0x6b:
4640 GETBYTE ();
4641 switch (op[1] & 0x00)
4643 case 0x00:
4644 goto op_semantics_29;
4645 break;
4647 break;
4648 case 0x6c:
4649 GETBYTE ();
4650 switch (op[1] & 0x00)
4652 case 0x00:
4653 op_semantics_30:
4655 /** 0110 110i mmmm rdst shll #%2, %0 */
4656 #line 731 "rx-decode.opc"
4657 int i AU = op[0] & 0x01;
4658 #line 731 "rx-decode.opc"
4659 int mmmm AU = (op[1] >> 4) & 0x0f;
4660 #line 731 "rx-decode.opc"
4661 int rdst AU = op[1] & 0x0f;
4662 if (trace)
4664 printf ("\033[33m%s\033[0m %02x %02x\n",
4665 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4666 op[0], op[1]);
4667 printf (" i = 0x%x,", i);
4668 printf (" mmmm = 0x%x,", mmmm);
4669 printf (" rdst = 0x%x\n", rdst);
4671 SYNTAX("shll #%2, %0");
4672 #line 731 "rx-decode.opc"
4673 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4676 break;
4678 break;
4679 case 0x6d:
4680 GETBYTE ();
4681 switch (op[1] & 0x00)
4683 case 0x00:
4684 goto op_semantics_30;
4685 break;
4687 break;
4688 case 0x6e:
4689 GETBYTE ();
4690 switch (op[1] & 0x00)
4692 case 0x00:
4694 /** 0110 1110 dsta dstb pushm %1-%2 */
4695 #line 393 "rx-decode.opc"
4696 int dsta AU = (op[1] >> 4) & 0x0f;
4697 #line 393 "rx-decode.opc"
4698 int dstb AU = op[1] & 0x0f;
4699 if (trace)
4701 printf ("\033[33m%s\033[0m %02x %02x\n",
4702 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4703 op[0], op[1]);
4704 printf (" dsta = 0x%x,", dsta);
4705 printf (" dstb = 0x%x\n", dstb);
4707 SYNTAX("pushm %1-%2");
4708 #line 393 "rx-decode.opc"
4709 ID(pushm); SR(dsta); S2R(dstb); F_____;
4712 break;
4714 break;
4715 case 0x6f:
4716 GETBYTE ();
4717 switch (op[1] & 0x00)
4719 case 0x00:
4721 /** 0110 1111 dsta dstb popm %1-%2 */
4722 #line 390 "rx-decode.opc"
4723 int dsta AU = (op[1] >> 4) & 0x0f;
4724 #line 390 "rx-decode.opc"
4725 int dstb AU = op[1] & 0x0f;
4726 if (trace)
4728 printf ("\033[33m%s\033[0m %02x %02x\n",
4729 "/** 0110 1111 dsta dstb popm %1-%2 */",
4730 op[0], op[1]);
4731 printf (" dsta = 0x%x,", dsta);
4732 printf (" dstb = 0x%x\n", dstb);
4734 SYNTAX("popm %1-%2");
4735 #line 390 "rx-decode.opc"
4736 ID(popm); SR(dsta); S2R(dstb); F_____;
4739 break;
4741 break;
4742 case 0x70:
4743 GETBYTE ();
4744 switch (op[1] & 0x00)
4746 case 0x00:
4747 op_semantics_31:
4749 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4750 #line 534 "rx-decode.opc"
4751 int im AU = op[0] & 0x03;
4752 #line 534 "rx-decode.opc"
4753 int rsrc AU = (op[1] >> 4) & 0x0f;
4754 #line 534 "rx-decode.opc"
4755 int rdst AU = op[1] & 0x0f;
4756 if (trace)
4758 printf ("\033[33m%s\033[0m %02x %02x\n",
4759 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4760 op[0], op[1]);
4761 printf (" im = 0x%x,", im);
4762 printf (" rsrc = 0x%x,", rsrc);
4763 printf (" rdst = 0x%x\n", rdst);
4765 SYNTAX("add #%1, %2, %0");
4766 #line 534 "rx-decode.opc"
4767 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4770 break;
4772 break;
4773 case 0x71:
4774 GETBYTE ();
4775 switch (op[1] & 0x00)
4777 case 0x00:
4778 goto op_semantics_31;
4779 break;
4781 break;
4782 case 0x72:
4783 GETBYTE ();
4784 switch (op[1] & 0x00)
4786 case 0x00:
4787 goto op_semantics_31;
4788 break;
4790 break;
4791 case 0x73:
4792 GETBYTE ();
4793 switch (op[1] & 0x00)
4795 case 0x00:
4796 goto op_semantics_31;
4797 break;
4799 break;
4800 case 0x74:
4801 GETBYTE ();
4802 switch (op[1] & 0xf0)
4804 case 0x00:
4805 op_semantics_32:
4807 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4808 #line 546 "rx-decode.opc"
4809 int im AU = op[0] & 0x03;
4810 #line 546 "rx-decode.opc"
4811 int rsrc AU = op[1] & 0x0f;
4812 if (trace)
4814 printf ("\033[33m%s\033[0m %02x %02x\n",
4815 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4816 op[0], op[1]);
4817 printf (" im = 0x%x,", im);
4818 printf (" rsrc = 0x%x\n", rsrc);
4820 SYNTAX("cmp #%2, %1%S1");
4821 #line 546 "rx-decode.opc"
4822 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4825 break;
4826 case 0x10:
4827 op_semantics_33:
4829 /** 0111 01im 0001rdst mul #%1, %0 */
4830 #line 649 "rx-decode.opc"
4831 int im AU = op[0] & 0x03;
4832 #line 649 "rx-decode.opc"
4833 int rdst AU = op[1] & 0x0f;
4834 if (trace)
4836 printf ("\033[33m%s\033[0m %02x %02x\n",
4837 "/** 0111 01im 0001rdst mul #%1, %0 */",
4838 op[0], op[1]);
4839 printf (" im = 0x%x,", im);
4840 printf (" rdst = 0x%x\n", rdst);
4842 SYNTAX("mul #%1, %0");
4843 #line 649 "rx-decode.opc"
4844 int val = IMMex(im);
4845 if (val == 1 && rdst == 0)
4847 SYNTAX("nop\t; mul\t#1, r0");
4848 switch (im)
4850 case 2: ID(nop4); break;
4851 case 3: ID(nop5); break;
4852 case 0: ID(nop6); break;
4853 default:
4854 ID(mul);
4855 SYNTAX("mul #%1, %0");
4856 break;
4859 else
4861 ID(mul);
4863 DR(rdst); SC(val); F_____;
4866 break;
4867 case 0x20:
4868 op_semantics_34:
4870 /** 0111 01im 0010 rdst and #%1, %0 */
4871 #line 438 "rx-decode.opc"
4872 int im AU = op[0] & 0x03;
4873 #line 438 "rx-decode.opc"
4874 int rdst AU = op[1] & 0x0f;
4875 if (trace)
4877 printf ("\033[33m%s\033[0m %02x %02x\n",
4878 "/** 0111 01im 0010 rdst and #%1, %0 */",
4879 op[0], op[1]);
4880 printf (" im = 0x%x,", im);
4881 printf (" rdst = 0x%x\n", rdst);
4883 SYNTAX("and #%1, %0");
4884 #line 438 "rx-decode.opc"
4885 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4888 break;
4889 case 0x30:
4890 op_semantics_35:
4892 /** 0111 01im 0011 rdst or #%1, %0 */
4893 #line 456 "rx-decode.opc"
4894 int im AU = op[0] & 0x03;
4895 #line 456 "rx-decode.opc"
4896 int rdst AU = op[1] & 0x0f;
4897 if (trace)
4899 printf ("\033[33m%s\033[0m %02x %02x\n",
4900 "/** 0111 01im 0011 rdst or #%1, %0 */",
4901 op[0], op[1]);
4902 printf (" im = 0x%x,", im);
4903 printf (" rdst = 0x%x\n", rdst);
4905 SYNTAX("or #%1, %0");
4906 #line 456 "rx-decode.opc"
4907 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4910 break;
4911 default: UNSUPPORTED(); break;
4913 break;
4914 case 0x75:
4915 GETBYTE ();
4916 switch (op[1] & 0xff)
4918 case 0x00:
4919 case 0x01:
4920 case 0x02:
4921 case 0x03:
4922 case 0x04:
4923 case 0x05:
4924 case 0x06:
4925 case 0x07:
4926 case 0x08:
4927 case 0x09:
4928 case 0x0a:
4929 case 0x0b:
4930 case 0x0c:
4931 case 0x0d:
4932 case 0x0e:
4933 case 0x0f:
4934 goto op_semantics_32;
4935 break;
4936 case 0x10:
4937 case 0x11:
4938 case 0x12:
4939 case 0x13:
4940 case 0x14:
4941 case 0x15:
4942 case 0x16:
4943 case 0x17:
4944 case 0x18:
4945 case 0x19:
4946 case 0x1a:
4947 case 0x1b:
4948 case 0x1c:
4949 case 0x1d:
4950 case 0x1e:
4951 case 0x1f:
4952 goto op_semantics_33;
4953 break;
4954 case 0x20:
4955 case 0x21:
4956 case 0x22:
4957 case 0x23:
4958 case 0x24:
4959 case 0x25:
4960 case 0x26:
4961 case 0x27:
4962 case 0x28:
4963 case 0x29:
4964 case 0x2a:
4965 case 0x2b:
4966 case 0x2c:
4967 case 0x2d:
4968 case 0x2e:
4969 case 0x2f:
4970 goto op_semantics_34;
4971 break;
4972 case 0x30:
4973 case 0x31:
4974 case 0x32:
4975 case 0x33:
4976 case 0x34:
4977 case 0x35:
4978 case 0x36:
4979 case 0x37:
4980 case 0x38:
4981 case 0x39:
4982 case 0x3a:
4983 case 0x3b:
4984 case 0x3c:
4985 case 0x3d:
4986 case 0x3e:
4987 case 0x3f:
4988 goto op_semantics_35;
4989 break;
4990 case 0x40:
4991 case 0x41:
4992 case 0x42:
4993 case 0x43:
4994 case 0x44:
4995 case 0x45:
4996 case 0x46:
4997 case 0x47:
4998 case 0x48:
4999 case 0x49:
5000 case 0x4a:
5001 case 0x4b:
5002 case 0x4c:
5003 case 0x4d:
5004 case 0x4e:
5005 case 0x4f:
5007 /** 0111 0101 0100 rdst mov%s #%1, %0 */
5008 #line 310 "rx-decode.opc"
5009 int rdst AU = op[1] & 0x0f;
5010 if (trace)
5012 printf ("\033[33m%s\033[0m %02x %02x\n",
5013 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
5014 op[0], op[1]);
5015 printf (" rdst = 0x%x\n", rdst);
5017 SYNTAX("mov%s #%1, %0");
5018 #line 310 "rx-decode.opc"
5019 ID(mov); DR(rdst); SC(IMM (1)); F_____;
5022 break;
5023 case 0x50:
5024 case 0x51:
5025 case 0x52:
5026 case 0x53:
5027 case 0x54:
5028 case 0x55:
5029 case 0x56:
5030 case 0x57:
5031 case 0x58:
5032 case 0x59:
5033 case 0x5a:
5034 case 0x5b:
5035 case 0x5c:
5036 case 0x5d:
5037 case 0x5e:
5038 case 0x5f:
5040 /** 0111 0101 0101 rsrc cmp #%2, %1 */
5041 #line 549 "rx-decode.opc"
5042 int rsrc AU = op[1] & 0x0f;
5043 if (trace)
5045 printf ("\033[33m%s\033[0m %02x %02x\n",
5046 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5047 op[0], op[1]);
5048 printf (" rsrc = 0x%x\n", rsrc);
5050 SYNTAX("cmp #%2, %1");
5051 #line 549 "rx-decode.opc"
5052 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5055 break;
5056 case 0x60:
5058 /** 0111 0101 0110 0000 int #%1 */
5059 if (trace)
5061 printf ("\033[33m%s\033[0m %02x %02x\n",
5062 "/** 0111 0101 0110 0000 int #%1 */",
5063 op[0], op[1]);
5065 SYNTAX("int #%1");
5066 #line 1056 "rx-decode.opc"
5067 ID(int); SC(IMM(1));
5070 break;
5071 case 0x70:
5072 GETBYTE ();
5073 switch (op[2] & 0xf0)
5075 case 0x00:
5077 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
5078 #line 1023 "rx-decode.opc"
5079 int immm AU = op[2] & 0x0f;
5080 if (trace)
5082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5083 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5084 op[0], op[1], op[2]);
5085 printf (" immm = 0x%x\n", immm);
5087 SYNTAX("mvtipl #%1");
5088 #line 1023 "rx-decode.opc"
5089 ID(mvtipl); SC(immm);
5092 break;
5093 default: UNSUPPORTED(); break;
5095 break;
5096 case 0x90:
5097 GETBYTE ();
5098 switch (op[2] & 0xff)
5100 case 0x1b:
5102 /** 0111 0101 1001 0000 0001 1011 mvfdr */
5103 if (trace)
5105 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5106 "/** 0111 0101 1001 0000 0001 1011 mvfdr */",
5107 op[0], op[1], op[2]);
5109 SYNTAX("mvfdr");
5110 #line 1229 "rx-decode.opc"
5111 ID(mvfdr); F_____;
5114 break;
5115 default: UNSUPPORTED(); break;
5117 break;
5118 case 0xa0:
5119 GETBYTE ();
5120 switch (op[2] & 0x00)
5122 case 0x00:
5124 /** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */
5125 #line 1223 "rx-decode.opc"
5126 int rdst AU = (op[2] >> 4) & 0x0f;
5127 #line 1223 "rx-decode.opc"
5128 int rnum AU = op[2] & 0x0f;
5129 if (trace)
5131 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5132 "/** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */",
5133 op[0], op[1], op[2]);
5134 printf (" rdst = 0x%x,", rdst);
5135 printf (" rnum = 0x%x\n", rnum);
5137 SYNTAX("dpushm.l %1-%2");
5138 #line 1223 "rx-decode.opc"
5139 ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____;
5142 break;
5144 break;
5145 case 0xa8:
5146 GETBYTE ();
5147 switch (op[2] & 0x00)
5149 case 0x00:
5151 /** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */
5152 #line 1217 "rx-decode.opc"
5153 int rdst AU = (op[2] >> 4) & 0x0f;
5154 #line 1217 "rx-decode.opc"
5155 int rnum AU = op[2] & 0x0f;
5156 if (trace)
5158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5159 "/** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */",
5160 op[0], op[1], op[2]);
5161 printf (" rdst = 0x%x,", rdst);
5162 printf (" rnum = 0x%x\n", rnum);
5164 SYNTAX("dpopm.l %1-%2");
5165 #line 1217 "rx-decode.opc"
5166 ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____;
5169 break;
5171 break;
5172 case 0xb0:
5173 GETBYTE ();
5174 switch (op[2] & 0x00)
5176 case 0x00:
5178 /** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */
5179 #line 1220 "rx-decode.opc"
5180 int rdst AU = (op[2] >> 4) & 0x0f;
5181 #line 1220 "rx-decode.opc"
5182 int rnum AU = op[2] & 0x0f;
5183 if (trace)
5185 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5186 "/** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */",
5187 op[0], op[1], op[2]);
5188 printf (" rdst = 0x%x,", rdst);
5189 printf (" rnum = 0x%x\n", rnum);
5191 SYNTAX("dpushm.d %1-%2");
5192 #line 1220 "rx-decode.opc"
5193 ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____;
5196 break;
5198 break;
5199 case 0xb8:
5200 GETBYTE ();
5201 switch (op[2] & 0x00)
5203 case 0x00:
5205 /** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */
5206 #line 1214 "rx-decode.opc"
5207 int rdst AU = (op[2] >> 4) & 0x0f;
5208 #line 1214 "rx-decode.opc"
5209 int rnum AU = op[2] & 0x0f;
5210 if (trace)
5212 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5213 "/** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */",
5214 op[0], op[1], op[2]);
5215 printf (" rdst = 0x%x,", rdst);
5216 printf (" rnum = 0x%x\n", rnum);
5218 SYNTAX("dpopm.d %1-%2");
5219 #line 1214 "rx-decode.opc"
5220 ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____;
5223 break;
5225 break;
5226 default: UNSUPPORTED(); break;
5228 break;
5229 case 0x76:
5230 GETBYTE ();
5231 switch (op[1] & 0xff)
5233 case 0x00:
5234 case 0x01:
5235 case 0x02:
5236 case 0x03:
5237 case 0x04:
5238 case 0x05:
5239 case 0x06:
5240 case 0x07:
5241 case 0x08:
5242 case 0x09:
5243 case 0x0a:
5244 case 0x0b:
5245 case 0x0c:
5246 case 0x0d:
5247 case 0x0e:
5248 case 0x0f:
5249 goto op_semantics_32;
5250 break;
5251 case 0x10:
5252 case 0x11:
5253 case 0x12:
5254 case 0x13:
5255 case 0x14:
5256 case 0x15:
5257 case 0x16:
5258 case 0x17:
5259 case 0x18:
5260 case 0x19:
5261 case 0x1a:
5262 case 0x1b:
5263 case 0x1c:
5264 case 0x1d:
5265 case 0x1e:
5266 case 0x1f:
5267 goto op_semantics_33;
5268 break;
5269 case 0x20:
5270 case 0x21:
5271 case 0x22:
5272 case 0x23:
5273 case 0x24:
5274 case 0x25:
5275 case 0x26:
5276 case 0x27:
5277 case 0x28:
5278 case 0x29:
5279 case 0x2a:
5280 case 0x2b:
5281 case 0x2c:
5282 case 0x2d:
5283 case 0x2e:
5284 case 0x2f:
5285 goto op_semantics_34;
5286 break;
5287 case 0x30:
5288 case 0x31:
5289 case 0x32:
5290 case 0x33:
5291 case 0x34:
5292 case 0x35:
5293 case 0x36:
5294 case 0x37:
5295 case 0x38:
5296 case 0x39:
5297 case 0x3a:
5298 case 0x3b:
5299 case 0x3c:
5300 case 0x3d:
5301 case 0x3e:
5302 case 0x3f:
5303 goto op_semantics_35;
5304 break;
5305 case 0x90:
5306 GETBYTE ();
5307 switch (op[2] & 0xff)
5309 case 0x00:
5310 GETBYTE ();
5311 switch (op[3] & 0x00)
5313 case 0x00:
5314 op_semantics_36:
5316 /** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */
5317 #line 1238 "rx-decode.opc"
5318 int srcb AU = (op[2] >> 4) & 0x0f;
5319 #line 1238 "rx-decode.opc"
5320 int rdst AU = (op[3] >> 4) & 0x0f;
5321 #line 1238 "rx-decode.opc"
5322 int srca AU = op[3] & 0x0f;
5323 if (trace)
5325 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5326 "/** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */",
5327 op[0], op[1], op[2], op[3]);
5328 printf (" srcb = 0x%x,", srcb);
5329 printf (" rdst = 0x%x,", rdst);
5330 printf (" srca = 0x%x\n", srca);
5332 SYNTAX("dadd %1, %2, %0");
5333 #line 1238 "rx-decode.opc"
5334 ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5337 break;
5339 break;
5340 case 0x01:
5341 GETBYTE ();
5342 switch (op[3] & 0x00)
5344 case 0x00:
5345 op_semantics_37:
5347 /** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */
5348 #line 1259 "rx-decode.opc"
5349 int srcb AU = (op[2] >> 4) & 0x0f;
5350 #line 1259 "rx-decode.opc"
5351 int rdst AU = (op[3] >> 4) & 0x0f;
5352 #line 1259 "rx-decode.opc"
5353 int srca AU = op[3] & 0x0f;
5354 if (trace)
5356 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5357 "/** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */",
5358 op[0], op[1], op[2], op[3]);
5359 printf (" srcb = 0x%x,", srcb);
5360 printf (" rdst = 0x%x,", rdst);
5361 printf (" srca = 0x%x\n", srca);
5363 SYNTAX("dsub %1, %2, %0");
5364 #line 1259 "rx-decode.opc"
5365 ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5368 break;
5370 break;
5371 case 0x02:
5372 GETBYTE ();
5373 switch (op[3] & 0x00)
5375 case 0x00:
5376 op_semantics_38:
5378 /** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */
5379 #line 1247 "rx-decode.opc"
5380 int srcb AU = (op[2] >> 4) & 0x0f;
5381 #line 1247 "rx-decode.opc"
5382 int rdst AU = (op[3] >> 4) & 0x0f;
5383 #line 1247 "rx-decode.opc"
5384 int srca AU = op[3] & 0x0f;
5385 if (trace)
5387 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5388 "/** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */",
5389 op[0], op[1], op[2], op[3]);
5390 printf (" srcb = 0x%x,", srcb);
5391 printf (" rdst = 0x%x,", rdst);
5392 printf (" srca = 0x%x\n", srca);
5394 SYNTAX("dmul %1, %2, %0");
5395 #line 1247 "rx-decode.opc"
5396 ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5399 break;
5401 break;
5402 case 0x05:
5403 GETBYTE ();
5404 switch (op[3] & 0x00)
5406 case 0x00:
5407 op_semantics_39:
5409 /** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */
5410 #line 1244 "rx-decode.opc"
5411 int srcb AU = (op[2] >> 4) & 0x0f;
5412 #line 1244 "rx-decode.opc"
5413 int rdst AU = (op[3] >> 4) & 0x0f;
5414 #line 1244 "rx-decode.opc"
5415 int srca AU = op[3] & 0x0f;
5416 if (trace)
5418 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5419 "/** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */",
5420 op[0], op[1], op[2], op[3]);
5421 printf (" srcb = 0x%x,", srcb);
5422 printf (" rdst = 0x%x,", rdst);
5423 printf (" srca = 0x%x\n", srca);
5425 SYNTAX("ddiv %1, %2, %0");
5426 #line 1244 "rx-decode.opc"
5427 ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5430 break;
5432 break;
5433 case 0x08:
5434 GETBYTE ();
5435 switch (op[3] & 0x00)
5437 case 0x00:
5438 op_semantics_40:
5440 /** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */
5441 #line 1241 "rx-decode.opc"
5442 int srcb AU = (op[2] >> 4) & 0x0f;
5443 #line 1241 "rx-decode.opc"
5444 int cond AU = (op[3] >> 4) & 0x0f;
5445 #line 1241 "rx-decode.opc"
5446 int srca AU = op[3] & 0x0f;
5447 if (trace)
5449 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5450 "/** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */",
5451 op[0], op[1], op[2], op[3]);
5452 printf (" srcb = 0x%x,", srcb);
5453 printf (" cond = 0x%x,", cond);
5454 printf (" srca = 0x%x\n", srca);
5456 SYNTAX("dcmp%0 %1, %2");
5457 #line 1241 "rx-decode.opc"
5458 ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____;
5461 break;
5463 break;
5464 case 0x0c:
5465 GETBYTE ();
5466 switch (op[3] & 0x0f)
5468 case 0x00:
5469 op_semantics_41:
5471 /** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */
5472 #line 1179 "rx-decode.opc"
5473 int rsrc AU = (op[2] >> 4) & 0x0f;
5474 #line 1179 "rx-decode.opc"
5475 int rdst AU = (op[3] >> 4) & 0x0f;
5476 if (trace)
5478 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5479 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */",
5480 op[0], op[1], op[2], op[3]);
5481 printf (" rsrc = 0x%x,", rsrc);
5482 printf (" rdst = 0x%x\n", rdst);
5484 SYNTAX("dmov.d %1, %0");
5485 #line 1179 "rx-decode.opc"
5486 ID(dmov); DDR(rdst); SDR(rsrc); F_____;
5489 break;
5490 case 0x01:
5491 op_semantics_42:
5493 /** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */
5494 #line 1235 "rx-decode.opc"
5495 int rsrc AU = (op[2] >> 4) & 0x0f;
5496 #line 1235 "rx-decode.opc"
5497 int rdst AU = (op[3] >> 4) & 0x0f;
5498 if (trace)
5500 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5501 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */",
5502 op[0], op[1], op[2], op[3]);
5503 printf (" rsrc = 0x%x,", rsrc);
5504 printf (" rdst = 0x%x\n", rdst);
5506 SYNTAX("dabs %1, %0");
5507 #line 1235 "rx-decode.opc"
5508 ID(dabs); DDR(rdst); SDR(rsrc); F_____;
5511 break;
5512 case 0x02:
5513 op_semantics_43:
5515 /** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */
5516 #line 1250 "rx-decode.opc"
5517 int rsrc AU = (op[2] >> 4) & 0x0f;
5518 #line 1250 "rx-decode.opc"
5519 int rdst AU = (op[3] >> 4) & 0x0f;
5520 if (trace)
5522 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5523 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */",
5524 op[0], op[1], op[2], op[3]);
5525 printf (" rsrc = 0x%x,", rsrc);
5526 printf (" rdst = 0x%x\n", rdst);
5528 SYNTAX("dneg %1, %0");
5529 #line 1250 "rx-decode.opc"
5530 ID(dneg); DDR(rdst); SDR(rsrc); F_____;
5533 break;
5534 default: UNSUPPORTED(); break;
5536 break;
5537 case 0x0d:
5538 GETBYTE ();
5539 switch (op[3] & 0x0f)
5541 case 0x00:
5542 op_semantics_44:
5544 /** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */
5545 #line 1256 "rx-decode.opc"
5546 int rsrc AU = (op[2] >> 4) & 0x0f;
5547 #line 1256 "rx-decode.opc"
5548 int rdst AU = (op[3] >> 4) & 0x0f;
5549 if (trace)
5551 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5552 "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */",
5553 op[0], op[1], op[2], op[3]);
5554 printf (" rsrc = 0x%x,", rsrc);
5555 printf (" rdst = 0x%x\n", rdst);
5557 SYNTAX("dsqrt %1, %0");
5558 #line 1256 "rx-decode.opc"
5559 ID(dsqrt); DDR(rdst); SDR(rsrc); F_____;
5562 break;
5563 case 0x08:
5564 op_semantics_45:
5566 /** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */
5567 #line 1265 "rx-decode.opc"
5568 int rsrc AU = (op[2] >> 4) & 0x0f;
5569 #line 1265 "rx-decode.opc"
5570 int rdst AU = (op[3] >> 4) & 0x0f;
5571 if (trace)
5573 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5574 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */",
5575 op[0], op[1], op[2], op[3]);
5576 printf (" rsrc = 0x%x,", rsrc);
5577 printf (" rdst = 0x%x\n", rdst);
5579 SYNTAX("dtoi %1, %0");
5580 #line 1265 "rx-decode.opc"
5581 ID(dtoi); DDR(rdst); SDR(rsrc); F_____;
5584 break;
5585 case 0x09:
5586 op_semantics_46:
5588 /** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */
5589 #line 1268 "rx-decode.opc"
5590 int rsrc AU = (op[2] >> 4) & 0x0f;
5591 #line 1268 "rx-decode.opc"
5592 int rdst AU = (op[3] >> 4) & 0x0f;
5593 if (trace)
5595 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5596 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */",
5597 op[0], op[1], op[2], op[3]);
5598 printf (" rsrc = 0x%x,", rsrc);
5599 printf (" rdst = 0x%x\n", rdst);
5601 SYNTAX("dtou %1, %0");
5602 #line 1268 "rx-decode.opc"
5603 ID(dtou); DDR(rdst); SDR(rsrc); F_____;
5606 break;
5607 case 0x0c:
5608 op_semantics_47:
5610 /** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */
5611 #line 1262 "rx-decode.opc"
5612 int rsrc AU = (op[2] >> 4) & 0x0f;
5613 #line 1262 "rx-decode.opc"
5614 int rdst AU = (op[3] >> 4) & 0x0f;
5615 if (trace)
5617 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5618 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */",
5619 op[0], op[1], op[2], op[3]);
5620 printf (" rsrc = 0x%x,", rsrc);
5621 printf (" rdst = 0x%x\n", rdst);
5623 SYNTAX("dtof %1, %0");
5624 #line 1262 "rx-decode.opc"
5625 ID(dtof); DDR(rdst); SDR(rsrc); F_____;
5628 break;
5629 case 0x0d:
5630 op_semantics_48:
5632 /** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */
5633 #line 1253 "rx-decode.opc"
5634 int rsrc AU = (op[2] >> 4) & 0x0f;
5635 #line 1253 "rx-decode.opc"
5636 int rdst AU = (op[3] >> 4) & 0x0f;
5637 if (trace)
5639 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5640 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */",
5641 op[0], op[1], op[2], op[3]);
5642 printf (" rsrc = 0x%x,", rsrc);
5643 printf (" rdst = 0x%x\n", rdst);
5645 SYNTAX("dround %1, %0");
5646 #line 1253 "rx-decode.opc"
5647 ID(dround); DDR(rdst); SDR(rsrc); F_____;
5650 break;
5651 default: UNSUPPORTED(); break;
5653 break;
5654 case 0x10:
5655 GETBYTE ();
5656 switch (op[3] & 0x00)
5658 case 0x00:
5659 goto op_semantics_36;
5660 break;
5662 break;
5663 case 0x11:
5664 GETBYTE ();
5665 switch (op[3] & 0x00)
5667 case 0x00:
5668 goto op_semantics_37;
5669 break;
5671 break;
5672 case 0x12:
5673 GETBYTE ();
5674 switch (op[3] & 0x00)
5676 case 0x00:
5677 goto op_semantics_38;
5678 break;
5680 break;
5681 case 0x15:
5682 GETBYTE ();
5683 switch (op[3] & 0x00)
5685 case 0x00:
5686 goto op_semantics_39;
5687 break;
5689 break;
5690 case 0x18:
5691 GETBYTE ();
5692 switch (op[3] & 0x00)
5694 case 0x00:
5695 goto op_semantics_40;
5696 break;
5698 break;
5699 case 0x1c:
5700 GETBYTE ();
5701 switch (op[3] & 0x0f)
5703 case 0x00:
5704 goto op_semantics_41;
5705 break;
5706 case 0x01:
5707 goto op_semantics_42;
5708 break;
5709 case 0x02:
5710 goto op_semantics_43;
5711 break;
5712 default: UNSUPPORTED(); break;
5714 break;
5715 case 0x1d:
5716 GETBYTE ();
5717 switch (op[3] & 0x0f)
5719 case 0x00:
5720 goto op_semantics_44;
5721 break;
5722 case 0x08:
5723 goto op_semantics_45;
5724 break;
5725 case 0x09:
5726 goto op_semantics_46;
5727 break;
5728 case 0x0c:
5729 goto op_semantics_47;
5730 break;
5731 case 0x0d:
5732 goto op_semantics_48;
5733 break;
5734 default: UNSUPPORTED(); break;
5736 break;
5737 case 0x20:
5738 GETBYTE ();
5739 switch (op[3] & 0x00)
5741 case 0x00:
5742 goto op_semantics_36;
5743 break;
5745 break;
5746 case 0x21:
5747 GETBYTE ();
5748 switch (op[3] & 0x00)
5750 case 0x00:
5751 goto op_semantics_37;
5752 break;
5754 break;
5755 case 0x22:
5756 GETBYTE ();
5757 switch (op[3] & 0x00)
5759 case 0x00:
5760 goto op_semantics_38;
5761 break;
5763 break;
5764 case 0x25:
5765 GETBYTE ();
5766 switch (op[3] & 0x00)
5768 case 0x00:
5769 goto op_semantics_39;
5770 break;
5772 break;
5773 case 0x28:
5774 GETBYTE ();
5775 switch (op[3] & 0x00)
5777 case 0x00:
5778 goto op_semantics_40;
5779 break;
5781 break;
5782 case 0x2c:
5783 GETBYTE ();
5784 switch (op[3] & 0x0f)
5786 case 0x00:
5787 goto op_semantics_41;
5788 break;
5789 case 0x01:
5790 goto op_semantics_42;
5791 break;
5792 case 0x02:
5793 goto op_semantics_43;
5794 break;
5795 default: UNSUPPORTED(); break;
5797 break;
5798 case 0x2d:
5799 GETBYTE ();
5800 switch (op[3] & 0x0f)
5802 case 0x00:
5803 goto op_semantics_44;
5804 break;
5805 case 0x08:
5806 goto op_semantics_45;
5807 break;
5808 case 0x09:
5809 goto op_semantics_46;
5810 break;
5811 case 0x0c:
5812 goto op_semantics_47;
5813 break;
5814 case 0x0d:
5815 goto op_semantics_48;
5816 break;
5817 default: UNSUPPORTED(); break;
5819 break;
5820 case 0x30:
5821 GETBYTE ();
5822 switch (op[3] & 0x00)
5824 case 0x00:
5825 goto op_semantics_36;
5826 break;
5828 break;
5829 case 0x31:
5830 GETBYTE ();
5831 switch (op[3] & 0x00)
5833 case 0x00:
5834 goto op_semantics_37;
5835 break;
5837 break;
5838 case 0x32:
5839 GETBYTE ();
5840 switch (op[3] & 0x00)
5842 case 0x00:
5843 goto op_semantics_38;
5844 break;
5846 break;
5847 case 0x35:
5848 GETBYTE ();
5849 switch (op[3] & 0x00)
5851 case 0x00:
5852 goto op_semantics_39;
5853 break;
5855 break;
5856 case 0x38:
5857 GETBYTE ();
5858 switch (op[3] & 0x00)
5860 case 0x00:
5861 goto op_semantics_40;
5862 break;
5864 break;
5865 case 0x3c:
5866 GETBYTE ();
5867 switch (op[3] & 0x0f)
5869 case 0x00:
5870 goto op_semantics_41;
5871 break;
5872 case 0x01:
5873 goto op_semantics_42;
5874 break;
5875 case 0x02:
5876 goto op_semantics_43;
5877 break;
5878 default: UNSUPPORTED(); break;
5880 break;
5881 case 0x3d:
5882 GETBYTE ();
5883 switch (op[3] & 0x0f)
5885 case 0x00:
5886 goto op_semantics_44;
5887 break;
5888 case 0x08:
5889 goto op_semantics_45;
5890 break;
5891 case 0x09:
5892 goto op_semantics_46;
5893 break;
5894 case 0x0c:
5895 goto op_semantics_47;
5896 break;
5897 case 0x0d:
5898 goto op_semantics_48;
5899 break;
5900 default: UNSUPPORTED(); break;
5902 break;
5903 case 0x40:
5904 GETBYTE ();
5905 switch (op[3] & 0x00)
5907 case 0x00:
5908 goto op_semantics_36;
5909 break;
5911 break;
5912 case 0x41:
5913 GETBYTE ();
5914 switch (op[3] & 0x00)
5916 case 0x00:
5917 goto op_semantics_37;
5918 break;
5920 break;
5921 case 0x42:
5922 GETBYTE ();
5923 switch (op[3] & 0x00)
5925 case 0x00:
5926 goto op_semantics_38;
5927 break;
5929 break;
5930 case 0x45:
5931 GETBYTE ();
5932 switch (op[3] & 0x00)
5934 case 0x00:
5935 goto op_semantics_39;
5936 break;
5938 break;
5939 case 0x48:
5940 GETBYTE ();
5941 switch (op[3] & 0x00)
5943 case 0x00:
5944 goto op_semantics_40;
5945 break;
5947 break;
5948 case 0x4c:
5949 GETBYTE ();
5950 switch (op[3] & 0x0f)
5952 case 0x00:
5953 goto op_semantics_41;
5954 break;
5955 case 0x01:
5956 goto op_semantics_42;
5957 break;
5958 case 0x02:
5959 goto op_semantics_43;
5960 break;
5961 default: UNSUPPORTED(); break;
5963 break;
5964 case 0x4d:
5965 GETBYTE ();
5966 switch (op[3] & 0x0f)
5968 case 0x00:
5969 goto op_semantics_44;
5970 break;
5971 case 0x08:
5972 goto op_semantics_45;
5973 break;
5974 case 0x09:
5975 goto op_semantics_46;
5976 break;
5977 case 0x0c:
5978 goto op_semantics_47;
5979 break;
5980 case 0x0d:
5981 goto op_semantics_48;
5982 break;
5983 default: UNSUPPORTED(); break;
5985 break;
5986 case 0x50:
5987 GETBYTE ();
5988 switch (op[3] & 0x00)
5990 case 0x00:
5991 goto op_semantics_36;
5992 break;
5994 break;
5995 case 0x51:
5996 GETBYTE ();
5997 switch (op[3] & 0x00)
5999 case 0x00:
6000 goto op_semantics_37;
6001 break;
6003 break;
6004 case 0x52:
6005 GETBYTE ();
6006 switch (op[3] & 0x00)
6008 case 0x00:
6009 goto op_semantics_38;
6010 break;
6012 break;
6013 case 0x55:
6014 GETBYTE ();
6015 switch (op[3] & 0x00)
6017 case 0x00:
6018 goto op_semantics_39;
6019 break;
6021 break;
6022 case 0x58:
6023 GETBYTE ();
6024 switch (op[3] & 0x00)
6026 case 0x00:
6027 goto op_semantics_40;
6028 break;
6030 break;
6031 case 0x5c:
6032 GETBYTE ();
6033 switch (op[3] & 0x0f)
6035 case 0x00:
6036 goto op_semantics_41;
6037 break;
6038 case 0x01:
6039 goto op_semantics_42;
6040 break;
6041 case 0x02:
6042 goto op_semantics_43;
6043 break;
6044 default: UNSUPPORTED(); break;
6046 break;
6047 case 0x5d:
6048 GETBYTE ();
6049 switch (op[3] & 0x0f)
6051 case 0x00:
6052 goto op_semantics_44;
6053 break;
6054 case 0x08:
6055 goto op_semantics_45;
6056 break;
6057 case 0x09:
6058 goto op_semantics_46;
6059 break;
6060 case 0x0c:
6061 goto op_semantics_47;
6062 break;
6063 case 0x0d:
6064 goto op_semantics_48;
6065 break;
6066 default: UNSUPPORTED(); break;
6068 break;
6069 case 0x60:
6070 GETBYTE ();
6071 switch (op[3] & 0x00)
6073 case 0x00:
6074 goto op_semantics_36;
6075 break;
6077 break;
6078 case 0x61:
6079 GETBYTE ();
6080 switch (op[3] & 0x00)
6082 case 0x00:
6083 goto op_semantics_37;
6084 break;
6086 break;
6087 case 0x62:
6088 GETBYTE ();
6089 switch (op[3] & 0x00)
6091 case 0x00:
6092 goto op_semantics_38;
6093 break;
6095 break;
6096 case 0x65:
6097 GETBYTE ();
6098 switch (op[3] & 0x00)
6100 case 0x00:
6101 goto op_semantics_39;
6102 break;
6104 break;
6105 case 0x68:
6106 GETBYTE ();
6107 switch (op[3] & 0x00)
6109 case 0x00:
6110 goto op_semantics_40;
6111 break;
6113 break;
6114 case 0x6c:
6115 GETBYTE ();
6116 switch (op[3] & 0x0f)
6118 case 0x00:
6119 goto op_semantics_41;
6120 break;
6121 case 0x01:
6122 goto op_semantics_42;
6123 break;
6124 case 0x02:
6125 goto op_semantics_43;
6126 break;
6127 default: UNSUPPORTED(); break;
6129 break;
6130 case 0x6d:
6131 GETBYTE ();
6132 switch (op[3] & 0x0f)
6134 case 0x00:
6135 goto op_semantics_44;
6136 break;
6137 case 0x08:
6138 goto op_semantics_45;
6139 break;
6140 case 0x09:
6141 goto op_semantics_46;
6142 break;
6143 case 0x0c:
6144 goto op_semantics_47;
6145 break;
6146 case 0x0d:
6147 goto op_semantics_48;
6148 break;
6149 default: UNSUPPORTED(); break;
6151 break;
6152 case 0x70:
6153 GETBYTE ();
6154 switch (op[3] & 0x00)
6156 case 0x00:
6157 goto op_semantics_36;
6158 break;
6160 break;
6161 case 0x71:
6162 GETBYTE ();
6163 switch (op[3] & 0x00)
6165 case 0x00:
6166 goto op_semantics_37;
6167 break;
6169 break;
6170 case 0x72:
6171 GETBYTE ();
6172 switch (op[3] & 0x00)
6174 case 0x00:
6175 goto op_semantics_38;
6176 break;
6178 break;
6179 case 0x75:
6180 GETBYTE ();
6181 switch (op[3] & 0x00)
6183 case 0x00:
6184 goto op_semantics_39;
6185 break;
6187 break;
6188 case 0x78:
6189 GETBYTE ();
6190 switch (op[3] & 0x00)
6192 case 0x00:
6193 goto op_semantics_40;
6194 break;
6196 break;
6197 case 0x7c:
6198 GETBYTE ();
6199 switch (op[3] & 0x0f)
6201 case 0x00:
6202 goto op_semantics_41;
6203 break;
6204 case 0x01:
6205 goto op_semantics_42;
6206 break;
6207 case 0x02:
6208 goto op_semantics_43;
6209 break;
6210 default: UNSUPPORTED(); break;
6212 break;
6213 case 0x7d:
6214 GETBYTE ();
6215 switch (op[3] & 0x0f)
6217 case 0x00:
6218 goto op_semantics_44;
6219 break;
6220 case 0x08:
6221 goto op_semantics_45;
6222 break;
6223 case 0x09:
6224 goto op_semantics_46;
6225 break;
6226 case 0x0c:
6227 goto op_semantics_47;
6228 break;
6229 case 0x0d:
6230 goto op_semantics_48;
6231 break;
6232 default: UNSUPPORTED(); break;
6234 break;
6235 case 0x80:
6236 GETBYTE ();
6237 switch (op[3] & 0x00)
6239 case 0x00:
6240 goto op_semantics_36;
6241 break;
6243 break;
6244 case 0x81:
6245 GETBYTE ();
6246 switch (op[3] & 0x00)
6248 case 0x00:
6249 goto op_semantics_37;
6250 break;
6252 break;
6253 case 0x82:
6254 GETBYTE ();
6255 switch (op[3] & 0x00)
6257 case 0x00:
6258 goto op_semantics_38;
6259 break;
6261 break;
6262 case 0x85:
6263 GETBYTE ();
6264 switch (op[3] & 0x00)
6266 case 0x00:
6267 goto op_semantics_39;
6268 break;
6270 break;
6271 case 0x88:
6272 GETBYTE ();
6273 switch (op[3] & 0x00)
6275 case 0x00:
6276 goto op_semantics_40;
6277 break;
6279 break;
6280 case 0x8c:
6281 GETBYTE ();
6282 switch (op[3] & 0x0f)
6284 case 0x00:
6285 goto op_semantics_41;
6286 break;
6287 case 0x01:
6288 goto op_semantics_42;
6289 break;
6290 case 0x02:
6291 goto op_semantics_43;
6292 break;
6293 default: UNSUPPORTED(); break;
6295 break;
6296 case 0x8d:
6297 GETBYTE ();
6298 switch (op[3] & 0x0f)
6300 case 0x00:
6301 goto op_semantics_44;
6302 break;
6303 case 0x08:
6304 goto op_semantics_45;
6305 break;
6306 case 0x09:
6307 goto op_semantics_46;
6308 break;
6309 case 0x0c:
6310 goto op_semantics_47;
6311 break;
6312 case 0x0d:
6313 goto op_semantics_48;
6314 break;
6315 default: UNSUPPORTED(); break;
6317 break;
6318 case 0x90:
6319 GETBYTE ();
6320 switch (op[3] & 0x00)
6322 case 0x00:
6323 goto op_semantics_36;
6324 break;
6326 break;
6327 case 0x91:
6328 GETBYTE ();
6329 switch (op[3] & 0x00)
6331 case 0x00:
6332 goto op_semantics_37;
6333 break;
6335 break;
6336 case 0x92:
6337 GETBYTE ();
6338 switch (op[3] & 0x00)
6340 case 0x00:
6341 goto op_semantics_38;
6342 break;
6344 break;
6345 case 0x95:
6346 GETBYTE ();
6347 switch (op[3] & 0x00)
6349 case 0x00:
6350 goto op_semantics_39;
6351 break;
6353 break;
6354 case 0x98:
6355 GETBYTE ();
6356 switch (op[3] & 0x00)
6358 case 0x00:
6359 goto op_semantics_40;
6360 break;
6362 break;
6363 case 0x9c:
6364 GETBYTE ();
6365 switch (op[3] & 0x0f)
6367 case 0x00:
6368 goto op_semantics_41;
6369 break;
6370 case 0x01:
6371 goto op_semantics_42;
6372 break;
6373 case 0x02:
6374 goto op_semantics_43;
6375 break;
6376 default: UNSUPPORTED(); break;
6378 break;
6379 case 0x9d:
6380 GETBYTE ();
6381 switch (op[3] & 0x0f)
6383 case 0x00:
6384 goto op_semantics_44;
6385 break;
6386 case 0x08:
6387 goto op_semantics_45;
6388 break;
6389 case 0x09:
6390 goto op_semantics_46;
6391 break;
6392 case 0x0c:
6393 goto op_semantics_47;
6394 break;
6395 case 0x0d:
6396 goto op_semantics_48;
6397 break;
6398 default: UNSUPPORTED(); break;
6400 break;
6401 case 0xa0:
6402 GETBYTE ();
6403 switch (op[3] & 0x00)
6405 case 0x00:
6406 goto op_semantics_36;
6407 break;
6409 break;
6410 case 0xa1:
6411 GETBYTE ();
6412 switch (op[3] & 0x00)
6414 case 0x00:
6415 goto op_semantics_37;
6416 break;
6418 break;
6419 case 0xa2:
6420 GETBYTE ();
6421 switch (op[3] & 0x00)
6423 case 0x00:
6424 goto op_semantics_38;
6425 break;
6427 break;
6428 case 0xa5:
6429 GETBYTE ();
6430 switch (op[3] & 0x00)
6432 case 0x00:
6433 goto op_semantics_39;
6434 break;
6436 break;
6437 case 0xa8:
6438 GETBYTE ();
6439 switch (op[3] & 0x00)
6441 case 0x00:
6442 goto op_semantics_40;
6443 break;
6445 break;
6446 case 0xac:
6447 GETBYTE ();
6448 switch (op[3] & 0x0f)
6450 case 0x00:
6451 goto op_semantics_41;
6452 break;
6453 case 0x01:
6454 goto op_semantics_42;
6455 break;
6456 case 0x02:
6457 goto op_semantics_43;
6458 break;
6459 default: UNSUPPORTED(); break;
6461 break;
6462 case 0xad:
6463 GETBYTE ();
6464 switch (op[3] & 0x0f)
6466 case 0x00:
6467 goto op_semantics_44;
6468 break;
6469 case 0x08:
6470 goto op_semantics_45;
6471 break;
6472 case 0x09:
6473 goto op_semantics_46;
6474 break;
6475 case 0x0c:
6476 goto op_semantics_47;
6477 break;
6478 case 0x0d:
6479 goto op_semantics_48;
6480 break;
6481 default: UNSUPPORTED(); break;
6483 break;
6484 case 0xb0:
6485 GETBYTE ();
6486 switch (op[3] & 0x00)
6488 case 0x00:
6489 goto op_semantics_36;
6490 break;
6492 break;
6493 case 0xb1:
6494 GETBYTE ();
6495 switch (op[3] & 0x00)
6497 case 0x00:
6498 goto op_semantics_37;
6499 break;
6501 break;
6502 case 0xb2:
6503 GETBYTE ();
6504 switch (op[3] & 0x00)
6506 case 0x00:
6507 goto op_semantics_38;
6508 break;
6510 break;
6511 case 0xb5:
6512 GETBYTE ();
6513 switch (op[3] & 0x00)
6515 case 0x00:
6516 goto op_semantics_39;
6517 break;
6519 break;
6520 case 0xb8:
6521 GETBYTE ();
6522 switch (op[3] & 0x00)
6524 case 0x00:
6525 goto op_semantics_40;
6526 break;
6528 break;
6529 case 0xbc:
6530 GETBYTE ();
6531 switch (op[3] & 0x0f)
6533 case 0x00:
6534 goto op_semantics_41;
6535 break;
6536 case 0x01:
6537 goto op_semantics_42;
6538 break;
6539 case 0x02:
6540 goto op_semantics_43;
6541 break;
6542 default: UNSUPPORTED(); break;
6544 break;
6545 case 0xbd:
6546 GETBYTE ();
6547 switch (op[3] & 0x0f)
6549 case 0x00:
6550 goto op_semantics_44;
6551 break;
6552 case 0x08:
6553 goto op_semantics_45;
6554 break;
6555 case 0x09:
6556 goto op_semantics_46;
6557 break;
6558 case 0x0c:
6559 goto op_semantics_47;
6560 break;
6561 case 0x0d:
6562 goto op_semantics_48;
6563 break;
6564 default: UNSUPPORTED(); break;
6566 break;
6567 case 0xc0:
6568 GETBYTE ();
6569 switch (op[3] & 0x00)
6571 case 0x00:
6572 goto op_semantics_36;
6573 break;
6575 break;
6576 case 0xc1:
6577 GETBYTE ();
6578 switch (op[3] & 0x00)
6580 case 0x00:
6581 goto op_semantics_37;
6582 break;
6584 break;
6585 case 0xc2:
6586 GETBYTE ();
6587 switch (op[3] & 0x00)
6589 case 0x00:
6590 goto op_semantics_38;
6591 break;
6593 break;
6594 case 0xc5:
6595 GETBYTE ();
6596 switch (op[3] & 0x00)
6598 case 0x00:
6599 goto op_semantics_39;
6600 break;
6602 break;
6603 case 0xc8:
6604 GETBYTE ();
6605 switch (op[3] & 0x00)
6607 case 0x00:
6608 goto op_semantics_40;
6609 break;
6611 break;
6612 case 0xcc:
6613 GETBYTE ();
6614 switch (op[3] & 0x0f)
6616 case 0x00:
6617 goto op_semantics_41;
6618 break;
6619 case 0x01:
6620 goto op_semantics_42;
6621 break;
6622 case 0x02:
6623 goto op_semantics_43;
6624 break;
6625 default: UNSUPPORTED(); break;
6627 break;
6628 case 0xcd:
6629 GETBYTE ();
6630 switch (op[3] & 0x0f)
6632 case 0x00:
6633 goto op_semantics_44;
6634 break;
6635 case 0x08:
6636 goto op_semantics_45;
6637 break;
6638 case 0x09:
6639 goto op_semantics_46;
6640 break;
6641 case 0x0c:
6642 goto op_semantics_47;
6643 break;
6644 case 0x0d:
6645 goto op_semantics_48;
6646 break;
6647 default: UNSUPPORTED(); break;
6649 break;
6650 case 0xd0:
6651 GETBYTE ();
6652 switch (op[3] & 0x00)
6654 case 0x00:
6655 goto op_semantics_36;
6656 break;
6658 break;
6659 case 0xd1:
6660 GETBYTE ();
6661 switch (op[3] & 0x00)
6663 case 0x00:
6664 goto op_semantics_37;
6665 break;
6667 break;
6668 case 0xd2:
6669 GETBYTE ();
6670 switch (op[3] & 0x00)
6672 case 0x00:
6673 goto op_semantics_38;
6674 break;
6676 break;
6677 case 0xd5:
6678 GETBYTE ();
6679 switch (op[3] & 0x00)
6681 case 0x00:
6682 goto op_semantics_39;
6683 break;
6685 break;
6686 case 0xd8:
6687 GETBYTE ();
6688 switch (op[3] & 0x00)
6690 case 0x00:
6691 goto op_semantics_40;
6692 break;
6694 break;
6695 case 0xdc:
6696 GETBYTE ();
6697 switch (op[3] & 0x0f)
6699 case 0x00:
6700 goto op_semantics_41;
6701 break;
6702 case 0x01:
6703 goto op_semantics_42;
6704 break;
6705 case 0x02:
6706 goto op_semantics_43;
6707 break;
6708 default: UNSUPPORTED(); break;
6710 break;
6711 case 0xdd:
6712 GETBYTE ();
6713 switch (op[3] & 0x0f)
6715 case 0x00:
6716 goto op_semantics_44;
6717 break;
6718 case 0x08:
6719 goto op_semantics_45;
6720 break;
6721 case 0x09:
6722 goto op_semantics_46;
6723 break;
6724 case 0x0c:
6725 goto op_semantics_47;
6726 break;
6727 case 0x0d:
6728 goto op_semantics_48;
6729 break;
6730 default: UNSUPPORTED(); break;
6732 break;
6733 case 0xe0:
6734 GETBYTE ();
6735 switch (op[3] & 0x00)
6737 case 0x00:
6738 goto op_semantics_36;
6739 break;
6741 break;
6742 case 0xe1:
6743 GETBYTE ();
6744 switch (op[3] & 0x00)
6746 case 0x00:
6747 goto op_semantics_37;
6748 break;
6750 break;
6751 case 0xe2:
6752 GETBYTE ();
6753 switch (op[3] & 0x00)
6755 case 0x00:
6756 goto op_semantics_38;
6757 break;
6759 break;
6760 case 0xe5:
6761 GETBYTE ();
6762 switch (op[3] & 0x00)
6764 case 0x00:
6765 goto op_semantics_39;
6766 break;
6768 break;
6769 case 0xe8:
6770 GETBYTE ();
6771 switch (op[3] & 0x00)
6773 case 0x00:
6774 goto op_semantics_40;
6775 break;
6777 break;
6778 case 0xec:
6779 GETBYTE ();
6780 switch (op[3] & 0x0f)
6782 case 0x00:
6783 goto op_semantics_41;
6784 break;
6785 case 0x01:
6786 goto op_semantics_42;
6787 break;
6788 case 0x02:
6789 goto op_semantics_43;
6790 break;
6791 default: UNSUPPORTED(); break;
6793 break;
6794 case 0xed:
6795 GETBYTE ();
6796 switch (op[3] & 0x0f)
6798 case 0x00:
6799 goto op_semantics_44;
6800 break;
6801 case 0x08:
6802 goto op_semantics_45;
6803 break;
6804 case 0x09:
6805 goto op_semantics_46;
6806 break;
6807 case 0x0c:
6808 goto op_semantics_47;
6809 break;
6810 case 0x0d:
6811 goto op_semantics_48;
6812 break;
6813 default: UNSUPPORTED(); break;
6815 break;
6816 case 0xf0:
6817 GETBYTE ();
6818 switch (op[3] & 0x00)
6820 case 0x00:
6821 goto op_semantics_36;
6822 break;
6824 break;
6825 case 0xf1:
6826 GETBYTE ();
6827 switch (op[3] & 0x00)
6829 case 0x00:
6830 goto op_semantics_37;
6831 break;
6833 break;
6834 case 0xf2:
6835 GETBYTE ();
6836 switch (op[3] & 0x00)
6838 case 0x00:
6839 goto op_semantics_38;
6840 break;
6842 break;
6843 case 0xf5:
6844 GETBYTE ();
6845 switch (op[3] & 0x00)
6847 case 0x00:
6848 goto op_semantics_39;
6849 break;
6851 break;
6852 case 0xf8:
6853 GETBYTE ();
6854 switch (op[3] & 0x00)
6856 case 0x00:
6857 goto op_semantics_40;
6858 break;
6860 break;
6861 case 0xfc:
6862 GETBYTE ();
6863 switch (op[3] & 0x0f)
6865 case 0x00:
6866 goto op_semantics_41;
6867 break;
6868 case 0x01:
6869 goto op_semantics_42;
6870 break;
6871 case 0x02:
6872 goto op_semantics_43;
6873 break;
6874 default: UNSUPPORTED(); break;
6876 break;
6877 case 0xfd:
6878 GETBYTE ();
6879 switch (op[3] & 0x0f)
6881 case 0x00:
6882 goto op_semantics_44;
6883 break;
6884 case 0x08:
6885 goto op_semantics_45;
6886 break;
6887 case 0x09:
6888 goto op_semantics_46;
6889 break;
6890 case 0x0c:
6891 goto op_semantics_47;
6892 break;
6893 case 0x0d:
6894 goto op_semantics_48;
6895 break;
6896 default: UNSUPPORTED(); break;
6898 break;
6899 default: UNSUPPORTED(); break;
6901 break;
6902 default: UNSUPPORTED(); break;
6904 break;
6905 case 0x77:
6906 GETBYTE ();
6907 switch (op[1] & 0xf0)
6909 case 0x00:
6910 goto op_semantics_32;
6911 break;
6912 case 0x10:
6913 goto op_semantics_33;
6914 break;
6915 case 0x20:
6916 goto op_semantics_34;
6917 break;
6918 case 0x30:
6919 goto op_semantics_35;
6920 break;
6921 default: UNSUPPORTED(); break;
6923 break;
6924 case 0x78:
6925 GETBYTE ();
6926 switch (op[1] & 0x00)
6928 case 0x00:
6929 op_semantics_49:
6931 /** 0111 100b ittt rdst bset #%1, %0 */
6932 #line 968 "rx-decode.opc"
6933 int b AU = op[0] & 0x01;
6934 #line 968 "rx-decode.opc"
6935 int ittt AU = (op[1] >> 4) & 0x0f;
6936 #line 968 "rx-decode.opc"
6937 int rdst AU = op[1] & 0x0f;
6938 if (trace)
6940 printf ("\033[33m%s\033[0m %02x %02x\n",
6941 "/** 0111 100b ittt rdst bset #%1, %0 */",
6942 op[0], op[1]);
6943 printf (" b = 0x%x,", b);
6944 printf (" ittt = 0x%x,", ittt);
6945 printf (" rdst = 0x%x\n", rdst);
6947 SYNTAX("bset #%1, %0");
6948 #line 968 "rx-decode.opc"
6949 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6953 break;
6955 break;
6956 case 0x79:
6957 GETBYTE ();
6958 switch (op[1] & 0x00)
6960 case 0x00:
6961 goto op_semantics_49;
6962 break;
6964 break;
6965 case 0x7a:
6966 GETBYTE ();
6967 switch (op[1] & 0x00)
6969 case 0x00:
6970 op_semantics_50:
6972 /** 0111 101b ittt rdst bclr #%1, %0 */
6973 #line 980 "rx-decode.opc"
6974 int b AU = op[0] & 0x01;
6975 #line 980 "rx-decode.opc"
6976 int ittt AU = (op[1] >> 4) & 0x0f;
6977 #line 980 "rx-decode.opc"
6978 int rdst AU = op[1] & 0x0f;
6979 if (trace)
6981 printf ("\033[33m%s\033[0m %02x %02x\n",
6982 "/** 0111 101b ittt rdst bclr #%1, %0 */",
6983 op[0], op[1]);
6984 printf (" b = 0x%x,", b);
6985 printf (" ittt = 0x%x,", ittt);
6986 printf (" rdst = 0x%x\n", rdst);
6988 SYNTAX("bclr #%1, %0");
6989 #line 980 "rx-decode.opc"
6990 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6994 break;
6996 break;
6997 case 0x7b:
6998 GETBYTE ();
6999 switch (op[1] & 0x00)
7001 case 0x00:
7002 goto op_semantics_50;
7003 break;
7005 break;
7006 case 0x7c:
7007 GETBYTE ();
7008 switch (op[1] & 0x00)
7010 case 0x00:
7011 op_semantics_51:
7013 /** 0111 110b ittt rdst btst #%2, %1 */
7014 #line 992 "rx-decode.opc"
7015 int b AU = op[0] & 0x01;
7016 #line 992 "rx-decode.opc"
7017 int ittt AU = (op[1] >> 4) & 0x0f;
7018 #line 992 "rx-decode.opc"
7019 int rdst AU = op[1] & 0x0f;
7020 if (trace)
7022 printf ("\033[33m%s\033[0m %02x %02x\n",
7023 "/** 0111 110b ittt rdst btst #%2, %1 */",
7024 op[0], op[1]);
7025 printf (" b = 0x%x,", b);
7026 printf (" ittt = 0x%x,", ittt);
7027 printf (" rdst = 0x%x\n", rdst);
7029 SYNTAX("btst #%2, %1");
7030 #line 992 "rx-decode.opc"
7031 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
7035 break;
7037 break;
7038 case 0x7d:
7039 GETBYTE ();
7040 switch (op[1] & 0x00)
7042 case 0x00:
7043 goto op_semantics_51;
7044 break;
7046 break;
7047 case 0x7e:
7048 GETBYTE ();
7049 switch (op[1] & 0xf0)
7051 case 0x00:
7053 /** 0111 1110 0000 rdst not %0 */
7054 #line 483 "rx-decode.opc"
7055 int rdst AU = op[1] & 0x0f;
7056 if (trace)
7058 printf ("\033[33m%s\033[0m %02x %02x\n",
7059 "/** 0111 1110 0000 rdst not %0 */",
7060 op[0], op[1]);
7061 printf (" rdst = 0x%x\n", rdst);
7063 SYNTAX("not %0");
7064 #line 483 "rx-decode.opc"
7065 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
7068 break;
7069 case 0x10:
7071 /** 0111 1110 0001 rdst neg %0 */
7072 #line 504 "rx-decode.opc"
7073 int rdst AU = op[1] & 0x0f;
7074 if (trace)
7076 printf ("\033[33m%s\033[0m %02x %02x\n",
7077 "/** 0111 1110 0001 rdst neg %0 */",
7078 op[0], op[1]);
7079 printf (" rdst = 0x%x\n", rdst);
7081 SYNTAX("neg %0");
7082 #line 504 "rx-decode.opc"
7083 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
7086 break;
7087 case 0x20:
7089 /** 0111 1110 0010 rdst abs %0 */
7090 #line 586 "rx-decode.opc"
7091 int rdst AU = op[1] & 0x0f;
7092 if (trace)
7094 printf ("\033[33m%s\033[0m %02x %02x\n",
7095 "/** 0111 1110 0010 rdst abs %0 */",
7096 op[0], op[1]);
7097 printf (" rdst = 0x%x\n", rdst);
7099 SYNTAX("abs %0");
7100 #line 586 "rx-decode.opc"
7101 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
7104 break;
7105 case 0x30:
7107 /** 0111 1110 0011 rdst sat %0 */
7108 #line 906 "rx-decode.opc"
7109 int rdst AU = op[1] & 0x0f;
7110 if (trace)
7112 printf ("\033[33m%s\033[0m %02x %02x\n",
7113 "/** 0111 1110 0011 rdst sat %0 */",
7114 op[0], op[1]);
7115 printf (" rdst = 0x%x\n", rdst);
7117 SYNTAX("sat %0");
7118 #line 906 "rx-decode.opc"
7119 ID(sat); DR (rdst);
7122 break;
7123 case 0x40:
7125 /** 0111 1110 0100 rdst rorc %0 */
7126 #line 766 "rx-decode.opc"
7127 int rdst AU = op[1] & 0x0f;
7128 if (trace)
7130 printf ("\033[33m%s\033[0m %02x %02x\n",
7131 "/** 0111 1110 0100 rdst rorc %0 */",
7132 op[0], op[1]);
7133 printf (" rdst = 0x%x\n", rdst);
7135 SYNTAX("rorc %0");
7136 #line 766 "rx-decode.opc"
7137 ID(rorc); DR(rdst); F__SZC;
7140 break;
7141 case 0x50:
7143 /** 0111 1110 0101 rdst rolc %0 */
7144 #line 763 "rx-decode.opc"
7145 int rdst AU = op[1] & 0x0f;
7146 if (trace)
7148 printf ("\033[33m%s\033[0m %02x %02x\n",
7149 "/** 0111 1110 0101 rdst rolc %0 */",
7150 op[0], op[1]);
7151 printf (" rdst = 0x%x\n", rdst);
7153 SYNTAX("rolc %0");
7154 #line 763 "rx-decode.opc"
7155 ID(rolc); DR(rdst); F__SZC;
7158 break;
7159 case 0x80:
7160 case 0x90:
7161 case 0xa0:
7163 /** 0111 1110 10sz rsrc push%s %1 */
7164 #line 399 "rx-decode.opc"
7165 int sz AU = (op[1] >> 4) & 0x03;
7166 #line 399 "rx-decode.opc"
7167 int rsrc AU = op[1] & 0x0f;
7168 if (trace)
7170 printf ("\033[33m%s\033[0m %02x %02x\n",
7171 "/** 0111 1110 10sz rsrc push%s %1 */",
7172 op[0], op[1]);
7173 printf (" sz = 0x%x,", sz);
7174 printf (" rsrc = 0x%x\n", rsrc);
7176 SYNTAX("push%s %1");
7177 #line 399 "rx-decode.opc"
7178 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7181 break;
7182 case 0xb0:
7184 /** 0111 1110 1011 rdst pop %0 */
7185 #line 396 "rx-decode.opc"
7186 int rdst AU = op[1] & 0x0f;
7187 if (trace)
7189 printf ("\033[33m%s\033[0m %02x %02x\n",
7190 "/** 0111 1110 1011 rdst pop %0 */",
7191 op[0], op[1]);
7192 printf (" rdst = 0x%x\n", rdst);
7194 SYNTAX("pop %0");
7195 #line 396 "rx-decode.opc"
7196 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7199 break;
7200 case 0xc0:
7201 case 0xd0:
7203 /** 0111 1110 110 crsrc pushc %1 */
7204 #line 1029 "rx-decode.opc"
7205 int crsrc AU = op[1] & 0x1f;
7206 if (trace)
7208 printf ("\033[33m%s\033[0m %02x %02x\n",
7209 "/** 0111 1110 110 crsrc pushc %1 */",
7210 op[0], op[1]);
7211 printf (" crsrc = 0x%x\n", crsrc);
7213 SYNTAX("pushc %1");
7214 #line 1029 "rx-decode.opc"
7215 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7218 break;
7219 case 0xe0:
7220 case 0xf0:
7222 /** 0111 1110 111 crdst popc %0 */
7223 #line 1026 "rx-decode.opc"
7224 int crdst AU = op[1] & 0x1f;
7225 if (trace)
7227 printf ("\033[33m%s\033[0m %02x %02x\n",
7228 "/** 0111 1110 111 crdst popc %0 */",
7229 op[0], op[1]);
7230 printf (" crdst = 0x%x\n", crdst);
7232 SYNTAX("popc %0");
7233 #line 1026 "rx-decode.opc"
7234 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7237 break;
7238 default: UNSUPPORTED(); break;
7240 break;
7241 case 0x7f:
7242 GETBYTE ();
7243 switch (op[1] & 0xff)
7245 case 0x00:
7246 case 0x01:
7247 case 0x02:
7248 case 0x03:
7249 case 0x04:
7250 case 0x05:
7251 case 0x06:
7252 case 0x07:
7253 case 0x08:
7254 case 0x09:
7255 case 0x0a:
7256 case 0x0b:
7257 case 0x0c:
7258 case 0x0d:
7259 case 0x0e:
7260 case 0x0f:
7262 /** 0111 1111 0000 rsrc jmp %0 */
7263 #line 816 "rx-decode.opc"
7264 int rsrc AU = op[1] & 0x0f;
7265 if (trace)
7267 printf ("\033[33m%s\033[0m %02x %02x\n",
7268 "/** 0111 1111 0000 rsrc jmp %0 */",
7269 op[0], op[1]);
7270 printf (" rsrc = 0x%x\n", rsrc);
7272 SYNTAX("jmp %0");
7273 #line 816 "rx-decode.opc"
7274 ID(branch); DR(rsrc);
7277 break;
7278 case 0x10:
7279 case 0x11:
7280 case 0x12:
7281 case 0x13:
7282 case 0x14:
7283 case 0x15:
7284 case 0x16:
7285 case 0x17:
7286 case 0x18:
7287 case 0x19:
7288 case 0x1a:
7289 case 0x1b:
7290 case 0x1c:
7291 case 0x1d:
7292 case 0x1e:
7293 case 0x1f:
7295 /** 0111 1111 0001 rsrc jsr %0 */
7296 #line 819 "rx-decode.opc"
7297 int rsrc AU = op[1] & 0x0f;
7298 if (trace)
7300 printf ("\033[33m%s\033[0m %02x %02x\n",
7301 "/** 0111 1111 0001 rsrc jsr %0 */",
7302 op[0], op[1]);
7303 printf (" rsrc = 0x%x\n", rsrc);
7305 SYNTAX("jsr %0");
7306 #line 819 "rx-decode.opc"
7307 ID(jsr); DR(rsrc);
7310 break;
7311 case 0x40:
7312 case 0x41:
7313 case 0x42:
7314 case 0x43:
7315 case 0x44:
7316 case 0x45:
7317 case 0x46:
7318 case 0x47:
7319 case 0x48:
7320 case 0x49:
7321 case 0x4a:
7322 case 0x4b:
7323 case 0x4c:
7324 case 0x4d:
7325 case 0x4e:
7326 case 0x4f:
7328 /** 0111 1111 0100 rsrc bra.l %0 */
7329 #line 812 "rx-decode.opc"
7330 int rsrc AU = op[1] & 0x0f;
7331 if (trace)
7333 printf ("\033[33m%s\033[0m %02x %02x\n",
7334 "/** 0111 1111 0100 rsrc bra.l %0 */",
7335 op[0], op[1]);
7336 printf (" rsrc = 0x%x\n", rsrc);
7338 SYNTAX("bra.l %0");
7339 #line 812 "rx-decode.opc"
7340 ID(branchrel); DR(rsrc);
7344 break;
7345 case 0x50:
7346 case 0x51:
7347 case 0x52:
7348 case 0x53:
7349 case 0x54:
7350 case 0x55:
7351 case 0x56:
7352 case 0x57:
7353 case 0x58:
7354 case 0x59:
7355 case 0x5a:
7356 case 0x5b:
7357 case 0x5c:
7358 case 0x5d:
7359 case 0x5e:
7360 case 0x5f:
7362 /** 0111 1111 0101 rsrc bsr.l %0 */
7363 #line 828 "rx-decode.opc"
7364 int rsrc AU = op[1] & 0x0f;
7365 if (trace)
7367 printf ("\033[33m%s\033[0m %02x %02x\n",
7368 "/** 0111 1111 0101 rsrc bsr.l %0 */",
7369 op[0], op[1]);
7370 printf (" rsrc = 0x%x\n", rsrc);
7372 SYNTAX("bsr.l %0");
7373 #line 828 "rx-decode.opc"
7374 ID(jsrrel); DR(rsrc);
7377 break;
7378 case 0x80:
7379 case 0x81:
7380 case 0x82:
7382 /** 0111 1111 1000 00sz suntil%s */
7383 #line 852 "rx-decode.opc"
7384 int sz AU = op[1] & 0x03;
7385 if (trace)
7387 printf ("\033[33m%s\033[0m %02x %02x\n",
7388 "/** 0111 1111 1000 00sz suntil%s */",
7389 op[0], op[1]);
7390 printf (" sz = 0x%x\n", sz);
7392 SYNTAX("suntil%s");
7393 #line 852 "rx-decode.opc"
7394 ID(suntil); BWL(sz); F___ZC;
7397 break;
7398 case 0x83:
7400 /** 0111 1111 1000 0011 scmpu */
7401 if (trace)
7403 printf ("\033[33m%s\033[0m %02x %02x\n",
7404 "/** 0111 1111 1000 0011 scmpu */",
7405 op[0], op[1]);
7407 SYNTAX("scmpu");
7408 #line 843 "rx-decode.opc"
7409 ID(scmpu); F___ZC;
7412 break;
7413 case 0x84:
7414 case 0x85:
7415 case 0x86:
7417 /** 0111 1111 1000 01sz swhile%s */
7418 #line 855 "rx-decode.opc"
7419 int sz AU = op[1] & 0x03;
7420 if (trace)
7422 printf ("\033[33m%s\033[0m %02x %02x\n",
7423 "/** 0111 1111 1000 01sz swhile%s */",
7424 op[0], op[1]);
7425 printf (" sz = 0x%x\n", sz);
7427 SYNTAX("swhile%s");
7428 #line 855 "rx-decode.opc"
7429 ID(swhile); BWL(sz); F___ZC;
7432 break;
7433 case 0x87:
7435 /** 0111 1111 1000 0111 smovu */
7436 if (trace)
7438 printf ("\033[33m%s\033[0m %02x %02x\n",
7439 "/** 0111 1111 1000 0111 smovu */",
7440 op[0], op[1]);
7442 SYNTAX("smovu");
7443 #line 846 "rx-decode.opc"
7444 ID(smovu);
7447 break;
7448 case 0x88:
7449 case 0x89:
7450 case 0x8a:
7452 /** 0111 1111 1000 10sz sstr%s */
7453 #line 861 "rx-decode.opc"
7454 int sz AU = op[1] & 0x03;
7455 if (trace)
7457 printf ("\033[33m%s\033[0m %02x %02x\n",
7458 "/** 0111 1111 1000 10sz sstr%s */",
7459 op[0], op[1]);
7460 printf (" sz = 0x%x\n", sz);
7462 SYNTAX("sstr%s");
7463 #line 861 "rx-decode.opc"
7464 ID(sstr); BWL(sz);
7466 /*----------------------------------------------------------------------*/
7467 /* RMPA */
7470 break;
7471 case 0x8b:
7473 /** 0111 1111 1000 1011 smovb */
7474 if (trace)
7476 printf ("\033[33m%s\033[0m %02x %02x\n",
7477 "/** 0111 1111 1000 1011 smovb */",
7478 op[0], op[1]);
7480 SYNTAX("smovb");
7481 #line 849 "rx-decode.opc"
7482 ID(smovb);
7485 break;
7486 case 0x8c:
7487 case 0x8d:
7488 case 0x8e:
7490 /** 0111 1111 1000 11sz rmpa%s */
7491 #line 867 "rx-decode.opc"
7492 int sz AU = op[1] & 0x03;
7493 if (trace)
7495 printf ("\033[33m%s\033[0m %02x %02x\n",
7496 "/** 0111 1111 1000 11sz rmpa%s */",
7497 op[0], op[1]);
7498 printf (" sz = 0x%x\n", sz);
7500 SYNTAX("rmpa%s");
7501 #line 867 "rx-decode.opc"
7502 ID(rmpa); BWL(sz); F_OS__;
7504 /*----------------------------------------------------------------------*/
7505 /* HI/LO stuff */
7508 break;
7509 case 0x8f:
7511 /** 0111 1111 1000 1111 smovf */
7512 if (trace)
7514 printf ("\033[33m%s\033[0m %02x %02x\n",
7515 "/** 0111 1111 1000 1111 smovf */",
7516 op[0], op[1]);
7518 SYNTAX("smovf");
7519 #line 858 "rx-decode.opc"
7520 ID(smovf);
7523 break;
7524 case 0x93:
7526 /** 0111 1111 1001 0011 satr */
7527 if (trace)
7529 printf ("\033[33m%s\033[0m %02x %02x\n",
7530 "/** 0111 1111 1001 0011 satr */",
7531 op[0], op[1]);
7533 SYNTAX("satr");
7534 #line 909 "rx-decode.opc"
7535 ID(satr);
7537 /*----------------------------------------------------------------------*/
7538 /* FLOAT */
7541 break;
7542 case 0x94:
7544 /** 0111 1111 1001 0100 rtfi */
7545 if (trace)
7547 printf ("\033[33m%s\033[0m %02x %02x\n",
7548 "/** 0111 1111 1001 0100 rtfi */",
7549 op[0], op[1]);
7551 SYNTAX("rtfi");
7552 #line 1044 "rx-decode.opc"
7553 ID(rtfi);
7556 break;
7557 case 0x95:
7559 /** 0111 1111 1001 0101 rte */
7560 if (trace)
7562 printf ("\033[33m%s\033[0m %02x %02x\n",
7563 "/** 0111 1111 1001 0101 rte */",
7564 op[0], op[1]);
7566 SYNTAX("rte");
7567 #line 1047 "rx-decode.opc"
7568 ID(rte);
7571 break;
7572 case 0x96:
7574 /** 0111 1111 1001 0110 wait */
7575 if (trace)
7577 printf ("\033[33m%s\033[0m %02x %02x\n",
7578 "/** 0111 1111 1001 0110 wait */",
7579 op[0], op[1]);
7581 SYNTAX("wait");
7582 #line 1059 "rx-decode.opc"
7583 ID(wait);
7585 /*----------------------------------------------------------------------*/
7586 /* SCcnd */
7589 break;
7590 case 0xa0:
7591 case 0xa1:
7592 case 0xa2:
7593 case 0xa3:
7594 case 0xa4:
7595 case 0xa5:
7596 case 0xa6:
7597 case 0xa7:
7598 case 0xa8:
7599 case 0xa9:
7600 case 0xaa:
7601 case 0xab:
7602 case 0xac:
7603 case 0xad:
7604 case 0xae:
7605 case 0xaf:
7607 /** 0111 1111 1010 rdst setpsw %0 */
7608 #line 1020 "rx-decode.opc"
7609 int rdst AU = op[1] & 0x0f;
7610 if (trace)
7612 printf ("\033[33m%s\033[0m %02x %02x\n",
7613 "/** 0111 1111 1010 rdst setpsw %0 */",
7614 op[0], op[1]);
7615 printf (" rdst = 0x%x\n", rdst);
7617 SYNTAX("setpsw %0");
7618 #line 1020 "rx-decode.opc"
7619 ID(setpsw); DF(rdst);
7622 break;
7623 case 0xb0:
7624 case 0xb1:
7625 case 0xb2:
7626 case 0xb3:
7627 case 0xb4:
7628 case 0xb5:
7629 case 0xb6:
7630 case 0xb7:
7631 case 0xb8:
7632 case 0xb9:
7633 case 0xba:
7634 case 0xbb:
7635 case 0xbc:
7636 case 0xbd:
7637 case 0xbe:
7638 case 0xbf:
7640 /** 0111 1111 1011 rdst clrpsw %0 */
7641 #line 1017 "rx-decode.opc"
7642 int rdst AU = op[1] & 0x0f;
7643 if (trace)
7645 printf ("\033[33m%s\033[0m %02x %02x\n",
7646 "/** 0111 1111 1011 rdst clrpsw %0 */",
7647 op[0], op[1]);
7648 printf (" rdst = 0x%x\n", rdst);
7650 SYNTAX("clrpsw %0");
7651 #line 1017 "rx-decode.opc"
7652 ID(clrpsw); DF(rdst);
7655 break;
7656 default: UNSUPPORTED(); break;
7658 break;
7659 case 0x80:
7660 GETBYTE ();
7661 switch (op[1] & 0x00)
7663 case 0x00:
7664 op_semantics_52:
7666 /** 10sz 0dsp a dst b src mov%s %1, %0 */
7667 #line 357 "rx-decode.opc"
7668 int sz AU = (op[0] >> 4) & 0x03;
7669 #line 357 "rx-decode.opc"
7670 int dsp AU = op[0] & 0x07;
7671 #line 357 "rx-decode.opc"
7672 int a AU = (op[1] >> 7) & 0x01;
7673 #line 357 "rx-decode.opc"
7674 int dst AU = (op[1] >> 4) & 0x07;
7675 #line 357 "rx-decode.opc"
7676 int b AU = (op[1] >> 3) & 0x01;
7677 #line 357 "rx-decode.opc"
7678 int src AU = op[1] & 0x07;
7679 if (trace)
7681 printf ("\033[33m%s\033[0m %02x %02x\n",
7682 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
7683 op[0], op[1]);
7684 printf (" sz = 0x%x,", sz);
7685 printf (" dsp = 0x%x,", dsp);
7686 printf (" a = 0x%x,", a);
7687 printf (" dst = 0x%x,", dst);
7688 printf (" b = 0x%x,", b);
7689 printf (" src = 0x%x\n", src);
7691 SYNTAX("mov%s %1, %0");
7692 #line 357 "rx-decode.opc"
7693 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
7696 break;
7698 break;
7699 case 0x81:
7700 GETBYTE ();
7701 switch (op[1] & 0x00)
7703 case 0x00:
7704 goto op_semantics_52;
7705 break;
7707 break;
7708 case 0x82:
7709 GETBYTE ();
7710 switch (op[1] & 0x00)
7712 case 0x00:
7713 goto op_semantics_52;
7714 break;
7716 break;
7717 case 0x83:
7718 GETBYTE ();
7719 switch (op[1] & 0x00)
7721 case 0x00:
7722 goto op_semantics_52;
7723 break;
7725 break;
7726 case 0x84:
7727 GETBYTE ();
7728 switch (op[1] & 0x00)
7730 case 0x00:
7731 goto op_semantics_52;
7732 break;
7734 break;
7735 case 0x85:
7736 GETBYTE ();
7737 switch (op[1] & 0x00)
7739 case 0x00:
7740 goto op_semantics_52;
7741 break;
7743 break;
7744 case 0x86:
7745 GETBYTE ();
7746 switch (op[1] & 0x00)
7748 case 0x00:
7749 goto op_semantics_52;
7750 break;
7752 break;
7753 case 0x87:
7754 GETBYTE ();
7755 switch (op[1] & 0x00)
7757 case 0x00:
7758 goto op_semantics_52;
7759 break;
7761 break;
7762 case 0x88:
7763 GETBYTE ();
7764 switch (op[1] & 0x00)
7766 case 0x00:
7767 op_semantics_53:
7769 /** 10sz 1dsp a src b dst mov%s %1, %0 */
7770 #line 354 "rx-decode.opc"
7771 int sz AU = (op[0] >> 4) & 0x03;
7772 #line 354 "rx-decode.opc"
7773 int dsp AU = op[0] & 0x07;
7774 #line 354 "rx-decode.opc"
7775 int a AU = (op[1] >> 7) & 0x01;
7776 #line 354 "rx-decode.opc"
7777 int src AU = (op[1] >> 4) & 0x07;
7778 #line 354 "rx-decode.opc"
7779 int b AU = (op[1] >> 3) & 0x01;
7780 #line 354 "rx-decode.opc"
7781 int dst AU = op[1] & 0x07;
7782 if (trace)
7784 printf ("\033[33m%s\033[0m %02x %02x\n",
7785 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
7786 op[0], op[1]);
7787 printf (" sz = 0x%x,", sz);
7788 printf (" dsp = 0x%x,", dsp);
7789 printf (" a = 0x%x,", a);
7790 printf (" src = 0x%x,", src);
7791 printf (" b = 0x%x,", b);
7792 printf (" dst = 0x%x\n", dst);
7794 SYNTAX("mov%s %1, %0");
7795 #line 354 "rx-decode.opc"
7796 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
7799 break;
7801 break;
7802 case 0x89:
7803 GETBYTE ();
7804 switch (op[1] & 0x00)
7806 case 0x00:
7807 goto op_semantics_53;
7808 break;
7810 break;
7811 case 0x8a:
7812 GETBYTE ();
7813 switch (op[1] & 0x00)
7815 case 0x00:
7816 goto op_semantics_53;
7817 break;
7819 break;
7820 case 0x8b:
7821 GETBYTE ();
7822 switch (op[1] & 0x00)
7824 case 0x00:
7825 goto op_semantics_53;
7826 break;
7828 break;
7829 case 0x8c:
7830 GETBYTE ();
7831 switch (op[1] & 0x00)
7833 case 0x00:
7834 goto op_semantics_53;
7835 break;
7837 break;
7838 case 0x8d:
7839 GETBYTE ();
7840 switch (op[1] & 0x00)
7842 case 0x00:
7843 goto op_semantics_53;
7844 break;
7846 break;
7847 case 0x8e:
7848 GETBYTE ();
7849 switch (op[1] & 0x00)
7851 case 0x00:
7852 goto op_semantics_53;
7853 break;
7855 break;
7856 case 0x8f:
7857 GETBYTE ();
7858 switch (op[1] & 0x00)
7860 case 0x00:
7861 goto op_semantics_53;
7862 break;
7864 break;
7865 case 0x90:
7866 GETBYTE ();
7867 switch (op[1] & 0x00)
7869 case 0x00:
7870 goto op_semantics_52;
7871 break;
7873 break;
7874 case 0x91:
7875 GETBYTE ();
7876 switch (op[1] & 0x00)
7878 case 0x00:
7879 goto op_semantics_52;
7880 break;
7882 break;
7883 case 0x92:
7884 GETBYTE ();
7885 switch (op[1] & 0x00)
7887 case 0x00:
7888 goto op_semantics_52;
7889 break;
7891 break;
7892 case 0x93:
7893 GETBYTE ();
7894 switch (op[1] & 0x00)
7896 case 0x00:
7897 goto op_semantics_52;
7898 break;
7900 break;
7901 case 0x94:
7902 GETBYTE ();
7903 switch (op[1] & 0x00)
7905 case 0x00:
7906 goto op_semantics_52;
7907 break;
7909 break;
7910 case 0x95:
7911 GETBYTE ();
7912 switch (op[1] & 0x00)
7914 case 0x00:
7915 goto op_semantics_52;
7916 break;
7918 break;
7919 case 0x96:
7920 GETBYTE ();
7921 switch (op[1] & 0x00)
7923 case 0x00:
7924 goto op_semantics_52;
7925 break;
7927 break;
7928 case 0x97:
7929 GETBYTE ();
7930 switch (op[1] & 0x00)
7932 case 0x00:
7933 goto op_semantics_52;
7934 break;
7936 break;
7937 case 0x98:
7938 GETBYTE ();
7939 switch (op[1] & 0x00)
7941 case 0x00:
7942 goto op_semantics_53;
7943 break;
7945 break;
7946 case 0x99:
7947 GETBYTE ();
7948 switch (op[1] & 0x00)
7950 case 0x00:
7951 goto op_semantics_53;
7952 break;
7954 break;
7955 case 0x9a:
7956 GETBYTE ();
7957 switch (op[1] & 0x00)
7959 case 0x00:
7960 goto op_semantics_53;
7961 break;
7963 break;
7964 case 0x9b:
7965 GETBYTE ();
7966 switch (op[1] & 0x00)
7968 case 0x00:
7969 goto op_semantics_53;
7970 break;
7972 break;
7973 case 0x9c:
7974 GETBYTE ();
7975 switch (op[1] & 0x00)
7977 case 0x00:
7978 goto op_semantics_53;
7979 break;
7981 break;
7982 case 0x9d:
7983 GETBYTE ();
7984 switch (op[1] & 0x00)
7986 case 0x00:
7987 goto op_semantics_53;
7988 break;
7990 break;
7991 case 0x9e:
7992 GETBYTE ();
7993 switch (op[1] & 0x00)
7995 case 0x00:
7996 goto op_semantics_53;
7997 break;
7999 break;
8000 case 0x9f:
8001 GETBYTE ();
8002 switch (op[1] & 0x00)
8004 case 0x00:
8005 goto op_semantics_53;
8006 break;
8008 break;
8009 case 0xa0:
8010 GETBYTE ();
8011 switch (op[1] & 0x00)
8013 case 0x00:
8014 goto op_semantics_52;
8015 break;
8017 break;
8018 case 0xa1:
8019 GETBYTE ();
8020 switch (op[1] & 0x00)
8022 case 0x00:
8023 goto op_semantics_52;
8024 break;
8026 break;
8027 case 0xa2:
8028 GETBYTE ();
8029 switch (op[1] & 0x00)
8031 case 0x00:
8032 goto op_semantics_52;
8033 break;
8035 break;
8036 case 0xa3:
8037 GETBYTE ();
8038 switch (op[1] & 0x00)
8040 case 0x00:
8041 goto op_semantics_52;
8042 break;
8044 break;
8045 case 0xa4:
8046 GETBYTE ();
8047 switch (op[1] & 0x00)
8049 case 0x00:
8050 goto op_semantics_52;
8051 break;
8053 break;
8054 case 0xa5:
8055 GETBYTE ();
8056 switch (op[1] & 0x00)
8058 case 0x00:
8059 goto op_semantics_52;
8060 break;
8062 break;
8063 case 0xa6:
8064 GETBYTE ();
8065 switch (op[1] & 0x00)
8067 case 0x00:
8068 goto op_semantics_52;
8069 break;
8071 break;
8072 case 0xa7:
8073 GETBYTE ();
8074 switch (op[1] & 0x00)
8076 case 0x00:
8077 goto op_semantics_52;
8078 break;
8080 break;
8081 case 0xa8:
8082 GETBYTE ();
8083 switch (op[1] & 0x00)
8085 case 0x00:
8086 goto op_semantics_53;
8087 break;
8089 break;
8090 case 0xa9:
8091 GETBYTE ();
8092 switch (op[1] & 0x00)
8094 case 0x00:
8095 goto op_semantics_53;
8096 break;
8098 break;
8099 case 0xaa:
8100 GETBYTE ();
8101 switch (op[1] & 0x00)
8103 case 0x00:
8104 goto op_semantics_53;
8105 break;
8107 break;
8108 case 0xab:
8109 GETBYTE ();
8110 switch (op[1] & 0x00)
8112 case 0x00:
8113 goto op_semantics_53;
8114 break;
8116 break;
8117 case 0xac:
8118 GETBYTE ();
8119 switch (op[1] & 0x00)
8121 case 0x00:
8122 goto op_semantics_53;
8123 break;
8125 break;
8126 case 0xad:
8127 GETBYTE ();
8128 switch (op[1] & 0x00)
8130 case 0x00:
8131 goto op_semantics_53;
8132 break;
8134 break;
8135 case 0xae:
8136 GETBYTE ();
8137 switch (op[1] & 0x00)
8139 case 0x00:
8140 goto op_semantics_53;
8141 break;
8143 break;
8144 case 0xaf:
8145 GETBYTE ();
8146 switch (op[1] & 0x00)
8148 case 0x00:
8149 goto op_semantics_53;
8150 break;
8152 break;
8153 case 0xb0:
8154 GETBYTE ();
8155 switch (op[1] & 0x00)
8157 case 0x00:
8158 op_semantics_54:
8160 /** 1011 w dsp a src b dst movu%s %1, %0 */
8161 #line 377 "rx-decode.opc"
8162 int w AU = (op[0] >> 3) & 0x01;
8163 #line 377 "rx-decode.opc"
8164 int dsp AU = op[0] & 0x07;
8165 #line 377 "rx-decode.opc"
8166 int a AU = (op[1] >> 7) & 0x01;
8167 #line 377 "rx-decode.opc"
8168 int src AU = (op[1] >> 4) & 0x07;
8169 #line 377 "rx-decode.opc"
8170 int b AU = (op[1] >> 3) & 0x01;
8171 #line 377 "rx-decode.opc"
8172 int dst AU = op[1] & 0x07;
8173 if (trace)
8175 printf ("\033[33m%s\033[0m %02x %02x\n",
8176 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
8177 op[0], op[1]);
8178 printf (" w = 0x%x,", w);
8179 printf (" dsp = 0x%x,", dsp);
8180 printf (" a = 0x%x,", a);
8181 printf (" src = 0x%x,", src);
8182 printf (" b = 0x%x,", b);
8183 printf (" dst = 0x%x\n", dst);
8185 SYNTAX("movu%s %1, %0");
8186 #line 377 "rx-decode.opc"
8187 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
8190 break;
8192 break;
8193 case 0xb1:
8194 GETBYTE ();
8195 switch (op[1] & 0x00)
8197 case 0x00:
8198 goto op_semantics_54;
8199 break;
8201 break;
8202 case 0xb2:
8203 GETBYTE ();
8204 switch (op[1] & 0x00)
8206 case 0x00:
8207 goto op_semantics_54;
8208 break;
8210 break;
8211 case 0xb3:
8212 GETBYTE ();
8213 switch (op[1] & 0x00)
8215 case 0x00:
8216 goto op_semantics_54;
8217 break;
8219 break;
8220 case 0xb4:
8221 GETBYTE ();
8222 switch (op[1] & 0x00)
8224 case 0x00:
8225 goto op_semantics_54;
8226 break;
8228 break;
8229 case 0xb5:
8230 GETBYTE ();
8231 switch (op[1] & 0x00)
8233 case 0x00:
8234 goto op_semantics_54;
8235 break;
8237 break;
8238 case 0xb6:
8239 GETBYTE ();
8240 switch (op[1] & 0x00)
8242 case 0x00:
8243 goto op_semantics_54;
8244 break;
8246 break;
8247 case 0xb7:
8248 GETBYTE ();
8249 switch (op[1] & 0x00)
8251 case 0x00:
8252 goto op_semantics_54;
8253 break;
8255 break;
8256 case 0xb8:
8257 GETBYTE ();
8258 switch (op[1] & 0x00)
8260 case 0x00:
8261 goto op_semantics_54;
8262 break;
8264 break;
8265 case 0xb9:
8266 GETBYTE ();
8267 switch (op[1] & 0x00)
8269 case 0x00:
8270 goto op_semantics_54;
8271 break;
8273 break;
8274 case 0xba:
8275 GETBYTE ();
8276 switch (op[1] & 0x00)
8278 case 0x00:
8279 goto op_semantics_54;
8280 break;
8282 break;
8283 case 0xbb:
8284 GETBYTE ();
8285 switch (op[1] & 0x00)
8287 case 0x00:
8288 goto op_semantics_54;
8289 break;
8291 break;
8292 case 0xbc:
8293 GETBYTE ();
8294 switch (op[1] & 0x00)
8296 case 0x00:
8297 goto op_semantics_54;
8298 break;
8300 break;
8301 case 0xbd:
8302 GETBYTE ();
8303 switch (op[1] & 0x00)
8305 case 0x00:
8306 goto op_semantics_54;
8307 break;
8309 break;
8310 case 0xbe:
8311 GETBYTE ();
8312 switch (op[1] & 0x00)
8314 case 0x00:
8315 goto op_semantics_54;
8316 break;
8318 break;
8319 case 0xbf:
8320 GETBYTE ();
8321 switch (op[1] & 0x00)
8323 case 0x00:
8324 goto op_semantics_54;
8325 break;
8327 break;
8328 case 0xc0:
8329 GETBYTE ();
8330 switch (op[1] & 0x00)
8332 case 0x00:
8333 op_semantics_55:
8335 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
8336 #line 335 "rx-decode.opc"
8337 int sz AU = (op[0] >> 4) & 0x03;
8338 #line 335 "rx-decode.opc"
8339 int sd AU = (op[0] >> 2) & 0x03;
8340 #line 335 "rx-decode.opc"
8341 int ss AU = op[0] & 0x03;
8342 #line 335 "rx-decode.opc"
8343 int rsrc AU = (op[1] >> 4) & 0x0f;
8344 #line 335 "rx-decode.opc"
8345 int rdst AU = op[1] & 0x0f;
8346 if (trace)
8348 printf ("\033[33m%s\033[0m %02x %02x\n",
8349 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
8350 op[0], op[1]);
8351 printf (" sz = 0x%x,", sz);
8352 printf (" sd = 0x%x,", sd);
8353 printf (" ss = 0x%x,", ss);
8354 printf (" rsrc = 0x%x,", rsrc);
8355 printf (" rdst = 0x%x\n", rdst);
8357 SYNTAX("mov%s %1, %0");
8358 #line 335 "rx-decode.opc"
8359 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
8361 ID(nop2);
8362 SYNTAX ("nop\t; mov.l\tr0, r0");
8364 else
8366 ID(mov); sBWL(sz); F_____;
8367 if ((ss == 3) && (sd != 3))
8369 SD(ss, rdst, sz); DD(sd, rsrc, sz);
8371 else
8373 SD(ss, rsrc, sz); DD(sd, rdst, sz);
8378 break;
8380 break;
8381 case 0xc1:
8382 GETBYTE ();
8383 switch (op[1] & 0x00)
8385 case 0x00:
8386 goto op_semantics_55;
8387 break;
8389 break;
8390 case 0xc2:
8391 GETBYTE ();
8392 switch (op[1] & 0x00)
8394 case 0x00:
8395 goto op_semantics_55;
8396 break;
8398 break;
8399 case 0xc3:
8400 GETBYTE ();
8401 switch (op[1] & 0x00)
8403 case 0x00:
8404 goto op_semantics_55;
8405 break;
8407 break;
8408 case 0xc4:
8409 GETBYTE ();
8410 switch (op[1] & 0x00)
8412 case 0x00:
8413 goto op_semantics_55;
8414 break;
8416 break;
8417 case 0xc5:
8418 GETBYTE ();
8419 switch (op[1] & 0x00)
8421 case 0x00:
8422 goto op_semantics_55;
8423 break;
8425 break;
8426 case 0xc6:
8427 GETBYTE ();
8428 switch (op[1] & 0x00)
8430 case 0x00:
8431 goto op_semantics_55;
8432 break;
8434 break;
8435 case 0xc7:
8436 GETBYTE ();
8437 switch (op[1] & 0x00)
8439 case 0x00:
8440 goto op_semantics_55;
8441 break;
8443 break;
8444 case 0xc8:
8445 GETBYTE ();
8446 switch (op[1] & 0x00)
8448 case 0x00:
8449 goto op_semantics_55;
8450 break;
8452 break;
8453 case 0xc9:
8454 GETBYTE ();
8455 switch (op[1] & 0x00)
8457 case 0x00:
8458 goto op_semantics_55;
8459 break;
8461 break;
8462 case 0xca:
8463 GETBYTE ();
8464 switch (op[1] & 0x00)
8466 case 0x00:
8467 goto op_semantics_55;
8468 break;
8470 break;
8471 case 0xcb:
8472 GETBYTE ();
8473 switch (op[1] & 0x00)
8475 case 0x00:
8476 goto op_semantics_55;
8477 break;
8479 break;
8480 case 0xcc:
8481 GETBYTE ();
8482 switch (op[1] & 0x00)
8484 case 0x00:
8485 goto op_semantics_55;
8486 break;
8488 break;
8489 case 0xcd:
8490 GETBYTE ();
8491 switch (op[1] & 0x00)
8493 case 0x00:
8494 goto op_semantics_55;
8495 break;
8497 break;
8498 case 0xce:
8499 GETBYTE ();
8500 switch (op[1] & 0x00)
8502 case 0x00:
8503 goto op_semantics_55;
8504 break;
8506 break;
8507 case 0xcf:
8508 GETBYTE ();
8509 switch (op[1] & 0x00)
8511 case 0x00:
8512 goto op_semantics_55;
8513 break;
8515 break;
8516 case 0xd0:
8517 GETBYTE ();
8518 switch (op[1] & 0x00)
8520 case 0x00:
8521 goto op_semantics_55;
8522 break;
8524 break;
8525 case 0xd1:
8526 GETBYTE ();
8527 switch (op[1] & 0x00)
8529 case 0x00:
8530 goto op_semantics_55;
8531 break;
8533 break;
8534 case 0xd2:
8535 GETBYTE ();
8536 switch (op[1] & 0x00)
8538 case 0x00:
8539 goto op_semantics_55;
8540 break;
8542 break;
8543 case 0xd3:
8544 GETBYTE ();
8545 switch (op[1] & 0x00)
8547 case 0x00:
8548 goto op_semantics_55;
8549 break;
8551 break;
8552 case 0xd4:
8553 GETBYTE ();
8554 switch (op[1] & 0x00)
8556 case 0x00:
8557 goto op_semantics_55;
8558 break;
8560 break;
8561 case 0xd5:
8562 GETBYTE ();
8563 switch (op[1] & 0x00)
8565 case 0x00:
8566 goto op_semantics_55;
8567 break;
8569 break;
8570 case 0xd6:
8571 GETBYTE ();
8572 switch (op[1] & 0x00)
8574 case 0x00:
8575 goto op_semantics_55;
8576 break;
8578 break;
8579 case 0xd7:
8580 GETBYTE ();
8581 switch (op[1] & 0x00)
8583 case 0x00:
8584 goto op_semantics_55;
8585 break;
8587 break;
8588 case 0xd8:
8589 GETBYTE ();
8590 switch (op[1] & 0x00)
8592 case 0x00:
8593 goto op_semantics_55;
8594 break;
8596 break;
8597 case 0xd9:
8598 GETBYTE ();
8599 switch (op[1] & 0x00)
8601 case 0x00:
8602 goto op_semantics_55;
8603 break;
8605 break;
8606 case 0xda:
8607 GETBYTE ();
8608 switch (op[1] & 0x00)
8610 case 0x00:
8611 goto op_semantics_55;
8612 break;
8614 break;
8615 case 0xdb:
8616 GETBYTE ();
8617 switch (op[1] & 0x00)
8619 case 0x00:
8620 goto op_semantics_55;
8621 break;
8623 break;
8624 case 0xdc:
8625 GETBYTE ();
8626 switch (op[1] & 0x00)
8628 case 0x00:
8629 goto op_semantics_55;
8630 break;
8632 break;
8633 case 0xdd:
8634 GETBYTE ();
8635 switch (op[1] & 0x00)
8637 case 0x00:
8638 goto op_semantics_55;
8639 break;
8641 break;
8642 case 0xde:
8643 GETBYTE ();
8644 switch (op[1] & 0x00)
8646 case 0x00:
8647 goto op_semantics_55;
8648 break;
8650 break;
8651 case 0xdf:
8652 GETBYTE ();
8653 switch (op[1] & 0x00)
8655 case 0x00:
8656 goto op_semantics_55;
8657 break;
8659 break;
8660 case 0xe0:
8661 GETBYTE ();
8662 switch (op[1] & 0x00)
8664 case 0x00:
8665 goto op_semantics_55;
8666 break;
8668 break;
8669 case 0xe1:
8670 GETBYTE ();
8671 switch (op[1] & 0x00)
8673 case 0x00:
8674 goto op_semantics_55;
8675 break;
8677 break;
8678 case 0xe2:
8679 GETBYTE ();
8680 switch (op[1] & 0x00)
8682 case 0x00:
8683 goto op_semantics_55;
8684 break;
8686 break;
8687 case 0xe3:
8688 GETBYTE ();
8689 switch (op[1] & 0x00)
8691 case 0x00:
8692 goto op_semantics_55;
8693 break;
8695 break;
8696 case 0xe4:
8697 GETBYTE ();
8698 switch (op[1] & 0x00)
8700 case 0x00:
8701 goto op_semantics_55;
8702 break;
8704 break;
8705 case 0xe5:
8706 GETBYTE ();
8707 switch (op[1] & 0x00)
8709 case 0x00:
8710 goto op_semantics_55;
8711 break;
8713 break;
8714 case 0xe6:
8715 GETBYTE ();
8716 switch (op[1] & 0x00)
8718 case 0x00:
8719 goto op_semantics_55;
8720 break;
8722 break;
8723 case 0xe7:
8724 GETBYTE ();
8725 switch (op[1] & 0x00)
8727 case 0x00:
8728 goto op_semantics_55;
8729 break;
8731 break;
8732 case 0xe8:
8733 GETBYTE ();
8734 switch (op[1] & 0x00)
8736 case 0x00:
8737 goto op_semantics_55;
8738 break;
8740 break;
8741 case 0xe9:
8742 GETBYTE ();
8743 switch (op[1] & 0x00)
8745 case 0x00:
8746 goto op_semantics_55;
8747 break;
8749 break;
8750 case 0xea:
8751 GETBYTE ();
8752 switch (op[1] & 0x00)
8754 case 0x00:
8755 goto op_semantics_55;
8756 break;
8758 break;
8759 case 0xeb:
8760 GETBYTE ();
8761 switch (op[1] & 0x00)
8763 case 0x00:
8764 goto op_semantics_55;
8765 break;
8767 break;
8768 case 0xec:
8769 GETBYTE ();
8770 switch (op[1] & 0x00)
8772 case 0x00:
8773 goto op_semantics_55;
8774 break;
8776 break;
8777 case 0xed:
8778 GETBYTE ();
8779 switch (op[1] & 0x00)
8781 case 0x00:
8782 goto op_semantics_55;
8783 break;
8785 break;
8786 case 0xee:
8787 GETBYTE ();
8788 switch (op[1] & 0x00)
8790 case 0x00:
8791 goto op_semantics_55;
8792 break;
8794 break;
8795 case 0xef:
8796 GETBYTE ();
8797 switch (op[1] & 0x00)
8799 case 0x00:
8800 goto op_semantics_55;
8801 break;
8803 break;
8804 case 0xf0:
8805 GETBYTE ();
8806 switch (op[1] & 0x08)
8808 case 0x00:
8809 op_semantics_56:
8811 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
8812 #line 960 "rx-decode.opc"
8813 int sd AU = op[0] & 0x03;
8814 #line 960 "rx-decode.opc"
8815 int rdst AU = (op[1] >> 4) & 0x0f;
8816 #line 960 "rx-decode.opc"
8817 int bit AU = op[1] & 0x07;
8818 if (trace)
8820 printf ("\033[33m%s\033[0m %02x %02x\n",
8821 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
8822 op[0], op[1]);
8823 printf (" sd = 0x%x,", sd);
8824 printf (" rdst = 0x%x,", rdst);
8825 printf (" bit = 0x%x\n", bit);
8827 SYNTAX("bset #%1, %0%S0");
8828 #line 960 "rx-decode.opc"
8829 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8832 break;
8833 case 0x08:
8834 op_semantics_57:
8836 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
8837 #line 972 "rx-decode.opc"
8838 int sd AU = op[0] & 0x03;
8839 #line 972 "rx-decode.opc"
8840 int rdst AU = (op[1] >> 4) & 0x0f;
8841 #line 972 "rx-decode.opc"
8842 int bit AU = op[1] & 0x07;
8843 if (trace)
8845 printf ("\033[33m%s\033[0m %02x %02x\n",
8846 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
8847 op[0], op[1]);
8848 printf (" sd = 0x%x,", sd);
8849 printf (" rdst = 0x%x,", rdst);
8850 printf (" bit = 0x%x\n", bit);
8852 SYNTAX("bclr #%1, %0%S0");
8853 #line 972 "rx-decode.opc"
8854 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8857 break;
8859 break;
8860 case 0xf1:
8861 GETBYTE ();
8862 switch (op[1] & 0x08)
8864 case 0x00:
8865 goto op_semantics_56;
8866 break;
8867 case 0x08:
8868 goto op_semantics_57;
8869 break;
8871 break;
8872 case 0xf2:
8873 GETBYTE ();
8874 switch (op[1] & 0x08)
8876 case 0x00:
8877 goto op_semantics_56;
8878 break;
8879 case 0x08:
8880 goto op_semantics_57;
8881 break;
8883 break;
8884 case 0xf3:
8885 GETBYTE ();
8886 switch (op[1] & 0x08)
8888 case 0x00:
8889 goto op_semantics_56;
8890 break;
8891 case 0x08:
8892 goto op_semantics_57;
8893 break;
8895 break;
8896 case 0xf4:
8897 GETBYTE ();
8898 switch (op[1] & 0x0c)
8900 case 0x00:
8901 case 0x04:
8902 op_semantics_58:
8904 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
8905 #line 984 "rx-decode.opc"
8906 int sd AU = op[0] & 0x03;
8907 #line 984 "rx-decode.opc"
8908 int rdst AU = (op[1] >> 4) & 0x0f;
8909 #line 984 "rx-decode.opc"
8910 int bit AU = op[1] & 0x07;
8911 if (trace)
8913 printf ("\033[33m%s\033[0m %02x %02x\n",
8914 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
8915 op[0], op[1]);
8916 printf (" sd = 0x%x,", sd);
8917 printf (" rdst = 0x%x,", rdst);
8918 printf (" bit = 0x%x\n", bit);
8920 SYNTAX("btst #%2, %1%S1");
8921 #line 984 "rx-decode.opc"
8922 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
8925 break;
8926 case 0x08:
8927 op_semantics_59:
8929 /** 1111 01ss rsrc 10sz push%s %1 */
8930 #line 402 "rx-decode.opc"
8931 int ss AU = op[0] & 0x03;
8932 #line 402 "rx-decode.opc"
8933 int rsrc AU = (op[1] >> 4) & 0x0f;
8934 #line 402 "rx-decode.opc"
8935 int sz AU = op[1] & 0x03;
8936 if (trace)
8938 printf ("\033[33m%s\033[0m %02x %02x\n",
8939 "/** 1111 01ss rsrc 10sz push%s %1 */",
8940 op[0], op[1]);
8941 printf (" ss = 0x%x,", ss);
8942 printf (" rsrc = 0x%x,", rsrc);
8943 printf (" sz = 0x%x\n", sz);
8945 SYNTAX("push%s %1");
8946 #line 402 "rx-decode.opc"
8947 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
8949 /*----------------------------------------------------------------------*/
8950 /* XCHG */
8953 break;
8954 default: UNSUPPORTED(); break;
8956 break;
8957 case 0xf5:
8958 GETBYTE ();
8959 switch (op[1] & 0x0c)
8961 case 0x00:
8962 case 0x04:
8963 goto op_semantics_58;
8964 break;
8965 case 0x08:
8966 goto op_semantics_59;
8967 break;
8968 default: UNSUPPORTED(); break;
8970 break;
8971 case 0xf6:
8972 GETBYTE ();
8973 switch (op[1] & 0x0c)
8975 case 0x00:
8976 case 0x04:
8977 goto op_semantics_58;
8978 break;
8979 case 0x08:
8980 goto op_semantics_59;
8981 break;
8982 default: UNSUPPORTED(); break;
8984 break;
8985 case 0xf7:
8986 GETBYTE ();
8987 switch (op[1] & 0x0c)
8989 case 0x00:
8990 case 0x04:
8991 goto op_semantics_58;
8992 break;
8993 case 0x08:
8994 goto op_semantics_59;
8995 break;
8996 default: UNSUPPORTED(); break;
8998 break;
8999 case 0xf8:
9000 GETBYTE ();
9001 switch (op[1] & 0x00)
9003 case 0x00:
9004 op_semantics_60:
9006 /** 1111 10sd rdst im sz mov%s #%1, %0 */
9007 #line 313 "rx-decode.opc"
9008 int sd AU = op[0] & 0x03;
9009 #line 313 "rx-decode.opc"
9010 int rdst AU = (op[1] >> 4) & 0x0f;
9011 #line 313 "rx-decode.opc"
9012 int im AU = (op[1] >> 2) & 0x03;
9013 #line 313 "rx-decode.opc"
9014 int sz AU = op[1] & 0x03;
9015 if (trace)
9017 printf ("\033[33m%s\033[0m %02x %02x\n",
9018 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
9019 op[0], op[1]);
9020 printf (" sd = 0x%x,", sd);
9021 printf (" rdst = 0x%x,", rdst);
9022 printf (" im = 0x%x,", im);
9023 printf (" sz = 0x%x\n", sz);
9025 SYNTAX("mov%s #%1, %0");
9026 #line 313 "rx-decode.opc"
9027 ID(mov); DD(sd, rdst, sz);
9028 if ((im == 1 && sz == 0)
9029 || (im == 2 && sz == 1)
9030 || (im == 0 && sz == 2))
9032 BWL (sz);
9033 SC(IMM(im));
9035 else
9037 sBWL (sz);
9038 SC(IMMex(im));
9040 F_____;
9043 break;
9045 break;
9046 case 0xf9:
9047 GETBYTE ();
9048 switch (op[1] & 0xff)
9050 case 0x00:
9051 case 0x01:
9052 case 0x02:
9053 case 0x04:
9054 case 0x05:
9055 case 0x06:
9056 case 0x08:
9057 case 0x09:
9058 case 0x0a:
9059 case 0x0c:
9060 case 0x0d:
9061 case 0x0e:
9062 case 0x10:
9063 case 0x11:
9064 case 0x12:
9065 case 0x14:
9066 case 0x15:
9067 case 0x16:
9068 case 0x18:
9069 case 0x19:
9070 case 0x1a:
9071 case 0x1c:
9072 case 0x1d:
9073 case 0x1e:
9074 case 0x20:
9075 case 0x21:
9076 case 0x22:
9077 case 0x24:
9078 case 0x25:
9079 case 0x26:
9080 case 0x28:
9081 case 0x29:
9082 case 0x2a:
9083 case 0x2c:
9084 case 0x2d:
9085 case 0x2e:
9086 case 0x30:
9087 case 0x31:
9088 case 0x32:
9089 case 0x34:
9090 case 0x35:
9091 case 0x36:
9092 case 0x38:
9093 case 0x39:
9094 case 0x3a:
9095 case 0x3c:
9096 case 0x3d:
9097 case 0x3e:
9098 case 0x40:
9099 case 0x41:
9100 case 0x42:
9101 case 0x44:
9102 case 0x45:
9103 case 0x46:
9104 case 0x48:
9105 case 0x49:
9106 case 0x4a:
9107 case 0x4c:
9108 case 0x4d:
9109 case 0x4e:
9110 case 0x50:
9111 case 0x51:
9112 case 0x52:
9113 case 0x54:
9114 case 0x55:
9115 case 0x56:
9116 case 0x58:
9117 case 0x59:
9118 case 0x5a:
9119 case 0x5c:
9120 case 0x5d:
9121 case 0x5e:
9122 case 0x60:
9123 case 0x61:
9124 case 0x62:
9125 case 0x64:
9126 case 0x65:
9127 case 0x66:
9128 case 0x68:
9129 case 0x69:
9130 case 0x6a:
9131 case 0x6c:
9132 case 0x6d:
9133 case 0x6e:
9134 case 0x70:
9135 case 0x71:
9136 case 0x72:
9137 case 0x74:
9138 case 0x75:
9139 case 0x76:
9140 case 0x78:
9141 case 0x79:
9142 case 0x7a:
9143 case 0x7c:
9144 case 0x7d:
9145 case 0x7e:
9146 case 0x80:
9147 case 0x81:
9148 case 0x82:
9149 case 0x84:
9150 case 0x85:
9151 case 0x86:
9152 case 0x88:
9153 case 0x89:
9154 case 0x8a:
9155 case 0x8c:
9156 case 0x8d:
9157 case 0x8e:
9158 case 0x90:
9159 case 0x91:
9160 case 0x92:
9161 case 0x94:
9162 case 0x95:
9163 case 0x96:
9164 case 0x98:
9165 case 0x99:
9166 case 0x9a:
9167 case 0x9c:
9168 case 0x9d:
9169 case 0x9e:
9170 case 0xa0:
9171 case 0xa1:
9172 case 0xa2:
9173 case 0xa4:
9174 case 0xa5:
9175 case 0xa6:
9176 case 0xa8:
9177 case 0xa9:
9178 case 0xaa:
9179 case 0xac:
9180 case 0xad:
9181 case 0xae:
9182 case 0xb0:
9183 case 0xb1:
9184 case 0xb2:
9185 case 0xb4:
9186 case 0xb5:
9187 case 0xb6:
9188 case 0xb8:
9189 case 0xb9:
9190 case 0xba:
9191 case 0xbc:
9192 case 0xbd:
9193 case 0xbe:
9194 case 0xc0:
9195 case 0xc1:
9196 case 0xc2:
9197 case 0xc4:
9198 case 0xc5:
9199 case 0xc6:
9200 case 0xc8:
9201 case 0xc9:
9202 case 0xca:
9203 case 0xcc:
9204 case 0xcd:
9205 case 0xce:
9206 case 0xd0:
9207 case 0xd1:
9208 case 0xd2:
9209 case 0xd4:
9210 case 0xd5:
9211 case 0xd6:
9212 case 0xd8:
9213 case 0xd9:
9214 case 0xda:
9215 case 0xdc:
9216 case 0xdd:
9217 case 0xde:
9218 case 0xe0:
9219 case 0xe1:
9220 case 0xe2:
9221 case 0xe4:
9222 case 0xe5:
9223 case 0xe6:
9224 case 0xe8:
9225 case 0xe9:
9226 case 0xea:
9227 case 0xec:
9228 case 0xed:
9229 case 0xee:
9230 case 0xf0:
9231 case 0xf1:
9232 case 0xf2:
9233 case 0xf4:
9234 case 0xf5:
9235 case 0xf6:
9236 case 0xf8:
9237 case 0xf9:
9238 case 0xfa:
9239 case 0xfc:
9240 case 0xfd:
9241 case 0xfe:
9242 goto op_semantics_60;
9243 break;
9244 case 0x03:
9245 GETBYTE ();
9246 switch (op[2] & 0x0f)
9248 case 0x00:
9250 /** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */
9251 #line 1211 "rx-decode.opc"
9252 int rdst AU = (op[2] >> 4) & 0x0f;
9253 if (trace)
9255 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9256 "/** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */",
9257 op[0], op[1], op[2]);
9258 printf (" rdst = 0x%x\n", rdst);
9260 SYNTAX("dmov.l #%1, %0");
9261 #line 1211 "rx-decode.opc"
9262 ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____;
9265 break;
9266 case 0x02:
9267 case 0x03:
9269 /** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */
9270 #line 1208 "rx-decode.opc"
9271 int rdst AU = (op[2] >> 4) & 0x0f;
9272 #line 1208 "rx-decode.opc"
9273 int s AU = op[2] & 0x01;
9274 if (trace)
9276 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9277 "/** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */",
9278 op[0], op[1], op[2]);
9279 printf (" rdst = 0x%x,", rdst);
9280 printf (" s = 0x%x\n", s);
9282 SYNTAX("dmov%s #%1, %0");
9283 #line 1208 "rx-decode.opc"
9284 ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____;
9287 break;
9288 default: UNSUPPORTED(); break;
9290 break;
9291 default: UNSUPPORTED(); break;
9293 break;
9294 case 0xfa:
9295 GETBYTE ();
9296 switch (op[1] & 0x00)
9298 case 0x00:
9299 goto op_semantics_60;
9300 break;
9302 break;
9303 case 0xfb:
9304 GETBYTE ();
9305 switch (op[1] & 0x00)
9307 case 0x00:
9308 goto op_semantics_60;
9309 break;
9311 break;
9312 case 0xfc:
9313 GETBYTE ();
9314 switch (op[1] & 0xff)
9316 case 0x03:
9317 GETBYTE ();
9318 switch (op[2] & 0x00)
9320 case 0x00:
9322 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
9323 #line 576 "rx-decode.opc"
9324 int rsrc AU = (op[2] >> 4) & 0x0f;
9325 #line 576 "rx-decode.opc"
9326 int rdst AU = op[2] & 0x0f;
9327 if (trace)
9329 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9330 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
9331 op[0], op[1], op[2]);
9332 printf (" rsrc = 0x%x,", rsrc);
9333 printf (" rdst = 0x%x\n", rdst);
9335 SYNTAX("sbb %1, %0");
9336 #line 576 "rx-decode.opc"
9337 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
9339 /* FIXME: only supports .L */
9341 break;
9343 break;
9344 case 0x07:
9345 GETBYTE ();
9346 switch (op[2] & 0x00)
9348 case 0x00:
9350 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
9351 #line 507 "rx-decode.opc"
9352 int rsrc AU = (op[2] >> 4) & 0x0f;
9353 #line 507 "rx-decode.opc"
9354 int rdst AU = op[2] & 0x0f;
9355 if (trace)
9357 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9358 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
9359 op[0], op[1], op[2]);
9360 printf (" rsrc = 0x%x,", rsrc);
9361 printf (" rdst = 0x%x\n", rdst);
9363 SYNTAX("neg %2, %0");
9364 #line 507 "rx-decode.opc"
9365 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
9367 /*----------------------------------------------------------------------*/
9368 /* ADC */
9371 break;
9373 break;
9374 case 0x0b:
9375 GETBYTE ();
9376 switch (op[2] & 0x00)
9378 case 0x00:
9380 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
9381 #line 516 "rx-decode.opc"
9382 int rsrc AU = (op[2] >> 4) & 0x0f;
9383 #line 516 "rx-decode.opc"
9384 int rdst AU = op[2] & 0x0f;
9385 if (trace)
9387 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9388 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
9389 op[0], op[1], op[2]);
9390 printf (" rsrc = 0x%x,", rsrc);
9391 printf (" rdst = 0x%x\n", rdst);
9393 SYNTAX("adc %1, %0");
9394 #line 516 "rx-decode.opc"
9395 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
9398 break;
9400 break;
9401 case 0x0f:
9402 GETBYTE ();
9403 switch (op[2] & 0x00)
9405 case 0x00:
9407 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
9408 #line 589 "rx-decode.opc"
9409 int rsrc AU = (op[2] >> 4) & 0x0f;
9410 #line 589 "rx-decode.opc"
9411 int rdst AU = op[2] & 0x0f;
9412 if (trace)
9414 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9415 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
9416 op[0], op[1], op[2]);
9417 printf (" rsrc = 0x%x,", rsrc);
9418 printf (" rdst = 0x%x\n", rdst);
9420 SYNTAX("abs %1, %0");
9421 #line 589 "rx-decode.opc"
9422 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
9424 /*----------------------------------------------------------------------*/
9425 /* MAX */
9428 break;
9430 break;
9431 case 0x10:
9432 GETBYTE ();
9433 switch (op[2] & 0x00)
9435 case 0x00:
9436 op_semantics_61:
9438 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
9439 #line 608 "rx-decode.opc"
9440 int ss AU = op[1] & 0x03;
9441 #line 608 "rx-decode.opc"
9442 int rsrc AU = (op[2] >> 4) & 0x0f;
9443 #line 608 "rx-decode.opc"
9444 int rdst AU = op[2] & 0x0f;
9445 if (trace)
9447 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9448 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
9449 op[0], op[1], op[2]);
9450 printf (" ss = 0x%x,", ss);
9451 printf (" rsrc = 0x%x,", rsrc);
9452 printf (" rdst = 0x%x\n", rdst);
9454 SYNTAX("max %1%S1, %0");
9455 #line 608 "rx-decode.opc"
9456 if (ss == 3 && rsrc == 0 && rdst == 0)
9458 ID(nop3);
9459 SYNTAX("nop\t; max\tr0, r0");
9461 else
9463 ID(max); SP(ss, rsrc); DR(rdst);
9467 break;
9469 break;
9470 case 0x11:
9471 GETBYTE ();
9472 switch (op[2] & 0x00)
9474 case 0x00:
9475 goto op_semantics_61;
9476 break;
9478 break;
9479 case 0x12:
9480 GETBYTE ();
9481 switch (op[2] & 0x00)
9483 case 0x00:
9484 goto op_semantics_61;
9485 break;
9487 break;
9488 case 0x13:
9489 GETBYTE ();
9490 switch (op[2] & 0x00)
9492 case 0x00:
9493 goto op_semantics_61;
9494 break;
9496 break;
9497 case 0x14:
9498 GETBYTE ();
9499 switch (op[2] & 0x00)
9501 case 0x00:
9502 op_semantics_62:
9504 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
9505 #line 628 "rx-decode.opc"
9506 int ss AU = op[1] & 0x03;
9507 #line 628 "rx-decode.opc"
9508 int rsrc AU = (op[2] >> 4) & 0x0f;
9509 #line 628 "rx-decode.opc"
9510 int rdst AU = op[2] & 0x0f;
9511 if (trace)
9513 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9514 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
9515 op[0], op[1], op[2]);
9516 printf (" ss = 0x%x,", ss);
9517 printf (" rsrc = 0x%x,", rsrc);
9518 printf (" rdst = 0x%x\n", rdst);
9520 SYNTAX("min %1%S1, %0");
9521 #line 628 "rx-decode.opc"
9522 ID(min); SP(ss, rsrc); DR(rdst);
9525 break;
9527 break;
9528 case 0x15:
9529 GETBYTE ();
9530 switch (op[2] & 0x00)
9532 case 0x00:
9533 goto op_semantics_62;
9534 break;
9536 break;
9537 case 0x16:
9538 GETBYTE ();
9539 switch (op[2] & 0x00)
9541 case 0x00:
9542 goto op_semantics_62;
9543 break;
9545 break;
9546 case 0x17:
9547 GETBYTE ();
9548 switch (op[2] & 0x00)
9550 case 0x00:
9551 goto op_semantics_62;
9552 break;
9554 break;
9555 case 0x18:
9556 GETBYTE ();
9557 switch (op[2] & 0x00)
9559 case 0x00:
9560 op_semantics_63:
9562 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
9563 #line 686 "rx-decode.opc"
9564 int ss AU = op[1] & 0x03;
9565 #line 686 "rx-decode.opc"
9566 int rsrc AU = (op[2] >> 4) & 0x0f;
9567 #line 686 "rx-decode.opc"
9568 int rdst AU = op[2] & 0x0f;
9569 if (trace)
9571 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9572 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
9573 op[0], op[1], op[2]);
9574 printf (" ss = 0x%x,", ss);
9575 printf (" rsrc = 0x%x,", rsrc);
9576 printf (" rdst = 0x%x\n", rdst);
9578 SYNTAX("emul %1%S1, %0");
9579 #line 686 "rx-decode.opc"
9580 ID(emul); SP(ss, rsrc); DR(rdst);
9583 break;
9585 break;
9586 case 0x19:
9587 GETBYTE ();
9588 switch (op[2] & 0x00)
9590 case 0x00:
9591 goto op_semantics_63;
9592 break;
9594 break;
9595 case 0x1a:
9596 GETBYTE ();
9597 switch (op[2] & 0x00)
9599 case 0x00:
9600 goto op_semantics_63;
9601 break;
9603 break;
9604 case 0x1b:
9605 GETBYTE ();
9606 switch (op[2] & 0x00)
9608 case 0x00:
9609 goto op_semantics_63;
9610 break;
9612 break;
9613 case 0x1c:
9614 GETBYTE ();
9615 switch (op[2] & 0x00)
9617 case 0x00:
9618 op_semantics_64:
9620 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
9621 #line 698 "rx-decode.opc"
9622 int ss AU = op[1] & 0x03;
9623 #line 698 "rx-decode.opc"
9624 int rsrc AU = (op[2] >> 4) & 0x0f;
9625 #line 698 "rx-decode.opc"
9626 int rdst AU = op[2] & 0x0f;
9627 if (trace)
9629 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9630 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
9631 op[0], op[1], op[2]);
9632 printf (" ss = 0x%x,", ss);
9633 printf (" rsrc = 0x%x,", rsrc);
9634 printf (" rdst = 0x%x\n", rdst);
9636 SYNTAX("emulu %1%S1, %0");
9637 #line 698 "rx-decode.opc"
9638 ID(emulu); SP(ss, rsrc); DR(rdst);
9641 break;
9643 break;
9644 case 0x1d:
9645 GETBYTE ();
9646 switch (op[2] & 0x00)
9648 case 0x00:
9649 goto op_semantics_64;
9650 break;
9652 break;
9653 case 0x1e:
9654 GETBYTE ();
9655 switch (op[2] & 0x00)
9657 case 0x00:
9658 goto op_semantics_64;
9659 break;
9661 break;
9662 case 0x1f:
9663 GETBYTE ();
9664 switch (op[2] & 0x00)
9666 case 0x00:
9667 goto op_semantics_64;
9668 break;
9670 break;
9671 case 0x20:
9672 GETBYTE ();
9673 switch (op[2] & 0x00)
9675 case 0x00:
9676 op_semantics_65:
9678 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
9679 #line 710 "rx-decode.opc"
9680 int ss AU = op[1] & 0x03;
9681 #line 710 "rx-decode.opc"
9682 int rsrc AU = (op[2] >> 4) & 0x0f;
9683 #line 710 "rx-decode.opc"
9684 int rdst AU = op[2] & 0x0f;
9685 if (trace)
9687 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9688 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
9689 op[0], op[1], op[2]);
9690 printf (" ss = 0x%x,", ss);
9691 printf (" rsrc = 0x%x,", rsrc);
9692 printf (" rdst = 0x%x\n", rdst);
9694 SYNTAX("div %1%S1, %0");
9695 #line 710 "rx-decode.opc"
9696 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
9699 break;
9701 break;
9702 case 0x21:
9703 GETBYTE ();
9704 switch (op[2] & 0x00)
9706 case 0x00:
9707 goto op_semantics_65;
9708 break;
9710 break;
9711 case 0x22:
9712 GETBYTE ();
9713 switch (op[2] & 0x00)
9715 case 0x00:
9716 goto op_semantics_65;
9717 break;
9719 break;
9720 case 0x23:
9721 GETBYTE ();
9722 switch (op[2] & 0x00)
9724 case 0x00:
9725 goto op_semantics_65;
9726 break;
9728 break;
9729 case 0x24:
9730 GETBYTE ();
9731 switch (op[2] & 0x00)
9733 case 0x00:
9734 op_semantics_66:
9736 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
9737 #line 722 "rx-decode.opc"
9738 int ss AU = op[1] & 0x03;
9739 #line 722 "rx-decode.opc"
9740 int rsrc AU = (op[2] >> 4) & 0x0f;
9741 #line 722 "rx-decode.opc"
9742 int rdst AU = op[2] & 0x0f;
9743 if (trace)
9745 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9746 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
9747 op[0], op[1], op[2]);
9748 printf (" ss = 0x%x,", ss);
9749 printf (" rsrc = 0x%x,", rsrc);
9750 printf (" rdst = 0x%x\n", rdst);
9752 SYNTAX("divu %1%S1, %0");
9753 #line 722 "rx-decode.opc"
9754 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
9757 break;
9759 break;
9760 case 0x25:
9761 GETBYTE ();
9762 switch (op[2] & 0x00)
9764 case 0x00:
9765 goto op_semantics_66;
9766 break;
9768 break;
9769 case 0x26:
9770 GETBYTE ();
9771 switch (op[2] & 0x00)
9773 case 0x00:
9774 goto op_semantics_66;
9775 break;
9777 break;
9778 case 0x27:
9779 GETBYTE ();
9780 switch (op[2] & 0x00)
9782 case 0x00:
9783 goto op_semantics_66;
9784 break;
9786 break;
9787 case 0x30:
9788 GETBYTE ();
9789 switch (op[2] & 0x00)
9791 case 0x00:
9792 op_semantics_67:
9794 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
9795 #line 495 "rx-decode.opc"
9796 int ss AU = op[1] & 0x03;
9797 #line 495 "rx-decode.opc"
9798 int rsrc AU = (op[2] >> 4) & 0x0f;
9799 #line 495 "rx-decode.opc"
9800 int rdst AU = op[2] & 0x0f;
9801 if (trace)
9803 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9804 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
9805 op[0], op[1], op[2]);
9806 printf (" ss = 0x%x,", ss);
9807 printf (" rsrc = 0x%x,", rsrc);
9808 printf (" rdst = 0x%x\n", rdst);
9810 SYNTAX("tst %1%S1, %2");
9811 #line 495 "rx-decode.opc"
9812 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
9815 break;
9817 break;
9818 case 0x31:
9819 GETBYTE ();
9820 switch (op[2] & 0x00)
9822 case 0x00:
9823 goto op_semantics_67;
9824 break;
9826 break;
9827 case 0x32:
9828 GETBYTE ();
9829 switch (op[2] & 0x00)
9831 case 0x00:
9832 goto op_semantics_67;
9833 break;
9835 break;
9836 case 0x33:
9837 GETBYTE ();
9838 switch (op[2] & 0x00)
9840 case 0x00:
9841 goto op_semantics_67;
9842 break;
9844 break;
9845 case 0x34:
9846 GETBYTE ();
9847 switch (op[2] & 0x00)
9849 case 0x00:
9850 op_semantics_68:
9852 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
9853 #line 474 "rx-decode.opc"
9854 int ss AU = op[1] & 0x03;
9855 #line 474 "rx-decode.opc"
9856 int rsrc AU = (op[2] >> 4) & 0x0f;
9857 #line 474 "rx-decode.opc"
9858 int rdst AU = op[2] & 0x0f;
9859 if (trace)
9861 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9862 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
9863 op[0], op[1], op[2]);
9864 printf (" ss = 0x%x,", ss);
9865 printf (" rsrc = 0x%x,", rsrc);
9866 printf (" rdst = 0x%x\n", rdst);
9868 SYNTAX("xor %1%S1, %0");
9869 #line 474 "rx-decode.opc"
9870 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
9873 break;
9875 break;
9876 case 0x35:
9877 GETBYTE ();
9878 switch (op[2] & 0x00)
9880 case 0x00:
9881 goto op_semantics_68;
9882 break;
9884 break;
9885 case 0x36:
9886 GETBYTE ();
9887 switch (op[2] & 0x00)
9889 case 0x00:
9890 goto op_semantics_68;
9891 break;
9893 break;
9894 case 0x37:
9895 GETBYTE ();
9896 switch (op[2] & 0x00)
9898 case 0x00:
9899 goto op_semantics_68;
9900 break;
9902 break;
9903 case 0x3b:
9904 GETBYTE ();
9905 switch (op[2] & 0x00)
9907 case 0x00:
9909 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
9910 #line 486 "rx-decode.opc"
9911 int rsrc AU = (op[2] >> 4) & 0x0f;
9912 #line 486 "rx-decode.opc"
9913 int rdst AU = op[2] & 0x0f;
9914 if (trace)
9916 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9917 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
9918 op[0], op[1], op[2]);
9919 printf (" rsrc = 0x%x,", rsrc);
9920 printf (" rdst = 0x%x\n", rdst);
9922 SYNTAX("not %1, %0");
9923 #line 486 "rx-decode.opc"
9924 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
9926 /*----------------------------------------------------------------------*/
9927 /* TST */
9930 break;
9932 break;
9933 case 0x40:
9934 GETBYTE ();
9935 switch (op[2] & 0x00)
9937 case 0x00:
9938 op_semantics_69:
9940 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
9941 #line 408 "rx-decode.opc"
9942 int ss AU = op[1] & 0x03;
9943 #line 408 "rx-decode.opc"
9944 int rsrc AU = (op[2] >> 4) & 0x0f;
9945 #line 408 "rx-decode.opc"
9946 int rdst AU = op[2] & 0x0f;
9947 if (trace)
9949 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9950 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
9951 op[0], op[1], op[2]);
9952 printf (" ss = 0x%x,", ss);
9953 printf (" rsrc = 0x%x,", rsrc);
9954 printf (" rdst = 0x%x\n", rdst);
9956 SYNTAX("xchg %1%S1, %0");
9957 #line 408 "rx-decode.opc"
9958 ID(xchg); DR(rdst); SP(ss, rsrc);
9961 break;
9963 break;
9964 case 0x41:
9965 GETBYTE ();
9966 switch (op[2] & 0x00)
9968 case 0x00:
9969 goto op_semantics_69;
9970 break;
9972 break;
9973 case 0x42:
9974 GETBYTE ();
9975 switch (op[2] & 0x00)
9977 case 0x00:
9978 goto op_semantics_69;
9979 break;
9981 break;
9982 case 0x43:
9983 GETBYTE ();
9984 switch (op[2] & 0x00)
9986 case 0x00:
9987 goto op_semantics_69;
9988 break;
9990 break;
9991 case 0x44:
9992 GETBYTE ();
9993 switch (op[2] & 0x00)
9995 case 0x00:
9996 op_semantics_70:
9998 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
9999 #line 951 "rx-decode.opc"
10000 int sd AU = op[1] & 0x03;
10001 #line 951 "rx-decode.opc"
10002 int rsrc AU = (op[2] >> 4) & 0x0f;
10003 #line 951 "rx-decode.opc"
10004 int rdst AU = op[2] & 0x0f;
10005 if (trace)
10007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10008 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
10009 op[0], op[1], op[2]);
10010 printf (" sd = 0x%x,", sd);
10011 printf (" rsrc = 0x%x,", rsrc);
10012 printf (" rdst = 0x%x\n", rdst);
10014 SYNTAX("itof %1%S1, %0");
10015 #line 951 "rx-decode.opc"
10016 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
10019 break;
10021 break;
10022 case 0x45:
10023 GETBYTE ();
10024 switch (op[2] & 0x00)
10026 case 0x00:
10027 goto op_semantics_70;
10028 break;
10030 break;
10031 case 0x46:
10032 GETBYTE ();
10033 switch (op[2] & 0x00)
10035 case 0x00:
10036 goto op_semantics_70;
10037 break;
10039 break;
10040 case 0x47:
10041 GETBYTE ();
10042 switch (op[2] & 0x00)
10044 case 0x00:
10045 goto op_semantics_70;
10046 break;
10048 break;
10049 case 0x4b:
10050 GETBYTE ();
10051 switch (op[2] & 0x00)
10053 case 0x00:
10055 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
10056 #line 1077 "rx-decode.opc"
10057 int rsrc AU = (op[2] >> 4) & 0x0f;
10058 #line 1077 "rx-decode.opc"
10059 int rdst AU = op[2] & 0x0f;
10060 if (trace)
10062 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10063 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
10064 op[0], op[1], op[2]);
10065 printf (" rsrc = 0x%x,", rsrc);
10066 printf (" rdst = 0x%x\n", rdst);
10068 SYNTAX("stz %1, %0");
10069 #line 1077 "rx-decode.opc"
10070 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
10073 break;
10075 break;
10076 case 0x4f:
10077 GETBYTE ();
10078 switch (op[2] & 0x00)
10080 case 0x00:
10082 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
10083 #line 1080 "rx-decode.opc"
10084 int rsrc AU = (op[2] >> 4) & 0x0f;
10085 #line 1080 "rx-decode.opc"
10086 int rdst AU = op[2] & 0x0f;
10087 if (trace)
10089 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10090 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
10091 op[0], op[1], op[2]);
10092 printf (" rsrc = 0x%x,", rsrc);
10093 printf (" rdst = 0x%x\n", rdst);
10095 SYNTAX("stnz %1, %0");
10096 #line 1080 "rx-decode.opc"
10097 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
10100 break;
10102 break;
10103 case 0x54:
10104 GETBYTE ();
10105 switch (op[2] & 0x00)
10107 case 0x00:
10108 op_semantics_71:
10110 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
10111 #line 1137 "rx-decode.opc"
10112 int sd AU = op[1] & 0x03;
10113 #line 1137 "rx-decode.opc"
10114 int rsrc AU = (op[2] >> 4) & 0x0f;
10115 #line 1137 "rx-decode.opc"
10116 int rdst AU = op[2] & 0x0f;
10117 if (trace)
10119 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10120 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
10121 op[0], op[1], op[2]);
10122 printf (" sd = 0x%x,", sd);
10123 printf (" rsrc = 0x%x,", rsrc);
10124 printf (" rdst = 0x%x\n", rdst);
10126 SYNTAX("utof %1%S1, %0");
10127 #line 1137 "rx-decode.opc"
10128 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
10131 break;
10133 break;
10134 case 0x55:
10135 GETBYTE ();
10136 switch (op[2] & 0x00)
10138 case 0x00:
10139 goto op_semantics_71;
10140 break;
10142 break;
10143 case 0x56:
10144 GETBYTE ();
10145 switch (op[2] & 0x00)
10147 case 0x00:
10148 goto op_semantics_71;
10149 break;
10151 break;
10152 case 0x57:
10153 GETBYTE ();
10154 switch (op[2] & 0x00)
10156 case 0x00:
10157 goto op_semantics_71;
10158 break;
10160 break;
10161 case 0x5a:
10162 GETBYTE ();
10163 switch (op[2] & 0x00)
10165 case 0x00:
10167 /** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */
10168 #line 1152 "rx-decode.opc"
10169 int rsrc AU = (op[2] >> 4) & 0x0f;
10170 #line 1152 "rx-decode.opc"
10171 int rdst AU = op[2] & 0x0f;
10172 if (trace)
10174 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10175 "/** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */",
10176 op[0], op[1], op[2]);
10177 printf (" rsrc = 0x%x,", rsrc);
10178 printf (" rdst = 0x%x\n", rdst);
10180 SYNTAX("bfmovz %bf");
10181 #line 1152 "rx-decode.opc"
10182 ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10185 break;
10187 break;
10188 case 0x5e:
10189 GETBYTE ();
10190 switch (op[2] & 0x00)
10192 case 0x00:
10194 /** 1111 1100 0101 1110 rsrc rdst bfmov %bf */
10195 #line 1149 "rx-decode.opc"
10196 int rsrc AU = (op[2] >> 4) & 0x0f;
10197 #line 1149 "rx-decode.opc"
10198 int rdst AU = op[2] & 0x0f;
10199 if (trace)
10201 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10202 "/** 1111 1100 0101 1110 rsrc rdst bfmov %bf */",
10203 op[0], op[1], op[2]);
10204 printf (" rsrc = 0x%x,", rsrc);
10205 printf (" rdst = 0x%x\n", rdst);
10207 SYNTAX("bfmov %bf");
10208 #line 1149 "rx-decode.opc"
10209 ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10212 break;
10214 break;
10215 case 0x60:
10216 GETBYTE ();
10217 switch (op[2] & 0x00)
10219 case 0x00:
10220 op_semantics_72:
10222 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
10223 #line 963 "rx-decode.opc"
10224 int sd AU = op[1] & 0x03;
10225 #line 963 "rx-decode.opc"
10226 int rdst AU = (op[2] >> 4) & 0x0f;
10227 #line 963 "rx-decode.opc"
10228 int rsrc AU = op[2] & 0x0f;
10229 if (trace)
10231 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10232 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
10233 op[0], op[1], op[2]);
10234 printf (" sd = 0x%x,", sd);
10235 printf (" rdst = 0x%x,", rdst);
10236 printf (" rsrc = 0x%x\n", rsrc);
10238 SYNTAX("bset %1, %0%S0");
10239 #line 963 "rx-decode.opc"
10240 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10241 if (sd == 3) /* bset reg,reg */
10242 BWL(LSIZE);
10245 break;
10247 break;
10248 case 0x61:
10249 GETBYTE ();
10250 switch (op[2] & 0x00)
10252 case 0x00:
10253 goto op_semantics_72;
10254 break;
10256 break;
10257 case 0x62:
10258 GETBYTE ();
10259 switch (op[2] & 0x00)
10261 case 0x00:
10262 goto op_semantics_72;
10263 break;
10265 break;
10266 case 0x63:
10267 GETBYTE ();
10268 switch (op[2] & 0x00)
10270 case 0x00:
10271 goto op_semantics_72;
10272 break;
10274 break;
10275 case 0x64:
10276 GETBYTE ();
10277 switch (op[2] & 0x00)
10279 case 0x00:
10280 op_semantics_73:
10282 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
10283 #line 975 "rx-decode.opc"
10284 int sd AU = op[1] & 0x03;
10285 #line 975 "rx-decode.opc"
10286 int rdst AU = (op[2] >> 4) & 0x0f;
10287 #line 975 "rx-decode.opc"
10288 int rsrc AU = op[2] & 0x0f;
10289 if (trace)
10291 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10292 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
10293 op[0], op[1], op[2]);
10294 printf (" sd = 0x%x,", sd);
10295 printf (" rdst = 0x%x,", rdst);
10296 printf (" rsrc = 0x%x\n", rsrc);
10298 SYNTAX("bclr %1, %0%S0");
10299 #line 975 "rx-decode.opc"
10300 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10301 if (sd == 3) /* bset reg,reg */
10302 BWL(LSIZE);
10305 break;
10307 break;
10308 case 0x65:
10309 GETBYTE ();
10310 switch (op[2] & 0x00)
10312 case 0x00:
10313 goto op_semantics_73;
10314 break;
10316 break;
10317 case 0x66:
10318 GETBYTE ();
10319 switch (op[2] & 0x00)
10321 case 0x00:
10322 goto op_semantics_73;
10323 break;
10325 break;
10326 case 0x67:
10327 GETBYTE ();
10328 switch (op[2] & 0x00)
10330 case 0x00:
10331 goto op_semantics_73;
10332 break;
10334 break;
10335 case 0x68:
10336 GETBYTE ();
10337 switch (op[2] & 0x00)
10339 case 0x00:
10340 op_semantics_74:
10342 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
10343 #line 987 "rx-decode.opc"
10344 int sd AU = op[1] & 0x03;
10345 #line 987 "rx-decode.opc"
10346 int rdst AU = (op[2] >> 4) & 0x0f;
10347 #line 987 "rx-decode.opc"
10348 int rsrc AU = op[2] & 0x0f;
10349 if (trace)
10351 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10352 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
10353 op[0], op[1], op[2]);
10354 printf (" sd = 0x%x,", sd);
10355 printf (" rdst = 0x%x,", rdst);
10356 printf (" rsrc = 0x%x\n", rsrc);
10358 SYNTAX("btst %2, %1%S1");
10359 #line 987 "rx-decode.opc"
10360 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
10361 if (sd == 3) /* bset reg,reg */
10362 BWL(LSIZE);
10365 break;
10367 break;
10368 case 0x69:
10369 GETBYTE ();
10370 switch (op[2] & 0x00)
10372 case 0x00:
10373 goto op_semantics_74;
10374 break;
10376 break;
10377 case 0x6a:
10378 GETBYTE ();
10379 switch (op[2] & 0x00)
10381 case 0x00:
10382 goto op_semantics_74;
10383 break;
10385 break;
10386 case 0x6b:
10387 GETBYTE ();
10388 switch (op[2] & 0x00)
10390 case 0x00:
10391 goto op_semantics_74;
10392 break;
10394 break;
10395 case 0x6c:
10396 GETBYTE ();
10397 switch (op[2] & 0x00)
10399 case 0x00:
10400 op_semantics_75:
10402 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
10403 #line 999 "rx-decode.opc"
10404 int sd AU = op[1] & 0x03;
10405 #line 999 "rx-decode.opc"
10406 int rdst AU = (op[2] >> 4) & 0x0f;
10407 #line 999 "rx-decode.opc"
10408 int rsrc AU = op[2] & 0x0f;
10409 if (trace)
10411 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10412 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
10413 op[0], op[1], op[2]);
10414 printf (" sd = 0x%x,", sd);
10415 printf (" rdst = 0x%x,", rdst);
10416 printf (" rsrc = 0x%x\n", rsrc);
10418 SYNTAX("bnot %1, %0%S0");
10419 #line 999 "rx-decode.opc"
10420 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
10421 if (sd == 3) /* bset reg,reg */
10422 BWL(LSIZE);
10425 break;
10427 break;
10428 case 0x6d:
10429 GETBYTE ();
10430 switch (op[2] & 0x00)
10432 case 0x00:
10433 goto op_semantics_75;
10434 break;
10436 break;
10437 case 0x6e:
10438 GETBYTE ();
10439 switch (op[2] & 0x00)
10441 case 0x00:
10442 goto op_semantics_75;
10443 break;
10445 break;
10446 case 0x6f:
10447 GETBYTE ();
10448 switch (op[2] & 0x00)
10450 case 0x00:
10451 goto op_semantics_75;
10452 break;
10454 break;
10455 case 0x78:
10456 GETBYTE ();
10457 switch (op[2] & 0x0f)
10459 case 0x08:
10460 op_semantics_76:
10462 /** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */
10463 #line 1185 "rx-decode.opc"
10464 int sz AU = op[1] & 0x03;
10465 #line 1185 "rx-decode.opc"
10466 int rdst AU = (op[2] >> 4) & 0x0f;
10467 if (trace)
10469 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10470 "/** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */",
10471 op[0], op[1], op[2]);
10472 printf (" sz = 0x%x,", sz);
10473 printf (" rdst = 0x%x\n", rdst);
10475 SYNTAX("dmov.d %1, %0");
10476 #line 1185 "rx-decode.opc"
10477 int rsrc;
10478 rx_disp(0, sz, rdst, RX_Double, ld);
10479 rsrc = GETBYTE();
10480 if (rsrc & 0x0f)
10481 UNSUPPORTED();
10482 else {
10483 ID(dmov); SDR(rsrc >> 4); F_____;
10487 break;
10488 default: UNSUPPORTED(); break;
10490 break;
10491 case 0x79:
10492 GETBYTE ();
10493 switch (op[2] & 0x0f)
10495 case 0x08:
10496 goto op_semantics_76;
10497 break;
10498 default: UNSUPPORTED(); break;
10500 break;
10501 case 0x7a:
10502 GETBYTE ();
10503 switch (op[2] & 0x0f)
10505 case 0x08:
10506 goto op_semantics_76;
10507 break;
10508 default: UNSUPPORTED(); break;
10510 break;
10511 case 0x80:
10512 GETBYTE ();
10513 switch (op[2] & 0x00)
10515 case 0x00:
10516 op_semantics_77:
10518 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
10519 #line 930 "rx-decode.opc"
10520 int sd AU = op[1] & 0x03;
10521 #line 930 "rx-decode.opc"
10522 int rsrc AU = (op[2] >> 4) & 0x0f;
10523 #line 930 "rx-decode.opc"
10524 int rdst AU = op[2] & 0x0f;
10525 if (trace)
10527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10528 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
10529 op[0], op[1], op[2]);
10530 printf (" sd = 0x%x,", sd);
10531 printf (" rsrc = 0x%x,", rsrc);
10532 printf (" rdst = 0x%x\n", rdst);
10534 SYNTAX("fsub %1%S1, %0");
10535 #line 930 "rx-decode.opc"
10536 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10539 break;
10541 break;
10542 case 0x81:
10543 GETBYTE ();
10544 switch (op[2] & 0x00)
10546 case 0x00:
10547 goto op_semantics_77;
10548 break;
10550 break;
10551 case 0x82:
10552 GETBYTE ();
10553 switch (op[2] & 0x00)
10555 case 0x00:
10556 goto op_semantics_77;
10557 break;
10559 break;
10560 case 0x83:
10561 GETBYTE ();
10562 switch (op[2] & 0x00)
10564 case 0x00:
10565 goto op_semantics_77;
10566 break;
10568 break;
10569 case 0x84:
10570 GETBYTE ();
10571 switch (op[2] & 0x00)
10573 case 0x00:
10574 op_semantics_78:
10576 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
10577 #line 924 "rx-decode.opc"
10578 int sd AU = op[1] & 0x03;
10579 #line 924 "rx-decode.opc"
10580 int rsrc AU = (op[2] >> 4) & 0x0f;
10581 #line 924 "rx-decode.opc"
10582 int rdst AU = op[2] & 0x0f;
10583 if (trace)
10585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10586 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
10587 op[0], op[1], op[2]);
10588 printf (" sd = 0x%x,", sd);
10589 printf (" rsrc = 0x%x,", rsrc);
10590 printf (" rdst = 0x%x\n", rdst);
10592 SYNTAX("fcmp %1%S1, %0");
10593 #line 924 "rx-decode.opc"
10594 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
10597 break;
10599 break;
10600 case 0x85:
10601 GETBYTE ();
10602 switch (op[2] & 0x00)
10604 case 0x00:
10605 goto op_semantics_78;
10606 break;
10608 break;
10609 case 0x86:
10610 GETBYTE ();
10611 switch (op[2] & 0x00)
10613 case 0x00:
10614 goto op_semantics_78;
10615 break;
10617 break;
10618 case 0x87:
10619 GETBYTE ();
10620 switch (op[2] & 0x00)
10622 case 0x00:
10623 goto op_semantics_78;
10624 break;
10626 break;
10627 case 0x88:
10628 GETBYTE ();
10629 switch (op[2] & 0x00)
10631 case 0x00:
10632 op_semantics_79:
10634 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
10635 #line 918 "rx-decode.opc"
10636 int sd AU = op[1] & 0x03;
10637 #line 918 "rx-decode.opc"
10638 int rsrc AU = (op[2] >> 4) & 0x0f;
10639 #line 918 "rx-decode.opc"
10640 int rdst AU = op[2] & 0x0f;
10641 if (trace)
10643 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10644 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
10645 op[0], op[1], op[2]);
10646 printf (" sd = 0x%x,", sd);
10647 printf (" rsrc = 0x%x,", rsrc);
10648 printf (" rdst = 0x%x\n", rdst);
10650 SYNTAX("fadd %1%S1, %0");
10651 #line 918 "rx-decode.opc"
10652 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10655 break;
10657 break;
10658 case 0x89:
10659 GETBYTE ();
10660 switch (op[2] & 0x00)
10662 case 0x00:
10663 goto op_semantics_79;
10664 break;
10666 break;
10667 case 0x8a:
10668 GETBYTE ();
10669 switch (op[2] & 0x00)
10671 case 0x00:
10672 goto op_semantics_79;
10673 break;
10675 break;
10676 case 0x8b:
10677 GETBYTE ();
10678 switch (op[2] & 0x00)
10680 case 0x00:
10681 goto op_semantics_79;
10682 break;
10684 break;
10685 case 0x8c:
10686 GETBYTE ();
10687 switch (op[2] & 0x00)
10689 case 0x00:
10690 op_semantics_80:
10692 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
10693 #line 939 "rx-decode.opc"
10694 int sd AU = op[1] & 0x03;
10695 #line 939 "rx-decode.opc"
10696 int rsrc AU = (op[2] >> 4) & 0x0f;
10697 #line 939 "rx-decode.opc"
10698 int rdst AU = op[2] & 0x0f;
10699 if (trace)
10701 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10702 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
10703 op[0], op[1], op[2]);
10704 printf (" sd = 0x%x,", sd);
10705 printf (" rsrc = 0x%x,", rsrc);
10706 printf (" rdst = 0x%x\n", rdst);
10708 SYNTAX("fmul %1%S1, %0");
10709 #line 939 "rx-decode.opc"
10710 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10713 break;
10715 break;
10716 case 0x8d:
10717 GETBYTE ();
10718 switch (op[2] & 0x00)
10720 case 0x00:
10721 goto op_semantics_80;
10722 break;
10724 break;
10725 case 0x8e:
10726 GETBYTE ();
10727 switch (op[2] & 0x00)
10729 case 0x00:
10730 goto op_semantics_80;
10731 break;
10733 break;
10734 case 0x8f:
10735 GETBYTE ();
10736 switch (op[2] & 0x00)
10738 case 0x00:
10739 goto op_semantics_80;
10740 break;
10742 break;
10743 case 0x90:
10744 GETBYTE ();
10745 switch (op[2] & 0x00)
10747 case 0x00:
10748 op_semantics_81:
10750 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
10751 #line 945 "rx-decode.opc"
10752 int sd AU = op[1] & 0x03;
10753 #line 945 "rx-decode.opc"
10754 int rsrc AU = (op[2] >> 4) & 0x0f;
10755 #line 945 "rx-decode.opc"
10756 int rdst AU = op[2] & 0x0f;
10757 if (trace)
10759 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10760 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
10761 op[0], op[1], op[2]);
10762 printf (" sd = 0x%x,", sd);
10763 printf (" rsrc = 0x%x,", rsrc);
10764 printf (" rdst = 0x%x\n", rdst);
10766 SYNTAX("fdiv %1%S1, %0");
10767 #line 945 "rx-decode.opc"
10768 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10771 break;
10773 break;
10774 case 0x91:
10775 GETBYTE ();
10776 switch (op[2] & 0x00)
10778 case 0x00:
10779 goto op_semantics_81;
10780 break;
10782 break;
10783 case 0x92:
10784 GETBYTE ();
10785 switch (op[2] & 0x00)
10787 case 0x00:
10788 goto op_semantics_81;
10789 break;
10791 break;
10792 case 0x93:
10793 GETBYTE ();
10794 switch (op[2] & 0x00)
10796 case 0x00:
10797 goto op_semantics_81;
10798 break;
10800 break;
10801 case 0x94:
10802 GETBYTE ();
10803 switch (op[2] & 0x00)
10805 case 0x00:
10806 op_semantics_82:
10808 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
10809 #line 933 "rx-decode.opc"
10810 int sd AU = op[1] & 0x03;
10811 #line 933 "rx-decode.opc"
10812 int rsrc AU = (op[2] >> 4) & 0x0f;
10813 #line 933 "rx-decode.opc"
10814 int rdst AU = op[2] & 0x0f;
10815 if (trace)
10817 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10818 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
10819 op[0], op[1], op[2]);
10820 printf (" sd = 0x%x,", sd);
10821 printf (" rsrc = 0x%x,", rsrc);
10822 printf (" rdst = 0x%x\n", rdst);
10824 SYNTAX("ftoi %1%S1, %0");
10825 #line 933 "rx-decode.opc"
10826 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10829 break;
10831 break;
10832 case 0x95:
10833 GETBYTE ();
10834 switch (op[2] & 0x00)
10836 case 0x00:
10837 goto op_semantics_82;
10838 break;
10840 break;
10841 case 0x96:
10842 GETBYTE ();
10843 switch (op[2] & 0x00)
10845 case 0x00:
10846 goto op_semantics_82;
10847 break;
10849 break;
10850 case 0x97:
10851 GETBYTE ();
10852 switch (op[2] & 0x00)
10854 case 0x00:
10855 goto op_semantics_82;
10856 break;
10858 break;
10859 case 0x98:
10860 GETBYTE ();
10861 switch (op[2] & 0x00)
10863 case 0x00:
10864 op_semantics_83:
10866 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
10867 #line 948 "rx-decode.opc"
10868 int sd AU = op[1] & 0x03;
10869 #line 948 "rx-decode.opc"
10870 int rsrc AU = (op[2] >> 4) & 0x0f;
10871 #line 948 "rx-decode.opc"
10872 int rdst AU = op[2] & 0x0f;
10873 if (trace)
10875 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10876 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
10877 op[0], op[1], op[2]);
10878 printf (" sd = 0x%x,", sd);
10879 printf (" rsrc = 0x%x,", rsrc);
10880 printf (" rdst = 0x%x\n", rdst);
10882 SYNTAX("round %1%S1, %0");
10883 #line 948 "rx-decode.opc"
10884 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10887 break;
10889 break;
10890 case 0x99:
10891 GETBYTE ();
10892 switch (op[2] & 0x00)
10894 case 0x00:
10895 goto op_semantics_83;
10896 break;
10898 break;
10899 case 0x9a:
10900 GETBYTE ();
10901 switch (op[2] & 0x00)
10903 case 0x00:
10904 goto op_semantics_83;
10905 break;
10907 break;
10908 case 0x9b:
10909 GETBYTE ();
10910 switch (op[2] & 0x00)
10912 case 0x00:
10913 goto op_semantics_83;
10914 break;
10916 break;
10917 case 0xa0:
10918 GETBYTE ();
10919 switch (op[2] & 0x00)
10921 case 0x00:
10922 op_semantics_84:
10924 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
10925 #line 1131 "rx-decode.opc"
10926 int sd AU = op[1] & 0x03;
10927 #line 1131 "rx-decode.opc"
10928 int rsrc AU = (op[2] >> 4) & 0x0f;
10929 #line 1131 "rx-decode.opc"
10930 int rdst AU = op[2] & 0x0f;
10931 if (trace)
10933 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10934 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
10935 op[0], op[1], op[2]);
10936 printf (" sd = 0x%x,", sd);
10937 printf (" rsrc = 0x%x,", rsrc);
10938 printf (" rdst = 0x%x\n", rdst);
10940 SYNTAX("fsqrt %1%S1, %0");
10941 #line 1131 "rx-decode.opc"
10942 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10945 break;
10947 break;
10948 case 0xa1:
10949 GETBYTE ();
10950 switch (op[2] & 0x00)
10952 case 0x00:
10953 goto op_semantics_84;
10954 break;
10956 break;
10957 case 0xa2:
10958 GETBYTE ();
10959 switch (op[2] & 0x00)
10961 case 0x00:
10962 goto op_semantics_84;
10963 break;
10965 break;
10966 case 0xa3:
10967 GETBYTE ();
10968 switch (op[2] & 0x00)
10970 case 0x00:
10971 goto op_semantics_84;
10972 break;
10974 break;
10975 case 0xa4:
10976 GETBYTE ();
10977 switch (op[2] & 0x00)
10979 case 0x00:
10980 op_semantics_85:
10982 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
10983 #line 1134 "rx-decode.opc"
10984 int sd AU = op[1] & 0x03;
10985 #line 1134 "rx-decode.opc"
10986 int rsrc AU = (op[2] >> 4) & 0x0f;
10987 #line 1134 "rx-decode.opc"
10988 int rdst AU = op[2] & 0x0f;
10989 if (trace)
10991 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10992 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
10993 op[0], op[1], op[2]);
10994 printf (" sd = 0x%x,", sd);
10995 printf (" rsrc = 0x%x,", rsrc);
10996 printf (" rdst = 0x%x\n", rdst);
10998 SYNTAX("ftou %1%S1, %0");
10999 #line 1134 "rx-decode.opc"
11000 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
11003 break;
11005 break;
11006 case 0xa5:
11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11010 case 0x00:
11011 goto op_semantics_85;
11012 break;
11014 break;
11015 case 0xa6:
11016 GETBYTE ();
11017 switch (op[2] & 0x00)
11019 case 0x00:
11020 goto op_semantics_85;
11021 break;
11023 break;
11024 case 0xa7:
11025 GETBYTE ();
11026 switch (op[2] & 0x00)
11028 case 0x00:
11029 goto op_semantics_85;
11030 break;
11032 break;
11033 case 0xc8:
11034 GETBYTE ();
11035 switch (op[2] & 0x0f)
11037 case 0x08:
11038 op_semantics_86:
11040 /** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */
11041 #line 1198 "rx-decode.opc"
11042 int sz AU = op[1] & 0x03;
11043 #line 1198 "rx-decode.opc"
11044 int rsrc AU = (op[2] >> 4) & 0x0f;
11045 if (trace)
11047 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11048 "/** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */",
11049 op[0], op[1], op[2]);
11050 printf (" sz = 0x%x,", sz);
11051 printf (" rsrc = 0x%x\n", rsrc);
11053 SYNTAX("dmov.d %1, %0");
11054 #line 1198 "rx-decode.opc"
11055 int rdst;
11056 rx_disp(1, sz, rsrc, RX_Double, ld);
11057 rdst = GETBYTE();
11058 if (rdst & 0x0f)
11059 UNSUPPORTED();
11060 else {
11061 ID(dmov); DDR(rdst >> 4); F_____;
11065 break;
11066 default: UNSUPPORTED(); break;
11068 break;
11069 case 0xc9:
11070 GETBYTE ();
11071 switch (op[2] & 0x0f)
11073 case 0x08:
11074 goto op_semantics_86;
11075 break;
11076 default: UNSUPPORTED(); break;
11078 break;
11079 case 0xca:
11080 GETBYTE ();
11081 switch (op[2] & 0x0f)
11083 case 0x08:
11084 goto op_semantics_86;
11085 break;
11086 default: UNSUPPORTED(); break;
11088 break;
11089 case 0xd0:
11090 GETBYTE ();
11091 switch (op[2] & 0x00)
11093 case 0x00:
11094 op_semantics_87:
11096 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
11097 #line 1065 "rx-decode.opc"
11098 int sz AU = (op[1] >> 2) & 0x03;
11099 #line 1065 "rx-decode.opc"
11100 int sd AU = op[1] & 0x03;
11101 #line 1065 "rx-decode.opc"
11102 int rdst AU = (op[2] >> 4) & 0x0f;
11103 #line 1065 "rx-decode.opc"
11104 int cond AU = op[2] & 0x0f;
11105 if (trace)
11107 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11108 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
11109 op[0], op[1], op[2]);
11110 printf (" sz = 0x%x,", sz);
11111 printf (" sd = 0x%x,", sd);
11112 printf (" rdst = 0x%x,", rdst);
11113 printf (" cond = 0x%x\n", cond);
11115 SYNTAX("sc%1%s %0");
11116 #line 1065 "rx-decode.opc"
11117 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
11119 /*----------------------------------------------------------------------*/
11120 /* RXv2 enhanced */
11123 break;
11125 break;
11126 case 0xd1:
11127 GETBYTE ();
11128 switch (op[2] & 0x00)
11130 case 0x00:
11131 goto op_semantics_87;
11132 break;
11134 break;
11135 case 0xd2:
11136 GETBYTE ();
11137 switch (op[2] & 0x00)
11139 case 0x00:
11140 goto op_semantics_87;
11141 break;
11143 break;
11144 case 0xd3:
11145 GETBYTE ();
11146 switch (op[2] & 0x00)
11148 case 0x00:
11149 goto op_semantics_87;
11150 break;
11152 break;
11153 case 0xd4:
11154 GETBYTE ();
11155 switch (op[2] & 0x00)
11157 case 0x00:
11158 goto op_semantics_87;
11159 break;
11161 break;
11162 case 0xd5:
11163 GETBYTE ();
11164 switch (op[2] & 0x00)
11166 case 0x00:
11167 goto op_semantics_87;
11168 break;
11170 break;
11171 case 0xd6:
11172 GETBYTE ();
11173 switch (op[2] & 0x00)
11175 case 0x00:
11176 goto op_semantics_87;
11177 break;
11179 break;
11180 case 0xd7:
11181 GETBYTE ();
11182 switch (op[2] & 0x00)
11184 case 0x00:
11185 goto op_semantics_87;
11186 break;
11188 break;
11189 case 0xd8:
11190 GETBYTE ();
11191 switch (op[2] & 0x00)
11193 case 0x00:
11194 goto op_semantics_87;
11195 break;
11197 break;
11198 case 0xd9:
11199 GETBYTE ();
11200 switch (op[2] & 0x00)
11202 case 0x00:
11203 goto op_semantics_87;
11204 break;
11206 break;
11207 case 0xda:
11208 GETBYTE ();
11209 switch (op[2] & 0x00)
11211 case 0x00:
11212 goto op_semantics_87;
11213 break;
11215 break;
11216 case 0xdb:
11217 GETBYTE ();
11218 switch (op[2] & 0x00)
11220 case 0x00:
11221 goto op_semantics_87;
11222 break;
11224 break;
11225 case 0xe0:
11226 GETBYTE ();
11227 switch (op[2] & 0x0f)
11229 case 0x00:
11230 case 0x01:
11231 case 0x02:
11232 case 0x03:
11233 case 0x04:
11234 case 0x05:
11235 case 0x06:
11236 case 0x07:
11237 case 0x08:
11238 case 0x09:
11239 case 0x0a:
11240 case 0x0b:
11241 case 0x0c:
11242 case 0x0d:
11243 case 0x0e:
11244 op_semantics_88:
11246 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
11247 #line 1008 "rx-decode.opc"
11248 int bit AU = (op[1] >> 2) & 0x07;
11249 #line 1008 "rx-decode.opc"
11250 int sd AU = op[1] & 0x03;
11251 #line 1008 "rx-decode.opc"
11252 int rdst AU = (op[2] >> 4) & 0x0f;
11253 #line 1008 "rx-decode.opc"
11254 int cond AU = op[2] & 0x0f;
11255 if (trace)
11257 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11258 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
11259 op[0], op[1], op[2]);
11260 printf (" bit = 0x%x,", bit);
11261 printf (" sd = 0x%x,", sd);
11262 printf (" rdst = 0x%x,", rdst);
11263 printf (" cond = 0x%x\n", cond);
11265 SYNTAX("bm%2 #%1, %0%S0");
11266 #line 1008 "rx-decode.opc"
11267 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
11270 break;
11271 case 0x0f:
11272 op_semantics_89:
11274 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
11275 #line 996 "rx-decode.opc"
11276 int bit AU = (op[1] >> 2) & 0x07;
11277 #line 996 "rx-decode.opc"
11278 int sd AU = op[1] & 0x03;
11279 #line 996 "rx-decode.opc"
11280 int rdst AU = (op[2] >> 4) & 0x0f;
11281 if (trace)
11283 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11284 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
11285 op[0], op[1], op[2]);
11286 printf (" bit = 0x%x,", bit);
11287 printf (" sd = 0x%x,", sd);
11288 printf (" rdst = 0x%x\n", rdst);
11290 SYNTAX("bnot #%1, %0%S0");
11291 #line 996 "rx-decode.opc"
11292 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
11295 break;
11297 break;
11298 case 0xe1:
11299 GETBYTE ();
11300 switch (op[2] & 0x0f)
11302 case 0x00:
11303 case 0x01:
11304 case 0x02:
11305 case 0x03:
11306 case 0x04:
11307 case 0x05:
11308 case 0x06:
11309 case 0x07:
11310 case 0x08:
11311 case 0x09:
11312 case 0x0a:
11313 case 0x0b:
11314 case 0x0c:
11315 case 0x0d:
11316 case 0x0e:
11317 goto op_semantics_88;
11318 break;
11319 case 0x0f:
11320 goto op_semantics_89;
11321 break;
11323 break;
11324 case 0xe2:
11325 GETBYTE ();
11326 switch (op[2] & 0x0f)
11328 case 0x00:
11329 case 0x01:
11330 case 0x02:
11331 case 0x03:
11332 case 0x04:
11333 case 0x05:
11334 case 0x06:
11335 case 0x07:
11336 case 0x08:
11337 case 0x09:
11338 case 0x0a:
11339 case 0x0b:
11340 case 0x0c:
11341 case 0x0d:
11342 case 0x0e:
11343 goto op_semantics_88;
11344 break;
11345 case 0x0f:
11346 goto op_semantics_89;
11347 break;
11349 break;
11350 case 0xe3:
11351 GETBYTE ();
11352 switch (op[2] & 0x0f)
11354 case 0x00:
11355 case 0x01:
11356 case 0x02:
11357 case 0x03:
11358 case 0x04:
11359 case 0x05:
11360 case 0x06:
11361 case 0x07:
11362 case 0x08:
11363 case 0x09:
11364 case 0x0a:
11365 case 0x0b:
11366 case 0x0c:
11367 case 0x0d:
11368 case 0x0e:
11369 goto op_semantics_88;
11370 break;
11371 case 0x0f:
11372 goto op_semantics_89;
11373 break;
11375 break;
11376 case 0xe4:
11377 GETBYTE ();
11378 switch (op[2] & 0x0f)
11380 case 0x00:
11381 case 0x01:
11382 case 0x02:
11383 case 0x03:
11384 case 0x04:
11385 case 0x05:
11386 case 0x06:
11387 case 0x07:
11388 case 0x08:
11389 case 0x09:
11390 case 0x0a:
11391 case 0x0b:
11392 case 0x0c:
11393 case 0x0d:
11394 case 0x0e:
11395 goto op_semantics_88;
11396 break;
11397 case 0x0f:
11398 goto op_semantics_89;
11399 break;
11401 break;
11402 case 0xe5:
11403 GETBYTE ();
11404 switch (op[2] & 0x0f)
11406 case 0x00:
11407 case 0x01:
11408 case 0x02:
11409 case 0x03:
11410 case 0x04:
11411 case 0x05:
11412 case 0x06:
11413 case 0x07:
11414 case 0x08:
11415 case 0x09:
11416 case 0x0a:
11417 case 0x0b:
11418 case 0x0c:
11419 case 0x0d:
11420 case 0x0e:
11421 goto op_semantics_88;
11422 break;
11423 case 0x0f:
11424 goto op_semantics_89;
11425 break;
11427 break;
11428 case 0xe6:
11429 GETBYTE ();
11430 switch (op[2] & 0x0f)
11432 case 0x00:
11433 case 0x01:
11434 case 0x02:
11435 case 0x03:
11436 case 0x04:
11437 case 0x05:
11438 case 0x06:
11439 case 0x07:
11440 case 0x08:
11441 case 0x09:
11442 case 0x0a:
11443 case 0x0b:
11444 case 0x0c:
11445 case 0x0d:
11446 case 0x0e:
11447 goto op_semantics_88;
11448 break;
11449 case 0x0f:
11450 goto op_semantics_89;
11451 break;
11453 break;
11454 case 0xe7:
11455 GETBYTE ();
11456 switch (op[2] & 0x0f)
11458 case 0x00:
11459 case 0x01:
11460 case 0x02:
11461 case 0x03:
11462 case 0x04:
11463 case 0x05:
11464 case 0x06:
11465 case 0x07:
11466 case 0x08:
11467 case 0x09:
11468 case 0x0a:
11469 case 0x0b:
11470 case 0x0c:
11471 case 0x0d:
11472 case 0x0e:
11473 goto op_semantics_88;
11474 break;
11475 case 0x0f:
11476 goto op_semantics_89;
11477 break;
11479 break;
11480 case 0xe8:
11481 GETBYTE ();
11482 switch (op[2] & 0x0f)
11484 case 0x00:
11485 case 0x01:
11486 case 0x02:
11487 case 0x03:
11488 case 0x04:
11489 case 0x05:
11490 case 0x06:
11491 case 0x07:
11492 case 0x08:
11493 case 0x09:
11494 case 0x0a:
11495 case 0x0b:
11496 case 0x0c:
11497 case 0x0d:
11498 case 0x0e:
11499 goto op_semantics_88;
11500 break;
11501 case 0x0f:
11502 goto op_semantics_89;
11503 break;
11505 break;
11506 case 0xe9:
11507 GETBYTE ();
11508 switch (op[2] & 0x0f)
11510 case 0x00:
11511 case 0x01:
11512 case 0x02:
11513 case 0x03:
11514 case 0x04:
11515 case 0x05:
11516 case 0x06:
11517 case 0x07:
11518 case 0x08:
11519 case 0x09:
11520 case 0x0a:
11521 case 0x0b:
11522 case 0x0c:
11523 case 0x0d:
11524 case 0x0e:
11525 goto op_semantics_88;
11526 break;
11527 case 0x0f:
11528 goto op_semantics_89;
11529 break;
11531 break;
11532 case 0xea:
11533 GETBYTE ();
11534 switch (op[2] & 0x0f)
11536 case 0x00:
11537 case 0x01:
11538 case 0x02:
11539 case 0x03:
11540 case 0x04:
11541 case 0x05:
11542 case 0x06:
11543 case 0x07:
11544 case 0x08:
11545 case 0x09:
11546 case 0x0a:
11547 case 0x0b:
11548 case 0x0c:
11549 case 0x0d:
11550 case 0x0e:
11551 goto op_semantics_88;
11552 break;
11553 case 0x0f:
11554 goto op_semantics_89;
11555 break;
11557 break;
11558 case 0xeb:
11559 GETBYTE ();
11560 switch (op[2] & 0x0f)
11562 case 0x00:
11563 case 0x01:
11564 case 0x02:
11565 case 0x03:
11566 case 0x04:
11567 case 0x05:
11568 case 0x06:
11569 case 0x07:
11570 case 0x08:
11571 case 0x09:
11572 case 0x0a:
11573 case 0x0b:
11574 case 0x0c:
11575 case 0x0d:
11576 case 0x0e:
11577 goto op_semantics_88;
11578 break;
11579 case 0x0f:
11580 goto op_semantics_89;
11581 break;
11583 break;
11584 case 0xec:
11585 GETBYTE ();
11586 switch (op[2] & 0x0f)
11588 case 0x00:
11589 case 0x01:
11590 case 0x02:
11591 case 0x03:
11592 case 0x04:
11593 case 0x05:
11594 case 0x06:
11595 case 0x07:
11596 case 0x08:
11597 case 0x09:
11598 case 0x0a:
11599 case 0x0b:
11600 case 0x0c:
11601 case 0x0d:
11602 case 0x0e:
11603 goto op_semantics_88;
11604 break;
11605 case 0x0f:
11606 goto op_semantics_89;
11607 break;
11609 break;
11610 case 0xed:
11611 GETBYTE ();
11612 switch (op[2] & 0x0f)
11614 case 0x00:
11615 case 0x01:
11616 case 0x02:
11617 case 0x03:
11618 case 0x04:
11619 case 0x05:
11620 case 0x06:
11621 case 0x07:
11622 case 0x08:
11623 case 0x09:
11624 case 0x0a:
11625 case 0x0b:
11626 case 0x0c:
11627 case 0x0d:
11628 case 0x0e:
11629 goto op_semantics_88;
11630 break;
11631 case 0x0f:
11632 goto op_semantics_89;
11633 break;
11635 break;
11636 case 0xee:
11637 GETBYTE ();
11638 switch (op[2] & 0x0f)
11640 case 0x00:
11641 case 0x01:
11642 case 0x02:
11643 case 0x03:
11644 case 0x04:
11645 case 0x05:
11646 case 0x06:
11647 case 0x07:
11648 case 0x08:
11649 case 0x09:
11650 case 0x0a:
11651 case 0x0b:
11652 case 0x0c:
11653 case 0x0d:
11654 case 0x0e:
11655 goto op_semantics_88;
11656 break;
11657 case 0x0f:
11658 goto op_semantics_89;
11659 break;
11661 break;
11662 case 0xef:
11663 GETBYTE ();
11664 switch (op[2] & 0x0f)
11666 case 0x00:
11667 case 0x01:
11668 case 0x02:
11669 case 0x03:
11670 case 0x04:
11671 case 0x05:
11672 case 0x06:
11673 case 0x07:
11674 case 0x08:
11675 case 0x09:
11676 case 0x0a:
11677 case 0x0b:
11678 case 0x0c:
11679 case 0x0d:
11680 case 0x0e:
11681 goto op_semantics_88;
11682 break;
11683 case 0x0f:
11684 goto op_semantics_89;
11685 break;
11687 break;
11688 case 0xf0:
11689 GETBYTE ();
11690 switch (op[2] & 0x0f)
11692 case 0x00:
11693 case 0x01:
11694 case 0x02:
11695 case 0x03:
11696 case 0x04:
11697 case 0x05:
11698 case 0x06:
11699 case 0x07:
11700 case 0x08:
11701 case 0x09:
11702 case 0x0a:
11703 case 0x0b:
11704 case 0x0c:
11705 case 0x0d:
11706 case 0x0e:
11707 goto op_semantics_88;
11708 break;
11709 case 0x0f:
11710 goto op_semantics_89;
11711 break;
11713 break;
11714 case 0xf1:
11715 GETBYTE ();
11716 switch (op[2] & 0x0f)
11718 case 0x00:
11719 case 0x01:
11720 case 0x02:
11721 case 0x03:
11722 case 0x04:
11723 case 0x05:
11724 case 0x06:
11725 case 0x07:
11726 case 0x08:
11727 case 0x09:
11728 case 0x0a:
11729 case 0x0b:
11730 case 0x0c:
11731 case 0x0d:
11732 case 0x0e:
11733 goto op_semantics_88;
11734 break;
11735 case 0x0f:
11736 goto op_semantics_89;
11737 break;
11739 break;
11740 case 0xf2:
11741 GETBYTE ();
11742 switch (op[2] & 0x0f)
11744 case 0x00:
11745 case 0x01:
11746 case 0x02:
11747 case 0x03:
11748 case 0x04:
11749 case 0x05:
11750 case 0x06:
11751 case 0x07:
11752 case 0x08:
11753 case 0x09:
11754 case 0x0a:
11755 case 0x0b:
11756 case 0x0c:
11757 case 0x0d:
11758 case 0x0e:
11759 goto op_semantics_88;
11760 break;
11761 case 0x0f:
11762 goto op_semantics_89;
11763 break;
11765 break;
11766 case 0xf3:
11767 GETBYTE ();
11768 switch (op[2] & 0x0f)
11770 case 0x00:
11771 case 0x01:
11772 case 0x02:
11773 case 0x03:
11774 case 0x04:
11775 case 0x05:
11776 case 0x06:
11777 case 0x07:
11778 case 0x08:
11779 case 0x09:
11780 case 0x0a:
11781 case 0x0b:
11782 case 0x0c:
11783 case 0x0d:
11784 case 0x0e:
11785 goto op_semantics_88;
11786 break;
11787 case 0x0f:
11788 goto op_semantics_89;
11789 break;
11791 break;
11792 case 0xf4:
11793 GETBYTE ();
11794 switch (op[2] & 0x0f)
11796 case 0x00:
11797 case 0x01:
11798 case 0x02:
11799 case 0x03:
11800 case 0x04:
11801 case 0x05:
11802 case 0x06:
11803 case 0x07:
11804 case 0x08:
11805 case 0x09:
11806 case 0x0a:
11807 case 0x0b:
11808 case 0x0c:
11809 case 0x0d:
11810 case 0x0e:
11811 goto op_semantics_88;
11812 break;
11813 case 0x0f:
11814 goto op_semantics_89;
11815 break;
11817 break;
11818 case 0xf5:
11819 GETBYTE ();
11820 switch (op[2] & 0x0f)
11822 case 0x00:
11823 case 0x01:
11824 case 0x02:
11825 case 0x03:
11826 case 0x04:
11827 case 0x05:
11828 case 0x06:
11829 case 0x07:
11830 case 0x08:
11831 case 0x09:
11832 case 0x0a:
11833 case 0x0b:
11834 case 0x0c:
11835 case 0x0d:
11836 case 0x0e:
11837 goto op_semantics_88;
11838 break;
11839 case 0x0f:
11840 goto op_semantics_89;
11841 break;
11843 break;
11844 case 0xf6:
11845 GETBYTE ();
11846 switch (op[2] & 0x0f)
11848 case 0x00:
11849 case 0x01:
11850 case 0x02:
11851 case 0x03:
11852 case 0x04:
11853 case 0x05:
11854 case 0x06:
11855 case 0x07:
11856 case 0x08:
11857 case 0x09:
11858 case 0x0a:
11859 case 0x0b:
11860 case 0x0c:
11861 case 0x0d:
11862 case 0x0e:
11863 goto op_semantics_88;
11864 break;
11865 case 0x0f:
11866 goto op_semantics_89;
11867 break;
11869 break;
11870 case 0xf7:
11871 GETBYTE ();
11872 switch (op[2] & 0x0f)
11874 case 0x00:
11875 case 0x01:
11876 case 0x02:
11877 case 0x03:
11878 case 0x04:
11879 case 0x05:
11880 case 0x06:
11881 case 0x07:
11882 case 0x08:
11883 case 0x09:
11884 case 0x0a:
11885 case 0x0b:
11886 case 0x0c:
11887 case 0x0d:
11888 case 0x0e:
11889 goto op_semantics_88;
11890 break;
11891 case 0x0f:
11892 goto op_semantics_89;
11893 break;
11895 break;
11896 case 0xf8:
11897 GETBYTE ();
11898 switch (op[2] & 0x0f)
11900 case 0x00:
11901 case 0x01:
11902 case 0x02:
11903 case 0x03:
11904 case 0x04:
11905 case 0x05:
11906 case 0x06:
11907 case 0x07:
11908 case 0x08:
11909 case 0x09:
11910 case 0x0a:
11911 case 0x0b:
11912 case 0x0c:
11913 case 0x0d:
11914 case 0x0e:
11915 goto op_semantics_88;
11916 break;
11917 case 0x0f:
11918 goto op_semantics_89;
11919 break;
11921 break;
11922 case 0xf9:
11923 GETBYTE ();
11924 switch (op[2] & 0x0f)
11926 case 0x00:
11927 case 0x01:
11928 case 0x02:
11929 case 0x03:
11930 case 0x04:
11931 case 0x05:
11932 case 0x06:
11933 case 0x07:
11934 case 0x08:
11935 case 0x09:
11936 case 0x0a:
11937 case 0x0b:
11938 case 0x0c:
11939 case 0x0d:
11940 case 0x0e:
11941 goto op_semantics_88;
11942 break;
11943 case 0x0f:
11944 goto op_semantics_89;
11945 break;
11947 break;
11948 case 0xfa:
11949 GETBYTE ();
11950 switch (op[2] & 0x0f)
11952 case 0x00:
11953 case 0x01:
11954 case 0x02:
11955 case 0x03:
11956 case 0x04:
11957 case 0x05:
11958 case 0x06:
11959 case 0x07:
11960 case 0x08:
11961 case 0x09:
11962 case 0x0a:
11963 case 0x0b:
11964 case 0x0c:
11965 case 0x0d:
11966 case 0x0e:
11967 goto op_semantics_88;
11968 break;
11969 case 0x0f:
11970 goto op_semantics_89;
11971 break;
11973 break;
11974 case 0xfb:
11975 GETBYTE ();
11976 switch (op[2] & 0x0f)
11978 case 0x00:
11979 case 0x01:
11980 case 0x02:
11981 case 0x03:
11982 case 0x04:
11983 case 0x05:
11984 case 0x06:
11985 case 0x07:
11986 case 0x08:
11987 case 0x09:
11988 case 0x0a:
11989 case 0x0b:
11990 case 0x0c:
11991 case 0x0d:
11992 case 0x0e:
11993 goto op_semantics_88;
11994 break;
11995 case 0x0f:
11996 goto op_semantics_89;
11997 break;
11999 break;
12000 case 0xfc:
12001 GETBYTE ();
12002 switch (op[2] & 0x0f)
12004 case 0x00:
12005 case 0x01:
12006 case 0x02:
12007 case 0x03:
12008 case 0x04:
12009 case 0x05:
12010 case 0x06:
12011 case 0x07:
12012 case 0x08:
12013 case 0x09:
12014 case 0x0a:
12015 case 0x0b:
12016 case 0x0c:
12017 case 0x0d:
12018 case 0x0e:
12019 goto op_semantics_88;
12020 break;
12021 case 0x0f:
12022 goto op_semantics_89;
12023 break;
12025 break;
12026 case 0xfd:
12027 GETBYTE ();
12028 switch (op[2] & 0x0f)
12030 case 0x00:
12031 case 0x01:
12032 case 0x02:
12033 case 0x03:
12034 case 0x04:
12035 case 0x05:
12036 case 0x06:
12037 case 0x07:
12038 case 0x08:
12039 case 0x09:
12040 case 0x0a:
12041 case 0x0b:
12042 case 0x0c:
12043 case 0x0d:
12044 case 0x0e:
12045 goto op_semantics_88;
12046 break;
12047 case 0x0f:
12048 goto op_semantics_89;
12049 break;
12051 break;
12052 case 0xfe:
12053 GETBYTE ();
12054 switch (op[2] & 0x0f)
12056 case 0x00:
12057 case 0x01:
12058 case 0x02:
12059 case 0x03:
12060 case 0x04:
12061 case 0x05:
12062 case 0x06:
12063 case 0x07:
12064 case 0x08:
12065 case 0x09:
12066 case 0x0a:
12067 case 0x0b:
12068 case 0x0c:
12069 case 0x0d:
12070 case 0x0e:
12071 goto op_semantics_88;
12072 break;
12073 case 0x0f:
12074 goto op_semantics_89;
12075 break;
12077 break;
12078 case 0xff:
12079 GETBYTE ();
12080 switch (op[2] & 0x0f)
12082 case 0x00:
12083 case 0x01:
12084 case 0x02:
12085 case 0x03:
12086 case 0x04:
12087 case 0x05:
12088 case 0x06:
12089 case 0x07:
12090 case 0x08:
12091 case 0x09:
12092 case 0x0a:
12093 case 0x0b:
12094 case 0x0c:
12095 case 0x0d:
12096 case 0x0e:
12097 goto op_semantics_88;
12098 break;
12099 case 0x0f:
12100 goto op_semantics_89;
12101 break;
12103 break;
12104 default: UNSUPPORTED(); break;
12106 break;
12107 case 0xfd:
12108 GETBYTE ();
12109 switch (op[1] & 0xff)
12111 case 0x00:
12112 GETBYTE ();
12113 switch (op[2] & 0x00)
12115 case 0x00:
12116 op_semantics_90:
12118 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
12119 #line 873 "rx-decode.opc"
12120 int a AU = (op[1] >> 3) & 0x01;
12121 #line 873 "rx-decode.opc"
12122 int srca AU = (op[2] >> 4) & 0x0f;
12123 #line 873 "rx-decode.opc"
12124 int srcb AU = op[2] & 0x0f;
12125 if (trace)
12127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12128 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
12129 op[0], op[1], op[2]);
12130 printf (" a = 0x%x,", a);
12131 printf (" srca = 0x%x,", srca);
12132 printf (" srcb = 0x%x\n", srcb);
12134 SYNTAX("mulhi %1, %2, %0");
12135 #line 873 "rx-decode.opc"
12136 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
12139 break;
12141 break;
12142 case 0x01:
12143 GETBYTE ();
12144 switch (op[2] & 0x00)
12146 case 0x00:
12147 op_semantics_91:
12149 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
12150 #line 876 "rx-decode.opc"
12151 int a AU = (op[1] >> 3) & 0x01;
12152 #line 876 "rx-decode.opc"
12153 int srca AU = (op[2] >> 4) & 0x0f;
12154 #line 876 "rx-decode.opc"
12155 int srcb AU = op[2] & 0x0f;
12156 if (trace)
12158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12159 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
12160 op[0], op[1], op[2]);
12161 printf (" a = 0x%x,", a);
12162 printf (" srca = 0x%x,", srca);
12163 printf (" srcb = 0x%x\n", srcb);
12165 SYNTAX("mullo %1, %2, %0");
12166 #line 876 "rx-decode.opc"
12167 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
12170 break;
12172 break;
12173 case 0x02:
12174 GETBYTE ();
12175 switch (op[2] & 0x00)
12177 case 0x00:
12178 op_semantics_92:
12180 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
12181 #line 1104 "rx-decode.opc"
12182 int a AU = (op[1] >> 3) & 0x01;
12183 #line 1104 "rx-decode.opc"
12184 int srca AU = (op[2] >> 4) & 0x0f;
12185 #line 1104 "rx-decode.opc"
12186 int srcb AU = op[2] & 0x0f;
12187 if (trace)
12189 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12190 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
12191 op[0], op[1], op[2]);
12192 printf (" a = 0x%x,", a);
12193 printf (" srca = 0x%x,", srca);
12194 printf (" srcb = 0x%x\n", srcb);
12196 SYNTAX("mullh %1, %2, %0");
12197 #line 1104 "rx-decode.opc"
12198 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
12201 break;
12203 break;
12204 case 0x03:
12205 GETBYTE ();
12206 switch (op[2] & 0x00)
12208 case 0x00:
12209 op_semantics_93:
12211 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
12212 #line 1089 "rx-decode.opc"
12213 int a AU = (op[1] >> 3) & 0x01;
12214 #line 1089 "rx-decode.opc"
12215 int srca AU = (op[2] >> 4) & 0x0f;
12216 #line 1089 "rx-decode.opc"
12217 int srcb AU = op[2] & 0x0f;
12218 if (trace)
12220 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12221 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
12222 op[0], op[1], op[2]);
12223 printf (" a = 0x%x,", a);
12224 printf (" srca = 0x%x,", srca);
12225 printf (" srcb = 0x%x\n", srcb);
12227 SYNTAX("emula %1, %2, %0");
12228 #line 1089 "rx-decode.opc"
12229 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
12232 break;
12234 break;
12235 case 0x04:
12236 GETBYTE ();
12237 switch (op[2] & 0x00)
12239 case 0x00:
12240 op_semantics_94:
12242 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
12243 #line 879 "rx-decode.opc"
12244 int a AU = (op[1] >> 3) & 0x01;
12245 #line 879 "rx-decode.opc"
12246 int srca AU = (op[2] >> 4) & 0x0f;
12247 #line 879 "rx-decode.opc"
12248 int srcb AU = op[2] & 0x0f;
12249 if (trace)
12251 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12252 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
12253 op[0], op[1], op[2]);
12254 printf (" a = 0x%x,", a);
12255 printf (" srca = 0x%x,", srca);
12256 printf (" srcb = 0x%x\n", srcb);
12258 SYNTAX("machi %1, %2, %0");
12259 #line 879 "rx-decode.opc"
12260 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
12263 break;
12265 break;
12266 case 0x05:
12267 GETBYTE ();
12268 switch (op[2] & 0x00)
12270 case 0x00:
12271 op_semantics_95:
12273 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
12274 #line 882 "rx-decode.opc"
12275 int a AU = (op[1] >> 3) & 0x01;
12276 #line 882 "rx-decode.opc"
12277 int srca AU = (op[2] >> 4) & 0x0f;
12278 #line 882 "rx-decode.opc"
12279 int srcb AU = op[2] & 0x0f;
12280 if (trace)
12282 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12283 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
12284 op[0], op[1], op[2]);
12285 printf (" a = 0x%x,", a);
12286 printf (" srca = 0x%x,", srca);
12287 printf (" srcb = 0x%x\n", srcb);
12289 SYNTAX("maclo %1, %2, %0");
12290 #line 882 "rx-decode.opc"
12291 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
12294 break;
12296 break;
12297 case 0x06:
12298 GETBYTE ();
12299 switch (op[2] & 0x00)
12301 case 0x00:
12302 op_semantics_96:
12304 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
12305 #line 1092 "rx-decode.opc"
12306 int a AU = (op[1] >> 3) & 0x01;
12307 #line 1092 "rx-decode.opc"
12308 int srca AU = (op[2] >> 4) & 0x0f;
12309 #line 1092 "rx-decode.opc"
12310 int srcb AU = op[2] & 0x0f;
12311 if (trace)
12313 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12314 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
12315 op[0], op[1], op[2]);
12316 printf (" a = 0x%x,", a);
12317 printf (" srca = 0x%x,", srca);
12318 printf (" srcb = 0x%x\n", srcb);
12320 SYNTAX("maclh %1, %2, %0");
12321 #line 1092 "rx-decode.opc"
12322 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
12325 break;
12327 break;
12328 case 0x07:
12329 GETBYTE ();
12330 switch (op[2] & 0x00)
12332 case 0x00:
12333 op_semantics_97:
12335 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
12336 #line 1083 "rx-decode.opc"
12337 int a AU = (op[1] >> 3) & 0x01;
12338 #line 1083 "rx-decode.opc"
12339 int srca AU = (op[2] >> 4) & 0x0f;
12340 #line 1083 "rx-decode.opc"
12341 int srcb AU = op[2] & 0x0f;
12342 if (trace)
12344 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12345 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
12346 op[0], op[1], op[2]);
12347 printf (" a = 0x%x,", a);
12348 printf (" srca = 0x%x,", srca);
12349 printf (" srcb = 0x%x\n", srcb);
12351 SYNTAX("emaca %1, %2, %0");
12352 #line 1083 "rx-decode.opc"
12353 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
12356 break;
12358 break;
12359 case 0x08:
12360 GETBYTE ();
12361 switch (op[2] & 0x00)
12363 case 0x00:
12364 goto op_semantics_90;
12365 break;
12367 break;
12368 case 0x09:
12369 GETBYTE ();
12370 switch (op[2] & 0x00)
12372 case 0x00:
12373 goto op_semantics_91;
12374 break;
12376 break;
12377 case 0x0a:
12378 GETBYTE ();
12379 switch (op[2] & 0x00)
12381 case 0x00:
12382 goto op_semantics_92;
12383 break;
12385 break;
12386 case 0x0b:
12387 GETBYTE ();
12388 switch (op[2] & 0x00)
12390 case 0x00:
12391 goto op_semantics_93;
12392 break;
12394 break;
12395 case 0x0c:
12396 GETBYTE ();
12397 switch (op[2] & 0x00)
12399 case 0x00:
12400 goto op_semantics_94;
12401 break;
12403 break;
12404 case 0x0d:
12405 GETBYTE ();
12406 switch (op[2] & 0x00)
12408 case 0x00:
12409 goto op_semantics_95;
12410 break;
12412 break;
12413 case 0x0e:
12414 GETBYTE ();
12415 switch (op[2] & 0x00)
12417 case 0x00:
12418 goto op_semantics_96;
12419 break;
12421 break;
12422 case 0x0f:
12423 GETBYTE ();
12424 switch (op[2] & 0x00)
12426 case 0x00:
12427 goto op_semantics_97;
12428 break;
12430 break;
12431 case 0x17:
12432 GETBYTE ();
12433 switch (op[2] & 0x70)
12435 case 0x00:
12437 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
12438 #line 885 "rx-decode.opc"
12439 int a AU = (op[2] >> 7) & 0x01;
12440 #line 885 "rx-decode.opc"
12441 int rsrc AU = op[2] & 0x0f;
12442 if (trace)
12444 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12445 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
12446 op[0], op[1], op[2]);
12447 printf (" a = 0x%x,", a);
12448 printf (" rsrc = 0x%x\n", rsrc);
12450 SYNTAX("mvtachi %1, %0");
12451 #line 885 "rx-decode.opc"
12452 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
12455 break;
12456 case 0x10:
12458 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
12459 #line 888 "rx-decode.opc"
12460 int a AU = (op[2] >> 7) & 0x01;
12461 #line 888 "rx-decode.opc"
12462 int rsrc AU = op[2] & 0x0f;
12463 if (trace)
12465 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12466 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
12467 op[0], op[1], op[2]);
12468 printf (" a = 0x%x,", a);
12469 printf (" rsrc = 0x%x\n", rsrc);
12471 SYNTAX("mvtaclo %1, %0");
12472 #line 888 "rx-decode.opc"
12473 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
12476 break;
12477 case 0x30:
12479 /** 1111 1101 0001 0111 a011 rsrc mvtacgu %1, %0 */
12480 #line 1110 "rx-decode.opc"
12481 int a AU = (op[2] >> 7) & 0x01;
12482 #line 1110 "rx-decode.opc"
12483 int rsrc AU = op[2] & 0x0f;
12484 if (trace)
12486 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12487 "/** 1111 1101 0001 0111 a011 rsrc mvtacgu %1, %0 */",
12488 op[0], op[1], op[2]);
12489 printf (" a = 0x%x,", a);
12490 printf (" rsrc = 0x%x\n", rsrc);
12492 SYNTAX("mvtacgu %1, %0");
12493 #line 1110 "rx-decode.opc"
12494 ID(mvtacgu); SR(rsrc); DR(a+32); F_____;
12497 break;
12498 default: UNSUPPORTED(); break;
12500 break;
12501 case 0x18:
12502 GETBYTE ();
12503 switch (op[2] & 0x6f)
12505 case 0x00:
12507 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
12508 #line 900 "rx-decode.opc"
12509 int a AU = (op[2] >> 7) & 0x01;
12510 #line 900 "rx-decode.opc"
12511 int i AU = (op[2] >> 4) & 0x01;
12512 if (trace)
12514 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12515 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
12516 op[0], op[1], op[2]);
12517 printf (" a = 0x%x,", a);
12518 printf (" i = 0x%x\n", i);
12520 SYNTAX("racw #%1, %0");
12521 #line 900 "rx-decode.opc"
12522 ID(racw); SC(i+1); DR(a+32); F_____;
12524 /*----------------------------------------------------------------------*/
12525 /* SAT */
12528 break;
12529 case 0x40:
12531 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
12532 #line 1119 "rx-decode.opc"
12533 int a AU = (op[2] >> 7) & 0x01;
12534 #line 1119 "rx-decode.opc"
12535 int i AU = (op[2] >> 4) & 0x01;
12536 if (trace)
12538 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12539 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
12540 op[0], op[1], op[2]);
12541 printf (" a = 0x%x,", a);
12542 printf (" i = 0x%x\n", i);
12544 SYNTAX("rdacw #%1, %0");
12545 #line 1119 "rx-decode.opc"
12546 ID(rdacw); SC(i+1); DR(a+32); F_____;
12549 break;
12550 default: UNSUPPORTED(); break;
12552 break;
12553 case 0x19:
12554 GETBYTE ();
12555 switch (op[2] & 0x6f)
12557 case 0x00:
12559 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
12560 #line 1113 "rx-decode.opc"
12561 int a AU = (op[2] >> 7) & 0x01;
12562 #line 1113 "rx-decode.opc"
12563 int i AU = (op[2] >> 4) & 0x01;
12564 if (trace)
12566 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12567 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
12568 op[0], op[1], op[2]);
12569 printf (" a = 0x%x,", a);
12570 printf (" i = 0x%x\n", i);
12572 SYNTAX("racl #%1, %0");
12573 #line 1113 "rx-decode.opc"
12574 ID(racl); SC(i+1); DR(a+32); F_____;
12577 break;
12578 case 0x40:
12580 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
12581 #line 1116 "rx-decode.opc"
12582 int a AU = (op[2] >> 7) & 0x01;
12583 #line 1116 "rx-decode.opc"
12584 int i AU = (op[2] >> 4) & 0x01;
12585 if (trace)
12587 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12588 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
12589 op[0], op[1], op[2]);
12590 printf (" a = 0x%x,", a);
12591 printf (" i = 0x%x\n", i);
12593 SYNTAX("rdacl #%1, %0");
12594 #line 1116 "rx-decode.opc"
12595 ID(rdacl); SC(i+1); DR(a+32); F_____;
12598 break;
12599 default: UNSUPPORTED(); break;
12601 break;
12602 case 0x1e:
12603 GETBYTE ();
12604 switch (op[2] & 0x30)
12606 case 0x00:
12607 op_semantics_98:
12609 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
12610 #line 891 "rx-decode.opc"
12611 int i AU = op[1] & 0x01;
12612 #line 891 "rx-decode.opc"
12613 int a AU = (op[2] >> 7) & 0x01;
12614 #line 891 "rx-decode.opc"
12615 int m AU = (op[2] >> 6) & 0x01;
12616 #line 891 "rx-decode.opc"
12617 int rdst AU = op[2] & 0x0f;
12618 if (trace)
12620 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12621 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
12622 op[0], op[1], op[2]);
12623 printf (" i = 0x%x,", i);
12624 printf (" a = 0x%x,", a);
12625 printf (" m = 0x%x,", m);
12626 printf (" rdst = 0x%x\n", rdst);
12628 SYNTAX("mvfachi #%2, %1, %0");
12629 #line 891 "rx-decode.opc"
12630 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12633 break;
12634 case 0x10:
12635 op_semantics_99:
12637 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
12638 #line 897 "rx-decode.opc"
12639 int i AU = op[1] & 0x01;
12640 #line 897 "rx-decode.opc"
12641 int a AU = (op[2] >> 7) & 0x01;
12642 #line 897 "rx-decode.opc"
12643 int m AU = (op[2] >> 6) & 0x01;
12644 #line 897 "rx-decode.opc"
12645 int rdst AU = op[2] & 0x0f;
12646 if (trace)
12648 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12649 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
12650 op[0], op[1], op[2]);
12651 printf (" i = 0x%x,", i);
12652 printf (" a = 0x%x,", a);
12653 printf (" m = 0x%x,", m);
12654 printf (" rdst = 0x%x\n", rdst);
12656 SYNTAX("mvfaclo #%2, %1, %0");
12657 #line 897 "rx-decode.opc"
12658 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12661 break;
12662 case 0x20:
12663 op_semantics_100:
12665 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
12666 #line 894 "rx-decode.opc"
12667 int i AU = op[1] & 0x01;
12668 #line 894 "rx-decode.opc"
12669 int a AU = (op[2] >> 7) & 0x01;
12670 #line 894 "rx-decode.opc"
12671 int m AU = (op[2] >> 6) & 0x01;
12672 #line 894 "rx-decode.opc"
12673 int rdst AU = op[2] & 0x0f;
12674 if (trace)
12676 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12677 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
12678 op[0], op[1], op[2]);
12679 printf (" i = 0x%x,", i);
12680 printf (" a = 0x%x,", a);
12681 printf (" m = 0x%x,", m);
12682 printf (" rdst = 0x%x\n", rdst);
12684 SYNTAX("mvfacmi #%2, %1, %0");
12685 #line 894 "rx-decode.opc"
12686 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12689 break;
12690 case 0x30:
12691 op_semantics_101:
12693 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
12694 #line 1107 "rx-decode.opc"
12695 int i AU = op[1] & 0x01;
12696 #line 1107 "rx-decode.opc"
12697 int a AU = (op[2] >> 7) & 0x01;
12698 #line 1107 "rx-decode.opc"
12699 int m AU = (op[2] >> 6) & 0x01;
12700 #line 1107 "rx-decode.opc"
12701 int rdst AU = op[2] & 0x0f;
12702 if (trace)
12704 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12705 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
12706 op[0], op[1], op[2]);
12707 printf (" i = 0x%x,", i);
12708 printf (" a = 0x%x,", a);
12709 printf (" m = 0x%x,", m);
12710 printf (" rdst = 0x%x\n", rdst);
12712 SYNTAX("mvfacgu #%2, %1, %0");
12713 #line 1107 "rx-decode.opc"
12714 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12717 break;
12719 break;
12720 case 0x1f:
12721 GETBYTE ();
12722 switch (op[2] & 0x30)
12724 case 0x00:
12725 goto op_semantics_98;
12726 break;
12727 case 0x10:
12728 goto op_semantics_99;
12729 break;
12730 case 0x20:
12731 goto op_semantics_100;
12732 break;
12733 case 0x30:
12734 goto op_semantics_101;
12735 break;
12737 break;
12738 case 0x20:
12739 GETBYTE ();
12740 switch (op[2] & 0x00)
12742 case 0x00:
12743 op_semantics_102:
12745 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
12746 #line 369 "rx-decode.opc"
12747 int p AU = (op[1] >> 2) & 0x01;
12748 #line 369 "rx-decode.opc"
12749 int sz AU = op[1] & 0x03;
12750 #line 369 "rx-decode.opc"
12751 int rdst AU = (op[2] >> 4) & 0x0f;
12752 #line 369 "rx-decode.opc"
12753 int rsrc AU = op[2] & 0x0f;
12754 if (trace)
12756 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12757 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
12758 op[0], op[1], op[2]);
12759 printf (" p = 0x%x,", p);
12760 printf (" sz = 0x%x,", sz);
12761 printf (" rdst = 0x%x,", rdst);
12762 printf (" rsrc = 0x%x\n", rsrc);
12764 SYNTAX("mov%s %1, %0");
12765 #line 369 "rx-decode.opc"
12766 ID(mov); sBWL (sz); SR(rsrc); F_____;
12767 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
12770 break;
12772 break;
12773 case 0x21:
12774 GETBYTE ();
12775 switch (op[2] & 0x00)
12777 case 0x00:
12778 goto op_semantics_102;
12779 break;
12781 break;
12782 case 0x22:
12783 GETBYTE ();
12784 switch (op[2] & 0x00)
12786 case 0x00:
12787 goto op_semantics_102;
12788 break;
12790 break;
12791 case 0x24:
12792 GETBYTE ();
12793 switch (op[2] & 0x00)
12795 case 0x00:
12796 goto op_semantics_102;
12797 break;
12799 break;
12800 case 0x25:
12801 GETBYTE ();
12802 switch (op[2] & 0x00)
12804 case 0x00:
12805 goto op_semantics_102;
12806 break;
12808 break;
12809 case 0x26:
12810 GETBYTE ();
12811 switch (op[2] & 0x00)
12813 case 0x00:
12814 goto op_semantics_102;
12815 break;
12817 break;
12818 case 0x27:
12819 GETBYTE ();
12820 switch (op[2] & 0x00)
12822 case 0x00:
12824 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
12825 #line 1071 "rx-decode.opc"
12826 int rdst AU = (op[2] >> 4) & 0x0f;
12827 #line 1071 "rx-decode.opc"
12828 int rsrc AU = op[2] & 0x0f;
12829 if (trace)
12831 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12832 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
12833 op[0], op[1], op[2]);
12834 printf (" rdst = 0x%x,", rdst);
12835 printf (" rsrc = 0x%x\n", rsrc);
12837 SYNTAX("movco %1, [%0]");
12838 #line 1071 "rx-decode.opc"
12839 ID(movco); SR(rsrc); DR(rdst); F_____;
12842 break;
12844 break;
12845 case 0x28:
12846 GETBYTE ();
12847 switch (op[2] & 0x00)
12849 case 0x00:
12850 op_semantics_103:
12852 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
12853 #line 373 "rx-decode.opc"
12854 int p AU = (op[1] >> 2) & 0x01;
12855 #line 373 "rx-decode.opc"
12856 int sz AU = op[1] & 0x03;
12857 #line 373 "rx-decode.opc"
12858 int rsrc AU = (op[2] >> 4) & 0x0f;
12859 #line 373 "rx-decode.opc"
12860 int rdst AU = op[2] & 0x0f;
12861 if (trace)
12863 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12864 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
12865 op[0], op[1], op[2]);
12866 printf (" p = 0x%x,", p);
12867 printf (" sz = 0x%x,", sz);
12868 printf (" rsrc = 0x%x,", rsrc);
12869 printf (" rdst = 0x%x\n", rdst);
12871 SYNTAX("mov%s %1, %0");
12872 #line 373 "rx-decode.opc"
12873 ID(mov); sBWL (sz); DR(rdst); F_____;
12874 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12877 break;
12879 break;
12880 case 0x29:
12881 GETBYTE ();
12882 switch (op[2] & 0x00)
12884 case 0x00:
12885 goto op_semantics_103;
12886 break;
12888 break;
12889 case 0x2a:
12890 GETBYTE ();
12891 switch (op[2] & 0x00)
12893 case 0x00:
12894 goto op_semantics_103;
12895 break;
12897 break;
12898 case 0x2c:
12899 GETBYTE ();
12900 switch (op[2] & 0x00)
12902 case 0x00:
12903 goto op_semantics_103;
12904 break;
12906 break;
12907 case 0x2d:
12908 GETBYTE ();
12909 switch (op[2] & 0x00)
12911 case 0x00:
12912 goto op_semantics_103;
12913 break;
12915 break;
12916 case 0x2e:
12917 GETBYTE ();
12918 switch (op[2] & 0x00)
12920 case 0x00:
12921 goto op_semantics_103;
12922 break;
12924 break;
12925 case 0x2f:
12926 GETBYTE ();
12927 switch (op[2] & 0x00)
12929 case 0x00:
12931 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
12932 #line 1074 "rx-decode.opc"
12933 int rsrc AU = (op[2] >> 4) & 0x0f;
12934 #line 1074 "rx-decode.opc"
12935 int rdst AU = op[2] & 0x0f;
12936 if (trace)
12938 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12939 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
12940 op[0], op[1], op[2]);
12941 printf (" rsrc = 0x%x,", rsrc);
12942 printf (" rdst = 0x%x\n", rdst);
12944 SYNTAX("movli [%1], %0");
12945 #line 1074 "rx-decode.opc"
12946 ID(movli); SR(rsrc); DR(rdst); F_____;
12949 break;
12951 break;
12952 case 0x38:
12953 GETBYTE ();
12954 switch (op[2] & 0x00)
12956 case 0x00:
12957 op_semantics_104:
12959 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
12960 #line 383 "rx-decode.opc"
12961 int p AU = (op[1] >> 2) & 0x01;
12962 #line 383 "rx-decode.opc"
12963 int sz AU = op[1] & 0x03;
12964 #line 383 "rx-decode.opc"
12965 int rsrc AU = (op[2] >> 4) & 0x0f;
12966 #line 383 "rx-decode.opc"
12967 int rdst AU = op[2] & 0x0f;
12968 if (trace)
12970 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12971 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
12972 op[0], op[1], op[2]);
12973 printf (" p = 0x%x,", p);
12974 printf (" sz = 0x%x,", sz);
12975 printf (" rsrc = 0x%x,", rsrc);
12976 printf (" rdst = 0x%x\n", rdst);
12978 SYNTAX("movu%s %1, %0");
12979 #line 383 "rx-decode.opc"
12980 ID(mov); uBW (sz); DR(rdst); F_____;
12981 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12983 /*----------------------------------------------------------------------*/
12984 /* PUSH/POP */
12987 break;
12989 break;
12990 case 0x39:
12991 GETBYTE ();
12992 switch (op[2] & 0x00)
12994 case 0x00:
12995 goto op_semantics_104;
12996 break;
12998 break;
12999 case 0x3a:
13000 GETBYTE ();
13001 switch (op[2] & 0x00)
13003 case 0x00:
13004 goto op_semantics_104;
13005 break;
13007 break;
13008 case 0x3c:
13009 GETBYTE ();
13010 switch (op[2] & 0x00)
13012 case 0x00:
13013 goto op_semantics_104;
13014 break;
13016 break;
13017 case 0x3d:
13018 GETBYTE ();
13019 switch (op[2] & 0x00)
13021 case 0x00:
13022 goto op_semantics_104;
13023 break;
13025 break;
13026 case 0x3e:
13027 GETBYTE ();
13028 switch (op[2] & 0x00)
13030 case 0x00:
13031 goto op_semantics_104;
13032 break;
13034 break;
13035 case 0x44:
13036 GETBYTE ();
13037 switch (op[2] & 0x00)
13039 case 0x00:
13040 op_semantics_105:
13042 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
13043 #line 1095 "rx-decode.opc"
13044 int a AU = (op[1] >> 3) & 0x01;
13045 #line 1095 "rx-decode.opc"
13046 int srca AU = (op[2] >> 4) & 0x0f;
13047 #line 1095 "rx-decode.opc"
13048 int srcb AU = op[2] & 0x0f;
13049 if (trace)
13051 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13052 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
13053 op[0], op[1], op[2]);
13054 printf (" a = 0x%x,", a);
13055 printf (" srca = 0x%x,", srca);
13056 printf (" srcb = 0x%x\n", srcb);
13058 SYNTAX("msbhi %1, %2, %0");
13059 #line 1095 "rx-decode.opc"
13060 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13063 break;
13065 break;
13066 case 0x45:
13067 GETBYTE ();
13068 switch (op[2] & 0x00)
13070 case 0x00:
13071 op_semantics_106:
13073 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
13074 #line 1101 "rx-decode.opc"
13075 int a AU = (op[1] >> 3) & 0x01;
13076 #line 1101 "rx-decode.opc"
13077 int srca AU = (op[2] >> 4) & 0x0f;
13078 #line 1101 "rx-decode.opc"
13079 int srcb AU = op[2] & 0x0f;
13080 if (trace)
13082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13083 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
13084 op[0], op[1], op[2]);
13085 printf (" a = 0x%x,", a);
13086 printf (" srca = 0x%x,", srca);
13087 printf (" srcb = 0x%x\n", srcb);
13089 SYNTAX("msblo %1, %2, %0");
13090 #line 1101 "rx-decode.opc"
13091 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
13094 break;
13096 break;
13097 case 0x46:
13098 GETBYTE ();
13099 switch (op[2] & 0x00)
13101 case 0x00:
13102 op_semantics_107:
13104 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
13105 #line 1098 "rx-decode.opc"
13106 int a AU = (op[1] >> 3) & 0x01;
13107 #line 1098 "rx-decode.opc"
13108 int srca AU = (op[2] >> 4) & 0x0f;
13109 #line 1098 "rx-decode.opc"
13110 int srcb AU = op[2] & 0x0f;
13111 if (trace)
13113 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13114 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
13115 op[0], op[1], op[2]);
13116 printf (" a = 0x%x,", a);
13117 printf (" srca = 0x%x,", srca);
13118 printf (" srcb = 0x%x\n", srcb);
13120 SYNTAX("msblh %1, %2, %0");
13121 #line 1098 "rx-decode.opc"
13122 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
13125 break;
13127 break;
13128 case 0x47:
13129 GETBYTE ();
13130 switch (op[2] & 0x00)
13132 case 0x00:
13133 op_semantics_108:
13135 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
13136 #line 1086 "rx-decode.opc"
13137 int a AU = (op[1] >> 3) & 0x01;
13138 #line 1086 "rx-decode.opc"
13139 int srca AU = (op[2] >> 4) & 0x0f;
13140 #line 1086 "rx-decode.opc"
13141 int srcb AU = op[2] & 0x0f;
13142 if (trace)
13144 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13145 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
13146 op[0], op[1], op[2]);
13147 printf (" a = 0x%x,", a);
13148 printf (" srca = 0x%x,", srca);
13149 printf (" srcb = 0x%x\n", srcb);
13151 SYNTAX("emsba %1, %2, %0");
13152 #line 1086 "rx-decode.opc"
13153 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
13156 break;
13158 break;
13159 case 0x4c:
13160 GETBYTE ();
13161 switch (op[2] & 0x00)
13163 case 0x00:
13164 goto op_semantics_105;
13165 break;
13167 break;
13168 case 0x4d:
13169 GETBYTE ();
13170 switch (op[2] & 0x00)
13172 case 0x00:
13173 goto op_semantics_106;
13174 break;
13176 break;
13177 case 0x4e:
13178 GETBYTE ();
13179 switch (op[2] & 0x00)
13181 case 0x00:
13182 goto op_semantics_107;
13183 break;
13185 break;
13186 case 0x4f:
13187 GETBYTE ();
13188 switch (op[2] & 0x00)
13190 case 0x00:
13191 goto op_semantics_108;
13192 break;
13194 break;
13195 case 0x60:
13196 GETBYTE ();
13197 switch (op[2] & 0x00)
13199 case 0x00:
13201 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
13202 #line 754 "rx-decode.opc"
13203 int rsrc AU = (op[2] >> 4) & 0x0f;
13204 #line 754 "rx-decode.opc"
13205 int rdst AU = op[2] & 0x0f;
13206 if (trace)
13208 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13209 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
13210 op[0], op[1], op[2]);
13211 printf (" rsrc = 0x%x,", rsrc);
13212 printf (" rdst = 0x%x\n", rdst);
13214 SYNTAX("shlr %2, %0");
13215 #line 754 "rx-decode.opc"
13216 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
13219 break;
13221 break;
13222 case 0x61:
13223 GETBYTE ();
13224 switch (op[2] & 0x00)
13226 case 0x00:
13228 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
13229 #line 744 "rx-decode.opc"
13230 int rsrc AU = (op[2] >> 4) & 0x0f;
13231 #line 744 "rx-decode.opc"
13232 int rdst AU = op[2] & 0x0f;
13233 if (trace)
13235 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13236 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
13237 op[0], op[1], op[2]);
13238 printf (" rsrc = 0x%x,", rsrc);
13239 printf (" rdst = 0x%x\n", rdst);
13241 SYNTAX("shar %2, %0");
13242 #line 744 "rx-decode.opc"
13243 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
13246 break;
13248 break;
13249 case 0x62:
13250 GETBYTE ();
13251 switch (op[2] & 0x00)
13253 case 0x00:
13255 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
13256 #line 734 "rx-decode.opc"
13257 int rsrc AU = (op[2] >> 4) & 0x0f;
13258 #line 734 "rx-decode.opc"
13259 int rdst AU = op[2] & 0x0f;
13260 if (trace)
13262 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13263 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
13264 op[0], op[1], op[2]);
13265 printf (" rsrc = 0x%x,", rsrc);
13266 printf (" rdst = 0x%x\n", rdst);
13268 SYNTAX("shll %2, %0");
13269 #line 734 "rx-decode.opc"
13270 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
13273 break;
13275 break;
13276 case 0x64:
13277 GETBYTE ();
13278 switch (op[2] & 0x00)
13280 case 0x00:
13282 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
13283 #line 778 "rx-decode.opc"
13284 int rsrc AU = (op[2] >> 4) & 0x0f;
13285 #line 778 "rx-decode.opc"
13286 int rdst AU = op[2] & 0x0f;
13287 if (trace)
13289 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13290 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
13291 op[0], op[1], op[2]);
13292 printf (" rsrc = 0x%x,", rsrc);
13293 printf (" rdst = 0x%x\n", rdst);
13295 SYNTAX("rotr %1, %0");
13296 #line 778 "rx-decode.opc"
13297 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
13300 break;
13302 break;
13303 case 0x65:
13304 GETBYTE ();
13305 switch (op[2] & 0x00)
13307 case 0x00:
13309 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
13310 #line 781 "rx-decode.opc"
13311 int rsrc AU = (op[2] >> 4) & 0x0f;
13312 #line 781 "rx-decode.opc"
13313 int rdst AU = op[2] & 0x0f;
13314 if (trace)
13316 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13317 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
13318 op[0], op[1], op[2]);
13319 printf (" rsrc = 0x%x,", rsrc);
13320 printf (" rdst = 0x%x\n", rdst);
13322 SYNTAX("revw %1, %0");
13323 #line 781 "rx-decode.opc"
13324 ID(revw); SR(rsrc); DR(rdst);
13327 break;
13329 break;
13330 case 0x66:
13331 GETBYTE ();
13332 switch (op[2] & 0x00)
13334 case 0x00:
13336 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
13337 #line 772 "rx-decode.opc"
13338 int rsrc AU = (op[2] >> 4) & 0x0f;
13339 #line 772 "rx-decode.opc"
13340 int rdst AU = op[2] & 0x0f;
13341 if (trace)
13343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13344 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
13345 op[0], op[1], op[2]);
13346 printf (" rsrc = 0x%x,", rsrc);
13347 printf (" rdst = 0x%x\n", rdst);
13349 SYNTAX("rotl %1, %0");
13350 #line 772 "rx-decode.opc"
13351 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
13354 break;
13356 break;
13357 case 0x67:
13358 GETBYTE ();
13359 switch (op[2] & 0x00)
13361 case 0x00:
13363 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
13364 #line 784 "rx-decode.opc"
13365 int rsrc AU = (op[2] >> 4) & 0x0f;
13366 #line 784 "rx-decode.opc"
13367 int rdst AU = op[2] & 0x0f;
13368 if (trace)
13370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13371 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
13372 op[0], op[1], op[2]);
13373 printf (" rsrc = 0x%x,", rsrc);
13374 printf (" rdst = 0x%x\n", rdst);
13376 SYNTAX("revl %1, %0");
13377 #line 784 "rx-decode.opc"
13378 ID(revl); SR(rsrc); DR(rdst);
13380 /*----------------------------------------------------------------------*/
13381 /* BRANCH */
13384 break;
13386 break;
13387 case 0x68:
13388 GETBYTE ();
13389 switch (op[2] & 0x00)
13391 case 0x00:
13392 op_semantics_109:
13394 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
13395 #line 1035 "rx-decode.opc"
13396 int c AU = op[1] & 0x01;
13397 #line 1035 "rx-decode.opc"
13398 int rsrc AU = (op[2] >> 4) & 0x0f;
13399 #line 1035 "rx-decode.opc"
13400 int rdst AU = op[2] & 0x0f;
13401 if (trace)
13403 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13404 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
13405 op[0], op[1], op[2]);
13406 printf (" c = 0x%x,", c);
13407 printf (" rsrc = 0x%x,", rsrc);
13408 printf (" rdst = 0x%x\n", rdst);
13410 SYNTAX("mvtc %1, %0");
13411 #line 1035 "rx-decode.opc"
13412 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
13415 break;
13417 break;
13418 case 0x69:
13419 GETBYTE ();
13420 switch (op[2] & 0x00)
13422 case 0x00:
13423 goto op_semantics_109;
13424 break;
13426 break;
13427 case 0x6a:
13428 GETBYTE ();
13429 switch (op[2] & 0x00)
13431 case 0x00:
13432 op_semantics_110:
13434 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
13435 #line 1038 "rx-decode.opc"
13436 int s AU = op[1] & 0x01;
13437 #line 1038 "rx-decode.opc"
13438 int rsrc AU = (op[2] >> 4) & 0x0f;
13439 #line 1038 "rx-decode.opc"
13440 int rdst AU = op[2] & 0x0f;
13441 if (trace)
13443 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13444 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
13445 op[0], op[1], op[2]);
13446 printf (" s = 0x%x,", s);
13447 printf (" rsrc = 0x%x,", rsrc);
13448 printf (" rdst = 0x%x\n", rdst);
13450 SYNTAX("mvfc %1, %0");
13451 #line 1038 "rx-decode.opc"
13452 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
13454 /*----------------------------------------------------------------------*/
13455 /* INTERRUPTS */
13458 break;
13460 break;
13461 case 0x6b:
13462 GETBYTE ();
13463 switch (op[2] & 0x00)
13465 case 0x00:
13466 goto op_semantics_110;
13467 break;
13469 break;
13470 case 0x6c:
13471 GETBYTE ();
13472 switch (op[2] & 0x00)
13474 case 0x00:
13475 op_semantics_111:
13477 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
13478 #line 775 "rx-decode.opc"
13479 int i AU = op[1] & 0x01;
13480 #line 775 "rx-decode.opc"
13481 int mmmm AU = (op[2] >> 4) & 0x0f;
13482 #line 775 "rx-decode.opc"
13483 int rdst AU = op[2] & 0x0f;
13484 if (trace)
13486 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13487 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
13488 op[0], op[1], op[2]);
13489 printf (" i = 0x%x,", i);
13490 printf (" mmmm = 0x%x,", mmmm);
13491 printf (" rdst = 0x%x\n", rdst);
13493 SYNTAX("rotr #%1, %0");
13494 #line 775 "rx-decode.opc"
13495 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
13498 break;
13500 break;
13501 case 0x6d:
13502 GETBYTE ();
13503 switch (op[2] & 0x00)
13505 case 0x00:
13506 goto op_semantics_111;
13507 break;
13509 break;
13510 case 0x6e:
13511 GETBYTE ();
13512 switch (op[2] & 0x00)
13514 case 0x00:
13515 op_semantics_112:
13517 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
13518 #line 769 "rx-decode.opc"
13519 int i AU = op[1] & 0x01;
13520 #line 769 "rx-decode.opc"
13521 int mmmm AU = (op[2] >> 4) & 0x0f;
13522 #line 769 "rx-decode.opc"
13523 int rdst AU = op[2] & 0x0f;
13524 if (trace)
13526 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13527 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
13528 op[0], op[1], op[2]);
13529 printf (" i = 0x%x,", i);
13530 printf (" mmmm = 0x%x,", mmmm);
13531 printf (" rdst = 0x%x\n", rdst);
13533 SYNTAX("rotl #%1, %0");
13534 #line 769 "rx-decode.opc"
13535 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
13538 break;
13540 break;
13541 case 0x6f:
13542 GETBYTE ();
13543 switch (op[2] & 0x00)
13545 case 0x00:
13546 goto op_semantics_112;
13547 break;
13549 break;
13550 case 0x70:
13551 GETBYTE ();
13552 switch (op[2] & 0xf0)
13554 case 0x20:
13555 op_semantics_113:
13557 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
13558 #line 513 "rx-decode.opc"
13559 int im AU = (op[1] >> 2) & 0x03;
13560 #line 513 "rx-decode.opc"
13561 int rdst AU = op[2] & 0x0f;
13562 if (trace)
13564 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13565 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
13566 op[0], op[1], op[2]);
13567 printf (" im = 0x%x,", im);
13568 printf (" rdst = 0x%x\n", rdst);
13570 SYNTAX("adc #%1, %0");
13571 #line 513 "rx-decode.opc"
13572 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
13575 break;
13576 case 0x40:
13577 op_semantics_114:
13579 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
13580 #line 595 "rx-decode.opc"
13581 int im AU = (op[1] >> 2) & 0x03;
13582 #line 595 "rx-decode.opc"
13583 int rdst AU = op[2] & 0x0f;
13584 if (trace)
13586 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13587 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
13588 op[0], op[1], op[2]);
13589 printf (" im = 0x%x,", im);
13590 printf (" rdst = 0x%x\n", rdst);
13592 SYNTAX("max #%1, %0");
13593 #line 595 "rx-decode.opc"
13594 int val = IMMex (im);
13595 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
13597 ID (nop7);
13598 SYNTAX("nop\t; max\t#0x80000000, r0");
13600 else
13602 ID(max);
13604 DR(rdst); SC(val);
13607 break;
13608 case 0x50:
13609 op_semantics_115:
13611 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
13612 #line 625 "rx-decode.opc"
13613 int im AU = (op[1] >> 2) & 0x03;
13614 #line 625 "rx-decode.opc"
13615 int rdst AU = op[2] & 0x0f;
13616 if (trace)
13618 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13619 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
13620 op[0], op[1], op[2]);
13621 printf (" im = 0x%x,", im);
13622 printf (" rdst = 0x%x\n", rdst);
13624 SYNTAX("min #%1, %0");
13625 #line 625 "rx-decode.opc"
13626 ID(min); DR(rdst); SC(IMMex(im));
13629 break;
13630 case 0x60:
13631 op_semantics_116:
13633 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
13634 #line 683 "rx-decode.opc"
13635 int im AU = (op[1] >> 2) & 0x03;
13636 #line 683 "rx-decode.opc"
13637 int rdst AU = op[2] & 0x0f;
13638 if (trace)
13640 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13641 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
13642 op[0], op[1], op[2]);
13643 printf (" im = 0x%x,", im);
13644 printf (" rdst = 0x%x\n", rdst);
13646 SYNTAX("emul #%1, %0");
13647 #line 683 "rx-decode.opc"
13648 ID(emul); DR(rdst); SC(IMMex(im));
13651 break;
13652 case 0x70:
13653 op_semantics_117:
13655 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
13656 #line 695 "rx-decode.opc"
13657 int im AU = (op[1] >> 2) & 0x03;
13658 #line 695 "rx-decode.opc"
13659 int rdst AU = op[2] & 0x0f;
13660 if (trace)
13662 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13663 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
13664 op[0], op[1], op[2]);
13665 printf (" im = 0x%x,", im);
13666 printf (" rdst = 0x%x\n", rdst);
13668 SYNTAX("emulu #%1, %0");
13669 #line 695 "rx-decode.opc"
13670 ID(emulu); DR(rdst); SC(IMMex(im));
13673 break;
13674 case 0x80:
13675 op_semantics_118:
13677 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
13678 #line 707 "rx-decode.opc"
13679 int im AU = (op[1] >> 2) & 0x03;
13680 #line 707 "rx-decode.opc"
13681 int rdst AU = op[2] & 0x0f;
13682 if (trace)
13684 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13685 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
13686 op[0], op[1], op[2]);
13687 printf (" im = 0x%x,", im);
13688 printf (" rdst = 0x%x\n", rdst);
13690 SYNTAX("div #%1, %0");
13691 #line 707 "rx-decode.opc"
13692 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
13695 break;
13696 case 0x90:
13697 op_semantics_119:
13699 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
13700 #line 719 "rx-decode.opc"
13701 int im AU = (op[1] >> 2) & 0x03;
13702 #line 719 "rx-decode.opc"
13703 int rdst AU = op[2] & 0x0f;
13704 if (trace)
13706 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13707 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
13708 op[0], op[1], op[2]);
13709 printf (" im = 0x%x,", im);
13710 printf (" rdst = 0x%x\n", rdst);
13712 SYNTAX("divu #%1, %0");
13713 #line 719 "rx-decode.opc"
13714 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
13717 break;
13718 case 0xc0:
13719 op_semantics_120:
13721 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
13722 #line 492 "rx-decode.opc"
13723 int im AU = (op[1] >> 2) & 0x03;
13724 #line 492 "rx-decode.opc"
13725 int rdst AU = op[2] & 0x0f;
13726 if (trace)
13728 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13729 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
13730 op[0], op[1], op[2]);
13731 printf (" im = 0x%x,", im);
13732 printf (" rdst = 0x%x\n", rdst);
13734 SYNTAX("tst #%1, %2");
13735 #line 492 "rx-decode.opc"
13736 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
13739 break;
13740 case 0xd0:
13741 op_semantics_121:
13743 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
13744 #line 471 "rx-decode.opc"
13745 int im AU = (op[1] >> 2) & 0x03;
13746 #line 471 "rx-decode.opc"
13747 int rdst AU = op[2] & 0x0f;
13748 if (trace)
13750 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13751 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
13752 op[0], op[1], op[2]);
13753 printf (" im = 0x%x,", im);
13754 printf (" rdst = 0x%x\n", rdst);
13756 SYNTAX("xor #%1, %0");
13757 #line 471 "rx-decode.opc"
13758 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
13761 break;
13762 case 0xe0:
13763 op_semantics_122:
13765 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
13766 #line 417 "rx-decode.opc"
13767 int im AU = (op[1] >> 2) & 0x03;
13768 #line 417 "rx-decode.opc"
13769 int rdst AU = op[2] & 0x0f;
13770 if (trace)
13772 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13773 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
13774 op[0], op[1], op[2]);
13775 printf (" im = 0x%x,", im);
13776 printf (" rdst = 0x%x\n", rdst);
13778 SYNTAX("stz #%1, %0");
13779 #line 417 "rx-decode.opc"
13780 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
13783 break;
13784 case 0xf0:
13785 op_semantics_123:
13787 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
13788 #line 420 "rx-decode.opc"
13789 int im AU = (op[1] >> 2) & 0x03;
13790 #line 420 "rx-decode.opc"
13791 int rdst AU = op[2] & 0x0f;
13792 if (trace)
13794 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13795 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
13796 op[0], op[1], op[2]);
13797 printf (" im = 0x%x,", im);
13798 printf (" rdst = 0x%x\n", rdst);
13800 SYNTAX("stnz #%1, %0");
13801 #line 420 "rx-decode.opc"
13802 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
13804 /*----------------------------------------------------------------------*/
13805 /* RTSD */
13808 break;
13809 default: UNSUPPORTED(); break;
13811 break;
13812 case 0x72:
13813 GETBYTE ();
13814 switch (op[2] & 0xf0)
13816 case 0x00:
13818 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
13819 #line 927 "rx-decode.opc"
13820 int rdst AU = op[2] & 0x0f;
13821 if (trace)
13823 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13824 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
13825 op[0], op[1], op[2]);
13826 printf (" rdst = 0x%x\n", rdst);
13828 SYNTAX("fsub #%1, %0");
13829 #line 927 "rx-decode.opc"
13830 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
13833 break;
13834 case 0x10:
13836 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
13837 #line 921 "rx-decode.opc"
13838 int rdst AU = op[2] & 0x0f;
13839 if (trace)
13841 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13842 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
13843 op[0], op[1], op[2]);
13844 printf (" rdst = 0x%x\n", rdst);
13846 SYNTAX("fcmp #%1, %0");
13847 #line 921 "rx-decode.opc"
13848 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
13851 break;
13852 case 0x20:
13854 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
13855 #line 915 "rx-decode.opc"
13856 int rdst AU = op[2] & 0x0f;
13857 if (trace)
13859 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13860 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
13861 op[0], op[1], op[2]);
13862 printf (" rdst = 0x%x\n", rdst);
13864 SYNTAX("fadd #%1, %0");
13865 #line 915 "rx-decode.opc"
13866 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
13869 break;
13870 case 0x30:
13872 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
13873 #line 936 "rx-decode.opc"
13874 int rdst AU = op[2] & 0x0f;
13875 if (trace)
13877 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13878 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
13879 op[0], op[1], op[2]);
13880 printf (" rdst = 0x%x\n", rdst);
13882 SYNTAX("fmul #%1, %0");
13883 #line 936 "rx-decode.opc"
13884 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
13887 break;
13888 case 0x40:
13890 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
13891 #line 942 "rx-decode.opc"
13892 int rdst AU = op[2] & 0x0f;
13893 if (trace)
13895 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13896 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
13897 op[0], op[1], op[2]);
13898 printf (" rdst = 0x%x\n", rdst);
13900 SYNTAX("fdiv #%1, %0");
13901 #line 942 "rx-decode.opc"
13902 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
13905 break;
13906 default: UNSUPPORTED(); break;
13908 break;
13909 case 0x73:
13910 GETBYTE ();
13911 switch (op[2] & 0xe0)
13913 case 0x00:
13914 op_semantics_124:
13916 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
13917 #line 1032 "rx-decode.opc"
13918 int im AU = (op[1] >> 2) & 0x03;
13919 #line 1032 "rx-decode.opc"
13920 int crdst AU = op[2] & 0x1f;
13921 if (trace)
13923 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13924 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
13925 op[0], op[1], op[2]);
13926 printf (" im = 0x%x,", im);
13927 printf (" crdst = 0x%x\n", crdst);
13929 SYNTAX("mvtc #%1, %0");
13930 #line 1032 "rx-decode.opc"
13931 ID(mov); SC(IMMex(im)); DR(crdst + 16);
13934 break;
13935 default: UNSUPPORTED(); break;
13937 break;
13938 case 0x74:
13939 GETBYTE ();
13940 switch (op[2] & 0xf0)
13942 case 0x20:
13943 goto op_semantics_113;
13944 break;
13945 case 0x40:
13946 goto op_semantics_114;
13947 break;
13948 case 0x50:
13949 goto op_semantics_115;
13950 break;
13951 case 0x60:
13952 goto op_semantics_116;
13953 break;
13954 case 0x70:
13955 goto op_semantics_117;
13956 break;
13957 case 0x80:
13958 goto op_semantics_118;
13959 break;
13960 case 0x90:
13961 goto op_semantics_119;
13962 break;
13963 case 0xc0:
13964 goto op_semantics_120;
13965 break;
13966 case 0xd0:
13967 goto op_semantics_121;
13968 break;
13969 case 0xe0:
13970 goto op_semantics_122;
13971 break;
13972 case 0xf0:
13973 goto op_semantics_123;
13974 break;
13975 default: UNSUPPORTED(); break;
13977 break;
13978 case 0x75:
13979 GETBYTE ();
13980 switch (op[2] & 0xff)
13982 case 0x80:
13983 GETBYTE ();
13984 switch (op[3] & 0x0f)
13986 case 0x00:
13987 op_semantics_125:
13989 /** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */
13990 #line 1176 "rx-decode.opc"
13991 int rdst AU = op[2] & 0x0f;
13992 #line 1176 "rx-decode.opc"
13993 int rsrc AU = (op[3] >> 4) & 0x0f;
13994 if (trace)
13996 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
13997 "/** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */",
13998 op[0], op[1], op[2], op[3]);
13999 printf (" rdst = 0x%x,", rdst);
14000 printf (" rsrc = 0x%x\n", rsrc);
14002 SYNTAX("dmov.l %1, %0");
14003 #line 1176 "rx-decode.opc"
14004 ID(dmov); DR(rdst); SDRL(rsrc); F_____;
14007 break;
14008 case 0x02:
14009 op_semantics_126:
14011 /** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */
14012 #line 1173 "rx-decode.opc"
14013 int rdst AU = op[2] & 0x0f;
14014 #line 1173 "rx-decode.opc"
14015 int rsrc AU = (op[3] >> 4) & 0x0f;
14016 if (trace)
14018 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14019 "/** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */",
14020 op[0], op[1], op[2], op[3]);
14021 printf (" rdst = 0x%x,", rdst);
14022 printf (" rsrc = 0x%x\n", rsrc);
14024 SYNTAX("dmov.l %1, %0");
14025 #line 1173 "rx-decode.opc"
14026 ID(dmov); DR(rdst); SDRH(rsrc); F_____;
14029 break;
14030 case 0x04:
14031 op_semantics_127:
14033 /** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */
14034 #line 1226 "rx-decode.opc"
14035 int rdst AU = op[2] & 0x0f;
14036 #line 1226 "rx-decode.opc"
14037 int rsrc AU = (op[3] >> 4) & 0x0f;
14038 if (trace)
14040 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14041 "/** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */",
14042 op[0], op[1], op[2], op[3]);
14043 printf (" rdst = 0x%x,", rdst);
14044 printf (" rsrc = 0x%x\n", rsrc);
14046 SYNTAX("mvfdc %1, %0");
14047 #line 1226 "rx-decode.opc"
14048 ID(mvfdc); DR(rdst); SCR(rsrc); F_____;
14051 break;
14052 default: UNSUPPORTED(); break;
14054 break;
14055 case 0x81:
14056 GETBYTE ();
14057 switch (op[3] & 0x0f)
14059 case 0x00:
14060 goto op_semantics_125;
14061 break;
14062 case 0x02:
14063 goto op_semantics_126;
14064 break;
14065 case 0x04:
14066 goto op_semantics_127;
14067 break;
14068 default: UNSUPPORTED(); break;
14070 break;
14071 case 0x82:
14072 GETBYTE ();
14073 switch (op[3] & 0x0f)
14075 case 0x00:
14076 goto op_semantics_125;
14077 break;
14078 case 0x02:
14079 goto op_semantics_126;
14080 break;
14081 case 0x04:
14082 goto op_semantics_127;
14083 break;
14084 default: UNSUPPORTED(); break;
14086 break;
14087 case 0x83:
14088 GETBYTE ();
14089 switch (op[3] & 0x0f)
14091 case 0x00:
14092 goto op_semantics_125;
14093 break;
14094 case 0x02:
14095 goto op_semantics_126;
14096 break;
14097 case 0x04:
14098 goto op_semantics_127;
14099 break;
14100 default: UNSUPPORTED(); break;
14102 break;
14103 case 0x84:
14104 GETBYTE ();
14105 switch (op[3] & 0x0f)
14107 case 0x00:
14108 goto op_semantics_125;
14109 break;
14110 case 0x02:
14111 goto op_semantics_126;
14112 break;
14113 case 0x04:
14114 goto op_semantics_127;
14115 break;
14116 default: UNSUPPORTED(); break;
14118 break;
14119 case 0x85:
14120 GETBYTE ();
14121 switch (op[3] & 0x0f)
14123 case 0x00:
14124 goto op_semantics_125;
14125 break;
14126 case 0x02:
14127 goto op_semantics_126;
14128 break;
14129 case 0x04:
14130 goto op_semantics_127;
14131 break;
14132 default: UNSUPPORTED(); break;
14134 break;
14135 case 0x86:
14136 GETBYTE ();
14137 switch (op[3] & 0x0f)
14139 case 0x00:
14140 goto op_semantics_125;
14141 break;
14142 case 0x02:
14143 goto op_semantics_126;
14144 break;
14145 case 0x04:
14146 goto op_semantics_127;
14147 break;
14148 default: UNSUPPORTED(); break;
14150 break;
14151 case 0x87:
14152 GETBYTE ();
14153 switch (op[3] & 0x0f)
14155 case 0x00:
14156 goto op_semantics_125;
14157 break;
14158 case 0x02:
14159 goto op_semantics_126;
14160 break;
14161 case 0x04:
14162 goto op_semantics_127;
14163 break;
14164 default: UNSUPPORTED(); break;
14166 break;
14167 case 0x88:
14168 GETBYTE ();
14169 switch (op[3] & 0x0f)
14171 case 0x00:
14172 goto op_semantics_125;
14173 break;
14174 case 0x02:
14175 goto op_semantics_126;
14176 break;
14177 case 0x04:
14178 goto op_semantics_127;
14179 break;
14180 default: UNSUPPORTED(); break;
14182 break;
14183 case 0x89:
14184 GETBYTE ();
14185 switch (op[3] & 0x0f)
14187 case 0x00:
14188 goto op_semantics_125;
14189 break;
14190 case 0x02:
14191 goto op_semantics_126;
14192 break;
14193 case 0x04:
14194 goto op_semantics_127;
14195 break;
14196 default: UNSUPPORTED(); break;
14198 break;
14199 case 0x8a:
14200 GETBYTE ();
14201 switch (op[3] & 0x0f)
14203 case 0x00:
14204 goto op_semantics_125;
14205 break;
14206 case 0x02:
14207 goto op_semantics_126;
14208 break;
14209 case 0x04:
14210 goto op_semantics_127;
14211 break;
14212 default: UNSUPPORTED(); break;
14214 break;
14215 case 0x8b:
14216 GETBYTE ();
14217 switch (op[3] & 0x0f)
14219 case 0x00:
14220 goto op_semantics_125;
14221 break;
14222 case 0x02:
14223 goto op_semantics_126;
14224 break;
14225 case 0x04:
14226 goto op_semantics_127;
14227 break;
14228 default: UNSUPPORTED(); break;
14230 break;
14231 case 0x8c:
14232 GETBYTE ();
14233 switch (op[3] & 0x0f)
14235 case 0x00:
14236 goto op_semantics_125;
14237 break;
14238 case 0x02:
14239 goto op_semantics_126;
14240 break;
14241 case 0x04:
14242 goto op_semantics_127;
14243 break;
14244 default: UNSUPPORTED(); break;
14246 break;
14247 case 0x8d:
14248 GETBYTE ();
14249 switch (op[3] & 0x0f)
14251 case 0x00:
14252 goto op_semantics_125;
14253 break;
14254 case 0x02:
14255 goto op_semantics_126;
14256 break;
14257 case 0x04:
14258 goto op_semantics_127;
14259 break;
14260 default: UNSUPPORTED(); break;
14262 break;
14263 case 0x8e:
14264 GETBYTE ();
14265 switch (op[3] & 0x0f)
14267 case 0x00:
14268 goto op_semantics_125;
14269 break;
14270 case 0x02:
14271 goto op_semantics_126;
14272 break;
14273 case 0x04:
14274 goto op_semantics_127;
14275 break;
14276 default: UNSUPPORTED(); break;
14278 break;
14279 case 0x8f:
14280 GETBYTE ();
14281 switch (op[3] & 0x0f)
14283 case 0x00:
14284 goto op_semantics_125;
14285 break;
14286 case 0x02:
14287 goto op_semantics_126;
14288 break;
14289 case 0x04:
14290 goto op_semantics_127;
14291 break;
14292 default: UNSUPPORTED(); break;
14294 break;
14295 default: UNSUPPORTED(); break;
14297 break;
14298 case 0x76:
14299 GETBYTE ();
14300 switch (op[2] & 0xff)
14302 case 0xc0:
14303 GETBYTE ();
14304 switch (op[3] & 0xff)
14306 case 0x00:
14307 op_semantics_128:
14309 /** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */
14310 #line 1161 "rx-decode.opc"
14311 int rsrc AU = op[2] & 0x0f;
14312 if (trace)
14314 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14315 "/** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */",
14316 op[0], op[1], op[2], op[3]);
14317 printf (" rsrc = 0x%x\n", rsrc);
14319 SYNTAX("save %1");
14320 #line 1161 "rx-decode.opc"
14321 ID(save); SR(rsrc); F_____;
14324 break;
14325 default: UNSUPPORTED(); break;
14327 break;
14328 case 0xc1:
14329 GETBYTE ();
14330 switch (op[3] & 0xff)
14332 case 0x00:
14333 goto op_semantics_128;
14334 break;
14335 default: UNSUPPORTED(); break;
14337 break;
14338 case 0xc2:
14339 GETBYTE ();
14340 switch (op[3] & 0xff)
14342 case 0x00:
14343 goto op_semantics_128;
14344 break;
14345 default: UNSUPPORTED(); break;
14347 break;
14348 case 0xc3:
14349 GETBYTE ();
14350 switch (op[3] & 0xff)
14352 case 0x00:
14353 goto op_semantics_128;
14354 break;
14355 default: UNSUPPORTED(); break;
14357 break;
14358 case 0xc4:
14359 GETBYTE ();
14360 switch (op[3] & 0xff)
14362 case 0x00:
14363 goto op_semantics_128;
14364 break;
14365 default: UNSUPPORTED(); break;
14367 break;
14368 case 0xc5:
14369 GETBYTE ();
14370 switch (op[3] & 0xff)
14372 case 0x00:
14373 goto op_semantics_128;
14374 break;
14375 default: UNSUPPORTED(); break;
14377 break;
14378 case 0xc6:
14379 GETBYTE ();
14380 switch (op[3] & 0xff)
14382 case 0x00:
14383 goto op_semantics_128;
14384 break;
14385 default: UNSUPPORTED(); break;
14387 break;
14388 case 0xc7:
14389 GETBYTE ();
14390 switch (op[3] & 0xff)
14392 case 0x00:
14393 goto op_semantics_128;
14394 break;
14395 default: UNSUPPORTED(); break;
14397 break;
14398 case 0xc8:
14399 GETBYTE ();
14400 switch (op[3] & 0xff)
14402 case 0x00:
14403 goto op_semantics_128;
14404 break;
14405 default: UNSUPPORTED(); break;
14407 break;
14408 case 0xc9:
14409 GETBYTE ();
14410 switch (op[3] & 0xff)
14412 case 0x00:
14413 goto op_semantics_128;
14414 break;
14415 default: UNSUPPORTED(); break;
14417 break;
14418 case 0xca:
14419 GETBYTE ();
14420 switch (op[3] & 0xff)
14422 case 0x00:
14423 goto op_semantics_128;
14424 break;
14425 default: UNSUPPORTED(); break;
14427 break;
14428 case 0xcb:
14429 GETBYTE ();
14430 switch (op[3] & 0xff)
14432 case 0x00:
14433 goto op_semantics_128;
14434 break;
14435 default: UNSUPPORTED(); break;
14437 break;
14438 case 0xcc:
14439 GETBYTE ();
14440 switch (op[3] & 0xff)
14442 case 0x00:
14443 goto op_semantics_128;
14444 break;
14445 default: UNSUPPORTED(); break;
14447 break;
14448 case 0xcd:
14449 GETBYTE ();
14450 switch (op[3] & 0xff)
14452 case 0x00:
14453 goto op_semantics_128;
14454 break;
14455 default: UNSUPPORTED(); break;
14457 break;
14458 case 0xce:
14459 GETBYTE ();
14460 switch (op[3] & 0xff)
14462 case 0x00:
14463 goto op_semantics_128;
14464 break;
14465 default: UNSUPPORTED(); break;
14467 break;
14468 case 0xcf:
14469 GETBYTE ();
14470 switch (op[3] & 0xff)
14472 case 0x00:
14473 goto op_semantics_128;
14474 break;
14475 default: UNSUPPORTED(); break;
14477 break;
14478 case 0xd0:
14479 GETBYTE ();
14480 switch (op[3] & 0xff)
14482 case 0x00:
14483 op_semantics_129:
14485 /** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */
14486 #line 1155 "rx-decode.opc"
14487 int rsrc AU = op[2] & 0x0f;
14488 if (trace)
14490 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14491 "/** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */",
14492 op[0], op[1], op[2], op[3]);
14493 printf (" rsrc = 0x%x\n", rsrc);
14495 SYNTAX("rstr %1");
14496 #line 1155 "rx-decode.opc"
14497 ID(rstr); SR(rsrc); F_____;
14500 break;
14501 default: UNSUPPORTED(); break;
14503 break;
14504 case 0xd1:
14505 GETBYTE ();
14506 switch (op[3] & 0xff)
14508 case 0x00:
14509 goto op_semantics_129;
14510 break;
14511 default: UNSUPPORTED(); break;
14513 break;
14514 case 0xd2:
14515 GETBYTE ();
14516 switch (op[3] & 0xff)
14518 case 0x00:
14519 goto op_semantics_129;
14520 break;
14521 default: UNSUPPORTED(); break;
14523 break;
14524 case 0xd3:
14525 GETBYTE ();
14526 switch (op[3] & 0xff)
14528 case 0x00:
14529 goto op_semantics_129;
14530 break;
14531 default: UNSUPPORTED(); break;
14533 break;
14534 case 0xd4:
14535 GETBYTE ();
14536 switch (op[3] & 0xff)
14538 case 0x00:
14539 goto op_semantics_129;
14540 break;
14541 default: UNSUPPORTED(); break;
14543 break;
14544 case 0xd5:
14545 GETBYTE ();
14546 switch (op[3] & 0xff)
14548 case 0x00:
14549 goto op_semantics_129;
14550 break;
14551 default: UNSUPPORTED(); break;
14553 break;
14554 case 0xd6:
14555 GETBYTE ();
14556 switch (op[3] & 0xff)
14558 case 0x00:
14559 goto op_semantics_129;
14560 break;
14561 default: UNSUPPORTED(); break;
14563 break;
14564 case 0xd7:
14565 GETBYTE ();
14566 switch (op[3] & 0xff)
14568 case 0x00:
14569 goto op_semantics_129;
14570 break;
14571 default: UNSUPPORTED(); break;
14573 break;
14574 case 0xd8:
14575 GETBYTE ();
14576 switch (op[3] & 0xff)
14578 case 0x00:
14579 goto op_semantics_129;
14580 break;
14581 default: UNSUPPORTED(); break;
14583 break;
14584 case 0xd9:
14585 GETBYTE ();
14586 switch (op[3] & 0xff)
14588 case 0x00:
14589 goto op_semantics_129;
14590 break;
14591 default: UNSUPPORTED(); break;
14593 break;
14594 case 0xda:
14595 GETBYTE ();
14596 switch (op[3] & 0xff)
14598 case 0x00:
14599 goto op_semantics_129;
14600 break;
14601 default: UNSUPPORTED(); break;
14603 break;
14604 case 0xdb:
14605 GETBYTE ();
14606 switch (op[3] & 0xff)
14608 case 0x00:
14609 goto op_semantics_129;
14610 break;
14611 default: UNSUPPORTED(); break;
14613 break;
14614 case 0xdc:
14615 GETBYTE ();
14616 switch (op[3] & 0xff)
14618 case 0x00:
14619 goto op_semantics_129;
14620 break;
14621 default: UNSUPPORTED(); break;
14623 break;
14624 case 0xdd:
14625 GETBYTE ();
14626 switch (op[3] & 0xff)
14628 case 0x00:
14629 goto op_semantics_129;
14630 break;
14631 default: UNSUPPORTED(); break;
14633 break;
14634 case 0xde:
14635 GETBYTE ();
14636 switch (op[3] & 0xff)
14638 case 0x00:
14639 goto op_semantics_129;
14640 break;
14641 default: UNSUPPORTED(); break;
14643 break;
14644 case 0xdf:
14645 GETBYTE ();
14646 switch (op[3] & 0xff)
14648 case 0x00:
14649 goto op_semantics_129;
14650 break;
14651 default: UNSUPPORTED(); break;
14653 break;
14654 case 0xe0:
14656 /** 1111 1101 0111 0110 1110 0000 save #%1 */
14657 if (trace)
14659 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14660 "/** 1111 1101 0111 0110 1110 0000 save #%1 */",
14661 op[0], op[1], op[2]);
14663 SYNTAX("save #%1");
14664 #line 1164 "rx-decode.opc"
14665 ID(save); SC(IMM(1)); F_____;
14668 break;
14669 case 0xf0:
14671 /** 1111 1101 0111 0110 1111 0000 rstr #%1 */
14672 if (trace)
14674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14675 "/** 1111 1101 0111 0110 1111 0000 rstr #%1 */",
14676 op[0], op[1], op[2]);
14678 SYNTAX("rstr #%1");
14679 #line 1158 "rx-decode.opc"
14680 ID(rstr); SC(IMM(1)); F_____;
14683 break;
14684 default: UNSUPPORTED(); break;
14686 break;
14687 case 0x77:
14688 GETBYTE ();
14689 switch (op[2] & 0xff)
14691 case 0x00:
14692 case 0x01:
14693 case 0x02:
14694 case 0x03:
14695 case 0x04:
14696 case 0x05:
14697 case 0x06:
14698 case 0x07:
14699 case 0x08:
14700 case 0x09:
14701 case 0x0a:
14702 case 0x0b:
14703 case 0x0c:
14704 case 0x0d:
14705 case 0x0e:
14706 case 0x0f:
14707 case 0x10:
14708 case 0x11:
14709 case 0x12:
14710 case 0x13:
14711 case 0x14:
14712 case 0x15:
14713 case 0x16:
14714 case 0x17:
14715 case 0x18:
14716 case 0x19:
14717 case 0x1a:
14718 case 0x1b:
14719 case 0x1c:
14720 case 0x1d:
14721 case 0x1e:
14722 case 0x1f:
14723 goto op_semantics_124;
14724 break;
14725 case 0x80:
14726 GETBYTE ();
14727 switch (op[3] & 0x0f)
14729 case 0x00:
14730 op_semantics_130:
14732 /** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */
14733 #line 1170 "rx-decode.opc"
14734 int rsrc AU = op[2] & 0x0f;
14735 #line 1170 "rx-decode.opc"
14736 int rdst AU = (op[3] >> 4) & 0x0f;
14737 if (trace)
14739 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14740 "/** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */",
14741 op[0], op[1], op[2], op[3]);
14742 printf (" rsrc = 0x%x,", rsrc);
14743 printf (" rdst = 0x%x\n", rdst);
14745 SYNTAX("dmov.l %1, %0");
14746 #line 1170 "rx-decode.opc"
14747 ID(dmov); DDRL(rdst); SR(rsrc); F_____;
14750 break;
14751 case 0x02:
14752 case 0x03:
14753 op_semantics_131:
14755 /** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */
14756 #line 1167 "rx-decode.opc"
14757 int rsrc AU = op[2] & 0x0f;
14758 #line 1167 "rx-decode.opc"
14759 int rdst AU = (op[3] >> 4) & 0x0f;
14760 #line 1167 "rx-decode.opc"
14761 int s AU = op[3] & 0x01;
14762 if (trace)
14764 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14765 "/** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */",
14766 op[0], op[1], op[2], op[3]);
14767 printf (" rsrc = 0x%x,", rsrc);
14768 printf (" rdst = 0x%x,", rdst);
14769 printf (" s = 0x%x\n", s);
14771 SYNTAX("dmov%s %1, %0");
14772 #line 1167 "rx-decode.opc"
14773 ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____;
14776 break;
14777 case 0x04:
14778 op_semantics_132:
14780 /** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */
14781 #line 1232 "rx-decode.opc"
14782 int rdst AU = op[2] & 0x0f;
14783 #line 1232 "rx-decode.opc"
14784 int rsrc AU = (op[3] >> 4) & 0x0f;
14785 if (trace)
14787 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14788 "/** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */",
14789 op[0], op[1], op[2], op[3]);
14790 printf (" rdst = 0x%x,", rdst);
14791 printf (" rsrc = 0x%x\n", rsrc);
14793 SYNTAX("mvtdc %1, %0");
14794 #line 1232 "rx-decode.opc"
14795 ID(mvtdc); DCR(rdst); SR(rsrc); F_____;
14798 break;
14799 case 0x09:
14800 op_semantics_133:
14802 /** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */
14803 #line 1274 "rx-decode.opc"
14804 int rsrc AU = op[2] & 0x0f;
14805 #line 1274 "rx-decode.opc"
14806 int rdst AU = (op[3] >> 4) & 0x0f;
14807 if (trace)
14809 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14810 "/** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */",
14811 op[0], op[1], op[2], op[3]);
14812 printf (" rsrc = 0x%x,", rsrc);
14813 printf (" rdst = 0x%x\n", rdst);
14815 SYNTAX("itod %1, %0");
14816 #line 1274 "rx-decode.opc"
14817 ID(itod); DDR(rdst); SR(rsrc); F_____;
14820 break;
14821 case 0x0a:
14822 op_semantics_134:
14824 /** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */
14825 #line 1271 "rx-decode.opc"
14826 int rsrc AU = op[2] & 0x0f;
14827 #line 1271 "rx-decode.opc"
14828 int rdst AU = (op[3] >> 4) & 0x0f;
14829 if (trace)
14831 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14832 "/** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */",
14833 op[0], op[1], op[2], op[3]);
14834 printf (" rsrc = 0x%x,", rsrc);
14835 printf (" rdst = 0x%x\n", rdst);
14837 SYNTAX("ftod %1, %0");
14838 #line 1271 "rx-decode.opc"
14839 ID(ftod); DDR(rdst); SR(rsrc); F_____;
14842 break;
14843 case 0x0d:
14844 op_semantics_135:
14846 /** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */
14847 #line 1277 "rx-decode.opc"
14848 int rsrc AU = op[2] & 0x0f;
14849 #line 1277 "rx-decode.opc"
14850 int rdst AU = (op[3] >> 4) & 0x0f;
14851 if (trace)
14853 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14854 "/** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */",
14855 op[0], op[1], op[2], op[3]);
14856 printf (" rsrc = 0x%x,", rsrc);
14857 printf (" rdst = 0x%x\n", rdst);
14859 SYNTAX("utod %1, %0");
14860 #line 1277 "rx-decode.opc"
14861 ID(dsqrt); DDR(rdst); SR(rsrc); F_____;
14864 break;
14865 default: UNSUPPORTED(); break;
14867 break;
14868 case 0x81:
14869 GETBYTE ();
14870 switch (op[3] & 0x0f)
14872 case 0x00:
14873 goto op_semantics_130;
14874 break;
14875 case 0x02:
14876 case 0x03:
14877 goto op_semantics_131;
14878 break;
14879 case 0x04:
14880 goto op_semantics_132;
14881 break;
14882 case 0x09:
14883 goto op_semantics_133;
14884 break;
14885 case 0x0a:
14886 goto op_semantics_134;
14887 break;
14888 case 0x0d:
14889 goto op_semantics_135;
14890 break;
14891 default: UNSUPPORTED(); break;
14893 break;
14894 case 0x82:
14895 GETBYTE ();
14896 switch (op[3] & 0x0f)
14898 case 0x00:
14899 goto op_semantics_130;
14900 break;
14901 case 0x02:
14902 case 0x03:
14903 goto op_semantics_131;
14904 break;
14905 case 0x04:
14906 goto op_semantics_132;
14907 break;
14908 case 0x09:
14909 goto op_semantics_133;
14910 break;
14911 case 0x0a:
14912 goto op_semantics_134;
14913 break;
14914 case 0x0d:
14915 goto op_semantics_135;
14916 break;
14917 default: UNSUPPORTED(); break;
14919 break;
14920 case 0x83:
14921 GETBYTE ();
14922 switch (op[3] & 0x0f)
14924 case 0x00:
14925 goto op_semantics_130;
14926 break;
14927 case 0x02:
14928 case 0x03:
14929 goto op_semantics_131;
14930 break;
14931 case 0x04:
14932 goto op_semantics_132;
14933 break;
14934 case 0x09:
14935 goto op_semantics_133;
14936 break;
14937 case 0x0a:
14938 goto op_semantics_134;
14939 break;
14940 case 0x0d:
14941 goto op_semantics_135;
14942 break;
14943 default: UNSUPPORTED(); break;
14945 break;
14946 case 0x84:
14947 GETBYTE ();
14948 switch (op[3] & 0x0f)
14950 case 0x00:
14951 goto op_semantics_130;
14952 break;
14953 case 0x02:
14954 case 0x03:
14955 goto op_semantics_131;
14956 break;
14957 case 0x04:
14958 goto op_semantics_132;
14959 break;
14960 case 0x09:
14961 goto op_semantics_133;
14962 break;
14963 case 0x0a:
14964 goto op_semantics_134;
14965 break;
14966 case 0x0d:
14967 goto op_semantics_135;
14968 break;
14969 default: UNSUPPORTED(); break;
14971 break;
14972 case 0x85:
14973 GETBYTE ();
14974 switch (op[3] & 0x0f)
14976 case 0x00:
14977 goto op_semantics_130;
14978 break;
14979 case 0x02:
14980 case 0x03:
14981 goto op_semantics_131;
14982 break;
14983 case 0x04:
14984 goto op_semantics_132;
14985 break;
14986 case 0x09:
14987 goto op_semantics_133;
14988 break;
14989 case 0x0a:
14990 goto op_semantics_134;
14991 break;
14992 case 0x0d:
14993 goto op_semantics_135;
14994 break;
14995 default: UNSUPPORTED(); break;
14997 break;
14998 case 0x86:
14999 GETBYTE ();
15000 switch (op[3] & 0x0f)
15002 case 0x00:
15003 goto op_semantics_130;
15004 break;
15005 case 0x02:
15006 case 0x03:
15007 goto op_semantics_131;
15008 break;
15009 case 0x04:
15010 goto op_semantics_132;
15011 break;
15012 case 0x09:
15013 goto op_semantics_133;
15014 break;
15015 case 0x0a:
15016 goto op_semantics_134;
15017 break;
15018 case 0x0d:
15019 goto op_semantics_135;
15020 break;
15021 default: UNSUPPORTED(); break;
15023 break;
15024 case 0x87:
15025 GETBYTE ();
15026 switch (op[3] & 0x0f)
15028 case 0x00:
15029 goto op_semantics_130;
15030 break;
15031 case 0x02:
15032 case 0x03:
15033 goto op_semantics_131;
15034 break;
15035 case 0x04:
15036 goto op_semantics_132;
15037 break;
15038 case 0x09:
15039 goto op_semantics_133;
15040 break;
15041 case 0x0a:
15042 goto op_semantics_134;
15043 break;
15044 case 0x0d:
15045 goto op_semantics_135;
15046 break;
15047 default: UNSUPPORTED(); break;
15049 break;
15050 case 0x88:
15051 GETBYTE ();
15052 switch (op[3] & 0x0f)
15054 case 0x00:
15055 goto op_semantics_130;
15056 break;
15057 case 0x02:
15058 case 0x03:
15059 goto op_semantics_131;
15060 break;
15061 case 0x04:
15062 goto op_semantics_132;
15063 break;
15064 case 0x09:
15065 goto op_semantics_133;
15066 break;
15067 case 0x0a:
15068 goto op_semantics_134;
15069 break;
15070 case 0x0d:
15071 goto op_semantics_135;
15072 break;
15073 default: UNSUPPORTED(); break;
15075 break;
15076 case 0x89:
15077 GETBYTE ();
15078 switch (op[3] & 0x0f)
15080 case 0x00:
15081 goto op_semantics_130;
15082 break;
15083 case 0x02:
15084 case 0x03:
15085 goto op_semantics_131;
15086 break;
15087 case 0x04:
15088 goto op_semantics_132;
15089 break;
15090 case 0x09:
15091 goto op_semantics_133;
15092 break;
15093 case 0x0a:
15094 goto op_semantics_134;
15095 break;
15096 case 0x0d:
15097 goto op_semantics_135;
15098 break;
15099 default: UNSUPPORTED(); break;
15101 break;
15102 case 0x8a:
15103 GETBYTE ();
15104 switch (op[3] & 0x0f)
15106 case 0x00:
15107 goto op_semantics_130;
15108 break;
15109 case 0x02:
15110 case 0x03:
15111 goto op_semantics_131;
15112 break;
15113 case 0x04:
15114 goto op_semantics_132;
15115 break;
15116 case 0x09:
15117 goto op_semantics_133;
15118 break;
15119 case 0x0a:
15120 goto op_semantics_134;
15121 break;
15122 case 0x0d:
15123 goto op_semantics_135;
15124 break;
15125 default: UNSUPPORTED(); break;
15127 break;
15128 case 0x8b:
15129 GETBYTE ();
15130 switch (op[3] & 0x0f)
15132 case 0x00:
15133 goto op_semantics_130;
15134 break;
15135 case 0x02:
15136 case 0x03:
15137 goto op_semantics_131;
15138 break;
15139 case 0x04:
15140 goto op_semantics_132;
15141 break;
15142 case 0x09:
15143 goto op_semantics_133;
15144 break;
15145 case 0x0a:
15146 goto op_semantics_134;
15147 break;
15148 case 0x0d:
15149 goto op_semantics_135;
15150 break;
15151 default: UNSUPPORTED(); break;
15153 break;
15154 case 0x8c:
15155 GETBYTE ();
15156 switch (op[3] & 0x0f)
15158 case 0x00:
15159 goto op_semantics_130;
15160 break;
15161 case 0x02:
15162 case 0x03:
15163 goto op_semantics_131;
15164 break;
15165 case 0x04:
15166 goto op_semantics_132;
15167 break;
15168 case 0x09:
15169 goto op_semantics_133;
15170 break;
15171 case 0x0a:
15172 goto op_semantics_134;
15173 break;
15174 case 0x0d:
15175 goto op_semantics_135;
15176 break;
15177 default: UNSUPPORTED(); break;
15179 break;
15180 case 0x8d:
15181 GETBYTE ();
15182 switch (op[3] & 0x0f)
15184 case 0x00:
15185 goto op_semantics_130;
15186 break;
15187 case 0x02:
15188 case 0x03:
15189 goto op_semantics_131;
15190 break;
15191 case 0x04:
15192 goto op_semantics_132;
15193 break;
15194 case 0x09:
15195 goto op_semantics_133;
15196 break;
15197 case 0x0a:
15198 goto op_semantics_134;
15199 break;
15200 case 0x0d:
15201 goto op_semantics_135;
15202 break;
15203 default: UNSUPPORTED(); break;
15205 break;
15206 case 0x8e:
15207 GETBYTE ();
15208 switch (op[3] & 0x0f)
15210 case 0x00:
15211 goto op_semantics_130;
15212 break;
15213 case 0x02:
15214 case 0x03:
15215 goto op_semantics_131;
15216 break;
15217 case 0x04:
15218 goto op_semantics_132;
15219 break;
15220 case 0x09:
15221 goto op_semantics_133;
15222 break;
15223 case 0x0a:
15224 goto op_semantics_134;
15225 break;
15226 case 0x0d:
15227 goto op_semantics_135;
15228 break;
15229 default: UNSUPPORTED(); break;
15231 break;
15232 case 0x8f:
15233 GETBYTE ();
15234 switch (op[3] & 0x0f)
15236 case 0x00:
15237 goto op_semantics_130;
15238 break;
15239 case 0x02:
15240 case 0x03:
15241 goto op_semantics_131;
15242 break;
15243 case 0x04:
15244 goto op_semantics_132;
15245 break;
15246 case 0x09:
15247 goto op_semantics_133;
15248 break;
15249 case 0x0a:
15250 goto op_semantics_134;
15251 break;
15252 case 0x0d:
15253 goto op_semantics_135;
15254 break;
15255 default: UNSUPPORTED(); break;
15257 break;
15258 default: UNSUPPORTED(); break;
15260 break;
15261 case 0x78:
15262 GETBYTE ();
15263 switch (op[2] & 0xf0)
15265 case 0x20:
15266 goto op_semantics_113;
15267 break;
15268 case 0x40:
15269 goto op_semantics_114;
15270 break;
15271 case 0x50:
15272 goto op_semantics_115;
15273 break;
15274 case 0x60:
15275 goto op_semantics_116;
15276 break;
15277 case 0x70:
15278 goto op_semantics_117;
15279 break;
15280 case 0x80:
15281 goto op_semantics_118;
15282 break;
15283 case 0x90:
15284 goto op_semantics_119;
15285 break;
15286 case 0xc0:
15287 goto op_semantics_120;
15288 break;
15289 case 0xd0:
15290 goto op_semantics_121;
15291 break;
15292 case 0xe0:
15293 goto op_semantics_122;
15294 break;
15295 case 0xf0:
15296 goto op_semantics_123;
15297 break;
15298 default: UNSUPPORTED(); break;
15300 break;
15301 case 0x7b:
15302 GETBYTE ();
15303 switch (op[2] & 0xe0)
15305 case 0x00:
15306 goto op_semantics_124;
15307 break;
15308 default: UNSUPPORTED(); break;
15310 break;
15311 case 0x7c:
15312 GETBYTE ();
15313 switch (op[2] & 0xf0)
15315 case 0x20:
15316 goto op_semantics_113;
15317 break;
15318 case 0x40:
15319 goto op_semantics_114;
15320 break;
15321 case 0x50:
15322 goto op_semantics_115;
15323 break;
15324 case 0x60:
15325 goto op_semantics_116;
15326 break;
15327 case 0x70:
15328 goto op_semantics_117;
15329 break;
15330 case 0x80:
15331 goto op_semantics_118;
15332 break;
15333 case 0x90:
15334 goto op_semantics_119;
15335 break;
15336 case 0xc0:
15337 goto op_semantics_120;
15338 break;
15339 case 0xd0:
15340 goto op_semantics_121;
15341 break;
15342 case 0xe0:
15343 goto op_semantics_122;
15344 break;
15345 case 0xf0:
15346 goto op_semantics_123;
15347 break;
15348 default: UNSUPPORTED(); break;
15350 break;
15351 case 0x7f:
15352 GETBYTE ();
15353 switch (op[2] & 0xe0)
15355 case 0x00:
15356 goto op_semantics_124;
15357 break;
15358 default: UNSUPPORTED(); break;
15360 break;
15361 case 0x80:
15362 GETBYTE ();
15363 switch (op[2] & 0x00)
15365 case 0x00:
15366 op_semantics_136:
15368 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
15369 #line 757 "rx-decode.opc"
15370 int immmm AU = op[1] & 0x1f;
15371 #line 757 "rx-decode.opc"
15372 int rsrc AU = (op[2] >> 4) & 0x0f;
15373 #line 757 "rx-decode.opc"
15374 int rdst AU = op[2] & 0x0f;
15375 if (trace)
15377 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15378 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
15379 op[0], op[1], op[2]);
15380 printf (" immmm = 0x%x,", immmm);
15381 printf (" rsrc = 0x%x,", rsrc);
15382 printf (" rdst = 0x%x\n", rdst);
15384 SYNTAX("shlr #%2, %1, %0");
15385 #line 757 "rx-decode.opc"
15386 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
15388 /*----------------------------------------------------------------------*/
15389 /* ROTATE */
15392 break;
15394 break;
15395 case 0x81:
15396 GETBYTE ();
15397 switch (op[2] & 0x00)
15399 case 0x00:
15400 goto op_semantics_136;
15401 break;
15403 break;
15404 case 0x82:
15405 GETBYTE ();
15406 switch (op[2] & 0x00)
15408 case 0x00:
15409 goto op_semantics_136;
15410 break;
15412 break;
15413 case 0x83:
15414 GETBYTE ();
15415 switch (op[2] & 0x00)
15417 case 0x00:
15418 goto op_semantics_136;
15419 break;
15421 break;
15422 case 0x84:
15423 GETBYTE ();
15424 switch (op[2] & 0x00)
15426 case 0x00:
15427 goto op_semantics_136;
15428 break;
15430 break;
15431 case 0x85:
15432 GETBYTE ();
15433 switch (op[2] & 0x00)
15435 case 0x00:
15436 goto op_semantics_136;
15437 break;
15439 break;
15440 case 0x86:
15441 GETBYTE ();
15442 switch (op[2] & 0x00)
15444 case 0x00:
15445 goto op_semantics_136;
15446 break;
15448 break;
15449 case 0x87:
15450 GETBYTE ();
15451 switch (op[2] & 0x00)
15453 case 0x00:
15454 goto op_semantics_136;
15455 break;
15457 break;
15458 case 0x88:
15459 GETBYTE ();
15460 switch (op[2] & 0x00)
15462 case 0x00:
15463 goto op_semantics_136;
15464 break;
15466 break;
15467 case 0x89:
15468 GETBYTE ();
15469 switch (op[2] & 0x00)
15471 case 0x00:
15472 goto op_semantics_136;
15473 break;
15475 break;
15476 case 0x8a:
15477 GETBYTE ();
15478 switch (op[2] & 0x00)
15480 case 0x00:
15481 goto op_semantics_136;
15482 break;
15484 break;
15485 case 0x8b:
15486 GETBYTE ();
15487 switch (op[2] & 0x00)
15489 case 0x00:
15490 goto op_semantics_136;
15491 break;
15493 break;
15494 case 0x8c:
15495 GETBYTE ();
15496 switch (op[2] & 0x00)
15498 case 0x00:
15499 goto op_semantics_136;
15500 break;
15502 break;
15503 case 0x8d:
15504 GETBYTE ();
15505 switch (op[2] & 0x00)
15507 case 0x00:
15508 goto op_semantics_136;
15509 break;
15511 break;
15512 case 0x8e:
15513 GETBYTE ();
15514 switch (op[2] & 0x00)
15516 case 0x00:
15517 goto op_semantics_136;
15518 break;
15520 break;
15521 case 0x8f:
15522 GETBYTE ();
15523 switch (op[2] & 0x00)
15525 case 0x00:
15526 goto op_semantics_136;
15527 break;
15529 break;
15530 case 0x90:
15531 GETBYTE ();
15532 switch (op[2] & 0x00)
15534 case 0x00:
15535 goto op_semantics_136;
15536 break;
15538 break;
15539 case 0x91:
15540 GETBYTE ();
15541 switch (op[2] & 0x00)
15543 case 0x00:
15544 goto op_semantics_136;
15545 break;
15547 break;
15548 case 0x92:
15549 GETBYTE ();
15550 switch (op[2] & 0x00)
15552 case 0x00:
15553 goto op_semantics_136;
15554 break;
15556 break;
15557 case 0x93:
15558 GETBYTE ();
15559 switch (op[2] & 0x00)
15561 case 0x00:
15562 goto op_semantics_136;
15563 break;
15565 break;
15566 case 0x94:
15567 GETBYTE ();
15568 switch (op[2] & 0x00)
15570 case 0x00:
15571 goto op_semantics_136;
15572 break;
15574 break;
15575 case 0x95:
15576 GETBYTE ();
15577 switch (op[2] & 0x00)
15579 case 0x00:
15580 goto op_semantics_136;
15581 break;
15583 break;
15584 case 0x96:
15585 GETBYTE ();
15586 switch (op[2] & 0x00)
15588 case 0x00:
15589 goto op_semantics_136;
15590 break;
15592 break;
15593 case 0x97:
15594 GETBYTE ();
15595 switch (op[2] & 0x00)
15597 case 0x00:
15598 goto op_semantics_136;
15599 break;
15601 break;
15602 case 0x98:
15603 GETBYTE ();
15604 switch (op[2] & 0x00)
15606 case 0x00:
15607 goto op_semantics_136;
15608 break;
15610 break;
15611 case 0x99:
15612 GETBYTE ();
15613 switch (op[2] & 0x00)
15615 case 0x00:
15616 goto op_semantics_136;
15617 break;
15619 break;
15620 case 0x9a:
15621 GETBYTE ();
15622 switch (op[2] & 0x00)
15624 case 0x00:
15625 goto op_semantics_136;
15626 break;
15628 break;
15629 case 0x9b:
15630 GETBYTE ();
15631 switch (op[2] & 0x00)
15633 case 0x00:
15634 goto op_semantics_136;
15635 break;
15637 break;
15638 case 0x9c:
15639 GETBYTE ();
15640 switch (op[2] & 0x00)
15642 case 0x00:
15643 goto op_semantics_136;
15644 break;
15646 break;
15647 case 0x9d:
15648 GETBYTE ();
15649 switch (op[2] & 0x00)
15651 case 0x00:
15652 goto op_semantics_136;
15653 break;
15655 break;
15656 case 0x9e:
15657 GETBYTE ();
15658 switch (op[2] & 0x00)
15660 case 0x00:
15661 goto op_semantics_136;
15662 break;
15664 break;
15665 case 0x9f:
15666 GETBYTE ();
15667 switch (op[2] & 0x00)
15669 case 0x00:
15670 goto op_semantics_136;
15671 break;
15673 break;
15674 case 0xa0:
15675 GETBYTE ();
15676 switch (op[2] & 0x00)
15678 case 0x00:
15679 op_semantics_137:
15681 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
15682 #line 747 "rx-decode.opc"
15683 int immmm AU = op[1] & 0x1f;
15684 #line 747 "rx-decode.opc"
15685 int rsrc AU = (op[2] >> 4) & 0x0f;
15686 #line 747 "rx-decode.opc"
15687 int rdst AU = op[2] & 0x0f;
15688 if (trace)
15690 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15691 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
15692 op[0], op[1], op[2]);
15693 printf (" immmm = 0x%x,", immmm);
15694 printf (" rsrc = 0x%x,", rsrc);
15695 printf (" rdst = 0x%x\n", rdst);
15697 SYNTAX("shar #%2, %1, %0");
15698 #line 747 "rx-decode.opc"
15699 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
15703 break;
15705 break;
15706 case 0xa1:
15707 GETBYTE ();
15708 switch (op[2] & 0x00)
15710 case 0x00:
15711 goto op_semantics_137;
15712 break;
15714 break;
15715 case 0xa2:
15716 GETBYTE ();
15717 switch (op[2] & 0x00)
15719 case 0x00:
15720 goto op_semantics_137;
15721 break;
15723 break;
15724 case 0xa3:
15725 GETBYTE ();
15726 switch (op[2] & 0x00)
15728 case 0x00:
15729 goto op_semantics_137;
15730 break;
15732 break;
15733 case 0xa4:
15734 GETBYTE ();
15735 switch (op[2] & 0x00)
15737 case 0x00:
15738 goto op_semantics_137;
15739 break;
15741 break;
15742 case 0xa5:
15743 GETBYTE ();
15744 switch (op[2] & 0x00)
15746 case 0x00:
15747 goto op_semantics_137;
15748 break;
15750 break;
15751 case 0xa6:
15752 GETBYTE ();
15753 switch (op[2] & 0x00)
15755 case 0x00:
15756 goto op_semantics_137;
15757 break;
15759 break;
15760 case 0xa7:
15761 GETBYTE ();
15762 switch (op[2] & 0x00)
15764 case 0x00:
15765 goto op_semantics_137;
15766 break;
15768 break;
15769 case 0xa8:
15770 GETBYTE ();
15771 switch (op[2] & 0x00)
15773 case 0x00:
15774 goto op_semantics_137;
15775 break;
15777 break;
15778 case 0xa9:
15779 GETBYTE ();
15780 switch (op[2] & 0x00)
15782 case 0x00:
15783 goto op_semantics_137;
15784 break;
15786 break;
15787 case 0xaa:
15788 GETBYTE ();
15789 switch (op[2] & 0x00)
15791 case 0x00:
15792 goto op_semantics_137;
15793 break;
15795 break;
15796 case 0xab:
15797 GETBYTE ();
15798 switch (op[2] & 0x00)
15800 case 0x00:
15801 goto op_semantics_137;
15802 break;
15804 break;
15805 case 0xac:
15806 GETBYTE ();
15807 switch (op[2] & 0x00)
15809 case 0x00:
15810 goto op_semantics_137;
15811 break;
15813 break;
15814 case 0xad:
15815 GETBYTE ();
15816 switch (op[2] & 0x00)
15818 case 0x00:
15819 goto op_semantics_137;
15820 break;
15822 break;
15823 case 0xae:
15824 GETBYTE ();
15825 switch (op[2] & 0x00)
15827 case 0x00:
15828 goto op_semantics_137;
15829 break;
15831 break;
15832 case 0xaf:
15833 GETBYTE ();
15834 switch (op[2] & 0x00)
15836 case 0x00:
15837 goto op_semantics_137;
15838 break;
15840 break;
15841 case 0xb0:
15842 GETBYTE ();
15843 switch (op[2] & 0x00)
15845 case 0x00:
15846 goto op_semantics_137;
15847 break;
15849 break;
15850 case 0xb1:
15851 GETBYTE ();
15852 switch (op[2] & 0x00)
15854 case 0x00:
15855 goto op_semantics_137;
15856 break;
15858 break;
15859 case 0xb2:
15860 GETBYTE ();
15861 switch (op[2] & 0x00)
15863 case 0x00:
15864 goto op_semantics_137;
15865 break;
15867 break;
15868 case 0xb3:
15869 GETBYTE ();
15870 switch (op[2] & 0x00)
15872 case 0x00:
15873 goto op_semantics_137;
15874 break;
15876 break;
15877 case 0xb4:
15878 GETBYTE ();
15879 switch (op[2] & 0x00)
15881 case 0x00:
15882 goto op_semantics_137;
15883 break;
15885 break;
15886 case 0xb5:
15887 GETBYTE ();
15888 switch (op[2] & 0x00)
15890 case 0x00:
15891 goto op_semantics_137;
15892 break;
15894 break;
15895 case 0xb6:
15896 GETBYTE ();
15897 switch (op[2] & 0x00)
15899 case 0x00:
15900 goto op_semantics_137;
15901 break;
15903 break;
15904 case 0xb7:
15905 GETBYTE ();
15906 switch (op[2] & 0x00)
15908 case 0x00:
15909 goto op_semantics_137;
15910 break;
15912 break;
15913 case 0xb8:
15914 GETBYTE ();
15915 switch (op[2] & 0x00)
15917 case 0x00:
15918 goto op_semantics_137;
15919 break;
15921 break;
15922 case 0xb9:
15923 GETBYTE ();
15924 switch (op[2] & 0x00)
15926 case 0x00:
15927 goto op_semantics_137;
15928 break;
15930 break;
15931 case 0xba:
15932 GETBYTE ();
15933 switch (op[2] & 0x00)
15935 case 0x00:
15936 goto op_semantics_137;
15937 break;
15939 break;
15940 case 0xbb:
15941 GETBYTE ();
15942 switch (op[2] & 0x00)
15944 case 0x00:
15945 goto op_semantics_137;
15946 break;
15948 break;
15949 case 0xbc:
15950 GETBYTE ();
15951 switch (op[2] & 0x00)
15953 case 0x00:
15954 goto op_semantics_137;
15955 break;
15957 break;
15958 case 0xbd:
15959 GETBYTE ();
15960 switch (op[2] & 0x00)
15962 case 0x00:
15963 goto op_semantics_137;
15964 break;
15966 break;
15967 case 0xbe:
15968 GETBYTE ();
15969 switch (op[2] & 0x00)
15971 case 0x00:
15972 goto op_semantics_137;
15973 break;
15975 break;
15976 case 0xbf:
15977 GETBYTE ();
15978 switch (op[2] & 0x00)
15980 case 0x00:
15981 goto op_semantics_137;
15982 break;
15984 break;
15985 case 0xc0:
15986 GETBYTE ();
15987 switch (op[2] & 0x00)
15989 case 0x00:
15990 op_semantics_138:
15992 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
15993 #line 737 "rx-decode.opc"
15994 int immmm AU = op[1] & 0x1f;
15995 #line 737 "rx-decode.opc"
15996 int rsrc AU = (op[2] >> 4) & 0x0f;
15997 #line 737 "rx-decode.opc"
15998 int rdst AU = op[2] & 0x0f;
15999 if (trace)
16001 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16002 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
16003 op[0], op[1], op[2]);
16004 printf (" immmm = 0x%x,", immmm);
16005 printf (" rsrc = 0x%x,", rsrc);
16006 printf (" rdst = 0x%x\n", rdst);
16008 SYNTAX("shll #%2, %1, %0");
16009 #line 737 "rx-decode.opc"
16010 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
16014 break;
16016 break;
16017 case 0xc1:
16018 GETBYTE ();
16019 switch (op[2] & 0x00)
16021 case 0x00:
16022 goto op_semantics_138;
16023 break;
16025 break;
16026 case 0xc2:
16027 GETBYTE ();
16028 switch (op[2] & 0x00)
16030 case 0x00:
16031 goto op_semantics_138;
16032 break;
16034 break;
16035 case 0xc3:
16036 GETBYTE ();
16037 switch (op[2] & 0x00)
16039 case 0x00:
16040 goto op_semantics_138;
16041 break;
16043 break;
16044 case 0xc4:
16045 GETBYTE ();
16046 switch (op[2] & 0x00)
16048 case 0x00:
16049 goto op_semantics_138;
16050 break;
16052 break;
16053 case 0xc5:
16054 GETBYTE ();
16055 switch (op[2] & 0x00)
16057 case 0x00:
16058 goto op_semantics_138;
16059 break;
16061 break;
16062 case 0xc6:
16063 GETBYTE ();
16064 switch (op[2] & 0x00)
16066 case 0x00:
16067 goto op_semantics_138;
16068 break;
16070 break;
16071 case 0xc7:
16072 GETBYTE ();
16073 switch (op[2] & 0x00)
16075 case 0x00:
16076 goto op_semantics_138;
16077 break;
16079 break;
16080 case 0xc8:
16081 GETBYTE ();
16082 switch (op[2] & 0x00)
16084 case 0x00:
16085 goto op_semantics_138;
16086 break;
16088 break;
16089 case 0xc9:
16090 GETBYTE ();
16091 switch (op[2] & 0x00)
16093 case 0x00:
16094 goto op_semantics_138;
16095 break;
16097 break;
16098 case 0xca:
16099 GETBYTE ();
16100 switch (op[2] & 0x00)
16102 case 0x00:
16103 goto op_semantics_138;
16104 break;
16106 break;
16107 case 0xcb:
16108 GETBYTE ();
16109 switch (op[2] & 0x00)
16111 case 0x00:
16112 goto op_semantics_138;
16113 break;
16115 break;
16116 case 0xcc:
16117 GETBYTE ();
16118 switch (op[2] & 0x00)
16120 case 0x00:
16121 goto op_semantics_138;
16122 break;
16124 break;
16125 case 0xcd:
16126 GETBYTE ();
16127 switch (op[2] & 0x00)
16129 case 0x00:
16130 goto op_semantics_138;
16131 break;
16133 break;
16134 case 0xce:
16135 GETBYTE ();
16136 switch (op[2] & 0x00)
16138 case 0x00:
16139 goto op_semantics_138;
16140 break;
16142 break;
16143 case 0xcf:
16144 GETBYTE ();
16145 switch (op[2] & 0x00)
16147 case 0x00:
16148 goto op_semantics_138;
16149 break;
16151 break;
16152 case 0xd0:
16153 GETBYTE ();
16154 switch (op[2] & 0x00)
16156 case 0x00:
16157 goto op_semantics_138;
16158 break;
16160 break;
16161 case 0xd1:
16162 GETBYTE ();
16163 switch (op[2] & 0x00)
16165 case 0x00:
16166 goto op_semantics_138;
16167 break;
16169 break;
16170 case 0xd2:
16171 GETBYTE ();
16172 switch (op[2] & 0x00)
16174 case 0x00:
16175 goto op_semantics_138;
16176 break;
16178 break;
16179 case 0xd3:
16180 GETBYTE ();
16181 switch (op[2] & 0x00)
16183 case 0x00:
16184 goto op_semantics_138;
16185 break;
16187 break;
16188 case 0xd4:
16189 GETBYTE ();
16190 switch (op[2] & 0x00)
16192 case 0x00:
16193 goto op_semantics_138;
16194 break;
16196 break;
16197 case 0xd5:
16198 GETBYTE ();
16199 switch (op[2] & 0x00)
16201 case 0x00:
16202 goto op_semantics_138;
16203 break;
16205 break;
16206 case 0xd6:
16207 GETBYTE ();
16208 switch (op[2] & 0x00)
16210 case 0x00:
16211 goto op_semantics_138;
16212 break;
16214 break;
16215 case 0xd7:
16216 GETBYTE ();
16217 switch (op[2] & 0x00)
16219 case 0x00:
16220 goto op_semantics_138;
16221 break;
16223 break;
16224 case 0xd8:
16225 GETBYTE ();
16226 switch (op[2] & 0x00)
16228 case 0x00:
16229 goto op_semantics_138;
16230 break;
16232 break;
16233 case 0xd9:
16234 GETBYTE ();
16235 switch (op[2] & 0x00)
16237 case 0x00:
16238 goto op_semantics_138;
16239 break;
16241 break;
16242 case 0xda:
16243 GETBYTE ();
16244 switch (op[2] & 0x00)
16246 case 0x00:
16247 goto op_semantics_138;
16248 break;
16250 break;
16251 case 0xdb:
16252 GETBYTE ();
16253 switch (op[2] & 0x00)
16255 case 0x00:
16256 goto op_semantics_138;
16257 break;
16259 break;
16260 case 0xdc:
16261 GETBYTE ();
16262 switch (op[2] & 0x00)
16264 case 0x00:
16265 goto op_semantics_138;
16266 break;
16268 break;
16269 case 0xdd:
16270 GETBYTE ();
16271 switch (op[2] & 0x00)
16273 case 0x00:
16274 goto op_semantics_138;
16275 break;
16277 break;
16278 case 0xde:
16279 GETBYTE ();
16280 switch (op[2] & 0x00)
16282 case 0x00:
16283 goto op_semantics_138;
16284 break;
16286 break;
16287 case 0xdf:
16288 GETBYTE ();
16289 switch (op[2] & 0x00)
16291 case 0x00:
16292 goto op_semantics_138;
16293 break;
16295 break;
16296 case 0xe0:
16297 GETBYTE ();
16298 switch (op[2] & 0xf0)
16300 case 0x00:
16301 case 0x10:
16302 case 0x20:
16303 case 0x30:
16304 case 0x40:
16305 case 0x50:
16306 case 0x60:
16307 case 0x70:
16308 case 0x80:
16309 case 0x90:
16310 case 0xa0:
16311 case 0xb0:
16312 case 0xc0:
16313 case 0xd0:
16314 case 0xe0:
16315 op_semantics_139:
16317 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
16318 #line 1011 "rx-decode.opc"
16319 int bittt AU = op[1] & 0x1f;
16320 #line 1011 "rx-decode.opc"
16321 int cond AU = (op[2] >> 4) & 0x0f;
16322 #line 1011 "rx-decode.opc"
16323 int rdst AU = op[2] & 0x0f;
16324 if (trace)
16326 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16327 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
16328 op[0], op[1], op[2]);
16329 printf (" bittt = 0x%x,", bittt);
16330 printf (" cond = 0x%x,", cond);
16331 printf (" rdst = 0x%x\n", rdst);
16333 SYNTAX("bm%2 #%1, %0%S0");
16334 #line 1011 "rx-decode.opc"
16335 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
16337 /*----------------------------------------------------------------------*/
16338 /* CONTROL REGISTERS */
16341 break;
16342 case 0xf0:
16343 op_semantics_140:
16345 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
16346 #line 1004 "rx-decode.opc"
16347 int bittt AU = op[1] & 0x1f;
16348 #line 1004 "rx-decode.opc"
16349 int rdst AU = op[2] & 0x0f;
16350 if (trace)
16352 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16353 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
16354 op[0], op[1], op[2]);
16355 printf (" bittt = 0x%x,", bittt);
16356 printf (" rdst = 0x%x\n", rdst);
16358 SYNTAX("bnot #%1, %0");
16359 #line 1004 "rx-decode.opc"
16360 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
16364 break;
16366 break;
16367 case 0xe1:
16368 GETBYTE ();
16369 switch (op[2] & 0xf0)
16371 case 0x00:
16372 case 0x10:
16373 case 0x20:
16374 case 0x30:
16375 case 0x40:
16376 case 0x50:
16377 case 0x60:
16378 case 0x70:
16379 case 0x80:
16380 case 0x90:
16381 case 0xa0:
16382 case 0xb0:
16383 case 0xc0:
16384 case 0xd0:
16385 case 0xe0:
16386 goto op_semantics_139;
16387 break;
16388 case 0xf0:
16389 goto op_semantics_140;
16390 break;
16392 break;
16393 case 0xe2:
16394 GETBYTE ();
16395 switch (op[2] & 0xf0)
16397 case 0x00:
16398 case 0x10:
16399 case 0x20:
16400 case 0x30:
16401 case 0x40:
16402 case 0x50:
16403 case 0x60:
16404 case 0x70:
16405 case 0x80:
16406 case 0x90:
16407 case 0xa0:
16408 case 0xb0:
16409 case 0xc0:
16410 case 0xd0:
16411 case 0xe0:
16412 goto op_semantics_139;
16413 break;
16414 case 0xf0:
16415 goto op_semantics_140;
16416 break;
16418 break;
16419 case 0xe3:
16420 GETBYTE ();
16421 switch (op[2] & 0xf0)
16423 case 0x00:
16424 case 0x10:
16425 case 0x20:
16426 case 0x30:
16427 case 0x40:
16428 case 0x50:
16429 case 0x60:
16430 case 0x70:
16431 case 0x80:
16432 case 0x90:
16433 case 0xa0:
16434 case 0xb0:
16435 case 0xc0:
16436 case 0xd0:
16437 case 0xe0:
16438 goto op_semantics_139;
16439 break;
16440 case 0xf0:
16441 goto op_semantics_140;
16442 break;
16444 break;
16445 case 0xe4:
16446 GETBYTE ();
16447 switch (op[2] & 0xf0)
16449 case 0x00:
16450 case 0x10:
16451 case 0x20:
16452 case 0x30:
16453 case 0x40:
16454 case 0x50:
16455 case 0x60:
16456 case 0x70:
16457 case 0x80:
16458 case 0x90:
16459 case 0xa0:
16460 case 0xb0:
16461 case 0xc0:
16462 case 0xd0:
16463 case 0xe0:
16464 goto op_semantics_139;
16465 break;
16466 case 0xf0:
16467 goto op_semantics_140;
16468 break;
16470 break;
16471 case 0xe5:
16472 GETBYTE ();
16473 switch (op[2] & 0xf0)
16475 case 0x00:
16476 case 0x10:
16477 case 0x20:
16478 case 0x30:
16479 case 0x40:
16480 case 0x50:
16481 case 0x60:
16482 case 0x70:
16483 case 0x80:
16484 case 0x90:
16485 case 0xa0:
16486 case 0xb0:
16487 case 0xc0:
16488 case 0xd0:
16489 case 0xe0:
16490 goto op_semantics_139;
16491 break;
16492 case 0xf0:
16493 goto op_semantics_140;
16494 break;
16496 break;
16497 case 0xe6:
16498 GETBYTE ();
16499 switch (op[2] & 0xf0)
16501 case 0x00:
16502 case 0x10:
16503 case 0x20:
16504 case 0x30:
16505 case 0x40:
16506 case 0x50:
16507 case 0x60:
16508 case 0x70:
16509 case 0x80:
16510 case 0x90:
16511 case 0xa0:
16512 case 0xb0:
16513 case 0xc0:
16514 case 0xd0:
16515 case 0xe0:
16516 goto op_semantics_139;
16517 break;
16518 case 0xf0:
16519 goto op_semantics_140;
16520 break;
16522 break;
16523 case 0xe7:
16524 GETBYTE ();
16525 switch (op[2] & 0xf0)
16527 case 0x00:
16528 case 0x10:
16529 case 0x20:
16530 case 0x30:
16531 case 0x40:
16532 case 0x50:
16533 case 0x60:
16534 case 0x70:
16535 case 0x80:
16536 case 0x90:
16537 case 0xa0:
16538 case 0xb0:
16539 case 0xc0:
16540 case 0xd0:
16541 case 0xe0:
16542 goto op_semantics_139;
16543 break;
16544 case 0xf0:
16545 goto op_semantics_140;
16546 break;
16548 break;
16549 case 0xe8:
16550 GETBYTE ();
16551 switch (op[2] & 0xf0)
16553 case 0x00:
16554 case 0x10:
16555 case 0x20:
16556 case 0x30:
16557 case 0x40:
16558 case 0x50:
16559 case 0x60:
16560 case 0x70:
16561 case 0x80:
16562 case 0x90:
16563 case 0xa0:
16564 case 0xb0:
16565 case 0xc0:
16566 case 0xd0:
16567 case 0xe0:
16568 goto op_semantics_139;
16569 break;
16570 case 0xf0:
16571 goto op_semantics_140;
16572 break;
16574 break;
16575 case 0xe9:
16576 GETBYTE ();
16577 switch (op[2] & 0xf0)
16579 case 0x00:
16580 case 0x10:
16581 case 0x20:
16582 case 0x30:
16583 case 0x40:
16584 case 0x50:
16585 case 0x60:
16586 case 0x70:
16587 case 0x80:
16588 case 0x90:
16589 case 0xa0:
16590 case 0xb0:
16591 case 0xc0:
16592 case 0xd0:
16593 case 0xe0:
16594 goto op_semantics_139;
16595 break;
16596 case 0xf0:
16597 goto op_semantics_140;
16598 break;
16600 break;
16601 case 0xea:
16602 GETBYTE ();
16603 switch (op[2] & 0xf0)
16605 case 0x00:
16606 case 0x10:
16607 case 0x20:
16608 case 0x30:
16609 case 0x40:
16610 case 0x50:
16611 case 0x60:
16612 case 0x70:
16613 case 0x80:
16614 case 0x90:
16615 case 0xa0:
16616 case 0xb0:
16617 case 0xc0:
16618 case 0xd0:
16619 case 0xe0:
16620 goto op_semantics_139;
16621 break;
16622 case 0xf0:
16623 goto op_semantics_140;
16624 break;
16626 break;
16627 case 0xeb:
16628 GETBYTE ();
16629 switch (op[2] & 0xf0)
16631 case 0x00:
16632 case 0x10:
16633 case 0x20:
16634 case 0x30:
16635 case 0x40:
16636 case 0x50:
16637 case 0x60:
16638 case 0x70:
16639 case 0x80:
16640 case 0x90:
16641 case 0xa0:
16642 case 0xb0:
16643 case 0xc0:
16644 case 0xd0:
16645 case 0xe0:
16646 goto op_semantics_139;
16647 break;
16648 case 0xf0:
16649 goto op_semantics_140;
16650 break;
16652 break;
16653 case 0xec:
16654 GETBYTE ();
16655 switch (op[2] & 0xf0)
16657 case 0x00:
16658 case 0x10:
16659 case 0x20:
16660 case 0x30:
16661 case 0x40:
16662 case 0x50:
16663 case 0x60:
16664 case 0x70:
16665 case 0x80:
16666 case 0x90:
16667 case 0xa0:
16668 case 0xb0:
16669 case 0xc0:
16670 case 0xd0:
16671 case 0xe0:
16672 goto op_semantics_139;
16673 break;
16674 case 0xf0:
16675 goto op_semantics_140;
16676 break;
16678 break;
16679 case 0xed:
16680 GETBYTE ();
16681 switch (op[2] & 0xf0)
16683 case 0x00:
16684 case 0x10:
16685 case 0x20:
16686 case 0x30:
16687 case 0x40:
16688 case 0x50:
16689 case 0x60:
16690 case 0x70:
16691 case 0x80:
16692 case 0x90:
16693 case 0xa0:
16694 case 0xb0:
16695 case 0xc0:
16696 case 0xd0:
16697 case 0xe0:
16698 goto op_semantics_139;
16699 break;
16700 case 0xf0:
16701 goto op_semantics_140;
16702 break;
16704 break;
16705 case 0xee:
16706 GETBYTE ();
16707 switch (op[2] & 0xf0)
16709 case 0x00:
16710 case 0x10:
16711 case 0x20:
16712 case 0x30:
16713 case 0x40:
16714 case 0x50:
16715 case 0x60:
16716 case 0x70:
16717 case 0x80:
16718 case 0x90:
16719 case 0xa0:
16720 case 0xb0:
16721 case 0xc0:
16722 case 0xd0:
16723 case 0xe0:
16724 goto op_semantics_139;
16725 break;
16726 case 0xf0:
16727 goto op_semantics_140;
16728 break;
16730 break;
16731 case 0xef:
16732 GETBYTE ();
16733 switch (op[2] & 0xf0)
16735 case 0x00:
16736 case 0x10:
16737 case 0x20:
16738 case 0x30:
16739 case 0x40:
16740 case 0x50:
16741 case 0x60:
16742 case 0x70:
16743 case 0x80:
16744 case 0x90:
16745 case 0xa0:
16746 case 0xb0:
16747 case 0xc0:
16748 case 0xd0:
16749 case 0xe0:
16750 goto op_semantics_139;
16751 break;
16752 case 0xf0:
16753 goto op_semantics_140;
16754 break;
16756 break;
16757 case 0xf0:
16758 GETBYTE ();
16759 switch (op[2] & 0xf0)
16761 case 0x00:
16762 case 0x10:
16763 case 0x20:
16764 case 0x30:
16765 case 0x40:
16766 case 0x50:
16767 case 0x60:
16768 case 0x70:
16769 case 0x80:
16770 case 0x90:
16771 case 0xa0:
16772 case 0xb0:
16773 case 0xc0:
16774 case 0xd0:
16775 case 0xe0:
16776 goto op_semantics_139;
16777 break;
16778 case 0xf0:
16779 goto op_semantics_140;
16780 break;
16782 break;
16783 case 0xf1:
16784 GETBYTE ();
16785 switch (op[2] & 0xf0)
16787 case 0x00:
16788 case 0x10:
16789 case 0x20:
16790 case 0x30:
16791 case 0x40:
16792 case 0x50:
16793 case 0x60:
16794 case 0x70:
16795 case 0x80:
16796 case 0x90:
16797 case 0xa0:
16798 case 0xb0:
16799 case 0xc0:
16800 case 0xd0:
16801 case 0xe0:
16802 goto op_semantics_139;
16803 break;
16804 case 0xf0:
16805 goto op_semantics_140;
16806 break;
16808 break;
16809 case 0xf2:
16810 GETBYTE ();
16811 switch (op[2] & 0xf0)
16813 case 0x00:
16814 case 0x10:
16815 case 0x20:
16816 case 0x30:
16817 case 0x40:
16818 case 0x50:
16819 case 0x60:
16820 case 0x70:
16821 case 0x80:
16822 case 0x90:
16823 case 0xa0:
16824 case 0xb0:
16825 case 0xc0:
16826 case 0xd0:
16827 case 0xe0:
16828 goto op_semantics_139;
16829 break;
16830 case 0xf0:
16831 goto op_semantics_140;
16832 break;
16834 break;
16835 case 0xf3:
16836 GETBYTE ();
16837 switch (op[2] & 0xf0)
16839 case 0x00:
16840 case 0x10:
16841 case 0x20:
16842 case 0x30:
16843 case 0x40:
16844 case 0x50:
16845 case 0x60:
16846 case 0x70:
16847 case 0x80:
16848 case 0x90:
16849 case 0xa0:
16850 case 0xb0:
16851 case 0xc0:
16852 case 0xd0:
16853 case 0xe0:
16854 goto op_semantics_139;
16855 break;
16856 case 0xf0:
16857 goto op_semantics_140;
16858 break;
16860 break;
16861 case 0xf4:
16862 GETBYTE ();
16863 switch (op[2] & 0xf0)
16865 case 0x00:
16866 case 0x10:
16867 case 0x20:
16868 case 0x30:
16869 case 0x40:
16870 case 0x50:
16871 case 0x60:
16872 case 0x70:
16873 case 0x80:
16874 case 0x90:
16875 case 0xa0:
16876 case 0xb0:
16877 case 0xc0:
16878 case 0xd0:
16879 case 0xe0:
16880 goto op_semantics_139;
16881 break;
16882 case 0xf0:
16883 goto op_semantics_140;
16884 break;
16886 break;
16887 case 0xf5:
16888 GETBYTE ();
16889 switch (op[2] & 0xf0)
16891 case 0x00:
16892 case 0x10:
16893 case 0x20:
16894 case 0x30:
16895 case 0x40:
16896 case 0x50:
16897 case 0x60:
16898 case 0x70:
16899 case 0x80:
16900 case 0x90:
16901 case 0xa0:
16902 case 0xb0:
16903 case 0xc0:
16904 case 0xd0:
16905 case 0xe0:
16906 goto op_semantics_139;
16907 break;
16908 case 0xf0:
16909 goto op_semantics_140;
16910 break;
16912 break;
16913 case 0xf6:
16914 GETBYTE ();
16915 switch (op[2] & 0xf0)
16917 case 0x00:
16918 case 0x10:
16919 case 0x20:
16920 case 0x30:
16921 case 0x40:
16922 case 0x50:
16923 case 0x60:
16924 case 0x70:
16925 case 0x80:
16926 case 0x90:
16927 case 0xa0:
16928 case 0xb0:
16929 case 0xc0:
16930 case 0xd0:
16931 case 0xe0:
16932 goto op_semantics_139;
16933 break;
16934 case 0xf0:
16935 goto op_semantics_140;
16936 break;
16938 break;
16939 case 0xf7:
16940 GETBYTE ();
16941 switch (op[2] & 0xf0)
16943 case 0x00:
16944 case 0x10:
16945 case 0x20:
16946 case 0x30:
16947 case 0x40:
16948 case 0x50:
16949 case 0x60:
16950 case 0x70:
16951 case 0x80:
16952 case 0x90:
16953 case 0xa0:
16954 case 0xb0:
16955 case 0xc0:
16956 case 0xd0:
16957 case 0xe0:
16958 goto op_semantics_139;
16959 break;
16960 case 0xf0:
16961 goto op_semantics_140;
16962 break;
16964 break;
16965 case 0xf8:
16966 GETBYTE ();
16967 switch (op[2] & 0xf0)
16969 case 0x00:
16970 case 0x10:
16971 case 0x20:
16972 case 0x30:
16973 case 0x40:
16974 case 0x50:
16975 case 0x60:
16976 case 0x70:
16977 case 0x80:
16978 case 0x90:
16979 case 0xa0:
16980 case 0xb0:
16981 case 0xc0:
16982 case 0xd0:
16983 case 0xe0:
16984 goto op_semantics_139;
16985 break;
16986 case 0xf0:
16987 goto op_semantics_140;
16988 break;
16990 break;
16991 case 0xf9:
16992 GETBYTE ();
16993 switch (op[2] & 0xf0)
16995 case 0x00:
16996 case 0x10:
16997 case 0x20:
16998 case 0x30:
16999 case 0x40:
17000 case 0x50:
17001 case 0x60:
17002 case 0x70:
17003 case 0x80:
17004 case 0x90:
17005 case 0xa0:
17006 case 0xb0:
17007 case 0xc0:
17008 case 0xd0:
17009 case 0xe0:
17010 goto op_semantics_139;
17011 break;
17012 case 0xf0:
17013 goto op_semantics_140;
17014 break;
17016 break;
17017 case 0xfa:
17018 GETBYTE ();
17019 switch (op[2] & 0xf0)
17021 case 0x00:
17022 case 0x10:
17023 case 0x20:
17024 case 0x30:
17025 case 0x40:
17026 case 0x50:
17027 case 0x60:
17028 case 0x70:
17029 case 0x80:
17030 case 0x90:
17031 case 0xa0:
17032 case 0xb0:
17033 case 0xc0:
17034 case 0xd0:
17035 case 0xe0:
17036 goto op_semantics_139;
17037 break;
17038 case 0xf0:
17039 goto op_semantics_140;
17040 break;
17042 break;
17043 case 0xfb:
17044 GETBYTE ();
17045 switch (op[2] & 0xf0)
17047 case 0x00:
17048 case 0x10:
17049 case 0x20:
17050 case 0x30:
17051 case 0x40:
17052 case 0x50:
17053 case 0x60:
17054 case 0x70:
17055 case 0x80:
17056 case 0x90:
17057 case 0xa0:
17058 case 0xb0:
17059 case 0xc0:
17060 case 0xd0:
17061 case 0xe0:
17062 goto op_semantics_139;
17063 break;
17064 case 0xf0:
17065 goto op_semantics_140;
17066 break;
17068 break;
17069 case 0xfc:
17070 GETBYTE ();
17071 switch (op[2] & 0xf0)
17073 case 0x00:
17074 case 0x10:
17075 case 0x20:
17076 case 0x30:
17077 case 0x40:
17078 case 0x50:
17079 case 0x60:
17080 case 0x70:
17081 case 0x80:
17082 case 0x90:
17083 case 0xa0:
17084 case 0xb0:
17085 case 0xc0:
17086 case 0xd0:
17087 case 0xe0:
17088 goto op_semantics_139;
17089 break;
17090 case 0xf0:
17091 goto op_semantics_140;
17092 break;
17094 break;
17095 case 0xfd:
17096 GETBYTE ();
17097 switch (op[2] & 0xf0)
17099 case 0x00:
17100 case 0x10:
17101 case 0x20:
17102 case 0x30:
17103 case 0x40:
17104 case 0x50:
17105 case 0x60:
17106 case 0x70:
17107 case 0x80:
17108 case 0x90:
17109 case 0xa0:
17110 case 0xb0:
17111 case 0xc0:
17112 case 0xd0:
17113 case 0xe0:
17114 goto op_semantics_139;
17115 break;
17116 case 0xf0:
17117 goto op_semantics_140;
17118 break;
17120 break;
17121 case 0xfe:
17122 GETBYTE ();
17123 switch (op[2] & 0xf0)
17125 case 0x00:
17126 case 0x10:
17127 case 0x20:
17128 case 0x30:
17129 case 0x40:
17130 case 0x50:
17131 case 0x60:
17132 case 0x70:
17133 case 0x80:
17134 case 0x90:
17135 case 0xa0:
17136 case 0xb0:
17137 case 0xc0:
17138 case 0xd0:
17139 case 0xe0:
17140 goto op_semantics_139;
17141 break;
17142 case 0xf0:
17143 goto op_semantics_140;
17144 break;
17146 break;
17147 case 0xff:
17148 GETBYTE ();
17149 switch (op[2] & 0xf0)
17151 case 0x00:
17152 case 0x10:
17153 case 0x20:
17154 case 0x30:
17155 case 0x40:
17156 case 0x50:
17157 case 0x60:
17158 case 0x70:
17159 case 0x80:
17160 case 0x90:
17161 case 0xa0:
17162 case 0xb0:
17163 case 0xc0:
17164 case 0xd0:
17165 case 0xe0:
17166 goto op_semantics_139;
17167 break;
17168 case 0xf0:
17169 goto op_semantics_140;
17170 break;
17172 break;
17173 default: UNSUPPORTED(); break;
17175 break;
17176 case 0xfe:
17177 GETBYTE ();
17178 switch (op[1] & 0xff)
17180 case 0x00:
17181 GETBYTE ();
17182 switch (op[2] & 0x00)
17184 case 0x00:
17185 op_semantics_141:
17187 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
17188 #line 363 "rx-decode.opc"
17189 int sz AU = (op[1] >> 4) & 0x03;
17190 #line 363 "rx-decode.opc"
17191 int isrc AU = op[1] & 0x0f;
17192 #line 363 "rx-decode.opc"
17193 int bsrc AU = (op[2] >> 4) & 0x0f;
17194 #line 363 "rx-decode.opc"
17195 int rdst AU = op[2] & 0x0f;
17196 if (trace)
17198 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
17199 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
17200 op[0], op[1], op[2]);
17201 printf (" sz = 0x%x,", sz);
17202 printf (" isrc = 0x%x,", isrc);
17203 printf (" bsrc = 0x%x,", bsrc);
17204 printf (" rdst = 0x%x\n", rdst);
17206 SYNTAX("mov%s %0, [%1, %2]");
17207 #line 363 "rx-decode.opc"
17208 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17211 break;
17213 break;
17214 case 0x01:
17215 GETBYTE ();
17216 switch (op[2] & 0x00)
17218 case 0x00:
17219 goto op_semantics_141;
17220 break;
17222 break;
17223 case 0x02:
17224 GETBYTE ();
17225 switch (op[2] & 0x00)
17227 case 0x00:
17228 goto op_semantics_141;
17229 break;
17231 break;
17232 case 0x03:
17233 GETBYTE ();
17234 switch (op[2] & 0x00)
17236 case 0x00:
17237 goto op_semantics_141;
17238 break;
17240 break;
17241 case 0x04:
17242 GETBYTE ();
17243 switch (op[2] & 0x00)
17245 case 0x00:
17246 goto op_semantics_141;
17247 break;
17249 break;
17250 case 0x05:
17251 GETBYTE ();
17252 switch (op[2] & 0x00)
17254 case 0x00:
17255 goto op_semantics_141;
17256 break;
17258 break;
17259 case 0x06:
17260 GETBYTE ();
17261 switch (op[2] & 0x00)
17263 case 0x00:
17264 goto op_semantics_141;
17265 break;
17267 break;
17268 case 0x07:
17269 GETBYTE ();
17270 switch (op[2] & 0x00)
17272 case 0x00:
17273 goto op_semantics_141;
17274 break;
17276 break;
17277 case 0x08:
17278 GETBYTE ();
17279 switch (op[2] & 0x00)
17281 case 0x00:
17282 goto op_semantics_141;
17283 break;
17285 break;
17286 case 0x09:
17287 GETBYTE ();
17288 switch (op[2] & 0x00)
17290 case 0x00:
17291 goto op_semantics_141;
17292 break;
17294 break;
17295 case 0x0a:
17296 GETBYTE ();
17297 switch (op[2] & 0x00)
17299 case 0x00:
17300 goto op_semantics_141;
17301 break;
17303 break;
17304 case 0x0b:
17305 GETBYTE ();
17306 switch (op[2] & 0x00)
17308 case 0x00:
17309 goto op_semantics_141;
17310 break;
17312 break;
17313 case 0x0c:
17314 GETBYTE ();
17315 switch (op[2] & 0x00)
17317 case 0x00:
17318 goto op_semantics_141;
17319 break;
17321 break;
17322 case 0x0d:
17323 GETBYTE ();
17324 switch (op[2] & 0x00)
17326 case 0x00:
17327 goto op_semantics_141;
17328 break;
17330 break;
17331 case 0x0e:
17332 GETBYTE ();
17333 switch (op[2] & 0x00)
17335 case 0x00:
17336 goto op_semantics_141;
17337 break;
17339 break;
17340 case 0x0f:
17341 GETBYTE ();
17342 switch (op[2] & 0x00)
17344 case 0x00:
17345 goto op_semantics_141;
17346 break;
17348 break;
17349 case 0x10:
17350 GETBYTE ();
17351 switch (op[2] & 0x00)
17353 case 0x00:
17354 goto op_semantics_141;
17355 break;
17357 break;
17358 case 0x11:
17359 GETBYTE ();
17360 switch (op[2] & 0x00)
17362 case 0x00:
17363 goto op_semantics_141;
17364 break;
17366 break;
17367 case 0x12:
17368 GETBYTE ();
17369 switch (op[2] & 0x00)
17371 case 0x00:
17372 goto op_semantics_141;
17373 break;
17375 break;
17376 case 0x13:
17377 GETBYTE ();
17378 switch (op[2] & 0x00)
17380 case 0x00:
17381 goto op_semantics_141;
17382 break;
17384 break;
17385 case 0x14:
17386 GETBYTE ();
17387 switch (op[2] & 0x00)
17389 case 0x00:
17390 goto op_semantics_141;
17391 break;
17393 break;
17394 case 0x15:
17395 GETBYTE ();
17396 switch (op[2] & 0x00)
17398 case 0x00:
17399 goto op_semantics_141;
17400 break;
17402 break;
17403 case 0x16:
17404 GETBYTE ();
17405 switch (op[2] & 0x00)
17407 case 0x00:
17408 goto op_semantics_141;
17409 break;
17411 break;
17412 case 0x17:
17413 GETBYTE ();
17414 switch (op[2] & 0x00)
17416 case 0x00:
17417 goto op_semantics_141;
17418 break;
17420 break;
17421 case 0x18:
17422 GETBYTE ();
17423 switch (op[2] & 0x00)
17425 case 0x00:
17426 goto op_semantics_141;
17427 break;
17429 break;
17430 case 0x19:
17431 GETBYTE ();
17432 switch (op[2] & 0x00)
17434 case 0x00:
17435 goto op_semantics_141;
17436 break;
17438 break;
17439 case 0x1a:
17440 GETBYTE ();
17441 switch (op[2] & 0x00)
17443 case 0x00:
17444 goto op_semantics_141;
17445 break;
17447 break;
17448 case 0x1b:
17449 GETBYTE ();
17450 switch (op[2] & 0x00)
17452 case 0x00:
17453 goto op_semantics_141;
17454 break;
17456 break;
17457 case 0x1c:
17458 GETBYTE ();
17459 switch (op[2] & 0x00)
17461 case 0x00:
17462 goto op_semantics_141;
17463 break;
17465 break;
17466 case 0x1d:
17467 GETBYTE ();
17468 switch (op[2] & 0x00)
17470 case 0x00:
17471 goto op_semantics_141;
17472 break;
17474 break;
17475 case 0x1e:
17476 GETBYTE ();
17477 switch (op[2] & 0x00)
17479 case 0x00:
17480 goto op_semantics_141;
17481 break;
17483 break;
17484 case 0x1f:
17485 GETBYTE ();
17486 switch (op[2] & 0x00)
17488 case 0x00:
17489 goto op_semantics_141;
17490 break;
17492 break;
17493 case 0x20:
17494 GETBYTE ();
17495 switch (op[2] & 0x00)
17497 case 0x00:
17498 goto op_semantics_141;
17499 break;
17501 break;
17502 case 0x21:
17503 GETBYTE ();
17504 switch (op[2] & 0x00)
17506 case 0x00:
17507 goto op_semantics_141;
17508 break;
17510 break;
17511 case 0x22:
17512 GETBYTE ();
17513 switch (op[2] & 0x00)
17515 case 0x00:
17516 goto op_semantics_141;
17517 break;
17519 break;
17520 case 0x23:
17521 GETBYTE ();
17522 switch (op[2] & 0x00)
17524 case 0x00:
17525 goto op_semantics_141;
17526 break;
17528 break;
17529 case 0x24:
17530 GETBYTE ();
17531 switch (op[2] & 0x00)
17533 case 0x00:
17534 goto op_semantics_141;
17535 break;
17537 break;
17538 case 0x25:
17539 GETBYTE ();
17540 switch (op[2] & 0x00)
17542 case 0x00:
17543 goto op_semantics_141;
17544 break;
17546 break;
17547 case 0x26:
17548 GETBYTE ();
17549 switch (op[2] & 0x00)
17551 case 0x00:
17552 goto op_semantics_141;
17553 break;
17555 break;
17556 case 0x27:
17557 GETBYTE ();
17558 switch (op[2] & 0x00)
17560 case 0x00:
17561 goto op_semantics_141;
17562 break;
17564 break;
17565 case 0x28:
17566 GETBYTE ();
17567 switch (op[2] & 0x00)
17569 case 0x00:
17570 goto op_semantics_141;
17571 break;
17573 break;
17574 case 0x29:
17575 GETBYTE ();
17576 switch (op[2] & 0x00)
17578 case 0x00:
17579 goto op_semantics_141;
17580 break;
17582 break;
17583 case 0x2a:
17584 GETBYTE ();
17585 switch (op[2] & 0x00)
17587 case 0x00:
17588 goto op_semantics_141;
17589 break;
17591 break;
17592 case 0x2b:
17593 GETBYTE ();
17594 switch (op[2] & 0x00)
17596 case 0x00:
17597 goto op_semantics_141;
17598 break;
17600 break;
17601 case 0x2c:
17602 GETBYTE ();
17603 switch (op[2] & 0x00)
17605 case 0x00:
17606 goto op_semantics_141;
17607 break;
17609 break;
17610 case 0x2d:
17611 GETBYTE ();
17612 switch (op[2] & 0x00)
17614 case 0x00:
17615 goto op_semantics_141;
17616 break;
17618 break;
17619 case 0x2e:
17620 GETBYTE ();
17621 switch (op[2] & 0x00)
17623 case 0x00:
17624 goto op_semantics_141;
17625 break;
17627 break;
17628 case 0x2f:
17629 GETBYTE ();
17630 switch (op[2] & 0x00)
17632 case 0x00:
17633 goto op_semantics_141;
17634 break;
17636 break;
17637 case 0x40:
17638 GETBYTE ();
17639 switch (op[2] & 0x00)
17641 case 0x00:
17642 op_semantics_142:
17644 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
17645 #line 360 "rx-decode.opc"
17646 int sz AU = (op[1] >> 4) & 0x03;
17647 #line 360 "rx-decode.opc"
17648 int isrc AU = op[1] & 0x0f;
17649 #line 360 "rx-decode.opc"
17650 int bsrc AU = (op[2] >> 4) & 0x0f;
17651 #line 360 "rx-decode.opc"
17652 int rdst AU = op[2] & 0x0f;
17653 if (trace)
17655 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
17656 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
17657 op[0], op[1], op[2]);
17658 printf (" sz = 0x%x,", sz);
17659 printf (" isrc = 0x%x,", isrc);
17660 printf (" bsrc = 0x%x,", bsrc);
17661 printf (" rdst = 0x%x\n", rdst);
17663 SYNTAX("mov%s [%1, %2], %0");
17664 #line 360 "rx-decode.opc"
17665 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17668 break;
17670 break;
17671 case 0x41:
17672 GETBYTE ();
17673 switch (op[2] & 0x00)
17675 case 0x00:
17676 goto op_semantics_142;
17677 break;
17679 break;
17680 case 0x42:
17681 GETBYTE ();
17682 switch (op[2] & 0x00)
17684 case 0x00:
17685 goto op_semantics_142;
17686 break;
17688 break;
17689 case 0x43:
17690 GETBYTE ();
17691 switch (op[2] & 0x00)
17693 case 0x00:
17694 goto op_semantics_142;
17695 break;
17697 break;
17698 case 0x44:
17699 GETBYTE ();
17700 switch (op[2] & 0x00)
17702 case 0x00:
17703 goto op_semantics_142;
17704 break;
17706 break;
17707 case 0x45:
17708 GETBYTE ();
17709 switch (op[2] & 0x00)
17711 case 0x00:
17712 goto op_semantics_142;
17713 break;
17715 break;
17716 case 0x46:
17717 GETBYTE ();
17718 switch (op[2] & 0x00)
17720 case 0x00:
17721 goto op_semantics_142;
17722 break;
17724 break;
17725 case 0x47:
17726 GETBYTE ();
17727 switch (op[2] & 0x00)
17729 case 0x00:
17730 goto op_semantics_142;
17731 break;
17733 break;
17734 case 0x48:
17735 GETBYTE ();
17736 switch (op[2] & 0x00)
17738 case 0x00:
17739 goto op_semantics_142;
17740 break;
17742 break;
17743 case 0x49:
17744 GETBYTE ();
17745 switch (op[2] & 0x00)
17747 case 0x00:
17748 goto op_semantics_142;
17749 break;
17751 break;
17752 case 0x4a:
17753 GETBYTE ();
17754 switch (op[2] & 0x00)
17756 case 0x00:
17757 goto op_semantics_142;
17758 break;
17760 break;
17761 case 0x4b:
17762 GETBYTE ();
17763 switch (op[2] & 0x00)
17765 case 0x00:
17766 goto op_semantics_142;
17767 break;
17769 break;
17770 case 0x4c:
17771 GETBYTE ();
17772 switch (op[2] & 0x00)
17774 case 0x00:
17775 goto op_semantics_142;
17776 break;
17778 break;
17779 case 0x4d:
17780 GETBYTE ();
17781 switch (op[2] & 0x00)
17783 case 0x00:
17784 goto op_semantics_142;
17785 break;
17787 break;
17788 case 0x4e:
17789 GETBYTE ();
17790 switch (op[2] & 0x00)
17792 case 0x00:
17793 goto op_semantics_142;
17794 break;
17796 break;
17797 case 0x4f:
17798 GETBYTE ();
17799 switch (op[2] & 0x00)
17801 case 0x00:
17802 goto op_semantics_142;
17803 break;
17805 break;
17806 case 0x50:
17807 GETBYTE ();
17808 switch (op[2] & 0x00)
17810 case 0x00:
17811 goto op_semantics_142;
17812 break;
17814 break;
17815 case 0x51:
17816 GETBYTE ();
17817 switch (op[2] & 0x00)
17819 case 0x00:
17820 goto op_semantics_142;
17821 break;
17823 break;
17824 case 0x52:
17825 GETBYTE ();
17826 switch (op[2] & 0x00)
17828 case 0x00:
17829 goto op_semantics_142;
17830 break;
17832 break;
17833 case 0x53:
17834 GETBYTE ();
17835 switch (op[2] & 0x00)
17837 case 0x00:
17838 goto op_semantics_142;
17839 break;
17841 break;
17842 case 0x54:
17843 GETBYTE ();
17844 switch (op[2] & 0x00)
17846 case 0x00:
17847 goto op_semantics_142;
17848 break;
17850 break;
17851 case 0x55:
17852 GETBYTE ();
17853 switch (op[2] & 0x00)
17855 case 0x00:
17856 goto op_semantics_142;
17857 break;
17859 break;
17860 case 0x56:
17861 GETBYTE ();
17862 switch (op[2] & 0x00)
17864 case 0x00:
17865 goto op_semantics_142;
17866 break;
17868 break;
17869 case 0x57:
17870 GETBYTE ();
17871 switch (op[2] & 0x00)
17873 case 0x00:
17874 goto op_semantics_142;
17875 break;
17877 break;
17878 case 0x58:
17879 GETBYTE ();
17880 switch (op[2] & 0x00)
17882 case 0x00:
17883 goto op_semantics_142;
17884 break;
17886 break;
17887 case 0x59:
17888 GETBYTE ();
17889 switch (op[2] & 0x00)
17891 case 0x00:
17892 goto op_semantics_142;
17893 break;
17895 break;
17896 case 0x5a:
17897 GETBYTE ();
17898 switch (op[2] & 0x00)
17900 case 0x00:
17901 goto op_semantics_142;
17902 break;
17904 break;
17905 case 0x5b:
17906 GETBYTE ();
17907 switch (op[2] & 0x00)
17909 case 0x00:
17910 goto op_semantics_142;
17911 break;
17913 break;
17914 case 0x5c:
17915 GETBYTE ();
17916 switch (op[2] & 0x00)
17918 case 0x00:
17919 goto op_semantics_142;
17920 break;
17922 break;
17923 case 0x5d:
17924 GETBYTE ();
17925 switch (op[2] & 0x00)
17927 case 0x00:
17928 goto op_semantics_142;
17929 break;
17931 break;
17932 case 0x5e:
17933 GETBYTE ();
17934 switch (op[2] & 0x00)
17936 case 0x00:
17937 goto op_semantics_142;
17938 break;
17940 break;
17941 case 0x5f:
17942 GETBYTE ();
17943 switch (op[2] & 0x00)
17945 case 0x00:
17946 goto op_semantics_142;
17947 break;
17949 break;
17950 case 0x60:
17951 GETBYTE ();
17952 switch (op[2] & 0x00)
17954 case 0x00:
17955 goto op_semantics_142;
17956 break;
17958 break;
17959 case 0x61:
17960 GETBYTE ();
17961 switch (op[2] & 0x00)
17963 case 0x00:
17964 goto op_semantics_142;
17965 break;
17967 break;
17968 case 0x62:
17969 GETBYTE ();
17970 switch (op[2] & 0x00)
17972 case 0x00:
17973 goto op_semantics_142;
17974 break;
17976 break;
17977 case 0x63:
17978 GETBYTE ();
17979 switch (op[2] & 0x00)
17981 case 0x00:
17982 goto op_semantics_142;
17983 break;
17985 break;
17986 case 0x64:
17987 GETBYTE ();
17988 switch (op[2] & 0x00)
17990 case 0x00:
17991 goto op_semantics_142;
17992 break;
17994 break;
17995 case 0x65:
17996 GETBYTE ();
17997 switch (op[2] & 0x00)
17999 case 0x00:
18000 goto op_semantics_142;
18001 break;
18003 break;
18004 case 0x66:
18005 GETBYTE ();
18006 switch (op[2] & 0x00)
18008 case 0x00:
18009 goto op_semantics_142;
18010 break;
18012 break;
18013 case 0x67:
18014 GETBYTE ();
18015 switch (op[2] & 0x00)
18017 case 0x00:
18018 goto op_semantics_142;
18019 break;
18021 break;
18022 case 0x68:
18023 GETBYTE ();
18024 switch (op[2] & 0x00)
18026 case 0x00:
18027 goto op_semantics_142;
18028 break;
18030 break;
18031 case 0x69:
18032 GETBYTE ();
18033 switch (op[2] & 0x00)
18035 case 0x00:
18036 goto op_semantics_142;
18037 break;
18039 break;
18040 case 0x6a:
18041 GETBYTE ();
18042 switch (op[2] & 0x00)
18044 case 0x00:
18045 goto op_semantics_142;
18046 break;
18048 break;
18049 case 0x6b:
18050 GETBYTE ();
18051 switch (op[2] & 0x00)
18053 case 0x00:
18054 goto op_semantics_142;
18055 break;
18057 break;
18058 case 0x6c:
18059 GETBYTE ();
18060 switch (op[2] & 0x00)
18062 case 0x00:
18063 goto op_semantics_142;
18064 break;
18066 break;
18067 case 0x6d:
18068 GETBYTE ();
18069 switch (op[2] & 0x00)
18071 case 0x00:
18072 goto op_semantics_142;
18073 break;
18075 break;
18076 case 0x6e:
18077 GETBYTE ();
18078 switch (op[2] & 0x00)
18080 case 0x00:
18081 goto op_semantics_142;
18082 break;
18084 break;
18085 case 0x6f:
18086 GETBYTE ();
18087 switch (op[2] & 0x00)
18089 case 0x00:
18090 goto op_semantics_142;
18091 break;
18093 break;
18094 case 0xc0:
18095 GETBYTE ();
18096 switch (op[2] & 0x00)
18098 case 0x00:
18099 op_semantics_143:
18101 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
18102 #line 366 "rx-decode.opc"
18103 int sz AU = (op[1] >> 4) & 0x03;
18104 #line 366 "rx-decode.opc"
18105 int isrc AU = op[1] & 0x0f;
18106 #line 366 "rx-decode.opc"
18107 int bsrc AU = (op[2] >> 4) & 0x0f;
18108 #line 366 "rx-decode.opc"
18109 int rdst AU = op[2] & 0x0f;
18110 if (trace)
18112 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18113 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
18114 op[0], op[1], op[2]);
18115 printf (" sz = 0x%x,", sz);
18116 printf (" isrc = 0x%x,", isrc);
18117 printf (" bsrc = 0x%x,", bsrc);
18118 printf (" rdst = 0x%x\n", rdst);
18120 SYNTAX("movu%s [%1, %2], %0");
18121 #line 366 "rx-decode.opc"
18122 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
18125 break;
18127 break;
18128 case 0xc1:
18129 GETBYTE ();
18130 switch (op[2] & 0x00)
18132 case 0x00:
18133 goto op_semantics_143;
18134 break;
18136 break;
18137 case 0xc2:
18138 GETBYTE ();
18139 switch (op[2] & 0x00)
18141 case 0x00:
18142 goto op_semantics_143;
18143 break;
18145 break;
18146 case 0xc3:
18147 GETBYTE ();
18148 switch (op[2] & 0x00)
18150 case 0x00:
18151 goto op_semantics_143;
18152 break;
18154 break;
18155 case 0xc4:
18156 GETBYTE ();
18157 switch (op[2] & 0x00)
18159 case 0x00:
18160 goto op_semantics_143;
18161 break;
18163 break;
18164 case 0xc5:
18165 GETBYTE ();
18166 switch (op[2] & 0x00)
18168 case 0x00:
18169 goto op_semantics_143;
18170 break;
18172 break;
18173 case 0xc6:
18174 GETBYTE ();
18175 switch (op[2] & 0x00)
18177 case 0x00:
18178 goto op_semantics_143;
18179 break;
18181 break;
18182 case 0xc7:
18183 GETBYTE ();
18184 switch (op[2] & 0x00)
18186 case 0x00:
18187 goto op_semantics_143;
18188 break;
18190 break;
18191 case 0xc8:
18192 GETBYTE ();
18193 switch (op[2] & 0x00)
18195 case 0x00:
18196 goto op_semantics_143;
18197 break;
18199 break;
18200 case 0xc9:
18201 GETBYTE ();
18202 switch (op[2] & 0x00)
18204 case 0x00:
18205 goto op_semantics_143;
18206 break;
18208 break;
18209 case 0xca:
18210 GETBYTE ();
18211 switch (op[2] & 0x00)
18213 case 0x00:
18214 goto op_semantics_143;
18215 break;
18217 break;
18218 case 0xcb:
18219 GETBYTE ();
18220 switch (op[2] & 0x00)
18222 case 0x00:
18223 goto op_semantics_143;
18224 break;
18226 break;
18227 case 0xcc:
18228 GETBYTE ();
18229 switch (op[2] & 0x00)
18231 case 0x00:
18232 goto op_semantics_143;
18233 break;
18235 break;
18236 case 0xcd:
18237 GETBYTE ();
18238 switch (op[2] & 0x00)
18240 case 0x00:
18241 goto op_semantics_143;
18242 break;
18244 break;
18245 case 0xce:
18246 GETBYTE ();
18247 switch (op[2] & 0x00)
18249 case 0x00:
18250 goto op_semantics_143;
18251 break;
18253 break;
18254 case 0xcf:
18255 GETBYTE ();
18256 switch (op[2] & 0x00)
18258 case 0x00:
18259 goto op_semantics_143;
18260 break;
18262 break;
18263 case 0xd0:
18264 GETBYTE ();
18265 switch (op[2] & 0x00)
18267 case 0x00:
18268 goto op_semantics_143;
18269 break;
18271 break;
18272 case 0xd1:
18273 GETBYTE ();
18274 switch (op[2] & 0x00)
18276 case 0x00:
18277 goto op_semantics_143;
18278 break;
18280 break;
18281 case 0xd2:
18282 GETBYTE ();
18283 switch (op[2] & 0x00)
18285 case 0x00:
18286 goto op_semantics_143;
18287 break;
18289 break;
18290 case 0xd3:
18291 GETBYTE ();
18292 switch (op[2] & 0x00)
18294 case 0x00:
18295 goto op_semantics_143;
18296 break;
18298 break;
18299 case 0xd4:
18300 GETBYTE ();
18301 switch (op[2] & 0x00)
18303 case 0x00:
18304 goto op_semantics_143;
18305 break;
18307 break;
18308 case 0xd5:
18309 GETBYTE ();
18310 switch (op[2] & 0x00)
18312 case 0x00:
18313 goto op_semantics_143;
18314 break;
18316 break;
18317 case 0xd6:
18318 GETBYTE ();
18319 switch (op[2] & 0x00)
18321 case 0x00:
18322 goto op_semantics_143;
18323 break;
18325 break;
18326 case 0xd7:
18327 GETBYTE ();
18328 switch (op[2] & 0x00)
18330 case 0x00:
18331 goto op_semantics_143;
18332 break;
18334 break;
18335 case 0xd8:
18336 GETBYTE ();
18337 switch (op[2] & 0x00)
18339 case 0x00:
18340 goto op_semantics_143;
18341 break;
18343 break;
18344 case 0xd9:
18345 GETBYTE ();
18346 switch (op[2] & 0x00)
18348 case 0x00:
18349 goto op_semantics_143;
18350 break;
18352 break;
18353 case 0xda:
18354 GETBYTE ();
18355 switch (op[2] & 0x00)
18357 case 0x00:
18358 goto op_semantics_143;
18359 break;
18361 break;
18362 case 0xdb:
18363 GETBYTE ();
18364 switch (op[2] & 0x00)
18366 case 0x00:
18367 goto op_semantics_143;
18368 break;
18370 break;
18371 case 0xdc:
18372 GETBYTE ();
18373 switch (op[2] & 0x00)
18375 case 0x00:
18376 goto op_semantics_143;
18377 break;
18379 break;
18380 case 0xdd:
18381 GETBYTE ();
18382 switch (op[2] & 0x00)
18384 case 0x00:
18385 goto op_semantics_143;
18386 break;
18388 break;
18389 case 0xde:
18390 GETBYTE ();
18391 switch (op[2] & 0x00)
18393 case 0x00:
18394 goto op_semantics_143;
18395 break;
18397 break;
18398 case 0xdf:
18399 GETBYTE ();
18400 switch (op[2] & 0x00)
18402 case 0x00:
18403 goto op_semantics_143;
18404 break;
18406 break;
18407 case 0xe0:
18408 GETBYTE ();
18409 switch (op[2] & 0x00)
18411 case 0x00:
18412 goto op_semantics_143;
18413 break;
18415 break;
18416 case 0xe1:
18417 GETBYTE ();
18418 switch (op[2] & 0x00)
18420 case 0x00:
18421 goto op_semantics_143;
18422 break;
18424 break;
18425 case 0xe2:
18426 GETBYTE ();
18427 switch (op[2] & 0x00)
18429 case 0x00:
18430 goto op_semantics_143;
18431 break;
18433 break;
18434 case 0xe3:
18435 GETBYTE ();
18436 switch (op[2] & 0x00)
18438 case 0x00:
18439 goto op_semantics_143;
18440 break;
18442 break;
18443 case 0xe4:
18444 GETBYTE ();
18445 switch (op[2] & 0x00)
18447 case 0x00:
18448 goto op_semantics_143;
18449 break;
18451 break;
18452 case 0xe5:
18453 GETBYTE ();
18454 switch (op[2] & 0x00)
18456 case 0x00:
18457 goto op_semantics_143;
18458 break;
18460 break;
18461 case 0xe6:
18462 GETBYTE ();
18463 switch (op[2] & 0x00)
18465 case 0x00:
18466 goto op_semantics_143;
18467 break;
18469 break;
18470 case 0xe7:
18471 GETBYTE ();
18472 switch (op[2] & 0x00)
18474 case 0x00:
18475 goto op_semantics_143;
18476 break;
18478 break;
18479 case 0xe8:
18480 GETBYTE ();
18481 switch (op[2] & 0x00)
18483 case 0x00:
18484 goto op_semantics_143;
18485 break;
18487 break;
18488 case 0xe9:
18489 GETBYTE ();
18490 switch (op[2] & 0x00)
18492 case 0x00:
18493 goto op_semantics_143;
18494 break;
18496 break;
18497 case 0xea:
18498 GETBYTE ();
18499 switch (op[2] & 0x00)
18501 case 0x00:
18502 goto op_semantics_143;
18503 break;
18505 break;
18506 case 0xeb:
18507 GETBYTE ();
18508 switch (op[2] & 0x00)
18510 case 0x00:
18511 goto op_semantics_143;
18512 break;
18514 break;
18515 case 0xec:
18516 GETBYTE ();
18517 switch (op[2] & 0x00)
18519 case 0x00:
18520 goto op_semantics_143;
18521 break;
18523 break;
18524 case 0xed:
18525 GETBYTE ();
18526 switch (op[2] & 0x00)
18528 case 0x00:
18529 goto op_semantics_143;
18530 break;
18532 break;
18533 case 0xee:
18534 GETBYTE ();
18535 switch (op[2] & 0x00)
18537 case 0x00:
18538 goto op_semantics_143;
18539 break;
18541 break;
18542 case 0xef:
18543 GETBYTE ();
18544 switch (op[2] & 0x00)
18546 case 0x00:
18547 goto op_semantics_143;
18548 break;
18550 break;
18551 default: UNSUPPORTED(); break;
18553 break;
18554 case 0xff:
18555 GETBYTE ();
18556 switch (op[1] & 0xff)
18558 case 0x00:
18559 GETBYTE ();
18560 switch (op[2] & 0x00)
18562 case 0x00:
18563 op_semantics_144:
18565 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
18566 #line 570 "rx-decode.opc"
18567 int rdst AU = op[1] & 0x0f;
18568 #line 570 "rx-decode.opc"
18569 int srca AU = (op[2] >> 4) & 0x0f;
18570 #line 570 "rx-decode.opc"
18571 int srcb AU = op[2] & 0x0f;
18572 if (trace)
18574 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18575 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
18576 op[0], op[1], op[2]);
18577 printf (" rdst = 0x%x,", rdst);
18578 printf (" srca = 0x%x,", srca);
18579 printf (" srcb = 0x%x\n", srcb);
18581 SYNTAX("sub %2, %1, %0");
18582 #line 570 "rx-decode.opc"
18583 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18585 /*----------------------------------------------------------------------*/
18586 /* SBB */
18589 break;
18591 break;
18592 case 0x01:
18593 GETBYTE ();
18594 switch (op[2] & 0x00)
18596 case 0x00:
18597 goto op_semantics_144;
18598 break;
18600 break;
18601 case 0x02:
18602 GETBYTE ();
18603 switch (op[2] & 0x00)
18605 case 0x00:
18606 goto op_semantics_144;
18607 break;
18609 break;
18610 case 0x03:
18611 GETBYTE ();
18612 switch (op[2] & 0x00)
18614 case 0x00:
18615 goto op_semantics_144;
18616 break;
18618 break;
18619 case 0x04:
18620 GETBYTE ();
18621 switch (op[2] & 0x00)
18623 case 0x00:
18624 goto op_semantics_144;
18625 break;
18627 break;
18628 case 0x05:
18629 GETBYTE ();
18630 switch (op[2] & 0x00)
18632 case 0x00:
18633 goto op_semantics_144;
18634 break;
18636 break;
18637 case 0x06:
18638 GETBYTE ();
18639 switch (op[2] & 0x00)
18641 case 0x00:
18642 goto op_semantics_144;
18643 break;
18645 break;
18646 case 0x07:
18647 GETBYTE ();
18648 switch (op[2] & 0x00)
18650 case 0x00:
18651 goto op_semantics_144;
18652 break;
18654 break;
18655 case 0x08:
18656 GETBYTE ();
18657 switch (op[2] & 0x00)
18659 case 0x00:
18660 goto op_semantics_144;
18661 break;
18663 break;
18664 case 0x09:
18665 GETBYTE ();
18666 switch (op[2] & 0x00)
18668 case 0x00:
18669 goto op_semantics_144;
18670 break;
18672 break;
18673 case 0x0a:
18674 GETBYTE ();
18675 switch (op[2] & 0x00)
18677 case 0x00:
18678 goto op_semantics_144;
18679 break;
18681 break;
18682 case 0x0b:
18683 GETBYTE ();
18684 switch (op[2] & 0x00)
18686 case 0x00:
18687 goto op_semantics_144;
18688 break;
18690 break;
18691 case 0x0c:
18692 GETBYTE ();
18693 switch (op[2] & 0x00)
18695 case 0x00:
18696 goto op_semantics_144;
18697 break;
18699 break;
18700 case 0x0d:
18701 GETBYTE ();
18702 switch (op[2] & 0x00)
18704 case 0x00:
18705 goto op_semantics_144;
18706 break;
18708 break;
18709 case 0x0e:
18710 GETBYTE ();
18711 switch (op[2] & 0x00)
18713 case 0x00:
18714 goto op_semantics_144;
18715 break;
18717 break;
18718 case 0x0f:
18719 GETBYTE ();
18720 switch (op[2] & 0x00)
18722 case 0x00:
18723 goto op_semantics_144;
18724 break;
18726 break;
18727 case 0x20:
18728 GETBYTE ();
18729 switch (op[2] & 0x00)
18731 case 0x00:
18732 op_semantics_145:
18734 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
18735 #line 537 "rx-decode.opc"
18736 int rdst AU = op[1] & 0x0f;
18737 #line 537 "rx-decode.opc"
18738 int srca AU = (op[2] >> 4) & 0x0f;
18739 #line 537 "rx-decode.opc"
18740 int srcb AU = op[2] & 0x0f;
18741 if (trace)
18743 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18744 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
18745 op[0], op[1], op[2]);
18746 printf (" rdst = 0x%x,", rdst);
18747 printf (" srca = 0x%x,", srca);
18748 printf (" srcb = 0x%x\n", srcb);
18750 SYNTAX("add %2, %1, %0");
18751 #line 537 "rx-decode.opc"
18752 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18754 /*----------------------------------------------------------------------*/
18755 /* CMP */
18758 break;
18760 break;
18761 case 0x21:
18762 GETBYTE ();
18763 switch (op[2] & 0x00)
18765 case 0x00:
18766 goto op_semantics_145;
18767 break;
18769 break;
18770 case 0x22:
18771 GETBYTE ();
18772 switch (op[2] & 0x00)
18774 case 0x00:
18775 goto op_semantics_145;
18776 break;
18778 break;
18779 case 0x23:
18780 GETBYTE ();
18781 switch (op[2] & 0x00)
18783 case 0x00:
18784 goto op_semantics_145;
18785 break;
18787 break;
18788 case 0x24:
18789 GETBYTE ();
18790 switch (op[2] & 0x00)
18792 case 0x00:
18793 goto op_semantics_145;
18794 break;
18796 break;
18797 case 0x25:
18798 GETBYTE ();
18799 switch (op[2] & 0x00)
18801 case 0x00:
18802 goto op_semantics_145;
18803 break;
18805 break;
18806 case 0x26:
18807 GETBYTE ();
18808 switch (op[2] & 0x00)
18810 case 0x00:
18811 goto op_semantics_145;
18812 break;
18814 break;
18815 case 0x27:
18816 GETBYTE ();
18817 switch (op[2] & 0x00)
18819 case 0x00:
18820 goto op_semantics_145;
18821 break;
18823 break;
18824 case 0x28:
18825 GETBYTE ();
18826 switch (op[2] & 0x00)
18828 case 0x00:
18829 goto op_semantics_145;
18830 break;
18832 break;
18833 case 0x29:
18834 GETBYTE ();
18835 switch (op[2] & 0x00)
18837 case 0x00:
18838 goto op_semantics_145;
18839 break;
18841 break;
18842 case 0x2a:
18843 GETBYTE ();
18844 switch (op[2] & 0x00)
18846 case 0x00:
18847 goto op_semantics_145;
18848 break;
18850 break;
18851 case 0x2b:
18852 GETBYTE ();
18853 switch (op[2] & 0x00)
18855 case 0x00:
18856 goto op_semantics_145;
18857 break;
18859 break;
18860 case 0x2c:
18861 GETBYTE ();
18862 switch (op[2] & 0x00)
18864 case 0x00:
18865 goto op_semantics_145;
18866 break;
18868 break;
18869 case 0x2d:
18870 GETBYTE ();
18871 switch (op[2] & 0x00)
18873 case 0x00:
18874 goto op_semantics_145;
18875 break;
18877 break;
18878 case 0x2e:
18879 GETBYTE ();
18880 switch (op[2] & 0x00)
18882 case 0x00:
18883 goto op_semantics_145;
18884 break;
18886 break;
18887 case 0x2f:
18888 GETBYTE ();
18889 switch (op[2] & 0x00)
18891 case 0x00:
18892 goto op_semantics_145;
18893 break;
18895 break;
18896 case 0x30:
18897 GETBYTE ();
18898 switch (op[2] & 0x00)
18900 case 0x00:
18901 op_semantics_146:
18903 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
18904 #line 677 "rx-decode.opc"
18905 int rdst AU = op[1] & 0x0f;
18906 #line 677 "rx-decode.opc"
18907 int srca AU = (op[2] >> 4) & 0x0f;
18908 #line 677 "rx-decode.opc"
18909 int srcb AU = op[2] & 0x0f;
18910 if (trace)
18912 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18913 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
18914 op[0], op[1], op[2]);
18915 printf (" rdst = 0x%x,", rdst);
18916 printf (" srca = 0x%x,", srca);
18917 printf (" srcb = 0x%x\n", srcb);
18919 SYNTAX("mul %2, %1, %0");
18920 #line 677 "rx-decode.opc"
18921 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
18923 /*----------------------------------------------------------------------*/
18924 /* EMUL */
18927 break;
18929 break;
18930 case 0x31:
18931 GETBYTE ();
18932 switch (op[2] & 0x00)
18934 case 0x00:
18935 goto op_semantics_146;
18936 break;
18938 break;
18939 case 0x32:
18940 GETBYTE ();
18941 switch (op[2] & 0x00)
18943 case 0x00:
18944 goto op_semantics_146;
18945 break;
18947 break;
18948 case 0x33:
18949 GETBYTE ();
18950 switch (op[2] & 0x00)
18952 case 0x00:
18953 goto op_semantics_146;
18954 break;
18956 break;
18957 case 0x34:
18958 GETBYTE ();
18959 switch (op[2] & 0x00)
18961 case 0x00:
18962 goto op_semantics_146;
18963 break;
18965 break;
18966 case 0x35:
18967 GETBYTE ();
18968 switch (op[2] & 0x00)
18970 case 0x00:
18971 goto op_semantics_146;
18972 break;
18974 break;
18975 case 0x36:
18976 GETBYTE ();
18977 switch (op[2] & 0x00)
18979 case 0x00:
18980 goto op_semantics_146;
18981 break;
18983 break;
18984 case 0x37:
18985 GETBYTE ();
18986 switch (op[2] & 0x00)
18988 case 0x00:
18989 goto op_semantics_146;
18990 break;
18992 break;
18993 case 0x38:
18994 GETBYTE ();
18995 switch (op[2] & 0x00)
18997 case 0x00:
18998 goto op_semantics_146;
18999 break;
19001 break;
19002 case 0x39:
19003 GETBYTE ();
19004 switch (op[2] & 0x00)
19006 case 0x00:
19007 goto op_semantics_146;
19008 break;
19010 break;
19011 case 0x3a:
19012 GETBYTE ();
19013 switch (op[2] & 0x00)
19015 case 0x00:
19016 goto op_semantics_146;
19017 break;
19019 break;
19020 case 0x3b:
19021 GETBYTE ();
19022 switch (op[2] & 0x00)
19024 case 0x00:
19025 goto op_semantics_146;
19026 break;
19028 break;
19029 case 0x3c:
19030 GETBYTE ();
19031 switch (op[2] & 0x00)
19033 case 0x00:
19034 goto op_semantics_146;
19035 break;
19037 break;
19038 case 0x3d:
19039 GETBYTE ();
19040 switch (op[2] & 0x00)
19042 case 0x00:
19043 goto op_semantics_146;
19044 break;
19046 break;
19047 case 0x3e:
19048 GETBYTE ();
19049 switch (op[2] & 0x00)
19051 case 0x00:
19052 goto op_semantics_146;
19053 break;
19055 break;
19056 case 0x3f:
19057 GETBYTE ();
19058 switch (op[2] & 0x00)
19060 case 0x00:
19061 goto op_semantics_146;
19062 break;
19064 break;
19065 case 0x40:
19066 GETBYTE ();
19067 switch (op[2] & 0x00)
19069 case 0x00:
19070 op_semantics_147:
19072 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
19073 #line 447 "rx-decode.opc"
19074 int rdst AU = op[1] & 0x0f;
19075 #line 447 "rx-decode.opc"
19076 int srca AU = (op[2] >> 4) & 0x0f;
19077 #line 447 "rx-decode.opc"
19078 int srcb AU = op[2] & 0x0f;
19079 if (trace)
19081 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19082 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
19083 op[0], op[1], op[2]);
19084 printf (" rdst = 0x%x,", rdst);
19085 printf (" srca = 0x%x,", srca);
19086 printf (" srcb = 0x%x\n", srcb);
19088 SYNTAX("and %2, %1, %0");
19089 #line 447 "rx-decode.opc"
19090 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19092 /*----------------------------------------------------------------------*/
19093 /* OR */
19096 break;
19098 break;
19099 case 0x41:
19100 GETBYTE ();
19101 switch (op[2] & 0x00)
19103 case 0x00:
19104 goto op_semantics_147;
19105 break;
19107 break;
19108 case 0x42:
19109 GETBYTE ();
19110 switch (op[2] & 0x00)
19112 case 0x00:
19113 goto op_semantics_147;
19114 break;
19116 break;
19117 case 0x43:
19118 GETBYTE ();
19119 switch (op[2] & 0x00)
19121 case 0x00:
19122 goto op_semantics_147;
19123 break;
19125 break;
19126 case 0x44:
19127 GETBYTE ();
19128 switch (op[2] & 0x00)
19130 case 0x00:
19131 goto op_semantics_147;
19132 break;
19134 break;
19135 case 0x45:
19136 GETBYTE ();
19137 switch (op[2] & 0x00)
19139 case 0x00:
19140 goto op_semantics_147;
19141 break;
19143 break;
19144 case 0x46:
19145 GETBYTE ();
19146 switch (op[2] & 0x00)
19148 case 0x00:
19149 goto op_semantics_147;
19150 break;
19152 break;
19153 case 0x47:
19154 GETBYTE ();
19155 switch (op[2] & 0x00)
19157 case 0x00:
19158 goto op_semantics_147;
19159 break;
19161 break;
19162 case 0x48:
19163 GETBYTE ();
19164 switch (op[2] & 0x00)
19166 case 0x00:
19167 goto op_semantics_147;
19168 break;
19170 break;
19171 case 0x49:
19172 GETBYTE ();
19173 switch (op[2] & 0x00)
19175 case 0x00:
19176 goto op_semantics_147;
19177 break;
19179 break;
19180 case 0x4a:
19181 GETBYTE ();
19182 switch (op[2] & 0x00)
19184 case 0x00:
19185 goto op_semantics_147;
19186 break;
19188 break;
19189 case 0x4b:
19190 GETBYTE ();
19191 switch (op[2] & 0x00)
19193 case 0x00:
19194 goto op_semantics_147;
19195 break;
19197 break;
19198 case 0x4c:
19199 GETBYTE ();
19200 switch (op[2] & 0x00)
19202 case 0x00:
19203 goto op_semantics_147;
19204 break;
19206 break;
19207 case 0x4d:
19208 GETBYTE ();
19209 switch (op[2] & 0x00)
19211 case 0x00:
19212 goto op_semantics_147;
19213 break;
19215 break;
19216 case 0x4e:
19217 GETBYTE ();
19218 switch (op[2] & 0x00)
19220 case 0x00:
19221 goto op_semantics_147;
19222 break;
19224 break;
19225 case 0x4f:
19226 GETBYTE ();
19227 switch (op[2] & 0x00)
19229 case 0x00:
19230 goto op_semantics_147;
19231 break;
19233 break;
19234 case 0x50:
19235 GETBYTE ();
19236 switch (op[2] & 0x00)
19238 case 0x00:
19239 op_semantics_148:
19241 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
19242 #line 465 "rx-decode.opc"
19243 int rdst AU = op[1] & 0x0f;
19244 #line 465 "rx-decode.opc"
19245 int srca AU = (op[2] >> 4) & 0x0f;
19246 #line 465 "rx-decode.opc"
19247 int srcb AU = op[2] & 0x0f;
19248 if (trace)
19250 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19251 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
19252 op[0], op[1], op[2]);
19253 printf (" rdst = 0x%x,", rdst);
19254 printf (" srca = 0x%x,", srca);
19255 printf (" srcb = 0x%x\n", srcb);
19257 SYNTAX("or %2, %1, %0");
19258 #line 465 "rx-decode.opc"
19259 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19261 /*----------------------------------------------------------------------*/
19262 /* XOR */
19265 break;
19267 break;
19268 case 0x51:
19269 GETBYTE ();
19270 switch (op[2] & 0x00)
19272 case 0x00:
19273 goto op_semantics_148;
19274 break;
19276 break;
19277 case 0x52:
19278 GETBYTE ();
19279 switch (op[2] & 0x00)
19281 case 0x00:
19282 goto op_semantics_148;
19283 break;
19285 break;
19286 case 0x53:
19287 GETBYTE ();
19288 switch (op[2] & 0x00)
19290 case 0x00:
19291 goto op_semantics_148;
19292 break;
19294 break;
19295 case 0x54:
19296 GETBYTE ();
19297 switch (op[2] & 0x00)
19299 case 0x00:
19300 goto op_semantics_148;
19301 break;
19303 break;
19304 case 0x55:
19305 GETBYTE ();
19306 switch (op[2] & 0x00)
19308 case 0x00:
19309 goto op_semantics_148;
19310 break;
19312 break;
19313 case 0x56:
19314 GETBYTE ();
19315 switch (op[2] & 0x00)
19317 case 0x00:
19318 goto op_semantics_148;
19319 break;
19321 break;
19322 case 0x57:
19323 GETBYTE ();
19324 switch (op[2] & 0x00)
19326 case 0x00:
19327 goto op_semantics_148;
19328 break;
19330 break;
19331 case 0x58:
19332 GETBYTE ();
19333 switch (op[2] & 0x00)
19335 case 0x00:
19336 goto op_semantics_148;
19337 break;
19339 break;
19340 case 0x59:
19341 GETBYTE ();
19342 switch (op[2] & 0x00)
19344 case 0x00:
19345 goto op_semantics_148;
19346 break;
19348 break;
19349 case 0x5a:
19350 GETBYTE ();
19351 switch (op[2] & 0x00)
19353 case 0x00:
19354 goto op_semantics_148;
19355 break;
19357 break;
19358 case 0x5b:
19359 GETBYTE ();
19360 switch (op[2] & 0x00)
19362 case 0x00:
19363 goto op_semantics_148;
19364 break;
19366 break;
19367 case 0x5c:
19368 GETBYTE ();
19369 switch (op[2] & 0x00)
19371 case 0x00:
19372 goto op_semantics_148;
19373 break;
19375 break;
19376 case 0x5d:
19377 GETBYTE ();
19378 switch (op[2] & 0x00)
19380 case 0x00:
19381 goto op_semantics_148;
19382 break;
19384 break;
19385 case 0x5e:
19386 GETBYTE ();
19387 switch (op[2] & 0x00)
19389 case 0x00:
19390 goto op_semantics_148;
19391 break;
19393 break;
19394 case 0x5f:
19395 GETBYTE ();
19396 switch (op[2] & 0x00)
19398 case 0x00:
19399 goto op_semantics_148;
19400 break;
19402 break;
19403 case 0x60:
19404 GETBYTE ();
19405 switch (op[2] & 0x00)
19407 case 0x00:
19408 op_semantics_149:
19410 /** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */
19411 #line 1146 "rx-decode.opc"
19412 int rdst AU = op[1] & 0x0f;
19413 #line 1146 "rx-decode.opc"
19414 int srca AU = (op[2] >> 4) & 0x0f;
19415 #line 1146 "rx-decode.opc"
19416 int srcb AU = op[2] & 0x0f;
19417 if (trace)
19419 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19420 "/** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */",
19421 op[0], op[1], op[2]);
19422 printf (" rdst = 0x%x,", rdst);
19423 printf (" srca = 0x%x,", srca);
19424 printf (" srcb = 0x%x\n", srcb);
19426 SYNTAX("xor %2, %1, %0");
19427 #line 1146 "rx-decode.opc"
19428 ID(xor); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19431 break;
19433 break;
19434 case 0x61:
19435 GETBYTE ();
19436 switch (op[2] & 0x00)
19438 case 0x00:
19439 goto op_semantics_149;
19440 break;
19442 break;
19443 case 0x62:
19444 GETBYTE ();
19445 switch (op[2] & 0x00)
19447 case 0x00:
19448 goto op_semantics_149;
19449 break;
19451 break;
19452 case 0x63:
19453 GETBYTE ();
19454 switch (op[2] & 0x00)
19456 case 0x00:
19457 goto op_semantics_149;
19458 break;
19460 break;
19461 case 0x64:
19462 GETBYTE ();
19463 switch (op[2] & 0x00)
19465 case 0x00:
19466 goto op_semantics_149;
19467 break;
19469 break;
19470 case 0x65:
19471 GETBYTE ();
19472 switch (op[2] & 0x00)
19474 case 0x00:
19475 goto op_semantics_149;
19476 break;
19478 break;
19479 case 0x66:
19480 GETBYTE ();
19481 switch (op[2] & 0x00)
19483 case 0x00:
19484 goto op_semantics_149;
19485 break;
19487 break;
19488 case 0x67:
19489 GETBYTE ();
19490 switch (op[2] & 0x00)
19492 case 0x00:
19493 goto op_semantics_149;
19494 break;
19496 break;
19497 case 0x68:
19498 GETBYTE ();
19499 switch (op[2] & 0x00)
19501 case 0x00:
19502 goto op_semantics_149;
19503 break;
19505 break;
19506 case 0x69:
19507 GETBYTE ();
19508 switch (op[2] & 0x00)
19510 case 0x00:
19511 goto op_semantics_149;
19512 break;
19514 break;
19515 case 0x6a:
19516 GETBYTE ();
19517 switch (op[2] & 0x00)
19519 case 0x00:
19520 goto op_semantics_149;
19521 break;
19523 break;
19524 case 0x6b:
19525 GETBYTE ();
19526 switch (op[2] & 0x00)
19528 case 0x00:
19529 goto op_semantics_149;
19530 break;
19532 break;
19533 case 0x6c:
19534 GETBYTE ();
19535 switch (op[2] & 0x00)
19537 case 0x00:
19538 goto op_semantics_149;
19539 break;
19541 break;
19542 case 0x6d:
19543 GETBYTE ();
19544 switch (op[2] & 0x00)
19546 case 0x00:
19547 goto op_semantics_149;
19548 break;
19550 break;
19551 case 0x6e:
19552 GETBYTE ();
19553 switch (op[2] & 0x00)
19555 case 0x00:
19556 goto op_semantics_149;
19557 break;
19559 break;
19560 case 0x6f:
19561 GETBYTE ();
19562 switch (op[2] & 0x00)
19564 case 0x00:
19565 goto op_semantics_149;
19566 break;
19568 break;
19569 case 0x80:
19570 GETBYTE ();
19571 switch (op[2] & 0x00)
19573 case 0x00:
19574 op_semantics_150:
19576 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
19577 #line 1125 "rx-decode.opc"
19578 int rdst AU = op[1] & 0x0f;
19579 #line 1125 "rx-decode.opc"
19580 int srca AU = (op[2] >> 4) & 0x0f;
19581 #line 1125 "rx-decode.opc"
19582 int srcb AU = op[2] & 0x0f;
19583 if (trace)
19585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19586 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
19587 op[0], op[1], op[2]);
19588 printf (" rdst = 0x%x,", rdst);
19589 printf (" srca = 0x%x,", srca);
19590 printf (" srcb = 0x%x\n", srcb);
19592 SYNTAX("fsub %2, %1, %0");
19593 #line 1125 "rx-decode.opc"
19594 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19597 break;
19599 break;
19600 case 0x81:
19601 GETBYTE ();
19602 switch (op[2] & 0x00)
19604 case 0x00:
19605 goto op_semantics_150;
19606 break;
19608 break;
19609 case 0x82:
19610 GETBYTE ();
19611 switch (op[2] & 0x00)
19613 case 0x00:
19614 goto op_semantics_150;
19615 break;
19617 break;
19618 case 0x83:
19619 GETBYTE ();
19620 switch (op[2] & 0x00)
19622 case 0x00:
19623 goto op_semantics_150;
19624 break;
19626 break;
19627 case 0x84:
19628 GETBYTE ();
19629 switch (op[2] & 0x00)
19631 case 0x00:
19632 goto op_semantics_150;
19633 break;
19635 break;
19636 case 0x85:
19637 GETBYTE ();
19638 switch (op[2] & 0x00)
19640 case 0x00:
19641 goto op_semantics_150;
19642 break;
19644 break;
19645 case 0x86:
19646 GETBYTE ();
19647 switch (op[2] & 0x00)
19649 case 0x00:
19650 goto op_semantics_150;
19651 break;
19653 break;
19654 case 0x87:
19655 GETBYTE ();
19656 switch (op[2] & 0x00)
19658 case 0x00:
19659 goto op_semantics_150;
19660 break;
19662 break;
19663 case 0x88:
19664 GETBYTE ();
19665 switch (op[2] & 0x00)
19667 case 0x00:
19668 goto op_semantics_150;
19669 break;
19671 break;
19672 case 0x89:
19673 GETBYTE ();
19674 switch (op[2] & 0x00)
19676 case 0x00:
19677 goto op_semantics_150;
19678 break;
19680 break;
19681 case 0x8a:
19682 GETBYTE ();
19683 switch (op[2] & 0x00)
19685 case 0x00:
19686 goto op_semantics_150;
19687 break;
19689 break;
19690 case 0x8b:
19691 GETBYTE ();
19692 switch (op[2] & 0x00)
19694 case 0x00:
19695 goto op_semantics_150;
19696 break;
19698 break;
19699 case 0x8c:
19700 GETBYTE ();
19701 switch (op[2] & 0x00)
19703 case 0x00:
19704 goto op_semantics_150;
19705 break;
19707 break;
19708 case 0x8d:
19709 GETBYTE ();
19710 switch (op[2] & 0x00)
19712 case 0x00:
19713 goto op_semantics_150;
19714 break;
19716 break;
19717 case 0x8e:
19718 GETBYTE ();
19719 switch (op[2] & 0x00)
19721 case 0x00:
19722 goto op_semantics_150;
19723 break;
19725 break;
19726 case 0x8f:
19727 GETBYTE ();
19728 switch (op[2] & 0x00)
19730 case 0x00:
19731 goto op_semantics_150;
19732 break;
19734 break;
19735 case 0xa0:
19736 GETBYTE ();
19737 switch (op[2] & 0x00)
19739 case 0x00:
19740 op_semantics_151:
19742 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
19743 #line 1122 "rx-decode.opc"
19744 int rdst AU = op[1] & 0x0f;
19745 #line 1122 "rx-decode.opc"
19746 int srca AU = (op[2] >> 4) & 0x0f;
19747 #line 1122 "rx-decode.opc"
19748 int srcb AU = op[2] & 0x0f;
19749 if (trace)
19751 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19752 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
19753 op[0], op[1], op[2]);
19754 printf (" rdst = 0x%x,", rdst);
19755 printf (" srca = 0x%x,", srca);
19756 printf (" srcb = 0x%x\n", srcb);
19758 SYNTAX("fadd %2, %1, %0");
19759 #line 1122 "rx-decode.opc"
19760 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19763 break;
19765 break;
19766 case 0xa1:
19767 GETBYTE ();
19768 switch (op[2] & 0x00)
19770 case 0x00:
19771 goto op_semantics_151;
19772 break;
19774 break;
19775 case 0xa2:
19776 GETBYTE ();
19777 switch (op[2] & 0x00)
19779 case 0x00:
19780 goto op_semantics_151;
19781 break;
19783 break;
19784 case 0xa3:
19785 GETBYTE ();
19786 switch (op[2] & 0x00)
19788 case 0x00:
19789 goto op_semantics_151;
19790 break;
19792 break;
19793 case 0xa4:
19794 GETBYTE ();
19795 switch (op[2] & 0x00)
19797 case 0x00:
19798 goto op_semantics_151;
19799 break;
19801 break;
19802 case 0xa5:
19803 GETBYTE ();
19804 switch (op[2] & 0x00)
19806 case 0x00:
19807 goto op_semantics_151;
19808 break;
19810 break;
19811 case 0xa6:
19812 GETBYTE ();
19813 switch (op[2] & 0x00)
19815 case 0x00:
19816 goto op_semantics_151;
19817 break;
19819 break;
19820 case 0xa7:
19821 GETBYTE ();
19822 switch (op[2] & 0x00)
19824 case 0x00:
19825 goto op_semantics_151;
19826 break;
19828 break;
19829 case 0xa8:
19830 GETBYTE ();
19831 switch (op[2] & 0x00)
19833 case 0x00:
19834 goto op_semantics_151;
19835 break;
19837 break;
19838 case 0xa9:
19839 GETBYTE ();
19840 switch (op[2] & 0x00)
19842 case 0x00:
19843 goto op_semantics_151;
19844 break;
19846 break;
19847 case 0xaa:
19848 GETBYTE ();
19849 switch (op[2] & 0x00)
19851 case 0x00:
19852 goto op_semantics_151;
19853 break;
19855 break;
19856 case 0xab:
19857 GETBYTE ();
19858 switch (op[2] & 0x00)
19860 case 0x00:
19861 goto op_semantics_151;
19862 break;
19864 break;
19865 case 0xac:
19866 GETBYTE ();
19867 switch (op[2] & 0x00)
19869 case 0x00:
19870 goto op_semantics_151;
19871 break;
19873 break;
19874 case 0xad:
19875 GETBYTE ();
19876 switch (op[2] & 0x00)
19878 case 0x00:
19879 goto op_semantics_151;
19880 break;
19882 break;
19883 case 0xae:
19884 GETBYTE ();
19885 switch (op[2] & 0x00)
19887 case 0x00:
19888 goto op_semantics_151;
19889 break;
19891 break;
19892 case 0xaf:
19893 GETBYTE ();
19894 switch (op[2] & 0x00)
19896 case 0x00:
19897 goto op_semantics_151;
19898 break;
19900 break;
19901 case 0xb0:
19902 GETBYTE ();
19903 switch (op[2] & 0x00)
19905 case 0x00:
19906 op_semantics_152:
19908 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
19909 #line 1128 "rx-decode.opc"
19910 int rdst AU = op[1] & 0x0f;
19911 #line 1128 "rx-decode.opc"
19912 int srca AU = (op[2] >> 4) & 0x0f;
19913 #line 1128 "rx-decode.opc"
19914 int srcb AU = op[2] & 0x0f;
19915 if (trace)
19917 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19918 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
19919 op[0], op[1], op[2]);
19920 printf (" rdst = 0x%x,", rdst);
19921 printf (" srca = 0x%x,", srca);
19922 printf (" srcb = 0x%x\n", srcb);
19924 SYNTAX("fmul %2, %1, %0");
19925 #line 1128 "rx-decode.opc"
19926 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19929 break;
19931 break;
19932 case 0xb1:
19933 GETBYTE ();
19934 switch (op[2] & 0x00)
19936 case 0x00:
19937 goto op_semantics_152;
19938 break;
19940 break;
19941 case 0xb2:
19942 GETBYTE ();
19943 switch (op[2] & 0x00)
19945 case 0x00:
19946 goto op_semantics_152;
19947 break;
19949 break;
19950 case 0xb3:
19951 GETBYTE ();
19952 switch (op[2] & 0x00)
19954 case 0x00:
19955 goto op_semantics_152;
19956 break;
19958 break;
19959 case 0xb4:
19960 GETBYTE ();
19961 switch (op[2] & 0x00)
19963 case 0x00:
19964 goto op_semantics_152;
19965 break;
19967 break;
19968 case 0xb5:
19969 GETBYTE ();
19970 switch (op[2] & 0x00)
19972 case 0x00:
19973 goto op_semantics_152;
19974 break;
19976 break;
19977 case 0xb6:
19978 GETBYTE ();
19979 switch (op[2] & 0x00)
19981 case 0x00:
19982 goto op_semantics_152;
19983 break;
19985 break;
19986 case 0xb7:
19987 GETBYTE ();
19988 switch (op[2] & 0x00)
19990 case 0x00:
19991 goto op_semantics_152;
19992 break;
19994 break;
19995 case 0xb8:
19996 GETBYTE ();
19997 switch (op[2] & 0x00)
19999 case 0x00:
20000 goto op_semantics_152;
20001 break;
20003 break;
20004 case 0xb9:
20005 GETBYTE ();
20006 switch (op[2] & 0x00)
20008 case 0x00:
20009 goto op_semantics_152;
20010 break;
20012 break;
20013 case 0xba:
20014 GETBYTE ();
20015 switch (op[2] & 0x00)
20017 case 0x00:
20018 goto op_semantics_152;
20019 break;
20021 break;
20022 case 0xbb:
20023 GETBYTE ();
20024 switch (op[2] & 0x00)
20026 case 0x00:
20027 goto op_semantics_152;
20028 break;
20030 break;
20031 case 0xbc:
20032 GETBYTE ();
20033 switch (op[2] & 0x00)
20035 case 0x00:
20036 goto op_semantics_152;
20037 break;
20039 break;
20040 case 0xbd:
20041 GETBYTE ();
20042 switch (op[2] & 0x00)
20044 case 0x00:
20045 goto op_semantics_152;
20046 break;
20048 break;
20049 case 0xbe:
20050 GETBYTE ();
20051 switch (op[2] & 0x00)
20053 case 0x00:
20054 goto op_semantics_152;
20055 break;
20057 break;
20058 case 0xbf:
20059 GETBYTE ();
20060 switch (op[2] & 0x00)
20062 case 0x00:
20063 goto op_semantics_152;
20064 break;
20066 break;
20067 default: UNSUPPORTED(); break;
20069 break;
20070 default: UNSUPPORTED(); break;
20072 #line 1280 "rx-decode.opc"
20074 return rx->n_bytes;