projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MI: Add new command -complete
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
1 /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
2 #line 1 "rx-decode.opc"
3 /* -*- c -*- */
4 /* Copyright (C) 2012-2019 Free Software Foundation, Inc.
5 Contributed by Red Hat.
6 Written by DJ Delorie.
7
8 This file is part of the GNU opcodes library.
9
10 This library is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
14
15 It is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
18 License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
24
25 #include "sysdep.h"
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include "ansidecl.h"
30 #include "opcode/rx.h"
31 #include "libiberty.h"
32
33 #define RX_OPCODE_BIG_ENDIAN 0
34
35 typedef struct
36 {
37 RX_Opcode_Decoded * rx;
38 int (* getbyte)(void *);
39 void * ptr;
40 unsigned char * op;
41 } LocalData;
42
43 static int trace = 0;
44
45 #define BSIZE 0
46 #define WSIZE 1
47 #define LSIZE 2
48 #define DSIZE 3
49
50 /* These are for when the upper bits are "don't care" or "undefined". */
51 static int bwl[4] =
52 {
53 RX_Byte,
54 RX_Word,
55 RX_Long,
56 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
57 };
58
59 static int sbwl[4] =
60 {
61 RX_SByte,
62 RX_SWord,
63 RX_Long,
64 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
65 };
66
67 static int ubw[4] =
68 {
69 RX_UByte,
70 RX_UWord,
71 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
72 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
73 };
74
75 static int memex[4] =
76 {
77 RX_SByte,
78 RX_SWord,
79 RX_Long,
80 RX_UWord
81 };
82
83 static int _ld[2] =
84 {
85 RX_Long,
86 RX_Double
87 };
88
89 #define ID(x) rx->id = RXO_##x
90 #define OP(n,t,r,a) (rx->op[n].type = t, \
91 rx->op[n].reg = r, \
92 rx->op[n].addend = a )
93 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
94 rx->op[n].size = s )
95
96 /* This is for the BWL and BW bitfields. */
97 static int SCALE[] = { 1, 2, 4, 0 };
98 /* This is for the prefix size enum. */
99 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4, 8 };
100
101 #define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
102 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
103
104 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
105 16, 17, 0, 0, 0, 0, 0, 0 };
106
107 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
108
109 /*
110 *C a constant (immediate) c
111 *R A register
112 *I Register indirect, no offset
113 *Is Register indirect, with offset
114 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
115 *P standard displacement: type (r,[r]), reg, assumes UByte
116 *Pm memex displacement: type (r,[r]), reg, memex code
117 *cc condition code. */
118
119 #define DC(c) OP (0, RX_Operand_Immediate, 0, c)
120 #define DR(r) OP (0, RX_Operand_Register, r, 0)
121 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
122 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
123 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
124 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
125 #define DCR(r) OP (0, RX_Operand_DoubleCReg, r, 0)
126 #define DDR(r) OP (0, RX_Operand_DoubleReg, r, 0)
127 #define DDRH(r) OP (0, RX_Operand_DoubleRegH, r, 0)
128 #define DDRL(r) OP (0, RX_Operand_DoubleRegL, r, 0)
129 #define DCND(r) OP (0, RX_Operand_DoubleCond, r, 0)
130
131 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
132 #define SR(r) OP (1, RX_Operand_Register, r, 0)
133 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
134 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
135 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
136 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
137 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
138 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
139 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
140 #define SCR(r) OP (1, RX_Operand_DoubleCReg, r, 0)
141 #define SDR(r) OP (1, RX_Operand_DoubleReg, r, 0)
142 #define SDRH(r) OP (1, RX_Operand_DoubleRegH, r, 0)
143 #define SDRL(r) OP (1, RX_Operand_DoubleRegL, r, 0)
144
145 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
146 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
147 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
148 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
149 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
150 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
151 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
152 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
153 #define S2DR(r) OP (2, RX_Operand_DoubleReg, r, 0)
154 #define S2CR(r) OP (2, RX_Operand_DoubleCReg, r, 0)
155
156 #define SDD(t,r,s) rx_disp (1, t, r, bwl, ld);
157
158 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
159 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
160 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
161 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
162 #define DL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz]
163
164 #define F(f) store_flags(rx, f)
165
166 #define AU ATTRIBUTE_UNUSED
167 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
168
169 #define SYNTAX(x) rx->syntax = x
170
171 #define UNSUPPORTED() \
172 rx->syntax = "*unknown*"
173
174 #define IMM(sf) immediate (sf, 0, ld)
175 #define IMMex(sf) immediate (sf, 1, ld)
176
177 static int
178 immediate (int sfield, int ex, LocalData * ld)
179 {
180 unsigned long i = 0, j;
181
182 switch (sfield)
183 {
184 #define B ((unsigned long) GETBYTE())
185 case 0:
186 #if RX_OPCODE_BIG_ENDIAN
187 i = B;
188 if (ex && (i & 0x80))
189 i -= 0x100;
190 i <<= 24;
191 i |= B << 16;
192 i |= B << 8;
193 i |= B;
194 #else
195 i = B;
196 i |= B << 8;
197 i |= B << 16;
198 j = B;
199 if (ex && (j & 0x80))
200 j -= 0x100;
201 i |= j << 24;
202 #endif
203 break;
204 case 3:
205 #if RX_OPCODE_BIG_ENDIAN
206 i = B << 16;
207 i |= B << 8;
208 i |= B;
209 #else
210 i = B;
211 i |= B << 8;
212 i |= B << 16;
213 #endif
214 if (ex && (i & 0x800000))
215 i -= 0x1000000;
216 break;
217 case 2:
218 #if RX_OPCODE_BIG_ENDIAN
219 i |= B << 8;
220 i |= B;
221 #else
222 i |= B;
223 i |= B << 8;
224 #endif
225 if (ex && (i & 0x8000))
226 i -= 0x10000;
227 break;
228 case 1:
229 i |= B;
230 if (ex && (i & 0x80))
231 i -= 0x100;
232 break;
233 default:
234 abort();
235 }
236 return i;
237 }
238
239 static void
240 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
241 {
242 int disp;
243
244 ld->rx->op[n].reg = reg;
245 switch (type)
246 {
247 case 3:
248 ld->rx->op[n].type = RX_Operand_Register;
249 break;
250 case 0:
251 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
252 ld->rx->op[n].addend = 0;
253 break;
254 case 1:
255 ld->rx->op[n].type = RX_Operand_Indirect;
256 disp = GETBYTE ();
257 ld->rx->op[n].addend = disp * GET_PSCALE (size);
258 break;
259 case 2:
260 ld->rx->op[n].type = RX_Operand_Indirect;
261 disp = GETBYTE ();
262 #if RX_OPCODE_BIG_ENDIAN
263 disp = disp * 256 + GETBYTE ();
264 #else
265 disp = disp + GETBYTE () * 256;
266 #endif
267 ld->rx->op[n].addend = disp * GET_PSCALE (size);
268 break;
269 default:
270 abort ();
271 }
272 }
273
274 #define xO 8
275 #define xS 4
276 #define xZ 2
277 #define xC 1
278
279 #define F_____
280 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
281 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
282 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
283 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
284 #define F_O___ rx->flags_0 = rx->flags_s = xO;
285 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
286 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
287 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
288
289 int
290 rx_decode_opcode (unsigned long pc AU,
291 RX_Opcode_Decoded * rx,
292 int (* getbyte)(void *),
293 void * ptr)
294 {
295 LocalData lds, * ld = &lds;
296 unsigned char op[20] = {0};
297
298 lds.rx = rx;
299 lds.getbyte = getbyte;
300 lds.ptr = ptr;
301 lds.op = op;
302
303 memset (rx, 0, sizeof (*rx));
304 BWL(LSIZE);
305
306
307 /*----------------------------------------------------------------------*/
308 /* MOV */
309
310 GETBYTE ();
311 switch (op[0] & 0xff)
312 {
313 case 0x00:
314 {
315 /** 0000 0000 brk */
316 if (trace)
317 {
318 printf ("\033[33m%s\033[0m %02x\n",
319 "/** 0000 0000 brk */",
320 op[0]);
321 }
322 SYNTAX("brk");
323 #line 1050 "rx-decode.opc"
324 ID(brk);
325
326 }
327 break;
328 case 0x01:
329 {
330 /** 0000 0001 dbt */
331 if (trace)
332 {
333 printf ("\033[33m%s\033[0m %02x\n",
334 "/** 0000 0001 dbt */",
335 op[0]);
336 }
337 SYNTAX("dbt");
338 #line 1053 "rx-decode.opc"
339 ID(dbt);
340
341 }
342 break;
343 case 0x02:
344 {
345 /** 0000 0010 rts */
346 if (trace)
347 {
348 printf ("\033[33m%s\033[0m %02x\n",
349 "/** 0000 0010 rts */",
350 op[0]);
351 }
352 SYNTAX("rts");
353 #line 831 "rx-decode.opc"
354 ID(rts);
355
356 /*----------------------------------------------------------------------*/
357 /* NOP */
358
359 }
360 break;
361 case 0x03:
362 {
363 /** 0000 0011 nop */
364 if (trace)
365 {
366 printf ("\033[33m%s\033[0m %02x\n",
367 "/** 0000 0011 nop */",
368 op[0]);
369 }
370 SYNTAX("nop");
371 #line 837 "rx-decode.opc"
372 ID(nop);
373
374 /*----------------------------------------------------------------------*/
375 /* STRING FUNCTIONS */
376
377 }
378 break;
379 case 0x04:
380 {
381 /** 0000 0100 bra.a %a0 */
382 if (trace)
383 {
384 printf ("\033[33m%s\033[0m %02x\n",
385 "/** 0000 0100 bra.a %a0 */",
386 op[0]);
387 }
388 SYNTAX("bra.a %a0");
389 #line 809 "rx-decode.opc"
390 ID(branch); DC(pc + IMMex(3));
391
392 }
393 break;
394 case 0x05:
395 {
396 /** 0000 0101 bsr.a %a0 */
397 if (trace)
398 {
399 printf ("\033[33m%s\033[0m %02x\n",
400 "/** 0000 0101 bsr.a %a0 */",
401 op[0]);
402 }
403 SYNTAX("bsr.a %a0");
404 #line 825 "rx-decode.opc"
405 ID(jsr); DC(pc + IMMex(3));
406
407 }
408 break;
409 case 0x06:
410 GETBYTE ();
411 switch (op[1] & 0xff)
412 {
413 case 0x00:
414 GETBYTE ();
415 switch (op[2] & 0x00)
416 {
417 case 0x00:
418 op_semantics_1:
419 {
420 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
421 #line 567 "rx-decode.opc"
422 int mx AU = (op[1] >> 6) & 0x03;
423 #line 567 "rx-decode.opc"
424 int ss AU = op[1] & 0x03;
425 #line 567 "rx-decode.opc"
426 int rsrc AU = (op[2] >> 4) & 0x0f;
427 #line 567 "rx-decode.opc"
428 int rdst AU = op[2] & 0x0f;
429 if (trace)
430 {
431 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
432 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
433 op[0], op[1], op[2]);
434 printf (" mx = 0x%x,", mx);
435 printf (" ss = 0x%x,", ss);
436 printf (" rsrc = 0x%x,", rsrc);
437 printf (" rdst = 0x%x\n", rdst);
438 }
439 SYNTAX("sub %2%S2, %1");
440 #line 567 "rx-decode.opc"
441 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
442
443 }
444 break;
445 }
446 break;
447 case 0x01:
448 GETBYTE ();
449 switch (op[2] & 0x00)
450 {
451 case 0x00:
452 goto op_semantics_1;
453 break;
454 }
455 break;
456 case 0x02:
457 GETBYTE ();
458 switch (op[2] & 0x00)
459 {
460 case 0x00:
461 goto op_semantics_1;
462 break;
463 }
464 break;
465 case 0x03:
466 GETBYTE ();
467 switch (op[2] & 0x00)
468 {
469 case 0x00:
470 goto op_semantics_1;
471 break;
472 }
473 break;
474 case 0x04:
475 GETBYTE ();
476 switch (op[2] & 0x00)
477 {
478 case 0x00:
479 op_semantics_2:
480 {
481 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
482 #line 555 "rx-decode.opc"
483 int mx AU = (op[1] >> 6) & 0x03;
484 #line 555 "rx-decode.opc"
485 int ss AU = op[1] & 0x03;
486 #line 555 "rx-decode.opc"
487 int rsrc AU = (op[2] >> 4) & 0x0f;
488 #line 555 "rx-decode.opc"
489 int rdst AU = op[2] & 0x0f;
490 if (trace)
491 {
492 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
493 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
494 op[0], op[1], op[2]);
495 printf (" mx = 0x%x,", mx);
496 printf (" ss = 0x%x,", ss);
497 printf (" rsrc = 0x%x,", rsrc);
498 printf (" rdst = 0x%x\n", rdst);
499 }
500 SYNTAX("cmp %2%S2, %1");
501 #line 555 "rx-decode.opc"
502 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
503
504 /*----------------------------------------------------------------------*/
505 /* SUB */
506
507 }
508 break;
509 }
510 break;
511 case 0x05:
512 GETBYTE ();
513 switch (op[2] & 0x00)
514 {
515 case 0x00:
516 goto op_semantics_2;
517 break;
518 }
519 break;
520 case 0x06:
521 GETBYTE ();
522 switch (op[2] & 0x00)
523 {
524 case 0x00:
525 goto op_semantics_2;
526 break;
527 }
528 break;
529 case 0x07:
530 GETBYTE ();
531 switch (op[2] & 0x00)
532 {
533 case 0x00:
534 goto op_semantics_2;
535 break;
536 }
537 break;
538 case 0x08:
539 GETBYTE ();
540 switch (op[2] & 0x00)
541 {
542 case 0x00:
543 op_semantics_3:
544 {
545 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
546 #line 531 "rx-decode.opc"
547 int mx AU = (op[1] >> 6) & 0x03;
548 #line 531 "rx-decode.opc"
549 int ss AU = op[1] & 0x03;
550 #line 531 "rx-decode.opc"
551 int rsrc AU = (op[2] >> 4) & 0x0f;
552 #line 531 "rx-decode.opc"
553 int rdst AU = op[2] & 0x0f;
554 if (trace)
555 {
556 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
557 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
558 op[0], op[1], op[2]);
559 printf (" mx = 0x%x,", mx);
560 printf (" ss = 0x%x,", ss);
561 printf (" rsrc = 0x%x,", rsrc);
562 printf (" rdst = 0x%x\n", rdst);
563 }
564 SYNTAX("add %1%S1, %0");
565 #line 531 "rx-decode.opc"
566 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
567
568 }
569 break;
570 }
571 break;
572 case 0x09:
573 GETBYTE ();
574 switch (op[2] & 0x00)
575 {
576 case 0x00:
577 goto op_semantics_3;
578 break;
579 }
580 break;
581 case 0x0a:
582 GETBYTE ();
583 switch (op[2] & 0x00)
584 {
585 case 0x00:
586 goto op_semantics_3;
587 break;
588 }
589 break;
590 case 0x0b:
591 GETBYTE ();
592 switch (op[2] & 0x00)
593 {
594 case 0x00:
595 goto op_semantics_3;
596 break;
597 }
598 break;
599 case 0x0c:
600 GETBYTE ();
601 switch (op[2] & 0x00)
602 {
603 case 0x00:
604 op_semantics_4:
605 {
606 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
607 #line 674 "rx-decode.opc"
608 int mx AU = (op[1] >> 6) & 0x03;
609 #line 674 "rx-decode.opc"
610 int ss AU = op[1] & 0x03;
611 #line 674 "rx-decode.opc"
612 int rsrc AU = (op[2] >> 4) & 0x0f;
613 #line 674 "rx-decode.opc"
614 int rdst AU = op[2] & 0x0f;
615 if (trace)
616 {
617 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
618 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
619 op[0], op[1], op[2]);
620 printf (" mx = 0x%x,", mx);
621 printf (" ss = 0x%x,", ss);
622 printf (" rsrc = 0x%x,", rsrc);
623 printf (" rdst = 0x%x\n", rdst);
624 }
625 SYNTAX("mul %1%S1, %0");
626 #line 674 "rx-decode.opc"
627 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
628
629 }
630 break;
631 }
632 break;
633 case 0x0d:
634 GETBYTE ();
635 switch (op[2] & 0x00)
636 {
637 case 0x00:
638 goto op_semantics_4;
639 break;
640 }
641 break;
642 case 0x0e:
643 GETBYTE ();
644 switch (op[2] & 0x00)
645 {
646 case 0x00:
647 goto op_semantics_4;
648 break;
649 }
650 break;
651 case 0x0f:
652 GETBYTE ();
653 switch (op[2] & 0x00)
654 {
655 case 0x00:
656 goto op_semantics_4;
657 break;
658 }
659 break;
660 case 0x10:
661 GETBYTE ();
662 switch (op[2] & 0x00)
663 {
664 case 0x00:
665 op_semantics_5:
666 {
667 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
668 #line 444 "rx-decode.opc"
669 int mx AU = (op[1] >> 6) & 0x03;
670 #line 444 "rx-decode.opc"
671 int ss AU = op[1] & 0x03;
672 #line 444 "rx-decode.opc"
673 int rsrc AU = (op[2] >> 4) & 0x0f;
674 #line 444 "rx-decode.opc"
675 int rdst AU = op[2] & 0x0f;
676 if (trace)
677 {
678 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
679 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
680 op[0], op[1], op[2]);
681 printf (" mx = 0x%x,", mx);
682 printf (" ss = 0x%x,", ss);
683 printf (" rsrc = 0x%x,", rsrc);
684 printf (" rdst = 0x%x\n", rdst);
685 }
686 SYNTAX("and %1%S1, %0");
687 #line 444 "rx-decode.opc"
688 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
689
690 }
691 break;
692 }
693 break;
694 case 0x11:
695 GETBYTE ();
696 switch (op[2] & 0x00)
697 {
698 case 0x00:
699 goto op_semantics_5;
700 break;
701 }
702 break;
703 case 0x12:
704 GETBYTE ();
705 switch (op[2] & 0x00)
706 {
707 case 0x00:
708 goto op_semantics_5;
709 break;
710 }
711 break;
712 case 0x13:
713 GETBYTE ();
714 switch (op[2] & 0x00)
715 {
716 case 0x00:
717 goto op_semantics_5;
718 break;
719 }
720 break;
721 case 0x14:
722 GETBYTE ();
723 switch (op[2] & 0x00)
724 {
725 case 0x00:
726 op_semantics_6:
727 {
728 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
729 #line 462 "rx-decode.opc"
730 int mx AU = (op[1] >> 6) & 0x03;
731 #line 462 "rx-decode.opc"
732 int ss AU = op[1] & 0x03;
733 #line 462 "rx-decode.opc"
734 int rsrc AU = (op[2] >> 4) & 0x0f;
735 #line 462 "rx-decode.opc"
736 int rdst AU = op[2] & 0x0f;
737 if (trace)
738 {
739 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
740 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
741 op[0], op[1], op[2]);
742 printf (" mx = 0x%x,", mx);
743 printf (" ss = 0x%x,", ss);
744 printf (" rsrc = 0x%x,", rsrc);
745 printf (" rdst = 0x%x\n", rdst);
746 }
747 SYNTAX("or %1%S1, %0");
748 #line 462 "rx-decode.opc"
749 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
750
751 }
752 break;
753 }
754 break;
755 case 0x15:
756 GETBYTE ();
757 switch (op[2] & 0x00)
758 {
759 case 0x00:
760 goto op_semantics_6;
761 break;
762 }
763 break;
764 case 0x16:
765 GETBYTE ();
766 switch (op[2] & 0x00)
767 {
768 case 0x00:
769 goto op_semantics_6;
770 break;
771 }
772 break;
773 case 0x17:
774 GETBYTE ();
775 switch (op[2] & 0x00)
776 {
777 case 0x00:
778 goto op_semantics_6;
779 break;
780 }
781 break;
782 case 0x20:
783 GETBYTE ();
784 switch (op[2] & 0xff)
785 {
786 case 0x00:
787 GETBYTE ();
788 switch (op[3] & 0x00)
789 {
790 case 0x00:
791 op_semantics_7:
792 {
793 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
794 #line 580 "rx-decode.opc"
795 int mx AU = (op[1] >> 6) & 0x03;
796 #line 580 "rx-decode.opc"
797 int sp AU = op[1] & 0x03;
798 #line 580 "rx-decode.opc"
799 int rsrc AU = (op[3] >> 4) & 0x0f;
800 #line 580 "rx-decode.opc"
801 int rdst AU = op[3] & 0x0f;
802 if (trace)
803 {
804 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
805 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
806 op[0], op[1], op[2], op[3]);
807 printf (" mx = 0x%x,", mx);
808 printf (" sp = 0x%x,", sp);
809 printf (" rsrc = 0x%x,", rsrc);
810 printf (" rdst = 0x%x\n", rdst);
811 }
812 SYNTAX("sbb %1%S1, %0");
813 #line 580 "rx-decode.opc"
814 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
815
816 /*----------------------------------------------------------------------*/
817 /* ABS */
818
819 }
820 break;
821 }
822 break;
823 case 0x04:
824 GETBYTE ();
825 switch (op[3] & 0x00)
826 {
827 case 0x00:
828 op_semantics_8:
829 {
830 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
831 #line 619 "rx-decode.opc"
832 int mx AU = (op[1] >> 6) & 0x03;
833 #line 619 "rx-decode.opc"
834 int ss AU = op[1] & 0x03;
835 #line 619 "rx-decode.opc"
836 int rsrc AU = (op[3] >> 4) & 0x0f;
837 #line 619 "rx-decode.opc"
838 int rdst AU = op[3] & 0x0f;
839 if (trace)
840 {
841 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
842 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
843 op[0], op[1], op[2], op[3]);
844 printf (" mx = 0x%x,", mx);
845 printf (" ss = 0x%x,", ss);
846 printf (" rsrc = 0x%x,", rsrc);
847 printf (" rdst = 0x%x\n", rdst);
848 }
849 SYNTAX("max %1%S1, %0");
850 #line 619 "rx-decode.opc"
851 ID(max); SPm(ss, rsrc, mx); DR(rdst);
852
853 /*----------------------------------------------------------------------*/
854 /* MIN */
855
856 }
857 break;
858 }
859 break;
860 case 0x05:
861 GETBYTE ();
862 switch (op[3] & 0x00)
863 {
864 case 0x00:
865 op_semantics_9:
866 {
867 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
868 #line 631 "rx-decode.opc"
869 int mx AU = (op[1] >> 6) & 0x03;
870 #line 631 "rx-decode.opc"
871 int ss AU = op[1] & 0x03;
872 #line 631 "rx-decode.opc"
873 int rsrc AU = (op[3] >> 4) & 0x0f;
874 #line 631 "rx-decode.opc"
875 int rdst AU = op[3] & 0x0f;
876 if (trace)
877 {
878 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
879 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
880 op[0], op[1], op[2], op[3]);
881 printf (" mx = 0x%x,", mx);
882 printf (" ss = 0x%x,", ss);
883 printf (" rsrc = 0x%x,", rsrc);
884 printf (" rdst = 0x%x\n", rdst);
885 }
886 SYNTAX("min %1%S1, %0");
887 #line 631 "rx-decode.opc"
888 ID(min); SPm(ss, rsrc, mx); DR(rdst);
889
890 /*----------------------------------------------------------------------*/
891 /* MUL */
892
893 }
894 break;
895 }
896 break;
897 case 0x06:
898 GETBYTE ();
899 switch (op[3] & 0x00)
900 {
901 case 0x00:
902 op_semantics_10:
903 {
904 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
905 #line 689 "rx-decode.opc"
906 int mx AU = (op[1] >> 6) & 0x03;
907 #line 689 "rx-decode.opc"
908 int ss AU = op[1] & 0x03;
909 #line 689 "rx-decode.opc"
910 int rsrc AU = (op[3] >> 4) & 0x0f;
911 #line 689 "rx-decode.opc"
912 int rdst AU = op[3] & 0x0f;
913 if (trace)
914 {
915 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
916 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
917 op[0], op[1], op[2], op[3]);
918 printf (" mx = 0x%x,", mx);
919 printf (" ss = 0x%x,", ss);
920 printf (" rsrc = 0x%x,", rsrc);
921 printf (" rdst = 0x%x\n", rdst);
922 }
923 SYNTAX("emul %1%S1, %0");
924 #line 689 "rx-decode.opc"
925 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
926
927 /*----------------------------------------------------------------------*/
928 /* EMULU */
929
930 }
931 break;
932 }
933 break;
934 case 0x07:
935 GETBYTE ();
936 switch (op[3] & 0x00)
937 {
938 case 0x00:
939 op_semantics_11:
940 {
941 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
942 #line 701 "rx-decode.opc"
943 int mx AU = (op[1] >> 6) & 0x03;
944 #line 701 "rx-decode.opc"
945 int ss AU = op[1] & 0x03;
946 #line 701 "rx-decode.opc"
947 int rsrc AU = (op[3] >> 4) & 0x0f;
948 #line 701 "rx-decode.opc"
949 int rdst AU = op[3] & 0x0f;
950 if (trace)
951 {
952 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
953 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
954 op[0], op[1], op[2], op[3]);
955 printf (" mx = 0x%x,", mx);
956 printf (" ss = 0x%x,", ss);
957 printf (" rsrc = 0x%x,", rsrc);
958 printf (" rdst = 0x%x\n", rdst);
959 }
960 SYNTAX("emulu %1%S1, %0");
961 #line 701 "rx-decode.opc"
962 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
963
964 /*----------------------------------------------------------------------*/
965 /* DIV */
966
967 }
968 break;
969 }
970 break;
971 case 0x08:
972 GETBYTE ();
973 switch (op[3] & 0x00)
974 {
975 case 0x00:
976 op_semantics_12:
977 {
978 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
979 #line 713 "rx-decode.opc"
980 int mx AU = (op[1] >> 6) & 0x03;
981 #line 713 "rx-decode.opc"
982 int ss AU = op[1] & 0x03;
983 #line 713 "rx-decode.opc"
984 int rsrc AU = (op[3] >> 4) & 0x0f;
985 #line 713 "rx-decode.opc"
986 int rdst AU = op[3] & 0x0f;
987 if (trace)
988 {
989 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
990 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
991 op[0], op[1], op[2], op[3]);
992 printf (" mx = 0x%x,", mx);
993 printf (" ss = 0x%x,", ss);
994 printf (" rsrc = 0x%x,", rsrc);
995 printf (" rdst = 0x%x\n", rdst);
996 }
997 SYNTAX("div %1%S1, %0");
998 #line 713 "rx-decode.opc"
999 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1000
1001 /*----------------------------------------------------------------------*/
1002 /* DIVU */
1003
1004 }
1005 break;
1006 }
1007 break;
1008 case 0x09:
1009 GETBYTE ();
1010 switch (op[3] & 0x00)
1011 {
1012 case 0x00:
1013 op_semantics_13:
1014 {
1015 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
1016 #line 725 "rx-decode.opc"
1017 int mx AU = (op[1] >> 6) & 0x03;
1018 #line 725 "rx-decode.opc"
1019 int ss AU = op[1] & 0x03;
1020 #line 725 "rx-decode.opc"
1021 int rsrc AU = (op[3] >> 4) & 0x0f;
1022 #line 725 "rx-decode.opc"
1023 int rdst AU = op[3] & 0x0f;
1024 if (trace)
1025 {
1026 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1027 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1028 op[0], op[1], op[2], op[3]);
1029 printf (" mx = 0x%x,", mx);
1030 printf (" ss = 0x%x,", ss);
1031 printf (" rsrc = 0x%x,", rsrc);
1032 printf (" rdst = 0x%x\n", rdst);
1033 }
1034 SYNTAX("divu %1%S1, %0");
1035 #line 725 "rx-decode.opc"
1036 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1037
1038 /*----------------------------------------------------------------------*/
1039 /* SHIFT */
1040
1041 }
1042 break;
1043 }
1044 break;
1045 case 0x0c:
1046 GETBYTE ();
1047 switch (op[3] & 0x00)
1048 {
1049 case 0x00:
1050 op_semantics_14:
1051 {
1052 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1053 #line 498 "rx-decode.opc"
1054 int mx AU = (op[1] >> 6) & 0x03;
1055 #line 498 "rx-decode.opc"
1056 int ss AU = op[1] & 0x03;
1057 #line 498 "rx-decode.opc"
1058 int rsrc AU = (op[3] >> 4) & 0x0f;
1059 #line 498 "rx-decode.opc"
1060 int rdst AU = op[3] & 0x0f;
1061 if (trace)
1062 {
1063 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1064 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1065 op[0], op[1], op[2], op[3]);
1066 printf (" mx = 0x%x,", mx);
1067 printf (" ss = 0x%x,", ss);
1068 printf (" rsrc = 0x%x,", rsrc);
1069 printf (" rdst = 0x%x\n", rdst);
1070 }
1071 SYNTAX("tst %1%S1, %2");
1072 #line 498 "rx-decode.opc"
1073 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1074
1075 /*----------------------------------------------------------------------*/
1076 /* NEG */
1077
1078 }
1079 break;
1080 }
1081 break;
1082 case 0x0d:
1083 GETBYTE ();
1084 switch (op[3] & 0x00)
1085 {
1086 case 0x00:
1087 op_semantics_15:
1088 {
1089 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1090 #line 477 "rx-decode.opc"
1091 int mx AU = (op[1] >> 6) & 0x03;
1092 #line 477 "rx-decode.opc"
1093 int ss AU = op[1] & 0x03;
1094 #line 477 "rx-decode.opc"
1095 int rsrc AU = (op[3] >> 4) & 0x0f;
1096 #line 477 "rx-decode.opc"
1097 int rdst AU = op[3] & 0x0f;
1098 if (trace)
1099 {
1100 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1101 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1102 op[0], op[1], op[2], op[3]);
1103 printf (" mx = 0x%x,", mx);
1104 printf (" ss = 0x%x,", ss);
1105 printf (" rsrc = 0x%x,", rsrc);
1106 printf (" rdst = 0x%x\n", rdst);
1107 }
1108 SYNTAX("xor %1%S1, %0");
1109 #line 477 "rx-decode.opc"
1110 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1111
1112 /*----------------------------------------------------------------------*/
1113 /* NOT */
1114
1115 }
1116 break;
1117 }
1118 break;
1119 case 0x10:
1120 GETBYTE ();
1121 switch (op[3] & 0x00)
1122 {
1123 case 0x00:
1124 op_semantics_16:
1125 {
1126 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1127 #line 411 "rx-decode.opc"
1128 int mx AU = (op[1] >> 6) & 0x03;
1129 #line 411 "rx-decode.opc"
1130 int ss AU = op[1] & 0x03;
1131 #line 411 "rx-decode.opc"
1132 int rsrc AU = (op[3] >> 4) & 0x0f;
1133 #line 411 "rx-decode.opc"
1134 int rdst AU = op[3] & 0x0f;
1135 if (trace)
1136 {
1137 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1138 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1139 op[0], op[1], op[2], op[3]);
1140 printf (" mx = 0x%x,", mx);
1141 printf (" ss = 0x%x,", ss);
1142 printf (" rsrc = 0x%x,", rsrc);
1143 printf (" rdst = 0x%x\n", rdst);
1144 }
1145 SYNTAX("xchg %1%S1, %0");
1146 #line 411 "rx-decode.opc"
1147 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1148
1149 /*----------------------------------------------------------------------*/
1150 /* STZ/STNZ */
1151
1152 }
1153 break;
1154 }
1155 break;
1156 case 0x11:
1157 GETBYTE ();
1158 switch (op[3] & 0x00)
1159 {
1160 case 0x00:
1161 op_semantics_17:
1162 {
1163 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1164 #line 954 "rx-decode.opc"
1165 int mx AU = (op[1] >> 6) & 0x03;
1166 #line 954 "rx-decode.opc"
1167 int sd AU = op[1] & 0x03;
1168 #line 954 "rx-decode.opc"
1169 int rsrc AU = (op[3] >> 4) & 0x0f;
1170 #line 954 "rx-decode.opc"
1171 int rdst AU = op[3] & 0x0f;
1172 if (trace)
1173 {
1174 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1175 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1176 op[0], op[1], op[2], op[3]);
1177 printf (" mx = 0x%x,", mx);
1178 printf (" sd = 0x%x,", sd);
1179 printf (" rsrc = 0x%x,", rsrc);
1180 printf (" rdst = 0x%x\n", rdst);
1181 }
1182 SYNTAX("itof %1%S1, %0");
1183 #line 954 "rx-decode.opc"
1184 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1185
1186 /*----------------------------------------------------------------------*/
1187 /* BIT OPS */
1188
1189 }
1190 break;
1191 }
1192 break;
1193 case 0x15:
1194 GETBYTE ();
1195 switch (op[3] & 0x00)
1196 {
1197 case 0x00:
1198 op_semantics_18:
1199 {
1200 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
1201 #line 1140 "rx-decode.opc"
1202 int mx AU = (op[1] >> 6) & 0x03;
1203 #line 1140 "rx-decode.opc"
1204 int sd AU = op[1] & 0x03;
1205 #line 1140 "rx-decode.opc"
1206 int rsrc AU = (op[3] >> 4) & 0x0f;
1207 #line 1140 "rx-decode.opc"
1208 int rdst AU = op[3] & 0x0f;
1209 if (trace)
1210 {
1211 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1212 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1213 op[0], op[1], op[2], op[3]);
1214 printf (" mx = 0x%x,", mx);
1215 printf (" sd = 0x%x,", sd);
1216 printf (" rsrc = 0x%x,", rsrc);
1217 printf (" rdst = 0x%x\n", rdst);
1218 }
1219 SYNTAX("utof %1%S1, %0");
1220 #line 1140 "rx-decode.opc"
1221 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1222
1223 /*----------------------------------------------------------------------*/
1224 /* RXv3 enhanced */
1225
1226 }
1227 break;
1228 }
1229 break;
1230 default: UNSUPPORTED(); break;
1231 }
1232 break;
1233 case 0x21:
1234 GETBYTE ();
1235 switch (op[2] & 0xff)
1236 {
1237 case 0x00:
1238 GETBYTE ();
1239 switch (op[3] & 0x00)
1240 {
1241 case 0x00:
1242 goto op_semantics_7;
1243 break;
1244 }
1245 break;
1246 case 0x04:
1247 GETBYTE ();
1248 switch (op[3] & 0x00)
1249 {
1250 case 0x00:
1251 goto op_semantics_8;
1252 break;
1253 }
1254 break;
1255 case 0x05:
1256 GETBYTE ();
1257 switch (op[3] & 0x00)
1258 {
1259 case 0x00:
1260 goto op_semantics_9;
1261 break;
1262 }
1263 break;
1264 case 0x06:
1265 GETBYTE ();
1266 switch (op[3] & 0x00)
1267 {
1268 case 0x00:
1269 goto op_semantics_10;
1270 break;
1271 }
1272 break;
1273 case 0x07:
1274 GETBYTE ();
1275 switch (op[3] & 0x00)
1276 {
1277 case 0x00:
1278 goto op_semantics_11;
1279 break;
1280 }
1281 break;
1282 case 0x08:
1283 GETBYTE ();
1284 switch (op[3] & 0x00)
1285 {
1286 case 0x00:
1287 goto op_semantics_12;
1288 break;
1289 }
1290 break;
1291 case 0x09:
1292 GETBYTE ();
1293 switch (op[3] & 0x00)
1294 {
1295 case 0x00:
1296 goto op_semantics_13;
1297 break;
1298 }
1299 break;
1300 case 0x0c:
1301 GETBYTE ();
1302 switch (op[3] & 0x00)
1303 {
1304 case 0x00:
1305 goto op_semantics_14;
1306 break;
1307 }
1308 break;
1309 case 0x0d:
1310 GETBYTE ();
1311 switch (op[3] & 0x00)
1312 {
1313 case 0x00:
1314 goto op_semantics_15;
1315 break;
1316 }
1317 break;
1318 case 0x10:
1319 GETBYTE ();
1320 switch (op[3] & 0x00)
1321 {
1322 case 0x00:
1323 goto op_semantics_16;
1324 break;
1325 }
1326 break;
1327 case 0x11:
1328 GETBYTE ();
1329 switch (op[3] & 0x00)
1330 {
1331 case 0x00:
1332 goto op_semantics_17;
1333 break;
1334 }
1335 break;
1336 case 0x15:
1337 GETBYTE ();
1338 switch (op[3] & 0x00)
1339 {
1340 case 0x00:
1341 goto op_semantics_18;
1342 break;
1343 }
1344 break;
1345 default: UNSUPPORTED(); break;
1346 }
1347 break;
1348 case 0x22:
1349 GETBYTE ();
1350 switch (op[2] & 0xff)
1351 {
1352 case 0x00:
1353 GETBYTE ();
1354 switch (op[3] & 0x00)
1355 {
1356 case 0x00:
1357 goto op_semantics_7;
1358 break;
1359 }
1360 break;
1361 case 0x04:
1362 GETBYTE ();
1363 switch (op[3] & 0x00)
1364 {
1365 case 0x00:
1366 goto op_semantics_8;
1367 break;
1368 }
1369 break;
1370 case 0x05:
1371 GETBYTE ();
1372 switch (op[3] & 0x00)
1373 {
1374 case 0x00:
1375 goto op_semantics_9;
1376 break;
1377 }
1378 break;
1379 case 0x06:
1380 GETBYTE ();
1381 switch (op[3] & 0x00)
1382 {
1383 case 0x00:
1384 goto op_semantics_10;
1385 break;
1386 }
1387 break;
1388 case 0x07:
1389 GETBYTE ();
1390 switch (op[3] & 0x00)
1391 {
1392 case 0x00:
1393 goto op_semantics_11;
1394 break;
1395 }
1396 break;
1397 case 0x08:
1398 GETBYTE ();
1399 switch (op[3] & 0x00)
1400 {
1401 case 0x00:
1402 goto op_semantics_12;
1403 break;
1404 }
1405 break;
1406 case 0x09:
1407 GETBYTE ();
1408 switch (op[3] & 0x00)
1409 {
1410 case 0x00:
1411 goto op_semantics_13;
1412 break;
1413 }
1414 break;
1415 case 0x0c:
1416 GETBYTE ();
1417 switch (op[3] & 0x00)
1418 {
1419 case 0x00:
1420 goto op_semantics_14;
1421 break;
1422 }
1423 break;
1424 case 0x0d:
1425 GETBYTE ();
1426 switch (op[3] & 0x00)
1427 {
1428 case 0x00:
1429 goto op_semantics_15;
1430 break;
1431 }
1432 break;
1433 case 0x10:
1434 GETBYTE ();
1435 switch (op[3] & 0x00)
1436 {
1437 case 0x00:
1438 goto op_semantics_16;
1439 break;
1440 }
1441 break;
1442 case 0x11:
1443 GETBYTE ();
1444 switch (op[3] & 0x00)
1445 {
1446 case 0x00:
1447 goto op_semantics_17;
1448 break;
1449 }
1450 break;
1451 case 0x15:
1452 GETBYTE ();
1453 switch (op[3] & 0x00)
1454 {
1455 case 0x00:
1456 goto op_semantics_18;
1457 break;
1458 }
1459 break;
1460 default: UNSUPPORTED(); break;
1461 }
1462 break;
1463 case 0x23:
1464 GETBYTE ();
1465 switch (op[2] & 0xff)
1466 {
1467 case 0x00:
1468 GETBYTE ();
1469 switch (op[3] & 0x00)
1470 {
1471 case 0x00:
1472 goto op_semantics_7;
1473 break;
1474 }
1475 break;
1476 case 0x04:
1477 GETBYTE ();
1478 switch (op[3] & 0x00)
1479 {
1480 case 0x00:
1481 goto op_semantics_8;
1482 break;
1483 }
1484 break;
1485 case 0x05:
1486 GETBYTE ();
1487 switch (op[3] & 0x00)
1488 {
1489 case 0x00:
1490 goto op_semantics_9;
1491 break;
1492 }
1493 break;
1494 case 0x06:
1495 GETBYTE ();
1496 switch (op[3] & 0x00)
1497 {
1498 case 0x00:
1499 goto op_semantics_10;
1500 break;
1501 }
1502 break;
1503 case 0x07:
1504 GETBYTE ();
1505 switch (op[3] & 0x00)
1506 {
1507 case 0x00:
1508 goto op_semantics_11;
1509 break;
1510 }
1511 break;
1512 case 0x08:
1513 GETBYTE ();
1514 switch (op[3] & 0x00)
1515 {
1516 case 0x00:
1517 goto op_semantics_12;
1518 break;
1519 }
1520 break;
1521 case 0x09:
1522 GETBYTE ();
1523 switch (op[3] & 0x00)
1524 {
1525 case 0x00:
1526 goto op_semantics_13;
1527 break;
1528 }
1529 break;
1530 case 0x0c:
1531 GETBYTE ();
1532 switch (op[3] & 0x00)
1533 {
1534 case 0x00:
1535 goto op_semantics_14;
1536 break;
1537 }
1538 break;
1539 case 0x0d:
1540 GETBYTE ();
1541 switch (op[3] & 0x00)
1542 {
1543 case 0x00:
1544 goto op_semantics_15;
1545 break;
1546 }
1547 break;
1548 case 0x10:
1549 GETBYTE ();
1550 switch (op[3] & 0x00)
1551 {
1552 case 0x00:
1553 goto op_semantics_16;
1554 break;
1555 }
1556 break;
1557 case 0x11:
1558 GETBYTE ();
1559 switch (op[3] & 0x00)
1560 {
1561 case 0x00:
1562 goto op_semantics_17;
1563 break;
1564 }
1565 break;
1566 case 0x15:
1567 GETBYTE ();
1568 switch (op[3] & 0x00)
1569 {
1570 case 0x00:
1571 goto op_semantics_18;
1572 break;
1573 }
1574 break;
1575 default: UNSUPPORTED(); break;
1576 }
1577 break;
1578 case 0x40:
1579 GETBYTE ();
1580 switch (op[2] & 0x00)
1581 {
1582 case 0x00:
1583 goto op_semantics_1;
1584 break;
1585 }
1586 break;
1587 case 0x41:
1588 GETBYTE ();
1589 switch (op[2] & 0x00)
1590 {
1591 case 0x00:
1592 goto op_semantics_1;
1593 break;
1594 }
1595 break;
1596 case 0x42:
1597 GETBYTE ();
1598 switch (op[2] & 0x00)
1599 {
1600 case 0x00:
1601 goto op_semantics_1;
1602 break;
1603 }
1604 break;
1605 case 0x43:
1606 GETBYTE ();
1607 switch (op[2] & 0x00)
1608 {
1609 case 0x00:
1610 goto op_semantics_1;
1611 break;
1612 }
1613 break;
1614 case 0x44:
1615 GETBYTE ();
1616 switch (op[2] & 0x00)
1617 {
1618 case 0x00:
1619 goto op_semantics_2;
1620 break;
1621 }
1622 break;
1623 case 0x45:
1624 GETBYTE ();
1625 switch (op[2] & 0x00)
1626 {
1627 case 0x00:
1628 goto op_semantics_2;
1629 break;
1630 }
1631 break;
1632 case 0x46:
1633 GETBYTE ();
1634 switch (op[2] & 0x00)
1635 {
1636 case 0x00:
1637 goto op_semantics_2;
1638 break;
1639 }
1640 break;
1641 case 0x47:
1642 GETBYTE ();
1643 switch (op[2] & 0x00)
1644 {
1645 case 0x00:
1646 goto op_semantics_2;
1647 break;
1648 }
1649 break;
1650 case 0x48:
1651 GETBYTE ();
1652 switch (op[2] & 0x00)
1653 {
1654 case 0x00:
1655 goto op_semantics_3;
1656 break;
1657 }
1658 break;
1659 case 0x49:
1660 GETBYTE ();
1661 switch (op[2] & 0x00)
1662 {
1663 case 0x00:
1664 goto op_semantics_3;
1665 break;
1666 }
1667 break;
1668 case 0x4a:
1669 GETBYTE ();
1670 switch (op[2] & 0x00)
1671 {
1672 case 0x00:
1673 goto op_semantics_3;
1674 break;
1675 }
1676 break;
1677 case 0x4b:
1678 GETBYTE ();
1679 switch (op[2] & 0x00)
1680 {
1681 case 0x00:
1682 goto op_semantics_3;
1683 break;
1684 }
1685 break;
1686 case 0x4c:
1687 GETBYTE ();
1688 switch (op[2] & 0x00)
1689 {
1690 case 0x00:
1691 goto op_semantics_4;
1692 break;
1693 }
1694 break;
1695 case 0x4d:
1696 GETBYTE ();
1697 switch (op[2] & 0x00)
1698 {
1699 case 0x00:
1700 goto op_semantics_4;
1701 break;
1702 }
1703 break;
1704 case 0x4e:
1705 GETBYTE ();
1706 switch (op[2] & 0x00)
1707 {
1708 case 0x00:
1709 goto op_semantics_4;
1710 break;
1711 }
1712 break;
1713 case 0x4f:
1714 GETBYTE ();
1715 switch (op[2] & 0x00)
1716 {
1717 case 0x00:
1718 goto op_semantics_4;
1719 break;
1720 }
1721 break;
1722 case 0x50:
1723 GETBYTE ();
1724 switch (op[2] & 0x00)
1725 {
1726 case 0x00:
1727 goto op_semantics_5;
1728 break;
1729 }
1730 break;
1731 case 0x51:
1732 GETBYTE ();
1733 switch (op[2] & 0x00)
1734 {
1735 case 0x00:
1736 goto op_semantics_5;
1737 break;
1738 }
1739 break;
1740 case 0x52:
1741 GETBYTE ();
1742 switch (op[2] & 0x00)
1743 {
1744 case 0x00:
1745 goto op_semantics_5;
1746 break;
1747 }
1748 break;
1749 case 0x53:
1750 GETBYTE ();
1751 switch (op[2] & 0x00)
1752 {
1753 case 0x00:
1754 goto op_semantics_5;
1755 break;
1756 }
1757 break;
1758 case 0x54:
1759 GETBYTE ();
1760 switch (op[2] & 0x00)
1761 {
1762 case 0x00:
1763 goto op_semantics_6;
1764 break;
1765 }
1766 break;
1767 case 0x55:
1768 GETBYTE ();
1769 switch (op[2] & 0x00)
1770 {
1771 case 0x00:
1772 goto op_semantics_6;
1773 break;
1774 }
1775 break;
1776 case 0x56:
1777 GETBYTE ();
1778 switch (op[2] & 0x00)
1779 {
1780 case 0x00:
1781 goto op_semantics_6;
1782 break;
1783 }
1784 break;
1785 case 0x57:
1786 GETBYTE ();
1787 switch (op[2] & 0x00)
1788 {
1789 case 0x00:
1790 goto op_semantics_6;
1791 break;
1792 }
1793 break;
1794 case 0x60:
1795 GETBYTE ();
1796 switch (op[2] & 0xff)
1797 {
1798 case 0x00:
1799 GETBYTE ();
1800 switch (op[3] & 0x00)
1801 {
1802 case 0x00:
1803 goto op_semantics_7;
1804 break;
1805 }
1806 break;
1807 case 0x04:
1808 GETBYTE ();
1809 switch (op[3] & 0x00)
1810 {
1811 case 0x00:
1812 goto op_semantics_8;
1813 break;
1814 }
1815 break;
1816 case 0x05:
1817 GETBYTE ();
1818 switch (op[3] & 0x00)
1819 {
1820 case 0x00:
1821 goto op_semantics_9;
1822 break;
1823 }
1824 break;
1825 case 0x06:
1826 GETBYTE ();
1827 switch (op[3] & 0x00)
1828 {
1829 case 0x00:
1830 goto op_semantics_10;
1831 break;
1832 }
1833 break;
1834 case 0x07:
1835 GETBYTE ();
1836 switch (op[3] & 0x00)
1837 {
1838 case 0x00:
1839 goto op_semantics_11;
1840 break;
1841 }
1842 break;
1843 case 0x08:
1844 GETBYTE ();
1845 switch (op[3] & 0x00)
1846 {
1847 case 0x00:
1848 goto op_semantics_12;
1849 break;
1850 }
1851 break;
1852 case 0x09:
1853 GETBYTE ();
1854 switch (op[3] & 0x00)
1855 {
1856 case 0x00:
1857 goto op_semantics_13;
1858 break;
1859 }
1860 break;
1861 case 0x0c:
1862 GETBYTE ();
1863 switch (op[3] & 0x00)
1864 {
1865 case 0x00:
1866 goto op_semantics_14;
1867 break;
1868 }
1869 break;
1870 case 0x0d:
1871 GETBYTE ();
1872 switch (op[3] & 0x00)
1873 {
1874 case 0x00:
1875 goto op_semantics_15;
1876 break;
1877 }
1878 break;
1879 case 0x10:
1880 GETBYTE ();
1881 switch (op[3] & 0x00)
1882 {
1883 case 0x00:
1884 goto op_semantics_16;
1885 break;
1886 }
1887 break;
1888 case 0x11:
1889 GETBYTE ();
1890 switch (op[3] & 0x00)
1891 {
1892 case 0x00:
1893 goto op_semantics_17;
1894 break;
1895 }
1896 break;
1897 case 0x15:
1898 GETBYTE ();
1899 switch (op[3] & 0x00)
1900 {
1901 case 0x00:
1902 goto op_semantics_18;
1903 break;
1904 }
1905 break;
1906 default: UNSUPPORTED(); break;
1907 }
1908 break;
1909 case 0x61:
1910 GETBYTE ();
1911 switch (op[2] & 0xff)
1912 {
1913 case 0x00:
1914 GETBYTE ();
1915 switch (op[3] & 0x00)
1916 {
1917 case 0x00:
1918 goto op_semantics_7;
1919 break;
1920 }
1921 break;
1922 case 0x04:
1923 GETBYTE ();
1924 switch (op[3] & 0x00)
1925 {
1926 case 0x00:
1927 goto op_semantics_8;
1928 break;
1929 }
1930 break;
1931 case 0x05:
1932 GETBYTE ();
1933 switch (op[3] & 0x00)
1934 {
1935 case 0x00:
1936 goto op_semantics_9;
1937 break;
1938 }
1939 break;
1940 case 0x06:
1941 GETBYTE ();
1942 switch (op[3] & 0x00)
1943 {
1944 case 0x00:
1945 goto op_semantics_10;
1946 break;
1947 }
1948 break;
1949 case 0x07:
1950 GETBYTE ();
1951 switch (op[3] & 0x00)
1952 {
1953 case 0x00:
1954 goto op_semantics_11;
1955 break;
1956 }
1957 break;
1958 case 0x08:
1959 GETBYTE ();
1960 switch (op[3] & 0x00)
1961 {
1962 case 0x00:
1963 goto op_semantics_12;
1964 break;
1965 }
1966 break;
1967 case 0x09:
1968 GETBYTE ();
1969 switch (op[3] & 0x00)
1970 {
1971 case 0x00:
1972 goto op_semantics_13;
1973 break;
1974 }
1975 break;
1976 case 0x0c:
1977 GETBYTE ();
1978 switch (op[3] & 0x00)
1979 {
1980 case 0x00:
1981 goto op_semantics_14;
1982 break;
1983 }
1984 break;
1985 case 0x0d:
1986 GETBYTE ();
1987 switch (op[3] & 0x00)
1988 {
1989 case 0x00:
1990 goto op_semantics_15;
1991 break;
1992 }
1993 break;
1994 case 0x10:
1995 GETBYTE ();
1996 switch (op[3] & 0x00)
1997 {
1998 case 0x00:
1999 goto op_semantics_16;
2000 break;
2001 }
2002 break;
2003 case 0x11:
2004 GETBYTE ();
2005 switch (op[3] & 0x00)
2006 {
2007 case 0x00:
2008 goto op_semantics_17;
2009 break;
2010 }
2011 break;
2012 case 0x15:
2013 GETBYTE ();
2014 switch (op[3] & 0x00)
2015 {
2016 case 0x00:
2017 goto op_semantics_18;
2018 break;
2019 }
2020 break;
2021 default: UNSUPPORTED(); break;
2022 }
2023 break;
2024 case 0x62:
2025 GETBYTE ();
2026 switch (op[2] & 0xff)
2027 {
2028 case 0x00:
2029 GETBYTE ();
2030 switch (op[3] & 0x00)
2031 {
2032 case 0x00:
2033 goto op_semantics_7;
2034 break;
2035 }
2036 break;
2037 case 0x04:
2038 GETBYTE ();
2039 switch (op[3] & 0x00)
2040 {
2041 case 0x00:
2042 goto op_semantics_8;
2043 break;
2044 }
2045 break;
2046 case 0x05:
2047 GETBYTE ();
2048 switch (op[3] & 0x00)
2049 {
2050 case 0x00:
2051 goto op_semantics_9;
2052 break;
2053 }
2054 break;
2055 case 0x06:
2056 GETBYTE ();
2057 switch (op[3] & 0x00)
2058 {
2059 case 0x00:
2060 goto op_semantics_10;
2061 break;
2062 }
2063 break;
2064 case 0x07:
2065 GETBYTE ();
2066 switch (op[3] & 0x00)
2067 {
2068 case 0x00:
2069 goto op_semantics_11;
2070 break;
2071 }
2072 break;
2073 case 0x08:
2074 GETBYTE ();
2075 switch (op[3] & 0x00)
2076 {
2077 case 0x00:
2078 goto op_semantics_12;
2079 break;
2080 }
2081 break;
2082 case 0x09:
2083 GETBYTE ();
2084 switch (op[3] & 0x00)
2085 {
2086 case 0x00:
2087 goto op_semantics_13;
2088 break;
2089 }
2090 break;
2091 case 0x0c:
2092 GETBYTE ();
2093 switch (op[3] & 0x00)
2094 {
2095 case 0x00:
2096 goto op_semantics_14;
2097 break;
2098 }
2099 break;
2100 case 0x0d:
2101 GETBYTE ();
2102 switch (op[3] & 0x00)
2103 {
2104 case 0x00:
2105 goto op_semantics_15;
2106 break;
2107 }
2108 break;
2109 case 0x10:
2110 GETBYTE ();
2111 switch (op[3] & 0x00)
2112 {
2113 case 0x00:
2114 goto op_semantics_16;
2115 break;
2116 }
2117 break;
2118 case 0x11:
2119 GETBYTE ();
2120 switch (op[3] & 0x00)
2121 {
2122 case 0x00:
2123 goto op_semantics_17;
2124 break;
2125 }
2126 break;
2127 case 0x15:
2128 GETBYTE ();
2129 switch (op[3] & 0x00)
2130 {
2131 case 0x00:
2132 goto op_semantics_18;
2133 break;
2134 }
2135 break;
2136 default: UNSUPPORTED(); break;
2137 }
2138 break;
2139 case 0x63:
2140 GETBYTE ();
2141 switch (op[2] & 0xff)
2142 {
2143 case 0x00:
2144 GETBYTE ();
2145 switch (op[3] & 0x00)
2146 {
2147 case 0x00:
2148 goto op_semantics_7;
2149 break;
2150 }
2151 break;
2152 case 0x04:
2153 GETBYTE ();
2154 switch (op[3] & 0x00)
2155 {
2156 case 0x00:
2157 goto op_semantics_8;
2158 break;
2159 }
2160 break;
2161 case 0x05:
2162 GETBYTE ();
2163 switch (op[3] & 0x00)
2164 {
2165 case 0x00:
2166 goto op_semantics_9;
2167 break;
2168 }
2169 break;
2170 case 0x06:
2171 GETBYTE ();
2172 switch (op[3] & 0x00)
2173 {
2174 case 0x00:
2175 goto op_semantics_10;
2176 break;
2177 }
2178 break;
2179 case 0x07:
2180 GETBYTE ();
2181 switch (op[3] & 0x00)
2182 {
2183 case 0x00:
2184 goto op_semantics_11;
2185 break;
2186 }
2187 break;
2188 case 0x08:
2189 GETBYTE ();
2190 switch (op[3] & 0x00)
2191 {
2192 case 0x00:
2193 goto op_semantics_12;
2194 break;
2195 }
2196 break;
2197 case 0x09:
2198 GETBYTE ();
2199 switch (op[3] & 0x00)
2200 {
2201 case 0x00:
2202 goto op_semantics_13;
2203 break;
2204 }
2205 break;
2206 case 0x0c:
2207 GETBYTE ();
2208 switch (op[3] & 0x00)
2209 {
2210 case 0x00:
2211 goto op_semantics_14;
2212 break;
2213 }
2214 break;
2215 case 0x0d:
2216 GETBYTE ();
2217 switch (op[3] & 0x00)
2218 {
2219 case 0x00:
2220 goto op_semantics_15;
2221 break;
2222 }
2223 break;
2224 case 0x10:
2225 GETBYTE ();
2226 switch (op[3] & 0x00)
2227 {
2228 case 0x00:
2229 goto op_semantics_16;
2230 break;
2231 }
2232 break;
2233 case 0x11:
2234 GETBYTE ();
2235 switch (op[3] & 0x00)
2236 {
2237 case 0x00:
2238 goto op_semantics_17;
2239 break;
2240 }
2241 break;
2242 case 0x15:
2243 GETBYTE ();
2244 switch (op[3] & 0x00)
2245 {
2246 case 0x00:
2247 goto op_semantics_18;
2248 break;
2249 }
2250 break;
2251 default: UNSUPPORTED(); break;
2252 }
2253 break;
2254 case 0x80:
2255 GETBYTE ();
2256 switch (op[2] & 0x00)
2257 {
2258 case 0x00:
2259 goto op_semantics_1;
2260 break;
2261 }
2262 break;
2263 case 0x81:
2264 GETBYTE ();
2265 switch (op[2] & 0x00)
2266 {
2267 case 0x00:
2268 goto op_semantics_1;
2269 break;
2270 }
2271 break;
2272 case 0x82:
2273 GETBYTE ();
2274 switch (op[2] & 0x00)
2275 {
2276 case 0x00:
2277 goto op_semantics_1;
2278 break;
2279 }
2280 break;
2281 case 0x83:
2282 GETBYTE ();
2283 switch (op[2] & 0x00)
2284 {
2285 case 0x00:
2286 goto op_semantics_1;
2287 break;
2288 }
2289 break;
2290 case 0x84:
2291 GETBYTE ();
2292 switch (op[2] & 0x00)
2293 {
2294 case 0x00:
2295 goto op_semantics_2;
2296 break;
2297 }
2298 break;
2299 case 0x85:
2300 GETBYTE ();
2301 switch (op[2] & 0x00)
2302 {
2303 case 0x00:
2304 goto op_semantics_2;
2305 break;
2306 }
2307 break;
2308 case 0x86:
2309 GETBYTE ();
2310 switch (op[2] & 0x00)
2311 {
2312 case 0x00:
2313 goto op_semantics_2;
2314 break;
2315 }
2316 break;
2317 case 0x87:
2318 GETBYTE ();
2319 switch (op[2] & 0x00)
2320 {
2321 case 0x00:
2322 goto op_semantics_2;
2323 break;
2324 }
2325 break;
2326 case 0x88:
2327 GETBYTE ();
2328 switch (op[2] & 0x00)
2329 {
2330 case 0x00:
2331 goto op_semantics_3;
2332 break;
2333 }
2334 break;
2335 case 0x89:
2336 GETBYTE ();
2337 switch (op[2] & 0x00)
2338 {
2339 case 0x00:
2340 goto op_semantics_3;
2341 break;
2342 }
2343 break;
2344 case 0x8a:
2345 GETBYTE ();
2346 switch (op[2] & 0x00)
2347 {
2348 case 0x00:
2349 goto op_semantics_3;
2350 break;
2351 }
2352 break;
2353 case 0x8b:
2354 GETBYTE ();
2355 switch (op[2] & 0x00)
2356 {
2357 case 0x00:
2358 goto op_semantics_3;
2359 break;
2360 }
2361 break;
2362 case 0x8c:
2363 GETBYTE ();
2364 switch (op[2] & 0x00)
2365 {
2366 case 0x00:
2367 goto op_semantics_4;
2368 break;
2369 }
2370 break;
2371 case 0x8d:
2372 GETBYTE ();
2373 switch (op[2] & 0x00)
2374 {
2375 case 0x00:
2376 goto op_semantics_4;
2377 break;
2378 }
2379 break;
2380 case 0x8e:
2381 GETBYTE ();
2382 switch (op[2] & 0x00)
2383 {
2384 case 0x00:
2385 goto op_semantics_4;
2386 break;
2387 }
2388 break;
2389 case 0x8f:
2390 GETBYTE ();
2391 switch (op[2] & 0x00)
2392 {
2393 case 0x00:
2394 goto op_semantics_4;
2395 break;
2396 }
2397 break;
2398 case 0x90:
2399 GETBYTE ();
2400 switch (op[2] & 0x00)
2401 {
2402 case 0x00:
2403 goto op_semantics_5;
2404 break;
2405 }
2406 break;
2407 case 0x91:
2408 GETBYTE ();
2409 switch (op[2] & 0x00)
2410 {
2411 case 0x00:
2412 goto op_semantics_5;
2413 break;
2414 }
2415 break;
2416 case 0x92:
2417 GETBYTE ();
2418 switch (op[2] & 0x00)
2419 {
2420 case 0x00:
2421 goto op_semantics_5;
2422 break;
2423 }
2424 break;
2425 case 0x93:
2426 GETBYTE ();
2427 switch (op[2] & 0x00)
2428 {
2429 case 0x00:
2430 goto op_semantics_5;
2431 break;
2432 }
2433 break;
2434 case 0x94:
2435 GETBYTE ();
2436 switch (op[2] & 0x00)
2437 {
2438 case 0x00:
2439 goto op_semantics_6;
2440 break;
2441 }
2442 break;
2443 case 0x95:
2444 GETBYTE ();
2445 switch (op[2] & 0x00)
2446 {
2447 case 0x00:
2448 goto op_semantics_6;
2449 break;
2450 }
2451 break;
2452 case 0x96:
2453 GETBYTE ();
2454 switch (op[2] & 0x00)
2455 {
2456 case 0x00:
2457 goto op_semantics_6;
2458 break;
2459 }
2460 break;
2461 case 0x97:
2462 GETBYTE ();
2463 switch (op[2] & 0x00)
2464 {
2465 case 0x00:
2466 goto op_semantics_6;
2467 break;
2468 }
2469 break;
2470 case 0xa0:
2471 GETBYTE ();
2472 switch (op[2] & 0xff)
2473 {
2474 case 0x00:
2475 GETBYTE ();
2476 switch (op[3] & 0x00)
2477 {
2478 case 0x00:
2479 goto op_semantics_7;
2480 break;
2481 }
2482 break;
2483 case 0x02:
2484 GETBYTE ();
2485 switch (op[3] & 0x00)
2486 {
2487 case 0x00:
2488 op_semantics_19:
2489 {
2490 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2491 #line 519 "rx-decode.opc"
2492 int ss AU = op[1] & 0x03;
2493 #line 519 "rx-decode.opc"
2494 int rsrc AU = (op[3] >> 4) & 0x0f;
2495 #line 519 "rx-decode.opc"
2496 int rdst AU = op[3] & 0x0f;
2497 if (trace)
2498 {
2499 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2500 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2501 op[0], op[1], op[2], op[3]);
2502 printf (" ss = 0x%x,", ss);
2503 printf (" rsrc = 0x%x,", rsrc);
2504 printf (" rdst = 0x%x\n", rdst);
2505 }
2506 SYNTAX("adc %1%S1, %0");
2507 #line 519 "rx-decode.opc"
2508 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2509
2510 /*----------------------------------------------------------------------*/
2511 /* ADD */
2512
2513 }
2514 break;
2515 }
2516 break;
2517 case 0x04:
2518 GETBYTE ();
2519 switch (op[3] & 0x00)
2520 {
2521 case 0x00:
2522 goto op_semantics_8;
2523 break;
2524 }
2525 break;
2526 case 0x05:
2527 GETBYTE ();
2528 switch (op[3] & 0x00)
2529 {
2530 case 0x00:
2531 goto op_semantics_9;
2532 break;
2533 }
2534 break;
2535 case 0x06:
2536 GETBYTE ();
2537 switch (op[3] & 0x00)
2538 {
2539 case 0x00:
2540 goto op_semantics_10;
2541 break;
2542 }
2543 break;
2544 case 0x07:
2545 GETBYTE ();
2546 switch (op[3] & 0x00)
2547 {
2548 case 0x00:
2549 goto op_semantics_11;
2550 break;
2551 }
2552 break;
2553 case 0x08:
2554 GETBYTE ();
2555 switch (op[3] & 0x00)
2556 {
2557 case 0x00:
2558 goto op_semantics_12;
2559 break;
2560 }
2561 break;
2562 case 0x09:
2563 GETBYTE ();
2564 switch (op[3] & 0x00)
2565 {
2566 case 0x00:
2567 goto op_semantics_13;
2568 break;
2569 }
2570 break;
2571 case 0x0c:
2572 GETBYTE ();
2573 switch (op[3] & 0x00)
2574 {
2575 case 0x00:
2576 goto op_semantics_14;
2577 break;
2578 }
2579 break;
2580 case 0x0d:
2581 GETBYTE ();
2582 switch (op[3] & 0x00)
2583 {
2584 case 0x00:
2585 goto op_semantics_15;
2586 break;
2587 }
2588 break;
2589 case 0x10:
2590 GETBYTE ();
2591 switch (op[3] & 0x00)
2592 {
2593 case 0x00:
2594 goto op_semantics_16;
2595 break;
2596 }
2597 break;
2598 case 0x11:
2599 GETBYTE ();
2600 switch (op[3] & 0x00)
2601 {
2602 case 0x00:
2603 goto op_semantics_17;
2604 break;
2605 }
2606 break;
2607 case 0x15:
2608 GETBYTE ();
2609 switch (op[3] & 0x00)
2610 {
2611 case 0x00:
2612 goto op_semantics_18;
2613 break;
2614 }
2615 break;
2616 default: UNSUPPORTED(); break;
2617 }
2618 break;
2619 case 0xa1:
2620 GETBYTE ();
2621 switch (op[2] & 0xff)
2622 {
2623 case 0x00:
2624 GETBYTE ();
2625 switch (op[3] & 0x00)
2626 {
2627 case 0x00:
2628 goto op_semantics_7;
2629 break;
2630 }
2631 break;
2632 case 0x02:
2633 GETBYTE ();
2634 switch (op[3] & 0x00)
2635 {
2636 case 0x00:
2637 goto op_semantics_19;
2638 break;
2639 }
2640 break;
2641 case 0x04:
2642 GETBYTE ();
2643 switch (op[3] & 0x00)
2644 {
2645 case 0x00:
2646 goto op_semantics_8;
2647 break;
2648 }
2649 break;
2650 case 0x05:
2651 GETBYTE ();
2652 switch (op[3] & 0x00)
2653 {
2654 case 0x00:
2655 goto op_semantics_9;
2656 break;
2657 }
2658 break;
2659 case 0x06:
2660 GETBYTE ();
2661 switch (op[3] & 0x00)
2662 {
2663 case 0x00:
2664 goto op_semantics_10;
2665 break;
2666 }
2667 break;
2668 case 0x07:
2669 GETBYTE ();
2670 switch (op[3] & 0x00)
2671 {
2672 case 0x00:
2673 goto op_semantics_11;
2674 break;
2675 }
2676 break;
2677 case 0x08:
2678 GETBYTE ();
2679 switch (op[3] & 0x00)
2680 {
2681 case 0x00:
2682 goto op_semantics_12;
2683 break;
2684 }
2685 break;
2686 case 0x09:
2687 GETBYTE ();
2688 switch (op[3] & 0x00)
2689 {
2690 case 0x00:
2691 goto op_semantics_13;
2692 break;
2693 }
2694 break;
2695 case 0x0c:
2696 GETBYTE ();
2697 switch (op[3] & 0x00)
2698 {
2699 case 0x00:
2700 goto op_semantics_14;
2701 break;
2702 }
2703 break;
2704 case 0x0d:
2705 GETBYTE ();
2706 switch (op[3] & 0x00)
2707 {
2708 case 0x00:
2709 goto op_semantics_15;
2710 break;
2711 }
2712 break;
2713 case 0x10:
2714 GETBYTE ();
2715 switch (op[3] & 0x00)
2716 {
2717 case 0x00:
2718 goto op_semantics_16;
2719 break;
2720 }
2721 break;
2722 case 0x11:
2723 GETBYTE ();
2724 switch (op[3] & 0x00)
2725 {
2726 case 0x00:
2727 goto op_semantics_17;
2728 break;
2729 }
2730 break;
2731 case 0x15:
2732 GETBYTE ();
2733 switch (op[3] & 0x00)
2734 {
2735 case 0x00:
2736 goto op_semantics_18;
2737 break;
2738 }
2739 break;
2740 default: UNSUPPORTED(); break;
2741 }
2742 break;
2743 case 0xa2:
2744 GETBYTE ();
2745 switch (op[2] & 0xff)
2746 {
2747 case 0x00:
2748 GETBYTE ();
2749 switch (op[3] & 0x00)
2750 {
2751 case 0x00:
2752 goto op_semantics_7;
2753 break;
2754 }
2755 break;
2756 case 0x02:
2757 GETBYTE ();
2758 switch (op[3] & 0x00)
2759 {
2760 case 0x00:
2761 goto op_semantics_19;
2762 break;
2763 }
2764 break;
2765 case 0x04:
2766 GETBYTE ();
2767 switch (op[3] & 0x00)
2768 {
2769 case 0x00:
2770 goto op_semantics_8;
2771 break;
2772 }
2773 break;
2774 case 0x05:
2775 GETBYTE ();
2776 switch (op[3] & 0x00)
2777 {
2778 case 0x00:
2779 goto op_semantics_9;
2780 break;
2781 }
2782 break;
2783 case 0x06:
2784 GETBYTE ();
2785 switch (op[3] & 0x00)
2786 {
2787 case 0x00:
2788 goto op_semantics_10;
2789 break;
2790 }
2791 break;
2792 case 0x07:
2793 GETBYTE ();
2794 switch (op[3] & 0x00)
2795 {
2796 case 0x00:
2797 goto op_semantics_11;
2798 break;
2799 }
2800 break;
2801 case 0x08:
2802 GETBYTE ();
2803 switch (op[3] & 0x00)
2804 {
2805 case 0x00:
2806 goto op_semantics_12;
2807 break;
2808 }
2809 break;
2810 case 0x09:
2811 GETBYTE ();
2812 switch (op[3] & 0x00)
2813 {
2814 case 0x00:
2815 goto op_semantics_13;
2816 break;
2817 }
2818 break;
2819 case 0x0c:
2820 GETBYTE ();
2821 switch (op[3] & 0x00)
2822 {
2823 case 0x00:
2824 goto op_semantics_14;
2825 break;
2826 }
2827 break;
2828 case 0x0d:
2829 GETBYTE ();
2830 switch (op[3] & 0x00)
2831 {
2832 case 0x00:
2833 goto op_semantics_15;
2834 break;
2835 }
2836 break;
2837 case 0x10:
2838 GETBYTE ();
2839 switch (op[3] & 0x00)
2840 {
2841 case 0x00:
2842 goto op_semantics_16;
2843 break;
2844 }
2845 break;
2846 case 0x11:
2847 GETBYTE ();
2848 switch (op[3] & 0x00)
2849 {
2850 case 0x00:
2851 goto op_semantics_17;
2852 break;
2853 }
2854 break;
2855 case 0x15:
2856 GETBYTE ();
2857 switch (op[3] & 0x00)
2858 {
2859 case 0x00:
2860 goto op_semantics_18;
2861 break;
2862 }
2863 break;
2864 default: UNSUPPORTED(); break;
2865 }
2866 break;
2867 case 0xa3:
2868 GETBYTE ();
2869 switch (op[2] & 0xff)
2870 {
2871 case 0x00:
2872 GETBYTE ();
2873 switch (op[3] & 0x00)
2874 {
2875 case 0x00:
2876 goto op_semantics_7;
2877 break;
2878 }
2879 break;
2880 case 0x02:
2881 GETBYTE ();
2882 switch (op[3] & 0x00)
2883 {
2884 case 0x00:
2885 goto op_semantics_19;
2886 break;
2887 }
2888 break;
2889 case 0x04:
2890 GETBYTE ();
2891 switch (op[3] & 0x00)
2892 {
2893 case 0x00:
2894 goto op_semantics_8;
2895 break;
2896 }
2897 break;
2898 case 0x05:
2899 GETBYTE ();
2900 switch (op[3] & 0x00)
2901 {
2902 case 0x00:
2903 goto op_semantics_9;
2904 break;
2905 }
2906 break;
2907 case 0x06:
2908 GETBYTE ();
2909 switch (op[3] & 0x00)
2910 {
2911 case 0x00:
2912 goto op_semantics_10;
2913 break;
2914 }
2915 break;
2916 case 0x07:
2917 GETBYTE ();
2918 switch (op[3] & 0x00)
2919 {
2920 case 0x00:
2921 goto op_semantics_11;
2922 break;
2923 }
2924 break;
2925 case 0x08:
2926 GETBYTE ();
2927 switch (op[3] & 0x00)
2928 {
2929 case 0x00:
2930 goto op_semantics_12;
2931 break;
2932 }
2933 break;
2934 case 0x09:
2935 GETBYTE ();
2936 switch (op[3] & 0x00)
2937 {
2938 case 0x00:
2939 goto op_semantics_13;
2940 break;
2941 }
2942 break;
2943 case 0x0c:
2944 GETBYTE ();
2945 switch (op[3] & 0x00)
2946 {
2947 case 0x00:
2948 goto op_semantics_14;
2949 break;
2950 }
2951 break;
2952 case 0x0d:
2953 GETBYTE ();
2954 switch (op[3] & 0x00)
2955 {
2956 case 0x00:
2957 goto op_semantics_15;
2958 break;
2959 }
2960 break;
2961 case 0x10:
2962 GETBYTE ();
2963 switch (op[3] & 0x00)
2964 {
2965 case 0x00:
2966 goto op_semantics_16;
2967 break;
2968 }
2969 break;
2970 case 0x11:
2971 GETBYTE ();
2972 switch (op[3] & 0x00)
2973 {
2974 case 0x00:
2975 goto op_semantics_17;
2976 break;
2977 }
2978 break;
2979 case 0x15:
2980 GETBYTE ();
2981 switch (op[3] & 0x00)
2982 {
2983 case 0x00:
2984 goto op_semantics_18;
2985 break;
2986 }
2987 break;
2988 default: UNSUPPORTED(); break;
2989 }
2990 break;
2991 case 0xc0:
2992 GETBYTE ();
2993 switch (op[2] & 0x00)
2994 {
2995 case 0x00:
2996 goto op_semantics_1;
2997 break;
2998 }
2999 break;
3000 case 0xc1:
3001 GETBYTE ();
3002 switch (op[2] & 0x00)
3003 {
3004 case 0x00:
3005 goto op_semantics_1;
3006 break;
3007 }
3008 break;
3009 case 0xc2:
3010 GETBYTE ();
3011 switch (op[2] & 0x00)
3012 {
3013 case 0x00:
3014 goto op_semantics_1;
3015 break;
3016 }
3017 break;
3018 case 0xc3:
3019 GETBYTE ();
3020 switch (op[2] & 0x00)
3021 {
3022 case 0x00:
3023 goto op_semantics_1;
3024 break;
3025 }
3026 break;
3027 case 0xc4:
3028 GETBYTE ();
3029 switch (op[2] & 0x00)
3030 {
3031 case 0x00:
3032 goto op_semantics_2;
3033 break;
3034 }
3035 break;
3036 case 0xc5:
3037 GETBYTE ();
3038 switch (op[2] & 0x00)
3039 {
3040 case 0x00:
3041 goto op_semantics_2;
3042 break;
3043 }
3044 break;
3045 case 0xc6:
3046 GETBYTE ();
3047 switch (op[2] & 0x00)
3048 {
3049 case 0x00:
3050 goto op_semantics_2;
3051 break;
3052 }
3053 break;
3054 case 0xc7:
3055 GETBYTE ();
3056 switch (op[2] & 0x00)
3057 {
3058 case 0x00:
3059 goto op_semantics_2;
3060 break;
3061 }
3062 break;
3063 case 0xc8:
3064 GETBYTE ();
3065 switch (op[2] & 0x00)
3066 {
3067 case 0x00:
3068 goto op_semantics_3;
3069 break;
3070 }
3071 break;
3072 case 0xc9:
3073 GETBYTE ();
3074 switch (op[2] & 0x00)
3075 {
3076 case 0x00:
3077 goto op_semantics_3;
3078 break;
3079 }
3080 break;
3081 case 0xca:
3082 GETBYTE ();
3083 switch (op[2] & 0x00)
3084 {
3085 case 0x00:
3086 goto op_semantics_3;
3087 break;
3088 }
3089 break;
3090 case 0xcb:
3091 GETBYTE ();
3092 switch (op[2] & 0x00)
3093 {
3094 case 0x00:
3095 goto op_semantics_3;
3096 break;
3097 }
3098 break;
3099 case 0xcc:
3100 GETBYTE ();
3101 switch (op[2] & 0x00)
3102 {
3103 case 0x00:
3104 goto op_semantics_4;
3105 break;
3106 }
3107 break;
3108 case 0xcd:
3109 GETBYTE ();
3110 switch (op[2] & 0x00)
3111 {
3112 case 0x00:
3113 goto op_semantics_4;
3114 break;
3115 }
3116 break;
3117 case 0xce:
3118 GETBYTE ();
3119 switch (op[2] & 0x00)
3120 {
3121 case 0x00:
3122 goto op_semantics_4;
3123 break;
3124 }
3125 break;
3126 case 0xcf:
3127 GETBYTE ();
3128 switch (op[2] & 0x00)
3129 {
3130 case 0x00:
3131 goto op_semantics_4;
3132 break;
3133 }
3134 break;
3135 case 0xd0:
3136 GETBYTE ();
3137 switch (op[2] & 0x00)
3138 {
3139 case 0x00:
3140 goto op_semantics_5;
3141 break;
3142 }
3143 break;
3144 case 0xd1:
3145 GETBYTE ();
3146 switch (op[2] & 0x00)
3147 {
3148 case 0x00:
3149 goto op_semantics_5;
3150 break;
3151 }
3152 break;
3153 case 0xd2:
3154 GETBYTE ();
3155 switch (op[2] & 0x00)
3156 {
3157 case 0x00:
3158 goto op_semantics_5;
3159 break;
3160 }
3161 break;
3162 case 0xd3:
3163 GETBYTE ();
3164 switch (op[2] & 0x00)
3165 {
3166 case 0x00:
3167 goto op_semantics_5;
3168 break;
3169 }
3170 break;
3171 case 0xd4:
3172 GETBYTE ();
3173 switch (op[2] & 0x00)
3174 {
3175 case 0x00:
3176 goto op_semantics_6;
3177 break;
3178 }
3179 break;
3180 case 0xd5:
3181 GETBYTE ();
3182 switch (op[2] & 0x00)
3183 {
3184 case 0x00:
3185 goto op_semantics_6;
3186 break;
3187 }
3188 break;
3189 case 0xd6:
3190 GETBYTE ();
3191 switch (op[2] & 0x00)
3192 {
3193 case 0x00:
3194 goto op_semantics_6;
3195 break;
3196 }
3197 break;
3198 case 0xd7:
3199 GETBYTE ();
3200 switch (op[2] & 0x00)
3201 {
3202 case 0x00:
3203 goto op_semantics_6;
3204 break;
3205 }
3206 break;
3207 case 0xe0:
3208 GETBYTE ();
3209 switch (op[2] & 0xff)
3210 {
3211 case 0x00:
3212 GETBYTE ();
3213 switch (op[3] & 0x00)
3214 {
3215 case 0x00:
3216 goto op_semantics_7;
3217 break;
3218 }
3219 break;
3220 case 0x04:
3221 GETBYTE ();
3222 switch (op[3] & 0x00)
3223 {
3224 case 0x00:
3225 goto op_semantics_8;
3226 break;
3227 }
3228 break;
3229 case 0x05:
3230 GETBYTE ();
3231 switch (op[3] & 0x00)
3232 {
3233 case 0x00:
3234 goto op_semantics_9;
3235 break;
3236 }
3237 break;
3238 case 0x06:
3239 GETBYTE ();
3240 switch (op[3] & 0x00)
3241 {
3242 case 0x00:
3243 goto op_semantics_10;
3244 break;
3245 }
3246 break;
3247 case 0x07:
3248 GETBYTE ();
3249 switch (op[3] & 0x00)
3250 {
3251 case 0x00:
3252 goto op_semantics_11;
3253 break;
3254 }
3255 break;
3256 case 0x08:
3257 GETBYTE ();
3258 switch (op[3] & 0x00)
3259 {
3260 case 0x00:
3261 goto op_semantics_12;
3262 break;
3263 }
3264 break;
3265 case 0x09:
3266 GETBYTE ();
3267 switch (op[3] & 0x00)
3268 {
3269 case 0x00:
3270 goto op_semantics_13;
3271 break;
3272 }
3273 break;
3274 case 0x0c:
3275 GETBYTE ();
3276 switch (op[3] & 0x00)
3277 {
3278 case 0x00:
3279 goto op_semantics_14;
3280 break;
3281 }
3282 break;
3283 case 0x0d:
3284 GETBYTE ();
3285 switch (op[3] & 0x00)
3286 {
3287 case 0x00:
3288 goto op_semantics_15;
3289 break;
3290 }
3291 break;
3292 case 0x10:
3293 GETBYTE ();
3294 switch (op[3] & 0x00)
3295 {
3296 case 0x00:
3297 goto op_semantics_16;
3298 break;
3299 }
3300 break;
3301 case 0x11:
3302 GETBYTE ();
3303 switch (op[3] & 0x00)
3304 {
3305 case 0x00:
3306 goto op_semantics_17;
3307 break;
3308 }
3309 break;
3310 case 0x15:
3311 GETBYTE ();
3312 switch (op[3] & 0x00)
3313 {
3314 case 0x00:
3315 goto op_semantics_18;
3316 break;
3317 }
3318 break;
3319 default: UNSUPPORTED(); break;
3320 }
3321 break;
3322 case 0xe1:
3323 GETBYTE ();
3324 switch (op[2] & 0xff)
3325 {
3326 case 0x00:
3327 GETBYTE ();
3328 switch (op[3] & 0x00)
3329 {
3330 case 0x00:
3331 goto op_semantics_7;
3332 break;
3333 }
3334 break;
3335 case 0x04:
3336 GETBYTE ();
3337 switch (op[3] & 0x00)
3338 {
3339 case 0x00:
3340 goto op_semantics_8;
3341 break;
3342 }
3343 break;
3344 case 0x05:
3345 GETBYTE ();
3346 switch (op[3] & 0x00)
3347 {
3348 case 0x00:
3349 goto op_semantics_9;
3350 break;
3351 }
3352 break;
3353 case 0x06:
3354 GETBYTE ();
3355 switch (op[3] & 0x00)
3356 {
3357 case 0x00:
3358 goto op_semantics_10;
3359 break;
3360 }
3361 break;
3362 case 0x07:
3363 GETBYTE ();
3364 switch (op[3] & 0x00)
3365 {
3366 case 0x00:
3367 goto op_semantics_11;
3368 break;
3369 }
3370 break;
3371 case 0x08:
3372 GETBYTE ();
3373 switch (op[3] & 0x00)
3374 {
3375 case 0x00:
3376 goto op_semantics_12;
3377 break;
3378 }
3379 break;
3380 case 0x09:
3381 GETBYTE ();
3382 switch (op[3] & 0x00)
3383 {
3384 case 0x00:
3385 goto op_semantics_13;
3386 break;
3387 }
3388 break;
3389 case 0x0c:
3390 GETBYTE ();
3391 switch (op[3] & 0x00)
3392 {
3393 case 0x00:
3394 goto op_semantics_14;
3395 break;
3396 }
3397 break;
3398 case 0x0d:
3399 GETBYTE ();
3400 switch (op[3] & 0x00)
3401 {
3402 case 0x00:
3403 goto op_semantics_15;
3404 break;
3405 }
3406 break;
3407 case 0x10:
3408 GETBYTE ();
3409 switch (op[3] & 0x00)
3410 {
3411 case 0x00:
3412 goto op_semantics_16;
3413 break;
3414 }
3415 break;
3416 case 0x11:
3417 GETBYTE ();
3418 switch (op[3] & 0x00)
3419 {
3420 case 0x00:
3421 goto op_semantics_17;
3422 break;
3423 }
3424 break;
3425 case 0x15:
3426 GETBYTE ();
3427 switch (op[3] & 0x00)
3428 {
3429 case 0x00:
3430 goto op_semantics_18;
3431 break;
3432 }
3433 break;
3434 default: UNSUPPORTED(); break;
3435 }
3436 break;
3437 case 0xe2:
3438 GETBYTE ();
3439 switch (op[2] & 0xff)
3440 {
3441 case 0x00:
3442 GETBYTE ();
3443 switch (op[3] & 0x00)
3444 {
3445 case 0x00:
3446 goto op_semantics_7;
3447 break;
3448 }
3449 break;
3450 case 0x04:
3451 GETBYTE ();
3452 switch (op[3] & 0x00)
3453 {
3454 case 0x00:
3455 goto op_semantics_8;
3456 break;
3457 }
3458 break;
3459 case 0x05:
3460 GETBYTE ();
3461 switch (op[3] & 0x00)
3462 {
3463 case 0x00:
3464 goto op_semantics_9;
3465 break;
3466 }
3467 break;
3468 case 0x06:
3469 GETBYTE ();
3470 switch (op[3] & 0x00)
3471 {
3472 case 0x00:
3473 goto op_semantics_10;
3474 break;
3475 }
3476 break;
3477 case 0x07:
3478 GETBYTE ();
3479 switch (op[3] & 0x00)
3480 {
3481 case 0x00:
3482 goto op_semantics_11;
3483 break;
3484 }
3485 break;
3486 case 0x08:
3487 GETBYTE ();
3488 switch (op[3] & 0x00)
3489 {
3490 case 0x00:
3491 goto op_semantics_12;
3492 break;
3493 }
3494 break;
3495 case 0x09:
3496 GETBYTE ();
3497 switch (op[3] & 0x00)
3498 {
3499 case 0x00:
3500 goto op_semantics_13;
3501 break;
3502 }
3503 break;
3504 case 0x0c:
3505 GETBYTE ();
3506 switch (op[3] & 0x00)
3507 {
3508 case 0x00:
3509 goto op_semantics_14;
3510 break;
3511 }
3512 break;
3513 case 0x0d:
3514 GETBYTE ();
3515 switch (op[3] & 0x00)
3516 {
3517 case 0x00:
3518 goto op_semantics_15;
3519 break;
3520 }
3521 break;
3522 case 0x10:
3523 GETBYTE ();
3524 switch (op[3] & 0x00)
3525 {
3526 case 0x00:
3527 goto op_semantics_16;
3528 break;
3529 }
3530 break;
3531 case 0x11:
3532 GETBYTE ();
3533 switch (op[3] & 0x00)
3534 {
3535 case 0x00:
3536 goto op_semantics_17;
3537 break;
3538 }
3539 break;
3540 case 0x15:
3541 GETBYTE ();
3542 switch (op[3] & 0x00)
3543 {
3544 case 0x00:
3545 goto op_semantics_18;
3546 break;
3547 }
3548 break;
3549 default: UNSUPPORTED(); break;
3550 }
3551 break;
3552 case 0xe3:
3553 GETBYTE ();
3554 switch (op[2] & 0xff)
3555 {
3556 case 0x00:
3557 GETBYTE ();
3558 switch (op[3] & 0x00)
3559 {
3560 case 0x00:
3561 goto op_semantics_7;
3562 break;
3563 }
3564 break;
3565 case 0x04:
3566 GETBYTE ();
3567 switch (op[3] & 0x00)
3568 {
3569 case 0x00:
3570 goto op_semantics_8;
3571 break;
3572 }
3573 break;
3574 case 0x05:
3575 GETBYTE ();
3576 switch (op[3] & 0x00)
3577 {
3578 case 0x00:
3579 goto op_semantics_9;
3580 break;
3581 }
3582 break;
3583 case 0x06:
3584 GETBYTE ();
3585 switch (op[3] & 0x00)
3586 {
3587 case 0x00:
3588 goto op_semantics_10;
3589 break;
3590 }
3591 break;
3592 case 0x07:
3593 GETBYTE ();
3594 switch (op[3] & 0x00)
3595 {
3596 case 0x00:
3597 goto op_semantics_11;
3598 break;
3599 }
3600 break;
3601 case 0x08:
3602 GETBYTE ();
3603 switch (op[3] & 0x00)
3604 {
3605 case 0x00:
3606 goto op_semantics_12;
3607 break;
3608 }
3609 break;
3610 case 0x09:
3611 GETBYTE ();
3612 switch (op[3] & 0x00)
3613 {
3614 case 0x00:
3615 goto op_semantics_13;
3616 break;
3617 }
3618 break;
3619 case 0x0c:
3620 GETBYTE ();
3621 switch (op[3] & 0x00)
3622 {
3623 case 0x00:
3624 goto op_semantics_14;
3625 break;
3626 }
3627 break;
3628 case 0x0d:
3629 GETBYTE ();
3630 switch (op[3] & 0x00)
3631 {
3632 case 0x00:
3633 goto op_semantics_15;
3634 break;
3635 }
3636 break;
3637 case 0x10:
3638 GETBYTE ();
3639 switch (op[3] & 0x00)
3640 {
3641 case 0x00:
3642 goto op_semantics_16;
3643 break;
3644 }
3645 break;
3646 case 0x11:
3647 GETBYTE ();
3648 switch (op[3] & 0x00)
3649 {
3650 case 0x00:
3651 goto op_semantics_17;
3652 break;
3653 }
3654 break;
3655 case 0x15:
3656 GETBYTE ();
3657 switch (op[3] & 0x00)
3658 {
3659 case 0x00:
3660 goto op_semantics_18;
3661 break;
3662 }
3663 break;
3664 default: UNSUPPORTED(); break;
3665 }
3666 break;
3667 default: UNSUPPORTED(); break;
3668 }
3669 break;
3670 case 0x08:
3671 case 0x09:
3672 case 0x0a:
3673 case 0x0b:
3674 case 0x0c:
3675 case 0x0d:
3676 case 0x0e:
3677 case 0x0f:
3678 {
3679 /** 0000 1dsp bra.s %a0 */
3680 #line 800 "rx-decode.opc"
3681 int dsp AU = op[0] & 0x07;
3682 if (trace)
3683 {
3684 printf ("\033[33m%s\033[0m %02x\n",
3685 "/** 0000 1dsp bra.s %a0 */",
3686 op[0]);
3687 printf (" dsp = 0x%x\n", dsp);
3688 }
3689 SYNTAX("bra.s %a0");
3690 #line 800 "rx-decode.opc"
3691 ID(branch); DC(pc + dsp3map[dsp]);
3692
3693 }
3694 break;
3695 case 0x10:
3696 case 0x11:
3697 case 0x12:
3698 case 0x13:
3699 case 0x14:
3700 case 0x15:
3701 case 0x16:
3702 case 0x17:
3703 case 0x18:
3704 case 0x19:
3705 case 0x1a:
3706 case 0x1b:
3707 case 0x1c:
3708 case 0x1d:
3709 case 0x1e:
3710 case 0x1f:
3711 {
3712 /** 0001 n dsp b%1.s %a0 */
3713 #line 790 "rx-decode.opc"
3714 int n AU = (op[0] >> 3) & 0x01;
3715 #line 790 "rx-decode.opc"
3716 int dsp AU = op[0] & 0x07;
3717 if (trace)
3718 {
3719 printf ("\033[33m%s\033[0m %02x\n",
3720 "/** 0001 n dsp b%1.s %a0 */",
3721 op[0]);
3722 printf (" n = 0x%x,", n);
3723 printf (" dsp = 0x%x\n", dsp);
3724 }
3725 SYNTAX("b%1.s %a0");
3726 #line 790 "rx-decode.opc"
3727 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3728
3729 }
3730 break;
3731 case 0x20:
3732 case 0x21:
3733 case 0x22:
3734 case 0x23:
3735 case 0x24:
3736 case 0x25:
3737 case 0x26:
3738 case 0x27:
3739 case 0x28:
3740 case 0x29:
3741 case 0x2a:
3742 case 0x2b:
3743 case 0x2c:
3744 case 0x2d:
3745 case 0x2f:
3746 {
3747 /** 0010 cond b%1.b %a0 */
3748 #line 793 "rx-decode.opc"
3749 int cond AU = op[0] & 0x0f;
3750 if (trace)
3751 {
3752 printf ("\033[33m%s\033[0m %02x\n",
3753 "/** 0010 cond b%1.b %a0 */",
3754 op[0]);
3755 printf (" cond = 0x%x\n", cond);
3756 }
3757 SYNTAX("b%1.b %a0");
3758 #line 793 "rx-decode.opc"
3759 ID(branch); Scc(cond); DC(pc + IMMex (1));
3760
3761 }
3762 break;
3763 case 0x2e:
3764 {
3765 /** 0010 1110 bra.b %a0 */
3766 if (trace)
3767 {
3768 printf ("\033[33m%s\033[0m %02x\n",
3769 "/** 0010 1110 bra.b %a0 */",
3770 op[0]);
3771 }
3772 SYNTAX("bra.b %a0");
3773 #line 803 "rx-decode.opc"
3774 ID(branch); DC(pc + IMMex(1));
3775
3776 }
3777 break;
3778 case 0x38:
3779 {
3780 /** 0011 1000 bra.w %a0 */
3781 if (trace)
3782 {
3783 printf ("\033[33m%s\033[0m %02x\n",
3784 "/** 0011 1000 bra.w %a0 */",
3785 op[0]);
3786 }
3787 SYNTAX("bra.w %a0");
3788 #line 806 "rx-decode.opc"
3789 ID(branch); DC(pc + IMMex(2));
3790
3791 }
3792 break;
3793 case 0x39:
3794 {
3795 /** 0011 1001 bsr.w %a0 */
3796 if (trace)
3797 {
3798 printf ("\033[33m%s\033[0m %02x\n",
3799 "/** 0011 1001 bsr.w %a0 */",
3800 op[0]);
3801 }
3802 SYNTAX("bsr.w %a0");
3803 #line 822 "rx-decode.opc"
3804 ID(jsr); DC(pc + IMMex(2));
3805
3806 }
3807 break;
3808 case 0x3a:
3809 case 0x3b:
3810 {
3811 /** 0011 101c b%1.w %a0 */
3812 #line 796 "rx-decode.opc"
3813 int c AU = op[0] & 0x01;
3814 if (trace)
3815 {
3816 printf ("\033[33m%s\033[0m %02x\n",
3817 "/** 0011 101c b%1.w %a0 */",
3818 op[0]);
3819 printf (" c = 0x%x\n", c);
3820 }
3821 SYNTAX("b%1.w %a0");
3822 #line 796 "rx-decode.opc"
3823 ID(branch); Scc(c); DC(pc + IMMex (2));
3824
3825
3826 }
3827 break;
3828 case 0x3c:
3829 GETBYTE ();
3830 switch (op[1] & 0x00)
3831 {
3832 case 0x00:
3833 op_semantics_20:
3834 {
3835 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3836 #line 332 "rx-decode.opc"
3837 int sz AU = op[0] & 0x03;
3838 #line 332 "rx-decode.opc"
3839 int d AU = (op[1] >> 7) & 0x01;
3840 #line 332 "rx-decode.opc"
3841 int dst AU = (op[1] >> 4) & 0x07;
3842 #line 332 "rx-decode.opc"
3843 int sppp AU = op[1] & 0x0f;
3844 if (trace)
3845 {
3846 printf ("\033[33m%s\033[0m %02x %02x\n",
3847 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3848 op[0], op[1]);
3849 printf (" sz = 0x%x,", sz);
3850 printf (" d = 0x%x,", d);
3851 printf (" dst = 0x%x,", dst);
3852 printf (" sppp = 0x%x\n", sppp);
3853 }
3854 SYNTAX("mov%s #%1, %0");
3855 #line 332 "rx-decode.opc"
3856 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3857
3858 }
3859 break;
3860 }
3861 break;
3862 case 0x3d:
3863 GETBYTE ();
3864 switch (op[1] & 0x00)
3865 {
3866 case 0x00:
3867 goto op_semantics_20;
3868 break;
3869 }
3870 break;
3871 case 0x3e:
3872 GETBYTE ();
3873 switch (op[1] & 0x00)
3874 {
3875 case 0x00:
3876 goto op_semantics_20;
3877 break;
3878 }
3879 break;
3880 case 0x3f:
3881 GETBYTE ();
3882 switch (op[1] & 0x00)
3883 {
3884 case 0x00:
3885 {
3886 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3887 #line 429 "rx-decode.opc"
3888 int rega AU = (op[1] >> 4) & 0x0f;
3889 #line 429 "rx-decode.opc"
3890 int regb AU = op[1] & 0x0f;
3891 if (trace)
3892 {
3893 printf ("\033[33m%s\033[0m %02x %02x\n",
3894 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3895 op[0], op[1]);
3896 printf (" rega = 0x%x,", rega);
3897 printf (" regb = 0x%x\n", regb);
3898 }
3899 SYNTAX("rtsd #%1, %2-%0");
3900 #line 429 "rx-decode.opc"
3901 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3902
3903 /*----------------------------------------------------------------------*/
3904 /* AND */
3905
3906 }
3907 break;
3908 }
3909 break;
3910 case 0x40:
3911 GETBYTE ();
3912 switch (op[1] & 0x00)
3913 {
3914 case 0x00:
3915 op_semantics_21:
3916 {
3917 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3918 #line 564 "rx-decode.opc"
3919 int ss AU = op[0] & 0x03;
3920 #line 564 "rx-decode.opc"
3921 int rsrc AU = (op[1] >> 4) & 0x0f;
3922 #line 564 "rx-decode.opc"
3923 int rdst AU = op[1] & 0x0f;
3924 if (trace)
3925 {
3926 printf ("\033[33m%s\033[0m %02x %02x\n",
3927 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3928 op[0], op[1]);
3929 printf (" ss = 0x%x,", ss);
3930 printf (" rsrc = 0x%x,", rsrc);
3931 printf (" rdst = 0x%x\n", rdst);
3932 }
3933 SYNTAX("sub %2%S2, %1");
3934 #line 564 "rx-decode.opc"
3935 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3936
3937 }
3938 break;
3939 }
3940 break;
3941 case 0x41:
3942 GETBYTE ();
3943 switch (op[1] & 0x00)
3944 {
3945 case 0x00:
3946 goto op_semantics_21;
3947 break;
3948 }
3949 break;
3950 case 0x42:
3951 GETBYTE ();
3952 switch (op[1] & 0x00)
3953 {
3954 case 0x00:
3955 goto op_semantics_21;
3956 break;
3957 }
3958 break;
3959 case 0x43:
3960 GETBYTE ();
3961 switch (op[1] & 0x00)
3962 {
3963 case 0x00:
3964 goto op_semantics_21;
3965 break;
3966 }
3967 break;
3968 case 0x44:
3969 GETBYTE ();
3970 switch (op[1] & 0x00)
3971 {
3972 case 0x00:
3973 op_semantics_22:
3974 {
3975 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3976 #line 552 "rx-decode.opc"
3977 int ss AU = op[0] & 0x03;
3978 #line 552 "rx-decode.opc"
3979 int rsrc AU = (op[1] >> 4) & 0x0f;
3980 #line 552 "rx-decode.opc"
3981 int rdst AU = op[1] & 0x0f;
3982 if (trace)
3983 {
3984 printf ("\033[33m%s\033[0m %02x %02x\n",
3985 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3986 op[0], op[1]);
3987 printf (" ss = 0x%x,", ss);
3988 printf (" rsrc = 0x%x,", rsrc);
3989 printf (" rdst = 0x%x\n", rdst);
3990 }
3991 SYNTAX("cmp %2%S2, %1");
3992 #line 552 "rx-decode.opc"
3993 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3994
3995 }
3996 break;
3997 }
3998 break;
3999 case 0x45:
4000 GETBYTE ();
4001 switch (op[1] & 0x00)
4002 {
4003 case 0x00:
4004 goto op_semantics_22;
4005 break;
4006 }
4007 break;
4008 case 0x46:
4009 GETBYTE ();
4010 switch (op[1] & 0x00)
4011 {
4012 case 0x00:
4013 goto op_semantics_22;
4014 break;
4015 }
4016 break;
4017 case 0x47:
4018 GETBYTE ();
4019 switch (op[1] & 0x00)
4020 {
4021 case 0x00:
4022 goto op_semantics_22;
4023 break;
4024 }
4025 break;
4026 case 0x48:
4027 GETBYTE ();
4028 switch (op[1] & 0x00)
4029 {
4030 case 0x00:
4031 op_semantics_23:
4032 {
4033 /** 0100 10ss rsrc rdst add %1%S1, %0 */
4034 #line 528 "rx-decode.opc"
4035 int ss AU = op[0] & 0x03;
4036 #line 528 "rx-decode.opc"
4037 int rsrc AU = (op[1] >> 4) & 0x0f;
4038 #line 528 "rx-decode.opc"
4039 int rdst AU = op[1] & 0x0f;
4040 if (trace)
4041 {
4042 printf ("\033[33m%s\033[0m %02x %02x\n",
4043 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4044 op[0], op[1]);
4045 printf (" ss = 0x%x,", ss);
4046 printf (" rsrc = 0x%x,", rsrc);
4047 printf (" rdst = 0x%x\n", rdst);
4048 }
4049 SYNTAX("add %1%S1, %0");
4050 #line 528 "rx-decode.opc"
4051 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4052
4053 }
4054 break;
4055 }
4056 break;
4057 case 0x49:
4058 GETBYTE ();
4059 switch (op[1] & 0x00)
4060 {
4061 case 0x00:
4062 goto op_semantics_23;
4063 break;
4064 }
4065 break;
4066 case 0x4a:
4067 GETBYTE ();
4068 switch (op[1] & 0x00)
4069 {
4070 case 0x00:
4071 goto op_semantics_23;
4072 break;
4073 }
4074 break;
4075 case 0x4b:
4076 GETBYTE ();
4077 switch (op[1] & 0x00)
4078 {
4079 case 0x00:
4080 goto op_semantics_23;
4081 break;
4082 }
4083 break;
4084 case 0x4c:
4085 GETBYTE ();
4086 switch (op[1] & 0x00)
4087 {
4088 case 0x00:
4089 op_semantics_24:
4090 {
4091 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
4092 #line 671 "rx-decode.opc"
4093 int ss AU = op[0] & 0x03;
4094 #line 671 "rx-decode.opc"
4095 int rsrc AU = (op[1] >> 4) & 0x0f;
4096 #line 671 "rx-decode.opc"
4097 int rdst AU = op[1] & 0x0f;
4098 if (trace)
4099 {
4100 printf ("\033[33m%s\033[0m %02x %02x\n",
4101 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4102 op[0], op[1]);
4103 printf (" ss = 0x%x,", ss);
4104 printf (" rsrc = 0x%x,", rsrc);
4105 printf (" rdst = 0x%x\n", rdst);
4106 }
4107 SYNTAX("mul %1%S1, %0");
4108 #line 671 "rx-decode.opc"
4109 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4110
4111 }
4112 break;
4113 }
4114 break;
4115 case 0x4d:
4116 GETBYTE ();
4117 switch (op[1] & 0x00)
4118 {
4119 case 0x00:
4120 goto op_semantics_24;
4121 break;
4122 }
4123 break;
4124 case 0x4e:
4125 GETBYTE ();
4126 switch (op[1] & 0x00)
4127 {
4128 case 0x00:
4129 goto op_semantics_24;
4130 break;
4131 }
4132 break;
4133 case 0x4f:
4134 GETBYTE ();
4135 switch (op[1] & 0x00)
4136 {
4137 case 0x00:
4138 goto op_semantics_24;
4139 break;
4140 }
4141 break;
4142 case 0x50:
4143 GETBYTE ();
4144 switch (op[1] & 0x00)
4145 {
4146 case 0x00:
4147 op_semantics_25:
4148 {
4149 /** 0101 00ss rsrc rdst and %1%S1, %0 */
4150 #line 441 "rx-decode.opc"
4151 int ss AU = op[0] & 0x03;
4152 #line 441 "rx-decode.opc"
4153 int rsrc AU = (op[1] >> 4) & 0x0f;
4154 #line 441 "rx-decode.opc"
4155 int rdst AU = op[1] & 0x0f;
4156 if (trace)
4157 {
4158 printf ("\033[33m%s\033[0m %02x %02x\n",
4159 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4160 op[0], op[1]);
4161 printf (" ss = 0x%x,", ss);
4162 printf (" rsrc = 0x%x,", rsrc);
4163 printf (" rdst = 0x%x\n", rdst);
4164 }
4165 SYNTAX("and %1%S1, %0");
4166 #line 441 "rx-decode.opc"
4167 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4168
4169 }
4170 break;
4171 }
4172 break;
4173 case 0x51:
4174 GETBYTE ();
4175 switch (op[1] & 0x00)
4176 {
4177 case 0x00:
4178 goto op_semantics_25;
4179 break;
4180 }
4181 break;
4182 case 0x52:
4183 GETBYTE ();
4184 switch (op[1] & 0x00)
4185 {
4186 case 0x00:
4187 goto op_semantics_25;
4188 break;
4189 }
4190 break;
4191 case 0x53:
4192 GETBYTE ();
4193 switch (op[1] & 0x00)
4194 {
4195 case 0x00:
4196 goto op_semantics_25;
4197 break;
4198 }
4199 break;
4200 case 0x54:
4201 GETBYTE ();
4202 switch (op[1] & 0x00)
4203 {
4204 case 0x00:
4205 op_semantics_26:
4206 {
4207 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4208 #line 459 "rx-decode.opc"
4209 int ss AU = op[0] & 0x03;
4210 #line 459 "rx-decode.opc"
4211 int rsrc AU = (op[1] >> 4) & 0x0f;
4212 #line 459 "rx-decode.opc"
4213 int rdst AU = op[1] & 0x0f;
4214 if (trace)
4215 {
4216 printf ("\033[33m%s\033[0m %02x %02x\n",
4217 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4218 op[0], op[1]);
4219 printf (" ss = 0x%x,", ss);
4220 printf (" rsrc = 0x%x,", rsrc);
4221 printf (" rdst = 0x%x\n", rdst);
4222 }
4223 SYNTAX("or %1%S1, %0");
4224 #line 459 "rx-decode.opc"
4225 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4226
4227 }
4228 break;
4229 }
4230 break;
4231 case 0x55:
4232 GETBYTE ();
4233 switch (op[1] & 0x00)
4234 {
4235 case 0x00:
4236 goto op_semantics_26;
4237 break;
4238 }
4239 break;
4240 case 0x56:
4241 GETBYTE ();
4242 switch (op[1] & 0x00)
4243 {
4244 case 0x00:
4245 goto op_semantics_26;
4246 break;
4247 }
4248 break;
4249 case 0x57:
4250 GETBYTE ();
4251 switch (op[1] & 0x00)
4252 {
4253 case 0x00:
4254 goto op_semantics_26;
4255 break;
4256 }
4257 break;
4258 case 0x58:
4259 GETBYTE ();
4260 switch (op[1] & 0x00)
4261 {
4262 case 0x00:
4263 op_semantics_27:
4264 {
4265 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4266 #line 380 "rx-decode.opc"
4267 int s AU = (op[0] >> 2) & 0x01;
4268 #line 380 "rx-decode.opc"
4269 int ss AU = op[0] & 0x03;
4270 #line 380 "rx-decode.opc"
4271 int rsrc AU = (op[1] >> 4) & 0x0f;
4272 #line 380 "rx-decode.opc"
4273 int rdst AU = op[1] & 0x0f;
4274 if (trace)
4275 {
4276 printf ("\033[33m%s\033[0m %02x %02x\n",
4277 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4278 op[0], op[1]);
4279 printf (" s = 0x%x,", s);
4280 printf (" ss = 0x%x,", ss);
4281 printf (" rsrc = 0x%x,", rsrc);
4282 printf (" rdst = 0x%x\n", rdst);
4283 }
4284 SYNTAX("movu%s %1, %0");
4285 #line 380 "rx-decode.opc"
4286 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4287
4288 }
4289 break;
4290 }
4291 break;
4292 case 0x59:
4293 GETBYTE ();
4294 switch (op[1] & 0x00)
4295 {
4296 case 0x00:
4297 goto op_semantics_27;
4298 break;
4299 }
4300 break;
4301 case 0x5a:
4302 GETBYTE ();
4303 switch (op[1] & 0x00)
4304 {
4305 case 0x00:
4306 goto op_semantics_27;
4307 break;
4308 }
4309 break;
4310 case 0x5b:
4311 GETBYTE ();
4312 switch (op[1] & 0x00)
4313 {
4314 case 0x00:
4315 goto op_semantics_27;
4316 break;
4317 }
4318 break;
4319 case 0x5c:
4320 GETBYTE ();
4321 switch (op[1] & 0x00)
4322 {
4323 case 0x00:
4324 goto op_semantics_27;
4325 break;
4326 }
4327 break;
4328 case 0x5d:
4329 GETBYTE ();
4330 switch (op[1] & 0x00)
4331 {
4332 case 0x00:
4333 goto op_semantics_27;
4334 break;
4335 }
4336 break;
4337 case 0x5e:
4338 GETBYTE ();
4339 switch (op[1] & 0x00)
4340 {
4341 case 0x00:
4342 goto op_semantics_27;
4343 break;
4344 }
4345 break;
4346 case 0x5f:
4347 GETBYTE ();
4348 switch (op[1] & 0x00)
4349 {
4350 case 0x00:
4351 goto op_semantics_27;
4352 break;
4353 }
4354 break;
4355 case 0x60:
4356 GETBYTE ();
4357 switch (op[1] & 0x00)
4358 {
4359 case 0x00:
4360 {
4361 /** 0110 0000 immm rdst sub #%2, %0 */
4362 #line 561 "rx-decode.opc"
4363 int immm AU = (op[1] >> 4) & 0x0f;
4364 #line 561 "rx-decode.opc"
4365 int rdst AU = op[1] & 0x0f;
4366 if (trace)
4367 {
4368 printf ("\033[33m%s\033[0m %02x %02x\n",
4369 "/** 0110 0000 immm rdst sub #%2, %0 */",
4370 op[0], op[1]);
4371 printf (" immm = 0x%x,", immm);
4372 printf (" rdst = 0x%x\n", rdst);
4373 }
4374 SYNTAX("sub #%2, %0");
4375 #line 561 "rx-decode.opc"
4376 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4377
4378 }
4379 break;
4380 }
4381 break;
4382 case 0x61:
4383 GETBYTE ();
4384 switch (op[1] & 0x00)
4385 {
4386 case 0x00:
4387 {
4388 /** 0110 0001 immm rdst cmp #%2, %1 */
4389 #line 543 "rx-decode.opc"
4390 int immm AU = (op[1] >> 4) & 0x0f;
4391 #line 543 "rx-decode.opc"
4392 int rdst AU = op[1] & 0x0f;
4393 if (trace)
4394 {
4395 printf ("\033[33m%s\033[0m %02x %02x\n",
4396 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4397 op[0], op[1]);
4398 printf (" immm = 0x%x,", immm);
4399 printf (" rdst = 0x%x\n", rdst);
4400 }
4401 SYNTAX("cmp #%2, %1");
4402 #line 543 "rx-decode.opc"
4403 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4404
4405 }
4406 break;
4407 }
4408 break;
4409 case 0x62:
4410 GETBYTE ();
4411 switch (op[1] & 0x00)
4412 {
4413 case 0x00:
4414 {
4415 /** 0110 0010 immm rdst add #%1, %0 */
4416 #line 525 "rx-decode.opc"
4417 int immm AU = (op[1] >> 4) & 0x0f;
4418 #line 525 "rx-decode.opc"
4419 int rdst AU = op[1] & 0x0f;
4420 if (trace)
4421 {
4422 printf ("\033[33m%s\033[0m %02x %02x\n",
4423 "/** 0110 0010 immm rdst add #%1, %0 */",
4424 op[0], op[1]);
4425 printf (" immm = 0x%x,", immm);
4426 printf (" rdst = 0x%x\n", rdst);
4427 }
4428 SYNTAX("add #%1, %0");
4429 #line 525 "rx-decode.opc"
4430 ID(add); SC(immm); DR(rdst); F_OSZC;
4431
4432 }
4433 break;
4434 }
4435 break;
4436 case 0x63:
4437 GETBYTE ();
4438 switch (op[1] & 0x00)
4439 {
4440 case 0x00:
4441 {
4442 /** 0110 0011 immm rdst mul #%1, %0 */
4443 #line 637 "rx-decode.opc"
4444 int immm AU = (op[1] >> 4) & 0x0f;
4445 #line 637 "rx-decode.opc"
4446 int rdst AU = op[1] & 0x0f;
4447 if (trace)
4448 {
4449 printf ("\033[33m%s\033[0m %02x %02x\n",
4450 "/** 0110 0011 immm rdst mul #%1, %0 */",
4451 op[0], op[1]);
4452 printf (" immm = 0x%x,", immm);
4453 printf (" rdst = 0x%x\n", rdst);
4454 }
4455 SYNTAX("mul #%1, %0");
4456 #line 637 "rx-decode.opc"
4457 if (immm == 1 && rdst == 0)
4458 {
4459 ID(nop2);
4460 SYNTAX ("nop\t; mul\t#1, r0");
4461 }
4462 else
4463 {
4464 ID(mul);
4465 }
4466 DR(rdst); SC(immm); F_____;
4467
4468 }
4469 break;
4470 }
4471 break;
4472 case 0x64:
4473 GETBYTE ();
4474 switch (op[1] & 0x00)
4475 {
4476 case 0x00:
4477 {
4478 /** 0110 0100 immm rdst and #%1, %0 */
4479 #line 435 "rx-decode.opc"
4480 int immm AU = (op[1] >> 4) & 0x0f;
4481 #line 435 "rx-decode.opc"
4482 int rdst AU = op[1] & 0x0f;
4483 if (trace)
4484 {
4485 printf ("\033[33m%s\033[0m %02x %02x\n",
4486 "/** 0110 0100 immm rdst and #%1, %0 */",
4487 op[0], op[1]);
4488 printf (" immm = 0x%x,", immm);
4489 printf (" rdst = 0x%x\n", rdst);
4490 }
4491 SYNTAX("and #%1, %0");
4492 #line 435 "rx-decode.opc"
4493 ID(and); SC(immm); DR(rdst); F__SZ_;
4494
4495 }
4496 break;
4497 }
4498 break;
4499 case 0x65:
4500 GETBYTE ();
4501 switch (op[1] & 0x00)
4502 {
4503 case 0x00:
4504 {
4505 /** 0110 0101 immm rdst or #%1, %0 */
4506 #line 453 "rx-decode.opc"
4507 int immm AU = (op[1] >> 4) & 0x0f;
4508 #line 453 "rx-decode.opc"
4509 int rdst AU = op[1] & 0x0f;
4510 if (trace)
4511 {
4512 printf ("\033[33m%s\033[0m %02x %02x\n",
4513 "/** 0110 0101 immm rdst or #%1, %0 */",
4514 op[0], op[1]);
4515 printf (" immm = 0x%x,", immm);
4516 printf (" rdst = 0x%x\n", rdst);
4517 }
4518 SYNTAX("or #%1, %0");
4519 #line 453 "rx-decode.opc"
4520 ID(or); SC(immm); DR(rdst); F__SZ_;
4521
4522 }
4523 break;
4524 }
4525 break;
4526 case 0x66:
4527 GETBYTE ();
4528 switch (op[1] & 0x00)
4529 {
4530 case 0x00:
4531 {
4532 /** 0110 0110 immm rdst mov%s #%1, %0 */
4533 #line 329 "rx-decode.opc"
4534 int immm AU = (op[1] >> 4) & 0x0f;
4535 #line 329 "rx-decode.opc"
4536 int rdst AU = op[1] & 0x0f;
4537 if (trace)
4538 {
4539 printf ("\033[33m%s\033[0m %02x %02x\n",
4540 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4541 op[0], op[1]);
4542 printf (" immm = 0x%x,", immm);
4543 printf (" rdst = 0x%x\n", rdst);
4544 }
4545 SYNTAX("mov%s #%1, %0");
4546 #line 329 "rx-decode.opc"
4547 ID(mov); DR(rdst); SC(immm); F_____;
4548
4549 }
4550 break;
4551 }
4552 break;
4553 case 0x67:
4554 {
4555 /** 0110 0111 rtsd #%1 */
4556 if (trace)
4557 {
4558 printf ("\033[33m%s\033[0m %02x\n",
4559 "/** 0110 0111 rtsd #%1 */",
4560 op[0]);
4561 }
4562 SYNTAX("rtsd #%1");
4563 #line 426 "rx-decode.opc"
4564 ID(rtsd); SC(IMM(1) * 4);
4565
4566 }
4567 break;
4568 case 0x68:
4569 GETBYTE ();
4570 switch (op[1] & 0x00)
4571 {
4572 case 0x00:
4573 op_semantics_28:
4574 {
4575 /** 0110 100i mmmm rdst shlr #%2, %0 */
4576 #line 751 "rx-decode.opc"
4577 int i AU = op[0] & 0x01;
4578 #line 751 "rx-decode.opc"
4579 int mmmm AU = (op[1] >> 4) & 0x0f;
4580 #line 751 "rx-decode.opc"
4581 int rdst AU = op[1] & 0x0f;
4582 if (trace)
4583 {
4584 printf ("\033[33m%s\033[0m %02x %02x\n",
4585 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4586 op[0], op[1]);
4587 printf (" i = 0x%x,", i);
4588 printf (" mmmm = 0x%x,", mmmm);
4589 printf (" rdst = 0x%x\n", rdst);
4590 }
4591 SYNTAX("shlr #%2, %0");
4592 #line 751 "rx-decode.opc"
4593 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4594
4595 }
4596 break;
4597 }
4598 break;
4599 case 0x69:
4600 GETBYTE ();
4601 switch (op[1] & 0x00)
4602 {
4603 case 0x00:
4604 goto op_semantics_28;
4605 break;
4606 }
4607 break;
4608 case 0x6a:
4609 GETBYTE ();
4610 switch (op[1] & 0x00)
4611 {
4612 case 0x00:
4613 op_semantics_29:
4614 {
4615 /** 0110 101i mmmm rdst shar #%2, %0 */
4616 #line 741 "rx-decode.opc"
4617 int i AU = op[0] & 0x01;
4618 #line 741 "rx-decode.opc"
4619 int mmmm AU = (op[1] >> 4) & 0x0f;
4620 #line 741 "rx-decode.opc"
4621 int rdst AU = op[1] & 0x0f;
4622 if (trace)
4623 {
4624 printf ("\033[33m%s\033[0m %02x %02x\n",
4625 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4626 op[0], op[1]);
4627 printf (" i = 0x%x,", i);
4628 printf (" mmmm = 0x%x,", mmmm);
4629 printf (" rdst = 0x%x\n", rdst);
4630 }
4631 SYNTAX("shar #%2, %0");
4632 #line 741 "rx-decode.opc"
4633 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4634
4635 }
4636 break;
4637 }
4638 break;
4639 case 0x6b:
4640 GETBYTE ();
4641 switch (op[1] & 0x00)
4642 {
4643 case 0x00:
4644 goto op_semantics_29;
4645 break;
4646 }
4647 break;
4648 case 0x6c:
4649 GETBYTE ();
4650 switch (op[1] & 0x00)
4651 {
4652 case 0x00:
4653 op_semantics_30:
4654 {
4655 /** 0110 110i mmmm rdst shll #%2, %0 */
4656 #line 731 "rx-decode.opc"
4657 int i AU = op[0] & 0x01;
4658 #line 731 "rx-decode.opc"
4659 int mmmm AU = (op[1] >> 4) & 0x0f;
4660 #line 731 "rx-decode.opc"
4661 int rdst AU = op[1] & 0x0f;
4662 if (trace)
4663 {
4664 printf ("\033[33m%s\033[0m %02x %02x\n",
4665 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4666 op[0], op[1]);
4667 printf (" i = 0x%x,", i);
4668 printf (" mmmm = 0x%x,", mmmm);
4669 printf (" rdst = 0x%x\n", rdst);
4670 }
4671 SYNTAX("shll #%2, %0");
4672 #line 731 "rx-decode.opc"
4673 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4674
4675 }
4676 break;
4677 }
4678 break;
4679 case 0x6d:
4680 GETBYTE ();
4681 switch (op[1] & 0x00)
4682 {
4683 case 0x00:
4684 goto op_semantics_30;
4685 break;
4686 }
4687 break;
4688 case 0x6e:
4689 GETBYTE ();
4690 switch (op[1] & 0x00)
4691 {
4692 case 0x00:
4693 {
4694 /** 0110 1110 dsta dstb pushm %1-%2 */
4695 #line 393 "rx-decode.opc"
4696 int dsta AU = (op[1] >> 4) & 0x0f;
4697 #line 393 "rx-decode.opc"
4698 int dstb AU = op[1] & 0x0f;
4699 if (trace)
4700 {
4701 printf ("\033[33m%s\033[0m %02x %02x\n",
4702 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4703 op[0], op[1]);
4704 printf (" dsta = 0x%x,", dsta);
4705 printf (" dstb = 0x%x\n", dstb);
4706 }
4707 SYNTAX("pushm %1-%2");
4708 #line 393 "rx-decode.opc"
4709 ID(pushm); SR(dsta); S2R(dstb); F_____;
4710
4711 }
4712 break;
4713 }
4714 break;
4715 case 0x6f:
4716 GETBYTE ();
4717 switch (op[1] & 0x00)
4718 {
4719 case 0x00:
4720 {
4721 /** 0110 1111 dsta dstb popm %1-%2 */
4722 #line 390 "rx-decode.opc"
4723 int dsta AU = (op[1] >> 4) & 0x0f;
4724 #line 390 "rx-decode.opc"
4725 int dstb AU = op[1] & 0x0f;
4726 if (trace)
4727 {
4728 printf ("\033[33m%s\033[0m %02x %02x\n",
4729 "/** 0110 1111 dsta dstb popm %1-%2 */",
4730 op[0], op[1]);
4731 printf (" dsta = 0x%x,", dsta);
4732 printf (" dstb = 0x%x\n", dstb);
4733 }
4734 SYNTAX("popm %1-%2");
4735 #line 390 "rx-decode.opc"
4736 ID(popm); SR(dsta); S2R(dstb); F_____;
4737
4738 }
4739 break;
4740 }
4741 break;
4742 case 0x70:
4743 GETBYTE ();
4744 switch (op[1] & 0x00)
4745 {
4746 case 0x00:
4747 op_semantics_31:
4748 {
4749 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4750 #line 534 "rx-decode.opc"
4751 int im AU = op[0] & 0x03;
4752 #line 534 "rx-decode.opc"
4753 int rsrc AU = (op[1] >> 4) & 0x0f;
4754 #line 534 "rx-decode.opc"
4755 int rdst AU = op[1] & 0x0f;
4756 if (trace)
4757 {
4758 printf ("\033[33m%s\033[0m %02x %02x\n",
4759 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4760 op[0], op[1]);
4761 printf (" im = 0x%x,", im);
4762 printf (" rsrc = 0x%x,", rsrc);
4763 printf (" rdst = 0x%x\n", rdst);
4764 }
4765 SYNTAX("add #%1, %2, %0");
4766 #line 534 "rx-decode.opc"
4767 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4768
4769 }
4770 break;
4771 }
4772 break;
4773 case 0x71:
4774 GETBYTE ();
4775 switch (op[1] & 0x00)
4776 {
4777 case 0x00:
4778 goto op_semantics_31;
4779 break;
4780 }
4781 break;
4782 case 0x72:
4783 GETBYTE ();
4784 switch (op[1] & 0x00)
4785 {
4786 case 0x00:
4787 goto op_semantics_31;
4788 break;
4789 }
4790 break;
4791 case 0x73:
4792 GETBYTE ();
4793 switch (op[1] & 0x00)
4794 {
4795 case 0x00:
4796 goto op_semantics_31;
4797 break;
4798 }
4799 break;
4800 case 0x74:
4801 GETBYTE ();
4802 switch (op[1] & 0xf0)
4803 {
4804 case 0x00:
4805 op_semantics_32:
4806 {
4807 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4808 #line 546 "rx-decode.opc"
4809 int im AU = op[0] & 0x03;
4810 #line 546 "rx-decode.opc"
4811 int rsrc AU = op[1] & 0x0f;
4812 if (trace)
4813 {
4814 printf ("\033[33m%s\033[0m %02x %02x\n",
4815 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4816 op[0], op[1]);
4817 printf (" im = 0x%x,", im);
4818 printf (" rsrc = 0x%x\n", rsrc);
4819 }
4820 SYNTAX("cmp #%2, %1%S1");
4821 #line 546 "rx-decode.opc"
4822 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4823
4824 }
4825 break;
4826 case 0x10:
4827 op_semantics_33:
4828 {
4829 /** 0111 01im 0001rdst mul #%1, %0 */
4830 #line 649 "rx-decode.opc"
4831 int im AU = op[0] & 0x03;
4832 #line 649 "rx-decode.opc"
4833 int rdst AU = op[1] & 0x0f;
4834 if (trace)
4835 {
4836 printf ("\033[33m%s\033[0m %02x %02x\n",
4837 "/** 0111 01im 0001rdst mul #%1, %0 */",
4838 op[0], op[1]);
4839 printf (" im = 0x%x,", im);
4840 printf (" rdst = 0x%x\n", rdst);
4841 }
4842 SYNTAX("mul #%1, %0");
4843 #line 649 "rx-decode.opc"
4844 int val = IMMex(im);
4845 if (val == 1 && rdst == 0)
4846 {
4847 SYNTAX("nop\t; mul\t#1, r0");
4848 switch (im)
4849 {
4850 case 2: ID(nop4); break;
4851 case 3: ID(nop5); break;
4852 case 0: ID(nop6); break;
4853 default:
4854 ID(mul);
4855 SYNTAX("mul #%1, %0");
4856 break;
4857 }
4858 }
4859 else
4860 {
4861 ID(mul);
4862 }
4863 DR(rdst); SC(val); F_____;
4864
4865 }
4866 break;
4867 case 0x20:
4868 op_semantics_34:
4869 {
4870 /** 0111 01im 0010 rdst and #%1, %0 */
4871 #line 438 "rx-decode.opc"
4872 int im AU = op[0] & 0x03;
4873 #line 438 "rx-decode.opc"
4874 int rdst AU = op[1] & 0x0f;
4875 if (trace)
4876 {
4877 printf ("\033[33m%s\033[0m %02x %02x\n",
4878 "/** 0111 01im 0010 rdst and #%1, %0 */",
4879 op[0], op[1]);
4880 printf (" im = 0x%x,", im);
4881 printf (" rdst = 0x%x\n", rdst);
4882 }
4883 SYNTAX("and #%1, %0");
4884 #line 438 "rx-decode.opc"
4885 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4886
4887 }
4888 break;
4889 case 0x30:
4890 op_semantics_35:
4891 {
4892 /** 0111 01im 0011 rdst or #%1, %0 */
4893 #line 456 "rx-decode.opc"
4894 int im AU = op[0] & 0x03;
4895 #line 456 "rx-decode.opc"
4896 int rdst AU = op[1] & 0x0f;
4897 if (trace)
4898 {
4899 printf ("\033[33m%s\033[0m %02x %02x\n",
4900 "/** 0111 01im 0011 rdst or #%1, %0 */",
4901 op[0], op[1]);
4902 printf (" im = 0x%x,", im);
4903 printf (" rdst = 0x%x\n", rdst);
4904 }
4905 SYNTAX("or #%1, %0");
4906 #line 456 "rx-decode.opc"
4907 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4908
4909 }
4910 break;
4911 default: UNSUPPORTED(); break;
4912 }
4913 break;
4914 case 0x75:
4915 GETBYTE ();
4916 switch (op[1] & 0xff)
4917 {
4918 case 0x00:
4919 case 0x01:
4920 case 0x02:
4921 case 0x03:
4922 case 0x04:
4923 case 0x05:
4924 case 0x06:
4925 case 0x07:
4926 case 0x08:
4927 case 0x09:
4928 case 0x0a:
4929 case 0x0b:
4930 case 0x0c:
4931 case 0x0d:
4932 case 0x0e:
4933 case 0x0f:
4934 goto op_semantics_32;
4935 break;
4936 case 0x10:
4937 case 0x11:
4938 case 0x12:
4939 case 0x13:
4940 case 0x14:
4941 case 0x15:
4942 case 0x16:
4943 case 0x17:
4944 case 0x18:
4945 case 0x19:
4946 case 0x1a:
4947 case 0x1b:
4948 case 0x1c:
4949 case 0x1d:
4950 case 0x1e:
4951 case 0x1f:
4952 goto op_semantics_33;
4953 break;
4954 case 0x20:
4955 case 0x21:
4956 case 0x22:
4957 case 0x23:
4958 case 0x24:
4959 case 0x25:
4960 case 0x26:
4961 case 0x27:
4962 case 0x28:
4963 case 0x29:
4964 case 0x2a:
4965 case 0x2b:
4966 case 0x2c:
4967 case 0x2d:
4968 case 0x2e:
4969 case 0x2f:
4970 goto op_semantics_34;
4971 break;
4972 case 0x30:
4973 case 0x31:
4974 case 0x32:
4975 case 0x33:
4976 case 0x34:
4977 case 0x35:
4978 case 0x36:
4979 case 0x37:
4980 case 0x38:
4981 case 0x39:
4982 case 0x3a:
4983 case 0x3b:
4984 case 0x3c:
4985 case 0x3d:
4986 case 0x3e:
4987 case 0x3f:
4988 goto op_semantics_35;
4989 break;
4990 case 0x40:
4991 case 0x41:
4992 case 0x42:
4993 case 0x43:
4994 case 0x44:
4995 case 0x45:
4996 case 0x46:
4997 case 0x47:
4998 case 0x48:
4999 case 0x49:
5000 case 0x4a:
5001 case 0x4b:
5002 case 0x4c:
5003 case 0x4d:
5004 case 0x4e:
5005 case 0x4f:
5006 {
5007 /** 0111 0101 0100 rdst mov%s #%1, %0 */
5008 #line 310 "rx-decode.opc"
5009 int rdst AU = op[1] & 0x0f;
5010 if (trace)
5011 {
5012 printf ("\033[33m%s\033[0m %02x %02x\n",
5013 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
5014 op[0], op[1]);
5015 printf (" rdst = 0x%x\n", rdst);
5016 }
5017 SYNTAX("mov%s #%1, %0");
5018 #line 310 "rx-decode.opc"
5019 ID(mov); DR(rdst); SC(IMM (1)); F_____;
5020
5021 }
5022 break;
5023 case 0x50:
5024 case 0x51:
5025 case 0x52:
5026 case 0x53:
5027 case 0x54:
5028 case 0x55:
5029 case 0x56:
5030 case 0x57:
5031 case 0x58:
5032 case 0x59:
5033 case 0x5a:
5034 case 0x5b:
5035 case 0x5c:
5036 case 0x5d:
5037 case 0x5e:
5038 case 0x5f:
5039 {
5040 /** 0111 0101 0101 rsrc cmp #%2, %1 */
5041 #line 549 "rx-decode.opc"
5042 int rsrc AU = op[1] & 0x0f;
5043 if (trace)
5044 {
5045 printf ("\033[33m%s\033[0m %02x %02x\n",
5046 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5047 op[0], op[1]);
5048 printf (" rsrc = 0x%x\n", rsrc);
5049 }
5050 SYNTAX("cmp #%2, %1");
5051 #line 549 "rx-decode.opc"
5052 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5053
5054 }
5055 break;
5056 case 0x60:
5057 {
5058 /** 0111 0101 0110 0000 int #%1 */
5059 if (trace)
5060 {
5061 printf ("\033[33m%s\033[0m %02x %02x\n",
5062 "/** 0111 0101 0110 0000 int #%1 */",
5063 op[0], op[1]);
5064 }
5065 SYNTAX("int #%1");
5066 #line 1056 "rx-decode.opc"
5067 ID(int); SC(IMM(1));
5068
5069 }
5070 break;
5071 case 0x70:
5072 GETBYTE ();
5073 switch (op[2] & 0xf0)
5074 {
5075 case 0x00:
5076 {
5077 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
5078 #line 1023 "rx-decode.opc"
5079 int immm AU = op[2] & 0x0f;
5080 if (trace)
5081 {
5082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5083 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5084 op[0], op[1], op[2]);
5085 printf (" immm = 0x%x\n", immm);
5086 }
5087 SYNTAX("mvtipl #%1");
5088 #line 1023 "rx-decode.opc"
5089 ID(mvtipl); SC(immm);
5090
5091 }
5092 break;
5093 default: UNSUPPORTED(); break;
5094 }
5095 break;
5096 case 0x90:
5097 GETBYTE ();
5098 switch (op[2] & 0xff)
5099 {
5100 case 0x1b:
5101 {
5102 /** 0111 0101 1001 0000 0001 1011 mvfdr */
5103 if (trace)
5104 {
5105 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5106 "/** 0111 0101 1001 0000 0001 1011 mvfdr */",
5107 op[0], op[1], op[2]);
5108 }
5109 SYNTAX("mvfdr");
5110 #line 1229 "rx-decode.opc"
5111 ID(mvfdr); F_____;
5112
5113 }
5114 break;
5115 default: UNSUPPORTED(); break;
5116 }
5117 break;
5118 case 0xa0:
5119 GETBYTE ();
5120 switch (op[2] & 0x00)
5121 {
5122 case 0x00:
5123 {
5124 /** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */
5125 #line 1223 "rx-decode.opc"
5126 int rdst AU = (op[2] >> 4) & 0x0f;
5127 #line 1223 "rx-decode.opc"
5128 int rnum AU = op[2] & 0x0f;
5129 if (trace)
5130 {
5131 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5132 "/** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */",
5133 op[0], op[1], op[2]);
5134 printf (" rdst = 0x%x,", rdst);
5135 printf (" rnum = 0x%x\n", rnum);
5136 }
5137 SYNTAX("dpushm.l %1-%2");
5138 #line 1223 "rx-decode.opc"
5139 ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____;
5140
5141 }
5142 break;
5143 }
5144 break;
5145 case 0xa8:
5146 GETBYTE ();
5147 switch (op[2] & 0x00)
5148 {
5149 case 0x00:
5150 {
5151 /** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */
5152 #line 1217 "rx-decode.opc"
5153 int rdst AU = (op[2] >> 4) & 0x0f;
5154 #line 1217 "rx-decode.opc"
5155 int rnum AU = op[2] & 0x0f;
5156 if (trace)
5157 {
5158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5159 "/** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */",
5160 op[0], op[1], op[2]);
5161 printf (" rdst = 0x%x,", rdst);
5162 printf (" rnum = 0x%x\n", rnum);
5163 }
5164 SYNTAX("dpopm.l %1-%2");
5165 #line 1217 "rx-decode.opc"
5166 ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____;
5167
5168 }
5169 break;
5170 }
5171 break;
5172 case 0xb0:
5173 GETBYTE ();
5174 switch (op[2] & 0x00)
5175 {
5176 case 0x00:
5177 {
5178 /** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */
5179 #line 1220 "rx-decode.opc"
5180 int rdst AU = (op[2] >> 4) & 0x0f;
5181 #line 1220 "rx-decode.opc"
5182 int rnum AU = op[2] & 0x0f;
5183 if (trace)
5184 {
5185 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5186 "/** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */",
5187 op[0], op[1], op[2]);
5188 printf (" rdst = 0x%x,", rdst);
5189 printf (" rnum = 0x%x\n", rnum);
5190 }
5191 SYNTAX("dpushm.d %1-%2");
5192 #line 1220 "rx-decode.opc"
5193 ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____;
5194
5195 }
5196 break;
5197 }
5198 break;
5199 case 0xb8:
5200 GETBYTE ();
5201 switch (op[2] & 0x00)
5202 {
5203 case 0x00:
5204 {
5205 /** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */
5206 #line 1214 "rx-decode.opc"
5207 int rdst AU = (op[2] >> 4) & 0x0f;
5208 #line 1214 "rx-decode.opc"
5209 int rnum AU = op[2] & 0x0f;
5210 if (trace)
5211 {
5212 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5213 "/** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */",
5214 op[0], op[1], op[2]);
5215 printf (" rdst = 0x%x,", rdst);
5216 printf (" rnum = 0x%x\n", rnum);
5217 }
5218 SYNTAX("dpopm.d %1-%2");
5219 #line 1214 "rx-decode.opc"
5220 ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____;
5221
5222 }
5223 break;
5224 }
5225 break;
5226 default: UNSUPPORTED(); break;
5227 }
5228 break;
5229 case 0x76:
5230 GETBYTE ();
5231 switch (op[1] & 0xff)
5232 {
5233 case 0x00:
5234 case 0x01:
5235 case 0x02:
5236 case 0x03:
5237 case 0x04:
5238 case 0x05:
5239 case 0x06:
5240 case 0x07:
5241 case 0x08:
5242 case 0x09:
5243 case 0x0a:
5244 case 0x0b:
5245 case 0x0c:
5246 case 0x0d:
5247 case 0x0e:
5248 case 0x0f:
5249 goto op_semantics_32;
5250 break;
5251 case 0x10:
5252 case 0x11:
5253 case 0x12:
5254 case 0x13:
5255 case 0x14:
5256 case 0x15:
5257 case 0x16:
5258 case 0x17:
5259 case 0x18:
5260 case 0x19:
5261 case 0x1a:
5262 case 0x1b:
5263 case 0x1c:
5264 case 0x1d:
5265 case 0x1e:
5266 case 0x1f:
5267 goto op_semantics_33;
5268 break;
5269 case 0x20:
5270 case 0x21:
5271 case 0x22:
5272 case 0x23:
5273 case 0x24:
5274 case 0x25:
5275 case 0x26:
5276 case 0x27:
5277 case 0x28:
5278 case 0x29:
5279 case 0x2a:
5280 case 0x2b:
5281 case 0x2c:
5282 case 0x2d:
5283 case 0x2e:
5284 case 0x2f:
5285 goto op_semantics_34;
5286 break;
5287 case 0x30:
5288 case 0x31:
5289 case 0x32:
5290 case 0x33:
5291 case 0x34:
5292 case 0x35:
5293 case 0x36:
5294 case 0x37:
5295 case 0x38:
5296 case 0x39:
5297 case 0x3a:
5298 case 0x3b:
5299 case 0x3c:
5300 case 0x3d:
5301 case 0x3e:
5302 case 0x3f:
5303 goto op_semantics_35;
5304 break;
5305 case 0x90:
5306 GETBYTE ();
5307 switch (op[2] & 0xff)
5308 {
5309 case 0x00:
5310 GETBYTE ();
5311 switch (op[3] & 0x00)
5312 {
5313 case 0x00:
5314 op_semantics_36:
5315 {
5316 /** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */
5317 #line 1238 "rx-decode.opc"
5318 int srcb AU = (op[2] >> 4) & 0x0f;
5319 #line 1238 "rx-decode.opc"
5320 int rdst AU = (op[3] >> 4) & 0x0f;
5321 #line 1238 "rx-decode.opc"
5322 int srca AU = op[3] & 0x0f;
5323 if (trace)
5324 {
5325 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5326 "/** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */",
5327 op[0], op[1], op[2], op[3]);
5328 printf (" srcb = 0x%x,", srcb);
5329 printf (" rdst = 0x%x,", rdst);
5330 printf (" srca = 0x%x\n", srca);
5331 }
5332 SYNTAX("dadd %1, %2, %0");
5333 #line 1238 "rx-decode.opc"
5334 ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5335
5336 }
5337 break;
5338 }
5339 break;
5340 case 0x01:
5341 GETBYTE ();
5342 switch (op[3] & 0x00)
5343 {
5344 case 0x00:
5345 op_semantics_37:
5346 {
5347 /** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */
5348 #line 1259 "rx-decode.opc"
5349 int srcb AU = (op[2] >> 4) & 0x0f;
5350 #line 1259 "rx-decode.opc"
5351 int rdst AU = (op[3] >> 4) & 0x0f;
5352 #line 1259 "rx-decode.opc"
5353 int srca AU = op[3] & 0x0f;
5354 if (trace)
5355 {
5356 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5357 "/** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */",
5358 op[0], op[1], op[2], op[3]);
5359 printf (" srcb = 0x%x,", srcb);
5360 printf (" rdst = 0x%x,", rdst);
5361 printf (" srca = 0x%x\n", srca);
5362 }
5363 SYNTAX("dsub %1, %2, %0");
5364 #line 1259 "rx-decode.opc"
5365 ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5366
5367 }
5368 break;
5369 }
5370 break;
5371 case 0x02:
5372 GETBYTE ();
5373 switch (op[3] & 0x00)
5374 {
5375 case 0x00:
5376 op_semantics_38:
5377 {
5378 /** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */
5379 #line 1247 "rx-decode.opc"
5380 int srcb AU = (op[2] >> 4) & 0x0f;
5381 #line 1247 "rx-decode.opc"
5382 int rdst AU = (op[3] >> 4) & 0x0f;
5383 #line 1247 "rx-decode.opc"
5384 int srca AU = op[3] & 0x0f;
5385 if (trace)
5386 {
5387 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5388 "/** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */",
5389 op[0], op[1], op[2], op[3]);
5390 printf (" srcb = 0x%x,", srcb);
5391 printf (" rdst = 0x%x,", rdst);
5392 printf (" srca = 0x%x\n", srca);
5393 }
5394 SYNTAX("dmul %1, %2, %0");
5395 #line 1247 "rx-decode.opc"
5396 ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5397
5398 }
5399 break;
5400 }
5401 break;
5402 case 0x05:
5403 GETBYTE ();
5404 switch (op[3] & 0x00)
5405 {
5406 case 0x00:
5407 op_semantics_39:
5408 {
5409 /** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */
5410 #line 1244 "rx-decode.opc"
5411 int srcb AU = (op[2] >> 4) & 0x0f;
5412 #line 1244 "rx-decode.opc"
5413 int rdst AU = (op[3] >> 4) & 0x0f;
5414 #line 1244 "rx-decode.opc"
5415 int srca AU = op[3] & 0x0f;
5416 if (trace)
5417 {
5418 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5419 "/** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */",
5420 op[0], op[1], op[2], op[3]);
5421 printf (" srcb = 0x%x,", srcb);
5422 printf (" rdst = 0x%x,", rdst);
5423 printf (" srca = 0x%x\n", srca);
5424 }
5425 SYNTAX("ddiv %1, %2, %0");
5426 #line 1244 "rx-decode.opc"
5427 ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5428
5429 }
5430 break;
5431 }
5432 break;
5433 case 0x08:
5434 GETBYTE ();
5435 switch (op[3] & 0x00)
5436 {
5437 case 0x00:
5438 op_semantics_40:
5439 {
5440 /** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */
5441 #line 1241 "rx-decode.opc"
5442 int srcb AU = (op[2] >> 4) & 0x0f;
5443 #line 1241 "rx-decode.opc"
5444 int cond AU = (op[3] >> 4) & 0x0f;
5445 #line 1241 "rx-decode.opc"
5446 int srca AU = op[3] & 0x0f;
5447 if (trace)
5448 {
5449 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5450 "/** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */",
5451 op[0], op[1], op[2], op[3]);
5452 printf (" srcb = 0x%x,", srcb);
5453 printf (" cond = 0x%x,", cond);
5454 printf (" srca = 0x%x\n", srca);
5455 }
5456 SYNTAX("dcmp%0 %1, %2");
5457 #line 1241 "rx-decode.opc"
5458 ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____;
5459
5460 }
5461 break;
5462 }
5463 break;
5464 case 0x0c:
5465 GETBYTE ();
5466 switch (op[3] & 0x0f)
5467 {
5468 case 0x00:
5469 op_semantics_41:
5470 {
5471 /** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */
5472 #line 1179 "rx-decode.opc"
5473 int rsrc AU = (op[2] >> 4) & 0x0f;
5474 #line 1179 "rx-decode.opc"
5475 int rdst AU = (op[3] >> 4) & 0x0f;
5476 if (trace)
5477 {
5478 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5479 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */",
5480 op[0], op[1], op[2], op[3]);
5481 printf (" rsrc = 0x%x,", rsrc);
5482 printf (" rdst = 0x%x\n", rdst);
5483 }
5484 SYNTAX("dmov.d %1, %0");
5485 #line 1179 "rx-decode.opc"
5486 ID(dmov); DDR(rdst); SDR(rsrc); F_____;
5487
5488 }
5489 break;
5490 case 0x01:
5491 op_semantics_42:
5492 {
5493 /** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */
5494 #line 1235 "rx-decode.opc"
5495 int rsrc AU = (op[2] >> 4) & 0x0f;
5496 #line 1235 "rx-decode.opc"
5497 int rdst AU = (op[3] >> 4) & 0x0f;
5498 if (trace)
5499 {
5500 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5501 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */",
5502 op[0], op[1], op[2], op[3]);
5503 printf (" rsrc = 0x%x,", rsrc);
5504 printf (" rdst = 0x%x\n", rdst);
5505 }
5506 SYNTAX("dabs %1, %0");
5507 #line 1235 "rx-decode.opc"
5508 ID(dabs); DDR(rdst); SDR(rsrc); F_____;
5509
5510 }
5511 break;
5512 case 0x02:
5513 op_semantics_43:
5514 {
5515 /** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */
5516 #line 1250 "rx-decode.opc"
5517 int rsrc AU = (op[2] >> 4) & 0x0f;
5518 #line 1250 "rx-decode.opc"
5519 int rdst AU = (op[3] >> 4) & 0x0f;
5520 if (trace)
5521 {
5522 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5523 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */",
5524 op[0], op[1], op[2], op[3]);
5525 printf (" rsrc = 0x%x,", rsrc);
5526 printf (" rdst = 0x%x\n", rdst);
5527 }
5528 SYNTAX("dneg %1, %0");
5529 #line 1250 "rx-decode.opc"
5530 ID(dneg); DDR(rdst); SDR(rsrc); F_____;
5531
5532 }
5533 break;
5534 default: UNSUPPORTED(); break;
5535 }
5536 break;
5537 case 0x0d:
5538 GETBYTE ();
5539 switch (op[3] & 0x0f)
5540 {
5541 case 0x00:
5542 op_semantics_44:
5543 {
5544 /** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */
5545 #line 1256 "rx-decode.opc"
5546 int rsrc AU = (op[2] >> 4) & 0x0f;
5547 #line 1256 "rx-decode.opc"
5548 int rdst AU = (op[3] >> 4) & 0x0f;
5549 if (trace)
5550 {
5551 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5552 "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */",
5553 op[0], op[1], op[2], op[3]);
5554 printf (" rsrc = 0x%x,", rsrc);
5555 printf (" rdst = 0x%x\n", rdst);
5556 }
5557 SYNTAX("dsqrt %1, %0");
5558 #line 1256 "rx-decode.opc"
5559 ID(dsqrt); DDR(rdst); SDR(rsrc); F_____;
5560
5561 }
5562 break;
5563 case 0x08:
5564 op_semantics_45:
5565 {
5566 /** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */
5567 #line 1265 "rx-decode.opc"
5568 int rsrc AU = (op[2] >> 4) & 0x0f;
5569 #line 1265 "rx-decode.opc"
5570 int rdst AU = (op[3] >> 4) & 0x0f;
5571 if (trace)
5572 {
5573 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5574 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */",
5575 op[0], op[1], op[2], op[3]);
5576 printf (" rsrc = 0x%x,", rsrc);
5577 printf (" rdst = 0x%x\n", rdst);
5578 }
5579 SYNTAX("dtoi %1, %0");
5580 #line 1265 "rx-decode.opc"
5581 ID(dtoi); DDR(rdst); SDR(rsrc); F_____;
5582
5583 }
5584 break;
5585 case 0x09:
5586 op_semantics_46:
5587 {
5588 /** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */
5589 #line 1268 "rx-decode.opc"
5590 int rsrc AU = (op[2] >> 4) & 0x0f;
5591 #line 1268 "rx-decode.opc"
5592 int rdst AU = (op[3] >> 4) & 0x0f;
5593 if (trace)
5594 {
5595 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5596 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */",
5597 op[0], op[1], op[2], op[3]);
5598 printf (" rsrc = 0x%x,", rsrc);
5599 printf (" rdst = 0x%x\n", rdst);
5600 }
5601 SYNTAX("dtou %1, %0");
5602 #line 1268 "rx-decode.opc"
5603 ID(dtou); DDR(rdst); SDR(rsrc); F_____;
5604
5605 }
5606 break;
5607 case 0x0c:
5608 op_semantics_47:
5609 {
5610 /** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */
5611 #line 1262 "rx-decode.opc"
5612 int rsrc AU = (op[2] >> 4) & 0x0f;
5613 #line 1262 "rx-decode.opc"
5614 int rdst AU = (op[3] >> 4) & 0x0f;
5615 if (trace)
5616 {
5617 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5618 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */",
5619 op[0], op[1], op[2], op[3]);
5620 printf (" rsrc = 0x%x,", rsrc);
5621 printf (" rdst = 0x%x\n", rdst);
5622 }
5623 SYNTAX("dtof %1, %0");
5624 #line 1262 "rx-decode.opc"
5625 ID(dtof); DDR(rdst); SDR(rsrc); F_____;
5626
5627 }
5628 break;
5629 case 0x0d:
5630 op_semantics_48:
5631 {
5632 /** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */
5633 #line 1253 "rx-decode.opc"
5634 int rsrc AU = (op[2] >> 4) & 0x0f;
5635 #line 1253 "rx-decode.opc"
5636 int rdst AU = (op[3] >> 4) & 0x0f;
5637 if (trace)
5638 {
5639 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5640 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */",
5641 op[0], op[1], op[2], op[3]);
5642 printf (" rsrc = 0x%x,", rsrc);
5643 printf (" rdst = 0x%x\n", rdst);
5644 }
5645 SYNTAX("dround %1, %0");
5646 #line 1253 "rx-decode.opc"
5647 ID(dround); DDR(rdst); SDR(rsrc); F_____;
5648
5649 }
5650 break;
5651 default: UNSUPPORTED(); break;
5652 }
5653 break;
5654 case 0x10:
5655 GETBYTE ();
5656 switch (op[3] & 0x00)
5657 {
5658 case 0x00:
5659 goto op_semantics_36;
5660 break;
5661 }
5662 break;
5663 case 0x11:
5664 GETBYTE ();
5665 switch (op[3] & 0x00)
5666 {
5667 case 0x00:
5668 goto op_semantics_37;
5669 break;
5670 }
5671 break;
5672 case 0x12:
5673 GETBYTE ();
5674 switch (op[3] & 0x00)
5675 {
5676 case 0x00:
5677 goto op_semantics_38;
5678 break;
5679 }
5680 break;
5681 case 0x15:
5682 GETBYTE ();
5683 switch (op[3] & 0x00)
5684 {
5685 case 0x00:
5686 goto op_semantics_39;
5687 break;
5688 }
5689 break;
5690 case 0x18:
5691 GETBYTE ();
5692 switch (op[3] & 0x00)
5693 {
5694 case 0x00:
5695 goto op_semantics_40;
5696 break;
5697 }
5698 break;
5699 case 0x1c:
5700 GETBYTE ();
5701 switch (op[3] & 0x0f)
5702 {
5703 case 0x00:
5704 goto op_semantics_41;
5705 break;
5706 case 0x01:
5707 goto op_semantics_42;
5708 break;
5709 case 0x02:
5710 goto op_semantics_43;
5711 break;
5712 default: UNSUPPORTED(); break;
5713 }
5714 break;
5715 case 0x1d:
5716 GETBYTE ();
5717 switch (op[3] & 0x0f)
5718 {
5719 case 0x00:
5720 goto op_semantics_44;
5721 break;
5722 case 0x08:
5723 goto op_semantics_45;
5724 break;
5725 case 0x09:
5726 goto op_semantics_46;
5727 break;
5728 case 0x0c:
5729 goto op_semantics_47;
5730 break;
5731 case 0x0d:
5732 goto op_semantics_48;
5733 break;
5734 default: UNSUPPORTED(); break;
5735 }
5736 break;
5737 case 0x20:
5738 GETBYTE ();
5739 switch (op[3] & 0x00)
5740 {
5741 case 0x00:
5742 goto op_semantics_36;
5743 break;
5744 }
5745 break;
5746 case 0x21:
5747 GETBYTE ();
5748 switch (op[3] & 0x00)
5749 {
5750 case 0x00:
5751 goto op_semantics_37;
5752 break;
5753 }
5754 break;
5755 case 0x22:
5756 GETBYTE ();
5757 switch (op[3] & 0x00)
5758 {
5759 case 0x00:
5760 goto op_semantics_38;
5761 break;
5762 }
5763 break;
5764 case 0x25:
5765 GETBYTE ();
5766 switch (op[3] & 0x00)
5767 {
5768 case 0x00:
5769 goto op_semantics_39;
5770 break;
5771 }
5772 break;
5773 case 0x28:
5774 GETBYTE ();
5775 switch (op[3] & 0x00)
5776 {
5777 case 0x00:
5778 goto op_semantics_40;
5779 break;
5780 }
5781 break;
5782 case 0x2c:
5783 GETBYTE ();
5784 switch (op[3] & 0x0f)
5785 {
5786 case 0x00:
5787 goto op_semantics_41;
5788 break;
5789 case 0x01:
5790 goto op_semantics_42;
5791 break;
5792 case 0x02:
5793 goto op_semantics_43;
5794 break;
5795 default: UNSUPPORTED(); break;
5796 }
5797 break;
5798 case 0x2d:
5799 GETBYTE ();
5800 switch (op[3] & 0x0f)
5801 {
5802 case 0x00:
5803 goto op_semantics_44;
5804 break;
5805 case 0x08:
5806 goto op_semantics_45;
5807 break;
5808 case 0x09:
5809 goto op_semantics_46;
5810 break;
5811 case 0x0c:
5812 goto op_semantics_47;
5813 break;
5814 case 0x0d:
5815 goto op_semantics_48;
5816 break;
5817 default: UNSUPPORTED(); break;
5818 }
5819 break;
5820 case 0x30:
5821 GETBYTE ();
5822 switch (op[3] & 0x00)
5823 {
5824 case 0x00:
5825 goto op_semantics_36;
5826 break;
5827 }
5828 break;
5829 case 0x31:
5830 GETBYTE ();
5831 switch (op[3] & 0x00)
5832 {
5833 case 0x00:
5834 goto op_semantics_37;
5835 break;
5836 }
5837 break;
5838 case 0x32:
5839 GETBYTE ();
5840 switch (op[3] & 0x00)
5841 {
5842 case 0x00:
5843 goto op_semantics_38;
5844 break;
5845 }
5846 break;
5847 case 0x35:
5848 GETBYTE ();
5849 switch (op[3] & 0x00)
5850 {
5851 case 0x00:
5852 goto op_semantics_39;
5853 break;
5854 }
5855 break;
5856 case 0x38:
5857 GETBYTE ();
5858 switch (op[3] & 0x00)
5859 {
5860 case 0x00:
5861 goto op_semantics_40;
5862 break;
5863 }
5864 break;
5865 case 0x3c:
5866 GETBYTE ();
5867 switch (op[3] & 0x0f)
5868 {
5869 case 0x00:
5870 goto op_semantics_41;
5871 break;
5872 case 0x01:
5873 goto op_semantics_42;
5874 break;
5875 case 0x02:
5876 goto op_semantics_43;
5877 break;
5878 default: UNSUPPORTED(); break;
5879 }
5880 break;
5881 case 0x3d:
5882 GETBYTE ();
5883 switch (op[3] & 0x0f)
5884 {
5885 case 0x00:
5886 goto op_semantics_44;
5887 break;
5888 case 0x08:
5889 goto op_semantics_45;
5890 break;
5891 case 0x09:
5892 goto op_semantics_46;
5893 break;
5894 case 0x0c:
5895 goto op_semantics_47;
5896 break;
5897 case 0x0d:
5898 goto op_semantics_48;
5899 break;
5900 default: UNSUPPORTED(); break;
5901 }
5902 break;
5903 case 0x40:
5904 GETBYTE ();
5905 switch (op[3] & 0x00)
5906 {
5907 case 0x00:
5908 goto op_semantics_36;
5909 break;
5910 }
5911 break;
5912 case 0x41:
5913 GETBYTE ();
5914 switch (op[3] & 0x00)
5915 {
5916 case 0x00:
5917 goto op_semantics_37;
5918 break;
5919 }
5920 break;
5921 case 0x42:
5922 GETBYTE ();
5923 switch (op[3] & 0x00)
5924 {
5925 case 0x00:
5926 goto op_semantics_38;
5927 break;
5928 }
5929 break;
5930 case 0x45:
5931 GETBYTE ();
5932 switch (op[3] & 0x00)
5933 {
5934 case 0x00:
5935 goto op_semantics_39;
5936 break;
5937 }
5938 break;
5939 case 0x48:
5940 GETBYTE ();
5941 switch (op[3] & 0x00)
5942 {
5943 case 0x00:
5944 goto op_semantics_40;
5945 break;
5946 }
5947 break;
5948 case 0x4c:
5949 GETBYTE ();
5950 switch (op[3] & 0x0f)
5951 {
5952 case 0x00:
5953 goto op_semantics_41;
5954 break;
5955 case 0x01:
5956 goto op_semantics_42;
5957 break;
5958 case 0x02:
5959 goto op_semantics_43;
5960 break;
5961 default: UNSUPPORTED(); break;
5962 }
5963 break;
5964 case 0x4d:
5965 GETBYTE ();
5966 switch (op[3] & 0x0f)
5967 {
5968 case 0x00:
5969 goto op_semantics_44;
5970 break;
5971 case 0x08:
5972 goto op_semantics_45;
5973 break;
5974 case 0x09:
5975 goto op_semantics_46;
5976 break;
5977 case 0x0c:
5978 goto op_semantics_47;
5979 break;
5980 case 0x0d:
5981 goto op_semantics_48;
5982 break;
5983 default: UNSUPPORTED(); break;
5984 }
5985 break;
5986 case 0x50:
5987 GETBYTE ();
5988 switch (op[3] & 0x00)
5989 {
5990 case 0x00:
5991 goto op_semantics_36;
5992 break;
5993 }
5994 break;
5995 case 0x51:
5996 GETBYTE ();
5997 switch (op[3] & 0x00)
5998 {
5999 case 0x00:
6000 goto op_semantics_37;
6001 break;
6002 }
6003 break;
6004 case 0x52:
6005 GETBYTE ();
6006 switch (op[3] & 0x00)
6007 {
6008 case 0x00:
6009 goto op_semantics_38;
6010 break;
6011 }
6012 break;
6013 case 0x55:
6014 GETBYTE ();
6015 switch (op[3] & 0x00)
6016 {
6017 case 0x00:
6018 goto op_semantics_39;
6019 break;
6020 }
6021 break;
6022 case 0x58:
6023 GETBYTE ();
6024 switch (op[3] & 0x00)
6025 {
6026 case 0x00:
6027 goto op_semantics_40;
6028 break;
6029 }
6030 break;
6031 case 0x5c:
6032 GETBYTE ();
6033 switch (op[3] & 0x0f)
6034 {
6035 case 0x00:
6036 goto op_semantics_41;
6037 break;
6038 case 0x01:
6039 goto op_semantics_42;
6040 break;
6041 case 0x02:
6042 goto op_semantics_43;
6043 break;
6044 default: UNSUPPORTED(); break;
6045 }
6046 break;
6047 case 0x5d:
6048 GETBYTE ();
6049 switch (op[3] & 0x0f)
6050 {
6051 case 0x00:
6052 goto op_semantics_44;
6053 break;
6054 case 0x08:
6055 goto op_semantics_45;
6056 break;
6057 case 0x09:
6058 goto op_semantics_46;
6059 break;
6060 case 0x0c:
6061 goto op_semantics_47;
6062 break;
6063 case 0x0d:
6064 goto op_semantics_48;
6065 break;
6066 default: UNSUPPORTED(); break;
6067 }
6068 break;
6069 case 0x60:
6070 GETBYTE ();
6071 switch (op[3] & 0x00)
6072 {
6073 case 0x00:
6074 goto op_semantics_36;
6075 break;
6076 }
6077 break;
6078 case 0x61:
6079 GETBYTE ();
6080 switch (op[3] & 0x00)
6081 {
6082 case 0x00:
6083 goto op_semantics_37;
6084 break;
6085 }
6086 break;
6087 case 0x62:
6088 GETBYTE ();
6089 switch (op[3] & 0x00)
6090 {
6091 case 0x00:
6092 goto op_semantics_38;
6093 break;
6094 }
6095 break;
6096 case 0x65:
6097 GETBYTE ();
6098 switch (op[3] & 0x00)
6099 {
6100 case 0x00:
6101 goto op_semantics_39;
6102 break;
6103 }
6104 break;
6105 case 0x68:
6106 GETBYTE ();
6107 switch (op[3] & 0x00)
6108 {
6109 case 0x00:
6110 goto op_semantics_40;
6111 break;
6112 }
6113 break;
6114 case 0x6c:
6115 GETBYTE ();
6116 switch (op[3] & 0x0f)
6117 {
6118 case 0x00:
6119 goto op_semantics_41;
6120 break;
6121 case 0x01:
6122 goto op_semantics_42;
6123 break;
6124 case 0x02:
6125 goto op_semantics_43;
6126 break;
6127 default: UNSUPPORTED(); break;
6128 }
6129 break;
6130 case 0x6d:
6131 GETBYTE ();
6132 switch (op[3] & 0x0f)
6133 {
6134 case 0x00:
6135 goto op_semantics_44;
6136 break;
6137 case 0x08:
6138 goto op_semantics_45;
6139 break;
6140 case 0x09:
6141 goto op_semantics_46;
6142 break;
6143 case 0x0c:
6144 goto op_semantics_47;
6145 break;
6146 case 0x0d:
6147 goto op_semantics_48;
6148 break;
6149 default: UNSUPPORTED(); break;
6150 }
6151 break;
6152 case 0x70:
6153 GETBYTE ();
6154 switch (op[3] & 0x00)
6155 {
6156 case 0x00:
6157 goto op_semantics_36;
6158 break;
6159 }
6160 break;
6161 case 0x71:
6162 GETBYTE ();
6163 switch (op[3] & 0x00)
6164 {
6165 case 0x00:
6166 goto op_semantics_37;
6167 break;
6168 }
6169 break;
6170 case 0x72:
6171 GETBYTE ();
6172 switch (op[3] & 0x00)
6173 {
6174 case 0x00:
6175 goto op_semantics_38;
6176 break;
6177 }
6178 break;
6179 case 0x75:
6180 GETBYTE ();
6181 switch (op[3] & 0x00)
6182 {
6183 case 0x00:
6184 goto op_semantics_39;
6185 break;
6186 }
6187 break;
6188 case 0x78:
6189 GETBYTE ();
6190 switch (op[3] & 0x00)
6191 {
6192 case 0x00:
6193 goto op_semantics_40;
6194 break;
6195 }
6196 break;
6197 case 0x7c:
6198 GETBYTE ();
6199 switch (op[3] & 0x0f)
6200 {
6201 case 0x00:
6202 goto op_semantics_41;
6203 break;
6204 case 0x01:
6205 goto op_semantics_42;
6206 break;
6207 case 0x02:
6208 goto op_semantics_43;
6209 break;
6210 default: UNSUPPORTED(); break;
6211 }
6212 break;
6213 case 0x7d:
6214 GETBYTE ();
6215 switch (op[3] & 0x0f)
6216 {
6217 case 0x00:
6218 goto op_semantics_44;
6219 break;
6220 case 0x08:
6221 goto op_semantics_45;
6222 break;
6223 case 0x09:
6224 goto op_semantics_46;
6225 break;
6226 case 0x0c:
6227 goto op_semantics_47;
6228 break;
6229 case 0x0d:
6230 goto op_semantics_48;
6231 break;
6232 default: UNSUPPORTED(); break;
6233 }
6234 break;
6235 case 0x80:
6236 GETBYTE ();
6237 switch (op[3] & 0x00)
6238 {
6239 case 0x00:
6240 goto op_semantics_36;
6241 break;
6242 }
6243 break;
6244 case 0x81:
6245 GETBYTE ();
6246 switch (op[3] & 0x00)
6247 {
6248 case 0x00:
6249 goto op_semantics_37;
6250 break;
6251 }
6252 break;
6253 case 0x82:
6254 GETBYTE ();
6255 switch (op[3] & 0x00)
6256 {
6257 case 0x00:
6258 goto op_semantics_38;
6259 break;
6260 }
6261 break;
6262 case 0x85:
6263 GETBYTE ();
6264 switch (op[3] & 0x00)
6265 {
6266 case 0x00:
6267 goto op_semantics_39;
6268 break;
6269 }
6270 break;
6271 case 0x88:
6272 GETBYTE ();
6273 switch (op[3] & 0x00)
6274 {
6275 case 0x00:
6276 goto op_semantics_40;
6277 break;
6278 }
6279 break;
6280 case 0x8c:
6281 GETBYTE ();
6282 switch (op[3] & 0x0f)
6283 {
6284 case 0x00:
6285 goto op_semantics_41;
6286 break;
6287 case 0x01:
6288 goto op_semantics_42;
6289 break;
6290 case 0x02:
6291 goto op_semantics_43;
6292 break;
6293 default: UNSUPPORTED(); break;
6294 }
6295 break;
6296 case 0x8d:
6297 GETBYTE ();
6298 switch (op[3] & 0x0f)
6299 {
6300 case 0x00:
6301 goto op_semantics_44;
6302 break;
6303 case 0x08:
6304 goto op_semantics_45;
6305 break;
6306 case 0x09:
6307 goto op_semantics_46;
6308 break;
6309 case 0x0c:
6310 goto op_semantics_47;
6311 break;
6312 case 0x0d:
6313 goto op_semantics_48;
6314 break;
6315 default: UNSUPPORTED(); break;
6316 }
6317 break;
6318 case 0x90:
6319 GETBYTE ();
6320 switch (op[3] & 0x00)
6321 {
6322 case 0x00:
6323 goto op_semantics_36;
6324 break;
6325 }
6326 break;
6327 case 0x91:
6328 GETBYTE ();
6329 switch (op[3] & 0x00)
6330 {
6331 case 0x00:
6332 goto op_semantics_37;
6333 break;
6334 }
6335 break;
6336 case 0x92:
6337 GETBYTE ();
6338 switch (op[3] & 0x00)
6339 {
6340 case 0x00:
6341 goto op_semantics_38;
6342 break;
6343 }
6344 break;
6345 case 0x95:
6346 GETBYTE ();
6347 switch (op[3] & 0x00)
6348 {
6349 case 0x00:
6350 goto op_semantics_39;
6351 break;
6352 }
6353 break;
6354 case 0x98:
6355 GETBYTE ();
6356 switch (op[3] & 0x00)
6357 {
6358 case 0x00:
6359 goto op_semantics_40;
6360 break;
6361 }
6362 break;
6363 case 0x9c:
6364 GETBYTE ();
6365 switch (op[3] & 0x0f)
6366 {
6367 case 0x00:
6368 goto op_semantics_41;
6369 break;
6370 case 0x01:
6371 goto op_semantics_42;
6372 break;
6373 case 0x02:
6374 goto op_semantics_43;
6375 break;
6376 default: UNSUPPORTED(); break;
6377 }
6378 break;
6379 case 0x9d:
6380 GETBYTE ();
6381 switch (op[3] & 0x0f)
6382 {
6383 case 0x00:
6384 goto op_semantics_44;
6385 break;
6386 case 0x08:
6387 goto op_semantics_45;
6388 break;
6389 case 0x09:
6390 goto op_semantics_46;
6391 break;
6392 case 0x0c:
6393 goto op_semantics_47;
6394 break;
6395 case 0x0d:
6396 goto op_semantics_48;
6397 break;
6398 default: UNSUPPORTED(); break;
6399 }
6400 break;
6401 case 0xa0:
6402 GETBYTE ();
6403 switch (op[3] & 0x00)
6404 {
6405 case 0x00:
6406 goto op_semantics_36;
6407 break;
6408 }
6409 break;
6410 case 0xa1:
6411 GETBYTE ();
6412 switch (op[3] & 0x00)
6413 {
6414 case 0x00:
6415 goto op_semantics_37;
6416 break;
6417 }
6418 break;
6419 case 0xa2:
6420 GETBYTE ();
6421 switch (op[3] & 0x00)
6422 {
6423 case 0x00:
6424 goto op_semantics_38;
6425 break;
6426 }
6427 break;
6428 case 0xa5:
6429 GETBYTE ();
6430 switch (op[3] & 0x00)
6431 {
6432 case 0x00:
6433 goto op_semantics_39;
6434 break;
6435 }
6436 break;
6437 case 0xa8:
6438 GETBYTE ();
6439 switch (op[3] & 0x00)
6440 {
6441 case 0x00:
6442 goto op_semantics_40;
6443 break;
6444 }
6445 break;
6446 case 0xac:
6447 GETBYTE ();
6448 switch (op[3] & 0x0f)
6449 {
6450 case 0x00:
6451 goto op_semantics_41;
6452 break;
6453 case 0x01:
6454 goto op_semantics_42;
6455 break;
6456 case 0x02:
6457 goto op_semantics_43;
6458 break;
6459 default: UNSUPPORTED(); break;
6460 }
6461 break;
6462 case 0xad:
6463 GETBYTE ();
6464 switch (op[3] & 0x0f)
6465 {
6466 case 0x00:
6467 goto op_semantics_44;
6468 break;
6469 case 0x08:
6470 goto op_semantics_45;
6471 break;
6472 case 0x09:
6473 goto op_semantics_46;
6474 break;
6475 case 0x0c:
6476 goto op_semantics_47;
6477 break;
6478 case 0x0d:
6479 goto op_semantics_48;
6480 break;
6481 default: UNSUPPORTED(); break;
6482 }
6483 break;
6484 case 0xb0:
6485 GETBYTE ();
6486 switch (op[3] & 0x00)
6487 {
6488 case 0x00:
6489 goto op_semantics_36;
6490 break;
6491 }
6492 break;
6493 case 0xb1:
6494 GETBYTE ();
6495 switch (op[3] & 0x00)
6496 {
6497 case 0x00:
6498 goto op_semantics_37;
6499 break;
6500 }
6501 break;
6502 case 0xb2:
6503 GETBYTE ();
6504 switch (op[3] & 0x00)
6505 {
6506 case 0x00:
6507 goto op_semantics_38;
6508 break;
6509 }
6510 break;
6511 case 0xb5:
6512 GETBYTE ();
6513 switch (op[3] & 0x00)
6514 {
6515 case 0x00:
6516 goto op_semantics_39;
6517 break;
6518 }
6519 break;
6520 case 0xb8:
6521 GETBYTE ();
6522 switch (op[3] & 0x00)
6523 {
6524 case 0x00:
6525 goto op_semantics_40;
6526 break;
6527 }
6528 break;
6529 case 0xbc:
6530 GETBYTE ();
6531 switch (op[3] & 0x0f)
6532 {
6533 case 0x00:
6534 goto op_semantics_41;
6535 break;
6536 case 0x01:
6537 goto op_semantics_42;
6538 break;
6539 case 0x02:
6540 goto op_semantics_43;
6541 break;
6542 default: UNSUPPORTED(); break;
6543 }
6544 break;
6545 case 0xbd:
6546 GETBYTE ();
6547 switch (op[3] & 0x0f)
6548 {
6549 case 0x00:
6550 goto op_semantics_44;
6551 break;
6552 case 0x08:
6553 goto op_semantics_45;
6554 break;
6555 case 0x09:
6556 goto op_semantics_46;
6557 break;
6558 case 0x0c:
6559 goto op_semantics_47;
6560 break;
6561 case 0x0d:
6562 goto op_semantics_48;
6563 break;
6564 default: UNSUPPORTED(); break;
6565 }
6566 break;
6567 case 0xc0:
6568 GETBYTE ();
6569 switch (op[3] & 0x00)
6570 {
6571 case 0x00:
6572 goto op_semantics_36;
6573 break;
6574 }
6575 break;
6576 case 0xc1:
6577 GETBYTE ();
6578 switch (op[3] & 0x00)
6579 {
6580 case 0x00:
6581 goto op_semantics_37;
6582 break;
6583 }
6584 break;
6585 case 0xc2:
6586 GETBYTE ();
6587 switch (op[3] & 0x00)
6588 {
6589 case 0x00:
6590 goto op_semantics_38;
6591 break;
6592 }
6593 break;
6594 case 0xc5:
6595 GETBYTE ();
6596 switch (op[3] & 0x00)
6597 {
6598 case 0x00:
6599 goto op_semantics_39;
6600 break;
6601 }
6602 break;
6603 case 0xc8:
6604 GETBYTE ();
6605 switch (op[3] & 0x00)
6606 {
6607 case 0x00:
6608 goto op_semantics_40;
6609 break;
6610 }
6611 break;
6612 case 0xcc:
6613 GETBYTE ();
6614 switch (op[3] & 0x0f)
6615 {
6616 case 0x00:
6617 goto op_semantics_41;
6618 break;
6619 case 0x01:
6620 goto op_semantics_42;
6621 break;
6622 case 0x02:
6623 goto op_semantics_43;
6624 break;
6625 default: UNSUPPORTED(); break;
6626 }
6627 break;
6628 case 0xcd:
6629 GETBYTE ();
6630 switch (op[3] & 0x0f)
6631 {
6632 case 0x00:
6633 goto op_semantics_44;
6634 break;
6635 case 0x08:
6636 goto op_semantics_45;
6637 break;
6638 case 0x09:
6639 goto op_semantics_46;
6640 break;
6641 case 0x0c:
6642 goto op_semantics_47;
6643 break;
6644 case 0x0d:
6645 goto op_semantics_48;
6646 break;
6647 default: UNSUPPORTED(); break;
6648 }
6649 break;
6650 case 0xd0:
6651 GETBYTE ();
6652 switch (op[3] & 0x00)
6653 {
6654 case 0x00:
6655 goto op_semantics_36;
6656 break;
6657 }
6658 break;
6659 case 0xd1:
6660 GETBYTE ();
6661 switch (op[3] & 0x00)
6662 {
6663 case 0x00:
6664 goto op_semantics_37;
6665 break;
6666 }
6667 break;
6668 case 0xd2:
6669 GETBYTE ();
6670 switch (op[3] & 0x00)
6671 {
6672 case 0x00:
6673 goto op_semantics_38;
6674 break;
6675 }
6676 break;
6677 case 0xd5:
6678 GETBYTE ();
6679 switch (op[3] & 0x00)
6680 {
6681 case 0x00:
6682 goto op_semantics_39;
6683 break;
6684 }
6685 break;
6686 case 0xd8:
6687 GETBYTE ();
6688 switch (op[3] & 0x00)
6689 {
6690 case 0x00:
6691 goto op_semantics_40;
6692 break;
6693 }
6694 break;
6695 case 0xdc:
6696 GETBYTE ();
6697 switch (op[3] & 0x0f)
6698 {
6699 case 0x00:
6700 goto op_semantics_41;
6701 break;
6702 case 0x01:
6703 goto op_semantics_42;
6704 break;
6705 case 0x02:
6706 goto op_semantics_43;
6707 break;
6708 default: UNSUPPORTED(); break;
6709 }
6710 break;
6711 case 0xdd:
6712 GETBYTE ();
6713 switch (op[3] & 0x0f)
6714 {
6715 case 0x00:
6716 goto op_semantics_44;
6717 break;
6718 case 0x08:
6719 goto op_semantics_45;
6720 break;
6721 case 0x09:
6722 goto op_semantics_46;
6723 break;
6724 case 0x0c:
6725 goto op_semantics_47;
6726 break;
6727 case 0x0d:
6728 goto op_semantics_48;
6729 break;
6730 default: UNSUPPORTED(); break;
6731 }
6732 break;
6733 case 0xe0:
6734 GETBYTE ();
6735 switch (op[3] & 0x00)
6736 {
6737 case 0x00:
6738 goto op_semantics_36;
6739 break;
6740 }
6741 break;
6742 case 0xe1:
6743 GETBYTE ();
6744 switch (op[3] & 0x00)
6745 {
6746 case 0x00:
6747 goto op_semantics_37;
6748 break;
6749 }
6750 break;
6751 case 0xe2:
6752 GETBYTE ();
6753 switch (op[3] & 0x00)
6754 {
6755 case 0x00:
6756 goto op_semantics_38;
6757 break;
6758 }
6759 break;
6760 case 0xe5:
6761 GETBYTE ();
6762 switch (op[3] & 0x00)
6763 {
6764 case 0x00:
6765 goto op_semantics_39;
6766 break;
6767 }
6768 break;
6769 case 0xe8:
6770 GETBYTE ();
6771 switch (op[3] & 0x00)
6772 {
6773 case 0x00:
6774 goto op_semantics_40;
6775 break;
6776 }
6777 break;
6778 case 0xec:
6779 GETBYTE ();
6780 switch (op[3] & 0x0f)
6781 {
6782 case 0x00:
6783 goto op_semantics_41;
6784 break;
6785 case 0x01:
6786 goto op_semantics_42;
6787 break;
6788 case 0x02:
6789 goto op_semantics_43;
6790 break;
6791 default: UNSUPPORTED(); break;
6792 }
6793 break;
6794 case 0xed:
6795 GETBYTE ();
6796 switch (op[3] & 0x0f)
6797 {
6798 case 0x00:
6799 goto op_semantics_44;
6800 break;
6801 case 0x08:
6802 goto op_semantics_45;
6803 break;
6804 case 0x09:
6805 goto op_semantics_46;
6806 break;
6807 case 0x0c:
6808 goto op_semantics_47;
6809 break;
6810 case 0x0d:
6811 goto op_semantics_48;
6812 break;
6813 default: UNSUPPORTED(); break;
6814 }
6815 break;
6816 case 0xf0:
6817 GETBYTE ();
6818 switch (op[3] & 0x00)
6819 {
6820 case 0x00:
6821 goto op_semantics_36;
6822 break;
6823 }
6824 break;
6825 case 0xf1:
6826 GETBYTE ();
6827 switch (op[3] & 0x00)
6828 {
6829 case 0x00:
6830 goto op_semantics_37;
6831 break;
6832 }
6833 break;
6834 case 0xf2:
6835 GETBYTE ();
6836 switch (op[3] & 0x00)
6837 {
6838 case 0x00:
6839 goto op_semantics_38;
6840 break;
6841 }
6842 break;
6843 case 0xf5:
6844 GETBYTE ();
6845 switch (op[3] & 0x00)
6846 {
6847 case 0x00:
6848 goto op_semantics_39;
6849 break;
6850 }
6851 break;
6852 case 0xf8:
6853 GETBYTE ();
6854 switch (op[3] & 0x00)
6855 {
6856 case 0x00:
6857 goto op_semantics_40;
6858 break;
6859 }
6860 break;
6861 case 0xfc:
6862 GETBYTE ();
6863 switch (op[3] & 0x0f)
6864 {
6865 case 0x00:
6866 goto op_semantics_41;
6867 break;
6868 case 0x01:
6869 goto op_semantics_42;
6870 break;
6871 case 0x02:
6872 goto op_semantics_43;
6873 break;
6874 default: UNSUPPORTED(); break;
6875 }
6876 break;
6877 case 0xfd:
6878 GETBYTE ();
6879 switch (op[3] & 0x0f)
6880 {
6881 case 0x00:
6882 goto op_semantics_44;
6883 break;
6884 case 0x08:
6885 goto op_semantics_45;
6886 break;
6887 case 0x09:
6888 goto op_semantics_46;
6889 break;
6890 case 0x0c:
6891 goto op_semantics_47;
6892 break;
6893 case 0x0d:
6894 goto op_semantics_48;
6895 break;
6896 default: UNSUPPORTED(); break;
6897 }
6898 break;
6899 default: UNSUPPORTED(); break;
6900 }
6901 break;
6902 default: UNSUPPORTED(); break;
6903 }
6904 break;
6905 case 0x77:
6906 GETBYTE ();
6907 switch (op[1] & 0xf0)
6908 {
6909 case 0x00:
6910 goto op_semantics_32;
6911 break;
6912 case 0x10:
6913 goto op_semantics_33;
6914 break;
6915 case 0x20:
6916 goto op_semantics_34;
6917 break;
6918 case 0x30:
6919 goto op_semantics_35;
6920 break;
6921 default: UNSUPPORTED(); break;
6922 }
6923 break;
6924 case 0x78:
6925 GETBYTE ();
6926 switch (op[1] & 0x00)
6927 {
6928 case 0x00:
6929 op_semantics_49:
6930 {
6931 /** 0111 100b ittt rdst bset #%1, %0 */
6932 #line 968 "rx-decode.opc"
6933 int b AU = op[0] & 0x01;
6934 #line 968 "rx-decode.opc"
6935 int ittt AU = (op[1] >> 4) & 0x0f;
6936 #line 968 "rx-decode.opc"
6937 int rdst AU = op[1] & 0x0f;
6938 if (trace)
6939 {
6940 printf ("\033[33m%s\033[0m %02x %02x\n",
6941 "/** 0111 100b ittt rdst bset #%1, %0 */",
6942 op[0], op[1]);
6943 printf (" b = 0x%x,", b);
6944 printf (" ittt = 0x%x,", ittt);
6945 printf (" rdst = 0x%x\n", rdst);
6946 }
6947 SYNTAX("bset #%1, %0");
6948 #line 968 "rx-decode.opc"
6949 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6950
6951
6952 }
6953 break;
6954 }
6955 break;
6956 case 0x79:
6957 GETBYTE ();
6958 switch (op[1] & 0x00)
6959 {
6960 case 0x00:
6961 goto op_semantics_49;
6962 break;
6963 }
6964 break;
6965 case 0x7a:
6966 GETBYTE ();
6967 switch (op[1] & 0x00)
6968 {
6969 case 0x00:
6970 op_semantics_50:
6971 {
6972 /** 0111 101b ittt rdst bclr #%1, %0 */
6973 #line 980 "rx-decode.opc"
6974 int b AU = op[0] & 0x01;
6975 #line 980 "rx-decode.opc"
6976 int ittt AU = (op[1] >> 4) & 0x0f;
6977 #line 980 "rx-decode.opc"
6978 int rdst AU = op[1] & 0x0f;
6979 if (trace)
6980 {
6981 printf ("\033[33m%s\033[0m %02x %02x\n",
6982 "/** 0111 101b ittt rdst bclr #%1, %0 */",
6983 op[0], op[1]);
6984 printf (" b = 0x%x,", b);
6985 printf (" ittt = 0x%x,", ittt);
6986 printf (" rdst = 0x%x\n", rdst);
6987 }
6988 SYNTAX("bclr #%1, %0");
6989 #line 980 "rx-decode.opc"
6990 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6991
6992
6993 }
6994 break;
6995 }
6996 break;
6997 case 0x7b:
6998 GETBYTE ();
6999 switch (op[1] & 0x00)
7000 {
7001 case 0x00:
7002 goto op_semantics_50;
7003 break;
7004 }
7005 break;
7006 case 0x7c:
7007 GETBYTE ();
7008 switch (op[1] & 0x00)
7009 {
7010 case 0x00:
7011 op_semantics_51:
7012 {
7013 /** 0111 110b ittt rdst btst #%2, %1 */
7014 #line 992 "rx-decode.opc"
7015 int b AU = op[0] & 0x01;
7016 #line 992 "rx-decode.opc"
7017 int ittt AU = (op[1] >> 4) & 0x0f;
7018 #line 992 "rx-decode.opc"
7019 int rdst AU = op[1] & 0x0f;
7020 if (trace)
7021 {
7022 printf ("\033[33m%s\033[0m %02x %02x\n",
7023 "/** 0111 110b ittt rdst btst #%2, %1 */",
7024 op[0], op[1]);
7025 printf (" b = 0x%x,", b);
7026 printf (" ittt = 0x%x,", ittt);
7027 printf (" rdst = 0x%x\n", rdst);
7028 }
7029 SYNTAX("btst #%2, %1");
7030 #line 992 "rx-decode.opc"
7031 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
7032
7033
7034 }
7035 break;
7036 }
7037 break;
7038 case 0x7d:
7039 GETBYTE ();
7040 switch (op[1] & 0x00)
7041 {
7042 case 0x00:
7043 goto op_semantics_51;
7044 break;
7045 }
7046 break;
7047 case 0x7e:
7048 GETBYTE ();
7049 switch (op[1] & 0xf0)
7050 {
7051 case 0x00:
7052 {
7053 /** 0111 1110 0000 rdst not %0 */
7054 #line 483 "rx-decode.opc"
7055 int rdst AU = op[1] & 0x0f;
7056 if (trace)
7057 {
7058 printf ("\033[33m%s\033[0m %02x %02x\n",
7059 "/** 0111 1110 0000 rdst not %0 */",
7060 op[0], op[1]);
7061 printf (" rdst = 0x%x\n", rdst);
7062 }
7063 SYNTAX("not %0");
7064 #line 483 "rx-decode.opc"
7065 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
7066
7067 }
7068 break;
7069 case 0x10:
7070 {
7071 /** 0111 1110 0001 rdst neg %0 */
7072 #line 504 "rx-decode.opc"
7073 int rdst AU = op[1] & 0x0f;
7074 if (trace)
7075 {
7076 printf ("\033[33m%s\033[0m %02x %02x\n",
7077 "/** 0111 1110 0001 rdst neg %0 */",
7078 op[0], op[1]);
7079 printf (" rdst = 0x%x\n", rdst);
7080 }
7081 SYNTAX("neg %0");
7082 #line 504 "rx-decode.opc"
7083 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
7084
7085 }
7086 break;
7087 case 0x20:
7088 {
7089 /** 0111 1110 0010 rdst abs %0 */
7090 #line 586 "rx-decode.opc"
7091 int rdst AU = op[1] & 0x0f;
7092 if (trace)
7093 {
7094 printf ("\033[33m%s\033[0m %02x %02x\n",
7095 "/** 0111 1110 0010 rdst abs %0 */",
7096 op[0], op[1]);
7097 printf (" rdst = 0x%x\n", rdst);
7098 }
7099 SYNTAX("abs %0");
7100 #line 586 "rx-decode.opc"
7101 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
7102
7103 }
7104 break;
7105 case 0x30:
7106 {
7107 /** 0111 1110 0011 rdst sat %0 */
7108 #line 906 "rx-decode.opc"
7109 int rdst AU = op[1] & 0x0f;
7110 if (trace)
7111 {
7112 printf ("\033[33m%s\033[0m %02x %02x\n",
7113 "/** 0111 1110 0011 rdst sat %0 */",
7114 op[0], op[1]);
7115 printf (" rdst = 0x%x\n", rdst);
7116 }
7117 SYNTAX("sat %0");
7118 #line 906 "rx-decode.opc"
7119 ID(sat); DR (rdst);
7120
7121 }
7122 break;
7123 case 0x40:
7124 {
7125 /** 0111 1110 0100 rdst rorc %0 */
7126 #line 766 "rx-decode.opc"
7127 int rdst AU = op[1] & 0x0f;
7128 if (trace)
7129 {
7130 printf ("\033[33m%s\033[0m %02x %02x\n",
7131 "/** 0111 1110 0100 rdst rorc %0 */",
7132 op[0], op[1]);
7133 printf (" rdst = 0x%x\n", rdst);
7134 }
7135 SYNTAX("rorc %0");
7136 #line 766 "rx-decode.opc"
7137 ID(rorc); DR(rdst); F__SZC;
7138
7139 }
7140 break;
7141 case 0x50:
7142 {
7143 /** 0111 1110 0101 rdst rolc %0 */
7144 #line 763 "rx-decode.opc"
7145 int rdst AU = op[1] & 0x0f;
7146 if (trace)
7147 {
7148 printf ("\033[33m%s\033[0m %02x %02x\n",
7149 "/** 0111 1110 0101 rdst rolc %0 */",
7150 op[0], op[1]);
7151 printf (" rdst = 0x%x\n", rdst);
7152 }
7153 SYNTAX("rolc %0");
7154 #line 763 "rx-decode.opc"
7155 ID(rolc); DR(rdst); F__SZC;
7156
7157 }
7158 break;
7159 case 0x80:
7160 case 0x90:
7161 case 0xa0:
7162 {
7163 /** 0111 1110 10sz rsrc push%s %1 */
7164 #line 399 "rx-decode.opc"
7165 int sz AU = (op[1] >> 4) & 0x03;
7166 #line 399 "rx-decode.opc"
7167 int rsrc AU = op[1] & 0x0f;
7168 if (trace)
7169 {
7170 printf ("\033[33m%s\033[0m %02x %02x\n",
7171 "/** 0111 1110 10sz rsrc push%s %1 */",
7172 op[0], op[1]);
7173 printf (" sz = 0x%x,", sz);
7174 printf (" rsrc = 0x%x\n", rsrc);
7175 }
7176 SYNTAX("push%s %1");
7177 #line 399 "rx-decode.opc"
7178 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7179
7180 }
7181 break;
7182 case 0xb0:
7183 {
7184 /** 0111 1110 1011 rdst pop %0 */
7185 #line 396 "rx-decode.opc"
7186 int rdst AU = op[1] & 0x0f;
7187 if (trace)
7188 {
7189 printf ("\033[33m%s\033[0m %02x %02x\n",
7190 "/** 0111 1110 1011 rdst pop %0 */",
7191 op[0], op[1]);
7192 printf (" rdst = 0x%x\n", rdst);
7193 }
7194 SYNTAX("pop %0");
7195 #line 396 "rx-decode.opc"
7196 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7197
7198 }
7199 break;
7200 case 0xc0:
7201 case 0xd0:
7202 {
7203 /** 0111 1110 110 crsrc pushc %1 */
7204 #line 1029 "rx-decode.opc"
7205 int crsrc AU = op[1] & 0x1f;
7206 if (trace)
7207 {
7208 printf ("\033[33m%s\033[0m %02x %02x\n",
7209 "/** 0111 1110 110 crsrc pushc %1 */",
7210 op[0], op[1]);
7211 printf (" crsrc = 0x%x\n", crsrc);
7212 }
7213 SYNTAX("pushc %1");
7214 #line 1029 "rx-decode.opc"
7215 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7216
7217 }
7218 break;
7219 case 0xe0:
7220 case 0xf0:
7221 {
7222 /** 0111 1110 111 crdst popc %0 */
7223 #line 1026 "rx-decode.opc"
7224 int crdst AU = op[1] & 0x1f;
7225 if (trace)
7226 {
7227 printf ("\033[33m%s\033[0m %02x %02x\n",
7228 "/** 0111 1110 111 crdst popc %0 */",
7229 op[0], op[1]);
7230 printf (" crdst = 0x%x\n", crdst);
7231 }
7232 SYNTAX("popc %0");
7233 #line 1026 "rx-decode.opc"
7234 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7235
7236 }
7237 break;
7238 default: UNSUPPORTED(); break;
7239 }
7240 break;
7241 case 0x7f:
7242 GETBYTE ();
7243 switch (op[1] & 0xff)
7244 {
7245 case 0x00:
7246 case 0x01:
7247 case 0x02:
7248 case 0x03:
7249 case 0x04:
7250 case 0x05:
7251 case 0x06:
7252 case 0x07:
7253 case 0x08:
7254 case 0x09:
7255 case 0x0a:
7256 case 0x0b:
7257 case 0x0c:
7258 case 0x0d:
7259 case 0x0e:
7260 case 0x0f:
7261 {
7262 /** 0111 1111 0000 rsrc jmp %0 */
7263 #line 816 "rx-decode.opc"
7264 int rsrc AU = op[1] & 0x0f;
7265 if (trace)
7266 {
7267 printf ("\033[33m%s\033[0m %02x %02x\n",
7268 "/** 0111 1111 0000 rsrc jmp %0 */",
7269 op[0], op[1]);
7270 printf (" rsrc = 0x%x\n", rsrc);
7271 }
7272 SYNTAX("jmp %0");
7273 #line 816 "rx-decode.opc"
7274 ID(branch); DR(rsrc);
7275
7276 }
7277 break;
7278 case 0x10:
7279 case 0x11:
7280 case 0x12:
7281 case 0x13:
7282 case 0x14:
7283 case 0x15:
7284 case 0x16:
7285 case 0x17:
7286 case 0x18:
7287 case 0x19:
7288 case 0x1a:
7289 case 0x1b:
7290 case 0x1c:
7291 case 0x1d:
7292 case 0x1e:
7293 case 0x1f:
7294 {
7295 /** 0111 1111 0001 rsrc jsr %0 */
7296 #line 819 "rx-decode.opc"
7297 int rsrc AU = op[1] & 0x0f;
7298 if (trace)
7299 {
7300 printf ("\033[33m%s\033[0m %02x %02x\n",
7301 "/** 0111 1111 0001 rsrc jsr %0 */",
7302 op[0], op[1]);
7303 printf (" rsrc = 0x%x\n", rsrc);
7304 }
7305 SYNTAX("jsr %0");
7306 #line 819 "rx-decode.opc"
7307 ID(jsr); DR(rsrc);
7308
7309 }
7310 break;
7311 case 0x40:
7312 case 0x41:
7313 case 0x42:
7314 case 0x43:
7315 case 0x44:
7316 case 0x45:
7317 case 0x46:
7318 case 0x47:
7319 case 0x48:
7320 case 0x49:
7321 case 0x4a:
7322 case 0x4b:
7323 case 0x4c:
7324 case 0x4d:
7325 case 0x4e:
7326 case 0x4f:
7327 {
7328 /** 0111 1111 0100 rsrc bra.l %0 */
7329 #line 812 "rx-decode.opc"
7330 int rsrc AU = op[1] & 0x0f;
7331 if (trace)
7332 {
7333 printf ("\033[33m%s\033[0m %02x %02x\n",
7334 "/** 0111 1111 0100 rsrc bra.l %0 */",
7335 op[0], op[1]);
7336 printf (" rsrc = 0x%x\n", rsrc);
7337 }
7338 SYNTAX("bra.l %0");
7339 #line 812 "rx-decode.opc"
7340 ID(branchrel); DR(rsrc);
7341
7342
7343 }
7344 break;
7345 case 0x50:
7346 case 0x51:
7347 case 0x52:
7348 case 0x53:
7349 case 0x54:
7350 case 0x55:
7351 case 0x56:
7352 case 0x57:
7353 case 0x58:
7354 case 0x59:
7355 case 0x5a:
7356 case 0x5b:
7357 case 0x5c:
7358 case 0x5d:
7359 case 0x5e:
7360 case 0x5f:
7361 {
7362 /** 0111 1111 0101 rsrc bsr.l %0 */
7363 #line 828 "rx-decode.opc"
7364 int rsrc AU = op[1] & 0x0f;
7365 if (trace)
7366 {
7367 printf ("\033[33m%s\033[0m %02x %02x\n",
7368 "/** 0111 1111 0101 rsrc bsr.l %0 */",
7369 op[0], op[1]);
7370 printf (" rsrc = 0x%x\n", rsrc);
7371 }
7372 SYNTAX("bsr.l %0");
7373 #line 828 "rx-decode.opc"
7374 ID(jsrrel); DR(rsrc);
7375
7376 }
7377 break;
7378 case 0x80:
7379 case 0x81:
7380 case 0x82:
7381 {
7382 /** 0111 1111 1000 00sz suntil%s */
7383 #line 852 "rx-decode.opc"
7384 int sz AU = op[1] & 0x03;
7385 if (trace)
7386 {
7387 printf ("\033[33m%s\033[0m %02x %02x\n",
7388 "/** 0111 1111 1000 00sz suntil%s */",
7389 op[0], op[1]);
7390 printf (" sz = 0x%x\n", sz);
7391 }
7392 SYNTAX("suntil%s");
7393 #line 852 "rx-decode.opc"
7394 ID(suntil); BWL(sz); F___ZC;
7395
7396 }
7397 break;
7398 case 0x83:
7399 {
7400 /** 0111 1111 1000 0011 scmpu */
7401 if (trace)
7402 {
7403 printf ("\033[33m%s\033[0m %02x %02x\n",
7404 "/** 0111 1111 1000 0011 scmpu */",
7405 op[0], op[1]);
7406 }
7407 SYNTAX("scmpu");
7408 #line 843 "rx-decode.opc"
7409 ID(scmpu); F___ZC;
7410
7411 }
7412 break;
7413 case 0x84:
7414 case 0x85:
7415 case 0x86:
7416 {
7417 /** 0111 1111 1000 01sz swhile%s */
7418 #line 855 "rx-decode.opc"
7419 int sz AU = op[1] & 0x03;
7420 if (trace)
7421 {
7422 printf ("\033[33m%s\033[0m %02x %02x\n",
7423 "/** 0111 1111 1000 01sz swhile%s */",
7424 op[0], op[1]);
7425 printf (" sz = 0x%x\n", sz);
7426 }
7427 SYNTAX("swhile%s");
7428 #line 855 "rx-decode.opc"
7429 ID(swhile); BWL(sz); F___ZC;
7430
7431 }
7432 break;
7433 case 0x87:
7434 {
7435 /** 0111 1111 1000 0111 smovu */
7436 if (trace)
7437 {
7438 printf ("\033[33m%s\033[0m %02x %02x\n",
7439 "/** 0111 1111 1000 0111 smovu */",
7440 op[0], op[1]);
7441 }
7442 SYNTAX("smovu");
7443 #line 846 "rx-decode.opc"
7444 ID(smovu);
7445
7446 }
7447 break;
7448 case 0x88:
7449 case 0x89:
7450 case 0x8a:
7451 {
7452 /** 0111 1111 1000 10sz sstr%s */
7453 #line 861 "rx-decode.opc"
7454 int sz AU = op[1] & 0x03;
7455 if (trace)
7456 {
7457 printf ("\033[33m%s\033[0m %02x %02x\n",
7458 "/** 0111 1111 1000 10sz sstr%s */",
7459 op[0], op[1]);
7460 printf (" sz = 0x%x\n", sz);
7461 }
7462 SYNTAX("sstr%s");
7463 #line 861 "rx-decode.opc"
7464 ID(sstr); BWL(sz);
7465
7466 /*----------------------------------------------------------------------*/
7467 /* RMPA */
7468
7469 }
7470 break;
7471 case 0x8b:
7472 {
7473 /** 0111 1111 1000 1011 smovb */
7474 if (trace)
7475 {
7476 printf ("\033[33m%s\033[0m %02x %02x\n",
7477 "/** 0111 1111 1000 1011 smovb */",
7478 op[0], op[1]);
7479 }
7480 SYNTAX("smovb");
7481 #line 849 "rx-decode.opc"
7482 ID(smovb);
7483
7484 }
7485 break;
7486 case 0x8c:
7487 case 0x8d:
7488 case 0x8e:
7489 {
7490 /** 0111 1111 1000 11sz rmpa%s */
7491 #line 867 "rx-decode.opc"
7492 int sz AU = op[1] & 0x03;
7493 if (trace)
7494 {
7495 printf ("\033[33m%s\033[0m %02x %02x\n",
7496 "/** 0111 1111 1000 11sz rmpa%s */",
7497 op[0], op[1]);
7498 printf (" sz = 0x%x\n", sz);
7499 }
7500 SYNTAX("rmpa%s");
7501 #line 867 "rx-decode.opc"
7502 ID(rmpa); BWL(sz); F_OS__;
7503
7504 /*----------------------------------------------------------------------*/
7505 /* HI/LO stuff */
7506
7507 }
7508 break;
7509 case 0x8f:
7510 {
7511 /** 0111 1111 1000 1111 smovf */
7512 if (trace)
7513 {
7514 printf ("\033[33m%s\033[0m %02x %02x\n",
7515 "/** 0111 1111 1000 1111 smovf */",
7516 op[0], op[1]);
7517 }
7518 SYNTAX("smovf");
7519 #line 858 "rx-decode.opc"
7520 ID(smovf);
7521
7522 }
7523 break;
7524 case 0x93:
7525 {
7526 /** 0111 1111 1001 0011 satr */
7527 if (trace)
7528 {
7529 printf ("\033[33m%s\033[0m %02x %02x\n",
7530 "/** 0111 1111 1001 0011 satr */",
7531 op[0], op[1]);
7532 }
7533 SYNTAX("satr");
7534 #line 909 "rx-decode.opc"
7535 ID(satr);
7536
7537 /*----------------------------------------------------------------------*/
7538 /* FLOAT */
7539
7540 }
7541 break;
7542 case 0x94:
7543 {
7544 /** 0111 1111 1001 0100 rtfi */
7545 if (trace)
7546 {
7547 printf ("\033[33m%s\033[0m %02x %02x\n",
7548 "/** 0111 1111 1001 0100 rtfi */",
7549 op[0], op[1]);
7550 }
7551 SYNTAX("rtfi");
7552 #line 1044 "rx-decode.opc"
7553 ID(rtfi);
7554
7555 }
7556 break;
7557 case 0x95:
7558 {
7559 /** 0111 1111 1001 0101 rte */
7560 if (trace)
7561 {
7562 printf ("\033[33m%s\033[0m %02x %02x\n",
7563 "/** 0111 1111 1001 0101 rte */",
7564 op[0], op[1]);
7565 }
7566 SYNTAX("rte");
7567 #line 1047 "rx-decode.opc"
7568 ID(rte);
7569
7570 }
7571 break;
7572 case 0x96:
7573 {
7574 /** 0111 1111 1001 0110 wait */
7575 if (trace)
7576 {
7577 printf ("\033[33m%s\033[0m %02x %02x\n",
7578 "/** 0111 1111 1001 0110 wait */",
7579 op[0], op[1]);
7580 }
7581 SYNTAX("wait");
7582 #line 1059 "rx-decode.opc"
7583 ID(wait);
7584
7585 /*----------------------------------------------------------------------*/
7586 /* SCcnd */
7587
7588 }
7589 break;
7590 case 0xa0:
7591 case 0xa1:
7592 case 0xa2:
7593 case 0xa3:
7594 case 0xa4:
7595 case 0xa5:
7596 case 0xa6:
7597 case 0xa7:
7598 case 0xa8:
7599 case 0xa9:
7600 case 0xaa:
7601 case 0xab:
7602 case 0xac:
7603 case 0xad:
7604 case 0xae:
7605 case 0xaf:
7606 {
7607 /** 0111 1111 1010 rdst setpsw %0 */
7608 #line 1020 "rx-decode.opc"
7609 int rdst AU = op[1] & 0x0f;
7610 if (trace)
7611 {
7612 printf ("\033[33m%s\033[0m %02x %02x\n",
7613 "/** 0111 1111 1010 rdst setpsw %0 */",
7614 op[0], op[1]);
7615 printf (" rdst = 0x%x\n", rdst);
7616 }
7617 SYNTAX("setpsw %0");
7618 #line 1020 "rx-decode.opc"
7619 ID(setpsw); DF(rdst);
7620
7621 }
7622 break;
7623 case 0xb0:
7624 case 0xb1:
7625 case 0xb2:
7626 case 0xb3:
7627 case 0xb4:
7628 case 0xb5:
7629 case 0xb6:
7630 case 0xb7:
7631 case 0xb8:
7632 case 0xb9:
7633 case 0xba:
7634 case 0xbb:
7635 case 0xbc:
7636 case 0xbd:
7637 case 0xbe:
7638 case 0xbf:
7639 {
7640 /** 0111 1111 1011 rdst clrpsw %0 */
7641 #line 1017 "rx-decode.opc"
7642 int rdst AU = op[1] & 0x0f;
7643 if (trace)
7644 {
7645 printf ("\033[33m%s\033[0m %02x %02x\n",
7646 "/** 0111 1111 1011 rdst clrpsw %0 */",
7647 op[0], op[1]);
7648 printf (" rdst = 0x%x\n", rdst);
7649 }
7650 SYNTAX("clrpsw %0");
7651 #line 1017 "rx-decode.opc"
7652 ID(clrpsw); DF(rdst);
7653
7654 }
7655 break;
7656 default: UNSUPPORTED(); break;
7657 }
7658 break;
7659 case 0x80:
7660 GETBYTE ();
7661 switch (op[1] & 0x00)
7662 {
7663 case 0x00:
7664 op_semantics_52:
7665 {
7666 /** 10sz 0dsp a dst b src mov%s %1, %0 */
7667 #line 357 "rx-decode.opc"
7668 int sz AU = (op[0] >> 4) & 0x03;
7669 #line 357 "rx-decode.opc"
7670 int dsp AU = op[0] & 0x07;
7671 #line 357 "rx-decode.opc"
7672 int a AU = (op[1] >> 7) & 0x01;
7673 #line 357 "rx-decode.opc"
7674 int dst AU = (op[1] >> 4) & 0x07;
7675 #line 357 "rx-decode.opc"
7676 int b AU = (op[1] >> 3) & 0x01;
7677 #line 357 "rx-decode.opc"
7678 int src AU = op[1] & 0x07;
7679 if (trace)
7680 {
7681 printf ("\033[33m%s\033[0m %02x %02x\n",
7682 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
7683 op[0], op[1]);
7684 printf (" sz = 0x%x,", sz);
7685 printf (" dsp = 0x%x,", dsp);
7686 printf (" a = 0x%x,", a);
7687 printf (" dst = 0x%x,", dst);
7688 printf (" b = 0x%x,", b);
7689 printf (" src = 0x%x\n", src);
7690 }
7691 SYNTAX("mov%s %1, %0");
7692 #line 357 "rx-decode.opc"
7693 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
7694
7695 }
7696 break;
7697 }
7698 break;
7699 case 0x81:
7700 GETBYTE ();
7701 switch (op[1] & 0x00)
7702 {
7703 case 0x00:
7704 goto op_semantics_52;
7705 break;
7706 }
7707 break;
7708 case 0x82:
7709 GETBYTE ();
7710 switch (op[1] & 0x00)
7711 {
7712 case 0x00:
7713 goto op_semantics_52;
7714 break;
7715 }
7716 break;
7717 case 0x83:
7718 GETBYTE ();
7719 switch (op[1] & 0x00)
7720 {
7721 case 0x00:
7722 goto op_semantics_52;
7723 break;
7724 }
7725 break;
7726 case 0x84:
7727 GETBYTE ();
7728 switch (op[1] & 0x00)
7729 {
7730 case 0x00:
7731 goto op_semantics_52;
7732 break;
7733 }
7734 break;
7735 case 0x85:
7736 GETBYTE ();
7737 switch (op[1] & 0x00)
7738 {
7739 case 0x00:
7740 goto op_semantics_52;
7741 break;
7742 }
7743 break;
7744 case 0x86:
7745 GETBYTE ();
7746 switch (op[1] & 0x00)
7747 {
7748 case 0x00:
7749 goto op_semantics_52;
7750 break;
7751 }
7752 break;
7753 case 0x87:
7754 GETBYTE ();
7755 switch (op[1] & 0x00)
7756 {
7757 case 0x00:
7758 goto op_semantics_52;
7759 break;
7760 }
7761 break;
7762 case 0x88:
7763 GETBYTE ();
7764 switch (op[1] & 0x00)
7765 {
7766 case 0x00:
7767 op_semantics_53:
7768 {
7769 /** 10sz 1dsp a src b dst mov%s %1, %0 */
7770 #line 354 "rx-decode.opc"
7771 int sz AU = (op[0] >> 4) & 0x03;
7772 #line 354 "rx-decode.opc"
7773 int dsp AU = op[0] & 0x07;
7774 #line 354 "rx-decode.opc"
7775 int a AU = (op[1] >> 7) & 0x01;
7776 #line 354 "rx-decode.opc"
7777 int src AU = (op[1] >> 4) & 0x07;
7778 #line 354 "rx-decode.opc"
7779 int b AU = (op[1] >> 3) & 0x01;
7780 #line 354 "rx-decode.opc"
7781 int dst AU = op[1] & 0x07;
7782 if (trace)
7783 {
7784 printf ("\033[33m%s\033[0m %02x %02x\n",
7785 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
7786 op[0], op[1]);
7787 printf (" sz = 0x%x,", sz);
7788 printf (" dsp = 0x%x,", dsp);
7789 printf (" a = 0x%x,", a);
7790 printf (" src = 0x%x,", src);
7791 printf (" b = 0x%x,", b);
7792 printf (" dst = 0x%x\n", dst);
7793 }
7794 SYNTAX("mov%s %1, %0");
7795 #line 354 "rx-decode.opc"
7796 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
7797
7798 }
7799 break;
7800 }
7801 break;
7802 case 0x89:
7803 GETBYTE ();
7804 switch (op[1] & 0x00)
7805 {
7806 case 0x00:
7807 goto op_semantics_53;
7808 break;
7809 }
7810 break;
7811 case 0x8a:
7812 GETBYTE ();
7813 switch (op[1] & 0x00)
7814 {
7815 case 0x00:
7816 goto op_semantics_53;
7817 break;
7818 }
7819 break;
7820 case 0x8b:
7821 GETBYTE ();
7822 switch (op[1] & 0x00)
7823 {
7824 case 0x00:
7825 goto op_semantics_53;
7826 break;
7827 }
7828 break;
7829 case 0x8c:
7830 GETBYTE ();
7831 switch (op[1] & 0x00)
7832 {
7833 case 0x00:
7834 goto op_semantics_53;
7835 break;
7836 }
7837 break;
7838 case 0x8d:
7839 GETBYTE ();
7840 switch (op[1] & 0x00)
7841 {
7842 case 0x00:
7843 goto op_semantics_53;
7844 break;
7845 }
7846 break;
7847 case 0x8e:
7848 GETBYTE ();
7849 switch (op[1] & 0x00)
7850 {
7851 case 0x00:
7852 goto op_semantics_53;
7853 break;
7854 }
7855 break;
7856 case 0x8f:
7857 GETBYTE ();
7858 switch (op[1] & 0x00)
7859 {
7860 case 0x00:
7861 goto op_semantics_53;
7862 break;
7863 }
7864 break;
7865 case 0x90:
7866 GETBYTE ();
7867 switch (op[1] & 0x00)
7868 {
7869 case 0x00:
7870 goto op_semantics_52;
7871 break;
7872 }
7873 break;
7874 case 0x91:
7875 GETBYTE ();
7876 switch (op[1] & 0x00)
7877 {
7878 case 0x00:
7879 goto op_semantics_52;
7880 break;
7881 }
7882 break;
7883 case 0x92:
7884 GETBYTE ();
7885 switch (op[1] & 0x00)
7886 {
7887 case 0x00:
7888 goto op_semantics_52;
7889 break;
7890 }
7891 break;
7892 case 0x93:
7893 GETBYTE ();
7894 switch (op[1] & 0x00)
7895 {
7896 case 0x00:
7897 goto op_semantics_52;
7898 break;
7899 }
7900 break;
7901 case 0x94:
7902 GETBYTE ();
7903 switch (op[1] & 0x00)
7904 {
7905 case 0x00:
7906 goto op_semantics_52;
7907 break;
7908 }
7909 break;
7910 case 0x95:
7911 GETBYTE ();
7912 switch (op[1] & 0x00)
7913 {
7914 case 0x00:
7915 goto op_semantics_52;
7916 break;
7917 }
7918 break;
7919 case 0x96:
7920 GETBYTE ();
7921 switch (op[1] & 0x00)
7922 {
7923 case 0x00:
7924 goto op_semantics_52;
7925 break;
7926 }
7927 break;
7928 case 0x97:
7929 GETBYTE ();
7930 switch (op[1] & 0x00)
7931 {
7932 case 0x00:
7933 goto op_semantics_52;
7934 break;
7935 }
7936 break;
7937 case 0x98:
7938 GETBYTE ();
7939 switch (op[1] & 0x00)
7940 {
7941 case 0x00:
7942 goto op_semantics_53;
7943 break;
7944 }
7945 break;
7946 case 0x99:
7947 GETBYTE ();
7948 switch (op[1] & 0x00)
7949 {
7950 case 0x00:
7951 goto op_semantics_53;
7952 break;
7953 }
7954 break;
7955 case 0x9a:
7956 GETBYTE ();
7957 switch (op[1] & 0x00)
7958 {
7959 case 0x00:
7960 goto op_semantics_53;
7961 break;
7962 }
7963 break;
7964 case 0x9b:
7965 GETBYTE ();
7966 switch (op[1] & 0x00)
7967 {
7968 case 0x00:
7969 goto op_semantics_53;
7970 break;
7971 }
7972 break;
7973 case 0x9c:
7974 GETBYTE ();
7975 switch (op[1] & 0x00)
7976 {
7977 case 0x00:
7978 goto op_semantics_53;
7979 break;
7980 }
7981 break;
7982 case 0x9d:
7983 GETBYTE ();
7984 switch (op[1] & 0x00)
7985 {
7986 case 0x00:
7987 goto op_semantics_53;
7988 break;
7989 }
7990 break;
7991 case 0x9e:
7992 GETBYTE ();
7993 switch (op[1] & 0x00)
7994 {
7995 case 0x00:
7996 goto op_semantics_53;
7997 break;
7998 }
7999 break;
8000 case 0x9f:
8001 GETBYTE ();
8002 switch (op[1] & 0x00)
8003 {
8004 case 0x00:
8005 goto op_semantics_53;
8006 break;
8007 }
8008 break;
8009 case 0xa0:
8010 GETBYTE ();
8011 switch (op[1] & 0x00)
8012 {
8013 case 0x00:
8014 goto op_semantics_52;
8015 break;
8016 }
8017 break;
8018 case 0xa1:
8019 GETBYTE ();
8020 switch (op[1] & 0x00)
8021 {
8022 case 0x00:
8023 goto op_semantics_52;
8024 break;
8025 }
8026 break;
8027 case 0xa2:
8028 GETBYTE ();
8029 switch (op[1] & 0x00)
8030 {
8031 case 0x00:
8032 goto op_semantics_52;
8033 break;
8034 }
8035 break;
8036 case 0xa3:
8037 GETBYTE ();
8038 switch (op[1] & 0x00)
8039 {
8040 case 0x00:
8041 goto op_semantics_52;
8042 break;
8043 }
8044 break;
8045 case 0xa4:
8046 GETBYTE ();
8047 switch (op[1] & 0x00)
8048 {
8049 case 0x00:
8050 goto op_semantics_52;
8051 break;
8052 }
8053 break;
8054 case 0xa5:
8055 GETBYTE ();
8056 switch (op[1] & 0x00)
8057 {
8058 case 0x00:
8059 goto op_semantics_52;
8060 break;
8061 }
8062 break;
8063 case 0xa6:
8064 GETBYTE ();
8065 switch (op[1] & 0x00)
8066 {
8067 case 0x00:
8068 goto op_semantics_52;
8069 break;
8070 }
8071 break;
8072 case 0xa7:
8073 GETBYTE ();
8074 switch (op[1] & 0x00)
8075 {
8076 case 0x00:
8077 goto op_semantics_52;
8078 break;
8079 }
8080 break;
8081 case 0xa8:
8082 GETBYTE ();
8083 switch (op[1] & 0x00)
8084 {
8085 case 0x00:
8086 goto op_semantics_53;
8087 break;
8088 }
8089 break;
8090 case 0xa9:
8091 GETBYTE ();
8092 switch (op[1] & 0x00)
8093 {
8094 case 0x00:
8095 goto op_semantics_53;
8096 break;
8097 }
8098 break;
8099 case 0xaa:
8100 GETBYTE ();
8101 switch (op[1] & 0x00)
8102 {
8103 case 0x00:
8104 goto op_semantics_53;
8105 break;
8106 }
8107 break;
8108 case 0xab:
8109 GETBYTE ();
8110 switch (op[1] & 0x00)
8111 {
8112 case 0x00:
8113 goto op_semantics_53;
8114 break;
8115 }
8116 break;
8117 case 0xac:
8118 GETBYTE ();
8119 switch (op[1] & 0x00)
8120 {
8121 case 0x00:
8122 goto op_semantics_53;
8123 break;
8124 }
8125 break;
8126 case 0xad:
8127 GETBYTE ();
8128 switch (op[1] & 0x00)
8129 {
8130 case 0x00:
8131 goto op_semantics_53;
8132 break;
8133 }
8134 break;
8135 case 0xae:
8136 GETBYTE ();
8137 switch (op[1] & 0x00)
8138 {
8139 case 0x00:
8140 goto op_semantics_53;
8141 break;
8142 }
8143 break;
8144 case 0xaf:
8145 GETBYTE ();
8146 switch (op[1] & 0x00)
8147 {
8148 case 0x00:
8149 goto op_semantics_53;
8150 break;
8151 }
8152 break;
8153 case 0xb0:
8154 GETBYTE ();
8155 switch (op[1] & 0x00)
8156 {
8157 case 0x00:
8158 op_semantics_54:
8159 {
8160 /** 1011 w dsp a src b dst movu%s %1, %0 */
8161 #line 377 "rx-decode.opc"
8162 int w AU = (op[0] >> 3) & 0x01;
8163 #line 377 "rx-decode.opc"
8164 int dsp AU = op[0] & 0x07;
8165 #line 377 "rx-decode.opc"
8166 int a AU = (op[1] >> 7) & 0x01;
8167 #line 377 "rx-decode.opc"
8168 int src AU = (op[1] >> 4) & 0x07;
8169 #line 377 "rx-decode.opc"
8170 int b AU = (op[1] >> 3) & 0x01;
8171 #line 377 "rx-decode.opc"
8172 int dst AU = op[1] & 0x07;
8173 if (trace)
8174 {
8175 printf ("\033[33m%s\033[0m %02x %02x\n",
8176 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
8177 op[0], op[1]);
8178 printf (" w = 0x%x,", w);
8179 printf (" dsp = 0x%x,", dsp);
8180 printf (" a = 0x%x,", a);
8181 printf (" src = 0x%x,", src);
8182 printf (" b = 0x%x,", b);
8183 printf (" dst = 0x%x\n", dst);
8184 }
8185 SYNTAX("movu%s %1, %0");
8186 #line 377 "rx-decode.opc"
8187 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
8188
8189 }
8190 break;
8191 }
8192 break;
8193 case 0xb1:
8194 GETBYTE ();
8195 switch (op[1] & 0x00)
8196 {
8197 case 0x00:
8198 goto op_semantics_54;
8199 break;
8200 }
8201 break;
8202 case 0xb2:
8203 GETBYTE ();
8204 switch (op[1] & 0x00)
8205 {
8206 case 0x00:
8207 goto op_semantics_54;
8208 break;
8209 }
8210 break;
8211 case 0xb3:
8212 GETBYTE ();
8213 switch (op[1] & 0x00)
8214 {
8215 case 0x00:
8216 goto op_semantics_54;
8217 break;
8218 }
8219 break;
8220 case 0xb4:
8221 GETBYTE ();
8222 switch (op[1] & 0x00)
8223 {
8224 case 0x00:
8225 goto op_semantics_54;
8226 break;
8227 }
8228 break;
8229 case 0xb5:
8230 GETBYTE ();
8231 switch (op[1] & 0x00)
8232 {
8233 case 0x00:
8234 goto op_semantics_54;
8235 break;
8236 }
8237 break;
8238 case 0xb6:
8239 GETBYTE ();
8240 switch (op[1] & 0x00)
8241 {
8242 case 0x00:
8243 goto op_semantics_54;
8244 break;
8245 }
8246 break;
8247 case 0xb7:
8248 GETBYTE ();
8249 switch (op[1] & 0x00)
8250 {
8251 case 0x00:
8252 goto op_semantics_54;
8253 break;
8254 }
8255 break;
8256 case 0xb8:
8257 GETBYTE ();
8258 switch (op[1] & 0x00)
8259 {
8260 case 0x00:
8261 goto op_semantics_54;
8262 break;
8263 }
8264 break;
8265 case 0xb9:
8266 GETBYTE ();
8267 switch (op[1] & 0x00)
8268 {
8269 case 0x00:
8270 goto op_semantics_54;
8271 break;
8272 }
8273 break;
8274 case 0xba:
8275 GETBYTE ();
8276 switch (op[1] & 0x00)
8277 {
8278 case 0x00:
8279 goto op_semantics_54;
8280 break;
8281 }
8282 break;
8283 case 0xbb:
8284 GETBYTE ();
8285 switch (op[1] & 0x00)
8286 {
8287 case 0x00:
8288 goto op_semantics_54;
8289 break;
8290 }
8291 break;
8292 case 0xbc:
8293 GETBYTE ();
8294 switch (op[1] & 0x00)
8295 {
8296 case 0x00:
8297 goto op_semantics_54;
8298 break;
8299 }
8300 break;
8301 case 0xbd:
8302 GETBYTE ();
8303 switch (op[1] & 0x00)
8304 {
8305 case 0x00:
8306 goto op_semantics_54;
8307 break;
8308 }
8309 break;
8310 case 0xbe:
8311 GETBYTE ();
8312 switch (op[1] & 0x00)
8313 {
8314 case 0x00:
8315 goto op_semantics_54;
8316 break;
8317 }
8318 break;
8319 case 0xbf:
8320 GETBYTE ();
8321 switch (op[1] & 0x00)
8322 {
8323 case 0x00:
8324 goto op_semantics_54;
8325 break;
8326 }
8327 break;
8328 case 0xc0:
8329 GETBYTE ();
8330 switch (op[1] & 0x00)
8331 {
8332 case 0x00:
8333 op_semantics_55:
8334 {
8335 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
8336 #line 335 "rx-decode.opc"
8337 int sz AU = (op[0] >> 4) & 0x03;
8338 #line 335 "rx-decode.opc"
8339 int sd AU = (op[0] >> 2) & 0x03;
8340 #line 335 "rx-decode.opc"
8341 int ss AU = op[0] & 0x03;
8342 #line 335 "rx-decode.opc"
8343 int rsrc AU = (op[1] >> 4) & 0x0f;
8344 #line 335 "rx-decode.opc"
8345 int rdst AU = op[1] & 0x0f;
8346 if (trace)
8347 {
8348 printf ("\033[33m%s\033[0m %02x %02x\n",
8349 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
8350 op[0], op[1]);
8351 printf (" sz = 0x%x,", sz);
8352 printf (" sd = 0x%x,", sd);
8353 printf (" ss = 0x%x,", ss);
8354 printf (" rsrc = 0x%x,", rsrc);
8355 printf (" rdst = 0x%x\n", rdst);
8356 }
8357 SYNTAX("mov%s %1, %0");
8358 #line 335 "rx-decode.opc"
8359 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
8360 {
8361 ID(nop2);
8362 SYNTAX ("nop\t; mov.l\tr0, r0");
8363 }
8364 else
8365 {
8366 ID(mov); sBWL(sz); F_____;
8367 if ((ss == 3) && (sd != 3))
8368 {
8369 SD(ss, rdst, sz); DD(sd, rsrc, sz);
8370 }
8371 else
8372 {
8373 SD(ss, rsrc, sz); DD(sd, rdst, sz);
8374 }
8375 }
8376
8377 }
8378 break;
8379 }
8380 break;
8381 case 0xc1:
8382 GETBYTE ();
8383 switch (op[1] & 0x00)
8384 {
8385 case 0x00:
8386 goto op_semantics_55;
8387 break;
8388 }
8389 break;
8390 case 0xc2:
8391 GETBYTE ();
8392 switch (op[1] & 0x00)
8393 {
8394 case 0x00:
8395 goto op_semantics_55;
8396 break;
8397 }
8398 break;
8399 case 0xc3:
8400 GETBYTE ();
8401 switch (op[1] & 0x00)
8402 {
8403 case 0x00:
8404 goto op_semantics_55;
8405 break;
8406 }
8407 break;
8408 case 0xc4:
8409 GETBYTE ();
8410 switch (op[1] & 0x00)
8411 {
8412 case 0x00:
8413 goto op_semantics_55;
8414 break;
8415 }
8416 break;
8417 case 0xc5:
8418 GETBYTE ();
8419 switch (op[1] & 0x00)
8420 {
8421 case 0x00:
8422 goto op_semantics_55;
8423 break;
8424 }
8425 break;
8426 case 0xc6:
8427 GETBYTE ();
8428 switch (op[1] & 0x00)
8429 {
8430 case 0x00:
8431 goto op_semantics_55;
8432 break;
8433 }
8434 break;
8435 case 0xc7:
8436 GETBYTE ();
8437 switch (op[1] & 0x00)
8438 {
8439 case 0x00:
8440 goto op_semantics_55;
8441 break;
8442 }
8443 break;
8444 case 0xc8:
8445 GETBYTE ();
8446 switch (op[1] & 0x00)
8447 {
8448 case 0x00:
8449 goto op_semantics_55;
8450 break;
8451 }
8452 break;
8453 case 0xc9:
8454 GETBYTE ();
8455 switch (op[1] & 0x00)
8456 {
8457 case 0x00:
8458 goto op_semantics_55;
8459 break;
8460 }
8461 break;
8462 case 0xca:
8463 GETBYTE ();
8464 switch (op[1] & 0x00)
8465 {
8466 case 0x00:
8467 goto op_semantics_55;
8468 break;
8469 }
8470 break;
8471 case 0xcb:
8472 GETBYTE ();
8473 switch (op[1] & 0x00)
8474 {
8475 case 0x00:
8476 goto op_semantics_55;
8477 break;
8478 }
8479 break;
8480 case 0xcc:
8481 GETBYTE ();
8482 switch (op[1] & 0x00)
8483 {
8484 case 0x00:
8485 goto op_semantics_55;
8486 break;
8487 }
8488 break;
8489 case 0xcd:
8490 GETBYTE ();
8491 switch (op[1] & 0x00)
8492 {
8493 case 0x00:
8494 goto op_semantics_55;
8495 break;
8496 }
8497 break;
8498 case 0xce:
8499 GETBYTE ();
8500 switch (op[1] & 0x00)
8501 {
8502 case 0x00:
8503 goto op_semantics_55;
8504 break;
8505 }
8506 break;
8507 case 0xcf:
8508 GETBYTE ();
8509 switch (op[1] & 0x00)
8510 {
8511 case 0x00:
8512 goto op_semantics_55;
8513 break;
8514 }
8515 break;
8516 case 0xd0:
8517 GETBYTE ();
8518 switch (op[1] & 0x00)
8519 {
8520 case 0x00:
8521 goto op_semantics_55;
8522 break;
8523 }
8524 break;
8525 case 0xd1:
8526 GETBYTE ();
8527 switch (op[1] & 0x00)
8528 {
8529 case 0x00:
8530 goto op_semantics_55;
8531 break;
8532 }
8533 break;
8534 case 0xd2:
8535 GETBYTE ();
8536 switch (op[1] & 0x00)
8537 {
8538 case 0x00:
8539 goto op_semantics_55;
8540 break;
8541 }
8542 break;
8543 case 0xd3:
8544 GETBYTE ();
8545 switch (op[1] & 0x00)
8546 {
8547 case 0x00:
8548 goto op_semantics_55;
8549 break;
8550 }
8551 break;
8552 case 0xd4:
8553 GETBYTE ();
8554 switch (op[1] & 0x00)
8555 {
8556 case 0x00:
8557 goto op_semantics_55;
8558 break;
8559 }
8560 break;
8561 case 0xd5:
8562 GETBYTE ();
8563 switch (op[1] & 0x00)
8564 {
8565 case 0x00:
8566 goto op_semantics_55;
8567 break;
8568 }
8569 break;
8570 case 0xd6:
8571 GETBYTE ();
8572 switch (op[1] & 0x00)
8573 {
8574 case 0x00:
8575 goto op_semantics_55;
8576 break;
8577 }
8578 break;
8579 case 0xd7:
8580 GETBYTE ();
8581 switch (op[1] & 0x00)
8582 {
8583 case 0x00:
8584 goto op_semantics_55;
8585 break;
8586 }
8587 break;
8588 case 0xd8:
8589 GETBYTE ();
8590 switch (op[1] & 0x00)
8591 {
8592 case 0x00:
8593 goto op_semantics_55;
8594 break;
8595 }
8596 break;
8597 case 0xd9:
8598 GETBYTE ();
8599 switch (op[1] & 0x00)
8600 {
8601 case 0x00:
8602 goto op_semantics_55;
8603 break;
8604 }
8605 break;
8606 case 0xda:
8607 GETBYTE ();
8608 switch (op[1] & 0x00)
8609 {
8610 case 0x00:
8611 goto op_semantics_55;
8612 break;
8613 }
8614 break;
8615 case 0xdb:
8616 GETBYTE ();
8617 switch (op[1] & 0x00)
8618 {
8619 case 0x00:
8620 goto op_semantics_55;
8621 break;
8622 }
8623 break;
8624 case 0xdc:
8625 GETBYTE ();
8626 switch (op[1] & 0x00)
8627 {
8628 case 0x00:
8629 goto op_semantics_55;
8630 break;
8631 }
8632 break;
8633 case 0xdd:
8634 GETBYTE ();
8635 switch (op[1] & 0x00)
8636 {
8637 case 0x00:
8638 goto op_semantics_55;
8639 break;
8640 }
8641 break;
8642 case 0xde:
8643 GETBYTE ();
8644 switch (op[1] & 0x00)
8645 {
8646 case 0x00:
8647 goto op_semantics_55;
8648 break;
8649 }
8650 break;
8651 case 0xdf:
8652 GETBYTE ();
8653 switch (op[1] & 0x00)
8654 {
8655 case 0x00:
8656 goto op_semantics_55;
8657 break;
8658 }
8659 break;
8660 case 0xe0:
8661 GETBYTE ();
8662 switch (op[1] & 0x00)
8663 {
8664 case 0x00:
8665 goto op_semantics_55;
8666 break;
8667 }
8668 break;
8669 case 0xe1:
8670 GETBYTE ();
8671 switch (op[1] & 0x00)
8672 {
8673 case 0x00:
8674 goto op_semantics_55;
8675 break;
8676 }
8677 break;
8678 case 0xe2:
8679 GETBYTE ();
8680 switch (op[1] & 0x00)
8681 {
8682 case 0x00:
8683 goto op_semantics_55;
8684 break;
8685 }
8686 break;
8687 case 0xe3:
8688 GETBYTE ();
8689 switch (op[1] & 0x00)
8690 {
8691 case 0x00:
8692 goto op_semantics_55;
8693 break;
8694 }
8695 break;
8696 case 0xe4:
8697 GETBYTE ();
8698 switch (op[1] & 0x00)
8699 {
8700 case 0x00:
8701 goto op_semantics_55;
8702 break;
8703 }
8704 break;
8705 case 0xe5:
8706 GETBYTE ();
8707 switch (op[1] & 0x00)
8708 {
8709 case 0x00:
8710 goto op_semantics_55;
8711 break;
8712 }
8713 break;
8714 case 0xe6:
8715 GETBYTE ();
8716 switch (op[1] & 0x00)
8717 {
8718 case 0x00:
8719 goto op_semantics_55;
8720 break;
8721 }
8722 break;
8723 case 0xe7:
8724 GETBYTE ();
8725 switch (op[1] & 0x00)
8726 {
8727 case 0x00:
8728 goto op_semantics_55;
8729 break;
8730 }
8731 break;
8732 case 0xe8:
8733 GETBYTE ();
8734 switch (op[1] & 0x00)
8735 {
8736 case 0x00:
8737 goto op_semantics_55;
8738 break;
8739 }
8740 break;
8741 case 0xe9:
8742 GETBYTE ();
8743 switch (op[1] & 0x00)
8744 {
8745 case 0x00:
8746 goto op_semantics_55;
8747 break;
8748 }
8749 break;
8750 case 0xea:
8751 GETBYTE ();
8752 switch (op[1] & 0x00)
8753 {
8754 case 0x00:
8755 goto op_semantics_55;
8756 break;
8757 }
8758 break;
8759 case 0xeb:
8760 GETBYTE ();
8761 switch (op[1] & 0x00)
8762 {
8763 case 0x00:
8764 goto op_semantics_55;
8765 break;
8766 }
8767 break;
8768 case 0xec:
8769 GETBYTE ();
8770 switch (op[1] & 0x00)
8771 {
8772 case 0x00:
8773 goto op_semantics_55;
8774 break;
8775 }
8776 break;
8777 case 0xed:
8778 GETBYTE ();
8779 switch (op[1] & 0x00)
8780 {
8781 case 0x00:
8782 goto op_semantics_55;
8783 break;
8784 }
8785 break;
8786 case 0xee:
8787 GETBYTE ();
8788 switch (op[1] & 0x00)
8789 {
8790 case 0x00:
8791 goto op_semantics_55;
8792 break;
8793 }
8794 break;
8795 case 0xef:
8796 GETBYTE ();
8797 switch (op[1] & 0x00)
8798 {
8799 case 0x00:
8800 goto op_semantics_55;
8801 break;
8802 }
8803 break;
8804 case 0xf0:
8805 GETBYTE ();
8806 switch (op[1] & 0x08)
8807 {
8808 case 0x00:
8809 op_semantics_56:
8810 {
8811 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
8812 #line 960 "rx-decode.opc"
8813 int sd AU = op[0] & 0x03;
8814 #line 960 "rx-decode.opc"
8815 int rdst AU = (op[1] >> 4) & 0x0f;
8816 #line 960 "rx-decode.opc"
8817 int bit AU = op[1] & 0x07;
8818 if (trace)
8819 {
8820 printf ("\033[33m%s\033[0m %02x %02x\n",
8821 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
8822 op[0], op[1]);
8823 printf (" sd = 0x%x,", sd);
8824 printf (" rdst = 0x%x,", rdst);
8825 printf (" bit = 0x%x\n", bit);
8826 }
8827 SYNTAX("bset #%1, %0%S0");
8828 #line 960 "rx-decode.opc"
8829 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8830
8831 }
8832 break;
8833 case 0x08:
8834 op_semantics_57:
8835 {
8836 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
8837 #line 972 "rx-decode.opc"
8838 int sd AU = op[0] & 0x03;
8839 #line 972 "rx-decode.opc"
8840 int rdst AU = (op[1] >> 4) & 0x0f;
8841 #line 972 "rx-decode.opc"
8842 int bit AU = op[1] & 0x07;
8843 if (trace)
8844 {
8845 printf ("\033[33m%s\033[0m %02x %02x\n",
8846 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
8847 op[0], op[1]);
8848 printf (" sd = 0x%x,", sd);
8849 printf (" rdst = 0x%x,", rdst);
8850 printf (" bit = 0x%x\n", bit);
8851 }
8852 SYNTAX("bclr #%1, %0%S0");
8853 #line 972 "rx-decode.opc"
8854 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8855
8856 }
8857 break;
8858 }
8859 break;
8860 case 0xf1:
8861 GETBYTE ();
8862 switch (op[1] & 0x08)
8863 {
8864 case 0x00:
8865 goto op_semantics_56;
8866 break;
8867 case 0x08:
8868 goto op_semantics_57;
8869 break;
8870 }
8871 break;
8872 case 0xf2:
8873 GETBYTE ();
8874 switch (op[1] & 0x08)
8875 {
8876 case 0x00:
8877 goto op_semantics_56;
8878 break;
8879 case 0x08:
8880 goto op_semantics_57;
8881 break;
8882 }
8883 break;
8884 case 0xf3:
8885 GETBYTE ();
8886 switch (op[1] & 0x08)
8887 {
8888 case 0x00:
8889 goto op_semantics_56;
8890 break;
8891 case 0x08:
8892 goto op_semantics_57;
8893 break;
8894 }
8895 break;
8896 case 0xf4:
8897 GETBYTE ();
8898 switch (op[1] & 0x0c)
8899 {
8900 case 0x00:
8901 case 0x04:
8902 op_semantics_58:
8903 {
8904 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
8905 #line 984 "rx-decode.opc"
8906 int sd AU = op[0] & 0x03;
8907 #line 984 "rx-decode.opc"
8908 int rdst AU = (op[1] >> 4) & 0x0f;
8909 #line 984 "rx-decode.opc"
8910 int bit AU = op[1] & 0x07;
8911 if (trace)
8912 {
8913 printf ("\033[33m%s\033[0m %02x %02x\n",
8914 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
8915 op[0], op[1]);
8916 printf (" sd = 0x%x,", sd);
8917 printf (" rdst = 0x%x,", rdst);
8918 printf (" bit = 0x%x\n", bit);
8919 }
8920 SYNTAX("btst #%2, %1%S1");
8921 #line 984 "rx-decode.opc"
8922 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
8923
8924 }
8925 break;
8926 case 0x08:
8927 op_semantics_59:
8928 {
8929 /** 1111 01ss rsrc 10sz push%s %1 */
8930 #line 402 "rx-decode.opc"
8931 int ss AU = op[0] & 0x03;
8932 #line 402 "rx-decode.opc"
8933 int rsrc AU = (op[1] >> 4) & 0x0f;
8934 #line 402 "rx-decode.opc"
8935 int sz AU = op[1] & 0x03;
8936 if (trace)
8937 {
8938 printf ("\033[33m%s\033[0m %02x %02x\n",
8939 "/** 1111 01ss rsrc 10sz push%s %1 */",
8940 op[0], op[1]);
8941 printf (" ss = 0x%x,", ss);
8942 printf (" rsrc = 0x%x,", rsrc);
8943 printf (" sz = 0x%x\n", sz);
8944 }
8945 SYNTAX("push%s %1");
8946 #line 402 "rx-decode.opc"
8947 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
8948
8949 /*----------------------------------------------------------------------*/
8950 /* XCHG */
8951
8952 }
8953 break;
8954 default: UNSUPPORTED(); break;
8955 }
8956 break;
8957 case 0xf5:
8958 GETBYTE ();
8959 switch (op[1] & 0x0c)
8960 {
8961 case 0x00:
8962 case 0x04:
8963 goto op_semantics_58;
8964 break;
8965 case 0x08:
8966 goto op_semantics_59;
8967 break;
8968 default: UNSUPPORTED(); break;
8969 }
8970 break;
8971 case 0xf6:
8972 GETBYTE ();
8973 switch (op[1] & 0x0c)
8974 {
8975 case 0x00:
8976 case 0x04:
8977 goto op_semantics_58;
8978 break;
8979 case 0x08:
8980 goto op_semantics_59;
8981 break;
8982 default: UNSUPPORTED(); break;
8983 }
8984 break;
8985 case 0xf7:
8986 GETBYTE ();
8987 switch (op[1] & 0x0c)
8988 {
8989 case 0x00:
8990 case 0x04:
8991 goto op_semantics_58;
8992 break;
8993 case 0x08:
8994 goto op_semantics_59;
8995 break;
8996 default: UNSUPPORTED(); break;
8997 }
8998 break;
8999 case 0xf8:
9000 GETBYTE ();
9001 switch (op[1] & 0x00)
9002 {
9003 case 0x00:
9004 op_semantics_60:
9005 {
9006 /** 1111 10sd rdst im sz mov%s #%1, %0 */
9007 #line 313 "rx-decode.opc"
9008 int sd AU = op[0] & 0x03;
9009 #line 313 "rx-decode.opc"
9010 int rdst AU = (op[1] >> 4) & 0x0f;
9011 #line 313 "rx-decode.opc"
9012 int im AU = (op[1] >> 2) & 0x03;
9013 #line 313 "rx-decode.opc"
9014 int sz AU = op[1] & 0x03;
9015 if (trace)
9016 {
9017 printf ("\033[33m%s\033[0m %02x %02x\n",
9018 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
9019 op[0], op[1]);
9020 printf (" sd = 0x%x,", sd);
9021 printf (" rdst = 0x%x,", rdst);
9022 printf (" im = 0x%x,", im);
9023 printf (" sz = 0x%x\n", sz);
9024 }
9025 SYNTAX("mov%s #%1, %0");
9026 #line 313 "rx-decode.opc"
9027 ID(mov); DD(sd, rdst, sz);
9028 if ((im == 1 && sz == 0)
9029 || (im == 2 && sz == 1)
9030 || (im == 0 && sz == 2))
9031 {
9032 BWL (sz);
9033 SC(IMM(im));
9034 }
9035 else
9036 {
9037 sBWL (sz);
9038 SC(IMMex(im));
9039 }
9040 F_____;
9041
9042 }
9043 break;
9044 }
9045 break;
9046 case 0xf9:
9047 GETBYTE ();
9048 switch (op[1] & 0xff)
9049 {
9050 case 0x00:
9051 case 0x01:
9052 case 0x02:
9053 case 0x04:
9054 case 0x05:
9055 case 0x06:
9056 case 0x08:
9057 case 0x09:
9058 case 0x0a:
9059 case 0x0c:
9060 case 0x0d:
9061 case 0x0e:
9062 case 0x10:
9063 case 0x11:
9064 case 0x12:
9065 case 0x14:
9066 case 0x15:
9067 case 0x16:
9068 case 0x18:
9069 case 0x19:
9070 case 0x1a:
9071 case 0x1c:
9072 case 0x1d:
9073 case 0x1e:
9074 case 0x20:
9075 case 0x21:
9076 case 0x22:
9077 case 0x24:
9078 case 0x25:
9079 case 0x26:
9080 case 0x28:
9081 case 0x29:
9082 case 0x2a:
9083 case 0x2c:
9084 case 0x2d:
9085 case 0x2e:
9086 case 0x30:
9087 case 0x31:
9088 case 0x32:
9089 case 0x34:
9090 case 0x35:
9091 case 0x36:
9092 case 0x38:
9093 case 0x39:
9094 case 0x3a:
9095 case 0x3c:
9096 case 0x3d:
9097 case 0x3e:
9098 case 0x40:
9099 case 0x41:
9100 case 0x42:
9101 case 0x44:
9102 case 0x45:
9103 case 0x46:
9104 case 0x48:
9105 case 0x49:
9106 case 0x4a:
9107 case 0x4c:
9108 case 0x4d:
9109 case 0x4e:
9110 case 0x50:
9111 case 0x51:
9112 case 0x52:
9113 case 0x54:
9114 case 0x55:
9115 case 0x56:
9116 case 0x58:
9117 case 0x59:
9118 case 0x5a:
9119 case 0x5c:
9120 case 0x5d:
9121 case 0x5e:
9122 case 0x60:
9123 case 0x61:
9124 case 0x62:
9125 case 0x64:
9126 case 0x65:
9127 case 0x66:
9128 case 0x68:
9129 case 0x69:
9130 case 0x6a:
9131 case 0x6c:
9132 case 0x6d:
9133 case 0x6e:
9134 case 0x70:
9135 case 0x71:
9136 case 0x72:
9137 case 0x74:
9138 case 0x75:
9139 case 0x76:
9140 case 0x78:
9141 case 0x79:
9142 case 0x7a:
9143 case 0x7c:
9144 case 0x7d:
9145 case 0x7e:
9146 case 0x80:
9147 case 0x81:
9148 case 0x82:
9149 case 0x84:
9150 case 0x85:
9151 case 0x86:
9152 case 0x88:
9153 case 0x89:
9154 case 0x8a:
9155 case 0x8c:
9156 case 0x8d:
9157 case 0x8e:
9158 case 0x90:
9159 case 0x91:
9160 case 0x92:
9161 case 0x94:
9162 case 0x95:
9163 case 0x96:
9164 case 0x98:
9165 case 0x99:
9166 case 0x9a:
9167 case 0x9c:
9168 case 0x9d:
9169 case 0x9e:
9170 case 0xa0:
9171 case 0xa1:
9172 case 0xa2:
9173 case 0xa4:
9174 case 0xa5:
9175 case 0xa6:
9176 case 0xa8:
9177 case 0xa9:
9178 case 0xaa:
9179 case 0xac:
9180 case 0xad:
9181 case 0xae:
9182 case 0xb0:
9183 case 0xb1:
9184 case 0xb2:
9185 case 0xb4:
9186 case 0xb5:
9187 case 0xb6:
9188 case 0xb8:
9189 case 0xb9:
9190 case 0xba:
9191 case 0xbc:
9192 case 0xbd:
9193 case 0xbe:
9194 case 0xc0:
9195 case 0xc1:
9196 case 0xc2:
9197 case 0xc4:
9198 case 0xc5:
9199 case 0xc6:
9200 case 0xc8:
9201 case 0xc9:
9202 case 0xca:
9203 case 0xcc:
9204 case 0xcd:
9205 case 0xce:
9206 case 0xd0:
9207 case 0xd1:
9208 case 0xd2:
9209 case 0xd4:
9210 case 0xd5:
9211 case 0xd6:
9212 case 0xd8:
9213 case 0xd9:
9214 case 0xda:
9215 case 0xdc:
9216 case 0xdd:
9217 case 0xde:
9218 case 0xe0:
9219 case 0xe1:
9220 case 0xe2:
9221 case 0xe4:
9222 case 0xe5:
9223 case 0xe6:
9224 case 0xe8:
9225 case 0xe9:
9226 case 0xea:
9227 case 0xec:
9228 case 0xed:
9229 case 0xee:
9230 case 0xf0:
9231 case 0xf1:
9232 case 0xf2:
9233 case 0xf4:
9234 case 0xf5:
9235 case 0xf6:
9236 case 0xf8:
9237 case 0xf9:
9238 case 0xfa:
9239 case 0xfc:
9240 case 0xfd:
9241 case 0xfe:
9242 goto op_semantics_60;
9243 break;
9244 case 0x03:
9245 GETBYTE ();
9246 switch (op[2] & 0x0f)
9247 {
9248 case 0x00:
9249 {
9250 /** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */
9251 #line 1211 "rx-decode.opc"
9252 int rdst AU = (op[2] >> 4) & 0x0f;
9253 if (trace)
9254 {
9255 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9256 "/** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */",
9257 op[0], op[1], op[2]);
9258 printf (" rdst = 0x%x\n", rdst);
9259 }
9260 SYNTAX("dmov.l #%1, %0");
9261 #line 1211 "rx-decode.opc"
9262 ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____;
9263
9264 }
9265 break;
9266 case 0x02:
9267 case 0x03:
9268 {
9269 /** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */
9270 #line 1208 "rx-decode.opc"
9271 int rdst AU = (op[2] >> 4) & 0x0f;
9272 #line 1208 "rx-decode.opc"
9273 int s AU = op[2] & 0x01;
9274 if (trace)
9275 {
9276 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9277 "/** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */",
9278 op[0], op[1], op[2]);
9279 printf (" rdst = 0x%x,", rdst);
9280 printf (" s = 0x%x\n", s);
9281 }
9282 SYNTAX("dmov%s #%1, %0");
9283 #line 1208 "rx-decode.opc"
9284 ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____;
9285
9286 }
9287 break;
9288 default: UNSUPPORTED(); break;
9289 }
9290 break;
9291 default: UNSUPPORTED(); break;
9292 }
9293 break;
9294 case 0xfa:
9295 GETBYTE ();
9296 switch (op[1] & 0x00)
9297 {
9298 case 0x00:
9299 goto op_semantics_60;
9300 break;
9301 }
9302 break;
9303 case 0xfb:
9304 GETBYTE ();
9305 switch (op[1] & 0x00)
9306 {
9307 case 0x00:
9308 goto op_semantics_60;
9309 break;
9310 }
9311 break;
9312 case 0xfc:
9313 GETBYTE ();
9314 switch (op[1] & 0xff)
9315 {
9316 case 0x03:
9317 GETBYTE ();
9318 switch (op[2] & 0x00)
9319 {
9320 case 0x00:
9321 {
9322 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
9323 #line 576 "rx-decode.opc"
9324 int rsrc AU = (op[2] >> 4) & 0x0f;
9325 #line 576 "rx-decode.opc"
9326 int rdst AU = op[2] & 0x0f;
9327 if (trace)
9328 {
9329 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9330 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
9331 op[0], op[1], op[2]);
9332 printf (" rsrc = 0x%x,", rsrc);
9333 printf (" rdst = 0x%x\n", rdst);
9334 }
9335 SYNTAX("sbb %1, %0");
9336 #line 576 "rx-decode.opc"
9337 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
9338
9339 /* FIXME: only supports .L */
9340 }
9341 break;
9342 }
9343 break;
9344 case 0x07:
9345 GETBYTE ();
9346 switch (op[2] & 0x00)
9347 {
9348 case 0x00:
9349 {
9350 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
9351 #line 507 "rx-decode.opc"
9352 int rsrc AU = (op[2] >> 4) & 0x0f;
9353 #line 507 "rx-decode.opc"
9354 int rdst AU = op[2] & 0x0f;
9355 if (trace)
9356 {
9357 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9358 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
9359 op[0], op[1], op[2]);
9360 printf (" rsrc = 0x%x,", rsrc);
9361 printf (" rdst = 0x%x\n", rdst);
9362 }
9363 SYNTAX("neg %2, %0");
9364 #line 507 "rx-decode.opc"
9365 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
9366
9367 /*----------------------------------------------------------------------*/
9368 /* ADC */
9369
9370 }
9371 break;
9372 }
9373 break;
9374 case 0x0b:
9375 GETBYTE ();
9376 switch (op[2] & 0x00)
9377 {
9378 case 0x00:
9379 {
9380 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
9381 #line 516 "rx-decode.opc"
9382 int rsrc AU = (op[2] >> 4) & 0x0f;
9383 #line 516 "rx-decode.opc"
9384 int rdst AU = op[2] & 0x0f;
9385 if (trace)
9386 {
9387 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9388 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
9389 op[0], op[1], op[2]);
9390 printf (" rsrc = 0x%x,", rsrc);
9391 printf (" rdst = 0x%x\n", rdst);
9392 }
9393 SYNTAX("adc %1, %0");
9394 #line 516 "rx-decode.opc"
9395 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
9396
9397 }
9398 break;
9399 }
9400 break;
9401 case 0x0f:
9402 GETBYTE ();
9403 switch (op[2] & 0x00)
9404 {
9405 case 0x00:
9406 {
9407 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
9408 #line 589 "rx-decode.opc"
9409 int rsrc AU = (op[2] >> 4) & 0x0f;
9410 #line 589 "rx-decode.opc"
9411 int rdst AU = op[2] & 0x0f;
9412 if (trace)
9413 {
9414 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9415 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
9416 op[0], op[1], op[2]);
9417 printf (" rsrc = 0x%x,", rsrc);
9418 printf (" rdst = 0x%x\n", rdst);
9419 }
9420 SYNTAX("abs %1, %0");
9421 #line 589 "rx-decode.opc"
9422 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
9423
9424 /*----------------------------------------------------------------------*/
9425 /* MAX */
9426
9427 }
9428 break;
9429 }
9430 break;
9431 case 0x10:
9432 GETBYTE ();
9433 switch (op[2] & 0x00)
9434 {
9435 case 0x00:
9436 op_semantics_61:
9437 {
9438 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
9439 #line 608 "rx-decode.opc"
9440 int ss AU = op[1] & 0x03;
9441 #line 608 "rx-decode.opc"
9442 int rsrc AU = (op[2] >> 4) & 0x0f;
9443 #line 608 "rx-decode.opc"
9444 int rdst AU = op[2] & 0x0f;
9445 if (trace)
9446 {
9447 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9448 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
9449 op[0], op[1], op[2]);
9450 printf (" ss = 0x%x,", ss);
9451 printf (" rsrc = 0x%x,", rsrc);
9452 printf (" rdst = 0x%x\n", rdst);
9453 }
9454 SYNTAX("max %1%S1, %0");
9455 #line 608 "rx-decode.opc"
9456 if (ss == 3 && rsrc == 0 && rdst == 0)
9457 {
9458 ID(nop3);
9459 SYNTAX("nop\t; max\tr0, r0");
9460 }
9461 else
9462 {
9463 ID(max); SP(ss, rsrc); DR(rdst);
9464 }
9465
9466 }
9467 break;
9468 }
9469 break;
9470 case 0x11:
9471 GETBYTE ();
9472 switch (op[2] & 0x00)
9473 {
9474 case 0x00:
9475 goto op_semantics_61;
9476 break;
9477 }
9478 break;
9479 case 0x12:
9480 GETBYTE ();
9481 switch (op[2] & 0x00)
9482 {
9483 case 0x00:
9484 goto op_semantics_61;
9485 break;
9486 }
9487 break;
9488 case 0x13:
9489 GETBYTE ();
9490 switch (op[2] & 0x00)
9491 {
9492 case 0x00:
9493 goto op_semantics_61;
9494 break;
9495 }
9496 break;
9497 case 0x14:
9498 GETBYTE ();
9499 switch (op[2] & 0x00)
9500 {
9501 case 0x00:
9502 op_semantics_62:
9503 {
9504 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
9505 #line 628 "rx-decode.opc"
9506 int ss AU = op[1] & 0x03;
9507 #line 628 "rx-decode.opc"
9508 int rsrc AU = (op[2] >> 4) & 0x0f;
9509 #line 628 "rx-decode.opc"
9510 int rdst AU = op[2] & 0x0f;
9511 if (trace)
9512 {
9513 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9514 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
9515 op[0], op[1], op[2]);
9516 printf (" ss = 0x%x,", ss);
9517 printf (" rsrc = 0x%x,", rsrc);
9518 printf (" rdst = 0x%x\n", rdst);
9519 }
9520 SYNTAX("min %1%S1, %0");
9521 #line 628 "rx-decode.opc"
9522 ID(min); SP(ss, rsrc); DR(rdst);
9523
9524 }
9525 break;
9526 }
9527 break;
9528 case 0x15:
9529 GETBYTE ();
9530 switch (op[2] & 0x00)
9531 {
9532 case 0x00:
9533 goto op_semantics_62;
9534 break;
9535 }
9536 break;
9537 case 0x16:
9538 GETBYTE ();
9539 switch (op[2] & 0x00)
9540 {
9541 case 0x00:
9542 goto op_semantics_62;
9543 break;
9544 }
9545 break;
9546 case 0x17:
9547 GETBYTE ();
9548 switch (op[2] & 0x00)
9549 {
9550 case 0x00:
9551 goto op_semantics_62;
9552 break;
9553 }
9554 break;
9555 case 0x18:
9556 GETBYTE ();
9557 switch (op[2] & 0x00)
9558 {
9559 case 0x00:
9560 op_semantics_63:
9561 {
9562 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
9563 #line 686 "rx-decode.opc"
9564 int ss AU = op[1] & 0x03;
9565 #line 686 "rx-decode.opc"
9566 int rsrc AU = (op[2] >> 4) & 0x0f;
9567 #line 686 "rx-decode.opc"
9568 int rdst AU = op[2] & 0x0f;
9569 if (trace)
9570 {
9571 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9572 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
9573 op[0], op[1], op[2]);
9574 printf (" ss = 0x%x,", ss);
9575 printf (" rsrc = 0x%x,", rsrc);
9576 printf (" rdst = 0x%x\n", rdst);
9577 }
9578 SYNTAX("emul %1%S1, %0");
9579 #line 686 "rx-decode.opc"
9580 ID(emul); SP(ss, rsrc); DR(rdst);
9581
9582 }
9583 break;
9584 }
9585 break;
9586 case 0x19:
9587 GETBYTE ();
9588 switch (op[2] & 0x00)
9589 {
9590 case 0x00:
9591 goto op_semantics_63;
9592 break;
9593 }
9594 break;
9595 case 0x1a:
9596 GETBYTE ();
9597 switch (op[2] & 0x00)
9598 {
9599 case 0x00:
9600 goto op_semantics_63;
9601 break;
9602 }
9603 break;
9604 case 0x1b:
9605 GETBYTE ();
9606 switch (op[2] & 0x00)
9607 {
9608 case 0x00:
9609 goto op_semantics_63;
9610 break;
9611 }
9612 break;
9613 case 0x1c:
9614 GETBYTE ();
9615 switch (op[2] & 0x00)
9616 {
9617 case 0x00:
9618 op_semantics_64:
9619 {
9620 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
9621 #line 698 "rx-decode.opc"
9622 int ss AU = op[1] & 0x03;
9623 #line 698 "rx-decode.opc"
9624 int rsrc AU = (op[2] >> 4) & 0x0f;
9625 #line 698 "rx-decode.opc"
9626 int rdst AU = op[2] & 0x0f;
9627 if (trace)
9628 {
9629 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9630 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
9631 op[0], op[1], op[2]);
9632 printf (" ss = 0x%x,", ss);
9633 printf (" rsrc = 0x%x,", rsrc);
9634 printf (" rdst = 0x%x\n", rdst);
9635 }
9636 SYNTAX("emulu %1%S1, %0");
9637 #line 698 "rx-decode.opc"
9638 ID(emulu); SP(ss, rsrc); DR(rdst);
9639
9640 }
9641 break;
9642 }
9643 break;
9644 case 0x1d:
9645 GETBYTE ();
9646 switch (op[2] & 0x00)
9647 {
9648 case 0x00:
9649 goto op_semantics_64;
9650 break;
9651 }
9652 break;
9653 case 0x1e:
9654 GETBYTE ();
9655 switch (op[2] & 0x00)
9656 {
9657 case 0x00:
9658 goto op_semantics_64;
9659 break;
9660 }
9661 break;
9662 case 0x1f:
9663 GETBYTE ();
9664 switch (op[2] & 0x00)
9665 {
9666 case 0x00:
9667 goto op_semantics_64;
9668 break;
9669 }
9670 break;
9671 case 0x20:
9672 GETBYTE ();
9673 switch (op[2] & 0x00)
9674 {
9675 case 0x00:
9676 op_semantics_65:
9677 {
9678 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
9679 #line 710 "rx-decode.opc"
9680 int ss AU = op[1] & 0x03;
9681 #line 710 "rx-decode.opc"
9682 int rsrc AU = (op[2] >> 4) & 0x0f;
9683 #line 710 "rx-decode.opc"
9684 int rdst AU = op[2] & 0x0f;
9685 if (trace)
9686 {
9687 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9688 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
9689 op[0], op[1], op[2]);
9690 printf (" ss = 0x%x,", ss);
9691 printf (" rsrc = 0x%x,", rsrc);
9692 printf (" rdst = 0x%x\n", rdst);
9693 }
9694 SYNTAX("div %1%S1, %0");
9695 #line 710 "rx-decode.opc"
9696 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
9697
9698 }
9699 break;
9700 }
9701 break;
9702 case 0x21:
9703 GETBYTE ();
9704 switch (op[2] & 0x00)
9705 {
9706 case 0x00:
9707 goto op_semantics_65;
9708 break;
9709 }
9710 break;
9711 case 0x22:
9712 GETBYTE ();
9713 switch (op[2] & 0x00)
9714 {
9715 case 0x00:
9716 goto op_semantics_65;
9717 break;
9718 }
9719 break;
9720 case 0x23:
9721 GETBYTE ();
9722 switch (op[2] & 0x00)
9723 {
9724 case 0x00:
9725 goto op_semantics_65;
9726 break;
9727 }
9728 break;
9729 case 0x24:
9730 GETBYTE ();
9731 switch (op[2] & 0x00)
9732 {
9733 case 0x00:
9734 op_semantics_66:
9735 {
9736 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
9737 #line 722 "rx-decode.opc"
9738 int ss AU = op[1] & 0x03;
9739 #line 722 "rx-decode.opc"
9740 int rsrc AU = (op[2] >> 4) & 0x0f;
9741 #line 722 "rx-decode.opc"
9742 int rdst AU = op[2] & 0x0f;
9743 if (trace)
9744 {
9745 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9746 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
9747 op[0], op[1], op[2]);
9748 printf (" ss = 0x%x,", ss);
9749 printf (" rsrc = 0x%x,", rsrc);
9750 printf (" rdst = 0x%x\n", rdst);
9751 }
9752 SYNTAX("divu %1%S1, %0");
9753 #line 722 "rx-decode.opc"
9754 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
9755
9756 }
9757 break;
9758 }
9759 break;
9760 case 0x25:
9761 GETBYTE ();
9762 switch (op[2] & 0x00)
9763 {
9764 case 0x00:
9765 goto op_semantics_66;
9766 break;
9767 }
9768 break;
9769 case 0x26:
9770 GETBYTE ();
9771 switch (op[2] & 0x00)
9772 {
9773 case 0x00:
9774 goto op_semantics_66;
9775 break;
9776 }
9777 break;
9778 case 0x27:
9779 GETBYTE ();
9780 switch (op[2] & 0x00)
9781 {
9782 case 0x00:
9783 goto op_semantics_66;
9784 break;
9785 }
9786 break;
9787 case 0x30:
9788 GETBYTE ();
9789 switch (op[2] & 0x00)
9790 {
9791 case 0x00:
9792 op_semantics_67:
9793 {
9794 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
9795 #line 495 "rx-decode.opc"
9796 int ss AU = op[1] & 0x03;
9797 #line 495 "rx-decode.opc"
9798 int rsrc AU = (op[2] >> 4) & 0x0f;
9799 #line 495 "rx-decode.opc"
9800 int rdst AU = op[2] & 0x0f;
9801 if (trace)
9802 {
9803 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9804 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
9805 op[0], op[1], op[2]);
9806 printf (" ss = 0x%x,", ss);
9807 printf (" rsrc = 0x%x,", rsrc);
9808 printf (" rdst = 0x%x\n", rdst);
9809 }
9810 SYNTAX("tst %1%S1, %2");
9811 #line 495 "rx-decode.opc"
9812 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
9813
9814 }
9815 break;
9816 }
9817 break;
9818 case 0x31:
9819 GETBYTE ();
9820 switch (op[2] & 0x00)
9821 {
9822 case 0x00:
9823 goto op_semantics_67;
9824 break;
9825 }
9826 break;
9827 case 0x32:
9828 GETBYTE ();
9829 switch (op[2] & 0x00)
9830 {
9831 case 0x00:
9832 goto op_semantics_67;
9833 break;
9834 }
9835 break;
9836 case 0x33:
9837 GETBYTE ();
9838 switch (op[2] & 0x00)
9839 {
9840 case 0x00:
9841 goto op_semantics_67;
9842 break;
9843 }
9844 break;
9845 case 0x34:
9846 GETBYTE ();
9847 switch (op[2] & 0x00)
9848 {
9849 case 0x00:
9850 op_semantics_68:
9851 {
9852 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
9853 #line 474 "rx-decode.opc"
9854 int ss AU = op[1] & 0x03;
9855 #line 474 "rx-decode.opc"
9856 int rsrc AU = (op[2] >> 4) & 0x0f;
9857 #line 474 "rx-decode.opc"
9858 int rdst AU = op[2] & 0x0f;
9859 if (trace)
9860 {
9861 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9862 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
9863 op[0], op[1], op[2]);
9864 printf (" ss = 0x%x,", ss);
9865 printf (" rsrc = 0x%x,", rsrc);
9866 printf (" rdst = 0x%x\n", rdst);
9867 }
9868 SYNTAX("xor %1%S1, %0");
9869 #line 474 "rx-decode.opc"
9870 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
9871
9872 }
9873 break;
9874 }
9875 break;
9876 case 0x35:
9877 GETBYTE ();
9878 switch (op[2] & 0x00)
9879 {
9880 case 0x00:
9881 goto op_semantics_68;
9882 break;
9883 }
9884 break;
9885 case 0x36:
9886 GETBYTE ();
9887 switch (op[2] & 0x00)
9888 {
9889 case 0x00:
9890 goto op_semantics_68;
9891 break;
9892 }
9893 break;
9894 case 0x37:
9895 GETBYTE ();
9896 switch (op[2] & 0x00)
9897 {
9898 case 0x00:
9899 goto op_semantics_68;
9900 break;
9901 }
9902 break;
9903 case 0x3b:
9904 GETBYTE ();
9905 switch (op[2] & 0x00)
9906 {
9907 case 0x00:
9908 {
9909 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
9910 #line 486 "rx-decode.opc"
9911 int rsrc AU = (op[2] >> 4) & 0x0f;
9912 #line 486 "rx-decode.opc"
9913 int rdst AU = op[2] & 0x0f;
9914 if (trace)
9915 {
9916 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9917 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
9918 op[0], op[1], op[2]);
9919 printf (" rsrc = 0x%x,", rsrc);
9920 printf (" rdst = 0x%x\n", rdst);
9921 }
9922 SYNTAX("not %1, %0");
9923 #line 486 "rx-decode.opc"
9924 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
9925
9926 /*----------------------------------------------------------------------*/
9927 /* TST */
9928
9929 }
9930 break;
9931 }
9932 break;
9933 case 0x40:
9934 GETBYTE ();
9935 switch (op[2] & 0x00)
9936 {
9937 case 0x00:
9938 op_semantics_69:
9939 {
9940 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
9941 #line 408 "rx-decode.opc"
9942 int ss AU = op[1] & 0x03;
9943 #line 408 "rx-decode.opc"
9944 int rsrc AU = (op[2] >> 4) & 0x0f;
9945 #line 408 "rx-decode.opc"
9946 int rdst AU = op[2] & 0x0f;
9947 if (trace)
9948 {
9949 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9950 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
9951 op[0], op[1], op[2]);
9952 printf (" ss = 0x%x,", ss);
9953 printf (" rsrc = 0x%x,", rsrc);
9954 printf (" rdst = 0x%x\n", rdst);
9955 }
9956 SYNTAX("xchg %1%S1, %0");
9957 #line 408 "rx-decode.opc"
9958 ID(xchg); DR(rdst); SP(ss, rsrc);
9959
9960 }
9961 break;
9962 }
9963 break;
9964 case 0x41:
9965 GETBYTE ();
9966 switch (op[2] & 0x00)
9967 {
9968 case 0x00:
9969 goto op_semantics_69;
9970 break;
9971 }
9972 break;
9973 case 0x42:
9974 GETBYTE ();
9975 switch (op[2] & 0x00)
9976 {
9977 case 0x00:
9978 goto op_semantics_69;
9979 break;
9980 }
9981 break;
9982 case 0x43:
9983 GETBYTE ();
9984 switch (op[2] & 0x00)
9985 {
9986 case 0x00:
9987 goto op_semantics_69;
9988 break;
9989 }
9990 break;
9991 case 0x44:
9992 GETBYTE ();
9993 switch (op[2] & 0x00)
9994 {
9995 case 0x00:
9996 op_semantics_70:
9997 {
9998 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
9999 #line 951 "rx-decode.opc"
10000 int sd AU = op[1] & 0x03;
10001 #line 951 "rx-decode.opc"
10002 int rsrc AU = (op[2] >> 4) & 0x0f;
10003 #line 951 "rx-decode.opc"
10004 int rdst AU = op[2] & 0x0f;
10005 if (trace)
10006 {
10007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10008 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
10009 op[0], op[1], op[2]);
10010 printf (" sd = 0x%x,", sd);
10011 printf (" rsrc = 0x%x,", rsrc);
10012 printf (" rdst = 0x%x\n", rdst);
10013 }
10014 SYNTAX("itof %1%S1, %0");
10015 #line 951 "rx-decode.opc"
10016 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
10017
10018 }
10019 break;
10020 }
10021 break;
10022 case 0x45:
10023 GETBYTE ();
10024 switch (op[2] & 0x00)
10025 {
10026 case 0x00:
10027 goto op_semantics_70;
10028 break;
10029 }
10030 break;
10031 case 0x46:
10032 GETBYTE ();
10033 switch (op[2] & 0x00)
10034 {
10035 case 0x00:
10036 goto op_semantics_70;
10037 break;
10038 }
10039 break;
10040 case 0x47:
10041 GETBYTE ();
10042 switch (op[2] & 0x00)
10043 {
10044 case 0x00:
10045 goto op_semantics_70;
10046 break;
10047 }
10048 break;
10049 case 0x4b:
10050 GETBYTE ();
10051 switch (op[2] & 0x00)
10052 {
10053 case 0x00:
10054 {
10055 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
10056 #line 1077 "rx-decode.opc"
10057 int rsrc AU = (op[2] >> 4) & 0x0f;
10058 #line 1077 "rx-decode.opc"
10059 int rdst AU = op[2] & 0x0f;
10060 if (trace)
10061 {
10062 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10063 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
10064 op[0], op[1], op[2]);
10065 printf (" rsrc = 0x%x,", rsrc);
10066 printf (" rdst = 0x%x\n", rdst);
10067 }
10068 SYNTAX("stz %1, %0");
10069 #line 1077 "rx-decode.opc"
10070 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
10071
10072 }
10073 break;
10074 }
10075 break;
10076 case 0x4f:
10077 GETBYTE ();
10078 switch (op[2] & 0x00)
10079 {
10080 case 0x00:
10081 {
10082 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
10083 #line 1080 "rx-decode.opc"
10084 int rsrc AU = (op[2] >> 4) & 0x0f;
10085 #line 1080 "rx-decode.opc"
10086 int rdst AU = op[2] & 0x0f;
10087 if (trace)
10088 {
10089 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10090 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
10091 op[0], op[1], op[2]);
10092 printf (" rsrc = 0x%x,", rsrc);
10093 printf (" rdst = 0x%x\n", rdst);
10094 }
10095 SYNTAX("stnz %1, %0");
10096 #line 1080 "rx-decode.opc"
10097 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
10098
10099 }
10100 break;
10101 }
10102 break;
10103 case 0x54:
10104 GETBYTE ();
10105 switch (op[2] & 0x00)
10106 {
10107 case 0x00:
10108 op_semantics_71:
10109 {
10110 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
10111 #line 1137 "rx-decode.opc"
10112 int sd AU = op[1] & 0x03;
10113 #line 1137 "rx-decode.opc"
10114 int rsrc AU = (op[2] >> 4) & 0x0f;
10115 #line 1137 "rx-decode.opc"
10116 int rdst AU = op[2] & 0x0f;
10117 if (trace)
10118 {
10119 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10120 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
10121 op[0], op[1], op[2]);
10122 printf (" sd = 0x%x,", sd);
10123 printf (" rsrc = 0x%x,", rsrc);
10124 printf (" rdst = 0x%x\n", rdst);
10125 }
10126 SYNTAX("utof %1%S1, %0");
10127 #line 1137 "rx-decode.opc"
10128 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
10129
10130 }
10131 break;
10132 }
10133 break;
10134 case 0x55:
10135 GETBYTE ();
10136 switch (op[2] & 0x00)
10137 {
10138 case 0x00:
10139 goto op_semantics_71;
10140 break;
10141 }
10142 break;
10143 case 0x56:
10144 GETBYTE ();
10145 switch (op[2] & 0x00)
10146 {
10147 case 0x00:
10148 goto op_semantics_71;
10149 break;
10150 }
10151 break;
10152 case 0x57:
10153 GETBYTE ();
10154 switch (op[2] & 0x00)
10155 {
10156 case 0x00:
10157 goto op_semantics_71;
10158 break;
10159 }
10160 break;
10161 case 0x5a:
10162 GETBYTE ();
10163 switch (op[2] & 0x00)
10164 {
10165 case 0x00:
10166 {
10167 /** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */
10168 #line 1152 "rx-decode.opc"
10169 int rsrc AU = (op[2] >> 4) & 0x0f;
10170 #line 1152 "rx-decode.opc"
10171 int rdst AU = op[2] & 0x0f;
10172 if (trace)
10173 {
10174 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10175 "/** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */",
10176 op[0], op[1], op[2]);
10177 printf (" rsrc = 0x%x,", rsrc);
10178 printf (" rdst = 0x%x\n", rdst);
10179 }
10180 SYNTAX("bfmovz %bf");
10181 #line 1152 "rx-decode.opc"
10182 ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10183
10184 }
10185 break;
10186 }
10187 break;
10188 case 0x5e:
10189 GETBYTE ();
10190 switch (op[2] & 0x00)
10191 {
10192 case 0x00:
10193 {
10194 /** 1111 1100 0101 1110 rsrc rdst bfmov %bf */
10195 #line 1149 "rx-decode.opc"
10196 int rsrc AU = (op[2] >> 4) & 0x0f;
10197 #line 1149 "rx-decode.opc"
10198 int rdst AU = op[2] & 0x0f;
10199 if (trace)
10200 {
10201 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10202 "/** 1111 1100 0101 1110 rsrc rdst bfmov %bf */",
10203 op[0], op[1], op[2]);
10204 printf (" rsrc = 0x%x,", rsrc);
10205 printf (" rdst = 0x%x\n", rdst);
10206 }
10207 SYNTAX("bfmov %bf");
10208 #line 1149 "rx-decode.opc"
10209 ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10210
10211 }
10212 break;
10213 }
10214 break;
10215 case 0x60:
10216 GETBYTE ();
10217 switch (op[2] & 0x00)
10218 {
10219 case 0x00:
10220 op_semantics_72:
10221 {
10222 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
10223 #line 963 "rx-decode.opc"
10224 int sd AU = op[1] & 0x03;
10225 #line 963 "rx-decode.opc"
10226 int rdst AU = (op[2] >> 4) & 0x0f;
10227 #line 963 "rx-decode.opc"
10228 int rsrc AU = op[2] & 0x0f;
10229 if (trace)
10230 {
10231 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10232 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
10233 op[0], op[1], op[2]);
10234 printf (" sd = 0x%x,", sd);
10235 printf (" rdst = 0x%x,", rdst);
10236 printf (" rsrc = 0x%x\n", rsrc);
10237 }
10238 SYNTAX("bset %1, %0%S0");
10239 #line 963 "rx-decode.opc"
10240 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10241 if (sd == 3) /* bset reg,reg */
10242 BWL(LSIZE);
10243
10244 }
10245 break;
10246 }
10247 break;
10248 case 0x61:
10249 GETBYTE ();
10250 switch (op[2] & 0x00)
10251 {
10252 case 0x00:
10253 goto op_semantics_72;
10254 break;
10255 }
10256 break;
10257 case 0x62:
10258 GETBYTE ();
10259 switch (op[2] & 0x00)
10260 {
10261 case 0x00:
10262 goto op_semantics_72;
10263 break;
10264 }
10265 break;
10266 case 0x63:
10267 GETBYTE ();
10268 switch (op[2] & 0x00)
10269 {
10270 case 0x00:
10271 goto op_semantics_72;
10272 break;
10273 }
10274 break;
10275 case 0x64:
10276 GETBYTE ();
10277 switch (op[2] & 0x00)
10278 {
10279 case 0x00:
10280 op_semantics_73:
10281 {
10282 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
10283 #line 975 "rx-decode.opc"
10284 int sd AU = op[1] & 0x03;
10285 #line 975 "rx-decode.opc"
10286 int rdst AU = (op[2] >> 4) & 0x0f;
10287 #line 975 "rx-decode.opc"
10288 int rsrc AU = op[2] & 0x0f;
10289 if (trace)
10290 {
10291 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10292 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
10293 op[0], op[1], op[2]);
10294 printf (" sd = 0x%x,", sd);
10295 printf (" rdst = 0x%x,", rdst);
10296 printf (" rsrc = 0x%x\n", rsrc);
10297 }
10298 SYNTAX("bclr %1, %0%S0");
10299 #line 975 "rx-decode.opc"
10300 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10301 if (sd == 3) /* bset reg,reg */
10302 BWL(LSIZE);
10303
10304 }
10305 break;
10306 }
10307 break;
10308 case 0x65:
10309 GETBYTE ();
10310 switch (op[2] & 0x00)
10311 {
10312 case 0x00:
10313 goto op_semantics_73;
10314 break;
10315 }
10316 break;
10317 case 0x66:
10318 GETBYTE ();
10319 switch (op[2] & 0x00)
10320 {
10321 case 0x00:
10322 goto op_semantics_73;
10323 break;
10324 }
10325 break;
10326 case 0x67:
10327 GETBYTE ();
10328 switch (op[2] & 0x00)
10329 {
10330 case 0x00:
10331 goto op_semantics_73;
10332 break;
10333 }
10334 break;
10335 case 0x68:
10336 GETBYTE ();
10337 switch (op[2] & 0x00)
10338 {
10339 case 0x00:
10340 op_semantics_74:
10341 {
10342 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
10343 #line 987 "rx-decode.opc"
10344 int sd AU = op[1] & 0x03;
10345 #line 987 "rx-decode.opc"
10346 int rdst AU = (op[2] >> 4) & 0x0f;
10347 #line 987 "rx-decode.opc"
10348 int rsrc AU = op[2] & 0x0f;
10349 if (trace)
10350 {
10351 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10352 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
10353 op[0], op[1], op[2]);
10354 printf (" sd = 0x%x,", sd);
10355 printf (" rdst = 0x%x,", rdst);
10356 printf (" rsrc = 0x%x\n", rsrc);
10357 }
10358 SYNTAX("btst %2, %1%S1");
10359 #line 987 "rx-decode.opc"
10360 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
10361 if (sd == 3) /* bset reg,reg */
10362 BWL(LSIZE);
10363
10364 }
10365 break;
10366 }
10367 break;
10368 case 0x69:
10369 GETBYTE ();
10370 switch (op[2] & 0x00)
10371 {
10372 case 0x00:
10373 goto op_semantics_74;
10374 break;
10375 }
10376 break;
10377 case 0x6a:
10378 GETBYTE ();
10379 switch (op[2] & 0x00)
10380 {
10381 case 0x00:
10382 goto op_semantics_74;
10383 break;
10384 }
10385 break;
10386 case 0x6b:
10387 GETBYTE ();
10388 switch (op[2] & 0x00)
10389 {
10390 case 0x00:
10391 goto op_semantics_74;
10392 break;
10393 }
10394 break;
10395 case 0x6c:
10396 GETBYTE ();
10397 switch (op[2] & 0x00)
10398 {
10399 case 0x00:
10400 op_semantics_75:
10401 {
10402 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
10403 #line 999 "rx-decode.opc"
10404 int sd AU = op[1] & 0x03;
10405 #line 999 "rx-decode.opc"
10406 int rdst AU = (op[2] >> 4) & 0x0f;
10407 #line 999 "rx-decode.opc"
10408 int rsrc AU = op[2] & 0x0f;
10409 if (trace)
10410 {
10411 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10412 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
10413 op[0], op[1], op[2]);
10414 printf (" sd = 0x%x,", sd);
10415 printf (" rdst = 0x%x,", rdst);
10416 printf (" rsrc = 0x%x\n", rsrc);
10417 }
10418 SYNTAX("bnot %1, %0%S0");
10419 #line 999 "rx-decode.opc"
10420 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
10421 if (sd == 3) /* bset reg,reg */
10422 BWL(LSIZE);
10423
10424 }
10425 break;
10426 }
10427 break;
10428 case 0x6d:
10429 GETBYTE ();
10430 switch (op[2] & 0x00)
10431 {
10432 case 0x00:
10433 goto op_semantics_75;
10434 break;
10435 }
10436 break;
10437 case 0x6e:
10438 GETBYTE ();
10439 switch (op[2] & 0x00)
10440 {
10441 case 0x00:
10442 goto op_semantics_75;
10443 break;
10444 }
10445 break;
10446 case 0x6f:
10447 GETBYTE ();
10448 switch (op[2] & 0x00)
10449 {
10450 case 0x00:
10451 goto op_semantics_75;
10452 break;
10453 }
10454 break;
10455 case 0x78:
10456 GETBYTE ();
10457 switch (op[2] & 0x0f)
10458 {
10459 case 0x08:
10460 op_semantics_76:
10461 {
10462 /** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */
10463 #line 1185 "rx-decode.opc"
10464 int sz AU = op[1] & 0x03;
10465 #line 1185 "rx-decode.opc"
10466 int rdst AU = (op[2] >> 4) & 0x0f;
10467 if (trace)
10468 {
10469 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10470 "/** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */",
10471 op[0], op[1], op[2]);
10472 printf (" sz = 0x%x,", sz);
10473 printf (" rdst = 0x%x\n", rdst);
10474 }
10475 SYNTAX("dmov.d %1, %0");
10476 #line 1185 "rx-decode.opc"
10477 int rsrc;
10478 rx_disp(0, sz, rdst, RX_Double, ld);
10479 rsrc = GETBYTE();
10480 if (rsrc & 0x0f)
10481 UNSUPPORTED();
10482 else {
10483 ID(dmov); SDR(rsrc >> 4); F_____;
10484 }
10485
10486 }
10487 break;
10488 default: UNSUPPORTED(); break;
10489 }
10490 break;
10491 case 0x79:
10492 GETBYTE ();
10493 switch (op[2] & 0x0f)
10494 {
10495 case 0x08:
10496 goto op_semantics_76;
10497 break;
10498 default: UNSUPPORTED(); break;
10499 }
10500 break;
10501 case 0x7a:
10502 GETBYTE ();
10503 switch (op[2] & 0x0f)
10504 {
10505 case 0x08:
10506 goto op_semantics_76;
10507 break;
10508 default: UNSUPPORTED(); break;
10509 }
10510 break;
10511 case 0x80:
10512 GETBYTE ();
10513 switch (op[2] & 0x00)
10514 {
10515 case 0x00:
10516 op_semantics_77:
10517 {
10518 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
10519 #line 930 "rx-decode.opc"
10520 int sd AU = op[1] & 0x03;
10521 #line 930 "rx-decode.opc"
10522 int rsrc AU = (op[2] >> 4) & 0x0f;
10523 #line 930 "rx-decode.opc"
10524 int rdst AU = op[2] & 0x0f;
10525 if (trace)
10526 {
10527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10528 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
10529 op[0], op[1], op[2]);
10530 printf (" sd = 0x%x,", sd);
10531 printf (" rsrc = 0x%x,", rsrc);
10532 printf (" rdst = 0x%x\n", rdst);
10533 }
10534 SYNTAX("fsub %1%S1, %0");
10535 #line 930 "rx-decode.opc"
10536 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10537
10538 }
10539 break;
10540 }
10541 break;
10542 case 0x81:
10543 GETBYTE ();
10544 switch (op[2] & 0x00)
10545 {
10546 case 0x00:
10547 goto op_semantics_77;
10548 break;
10549 }
10550 break;
10551 case 0x82:
10552 GETBYTE ();
10553 switch (op[2] & 0x00)
10554 {
10555 case 0x00:
10556 goto op_semantics_77;
10557 break;
10558 }
10559 break;
10560 case 0x83:
10561 GETBYTE ();
10562 switch (op[2] & 0x00)
10563 {
10564 case 0x00:
10565 goto op_semantics_77;
10566 break;
10567 }
10568 break;
10569 case 0x84:
10570 GETBYTE ();
10571 switch (op[2] & 0x00)
10572 {
10573 case 0x00:
10574 op_semantics_78:
10575 {
10576 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
10577 #line 924 "rx-decode.opc"
10578 int sd AU = op[1] & 0x03;
10579 #line 924 "rx-decode.opc"
10580 int rsrc AU = (op[2] >> 4) & 0x0f;
10581 #line 924 "rx-decode.opc"
10582 int rdst AU = op[2] & 0x0f;
10583 if (trace)
10584 {
10585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10586 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
10587 op[0], op[1], op[2]);
10588 printf (" sd = 0x%x,", sd);
10589 printf (" rsrc = 0x%x,", rsrc);
10590 printf (" rdst = 0x%x\n", rdst);
10591 }
10592 SYNTAX("fcmp %1%S1, %0");
10593 #line 924 "rx-decode.opc"
10594 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
10595
10596 }
10597 break;
10598 }
10599 break;
10600 case 0x85:
10601 GETBYTE ();
10602 switch (op[2] & 0x00)
10603 {
10604 case 0x00:
10605 goto op_semantics_78;
10606 break;
10607 }
10608 break;
10609 case 0x86:
10610 GETBYTE ();
10611 switch (op[2] & 0x00)
10612 {
10613 case 0x00:
10614 goto op_semantics_78;
10615 break;
10616 }
10617 break;
10618 case 0x87:
10619 GETBYTE ();
10620 switch (op[2] & 0x00)
10621 {
10622 case 0x00:
10623 goto op_semantics_78;
10624 break;
10625 }
10626 break;
10627 case 0x88:
10628 GETBYTE ();
10629 switch (op[2] & 0x00)
10630 {
10631 case 0x00:
10632 op_semantics_79:
10633 {
10634 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
10635 #line 918 "rx-decode.opc"
10636 int sd AU = op[1] & 0x03;
10637 #line 918 "rx-decode.opc"
10638 int rsrc AU = (op[2] >> 4) & 0x0f;
10639 #line 918 "rx-decode.opc"
10640 int rdst AU = op[2] & 0x0f;
10641 if (trace)
10642 {
10643 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10644 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
10645 op[0], op[1], op[2]);
10646 printf (" sd = 0x%x,", sd);
10647 printf (" rsrc = 0x%x,", rsrc);
10648 printf (" rdst = 0x%x\n", rdst);
10649 }
10650 SYNTAX("fadd %1%S1, %0");
10651 #line 918 "rx-decode.opc"
10652 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10653
10654 }
10655 break;
10656 }
10657 break;
10658 case 0x89:
10659 GETBYTE ();
10660 switch (op[2] & 0x00)
10661 {
10662 case 0x00:
10663 goto op_semantics_79;
10664 break;
10665 }
10666 break;
10667 case 0x8a:
10668 GETBYTE ();
10669 switch (op[2] & 0x00)
10670 {
10671 case 0x00:
10672 goto op_semantics_79;
10673 break;
10674 }
10675 break;
10676 case 0x8b:
10677 GETBYTE ();
10678 switch (op[2] & 0x00)
10679 {
10680 case 0x00:
10681 goto op_semantics_79;
10682 break;
10683 }
10684 break;
10685 case 0x8c:
10686 GETBYTE ();
10687 switch (op[2] & 0x00)
10688 {
10689 case 0x00:
10690 op_semantics_80:
10691 {
10692 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
10693 #line 939 "rx-decode.opc"
10694 int sd AU = op[1] & 0x03;
10695 #line 939 "rx-decode.opc"
10696 int rsrc AU = (op[2] >> 4) & 0x0f;
10697 #line 939 "rx-decode.opc"
10698 int rdst AU = op[2] & 0x0f;
10699 if (trace)
10700 {
10701 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10702 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
10703 op[0], op[1], op[2]);
10704 printf (" sd = 0x%x,", sd);
10705 printf (" rsrc = 0x%x,", rsrc);
10706 printf (" rdst = 0x%x\n", rdst);
10707 }
10708 SYNTAX("fmul %1%S1, %0");
10709 #line 939 "rx-decode.opc"
10710 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10711
10712 }
10713 break;
10714 }
10715 break;
10716 case 0x8d:
10717 GETBYTE ();
10718 switch (op[2] & 0x00)
10719 {
10720 case 0x00:
10721 goto op_semantics_80;
10722 break;
10723 }
10724 break;
10725 case 0x8e:
10726 GETBYTE ();
10727 switch (op[2] & 0x00)
10728 {
10729 case 0x00:
10730 goto op_semantics_80;
10731 break;
10732 }
10733 break;
10734 case 0x8f:
10735 GETBYTE ();
10736 switch (op[2] & 0x00)
10737 {
10738 case 0x00:
10739 goto op_semantics_80;
10740 break;
10741 }
10742 break;
10743 case 0x90:
10744 GETBYTE ();
10745 switch (op[2] & 0x00)
10746 {
10747 case 0x00:
10748 op_semantics_81:
10749 {
10750 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
10751 #line 945 "rx-decode.opc"
10752 int sd AU = op[1] & 0x03;
10753 #line 945 "rx-decode.opc"
10754 int rsrc AU = (op[2] >> 4) & 0x0f;
10755 #line 945 "rx-decode.opc"
10756 int rdst AU = op[2] & 0x0f;
10757 if (trace)
10758 {
10759 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10760 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
10761 op[0], op[1], op[2]);
10762 printf (" sd = 0x%x,", sd);
10763 printf (" rsrc = 0x%x,", rsrc);
10764 printf (" rdst = 0x%x\n", rdst);
10765 }
10766 SYNTAX("fdiv %1%S1, %0");
10767 #line 945 "rx-decode.opc"
10768 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10769
10770 }
10771 break;
10772 }
10773 break;
10774 case 0x91:
10775 GETBYTE ();
10776 switch (op[2] & 0x00)
10777 {
10778 case 0x00:
10779 goto op_semantics_81;
10780 break;
10781 }
10782 break;
10783 case 0x92:
10784 GETBYTE ();
10785 switch (op[2] & 0x00)
10786 {
10787 case 0x00:
10788 goto op_semantics_81;
10789 break;
10790 }
10791 break;
10792 case 0x93:
10793 GETBYTE ();
10794 switch (op[2] & 0x00)
10795 {
10796 case 0x00:
10797 goto op_semantics_81;
10798 break;
10799 }
10800 break;
10801 case 0x94:
10802 GETBYTE ();
10803 switch (op[2] & 0x00)
10804 {
10805 case 0x00:
10806 op_semantics_82:
10807 {
10808 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
10809 #line 933 "rx-decode.opc"
10810 int sd AU = op[1] & 0x03;
10811 #line 933 "rx-decode.opc"
10812 int rsrc AU = (op[2] >> 4) & 0x0f;
10813 #line 933 "rx-decode.opc"
10814 int rdst AU = op[2] & 0x0f;
10815 if (trace)
10816 {
10817 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10818 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
10819 op[0], op[1], op[2]);
10820 printf (" sd = 0x%x,", sd);
10821 printf (" rsrc = 0x%x,", rsrc);
10822 printf (" rdst = 0x%x\n", rdst);
10823 }
10824 SYNTAX("ftoi %1%S1, %0");
10825 #line 933 "rx-decode.opc"
10826 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10827
10828 }
10829 break;
10830 }
10831 break;
10832 case 0x95:
10833 GETBYTE ();
10834 switch (op[2] & 0x00)
10835 {
10836 case 0x00:
10837 goto op_semantics_82;
10838 break;
10839 }
10840 break;
10841 case 0x96:
10842 GETBYTE ();
10843 switch (op[2] & 0x00)
10844 {
10845 case 0x00:
10846 goto op_semantics_82;
10847 break;
10848 }
10849 break;
10850 case 0x97:
10851 GETBYTE ();
10852 switch (op[2] & 0x00)
10853 {
10854 case 0x00:
10855 goto op_semantics_82;
10856 break;
10857 }
10858 break;
10859 case 0x98:
10860 GETBYTE ();
10861 switch (op[2] & 0x00)
10862 {
10863 case 0x00:
10864 op_semantics_83:
10865 {
10866 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
10867 #line 948 "rx-decode.opc"
10868 int sd AU = op[1] & 0x03;
10869 #line 948 "rx-decode.opc"
10870 int rsrc AU = (op[2] >> 4) & 0x0f;
10871 #line 948 "rx-decode.opc"
10872 int rdst AU = op[2] & 0x0f;
10873 if (trace)
10874 {
10875 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10876 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
10877 op[0], op[1], op[2]);
10878 printf (" sd = 0x%x,", sd);
10879 printf (" rsrc = 0x%x,", rsrc);
10880 printf (" rdst = 0x%x\n", rdst);
10881 }
10882 SYNTAX("round %1%S1, %0");
10883 #line 948 "rx-decode.opc"
10884 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10885
10886 }
10887 break;
10888 }
10889 break;
10890 case 0x99:
10891 GETBYTE ();
10892 switch (op[2] & 0x00)
10893 {
10894 case 0x00:
10895 goto op_semantics_83;
10896 break;
10897 }
10898 break;
10899 case 0x9a:
10900 GETBYTE ();
10901 switch (op[2] & 0x00)
10902 {
10903 case 0x00:
10904 goto op_semantics_83;
10905 break;
10906 }
10907 break;
10908 case 0x9b:
10909 GETBYTE ();
10910 switch (op[2] & 0x00)
10911 {
10912 case 0x00:
10913 goto op_semantics_83;
10914 break;
10915 }
10916 break;
10917 case 0xa0:
10918 GETBYTE ();
10919 switch (op[2] & 0x00)
10920 {
10921 case 0x00:
10922 op_semantics_84:
10923 {
10924 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
10925 #line 1131 "rx-decode.opc"
10926 int sd AU = op[1] & 0x03;
10927 #line 1131 "rx-decode.opc"
10928 int rsrc AU = (op[2] >> 4) & 0x0f;
10929 #line 1131 "rx-decode.opc"
10930 int rdst AU = op[2] & 0x0f;
10931 if (trace)
10932 {
10933 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10934 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
10935 op[0], op[1], op[2]);
10936 printf (" sd = 0x%x,", sd);
10937 printf (" rsrc = 0x%x,", rsrc);
10938 printf (" rdst = 0x%x\n", rdst);
10939 }
10940 SYNTAX("fsqrt %1%S1, %0");
10941 #line 1131 "rx-decode.opc"
10942 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10943
10944 }
10945 break;
10946 }
10947 break;
10948 case 0xa1:
10949 GETBYTE ();
10950 switch (op[2] & 0x00)
10951 {
10952 case 0x00:
10953 goto op_semantics_84;
10954 break;
10955 }
10956 break;
10957 case 0xa2:
10958 GETBYTE ();
10959 switch (op[2] & 0x00)
10960 {
10961 case 0x00:
10962 goto op_semantics_84;
10963 break;
10964 }
10965 break;
10966 case 0xa3:
10967 GETBYTE ();
10968 switch (op[2] & 0x00)
10969 {
10970 case 0x00:
10971 goto op_semantics_84;
10972 break;
10973 }
10974 break;
10975 case 0xa4:
10976 GETBYTE ();
10977 switch (op[2] & 0x00)
10978 {
10979 case 0x00:
10980 op_semantics_85:
10981 {
10982 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
10983 #line 1134 "rx-decode.opc"
10984 int sd AU = op[1] & 0x03;
10985 #line 1134 "rx-decode.opc"
10986 int rsrc AU = (op[2] >> 4) & 0x0f;
10987 #line 1134 "rx-decode.opc"
10988 int rdst AU = op[2] & 0x0f;
10989 if (trace)
10990 {
10991 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10992 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
10993 op[0], op[1], op[2]);
10994 printf (" sd = 0x%x,", sd);
10995 printf (" rsrc = 0x%x,", rsrc);
10996 printf (" rdst = 0x%x\n", rdst);
10997 }
10998 SYNTAX("ftou %1%S1, %0");
10999 #line 1134 "rx-decode.opc"
11000 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
11001
11002 }
11003 break;
11004 }
11005 break;
11006 case 0xa5:
11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11009 {
11010 case 0x00:
11011 goto op_semantics_85;
11012 break;
11013 }
11014 break;
11015 case 0xa6:
11016 GETBYTE ();
11017 switch (op[2] & 0x00)
11018 {
11019 case 0x00:
11020 goto op_semantics_85;
11021 break;
11022 }
11023 break;
11024 case 0xa7:
11025 GETBYTE ();
11026 switch (op[2] & 0x00)
11027 {
11028 case 0x00:
11029 goto op_semantics_85;
11030 break;
11031 }
11032 break;
11033 case 0xc8:
11034 GETBYTE ();
11035 switch (op[2] & 0x0f)
11036 {
11037 case 0x08:
11038 op_semantics_86:
11039 {
11040 /** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */
11041 #line 1198 "rx-decode.opc"
11042 int sz AU = op[1] & 0x03;
11043 #line 1198 "rx-decode.opc"
11044 int rsrc AU = (op[2] >> 4) & 0x0f;
11045 if (trace)
11046 {
11047 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11048 "/** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */",
11049 op[0], op[1], op[2]);
11050 printf (" sz = 0x%x,", sz);
11051 printf (" rsrc = 0x%x\n", rsrc);
11052 }
11053 SYNTAX("dmov.d %1, %0");
11054 #line 1198 "rx-decode.opc"
11055 int rdst;
11056 rx_disp(1, sz, rsrc, RX_Double, ld);
11057 rdst = GETBYTE();
11058 if (rdst & 0x0f)
11059 UNSUPPORTED();
11060 else {
11061 ID(dmov); DDR(rdst >> 4); F_____;
11062 }
11063
11064 }
11065 break;
11066 default: UNSUPPORTED(); break;
11067 }
11068 break;
11069 case 0xc9:
11070 GETBYTE ();
11071 switch (op[2] & 0x0f)
11072 {
11073 case 0x08:
11074 goto op_semantics_86;
11075 break;
11076 default: UNSUPPORTED(); break;
11077 }
11078 break;
11079 case 0xca:
11080 GETBYTE ();
11081 switch (op[2] & 0x0f)
11082 {
11083 case 0x08:
11084 goto op_semantics_86;
11085 break;
11086 default: UNSUPPORTED(); break;
11087 }
11088 break;
11089 case 0xd0:
11090 GETBYTE ();
11091 switch (op[2] & 0x00)
11092 {
11093 case 0x00:
11094 op_semantics_87:
11095 {
11096 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
11097 #line 1065 "rx-decode.opc"
11098 int sz AU = (op[1] >> 2) & 0x03;
11099 #line 1065 "rx-decode.opc"
11100 int sd AU = op[1] & 0x03;
11101 #line 1065 "rx-decode.opc"
11102 int rdst AU = (op[2] >> 4) & 0x0f;
11103 #line 1065 "rx-decode.opc"
11104 int cond AU = op[2] & 0x0f;
11105 if (trace)
11106 {
11107 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11108 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
11109 op[0], op[1], op[2]);
11110 printf (" sz = 0x%x,", sz);
11111 printf (" sd = 0x%x,", sd);
11112 printf (" rdst = 0x%x,", rdst);
11113 printf (" cond = 0x%x\n", cond);
11114 }
11115 SYNTAX("sc%1%s %0");
11116 #line 1065 "rx-decode.opc"
11117 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
11118
11119 /*----------------------------------------------------------------------*/
11120 /* RXv2 enhanced */
11121
11122 }
11123 break;
11124 }
11125 break;
11126 case 0xd1:
11127 GETBYTE ();
11128 switch (op[2] & 0x00)
11129 {
11130 case 0x00:
11131 goto op_semantics_87;
11132 break;
11133 }
11134 break;
11135 case 0xd2:
11136 GETBYTE ();
11137 switch (op[2] & 0x00)
11138 {
11139 case 0x00:
11140 goto op_semantics_87;
11141 break;
11142 }
11143 break;
11144 case 0xd3:
11145 GETBYTE ();
11146 switch (op[2] & 0x00)
11147 {
11148 case 0x00:
11149 goto op_semantics_87;
11150 break;
11151 }
11152 break;
11153 case 0xd4:
11154 GETBYTE ();
11155 switch (op[2] & 0x00)
11156 {
11157 case 0x00:
11158 goto op_semantics_87;
11159 break;
11160 }
11161 break;
11162 case 0xd5:
11163 GETBYTE ();
11164 switch (op[2] & 0x00)
11165 {
11166 case 0x00:
11167 goto op_semantics_87;
11168 break;
11169 }
11170 break;
11171 case 0xd6:
11172 GETBYTE ();
11173 switch (op[2] & 0x00)
11174 {
11175 case 0x00:
11176 goto op_semantics_87;
11177 break;
11178 }
11179 break;
11180 case 0xd7:
11181 GETBYTE ();
11182 switch (op[2] & 0x00)
11183 {
11184 case 0x00:
11185 goto op_semantics_87;
11186 break;
11187 }
11188 break;
11189 case 0xd8:
11190 GETBYTE ();
11191 switch (op[2] & 0x00)
11192 {
11193 case 0x00:
11194 goto op_semantics_87;
11195 break;
11196 }
11197 break;
11198 case 0xd9:
11199 GETBYTE ();
11200 switch (op[2] & 0x00)
11201 {
11202 case 0x00:
11203 goto op_semantics_87;
11204 break;
11205 }
11206 break;
11207 case 0xda:
11208 GETBYTE ();
11209 switch (op[2] & 0x00)
11210 {
11211 case 0x00:
11212 goto op_semantics_87;
11213 break;
11214 }
11215 break;
11216 case 0xdb:
11217 GETBYTE ();
11218 switch (op[2] & 0x00)
11219 {
11220 case 0x00:
11221 goto op_semantics_87;
11222 break;
11223 }
11224 break;
11225 case 0xe0:
11226 GETBYTE ();
11227 switch (op[2] & 0x0f)
11228 {
11229 case 0x00:
11230 case 0x01:
11231 case 0x02:
11232 case 0x03:
11233 case 0x04:
11234 case 0x05:
11235 case 0x06:
11236 case 0x07:
11237 case 0x08:
11238 case 0x09:
11239 case 0x0a:
11240 case 0x0b:
11241 case 0x0c:
11242 case 0x0d:
11243 case 0x0e:
11244 op_semantics_88:
11245 {
11246 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
11247 #line 1008 "rx-decode.opc"
11248 int bit AU = (op[1] >> 2) & 0x07;
11249 #line 1008 "rx-decode.opc"
11250 int sd AU = op[1] & 0x03;
11251 #line 1008 "rx-decode.opc"
11252 int rdst AU = (op[2] >> 4) & 0x0f;
11253 #line 1008 "rx-decode.opc"
11254 int cond AU = op[2] & 0x0f;
11255 if (trace)
11256 {
11257 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11258 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
11259 op[0], op[1], op[2]);
11260 printf (" bit = 0x%x,", bit);
11261 printf (" sd = 0x%x,", sd);
11262 printf (" rdst = 0x%x,", rdst);
11263 printf (" cond = 0x%x\n", cond);
11264 }
11265 SYNTAX("bm%2 #%1, %0%S0");
11266 #line 1008 "rx-decode.opc"
11267 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
11268
11269 }
11270 break;
11271 case 0x0f:
11272 op_semantics_89:
11273 {
11274 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
11275 #line 996 "rx-decode.opc"
11276 int bit AU = (op[1] >> 2) & 0x07;
11277 #line 996 "rx-decode.opc"
11278 int sd AU = op[1] & 0x03;
11279 #line 996 "rx-decode.opc"
11280 int rdst AU = (op[2] >> 4) & 0x0f;
11281 if (trace)
11282 {
11283 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11284 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
11285 op[0], op[1], op[2]);
11286 printf (" bit = 0x%x,", bit);
11287 printf (" sd = 0x%x,", sd);
11288 printf (" rdst = 0x%x\n", rdst);
11289 }
11290 SYNTAX("bnot #%1, %0%S0");
11291 #line 996 "rx-decode.opc"
11292 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
11293
11294 }
11295 break;
11296 }
11297 break;
11298 case 0xe1:
11299 GETBYTE ();
11300 switch (op[2] & 0x0f)
11301 {
11302 case 0x00:
11303 case 0x01:
11304 case 0x02:
11305 case 0x03:
11306 case 0x04:
11307 case 0x05:
11308 case 0x06:
11309 case 0x07:
11310 case 0x08:
11311 case 0x09:
11312 case 0x0a:
11313 case 0x0b:
11314 case 0x0c:
11315 case 0x0d:
11316 case 0x0e:
11317 goto op_semantics_88;
11318 break;
11319 case 0x0f:
11320 goto op_semantics_89;
11321 break;
11322 }
11323 break;
11324 case 0xe2:
11325 GETBYTE ();
11326 switch (op[2] & 0x0f)
11327 {
11328 case 0x00:
11329 case 0x01:
11330 case 0x02:
11331 case 0x03:
11332 case 0x04:
11333 case 0x05:
11334 case 0x06:
11335 case 0x07:
11336 case 0x08:
11337 case 0x09:
11338 case 0x0a:
11339 case 0x0b:
11340 case 0x0c:
11341 case 0x0d:
11342 case 0x0e:
11343 goto op_semantics_88;
11344 break;
11345 case 0x0f:
11346 goto op_semantics_89;
11347 break;
11348 }
11349 break;
11350 case 0xe3:
11351 GETBYTE ();
11352 switch (op[2] & 0x0f)
11353 {
11354 case 0x00:
11355 case 0x01:
11356 case 0x02:
11357 case 0x03:
11358 case 0x04:
11359 case 0x05:
11360 case 0x06:
11361 case 0x07:
11362 case 0x08:
11363 case 0x09:
11364 case 0x0a:
11365 case 0x0b:
11366 case 0x0c:
11367 case 0x0d:
11368 case 0x0e:
11369 goto op_semantics_88;
11370 break;
11371 case 0x0f:
11372 goto op_semantics_89;
11373 break;
11374 }
11375 break;
11376 case 0xe4:
11377 GETBYTE ();
11378 switch (op[2] & 0x0f)
11379 {
11380 case 0x00:
11381 case 0x01:
11382 case 0x02:
11383 case 0x03:
11384 case 0x04:
11385 case 0x05:
11386 case 0x06:
11387 case 0x07:
11388 case 0x08:
11389 case 0x09:
11390 case 0x0a:
11391 case 0x0b:
11392 case 0x0c:
11393 case 0x0d:
11394 case 0x0e:
11395 goto op_semantics_88;
11396 break;
11397 case 0x0f:
11398 goto op_semantics_89;
11399 break;
11400 }
11401 break;
11402 case 0xe5:
11403 GETBYTE ();
11404 switch (op[2] & 0x0f)
11405 {
11406 case 0x00:
11407 case 0x01:
11408 case 0x02:
11409 case 0x03:
11410 case 0x04:
11411 case 0x05:
11412 case 0x06:
11413 case 0x07:
11414 case 0x08:
11415 case 0x09:
11416 case 0x0a:
11417 case 0x0b:
11418 case 0x0c:
11419 case 0x0d:
11420 case 0x0e:
11421 goto op_semantics_88;
11422 break;
11423 case 0x0f:
11424 goto op_semantics_89;
11425 break;
11426 }
11427 break;
11428 case 0xe6:
11429 GETBYTE ();
11430 switch (op[2] & 0x0f)
11431 {
11432 case 0x00:
11433 case 0x01:
11434 case 0x02:
11435 case 0x03:
11436 case 0x04:
11437 case 0x05:
11438 case 0x06:
11439 case 0x07:
11440 case 0x08:
11441 case 0x09:
11442 case 0x0a:
11443 case 0x0b:
11444 case 0x0c:
11445 case 0x0d:
11446 case 0x0e:
11447 goto op_semantics_88;
11448 break;
11449 case 0x0f:
11450 goto op_semantics_89;
11451 break;
11452 }
11453 break;
11454 case 0xe7:
11455 GETBYTE ();
11456 switch (op[2] & 0x0f)
11457 {
11458 case 0x00:
11459 case 0x01:
11460 case 0x02:
11461 case 0x03:
11462 case 0x04:
11463 case 0x05:
11464 case 0x06:
11465 case 0x07:
11466 case 0x08:
11467 case 0x09:
11468 case 0x0a:
11469 case 0x0b:
11470 case 0x0c:
11471 case 0x0d:
11472 case 0x0e:
11473 goto op_semantics_88;
11474 break;
11475 case 0x0f:
11476 goto op_semantics_89;
11477 break;
11478 }
11479 break;
11480 case 0xe8:
11481 GETBYTE ();
11482 switch (op[2] & 0x0f)
11483 {
11484 case 0x00:
11485 case 0x01:
11486 case 0x02:
11487 case 0x03:
11488 case 0x04:
11489 case 0x05:
11490 case 0x06:
11491 case 0x07:
11492 case 0x08:
11493 case 0x09:
11494 case 0x0a:
11495 case 0x0b:
11496 case 0x0c:
11497 case 0x0d:
11498 case 0x0e:
11499 goto op_semantics_88;
11500 break;
11501 case 0x0f:
11502 goto op_semantics_89;
11503 break;
11504 }
11505 break;
11506 case 0xe9:
11507 GETBYTE ();
11508 switch (op[2] & 0x0f)
11509 {
11510 case 0x00:
11511 case 0x01:
11512 case 0x02:
11513 case 0x03:
11514 case 0x04:
11515 case 0x05:
11516 case 0x06:
11517 case 0x07:
11518 case 0x08:
11519 case 0x09:
11520 case 0x0a:
11521 case 0x0b:
11522 case 0x0c:
11523 case 0x0d:
11524 case 0x0e:
11525 goto op_semantics_88;
11526 break;
11527 case 0x0f:
11528 goto op_semantics_89;
11529 break;
11530 }
11531 break;
11532 case 0xea:
11533 GETBYTE ();
11534 switch (op[2] & 0x0f)
11535 {
11536 case 0x00:
11537 case 0x01:
11538 case 0x02:
11539 case 0x03:
11540 case 0x04:
11541 case 0x05:
11542 case 0x06:
11543 case 0x07:
11544 case 0x08:
11545 case 0x09:
11546 case 0x0a:
11547 case 0x0b:
11548 case 0x0c:
11549 case 0x0d:
11550 case 0x0e:
11551 goto op_semantics_88;
11552 break;
11553 case 0x0f:
11554 goto op_semantics_89;
11555 break;
11556 }
11557 break;
11558 case 0xeb:
11559 GETBYTE ();
11560 switch (op[2] & 0x0f)
11561 {
11562 case 0x00:
11563 case 0x01:
11564 case 0x02:
11565 case 0x03:
11566 case 0x04:
11567 case 0x05:
11568 case 0x06:
11569 case 0x07:
11570 case 0x08:
11571 case 0x09:
11572 case 0x0a:
11573 case 0x0b:
11574 case 0x0c:
11575 case 0x0d:
11576 case 0x0e:
11577 goto op_semantics_88;
11578 break;
11579 case 0x0f:
11580 goto op_semantics_89;
11581 break;
11582 }
11583 break;
11584 case 0xec:
11585 GETBYTE ();
11586 switch (op[2] & 0x0f)
11587 {
11588 case 0x00:
11589 case 0x01:
11590 case 0x02:
11591 case 0x03:
11592 case 0x04:
11593 case 0x05:
11594 case 0x06:
11595 case 0x07:
11596 case 0x08:
11597 case 0x09:
11598 case 0x0a:
11599 case 0x0b:
11600 case 0x0c:
11601 case 0x0d:
11602 case 0x0e:
11603 goto op_semantics_88;
11604 break;
11605 case 0x0f:
11606 goto op_semantics_89;
11607 break;
11608 }
11609 break;
11610 case 0xed:
11611 GETBYTE ();
11612 switch (op[2] & 0x0f)
11613 {
11614 case 0x00:
11615 case 0x01:
11616 case 0x02:
11617 case 0x03:
11618 case 0x04:
11619 case 0x05:
11620 case 0x06:
11621 case 0x07:
11622 case 0x08:
11623 case 0x09:
11624 case 0x0a:
11625 case 0x0b:
11626 case 0x0c:
11627 case 0x0d:
11628 case 0x0e:
11629 goto op_semantics_88;
11630 break;
11631 case 0x0f:
11632 goto op_semantics_89;
11633 break;
11634 }
11635 break;
11636 case 0xee:
11637 GETBYTE ();
11638 switch (op[2] & 0x0f)
11639 {
11640 case 0x00:
11641 case 0x01:
11642 case 0x02:
11643 case 0x03:
11644 case 0x04:
11645 case 0x05:
11646 case 0x06:
11647 case 0x07:
11648 case 0x08:
11649 case 0x09:
11650 case 0x0a:
11651 case 0x0b:
11652 case 0x0c:
11653 case 0x0d:
11654 case 0x0e:
11655 goto op_semantics_88;
11656 break;
11657 case 0x0f:
11658 goto op_semantics_89;
11659 break;
11660 }
11661 break;
11662 case 0xef:
11663 GETBYTE ();
11664 switch (op[2] & 0x0f)
11665 {
11666 case 0x00:
11667 case 0x01:
11668 case 0x02:
11669 case 0x03:
11670 case 0x04:
11671 case 0x05:
11672 case 0x06:
11673 case 0x07:
11674 case 0x08:
11675 case 0x09:
11676 case 0x0a:
11677 case 0x0b:
11678 case 0x0c:
11679 case 0x0d:
11680 case 0x0e:
11681 goto op_semantics_88;
11682 break;
11683 case 0x0f:
11684 goto op_semantics_89;
11685 break;
11686 }
11687 break;
11688 case 0xf0:
11689 GETBYTE ();
11690 switch (op[2] & 0x0f)
11691 {
11692 case 0x00:
11693 case 0x01:
11694 case 0x02:
11695 case 0x03:
11696 case 0x04:
11697 case 0x05:
11698 case 0x06:
11699 case 0x07:
11700 case 0x08:
11701 case 0x09:
11702 case 0x0a:
11703 case 0x0b:
11704 case 0x0c:
11705 case 0x0d:
11706 case 0x0e:
11707 goto op_semantics_88;
11708 break;
11709 case 0x0f:
11710 goto op_semantics_89;
11711 break;
11712 }
11713 break;
11714 case 0xf1:
11715 GETBYTE ();
11716 switch (op[2] & 0x0f)
11717 {
11718 case 0x00:
11719 case 0x01:
11720 case 0x02:
11721 case 0x03:
11722 case 0x04:
11723 case 0x05:
11724 case 0x06:
11725 case 0x07:
11726 case 0x08:
11727 case 0x09:
11728 case 0x0a:
11729 case 0x0b:
11730 case 0x0c:
11731 case 0x0d:
11732 case 0x0e:
11733 goto op_semantics_88;
11734 break;
11735 case 0x0f:
11736 goto op_semantics_89;
11737 break;
11738 }
11739 break;
11740 case 0xf2:
11741 GETBYTE ();
11742 switch (op[2] & 0x0f)
11743 {
11744 case 0x00:
11745 case 0x01:
11746 case 0x02:
11747 case 0x03:
11748 case 0x04:
11749 case 0x05:
11750 case 0x06:
11751 case 0x07:
11752 case 0x08:
11753 case 0x09:
11754 case 0x0a:
11755 case 0x0b:
11756 case 0x0c:
11757 case 0x0d:
11758 case 0x0e:
11759 goto op_semantics_88;
11760 break;
11761 case 0x0f:
11762 goto op_semantics_89;
11763 break;
11764 }
11765 break;
11766 case 0xf3:
11767 GETBYTE ();
11768 switch (op[2] & 0x0f)
11769 {
11770 case 0x00:
11771 case 0x01:
11772 case 0x02:
11773 case 0x03:
11774 case 0x04:
11775 case 0x05:
11776 case 0x06:
11777 case 0x07:
11778 case 0x08:
11779 case 0x09:
11780 case 0x0a:
11781 case 0x0b:
11782 case 0x0c:
11783 case 0x0d:
11784 case 0x0e:
11785 goto op_semantics_88;
11786 break;
11787 case 0x0f:
11788 goto op_semantics_89;
11789 break;
11790 }
11791 break;
11792 case 0xf4:
11793 GETBYTE ();
11794 switch (op[2] & 0x0f)
11795 {
11796 case 0x00:
11797 case 0x01:
11798 case 0x02:
11799 case 0x03:
11800 case 0x04:
11801 case 0x05:
11802 case 0x06:
11803 case 0x07:
11804 case 0x08:
11805 case 0x09:
11806 case 0x0a:
11807 case 0x0b:
11808 case 0x0c:
11809 case 0x0d:
11810 case 0x0e:
11811 goto op_semantics_88;
11812 break;
11813 case 0x0f:
11814 goto op_semantics_89;
11815 break;
11816 }
11817 break;
11818 case 0xf5:
11819 GETBYTE ();
11820 switch (op[2] & 0x0f)
11821 {
11822 case 0x00:
11823 case 0x01:
11824 case 0x02:
11825 case 0x03:
11826 case 0x04:
11827 case 0x05:
11828 case 0x06:
11829 case 0x07:
11830 case 0x08:
11831 case 0x09:
11832 case 0x0a:
11833 case 0x0b:
11834 case 0x0c:
11835 case 0x0d:
11836 case 0x0e:
11837 goto op_semantics_88;
11838 break;
11839 case 0x0f:
11840 goto op_semantics_89;
11841 break;
11842 }
11843 break;
11844 case 0xf6:
11845 GETBYTE ();
11846 switch (op[2] & 0x0f)
11847 {
11848 case 0x00:
11849 case 0x01:
11850 case 0x02:
11851 case 0x03:
11852 case 0x04:
11853 case 0x05:
11854 case 0x06:
11855 case 0x07:
11856 case 0x08:
11857 case 0x09:
11858 case 0x0a:
11859 case 0x0b:
11860 case 0x0c:
11861 case 0x0d:
11862 case 0x0e:
11863 goto op_semantics_88;
11864 break;
11865 case 0x0f:
11866 goto op_semantics_89;
11867 break;
11868 }
11869 break;
11870 case 0xf7:
11871 GETBYTE ();
11872 switch (op[2] & 0x0f)
11873 {
11874 case 0x00:
11875 case 0x01:
11876 case 0x02:
11877 case 0x03:
11878 case 0x04:
11879 case 0x05:
11880 case 0x06:
11881 case 0x07:
11882 case 0x08:
11883 case 0x09:
11884 case 0x0a:
11885 case 0x0b:
11886 case 0x0c:
11887 case 0x0d:
11888 case 0x0e:
11889 goto op_semantics_88;
11890 break;
11891 case 0x0f:
11892 goto op_semantics_89;
11893 break;
11894 }
11895 break;
11896 case 0xf8:
11897 GETBYTE ();
11898 switch (op[2] & 0x0f)
11899 {
11900 case 0x00:
11901 case 0x01:
11902 case 0x02:
11903 case 0x03:
11904 case 0x04:
11905 case 0x05:
11906 case 0x06:
11907 case 0x07:
11908 case 0x08:
11909 case 0x09:
11910 case 0x0a:
11911 case 0x0b:
11912 case 0x0c:
11913 case 0x0d:
11914 case 0x0e:
11915 goto op_semantics_88;
11916 break;
11917 case 0x0f:
11918 goto op_semantics_89;
11919 break;
11920 }
11921 break;
11922 case 0xf9:
11923 GETBYTE ();
11924 switch (op[2] & 0x0f)
11925 {
11926 case 0x00:
11927 case 0x01:
11928 case 0x02:
11929 case 0x03:
11930 case 0x04:
11931 case 0x05:
11932 case 0x06:
11933 case 0x07:
11934 case 0x08:
11935 case 0x09:
11936 case 0x0a:
11937 case 0x0b:
11938 case 0x0c:
11939 case 0x0d:
11940 case 0x0e:
11941 goto op_semantics_88;
11942 break;
11943 case 0x0f:
11944 goto op_semantics_89;
11945 break;
11946 }
11947 break;
11948 case 0xfa:
11949 GETBYTE ();
11950 switch (op[2] & 0x0f)
11951 {
11952 case 0x00:
11953 case 0x01:
11954 case 0x02:
11955 case 0x03:
11956 case 0x04:
11957 case 0x05:
11958 case 0x06:
11959 case 0x07:
11960 case 0x08:
11961 case 0x09:
11962 case 0x0a:
11963 case 0x0b:
11964 case 0x0c:
11965 case 0x0d:
11966 case 0x0e:
11967 goto op_semantics_88;
11968 break;
11969 case 0x0f:
11970 goto op_semantics_89;
11971 break;
11972 }
11973 break;
11974 case 0xfb:
11975 GETBYTE ();
11976 switch (op[2] & 0x0f)
11977 {
11978 case 0x00:
11979 case 0x01:
11980 case 0x02:
11981 case 0x03:
11982 case 0x04:
11983 case 0x05:
11984 case 0x06:
11985 case 0x07:
11986 case 0x08:
11987 case 0x09:
11988 case 0x0a:
11989 case 0x0b:
11990 case 0x0c:
11991 case 0x0d:
11992 case 0x0e:
11993 goto op_semantics_88;
11994 break;
11995 case 0x0f:
11996 goto op_semantics_89;
11997 break;
11998 }
11999 break;
12000 case 0xfc:
12001 GETBYTE ();
12002 switch (op[2] & 0x0f)
12003 {
12004 case 0x00:
12005 case 0x01:
12006 case 0x02:
12007 case 0x03:
12008 case 0x04:
12009 case 0x05:
12010 case 0x06:
12011 case 0x07:
12012 case 0x08:
12013 case 0x09:
12014 case 0x0a:
12015 case 0x0b:
12016 case 0x0c:
12017 case 0x0d:
12018 case 0x0e:
12019 goto op_semantics_88;
12020 break;
12021 case 0x0f:
12022 goto op_semantics_89;
12023 break;
12024 }
12025 break;
12026 case 0xfd:
12027 GETBYTE ();
12028 switch (op[2] & 0x0f)
12029 {
12030 case 0x00:
12031 case 0x01:
12032 case 0x02:
12033 case 0x03:
12034 case 0x04:
12035 case 0x05:
12036 case 0x06:
12037 case 0x07:
12038 case 0x08:
12039 case 0x09:
12040 case 0x0a:
12041 case 0x0b:
12042 case 0x0c:
12043 case 0x0d:
12044 case 0x0e:
12045 goto op_semantics_88;
12046 break;
12047 case 0x0f:
12048 goto op_semantics_89;
12049 break;
12050 }
12051 break;
12052 case 0xfe:
12053 GETBYTE ();
12054 switch (op[2] & 0x0f)
12055 {
12056 case 0x00:
12057 case 0x01:
12058 case 0x02:
12059 case 0x03:
12060 case 0x04:
12061 case 0x05:
12062 case 0x06:
12063 case 0x07:
12064 case 0x08:
12065 case 0x09:
12066 case 0x0a:
12067 case 0x0b:
12068 case 0x0c:
12069 case 0x0d:
12070 case 0x0e:
12071 goto op_semantics_88;
12072 break;
12073 case 0x0f:
12074 goto op_semantics_89;
12075 break;
12076 }
12077 break;
12078 case 0xff:
12079 GETBYTE ();
12080 switch (op[2] & 0x0f)
12081 {
12082 case 0x00:
12083 case 0x01:
12084 case 0x02:
12085 case 0x03:
12086 case 0x04:
12087 case 0x05:
12088 case 0x06:
12089 case 0x07:
12090 case 0x08:
12091 case 0x09:
12092 case 0x0a:
12093 case 0x0b:
12094 case 0x0c:
12095 case 0x0d:
12096 case 0x0e:
12097 goto op_semantics_88;
12098 break;
12099 case 0x0f:
12100 goto op_semantics_89;
12101 break;
12102 }
12103 break;
12104 default: UNSUPPORTED(); break;
12105 }
12106 break;
12107 case 0xfd:
12108 GETBYTE ();
12109 switch (op[1] & 0xff)
12110 {
12111 case 0x00:
12112 GETBYTE ();
12113 switch (op[2] & 0x00)
12114 {
12115 case 0x00:
12116 op_semantics_90:
12117 {
12118 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
12119 #line 873 "rx-decode.opc"
12120 int a AU = (op[1] >> 3) & 0x01;
12121 #line 873 "rx-decode.opc"
12122 int srca AU = (op[2] >> 4) & 0x0f;
12123 #line 873 "rx-decode.opc"
12124 int srcb AU = op[2] & 0x0f;
12125 if (trace)
12126 {
12127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12128 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
12129 op[0], op[1], op[2]);
12130 printf (" a = 0x%x,", a);
12131 printf (" srca = 0x%x,", srca);
12132 printf (" srcb = 0x%x\n", srcb);
12133 }
12134 SYNTAX("mulhi %1, %2, %0");
12135 #line 873 "rx-decode.opc"
12136 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
12137
12138 }
12139 break;
12140 }
12141 break;
12142 case 0x01:
12143 GETBYTE ();
12144 switch (op[2] & 0x00)
12145 {
12146 case 0x00:
12147 op_semantics_91:
12148 {
12149 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
12150 #line 876 "rx-decode.opc"
12151 int a AU = (op[1] >> 3) & 0x01;
12152 #line 876 "rx-decode.opc"
12153 int srca AU = (op[2] >> 4) & 0x0f;
12154 #line 876 "rx-decode.opc"
12155 int srcb AU = op[2] & 0x0f;
12156 if (trace)
12157 {
12158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12159 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
12160 op[0], op[1], op[2]);
12161 printf (" a = 0x%x,", a);
12162 printf (" srca = 0x%x,", srca);
12163 printf (" srcb = 0x%x\n", srcb);
12164 }
12165 SYNTAX("mullo %1, %2, %0");
12166 #line 876 "rx-decode.opc"
12167 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
12168
12169 }
12170 break;
12171 }
12172 break;
12173 case 0x02:
12174 GETBYTE ();
12175 switch (op[2] & 0x00)
12176 {
12177 case 0x00:
12178 op_semantics_92:
12179 {
12180 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
12181 #line 1104 "rx-decode.opc"
12182 int a AU = (op[1] >> 3) & 0x01;
12183 #line 1104 "rx-decode.opc"
12184 int srca AU = (op[2] >> 4) & 0x0f;
12185 #line 1104 "rx-decode.opc"
12186 int srcb AU = op[2] & 0x0f;
12187 if (trace)
12188 {
12189 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12190 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
12191 op[0], op[1], op[2]);
12192 printf (" a = 0x%x,", a);
12193 printf (" srca = 0x%x,", srca);
12194 printf (" srcb = 0x%x\n", srcb);
12195 }
12196 SYNTAX("mullh %1, %2, %0");
12197 #line 1104 "rx-decode.opc"
12198 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
12199
12200 }
12201 break;
12202 }
12203 break;
12204 case 0x03:
12205 GETBYTE ();
12206 switch (op[2] & 0x00)
12207 {
12208 case 0x00:
12209 op_semantics_93:
12210 {
12211 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
12212 #line 1089 "rx-decode.opc"
12213 int a AU = (op[1] >> 3) & 0x01;
12214 #line 1089 "rx-decode.opc"
12215 int srca AU = (op[2] >> 4) & 0x0f;
12216 #line 1089 "rx-decode.opc"
12217 int srcb AU = op[2] & 0x0f;
12218 if (trace)
12219 {
12220 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12221 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
12222 op[0], op[1], op[2]);
12223 printf (" a = 0x%x,", a);
12224 printf (" srca = 0x%x,", srca);
12225 printf (" srcb = 0x%x\n", srcb);
12226 }
12227 SYNTAX("emula %1, %2, %0");
12228 #line 1089 "rx-decode.opc"
12229 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
12230
12231 }
12232 break;
12233 }
12234 break;
12235 case 0x04:
12236 GETBYTE ();
12237 switch (op[2] & 0x00)
12238 {
12239 case 0x00:
12240 op_semantics_94:
12241 {
12242 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
12243 #line 879 "rx-decode.opc"
12244 int a AU = (op[1] >> 3) & 0x01;
12245 #line 879 "rx-decode.opc"
12246 int srca AU = (op[2] >> 4) & 0x0f;
12247 #line 879 "rx-decode.opc"
12248 int srcb AU = op[2] & 0x0f;
12249 if (trace)
12250 {
12251 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12252 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
12253 op[0], op[1], op[2]);
12254 printf (" a = 0x%x,", a);
12255 printf (" srca = 0x%x,", srca);
12256 printf (" srcb = 0x%x\n", srcb);
12257 }
12258 SYNTAX("machi %1, %2, %0");
12259 #line 879 "rx-decode.opc"
12260 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
12261
12262 }
12263 break;
12264 }
12265 break;
12266 case 0x05:
12267 GETBYTE ();
12268 switch (op[2] & 0x00)
12269 {
12270 case 0x00:
12271 op_semantics_95:
12272 {
12273 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
12274 #line 882 "rx-decode.opc"
12275 int a AU = (op[1] >> 3) & 0x01;
12276 #line 882 "rx-decode.opc"
12277 int srca AU = (op[2] >> 4) & 0x0f;
12278 #line 882 "rx-decode.opc"
12279 int srcb AU = op[2] & 0x0f;
12280 if (trace)
12281 {
12282 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12283 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
12284 op[0], op[1], op[2]);
12285 printf (" a = 0x%x,", a);
12286 printf (" srca = 0x%x,", srca);
12287 printf (" srcb = 0x%x\n", srcb);
12288 }
12289 SYNTAX("maclo %1, %2, %0");
12290 #line 882 "rx-decode.opc"
12291 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
12292
12293 }
12294 break;
12295 }
12296 break;
12297 case 0x06:
12298 GETBYTE ();
12299 switch (op[2] & 0x00)
12300 {
12301 case 0x00:
12302 op_semantics_96:
12303 {
12304 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
12305 #line 1092 "rx-decode.opc"
12306 int a AU = (op[1] >> 3) & 0x01;
12307 #line 1092 "rx-decode.opc"
12308 int srca AU = (op[2] >> 4) & 0x0f;
12309 #line 1092 "rx-decode.opc"
12310 int srcb AU = op[2] & 0x0f;
12311 if (trace)
12312 {
12313 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12314 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
12315 op[0], op[1], op[2]);
12316 printf (" a = 0x%x,", a);
12317 printf (" srca = 0x%x,", srca);
12318 printf (" srcb = 0x%x\n", srcb);
12319 }
12320 SYNTAX("maclh %1, %2, %0");
12321 #line 1092 "rx-decode.opc"
12322 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
12323
12324 }
12325 break;
12326 }
12327 break;
12328 case 0x07:
12329 GETBYTE ();
12330 switch (op[2] & 0x00)
12331 {
12332 case 0x00:
12333 op_semantics_97:
12334 {
12335 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
12336 #line 1083 "rx-decode.opc"
12337 int a AU = (op[1] >> 3) & 0x01;
12338 #line 1083 "rx-decode.opc"
12339 int srca AU = (op[2] >> 4) & 0x0f;
12340 #line 1083 "rx-decode.opc"
12341 int srcb AU = op[2] & 0x0f;
12342 if (trace)
12343 {
12344 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12345 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
12346 op[0], op[1], op[2]);
12347 printf (" a = 0x%x,", a);
12348 printf (" srca = 0x%x,", srca);
12349 printf (" srcb = 0x%x\n", srcb);
12350 }
12351 SYNTAX("emaca %1, %2, %0");
12352 #line 1083 "rx-decode.opc"
12353 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
12354
12355 }
12356 break;
12357 }
12358 break;
12359 case 0x08:
12360 GETBYTE ();
12361 switch (op[2] & 0x00)
12362 {
12363 case 0x00:
12364 goto op_semantics_90;
12365 break;
12366 }
12367 break;
12368 case 0x09:
12369 GETBYTE ();
12370 switch (op[2] & 0x00)
12371 {
12372 case 0x00:
12373 goto op_semantics_91;
12374 break;
12375 }
12376 break;
12377 case 0x0a:
12378 GETBYTE ();
12379 switch (op[2] & 0x00)
12380 {
12381 case 0x00:
12382 goto op_semantics_92;
12383 break;
12384 }
12385 break;
12386 case 0x0b:
12387 GETBYTE ();
12388 switch (op[2] & 0x00)
12389 {
12390 case 0x00:
12391 goto op_semantics_93;
12392 break;
12393 }
12394 break;
12395 case 0x0c:
12396 GETBYTE ();
12397 switch (op[2] & 0x00)
12398 {
12399 case 0x00:
12400 goto op_semantics_94;
12401 break;
12402 }
12403 break;
12404 case 0x0d:
12405 GETBYTE ();
12406 switch (op[2] & 0x00)
12407 {
12408 case 0x00:
12409 goto op_semantics_95;
12410 break;
12411 }
12412 break;
12413 case 0x0e:
12414 GETBYTE ();
12415 switch (op[2] & 0x00)
12416 {
12417 case 0x00:
12418 goto op_semantics_96;
12419 break;
12420 }
12421 break;
12422 case 0x0f:
12423 GETBYTE ();
12424 switch (op[2] & 0x00)
12425 {
12426 case 0x00:
12427 goto op_semantics_97;
12428 break;
12429 }
12430 break;
12431 case 0x17:
12432 GETBYTE ();
12433 switch (op[2] & 0x70)
12434 {
12435 case 0x00:
12436 {
12437 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
12438 #line 885 "rx-decode.opc"
12439 int a AU = (op[2] >> 7) & 0x01;
12440 #line 885 "rx-decode.opc"
12441 int rsrc AU = op[2] & 0x0f;
12442 if (trace)
12443 {
12444 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12445 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
12446 op[0], op[1], op[2]);
12447 printf (" a = 0x%x,", a);
12448 printf (" rsrc = 0x%x\n", rsrc);
12449 }
12450 SYNTAX("mvtachi %1, %0");
12451 #line 885 "rx-decode.opc"
12452 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
12453
12454 }
12455 break;
12456 case 0x10:
12457 {
12458 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
12459 #line 888 "rx-decode.opc"
12460 int a AU = (op[2] >> 7) & 0x01;
12461 #line 888 "rx-decode.opc"
12462 int rsrc AU = op[2] & 0x0f;
12463 if (trace)
12464 {
12465 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12466 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
12467 op[0], op[1], op[2]);
12468 printf (" a = 0x%x,", a);
12469 printf (" rsrc = 0x%x\n", rsrc);
12470 }
12471 SYNTAX("mvtaclo %1, %0");
12472 #line 888 "rx-decode.opc"
12473 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
12474
12475 }
12476 break;
12477 case 0x30:
12478 {
12479 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
12480 #line 1110 "rx-decode.opc"
12481 int a AU = (op[2] >> 7) & 0x01;
12482 #line 1110 "rx-decode.opc"
12483 int rdst AU = op[2] & 0x0f;
12484 if (trace)
12485 {
12486 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12487 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
12488 op[0], op[1], op[2]);
12489 printf (" a = 0x%x,", a);
12490 printf (" rdst = 0x%x\n", rdst);
12491 }
12492 SYNTAX("mvtacgu %0, %1");
12493 #line 1110 "rx-decode.opc"
12494 ID(mvtacgu); DR(a+32); SR(rdst); F_____;
12495
12496 }
12497 break;
12498 default: UNSUPPORTED(); break;
12499 }
12500 break;
12501 case 0x18:
12502 GETBYTE ();
12503 switch (op[2] & 0x6f)
12504 {
12505 case 0x00:
12506 {
12507 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
12508 #line 900 "rx-decode.opc"
12509 int a AU = (op[2] >> 7) & 0x01;
12510 #line 900 "rx-decode.opc"
12511 int i AU = (op[2] >> 4) & 0x01;
12512 if (trace)
12513 {
12514 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12515 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
12516 op[0], op[1], op[2]);
12517 printf (" a = 0x%x,", a);
12518 printf (" i = 0x%x\n", i);
12519 }
12520 SYNTAX("racw #%1, %0");
12521 #line 900 "rx-decode.opc"
12522 ID(racw); SC(i+1); DR(a+32); F_____;
12523
12524 /*----------------------------------------------------------------------*/
12525 /* SAT */
12526
12527 }
12528 break;
12529 case 0x40:
12530 {
12531 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
12532 #line 1119 "rx-decode.opc"
12533 int a AU = (op[2] >> 7) & 0x01;
12534 #line 1119 "rx-decode.opc"
12535 int i AU = (op[2] >> 4) & 0x01;
12536 if (trace)
12537 {
12538 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12539 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
12540 op[0], op[1], op[2]);
12541 printf (" a = 0x%x,", a);
12542 printf (" i = 0x%x\n", i);
12543 }
12544 SYNTAX("rdacw #%1, %0");
12545 #line 1119 "rx-decode.opc"
12546 ID(rdacw); SC(i+1); DR(a+32); F_____;
12547
12548 }
12549 break;
12550 default: UNSUPPORTED(); break;
12551 }
12552 break;
12553 case 0x19:
12554 GETBYTE ();
12555 switch (op[2] & 0x6f)
12556 {
12557 case 0x00:
12558 {
12559 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
12560 #line 1113 "rx-decode.opc"
12561 int a AU = (op[2] >> 7) & 0x01;
12562 #line 1113 "rx-decode.opc"
12563 int i AU = (op[2] >> 4) & 0x01;
12564 if (trace)
12565 {
12566 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12567 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
12568 op[0], op[1], op[2]);
12569 printf (" a = 0x%x,", a);
12570 printf (" i = 0x%x\n", i);
12571 }
12572 SYNTAX("racl #%1, %0");
12573 #line 1113 "rx-decode.opc"
12574 ID(racl); SC(i+1); DR(a+32); F_____;
12575
12576 }
12577 break;
12578 case 0x40:
12579 {
12580 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
12581 #line 1116 "rx-decode.opc"
12582 int a AU = (op[2] >> 7) & 0x01;
12583 #line 1116 "rx-decode.opc"
12584 int i AU = (op[2] >> 4) & 0x01;
12585 if (trace)
12586 {
12587 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12588 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
12589 op[0], op[1], op[2]);
12590 printf (" a = 0x%x,", a);
12591 printf (" i = 0x%x\n", i);
12592 }
12593 SYNTAX("rdacl #%1, %0");
12594 #line 1116 "rx-decode.opc"
12595 ID(rdacl); SC(i+1); DR(a+32); F_____;
12596
12597 }
12598 break;
12599 default: UNSUPPORTED(); break;
12600 }
12601 break;
12602 case 0x1e:
12603 GETBYTE ();
12604 switch (op[2] & 0x30)
12605 {
12606 case 0x00:
12607 op_semantics_98:
12608 {
12609 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
12610 #line 891 "rx-decode.opc"
12611 int i AU = op[1] & 0x01;
12612 #line 891 "rx-decode.opc"
12613 int a AU = (op[2] >> 7) & 0x01;
12614 #line 891 "rx-decode.opc"
12615 int m AU = (op[2] >> 6) & 0x01;
12616 #line 891 "rx-decode.opc"
12617 int rdst AU = op[2] & 0x0f;
12618 if (trace)
12619 {
12620 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12621 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
12622 op[0], op[1], op[2]);
12623 printf (" i = 0x%x,", i);
12624 printf (" a = 0x%x,", a);
12625 printf (" m = 0x%x,", m);
12626 printf (" rdst = 0x%x\n", rdst);
12627 }
12628 SYNTAX("mvfachi #%2, %1, %0");
12629 #line 891 "rx-decode.opc"
12630 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12631
12632 }
12633 break;
12634 case 0x10:
12635 op_semantics_99:
12636 {
12637 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
12638 #line 897 "rx-decode.opc"
12639 int i AU = op[1] & 0x01;
12640 #line 897 "rx-decode.opc"
12641 int a AU = (op[2] >> 7) & 0x01;
12642 #line 897 "rx-decode.opc"
12643 int m AU = (op[2] >> 6) & 0x01;
12644 #line 897 "rx-decode.opc"
12645 int rdst AU = op[2] & 0x0f;
12646 if (trace)
12647 {
12648 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12649 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
12650 op[0], op[1], op[2]);
12651 printf (" i = 0x%x,", i);
12652 printf (" a = 0x%x,", a);
12653 printf (" m = 0x%x,", m);
12654 printf (" rdst = 0x%x\n", rdst);
12655 }
12656 SYNTAX("mvfaclo #%2, %1, %0");
12657 #line 897 "rx-decode.opc"
12658 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12659
12660 }
12661 break;
12662 case 0x20:
12663 op_semantics_100:
12664 {
12665 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
12666 #line 894 "rx-decode.opc"
12667 int i AU = op[1] & 0x01;
12668 #line 894 "rx-decode.opc"
12669 int a AU = (op[2] >> 7) & 0x01;
12670 #line 894 "rx-decode.opc"
12671 int m AU = (op[2] >> 6) & 0x01;
12672 #line 894 "rx-decode.opc"
12673 int rdst AU = op[2] & 0x0f;
12674 if (trace)
12675 {
12676 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12677 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
12678 op[0], op[1], op[2]);
12679 printf (" i = 0x%x,", i);
12680 printf (" a = 0x%x,", a);
12681 printf (" m = 0x%x,", m);
12682 printf (" rdst = 0x%x\n", rdst);
12683 }
12684 SYNTAX("mvfacmi #%2, %1, %0");
12685 #line 894 "rx-decode.opc"
12686 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12687
12688 }
12689 break;
12690 case 0x30:
12691 op_semantics_101:
12692 {
12693 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
12694 #line 1107 "rx-decode.opc"
12695 int i AU = op[1] & 0x01;
12696 #line 1107 "rx-decode.opc"
12697 int a AU = (op[2] >> 7) & 0x01;
12698 #line 1107 "rx-decode.opc"
12699 int m AU = (op[2] >> 6) & 0x01;
12700 #line 1107 "rx-decode.opc"
12701 int rdst AU = op[2] & 0x0f;
12702 if (trace)
12703 {
12704 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12705 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
12706 op[0], op[1], op[2]);
12707 printf (" i = 0x%x,", i);
12708 printf (" a = 0x%x,", a);
12709 printf (" m = 0x%x,", m);
12710 printf (" rdst = 0x%x\n", rdst);
12711 }
12712 SYNTAX("mvfacgu #%2, %1, %0");
12713 #line 1107 "rx-decode.opc"
12714 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12715
12716 }
12717 break;
12718 }
12719 break;
12720 case 0x1f:
12721 GETBYTE ();
12722 switch (op[2] & 0x30)
12723 {
12724 case 0x00:
12725 goto op_semantics_98;
12726 break;
12727 case 0x10:
12728 goto op_semantics_99;
12729 break;
12730 case 0x20:
12731 goto op_semantics_100;
12732 break;
12733 case 0x30:
12734 goto op_semantics_101;
12735 break;
12736 }
12737 break;
12738 case 0x20:
12739 GETBYTE ();
12740 switch (op[2] & 0x00)
12741 {
12742 case 0x00:
12743 op_semantics_102:
12744 {
12745 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
12746 #line 369 "rx-decode.opc"
12747 int p AU = (op[1] >> 2) & 0x01;
12748 #line 369 "rx-decode.opc"
12749 int sz AU = op[1] & 0x03;
12750 #line 369 "rx-decode.opc"
12751 int rdst AU = (op[2] >> 4) & 0x0f;
12752 #line 369 "rx-decode.opc"
12753 int rsrc AU = op[2] & 0x0f;
12754 if (trace)
12755 {
12756 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12757 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
12758 op[0], op[1], op[2]);
12759 printf (" p = 0x%x,", p);
12760 printf (" sz = 0x%x,", sz);
12761 printf (" rdst = 0x%x,", rdst);
12762 printf (" rsrc = 0x%x\n", rsrc);
12763 }
12764 SYNTAX("mov%s %1, %0");
12765 #line 369 "rx-decode.opc"
12766 ID(mov); sBWL (sz); SR(rsrc); F_____;
12767 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
12768
12769 }
12770 break;
12771 }
12772 break;
12773 case 0x21:
12774 GETBYTE ();
12775 switch (op[2] & 0x00)
12776 {
12777 case 0x00:
12778 goto op_semantics_102;
12779 break;
12780 }
12781 break;
12782 case 0x22:
12783 GETBYTE ();
12784 switch (op[2] & 0x00)
12785 {
12786 case 0x00:
12787 goto op_semantics_102;
12788 break;
12789 }
12790 break;
12791 case 0x24:
12792 GETBYTE ();
12793 switch (op[2] & 0x00)
12794 {
12795 case 0x00:
12796 goto op_semantics_102;
12797 break;
12798 }
12799 break;
12800 case 0x25:
12801 GETBYTE ();
12802 switch (op[2] & 0x00)
12803 {
12804 case 0x00:
12805 goto op_semantics_102;
12806 break;
12807 }
12808 break;
12809 case 0x26:
12810 GETBYTE ();
12811 switch (op[2] & 0x00)
12812 {
12813 case 0x00:
12814 goto op_semantics_102;
12815 break;
12816 }
12817 break;
12818 case 0x27:
12819 GETBYTE ();
12820 switch (op[2] & 0x00)
12821 {
12822 case 0x00:
12823 {
12824 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
12825 #line 1071 "rx-decode.opc"
12826 int rdst AU = (op[2] >> 4) & 0x0f;
12827 #line 1071 "rx-decode.opc"
12828 int rsrc AU = op[2] & 0x0f;
12829 if (trace)
12830 {
12831 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12832 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
12833 op[0], op[1], op[2]);
12834 printf (" rdst = 0x%x,", rdst);
12835 printf (" rsrc = 0x%x\n", rsrc);
12836 }
12837 SYNTAX("movco %1, [%0]");
12838 #line 1071 "rx-decode.opc"
12839 ID(movco); SR(rsrc); DR(rdst); F_____;
12840
12841 }
12842 break;
12843 }
12844 break;
12845 case 0x28:
12846 GETBYTE ();
12847 switch (op[2] & 0x00)
12848 {
12849 case 0x00:
12850 op_semantics_103:
12851 {
12852 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
12853 #line 373 "rx-decode.opc"
12854 int p AU = (op[1] >> 2) & 0x01;
12855 #line 373 "rx-decode.opc"
12856 int sz AU = op[1] & 0x03;
12857 #line 373 "rx-decode.opc"
12858 int rsrc AU = (op[2] >> 4) & 0x0f;
12859 #line 373 "rx-decode.opc"
12860 int rdst AU = op[2] & 0x0f;
12861 if (trace)
12862 {
12863 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12864 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
12865 op[0], op[1], op[2]);
12866 printf (" p = 0x%x,", p);
12867 printf (" sz = 0x%x,", sz);
12868 printf (" rsrc = 0x%x,", rsrc);
12869 printf (" rdst = 0x%x\n", rdst);
12870 }
12871 SYNTAX("mov%s %1, %0");
12872 #line 373 "rx-decode.opc"
12873 ID(mov); sBWL (sz); DR(rdst); F_____;
12874 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12875
12876 }
12877 break;
12878 }
12879 break;
12880 case 0x29:
12881 GETBYTE ();
12882 switch (op[2] & 0x00)
12883 {
12884 case 0x00:
12885 goto op_semantics_103;
12886 break;
12887 }
12888 break;
12889 case 0x2a:
12890 GETBYTE ();
12891 switch (op[2] & 0x00)
12892 {
12893 case 0x00:
12894 goto op_semantics_103;
12895 break;
12896 }
12897 break;
12898 case 0x2c:
12899 GETBYTE ();
12900 switch (op[2] & 0x00)
12901 {
12902 case 0x00:
12903 goto op_semantics_103;
12904 break;
12905 }
12906 break;
12907 case 0x2d:
12908 GETBYTE ();
12909 switch (op[2] & 0x00)
12910 {
12911 case 0x00:
12912 goto op_semantics_103;
12913 break;
12914 }
12915 break;
12916 case 0x2e:
12917 GETBYTE ();
12918 switch (op[2] & 0x00)
12919 {
12920 case 0x00:
12921 goto op_semantics_103;
12922 break;
12923 }
12924 break;
12925 case 0x2f:
12926 GETBYTE ();
12927 switch (op[2] & 0x00)
12928 {
12929 case 0x00:
12930 {
12931 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
12932 #line 1074 "rx-decode.opc"
12933 int rsrc AU = (op[2] >> 4) & 0x0f;
12934 #line 1074 "rx-decode.opc"
12935 int rdst AU = op[2] & 0x0f;
12936 if (trace)
12937 {
12938 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12939 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
12940 op[0], op[1], op[2]);
12941 printf (" rsrc = 0x%x,", rsrc);
12942 printf (" rdst = 0x%x\n", rdst);
12943 }
12944 SYNTAX("movli [%1], %0");
12945 #line 1074 "rx-decode.opc"
12946 ID(movli); SR(rsrc); DR(rdst); F_____;
12947
12948 }
12949 break;
12950 }
12951 break;
12952 case 0x38:
12953 GETBYTE ();
12954 switch (op[2] & 0x00)
12955 {
12956 case 0x00:
12957 op_semantics_104:
12958 {
12959 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
12960 #line 383 "rx-decode.opc"
12961 int p AU = (op[1] >> 2) & 0x01;
12962 #line 383 "rx-decode.opc"
12963 int sz AU = op[1] & 0x03;
12964 #line 383 "rx-decode.opc"
12965 int rsrc AU = (op[2] >> 4) & 0x0f;
12966 #line 383 "rx-decode.opc"
12967 int rdst AU = op[2] & 0x0f;
12968 if (trace)
12969 {
12970 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12971 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
12972 op[0], op[1], op[2]);
12973 printf (" p = 0x%x,", p);
12974 printf (" sz = 0x%x,", sz);
12975 printf (" rsrc = 0x%x,", rsrc);
12976 printf (" rdst = 0x%x\n", rdst);
12977 }
12978 SYNTAX("movu%s %1, %0");
12979 #line 383 "rx-decode.opc"
12980 ID(mov); uBW (sz); DR(rdst); F_____;
12981 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12982
12983 /*----------------------------------------------------------------------*/
12984 /* PUSH/POP */
12985
12986 }
12987 break;
12988 }
12989 break;
12990 case 0x39:
12991 GETBYTE ();
12992 switch (op[2] & 0x00)
12993 {
12994 case 0x00:
12995 goto op_semantics_104;
12996 break;
12997 }
12998 break;
12999 case 0x3a:
13000 GETBYTE ();
13001 switch (op[2] & 0x00)
13002 {
13003 case 0x00:
13004 goto op_semantics_104;
13005 break;
13006 }
13007 break;
13008 case 0x3c:
13009 GETBYTE ();
13010 switch (op[2] & 0x00)
13011 {
13012 case 0x00:
13013 goto op_semantics_104;
13014 break;
13015 }
13016 break;
13017 case 0x3d:
13018 GETBYTE ();
13019 switch (op[2] & 0x00)
13020 {
13021 case 0x00:
13022 goto op_semantics_104;
13023 break;
13024 }
13025 break;
13026 case 0x3e:
13027 GETBYTE ();
13028 switch (op[2] & 0x00)
13029 {
13030 case 0x00:
13031 goto op_semantics_104;
13032 break;
13033 }
13034 break;
13035 case 0x44:
13036 GETBYTE ();
13037 switch (op[2] & 0x00)
13038 {
13039 case 0x00:
13040 op_semantics_105:
13041 {
13042 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
13043 #line 1095 "rx-decode.opc"
13044 int a AU = (op[1] >> 3) & 0x01;
13045 #line 1095 "rx-decode.opc"
13046 int srca AU = (op[2] >> 4) & 0x0f;
13047 #line 1095 "rx-decode.opc"
13048 int srcb AU = op[2] & 0x0f;
13049 if (trace)
13050 {
13051 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13052 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
13053 op[0], op[1], op[2]);
13054 printf (" a = 0x%x,", a);
13055 printf (" srca = 0x%x,", srca);
13056 printf (" srcb = 0x%x\n", srcb);
13057 }
13058 SYNTAX("msbhi %1, %2, %0");
13059 #line 1095 "rx-decode.opc"
13060 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13061
13062 }
13063 break;
13064 }
13065 break;
13066 case 0x45:
13067 GETBYTE ();
13068 switch (op[2] & 0x00)
13069 {
13070 case 0x00:
13071 op_semantics_106:
13072 {
13073 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
13074 #line 1101 "rx-decode.opc"
13075 int a AU = (op[1] >> 3) & 0x01;
13076 #line 1101 "rx-decode.opc"
13077 int srca AU = (op[2] >> 4) & 0x0f;
13078 #line 1101 "rx-decode.opc"
13079 int srcb AU = op[2] & 0x0f;
13080 if (trace)
13081 {
13082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13083 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
13084 op[0], op[1], op[2]);
13085 printf (" a = 0x%x,", a);
13086 printf (" srca = 0x%x,", srca);
13087 printf (" srcb = 0x%x\n", srcb);
13088 }
13089 SYNTAX("msblo %1, %2, %0");
13090 #line 1101 "rx-decode.opc"
13091 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
13092
13093 }
13094 break;
13095 }
13096 break;
13097 case 0x46:
13098 GETBYTE ();
13099 switch (op[2] & 0x00)
13100 {
13101 case 0x00:
13102 op_semantics_107:
13103 {
13104 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
13105 #line 1098 "rx-decode.opc"
13106 int a AU = (op[1] >> 3) & 0x01;
13107 #line 1098 "rx-decode.opc"
13108 int srca AU = (op[2] >> 4) & 0x0f;
13109 #line 1098 "rx-decode.opc"
13110 int srcb AU = op[2] & 0x0f;
13111 if (trace)
13112 {
13113 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13114 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
13115 op[0], op[1], op[2]);
13116 printf (" a = 0x%x,", a);
13117 printf (" srca = 0x%x,", srca);
13118 printf (" srcb = 0x%x\n", srcb);
13119 }
13120 SYNTAX("msblh %1, %2, %0");
13121 #line 1098 "rx-decode.opc"
13122 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
13123
13124 }
13125 break;
13126 }
13127 break;
13128 case 0x47:
13129 GETBYTE ();
13130 switch (op[2] & 0x00)
13131 {
13132 case 0x00:
13133 op_semantics_108:
13134 {
13135 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
13136 #line 1086 "rx-decode.opc"
13137 int a AU = (op[1] >> 3) & 0x01;
13138 #line 1086 "rx-decode.opc"
13139 int srca AU = (op[2] >> 4) & 0x0f;
13140 #line 1086 "rx-decode.opc"
13141 int srcb AU = op[2] & 0x0f;
13142 if (trace)
13143 {
13144 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13145 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
13146 op[0], op[1], op[2]);
13147 printf (" a = 0x%x,", a);
13148 printf (" srca = 0x%x,", srca);
13149 printf (" srcb = 0x%x\n", srcb);
13150 }
13151 SYNTAX("emsba %1, %2, %0");
13152 #line 1086 "rx-decode.opc"
13153 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
13154
13155 }
13156 break;
13157 }
13158 break;
13159 case 0x4c:
13160 GETBYTE ();
13161 switch (op[2] & 0x00)
13162 {
13163 case 0x00:
13164 goto op_semantics_105;
13165 break;
13166 }
13167 break;
13168 case 0x4d:
13169 GETBYTE ();
13170 switch (op[2] & 0x00)
13171 {
13172 case 0x00:
13173 goto op_semantics_106;
13174 break;
13175 }
13176 break;
13177 case 0x4e:
13178 GETBYTE ();
13179 switch (op[2] & 0x00)
13180 {
13181 case 0x00:
13182 goto op_semantics_107;
13183 break;
13184 }
13185 break;
13186 case 0x4f:
13187 GETBYTE ();
13188 switch (op[2] & 0x00)
13189 {
13190 case 0x00:
13191 goto op_semantics_108;
13192 break;
13193 }
13194 break;
13195 case 0x60:
13196 GETBYTE ();
13197 switch (op[2] & 0x00)
13198 {
13199 case 0x00:
13200 {
13201 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
13202 #line 754 "rx-decode.opc"
13203 int rsrc AU = (op[2] >> 4) & 0x0f;
13204 #line 754 "rx-decode.opc"
13205 int rdst AU = op[2] & 0x0f;
13206 if (trace)
13207 {
13208 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13209 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
13210 op[0], op[1], op[2]);
13211 printf (" rsrc = 0x%x,", rsrc);
13212 printf (" rdst = 0x%x\n", rdst);
13213 }
13214 SYNTAX("shlr %2, %0");
13215 #line 754 "rx-decode.opc"
13216 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
13217
13218 }
13219 break;
13220 }
13221 break;
13222 case 0x61:
13223 GETBYTE ();
13224 switch (op[2] & 0x00)
13225 {
13226 case 0x00:
13227 {
13228 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
13229 #line 744 "rx-decode.opc"
13230 int rsrc AU = (op[2] >> 4) & 0x0f;
13231 #line 744 "rx-decode.opc"
13232 int rdst AU = op[2] & 0x0f;
13233 if (trace)
13234 {
13235 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13236 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
13237 op[0], op[1], op[2]);
13238 printf (" rsrc = 0x%x,", rsrc);
13239 printf (" rdst = 0x%x\n", rdst);
13240 }
13241 SYNTAX("shar %2, %0");
13242 #line 744 "rx-decode.opc"
13243 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
13244
13245 }
13246 break;
13247 }
13248 break;
13249 case 0x62:
13250 GETBYTE ();
13251 switch (op[2] & 0x00)
13252 {
13253 case 0x00:
13254 {
13255 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
13256 #line 734 "rx-decode.opc"
13257 int rsrc AU = (op[2] >> 4) & 0x0f;
13258 #line 734 "rx-decode.opc"
13259 int rdst AU = op[2] & 0x0f;
13260 if (trace)
13261 {
13262 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13263 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
13264 op[0], op[1], op[2]);
13265 printf (" rsrc = 0x%x,", rsrc);
13266 printf (" rdst = 0x%x\n", rdst);
13267 }
13268 SYNTAX("shll %2, %0");
13269 #line 734 "rx-decode.opc"
13270 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
13271
13272 }
13273 break;
13274 }
13275 break;
13276 case 0x64:
13277 GETBYTE ();
13278 switch (op[2] & 0x00)
13279 {
13280 case 0x00:
13281 {
13282 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
13283 #line 778 "rx-decode.opc"
13284 int rsrc AU = (op[2] >> 4) & 0x0f;
13285 #line 778 "rx-decode.opc"
13286 int rdst AU = op[2] & 0x0f;
13287 if (trace)
13288 {
13289 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13290 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
13291 op[0], op[1], op[2]);
13292 printf (" rsrc = 0x%x,", rsrc);
13293 printf (" rdst = 0x%x\n", rdst);
13294 }
13295 SYNTAX("rotr %1, %0");
13296 #line 778 "rx-decode.opc"
13297 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
13298
13299 }
13300 break;
13301 }
13302 break;
13303 case 0x65:
13304 GETBYTE ();
13305 switch (op[2] & 0x00)
13306 {
13307 case 0x00:
13308 {
13309 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
13310 #line 781 "rx-decode.opc"
13311 int rsrc AU = (op[2] >> 4) & 0x0f;
13312 #line 781 "rx-decode.opc"
13313 int rdst AU = op[2] & 0x0f;
13314 if (trace)
13315 {
13316 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13317 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
13318 op[0], op[1], op[2]);
13319 printf (" rsrc = 0x%x,", rsrc);
13320 printf (" rdst = 0x%x\n", rdst);
13321 }
13322 SYNTAX("revw %1, %0");
13323 #line 781 "rx-decode.opc"
13324 ID(revw); SR(rsrc); DR(rdst);
13325
13326 }
13327 break;
13328 }
13329 break;
13330 case 0x66:
13331 GETBYTE ();
13332 switch (op[2] & 0x00)
13333 {
13334 case 0x00:
13335 {
13336 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
13337 #line 772 "rx-decode.opc"
13338 int rsrc AU = (op[2] >> 4) & 0x0f;
13339 #line 772 "rx-decode.opc"
13340 int rdst AU = op[2] & 0x0f;
13341 if (trace)
13342 {
13343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13344 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
13345 op[0], op[1], op[2]);
13346 printf (" rsrc = 0x%x,", rsrc);
13347 printf (" rdst = 0x%x\n", rdst);
13348 }
13349 SYNTAX("rotl %1, %0");
13350 #line 772 "rx-decode.opc"
13351 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
13352
13353 }
13354 break;
13355 }
13356 break;
13357 case 0x67:
13358 GETBYTE ();
13359 switch (op[2] & 0x00)
13360 {
13361 case 0x00:
13362 {
13363 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
13364 #line 784 "rx-decode.opc"
13365 int rsrc AU = (op[2] >> 4) & 0x0f;
13366 #line 784 "rx-decode.opc"
13367 int rdst AU = op[2] & 0x0f;
13368 if (trace)
13369 {
13370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13371 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
13372 op[0], op[1], op[2]);
13373 printf (" rsrc = 0x%x,", rsrc);
13374 printf (" rdst = 0x%x\n", rdst);
13375 }
13376 SYNTAX("revl %1, %0");
13377 #line 784 "rx-decode.opc"
13378 ID(revl); SR(rsrc); DR(rdst);
13379
13380 /*----------------------------------------------------------------------*/
13381 /* BRANCH */
13382
13383 }
13384 break;
13385 }
13386 break;
13387 case 0x68:
13388 GETBYTE ();
13389 switch (op[2] & 0x00)
13390 {
13391 case 0x00:
13392 op_semantics_109:
13393 {
13394 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
13395 #line 1035 "rx-decode.opc"
13396 int c AU = op[1] & 0x01;
13397 #line 1035 "rx-decode.opc"
13398 int rsrc AU = (op[2] >> 4) & 0x0f;
13399 #line 1035 "rx-decode.opc"
13400 int rdst AU = op[2] & 0x0f;
13401 if (trace)
13402 {
13403 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13404 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
13405 op[0], op[1], op[2]);
13406 printf (" c = 0x%x,", c);
13407 printf (" rsrc = 0x%x,", rsrc);
13408 printf (" rdst = 0x%x\n", rdst);
13409 }
13410 SYNTAX("mvtc %1, %0");
13411 #line 1035 "rx-decode.opc"
13412 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
13413
13414 }
13415 break;
13416 }
13417 break;
13418 case 0x69:
13419 GETBYTE ();
13420 switch (op[2] & 0x00)
13421 {
13422 case 0x00:
13423 goto op_semantics_109;
13424 break;
13425 }
13426 break;
13427 case 0x6a:
13428 GETBYTE ();
13429 switch (op[2] & 0x00)
13430 {
13431 case 0x00:
13432 op_semantics_110:
13433 {
13434 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
13435 #line 1038 "rx-decode.opc"
13436 int s AU = op[1] & 0x01;
13437 #line 1038 "rx-decode.opc"
13438 int rsrc AU = (op[2] >> 4) & 0x0f;
13439 #line 1038 "rx-decode.opc"
13440 int rdst AU = op[2] & 0x0f;
13441 if (trace)
13442 {
13443 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13444 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
13445 op[0], op[1], op[2]);
13446 printf (" s = 0x%x,", s);
13447 printf (" rsrc = 0x%x,", rsrc);
13448 printf (" rdst = 0x%x\n", rdst);
13449 }
13450 SYNTAX("mvfc %1, %0");
13451 #line 1038 "rx-decode.opc"
13452 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
13453
13454 /*----------------------------------------------------------------------*/
13455 /* INTERRUPTS */
13456
13457 }
13458 break;
13459 }
13460 break;
13461 case 0x6b:
13462 GETBYTE ();
13463 switch (op[2] & 0x00)
13464 {
13465 case 0x00:
13466 goto op_semantics_110;
13467 break;
13468 }
13469 break;
13470 case 0x6c:
13471 GETBYTE ();
13472 switch (op[2] & 0x00)
13473 {
13474 case 0x00:
13475 op_semantics_111:
13476 {
13477 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
13478 #line 775 "rx-decode.opc"
13479 int i AU = op[1] & 0x01;
13480 #line 775 "rx-decode.opc"
13481 int mmmm AU = (op[2] >> 4) & 0x0f;
13482 #line 775 "rx-decode.opc"
13483 int rdst AU = op[2] & 0x0f;
13484 if (trace)
13485 {
13486 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13487 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
13488 op[0], op[1], op[2]);
13489 printf (" i = 0x%x,", i);
13490 printf (" mmmm = 0x%x,", mmmm);
13491 printf (" rdst = 0x%x\n", rdst);
13492 }
13493 SYNTAX("rotr #%1, %0");
13494 #line 775 "rx-decode.opc"
13495 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
13496
13497 }
13498 break;
13499 }
13500 break;
13501 case 0x6d:
13502 GETBYTE ();
13503 switch (op[2] & 0x00)
13504 {
13505 case 0x00:
13506 goto op_semantics_111;
13507 break;
13508 }
13509 break;
13510 case 0x6e:
13511 GETBYTE ();
13512 switch (op[2] & 0x00)
13513 {
13514 case 0x00:
13515 op_semantics_112:
13516 {
13517 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
13518 #line 769 "rx-decode.opc"
13519 int i AU = op[1] & 0x01;
13520 #line 769 "rx-decode.opc"
13521 int mmmm AU = (op[2] >> 4) & 0x0f;
13522 #line 769 "rx-decode.opc"
13523 int rdst AU = op[2] & 0x0f;
13524 if (trace)
13525 {
13526 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13527 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
13528 op[0], op[1], op[2]);
13529 printf (" i = 0x%x,", i);
13530 printf (" mmmm = 0x%x,", mmmm);
13531 printf (" rdst = 0x%x\n", rdst);
13532 }
13533 SYNTAX("rotl #%1, %0");
13534 #line 769 "rx-decode.opc"
13535 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
13536
13537 }
13538 break;
13539 }
13540 break;
13541 case 0x6f:
13542 GETBYTE ();
13543 switch (op[2] & 0x00)
13544 {
13545 case 0x00:
13546 goto op_semantics_112;
13547 break;
13548 }
13549 break;
13550 case 0x70:
13551 GETBYTE ();
13552 switch (op[2] & 0xf0)
13553 {
13554 case 0x20:
13555 op_semantics_113:
13556 {
13557 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
13558 #line 513 "rx-decode.opc"
13559 int im AU = (op[1] >> 2) & 0x03;
13560 #line 513 "rx-decode.opc"
13561 int rdst AU = op[2] & 0x0f;
13562 if (trace)
13563 {
13564 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13565 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
13566 op[0], op[1], op[2]);
13567 printf (" im = 0x%x,", im);
13568 printf (" rdst = 0x%x\n", rdst);
13569 }
13570 SYNTAX("adc #%1, %0");
13571 #line 513 "rx-decode.opc"
13572 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
13573
13574 }
13575 break;
13576 case 0x40:
13577 op_semantics_114:
13578 {
13579 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
13580 #line 595 "rx-decode.opc"
13581 int im AU = (op[1] >> 2) & 0x03;
13582 #line 595 "rx-decode.opc"
13583 int rdst AU = op[2] & 0x0f;
13584 if (trace)
13585 {
13586 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13587 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
13588 op[0], op[1], op[2]);
13589 printf (" im = 0x%x,", im);
13590 printf (" rdst = 0x%x\n", rdst);
13591 }
13592 SYNTAX("max #%1, %0");
13593 #line 595 "rx-decode.opc"
13594 int val = IMMex (im);
13595 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
13596 {
13597 ID (nop7);
13598 SYNTAX("nop\t; max\t#0x80000000, r0");
13599 }
13600 else
13601 {
13602 ID(max);
13603 }
13604 DR(rdst); SC(val);
13605
13606 }
13607 break;
13608 case 0x50:
13609 op_semantics_115:
13610 {
13611 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
13612 #line 625 "rx-decode.opc"
13613 int im AU = (op[1] >> 2) & 0x03;
13614 #line 625 "rx-decode.opc"
13615 int rdst AU = op[2] & 0x0f;
13616 if (trace)
13617 {
13618 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13619 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
13620 op[0], op[1], op[2]);
13621 printf (" im = 0x%x,", im);
13622 printf (" rdst = 0x%x\n", rdst);
13623 }
13624 SYNTAX("min #%1, %0");
13625 #line 625 "rx-decode.opc"
13626 ID(min); DR(rdst); SC(IMMex(im));
13627
13628 }
13629 break;
13630 case 0x60:
13631 op_semantics_116:
13632 {
13633 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
13634 #line 683 "rx-decode.opc"
13635 int im AU = (op[1] >> 2) & 0x03;
13636 #line 683 "rx-decode.opc"
13637 int rdst AU = op[2] & 0x0f;
13638 if (trace)
13639 {
13640 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13641 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
13642 op[0], op[1], op[2]);
13643 printf (" im = 0x%x,", im);
13644 printf (" rdst = 0x%x\n", rdst);
13645 }
13646 SYNTAX("emul #%1, %0");
13647 #line 683 "rx-decode.opc"
13648 ID(emul); DR(rdst); SC(IMMex(im));
13649
13650 }
13651 break;
13652 case 0x70:
13653 op_semantics_117:
13654 {
13655 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
13656 #line 695 "rx-decode.opc"
13657 int im AU = (op[1] >> 2) & 0x03;
13658 #line 695 "rx-decode.opc"
13659 int rdst AU = op[2] & 0x0f;
13660 if (trace)
13661 {
13662 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13663 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
13664 op[0], op[1], op[2]);
13665 printf (" im = 0x%x,", im);
13666 printf (" rdst = 0x%x\n", rdst);
13667 }
13668 SYNTAX("emulu #%1, %0");
13669 #line 695 "rx-decode.opc"
13670 ID(emulu); DR(rdst); SC(IMMex(im));
13671
13672 }
13673 break;
13674 case 0x80:
13675 op_semantics_118:
13676 {
13677 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
13678 #line 707 "rx-decode.opc"
13679 int im AU = (op[1] >> 2) & 0x03;
13680 #line 707 "rx-decode.opc"
13681 int rdst AU = op[2] & 0x0f;
13682 if (trace)
13683 {
13684 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13685 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
13686 op[0], op[1], op[2]);
13687 printf (" im = 0x%x,", im);
13688 printf (" rdst = 0x%x\n", rdst);
13689 }
13690 SYNTAX("div #%1, %0");
13691 #line 707 "rx-decode.opc"
13692 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
13693
13694 }
13695 break;
13696 case 0x90:
13697 op_semantics_119:
13698 {
13699 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
13700 #line 719 "rx-decode.opc"
13701 int im AU = (op[1] >> 2) & 0x03;
13702 #line 719 "rx-decode.opc"
13703 int rdst AU = op[2] & 0x0f;
13704 if (trace)
13705 {
13706 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13707 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
13708 op[0], op[1], op[2]);
13709 printf (" im = 0x%x,", im);
13710 printf (" rdst = 0x%x\n", rdst);
13711 }
13712 SYNTAX("divu #%1, %0");
13713 #line 719 "rx-decode.opc"
13714 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
13715
13716 }
13717 break;
13718 case 0xc0:
13719 op_semantics_120:
13720 {
13721 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
13722 #line 492 "rx-decode.opc"
13723 int im AU = (op[1] >> 2) & 0x03;
13724 #line 492 "rx-decode.opc"
13725 int rdst AU = op[2] & 0x0f;
13726 if (trace)
13727 {
13728 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13729 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
13730 op[0], op[1], op[2]);
13731 printf (" im = 0x%x,", im);
13732 printf (" rdst = 0x%x\n", rdst);
13733 }
13734 SYNTAX("tst #%1, %2");
13735 #line 492 "rx-decode.opc"
13736 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
13737
13738 }
13739 break;
13740 case 0xd0:
13741 op_semantics_121:
13742 {
13743 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
13744 #line 471 "rx-decode.opc"
13745 int im AU = (op[1] >> 2) & 0x03;
13746 #line 471 "rx-decode.opc"
13747 int rdst AU = op[2] & 0x0f;
13748 if (trace)
13749 {
13750 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13751 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
13752 op[0], op[1], op[2]);
13753 printf (" im = 0x%x,", im);
13754 printf (" rdst = 0x%x\n", rdst);
13755 }
13756 SYNTAX("xor #%1, %0");
13757 #line 471 "rx-decode.opc"
13758 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
13759
13760 }
13761 break;
13762 case 0xe0:
13763 op_semantics_122:
13764 {
13765 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
13766 #line 417 "rx-decode.opc"
13767 int im AU = (op[1] >> 2) & 0x03;
13768 #line 417 "rx-decode.opc"
13769 int rdst AU = op[2] & 0x0f;
13770 if (trace)
13771 {
13772 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13773 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
13774 op[0], op[1], op[2]);
13775 printf (" im = 0x%x,", im);
13776 printf (" rdst = 0x%x\n", rdst);
13777 }
13778 SYNTAX("stz #%1, %0");
13779 #line 417 "rx-decode.opc"
13780 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
13781
13782 }
13783 break;
13784 case 0xf0:
13785 op_semantics_123:
13786 {
13787 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
13788 #line 420 "rx-decode.opc"
13789 int im AU = (op[1] >> 2) & 0x03;
13790 #line 420 "rx-decode.opc"
13791 int rdst AU = op[2] & 0x0f;
13792 if (trace)
13793 {
13794 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13795 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
13796 op[0], op[1], op[2]);
13797 printf (" im = 0x%x,", im);
13798 printf (" rdst = 0x%x\n", rdst);
13799 }
13800 SYNTAX("stnz #%1, %0");
13801 #line 420 "rx-decode.opc"
13802 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
13803
13804 /*----------------------------------------------------------------------*/
13805 /* RTSD */
13806
13807 }
13808 break;
13809 default: UNSUPPORTED(); break;
13810 }
13811 break;
13812 case 0x72:
13813 GETBYTE ();
13814 switch (op[2] & 0xf0)
13815 {
13816 case 0x00:
13817 {
13818 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
13819 #line 927 "rx-decode.opc"
13820 int rdst AU = op[2] & 0x0f;
13821 if (trace)
13822 {
13823 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13824 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
13825 op[0], op[1], op[2]);
13826 printf (" rdst = 0x%x\n", rdst);
13827 }
13828 SYNTAX("fsub #%1, %0");
13829 #line 927 "rx-decode.opc"
13830 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
13831
13832 }
13833 break;
13834 case 0x10:
13835 {
13836 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
13837 #line 921 "rx-decode.opc"
13838 int rdst AU = op[2] & 0x0f;
13839 if (trace)
13840 {
13841 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13842 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
13843 op[0], op[1], op[2]);
13844 printf (" rdst = 0x%x\n", rdst);
13845 }
13846 SYNTAX("fcmp #%1, %0");
13847 #line 921 "rx-decode.opc"
13848 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
13849
13850 }
13851 break;
13852 case 0x20:
13853 {
13854 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
13855 #line 915 "rx-decode.opc"
13856 int rdst AU = op[2] & 0x0f;
13857 if (trace)
13858 {
13859 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13860 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
13861 op[0], op[1], op[2]);
13862 printf (" rdst = 0x%x\n", rdst);
13863 }
13864 SYNTAX("fadd #%1, %0");
13865 #line 915 "rx-decode.opc"
13866 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
13867
13868 }
13869 break;
13870 case 0x30:
13871 {
13872 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
13873 #line 936 "rx-decode.opc"
13874 int rdst AU = op[2] & 0x0f;
13875 if (trace)
13876 {
13877 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13878 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
13879 op[0], op[1], op[2]);
13880 printf (" rdst = 0x%x\n", rdst);
13881 }
13882 SYNTAX("fmul #%1, %0");
13883 #line 936 "rx-decode.opc"
13884 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
13885
13886 }
13887 break;
13888 case 0x40:
13889 {
13890 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
13891 #line 942 "rx-decode.opc"
13892 int rdst AU = op[2] & 0x0f;
13893 if (trace)
13894 {
13895 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13896 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
13897 op[0], op[1], op[2]);
13898 printf (" rdst = 0x%x\n", rdst);
13899 }
13900 SYNTAX("fdiv #%1, %0");
13901 #line 942 "rx-decode.opc"
13902 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
13903
13904 }
13905 break;
13906 default: UNSUPPORTED(); break;
13907 }
13908 break;
13909 case 0x73:
13910 GETBYTE ();
13911 switch (op[2] & 0xe0)
13912 {
13913 case 0x00:
13914 op_semantics_124:
13915 {
13916 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
13917 #line 1032 "rx-decode.opc"
13918 int im AU = (op[1] >> 2) & 0x03;
13919 #line 1032 "rx-decode.opc"
13920 int crdst AU = op[2] & 0x1f;
13921 if (trace)
13922 {
13923 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13924 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
13925 op[0], op[1], op[2]);
13926 printf (" im = 0x%x,", im);
13927 printf (" crdst = 0x%x\n", crdst);
13928 }
13929 SYNTAX("mvtc #%1, %0");
13930 #line 1032 "rx-decode.opc"
13931 ID(mov); SC(IMMex(im)); DR(crdst + 16);
13932
13933 }
13934 break;
13935 default: UNSUPPORTED(); break;
13936 }
13937 break;
13938 case 0x74:
13939 GETBYTE ();
13940 switch (op[2] & 0xf0)
13941 {
13942 case 0x20:
13943 goto op_semantics_113;
13944 break;
13945 case 0x40:
13946 goto op_semantics_114;
13947 break;
13948 case 0x50:
13949 goto op_semantics_115;
13950 break;
13951 case 0x60:
13952 goto op_semantics_116;
13953 break;
13954 case 0x70:
13955 goto op_semantics_117;
13956 break;
13957 case 0x80:
13958 goto op_semantics_118;
13959 break;
13960 case 0x90:
13961 goto op_semantics_119;
13962 break;
13963 case 0xc0:
13964 goto op_semantics_120;
13965 break;
13966 case 0xd0:
13967 goto op_semantics_121;
13968 break;
13969 case 0xe0:
13970 goto op_semantics_122;
13971 break;
13972 case 0xf0:
13973 goto op_semantics_123;
13974 break;
13975 default: UNSUPPORTED(); break;
13976 }
13977 break;
13978 case 0x75:
13979 GETBYTE ();
13980 switch (op[2] & 0xff)
13981 {
13982 case 0x80:
13983 GETBYTE ();
13984 switch (op[3] & 0x0f)
13985 {
13986 case 0x00:
13987 op_semantics_125:
13988 {
13989 /** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */
13990 #line 1176 "rx-decode.opc"
13991 int rdst AU = op[2] & 0x0f;
13992 #line 1176 "rx-decode.opc"
13993 int rsrc AU = (op[3] >> 4) & 0x0f;
13994 if (trace)
13995 {
13996 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
13997 "/** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */",
13998 op[0], op[1], op[2], op[3]);
13999 printf (" rdst = 0x%x,", rdst);
14000 printf (" rsrc = 0x%x\n", rsrc);
14001 }
14002 SYNTAX("dmov.l %1, %0");
14003 #line 1176 "rx-decode.opc"
14004 ID(dmov); DR(rdst); SDRL(rsrc); F_____;
14005
14006 }
14007 break;
14008 case 0x02:
14009 op_semantics_126:
14010 {
14011 /** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */
14012 #line 1173 "rx-decode.opc"
14013 int rdst AU = op[2] & 0x0f;
14014 #line 1173 "rx-decode.opc"
14015 int rsrc AU = (op[3] >> 4) & 0x0f;
14016 if (trace)
14017 {
14018 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14019 "/** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */",
14020 op[0], op[1], op[2], op[3]);
14021 printf (" rdst = 0x%x,", rdst);
14022 printf (" rsrc = 0x%x\n", rsrc);
14023 }
14024 SYNTAX("dmov.l %1, %0");
14025 #line 1173 "rx-decode.opc"
14026 ID(dmov); DR(rdst); SDRH(rsrc); F_____;
14027
14028 }
14029 break;
14030 case 0x04:
14031 op_semantics_127:
14032 {
14033 /** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */
14034 #line 1226 "rx-decode.opc"
14035 int rdst AU = op[2] & 0x0f;
14036 #line 1226 "rx-decode.opc"
14037 int rsrc AU = (op[3] >> 4) & 0x0f;
14038 if (trace)
14039 {
14040 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14041 "/** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */",
14042 op[0], op[1], op[2], op[3]);
14043 printf (" rdst = 0x%x,", rdst);
14044 printf (" rsrc = 0x%x\n", rsrc);
14045 }
14046 SYNTAX("mvfdc %1, %0");
14047 #line 1226 "rx-decode.opc"
14048 ID(mvfdc); DR(rdst); SCR(rsrc); F_____;
14049
14050 }
14051 break;
14052 default: UNSUPPORTED(); break;
14053 }
14054 break;
14055 case 0x81:
14056 GETBYTE ();
14057 switch (op[3] & 0x0f)
14058 {
14059 case 0x00:
14060 goto op_semantics_125;
14061 break;
14062 case 0x02:
14063 goto op_semantics_126;
14064 break;
14065 case 0x04:
14066 goto op_semantics_127;
14067 break;
14068 default: UNSUPPORTED(); break;
14069 }
14070 break;
14071 case 0x82:
14072 GETBYTE ();
14073 switch (op[3] & 0x0f)
14074 {
14075 case 0x00:
14076 goto op_semantics_125;
14077 break;
14078 case 0x02:
14079 goto op_semantics_126;
14080 break;
14081 case 0x04:
14082 goto op_semantics_127;
14083 break;
14084 default: UNSUPPORTED(); break;
14085 }
14086 break;
14087 case 0x83:
14088 GETBYTE ();
14089 switch (op[3] & 0x0f)
14090 {
14091 case 0x00:
14092 goto op_semantics_125;
14093 break;
14094 case 0x02:
14095 goto op_semantics_126;
14096 break;
14097 case 0x04:
14098 goto op_semantics_127;
14099 break;
14100 default: UNSUPPORTED(); break;
14101 }
14102 break;
14103 case 0x84:
14104 GETBYTE ();
14105 switch (op[3] & 0x0f)
14106 {
14107 case 0x00:
14108 goto op_semantics_125;
14109 break;
14110 case 0x02:
14111 goto op_semantics_126;
14112 break;
14113 case 0x04:
14114 goto op_semantics_127;
14115 break;
14116 default: UNSUPPORTED(); break;
14117 }
14118 break;
14119 case 0x85:
14120 GETBYTE ();
14121 switch (op[3] & 0x0f)
14122 {
14123 case 0x00:
14124 goto op_semantics_125;
14125 break;
14126 case 0x02:
14127 goto op_semantics_126;
14128 break;
14129 case 0x04:
14130 goto op_semantics_127;
14131 break;
14132 default: UNSUPPORTED(); break;
14133 }
14134 break;
14135 case 0x86:
14136 GETBYTE ();
14137 switch (op[3] & 0x0f)
14138 {
14139 case 0x00:
14140 goto op_semantics_125;
14141 break;
14142 case 0x02:
14143 goto op_semantics_126;
14144 break;
14145 case 0x04:
14146 goto op_semantics_127;
14147 break;
14148 default: UNSUPPORTED(); break;
14149 }
14150 break;
14151 case 0x87:
14152 GETBYTE ();
14153 switch (op[3] & 0x0f)
14154 {
14155 case 0x00:
14156 goto op_semantics_125;
14157 break;
14158 case 0x02:
14159 goto op_semantics_126;
14160 break;
14161 case 0x04:
14162 goto op_semantics_127;
14163 break;
14164 default: UNSUPPORTED(); break;
14165 }
14166 break;
14167 case 0x88:
14168 GETBYTE ();
14169 switch (op[3] & 0x0f)
14170 {
14171 case 0x00:
14172 goto op_semantics_125;
14173 break;
14174 case 0x02:
14175 goto op_semantics_126;
14176 break;
14177 case 0x04:
14178 goto op_semantics_127;
14179 break;
14180 default: UNSUPPORTED(); break;
14181 }
14182 break;
14183 case 0x89:
14184 GETBYTE ();
14185 switch (op[3] & 0x0f)
14186 {
14187 case 0x00:
14188 goto op_semantics_125;
14189 break;
14190 case 0x02:
14191 goto op_semantics_126;
14192 break;
14193 case 0x04:
14194 goto op_semantics_127;
14195 break;
14196 default: UNSUPPORTED(); break;
14197 }
14198 break;
14199 case 0x8a:
14200 GETBYTE ();
14201 switch (op[3] & 0x0f)
14202 {
14203 case 0x00:
14204 goto op_semantics_125;
14205 break;
14206 case 0x02:
14207 goto op_semantics_126;
14208 break;
14209 case 0x04:
14210 goto op_semantics_127;
14211 break;
14212 default: UNSUPPORTED(); break;
14213 }
14214 break;
14215 case 0x8b:
14216 GETBYTE ();
14217 switch (op[3] & 0x0f)
14218 {
14219 case 0x00:
14220 goto op_semantics_125;
14221 break;
14222 case 0x02:
14223 goto op_semantics_126;
14224 break;
14225 case 0x04:
14226 goto op_semantics_127;
14227 break;
14228 default: UNSUPPORTED(); break;
14229 }
14230 break;
14231 case 0x8c:
14232 GETBYTE ();
14233 switch (op[3] & 0x0f)
14234 {
14235 case 0x00:
14236 goto op_semantics_125;
14237 break;
14238 case 0x02:
14239 goto op_semantics_126;
14240 break;
14241 case 0x04:
14242 goto op_semantics_127;
14243 break;
14244 default: UNSUPPORTED(); break;
14245 }
14246 break;
14247 case 0x8d:
14248 GETBYTE ();
14249 switch (op[3] & 0x0f)
14250 {
14251 case 0x00:
14252 goto op_semantics_125;
14253 break;
14254 case 0x02:
14255 goto op_semantics_126;
14256 break;
14257 case 0x04:
14258 goto op_semantics_127;
14259 break;
14260 default: UNSUPPORTED(); break;
14261 }
14262 break;
14263 case 0x8e:
14264 GETBYTE ();
14265 switch (op[3] & 0x0f)
14266 {
14267 case 0x00:
14268 goto op_semantics_125;
14269 break;
14270 case 0x02:
14271 goto op_semantics_126;
14272 break;
14273 case 0x04:
14274 goto op_semantics_127;
14275 break;
14276 default: UNSUPPORTED(); break;
14277 }
14278 break;
14279 case 0x8f:
14280 GETBYTE ();
14281 switch (op[3] & 0x0f)
14282 {
14283 case 0x00:
14284 goto op_semantics_125;
14285 break;
14286 case 0x02:
14287 goto op_semantics_126;
14288 break;
14289 case 0x04:
14290 goto op_semantics_127;
14291 break;
14292 default: UNSUPPORTED(); break;
14293 }
14294 break;
14295 default: UNSUPPORTED(); break;
14296 }
14297 break;
14298 case 0x76:
14299 GETBYTE ();
14300 switch (op[2] & 0xff)
14301 {
14302 case 0xc0:
14303 GETBYTE ();
14304 switch (op[3] & 0xff)
14305 {
14306 case 0x00:
14307 op_semantics_128:
14308 {
14309 /** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */
14310 #line 1161 "rx-decode.opc"
14311 int rsrc AU = op[2] & 0x0f;
14312 if (trace)
14313 {
14314 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14315 "/** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */",
14316 op[0], op[1], op[2], op[3]);
14317 printf (" rsrc = 0x%x\n", rsrc);
14318 }
14319 SYNTAX("save %1");
14320 #line 1161 "rx-decode.opc"
14321 ID(save); SR(rsrc); F_____;
14322
14323 }
14324 break;
14325 default: UNSUPPORTED(); break;
14326 }
14327 break;
14328 case 0xc1:
14329 GETBYTE ();
14330 switch (op[3] & 0xff)
14331 {
14332 case 0x00:
14333 goto op_semantics_128;
14334 break;
14335 default: UNSUPPORTED(); break;
14336 }
14337 break;
14338 case 0xc2:
14339 GETBYTE ();
14340 switch (op[3] & 0xff)
14341 {
14342 case 0x00:
14343 goto op_semantics_128;
14344 break;
14345 default: UNSUPPORTED(); break;
14346 }
14347 break;
14348 case 0xc3:
14349 GETBYTE ();
14350 switch (op[3] & 0xff)
14351 {
14352 case 0x00:
14353 goto op_semantics_128;
14354 break;
14355 default: UNSUPPORTED(); break;
14356 }
14357 break;
14358 case 0xc4:
14359 GETBYTE ();
14360 switch (op[3] & 0xff)
14361 {
14362 case 0x00:
14363 goto op_semantics_128;
14364 break;
14365 default: UNSUPPORTED(); break;
14366 }
14367 break;
14368 case 0xc5:
14369 GETBYTE ();
14370 switch (op[3] & 0xff)
14371 {
14372 case 0x00:
14373 goto op_semantics_128;
14374 break;
14375 default: UNSUPPORTED(); break;
14376 }
14377 break;
14378 case 0xc6:
14379 GETBYTE ();
14380 switch (op[3] & 0xff)
14381 {
14382 case 0x00:
14383 goto op_semantics_128;
14384 break;
14385 default: UNSUPPORTED(); break;
14386 }
14387 break;
14388 case 0xc7:
14389 GETBYTE ();
14390 switch (op[3] & 0xff)
14391 {
14392 case 0x00:
14393 goto op_semantics_128;
14394 break;
14395 default: UNSUPPORTED(); break;
14396 }
14397 break;
14398 case 0xc8:
14399 GETBYTE ();
14400 switch (op[3] & 0xff)
14401 {
14402 case 0x00:
14403 goto op_semantics_128;
14404 break;
14405 default: UNSUPPORTED(); break;
14406 }
14407 break;
14408 case 0xc9:
14409 GETBYTE ();
14410 switch (op[3] & 0xff)
14411 {
14412 case 0x00:
14413 goto op_semantics_128;
14414 break;
14415 default: UNSUPPORTED(); break;
14416 }
14417 break;
14418 case 0xca:
14419 GETBYTE ();
14420 switch (op[3] & 0xff)
14421 {
14422 case 0x00:
14423 goto op_semantics_128;
14424 break;
14425 default: UNSUPPORTED(); break;
14426 }
14427 break;
14428 case 0xcb:
14429 GETBYTE ();
14430 switch (op[3] & 0xff)
14431 {
14432 case 0x00:
14433 goto op_semantics_128;
14434 break;
14435 default: UNSUPPORTED(); break;
14436 }
14437 break;
14438 case 0xcc:
14439 GETBYTE ();
14440 switch (op[3] & 0xff)
14441 {
14442 case 0x00:
14443 goto op_semantics_128;
14444 break;
14445 default: UNSUPPORTED(); break;
14446 }
14447 break;
14448 case 0xcd:
14449 GETBYTE ();
14450 switch (op[3] & 0xff)
14451 {
14452 case 0x00:
14453 goto op_semantics_128;
14454 break;
14455 default: UNSUPPORTED(); break;
14456 }
14457 break;
14458 case 0xce:
14459 GETBYTE ();
14460 switch (op[3] & 0xff)
14461 {
14462 case 0x00:
14463 goto op_semantics_128;
14464 break;
14465 default: UNSUPPORTED(); break;
14466 }
14467 break;
14468 case 0xcf:
14469 GETBYTE ();
14470 switch (op[3] & 0xff)
14471 {
14472 case 0x00:
14473 goto op_semantics_128;
14474 break;
14475 default: UNSUPPORTED(); break;
14476 }
14477 break;
14478 case 0xd0:
14479 GETBYTE ();
14480 switch (op[3] & 0xff)
14481 {
14482 case 0x00:
14483 op_semantics_129:
14484 {
14485 /** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */
14486 #line 1155 "rx-decode.opc"
14487 int rsrc AU = op[2] & 0x0f;
14488 if (trace)
14489 {
14490 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14491 "/** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */",
14492 op[0], op[1], op[2], op[3]);
14493 printf (" rsrc = 0x%x\n", rsrc);
14494 }
14495 SYNTAX("rstr %1");
14496 #line 1155 "rx-decode.opc"
14497 ID(rstr); SR(rsrc); F_____;
14498
14499 }
14500 break;
14501 default: UNSUPPORTED(); break;
14502 }
14503 break;
14504 case 0xd1:
14505 GETBYTE ();
14506 switch (op[3] & 0xff)
14507 {
14508 case 0x00:
14509 goto op_semantics_129;
14510 break;
14511 default: UNSUPPORTED(); break;
14512 }
14513 break;
14514 case 0xd2:
14515 GETBYTE ();
14516 switch (op[3] & 0xff)
14517 {
14518 case 0x00:
14519 goto op_semantics_129;
14520 break;
14521 default: UNSUPPORTED(); break;
14522 }
14523 break;
14524 case 0xd3:
14525 GETBYTE ();
14526 switch (op[3] & 0xff)
14527 {
14528 case 0x00:
14529 goto op_semantics_129;
14530 break;
14531 default: UNSUPPORTED(); break;
14532 }
14533 break;
14534 case 0xd4:
14535 GETBYTE ();
14536 switch (op[3] & 0xff)
14537 {
14538 case 0x00:
14539 goto op_semantics_129;
14540 break;
14541 default: UNSUPPORTED(); break;
14542 }
14543 break;
14544 case 0xd5:
14545 GETBYTE ();
14546 switch (op[3] & 0xff)
14547 {
14548 case 0x00:
14549 goto op_semantics_129;
14550 break;
14551 default: UNSUPPORTED(); break;
14552 }
14553 break;
14554 case 0xd6:
14555 GETBYTE ();
14556 switch (op[3] & 0xff)
14557 {
14558 case 0x00:
14559 goto op_semantics_129;
14560 break;
14561 default: UNSUPPORTED(); break;
14562 }
14563 break;
14564 case 0xd7:
14565 GETBYTE ();
14566 switch (op[3] & 0xff)
14567 {
14568 case 0x00:
14569 goto op_semantics_129;
14570 break;
14571 default: UNSUPPORTED(); break;
14572 }
14573 break;
14574 case 0xd8:
14575 GETBYTE ();
14576 switch (op[3] & 0xff)
14577 {
14578 case 0x00:
14579 goto op_semantics_129;
14580 break;
14581 default: UNSUPPORTED(); break;
14582 }
14583 break;
14584 case 0xd9:
14585 GETBYTE ();
14586 switch (op[3] & 0xff)
14587 {
14588 case 0x00:
14589 goto op_semantics_129;
14590 break;
14591 default: UNSUPPORTED(); break;
14592 }
14593 break;
14594 case 0xda:
14595 GETBYTE ();
14596 switch (op[3] & 0xff)
14597 {
14598 case 0x00:
14599 goto op_semantics_129;
14600 break;
14601 default: UNSUPPORTED(); break;
14602 }
14603 break;
14604 case 0xdb:
14605 GETBYTE ();
14606 switch (op[3] & 0xff)
14607 {
14608 case 0x00:
14609 goto op_semantics_129;
14610 break;
14611 default: UNSUPPORTED(); break;
14612 }
14613 break;
14614 case 0xdc:
14615 GETBYTE ();
14616 switch (op[3] & 0xff)
14617 {
14618 case 0x00:
14619 goto op_semantics_129;
14620 break;
14621 default: UNSUPPORTED(); break;
14622 }
14623 break;
14624 case 0xdd:
14625 GETBYTE ();
14626 switch (op[3] & 0xff)
14627 {
14628 case 0x00:
14629 goto op_semantics_129;
14630 break;
14631 default: UNSUPPORTED(); break;
14632 }
14633 break;
14634 case 0xde:
14635 GETBYTE ();
14636 switch (op[3] & 0xff)
14637 {
14638 case 0x00:
14639 goto op_semantics_129;
14640 break;
14641 default: UNSUPPORTED(); break;
14642 }
14643 break;
14644 case 0xdf:
14645 GETBYTE ();
14646 switch (op[3] & 0xff)
14647 {
14648 case 0x00:
14649 goto op_semantics_129;
14650 break;
14651 default: UNSUPPORTED(); break;
14652 }
14653 break;
14654 case 0xe0:
14655 {
14656 /** 1111 1101 0111 0110 1110 0000 save #%1 */
14657 if (trace)
14658 {
14659 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14660 "/** 1111 1101 0111 0110 1110 0000 save #%1 */",
14661 op[0], op[1], op[2]);
14662 }
14663 SYNTAX("save #%1");
14664 #line 1164 "rx-decode.opc"
14665 ID(save); SC(IMM(1)); F_____;
14666
14667 }
14668 break;
14669 case 0xf0:
14670 {
14671 /** 1111 1101 0111 0110 1111 0000 rstr #%1 */
14672 if (trace)
14673 {
14674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14675 "/** 1111 1101 0111 0110 1111 0000 rstr #%1 */",
14676 op[0], op[1], op[2]);
14677 }
14678 SYNTAX("rstr #%1");
14679 #line 1158 "rx-decode.opc"
14680 ID(rstr); SC(IMM(1)); F_____;
14681
14682 }
14683 break;
14684 default: UNSUPPORTED(); break;
14685 }
14686 break;
14687 case 0x77:
14688 GETBYTE ();
14689 switch (op[2] & 0xff)
14690 {
14691 case 0x00:
14692 case 0x01:
14693 case 0x02:
14694 case 0x03:
14695 case 0x04:
14696 case 0x05:
14697 case 0x06:
14698 case 0x07:
14699 case 0x08:
14700 case 0x09:
14701 case 0x0a:
14702 case 0x0b:
14703 case 0x0c:
14704 case 0x0d:
14705 case 0x0e:
14706 case 0x0f:
14707 case 0x10:
14708 case 0x11:
14709 case 0x12:
14710 case 0x13:
14711 case 0x14:
14712 case 0x15:
14713 case 0x16:
14714 case 0x17:
14715 case 0x18:
14716 case 0x19:
14717 case 0x1a:
14718 case 0x1b:
14719 case 0x1c:
14720 case 0x1d:
14721 case 0x1e:
14722 case 0x1f:
14723 goto op_semantics_124;
14724 break;
14725 case 0x80:
14726 GETBYTE ();
14727 switch (op[3] & 0x0f)
14728 {
14729 case 0x00:
14730 op_semantics_130:
14731 {
14732 /** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */
14733 #line 1170 "rx-decode.opc"
14734 int rsrc AU = op[2] & 0x0f;
14735 #line 1170 "rx-decode.opc"
14736 int rdst AU = (op[3] >> 4) & 0x0f;
14737 if (trace)
14738 {
14739 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14740 "/** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */",
14741 op[0], op[1], op[2], op[3]);
14742 printf (" rsrc = 0x%x,", rsrc);
14743 printf (" rdst = 0x%x\n", rdst);
14744 }
14745 SYNTAX("dmov.l %1, %0");
14746 #line 1170 "rx-decode.opc"
14747 ID(dmov); DDRL(rdst); SR(rsrc); F_____;
14748
14749 }
14750 break;
14751 case 0x02:
14752 case 0x03:
14753 op_semantics_131:
14754 {
14755 /** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */
14756 #line 1167 "rx-decode.opc"
14757 int rsrc AU = op[2] & 0x0f;
14758 #line 1167 "rx-decode.opc"
14759 int rdst AU = (op[3] >> 4) & 0x0f;
14760 #line 1167 "rx-decode.opc"
14761 int s AU = op[3] & 0x01;
14762 if (trace)
14763 {
14764 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14765 "/** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */",
14766 op[0], op[1], op[2], op[3]);
14767 printf (" rsrc = 0x%x,", rsrc);
14768 printf (" rdst = 0x%x,", rdst);
14769 printf (" s = 0x%x\n", s);
14770 }
14771 SYNTAX("dmov%s %1, %0");
14772 #line 1167 "rx-decode.opc"
14773 ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____;
14774
14775 }
14776 break;
14777 case 0x04:
14778 op_semantics_132:
14779 {
14780 /** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */
14781 #line 1232 "rx-decode.opc"
14782 int rdst AU = op[2] & 0x0f;
14783 #line 1232 "rx-decode.opc"
14784 int rsrc AU = (op[3] >> 4) & 0x0f;
14785 if (trace)
14786 {
14787 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14788 "/** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */",
14789 op[0], op[1], op[2], op[3]);
14790 printf (" rdst = 0x%x,", rdst);
14791 printf (" rsrc = 0x%x\n", rsrc);
14792 }
14793 SYNTAX("mvtdc %1, %0");
14794 #line 1232 "rx-decode.opc"
14795 ID(mvtdc); DCR(rdst); SR(rsrc); F_____;
14796
14797 }
14798 break;
14799 case 0x09:
14800 op_semantics_133:
14801 {
14802 /** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */
14803 #line 1274 "rx-decode.opc"
14804 int rsrc AU = op[2] & 0x0f;
14805 #line 1274 "rx-decode.opc"
14806 int rdst AU = (op[3] >> 4) & 0x0f;
14807 if (trace)
14808 {
14809 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14810 "/** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */",
14811 op[0], op[1], op[2], op[3]);
14812 printf (" rsrc = 0x%x,", rsrc);
14813 printf (" rdst = 0x%x\n", rdst);
14814 }
14815 SYNTAX("itod %1, %0");
14816 #line 1274 "rx-decode.opc"
14817 ID(itod); DDR(rdst); SR(rsrc); F_____;
14818
14819 }
14820 break;
14821 case 0x0a:
14822 op_semantics_134:
14823 {
14824 /** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */
14825 #line 1271 "rx-decode.opc"
14826 int rsrc AU = op[2] & 0x0f;
14827 #line 1271 "rx-decode.opc"
14828 int rdst AU = (op[3] >> 4) & 0x0f;
14829 if (trace)
14830 {
14831 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14832 "/** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */",
14833 op[0], op[1], op[2], op[3]);
14834 printf (" rsrc = 0x%x,", rsrc);
14835 printf (" rdst = 0x%x\n", rdst);
14836 }
14837 SYNTAX("ftod %1, %0");
14838 #line 1271 "rx-decode.opc"
14839 ID(ftod); DDR(rdst); SR(rsrc); F_____;
14840
14841 }
14842 break;
14843 case 0x0d:
14844 op_semantics_135:
14845 {
14846 /** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */
14847 #line 1277 "rx-decode.opc"
14848 int rsrc AU = op[2] & 0x0f;
14849 #line 1277 "rx-decode.opc"
14850 int rdst AU = (op[3] >> 4) & 0x0f;
14851 if (trace)
14852 {
14853 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14854 "/** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */",
14855 op[0], op[1], op[2], op[3]);
14856 printf (" rsrc = 0x%x,", rsrc);
14857 printf (" rdst = 0x%x\n", rdst);
14858 }
14859 SYNTAX("utod %1, %0");
14860 #line 1277 "rx-decode.opc"
14861 ID(dsqrt); DDR(rdst); SR(rsrc); F_____;
14862
14863 }
14864 break;
14865 default: UNSUPPORTED(); break;
14866 }
14867 break;
14868 case 0x81:
14869 GETBYTE ();
14870 switch (op[3] & 0x0f)
14871 {
14872 case 0x00:
14873 goto op_semantics_130;
14874 break;
14875 case 0x02:
14876 case 0x03:
14877 goto op_semantics_131;
14878 break;
14879 case 0x04:
14880 goto op_semantics_132;
14881 break;
14882 case 0x09:
14883 goto op_semantics_133;
14884 break;
14885 case 0x0a:
14886 goto op_semantics_134;
14887 break;
14888 case 0x0d:
14889 goto op_semantics_135;
14890 break;
14891 default: UNSUPPORTED(); break;
14892 }
14893 break;
14894 case 0x82:
14895 GETBYTE ();
14896 switch (op[3] & 0x0f)
14897 {
14898 case 0x00:
14899 goto op_semantics_130;
14900 break;
14901 case 0x02:
14902 case 0x03:
14903 goto op_semantics_131;
14904 break;
14905 case 0x04:
14906 goto op_semantics_132;
14907 break;
14908 case 0x09:
14909 goto op_semantics_133;
14910 break;
14911 case 0x0a:
14912 goto op_semantics_134;
14913 break;
14914 case 0x0d:
14915 goto op_semantics_135;
14916 break;
14917 default: UNSUPPORTED(); break;
14918 }
14919 break;
14920 case 0x83:
14921 GETBYTE ();
14922 switch (op[3] & 0x0f)
14923 {
14924 case 0x00:
14925 goto op_semantics_130;
14926 break;
14927 case 0x02:
14928 case 0x03:
14929 goto op_semantics_131;
14930 break;
14931 case 0x04:
14932 goto op_semantics_132;
14933 break;
14934 case 0x09:
14935 goto op_semantics_133;
14936 break;
14937 case 0x0a:
14938 goto op_semantics_134;
14939 break;
14940 case 0x0d:
14941 goto op_semantics_135;
14942 break;
14943 default: UNSUPPORTED(); break;
14944 }
14945 break;
14946 case 0x84:
14947 GETBYTE ();
14948 switch (op[3] & 0x0f)
14949 {
14950 case 0x00:
14951 goto op_semantics_130;
14952 break;
14953 case 0x02:
14954 case 0x03:
14955 goto op_semantics_131;
14956 break;
14957 case 0x04:
14958 goto op_semantics_132;
14959 break;
14960 case 0x09:
14961 goto op_semantics_133;
14962 break;
14963 case 0x0a:
14964 goto op_semantics_134;
14965 break;
14966 case 0x0d:
14967 goto op_semantics_135;
14968 break;
14969 default: UNSUPPORTED(); break;
14970 }
14971 break;
14972 case 0x85:
14973 GETBYTE ();
14974 switch (op[3] & 0x0f)
14975 {
14976 case 0x00:
14977 goto op_semantics_130;
14978 break;
14979 case 0x02:
14980 case 0x03:
14981 goto op_semantics_131;
14982 break;
14983 case 0x04:
14984 goto op_semantics_132;
14985 break;
14986 case 0x09:
14987 goto op_semantics_133;
14988 break;
14989 case 0x0a:
14990 goto op_semantics_134;
14991 break;
14992 case 0x0d:
14993 goto op_semantics_135;
14994 break;
14995 default: UNSUPPORTED(); break;
14996 }
14997 break;
14998 case 0x86:
14999 GETBYTE ();
15000 switch (op[3] & 0x0f)
15001 {
15002 case 0x00:
15003 goto op_semantics_130;
15004 break;
15005 case 0x02:
15006 case 0x03:
15007 goto op_semantics_131;
15008 break;
15009 case 0x04:
15010 goto op_semantics_132;
15011 break;
15012 case 0x09:
15013 goto op_semantics_133;
15014 break;
15015 case 0x0a:
15016 goto op_semantics_134;
15017 break;
15018 case 0x0d:
15019 goto op_semantics_135;
15020 break;
15021 default: UNSUPPORTED(); break;
15022 }
15023 break;
15024 case 0x87:
15025 GETBYTE ();
15026 switch (op[3] & 0x0f)
15027 {
15028 case 0x00:
15029 goto op_semantics_130;
15030 break;
15031 case 0x02:
15032 case 0x03:
15033 goto op_semantics_131;
15034 break;
15035 case 0x04:
15036 goto op_semantics_132;
15037 break;
15038 case 0x09:
15039 goto op_semantics_133;
15040 break;
15041 case 0x0a:
15042 goto op_semantics_134;
15043 break;
15044 case 0x0d:
15045 goto op_semantics_135;
15046 break;
15047 default: UNSUPPORTED(); break;
15048 }
15049 break;
15050 case 0x88:
15051 GETBYTE ();
15052 switch (op[3] & 0x0f)
15053 {
15054 case 0x00:
15055 goto op_semantics_130;
15056 break;
15057 case 0x02:
15058 case 0x03:
15059 goto op_semantics_131;
15060 break;
15061 case 0x04:
15062 goto op_semantics_132;
15063 break;
15064 case 0x09:
15065 goto op_semantics_133;
15066 break;
15067 case 0x0a:
15068 goto op_semantics_134;
15069 break;
15070 case 0x0d:
15071 goto op_semantics_135;
15072 break;
15073 default: UNSUPPORTED(); break;
15074 }
15075 break;
15076 case 0x89:
15077 GETBYTE ();
15078 switch (op[3] & 0x0f)
15079 {
15080 case 0x00:
15081 goto op_semantics_130;
15082 break;
15083 case 0x02:
15084 case 0x03:
15085 goto op_semantics_131;
15086 break;
15087 case 0x04:
15088 goto op_semantics_132;
15089 break;
15090 case 0x09:
15091 goto op_semantics_133;
15092 break;
15093 case 0x0a:
15094 goto op_semantics_134;
15095 break;
15096 case 0x0d:
15097 goto op_semantics_135;
15098 break;
15099 default: UNSUPPORTED(); break;
15100 }
15101 break;
15102 case 0x8a:
15103 GETBYTE ();
15104 switch (op[3] & 0x0f)
15105 {
15106 case 0x00:
15107 goto op_semantics_130;
15108 break;
15109 case 0x02:
15110 case 0x03:
15111 goto op_semantics_131;
15112 break;
15113 case 0x04:
15114 goto op_semantics_132;
15115 break;
15116 case 0x09:
15117 goto op_semantics_133;
15118 break;
15119 case 0x0a:
15120 goto op_semantics_134;
15121 break;
15122 case 0x0d:
15123 goto op_semantics_135;
15124 break;
15125 default: UNSUPPORTED(); break;
15126 }
15127 break;
15128 case 0x8b:
15129 GETBYTE ();
15130 switch (op[3] & 0x0f)
15131 {
15132 case 0x00:
15133 goto op_semantics_130;
15134 break;
15135 case 0x02:
15136 case 0x03:
15137 goto op_semantics_131;
15138 break;
15139 case 0x04:
15140 goto op_semantics_132;
15141 break;
15142 case 0x09:
15143 goto op_semantics_133;
15144 break;
15145 case 0x0a:
15146 goto op_semantics_134;
15147 break;
15148 case 0x0d:
15149 goto op_semantics_135;
15150 break;
15151 default: UNSUPPORTED(); break;
15152 }
15153 break;
15154 case 0x8c:
15155 GETBYTE ();
15156 switch (op[3] & 0x0f)
15157 {
15158 case 0x00:
15159 goto op_semantics_130;
15160 break;
15161 case 0x02:
15162 case 0x03:
15163 goto op_semantics_131;
15164 break;
15165 case 0x04:
15166 goto op_semantics_132;
15167 break;
15168 case 0x09:
15169 goto op_semantics_133;
15170 break;
15171 case 0x0a:
15172 goto op_semantics_134;
15173 break;
15174 case 0x0d:
15175 goto op_semantics_135;
15176 break;
15177 default: UNSUPPORTED(); break;
15178 }
15179 break;
15180 case 0x8d:
15181 GETBYTE ();
15182 switch (op[3] & 0x0f)
15183 {
15184 case 0x00:
15185 goto op_semantics_130;
15186 break;
15187 case 0x02:
15188 case 0x03:
15189 goto op_semantics_131;
15190 break;
15191 case 0x04:
15192 goto op_semantics_132;
15193 break;
15194 case 0x09:
15195 goto op_semantics_133;
15196 break;
15197 case 0x0a:
15198 goto op_semantics_134;
15199 break;
15200 case 0x0d:
15201 goto op_semantics_135;
15202 break;
15203 default: UNSUPPORTED(); break;
15204 }
15205 break;
15206 case 0x8e:
15207 GETBYTE ();
15208 switch (op[3] & 0x0f)
15209 {
15210 case 0x00:
15211 goto op_semantics_130;
15212 break;
15213 case 0x02:
15214 case 0x03:
15215 goto op_semantics_131;
15216 break;
15217 case 0x04:
15218 goto op_semantics_132;
15219 break;
15220 case 0x09:
15221 goto op_semantics_133;
15222 break;
15223 case 0x0a:
15224 goto op_semantics_134;
15225 break;
15226 case 0x0d:
15227 goto op_semantics_135;
15228 break;
15229 default: UNSUPPORTED(); break;
15230 }
15231 break;
15232 case 0x8f:
15233 GETBYTE ();
15234 switch (op[3] & 0x0f)
15235 {
15236 case 0x00:
15237 goto op_semantics_130;
15238 break;
15239 case 0x02:
15240 case 0x03:
15241 goto op_semantics_131;
15242 break;
15243 case 0x04:
15244 goto op_semantics_132;
15245 break;
15246 case 0x09:
15247 goto op_semantics_133;
15248 break;
15249 case 0x0a:
15250 goto op_semantics_134;
15251 break;
15252 case 0x0d:
15253 goto op_semantics_135;
15254 break;
15255 default: UNSUPPORTED(); break;
15256 }
15257 break;
15258 default: UNSUPPORTED(); break;
15259 }
15260 break;
15261 case 0x78:
15262 GETBYTE ();
15263 switch (op[2] & 0xf0)
15264 {
15265 case 0x20:
15266 goto op_semantics_113;
15267 break;
15268 case 0x40:
15269 goto op_semantics_114;
15270 break;
15271 case 0x50:
15272 goto op_semantics_115;
15273 break;
15274 case 0x60:
15275 goto op_semantics_116;
15276 break;
15277 case 0x70:
15278 goto op_semantics_117;
15279 break;
15280 case 0x80:
15281 goto op_semantics_118;
15282 break;
15283 case 0x90:
15284 goto op_semantics_119;
15285 break;
15286 case 0xc0:
15287 goto op_semantics_120;
15288 break;
15289 case 0xd0:
15290 goto op_semantics_121;
15291 break;
15292 case 0xe0:
15293 goto op_semantics_122;
15294 break;
15295 case 0xf0:
15296 goto op_semantics_123;
15297 break;
15298 default: UNSUPPORTED(); break;
15299 }
15300 break;
15301 case 0x7b:
15302 GETBYTE ();
15303 switch (op[2] & 0xe0)
15304 {
15305 case 0x00:
15306 goto op_semantics_124;
15307 break;
15308 default: UNSUPPORTED(); break;
15309 }
15310 break;
15311 case 0x7c:
15312 GETBYTE ();
15313 switch (op[2] & 0xf0)
15314 {
15315 case 0x20:
15316 goto op_semantics_113;
15317 break;
15318 case 0x40:
15319 goto op_semantics_114;
15320 break;
15321 case 0x50:
15322 goto op_semantics_115;
15323 break;
15324 case 0x60:
15325 goto op_semantics_116;
15326 break;
15327 case 0x70:
15328 goto op_semantics_117;
15329 break;
15330 case 0x80:
15331 goto op_semantics_118;
15332 break;
15333 case 0x90:
15334 goto op_semantics_119;
15335 break;
15336 case 0xc0:
15337 goto op_semantics_120;
15338 break;
15339 case 0xd0:
15340 goto op_semantics_121;
15341 break;
15342 case 0xe0:
15343 goto op_semantics_122;
15344 break;
15345 case 0xf0:
15346 goto op_semantics_123;
15347 break;
15348 default: UNSUPPORTED(); break;
15349 }
15350 break;
15351 case 0x7f:
15352 GETBYTE ();
15353 switch (op[2] & 0xe0)
15354 {
15355 case 0x00:
15356 goto op_semantics_124;
15357 break;
15358 default: UNSUPPORTED(); break;
15359 }
15360 break;
15361 case 0x80:
15362 GETBYTE ();
15363 switch (op[2] & 0x00)
15364 {
15365 case 0x00:
15366 op_semantics_136:
15367 {
15368 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
15369 #line 757 "rx-decode.opc"
15370 int immmm AU = op[1] & 0x1f;
15371 #line 757 "rx-decode.opc"
15372 int rsrc AU = (op[2] >> 4) & 0x0f;
15373 #line 757 "rx-decode.opc"
15374 int rdst AU = op[2] & 0x0f;
15375 if (trace)
15376 {
15377 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15378 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
15379 op[0], op[1], op[2]);
15380 printf (" immmm = 0x%x,", immmm);
15381 printf (" rsrc = 0x%x,", rsrc);
15382 printf (" rdst = 0x%x\n", rdst);
15383 }
15384 SYNTAX("shlr #%2, %1, %0");
15385 #line 757 "rx-decode.opc"
15386 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
15387
15388 /*----------------------------------------------------------------------*/
15389 /* ROTATE */
15390
15391 }
15392 break;
15393 }
15394 break;
15395 case 0x81:
15396 GETBYTE ();
15397 switch (op[2] & 0x00)
15398 {
15399 case 0x00:
15400 goto op_semantics_136;
15401 break;
15402 }
15403 break;
15404 case 0x82:
15405 GETBYTE ();
15406 switch (op[2] & 0x00)
15407 {
15408 case 0x00:
15409 goto op_semantics_136;
15410 break;
15411 }
15412 break;
15413 case 0x83:
15414 GETBYTE ();
15415 switch (op[2] & 0x00)
15416 {
15417 case 0x00:
15418 goto op_semantics_136;
15419 break;
15420 }
15421 break;
15422 case 0x84:
15423 GETBYTE ();
15424 switch (op[2] & 0x00)
15425 {
15426 case 0x00:
15427 goto op_semantics_136;
15428 break;
15429 }
15430 break;
15431 case 0x85:
15432 GETBYTE ();
15433 switch (op[2] & 0x00)
15434 {
15435 case 0x00:
15436 goto op_semantics_136;
15437 break;
15438 }
15439 break;
15440 case 0x86:
15441 GETBYTE ();
15442 switch (op[2] & 0x00)
15443 {
15444 case 0x00:
15445 goto op_semantics_136;
15446 break;
15447 }
15448 break;
15449 case 0x87:
15450 GETBYTE ();
15451 switch (op[2] & 0x00)
15452 {
15453 case 0x00:
15454 goto op_semantics_136;
15455 break;
15456 }
15457 break;
15458 case 0x88:
15459 GETBYTE ();
15460 switch (op[2] & 0x00)
15461 {
15462 case 0x00:
15463 goto op_semantics_136;
15464 break;
15465 }
15466 break;
15467 case 0x89:
15468 GETBYTE ();
15469 switch (op[2] & 0x00)
15470 {
15471 case 0x00:
15472 goto op_semantics_136;
15473 break;
15474 }
15475 break;
15476 case 0x8a:
15477 GETBYTE ();
15478 switch (op[2] & 0x00)
15479 {
15480 case 0x00:
15481 goto op_semantics_136;
15482 break;
15483 }
15484 break;
15485 case 0x8b:
15486 GETBYTE ();
15487 switch (op[2] & 0x00)
15488 {
15489 case 0x00:
15490 goto op_semantics_136;
15491 break;
15492 }
15493 break;
15494 case 0x8c:
15495 GETBYTE ();
15496 switch (op[2] & 0x00)
15497 {
15498 case 0x00:
15499 goto op_semantics_136;
15500 break;
15501 }
15502 break;
15503 case 0x8d:
15504 GETBYTE ();
15505 switch (op[2] & 0x00)
15506 {
15507 case 0x00:
15508 goto op_semantics_136;
15509 break;
15510 }
15511 break;
15512 case 0x8e:
15513 GETBYTE ();
15514 switch (op[2] & 0x00)
15515 {
15516 case 0x00:
15517 goto op_semantics_136;
15518 break;
15519 }
15520 break;
15521 case 0x8f:
15522 GETBYTE ();
15523 switch (op[2] & 0x00)
15524 {
15525 case 0x00:
15526 goto op_semantics_136;
15527 break;
15528 }
15529 break;
15530 case 0x90:
15531 GETBYTE ();
15532 switch (op[2] & 0x00)
15533 {
15534 case 0x00:
15535 goto op_semantics_136;
15536 break;
15537 }
15538 break;
15539 case 0x91:
15540 GETBYTE ();
15541 switch (op[2] & 0x00)
15542 {
15543 case 0x00:
15544 goto op_semantics_136;
15545 break;
15546 }
15547 break;
15548 case 0x92:
15549 GETBYTE ();
15550 switch (op[2] & 0x00)
15551 {
15552 case 0x00:
15553 goto op_semantics_136;
15554 break;
15555 }
15556 break;
15557 case 0x93:
15558 GETBYTE ();
15559 switch (op[2] & 0x00)
15560 {
15561 case 0x00:
15562 goto op_semantics_136;
15563 break;
15564 }
15565 break;
15566 case 0x94:
15567 GETBYTE ();
15568 switch (op[2] & 0x00)
15569 {
15570 case 0x00:
15571 goto op_semantics_136;
15572 break;
15573 }
15574 break;
15575 case 0x95:
15576 GETBYTE ();
15577 switch (op[2] & 0x00)
15578 {
15579 case 0x00:
15580 goto op_semantics_136;
15581 break;
15582 }
15583 break;
15584 case 0x96:
15585 GETBYTE ();
15586 switch (op[2] & 0x00)
15587 {
15588 case 0x00:
15589 goto op_semantics_136;
15590 break;
15591 }
15592 break;
15593 case 0x97:
15594 GETBYTE ();
15595 switch (op[2] & 0x00)
15596 {
15597 case 0x00:
15598 goto op_semantics_136;
15599 break;
15600 }
15601 break;
15602 case 0x98:
15603 GETBYTE ();
15604 switch (op[2] & 0x00)
15605 {
15606 case 0x00:
15607 goto op_semantics_136;
15608 break;
15609 }
15610 break;
15611 case 0x99:
15612 GETBYTE ();
15613 switch (op[2] & 0x00)
15614 {
15615 case 0x00:
15616 goto op_semantics_136;
15617 break;
15618 }
15619 break;
15620 case 0x9a:
15621 GETBYTE ();
15622 switch (op[2] & 0x00)
15623 {
15624 case 0x00:
15625 goto op_semantics_136;
15626 break;
15627 }
15628 break;
15629 case 0x9b:
15630 GETBYTE ();
15631 switch (op[2] & 0x00)
15632 {
15633 case 0x00:
15634 goto op_semantics_136;
15635 break;
15636 }
15637 break;
15638 case 0x9c:
15639 GETBYTE ();
15640 switch (op[2] & 0x00)
15641 {
15642 case 0x00:
15643 goto op_semantics_136;
15644 break;
15645 }
15646 break;
15647 case 0x9d:
15648 GETBYTE ();
15649 switch (op[2] & 0x00)
15650 {
15651 case 0x00:
15652 goto op_semantics_136;
15653 break;
15654 }
15655 break;
15656 case 0x9e:
15657 GETBYTE ();
15658 switch (op[2] & 0x00)
15659 {
15660 case 0x00:
15661 goto op_semantics_136;
15662 break;
15663 }
15664 break;
15665 case 0x9f:
15666 GETBYTE ();
15667 switch (op[2] & 0x00)
15668 {
15669 case 0x00:
15670 goto op_semantics_136;
15671 break;
15672 }
15673 break;
15674 case 0xa0:
15675 GETBYTE ();
15676 switch (op[2] & 0x00)
15677 {
15678 case 0x00:
15679 op_semantics_137:
15680 {
15681 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
15682 #line 747 "rx-decode.opc"
15683 int immmm AU = op[1] & 0x1f;
15684 #line 747 "rx-decode.opc"
15685 int rsrc AU = (op[2] >> 4) & 0x0f;
15686 #line 747 "rx-decode.opc"
15687 int rdst AU = op[2] & 0x0f;
15688 if (trace)
15689 {
15690 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15691 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
15692 op[0], op[1], op[2]);
15693 printf (" immmm = 0x%x,", immmm);
15694 printf (" rsrc = 0x%x,", rsrc);
15695 printf (" rdst = 0x%x\n", rdst);
15696 }
15697 SYNTAX("shar #%2, %1, %0");
15698 #line 747 "rx-decode.opc"
15699 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
15700
15701
15702 }
15703 break;
15704 }
15705 break;
15706 case 0xa1:
15707 GETBYTE ();
15708 switch (op[2] & 0x00)
15709 {
15710 case 0x00:
15711 goto op_semantics_137;
15712 break;
15713 }
15714 break;
15715 case 0xa2:
15716 GETBYTE ();
15717 switch (op[2] & 0x00)
15718 {
15719 case 0x00:
15720 goto op_semantics_137;
15721 break;
15722 }
15723 break;
15724 case 0xa3:
15725 GETBYTE ();
15726 switch (op[2] & 0x00)
15727 {
15728 case 0x00:
15729 goto op_semantics_137;
15730 break;
15731 }
15732 break;
15733 case 0xa4:
15734 GETBYTE ();
15735 switch (op[2] & 0x00)
15736 {
15737 case 0x00:
15738 goto op_semantics_137;
15739 break;
15740 }
15741 break;
15742 case 0xa5:
15743 GETBYTE ();
15744 switch (op[2] & 0x00)
15745 {
15746 case 0x00:
15747 goto op_semantics_137;
15748 break;
15749 }
15750 break;
15751 case 0xa6:
15752 GETBYTE ();
15753 switch (op[2] & 0x00)
15754 {
15755 case 0x00:
15756 goto op_semantics_137;
15757 break;
15758 }
15759 break;
15760 case 0xa7:
15761 GETBYTE ();
15762 switch (op[2] & 0x00)
15763 {
15764 case 0x00:
15765 goto op_semantics_137;
15766 break;
15767 }
15768 break;
15769 case 0xa8:
15770 GETBYTE ();
15771 switch (op[2] & 0x00)
15772 {
15773 case 0x00:
15774 goto op_semantics_137;
15775 break;
15776 }
15777 break;
15778 case 0xa9:
15779 GETBYTE ();
15780 switch (op[2] & 0x00)
15781 {
15782 case 0x00:
15783 goto op_semantics_137;
15784 break;
15785 }
15786 break;
15787 case 0xaa:
15788 GETBYTE ();
15789 switch (op[2] & 0x00)
15790 {
15791 case 0x00:
15792 goto op_semantics_137;
15793 break;
15794 }
15795 break;
15796 case 0xab:
15797 GETBYTE ();
15798 switch (op[2] & 0x00)
15799 {
15800 case 0x00:
15801 goto op_semantics_137;
15802 break;
15803 }
15804 break;
15805 case 0xac:
15806 GETBYTE ();
15807 switch (op[2] & 0x00)
15808 {
15809 case 0x00:
15810 goto op_semantics_137;
15811 break;
15812 }
15813 break;
15814 case 0xad:
15815 GETBYTE ();
15816 switch (op[2] & 0x00)
15817 {
15818 case 0x00:
15819 goto op_semantics_137;
15820 break;
15821 }
15822 break;
15823 case 0xae:
15824 GETBYTE ();
15825 switch (op[2] & 0x00)
15826 {
15827 case 0x00:
15828 goto op_semantics_137;
15829 break;
15830 }
15831 break;
15832 case 0xaf:
15833 GETBYTE ();
15834 switch (op[2] & 0x00)
15835 {
15836 case 0x00:
15837 goto op_semantics_137;
15838 break;
15839 }
15840 break;
15841 case 0xb0:
15842 GETBYTE ();
15843 switch (op[2] & 0x00)
15844 {
15845 case 0x00:
15846 goto op_semantics_137;
15847 break;
15848 }
15849 break;
15850 case 0xb1:
15851 GETBYTE ();
15852 switch (op[2] & 0x00)
15853 {
15854 case 0x00:
15855 goto op_semantics_137;
15856 break;
15857 }
15858 break;
15859 case 0xb2:
15860 GETBYTE ();
15861 switch (op[2] & 0x00)
15862 {
15863 case 0x00:
15864 goto op_semantics_137;
15865 break;
15866 }
15867 break;
15868 case 0xb3:
15869 GETBYTE ();
15870 switch (op[2] & 0x00)
15871 {
15872 case 0x00:
15873 goto op_semantics_137;
15874 break;
15875 }
15876 break;
15877 case 0xb4:
15878 GETBYTE ();
15879 switch (op[2] & 0x00)
15880 {
15881 case 0x00:
15882 goto op_semantics_137;
15883 break;
15884 }
15885 break;
15886 case 0xb5:
15887 GETBYTE ();
15888 switch (op[2] & 0x00)
15889 {
15890 case 0x00:
15891 goto op_semantics_137;
15892 break;
15893 }
15894 break;
15895 case 0xb6:
15896 GETBYTE ();
15897 switch (op[2] & 0x00)
15898 {
15899 case 0x00:
15900 goto op_semantics_137;
15901 break;
15902 }
15903 break;
15904 case 0xb7:
15905 GETBYTE ();
15906 switch (op[2] & 0x00)
15907 {
15908 case 0x00:
15909 goto op_semantics_137;
15910 break;
15911 }
15912 break;
15913 case 0xb8:
15914 GETBYTE ();
15915 switch (op[2] & 0x00)
15916 {
15917 case 0x00:
15918 goto op_semantics_137;
15919 break;
15920 }
15921 break;
15922 case 0xb9:
15923 GETBYTE ();
15924 switch (op[2] & 0x00)
15925 {
15926 case 0x00:
15927 goto op_semantics_137;
15928 break;
15929 }
15930 break;
15931 case 0xba:
15932 GETBYTE ();
15933 switch (op[2] & 0x00)
15934 {
15935 case 0x00:
15936 goto op_semantics_137;
15937 break;
15938 }
15939 break;
15940 case 0xbb:
15941 GETBYTE ();
15942 switch (op[2] & 0x00)
15943 {
15944 case 0x00:
15945 goto op_semantics_137;
15946 break;
15947 }
15948 break;
15949 case 0xbc:
15950 GETBYTE ();
15951 switch (op[2] & 0x00)
15952 {
15953 case 0x00:
15954 goto op_semantics_137;
15955 break;
15956 }
15957 break;
15958 case 0xbd:
15959 GETBYTE ();
15960 switch (op[2] & 0x00)
15961 {
15962 case 0x00:
15963 goto op_semantics_137;
15964 break;
15965 }
15966 break;
15967 case 0xbe:
15968 GETBYTE ();
15969 switch (op[2] & 0x00)
15970 {
15971 case 0x00:
15972 goto op_semantics_137;
15973 break;
15974 }
15975 break;
15976 case 0xbf:
15977 GETBYTE ();
15978 switch (op[2] & 0x00)
15979 {
15980 case 0x00:
15981 goto op_semantics_137;
15982 break;
15983 }
15984 break;
15985 case 0xc0:
15986 GETBYTE ();
15987 switch (op[2] & 0x00)
15988 {
15989 case 0x00:
15990 op_semantics_138:
15991 {
15992 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
15993 #line 737 "rx-decode.opc"
15994 int immmm AU = op[1] & 0x1f;
15995 #line 737 "rx-decode.opc"
15996 int rsrc AU = (op[2] >> 4) & 0x0f;
15997 #line 737 "rx-decode.opc"
15998 int rdst AU = op[2] & 0x0f;
15999 if (trace)
16000 {
16001 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16002 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
16003 op[0], op[1], op[2]);
16004 printf (" immmm = 0x%x,", immmm);
16005 printf (" rsrc = 0x%x,", rsrc);
16006 printf (" rdst = 0x%x\n", rdst);
16007 }
16008 SYNTAX("shll #%2, %1, %0");
16009 #line 737 "rx-decode.opc"
16010 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
16011
16012
16013 }
16014 break;
16015 }
16016 break;
16017 case 0xc1:
16018 GETBYTE ();
16019 switch (op[2] & 0x00)
16020 {
16021 case 0x00:
16022 goto op_semantics_138;
16023 break;
16024 }
16025 break;
16026 case 0xc2:
16027 GETBYTE ();
16028 switch (op[2] & 0x00)
16029 {
16030 case 0x00:
16031 goto op_semantics_138;
16032 break;
16033 }
16034 break;
16035 case 0xc3:
16036 GETBYTE ();
16037 switch (op[2] & 0x00)
16038 {
16039 case 0x00:
16040 goto op_semantics_138;
16041 break;
16042 }
16043 break;
16044 case 0xc4:
16045 GETBYTE ();
16046 switch (op[2] & 0x00)
16047 {
16048 case 0x00:
16049 goto op_semantics_138;
16050 break;
16051 }
16052 break;
16053 case 0xc5:
16054 GETBYTE ();
16055 switch (op[2] & 0x00)
16056 {
16057 case 0x00:
16058 goto op_semantics_138;
16059 break;
16060 }
16061 break;
16062 case 0xc6:
16063 GETBYTE ();
16064 switch (op[2] & 0x00)
16065 {
16066 case 0x00:
16067 goto op_semantics_138;
16068 break;
16069 }
16070 break;
16071 case 0xc7:
16072 GETBYTE ();
16073 switch (op[2] & 0x00)
16074 {
16075 case 0x00:
16076 goto op_semantics_138;
16077 break;
16078 }
16079 break;
16080 case 0xc8:
16081 GETBYTE ();
16082 switch (op[2] & 0x00)
16083 {
16084 case 0x00:
16085 goto op_semantics_138;
16086 break;
16087 }
16088 break;
16089 case 0xc9:
16090 GETBYTE ();
16091 switch (op[2] & 0x00)
16092 {
16093 case 0x00:
16094 goto op_semantics_138;
16095 break;
16096 }
16097 break;
16098 case 0xca:
16099 GETBYTE ();
16100 switch (op[2] & 0x00)
16101 {
16102 case 0x00:
16103 goto op_semantics_138;
16104 break;
16105 }
16106 break;
16107 case 0xcb:
16108 GETBYTE ();
16109 switch (op[2] & 0x00)
16110 {
16111 case 0x00:
16112 goto op_semantics_138;
16113 break;
16114 }
16115 break;
16116 case 0xcc:
16117 GETBYTE ();
16118 switch (op[2] & 0x00)
16119 {
16120 case 0x00:
16121 goto op_semantics_138;
16122 break;
16123 }
16124 break;
16125 case 0xcd:
16126 GETBYTE ();
16127 switch (op[2] & 0x00)
16128 {
16129 case 0x00:
16130 goto op_semantics_138;
16131 break;
16132 }
16133 break;
16134 case 0xce:
16135 GETBYTE ();
16136 switch (op[2] & 0x00)
16137 {
16138 case 0x00:
16139 goto op_semantics_138;
16140 break;
16141 }
16142 break;
16143 case 0xcf:
16144 GETBYTE ();
16145 switch (op[2] & 0x00)
16146 {
16147 case 0x00:
16148 goto op_semantics_138;
16149 break;
16150 }
16151 break;
16152 case 0xd0:
16153 GETBYTE ();
16154 switch (op[2] & 0x00)
16155 {
16156 case 0x00:
16157 goto op_semantics_138;
16158 break;
16159 }
16160 break;
16161 case 0xd1:
16162 GETBYTE ();
16163 switch (op[2] & 0x00)
16164 {
16165 case 0x00:
16166 goto op_semantics_138;
16167 break;
16168 }
16169 break;
16170 case 0xd2:
16171 GETBYTE ();
16172 switch (op[2] & 0x00)
16173 {
16174 case 0x00:
16175 goto op_semantics_138;
16176 break;
16177 }
16178 break;
16179 case 0xd3:
16180 GETBYTE ();
16181 switch (op[2] & 0x00)
16182 {
16183 case 0x00:
16184 goto op_semantics_138;
16185 break;
16186 }
16187 break;
16188 case 0xd4:
16189 GETBYTE ();
16190 switch (op[2] & 0x00)
16191 {
16192 case 0x00:
16193 goto op_semantics_138;
16194 break;
16195 }
16196 break;
16197 case 0xd5:
16198 GETBYTE ();
16199 switch (op[2] & 0x00)
16200 {
16201 case 0x00:
16202 goto op_semantics_138;
16203 break;
16204 }
16205 break;
16206 case 0xd6:
16207 GETBYTE ();
16208 switch (op[2] & 0x00)
16209 {
16210 case 0x00:
16211 goto op_semantics_138;
16212 break;
16213 }
16214 break;
16215 case 0xd7:
16216 GETBYTE ();
16217 switch (op[2] & 0x00)
16218 {
16219 case 0x00:
16220 goto op_semantics_138;
16221 break;
16222 }
16223 break;
16224 case 0xd8:
16225 GETBYTE ();
16226 switch (op[2] & 0x00)
16227 {
16228 case 0x00:
16229 goto op_semantics_138;
16230 break;
16231 }
16232 break;
16233 case 0xd9:
16234 GETBYTE ();
16235 switch (op[2] & 0x00)
16236 {
16237 case 0x00:
16238 goto op_semantics_138;
16239 break;
16240 }
16241 break;
16242 case 0xda:
16243 GETBYTE ();
16244 switch (op[2] & 0x00)
16245 {
16246 case 0x00:
16247 goto op_semantics_138;
16248 break;
16249 }
16250 break;
16251 case 0xdb:
16252 GETBYTE ();
16253 switch (op[2] & 0x00)
16254 {
16255 case 0x00:
16256 goto op_semantics_138;
16257 break;
16258 }
16259 break;
16260 case 0xdc:
16261 GETBYTE ();
16262 switch (op[2] & 0x00)
16263 {
16264 case 0x00:
16265 goto op_semantics_138;
16266 break;
16267 }
16268 break;
16269 case 0xdd:
16270 GETBYTE ();
16271 switch (op[2] & 0x00)
16272 {
16273 case 0x00:
16274 goto op_semantics_138;
16275 break;
16276 }
16277 break;
16278 case 0xde:
16279 GETBYTE ();
16280 switch (op[2] & 0x00)
16281 {
16282 case 0x00:
16283 goto op_semantics_138;
16284 break;
16285 }
16286 break;
16287 case 0xdf:
16288 GETBYTE ();
16289 switch (op[2] & 0x00)
16290 {
16291 case 0x00:
16292 goto op_semantics_138;
16293 break;
16294 }
16295 break;
16296 case 0xe0:
16297 GETBYTE ();
16298 switch (op[2] & 0xf0)
16299 {
16300 case 0x00:
16301 case 0x10:
16302 case 0x20:
16303 case 0x30:
16304 case 0x40:
16305 case 0x50:
16306 case 0x60:
16307 case 0x70:
16308 case 0x80:
16309 case 0x90:
16310 case 0xa0:
16311 case 0xb0:
16312 case 0xc0:
16313 case 0xd0:
16314 case 0xe0:
16315 op_semantics_139:
16316 {
16317 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
16318 #line 1011 "rx-decode.opc"
16319 int bittt AU = op[1] & 0x1f;
16320 #line 1011 "rx-decode.opc"
16321 int cond AU = (op[2] >> 4) & 0x0f;
16322 #line 1011 "rx-decode.opc"
16323 int rdst AU = op[2] & 0x0f;
16324 if (trace)
16325 {
16326 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16327 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
16328 op[0], op[1], op[2]);
16329 printf (" bittt = 0x%x,", bittt);
16330 printf (" cond = 0x%x,", cond);
16331 printf (" rdst = 0x%x\n", rdst);
16332 }
16333 SYNTAX("bm%2 #%1, %0%S0");
16334 #line 1011 "rx-decode.opc"
16335 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
16336
16337 /*----------------------------------------------------------------------*/
16338 /* CONTROL REGISTERS */
16339
16340 }
16341 break;
16342 case 0xf0:
16343 op_semantics_140:
16344 {
16345 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
16346 #line 1004 "rx-decode.opc"
16347 int bittt AU = op[1] & 0x1f;
16348 #line 1004 "rx-decode.opc"
16349 int rdst AU = op[2] & 0x0f;
16350 if (trace)
16351 {
16352 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16353 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
16354 op[0], op[1], op[2]);
16355 printf (" bittt = 0x%x,", bittt);
16356 printf (" rdst = 0x%x\n", rdst);
16357 }
16358 SYNTAX("bnot #%1, %0");
16359 #line 1004 "rx-decode.opc"
16360 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
16361
16362
16363 }
16364 break;
16365 }
16366 break;
16367 case 0xe1:
16368 GETBYTE ();
16369 switch (op[2] & 0xf0)
16370 {
16371 case 0x00:
16372 case 0x10:
16373 case 0x20:
16374 case 0x30:
16375 case 0x40:
16376 case 0x50:
16377 case 0x60:
16378 case 0x70:
16379 case 0x80:
16380 case 0x90:
16381 case 0xa0:
16382 case 0xb0:
16383 case 0xc0:
16384 case 0xd0:
16385 case 0xe0:
16386 goto op_semantics_139;
16387 break;
16388 case 0xf0:
16389 goto op_semantics_140;
16390 break;
16391 }
16392 break;
16393 case 0xe2:
16394 GETBYTE ();
16395 switch (op[2] & 0xf0)
16396 {
16397 case 0x00:
16398 case 0x10:
16399 case 0x20:
16400 case 0x30:
16401 case 0x40:
16402 case 0x50:
16403 case 0x60:
16404 case 0x70:
16405 case 0x80:
16406 case 0x90:
16407 case 0xa0:
16408 case 0xb0:
16409 case 0xc0:
16410 case 0xd0:
16411 case 0xe0:
16412 goto op_semantics_139;
16413 break;
16414 case 0xf0:
16415 goto op_semantics_140;
16416 break;
16417 }
16418 break;
16419 case 0xe3:
16420 GETBYTE ();
16421 switch (op[2] & 0xf0)
16422 {
16423 case 0x00:
16424 case 0x10:
16425 case 0x20:
16426 case 0x30:
16427 case 0x40:
16428 case 0x50:
16429 case 0x60:
16430 case 0x70:
16431 case 0x80:
16432 case 0x90:
16433 case 0xa0:
16434 case 0xb0:
16435 case 0xc0:
16436 case 0xd0:
16437 case 0xe0:
16438 goto op_semantics_139;
16439 break;
16440 case 0xf0:
16441 goto op_semantics_140;
16442 break;
16443 }
16444 break;
16445 case 0xe4:
16446 GETBYTE ();
16447 switch (op[2] & 0xf0)
16448 {
16449 case 0x00:
16450 case 0x10:
16451 case 0x20:
16452 case 0x30:
16453 case 0x40:
16454 case 0x50:
16455 case 0x60:
16456 case 0x70:
16457 case 0x80:
16458 case 0x90:
16459 case 0xa0:
16460 case 0xb0:
16461 case 0xc0:
16462 case 0xd0:
16463 case 0xe0:
16464 goto op_semantics_139;
16465 break;
16466 case 0xf0:
16467 goto op_semantics_140;
16468 break;
16469 }
16470 break;
16471 case 0xe5:
16472 GETBYTE ();
16473 switch (op[2] & 0xf0)
16474 {
16475 case 0x00:
16476 case 0x10:
16477 case 0x20:
16478 case 0x30:
16479 case 0x40:
16480 case 0x50:
16481 case 0x60:
16482 case 0x70:
16483 case 0x80:
16484 case 0x90:
16485 case 0xa0:
16486 case 0xb0:
16487 case 0xc0:
16488 case 0xd0:
16489 case 0xe0:
16490 goto op_semantics_139;
16491 break;
16492 case 0xf0:
16493 goto op_semantics_140;
16494 break;
16495 }
16496 break;
16497 case 0xe6:
16498 GETBYTE ();
16499 switch (op[2] & 0xf0)
16500 {
16501 case 0x00:
16502 case 0x10:
16503 case 0x20:
16504 case 0x30:
16505 case 0x40:
16506 case 0x50:
16507 case 0x60:
16508 case 0x70:
16509 case 0x80:
16510 case 0x90:
16511 case 0xa0:
16512 case 0xb0:
16513 case 0xc0:
16514 case 0xd0:
16515 case 0xe0:
16516 goto op_semantics_139;
16517 break;
16518 case 0xf0:
16519 goto op_semantics_140;
16520 break;
16521 }
16522 break;
16523 case 0xe7:
16524 GETBYTE ();
16525 switch (op[2] & 0xf0)
16526 {
16527 case 0x00:
16528 case 0x10:
16529 case 0x20:
16530 case 0x30:
16531 case 0x40:
16532 case 0x50:
16533 case 0x60:
16534 case 0x70:
16535 case 0x80:
16536 case 0x90:
16537 case 0xa0:
16538 case 0xb0:
16539 case 0xc0:
16540 case 0xd0:
16541 case 0xe0:
16542 goto op_semantics_139;
16543 break;
16544 case 0xf0:
16545 goto op_semantics_140;
16546 break;
16547 }
16548 break;
16549 case 0xe8:
16550 GETBYTE ();
16551 switch (op[2] & 0xf0)
16552 {
16553 case 0x00:
16554 case 0x10:
16555 case 0x20:
16556 case 0x30:
16557 case 0x40:
16558 case 0x50:
16559 case 0x60:
16560 case 0x70:
16561 case 0x80:
16562 case 0x90:
16563 case 0xa0:
16564 case 0xb0:
16565 case 0xc0:
16566 case 0xd0:
16567 case 0xe0:
16568 goto op_semantics_139;
16569 break;
16570 case 0xf0:
16571 goto op_semantics_140;
16572 break;
16573 }
16574 break;
16575 case 0xe9:
16576 GETBYTE ();
16577 switch (op[2] & 0xf0)
16578 {
16579 case 0x00:
16580 case 0x10:
16581 case 0x20:
16582 case 0x30:
16583 case 0x40:
16584 case 0x50:
16585 case 0x60:
16586 case 0x70:
16587 case 0x80:
16588 case 0x90:
16589 case 0xa0:
16590 case 0xb0:
16591 case 0xc0:
16592 case 0xd0:
16593 case 0xe0:
16594 goto op_semantics_139;
16595 break;
16596 case 0xf0:
16597 goto op_semantics_140;
16598 break;
16599 }
16600 break;
16601 case 0xea:
16602 GETBYTE ();
16603 switch (op[2] & 0xf0)
16604 {
16605 case 0x00:
16606 case 0x10:
16607 case 0x20:
16608 case 0x30:
16609 case 0x40:
16610 case 0x50:
16611 case 0x60:
16612 case 0x70:
16613 case 0x80:
16614 case 0x90:
16615 case 0xa0:
16616 case 0xb0:
16617 case 0xc0:
16618 case 0xd0:
16619 case 0xe0:
16620 goto op_semantics_139;
16621 break;
16622 case 0xf0:
16623 goto op_semantics_140;
16624 break;
16625 }
16626 break;
16627 case 0xeb:
16628 GETBYTE ();
16629 switch (op[2] & 0xf0)
16630 {
16631 case 0x00:
16632 case 0x10:
16633 case 0x20:
16634 case 0x30:
16635 case 0x40:
16636 case 0x50:
16637 case 0x60:
16638 case 0x70:
16639 case 0x80:
16640 case 0x90:
16641 case 0xa0:
16642 case 0xb0:
16643 case 0xc0:
16644 case 0xd0:
16645 case 0xe0:
16646 goto op_semantics_139;
16647 break;
16648 case 0xf0:
16649 goto op_semantics_140;
16650 break;
16651 }
16652 break;
16653 case 0xec:
16654 GETBYTE ();
16655 switch (op[2] & 0xf0)
16656 {
16657 case 0x00:
16658 case 0x10:
16659 case 0x20:
16660 case 0x30:
16661 case 0x40:
16662 case 0x50:
16663 case 0x60:
16664 case 0x70:
16665 case 0x80:
16666 case 0x90:
16667 case 0xa0:
16668 case 0xb0:
16669 case 0xc0:
16670 case 0xd0:
16671 case 0xe0:
16672 goto op_semantics_139;
16673 break;
16674 case 0xf0:
16675 goto op_semantics_140;
16676 break;
16677 }
16678 break;
16679 case 0xed:
16680 GETBYTE ();
16681 switch (op[2] & 0xf0)
16682 {
16683 case 0x00:
16684 case 0x10:
16685 case 0x20:
16686 case 0x30:
16687 case 0x40:
16688 case 0x50:
16689 case 0x60:
16690 case 0x70:
16691 case 0x80:
16692 case 0x90:
16693 case 0xa0:
16694 case 0xb0:
16695 case 0xc0:
16696 case 0xd0:
16697 case 0xe0:
16698 goto op_semantics_139;
16699 break;
16700 case 0xf0:
16701 goto op_semantics_140;
16702 break;
16703 }
16704 break;
16705 case 0xee:
16706 GETBYTE ();
16707 switch (op[2] & 0xf0)
16708 {
16709 case 0x00:
16710 case 0x10:
16711 case 0x20:
16712 case 0x30:
16713 case 0x40:
16714 case 0x50:
16715 case 0x60:
16716 case 0x70:
16717 case 0x80:
16718 case 0x90:
16719 case 0xa0:
16720 case 0xb0:
16721 case 0xc0:
16722 case 0xd0:
16723 case 0xe0:
16724 goto op_semantics_139;
16725 break;
16726 case 0xf0:
16727 goto op_semantics_140;
16728 break;
16729 }
16730 break;
16731 case 0xef:
16732 GETBYTE ();
16733 switch (op[2] & 0xf0)
16734 {
16735 case 0x00:
16736 case 0x10:
16737 case 0x20:
16738 case 0x30:
16739 case 0x40:
16740 case 0x50:
16741 case 0x60:
16742 case 0x70:
16743 case 0x80:
16744 case 0x90:
16745 case 0xa0:
16746 case 0xb0:
16747 case 0xc0:
16748 case 0xd0:
16749 case 0xe0:
16750 goto op_semantics_139;
16751 break;
16752 case 0xf0:
16753 goto op_semantics_140;
16754 break;
16755 }
16756 break;
16757 case 0xf0:
16758 GETBYTE ();
16759 switch (op[2] & 0xf0)
16760 {
16761 case 0x00:
16762 case 0x10:
16763 case 0x20:
16764 case 0x30:
16765 case 0x40:
16766 case 0x50:
16767 case 0x60:
16768 case 0x70:
16769 case 0x80:
16770 case 0x90:
16771 case 0xa0:
16772 case 0xb0:
16773 case 0xc0:
16774 case 0xd0:
16775 case 0xe0:
16776 goto op_semantics_139;
16777 break;
16778 case 0xf0:
16779 goto op_semantics_140;
16780 break;
16781 }
16782 break;
16783 case 0xf1:
16784 GETBYTE ();
16785 switch (op[2] & 0xf0)
16786 {
16787 case 0x00:
16788 case 0x10:
16789 case 0x20:
16790 case 0x30:
16791 case 0x40:
16792 case 0x50:
16793 case 0x60:
16794 case 0x70:
16795 case 0x80:
16796 case 0x90:
16797 case 0xa0:
16798 case 0xb0:
16799 case 0xc0:
16800 case 0xd0:
16801 case 0xe0:
16802 goto op_semantics_139;
16803 break;
16804 case 0xf0:
16805 goto op_semantics_140;
16806 break;
16807 }
16808 break;
16809 case 0xf2:
16810 GETBYTE ();
16811 switch (op[2] & 0xf0)
16812 {
16813 case 0x00:
16814 case 0x10:
16815 case 0x20:
16816 case 0x30:
16817 case 0x40:
16818 case 0x50:
16819 case 0x60:
16820 case 0x70:
16821 case 0x80:
16822 case 0x90:
16823 case 0xa0:
16824 case 0xb0:
16825 case 0xc0:
16826 case 0xd0:
16827 case 0xe0:
16828 goto op_semantics_139;
16829 break;
16830 case 0xf0:
16831 goto op_semantics_140;
16832 break;
16833 }
16834 break;
16835 case 0xf3:
16836 GETBYTE ();
16837 switch (op[2] & 0xf0)
16838 {
16839 case 0x00:
16840 case 0x10:
16841 case 0x20:
16842 case 0x30:
16843 case 0x40:
16844 case 0x50:
16845 case 0x60:
16846 case 0x70:
16847 case 0x80:
16848 case 0x90:
16849 case 0xa0:
16850 case 0xb0:
16851 case 0xc0:
16852 case 0xd0:
16853 case 0xe0:
16854 goto op_semantics_139;
16855 break;
16856 case 0xf0:
16857 goto op_semantics_140;
16858 break;
16859 }
16860 break;
16861 case 0xf4:
16862 GETBYTE ();
16863 switch (op[2] & 0xf0)
16864 {
16865 case 0x00:
16866 case 0x10:
16867 case 0x20:
16868 case 0x30:
16869 case 0x40:
16870 case 0x50:
16871 case 0x60:
16872 case 0x70:
16873 case 0x80:
16874 case 0x90:
16875 case 0xa0:
16876 case 0xb0:
16877 case 0xc0:
16878 case 0xd0:
16879 case 0xe0:
16880 goto op_semantics_139;
16881 break;
16882 case 0xf0:
16883 goto op_semantics_140;
16884 break;
16885 }
16886 break;
16887 case 0xf5:
16888 GETBYTE ();
16889 switch (op[2] & 0xf0)
16890 {
16891 case 0x00:
16892 case 0x10:
16893 case 0x20:
16894 case 0x30:
16895 case 0x40:
16896 case 0x50:
16897 case 0x60:
16898 case 0x70:
16899 case 0x80:
16900 case 0x90:
16901 case 0xa0:
16902 case 0xb0:
16903 case 0xc0:
16904 case 0xd0:
16905 case 0xe0:
16906 goto op_semantics_139;
16907 break;
16908 case 0xf0:
16909 goto op_semantics_140;
16910 break;
16911 }
16912 break;
16913 case 0xf6:
16914 GETBYTE ();
16915 switch (op[2] & 0xf0)
16916 {
16917 case 0x00:
16918 case 0x10:
16919 case 0x20:
16920 case 0x30:
16921 case 0x40:
16922 case 0x50:
16923 case 0x60:
16924 case 0x70:
16925 case 0x80:
16926 case 0x90:
16927 case 0xa0:
16928 case 0xb0:
16929 case 0xc0:
16930 case 0xd0:
16931 case 0xe0:
16932 goto op_semantics_139;
16933 break;
16934 case 0xf0:
16935 goto op_semantics_140;
16936 break;
16937 }
16938 break;
16939 case 0xf7:
16940 GETBYTE ();
16941 switch (op[2] & 0xf0)
16942 {
16943 case 0x00:
16944 case 0x10:
16945 case 0x20:
16946 case 0x30:
16947 case 0x40:
16948 case 0x50:
16949 case 0x60:
16950 case 0x70:
16951 case 0x80:
16952 case 0x90:
16953 case 0xa0:
16954 case 0xb0:
16955 case 0xc0:
16956 case 0xd0:
16957 case 0xe0:
16958 goto op_semantics_139;
16959 break;
16960 case 0xf0:
16961 goto op_semantics_140;
16962 break;
16963 }
16964 break;
16965 case 0xf8:
16966 GETBYTE ();
16967 switch (op[2] & 0xf0)
16968 {
16969 case 0x00:
16970 case 0x10:
16971 case 0x20:
16972 case 0x30:
16973 case 0x40:
16974 case 0x50:
16975 case 0x60:
16976 case 0x70:
16977 case 0x80:
16978 case 0x90:
16979 case 0xa0:
16980 case 0xb0:
16981 case 0xc0:
16982 case 0xd0:
16983 case 0xe0:
16984 goto op_semantics_139;
16985 break;
16986 case 0xf0:
16987 goto op_semantics_140;
16988 break;
16989 }
16990 break;
16991 case 0xf9:
16992 GETBYTE ();
16993 switch (op[2] & 0xf0)
16994 {
16995 case 0x00:
16996 case 0x10:
16997 case 0x20:
16998 case 0x30:
16999 case 0x40:
17000 case 0x50:
17001 case 0x60:
17002 case 0x70:
17003 case 0x80:
17004 case 0x90:
17005 case 0xa0:
17006 case 0xb0:
17007 case 0xc0:
17008 case 0xd0:
17009 case 0xe0:
17010 goto op_semantics_139;
17011 break;
17012 case 0xf0:
17013 goto op_semantics_140;
17014 break;
17015 }
17016 break;
17017 case 0xfa:
17018 GETBYTE ();
17019 switch (op[2] & 0xf0)
17020 {
17021 case 0x00:
17022 case 0x10:
17023 case 0x20:
17024 case 0x30:
17025 case 0x40:
17026 case 0x50:
17027 case 0x60:
17028 case 0x70:
17029 case 0x80:
17030 case 0x90:
17031 case 0xa0:
17032 case 0xb0:
17033 case 0xc0:
17034 case 0xd0:
17035 case 0xe0:
17036 goto op_semantics_139;
17037 break;
17038 case 0xf0:
17039 goto op_semantics_140;
17040 break;
17041 }
17042 break;
17043 case 0xfb:
17044 GETBYTE ();
17045 switch (op[2] & 0xf0)
17046 {
17047 case 0x00:
17048 case 0x10:
17049 case 0x20:
17050 case 0x30:
17051 case 0x40:
17052 case 0x50:
17053 case 0x60:
17054 case 0x70:
17055 case 0x80:
17056 case 0x90:
17057 case 0xa0:
17058 case 0xb0:
17059 case 0xc0:
17060 case 0xd0:
17061 case 0xe0:
17062 goto op_semantics_139;
17063 break;
17064 case 0xf0:
17065 goto op_semantics_140;
17066 break;
17067 }
17068 break;
17069 case 0xfc:
17070 GETBYTE ();
17071 switch (op[2] & 0xf0)
17072 {
17073 case 0x00:
17074 case 0x10:
17075 case 0x20:
17076 case 0x30:
17077 case 0x40:
17078 case 0x50:
17079 case 0x60:
17080 case 0x70:
17081 case 0x80:
17082 case 0x90:
17083 case 0xa0:
17084 case 0xb0:
17085 case 0xc0:
17086 case 0xd0:
17087 case 0xe0:
17088 goto op_semantics_139;
17089 break;
17090 case 0xf0:
17091 goto op_semantics_140;
17092 break;
17093 }
17094 break;
17095 case 0xfd:
17096 GETBYTE ();
17097 switch (op[2] & 0xf0)
17098 {
17099 case 0x00:
17100 case 0x10:
17101 case 0x20:
17102 case 0x30:
17103 case 0x40:
17104 case 0x50:
17105 case 0x60:
17106 case 0x70:
17107 case 0x80:
17108 case 0x90:
17109 case 0xa0:
17110 case 0xb0:
17111 case 0xc0:
17112 case 0xd0:
17113 case 0xe0:
17114 goto op_semantics_139;
17115 break;
17116 case 0xf0:
17117 goto op_semantics_140;
17118 break;
17119 }
17120 break;
17121 case 0xfe:
17122 GETBYTE ();
17123 switch (op[2] & 0xf0)
17124 {
17125 case 0x00:
17126 case 0x10:
17127 case 0x20:
17128 case 0x30:
17129 case 0x40:
17130 case 0x50:
17131 case 0x60:
17132 case 0x70:
17133 case 0x80:
17134 case 0x90:
17135 case 0xa0:
17136 case 0xb0:
17137 case 0xc0:
17138 case 0xd0:
17139 case 0xe0:
17140 goto op_semantics_139;
17141 break;
17142 case 0xf0:
17143 goto op_semantics_140;
17144 break;
17145 }
17146 break;
17147 case 0xff:
17148 GETBYTE ();
17149 switch (op[2] & 0xf0)
17150 {
17151 case 0x00:
17152 case 0x10:
17153 case 0x20:
17154 case 0x30:
17155 case 0x40:
17156 case 0x50:
17157 case 0x60:
17158 case 0x70:
17159 case 0x80:
17160 case 0x90:
17161 case 0xa0:
17162 case 0xb0:
17163 case 0xc0:
17164 case 0xd0:
17165 case 0xe0:
17166 goto op_semantics_139;
17167 break;
17168 case 0xf0:
17169 goto op_semantics_140;
17170 break;
17171 }
17172 break;
17173 default: UNSUPPORTED(); break;
17174 }
17175 break;
17176 case 0xfe:
17177 GETBYTE ();
17178 switch (op[1] & 0xff)
17179 {
17180 case 0x00:
17181 GETBYTE ();
17182 switch (op[2] & 0x00)
17183 {
17184 case 0x00:
17185 op_semantics_141:
17186 {
17187 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
17188 #line 363 "rx-decode.opc"
17189 int sz AU = (op[1] >> 4) & 0x03;
17190 #line 363 "rx-decode.opc"
17191 int isrc AU = op[1] & 0x0f;
17192 #line 363 "rx-decode.opc"
17193 int bsrc AU = (op[2] >> 4) & 0x0f;
17194 #line 363 "rx-decode.opc"
17195 int rdst AU = op[2] & 0x0f;
17196 if (trace)
17197 {
17198 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
17199 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
17200 op[0], op[1], op[2]);
17201 printf (" sz = 0x%x,", sz);
17202 printf (" isrc = 0x%x,", isrc);
17203 printf (" bsrc = 0x%x,", bsrc);
17204 printf (" rdst = 0x%x\n", rdst);
17205 }
17206 SYNTAX("mov%s %0, [%1, %2]");
17207 #line 363 "rx-decode.opc"
17208 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17209
17210 }
17211 break;
17212 }
17213 break;
17214 case 0x01:
17215 GETBYTE ();
17216 switch (op[2] & 0x00)
17217 {
17218 case 0x00:
17219 goto op_semantics_141;
17220 break;
17221 }
17222 break;
17223 case 0x02:
17224 GETBYTE ();
17225 switch (op[2] & 0x00)
17226 {
17227 case 0x00:
17228 goto op_semantics_141;
17229 break;
17230 }
17231 break;
17232 case 0x03:
17233 GETBYTE ();
17234 switch (op[2] & 0x00)
17235 {
17236 case 0x00:
17237 goto op_semantics_141;
17238 break;
17239 }
17240 break;
17241 case 0x04:
17242 GETBYTE ();
17243 switch (op[2] & 0x00)
17244 {
17245 case 0x00:
17246 goto op_semantics_141;
17247 break;
17248 }
17249 break;
17250 case 0x05:
17251 GETBYTE ();
17252 switch (op[2] & 0x00)
17253 {
17254 case 0x00:
17255 goto op_semantics_141;
17256 break;
17257 }
17258 break;
17259 case 0x06:
17260 GETBYTE ();
17261 switch (op[2] & 0x00)
17262 {
17263 case 0x00:
17264 goto op_semantics_141;
17265 break;
17266 }
17267 break;
17268 case 0x07:
17269 GETBYTE ();
17270 switch (op[2] & 0x00)
17271 {
17272 case 0x00:
17273 goto op_semantics_141;
17274 break;
17275 }
17276 break;
17277 case 0x08:
17278 GETBYTE ();
17279 switch (op[2] & 0x00)
17280 {
17281 case 0x00:
17282 goto op_semantics_141;
17283 break;
17284 }
17285 break;
17286 case 0x09:
17287 GETBYTE ();
17288 switch (op[2] & 0x00)
17289 {
17290 case 0x00:
17291 goto op_semantics_141;
17292 break;
17293 }
17294 break;
17295 case 0x0a:
17296 GETBYTE ();
17297 switch (op[2] & 0x00)
17298 {
17299 case 0x00:
17300 goto op_semantics_141;
17301 break;
17302 }
17303 break;
17304 case 0x0b:
17305 GETBYTE ();
17306 switch (op[2] & 0x00)
17307 {
17308 case 0x00:
17309 goto op_semantics_141;
17310 break;
17311 }
17312 break;
17313 case 0x0c:
17314 GETBYTE ();
17315 switch (op[2] & 0x00)
17316 {
17317 case 0x00:
17318 goto op_semantics_141;
17319 break;
17320 }
17321 break;
17322 case 0x0d:
17323 GETBYTE ();
17324 switch (op[2] & 0x00)
17325 {
17326 case 0x00:
17327 goto op_semantics_141;
17328 break;
17329 }
17330 break;
17331 case 0x0e:
17332 GETBYTE ();
17333 switch (op[2] & 0x00)
17334 {
17335 case 0x00:
17336 goto op_semantics_141;
17337 break;
17338 }
17339 break;
17340 case 0x0f:
17341 GETBYTE ();
17342 switch (op[2] & 0x00)
17343 {
17344 case 0x00:
17345 goto op_semantics_141;
17346 break;
17347 }
17348 break;
17349 case 0x10:
17350 GETBYTE ();
17351 switch (op[2] & 0x00)
17352 {
17353 case 0x00:
17354 goto op_semantics_141;
17355 break;
17356 }
17357 break;
17358 case 0x11:
17359 GETBYTE ();
17360 switch (op[2] & 0x00)
17361 {
17362 case 0x00:
17363 goto op_semantics_141;
17364 break;
17365 }
17366 break;
17367 case 0x12:
17368 GETBYTE ();
17369 switch (op[2] & 0x00)
17370 {
17371 case 0x00:
17372 goto op_semantics_141;
17373 break;
17374 }
17375 break;
17376 case 0x13:
17377 GETBYTE ();
17378 switch (op[2] & 0x00)
17379 {
17380 case 0x00:
17381 goto op_semantics_141;
17382 break;
17383 }
17384 break;
17385 case 0x14:
17386 GETBYTE ();
17387 switch (op[2] & 0x00)
17388 {
17389 case 0x00:
17390 goto op_semantics_141;
17391 break;
17392 }
17393 break;
17394 case 0x15:
17395 GETBYTE ();
17396 switch (op[2] & 0x00)
17397 {
17398 case 0x00:
17399 goto op_semantics_141;
17400 break;
17401 }
17402 break;
17403 case 0x16:
17404 GETBYTE ();
17405 switch (op[2] & 0x00)
17406 {
17407 case 0x00:
17408 goto op_semantics_141;
17409 break;
17410 }
17411 break;
17412 case 0x17:
17413 GETBYTE ();
17414 switch (op[2] & 0x00)
17415 {
17416 case 0x00:
17417 goto op_semantics_141;
17418 break;
17419 }
17420 break;
17421 case 0x18:
17422 GETBYTE ();
17423 switch (op[2] & 0x00)
17424 {
17425 case 0x00:
17426 goto op_semantics_141;
17427 break;
17428 }
17429 break;
17430 case 0x19:
17431 GETBYTE ();
17432 switch (op[2] & 0x00)
17433 {
17434 case 0x00:
17435 goto op_semantics_141;
17436 break;
17437 }
17438 break;
17439 case 0x1a:
17440 GETBYTE ();
17441 switch (op[2] & 0x00)
17442 {
17443 case 0x00:
17444 goto op_semantics_141;
17445 break;
17446 }
17447 break;
17448 case 0x1b:
17449 GETBYTE ();
17450 switch (op[2] & 0x00)
17451 {
17452 case 0x00:
17453 goto op_semantics_141;
17454 break;
17455 }
17456 break;
17457 case 0x1c:
17458 GETBYTE ();
17459 switch (op[2] & 0x00)
17460 {
17461 case 0x00:
17462 goto op_semantics_141;
17463 break;
17464 }
17465 break;
17466 case 0x1d:
17467 GETBYTE ();
17468 switch (op[2] & 0x00)
17469 {
17470 case 0x00:
17471 goto op_semantics_141;
17472 break;
17473 }
17474 break;
17475 case 0x1e:
17476 GETBYTE ();
17477 switch (op[2] & 0x00)
17478 {
17479 case 0x00:
17480 goto op_semantics_141;
17481 break;
17482 }
17483 break;
17484 case 0x1f:
17485 GETBYTE ();
17486 switch (op[2] & 0x00)
17487 {
17488 case 0x00:
17489 goto op_semantics_141;
17490 break;
17491 }
17492 break;
17493 case 0x20:
17494 GETBYTE ();
17495 switch (op[2] & 0x00)
17496 {
17497 case 0x00:
17498 goto op_semantics_141;
17499 break;
17500 }
17501 break;
17502 case 0x21:
17503 GETBYTE ();
17504 switch (op[2] & 0x00)
17505 {
17506 case 0x00:
17507 goto op_semantics_141;
17508 break;
17509 }
17510 break;
17511 case 0x22:
17512 GETBYTE ();
17513 switch (op[2] & 0x00)
17514 {
17515 case 0x00:
17516 goto op_semantics_141;
17517 break;
17518 }
17519 break;
17520 case 0x23:
17521 GETBYTE ();
17522 switch (op[2] & 0x00)
17523 {
17524 case 0x00:
17525 goto op_semantics_141;
17526 break;
17527 }
17528 break;
17529 case 0x24:
17530 GETBYTE ();
17531 switch (op[2] & 0x00)
17532 {
17533 case 0x00:
17534 goto op_semantics_141;
17535 break;
17536 }
17537 break;
17538 case 0x25:
17539 GETBYTE ();
17540 switch (op[2] & 0x00)
17541 {
17542 case 0x00:
17543 goto op_semantics_141;
17544 break;
17545 }
17546 break;
17547 case 0x26:
17548 GETBYTE ();
17549 switch (op[2] & 0x00)
17550 {
17551 case 0x00:
17552 goto op_semantics_141;
17553 break;
17554 }
17555 break;
17556 case 0x27:
17557 GETBYTE ();
17558 switch (op[2] & 0x00)
17559 {
17560 case 0x00:
17561 goto op_semantics_141;
17562 break;
17563 }
17564 break;
17565 case 0x28:
17566 GETBYTE ();
17567 switch (op[2] & 0x00)
17568 {
17569 case 0x00:
17570 goto op_semantics_141;
17571 break;
17572 }
17573 break;
17574 case 0x29:
17575 GETBYTE ();
17576 switch (op[2] & 0x00)
17577 {
17578 case 0x00:
17579 goto op_semantics_141;
17580 break;
17581 }
17582 break;
17583 case 0x2a:
17584 GETBYTE ();
17585 switch (op[2] & 0x00)
17586 {
17587 case 0x00:
17588 goto op_semantics_141;
17589 break;
17590 }
17591 break;
17592 case 0x2b:
17593 GETBYTE ();
17594 switch (op[2] & 0x00)
17595 {
17596 case 0x00:
17597 goto op_semantics_141;
17598 break;
17599 }
17600 break;
17601 case 0x2c:
17602 GETBYTE ();
17603 switch (op[2] & 0x00)
17604 {
17605 case 0x00:
17606 goto op_semantics_141;
17607 break;
17608 }
17609 break;
17610 case 0x2d:
17611 GETBYTE ();
17612 switch (op[2] & 0x00)
17613 {
17614 case 0x00:
17615 goto op_semantics_141;
17616 break;
17617 }
17618 break;
17619 case 0x2e:
17620 GETBYTE ();
17621 switch (op[2] & 0x00)
17622 {
17623 case 0x00:
17624 goto op_semantics_141;
17625 break;
17626 }
17627 break;
17628 case 0x2f:
17629 GETBYTE ();
17630 switch (op[2] & 0x00)
17631 {
17632 case 0x00:
17633 goto op_semantics_141;
17634 break;
17635 }
17636 break;
17637 case 0x40:
17638 GETBYTE ();
17639 switch (op[2] & 0x00)
17640 {
17641 case 0x00:
17642 op_semantics_142:
17643 {
17644 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
17645 #line 360 "rx-decode.opc"
17646 int sz AU = (op[1] >> 4) & 0x03;
17647 #line 360 "rx-decode.opc"
17648 int isrc AU = op[1] & 0x0f;
17649 #line 360 "rx-decode.opc"
17650 int bsrc AU = (op[2] >> 4) & 0x0f;
17651 #line 360 "rx-decode.opc"
17652 int rdst AU = op[2] & 0x0f;
17653 if (trace)
17654 {
17655 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
17656 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
17657 op[0], op[1], op[2]);
17658 printf (" sz = 0x%x,", sz);
17659 printf (" isrc = 0x%x,", isrc);
17660 printf (" bsrc = 0x%x,", bsrc);
17661 printf (" rdst = 0x%x\n", rdst);
17662 }
17663 SYNTAX("mov%s [%1, %2], %0");
17664 #line 360 "rx-decode.opc"
17665 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17666
17667 }
17668 break;
17669 }
17670 break;
17671 case 0x41:
17672 GETBYTE ();
17673 switch (op[2] & 0x00)
17674 {
17675 case 0x00:
17676 goto op_semantics_142;
17677 break;
17678 }
17679 break;
17680 case 0x42:
17681 GETBYTE ();
17682 switch (op[2] & 0x00)
17683 {
17684 case 0x00:
17685 goto op_semantics_142;
17686 break;
17687 }
17688 break;
17689 case 0x43:
17690 GETBYTE ();
17691 switch (op[2] & 0x00)
17692 {
17693 case 0x00:
17694 goto op_semantics_142;
17695 break;
17696 }
17697 break;
17698 case 0x44:
17699 GETBYTE ();
17700 switch (op[2] & 0x00)
17701 {
17702 case 0x00:
17703 goto op_semantics_142;
17704 break;
17705 }
17706 break;
17707 case 0x45:
17708 GETBYTE ();
17709 switch (op[2] & 0x00)
17710 {
17711 case 0x00:
17712 goto op_semantics_142;
17713 break;
17714 }
17715 break;
17716 case 0x46:
17717 GETBYTE ();
17718 switch (op[2] & 0x00)
17719 {
17720 case 0x00:
17721 goto op_semantics_142;
17722 break;
17723 }
17724 break;
17725 case 0x47:
17726 GETBYTE ();
17727 switch (op[2] & 0x00)
17728 {
17729 case 0x00:
17730 goto op_semantics_142;
17731 break;
17732 }
17733 break;
17734 case 0x48:
17735 GETBYTE ();
17736 switch (op[2] & 0x00)
17737 {
17738 case 0x00:
17739 goto op_semantics_142;
17740 break;
17741 }
17742 break;
17743 case 0x49:
17744 GETBYTE ();
17745 switch (op[2] & 0x00)
17746 {
17747 case 0x00:
17748 goto op_semantics_142;
17749 break;
17750 }
17751 break;
17752 case 0x4a:
17753 GETBYTE ();
17754 switch (op[2] & 0x00)
17755 {
17756 case 0x00:
17757 goto op_semantics_142;
17758 break;
17759 }
17760 break;
17761 case 0x4b:
17762 GETBYTE ();
17763 switch (op[2] & 0x00)
17764 {
17765 case 0x00:
17766 goto op_semantics_142;
17767 break;
17768 }
17769 break;
17770 case 0x4c:
17771 GETBYTE ();
17772 switch (op[2] & 0x00)
17773 {
17774 case 0x00:
17775 goto op_semantics_142;
17776 break;
17777 }
17778 break;
17779 case 0x4d:
17780 GETBYTE ();
17781 switch (op[2] & 0x00)
17782 {
17783 case 0x00:
17784 goto op_semantics_142;
17785 break;
17786 }
17787 break;
17788 case 0x4e:
17789 GETBYTE ();
17790 switch (op[2] & 0x00)
17791 {
17792 case 0x00:
17793 goto op_semantics_142;
17794 break;
17795 }
17796 break;
17797 case 0x4f:
17798 GETBYTE ();
17799 switch (op[2] & 0x00)
17800 {
17801 case 0x00:
17802 goto op_semantics_142;
17803 break;
17804 }
17805 break;
17806 case 0x50:
17807 GETBYTE ();
17808 switch (op[2] & 0x00)
17809 {
17810 case 0x00:
17811 goto op_semantics_142;
17812 break;
17813 }
17814 break;
17815 case 0x51:
17816 GETBYTE ();
17817 switch (op[2] & 0x00)
17818 {
17819 case 0x00:
17820 goto op_semantics_142;
17821 break;
17822 }
17823 break;
17824 case 0x52:
17825 GETBYTE ();
17826 switch (op[2] & 0x00)
17827 {
17828 case 0x00:
17829 goto op_semantics_142;
17830 break;
17831 }
17832 break;
17833 case 0x53:
17834 GETBYTE ();
17835 switch (op[2] & 0x00)
17836 {
17837 case 0x00:
17838 goto op_semantics_142;
17839 break;
17840 }
17841 break;
17842 case 0x54:
17843 GETBYTE ();
17844 switch (op[2] & 0x00)
17845 {
17846 case 0x00:
17847 goto op_semantics_142;
17848 break;
17849 }
17850 break;
17851 case 0x55:
17852 GETBYTE ();
17853 switch (op[2] & 0x00)
17854 {
17855 case 0x00:
17856 goto op_semantics_142;
17857 break;
17858 }
17859 break;
17860 case 0x56:
17861 GETBYTE ();
17862 switch (op[2] & 0x00)
17863 {
17864 case 0x00:
17865 goto op_semantics_142;
17866 break;
17867 }
17868 break;
17869 case 0x57:
17870 GETBYTE ();
17871 switch (op[2] & 0x00)
17872 {
17873 case 0x00:
17874 goto op_semantics_142;
17875 break;
17876 }
17877 break;
17878 case 0x58:
17879 GETBYTE ();
17880 switch (op[2] & 0x00)
17881 {
17882 case 0x00:
17883 goto op_semantics_142;
17884 break;
17885 }
17886 break;
17887 case 0x59:
17888 GETBYTE ();
17889 switch (op[2] & 0x00)
17890 {
17891 case 0x00:
17892 goto op_semantics_142;
17893 break;
17894 }
17895 break;
17896 case 0x5a:
17897 GETBYTE ();
17898 switch (op[2] & 0x00)
17899 {
17900 case 0x00:
17901 goto op_semantics_142;
17902 break;
17903 }
17904 break;
17905 case 0x5b:
17906 GETBYTE ();
17907 switch (op[2] & 0x00)
17908 {
17909 case 0x00:
17910 goto op_semantics_142;
17911 break;
17912 }
17913 break;
17914 case 0x5c:
17915 GETBYTE ();
17916 switch (op[2] & 0x00)
17917 {
17918 case 0x00:
17919 goto op_semantics_142;
17920 break;
17921 }
17922 break;
17923 case 0x5d:
17924 GETBYTE ();
17925 switch (op[2] & 0x00)
17926 {
17927 case 0x00:
17928 goto op_semantics_142;
17929 break;
17930 }
17931 break;
17932 case 0x5e:
17933 GETBYTE ();
17934 switch (op[2] & 0x00)
17935 {
17936 case 0x00:
17937 goto op_semantics_142;
17938 break;
17939 }
17940 break;
17941 case 0x5f:
17942 GETBYTE ();
17943 switch (op[2] & 0x00)
17944 {
17945 case 0x00:
17946 goto op_semantics_142;
17947 break;
17948 }
17949 break;
17950 case 0x60:
17951 GETBYTE ();
17952 switch (op[2] & 0x00)
17953 {
17954 case 0x00:
17955 goto op_semantics_142;
17956 break;
17957 }
17958 break;
17959 case 0x61:
17960 GETBYTE ();
17961 switch (op[2] & 0x00)
17962 {
17963 case 0x00:
17964 goto op_semantics_142;
17965 break;
17966 }
17967 break;
17968 case 0x62:
17969 GETBYTE ();
17970 switch (op[2] & 0x00)
17971 {
17972 case 0x00:
17973 goto op_semantics_142;
17974 break;
17975 }
17976 break;
17977 case 0x63:
17978 GETBYTE ();
17979 switch (op[2] & 0x00)
17980 {
17981 case 0x00:
17982 goto op_semantics_142;
17983 break;
17984 }
17985 break;
17986 case 0x64:
17987 GETBYTE ();
17988 switch (op[2] & 0x00)
17989 {
17990 case 0x00:
17991 goto op_semantics_142;
17992 break;
17993 }
17994 break;
17995 case 0x65:
17996 GETBYTE ();
17997 switch (op[2] & 0x00)
17998 {
17999 case 0x00:
18000 goto op_semantics_142;
18001 break;
18002 }
18003 break;
18004 case 0x66:
18005 GETBYTE ();
18006 switch (op[2] & 0x00)
18007 {
18008 case 0x00:
18009 goto op_semantics_142;
18010 break;
18011 }
18012 break;
18013 case 0x67:
18014 GETBYTE ();
18015 switch (op[2] & 0x00)
18016 {
18017 case 0x00:
18018 goto op_semantics_142;
18019 break;
18020 }
18021 break;
18022 case 0x68:
18023 GETBYTE ();
18024 switch (op[2] & 0x00)
18025 {
18026 case 0x00:
18027 goto op_semantics_142;
18028 break;
18029 }
18030 break;
18031 case 0x69:
18032 GETBYTE ();
18033 switch (op[2] & 0x00)
18034 {
18035 case 0x00:
18036 goto op_semantics_142;
18037 break;
18038 }
18039 break;
18040 case 0x6a:
18041 GETBYTE ();
18042 switch (op[2] & 0x00)
18043 {
18044 case 0x00:
18045 goto op_semantics_142;
18046 break;
18047 }
18048 break;
18049 case 0x6b:
18050 GETBYTE ();
18051 switch (op[2] & 0x00)
18052 {
18053 case 0x00:
18054 goto op_semantics_142;
18055 break;
18056 }
18057 break;
18058 case 0x6c:
18059 GETBYTE ();
18060 switch (op[2] & 0x00)
18061 {
18062 case 0x00:
18063 goto op_semantics_142;
18064 break;
18065 }
18066 break;
18067 case 0x6d:
18068 GETBYTE ();
18069 switch (op[2] & 0x00)
18070 {
18071 case 0x00:
18072 goto op_semantics_142;
18073 break;
18074 }
18075 break;
18076 case 0x6e:
18077 GETBYTE ();
18078 switch (op[2] & 0x00)
18079 {
18080 case 0x00:
18081 goto op_semantics_142;
18082 break;
18083 }
18084 break;
18085 case 0x6f:
18086 GETBYTE ();
18087 switch (op[2] & 0x00)
18088 {
18089 case 0x00:
18090 goto op_semantics_142;
18091 break;
18092 }
18093 break;
18094 case 0xc0:
18095 GETBYTE ();
18096 switch (op[2] & 0x00)
18097 {
18098 case 0x00:
18099 op_semantics_143:
18100 {
18101 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
18102 #line 366 "rx-decode.opc"
18103 int sz AU = (op[1] >> 4) & 0x03;
18104 #line 366 "rx-decode.opc"
18105 int isrc AU = op[1] & 0x0f;
18106 #line 366 "rx-decode.opc"
18107 int bsrc AU = (op[2] >> 4) & 0x0f;
18108 #line 366 "rx-decode.opc"
18109 int rdst AU = op[2] & 0x0f;
18110 if (trace)
18111 {
18112 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18113 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
18114 op[0], op[1], op[2]);
18115 printf (" sz = 0x%x,", sz);
18116 printf (" isrc = 0x%x,", isrc);
18117 printf (" bsrc = 0x%x,", bsrc);
18118 printf (" rdst = 0x%x\n", rdst);
18119 }
18120 SYNTAX("movu%s [%1, %2], %0");
18121 #line 366 "rx-decode.opc"
18122 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
18123
18124 }
18125 break;
18126 }
18127 break;
18128 case 0xc1:
18129 GETBYTE ();
18130 switch (op[2] & 0x00)
18131 {
18132 case 0x00:
18133 goto op_semantics_143;
18134 break;
18135 }
18136 break;
18137 case 0xc2:
18138 GETBYTE ();
18139 switch (op[2] & 0x00)
18140 {
18141 case 0x00:
18142 goto op_semantics_143;
18143 break;
18144 }
18145 break;
18146 case 0xc3:
18147 GETBYTE ();
18148 switch (op[2] & 0x00)
18149 {
18150 case 0x00:
18151 goto op_semantics_143;
18152 break;
18153 }
18154 break;
18155 case 0xc4:
18156 GETBYTE ();
18157 switch (op[2] & 0x00)
18158 {
18159 case 0x00:
18160 goto op_semantics_143;
18161 break;
18162 }
18163 break;
18164 case 0xc5:
18165 GETBYTE ();
18166 switch (op[2] & 0x00)
18167 {
18168 case 0x00:
18169 goto op_semantics_143;
18170 break;
18171 }
18172 break;
18173 case 0xc6:
18174 GETBYTE ();
18175 switch (op[2] & 0x00)
18176 {
18177 case 0x00:
18178 goto op_semantics_143;
18179 break;
18180 }
18181 break;
18182 case 0xc7:
18183 GETBYTE ();
18184 switch (op[2] & 0x00)
18185 {
18186 case 0x00:
18187 goto op_semantics_143;
18188 break;
18189 }
18190 break;
18191 case 0xc8:
18192 GETBYTE ();
18193 switch (op[2] & 0x00)
18194 {
18195 case 0x00:
18196 goto op_semantics_143;
18197 break;
18198 }
18199 break;
18200 case 0xc9:
18201 GETBYTE ();
18202 switch (op[2] & 0x00)
18203 {
18204 case 0x00:
18205 goto op_semantics_143;
18206 break;
18207 }
18208 break;
18209 case 0xca:
18210 GETBYTE ();
18211 switch (op[2] & 0x00)
18212 {
18213 case 0x00:
18214 goto op_semantics_143;
18215 break;
18216 }
18217 break;
18218 case 0xcb:
18219 GETBYTE ();
18220 switch (op[2] & 0x00)
18221 {
18222 case 0x00:
18223 goto op_semantics_143;
18224 break;
18225 }
18226 break;
18227 case 0xcc:
18228 GETBYTE ();
18229 switch (op[2] & 0x00)
18230 {
18231 case 0x00:
18232 goto op_semantics_143;
18233 break;
18234 }
18235 break;
18236 case 0xcd:
18237 GETBYTE ();
18238 switch (op[2] & 0x00)
18239 {
18240 case 0x00:
18241 goto op_semantics_143;
18242 break;
18243 }
18244 break;
18245 case 0xce:
18246 GETBYTE ();
18247 switch (op[2] & 0x00)
18248 {
18249 case 0x00:
18250 goto op_semantics_143;
18251 break;
18252 }
18253 break;
18254 case 0xcf:
18255 GETBYTE ();
18256 switch (op[2] & 0x00)
18257 {
18258 case 0x00:
18259 goto op_semantics_143;
18260 break;
18261 }
18262 break;
18263 case 0xd0:
18264 GETBYTE ();
18265 switch (op[2] & 0x00)
18266 {
18267 case 0x00:
18268 goto op_semantics_143;
18269 break;
18270 }
18271 break;
18272 case 0xd1:
18273 GETBYTE ();
18274 switch (op[2] & 0x00)
18275 {
18276 case 0x00:
18277 goto op_semantics_143;
18278 break;
18279 }
18280 break;
18281 case 0xd2:
18282 GETBYTE ();
18283 switch (op[2] & 0x00)
18284 {
18285 case 0x00:
18286 goto op_semantics_143;
18287 break;
18288 }
18289 break;
18290 case 0xd3:
18291 GETBYTE ();
18292 switch (op[2] & 0x00)
18293 {
18294 case 0x00:
18295 goto op_semantics_143;
18296 break;
18297 }
18298 break;
18299 case 0xd4:
18300 GETBYTE ();
18301 switch (op[2] & 0x00)
18302 {
18303 case 0x00:
18304 goto op_semantics_143;
18305 break;
18306 }
18307 break;
18308 case 0xd5:
18309 GETBYTE ();
18310 switch (op[2] & 0x00)
18311 {
18312 case 0x00:
18313 goto op_semantics_143;
18314 break;
18315 }
18316 break;
18317 case 0xd6:
18318 GETBYTE ();
18319 switch (op[2] & 0x00)
18320 {
18321 case 0x00:
18322 goto op_semantics_143;
18323 break;
18324 }
18325 break;
18326 case 0xd7:
18327 GETBYTE ();
18328 switch (op[2] & 0x00)
18329 {
18330 case 0x00:
18331 goto op_semantics_143;
18332 break;
18333 }
18334 break;
18335 case 0xd8:
18336 GETBYTE ();
18337 switch (op[2] & 0x00)
18338 {
18339 case 0x00:
18340 goto op_semantics_143;
18341 break;
18342 }
18343 break;
18344 case 0xd9:
18345 GETBYTE ();
18346 switch (op[2] & 0x00)
18347 {
18348 case 0x00:
18349 goto op_semantics_143;
18350 break;
18351 }
18352 break;
18353 case 0xda:
18354 GETBYTE ();
18355 switch (op[2] & 0x00)
18356 {
18357 case 0x00:
18358 goto op_semantics_143;
18359 break;
18360 }
18361 break;
18362 case 0xdb:
18363 GETBYTE ();
18364 switch (op[2] & 0x00)
18365 {
18366 case 0x00:
18367 goto op_semantics_143;
18368 break;
18369 }
18370 break;
18371 case 0xdc:
18372 GETBYTE ();
18373 switch (op[2] & 0x00)
18374 {
18375 case 0x00:
18376 goto op_semantics_143;
18377 break;
18378 }
18379 break;
18380 case 0xdd:
18381 GETBYTE ();
18382 switch (op[2] & 0x00)
18383 {
18384 case 0x00:
18385 goto op_semantics_143;
18386 break;
18387 }
18388 break;
18389 case 0xde:
18390 GETBYTE ();
18391 switch (op[2] & 0x00)
18392 {
18393 case 0x00:
18394 goto op_semantics_143;
18395 break;
18396 }
18397 break;
18398 case 0xdf:
18399 GETBYTE ();
18400 switch (op[2] & 0x00)
18401 {
18402 case 0x00:
18403 goto op_semantics_143;
18404 break;
18405 }
18406 break;
18407 case 0xe0:
18408 GETBYTE ();
18409 switch (op[2] & 0x00)
18410 {
18411 case 0x00:
18412 goto op_semantics_143;
18413 break;
18414 }
18415 break;
18416 case 0xe1:
18417 GETBYTE ();
18418 switch (op[2] & 0x00)
18419 {
18420 case 0x00:
18421 goto op_semantics_143;
18422 break;
18423 }
18424 break;
18425 case 0xe2:
18426 GETBYTE ();
18427 switch (op[2] & 0x00)
18428 {
18429 case 0x00:
18430 goto op_semantics_143;
18431 break;
18432 }
18433 break;
18434 case 0xe3:
18435 GETBYTE ();
18436 switch (op[2] & 0x00)
18437 {
18438 case 0x00:
18439 goto op_semantics_143;
18440 break;
18441 }
18442 break;
18443 case 0xe4:
18444 GETBYTE ();
18445 switch (op[2] & 0x00)
18446 {
18447 case 0x00:
18448 goto op_semantics_143;
18449 break;
18450 }
18451 break;
18452 case 0xe5:
18453 GETBYTE ();
18454 switch (op[2] & 0x00)
18455 {
18456 case 0x00:
18457 goto op_semantics_143;
18458 break;
18459 }
18460 break;
18461 case 0xe6:
18462 GETBYTE ();
18463 switch (op[2] & 0x00)
18464 {
18465 case 0x00:
18466 goto op_semantics_143;
18467 break;
18468 }
18469 break;
18470 case 0xe7:
18471 GETBYTE ();
18472 switch (op[2] & 0x00)
18473 {
18474 case 0x00:
18475 goto op_semantics_143;
18476 break;
18477 }
18478 break;
18479 case 0xe8:
18480 GETBYTE ();
18481 switch (op[2] & 0x00)
18482 {
18483 case 0x00:
18484 goto op_semantics_143;
18485 break;
18486 }
18487 break;
18488 case 0xe9:
18489 GETBYTE ();
18490 switch (op[2] & 0x00)
18491 {
18492 case 0x00:
18493 goto op_semantics_143;
18494 break;
18495 }
18496 break;
18497 case 0xea:
18498 GETBYTE ();
18499 switch (op[2] & 0x00)
18500 {
18501 case 0x00:
18502 goto op_semantics_143;
18503 break;
18504 }
18505 break;
18506 case 0xeb:
18507 GETBYTE ();
18508 switch (op[2] & 0x00)
18509 {
18510 case 0x00:
18511 goto op_semantics_143;
18512 break;
18513 }
18514 break;
18515 case 0xec:
18516 GETBYTE ();
18517 switch (op[2] & 0x00)
18518 {
18519 case 0x00:
18520 goto op_semantics_143;
18521 break;
18522 }
18523 break;
18524 case 0xed:
18525 GETBYTE ();
18526 switch (op[2] & 0x00)
18527 {
18528 case 0x00:
18529 goto op_semantics_143;
18530 break;
18531 }
18532 break;
18533 case 0xee:
18534 GETBYTE ();
18535 switch (op[2] & 0x00)
18536 {
18537 case 0x00:
18538 goto op_semantics_143;
18539 break;
18540 }
18541 break;
18542 case 0xef:
18543 GETBYTE ();
18544 switch (op[2] & 0x00)
18545 {
18546 case 0x00:
18547 goto op_semantics_143;
18548 break;
18549 }
18550 break;
18551 default: UNSUPPORTED(); break;
18552 }
18553 break;
18554 case 0xff:
18555 GETBYTE ();
18556 switch (op[1] & 0xff)
18557 {
18558 case 0x00:
18559 GETBYTE ();
18560 switch (op[2] & 0x00)
18561 {
18562 case 0x00:
18563 op_semantics_144:
18564 {
18565 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
18566 #line 570 "rx-decode.opc"
18567 int rdst AU = op[1] & 0x0f;
18568 #line 570 "rx-decode.opc"
18569 int srca AU = (op[2] >> 4) & 0x0f;
18570 #line 570 "rx-decode.opc"
18571 int srcb AU = op[2] & 0x0f;
18572 if (trace)
18573 {
18574 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18575 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
18576 op[0], op[1], op[2]);
18577 printf (" rdst = 0x%x,", rdst);
18578 printf (" srca = 0x%x,", srca);
18579 printf (" srcb = 0x%x\n", srcb);
18580 }
18581 SYNTAX("sub %2, %1, %0");
18582 #line 570 "rx-decode.opc"
18583 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18584
18585 /*----------------------------------------------------------------------*/
18586 /* SBB */
18587
18588 }
18589 break;
18590 }
18591 break;
18592 case 0x01:
18593 GETBYTE ();
18594 switch (op[2] & 0x00)
18595 {
18596 case 0x00:
18597 goto op_semantics_144;
18598 break;
18599 }
18600 break;
18601 case 0x02:
18602 GETBYTE ();
18603 switch (op[2] & 0x00)
18604 {
18605 case 0x00:
18606 goto op_semantics_144;
18607 break;
18608 }
18609 break;
18610 case 0x03:
18611 GETBYTE ();
18612 switch (op[2] & 0x00)
18613 {
18614 case 0x00:
18615 goto op_semantics_144;
18616 break;
18617 }
18618 break;
18619 case 0x04:
18620 GETBYTE ();
18621 switch (op[2] & 0x00)
18622 {
18623 case 0x00:
18624 goto op_semantics_144;
18625 break;
18626 }
18627 break;
18628 case 0x05:
18629 GETBYTE ();
18630 switch (op[2] & 0x00)
18631 {
18632 case 0x00:
18633 goto op_semantics_144;
18634 break;
18635 }
18636 break;
18637 case 0x06:
18638 GETBYTE ();
18639 switch (op[2] & 0x00)
18640 {
18641 case 0x00:
18642 goto op_semantics_144;
18643 break;
18644 }
18645 break;
18646 case 0x07:
18647 GETBYTE ();
18648 switch (op[2] & 0x00)
18649 {
18650 case 0x00:
18651 goto op_semantics_144;
18652 break;
18653 }
18654 break;
18655 case 0x08:
18656 GETBYTE ();
18657 switch (op[2] & 0x00)
18658 {
18659 case 0x00:
18660 goto op_semantics_144;
18661 break;
18662 }
18663 break;
18664 case 0x09:
18665 GETBYTE ();
18666 switch (op[2] & 0x00)
18667 {
18668 case 0x00:
18669 goto op_semantics_144;
18670 break;
18671 }
18672 break;
18673 case 0x0a:
18674 GETBYTE ();
18675 switch (op[2] & 0x00)
18676 {
18677 case 0x00:
18678 goto op_semantics_144;
18679 break;
18680 }
18681 break;
18682 case 0x0b:
18683 GETBYTE ();
18684 switch (op[2] & 0x00)
18685 {
18686 case 0x00:
18687 goto op_semantics_144;
18688 break;
18689 }
18690 break;
18691 case 0x0c:
18692 GETBYTE ();
18693 switch (op[2] & 0x00)
18694 {
18695 case 0x00:
18696 goto op_semantics_144;
18697 break;
18698 }
18699 break;
18700 case 0x0d:
18701 GETBYTE ();
18702 switch (op[2] & 0x00)
18703 {
18704 case 0x00:
18705 goto op_semantics_144;
18706 break;
18707 }
18708 break;
18709 case 0x0e:
18710 GETBYTE ();
18711 switch (op[2] & 0x00)
18712 {
18713 case 0x00:
18714 goto op_semantics_144;
18715 break;
18716 }
18717 break;
18718 case 0x0f:
18719 GETBYTE ();
18720 switch (op[2] & 0x00)
18721 {
18722 case 0x00:
18723 goto op_semantics_144;
18724 break;
18725 }
18726 break;
18727 case 0x20:
18728 GETBYTE ();
18729 switch (op[2] & 0x00)
18730 {
18731 case 0x00:
18732 op_semantics_145:
18733 {
18734 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
18735 #line 537 "rx-decode.opc"
18736 int rdst AU = op[1] & 0x0f;
18737 #line 537 "rx-decode.opc"
18738 int srca AU = (op[2] >> 4) & 0x0f;
18739 #line 537 "rx-decode.opc"
18740 int srcb AU = op[2] & 0x0f;
18741 if (trace)
18742 {
18743 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18744 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
18745 op[0], op[1], op[2]);
18746 printf (" rdst = 0x%x,", rdst);
18747 printf (" srca = 0x%x,", srca);
18748 printf (" srcb = 0x%x\n", srcb);
18749 }
18750 SYNTAX("add %2, %1, %0");
18751 #line 537 "rx-decode.opc"
18752 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18753
18754 /*----------------------------------------------------------------------*/
18755 /* CMP */
18756
18757 }
18758 break;
18759 }
18760 break;
18761 case 0x21:
18762 GETBYTE ();
18763 switch (op[2] & 0x00)
18764 {
18765 case 0x00:
18766 goto op_semantics_145;
18767 break;
18768 }
18769 break;
18770 case 0x22:
18771 GETBYTE ();
18772 switch (op[2] & 0x00)
18773 {
18774 case 0x00:
18775 goto op_semantics_145;
18776 break;
18777 }
18778 break;
18779 case 0x23:
18780 GETBYTE ();
18781 switch (op[2] & 0x00)
18782 {
18783 case 0x00:
18784 goto op_semantics_145;
18785 break;
18786 }
18787 break;
18788 case 0x24:
18789 GETBYTE ();
18790 switch (op[2] & 0x00)
18791 {
18792 case 0x00:
18793 goto op_semantics_145;
18794 break;
18795 }
18796 break;
18797 case 0x25:
18798 GETBYTE ();
18799 switch (op[2] & 0x00)
18800 {
18801 case 0x00:
18802 goto op_semantics_145;
18803 break;
18804 }
18805 break;
18806 case 0x26:
18807 GETBYTE ();
18808 switch (op[2] & 0x00)
18809 {
18810 case 0x00:
18811 goto op_semantics_145;
18812 break;
18813 }
18814 break;
18815 case 0x27:
18816 GETBYTE ();
18817 switch (op[2] & 0x00)
18818 {
18819 case 0x00:
18820 goto op_semantics_145;
18821 break;
18822 }
18823 break;
18824 case 0x28:
18825 GETBYTE ();
18826 switch (op[2] & 0x00)
18827 {
18828 case 0x00:
18829 goto op_semantics_145;
18830 break;
18831 }
18832 break;
18833 case 0x29:
18834 GETBYTE ();
18835 switch (op[2] & 0x00)
18836 {
18837 case 0x00:
18838 goto op_semantics_145;
18839 break;
18840 }
18841 break;
18842 case 0x2a:
18843 GETBYTE ();
18844 switch (op[2] & 0x00)
18845 {
18846 case 0x00:
18847 goto op_semantics_145;
18848 break;
18849 }
18850 break;
18851 case 0x2b:
18852 GETBYTE ();
18853 switch (op[2] & 0x00)
18854 {
18855 case 0x00:
18856 goto op_semantics_145;
18857 break;
18858 }
18859 break;
18860 case 0x2c:
18861 GETBYTE ();
18862 switch (op[2] & 0x00)
18863 {
18864 case 0x00:
18865 goto op_semantics_145;
18866 break;
18867 }
18868 break;
18869 case 0x2d:
18870 GETBYTE ();
18871 switch (op[2] & 0x00)
18872 {
18873 case 0x00:
18874 goto op_semantics_145;
18875 break;
18876 }
18877 break;
18878 case 0x2e:
18879 GETBYTE ();
18880 switch (op[2] & 0x00)
18881 {
18882 case 0x00:
18883 goto op_semantics_145;
18884 break;
18885 }
18886 break;
18887 case 0x2f:
18888 GETBYTE ();
18889 switch (op[2] & 0x00)
18890 {
18891 case 0x00:
18892 goto op_semantics_145;
18893 break;
18894 }
18895 break;
18896 case 0x30:
18897 GETBYTE ();
18898 switch (op[2] & 0x00)
18899 {
18900 case 0x00:
18901 op_semantics_146:
18902 {
18903 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
18904 #line 677 "rx-decode.opc"
18905 int rdst AU = op[1] & 0x0f;
18906 #line 677 "rx-decode.opc"
18907 int srca AU = (op[2] >> 4) & 0x0f;
18908 #line 677 "rx-decode.opc"
18909 int srcb AU = op[2] & 0x0f;
18910 if (trace)
18911 {
18912 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18913 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
18914 op[0], op[1], op[2]);
18915 printf (" rdst = 0x%x,", rdst);
18916 printf (" srca = 0x%x,", srca);
18917 printf (" srcb = 0x%x\n", srcb);
18918 }
18919 SYNTAX("mul %2, %1, %0");
18920 #line 677 "rx-decode.opc"
18921 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
18922
18923 /*----------------------------------------------------------------------*/
18924 /* EMUL */
18925
18926 }
18927 break;
18928 }
18929 break;
18930 case 0x31:
18931 GETBYTE ();
18932 switch (op[2] & 0x00)
18933 {
18934 case 0x00:
18935 goto op_semantics_146;
18936 break;
18937 }
18938 break;
18939 case 0x32:
18940 GETBYTE ();
18941 switch (op[2] & 0x00)
18942 {
18943 case 0x00:
18944 goto op_semantics_146;
18945 break;
18946 }
18947 break;
18948 case 0x33:
18949 GETBYTE ();
18950 switch (op[2] & 0x00)
18951 {
18952 case 0x00:
18953 goto op_semantics_146;
18954 break;
18955 }
18956 break;
18957 case 0x34:
18958 GETBYTE ();
18959 switch (op[2] & 0x00)
18960 {
18961 case 0x00:
18962 goto op_semantics_146;
18963 break;
18964 }
18965 break;
18966 case 0x35:
18967 GETBYTE ();
18968 switch (op[2] & 0x00)
18969 {
18970 case 0x00:
18971 goto op_semantics_146;
18972 break;
18973 }
18974 break;
18975 case 0x36:
18976 GETBYTE ();
18977 switch (op[2] & 0x00)
18978 {
18979 case 0x00:
18980 goto op_semantics_146;
18981 break;
18982 }
18983 break;
18984 case 0x37:
18985 GETBYTE ();
18986 switch (op[2] & 0x00)
18987 {
18988 case 0x00:
18989 goto op_semantics_146;
18990 break;
18991 }
18992 break;
18993 case 0x38:
18994 GETBYTE ();
18995 switch (op[2] & 0x00)
18996 {
18997 case 0x00:
18998 goto op_semantics_146;
18999 break;
19000 }
19001 break;
19002 case 0x39:
19003 GETBYTE ();
19004 switch (op[2] & 0x00)
19005 {
19006 case 0x00:
19007 goto op_semantics_146;
19008 break;
19009 }
19010 break;
19011 case 0x3a:
19012 GETBYTE ();
19013 switch (op[2] & 0x00)
19014 {
19015 case 0x00:
19016 goto op_semantics_146;
19017 break;
19018 }
19019 break;
19020 case 0x3b:
19021 GETBYTE ();
19022 switch (op[2] & 0x00)
19023 {
19024 case 0x00:
19025 goto op_semantics_146;
19026 break;
19027 }
19028 break;
19029 case 0x3c:
19030 GETBYTE ();
19031 switch (op[2] & 0x00)
19032 {
19033 case 0x00:
19034 goto op_semantics_146;
19035 break;
19036 }
19037 break;
19038 case 0x3d:
19039 GETBYTE ();
19040 switch (op[2] & 0x00)
19041 {
19042 case 0x00:
19043 goto op_semantics_146;
19044 break;
19045 }
19046 break;
19047 case 0x3e:
19048 GETBYTE ();
19049 switch (op[2] & 0x00)
19050 {
19051 case 0x00:
19052 goto op_semantics_146;
19053 break;
19054 }
19055 break;
19056 case 0x3f:
19057 GETBYTE ();
19058 switch (op[2] & 0x00)
19059 {
19060 case 0x00:
19061 goto op_semantics_146;
19062 break;
19063 }
19064 break;
19065 case 0x40:
19066 GETBYTE ();
19067 switch (op[2] & 0x00)
19068 {
19069 case 0x00:
19070 op_semantics_147:
19071 {
19072 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
19073 #line 447 "rx-decode.opc"
19074 int rdst AU = op[1] & 0x0f;
19075 #line 447 "rx-decode.opc"
19076 int srca AU = (op[2] >> 4) & 0x0f;
19077 #line 447 "rx-decode.opc"
19078 int srcb AU = op[2] & 0x0f;
19079 if (trace)
19080 {
19081 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19082 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
19083 op[0], op[1], op[2]);
19084 printf (" rdst = 0x%x,", rdst);
19085 printf (" srca = 0x%x,", srca);
19086 printf (" srcb = 0x%x\n", srcb);
19087 }
19088 SYNTAX("and %2, %1, %0");
19089 #line 447 "rx-decode.opc"
19090 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19091
19092 /*----------------------------------------------------------------------*/
19093 /* OR */
19094
19095 }
19096 break;
19097 }
19098 break;
19099 case 0x41:
19100 GETBYTE ();
19101 switch (op[2] & 0x00)
19102 {
19103 case 0x00:
19104 goto op_semantics_147;
19105 break;
19106 }
19107 break;
19108 case 0x42:
19109 GETBYTE ();
19110 switch (op[2] & 0x00)
19111 {
19112 case 0x00:
19113 goto op_semantics_147;
19114 break;
19115 }
19116 break;
19117 case 0x43:
19118 GETBYTE ();
19119 switch (op[2] & 0x00)
19120 {
19121 case 0x00:
19122 goto op_semantics_147;
19123 break;
19124 }
19125 break;
19126 case 0x44:
19127 GETBYTE ();
19128 switch (op[2] & 0x00)
19129 {
19130 case 0x00:
19131 goto op_semantics_147;
19132 break;
19133 }
19134 break;
19135 case 0x45:
19136 GETBYTE ();
19137 switch (op[2] & 0x00)
19138 {
19139 case 0x00:
19140 goto op_semantics_147;
19141 break;
19142 }
19143 break;
19144 case 0x46:
19145 GETBYTE ();
19146 switch (op[2] & 0x00)
19147 {
19148 case 0x00:
19149 goto op_semantics_147;
19150 break;
19151 }
19152 break;
19153 case 0x47:
19154 GETBYTE ();
19155 switch (op[2] & 0x00)
19156 {
19157 case 0x00:
19158 goto op_semantics_147;
19159 break;
19160 }
19161 break;
19162 case 0x48:
19163 GETBYTE ();
19164 switch (op[2] & 0x00)
19165 {
19166 case 0x00:
19167 goto op_semantics_147;
19168 break;
19169 }
19170 break;
19171 case 0x49:
19172 GETBYTE ();
19173 switch (op[2] & 0x00)
19174 {
19175 case 0x00:
19176 goto op_semantics_147;
19177 break;
19178 }
19179 break;
19180 case 0x4a:
19181 GETBYTE ();
19182 switch (op[2] & 0x00)
19183 {
19184 case 0x00:
19185 goto op_semantics_147;
19186 break;
19187 }
19188 break;
19189 case 0x4b:
19190 GETBYTE ();
19191 switch (op[2] & 0x00)
19192 {
19193 case 0x00:
19194 goto op_semantics_147;
19195 break;
19196 }
19197 break;
19198 case 0x4c:
19199 GETBYTE ();
19200 switch (op[2] & 0x00)
19201 {
19202 case 0x00:
19203 goto op_semantics_147;
19204 break;
19205 }
19206 break;
19207 case 0x4d:
19208 GETBYTE ();
19209 switch (op[2] & 0x00)
19210 {
19211 case 0x00:
19212 goto op_semantics_147;
19213 break;
19214 }
19215 break;
19216 case 0x4e:
19217 GETBYTE ();
19218 switch (op[2] & 0x00)
19219 {
19220 case 0x00:
19221 goto op_semantics_147;
19222 break;
19223 }
19224 break;
19225 case 0x4f:
19226 GETBYTE ();
19227 switch (op[2] & 0x00)
19228 {
19229 case 0x00:
19230 goto op_semantics_147;
19231 break;
19232 }
19233 break;
19234 case 0x50:
19235 GETBYTE ();
19236 switch (op[2] & 0x00)
19237 {
19238 case 0x00:
19239 op_semantics_148:
19240 {
19241 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
19242 #line 465 "rx-decode.opc"
19243 int rdst AU = op[1] & 0x0f;
19244 #line 465 "rx-decode.opc"
19245 int srca AU = (op[2] >> 4) & 0x0f;
19246 #line 465 "rx-decode.opc"
19247 int srcb AU = op[2] & 0x0f;
19248 if (trace)
19249 {
19250 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19251 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
19252 op[0], op[1], op[2]);
19253 printf (" rdst = 0x%x,", rdst);
19254 printf (" srca = 0x%x,", srca);
19255 printf (" srcb = 0x%x\n", srcb);
19256 }
19257 SYNTAX("or %2, %1, %0");
19258 #line 465 "rx-decode.opc"
19259 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19260
19261 /*----------------------------------------------------------------------*/
19262 /* XOR */
19263
19264 }
19265 break;
19266 }
19267 break;
19268 case 0x51:
19269 GETBYTE ();
19270 switch (op[2] & 0x00)
19271 {
19272 case 0x00:
19273 goto op_semantics_148;
19274 break;
19275 }
19276 break;
19277 case 0x52:
19278 GETBYTE ();
19279 switch (op[2] & 0x00)
19280 {
19281 case 0x00:
19282 goto op_semantics_148;
19283 break;
19284 }
19285 break;
19286 case 0x53:
19287 GETBYTE ();
19288 switch (op[2] & 0x00)
19289 {
19290 case 0x00:
19291 goto op_semantics_148;
19292 break;
19293 }
19294 break;
19295 case 0x54:
19296 GETBYTE ();
19297 switch (op[2] & 0x00)
19298 {
19299 case 0x00:
19300 goto op_semantics_148;
19301 break;
19302 }
19303 break;
19304 case 0x55:
19305 GETBYTE ();
19306 switch (op[2] & 0x00)
19307 {
19308 case 0x00:
19309 goto op_semantics_148;
19310 break;
19311 }
19312 break;
19313 case 0x56:
19314 GETBYTE ();
19315 switch (op[2] & 0x00)
19316 {
19317 case 0x00:
19318 goto op_semantics_148;
19319 break;
19320 }
19321 break;
19322 case 0x57:
19323 GETBYTE ();
19324 switch (op[2] & 0x00)
19325 {
19326 case 0x00:
19327 goto op_semantics_148;
19328 break;
19329 }
19330 break;
19331 case 0x58:
19332 GETBYTE ();
19333 switch (op[2] & 0x00)
19334 {
19335 case 0x00:
19336 goto op_semantics_148;
19337 break;
19338 }
19339 break;
19340 case 0x59:
19341 GETBYTE ();
19342 switch (op[2] & 0x00)
19343 {
19344 case 0x00:
19345 goto op_semantics_148;
19346 break;
19347 }
19348 break;
19349 case 0x5a:
19350 GETBYTE ();
19351 switch (op[2] & 0x00)
19352 {
19353 case 0x00:
19354 goto op_semantics_148;
19355 break;
19356 }
19357 break;
19358 case 0x5b:
19359 GETBYTE ();
19360 switch (op[2] & 0x00)
19361 {
19362 case 0x00:
19363 goto op_semantics_148;
19364 break;
19365 }
19366 break;
19367 case 0x5c:
19368 GETBYTE ();
19369 switch (op[2] & 0x00)
19370 {
19371 case 0x00:
19372 goto op_semantics_148;
19373 break;
19374 }
19375 break;
19376 case 0x5d:
19377 GETBYTE ();
19378 switch (op[2] & 0x00)
19379 {
19380 case 0x00:
19381 goto op_semantics_148;
19382 break;
19383 }
19384 break;
19385 case 0x5e:
19386 GETBYTE ();
19387 switch (op[2] & 0x00)
19388 {
19389 case 0x00:
19390 goto op_semantics_148;
19391 break;
19392 }
19393 break;
19394 case 0x5f:
19395 GETBYTE ();
19396 switch (op[2] & 0x00)
19397 {
19398 case 0x00:
19399 goto op_semantics_148;
19400 break;
19401 }
19402 break;
19403 case 0x60:
19404 GETBYTE ();
19405 switch (op[2] & 0x00)
19406 {
19407 case 0x00:
19408 op_semantics_149:
19409 {
19410 /** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */
19411 #line 1146 "rx-decode.opc"
19412 int rdst AU = op[1] & 0x0f;
19413 #line 1146 "rx-decode.opc"
19414 int srca AU = (op[2] >> 4) & 0x0f;
19415 #line 1146 "rx-decode.opc"
19416 int srcb AU = op[2] & 0x0f;
19417 if (trace)
19418 {
19419 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19420 "/** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */",
19421 op[0], op[1], op[2]);
19422 printf (" rdst = 0x%x,", rdst);
19423 printf (" srca = 0x%x,", srca);
19424 printf (" srcb = 0x%x\n", srcb);
19425 }
19426 SYNTAX("xor %2, %1, %0");
19427 #line 1146 "rx-decode.opc"
19428 ID(xor); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19429
19430 }
19431 break;
19432 }
19433 break;
19434 case 0x61:
19435 GETBYTE ();
19436 switch (op[2] & 0x00)
19437 {
19438 case 0x00:
19439 goto op_semantics_149;
19440 break;
19441 }
19442 break;
19443 case 0x62:
19444 GETBYTE ();
19445 switch (op[2] & 0x00)
19446 {
19447 case 0x00:
19448 goto op_semantics_149;
19449 break;
19450 }
19451 break;
19452 case 0x63:
19453 GETBYTE ();
19454 switch (op[2] & 0x00)
19455 {
19456 case 0x00:
19457 goto op_semantics_149;
19458 break;
19459 }
19460 break;
19461 case 0x64:
19462 GETBYTE ();
19463 switch (op[2] & 0x00)
19464 {
19465 case 0x00:
19466 goto op_semantics_149;
19467 break;
19468 }
19469 break;
19470 case 0x65:
19471 GETBYTE ();
19472 switch (op[2] & 0x00)
19473 {
19474 case 0x00:
19475 goto op_semantics_149;
19476 break;
19477 }
19478 break;
19479 case 0x66:
19480 GETBYTE ();
19481 switch (op[2] & 0x00)
19482 {
19483 case 0x00:
19484 goto op_semantics_149;
19485 break;
19486 }
19487 break;
19488 case 0x67:
19489 GETBYTE ();
19490 switch (op[2] & 0x00)
19491 {
19492 case 0x00:
19493 goto op_semantics_149;
19494 break;
19495 }
19496 break;
19497 case 0x68:
19498 GETBYTE ();
19499 switch (op[2] & 0x00)
19500 {
19501 case 0x00:
19502 goto op_semantics_149;
19503 break;
19504 }
19505 break;
19506 case 0x69:
19507 GETBYTE ();
19508 switch (op[2] & 0x00)
19509 {
19510 case 0x00:
19511 goto op_semantics_149;
19512 break;
19513 }
19514 break;
19515 case 0x6a:
19516 GETBYTE ();
19517 switch (op[2] & 0x00)
19518 {
19519 case 0x00:
19520 goto op_semantics_149;
19521 break;
19522 }
19523 break;
19524 case 0x6b:
19525 GETBYTE ();
19526 switch (op[2] & 0x00)
19527 {
19528 case 0x00:
19529 goto op_semantics_149;
19530 break;
19531 }
19532 break;
19533 case 0x6c:
19534 GETBYTE ();
19535 switch (op[2] & 0x00)
19536 {
19537 case 0x00:
19538 goto op_semantics_149;
19539 break;
19540 }
19541 break;
19542 case 0x6d:
19543 GETBYTE ();
19544 switch (op[2] & 0x00)
19545 {
19546 case 0x00:
19547 goto op_semantics_149;
19548 break;
19549 }
19550 break;
19551 case 0x6e:
19552 GETBYTE ();
19553 switch (op[2] & 0x00)
19554 {
19555 case 0x00:
19556 goto op_semantics_149;
19557 break;
19558 }
19559 break;
19560 case 0x6f:
19561 GETBYTE ();
19562 switch (op[2] & 0x00)
19563 {
19564 case 0x00:
19565 goto op_semantics_149;
19566 break;
19567 }
19568 break;
19569 case 0x80:
19570 GETBYTE ();
19571 switch (op[2] & 0x00)
19572 {
19573 case 0x00:
19574 op_semantics_150:
19575 {
19576 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
19577 #line 1125 "rx-decode.opc"
19578 int rdst AU = op[1] & 0x0f;
19579 #line 1125 "rx-decode.opc"
19580 int srca AU = (op[2] >> 4) & 0x0f;
19581 #line 1125 "rx-decode.opc"
19582 int srcb AU = op[2] & 0x0f;
19583 if (trace)
19584 {
19585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19586 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
19587 op[0], op[1], op[2]);
19588 printf (" rdst = 0x%x,", rdst);
19589 printf (" srca = 0x%x,", srca);
19590 printf (" srcb = 0x%x\n", srcb);
19591 }
19592 SYNTAX("fsub %2, %1, %0");
19593 #line 1125 "rx-decode.opc"
19594 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19595
19596 }
19597 break;
19598 }
19599 break;
19600 case 0x81:
19601 GETBYTE ();
19602 switch (op[2] & 0x00)
19603 {
19604 case 0x00:
19605 goto op_semantics_150;
19606 break;
19607 }
19608 break;
19609 case 0x82:
19610 GETBYTE ();
19611 switch (op[2] & 0x00)
19612 {
19613 case 0x00:
19614 goto op_semantics_150;
19615 break;
19616 }
19617 break;
19618 case 0x83:
19619 GETBYTE ();
19620 switch (op[2] & 0x00)
19621 {
19622 case 0x00:
19623 goto op_semantics_150;
19624 break;
19625 }
19626 break;
19627 case 0x84:
19628 GETBYTE ();
19629 switch (op[2] & 0x00)
19630 {
19631 case 0x00:
19632 goto op_semantics_150;
19633 break;
19634 }
19635 break;
19636 case 0x85:
19637 GETBYTE ();
19638 switch (op[2] & 0x00)
19639 {
19640 case 0x00:
19641 goto op_semantics_150;
19642 break;
19643 }
19644 break;
19645 case 0x86:
19646 GETBYTE ();
19647 switch (op[2] & 0x00)
19648 {
19649 case 0x00:
19650 goto op_semantics_150;
19651 break;
19652 }
19653 break;
19654 case 0x87:
19655 GETBYTE ();
19656 switch (op[2] & 0x00)
19657 {
19658 case 0x00:
19659 goto op_semantics_150;
19660 break;
19661 }
19662 break;
19663 case 0x88:
19664 GETBYTE ();
19665 switch (op[2] & 0x00)
19666 {
19667 case 0x00:
19668 goto op_semantics_150;
19669 break;
19670 }
19671 break;
19672 case 0x89:
19673 GETBYTE ();
19674 switch (op[2] & 0x00)
19675 {
19676 case 0x00:
19677 goto op_semantics_150;
19678 break;
19679 }
19680 break;
19681 case 0x8a:
19682 GETBYTE ();
19683 switch (op[2] & 0x00)
19684 {
19685 case 0x00:
19686 goto op_semantics_150;
19687 break;
19688 }
19689 break;
19690 case 0x8b:
19691 GETBYTE ();
19692 switch (op[2] & 0x00)
19693 {
19694 case 0x00:
19695 goto op_semantics_150;
19696 break;
19697 }
19698 break;
19699 case 0x8c:
19700 GETBYTE ();
19701 switch (op[2] & 0x00)
19702 {
19703 case 0x00:
19704 goto op_semantics_150;
19705 break;
19706 }
19707 break;
19708 case 0x8d:
19709 GETBYTE ();
19710 switch (op[2] & 0x00)
19711 {
19712 case 0x00:
19713 goto op_semantics_150;
19714 break;
19715 }
19716 break;
19717 case 0x8e:
19718 GETBYTE ();
19719 switch (op[2] & 0x00)
19720 {
19721 case 0x00:
19722 goto op_semantics_150;
19723 break;
19724 }
19725 break;
19726 case 0x8f:
19727 GETBYTE ();
19728 switch (op[2] & 0x00)
19729 {
19730 case 0x00:
19731 goto op_semantics_150;
19732 break;
19733 }
19734 break;
19735 case 0xa0:
19736 GETBYTE ();
19737 switch (op[2] & 0x00)
19738 {
19739 case 0x00:
19740 op_semantics_151:
19741 {
19742 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
19743 #line 1122 "rx-decode.opc"
19744 int rdst AU = op[1] & 0x0f;
19745 #line 1122 "rx-decode.opc"
19746 int srca AU = (op[2] >> 4) & 0x0f;
19747 #line 1122 "rx-decode.opc"
19748 int srcb AU = op[2] & 0x0f;
19749 if (trace)
19750 {
19751 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19752 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
19753 op[0], op[1], op[2]);
19754 printf (" rdst = 0x%x,", rdst);
19755 printf (" srca = 0x%x,", srca);
19756 printf (" srcb = 0x%x\n", srcb);
19757 }
19758 SYNTAX("fadd %2, %1, %0");
19759 #line 1122 "rx-decode.opc"
19760 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19761
19762 }
19763 break;
19764 }
19765 break;
19766 case 0xa1:
19767 GETBYTE ();
19768 switch (op[2] & 0x00)
19769 {
19770 case 0x00:
19771 goto op_semantics_151;
19772 break;
19773 }
19774 break;
19775 case 0xa2:
19776 GETBYTE ();
19777 switch (op[2] & 0x00)
19778 {
19779 case 0x00:
19780 goto op_semantics_151;
19781 break;
19782 }
19783 break;
19784 case 0xa3:
19785 GETBYTE ();
19786 switch (op[2] & 0x00)
19787 {
19788 case 0x00:
19789 goto op_semantics_151;
19790 break;
19791 }
19792 break;
19793 case 0xa4:
19794 GETBYTE ();
19795 switch (op[2] & 0x00)
19796 {
19797 case 0x00:
19798 goto op_semantics_151;
19799 break;
19800 }
19801 break;
19802 case 0xa5:
19803 GETBYTE ();
19804 switch (op[2] & 0x00)
19805 {
19806 case 0x00:
19807 goto op_semantics_151;
19808 break;
19809 }
19810 break;
19811 case 0xa6:
19812 GETBYTE ();
19813 switch (op[2] & 0x00)
19814 {
19815 case 0x00:
19816 goto op_semantics_151;
19817 break;
19818 }
19819 break;
19820 case 0xa7:
19821 GETBYTE ();
19822 switch (op[2] & 0x00)
19823 {
19824 case 0x00:
19825 goto op_semantics_151;
19826 break;
19827 }
19828 break;
19829 case 0xa8:
19830 GETBYTE ();
19831 switch (op[2] & 0x00)
19832 {
19833 case 0x00:
19834 goto op_semantics_151;
19835 break;
19836 }
19837 break;
19838 case 0xa9:
19839 GETBYTE ();
19840 switch (op[2] & 0x00)
19841 {
19842 case 0x00:
19843 goto op_semantics_151;
19844 break;
19845 }
19846 break;
19847 case 0xaa:
19848 GETBYTE ();
19849 switch (op[2] & 0x00)
19850 {
19851 case 0x00:
19852 goto op_semantics_151;
19853 break;
19854 }
19855 break;
19856 case 0xab:
19857 GETBYTE ();
19858 switch (op[2] & 0x00)
19859 {
19860 case 0x00:
19861 goto op_semantics_151;
19862 break;
19863 }
19864 break;
19865 case 0xac:
19866 GETBYTE ();
19867 switch (op[2] & 0x00)
19868 {
19869 case 0x00:
19870 goto op_semantics_151;
19871 break;
19872 }
19873 break;
19874 case 0xad:
19875 GETBYTE ();
19876 switch (op[2] & 0x00)
19877 {
19878 case 0x00:
19879 goto op_semantics_151;
19880 break;
19881 }
19882 break;
19883 case 0xae:
19884 GETBYTE ();
19885 switch (op[2] & 0x00)
19886 {
19887 case 0x00:
19888 goto op_semantics_151;
19889 break;
19890 }
19891 break;
19892 case 0xaf:
19893 GETBYTE ();
19894 switch (op[2] & 0x00)
19895 {
19896 case 0x00:
19897 goto op_semantics_151;
19898 break;
19899 }
19900 break;
19901 case 0xb0:
19902 GETBYTE ();
19903 switch (op[2] & 0x00)
19904 {
19905 case 0x00:
19906 op_semantics_152:
19907 {
19908 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
19909 #line 1128 "rx-decode.opc"
19910 int rdst AU = op[1] & 0x0f;
19911 #line 1128 "rx-decode.opc"
19912 int srca AU = (op[2] >> 4) & 0x0f;
19913 #line 1128 "rx-decode.opc"
19914 int srcb AU = op[2] & 0x0f;
19915 if (trace)
19916 {
19917 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19918 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
19919 op[0], op[1], op[2]);
19920 printf (" rdst = 0x%x,", rdst);
19921 printf (" srca = 0x%x,", srca);
19922 printf (" srcb = 0x%x\n", srcb);
19923 }
19924 SYNTAX("fmul %2, %1, %0");
19925 #line 1128 "rx-decode.opc"
19926 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19927
19928 }
19929 break;
19930 }
19931 break;
19932 case 0xb1:
19933 GETBYTE ();
19934 switch (op[2] & 0x00)
19935 {
19936 case 0x00:
19937 goto op_semantics_152;
19938 break;
19939 }
19940 break;
19941 case 0xb2:
19942 GETBYTE ();
19943 switch (op[2] & 0x00)
19944 {
19945 case 0x00:
19946 goto op_semantics_152;
19947 break;
19948 }
19949 break;
19950 case 0xb3:
19951 GETBYTE ();
19952 switch (op[2] & 0x00)
19953 {
19954 case 0x00:
19955 goto op_semantics_152;
19956 break;
19957 }
19958 break;
19959 case 0xb4:
19960 GETBYTE ();
19961 switch (op[2] & 0x00)
19962 {
19963 case 0x00:
19964 goto op_semantics_152;
19965 break;
19966 }
19967 break;
19968 case 0xb5:
19969 GETBYTE ();
19970 switch (op[2] & 0x00)
19971 {
19972 case 0x00:
19973 goto op_semantics_152;
19974 break;
19975 }
19976 break;
19977 case 0xb6:
19978 GETBYTE ();
19979 switch (op[2] & 0x00)
19980 {
19981 case 0x00:
19982 goto op_semantics_152;
19983 break;
19984 }
19985 break;
19986 case 0xb7:
19987 GETBYTE ();
19988 switch (op[2] & 0x00)
19989 {
19990 case 0x00:
19991 goto op_semantics_152;
19992 break;
19993 }
19994 break;
19995 case 0xb8:
19996 GETBYTE ();
19997 switch (op[2] & 0x00)
19998 {
19999 case 0x00:
20000 goto op_semantics_152;
20001 break;
20002 }
20003 break;
20004 case 0xb9:
20005 GETBYTE ();
20006 switch (op[2] & 0x00)
20007 {
20008 case 0x00:
20009 goto op_semantics_152;
20010 break;
20011 }
20012 break;
20013 case 0xba:
20014 GETBYTE ();
20015 switch (op[2] & 0x00)
20016 {
20017 case 0x00:
20018 goto op_semantics_152;
20019 break;
20020 }
20021 break;
20022 case 0xbb:
20023 GETBYTE ();
20024 switch (op[2] & 0x00)
20025 {
20026 case 0x00:
20027 goto op_semantics_152;
20028 break;
20029 }
20030 break;
20031 case 0xbc:
20032 GETBYTE ();
20033 switch (op[2] & 0x00)
20034 {
20035 case 0x00:
20036 goto op_semantics_152;
20037 break;
20038 }
20039 break;
20040 case 0xbd:
20041 GETBYTE ();
20042 switch (op[2] & 0x00)
20043 {
20044 case 0x00:
20045 goto op_semantics_152;
20046 break;
20047 }
20048 break;
20049 case 0xbe:
20050 GETBYTE ();
20051 switch (op[2] & 0x00)
20052 {
20053 case 0x00:
20054 goto op_semantics_152;
20055 break;
20056 }
20057 break;
20058 case 0xbf:
20059 GETBYTE ();
20060 switch (op[2] & 0x00)
20061 {
20062 case 0x00:
20063 goto op_semantics_152;
20064 break;
20065 }
20066 break;
20067 default: UNSUPPORTED(); break;
20068 }
20069 break;
20070 default: UNSUPPORTED(); break;
20071 }
20072 #line 1280 "rx-decode.opc"
20073
20074 return rx->n_bytes;
20075 }
GDB Binutils - Deliverables
This page took 0.530378 seconds and 4 git commands to generate.