projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Automatic date update in version.in
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
... / ...
CommitLineData
1#line 1 "rx-decode.opc"
2/* -*- c -*- */
3/* Copyright (C) 2012-2015 Free Software Foundation, Inc.
4 Contributed by Red Hat.
5 Written by DJ Delorie.
6
7 This file is part of the GNU opcodes library.
8
9 This library is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 It is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
17 License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
23
24#include "sysdep.h"
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include "ansidecl.h"
29#include "opcode/rx.h"
30
31#define RX_OPCODE_BIG_ENDIAN 0
32
33typedef struct
34{
35 RX_Opcode_Decoded * rx;
36 int (* getbyte)(void *);
37 void * ptr;
38 unsigned char * op;
39} LocalData;
40
41static int trace = 0;
42
43#define BSIZE 0
44#define WSIZE 1
45#define LSIZE 2
46
47/* These are for when the upper bits are "don't care" or "undefined". */
48static int bwl[] =
49{
50 RX_Byte,
51 RX_Word,
52 RX_Long,
53 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
54};
55
56static int sbwl[] =
57{
58 RX_SByte,
59 RX_SWord,
60 RX_Long,
61 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
62};
63
64static int ubw[] =
65{
66 RX_UByte,
67 RX_UWord,
68 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
69 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
70};
71
72static int memex[] =
73{
74 RX_SByte,
75 RX_SWord,
76 RX_Long,
77 RX_UWord
78};
79
80#define ID(x) rx->id = RXO_##x
81#define OP(n,t,r,a) (rx->op[n].type = t, \
82 rx->op[n].reg = r, \
83 rx->op[n].addend = a )
84#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
85 rx->op[n].size = s )
86
87/* This is for the BWL and BW bitfields. */
88static int SCALE[] = { 1, 2, 4, 0 };
89/* This is for the prefix size enum. */
90static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
91
92static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
93 16, 17, 0, 0, 0, 0, 0, 0 };
94
95static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
96
97/*
98 *C a constant (immediate) c
99 *R A register
100 *I Register indirect, no offset
101 *Is Register indirect, with offset
102 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
103 *P standard displacement: type (r,[r]), reg, assumes UByte
104 *Pm memex displacement: type (r,[r]), reg, memex code
105 *cc condition code. */
106
107#define DC(c) OP (0, RX_Operand_Immediate, 0, c)
108#define DR(r) OP (0, RX_Operand_Register, r, 0)
109#define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
110#define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
111#define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
112#define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
113
114#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
115#define SR(r) OP (1, RX_Operand_Register, r, 0)
116#define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
117#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
118#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
119#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
120#define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
121#define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
122#define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
123
124#define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
125#define S2R(r) OP (2, RX_Operand_Register, r, 0)
126#define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
127#define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
128#define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
129#define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
130#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
131#define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
132
133#define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
134#define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
135#define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
136#define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
137
138#define F(f) store_flags(rx, f)
139
140#define AU ATTRIBUTE_UNUSED
141#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
142
143#define SYNTAX(x) rx->syntax = x
144
145#define UNSUPPORTED() \
146 rx->syntax = "*unknown*"
147
148#define IMM(sf) immediate (sf, 0, ld)
149#define IMMex(sf) immediate (sf, 1, ld)
150
151static int
152immediate (int sfield, int ex, LocalData * ld)
153{
154 unsigned long i = 0, j;
155
156 switch (sfield)
157 {
158#define B ((unsigned long) GETBYTE())
159 case 0:
160#if RX_OPCODE_BIG_ENDIAN
161 i = B;
162 if (ex && (i & 0x80))
163 i -= 0x100;
164 i <<= 24;
165 i |= B << 16;
166 i |= B << 8;
167 i |= B;
168#else
169 i = B;
170 i |= B << 8;
171 i |= B << 16;
172 j = B;
173 if (ex && (j & 0x80))
174 j -= 0x100;
175 i |= j << 24;
176#endif
177 break;
178 case 3:
179#if RX_OPCODE_BIG_ENDIAN
180 i = B << 16;
181 i |= B << 8;
182 i |= B;
183#else
184 i = B;
185 i |= B << 8;
186 i |= B << 16;
187#endif
188 if (ex && (i & 0x800000))
189 i -= 0x1000000;
190 break;
191 case 2:
192#if RX_OPCODE_BIG_ENDIAN
193 i |= B << 8;
194 i |= B;
195#else
196 i |= B;
197 i |= B << 8;
198#endif
199 if (ex && (i & 0x8000))
200 i -= 0x10000;
201 break;
202 case 1:
203 i |= B;
204 if (ex && (i & 0x80))
205 i -= 0x100;
206 break;
207 default:
208 abort();
209 }
210 return i;
211}
212
213static void
214rx_disp (int n, int type, int reg, int size, LocalData * ld)
215{
216 int disp;
217
218 ld->rx->op[n].reg = reg;
219 switch (type)
220 {
221 case 3:
222 ld->rx->op[n].type = RX_Operand_Register;
223 break;
224 case 0:
225 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
226 ld->rx->op[n].addend = 0;
227 break;
228 case 1:
229 ld->rx->op[n].type = RX_Operand_Indirect;
230 disp = GETBYTE ();
231 ld->rx->op[n].addend = disp * PSCALE[size];
232 break;
233 case 2:
234 ld->rx->op[n].type = RX_Operand_Indirect;
235 disp = GETBYTE ();
236#if RX_OPCODE_BIG_ENDIAN
237 disp = disp * 256 + GETBYTE ();
238#else
239 disp = disp + GETBYTE () * 256;
240#endif
241 ld->rx->op[n].addend = disp * PSCALE[size];
242 break;
243 default:
244 abort ();
245 }
246}
247
248#define xO 8
249#define xS 4
250#define xZ 2
251#define xC 1
252
253#define F_____
254#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
255#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
256#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
257#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
258#define F_O___ rx->flags_0 = rx->flags_s = xO;
259#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
260#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
261#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
262
263int
264rx_decode_opcode (unsigned long pc AU,
265 RX_Opcode_Decoded * rx,
266 int (* getbyte)(void *),
267 void * ptr)
268{
269 LocalData lds, * ld = &lds;
270 unsigned char op[20] = {0};
271
272 lds.rx = rx;
273 lds.getbyte = getbyte;
274 lds.ptr = ptr;
275 lds.op = op;
276
277 memset (rx, 0, sizeof (*rx));
278 BWL(LSIZE);
279
280
281/*----------------------------------------------------------------------*/
282/* MOV */
283
284 GETBYTE ();
285 switch (op[0] & 0xff)
286 {
287 case 0x00:
288 {
289 /** 0000 0000 brk */
290 if (trace)
291 {
292 printf ("\033[33m%s\033[0m %02x\n",
293 "/** 0000 0000 brk */",
294 op[0]);
295 }
296 SYNTAX("brk");
297#line 987 "rx-decode.opc"
298 ID(brk);
299
300 }
301 break;
302 case 0x01:
303 {
304 /** 0000 0001 dbt */
305 if (trace)
306 {
307 printf ("\033[33m%s\033[0m %02x\n",
308 "/** 0000 0001 dbt */",
309 op[0]);
310 }
311 SYNTAX("dbt");
312#line 990 "rx-decode.opc"
313 ID(dbt);
314
315 }
316 break;
317 case 0x02:
318 {
319 /** 0000 0010 rts */
320 if (trace)
321 {
322 printf ("\033[33m%s\033[0m %02x\n",
323 "/** 0000 0010 rts */",
324 op[0]);
325 }
326 SYNTAX("rts");
327#line 768 "rx-decode.opc"
328 ID(rts);
329
330 /*----------------------------------------------------------------------*/
331 /* NOP */
332
333 }
334 break;
335 case 0x03:
336 {
337 /** 0000 0011 nop */
338 if (trace)
339 {
340 printf ("\033[33m%s\033[0m %02x\n",
341 "/** 0000 0011 nop */",
342 op[0]);
343 }
344 SYNTAX("nop");
345#line 774 "rx-decode.opc"
346 ID(nop);
347
348 /*----------------------------------------------------------------------*/
349 /* STRING FUNCTIONS */
350
351 }
352 break;
353 case 0x04:
354 {
355 /** 0000 0100 bra.a %a0 */
356 if (trace)
357 {
358 printf ("\033[33m%s\033[0m %02x\n",
359 "/** 0000 0100 bra.a %a0 */",
360 op[0]);
361 }
362 SYNTAX("bra.a %a0");
363#line 746 "rx-decode.opc"
364 ID(branch); DC(pc + IMMex(3));
365
366 }
367 break;
368 case 0x05:
369 {
370 /** 0000 0101 bsr.a %a0 */
371 if (trace)
372 {
373 printf ("\033[33m%s\033[0m %02x\n",
374 "/** 0000 0101 bsr.a %a0 */",
375 op[0]);
376 }
377 SYNTAX("bsr.a %a0");
378#line 762 "rx-decode.opc"
379 ID(jsr); DC(pc + IMMex(3));
380
381 }
382 break;
383 case 0x06:
384 GETBYTE ();
385 switch (op[1] & 0xff)
386 {
387 case 0x00:
388 GETBYTE ();
389 switch (op[2] & 0x00)
390 {
391 case 0x00:
392 op_semantics_1:
393 {
394 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
395#line 542 "rx-decode.opc"
396 int mx AU = (op[1] >> 6) & 0x03;
397#line 542 "rx-decode.opc"
398 int ss AU = op[1] & 0x03;
399#line 542 "rx-decode.opc"
400 int rsrc AU = (op[2] >> 4) & 0x0f;
401#line 542 "rx-decode.opc"
402 int rdst AU = op[2] & 0x0f;
403 if (trace)
404 {
405 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
406 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
407 op[0], op[1], op[2]);
408 printf (" mx = 0x%x,", mx);
409 printf (" ss = 0x%x,", ss);
410 printf (" rsrc = 0x%x,", rsrc);
411 printf (" rdst = 0x%x\n", rdst);
412 }
413 SYNTAX("sub %2%S2, %1");
414#line 542 "rx-decode.opc"
415 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
416
417 }
418 break;
419 }
420 break;
421 case 0x01:
422 GETBYTE ();
423 switch (op[2] & 0x00)
424 {
425 case 0x00:
426 goto op_semantics_1;
427 break;
428 }
429 break;
430 case 0x02:
431 GETBYTE ();
432 switch (op[2] & 0x00)
433 {
434 case 0x00:
435 goto op_semantics_1;
436 break;
437 }
438 break;
439 case 0x03:
440 GETBYTE ();
441 switch (op[2] & 0x00)
442 {
443 case 0x00:
444 goto op_semantics_1;
445 break;
446 }
447 break;
448 case 0x04:
449 GETBYTE ();
450 switch (op[2] & 0x00)
451 {
452 case 0x00:
453 op_semantics_2:
454 {
455 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
456#line 530 "rx-decode.opc"
457 int mx AU = (op[1] >> 6) & 0x03;
458#line 530 "rx-decode.opc"
459 int ss AU = op[1] & 0x03;
460#line 530 "rx-decode.opc"
461 int rsrc AU = (op[2] >> 4) & 0x0f;
462#line 530 "rx-decode.opc"
463 int rdst AU = op[2] & 0x0f;
464 if (trace)
465 {
466 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
467 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
468 op[0], op[1], op[2]);
469 printf (" mx = 0x%x,", mx);
470 printf (" ss = 0x%x,", ss);
471 printf (" rsrc = 0x%x,", rsrc);
472 printf (" rdst = 0x%x\n", rdst);
473 }
474 SYNTAX("cmp %2%S2, %1");
475#line 530 "rx-decode.opc"
476 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
477
478 /*----------------------------------------------------------------------*/
479 /* SUB */
480
481 }
482 break;
483 }
484 break;
485 case 0x05:
486 GETBYTE ();
487 switch (op[2] & 0x00)
488 {
489 case 0x00:
490 goto op_semantics_2;
491 break;
492 }
493 break;
494 case 0x06:
495 GETBYTE ();
496 switch (op[2] & 0x00)
497 {
498 case 0x00:
499 goto op_semantics_2;
500 break;
501 }
502 break;
503 case 0x07:
504 GETBYTE ();
505 switch (op[2] & 0x00)
506 {
507 case 0x00:
508 goto op_semantics_2;
509 break;
510 }
511 break;
512 case 0x08:
513 GETBYTE ();
514 switch (op[2] & 0x00)
515 {
516 case 0x00:
517 op_semantics_3:
518 {
519 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
520#line 506 "rx-decode.opc"
521 int mx AU = (op[1] >> 6) & 0x03;
522#line 506 "rx-decode.opc"
523 int ss AU = op[1] & 0x03;
524#line 506 "rx-decode.opc"
525 int rsrc AU = (op[2] >> 4) & 0x0f;
526#line 506 "rx-decode.opc"
527 int rdst AU = op[2] & 0x0f;
528 if (trace)
529 {
530 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
531 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
532 op[0], op[1], op[2]);
533 printf (" mx = 0x%x,", mx);
534 printf (" ss = 0x%x,", ss);
535 printf (" rsrc = 0x%x,", rsrc);
536 printf (" rdst = 0x%x\n", rdst);
537 }
538 SYNTAX("add %1%S1, %0");
539#line 506 "rx-decode.opc"
540 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
541
542 }
543 break;
544 }
545 break;
546 case 0x09:
547 GETBYTE ();
548 switch (op[2] & 0x00)
549 {
550 case 0x00:
551 goto op_semantics_3;
552 break;
553 }
554 break;
555 case 0x0a:
556 GETBYTE ();
557 switch (op[2] & 0x00)
558 {
559 case 0x00:
560 goto op_semantics_3;
561 break;
562 }
563 break;
564 case 0x0b:
565 GETBYTE ();
566 switch (op[2] & 0x00)
567 {
568 case 0x00:
569 goto op_semantics_3;
570 break;
571 }
572 break;
573 case 0x0c:
574 GETBYTE ();
575 switch (op[2] & 0x00)
576 {
577 case 0x00:
578 op_semantics_4:
579 {
580 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
581#line 611 "rx-decode.opc"
582 int mx AU = (op[1] >> 6) & 0x03;
583#line 611 "rx-decode.opc"
584 int ss AU = op[1] & 0x03;
585#line 611 "rx-decode.opc"
586 int rsrc AU = (op[2] >> 4) & 0x0f;
587#line 611 "rx-decode.opc"
588 int rdst AU = op[2] & 0x0f;
589 if (trace)
590 {
591 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
592 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
593 op[0], op[1], op[2]);
594 printf (" mx = 0x%x,", mx);
595 printf (" ss = 0x%x,", ss);
596 printf (" rsrc = 0x%x,", rsrc);
597 printf (" rdst = 0x%x\n", rdst);
598 }
599 SYNTAX("mul %1%S1, %0");
600#line 611 "rx-decode.opc"
601 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
602
603 }
604 break;
605 }
606 break;
607 case 0x0d:
608 GETBYTE ();
609 switch (op[2] & 0x00)
610 {
611 case 0x00:
612 goto op_semantics_4;
613 break;
614 }
615 break;
616 case 0x0e:
617 GETBYTE ();
618 switch (op[2] & 0x00)
619 {
620 case 0x00:
621 goto op_semantics_4;
622 break;
623 }
624 break;
625 case 0x0f:
626 GETBYTE ();
627 switch (op[2] & 0x00)
628 {
629 case 0x00:
630 goto op_semantics_4;
631 break;
632 }
633 break;
634 case 0x10:
635 GETBYTE ();
636 switch (op[2] & 0x00)
637 {
638 case 0x00:
639 op_semantics_5:
640 {
641 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
642#line 419 "rx-decode.opc"
643 int mx AU = (op[1] >> 6) & 0x03;
644#line 419 "rx-decode.opc"
645 int ss AU = op[1] & 0x03;
646#line 419 "rx-decode.opc"
647 int rsrc AU = (op[2] >> 4) & 0x0f;
648#line 419 "rx-decode.opc"
649 int rdst AU = op[2] & 0x0f;
650 if (trace)
651 {
652 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
653 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
654 op[0], op[1], op[2]);
655 printf (" mx = 0x%x,", mx);
656 printf (" ss = 0x%x,", ss);
657 printf (" rsrc = 0x%x,", rsrc);
658 printf (" rdst = 0x%x\n", rdst);
659 }
660 SYNTAX("and %1%S1, %0");
661#line 419 "rx-decode.opc"
662 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
663
664 }
665 break;
666 }
667 break;
668 case 0x11:
669 GETBYTE ();
670 switch (op[2] & 0x00)
671 {
672 case 0x00:
673 goto op_semantics_5;
674 break;
675 }
676 break;
677 case 0x12:
678 GETBYTE ();
679 switch (op[2] & 0x00)
680 {
681 case 0x00:
682 goto op_semantics_5;
683 break;
684 }
685 break;
686 case 0x13:
687 GETBYTE ();
688 switch (op[2] & 0x00)
689 {
690 case 0x00:
691 goto op_semantics_5;
692 break;
693 }
694 break;
695 case 0x14:
696 GETBYTE ();
697 switch (op[2] & 0x00)
698 {
699 case 0x00:
700 op_semantics_6:
701 {
702 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
703#line 437 "rx-decode.opc"
704 int mx AU = (op[1] >> 6) & 0x03;
705#line 437 "rx-decode.opc"
706 int ss AU = op[1] & 0x03;
707#line 437 "rx-decode.opc"
708 int rsrc AU = (op[2] >> 4) & 0x0f;
709#line 437 "rx-decode.opc"
710 int rdst AU = op[2] & 0x0f;
711 if (trace)
712 {
713 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
714 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
715 op[0], op[1], op[2]);
716 printf (" mx = 0x%x,", mx);
717 printf (" ss = 0x%x,", ss);
718 printf (" rsrc = 0x%x,", rsrc);
719 printf (" rdst = 0x%x\n", rdst);
720 }
721 SYNTAX("or %1%S1, %0");
722#line 437 "rx-decode.opc"
723 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
724
725 }
726 break;
727 }
728 break;
729 case 0x15:
730 GETBYTE ();
731 switch (op[2] & 0x00)
732 {
733 case 0x00:
734 goto op_semantics_6;
735 break;
736 }
737 break;
738 case 0x16:
739 GETBYTE ();
740 switch (op[2] & 0x00)
741 {
742 case 0x00:
743 goto op_semantics_6;
744 break;
745 }
746 break;
747 case 0x17:
748 GETBYTE ();
749 switch (op[2] & 0x00)
750 {
751 case 0x00:
752 goto op_semantics_6;
753 break;
754 }
755 break;
756 case 0x20:
757 GETBYTE ();
758 switch (op[2] & 0xff)
759 {
760 case 0x00:
761 GETBYTE ();
762 switch (op[3] & 0x00)
763 {
764 case 0x00:
765 op_semantics_7:
766 {
767 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
768#line 555 "rx-decode.opc"
769 int mx AU = (op[1] >> 6) & 0x03;
770#line 555 "rx-decode.opc"
771 int sp AU = op[1] & 0x03;
772#line 555 "rx-decode.opc"
773 int rsrc AU = (op[3] >> 4) & 0x0f;
774#line 555 "rx-decode.opc"
775 int rdst AU = op[3] & 0x0f;
776 if (trace)
777 {
778 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
779 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
780 op[0], op[1], op[2], op[3]);
781 printf (" mx = 0x%x,", mx);
782 printf (" sp = 0x%x,", sp);
783 printf (" rsrc = 0x%x,", rsrc);
784 printf (" rdst = 0x%x\n", rdst);
785 }
786 SYNTAX("sbb %1%S1, %0");
787#line 555 "rx-decode.opc"
788 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
789
790 /*----------------------------------------------------------------------*/
791 /* ABS */
792
793 }
794 break;
795 }
796 break;
797 case 0x04:
798 GETBYTE ();
799 switch (op[3] & 0x00)
800 {
801 case 0x00:
802 op_semantics_8:
803 {
804 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
805#line 584 "rx-decode.opc"
806 int mx AU = (op[1] >> 6) & 0x03;
807#line 584 "rx-decode.opc"
808 int ss AU = op[1] & 0x03;
809#line 584 "rx-decode.opc"
810 int rsrc AU = (op[3] >> 4) & 0x0f;
811#line 584 "rx-decode.opc"
812 int rdst AU = op[3] & 0x0f;
813 if (trace)
814 {
815 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
816 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
817 op[0], op[1], op[2], op[3]);
818 printf (" mx = 0x%x,", mx);
819 printf (" ss = 0x%x,", ss);
820 printf (" rsrc = 0x%x,", rsrc);
821 printf (" rdst = 0x%x\n", rdst);
822 }
823 SYNTAX("max %1%S1, %0");
824#line 584 "rx-decode.opc"
825 ID(max); SPm(ss, rsrc, mx); DR(rdst);
826
827 /*----------------------------------------------------------------------*/
828 /* MIN */
829
830 }
831 break;
832 }
833 break;
834 case 0x05:
835 GETBYTE ();
836 switch (op[3] & 0x00)
837 {
838 case 0x00:
839 op_semantics_9:
840 {
841 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
842#line 596 "rx-decode.opc"
843 int mx AU = (op[1] >> 6) & 0x03;
844#line 596 "rx-decode.opc"
845 int ss AU = op[1] & 0x03;
846#line 596 "rx-decode.opc"
847 int rsrc AU = (op[3] >> 4) & 0x0f;
848#line 596 "rx-decode.opc"
849 int rdst AU = op[3] & 0x0f;
850 if (trace)
851 {
852 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
853 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
854 op[0], op[1], op[2], op[3]);
855 printf (" mx = 0x%x,", mx);
856 printf (" ss = 0x%x,", ss);
857 printf (" rsrc = 0x%x,", rsrc);
858 printf (" rdst = 0x%x\n", rdst);
859 }
860 SYNTAX("min %1%S1, %0");
861#line 596 "rx-decode.opc"
862 ID(min); SPm(ss, rsrc, mx); DR(rdst);
863
864 /*----------------------------------------------------------------------*/
865 /* MUL */
866
867 }
868 break;
869 }
870 break;
871 case 0x06:
872 GETBYTE ();
873 switch (op[3] & 0x00)
874 {
875 case 0x00:
876 op_semantics_10:
877 {
878 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
879#line 626 "rx-decode.opc"
880 int mx AU = (op[1] >> 6) & 0x03;
881#line 626 "rx-decode.opc"
882 int ss AU = op[1] & 0x03;
883#line 626 "rx-decode.opc"
884 int rsrc AU = (op[3] >> 4) & 0x0f;
885#line 626 "rx-decode.opc"
886 int rdst AU = op[3] & 0x0f;
887 if (trace)
888 {
889 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
890 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
891 op[0], op[1], op[2], op[3]);
892 printf (" mx = 0x%x,", mx);
893 printf (" ss = 0x%x,", ss);
894 printf (" rsrc = 0x%x,", rsrc);
895 printf (" rdst = 0x%x\n", rdst);
896 }
897 SYNTAX("emul %1%S1, %0");
898#line 626 "rx-decode.opc"
899 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
900
901 /*----------------------------------------------------------------------*/
902 /* EMULU */
903
904 }
905 break;
906 }
907 break;
908 case 0x07:
909 GETBYTE ();
910 switch (op[3] & 0x00)
911 {
912 case 0x00:
913 op_semantics_11:
914 {
915 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
916#line 638 "rx-decode.opc"
917 int mx AU = (op[1] >> 6) & 0x03;
918#line 638 "rx-decode.opc"
919 int ss AU = op[1] & 0x03;
920#line 638 "rx-decode.opc"
921 int rsrc AU = (op[3] >> 4) & 0x0f;
922#line 638 "rx-decode.opc"
923 int rdst AU = op[3] & 0x0f;
924 if (trace)
925 {
926 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
927 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
928 op[0], op[1], op[2], op[3]);
929 printf (" mx = 0x%x,", mx);
930 printf (" ss = 0x%x,", ss);
931 printf (" rsrc = 0x%x,", rsrc);
932 printf (" rdst = 0x%x\n", rdst);
933 }
934 SYNTAX("emulu %1%S1, %0");
935#line 638 "rx-decode.opc"
936 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
937
938 /*----------------------------------------------------------------------*/
939 /* DIV */
940
941 }
942 break;
943 }
944 break;
945 case 0x08:
946 GETBYTE ();
947 switch (op[3] & 0x00)
948 {
949 case 0x00:
950 op_semantics_12:
951 {
952 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
953#line 650 "rx-decode.opc"
954 int mx AU = (op[1] >> 6) & 0x03;
955#line 650 "rx-decode.opc"
956 int ss AU = op[1] & 0x03;
957#line 650 "rx-decode.opc"
958 int rsrc AU = (op[3] >> 4) & 0x0f;
959#line 650 "rx-decode.opc"
960 int rdst AU = op[3] & 0x0f;
961 if (trace)
962 {
963 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
964 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
965 op[0], op[1], op[2], op[3]);
966 printf (" mx = 0x%x,", mx);
967 printf (" ss = 0x%x,", ss);
968 printf (" rsrc = 0x%x,", rsrc);
969 printf (" rdst = 0x%x\n", rdst);
970 }
971 SYNTAX("div %1%S1, %0");
972#line 650 "rx-decode.opc"
973 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
974
975 /*----------------------------------------------------------------------*/
976 /* DIVU */
977
978 }
979 break;
980 }
981 break;
982 case 0x09:
983 GETBYTE ();
984 switch (op[3] & 0x00)
985 {
986 case 0x00:
987 op_semantics_13:
988 {
989 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
990#line 662 "rx-decode.opc"
991 int mx AU = (op[1] >> 6) & 0x03;
992#line 662 "rx-decode.opc"
993 int ss AU = op[1] & 0x03;
994#line 662 "rx-decode.opc"
995 int rsrc AU = (op[3] >> 4) & 0x0f;
996#line 662 "rx-decode.opc"
997 int rdst AU = op[3] & 0x0f;
998 if (trace)
999 {
1000 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1001 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1002 op[0], op[1], op[2], op[3]);
1003 printf (" mx = 0x%x,", mx);
1004 printf (" ss = 0x%x,", ss);
1005 printf (" rsrc = 0x%x,", rsrc);
1006 printf (" rdst = 0x%x\n", rdst);
1007 }
1008 SYNTAX("divu %1%S1, %0");
1009#line 662 "rx-decode.opc"
1010 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1011
1012 /*----------------------------------------------------------------------*/
1013 /* SHIFT */
1014
1015 }
1016 break;
1017 }
1018 break;
1019 case 0x0c:
1020 GETBYTE ();
1021 switch (op[3] & 0x00)
1022 {
1023 case 0x00:
1024 op_semantics_14:
1025 {
1026 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1027#line 473 "rx-decode.opc"
1028 int mx AU = (op[1] >> 6) & 0x03;
1029#line 473 "rx-decode.opc"
1030 int ss AU = op[1] & 0x03;
1031#line 473 "rx-decode.opc"
1032 int rsrc AU = (op[3] >> 4) & 0x0f;
1033#line 473 "rx-decode.opc"
1034 int rdst AU = op[3] & 0x0f;
1035 if (trace)
1036 {
1037 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1038 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1039 op[0], op[1], op[2], op[3]);
1040 printf (" mx = 0x%x,", mx);
1041 printf (" ss = 0x%x,", ss);
1042 printf (" rsrc = 0x%x,", rsrc);
1043 printf (" rdst = 0x%x\n", rdst);
1044 }
1045 SYNTAX("tst %1%S1, %2");
1046#line 473 "rx-decode.opc"
1047 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1048
1049 /*----------------------------------------------------------------------*/
1050 /* NEG */
1051
1052 }
1053 break;
1054 }
1055 break;
1056 case 0x0d:
1057 GETBYTE ();
1058 switch (op[3] & 0x00)
1059 {
1060 case 0x00:
1061 op_semantics_15:
1062 {
1063 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1064#line 452 "rx-decode.opc"
1065 int mx AU = (op[1] >> 6) & 0x03;
1066#line 452 "rx-decode.opc"
1067 int ss AU = op[1] & 0x03;
1068#line 452 "rx-decode.opc"
1069 int rsrc AU = (op[3] >> 4) & 0x0f;
1070#line 452 "rx-decode.opc"
1071 int rdst AU = op[3] & 0x0f;
1072 if (trace)
1073 {
1074 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1075 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1076 op[0], op[1], op[2], op[3]);
1077 printf (" mx = 0x%x,", mx);
1078 printf (" ss = 0x%x,", ss);
1079 printf (" rsrc = 0x%x,", rsrc);
1080 printf (" rdst = 0x%x\n", rdst);
1081 }
1082 SYNTAX("xor %1%S1, %0");
1083#line 452 "rx-decode.opc"
1084 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1085
1086 /*----------------------------------------------------------------------*/
1087 /* NOT */
1088
1089 }
1090 break;
1091 }
1092 break;
1093 case 0x10:
1094 GETBYTE ();
1095 switch (op[3] & 0x00)
1096 {
1097 case 0x00:
1098 op_semantics_16:
1099 {
1100 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1101#line 386 "rx-decode.opc"
1102 int mx AU = (op[1] >> 6) & 0x03;
1103#line 386 "rx-decode.opc"
1104 int ss AU = op[1] & 0x03;
1105#line 386 "rx-decode.opc"
1106 int rsrc AU = (op[3] >> 4) & 0x0f;
1107#line 386 "rx-decode.opc"
1108 int rdst AU = op[3] & 0x0f;
1109 if (trace)
1110 {
1111 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1112 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1113 op[0], op[1], op[2], op[3]);
1114 printf (" mx = 0x%x,", mx);
1115 printf (" ss = 0x%x,", ss);
1116 printf (" rsrc = 0x%x,", rsrc);
1117 printf (" rdst = 0x%x\n", rdst);
1118 }
1119 SYNTAX("xchg %1%S1, %0");
1120#line 386 "rx-decode.opc"
1121 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1122
1123 /*----------------------------------------------------------------------*/
1124 /* STZ/STNZ */
1125
1126 }
1127 break;
1128 }
1129 break;
1130 case 0x11:
1131 GETBYTE ();
1132 switch (op[3] & 0x00)
1133 {
1134 case 0x00:
1135 op_semantics_17:
1136 {
1137 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1138#line 891 "rx-decode.opc"
1139 int mx AU = (op[1] >> 6) & 0x03;
1140#line 891 "rx-decode.opc"
1141 int sd AU = op[1] & 0x03;
1142#line 891 "rx-decode.opc"
1143 int rsrc AU = (op[3] >> 4) & 0x0f;
1144#line 891 "rx-decode.opc"
1145 int rdst AU = op[3] & 0x0f;
1146 if (trace)
1147 {
1148 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1149 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1150 op[0], op[1], op[2], op[3]);
1151 printf (" mx = 0x%x,", mx);
1152 printf (" sd = 0x%x,", sd);
1153 printf (" rsrc = 0x%x,", rsrc);
1154 printf (" rdst = 0x%x\n", rdst);
1155 }
1156 SYNTAX("itof %1%S1, %0");
1157#line 891 "rx-decode.opc"
1158 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1159
1160 /*----------------------------------------------------------------------*/
1161 /* BIT OPS */
1162
1163 }
1164 break;
1165 }
1166 break;
1167 default: UNSUPPORTED(); break;
1168 }
1169 break;
1170 case 0x21:
1171 GETBYTE ();
1172 switch (op[2] & 0xff)
1173 {
1174 case 0x00:
1175 GETBYTE ();
1176 switch (op[3] & 0x00)
1177 {
1178 case 0x00:
1179 goto op_semantics_7;
1180 break;
1181 }
1182 break;
1183 case 0x04:
1184 GETBYTE ();
1185 switch (op[3] & 0x00)
1186 {
1187 case 0x00:
1188 goto op_semantics_8;
1189 break;
1190 }
1191 break;
1192 case 0x05:
1193 GETBYTE ();
1194 switch (op[3] & 0x00)
1195 {
1196 case 0x00:
1197 goto op_semantics_9;
1198 break;
1199 }
1200 break;
1201 case 0x06:
1202 GETBYTE ();
1203 switch (op[3] & 0x00)
1204 {
1205 case 0x00:
1206 goto op_semantics_10;
1207 break;
1208 }
1209 break;
1210 case 0x07:
1211 GETBYTE ();
1212 switch (op[3] & 0x00)
1213 {
1214 case 0x00:
1215 goto op_semantics_11;
1216 break;
1217 }
1218 break;
1219 case 0x08:
1220 GETBYTE ();
1221 switch (op[3] & 0x00)
1222 {
1223 case 0x00:
1224 goto op_semantics_12;
1225 break;
1226 }
1227 break;
1228 case 0x09:
1229 GETBYTE ();
1230 switch (op[3] & 0x00)
1231 {
1232 case 0x00:
1233 goto op_semantics_13;
1234 break;
1235 }
1236 break;
1237 case 0x0c:
1238 GETBYTE ();
1239 switch (op[3] & 0x00)
1240 {
1241 case 0x00:
1242 goto op_semantics_14;
1243 break;
1244 }
1245 break;
1246 case 0x0d:
1247 GETBYTE ();
1248 switch (op[3] & 0x00)
1249 {
1250 case 0x00:
1251 goto op_semantics_15;
1252 break;
1253 }
1254 break;
1255 case 0x10:
1256 GETBYTE ();
1257 switch (op[3] & 0x00)
1258 {
1259 case 0x00:
1260 goto op_semantics_16;
1261 break;
1262 }
1263 break;
1264 case 0x11:
1265 GETBYTE ();
1266 switch (op[3] & 0x00)
1267 {
1268 case 0x00:
1269 goto op_semantics_17;
1270 break;
1271 }
1272 break;
1273 default: UNSUPPORTED(); break;
1274 }
1275 break;
1276 case 0x22:
1277 GETBYTE ();
1278 switch (op[2] & 0xff)
1279 {
1280 case 0x00:
1281 GETBYTE ();
1282 switch (op[3] & 0x00)
1283 {
1284 case 0x00:
1285 goto op_semantics_7;
1286 break;
1287 }
1288 break;
1289 case 0x04:
1290 GETBYTE ();
1291 switch (op[3] & 0x00)
1292 {
1293 case 0x00:
1294 goto op_semantics_8;
1295 break;
1296 }
1297 break;
1298 case 0x05:
1299 GETBYTE ();
1300 switch (op[3] & 0x00)
1301 {
1302 case 0x00:
1303 goto op_semantics_9;
1304 break;
1305 }
1306 break;
1307 case 0x06:
1308 GETBYTE ();
1309 switch (op[3] & 0x00)
1310 {
1311 case 0x00:
1312 goto op_semantics_10;
1313 break;
1314 }
1315 break;
1316 case 0x07:
1317 GETBYTE ();
1318 switch (op[3] & 0x00)
1319 {
1320 case 0x00:
1321 goto op_semantics_11;
1322 break;
1323 }
1324 break;
1325 case 0x08:
1326 GETBYTE ();
1327 switch (op[3] & 0x00)
1328 {
1329 case 0x00:
1330 goto op_semantics_12;
1331 break;
1332 }
1333 break;
1334 case 0x09:
1335 GETBYTE ();
1336 switch (op[3] & 0x00)
1337 {
1338 case 0x00:
1339 goto op_semantics_13;
1340 break;
1341 }
1342 break;
1343 case 0x0c:
1344 GETBYTE ();
1345 switch (op[3] & 0x00)
1346 {
1347 case 0x00:
1348 goto op_semantics_14;
1349 break;
1350 }
1351 break;
1352 case 0x0d:
1353 GETBYTE ();
1354 switch (op[3] & 0x00)
1355 {
1356 case 0x00:
1357 goto op_semantics_15;
1358 break;
1359 }
1360 break;
1361 case 0x10:
1362 GETBYTE ();
1363 switch (op[3] & 0x00)
1364 {
1365 case 0x00:
1366 goto op_semantics_16;
1367 break;
1368 }
1369 break;
1370 case 0x11:
1371 GETBYTE ();
1372 switch (op[3] & 0x00)
1373 {
1374 case 0x00:
1375 goto op_semantics_17;
1376 break;
1377 }
1378 break;
1379 default: UNSUPPORTED(); break;
1380 }
1381 break;
1382 case 0x23:
1383 GETBYTE ();
1384 switch (op[2] & 0xff)
1385 {
1386 case 0x00:
1387 GETBYTE ();
1388 switch (op[3] & 0x00)
1389 {
1390 case 0x00:
1391 goto op_semantics_7;
1392 break;
1393 }
1394 break;
1395 case 0x04:
1396 GETBYTE ();
1397 switch (op[3] & 0x00)
1398 {
1399 case 0x00:
1400 goto op_semantics_8;
1401 break;
1402 }
1403 break;
1404 case 0x05:
1405 GETBYTE ();
1406 switch (op[3] & 0x00)
1407 {
1408 case 0x00:
1409 goto op_semantics_9;
1410 break;
1411 }
1412 break;
1413 case 0x06:
1414 GETBYTE ();
1415 switch (op[3] & 0x00)
1416 {
1417 case 0x00:
1418 goto op_semantics_10;
1419 break;
1420 }
1421 break;
1422 case 0x07:
1423 GETBYTE ();
1424 switch (op[3] & 0x00)
1425 {
1426 case 0x00:
1427 goto op_semantics_11;
1428 break;
1429 }
1430 break;
1431 case 0x08:
1432 GETBYTE ();
1433 switch (op[3] & 0x00)
1434 {
1435 case 0x00:
1436 goto op_semantics_12;
1437 break;
1438 }
1439 break;
1440 case 0x09:
1441 GETBYTE ();
1442 switch (op[3] & 0x00)
1443 {
1444 case 0x00:
1445 goto op_semantics_13;
1446 break;
1447 }
1448 break;
1449 case 0x0c:
1450 GETBYTE ();
1451 switch (op[3] & 0x00)
1452 {
1453 case 0x00:
1454 goto op_semantics_14;
1455 break;
1456 }
1457 break;
1458 case 0x0d:
1459 GETBYTE ();
1460 switch (op[3] & 0x00)
1461 {
1462 case 0x00:
1463 goto op_semantics_15;
1464 break;
1465 }
1466 break;
1467 case 0x10:
1468 GETBYTE ();
1469 switch (op[3] & 0x00)
1470 {
1471 case 0x00:
1472 goto op_semantics_16;
1473 break;
1474 }
1475 break;
1476 case 0x11:
1477 GETBYTE ();
1478 switch (op[3] & 0x00)
1479 {
1480 case 0x00:
1481 goto op_semantics_17;
1482 break;
1483 }
1484 break;
1485 default: UNSUPPORTED(); break;
1486 }
1487 break;
1488 case 0x40:
1489 GETBYTE ();
1490 switch (op[2] & 0x00)
1491 {
1492 case 0x00:
1493 goto op_semantics_1;
1494 break;
1495 }
1496 break;
1497 case 0x41:
1498 GETBYTE ();
1499 switch (op[2] & 0x00)
1500 {
1501 case 0x00:
1502 goto op_semantics_1;
1503 break;
1504 }
1505 break;
1506 case 0x42:
1507 GETBYTE ();
1508 switch (op[2] & 0x00)
1509 {
1510 case 0x00:
1511 goto op_semantics_1;
1512 break;
1513 }
1514 break;
1515 case 0x43:
1516 GETBYTE ();
1517 switch (op[2] & 0x00)
1518 {
1519 case 0x00:
1520 goto op_semantics_1;
1521 break;
1522 }
1523 break;
1524 case 0x44:
1525 GETBYTE ();
1526 switch (op[2] & 0x00)
1527 {
1528 case 0x00:
1529 goto op_semantics_2;
1530 break;
1531 }
1532 break;
1533 case 0x45:
1534 GETBYTE ();
1535 switch (op[2] & 0x00)
1536 {
1537 case 0x00:
1538 goto op_semantics_2;
1539 break;
1540 }
1541 break;
1542 case 0x46:
1543 GETBYTE ();
1544 switch (op[2] & 0x00)
1545 {
1546 case 0x00:
1547 goto op_semantics_2;
1548 break;
1549 }
1550 break;
1551 case 0x47:
1552 GETBYTE ();
1553 switch (op[2] & 0x00)
1554 {
1555 case 0x00:
1556 goto op_semantics_2;
1557 break;
1558 }
1559 break;
1560 case 0x48:
1561 GETBYTE ();
1562 switch (op[2] & 0x00)
1563 {
1564 case 0x00:
1565 goto op_semantics_3;
1566 break;
1567 }
1568 break;
1569 case 0x49:
1570 GETBYTE ();
1571 switch (op[2] & 0x00)
1572 {
1573 case 0x00:
1574 goto op_semantics_3;
1575 break;
1576 }
1577 break;
1578 case 0x4a:
1579 GETBYTE ();
1580 switch (op[2] & 0x00)
1581 {
1582 case 0x00:
1583 goto op_semantics_3;
1584 break;
1585 }
1586 break;
1587 case 0x4b:
1588 GETBYTE ();
1589 switch (op[2] & 0x00)
1590 {
1591 case 0x00:
1592 goto op_semantics_3;
1593 break;
1594 }
1595 break;
1596 case 0x4c:
1597 GETBYTE ();
1598 switch (op[2] & 0x00)
1599 {
1600 case 0x00:
1601 goto op_semantics_4;
1602 break;
1603 }
1604 break;
1605 case 0x4d:
1606 GETBYTE ();
1607 switch (op[2] & 0x00)
1608 {
1609 case 0x00:
1610 goto op_semantics_4;
1611 break;
1612 }
1613 break;
1614 case 0x4e:
1615 GETBYTE ();
1616 switch (op[2] & 0x00)
1617 {
1618 case 0x00:
1619 goto op_semantics_4;
1620 break;
1621 }
1622 break;
1623 case 0x4f:
1624 GETBYTE ();
1625 switch (op[2] & 0x00)
1626 {
1627 case 0x00:
1628 goto op_semantics_4;
1629 break;
1630 }
1631 break;
1632 case 0x50:
1633 GETBYTE ();
1634 switch (op[2] & 0x00)
1635 {
1636 case 0x00:
1637 goto op_semantics_5;
1638 break;
1639 }
1640 break;
1641 case 0x51:
1642 GETBYTE ();
1643 switch (op[2] & 0x00)
1644 {
1645 case 0x00:
1646 goto op_semantics_5;
1647 break;
1648 }
1649 break;
1650 case 0x52:
1651 GETBYTE ();
1652 switch (op[2] & 0x00)
1653 {
1654 case 0x00:
1655 goto op_semantics_5;
1656 break;
1657 }
1658 break;
1659 case 0x53:
1660 GETBYTE ();
1661 switch (op[2] & 0x00)
1662 {
1663 case 0x00:
1664 goto op_semantics_5;
1665 break;
1666 }
1667 break;
1668 case 0x54:
1669 GETBYTE ();
1670 switch (op[2] & 0x00)
1671 {
1672 case 0x00:
1673 goto op_semantics_6;
1674 break;
1675 }
1676 break;
1677 case 0x55:
1678 GETBYTE ();
1679 switch (op[2] & 0x00)
1680 {
1681 case 0x00:
1682 goto op_semantics_6;
1683 break;
1684 }
1685 break;
1686 case 0x56:
1687 GETBYTE ();
1688 switch (op[2] & 0x00)
1689 {
1690 case 0x00:
1691 goto op_semantics_6;
1692 break;
1693 }
1694 break;
1695 case 0x57:
1696 GETBYTE ();
1697 switch (op[2] & 0x00)
1698 {
1699 case 0x00:
1700 goto op_semantics_6;
1701 break;
1702 }
1703 break;
1704 case 0x60:
1705 GETBYTE ();
1706 switch (op[2] & 0xff)
1707 {
1708 case 0x00:
1709 GETBYTE ();
1710 switch (op[3] & 0x00)
1711 {
1712 case 0x00:
1713 goto op_semantics_7;
1714 break;
1715 }
1716 break;
1717 case 0x04:
1718 GETBYTE ();
1719 switch (op[3] & 0x00)
1720 {
1721 case 0x00:
1722 goto op_semantics_8;
1723 break;
1724 }
1725 break;
1726 case 0x05:
1727 GETBYTE ();
1728 switch (op[3] & 0x00)
1729 {
1730 case 0x00:
1731 goto op_semantics_9;
1732 break;
1733 }
1734 break;
1735 case 0x06:
1736 GETBYTE ();
1737 switch (op[3] & 0x00)
1738 {
1739 case 0x00:
1740 goto op_semantics_10;
1741 break;
1742 }
1743 break;
1744 case 0x07:
1745 GETBYTE ();
1746 switch (op[3] & 0x00)
1747 {
1748 case 0x00:
1749 goto op_semantics_11;
1750 break;
1751 }
1752 break;
1753 case 0x08:
1754 GETBYTE ();
1755 switch (op[3] & 0x00)
1756 {
1757 case 0x00:
1758 goto op_semantics_12;
1759 break;
1760 }
1761 break;
1762 case 0x09:
1763 GETBYTE ();
1764 switch (op[3] & 0x00)
1765 {
1766 case 0x00:
1767 goto op_semantics_13;
1768 break;
1769 }
1770 break;
1771 case 0x0c:
1772 GETBYTE ();
1773 switch (op[3] & 0x00)
1774 {
1775 case 0x00:
1776 goto op_semantics_14;
1777 break;
1778 }
1779 break;
1780 case 0x0d:
1781 GETBYTE ();
1782 switch (op[3] & 0x00)
1783 {
1784 case 0x00:
1785 goto op_semantics_15;
1786 break;
1787 }
1788 break;
1789 case 0x10:
1790 GETBYTE ();
1791 switch (op[3] & 0x00)
1792 {
1793 case 0x00:
1794 goto op_semantics_16;
1795 break;
1796 }
1797 break;
1798 case 0x11:
1799 GETBYTE ();
1800 switch (op[3] & 0x00)
1801 {
1802 case 0x00:
1803 goto op_semantics_17;
1804 break;
1805 }
1806 break;
1807 default: UNSUPPORTED(); break;
1808 }
1809 break;
1810 case 0x61:
1811 GETBYTE ();
1812 switch (op[2] & 0xff)
1813 {
1814 case 0x00:
1815 GETBYTE ();
1816 switch (op[3] & 0x00)
1817 {
1818 case 0x00:
1819 goto op_semantics_7;
1820 break;
1821 }
1822 break;
1823 case 0x04:
1824 GETBYTE ();
1825 switch (op[3] & 0x00)
1826 {
1827 case 0x00:
1828 goto op_semantics_8;
1829 break;
1830 }
1831 break;
1832 case 0x05:
1833 GETBYTE ();
1834 switch (op[3] & 0x00)
1835 {
1836 case 0x00:
1837 goto op_semantics_9;
1838 break;
1839 }
1840 break;
1841 case 0x06:
1842 GETBYTE ();
1843 switch (op[3] & 0x00)
1844 {
1845 case 0x00:
1846 goto op_semantics_10;
1847 break;
1848 }
1849 break;
1850 case 0x07:
1851 GETBYTE ();
1852 switch (op[3] & 0x00)
1853 {
1854 case 0x00:
1855 goto op_semantics_11;
1856 break;
1857 }
1858 break;
1859 case 0x08:
1860 GETBYTE ();
1861 switch (op[3] & 0x00)
1862 {
1863 case 0x00:
1864 goto op_semantics_12;
1865 break;
1866 }
1867 break;
1868 case 0x09:
1869 GETBYTE ();
1870 switch (op[3] & 0x00)
1871 {
1872 case 0x00:
1873 goto op_semantics_13;
1874 break;
1875 }
1876 break;
1877 case 0x0c:
1878 GETBYTE ();
1879 switch (op[3] & 0x00)
1880 {
1881 case 0x00:
1882 goto op_semantics_14;
1883 break;
1884 }
1885 break;
1886 case 0x0d:
1887 GETBYTE ();
1888 switch (op[3] & 0x00)
1889 {
1890 case 0x00:
1891 goto op_semantics_15;
1892 break;
1893 }
1894 break;
1895 case 0x10:
1896 GETBYTE ();
1897 switch (op[3] & 0x00)
1898 {
1899 case 0x00:
1900 goto op_semantics_16;
1901 break;
1902 }
1903 break;
1904 case 0x11:
1905 GETBYTE ();
1906 switch (op[3] & 0x00)
1907 {
1908 case 0x00:
1909 goto op_semantics_17;
1910 break;
1911 }
1912 break;
1913 default: UNSUPPORTED(); break;
1914 }
1915 break;
1916 case 0x62:
1917 GETBYTE ();
1918 switch (op[2] & 0xff)
1919 {
1920 case 0x00:
1921 GETBYTE ();
1922 switch (op[3] & 0x00)
1923 {
1924 case 0x00:
1925 goto op_semantics_7;
1926 break;
1927 }
1928 break;
1929 case 0x04:
1930 GETBYTE ();
1931 switch (op[3] & 0x00)
1932 {
1933 case 0x00:
1934 goto op_semantics_8;
1935 break;
1936 }
1937 break;
1938 case 0x05:
1939 GETBYTE ();
1940 switch (op[3] & 0x00)
1941 {
1942 case 0x00:
1943 goto op_semantics_9;
1944 break;
1945 }
1946 break;
1947 case 0x06:
1948 GETBYTE ();
1949 switch (op[3] & 0x00)
1950 {
1951 case 0x00:
1952 goto op_semantics_10;
1953 break;
1954 }
1955 break;
1956 case 0x07:
1957 GETBYTE ();
1958 switch (op[3] & 0x00)
1959 {
1960 case 0x00:
1961 goto op_semantics_11;
1962 break;
1963 }
1964 break;
1965 case 0x08:
1966 GETBYTE ();
1967 switch (op[3] & 0x00)
1968 {
1969 case 0x00:
1970 goto op_semantics_12;
1971 break;
1972 }
1973 break;
1974 case 0x09:
1975 GETBYTE ();
1976 switch (op[3] & 0x00)
1977 {
1978 case 0x00:
1979 goto op_semantics_13;
1980 break;
1981 }
1982 break;
1983 case 0x0c:
1984 GETBYTE ();
1985 switch (op[3] & 0x00)
1986 {
1987 case 0x00:
1988 goto op_semantics_14;
1989 break;
1990 }
1991 break;
1992 case 0x0d:
1993 GETBYTE ();
1994 switch (op[3] & 0x00)
1995 {
1996 case 0x00:
1997 goto op_semantics_15;
1998 break;
1999 }
2000 break;
2001 case 0x10:
2002 GETBYTE ();
2003 switch (op[3] & 0x00)
2004 {
2005 case 0x00:
2006 goto op_semantics_16;
2007 break;
2008 }
2009 break;
2010 case 0x11:
2011 GETBYTE ();
2012 switch (op[3] & 0x00)
2013 {
2014 case 0x00:
2015 goto op_semantics_17;
2016 break;
2017 }
2018 break;
2019 default: UNSUPPORTED(); break;
2020 }
2021 break;
2022 case 0x63:
2023 GETBYTE ();
2024 switch (op[2] & 0xff)
2025 {
2026 case 0x00:
2027 GETBYTE ();
2028 switch (op[3] & 0x00)
2029 {
2030 case 0x00:
2031 goto op_semantics_7;
2032 break;
2033 }
2034 break;
2035 case 0x04:
2036 GETBYTE ();
2037 switch (op[3] & 0x00)
2038 {
2039 case 0x00:
2040 goto op_semantics_8;
2041 break;
2042 }
2043 break;
2044 case 0x05:
2045 GETBYTE ();
2046 switch (op[3] & 0x00)
2047 {
2048 case 0x00:
2049 goto op_semantics_9;
2050 break;
2051 }
2052 break;
2053 case 0x06:
2054 GETBYTE ();
2055 switch (op[3] & 0x00)
2056 {
2057 case 0x00:
2058 goto op_semantics_10;
2059 break;
2060 }
2061 break;
2062 case 0x07:
2063 GETBYTE ();
2064 switch (op[3] & 0x00)
2065 {
2066 case 0x00:
2067 goto op_semantics_11;
2068 break;
2069 }
2070 break;
2071 case 0x08:
2072 GETBYTE ();
2073 switch (op[3] & 0x00)
2074 {
2075 case 0x00:
2076 goto op_semantics_12;
2077 break;
2078 }
2079 break;
2080 case 0x09:
2081 GETBYTE ();
2082 switch (op[3] & 0x00)
2083 {
2084 case 0x00:
2085 goto op_semantics_13;
2086 break;
2087 }
2088 break;
2089 case 0x0c:
2090 GETBYTE ();
2091 switch (op[3] & 0x00)
2092 {
2093 case 0x00:
2094 goto op_semantics_14;
2095 break;
2096 }
2097 break;
2098 case 0x0d:
2099 GETBYTE ();
2100 switch (op[3] & 0x00)
2101 {
2102 case 0x00:
2103 goto op_semantics_15;
2104 break;
2105 }
2106 break;
2107 case 0x10:
2108 GETBYTE ();
2109 switch (op[3] & 0x00)
2110 {
2111 case 0x00:
2112 goto op_semantics_16;
2113 break;
2114 }
2115 break;
2116 case 0x11:
2117 GETBYTE ();
2118 switch (op[3] & 0x00)
2119 {
2120 case 0x00:
2121 goto op_semantics_17;
2122 break;
2123 }
2124 break;
2125 default: UNSUPPORTED(); break;
2126 }
2127 break;
2128 case 0x80:
2129 GETBYTE ();
2130 switch (op[2] & 0x00)
2131 {
2132 case 0x00:
2133 goto op_semantics_1;
2134 break;
2135 }
2136 break;
2137 case 0x81:
2138 GETBYTE ();
2139 switch (op[2] & 0x00)
2140 {
2141 case 0x00:
2142 goto op_semantics_1;
2143 break;
2144 }
2145 break;
2146 case 0x82:
2147 GETBYTE ();
2148 switch (op[2] & 0x00)
2149 {
2150 case 0x00:
2151 goto op_semantics_1;
2152 break;
2153 }
2154 break;
2155 case 0x83:
2156 GETBYTE ();
2157 switch (op[2] & 0x00)
2158 {
2159 case 0x00:
2160 goto op_semantics_1;
2161 break;
2162 }
2163 break;
2164 case 0x84:
2165 GETBYTE ();
2166 switch (op[2] & 0x00)
2167 {
2168 case 0x00:
2169 goto op_semantics_2;
2170 break;
2171 }
2172 break;
2173 case 0x85:
2174 GETBYTE ();
2175 switch (op[2] & 0x00)
2176 {
2177 case 0x00:
2178 goto op_semantics_2;
2179 break;
2180 }
2181 break;
2182 case 0x86:
2183 GETBYTE ();
2184 switch (op[2] & 0x00)
2185 {
2186 case 0x00:
2187 goto op_semantics_2;
2188 break;
2189 }
2190 break;
2191 case 0x87:
2192 GETBYTE ();
2193 switch (op[2] & 0x00)
2194 {
2195 case 0x00:
2196 goto op_semantics_2;
2197 break;
2198 }
2199 break;
2200 case 0x88:
2201 GETBYTE ();
2202 switch (op[2] & 0x00)
2203 {
2204 case 0x00:
2205 goto op_semantics_3;
2206 break;
2207 }
2208 break;
2209 case 0x89:
2210 GETBYTE ();
2211 switch (op[2] & 0x00)
2212 {
2213 case 0x00:
2214 goto op_semantics_3;
2215 break;
2216 }
2217 break;
2218 case 0x8a:
2219 GETBYTE ();
2220 switch (op[2] & 0x00)
2221 {
2222 case 0x00:
2223 goto op_semantics_3;
2224 break;
2225 }
2226 break;
2227 case 0x8b:
2228 GETBYTE ();
2229 switch (op[2] & 0x00)
2230 {
2231 case 0x00:
2232 goto op_semantics_3;
2233 break;
2234 }
2235 break;
2236 case 0x8c:
2237 GETBYTE ();
2238 switch (op[2] & 0x00)
2239 {
2240 case 0x00:
2241 goto op_semantics_4;
2242 break;
2243 }
2244 break;
2245 case 0x8d:
2246 GETBYTE ();
2247 switch (op[2] & 0x00)
2248 {
2249 case 0x00:
2250 goto op_semantics_4;
2251 break;
2252 }
2253 break;
2254 case 0x8e:
2255 GETBYTE ();
2256 switch (op[2] & 0x00)
2257 {
2258 case 0x00:
2259 goto op_semantics_4;
2260 break;
2261 }
2262 break;
2263 case 0x8f:
2264 GETBYTE ();
2265 switch (op[2] & 0x00)
2266 {
2267 case 0x00:
2268 goto op_semantics_4;
2269 break;
2270 }
2271 break;
2272 case 0x90:
2273 GETBYTE ();
2274 switch (op[2] & 0x00)
2275 {
2276 case 0x00:
2277 goto op_semantics_5;
2278 break;
2279 }
2280 break;
2281 case 0x91:
2282 GETBYTE ();
2283 switch (op[2] & 0x00)
2284 {
2285 case 0x00:
2286 goto op_semantics_5;
2287 break;
2288 }
2289 break;
2290 case 0x92:
2291 GETBYTE ();
2292 switch (op[2] & 0x00)
2293 {
2294 case 0x00:
2295 goto op_semantics_5;
2296 break;
2297 }
2298 break;
2299 case 0x93:
2300 GETBYTE ();
2301 switch (op[2] & 0x00)
2302 {
2303 case 0x00:
2304 goto op_semantics_5;
2305 break;
2306 }
2307 break;
2308 case 0x94:
2309 GETBYTE ();
2310 switch (op[2] & 0x00)
2311 {
2312 case 0x00:
2313 goto op_semantics_6;
2314 break;
2315 }
2316 break;
2317 case 0x95:
2318 GETBYTE ();
2319 switch (op[2] & 0x00)
2320 {
2321 case 0x00:
2322 goto op_semantics_6;
2323 break;
2324 }
2325 break;
2326 case 0x96:
2327 GETBYTE ();
2328 switch (op[2] & 0x00)
2329 {
2330 case 0x00:
2331 goto op_semantics_6;
2332 break;
2333 }
2334 break;
2335 case 0x97:
2336 GETBYTE ();
2337 switch (op[2] & 0x00)
2338 {
2339 case 0x00:
2340 goto op_semantics_6;
2341 break;
2342 }
2343 break;
2344 case 0xa0:
2345 GETBYTE ();
2346 switch (op[2] & 0xff)
2347 {
2348 case 0x00:
2349 GETBYTE ();
2350 switch (op[3] & 0x00)
2351 {
2352 case 0x00:
2353 goto op_semantics_7;
2354 break;
2355 }
2356 break;
2357 case 0x02:
2358 GETBYTE ();
2359 switch (op[3] & 0x00)
2360 {
2361 case 0x00:
2362 op_semantics_18:
2363 {
2364 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2365#line 494 "rx-decode.opc"
2366 int ss AU = op[1] & 0x03;
2367#line 494 "rx-decode.opc"
2368 int rsrc AU = (op[3] >> 4) & 0x0f;
2369#line 494 "rx-decode.opc"
2370 int rdst AU = op[3] & 0x0f;
2371 if (trace)
2372 {
2373 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2374 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2375 op[0], op[1], op[2], op[3]);
2376 printf (" ss = 0x%x,", ss);
2377 printf (" rsrc = 0x%x,", rsrc);
2378 printf (" rdst = 0x%x\n", rdst);
2379 }
2380 SYNTAX("adc %1%S1, %0");
2381#line 494 "rx-decode.opc"
2382 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2383
2384 /*----------------------------------------------------------------------*/
2385 /* ADD */
2386
2387 }
2388 break;
2389 }
2390 break;
2391 case 0x04:
2392 GETBYTE ();
2393 switch (op[3] & 0x00)
2394 {
2395 case 0x00:
2396 goto op_semantics_8;
2397 break;
2398 }
2399 break;
2400 case 0x05:
2401 GETBYTE ();
2402 switch (op[3] & 0x00)
2403 {
2404 case 0x00:
2405 goto op_semantics_9;
2406 break;
2407 }
2408 break;
2409 case 0x06:
2410 GETBYTE ();
2411 switch (op[3] & 0x00)
2412 {
2413 case 0x00:
2414 goto op_semantics_10;
2415 break;
2416 }
2417 break;
2418 case 0x07:
2419 GETBYTE ();
2420 switch (op[3] & 0x00)
2421 {
2422 case 0x00:
2423 goto op_semantics_11;
2424 break;
2425 }
2426 break;
2427 case 0x08:
2428 GETBYTE ();
2429 switch (op[3] & 0x00)
2430 {
2431 case 0x00:
2432 goto op_semantics_12;
2433 break;
2434 }
2435 break;
2436 case 0x09:
2437 GETBYTE ();
2438 switch (op[3] & 0x00)
2439 {
2440 case 0x00:
2441 goto op_semantics_13;
2442 break;
2443 }
2444 break;
2445 case 0x0c:
2446 GETBYTE ();
2447 switch (op[3] & 0x00)
2448 {
2449 case 0x00:
2450 goto op_semantics_14;
2451 break;
2452 }
2453 break;
2454 case 0x0d:
2455 GETBYTE ();
2456 switch (op[3] & 0x00)
2457 {
2458 case 0x00:
2459 goto op_semantics_15;
2460 break;
2461 }
2462 break;
2463 case 0x10:
2464 GETBYTE ();
2465 switch (op[3] & 0x00)
2466 {
2467 case 0x00:
2468 goto op_semantics_16;
2469 break;
2470 }
2471 break;
2472 case 0x11:
2473 GETBYTE ();
2474 switch (op[3] & 0x00)
2475 {
2476 case 0x00:
2477 goto op_semantics_17;
2478 break;
2479 }
2480 break;
2481 default: UNSUPPORTED(); break;
2482 }
2483 break;
2484 case 0xa1:
2485 GETBYTE ();
2486 switch (op[2] & 0xff)
2487 {
2488 case 0x00:
2489 GETBYTE ();
2490 switch (op[3] & 0x00)
2491 {
2492 case 0x00:
2493 goto op_semantics_7;
2494 break;
2495 }
2496 break;
2497 case 0x02:
2498 GETBYTE ();
2499 switch (op[3] & 0x00)
2500 {
2501 case 0x00:
2502 goto op_semantics_18;
2503 break;
2504 }
2505 break;
2506 case 0x04:
2507 GETBYTE ();
2508 switch (op[3] & 0x00)
2509 {
2510 case 0x00:
2511 goto op_semantics_8;
2512 break;
2513 }
2514 break;
2515 case 0x05:
2516 GETBYTE ();
2517 switch (op[3] & 0x00)
2518 {
2519 case 0x00:
2520 goto op_semantics_9;
2521 break;
2522 }
2523 break;
2524 case 0x06:
2525 GETBYTE ();
2526 switch (op[3] & 0x00)
2527 {
2528 case 0x00:
2529 goto op_semantics_10;
2530 break;
2531 }
2532 break;
2533 case 0x07:
2534 GETBYTE ();
2535 switch (op[3] & 0x00)
2536 {
2537 case 0x00:
2538 goto op_semantics_11;
2539 break;
2540 }
2541 break;
2542 case 0x08:
2543 GETBYTE ();
2544 switch (op[3] & 0x00)
2545 {
2546 case 0x00:
2547 goto op_semantics_12;
2548 break;
2549 }
2550 break;
2551 case 0x09:
2552 GETBYTE ();
2553 switch (op[3] & 0x00)
2554 {
2555 case 0x00:
2556 goto op_semantics_13;
2557 break;
2558 }
2559 break;
2560 case 0x0c:
2561 GETBYTE ();
2562 switch (op[3] & 0x00)
2563 {
2564 case 0x00:
2565 goto op_semantics_14;
2566 break;
2567 }
2568 break;
2569 case 0x0d:
2570 GETBYTE ();
2571 switch (op[3] & 0x00)
2572 {
2573 case 0x00:
2574 goto op_semantics_15;
2575 break;
2576 }
2577 break;
2578 case 0x10:
2579 GETBYTE ();
2580 switch (op[3] & 0x00)
2581 {
2582 case 0x00:
2583 goto op_semantics_16;
2584 break;
2585 }
2586 break;
2587 case 0x11:
2588 GETBYTE ();
2589 switch (op[3] & 0x00)
2590 {
2591 case 0x00:
2592 goto op_semantics_17;
2593 break;
2594 }
2595 break;
2596 default: UNSUPPORTED(); break;
2597 }
2598 break;
2599 case 0xa2:
2600 GETBYTE ();
2601 switch (op[2] & 0xff)
2602 {
2603 case 0x00:
2604 GETBYTE ();
2605 switch (op[3] & 0x00)
2606 {
2607 case 0x00:
2608 goto op_semantics_7;
2609 break;
2610 }
2611 break;
2612 case 0x02:
2613 GETBYTE ();
2614 switch (op[3] & 0x00)
2615 {
2616 case 0x00:
2617 goto op_semantics_18;
2618 break;
2619 }
2620 break;
2621 case 0x04:
2622 GETBYTE ();
2623 switch (op[3] & 0x00)
2624 {
2625 case 0x00:
2626 goto op_semantics_8;
2627 break;
2628 }
2629 break;
2630 case 0x05:
2631 GETBYTE ();
2632 switch (op[3] & 0x00)
2633 {
2634 case 0x00:
2635 goto op_semantics_9;
2636 break;
2637 }
2638 break;
2639 case 0x06:
2640 GETBYTE ();
2641 switch (op[3] & 0x00)
2642 {
2643 case 0x00:
2644 goto op_semantics_10;
2645 break;
2646 }
2647 break;
2648 case 0x07:
2649 GETBYTE ();
2650 switch (op[3] & 0x00)
2651 {
2652 case 0x00:
2653 goto op_semantics_11;
2654 break;
2655 }
2656 break;
2657 case 0x08:
2658 GETBYTE ();
2659 switch (op[3] & 0x00)
2660 {
2661 case 0x00:
2662 goto op_semantics_12;
2663 break;
2664 }
2665 break;
2666 case 0x09:
2667 GETBYTE ();
2668 switch (op[3] & 0x00)
2669 {
2670 case 0x00:
2671 goto op_semantics_13;
2672 break;
2673 }
2674 break;
2675 case 0x0c:
2676 GETBYTE ();
2677 switch (op[3] & 0x00)
2678 {
2679 case 0x00:
2680 goto op_semantics_14;
2681 break;
2682 }
2683 break;
2684 case 0x0d:
2685 GETBYTE ();
2686 switch (op[3] & 0x00)
2687 {
2688 case 0x00:
2689 goto op_semantics_15;
2690 break;
2691 }
2692 break;
2693 case 0x10:
2694 GETBYTE ();
2695 switch (op[3] & 0x00)
2696 {
2697 case 0x00:
2698 goto op_semantics_16;
2699 break;
2700 }
2701 break;
2702 case 0x11:
2703 GETBYTE ();
2704 switch (op[3] & 0x00)
2705 {
2706 case 0x00:
2707 goto op_semantics_17;
2708 break;
2709 }
2710 break;
2711 default: UNSUPPORTED(); break;
2712 }
2713 break;
2714 case 0xa3:
2715 GETBYTE ();
2716 switch (op[2] & 0xff)
2717 {
2718 case 0x00:
2719 GETBYTE ();
2720 switch (op[3] & 0x00)
2721 {
2722 case 0x00:
2723 goto op_semantics_7;
2724 break;
2725 }
2726 break;
2727 case 0x02:
2728 GETBYTE ();
2729 switch (op[3] & 0x00)
2730 {
2731 case 0x00:
2732 goto op_semantics_18;
2733 break;
2734 }
2735 break;
2736 case 0x04:
2737 GETBYTE ();
2738 switch (op[3] & 0x00)
2739 {
2740 case 0x00:
2741 goto op_semantics_8;
2742 break;
2743 }
2744 break;
2745 case 0x05:
2746 GETBYTE ();
2747 switch (op[3] & 0x00)
2748 {
2749 case 0x00:
2750 goto op_semantics_9;
2751 break;
2752 }
2753 break;
2754 case 0x06:
2755 GETBYTE ();
2756 switch (op[3] & 0x00)
2757 {
2758 case 0x00:
2759 goto op_semantics_10;
2760 break;
2761 }
2762 break;
2763 case 0x07:
2764 GETBYTE ();
2765 switch (op[3] & 0x00)
2766 {
2767 case 0x00:
2768 goto op_semantics_11;
2769 break;
2770 }
2771 break;
2772 case 0x08:
2773 GETBYTE ();
2774 switch (op[3] & 0x00)
2775 {
2776 case 0x00:
2777 goto op_semantics_12;
2778 break;
2779 }
2780 break;
2781 case 0x09:
2782 GETBYTE ();
2783 switch (op[3] & 0x00)
2784 {
2785 case 0x00:
2786 goto op_semantics_13;
2787 break;
2788 }
2789 break;
2790 case 0x0c:
2791 GETBYTE ();
2792 switch (op[3] & 0x00)
2793 {
2794 case 0x00:
2795 goto op_semantics_14;
2796 break;
2797 }
2798 break;
2799 case 0x0d:
2800 GETBYTE ();
2801 switch (op[3] & 0x00)
2802 {
2803 case 0x00:
2804 goto op_semantics_15;
2805 break;
2806 }
2807 break;
2808 case 0x10:
2809 GETBYTE ();
2810 switch (op[3] & 0x00)
2811 {
2812 case 0x00:
2813 goto op_semantics_16;
2814 break;
2815 }
2816 break;
2817 case 0x11:
2818 GETBYTE ();
2819 switch (op[3] & 0x00)
2820 {
2821 case 0x00:
2822 goto op_semantics_17;
2823 break;
2824 }
2825 break;
2826 default: UNSUPPORTED(); break;
2827 }
2828 break;
2829 case 0xc0:
2830 GETBYTE ();
2831 switch (op[2] & 0x00)
2832 {
2833 case 0x00:
2834 goto op_semantics_1;
2835 break;
2836 }
2837 break;
2838 case 0xc1:
2839 GETBYTE ();
2840 switch (op[2] & 0x00)
2841 {
2842 case 0x00:
2843 goto op_semantics_1;
2844 break;
2845 }
2846 break;
2847 case 0xc2:
2848 GETBYTE ();
2849 switch (op[2] & 0x00)
2850 {
2851 case 0x00:
2852 goto op_semantics_1;
2853 break;
2854 }
2855 break;
2856 case 0xc3:
2857 GETBYTE ();
2858 switch (op[2] & 0x00)
2859 {
2860 case 0x00:
2861 goto op_semantics_1;
2862 break;
2863 }
2864 break;
2865 case 0xc4:
2866 GETBYTE ();
2867 switch (op[2] & 0x00)
2868 {
2869 case 0x00:
2870 goto op_semantics_2;
2871 break;
2872 }
2873 break;
2874 case 0xc5:
2875 GETBYTE ();
2876 switch (op[2] & 0x00)
2877 {
2878 case 0x00:
2879 goto op_semantics_2;
2880 break;
2881 }
2882 break;
2883 case 0xc6:
2884 GETBYTE ();
2885 switch (op[2] & 0x00)
2886 {
2887 case 0x00:
2888 goto op_semantics_2;
2889 break;
2890 }
2891 break;
2892 case 0xc7:
2893 GETBYTE ();
2894 switch (op[2] & 0x00)
2895 {
2896 case 0x00:
2897 goto op_semantics_2;
2898 break;
2899 }
2900 break;
2901 case 0xc8:
2902 GETBYTE ();
2903 switch (op[2] & 0x00)
2904 {
2905 case 0x00:
2906 goto op_semantics_3;
2907 break;
2908 }
2909 break;
2910 case 0xc9:
2911 GETBYTE ();
2912 switch (op[2] & 0x00)
2913 {
2914 case 0x00:
2915 goto op_semantics_3;
2916 break;
2917 }
2918 break;
2919 case 0xca:
2920 GETBYTE ();
2921 switch (op[2] & 0x00)
2922 {
2923 case 0x00:
2924 goto op_semantics_3;
2925 break;
2926 }
2927 break;
2928 case 0xcb:
2929 GETBYTE ();
2930 switch (op[2] & 0x00)
2931 {
2932 case 0x00:
2933 goto op_semantics_3;
2934 break;
2935 }
2936 break;
2937 case 0xcc:
2938 GETBYTE ();
2939 switch (op[2] & 0x00)
2940 {
2941 case 0x00:
2942 goto op_semantics_4;
2943 break;
2944 }
2945 break;
2946 case 0xcd:
2947 GETBYTE ();
2948 switch (op[2] & 0x00)
2949 {
2950 case 0x00:
2951 goto op_semantics_4;
2952 break;
2953 }
2954 break;
2955 case 0xce:
2956 GETBYTE ();
2957 switch (op[2] & 0x00)
2958 {
2959 case 0x00:
2960 goto op_semantics_4;
2961 break;
2962 }
2963 break;
2964 case 0xcf:
2965 GETBYTE ();
2966 switch (op[2] & 0x00)
2967 {
2968 case 0x00:
2969 goto op_semantics_4;
2970 break;
2971 }
2972 break;
2973 case 0xd0:
2974 GETBYTE ();
2975 switch (op[2] & 0x00)
2976 {
2977 case 0x00:
2978 goto op_semantics_5;
2979 break;
2980 }
2981 break;
2982 case 0xd1:
2983 GETBYTE ();
2984 switch (op[2] & 0x00)
2985 {
2986 case 0x00:
2987 goto op_semantics_5;
2988 break;
2989 }
2990 break;
2991 case 0xd2:
2992 GETBYTE ();
2993 switch (op[2] & 0x00)
2994 {
2995 case 0x00:
2996 goto op_semantics_5;
2997 break;
2998 }
2999 break;
3000 case 0xd3:
3001 GETBYTE ();
3002 switch (op[2] & 0x00)
3003 {
3004 case 0x00:
3005 goto op_semantics_5;
3006 break;
3007 }
3008 break;
3009 case 0xd4:
3010 GETBYTE ();
3011 switch (op[2] & 0x00)
3012 {
3013 case 0x00:
3014 goto op_semantics_6;
3015 break;
3016 }
3017 break;
3018 case 0xd5:
3019 GETBYTE ();
3020 switch (op[2] & 0x00)
3021 {
3022 case 0x00:
3023 goto op_semantics_6;
3024 break;
3025 }
3026 break;
3027 case 0xd6:
3028 GETBYTE ();
3029 switch (op[2] & 0x00)
3030 {
3031 case 0x00:
3032 goto op_semantics_6;
3033 break;
3034 }
3035 break;
3036 case 0xd7:
3037 GETBYTE ();
3038 switch (op[2] & 0x00)
3039 {
3040 case 0x00:
3041 goto op_semantics_6;
3042 break;
3043 }
3044 break;
3045 case 0xe0:
3046 GETBYTE ();
3047 switch (op[2] & 0xff)
3048 {
3049 case 0x00:
3050 GETBYTE ();
3051 switch (op[3] & 0x00)
3052 {
3053 case 0x00:
3054 goto op_semantics_7;
3055 break;
3056 }
3057 break;
3058 case 0x04:
3059 GETBYTE ();
3060 switch (op[3] & 0x00)
3061 {
3062 case 0x00:
3063 goto op_semantics_8;
3064 break;
3065 }
3066 break;
3067 case 0x05:
3068 GETBYTE ();
3069 switch (op[3] & 0x00)
3070 {
3071 case 0x00:
3072 goto op_semantics_9;
3073 break;
3074 }
3075 break;
3076 case 0x06:
3077 GETBYTE ();
3078 switch (op[3] & 0x00)
3079 {
3080 case 0x00:
3081 goto op_semantics_10;
3082 break;
3083 }
3084 break;
3085 case 0x07:
3086 GETBYTE ();
3087 switch (op[3] & 0x00)
3088 {
3089 case 0x00:
3090 goto op_semantics_11;
3091 break;
3092 }
3093 break;
3094 case 0x08:
3095 GETBYTE ();
3096 switch (op[3] & 0x00)
3097 {
3098 case 0x00:
3099 goto op_semantics_12;
3100 break;
3101 }
3102 break;
3103 case 0x09:
3104 GETBYTE ();
3105 switch (op[3] & 0x00)
3106 {
3107 case 0x00:
3108 goto op_semantics_13;
3109 break;
3110 }
3111 break;
3112 case 0x0c:
3113 GETBYTE ();
3114 switch (op[3] & 0x00)
3115 {
3116 case 0x00:
3117 goto op_semantics_14;
3118 break;
3119 }
3120 break;
3121 case 0x0d:
3122 GETBYTE ();
3123 switch (op[3] & 0x00)
3124 {
3125 case 0x00:
3126 goto op_semantics_15;
3127 break;
3128 }
3129 break;
3130 case 0x10:
3131 GETBYTE ();
3132 switch (op[3] & 0x00)
3133 {
3134 case 0x00:
3135 goto op_semantics_16;
3136 break;
3137 }
3138 break;
3139 case 0x11:
3140 GETBYTE ();
3141 switch (op[3] & 0x00)
3142 {
3143 case 0x00:
3144 goto op_semantics_17;
3145 break;
3146 }
3147 break;
3148 default: UNSUPPORTED(); break;
3149 }
3150 break;
3151 case 0xe1:
3152 GETBYTE ();
3153 switch (op[2] & 0xff)
3154 {
3155 case 0x00:
3156 GETBYTE ();
3157 switch (op[3] & 0x00)
3158 {
3159 case 0x00:
3160 goto op_semantics_7;
3161 break;
3162 }
3163 break;
3164 case 0x04:
3165 GETBYTE ();
3166 switch (op[3] & 0x00)
3167 {
3168 case 0x00:
3169 goto op_semantics_8;
3170 break;
3171 }
3172 break;
3173 case 0x05:
3174 GETBYTE ();
3175 switch (op[3] & 0x00)
3176 {
3177 case 0x00:
3178 goto op_semantics_9;
3179 break;
3180 }
3181 break;
3182 case 0x06:
3183 GETBYTE ();
3184 switch (op[3] & 0x00)
3185 {
3186 case 0x00:
3187 goto op_semantics_10;
3188 break;
3189 }
3190 break;
3191 case 0x07:
3192 GETBYTE ();
3193 switch (op[3] & 0x00)
3194 {
3195 case 0x00:
3196 goto op_semantics_11;
3197 break;
3198 }
3199 break;
3200 case 0x08:
3201 GETBYTE ();
3202 switch (op[3] & 0x00)
3203 {
3204 case 0x00:
3205 goto op_semantics_12;
3206 break;
3207 }
3208 break;
3209 case 0x09:
3210 GETBYTE ();
3211 switch (op[3] & 0x00)
3212 {
3213 case 0x00:
3214 goto op_semantics_13;
3215 break;
3216 }
3217 break;
3218 case 0x0c:
3219 GETBYTE ();
3220 switch (op[3] & 0x00)
3221 {
3222 case 0x00:
3223 goto op_semantics_14;
3224 break;
3225 }
3226 break;
3227 case 0x0d:
3228 GETBYTE ();
3229 switch (op[3] & 0x00)
3230 {
3231 case 0x00:
3232 goto op_semantics_15;
3233 break;
3234 }
3235 break;
3236 case 0x10:
3237 GETBYTE ();
3238 switch (op[3] & 0x00)
3239 {
3240 case 0x00:
3241 goto op_semantics_16;
3242 break;
3243 }
3244 break;
3245 case 0x11:
3246 GETBYTE ();
3247 switch (op[3] & 0x00)
3248 {
3249 case 0x00:
3250 goto op_semantics_17;
3251 break;
3252 }
3253 break;
3254 default: UNSUPPORTED(); break;
3255 }
3256 break;
3257 case 0xe2:
3258 GETBYTE ();
3259 switch (op[2] & 0xff)
3260 {
3261 case 0x00:
3262 GETBYTE ();
3263 switch (op[3] & 0x00)
3264 {
3265 case 0x00:
3266 goto op_semantics_7;
3267 break;
3268 }
3269 break;
3270 case 0x04:
3271 GETBYTE ();
3272 switch (op[3] & 0x00)
3273 {
3274 case 0x00:
3275 goto op_semantics_8;
3276 break;
3277 }
3278 break;
3279 case 0x05:
3280 GETBYTE ();
3281 switch (op[3] & 0x00)
3282 {
3283 case 0x00:
3284 goto op_semantics_9;
3285 break;
3286 }
3287 break;
3288 case 0x06:
3289 GETBYTE ();
3290 switch (op[3] & 0x00)
3291 {
3292 case 0x00:
3293 goto op_semantics_10;
3294 break;
3295 }
3296 break;
3297 case 0x07:
3298 GETBYTE ();
3299 switch (op[3] & 0x00)
3300 {
3301 case 0x00:
3302 goto op_semantics_11;
3303 break;
3304 }
3305 break;
3306 case 0x08:
3307 GETBYTE ();
3308 switch (op[3] & 0x00)
3309 {
3310 case 0x00:
3311 goto op_semantics_12;
3312 break;
3313 }
3314 break;
3315 case 0x09:
3316 GETBYTE ();
3317 switch (op[3] & 0x00)
3318 {
3319 case 0x00:
3320 goto op_semantics_13;
3321 break;
3322 }
3323 break;
3324 case 0x0c:
3325 GETBYTE ();
3326 switch (op[3] & 0x00)
3327 {
3328 case 0x00:
3329 goto op_semantics_14;
3330 break;
3331 }
3332 break;
3333 case 0x0d:
3334 GETBYTE ();
3335 switch (op[3] & 0x00)
3336 {
3337 case 0x00:
3338 goto op_semantics_15;
3339 break;
3340 }
3341 break;
3342 case 0x10:
3343 GETBYTE ();
3344 switch (op[3] & 0x00)
3345 {
3346 case 0x00:
3347 goto op_semantics_16;
3348 break;
3349 }
3350 break;
3351 case 0x11:
3352 GETBYTE ();
3353 switch (op[3] & 0x00)
3354 {
3355 case 0x00:
3356 goto op_semantics_17;
3357 break;
3358 }
3359 break;
3360 default: UNSUPPORTED(); break;
3361 }
3362 break;
3363 case 0xe3:
3364 GETBYTE ();
3365 switch (op[2] & 0xff)
3366 {
3367 case 0x00:
3368 GETBYTE ();
3369 switch (op[3] & 0x00)
3370 {
3371 case 0x00:
3372 goto op_semantics_7;
3373 break;
3374 }
3375 break;
3376 case 0x04:
3377 GETBYTE ();
3378 switch (op[3] & 0x00)
3379 {
3380 case 0x00:
3381 goto op_semantics_8;
3382 break;
3383 }
3384 break;
3385 case 0x05:
3386 GETBYTE ();
3387 switch (op[3] & 0x00)
3388 {
3389 case 0x00:
3390 goto op_semantics_9;
3391 break;
3392 }
3393 break;
3394 case 0x06:
3395 GETBYTE ();
3396 switch (op[3] & 0x00)
3397 {
3398 case 0x00:
3399 goto op_semantics_10;
3400 break;
3401 }
3402 break;
3403 case 0x07:
3404 GETBYTE ();
3405 switch (op[3] & 0x00)
3406 {
3407 case 0x00:
3408 goto op_semantics_11;
3409 break;
3410 }
3411 break;
3412 case 0x08:
3413 GETBYTE ();
3414 switch (op[3] & 0x00)
3415 {
3416 case 0x00:
3417 goto op_semantics_12;
3418 break;
3419 }
3420 break;
3421 case 0x09:
3422 GETBYTE ();
3423 switch (op[3] & 0x00)
3424 {
3425 case 0x00:
3426 goto op_semantics_13;
3427 break;
3428 }
3429 break;
3430 case 0x0c:
3431 GETBYTE ();
3432 switch (op[3] & 0x00)
3433 {
3434 case 0x00:
3435 goto op_semantics_14;
3436 break;
3437 }
3438 break;
3439 case 0x0d:
3440 GETBYTE ();
3441 switch (op[3] & 0x00)
3442 {
3443 case 0x00:
3444 goto op_semantics_15;
3445 break;
3446 }
3447 break;
3448 case 0x10:
3449 GETBYTE ();
3450 switch (op[3] & 0x00)
3451 {
3452 case 0x00:
3453 goto op_semantics_16;
3454 break;
3455 }
3456 break;
3457 case 0x11:
3458 GETBYTE ();
3459 switch (op[3] & 0x00)
3460 {
3461 case 0x00:
3462 goto op_semantics_17;
3463 break;
3464 }
3465 break;
3466 default: UNSUPPORTED(); break;
3467 }
3468 break;
3469 default: UNSUPPORTED(); break;
3470 }
3471 break;
3472 case 0x08:
3473 case 0x09:
3474 case 0x0a:
3475 case 0x0b:
3476 case 0x0c:
3477 case 0x0d:
3478 case 0x0e:
3479 case 0x0f:
3480 {
3481 /** 0000 1dsp bra.s %a0 */
3482#line 737 "rx-decode.opc"
3483 int dsp AU = op[0] & 0x07;
3484 if (trace)
3485 {
3486 printf ("\033[33m%s\033[0m %02x\n",
3487 "/** 0000 1dsp bra.s %a0 */",
3488 op[0]);
3489 printf (" dsp = 0x%x\n", dsp);
3490 }
3491 SYNTAX("bra.s %a0");
3492#line 737 "rx-decode.opc"
3493 ID(branch); DC(pc + dsp3map[dsp]);
3494
3495 }
3496 break;
3497 case 0x10:
3498 case 0x11:
3499 case 0x12:
3500 case 0x13:
3501 case 0x14:
3502 case 0x15:
3503 case 0x16:
3504 case 0x17:
3505 case 0x18:
3506 case 0x19:
3507 case 0x1a:
3508 case 0x1b:
3509 case 0x1c:
3510 case 0x1d:
3511 case 0x1e:
3512 case 0x1f:
3513 {
3514 /** 0001 n dsp b%1.s %a0 */
3515#line 727 "rx-decode.opc"
3516 int n AU = (op[0] >> 3) & 0x01;
3517#line 727 "rx-decode.opc"
3518 int dsp AU = op[0] & 0x07;
3519 if (trace)
3520 {
3521 printf ("\033[33m%s\033[0m %02x\n",
3522 "/** 0001 n dsp b%1.s %a0 */",
3523 op[0]);
3524 printf (" n = 0x%x,", n);
3525 printf (" dsp = 0x%x\n", dsp);
3526 }
3527 SYNTAX("b%1.s %a0");
3528#line 727 "rx-decode.opc"
3529 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3530
3531 }
3532 break;
3533 case 0x20:
3534 case 0x21:
3535 case 0x22:
3536 case 0x23:
3537 case 0x24:
3538 case 0x25:
3539 case 0x26:
3540 case 0x27:
3541 case 0x28:
3542 case 0x29:
3543 case 0x2a:
3544 case 0x2b:
3545 case 0x2c:
3546 case 0x2d:
3547 case 0x2f:
3548 {
3549 /** 0010 cond b%1.b %a0 */
3550#line 730 "rx-decode.opc"
3551 int cond AU = op[0] & 0x0f;
3552 if (trace)
3553 {
3554 printf ("\033[33m%s\033[0m %02x\n",
3555 "/** 0010 cond b%1.b %a0 */",
3556 op[0]);
3557 printf (" cond = 0x%x\n", cond);
3558 }
3559 SYNTAX("b%1.b %a0");
3560#line 730 "rx-decode.opc"
3561 ID(branch); Scc(cond); DC(pc + IMMex (1));
3562
3563 }
3564 break;
3565 case 0x2e:
3566 {
3567 /** 0010 1110 bra.b %a0 */
3568 if (trace)
3569 {
3570 printf ("\033[33m%s\033[0m %02x\n",
3571 "/** 0010 1110 bra.b %a0 */",
3572 op[0]);
3573 }
3574 SYNTAX("bra.b %a0");
3575#line 740 "rx-decode.opc"
3576 ID(branch); DC(pc + IMMex(1));
3577
3578 }
3579 break;
3580 case 0x38:
3581 {
3582 /** 0011 1000 bra.w %a0 */
3583 if (trace)
3584 {
3585 printf ("\033[33m%s\033[0m %02x\n",
3586 "/** 0011 1000 bra.w %a0 */",
3587 op[0]);
3588 }
3589 SYNTAX("bra.w %a0");
3590#line 743 "rx-decode.opc"
3591 ID(branch); DC(pc + IMMex(2));
3592
3593 }
3594 break;
3595 case 0x39:
3596 {
3597 /** 0011 1001 bsr.w %a0 */
3598 if (trace)
3599 {
3600 printf ("\033[33m%s\033[0m %02x\n",
3601 "/** 0011 1001 bsr.w %a0 */",
3602 op[0]);
3603 }
3604 SYNTAX("bsr.w %a0");
3605#line 759 "rx-decode.opc"
3606 ID(jsr); DC(pc + IMMex(2));
3607
3608 }
3609 break;
3610 case 0x3a:
3611 case 0x3b:
3612 {
3613 /** 0011 101c b%1.w %a0 */
3614#line 733 "rx-decode.opc"
3615 int c AU = op[0] & 0x01;
3616 if (trace)
3617 {
3618 printf ("\033[33m%s\033[0m %02x\n",
3619 "/** 0011 101c b%1.w %a0 */",
3620 op[0]);
3621 printf (" c = 0x%x\n", c);
3622 }
3623 SYNTAX("b%1.w %a0");
3624#line 733 "rx-decode.opc"
3625 ID(branch); Scc(c); DC(pc + IMMex (2));
3626
3627
3628 }
3629 break;
3630 case 0x3c:
3631 GETBYTE ();
3632 switch (op[1] & 0x00)
3633 {
3634 case 0x00:
3635 op_semantics_19:
3636 {
3637 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3638#line 307 "rx-decode.opc"
3639 int sz AU = op[0] & 0x03;
3640#line 307 "rx-decode.opc"
3641 int d AU = (op[1] >> 7) & 0x01;
3642#line 307 "rx-decode.opc"
3643 int dst AU = (op[1] >> 4) & 0x07;
3644#line 307 "rx-decode.opc"
3645 int sppp AU = op[1] & 0x0f;
3646 if (trace)
3647 {
3648 printf ("\033[33m%s\033[0m %02x %02x\n",
3649 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3650 op[0], op[1]);
3651 printf (" sz = 0x%x,", sz);
3652 printf (" d = 0x%x,", d);
3653 printf (" dst = 0x%x,", dst);
3654 printf (" sppp = 0x%x\n", sppp);
3655 }
3656 SYNTAX("mov%s #%1, %0");
3657#line 307 "rx-decode.opc"
3658 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3659
3660 }
3661 break;
3662 }
3663 break;
3664 case 0x3d:
3665 GETBYTE ();
3666 switch (op[1] & 0x00)
3667 {
3668 case 0x00:
3669 goto op_semantics_19;
3670 break;
3671 }
3672 break;
3673 case 0x3e:
3674 GETBYTE ();
3675 switch (op[1] & 0x00)
3676 {
3677 case 0x00:
3678 goto op_semantics_19;
3679 break;
3680 }
3681 break;
3682 case 0x3f:
3683 GETBYTE ();
3684 switch (op[1] & 0x00)
3685 {
3686 case 0x00:
3687 {
3688 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3689#line 404 "rx-decode.opc"
3690 int rega AU = (op[1] >> 4) & 0x0f;
3691#line 404 "rx-decode.opc"
3692 int regb AU = op[1] & 0x0f;
3693 if (trace)
3694 {
3695 printf ("\033[33m%s\033[0m %02x %02x\n",
3696 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3697 op[0], op[1]);
3698 printf (" rega = 0x%x,", rega);
3699 printf (" regb = 0x%x\n", regb);
3700 }
3701 SYNTAX("rtsd #%1, %2-%0");
3702#line 404 "rx-decode.opc"
3703 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3704
3705 /*----------------------------------------------------------------------*/
3706 /* AND */
3707
3708 }
3709 break;
3710 }
3711 break;
3712 case 0x40:
3713 GETBYTE ();
3714 switch (op[1] & 0x00)
3715 {
3716 case 0x00:
3717 op_semantics_20:
3718 {
3719 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3720#line 539 "rx-decode.opc"
3721 int ss AU = op[0] & 0x03;
3722#line 539 "rx-decode.opc"
3723 int rsrc AU = (op[1] >> 4) & 0x0f;
3724#line 539 "rx-decode.opc"
3725 int rdst AU = op[1] & 0x0f;
3726 if (trace)
3727 {
3728 printf ("\033[33m%s\033[0m %02x %02x\n",
3729 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3730 op[0], op[1]);
3731 printf (" ss = 0x%x,", ss);
3732 printf (" rsrc = 0x%x,", rsrc);
3733 printf (" rdst = 0x%x\n", rdst);
3734 }
3735 SYNTAX("sub %2%S2, %1");
3736#line 539 "rx-decode.opc"
3737 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3738
3739 }
3740 break;
3741 }
3742 break;
3743 case 0x41:
3744 GETBYTE ();
3745 switch (op[1] & 0x00)
3746 {
3747 case 0x00:
3748 goto op_semantics_20;
3749 break;
3750 }
3751 break;
3752 case 0x42:
3753 GETBYTE ();
3754 switch (op[1] & 0x00)
3755 {
3756 case 0x00:
3757 goto op_semantics_20;
3758 break;
3759 }
3760 break;
3761 case 0x43:
3762 GETBYTE ();
3763 switch (op[1] & 0x00)
3764 {
3765 case 0x00:
3766 goto op_semantics_20;
3767 break;
3768 }
3769 break;
3770 case 0x44:
3771 GETBYTE ();
3772 switch (op[1] & 0x00)
3773 {
3774 case 0x00:
3775 op_semantics_21:
3776 {
3777 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3778#line 527 "rx-decode.opc"
3779 int ss AU = op[0] & 0x03;
3780#line 527 "rx-decode.opc"
3781 int rsrc AU = (op[1] >> 4) & 0x0f;
3782#line 527 "rx-decode.opc"
3783 int rdst AU = op[1] & 0x0f;
3784 if (trace)
3785 {
3786 printf ("\033[33m%s\033[0m %02x %02x\n",
3787 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3788 op[0], op[1]);
3789 printf (" ss = 0x%x,", ss);
3790 printf (" rsrc = 0x%x,", rsrc);
3791 printf (" rdst = 0x%x\n", rdst);
3792 }
3793 SYNTAX("cmp %2%S2, %1");
3794#line 527 "rx-decode.opc"
3795 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3796
3797 }
3798 break;
3799 }
3800 break;
3801 case 0x45:
3802 GETBYTE ();
3803 switch (op[1] & 0x00)
3804 {
3805 case 0x00:
3806 goto op_semantics_21;
3807 break;
3808 }
3809 break;
3810 case 0x46:
3811 GETBYTE ();
3812 switch (op[1] & 0x00)
3813 {
3814 case 0x00:
3815 goto op_semantics_21;
3816 break;
3817 }
3818 break;
3819 case 0x47:
3820 GETBYTE ();
3821 switch (op[1] & 0x00)
3822 {
3823 case 0x00:
3824 goto op_semantics_21;
3825 break;
3826 }
3827 break;
3828 case 0x48:
3829 GETBYTE ();
3830 switch (op[1] & 0x00)
3831 {
3832 case 0x00:
3833 op_semantics_22:
3834 {
3835 /** 0100 10ss rsrc rdst add %1%S1, %0 */
3836#line 503 "rx-decode.opc"
3837 int ss AU = op[0] & 0x03;
3838#line 503 "rx-decode.opc"
3839 int rsrc AU = (op[1] >> 4) & 0x0f;
3840#line 503 "rx-decode.opc"
3841 int rdst AU = op[1] & 0x0f;
3842 if (trace)
3843 {
3844 printf ("\033[33m%s\033[0m %02x %02x\n",
3845 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3846 op[0], op[1]);
3847 printf (" ss = 0x%x,", ss);
3848 printf (" rsrc = 0x%x,", rsrc);
3849 printf (" rdst = 0x%x\n", rdst);
3850 }
3851 SYNTAX("add %1%S1, %0");
3852#line 503 "rx-decode.opc"
3853 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
3854
3855 }
3856 break;
3857 }
3858 break;
3859 case 0x49:
3860 GETBYTE ();
3861 switch (op[1] & 0x00)
3862 {
3863 case 0x00:
3864 goto op_semantics_22;
3865 break;
3866 }
3867 break;
3868 case 0x4a:
3869 GETBYTE ();
3870 switch (op[1] & 0x00)
3871 {
3872 case 0x00:
3873 goto op_semantics_22;
3874 break;
3875 }
3876 break;
3877 case 0x4b:
3878 GETBYTE ();
3879 switch (op[1] & 0x00)
3880 {
3881 case 0x00:
3882 goto op_semantics_22;
3883 break;
3884 }
3885 break;
3886 case 0x4c:
3887 GETBYTE ();
3888 switch (op[1] & 0x00)
3889 {
3890 case 0x00:
3891 op_semantics_23:
3892 {
3893 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
3894#line 608 "rx-decode.opc"
3895 int ss AU = op[0] & 0x03;
3896#line 608 "rx-decode.opc"
3897 int rsrc AU = (op[1] >> 4) & 0x0f;
3898#line 608 "rx-decode.opc"
3899 int rdst AU = op[1] & 0x0f;
3900 if (trace)
3901 {
3902 printf ("\033[33m%s\033[0m %02x %02x\n",
3903 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3904 op[0], op[1]);
3905 printf (" ss = 0x%x,", ss);
3906 printf (" rsrc = 0x%x,", rsrc);
3907 printf (" rdst = 0x%x\n", rdst);
3908 }
3909 SYNTAX("mul %1%S1, %0");
3910#line 608 "rx-decode.opc"
3911 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
3912
3913 }
3914 break;
3915 }
3916 break;
3917 case 0x4d:
3918 GETBYTE ();
3919 switch (op[1] & 0x00)
3920 {
3921 case 0x00:
3922 goto op_semantics_23;
3923 break;
3924 }
3925 break;
3926 case 0x4e:
3927 GETBYTE ();
3928 switch (op[1] & 0x00)
3929 {
3930 case 0x00:
3931 goto op_semantics_23;
3932 break;
3933 }
3934 break;
3935 case 0x4f:
3936 GETBYTE ();
3937 switch (op[1] & 0x00)
3938 {
3939 case 0x00:
3940 goto op_semantics_23;
3941 break;
3942 }
3943 break;
3944 case 0x50:
3945 GETBYTE ();
3946 switch (op[1] & 0x00)
3947 {
3948 case 0x00:
3949 op_semantics_24:
3950 {
3951 /** 0101 00ss rsrc rdst and %1%S1, %0 */
3952#line 416 "rx-decode.opc"
3953 int ss AU = op[0] & 0x03;
3954#line 416 "rx-decode.opc"
3955 int rsrc AU = (op[1] >> 4) & 0x0f;
3956#line 416 "rx-decode.opc"
3957 int rdst AU = op[1] & 0x0f;
3958 if (trace)
3959 {
3960 printf ("\033[33m%s\033[0m %02x %02x\n",
3961 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3962 op[0], op[1]);
3963 printf (" ss = 0x%x,", ss);
3964 printf (" rsrc = 0x%x,", rsrc);
3965 printf (" rdst = 0x%x\n", rdst);
3966 }
3967 SYNTAX("and %1%S1, %0");
3968#line 416 "rx-decode.opc"
3969 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
3970
3971 }
3972 break;
3973 }
3974 break;
3975 case 0x51:
3976 GETBYTE ();
3977 switch (op[1] & 0x00)
3978 {
3979 case 0x00:
3980 goto op_semantics_24;
3981 break;
3982 }
3983 break;
3984 case 0x52:
3985 GETBYTE ();
3986 switch (op[1] & 0x00)
3987 {
3988 case 0x00:
3989 goto op_semantics_24;
3990 break;
3991 }
3992 break;
3993 case 0x53:
3994 GETBYTE ();
3995 switch (op[1] & 0x00)
3996 {
3997 case 0x00:
3998 goto op_semantics_24;
3999 break;
4000 }
4001 break;
4002 case 0x54:
4003 GETBYTE ();
4004 switch (op[1] & 0x00)
4005 {
4006 case 0x00:
4007 op_semantics_25:
4008 {
4009 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4010#line 434 "rx-decode.opc"
4011 int ss AU = op[0] & 0x03;
4012#line 434 "rx-decode.opc"
4013 int rsrc AU = (op[1] >> 4) & 0x0f;
4014#line 434 "rx-decode.opc"
4015 int rdst AU = op[1] & 0x0f;
4016 if (trace)
4017 {
4018 printf ("\033[33m%s\033[0m %02x %02x\n",
4019 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4020 op[0], op[1]);
4021 printf (" ss = 0x%x,", ss);
4022 printf (" rsrc = 0x%x,", rsrc);
4023 printf (" rdst = 0x%x\n", rdst);
4024 }
4025 SYNTAX("or %1%S1, %0");
4026#line 434 "rx-decode.opc"
4027 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4028
4029 }
4030 break;
4031 }
4032 break;
4033 case 0x55:
4034 GETBYTE ();
4035 switch (op[1] & 0x00)
4036 {
4037 case 0x00:
4038 goto op_semantics_25;
4039 break;
4040 }
4041 break;
4042 case 0x56:
4043 GETBYTE ();
4044 switch (op[1] & 0x00)
4045 {
4046 case 0x00:
4047 goto op_semantics_25;
4048 break;
4049 }
4050 break;
4051 case 0x57:
4052 GETBYTE ();
4053 switch (op[1] & 0x00)
4054 {
4055 case 0x00:
4056 goto op_semantics_25;
4057 break;
4058 }
4059 break;
4060 case 0x58:
4061 GETBYTE ();
4062 switch (op[1] & 0x00)
4063 {
4064 case 0x00:
4065 op_semantics_26:
4066 {
4067 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4068#line 355 "rx-decode.opc"
4069 int s AU = (op[0] >> 2) & 0x01;
4070#line 355 "rx-decode.opc"
4071 int ss AU = op[0] & 0x03;
4072#line 355 "rx-decode.opc"
4073 int rsrc AU = (op[1] >> 4) & 0x0f;
4074#line 355 "rx-decode.opc"
4075 int rdst AU = op[1] & 0x0f;
4076 if (trace)
4077 {
4078 printf ("\033[33m%s\033[0m %02x %02x\n",
4079 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4080 op[0], op[1]);
4081 printf (" s = 0x%x,", s);
4082 printf (" ss = 0x%x,", ss);
4083 printf (" rsrc = 0x%x,", rsrc);
4084 printf (" rdst = 0x%x\n", rdst);
4085 }
4086 SYNTAX("movu%s %1, %0");
4087#line 355 "rx-decode.opc"
4088 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4089
4090 }
4091 break;
4092 }
4093 break;
4094 case 0x59:
4095 GETBYTE ();
4096 switch (op[1] & 0x00)
4097 {
4098 case 0x00:
4099 goto op_semantics_26;
4100 break;
4101 }
4102 break;
4103 case 0x5a:
4104 GETBYTE ();
4105 switch (op[1] & 0x00)
4106 {
4107 case 0x00:
4108 goto op_semantics_26;
4109 break;
4110 }
4111 break;
4112 case 0x5b:
4113 GETBYTE ();
4114 switch (op[1] & 0x00)
4115 {
4116 case 0x00:
4117 goto op_semantics_26;
4118 break;
4119 }
4120 break;
4121 case 0x5c:
4122 GETBYTE ();
4123 switch (op[1] & 0x00)
4124 {
4125 case 0x00:
4126 goto op_semantics_26;
4127 break;
4128 }
4129 break;
4130 case 0x5d:
4131 GETBYTE ();
4132 switch (op[1] & 0x00)
4133 {
4134 case 0x00:
4135 goto op_semantics_26;
4136 break;
4137 }
4138 break;
4139 case 0x5e:
4140 GETBYTE ();
4141 switch (op[1] & 0x00)
4142 {
4143 case 0x00:
4144 goto op_semantics_26;
4145 break;
4146 }
4147 break;
4148 case 0x5f:
4149 GETBYTE ();
4150 switch (op[1] & 0x00)
4151 {
4152 case 0x00:
4153 goto op_semantics_26;
4154 break;
4155 }
4156 break;
4157 case 0x60:
4158 GETBYTE ();
4159 switch (op[1] & 0x00)
4160 {
4161 case 0x00:
4162 {
4163 /** 0110 0000 immm rdst sub #%2, %0 */
4164#line 536 "rx-decode.opc"
4165 int immm AU = (op[1] >> 4) & 0x0f;
4166#line 536 "rx-decode.opc"
4167 int rdst AU = op[1] & 0x0f;
4168 if (trace)
4169 {
4170 printf ("\033[33m%s\033[0m %02x %02x\n",
4171 "/** 0110 0000 immm rdst sub #%2, %0 */",
4172 op[0], op[1]);
4173 printf (" immm = 0x%x,", immm);
4174 printf (" rdst = 0x%x\n", rdst);
4175 }
4176 SYNTAX("sub #%2, %0");
4177#line 536 "rx-decode.opc"
4178 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4179
4180 }
4181 break;
4182 }
4183 break;
4184 case 0x61:
4185 GETBYTE ();
4186 switch (op[1] & 0x00)
4187 {
4188 case 0x00:
4189 {
4190 /** 0110 0001 immm rdst cmp #%2, %1 */
4191#line 518 "rx-decode.opc"
4192 int immm AU = (op[1] >> 4) & 0x0f;
4193#line 518 "rx-decode.opc"
4194 int rdst AU = op[1] & 0x0f;
4195 if (trace)
4196 {
4197 printf ("\033[33m%s\033[0m %02x %02x\n",
4198 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4199 op[0], op[1]);
4200 printf (" immm = 0x%x,", immm);
4201 printf (" rdst = 0x%x\n", rdst);
4202 }
4203 SYNTAX("cmp #%2, %1");
4204#line 518 "rx-decode.opc"
4205 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4206
4207 }
4208 break;
4209 }
4210 break;
4211 case 0x62:
4212 GETBYTE ();
4213 switch (op[1] & 0x00)
4214 {
4215 case 0x00:
4216 {
4217 /** 0110 0010 immm rdst add #%1, %0 */
4218#line 500 "rx-decode.opc"
4219 int immm AU = (op[1] >> 4) & 0x0f;
4220#line 500 "rx-decode.opc"
4221 int rdst AU = op[1] & 0x0f;
4222 if (trace)
4223 {
4224 printf ("\033[33m%s\033[0m %02x %02x\n",
4225 "/** 0110 0010 immm rdst add #%1, %0 */",
4226 op[0], op[1]);
4227 printf (" immm = 0x%x,", immm);
4228 printf (" rdst = 0x%x\n", rdst);
4229 }
4230 SYNTAX("add #%1, %0");
4231#line 500 "rx-decode.opc"
4232 ID(add); SC(immm); DR(rdst); F_OSZC;
4233
4234 }
4235 break;
4236 }
4237 break;
4238 case 0x63:
4239 GETBYTE ();
4240 switch (op[1] & 0x00)
4241 {
4242 case 0x00:
4243 {
4244 /** 0110 0011 immm rdst mul #%1, %0 */
4245#line 602 "rx-decode.opc"
4246 int immm AU = (op[1] >> 4) & 0x0f;
4247#line 602 "rx-decode.opc"
4248 int rdst AU = op[1] & 0x0f;
4249 if (trace)
4250 {
4251 printf ("\033[33m%s\033[0m %02x %02x\n",
4252 "/** 0110 0011 immm rdst mul #%1, %0 */",
4253 op[0], op[1]);
4254 printf (" immm = 0x%x,", immm);
4255 printf (" rdst = 0x%x\n", rdst);
4256 }
4257 SYNTAX("mul #%1, %0");
4258#line 602 "rx-decode.opc"
4259 if (immm == 1 && rdst == 0)
4260 {
4261 ID(nop2);
4262 SYNTAX ("nop\t; mul\t#1, r0");
4263 }
4264 else
4265 {
4266 ID(mul);
4267 }
4268 DR(rdst); SC(immm); F_____;
4269 }
4270 break;
4271 }
4272 break;
4273 case 0x64:
4274 GETBYTE ();
4275 switch (op[1] & 0x00)
4276 {
4277 case 0x00:
4278 {
4279 /** 0110 0100 immm rdst and #%1, %0 */
4280#line 410 "rx-decode.opc"
4281 int immm AU = (op[1] >> 4) & 0x0f;
4282#line 410 "rx-decode.opc"
4283 int rdst AU = op[1] & 0x0f;
4284 if (trace)
4285 {
4286 printf ("\033[33m%s\033[0m %02x %02x\n",
4287 "/** 0110 0100 immm rdst and #%1, %0 */",
4288 op[0], op[1]);
4289 printf (" immm = 0x%x,", immm);
4290 printf (" rdst = 0x%x\n", rdst);
4291 }
4292 SYNTAX("and #%1, %0");
4293#line 410 "rx-decode.opc"
4294 ID(and); SC(immm); DR(rdst); F__SZ_;
4295
4296 }
4297 break;
4298 }
4299 break;
4300 case 0x65:
4301 GETBYTE ();
4302 switch (op[1] & 0x00)
4303 {
4304 case 0x00:
4305 {
4306 /** 0110 0101 immm rdst or #%1, %0 */
4307#line 428 "rx-decode.opc"
4308 int immm AU = (op[1] >> 4) & 0x0f;
4309#line 428 "rx-decode.opc"
4310 int rdst AU = op[1] & 0x0f;
4311 if (trace)
4312 {
4313 printf ("\033[33m%s\033[0m %02x %02x\n",
4314 "/** 0110 0101 immm rdst or #%1, %0 */",
4315 op[0], op[1]);
4316 printf (" immm = 0x%x,", immm);
4317 printf (" rdst = 0x%x\n", rdst);
4318 }
4319 SYNTAX("or #%1, %0");
4320#line 428 "rx-decode.opc"
4321 ID(or); SC(immm); DR(rdst); F__SZ_;
4322
4323 }
4324 break;
4325 }
4326 break;
4327 case 0x66:
4328 GETBYTE ();
4329 switch (op[1] & 0x00)
4330 {
4331 case 0x00:
4332 {
4333 /** 0110 0110 immm rdst mov%s #%1, %0 */
4334#line 304 "rx-decode.opc"
4335 int immm AU = (op[1] >> 4) & 0x0f;
4336#line 304 "rx-decode.opc"
4337 int rdst AU = op[1] & 0x0f;
4338 if (trace)
4339 {
4340 printf ("\033[33m%s\033[0m %02x %02x\n",
4341 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4342 op[0], op[1]);
4343 printf (" immm = 0x%x,", immm);
4344 printf (" rdst = 0x%x\n", rdst);
4345 }
4346 SYNTAX("mov%s #%1, %0");
4347#line 304 "rx-decode.opc"
4348 ID(mov); DR(rdst); SC(immm); F_____;
4349
4350 }
4351 break;
4352 }
4353 break;
4354 case 0x67:
4355 {
4356 /** 0110 0111 rtsd #%1 */
4357 if (trace)
4358 {
4359 printf ("\033[33m%s\033[0m %02x\n",
4360 "/** 0110 0111 rtsd #%1 */",
4361 op[0]);
4362 }
4363 SYNTAX("rtsd #%1");
4364#line 401 "rx-decode.opc"
4365 ID(rtsd); SC(IMM(1) * 4);
4366
4367 }
4368 break;
4369 case 0x68:
4370 GETBYTE ();
4371 switch (op[1] & 0x00)
4372 {
4373 case 0x00:
4374 op_semantics_27:
4375 {
4376 /** 0110 100i mmmm rdst shlr #%2, %0 */
4377#line 688 "rx-decode.opc"
4378 int i AU = op[0] & 0x01;
4379#line 688 "rx-decode.opc"
4380 int mmmm AU = (op[1] >> 4) & 0x0f;
4381#line 688 "rx-decode.opc"
4382 int rdst AU = op[1] & 0x0f;
4383 if (trace)
4384 {
4385 printf ("\033[33m%s\033[0m %02x %02x\n",
4386 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4387 op[0], op[1]);
4388 printf (" i = 0x%x,", i);
4389 printf (" mmmm = 0x%x,", mmmm);
4390 printf (" rdst = 0x%x\n", rdst);
4391 }
4392 SYNTAX("shlr #%2, %0");
4393#line 688 "rx-decode.opc"
4394 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4395
4396 }
4397 break;
4398 }
4399 break;
4400 case 0x69:
4401 GETBYTE ();
4402 switch (op[1] & 0x00)
4403 {
4404 case 0x00:
4405 goto op_semantics_27;
4406 break;
4407 }
4408 break;
4409 case 0x6a:
4410 GETBYTE ();
4411 switch (op[1] & 0x00)
4412 {
4413 case 0x00:
4414 op_semantics_28:
4415 {
4416 /** 0110 101i mmmm rdst shar #%2, %0 */
4417#line 678 "rx-decode.opc"
4418 int i AU = op[0] & 0x01;
4419#line 678 "rx-decode.opc"
4420 int mmmm AU = (op[1] >> 4) & 0x0f;
4421#line 678 "rx-decode.opc"
4422 int rdst AU = op[1] & 0x0f;
4423 if (trace)
4424 {
4425 printf ("\033[33m%s\033[0m %02x %02x\n",
4426 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4427 op[0], op[1]);
4428 printf (" i = 0x%x,", i);
4429 printf (" mmmm = 0x%x,", mmmm);
4430 printf (" rdst = 0x%x\n", rdst);
4431 }
4432 SYNTAX("shar #%2, %0");
4433#line 678 "rx-decode.opc"
4434 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4435
4436 }
4437 break;
4438 }
4439 break;
4440 case 0x6b:
4441 GETBYTE ();
4442 switch (op[1] & 0x00)
4443 {
4444 case 0x00:
4445 goto op_semantics_28;
4446 break;
4447 }
4448 break;
4449 case 0x6c:
4450 GETBYTE ();
4451 switch (op[1] & 0x00)
4452 {
4453 case 0x00:
4454 op_semantics_29:
4455 {
4456 /** 0110 110i mmmm rdst shll #%2, %0 */
4457#line 668 "rx-decode.opc"
4458 int i AU = op[0] & 0x01;
4459#line 668 "rx-decode.opc"
4460 int mmmm AU = (op[1] >> 4) & 0x0f;
4461#line 668 "rx-decode.opc"
4462 int rdst AU = op[1] & 0x0f;
4463 if (trace)
4464 {
4465 printf ("\033[33m%s\033[0m %02x %02x\n",
4466 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4467 op[0], op[1]);
4468 printf (" i = 0x%x,", i);
4469 printf (" mmmm = 0x%x,", mmmm);
4470 printf (" rdst = 0x%x\n", rdst);
4471 }
4472 SYNTAX("shll #%2, %0");
4473#line 668 "rx-decode.opc"
4474 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4475
4476 }
4477 break;
4478 }
4479 break;
4480 case 0x6d:
4481 GETBYTE ();
4482 switch (op[1] & 0x00)
4483 {
4484 case 0x00:
4485 goto op_semantics_29;
4486 break;
4487 }
4488 break;
4489 case 0x6e:
4490 GETBYTE ();
4491 switch (op[1] & 0x00)
4492 {
4493 case 0x00:
4494 {
4495 /** 0110 1110 dsta dstb pushm %1-%2 */
4496#line 368 "rx-decode.opc"
4497 int dsta AU = (op[1] >> 4) & 0x0f;
4498#line 368 "rx-decode.opc"
4499 int dstb AU = op[1] & 0x0f;
4500 if (trace)
4501 {
4502 printf ("\033[33m%s\033[0m %02x %02x\n",
4503 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4504 op[0], op[1]);
4505 printf (" dsta = 0x%x,", dsta);
4506 printf (" dstb = 0x%x\n", dstb);
4507 }
4508 SYNTAX("pushm %1-%2");
4509#line 368 "rx-decode.opc"
4510 ID(pushm); SR(dsta); S2R(dstb); F_____;
4511
4512 }
4513 break;
4514 }
4515 break;
4516 case 0x6f:
4517 GETBYTE ();
4518 switch (op[1] & 0x00)
4519 {
4520 case 0x00:
4521 {
4522 /** 0110 1111 dsta dstb popm %1-%2 */
4523#line 365 "rx-decode.opc"
4524 int dsta AU = (op[1] >> 4) & 0x0f;
4525#line 365 "rx-decode.opc"
4526 int dstb AU = op[1] & 0x0f;
4527 if (trace)
4528 {
4529 printf ("\033[33m%s\033[0m %02x %02x\n",
4530 "/** 0110 1111 dsta dstb popm %1-%2 */",
4531 op[0], op[1]);
4532 printf (" dsta = 0x%x,", dsta);
4533 printf (" dstb = 0x%x\n", dstb);
4534 }
4535 SYNTAX("popm %1-%2");
4536#line 365 "rx-decode.opc"
4537 ID(popm); SR(dsta); S2R(dstb); F_____;
4538
4539 }
4540 break;
4541 }
4542 break;
4543 case 0x70:
4544 GETBYTE ();
4545 switch (op[1] & 0x00)
4546 {
4547 case 0x00:
4548 op_semantics_30:
4549 {
4550 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4551#line 509 "rx-decode.opc"
4552 int im AU = op[0] & 0x03;
4553#line 509 "rx-decode.opc"
4554 int rsrc AU = (op[1] >> 4) & 0x0f;
4555#line 509 "rx-decode.opc"
4556 int rdst AU = op[1] & 0x0f;
4557 if (trace)
4558 {
4559 printf ("\033[33m%s\033[0m %02x %02x\n",
4560 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4561 op[0], op[1]);
4562 printf (" im = 0x%x,", im);
4563 printf (" rsrc = 0x%x,", rsrc);
4564 printf (" rdst = 0x%x\n", rdst);
4565 }
4566 SYNTAX("add #%1, %2, %0");
4567#line 509 "rx-decode.opc"
4568 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4569
4570 }
4571 break;
4572 }
4573 break;
4574 case 0x71:
4575 GETBYTE ();
4576 switch (op[1] & 0x00)
4577 {
4578 case 0x00:
4579 goto op_semantics_30;
4580 break;
4581 }
4582 break;
4583 case 0x72:
4584 GETBYTE ();
4585 switch (op[1] & 0x00)
4586 {
4587 case 0x00:
4588 goto op_semantics_30;
4589 break;
4590 }
4591 break;
4592 case 0x73:
4593 GETBYTE ();
4594 switch (op[1] & 0x00)
4595 {
4596 case 0x00:
4597 goto op_semantics_30;
4598 break;
4599 }
4600 break;
4601 case 0x74:
4602 GETBYTE ();
4603 switch (op[1] & 0xf0)
4604 {
4605 case 0x00:
4606 op_semantics_31:
4607 {
4608 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4609#line 521 "rx-decode.opc"
4610 int im AU = op[0] & 0x03;
4611#line 521 "rx-decode.opc"
4612 int rsrc AU = op[1] & 0x0f;
4613 if (trace)
4614 {
4615 printf ("\033[33m%s\033[0m %02x %02x\n",
4616 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4617 op[0], op[1]);
4618 printf (" im = 0x%x,", im);
4619 printf (" rsrc = 0x%x\n", rsrc);
4620 }
4621 SYNTAX("cmp #%2, %1%S1");
4622#line 521 "rx-decode.opc"
4623 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4624
4625 }
4626 break;
4627 case 0x10:
4628 op_semantics_32:
4629 {
4630 /** 0111 01im 0001rdst mul #%1, %0 */
4631#line 605 "rx-decode.opc"
4632 int im AU = op[0] & 0x03;
4633#line 605 "rx-decode.opc"
4634 int rdst AU = op[1] & 0x0f;
4635 int val = IMMex(im);
4636 if (trace)
4637 {
4638 printf ("\033[33m%s\033[0m %02x %02x\n",
4639 "/** 0111 01im 0001rdst mul #%1, %0 */",
4640 op[0], op[1]);
4641 printf (" im = 0x%x,", im);
4642 printf (" rdst = 0x%x\n", rdst);
4643 }
4644 SYNTAX("mul #%1, %0");
4645#line 605 "rx-decode.opc"
4646 if (val == 1 && rdst == 0)
4647 {
4648 SYNTAX("nop\t; mul\t#1, r0");
4649 switch (im)
4650 {
4651 case 2: ID(nop4); break;
4652 case 3: ID(nop5); break;
4653 case 0: ID(nop6); break;
4654 default:
4655 ID(mul);
4656 SYNTAX("mul #%1, %0");
4657 break;
4658 }
4659 }
4660 else
4661 {
4662 ID(mul);
4663 }
4664 DR(rdst); SC(val); F_____;
4665
4666 }
4667 break;
4668 case 0x20:
4669 op_semantics_33:
4670 {
4671 /** 0111 01im 0010 rdst and #%1, %0 */
4672#line 413 "rx-decode.opc"
4673 int im AU = op[0] & 0x03;
4674#line 413 "rx-decode.opc"
4675 int rdst AU = op[1] & 0x0f;
4676 if (trace)
4677 {
4678 printf ("\033[33m%s\033[0m %02x %02x\n",
4679 "/** 0111 01im 0010 rdst and #%1, %0 */",
4680 op[0], op[1]);
4681 printf (" im = 0x%x,", im);
4682 printf (" rdst = 0x%x\n", rdst);
4683 }
4684 SYNTAX("and #%1, %0");
4685#line 413 "rx-decode.opc"
4686 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4687
4688 }
4689 break;
4690 case 0x30:
4691 op_semantics_34:
4692 {
4693 /** 0111 01im 0011 rdst or #%1, %0 */
4694#line 431 "rx-decode.opc"
4695 int im AU = op[0] & 0x03;
4696#line 431 "rx-decode.opc"
4697 int rdst AU = op[1] & 0x0f;
4698 if (trace)
4699 {
4700 printf ("\033[33m%s\033[0m %02x %02x\n",
4701 "/** 0111 01im 0011 rdst or #%1, %0 */",
4702 op[0], op[1]);
4703 printf (" im = 0x%x,", im);
4704 printf (" rdst = 0x%x\n", rdst);
4705 }
4706 SYNTAX("or #%1, %0");
4707#line 431 "rx-decode.opc"
4708 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4709
4710 }
4711 break;
4712 default: UNSUPPORTED(); break;
4713 }
4714 break;
4715 case 0x75:
4716 GETBYTE ();
4717 switch (op[1] & 0xff)
4718 {
4719 case 0x00:
4720 case 0x01:
4721 case 0x02:
4722 case 0x03:
4723 case 0x04:
4724 case 0x05:
4725 case 0x06:
4726 case 0x07:
4727 case 0x08:
4728 case 0x09:
4729 case 0x0a:
4730 case 0x0b:
4731 case 0x0c:
4732 case 0x0d:
4733 case 0x0e:
4734 case 0x0f:
4735 goto op_semantics_31;
4736 break;
4737 case 0x10:
4738 case 0x11:
4739 case 0x12:
4740 case 0x13:
4741 case 0x14:
4742 case 0x15:
4743 case 0x16:
4744 case 0x17:
4745 case 0x18:
4746 case 0x19:
4747 case 0x1a:
4748 case 0x1b:
4749 case 0x1c:
4750 case 0x1d:
4751 case 0x1e:
4752 case 0x1f:
4753 goto op_semantics_32;
4754 break;
4755 case 0x20:
4756 case 0x21:
4757 case 0x22:
4758 case 0x23:
4759 case 0x24:
4760 case 0x25:
4761 case 0x26:
4762 case 0x27:
4763 case 0x28:
4764 case 0x29:
4765 case 0x2a:
4766 case 0x2b:
4767 case 0x2c:
4768 case 0x2d:
4769 case 0x2e:
4770 case 0x2f:
4771 goto op_semantics_33;
4772 break;
4773 case 0x30:
4774 case 0x31:
4775 case 0x32:
4776 case 0x33:
4777 case 0x34:
4778 case 0x35:
4779 case 0x36:
4780 case 0x37:
4781 case 0x38:
4782 case 0x39:
4783 case 0x3a:
4784 case 0x3b:
4785 case 0x3c:
4786 case 0x3d:
4787 case 0x3e:
4788 case 0x3f:
4789 goto op_semantics_34;
4790 break;
4791 case 0x40:
4792 case 0x41:
4793 case 0x42:
4794 case 0x43:
4795 case 0x44:
4796 case 0x45:
4797 case 0x46:
4798 case 0x47:
4799 case 0x48:
4800 case 0x49:
4801 case 0x4a:
4802 case 0x4b:
4803 case 0x4c:
4804 case 0x4d:
4805 case 0x4e:
4806 case 0x4f:
4807 {
4808 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4809#line 285 "rx-decode.opc"
4810 int rdst AU = op[1] & 0x0f;
4811 if (trace)
4812 {
4813 printf ("\033[33m%s\033[0m %02x %02x\n",
4814 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4815 op[0], op[1]);
4816 printf (" rdst = 0x%x\n", rdst);
4817 }
4818 SYNTAX("mov%s #%1, %0");
4819#line 285 "rx-decode.opc"
4820 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4821
4822 }
4823 break;
4824 case 0x50:
4825 case 0x51:
4826 case 0x52:
4827 case 0x53:
4828 case 0x54:
4829 case 0x55:
4830 case 0x56:
4831 case 0x57:
4832 case 0x58:
4833 case 0x59:
4834 case 0x5a:
4835 case 0x5b:
4836 case 0x5c:
4837 case 0x5d:
4838 case 0x5e:
4839 case 0x5f:
4840 {
4841 /** 0111 0101 0101 rsrc cmp #%2, %1 */
4842#line 524 "rx-decode.opc"
4843 int rsrc AU = op[1] & 0x0f;
4844 if (trace)
4845 {
4846 printf ("\033[33m%s\033[0m %02x %02x\n",
4847 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4848 op[0], op[1]);
4849 printf (" rsrc = 0x%x\n", rsrc);
4850 }
4851 SYNTAX("cmp #%2, %1");
4852#line 524 "rx-decode.opc"
4853 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
4854
4855 }
4856 break;
4857 case 0x60:
4858 {
4859 /** 0111 0101 0110 0000 int #%1 */
4860 if (trace)
4861 {
4862 printf ("\033[33m%s\033[0m %02x %02x\n",
4863 "/** 0111 0101 0110 0000 int #%1 */",
4864 op[0], op[1]);
4865 }
4866 SYNTAX("int #%1");
4867#line 993 "rx-decode.opc"
4868 ID(int); SC(IMM(1));
4869
4870 }
4871 break;
4872 case 0x70:
4873 GETBYTE ();
4874 switch (op[2] & 0xf0)
4875 {
4876 case 0x00:
4877 {
4878 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
4879#line 960 "rx-decode.opc"
4880 int immm AU = op[2] & 0x0f;
4881 if (trace)
4882 {
4883 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4884 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
4885 op[0], op[1], op[2]);
4886 printf (" immm = 0x%x\n", immm);
4887 }
4888 SYNTAX("mvtipl #%1");
4889#line 960 "rx-decode.opc"
4890 ID(mvtipl); SC(immm);
4891
4892 }
4893 break;
4894 default: UNSUPPORTED(); break;
4895 }
4896 break;
4897 default: UNSUPPORTED(); break;
4898 }
4899 break;
4900 case 0x76:
4901 GETBYTE ();
4902 switch (op[1] & 0xf0)
4903 {
4904 case 0x00:
4905 goto op_semantics_31;
4906 break;
4907 case 0x10:
4908 goto op_semantics_32;
4909 break;
4910 case 0x20:
4911 goto op_semantics_33;
4912 break;
4913 case 0x30:
4914 goto op_semantics_34;
4915 break;
4916 default: UNSUPPORTED(); break;
4917 }
4918 break;
4919 case 0x77:
4920 GETBYTE ();
4921 switch (op[1] & 0xf0)
4922 {
4923 case 0x00:
4924 goto op_semantics_31;
4925 break;
4926 case 0x10:
4927 goto op_semantics_32;
4928 break;
4929 case 0x20:
4930 goto op_semantics_33;
4931 break;
4932 case 0x30:
4933 goto op_semantics_34;
4934 break;
4935 default: UNSUPPORTED(); break;
4936 }
4937 break;
4938 case 0x78:
4939 GETBYTE ();
4940 switch (op[1] & 0x00)
4941 {
4942 case 0x00:
4943 op_semantics_35:
4944 {
4945 /** 0111 100b ittt rdst bset #%1, %0 */
4946#line 905 "rx-decode.opc"
4947 int b AU = op[0] & 0x01;
4948#line 905 "rx-decode.opc"
4949 int ittt AU = (op[1] >> 4) & 0x0f;
4950#line 905 "rx-decode.opc"
4951 int rdst AU = op[1] & 0x0f;
4952 if (trace)
4953 {
4954 printf ("\033[33m%s\033[0m %02x %02x\n",
4955 "/** 0111 100b ittt rdst bset #%1, %0 */",
4956 op[0], op[1]);
4957 printf (" b = 0x%x,", b);
4958 printf (" ittt = 0x%x,", ittt);
4959 printf (" rdst = 0x%x\n", rdst);
4960 }
4961 SYNTAX("bset #%1, %0");
4962#line 905 "rx-decode.opc"
4963 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4964
4965
4966 }
4967 break;
4968 }
4969 break;
4970 case 0x79:
4971 GETBYTE ();
4972 switch (op[1] & 0x00)
4973 {
4974 case 0x00:
4975 goto op_semantics_35;
4976 break;
4977 }
4978 break;
4979 case 0x7a:
4980 GETBYTE ();
4981 switch (op[1] & 0x00)
4982 {
4983 case 0x00:
4984 op_semantics_36:
4985 {
4986 /** 0111 101b ittt rdst bclr #%1, %0 */
4987#line 917 "rx-decode.opc"
4988 int b AU = op[0] & 0x01;
4989#line 917 "rx-decode.opc"
4990 int ittt AU = (op[1] >> 4) & 0x0f;
4991#line 917 "rx-decode.opc"
4992 int rdst AU = op[1] & 0x0f;
4993 if (trace)
4994 {
4995 printf ("\033[33m%s\033[0m %02x %02x\n",
4996 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4997 op[0], op[1]);
4998 printf (" b = 0x%x,", b);
4999 printf (" ittt = 0x%x,", ittt);
5000 printf (" rdst = 0x%x\n", rdst);
5001 }
5002 SYNTAX("bclr #%1, %0");
5003#line 917 "rx-decode.opc"
5004 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5005
5006
5007 }
5008 break;
5009 }
5010 break;
5011 case 0x7b:
5012 GETBYTE ();
5013 switch (op[1] & 0x00)
5014 {
5015 case 0x00:
5016 goto op_semantics_36;
5017 break;
5018 }
5019 break;
5020 case 0x7c:
5021 GETBYTE ();
5022 switch (op[1] & 0x00)
5023 {
5024 case 0x00:
5025 op_semantics_37:
5026 {
5027 /** 0111 110b ittt rdst btst #%2, %1 */
5028#line 929 "rx-decode.opc"
5029 int b AU = op[0] & 0x01;
5030#line 929 "rx-decode.opc"
5031 int ittt AU = (op[1] >> 4) & 0x0f;
5032#line 929 "rx-decode.opc"
5033 int rdst AU = op[1] & 0x0f;
5034 if (trace)
5035 {
5036 printf ("\033[33m%s\033[0m %02x %02x\n",
5037 "/** 0111 110b ittt rdst btst #%2, %1 */",
5038 op[0], op[1]);
5039 printf (" b = 0x%x,", b);
5040 printf (" ittt = 0x%x,", ittt);
5041 printf (" rdst = 0x%x\n", rdst);
5042 }
5043 SYNTAX("btst #%2, %1");
5044#line 929 "rx-decode.opc"
5045 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5046
5047
5048 }
5049 break;
5050 }
5051 break;
5052 case 0x7d:
5053 GETBYTE ();
5054 switch (op[1] & 0x00)
5055 {
5056 case 0x00:
5057 goto op_semantics_37;
5058 break;
5059 }
5060 break;
5061 case 0x7e:
5062 GETBYTE ();
5063 switch (op[1] & 0xf0)
5064 {
5065 case 0x00:
5066 {
5067 /** 0111 1110 0000 rdst not %0 */
5068#line 458 "rx-decode.opc"
5069 int rdst AU = op[1] & 0x0f;
5070 if (trace)
5071 {
5072 printf ("\033[33m%s\033[0m %02x %02x\n",
5073 "/** 0111 1110 0000 rdst not %0 */",
5074 op[0], op[1]);
5075 printf (" rdst = 0x%x\n", rdst);
5076 }
5077 SYNTAX("not %0");
5078#line 458 "rx-decode.opc"
5079 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5080
5081 }
5082 break;
5083 case 0x10:
5084 {
5085 /** 0111 1110 0001 rdst neg %0 */
5086#line 479 "rx-decode.opc"
5087 int rdst AU = op[1] & 0x0f;
5088 if (trace)
5089 {
5090 printf ("\033[33m%s\033[0m %02x %02x\n",
5091 "/** 0111 1110 0001 rdst neg %0 */",
5092 op[0], op[1]);
5093 printf (" rdst = 0x%x\n", rdst);
5094 }
5095 SYNTAX("neg %0");
5096#line 479 "rx-decode.opc"
5097 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5098
5099 }
5100 break;
5101 case 0x20:
5102 {
5103 /** 0111 1110 0010 rdst abs %0 */
5104#line 561 "rx-decode.opc"
5105 int rdst AU = op[1] & 0x0f;
5106 if (trace)
5107 {
5108 printf ("\033[33m%s\033[0m %02x %02x\n",
5109 "/** 0111 1110 0010 rdst abs %0 */",
5110 op[0], op[1]);
5111 printf (" rdst = 0x%x\n", rdst);
5112 }
5113 SYNTAX("abs %0");
5114#line 561 "rx-decode.opc"
5115 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5116
5117 }
5118 break;
5119 case 0x30:
5120 {
5121 /** 0111 1110 0011 rdst sat %0 */
5122#line 843 "rx-decode.opc"
5123 int rdst AU = op[1] & 0x0f;
5124 if (trace)
5125 {
5126 printf ("\033[33m%s\033[0m %02x %02x\n",
5127 "/** 0111 1110 0011 rdst sat %0 */",
5128 op[0], op[1]);
5129 printf (" rdst = 0x%x\n", rdst);
5130 }
5131 SYNTAX("sat %0");
5132#line 843 "rx-decode.opc"
5133 ID(sat); DR (rdst);
5134
5135 }
5136 break;
5137 case 0x40:
5138 {
5139 /** 0111 1110 0100 rdst rorc %0 */
5140#line 703 "rx-decode.opc"
5141 int rdst AU = op[1] & 0x0f;
5142 if (trace)
5143 {
5144 printf ("\033[33m%s\033[0m %02x %02x\n",
5145 "/** 0111 1110 0100 rdst rorc %0 */",
5146 op[0], op[1]);
5147 printf (" rdst = 0x%x\n", rdst);
5148 }
5149 SYNTAX("rorc %0");
5150#line 703 "rx-decode.opc"
5151 ID(rorc); DR(rdst); F__SZC;
5152
5153 }
5154 break;
5155 case 0x50:
5156 {
5157 /** 0111 1110 0101 rdst rolc %0 */
5158#line 700 "rx-decode.opc"
5159 int rdst AU = op[1] & 0x0f;
5160 if (trace)
5161 {
5162 printf ("\033[33m%s\033[0m %02x %02x\n",
5163 "/** 0111 1110 0101 rdst rolc %0 */",
5164 op[0], op[1]);
5165 printf (" rdst = 0x%x\n", rdst);
5166 }
5167 SYNTAX("rolc %0");
5168#line 700 "rx-decode.opc"
5169 ID(rolc); DR(rdst); F__SZC;
5170
5171 }
5172 break;
5173 case 0x80:
5174 case 0x90:
5175 case 0xa0:
5176 {
5177 /** 0111 1110 10sz rsrc push%s %1 */
5178#line 374 "rx-decode.opc"
5179 int sz AU = (op[1] >> 4) & 0x03;
5180#line 374 "rx-decode.opc"
5181 int rsrc AU = op[1] & 0x0f;
5182 if (trace)
5183 {
5184 printf ("\033[33m%s\033[0m %02x %02x\n",
5185 "/** 0111 1110 10sz rsrc push%s %1 */",
5186 op[0], op[1]);
5187 printf (" sz = 0x%x,", sz);
5188 printf (" rsrc = 0x%x\n", rsrc);
5189 }
5190 SYNTAX("push%s %1");
5191#line 374 "rx-decode.opc"
5192 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5193
5194 }
5195 break;
5196 case 0xb0:
5197 {
5198 /** 0111 1110 1011 rdst pop %0 */
5199#line 371 "rx-decode.opc"
5200 int rdst AU = op[1] & 0x0f;
5201 if (trace)
5202 {
5203 printf ("\033[33m%s\033[0m %02x %02x\n",
5204 "/** 0111 1110 1011 rdst pop %0 */",
5205 op[0], op[1]);
5206 printf (" rdst = 0x%x\n", rdst);
5207 }
5208 SYNTAX("pop %0");
5209#line 371 "rx-decode.opc"
5210 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5211
5212 }
5213 break;
5214 case 0xc0:
5215 case 0xd0:
5216 {
5217 /** 0111 1110 110 crsrc pushc %1 */
5218#line 966 "rx-decode.opc"
5219 int crsrc AU = op[1] & 0x1f;
5220 if (trace)
5221 {
5222 printf ("\033[33m%s\033[0m %02x %02x\n",
5223 "/** 0111 1110 110 crsrc pushc %1 */",
5224 op[0], op[1]);
5225 printf (" crsrc = 0x%x\n", crsrc);
5226 }
5227 SYNTAX("pushc %1");
5228#line 966 "rx-decode.opc"
5229 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5230
5231 }
5232 break;
5233 case 0xe0:
5234 case 0xf0:
5235 {
5236 /** 0111 1110 111 crdst popc %0 */
5237#line 963 "rx-decode.opc"
5238 int crdst AU = op[1] & 0x1f;
5239 if (trace)
5240 {
5241 printf ("\033[33m%s\033[0m %02x %02x\n",
5242 "/** 0111 1110 111 crdst popc %0 */",
5243 op[0], op[1]);
5244 printf (" crdst = 0x%x\n", crdst);
5245 }
5246 SYNTAX("popc %0");
5247#line 963 "rx-decode.opc"
5248 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5249
5250 }
5251 break;
5252 default: UNSUPPORTED(); break;
5253 }
5254 break;
5255 case 0x7f:
5256 GETBYTE ();
5257 switch (op[1] & 0xff)
5258 {
5259 case 0x00:
5260 case 0x01:
5261 case 0x02:
5262 case 0x03:
5263 case 0x04:
5264 case 0x05:
5265 case 0x06:
5266 case 0x07:
5267 case 0x08:
5268 case 0x09:
5269 case 0x0a:
5270 case 0x0b:
5271 case 0x0c:
5272 case 0x0d:
5273 case 0x0e:
5274 case 0x0f:
5275 {
5276 /** 0111 1111 0000 rsrc jmp %0 */
5277#line 753 "rx-decode.opc"
5278 int rsrc AU = op[1] & 0x0f;
5279 if (trace)
5280 {
5281 printf ("\033[33m%s\033[0m %02x %02x\n",
5282 "/** 0111 1111 0000 rsrc jmp %0 */",
5283 op[0], op[1]);
5284 printf (" rsrc = 0x%x\n", rsrc);
5285 }
5286 SYNTAX("jmp %0");
5287#line 753 "rx-decode.opc"
5288 ID(branch); DR(rsrc);
5289
5290 }
5291 break;
5292 case 0x10:
5293 case 0x11:
5294 case 0x12:
5295 case 0x13:
5296 case 0x14:
5297 case 0x15:
5298 case 0x16:
5299 case 0x17:
5300 case 0x18:
5301 case 0x19:
5302 case 0x1a:
5303 case 0x1b:
5304 case 0x1c:
5305 case 0x1d:
5306 case 0x1e:
5307 case 0x1f:
5308 {
5309 /** 0111 1111 0001 rsrc jsr %0 */
5310#line 756 "rx-decode.opc"
5311 int rsrc AU = op[1] & 0x0f;
5312 if (trace)
5313 {
5314 printf ("\033[33m%s\033[0m %02x %02x\n",
5315 "/** 0111 1111 0001 rsrc jsr %0 */",
5316 op[0], op[1]);
5317 printf (" rsrc = 0x%x\n", rsrc);
5318 }
5319 SYNTAX("jsr %0");
5320#line 756 "rx-decode.opc"
5321 ID(jsr); DR(rsrc);
5322
5323 }
5324 break;
5325 case 0x40:
5326 case 0x41:
5327 case 0x42:
5328 case 0x43:
5329 case 0x44:
5330 case 0x45:
5331 case 0x46:
5332 case 0x47:
5333 case 0x48:
5334 case 0x49:
5335 case 0x4a:
5336 case 0x4b:
5337 case 0x4c:
5338 case 0x4d:
5339 case 0x4e:
5340 case 0x4f:
5341 {
5342 /** 0111 1111 0100 rsrc bra.l %0 */
5343#line 749 "rx-decode.opc"
5344 int rsrc AU = op[1] & 0x0f;
5345 if (trace)
5346 {
5347 printf ("\033[33m%s\033[0m %02x %02x\n",
5348 "/** 0111 1111 0100 rsrc bra.l %0 */",
5349 op[0], op[1]);
5350 printf (" rsrc = 0x%x\n", rsrc);
5351 }
5352 SYNTAX("bra.l %0");
5353#line 749 "rx-decode.opc"
5354 ID(branchrel); DR(rsrc);
5355
5356
5357 }
5358 break;
5359 case 0x50:
5360 case 0x51:
5361 case 0x52:
5362 case 0x53:
5363 case 0x54:
5364 case 0x55:
5365 case 0x56:
5366 case 0x57:
5367 case 0x58:
5368 case 0x59:
5369 case 0x5a:
5370 case 0x5b:
5371 case 0x5c:
5372 case 0x5d:
5373 case 0x5e:
5374 case 0x5f:
5375 {
5376 /** 0111 1111 0101 rsrc bsr.l %0 */
5377#line 765 "rx-decode.opc"
5378 int rsrc AU = op[1] & 0x0f;
5379 if (trace)
5380 {
5381 printf ("\033[33m%s\033[0m %02x %02x\n",
5382 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5383 op[0], op[1]);
5384 printf (" rsrc = 0x%x\n", rsrc);
5385 }
5386 SYNTAX("bsr.l %0");
5387#line 765 "rx-decode.opc"
5388 ID(jsrrel); DR(rsrc);
5389
5390 }
5391 break;
5392 case 0x80:
5393 case 0x81:
5394 case 0x82:
5395 {
5396 /** 0111 1111 1000 00sz suntil%s */
5397#line 789 "rx-decode.opc"
5398 int sz AU = op[1] & 0x03;
5399 if (trace)
5400 {
5401 printf ("\033[33m%s\033[0m %02x %02x\n",
5402 "/** 0111 1111 1000 00sz suntil%s */",
5403 op[0], op[1]);
5404 printf (" sz = 0x%x\n", sz);
5405 }
5406 SYNTAX("suntil%s");
5407#line 789 "rx-decode.opc"
5408 ID(suntil); BWL(sz); F___ZC;
5409
5410 }
5411 break;
5412 case 0x83:
5413 {
5414 /** 0111 1111 1000 0011 scmpu */
5415 if (trace)
5416 {
5417 printf ("\033[33m%s\033[0m %02x %02x\n",
5418 "/** 0111 1111 1000 0011 scmpu */",
5419 op[0], op[1]);
5420 }
5421 SYNTAX("scmpu");
5422#line 780 "rx-decode.opc"
5423 ID(scmpu); F___ZC;
5424
5425 }
5426 break;
5427 case 0x84:
5428 case 0x85:
5429 case 0x86:
5430 {
5431 /** 0111 1111 1000 01sz swhile%s */
5432#line 792 "rx-decode.opc"
5433 int sz AU = op[1] & 0x03;
5434 if (trace)
5435 {
5436 printf ("\033[33m%s\033[0m %02x %02x\n",
5437 "/** 0111 1111 1000 01sz swhile%s */",
5438 op[0], op[1]);
5439 printf (" sz = 0x%x\n", sz);
5440 }
5441 SYNTAX("swhile%s");
5442#line 792 "rx-decode.opc"
5443 ID(swhile); BWL(sz); F___ZC;
5444
5445 }
5446 break;
5447 case 0x87:
5448 {
5449 /** 0111 1111 1000 0111 smovu */
5450 if (trace)
5451 {
5452 printf ("\033[33m%s\033[0m %02x %02x\n",
5453 "/** 0111 1111 1000 0111 smovu */",
5454 op[0], op[1]);
5455 }
5456 SYNTAX("smovu");
5457#line 783 "rx-decode.opc"
5458 ID(smovu);
5459
5460 }
5461 break;
5462 case 0x88:
5463 case 0x89:
5464 case 0x8a:
5465 {
5466 /** 0111 1111 1000 10sz sstr%s */
5467#line 798 "rx-decode.opc"
5468 int sz AU = op[1] & 0x03;
5469 if (trace)
5470 {
5471 printf ("\033[33m%s\033[0m %02x %02x\n",
5472 "/** 0111 1111 1000 10sz sstr%s */",
5473 op[0], op[1]);
5474 printf (" sz = 0x%x\n", sz);
5475 }
5476 SYNTAX("sstr%s");
5477#line 798 "rx-decode.opc"
5478 ID(sstr); BWL(sz);
5479
5480 /*----------------------------------------------------------------------*/
5481 /* RMPA */
5482
5483 }
5484 break;
5485 case 0x8b:
5486 {
5487 /** 0111 1111 1000 1011 smovb */
5488 if (trace)
5489 {
5490 printf ("\033[33m%s\033[0m %02x %02x\n",
5491 "/** 0111 1111 1000 1011 smovb */",
5492 op[0], op[1]);
5493 }
5494 SYNTAX("smovb");
5495#line 786 "rx-decode.opc"
5496 ID(smovb);
5497
5498 }
5499 break;
5500 case 0x8c:
5501 case 0x8d:
5502 case 0x8e:
5503 {
5504 /** 0111 1111 1000 11sz rmpa%s */
5505#line 804 "rx-decode.opc"
5506 int sz AU = op[1] & 0x03;
5507 if (trace)
5508 {
5509 printf ("\033[33m%s\033[0m %02x %02x\n",
5510 "/** 0111 1111 1000 11sz rmpa%s */",
5511 op[0], op[1]);
5512 printf (" sz = 0x%x\n", sz);
5513 }
5514 SYNTAX("rmpa%s");
5515#line 804 "rx-decode.opc"
5516 ID(rmpa); BWL(sz); F_OS__;
5517
5518 /*----------------------------------------------------------------------*/
5519 /* HI/LO stuff */
5520
5521 }
5522 break;
5523 case 0x8f:
5524 {
5525 /** 0111 1111 1000 1111 smovf */
5526 if (trace)
5527 {
5528 printf ("\033[33m%s\033[0m %02x %02x\n",
5529 "/** 0111 1111 1000 1111 smovf */",
5530 op[0], op[1]);
5531 }
5532 SYNTAX("smovf");
5533#line 795 "rx-decode.opc"
5534 ID(smovf);
5535
5536 }
5537 break;
5538 case 0x93:
5539 {
5540 /** 0111 1111 1001 0011 satr */
5541 if (trace)
5542 {
5543 printf ("\033[33m%s\033[0m %02x %02x\n",
5544 "/** 0111 1111 1001 0011 satr */",
5545 op[0], op[1]);
5546 }
5547 SYNTAX("satr");
5548#line 846 "rx-decode.opc"
5549 ID(satr);
5550
5551 /*----------------------------------------------------------------------*/
5552 /* FLOAT */
5553
5554 }
5555 break;
5556 case 0x94:
5557 {
5558 /** 0111 1111 1001 0100 rtfi */
5559 if (trace)
5560 {
5561 printf ("\033[33m%s\033[0m %02x %02x\n",
5562 "/** 0111 1111 1001 0100 rtfi */",
5563 op[0], op[1]);
5564 }
5565 SYNTAX("rtfi");
5566#line 981 "rx-decode.opc"
5567 ID(rtfi);
5568
5569 }
5570 break;
5571 case 0x95:
5572 {
5573 /** 0111 1111 1001 0101 rte */
5574 if (trace)
5575 {
5576 printf ("\033[33m%s\033[0m %02x %02x\n",
5577 "/** 0111 1111 1001 0101 rte */",
5578 op[0], op[1]);
5579 }
5580 SYNTAX("rte");
5581#line 984 "rx-decode.opc"
5582 ID(rte);
5583
5584 }
5585 break;
5586 case 0x96:
5587 {
5588 /** 0111 1111 1001 0110 wait */
5589 if (trace)
5590 {
5591 printf ("\033[33m%s\033[0m %02x %02x\n",
5592 "/** 0111 1111 1001 0110 wait */",
5593 op[0], op[1]);
5594 }
5595 SYNTAX("wait");
5596#line 996 "rx-decode.opc"
5597 ID(wait);
5598
5599 /*----------------------------------------------------------------------*/
5600 /* SCcnd */
5601
5602 }
5603 break;
5604 case 0xa0:
5605 case 0xa1:
5606 case 0xa2:
5607 case 0xa3:
5608 case 0xa4:
5609 case 0xa5:
5610 case 0xa6:
5611 case 0xa7:
5612 case 0xa8:
5613 case 0xa9:
5614 case 0xaa:
5615 case 0xab:
5616 case 0xac:
5617 case 0xad:
5618 case 0xae:
5619 case 0xaf:
5620 {
5621 /** 0111 1111 1010 rdst setpsw %0 */
5622#line 957 "rx-decode.opc"
5623 int rdst AU = op[1] & 0x0f;
5624 if (trace)
5625 {
5626 printf ("\033[33m%s\033[0m %02x %02x\n",
5627 "/** 0111 1111 1010 rdst setpsw %0 */",
5628 op[0], op[1]);
5629 printf (" rdst = 0x%x\n", rdst);
5630 }
5631 SYNTAX("setpsw %0");
5632#line 957 "rx-decode.opc"
5633 ID(setpsw); DF(rdst);
5634
5635 }
5636 break;
5637 case 0xb0:
5638 case 0xb1:
5639 case 0xb2:
5640 case 0xb3:
5641 case 0xb4:
5642 case 0xb5:
5643 case 0xb6:
5644 case 0xb7:
5645 case 0xb8:
5646 case 0xb9:
5647 case 0xba:
5648 case 0xbb:
5649 case 0xbc:
5650 case 0xbd:
5651 case 0xbe:
5652 case 0xbf:
5653 {
5654 /** 0111 1111 1011 rdst clrpsw %0 */
5655#line 954 "rx-decode.opc"
5656 int rdst AU = op[1] & 0x0f;
5657 if (trace)
5658 {
5659 printf ("\033[33m%s\033[0m %02x %02x\n",
5660 "/** 0111 1111 1011 rdst clrpsw %0 */",
5661 op[0], op[1]);
5662 printf (" rdst = 0x%x\n", rdst);
5663 }
5664 SYNTAX("clrpsw %0");
5665#line 954 "rx-decode.opc"
5666 ID(clrpsw); DF(rdst);
5667
5668 }
5669 break;
5670 default: UNSUPPORTED(); break;
5671 }
5672 break;
5673 case 0x80:
5674 GETBYTE ();
5675 switch (op[1] & 0x00)
5676 {
5677 case 0x00:
5678 op_semantics_38:
5679 {
5680 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5681#line 332 "rx-decode.opc"
5682 int sz AU = (op[0] >> 4) & 0x03;
5683#line 332 "rx-decode.opc"
5684 int dsp AU = op[0] & 0x07;
5685#line 332 "rx-decode.opc"
5686 int a AU = (op[1] >> 7) & 0x01;
5687#line 332 "rx-decode.opc"
5688 int dst AU = (op[1] >> 4) & 0x07;
5689#line 332 "rx-decode.opc"
5690 int b AU = (op[1] >> 3) & 0x01;
5691#line 332 "rx-decode.opc"
5692 int src AU = op[1] & 0x07;
5693 if (trace)
5694 {
5695 printf ("\033[33m%s\033[0m %02x %02x\n",
5696 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5697 op[0], op[1]);
5698 printf (" sz = 0x%x,", sz);
5699 printf (" dsp = 0x%x,", dsp);
5700 printf (" a = 0x%x,", a);
5701 printf (" dst = 0x%x,", dst);
5702 printf (" b = 0x%x,", b);
5703 printf (" src = 0x%x\n", src);
5704 }
5705 SYNTAX("mov%s %1, %0");
5706#line 332 "rx-decode.opc"
5707 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5708
5709 }
5710 break;
5711 }
5712 break;
5713 case 0x81:
5714 GETBYTE ();
5715 switch (op[1] & 0x00)
5716 {
5717 case 0x00:
5718 goto op_semantics_38;
5719 break;
5720 }
5721 break;
5722 case 0x82:
5723 GETBYTE ();
5724 switch (op[1] & 0x00)
5725 {
5726 case 0x00:
5727 goto op_semantics_38;
5728 break;
5729 }
5730 break;
5731 case 0x83:
5732 GETBYTE ();
5733 switch (op[1] & 0x00)
5734 {
5735 case 0x00:
5736 goto op_semantics_38;
5737 break;
5738 }
5739 break;
5740 case 0x84:
5741 GETBYTE ();
5742 switch (op[1] & 0x00)
5743 {
5744 case 0x00:
5745 goto op_semantics_38;
5746 break;
5747 }
5748 break;
5749 case 0x85:
5750 GETBYTE ();
5751 switch (op[1] & 0x00)
5752 {
5753 case 0x00:
5754 goto op_semantics_38;
5755 break;
5756 }
5757 break;
5758 case 0x86:
5759 GETBYTE ();
5760 switch (op[1] & 0x00)
5761 {
5762 case 0x00:
5763 goto op_semantics_38;
5764 break;
5765 }
5766 break;
5767 case 0x87:
5768 GETBYTE ();
5769 switch (op[1] & 0x00)
5770 {
5771 case 0x00:
5772 goto op_semantics_38;
5773 break;
5774 }
5775 break;
5776 case 0x88:
5777 GETBYTE ();
5778 switch (op[1] & 0x00)
5779 {
5780 case 0x00:
5781 op_semantics_39:
5782 {
5783 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5784#line 329 "rx-decode.opc"
5785 int sz AU = (op[0] >> 4) & 0x03;
5786#line 329 "rx-decode.opc"
5787 int dsp AU = op[0] & 0x07;
5788#line 329 "rx-decode.opc"
5789 int a AU = (op[1] >> 7) & 0x01;
5790#line 329 "rx-decode.opc"
5791 int src AU = (op[1] >> 4) & 0x07;
5792#line 329 "rx-decode.opc"
5793 int b AU = (op[1] >> 3) & 0x01;
5794#line 329 "rx-decode.opc"
5795 int dst AU = op[1] & 0x07;
5796 if (trace)
5797 {
5798 printf ("\033[33m%s\033[0m %02x %02x\n",
5799 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5800 op[0], op[1]);
5801 printf (" sz = 0x%x,", sz);
5802 printf (" dsp = 0x%x,", dsp);
5803 printf (" a = 0x%x,", a);
5804 printf (" src = 0x%x,", src);
5805 printf (" b = 0x%x,", b);
5806 printf (" dst = 0x%x\n", dst);
5807 }
5808 SYNTAX("mov%s %1, %0");
5809#line 329 "rx-decode.opc"
5810 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5811
5812 }
5813 break;
5814 }
5815 break;
5816 case 0x89:
5817 GETBYTE ();
5818 switch (op[1] & 0x00)
5819 {
5820 case 0x00:
5821 goto op_semantics_39;
5822 break;
5823 }
5824 break;
5825 case 0x8a:
5826 GETBYTE ();
5827 switch (op[1] & 0x00)
5828 {
5829 case 0x00:
5830 goto op_semantics_39;
5831 break;
5832 }
5833 break;
5834 case 0x8b:
5835 GETBYTE ();
5836 switch (op[1] & 0x00)
5837 {
5838 case 0x00:
5839 goto op_semantics_39;
5840 break;
5841 }
5842 break;
5843 case 0x8c:
5844 GETBYTE ();
5845 switch (op[1] & 0x00)
5846 {
5847 case 0x00:
5848 goto op_semantics_39;
5849 break;
5850 }
5851 break;
5852 case 0x8d:
5853 GETBYTE ();
5854 switch (op[1] & 0x00)
5855 {
5856 case 0x00:
5857 goto op_semantics_39;
5858 break;
5859 }
5860 break;
5861 case 0x8e:
5862 GETBYTE ();
5863 switch (op[1] & 0x00)
5864 {
5865 case 0x00:
5866 goto op_semantics_39;
5867 break;
5868 }
5869 break;
5870 case 0x8f:
5871 GETBYTE ();
5872 switch (op[1] & 0x00)
5873 {
5874 case 0x00:
5875 goto op_semantics_39;
5876 break;
5877 }
5878 break;
5879 case 0x90:
5880 GETBYTE ();
5881 switch (op[1] & 0x00)
5882 {
5883 case 0x00:
5884 goto op_semantics_38;
5885 break;
5886 }
5887 break;
5888 case 0x91:
5889 GETBYTE ();
5890 switch (op[1] & 0x00)
5891 {
5892 case 0x00:
5893 goto op_semantics_38;
5894 break;
5895 }
5896 break;
5897 case 0x92:
5898 GETBYTE ();
5899 switch (op[1] & 0x00)
5900 {
5901 case 0x00:
5902 goto op_semantics_38;
5903 break;
5904 }
5905 break;
5906 case 0x93:
5907 GETBYTE ();
5908 switch (op[1] & 0x00)
5909 {
5910 case 0x00:
5911 goto op_semantics_38;
5912 break;
5913 }
5914 break;
5915 case 0x94:
5916 GETBYTE ();
5917 switch (op[1] & 0x00)
5918 {
5919 case 0x00:
5920 goto op_semantics_38;
5921 break;
5922 }
5923 break;
5924 case 0x95:
5925 GETBYTE ();
5926 switch (op[1] & 0x00)
5927 {
5928 case 0x00:
5929 goto op_semantics_38;
5930 break;
5931 }
5932 break;
5933 case 0x96:
5934 GETBYTE ();
5935 switch (op[1] & 0x00)
5936 {
5937 case 0x00:
5938 goto op_semantics_38;
5939 break;
5940 }
5941 break;
5942 case 0x97:
5943 GETBYTE ();
5944 switch (op[1] & 0x00)
5945 {
5946 case 0x00:
5947 goto op_semantics_38;
5948 break;
5949 }
5950 break;
5951 case 0x98:
5952 GETBYTE ();
5953 switch (op[1] & 0x00)
5954 {
5955 case 0x00:
5956 goto op_semantics_39;
5957 break;
5958 }
5959 break;
5960 case 0x99:
5961 GETBYTE ();
5962 switch (op[1] & 0x00)
5963 {
5964 case 0x00:
5965 goto op_semantics_39;
5966 break;
5967 }
5968 break;
5969 case 0x9a:
5970 GETBYTE ();
5971 switch (op[1] & 0x00)
5972 {
5973 case 0x00:
5974 goto op_semantics_39;
5975 break;
5976 }
5977 break;
5978 case 0x9b:
5979 GETBYTE ();
5980 switch (op[1] & 0x00)
5981 {
5982 case 0x00:
5983 goto op_semantics_39;
5984 break;
5985 }
5986 break;
5987 case 0x9c:
5988 GETBYTE ();
5989 switch (op[1] & 0x00)
5990 {
5991 case 0x00:
5992 goto op_semantics_39;
5993 break;
5994 }
5995 break;
5996 case 0x9d:
5997 GETBYTE ();
5998 switch (op[1] & 0x00)
5999 {
6000 case 0x00:
6001 goto op_semantics_39;
6002 break;
6003 }
6004 break;
6005 case 0x9e:
6006 GETBYTE ();
6007 switch (op[1] & 0x00)
6008 {
6009 case 0x00:
6010 goto op_semantics_39;
6011 break;
6012 }
6013 break;
6014 case 0x9f:
6015 GETBYTE ();
6016 switch (op[1] & 0x00)
6017 {
6018 case 0x00:
6019 goto op_semantics_39;
6020 break;
6021 }
6022 break;
6023 case 0xa0:
6024 GETBYTE ();
6025 switch (op[1] & 0x00)
6026 {
6027 case 0x00:
6028 goto op_semantics_38;
6029 break;
6030 }
6031 break;
6032 case 0xa1:
6033 GETBYTE ();
6034 switch (op[1] & 0x00)
6035 {
6036 case 0x00:
6037 goto op_semantics_38;
6038 break;
6039 }
6040 break;
6041 case 0xa2:
6042 GETBYTE ();
6043 switch (op[1] & 0x00)
6044 {
6045 case 0x00:
6046 goto op_semantics_38;
6047 break;
6048 }
6049 break;
6050 case 0xa3:
6051 GETBYTE ();
6052 switch (op[1] & 0x00)
6053 {
6054 case 0x00:
6055 goto op_semantics_38;
6056 break;
6057 }
6058 break;
6059 case 0xa4:
6060 GETBYTE ();
6061 switch (op[1] & 0x00)
6062 {
6063 case 0x00:
6064 goto op_semantics_38;
6065 break;
6066 }
6067 break;
6068 case 0xa5:
6069 GETBYTE ();
6070 switch (op[1] & 0x00)
6071 {
6072 case 0x00:
6073 goto op_semantics_38;
6074 break;
6075 }
6076 break;
6077 case 0xa6:
6078 GETBYTE ();
6079 switch (op[1] & 0x00)
6080 {
6081 case 0x00:
6082 goto op_semantics_38;
6083 break;
6084 }
6085 break;
6086 case 0xa7:
6087 GETBYTE ();
6088 switch (op[1] & 0x00)
6089 {
6090 case 0x00:
6091 goto op_semantics_38;
6092 break;
6093 }
6094 break;
6095 case 0xa8:
6096 GETBYTE ();
6097 switch (op[1] & 0x00)
6098 {
6099 case 0x00:
6100 goto op_semantics_39;
6101 break;
6102 }
6103 break;
6104 case 0xa9:
6105 GETBYTE ();
6106 switch (op[1] & 0x00)
6107 {
6108 case 0x00:
6109 goto op_semantics_39;
6110 break;
6111 }
6112 break;
6113 case 0xaa:
6114 GETBYTE ();
6115 switch (op[1] & 0x00)
6116 {
6117 case 0x00:
6118 goto op_semantics_39;
6119 break;
6120 }
6121 break;
6122 case 0xab:
6123 GETBYTE ();
6124 switch (op[1] & 0x00)
6125 {
6126 case 0x00:
6127 goto op_semantics_39;
6128 break;
6129 }
6130 break;
6131 case 0xac:
6132 GETBYTE ();
6133 switch (op[1] & 0x00)
6134 {
6135 case 0x00:
6136 goto op_semantics_39;
6137 break;
6138 }
6139 break;
6140 case 0xad:
6141 GETBYTE ();
6142 switch (op[1] & 0x00)
6143 {
6144 case 0x00:
6145 goto op_semantics_39;
6146 break;
6147 }
6148 break;
6149 case 0xae:
6150 GETBYTE ();
6151 switch (op[1] & 0x00)
6152 {
6153 case 0x00:
6154 goto op_semantics_39;
6155 break;
6156 }
6157 break;
6158 case 0xaf:
6159 GETBYTE ();
6160 switch (op[1] & 0x00)
6161 {
6162 case 0x00:
6163 goto op_semantics_39;
6164 break;
6165 }
6166 break;
6167 case 0xb0:
6168 GETBYTE ();
6169 switch (op[1] & 0x00)
6170 {
6171 case 0x00:
6172 op_semantics_40:
6173 {
6174 /** 1011 w dsp a src b dst movu%s %1, %0 */
6175#line 352 "rx-decode.opc"
6176 int w AU = (op[0] >> 3) & 0x01;
6177#line 352 "rx-decode.opc"
6178 int dsp AU = op[0] & 0x07;
6179#line 352 "rx-decode.opc"
6180 int a AU = (op[1] >> 7) & 0x01;
6181#line 352 "rx-decode.opc"
6182 int src AU = (op[1] >> 4) & 0x07;
6183#line 352 "rx-decode.opc"
6184 int b AU = (op[1] >> 3) & 0x01;
6185#line 352 "rx-decode.opc"
6186 int dst AU = op[1] & 0x07;
6187 if (trace)
6188 {
6189 printf ("\033[33m%s\033[0m %02x %02x\n",
6190 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6191 op[0], op[1]);
6192 printf (" w = 0x%x,", w);
6193 printf (" dsp = 0x%x,", dsp);
6194 printf (" a = 0x%x,", a);
6195 printf (" src = 0x%x,", src);
6196 printf (" b = 0x%x,", b);
6197 printf (" dst = 0x%x\n", dst);
6198 }
6199 SYNTAX("movu%s %1, %0");
6200#line 352 "rx-decode.opc"
6201 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6202
6203 }
6204 break;
6205 }
6206 break;
6207 case 0xb1:
6208 GETBYTE ();
6209 switch (op[1] & 0x00)
6210 {
6211 case 0x00:
6212 goto op_semantics_40;
6213 break;
6214 }
6215 break;
6216 case 0xb2:
6217 GETBYTE ();
6218 switch (op[1] & 0x00)
6219 {
6220 case 0x00:
6221 goto op_semantics_40;
6222 break;
6223 }
6224 break;
6225 case 0xb3:
6226 GETBYTE ();
6227 switch (op[1] & 0x00)
6228 {
6229 case 0x00:
6230 goto op_semantics_40;
6231 break;
6232 }
6233 break;
6234 case 0xb4:
6235 GETBYTE ();
6236 switch (op[1] & 0x00)
6237 {
6238 case 0x00:
6239 goto op_semantics_40;
6240 break;
6241 }
6242 break;
6243 case 0xb5:
6244 GETBYTE ();
6245 switch (op[1] & 0x00)
6246 {
6247 case 0x00:
6248 goto op_semantics_40;
6249 break;
6250 }
6251 break;
6252 case 0xb6:
6253 GETBYTE ();
6254 switch (op[1] & 0x00)
6255 {
6256 case 0x00:
6257 goto op_semantics_40;
6258 break;
6259 }
6260 break;
6261 case 0xb7:
6262 GETBYTE ();
6263 switch (op[1] & 0x00)
6264 {
6265 case 0x00:
6266 goto op_semantics_40;
6267 break;
6268 }
6269 break;
6270 case 0xb8:
6271 GETBYTE ();
6272 switch (op[1] & 0x00)
6273 {
6274 case 0x00:
6275 goto op_semantics_40;
6276 break;
6277 }
6278 break;
6279 case 0xb9:
6280 GETBYTE ();
6281 switch (op[1] & 0x00)
6282 {
6283 case 0x00:
6284 goto op_semantics_40;
6285 break;
6286 }
6287 break;
6288 case 0xba:
6289 GETBYTE ();
6290 switch (op[1] & 0x00)
6291 {
6292 case 0x00:
6293 goto op_semantics_40;
6294 break;
6295 }
6296 break;
6297 case 0xbb:
6298 GETBYTE ();
6299 switch (op[1] & 0x00)
6300 {
6301 case 0x00:
6302 goto op_semantics_40;
6303 break;
6304 }
6305 break;
6306 case 0xbc:
6307 GETBYTE ();
6308 switch (op[1] & 0x00)
6309 {
6310 case 0x00:
6311 goto op_semantics_40;
6312 break;
6313 }
6314 break;
6315 case 0xbd:
6316 GETBYTE ();
6317 switch (op[1] & 0x00)
6318 {
6319 case 0x00:
6320 goto op_semantics_40;
6321 break;
6322 }
6323 break;
6324 case 0xbe:
6325 GETBYTE ();
6326 switch (op[1] & 0x00)
6327 {
6328 case 0x00:
6329 goto op_semantics_40;
6330 break;
6331 }
6332 break;
6333 case 0xbf:
6334 GETBYTE ();
6335 switch (op[1] & 0x00)
6336 {
6337 case 0x00:
6338 goto op_semantics_40;
6339 break;
6340 }
6341 break;
6342 case 0xc0:
6343 GETBYTE ();
6344 switch (op[1] & 0x00)
6345 {
6346 case 0x00:
6347 op_semantics_41:
6348 {
6349 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6350#line 310 "rx-decode.opc"
6351 int sz AU = (op[0] >> 4) & 0x03;
6352#line 310 "rx-decode.opc"
6353 int sd AU = (op[0] >> 2) & 0x03;
6354#line 310 "rx-decode.opc"
6355 int ss AU = op[0] & 0x03;
6356#line 310 "rx-decode.opc"
6357 int rsrc AU = (op[1] >> 4) & 0x0f;
6358#line 310 "rx-decode.opc"
6359 int rdst AU = op[1] & 0x0f;
6360 if (trace)
6361 {
6362 printf ("\033[33m%s\033[0m %02x %02x\n",
6363 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6364 op[0], op[1]);
6365 printf (" sz = 0x%x,", sz);
6366 printf (" sd = 0x%x,", sd);
6367 printf (" ss = 0x%x,", ss);
6368 printf (" rsrc = 0x%x,", rsrc);
6369 printf (" rdst = 0x%x\n", rdst);
6370 }
6371 SYNTAX("mov%s %1, %0");
6372#line 310 "rx-decode.opc"
6373 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6374 {
6375 ID(nop2);
6376 SYNTAX ("nop\t; mov.l\tr0, r0");
6377 }
6378 else
6379 {
6380 ID(mov); sBWL(sz); F_____;
6381 if ((ss == 3) && (sd != 3))
6382 {
6383 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6384 }
6385 else
6386 {
6387 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6388 }
6389 }
6390
6391 }
6392 break;
6393 }
6394 break;
6395 case 0xc1:
6396 GETBYTE ();
6397 switch (op[1] & 0x00)
6398 {
6399 case 0x00:
6400 goto op_semantics_41;
6401 break;
6402 }
6403 break;
6404 case 0xc2:
6405 GETBYTE ();
6406 switch (op[1] & 0x00)
6407 {
6408 case 0x00:
6409 goto op_semantics_41;
6410 break;
6411 }
6412 break;
6413 case 0xc3:
6414 GETBYTE ();
6415 switch (op[1] & 0x00)
6416 {
6417 case 0x00:
6418 goto op_semantics_41;
6419 break;
6420 }
6421 break;
6422 case 0xc4:
6423 GETBYTE ();
6424 switch (op[1] & 0x00)
6425 {
6426 case 0x00:
6427 goto op_semantics_41;
6428 break;
6429 }
6430 break;
6431 case 0xc5:
6432 GETBYTE ();
6433 switch (op[1] & 0x00)
6434 {
6435 case 0x00:
6436 goto op_semantics_41;
6437 break;
6438 }
6439 break;
6440 case 0xc6:
6441 GETBYTE ();
6442 switch (op[1] & 0x00)
6443 {
6444 case 0x00:
6445 goto op_semantics_41;
6446 break;
6447 }
6448 break;
6449 case 0xc7:
6450 GETBYTE ();
6451 switch (op[1] & 0x00)
6452 {
6453 case 0x00:
6454 goto op_semantics_41;
6455 break;
6456 }
6457 break;
6458 case 0xc8:
6459 GETBYTE ();
6460 switch (op[1] & 0x00)
6461 {
6462 case 0x00:
6463 goto op_semantics_41;
6464 break;
6465 }
6466 break;
6467 case 0xc9:
6468 GETBYTE ();
6469 switch (op[1] & 0x00)
6470 {
6471 case 0x00:
6472 goto op_semantics_41;
6473 break;
6474 }
6475 break;
6476 case 0xca:
6477 GETBYTE ();
6478 switch (op[1] & 0x00)
6479 {
6480 case 0x00:
6481 goto op_semantics_41;
6482 break;
6483 }
6484 break;
6485 case 0xcb:
6486 GETBYTE ();
6487 switch (op[1] & 0x00)
6488 {
6489 case 0x00:
6490 goto op_semantics_41;
6491 break;
6492 }
6493 break;
6494 case 0xcc:
6495 GETBYTE ();
6496 switch (op[1] & 0x00)
6497 {
6498 case 0x00:
6499 goto op_semantics_41;
6500 break;
6501 }
6502 break;
6503 case 0xcd:
6504 GETBYTE ();
6505 switch (op[1] & 0x00)
6506 {
6507 case 0x00:
6508 goto op_semantics_41;
6509 break;
6510 }
6511 break;
6512 case 0xce:
6513 GETBYTE ();
6514 switch (op[1] & 0x00)
6515 {
6516 case 0x00:
6517 goto op_semantics_41;
6518 break;
6519 }
6520 break;
6521 case 0xcf:
6522 GETBYTE ();
6523 switch (op[1] & 0x00)
6524 {
6525 case 0x00:
6526 goto op_semantics_41;
6527 break;
6528 }
6529 break;
6530 case 0xd0:
6531 GETBYTE ();
6532 switch (op[1] & 0x00)
6533 {
6534 case 0x00:
6535 goto op_semantics_41;
6536 break;
6537 }
6538 break;
6539 case 0xd1:
6540 GETBYTE ();
6541 switch (op[1] & 0x00)
6542 {
6543 case 0x00:
6544 goto op_semantics_41;
6545 break;
6546 }
6547 break;
6548 case 0xd2:
6549 GETBYTE ();
6550 switch (op[1] & 0x00)
6551 {
6552 case 0x00:
6553 goto op_semantics_41;
6554 break;
6555 }
6556 break;
6557 case 0xd3:
6558 GETBYTE ();
6559 switch (op[1] & 0x00)
6560 {
6561 case 0x00:
6562 goto op_semantics_41;
6563 break;
6564 }
6565 break;
6566 case 0xd4:
6567 GETBYTE ();
6568 switch (op[1] & 0x00)
6569 {
6570 case 0x00:
6571 goto op_semantics_41;
6572 break;
6573 }
6574 break;
6575 case 0xd5:
6576 GETBYTE ();
6577 switch (op[1] & 0x00)
6578 {
6579 case 0x00:
6580 goto op_semantics_41;
6581 break;
6582 }
6583 break;
6584 case 0xd6:
6585 GETBYTE ();
6586 switch (op[1] & 0x00)
6587 {
6588 case 0x00:
6589 goto op_semantics_41;
6590 break;
6591 }
6592 break;
6593 case 0xd7:
6594 GETBYTE ();
6595 switch (op[1] & 0x00)
6596 {
6597 case 0x00:
6598 goto op_semantics_41;
6599 break;
6600 }
6601 break;
6602 case 0xd8:
6603 GETBYTE ();
6604 switch (op[1] & 0x00)
6605 {
6606 case 0x00:
6607 goto op_semantics_41;
6608 break;
6609 }
6610 break;
6611 case 0xd9:
6612 GETBYTE ();
6613 switch (op[1] & 0x00)
6614 {
6615 case 0x00:
6616 goto op_semantics_41;
6617 break;
6618 }
6619 break;
6620 case 0xda:
6621 GETBYTE ();
6622 switch (op[1] & 0x00)
6623 {
6624 case 0x00:
6625 goto op_semantics_41;
6626 break;
6627 }
6628 break;
6629 case 0xdb:
6630 GETBYTE ();
6631 switch (op[1] & 0x00)
6632 {
6633 case 0x00:
6634 goto op_semantics_41;
6635 break;
6636 }
6637 break;
6638 case 0xdc:
6639 GETBYTE ();
6640 switch (op[1] & 0x00)
6641 {
6642 case 0x00:
6643 goto op_semantics_41;
6644 break;
6645 }
6646 break;
6647 case 0xdd:
6648 GETBYTE ();
6649 switch (op[1] & 0x00)
6650 {
6651 case 0x00:
6652 goto op_semantics_41;
6653 break;
6654 }
6655 break;
6656 case 0xde:
6657 GETBYTE ();
6658 switch (op[1] & 0x00)
6659 {
6660 case 0x00:
6661 goto op_semantics_41;
6662 break;
6663 }
6664 break;
6665 case 0xdf:
6666 GETBYTE ();
6667 switch (op[1] & 0x00)
6668 {
6669 case 0x00:
6670 goto op_semantics_41;
6671 break;
6672 }
6673 break;
6674 case 0xe0:
6675 GETBYTE ();
6676 switch (op[1] & 0x00)
6677 {
6678 case 0x00:
6679 goto op_semantics_41;
6680 break;
6681 }
6682 break;
6683 case 0xe1:
6684 GETBYTE ();
6685 switch (op[1] & 0x00)
6686 {
6687 case 0x00:
6688 goto op_semantics_41;
6689 break;
6690 }
6691 break;
6692 case 0xe2:
6693 GETBYTE ();
6694 switch (op[1] & 0x00)
6695 {
6696 case 0x00:
6697 goto op_semantics_41;
6698 break;
6699 }
6700 break;
6701 case 0xe3:
6702 GETBYTE ();
6703 switch (op[1] & 0x00)
6704 {
6705 case 0x00:
6706 goto op_semantics_41;
6707 break;
6708 }
6709 break;
6710 case 0xe4:
6711 GETBYTE ();
6712 switch (op[1] & 0x00)
6713 {
6714 case 0x00:
6715 goto op_semantics_41;
6716 break;
6717 }
6718 break;
6719 case 0xe5:
6720 GETBYTE ();
6721 switch (op[1] & 0x00)
6722 {
6723 case 0x00:
6724 goto op_semantics_41;
6725 break;
6726 }
6727 break;
6728 case 0xe6:
6729 GETBYTE ();
6730 switch (op[1] & 0x00)
6731 {
6732 case 0x00:
6733 goto op_semantics_41;
6734 break;
6735 }
6736 break;
6737 case 0xe7:
6738 GETBYTE ();
6739 switch (op[1] & 0x00)
6740 {
6741 case 0x00:
6742 goto op_semantics_41;
6743 break;
6744 }
6745 break;
6746 case 0xe8:
6747 GETBYTE ();
6748 switch (op[1] & 0x00)
6749 {
6750 case 0x00:
6751 goto op_semantics_41;
6752 break;
6753 }
6754 break;
6755 case 0xe9:
6756 GETBYTE ();
6757 switch (op[1] & 0x00)
6758 {
6759 case 0x00:
6760 goto op_semantics_41;
6761 break;
6762 }
6763 break;
6764 case 0xea:
6765 GETBYTE ();
6766 switch (op[1] & 0x00)
6767 {
6768 case 0x00:
6769 goto op_semantics_41;
6770 break;
6771 }
6772 break;
6773 case 0xeb:
6774 GETBYTE ();
6775 switch (op[1] & 0x00)
6776 {
6777 case 0x00:
6778 goto op_semantics_41;
6779 break;
6780 }
6781 break;
6782 case 0xec:
6783 GETBYTE ();
6784 switch (op[1] & 0x00)
6785 {
6786 case 0x00:
6787 goto op_semantics_41;
6788 break;
6789 }
6790 break;
6791 case 0xed:
6792 GETBYTE ();
6793 switch (op[1] & 0x00)
6794 {
6795 case 0x00:
6796 goto op_semantics_41;
6797 break;
6798 }
6799 break;
6800 case 0xee:
6801 GETBYTE ();
6802 switch (op[1] & 0x00)
6803 {
6804 case 0x00:
6805 goto op_semantics_41;
6806 break;
6807 }
6808 break;
6809 case 0xef:
6810 GETBYTE ();
6811 switch (op[1] & 0x00)
6812 {
6813 case 0x00:
6814 goto op_semantics_41;
6815 break;
6816 }
6817 break;
6818 case 0xf0:
6819 GETBYTE ();
6820 switch (op[1] & 0x08)
6821 {
6822 case 0x00:
6823 op_semantics_42:
6824 {
6825 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
6826#line 897 "rx-decode.opc"
6827 int sd AU = op[0] & 0x03;
6828#line 897 "rx-decode.opc"
6829 int rdst AU = (op[1] >> 4) & 0x0f;
6830#line 897 "rx-decode.opc"
6831 int bit AU = op[1] & 0x07;
6832 if (trace)
6833 {
6834 printf ("\033[33m%s\033[0m %02x %02x\n",
6835 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6836 op[0], op[1]);
6837 printf (" sd = 0x%x,", sd);
6838 printf (" rdst = 0x%x,", rdst);
6839 printf (" bit = 0x%x\n", bit);
6840 }
6841 SYNTAX("bset #%1, %0%S0");
6842#line 897 "rx-decode.opc"
6843 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6844
6845 }
6846 break;
6847 case 0x08:
6848 op_semantics_43:
6849 {
6850 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
6851#line 909 "rx-decode.opc"
6852 int sd AU = op[0] & 0x03;
6853#line 909 "rx-decode.opc"
6854 int rdst AU = (op[1] >> 4) & 0x0f;
6855#line 909 "rx-decode.opc"
6856 int bit AU = op[1] & 0x07;
6857 if (trace)
6858 {
6859 printf ("\033[33m%s\033[0m %02x %02x\n",
6860 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6861 op[0], op[1]);
6862 printf (" sd = 0x%x,", sd);
6863 printf (" rdst = 0x%x,", rdst);
6864 printf (" bit = 0x%x\n", bit);
6865 }
6866 SYNTAX("bclr #%1, %0%S0");
6867#line 909 "rx-decode.opc"
6868 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6869
6870 }
6871 break;
6872 }
6873 break;
6874 case 0xf1:
6875 GETBYTE ();
6876 switch (op[1] & 0x08)
6877 {
6878 case 0x00:
6879 goto op_semantics_42;
6880 break;
6881 case 0x08:
6882 goto op_semantics_43;
6883 break;
6884 }
6885 break;
6886 case 0xf2:
6887 GETBYTE ();
6888 switch (op[1] & 0x08)
6889 {
6890 case 0x00:
6891 goto op_semantics_42;
6892 break;
6893 case 0x08:
6894 goto op_semantics_43;
6895 break;
6896 }
6897 break;
6898 case 0xf3:
6899 GETBYTE ();
6900 switch (op[1] & 0x08)
6901 {
6902 case 0x00:
6903 goto op_semantics_42;
6904 break;
6905 case 0x08:
6906 goto op_semantics_43;
6907 break;
6908 }
6909 break;
6910 case 0xf4:
6911 GETBYTE ();
6912 switch (op[1] & 0x0c)
6913 {
6914 case 0x00:
6915 case 0x04:
6916 op_semantics_44:
6917 {
6918 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
6919#line 921 "rx-decode.opc"
6920 int sd AU = op[0] & 0x03;
6921#line 921 "rx-decode.opc"
6922 int rdst AU = (op[1] >> 4) & 0x0f;
6923#line 921 "rx-decode.opc"
6924 int bit AU = op[1] & 0x07;
6925 if (trace)
6926 {
6927 printf ("\033[33m%s\033[0m %02x %02x\n",
6928 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6929 op[0], op[1]);
6930 printf (" sd = 0x%x,", sd);
6931 printf (" rdst = 0x%x,", rdst);
6932 printf (" bit = 0x%x\n", bit);
6933 }
6934 SYNTAX("btst #%2, %1%S1");
6935#line 921 "rx-decode.opc"
6936 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
6937
6938 }
6939 break;
6940 case 0x08:
6941 op_semantics_45:
6942 {
6943 /** 1111 01ss rsrc 10sz push%s %1 */
6944#line 377 "rx-decode.opc"
6945 int ss AU = op[0] & 0x03;
6946#line 377 "rx-decode.opc"
6947 int rsrc AU = (op[1] >> 4) & 0x0f;
6948#line 377 "rx-decode.opc"
6949 int sz AU = op[1] & 0x03;
6950 if (trace)
6951 {
6952 printf ("\033[33m%s\033[0m %02x %02x\n",
6953 "/** 1111 01ss rsrc 10sz push%s %1 */",
6954 op[0], op[1]);
6955 printf (" ss = 0x%x,", ss);
6956 printf (" rsrc = 0x%x,", rsrc);
6957 printf (" sz = 0x%x\n", sz);
6958 }
6959 SYNTAX("push%s %1");
6960#line 377 "rx-decode.opc"
6961 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
6962
6963 /*----------------------------------------------------------------------*/
6964 /* XCHG */
6965
6966 }
6967 break;
6968 default: UNSUPPORTED(); break;
6969 }
6970 break;
6971 case 0xf5:
6972 GETBYTE ();
6973 switch (op[1] & 0x0c)
6974 {
6975 case 0x00:
6976 case 0x04:
6977 goto op_semantics_44;
6978 break;
6979 case 0x08:
6980 goto op_semantics_45;
6981 break;
6982 default: UNSUPPORTED(); break;
6983 }
6984 break;
6985 case 0xf6:
6986 GETBYTE ();
6987 switch (op[1] & 0x0c)
6988 {
6989 case 0x00:
6990 case 0x04:
6991 goto op_semantics_44;
6992 break;
6993 case 0x08:
6994 goto op_semantics_45;
6995 break;
6996 default: UNSUPPORTED(); break;
6997 }
6998 break;
6999 case 0xf7:
7000 GETBYTE ();
7001 switch (op[1] & 0x0c)
7002 {
7003 case 0x00:
7004 case 0x04:
7005 goto op_semantics_44;
7006 break;
7007 case 0x08:
7008 goto op_semantics_45;
7009 break;
7010 default: UNSUPPORTED(); break;
7011 }
7012 break;
7013 case 0xf8:
7014 GETBYTE ();
7015 switch (op[1] & 0x00)
7016 {
7017 case 0x00:
7018 op_semantics_46:
7019 {
7020 /** 1111 10sd rdst im sz mov%s #%1, %0 */
7021#line 288 "rx-decode.opc"
7022 int sd AU = op[0] & 0x03;
7023#line 288 "rx-decode.opc"
7024 int rdst AU = (op[1] >> 4) & 0x0f;
7025#line 288 "rx-decode.opc"
7026 int im AU = (op[1] >> 2) & 0x03;
7027#line 288 "rx-decode.opc"
7028 int sz AU = op[1] & 0x03;
7029 if (trace)
7030 {
7031 printf ("\033[33m%s\033[0m %02x %02x\n",
7032 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
7033 op[0], op[1]);
7034 printf (" sd = 0x%x,", sd);
7035 printf (" rdst = 0x%x,", rdst);
7036 printf (" im = 0x%x,", im);
7037 printf (" sz = 0x%x\n", sz);
7038 }
7039 SYNTAX("mov%s #%1, %0");
7040#line 288 "rx-decode.opc"
7041 ID(mov); DD(sd, rdst, sz);
7042 if ((im == 1 && sz == 0)
7043 || (im == 2 && sz == 1)
7044 || (im == 0 && sz == 2))
7045 {
7046 BWL (sz);
7047 SC(IMM(im));
7048 }
7049 else
7050 {
7051 sBWL (sz);
7052 SC(IMMex(im));
7053 }
7054 F_____;
7055
7056 }
7057 break;
7058 }
7059 break;
7060 case 0xf9:
7061 GETBYTE ();
7062 switch (op[1] & 0x00)
7063 {
7064 case 0x00:
7065 goto op_semantics_46;
7066 break;
7067 }
7068 break;
7069 case 0xfa:
7070 GETBYTE ();
7071 switch (op[1] & 0x00)
7072 {
7073 case 0x00:
7074 goto op_semantics_46;
7075 break;
7076 }
7077 break;
7078 case 0xfb:
7079 GETBYTE ();
7080 switch (op[1] & 0x00)
7081 {
7082 case 0x00:
7083 goto op_semantics_46;
7084 break;
7085 }
7086 break;
7087 case 0xfc:
7088 GETBYTE ();
7089 switch (op[1] & 0xff)
7090 {
7091 case 0x03:
7092 GETBYTE ();
7093 switch (op[2] & 0x00)
7094 {
7095 case 0x00:
7096 {
7097 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7098#line 551 "rx-decode.opc"
7099 int rsrc AU = (op[2] >> 4) & 0x0f;
7100#line 551 "rx-decode.opc"
7101 int rdst AU = op[2] & 0x0f;
7102 if (trace)
7103 {
7104 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7105 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7106 op[0], op[1], op[2]);
7107 printf (" rsrc = 0x%x,", rsrc);
7108 printf (" rdst = 0x%x\n", rdst);
7109 }
7110 SYNTAX("sbb %1, %0");
7111#line 551 "rx-decode.opc"
7112 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7113
7114 /* FIXME: only supports .L */
7115 }
7116 break;
7117 }
7118 break;
7119 case 0x07:
7120 GETBYTE ();
7121 switch (op[2] & 0x00)
7122 {
7123 case 0x00:
7124 {
7125 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7126#line 482 "rx-decode.opc"
7127 int rsrc AU = (op[2] >> 4) & 0x0f;
7128#line 482 "rx-decode.opc"
7129 int rdst AU = op[2] & 0x0f;
7130 if (trace)
7131 {
7132 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7133 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7134 op[0], op[1], op[2]);
7135 printf (" rsrc = 0x%x,", rsrc);
7136 printf (" rdst = 0x%x\n", rdst);
7137 }
7138 SYNTAX("neg %2, %0");
7139#line 482 "rx-decode.opc"
7140 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7141
7142 /*----------------------------------------------------------------------*/
7143 /* ADC */
7144
7145 }
7146 break;
7147 }
7148 break;
7149 case 0x0b:
7150 GETBYTE ();
7151 switch (op[2] & 0x00)
7152 {
7153 case 0x00:
7154 {
7155 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7156#line 491 "rx-decode.opc"
7157 int rsrc AU = (op[2] >> 4) & 0x0f;
7158#line 491 "rx-decode.opc"
7159 int rdst AU = op[2] & 0x0f;
7160 if (trace)
7161 {
7162 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7163 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7164 op[0], op[1], op[2]);
7165 printf (" rsrc = 0x%x,", rsrc);
7166 printf (" rdst = 0x%x\n", rdst);
7167 }
7168 SYNTAX("adc %1, %0");
7169#line 491 "rx-decode.opc"
7170 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7171
7172 }
7173 break;
7174 }
7175 break;
7176 case 0x0f:
7177 GETBYTE ();
7178 switch (op[2] & 0x00)
7179 {
7180 case 0x00:
7181 {
7182 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7183#line 564 "rx-decode.opc"
7184 int rsrc AU = (op[2] >> 4) & 0x0f;
7185#line 564 "rx-decode.opc"
7186 int rdst AU = op[2] & 0x0f;
7187 if (trace)
7188 {
7189 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7190 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7191 op[0], op[1], op[2]);
7192 printf (" rsrc = 0x%x,", rsrc);
7193 printf (" rdst = 0x%x\n", rdst);
7194 }
7195 SYNTAX("abs %1, %0");
7196#line 564 "rx-decode.opc"
7197 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7198
7199 /*----------------------------------------------------------------------*/
7200 /* MAX */
7201
7202 }
7203 break;
7204 }
7205 break;
7206 case 0x10:
7207 GETBYTE ();
7208 switch (op[2] & 0x00)
7209 {
7210 case 0x00:
7211 op_semantics_47:
7212 {
7213 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7214#line 573 "rx-decode.opc"
7215 int ss AU = op[1] & 0x03;
7216#line 573 "rx-decode.opc"
7217 int rsrc AU = (op[2] >> 4) & 0x0f;
7218#line 573 "rx-decode.opc"
7219 int rdst AU = op[2] & 0x0f;
7220 if (trace)
7221 {
7222 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7223 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7224 op[0], op[1], op[2]);
7225 printf (" ss = 0x%x,", ss);
7226 printf (" rsrc = 0x%x,", rsrc);
7227 printf (" rdst = 0x%x\n", rdst);
7228 }
7229 SYNTAX("max %1%S1, %0");
7230#line 573 "rx-decode.opc"
7231 if (ss == 3 && rsrc == 0 && rdst == 0)
7232 {
7233 ID(nop3);
7234 SYNTAX ("nop\t; max\tr0, r0");
7235 }
7236 else
7237 {
7238 ID(max); SP(ss, rsrc); DR(rdst);
7239 }
7240
7241 }
7242 break;
7243 }
7244 break;
7245 case 0x11:
7246 GETBYTE ();
7247 switch (op[2] & 0x00)
7248 {
7249 case 0x00:
7250 goto op_semantics_47;
7251 break;
7252 }
7253 break;
7254 case 0x12:
7255 GETBYTE ();
7256 switch (op[2] & 0x00)
7257 {
7258 case 0x00:
7259 goto op_semantics_47;
7260 break;
7261 }
7262 break;
7263 case 0x13:
7264 GETBYTE ();
7265 switch (op[2] & 0x00)
7266 {
7267 case 0x00:
7268 goto op_semantics_47;
7269 break;
7270 }
7271 break;
7272 case 0x14:
7273 GETBYTE ();
7274 switch (op[2] & 0x00)
7275 {
7276 case 0x00:
7277 op_semantics_48:
7278 {
7279 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7280#line 593 "rx-decode.opc"
7281 int ss AU = op[1] & 0x03;
7282#line 593 "rx-decode.opc"
7283 int rsrc AU = (op[2] >> 4) & 0x0f;
7284#line 593 "rx-decode.opc"
7285 int rdst AU = op[2] & 0x0f;
7286 if (trace)
7287 {
7288 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7289 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7290 op[0], op[1], op[2]);
7291 printf (" ss = 0x%x,", ss);
7292 printf (" rsrc = 0x%x,", rsrc);
7293 printf (" rdst = 0x%x\n", rdst);
7294 }
7295 SYNTAX("min %1%S1, %0");
7296#line 593 "rx-decode.opc"
7297 ID(min); SP(ss, rsrc); DR(rdst);
7298
7299 }
7300 break;
7301 }
7302 break;
7303 case 0x15:
7304 GETBYTE ();
7305 switch (op[2] & 0x00)
7306 {
7307 case 0x00:
7308 goto op_semantics_48;
7309 break;
7310 }
7311 break;
7312 case 0x16:
7313 GETBYTE ();
7314 switch (op[2] & 0x00)
7315 {
7316 case 0x00:
7317 goto op_semantics_48;
7318 break;
7319 }
7320 break;
7321 case 0x17:
7322 GETBYTE ();
7323 switch (op[2] & 0x00)
7324 {
7325 case 0x00:
7326 goto op_semantics_48;
7327 break;
7328 }
7329 break;
7330 case 0x18:
7331 GETBYTE ();
7332 switch (op[2] & 0x00)
7333 {
7334 case 0x00:
7335 op_semantics_49:
7336 {
7337 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7338#line 623 "rx-decode.opc"
7339 int ss AU = op[1] & 0x03;
7340#line 623 "rx-decode.opc"
7341 int rsrc AU = (op[2] >> 4) & 0x0f;
7342#line 623 "rx-decode.opc"
7343 int rdst AU = op[2] & 0x0f;
7344 if (trace)
7345 {
7346 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7347 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7348 op[0], op[1], op[2]);
7349 printf (" ss = 0x%x,", ss);
7350 printf (" rsrc = 0x%x,", rsrc);
7351 printf (" rdst = 0x%x\n", rdst);
7352 }
7353 SYNTAX("emul %1%S1, %0");
7354#line 623 "rx-decode.opc"
7355 ID(emul); SP(ss, rsrc); DR(rdst);
7356
7357 }
7358 break;
7359 }
7360 break;
7361 case 0x19:
7362 GETBYTE ();
7363 switch (op[2] & 0x00)
7364 {
7365 case 0x00:
7366 goto op_semantics_49;
7367 break;
7368 }
7369 break;
7370 case 0x1a:
7371 GETBYTE ();
7372 switch (op[2] & 0x00)
7373 {
7374 case 0x00:
7375 goto op_semantics_49;
7376 break;
7377 }
7378 break;
7379 case 0x1b:
7380 GETBYTE ();
7381 switch (op[2] & 0x00)
7382 {
7383 case 0x00:
7384 goto op_semantics_49;
7385 break;
7386 }
7387 break;
7388 case 0x1c:
7389 GETBYTE ();
7390 switch (op[2] & 0x00)
7391 {
7392 case 0x00:
7393 op_semantics_50:
7394 {
7395 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7396#line 635 "rx-decode.opc"
7397 int ss AU = op[1] & 0x03;
7398#line 635 "rx-decode.opc"
7399 int rsrc AU = (op[2] >> 4) & 0x0f;
7400#line 635 "rx-decode.opc"
7401 int rdst AU = op[2] & 0x0f;
7402 if (trace)
7403 {
7404 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7405 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7406 op[0], op[1], op[2]);
7407 printf (" ss = 0x%x,", ss);
7408 printf (" rsrc = 0x%x,", rsrc);
7409 printf (" rdst = 0x%x\n", rdst);
7410 }
7411 SYNTAX("emulu %1%S1, %0");
7412#line 635 "rx-decode.opc"
7413 ID(emulu); SP(ss, rsrc); DR(rdst);
7414
7415 }
7416 break;
7417 }
7418 break;
7419 case 0x1d:
7420 GETBYTE ();
7421 switch (op[2] & 0x00)
7422 {
7423 case 0x00:
7424 goto op_semantics_50;
7425 break;
7426 }
7427 break;
7428 case 0x1e:
7429 GETBYTE ();
7430 switch (op[2] & 0x00)
7431 {
7432 case 0x00:
7433 goto op_semantics_50;
7434 break;
7435 }
7436 break;
7437 case 0x1f:
7438 GETBYTE ();
7439 switch (op[2] & 0x00)
7440 {
7441 case 0x00:
7442 goto op_semantics_50;
7443 break;
7444 }
7445 break;
7446 case 0x20:
7447 GETBYTE ();
7448 switch (op[2] & 0x00)
7449 {
7450 case 0x00:
7451 op_semantics_51:
7452 {
7453 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7454#line 647 "rx-decode.opc"
7455 int ss AU = op[1] & 0x03;
7456#line 647 "rx-decode.opc"
7457 int rsrc AU = (op[2] >> 4) & 0x0f;
7458#line 647 "rx-decode.opc"
7459 int rdst AU = op[2] & 0x0f;
7460 if (trace)
7461 {
7462 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7463 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7464 op[0], op[1], op[2]);
7465 printf (" ss = 0x%x,", ss);
7466 printf (" rsrc = 0x%x,", rsrc);
7467 printf (" rdst = 0x%x\n", rdst);
7468 }
7469 SYNTAX("div %1%S1, %0");
7470#line 647 "rx-decode.opc"
7471 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7472
7473 }
7474 break;
7475 }
7476 break;
7477 case 0x21:
7478 GETBYTE ();
7479 switch (op[2] & 0x00)
7480 {
7481 case 0x00:
7482 goto op_semantics_51;
7483 break;
7484 }
7485 break;
7486 case 0x22:
7487 GETBYTE ();
7488 switch (op[2] & 0x00)
7489 {
7490 case 0x00:
7491 goto op_semantics_51;
7492 break;
7493 }
7494 break;
7495 case 0x23:
7496 GETBYTE ();
7497 switch (op[2] & 0x00)
7498 {
7499 case 0x00:
7500 goto op_semantics_51;
7501 break;
7502 }
7503 break;
7504 case 0x24:
7505 GETBYTE ();
7506 switch (op[2] & 0x00)
7507 {
7508 case 0x00:
7509 op_semantics_52:
7510 {
7511 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7512#line 659 "rx-decode.opc"
7513 int ss AU = op[1] & 0x03;
7514#line 659 "rx-decode.opc"
7515 int rsrc AU = (op[2] >> 4) & 0x0f;
7516#line 659 "rx-decode.opc"
7517 int rdst AU = op[2] & 0x0f;
7518 if (trace)
7519 {
7520 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7521 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7522 op[0], op[1], op[2]);
7523 printf (" ss = 0x%x,", ss);
7524 printf (" rsrc = 0x%x,", rsrc);
7525 printf (" rdst = 0x%x\n", rdst);
7526 }
7527 SYNTAX("divu %1%S1, %0");
7528#line 659 "rx-decode.opc"
7529 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7530
7531 }
7532 break;
7533 }
7534 break;
7535 case 0x25:
7536 GETBYTE ();
7537 switch (op[2] & 0x00)
7538 {
7539 case 0x00:
7540 goto op_semantics_52;
7541 break;
7542 }
7543 break;
7544 case 0x26:
7545 GETBYTE ();
7546 switch (op[2] & 0x00)
7547 {
7548 case 0x00:
7549 goto op_semantics_52;
7550 break;
7551 }
7552 break;
7553 case 0x27:
7554 GETBYTE ();
7555 switch (op[2] & 0x00)
7556 {
7557 case 0x00:
7558 goto op_semantics_52;
7559 break;
7560 }
7561 break;
7562 case 0x30:
7563 GETBYTE ();
7564 switch (op[2] & 0x00)
7565 {
7566 case 0x00:
7567 op_semantics_53:
7568 {
7569 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7570#line 470 "rx-decode.opc"
7571 int ss AU = op[1] & 0x03;
7572#line 470 "rx-decode.opc"
7573 int rsrc AU = (op[2] >> 4) & 0x0f;
7574#line 470 "rx-decode.opc"
7575 int rdst AU = op[2] & 0x0f;
7576 if (trace)
7577 {
7578 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7579 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7580 op[0], op[1], op[2]);
7581 printf (" ss = 0x%x,", ss);
7582 printf (" rsrc = 0x%x,", rsrc);
7583 printf (" rdst = 0x%x\n", rdst);
7584 }
7585 SYNTAX("tst %1%S1, %2");
7586#line 470 "rx-decode.opc"
7587 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7588
7589 }
7590 break;
7591 }
7592 break;
7593 case 0x31:
7594 GETBYTE ();
7595 switch (op[2] & 0x00)
7596 {
7597 case 0x00:
7598 goto op_semantics_53;
7599 break;
7600 }
7601 break;
7602 case 0x32:
7603 GETBYTE ();
7604 switch (op[2] & 0x00)
7605 {
7606 case 0x00:
7607 goto op_semantics_53;
7608 break;
7609 }
7610 break;
7611 case 0x33:
7612 GETBYTE ();
7613 switch (op[2] & 0x00)
7614 {
7615 case 0x00:
7616 goto op_semantics_53;
7617 break;
7618 }
7619 break;
7620 case 0x34:
7621 GETBYTE ();
7622 switch (op[2] & 0x00)
7623 {
7624 case 0x00:
7625 op_semantics_54:
7626 {
7627 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7628#line 449 "rx-decode.opc"
7629 int ss AU = op[1] & 0x03;
7630#line 449 "rx-decode.opc"
7631 int rsrc AU = (op[2] >> 4) & 0x0f;
7632#line 449 "rx-decode.opc"
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 01ss rsrc rdst xor %1%S1, %0 */",
7638 op[0], op[1], op[2]);
7639 printf (" ss = 0x%x,", ss);
7640 printf (" rsrc = 0x%x,", rsrc);
7641 printf (" rdst = 0x%x\n", rdst);
7642 }
7643 SYNTAX("xor %1%S1, %0");
7644#line 449 "rx-decode.opc"
7645 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7646
7647 }
7648 break;
7649 }
7650 break;
7651 case 0x35:
7652 GETBYTE ();
7653 switch (op[2] & 0x00)
7654 {
7655 case 0x00:
7656 goto op_semantics_54;
7657 break;
7658 }
7659 break;
7660 case 0x36:
7661 GETBYTE ();
7662 switch (op[2] & 0x00)
7663 {
7664 case 0x00:
7665 goto op_semantics_54;
7666 break;
7667 }
7668 break;
7669 case 0x37:
7670 GETBYTE ();
7671 switch (op[2] & 0x00)
7672 {
7673 case 0x00:
7674 goto op_semantics_54;
7675 break;
7676 }
7677 break;
7678 case 0x3b:
7679 GETBYTE ();
7680 switch (op[2] & 0x00)
7681 {
7682 case 0x00:
7683 {
7684 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7685#line 461 "rx-decode.opc"
7686 int rsrc AU = (op[2] >> 4) & 0x0f;
7687#line 461 "rx-decode.opc"
7688 int rdst AU = op[2] & 0x0f;
7689 if (trace)
7690 {
7691 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7692 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7693 op[0], op[1], op[2]);
7694 printf (" rsrc = 0x%x,", rsrc);
7695 printf (" rdst = 0x%x\n", rdst);
7696 }
7697 SYNTAX("not %1, %0");
7698#line 461 "rx-decode.opc"
7699 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7700
7701 /*----------------------------------------------------------------------*/
7702 /* TST */
7703
7704 }
7705 break;
7706 }
7707 break;
7708 case 0x40:
7709 GETBYTE ();
7710 switch (op[2] & 0x00)
7711 {
7712 case 0x00:
7713 op_semantics_55:
7714 {
7715 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7716#line 383 "rx-decode.opc"
7717 int ss AU = op[1] & 0x03;
7718#line 383 "rx-decode.opc"
7719 int rsrc AU = (op[2] >> 4) & 0x0f;
7720#line 383 "rx-decode.opc"
7721 int rdst AU = op[2] & 0x0f;
7722 if (trace)
7723 {
7724 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7725 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7726 op[0], op[1], op[2]);
7727 printf (" ss = 0x%x,", ss);
7728 printf (" rsrc = 0x%x,", rsrc);
7729 printf (" rdst = 0x%x\n", rdst);
7730 }
7731 SYNTAX("xchg %1%S1, %0");
7732#line 383 "rx-decode.opc"
7733 ID(xchg); DR(rdst); SP(ss, rsrc);
7734
7735 }
7736 break;
7737 }
7738 break;
7739 case 0x41:
7740 GETBYTE ();
7741 switch (op[2] & 0x00)
7742 {
7743 case 0x00:
7744 goto op_semantics_55;
7745 break;
7746 }
7747 break;
7748 case 0x42:
7749 GETBYTE ();
7750 switch (op[2] & 0x00)
7751 {
7752 case 0x00:
7753 goto op_semantics_55;
7754 break;
7755 }
7756 break;
7757 case 0x43:
7758 GETBYTE ();
7759 switch (op[2] & 0x00)
7760 {
7761 case 0x00:
7762 goto op_semantics_55;
7763 break;
7764 }
7765 break;
7766 case 0x44:
7767 GETBYTE ();
7768 switch (op[2] & 0x00)
7769 {
7770 case 0x00:
7771 op_semantics_56:
7772 {
7773 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7774#line 888 "rx-decode.opc"
7775 int sd AU = op[1] & 0x03;
7776#line 888 "rx-decode.opc"
7777 int rsrc AU = (op[2] >> 4) & 0x0f;
7778#line 888 "rx-decode.opc"
7779 int rdst AU = op[2] & 0x0f;
7780 if (trace)
7781 {
7782 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7783 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7784 op[0], op[1], op[2]);
7785 printf (" sd = 0x%x,", sd);
7786 printf (" rsrc = 0x%x,", rsrc);
7787 printf (" rdst = 0x%x\n", rdst);
7788 }
7789 SYNTAX("itof %1%S1, %0");
7790#line 888 "rx-decode.opc"
7791 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7792
7793 }
7794 break;
7795 }
7796 break;
7797 case 0x45:
7798 GETBYTE ();
7799 switch (op[2] & 0x00)
7800 {
7801 case 0x00:
7802 goto op_semantics_56;
7803 break;
7804 }
7805 break;
7806 case 0x46:
7807 GETBYTE ();
7808 switch (op[2] & 0x00)
7809 {
7810 case 0x00:
7811 goto op_semantics_56;
7812 break;
7813 }
7814 break;
7815 case 0x47:
7816 GETBYTE ();
7817 switch (op[2] & 0x00)
7818 {
7819 case 0x00:
7820 goto op_semantics_56;
7821 break;
7822 }
7823 break;
7824 case 0x60:
7825 GETBYTE ();
7826 switch (op[2] & 0x00)
7827 {
7828 case 0x00:
7829 op_semantics_57:
7830 {
7831 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
7832#line 900 "rx-decode.opc"
7833 int sd AU = op[1] & 0x03;
7834#line 900 "rx-decode.opc"
7835 int rdst AU = (op[2] >> 4) & 0x0f;
7836#line 900 "rx-decode.opc"
7837 int rsrc AU = op[2] & 0x0f;
7838 if (trace)
7839 {
7840 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7841 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7842 op[0], op[1], op[2]);
7843 printf (" sd = 0x%x,", sd);
7844 printf (" rdst = 0x%x,", rdst);
7845 printf (" rsrc = 0x%x\n", rsrc);
7846 }
7847 SYNTAX("bset %1, %0%S0");
7848#line 900 "rx-decode.opc"
7849 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7850 if (sd == 3) /* bset reg,reg */
7851 BWL(LSIZE);
7852
7853 }
7854 break;
7855 }
7856 break;
7857 case 0x61:
7858 GETBYTE ();
7859 switch (op[2] & 0x00)
7860 {
7861 case 0x00:
7862 goto op_semantics_57;
7863 break;
7864 }
7865 break;
7866 case 0x62:
7867 GETBYTE ();
7868 switch (op[2] & 0x00)
7869 {
7870 case 0x00:
7871 goto op_semantics_57;
7872 break;
7873 }
7874 break;
7875 case 0x63:
7876 GETBYTE ();
7877 switch (op[2] & 0x00)
7878 {
7879 case 0x00:
7880 goto op_semantics_57;
7881 break;
7882 }
7883 break;
7884 case 0x64:
7885 GETBYTE ();
7886 switch (op[2] & 0x00)
7887 {
7888 case 0x00:
7889 op_semantics_58:
7890 {
7891 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
7892#line 912 "rx-decode.opc"
7893 int sd AU = op[1] & 0x03;
7894#line 912 "rx-decode.opc"
7895 int rdst AU = (op[2] >> 4) & 0x0f;
7896#line 912 "rx-decode.opc"
7897 int rsrc AU = op[2] & 0x0f;
7898 if (trace)
7899 {
7900 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7901 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7902 op[0], op[1], op[2]);
7903 printf (" sd = 0x%x,", sd);
7904 printf (" rdst = 0x%x,", rdst);
7905 printf (" rsrc = 0x%x\n", rsrc);
7906 }
7907 SYNTAX("bclr %1, %0%S0");
7908#line 912 "rx-decode.opc"
7909 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7910 if (sd == 3) /* bset reg,reg */
7911 BWL(LSIZE);
7912
7913 }
7914 break;
7915 }
7916 break;
7917 case 0x65:
7918 GETBYTE ();
7919 switch (op[2] & 0x00)
7920 {
7921 case 0x00:
7922 goto op_semantics_58;
7923 break;
7924 }
7925 break;
7926 case 0x66:
7927 GETBYTE ();
7928 switch (op[2] & 0x00)
7929 {
7930 case 0x00:
7931 goto op_semantics_58;
7932 break;
7933 }
7934 break;
7935 case 0x67:
7936 GETBYTE ();
7937 switch (op[2] & 0x00)
7938 {
7939 case 0x00:
7940 goto op_semantics_58;
7941 break;
7942 }
7943 break;
7944 case 0x68:
7945 GETBYTE ();
7946 switch (op[2] & 0x00)
7947 {
7948 case 0x00:
7949 op_semantics_59:
7950 {
7951 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
7952#line 924 "rx-decode.opc"
7953 int sd AU = op[1] & 0x03;
7954#line 924 "rx-decode.opc"
7955 int rdst AU = (op[2] >> 4) & 0x0f;
7956#line 924 "rx-decode.opc"
7957 int rsrc AU = op[2] & 0x0f;
7958 if (trace)
7959 {
7960 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7961 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7962 op[0], op[1], op[2]);
7963 printf (" sd = 0x%x,", sd);
7964 printf (" rdst = 0x%x,", rdst);
7965 printf (" rsrc = 0x%x\n", rsrc);
7966 }
7967 SYNTAX("btst %2, %1%S1");
7968#line 924 "rx-decode.opc"
7969 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
7970 if (sd == 3) /* bset reg,reg */
7971 BWL(LSIZE);
7972
7973 }
7974 break;
7975 }
7976 break;
7977 case 0x69:
7978 GETBYTE ();
7979 switch (op[2] & 0x00)
7980 {
7981 case 0x00:
7982 goto op_semantics_59;
7983 break;
7984 }
7985 break;
7986 case 0x6a:
7987 GETBYTE ();
7988 switch (op[2] & 0x00)
7989 {
7990 case 0x00:
7991 goto op_semantics_59;
7992 break;
7993 }
7994 break;
7995 case 0x6b:
7996 GETBYTE ();
7997 switch (op[2] & 0x00)
7998 {
7999 case 0x00:
8000 goto op_semantics_59;
8001 break;
8002 }
8003 break;
8004 case 0x6c:
8005 GETBYTE ();
8006 switch (op[2] & 0x00)
8007 {
8008 case 0x00:
8009 op_semantics_60:
8010 {
8011 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
8012#line 936 "rx-decode.opc"
8013 int sd AU = op[1] & 0x03;
8014#line 936 "rx-decode.opc"
8015 int rdst AU = (op[2] >> 4) & 0x0f;
8016#line 936 "rx-decode.opc"
8017 int rsrc AU = op[2] & 0x0f;
8018 if (trace)
8019 {
8020 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8021 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
8022 op[0], op[1], op[2]);
8023 printf (" sd = 0x%x,", sd);
8024 printf (" rdst = 0x%x,", rdst);
8025 printf (" rsrc = 0x%x\n", rsrc);
8026 }
8027 SYNTAX("bnot %1, %0%S0");
8028#line 936 "rx-decode.opc"
8029 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8030 if (sd == 3) /* bset reg,reg */
8031 BWL(LSIZE);
8032
8033 }
8034 break;
8035 }
8036 break;
8037 case 0x6d:
8038 GETBYTE ();
8039 switch (op[2] & 0x00)
8040 {
8041 case 0x00:
8042 goto op_semantics_60;
8043 break;
8044 }
8045 break;
8046 case 0x6e:
8047 GETBYTE ();
8048 switch (op[2] & 0x00)
8049 {
8050 case 0x00:
8051 goto op_semantics_60;
8052 break;
8053 }
8054 break;
8055 case 0x6f:
8056 GETBYTE ();
8057 switch (op[2] & 0x00)
8058 {
8059 case 0x00:
8060 goto op_semantics_60;
8061 break;
8062 }
8063 break;
8064 case 0x80:
8065 GETBYTE ();
8066 switch (op[2] & 0x00)
8067 {
8068 case 0x00:
8069 op_semantics_61:
8070 {
8071 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8072#line 867 "rx-decode.opc"
8073 int sd AU = op[1] & 0x03;
8074#line 867 "rx-decode.opc"
8075 int rsrc AU = (op[2] >> 4) & 0x0f;
8076#line 867 "rx-decode.opc"
8077 int rdst AU = op[2] & 0x0f;
8078 if (trace)
8079 {
8080 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8081 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8082 op[0], op[1], op[2]);
8083 printf (" sd = 0x%x,", sd);
8084 printf (" rsrc = 0x%x,", rsrc);
8085 printf (" rdst = 0x%x\n", rdst);
8086 }
8087 SYNTAX("fsub %1%S1, %0");
8088#line 867 "rx-decode.opc"
8089 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8090
8091 }
8092 break;
8093 }
8094 break;
8095 case 0x81:
8096 GETBYTE ();
8097 switch (op[2] & 0x00)
8098 {
8099 case 0x00:
8100 goto op_semantics_61;
8101 break;
8102 }
8103 break;
8104 case 0x82:
8105 GETBYTE ();
8106 switch (op[2] & 0x00)
8107 {
8108 case 0x00:
8109 goto op_semantics_61;
8110 break;
8111 }
8112 break;
8113 case 0x83:
8114 GETBYTE ();
8115 switch (op[2] & 0x00)
8116 {
8117 case 0x00:
8118 goto op_semantics_61;
8119 break;
8120 }
8121 break;
8122 case 0x84:
8123 GETBYTE ();
8124 switch (op[2] & 0x00)
8125 {
8126 case 0x00:
8127 op_semantics_62:
8128 {
8129 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8130#line 861 "rx-decode.opc"
8131 int sd AU = op[1] & 0x03;
8132#line 861 "rx-decode.opc"
8133 int rsrc AU = (op[2] >> 4) & 0x0f;
8134#line 861 "rx-decode.opc"
8135 int rdst AU = op[2] & 0x0f;
8136 if (trace)
8137 {
8138 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8139 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8140 op[0], op[1], op[2]);
8141 printf (" sd = 0x%x,", sd);
8142 printf (" rsrc = 0x%x,", rsrc);
8143 printf (" rdst = 0x%x\n", rdst);
8144 }
8145 SYNTAX("fcmp %1%S1, %0");
8146#line 861 "rx-decode.opc"
8147 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8148
8149 }
8150 break;
8151 }
8152 break;
8153 case 0x85:
8154 GETBYTE ();
8155 switch (op[2] & 0x00)
8156 {
8157 case 0x00:
8158 goto op_semantics_62;
8159 break;
8160 }
8161 break;
8162 case 0x86:
8163 GETBYTE ();
8164 switch (op[2] & 0x00)
8165 {
8166 case 0x00:
8167 goto op_semantics_62;
8168 break;
8169 }
8170 break;
8171 case 0x87:
8172 GETBYTE ();
8173 switch (op[2] & 0x00)
8174 {
8175 case 0x00:
8176 goto op_semantics_62;
8177 break;
8178 }
8179 break;
8180 case 0x88:
8181 GETBYTE ();
8182 switch (op[2] & 0x00)
8183 {
8184 case 0x00:
8185 op_semantics_63:
8186 {
8187 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8188#line 855 "rx-decode.opc"
8189 int sd AU = op[1] & 0x03;
8190#line 855 "rx-decode.opc"
8191 int rsrc AU = (op[2] >> 4) & 0x0f;
8192#line 855 "rx-decode.opc"
8193 int rdst AU = op[2] & 0x0f;
8194 if (trace)
8195 {
8196 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8197 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8198 op[0], op[1], op[2]);
8199 printf (" sd = 0x%x,", sd);
8200 printf (" rsrc = 0x%x,", rsrc);
8201 printf (" rdst = 0x%x\n", rdst);
8202 }
8203 SYNTAX("fadd %1%S1, %0");
8204#line 855 "rx-decode.opc"
8205 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8206
8207 }
8208 break;
8209 }
8210 break;
8211 case 0x89:
8212 GETBYTE ();
8213 switch (op[2] & 0x00)
8214 {
8215 case 0x00:
8216 goto op_semantics_63;
8217 break;
8218 }
8219 break;
8220 case 0x8a:
8221 GETBYTE ();
8222 switch (op[2] & 0x00)
8223 {
8224 case 0x00:
8225 goto op_semantics_63;
8226 break;
8227 }
8228 break;
8229 case 0x8b:
8230 GETBYTE ();
8231 switch (op[2] & 0x00)
8232 {
8233 case 0x00:
8234 goto op_semantics_63;
8235 break;
8236 }
8237 break;
8238 case 0x8c:
8239 GETBYTE ();
8240 switch (op[2] & 0x00)
8241 {
8242 case 0x00:
8243 op_semantics_64:
8244 {
8245 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8246#line 876 "rx-decode.opc"
8247 int sd AU = op[1] & 0x03;
8248#line 876 "rx-decode.opc"
8249 int rsrc AU = (op[2] >> 4) & 0x0f;
8250#line 876 "rx-decode.opc"
8251 int rdst AU = op[2] & 0x0f;
8252 if (trace)
8253 {
8254 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8255 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8256 op[0], op[1], op[2]);
8257 printf (" sd = 0x%x,", sd);
8258 printf (" rsrc = 0x%x,", rsrc);
8259 printf (" rdst = 0x%x\n", rdst);
8260 }
8261 SYNTAX("fmul %1%S1, %0");
8262#line 876 "rx-decode.opc"
8263 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8264
8265 }
8266 break;
8267 }
8268 break;
8269 case 0x8d:
8270 GETBYTE ();
8271 switch (op[2] & 0x00)
8272 {
8273 case 0x00:
8274 goto op_semantics_64;
8275 break;
8276 }
8277 break;
8278 case 0x8e:
8279 GETBYTE ();
8280 switch (op[2] & 0x00)
8281 {
8282 case 0x00:
8283 goto op_semantics_64;
8284 break;
8285 }
8286 break;
8287 case 0x8f:
8288 GETBYTE ();
8289 switch (op[2] & 0x00)
8290 {
8291 case 0x00:
8292 goto op_semantics_64;
8293 break;
8294 }
8295 break;
8296 case 0x90:
8297 GETBYTE ();
8298 switch (op[2] & 0x00)
8299 {
8300 case 0x00:
8301 op_semantics_65:
8302 {
8303 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8304#line 882 "rx-decode.opc"
8305 int sd AU = op[1] & 0x03;
8306#line 882 "rx-decode.opc"
8307 int rsrc AU = (op[2] >> 4) & 0x0f;
8308#line 882 "rx-decode.opc"
8309 int rdst AU = op[2] & 0x0f;
8310 if (trace)
8311 {
8312 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8313 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8314 op[0], op[1], op[2]);
8315 printf (" sd = 0x%x,", sd);
8316 printf (" rsrc = 0x%x,", rsrc);
8317 printf (" rdst = 0x%x\n", rdst);
8318 }
8319 SYNTAX("fdiv %1%S1, %0");
8320#line 882 "rx-decode.opc"
8321 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8322
8323 }
8324 break;
8325 }
8326 break;
8327 case 0x91:
8328 GETBYTE ();
8329 switch (op[2] & 0x00)
8330 {
8331 case 0x00:
8332 goto op_semantics_65;
8333 break;
8334 }
8335 break;
8336 case 0x92:
8337 GETBYTE ();
8338 switch (op[2] & 0x00)
8339 {
8340 case 0x00:
8341 goto op_semantics_65;
8342 break;
8343 }
8344 break;
8345 case 0x93:
8346 GETBYTE ();
8347 switch (op[2] & 0x00)
8348 {
8349 case 0x00:
8350 goto op_semantics_65;
8351 break;
8352 }
8353 break;
8354 case 0x94:
8355 GETBYTE ();
8356 switch (op[2] & 0x00)
8357 {
8358 case 0x00:
8359 op_semantics_66:
8360 {
8361 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8362#line 870 "rx-decode.opc"
8363 int sd AU = op[1] & 0x03;
8364#line 870 "rx-decode.opc"
8365 int rsrc AU = (op[2] >> 4) & 0x0f;
8366#line 870 "rx-decode.opc"
8367 int rdst AU = op[2] & 0x0f;
8368 if (trace)
8369 {
8370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8371 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8372 op[0], op[1], op[2]);
8373 printf (" sd = 0x%x,", sd);
8374 printf (" rsrc = 0x%x,", rsrc);
8375 printf (" rdst = 0x%x\n", rdst);
8376 }
8377 SYNTAX("ftoi %1%S1, %0");
8378#line 870 "rx-decode.opc"
8379 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8380
8381 }
8382 break;
8383 }
8384 break;
8385 case 0x95:
8386 GETBYTE ();
8387 switch (op[2] & 0x00)
8388 {
8389 case 0x00:
8390 goto op_semantics_66;
8391 break;
8392 }
8393 break;
8394 case 0x96:
8395 GETBYTE ();
8396 switch (op[2] & 0x00)
8397 {
8398 case 0x00:
8399 goto op_semantics_66;
8400 break;
8401 }
8402 break;
8403 case 0x97:
8404 GETBYTE ();
8405 switch (op[2] & 0x00)
8406 {
8407 case 0x00:
8408 goto op_semantics_66;
8409 break;
8410 }
8411 break;
8412 case 0x98:
8413 GETBYTE ();
8414 switch (op[2] & 0x00)
8415 {
8416 case 0x00:
8417 op_semantics_67:
8418 {
8419 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8420#line 885 "rx-decode.opc"
8421 int sd AU = op[1] & 0x03;
8422#line 885 "rx-decode.opc"
8423 int rsrc AU = (op[2] >> 4) & 0x0f;
8424#line 885 "rx-decode.opc"
8425 int rdst AU = op[2] & 0x0f;
8426 if (trace)
8427 {
8428 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8429 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8430 op[0], op[1], op[2]);
8431 printf (" sd = 0x%x,", sd);
8432 printf (" rsrc = 0x%x,", rsrc);
8433 printf (" rdst = 0x%x\n", rdst);
8434 }
8435 SYNTAX("round %1%S1, %0");
8436#line 885 "rx-decode.opc"
8437 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8438
8439 }
8440 break;
8441 }
8442 break;
8443 case 0x99:
8444 GETBYTE ();
8445 switch (op[2] & 0x00)
8446 {
8447 case 0x00:
8448 goto op_semantics_67;
8449 break;
8450 }
8451 break;
8452 case 0x9a:
8453 GETBYTE ();
8454 switch (op[2] & 0x00)
8455 {
8456 case 0x00:
8457 goto op_semantics_67;
8458 break;
8459 }
8460 break;
8461 case 0x9b:
8462 GETBYTE ();
8463 switch (op[2] & 0x00)
8464 {
8465 case 0x00:
8466 goto op_semantics_67;
8467 break;
8468 }
8469 break;
8470 case 0xd0:
8471 GETBYTE ();
8472 switch (op[2] & 0x00)
8473 {
8474 case 0x00:
8475 op_semantics_68:
8476 {
8477 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8478#line 1002 "rx-decode.opc"
8479 int sz AU = (op[1] >> 2) & 0x03;
8480#line 1002 "rx-decode.opc"
8481 int sd AU = op[1] & 0x03;
8482#line 1002 "rx-decode.opc"
8483 int rdst AU = (op[2] >> 4) & 0x0f;
8484#line 1002 "rx-decode.opc"
8485 int cond AU = op[2] & 0x0f;
8486 if (trace)
8487 {
8488 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8489 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8490 op[0], op[1], op[2]);
8491 printf (" sz = 0x%x,", sz);
8492 printf (" sd = 0x%x,", sd);
8493 printf (" rdst = 0x%x,", rdst);
8494 printf (" cond = 0x%x\n", cond);
8495 }
8496 SYNTAX("sc%1%s %0");
8497#line 1002 "rx-decode.opc"
8498 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8499
8500 }
8501 break;
8502 }
8503 break;
8504 case 0xd1:
8505 GETBYTE ();
8506 switch (op[2] & 0x00)
8507 {
8508 case 0x00:
8509 goto op_semantics_68;
8510 break;
8511 }
8512 break;
8513 case 0xd2:
8514 GETBYTE ();
8515 switch (op[2] & 0x00)
8516 {
8517 case 0x00:
8518 goto op_semantics_68;
8519 break;
8520 }
8521 break;
8522 case 0xd3:
8523 GETBYTE ();
8524 switch (op[2] & 0x00)
8525 {
8526 case 0x00:
8527 goto op_semantics_68;
8528 break;
8529 }
8530 break;
8531 case 0xd4:
8532 GETBYTE ();
8533 switch (op[2] & 0x00)
8534 {
8535 case 0x00:
8536 goto op_semantics_68;
8537 break;
8538 }
8539 break;
8540 case 0xd5:
8541 GETBYTE ();
8542 switch (op[2] & 0x00)
8543 {
8544 case 0x00:
8545 goto op_semantics_68;
8546 break;
8547 }
8548 break;
8549 case 0xd6:
8550 GETBYTE ();
8551 switch (op[2] & 0x00)
8552 {
8553 case 0x00:
8554 goto op_semantics_68;
8555 break;
8556 }
8557 break;
8558 case 0xd7:
8559 GETBYTE ();
8560 switch (op[2] & 0x00)
8561 {
8562 case 0x00:
8563 goto op_semantics_68;
8564 break;
8565 }
8566 break;
8567 case 0xd8:
8568 GETBYTE ();
8569 switch (op[2] & 0x00)
8570 {
8571 case 0x00:
8572 goto op_semantics_68;
8573 break;
8574 }
8575 break;
8576 case 0xd9:
8577 GETBYTE ();
8578 switch (op[2] & 0x00)
8579 {
8580 case 0x00:
8581 goto op_semantics_68;
8582 break;
8583 }
8584 break;
8585 case 0xda:
8586 GETBYTE ();
8587 switch (op[2] & 0x00)
8588 {
8589 case 0x00:
8590 goto op_semantics_68;
8591 break;
8592 }
8593 break;
8594 case 0xdb:
8595 GETBYTE ();
8596 switch (op[2] & 0x00)
8597 {
8598 case 0x00:
8599 goto op_semantics_68;
8600 break;
8601 }
8602 break;
8603 case 0xe0:
8604 GETBYTE ();
8605 switch (op[2] & 0x0f)
8606 {
8607 case 0x00:
8608 case 0x01:
8609 case 0x02:
8610 case 0x03:
8611 case 0x04:
8612 case 0x05:
8613 case 0x06:
8614 case 0x07:
8615 case 0x08:
8616 case 0x09:
8617 case 0x0a:
8618 case 0x0b:
8619 case 0x0c:
8620 case 0x0d:
8621 case 0x0e:
8622 op_semantics_69:
8623 {
8624 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
8625#line 945 "rx-decode.opc"
8626 int bit AU = (op[1] >> 2) & 0x07;
8627#line 945 "rx-decode.opc"
8628 int sd AU = op[1] & 0x03;
8629#line 945 "rx-decode.opc"
8630 int rdst AU = (op[2] >> 4) & 0x0f;
8631#line 945 "rx-decode.opc"
8632 int cond AU = op[2] & 0x0f;
8633 if (trace)
8634 {
8635 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8636 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8637 op[0], op[1], op[2]);
8638 printf (" bit = 0x%x,", bit);
8639 printf (" sd = 0x%x,", sd);
8640 printf (" rdst = 0x%x,", rdst);
8641 printf (" cond = 0x%x\n", cond);
8642 }
8643 SYNTAX("bm%2 #%1, %0%S0");
8644#line 945 "rx-decode.opc"
8645 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8646
8647 }
8648 break;
8649 case 0x0f:
8650 op_semantics_70:
8651 {
8652 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
8653#line 933 "rx-decode.opc"
8654 int bit AU = (op[1] >> 2) & 0x07;
8655#line 933 "rx-decode.opc"
8656 int sd AU = op[1] & 0x03;
8657#line 933 "rx-decode.opc"
8658 int rdst AU = (op[2] >> 4) & 0x0f;
8659 if (trace)
8660 {
8661 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8662 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8663 op[0], op[1], op[2]);
8664 printf (" bit = 0x%x,", bit);
8665 printf (" sd = 0x%x,", sd);
8666 printf (" rdst = 0x%x\n", rdst);
8667 }
8668 SYNTAX("bnot #%1, %0%S0");
8669#line 933 "rx-decode.opc"
8670 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8671
8672 }
8673 break;
8674 }
8675 break;
8676 case 0xe1:
8677 GETBYTE ();
8678 switch (op[2] & 0x0f)
8679 {
8680 case 0x00:
8681 case 0x01:
8682 case 0x02:
8683 case 0x03:
8684 case 0x04:
8685 case 0x05:
8686 case 0x06:
8687 case 0x07:
8688 case 0x08:
8689 case 0x09:
8690 case 0x0a:
8691 case 0x0b:
8692 case 0x0c:
8693 case 0x0d:
8694 case 0x0e:
8695 goto op_semantics_69;
8696 break;
8697 case 0x0f:
8698 goto op_semantics_70;
8699 break;
8700 }
8701 break;
8702 case 0xe2:
8703 GETBYTE ();
8704 switch (op[2] & 0x0f)
8705 {
8706 case 0x00:
8707 case 0x01:
8708 case 0x02:
8709 case 0x03:
8710 case 0x04:
8711 case 0x05:
8712 case 0x06:
8713 case 0x07:
8714 case 0x08:
8715 case 0x09:
8716 case 0x0a:
8717 case 0x0b:
8718 case 0x0c:
8719 case 0x0d:
8720 case 0x0e:
8721 goto op_semantics_69;
8722 break;
8723 case 0x0f:
8724 goto op_semantics_70;
8725 break;
8726 }
8727 break;
8728 case 0xe3:
8729 GETBYTE ();
8730 switch (op[2] & 0x0f)
8731 {
8732 case 0x00:
8733 case 0x01:
8734 case 0x02:
8735 case 0x03:
8736 case 0x04:
8737 case 0x05:
8738 case 0x06:
8739 case 0x07:
8740 case 0x08:
8741 case 0x09:
8742 case 0x0a:
8743 case 0x0b:
8744 case 0x0c:
8745 case 0x0d:
8746 case 0x0e:
8747 goto op_semantics_69;
8748 break;
8749 case 0x0f:
8750 goto op_semantics_70;
8751 break;
8752 }
8753 break;
8754 case 0xe4:
8755 GETBYTE ();
8756 switch (op[2] & 0x0f)
8757 {
8758 case 0x00:
8759 case 0x01:
8760 case 0x02:
8761 case 0x03:
8762 case 0x04:
8763 case 0x05:
8764 case 0x06:
8765 case 0x07:
8766 case 0x08:
8767 case 0x09:
8768 case 0x0a:
8769 case 0x0b:
8770 case 0x0c:
8771 case 0x0d:
8772 case 0x0e:
8773 goto op_semantics_69;
8774 break;
8775 case 0x0f:
8776 goto op_semantics_70;
8777 break;
8778 }
8779 break;
8780 case 0xe5:
8781 GETBYTE ();
8782 switch (op[2] & 0x0f)
8783 {
8784 case 0x00:
8785 case 0x01:
8786 case 0x02:
8787 case 0x03:
8788 case 0x04:
8789 case 0x05:
8790 case 0x06:
8791 case 0x07:
8792 case 0x08:
8793 case 0x09:
8794 case 0x0a:
8795 case 0x0b:
8796 case 0x0c:
8797 case 0x0d:
8798 case 0x0e:
8799 goto op_semantics_69;
8800 break;
8801 case 0x0f:
8802 goto op_semantics_70;
8803 break;
8804 }
8805 break;
8806 case 0xe6:
8807 GETBYTE ();
8808 switch (op[2] & 0x0f)
8809 {
8810 case 0x00:
8811 case 0x01:
8812 case 0x02:
8813 case 0x03:
8814 case 0x04:
8815 case 0x05:
8816 case 0x06:
8817 case 0x07:
8818 case 0x08:
8819 case 0x09:
8820 case 0x0a:
8821 case 0x0b:
8822 case 0x0c:
8823 case 0x0d:
8824 case 0x0e:
8825 goto op_semantics_69;
8826 break;
8827 case 0x0f:
8828 goto op_semantics_70;
8829 break;
8830 }
8831 break;
8832 case 0xe7:
8833 GETBYTE ();
8834 switch (op[2] & 0x0f)
8835 {
8836 case 0x00:
8837 case 0x01:
8838 case 0x02:
8839 case 0x03:
8840 case 0x04:
8841 case 0x05:
8842 case 0x06:
8843 case 0x07:
8844 case 0x08:
8845 case 0x09:
8846 case 0x0a:
8847 case 0x0b:
8848 case 0x0c:
8849 case 0x0d:
8850 case 0x0e:
8851 goto op_semantics_69;
8852 break;
8853 case 0x0f:
8854 goto op_semantics_70;
8855 break;
8856 }
8857 break;
8858 case 0xe8:
8859 GETBYTE ();
8860 switch (op[2] & 0x0f)
8861 {
8862 case 0x00:
8863 case 0x01:
8864 case 0x02:
8865 case 0x03:
8866 case 0x04:
8867 case 0x05:
8868 case 0x06:
8869 case 0x07:
8870 case 0x08:
8871 case 0x09:
8872 case 0x0a:
8873 case 0x0b:
8874 case 0x0c:
8875 case 0x0d:
8876 case 0x0e:
8877 goto op_semantics_69;
8878 break;
8879 case 0x0f:
8880 goto op_semantics_70;
8881 break;
8882 }
8883 break;
8884 case 0xe9:
8885 GETBYTE ();
8886 switch (op[2] & 0x0f)
8887 {
8888 case 0x00:
8889 case 0x01:
8890 case 0x02:
8891 case 0x03:
8892 case 0x04:
8893 case 0x05:
8894 case 0x06:
8895 case 0x07:
8896 case 0x08:
8897 case 0x09:
8898 case 0x0a:
8899 case 0x0b:
8900 case 0x0c:
8901 case 0x0d:
8902 case 0x0e:
8903 goto op_semantics_69;
8904 break;
8905 case 0x0f:
8906 goto op_semantics_70;
8907 break;
8908 }
8909 break;
8910 case 0xea:
8911 GETBYTE ();
8912 switch (op[2] & 0x0f)
8913 {
8914 case 0x00:
8915 case 0x01:
8916 case 0x02:
8917 case 0x03:
8918 case 0x04:
8919 case 0x05:
8920 case 0x06:
8921 case 0x07:
8922 case 0x08:
8923 case 0x09:
8924 case 0x0a:
8925 case 0x0b:
8926 case 0x0c:
8927 case 0x0d:
8928 case 0x0e:
8929 goto op_semantics_69;
8930 break;
8931 case 0x0f:
8932 goto op_semantics_70;
8933 break;
8934 }
8935 break;
8936 case 0xeb:
8937 GETBYTE ();
8938 switch (op[2] & 0x0f)
8939 {
8940 case 0x00:
8941 case 0x01:
8942 case 0x02:
8943 case 0x03:
8944 case 0x04:
8945 case 0x05:
8946 case 0x06:
8947 case 0x07:
8948 case 0x08:
8949 case 0x09:
8950 case 0x0a:
8951 case 0x0b:
8952 case 0x0c:
8953 case 0x0d:
8954 case 0x0e:
8955 goto op_semantics_69;
8956 break;
8957 case 0x0f:
8958 goto op_semantics_70;
8959 break;
8960 }
8961 break;
8962 case 0xec:
8963 GETBYTE ();
8964 switch (op[2] & 0x0f)
8965 {
8966 case 0x00:
8967 case 0x01:
8968 case 0x02:
8969 case 0x03:
8970 case 0x04:
8971 case 0x05:
8972 case 0x06:
8973 case 0x07:
8974 case 0x08:
8975 case 0x09:
8976 case 0x0a:
8977 case 0x0b:
8978 case 0x0c:
8979 case 0x0d:
8980 case 0x0e:
8981 goto op_semantics_69;
8982 break;
8983 case 0x0f:
8984 goto op_semantics_70;
8985 break;
8986 }
8987 break;
8988 case 0xed:
8989 GETBYTE ();
8990 switch (op[2] & 0x0f)
8991 {
8992 case 0x00:
8993 case 0x01:
8994 case 0x02:
8995 case 0x03:
8996 case 0x04:
8997 case 0x05:
8998 case 0x06:
8999 case 0x07:
9000 case 0x08:
9001 case 0x09:
9002 case 0x0a:
9003 case 0x0b:
9004 case 0x0c:
9005 case 0x0d:
9006 case 0x0e:
9007 goto op_semantics_69;
9008 break;
9009 case 0x0f:
9010 goto op_semantics_70;
9011 break;
9012 }
9013 break;
9014 case 0xee:
9015 GETBYTE ();
9016 switch (op[2] & 0x0f)
9017 {
9018 case 0x00:
9019 case 0x01:
9020 case 0x02:
9021 case 0x03:
9022 case 0x04:
9023 case 0x05:
9024 case 0x06:
9025 case 0x07:
9026 case 0x08:
9027 case 0x09:
9028 case 0x0a:
9029 case 0x0b:
9030 case 0x0c:
9031 case 0x0d:
9032 case 0x0e:
9033 goto op_semantics_69;
9034 break;
9035 case 0x0f:
9036 goto op_semantics_70;
9037 break;
9038 }
9039 break;
9040 case 0xef:
9041 GETBYTE ();
9042 switch (op[2] & 0x0f)
9043 {
9044 case 0x00:
9045 case 0x01:
9046 case 0x02:
9047 case 0x03:
9048 case 0x04:
9049 case 0x05:
9050 case 0x06:
9051 case 0x07:
9052 case 0x08:
9053 case 0x09:
9054 case 0x0a:
9055 case 0x0b:
9056 case 0x0c:
9057 case 0x0d:
9058 case 0x0e:
9059 goto op_semantics_69;
9060 break;
9061 case 0x0f:
9062 goto op_semantics_70;
9063 break;
9064 }
9065 break;
9066 case 0xf0:
9067 GETBYTE ();
9068 switch (op[2] & 0x0f)
9069 {
9070 case 0x00:
9071 case 0x01:
9072 case 0x02:
9073 case 0x03:
9074 case 0x04:
9075 case 0x05:
9076 case 0x06:
9077 case 0x07:
9078 case 0x08:
9079 case 0x09:
9080 case 0x0a:
9081 case 0x0b:
9082 case 0x0c:
9083 case 0x0d:
9084 case 0x0e:
9085 goto op_semantics_69;
9086 break;
9087 case 0x0f:
9088 goto op_semantics_70;
9089 break;
9090 }
9091 break;
9092 case 0xf1:
9093 GETBYTE ();
9094 switch (op[2] & 0x0f)
9095 {
9096 case 0x00:
9097 case 0x01:
9098 case 0x02:
9099 case 0x03:
9100 case 0x04:
9101 case 0x05:
9102 case 0x06:
9103 case 0x07:
9104 case 0x08:
9105 case 0x09:
9106 case 0x0a:
9107 case 0x0b:
9108 case 0x0c:
9109 case 0x0d:
9110 case 0x0e:
9111 goto op_semantics_69;
9112 break;
9113 case 0x0f:
9114 goto op_semantics_70;
9115 break;
9116 }
9117 break;
9118 case 0xf2:
9119 GETBYTE ();
9120 switch (op[2] & 0x0f)
9121 {
9122 case 0x00:
9123 case 0x01:
9124 case 0x02:
9125 case 0x03:
9126 case 0x04:
9127 case 0x05:
9128 case 0x06:
9129 case 0x07:
9130 case 0x08:
9131 case 0x09:
9132 case 0x0a:
9133 case 0x0b:
9134 case 0x0c:
9135 case 0x0d:
9136 case 0x0e:
9137 goto op_semantics_69;
9138 break;
9139 case 0x0f:
9140 goto op_semantics_70;
9141 break;
9142 }
9143 break;
9144 case 0xf3:
9145 GETBYTE ();
9146 switch (op[2] & 0x0f)
9147 {
9148 case 0x00:
9149 case 0x01:
9150 case 0x02:
9151 case 0x03:
9152 case 0x04:
9153 case 0x05:
9154 case 0x06:
9155 case 0x07:
9156 case 0x08:
9157 case 0x09:
9158 case 0x0a:
9159 case 0x0b:
9160 case 0x0c:
9161 case 0x0d:
9162 case 0x0e:
9163 goto op_semantics_69;
9164 break;
9165 case 0x0f:
9166 goto op_semantics_70;
9167 break;
9168 }
9169 break;
9170 case 0xf4:
9171 GETBYTE ();
9172 switch (op[2] & 0x0f)
9173 {
9174 case 0x00:
9175 case 0x01:
9176 case 0x02:
9177 case 0x03:
9178 case 0x04:
9179 case 0x05:
9180 case 0x06:
9181 case 0x07:
9182 case 0x08:
9183 case 0x09:
9184 case 0x0a:
9185 case 0x0b:
9186 case 0x0c:
9187 case 0x0d:
9188 case 0x0e:
9189 goto op_semantics_69;
9190 break;
9191 case 0x0f:
9192 goto op_semantics_70;
9193 break;
9194 }
9195 break;
9196 case 0xf5:
9197 GETBYTE ();
9198 switch (op[2] & 0x0f)
9199 {
9200 case 0x00:
9201 case 0x01:
9202 case 0x02:
9203 case 0x03:
9204 case 0x04:
9205 case 0x05:
9206 case 0x06:
9207 case 0x07:
9208 case 0x08:
9209 case 0x09:
9210 case 0x0a:
9211 case 0x0b:
9212 case 0x0c:
9213 case 0x0d:
9214 case 0x0e:
9215 goto op_semantics_69;
9216 break;
9217 case 0x0f:
9218 goto op_semantics_70;
9219 break;
9220 }
9221 break;
9222 case 0xf6:
9223 GETBYTE ();
9224 switch (op[2] & 0x0f)
9225 {
9226 case 0x00:
9227 case 0x01:
9228 case 0x02:
9229 case 0x03:
9230 case 0x04:
9231 case 0x05:
9232 case 0x06:
9233 case 0x07:
9234 case 0x08:
9235 case 0x09:
9236 case 0x0a:
9237 case 0x0b:
9238 case 0x0c:
9239 case 0x0d:
9240 case 0x0e:
9241 goto op_semantics_69;
9242 break;
9243 case 0x0f:
9244 goto op_semantics_70;
9245 break;
9246 }
9247 break;
9248 case 0xf7:
9249 GETBYTE ();
9250 switch (op[2] & 0x0f)
9251 {
9252 case 0x00:
9253 case 0x01:
9254 case 0x02:
9255 case 0x03:
9256 case 0x04:
9257 case 0x05:
9258 case 0x06:
9259 case 0x07:
9260 case 0x08:
9261 case 0x09:
9262 case 0x0a:
9263 case 0x0b:
9264 case 0x0c:
9265 case 0x0d:
9266 case 0x0e:
9267 goto op_semantics_69;
9268 break;
9269 case 0x0f:
9270 goto op_semantics_70;
9271 break;
9272 }
9273 break;
9274 case 0xf8:
9275 GETBYTE ();
9276 switch (op[2] & 0x0f)
9277 {
9278 case 0x00:
9279 case 0x01:
9280 case 0x02:
9281 case 0x03:
9282 case 0x04:
9283 case 0x05:
9284 case 0x06:
9285 case 0x07:
9286 case 0x08:
9287 case 0x09:
9288 case 0x0a:
9289 case 0x0b:
9290 case 0x0c:
9291 case 0x0d:
9292 case 0x0e:
9293 goto op_semantics_69;
9294 break;
9295 case 0x0f:
9296 goto op_semantics_70;
9297 break;
9298 }
9299 break;
9300 case 0xf9:
9301 GETBYTE ();
9302 switch (op[2] & 0x0f)
9303 {
9304 case 0x00:
9305 case 0x01:
9306 case 0x02:
9307 case 0x03:
9308 case 0x04:
9309 case 0x05:
9310 case 0x06:
9311 case 0x07:
9312 case 0x08:
9313 case 0x09:
9314 case 0x0a:
9315 case 0x0b:
9316 case 0x0c:
9317 case 0x0d:
9318 case 0x0e:
9319 goto op_semantics_69;
9320 break;
9321 case 0x0f:
9322 goto op_semantics_70;
9323 break;
9324 }
9325 break;
9326 case 0xfa:
9327 GETBYTE ();
9328 switch (op[2] & 0x0f)
9329 {
9330 case 0x00:
9331 case 0x01:
9332 case 0x02:
9333 case 0x03:
9334 case 0x04:
9335 case 0x05:
9336 case 0x06:
9337 case 0x07:
9338 case 0x08:
9339 case 0x09:
9340 case 0x0a:
9341 case 0x0b:
9342 case 0x0c:
9343 case 0x0d:
9344 case 0x0e:
9345 goto op_semantics_69;
9346 break;
9347 case 0x0f:
9348 goto op_semantics_70;
9349 break;
9350 }
9351 break;
9352 case 0xfb:
9353 GETBYTE ();
9354 switch (op[2] & 0x0f)
9355 {
9356 case 0x00:
9357 case 0x01:
9358 case 0x02:
9359 case 0x03:
9360 case 0x04:
9361 case 0x05:
9362 case 0x06:
9363 case 0x07:
9364 case 0x08:
9365 case 0x09:
9366 case 0x0a:
9367 case 0x0b:
9368 case 0x0c:
9369 case 0x0d:
9370 case 0x0e:
9371 goto op_semantics_69;
9372 break;
9373 case 0x0f:
9374 goto op_semantics_70;
9375 break;
9376 }
9377 break;
9378 case 0xfc:
9379 GETBYTE ();
9380 switch (op[2] & 0x0f)
9381 {
9382 case 0x00:
9383 case 0x01:
9384 case 0x02:
9385 case 0x03:
9386 case 0x04:
9387 case 0x05:
9388 case 0x06:
9389 case 0x07:
9390 case 0x08:
9391 case 0x09:
9392 case 0x0a:
9393 case 0x0b:
9394 case 0x0c:
9395 case 0x0d:
9396 case 0x0e:
9397 goto op_semantics_69;
9398 break;
9399 case 0x0f:
9400 goto op_semantics_70;
9401 break;
9402 }
9403 break;
9404 case 0xfd:
9405 GETBYTE ();
9406 switch (op[2] & 0x0f)
9407 {
9408 case 0x00:
9409 case 0x01:
9410 case 0x02:
9411 case 0x03:
9412 case 0x04:
9413 case 0x05:
9414 case 0x06:
9415 case 0x07:
9416 case 0x08:
9417 case 0x09:
9418 case 0x0a:
9419 case 0x0b:
9420 case 0x0c:
9421 case 0x0d:
9422 case 0x0e:
9423 goto op_semantics_69;
9424 break;
9425 case 0x0f:
9426 goto op_semantics_70;
9427 break;
9428 }
9429 break;
9430 case 0xfe:
9431 GETBYTE ();
9432 switch (op[2] & 0x0f)
9433 {
9434 case 0x00:
9435 case 0x01:
9436 case 0x02:
9437 case 0x03:
9438 case 0x04:
9439 case 0x05:
9440 case 0x06:
9441 case 0x07:
9442 case 0x08:
9443 case 0x09:
9444 case 0x0a:
9445 case 0x0b:
9446 case 0x0c:
9447 case 0x0d:
9448 case 0x0e:
9449 goto op_semantics_69;
9450 break;
9451 case 0x0f:
9452 goto op_semantics_70;
9453 break;
9454 }
9455 break;
9456 case 0xff:
9457 GETBYTE ();
9458 switch (op[2] & 0x0f)
9459 {
9460 case 0x00:
9461 case 0x01:
9462 case 0x02:
9463 case 0x03:
9464 case 0x04:
9465 case 0x05:
9466 case 0x06:
9467 case 0x07:
9468 case 0x08:
9469 case 0x09:
9470 case 0x0a:
9471 case 0x0b:
9472 case 0x0c:
9473 case 0x0d:
9474 case 0x0e:
9475 goto op_semantics_69;
9476 break;
9477 case 0x0f:
9478 goto op_semantics_70;
9479 break;
9480 }
9481 break;
9482 default: UNSUPPORTED(); break;
9483 }
9484 break;
9485 case 0xfd:
9486 GETBYTE ();
9487 switch (op[1] & 0xff)
9488 {
9489 case 0x00:
9490 GETBYTE ();
9491 switch (op[2] & 0x00)
9492 {
9493 case 0x00:
9494 {
9495 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
9496#line 810 "rx-decode.opc"
9497 int srca AU = (op[2] >> 4) & 0x0f;
9498#line 810 "rx-decode.opc"
9499 int srcb AU = op[2] & 0x0f;
9500 if (trace)
9501 {
9502 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9503 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9504 op[0], op[1], op[2]);
9505 printf (" srca = 0x%x,", srca);
9506 printf (" srcb = 0x%x\n", srcb);
9507 }
9508 SYNTAX("mulhi %1, %2");
9509#line 810 "rx-decode.opc"
9510 ID(mulhi); SR(srca); S2R(srcb); F_____;
9511
9512 }
9513 break;
9514 }
9515 break;
9516 case 0x01:
9517 GETBYTE ();
9518 switch (op[2] & 0x00)
9519 {
9520 case 0x00:
9521 {
9522 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
9523#line 813 "rx-decode.opc"
9524 int srca AU = (op[2] >> 4) & 0x0f;
9525#line 813 "rx-decode.opc"
9526 int srcb AU = op[2] & 0x0f;
9527 if (trace)
9528 {
9529 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9530 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9531 op[0], op[1], op[2]);
9532 printf (" srca = 0x%x,", srca);
9533 printf (" srcb = 0x%x\n", srcb);
9534 }
9535 SYNTAX("mullo %1, %2");
9536#line 813 "rx-decode.opc"
9537 ID(mullo); SR(srca); S2R(srcb); F_____;
9538
9539 }
9540 break;
9541 }
9542 break;
9543 case 0x04:
9544 GETBYTE ();
9545 switch (op[2] & 0x00)
9546 {
9547 case 0x00:
9548 {
9549 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
9550#line 816 "rx-decode.opc"
9551 int srca AU = (op[2] >> 4) & 0x0f;
9552#line 816 "rx-decode.opc"
9553 int srcb AU = op[2] & 0x0f;
9554 if (trace)
9555 {
9556 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9557 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9558 op[0], op[1], op[2]);
9559 printf (" srca = 0x%x,", srca);
9560 printf (" srcb = 0x%x\n", srcb);
9561 }
9562 SYNTAX("machi %1, %2");
9563#line 816 "rx-decode.opc"
9564 ID(machi); SR(srca); S2R(srcb); F_____;
9565
9566 }
9567 break;
9568 }
9569 break;
9570 case 0x05:
9571 GETBYTE ();
9572 switch (op[2] & 0x00)
9573 {
9574 case 0x00:
9575 {
9576 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
9577#line 819 "rx-decode.opc"
9578 int srca AU = (op[2] >> 4) & 0x0f;
9579#line 819 "rx-decode.opc"
9580 int srcb AU = op[2] & 0x0f;
9581 if (trace)
9582 {
9583 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9584 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9585 op[0], op[1], op[2]);
9586 printf (" srca = 0x%x,", srca);
9587 printf (" srcb = 0x%x\n", srcb);
9588 }
9589 SYNTAX("maclo %1, %2");
9590#line 819 "rx-decode.opc"
9591 ID(maclo); SR(srca); S2R(srcb); F_____;
9592
9593 }
9594 break;
9595 }
9596 break;
9597 case 0x17:
9598 GETBYTE ();
9599 switch (op[2] & 0xf0)
9600 {
9601 case 0x00:
9602 {
9603 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9604#line 822 "rx-decode.opc"
9605 int rsrc AU = op[2] & 0x0f;
9606 if (trace)
9607 {
9608 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9609 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9610 op[0], op[1], op[2]);
9611 printf (" rsrc = 0x%x\n", rsrc);
9612 }
9613 SYNTAX("mvtachi %1");
9614#line 822 "rx-decode.opc"
9615 ID(mvtachi); SR(rsrc); F_____;
9616
9617 }
9618 break;
9619 case 0x10:
9620 {
9621 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9622#line 825 "rx-decode.opc"
9623 int rsrc AU = op[2] & 0x0f;
9624 if (trace)
9625 {
9626 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9627 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9628 op[0], op[1], op[2]);
9629 printf (" rsrc = 0x%x\n", rsrc);
9630 }
9631 SYNTAX("mvtaclo %1");
9632#line 825 "rx-decode.opc"
9633 ID(mvtaclo); SR(rsrc); F_____;
9634
9635 }
9636 break;
9637 default: UNSUPPORTED(); break;
9638 }
9639 break;
9640 case 0x18:
9641 GETBYTE ();
9642 switch (op[2] & 0xef)
9643 {
9644 case 0x00:
9645 {
9646 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
9647#line 837 "rx-decode.opc"
9648 int i AU = (op[2] >> 4) & 0x01;
9649 if (trace)
9650 {
9651 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9652 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9653 op[0], op[1], op[2]);
9654 printf (" i = 0x%x\n", i);
9655 }
9656 SYNTAX("racw #%1");
9657#line 837 "rx-decode.opc"
9658 ID(racw); SC(i+1); F_____;
9659
9660 /*----------------------------------------------------------------------*/
9661 /* SAT */
9662
9663 }
9664 break;
9665 default: UNSUPPORTED(); break;
9666 }
9667 break;
9668 case 0x1f:
9669 GETBYTE ();
9670 switch (op[2] & 0xf0)
9671 {
9672 case 0x00:
9673 {
9674 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9675#line 828 "rx-decode.opc"
9676 int rdst AU = op[2] & 0x0f;
9677 if (trace)
9678 {
9679 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9680 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9681 op[0], op[1], op[2]);
9682 printf (" rdst = 0x%x\n", rdst);
9683 }
9684 SYNTAX("mvfachi %0");
9685#line 828 "rx-decode.opc"
9686 ID(mvfachi); DR(rdst); F_____;
9687
9688 }
9689 break;
9690 case 0x10:
9691 {
9692 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9693#line 834 "rx-decode.opc"
9694 int rdst AU = op[2] & 0x0f;
9695 if (trace)
9696 {
9697 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9698 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9699 op[0], op[1], op[2]);
9700 printf (" rdst = 0x%x\n", rdst);
9701 }
9702 SYNTAX("mvfaclo %0");
9703#line 834 "rx-decode.opc"
9704 ID(mvfaclo); DR(rdst); F_____;
9705
9706 }
9707 break;
9708 case 0x20:
9709 {
9710 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9711#line 831 "rx-decode.opc"
9712 int rdst AU = op[2] & 0x0f;
9713 if (trace)
9714 {
9715 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9716 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9717 op[0], op[1], op[2]);
9718 printf (" rdst = 0x%x\n", rdst);
9719 }
9720 SYNTAX("mvfacmi %0");
9721#line 831 "rx-decode.opc"
9722 ID(mvfacmi); DR(rdst); F_____;
9723
9724 }
9725 break;
9726 default: UNSUPPORTED(); break;
9727 }
9728 break;
9729 case 0x20:
9730 GETBYTE ();
9731 switch (op[2] & 0x00)
9732 {
9733 case 0x00:
9734 op_semantics_71:
9735 {
9736 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
9737#line 344 "rx-decode.opc"
9738 int p AU = (op[1] >> 2) & 0x01;
9739#line 344 "rx-decode.opc"
9740 int sz AU = op[1] & 0x03;
9741#line 344 "rx-decode.opc"
9742 int rdst AU = (op[2] >> 4) & 0x0f;
9743#line 344 "rx-decode.opc"
9744 int rsrc AU = op[2] & 0x0f;
9745 if (trace)
9746 {
9747 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9748 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9749 op[0], op[1], op[2]);
9750 printf (" p = 0x%x,", p);
9751 printf (" sz = 0x%x,", sz);
9752 printf (" rdst = 0x%x,", rdst);
9753 printf (" rsrc = 0x%x\n", rsrc);
9754 }
9755 SYNTAX("mov%s %1, %0");
9756#line 344 "rx-decode.opc"
9757 ID(mov); sBWL (sz); SR(rsrc); F_____;
9758 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9759
9760 }
9761 break;
9762 }
9763 break;
9764 case 0x21:
9765 GETBYTE ();
9766 switch (op[2] & 0x00)
9767 {
9768 case 0x00:
9769 goto op_semantics_71;
9770 break;
9771 }
9772 break;
9773 case 0x22:
9774 GETBYTE ();
9775 switch (op[2] & 0x00)
9776 {
9777 case 0x00:
9778 goto op_semantics_71;
9779 break;
9780 }
9781 break;
9782 case 0x24:
9783 GETBYTE ();
9784 switch (op[2] & 0x00)
9785 {
9786 case 0x00:
9787 goto op_semantics_71;
9788 break;
9789 }
9790 break;
9791 case 0x25:
9792 GETBYTE ();
9793 switch (op[2] & 0x00)
9794 {
9795 case 0x00:
9796 goto op_semantics_71;
9797 break;
9798 }
9799 break;
9800 case 0x26:
9801 GETBYTE ();
9802 switch (op[2] & 0x00)
9803 {
9804 case 0x00:
9805 goto op_semantics_71;
9806 break;
9807 }
9808 break;
9809 case 0x28:
9810 GETBYTE ();
9811 switch (op[2] & 0x00)
9812 {
9813 case 0x00:
9814 op_semantics_72:
9815 {
9816 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
9817#line 348 "rx-decode.opc"
9818 int p AU = (op[1] >> 2) & 0x01;
9819#line 348 "rx-decode.opc"
9820 int sz AU = op[1] & 0x03;
9821#line 348 "rx-decode.opc"
9822 int rsrc AU = (op[2] >> 4) & 0x0f;
9823#line 348 "rx-decode.opc"
9824 int rdst AU = op[2] & 0x0f;
9825 if (trace)
9826 {
9827 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9828 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9829 op[0], op[1], op[2]);
9830 printf (" p = 0x%x,", p);
9831 printf (" sz = 0x%x,", sz);
9832 printf (" rsrc = 0x%x,", rsrc);
9833 printf (" rdst = 0x%x\n", rdst);
9834 }
9835 SYNTAX("mov%s %1, %0");
9836#line 348 "rx-decode.opc"
9837 ID(mov); sBWL (sz); DR(rdst); F_____;
9838 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9839
9840 }
9841 break;
9842 }
9843 break;
9844 case 0x29:
9845 GETBYTE ();
9846 switch (op[2] & 0x00)
9847 {
9848 case 0x00:
9849 goto op_semantics_72;
9850 break;
9851 }
9852 break;
9853 case 0x2a:
9854 GETBYTE ();
9855 switch (op[2] & 0x00)
9856 {
9857 case 0x00:
9858 goto op_semantics_72;
9859 break;
9860 }
9861 break;
9862 case 0x2c:
9863 GETBYTE ();
9864 switch (op[2] & 0x00)
9865 {
9866 case 0x00:
9867 goto op_semantics_72;
9868 break;
9869 }
9870 break;
9871 case 0x2d:
9872 GETBYTE ();
9873 switch (op[2] & 0x00)
9874 {
9875 case 0x00:
9876 goto op_semantics_72;
9877 break;
9878 }
9879 break;
9880 case 0x2e:
9881 GETBYTE ();
9882 switch (op[2] & 0x00)
9883 {
9884 case 0x00:
9885 goto op_semantics_72;
9886 break;
9887 }
9888 break;
9889 case 0x38:
9890 GETBYTE ();
9891 switch (op[2] & 0x00)
9892 {
9893 case 0x00:
9894 op_semantics_73:
9895 {
9896 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
9897#line 358 "rx-decode.opc"
9898 int p AU = (op[1] >> 2) & 0x01;
9899#line 358 "rx-decode.opc"
9900 int sz AU = op[1] & 0x03;
9901#line 358 "rx-decode.opc"
9902 int rsrc AU = (op[2] >> 4) & 0x0f;
9903#line 358 "rx-decode.opc"
9904 int rdst AU = op[2] & 0x0f;
9905 if (trace)
9906 {
9907 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9908 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9909 op[0], op[1], op[2]);
9910 printf (" p = 0x%x,", p);
9911 printf (" sz = 0x%x,", sz);
9912 printf (" rsrc = 0x%x,", rsrc);
9913 printf (" rdst = 0x%x\n", rdst);
9914 }
9915 SYNTAX("movu%s %1, %0");
9916#line 358 "rx-decode.opc"
9917 ID(mov); uBW (sz); DR(rdst); F_____;
9918 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9919
9920 /*----------------------------------------------------------------------*/
9921 /* PUSH/POP */
9922
9923 }
9924 break;
9925 }
9926 break;
9927 case 0x39:
9928 GETBYTE ();
9929 switch (op[2] & 0x00)
9930 {
9931 case 0x00:
9932 goto op_semantics_73;
9933 break;
9934 }
9935 break;
9936 case 0x3a:
9937 GETBYTE ();
9938 switch (op[2] & 0x00)
9939 {
9940 case 0x00:
9941 goto op_semantics_73;
9942 break;
9943 }
9944 break;
9945 case 0x3c:
9946 GETBYTE ();
9947 switch (op[2] & 0x00)
9948 {
9949 case 0x00:
9950 goto op_semantics_73;
9951 break;
9952 }
9953 break;
9954 case 0x3d:
9955 GETBYTE ();
9956 switch (op[2] & 0x00)
9957 {
9958 case 0x00:
9959 goto op_semantics_73;
9960 break;
9961 }
9962 break;
9963 case 0x3e:
9964 GETBYTE ();
9965 switch (op[2] & 0x00)
9966 {
9967 case 0x00:
9968 goto op_semantics_73;
9969 break;
9970 }
9971 break;
9972 case 0x60:
9973 GETBYTE ();
9974 switch (op[2] & 0x00)
9975 {
9976 case 0x00:
9977 {
9978 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
9979#line 691 "rx-decode.opc"
9980 int rsrc AU = (op[2] >> 4) & 0x0f;
9981#line 691 "rx-decode.opc"
9982 int rdst AU = op[2] & 0x0f;
9983 if (trace)
9984 {
9985 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9986 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9987 op[0], op[1], op[2]);
9988 printf (" rsrc = 0x%x,", rsrc);
9989 printf (" rdst = 0x%x\n", rdst);
9990 }
9991 SYNTAX("shlr %2, %0");
9992#line 691 "rx-decode.opc"
9993 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
9994
9995 }
9996 break;
9997 }
9998 break;
9999 case 0x61:
10000 GETBYTE ();
10001 switch (op[2] & 0x00)
10002 {
10003 case 0x00:
10004 {
10005 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
10006#line 681 "rx-decode.opc"
10007 int rsrc AU = (op[2] >> 4) & 0x0f;
10008#line 681 "rx-decode.opc"
10009 int rdst AU = op[2] & 0x0f;
10010 if (trace)
10011 {
10012 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10013 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
10014 op[0], op[1], op[2]);
10015 printf (" rsrc = 0x%x,", rsrc);
10016 printf (" rdst = 0x%x\n", rdst);
10017 }
10018 SYNTAX("shar %2, %0");
10019#line 681 "rx-decode.opc"
10020 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
10021
10022 }
10023 break;
10024 }
10025 break;
10026 case 0x62:
10027 GETBYTE ();
10028 switch (op[2] & 0x00)
10029 {
10030 case 0x00:
10031 {
10032 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
10033#line 671 "rx-decode.opc"
10034 int rsrc AU = (op[2] >> 4) & 0x0f;
10035#line 671 "rx-decode.opc"
10036 int rdst AU = op[2] & 0x0f;
10037 if (trace)
10038 {
10039 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10040 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
10041 op[0], op[1], op[2]);
10042 printf (" rsrc = 0x%x,", rsrc);
10043 printf (" rdst = 0x%x\n", rdst);
10044 }
10045 SYNTAX("shll %2, %0");
10046#line 671 "rx-decode.opc"
10047 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
10048
10049 }
10050 break;
10051 }
10052 break;
10053 case 0x64:
10054 GETBYTE ();
10055 switch (op[2] & 0x00)
10056 {
10057 case 0x00:
10058 {
10059 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
10060#line 715 "rx-decode.opc"
10061 int rsrc AU = (op[2] >> 4) & 0x0f;
10062#line 715 "rx-decode.opc"
10063 int rdst AU = op[2] & 0x0f;
10064 if (trace)
10065 {
10066 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10067 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
10068 op[0], op[1], op[2]);
10069 printf (" rsrc = 0x%x,", rsrc);
10070 printf (" rdst = 0x%x\n", rdst);
10071 }
10072 SYNTAX("rotr %1, %0");
10073#line 715 "rx-decode.opc"
10074 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
10075
10076 }
10077 break;
10078 }
10079 break;
10080 case 0x65:
10081 GETBYTE ();
10082 switch (op[2] & 0x00)
10083 {
10084 case 0x00:
10085 {
10086 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
10087#line 718 "rx-decode.opc"
10088 int rsrc AU = (op[2] >> 4) & 0x0f;
10089#line 718 "rx-decode.opc"
10090 int rdst AU = op[2] & 0x0f;
10091 if (trace)
10092 {
10093 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10094 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10095 op[0], op[1], op[2]);
10096 printf (" rsrc = 0x%x,", rsrc);
10097 printf (" rdst = 0x%x\n", rdst);
10098 }
10099 SYNTAX("revw %1, %0");
10100#line 718 "rx-decode.opc"
10101 ID(revw); SR(rsrc); DR(rdst);
10102
10103 }
10104 break;
10105 }
10106 break;
10107 case 0x66:
10108 GETBYTE ();
10109 switch (op[2] & 0x00)
10110 {
10111 case 0x00:
10112 {
10113 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
10114#line 709 "rx-decode.opc"
10115 int rsrc AU = (op[2] >> 4) & 0x0f;
10116#line 709 "rx-decode.opc"
10117 int rdst AU = op[2] & 0x0f;
10118 if (trace)
10119 {
10120 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10121 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10122 op[0], op[1], op[2]);
10123 printf (" rsrc = 0x%x,", rsrc);
10124 printf (" rdst = 0x%x\n", rdst);
10125 }
10126 SYNTAX("rotl %1, %0");
10127#line 709 "rx-decode.opc"
10128 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
10129
10130 }
10131 break;
10132 }
10133 break;
10134 case 0x67:
10135 GETBYTE ();
10136 switch (op[2] & 0x00)
10137 {
10138 case 0x00:
10139 {
10140 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
10141#line 721 "rx-decode.opc"
10142 int rsrc AU = (op[2] >> 4) & 0x0f;
10143#line 721 "rx-decode.opc"
10144 int rdst AU = op[2] & 0x0f;
10145 if (trace)
10146 {
10147 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10148 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10149 op[0], op[1], op[2]);
10150 printf (" rsrc = 0x%x,", rsrc);
10151 printf (" rdst = 0x%x\n", rdst);
10152 }
10153 SYNTAX("revl %1, %0");
10154#line 721 "rx-decode.opc"
10155 ID(revl); SR(rsrc); DR(rdst);
10156
10157 /*----------------------------------------------------------------------*/
10158 /* BRANCH */
10159
10160 }
10161 break;
10162 }
10163 break;
10164 case 0x68:
10165 GETBYTE ();
10166 switch (op[2] & 0x00)
10167 {
10168 case 0x00:
10169 op_semantics_74:
10170 {
10171 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
10172#line 972 "rx-decode.opc"
10173 int c AU = op[1] & 0x01;
10174#line 972 "rx-decode.opc"
10175 int rsrc AU = (op[2] >> 4) & 0x0f;
10176#line 972 "rx-decode.opc"
10177 int rdst AU = op[2] & 0x0f;
10178 if (trace)
10179 {
10180 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10181 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10182 op[0], op[1], op[2]);
10183 printf (" c = 0x%x,", c);
10184 printf (" rsrc = 0x%x,", rsrc);
10185 printf (" rdst = 0x%x\n", rdst);
10186 }
10187 SYNTAX("mvtc %1, %0");
10188#line 972 "rx-decode.opc"
10189 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10190
10191 }
10192 break;
10193 }
10194 break;
10195 case 0x69:
10196 GETBYTE ();
10197 switch (op[2] & 0x00)
10198 {
10199 case 0x00:
10200 goto op_semantics_74;
10201 break;
10202 }
10203 break;
10204 case 0x6a:
10205 GETBYTE ();
10206 switch (op[2] & 0x00)
10207 {
10208 case 0x00:
10209 op_semantics_75:
10210 {
10211 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
10212#line 975 "rx-decode.opc"
10213 int s AU = op[1] & 0x01;
10214#line 975 "rx-decode.opc"
10215 int rsrc AU = (op[2] >> 4) & 0x0f;
10216#line 975 "rx-decode.opc"
10217 int rdst AU = op[2] & 0x0f;
10218 if (trace)
10219 {
10220 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10221 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10222 op[0], op[1], op[2]);
10223 printf (" s = 0x%x,", s);
10224 printf (" rsrc = 0x%x,", rsrc);
10225 printf (" rdst = 0x%x\n", rdst);
10226 }
10227 SYNTAX("mvfc %1, %0");
10228#line 975 "rx-decode.opc"
10229 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10230
10231 /*----------------------------------------------------------------------*/
10232 /* INTERRUPTS */
10233
10234 }
10235 break;
10236 }
10237 break;
10238 case 0x6b:
10239 GETBYTE ();
10240 switch (op[2] & 0x00)
10241 {
10242 case 0x00:
10243 goto op_semantics_75;
10244 break;
10245 }
10246 break;
10247 case 0x6c:
10248 GETBYTE ();
10249 switch (op[2] & 0x00)
10250 {
10251 case 0x00:
10252 op_semantics_76:
10253 {
10254 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
10255#line 712 "rx-decode.opc"
10256 int i AU = op[1] & 0x01;
10257#line 712 "rx-decode.opc"
10258 int mmmm AU = (op[2] >> 4) & 0x0f;
10259#line 712 "rx-decode.opc"
10260 int rdst AU = op[2] & 0x0f;
10261 if (trace)
10262 {
10263 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10264 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10265 op[0], op[1], op[2]);
10266 printf (" i = 0x%x,", i);
10267 printf (" mmmm = 0x%x,", mmmm);
10268 printf (" rdst = 0x%x\n", rdst);
10269 }
10270 SYNTAX("rotr #%1, %0");
10271#line 712 "rx-decode.opc"
10272 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
10273
10274 }
10275 break;
10276 }
10277 break;
10278 case 0x6d:
10279 GETBYTE ();
10280 switch (op[2] & 0x00)
10281 {
10282 case 0x00:
10283 goto op_semantics_76;
10284 break;
10285 }
10286 break;
10287 case 0x6e:
10288 GETBYTE ();
10289 switch (op[2] & 0x00)
10290 {
10291 case 0x00:
10292 op_semantics_77:
10293 {
10294 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
10295#line 706 "rx-decode.opc"
10296 int i AU = op[1] & 0x01;
10297#line 706 "rx-decode.opc"
10298 int mmmm AU = (op[2] >> 4) & 0x0f;
10299#line 706 "rx-decode.opc"
10300 int rdst AU = op[2] & 0x0f;
10301 if (trace)
10302 {
10303 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10304 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10305 op[0], op[1], op[2]);
10306 printf (" i = 0x%x,", i);
10307 printf (" mmmm = 0x%x,", mmmm);
10308 printf (" rdst = 0x%x\n", rdst);
10309 }
10310 SYNTAX("rotl #%1, %0");
10311#line 706 "rx-decode.opc"
10312 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
10313
10314 }
10315 break;
10316 }
10317 break;
10318 case 0x6f:
10319 GETBYTE ();
10320 switch (op[2] & 0x00)
10321 {
10322 case 0x00:
10323 goto op_semantics_77;
10324 break;
10325 }
10326 break;
10327 case 0x70:
10328 GETBYTE ();
10329 switch (op[2] & 0xf0)
10330 {
10331 case 0x20:
10332 op_semantics_78:
10333 {
10334 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
10335#line 488 "rx-decode.opc"
10336 int im AU = (op[1] >> 2) & 0x03;
10337#line 488 "rx-decode.opc"
10338 int rdst AU = op[2] & 0x0f;
10339 if (trace)
10340 {
10341 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10342 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10343 op[0], op[1], op[2]);
10344 printf (" im = 0x%x,", im);
10345 printf (" rdst = 0x%x\n", rdst);
10346 }
10347 SYNTAX("adc #%1, %0");
10348#line 488 "rx-decode.opc"
10349 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
10350
10351 }
10352 break;
10353 case 0x40:
10354 op_semantics_79:
10355 {
10356 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
10357#line 570 "rx-decode.opc"
10358 int im AU = (op[1] >> 2) & 0x03;
10359#line 570 "rx-decode.opc"
10360 int rdst AU = op[2] & 0x0f;
10361 int val = IMMex (im);
10362 if (trace)
10363 {
10364 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10365 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10366 op[0], op[1], op[2]);
10367 printf (" im = 0x%x,", im);
10368 printf (" rdst = 0x%x\n", rdst);
10369 }
10370 SYNTAX("max #%1, %0");
10371#line 570 "rx-decode.opc"
10372 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
10373 {
10374 ID(nop7);
10375 SYNTAX ("nop\t; max\t#0x80000000, r0");
10376 }
10377 else
10378 {
10379 ID(max);
10380 }
10381 DR(rdst); SC(val);
10382 }
10383 break;
10384 case 0x50:
10385 op_semantics_80:
10386 {
10387 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
10388#line 590 "rx-decode.opc"
10389 int im AU = (op[1] >> 2) & 0x03;
10390#line 590 "rx-decode.opc"
10391 int rdst AU = op[2] & 0x0f;
10392 if (trace)
10393 {
10394 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10395 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10396 op[0], op[1], op[2]);
10397 printf (" im = 0x%x,", im);
10398 printf (" rdst = 0x%x\n", rdst);
10399 }
10400 SYNTAX("min #%1, %0");
10401#line 590 "rx-decode.opc"
10402 ID(min); DR(rdst); SC(IMMex(im));
10403
10404 }
10405 break;
10406 case 0x60:
10407 op_semantics_81:
10408 {
10409 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
10410#line 620 "rx-decode.opc"
10411 int im AU = (op[1] >> 2) & 0x03;
10412#line 620 "rx-decode.opc"
10413 int rdst AU = op[2] & 0x0f;
10414 if (trace)
10415 {
10416 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10417 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10418 op[0], op[1], op[2]);
10419 printf (" im = 0x%x,", im);
10420 printf (" rdst = 0x%x\n", rdst);
10421 }
10422 SYNTAX("emul #%1, %0");
10423#line 620 "rx-decode.opc"
10424 ID(emul); DR(rdst); SC(IMMex(im));
10425
10426 }
10427 break;
10428 case 0x70:
10429 op_semantics_82:
10430 {
10431 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
10432#line 632 "rx-decode.opc"
10433 int im AU = (op[1] >> 2) & 0x03;
10434#line 632 "rx-decode.opc"
10435 int rdst AU = op[2] & 0x0f;
10436 if (trace)
10437 {
10438 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10439 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10440 op[0], op[1], op[2]);
10441 printf (" im = 0x%x,", im);
10442 printf (" rdst = 0x%x\n", rdst);
10443 }
10444 SYNTAX("emulu #%1, %0");
10445#line 632 "rx-decode.opc"
10446 ID(emulu); DR(rdst); SC(IMMex(im));
10447
10448 }
10449 break;
10450 case 0x80:
10451 op_semantics_83:
10452 {
10453 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
10454#line 644 "rx-decode.opc"
10455 int im AU = (op[1] >> 2) & 0x03;
10456#line 644 "rx-decode.opc"
10457 int rdst AU = op[2] & 0x0f;
10458 if (trace)
10459 {
10460 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10461 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10462 op[0], op[1], op[2]);
10463 printf (" im = 0x%x,", im);
10464 printf (" rdst = 0x%x\n", rdst);
10465 }
10466 SYNTAX("div #%1, %0");
10467#line 644 "rx-decode.opc"
10468 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
10469
10470 }
10471 break;
10472 case 0x90:
10473 op_semantics_84:
10474 {
10475 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
10476#line 656 "rx-decode.opc"
10477 int im AU = (op[1] >> 2) & 0x03;
10478#line 656 "rx-decode.opc"
10479 int rdst AU = op[2] & 0x0f;
10480 if (trace)
10481 {
10482 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10483 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10484 op[0], op[1], op[2]);
10485 printf (" im = 0x%x,", im);
10486 printf (" rdst = 0x%x\n", rdst);
10487 }
10488 SYNTAX("divu #%1, %0");
10489#line 656 "rx-decode.opc"
10490 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
10491
10492 }
10493 break;
10494 case 0xc0:
10495 op_semantics_85:
10496 {
10497 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
10498#line 467 "rx-decode.opc"
10499 int im AU = (op[1] >> 2) & 0x03;
10500#line 467 "rx-decode.opc"
10501 int rdst AU = op[2] & 0x0f;
10502 if (trace)
10503 {
10504 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10505 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
10506 op[0], op[1], op[2]);
10507 printf (" im = 0x%x,", im);
10508 printf (" rdst = 0x%x\n", rdst);
10509 }
10510 SYNTAX("tst #%1, %2");
10511#line 467 "rx-decode.opc"
10512 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
10513
10514 }
10515 break;
10516 case 0xd0:
10517 op_semantics_86:
10518 {
10519 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
10520#line 446 "rx-decode.opc"
10521 int im AU = (op[1] >> 2) & 0x03;
10522#line 446 "rx-decode.opc"
10523 int rdst AU = op[2] & 0x0f;
10524 if (trace)
10525 {
10526 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10527 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10528 op[0], op[1], op[2]);
10529 printf (" im = 0x%x,", im);
10530 printf (" rdst = 0x%x\n", rdst);
10531 }
10532 SYNTAX("xor #%1, %0");
10533#line 446 "rx-decode.opc"
10534 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
10535
10536 }
10537 break;
10538 case 0xe0:
10539 op_semantics_87:
10540 {
10541 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
10542#line 392 "rx-decode.opc"
10543 int im AU = (op[1] >> 2) & 0x03;
10544#line 392 "rx-decode.opc"
10545 int rdst AU = op[2] & 0x0f;
10546 if (trace)
10547 {
10548 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10549 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10550 op[0], op[1], op[2]);
10551 printf (" im = 0x%x,", im);
10552 printf (" rdst = 0x%x\n", rdst);
10553 }
10554 SYNTAX("stz #%1, %0");
10555#line 392 "rx-decode.opc"
10556 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10557
10558 }
10559 break;
10560 case 0xf0:
10561 op_semantics_88:
10562 {
10563 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
10564#line 395 "rx-decode.opc"
10565 int im AU = (op[1] >> 2) & 0x03;
10566#line 395 "rx-decode.opc"
10567 int rdst AU = op[2] & 0x0f;
10568 if (trace)
10569 {
10570 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10571 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10572 op[0], op[1], op[2]);
10573 printf (" im = 0x%x,", im);
10574 printf (" rdst = 0x%x\n", rdst);
10575 }
10576 SYNTAX("stnz #%1, %0");
10577#line 395 "rx-decode.opc"
10578 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10579
10580 /*----------------------------------------------------------------------*/
10581 /* RTSD */
10582
10583 }
10584 break;
10585 default: UNSUPPORTED(); break;
10586 }
10587 break;
10588 case 0x72:
10589 GETBYTE ();
10590 switch (op[2] & 0xf0)
10591 {
10592 case 0x00:
10593 {
10594 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
10595#line 864 "rx-decode.opc"
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 0000 rdst fsub #%1, %0 */",
10601 op[0], op[1], op[2]);
10602 printf (" rdst = 0x%x\n", rdst);
10603 }
10604 SYNTAX("fsub #%1, %0");
10605#line 864 "rx-decode.opc"
10606 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
10607
10608 }
10609 break;
10610 case 0x10:
10611 {
10612 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
10613#line 858 "rx-decode.opc"
10614 int rdst AU = op[2] & 0x0f;
10615 if (trace)
10616 {
10617 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10618 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10619 op[0], op[1], op[2]);
10620 printf (" rdst = 0x%x\n", rdst);
10621 }
10622 SYNTAX("fcmp #%1, %0");
10623#line 858 "rx-decode.opc"
10624 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
10625
10626 }
10627 break;
10628 case 0x20:
10629 {
10630 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
10631#line 852 "rx-decode.opc"
10632 int rdst AU = op[2] & 0x0f;
10633 if (trace)
10634 {
10635 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10636 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10637 op[0], op[1], op[2]);
10638 printf (" rdst = 0x%x\n", rdst);
10639 }
10640 SYNTAX("fadd #%1, %0");
10641#line 852 "rx-decode.opc"
10642 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
10643
10644 }
10645 break;
10646 case 0x30:
10647 {
10648 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
10649#line 873 "rx-decode.opc"
10650 int rdst AU = op[2] & 0x0f;
10651 if (trace)
10652 {
10653 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10654 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10655 op[0], op[1], op[2]);
10656 printf (" rdst = 0x%x\n", rdst);
10657 }
10658 SYNTAX("fmul #%1, %0");
10659#line 873 "rx-decode.opc"
10660 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
10661
10662 }
10663 break;
10664 case 0x40:
10665 {
10666 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
10667#line 879 "rx-decode.opc"
10668 int rdst AU = op[2] & 0x0f;
10669 if (trace)
10670 {
10671 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10672 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10673 op[0], op[1], op[2]);
10674 printf (" rdst = 0x%x\n", rdst);
10675 }
10676 SYNTAX("fdiv #%1, %0");
10677#line 879 "rx-decode.opc"
10678 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
10679
10680 }
10681 break;
10682 default: UNSUPPORTED(); break;
10683 }
10684 break;
10685 case 0x73:
10686 GETBYTE ();
10687 switch (op[2] & 0xe0)
10688 {
10689 case 0x00:
10690 op_semantics_89:
10691 {
10692 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
10693#line 969 "rx-decode.opc"
10694 int im AU = (op[1] >> 2) & 0x03;
10695#line 969 "rx-decode.opc"
10696 int crdst AU = op[2] & 0x1f;
10697 if (trace)
10698 {
10699 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10700 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10701 op[0], op[1], op[2]);
10702 printf (" im = 0x%x,", im);
10703 printf (" crdst = 0x%x\n", crdst);
10704 }
10705 SYNTAX("mvtc #%1, %0");
10706#line 969 "rx-decode.opc"
10707 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10708
10709 }
10710 break;
10711 default: UNSUPPORTED(); break;
10712 }
10713 break;
10714 case 0x74:
10715 GETBYTE ();
10716 switch (op[2] & 0xf0)
10717 {
10718 case 0x20:
10719 goto op_semantics_78;
10720 break;
10721 case 0x40:
10722 goto op_semantics_79;
10723 break;
10724 case 0x50:
10725 goto op_semantics_80;
10726 break;
10727 case 0x60:
10728 goto op_semantics_81;
10729 break;
10730 case 0x70:
10731 goto op_semantics_82;
10732 break;
10733 case 0x80:
10734 goto op_semantics_83;
10735 break;
10736 case 0x90:
10737 goto op_semantics_84;
10738 break;
10739 case 0xc0:
10740 goto op_semantics_85;
10741 break;
10742 case 0xd0:
10743 goto op_semantics_86;
10744 break;
10745 case 0xe0:
10746 goto op_semantics_87;
10747 break;
10748 case 0xf0:
10749 goto op_semantics_88;
10750 break;
10751 default: UNSUPPORTED(); break;
10752 }
10753 break;
10754 case 0x77:
10755 GETBYTE ();
10756 switch (op[2] & 0xe0)
10757 {
10758 case 0x00:
10759 goto op_semantics_89;
10760 break;
10761 default: UNSUPPORTED(); break;
10762 }
10763 break;
10764 case 0x78:
10765 GETBYTE ();
10766 switch (op[2] & 0xf0)
10767 {
10768 case 0x20:
10769 goto op_semantics_78;
10770 break;
10771 case 0x40:
10772 goto op_semantics_79;
10773 break;
10774 case 0x50:
10775 goto op_semantics_80;
10776 break;
10777 case 0x60:
10778 goto op_semantics_81;
10779 break;
10780 case 0x70:
10781 goto op_semantics_82;
10782 break;
10783 case 0x80:
10784 goto op_semantics_83;
10785 break;
10786 case 0x90:
10787 goto op_semantics_84;
10788 break;
10789 case 0xc0:
10790 goto op_semantics_85;
10791 break;
10792 case 0xd0:
10793 goto op_semantics_86;
10794 break;
10795 case 0xe0:
10796 goto op_semantics_87;
10797 break;
10798 case 0xf0:
10799 goto op_semantics_88;
10800 break;
10801 default: UNSUPPORTED(); break;
10802 }
10803 break;
10804 case 0x7b:
10805 GETBYTE ();
10806 switch (op[2] & 0xe0)
10807 {
10808 case 0x00:
10809 goto op_semantics_89;
10810 break;
10811 default: UNSUPPORTED(); break;
10812 }
10813 break;
10814 case 0x7c:
10815 GETBYTE ();
10816 switch (op[2] & 0xf0)
10817 {
10818 case 0x20:
10819 goto op_semantics_78;
10820 break;
10821 case 0x40:
10822 goto op_semantics_79;
10823 break;
10824 case 0x50:
10825 goto op_semantics_80;
10826 break;
10827 case 0x60:
10828 goto op_semantics_81;
10829 break;
10830 case 0x70:
10831 goto op_semantics_82;
10832 break;
10833 case 0x80:
10834 goto op_semantics_83;
10835 break;
10836 case 0x90:
10837 goto op_semantics_84;
10838 break;
10839 case 0xc0:
10840 goto op_semantics_85;
10841 break;
10842 case 0xd0:
10843 goto op_semantics_86;
10844 break;
10845 case 0xe0:
10846 goto op_semantics_87;
10847 break;
10848 case 0xf0:
10849 goto op_semantics_88;
10850 break;
10851 default: UNSUPPORTED(); break;
10852 }
10853 break;
10854 case 0x7f:
10855 GETBYTE ();
10856 switch (op[2] & 0xe0)
10857 {
10858 case 0x00:
10859 goto op_semantics_89;
10860 break;
10861 default: UNSUPPORTED(); break;
10862 }
10863 break;
10864 case 0x80:
10865 GETBYTE ();
10866 switch (op[2] & 0x00)
10867 {
10868 case 0x00:
10869 op_semantics_90:
10870 {
10871 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
10872#line 694 "rx-decode.opc"
10873 int immmm AU = op[1] & 0x1f;
10874#line 694 "rx-decode.opc"
10875 int rsrc AU = (op[2] >> 4) & 0x0f;
10876#line 694 "rx-decode.opc"
10877 int rdst AU = op[2] & 0x0f;
10878 if (trace)
10879 {
10880 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10881 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10882 op[0], op[1], op[2]);
10883 printf (" immmm = 0x%x,", immmm);
10884 printf (" rsrc = 0x%x,", rsrc);
10885 printf (" rdst = 0x%x\n", rdst);
10886 }
10887 SYNTAX("shlr #%2, %1, %0");
10888#line 694 "rx-decode.opc"
10889 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
10890
10891 /*----------------------------------------------------------------------*/
10892 /* ROTATE */
10893
10894 }
10895 break;
10896 }
10897 break;
10898 case 0x81:
10899 GETBYTE ();
10900 switch (op[2] & 0x00)
10901 {
10902 case 0x00:
10903 goto op_semantics_90;
10904 break;
10905 }
10906 break;
10907 case 0x82:
10908 GETBYTE ();
10909 switch (op[2] & 0x00)
10910 {
10911 case 0x00:
10912 goto op_semantics_90;
10913 break;
10914 }
10915 break;
10916 case 0x83:
10917 GETBYTE ();
10918 switch (op[2] & 0x00)
10919 {
10920 case 0x00:
10921 goto op_semantics_90;
10922 break;
10923 }
10924 break;
10925 case 0x84:
10926 GETBYTE ();
10927 switch (op[2] & 0x00)
10928 {
10929 case 0x00:
10930 goto op_semantics_90;
10931 break;
10932 }
10933 break;
10934 case 0x85:
10935 GETBYTE ();
10936 switch (op[2] & 0x00)
10937 {
10938 case 0x00:
10939 goto op_semantics_90;
10940 break;
10941 }
10942 break;
10943 case 0x86:
10944 GETBYTE ();
10945 switch (op[2] & 0x00)
10946 {
10947 case 0x00:
10948 goto op_semantics_90;
10949 break;
10950 }
10951 break;
10952 case 0x87:
10953 GETBYTE ();
10954 switch (op[2] & 0x00)
10955 {
10956 case 0x00:
10957 goto op_semantics_90;
10958 break;
10959 }
10960 break;
10961 case 0x88:
10962 GETBYTE ();
10963 switch (op[2] & 0x00)
10964 {
10965 case 0x00:
10966 goto op_semantics_90;
10967 break;
10968 }
10969 break;
10970 case 0x89:
10971 GETBYTE ();
10972 switch (op[2] & 0x00)
10973 {
10974 case 0x00:
10975 goto op_semantics_90;
10976 break;
10977 }
10978 break;
10979 case 0x8a:
10980 GETBYTE ();
10981 switch (op[2] & 0x00)
10982 {
10983 case 0x00:
10984 goto op_semantics_90;
10985 break;
10986 }
10987 break;
10988 case 0x8b:
10989 GETBYTE ();
10990 switch (op[2] & 0x00)
10991 {
10992 case 0x00:
10993 goto op_semantics_90;
10994 break;
10995 }
10996 break;
10997 case 0x8c:
10998 GETBYTE ();
10999 switch (op[2] & 0x00)
11000 {
11001 case 0x00:
11002 goto op_semantics_90;
11003 break;
11004 }
11005 break;
11006 case 0x8d:
11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11009 {
11010 case 0x00:
11011 goto op_semantics_90;
11012 break;
11013 }
11014 break;
11015 case 0x8e:
11016 GETBYTE ();
11017 switch (op[2] & 0x00)
11018 {
11019 case 0x00:
11020 goto op_semantics_90;
11021 break;
11022 }
11023 break;
11024 case 0x8f:
11025 GETBYTE ();
11026 switch (op[2] & 0x00)
11027 {
11028 case 0x00:
11029 goto op_semantics_90;
11030 break;
11031 }
11032 break;
11033 case 0x90:
11034 GETBYTE ();
11035 switch (op[2] & 0x00)
11036 {
11037 case 0x00:
11038 goto op_semantics_90;
11039 break;
11040 }
11041 break;
11042 case 0x91:
11043 GETBYTE ();
11044 switch (op[2] & 0x00)
11045 {
11046 case 0x00:
11047 goto op_semantics_90;
11048 break;
11049 }
11050 break;
11051 case 0x92:
11052 GETBYTE ();
11053 switch (op[2] & 0x00)
11054 {
11055 case 0x00:
11056 goto op_semantics_90;
11057 break;
11058 }
11059 break;
11060 case 0x93:
11061 GETBYTE ();
11062 switch (op[2] & 0x00)
11063 {
11064 case 0x00:
11065 goto op_semantics_90;
11066 break;
11067 }
11068 break;
11069 case 0x94:
11070 GETBYTE ();
11071 switch (op[2] & 0x00)
11072 {
11073 case 0x00:
11074 goto op_semantics_90;
11075 break;
11076 }
11077 break;
11078 case 0x95:
11079 GETBYTE ();
11080 switch (op[2] & 0x00)
11081 {
11082 case 0x00:
11083 goto op_semantics_90;
11084 break;
11085 }
11086 break;
11087 case 0x96:
11088 GETBYTE ();
11089 switch (op[2] & 0x00)
11090 {
11091 case 0x00:
11092 goto op_semantics_90;
11093 break;
11094 }
11095 break;
11096 case 0x97:
11097 GETBYTE ();
11098 switch (op[2] & 0x00)
11099 {
11100 case 0x00:
11101 goto op_semantics_90;
11102 break;
11103 }
11104 break;
11105 case 0x98:
11106 GETBYTE ();
11107 switch (op[2] & 0x00)
11108 {
11109 case 0x00:
11110 goto op_semantics_90;
11111 break;
11112 }
11113 break;
11114 case 0x99:
11115 GETBYTE ();
11116 switch (op[2] & 0x00)
11117 {
11118 case 0x00:
11119 goto op_semantics_90;
11120 break;
11121 }
11122 break;
11123 case 0x9a:
11124 GETBYTE ();
11125 switch (op[2] & 0x00)
11126 {
11127 case 0x00:
11128 goto op_semantics_90;
11129 break;
11130 }
11131 break;
11132 case 0x9b:
11133 GETBYTE ();
11134 switch (op[2] & 0x00)
11135 {
11136 case 0x00:
11137 goto op_semantics_90;
11138 break;
11139 }
11140 break;
11141 case 0x9c:
11142 GETBYTE ();
11143 switch (op[2] & 0x00)
11144 {
11145 case 0x00:
11146 goto op_semantics_90;
11147 break;
11148 }
11149 break;
11150 case 0x9d:
11151 GETBYTE ();
11152 switch (op[2] & 0x00)
11153 {
11154 case 0x00:
11155 goto op_semantics_90;
11156 break;
11157 }
11158 break;
11159 case 0x9e:
11160 GETBYTE ();
11161 switch (op[2] & 0x00)
11162 {
11163 case 0x00:
11164 goto op_semantics_90;
11165 break;
11166 }
11167 break;
11168 case 0x9f:
11169 GETBYTE ();
11170 switch (op[2] & 0x00)
11171 {
11172 case 0x00:
11173 goto op_semantics_90;
11174 break;
11175 }
11176 break;
11177 case 0xa0:
11178 GETBYTE ();
11179 switch (op[2] & 0x00)
11180 {
11181 case 0x00:
11182 op_semantics_91:
11183 {
11184 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
11185#line 684 "rx-decode.opc"
11186 int immmm AU = op[1] & 0x1f;
11187#line 684 "rx-decode.opc"
11188 int rsrc AU = (op[2] >> 4) & 0x0f;
11189#line 684 "rx-decode.opc"
11190 int rdst AU = op[2] & 0x0f;
11191 if (trace)
11192 {
11193 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11194 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11195 op[0], op[1], op[2]);
11196 printf (" immmm = 0x%x,", immmm);
11197 printf (" rsrc = 0x%x,", rsrc);
11198 printf (" rdst = 0x%x\n", rdst);
11199 }
11200 SYNTAX("shar #%2, %1, %0");
11201#line 684 "rx-decode.opc"
11202 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
11203
11204
11205 }
11206 break;
11207 }
11208 break;
11209 case 0xa1:
11210 GETBYTE ();
11211 switch (op[2] & 0x00)
11212 {
11213 case 0x00:
11214 goto op_semantics_91;
11215 break;
11216 }
11217 break;
11218 case 0xa2:
11219 GETBYTE ();
11220 switch (op[2] & 0x00)
11221 {
11222 case 0x00:
11223 goto op_semantics_91;
11224 break;
11225 }
11226 break;
11227 case 0xa3:
11228 GETBYTE ();
11229 switch (op[2] & 0x00)
11230 {
11231 case 0x00:
11232 goto op_semantics_91;
11233 break;
11234 }
11235 break;
11236 case 0xa4:
11237 GETBYTE ();
11238 switch (op[2] & 0x00)
11239 {
11240 case 0x00:
11241 goto op_semantics_91;
11242 break;
11243 }
11244 break;
11245 case 0xa5:
11246 GETBYTE ();
11247 switch (op[2] & 0x00)
11248 {
11249 case 0x00:
11250 goto op_semantics_91;
11251 break;
11252 }
11253 break;
11254 case 0xa6:
11255 GETBYTE ();
11256 switch (op[2] & 0x00)
11257 {
11258 case 0x00:
11259 goto op_semantics_91;
11260 break;
11261 }
11262 break;
11263 case 0xa7:
11264 GETBYTE ();
11265 switch (op[2] & 0x00)
11266 {
11267 case 0x00:
11268 goto op_semantics_91;
11269 break;
11270 }
11271 break;
11272 case 0xa8:
11273 GETBYTE ();
11274 switch (op[2] & 0x00)
11275 {
11276 case 0x00:
11277 goto op_semantics_91;
11278 break;
11279 }
11280 break;
11281 case 0xa9:
11282 GETBYTE ();
11283 switch (op[2] & 0x00)
11284 {
11285 case 0x00:
11286 goto op_semantics_91;
11287 break;
11288 }
11289 break;
11290 case 0xaa:
11291 GETBYTE ();
11292 switch (op[2] & 0x00)
11293 {
11294 case 0x00:
11295 goto op_semantics_91;
11296 break;
11297 }
11298 break;
11299 case 0xab:
11300 GETBYTE ();
11301 switch (op[2] & 0x00)
11302 {
11303 case 0x00:
11304 goto op_semantics_91;
11305 break;
11306 }
11307 break;
11308 case 0xac:
11309 GETBYTE ();
11310 switch (op[2] & 0x00)
11311 {
11312 case 0x00:
11313 goto op_semantics_91;
11314 break;
11315 }
11316 break;
11317 case 0xad:
11318 GETBYTE ();
11319 switch (op[2] & 0x00)
11320 {
11321 case 0x00:
11322 goto op_semantics_91;
11323 break;
11324 }
11325 break;
11326 case 0xae:
11327 GETBYTE ();
11328 switch (op[2] & 0x00)
11329 {
11330 case 0x00:
11331 goto op_semantics_91;
11332 break;
11333 }
11334 break;
11335 case 0xaf:
11336 GETBYTE ();
11337 switch (op[2] & 0x00)
11338 {
11339 case 0x00:
11340 goto op_semantics_91;
11341 break;
11342 }
11343 break;
11344 case 0xb0:
11345 GETBYTE ();
11346 switch (op[2] & 0x00)
11347 {
11348 case 0x00:
11349 goto op_semantics_91;
11350 break;
11351 }
11352 break;
11353 case 0xb1:
11354 GETBYTE ();
11355 switch (op[2] & 0x00)
11356 {
11357 case 0x00:
11358 goto op_semantics_91;
11359 break;
11360 }
11361 break;
11362 case 0xb2:
11363 GETBYTE ();
11364 switch (op[2] & 0x00)
11365 {
11366 case 0x00:
11367 goto op_semantics_91;
11368 break;
11369 }
11370 break;
11371 case 0xb3:
11372 GETBYTE ();
11373 switch (op[2] & 0x00)
11374 {
11375 case 0x00:
11376 goto op_semantics_91;
11377 break;
11378 }
11379 break;
11380 case 0xb4:
11381 GETBYTE ();
11382 switch (op[2] & 0x00)
11383 {
11384 case 0x00:
11385 goto op_semantics_91;
11386 break;
11387 }
11388 break;
11389 case 0xb5:
11390 GETBYTE ();
11391 switch (op[2] & 0x00)
11392 {
11393 case 0x00:
11394 goto op_semantics_91;
11395 break;
11396 }
11397 break;
11398 case 0xb6:
11399 GETBYTE ();
11400 switch (op[2] & 0x00)
11401 {
11402 case 0x00:
11403 goto op_semantics_91;
11404 break;
11405 }
11406 break;
11407 case 0xb7:
11408 GETBYTE ();
11409 switch (op[2] & 0x00)
11410 {
11411 case 0x00:
11412 goto op_semantics_91;
11413 break;
11414 }
11415 break;
11416 case 0xb8:
11417 GETBYTE ();
11418 switch (op[2] & 0x00)
11419 {
11420 case 0x00:
11421 goto op_semantics_91;
11422 break;
11423 }
11424 break;
11425 case 0xb9:
11426 GETBYTE ();
11427 switch (op[2] & 0x00)
11428 {
11429 case 0x00:
11430 goto op_semantics_91;
11431 break;
11432 }
11433 break;
11434 case 0xba:
11435 GETBYTE ();
11436 switch (op[2] & 0x00)
11437 {
11438 case 0x00:
11439 goto op_semantics_91;
11440 break;
11441 }
11442 break;
11443 case 0xbb:
11444 GETBYTE ();
11445 switch (op[2] & 0x00)
11446 {
11447 case 0x00:
11448 goto op_semantics_91;
11449 break;
11450 }
11451 break;
11452 case 0xbc:
11453 GETBYTE ();
11454 switch (op[2] & 0x00)
11455 {
11456 case 0x00:
11457 goto op_semantics_91;
11458 break;
11459 }
11460 break;
11461 case 0xbd:
11462 GETBYTE ();
11463 switch (op[2] & 0x00)
11464 {
11465 case 0x00:
11466 goto op_semantics_91;
11467 break;
11468 }
11469 break;
11470 case 0xbe:
11471 GETBYTE ();
11472 switch (op[2] & 0x00)
11473 {
11474 case 0x00:
11475 goto op_semantics_91;
11476 break;
11477 }
11478 break;
11479 case 0xbf:
11480 GETBYTE ();
11481 switch (op[2] & 0x00)
11482 {
11483 case 0x00:
11484 goto op_semantics_91;
11485 break;
11486 }
11487 break;
11488 case 0xc0:
11489 GETBYTE ();
11490 switch (op[2] & 0x00)
11491 {
11492 case 0x00:
11493 op_semantics_92:
11494 {
11495 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
11496#line 674 "rx-decode.opc"
11497 int immmm AU = op[1] & 0x1f;
11498#line 674 "rx-decode.opc"
11499 int rsrc AU = (op[2] >> 4) & 0x0f;
11500#line 674 "rx-decode.opc"
11501 int rdst AU = op[2] & 0x0f;
11502 if (trace)
11503 {
11504 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11505 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11506 op[0], op[1], op[2]);
11507 printf (" immmm = 0x%x,", immmm);
11508 printf (" rsrc = 0x%x,", rsrc);
11509 printf (" rdst = 0x%x\n", rdst);
11510 }
11511 SYNTAX("shll #%2, %1, %0");
11512#line 674 "rx-decode.opc"
11513 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
11514
11515
11516 }
11517 break;
11518 }
11519 break;
11520 case 0xc1:
11521 GETBYTE ();
11522 switch (op[2] & 0x00)
11523 {
11524 case 0x00:
11525 goto op_semantics_92;
11526 break;
11527 }
11528 break;
11529 case 0xc2:
11530 GETBYTE ();
11531 switch (op[2] & 0x00)
11532 {
11533 case 0x00:
11534 goto op_semantics_92;
11535 break;
11536 }
11537 break;
11538 case 0xc3:
11539 GETBYTE ();
11540 switch (op[2] & 0x00)
11541 {
11542 case 0x00:
11543 goto op_semantics_92;
11544 break;
11545 }
11546 break;
11547 case 0xc4:
11548 GETBYTE ();
11549 switch (op[2] & 0x00)
11550 {
11551 case 0x00:
11552 goto op_semantics_92;
11553 break;
11554 }
11555 break;
11556 case 0xc5:
11557 GETBYTE ();
11558 switch (op[2] & 0x00)
11559 {
11560 case 0x00:
11561 goto op_semantics_92;
11562 break;
11563 }
11564 break;
11565 case 0xc6:
11566 GETBYTE ();
11567 switch (op[2] & 0x00)
11568 {
11569 case 0x00:
11570 goto op_semantics_92;
11571 break;
11572 }
11573 break;
11574 case 0xc7:
11575 GETBYTE ();
11576 switch (op[2] & 0x00)
11577 {
11578 case 0x00:
11579 goto op_semantics_92;
11580 break;
11581 }
11582 break;
11583 case 0xc8:
11584 GETBYTE ();
11585 switch (op[2] & 0x00)
11586 {
11587 case 0x00:
11588 goto op_semantics_92;
11589 break;
11590 }
11591 break;
11592 case 0xc9:
11593 GETBYTE ();
11594 switch (op[2] & 0x00)
11595 {
11596 case 0x00:
11597 goto op_semantics_92;
11598 break;
11599 }
11600 break;
11601 case 0xca:
11602 GETBYTE ();
11603 switch (op[2] & 0x00)
11604 {
11605 case 0x00:
11606 goto op_semantics_92;
11607 break;
11608 }
11609 break;
11610 case 0xcb:
11611 GETBYTE ();
11612 switch (op[2] & 0x00)
11613 {
11614 case 0x00:
11615 goto op_semantics_92;
11616 break;
11617 }
11618 break;
11619 case 0xcc:
11620 GETBYTE ();
11621 switch (op[2] & 0x00)
11622 {
11623 case 0x00:
11624 goto op_semantics_92;
11625 break;
11626 }
11627 break;
11628 case 0xcd:
11629 GETBYTE ();
11630 switch (op[2] & 0x00)
11631 {
11632 case 0x00:
11633 goto op_semantics_92;
11634 break;
11635 }
11636 break;
11637 case 0xce:
11638 GETBYTE ();
11639 switch (op[2] & 0x00)
11640 {
11641 case 0x00:
11642 goto op_semantics_92;
11643 break;
11644 }
11645 break;
11646 case 0xcf:
11647 GETBYTE ();
11648 switch (op[2] & 0x00)
11649 {
11650 case 0x00:
11651 goto op_semantics_92;
11652 break;
11653 }
11654 break;
11655 case 0xd0:
11656 GETBYTE ();
11657 switch (op[2] & 0x00)
11658 {
11659 case 0x00:
11660 goto op_semantics_92;
11661 break;
11662 }
11663 break;
11664 case 0xd1:
11665 GETBYTE ();
11666 switch (op[2] & 0x00)
11667 {
11668 case 0x00:
11669 goto op_semantics_92;
11670 break;
11671 }
11672 break;
11673 case 0xd2:
11674 GETBYTE ();
11675 switch (op[2] & 0x00)
11676 {
11677 case 0x00:
11678 goto op_semantics_92;
11679 break;
11680 }
11681 break;
11682 case 0xd3:
11683 GETBYTE ();
11684 switch (op[2] & 0x00)
11685 {
11686 case 0x00:
11687 goto op_semantics_92;
11688 break;
11689 }
11690 break;
11691 case 0xd4:
11692 GETBYTE ();
11693 switch (op[2] & 0x00)
11694 {
11695 case 0x00:
11696 goto op_semantics_92;
11697 break;
11698 }
11699 break;
11700 case 0xd5:
11701 GETBYTE ();
11702 switch (op[2] & 0x00)
11703 {
11704 case 0x00:
11705 goto op_semantics_92;
11706 break;
11707 }
11708 break;
11709 case 0xd6:
11710 GETBYTE ();
11711 switch (op[2] & 0x00)
11712 {
11713 case 0x00:
11714 goto op_semantics_92;
11715 break;
11716 }
11717 break;
11718 case 0xd7:
11719 GETBYTE ();
11720 switch (op[2] & 0x00)
11721 {
11722 case 0x00:
11723 goto op_semantics_92;
11724 break;
11725 }
11726 break;
11727 case 0xd8:
11728 GETBYTE ();
11729 switch (op[2] & 0x00)
11730 {
11731 case 0x00:
11732 goto op_semantics_92;
11733 break;
11734 }
11735 break;
11736 case 0xd9:
11737 GETBYTE ();
11738 switch (op[2] & 0x00)
11739 {
11740 case 0x00:
11741 goto op_semantics_92;
11742 break;
11743 }
11744 break;
11745 case 0xda:
11746 GETBYTE ();
11747 switch (op[2] & 0x00)
11748 {
11749 case 0x00:
11750 goto op_semantics_92;
11751 break;
11752 }
11753 break;
11754 case 0xdb:
11755 GETBYTE ();
11756 switch (op[2] & 0x00)
11757 {
11758 case 0x00:
11759 goto op_semantics_92;
11760 break;
11761 }
11762 break;
11763 case 0xdc:
11764 GETBYTE ();
11765 switch (op[2] & 0x00)
11766 {
11767 case 0x00:
11768 goto op_semantics_92;
11769 break;
11770 }
11771 break;
11772 case 0xdd:
11773 GETBYTE ();
11774 switch (op[2] & 0x00)
11775 {
11776 case 0x00:
11777 goto op_semantics_92;
11778 break;
11779 }
11780 break;
11781 case 0xde:
11782 GETBYTE ();
11783 switch (op[2] & 0x00)
11784 {
11785 case 0x00:
11786 goto op_semantics_92;
11787 break;
11788 }
11789 break;
11790 case 0xdf:
11791 GETBYTE ();
11792 switch (op[2] & 0x00)
11793 {
11794 case 0x00:
11795 goto op_semantics_92;
11796 break;
11797 }
11798 break;
11799 case 0xe0:
11800 GETBYTE ();
11801 switch (op[2] & 0xf0)
11802 {
11803 case 0x00:
11804 case 0x10:
11805 case 0x20:
11806 case 0x30:
11807 case 0x40:
11808 case 0x50:
11809 case 0x60:
11810 case 0x70:
11811 case 0x80:
11812 case 0x90:
11813 case 0xa0:
11814 case 0xb0:
11815 case 0xc0:
11816 case 0xd0:
11817 case 0xe0:
11818 op_semantics_93:
11819 {
11820 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
11821#line 948 "rx-decode.opc"
11822 int bittt AU = op[1] & 0x1f;
11823#line 948 "rx-decode.opc"
11824 int cond AU = (op[2] >> 4) & 0x0f;
11825#line 948 "rx-decode.opc"
11826 int rdst AU = op[2] & 0x0f;
11827 if (trace)
11828 {
11829 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11830 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11831 op[0], op[1], op[2]);
11832 printf (" bittt = 0x%x,", bittt);
11833 printf (" cond = 0x%x,", cond);
11834 printf (" rdst = 0x%x\n", rdst);
11835 }
11836 SYNTAX("bm%2 #%1, %0%S0");
11837#line 948 "rx-decode.opc"
11838 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11839
11840 /*----------------------------------------------------------------------*/
11841 /* CONTROL REGISTERS */
11842
11843 }
11844 break;
11845 case 0xf0:
11846 op_semantics_94:
11847 {
11848 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
11849#line 941 "rx-decode.opc"
11850 int bittt AU = op[1] & 0x1f;
11851#line 941 "rx-decode.opc"
11852 int rdst AU = op[2] & 0x0f;
11853 if (trace)
11854 {
11855 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11856 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11857 op[0], op[1], op[2]);
11858 printf (" bittt = 0x%x,", bittt);
11859 printf (" rdst = 0x%x\n", rdst);
11860 }
11861 SYNTAX("bnot #%1, %0");
11862#line 941 "rx-decode.opc"
11863 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11864
11865
11866 }
11867 break;
11868 }
11869 break;
11870 case 0xe1:
11871 GETBYTE ();
11872 switch (op[2] & 0xf0)
11873 {
11874 case 0x00:
11875 case 0x10:
11876 case 0x20:
11877 case 0x30:
11878 case 0x40:
11879 case 0x50:
11880 case 0x60:
11881 case 0x70:
11882 case 0x80:
11883 case 0x90:
11884 case 0xa0:
11885 case 0xb0:
11886 case 0xc0:
11887 case 0xd0:
11888 case 0xe0:
11889 goto op_semantics_93;
11890 break;
11891 case 0xf0:
11892 goto op_semantics_94;
11893 break;
11894 }
11895 break;
11896 case 0xe2:
11897 GETBYTE ();
11898 switch (op[2] & 0xf0)
11899 {
11900 case 0x00:
11901 case 0x10:
11902 case 0x20:
11903 case 0x30:
11904 case 0x40:
11905 case 0x50:
11906 case 0x60:
11907 case 0x70:
11908 case 0x80:
11909 case 0x90:
11910 case 0xa0:
11911 case 0xb0:
11912 case 0xc0:
11913 case 0xd0:
11914 case 0xe0:
11915 goto op_semantics_93;
11916 break;
11917 case 0xf0:
11918 goto op_semantics_94;
11919 break;
11920 }
11921 break;
11922 case 0xe3:
11923 GETBYTE ();
11924 switch (op[2] & 0xf0)
11925 {
11926 case 0x00:
11927 case 0x10:
11928 case 0x20:
11929 case 0x30:
11930 case 0x40:
11931 case 0x50:
11932 case 0x60:
11933 case 0x70:
11934 case 0x80:
11935 case 0x90:
11936 case 0xa0:
11937 case 0xb0:
11938 case 0xc0:
11939 case 0xd0:
11940 case 0xe0:
11941 goto op_semantics_93;
11942 break;
11943 case 0xf0:
11944 goto op_semantics_94;
11945 break;
11946 }
11947 break;
11948 case 0xe4:
11949 GETBYTE ();
11950 switch (op[2] & 0xf0)
11951 {
11952 case 0x00:
11953 case 0x10:
11954 case 0x20:
11955 case 0x30:
11956 case 0x40:
11957 case 0x50:
11958 case 0x60:
11959 case 0x70:
11960 case 0x80:
11961 case 0x90:
11962 case 0xa0:
11963 case 0xb0:
11964 case 0xc0:
11965 case 0xd0:
11966 case 0xe0:
11967 goto op_semantics_93;
11968 break;
11969 case 0xf0:
11970 goto op_semantics_94;
11971 break;
11972 }
11973 break;
11974 case 0xe5:
11975 GETBYTE ();
11976 switch (op[2] & 0xf0)
11977 {
11978 case 0x00:
11979 case 0x10:
11980 case 0x20:
11981 case 0x30:
11982 case 0x40:
11983 case 0x50:
11984 case 0x60:
11985 case 0x70:
11986 case 0x80:
11987 case 0x90:
11988 case 0xa0:
11989 case 0xb0:
11990 case 0xc0:
11991 case 0xd0:
11992 case 0xe0:
11993 goto op_semantics_93;
11994 break;
11995 case 0xf0:
11996 goto op_semantics_94;
11997 break;
11998 }
11999 break;
12000 case 0xe6:
12001 GETBYTE ();
12002 switch (op[2] & 0xf0)
12003 {
12004 case 0x00:
12005 case 0x10:
12006 case 0x20:
12007 case 0x30:
12008 case 0x40:
12009 case 0x50:
12010 case 0x60:
12011 case 0x70:
12012 case 0x80:
12013 case 0x90:
12014 case 0xa0:
12015 case 0xb0:
12016 case 0xc0:
12017 case 0xd0:
12018 case 0xe0:
12019 goto op_semantics_93;
12020 break;
12021 case 0xf0:
12022 goto op_semantics_94;
12023 break;
12024 }
12025 break;
12026 case 0xe7:
12027 GETBYTE ();
12028 switch (op[2] & 0xf0)
12029 {
12030 case 0x00:
12031 case 0x10:
12032 case 0x20:
12033 case 0x30:
12034 case 0x40:
12035 case 0x50:
12036 case 0x60:
12037 case 0x70:
12038 case 0x80:
12039 case 0x90:
12040 case 0xa0:
12041 case 0xb0:
12042 case 0xc0:
12043 case 0xd0:
12044 case 0xe0:
12045 goto op_semantics_93;
12046 break;
12047 case 0xf0:
12048 goto op_semantics_94;
12049 break;
12050 }
12051 break;
12052 case 0xe8:
12053 GETBYTE ();
12054 switch (op[2] & 0xf0)
12055 {
12056 case 0x00:
12057 case 0x10:
12058 case 0x20:
12059 case 0x30:
12060 case 0x40:
12061 case 0x50:
12062 case 0x60:
12063 case 0x70:
12064 case 0x80:
12065 case 0x90:
12066 case 0xa0:
12067 case 0xb0:
12068 case 0xc0:
12069 case 0xd0:
12070 case 0xe0:
12071 goto op_semantics_93;
12072 break;
12073 case 0xf0:
12074 goto op_semantics_94;
12075 break;
12076 }
12077 break;
12078 case 0xe9:
12079 GETBYTE ();
12080 switch (op[2] & 0xf0)
12081 {
12082 case 0x00:
12083 case 0x10:
12084 case 0x20:
12085 case 0x30:
12086 case 0x40:
12087 case 0x50:
12088 case 0x60:
12089 case 0x70:
12090 case 0x80:
12091 case 0x90:
12092 case 0xa0:
12093 case 0xb0:
12094 case 0xc0:
12095 case 0xd0:
12096 case 0xe0:
12097 goto op_semantics_93;
12098 break;
12099 case 0xf0:
12100 goto op_semantics_94;
12101 break;
12102 }
12103 break;
12104 case 0xea:
12105 GETBYTE ();
12106 switch (op[2] & 0xf0)
12107 {
12108 case 0x00:
12109 case 0x10:
12110 case 0x20:
12111 case 0x30:
12112 case 0x40:
12113 case 0x50:
12114 case 0x60:
12115 case 0x70:
12116 case 0x80:
12117 case 0x90:
12118 case 0xa0:
12119 case 0xb0:
12120 case 0xc0:
12121 case 0xd0:
12122 case 0xe0:
12123 goto op_semantics_93;
12124 break;
12125 case 0xf0:
12126 goto op_semantics_94;
12127 break;
12128 }
12129 break;
12130 case 0xeb:
12131 GETBYTE ();
12132 switch (op[2] & 0xf0)
12133 {
12134 case 0x00:
12135 case 0x10:
12136 case 0x20:
12137 case 0x30:
12138 case 0x40:
12139 case 0x50:
12140 case 0x60:
12141 case 0x70:
12142 case 0x80:
12143 case 0x90:
12144 case 0xa0:
12145 case 0xb0:
12146 case 0xc0:
12147 case 0xd0:
12148 case 0xe0:
12149 goto op_semantics_93;
12150 break;
12151 case 0xf0:
12152 goto op_semantics_94;
12153 break;
12154 }
12155 break;
12156 case 0xec:
12157 GETBYTE ();
12158 switch (op[2] & 0xf0)
12159 {
12160 case 0x00:
12161 case 0x10:
12162 case 0x20:
12163 case 0x30:
12164 case 0x40:
12165 case 0x50:
12166 case 0x60:
12167 case 0x70:
12168 case 0x80:
12169 case 0x90:
12170 case 0xa0:
12171 case 0xb0:
12172 case 0xc0:
12173 case 0xd0:
12174 case 0xe0:
12175 goto op_semantics_93;
12176 break;
12177 case 0xf0:
12178 goto op_semantics_94;
12179 break;
12180 }
12181 break;
12182 case 0xed:
12183 GETBYTE ();
12184 switch (op[2] & 0xf0)
12185 {
12186 case 0x00:
12187 case 0x10:
12188 case 0x20:
12189 case 0x30:
12190 case 0x40:
12191 case 0x50:
12192 case 0x60:
12193 case 0x70:
12194 case 0x80:
12195 case 0x90:
12196 case 0xa0:
12197 case 0xb0:
12198 case 0xc0:
12199 case 0xd0:
12200 case 0xe0:
12201 goto op_semantics_93;
12202 break;
12203 case 0xf0:
12204 goto op_semantics_94;
12205 break;
12206 }
12207 break;
12208 case 0xee:
12209 GETBYTE ();
12210 switch (op[2] & 0xf0)
12211 {
12212 case 0x00:
12213 case 0x10:
12214 case 0x20:
12215 case 0x30:
12216 case 0x40:
12217 case 0x50:
12218 case 0x60:
12219 case 0x70:
12220 case 0x80:
12221 case 0x90:
12222 case 0xa0:
12223 case 0xb0:
12224 case 0xc0:
12225 case 0xd0:
12226 case 0xe0:
12227 goto op_semantics_93;
12228 break;
12229 case 0xf0:
12230 goto op_semantics_94;
12231 break;
12232 }
12233 break;
12234 case 0xef:
12235 GETBYTE ();
12236 switch (op[2] & 0xf0)
12237 {
12238 case 0x00:
12239 case 0x10:
12240 case 0x20:
12241 case 0x30:
12242 case 0x40:
12243 case 0x50:
12244 case 0x60:
12245 case 0x70:
12246 case 0x80:
12247 case 0x90:
12248 case 0xa0:
12249 case 0xb0:
12250 case 0xc0:
12251 case 0xd0:
12252 case 0xe0:
12253 goto op_semantics_93;
12254 break;
12255 case 0xf0:
12256 goto op_semantics_94;
12257 break;
12258 }
12259 break;
12260 case 0xf0:
12261 GETBYTE ();
12262 switch (op[2] & 0xf0)
12263 {
12264 case 0x00:
12265 case 0x10:
12266 case 0x20:
12267 case 0x30:
12268 case 0x40:
12269 case 0x50:
12270 case 0x60:
12271 case 0x70:
12272 case 0x80:
12273 case 0x90:
12274 case 0xa0:
12275 case 0xb0:
12276 case 0xc0:
12277 case 0xd0:
12278 case 0xe0:
12279 goto op_semantics_93;
12280 break;
12281 case 0xf0:
12282 goto op_semantics_94;
12283 break;
12284 }
12285 break;
12286 case 0xf1:
12287 GETBYTE ();
12288 switch (op[2] & 0xf0)
12289 {
12290 case 0x00:
12291 case 0x10:
12292 case 0x20:
12293 case 0x30:
12294 case 0x40:
12295 case 0x50:
12296 case 0x60:
12297 case 0x70:
12298 case 0x80:
12299 case 0x90:
12300 case 0xa0:
12301 case 0xb0:
12302 case 0xc0:
12303 case 0xd0:
12304 case 0xe0:
12305 goto op_semantics_93;
12306 break;
12307 case 0xf0:
12308 goto op_semantics_94;
12309 break;
12310 }
12311 break;
12312 case 0xf2:
12313 GETBYTE ();
12314 switch (op[2] & 0xf0)
12315 {
12316 case 0x00:
12317 case 0x10:
12318 case 0x20:
12319 case 0x30:
12320 case 0x40:
12321 case 0x50:
12322 case 0x60:
12323 case 0x70:
12324 case 0x80:
12325 case 0x90:
12326 case 0xa0:
12327 case 0xb0:
12328 case 0xc0:
12329 case 0xd0:
12330 case 0xe0:
12331 goto op_semantics_93;
12332 break;
12333 case 0xf0:
12334 goto op_semantics_94;
12335 break;
12336 }
12337 break;
12338 case 0xf3:
12339 GETBYTE ();
12340 switch (op[2] & 0xf0)
12341 {
12342 case 0x00:
12343 case 0x10:
12344 case 0x20:
12345 case 0x30:
12346 case 0x40:
12347 case 0x50:
12348 case 0x60:
12349 case 0x70:
12350 case 0x80:
12351 case 0x90:
12352 case 0xa0:
12353 case 0xb0:
12354 case 0xc0:
12355 case 0xd0:
12356 case 0xe0:
12357 goto op_semantics_93;
12358 break;
12359 case 0xf0:
12360 goto op_semantics_94;
12361 break;
12362 }
12363 break;
12364 case 0xf4:
12365 GETBYTE ();
12366 switch (op[2] & 0xf0)
12367 {
12368 case 0x00:
12369 case 0x10:
12370 case 0x20:
12371 case 0x30:
12372 case 0x40:
12373 case 0x50:
12374 case 0x60:
12375 case 0x70:
12376 case 0x80:
12377 case 0x90:
12378 case 0xa0:
12379 case 0xb0:
12380 case 0xc0:
12381 case 0xd0:
12382 case 0xe0:
12383 goto op_semantics_93;
12384 break;
12385 case 0xf0:
12386 goto op_semantics_94;
12387 break;
12388 }
12389 break;
12390 case 0xf5:
12391 GETBYTE ();
12392 switch (op[2] & 0xf0)
12393 {
12394 case 0x00:
12395 case 0x10:
12396 case 0x20:
12397 case 0x30:
12398 case 0x40:
12399 case 0x50:
12400 case 0x60:
12401 case 0x70:
12402 case 0x80:
12403 case 0x90:
12404 case 0xa0:
12405 case 0xb0:
12406 case 0xc0:
12407 case 0xd0:
12408 case 0xe0:
12409 goto op_semantics_93;
12410 break;
12411 case 0xf0:
12412 goto op_semantics_94;
12413 break;
12414 }
12415 break;
12416 case 0xf6:
12417 GETBYTE ();
12418 switch (op[2] & 0xf0)
12419 {
12420 case 0x00:
12421 case 0x10:
12422 case 0x20:
12423 case 0x30:
12424 case 0x40:
12425 case 0x50:
12426 case 0x60:
12427 case 0x70:
12428 case 0x80:
12429 case 0x90:
12430 case 0xa0:
12431 case 0xb0:
12432 case 0xc0:
12433 case 0xd0:
12434 case 0xe0:
12435 goto op_semantics_93;
12436 break;
12437 case 0xf0:
12438 goto op_semantics_94;
12439 break;
12440 }
12441 break;
12442 case 0xf7:
12443 GETBYTE ();
12444 switch (op[2] & 0xf0)
12445 {
12446 case 0x00:
12447 case 0x10:
12448 case 0x20:
12449 case 0x30:
12450 case 0x40:
12451 case 0x50:
12452 case 0x60:
12453 case 0x70:
12454 case 0x80:
12455 case 0x90:
12456 case 0xa0:
12457 case 0xb0:
12458 case 0xc0:
12459 case 0xd0:
12460 case 0xe0:
12461 goto op_semantics_93;
12462 break;
12463 case 0xf0:
12464 goto op_semantics_94;
12465 break;
12466 }
12467 break;
12468 case 0xf8:
12469 GETBYTE ();
12470 switch (op[2] & 0xf0)
12471 {
12472 case 0x00:
12473 case 0x10:
12474 case 0x20:
12475 case 0x30:
12476 case 0x40:
12477 case 0x50:
12478 case 0x60:
12479 case 0x70:
12480 case 0x80:
12481 case 0x90:
12482 case 0xa0:
12483 case 0xb0:
12484 case 0xc0:
12485 case 0xd0:
12486 case 0xe0:
12487 goto op_semantics_93;
12488 break;
12489 case 0xf0:
12490 goto op_semantics_94;
12491 break;
12492 }
12493 break;
12494 case 0xf9:
12495 GETBYTE ();
12496 switch (op[2] & 0xf0)
12497 {
12498 case 0x00:
12499 case 0x10:
12500 case 0x20:
12501 case 0x30:
12502 case 0x40:
12503 case 0x50:
12504 case 0x60:
12505 case 0x70:
12506 case 0x80:
12507 case 0x90:
12508 case 0xa0:
12509 case 0xb0:
12510 case 0xc0:
12511 case 0xd0:
12512 case 0xe0:
12513 goto op_semantics_93;
12514 break;
12515 case 0xf0:
12516 goto op_semantics_94;
12517 break;
12518 }
12519 break;
12520 case 0xfa:
12521 GETBYTE ();
12522 switch (op[2] & 0xf0)
12523 {
12524 case 0x00:
12525 case 0x10:
12526 case 0x20:
12527 case 0x30:
12528 case 0x40:
12529 case 0x50:
12530 case 0x60:
12531 case 0x70:
12532 case 0x80:
12533 case 0x90:
12534 case 0xa0:
12535 case 0xb0:
12536 case 0xc0:
12537 case 0xd0:
12538 case 0xe0:
12539 goto op_semantics_93;
12540 break;
12541 case 0xf0:
12542 goto op_semantics_94;
12543 break;
12544 }
12545 break;
12546 case 0xfb:
12547 GETBYTE ();
12548 switch (op[2] & 0xf0)
12549 {
12550 case 0x00:
12551 case 0x10:
12552 case 0x20:
12553 case 0x30:
12554 case 0x40:
12555 case 0x50:
12556 case 0x60:
12557 case 0x70:
12558 case 0x80:
12559 case 0x90:
12560 case 0xa0:
12561 case 0xb0:
12562 case 0xc0:
12563 case 0xd0:
12564 case 0xe0:
12565 goto op_semantics_93;
12566 break;
12567 case 0xf0:
12568 goto op_semantics_94;
12569 break;
12570 }
12571 break;
12572 case 0xfc:
12573 GETBYTE ();
12574 switch (op[2] & 0xf0)
12575 {
12576 case 0x00:
12577 case 0x10:
12578 case 0x20:
12579 case 0x30:
12580 case 0x40:
12581 case 0x50:
12582 case 0x60:
12583 case 0x70:
12584 case 0x80:
12585 case 0x90:
12586 case 0xa0:
12587 case 0xb0:
12588 case 0xc0:
12589 case 0xd0:
12590 case 0xe0:
12591 goto op_semantics_93;
12592 break;
12593 case 0xf0:
12594 goto op_semantics_94;
12595 break;
12596 }
12597 break;
12598 case 0xfd:
12599 GETBYTE ();
12600 switch (op[2] & 0xf0)
12601 {
12602 case 0x00:
12603 case 0x10:
12604 case 0x20:
12605 case 0x30:
12606 case 0x40:
12607 case 0x50:
12608 case 0x60:
12609 case 0x70:
12610 case 0x80:
12611 case 0x90:
12612 case 0xa0:
12613 case 0xb0:
12614 case 0xc0:
12615 case 0xd0:
12616 case 0xe0:
12617 goto op_semantics_93;
12618 break;
12619 case 0xf0:
12620 goto op_semantics_94;
12621 break;
12622 }
12623 break;
12624 case 0xfe:
12625 GETBYTE ();
12626 switch (op[2] & 0xf0)
12627 {
12628 case 0x00:
12629 case 0x10:
12630 case 0x20:
12631 case 0x30:
12632 case 0x40:
12633 case 0x50:
12634 case 0x60:
12635 case 0x70:
12636 case 0x80:
12637 case 0x90:
12638 case 0xa0:
12639 case 0xb0:
12640 case 0xc0:
12641 case 0xd0:
12642 case 0xe0:
12643 goto op_semantics_93;
12644 break;
12645 case 0xf0:
12646 goto op_semantics_94;
12647 break;
12648 }
12649 break;
12650 case 0xff:
12651 GETBYTE ();
12652 switch (op[2] & 0xf0)
12653 {
12654 case 0x00:
12655 case 0x10:
12656 case 0x20:
12657 case 0x30:
12658 case 0x40:
12659 case 0x50:
12660 case 0x60:
12661 case 0x70:
12662 case 0x80:
12663 case 0x90:
12664 case 0xa0:
12665 case 0xb0:
12666 case 0xc0:
12667 case 0xd0:
12668 case 0xe0:
12669 goto op_semantics_93;
12670 break;
12671 case 0xf0:
12672 goto op_semantics_94;
12673 break;
12674 }
12675 break;
12676 default: UNSUPPORTED(); break;
12677 }
12678 break;
12679 case 0xfe:
12680 GETBYTE ();
12681 switch (op[1] & 0xff)
12682 {
12683 case 0x00:
12684 GETBYTE ();
12685 switch (op[2] & 0x00)
12686 {
12687 case 0x00:
12688 op_semantics_95:
12689 {
12690 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
12691#line 338 "rx-decode.opc"
12692 int sz AU = (op[1] >> 4) & 0x03;
12693#line 338 "rx-decode.opc"
12694 int isrc AU = op[1] & 0x0f;
12695#line 338 "rx-decode.opc"
12696 int bsrc AU = (op[2] >> 4) & 0x0f;
12697#line 338 "rx-decode.opc"
12698 int rdst AU = op[2] & 0x0f;
12699 if (trace)
12700 {
12701 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12702 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12703 op[0], op[1], op[2]);
12704 printf (" sz = 0x%x,", sz);
12705 printf (" isrc = 0x%x,", isrc);
12706 printf (" bsrc = 0x%x,", bsrc);
12707 printf (" rdst = 0x%x\n", rdst);
12708 }
12709 SYNTAX("mov%s %0, [%1, %2]");
12710#line 338 "rx-decode.opc"
12711 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
12712
12713 }
12714 break;
12715 }
12716 break;
12717 case 0x01:
12718 GETBYTE ();
12719 switch (op[2] & 0x00)
12720 {
12721 case 0x00:
12722 goto op_semantics_95;
12723 break;
12724 }
12725 break;
12726 case 0x02:
12727 GETBYTE ();
12728 switch (op[2] & 0x00)
12729 {
12730 case 0x00:
12731 goto op_semantics_95;
12732 break;
12733 }
12734 break;
12735 case 0x03:
12736 GETBYTE ();
12737 switch (op[2] & 0x00)
12738 {
12739 case 0x00:
12740 goto op_semantics_95;
12741 break;
12742 }
12743 break;
12744 case 0x04:
12745 GETBYTE ();
12746 switch (op[2] & 0x00)
12747 {
12748 case 0x00:
12749 goto op_semantics_95;
12750 break;
12751 }
12752 break;
12753 case 0x05:
12754 GETBYTE ();
12755 switch (op[2] & 0x00)
12756 {
12757 case 0x00:
12758 goto op_semantics_95;
12759 break;
12760 }
12761 break;
12762 case 0x06:
12763 GETBYTE ();
12764 switch (op[2] & 0x00)
12765 {
12766 case 0x00:
12767 goto op_semantics_95;
12768 break;
12769 }
12770 break;
12771 case 0x07:
12772 GETBYTE ();
12773 switch (op[2] & 0x00)
12774 {
12775 case 0x00:
12776 goto op_semantics_95;
12777 break;
12778 }
12779 break;
12780 case 0x08:
12781 GETBYTE ();
12782 switch (op[2] & 0x00)
12783 {
12784 case 0x00:
12785 goto op_semantics_95;
12786 break;
12787 }
12788 break;
12789 case 0x09:
12790 GETBYTE ();
12791 switch (op[2] & 0x00)
12792 {
12793 case 0x00:
12794 goto op_semantics_95;
12795 break;
12796 }
12797 break;
12798 case 0x0a:
12799 GETBYTE ();
12800 switch (op[2] & 0x00)
12801 {
12802 case 0x00:
12803 goto op_semantics_95;
12804 break;
12805 }
12806 break;
12807 case 0x0b:
12808 GETBYTE ();
12809 switch (op[2] & 0x00)
12810 {
12811 case 0x00:
12812 goto op_semantics_95;
12813 break;
12814 }
12815 break;
12816 case 0x0c:
12817 GETBYTE ();
12818 switch (op[2] & 0x00)
12819 {
12820 case 0x00:
12821 goto op_semantics_95;
12822 break;
12823 }
12824 break;
12825 case 0x0d:
12826 GETBYTE ();
12827 switch (op[2] & 0x00)
12828 {
12829 case 0x00:
12830 goto op_semantics_95;
12831 break;
12832 }
12833 break;
12834 case 0x0e:
12835 GETBYTE ();
12836 switch (op[2] & 0x00)
12837 {
12838 case 0x00:
12839 goto op_semantics_95;
12840 break;
12841 }
12842 break;
12843 case 0x0f:
12844 GETBYTE ();
12845 switch (op[2] & 0x00)
12846 {
12847 case 0x00:
12848 goto op_semantics_95;
12849 break;
12850 }
12851 break;
12852 case 0x10:
12853 GETBYTE ();
12854 switch (op[2] & 0x00)
12855 {
12856 case 0x00:
12857 goto op_semantics_95;
12858 break;
12859 }
12860 break;
12861 case 0x11:
12862 GETBYTE ();
12863 switch (op[2] & 0x00)
12864 {
12865 case 0x00:
12866 goto op_semantics_95;
12867 break;
12868 }
12869 break;
12870 case 0x12:
12871 GETBYTE ();
12872 switch (op[2] & 0x00)
12873 {
12874 case 0x00:
12875 goto op_semantics_95;
12876 break;
12877 }
12878 break;
12879 case 0x13:
12880 GETBYTE ();
12881 switch (op[2] & 0x00)
12882 {
12883 case 0x00:
12884 goto op_semantics_95;
12885 break;
12886 }
12887 break;
12888 case 0x14:
12889 GETBYTE ();
12890 switch (op[2] & 0x00)
12891 {
12892 case 0x00:
12893 goto op_semantics_95;
12894 break;
12895 }
12896 break;
12897 case 0x15:
12898 GETBYTE ();
12899 switch (op[2] & 0x00)
12900 {
12901 case 0x00:
12902 goto op_semantics_95;
12903 break;
12904 }
12905 break;
12906 case 0x16:
12907 GETBYTE ();
12908 switch (op[2] & 0x00)
12909 {
12910 case 0x00:
12911 goto op_semantics_95;
12912 break;
12913 }
12914 break;
12915 case 0x17:
12916 GETBYTE ();
12917 switch (op[2] & 0x00)
12918 {
12919 case 0x00:
12920 goto op_semantics_95;
12921 break;
12922 }
12923 break;
12924 case 0x18:
12925 GETBYTE ();
12926 switch (op[2] & 0x00)
12927 {
12928 case 0x00:
12929 goto op_semantics_95;
12930 break;
12931 }
12932 break;
12933 case 0x19:
12934 GETBYTE ();
12935 switch (op[2] & 0x00)
12936 {
12937 case 0x00:
12938 goto op_semantics_95;
12939 break;
12940 }
12941 break;
12942 case 0x1a:
12943 GETBYTE ();
12944 switch (op[2] & 0x00)
12945 {
12946 case 0x00:
12947 goto op_semantics_95;
12948 break;
12949 }
12950 break;
12951 case 0x1b:
12952 GETBYTE ();
12953 switch (op[2] & 0x00)
12954 {
12955 case 0x00:
12956 goto op_semantics_95;
12957 break;
12958 }
12959 break;
12960 case 0x1c:
12961 GETBYTE ();
12962 switch (op[2] & 0x00)
12963 {
12964 case 0x00:
12965 goto op_semantics_95;
12966 break;
12967 }
12968 break;
12969 case 0x1d:
12970 GETBYTE ();
12971 switch (op[2] & 0x00)
12972 {
12973 case 0x00:
12974 goto op_semantics_95;
12975 break;
12976 }
12977 break;
12978 case 0x1e:
12979 GETBYTE ();
12980 switch (op[2] & 0x00)
12981 {
12982 case 0x00:
12983 goto op_semantics_95;
12984 break;
12985 }
12986 break;
12987 case 0x1f:
12988 GETBYTE ();
12989 switch (op[2] & 0x00)
12990 {
12991 case 0x00:
12992 goto op_semantics_95;
12993 break;
12994 }
12995 break;
12996 case 0x20:
12997 GETBYTE ();
12998 switch (op[2] & 0x00)
12999 {
13000 case 0x00:
13001 goto op_semantics_95;
13002 break;
13003 }
13004 break;
13005 case 0x21:
13006 GETBYTE ();
13007 switch (op[2] & 0x00)
13008 {
13009 case 0x00:
13010 goto op_semantics_95;
13011 break;
13012 }
13013 break;
13014 case 0x22:
13015 GETBYTE ();
13016 switch (op[2] & 0x00)
13017 {
13018 case 0x00:
13019 goto op_semantics_95;
13020 break;
13021 }
13022 break;
13023 case 0x23:
13024 GETBYTE ();
13025 switch (op[2] & 0x00)
13026 {
13027 case 0x00:
13028 goto op_semantics_95;
13029 break;
13030 }
13031 break;
13032 case 0x24:
13033 GETBYTE ();
13034 switch (op[2] & 0x00)
13035 {
13036 case 0x00:
13037 goto op_semantics_95;
13038 break;
13039 }
13040 break;
13041 case 0x25:
13042 GETBYTE ();
13043 switch (op[2] & 0x00)
13044 {
13045 case 0x00:
13046 goto op_semantics_95;
13047 break;
13048 }
13049 break;
13050 case 0x26:
13051 GETBYTE ();
13052 switch (op[2] & 0x00)
13053 {
13054 case 0x00:
13055 goto op_semantics_95;
13056 break;
13057 }
13058 break;
13059 case 0x27:
13060 GETBYTE ();
13061 switch (op[2] & 0x00)
13062 {
13063 case 0x00:
13064 goto op_semantics_95;
13065 break;
13066 }
13067 break;
13068 case 0x28:
13069 GETBYTE ();
13070 switch (op[2] & 0x00)
13071 {
13072 case 0x00:
13073 goto op_semantics_95;
13074 break;
13075 }
13076 break;
13077 case 0x29:
13078 GETBYTE ();
13079 switch (op[2] & 0x00)
13080 {
13081 case 0x00:
13082 goto op_semantics_95;
13083 break;
13084 }
13085 break;
13086 case 0x2a:
13087 GETBYTE ();
13088 switch (op[2] & 0x00)
13089 {
13090 case 0x00:
13091 goto op_semantics_95;
13092 break;
13093 }
13094 break;
13095 case 0x2b:
13096 GETBYTE ();
13097 switch (op[2] & 0x00)
13098 {
13099 case 0x00:
13100 goto op_semantics_95;
13101 break;
13102 }
13103 break;
13104 case 0x2c:
13105 GETBYTE ();
13106 switch (op[2] & 0x00)
13107 {
13108 case 0x00:
13109 goto op_semantics_95;
13110 break;
13111 }
13112 break;
13113 case 0x2d:
13114 GETBYTE ();
13115 switch (op[2] & 0x00)
13116 {
13117 case 0x00:
13118 goto op_semantics_95;
13119 break;
13120 }
13121 break;
13122 case 0x2e:
13123 GETBYTE ();
13124 switch (op[2] & 0x00)
13125 {
13126 case 0x00:
13127 goto op_semantics_95;
13128 break;
13129 }
13130 break;
13131 case 0x2f:
13132 GETBYTE ();
13133 switch (op[2] & 0x00)
13134 {
13135 case 0x00:
13136 goto op_semantics_95;
13137 break;
13138 }
13139 break;
13140 case 0x40:
13141 GETBYTE ();
13142 switch (op[2] & 0x00)
13143 {
13144 case 0x00:
13145 op_semantics_96:
13146 {
13147 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
13148#line 335 "rx-decode.opc"
13149 int sz AU = (op[1] >> 4) & 0x03;
13150#line 335 "rx-decode.opc"
13151 int isrc AU = op[1] & 0x0f;
13152#line 335 "rx-decode.opc"
13153 int bsrc AU = (op[2] >> 4) & 0x0f;
13154#line 335 "rx-decode.opc"
13155 int rdst AU = op[2] & 0x0f;
13156 if (trace)
13157 {
13158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13159 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13160 op[0], op[1], op[2]);
13161 printf (" sz = 0x%x,", sz);
13162 printf (" isrc = 0x%x,", isrc);
13163 printf (" bsrc = 0x%x,", bsrc);
13164 printf (" rdst = 0x%x\n", rdst);
13165 }
13166 SYNTAX("mov%s [%1, %2], %0");
13167#line 335 "rx-decode.opc"
13168 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13169
13170 }
13171 break;
13172 }
13173 break;
13174 case 0x41:
13175 GETBYTE ();
13176 switch (op[2] & 0x00)
13177 {
13178 case 0x00:
13179 goto op_semantics_96;
13180 break;
13181 }
13182 break;
13183 case 0x42:
13184 GETBYTE ();
13185 switch (op[2] & 0x00)
13186 {
13187 case 0x00:
13188 goto op_semantics_96;
13189 break;
13190 }
13191 break;
13192 case 0x43:
13193 GETBYTE ();
13194 switch (op[2] & 0x00)
13195 {
13196 case 0x00:
13197 goto op_semantics_96;
13198 break;
13199 }
13200 break;
13201 case 0x44:
13202 GETBYTE ();
13203 switch (op[2] & 0x00)
13204 {
13205 case 0x00:
13206 goto op_semantics_96;
13207 break;
13208 }
13209 break;
13210 case 0x45:
13211 GETBYTE ();
13212 switch (op[2] & 0x00)
13213 {
13214 case 0x00:
13215 goto op_semantics_96;
13216 break;
13217 }
13218 break;
13219 case 0x46:
13220 GETBYTE ();
13221 switch (op[2] & 0x00)
13222 {
13223 case 0x00:
13224 goto op_semantics_96;
13225 break;
13226 }
13227 break;
13228 case 0x47:
13229 GETBYTE ();
13230 switch (op[2] & 0x00)
13231 {
13232 case 0x00:
13233 goto op_semantics_96;
13234 break;
13235 }
13236 break;
13237 case 0x48:
13238 GETBYTE ();
13239 switch (op[2] & 0x00)
13240 {
13241 case 0x00:
13242 goto op_semantics_96;
13243 break;
13244 }
13245 break;
13246 case 0x49:
13247 GETBYTE ();
13248 switch (op[2] & 0x00)
13249 {
13250 case 0x00:
13251 goto op_semantics_96;
13252 break;
13253 }
13254 break;
13255 case 0x4a:
13256 GETBYTE ();
13257 switch (op[2] & 0x00)
13258 {
13259 case 0x00:
13260 goto op_semantics_96;
13261 break;
13262 }
13263 break;
13264 case 0x4b:
13265 GETBYTE ();
13266 switch (op[2] & 0x00)
13267 {
13268 case 0x00:
13269 goto op_semantics_96;
13270 break;
13271 }
13272 break;
13273 case 0x4c:
13274 GETBYTE ();
13275 switch (op[2] & 0x00)
13276 {
13277 case 0x00:
13278 goto op_semantics_96;
13279 break;
13280 }
13281 break;
13282 case 0x4d:
13283 GETBYTE ();
13284 switch (op[2] & 0x00)
13285 {
13286 case 0x00:
13287 goto op_semantics_96;
13288 break;
13289 }
13290 break;
13291 case 0x4e:
13292 GETBYTE ();
13293 switch (op[2] & 0x00)
13294 {
13295 case 0x00:
13296 goto op_semantics_96;
13297 break;
13298 }
13299 break;
13300 case 0x4f:
13301 GETBYTE ();
13302 switch (op[2] & 0x00)
13303 {
13304 case 0x00:
13305 goto op_semantics_96;
13306 break;
13307 }
13308 break;
13309 case 0x50:
13310 GETBYTE ();
13311 switch (op[2] & 0x00)
13312 {
13313 case 0x00:
13314 goto op_semantics_96;
13315 break;
13316 }
13317 break;
13318 case 0x51:
13319 GETBYTE ();
13320 switch (op[2] & 0x00)
13321 {
13322 case 0x00:
13323 goto op_semantics_96;
13324 break;
13325 }
13326 break;
13327 case 0x52:
13328 GETBYTE ();
13329 switch (op[2] & 0x00)
13330 {
13331 case 0x00:
13332 goto op_semantics_96;
13333 break;
13334 }
13335 break;
13336 case 0x53:
13337 GETBYTE ();
13338 switch (op[2] & 0x00)
13339 {
13340 case 0x00:
13341 goto op_semantics_96;
13342 break;
13343 }
13344 break;
13345 case 0x54:
13346 GETBYTE ();
13347 switch (op[2] & 0x00)
13348 {
13349 case 0x00:
13350 goto op_semantics_96;
13351 break;
13352 }
13353 break;
13354 case 0x55:
13355 GETBYTE ();
13356 switch (op[2] & 0x00)
13357 {
13358 case 0x00:
13359 goto op_semantics_96;
13360 break;
13361 }
13362 break;
13363 case 0x56:
13364 GETBYTE ();
13365 switch (op[2] & 0x00)
13366 {
13367 case 0x00:
13368 goto op_semantics_96;
13369 break;
13370 }
13371 break;
13372 case 0x57:
13373 GETBYTE ();
13374 switch (op[2] & 0x00)
13375 {
13376 case 0x00:
13377 goto op_semantics_96;
13378 break;
13379 }
13380 break;
13381 case 0x58:
13382 GETBYTE ();
13383 switch (op[2] & 0x00)
13384 {
13385 case 0x00:
13386 goto op_semantics_96;
13387 break;
13388 }
13389 break;
13390 case 0x59:
13391 GETBYTE ();
13392 switch (op[2] & 0x00)
13393 {
13394 case 0x00:
13395 goto op_semantics_96;
13396 break;
13397 }
13398 break;
13399 case 0x5a:
13400 GETBYTE ();
13401 switch (op[2] & 0x00)
13402 {
13403 case 0x00:
13404 goto op_semantics_96;
13405 break;
13406 }
13407 break;
13408 case 0x5b:
13409 GETBYTE ();
13410 switch (op[2] & 0x00)
13411 {
13412 case 0x00:
13413 goto op_semantics_96;
13414 break;
13415 }
13416 break;
13417 case 0x5c:
13418 GETBYTE ();
13419 switch (op[2] & 0x00)
13420 {
13421 case 0x00:
13422 goto op_semantics_96;
13423 break;
13424 }
13425 break;
13426 case 0x5d:
13427 GETBYTE ();
13428 switch (op[2] & 0x00)
13429 {
13430 case 0x00:
13431 goto op_semantics_96;
13432 break;
13433 }
13434 break;
13435 case 0x5e:
13436 GETBYTE ();
13437 switch (op[2] & 0x00)
13438 {
13439 case 0x00:
13440 goto op_semantics_96;
13441 break;
13442 }
13443 break;
13444 case 0x5f:
13445 GETBYTE ();
13446 switch (op[2] & 0x00)
13447 {
13448 case 0x00:
13449 goto op_semantics_96;
13450 break;
13451 }
13452 break;
13453 case 0x60:
13454 GETBYTE ();
13455 switch (op[2] & 0x00)
13456 {
13457 case 0x00:
13458 goto op_semantics_96;
13459 break;
13460 }
13461 break;
13462 case 0x61:
13463 GETBYTE ();
13464 switch (op[2] & 0x00)
13465 {
13466 case 0x00:
13467 goto op_semantics_96;
13468 break;
13469 }
13470 break;
13471 case 0x62:
13472 GETBYTE ();
13473 switch (op[2] & 0x00)
13474 {
13475 case 0x00:
13476 goto op_semantics_96;
13477 break;
13478 }
13479 break;
13480 case 0x63:
13481 GETBYTE ();
13482 switch (op[2] & 0x00)
13483 {
13484 case 0x00:
13485 goto op_semantics_96;
13486 break;
13487 }
13488 break;
13489 case 0x64:
13490 GETBYTE ();
13491 switch (op[2] & 0x00)
13492 {
13493 case 0x00:
13494 goto op_semantics_96;
13495 break;
13496 }
13497 break;
13498 case 0x65:
13499 GETBYTE ();
13500 switch (op[2] & 0x00)
13501 {
13502 case 0x00:
13503 goto op_semantics_96;
13504 break;
13505 }
13506 break;
13507 case 0x66:
13508 GETBYTE ();
13509 switch (op[2] & 0x00)
13510 {
13511 case 0x00:
13512 goto op_semantics_96;
13513 break;
13514 }
13515 break;
13516 case 0x67:
13517 GETBYTE ();
13518 switch (op[2] & 0x00)
13519 {
13520 case 0x00:
13521 goto op_semantics_96;
13522 break;
13523 }
13524 break;
13525 case 0x68:
13526 GETBYTE ();
13527 switch (op[2] & 0x00)
13528 {
13529 case 0x00:
13530 goto op_semantics_96;
13531 break;
13532 }
13533 break;
13534 case 0x69:
13535 GETBYTE ();
13536 switch (op[2] & 0x00)
13537 {
13538 case 0x00:
13539 goto op_semantics_96;
13540 break;
13541 }
13542 break;
13543 case 0x6a:
13544 GETBYTE ();
13545 switch (op[2] & 0x00)
13546 {
13547 case 0x00:
13548 goto op_semantics_96;
13549 break;
13550 }
13551 break;
13552 case 0x6b:
13553 GETBYTE ();
13554 switch (op[2] & 0x00)
13555 {
13556 case 0x00:
13557 goto op_semantics_96;
13558 break;
13559 }
13560 break;
13561 case 0x6c:
13562 GETBYTE ();
13563 switch (op[2] & 0x00)
13564 {
13565 case 0x00:
13566 goto op_semantics_96;
13567 break;
13568 }
13569 break;
13570 case 0x6d:
13571 GETBYTE ();
13572 switch (op[2] & 0x00)
13573 {
13574 case 0x00:
13575 goto op_semantics_96;
13576 break;
13577 }
13578 break;
13579 case 0x6e:
13580 GETBYTE ();
13581 switch (op[2] & 0x00)
13582 {
13583 case 0x00:
13584 goto op_semantics_96;
13585 break;
13586 }
13587 break;
13588 case 0x6f:
13589 GETBYTE ();
13590 switch (op[2] & 0x00)
13591 {
13592 case 0x00:
13593 goto op_semantics_96;
13594 break;
13595 }
13596 break;
13597 case 0xc0:
13598 GETBYTE ();
13599 switch (op[2] & 0x00)
13600 {
13601 case 0x00:
13602 op_semantics_97:
13603 {
13604 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
13605#line 341 "rx-decode.opc"
13606 int sz AU = (op[1] >> 4) & 0x03;
13607#line 341 "rx-decode.opc"
13608 int isrc AU = op[1] & 0x0f;
13609#line 341 "rx-decode.opc"
13610 int bsrc AU = (op[2] >> 4) & 0x0f;
13611#line 341 "rx-decode.opc"
13612 int rdst AU = op[2] & 0x0f;
13613 if (trace)
13614 {
13615 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13616 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13617 op[0], op[1], op[2]);
13618 printf (" sz = 0x%x,", sz);
13619 printf (" isrc = 0x%x,", isrc);
13620 printf (" bsrc = 0x%x,", bsrc);
13621 printf (" rdst = 0x%x\n", rdst);
13622 }
13623 SYNTAX("movu%s [%1, %2], %0");
13624#line 341 "rx-decode.opc"
13625 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13626
13627 }
13628 break;
13629 }
13630 break;
13631 case 0xc1:
13632 GETBYTE ();
13633 switch (op[2] & 0x00)
13634 {
13635 case 0x00:
13636 goto op_semantics_97;
13637 break;
13638 }
13639 break;
13640 case 0xc2:
13641 GETBYTE ();
13642 switch (op[2] & 0x00)
13643 {
13644 case 0x00:
13645 goto op_semantics_97;
13646 break;
13647 }
13648 break;
13649 case 0xc3:
13650 GETBYTE ();
13651 switch (op[2] & 0x00)
13652 {
13653 case 0x00:
13654 goto op_semantics_97;
13655 break;
13656 }
13657 break;
13658 case 0xc4:
13659 GETBYTE ();
13660 switch (op[2] & 0x00)
13661 {
13662 case 0x00:
13663 goto op_semantics_97;
13664 break;
13665 }
13666 break;
13667 case 0xc5:
13668 GETBYTE ();
13669 switch (op[2] & 0x00)
13670 {
13671 case 0x00:
13672 goto op_semantics_97;
13673 break;
13674 }
13675 break;
13676 case 0xc6:
13677 GETBYTE ();
13678 switch (op[2] & 0x00)
13679 {
13680 case 0x00:
13681 goto op_semantics_97;
13682 break;
13683 }
13684 break;
13685 case 0xc7:
13686 GETBYTE ();
13687 switch (op[2] & 0x00)
13688 {
13689 case 0x00:
13690 goto op_semantics_97;
13691 break;
13692 }
13693 break;
13694 case 0xc8:
13695 GETBYTE ();
13696 switch (op[2] & 0x00)
13697 {
13698 case 0x00:
13699 goto op_semantics_97;
13700 break;
13701 }
13702 break;
13703 case 0xc9:
13704 GETBYTE ();
13705 switch (op[2] & 0x00)
13706 {
13707 case 0x00:
13708 goto op_semantics_97;
13709 break;
13710 }
13711 break;
13712 case 0xca:
13713 GETBYTE ();
13714 switch (op[2] & 0x00)
13715 {
13716 case 0x00:
13717 goto op_semantics_97;
13718 break;
13719 }
13720 break;
13721 case 0xcb:
13722 GETBYTE ();
13723 switch (op[2] & 0x00)
13724 {
13725 case 0x00:
13726 goto op_semantics_97;
13727 break;
13728 }
13729 break;
13730 case 0xcc:
13731 GETBYTE ();
13732 switch (op[2] & 0x00)
13733 {
13734 case 0x00:
13735 goto op_semantics_97;
13736 break;
13737 }
13738 break;
13739 case 0xcd:
13740 GETBYTE ();
13741 switch (op[2] & 0x00)
13742 {
13743 case 0x00:
13744 goto op_semantics_97;
13745 break;
13746 }
13747 break;
13748 case 0xce:
13749 GETBYTE ();
13750 switch (op[2] & 0x00)
13751 {
13752 case 0x00:
13753 goto op_semantics_97;
13754 break;
13755 }
13756 break;
13757 case 0xcf:
13758 GETBYTE ();
13759 switch (op[2] & 0x00)
13760 {
13761 case 0x00:
13762 goto op_semantics_97;
13763 break;
13764 }
13765 break;
13766 case 0xd0:
13767 GETBYTE ();
13768 switch (op[2] & 0x00)
13769 {
13770 case 0x00:
13771 goto op_semantics_97;
13772 break;
13773 }
13774 break;
13775 case 0xd1:
13776 GETBYTE ();
13777 switch (op[2] & 0x00)
13778 {
13779 case 0x00:
13780 goto op_semantics_97;
13781 break;
13782 }
13783 break;
13784 case 0xd2:
13785 GETBYTE ();
13786 switch (op[2] & 0x00)
13787 {
13788 case 0x00:
13789 goto op_semantics_97;
13790 break;
13791 }
13792 break;
13793 case 0xd3:
13794 GETBYTE ();
13795 switch (op[2] & 0x00)
13796 {
13797 case 0x00:
13798 goto op_semantics_97;
13799 break;
13800 }
13801 break;
13802 case 0xd4:
13803 GETBYTE ();
13804 switch (op[2] & 0x00)
13805 {
13806 case 0x00:
13807 goto op_semantics_97;
13808 break;
13809 }
13810 break;
13811 case 0xd5:
13812 GETBYTE ();
13813 switch (op[2] & 0x00)
13814 {
13815 case 0x00:
13816 goto op_semantics_97;
13817 break;
13818 }
13819 break;
13820 case 0xd6:
13821 GETBYTE ();
13822 switch (op[2] & 0x00)
13823 {
13824 case 0x00:
13825 goto op_semantics_97;
13826 break;
13827 }
13828 break;
13829 case 0xd7:
13830 GETBYTE ();
13831 switch (op[2] & 0x00)
13832 {
13833 case 0x00:
13834 goto op_semantics_97;
13835 break;
13836 }
13837 break;
13838 case 0xd8:
13839 GETBYTE ();
13840 switch (op[2] & 0x00)
13841 {
13842 case 0x00:
13843 goto op_semantics_97;
13844 break;
13845 }
13846 break;
13847 case 0xd9:
13848 GETBYTE ();
13849 switch (op[2] & 0x00)
13850 {
13851 case 0x00:
13852 goto op_semantics_97;
13853 break;
13854 }
13855 break;
13856 case 0xda:
13857 GETBYTE ();
13858 switch (op[2] & 0x00)
13859 {
13860 case 0x00:
13861 goto op_semantics_97;
13862 break;
13863 }
13864 break;
13865 case 0xdb:
13866 GETBYTE ();
13867 switch (op[2] & 0x00)
13868 {
13869 case 0x00:
13870 goto op_semantics_97;
13871 break;
13872 }
13873 break;
13874 case 0xdc:
13875 GETBYTE ();
13876 switch (op[2] & 0x00)
13877 {
13878 case 0x00:
13879 goto op_semantics_97;
13880 break;
13881 }
13882 break;
13883 case 0xdd:
13884 GETBYTE ();
13885 switch (op[2] & 0x00)
13886 {
13887 case 0x00:
13888 goto op_semantics_97;
13889 break;
13890 }
13891 break;
13892 case 0xde:
13893 GETBYTE ();
13894 switch (op[2] & 0x00)
13895 {
13896 case 0x00:
13897 goto op_semantics_97;
13898 break;
13899 }
13900 break;
13901 case 0xdf:
13902 GETBYTE ();
13903 switch (op[2] & 0x00)
13904 {
13905 case 0x00:
13906 goto op_semantics_97;
13907 break;
13908 }
13909 break;
13910 case 0xe0:
13911 GETBYTE ();
13912 switch (op[2] & 0x00)
13913 {
13914 case 0x00:
13915 goto op_semantics_97;
13916 break;
13917 }
13918 break;
13919 case 0xe1:
13920 GETBYTE ();
13921 switch (op[2] & 0x00)
13922 {
13923 case 0x00:
13924 goto op_semantics_97;
13925 break;
13926 }
13927 break;
13928 case 0xe2:
13929 GETBYTE ();
13930 switch (op[2] & 0x00)
13931 {
13932 case 0x00:
13933 goto op_semantics_97;
13934 break;
13935 }
13936 break;
13937 case 0xe3:
13938 GETBYTE ();
13939 switch (op[2] & 0x00)
13940 {
13941 case 0x00:
13942 goto op_semantics_97;
13943 break;
13944 }
13945 break;
13946 case 0xe4:
13947 GETBYTE ();
13948 switch (op[2] & 0x00)
13949 {
13950 case 0x00:
13951 goto op_semantics_97;
13952 break;
13953 }
13954 break;
13955 case 0xe5:
13956 GETBYTE ();
13957 switch (op[2] & 0x00)
13958 {
13959 case 0x00:
13960 goto op_semantics_97;
13961 break;
13962 }
13963 break;
13964 case 0xe6:
13965 GETBYTE ();
13966 switch (op[2] & 0x00)
13967 {
13968 case 0x00:
13969 goto op_semantics_97;
13970 break;
13971 }
13972 break;
13973 case 0xe7:
13974 GETBYTE ();
13975 switch (op[2] & 0x00)
13976 {
13977 case 0x00:
13978 goto op_semantics_97;
13979 break;
13980 }
13981 break;
13982 case 0xe8:
13983 GETBYTE ();
13984 switch (op[2] & 0x00)
13985 {
13986 case 0x00:
13987 goto op_semantics_97;
13988 break;
13989 }
13990 break;
13991 case 0xe9:
13992 GETBYTE ();
13993 switch (op[2] & 0x00)
13994 {
13995 case 0x00:
13996 goto op_semantics_97;
13997 break;
13998 }
13999 break;
14000 case 0xea:
14001 GETBYTE ();
14002 switch (op[2] & 0x00)
14003 {
14004 case 0x00:
14005 goto op_semantics_97;
14006 break;
14007 }
14008 break;
14009 case 0xeb:
14010 GETBYTE ();
14011 switch (op[2] & 0x00)
14012 {
14013 case 0x00:
14014 goto op_semantics_97;
14015 break;
14016 }
14017 break;
14018 case 0xec:
14019 GETBYTE ();
14020 switch (op[2] & 0x00)
14021 {
14022 case 0x00:
14023 goto op_semantics_97;
14024 break;
14025 }
14026 break;
14027 case 0xed:
14028 GETBYTE ();
14029 switch (op[2] & 0x00)
14030 {
14031 case 0x00:
14032 goto op_semantics_97;
14033 break;
14034 }
14035 break;
14036 case 0xee:
14037 GETBYTE ();
14038 switch (op[2] & 0x00)
14039 {
14040 case 0x00:
14041 goto op_semantics_97;
14042 break;
14043 }
14044 break;
14045 case 0xef:
14046 GETBYTE ();
14047 switch (op[2] & 0x00)
14048 {
14049 case 0x00:
14050 goto op_semantics_97;
14051 break;
14052 }
14053 break;
14054 default: UNSUPPORTED(); break;
14055 }
14056 break;
14057 case 0xff:
14058 GETBYTE ();
14059 switch (op[1] & 0xff)
14060 {
14061 case 0x00:
14062 GETBYTE ();
14063 switch (op[2] & 0x00)
14064 {
14065 case 0x00:
14066 op_semantics_98:
14067 {
14068 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
14069#line 545 "rx-decode.opc"
14070 int rdst AU = op[1] & 0x0f;
14071#line 545 "rx-decode.opc"
14072 int srca AU = (op[2] >> 4) & 0x0f;
14073#line 545 "rx-decode.opc"
14074 int srcb AU = op[2] & 0x0f;
14075 if (trace)
14076 {
14077 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14078 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
14079 op[0], op[1], op[2]);
14080 printf (" rdst = 0x%x,", rdst);
14081 printf (" srca = 0x%x,", srca);
14082 printf (" srcb = 0x%x\n", srcb);
14083 }
14084 SYNTAX("sub %2, %1, %0");
14085#line 545 "rx-decode.opc"
14086 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14087
14088 /*----------------------------------------------------------------------*/
14089 /* SBB */
14090
14091 }
14092 break;
14093 }
14094 break;
14095 case 0x01:
14096 GETBYTE ();
14097 switch (op[2] & 0x00)
14098 {
14099 case 0x00:
14100 goto op_semantics_98;
14101 break;
14102 }
14103 break;
14104 case 0x02:
14105 GETBYTE ();
14106 switch (op[2] & 0x00)
14107 {
14108 case 0x00:
14109 goto op_semantics_98;
14110 break;
14111 }
14112 break;
14113 case 0x03:
14114 GETBYTE ();
14115 switch (op[2] & 0x00)
14116 {
14117 case 0x00:
14118 goto op_semantics_98;
14119 break;
14120 }
14121 break;
14122 case 0x04:
14123 GETBYTE ();
14124 switch (op[2] & 0x00)
14125 {
14126 case 0x00:
14127 goto op_semantics_98;
14128 break;
14129 }
14130 break;
14131 case 0x05:
14132 GETBYTE ();
14133 switch (op[2] & 0x00)
14134 {
14135 case 0x00:
14136 goto op_semantics_98;
14137 break;
14138 }
14139 break;
14140 case 0x06:
14141 GETBYTE ();
14142 switch (op[2] & 0x00)
14143 {
14144 case 0x00:
14145 goto op_semantics_98;
14146 break;
14147 }
14148 break;
14149 case 0x07:
14150 GETBYTE ();
14151 switch (op[2] & 0x00)
14152 {
14153 case 0x00:
14154 goto op_semantics_98;
14155 break;
14156 }
14157 break;
14158 case 0x08:
14159 GETBYTE ();
14160 switch (op[2] & 0x00)
14161 {
14162 case 0x00:
14163 goto op_semantics_98;
14164 break;
14165 }
14166 break;
14167 case 0x09:
14168 GETBYTE ();
14169 switch (op[2] & 0x00)
14170 {
14171 case 0x00:
14172 goto op_semantics_98;
14173 break;
14174 }
14175 break;
14176 case 0x0a:
14177 GETBYTE ();
14178 switch (op[2] & 0x00)
14179 {
14180 case 0x00:
14181 goto op_semantics_98;
14182 break;
14183 }
14184 break;
14185 case 0x0b:
14186 GETBYTE ();
14187 switch (op[2] & 0x00)
14188 {
14189 case 0x00:
14190 goto op_semantics_98;
14191 break;
14192 }
14193 break;
14194 case 0x0c:
14195 GETBYTE ();
14196 switch (op[2] & 0x00)
14197 {
14198 case 0x00:
14199 goto op_semantics_98;
14200 break;
14201 }
14202 break;
14203 case 0x0d:
14204 GETBYTE ();
14205 switch (op[2] & 0x00)
14206 {
14207 case 0x00:
14208 goto op_semantics_98;
14209 break;
14210 }
14211 break;
14212 case 0x0e:
14213 GETBYTE ();
14214 switch (op[2] & 0x00)
14215 {
14216 case 0x00:
14217 goto op_semantics_98;
14218 break;
14219 }
14220 break;
14221 case 0x0f:
14222 GETBYTE ();
14223 switch (op[2] & 0x00)
14224 {
14225 case 0x00:
14226 goto op_semantics_98;
14227 break;
14228 }
14229 break;
14230 case 0x20:
14231 GETBYTE ();
14232 switch (op[2] & 0x00)
14233 {
14234 case 0x00:
14235 op_semantics_99:
14236 {
14237 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
14238#line 512 "rx-decode.opc"
14239 int rdst AU = op[1] & 0x0f;
14240#line 512 "rx-decode.opc"
14241 int srca AU = (op[2] >> 4) & 0x0f;
14242#line 512 "rx-decode.opc"
14243 int srcb AU = op[2] & 0x0f;
14244 if (trace)
14245 {
14246 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14247 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14248 op[0], op[1], op[2]);
14249 printf (" rdst = 0x%x,", rdst);
14250 printf (" srca = 0x%x,", srca);
14251 printf (" srcb = 0x%x\n", srcb);
14252 }
14253 SYNTAX("add %2, %1, %0");
14254#line 512 "rx-decode.opc"
14255 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14256
14257 /*----------------------------------------------------------------------*/
14258 /* CMP */
14259
14260 }
14261 break;
14262 }
14263 break;
14264 case 0x21:
14265 GETBYTE ();
14266 switch (op[2] & 0x00)
14267 {
14268 case 0x00:
14269 goto op_semantics_99;
14270 break;
14271 }
14272 break;
14273 case 0x22:
14274 GETBYTE ();
14275 switch (op[2] & 0x00)
14276 {
14277 case 0x00:
14278 goto op_semantics_99;
14279 break;
14280 }
14281 break;
14282 case 0x23:
14283 GETBYTE ();
14284 switch (op[2] & 0x00)
14285 {
14286 case 0x00:
14287 goto op_semantics_99;
14288 break;
14289 }
14290 break;
14291 case 0x24:
14292 GETBYTE ();
14293 switch (op[2] & 0x00)
14294 {
14295 case 0x00:
14296 goto op_semantics_99;
14297 break;
14298 }
14299 break;
14300 case 0x25:
14301 GETBYTE ();
14302 switch (op[2] & 0x00)
14303 {
14304 case 0x00:
14305 goto op_semantics_99;
14306 break;
14307 }
14308 break;
14309 case 0x26:
14310 GETBYTE ();
14311 switch (op[2] & 0x00)
14312 {
14313 case 0x00:
14314 goto op_semantics_99;
14315 break;
14316 }
14317 break;
14318 case 0x27:
14319 GETBYTE ();
14320 switch (op[2] & 0x00)
14321 {
14322 case 0x00:
14323 goto op_semantics_99;
14324 break;
14325 }
14326 break;
14327 case 0x28:
14328 GETBYTE ();
14329 switch (op[2] & 0x00)
14330 {
14331 case 0x00:
14332 goto op_semantics_99;
14333 break;
14334 }
14335 break;
14336 case 0x29:
14337 GETBYTE ();
14338 switch (op[2] & 0x00)
14339 {
14340 case 0x00:
14341 goto op_semantics_99;
14342 break;
14343 }
14344 break;
14345 case 0x2a:
14346 GETBYTE ();
14347 switch (op[2] & 0x00)
14348 {
14349 case 0x00:
14350 goto op_semantics_99;
14351 break;
14352 }
14353 break;
14354 case 0x2b:
14355 GETBYTE ();
14356 switch (op[2] & 0x00)
14357 {
14358 case 0x00:
14359 goto op_semantics_99;
14360 break;
14361 }
14362 break;
14363 case 0x2c:
14364 GETBYTE ();
14365 switch (op[2] & 0x00)
14366 {
14367 case 0x00:
14368 goto op_semantics_99;
14369 break;
14370 }
14371 break;
14372 case 0x2d:
14373 GETBYTE ();
14374 switch (op[2] & 0x00)
14375 {
14376 case 0x00:
14377 goto op_semantics_99;
14378 break;
14379 }
14380 break;
14381 case 0x2e:
14382 GETBYTE ();
14383 switch (op[2] & 0x00)
14384 {
14385 case 0x00:
14386 goto op_semantics_99;
14387 break;
14388 }
14389 break;
14390 case 0x2f:
14391 GETBYTE ();
14392 switch (op[2] & 0x00)
14393 {
14394 case 0x00:
14395 goto op_semantics_99;
14396 break;
14397 }
14398 break;
14399 case 0x30:
14400 GETBYTE ();
14401 switch (op[2] & 0x00)
14402 {
14403 case 0x00:
14404 op_semantics_100:
14405 {
14406 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
14407#line 614 "rx-decode.opc"
14408 int rdst AU = op[1] & 0x0f;
14409#line 614 "rx-decode.opc"
14410 int srca AU = (op[2] >> 4) & 0x0f;
14411#line 614 "rx-decode.opc"
14412 int srcb AU = op[2] & 0x0f;
14413 if (trace)
14414 {
14415 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14416 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14417 op[0], op[1], op[2]);
14418 printf (" rdst = 0x%x,", rdst);
14419 printf (" srca = 0x%x,", srca);
14420 printf (" srcb = 0x%x\n", srcb);
14421 }
14422 SYNTAX("mul %2, %1, %0");
14423#line 614 "rx-decode.opc"
14424 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
14425
14426 /*----------------------------------------------------------------------*/
14427 /* EMUL */
14428
14429 }
14430 break;
14431 }
14432 break;
14433 case 0x31:
14434 GETBYTE ();
14435 switch (op[2] & 0x00)
14436 {
14437 case 0x00:
14438 goto op_semantics_100;
14439 break;
14440 }
14441 break;
14442 case 0x32:
14443 GETBYTE ();
14444 switch (op[2] & 0x00)
14445 {
14446 case 0x00:
14447 goto op_semantics_100;
14448 break;
14449 }
14450 break;
14451 case 0x33:
14452 GETBYTE ();
14453 switch (op[2] & 0x00)
14454 {
14455 case 0x00:
14456 goto op_semantics_100;
14457 break;
14458 }
14459 break;
14460 case 0x34:
14461 GETBYTE ();
14462 switch (op[2] & 0x00)
14463 {
14464 case 0x00:
14465 goto op_semantics_100;
14466 break;
14467 }
14468 break;
14469 case 0x35:
14470 GETBYTE ();
14471 switch (op[2] & 0x00)
14472 {
14473 case 0x00:
14474 goto op_semantics_100;
14475 break;
14476 }
14477 break;
14478 case 0x36:
14479 GETBYTE ();
14480 switch (op[2] & 0x00)
14481 {
14482 case 0x00:
14483 goto op_semantics_100;
14484 break;
14485 }
14486 break;
14487 case 0x37:
14488 GETBYTE ();
14489 switch (op[2] & 0x00)
14490 {
14491 case 0x00:
14492 goto op_semantics_100;
14493 break;
14494 }
14495 break;
14496 case 0x38:
14497 GETBYTE ();
14498 switch (op[2] & 0x00)
14499 {
14500 case 0x00:
14501 goto op_semantics_100;
14502 break;
14503 }
14504 break;
14505 case 0x39:
14506 GETBYTE ();
14507 switch (op[2] & 0x00)
14508 {
14509 case 0x00:
14510 goto op_semantics_100;
14511 break;
14512 }
14513 break;
14514 case 0x3a:
14515 GETBYTE ();
14516 switch (op[2] & 0x00)
14517 {
14518 case 0x00:
14519 goto op_semantics_100;
14520 break;
14521 }
14522 break;
14523 case 0x3b:
14524 GETBYTE ();
14525 switch (op[2] & 0x00)
14526 {
14527 case 0x00:
14528 goto op_semantics_100;
14529 break;
14530 }
14531 break;
14532 case 0x3c:
14533 GETBYTE ();
14534 switch (op[2] & 0x00)
14535 {
14536 case 0x00:
14537 goto op_semantics_100;
14538 break;
14539 }
14540 break;
14541 case 0x3d:
14542 GETBYTE ();
14543 switch (op[2] & 0x00)
14544 {
14545 case 0x00:
14546 goto op_semantics_100;
14547 break;
14548 }
14549 break;
14550 case 0x3e:
14551 GETBYTE ();
14552 switch (op[2] & 0x00)
14553 {
14554 case 0x00:
14555 goto op_semantics_100;
14556 break;
14557 }
14558 break;
14559 case 0x3f:
14560 GETBYTE ();
14561 switch (op[2] & 0x00)
14562 {
14563 case 0x00:
14564 goto op_semantics_100;
14565 break;
14566 }
14567 break;
14568 case 0x40:
14569 GETBYTE ();
14570 switch (op[2] & 0x00)
14571 {
14572 case 0x00:
14573 op_semantics_101:
14574 {
14575 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
14576#line 422 "rx-decode.opc"
14577 int rdst AU = op[1] & 0x0f;
14578#line 422 "rx-decode.opc"
14579 int srca AU = (op[2] >> 4) & 0x0f;
14580#line 422 "rx-decode.opc"
14581 int srcb AU = op[2] & 0x0f;
14582 if (trace)
14583 {
14584 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14585 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14586 op[0], op[1], op[2]);
14587 printf (" rdst = 0x%x,", rdst);
14588 printf (" srca = 0x%x,", srca);
14589 printf (" srcb = 0x%x\n", srcb);
14590 }
14591 SYNTAX("and %2, %1, %0");
14592#line 422 "rx-decode.opc"
14593 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14594
14595 /*----------------------------------------------------------------------*/
14596 /* OR */
14597
14598 }
14599 break;
14600 }
14601 break;
14602 case 0x41:
14603 GETBYTE ();
14604 switch (op[2] & 0x00)
14605 {
14606 case 0x00:
14607 goto op_semantics_101;
14608 break;
14609 }
14610 break;
14611 case 0x42:
14612 GETBYTE ();
14613 switch (op[2] & 0x00)
14614 {
14615 case 0x00:
14616 goto op_semantics_101;
14617 break;
14618 }
14619 break;
14620 case 0x43:
14621 GETBYTE ();
14622 switch (op[2] & 0x00)
14623 {
14624 case 0x00:
14625 goto op_semantics_101;
14626 break;
14627 }
14628 break;
14629 case 0x44:
14630 GETBYTE ();
14631 switch (op[2] & 0x00)
14632 {
14633 case 0x00:
14634 goto op_semantics_101;
14635 break;
14636 }
14637 break;
14638 case 0x45:
14639 GETBYTE ();
14640 switch (op[2] & 0x00)
14641 {
14642 case 0x00:
14643 goto op_semantics_101;
14644 break;
14645 }
14646 break;
14647 case 0x46:
14648 GETBYTE ();
14649 switch (op[2] & 0x00)
14650 {
14651 case 0x00:
14652 goto op_semantics_101;
14653 break;
14654 }
14655 break;
14656 case 0x47:
14657 GETBYTE ();
14658 switch (op[2] & 0x00)
14659 {
14660 case 0x00:
14661 goto op_semantics_101;
14662 break;
14663 }
14664 break;
14665 case 0x48:
14666 GETBYTE ();
14667 switch (op[2] & 0x00)
14668 {
14669 case 0x00:
14670 goto op_semantics_101;
14671 break;
14672 }
14673 break;
14674 case 0x49:
14675 GETBYTE ();
14676 switch (op[2] & 0x00)
14677 {
14678 case 0x00:
14679 goto op_semantics_101;
14680 break;
14681 }
14682 break;
14683 case 0x4a:
14684 GETBYTE ();
14685 switch (op[2] & 0x00)
14686 {
14687 case 0x00:
14688 goto op_semantics_101;
14689 break;
14690 }
14691 break;
14692 case 0x4b:
14693 GETBYTE ();
14694 switch (op[2] & 0x00)
14695 {
14696 case 0x00:
14697 goto op_semantics_101;
14698 break;
14699 }
14700 break;
14701 case 0x4c:
14702 GETBYTE ();
14703 switch (op[2] & 0x00)
14704 {
14705 case 0x00:
14706 goto op_semantics_101;
14707 break;
14708 }
14709 break;
14710 case 0x4d:
14711 GETBYTE ();
14712 switch (op[2] & 0x00)
14713 {
14714 case 0x00:
14715 goto op_semantics_101;
14716 break;
14717 }
14718 break;
14719 case 0x4e:
14720 GETBYTE ();
14721 switch (op[2] & 0x00)
14722 {
14723 case 0x00:
14724 goto op_semantics_101;
14725 break;
14726 }
14727 break;
14728 case 0x4f:
14729 GETBYTE ();
14730 switch (op[2] & 0x00)
14731 {
14732 case 0x00:
14733 goto op_semantics_101;
14734 break;
14735 }
14736 break;
14737 case 0x50:
14738 GETBYTE ();
14739 switch (op[2] & 0x00)
14740 {
14741 case 0x00:
14742 op_semantics_102:
14743 {
14744 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
14745#line 440 "rx-decode.opc"
14746 int rdst AU = op[1] & 0x0f;
14747#line 440 "rx-decode.opc"
14748 int srca AU = (op[2] >> 4) & 0x0f;
14749#line 440 "rx-decode.opc"
14750 int srcb AU = op[2] & 0x0f;
14751 if (trace)
14752 {
14753 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14754 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14755 op[0], op[1], op[2]);
14756 printf (" rdst = 0x%x,", rdst);
14757 printf (" srca = 0x%x,", srca);
14758 printf (" srcb = 0x%x\n", srcb);
14759 }
14760 SYNTAX("or %2, %1, %0");
14761#line 440 "rx-decode.opc"
14762 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14763
14764 /*----------------------------------------------------------------------*/
14765 /* XOR */
14766
14767 }
14768 break;
14769 }
14770 break;
14771 case 0x51:
14772 GETBYTE ();
14773 switch (op[2] & 0x00)
14774 {
14775 case 0x00:
14776 goto op_semantics_102;
14777 break;
14778 }
14779 break;
14780 case 0x52:
14781 GETBYTE ();
14782 switch (op[2] & 0x00)
14783 {
14784 case 0x00:
14785 goto op_semantics_102;
14786 break;
14787 }
14788 break;
14789 case 0x53:
14790 GETBYTE ();
14791 switch (op[2] & 0x00)
14792 {
14793 case 0x00:
14794 goto op_semantics_102;
14795 break;
14796 }
14797 break;
14798 case 0x54:
14799 GETBYTE ();
14800 switch (op[2] & 0x00)
14801 {
14802 case 0x00:
14803 goto op_semantics_102;
14804 break;
14805 }
14806 break;
14807 case 0x55:
14808 GETBYTE ();
14809 switch (op[2] & 0x00)
14810 {
14811 case 0x00:
14812 goto op_semantics_102;
14813 break;
14814 }
14815 break;
14816 case 0x56:
14817 GETBYTE ();
14818 switch (op[2] & 0x00)
14819 {
14820 case 0x00:
14821 goto op_semantics_102;
14822 break;
14823 }
14824 break;
14825 case 0x57:
14826 GETBYTE ();
14827 switch (op[2] & 0x00)
14828 {
14829 case 0x00:
14830 goto op_semantics_102;
14831 break;
14832 }
14833 break;
14834 case 0x58:
14835 GETBYTE ();
14836 switch (op[2] & 0x00)
14837 {
14838 case 0x00:
14839 goto op_semantics_102;
14840 break;
14841 }
14842 break;
14843 case 0x59:
14844 GETBYTE ();
14845 switch (op[2] & 0x00)
14846 {
14847 case 0x00:
14848 goto op_semantics_102;
14849 break;
14850 }
14851 break;
14852 case 0x5a:
14853 GETBYTE ();
14854 switch (op[2] & 0x00)
14855 {
14856 case 0x00:
14857 goto op_semantics_102;
14858 break;
14859 }
14860 break;
14861 case 0x5b:
14862 GETBYTE ();
14863 switch (op[2] & 0x00)
14864 {
14865 case 0x00:
14866 goto op_semantics_102;
14867 break;
14868 }
14869 break;
14870 case 0x5c:
14871 GETBYTE ();
14872 switch (op[2] & 0x00)
14873 {
14874 case 0x00:
14875 goto op_semantics_102;
14876 break;
14877 }
14878 break;
14879 case 0x5d:
14880 GETBYTE ();
14881 switch (op[2] & 0x00)
14882 {
14883 case 0x00:
14884 goto op_semantics_102;
14885 break;
14886 }
14887 break;
14888 case 0x5e:
14889 GETBYTE ();
14890 switch (op[2] & 0x00)
14891 {
14892 case 0x00:
14893 goto op_semantics_102;
14894 break;
14895 }
14896 break;
14897 case 0x5f:
14898 GETBYTE ();
14899 switch (op[2] & 0x00)
14900 {
14901 case 0x00:
14902 goto op_semantics_102;
14903 break;
14904 }
14905 break;
14906 default: UNSUPPORTED(); break;
14907 }
14908 break;
14909 default: UNSUPPORTED(); break;
14910 }
14911#line 1005 "rx-decode.opc"
14912
14913 return rx->n_bytes;
14914}
GDB Binutils - Deliverables
This page took 0.077222 seconds and 4 git commands to generate.