projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
CommitLineData
f282425e 1#line 1 "rx-decode.opc"
c7927a3c
NC		 2/* -*- c -*- */
3#include <stdio.h>
4#include <stdlib.h>
5#include <string.h>
6
7#include "config.h"
8#include "ansidecl.h"
9#include "opcode/rx.h"
10
11#define RX_OPCODE_BIG_ENDIAN 0
12
13typedef struct
14{
15 RX_Opcode_Decoded * rx;
16 int (* getbyte)(void *);
17 void * ptr;
18 unsigned char * op;
19} LocalData;
20
21static int trace = 0;
22
23#define BSIZE 0
24#define WSIZE 1
25#define LSIZE 2
26
27/* These are for when the upper bits are "don't care" or "undefined". */
28static int bwl[] =
29{
30 RX_Byte,
31 RX_Word,
32 RX_Long
33};
34
35static int sbwl[] =
36{
37 RX_SByte,
38 RX_SWord,
39 RX_Long
40};
41
42static int ubwl[] =
43{
44 RX_UByte,
45 RX_UWord,
46 RX_Long
47};
48
49static int memex[] =
50{
51 RX_SByte,
52 RX_SWord,
53 RX_Long,
54 RX_UWord
55};
56
57#define ID(x) rx->id = RXO_##x
58#define OP(n,t,r,a) (rx->op[n].type = t, \
59 rx->op[n].reg = r, \
60 rx->op[n].addend = a )
61#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
62 rx->op[n].size = s )
63
64/* This is for the BWL and BW bitfields. */
65static int SCALE[] = { 1, 2, 4 };
66/* This is for the prefix size enum. */
67static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
68
69static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
70 16, 17, 0, 0, 0, 0, 0, 0 };
71
72static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
73
74/*
75 *C a constant (immediate) c
76 *R A register
77 *I Register indirect, no offset
78 *Is Register indirect, with offset
79 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
80 *P standard displacement: type (r,[r]), reg, assumes UByte
81 *Pm memex displacement: type (r,[r]), reg, memex code
82 *cc condition code. */
83
84#define DC(c) OP (0, RX_Operand_Immediate, 0, c)
85#define DR(r) OP (0, RX_Operand_Register, r, 0)
86#define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
87#define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
88#define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
89#define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
90
91#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
92#define SR(r) OP (1, RX_Operand_Register, r, 0)
93#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
94#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
95#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
96#define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
97#define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
98#define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
99
100#define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
101#define S2R(r) OP (2, RX_Operand_Register, r, 0)
102#define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
103#define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
104#define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
105#define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
106#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
107#define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
108
109#define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
110#define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
111#define uBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
112#define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
113
114#define F(f) store_flags(rx, f)
115
116#define AU ATTRIBUTE_UNUSED
117#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
118
119#define SYNTAX(x) rx->syntax = x
120
121#define UNSUPPORTED() \
122 rx->syntax = "*unknown*"
123
124#define IMM(sf) immediate (sf, 0, ld)
125#define IMMex(sf) immediate (sf, 1, ld)
126
127static int
128immediate (int sfield, int ex, LocalData * ld)
129{
130 unsigned long i = 0, j;
131
132 switch (sfield)
133 {
134#define B ((unsigned long) GETBYTE())
135 case 0:
136#if RX_OPCODE_BIG_ENDIAN
137 i = B;
138 if (ex && (i & 0x80))
139 i -= 0x100;
140 i <<= 24;
141 i |= B << 16;
142 i |= B << 8;
143 i |= B;
144#else
145 i = B;
146 i |= B << 8;
147 i |= B << 16;
148 j = B;
149 if (ex && (j & 0x80))
150 j -= 0x100;
151 i |= j << 24;
152#endif
153 break;
154 case 3:
155#if RX_OPCODE_BIG_ENDIAN
156 i = B << 16;
157 i |= B << 8;
158 i |= B;
159#else
160 i = B;
161 i |= B << 8;
162 i |= B << 16;
163#endif
164 if (ex && (i & 0x800000))
165 i -= 0x1000000;
166 break;
167 case 2:
168#if RX_OPCODE_BIG_ENDIAN
169 i |= B << 8;
170 i |= B;
171#else
172 i |= B;
173 i |= B << 8;
174#endif
175 if (ex && (i & 0x8000))
176 i -= 0x10000;
177 break;
178 case 1:
179 i |= B;
180 if (ex && (i & 0x80))
181 i -= 0x100;
182 break;
183 default:
184 abort();
185 }
186 return i;
187}
188
189static void
190rx_disp (int n, int type, int reg, int size, LocalData * ld)
191{
192 int disp;
193
194 ld->rx->op[n].reg = reg;
195 switch (type)
196 {
197 case 3:
198 ld->rx->op[n].type = RX_Operand_Register;
199 break;
200 case 0:
201 ld->rx->op[n].type = RX_Operand_Indirect;
202 ld->rx->op[n].addend = 0;
203 break;
204 case 1:
205 ld->rx->op[n].type = RX_Operand_Indirect;
206 disp = GETBYTE ();
207 ld->rx->op[n].addend = disp * PSCALE[size];
208 break;
209 case 2:
210 ld->rx->op[n].type = RX_Operand_Indirect;
211 disp = GETBYTE ();
212#if RX_OPCODE_BIG_ENDIAN
213 disp = disp * 256 + GETBYTE ();
214#else
215 disp = disp + GETBYTE () * 256;
216#endif
217 ld->rx->op[n].addend = disp * PSCALE[size];
218 break;
219 default:
220 abort ();
221 }
222}
223
224/* The syntax is "OSZC" where each character is one of the following:
225 - = flag unchanged
226 0 = flag cleared
227 1 = flag set
228 ? = flag undefined
229 x = flag set (any letter will do, use it for hints :). */
230
231static void
232store_flags (RX_Opcode_Decoded * rx, char * str)
233{
234 int i, mask;
235 rx->flags_0 = 0;
236 rx->flags_1 = 0;
237 rx->flags_s = 0;
238
239 for (i = 0; i < 4; i++)
240 {
241 mask = 8 >> i;
242 switch (str[i])
243 {
244 case 0:
245 abort ();
246 case '-':
247 break;
248 case '0':
249 rx->flags_0 |= mask;
250 break;
251 case '1':
252 rx->flags_1 |= mask;
253 break;
254 case '?':
255 break;
256 default:
257 rx->flags_0 |= mask;
258 rx->flags_s |= mask;
259 break;
260 }
261 }
262}
263
264int
265rx_decode_opcode (unsigned long pc AU,
266 RX_Opcode_Decoded * rx,
267 int (* getbyte)(void *),
268 void * ptr)
269{
270 LocalData lds, * ld = &lds;
271 unsigned char op[20] = {0};
272
273 lds.rx = rx;
274 lds.getbyte = getbyte;
275 lds.ptr = ptr;
276 lds.op = op;
277
278 memset (rx, 0, sizeof (*rx));
279 BWL(LSIZE);
280
281
282/*----------------------------------------------------------------------*/
283/* MOV */
284
285 GETBYTE ();
286 switch (op[0] & 0xff)
287 {
288 case 0x00:
289 {
290 /** 0000 0000 brk */
291 if (trace)
292 {
293 printf ("\033[33m%s\033[0m %02x\n",
294 "/** 0000 0000 brk */",
295 op[0]);
296 }
297 SYNTAX("brk");
946ef196 298#line 951 "rx-decode.opc"
c7927a3c
NC		 299 ID(brk);
300
301 }
302 break;
303 case 0x01:
304 {
305 /** 0000 0001 dbt */
306 if (trace)
307 {
308 printf ("\033[33m%s\033[0m %02x\n",
309 "/** 0000 0001 dbt */",
310 op[0]);
311 }
312 SYNTAX("dbt");
946ef196 313#line 954 "rx-decode.opc"
c7927a3c
NC		 314 ID(dbt);
315
316 }
317 break;
318 case 0x02:
319 {
320 /** 0000 0010 rts */
321 if (trace)
322 {
323 printf ("\033[33m%s\033[0m %02x\n",
324 "/** 0000 0010 rts */",
325 op[0]);
326 }
327 SYNTAX("rts");
f282425e 328#line 740 "rx-decode.opc"
c7927a3c
NC		 329 ID(rts);
330
331 /*----------------------------------------------------------------------*/
332 /* NOP */
333
334 }
335 break;
336 case 0x03:
337 {
338 /** 0000 0011 nop */
339 if (trace)
340 {
341 printf ("\033[33m%s\033[0m %02x\n",
342 "/** 0000 0011 nop */",
343 op[0]);
344 }
345 SYNTAX("nop");
f282425e 346#line 746 "rx-decode.opc"
c7927a3c
NC		 347 ID(nop);
348
349 /*----------------------------------------------------------------------*/
350 /* STRING FUNCTIONS */
351
352 }
353 break;
354 case 0x04:
355 {
356 /** 0000 0100 bra.a %a0 */
357 if (trace)
358 {
359 printf ("\033[33m%s\033[0m %02x\n",
360 "/** 0000 0100 bra.a %a0 */",
361 op[0]);
362 }
363 SYNTAX("bra.a %a0");
f282425e 364#line 718 "rx-decode.opc"
c7927a3c
NC		 365 ID(branch); Scc(RXC_always); DC(pc + IMMex(3));
366
367 }
368 break;
369 case 0x05:
370 {
371 /** 0000 0101 bsr.a %a0 */
372 if (trace)
373 {
374 printf ("\033[33m%s\033[0m %02x\n",
375 "/** 0000 0101 bsr.a %a0 */",
376 op[0]);
377 }
378 SYNTAX("bsr.a %a0");
f282425e 379#line 734 "rx-decode.opc"
c7927a3c
NC		 380 ID(jsr); DC(pc + IMMex(3));
381
382 }
383 break;
384 case 0x06:
385 GETBYTE ();
386 switch (op[1] & 0xff)
387 {
388 case 0x00:
389 GETBYTE ();
390 switch (op[2] & 0x00)
391 {
392 case 0x00:
393 op_semantics_1:
394 {
395 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
f282425e 396#line 522 "rx-decode.opc"
c7927a3c 397 int mx AU = (op[1] >> 6) & 0x03;
f282425e 398#line 522 "rx-decode.opc"
c7927a3c 399 int ss AU = op[1] & 0x03;
f282425e 400#line 522 "rx-decode.opc"
c7927a3c 401 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 402#line 522 "rx-decode.opc"
c7927a3c
NC		 403 int rdst AU = op[2] & 0x0f;
404 if (trace)
405 {
406 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
407 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
408 op[0], op[1], op[2]);
409 printf (" mx = 0x%x,", mx);
410 printf (" ss = 0x%x,", ss);
411 printf (" rsrc = 0x%x,", rsrc);
412 printf (" rdst = 0x%x\n", rdst);
413 }
414 SYNTAX("sub %2%S2, %1");
f282425e 415#line 522 "rx-decode.opc"
c7927a3c
NC		 416 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F("OSZC");
417
418 }
419 break;
420 }
421 break;
422 case 0x01:
423 GETBYTE ();
424 switch (op[2] & 0x00)
425 {
426 case 0x00:
427 goto op_semantics_1;
428 break;
429 }
430 break;
431 case 0x02:
432 GETBYTE ();
433 switch (op[2] & 0x00)
434 {
435 case 0x00:
436 goto op_semantics_1;
437 break;
438 }
439 break;
440 case 0x03:
441 GETBYTE ();
442 switch (op[2] & 0x00)
443 {
444 case 0x00:
445 goto op_semantics_1;
446 break;
447 }
448 break;
449 case 0x04:
450 GETBYTE ();
451 switch (op[2] & 0x00)
452 {
453 case 0x00:
454 op_semantics_2:
455 {
456 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
f282425e 457#line 510 "rx-decode.opc"
c7927a3c 458 int mx AU = (op[1] >> 6) & 0x03;
f282425e 459#line 510 "rx-decode.opc"
c7927a3c 460 int ss AU = op[1] & 0x03;
f282425e 461#line 510 "rx-decode.opc"
c7927a3c 462 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 463#line 510 "rx-decode.opc"
c7927a3c
NC		 464 int rdst AU = op[2] & 0x0f;
465 if (trace)
466 {
467 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
468 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
469 op[0], op[1], op[2]);
470 printf (" mx = 0x%x,", mx);
471 printf (" ss = 0x%x,", ss);
472 printf (" rsrc = 0x%x,", rsrc);
473 printf (" rdst = 0x%x\n", rdst);
474 }
475 SYNTAX("cmp %2%S2, %1");
f282425e 476#line 510 "rx-decode.opc"
c7927a3c
NC		 477 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F("OSZC");
478
479 /*----------------------------------------------------------------------*/
480 /* SUB */
481
482 }
483 break;
484 }
485 break;
486 case 0x05:
487 GETBYTE ();
488 switch (op[2] & 0x00)
489 {
490 case 0x00:
491 goto op_semantics_2;
492 break;
493 }
494 break;
495 case 0x06:
496 GETBYTE ();
497 switch (op[2] & 0x00)
498 {
499 case 0x00:
500 goto op_semantics_2;
501 break;
502 }
503 break;
504 case 0x07:
505 GETBYTE ();
506 switch (op[2] & 0x00)
507 {
508 case 0x00:
509 goto op_semantics_2;
510 break;
511 }
512 break;
513 case 0x08:
514 GETBYTE ();
515 switch (op[2] & 0x00)
516 {
517 case 0x00:
518 op_semantics_3:
519 {
520 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
f282425e 521#line 486 "rx-decode.opc"
c7927a3c 522 int mx AU = (op[1] >> 6) & 0x03;
f282425e 523#line 486 "rx-decode.opc"
c7927a3c 524 int ss AU = op[1] & 0x03;
f282425e 525#line 486 "rx-decode.opc"
c7927a3c 526 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 527#line 486 "rx-decode.opc"
c7927a3c
NC		 528 int rdst AU = op[2] & 0x0f;
529 if (trace)
530 {
531 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
532 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
533 op[0], op[1], op[2]);
534 printf (" mx = 0x%x,", mx);
535 printf (" ss = 0x%x,", ss);
536 printf (" rsrc = 0x%x,", rsrc);
537 printf (" rdst = 0x%x\n", rdst);
538 }
539 SYNTAX("add %1%S1, %0");
f282425e 540#line 486 "rx-decode.opc"
c7927a3c
NC		 541 ID(add); SPm(ss, rsrc, mx); DR(rdst); F("OSZC");
542
543 }
544 break;
545 }
546 break;
547 case 0x09:
548 GETBYTE ();
549 switch (op[2] & 0x00)
550 {
551 case 0x00:
552 goto op_semantics_3;
553 break;
554 }
555 break;
556 case 0x0a:
557 GETBYTE ();
558 switch (op[2] & 0x00)
559 {
560 case 0x00:
561 goto op_semantics_3;
562 break;
563 }
564 break;
565 case 0x0b:
566 GETBYTE ();
567 switch (op[2] & 0x00)
568 {
569 case 0x00:
570 goto op_semantics_3;
571 break;
572 }
573 break;
574 case 0x0c:
575 GETBYTE ();
576 switch (op[2] & 0x00)
577 {
578 case 0x00:
579 op_semantics_4:
580 {
581 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
f282425e 582#line 583 "rx-decode.opc"
c7927a3c 583 int mx AU = (op[1] >> 6) & 0x03;
f282425e 584#line 583 "rx-decode.opc"
c7927a3c 585 int ss AU = op[1] & 0x03;
f282425e 586#line 583 "rx-decode.opc"
c7927a3c 587 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 588#line 583 "rx-decode.opc"
c7927a3c
NC		 589 int rdst AU = op[2] & 0x0f;
590 if (trace)
591 {
592 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
593 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
594 op[0], op[1], op[2]);
595 printf (" mx = 0x%x,", mx);
596 printf (" ss = 0x%x,", ss);
597 printf (" rsrc = 0x%x,", rsrc);
598 printf (" rdst = 0x%x\n", rdst);
599 }
600 SYNTAX("mul %1%S1, %0");
f282425e
DD		 601#line 583 "rx-decode.opc"
602 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F("----");
c7927a3c
NC		 603
604 }
605 break;
606 }
607 break;
608 case 0x0d:
609 GETBYTE ();
610 switch (op[2] & 0x00)
611 {
612 case 0x00:
613 goto op_semantics_4;
614 break;
615 }
616 break;
617 case 0x0e:
618 GETBYTE ();
619 switch (op[2] & 0x00)
620 {
621 case 0x00:
622 goto op_semantics_4;
623 break;
624 }
625 break;
626 case 0x0f:
627 GETBYTE ();
628 switch (op[2] & 0x00)
629 {
630 case 0x00:
631 goto op_semantics_4;
632 break;
633 }
634 break;
635 case 0x10:
636 GETBYTE ();
637 switch (op[2] & 0x00)
638 {
639 case 0x00:
640 op_semantics_5:
641 {
642 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
f282425e 643#line 399 "rx-decode.opc"
c7927a3c 644 int mx AU = (op[1] >> 6) & 0x03;
f282425e 645#line 399 "rx-decode.opc"
c7927a3c 646 int ss AU = op[1] & 0x03;
f282425e 647#line 399 "rx-decode.opc"
c7927a3c 648 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 649#line 399 "rx-decode.opc"
c7927a3c
NC		 650 int rdst AU = op[2] & 0x0f;
651 if (trace)
652 {
653 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
654 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
655 op[0], op[1], op[2]);
656 printf (" mx = 0x%x,", mx);
657 printf (" ss = 0x%x,", ss);
658 printf (" rsrc = 0x%x,", rsrc);
659 printf (" rdst = 0x%x\n", rdst);
660 }
661 SYNTAX("and %1%S1, %0");
f282425e 662#line 399 "rx-decode.opc"
c7927a3c
NC		 663 ID(and); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
664
665 }
666 break;
667 }
668 break;
669 case 0x11:
670 GETBYTE ();
671 switch (op[2] & 0x00)
672 {
673 case 0x00:
674 goto op_semantics_5;
675 break;
676 }
677 break;
678 case 0x12:
679 GETBYTE ();
680 switch (op[2] & 0x00)
681 {
682 case 0x00:
683 goto op_semantics_5;
684 break;
685 }
686 break;
687 case 0x13:
688 GETBYTE ();
689 switch (op[2] & 0x00)
690 {
691 case 0x00:
692 goto op_semantics_5;
693 break;
694 }
695 break;
696 case 0x14:
697 GETBYTE ();
698 switch (op[2] & 0x00)
699 {
700 case 0x00:
701 op_semantics_6:
702 {
703 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
f282425e 704#line 417 "rx-decode.opc"
c7927a3c 705 int mx AU = (op[1] >> 6) & 0x03;
f282425e 706#line 417 "rx-decode.opc"
c7927a3c 707 int ss AU = op[1] & 0x03;
f282425e 708#line 417 "rx-decode.opc"
c7927a3c 709 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 710#line 417 "rx-decode.opc"
c7927a3c
NC		 711 int rdst AU = op[2] & 0x0f;
712 if (trace)
713 {
714 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
715 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
716 op[0], op[1], op[2]);
717 printf (" mx = 0x%x,", mx);
718 printf (" ss = 0x%x,", ss);
719 printf (" rsrc = 0x%x,", rsrc);
720 printf (" rdst = 0x%x\n", rdst);
721 }
722 SYNTAX("or %1%S1, %0");
f282425e 723#line 417 "rx-decode.opc"
c7927a3c
NC		 724 ID(or); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
725
726 }
727 break;
728 }
729 break;
730 case 0x15:
731 GETBYTE ();
732 switch (op[2] & 0x00)
733 {
734 case 0x00:
735 goto op_semantics_6;
736 break;
737 }
738 break;
739 case 0x16:
740 GETBYTE ();
741 switch (op[2] & 0x00)
742 {
743 case 0x00:
744 goto op_semantics_6;
745 break;
746 }
747 break;
748 case 0x17:
749 GETBYTE ();
750 switch (op[2] & 0x00)
751 {
752 case 0x00:
753 goto op_semantics_6;
754 break;
755 }
756 break;
757 case 0x20:
758 GETBYTE ();
759 switch (op[2] & 0xff)
760 {
761 case 0x00:
762 GETBYTE ();
763 switch (op[3] & 0x00)
764 {
765 case 0x00:
766 op_semantics_7:
767 {
768 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
f282425e 769#line 535 "rx-decode.opc"
c7927a3c 770 int mx AU = (op[1] >> 6) & 0x03;
f282425e 771#line 535 "rx-decode.opc"
c7927a3c 772 int sp AU = op[1] & 0x03;
f282425e 773#line 535 "rx-decode.opc"
c7927a3c 774 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 775#line 535 "rx-decode.opc"
c7927a3c
NC		 776 int rdst AU = op[3] & 0x0f;
777 if (trace)
778 {
779 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
780 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
781 op[0], op[1], op[2], op[3]);
782 printf (" mx = 0x%x,", mx);
783 printf (" sp = 0x%x,", sp);
784 printf (" rsrc = 0x%x,", rsrc);
785 printf (" rdst = 0x%x\n", rdst);
786 }
787 SYNTAX("sbb %1%S1, %0");
f282425e 788#line 535 "rx-decode.opc"
c7927a3c
NC		 789 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F("OSZC");
790
791 /*----------------------------------------------------------------------*/
792 /* ABS */
793
794 }
795 break;
796 }
797 break;
798 case 0x04:
799 GETBYTE ();
800 switch (op[3] & 0x00)
801 {
802 case 0x00:
803 op_semantics_8:
804 {
805 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
f282425e 806#line 556 "rx-decode.opc"
c7927a3c 807 int mx AU = (op[1] >> 6) & 0x03;
f282425e 808#line 556 "rx-decode.opc"
c7927a3c 809 int ss AU = op[1] & 0x03;
f282425e 810#line 556 "rx-decode.opc"
c7927a3c 811 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 812#line 556 "rx-decode.opc"
c7927a3c
NC		 813 int rdst AU = op[3] & 0x0f;
814 if (trace)
815 {
816 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
817 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
818 op[0], op[1], op[2], op[3]);
819 printf (" mx = 0x%x,", mx);
820 printf (" ss = 0x%x,", ss);
821 printf (" rsrc = 0x%x,", rsrc);
822 printf (" rdst = 0x%x\n", rdst);
823 }
824 SYNTAX("max %1%S1, %0");
f282425e 825#line 556 "rx-decode.opc"
c7927a3c
NC		 826 ID(max); SPm(ss, rsrc, mx); DR(rdst);
827
828 /*----------------------------------------------------------------------*/
829 /* MIN */
830
831 }
832 break;
833 }
834 break;
835 case 0x05:
836 GETBYTE ();
837 switch (op[3] & 0x00)
838 {
839 case 0x00:
840 op_semantics_9:
841 {
842 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
f282425e 843#line 568 "rx-decode.opc"
c7927a3c 844 int mx AU = (op[1] >> 6) & 0x03;
f282425e 845#line 568 "rx-decode.opc"
c7927a3c 846 int ss AU = op[1] & 0x03;
f282425e 847#line 568 "rx-decode.opc"
c7927a3c 848 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 849#line 568 "rx-decode.opc"
c7927a3c
NC		 850 int rdst AU = op[3] & 0x0f;
851 if (trace)
852 {
853 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
854 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
855 op[0], op[1], op[2], op[3]);
856 printf (" mx = 0x%x,", mx);
857 printf (" ss = 0x%x,", ss);
858 printf (" rsrc = 0x%x,", rsrc);
859 printf (" rdst = 0x%x\n", rdst);
860 }
861 SYNTAX("min %1%S1, %0");
f282425e 862#line 568 "rx-decode.opc"
c7927a3c
NC		 863 ID(min); SPm(ss, rsrc, mx); DR(rdst);
864
865 /*----------------------------------------------------------------------*/
866 /* MUL */
867
868 }
869 break;
870 }
871 break;
872 case 0x06:
873 GETBYTE ();
874 switch (op[3] & 0x00)
875 {
876 case 0x00:
877 op_semantics_10:
878 {
879 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
f282425e 880#line 598 "rx-decode.opc"
c7927a3c 881 int mx AU = (op[1] >> 6) & 0x03;
f282425e 882#line 598 "rx-decode.opc"
c7927a3c 883 int ss AU = op[1] & 0x03;
f282425e 884#line 598 "rx-decode.opc"
c7927a3c 885 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 886#line 598 "rx-decode.opc"
c7927a3c
NC		 887 int rdst AU = op[3] & 0x0f;
888 if (trace)
889 {
890 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
891 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
892 op[0], op[1], op[2], op[3]);
893 printf (" mx = 0x%x,", mx);
894 printf (" ss = 0x%x,", ss);
895 printf (" rsrc = 0x%x,", rsrc);
896 printf (" rdst = 0x%x\n", rdst);
897 }
898 SYNTAX("emul %1%S1, %0");
f282425e 899#line 598 "rx-decode.opc"
c7927a3c
NC		 900 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
901
902 /*----------------------------------------------------------------------*/
903 /* EMULU */
904
905 }
906 break;
907 }
908 break;
909 case 0x07:
910 GETBYTE ();
911 switch (op[3] & 0x00)
912 {
913 case 0x00:
914 op_semantics_11:
915 {
916 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
f282425e 917#line 610 "rx-decode.opc"
c7927a3c 918 int mx AU = (op[1] >> 6) & 0x03;
f282425e 919#line 610 "rx-decode.opc"
c7927a3c 920 int ss AU = op[1] & 0x03;
f282425e 921#line 610 "rx-decode.opc"
c7927a3c 922 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 923#line 610 "rx-decode.opc"
c7927a3c
NC		 924 int rdst AU = op[3] & 0x0f;
925 if (trace)
926 {
927 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
928 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
929 op[0], op[1], op[2], op[3]);
930 printf (" mx = 0x%x,", mx);
931 printf (" ss = 0x%x,", ss);
932 printf (" rsrc = 0x%x,", rsrc);
933 printf (" rdst = 0x%x\n", rdst);
934 }
935 SYNTAX("emulu %1%S1, %0");
f282425e 936#line 610 "rx-decode.opc"
c7927a3c
NC		 937 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
938
939 /*----------------------------------------------------------------------*/
940 /* DIV */
941
942 }
943 break;
944 }
945 break;
946 case 0x08:
947 GETBYTE ();
948 switch (op[3] & 0x00)
949 {
950 case 0x00:
951 op_semantics_12:
952 {
953 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
f282425e 954#line 622 "rx-decode.opc"
c7927a3c 955 int mx AU = (op[1] >> 6) & 0x03;
f282425e 956#line 622 "rx-decode.opc"
c7927a3c 957 int ss AU = op[1] & 0x03;
f282425e 958#line 622 "rx-decode.opc"
c7927a3c 959 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 960#line 622 "rx-decode.opc"
c7927a3c
NC		 961 int rdst AU = op[3] & 0x0f;
962 if (trace)
963 {
964 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
965 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
966 op[0], op[1], op[2], op[3]);
967 printf (" mx = 0x%x,", mx);
968 printf (" ss = 0x%x,", ss);
969 printf (" rsrc = 0x%x,", rsrc);
970 printf (" rdst = 0x%x\n", rdst);
971 }
972 SYNTAX("div %1%S1, %0");
f282425e 973#line 622 "rx-decode.opc"
c7927a3c
NC		 974 ID(div); SPm(ss, rsrc, mx); DR(rdst); F("O---");
975
976 /*----------------------------------------------------------------------*/
977 /* DIVU */
978
979 }
980 break;
981 }
982 break;
983 case 0x09:
984 GETBYTE ();
985 switch (op[3] & 0x00)
986 {
987 case 0x00:
988 op_semantics_13:
989 {
990 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
f282425e 991#line 634 "rx-decode.opc"
c7927a3c 992 int mx AU = (op[1] >> 6) & 0x03;
f282425e 993#line 634 "rx-decode.opc"
c7927a3c 994 int ss AU = op[1] & 0x03;
f282425e 995#line 634 "rx-decode.opc"
c7927a3c 996 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 997#line 634 "rx-decode.opc"
c7927a3c
NC		 998 int rdst AU = op[3] & 0x0f;
999 if (trace)
1000 {
1001 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1002 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1003 op[0], op[1], op[2], op[3]);
1004 printf (" mx = 0x%x,", mx);
1005 printf (" ss = 0x%x,", ss);
1006 printf (" rsrc = 0x%x,", rsrc);
1007 printf (" rdst = 0x%x\n", rdst);
1008 }
1009 SYNTAX("divu %1%S1, %0");
f282425e 1010#line 634 "rx-decode.opc"
c7927a3c
NC		 1011 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F("O---");
1012
1013 /*----------------------------------------------------------------------*/
1014 /* SHIFT */
1015
1016 }
1017 break;
1018 }
1019 break;
1020 case 0x0c:
1021 GETBYTE ();
1022 switch (op[3] & 0x00)
1023 {
1024 case 0x00:
1025 op_semantics_14:
1026 {
1027 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
f282425e 1028#line 453 "rx-decode.opc"
c7927a3c 1029 int mx AU = (op[1] >> 6) & 0x03;
f282425e 1030#line 453 "rx-decode.opc"
c7927a3c 1031 int ss AU = op[1] & 0x03;
f282425e 1032#line 453 "rx-decode.opc"
c7927a3c 1033 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 1034#line 453 "rx-decode.opc"
c7927a3c
NC		 1035 int rdst AU = op[3] & 0x0f;
1036 if (trace)
1037 {
1038 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1039 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1040 op[0], op[1], op[2], op[3]);
1041 printf (" mx = 0x%x,", mx);
1042 printf (" ss = 0x%x,", ss);
1043 printf (" rsrc = 0x%x,", rsrc);
1044 printf (" rdst = 0x%x\n", rdst);
1045 }
1046 SYNTAX("tst %1%S1, %2");
f282425e 1047#line 453 "rx-decode.opc"
c7927a3c
NC		 1048 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F("-SZ-");
1049
1050 /*----------------------------------------------------------------------*/
1051 /* NEG */
1052
1053 }
1054 break;
1055 }
1056 break;
1057 case 0x0d:
1058 GETBYTE ();
1059 switch (op[3] & 0x00)
1060 {
1061 case 0x00:
1062 op_semantics_15:
1063 {
1064 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
f282425e 1065#line 432 "rx-decode.opc"
c7927a3c 1066 int mx AU = (op[1] >> 6) & 0x03;
f282425e 1067#line 432 "rx-decode.opc"
c7927a3c 1068 int ss AU = op[1] & 0x03;
f282425e 1069#line 432 "rx-decode.opc"
c7927a3c 1070 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 1071#line 432 "rx-decode.opc"
c7927a3c
NC		 1072 int rdst AU = op[3] & 0x0f;
1073 if (trace)
1074 {
1075 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1076 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1077 op[0], op[1], op[2], op[3]);
1078 printf (" mx = 0x%x,", mx);
1079 printf (" ss = 0x%x,", ss);
1080 printf (" rsrc = 0x%x,", rsrc);
1081 printf (" rdst = 0x%x\n", rdst);
1082 }
1083 SYNTAX("xor %1%S1, %0");
f282425e 1084#line 432 "rx-decode.opc"
c7927a3c
NC		 1085 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
1086
1087 /*----------------------------------------------------------------------*/
1088 /* NOT */
1089
1090 }
1091 break;
1092 }
1093 break;
1094 case 0x10:
1095 GETBYTE ();
1096 switch (op[3] & 0x00)
1097 {
1098 case 0x00:
1099 op_semantics_16:
1100 {
1101 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
f282425e 1102#line 366 "rx-decode.opc"
c7927a3c 1103 int mx AU = (op[1] >> 6) & 0x03;
f282425e 1104#line 366 "rx-decode.opc"
c7927a3c 1105 int ss AU = op[1] & 0x03;
f282425e 1106#line 366 "rx-decode.opc"
c7927a3c 1107 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 1108#line 366 "rx-decode.opc"
c7927a3c
NC		 1109 int rdst AU = op[3] & 0x0f;
1110 if (trace)
1111 {
1112 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1113 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1114 op[0], op[1], op[2], op[3]);
1115 printf (" mx = 0x%x,", mx);
1116 printf (" ss = 0x%x,", ss);
1117 printf (" rsrc = 0x%x,", rsrc);
1118 printf (" rdst = 0x%x\n", rdst);
1119 }
1120 SYNTAX("xchg %1%S1, %0");
f282425e 1121#line 366 "rx-decode.opc"
c7927a3c
NC		 1122 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1123
1124 /*----------------------------------------------------------------------*/
1125 /* STZ/STNZ */
1126
1127 }
1128 break;
1129 }
1130 break;
1131 case 0x11:
1132 GETBYTE ();
1133 switch (op[3] & 0x00)
1134 {
1135 case 0x00:
1136 op_semantics_17:
1137 {
1138 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
f282425e 1139#line 863 "rx-decode.opc"
c7927a3c 1140 int mx AU = (op[1] >> 6) & 0x03;
f282425e 1141#line 863 "rx-decode.opc"
c7927a3c 1142 int sd AU = op[1] & 0x03;
f282425e 1143#line 863 "rx-decode.opc"
c7927a3c 1144 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 1145#line 863 "rx-decode.opc"
c7927a3c
NC		 1146 int rdst AU = op[3] & 0x0f;
1147 if (trace)
1148 {
1149 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1150 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1151 op[0], op[1], op[2], op[3]);
1152 printf (" mx = 0x%x,", mx);
1153 printf (" sd = 0x%x,", sd);
1154 printf (" rsrc = 0x%x,", rsrc);
1155 printf (" rdst = 0x%x\n", rdst);
1156 }
1157 SYNTAX("itof %1%S1, %0");
f282425e 1158#line 863 "rx-decode.opc"
c7927a3c
NC		 1159 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F("-SZ-");
1160
1161 /*----------------------------------------------------------------------*/
1162 /* BIT OPS */
1163
1164 }
1165 break;
1166 }
1167 break;
1168 default: UNSUPPORTED(); break;
1169 }
1170 break;
1171 case 0x21:
1172 GETBYTE ();
1173 switch (op[2] & 0xff)
1174 {
1175 case 0x00:
1176 GETBYTE ();
1177 switch (op[3] & 0x00)
1178 {
1179 case 0x00:
1180 goto op_semantics_7;
1181 break;
1182 }
1183 break;
1184 case 0x04:
1185 GETBYTE ();
1186 switch (op[3] & 0x00)
1187 {
1188 case 0x00:
1189 goto op_semantics_8;
1190 break;
1191 }
1192 break;
1193 case 0x05:
1194 GETBYTE ();
1195 switch (op[3] & 0x00)
1196 {
1197 case 0x00:
1198 goto op_semantics_9;
1199 break;
1200 }
1201 break;
1202 case 0x06:
1203 GETBYTE ();
1204 switch (op[3] & 0x00)
1205 {
1206 case 0x00:
1207 goto op_semantics_10;
1208 break;
1209 }
1210 break;
1211 case 0x07:
1212 GETBYTE ();
1213 switch (op[3] & 0x00)
1214 {
1215 case 0x00:
1216 goto op_semantics_11;
1217 break;
1218 }
1219 break;
1220 case 0x08:
1221 GETBYTE ();
1222 switch (op[3] & 0x00)
1223 {
1224 case 0x00:
1225 goto op_semantics_12;
1226 break;
1227 }
1228 break;
1229 case 0x09:
1230 GETBYTE ();
1231 switch (op[3] & 0x00)
1232 {
1233 case 0x00:
1234 goto op_semantics_13;
1235 break;
1236 }
1237 break;
1238 case 0x0c:
1239 GETBYTE ();
1240 switch (op[3] & 0x00)
1241 {
1242 case 0x00:
1243 goto op_semantics_14;
1244 break;
1245 }
1246 break;
1247 case 0x0d:
1248 GETBYTE ();
1249 switch (op[3] & 0x00)
1250 {
1251 case 0x00:
1252 goto op_semantics_15;
1253 break;
1254 }
1255 break;
1256 case 0x10:
1257 GETBYTE ();
1258 switch (op[3] & 0x00)
1259 {
1260 case 0x00:
1261 goto op_semantics_16;
1262 break;
1263 }
1264 break;
1265 case 0x11:
1266 GETBYTE ();
1267 switch (op[3] & 0x00)
1268 {
1269 case 0x00:
1270 goto op_semantics_17;
1271 break;
1272 }
1273 break;
1274 default: UNSUPPORTED(); break;
1275 }
1276 break;
1277 case 0x22:
1278 GETBYTE ();
1279 switch (op[2] & 0xff)
1280 {
1281 case 0x00:
1282 GETBYTE ();
1283 switch (op[3] & 0x00)
1284 {
1285 case 0x00:
1286 goto op_semantics_7;
1287 break;
1288 }
1289 break;
1290 case 0x04:
1291 GETBYTE ();
1292 switch (op[3] & 0x00)
1293 {
1294 case 0x00:
1295 goto op_semantics_8;
1296 break;
1297 }
1298 break;
1299 case 0x05:
1300 GETBYTE ();
1301 switch (op[3] & 0x00)
1302 {
1303 case 0x00:
1304 goto op_semantics_9;
1305 break;
1306 }
1307 break;
1308 case 0x06:
1309 GETBYTE ();
1310 switch (op[3] & 0x00)
1311 {
1312 case 0x00:
1313 goto op_semantics_10;
1314 break;
1315 }
1316 break;
1317 case 0x07:
1318 GETBYTE ();
1319 switch (op[3] & 0x00)
1320 {
1321 case 0x00:
1322 goto op_semantics_11;
1323 break;
1324 }
1325 break;
1326 case 0x08:
1327 GETBYTE ();
1328 switch (op[3] & 0x00)
1329 {
1330 case 0x00:
1331 goto op_semantics_12;
1332 break;
1333 }
1334 break;
1335 case 0x09:
1336 GETBYTE ();
1337 switch (op[3] & 0x00)
1338 {
1339 case 0x00:
1340 goto op_semantics_13;
1341 break;
1342 }
1343 break;
1344 case 0x0c:
1345 GETBYTE ();
1346 switch (op[3] & 0x00)
1347 {
1348 case 0x00:
1349 goto op_semantics_14;
1350 break;
1351 }
1352 break;
1353 case 0x0d:
1354 GETBYTE ();
1355 switch (op[3] & 0x00)
1356 {
1357 case 0x00:
1358 goto op_semantics_15;
1359 break;
1360 }
1361 break;
1362 case 0x10:
1363 GETBYTE ();
1364 switch (op[3] & 0x00)
1365 {
1366 case 0x00:
1367 goto op_semantics_16;
1368 break;
1369 }
1370 break;
1371 case 0x11:
1372 GETBYTE ();
1373 switch (op[3] & 0x00)
1374 {
1375 case 0x00:
1376 goto op_semantics_17;
1377 break;
1378 }
1379 break;
1380 default: UNSUPPORTED(); break;
1381 }
1382 break;
1383 case 0x23:
1384 GETBYTE ();
1385 switch (op[2] & 0xff)
1386 {
1387 case 0x00:
1388 GETBYTE ();
1389 switch (op[3] & 0x00)
1390 {
1391 case 0x00:
1392 goto op_semantics_7;
1393 break;
1394 }
1395 break;
1396 case 0x04:
1397 GETBYTE ();
1398 switch (op[3] & 0x00)
1399 {
1400 case 0x00:
1401 goto op_semantics_8;
1402 break;
1403 }
1404 break;
1405 case 0x05:
1406 GETBYTE ();
1407 switch (op[3] & 0x00)
1408 {
1409 case 0x00:
1410 goto op_semantics_9;
1411 break;
1412 }
1413 break;
1414 case 0x06:
1415 GETBYTE ();
1416 switch (op[3] & 0x00)
1417 {
1418 case 0x00:
1419 goto op_semantics_10;
1420 break;
1421 }
1422 break;
1423 case 0x07:
1424 GETBYTE ();
1425 switch (op[3] & 0x00)
1426 {
1427 case 0x00:
1428 goto op_semantics_11;
1429 break;
1430 }
1431 break;
1432 case 0x08:
1433 GETBYTE ();
1434 switch (op[3] & 0x00)
1435 {
1436 case 0x00:
1437 goto op_semantics_12;
1438 break;
1439 }
1440 break;
1441 case 0x09:
1442 GETBYTE ();
1443 switch (op[3] & 0x00)
1444 {
1445 case 0x00:
1446 goto op_semantics_13;
1447 break;
1448 }
1449 break;
1450 case 0x0c:
1451 GETBYTE ();
1452 switch (op[3] & 0x00)
1453 {
1454 case 0x00:
1455 goto op_semantics_14;
1456 break;
1457 }
1458 break;
1459 case 0x0d:
1460 GETBYTE ();
1461 switch (op[3] & 0x00)
1462 {
1463 case 0x00:
1464 goto op_semantics_15;
1465 break;
1466 }
1467 break;
1468 case 0x10:
1469 GETBYTE ();
1470 switch (op[3] & 0x00)
1471 {
1472 case 0x00:
1473 goto op_semantics_16;
1474 break;
1475 }
1476 break;
1477 case 0x11:
1478 GETBYTE ();
1479 switch (op[3] & 0x00)
1480 {
1481 case 0x00:
1482 goto op_semantics_17;
1483 break;
1484 }
1485 break;
1486 default: UNSUPPORTED(); break;
1487 }
1488 break;
1489 case 0x40:
1490 GETBYTE ();
1491 switch (op[2] & 0x00)
1492 {
1493 case 0x00:
1494 goto op_semantics_1;
1495 break;
1496 }
1497 break;
1498 case 0x41:
1499 GETBYTE ();
1500 switch (op[2] & 0x00)
1501 {
1502 case 0x00:
1503 goto op_semantics_1;
1504 break;
1505 }
1506 break;
1507 case 0x42:
1508 GETBYTE ();
1509 switch (op[2] & 0x00)
1510 {
1511 case 0x00:
1512 goto op_semantics_1;
1513 break;
1514 }
1515 break;
1516 case 0x43:
1517 GETBYTE ();
1518 switch (op[2] & 0x00)
1519 {
1520 case 0x00:
1521 goto op_semantics_1;
1522 break;
1523 }
1524 break;
1525 case 0x44:
1526 GETBYTE ();
1527 switch (op[2] & 0x00)
1528 {
1529 case 0x00:
1530 goto op_semantics_2;
1531 break;
1532 }
1533 break;
1534 case 0x45:
1535 GETBYTE ();
1536 switch (op[2] & 0x00)
1537 {
1538 case 0x00:
1539 goto op_semantics_2;
1540 break;
1541 }
1542 break;
1543 case 0x46:
1544 GETBYTE ();
1545 switch (op[2] & 0x00)
1546 {
1547 case 0x00:
1548 goto op_semantics_2;
1549 break;
1550 }
1551 break;
1552 case 0x47:
1553 GETBYTE ();
1554 switch (op[2] & 0x00)
1555 {
1556 case 0x00:
1557 goto op_semantics_2;
1558 break;
1559 }
1560 break;
1561 case 0x48:
1562 GETBYTE ();
1563 switch (op[2] & 0x00)
1564 {
1565 case 0x00:
1566 goto op_semantics_3;
1567 break;
1568 }
1569 break;
1570 case 0x49:
1571 GETBYTE ();
1572 switch (op[2] & 0x00)
1573 {
1574 case 0x00:
1575 goto op_semantics_3;
1576 break;
1577 }
1578 break;
1579 case 0x4a:
1580 GETBYTE ();
1581 switch (op[2] & 0x00)
1582 {
1583 case 0x00:
1584 goto op_semantics_3;
1585 break;
1586 }
1587 break;
1588 case 0x4b:
1589 GETBYTE ();
1590 switch (op[2] & 0x00)
1591 {
1592 case 0x00:
1593 goto op_semantics_3;
1594 break;
1595 }
1596 break;
1597 case 0x4c:
1598 GETBYTE ();
1599 switch (op[2] & 0x00)
1600 {
1601 case 0x00:
1602 goto op_semantics_4;
1603 break;
1604 }
1605 break;
1606 case 0x4d:
1607 GETBYTE ();
1608 switch (op[2] & 0x00)
1609 {
1610 case 0x00:
1611 goto op_semantics_4;
1612 break;
1613 }
1614 break;
1615 case 0x4e:
1616 GETBYTE ();
1617 switch (op[2] & 0x00)
1618 {
1619 case 0x00:
1620 goto op_semantics_4;
1621 break;
1622 }
1623 break;
1624 case 0x4f:
1625 GETBYTE ();
1626 switch (op[2] & 0x00)
1627 {
1628 case 0x00:
1629 goto op_semantics_4;
1630 break;
1631 }
1632 break;
1633 case 0x50:
1634 GETBYTE ();
1635 switch (op[2] & 0x00)
1636 {
1637 case 0x00:
1638 goto op_semantics_5;
1639 break;
1640 }
1641 break;
1642 case 0x51:
1643 GETBYTE ();
1644 switch (op[2] & 0x00)
1645 {
1646 case 0x00:
1647 goto op_semantics_5;
1648 break;
1649 }
1650 break;
1651 case 0x52:
1652 GETBYTE ();
1653 switch (op[2] & 0x00)
1654 {
1655 case 0x00:
1656 goto op_semantics_5;
1657 break;
1658 }
1659 break;
1660 case 0x53:
1661 GETBYTE ();
1662 switch (op[2] & 0x00)
1663 {
1664 case 0x00:
1665 goto op_semantics_5;
1666 break;
1667 }
1668 break;
1669 case 0x54:
1670 GETBYTE ();
1671 switch (op[2] & 0x00)
1672 {
1673 case 0x00:
1674 goto op_semantics_6;
1675 break;
1676 }
1677 break;
1678 case 0x55:
1679 GETBYTE ();
1680 switch (op[2] & 0x00)
1681 {
1682 case 0x00:
1683 goto op_semantics_6;
1684 break;
1685 }
1686 break;
1687 case 0x56:
1688 GETBYTE ();
1689 switch (op[2] & 0x00)
1690 {
1691 case 0x00:
1692 goto op_semantics_6;
1693 break;
1694 }
1695 break;
1696 case 0x57:
1697 GETBYTE ();
1698 switch (op[2] & 0x00)
1699 {
1700 case 0x00:
1701 goto op_semantics_6;
1702 break;
1703 }
1704 break;
1705 case 0x60:
1706 GETBYTE ();
1707 switch (op[2] & 0xff)
1708 {
1709 case 0x00:
1710 GETBYTE ();
1711 switch (op[3] & 0x00)
1712 {
1713 case 0x00:
1714 goto op_semantics_7;
1715 break;
1716 }
1717 break;
1718 case 0x04:
1719 GETBYTE ();
1720 switch (op[3] & 0x00)
1721 {
1722 case 0x00:
1723 goto op_semantics_8;
1724 break;
1725 }
1726 break;
1727 case 0x05:
1728 GETBYTE ();
1729 switch (op[3] & 0x00)
1730 {
1731 case 0x00:
1732 goto op_semantics_9;
1733 break;
1734 }
1735 break;
1736 case 0x06:
1737 GETBYTE ();
1738 switch (op[3] & 0x00)
1739 {
1740 case 0x00:
1741 goto op_semantics_10;
1742 break;
1743 }
1744 break;
1745 case 0x07:
1746 GETBYTE ();
1747 switch (op[3] & 0x00)
1748 {
1749 case 0x00:
1750 goto op_semantics_11;
1751 break;
1752 }
1753 break;
1754 case 0x08:
1755 GETBYTE ();
1756 switch (op[3] & 0x00)
1757 {
1758 case 0x00:
1759 goto op_semantics_12;
1760 break;
1761 }
1762 break;
1763 case 0x09:
1764 GETBYTE ();
1765 switch (op[3] & 0x00)
1766 {
1767 case 0x00:
1768 goto op_semantics_13;
1769 break;
1770 }
1771 break;
1772 case 0x0c:
1773 GETBYTE ();
1774 switch (op[3] & 0x00)
1775 {
1776 case 0x00:
1777 goto op_semantics_14;
1778 break;
1779 }
1780 break;
1781 case 0x0d:
1782 GETBYTE ();
1783 switch (op[3] & 0x00)
1784 {
1785 case 0x00:
1786 goto op_semantics_15;
1787 break;
1788 }
1789 break;
1790 case 0x10:
1791 GETBYTE ();
1792 switch (op[3] & 0x00)
1793 {
1794 case 0x00:
1795 goto op_semantics_16;
1796 break;
1797 }
1798 break;
1799 case 0x11:
1800 GETBYTE ();
1801 switch (op[3] & 0x00)
1802 {
1803 case 0x00:
1804 goto op_semantics_17;
1805 break;
1806 }
1807 break;
1808 default: UNSUPPORTED(); break;
1809 }
1810 break;
1811 case 0x61:
1812 GETBYTE ();
1813 switch (op[2] & 0xff)
1814 {
1815 case 0x00:
1816 GETBYTE ();
1817 switch (op[3] & 0x00)
1818 {
1819 case 0x00:
1820 goto op_semantics_7;
1821 break;
1822 }
1823 break;
1824 case 0x04:
1825 GETBYTE ();
1826 switch (op[3] & 0x00)
1827 {
1828 case 0x00:
1829 goto op_semantics_8;
1830 break;
1831 }
1832 break;
1833 case 0x05:
1834 GETBYTE ();
1835 switch (op[3] & 0x00)
1836 {
1837 case 0x00:
1838 goto op_semantics_9;
1839 break;
1840 }
1841 break;
1842 case 0x06:
1843 GETBYTE ();
1844 switch (op[3] & 0x00)
1845 {
1846 case 0x00:
1847 goto op_semantics_10;
1848 break;
1849 }
1850 break;
1851 case 0x07:
1852 GETBYTE ();
1853 switch (op[3] & 0x00)
1854 {
1855 case 0x00:
1856 goto op_semantics_11;
1857 break;
1858 }
1859 break;
1860 case 0x08:
1861 GETBYTE ();
1862 switch (op[3] & 0x00)
1863 {
1864 case 0x00:
1865 goto op_semantics_12;
1866 break;
1867 }
1868 break;
1869 case 0x09:
1870 GETBYTE ();
1871 switch (op[3] & 0x00)
1872 {
1873 case 0x00:
1874 goto op_semantics_13;
1875 break;
1876 }
1877 break;
1878 case 0x0c:
1879 GETBYTE ();
1880 switch (op[3] & 0x00)
1881 {
1882 case 0x00:
1883 goto op_semantics_14;
1884 break;
1885 }
1886 break;
1887 case 0x0d:
1888 GETBYTE ();
1889 switch (op[3] & 0x00)
1890 {
1891 case 0x00:
1892 goto op_semantics_15;
1893 break;
1894 }
1895 break;
1896 case 0x10:
1897 GETBYTE ();
1898 switch (op[3] & 0x00)
1899 {
1900 case 0x00:
1901 goto op_semantics_16;
1902 break;
1903 }
1904 break;
1905 case 0x11:
1906 GETBYTE ();
1907 switch (op[3] & 0x00)
1908 {
1909 case 0x00:
1910 goto op_semantics_17;
1911 break;
1912 }
1913 break;
1914 default: UNSUPPORTED(); break;
1915 }
1916 break;
1917 case 0x62:
1918 GETBYTE ();
1919 switch (op[2] & 0xff)
1920 {
1921 case 0x00:
1922 GETBYTE ();
1923 switch (op[3] & 0x00)
1924 {
1925 case 0x00:
1926 goto op_semantics_7;
1927 break;
1928 }
1929 break;
1930 case 0x04:
1931 GETBYTE ();
1932 switch (op[3] & 0x00)
1933 {
1934 case 0x00:
1935 goto op_semantics_8;
1936 break;
1937 }
1938 break;
1939 case 0x05:
1940 GETBYTE ();
1941 switch (op[3] & 0x00)
1942 {
1943 case 0x00:
1944 goto op_semantics_9;
1945 break;
1946 }
1947 break;
1948 case 0x06:
1949 GETBYTE ();
1950 switch (op[3] & 0x00)
1951 {
1952 case 0x00:
1953 goto op_semantics_10;
1954 break;
1955 }
1956 break;
1957 case 0x07:
1958 GETBYTE ();
1959 switch (op[3] & 0x00)
1960 {
1961 case 0x00:
1962 goto op_semantics_11;
1963 break;
1964 }
1965 break;
1966 case 0x08:
1967 GETBYTE ();
1968 switch (op[3] & 0x00)
1969 {
1970 case 0x00:
1971 goto op_semantics_12;
1972 break;
1973 }
1974 break;
1975 case 0x09:
1976 GETBYTE ();
1977 switch (op[3] & 0x00)
1978 {
1979 case 0x00:
1980 goto op_semantics_13;
1981 break;
1982 }
1983 break;
1984 case 0x0c:
1985 GETBYTE ();
1986 switch (op[3] & 0x00)
1987 {
1988 case 0x00:
1989 goto op_semantics_14;
1990 break;
1991 }
1992 break;
1993 case 0x0d:
1994 GETBYTE ();
1995 switch (op[3] & 0x00)
1996 {
1997 case 0x00:
1998 goto op_semantics_15;
1999 break;
2000 }
2001 break;
2002 case 0x10:
2003 GETBYTE ();
2004 switch (op[3] & 0x00)
2005 {
2006 case 0x00:
2007 goto op_semantics_16;
2008 break;
2009 }
2010 break;
2011 case 0x11:
2012 GETBYTE ();
2013 switch (op[3] & 0x00)
2014 {
2015 case 0x00:
2016 goto op_semantics_17;
2017 break;
2018 }
2019 break;
2020 default: UNSUPPORTED(); break;
2021 }
2022 break;
2023 case 0x63:
2024 GETBYTE ();
2025 switch (op[2] & 0xff)
2026 {
2027 case 0x00:
2028 GETBYTE ();
2029 switch (op[3] & 0x00)
2030 {
2031 case 0x00:
2032 goto op_semantics_7;
2033 break;
2034 }
2035 break;
2036 case 0x04:
2037 GETBYTE ();
2038 switch (op[3] & 0x00)
2039 {
2040 case 0x00:
2041 goto op_semantics_8;
2042 break;
2043 }
2044 break;
2045 case 0x05:
2046 GETBYTE ();
2047 switch (op[3] & 0x00)
2048 {
2049 case 0x00:
2050 goto op_semantics_9;
2051 break;
2052 }
2053 break;
2054 case 0x06:
2055 GETBYTE ();
2056 switch (op[3] & 0x00)
2057 {
2058 case 0x00:
2059 goto op_semantics_10;
2060 break;
2061 }
2062 break;
2063 case 0x07:
2064 GETBYTE ();
2065 switch (op[3] & 0x00)
2066 {
2067 case 0x00:
2068 goto op_semantics_11;
2069 break;
2070 }
2071 break;
2072 case 0x08:
2073 GETBYTE ();
2074 switch (op[3] & 0x00)
2075 {
2076 case 0x00:
2077 goto op_semantics_12;
2078 break;
2079 }
2080 break;
2081 case 0x09:
2082 GETBYTE ();
2083 switch (op[3] & 0x00)
2084 {
2085 case 0x00:
2086 goto op_semantics_13;
2087 break;
2088 }
2089 break;
2090 case 0x0c:
2091 GETBYTE ();
2092 switch (op[3] & 0x00)
2093 {
2094 case 0x00:
2095 goto op_semantics_14;
2096 break;
2097 }
2098 break;
2099 case 0x0d:
2100 GETBYTE ();
2101 switch (op[3] & 0x00)
2102 {
2103 case 0x00:
2104 goto op_semantics_15;
2105 break;
2106 }
2107 break;
2108 case 0x10:
2109 GETBYTE ();
2110 switch (op[3] & 0x00)
2111 {
2112 case 0x00:
2113 goto op_semantics_16;
2114 break;
2115 }
2116 break;
2117 case 0x11:
2118 GETBYTE ();
2119 switch (op[3] & 0x00)
2120 {
2121 case 0x00:
2122 goto op_semantics_17;
2123 break;
2124 }
2125 break;
2126 default: UNSUPPORTED(); break;
2127 }
2128 break;
2129 case 0x80:
2130 GETBYTE ();
2131 switch (op[2] & 0x00)
2132 {
2133 case 0x00:
2134 goto op_semantics_1;
2135 break;
2136 }
2137 break;
2138 case 0x81:
2139 GETBYTE ();
2140 switch (op[2] & 0x00)
2141 {
2142 case 0x00:
2143 goto op_semantics_1;
2144 break;
2145 }
2146 break;
2147 case 0x82:
2148 GETBYTE ();
2149 switch (op[2] & 0x00)
2150 {
2151 case 0x00:
2152 goto op_semantics_1;
2153 break;
2154 }
2155 break;
2156 case 0x83:
2157 GETBYTE ();
2158 switch (op[2] & 0x00)
2159 {
2160 case 0x00:
2161 goto op_semantics_1;
2162 break;
2163 }
2164 break;
2165 case 0x84:
2166 GETBYTE ();
2167 switch (op[2] & 0x00)
2168 {
2169 case 0x00:
2170 goto op_semantics_2;
2171 break;
2172 }
2173 break;
2174 case 0x85:
2175 GETBYTE ();
2176 switch (op[2] & 0x00)
2177 {
2178 case 0x00:
2179 goto op_semantics_2;
2180 break;
2181 }
2182 break;
2183 case 0x86:
2184 GETBYTE ();
2185 switch (op[2] & 0x00)
2186 {
2187 case 0x00:
2188 goto op_semantics_2;
2189 break;
2190 }
2191 break;
2192 case 0x87:
2193 GETBYTE ();
2194 switch (op[2] & 0x00)
2195 {
2196 case 0x00:
2197 goto op_semantics_2;
2198 break;
2199 }
2200 break;
2201 case 0x88:
2202 GETBYTE ();
2203 switch (op[2] & 0x00)
2204 {
2205 case 0x00:
2206 goto op_semantics_3;
2207 break;
2208 }
2209 break;
2210 case 0x89:
2211 GETBYTE ();
2212 switch (op[2] & 0x00)
2213 {
2214 case 0x00:
2215 goto op_semantics_3;
2216 break;
2217 }
2218 break;
2219 case 0x8a:
2220 GETBYTE ();
2221 switch (op[2] & 0x00)
2222 {
2223 case 0x00:
2224 goto op_semantics_3;
2225 break;
2226 }
2227 break;
2228 case 0x8b:
2229 GETBYTE ();
2230 switch (op[2] & 0x00)
2231 {
2232 case 0x00:
2233 goto op_semantics_3;
2234 break;
2235 }
2236 break;
2237 case 0x8c:
2238 GETBYTE ();
2239 switch (op[2] & 0x00)
2240 {
2241 case 0x00:
2242 goto op_semantics_4;
2243 break;
2244 }
2245 break;
2246 case 0x8d:
2247 GETBYTE ();
2248 switch (op[2] & 0x00)
2249 {
2250 case 0x00:
2251 goto op_semantics_4;
2252 break;
2253 }
2254 break;
2255 case 0x8e:
2256 GETBYTE ();
2257 switch (op[2] & 0x00)
2258 {
2259 case 0x00:
2260 goto op_semantics_4;
2261 break;
2262 }
2263 break;
2264 case 0x8f:
2265 GETBYTE ();
2266 switch (op[2] & 0x00)
2267 {
2268 case 0x00:
2269 goto op_semantics_4;
2270 break;
2271 }
2272 break;
2273 case 0x90:
2274 GETBYTE ();
2275 switch (op[2] & 0x00)
2276 {
2277 case 0x00:
2278 goto op_semantics_5;
2279 break;
2280 }
2281 break;
2282 case 0x91:
2283 GETBYTE ();
2284 switch (op[2] & 0x00)
2285 {
2286 case 0x00:
2287 goto op_semantics_5;
2288 break;
2289 }
2290 break;
2291 case 0x92:
2292 GETBYTE ();
2293 switch (op[2] & 0x00)
2294 {
2295 case 0x00:
2296 goto op_semantics_5;
2297 break;
2298 }
2299 break;
2300 case 0x93:
2301 GETBYTE ();
2302 switch (op[2] & 0x00)
2303 {
2304 case 0x00:
2305 goto op_semantics_5;
2306 break;
2307 }
2308 break;
2309 case 0x94:
2310 GETBYTE ();
2311 switch (op[2] & 0x00)
2312 {
2313 case 0x00:
2314 goto op_semantics_6;
2315 break;
2316 }
2317 break;
2318 case 0x95:
2319 GETBYTE ();
2320 switch (op[2] & 0x00)
2321 {
2322 case 0x00:
2323 goto op_semantics_6;
2324 break;
2325 }
2326 break;
2327 case 0x96:
2328 GETBYTE ();
2329 switch (op[2] & 0x00)
2330 {
2331 case 0x00:
2332 goto op_semantics_6;
2333 break;
2334 }
2335 break;
2336 case 0x97:
2337 GETBYTE ();
2338 switch (op[2] & 0x00)
2339 {
2340 case 0x00:
2341 goto op_semantics_6;
2342 break;
2343 }
2344 break;
2345 case 0xa0:
2346 GETBYTE ();
2347 switch (op[2] & 0xff)
2348 {
2349 case 0x00:
2350 GETBYTE ();
2351 switch (op[3] & 0x00)
2352 {
2353 case 0x00:
2354 goto op_semantics_7;
2355 break;
2356 }
2357 break;
2358 case 0x02:
2359 GETBYTE ();
2360 switch (op[3] & 0x00)
2361 {
2362 case 0x00:
2363 op_semantics_18:
2364 {
2365 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
f282425e 2366#line 474 "rx-decode.opc"
c7927a3c 2367 int ss AU = op[1] & 0x03;
f282425e 2368#line 474 "rx-decode.opc"
c7927a3c 2369 int rsrc AU = (op[3] >> 4) & 0x0f;
f282425e 2370#line 474 "rx-decode.opc"
c7927a3c
NC		 2371 int rdst AU = op[3] & 0x0f;
2372 if (trace)
2373 {
2374 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2375 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2376 op[0], op[1], op[2], op[3]);
2377 printf (" ss = 0x%x,", ss);
2378 printf (" rsrc = 0x%x,", rsrc);
2379 printf (" rdst = 0x%x\n", rdst);
2380 }
2381 SYNTAX("adc %1%S1, %0");
f282425e 2382#line 474 "rx-decode.opc"
c7927a3c
NC		 2383 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F("OSZC");
2384
2385 /*----------------------------------------------------------------------*/
2386 /* ADD */
2387
2388 }
2389 break;
2390 }
2391 break;
2392 case 0x04:
2393 GETBYTE ();
2394 switch (op[3] & 0x00)
2395 {
2396 case 0x00:
2397 goto op_semantics_8;
2398 break;
2399 }
2400 break;
2401 case 0x05:
2402 GETBYTE ();
2403 switch (op[3] & 0x00)
2404 {
2405 case 0x00:
2406 goto op_semantics_9;
2407 break;
2408 }
2409 break;
2410 case 0x06:
2411 GETBYTE ();
2412 switch (op[3] & 0x00)
2413 {
2414 case 0x00:
2415 goto op_semantics_10;
2416 break;
2417 }
2418 break;
2419 case 0x07:
2420 GETBYTE ();
2421 switch (op[3] & 0x00)
2422 {
2423 case 0x00:
2424 goto op_semantics_11;
2425 break;
2426 }
2427 break;
2428 case 0x08:
2429 GETBYTE ();
2430 switch (op[3] & 0x00)
2431 {
2432 case 0x00:
2433 goto op_semantics_12;
2434 break;
2435 }
2436 break;
2437 case 0x09:
2438 GETBYTE ();
2439 switch (op[3] & 0x00)
2440 {
2441 case 0x00:
2442 goto op_semantics_13;
2443 break;
2444 }
2445 break;
2446 case 0x0c:
2447 GETBYTE ();
2448 switch (op[3] & 0x00)
2449 {
2450 case 0x00:
2451 goto op_semantics_14;
2452 break;
2453 }
2454 break;
2455 case 0x0d:
2456 GETBYTE ();
2457 switch (op[3] & 0x00)
2458 {
2459 case 0x00:
2460 goto op_semantics_15;
2461 break;
2462 }
2463 break;
2464 case 0x10:
2465 GETBYTE ();
2466 switch (op[3] & 0x00)
2467 {
2468 case 0x00:
2469 goto op_semantics_16;
2470 break;
2471 }
2472 break;
2473 case 0x11:
2474 GETBYTE ();
2475 switch (op[3] & 0x00)
2476 {
2477 case 0x00:
2478 goto op_semantics_17;
2479 break;
2480 }
2481 break;
2482 default: UNSUPPORTED(); break;
2483 }
2484 break;
2485 case 0xa1:
2486 GETBYTE ();
2487 switch (op[2] & 0xff)
2488 {
2489 case 0x00:
2490 GETBYTE ();
2491 switch (op[3] & 0x00)
2492 {
2493 case 0x00:
2494 goto op_semantics_7;
2495 break;
2496 }
2497 break;
2498 case 0x02:
2499 GETBYTE ();
2500 switch (op[3] & 0x00)
2501 {
2502 case 0x00:
2503 goto op_semantics_18;
2504 break;
2505 }
2506 break;
2507 case 0x04:
2508 GETBYTE ();
2509 switch (op[3] & 0x00)
2510 {
2511 case 0x00:
2512 goto op_semantics_8;
2513 break;
2514 }
2515 break;
2516 case 0x05:
2517 GETBYTE ();
2518 switch (op[3] & 0x00)
2519 {
2520 case 0x00:
2521 goto op_semantics_9;
2522 break;
2523 }
2524 break;
2525 case 0x06:
2526 GETBYTE ();
2527 switch (op[3] & 0x00)
2528 {
2529 case 0x00:
2530 goto op_semantics_10;
2531 break;
2532 }
2533 break;
2534 case 0x07:
2535 GETBYTE ();
2536 switch (op[3] & 0x00)
2537 {
2538 case 0x00:
2539 goto op_semantics_11;
2540 break;
2541 }
2542 break;
2543 case 0x08:
2544 GETBYTE ();
2545 switch (op[3] & 0x00)
2546 {
2547 case 0x00:
2548 goto op_semantics_12;
2549 break;
2550 }
2551 break;
2552 case 0x09:
2553 GETBYTE ();
2554 switch (op[3] & 0x00)
2555 {
2556 case 0x00:
2557 goto op_semantics_13;
2558 break;
2559 }
2560 break;
2561 case 0x0c:
2562 GETBYTE ();
2563 switch (op[3] & 0x00)
2564 {
2565 case 0x00:
2566 goto op_semantics_14;
2567 break;
2568 }
2569 break;
2570 case 0x0d:
2571 GETBYTE ();
2572 switch (op[3] & 0x00)
2573 {
2574 case 0x00:
2575 goto op_semantics_15;
2576 break;
2577 }
2578 break;
2579 case 0x10:
2580 GETBYTE ();
2581 switch (op[3] & 0x00)
2582 {
2583 case 0x00:
2584 goto op_semantics_16;
2585 break;
2586 }
2587 break;
2588 case 0x11:
2589 GETBYTE ();
2590 switch (op[3] & 0x00)
2591 {
2592 case 0x00:
2593 goto op_semantics_17;
2594 break;
2595 }
2596 break;
2597 default: UNSUPPORTED(); break;
2598 }
2599 break;
2600 case 0xa2:
2601 GETBYTE ();
2602 switch (op[2] & 0xff)
2603 {
2604 case 0x00:
2605 GETBYTE ();
2606 switch (op[3] & 0x00)
2607 {
2608 case 0x00:
2609 goto op_semantics_7;
2610 break;
2611 }
2612 break;
2613 case 0x02:
2614 GETBYTE ();
2615 switch (op[3] & 0x00)
2616 {
2617 case 0x00:
2618 goto op_semantics_18;
2619 break;
2620 }
2621 break;
2622 case 0x04:
2623 GETBYTE ();
2624 switch (op[3] & 0x00)
2625 {
2626 case 0x00:
2627 goto op_semantics_8;
2628 break;
2629 }
2630 break;
2631 case 0x05:
2632 GETBYTE ();
2633 switch (op[3] & 0x00)
2634 {
2635 case 0x00:
2636 goto op_semantics_9;
2637 break;
2638 }
2639 break;
2640 case 0x06:
2641 GETBYTE ();
2642 switch (op[3] & 0x00)
2643 {
2644 case 0x00:
2645 goto op_semantics_10;
2646 break;
2647 }
2648 break;
2649 case 0x07:
2650 GETBYTE ();
2651 switch (op[3] & 0x00)
2652 {
2653 case 0x00:
2654 goto op_semantics_11;
2655 break;
2656 }
2657 break;
2658 case 0x08:
2659 GETBYTE ();
2660 switch (op[3] & 0x00)
2661 {
2662 case 0x00:
2663 goto op_semantics_12;
2664 break;
2665 }
2666 break;
2667 case 0x09:
2668 GETBYTE ();
2669 switch (op[3] & 0x00)
2670 {
2671 case 0x00:
2672 goto op_semantics_13;
2673 break;
2674 }
2675 break;
2676 case 0x0c:
2677 GETBYTE ();
2678 switch (op[3] & 0x00)
2679 {
2680 case 0x00:
2681 goto op_semantics_14;
2682 break;
2683 }
2684 break;
2685 case 0x0d:
2686 GETBYTE ();
2687 switch (op[3] & 0x00)
2688 {
2689 case 0x00:
2690 goto op_semantics_15;
2691 break;
2692 }
2693 break;
2694 case 0x10:
2695 GETBYTE ();
2696 switch (op[3] & 0x00)
2697 {
2698 case 0x00:
2699 goto op_semantics_16;
2700 break;
2701 }
2702 break;
2703 case 0x11:
2704 GETBYTE ();
2705 switch (op[3] & 0x00)
2706 {
2707 case 0x00:
2708 goto op_semantics_17;
2709 break;
2710 }
2711 break;
2712 default: UNSUPPORTED(); break;
2713 }
2714 break;
2715 case 0xa3:
2716 GETBYTE ();
2717 switch (op[2] & 0xff)
2718 {
2719 case 0x00:
2720 GETBYTE ();
2721 switch (op[3] & 0x00)
2722 {
2723 case 0x00:
2724 goto op_semantics_7;
2725 break;
2726 }
2727 break;
2728 case 0x02:
2729 GETBYTE ();
2730 switch (op[3] & 0x00)
2731 {
2732 case 0x00:
2733 goto op_semantics_18;
2734 break;
2735 }
2736 break;
2737 case 0x04:
2738 GETBYTE ();
2739 switch (op[3] & 0x00)
2740 {
2741 case 0x00:
2742 goto op_semantics_8;
2743 break;
2744 }
2745 break;
2746 case 0x05:
2747 GETBYTE ();
2748 switch (op[3] & 0x00)
2749 {
2750 case 0x00:
2751 goto op_semantics_9;
2752 break;
2753 }
2754 break;
2755 case 0x06:
2756 GETBYTE ();
2757 switch (op[3] & 0x00)
2758 {
2759 case 0x00:
2760 goto op_semantics_10;
2761 break;
2762 }
2763 break;
2764 case 0x07:
2765 GETBYTE ();
2766 switch (op[3] & 0x00)
2767 {
2768 case 0x00:
2769 goto op_semantics_11;
2770 break;
2771 }
2772 break;
2773 case 0x08:
2774 GETBYTE ();
2775 switch (op[3] & 0x00)
2776 {
2777 case 0x00:
2778 goto op_semantics_12;
2779 break;
2780 }
2781 break;
2782 case 0x09:
2783 GETBYTE ();
2784 switch (op[3] & 0x00)
2785 {
2786 case 0x00:
2787 goto op_semantics_13;
2788 break;
2789 }
2790 break;
2791 case 0x0c:
2792 GETBYTE ();
2793 switch (op[3] & 0x00)
2794 {
2795 case 0x00:
2796 goto op_semantics_14;
2797 break;
2798 }
2799 break;
2800 case 0x0d:
2801 GETBYTE ();
2802 switch (op[3] & 0x00)
2803 {
2804 case 0x00:
2805 goto op_semantics_15;
2806 break;
2807 }
2808 break;
2809 case 0x10:
2810 GETBYTE ();
2811 switch (op[3] & 0x00)
2812 {
2813 case 0x00:
2814 goto op_semantics_16;
2815 break;
2816 }
2817 break;
2818 case 0x11:
2819 GETBYTE ();
2820 switch (op[3] & 0x00)
2821 {
2822 case 0x00:
2823 goto op_semantics_17;
2824 break;
2825 }
2826 break;
2827 default: UNSUPPORTED(); break;
2828 }
2829 break;
2830 case 0xc0:
2831 GETBYTE ();
2832 switch (op[2] & 0x00)
2833 {
2834 case 0x00:
2835 goto op_semantics_1;
2836 break;
2837 }
2838 break;
2839 case 0xc1:
2840 GETBYTE ();
2841 switch (op[2] & 0x00)
2842 {
2843 case 0x00:
2844 goto op_semantics_1;
2845 break;
2846 }
2847 break;
2848 case 0xc2:
2849 GETBYTE ();
2850 switch (op[2] & 0x00)
2851 {
2852 case 0x00:
2853 goto op_semantics_1;
2854 break;
2855 }
2856 break;
2857 case 0xc3:
2858 GETBYTE ();
2859 switch (op[2] & 0x00)
2860 {
2861 case 0x00:
2862 goto op_semantics_1;
2863 break;
2864 }
2865 break;
2866 case 0xc4:
2867 GETBYTE ();
2868 switch (op[2] & 0x00)
2869 {
2870 case 0x00:
2871 goto op_semantics_2;
2872 break;
2873 }
2874 break;
2875 case 0xc5:
2876 GETBYTE ();
2877 switch (op[2] & 0x00)
2878 {
2879 case 0x00:
2880 goto op_semantics_2;
2881 break;
2882 }
2883 break;
2884 case 0xc6:
2885 GETBYTE ();
2886 switch (op[2] & 0x00)
2887 {
2888 case 0x00:
2889 goto op_semantics_2;
2890 break;
2891 }
2892 break;
2893 case 0xc7:
2894 GETBYTE ();
2895 switch (op[2] & 0x00)
2896 {
2897 case 0x00:
2898 goto op_semantics_2;
2899 break;
2900 }
2901 break;
2902 case 0xc8:
2903 GETBYTE ();
2904 switch (op[2] & 0x00)
2905 {
2906 case 0x00:
2907 goto op_semantics_3;
2908 break;
2909 }
2910 break;
2911 case 0xc9:
2912 GETBYTE ();
2913 switch (op[2] & 0x00)
2914 {
2915 case 0x00:
2916 goto op_semantics_3;
2917 break;
2918 }
2919 break;
2920 case 0xca:
2921 GETBYTE ();
2922 switch (op[2] & 0x00)
2923 {
2924 case 0x00:
2925 goto op_semantics_3;
2926 break;
2927 }
2928 break;
2929 case 0xcb:
2930 GETBYTE ();
2931 switch (op[2] & 0x00)
2932 {
2933 case 0x00:
2934 goto op_semantics_3;
2935 break;
2936 }
2937 break;
2938 case 0xcc:
2939 GETBYTE ();
2940 switch (op[2] & 0x00)
2941 {
2942 case 0x00:
2943 goto op_semantics_4;
2944 break;
2945 }
2946 break;
2947 case 0xcd:
2948 GETBYTE ();
2949 switch (op[2] & 0x00)
2950 {
2951 case 0x00:
2952 goto op_semantics_4;
2953 break;
2954 }
2955 break;
2956 case 0xce:
2957 GETBYTE ();
2958 switch (op[2] & 0x00)
2959 {
2960 case 0x00:
2961 goto op_semantics_4;
2962 break;
2963 }
2964 break;
2965 case 0xcf:
2966 GETBYTE ();
2967 switch (op[2] & 0x00)
2968 {
2969 case 0x00:
2970 goto op_semantics_4;
2971 break;
2972 }
2973 break;
2974 case 0xd0:
2975 GETBYTE ();
2976 switch (op[2] & 0x00)
2977 {
2978 case 0x00:
2979 goto op_semantics_5;
2980 break;
2981 }
2982 break;
2983 case 0xd1:
2984 GETBYTE ();
2985 switch (op[2] & 0x00)
2986 {
2987 case 0x00:
2988 goto op_semantics_5;
2989 break;
2990 }
2991 break;
2992 case 0xd2:
2993 GETBYTE ();
2994 switch (op[2] & 0x00)
2995 {
2996 case 0x00:
2997 goto op_semantics_5;
2998 break;
2999 }
3000 break;
3001 case 0xd3:
3002 GETBYTE ();
3003 switch (op[2] & 0x00)
3004 {
3005 case 0x00:
3006 goto op_semantics_5;
3007 break;
3008 }
3009 break;
3010 case 0xd4:
3011 GETBYTE ();
3012 switch (op[2] & 0x00)
3013 {
3014 case 0x00:
3015 goto op_semantics_6;
3016 break;
3017 }
3018 break;
3019 case 0xd5:
3020 GETBYTE ();
3021 switch (op[2] & 0x00)
3022 {
3023 case 0x00:
3024 goto op_semantics_6;
3025 break;
3026 }
3027 break;
3028 case 0xd6:
3029 GETBYTE ();
3030 switch (op[2] & 0x00)
3031 {
3032 case 0x00:
3033 goto op_semantics_6;
3034 break;
3035 }
3036 break;
3037 case 0xd7:
3038 GETBYTE ();
3039 switch (op[2] & 0x00)
3040 {
3041 case 0x00:
3042 goto op_semantics_6;
3043 break;
3044 }
3045 break;
3046 case 0xe0:
3047 GETBYTE ();
3048 switch (op[2] & 0xff)
3049 {
3050 case 0x00:
3051 GETBYTE ();
3052 switch (op[3] & 0x00)
3053 {
3054 case 0x00:
3055 goto op_semantics_7;
3056 break;
3057 }
3058 break;
3059 case 0x04:
3060 GETBYTE ();
3061 switch (op[3] & 0x00)
3062 {
3063 case 0x00:
3064 goto op_semantics_8;
3065 break;
3066 }
3067 break;
3068 case 0x05:
3069 GETBYTE ();
3070 switch (op[3] & 0x00)
3071 {
3072 case 0x00:
3073 goto op_semantics_9;
3074 break;
3075 }
3076 break;
3077 case 0x06:
3078 GETBYTE ();
3079 switch (op[3] & 0x00)
3080 {
3081 case 0x00:
3082 goto op_semantics_10;
3083 break;
3084 }
3085 break;
3086 case 0x07:
3087 GETBYTE ();
3088 switch (op[3] & 0x00)
3089 {
3090 case 0x00:
3091 goto op_semantics_11;
3092 break;
3093 }
3094 break;
3095 case 0x08:
3096 GETBYTE ();
3097 switch (op[3] & 0x00)
3098 {
3099 case 0x00:
3100 goto op_semantics_12;
3101 break;
3102 }
3103 break;
3104 case 0x09:
3105 GETBYTE ();
3106 switch (op[3] & 0x00)
3107 {
3108 case 0x00:
3109 goto op_semantics_13;
3110 break;
3111 }
3112 break;
3113 case 0x0c:
3114 GETBYTE ();
3115 switch (op[3] & 0x00)
3116 {
3117 case 0x00:
3118 goto op_semantics_14;
3119 break;
3120 }
3121 break;
3122 case 0x0d:
3123 GETBYTE ();
3124 switch (op[3] & 0x00)
3125 {
3126 case 0x00:
3127 goto op_semantics_15;
3128 break;
3129 }
3130 break;
3131 case 0x10:
3132 GETBYTE ();
3133 switch (op[3] & 0x00)
3134 {
3135 case 0x00:
3136 goto op_semantics_16;
3137 break;
3138 }
3139 break;
3140 case 0x11:
3141 GETBYTE ();
3142 switch (op[3] & 0x00)
3143 {
3144 case 0x00:
3145 goto op_semantics_17;
3146 break;
3147 }
3148 break;
3149 default: UNSUPPORTED(); break;
3150 }
3151 break;
3152 case 0xe1:
3153 GETBYTE ();
3154 switch (op[2] & 0xff)
3155 {
3156 case 0x00:
3157 GETBYTE ();
3158 switch (op[3] & 0x00)
3159 {
3160 case 0x00:
3161 goto op_semantics_7;
3162 break;
3163 }
3164 break;
3165 case 0x04:
3166 GETBYTE ();
3167 switch (op[3] & 0x00)
3168 {
3169 case 0x00:
3170 goto op_semantics_8;
3171 break;
3172 }
3173 break;
3174 case 0x05:
3175 GETBYTE ();
3176 switch (op[3] & 0x00)
3177 {
3178 case 0x00:
3179 goto op_semantics_9;
3180 break;
3181 }
3182 break;
3183 case 0x06:
3184 GETBYTE ();
3185 switch (op[3] & 0x00)
3186 {
3187 case 0x00:
3188 goto op_semantics_10;
3189 break;
3190 }
3191 break;
3192 case 0x07:
3193 GETBYTE ();
3194 switch (op[3] & 0x00)
3195 {
3196 case 0x00:
3197 goto op_semantics_11;
3198 break;
3199 }
3200 break;
3201 case 0x08:
3202 GETBYTE ();
3203 switch (op[3] & 0x00)
3204 {
3205 case 0x00:
3206 goto op_semantics_12;
3207 break;
3208 }
3209 break;
3210 case 0x09:
3211 GETBYTE ();
3212 switch (op[3] & 0x00)
3213 {
3214 case 0x00:
3215 goto op_semantics_13;
3216 break;
3217 }
3218 break;
3219 case 0x0c:
3220 GETBYTE ();
3221 switch (op[3] & 0x00)
3222 {
3223 case 0x00:
3224 goto op_semantics_14;
3225 break;
3226 }
3227 break;
3228 case 0x0d:
3229 GETBYTE ();
3230 switch (op[3] & 0x00)
3231 {
3232 case 0x00:
3233 goto op_semantics_15;
3234 break;
3235 }
3236 break;
3237 case 0x10:
3238 GETBYTE ();
3239 switch (op[3] & 0x00)
3240 {
3241 case 0x00:
3242 goto op_semantics_16;
3243 break;
3244 }
3245 break;
3246 case 0x11:
3247 GETBYTE ();
3248 switch (op[3] & 0x00)
3249 {
3250 case 0x00:
3251 goto op_semantics_17;
3252 break;
3253 }
3254 break;
3255 default: UNSUPPORTED(); break;
3256 }
3257 break;
3258 case 0xe2:
3259 GETBYTE ();
3260 switch (op[2] & 0xff)
3261 {
3262 case 0x00:
3263 GETBYTE ();
3264 switch (op[3] & 0x00)
3265 {
3266 case 0x00:
3267 goto op_semantics_7;
3268 break;
3269 }
3270 break;
3271 case 0x04:
3272 GETBYTE ();
3273 switch (op[3] & 0x00)
3274 {
3275 case 0x00:
3276 goto op_semantics_8;
3277 break;
3278 }
3279 break;
3280 case 0x05:
3281 GETBYTE ();
3282 switch (op[3] & 0x00)
3283 {
3284 case 0x00:
3285 goto op_semantics_9;
3286 break;
3287 }
3288 break;
3289 case 0x06:
3290 GETBYTE ();
3291 switch (op[3] & 0x00)
3292 {
3293 case 0x00:
3294 goto op_semantics_10;
3295 break;
3296 }
3297 break;
3298 case 0x07:
3299 GETBYTE ();
3300 switch (op[3] & 0x00)
3301 {
3302 case 0x00:
3303 goto op_semantics_11;
3304 break;
3305 }
3306 break;
3307 case 0x08:
3308 GETBYTE ();
3309 switch (op[3] & 0x00)
3310 {
3311 case 0x00:
3312 goto op_semantics_12;
3313 break;
3314 }
3315 break;
3316 case 0x09:
3317 GETBYTE ();
3318 switch (op[3] & 0x00)
3319 {
3320 case 0x00:
3321 goto op_semantics_13;
3322 break;
3323 }
3324 break;
3325 case 0x0c:
3326 GETBYTE ();
3327 switch (op[3] & 0x00)
3328 {
3329 case 0x00:
3330 goto op_semantics_14;
3331 break;
3332 }
3333 break;
3334 case 0x0d:
3335 GETBYTE ();
3336 switch (op[3] & 0x00)
3337 {
3338 case 0x00:
3339 goto op_semantics_15;
3340 break;
3341 }
3342 break;
3343 case 0x10:
3344 GETBYTE ();
3345 switch (op[3] & 0x00)
3346 {
3347 case 0x00:
3348 goto op_semantics_16;
3349 break;
3350 }
3351 break;
3352 case 0x11:
3353 GETBYTE ();
3354 switch (op[3] & 0x00)
3355 {
3356 case 0x00:
3357 goto op_semantics_17;
3358 break;
3359 }
3360 break;
3361 default: UNSUPPORTED(); break;
3362 }
3363 break;
3364 case 0xe3:
3365 GETBYTE ();
3366 switch (op[2] & 0xff)
3367 {
3368 case 0x00:
3369 GETBYTE ();
3370 switch (op[3] & 0x00)
3371 {
3372 case 0x00:
3373 goto op_semantics_7;
3374 break;
3375 }
3376 break;
3377 case 0x04:
3378 GETBYTE ();
3379 switch (op[3] & 0x00)
3380 {
3381 case 0x00:
3382 goto op_semantics_8;
3383 break;
3384 }
3385 break;
3386 case 0x05:
3387 GETBYTE ();
3388 switch (op[3] & 0x00)
3389 {
3390 case 0x00:
3391 goto op_semantics_9;
3392 break;
3393 }
3394 break;
3395 case 0x06:
3396 GETBYTE ();
3397 switch (op[3] & 0x00)
3398 {
3399 case 0x00:
3400 goto op_semantics_10;
3401 break;
3402 }
3403 break;
3404 case 0x07:
3405 GETBYTE ();
3406 switch (op[3] & 0x00)
3407 {
3408 case 0x00:
3409 goto op_semantics_11;
3410 break;
3411 }
3412 break;
3413 case 0x08:
3414 GETBYTE ();
3415 switch (op[3] & 0x00)
3416 {
3417 case 0x00:
3418 goto op_semantics_12;
3419 break;
3420 }
3421 break;
3422 case 0x09:
3423 GETBYTE ();
3424 switch (op[3] & 0x00)
3425 {
3426 case 0x00:
3427 goto op_semantics_13;
3428 break;
3429 }
3430 break;
3431 case 0x0c:
3432 GETBYTE ();
3433 switch (op[3] & 0x00)
3434 {
3435 case 0x00:
3436 goto op_semantics_14;
3437 break;
3438 }
3439 break;
3440 case 0x0d:
3441 GETBYTE ();
3442 switch (op[3] & 0x00)
3443 {
3444 case 0x00:
3445 goto op_semantics_15;
3446 break;
3447 }
3448 break;
3449 case 0x10:
3450 GETBYTE ();
3451 switch (op[3] & 0x00)
3452 {
3453 case 0x00:
3454 goto op_semantics_16;
3455 break;
3456 }
3457 break;
3458 case 0x11:
3459 GETBYTE ();
3460 switch (op[3] & 0x00)
3461 {
3462 case 0x00:
3463 goto op_semantics_17;
3464 break;
3465 }
3466 break;
3467 default: UNSUPPORTED(); break;
3468 }
3469 break;
3470 default: UNSUPPORTED(); break;
3471 }
3472 break;
3473 case 0x08:
3474 case 0x09:
3475 case 0x0a:
3476 case 0x0b:
3477 case 0x0c:
3478 case 0x0d:
3479 case 0x0e:
3480 case 0x0f:
3481 {
3482 /** 0000 1dsp bra.s %a0 */
f282425e 3483#line 709 "rx-decode.opc"
c7927a3c
NC		 3484 int dsp AU = op[0] & 0x07;
3485 if (trace)
3486 {
3487 printf ("\033[33m%s\033[0m %02x\n",
3488 "/** 0000 1dsp bra.s %a0 */",
3489 op[0]);
3490 printf (" dsp = 0x%x\n", dsp);
3491 }
3492 SYNTAX("bra.s %a0");
f282425e 3493#line 709 "rx-decode.opc"
c7927a3c
NC		 3494 ID(branch); Scc(RXC_always); DC(pc + dsp3map[dsp]);
3495
3496 }
3497 break;
3498 case 0x10:
3499 case 0x11:
3500 case 0x12:
3501 case 0x13:
3502 case 0x14:
3503 case 0x15:
3504 case 0x16:
3505 case 0x17:
3506 case 0x18:
3507 case 0x19:
3508 case 0x1a:
3509 case 0x1b:
3510 case 0x1c:
3511 case 0x1d:
3512 case 0x1e:
3513 case 0x1f:
3514 {
3515 /** 0001 n dsp b%1.s %a0 */
f282425e 3516#line 699 "rx-decode.opc"
c7927a3c 3517 int n AU = (op[0] >> 3) & 0x01;
f282425e 3518#line 699 "rx-decode.opc"
c7927a3c
NC		 3519 int dsp AU = op[0] & 0x07;
3520 if (trace)
3521 {
3522 printf ("\033[33m%s\033[0m %02x\n",
3523 "/** 0001 n dsp b%1.s %a0 */",
3524 op[0]);
3525 printf (" n = 0x%x,", n);
3526 printf (" dsp = 0x%x\n", dsp);
3527 }
3528 SYNTAX("b%1.s %a0");
f282425e 3529#line 699 "rx-decode.opc"
c7927a3c
NC		 3530 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3531
3532 }
3533 break;
3534 case 0x20:
3535 case 0x21:
3536 case 0x22:
3537 case 0x23:
3538 case 0x24:
3539 case 0x25:
3540 case 0x26:
3541 case 0x27:
3542 case 0x28:
3543 case 0x29:
3544 case 0x2a:
3545 case 0x2b:
3546 case 0x2c:
3547 case 0x2d:
3548 case 0x2f:
3549 {
3550 /** 0010 cond b%1.b %a0 */
f282425e 3551#line 702 "rx-decode.opc"
c7927a3c
NC		 3552 int cond AU = op[0] & 0x0f;
3553 if (trace)
3554 {
3555 printf ("\033[33m%s\033[0m %02x\n",
3556 "/** 0010 cond b%1.b %a0 */",
3557 op[0]);
3558 printf (" cond = 0x%x\n", cond);
3559 }
3560 SYNTAX("b%1.b %a0");
f282425e 3561#line 702 "rx-decode.opc"
c7927a3c
NC		 3562 ID(branch); Scc(cond); DC(pc + IMMex (1));
3563
3564 }
3565 break;
3566 case 0x2e:
3567 {
3568 /** 0010 1110 bra.b %a0 */
3569 if (trace)
3570 {
3571 printf ("\033[33m%s\033[0m %02x\n",
3572 "/** 0010 1110 bra.b %a0 */",
3573 op[0]);
3574 }
3575 SYNTAX("bra.b %a0");
f282425e 3576#line 712 "rx-decode.opc"
c7927a3c
NC		 3577 ID(branch); Scc(RXC_always); DC(pc + IMMex(1));
3578
3579 }
3580 break;
3581 case 0x38:
3582 {
3583 /** 0011 1000 bra.w %a0 */
3584 if (trace)
3585 {
3586 printf ("\033[33m%s\033[0m %02x\n",
3587 "/** 0011 1000 bra.w %a0 */",
3588 op[0]);
3589 }
3590 SYNTAX("bra.w %a0");
f282425e 3591#line 715 "rx-decode.opc"
c7927a3c
NC		 3592 ID(branch); Scc(RXC_always); DC(pc + IMMex(2));
3593
3594 }
3595 break;
3596 case 0x39:
3597 {
3598 /** 0011 1001 bsr.w %a0 */
3599 if (trace)
3600 {
3601 printf ("\033[33m%s\033[0m %02x\n",
3602 "/** 0011 1001 bsr.w %a0 */",
3603 op[0]);
3604 }
3605 SYNTAX("bsr.w %a0");
f282425e 3606#line 731 "rx-decode.opc"
c7927a3c
NC		 3607 ID(jsr); DC(pc + IMMex(2));
3608
3609 }
3610 break;
3611 case 0x3a:
3612 case 0x3b:
3613 {
3614 /** 0011 101c b%1.w %a0 */
f282425e 3615#line 705 "rx-decode.opc"
c7927a3c
NC		 3616 int c AU = op[0] & 0x01;
3617 if (trace)
3618 {
3619 printf ("\033[33m%s\033[0m %02x\n",
3620 "/** 0011 101c b%1.w %a0 */",
3621 op[0]);
3622 printf (" c = 0x%x\n", c);
3623 }
3624 SYNTAX("b%1.w %a0");
f282425e 3625#line 705 "rx-decode.opc"
c7927a3c
NC		 3626 ID(branch); Scc(c); DC(pc + IMMex (2));
3627
3628
3629 }
3630 break;
3631 case 0x3c:
3632 GETBYTE ();
3633 switch (op[1] & 0x00)
3634 {
3635 case 0x00:
3636 op_semantics_19:
3637 {
3638 /** 0011 11sz d dst sppp mov%s #%1, %0 */
f282425e 3639#line 295 "rx-decode.opc"
c7927a3c 3640 int sz AU = op[0] & 0x03;
f282425e 3641#line 295 "rx-decode.opc"
c7927a3c 3642 int d AU = (op[1] >> 7) & 0x01;
f282425e 3643#line 295 "rx-decode.opc"
c7927a3c 3644 int dst AU = (op[1] >> 4) & 0x07;
f282425e 3645#line 295 "rx-decode.opc"
c7927a3c
NC		 3646 int sppp AU = op[1] & 0x0f;
3647 if (trace)
3648 {
3649 printf ("\033[33m%s\033[0m %02x %02x\n",
3650 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3651 op[0], op[1]);
3652 printf (" sz = 0x%x,", sz);
3653 printf (" d = 0x%x,", d);
3654 printf (" dst = 0x%x,", dst);
3655 printf (" sppp = 0x%x\n", sppp);
3656 }
3657 SYNTAX("mov%s #%1, %0");
f282425e 3658#line 295 "rx-decode.opc"
c7927a3c
NC		 3659 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F("----");
3660
3661 }
3662 break;
3663 }
3664 break;
3665 case 0x3d:
3666 GETBYTE ();
3667 switch (op[1] & 0x00)
3668 {
3669 case 0x00:
3670 goto op_semantics_19;
3671 break;
3672 }
3673 break;
3674 case 0x3e:
3675 GETBYTE ();
3676 switch (op[1] & 0x00)
3677 {
3678 case 0x00:
3679 goto op_semantics_19;
3680 break;
3681 }
3682 break;
3683 case 0x3f:
3684 GETBYTE ();
3685 switch (op[1] & 0x00)
3686 {
3687 case 0x00:
3688 {
3689 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
f282425e 3690#line 384 "rx-decode.opc"
c7927a3c 3691 int rega AU = (op[1] >> 4) & 0x0f;
f282425e 3692#line 384 "rx-decode.opc"
c7927a3c
NC		 3693 int regb AU = op[1] & 0x0f;
3694 if (trace)
3695 {
3696 printf ("\033[33m%s\033[0m %02x %02x\n",
3697 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3698 op[0], op[1]);
3699 printf (" rega = 0x%x,", rega);
3700 printf (" regb = 0x%x\n", regb);
3701 }
3702 SYNTAX("rtsd #%1, %2-%0");
f282425e 3703#line 384 "rx-decode.opc"
c7927a3c
NC		 3704 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3705
3706 /*----------------------------------------------------------------------*/
3707 /* AND */
3708
3709 }
3710 break;
3711 }
3712 break;
3713 case 0x40:
3714 GETBYTE ();
3715 switch (op[1] & 0x00)
3716 {
3717 case 0x00:
3718 op_semantics_20:
3719 {
3720 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
f282425e 3721#line 519 "rx-decode.opc"
c7927a3c 3722 int ss AU = op[0] & 0x03;
f282425e 3723#line 519 "rx-decode.opc"
c7927a3c 3724 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 3725#line 519 "rx-decode.opc"
c7927a3c
NC		 3726 int rdst AU = op[1] & 0x0f;
3727 if (trace)
3728 {
3729 printf ("\033[33m%s\033[0m %02x %02x\n",
3730 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3731 op[0], op[1]);
3732 printf (" ss = 0x%x,", ss);
3733 printf (" rsrc = 0x%x,", rsrc);
3734 printf (" rdst = 0x%x\n", rdst);
3735 }
3736 SYNTAX("sub %2%S2, %1");
f282425e 3737#line 519 "rx-decode.opc"
c7927a3c
NC		 3738 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F("OSZC");
3739
3740 }
3741 break;
3742 }
3743 break;
3744 case 0x41:
3745 GETBYTE ();
3746 switch (op[1] & 0x00)
3747 {
3748 case 0x00:
3749 goto op_semantics_20;
3750 break;
3751 }
3752 break;
3753 case 0x42:
3754 GETBYTE ();
3755 switch (op[1] & 0x00)
3756 {
3757 case 0x00:
3758 goto op_semantics_20;
3759 break;
3760 }
3761 break;
3762 case 0x43:
3763 GETBYTE ();
3764 switch (op[1] & 0x00)
3765 {
3766 case 0x00:
3767 goto op_semantics_20;
3768 break;
3769 }
3770 break;
3771 case 0x44:
3772 GETBYTE ();
3773 switch (op[1] & 0x00)
3774 {
3775 case 0x00:
3776 op_semantics_21:
3777 {
3778 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
f282425e 3779#line 507 "rx-decode.opc"
c7927a3c 3780 int ss AU = op[0] & 0x03;
f282425e 3781#line 507 "rx-decode.opc"
c7927a3c 3782 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 3783#line 507 "rx-decode.opc"
c7927a3c
NC		 3784 int rdst AU = op[1] & 0x0f;
3785 if (trace)
3786 {
3787 printf ("\033[33m%s\033[0m %02x %02x\n",
3788 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3789 op[0], op[1]);
3790 printf (" ss = 0x%x,", ss);
3791 printf (" rsrc = 0x%x,", rsrc);
3792 printf (" rdst = 0x%x\n", rdst);
3793 }
3794 SYNTAX("cmp %2%S2, %1");
f282425e 3795#line 507 "rx-decode.opc"
c7927a3c
NC		 3796 ID(sub); S2P(ss, rsrc); SR(rdst); F("OSZC");
3797
3798 }
3799 break;
3800 }
3801 break;
3802 case 0x45:
3803 GETBYTE ();
3804 switch (op[1] & 0x00)
3805 {
3806 case 0x00:
3807 goto op_semantics_21;
3808 break;
3809 }
3810 break;
3811 case 0x46:
3812 GETBYTE ();
3813 switch (op[1] & 0x00)
3814 {
3815 case 0x00:
3816 goto op_semantics_21;
3817 break;
3818 }
3819 break;
3820 case 0x47:
3821 GETBYTE ();
3822 switch (op[1] & 0x00)
3823 {
3824 case 0x00:
3825 goto op_semantics_21;
3826 break;
3827 }
3828 break;
3829 case 0x48:
3830 GETBYTE ();
3831 switch (op[1] & 0x00)
3832 {
3833 case 0x00:
3834 op_semantics_22:
3835 {
3836 /** 0100 10ss rsrc rdst add %1%S1, %0 */
f282425e 3837#line 483 "rx-decode.opc"
c7927a3c 3838 int ss AU = op[0] & 0x03;
f282425e 3839#line 483 "rx-decode.opc"
c7927a3c 3840 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 3841#line 483 "rx-decode.opc"
c7927a3c
NC		 3842 int rdst AU = op[1] & 0x0f;
3843 if (trace)
3844 {
3845 printf ("\033[33m%s\033[0m %02x %02x\n",
3846 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3847 op[0], op[1]);
3848 printf (" ss = 0x%x,", ss);
3849 printf (" rsrc = 0x%x,", rsrc);
3850 printf (" rdst = 0x%x\n", rdst);
3851 }
3852 SYNTAX("add %1%S1, %0");
f282425e 3853#line 483 "rx-decode.opc"
c7927a3c
NC		 3854 ID(add); SP(ss, rsrc); DR(rdst); F("OSZC");
3855
3856 }
3857 break;
3858 }
3859 break;
3860 case 0x49:
3861 GETBYTE ();
3862 switch (op[1] & 0x00)
3863 {
3864 case 0x00:
3865 goto op_semantics_22;
3866 break;
3867 }
3868 break;
3869 case 0x4a:
3870 GETBYTE ();
3871 switch (op[1] & 0x00)
3872 {
3873 case 0x00:
3874 goto op_semantics_22;
3875 break;
3876 }
3877 break;
3878 case 0x4b:
3879 GETBYTE ();
3880 switch (op[1] & 0x00)
3881 {
3882 case 0x00:
3883 goto op_semantics_22;
3884 break;
3885 }
3886 break;
3887 case 0x4c:
3888 GETBYTE ();
3889 switch (op[1] & 0x00)
3890 {
3891 case 0x00:
3892 op_semantics_23:
3893 {
3894 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
f282425e 3895#line 580 "rx-decode.opc"
c7927a3c 3896 int ss AU = op[0] & 0x03;
f282425e 3897#line 580 "rx-decode.opc"
c7927a3c 3898 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 3899#line 580 "rx-decode.opc"
c7927a3c
NC		 3900 int rdst AU = op[1] & 0x0f;
3901 if (trace)
3902 {
3903 printf ("\033[33m%s\033[0m %02x %02x\n",
3904 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3905 op[0], op[1]);
3906 printf (" ss = 0x%x,", ss);
3907 printf (" rsrc = 0x%x,", rsrc);
3908 printf (" rdst = 0x%x\n", rdst);
3909 }
3910 SYNTAX("mul %1%S1, %0");
f282425e
DD		 3911#line 580 "rx-decode.opc"
3912 ID(mul); SP(ss, rsrc); DR(rdst); F("----");
c7927a3c
NC		 3913
3914 }
3915 break;
3916 }
3917 break;
3918 case 0x4d:
3919 GETBYTE ();
3920 switch (op[1] & 0x00)
3921 {
3922 case 0x00:
3923 goto op_semantics_23;
3924 break;
3925 }
3926 break;
3927 case 0x4e:
3928 GETBYTE ();
3929 switch (op[1] & 0x00)
3930 {
3931 case 0x00:
3932 goto op_semantics_23;
3933 break;
3934 }
3935 break;
3936 case 0x4f:
3937 GETBYTE ();
3938 switch (op[1] & 0x00)
3939 {
3940 case 0x00:
3941 goto op_semantics_23;
3942 break;
3943 }
3944 break;
3945 case 0x50:
3946 GETBYTE ();
3947 switch (op[1] & 0x00)
3948 {
3949 case 0x00:
3950 op_semantics_24:
3951 {
3952 /** 0101 00ss rsrc rdst and %1%S1, %0 */
f282425e 3953#line 396 "rx-decode.opc"
c7927a3c 3954 int ss AU = op[0] & 0x03;
f282425e 3955#line 396 "rx-decode.opc"
c7927a3c 3956 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 3957#line 396 "rx-decode.opc"
c7927a3c
NC		 3958 int rdst AU = op[1] & 0x0f;
3959 if (trace)
3960 {
3961 printf ("\033[33m%s\033[0m %02x %02x\n",
3962 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3963 op[0], op[1]);
3964 printf (" ss = 0x%x,", ss);
3965 printf (" rsrc = 0x%x,", rsrc);
3966 printf (" rdst = 0x%x\n", rdst);
3967 }
3968 SYNTAX("and %1%S1, %0");
f282425e 3969#line 396 "rx-decode.opc"
c7927a3c
NC		 3970 ID(and); SP(ss, rsrc); DR(rdst); F("-SZ-");
3971
3972 }
3973 break;
3974 }
3975 break;
3976 case 0x51:
3977 GETBYTE ();
3978 switch (op[1] & 0x00)
3979 {
3980 case 0x00:
3981 goto op_semantics_24;
3982 break;
3983 }
3984 break;
3985 case 0x52:
3986 GETBYTE ();
3987 switch (op[1] & 0x00)
3988 {
3989 case 0x00:
3990 goto op_semantics_24;
3991 break;
3992 }
3993 break;
3994 case 0x53:
3995 GETBYTE ();
3996 switch (op[1] & 0x00)
3997 {
3998 case 0x00:
3999 goto op_semantics_24;
4000 break;
4001 }
4002 break;
4003 case 0x54:
4004 GETBYTE ();
4005 switch (op[1] & 0x00)
4006 {
4007 case 0x00:
4008 op_semantics_25:
4009 {
4010 /** 0101 01ss rsrc rdst or %1%S1, %0 */
f282425e 4011#line 414 "rx-decode.opc"
c7927a3c 4012 int ss AU = op[0] & 0x03;
f282425e 4013#line 414 "rx-decode.opc"
c7927a3c 4014 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 4015#line 414 "rx-decode.opc"
c7927a3c
NC		 4016 int rdst AU = op[1] & 0x0f;
4017 if (trace)
4018 {
4019 printf ("\033[33m%s\033[0m %02x %02x\n",
4020 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4021 op[0], op[1]);
4022 printf (" ss = 0x%x,", ss);
4023 printf (" rsrc = 0x%x,", rsrc);
4024 printf (" rdst = 0x%x\n", rdst);
4025 }
4026 SYNTAX("or %1%S1, %0");
f282425e 4027#line 414 "rx-decode.opc"
c7927a3c
NC		 4028 ID(or); SP(ss, rsrc); DR(rdst); F("-SZ-");
4029
4030 }
4031 break;
4032 }
4033 break;
4034 case 0x55:
4035 GETBYTE ();
4036 switch (op[1] & 0x00)
4037 {
4038 case 0x00:
4039 goto op_semantics_25;
4040 break;
4041 }
4042 break;
4043 case 0x56:
4044 GETBYTE ();
4045 switch (op[1] & 0x00)
4046 {
4047 case 0x00:
4048 goto op_semantics_25;
4049 break;
4050 }
4051 break;
4052 case 0x57:
4053 GETBYTE ();
4054 switch (op[1] & 0x00)
4055 {
4056 case 0x00:
4057 goto op_semantics_25;
4058 break;
4059 }
4060 break;
4061 case 0x58:
4062 GETBYTE ();
4063 switch (op[1] & 0x00)
4064 {
4065 case 0x00:
4066 op_semantics_26:
4067 {
4068 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
f282425e 4069#line 335 "rx-decode.opc"
c7927a3c 4070 int s AU = (op[0] >> 2) & 0x01;
f282425e 4071#line 335 "rx-decode.opc"
c7927a3c 4072 int ss AU = op[0] & 0x03;
f282425e 4073#line 335 "rx-decode.opc"
c7927a3c 4074 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 4075#line 335 "rx-decode.opc"
c7927a3c
NC		 4076 int rdst AU = op[1] & 0x0f;
4077 if (trace)
4078 {
4079 printf ("\033[33m%s\033[0m %02x %02x\n",
4080 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4081 op[0], op[1]);
4082 printf (" s = 0x%x,", s);
4083 printf (" ss = 0x%x,", ss);
4084 printf (" rsrc = 0x%x,", rsrc);
4085 printf (" rdst = 0x%x\n", rdst);
4086 }
4087 SYNTAX("movu%s %1, %0");
f282425e 4088#line 335 "rx-decode.opc"
c7927a3c
NC		 4089 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F("----");
4090
4091 }
4092 break;
4093 }
4094 break;
4095 case 0x59:
4096 GETBYTE ();
4097 switch (op[1] & 0x00)
4098 {
4099 case 0x00:
4100 goto op_semantics_26;
4101 break;
4102 }
4103 break;
4104 case 0x5a:
4105 GETBYTE ();
4106 switch (op[1] & 0x00)
4107 {
4108 case 0x00:
4109 goto op_semantics_26;
4110 break;
4111 }
4112 break;
4113 case 0x5b:
4114 GETBYTE ();
4115 switch (op[1] & 0x00)
4116 {
4117 case 0x00:
4118 goto op_semantics_26;
4119 break;
4120 }
4121 break;
4122 case 0x5c:
4123 GETBYTE ();
4124 switch (op[1] & 0x00)
4125 {
4126 case 0x00:
4127 goto op_semantics_26;
4128 break;
4129 }
4130 break;
4131 case 0x5d:
4132 GETBYTE ();
4133 switch (op[1] & 0x00)
4134 {
4135 case 0x00:
4136 goto op_semantics_26;
4137 break;
4138 }
4139 break;
4140 case 0x5e:
4141 GETBYTE ();
4142 switch (op[1] & 0x00)
4143 {
4144 case 0x00:
4145 goto op_semantics_26;
4146 break;
4147 }
4148 break;
4149 case 0x5f:
4150 GETBYTE ();
4151 switch (op[1] & 0x00)
4152 {
4153 case 0x00:
4154 goto op_semantics_26;
4155 break;
4156 }
4157 break;
4158 case 0x60:
4159 GETBYTE ();
4160 switch (op[1] & 0x00)
4161 {
4162 case 0x00:
4163 {
4164 /** 0110 0000 immm rdst sub #%2, %0 */
f282425e 4165#line 516 "rx-decode.opc"
c7927a3c 4166 int immm AU = (op[1] >> 4) & 0x0f;
f282425e 4167#line 516 "rx-decode.opc"
c7927a3c
NC		 4168 int rdst AU = op[1] & 0x0f;
4169 if (trace)
4170 {
4171 printf ("\033[33m%s\033[0m %02x %02x\n",
4172 "/** 0110 0000 immm rdst sub #%2, %0 */",
4173 op[0], op[1]);
4174 printf (" immm = 0x%x,", immm);
4175 printf (" rdst = 0x%x\n", rdst);
4176 }
4177 SYNTAX("sub #%2, %0");
f282425e 4178#line 516 "rx-decode.opc"
c7927a3c
NC		 4179 ID(sub); S2C(immm); SR(rdst); DR(rdst); F("OSZC");
4180
4181 }
4182 break;
4183 }
4184 break;
4185 case 0x61:
4186 GETBYTE ();
4187 switch (op[1] & 0x00)
4188 {
4189 case 0x00:
4190 {
4191 /** 0110 0001 immm rdst cmp #%2, %1 */
f282425e 4192#line 498 "rx-decode.opc"
c7927a3c 4193 int immm AU = (op[1] >> 4) & 0x0f;
f282425e 4194#line 498 "rx-decode.opc"
c7927a3c
NC		 4195 int rdst AU = op[1] & 0x0f;
4196 if (trace)
4197 {
4198 printf ("\033[33m%s\033[0m %02x %02x\n",
4199 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4200 op[0], op[1]);
4201 printf (" immm = 0x%x,", immm);
4202 printf (" rdst = 0x%x\n", rdst);
4203 }
4204 SYNTAX("cmp #%2, %1");
f282425e 4205#line 498 "rx-decode.opc"
c7927a3c
NC		 4206 ID(sub); S2C(immm); SR(rdst); F("OSZC");
4207
4208 }
4209 break;
4210 }
4211 break;
4212 case 0x62:
4213 GETBYTE ();
4214 switch (op[1] & 0x00)
4215 {
4216 case 0x00:
4217 {
4218 /** 0110 0010 immm rdst add #%1, %0 */
f282425e 4219#line 480 "rx-decode.opc"
c7927a3c 4220 int immm AU = (op[1] >> 4) & 0x0f;
f282425e 4221#line 480 "rx-decode.opc"
c7927a3c
NC		 4222 int rdst AU = op[1] & 0x0f;
4223 if (trace)
4224 {
4225 printf ("\033[33m%s\033[0m %02x %02x\n",
4226 "/** 0110 0010 immm rdst add #%1, %0 */",
4227 op[0], op[1]);
4228 printf (" immm = 0x%x,", immm);
4229 printf (" rdst = 0x%x\n", rdst);
4230 }
4231 SYNTAX("add #%1, %0");
f282425e 4232#line 480 "rx-decode.opc"
c7927a3c
NC		 4233 ID(add); SC(immm); DR(rdst); F("OSZC");
4234
4235 }
4236 break;
4237 }
4238 break;
4239 case 0x63:
4240 GETBYTE ();
4241 switch (op[1] & 0x00)
4242 {
4243 case 0x00:
4244 {
4245 /** 0110 0011 immm rdst mul #%1, %0 */
f282425e 4246#line 574 "rx-decode.opc"
c7927a3c 4247 int immm AU = (op[1] >> 4) & 0x0f;
f282425e 4248#line 574 "rx-decode.opc"
c7927a3c
NC		 4249 int rdst AU = op[1] & 0x0f;
4250 if (trace)
4251 {
4252 printf ("\033[33m%s\033[0m %02x %02x\n",
4253 "/** 0110 0011 immm rdst mul #%1, %0 */",
4254 op[0], op[1]);
4255 printf (" immm = 0x%x,", immm);
4256 printf (" rdst = 0x%x\n", rdst);
4257 }
4258 SYNTAX("mul #%1, %0");
f282425e
DD		 4259#line 574 "rx-decode.opc"
4260 ID(mul); DR(rdst); SC(immm); F("----");
c7927a3c
NC		 4261
4262 }
4263 break;
4264 }
4265 break;
4266 case 0x64:
4267 GETBYTE ();
4268 switch (op[1] & 0x00)
4269 {
4270 case 0x00:
4271 {
4272 /** 0110 0100 immm rdst and #%1, %0 */
f282425e 4273#line 390 "rx-decode.opc"
c7927a3c 4274 int immm AU = (op[1] >> 4) & 0x0f;
f282425e 4275#line 390 "rx-decode.opc"
c7927a3c
NC		 4276 int rdst AU = op[1] & 0x0f;
4277 if (trace)
4278 {
4279 printf ("\033[33m%s\033[0m %02x %02x\n",
4280 "/** 0110 0100 immm rdst and #%1, %0 */",
4281 op[0], op[1]);
4282 printf (" immm = 0x%x,", immm);
4283 printf (" rdst = 0x%x\n", rdst);
4284 }
4285 SYNTAX("and #%1, %0");
f282425e 4286#line 390 "rx-decode.opc"
c7927a3c
NC		 4287 ID(and); SC(immm); DR(rdst); F("-SZ-");
4288
4289 }
4290 break;
4291 }
4292 break;
4293 case 0x65:
4294 GETBYTE ();
4295 switch (op[1] & 0x00)
4296 {
4297 case 0x00:
4298 {
4299 /** 0110 0101 immm rdst or #%1, %0 */
f282425e 4300#line 408 "rx-decode.opc"
c7927a3c 4301 int immm AU = (op[1] >> 4) & 0x0f;
f282425e 4302#line 408 "rx-decode.opc"
c7927a3c
NC		 4303 int rdst AU = op[1] & 0x0f;
4304 if (trace)
4305 {
4306 printf ("\033[33m%s\033[0m %02x %02x\n",
4307 "/** 0110 0101 immm rdst or #%1, %0 */",
4308 op[0], op[1]);
4309 printf (" immm = 0x%x,", immm);
4310 printf (" rdst = 0x%x\n", rdst);
4311 }
4312 SYNTAX("or #%1, %0");
f282425e 4313#line 408 "rx-decode.opc"
c7927a3c
NC		 4314 ID(or); SC(immm); DR(rdst); F("-SZ-");
4315
4316 }
4317 break;
4318 }
4319 break;
4320 case 0x66:
4321 GETBYTE ();
4322 switch (op[1] & 0x00)
4323 {
4324 case 0x00:
4325 {
4326 /** 0110 0110 immm rdst mov%s #%1, %0 */
f282425e 4327#line 292 "rx-decode.opc"
c7927a3c 4328 int immm AU = (op[1] >> 4) & 0x0f;
f282425e 4329#line 292 "rx-decode.opc"
c7927a3c
NC		 4330 int rdst AU = op[1] & 0x0f;
4331 if (trace)
4332 {
4333 printf ("\033[33m%s\033[0m %02x %02x\n",
4334 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4335 op[0], op[1]);
4336 printf (" immm = 0x%x,", immm);
4337 printf (" rdst = 0x%x\n", rdst);
4338 }
4339 SYNTAX("mov%s #%1, %0");
f282425e 4340#line 292 "rx-decode.opc"
c7927a3c
NC		 4341 ID(mov); DR(rdst); SC(immm); F("----");
4342
4343 }
4344 break;
4345 }
4346 break;
4347 case 0x67:
4348 {
4349 /** 0110 0111 rtsd #%1 */
4350 if (trace)
4351 {
4352 printf ("\033[33m%s\033[0m %02x\n",
4353 "/** 0110 0111 rtsd #%1 */",
4354 op[0]);
4355 }
4356 SYNTAX("rtsd #%1");
f282425e 4357#line 381 "rx-decode.opc"
c7927a3c
NC		 4358 ID(rtsd); SC(IMM(1) * 4);
4359
4360 }
4361 break;
4362 case 0x68:
4363 GETBYTE ();
4364 switch (op[1] & 0x00)
4365 {
4366 case 0x00:
4367 op_semantics_27:
4368 {
4369 /** 0110 100i mmmm rdst shlr #%2, %0 */
f282425e 4370#line 660 "rx-decode.opc"
c7927a3c 4371 int i AU = op[0] & 0x01;
f282425e 4372#line 660 "rx-decode.opc"
c7927a3c 4373 int mmmm AU = (op[1] >> 4) & 0x0f;
f282425e 4374#line 660 "rx-decode.opc"
c7927a3c
NC		 4375 int rdst AU = op[1] & 0x0f;
4376 if (trace)
4377 {
4378 printf ("\033[33m%s\033[0m %02x %02x\n",
4379 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4380 op[0], op[1]);
4381 printf (" i = 0x%x,", i);
4382 printf (" mmmm = 0x%x,", mmmm);
4383 printf (" rdst = 0x%x\n", rdst);
4384 }
4385 SYNTAX("shlr #%2, %0");
f282425e 4386#line 660 "rx-decode.opc"
c7927a3c
NC		 4387 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("-SZC");
4388
4389 }
4390 break;
4391 }
4392 break;
4393 case 0x69:
4394 GETBYTE ();
4395 switch (op[1] & 0x00)
4396 {
4397 case 0x00:
4398 goto op_semantics_27;
4399 break;
4400 }
4401 break;
4402 case 0x6a:
4403 GETBYTE ();
4404 switch (op[1] & 0x00)
4405 {
4406 case 0x00:
4407 op_semantics_28:
4408 {
4409 /** 0110 101i mmmm rdst shar #%2, %0 */
f282425e 4410#line 650 "rx-decode.opc"
c7927a3c 4411 int i AU = op[0] & 0x01;
f282425e 4412#line 650 "rx-decode.opc"
c7927a3c 4413 int mmmm AU = (op[1] >> 4) & 0x0f;
f282425e 4414#line 650 "rx-decode.opc"
c7927a3c
NC		 4415 int rdst AU = op[1] & 0x0f;
4416 if (trace)
4417 {
4418 printf ("\033[33m%s\033[0m %02x %02x\n",
4419 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4420 op[0], op[1]);
4421 printf (" i = 0x%x,", i);
4422 printf (" mmmm = 0x%x,", mmmm);
4423 printf (" rdst = 0x%x\n", rdst);
4424 }
4425 SYNTAX("shar #%2, %0");
f282425e 4426#line 650 "rx-decode.opc"
c7927a3c
NC		 4427 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("0SZC");
4428
4429 }
4430 break;
4431 }
4432 break;
4433 case 0x6b:
4434 GETBYTE ();
4435 switch (op[1] & 0x00)
4436 {
4437 case 0x00:
4438 goto op_semantics_28;
4439 break;
4440 }
4441 break;
4442 case 0x6c:
4443 GETBYTE ();
4444 switch (op[1] & 0x00)
4445 {
4446 case 0x00:
4447 op_semantics_29:
4448 {
4449 /** 0110 110i mmmm rdst shll #%2, %0 */
f282425e 4450#line 640 "rx-decode.opc"
c7927a3c 4451 int i AU = op[0] & 0x01;
f282425e 4452#line 640 "rx-decode.opc"
c7927a3c 4453 int mmmm AU = (op[1] >> 4) & 0x0f;
f282425e 4454#line 640 "rx-decode.opc"
c7927a3c
NC		 4455 int rdst AU = op[1] & 0x0f;
4456 if (trace)
4457 {
4458 printf ("\033[33m%s\033[0m %02x %02x\n",
4459 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4460 op[0], op[1]);
4461 printf (" i = 0x%x,", i);
4462 printf (" mmmm = 0x%x,", mmmm);
4463 printf (" rdst = 0x%x\n", rdst);
4464 }
4465 SYNTAX("shll #%2, %0");
f282425e 4466#line 640 "rx-decode.opc"
c7927a3c
NC		 4467 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("OSZC");
4468
4469 }
4470 break;
4471 }
4472 break;
4473 case 0x6d:
4474 GETBYTE ();
4475 switch (op[1] & 0x00)
4476 {
4477 case 0x00:
4478 goto op_semantics_29;
4479 break;
4480 }
4481 break;
4482 case 0x6e:
4483 GETBYTE ();
4484 switch (op[1] & 0x00)
4485 {
4486 case 0x00:
4487 {
4488 /** 0110 1110 dsta dstb pushm %1-%2 */
f282425e 4489#line 348 "rx-decode.opc"
c7927a3c 4490 int dsta AU = (op[1] >> 4) & 0x0f;
f282425e 4491#line 348 "rx-decode.opc"
c7927a3c
NC		 4492 int dstb AU = op[1] & 0x0f;
4493 if (trace)
4494 {
4495 printf ("\033[33m%s\033[0m %02x %02x\n",
4496 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4497 op[0], op[1]);
4498 printf (" dsta = 0x%x,", dsta);
4499 printf (" dstb = 0x%x\n", dstb);
4500 }
4501 SYNTAX("pushm %1-%2");
f282425e 4502#line 348 "rx-decode.opc"
c7927a3c
NC		 4503 ID(pushm); SR(dsta); S2R(dstb); F("----");
4504
4505 }
4506 break;
4507 }
4508 break;
4509 case 0x6f:
4510 GETBYTE ();
4511 switch (op[1] & 0x00)
4512 {
4513 case 0x00:
4514 {
4515 /** 0110 1111 dsta dstb popm %1-%2 */
f282425e 4516#line 345 "rx-decode.opc"
c7927a3c 4517 int dsta AU = (op[1] >> 4) & 0x0f;
f282425e 4518#line 345 "rx-decode.opc"
c7927a3c
NC		 4519 int dstb AU = op[1] & 0x0f;
4520 if (trace)
4521 {
4522 printf ("\033[33m%s\033[0m %02x %02x\n",
4523 "/** 0110 1111 dsta dstb popm %1-%2 */",
4524 op[0], op[1]);
4525 printf (" dsta = 0x%x,", dsta);
4526 printf (" dstb = 0x%x\n", dstb);
4527 }
4528 SYNTAX("popm %1-%2");
f282425e 4529#line 345 "rx-decode.opc"
c7927a3c
NC		 4530 ID(popm); SR(dsta); S2R(dstb); F("----");
4531
4532 }
4533 break;
4534 }
4535 break;
4536 case 0x70:
4537 GETBYTE ();
4538 switch (op[1] & 0x00)
4539 {
4540 case 0x00:
4541 op_semantics_30:
4542 {
4543 /** 0111 00im rsrc rdst add #%1, %2, %0 */
f282425e 4544#line 489 "rx-decode.opc"
c7927a3c 4545 int im AU = op[0] & 0x03;
f282425e 4546#line 489 "rx-decode.opc"
c7927a3c 4547 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 4548#line 489 "rx-decode.opc"
c7927a3c
NC		 4549 int rdst AU = op[1] & 0x0f;
4550 if (trace)
4551 {
4552 printf ("\033[33m%s\033[0m %02x %02x\n",
4553 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4554 op[0], op[1]);
4555 printf (" im = 0x%x,", im);
4556 printf (" rsrc = 0x%x,", rsrc);
4557 printf (" rdst = 0x%x\n", rdst);
4558 }
4559 SYNTAX("add #%1, %2, %0");
f282425e 4560#line 489 "rx-decode.opc"
c7927a3c
NC		 4561 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F("OSZC");
4562
4563 }
4564 break;
4565 }
4566 break;
4567 case 0x71:
4568 GETBYTE ();
4569 switch (op[1] & 0x00)
4570 {
4571 case 0x00:
4572 goto op_semantics_30;
4573 break;
4574 }
4575 break;
4576 case 0x72:
4577 GETBYTE ();
4578 switch (op[1] & 0x00)
4579 {
4580 case 0x00:
4581 goto op_semantics_30;
4582 break;
4583 }
4584 break;
4585 case 0x73:
4586 GETBYTE ();
4587 switch (op[1] & 0x00)
4588 {
4589 case 0x00:
4590 goto op_semantics_30;
4591 break;
4592 }
4593 break;
4594 case 0x74:
4595 GETBYTE ();
4596 switch (op[1] & 0xf0)
4597 {
4598 case 0x00:
4599 op_semantics_31:
4600 {
4601 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
f282425e 4602#line 501 "rx-decode.opc"
c7927a3c 4603 int im AU = op[0] & 0x03;
f282425e 4604#line 501 "rx-decode.opc"
c7927a3c
NC		 4605 int rsrc AU = op[1] & 0x0f;
4606 if (trace)
4607 {
4608 printf ("\033[33m%s\033[0m %02x %02x\n",
4609 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4610 op[0], op[1]);
4611 printf (" im = 0x%x,", im);
4612 printf (" rsrc = 0x%x\n", rsrc);
4613 }
4614 SYNTAX("cmp #%2, %1%S1");
f282425e 4615#line 501 "rx-decode.opc"
c7927a3c
NC		 4616 ID(sub); SR(rsrc); S2C(IMMex(im)); F("OSZC");
4617
4618 }
4619 break;
4620 case 0x10:
4621 op_semantics_32:
4622 {
4623 /** 0111 01im 0001rdst mul #%1, %0 */
f282425e 4624#line 577 "rx-decode.opc"
c7927a3c 4625 int im AU = op[0] & 0x03;
f282425e 4626#line 577 "rx-decode.opc"
c7927a3c
NC		 4627 int rdst AU = op[1] & 0x0f;
4628 if (trace)
4629 {
4630 printf ("\033[33m%s\033[0m %02x %02x\n",
4631 "/** 0111 01im 0001rdst mul #%1, %0 */",
4632 op[0], op[1]);
4633 printf (" im = 0x%x,", im);
4634 printf (" rdst = 0x%x\n", rdst);
4635 }
4636 SYNTAX("mul #%1, %0");
f282425e
DD		 4637#line 577 "rx-decode.opc"
4638 ID(mul); DR(rdst); SC(IMMex(im)); F("----");
c7927a3c
NC		 4639
4640 }
4641 break;
4642 case 0x20:
4643 op_semantics_33:
4644 {
4645 /** 0111 01im 0010 rdst and #%1, %0 */
f282425e 4646#line 393 "rx-decode.opc"
c7927a3c 4647 int im AU = op[0] & 0x03;
f282425e 4648#line 393 "rx-decode.opc"
c7927a3c
NC		 4649 int rdst AU = op[1] & 0x0f;
4650 if (trace)
4651 {
4652 printf ("\033[33m%s\033[0m %02x %02x\n",
4653 "/** 0111 01im 0010 rdst and #%1, %0 */",
4654 op[0], op[1]);
4655 printf (" im = 0x%x,", im);
4656 printf (" rdst = 0x%x\n", rdst);
4657 }
4658 SYNTAX("and #%1, %0");
f282425e 4659#line 393 "rx-decode.opc"
c7927a3c
NC		 4660 ID(and); SC(IMMex(im)); DR(rdst); F("-SZ-");
4661
4662 }
4663 break;
4664 case 0x30:
4665 op_semantics_34:
4666 {
4667 /** 0111 01im 0011 rdst or #%1, %0 */
f282425e 4668#line 411 "rx-decode.opc"
c7927a3c 4669 int im AU = op[0] & 0x03;
f282425e 4670#line 411 "rx-decode.opc"
c7927a3c
NC		 4671 int rdst AU = op[1] & 0x0f;
4672 if (trace)
4673 {
4674 printf ("\033[33m%s\033[0m %02x %02x\n",
4675 "/** 0111 01im 0011 rdst or #%1, %0 */",
4676 op[0], op[1]);
4677 printf (" im = 0x%x,", im);
4678 printf (" rdst = 0x%x\n", rdst);
4679 }
4680 SYNTAX("or #%1, %0");
f282425e 4681#line 411 "rx-decode.opc"
c7927a3c
NC		 4682 ID(or); SC(IMMex(im)); DR(rdst); F("-SZ-");
4683
4684 }
4685 break;
4686 default: UNSUPPORTED(); break;
4687 }
4688 break;
4689 case 0x75:
4690 GETBYTE ();
4691 switch (op[1] & 0xff)
4692 {
4693 case 0x00:
4694 case 0x01:
4695 case 0x02:
4696 case 0x03:
4697 case 0x04:
4698 case 0x05:
4699 case 0x06:
4700 case 0x07:
4701 case 0x08:
4702 case 0x09:
4703 case 0x0a:
4704 case 0x0b:
4705 case 0x0c:
4706 case 0x0d:
4707 case 0x0e:
4708 case 0x0f:
4709 goto op_semantics_31;
4710 break;
4711 case 0x10:
4712 case 0x11:
4713 case 0x12:
4714 case 0x13:
4715 case 0x14:
4716 case 0x15:
4717 case 0x16:
4718 case 0x17:
4719 case 0x18:
4720 case 0x19:
4721 case 0x1a:
4722 case 0x1b:
4723 case 0x1c:
4724 case 0x1d:
4725 case 0x1e:
4726 case 0x1f:
4727 goto op_semantics_32;
4728 break;
4729 case 0x20:
4730 case 0x21:
4731 case 0x22:
4732 case 0x23:
4733 case 0x24:
4734 case 0x25:
4735 case 0x26:
4736 case 0x27:
4737 case 0x28:
4738 case 0x29:
4739 case 0x2a:
4740 case 0x2b:
4741 case 0x2c:
4742 case 0x2d:
4743 case 0x2e:
4744 case 0x2f:
4745 goto op_semantics_33;
4746 break;
4747 case 0x30:
4748 case 0x31:
4749 case 0x32:
4750 case 0x33:
4751 case 0x34:
4752 case 0x35:
4753 case 0x36:
4754 case 0x37:
4755 case 0x38:
4756 case 0x39:
4757 case 0x3a:
4758 case 0x3b:
4759 case 0x3c:
4760 case 0x3d:
4761 case 0x3e:
4762 case 0x3f:
4763 goto op_semantics_34;
4764 break;
4765 case 0x40:
4766 case 0x41:
4767 case 0x42:
4768 case 0x43:
4769 case 0x44:
4770 case 0x45:
4771 case 0x46:
4772 case 0x47:
4773 case 0x48:
4774 case 0x49:
4775 case 0x4a:
4776 case 0x4b:
4777 case 0x4c:
4778 case 0x4d:
4779 case 0x4e:
4780 case 0x4f:
4781 {
4782 /** 0111 0101 0100 rdst mov%s #%1, %0 */
f282425e 4783#line 286 "rx-decode.opc"
c7927a3c
NC		 4784 int rdst AU = op[1] & 0x0f;
4785 if (trace)
4786 {
4787 printf ("\033[33m%s\033[0m %02x %02x\n",
4788 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4789 op[0], op[1]);
4790 printf (" rdst = 0x%x\n", rdst);
4791 }
4792 SYNTAX("mov%s #%1, %0");
f282425e 4793#line 286 "rx-decode.opc"
c7927a3c
NC		 4794 ID(mov); DR(rdst); SC(IMM (1)); F("----");
4795
4796 }
4797 break;
4798 case 0x50:
4799 case 0x51:
4800 case 0x52:
4801 case 0x53:
4802 case 0x54:
4803 case 0x55:
4804 case 0x56:
4805 case 0x57:
4806 case 0x58:
4807 case 0x59:
4808 case 0x5a:
4809 case 0x5b:
4810 case 0x5c:
4811 case 0x5d:
4812 case 0x5e:
4813 case 0x5f:
4814 {
4815 /** 0111 0101 0101 rsrc cmp #%2, %1 */
f282425e 4816#line 504 "rx-decode.opc"
c7927a3c
NC		 4817 int rsrc AU = op[1] & 0x0f;
4818 if (trace)
4819 {
4820 printf ("\033[33m%s\033[0m %02x %02x\n",
4821 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4822 op[0], op[1]);
4823 printf (" rsrc = 0x%x\n", rsrc);
4824 }
4825 SYNTAX("cmp #%2, %1");
f282425e 4826#line 504 "rx-decode.opc"
c7927a3c
NC		 4827 ID(sub); SR(rsrc); S2C(IMM(1)); F("OSZC");
4828
4829 }
4830 break;
4831 case 0x60:
4832 {
4833 /** 0111 0101 0110 0000 int #%1 */
4834 if (trace)
4835 {
4836 printf ("\033[33m%s\033[0m %02x %02x\n",
4837 "/** 0111 0101 0110 0000 int #%1 */",
4838 op[0], op[1]);
4839 }
4840 SYNTAX("int #%1");
946ef196 4841#line 957 "rx-decode.opc"
c7927a3c
NC		 4842 ID(int); SC(IMM(1));
4843
4844 }
4845 break;
946ef196
DD		 4846 case 0x70:
4847 GETBYTE ();
4848 switch (op[2] & 0xf0)
4849 {
4850 case 0x00:
4851 {
4852 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
4853#line 924 "rx-decode.opc"
4854 int immm AU = op[2] & 0x0f;
4855 if (trace)
4856 {
4857 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4858 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
4859 op[0], op[1], op[2]);
4860 printf (" immm = 0x%x\n", immm);
4861 }
4862 SYNTAX("mvtipl #%1");
4863#line 924 "rx-decode.opc"
4864 ID(mvtipl); SC(immm);
4865
4866 }
4867 break;
4868 default: UNSUPPORTED(); break;
4869 }
4870 break;
c7927a3c
NC		 4871 default: UNSUPPORTED(); break;
4872 }
4873 break;
4874 case 0x76:
4875 GETBYTE ();
4876 switch (op[1] & 0xf0)
4877 {
4878 case 0x00:
4879 goto op_semantics_31;
4880 break;
4881 case 0x10:
4882 goto op_semantics_32;
4883 break;
4884 case 0x20:
4885 goto op_semantics_33;
4886 break;
4887 case 0x30:
4888 goto op_semantics_34;
4889 break;
4890 default: UNSUPPORTED(); break;
4891 }
4892 break;
4893 case 0x77:
4894 GETBYTE ();
4895 switch (op[1] & 0xf0)
4896 {
4897 case 0x00:
4898 goto op_semantics_31;
4899 break;
4900 case 0x10:
4901 goto op_semantics_32;
4902 break;
4903 case 0x20:
4904 goto op_semantics_33;
4905 break;
4906 case 0x30:
4907 goto op_semantics_34;
4908 break;
4909 default: UNSUPPORTED(); break;
4910 }
4911 break;
4912 case 0x78:
4913 GETBYTE ();
4914 switch (op[1] & 0x00)
4915 {
4916 case 0x00:
4917 op_semantics_35:
4918 {
4919 /** 0111 100b ittt rdst bset #%1, %0 */
f282425e 4920#line 875 "rx-decode.opc"
c7927a3c 4921 int b AU = op[0] & 0x01;
f282425e 4922#line 875 "rx-decode.opc"
c7927a3c 4923 int ittt AU = (op[1] >> 4) & 0x0f;
f282425e 4924#line 875 "rx-decode.opc"
c7927a3c
NC		 4925 int rdst AU = op[1] & 0x0f;
4926 if (trace)
4927 {
4928 printf ("\033[33m%s\033[0m %02x %02x\n",
4929 "/** 0111 100b ittt rdst bset #%1, %0 */",
4930 op[0], op[1]);
4931 printf (" b = 0x%x,", b);
4932 printf (" ittt = 0x%x,", ittt);
4933 printf (" rdst = 0x%x\n", rdst);
4934 }
4935 SYNTAX("bset #%1, %0");
f282425e 4936#line 875 "rx-decode.opc"
c7927a3c
NC		 4937 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4938
4939
4940 }
4941 break;
4942 }
4943 break;
4944 case 0x79:
4945 GETBYTE ();
4946 switch (op[1] & 0x00)
4947 {
4948 case 0x00:
4949 goto op_semantics_35;
4950 break;
4951 }
4952 break;
4953 case 0x7a:
4954 GETBYTE ();
4955 switch (op[1] & 0x00)
4956 {
4957 case 0x00:
4958 op_semantics_36:
4959 {
4960 /** 0111 101b ittt rdst bclr #%1, %0 */
f282425e 4961#line 885 "rx-decode.opc"
c7927a3c 4962 int b AU = op[0] & 0x01;
f282425e 4963#line 885 "rx-decode.opc"
c7927a3c 4964 int ittt AU = (op[1] >> 4) & 0x0f;
f282425e 4965#line 885 "rx-decode.opc"
c7927a3c
NC		 4966 int rdst AU = op[1] & 0x0f;
4967 if (trace)
4968 {
4969 printf ("\033[33m%s\033[0m %02x %02x\n",
4970 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4971 op[0], op[1]);
4972 printf (" b = 0x%x,", b);
4973 printf (" ittt = 0x%x,", ittt);
4974 printf (" rdst = 0x%x\n", rdst);
4975 }
4976 SYNTAX("bclr #%1, %0");
f282425e 4977#line 885 "rx-decode.opc"
c7927a3c
NC		 4978 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4979
4980
4981 }
4982 break;
4983 }
4984 break;
4985 case 0x7b:
4986 GETBYTE ();
4987 switch (op[1] & 0x00)
4988 {
4989 case 0x00:
4990 goto op_semantics_36;
4991 break;
4992 }
4993 break;
4994 case 0x7c:
4995 GETBYTE ();
4996 switch (op[1] & 0x00)
4997 {
4998 case 0x00:
4999 op_semantics_37:
5000 {
5001 /** 0111 110b ittt rdst btst #%2, %1 */
f282425e 5002#line 895 "rx-decode.opc"
c7927a3c 5003 int b AU = op[0] & 0x01;
f282425e 5004#line 895 "rx-decode.opc"
c7927a3c 5005 int ittt AU = (op[1] >> 4) & 0x0f;
f282425e 5006#line 895 "rx-decode.opc"
c7927a3c
NC		 5007 int rdst AU = op[1] & 0x0f;
5008 if (trace)
5009 {
5010 printf ("\033[33m%s\033[0m %02x %02x\n",
5011 "/** 0111 110b ittt rdst btst #%2, %1 */",
5012 op[0], op[1]);
5013 printf (" b = 0x%x,", b);
5014 printf (" ittt = 0x%x,", ittt);
5015 printf (" rdst = 0x%x\n", rdst);
5016 }
5017 SYNTAX("btst #%2, %1");
f282425e 5018#line 895 "rx-decode.opc"
c7927a3c
NC		 5019 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F("--ZC");
5020
5021
5022 }
5023 break;
5024 }
5025 break;
5026 case 0x7d:
5027 GETBYTE ();
5028 switch (op[1] & 0x00)
5029 {
5030 case 0x00:
5031 goto op_semantics_37;
5032 break;
5033 }
5034 break;
5035 case 0x7e:
5036 GETBYTE ();
5037 switch (op[1] & 0xf0)
5038 {
5039 case 0x00:
5040 {
5041 /** 0111 1110 0000 rdst not %0 */
f282425e 5042#line 438 "rx-decode.opc"
c7927a3c
NC		 5043 int rdst AU = op[1] & 0x0f;
5044 if (trace)
5045 {
5046 printf ("\033[33m%s\033[0m %02x %02x\n",
5047 "/** 0111 1110 0000 rdst not %0 */",
5048 op[0], op[1]);
5049 printf (" rdst = 0x%x\n", rdst);
5050 }
5051 SYNTAX("not %0");
f282425e 5052#line 438 "rx-decode.opc"
c7927a3c
NC		 5053 ID(xor); DR(rdst); SR(rdst); S2C(~0); F("-SZ-");
5054
5055 }
5056 break;
5057 case 0x10:
5058 {
5059 /** 0111 1110 0001 rdst neg %0 */
f282425e 5060#line 459 "rx-decode.opc"
c7927a3c
NC		 5061 int rdst AU = op[1] & 0x0f;
5062 if (trace)
5063 {
5064 printf ("\033[33m%s\033[0m %02x %02x\n",
5065 "/** 0111 1110 0001 rdst neg %0 */",
5066 op[0], op[1]);
5067 printf (" rdst = 0x%x\n", rdst);
5068 }
5069 SYNTAX("neg %0");
f282425e 5070#line 459 "rx-decode.opc"
c7927a3c
NC		 5071 ID(sub); DR(rdst); SC(0); S2R(rdst); F("OSZC");
5072
5073 }
5074 break;
5075 case 0x20:
5076 {
5077 /** 0111 1110 0010 rdst abs %0 */
f282425e 5078#line 541 "rx-decode.opc"
c7927a3c
NC		 5079 int rdst AU = op[1] & 0x0f;
5080 if (trace)
5081 {
5082 printf ("\033[33m%s\033[0m %02x %02x\n",
5083 "/** 0111 1110 0010 rdst abs %0 */",
5084 op[0], op[1]);
5085 printf (" rdst = 0x%x\n", rdst);
5086 }
5087 SYNTAX("abs %0");
f282425e 5088#line 541 "rx-decode.opc"
c7927a3c
NC		 5089 ID(abs); DR(rdst); SR(rdst); F("OSZ-");
5090
5091 }
5092 break;
5093 case 0x30:
5094 {
5095 /** 0111 1110 0011 rdst sat %0 */
f282425e 5096#line 815 "rx-decode.opc"
c7927a3c
NC		 5097 int rdst AU = op[1] & 0x0f;
5098 if (trace)
5099 {
5100 printf ("\033[33m%s\033[0m %02x %02x\n",
5101 "/** 0111 1110 0011 rdst sat %0 */",
5102 op[0], op[1]);
5103 printf (" rdst = 0x%x\n", rdst);
5104 }
5105 SYNTAX("sat %0");
f282425e 5106#line 815 "rx-decode.opc"
c7927a3c
NC		 5107 ID(sat); DR (rdst);
5108
5109 }
5110 break;
5111 case 0x40:
5112 {
5113 /** 0111 1110 0100 rdst rorc %0 */
f282425e 5114#line 675 "rx-decode.opc"
c7927a3c
NC		 5115 int rdst AU = op[1] & 0x0f;
5116 if (trace)
5117 {
5118 printf ("\033[33m%s\033[0m %02x %02x\n",
5119 "/** 0111 1110 0100 rdst rorc %0 */",
5120 op[0], op[1]);
5121 printf (" rdst = 0x%x\n", rdst);
5122 }
5123 SYNTAX("rorc %0");
f282425e 5124#line 675 "rx-decode.opc"
c7927a3c
NC		 5125 ID(rorc); DR(rdst); F("-SZC");
5126
5127 }
5128 break;
5129 case 0x50:
5130 {
5131 /** 0111 1110 0101 rdst rolc %0 */
f282425e 5132#line 672 "rx-decode.opc"
c7927a3c
NC		 5133 int rdst AU = op[1] & 0x0f;
5134 if (trace)
5135 {
5136 printf ("\033[33m%s\033[0m %02x %02x\n",
5137 "/** 0111 1110 0101 rdst rolc %0 */",
5138 op[0], op[1]);
5139 printf (" rdst = 0x%x\n", rdst);
5140 }
5141 SYNTAX("rolc %0");
f282425e 5142#line 672 "rx-decode.opc"
c7927a3c
NC		 5143 ID(rolc); DR(rdst); F("-SZC");
5144
5145 }
5146 break;
5147 case 0x80:
5148 case 0x90:
5149 case 0xa0:
5150 {
5151 /** 0111 1110 10sz rsrc push%s %1 */
f282425e 5152#line 354 "rx-decode.opc"
c7927a3c 5153 int sz AU = (op[1] >> 4) & 0x03;
f282425e 5154#line 354 "rx-decode.opc"
c7927a3c
NC		 5155 int rsrc AU = op[1] & 0x0f;
5156 if (trace)
5157 {
5158 printf ("\033[33m%s\033[0m %02x %02x\n",
5159 "/** 0111 1110 10sz rsrc push%s %1 */",
5160 op[0], op[1]);
5161 printf (" sz = 0x%x,", sz);
5162 printf (" rsrc = 0x%x\n", rsrc);
5163 }
5164 SYNTAX("push%s %1");
f282425e 5165#line 354 "rx-decode.opc"
c7927a3c
NC		 5166 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F("----");
5167
5168 }
5169 break;
5170 case 0xb0:
5171 {
5172 /** 0111 1110 1011 rdst pop %0 */
f282425e 5173#line 351 "rx-decode.opc"
c7927a3c
NC		 5174 int rdst AU = op[1] & 0x0f;
5175 if (trace)
5176 {
5177 printf ("\033[33m%s\033[0m %02x %02x\n",
5178 "/** 0111 1110 1011 rdst pop %0 */",
5179 op[0], op[1]);
5180 printf (" rdst = 0x%x\n", rdst);
5181 }
5182 SYNTAX("pop %0");
f282425e 5183#line 351 "rx-decode.opc"
c7927a3c
NC		 5184 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F("----");
5185
5186 }
5187 break;
5188 case 0xc0:
5189 case 0xd0:
5190 {
5191 /** 0111 1110 110 crsrc pushc %1 */
946ef196 5192#line 930 "rx-decode.opc"
c7927a3c
NC		 5193 int crsrc AU = op[1] & 0x1f;
5194 if (trace)
5195 {
5196 printf ("\033[33m%s\033[0m %02x %02x\n",
5197 "/** 0111 1110 110 crsrc pushc %1 */",
5198 op[0], op[1]);
5199 printf (" crsrc = 0x%x\n", crsrc);
5200 }
5201 SYNTAX("pushc %1");
946ef196 5202#line 930 "rx-decode.opc"
c7927a3c
NC		 5203 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5204
5205 }
5206 break;
5207 case 0xe0:
5208 case 0xf0:
5209 {
5210 /** 0111 1110 111 crdst popc %0 */
946ef196 5211#line 927 "rx-decode.opc"
c7927a3c
NC		 5212 int crdst AU = op[1] & 0x1f;
5213 if (trace)
5214 {
5215 printf ("\033[33m%s\033[0m %02x %02x\n",
5216 "/** 0111 1110 111 crdst popc %0 */",
5217 op[0], op[1]);
5218 printf (" crdst = 0x%x\n", crdst);
5219 }
5220 SYNTAX("popc %0");
946ef196 5221#line 927 "rx-decode.opc"
c7927a3c
NC		 5222 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5223
5224 }
5225 break;
5226 default: UNSUPPORTED(); break;
5227 }
5228 break;
5229 case 0x7f:
5230 GETBYTE ();
5231 switch (op[1] & 0xff)
5232 {
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 {
5250 /** 0111 1111 0000 rsrc jmp %0 */
f282425e 5251#line 725 "rx-decode.opc"
c7927a3c
NC		 5252 int rsrc AU = op[1] & 0x0f;
5253 if (trace)
5254 {
5255 printf ("\033[33m%s\033[0m %02x %02x\n",
5256 "/** 0111 1111 0000 rsrc jmp %0 */",
5257 op[0], op[1]);
5258 printf (" rsrc = 0x%x\n", rsrc);
5259 }
5260 SYNTAX("jmp %0");
f282425e 5261#line 725 "rx-decode.opc"
c7927a3c
NC		 5262 ID(branch); Scc(RXC_always); DR(rsrc);
5263
5264 }
5265 break;
5266 case 0x10:
5267 case 0x11:
5268 case 0x12:
5269 case 0x13:
5270 case 0x14:
5271 case 0x15:
5272 case 0x16:
5273 case 0x17:
5274 case 0x18:
5275 case 0x19:
5276 case 0x1a:
5277 case 0x1b:
5278 case 0x1c:
5279 case 0x1d:
5280 case 0x1e:
5281 case 0x1f:
5282 {
5283 /** 0111 1111 0001 rsrc jsr %0 */
f282425e 5284#line 728 "rx-decode.opc"
c7927a3c
NC		 5285 int rsrc AU = op[1] & 0x0f;
5286 if (trace)
5287 {
5288 printf ("\033[33m%s\033[0m %02x %02x\n",
5289 "/** 0111 1111 0001 rsrc jsr %0 */",
5290 op[0], op[1]);
5291 printf (" rsrc = 0x%x\n", rsrc);
5292 }
5293 SYNTAX("jsr %0");
f282425e 5294#line 728 "rx-decode.opc"
c7927a3c
NC		 5295 ID(jsr); DR(rsrc);
5296
5297 }
5298 break;
5299 case 0x40:
5300 case 0x41:
5301 case 0x42:
5302 case 0x43:
5303 case 0x44:
5304 case 0x45:
5305 case 0x46:
5306 case 0x47:
5307 case 0x48:
5308 case 0x49:
5309 case 0x4a:
5310 case 0x4b:
5311 case 0x4c:
5312 case 0x4d:
5313 case 0x4e:
5314 case 0x4f:
5315 {
5316 /** 0111 1111 0100 rsrc bra.l %0 */
f282425e 5317#line 721 "rx-decode.opc"
c7927a3c
NC		 5318 int rsrc AU = op[1] & 0x0f;
5319 if (trace)
5320 {
5321 printf ("\033[33m%s\033[0m %02x %02x\n",
5322 "/** 0111 1111 0100 rsrc bra.l %0 */",
5323 op[0], op[1]);
5324 printf (" rsrc = 0x%x\n", rsrc);
5325 }
5326 SYNTAX("bra.l %0");
f282425e 5327#line 721 "rx-decode.opc"
c7927a3c
NC		 5328 ID(branchrel); Scc(RXC_always); DR(rsrc);
5329
5330
5331 }
5332 break;
5333 case 0x50:
5334 case 0x51:
5335 case 0x52:
5336 case 0x53:
5337 case 0x54:
5338 case 0x55:
5339 case 0x56:
5340 case 0x57:
5341 case 0x58:
5342 case 0x59:
5343 case 0x5a:
5344 case 0x5b:
5345 case 0x5c:
5346 case 0x5d:
5347 case 0x5e:
5348 case 0x5f:
5349 {
5350 /** 0111 1111 0101 rsrc bsr.l %0 */
f282425e 5351#line 737 "rx-decode.opc"
c7927a3c
NC		 5352 int rsrc AU = op[1] & 0x0f;
5353 if (trace)
5354 {
5355 printf ("\033[33m%s\033[0m %02x %02x\n",
5356 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5357 op[0], op[1]);
5358 printf (" rsrc = 0x%x\n", rsrc);
5359 }
5360 SYNTAX("bsr.l %0");
f282425e 5361#line 737 "rx-decode.opc"
c7927a3c
NC		 5362 ID(jsrrel); DR(rsrc);
5363
5364 }
5365 break;
5366 case 0x80:
5367 case 0x81:
5368 case 0x82:
5369 {
5370 /** 0111 1111 1000 00sz suntil%s */
f282425e 5371#line 761 "rx-decode.opc"
c7927a3c
NC		 5372 int sz AU = op[1] & 0x03;
5373 if (trace)
5374 {
5375 printf ("\033[33m%s\033[0m %02x %02x\n",
5376 "/** 0111 1111 1000 00sz suntil%s */",
5377 op[0], op[1]);
5378 printf (" sz = 0x%x\n", sz);
5379 }
5380 SYNTAX("suntil%s");
f282425e
DD		 5381#line 761 "rx-decode.opc"
5382 ID(suntil); BWL(sz); F("--ZC");
c7927a3c
NC		 5383
5384 }
5385 break;
5386 case 0x83:
5387 {
5388 /** 0111 1111 1000 0011 scmpu */
5389 if (trace)
5390 {
5391 printf ("\033[33m%s\033[0m %02x %02x\n",
5392 "/** 0111 1111 1000 0011 scmpu */",
5393 op[0], op[1]);
5394 }
5395 SYNTAX("scmpu");
f282425e 5396#line 752 "rx-decode.opc"
c7927a3c
NC		 5397 ID(scmpu); F("--ZC");
5398
5399 }
5400 break;
5401 case 0x84:
5402 case 0x85:
5403 case 0x86:
5404 {
5405 /** 0111 1111 1000 01sz swhile%s */
f282425e 5406#line 764 "rx-decode.opc"
c7927a3c
NC		 5407 int sz AU = op[1] & 0x03;
5408 if (trace)
5409 {
5410 printf ("\033[33m%s\033[0m %02x %02x\n",
5411 "/** 0111 1111 1000 01sz swhile%s */",
5412 op[0], op[1]);
5413 printf (" sz = 0x%x\n", sz);
5414 }
5415 SYNTAX("swhile%s");
f282425e
DD		 5416#line 764 "rx-decode.opc"
5417 ID(swhile); BWL(sz); F("--ZC");
c7927a3c
NC		 5418
5419 }
5420 break;
5421 case 0x87:
5422 {
5423 /** 0111 1111 1000 0111 smovu */
5424 if (trace)
5425 {
5426 printf ("\033[33m%s\033[0m %02x %02x\n",
5427 "/** 0111 1111 1000 0111 smovu */",
5428 op[0], op[1]);
5429 }
5430 SYNTAX("smovu");
f282425e 5431#line 755 "rx-decode.opc"
c7927a3c
NC		 5432 ID(smovu);
5433
5434 }
5435 break;
5436 case 0x88:
5437 case 0x89:
5438 case 0x8a:
5439 {
5440 /** 0111 1111 1000 10sz sstr%s */
f282425e 5441#line 770 "rx-decode.opc"
c7927a3c
NC		 5442 int sz AU = op[1] & 0x03;
5443 if (trace)
5444 {
5445 printf ("\033[33m%s\033[0m %02x %02x\n",
5446 "/** 0111 1111 1000 10sz sstr%s */",
5447 op[0], op[1]);
5448 printf (" sz = 0x%x\n", sz);
5449 }
5450 SYNTAX("sstr%s");
f282425e 5451#line 770 "rx-decode.opc"
c7927a3c
NC		 5452 ID(sstr); BWL(sz);
5453
5454 /*----------------------------------------------------------------------*/
5455 /* RMPA */
5456
5457 }
5458 break;
5459 case 0x8b:
5460 {
5461 /** 0111 1111 1000 1011 smovb */
5462 if (trace)
5463 {
5464 printf ("\033[33m%s\033[0m %02x %02x\n",
5465 "/** 0111 1111 1000 1011 smovb */",
5466 op[0], op[1]);
5467 }
5468 SYNTAX("smovb");
f282425e 5469#line 758 "rx-decode.opc"
c7927a3c
NC		 5470 ID(smovb);
5471
5472 }
5473 break;
5474 case 0x8c:
5475 case 0x8d:
5476 case 0x8e:
5477 {
5478 /** 0111 1111 1000 11sz rmpa%s */
f282425e 5479#line 776 "rx-decode.opc"
c7927a3c
NC		 5480 int sz AU = op[1] & 0x03;
5481 if (trace)
5482 {
5483 printf ("\033[33m%s\033[0m %02x %02x\n",
5484 "/** 0111 1111 1000 11sz rmpa%s */",
5485 op[0], op[1]);
5486 printf (" sz = 0x%x\n", sz);
5487 }
5488 SYNTAX("rmpa%s");
f282425e 5489#line 776 "rx-decode.opc"
c7927a3c
NC		 5490 ID(rmpa); BWL(sz); F("OS--");
5491
5492 /*----------------------------------------------------------------------*/
5493 /* HI/LO stuff */
5494
5495 }
5496 break;
5497 case 0x8f:
5498 {
5499 /** 0111 1111 1000 1111 smovf */
5500 if (trace)
5501 {
5502 printf ("\033[33m%s\033[0m %02x %02x\n",
5503 "/** 0111 1111 1000 1111 smovf */",
5504 op[0], op[1]);
5505 }
5506 SYNTAX("smovf");
f282425e 5507#line 767 "rx-decode.opc"
c7927a3c
NC		 5508 ID(smovf);
5509
5510 }
5511 break;
5512 case 0x93:
5513 {
5514 /** 0111 1111 1001 0011 satr */
5515 if (trace)
5516 {
5517 printf ("\033[33m%s\033[0m %02x %02x\n",
5518 "/** 0111 1111 1001 0011 satr */",
5519 op[0], op[1]);
5520 }
5521 SYNTAX("satr");
f282425e 5522#line 818 "rx-decode.opc"
c7927a3c
NC		 5523 ID(satr);
5524
5525 /*----------------------------------------------------------------------*/
5526 /* FLOAT */
5527
5528 }
5529 break;
5530 case 0x94:
5531 {
5532 /** 0111 1111 1001 0100 rtfi */
5533 if (trace)
5534 {
5535 printf ("\033[33m%s\033[0m %02x %02x\n",
5536 "/** 0111 1111 1001 0100 rtfi */",
5537 op[0], op[1]);
5538 }
5539 SYNTAX("rtfi");
946ef196 5540#line 945 "rx-decode.opc"
c7927a3c
NC		 5541 ID(rtfi);
5542
5543 }
5544 break;
5545 case 0x95:
5546 {
5547 /** 0111 1111 1001 0101 rte */
5548 if (trace)
5549 {
5550 printf ("\033[33m%s\033[0m %02x %02x\n",
5551 "/** 0111 1111 1001 0101 rte */",
5552 op[0], op[1]);
5553 }
5554 SYNTAX("rte");
946ef196 5555#line 948 "rx-decode.opc"
c7927a3c
NC		 5556 ID(rte);
5557
5558 }
5559 break;
5560 case 0x96:
5561 {
5562 /** 0111 1111 1001 0110 wait */
5563 if (trace)
5564 {
5565 printf ("\033[33m%s\033[0m %02x %02x\n",
5566 "/** 0111 1111 1001 0110 wait */",
5567 op[0], op[1]);
5568 }
5569 SYNTAX("wait");
946ef196 5570#line 960 "rx-decode.opc"
c7927a3c
NC		 5571 ID(wait);
5572
5573 /*----------------------------------------------------------------------*/
5574 /* SCcnd */
5575
5576 }
5577 break;
5578 case 0xa0:
5579 case 0xa1:
5580 case 0xa2:
5581 case 0xa3:
5582 case 0xa4:
5583 case 0xa5:
5584 case 0xa6:
5585 case 0xa7:
5586 case 0xa8:
5587 case 0xa9:
5588 case 0xaa:
5589 case 0xab:
5590 case 0xac:
5591 case 0xad:
5592 case 0xae:
5593 case 0xaf:
5594 {
5595 /** 0111 1111 1010 rdst setpsw %0 */
f282425e 5596#line 921 "rx-decode.opc"
c7927a3c
NC		 5597 int rdst AU = op[1] & 0x0f;
5598 if (trace)
5599 {
5600 printf ("\033[33m%s\033[0m %02x %02x\n",
5601 "/** 0111 1111 1010 rdst setpsw %0 */",
5602 op[0], op[1]);
5603 printf (" rdst = 0x%x\n", rdst);
5604 }
5605 SYNTAX("setpsw %0");
f282425e 5606#line 921 "rx-decode.opc"
c7927a3c
NC		 5607 ID(setpsw); DF(rdst);
5608
5609 }
5610 break;
5611 case 0xb0:
5612 case 0xb1:
5613 case 0xb2:
5614 case 0xb3:
5615 case 0xb4:
5616 case 0xb5:
5617 case 0xb6:
5618 case 0xb7:
5619 case 0xb8:
5620 case 0xb9:
5621 case 0xba:
5622 case 0xbb:
5623 case 0xbc:
5624 case 0xbd:
5625 case 0xbe:
5626 case 0xbf:
5627 {
5628 /** 0111 1111 1011 rdst clrpsw %0 */
f282425e 5629#line 918 "rx-decode.opc"
c7927a3c
NC		 5630 int rdst AU = op[1] & 0x0f;
5631 if (trace)
5632 {
5633 printf ("\033[33m%s\033[0m %02x %02x\n",
5634 "/** 0111 1111 1011 rdst clrpsw %0 */",
5635 op[0], op[1]);
5636 printf (" rdst = 0x%x\n", rdst);
5637 }
5638 SYNTAX("clrpsw %0");
f282425e 5639#line 918 "rx-decode.opc"
c7927a3c
NC		 5640 ID(clrpsw); DF(rdst);
5641
5642 }
5643 break;
5644 default: UNSUPPORTED(); break;
5645 }
5646 break;
5647 case 0x80:
5648 GETBYTE ();
5649 switch (op[1] & 0x00)
5650 {
5651 case 0x00:
5652 op_semantics_38:
5653 {
5654 /** 10sz 0dsp a dst b src mov%s %1, %0 */
f282425e 5655#line 312 "rx-decode.opc"
c7927a3c 5656 int sz AU = (op[0] >> 4) & 0x03;
f282425e 5657#line 312 "rx-decode.opc"
c7927a3c 5658 int dsp AU = op[0] & 0x07;
f282425e 5659#line 312 "rx-decode.opc"
c7927a3c 5660 int a AU = (op[1] >> 7) & 0x01;
f282425e 5661#line 312 "rx-decode.opc"
c7927a3c 5662 int dst AU = (op[1] >> 4) & 0x07;
f282425e 5663#line 312 "rx-decode.opc"
c7927a3c 5664 int b AU = (op[1] >> 3) & 0x01;
f282425e 5665#line 312 "rx-decode.opc"
c7927a3c
NC		 5666 int src AU = op[1] & 0x07;
5667 if (trace)
5668 {
5669 printf ("\033[33m%s\033[0m %02x %02x\n",
5670 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5671 op[0], op[1]);
5672 printf (" sz = 0x%x,", sz);
5673 printf (" dsp = 0x%x,", dsp);
5674 printf (" a = 0x%x,", a);
5675 printf (" dst = 0x%x,", dst);
5676 printf (" b = 0x%x,", b);
5677 printf (" src = 0x%x\n", src);
5678 }
5679 SYNTAX("mov%s %1, %0");
f282425e 5680#line 312 "rx-decode.opc"
c7927a3c
NC		 5681 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F("----");
5682
5683 }
5684 break;
5685 }
5686 break;
5687 case 0x81:
5688 GETBYTE ();
5689 switch (op[1] & 0x00)
5690 {
5691 case 0x00:
5692 goto op_semantics_38;
5693 break;
5694 }
5695 break;
5696 case 0x82:
5697 GETBYTE ();
5698 switch (op[1] & 0x00)
5699 {
5700 case 0x00:
5701 goto op_semantics_38;
5702 break;
5703 }
5704 break;
5705 case 0x83:
5706 GETBYTE ();
5707 switch (op[1] & 0x00)
5708 {
5709 case 0x00:
5710 goto op_semantics_38;
5711 break;
5712 }
5713 break;
5714 case 0x84:
5715 GETBYTE ();
5716 switch (op[1] & 0x00)
5717 {
5718 case 0x00:
5719 goto op_semantics_38;
5720 break;
5721 }
5722 break;
5723 case 0x85:
5724 GETBYTE ();
5725 switch (op[1] & 0x00)
5726 {
5727 case 0x00:
5728 goto op_semantics_38;
5729 break;
5730 }
5731 break;
5732 case 0x86:
5733 GETBYTE ();
5734 switch (op[1] & 0x00)
5735 {
5736 case 0x00:
5737 goto op_semantics_38;
5738 break;
5739 }
5740 break;
5741 case 0x87:
5742 GETBYTE ();
5743 switch (op[1] & 0x00)
5744 {
5745 case 0x00:
5746 goto op_semantics_38;
5747 break;
5748 }
5749 break;
5750 case 0x88:
5751 GETBYTE ();
5752 switch (op[1] & 0x00)
5753 {
5754 case 0x00:
5755 op_semantics_39:
5756 {
5757 /** 10sz 1dsp a src b dst mov%s %1, %0 */
f282425e 5758#line 309 "rx-decode.opc"
c7927a3c 5759 int sz AU = (op[0] >> 4) & 0x03;
f282425e 5760#line 309 "rx-decode.opc"
c7927a3c 5761 int dsp AU = op[0] & 0x07;
f282425e 5762#line 309 "rx-decode.opc"
c7927a3c 5763 int a AU = (op[1] >> 7) & 0x01;
f282425e 5764#line 309 "rx-decode.opc"
c7927a3c 5765 int src AU = (op[1] >> 4) & 0x07;
f282425e 5766#line 309 "rx-decode.opc"
c7927a3c 5767 int b AU = (op[1] >> 3) & 0x01;
f282425e 5768#line 309 "rx-decode.opc"
c7927a3c
NC		 5769 int dst AU = op[1] & 0x07;
5770 if (trace)
5771 {
5772 printf ("\033[33m%s\033[0m %02x %02x\n",
5773 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5774 op[0], op[1]);
5775 printf (" sz = 0x%x,", sz);
5776 printf (" dsp = 0x%x,", dsp);
5777 printf (" a = 0x%x,", a);
5778 printf (" src = 0x%x,", src);
5779 printf (" b = 0x%x,", b);
5780 printf (" dst = 0x%x\n", dst);
5781 }
5782 SYNTAX("mov%s %1, %0");
f282425e 5783#line 309 "rx-decode.opc"
c7927a3c
NC		 5784 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F("----");
5785
5786 }
5787 break;
5788 }
5789 break;
5790 case 0x89:
5791 GETBYTE ();
5792 switch (op[1] & 0x00)
5793 {
5794 case 0x00:
5795 goto op_semantics_39;
5796 break;
5797 }
5798 break;
5799 case 0x8a:
5800 GETBYTE ();
5801 switch (op[1] & 0x00)
5802 {
5803 case 0x00:
5804 goto op_semantics_39;
5805 break;
5806 }
5807 break;
5808 case 0x8b:
5809 GETBYTE ();
5810 switch (op[1] & 0x00)
5811 {
5812 case 0x00:
5813 goto op_semantics_39;
5814 break;
5815 }
5816 break;
5817 case 0x8c:
5818 GETBYTE ();
5819 switch (op[1] & 0x00)
5820 {
5821 case 0x00:
5822 goto op_semantics_39;
5823 break;
5824 }
5825 break;
5826 case 0x8d:
5827 GETBYTE ();
5828 switch (op[1] & 0x00)
5829 {
5830 case 0x00:
5831 goto op_semantics_39;
5832 break;
5833 }
5834 break;
5835 case 0x8e:
5836 GETBYTE ();
5837 switch (op[1] & 0x00)
5838 {
5839 case 0x00:
5840 goto op_semantics_39;
5841 break;
5842 }
5843 break;
5844 case 0x8f:
5845 GETBYTE ();
5846 switch (op[1] & 0x00)
5847 {
5848 case 0x00:
5849 goto op_semantics_39;
5850 break;
5851 }
5852 break;
5853 case 0x90:
5854 GETBYTE ();
5855 switch (op[1] & 0x00)
5856 {
5857 case 0x00:
5858 goto op_semantics_38;
5859 break;
5860 }
5861 break;
5862 case 0x91:
5863 GETBYTE ();
5864 switch (op[1] & 0x00)
5865 {
5866 case 0x00:
5867 goto op_semantics_38;
5868 break;
5869 }
5870 break;
5871 case 0x92:
5872 GETBYTE ();
5873 switch (op[1] & 0x00)
5874 {
5875 case 0x00:
5876 goto op_semantics_38;
5877 break;
5878 }
5879 break;
5880 case 0x93:
5881 GETBYTE ();
5882 switch (op[1] & 0x00)
5883 {
5884 case 0x00:
5885 goto op_semantics_38;
5886 break;
5887 }
5888 break;
5889 case 0x94:
5890 GETBYTE ();
5891 switch (op[1] & 0x00)
5892 {
5893 case 0x00:
5894 goto op_semantics_38;
5895 break;
5896 }
5897 break;
5898 case 0x95:
5899 GETBYTE ();
5900 switch (op[1] & 0x00)
5901 {
5902 case 0x00:
5903 goto op_semantics_38;
5904 break;
5905 }
5906 break;
5907 case 0x96:
5908 GETBYTE ();
5909 switch (op[1] & 0x00)
5910 {
5911 case 0x00:
5912 goto op_semantics_38;
5913 break;
5914 }
5915 break;
5916 case 0x97:
5917 GETBYTE ();
5918 switch (op[1] & 0x00)
5919 {
5920 case 0x00:
5921 goto op_semantics_38;
5922 break;
5923 }
5924 break;
5925 case 0x98:
5926 GETBYTE ();
5927 switch (op[1] & 0x00)
5928 {
5929 case 0x00:
5930 goto op_semantics_39;
5931 break;
5932 }
5933 break;
5934 case 0x99:
5935 GETBYTE ();
5936 switch (op[1] & 0x00)
5937 {
5938 case 0x00:
5939 goto op_semantics_39;
5940 break;
5941 }
5942 break;
5943 case 0x9a:
5944 GETBYTE ();
5945 switch (op[1] & 0x00)
5946 {
5947 case 0x00:
5948 goto op_semantics_39;
5949 break;
5950 }
5951 break;
5952 case 0x9b:
5953 GETBYTE ();
5954 switch (op[1] & 0x00)
5955 {
5956 case 0x00:
5957 goto op_semantics_39;
5958 break;
5959 }
5960 break;
5961 case 0x9c:
5962 GETBYTE ();
5963 switch (op[1] & 0x00)
5964 {
5965 case 0x00:
5966 goto op_semantics_39;
5967 break;
5968 }
5969 break;
5970 case 0x9d:
5971 GETBYTE ();
5972 switch (op[1] & 0x00)
5973 {
5974 case 0x00:
5975 goto op_semantics_39;
5976 break;
5977 }
5978 break;
5979 case 0x9e:
5980 GETBYTE ();
5981 switch (op[1] & 0x00)
5982 {
5983 case 0x00:
5984 goto op_semantics_39;
5985 break;
5986 }
5987 break;
5988 case 0x9f:
5989 GETBYTE ();
5990 switch (op[1] & 0x00)
5991 {
5992 case 0x00:
5993 goto op_semantics_39;
5994 break;
5995 }
5996 break;
5997 case 0xa0:
5998 GETBYTE ();
5999 switch (op[1] & 0x00)
6000 {
6001 case 0x00:
6002 goto op_semantics_38;
6003 break;
6004 }
6005 break;
6006 case 0xa1:
6007 GETBYTE ();
6008 switch (op[1] & 0x00)
6009 {
6010 case 0x00:
6011 goto op_semantics_38;
6012 break;
6013 }
6014 break;
6015 case 0xa2:
6016 GETBYTE ();
6017 switch (op[1] & 0x00)
6018 {
6019 case 0x00:
6020 goto op_semantics_38;
6021 break;
6022 }
6023 break;
6024 case 0xa3:
6025 GETBYTE ();
6026 switch (op[1] & 0x00)
6027 {
6028 case 0x00:
6029 goto op_semantics_38;
6030 break;
6031 }
6032 break;
6033 case 0xa4:
6034 GETBYTE ();
6035 switch (op[1] & 0x00)
6036 {
6037 case 0x00:
6038 goto op_semantics_38;
6039 break;
6040 }
6041 break;
6042 case 0xa5:
6043 GETBYTE ();
6044 switch (op[1] & 0x00)
6045 {
6046 case 0x00:
6047 goto op_semantics_38;
6048 break;
6049 }
6050 break;
6051 case 0xa6:
6052 GETBYTE ();
6053 switch (op[1] & 0x00)
6054 {
6055 case 0x00:
6056 goto op_semantics_38;
6057 break;
6058 }
6059 break;
6060 case 0xa7:
6061 GETBYTE ();
6062 switch (op[1] & 0x00)
6063 {
6064 case 0x00:
6065 goto op_semantics_38;
6066 break;
6067 }
6068 break;
6069 case 0xa8:
6070 GETBYTE ();
6071 switch (op[1] & 0x00)
6072 {
6073 case 0x00:
6074 goto op_semantics_39;
6075 break;
6076 }
6077 break;
6078 case 0xa9:
6079 GETBYTE ();
6080 switch (op[1] & 0x00)
6081 {
6082 case 0x00:
6083 goto op_semantics_39;
6084 break;
6085 }
6086 break;
6087 case 0xaa:
6088 GETBYTE ();
6089 switch (op[1] & 0x00)
6090 {
6091 case 0x00:
6092 goto op_semantics_39;
6093 break;
6094 }
6095 break;
6096 case 0xab:
6097 GETBYTE ();
6098 switch (op[1] & 0x00)
6099 {
6100 case 0x00:
6101 goto op_semantics_39;
6102 break;
6103 }
6104 break;
6105 case 0xac:
6106 GETBYTE ();
6107 switch (op[1] & 0x00)
6108 {
6109 case 0x00:
6110 goto op_semantics_39;
6111 break;
6112 }
6113 break;
6114 case 0xad:
6115 GETBYTE ();
6116 switch (op[1] & 0x00)
6117 {
6118 case 0x00:
6119 goto op_semantics_39;
6120 break;
6121 }
6122 break;
6123 case 0xae:
6124 GETBYTE ();
6125 switch (op[1] & 0x00)
6126 {
6127 case 0x00:
6128 goto op_semantics_39;
6129 break;
6130 }
6131 break;
6132 case 0xaf:
6133 GETBYTE ();
6134 switch (op[1] & 0x00)
6135 {
6136 case 0x00:
6137 goto op_semantics_39;
6138 break;
6139 }
6140 break;
6141 case 0xb0:
6142 GETBYTE ();
6143 switch (op[1] & 0x00)
6144 {
6145 case 0x00:
6146 op_semantics_40:
6147 {
6148 /** 1011 w dsp a src b dst movu%s %1, %0 */
f282425e 6149#line 332 "rx-decode.opc"
c7927a3c 6150 int w AU = (op[0] >> 3) & 0x01;
f282425e 6151#line 332 "rx-decode.opc"
c7927a3c 6152 int dsp AU = op[0] & 0x07;
f282425e 6153#line 332 "rx-decode.opc"
c7927a3c 6154 int a AU = (op[1] >> 7) & 0x01;
f282425e 6155#line 332 "rx-decode.opc"
c7927a3c 6156 int src AU = (op[1] >> 4) & 0x07;
f282425e 6157#line 332 "rx-decode.opc"
c7927a3c 6158 int b AU = (op[1] >> 3) & 0x01;
f282425e 6159#line 332 "rx-decode.opc"
c7927a3c
NC		 6160 int dst AU = op[1] & 0x07;
6161 if (trace)
6162 {
6163 printf ("\033[33m%s\033[0m %02x %02x\n",
6164 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6165 op[0], op[1]);
6166 printf (" w = 0x%x,", w);
6167 printf (" dsp = 0x%x,", dsp);
6168 printf (" a = 0x%x,", a);
6169 printf (" src = 0x%x,", src);
6170 printf (" b = 0x%x,", b);
6171 printf (" dst = 0x%x\n", dst);
6172 }
6173 SYNTAX("movu%s %1, %0");
f282425e 6174#line 332 "rx-decode.opc"
c7927a3c
NC		 6175 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F("----");
6176
6177 }
6178 break;
6179 }
6180 break;
6181 case 0xb1:
6182 GETBYTE ();
6183 switch (op[1] & 0x00)
6184 {
6185 case 0x00:
6186 goto op_semantics_40;
6187 break;
6188 }
6189 break;
6190 case 0xb2:
6191 GETBYTE ();
6192 switch (op[1] & 0x00)
6193 {
6194 case 0x00:
6195 goto op_semantics_40;
6196 break;
6197 }
6198 break;
6199 case 0xb3:
6200 GETBYTE ();
6201 switch (op[1] & 0x00)
6202 {
6203 case 0x00:
6204 goto op_semantics_40;
6205 break;
6206 }
6207 break;
6208 case 0xb4:
6209 GETBYTE ();
6210 switch (op[1] & 0x00)
6211 {
6212 case 0x00:
6213 goto op_semantics_40;
6214 break;
6215 }
6216 break;
6217 case 0xb5:
6218 GETBYTE ();
6219 switch (op[1] & 0x00)
6220 {
6221 case 0x00:
6222 goto op_semantics_40;
6223 break;
6224 }
6225 break;
6226 case 0xb6:
6227 GETBYTE ();
6228 switch (op[1] & 0x00)
6229 {
6230 case 0x00:
6231 goto op_semantics_40;
6232 break;
6233 }
6234 break;
6235 case 0xb7:
6236 GETBYTE ();
6237 switch (op[1] & 0x00)
6238 {
6239 case 0x00:
6240 goto op_semantics_40;
6241 break;
6242 }
6243 break;
6244 case 0xb8:
6245 GETBYTE ();
6246 switch (op[1] & 0x00)
6247 {
6248 case 0x00:
6249 goto op_semantics_40;
6250 break;
6251 }
6252 break;
6253 case 0xb9:
6254 GETBYTE ();
6255 switch (op[1] & 0x00)
6256 {
6257 case 0x00:
6258 goto op_semantics_40;
6259 break;
6260 }
6261 break;
6262 case 0xba:
6263 GETBYTE ();
6264 switch (op[1] & 0x00)
6265 {
6266 case 0x00:
6267 goto op_semantics_40;
6268 break;
6269 }
6270 break;
6271 case 0xbb:
6272 GETBYTE ();
6273 switch (op[1] & 0x00)
6274 {
6275 case 0x00:
6276 goto op_semantics_40;
6277 break;
6278 }
6279 break;
6280 case 0xbc:
6281 GETBYTE ();
6282 switch (op[1] & 0x00)
6283 {
6284 case 0x00:
6285 goto op_semantics_40;
6286 break;
6287 }
6288 break;
6289 case 0xbd:
6290 GETBYTE ();
6291 switch (op[1] & 0x00)
6292 {
6293 case 0x00:
6294 goto op_semantics_40;
6295 break;
6296 }
6297 break;
6298 case 0xbe:
6299 GETBYTE ();
6300 switch (op[1] & 0x00)
6301 {
6302 case 0x00:
6303 goto op_semantics_40;
6304 break;
6305 }
6306 break;
6307 case 0xbf:
6308 GETBYTE ();
6309 switch (op[1] & 0x00)
6310 {
6311 case 0x00:
6312 goto op_semantics_40;
6313 break;
6314 }
6315 break;
6316 case 0xc0:
6317 GETBYTE ();
6318 switch (op[1] & 0x00)
6319 {
6320 case 0x00:
6321 op_semantics_41:
6322 {
6323 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
f282425e 6324#line 298 "rx-decode.opc"
c7927a3c 6325 int sz AU = (op[0] >> 4) & 0x03;
f282425e 6326#line 298 "rx-decode.opc"
c7927a3c 6327 int sd AU = (op[0] >> 2) & 0x03;
f282425e 6328#line 298 "rx-decode.opc"
c7927a3c 6329 int ss AU = op[0] & 0x03;
f282425e 6330#line 298 "rx-decode.opc"
c7927a3c 6331 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 6332#line 298 "rx-decode.opc"
c7927a3c
NC		 6333 int rdst AU = op[1] & 0x0f;
6334 if (trace)
6335 {
6336 printf ("\033[33m%s\033[0m %02x %02x\n",
6337 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6338 op[0], op[1]);
6339 printf (" sz = 0x%x,", sz);
6340 printf (" sd = 0x%x,", sd);
6341 printf (" ss = 0x%x,", ss);
6342 printf (" rsrc = 0x%x,", rsrc);
6343 printf (" rdst = 0x%x\n", rdst);
6344 }
6345 SYNTAX("mov%s %1, %0");
f282425e 6346#line 298 "rx-decode.opc"
c7927a3c
NC		 6347 ID(mov); sBWL(sz); F("----");
6348 if ((ss == 3) && (sd != 3))
6349 {
6350 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6351 }
6352 else
6353 {
6354 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6355 }
6356
6357 }
6358 break;
6359 }
6360 break;
6361 case 0xc1:
6362 GETBYTE ();
6363 switch (op[1] & 0x00)
6364 {
6365 case 0x00:
6366 goto op_semantics_41;
6367 break;
6368 }
6369 break;
6370 case 0xc2:
6371 GETBYTE ();
6372 switch (op[1] & 0x00)
6373 {
6374 case 0x00:
6375 goto op_semantics_41;
6376 break;
6377 }
6378 break;
6379 case 0xc3:
6380 GETBYTE ();
6381 switch (op[1] & 0x00)
6382 {
6383 case 0x00:
6384 goto op_semantics_41;
6385 break;
6386 }
6387 break;
6388 case 0xc4:
6389 GETBYTE ();
6390 switch (op[1] & 0x00)
6391 {
6392 case 0x00:
6393 goto op_semantics_41;
6394 break;
6395 }
6396 break;
6397 case 0xc5:
6398 GETBYTE ();
6399 switch (op[1] & 0x00)
6400 {
6401 case 0x00:
6402 goto op_semantics_41;
6403 break;
6404 }
6405 break;
6406 case 0xc6:
6407 GETBYTE ();
6408 switch (op[1] & 0x00)
6409 {
6410 case 0x00:
6411 goto op_semantics_41;
6412 break;
6413 }
6414 break;
6415 case 0xc7:
6416 GETBYTE ();
6417 switch (op[1] & 0x00)
6418 {
6419 case 0x00:
6420 goto op_semantics_41;
6421 break;
6422 }
6423 break;
6424 case 0xc8:
6425 GETBYTE ();
6426 switch (op[1] & 0x00)
6427 {
6428 case 0x00:
6429 goto op_semantics_41;
6430 break;
6431 }
6432 break;
6433 case 0xc9:
6434 GETBYTE ();
6435 switch (op[1] & 0x00)
6436 {
6437 case 0x00:
6438 goto op_semantics_41;
6439 break;
6440 }
6441 break;
6442 case 0xca:
6443 GETBYTE ();
6444 switch (op[1] & 0x00)
6445 {
6446 case 0x00:
6447 goto op_semantics_41;
6448 break;
6449 }
6450 break;
6451 case 0xcb:
6452 GETBYTE ();
6453 switch (op[1] & 0x00)
6454 {
6455 case 0x00:
6456 goto op_semantics_41;
6457 break;
6458 }
6459 break;
6460 case 0xcc:
6461 GETBYTE ();
6462 switch (op[1] & 0x00)
6463 {
6464 case 0x00:
6465 goto op_semantics_41;
6466 break;
6467 }
6468 break;
6469 case 0xcd:
6470 GETBYTE ();
6471 switch (op[1] & 0x00)
6472 {
6473 case 0x00:
6474 goto op_semantics_41;
6475 break;
6476 }
6477 break;
6478 case 0xce:
6479 GETBYTE ();
6480 switch (op[1] & 0x00)
6481 {
6482 case 0x00:
6483 goto op_semantics_41;
6484 break;
6485 }
6486 break;
6487 case 0xcf:
6488 GETBYTE ();
6489 switch (op[1] & 0x00)
6490 {
6491 case 0x00:
6492 goto op_semantics_41;
6493 break;
6494 }
6495 break;
6496 case 0xd0:
6497 GETBYTE ();
6498 switch (op[1] & 0x00)
6499 {
6500 case 0x00:
6501 goto op_semantics_41;
6502 break;
6503 }
6504 break;
6505 case 0xd1:
6506 GETBYTE ();
6507 switch (op[1] & 0x00)
6508 {
6509 case 0x00:
6510 goto op_semantics_41;
6511 break;
6512 }
6513 break;
6514 case 0xd2:
6515 GETBYTE ();
6516 switch (op[1] & 0x00)
6517 {
6518 case 0x00:
6519 goto op_semantics_41;
6520 break;
6521 }
6522 break;
6523 case 0xd3:
6524 GETBYTE ();
6525 switch (op[1] & 0x00)
6526 {
6527 case 0x00:
6528 goto op_semantics_41;
6529 break;
6530 }
6531 break;
6532 case 0xd4:
6533 GETBYTE ();
6534 switch (op[1] & 0x00)
6535 {
6536 case 0x00:
6537 goto op_semantics_41;
6538 break;
6539 }
6540 break;
6541 case 0xd5:
6542 GETBYTE ();
6543 switch (op[1] & 0x00)
6544 {
6545 case 0x00:
6546 goto op_semantics_41;
6547 break;
6548 }
6549 break;
6550 case 0xd6:
6551 GETBYTE ();
6552 switch (op[1] & 0x00)
6553 {
6554 case 0x00:
6555 goto op_semantics_41;
6556 break;
6557 }
6558 break;
6559 case 0xd7:
6560 GETBYTE ();
6561 switch (op[1] & 0x00)
6562 {
6563 case 0x00:
6564 goto op_semantics_41;
6565 break;
6566 }
6567 break;
6568 case 0xd8:
6569 GETBYTE ();
6570 switch (op[1] & 0x00)
6571 {
6572 case 0x00:
6573 goto op_semantics_41;
6574 break;
6575 }
6576 break;
6577 case 0xd9:
6578 GETBYTE ();
6579 switch (op[1] & 0x00)
6580 {
6581 case 0x00:
6582 goto op_semantics_41;
6583 break;
6584 }
6585 break;
6586 case 0xda:
6587 GETBYTE ();
6588 switch (op[1] & 0x00)
6589 {
6590 case 0x00:
6591 goto op_semantics_41;
6592 break;
6593 }
6594 break;
6595 case 0xdb:
6596 GETBYTE ();
6597 switch (op[1] & 0x00)
6598 {
6599 case 0x00:
6600 goto op_semantics_41;
6601 break;
6602 }
6603 break;
6604 case 0xdc:
6605 GETBYTE ();
6606 switch (op[1] & 0x00)
6607 {
6608 case 0x00:
6609 goto op_semantics_41;
6610 break;
6611 }
6612 break;
6613 case 0xdd:
6614 GETBYTE ();
6615 switch (op[1] & 0x00)
6616 {
6617 case 0x00:
6618 goto op_semantics_41;
6619 break;
6620 }
6621 break;
6622 case 0xde:
6623 GETBYTE ();
6624 switch (op[1] & 0x00)
6625 {
6626 case 0x00:
6627 goto op_semantics_41;
6628 break;
6629 }
6630 break;
6631 case 0xdf:
6632 GETBYTE ();
6633 switch (op[1] & 0x00)
6634 {
6635 case 0x00:
6636 goto op_semantics_41;
6637 break;
6638 }
6639 break;
6640 case 0xe0:
6641 GETBYTE ();
6642 switch (op[1] & 0x00)
6643 {
6644 case 0x00:
6645 goto op_semantics_41;
6646 break;
6647 }
6648 break;
6649 case 0xe1:
6650 GETBYTE ();
6651 switch (op[1] & 0x00)
6652 {
6653 case 0x00:
6654 goto op_semantics_41;
6655 break;
6656 }
6657 break;
6658 case 0xe2:
6659 GETBYTE ();
6660 switch (op[1] & 0x00)
6661 {
6662 case 0x00:
6663 goto op_semantics_41;
6664 break;
6665 }
6666 break;
6667 case 0xe3:
6668 GETBYTE ();
6669 switch (op[1] & 0x00)
6670 {
6671 case 0x00:
6672 goto op_semantics_41;
6673 break;
6674 }
6675 break;
6676 case 0xe4:
6677 GETBYTE ();
6678 switch (op[1] & 0x00)
6679 {
6680 case 0x00:
6681 goto op_semantics_41;
6682 break;
6683 }
6684 break;
6685 case 0xe5:
6686 GETBYTE ();
6687 switch (op[1] & 0x00)
6688 {
6689 case 0x00:
6690 goto op_semantics_41;
6691 break;
6692 }
6693 break;
6694 case 0xe6:
6695 GETBYTE ();
6696 switch (op[1] & 0x00)
6697 {
6698 case 0x00:
6699 goto op_semantics_41;
6700 break;
6701 }
6702 break;
6703 case 0xe7:
6704 GETBYTE ();
6705 switch (op[1] & 0x00)
6706 {
6707 case 0x00:
6708 goto op_semantics_41;
6709 break;
6710 }
6711 break;
6712 case 0xe8:
6713 GETBYTE ();
6714 switch (op[1] & 0x00)
6715 {
6716 case 0x00:
6717 goto op_semantics_41;
6718 break;
6719 }
6720 break;
6721 case 0xe9:
6722 GETBYTE ();
6723 switch (op[1] & 0x00)
6724 {
6725 case 0x00:
6726 goto op_semantics_41;
6727 break;
6728 }
6729 break;
6730 case 0xea:
6731 GETBYTE ();
6732 switch (op[1] & 0x00)
6733 {
6734 case 0x00:
6735 goto op_semantics_41;
6736 break;
6737 }
6738 break;
6739 case 0xeb:
6740 GETBYTE ();
6741 switch (op[1] & 0x00)
6742 {
6743 case 0x00:
6744 goto op_semantics_41;
6745 break;
6746 }
6747 break;
6748 case 0xec:
6749 GETBYTE ();
6750 switch (op[1] & 0x00)
6751 {
6752 case 0x00:
6753 goto op_semantics_41;
6754 break;
6755 }
6756 break;
6757 case 0xed:
6758 GETBYTE ();
6759 switch (op[1] & 0x00)
6760 {
6761 case 0x00:
6762 goto op_semantics_41;
6763 break;
6764 }
6765 break;
6766 case 0xee:
6767 GETBYTE ();
6768 switch (op[1] & 0x00)
6769 {
6770 case 0x00:
6771 goto op_semantics_41;
6772 break;
6773 }
6774 break;
6775 case 0xef:
6776 GETBYTE ();
6777 switch (op[1] & 0x00)
6778 {
6779 case 0x00:
6780 goto op_semantics_41;
6781 break;
6782 }
6783 break;
6784 case 0xf0:
6785 GETBYTE ();
6786 switch (op[1] & 0x08)
6787 {
6788 case 0x00:
6789 op_semantics_42:
6790 {
6791 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
f282425e 6792#line 869 "rx-decode.opc"
c7927a3c 6793 int sd AU = op[0] & 0x03;
f282425e 6794#line 869 "rx-decode.opc"
c7927a3c 6795 int rdst AU = (op[1] >> 4) & 0x0f;
f282425e 6796#line 869 "rx-decode.opc"
c7927a3c
NC		 6797 int bit AU = op[1] & 0x07;
6798 if (trace)
6799 {
6800 printf ("\033[33m%s\033[0m %02x %02x\n",
6801 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6802 op[0], op[1]);
6803 printf (" sd = 0x%x,", sd);
6804 printf (" rdst = 0x%x,", rdst);
6805 printf (" bit = 0x%x\n", bit);
6806 }
6807 SYNTAX("bset #%1, %0%S0");
f282425e 6808#line 869 "rx-decode.opc"
c7927a3c
NC		 6809 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6810
6811 }
6812 break;
6813 case 0x08:
6814 op_semantics_43:
6815 {
6816 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
f282425e 6817#line 879 "rx-decode.opc"
c7927a3c 6818 int sd AU = op[0] & 0x03;
f282425e 6819#line 879 "rx-decode.opc"
c7927a3c 6820 int rdst AU = (op[1] >> 4) & 0x0f;
f282425e 6821#line 879 "rx-decode.opc"
c7927a3c
NC		 6822 int bit AU = op[1] & 0x07;
6823 if (trace)
6824 {
6825 printf ("\033[33m%s\033[0m %02x %02x\n",
6826 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6827 op[0], op[1]);
6828 printf (" sd = 0x%x,", sd);
6829 printf (" rdst = 0x%x,", rdst);
6830 printf (" bit = 0x%x\n", bit);
6831 }
6832 SYNTAX("bclr #%1, %0%S0");
f282425e 6833#line 879 "rx-decode.opc"
c7927a3c
NC		 6834 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6835
6836 }
6837 break;
6838 }
6839 break;
6840 case 0xf1:
6841 GETBYTE ();
6842 switch (op[1] & 0x08)
6843 {
6844 case 0x00:
6845 goto op_semantics_42;
6846 break;
6847 case 0x08:
6848 goto op_semantics_43;
6849 break;
6850 }
6851 break;
6852 case 0xf2:
6853 GETBYTE ();
6854 switch (op[1] & 0x08)
6855 {
6856 case 0x00:
6857 goto op_semantics_42;
6858 break;
6859 case 0x08:
6860 goto op_semantics_43;
6861 break;
6862 }
6863 break;
6864 case 0xf3:
6865 GETBYTE ();
6866 switch (op[1] & 0x08)
6867 {
6868 case 0x00:
6869 goto op_semantics_42;
6870 break;
6871 case 0x08:
6872 goto op_semantics_43;
6873 break;
6874 }
6875 break;
6876 case 0xf4:
6877 GETBYTE ();
6878 switch (op[1] & 0x0c)
6879 {
6880 case 0x00:
6881 case 0x04:
6882 op_semantics_44:
6883 {
6884 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
f282425e 6885#line 889 "rx-decode.opc"
c7927a3c 6886 int sd AU = op[0] & 0x03;
f282425e 6887#line 889 "rx-decode.opc"
c7927a3c 6888 int rdst AU = (op[1] >> 4) & 0x0f;
f282425e 6889#line 889 "rx-decode.opc"
c7927a3c
NC		 6890 int bit AU = op[1] & 0x07;
6891 if (trace)
6892 {
6893 printf ("\033[33m%s\033[0m %02x %02x\n",
6894 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6895 op[0], op[1]);
6896 printf (" sd = 0x%x,", sd);
6897 printf (" rdst = 0x%x,", rdst);
6898 printf (" bit = 0x%x\n", bit);
6899 }
6900 SYNTAX("btst #%2, %1%S1");
f282425e 6901#line 889 "rx-decode.opc"
c7927a3c
NC		 6902 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F("--ZC");
6903
6904 }
6905 break;
6906 case 0x08:
6907 op_semantics_45:
6908 {
6909 /** 1111 01ss rsrc 10sz push%s %1 */
f282425e 6910#line 357 "rx-decode.opc"
c7927a3c 6911 int ss AU = op[0] & 0x03;
f282425e 6912#line 357 "rx-decode.opc"
c7927a3c 6913 int rsrc AU = (op[1] >> 4) & 0x0f;
f282425e 6914#line 357 "rx-decode.opc"
c7927a3c
NC		 6915 int sz AU = op[1] & 0x03;
6916 if (trace)
6917 {
6918 printf ("\033[33m%s\033[0m %02x %02x\n",
6919 "/** 1111 01ss rsrc 10sz push%s %1 */",
6920 op[0], op[1]);
6921 printf (" ss = 0x%x,", ss);
6922 printf (" rsrc = 0x%x,", rsrc);
6923 printf (" sz = 0x%x\n", sz);
6924 }
6925 SYNTAX("push%s %1");
f282425e 6926#line 357 "rx-decode.opc"
c7927a3c
NC		 6927 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F("----");
6928
6929 /*----------------------------------------------------------------------*/
6930 /* XCHG */
6931
6932 }
6933 break;
6934 default: UNSUPPORTED(); break;
6935 }
6936 break;
6937 case 0xf5:
6938 GETBYTE ();
6939 switch (op[1] & 0x0c)
6940 {
6941 case 0x00:
6942 case 0x04:
6943 goto op_semantics_44;
6944 break;
6945 case 0x08:
6946 goto op_semantics_45;
6947 break;
6948 default: UNSUPPORTED(); break;
6949 }
6950 break;
6951 case 0xf6:
6952 GETBYTE ();
6953 switch (op[1] & 0x0c)
6954 {
6955 case 0x00:
6956 case 0x04:
6957 goto op_semantics_44;
6958 break;
6959 case 0x08:
6960 goto op_semantics_45;
6961 break;
6962 default: UNSUPPORTED(); break;
6963 }
6964 break;
6965 case 0xf7:
6966 GETBYTE ();
6967 switch (op[1] & 0x0c)
6968 {
6969 case 0x00:
6970 case 0x04:
6971 goto op_semantics_44;
6972 break;
6973 case 0x08:
6974 goto op_semantics_45;
6975 break;
6976 default: UNSUPPORTED(); break;
6977 }
6978 break;
6979 case 0xf8:
6980 GETBYTE ();
6981 switch (op[1] & 0x00)
6982 {
6983 case 0x00:
6984 op_semantics_46:
6985 {
6986 /** 1111 10sd rdst im sz mov%s #%1, %0 */
f282425e 6987#line 289 "rx-decode.opc"
c7927a3c 6988 int sd AU = op[0] & 0x03;
f282425e 6989#line 289 "rx-decode.opc"
c7927a3c 6990 int rdst AU = (op[1] >> 4) & 0x0f;
f282425e 6991#line 289 "rx-decode.opc"
c7927a3c 6992 int im AU = (op[1] >> 2) & 0x03;
f282425e 6993#line 289 "rx-decode.opc"
c7927a3c
NC		 6994 int sz AU = op[1] & 0x03;
6995 if (trace)
6996 {
6997 printf ("\033[33m%s\033[0m %02x %02x\n",
6998 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
6999 op[0], op[1]);
7000 printf (" sd = 0x%x,", sd);
7001 printf (" rdst = 0x%x,", rdst);
7002 printf (" im = 0x%x,", im);
7003 printf (" sz = 0x%x\n", sz);
7004 }
7005 SYNTAX("mov%s #%1, %0");
f282425e 7006#line 289 "rx-decode.opc"
c7927a3c
NC		 7007 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F("----");
7008
7009 }
7010 break;
7011 }
7012 break;
7013 case 0xf9:
7014 GETBYTE ();
7015 switch (op[1] & 0x00)
7016 {
7017 case 0x00:
7018 goto op_semantics_46;
7019 break;
7020 }
7021 break;
7022 case 0xfa:
7023 GETBYTE ();
7024 switch (op[1] & 0x00)
7025 {
7026 case 0x00:
7027 goto op_semantics_46;
7028 break;
7029 }
7030 break;
7031 case 0xfb:
7032 GETBYTE ();
7033 switch (op[1] & 0x00)
7034 {
7035 case 0x00:
7036 goto op_semantics_46;
7037 break;
7038 }
7039 break;
7040 case 0xfc:
7041 GETBYTE ();
7042 switch (op[1] & 0xff)
7043 {
7044 case 0x03:
7045 GETBYTE ();
7046 switch (op[2] & 0x00)
7047 {
7048 case 0x00:
7049 {
7050 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
f282425e 7051#line 531 "rx-decode.opc"
c7927a3c 7052 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7053#line 531 "rx-decode.opc"
c7927a3c
NC		 7054 int rdst AU = op[2] & 0x0f;
7055 if (trace)
7056 {
7057 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7058 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7059 op[0], op[1], op[2]);
7060 printf (" rsrc = 0x%x,", rsrc);
7061 printf (" rdst = 0x%x\n", rdst);
7062 }
7063 SYNTAX("sbb %1, %0");
f282425e 7064#line 531 "rx-decode.opc"
c7927a3c
NC		 7065 ID(sbb); SR (rsrc); DR(rdst); F("OSZC");
7066
7067 /* FIXME: only supports .L */
7068 }
7069 break;
7070 }
7071 break;
7072 case 0x07:
7073 GETBYTE ();
7074 switch (op[2] & 0x00)
7075 {
7076 case 0x00:
7077 {
7078 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
f282425e 7079#line 462 "rx-decode.opc"
c7927a3c 7080 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7081#line 462 "rx-decode.opc"
c7927a3c
NC		 7082 int rdst AU = op[2] & 0x0f;
7083 if (trace)
7084 {
7085 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7086 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7087 op[0], op[1], op[2]);
7088 printf (" rsrc = 0x%x,", rsrc);
7089 printf (" rdst = 0x%x\n", rdst);
7090 }
7091 SYNTAX("neg %2, %0");
f282425e 7092#line 462 "rx-decode.opc"
c7927a3c
NC		 7093 ID(sub); DR(rdst); SC(0); S2R(rsrc); F("OSZC");
7094
7095 /*----------------------------------------------------------------------*/
7096 /* ADC */
7097
7098 }
7099 break;
7100 }
7101 break;
7102 case 0x0b:
7103 GETBYTE ();
7104 switch (op[2] & 0x00)
7105 {
7106 case 0x00:
7107 {
7108 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
f282425e 7109#line 471 "rx-decode.opc"
c7927a3c 7110 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7111#line 471 "rx-decode.opc"
c7927a3c
NC		 7112 int rdst AU = op[2] & 0x0f;
7113 if (trace)
7114 {
7115 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7116 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7117 op[0], op[1], op[2]);
7118 printf (" rsrc = 0x%x,", rsrc);
7119 printf (" rdst = 0x%x\n", rdst);
7120 }
7121 SYNTAX("adc %1, %0");
f282425e 7122#line 471 "rx-decode.opc"
c7927a3c
NC		 7123 ID(adc); SR(rsrc); DR(rdst); F("OSZC");
7124
7125 }
7126 break;
7127 }
7128 break;
7129 case 0x0f:
7130 GETBYTE ();
7131 switch (op[2] & 0x00)
7132 {
7133 case 0x00:
7134 {
7135 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
f282425e 7136#line 544 "rx-decode.opc"
c7927a3c 7137 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7138#line 544 "rx-decode.opc"
c7927a3c
NC		 7139 int rdst AU = op[2] & 0x0f;
7140 if (trace)
7141 {
7142 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7143 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7144 op[0], op[1], op[2]);
7145 printf (" rsrc = 0x%x,", rsrc);
7146 printf (" rdst = 0x%x\n", rdst);
7147 }
7148 SYNTAX("abs %1, %0");
f282425e 7149#line 544 "rx-decode.opc"
c7927a3c
NC		 7150 ID(abs); DR(rdst); SR(rsrc); F("OSZ-");
7151
7152 /*----------------------------------------------------------------------*/
7153 /* MAX */
7154
7155 }
7156 break;
7157 }
7158 break;
7159 case 0x10:
7160 GETBYTE ();
7161 switch (op[2] & 0x00)
7162 {
7163 case 0x00:
7164 op_semantics_47:
7165 {
7166 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
f282425e 7167#line 553 "rx-decode.opc"
c7927a3c 7168 int ss AU = op[1] & 0x03;
f282425e 7169#line 553 "rx-decode.opc"
c7927a3c 7170 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7171#line 553 "rx-decode.opc"
c7927a3c
NC		 7172 int rdst AU = op[2] & 0x0f;
7173 if (trace)
7174 {
7175 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7176 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7177 op[0], op[1], op[2]);
7178 printf (" ss = 0x%x,", ss);
7179 printf (" rsrc = 0x%x,", rsrc);
7180 printf (" rdst = 0x%x\n", rdst);
7181 }
7182 SYNTAX("max %1%S1, %0");
f282425e 7183#line 553 "rx-decode.opc"
c7927a3c
NC		 7184 ID(max); SP(ss, rsrc); DR(rdst);
7185
7186 }
7187 break;
7188 }
7189 break;
7190 case 0x11:
7191 GETBYTE ();
7192 switch (op[2] & 0x00)
7193 {
7194 case 0x00:
7195 goto op_semantics_47;
7196 break;
7197 }
7198 break;
7199 case 0x12:
7200 GETBYTE ();
7201 switch (op[2] & 0x00)
7202 {
7203 case 0x00:
7204 goto op_semantics_47;
7205 break;
7206 }
7207 break;
7208 case 0x13:
7209 GETBYTE ();
7210 switch (op[2] & 0x00)
7211 {
7212 case 0x00:
7213 goto op_semantics_47;
7214 break;
7215 }
7216 break;
7217 case 0x14:
7218 GETBYTE ();
7219 switch (op[2] & 0x00)
7220 {
7221 case 0x00:
7222 op_semantics_48:
7223 {
7224 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
f282425e 7225#line 565 "rx-decode.opc"
c7927a3c 7226 int ss AU = op[1] & 0x03;
f282425e 7227#line 565 "rx-decode.opc"
c7927a3c 7228 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7229#line 565 "rx-decode.opc"
c7927a3c
NC		 7230 int rdst AU = op[2] & 0x0f;
7231 if (trace)
7232 {
7233 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7234 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7235 op[0], op[1], op[2]);
7236 printf (" ss = 0x%x,", ss);
7237 printf (" rsrc = 0x%x,", rsrc);
7238 printf (" rdst = 0x%x\n", rdst);
7239 }
7240 SYNTAX("min %1%S1, %0");
f282425e 7241#line 565 "rx-decode.opc"
c7927a3c
NC		 7242 ID(min); SP(ss, rsrc); DR(rdst);
7243
7244 }
7245 break;
7246 }
7247 break;
7248 case 0x15:
7249 GETBYTE ();
7250 switch (op[2] & 0x00)
7251 {
7252 case 0x00:
7253 goto op_semantics_48;
7254 break;
7255 }
7256 break;
7257 case 0x16:
7258 GETBYTE ();
7259 switch (op[2] & 0x00)
7260 {
7261 case 0x00:
7262 goto op_semantics_48;
7263 break;
7264 }
7265 break;
7266 case 0x17:
7267 GETBYTE ();
7268 switch (op[2] & 0x00)
7269 {
7270 case 0x00:
7271 goto op_semantics_48;
7272 break;
7273 }
7274 break;
7275 case 0x18:
7276 GETBYTE ();
7277 switch (op[2] & 0x00)
7278 {
7279 case 0x00:
7280 op_semantics_49:
7281 {
7282 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
f282425e 7283#line 595 "rx-decode.opc"
c7927a3c 7284 int ss AU = op[1] & 0x03;
f282425e 7285#line 595 "rx-decode.opc"
c7927a3c 7286 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7287#line 595 "rx-decode.opc"
c7927a3c
NC		 7288 int rdst AU = op[2] & 0x0f;
7289 if (trace)
7290 {
7291 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7292 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7293 op[0], op[1], op[2]);
7294 printf (" ss = 0x%x,", ss);
7295 printf (" rsrc = 0x%x,", rsrc);
7296 printf (" rdst = 0x%x\n", rdst);
7297 }
7298 SYNTAX("emul %1%S1, %0");
f282425e 7299#line 595 "rx-decode.opc"
c7927a3c
NC		 7300 ID(emul); SP(ss, rsrc); DR(rdst);
7301
7302 }
7303 break;
7304 }
7305 break;
7306 case 0x19:
7307 GETBYTE ();
7308 switch (op[2] & 0x00)
7309 {
7310 case 0x00:
7311 goto op_semantics_49;
7312 break;
7313 }
7314 break;
7315 case 0x1a:
7316 GETBYTE ();
7317 switch (op[2] & 0x00)
7318 {
7319 case 0x00:
7320 goto op_semantics_49;
7321 break;
7322 }
7323 break;
7324 case 0x1b:
7325 GETBYTE ();
7326 switch (op[2] & 0x00)
7327 {
7328 case 0x00:
7329 goto op_semantics_49;
7330 break;
7331 }
7332 break;
7333 case 0x1c:
7334 GETBYTE ();
7335 switch (op[2] & 0x00)
7336 {
7337 case 0x00:
7338 op_semantics_50:
7339 {
7340 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
f282425e 7341#line 607 "rx-decode.opc"
c7927a3c 7342 int ss AU = op[1] & 0x03;
f282425e 7343#line 607 "rx-decode.opc"
c7927a3c 7344 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7345#line 607 "rx-decode.opc"
c7927a3c
NC		 7346 int rdst AU = op[2] & 0x0f;
7347 if (trace)
7348 {
7349 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7350 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7351 op[0], op[1], op[2]);
7352 printf (" ss = 0x%x,", ss);
7353 printf (" rsrc = 0x%x,", rsrc);
7354 printf (" rdst = 0x%x\n", rdst);
7355 }
7356 SYNTAX("emulu %1%S1, %0");
f282425e 7357#line 607 "rx-decode.opc"
c7927a3c
NC		 7358 ID(emulu); SP(ss, rsrc); DR(rdst);
7359
7360 }
7361 break;
7362 }
7363 break;
7364 case 0x1d:
7365 GETBYTE ();
7366 switch (op[2] & 0x00)
7367 {
7368 case 0x00:
7369 goto op_semantics_50;
7370 break;
7371 }
7372 break;
7373 case 0x1e:
7374 GETBYTE ();
7375 switch (op[2] & 0x00)
7376 {
7377 case 0x00:
7378 goto op_semantics_50;
7379 break;
7380 }
7381 break;
7382 case 0x1f:
7383 GETBYTE ();
7384 switch (op[2] & 0x00)
7385 {
7386 case 0x00:
7387 goto op_semantics_50;
7388 break;
7389 }
7390 break;
7391 case 0x20:
7392 GETBYTE ();
7393 switch (op[2] & 0x00)
7394 {
7395 case 0x00:
7396 op_semantics_51:
7397 {
7398 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
f282425e 7399#line 619 "rx-decode.opc"
c7927a3c 7400 int ss AU = op[1] & 0x03;
f282425e 7401#line 619 "rx-decode.opc"
c7927a3c 7402 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7403#line 619 "rx-decode.opc"
c7927a3c
NC		 7404 int rdst AU = op[2] & 0x0f;
7405 if (trace)
7406 {
7407 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7408 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7409 op[0], op[1], op[2]);
7410 printf (" ss = 0x%x,", ss);
7411 printf (" rsrc = 0x%x,", rsrc);
7412 printf (" rdst = 0x%x\n", rdst);
7413 }
7414 SYNTAX("div %1%S1, %0");
f282425e 7415#line 619 "rx-decode.opc"
c7927a3c
NC		 7416 ID(div); SP(ss, rsrc); DR(rdst); F("O---");
7417
7418 }
7419 break;
7420 }
7421 break;
7422 case 0x21:
7423 GETBYTE ();
7424 switch (op[2] & 0x00)
7425 {
7426 case 0x00:
7427 goto op_semantics_51;
7428 break;
7429 }
7430 break;
7431 case 0x22:
7432 GETBYTE ();
7433 switch (op[2] & 0x00)
7434 {
7435 case 0x00:
7436 goto op_semantics_51;
7437 break;
7438 }
7439 break;
7440 case 0x23:
7441 GETBYTE ();
7442 switch (op[2] & 0x00)
7443 {
7444 case 0x00:
7445 goto op_semantics_51;
7446 break;
7447 }
7448 break;
7449 case 0x24:
7450 GETBYTE ();
7451 switch (op[2] & 0x00)
7452 {
7453 case 0x00:
7454 op_semantics_52:
7455 {
7456 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
f282425e 7457#line 631 "rx-decode.opc"
c7927a3c 7458 int ss AU = op[1] & 0x03;
f282425e 7459#line 631 "rx-decode.opc"
c7927a3c 7460 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7461#line 631 "rx-decode.opc"
c7927a3c
NC		 7462 int rdst AU = op[2] & 0x0f;
7463 if (trace)
7464 {
7465 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7466 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7467 op[0], op[1], op[2]);
7468 printf (" ss = 0x%x,", ss);
7469 printf (" rsrc = 0x%x,", rsrc);
7470 printf (" rdst = 0x%x\n", rdst);
7471 }
7472 SYNTAX("divu %1%S1, %0");
f282425e 7473#line 631 "rx-decode.opc"
c7927a3c
NC		 7474 ID(divu); SP(ss, rsrc); DR(rdst); F("O---");
7475
7476 }
7477 break;
7478 }
7479 break;
7480 case 0x25:
7481 GETBYTE ();
7482 switch (op[2] & 0x00)
7483 {
7484 case 0x00:
7485 goto op_semantics_52;
7486 break;
7487 }
7488 break;
7489 case 0x26:
7490 GETBYTE ();
7491 switch (op[2] & 0x00)
7492 {
7493 case 0x00:
7494 goto op_semantics_52;
7495 break;
7496 }
7497 break;
7498 case 0x27:
7499 GETBYTE ();
7500 switch (op[2] & 0x00)
7501 {
7502 case 0x00:
7503 goto op_semantics_52;
7504 break;
7505 }
7506 break;
7507 case 0x30:
7508 GETBYTE ();
7509 switch (op[2] & 0x00)
7510 {
7511 case 0x00:
7512 op_semantics_53:
7513 {
7514 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
f282425e 7515#line 450 "rx-decode.opc"
c7927a3c 7516 int ss AU = op[1] & 0x03;
f282425e 7517#line 450 "rx-decode.opc"
c7927a3c 7518 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7519#line 450 "rx-decode.opc"
c7927a3c
NC		 7520 int rdst AU = op[2] & 0x0f;
7521 if (trace)
7522 {
7523 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7524 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7525 op[0], op[1], op[2]);
7526 printf (" ss = 0x%x,", ss);
7527 printf (" rsrc = 0x%x,", rsrc);
7528 printf (" rdst = 0x%x\n", rdst);
7529 }
7530 SYNTAX("tst %1%S1, %2");
f282425e 7531#line 450 "rx-decode.opc"
c7927a3c
NC		 7532 ID(and); SP(ss, rsrc); S2R(rdst); F("-SZ-");
7533
7534 }
7535 break;
7536 }
7537 break;
7538 case 0x31:
7539 GETBYTE ();
7540 switch (op[2] & 0x00)
7541 {
7542 case 0x00:
7543 goto op_semantics_53;
7544 break;
7545 }
7546 break;
7547 case 0x32:
7548 GETBYTE ();
7549 switch (op[2] & 0x00)
7550 {
7551 case 0x00:
7552 goto op_semantics_53;
7553 break;
7554 }
7555 break;
7556 case 0x33:
7557 GETBYTE ();
7558 switch (op[2] & 0x00)
7559 {
7560 case 0x00:
7561 goto op_semantics_53;
7562 break;
7563 }
7564 break;
7565 case 0x34:
7566 GETBYTE ();
7567 switch (op[2] & 0x00)
7568 {
7569 case 0x00:
7570 op_semantics_54:
7571 {
7572 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
f282425e 7573#line 429 "rx-decode.opc"
c7927a3c 7574 int ss AU = op[1] & 0x03;
f282425e 7575#line 429 "rx-decode.opc"
c7927a3c 7576 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7577#line 429 "rx-decode.opc"
c7927a3c
NC		 7578 int rdst AU = op[2] & 0x0f;
7579 if (trace)
7580 {
7581 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7582 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7583 op[0], op[1], op[2]);
7584 printf (" ss = 0x%x,", ss);
7585 printf (" rsrc = 0x%x,", rsrc);
7586 printf (" rdst = 0x%x\n", rdst);
7587 }
7588 SYNTAX("xor %1%S1, %0");
f282425e 7589#line 429 "rx-decode.opc"
c7927a3c
NC		 7590 ID(xor); SP(ss, rsrc); DR(rdst); F("-SZ-");
7591
7592 }
7593 break;
7594 }
7595 break;
7596 case 0x35:
7597 GETBYTE ();
7598 switch (op[2] & 0x00)
7599 {
7600 case 0x00:
7601 goto op_semantics_54;
7602 break;
7603 }
7604 break;
7605 case 0x36:
7606 GETBYTE ();
7607 switch (op[2] & 0x00)
7608 {
7609 case 0x00:
7610 goto op_semantics_54;
7611 break;
7612 }
7613 break;
7614 case 0x37:
7615 GETBYTE ();
7616 switch (op[2] & 0x00)
7617 {
7618 case 0x00:
7619 goto op_semantics_54;
7620 break;
7621 }
7622 break;
7623 case 0x3b:
7624 GETBYTE ();
7625 switch (op[2] & 0x00)
7626 {
7627 case 0x00:
7628 {
7629 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
f282425e 7630#line 441 "rx-decode.opc"
c7927a3c 7631 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7632#line 441 "rx-decode.opc"
c7927a3c
NC		 7633 int rdst AU = op[2] & 0x0f;
7634 if (trace)
7635 {
7636 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7637 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7638 op[0], op[1], op[2]);
7639 printf (" rsrc = 0x%x,", rsrc);
7640 printf (" rdst = 0x%x\n", rdst);
7641 }
7642 SYNTAX("not %1, %0");
f282425e 7643#line 441 "rx-decode.opc"
c7927a3c
NC		 7644 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F("-SZ-");
7645
7646 /*----------------------------------------------------------------------*/
7647 /* TST */
7648
7649 }
7650 break;
7651 }
7652 break;
7653 case 0x40:
7654 GETBYTE ();
7655 switch (op[2] & 0x00)
7656 {
7657 case 0x00:
7658 op_semantics_55:
7659 {
7660 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
f282425e 7661#line 363 "rx-decode.opc"
c7927a3c 7662 int ss AU = op[1] & 0x03;
f282425e 7663#line 363 "rx-decode.opc"
c7927a3c 7664 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7665#line 363 "rx-decode.opc"
c7927a3c
NC		 7666 int rdst AU = op[2] & 0x0f;
7667 if (trace)
7668 {
7669 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7670 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7671 op[0], op[1], op[2]);
7672 printf (" ss = 0x%x,", ss);
7673 printf (" rsrc = 0x%x,", rsrc);
7674 printf (" rdst = 0x%x\n", rdst);
7675 }
7676 SYNTAX("xchg %1%S1, %0");
f282425e 7677#line 363 "rx-decode.opc"
c7927a3c
NC		 7678 ID(xchg); DR(rdst); SP(ss, rsrc);
7679
7680 }
7681 break;
7682 }
7683 break;
7684 case 0x41:
7685 GETBYTE ();
7686 switch (op[2] & 0x00)
7687 {
7688 case 0x00:
7689 goto op_semantics_55;
7690 break;
7691 }
7692 break;
7693 case 0x42:
7694 GETBYTE ();
7695 switch (op[2] & 0x00)
7696 {
7697 case 0x00:
7698 goto op_semantics_55;
7699 break;
7700 }
7701 break;
7702 case 0x43:
7703 GETBYTE ();
7704 switch (op[2] & 0x00)
7705 {
7706 case 0x00:
7707 goto op_semantics_55;
7708 break;
7709 }
7710 break;
7711 case 0x44:
7712 GETBYTE ();
7713 switch (op[2] & 0x00)
7714 {
7715 case 0x00:
7716 op_semantics_56:
7717 {
7718 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
f282425e 7719#line 860 "rx-decode.opc"
c7927a3c 7720 int sd AU = op[1] & 0x03;
f282425e 7721#line 860 "rx-decode.opc"
c7927a3c 7722 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 7723#line 860 "rx-decode.opc"
c7927a3c
NC		 7724 int rdst AU = op[2] & 0x0f;
7725 if (trace)
7726 {
7727 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7728 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7729 op[0], op[1], op[2]);
7730 printf (" sd = 0x%x,", sd);
7731 printf (" rsrc = 0x%x,", rsrc);
7732 printf (" rdst = 0x%x\n", rdst);
7733 }
7734 SYNTAX("itof %1%S1, %0");
f282425e 7735#line 860 "rx-decode.opc"
c7927a3c
NC		 7736 ID(itof); DR (rdst); SP(sd, rsrc); F("-SZ-");
7737
7738 }
7739 break;
7740 }
7741 break;
7742 case 0x45:
7743 GETBYTE ();
7744 switch (op[2] & 0x00)
7745 {
7746 case 0x00:
7747 goto op_semantics_56;
7748 break;
7749 }
7750 break;
7751 case 0x46:
7752 GETBYTE ();
7753 switch (op[2] & 0x00)
7754 {
7755 case 0x00:
7756 goto op_semantics_56;
7757 break;
7758 }
7759 break;
7760 case 0x47:
7761 GETBYTE ();
7762 switch (op[2] & 0x00)
7763 {
7764 case 0x00:
7765 goto op_semantics_56;
7766 break;
7767 }
7768 break;
7769 case 0x60:
7770 GETBYTE ();
7771 switch (op[2] & 0x00)
7772 {
7773 case 0x00:
7774 op_semantics_57:
7775 {
7776 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
f282425e 7777#line 872 "rx-decode.opc"
c7927a3c 7778 int sd AU = op[1] & 0x03;
f282425e 7779#line 872 "rx-decode.opc"
c7927a3c 7780 int rdst AU = (op[2] >> 4) & 0x0f;
f282425e 7781#line 872 "rx-decode.opc"
c7927a3c
NC		 7782 int rsrc AU = op[2] & 0x0f;
7783 if (trace)
7784 {
7785 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7786 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7787 op[0], op[1], op[2]);
7788 printf (" sd = 0x%x,", sd);
7789 printf (" rdst = 0x%x,", rdst);
7790 printf (" rsrc = 0x%x\n", rsrc);
7791 }
7792 SYNTAX("bset %1, %0%S0");
f282425e 7793#line 872 "rx-decode.opc"
c7927a3c
NC		 7794 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7795
7796 }
7797 break;
7798 }
7799 break;
7800 case 0x61:
7801 GETBYTE ();
7802 switch (op[2] & 0x00)
7803 {
7804 case 0x00:
7805 goto op_semantics_57;
7806 break;
7807 }
7808 break;
7809 case 0x62:
7810 GETBYTE ();
7811 switch (op[2] & 0x00)
7812 {
7813 case 0x00:
7814 goto op_semantics_57;
7815 break;
7816 }
7817 break;
7818 case 0x63:
7819 GETBYTE ();
7820 switch (op[2] & 0x00)
7821 {
7822 case 0x00:
7823 goto op_semantics_57;
7824 break;
7825 }
7826 break;
7827 case 0x64:
7828 GETBYTE ();
7829 switch (op[2] & 0x00)
7830 {
7831 case 0x00:
7832 op_semantics_58:
7833 {
7834 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
f282425e 7835#line 882 "rx-decode.opc"
c7927a3c 7836 int sd AU = op[1] & 0x03;
f282425e 7837#line 882 "rx-decode.opc"
c7927a3c 7838 int rdst AU = (op[2] >> 4) & 0x0f;
f282425e 7839#line 882 "rx-decode.opc"
c7927a3c
NC		 7840 int rsrc AU = op[2] & 0x0f;
7841 if (trace)
7842 {
7843 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7844 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7845 op[0], op[1], op[2]);
7846 printf (" sd = 0x%x,", sd);
7847 printf (" rdst = 0x%x,", rdst);
7848 printf (" rsrc = 0x%x\n", rsrc);
7849 }
7850 SYNTAX("bclr %1, %0%S0");
f282425e 7851#line 882 "rx-decode.opc"
c7927a3c
NC		 7852 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7853
7854 }
7855 break;
7856 }
7857 break;
7858 case 0x65:
7859 GETBYTE ();
7860 switch (op[2] & 0x00)
7861 {
7862 case 0x00:
7863 goto op_semantics_58;
7864 break;
7865 }
7866 break;
7867 case 0x66:
7868 GETBYTE ();
7869 switch (op[2] & 0x00)
7870 {
7871 case 0x00:
7872 goto op_semantics_58;
7873 break;
7874 }
7875 break;
7876 case 0x67:
7877 GETBYTE ();
7878 switch (op[2] & 0x00)
7879 {
7880 case 0x00:
7881 goto op_semantics_58;
7882 break;
7883 }
7884 break;
7885 case 0x68:
7886 GETBYTE ();
7887 switch (op[2] & 0x00)
7888 {
7889 case 0x00:
7890 op_semantics_59:
7891 {
7892 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
f282425e 7893#line 892 "rx-decode.opc"
c7927a3c 7894 int sd AU = op[1] & 0x03;
f282425e 7895#line 892 "rx-decode.opc"
c7927a3c 7896 int rdst AU = (op[2] >> 4) & 0x0f;
f282425e 7897#line 892 "rx-decode.opc"
c7927a3c
NC		 7898 int rsrc AU = op[2] & 0x0f;
7899 if (trace)
7900 {
7901 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7902 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7903 op[0], op[1], op[2]);
7904 printf (" sd = 0x%x,", sd);
7905 printf (" rdst = 0x%x,", rdst);
7906 printf (" rsrc = 0x%x\n", rsrc);
7907 }
7908 SYNTAX("btst %2, %1%S1");
f282425e 7909#line 892 "rx-decode.opc"
c7927a3c
NC		 7910 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F("--ZC");
7911
7912 }
7913 break;
7914 }
7915 break;
7916 case 0x69:
7917 GETBYTE ();
7918 switch (op[2] & 0x00)
7919 {
7920 case 0x00:
7921 goto op_semantics_59;
7922 break;
7923 }
7924 break;
7925 case 0x6a:
7926 GETBYTE ();
7927 switch (op[2] & 0x00)
7928 {
7929 case 0x00:
7930 goto op_semantics_59;
7931 break;
7932 }
7933 break;
7934 case 0x6b:
7935 GETBYTE ();
7936 switch (op[2] & 0x00)
7937 {
7938 case 0x00:
7939 goto op_semantics_59;
7940 break;
7941 }
7942 break;
7943 case 0x6c:
7944 GETBYTE ();
7945 switch (op[2] & 0x00)
7946 {
7947 case 0x00:
7948 op_semantics_60:
7949 {
7950 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
f282425e 7951#line 902 "rx-decode.opc"
c7927a3c 7952 int sd AU = op[1] & 0x03;
f282425e 7953#line 902 "rx-decode.opc"
c7927a3c 7954 int rdst AU = (op[2] >> 4) & 0x0f;
f282425e 7955#line 902 "rx-decode.opc"
c7927a3c
NC		 7956 int rsrc AU = op[2] & 0x0f;
7957 if (trace)
7958 {
7959 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7960 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
7961 op[0], op[1], op[2]);
7962 printf (" sd = 0x%x,", sd);
7963 printf (" rdst = 0x%x,", rdst);
7964 printf (" rsrc = 0x%x\n", rsrc);
7965 }
7966 SYNTAX("bnot %1, %0%S0");
f282425e 7967#line 902 "rx-decode.opc"
c7927a3c
NC		 7968 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7969
7970 }
7971 break;
7972 }
7973 break;
7974 case 0x6d:
7975 GETBYTE ();
7976 switch (op[2] & 0x00)
7977 {
7978 case 0x00:
7979 goto op_semantics_60;
7980 break;
7981 }
7982 break;
7983 case 0x6e:
7984 GETBYTE ();
7985 switch (op[2] & 0x00)
7986 {
7987 case 0x00:
7988 goto op_semantics_60;
7989 break;
7990 }
7991 break;
7992 case 0x6f:
7993 GETBYTE ();
7994 switch (op[2] & 0x00)
7995 {
7996 case 0x00:
7997 goto op_semantics_60;
7998 break;
7999 }
8000 break;
8001 case 0x80:
8002 GETBYTE ();
8003 switch (op[2] & 0x00)
8004 {
8005 case 0x00:
8006 op_semantics_61:
8007 {
8008 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
f282425e 8009#line 839 "rx-decode.opc"
c7927a3c 8010 int sd AU = op[1] & 0x03;
f282425e 8011#line 839 "rx-decode.opc"
c7927a3c 8012 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 8013#line 839 "rx-decode.opc"
c7927a3c
NC		 8014 int rdst AU = op[2] & 0x0f;
8015 if (trace)
8016 {
8017 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8018 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8019 op[0], op[1], op[2]);
8020 printf (" sd = 0x%x,", sd);
8021 printf (" rsrc = 0x%x,", rsrc);
8022 printf (" rdst = 0x%x\n", rdst);
8023 }
8024 SYNTAX("fsub %1%S1, %0");
f282425e 8025#line 839 "rx-decode.opc"
c7927a3c
NC		 8026 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8027
8028 }
8029 break;
8030 }
8031 break;
8032 case 0x81:
8033 GETBYTE ();
8034 switch (op[2] & 0x00)
8035 {
8036 case 0x00:
8037 goto op_semantics_61;
8038 break;
8039 }
8040 break;
8041 case 0x82:
8042 GETBYTE ();
8043 switch (op[2] & 0x00)
8044 {
8045 case 0x00:
8046 goto op_semantics_61;
8047 break;
8048 }
8049 break;
8050 case 0x83:
8051 GETBYTE ();
8052 switch (op[2] & 0x00)
8053 {
8054 case 0x00:
8055 goto op_semantics_61;
8056 break;
8057 }
8058 break;
8059 case 0x84:
8060 GETBYTE ();
8061 switch (op[2] & 0x00)
8062 {
8063 case 0x00:
8064 op_semantics_62:
8065 {
8066 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
f282425e 8067#line 833 "rx-decode.opc"
c7927a3c 8068 int sd AU = op[1] & 0x03;
f282425e 8069#line 833 "rx-decode.opc"
c7927a3c 8070 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 8071#line 833 "rx-decode.opc"
c7927a3c
NC		 8072 int rdst AU = op[2] & 0x0f;
8073 if (trace)
8074 {
8075 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8076 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8077 op[0], op[1], op[2]);
8078 printf (" sd = 0x%x,", sd);
8079 printf (" rsrc = 0x%x,", rsrc);
8080 printf (" rdst = 0x%x\n", rdst);
8081 }
8082 SYNTAX("fcmp %1%S1, %0");
f282425e 8083#line 833 "rx-decode.opc"
c7927a3c
NC		 8084 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F("OSZ-");
8085
8086 }
8087 break;
8088 }
8089 break;
8090 case 0x85:
8091 GETBYTE ();
8092 switch (op[2] & 0x00)
8093 {
8094 case 0x00:
8095 goto op_semantics_62;
8096 break;
8097 }
8098 break;
8099 case 0x86:
8100 GETBYTE ();
8101 switch (op[2] & 0x00)
8102 {
8103 case 0x00:
8104 goto op_semantics_62;
8105 break;
8106 }
8107 break;
8108 case 0x87:
8109 GETBYTE ();
8110 switch (op[2] & 0x00)
8111 {
8112 case 0x00:
8113 goto op_semantics_62;
8114 break;
8115 }
8116 break;
8117 case 0x88:
8118 GETBYTE ();
8119 switch (op[2] & 0x00)
8120 {
8121 case 0x00:
8122 op_semantics_63:
8123 {
8124 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
f282425e 8125#line 827 "rx-decode.opc"
c7927a3c 8126 int sd AU = op[1] & 0x03;
f282425e 8127#line 827 "rx-decode.opc"
c7927a3c 8128 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 8129#line 827 "rx-decode.opc"
c7927a3c
NC		 8130 int rdst AU = op[2] & 0x0f;
8131 if (trace)
8132 {
8133 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8134 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8135 op[0], op[1], op[2]);
8136 printf (" sd = 0x%x,", sd);
8137 printf (" rsrc = 0x%x,", rsrc);
8138 printf (" rdst = 0x%x\n", rdst);
8139 }
8140 SYNTAX("fadd %1%S1, %0");
f282425e 8141#line 827 "rx-decode.opc"
c7927a3c
NC		 8142 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8143
8144 }
8145 break;
8146 }
8147 break;
8148 case 0x89:
8149 GETBYTE ();
8150 switch (op[2] & 0x00)
8151 {
8152 case 0x00:
8153 goto op_semantics_63;
8154 break;
8155 }
8156 break;
8157 case 0x8a:
8158 GETBYTE ();
8159 switch (op[2] & 0x00)
8160 {
8161 case 0x00:
8162 goto op_semantics_63;
8163 break;
8164 }
8165 break;
8166 case 0x8b:
8167 GETBYTE ();
8168 switch (op[2] & 0x00)
8169 {
8170 case 0x00:
8171 goto op_semantics_63;
8172 break;
8173 }
8174 break;
8175 case 0x8c:
8176 GETBYTE ();
8177 switch (op[2] & 0x00)
8178 {
8179 case 0x00:
8180 op_semantics_64:
8181 {
8182 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
f282425e 8183#line 848 "rx-decode.opc"
c7927a3c 8184 int sd AU = op[1] & 0x03;
f282425e 8185#line 848 "rx-decode.opc"
c7927a3c 8186 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 8187#line 848 "rx-decode.opc"
c7927a3c
NC		 8188 int rdst AU = op[2] & 0x0f;
8189 if (trace)
8190 {
8191 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8192 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8193 op[0], op[1], op[2]);
8194 printf (" sd = 0x%x,", sd);
8195 printf (" rsrc = 0x%x,", rsrc);
8196 printf (" rdst = 0x%x\n", rdst);
8197 }
8198 SYNTAX("fmul %1%S1, %0");
f282425e 8199#line 848 "rx-decode.opc"
c7927a3c
NC		 8200 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8201
8202 }
8203 break;
8204 }
8205 break;
8206 case 0x8d:
8207 GETBYTE ();
8208 switch (op[2] & 0x00)
8209 {
8210 case 0x00:
8211 goto op_semantics_64;
8212 break;
8213 }
8214 break;
8215 case 0x8e:
8216 GETBYTE ();
8217 switch (op[2] & 0x00)
8218 {
8219 case 0x00:
8220 goto op_semantics_64;
8221 break;
8222 }
8223 break;
8224 case 0x8f:
8225 GETBYTE ();
8226 switch (op[2] & 0x00)
8227 {
8228 case 0x00:
8229 goto op_semantics_64;
8230 break;
8231 }
8232 break;
8233 case 0x90:
8234 GETBYTE ();
8235 switch (op[2] & 0x00)
8236 {
8237 case 0x00:
8238 op_semantics_65:
8239 {
8240 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
f282425e 8241#line 854 "rx-decode.opc"
c7927a3c 8242 int sd AU = op[1] & 0x03;
f282425e 8243#line 854 "rx-decode.opc"
c7927a3c 8244 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 8245#line 854 "rx-decode.opc"
c7927a3c
NC		 8246 int rdst AU = op[2] & 0x0f;
8247 if (trace)
8248 {
8249 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8250 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8251 op[0], op[1], op[2]);
8252 printf (" sd = 0x%x,", sd);
8253 printf (" rsrc = 0x%x,", rsrc);
8254 printf (" rdst = 0x%x\n", rdst);
8255 }
8256 SYNTAX("fdiv %1%S1, %0");
f282425e 8257#line 854 "rx-decode.opc"
c7927a3c
NC		 8258 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8259
8260 }
8261 break;
8262 }
8263 break;
8264 case 0x91:
8265 GETBYTE ();
8266 switch (op[2] & 0x00)
8267 {
8268 case 0x00:
8269 goto op_semantics_65;
8270 break;
8271 }
8272 break;
8273 case 0x92:
8274 GETBYTE ();
8275 switch (op[2] & 0x00)
8276 {
8277 case 0x00:
8278 goto op_semantics_65;
8279 break;
8280 }
8281 break;
8282 case 0x93:
8283 GETBYTE ();
8284 switch (op[2] & 0x00)
8285 {
8286 case 0x00:
8287 goto op_semantics_65;
8288 break;
8289 }
8290 break;
8291 case 0x94:
8292 GETBYTE ();
8293 switch (op[2] & 0x00)
8294 {
8295 case 0x00:
8296 op_semantics_66:
8297 {
8298 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
f282425e 8299#line 842 "rx-decode.opc"
c7927a3c 8300 int sd AU = op[1] & 0x03;
f282425e 8301#line 842 "rx-decode.opc"
c7927a3c 8302 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 8303#line 842 "rx-decode.opc"
c7927a3c
NC		 8304 int rdst AU = op[2] & 0x0f;
8305 if (trace)
8306 {
8307 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8308 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8309 op[0], op[1], op[2]);
8310 printf (" sd = 0x%x,", sd);
8311 printf (" rsrc = 0x%x,", rsrc);
8312 printf (" rdst = 0x%x\n", rdst);
8313 }
8314 SYNTAX("ftoi %1%S1, %0");
f282425e 8315#line 842 "rx-decode.opc"
c7927a3c
NC		 8316 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8317
8318 }
8319 break;
8320 }
8321 break;
8322 case 0x95:
8323 GETBYTE ();
8324 switch (op[2] & 0x00)
8325 {
8326 case 0x00:
8327 goto op_semantics_66;
8328 break;
8329 }
8330 break;
8331 case 0x96:
8332 GETBYTE ();
8333 switch (op[2] & 0x00)
8334 {
8335 case 0x00:
8336 goto op_semantics_66;
8337 break;
8338 }
8339 break;
8340 case 0x97:
8341 GETBYTE ();
8342 switch (op[2] & 0x00)
8343 {
8344 case 0x00:
8345 goto op_semantics_66;
8346 break;
8347 }
8348 break;
8349 case 0x98:
8350 GETBYTE ();
8351 switch (op[2] & 0x00)
8352 {
8353 case 0x00:
8354 op_semantics_67:
8355 {
8356 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
f282425e 8357#line 857 "rx-decode.opc"
c7927a3c 8358 int sd AU = op[1] & 0x03;
f282425e 8359#line 857 "rx-decode.opc"
c7927a3c 8360 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 8361#line 857 "rx-decode.opc"
c7927a3c
NC		 8362 int rdst AU = op[2] & 0x0f;
8363 if (trace)
8364 {
8365 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8366 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8367 op[0], op[1], op[2]);
8368 printf (" sd = 0x%x,", sd);
8369 printf (" rsrc = 0x%x,", rsrc);
8370 printf (" rdst = 0x%x\n", rdst);
8371 }
8372 SYNTAX("round %1%S1, %0");
f282425e 8373#line 857 "rx-decode.opc"
c7927a3c
NC		 8374 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8375
8376 }
8377 break;
8378 }
8379 break;
8380 case 0x99:
8381 GETBYTE ();
8382 switch (op[2] & 0x00)
8383 {
8384 case 0x00:
8385 goto op_semantics_67;
8386 break;
8387 }
8388 break;
8389 case 0x9a:
8390 GETBYTE ();
8391 switch (op[2] & 0x00)
8392 {
8393 case 0x00:
8394 goto op_semantics_67;
8395 break;
8396 }
8397 break;
8398 case 0x9b:
8399 GETBYTE ();
8400 switch (op[2] & 0x00)
8401 {
8402 case 0x00:
8403 goto op_semantics_67;
8404 break;
8405 }
8406 break;
8407 case 0xd0:
8408 GETBYTE ();
8409 switch (op[2] & 0x00)
8410 {
8411 case 0x00:
8412 op_semantics_68:
8413 {
8414 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
946ef196 8415#line 966 "rx-decode.opc"
c7927a3c 8416 int sz AU = (op[1] >> 2) & 0x03;
946ef196 8417#line 966 "rx-decode.opc"
c7927a3c 8418 int sd AU = op[1] & 0x03;
946ef196 8419#line 966 "rx-decode.opc"
c7927a3c 8420 int rdst AU = (op[2] >> 4) & 0x0f;
946ef196 8421#line 966 "rx-decode.opc"
c7927a3c
NC		 8422 int cond AU = op[2] & 0x0f;
8423 if (trace)
8424 {
8425 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8426 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8427 op[0], op[1], op[2]);
8428 printf (" sz = 0x%x,", sz);
8429 printf (" sd = 0x%x,", sd);
8430 printf (" rdst = 0x%x,", rdst);
8431 printf (" cond = 0x%x\n", cond);
8432 }
8433 SYNTAX("sc%1%s %0");
946ef196 8434#line 966 "rx-decode.opc"
c7927a3c
NC		 8435 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8436
8437 }
8438 break;
8439 }
8440 break;
8441 case 0xd1:
8442 GETBYTE ();
8443 switch (op[2] & 0x00)
8444 {
8445 case 0x00:
8446 goto op_semantics_68;
8447 break;
8448 }
8449 break;
8450 case 0xd2:
8451 GETBYTE ();
8452 switch (op[2] & 0x00)
8453 {
8454 case 0x00:
8455 goto op_semantics_68;
8456 break;
8457 }
8458 break;
8459 case 0xd3:
8460 GETBYTE ();
8461 switch (op[2] & 0x00)
8462 {
8463 case 0x00:
8464 goto op_semantics_68;
8465 break;
8466 }
8467 break;
8468 case 0xd4:
8469 GETBYTE ();
8470 switch (op[2] & 0x00)
8471 {
8472 case 0x00:
8473 goto op_semantics_68;
8474 break;
8475 }
8476 break;
8477 case 0xd5:
8478 GETBYTE ();
8479 switch (op[2] & 0x00)
8480 {
8481 case 0x00:
8482 goto op_semantics_68;
8483 break;
8484 }
8485 break;
8486 case 0xd6:
8487 GETBYTE ();
8488 switch (op[2] & 0x00)
8489 {
8490 case 0x00:
8491 goto op_semantics_68;
8492 break;
8493 }
8494 break;
8495 case 0xd7:
8496 GETBYTE ();
8497 switch (op[2] & 0x00)
8498 {
8499 case 0x00:
8500 goto op_semantics_68;
8501 break;
8502 }
8503 break;
8504 case 0xd8:
8505 GETBYTE ();
8506 switch (op[2] & 0x00)
8507 {
8508 case 0x00:
8509 goto op_semantics_68;
8510 break;
8511 }
8512 break;
8513 case 0xd9:
8514 GETBYTE ();
8515 switch (op[2] & 0x00)
8516 {
8517 case 0x00:
8518 goto op_semantics_68;
8519 break;
8520 }
8521 break;
8522 case 0xda:
8523 GETBYTE ();
8524 switch (op[2] & 0x00)
8525 {
8526 case 0x00:
8527 goto op_semantics_68;
8528 break;
8529 }
8530 break;
8531 case 0xdb:
8532 GETBYTE ();
8533 switch (op[2] & 0x00)
8534 {
8535 case 0x00:
8536 goto op_semantics_68;
8537 break;
8538 }
8539 break;
8540 case 0xe0:
8541 GETBYTE ();
8542 switch (op[2] & 0x0f)
8543 {
8544 case 0x00:
8545 case 0x01:
8546 case 0x02:
8547 case 0x03:
8548 case 0x04:
8549 case 0x05:
8550 case 0x06:
8551 case 0x07:
8552 case 0x08:
8553 case 0x09:
8554 case 0x0a:
8555 case 0x0b:
8556 case 0x0c:
8557 case 0x0d:
8558 case 0x0e:
8559 op_semantics_69:
8560 {
8561 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
f282425e 8562#line 909 "rx-decode.opc"
c7927a3c 8563 int bit AU = (op[1] >> 2) & 0x07;
f282425e 8564#line 909 "rx-decode.opc"
c7927a3c 8565 int sd AU = op[1] & 0x03;
f282425e 8566#line 909 "rx-decode.opc"
c7927a3c 8567 int rdst AU = (op[2] >> 4) & 0x0f;
f282425e 8568#line 909 "rx-decode.opc"
c7927a3c
NC		 8569 int cond AU = op[2] & 0x0f;
8570 if (trace)
8571 {
8572 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8573 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8574 op[0], op[1], op[2]);
8575 printf (" bit = 0x%x,", bit);
8576 printf (" sd = 0x%x,", sd);
8577 printf (" rdst = 0x%x,", rdst);
8578 printf (" cond = 0x%x\n", cond);
8579 }
8580 SYNTAX("bm%2 #%1, %0%S0");
f282425e 8581#line 909 "rx-decode.opc"
c7927a3c
NC		 8582 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8583
8584 }
8585 break;
8586 case 0x0f:
8587 op_semantics_70:
8588 {
8589 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
f282425e 8590#line 899 "rx-decode.opc"
c7927a3c 8591 int bit AU = (op[1] >> 2) & 0x07;
f282425e 8592#line 899 "rx-decode.opc"
c7927a3c 8593 int sd AU = op[1] & 0x03;
f282425e 8594#line 899 "rx-decode.opc"
c7927a3c
NC		 8595 int rdst AU = (op[2] >> 4) & 0x0f;
8596 if (trace)
8597 {
8598 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8599 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8600 op[0], op[1], op[2]);
8601 printf (" bit = 0x%x,", bit);
8602 printf (" sd = 0x%x,", sd);
8603 printf (" rdst = 0x%x\n", rdst);
8604 }
8605 SYNTAX("bnot #%1, %0%S0");
f282425e 8606#line 899 "rx-decode.opc"
c7927a3c
NC		 8607 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8608
8609 }
8610 break;
8611 }
8612 break;
8613 case 0xe1:
8614 GETBYTE ();
8615 switch (op[2] & 0x0f)
8616 {
8617 case 0x00:
8618 case 0x01:
8619 case 0x02:
8620 case 0x03:
8621 case 0x04:
8622 case 0x05:
8623 case 0x06:
8624 case 0x07:
8625 case 0x08:
8626 case 0x09:
8627 case 0x0a:
8628 case 0x0b:
8629 case 0x0c:
8630 case 0x0d:
8631 case 0x0e:
8632 goto op_semantics_69;
8633 break;
8634 case 0x0f:
8635 goto op_semantics_70;
8636 break;
8637 }
8638 break;
8639 case 0xe2:
8640 GETBYTE ();
8641 switch (op[2] & 0x0f)
8642 {
8643 case 0x00:
8644 case 0x01:
8645 case 0x02:
8646 case 0x03:
8647 case 0x04:
8648 case 0x05:
8649 case 0x06:
8650 case 0x07:
8651 case 0x08:
8652 case 0x09:
8653 case 0x0a:
8654 case 0x0b:
8655 case 0x0c:
8656 case 0x0d:
8657 case 0x0e:
8658 goto op_semantics_69;
8659 break;
8660 case 0x0f:
8661 goto op_semantics_70;
8662 break;
8663 }
8664 break;
8665 case 0xe3:
8666 GETBYTE ();
8667 switch (op[2] & 0x0f)
8668 {
8669 case 0x00:
8670 case 0x01:
8671 case 0x02:
8672 case 0x03:
8673 case 0x04:
8674 case 0x05:
8675 case 0x06:
8676 case 0x07:
8677 case 0x08:
8678 case 0x09:
8679 case 0x0a:
8680 case 0x0b:
8681 case 0x0c:
8682 case 0x0d:
8683 case 0x0e:
8684 goto op_semantics_69;
8685 break;
8686 case 0x0f:
8687 goto op_semantics_70;
8688 break;
8689 }
8690 break;
8691 case 0xe4:
8692 GETBYTE ();
8693 switch (op[2] & 0x0f)
8694 {
8695 case 0x00:
8696 case 0x01:
8697 case 0x02:
8698 case 0x03:
8699 case 0x04:
8700 case 0x05:
8701 case 0x06:
8702 case 0x07:
8703 case 0x08:
8704 case 0x09:
8705 case 0x0a:
8706 case 0x0b:
8707 case 0x0c:
8708 case 0x0d:
8709 case 0x0e:
8710 goto op_semantics_69;
8711 break;
8712 case 0x0f:
8713 goto op_semantics_70;
8714 break;
8715 }
8716 break;
8717 case 0xe5:
8718 GETBYTE ();
8719 switch (op[2] & 0x0f)
8720 {
8721 case 0x00:
8722 case 0x01:
8723 case 0x02:
8724 case 0x03:
8725 case 0x04:
8726 case 0x05:
8727 case 0x06:
8728 case 0x07:
8729 case 0x08:
8730 case 0x09:
8731 case 0x0a:
8732 case 0x0b:
8733 case 0x0c:
8734 case 0x0d:
8735 case 0x0e:
8736 goto op_semantics_69;
8737 break;
8738 case 0x0f:
8739 goto op_semantics_70;
8740 break;
8741 }
8742 break;
8743 case 0xe6:
8744 GETBYTE ();
8745 switch (op[2] & 0x0f)
8746 {
8747 case 0x00:
8748 case 0x01:
8749 case 0x02:
8750 case 0x03:
8751 case 0x04:
8752 case 0x05:
8753 case 0x06:
8754 case 0x07:
8755 case 0x08:
8756 case 0x09:
8757 case 0x0a:
8758 case 0x0b:
8759 case 0x0c:
8760 case 0x0d:
8761 case 0x0e:
8762 goto op_semantics_69;
8763 break;
8764 case 0x0f:
8765 goto op_semantics_70;
8766 break;
8767 }
8768 break;
8769 case 0xe7:
8770 GETBYTE ();
8771 switch (op[2] & 0x0f)
8772 {
8773 case 0x00:
8774 case 0x01:
8775 case 0x02:
8776 case 0x03:
8777 case 0x04:
8778 case 0x05:
8779 case 0x06:
8780 case 0x07:
8781 case 0x08:
8782 case 0x09:
8783 case 0x0a:
8784 case 0x0b:
8785 case 0x0c:
8786 case 0x0d:
8787 case 0x0e:
8788 goto op_semantics_69;
8789 break;
8790 case 0x0f:
8791 goto op_semantics_70;
8792 break;
8793 }
8794 break;
8795 case 0xe8:
8796 GETBYTE ();
8797 switch (op[2] & 0x0f)
8798 {
8799 case 0x00:
8800 case 0x01:
8801 case 0x02:
8802 case 0x03:
8803 case 0x04:
8804 case 0x05:
8805 case 0x06:
8806 case 0x07:
8807 case 0x08:
8808 case 0x09:
8809 case 0x0a:
8810 case 0x0b:
8811 case 0x0c:
8812 case 0x0d:
8813 case 0x0e:
8814 goto op_semantics_69;
8815 break;
8816 case 0x0f:
8817 goto op_semantics_70;
8818 break;
8819 }
8820 break;
8821 case 0xe9:
8822 GETBYTE ();
8823 switch (op[2] & 0x0f)
8824 {
8825 case 0x00:
8826 case 0x01:
8827 case 0x02:
8828 case 0x03:
8829 case 0x04:
8830 case 0x05:
8831 case 0x06:
8832 case 0x07:
8833 case 0x08:
8834 case 0x09:
8835 case 0x0a:
8836 case 0x0b:
8837 case 0x0c:
8838 case 0x0d:
8839 case 0x0e:
8840 goto op_semantics_69;
8841 break;
8842 case 0x0f:
8843 goto op_semantics_70;
8844 break;
8845 }
8846 break;
8847 case 0xea:
8848 GETBYTE ();
8849 switch (op[2] & 0x0f)
8850 {
8851 case 0x00:
8852 case 0x01:
8853 case 0x02:
8854 case 0x03:
8855 case 0x04:
8856 case 0x05:
8857 case 0x06:
8858 case 0x07:
8859 case 0x08:
8860 case 0x09:
8861 case 0x0a:
8862 case 0x0b:
8863 case 0x0c:
8864 case 0x0d:
8865 case 0x0e:
8866 goto op_semantics_69;
8867 break;
8868 case 0x0f:
8869 goto op_semantics_70;
8870 break;
8871 }
8872 break;
8873 case 0xeb:
8874 GETBYTE ();
8875 switch (op[2] & 0x0f)
8876 {
8877 case 0x00:
8878 case 0x01:
8879 case 0x02:
8880 case 0x03:
8881 case 0x04:
8882 case 0x05:
8883 case 0x06:
8884 case 0x07:
8885 case 0x08:
8886 case 0x09:
8887 case 0x0a:
8888 case 0x0b:
8889 case 0x0c:
8890 case 0x0d:
8891 case 0x0e:
8892 goto op_semantics_69;
8893 break;
8894 case 0x0f:
8895 goto op_semantics_70;
8896 break;
8897 }
8898 break;
8899 case 0xec:
8900 GETBYTE ();
8901 switch (op[2] & 0x0f)
8902 {
8903 case 0x00:
8904 case 0x01:
8905 case 0x02:
8906 case 0x03:
8907 case 0x04:
8908 case 0x05:
8909 case 0x06:
8910 case 0x07:
8911 case 0x08:
8912 case 0x09:
8913 case 0x0a:
8914 case 0x0b:
8915 case 0x0c:
8916 case 0x0d:
8917 case 0x0e:
8918 goto op_semantics_69;
8919 break;
8920 case 0x0f:
8921 goto op_semantics_70;
8922 break;
8923 }
8924 break;
8925 case 0xed:
8926 GETBYTE ();
8927 switch (op[2] & 0x0f)
8928 {
8929 case 0x00:
8930 case 0x01:
8931 case 0x02:
8932 case 0x03:
8933 case 0x04:
8934 case 0x05:
8935 case 0x06:
8936 case 0x07:
8937 case 0x08:
8938 case 0x09:
8939 case 0x0a:
8940 case 0x0b:
8941 case 0x0c:
8942 case 0x0d:
8943 case 0x0e:
8944 goto op_semantics_69;
8945 break;
8946 case 0x0f:
8947 goto op_semantics_70;
8948 break;
8949 }
8950 break;
8951 case 0xee:
8952 GETBYTE ();
8953 switch (op[2] & 0x0f)
8954 {
8955 case 0x00:
8956 case 0x01:
8957 case 0x02:
8958 case 0x03:
8959 case 0x04:
8960 case 0x05:
8961 case 0x06:
8962 case 0x07:
8963 case 0x08:
8964 case 0x09:
8965 case 0x0a:
8966 case 0x0b:
8967 case 0x0c:
8968 case 0x0d:
8969 case 0x0e:
8970 goto op_semantics_69;
8971 break;
8972 case 0x0f:
8973 goto op_semantics_70;
8974 break;
8975 }
8976 break;
8977 case 0xef:
8978 GETBYTE ();
8979 switch (op[2] & 0x0f)
8980 {
8981 case 0x00:
8982 case 0x01:
8983 case 0x02:
8984 case 0x03:
8985 case 0x04:
8986 case 0x05:
8987 case 0x06:
8988 case 0x07:
8989 case 0x08:
8990 case 0x09:
8991 case 0x0a:
8992 case 0x0b:
8993 case 0x0c:
8994 case 0x0d:
8995 case 0x0e:
8996 goto op_semantics_69;
8997 break;
8998 case 0x0f:
8999 goto op_semantics_70;
9000 break;
9001 }
9002 break;
9003 case 0xf0:
9004 GETBYTE ();
9005 switch (op[2] & 0x0f)
9006 {
9007 case 0x00:
9008 case 0x01:
9009 case 0x02:
9010 case 0x03:
9011 case 0x04:
9012 case 0x05:
9013 case 0x06:
9014 case 0x07:
9015 case 0x08:
9016 case 0x09:
9017 case 0x0a:
9018 case 0x0b:
9019 case 0x0c:
9020 case 0x0d:
9021 case 0x0e:
9022 goto op_semantics_69;
9023 break;
9024 case 0x0f:
9025 goto op_semantics_70;
9026 break;
9027 }
9028 break;
9029 case 0xf1:
9030 GETBYTE ();
9031 switch (op[2] & 0x0f)
9032 {
9033 case 0x00:
9034 case 0x01:
9035 case 0x02:
9036 case 0x03:
9037 case 0x04:
9038 case 0x05:
9039 case 0x06:
9040 case 0x07:
9041 case 0x08:
9042 case 0x09:
9043 case 0x0a:
9044 case 0x0b:
9045 case 0x0c:
9046 case 0x0d:
9047 case 0x0e:
9048 goto op_semantics_69;
9049 break;
9050 case 0x0f:
9051 goto op_semantics_70;
9052 break;
9053 }
9054 break;
9055 case 0xf2:
9056 GETBYTE ();
9057 switch (op[2] & 0x0f)
9058 {
9059 case 0x00:
9060 case 0x01:
9061 case 0x02:
9062 case 0x03:
9063 case 0x04:
9064 case 0x05:
9065 case 0x06:
9066 case 0x07:
9067 case 0x08:
9068 case 0x09:
9069 case 0x0a:
9070 case 0x0b:
9071 case 0x0c:
9072 case 0x0d:
9073 case 0x0e:
9074 goto op_semantics_69;
9075 break;
9076 case 0x0f:
9077 goto op_semantics_70;
9078 break;
9079 }
9080 break;
9081 case 0xf3:
9082 GETBYTE ();
9083 switch (op[2] & 0x0f)
9084 {
9085 case 0x00:
9086 case 0x01:
9087 case 0x02:
9088 case 0x03:
9089 case 0x04:
9090 case 0x05:
9091 case 0x06:
9092 case 0x07:
9093 case 0x08:
9094 case 0x09:
9095 case 0x0a:
9096 case 0x0b:
9097 case 0x0c:
9098 case 0x0d:
9099 case 0x0e:
9100 goto op_semantics_69;
9101 break;
9102 case 0x0f:
9103 goto op_semantics_70;
9104 break;
9105 }
9106 break;
9107 case 0xf4:
9108 GETBYTE ();
9109 switch (op[2] & 0x0f)
9110 {
9111 case 0x00:
9112 case 0x01:
9113 case 0x02:
9114 case 0x03:
9115 case 0x04:
9116 case 0x05:
9117 case 0x06:
9118 case 0x07:
9119 case 0x08:
9120 case 0x09:
9121 case 0x0a:
9122 case 0x0b:
9123 case 0x0c:
9124 case 0x0d:
9125 case 0x0e:
9126 goto op_semantics_69;
9127 break;
9128 case 0x0f:
9129 goto op_semantics_70;
9130 break;
9131 }
9132 break;
9133 case 0xf5:
9134 GETBYTE ();
9135 switch (op[2] & 0x0f)
9136 {
9137 case 0x00:
9138 case 0x01:
9139 case 0x02:
9140 case 0x03:
9141 case 0x04:
9142 case 0x05:
9143 case 0x06:
9144 case 0x07:
9145 case 0x08:
9146 case 0x09:
9147 case 0x0a:
9148 case 0x0b:
9149 case 0x0c:
9150 case 0x0d:
9151 case 0x0e:
9152 goto op_semantics_69;
9153 break;
9154 case 0x0f:
9155 goto op_semantics_70;
9156 break;
9157 }
9158 break;
9159 case 0xf6:
9160 GETBYTE ();
9161 switch (op[2] & 0x0f)
9162 {
9163 case 0x00:
9164 case 0x01:
9165 case 0x02:
9166 case 0x03:
9167 case 0x04:
9168 case 0x05:
9169 case 0x06:
9170 case 0x07:
9171 case 0x08:
9172 case 0x09:
9173 case 0x0a:
9174 case 0x0b:
9175 case 0x0c:
9176 case 0x0d:
9177 case 0x0e:
9178 goto op_semantics_69;
9179 break;
9180 case 0x0f:
9181 goto op_semantics_70;
9182 break;
9183 }
9184 break;
9185 case 0xf7:
9186 GETBYTE ();
9187 switch (op[2] & 0x0f)
9188 {
9189 case 0x00:
9190 case 0x01:
9191 case 0x02:
9192 case 0x03:
9193 case 0x04:
9194 case 0x05:
9195 case 0x06:
9196 case 0x07:
9197 case 0x08:
9198 case 0x09:
9199 case 0x0a:
9200 case 0x0b:
9201 case 0x0c:
9202 case 0x0d:
9203 case 0x0e:
9204 goto op_semantics_69;
9205 break;
9206 case 0x0f:
9207 goto op_semantics_70;
9208 break;
9209 }
9210 break;
9211 case 0xf8:
9212 GETBYTE ();
9213 switch (op[2] & 0x0f)
9214 {
9215 case 0x00:
9216 case 0x01:
9217 case 0x02:
9218 case 0x03:
9219 case 0x04:
9220 case 0x05:
9221 case 0x06:
9222 case 0x07:
9223 case 0x08:
9224 case 0x09:
9225 case 0x0a:
9226 case 0x0b:
9227 case 0x0c:
9228 case 0x0d:
9229 case 0x0e:
9230 goto op_semantics_69;
9231 break;
9232 case 0x0f:
9233 goto op_semantics_70;
9234 break;
9235 }
9236 break;
9237 case 0xf9:
9238 GETBYTE ();
9239 switch (op[2] & 0x0f)
9240 {
9241 case 0x00:
9242 case 0x01:
9243 case 0x02:
9244 case 0x03:
9245 case 0x04:
9246 case 0x05:
9247 case 0x06:
9248 case 0x07:
9249 case 0x08:
9250 case 0x09:
9251 case 0x0a:
9252 case 0x0b:
9253 case 0x0c:
9254 case 0x0d:
9255 case 0x0e:
9256 goto op_semantics_69;
9257 break;
9258 case 0x0f:
9259 goto op_semantics_70;
9260 break;
9261 }
9262 break;
9263 case 0xfa:
9264 GETBYTE ();
9265 switch (op[2] & 0x0f)
9266 {
9267 case 0x00:
9268 case 0x01:
9269 case 0x02:
9270 case 0x03:
9271 case 0x04:
9272 case 0x05:
9273 case 0x06:
9274 case 0x07:
9275 case 0x08:
9276 case 0x09:
9277 case 0x0a:
9278 case 0x0b:
9279 case 0x0c:
9280 case 0x0d:
9281 case 0x0e:
9282 goto op_semantics_69;
9283 break;
9284 case 0x0f:
9285 goto op_semantics_70;
9286 break;
9287 }
9288 break;
9289 case 0xfb:
9290 GETBYTE ();
9291 switch (op[2] & 0x0f)
9292 {
9293 case 0x00:
9294 case 0x01:
9295 case 0x02:
9296 case 0x03:
9297 case 0x04:
9298 case 0x05:
9299 case 0x06:
9300 case 0x07:
9301 case 0x08:
9302 case 0x09:
9303 case 0x0a:
9304 case 0x0b:
9305 case 0x0c:
9306 case 0x0d:
9307 case 0x0e:
9308 goto op_semantics_69;
9309 break;
9310 case 0x0f:
9311 goto op_semantics_70;
9312 break;
9313 }
9314 break;
9315 case 0xfc:
9316 GETBYTE ();
9317 switch (op[2] & 0x0f)
9318 {
9319 case 0x00:
9320 case 0x01:
9321 case 0x02:
9322 case 0x03:
9323 case 0x04:
9324 case 0x05:
9325 case 0x06:
9326 case 0x07:
9327 case 0x08:
9328 case 0x09:
9329 case 0x0a:
9330 case 0x0b:
9331 case 0x0c:
9332 case 0x0d:
9333 case 0x0e:
9334 goto op_semantics_69;
9335 break;
9336 case 0x0f:
9337 goto op_semantics_70;
9338 break;
9339 }
9340 break;
9341 case 0xfd:
9342 GETBYTE ();
9343 switch (op[2] & 0x0f)
9344 {
9345 case 0x00:
9346 case 0x01:
9347 case 0x02:
9348 case 0x03:
9349 case 0x04:
9350 case 0x05:
9351 case 0x06:
9352 case 0x07:
9353 case 0x08:
9354 case 0x09:
9355 case 0x0a:
9356 case 0x0b:
9357 case 0x0c:
9358 case 0x0d:
9359 case 0x0e:
9360 goto op_semantics_69;
9361 break;
9362 case 0x0f:
9363 goto op_semantics_70;
9364 break;
9365 }
9366 break;
9367 case 0xfe:
9368 GETBYTE ();
9369 switch (op[2] & 0x0f)
9370 {
9371 case 0x00:
9372 case 0x01:
9373 case 0x02:
9374 case 0x03:
9375 case 0x04:
9376 case 0x05:
9377 case 0x06:
9378 case 0x07:
9379 case 0x08:
9380 case 0x09:
9381 case 0x0a:
9382 case 0x0b:
9383 case 0x0c:
9384 case 0x0d:
9385 case 0x0e:
9386 goto op_semantics_69;
9387 break;
9388 case 0x0f:
9389 goto op_semantics_70;
9390 break;
9391 }
9392 break;
9393 case 0xff:
9394 GETBYTE ();
9395 switch (op[2] & 0x0f)
9396 {
9397 case 0x00:
9398 case 0x01:
9399 case 0x02:
9400 case 0x03:
9401 case 0x04:
9402 case 0x05:
9403 case 0x06:
9404 case 0x07:
9405 case 0x08:
9406 case 0x09:
9407 case 0x0a:
9408 case 0x0b:
9409 case 0x0c:
9410 case 0x0d:
9411 case 0x0e:
9412 goto op_semantics_69;
9413 break;
9414 case 0x0f:
9415 goto op_semantics_70;
9416 break;
9417 }
9418 break;
9419 default: UNSUPPORTED(); break;
9420 }
9421 break;
9422 case 0xfd:
9423 GETBYTE ();
9424 switch (op[1] & 0xff)
9425 {
9426 case 0x00:
9427 GETBYTE ();
9428 switch (op[2] & 0x00)
9429 {
9430 case 0x00:
9431 {
9432 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
f282425e 9433#line 782 "rx-decode.opc"
c7927a3c 9434 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 9435#line 782 "rx-decode.opc"
c7927a3c
NC		 9436 int srcb AU = op[2] & 0x0f;
9437 if (trace)
9438 {
9439 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9440 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9441 op[0], op[1], op[2]);
9442 printf (" srca = 0x%x,", srca);
9443 printf (" srcb = 0x%x\n", srcb);
9444 }
9445 SYNTAX("mulhi %1, %2");
f282425e 9446#line 782 "rx-decode.opc"
c7927a3c
NC		 9447 ID(mulhi); SR(srca); S2R(srcb); F("----");
9448
9449 }
9450 break;
9451 }
9452 break;
9453 case 0x01:
9454 GETBYTE ();
9455 switch (op[2] & 0x00)
9456 {
9457 case 0x00:
9458 {
9459 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
f282425e 9460#line 785 "rx-decode.opc"
c7927a3c 9461 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 9462#line 785 "rx-decode.opc"
c7927a3c
NC		 9463 int srcb AU = op[2] & 0x0f;
9464 if (trace)
9465 {
9466 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9467 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9468 op[0], op[1], op[2]);
9469 printf (" srca = 0x%x,", srca);
9470 printf (" srcb = 0x%x\n", srcb);
9471 }
9472 SYNTAX("mullo %1, %2");
f282425e 9473#line 785 "rx-decode.opc"
c7927a3c
NC		 9474 ID(mullo); SR(srca); S2R(srcb); F("----");
9475
9476 }
9477 break;
9478 }
9479 break;
9480 case 0x04:
9481 GETBYTE ();
9482 switch (op[2] & 0x00)
9483 {
9484 case 0x00:
9485 {
9486 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
f282425e 9487#line 788 "rx-decode.opc"
c7927a3c 9488 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 9489#line 788 "rx-decode.opc"
c7927a3c
NC		 9490 int srcb AU = op[2] & 0x0f;
9491 if (trace)
9492 {
9493 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9494 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9495 op[0], op[1], op[2]);
9496 printf (" srca = 0x%x,", srca);
9497 printf (" srcb = 0x%x\n", srcb);
9498 }
9499 SYNTAX("machi %1, %2");
f282425e 9500#line 788 "rx-decode.opc"
c7927a3c
NC		 9501 ID(machi); SR(srca); S2R(srcb); F("----");
9502
9503 }
9504 break;
9505 }
9506 break;
9507 case 0x05:
9508 GETBYTE ();
9509 switch (op[2] & 0x00)
9510 {
9511 case 0x00:
9512 {
9513 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
f282425e 9514#line 791 "rx-decode.opc"
c7927a3c 9515 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 9516#line 791 "rx-decode.opc"
c7927a3c
NC		 9517 int srcb AU = op[2] & 0x0f;
9518 if (trace)
9519 {
9520 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9521 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9522 op[0], op[1], op[2]);
9523 printf (" srca = 0x%x,", srca);
9524 printf (" srcb = 0x%x\n", srcb);
9525 }
9526 SYNTAX("maclo %1, %2");
f282425e 9527#line 791 "rx-decode.opc"
c7927a3c
NC		 9528 ID(maclo); SR(srca); S2R(srcb); F("----");
9529
9530 }
9531 break;
9532 }
9533 break;
9534 case 0x17:
9535 GETBYTE ();
9536 switch (op[2] & 0xf0)
9537 {
9538 case 0x00:
9539 {
9540 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
f282425e 9541#line 794 "rx-decode.opc"
c7927a3c
NC		 9542 int rsrc AU = op[2] & 0x0f;
9543 if (trace)
9544 {
9545 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9546 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9547 op[0], op[1], op[2]);
9548 printf (" rsrc = 0x%x\n", rsrc);
9549 }
9550 SYNTAX("mvtachi %1");
f282425e 9551#line 794 "rx-decode.opc"
c7927a3c
NC		 9552 ID(mvtachi); SR(rsrc); F("----");
9553
9554 }
9555 break;
9556 case 0x10:
9557 {
9558 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
f282425e 9559#line 797 "rx-decode.opc"
c7927a3c
NC		 9560 int rsrc AU = op[2] & 0x0f;
9561 if (trace)
9562 {
9563 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9564 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9565 op[0], op[1], op[2]);
9566 printf (" rsrc = 0x%x\n", rsrc);
9567 }
9568 SYNTAX("mvtaclo %1");
f282425e 9569#line 797 "rx-decode.opc"
c7927a3c
NC		 9570 ID(mvtaclo); SR(rsrc); F("----");
9571
9572 }
9573 break;
9574 default: UNSUPPORTED(); break;
9575 }
9576 break;
9577 case 0x18:
9578 GETBYTE ();
9579 switch (op[2] & 0xef)
9580 {
9581 case 0x00:
9582 {
9583 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
f282425e 9584#line 809 "rx-decode.opc"
c7927a3c
NC		 9585 int i AU = (op[2] >> 4) & 0x01;
9586 if (trace)
9587 {
9588 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9589 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9590 op[0], op[1], op[2]);
9591 printf (" i = 0x%x\n", i);
9592 }
9593 SYNTAX("racw #%1");
f282425e 9594#line 809 "rx-decode.opc"
c7927a3c
NC		 9595 ID(racw); SC(i+1); F("----");
9596
9597 /*----------------------------------------------------------------------*/
9598 /* SAT */
9599
9600 }
9601 break;
9602 default: UNSUPPORTED(); break;
9603 }
9604 break;
9605 case 0x1f:
9606 GETBYTE ();
9607 switch (op[2] & 0xf0)
9608 {
9609 case 0x00:
9610 {
9611 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
f282425e 9612#line 800 "rx-decode.opc"
c7927a3c
NC		 9613 int rdst AU = op[2] & 0x0f;
9614 if (trace)
9615 {
9616 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9617 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9618 op[0], op[1], op[2]);
9619 printf (" rdst = 0x%x\n", rdst);
9620 }
9621 SYNTAX("mvfachi %0");
f282425e 9622#line 800 "rx-decode.opc"
c7927a3c
NC		 9623 ID(mvfachi); DR(rdst); F("----");
9624
9625 }
9626 break;
9627 case 0x10:
9628 {
9629 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
f282425e 9630#line 806 "rx-decode.opc"
c7927a3c
NC		 9631 int rdst AU = op[2] & 0x0f;
9632 if (trace)
9633 {
9634 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9635 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9636 op[0], op[1], op[2]);
9637 printf (" rdst = 0x%x\n", rdst);
9638 }
9639 SYNTAX("mvfaclo %0");
f282425e 9640#line 806 "rx-decode.opc"
c7927a3c
NC		 9641 ID(mvfaclo); DR(rdst); F("----");
9642
9643 }
9644 break;
9645 case 0x20:
9646 {
9647 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
f282425e 9648#line 803 "rx-decode.opc"
c7927a3c
NC		 9649 int rdst AU = op[2] & 0x0f;
9650 if (trace)
9651 {
9652 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9653 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9654 op[0], op[1], op[2]);
9655 printf (" rdst = 0x%x\n", rdst);
9656 }
9657 SYNTAX("mvfacmi %0");
f282425e 9658#line 803 "rx-decode.opc"
c7927a3c
NC		 9659 ID(mvfacmi); DR(rdst); F("----");
9660
9661 }
9662 break;
9663 default: UNSUPPORTED(); break;
9664 }
9665 break;
9666 case 0x20:
9667 GETBYTE ();
9668 switch (op[2] & 0x00)
9669 {
9670 case 0x00:
9671 op_semantics_71:
9672 {
9673 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
f282425e 9674#line 324 "rx-decode.opc"
c7927a3c 9675 int p AU = (op[1] >> 2) & 0x01;
f282425e 9676#line 324 "rx-decode.opc"
c7927a3c 9677 int sz AU = op[1] & 0x03;
f282425e 9678#line 324 "rx-decode.opc"
c7927a3c 9679 int rdst AU = (op[2] >> 4) & 0x0f;
f282425e 9680#line 324 "rx-decode.opc"
c7927a3c
NC		 9681 int rsrc AU = op[2] & 0x0f;
9682 if (trace)
9683 {
9684 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9685 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9686 op[0], op[1], op[2]);
9687 printf (" p = 0x%x,", p);
9688 printf (" sz = 0x%x,", sz);
9689 printf (" rdst = 0x%x,", rdst);
9690 printf (" rsrc = 0x%x\n", rsrc);
9691 }
9692 SYNTAX("mov%s %1, %0");
f282425e 9693#line 324 "rx-decode.opc"
c7927a3c
NC		 9694 ID(mov); sBWL (sz); SR(rsrc); F("----");
9695 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9696
9697 }
9698 break;
9699 }
9700 break;
9701 case 0x21:
9702 GETBYTE ();
9703 switch (op[2] & 0x00)
9704 {
9705 case 0x00:
9706 goto op_semantics_71;
9707 break;
9708 }
9709 break;
9710 case 0x22:
9711 GETBYTE ();
9712 switch (op[2] & 0x00)
9713 {
9714 case 0x00:
9715 goto op_semantics_71;
9716 break;
9717 }
9718 break;
9719 case 0x24:
9720 GETBYTE ();
9721 switch (op[2] & 0x00)
9722 {
9723 case 0x00:
9724 goto op_semantics_71;
9725 break;
9726 }
9727 break;
9728 case 0x25:
9729 GETBYTE ();
9730 switch (op[2] & 0x00)
9731 {
9732 case 0x00:
9733 goto op_semantics_71;
9734 break;
9735 }
9736 break;
9737 case 0x26:
9738 GETBYTE ();
9739 switch (op[2] & 0x00)
9740 {
9741 case 0x00:
9742 goto op_semantics_71;
9743 break;
9744 }
9745 break;
9746 case 0x28:
9747 GETBYTE ();
9748 switch (op[2] & 0x00)
9749 {
9750 case 0x00:
9751 op_semantics_72:
9752 {
9753 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
f282425e 9754#line 328 "rx-decode.opc"
c7927a3c 9755 int p AU = (op[1] >> 2) & 0x01;
f282425e 9756#line 328 "rx-decode.opc"
c7927a3c 9757 int sz AU = op[1] & 0x03;
f282425e 9758#line 328 "rx-decode.opc"
c7927a3c 9759 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 9760#line 328 "rx-decode.opc"
c7927a3c
NC		 9761 int rdst AU = op[2] & 0x0f;
9762 if (trace)
9763 {
9764 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9765 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9766 op[0], op[1], op[2]);
9767 printf (" p = 0x%x,", p);
9768 printf (" sz = 0x%x,", sz);
9769 printf (" rsrc = 0x%x,", rsrc);
9770 printf (" rdst = 0x%x\n", rdst);
9771 }
9772 SYNTAX("mov%s %1, %0");
f282425e 9773#line 328 "rx-decode.opc"
c7927a3c
NC		 9774 ID(mov); sBWL (sz); DR(rdst); F("----");
9775 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9776
9777 }
9778 break;
9779 }
9780 break;
9781 case 0x29:
9782 GETBYTE ();
9783 switch (op[2] & 0x00)
9784 {
9785 case 0x00:
9786 goto op_semantics_72;
9787 break;
9788 }
9789 break;
9790 case 0x2a:
9791 GETBYTE ();
9792 switch (op[2] & 0x00)
9793 {
9794 case 0x00:
9795 goto op_semantics_72;
9796 break;
9797 }
9798 break;
9799 case 0x2c:
9800 GETBYTE ();
9801 switch (op[2] & 0x00)
9802 {
9803 case 0x00:
9804 goto op_semantics_72;
9805 break;
9806 }
9807 break;
9808 case 0x2d:
9809 GETBYTE ();
9810 switch (op[2] & 0x00)
9811 {
9812 case 0x00:
9813 goto op_semantics_72;
9814 break;
9815 }
9816 break;
9817 case 0x2e:
9818 GETBYTE ();
9819 switch (op[2] & 0x00)
9820 {
9821 case 0x00:
9822 goto op_semantics_72;
9823 break;
9824 }
9825 break;
9826 case 0x38:
9827 GETBYTE ();
9828 switch (op[2] & 0x00)
9829 {
9830 case 0x00:
9831 op_semantics_73:
9832 {
9833 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
f282425e 9834#line 338 "rx-decode.opc"
c7927a3c 9835 int p AU = (op[1] >> 2) & 0x01;
f282425e 9836#line 338 "rx-decode.opc"
c7927a3c 9837 int sz AU = op[1] & 0x03;
f282425e 9838#line 338 "rx-decode.opc"
c7927a3c 9839 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 9840#line 338 "rx-decode.opc"
c7927a3c
NC		 9841 int rdst AU = op[2] & 0x0f;
9842 if (trace)
9843 {
9844 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9845 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9846 op[0], op[1], op[2]);
9847 printf (" p = 0x%x,", p);
9848 printf (" sz = 0x%x,", sz);
9849 printf (" rsrc = 0x%x,", rsrc);
9850 printf (" rdst = 0x%x\n", rdst);
9851 }
9852 SYNTAX("movu%s %1, %0");
f282425e 9853#line 338 "rx-decode.opc"
c7927a3c
NC		 9854 ID(mov); uBWL (sz); DR(rdst); F("----");
9855 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9856
9857 /*----------------------------------------------------------------------*/
9858 /* PUSH/POP */
9859
9860 }
9861 break;
9862 }
9863 break;
9864 case 0x39:
9865 GETBYTE ();
9866 switch (op[2] & 0x00)
9867 {
9868 case 0x00:
9869 goto op_semantics_73;
9870 break;
9871 }
9872 break;
9873 case 0x3a:
9874 GETBYTE ();
9875 switch (op[2] & 0x00)
9876 {
9877 case 0x00:
9878 goto op_semantics_73;
9879 break;
9880 }
9881 break;
9882 case 0x3c:
9883 GETBYTE ();
9884 switch (op[2] & 0x00)
9885 {
9886 case 0x00:
9887 goto op_semantics_73;
9888 break;
9889 }
9890 break;
9891 case 0x3d:
9892 GETBYTE ();
9893 switch (op[2] & 0x00)
9894 {
9895 case 0x00:
9896 goto op_semantics_73;
9897 break;
9898 }
9899 break;
9900 case 0x3e:
9901 GETBYTE ();
9902 switch (op[2] & 0x00)
9903 {
9904 case 0x00:
9905 goto op_semantics_73;
9906 break;
9907 }
9908 break;
9909 case 0x60:
9910 GETBYTE ();
9911 switch (op[2] & 0x00)
9912 {
9913 case 0x00:
9914 {
9915 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
f282425e 9916#line 663 "rx-decode.opc"
c7927a3c 9917 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 9918#line 663 "rx-decode.opc"
c7927a3c
NC		 9919 int rdst AU = op[2] & 0x0f;
9920 if (trace)
9921 {
9922 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9923 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9924 op[0], op[1], op[2]);
9925 printf (" rsrc = 0x%x,", rsrc);
9926 printf (" rdst = 0x%x\n", rdst);
9927 }
9928 SYNTAX("shlr %2, %0");
f282425e 9929#line 663 "rx-decode.opc"
c7927a3c
NC		 9930 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F("-SZC");
9931
9932 }
9933 break;
9934 }
9935 break;
9936 case 0x61:
9937 GETBYTE ();
9938 switch (op[2] & 0x00)
9939 {
9940 case 0x00:
9941 {
9942 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
f282425e 9943#line 653 "rx-decode.opc"
c7927a3c 9944 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 9945#line 653 "rx-decode.opc"
c7927a3c
NC		 9946 int rdst AU = op[2] & 0x0f;
9947 if (trace)
9948 {
9949 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9950 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
9951 op[0], op[1], op[2]);
9952 printf (" rsrc = 0x%x,", rsrc);
9953 printf (" rdst = 0x%x\n", rdst);
9954 }
9955 SYNTAX("shar %2, %0");
f282425e 9956#line 653 "rx-decode.opc"
c7927a3c
NC		 9957 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F("0SZC");
9958
9959 }
9960 break;
9961 }
9962 break;
9963 case 0x62:
9964 GETBYTE ();
9965 switch (op[2] & 0x00)
9966 {
9967 case 0x00:
9968 {
9969 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
f282425e 9970#line 643 "rx-decode.opc"
c7927a3c 9971 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 9972#line 643 "rx-decode.opc"
c7927a3c
NC		 9973 int rdst AU = op[2] & 0x0f;
9974 if (trace)
9975 {
9976 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9977 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
9978 op[0], op[1], op[2]);
9979 printf (" rsrc = 0x%x,", rsrc);
9980 printf (" rdst = 0x%x\n", rdst);
9981 }
9982 SYNTAX("shll %2, %0");
f282425e 9983#line 643 "rx-decode.opc"
c7927a3c
NC		 9984 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F("OSZC");
9985
9986 }
9987 break;
9988 }
9989 break;
9990 case 0x64:
9991 GETBYTE ();
9992 switch (op[2] & 0x00)
9993 {
9994 case 0x00:
9995 {
9996 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
f282425e 9997#line 687 "rx-decode.opc"
c7927a3c 9998 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 9999#line 687 "rx-decode.opc"
c7927a3c
NC		 10000 int rdst AU = op[2] & 0x0f;
10001 if (trace)
10002 {
10003 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10004 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
10005 op[0], op[1], op[2]);
10006 printf (" rsrc = 0x%x,", rsrc);
10007 printf (" rdst = 0x%x\n", rdst);
10008 }
10009 SYNTAX("rotr %1, %0");
f282425e 10010#line 687 "rx-decode.opc"
c7927a3c
NC		 10011 ID(rotr); SR(rsrc); DR(rdst); F("-SZC");
10012
10013 }
10014 break;
10015 }
10016 break;
10017 case 0x65:
10018 GETBYTE ();
10019 switch (op[2] & 0x00)
10020 {
10021 case 0x00:
10022 {
10023 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
f282425e 10024#line 690 "rx-decode.opc"
c7927a3c 10025 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 10026#line 690 "rx-decode.opc"
c7927a3c
NC		 10027 int rdst AU = op[2] & 0x0f;
10028 if (trace)
10029 {
10030 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10031 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10032 op[0], op[1], op[2]);
10033 printf (" rsrc = 0x%x,", rsrc);
10034 printf (" rdst = 0x%x\n", rdst);
10035 }
10036 SYNTAX("revw %1, %0");
f282425e 10037#line 690 "rx-decode.opc"
c7927a3c
NC		 10038 ID(revw); SR(rsrc); DR(rdst);
10039
10040 }
10041 break;
10042 }
10043 break;
10044 case 0x66:
10045 GETBYTE ();
10046 switch (op[2] & 0x00)
10047 {
10048 case 0x00:
10049 {
10050 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
f282425e 10051#line 681 "rx-decode.opc"
c7927a3c 10052 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 10053#line 681 "rx-decode.opc"
c7927a3c
NC		 10054 int rdst AU = op[2] & 0x0f;
10055 if (trace)
10056 {
10057 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10058 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10059 op[0], op[1], op[2]);
10060 printf (" rsrc = 0x%x,", rsrc);
10061 printf (" rdst = 0x%x\n", rdst);
10062 }
10063 SYNTAX("rotl %1, %0");
f282425e 10064#line 681 "rx-decode.opc"
c7927a3c
NC		 10065 ID(rotl); SR(rsrc); DR(rdst); F("-SZC");
10066
10067 }
10068 break;
10069 }
10070 break;
10071 case 0x67:
10072 GETBYTE ();
10073 switch (op[2] & 0x00)
10074 {
10075 case 0x00:
10076 {
10077 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
f282425e 10078#line 693 "rx-decode.opc"
c7927a3c 10079 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 10080#line 693 "rx-decode.opc"
c7927a3c
NC		 10081 int rdst AU = op[2] & 0x0f;
10082 if (trace)
10083 {
10084 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10085 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10086 op[0], op[1], op[2]);
10087 printf (" rsrc = 0x%x,", rsrc);
10088 printf (" rdst = 0x%x\n", rdst);
10089 }
10090 SYNTAX("revl %1, %0");
f282425e 10091#line 693 "rx-decode.opc"
c7927a3c
NC		 10092 ID(revl); SR(rsrc); DR(rdst);
10093
10094 /*----------------------------------------------------------------------*/
10095 /* BRANCH */
10096
10097 }
10098 break;
10099 }
10100 break;
10101 case 0x68:
10102 GETBYTE ();
10103 switch (op[2] & 0x00)
10104 {
10105 case 0x00:
10106 op_semantics_74:
10107 {
10108 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
946ef196 10109#line 936 "rx-decode.opc"
c7927a3c 10110 int c AU = op[1] & 0x01;
946ef196 10111#line 936 "rx-decode.opc"
c7927a3c 10112 int rsrc AU = (op[2] >> 4) & 0x0f;
946ef196 10113#line 936 "rx-decode.opc"
c7927a3c
NC		 10114 int rdst AU = op[2] & 0x0f;
10115 if (trace)
10116 {
10117 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10118 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10119 op[0], op[1], op[2]);
10120 printf (" c = 0x%x,", c);
10121 printf (" rsrc = 0x%x,", rsrc);
10122 printf (" rdst = 0x%x\n", rdst);
10123 }
10124 SYNTAX("mvtc %1, %0");
946ef196 10125#line 936 "rx-decode.opc"
c7927a3c
NC		 10126 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10127
10128 }
10129 break;
10130 }
10131 break;
10132 case 0x69:
10133 GETBYTE ();
10134 switch (op[2] & 0x00)
10135 {
10136 case 0x00:
10137 goto op_semantics_74;
10138 break;
10139 }
10140 break;
10141 case 0x6a:
10142 GETBYTE ();
10143 switch (op[2] & 0x00)
10144 {
10145 case 0x00:
10146 op_semantics_75:
10147 {
10148 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
946ef196 10149#line 939 "rx-decode.opc"
c7927a3c 10150 int s AU = op[1] & 0x01;
946ef196 10151#line 939 "rx-decode.opc"
c7927a3c 10152 int rsrc AU = (op[2] >> 4) & 0x0f;
946ef196 10153#line 939 "rx-decode.opc"
c7927a3c
NC		 10154 int rdst AU = op[2] & 0x0f;
10155 if (trace)
10156 {
10157 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10158 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10159 op[0], op[1], op[2]);
10160 printf (" s = 0x%x,", s);
10161 printf (" rsrc = 0x%x,", rsrc);
10162 printf (" rdst = 0x%x\n", rdst);
10163 }
10164 SYNTAX("mvfc %1, %0");
946ef196 10165#line 939 "rx-decode.opc"
c7927a3c
NC		 10166 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10167
946ef196
DD		 10168 /*----------------------------------------------------------------------*/
10169 /* INTERRUPTS */
10170
c7927a3c
NC		 10171 }
10172 break;
10173 }
10174 break;
10175 case 0x6b:
10176 GETBYTE ();
10177 switch (op[2] & 0x00)
10178 {
10179 case 0x00:
10180 goto op_semantics_75;
10181 break;
10182 }
10183 break;
10184 case 0x6c:
10185 GETBYTE ();
10186 switch (op[2] & 0x00)
10187 {
10188 case 0x00:
10189 op_semantics_76:
10190 {
10191 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
f282425e 10192#line 684 "rx-decode.opc"
c7927a3c 10193 int i AU = op[1] & 0x01;
f282425e 10194#line 684 "rx-decode.opc"
c7927a3c 10195 int mmmm AU = (op[2] >> 4) & 0x0f;
f282425e 10196#line 684 "rx-decode.opc"
c7927a3c
NC		 10197 int rdst AU = op[2] & 0x0f;
10198 if (trace)
10199 {
10200 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10201 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10202 op[0], op[1], op[2]);
10203 printf (" i = 0x%x,", i);
10204 printf (" mmmm = 0x%x,", mmmm);
10205 printf (" rdst = 0x%x\n", rdst);
10206 }
10207 SYNTAX("rotr #%1, %0");
f282425e 10208#line 684 "rx-decode.opc"
c7927a3c
NC		 10209 ID(rotr); SC(i*16+mmmm); DR(rdst); F("-SZC");
10210
10211 }
10212 break;
10213 }
10214 break;
10215 case 0x6d:
10216 GETBYTE ();
10217 switch (op[2] & 0x00)
10218 {
10219 case 0x00:
10220 goto op_semantics_76;
10221 break;
10222 }
10223 break;
10224 case 0x6e:
10225 GETBYTE ();
10226 switch (op[2] & 0x00)
10227 {
10228 case 0x00:
10229 op_semantics_77:
10230 {
10231 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
f282425e 10232#line 678 "rx-decode.opc"
c7927a3c 10233 int i AU = op[1] & 0x01;
f282425e 10234#line 678 "rx-decode.opc"
c7927a3c 10235 int mmmm AU = (op[2] >> 4) & 0x0f;
f282425e 10236#line 678 "rx-decode.opc"
c7927a3c
NC		 10237 int rdst AU = op[2] & 0x0f;
10238 if (trace)
10239 {
10240 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10241 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10242 op[0], op[1], op[2]);
10243 printf (" i = 0x%x,", i);
10244 printf (" mmmm = 0x%x,", mmmm);
10245 printf (" rdst = 0x%x\n", rdst);
10246 }
10247 SYNTAX("rotl #%1, %0");
f282425e 10248#line 678 "rx-decode.opc"
c7927a3c
NC		 10249 ID(rotl); SC(i*16+mmmm); DR(rdst); F("-SZC");
10250
10251 }
10252 break;
10253 }
10254 break;
10255 case 0x6f:
10256 GETBYTE ();
10257 switch (op[2] & 0x00)
10258 {
10259 case 0x00:
10260 goto op_semantics_77;
10261 break;
10262 }
10263 break;
10264 case 0x70:
10265 GETBYTE ();
10266 switch (op[2] & 0xf0)
10267 {
10268 case 0x20:
10269 op_semantics_78:
10270 {
10271 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
f282425e 10272#line 468 "rx-decode.opc"
c7927a3c 10273 int im AU = (op[1] >> 2) & 0x03;
f282425e 10274#line 468 "rx-decode.opc"
c7927a3c
NC		 10275 int rdst AU = op[2] & 0x0f;
10276 if (trace)
10277 {
10278 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10279 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10280 op[0], op[1], op[2]);
10281 printf (" im = 0x%x,", im);
10282 printf (" rdst = 0x%x\n", rdst);
10283 }
10284 SYNTAX("adc #%1, %0");
f282425e 10285#line 468 "rx-decode.opc"
c7927a3c
NC		 10286 ID(adc); SC(IMMex(im)); DR(rdst); F("OSZC");
10287
10288 }
10289 break;
10290 case 0x40:
10291 op_semantics_79:
10292 {
10293 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
f282425e 10294#line 550 "rx-decode.opc"
c7927a3c 10295 int im AU = (op[1] >> 2) & 0x03;
f282425e 10296#line 550 "rx-decode.opc"
c7927a3c
NC		 10297 int rdst AU = op[2] & 0x0f;
10298 if (trace)
10299 {
10300 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10301 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10302 op[0], op[1], op[2]);
10303 printf (" im = 0x%x,", im);
10304 printf (" rdst = 0x%x\n", rdst);
10305 }
10306 SYNTAX("max #%1, %0");
f282425e 10307#line 550 "rx-decode.opc"
c7927a3c
NC		 10308 ID(max); DR(rdst); SC(IMMex(im));
10309
10310 }
10311 break;
10312 case 0x50:
10313 op_semantics_80:
10314 {
10315 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
f282425e 10316#line 562 "rx-decode.opc"
c7927a3c 10317 int im AU = (op[1] >> 2) & 0x03;
f282425e 10318#line 562 "rx-decode.opc"
c7927a3c
NC		 10319 int rdst AU = op[2] & 0x0f;
10320 if (trace)
10321 {
10322 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10323 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10324 op[0], op[1], op[2]);
10325 printf (" im = 0x%x,", im);
10326 printf (" rdst = 0x%x\n", rdst);
10327 }
10328 SYNTAX("min #%1, %0");
f282425e 10329#line 562 "rx-decode.opc"
c7927a3c
NC		 10330 ID(min); DR(rdst); SC(IMMex(im));
10331
10332 }
10333 break;
10334 case 0x60:
10335 op_semantics_81:
10336 {
10337 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
f282425e 10338#line 592 "rx-decode.opc"
c7927a3c 10339 int im AU = (op[1] >> 2) & 0x03;
f282425e 10340#line 592 "rx-decode.opc"
c7927a3c
NC		 10341 int rdst AU = op[2] & 0x0f;
10342 if (trace)
10343 {
10344 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10345 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10346 op[0], op[1], op[2]);
10347 printf (" im = 0x%x,", im);
10348 printf (" rdst = 0x%x\n", rdst);
10349 }
10350 SYNTAX("emul #%1, %0");
f282425e 10351#line 592 "rx-decode.opc"
c7927a3c
NC		 10352 ID(emul); DR(rdst); SC(IMMex(im));
10353
10354 }
10355 break;
10356 case 0x70:
10357 op_semantics_82:
10358 {
10359 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
f282425e 10360#line 604 "rx-decode.opc"
c7927a3c 10361 int im AU = (op[1] >> 2) & 0x03;
f282425e 10362#line 604 "rx-decode.opc"
c7927a3c
NC		 10363 int rdst AU = op[2] & 0x0f;
10364 if (trace)
10365 {
10366 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10367 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10368 op[0], op[1], op[2]);
10369 printf (" im = 0x%x,", im);
10370 printf (" rdst = 0x%x\n", rdst);
10371 }
10372 SYNTAX("emulu #%1, %0");
f282425e 10373#line 604 "rx-decode.opc"
c7927a3c
NC		 10374 ID(emulu); DR(rdst); SC(IMMex(im));
10375
10376 }
10377 break;
10378 case 0x80:
10379 op_semantics_83:
10380 {
10381 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
f282425e 10382#line 616 "rx-decode.opc"
c7927a3c 10383 int im AU = (op[1] >> 2) & 0x03;
f282425e 10384#line 616 "rx-decode.opc"
c7927a3c
NC		 10385 int rdst AU = op[2] & 0x0f;
10386 if (trace)
10387 {
10388 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10389 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10390 op[0], op[1], op[2]);
10391 printf (" im = 0x%x,", im);
10392 printf (" rdst = 0x%x\n", rdst);
10393 }
10394 SYNTAX("div #%1, %0");
f282425e 10395#line 616 "rx-decode.opc"
c7927a3c
NC		 10396 ID(div); DR(rdst); SC(IMMex(im)); F("O---");
10397
10398 }
10399 break;
10400 case 0x90:
10401 op_semantics_84:
10402 {
10403 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
f282425e 10404#line 628 "rx-decode.opc"
c7927a3c 10405 int im AU = (op[1] >> 2) & 0x03;
f282425e 10406#line 628 "rx-decode.opc"
c7927a3c
NC		 10407 int rdst AU = op[2] & 0x0f;
10408 if (trace)
10409 {
10410 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10411 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10412 op[0], op[1], op[2]);
10413 printf (" im = 0x%x,", im);
10414 printf (" rdst = 0x%x\n", rdst);
10415 }
10416 SYNTAX("divu #%1, %0");
f282425e 10417#line 628 "rx-decode.opc"
c7927a3c
NC		 10418 ID(divu); DR(rdst); SC(IMMex(im)); F("O---");
10419
10420 }
10421 break;
10422 case 0xc0:
10423 op_semantics_85:
10424 {
10425 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
f282425e 10426#line 447 "rx-decode.opc"
c7927a3c 10427 int im AU = (op[1] >> 2) & 0x03;
f282425e 10428#line 447 "rx-decode.opc"
c7927a3c
NC		 10429 int rdst AU = op[2] & 0x0f;
10430 if (trace)
10431 {
10432 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10433 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
10434 op[0], op[1], op[2]);
10435 printf (" im = 0x%x,", im);
10436 printf (" rdst = 0x%x\n", rdst);
10437 }
10438 SYNTAX("tst #%1, %2");
f282425e 10439#line 447 "rx-decode.opc"
c7927a3c
NC		 10440 ID(and); SC(IMMex(im)); S2R(rdst); F("-SZ-");
10441
10442 }
10443 break;
10444 case 0xd0:
10445 op_semantics_86:
10446 {
10447 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
f282425e 10448#line 426 "rx-decode.opc"
c7927a3c 10449 int im AU = (op[1] >> 2) & 0x03;
f282425e 10450#line 426 "rx-decode.opc"
c7927a3c
NC		 10451 int rdst AU = op[2] & 0x0f;
10452 if (trace)
10453 {
10454 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10455 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10456 op[0], op[1], op[2]);
10457 printf (" im = 0x%x,", im);
10458 printf (" rdst = 0x%x\n", rdst);
10459 }
10460 SYNTAX("xor #%1, %0");
f282425e 10461#line 426 "rx-decode.opc"
c7927a3c
NC		 10462 ID(xor); SC(IMMex(im)); DR(rdst); F("-SZ-");
10463
10464 }
10465 break;
10466 case 0xe0:
10467 op_semantics_87:
10468 {
10469 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
f282425e 10470#line 372 "rx-decode.opc"
c7927a3c 10471 int im AU = (op[1] >> 2) & 0x03;
f282425e 10472#line 372 "rx-decode.opc"
c7927a3c
NC		 10473 int rdst AU = op[2] & 0x0f;
10474 if (trace)
10475 {
10476 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10477 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10478 op[0], op[1], op[2]);
10479 printf (" im = 0x%x,", im);
10480 printf (" rdst = 0x%x\n", rdst);
10481 }
10482 SYNTAX("stz #%1, %0");
f282425e 10483#line 372 "rx-decode.opc"
c7927a3c
NC		 10484 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10485
10486 }
10487 break;
10488 case 0xf0:
10489 op_semantics_88:
10490 {
10491 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
f282425e 10492#line 375 "rx-decode.opc"
c7927a3c 10493 int im AU = (op[1] >> 2) & 0x03;
f282425e 10494#line 375 "rx-decode.opc"
c7927a3c
NC		 10495 int rdst AU = op[2] & 0x0f;
10496 if (trace)
10497 {
10498 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10499 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10500 op[0], op[1], op[2]);
10501 printf (" im = 0x%x,", im);
10502 printf (" rdst = 0x%x\n", rdst);
10503 }
10504 SYNTAX("stnz #%1, %0");
f282425e 10505#line 375 "rx-decode.opc"
c7927a3c
NC		 10506 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10507
10508 /*----------------------------------------------------------------------*/
10509 /* RTSD */
10510
10511 }
10512 break;
10513 default: UNSUPPORTED(); break;
10514 }
10515 break;
10516 case 0x72:
10517 GETBYTE ();
10518 switch (op[2] & 0xf0)
10519 {
10520 case 0x00:
10521 {
10522 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
f282425e 10523#line 836 "rx-decode.opc"
c7927a3c
NC		 10524 int rdst AU = op[2] & 0x0f;
10525 if (trace)
10526 {
10527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10528 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
10529 op[0], op[1], op[2]);
10530 printf (" rdst = 0x%x\n", rdst);
10531 }
10532 SYNTAX("fsub #%1, %0");
f282425e 10533#line 836 "rx-decode.opc"
c7927a3c
NC		 10534 ID(fsub); DR(rdst); SC(IMM(0)); F("-SZ-");
10535
10536 }
10537 break;
10538 case 0x10:
10539 {
10540 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
f282425e 10541#line 830 "rx-decode.opc"
c7927a3c
NC		 10542 int rdst AU = op[2] & 0x0f;
10543 if (trace)
10544 {
10545 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10546 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10547 op[0], op[1], op[2]);
10548 printf (" rdst = 0x%x\n", rdst);
10549 }
10550 SYNTAX("fcmp #%1, %0");
f282425e 10551#line 830 "rx-decode.opc"
c7927a3c
NC		 10552 ID(fcmp); DR(rdst); SC(IMM(0)); F("OSZ-");
10553
10554 }
10555 break;
10556 case 0x20:
10557 {
10558 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
f282425e 10559#line 824 "rx-decode.opc"
c7927a3c
NC		 10560 int rdst AU = op[2] & 0x0f;
10561 if (trace)
10562 {
10563 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10564 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10565 op[0], op[1], op[2]);
10566 printf (" rdst = 0x%x\n", rdst);
10567 }
10568 SYNTAX("fadd #%1, %0");
f282425e 10569#line 824 "rx-decode.opc"
c7927a3c
NC		 10570 ID(fadd); DR(rdst); SC(IMM(0)); F("-SZ-");
10571
10572 }
10573 break;
10574 case 0x30:
10575 {
10576 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
f282425e 10577#line 845 "rx-decode.opc"
c7927a3c
NC		 10578 int rdst AU = op[2] & 0x0f;
10579 if (trace)
10580 {
10581 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10582 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10583 op[0], op[1], op[2]);
10584 printf (" rdst = 0x%x\n", rdst);
10585 }
10586 SYNTAX("fmul #%1, %0");
f282425e 10587#line 845 "rx-decode.opc"
c7927a3c
NC		 10588 ID(fmul); DR(rdst); SC(IMM(0)); F("-SZ-");
10589
10590 }
10591 break;
10592 case 0x40:
10593 {
10594 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
f282425e 10595#line 851 "rx-decode.opc"
c7927a3c
NC		 10596 int rdst AU = op[2] & 0x0f;
10597 if (trace)
10598 {
10599 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10600 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10601 op[0], op[1], op[2]);
10602 printf (" rdst = 0x%x\n", rdst);
10603 }
10604 SYNTAX("fdiv #%1, %0");
f282425e 10605#line 851 "rx-decode.opc"
c7927a3c
NC		 10606 ID(fdiv); DR(rdst); SC(IMM(0)); F("-SZ-");
10607
10608 }
10609 break;
10610 default: UNSUPPORTED(); break;
10611 }
10612 break;
10613 case 0x73:
10614 GETBYTE ();
10615 switch (op[2] & 0xe0)
10616 {
10617 case 0x00:
10618 op_semantics_89:
10619 {
10620 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
946ef196 10621#line 933 "rx-decode.opc"
c7927a3c 10622 int im AU = (op[1] >> 2) & 0x03;
946ef196 10623#line 933 "rx-decode.opc"
c7927a3c
NC		 10624 int crdst AU = op[2] & 0x1f;
10625 if (trace)
10626 {
10627 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10628 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10629 op[0], op[1], op[2]);
10630 printf (" im = 0x%x,", im);
10631 printf (" crdst = 0x%x\n", crdst);
10632 }
10633 SYNTAX("mvtc #%1, %0");
946ef196 10634#line 933 "rx-decode.opc"
c7927a3c
NC		 10635 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10636
10637 }
10638 break;
10639 default: UNSUPPORTED(); break;
10640 }
10641 break;
10642 case 0x74:
10643 GETBYTE ();
10644 switch (op[2] & 0xf0)
10645 {
10646 case 0x20:
10647 goto op_semantics_78;
10648 break;
10649 case 0x40:
10650 goto op_semantics_79;
10651 break;
10652 case 0x50:
10653 goto op_semantics_80;
10654 break;
10655 case 0x60:
10656 goto op_semantics_81;
10657 break;
10658 case 0x70:
10659 goto op_semantics_82;
10660 break;
10661 case 0x80:
10662 goto op_semantics_83;
10663 break;
10664 case 0x90:
10665 goto op_semantics_84;
10666 break;
10667 case 0xc0:
10668 goto op_semantics_85;
10669 break;
10670 case 0xd0:
10671 goto op_semantics_86;
10672 break;
10673 case 0xe0:
10674 goto op_semantics_87;
10675 break;
10676 case 0xf0:
10677 goto op_semantics_88;
10678 break;
10679 default: UNSUPPORTED(); break;
10680 }
10681 break;
10682 case 0x77:
10683 GETBYTE ();
10684 switch (op[2] & 0xe0)
10685 {
10686 case 0x00:
10687 goto op_semantics_89;
10688 break;
10689 default: UNSUPPORTED(); break;
10690 }
10691 break;
10692 case 0x78:
10693 GETBYTE ();
10694 switch (op[2] & 0xf0)
10695 {
10696 case 0x20:
10697 goto op_semantics_78;
10698 break;
10699 case 0x40:
10700 goto op_semantics_79;
10701 break;
10702 case 0x50:
10703 goto op_semantics_80;
10704 break;
10705 case 0x60:
10706 goto op_semantics_81;
10707 break;
10708 case 0x70:
10709 goto op_semantics_82;
10710 break;
10711 case 0x80:
10712 goto op_semantics_83;
10713 break;
10714 case 0x90:
10715 goto op_semantics_84;
10716 break;
10717 case 0xc0:
10718 goto op_semantics_85;
10719 break;
10720 case 0xd0:
10721 goto op_semantics_86;
10722 break;
10723 case 0xe0:
10724 goto op_semantics_87;
10725 break;
10726 case 0xf0:
10727 goto op_semantics_88;
10728 break;
10729 default: UNSUPPORTED(); break;
10730 }
10731 break;
10732 case 0x7b:
10733 GETBYTE ();
10734 switch (op[2] & 0xe0)
10735 {
10736 case 0x00:
10737 goto op_semantics_89;
10738 break;
10739 default: UNSUPPORTED(); break;
10740 }
10741 break;
10742 case 0x7c:
10743 GETBYTE ();
10744 switch (op[2] & 0xf0)
10745 {
10746 case 0x20:
10747 goto op_semantics_78;
10748 break;
10749 case 0x40:
10750 goto op_semantics_79;
10751 break;
10752 case 0x50:
10753 goto op_semantics_80;
10754 break;
10755 case 0x60:
10756 goto op_semantics_81;
10757 break;
10758 case 0x70:
10759 goto op_semantics_82;
10760 break;
10761 case 0x80:
10762 goto op_semantics_83;
10763 break;
10764 case 0x90:
10765 goto op_semantics_84;
10766 break;
10767 case 0xc0:
10768 goto op_semantics_85;
10769 break;
10770 case 0xd0:
10771 goto op_semantics_86;
10772 break;
10773 case 0xe0:
10774 goto op_semantics_87;
10775 break;
10776 case 0xf0:
10777 goto op_semantics_88;
10778 break;
10779 default: UNSUPPORTED(); break;
10780 }
10781 break;
10782 case 0x7f:
10783 GETBYTE ();
10784 switch (op[2] & 0xe0)
10785 {
10786 case 0x00:
10787 goto op_semantics_89;
10788 break;
10789 default: UNSUPPORTED(); break;
10790 }
10791 break;
10792 case 0x80:
10793 GETBYTE ();
10794 switch (op[2] & 0x00)
10795 {
10796 case 0x00:
10797 op_semantics_90:
10798 {
10799 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
f282425e 10800#line 666 "rx-decode.opc"
c7927a3c 10801 int immmm AU = op[1] & 0x1f;
f282425e 10802#line 666 "rx-decode.opc"
c7927a3c 10803 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 10804#line 666 "rx-decode.opc"
c7927a3c
NC		 10805 int rdst AU = op[2] & 0x0f;
10806 if (trace)
10807 {
10808 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10809 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10810 op[0], op[1], op[2]);
10811 printf (" immmm = 0x%x,", immmm);
10812 printf (" rsrc = 0x%x,", rsrc);
10813 printf (" rdst = 0x%x\n", rdst);
10814 }
10815 SYNTAX("shlr #%2, %1, %0");
f282425e 10816#line 666 "rx-decode.opc"
c7927a3c
NC		 10817 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F("-SZC");
10818
10819 /*----------------------------------------------------------------------*/
10820 /* ROTATE */
10821
10822 }
10823 break;
10824 }
10825 break;
10826 case 0x81:
10827 GETBYTE ();
10828 switch (op[2] & 0x00)
10829 {
10830 case 0x00:
10831 goto op_semantics_90;
10832 break;
10833 }
10834 break;
10835 case 0x82:
10836 GETBYTE ();
10837 switch (op[2] & 0x00)
10838 {
10839 case 0x00:
10840 goto op_semantics_90;
10841 break;
10842 }
10843 break;
10844 case 0x83:
10845 GETBYTE ();
10846 switch (op[2] & 0x00)
10847 {
10848 case 0x00:
10849 goto op_semantics_90;
10850 break;
10851 }
10852 break;
10853 case 0x84:
10854 GETBYTE ();
10855 switch (op[2] & 0x00)
10856 {
10857 case 0x00:
10858 goto op_semantics_90;
10859 break;
10860 }
10861 break;
10862 case 0x85:
10863 GETBYTE ();
10864 switch (op[2] & 0x00)
10865 {
10866 case 0x00:
10867 goto op_semantics_90;
10868 break;
10869 }
10870 break;
10871 case 0x86:
10872 GETBYTE ();
10873 switch (op[2] & 0x00)
10874 {
10875 case 0x00:
10876 goto op_semantics_90;
10877 break;
10878 }
10879 break;
10880 case 0x87:
10881 GETBYTE ();
10882 switch (op[2] & 0x00)
10883 {
10884 case 0x00:
10885 goto op_semantics_90;
10886 break;
10887 }
10888 break;
10889 case 0x88:
10890 GETBYTE ();
10891 switch (op[2] & 0x00)
10892 {
10893 case 0x00:
10894 goto op_semantics_90;
10895 break;
10896 }
10897 break;
10898 case 0x89:
10899 GETBYTE ();
10900 switch (op[2] & 0x00)
10901 {
10902 case 0x00:
10903 goto op_semantics_90;
10904 break;
10905 }
10906 break;
10907 case 0x8a:
10908 GETBYTE ();
10909 switch (op[2] & 0x00)
10910 {
10911 case 0x00:
10912 goto op_semantics_90;
10913 break;
10914 }
10915 break;
10916 case 0x8b:
10917 GETBYTE ();
10918 switch (op[2] & 0x00)
10919 {
10920 case 0x00:
10921 goto op_semantics_90;
10922 break;
10923 }
10924 break;
10925 case 0x8c:
10926 GETBYTE ();
10927 switch (op[2] & 0x00)
10928 {
10929 case 0x00:
10930 goto op_semantics_90;
10931 break;
10932 }
10933 break;
10934 case 0x8d:
10935 GETBYTE ();
10936 switch (op[2] & 0x00)
10937 {
10938 case 0x00:
10939 goto op_semantics_90;
10940 break;
10941 }
10942 break;
10943 case 0x8e:
10944 GETBYTE ();
10945 switch (op[2] & 0x00)
10946 {
10947 case 0x00:
10948 goto op_semantics_90;
10949 break;
10950 }
10951 break;
10952 case 0x8f:
10953 GETBYTE ();
10954 switch (op[2] & 0x00)
10955 {
10956 case 0x00:
10957 goto op_semantics_90;
10958 break;
10959 }
10960 break;
10961 case 0x90:
10962 GETBYTE ();
10963 switch (op[2] & 0x00)
10964 {
10965 case 0x00:
10966 goto op_semantics_90;
10967 break;
10968 }
10969 break;
10970 case 0x91:
10971 GETBYTE ();
10972 switch (op[2] & 0x00)
10973 {
10974 case 0x00:
10975 goto op_semantics_90;
10976 break;
10977 }
10978 break;
10979 case 0x92:
10980 GETBYTE ();
10981 switch (op[2] & 0x00)
10982 {
10983 case 0x00:
10984 goto op_semantics_90;
10985 break;
10986 }
10987 break;
10988 case 0x93:
10989 GETBYTE ();
10990 switch (op[2] & 0x00)
10991 {
10992 case 0x00:
10993 goto op_semantics_90;
10994 break;
10995 }
10996 break;
10997 case 0x94:
10998 GETBYTE ();
10999 switch (op[2] & 0x00)
11000 {
11001 case 0x00:
11002 goto op_semantics_90;
11003 break;
11004 }
11005 break;
11006 case 0x95:
11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11009 {
11010 case 0x00:
11011 goto op_semantics_90;
11012 break;
11013 }
11014 break;
11015 case 0x96:
11016 GETBYTE ();
11017 switch (op[2] & 0x00)
11018 {
11019 case 0x00:
11020 goto op_semantics_90;
11021 break;
11022 }
11023 break;
11024 case 0x97:
11025 GETBYTE ();
11026 switch (op[2] & 0x00)
11027 {
11028 case 0x00:
11029 goto op_semantics_90;
11030 break;
11031 }
11032 break;
11033 case 0x98:
11034 GETBYTE ();
11035 switch (op[2] & 0x00)
11036 {
11037 case 0x00:
11038 goto op_semantics_90;
11039 break;
11040 }
11041 break;
11042 case 0x99:
11043 GETBYTE ();
11044 switch (op[2] & 0x00)
11045 {
11046 case 0x00:
11047 goto op_semantics_90;
11048 break;
11049 }
11050 break;
11051 case 0x9a:
11052 GETBYTE ();
11053 switch (op[2] & 0x00)
11054 {
11055 case 0x00:
11056 goto op_semantics_90;
11057 break;
11058 }
11059 break;
11060 case 0x9b:
11061 GETBYTE ();
11062 switch (op[2] & 0x00)
11063 {
11064 case 0x00:
11065 goto op_semantics_90;
11066 break;
11067 }
11068 break;
11069 case 0x9c:
11070 GETBYTE ();
11071 switch (op[2] & 0x00)
11072 {
11073 case 0x00:
11074 goto op_semantics_90;
11075 break;
11076 }
11077 break;
11078 case 0x9d:
11079 GETBYTE ();
11080 switch (op[2] & 0x00)
11081 {
11082 case 0x00:
11083 goto op_semantics_90;
11084 break;
11085 }
11086 break;
11087 case 0x9e:
11088 GETBYTE ();
11089 switch (op[2] & 0x00)
11090 {
11091 case 0x00:
11092 goto op_semantics_90;
11093 break;
11094 }
11095 break;
11096 case 0x9f:
11097 GETBYTE ();
11098 switch (op[2] & 0x00)
11099 {
11100 case 0x00:
11101 goto op_semantics_90;
11102 break;
11103 }
11104 break;
11105 case 0xa0:
11106 GETBYTE ();
11107 switch (op[2] & 0x00)
11108 {
11109 case 0x00:
11110 op_semantics_91:
11111 {
11112 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
f282425e 11113#line 656 "rx-decode.opc"
c7927a3c 11114 int immmm AU = op[1] & 0x1f;
f282425e 11115#line 656 "rx-decode.opc"
c7927a3c 11116 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 11117#line 656 "rx-decode.opc"
c7927a3c
NC		 11118 int rdst AU = op[2] & 0x0f;
11119 if (trace)
11120 {
11121 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11122 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11123 op[0], op[1], op[2]);
11124 printf (" immmm = 0x%x,", immmm);
11125 printf (" rsrc = 0x%x,", rsrc);
11126 printf (" rdst = 0x%x\n", rdst);
11127 }
11128 SYNTAX("shar #%2, %1, %0");
f282425e 11129#line 656 "rx-decode.opc"
c7927a3c
NC		 11130 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F("0SZC");
11131
11132
11133 }
11134 break;
11135 }
11136 break;
11137 case 0xa1:
11138 GETBYTE ();
11139 switch (op[2] & 0x00)
11140 {
11141 case 0x00:
11142 goto op_semantics_91;
11143 break;
11144 }
11145 break;
11146 case 0xa2:
11147 GETBYTE ();
11148 switch (op[2] & 0x00)
11149 {
11150 case 0x00:
11151 goto op_semantics_91;
11152 break;
11153 }
11154 break;
11155 case 0xa3:
11156 GETBYTE ();
11157 switch (op[2] & 0x00)
11158 {
11159 case 0x00:
11160 goto op_semantics_91;
11161 break;
11162 }
11163 break;
11164 case 0xa4:
11165 GETBYTE ();
11166 switch (op[2] & 0x00)
11167 {
11168 case 0x00:
11169 goto op_semantics_91;
11170 break;
11171 }
11172 break;
11173 case 0xa5:
11174 GETBYTE ();
11175 switch (op[2] & 0x00)
11176 {
11177 case 0x00:
11178 goto op_semantics_91;
11179 break;
11180 }
11181 break;
11182 case 0xa6:
11183 GETBYTE ();
11184 switch (op[2] & 0x00)
11185 {
11186 case 0x00:
11187 goto op_semantics_91;
11188 break;
11189 }
11190 break;
11191 case 0xa7:
11192 GETBYTE ();
11193 switch (op[2] & 0x00)
11194 {
11195 case 0x00:
11196 goto op_semantics_91;
11197 break;
11198 }
11199 break;
11200 case 0xa8:
11201 GETBYTE ();
11202 switch (op[2] & 0x00)
11203 {
11204 case 0x00:
11205 goto op_semantics_91;
11206 break;
11207 }
11208 break;
11209 case 0xa9:
11210 GETBYTE ();
11211 switch (op[2] & 0x00)
11212 {
11213 case 0x00:
11214 goto op_semantics_91;
11215 break;
11216 }
11217 break;
11218 case 0xaa:
11219 GETBYTE ();
11220 switch (op[2] & 0x00)
11221 {
11222 case 0x00:
11223 goto op_semantics_91;
11224 break;
11225 }
11226 break;
11227 case 0xab:
11228 GETBYTE ();
11229 switch (op[2] & 0x00)
11230 {
11231 case 0x00:
11232 goto op_semantics_91;
11233 break;
11234 }
11235 break;
11236 case 0xac:
11237 GETBYTE ();
11238 switch (op[2] & 0x00)
11239 {
11240 case 0x00:
11241 goto op_semantics_91;
11242 break;
11243 }
11244 break;
11245 case 0xad:
11246 GETBYTE ();
11247 switch (op[2] & 0x00)
11248 {
11249 case 0x00:
11250 goto op_semantics_91;
11251 break;
11252 }
11253 break;
11254 case 0xae:
11255 GETBYTE ();
11256 switch (op[2] & 0x00)
11257 {
11258 case 0x00:
11259 goto op_semantics_91;
11260 break;
11261 }
11262 break;
11263 case 0xaf:
11264 GETBYTE ();
11265 switch (op[2] & 0x00)
11266 {
11267 case 0x00:
11268 goto op_semantics_91;
11269 break;
11270 }
11271 break;
11272 case 0xb0:
11273 GETBYTE ();
11274 switch (op[2] & 0x00)
11275 {
11276 case 0x00:
11277 goto op_semantics_91;
11278 break;
11279 }
11280 break;
11281 case 0xb1:
11282 GETBYTE ();
11283 switch (op[2] & 0x00)
11284 {
11285 case 0x00:
11286 goto op_semantics_91;
11287 break;
11288 }
11289 break;
11290 case 0xb2:
11291 GETBYTE ();
11292 switch (op[2] & 0x00)
11293 {
11294 case 0x00:
11295 goto op_semantics_91;
11296 break;
11297 }
11298 break;
11299 case 0xb3:
11300 GETBYTE ();
11301 switch (op[2] & 0x00)
11302 {
11303 case 0x00:
11304 goto op_semantics_91;
11305 break;
11306 }
11307 break;
11308 case 0xb4:
11309 GETBYTE ();
11310 switch (op[2] & 0x00)
11311 {
11312 case 0x00:
11313 goto op_semantics_91;
11314 break;
11315 }
11316 break;
11317 case 0xb5:
11318 GETBYTE ();
11319 switch (op[2] & 0x00)
11320 {
11321 case 0x00:
11322 goto op_semantics_91;
11323 break;
11324 }
11325 break;
11326 case 0xb6:
11327 GETBYTE ();
11328 switch (op[2] & 0x00)
11329 {
11330 case 0x00:
11331 goto op_semantics_91;
11332 break;
11333 }
11334 break;
11335 case 0xb7:
11336 GETBYTE ();
11337 switch (op[2] & 0x00)
11338 {
11339 case 0x00:
11340 goto op_semantics_91;
11341 break;
11342 }
11343 break;
11344 case 0xb8:
11345 GETBYTE ();
11346 switch (op[2] & 0x00)
11347 {
11348 case 0x00:
11349 goto op_semantics_91;
11350 break;
11351 }
11352 break;
11353 case 0xb9:
11354 GETBYTE ();
11355 switch (op[2] & 0x00)
11356 {
11357 case 0x00:
11358 goto op_semantics_91;
11359 break;
11360 }
11361 break;
11362 case 0xba:
11363 GETBYTE ();
11364 switch (op[2] & 0x00)
11365 {
11366 case 0x00:
11367 goto op_semantics_91;
11368 break;
11369 }
11370 break;
11371 case 0xbb:
11372 GETBYTE ();
11373 switch (op[2] & 0x00)
11374 {
11375 case 0x00:
11376 goto op_semantics_91;
11377 break;
11378 }
11379 break;
11380 case 0xbc:
11381 GETBYTE ();
11382 switch (op[2] & 0x00)
11383 {
11384 case 0x00:
11385 goto op_semantics_91;
11386 break;
11387 }
11388 break;
11389 case 0xbd:
11390 GETBYTE ();
11391 switch (op[2] & 0x00)
11392 {
11393 case 0x00:
11394 goto op_semantics_91;
11395 break;
11396 }
11397 break;
11398 case 0xbe:
11399 GETBYTE ();
11400 switch (op[2] & 0x00)
11401 {
11402 case 0x00:
11403 goto op_semantics_91;
11404 break;
11405 }
11406 break;
11407 case 0xbf:
11408 GETBYTE ();
11409 switch (op[2] & 0x00)
11410 {
11411 case 0x00:
11412 goto op_semantics_91;
11413 break;
11414 }
11415 break;
11416 case 0xc0:
11417 GETBYTE ();
11418 switch (op[2] & 0x00)
11419 {
11420 case 0x00:
11421 op_semantics_92:
11422 {
11423 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
f282425e 11424#line 646 "rx-decode.opc"
c7927a3c 11425 int immmm AU = op[1] & 0x1f;
f282425e 11426#line 646 "rx-decode.opc"
c7927a3c 11427 int rsrc AU = (op[2] >> 4) & 0x0f;
f282425e 11428#line 646 "rx-decode.opc"
c7927a3c
NC		 11429 int rdst AU = op[2] & 0x0f;
11430 if (trace)
11431 {
11432 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11433 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11434 op[0], op[1], op[2]);
11435 printf (" immmm = 0x%x,", immmm);
11436 printf (" rsrc = 0x%x,", rsrc);
11437 printf (" rdst = 0x%x\n", rdst);
11438 }
11439 SYNTAX("shll #%2, %1, %0");
f282425e 11440#line 646 "rx-decode.opc"
c7927a3c
NC		 11441 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F("OSZC");
11442
11443
11444 }
11445 break;
11446 }
11447 break;
11448 case 0xc1:
11449 GETBYTE ();
11450 switch (op[2] & 0x00)
11451 {
11452 case 0x00:
11453 goto op_semantics_92;
11454 break;
11455 }
11456 break;
11457 case 0xc2:
11458 GETBYTE ();
11459 switch (op[2] & 0x00)
11460 {
11461 case 0x00:
11462 goto op_semantics_92;
11463 break;
11464 }
11465 break;
11466 case 0xc3:
11467 GETBYTE ();
11468 switch (op[2] & 0x00)
11469 {
11470 case 0x00:
11471 goto op_semantics_92;
11472 break;
11473 }
11474 break;
11475 case 0xc4:
11476 GETBYTE ();
11477 switch (op[2] & 0x00)
11478 {
11479 case 0x00:
11480 goto op_semantics_92;
11481 break;
11482 }
11483 break;
11484 case 0xc5:
11485 GETBYTE ();
11486 switch (op[2] & 0x00)
11487 {
11488 case 0x00:
11489 goto op_semantics_92;
11490 break;
11491 }
11492 break;
11493 case 0xc6:
11494 GETBYTE ();
11495 switch (op[2] & 0x00)
11496 {
11497 case 0x00:
11498 goto op_semantics_92;
11499 break;
11500 }
11501 break;
11502 case 0xc7:
11503 GETBYTE ();
11504 switch (op[2] & 0x00)
11505 {
11506 case 0x00:
11507 goto op_semantics_92;
11508 break;
11509 }
11510 break;
11511 case 0xc8:
11512 GETBYTE ();
11513 switch (op[2] & 0x00)
11514 {
11515 case 0x00:
11516 goto op_semantics_92;
11517 break;
11518 }
11519 break;
11520 case 0xc9:
11521 GETBYTE ();
11522 switch (op[2] & 0x00)
11523 {
11524 case 0x00:
11525 goto op_semantics_92;
11526 break;
11527 }
11528 break;
11529 case 0xca:
11530 GETBYTE ();
11531 switch (op[2] & 0x00)
11532 {
11533 case 0x00:
11534 goto op_semantics_92;
11535 break;
11536 }
11537 break;
11538 case 0xcb:
11539 GETBYTE ();
11540 switch (op[2] & 0x00)
11541 {
11542 case 0x00:
11543 goto op_semantics_92;
11544 break;
11545 }
11546 break;
11547 case 0xcc:
11548 GETBYTE ();
11549 switch (op[2] & 0x00)
11550 {
11551 case 0x00:
11552 goto op_semantics_92;
11553 break;
11554 }
11555 break;
11556 case 0xcd:
11557 GETBYTE ();
11558 switch (op[2] & 0x00)
11559 {
11560 case 0x00:
11561 goto op_semantics_92;
11562 break;
11563 }
11564 break;
11565 case 0xce:
11566 GETBYTE ();
11567 switch (op[2] & 0x00)
11568 {
11569 case 0x00:
11570 goto op_semantics_92;
11571 break;
11572 }
11573 break;
11574 case 0xcf:
11575 GETBYTE ();
11576 switch (op[2] & 0x00)
11577 {
11578 case 0x00:
11579 goto op_semantics_92;
11580 break;
11581 }
11582 break;
11583 case 0xd0:
11584 GETBYTE ();
11585 switch (op[2] & 0x00)
11586 {
11587 case 0x00:
11588 goto op_semantics_92;
11589 break;
11590 }
11591 break;
11592 case 0xd1:
11593 GETBYTE ();
11594 switch (op[2] & 0x00)
11595 {
11596 case 0x00:
11597 goto op_semantics_92;
11598 break;
11599 }
11600 break;
11601 case 0xd2:
11602 GETBYTE ();
11603 switch (op[2] & 0x00)
11604 {
11605 case 0x00:
11606 goto op_semantics_92;
11607 break;
11608 }
11609 break;
11610 case 0xd3:
11611 GETBYTE ();
11612 switch (op[2] & 0x00)
11613 {
11614 case 0x00:
11615 goto op_semantics_92;
11616 break;
11617 }
11618 break;
11619 case 0xd4:
11620 GETBYTE ();
11621 switch (op[2] & 0x00)
11622 {
11623 case 0x00:
11624 goto op_semantics_92;
11625 break;
11626 }
11627 break;
11628 case 0xd5:
11629 GETBYTE ();
11630 switch (op[2] & 0x00)
11631 {
11632 case 0x00:
11633 goto op_semantics_92;
11634 break;
11635 }
11636 break;
11637 case 0xd6:
11638 GETBYTE ();
11639 switch (op[2] & 0x00)
11640 {
11641 case 0x00:
11642 goto op_semantics_92;
11643 break;
11644 }
11645 break;
11646 case 0xd7:
11647 GETBYTE ();
11648 switch (op[2] & 0x00)
11649 {
11650 case 0x00:
11651 goto op_semantics_92;
11652 break;
11653 }
11654 break;
11655 case 0xd8:
11656 GETBYTE ();
11657 switch (op[2] & 0x00)
11658 {
11659 case 0x00:
11660 goto op_semantics_92;
11661 break;
11662 }
11663 break;
11664 case 0xd9:
11665 GETBYTE ();
11666 switch (op[2] & 0x00)
11667 {
11668 case 0x00:
11669 goto op_semantics_92;
11670 break;
11671 }
11672 break;
11673 case 0xda:
11674 GETBYTE ();
11675 switch (op[2] & 0x00)
11676 {
11677 case 0x00:
11678 goto op_semantics_92;
11679 break;
11680 }
11681 break;
11682 case 0xdb:
11683 GETBYTE ();
11684 switch (op[2] & 0x00)
11685 {
11686 case 0x00:
11687 goto op_semantics_92;
11688 break;
11689 }
11690 break;
11691 case 0xdc:
11692 GETBYTE ();
11693 switch (op[2] & 0x00)
11694 {
11695 case 0x00:
11696 goto op_semantics_92;
11697 break;
11698 }
11699 break;
11700 case 0xdd:
11701 GETBYTE ();
11702 switch (op[2] & 0x00)
11703 {
11704 case 0x00:
11705 goto op_semantics_92;
11706 break;
11707 }
11708 break;
11709 case 0xde:
11710 GETBYTE ();
11711 switch (op[2] & 0x00)
11712 {
11713 case 0x00:
11714 goto op_semantics_92;
11715 break;
11716 }
11717 break;
11718 case 0xdf:
11719 GETBYTE ();
11720 switch (op[2] & 0x00)
11721 {
11722 case 0x00:
11723 goto op_semantics_92;
11724 break;
11725 }
11726 break;
11727 case 0xe0:
11728 GETBYTE ();
11729 switch (op[2] & 0xf0)
11730 {
11731 case 0x00:
11732 case 0x10:
11733 case 0x20:
11734 case 0x30:
11735 case 0x40:
11736 case 0x50:
11737 case 0x60:
11738 case 0x70:
11739 case 0x80:
11740 case 0x90:
11741 case 0xa0:
11742 case 0xb0:
11743 case 0xc0:
11744 case 0xd0:
11745 case 0xe0:
11746 op_semantics_93:
11747 {
11748 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
f282425e 11749#line 912 "rx-decode.opc"
c7927a3c 11750 int bittt AU = op[1] & 0x1f;
f282425e 11751#line 912 "rx-decode.opc"
c7927a3c 11752 int cond AU = (op[2] >> 4) & 0x0f;
f282425e 11753#line 912 "rx-decode.opc"
c7927a3c
NC		 11754 int rdst AU = op[2] & 0x0f;
11755 if (trace)
11756 {
11757 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11758 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11759 op[0], op[1], op[2]);
11760 printf (" bittt = 0x%x,", bittt);
11761 printf (" cond = 0x%x,", cond);
11762 printf (" rdst = 0x%x\n", rdst);
11763 }
11764 SYNTAX("bm%2 #%1, %0%S0");
f282425e 11765#line 912 "rx-decode.opc"
c7927a3c
NC		 11766 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11767
11768 /*----------------------------------------------------------------------*/
11769 /* CONTROL REGISTERS */
11770
11771 }
11772 break;
11773 case 0xf0:
11774 op_semantics_94:
11775 {
11776 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
f282425e 11777#line 905 "rx-decode.opc"
c7927a3c 11778 int bittt AU = op[1] & 0x1f;
f282425e 11779#line 905 "rx-decode.opc"
c7927a3c
NC		 11780 int rdst AU = op[2] & 0x0f;
11781 if (trace)
11782 {
11783 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11784 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11785 op[0], op[1], op[2]);
11786 printf (" bittt = 0x%x,", bittt);
11787 printf (" rdst = 0x%x\n", rdst);
11788 }
11789 SYNTAX("bnot #%1, %0");
f282425e 11790#line 905 "rx-decode.opc"
c7927a3c
NC		 11791 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11792
11793
11794 }
11795 break;
11796 }
11797 break;
11798 case 0xe1:
11799 GETBYTE ();
11800 switch (op[2] & 0xf0)
11801 {
11802 case 0x00:
11803 case 0x10:
11804 case 0x20:
11805 case 0x30:
11806 case 0x40:
11807 case 0x50:
11808 case 0x60:
11809 case 0x70:
11810 case 0x80:
11811 case 0x90:
11812 case 0xa0:
11813 case 0xb0:
11814 case 0xc0:
11815 case 0xd0:
11816 case 0xe0:
11817 goto op_semantics_93;
11818 break;
11819 case 0xf0:
11820 goto op_semantics_94;
11821 break;
11822 }
11823 break;
11824 case 0xe2:
11825 GETBYTE ();
11826 switch (op[2] & 0xf0)
11827 {
11828 case 0x00:
11829 case 0x10:
11830 case 0x20:
11831 case 0x30:
11832 case 0x40:
11833 case 0x50:
11834 case 0x60:
11835 case 0x70:
11836 case 0x80:
11837 case 0x90:
11838 case 0xa0:
11839 case 0xb0:
11840 case 0xc0:
11841 case 0xd0:
11842 case 0xe0:
11843 goto op_semantics_93;
11844 break;
11845 case 0xf0:
11846 goto op_semantics_94;
11847 break;
11848 }
11849 break;
11850 case 0xe3:
11851 GETBYTE ();
11852 switch (op[2] & 0xf0)
11853 {
11854 case 0x00:
11855 case 0x10:
11856 case 0x20:
11857 case 0x30:
11858 case 0x40:
11859 case 0x50:
11860 case 0x60:
11861 case 0x70:
11862 case 0x80:
11863 case 0x90:
11864 case 0xa0:
11865 case 0xb0:
11866 case 0xc0:
11867 case 0xd0:
11868 case 0xe0:
11869 goto op_semantics_93;
11870 break;
11871 case 0xf0:
11872 goto op_semantics_94;
11873 break;
11874 }
11875 break;
11876 case 0xe4:
11877 GETBYTE ();
11878 switch (op[2] & 0xf0)
11879 {
11880 case 0x00:
11881 case 0x10:
11882 case 0x20:
11883 case 0x30:
11884 case 0x40:
11885 case 0x50:
11886 case 0x60:
11887 case 0x70:
11888 case 0x80:
11889 case 0x90:
11890 case 0xa0:
11891 case 0xb0:
11892 case 0xc0:
11893 case 0xd0:
11894 case 0xe0:
11895 goto op_semantics_93;
11896 break;
11897 case 0xf0:
11898 goto op_semantics_94;
11899 break;
11900 }
11901 break;
11902 case 0xe5:
11903 GETBYTE ();
11904 switch (op[2] & 0xf0)
11905 {
11906 case 0x00:
11907 case 0x10:
11908 case 0x20:
11909 case 0x30:
11910 case 0x40:
11911 case 0x50:
11912 case 0x60:
11913 case 0x70:
11914 case 0x80:
11915 case 0x90:
11916 case 0xa0:
11917 case 0xb0:
11918 case 0xc0:
11919 case 0xd0:
11920 case 0xe0:
11921 goto op_semantics_93;
11922 break;
11923 case 0xf0:
11924 goto op_semantics_94;
11925 break;
11926 }
11927 break;
11928 case 0xe6:
11929 GETBYTE ();
11930 switch (op[2] & 0xf0)
11931 {
11932 case 0x00:
11933 case 0x10:
11934 case 0x20:
11935 case 0x30:
11936 case 0x40:
11937 case 0x50:
11938 case 0x60:
11939 case 0x70:
11940 case 0x80:
11941 case 0x90:
11942 case 0xa0:
11943 case 0xb0:
11944 case 0xc0:
11945 case 0xd0:
11946 case 0xe0:
11947 goto op_semantics_93;
11948 break;
11949 case 0xf0:
11950 goto op_semantics_94;
11951 break;
11952 }
11953 break;
11954 case 0xe7:
11955 GETBYTE ();
11956 switch (op[2] & 0xf0)
11957 {
11958 case 0x00:
11959 case 0x10:
11960 case 0x20:
11961 case 0x30:
11962 case 0x40:
11963 case 0x50:
11964 case 0x60:
11965 case 0x70:
11966 case 0x80:
11967 case 0x90:
11968 case 0xa0:
11969 case 0xb0:
11970 case 0xc0:
11971 case 0xd0:
11972 case 0xe0:
11973 goto op_semantics_93;
11974 break;
11975 case 0xf0:
11976 goto op_semantics_94;
11977 break;
11978 }
11979 break;
11980 case 0xe8:
11981 GETBYTE ();
11982 switch (op[2] & 0xf0)
11983 {
11984 case 0x00:
11985 case 0x10:
11986 case 0x20:
11987 case 0x30:
11988 case 0x40:
11989 case 0x50:
11990 case 0x60:
11991 case 0x70:
11992 case 0x80:
11993 case 0x90:
11994 case 0xa0:
11995 case 0xb0:
11996 case 0xc0:
11997 case 0xd0:
11998 case 0xe0:
11999 goto op_semantics_93;
12000 break;
12001 case 0xf0:
12002 goto op_semantics_94;
12003 break;
12004 }
12005 break;
12006 case 0xe9:
12007 GETBYTE ();
12008 switch (op[2] & 0xf0)
12009 {
12010 case 0x00:
12011 case 0x10:
12012 case 0x20:
12013 case 0x30:
12014 case 0x40:
12015 case 0x50:
12016 case 0x60:
12017 case 0x70:
12018 case 0x80:
12019 case 0x90:
12020 case 0xa0:
12021 case 0xb0:
12022 case 0xc0:
12023 case 0xd0:
12024 case 0xe0:
12025 goto op_semantics_93;
12026 break;
12027 case 0xf0:
12028 goto op_semantics_94;
12029 break;
12030 }
12031 break;
12032 case 0xea:
12033 GETBYTE ();
12034 switch (op[2] & 0xf0)
12035 {
12036 case 0x00:
12037 case 0x10:
12038 case 0x20:
12039 case 0x30:
12040 case 0x40:
12041 case 0x50:
12042 case 0x60:
12043 case 0x70:
12044 case 0x80:
12045 case 0x90:
12046 case 0xa0:
12047 case 0xb0:
12048 case 0xc0:
12049 case 0xd0:
12050 case 0xe0:
12051 goto op_semantics_93;
12052 break;
12053 case 0xf0:
12054 goto op_semantics_94;
12055 break;
12056 }
12057 break;
12058 case 0xeb:
12059 GETBYTE ();
12060 switch (op[2] & 0xf0)
12061 {
12062 case 0x00:
12063 case 0x10:
12064 case 0x20:
12065 case 0x30:
12066 case 0x40:
12067 case 0x50:
12068 case 0x60:
12069 case 0x70:
12070 case 0x80:
12071 case 0x90:
12072 case 0xa0:
12073 case 0xb0:
12074 case 0xc0:
12075 case 0xd0:
12076 case 0xe0:
12077 goto op_semantics_93;
12078 break;
12079 case 0xf0:
12080 goto op_semantics_94;
12081 break;
12082 }
12083 break;
12084 case 0xec:
12085 GETBYTE ();
12086 switch (op[2] & 0xf0)
12087 {
12088 case 0x00:
12089 case 0x10:
12090 case 0x20:
12091 case 0x30:
12092 case 0x40:
12093 case 0x50:
12094 case 0x60:
12095 case 0x70:
12096 case 0x80:
12097 case 0x90:
12098 case 0xa0:
12099 case 0xb0:
12100 case 0xc0:
12101 case 0xd0:
12102 case 0xe0:
12103 goto op_semantics_93;
12104 break;
12105 case 0xf0:
12106 goto op_semantics_94;
12107 break;
12108 }
12109 break;
12110 case 0xed:
12111 GETBYTE ();
12112 switch (op[2] & 0xf0)
12113 {
12114 case 0x00:
12115 case 0x10:
12116 case 0x20:
12117 case 0x30:
12118 case 0x40:
12119 case 0x50:
12120 case 0x60:
12121 case 0x70:
12122 case 0x80:
12123 case 0x90:
12124 case 0xa0:
12125 case 0xb0:
12126 case 0xc0:
12127 case 0xd0:
12128 case 0xe0:
12129 goto op_semantics_93;
12130 break;
12131 case 0xf0:
12132 goto op_semantics_94;
12133 break;
12134 }
12135 break;
12136 case 0xee:
12137 GETBYTE ();
12138 switch (op[2] & 0xf0)
12139 {
12140 case 0x00:
12141 case 0x10:
12142 case 0x20:
12143 case 0x30:
12144 case 0x40:
12145 case 0x50:
12146 case 0x60:
12147 case 0x70:
12148 case 0x80:
12149 case 0x90:
12150 case 0xa0:
12151 case 0xb0:
12152 case 0xc0:
12153 case 0xd0:
12154 case 0xe0:
12155 goto op_semantics_93;
12156 break;
12157 case 0xf0:
12158 goto op_semantics_94;
12159 break;
12160 }
12161 break;
12162 case 0xef:
12163 GETBYTE ();
12164 switch (op[2] & 0xf0)
12165 {
12166 case 0x00:
12167 case 0x10:
12168 case 0x20:
12169 case 0x30:
12170 case 0x40:
12171 case 0x50:
12172 case 0x60:
12173 case 0x70:
12174 case 0x80:
12175 case 0x90:
12176 case 0xa0:
12177 case 0xb0:
12178 case 0xc0:
12179 case 0xd0:
12180 case 0xe0:
12181 goto op_semantics_93;
12182 break;
12183 case 0xf0:
12184 goto op_semantics_94;
12185 break;
12186 }
12187 break;
12188 case 0xf0:
12189 GETBYTE ();
12190 switch (op[2] & 0xf0)
12191 {
12192 case 0x00:
12193 case 0x10:
12194 case 0x20:
12195 case 0x30:
12196 case 0x40:
12197 case 0x50:
12198 case 0x60:
12199 case 0x70:
12200 case 0x80:
12201 case 0x90:
12202 case 0xa0:
12203 case 0xb0:
12204 case 0xc0:
12205 case 0xd0:
12206 case 0xe0:
12207 goto op_semantics_93;
12208 break;
12209 case 0xf0:
12210 goto op_semantics_94;
12211 break;
12212 }
12213 break;
12214 case 0xf1:
12215 GETBYTE ();
12216 switch (op[2] & 0xf0)
12217 {
12218 case 0x00:
12219 case 0x10:
12220 case 0x20:
12221 case 0x30:
12222 case 0x40:
12223 case 0x50:
12224 case 0x60:
12225 case 0x70:
12226 case 0x80:
12227 case 0x90:
12228 case 0xa0:
12229 case 0xb0:
12230 case 0xc0:
12231 case 0xd0:
12232 case 0xe0:
12233 goto op_semantics_93;
12234 break;
12235 case 0xf0:
12236 goto op_semantics_94;
12237 break;
12238 }
12239 break;
12240 case 0xf2:
12241 GETBYTE ();
12242 switch (op[2] & 0xf0)
12243 {
12244 case 0x00:
12245 case 0x10:
12246 case 0x20:
12247 case 0x30:
12248 case 0x40:
12249 case 0x50:
12250 case 0x60:
12251 case 0x70:
12252 case 0x80:
12253 case 0x90:
12254 case 0xa0:
12255 case 0xb0:
12256 case 0xc0:
12257 case 0xd0:
12258 case 0xe0:
12259 goto op_semantics_93;
12260 break;
12261 case 0xf0:
12262 goto op_semantics_94;
12263 break;
12264 }
12265 break;
12266 case 0xf3:
12267 GETBYTE ();
12268 switch (op[2] & 0xf0)
12269 {
12270 case 0x00:
12271 case 0x10:
12272 case 0x20:
12273 case 0x30:
12274 case 0x40:
12275 case 0x50:
12276 case 0x60:
12277 case 0x70:
12278 case 0x80:
12279 case 0x90:
12280 case 0xa0:
12281 case 0xb0:
12282 case 0xc0:
12283 case 0xd0:
12284 case 0xe0:
12285 goto op_semantics_93;
12286 break;
12287 case 0xf0:
12288 goto op_semantics_94;
12289 break;
12290 }
12291 break;
12292 case 0xf4:
12293 GETBYTE ();
12294 switch (op[2] & 0xf0)
12295 {
12296 case 0x00:
12297 case 0x10:
12298 case 0x20:
12299 case 0x30:
12300 case 0x40:
12301 case 0x50:
12302 case 0x60:
12303 case 0x70:
12304 case 0x80:
12305 case 0x90:
12306 case 0xa0:
12307 case 0xb0:
12308 case 0xc0:
12309 case 0xd0:
12310 case 0xe0:
12311 goto op_semantics_93;
12312 break;
12313 case 0xf0:
12314 goto op_semantics_94;
12315 break;
12316 }
12317 break;
12318 case 0xf5:
12319 GETBYTE ();
12320 switch (op[2] & 0xf0)
12321 {
12322 case 0x00:
12323 case 0x10:
12324 case 0x20:
12325 case 0x30:
12326 case 0x40:
12327 case 0x50:
12328 case 0x60:
12329 case 0x70:
12330 case 0x80:
12331 case 0x90:
12332 case 0xa0:
12333 case 0xb0:
12334 case 0xc0:
12335 case 0xd0:
12336 case 0xe0:
12337 goto op_semantics_93;
12338 break;
12339 case 0xf0:
12340 goto op_semantics_94;
12341 break;
12342 }
12343 break;
12344 case 0xf6:
12345 GETBYTE ();
12346 switch (op[2] & 0xf0)
12347 {
12348 case 0x00:
12349 case 0x10:
12350 case 0x20:
12351 case 0x30:
12352 case 0x40:
12353 case 0x50:
12354 case 0x60:
12355 case 0x70:
12356 case 0x80:
12357 case 0x90:
12358 case 0xa0:
12359 case 0xb0:
12360 case 0xc0:
12361 case 0xd0:
12362 case 0xe0:
12363 goto op_semantics_93;
12364 break;
12365 case 0xf0:
12366 goto op_semantics_94;
12367 break;
12368 }
12369 break;
12370 case 0xf7:
12371 GETBYTE ();
12372 switch (op[2] & 0xf0)
12373 {
12374 case 0x00:
12375 case 0x10:
12376 case 0x20:
12377 case 0x30:
12378 case 0x40:
12379 case 0x50:
12380 case 0x60:
12381 case 0x70:
12382 case 0x80:
12383 case 0x90:
12384 case 0xa0:
12385 case 0xb0:
12386 case 0xc0:
12387 case 0xd0:
12388 case 0xe0:
12389 goto op_semantics_93;
12390 break;
12391 case 0xf0:
12392 goto op_semantics_94;
12393 break;
12394 }
12395 break;
12396 case 0xf8:
12397 GETBYTE ();
12398 switch (op[2] & 0xf0)
12399 {
12400 case 0x00:
12401 case 0x10:
12402 case 0x20:
12403 case 0x30:
12404 case 0x40:
12405 case 0x50:
12406 case 0x60:
12407 case 0x70:
12408 case 0x80:
12409 case 0x90:
12410 case 0xa0:
12411 case 0xb0:
12412 case 0xc0:
12413 case 0xd0:
12414 case 0xe0:
12415 goto op_semantics_93;
12416 break;
12417 case 0xf0:
12418 goto op_semantics_94;
12419 break;
12420 }
12421 break;
12422 case 0xf9:
12423 GETBYTE ();
12424 switch (op[2] & 0xf0)
12425 {
12426 case 0x00:
12427 case 0x10:
12428 case 0x20:
12429 case 0x30:
12430 case 0x40:
12431 case 0x50:
12432 case 0x60:
12433 case 0x70:
12434 case 0x80:
12435 case 0x90:
12436 case 0xa0:
12437 case 0xb0:
12438 case 0xc0:
12439 case 0xd0:
12440 case 0xe0:
12441 goto op_semantics_93;
12442 break;
12443 case 0xf0:
12444 goto op_semantics_94;
12445 break;
12446 }
12447 break;
12448 case 0xfa:
12449 GETBYTE ();
12450 switch (op[2] & 0xf0)
12451 {
12452 case 0x00:
12453 case 0x10:
12454 case 0x20:
12455 case 0x30:
12456 case 0x40:
12457 case 0x50:
12458 case 0x60:
12459 case 0x70:
12460 case 0x80:
12461 case 0x90:
12462 case 0xa0:
12463 case 0xb0:
12464 case 0xc0:
12465 case 0xd0:
12466 case 0xe0:
12467 goto op_semantics_93;
12468 break;
12469 case 0xf0:
12470 goto op_semantics_94;
12471 break;
12472 }
12473 break;
12474 case 0xfb:
12475 GETBYTE ();
12476 switch (op[2] & 0xf0)
12477 {
12478 case 0x00:
12479 case 0x10:
12480 case 0x20:
12481 case 0x30:
12482 case 0x40:
12483 case 0x50:
12484 case 0x60:
12485 case 0x70:
12486 case 0x80:
12487 case 0x90:
12488 case 0xa0:
12489 case 0xb0:
12490 case 0xc0:
12491 case 0xd0:
12492 case 0xe0:
12493 goto op_semantics_93;
12494 break;
12495 case 0xf0:
12496 goto op_semantics_94;
12497 break;
12498 }
12499 break;
12500 case 0xfc:
12501 GETBYTE ();
12502 switch (op[2] & 0xf0)
12503 {
12504 case 0x00:
12505 case 0x10:
12506 case 0x20:
12507 case 0x30:
12508 case 0x40:
12509 case 0x50:
12510 case 0x60:
12511 case 0x70:
12512 case 0x80:
12513 case 0x90:
12514 case 0xa0:
12515 case 0xb0:
12516 case 0xc0:
12517 case 0xd0:
12518 case 0xe0:
12519 goto op_semantics_93;
12520 break;
12521 case 0xf0:
12522 goto op_semantics_94;
12523 break;
12524 }
12525 break;
12526 case 0xfd:
12527 GETBYTE ();
12528 switch (op[2] & 0xf0)
12529 {
12530 case 0x00:
12531 case 0x10:
12532 case 0x20:
12533 case 0x30:
12534 case 0x40:
12535 case 0x50:
12536 case 0x60:
12537 case 0x70:
12538 case 0x80:
12539 case 0x90:
12540 case 0xa0:
12541 case 0xb0:
12542 case 0xc0:
12543 case 0xd0:
12544 case 0xe0:
12545 goto op_semantics_93;
12546 break;
12547 case 0xf0:
12548 goto op_semantics_94;
12549 break;
12550 }
12551 break;
12552 case 0xfe:
12553 GETBYTE ();
12554 switch (op[2] & 0xf0)
12555 {
12556 case 0x00:
12557 case 0x10:
12558 case 0x20:
12559 case 0x30:
12560 case 0x40:
12561 case 0x50:
12562 case 0x60:
12563 case 0x70:
12564 case 0x80:
12565 case 0x90:
12566 case 0xa0:
12567 case 0xb0:
12568 case 0xc0:
12569 case 0xd0:
12570 case 0xe0:
12571 goto op_semantics_93;
12572 break;
12573 case 0xf0:
12574 goto op_semantics_94;
12575 break;
12576 }
12577 break;
12578 case 0xff:
12579 GETBYTE ();
12580 switch (op[2] & 0xf0)
12581 {
12582 case 0x00:
12583 case 0x10:
12584 case 0x20:
12585 case 0x30:
12586 case 0x40:
12587 case 0x50:
12588 case 0x60:
12589 case 0x70:
12590 case 0x80:
12591 case 0x90:
12592 case 0xa0:
12593 case 0xb0:
12594 case 0xc0:
12595 case 0xd0:
12596 case 0xe0:
12597 goto op_semantics_93;
12598 break;
12599 case 0xf0:
12600 goto op_semantics_94;
12601 break;
12602 }
12603 break;
12604 default: UNSUPPORTED(); break;
12605 }
12606 break;
12607 case 0xfe:
12608 GETBYTE ();
12609 switch (op[1] & 0xff)
12610 {
12611 case 0x00:
12612 GETBYTE ();
12613 switch (op[2] & 0x00)
12614 {
12615 case 0x00:
12616 op_semantics_95:
12617 {
12618 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
f282425e 12619#line 318 "rx-decode.opc"
c7927a3c 12620 int sz AU = (op[1] >> 4) & 0x03;
f282425e 12621#line 318 "rx-decode.opc"
c7927a3c 12622 int isrc AU = op[1] & 0x0f;
f282425e 12623#line 318 "rx-decode.opc"
c7927a3c 12624 int bsrc AU = (op[2] >> 4) & 0x0f;
f282425e 12625#line 318 "rx-decode.opc"
c7927a3c
NC		 12626 int rdst AU = op[2] & 0x0f;
12627 if (trace)
12628 {
12629 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12630 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12631 op[0], op[1], op[2]);
12632 printf (" sz = 0x%x,", sz);
12633 printf (" isrc = 0x%x,", isrc);
12634 printf (" bsrc = 0x%x,", bsrc);
12635 printf (" rdst = 0x%x\n", rdst);
12636 }
12637 SYNTAX("mov%s %0, [%1, %2]");
f282425e 12638#line 318 "rx-decode.opc"
c7927a3c
NC		 12639 ID(movbir); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
12640
12641 }
12642 break;
12643 }
12644 break;
12645 case 0x01:
12646 GETBYTE ();
12647 switch (op[2] & 0x00)
12648 {
12649 case 0x00:
12650 goto op_semantics_95;
12651 break;
12652 }
12653 break;
12654 case 0x02:
12655 GETBYTE ();
12656 switch (op[2] & 0x00)
12657 {
12658 case 0x00:
12659 goto op_semantics_95;
12660 break;
12661 }
12662 break;
12663 case 0x03:
12664 GETBYTE ();
12665 switch (op[2] & 0x00)
12666 {
12667 case 0x00:
12668 goto op_semantics_95;
12669 break;
12670 }
12671 break;
12672 case 0x04:
12673 GETBYTE ();
12674 switch (op[2] & 0x00)
12675 {
12676 case 0x00:
12677 goto op_semantics_95;
12678 break;
12679 }
12680 break;
12681 case 0x05:
12682 GETBYTE ();
12683 switch (op[2] & 0x00)
12684 {
12685 case 0x00:
12686 goto op_semantics_95;
12687 break;
12688 }
12689 break;
12690 case 0x06:
12691 GETBYTE ();
12692 switch (op[2] & 0x00)
12693 {
12694 case 0x00:
12695 goto op_semantics_95;
12696 break;
12697 }
12698 break;
12699 case 0x07:
12700 GETBYTE ();
12701 switch (op[2] & 0x00)
12702 {
12703 case 0x00:
12704 goto op_semantics_95;
12705 break;
12706 }
12707 break;
12708 case 0x08:
12709 GETBYTE ();
12710 switch (op[2] & 0x00)
12711 {
12712 case 0x00:
12713 goto op_semantics_95;
12714 break;
12715 }
12716 break;
12717 case 0x09:
12718 GETBYTE ();
12719 switch (op[2] & 0x00)
12720 {
12721 case 0x00:
12722 goto op_semantics_95;
12723 break;
12724 }
12725 break;
12726 case 0x0a:
12727 GETBYTE ();
12728 switch (op[2] & 0x00)
12729 {
12730 case 0x00:
12731 goto op_semantics_95;
12732 break;
12733 }
12734 break;
12735 case 0x0b:
12736 GETBYTE ();
12737 switch (op[2] & 0x00)
12738 {
12739 case 0x00:
12740 goto op_semantics_95;
12741 break;
12742 }
12743 break;
12744 case 0x0c:
12745 GETBYTE ();
12746 switch (op[2] & 0x00)
12747 {
12748 case 0x00:
12749 goto op_semantics_95;
12750 break;
12751 }
12752 break;
12753 case 0x0d:
12754 GETBYTE ();
12755 switch (op[2] & 0x00)
12756 {
12757 case 0x00:
12758 goto op_semantics_95;
12759 break;
12760 }
12761 break;
12762 case 0x0e:
12763 GETBYTE ();
12764 switch (op[2] & 0x00)
12765 {
12766 case 0x00:
12767 goto op_semantics_95;
12768 break;
12769 }
12770 break;
12771 case 0x0f:
12772 GETBYTE ();
12773 switch (op[2] & 0x00)
12774 {
12775 case 0x00:
12776 goto op_semantics_95;
12777 break;
12778 }
12779 break;
12780 case 0x10:
12781 GETBYTE ();
12782 switch (op[2] & 0x00)
12783 {
12784 case 0x00:
12785 goto op_semantics_95;
12786 break;
12787 }
12788 break;
12789 case 0x11:
12790 GETBYTE ();
12791 switch (op[2] & 0x00)
12792 {
12793 case 0x00:
12794 goto op_semantics_95;
12795 break;
12796 }
12797 break;
12798 case 0x12:
12799 GETBYTE ();
12800 switch (op[2] & 0x00)
12801 {
12802 case 0x00:
12803 goto op_semantics_95;
12804 break;
12805 }
12806 break;
12807 case 0x13:
12808 GETBYTE ();
12809 switch (op[2] & 0x00)
12810 {
12811 case 0x00:
12812 goto op_semantics_95;
12813 break;
12814 }
12815 break;
12816 case 0x14:
12817 GETBYTE ();
12818 switch (op[2] & 0x00)
12819 {
12820 case 0x00:
12821 goto op_semantics_95;
12822 break;
12823 }
12824 break;
12825 case 0x15:
12826 GETBYTE ();
12827 switch (op[2] & 0x00)
12828 {
12829 case 0x00:
12830 goto op_semantics_95;
12831 break;
12832 }
12833 break;
12834 case 0x16:
12835 GETBYTE ();
12836 switch (op[2] & 0x00)
12837 {
12838 case 0x00:
12839 goto op_semantics_95;
12840 break;
12841 }
12842 break;
12843 case 0x17:
12844 GETBYTE ();
12845 switch (op[2] & 0x00)
12846 {
12847 case 0x00:
12848 goto op_semantics_95;
12849 break;
12850 }
12851 break;
12852 case 0x18:
12853 GETBYTE ();
12854 switch (op[2] & 0x00)
12855 {
12856 case 0x00:
12857 goto op_semantics_95;
12858 break;
12859 }
12860 break;
12861 case 0x19:
12862 GETBYTE ();
12863 switch (op[2] & 0x00)
12864 {
12865 case 0x00:
12866 goto op_semantics_95;
12867 break;
12868 }
12869 break;
12870 case 0x1a:
12871 GETBYTE ();
12872 switch (op[2] & 0x00)
12873 {
12874 case 0x00:
12875 goto op_semantics_95;
12876 break;
12877 }
12878 break;
12879 case 0x1b:
12880 GETBYTE ();
12881 switch (op[2] & 0x00)
12882 {
12883 case 0x00:
12884 goto op_semantics_95;
12885 break;
12886 }
12887 break;
12888 case 0x1c:
12889 GETBYTE ();
12890 switch (op[2] & 0x00)
12891 {
12892 case 0x00:
12893 goto op_semantics_95;
12894 break;
12895 }
12896 break;
12897 case 0x1d:
12898 GETBYTE ();
12899 switch (op[2] & 0x00)
12900 {
12901 case 0x00:
12902 goto op_semantics_95;
12903 break;
12904 }
12905 break;
12906 case 0x1e:
12907 GETBYTE ();
12908 switch (op[2] & 0x00)
12909 {
12910 case 0x00:
12911 goto op_semantics_95;
12912 break;
12913 }
12914 break;
12915 case 0x1f:
12916 GETBYTE ();
12917 switch (op[2] & 0x00)
12918 {
12919 case 0x00:
12920 goto op_semantics_95;
12921 break;
12922 }
12923 break;
12924 case 0x20:
12925 GETBYTE ();
12926 switch (op[2] & 0x00)
12927 {
12928 case 0x00:
12929 goto op_semantics_95;
12930 break;
12931 }
12932 break;
12933 case 0x21:
12934 GETBYTE ();
12935 switch (op[2] & 0x00)
12936 {
12937 case 0x00:
12938 goto op_semantics_95;
12939 break;
12940 }
12941 break;
12942 case 0x22:
12943 GETBYTE ();
12944 switch (op[2] & 0x00)
12945 {
12946 case 0x00:
12947 goto op_semantics_95;
12948 break;
12949 }
12950 break;
12951 case 0x23:
12952 GETBYTE ();
12953 switch (op[2] & 0x00)
12954 {
12955 case 0x00:
12956 goto op_semantics_95;
12957 break;
12958 }
12959 break;
12960 case 0x24:
12961 GETBYTE ();
12962 switch (op[2] & 0x00)
12963 {
12964 case 0x00:
12965 goto op_semantics_95;
12966 break;
12967 }
12968 break;
12969 case 0x25:
12970 GETBYTE ();
12971 switch (op[2] & 0x00)
12972 {
12973 case 0x00:
12974 goto op_semantics_95;
12975 break;
12976 }
12977 break;
12978 case 0x26:
12979 GETBYTE ();
12980 switch (op[2] & 0x00)
12981 {
12982 case 0x00:
12983 goto op_semantics_95;
12984 break;
12985 }
12986 break;
12987 case 0x27:
12988 GETBYTE ();
12989 switch (op[2] & 0x00)
12990 {
12991 case 0x00:
12992 goto op_semantics_95;
12993 break;
12994 }
12995 break;
12996 case 0x28:
12997 GETBYTE ();
12998 switch (op[2] & 0x00)
12999 {
13000 case 0x00:
13001 goto op_semantics_95;
13002 break;
13003 }
13004 break;
13005 case 0x29:
13006 GETBYTE ();
13007 switch (op[2] & 0x00)
13008 {
13009 case 0x00:
13010 goto op_semantics_95;
13011 break;
13012 }
13013 break;
13014 case 0x2a:
13015 GETBYTE ();
13016 switch (op[2] & 0x00)
13017 {
13018 case 0x00:
13019 goto op_semantics_95;
13020 break;
13021 }
13022 break;
13023 case 0x2b:
13024 GETBYTE ();
13025 switch (op[2] & 0x00)
13026 {
13027 case 0x00:
13028 goto op_semantics_95;
13029 break;
13030 }
13031 break;
13032 case 0x2c:
13033 GETBYTE ();
13034 switch (op[2] & 0x00)
13035 {
13036 case 0x00:
13037 goto op_semantics_95;
13038 break;
13039 }
13040 break;
13041 case 0x2d:
13042 GETBYTE ();
13043 switch (op[2] & 0x00)
13044 {
13045 case 0x00:
13046 goto op_semantics_95;
13047 break;
13048 }
13049 break;
13050 case 0x2e:
13051 GETBYTE ();
13052 switch (op[2] & 0x00)
13053 {
13054 case 0x00:
13055 goto op_semantics_95;
13056 break;
13057 }
13058 break;
13059 case 0x2f:
13060 GETBYTE ();
13061 switch (op[2] & 0x00)
13062 {
13063 case 0x00:
13064 goto op_semantics_95;
13065 break;
13066 }
13067 break;
13068 case 0x40:
13069 GETBYTE ();
13070 switch (op[2] & 0x00)
13071 {
13072 case 0x00:
13073 op_semantics_96:
13074 {
13075 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
f282425e 13076#line 315 "rx-decode.opc"
c7927a3c 13077 int sz AU = (op[1] >> 4) & 0x03;
f282425e 13078#line 315 "rx-decode.opc"
c7927a3c 13079 int isrc AU = op[1] & 0x0f;
f282425e 13080#line 315 "rx-decode.opc"
c7927a3c 13081 int bsrc AU = (op[2] >> 4) & 0x0f;
f282425e 13082#line 315 "rx-decode.opc"
c7927a3c
NC		 13083 int rdst AU = op[2] & 0x0f;
13084 if (trace)
13085 {
13086 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13087 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13088 op[0], op[1], op[2]);
13089 printf (" sz = 0x%x,", sz);
13090 printf (" isrc = 0x%x,", isrc);
13091 printf (" bsrc = 0x%x,", bsrc);
13092 printf (" rdst = 0x%x\n", rdst);
13093 }
13094 SYNTAX("mov%s [%1, %2], %0");
f282425e 13095#line 315 "rx-decode.opc"
c7927a3c
NC		 13096 ID(movbi); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13097
13098 }
13099 break;
13100 }
13101 break;
13102 case 0x41:
13103 GETBYTE ();
13104 switch (op[2] & 0x00)
13105 {
13106 case 0x00:
13107 goto op_semantics_96;
13108 break;
13109 }
13110 break;
13111 case 0x42:
13112 GETBYTE ();
13113 switch (op[2] & 0x00)
13114 {
13115 case 0x00:
13116 goto op_semantics_96;
13117 break;
13118 }
13119 break;
13120 case 0x43:
13121 GETBYTE ();
13122 switch (op[2] & 0x00)
13123 {
13124 case 0x00:
13125 goto op_semantics_96;
13126 break;
13127 }
13128 break;
13129 case 0x44:
13130 GETBYTE ();
13131 switch (op[2] & 0x00)
13132 {
13133 case 0x00:
13134 goto op_semantics_96;
13135 break;
13136 }
13137 break;
13138 case 0x45:
13139 GETBYTE ();
13140 switch (op[2] & 0x00)
13141 {
13142 case 0x00:
13143 goto op_semantics_96;
13144 break;
13145 }
13146 break;
13147 case 0x46:
13148 GETBYTE ();
13149 switch (op[2] & 0x00)
13150 {
13151 case 0x00:
13152 goto op_semantics_96;
13153 break;
13154 }
13155 break;
13156 case 0x47:
13157 GETBYTE ();
13158 switch (op[2] & 0x00)
13159 {
13160 case 0x00:
13161 goto op_semantics_96;
13162 break;
13163 }
13164 break;
13165 case 0x48:
13166 GETBYTE ();
13167 switch (op[2] & 0x00)
13168 {
13169 case 0x00:
13170 goto op_semantics_96;
13171 break;
13172 }
13173 break;
13174 case 0x49:
13175 GETBYTE ();
13176 switch (op[2] & 0x00)
13177 {
13178 case 0x00:
13179 goto op_semantics_96;
13180 break;
13181 }
13182 break;
13183 case 0x4a:
13184 GETBYTE ();
13185 switch (op[2] & 0x00)
13186 {
13187 case 0x00:
13188 goto op_semantics_96;
13189 break;
13190 }
13191 break;
13192 case 0x4b:
13193 GETBYTE ();
13194 switch (op[2] & 0x00)
13195 {
13196 case 0x00:
13197 goto op_semantics_96;
13198 break;
13199 }
13200 break;
13201 case 0x4c:
13202 GETBYTE ();
13203 switch (op[2] & 0x00)
13204 {
13205 case 0x00:
13206 goto op_semantics_96;
13207 break;
13208 }
13209 break;
13210 case 0x4d:
13211 GETBYTE ();
13212 switch (op[2] & 0x00)
13213 {
13214 case 0x00:
13215 goto op_semantics_96;
13216 break;
13217 }
13218 break;
13219 case 0x4e:
13220 GETBYTE ();
13221 switch (op[2] & 0x00)
13222 {
13223 case 0x00:
13224 goto op_semantics_96;
13225 break;
13226 }
13227 break;
13228 case 0x4f:
13229 GETBYTE ();
13230 switch (op[2] & 0x00)
13231 {
13232 case 0x00:
13233 goto op_semantics_96;
13234 break;
13235 }
13236 break;
13237 case 0x50:
13238 GETBYTE ();
13239 switch (op[2] & 0x00)
13240 {
13241 case 0x00:
13242 goto op_semantics_96;
13243 break;
13244 }
13245 break;
13246 case 0x51:
13247 GETBYTE ();
13248 switch (op[2] & 0x00)
13249 {
13250 case 0x00:
13251 goto op_semantics_96;
13252 break;
13253 }
13254 break;
13255 case 0x52:
13256 GETBYTE ();
13257 switch (op[2] & 0x00)
13258 {
13259 case 0x00:
13260 goto op_semantics_96;
13261 break;
13262 }
13263 break;
13264 case 0x53:
13265 GETBYTE ();
13266 switch (op[2] & 0x00)
13267 {
13268 case 0x00:
13269 goto op_semantics_96;
13270 break;
13271 }
13272 break;
13273 case 0x54:
13274 GETBYTE ();
13275 switch (op[2] & 0x00)
13276 {
13277 case 0x00:
13278 goto op_semantics_96;
13279 break;
13280 }
13281 break;
13282 case 0x55:
13283 GETBYTE ();
13284 switch (op[2] & 0x00)
13285 {
13286 case 0x00:
13287 goto op_semantics_96;
13288 break;
13289 }
13290 break;
13291 case 0x56:
13292 GETBYTE ();
13293 switch (op[2] & 0x00)
13294 {
13295 case 0x00:
13296 goto op_semantics_96;
13297 break;
13298 }
13299 break;
13300 case 0x57:
13301 GETBYTE ();
13302 switch (op[2] & 0x00)
13303 {
13304 case 0x00:
13305 goto op_semantics_96;
13306 break;
13307 }
13308 break;
13309 case 0x58:
13310 GETBYTE ();
13311 switch (op[2] & 0x00)
13312 {
13313 case 0x00:
13314 goto op_semantics_96;
13315 break;
13316 }
13317 break;
13318 case 0x59:
13319 GETBYTE ();
13320 switch (op[2] & 0x00)
13321 {
13322 case 0x00:
13323 goto op_semantics_96;
13324 break;
13325 }
13326 break;
13327 case 0x5a:
13328 GETBYTE ();
13329 switch (op[2] & 0x00)
13330 {
13331 case 0x00:
13332 goto op_semantics_96;
13333 break;
13334 }
13335 break;
13336 case 0x5b:
13337 GETBYTE ();
13338 switch (op[2] & 0x00)
13339 {
13340 case 0x00:
13341 goto op_semantics_96;
13342 break;
13343 }
13344 break;
13345 case 0x5c:
13346 GETBYTE ();
13347 switch (op[2] & 0x00)
13348 {
13349 case 0x00:
13350 goto op_semantics_96;
13351 break;
13352 }
13353 break;
13354 case 0x5d:
13355 GETBYTE ();
13356 switch (op[2] & 0x00)
13357 {
13358 case 0x00:
13359 goto op_semantics_96;
13360 break;
13361 }
13362 break;
13363 case 0x5e:
13364 GETBYTE ();
13365 switch (op[2] & 0x00)
13366 {
13367 case 0x00:
13368 goto op_semantics_96;
13369 break;
13370 }
13371 break;
13372 case 0x5f:
13373 GETBYTE ();
13374 switch (op[2] & 0x00)
13375 {
13376 case 0x00:
13377 goto op_semantics_96;
13378 break;
13379 }
13380 break;
13381 case 0x60:
13382 GETBYTE ();
13383 switch (op[2] & 0x00)
13384 {
13385 case 0x00:
13386 goto op_semantics_96;
13387 break;
13388 }
13389 break;
13390 case 0x61:
13391 GETBYTE ();
13392 switch (op[2] & 0x00)
13393 {
13394 case 0x00:
13395 goto op_semantics_96;
13396 break;
13397 }
13398 break;
13399 case 0x62:
13400 GETBYTE ();
13401 switch (op[2] & 0x00)
13402 {
13403 case 0x00:
13404 goto op_semantics_96;
13405 break;
13406 }
13407 break;
13408 case 0x63:
13409 GETBYTE ();
13410 switch (op[2] & 0x00)
13411 {
13412 case 0x00:
13413 goto op_semantics_96;
13414 break;
13415 }
13416 break;
13417 case 0x64:
13418 GETBYTE ();
13419 switch (op[2] & 0x00)
13420 {
13421 case 0x00:
13422 goto op_semantics_96;
13423 break;
13424 }
13425 break;
13426 case 0x65:
13427 GETBYTE ();
13428 switch (op[2] & 0x00)
13429 {
13430 case 0x00:
13431 goto op_semantics_96;
13432 break;
13433 }
13434 break;
13435 case 0x66:
13436 GETBYTE ();
13437 switch (op[2] & 0x00)
13438 {
13439 case 0x00:
13440 goto op_semantics_96;
13441 break;
13442 }
13443 break;
13444 case 0x67:
13445 GETBYTE ();
13446 switch (op[2] & 0x00)
13447 {
13448 case 0x00:
13449 goto op_semantics_96;
13450 break;
13451 }
13452 break;
13453 case 0x68:
13454 GETBYTE ();
13455 switch (op[2] & 0x00)
13456 {
13457 case 0x00:
13458 goto op_semantics_96;
13459 break;
13460 }
13461 break;
13462 case 0x69:
13463 GETBYTE ();
13464 switch (op[2] & 0x00)
13465 {
13466 case 0x00:
13467 goto op_semantics_96;
13468 break;
13469 }
13470 break;
13471 case 0x6a:
13472 GETBYTE ();
13473 switch (op[2] & 0x00)
13474 {
13475 case 0x00:
13476 goto op_semantics_96;
13477 break;
13478 }
13479 break;
13480 case 0x6b:
13481 GETBYTE ();
13482 switch (op[2] & 0x00)
13483 {
13484 case 0x00:
13485 goto op_semantics_96;
13486 break;
13487 }
13488 break;
13489 case 0x6c:
13490 GETBYTE ();
13491 switch (op[2] & 0x00)
13492 {
13493 case 0x00:
13494 goto op_semantics_96;
13495 break;
13496 }
13497 break;
13498 case 0x6d:
13499 GETBYTE ();
13500 switch (op[2] & 0x00)
13501 {
13502 case 0x00:
13503 goto op_semantics_96;
13504 break;
13505 }
13506 break;
13507 case 0x6e:
13508 GETBYTE ();
13509 switch (op[2] & 0x00)
13510 {
13511 case 0x00:
13512 goto op_semantics_96;
13513 break;
13514 }
13515 break;
13516 case 0x6f:
13517 GETBYTE ();
13518 switch (op[2] & 0x00)
13519 {
13520 case 0x00:
13521 goto op_semantics_96;
13522 break;
13523 }
13524 break;
13525 case 0xc0:
13526 GETBYTE ();
13527 switch (op[2] & 0x00)
13528 {
13529 case 0x00:
13530 op_semantics_97:
13531 {
13532 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
f282425e 13533#line 321 "rx-decode.opc"
c7927a3c 13534 int sz AU = (op[1] >> 4) & 0x03;
f282425e 13535#line 321 "rx-decode.opc"
c7927a3c 13536 int isrc AU = op[1] & 0x0f;
f282425e 13537#line 321 "rx-decode.opc"
c7927a3c 13538 int bsrc AU = (op[2] >> 4) & 0x0f;
f282425e 13539#line 321 "rx-decode.opc"
c7927a3c
NC		 13540 int rdst AU = op[2] & 0x0f;
13541 if (trace)
13542 {
13543 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13544 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13545 op[0], op[1], op[2]);
13546 printf (" sz = 0x%x,", sz);
13547 printf (" isrc = 0x%x,", isrc);
13548 printf (" bsrc = 0x%x,", bsrc);
13549 printf (" rdst = 0x%x\n", rdst);
13550 }
13551 SYNTAX("movu%s [%1, %2], %0");
f282425e 13552#line 321 "rx-decode.opc"
c7927a3c
NC		 13553 ID(movbi); uBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13554
13555 }
13556 break;
13557 }
13558 break;
13559 case 0xc1:
13560 GETBYTE ();
13561 switch (op[2] & 0x00)
13562 {
13563 case 0x00:
13564 goto op_semantics_97;
13565 break;
13566 }
13567 break;
13568 case 0xc2:
13569 GETBYTE ();
13570 switch (op[2] & 0x00)
13571 {
13572 case 0x00:
13573 goto op_semantics_97;
13574 break;
13575 }
13576 break;
13577 case 0xc3:
13578 GETBYTE ();
13579 switch (op[2] & 0x00)
13580 {
13581 case 0x00:
13582 goto op_semantics_97;
13583 break;
13584 }
13585 break;
13586 case 0xc4:
13587 GETBYTE ();
13588 switch (op[2] & 0x00)
13589 {
13590 case 0x00:
13591 goto op_semantics_97;
13592 break;
13593 }
13594 break;
13595 case 0xc5:
13596 GETBYTE ();
13597 switch (op[2] & 0x00)
13598 {
13599 case 0x00:
13600 goto op_semantics_97;
13601 break;
13602 }
13603 break;
13604 case 0xc6:
13605 GETBYTE ();
13606 switch (op[2] & 0x00)
13607 {
13608 case 0x00:
13609 goto op_semantics_97;
13610 break;
13611 }
13612 break;
13613 case 0xc7:
13614 GETBYTE ();
13615 switch (op[2] & 0x00)
13616 {
13617 case 0x00:
13618 goto op_semantics_97;
13619 break;
13620 }
13621 break;
13622 case 0xc8:
13623 GETBYTE ();
13624 switch (op[2] & 0x00)
13625 {
13626 case 0x00:
13627 goto op_semantics_97;
13628 break;
13629 }
13630 break;
13631 case 0xc9:
13632 GETBYTE ();
13633 switch (op[2] & 0x00)
13634 {
13635 case 0x00:
13636 goto op_semantics_97;
13637 break;
13638 }
13639 break;
13640 case 0xca:
13641 GETBYTE ();
13642 switch (op[2] & 0x00)
13643 {
13644 case 0x00:
13645 goto op_semantics_97;
13646 break;
13647 }
13648 break;
13649 case 0xcb:
13650 GETBYTE ();
13651 switch (op[2] & 0x00)
13652 {
13653 case 0x00:
13654 goto op_semantics_97;
13655 break;
13656 }
13657 break;
13658 case 0xcc:
13659 GETBYTE ();
13660 switch (op[2] & 0x00)
13661 {
13662 case 0x00:
13663 goto op_semantics_97;
13664 break;
13665 }
13666 break;
13667 case 0xcd:
13668 GETBYTE ();
13669 switch (op[2] & 0x00)
13670 {
13671 case 0x00:
13672 goto op_semantics_97;
13673 break;
13674 }
13675 break;
13676 case 0xce:
13677 GETBYTE ();
13678 switch (op[2] & 0x00)
13679 {
13680 case 0x00:
13681 goto op_semantics_97;
13682 break;
13683 }
13684 break;
13685 case 0xcf:
13686 GETBYTE ();
13687 switch (op[2] & 0x00)
13688 {
13689 case 0x00:
13690 goto op_semantics_97;
13691 break;
13692 }
13693 break;
13694 case 0xd0:
13695 GETBYTE ();
13696 switch (op[2] & 0x00)
13697 {
13698 case 0x00:
13699 goto op_semantics_97;
13700 break;
13701 }
13702 break;
13703 case 0xd1:
13704 GETBYTE ();
13705 switch (op[2] & 0x00)
13706 {
13707 case 0x00:
13708 goto op_semantics_97;
13709 break;
13710 }
13711 break;
13712 case 0xd2:
13713 GETBYTE ();
13714 switch (op[2] & 0x00)
13715 {
13716 case 0x00:
13717 goto op_semantics_97;
13718 break;
13719 }
13720 break;
13721 case 0xd3:
13722 GETBYTE ();
13723 switch (op[2] & 0x00)
13724 {
13725 case 0x00:
13726 goto op_semantics_97;
13727 break;
13728 }
13729 break;
13730 case 0xd4:
13731 GETBYTE ();
13732 switch (op[2] & 0x00)
13733 {
13734 case 0x00:
13735 goto op_semantics_97;
13736 break;
13737 }
13738 break;
13739 case 0xd5:
13740 GETBYTE ();
13741 switch (op[2] & 0x00)
13742 {
13743 case 0x00:
13744 goto op_semantics_97;
13745 break;
13746 }
13747 break;
13748 case 0xd6:
13749 GETBYTE ();
13750 switch (op[2] & 0x00)
13751 {
13752 case 0x00:
13753 goto op_semantics_97;
13754 break;
13755 }
13756 break;
13757 case 0xd7:
13758 GETBYTE ();
13759 switch (op[2] & 0x00)
13760 {
13761 case 0x00:
13762 goto op_semantics_97;
13763 break;
13764 }
13765 break;
13766 case 0xd8:
13767 GETBYTE ();
13768 switch (op[2] & 0x00)
13769 {
13770 case 0x00:
13771 goto op_semantics_97;
13772 break;
13773 }
13774 break;
13775 case 0xd9:
13776 GETBYTE ();
13777 switch (op[2] & 0x00)
13778 {
13779 case 0x00:
13780 goto op_semantics_97;
13781 break;
13782 }
13783 break;
13784 case 0xda:
13785 GETBYTE ();
13786 switch (op[2] & 0x00)
13787 {
13788 case 0x00:
13789 goto op_semantics_97;
13790 break;
13791 }
13792 break;
13793 case 0xdb:
13794 GETBYTE ();
13795 switch (op[2] & 0x00)
13796 {
13797 case 0x00:
13798 goto op_semantics_97;
13799 break;
13800 }
13801 break;
13802 case 0xdc:
13803 GETBYTE ();
13804 switch (op[2] & 0x00)
13805 {
13806 case 0x00:
13807 goto op_semantics_97;
13808 break;
13809 }
13810 break;
13811 case 0xdd:
13812 GETBYTE ();
13813 switch (op[2] & 0x00)
13814 {
13815 case 0x00:
13816 goto op_semantics_97;
13817 break;
13818 }
13819 break;
13820 case 0xde:
13821 GETBYTE ();
13822 switch (op[2] & 0x00)
13823 {
13824 case 0x00:
13825 goto op_semantics_97;
13826 break;
13827 }
13828 break;
13829 case 0xdf:
13830 GETBYTE ();
13831 switch (op[2] & 0x00)
13832 {
13833 case 0x00:
13834 goto op_semantics_97;
13835 break;
13836 }
13837 break;
13838 case 0xe0:
13839 GETBYTE ();
13840 switch (op[2] & 0x00)
13841 {
13842 case 0x00:
13843 goto op_semantics_97;
13844 break;
13845 }
13846 break;
13847 case 0xe1:
13848 GETBYTE ();
13849 switch (op[2] & 0x00)
13850 {
13851 case 0x00:
13852 goto op_semantics_97;
13853 break;
13854 }
13855 break;
13856 case 0xe2:
13857 GETBYTE ();
13858 switch (op[2] & 0x00)
13859 {
13860 case 0x00:
13861 goto op_semantics_97;
13862 break;
13863 }
13864 break;
13865 case 0xe3:
13866 GETBYTE ();
13867 switch (op[2] & 0x00)
13868 {
13869 case 0x00:
13870 goto op_semantics_97;
13871 break;
13872 }
13873 break;
13874 case 0xe4:
13875 GETBYTE ();
13876 switch (op[2] & 0x00)
13877 {
13878 case 0x00:
13879 goto op_semantics_97;
13880 break;
13881 }
13882 break;
13883 case 0xe5:
13884 GETBYTE ();
13885 switch (op[2] & 0x00)
13886 {
13887 case 0x00:
13888 goto op_semantics_97;
13889 break;
13890 }
13891 break;
13892 case 0xe6:
13893 GETBYTE ();
13894 switch (op[2] & 0x00)
13895 {
13896 case 0x00:
13897 goto op_semantics_97;
13898 break;
13899 }
13900 break;
13901 case 0xe7:
13902 GETBYTE ();
13903 switch (op[2] & 0x00)
13904 {
13905 case 0x00:
13906 goto op_semantics_97;
13907 break;
13908 }
13909 break;
13910 case 0xe8:
13911 GETBYTE ();
13912 switch (op[2] & 0x00)
13913 {
13914 case 0x00:
13915 goto op_semantics_97;
13916 break;
13917 }
13918 break;
13919 case 0xe9:
13920 GETBYTE ();
13921 switch (op[2] & 0x00)
13922 {
13923 case 0x00:
13924 goto op_semantics_97;
13925 break;
13926 }
13927 break;
13928 case 0xea:
13929 GETBYTE ();
13930 switch (op[2] & 0x00)
13931 {
13932 case 0x00:
13933 goto op_semantics_97;
13934 break;
13935 }
13936 break;
13937 case 0xeb:
13938 GETBYTE ();
13939 switch (op[2] & 0x00)
13940 {
13941 case 0x00:
13942 goto op_semantics_97;
13943 break;
13944 }
13945 break;
13946 case 0xec:
13947 GETBYTE ();
13948 switch (op[2] & 0x00)
13949 {
13950 case 0x00:
13951 goto op_semantics_97;
13952 break;
13953 }
13954 break;
13955 case 0xed:
13956 GETBYTE ();
13957 switch (op[2] & 0x00)
13958 {
13959 case 0x00:
13960 goto op_semantics_97;
13961 break;
13962 }
13963 break;
13964 case 0xee:
13965 GETBYTE ();
13966 switch (op[2] & 0x00)
13967 {
13968 case 0x00:
13969 goto op_semantics_97;
13970 break;
13971 }
13972 break;
13973 case 0xef:
13974 GETBYTE ();
13975 switch (op[2] & 0x00)
13976 {
13977 case 0x00:
13978 goto op_semantics_97;
13979 break;
13980 }
13981 break;
13982 default: UNSUPPORTED(); break;
13983 }
13984 break;
13985 case 0xff:
13986 GETBYTE ();
13987 switch (op[1] & 0xff)
13988 {
13989 case 0x00:
13990 GETBYTE ();
13991 switch (op[2] & 0x00)
13992 {
13993 case 0x00:
13994 op_semantics_98:
13995 {
13996 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
f282425e 13997#line 525 "rx-decode.opc"
c7927a3c 13998 int rdst AU = op[1] & 0x0f;
f282425e 13999#line 525 "rx-decode.opc"
c7927a3c 14000 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 14001#line 525 "rx-decode.opc"
c7927a3c
NC		 14002 int srcb AU = op[2] & 0x0f;
14003 if (trace)
14004 {
14005 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14006 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
14007 op[0], op[1], op[2]);
14008 printf (" rdst = 0x%x,", rdst);
14009 printf (" srca = 0x%x,", srca);
14010 printf (" srcb = 0x%x\n", srcb);
14011 }
14012 SYNTAX("sub %2, %1, %0");
f282425e 14013#line 525 "rx-decode.opc"
c7927a3c
NC		 14014 ID(sub); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14015
14016 /*----------------------------------------------------------------------*/
14017 /* SBB */
14018
14019 }
14020 break;
14021 }
14022 break;
14023 case 0x01:
14024 GETBYTE ();
14025 switch (op[2] & 0x00)
14026 {
14027 case 0x00:
14028 goto op_semantics_98;
14029 break;
14030 }
14031 break;
14032 case 0x02:
14033 GETBYTE ();
14034 switch (op[2] & 0x00)
14035 {
14036 case 0x00:
14037 goto op_semantics_98;
14038 break;
14039 }
14040 break;
14041 case 0x03:
14042 GETBYTE ();
14043 switch (op[2] & 0x00)
14044 {
14045 case 0x00:
14046 goto op_semantics_98;
14047 break;
14048 }
14049 break;
14050 case 0x04:
14051 GETBYTE ();
14052 switch (op[2] & 0x00)
14053 {
14054 case 0x00:
14055 goto op_semantics_98;
14056 break;
14057 }
14058 break;
14059 case 0x05:
14060 GETBYTE ();
14061 switch (op[2] & 0x00)
14062 {
14063 case 0x00:
14064 goto op_semantics_98;
14065 break;
14066 }
14067 break;
14068 case 0x06:
14069 GETBYTE ();
14070 switch (op[2] & 0x00)
14071 {
14072 case 0x00:
14073 goto op_semantics_98;
14074 break;
14075 }
14076 break;
14077 case 0x07:
14078 GETBYTE ();
14079 switch (op[2] & 0x00)
14080 {
14081 case 0x00:
14082 goto op_semantics_98;
14083 break;
14084 }
14085 break;
14086 case 0x08:
14087 GETBYTE ();
14088 switch (op[2] & 0x00)
14089 {
14090 case 0x00:
14091 goto op_semantics_98;
14092 break;
14093 }
14094 break;
14095 case 0x09:
14096 GETBYTE ();
14097 switch (op[2] & 0x00)
14098 {
14099 case 0x00:
14100 goto op_semantics_98;
14101 break;
14102 }
14103 break;
14104 case 0x0a:
14105 GETBYTE ();
14106 switch (op[2] & 0x00)
14107 {
14108 case 0x00:
14109 goto op_semantics_98;
14110 break;
14111 }
14112 break;
14113 case 0x0b:
14114 GETBYTE ();
14115 switch (op[2] & 0x00)
14116 {
14117 case 0x00:
14118 goto op_semantics_98;
14119 break;
14120 }
14121 break;
14122 case 0x0c:
14123 GETBYTE ();
14124 switch (op[2] & 0x00)
14125 {
14126 case 0x00:
14127 goto op_semantics_98;
14128 break;
14129 }
14130 break;
14131 case 0x0d:
14132 GETBYTE ();
14133 switch (op[2] & 0x00)
14134 {
14135 case 0x00:
14136 goto op_semantics_98;
14137 break;
14138 }
14139 break;
14140 case 0x0e:
14141 GETBYTE ();
14142 switch (op[2] & 0x00)
14143 {
14144 case 0x00:
14145 goto op_semantics_98;
14146 break;
14147 }
14148 break;
14149 case 0x0f:
14150 GETBYTE ();
14151 switch (op[2] & 0x00)
14152 {
14153 case 0x00:
14154 goto op_semantics_98;
14155 break;
14156 }
14157 break;
14158 case 0x20:
14159 GETBYTE ();
14160 switch (op[2] & 0x00)
14161 {
14162 case 0x00:
14163 op_semantics_99:
14164 {
14165 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
f282425e 14166#line 492 "rx-decode.opc"
c7927a3c 14167 int rdst AU = op[1] & 0x0f;
f282425e 14168#line 492 "rx-decode.opc"
c7927a3c 14169 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 14170#line 492 "rx-decode.opc"
c7927a3c
NC		 14171 int srcb AU = op[2] & 0x0f;
14172 if (trace)
14173 {
14174 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14175 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14176 op[0], op[1], op[2]);
14177 printf (" rdst = 0x%x,", rdst);
14178 printf (" srca = 0x%x,", srca);
14179 printf (" srcb = 0x%x\n", srcb);
14180 }
14181 SYNTAX("add %2, %1, %0");
f282425e 14182#line 492 "rx-decode.opc"
c7927a3c
NC		 14183 ID(add); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14184
14185 /*----------------------------------------------------------------------*/
14186 /* CMP */
14187
14188 }
14189 break;
14190 }
14191 break;
14192 case 0x21:
14193 GETBYTE ();
14194 switch (op[2] & 0x00)
14195 {
14196 case 0x00:
14197 goto op_semantics_99;
14198 break;
14199 }
14200 break;
14201 case 0x22:
14202 GETBYTE ();
14203 switch (op[2] & 0x00)
14204 {
14205 case 0x00:
14206 goto op_semantics_99;
14207 break;
14208 }
14209 break;
14210 case 0x23:
14211 GETBYTE ();
14212 switch (op[2] & 0x00)
14213 {
14214 case 0x00:
14215 goto op_semantics_99;
14216 break;
14217 }
14218 break;
14219 case 0x24:
14220 GETBYTE ();
14221 switch (op[2] & 0x00)
14222 {
14223 case 0x00:
14224 goto op_semantics_99;
14225 break;
14226 }
14227 break;
14228 case 0x25:
14229 GETBYTE ();
14230 switch (op[2] & 0x00)
14231 {
14232 case 0x00:
14233 goto op_semantics_99;
14234 break;
14235 }
14236 break;
14237 case 0x26:
14238 GETBYTE ();
14239 switch (op[2] & 0x00)
14240 {
14241 case 0x00:
14242 goto op_semantics_99;
14243 break;
14244 }
14245 break;
14246 case 0x27:
14247 GETBYTE ();
14248 switch (op[2] & 0x00)
14249 {
14250 case 0x00:
14251 goto op_semantics_99;
14252 break;
14253 }
14254 break;
14255 case 0x28:
14256 GETBYTE ();
14257 switch (op[2] & 0x00)
14258 {
14259 case 0x00:
14260 goto op_semantics_99;
14261 break;
14262 }
14263 break;
14264 case 0x29:
14265 GETBYTE ();
14266 switch (op[2] & 0x00)
14267 {
14268 case 0x00:
14269 goto op_semantics_99;
14270 break;
14271 }
14272 break;
14273 case 0x2a:
14274 GETBYTE ();
14275 switch (op[2] & 0x00)
14276 {
14277 case 0x00:
14278 goto op_semantics_99;
14279 break;
14280 }
14281 break;
14282 case 0x2b:
14283 GETBYTE ();
14284 switch (op[2] & 0x00)
14285 {
14286 case 0x00:
14287 goto op_semantics_99;
14288 break;
14289 }
14290 break;
14291 case 0x2c:
14292 GETBYTE ();
14293 switch (op[2] & 0x00)
14294 {
14295 case 0x00:
14296 goto op_semantics_99;
14297 break;
14298 }
14299 break;
14300 case 0x2d:
14301 GETBYTE ();
14302 switch (op[2] & 0x00)
14303 {
14304 case 0x00:
14305 goto op_semantics_99;
14306 break;
14307 }
14308 break;
14309 case 0x2e:
14310 GETBYTE ();
14311 switch (op[2] & 0x00)
14312 {
14313 case 0x00:
14314 goto op_semantics_99;
14315 break;
14316 }
14317 break;
14318 case 0x2f:
14319 GETBYTE ();
14320 switch (op[2] & 0x00)
14321 {
14322 case 0x00:
14323 goto op_semantics_99;
14324 break;
14325 }
14326 break;
14327 case 0x30:
14328 GETBYTE ();
14329 switch (op[2] & 0x00)
14330 {
14331 case 0x00:
14332 op_semantics_100:
14333 {
14334 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
f282425e 14335#line 586 "rx-decode.opc"
c7927a3c 14336 int rdst AU = op[1] & 0x0f;
f282425e 14337#line 586 "rx-decode.opc"
c7927a3c 14338 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 14339#line 586 "rx-decode.opc"
c7927a3c
NC		 14340 int srcb AU = op[2] & 0x0f;
14341 if (trace)
14342 {
14343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14344 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14345 op[0], op[1], op[2]);
14346 printf (" rdst = 0x%x,", rdst);
14347 printf (" srca = 0x%x,", srca);
14348 printf (" srcb = 0x%x\n", srcb);
14349 }
14350 SYNTAX("mul %2, %1, %0");
f282425e
DD		 14351#line 586 "rx-decode.opc"
14352 ID(mul); DR(rdst); SR(srcb); S2R(srca); F("----");
c7927a3c
NC		 14353
14354 /*----------------------------------------------------------------------*/
14355 /* EMUL */
14356
14357 }
14358 break;
14359 }
14360 break;
14361 case 0x31:
14362 GETBYTE ();
14363 switch (op[2] & 0x00)
14364 {
14365 case 0x00:
14366 goto op_semantics_100;
14367 break;
14368 }
14369 break;
14370 case 0x32:
14371 GETBYTE ();
14372 switch (op[2] & 0x00)
14373 {
14374 case 0x00:
14375 goto op_semantics_100;
14376 break;
14377 }
14378 break;
14379 case 0x33:
14380 GETBYTE ();
14381 switch (op[2] & 0x00)
14382 {
14383 case 0x00:
14384 goto op_semantics_100;
14385 break;
14386 }
14387 break;
14388 case 0x34:
14389 GETBYTE ();
14390 switch (op[2] & 0x00)
14391 {
14392 case 0x00:
14393 goto op_semantics_100;
14394 break;
14395 }
14396 break;
14397 case 0x35:
14398 GETBYTE ();
14399 switch (op[2] & 0x00)
14400 {
14401 case 0x00:
14402 goto op_semantics_100;
14403 break;
14404 }
14405 break;
14406 case 0x36:
14407 GETBYTE ();
14408 switch (op[2] & 0x00)
14409 {
14410 case 0x00:
14411 goto op_semantics_100;
14412 break;
14413 }
14414 break;
14415 case 0x37:
14416 GETBYTE ();
14417 switch (op[2] & 0x00)
14418 {
14419 case 0x00:
14420 goto op_semantics_100;
14421 break;
14422 }
14423 break;
14424 case 0x38:
14425 GETBYTE ();
14426 switch (op[2] & 0x00)
14427 {
14428 case 0x00:
14429 goto op_semantics_100;
14430 break;
14431 }
14432 break;
14433 case 0x39:
14434 GETBYTE ();
14435 switch (op[2] & 0x00)
14436 {
14437 case 0x00:
14438 goto op_semantics_100;
14439 break;
14440 }
14441 break;
14442 case 0x3a:
14443 GETBYTE ();
14444 switch (op[2] & 0x00)
14445 {
14446 case 0x00:
14447 goto op_semantics_100;
14448 break;
14449 }
14450 break;
14451 case 0x3b:
14452 GETBYTE ();
14453 switch (op[2] & 0x00)
14454 {
14455 case 0x00:
14456 goto op_semantics_100;
14457 break;
14458 }
14459 break;
14460 case 0x3c:
14461 GETBYTE ();
14462 switch (op[2] & 0x00)
14463 {
14464 case 0x00:
14465 goto op_semantics_100;
14466 break;
14467 }
14468 break;
14469 case 0x3d:
14470 GETBYTE ();
14471 switch (op[2] & 0x00)
14472 {
14473 case 0x00:
14474 goto op_semantics_100;
14475 break;
14476 }
14477 break;
14478 case 0x3e:
14479 GETBYTE ();
14480 switch (op[2] & 0x00)
14481 {
14482 case 0x00:
14483 goto op_semantics_100;
14484 break;
14485 }
14486 break;
14487 case 0x3f:
14488 GETBYTE ();
14489 switch (op[2] & 0x00)
14490 {
14491 case 0x00:
14492 goto op_semantics_100;
14493 break;
14494 }
14495 break;
14496 case 0x40:
14497 GETBYTE ();
14498 switch (op[2] & 0x00)
14499 {
14500 case 0x00:
14501 op_semantics_101:
14502 {
14503 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
f282425e 14504#line 402 "rx-decode.opc"
c7927a3c 14505 int rdst AU = op[1] & 0x0f;
f282425e 14506#line 402 "rx-decode.opc"
c7927a3c 14507 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 14508#line 402 "rx-decode.opc"
c7927a3c
NC		 14509 int srcb AU = op[2] & 0x0f;
14510 if (trace)
14511 {
14512 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14513 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14514 op[0], op[1], op[2]);
14515 printf (" rdst = 0x%x,", rdst);
14516 printf (" srca = 0x%x,", srca);
14517 printf (" srcb = 0x%x\n", srcb);
14518 }
14519 SYNTAX("and %2, %1, %0");
f282425e 14520#line 402 "rx-decode.opc"
c7927a3c
NC		 14521 ID(and); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14522
14523 /*----------------------------------------------------------------------*/
14524 /* OR */
14525
14526 }
14527 break;
14528 }
14529 break;
14530 case 0x41:
14531 GETBYTE ();
14532 switch (op[2] & 0x00)
14533 {
14534 case 0x00:
14535 goto op_semantics_101;
14536 break;
14537 }
14538 break;
14539 case 0x42:
14540 GETBYTE ();
14541 switch (op[2] & 0x00)
14542 {
14543 case 0x00:
14544 goto op_semantics_101;
14545 break;
14546 }
14547 break;
14548 case 0x43:
14549 GETBYTE ();
14550 switch (op[2] & 0x00)
14551 {
14552 case 0x00:
14553 goto op_semantics_101;
14554 break;
14555 }
14556 break;
14557 case 0x44:
14558 GETBYTE ();
14559 switch (op[2] & 0x00)
14560 {
14561 case 0x00:
14562 goto op_semantics_101;
14563 break;
14564 }
14565 break;
14566 case 0x45:
14567 GETBYTE ();
14568 switch (op[2] & 0x00)
14569 {
14570 case 0x00:
14571 goto op_semantics_101;
14572 break;
14573 }
14574 break;
14575 case 0x46:
14576 GETBYTE ();
14577 switch (op[2] & 0x00)
14578 {
14579 case 0x00:
14580 goto op_semantics_101;
14581 break;
14582 }
14583 break;
14584 case 0x47:
14585 GETBYTE ();
14586 switch (op[2] & 0x00)
14587 {
14588 case 0x00:
14589 goto op_semantics_101;
14590 break;
14591 }
14592 break;
14593 case 0x48:
14594 GETBYTE ();
14595 switch (op[2] & 0x00)
14596 {
14597 case 0x00:
14598 goto op_semantics_101;
14599 break;
14600 }
14601 break;
14602 case 0x49:
14603 GETBYTE ();
14604 switch (op[2] & 0x00)
14605 {
14606 case 0x00:
14607 goto op_semantics_101;
14608 break;
14609 }
14610 break;
14611 case 0x4a:
14612 GETBYTE ();
14613 switch (op[2] & 0x00)
14614 {
14615 case 0x00:
14616 goto op_semantics_101;
14617 break;
14618 }
14619 break;
14620 case 0x4b:
14621 GETBYTE ();
14622 switch (op[2] & 0x00)
14623 {
14624 case 0x00:
14625 goto op_semantics_101;
14626 break;
14627 }
14628 break;
14629 case 0x4c:
14630 GETBYTE ();
14631 switch (op[2] & 0x00)
14632 {
14633 case 0x00:
14634 goto op_semantics_101;
14635 break;
14636 }
14637 break;
14638 case 0x4d:
14639 GETBYTE ();
14640 switch (op[2] & 0x00)
14641 {
14642 case 0x00:
14643 goto op_semantics_101;
14644 break;
14645 }
14646 break;
14647 case 0x4e:
14648 GETBYTE ();
14649 switch (op[2] & 0x00)
14650 {
14651 case 0x00:
14652 goto op_semantics_101;
14653 break;
14654 }
14655 break;
14656 case 0x4f:
14657 GETBYTE ();
14658 switch (op[2] & 0x00)
14659 {
14660 case 0x00:
14661 goto op_semantics_101;
14662 break;
14663 }
14664 break;
14665 case 0x50:
14666 GETBYTE ();
14667 switch (op[2] & 0x00)
14668 {
14669 case 0x00:
14670 op_semantics_102:
14671 {
14672 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
f282425e 14673#line 420 "rx-decode.opc"
c7927a3c 14674 int rdst AU = op[1] & 0x0f;
f282425e 14675#line 420 "rx-decode.opc"
c7927a3c 14676 int srca AU = (op[2] >> 4) & 0x0f;
f282425e 14677#line 420 "rx-decode.opc"
c7927a3c
NC		 14678 int srcb AU = op[2] & 0x0f;
14679 if (trace)
14680 {
14681 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14682 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14683 op[0], op[1], op[2]);
14684 printf (" rdst = 0x%x,", rdst);
14685 printf (" srca = 0x%x,", srca);
14686 printf (" srcb = 0x%x\n", srcb);
14687 }
14688 SYNTAX("or %2, %1, %0");
f282425e 14689#line 420 "rx-decode.opc"
c7927a3c
NC		 14690 ID(or); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14691
14692 /*----------------------------------------------------------------------*/
14693 /* XOR */
14694
14695 }
14696 break;
14697 }
14698 break;
14699 case 0x51:
14700 GETBYTE ();
14701 switch (op[2] & 0x00)
14702 {
14703 case 0x00:
14704 goto op_semantics_102;
14705 break;
14706 }
14707 break;
14708 case 0x52:
14709 GETBYTE ();
14710 switch (op[2] & 0x00)
14711 {
14712 case 0x00:
14713 goto op_semantics_102;
14714 break;
14715 }
14716 break;
14717 case 0x53:
14718 GETBYTE ();
14719 switch (op[2] & 0x00)
14720 {
14721 case 0x00:
14722 goto op_semantics_102;
14723 break;
14724 }
14725 break;
14726 case 0x54:
14727 GETBYTE ();
14728 switch (op[2] & 0x00)
14729 {
14730 case 0x00:
14731 goto op_semantics_102;
14732 break;
14733 }
14734 break;
14735 case 0x55:
14736 GETBYTE ();
14737 switch (op[2] & 0x00)
14738 {
14739 case 0x00:
14740 goto op_semantics_102;
14741 break;
14742 }
14743 break;
14744 case 0x56:
14745 GETBYTE ();
14746 switch (op[2] & 0x00)
14747 {
14748 case 0x00:
14749 goto op_semantics_102;
14750 break;
14751 }
14752 break;
14753 case 0x57:
14754 GETBYTE ();
14755 switch (op[2] & 0x00)
14756 {
14757 case 0x00:
14758 goto op_semantics_102;
14759 break;
14760 }
14761 break;
14762 case 0x58:
14763 GETBYTE ();
14764 switch (op[2] & 0x00)
14765 {
14766 case 0x00:
14767 goto op_semantics_102;
14768 break;
14769 }
14770 break;
14771 case 0x59:
14772 GETBYTE ();
14773 switch (op[2] & 0x00)
14774 {
14775 case 0x00:
14776 goto op_semantics_102;
14777 break;
14778 }
14779 break;
14780 case 0x5a:
14781 GETBYTE ();
14782 switch (op[2] & 0x00)
14783 {
14784 case 0x00:
14785 goto op_semantics_102;
14786 break;
14787 }
14788 break;
14789 case 0x5b:
14790 GETBYTE ();
14791 switch (op[2] & 0x00)
14792 {
14793 case 0x00:
14794 goto op_semantics_102;
14795 break;
14796 }
14797 break;
14798 case 0x5c:
14799 GETBYTE ();
14800 switch (op[2] & 0x00)
14801 {
14802 case 0x00:
14803 goto op_semantics_102;
14804 break;
14805 }
14806 break;
14807 case 0x5d:
14808 GETBYTE ();
14809 switch (op[2] & 0x00)
14810 {
14811 case 0x00:
14812 goto op_semantics_102;
14813 break;
14814 }
14815 break;
14816 case 0x5e:
14817 GETBYTE ();
14818 switch (op[2] & 0x00)
14819 {
14820 case 0x00:
14821 goto op_semantics_102;
14822 break;
14823 }
14824 break;
14825 case 0x5f:
14826 GETBYTE ();
14827 switch (op[2] & 0x00)
14828 {
14829 case 0x00:
14830 goto op_semantics_102;
14831 break;
14832 }
14833 break;
14834 default: UNSUPPORTED(); break;
14835 }
14836 break;
14837 default: UNSUPPORTED(); break;
14838 }
946ef196 14839#line 969 "rx-decode.opc"
c7927a3c
NC		 14840
14841 return rx->n_bytes;
14842}
GDB Binutils - Deliverables
This page took 0.784271 seconds and 4 git commands to generate.