]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - opcodes/rx-decode.c
projects / thirdparty / binutils-gdb.git / blob
? search:


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