projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fixup gdb.python/py-value.exp for bare-metal aarch64-elf
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
CommitLineData
f282425e 1#line 1 "rx-decode.opc"
c7927a3c 2/* -*- c -*- */
6f2750fe 3/* Copyright (C) 2012-2016 Free Software Foundation, Inc.
5bf135a7
NC		 4 Contributed by Red Hat.
5 Written by DJ Delorie.
6
7 This file is part of the GNU opcodes library.
8
9 This library is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 It is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
17 License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
23
df7b86aa 24#include "sysdep.h"
c7927a3c
NC		 25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
c7927a3c
NC		 28#include "ansidecl.h"
29#include "opcode/rx.h"
30
31#define RX_OPCODE_BIG_ENDIAN 0
32
33typedef struct
34{
35 RX_Opcode_Decoded * rx;
36 int (* getbyte)(void *);
37 void * ptr;
38 unsigned char * op;
39} LocalData;
40
41static int trace = 0;
42
43#define BSIZE 0
44#define WSIZE 1
45#define LSIZE 2
46
47/* These are for when the upper bits are "don't care" or "undefined". */
48static int bwl[] =
49{
50 RX_Byte,
51 RX_Word,
b8985e5c 52 RX_Long,
f04265ec 53 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 54};
55
56static int sbwl[] =
57{
58 RX_SByte,
59 RX_SWord,
b8985e5c 60 RX_Long,
f04265ec 61 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 62};
63
f04265ec 64static int ubw[] =
c7927a3c
NC		 65{
66 RX_UByte,
67 RX_UWord,
f04265ec
NC		 68 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
69 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 70};
71
72static int memex[] =
73{
74 RX_SByte,
75 RX_SWord,
76 RX_Long,
77 RX_UWord
78};
79
80#define ID(x) rx->id = RXO_##x
81#define OP(n,t,r,a) (rx->op[n].type = t, \
82 rx->op[n].reg = r, \
83 rx->op[n].addend = a )
84#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
85 rx->op[n].size = s )
86
87/* This is for the BWL and BW bitfields. */
b8985e5c 88static int SCALE[] = { 1, 2, 4, 0 };
c7927a3c
NC		 89/* This is for the prefix size enum. */
90static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
91
92static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
93 16, 17, 0, 0, 0, 0, 0, 0 };
94
95static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
96
97/*
98 *C a constant (immediate) c
99 *R A register
100 *I Register indirect, no offset
101 *Is Register indirect, with offset
102 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
103 *P standard displacement: type (r,[r]), reg, assumes UByte
104 *Pm memex displacement: type (r,[r]), reg, memex code
105 *cc condition code. */
106
107#define DC(c) OP (0, RX_Operand_Immediate, 0, c)
108#define DR(r) OP (0, RX_Operand_Register, r, 0)
109#define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
110#define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
111#define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
112#define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
113
114#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
115#define SR(r) OP (1, RX_Operand_Register, r, 0)
f9c7014e 116#define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
c7927a3c
NC		 117#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
118#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
119#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
120#define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
121#define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
122#define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
123
124#define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
125#define S2R(r) OP (2, RX_Operand_Register, r, 0)
126#define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
127#define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
128#define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
129#define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
130#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
131#define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
132
133#define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
134#define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
f04265ec 135#define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
c7927a3c
NC		 136#define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
137
138#define F(f) store_flags(rx, f)
139
140#define AU ATTRIBUTE_UNUSED
141#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
142
143#define SYNTAX(x) rx->syntax = x
144
145#define UNSUPPORTED() \
146 rx->syntax = "*unknown*"
147
148#define IMM(sf) immediate (sf, 0, ld)
149#define IMMex(sf) immediate (sf, 1, ld)
150
151static int
152immediate (int sfield, int ex, LocalData * ld)
153{
154 unsigned long i = 0, j;
155
156 switch (sfield)
157 {
158#define B ((unsigned long) GETBYTE())
159 case 0:
160#if RX_OPCODE_BIG_ENDIAN
161 i = B;
162 if (ex && (i & 0x80))
163 i -= 0x100;
164 i <<= 24;
165 i |= B << 16;
166 i |= B << 8;
167 i |= B;
168#else
169 i = B;
170 i |= B << 8;
171 i |= B << 16;
172 j = B;
173 if (ex && (j & 0x80))
174 j -= 0x100;
175 i |= j << 24;
176#endif
177 break;
178 case 3:
179#if RX_OPCODE_BIG_ENDIAN
180 i = B << 16;
181 i |= B << 8;
182 i |= B;
183#else
184 i = B;
185 i |= B << 8;
186 i |= B << 16;
187#endif
188 if (ex && (i & 0x800000))
189 i -= 0x1000000;
190 break;
191 case 2:
192#if RX_OPCODE_BIG_ENDIAN
193 i |= B << 8;
194 i |= B;
195#else
196 i |= B;
197 i |= B << 8;
198#endif
199 if (ex && (i & 0x8000))
200 i -= 0x10000;
201 break;
202 case 1:
203 i |= B;
204 if (ex && (i & 0x80))
205 i -= 0x100;
206 break;
207 default:
208 abort();
209 }
210 return i;
211}
212
213static void
214rx_disp (int n, int type, int reg, int size, LocalData * ld)
215{
216 int disp;
217
218 ld->rx->op[n].reg = reg;
219 switch (type)
220 {
221 case 3:
222 ld->rx->op[n].type = RX_Operand_Register;
223 break;
224 case 0:
e292aa7a 225 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
c7927a3c
NC		 226 ld->rx->op[n].addend = 0;
227 break;
228 case 1:
229 ld->rx->op[n].type = RX_Operand_Indirect;
230 disp = GETBYTE ();
231 ld->rx->op[n].addend = disp * PSCALE[size];
232 break;
233 case 2:
234 ld->rx->op[n].type = RX_Operand_Indirect;
235 disp = GETBYTE ();
236#if RX_OPCODE_BIG_ENDIAN
237 disp = disp * 256 + GETBYTE ();
238#else
239 disp = disp + GETBYTE () * 256;
240#endif
241 ld->rx->op[n].addend = disp * PSCALE[size];
242 break;
243 default:
244 abort ();
245 }
246}
247
3cf79a01
DD		 248#define xO 8
249#define xS 4
250#define xZ 2
251#define xC 1
c7927a3c 252
43e65147 253#define F_____
3cf79a01
DD		 254#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
255#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
256#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
257#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
258#define F_O___ rx->flags_0 = rx->flags_s = xO;
259#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
260#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
261#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
c7927a3c
NC		 262
263int
264rx_decode_opcode (unsigned long pc AU,
265 RX_Opcode_Decoded * rx,
266 int (* getbyte)(void *),
267 void * ptr)
268{
269 LocalData lds, * ld = &lds;
270 unsigned char op[20] = {0};
271
272 lds.rx = rx;
273 lds.getbyte = getbyte;
274 lds.ptr = ptr;
275 lds.op = op;
276
277 memset (rx, 0, sizeof (*rx));
278 BWL(LSIZE);
279
280
281/*----------------------------------------------------------------------*/
282/* MOV */
283
284 GETBYTE ();
285 switch (op[0] & 0xff)
286 {
287 case 0x00:
288 {
289 /** 0000 0000 brk */
290 if (trace)
291 {
292 printf ("\033[33m%s\033[0m %02x\n",
293 "/** 0000 0000 brk */",
294 op[0]);
295 }
296 SYNTAX("brk");
a117b0a5 297#line 1025 "rx-decode.opc"
c7927a3c 298 ID(brk);
43e65147 299
c7927a3c
NC		 300 }
301 break;
302 case 0x01:
303 {
304 /** 0000 0001 dbt */
305 if (trace)
306 {
307 printf ("\033[33m%s\033[0m %02x\n",
308 "/** 0000 0001 dbt */",
309 op[0]);
310 }
311 SYNTAX("dbt");
a117b0a5 312#line 1028 "rx-decode.opc"
c7927a3c 313 ID(dbt);
43e65147 314
c7927a3c
NC		 315 }
316 break;
317 case 0x02:
318 {
319 /** 0000 0010 rts */
320 if (trace)
321 {
322 printf ("\033[33m%s\033[0m %02x\n",
323 "/** 0000 0010 rts */",
324 op[0]);
325 }
326 SYNTAX("rts");
a117b0a5 327#line 806 "rx-decode.opc"
c7927a3c 328 ID(rts);
43e65147 329
c7927a3c
NC		 330 /*----------------------------------------------------------------------*/
331 /* NOP */
43e65147 332
c7927a3c
NC		 333 }
334 break;
335 case 0x03:
336 {
337 /** 0000 0011 nop */
338 if (trace)
339 {
340 printf ("\033[33m%s\033[0m %02x\n",
341 "/** 0000 0011 nop */",
342 op[0]);
343 }
344 SYNTAX("nop");
a117b0a5 345#line 812 "rx-decode.opc"
c7927a3c 346 ID(nop);
43e65147 347
c7927a3c
NC		 348 /*----------------------------------------------------------------------*/
349 /* STRING FUNCTIONS */
43e65147 350
c7927a3c
NC		 351 }
352 break;
353 case 0x04:
354 {
355 /** 0000 0100 bra.a %a0 */
356 if (trace)
357 {
358 printf ("\033[33m%s\033[0m %02x\n",
359 "/** 0000 0100 bra.a %a0 */",
360 op[0]);
361 }
362 SYNTAX("bra.a %a0");
a117b0a5 363#line 784 "rx-decode.opc"
f9c7014e 364 ID(branch); DC(pc + IMMex(3));
43e65147 365
c7927a3c
NC		 366 }
367 break;
368 case 0x05:
369 {
370 /** 0000 0101 bsr.a %a0 */
371 if (trace)
372 {
373 printf ("\033[33m%s\033[0m %02x\n",
374 "/** 0000 0101 bsr.a %a0 */",
375 op[0]);
376 }
377 SYNTAX("bsr.a %a0");
a117b0a5 378#line 800 "rx-decode.opc"
c7927a3c 379 ID(jsr); DC(pc + IMMex(3));
43e65147 380
c7927a3c
NC		 381 }
382 break;
383 case 0x06:
384 GETBYTE ();
385 switch (op[1] & 0xff)
386 {
387 case 0x00:
388 GETBYTE ();
389 switch (op[2] & 0x00)
390 {
391 case 0x00:
392 op_semantics_1:
393 {
394 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
b8985e5c 395#line 542 "rx-decode.opc"
c7927a3c 396 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 397#line 542 "rx-decode.opc"
c7927a3c 398 int ss AU = op[1] & 0x03;
b8985e5c 399#line 542 "rx-decode.opc"
c7927a3c 400 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 401#line 542 "rx-decode.opc"
c7927a3c
NC		 402 int rdst AU = op[2] & 0x0f;
403 if (trace)
404 {
405 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
406 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
407 op[0], op[1], op[2]);
408 printf (" mx = 0x%x,", mx);
409 printf (" ss = 0x%x,", ss);
410 printf (" rsrc = 0x%x,", rsrc);
411 printf (" rdst = 0x%x\n", rdst);
412 }
413 SYNTAX("sub %2%S2, %1");
b8985e5c 414#line 542 "rx-decode.opc"
3cf79a01 415 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
43e65147 416
c7927a3c
NC		 417 }
418 break;
419 }
420 break;
421 case 0x01:
422 GETBYTE ();
423 switch (op[2] & 0x00)
424 {
425 case 0x00:
426 goto op_semantics_1;
427 break;
428 }
429 break;
430 case 0x02:
431 GETBYTE ();
432 switch (op[2] & 0x00)
433 {
434 case 0x00:
435 goto op_semantics_1;
436 break;
437 }
438 break;
439 case 0x03:
440 GETBYTE ();
441 switch (op[2] & 0x00)
442 {
443 case 0x00:
444 goto op_semantics_1;
445 break;
446 }
447 break;
448 case 0x04:
449 GETBYTE ();
450 switch (op[2] & 0x00)
451 {
452 case 0x00:
453 op_semantics_2:
454 {
455 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
b8985e5c 456#line 530 "rx-decode.opc"
c7927a3c 457 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 458#line 530 "rx-decode.opc"
c7927a3c 459 int ss AU = op[1] & 0x03;
b8985e5c 460#line 530 "rx-decode.opc"
c7927a3c 461 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 462#line 530 "rx-decode.opc"
c7927a3c
NC		 463 int rdst AU = op[2] & 0x0f;
464 if (trace)
465 {
466 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
467 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
468 op[0], op[1], op[2]);
469 printf (" mx = 0x%x,", mx);
470 printf (" ss = 0x%x,", ss);
471 printf (" rsrc = 0x%x,", rsrc);
472 printf (" rdst = 0x%x\n", rdst);
473 }
474 SYNTAX("cmp %2%S2, %1");
b8985e5c 475#line 530 "rx-decode.opc"
3cf79a01 476 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
43e65147 477
c7927a3c
NC		 478 /*----------------------------------------------------------------------*/
479 /* SUB */
43e65147 480
c7927a3c
NC		 481 }
482 break;
483 }
484 break;
485 case 0x05:
486 GETBYTE ();
487 switch (op[2] & 0x00)
488 {
489 case 0x00:
490 goto op_semantics_2;
491 break;
492 }
493 break;
494 case 0x06:
495 GETBYTE ();
496 switch (op[2] & 0x00)
497 {
498 case 0x00:
499 goto op_semantics_2;
500 break;
501 }
502 break;
503 case 0x07:
504 GETBYTE ();
505 switch (op[2] & 0x00)
506 {
507 case 0x00:
508 goto op_semantics_2;
509 break;
510 }
511 break;
512 case 0x08:
513 GETBYTE ();
514 switch (op[2] & 0x00)
515 {
516 case 0x00:
517 op_semantics_3:
518 {
519 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
b8985e5c 520#line 506 "rx-decode.opc"
c7927a3c 521 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 522#line 506 "rx-decode.opc"
c7927a3c 523 int ss AU = op[1] & 0x03;
b8985e5c 524#line 506 "rx-decode.opc"
c7927a3c 525 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 526#line 506 "rx-decode.opc"
c7927a3c
NC		 527 int rdst AU = op[2] & 0x0f;
528 if (trace)
529 {
530 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
531 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
532 op[0], op[1], op[2]);
533 printf (" mx = 0x%x,", mx);
534 printf (" ss = 0x%x,", ss);
535 printf (" rsrc = 0x%x,", rsrc);
536 printf (" rdst = 0x%x\n", rdst);
537 }
538 SYNTAX("add %1%S1, %0");
b8985e5c 539#line 506 "rx-decode.opc"
3cf79a01 540 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
43e65147 541
c7927a3c
NC		 542 }
543 break;
544 }
545 break;
546 case 0x09:
547 GETBYTE ();
548 switch (op[2] & 0x00)
549 {
550 case 0x00:
551 goto op_semantics_3;
552 break;
553 }
554 break;
555 case 0x0a:
556 GETBYTE ();
557 switch (op[2] & 0x00)
558 {
559 case 0x00:
560 goto op_semantics_3;
561 break;
562 }
563 break;
564 case 0x0b:
565 GETBYTE ();
566 switch (op[2] & 0x00)
567 {
568 case 0x00:
569 goto op_semantics_3;
570 break;
571 }
572 break;
573 case 0x0c:
574 GETBYTE ();
575 switch (op[2] & 0x00)
576 {
577 case 0x00:
578 op_semantics_4:
579 {
580 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
a117b0a5 581#line 649 "rx-decode.opc"
c7927a3c 582 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 583#line 649 "rx-decode.opc"
c7927a3c 584 int ss AU = op[1] & 0x03;
a117b0a5 585#line 649 "rx-decode.opc"
c7927a3c 586 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 587#line 649 "rx-decode.opc"
c7927a3c
NC		 588 int rdst AU = op[2] & 0x0f;
589 if (trace)
590 {
591 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
592 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
593 op[0], op[1], op[2]);
594 printf (" mx = 0x%x,", mx);
595 printf (" ss = 0x%x,", ss);
596 printf (" rsrc = 0x%x,", rsrc);
597 printf (" rdst = 0x%x\n", rdst);
598 }
599 SYNTAX("mul %1%S1, %0");
a117b0a5 600#line 649 "rx-decode.opc"
3cf79a01 601 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
43e65147 602
c7927a3c
NC		 603 }
604 break;
605 }
606 break;
607 case 0x0d:
608 GETBYTE ();
609 switch (op[2] & 0x00)
610 {
611 case 0x00:
612 goto op_semantics_4;
613 break;
614 }
615 break;
616 case 0x0e:
617 GETBYTE ();
618 switch (op[2] & 0x00)
619 {
620 case 0x00:
621 goto op_semantics_4;
622 break;
623 }
624 break;
625 case 0x0f:
626 GETBYTE ();
627 switch (op[2] & 0x00)
628 {
629 case 0x00:
630 goto op_semantics_4;
631 break;
632 }
633 break;
634 case 0x10:
635 GETBYTE ();
636 switch (op[2] & 0x00)
637 {
638 case 0x00:
639 op_semantics_5:
640 {
641 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
b8985e5c 642#line 419 "rx-decode.opc"
c7927a3c 643 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 644#line 419 "rx-decode.opc"
c7927a3c 645 int ss AU = op[1] & 0x03;
b8985e5c 646#line 419 "rx-decode.opc"
c7927a3c 647 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 648#line 419 "rx-decode.opc"
c7927a3c
NC		 649 int rdst AU = op[2] & 0x0f;
650 if (trace)
651 {
652 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
653 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
654 op[0], op[1], op[2]);
655 printf (" mx = 0x%x,", mx);
656 printf (" ss = 0x%x,", ss);
657 printf (" rsrc = 0x%x,", rsrc);
658 printf (" rdst = 0x%x\n", rdst);
659 }
660 SYNTAX("and %1%S1, %0");
b8985e5c 661#line 419 "rx-decode.opc"
3cf79a01 662 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 663
c7927a3c
NC		 664 }
665 break;
666 }
667 break;
668 case 0x11:
669 GETBYTE ();
670 switch (op[2] & 0x00)
671 {
672 case 0x00:
673 goto op_semantics_5;
674 break;
675 }
676 break;
677 case 0x12:
678 GETBYTE ();
679 switch (op[2] & 0x00)
680 {
681 case 0x00:
682 goto op_semantics_5;
683 break;
684 }
685 break;
686 case 0x13:
687 GETBYTE ();
688 switch (op[2] & 0x00)
689 {
690 case 0x00:
691 goto op_semantics_5;
692 break;
693 }
694 break;
695 case 0x14:
696 GETBYTE ();
697 switch (op[2] & 0x00)
698 {
699 case 0x00:
700 op_semantics_6:
701 {
702 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
b8985e5c 703#line 437 "rx-decode.opc"
c7927a3c 704 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 705#line 437 "rx-decode.opc"
c7927a3c 706 int ss AU = op[1] & 0x03;
b8985e5c 707#line 437 "rx-decode.opc"
c7927a3c 708 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 709#line 437 "rx-decode.opc"
c7927a3c
NC		 710 int rdst AU = op[2] & 0x0f;
711 if (trace)
712 {
713 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
714 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
715 op[0], op[1], op[2]);
716 printf (" mx = 0x%x,", mx);
717 printf (" ss = 0x%x,", ss);
718 printf (" rsrc = 0x%x,", rsrc);
719 printf (" rdst = 0x%x\n", rdst);
720 }
721 SYNTAX("or %1%S1, %0");
b8985e5c 722#line 437 "rx-decode.opc"
3cf79a01 723 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 724
c7927a3c
NC		 725 }
726 break;
727 }
728 break;
729 case 0x15:
730 GETBYTE ();
731 switch (op[2] & 0x00)
732 {
733 case 0x00:
734 goto op_semantics_6;
735 break;
736 }
737 break;
738 case 0x16:
739 GETBYTE ();
740 switch (op[2] & 0x00)
741 {
742 case 0x00:
743 goto op_semantics_6;
744 break;
745 }
746 break;
747 case 0x17:
748 GETBYTE ();
749 switch (op[2] & 0x00)
750 {
751 case 0x00:
752 goto op_semantics_6;
753 break;
754 }
755 break;
756 case 0x20:
757 GETBYTE ();
758 switch (op[2] & 0xff)
759 {
760 case 0x00:
761 GETBYTE ();
762 switch (op[3] & 0x00)
763 {
764 case 0x00:
765 op_semantics_7:
766 {
767 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
b8985e5c 768#line 555 "rx-decode.opc"
c7927a3c 769 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 770#line 555 "rx-decode.opc"
c7927a3c 771 int sp AU = op[1] & 0x03;
b8985e5c 772#line 555 "rx-decode.opc"
c7927a3c 773 int rsrc AU = (op[3] >> 4) & 0x0f;
b8985e5c 774#line 555 "rx-decode.opc"
c7927a3c
NC		 775 int rdst AU = op[3] & 0x0f;
776 if (trace)
777 {
778 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
779 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
780 op[0], op[1], op[2], op[3]);
781 printf (" mx = 0x%x,", mx);
782 printf (" sp = 0x%x,", sp);
783 printf (" rsrc = 0x%x,", rsrc);
784 printf (" rdst = 0x%x\n", rdst);
785 }
786 SYNTAX("sbb %1%S1, %0");
b8985e5c 787#line 555 "rx-decode.opc"
3cf79a01 788 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
43e65147 789
c7927a3c
NC		 790 /*----------------------------------------------------------------------*/
791 /* ABS */
43e65147 792
c7927a3c
NC		 793 }
794 break;
795 }
796 break;
797 case 0x04:
798 GETBYTE ();
799 switch (op[3] & 0x00)
800 {
801 case 0x00:
802 op_semantics_8:
803 {
804 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
a117b0a5 805#line 594 "rx-decode.opc"
c7927a3c 806 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 807#line 594 "rx-decode.opc"
c7927a3c 808 int ss AU = op[1] & 0x03;
a117b0a5 809#line 594 "rx-decode.opc"
c7927a3c 810 int rsrc AU = (op[3] >> 4) & 0x0f;
a117b0a5 811#line 594 "rx-decode.opc"
c7927a3c
NC		 812 int rdst AU = op[3] & 0x0f;
813 if (trace)
814 {
815 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
816 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
817 op[0], op[1], op[2], op[3]);
818 printf (" mx = 0x%x,", mx);
819 printf (" ss = 0x%x,", ss);
820 printf (" rsrc = 0x%x,", rsrc);
821 printf (" rdst = 0x%x\n", rdst);
822 }
823 SYNTAX("max %1%S1, %0");
a117b0a5 824#line 594 "rx-decode.opc"
c7927a3c 825 ID(max); SPm(ss, rsrc, mx); DR(rdst);
43e65147 826
c7927a3c
NC		 827 /*----------------------------------------------------------------------*/
828 /* MIN */
43e65147 829
c7927a3c
NC		 830 }
831 break;
832 }
833 break;
834 case 0x05:
835 GETBYTE ();
836 switch (op[3] & 0x00)
837 {
838 case 0x00:
839 op_semantics_9:
840 {
841 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
a117b0a5 842#line 606 "rx-decode.opc"
c7927a3c 843 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 844#line 606 "rx-decode.opc"
c7927a3c 845 int ss AU = op[1] & 0x03;
a117b0a5 846#line 606 "rx-decode.opc"
c7927a3c 847 int rsrc AU = (op[3] >> 4) & 0x0f;
a117b0a5 848#line 606 "rx-decode.opc"
c7927a3c
NC		 849 int rdst AU = op[3] & 0x0f;
850 if (trace)
851 {
852 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
853 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
854 op[0], op[1], op[2], op[3]);
855 printf (" mx = 0x%x,", mx);
856 printf (" ss = 0x%x,", ss);
857 printf (" rsrc = 0x%x,", rsrc);
858 printf (" rdst = 0x%x\n", rdst);
859 }
860 SYNTAX("min %1%S1, %0");
a117b0a5 861#line 606 "rx-decode.opc"
c7927a3c 862 ID(min); SPm(ss, rsrc, mx); DR(rdst);
43e65147 863
c7927a3c
NC		 864 /*----------------------------------------------------------------------*/
865 /* MUL */
43e65147 866
c7927a3c
NC		 867 }
868 break;
869 }
870 break;
871 case 0x06:
872 GETBYTE ();
873 switch (op[3] & 0x00)
874 {
875 case 0x00:
876 op_semantics_10:
877 {
878 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
a117b0a5 879#line 664 "rx-decode.opc"
c7927a3c 880 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 881#line 664 "rx-decode.opc"
c7927a3c 882 int ss AU = op[1] & 0x03;
a117b0a5 883#line 664 "rx-decode.opc"
c7927a3c 884 int rsrc AU = (op[3] >> 4) & 0x0f;
a117b0a5 885#line 664 "rx-decode.opc"
c7927a3c
NC		 886 int rdst AU = op[3] & 0x0f;
887 if (trace)
888 {
889 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
890 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
891 op[0], op[1], op[2], op[3]);
892 printf (" mx = 0x%x,", mx);
893 printf (" ss = 0x%x,", ss);
894 printf (" rsrc = 0x%x,", rsrc);
895 printf (" rdst = 0x%x\n", rdst);
896 }
897 SYNTAX("emul %1%S1, %0");
a117b0a5 898#line 664 "rx-decode.opc"
c7927a3c 899 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
43e65147 900
c7927a3c
NC		 901 /*----------------------------------------------------------------------*/
902 /* EMULU */
43e65147 903
c7927a3c
NC		 904 }
905 break;
906 }
907 break;
908 case 0x07:
909 GETBYTE ();
910 switch (op[3] & 0x00)
911 {
912 case 0x00:
913 op_semantics_11:
914 {
915 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
a117b0a5 916#line 676 "rx-decode.opc"
c7927a3c 917 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 918#line 676 "rx-decode.opc"
c7927a3c 919 int ss AU = op[1] & 0x03;
a117b0a5 920#line 676 "rx-decode.opc"
c7927a3c 921 int rsrc AU = (op[3] >> 4) & 0x0f;
a117b0a5 922#line 676 "rx-decode.opc"
c7927a3c
NC		 923 int rdst AU = op[3] & 0x0f;
924 if (trace)
925 {
926 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
927 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
928 op[0], op[1], op[2], op[3]);
929 printf (" mx = 0x%x,", mx);
930 printf (" ss = 0x%x,", ss);
931 printf (" rsrc = 0x%x,", rsrc);
932 printf (" rdst = 0x%x\n", rdst);
933 }
934 SYNTAX("emulu %1%S1, %0");
a117b0a5 935#line 676 "rx-decode.opc"
c7927a3c 936 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
43e65147 937
c7927a3c
NC		 938 /*----------------------------------------------------------------------*/
939 /* DIV */
43e65147 940
c7927a3c
NC		 941 }
942 break;
943 }
944 break;
945 case 0x08:
946 GETBYTE ();
947 switch (op[3] & 0x00)
948 {
949 case 0x00:
950 op_semantics_12:
951 {
952 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
a117b0a5 953#line 688 "rx-decode.opc"
c7927a3c 954 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 955#line 688 "rx-decode.opc"
c7927a3c 956 int ss AU = op[1] & 0x03;
a117b0a5 957#line 688 "rx-decode.opc"
c7927a3c 958 int rsrc AU = (op[3] >> 4) & 0x0f;
a117b0a5 959#line 688 "rx-decode.opc"
c7927a3c
NC		 960 int rdst AU = op[3] & 0x0f;
961 if (trace)
962 {
963 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
964 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
965 op[0], op[1], op[2], op[3]);
966 printf (" mx = 0x%x,", mx);
967 printf (" ss = 0x%x,", ss);
968 printf (" rsrc = 0x%x,", rsrc);
969 printf (" rdst = 0x%x\n", rdst);
970 }
971 SYNTAX("div %1%S1, %0");
a117b0a5 972#line 688 "rx-decode.opc"
3cf79a01 973 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
43e65147 974
c7927a3c
NC		 975 /*----------------------------------------------------------------------*/
976 /* DIVU */
43e65147 977
c7927a3c
NC		 978 }
979 break;
980 }
981 break;
982 case 0x09:
983 GETBYTE ();
984 switch (op[3] & 0x00)
985 {
986 case 0x00:
987 op_semantics_13:
988 {
989 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
a117b0a5 990#line 700 "rx-decode.opc"
c7927a3c 991 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 992#line 700 "rx-decode.opc"
c7927a3c 993 int ss AU = op[1] & 0x03;
a117b0a5 994#line 700 "rx-decode.opc"
c7927a3c 995 int rsrc AU = (op[3] >> 4) & 0x0f;
a117b0a5 996#line 700 "rx-decode.opc"
c7927a3c
NC		 997 int rdst AU = op[3] & 0x0f;
998 if (trace)
999 {
1000 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1001 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1002 op[0], op[1], op[2], op[3]);
1003 printf (" mx = 0x%x,", mx);
1004 printf (" ss = 0x%x,", ss);
1005 printf (" rsrc = 0x%x,", rsrc);
1006 printf (" rdst = 0x%x\n", rdst);
1007 }
1008 SYNTAX("divu %1%S1, %0");
a117b0a5 1009#line 700 "rx-decode.opc"
3cf79a01 1010 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
43e65147 1011
c7927a3c
NC		 1012 /*----------------------------------------------------------------------*/
1013 /* SHIFT */
43e65147 1014
c7927a3c
NC		 1015 }
1016 break;
1017 }
1018 break;
1019 case 0x0c:
1020 GETBYTE ();
1021 switch (op[3] & 0x00)
1022 {
1023 case 0x00:
1024 op_semantics_14:
1025 {
1026 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
b8985e5c 1027#line 473 "rx-decode.opc"
c7927a3c 1028 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 1029#line 473 "rx-decode.opc"
c7927a3c 1030 int ss AU = op[1] & 0x03;
b8985e5c 1031#line 473 "rx-decode.opc"
c7927a3c 1032 int rsrc AU = (op[3] >> 4) & 0x0f;
b8985e5c 1033#line 473 "rx-decode.opc"
c7927a3c
NC		 1034 int rdst AU = op[3] & 0x0f;
1035 if (trace)
1036 {
1037 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1038 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1039 op[0], op[1], op[2], op[3]);
1040 printf (" mx = 0x%x,", mx);
1041 printf (" ss = 0x%x,", ss);
1042 printf (" rsrc = 0x%x,", rsrc);
1043 printf (" rdst = 0x%x\n", rdst);
1044 }
1045 SYNTAX("tst %1%S1, %2");
b8985e5c 1046#line 473 "rx-decode.opc"
3cf79a01 1047 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
43e65147 1048
c7927a3c
NC		 1049 /*----------------------------------------------------------------------*/
1050 /* NEG */
43e65147 1051
c7927a3c
NC		 1052 }
1053 break;
1054 }
1055 break;
1056 case 0x0d:
1057 GETBYTE ();
1058 switch (op[3] & 0x00)
1059 {
1060 case 0x00:
1061 op_semantics_15:
1062 {
1063 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
b8985e5c 1064#line 452 "rx-decode.opc"
c7927a3c 1065 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 1066#line 452 "rx-decode.opc"
c7927a3c 1067 int ss AU = op[1] & 0x03;
b8985e5c 1068#line 452 "rx-decode.opc"
c7927a3c 1069 int rsrc AU = (op[3] >> 4) & 0x0f;
b8985e5c 1070#line 452 "rx-decode.opc"
c7927a3c
NC		 1071 int rdst AU = op[3] & 0x0f;
1072 if (trace)
1073 {
1074 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1075 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1076 op[0], op[1], op[2], op[3]);
1077 printf (" mx = 0x%x,", mx);
1078 printf (" ss = 0x%x,", ss);
1079 printf (" rsrc = 0x%x,", rsrc);
1080 printf (" rdst = 0x%x\n", rdst);
1081 }
1082 SYNTAX("xor %1%S1, %0");
b8985e5c 1083#line 452 "rx-decode.opc"
3cf79a01 1084 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 1085
c7927a3c
NC		 1086 /*----------------------------------------------------------------------*/
1087 /* NOT */
43e65147 1088
c7927a3c
NC		 1089 }
1090 break;
1091 }
1092 break;
1093 case 0x10:
1094 GETBYTE ();
1095 switch (op[3] & 0x00)
1096 {
1097 case 0x00:
1098 op_semantics_16:
1099 {
1100 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
b8985e5c 1101#line 386 "rx-decode.opc"
c7927a3c 1102 int mx AU = (op[1] >> 6) & 0x03;
b8985e5c 1103#line 386 "rx-decode.opc"
c7927a3c 1104 int ss AU = op[1] & 0x03;
b8985e5c 1105#line 386 "rx-decode.opc"
c7927a3c 1106 int rsrc AU = (op[3] >> 4) & 0x0f;
b8985e5c 1107#line 386 "rx-decode.opc"
c7927a3c
NC		 1108 int rdst AU = op[3] & 0x0f;
1109 if (trace)
1110 {
1111 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1112 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1113 op[0], op[1], op[2], op[3]);
1114 printf (" mx = 0x%x,", mx);
1115 printf (" ss = 0x%x,", ss);
1116 printf (" rsrc = 0x%x,", rsrc);
1117 printf (" rdst = 0x%x\n", rdst);
1118 }
1119 SYNTAX("xchg %1%S1, %0");
b8985e5c 1120#line 386 "rx-decode.opc"
c7927a3c 1121 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
43e65147 1122
c7927a3c
NC		 1123 /*----------------------------------------------------------------------*/
1124 /* STZ/STNZ */
43e65147 1125
c7927a3c
NC		 1126 }
1127 break;
1128 }
1129 break;
1130 case 0x11:
1131 GETBYTE ();
1132 switch (op[3] & 0x00)
1133 {
1134 case 0x00:
1135 op_semantics_17:
1136 {
1137 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
a117b0a5 1138#line 929 "rx-decode.opc"
c7927a3c 1139 int mx AU = (op[1] >> 6) & 0x03;
a117b0a5 1140#line 929 "rx-decode.opc"
c7927a3c 1141 int sd AU = op[1] & 0x03;
a117b0a5 1142#line 929 "rx-decode.opc"
c7927a3c 1143 int rsrc AU = (op[3] >> 4) & 0x0f;
a117b0a5 1144#line 929 "rx-decode.opc"
c7927a3c
NC		 1145 int rdst AU = op[3] & 0x0f;
1146 if (trace)
1147 {
1148 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1149 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1150 op[0], op[1], op[2], op[3]);
1151 printf (" mx = 0x%x,", mx);
1152 printf (" sd = 0x%x,", sd);
1153 printf (" rsrc = 0x%x,", rsrc);
1154 printf (" rdst = 0x%x\n", rdst);
1155 }
1156 SYNTAX("itof %1%S1, %0");
a117b0a5 1157#line 929 "rx-decode.opc"
3cf79a01 1158 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
43e65147 1159
c7927a3c
NC		 1160 /*----------------------------------------------------------------------*/
1161 /* BIT OPS */
43e65147 1162
a117b0a5
YS		 1163 }
1164 break;
1165 }
1166 break;
1167 case 0x15:
1168 GETBYTE ();
1169 switch (op[3] & 0x00)
1170 {
1171 case 0x00:
1172 op_semantics_18:
1173 {
1174 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
1175#line 1115 "rx-decode.opc"
1176 int mx AU = (op[1] >> 6) & 0x03;
1177#line 1115 "rx-decode.opc"
1178 int sd AU = op[1] & 0x03;
1179#line 1115 "rx-decode.opc"
1180 int rsrc AU = (op[3] >> 4) & 0x0f;
1181#line 1115 "rx-decode.opc"
1182 int rdst AU = op[3] & 0x0f;
1183 if (trace)
1184 {
1185 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1186 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1187 op[0], op[1], op[2], op[3]);
1188 printf (" mx = 0x%x,", mx);
1189 printf (" sd = 0x%x,", sd);
1190 printf (" rsrc = 0x%x,", rsrc);
1191 printf (" rdst = 0x%x\n", rdst);
1192 }
1193 SYNTAX("utof %1%S1, %0");
1194#line 1115 "rx-decode.opc"
1195 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1196
c7927a3c
NC		 1197 }
1198 break;
1199 }
1200 break;
1201 default: UNSUPPORTED(); break;
1202 }
1203 break;
1204 case 0x21:
1205 GETBYTE ();
1206 switch (op[2] & 0xff)
1207 {
1208 case 0x00:
1209 GETBYTE ();
1210 switch (op[3] & 0x00)
1211 {
1212 case 0x00:
1213 goto op_semantics_7;
1214 break;
1215 }
1216 break;
1217 case 0x04:
1218 GETBYTE ();
1219 switch (op[3] & 0x00)
1220 {
1221 case 0x00:
1222 goto op_semantics_8;
1223 break;
1224 }
1225 break;
1226 case 0x05:
1227 GETBYTE ();
1228 switch (op[3] & 0x00)
1229 {
1230 case 0x00:
1231 goto op_semantics_9;
1232 break;
1233 }
1234 break;
1235 case 0x06:
1236 GETBYTE ();
1237 switch (op[3] & 0x00)
1238 {
1239 case 0x00:
1240 goto op_semantics_10;
1241 break;
1242 }
1243 break;
1244 case 0x07:
1245 GETBYTE ();
1246 switch (op[3] & 0x00)
1247 {
1248 case 0x00:
1249 goto op_semantics_11;
1250 break;
1251 }
1252 break;
1253 case 0x08:
1254 GETBYTE ();
1255 switch (op[3] & 0x00)
1256 {
1257 case 0x00:
1258 goto op_semantics_12;
1259 break;
1260 }
1261 break;
1262 case 0x09:
1263 GETBYTE ();
1264 switch (op[3] & 0x00)
1265 {
1266 case 0x00:
1267 goto op_semantics_13;
1268 break;
1269 }
1270 break;
1271 case 0x0c:
1272 GETBYTE ();
1273 switch (op[3] & 0x00)
1274 {
1275 case 0x00:
1276 goto op_semantics_14;
1277 break;
1278 }
1279 break;
1280 case 0x0d:
1281 GETBYTE ();
1282 switch (op[3] & 0x00)
1283 {
1284 case 0x00:
1285 goto op_semantics_15;
1286 break;
1287 }
1288 break;
1289 case 0x10:
1290 GETBYTE ();
1291 switch (op[3] & 0x00)
1292 {
1293 case 0x00:
1294 goto op_semantics_16;
1295 break;
1296 }
1297 break;
1298 case 0x11:
1299 GETBYTE ();
1300 switch (op[3] & 0x00)
1301 {
1302 case 0x00:
1303 goto op_semantics_17;
1304 break;
1305 }
1306 break;
a117b0a5
YS		 1307 case 0x15:
1308 GETBYTE ();
1309 switch (op[3] & 0x00)
1310 {
1311 case 0x00:
1312 goto op_semantics_18;
1313 break;
1314 }
1315 break;
c7927a3c
NC		 1316 default: UNSUPPORTED(); break;
1317 }
1318 break;
1319 case 0x22:
1320 GETBYTE ();
1321 switch (op[2] & 0xff)
1322 {
1323 case 0x00:
1324 GETBYTE ();
1325 switch (op[3] & 0x00)
1326 {
1327 case 0x00:
1328 goto op_semantics_7;
1329 break;
1330 }
1331 break;
1332 case 0x04:
1333 GETBYTE ();
1334 switch (op[3] & 0x00)
1335 {
1336 case 0x00:
1337 goto op_semantics_8;
1338 break;
1339 }
1340 break;
1341 case 0x05:
1342 GETBYTE ();
1343 switch (op[3] & 0x00)
1344 {
1345 case 0x00:
1346 goto op_semantics_9;
1347 break;
1348 }
1349 break;
1350 case 0x06:
1351 GETBYTE ();
1352 switch (op[3] & 0x00)
1353 {
1354 case 0x00:
1355 goto op_semantics_10;
1356 break;
1357 }
1358 break;
1359 case 0x07:
1360 GETBYTE ();
1361 switch (op[3] & 0x00)
1362 {
1363 case 0x00:
1364 goto op_semantics_11;
1365 break;
1366 }
1367 break;
1368 case 0x08:
1369 GETBYTE ();
1370 switch (op[3] & 0x00)
1371 {
1372 case 0x00:
1373 goto op_semantics_12;
1374 break;
1375 }
1376 break;
1377 case 0x09:
1378 GETBYTE ();
1379 switch (op[3] & 0x00)
1380 {
1381 case 0x00:
1382 goto op_semantics_13;
1383 break;
1384 }
1385 break;
1386 case 0x0c:
1387 GETBYTE ();
1388 switch (op[3] & 0x00)
1389 {
1390 case 0x00:
1391 goto op_semantics_14;
1392 break;
1393 }
1394 break;
1395 case 0x0d:
1396 GETBYTE ();
1397 switch (op[3] & 0x00)
1398 {
1399 case 0x00:
1400 goto op_semantics_15;
1401 break;
1402 }
1403 break;
1404 case 0x10:
1405 GETBYTE ();
1406 switch (op[3] & 0x00)
1407 {
1408 case 0x00:
1409 goto op_semantics_16;
1410 break;
1411 }
1412 break;
1413 case 0x11:
1414 GETBYTE ();
1415 switch (op[3] & 0x00)
1416 {
1417 case 0x00:
1418 goto op_semantics_17;
1419 break;
1420 }
1421 break;
a117b0a5
YS		 1422 case 0x15:
1423 GETBYTE ();
1424 switch (op[3] & 0x00)
1425 {
1426 case 0x00:
1427 goto op_semantics_18;
1428 break;
1429 }
1430 break;
c7927a3c
NC		 1431 default: UNSUPPORTED(); break;
1432 }
1433 break;
1434 case 0x23:
1435 GETBYTE ();
1436 switch (op[2] & 0xff)
1437 {
1438 case 0x00:
1439 GETBYTE ();
1440 switch (op[3] & 0x00)
1441 {
1442 case 0x00:
1443 goto op_semantics_7;
1444 break;
1445 }
1446 break;
1447 case 0x04:
1448 GETBYTE ();
1449 switch (op[3] & 0x00)
1450 {
1451 case 0x00:
1452 goto op_semantics_8;
1453 break;
1454 }
1455 break;
1456 case 0x05:
1457 GETBYTE ();
1458 switch (op[3] & 0x00)
1459 {
1460 case 0x00:
1461 goto op_semantics_9;
1462 break;
1463 }
1464 break;
1465 case 0x06:
1466 GETBYTE ();
1467 switch (op[3] & 0x00)
1468 {
1469 case 0x00:
1470 goto op_semantics_10;
1471 break;
1472 }
1473 break;
1474 case 0x07:
1475 GETBYTE ();
1476 switch (op[3] & 0x00)
1477 {
1478 case 0x00:
1479 goto op_semantics_11;
1480 break;
1481 }
1482 break;
1483 case 0x08:
1484 GETBYTE ();
1485 switch (op[3] & 0x00)
1486 {
1487 case 0x00:
1488 goto op_semantics_12;
1489 break;
1490 }
1491 break;
1492 case 0x09:
1493 GETBYTE ();
1494 switch (op[3] & 0x00)
1495 {
1496 case 0x00:
1497 goto op_semantics_13;
1498 break;
1499 }
1500 break;
1501 case 0x0c:
1502 GETBYTE ();
1503 switch (op[3] & 0x00)
1504 {
1505 case 0x00:
1506 goto op_semantics_14;
1507 break;
1508 }
1509 break;
1510 case 0x0d:
1511 GETBYTE ();
1512 switch (op[3] & 0x00)
1513 {
1514 case 0x00:
1515 goto op_semantics_15;
1516 break;
1517 }
1518 break;
1519 case 0x10:
1520 GETBYTE ();
1521 switch (op[3] & 0x00)
1522 {
1523 case 0x00:
1524 goto op_semantics_16;
1525 break;
1526 }
1527 break;
1528 case 0x11:
1529 GETBYTE ();
1530 switch (op[3] & 0x00)
1531 {
1532 case 0x00:
1533 goto op_semantics_17;
1534 break;
1535 }
1536 break;
a117b0a5
YS		 1537 case 0x15:
1538 GETBYTE ();
1539 switch (op[3] & 0x00)
1540 {
1541 case 0x00:
1542 goto op_semantics_18;
1543 break;
1544 }
1545 break;
c7927a3c
NC		 1546 default: UNSUPPORTED(); break;
1547 }
1548 break;
1549 case 0x40:
1550 GETBYTE ();
1551 switch (op[2] & 0x00)
1552 {
1553 case 0x00:
1554 goto op_semantics_1;
1555 break;
1556 }
1557 break;
1558 case 0x41:
1559 GETBYTE ();
1560 switch (op[2] & 0x00)
1561 {
1562 case 0x00:
1563 goto op_semantics_1;
1564 break;
1565 }
1566 break;
1567 case 0x42:
1568 GETBYTE ();
1569 switch (op[2] & 0x00)
1570 {
1571 case 0x00:
1572 goto op_semantics_1;
1573 break;
1574 }
1575 break;
1576 case 0x43:
1577 GETBYTE ();
1578 switch (op[2] & 0x00)
1579 {
1580 case 0x00:
1581 goto op_semantics_1;
1582 break;
1583 }
1584 break;
1585 case 0x44:
1586 GETBYTE ();
1587 switch (op[2] & 0x00)
1588 {
1589 case 0x00:
1590 goto op_semantics_2;
1591 break;
1592 }
1593 break;
1594 case 0x45:
1595 GETBYTE ();
1596 switch (op[2] & 0x00)
1597 {
1598 case 0x00:
1599 goto op_semantics_2;
1600 break;
1601 }
1602 break;
1603 case 0x46:
1604 GETBYTE ();
1605 switch (op[2] & 0x00)
1606 {
1607 case 0x00:
1608 goto op_semantics_2;
1609 break;
1610 }
1611 break;
1612 case 0x47:
1613 GETBYTE ();
1614 switch (op[2] & 0x00)
1615 {
1616 case 0x00:
1617 goto op_semantics_2;
1618 break;
1619 }
1620 break;
1621 case 0x48:
1622 GETBYTE ();
1623 switch (op[2] & 0x00)
1624 {
1625 case 0x00:
1626 goto op_semantics_3;
1627 break;
1628 }
1629 break;
1630 case 0x49:
1631 GETBYTE ();
1632 switch (op[2] & 0x00)
1633 {
1634 case 0x00:
1635 goto op_semantics_3;
1636 break;
1637 }
1638 break;
1639 case 0x4a:
1640 GETBYTE ();
1641 switch (op[2] & 0x00)
1642 {
1643 case 0x00:
1644 goto op_semantics_3;
1645 break;
1646 }
1647 break;
1648 case 0x4b:
1649 GETBYTE ();
1650 switch (op[2] & 0x00)
1651 {
1652 case 0x00:
1653 goto op_semantics_3;
1654 break;
1655 }
1656 break;
1657 case 0x4c:
1658 GETBYTE ();
1659 switch (op[2] & 0x00)
1660 {
1661 case 0x00:
1662 goto op_semantics_4;
1663 break;
1664 }
1665 break;
1666 case 0x4d:
1667 GETBYTE ();
1668 switch (op[2] & 0x00)
1669 {
1670 case 0x00:
1671 goto op_semantics_4;
1672 break;
1673 }
1674 break;
1675 case 0x4e:
1676 GETBYTE ();
1677 switch (op[2] & 0x00)
1678 {
1679 case 0x00:
1680 goto op_semantics_4;
1681 break;
1682 }
1683 break;
1684 case 0x4f:
1685 GETBYTE ();
1686 switch (op[2] & 0x00)
1687 {
1688 case 0x00:
1689 goto op_semantics_4;
1690 break;
1691 }
1692 break;
1693 case 0x50:
1694 GETBYTE ();
1695 switch (op[2] & 0x00)
1696 {
1697 case 0x00:
1698 goto op_semantics_5;
1699 break;
1700 }
1701 break;
1702 case 0x51:
1703 GETBYTE ();
1704 switch (op[2] & 0x00)
1705 {
1706 case 0x00:
1707 goto op_semantics_5;
1708 break;
1709 }
1710 break;
1711 case 0x52:
1712 GETBYTE ();
1713 switch (op[2] & 0x00)
1714 {
1715 case 0x00:
1716 goto op_semantics_5;
1717 break;
1718 }
1719 break;
1720 case 0x53:
1721 GETBYTE ();
1722 switch (op[2] & 0x00)
1723 {
1724 case 0x00:
1725 goto op_semantics_5;
1726 break;
1727 }
1728 break;
1729 case 0x54:
1730 GETBYTE ();
1731 switch (op[2] & 0x00)
1732 {
1733 case 0x00:
1734 goto op_semantics_6;
1735 break;
1736 }
1737 break;
1738 case 0x55:
1739 GETBYTE ();
1740 switch (op[2] & 0x00)
1741 {
1742 case 0x00:
1743 goto op_semantics_6;
1744 break;
1745 }
1746 break;
1747 case 0x56:
1748 GETBYTE ();
1749 switch (op[2] & 0x00)
1750 {
1751 case 0x00:
1752 goto op_semantics_6;
1753 break;
1754 }
1755 break;
1756 case 0x57:
1757 GETBYTE ();
1758 switch (op[2] & 0x00)
1759 {
1760 case 0x00:
1761 goto op_semantics_6;
1762 break;
1763 }
1764 break;
1765 case 0x60:
1766 GETBYTE ();
1767 switch (op[2] & 0xff)
1768 {
1769 case 0x00:
1770 GETBYTE ();
1771 switch (op[3] & 0x00)
1772 {
1773 case 0x00:
1774 goto op_semantics_7;
1775 break;
1776 }
1777 break;
1778 case 0x04:
1779 GETBYTE ();
1780 switch (op[3] & 0x00)
1781 {
1782 case 0x00:
1783 goto op_semantics_8;
1784 break;
1785 }
1786 break;
1787 case 0x05:
1788 GETBYTE ();
1789 switch (op[3] & 0x00)
1790 {
1791 case 0x00:
1792 goto op_semantics_9;
1793 break;
1794 }
1795 break;
1796 case 0x06:
1797 GETBYTE ();
1798 switch (op[3] & 0x00)
1799 {
1800 case 0x00:
1801 goto op_semantics_10;
1802 break;
1803 }
1804 break;
1805 case 0x07:
1806 GETBYTE ();
1807 switch (op[3] & 0x00)
1808 {
1809 case 0x00:
1810 goto op_semantics_11;
1811 break;
1812 }
1813 break;
1814 case 0x08:
1815 GETBYTE ();
1816 switch (op[3] & 0x00)
1817 {
1818 case 0x00:
1819 goto op_semantics_12;
1820 break;
1821 }
1822 break;
1823 case 0x09:
1824 GETBYTE ();
1825 switch (op[3] & 0x00)
1826 {
1827 case 0x00:
1828 goto op_semantics_13;
1829 break;
1830 }
1831 break;
1832 case 0x0c:
1833 GETBYTE ();
1834 switch (op[3] & 0x00)
1835 {
1836 case 0x00:
1837 goto op_semantics_14;
1838 break;
1839 }
1840 break;
1841 case 0x0d:
1842 GETBYTE ();
1843 switch (op[3] & 0x00)
1844 {
1845 case 0x00:
1846 goto op_semantics_15;
1847 break;
1848 }
1849 break;
1850 case 0x10:
1851 GETBYTE ();
1852 switch (op[3] & 0x00)
1853 {
1854 case 0x00:
1855 goto op_semantics_16;
1856 break;
1857 }
1858 break;
1859 case 0x11:
1860 GETBYTE ();
1861 switch (op[3] & 0x00)
1862 {
1863 case 0x00:
1864 goto op_semantics_17;
1865 break;
1866 }
1867 break;
a117b0a5
YS		 1868 case 0x15:
1869 GETBYTE ();
1870 switch (op[3] & 0x00)
1871 {
1872 case 0x00:
1873 goto op_semantics_18;
1874 break;
1875 }
1876 break;
c7927a3c
NC		 1877 default: UNSUPPORTED(); break;
1878 }
1879 break;
1880 case 0x61:
1881 GETBYTE ();
1882 switch (op[2] & 0xff)
1883 {
1884 case 0x00:
1885 GETBYTE ();
1886 switch (op[3] & 0x00)
1887 {
1888 case 0x00:
1889 goto op_semantics_7;
1890 break;
1891 }
1892 break;
1893 case 0x04:
1894 GETBYTE ();
1895 switch (op[3] & 0x00)
1896 {
1897 case 0x00:
1898 goto op_semantics_8;
1899 break;
1900 }
1901 break;
1902 case 0x05:
1903 GETBYTE ();
1904 switch (op[3] & 0x00)
1905 {
1906 case 0x00:
1907 goto op_semantics_9;
1908 break;
1909 }
1910 break;
1911 case 0x06:
1912 GETBYTE ();
1913 switch (op[3] & 0x00)
1914 {
1915 case 0x00:
1916 goto op_semantics_10;
1917 break;
1918 }
1919 break;
1920 case 0x07:
1921 GETBYTE ();
1922 switch (op[3] & 0x00)
1923 {
1924 case 0x00:
1925 goto op_semantics_11;
1926 break;
1927 }
1928 break;
1929 case 0x08:
1930 GETBYTE ();
1931 switch (op[3] & 0x00)
1932 {
1933 case 0x00:
1934 goto op_semantics_12;
1935 break;
1936 }
1937 break;
1938 case 0x09:
1939 GETBYTE ();
1940 switch (op[3] & 0x00)
1941 {
1942 case 0x00:
1943 goto op_semantics_13;
1944 break;
1945 }
1946 break;
1947 case 0x0c:
1948 GETBYTE ();
1949 switch (op[3] & 0x00)
1950 {
1951 case 0x00:
1952 goto op_semantics_14;
1953 break;
1954 }
1955 break;
1956 case 0x0d:
1957 GETBYTE ();
1958 switch (op[3] & 0x00)
1959 {
1960 case 0x00:
1961 goto op_semantics_15;
1962 break;
1963 }
1964 break;
1965 case 0x10:
1966 GETBYTE ();
1967 switch (op[3] & 0x00)
1968 {
1969 case 0x00:
1970 goto op_semantics_16;
1971 break;
1972 }
1973 break;
1974 case 0x11:
1975 GETBYTE ();
1976 switch (op[3] & 0x00)
1977 {
1978 case 0x00:
1979 goto op_semantics_17;
1980 break;
1981 }
1982 break;
a117b0a5
YS		 1983 case 0x15:
1984 GETBYTE ();
1985 switch (op[3] & 0x00)
1986 {
1987 case 0x00:
1988 goto op_semantics_18;
1989 break;
1990 }
1991 break;
c7927a3c
NC		 1992 default: UNSUPPORTED(); break;
1993 }
1994 break;
1995 case 0x62:
1996 GETBYTE ();
1997 switch (op[2] & 0xff)
1998 {
1999 case 0x00:
2000 GETBYTE ();
2001 switch (op[3] & 0x00)
2002 {
2003 case 0x00:
2004 goto op_semantics_7;
2005 break;
2006 }
2007 break;
2008 case 0x04:
2009 GETBYTE ();
2010 switch (op[3] & 0x00)
2011 {
2012 case 0x00:
2013 goto op_semantics_8;
2014 break;
2015 }
2016 break;
2017 case 0x05:
2018 GETBYTE ();
2019 switch (op[3] & 0x00)
2020 {
2021 case 0x00:
2022 goto op_semantics_9;
2023 break;
2024 }
2025 break;
2026 case 0x06:
2027 GETBYTE ();
2028 switch (op[3] & 0x00)
2029 {
2030 case 0x00:
2031 goto op_semantics_10;
2032 break;
2033 }
2034 break;
2035 case 0x07:
2036 GETBYTE ();
2037 switch (op[3] & 0x00)
2038 {
2039 case 0x00:
2040 goto op_semantics_11;
2041 break;
2042 }
2043 break;
2044 case 0x08:
2045 GETBYTE ();
2046 switch (op[3] & 0x00)
2047 {
2048 case 0x00:
2049 goto op_semantics_12;
2050 break;
2051 }
2052 break;
2053 case 0x09:
2054 GETBYTE ();
2055 switch (op[3] & 0x00)
2056 {
2057 case 0x00:
2058 goto op_semantics_13;
2059 break;
2060 }
2061 break;
2062 case 0x0c:
2063 GETBYTE ();
2064 switch (op[3] & 0x00)
2065 {
2066 case 0x00:
2067 goto op_semantics_14;
2068 break;
2069 }
2070 break;
2071 case 0x0d:
2072 GETBYTE ();
2073 switch (op[3] & 0x00)
2074 {
2075 case 0x00:
2076 goto op_semantics_15;
2077 break;
2078 }
2079 break;
2080 case 0x10:
2081 GETBYTE ();
2082 switch (op[3] & 0x00)
2083 {
2084 case 0x00:
2085 goto op_semantics_16;
2086 break;
2087 }
2088 break;
2089 case 0x11:
2090 GETBYTE ();
2091 switch (op[3] & 0x00)
2092 {
2093 case 0x00:
2094 goto op_semantics_17;
2095 break;
2096 }
2097 break;
a117b0a5
YS		 2098 case 0x15:
2099 GETBYTE ();
2100 switch (op[3] & 0x00)
2101 {
2102 case 0x00:
2103 goto op_semantics_18;
2104 break;
2105 }
2106 break;
c7927a3c
NC		 2107 default: UNSUPPORTED(); break;
2108 }
2109 break;
2110 case 0x63:
2111 GETBYTE ();
2112 switch (op[2] & 0xff)
2113 {
2114 case 0x00:
2115 GETBYTE ();
2116 switch (op[3] & 0x00)
2117 {
2118 case 0x00:
2119 goto op_semantics_7;
2120 break;
2121 }
2122 break;
2123 case 0x04:
2124 GETBYTE ();
2125 switch (op[3] & 0x00)
2126 {
2127 case 0x00:
2128 goto op_semantics_8;
2129 break;
2130 }
2131 break;
2132 case 0x05:
2133 GETBYTE ();
2134 switch (op[3] & 0x00)
2135 {
2136 case 0x00:
2137 goto op_semantics_9;
2138 break;
2139 }
2140 break;
2141 case 0x06:
2142 GETBYTE ();
2143 switch (op[3] & 0x00)
2144 {
2145 case 0x00:
2146 goto op_semantics_10;
2147 break;
2148 }
2149 break;
2150 case 0x07:
2151 GETBYTE ();
2152 switch (op[3] & 0x00)
2153 {
2154 case 0x00:
2155 goto op_semantics_11;
2156 break;
2157 }
2158 break;
2159 case 0x08:
2160 GETBYTE ();
2161 switch (op[3] & 0x00)
2162 {
2163 case 0x00:
2164 goto op_semantics_12;
2165 break;
2166 }
2167 break;
2168 case 0x09:
2169 GETBYTE ();
2170 switch (op[3] & 0x00)
2171 {
2172 case 0x00:
2173 goto op_semantics_13;
2174 break;
2175 }
2176 break;
2177 case 0x0c:
2178 GETBYTE ();
2179 switch (op[3] & 0x00)
2180 {
2181 case 0x00:
2182 goto op_semantics_14;
2183 break;
2184 }
2185 break;
2186 case 0x0d:
2187 GETBYTE ();
2188 switch (op[3] & 0x00)
2189 {
2190 case 0x00:
2191 goto op_semantics_15;
2192 break;
2193 }
2194 break;
2195 case 0x10:
2196 GETBYTE ();
2197 switch (op[3] & 0x00)
2198 {
2199 case 0x00:
2200 goto op_semantics_16;
2201 break;
2202 }
2203 break;
2204 case 0x11:
2205 GETBYTE ();
2206 switch (op[3] & 0x00)
2207 {
2208 case 0x00:
2209 goto op_semantics_17;
2210 break;
2211 }
2212 break;
a117b0a5
YS		 2213 case 0x15:
2214 GETBYTE ();
2215 switch (op[3] & 0x00)
2216 {
2217 case 0x00:
2218 goto op_semantics_18;
2219 break;
2220 }
2221 break;
c7927a3c
NC		 2222 default: UNSUPPORTED(); break;
2223 }
2224 break;
2225 case 0x80:
2226 GETBYTE ();
2227 switch (op[2] & 0x00)
2228 {
2229 case 0x00:
2230 goto op_semantics_1;
2231 break;
2232 }
2233 break;
2234 case 0x81:
2235 GETBYTE ();
2236 switch (op[2] & 0x00)
2237 {
2238 case 0x00:
2239 goto op_semantics_1;
2240 break;
2241 }
2242 break;
2243 case 0x82:
2244 GETBYTE ();
2245 switch (op[2] & 0x00)
2246 {
2247 case 0x00:
2248 goto op_semantics_1;
2249 break;
2250 }
2251 break;
2252 case 0x83:
2253 GETBYTE ();
2254 switch (op[2] & 0x00)
2255 {
2256 case 0x00:
2257 goto op_semantics_1;
2258 break;
2259 }
2260 break;
2261 case 0x84:
2262 GETBYTE ();
2263 switch (op[2] & 0x00)
2264 {
2265 case 0x00:
2266 goto op_semantics_2;
2267 break;
2268 }
2269 break;
2270 case 0x85:
2271 GETBYTE ();
2272 switch (op[2] & 0x00)
2273 {
2274 case 0x00:
2275 goto op_semantics_2;
2276 break;
2277 }
2278 break;
2279 case 0x86:
2280 GETBYTE ();
2281 switch (op[2] & 0x00)
2282 {
2283 case 0x00:
2284 goto op_semantics_2;
2285 break;
2286 }
2287 break;
2288 case 0x87:
2289 GETBYTE ();
2290 switch (op[2] & 0x00)
2291 {
2292 case 0x00:
2293 goto op_semantics_2;
2294 break;
2295 }
2296 break;
2297 case 0x88:
2298 GETBYTE ();
2299 switch (op[2] & 0x00)
2300 {
2301 case 0x00:
2302 goto op_semantics_3;
2303 break;
2304 }
2305 break;
2306 case 0x89:
2307 GETBYTE ();
2308 switch (op[2] & 0x00)
2309 {
2310 case 0x00:
2311 goto op_semantics_3;
2312 break;
2313 }
2314 break;
2315 case 0x8a:
2316 GETBYTE ();
2317 switch (op[2] & 0x00)
2318 {
2319 case 0x00:
2320 goto op_semantics_3;
2321 break;
2322 }
2323 break;
2324 case 0x8b:
2325 GETBYTE ();
2326 switch (op[2] & 0x00)
2327 {
2328 case 0x00:
2329 goto op_semantics_3;
2330 break;
2331 }
2332 break;
2333 case 0x8c:
2334 GETBYTE ();
2335 switch (op[2] & 0x00)
2336 {
2337 case 0x00:
2338 goto op_semantics_4;
2339 break;
2340 }
2341 break;
2342 case 0x8d:
2343 GETBYTE ();
2344 switch (op[2] & 0x00)
2345 {
2346 case 0x00:
2347 goto op_semantics_4;
2348 break;
2349 }
2350 break;
2351 case 0x8e:
2352 GETBYTE ();
2353 switch (op[2] & 0x00)
2354 {
2355 case 0x00:
2356 goto op_semantics_4;
2357 break;
2358 }
2359 break;
2360 case 0x8f:
2361 GETBYTE ();
2362 switch (op[2] & 0x00)
2363 {
2364 case 0x00:
2365 goto op_semantics_4;
2366 break;
2367 }
2368 break;
2369 case 0x90:
2370 GETBYTE ();
2371 switch (op[2] & 0x00)
2372 {
2373 case 0x00:
2374 goto op_semantics_5;
2375 break;
2376 }
2377 break;
2378 case 0x91:
2379 GETBYTE ();
2380 switch (op[2] & 0x00)
2381 {
2382 case 0x00:
2383 goto op_semantics_5;
2384 break;
2385 }
2386 break;
2387 case 0x92:
2388 GETBYTE ();
2389 switch (op[2] & 0x00)
2390 {
2391 case 0x00:
2392 goto op_semantics_5;
2393 break;
2394 }
2395 break;
2396 case 0x93:
2397 GETBYTE ();
2398 switch (op[2] & 0x00)
2399 {
2400 case 0x00:
2401 goto op_semantics_5;
2402 break;
2403 }
2404 break;
2405 case 0x94:
2406 GETBYTE ();
2407 switch (op[2] & 0x00)
2408 {
2409 case 0x00:
2410 goto op_semantics_6;
2411 break;
2412 }
2413 break;
2414 case 0x95:
2415 GETBYTE ();
2416 switch (op[2] & 0x00)
2417 {
2418 case 0x00:
2419 goto op_semantics_6;
2420 break;
2421 }
2422 break;
2423 case 0x96:
2424 GETBYTE ();
2425 switch (op[2] & 0x00)
2426 {
2427 case 0x00:
2428 goto op_semantics_6;
2429 break;
2430 }
2431 break;
2432 case 0x97:
2433 GETBYTE ();
2434 switch (op[2] & 0x00)
2435 {
2436 case 0x00:
2437 goto op_semantics_6;
2438 break;
2439 }
2440 break;
2441 case 0xa0:
2442 GETBYTE ();
2443 switch (op[2] & 0xff)
2444 {
2445 case 0x00:
2446 GETBYTE ();
2447 switch (op[3] & 0x00)
2448 {
2449 case 0x00:
2450 goto op_semantics_7;
2451 break;
2452 }
2453 break;
2454 case 0x02:
2455 GETBYTE ();
2456 switch (op[3] & 0x00)
2457 {
2458 case 0x00:
a117b0a5 2459 op_semantics_19:
c7927a3c
NC		 2460 {
2461 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
b8985e5c 2462#line 494 "rx-decode.opc"
c7927a3c 2463 int ss AU = op[1] & 0x03;
b8985e5c 2464#line 494 "rx-decode.opc"
c7927a3c 2465 int rsrc AU = (op[3] >> 4) & 0x0f;
b8985e5c 2466#line 494 "rx-decode.opc"
c7927a3c
NC		 2467 int rdst AU = op[3] & 0x0f;
2468 if (trace)
2469 {
2470 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2471 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2472 op[0], op[1], op[2], op[3]);
2473 printf (" ss = 0x%x,", ss);
2474 printf (" rsrc = 0x%x,", rsrc);
2475 printf (" rdst = 0x%x\n", rdst);
2476 }
2477 SYNTAX("adc %1%S1, %0");
b8985e5c 2478#line 494 "rx-decode.opc"
3cf79a01 2479 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
43e65147 2480
c7927a3c
NC		 2481 /*----------------------------------------------------------------------*/
2482 /* ADD */
43e65147 2483
c7927a3c
NC		 2484 }
2485 break;
2486 }
2487 break;
2488 case 0x04:
2489 GETBYTE ();
2490 switch (op[3] & 0x00)
2491 {
2492 case 0x00:
2493 goto op_semantics_8;
2494 break;
2495 }
2496 break;
2497 case 0x05:
2498 GETBYTE ();
2499 switch (op[3] & 0x00)
2500 {
2501 case 0x00:
2502 goto op_semantics_9;
2503 break;
2504 }
2505 break;
2506 case 0x06:
2507 GETBYTE ();
2508 switch (op[3] & 0x00)
2509 {
2510 case 0x00:
2511 goto op_semantics_10;
2512 break;
2513 }
2514 break;
2515 case 0x07:
2516 GETBYTE ();
2517 switch (op[3] & 0x00)
2518 {
2519 case 0x00:
2520 goto op_semantics_11;
2521 break;
2522 }
2523 break;
2524 case 0x08:
2525 GETBYTE ();
2526 switch (op[3] & 0x00)
2527 {
2528 case 0x00:
2529 goto op_semantics_12;
2530 break;
2531 }
2532 break;
2533 case 0x09:
2534 GETBYTE ();
2535 switch (op[3] & 0x00)
2536 {
2537 case 0x00:
2538 goto op_semantics_13;
2539 break;
2540 }
2541 break;
2542 case 0x0c:
2543 GETBYTE ();
2544 switch (op[3] & 0x00)
2545 {
2546 case 0x00:
2547 goto op_semantics_14;
2548 break;
2549 }
2550 break;
2551 case 0x0d:
2552 GETBYTE ();
2553 switch (op[3] & 0x00)
2554 {
2555 case 0x00:
2556 goto op_semantics_15;
2557 break;
2558 }
2559 break;
2560 case 0x10:
2561 GETBYTE ();
2562 switch (op[3] & 0x00)
2563 {
2564 case 0x00:
2565 goto op_semantics_16;
2566 break;
2567 }
2568 break;
2569 case 0x11:
2570 GETBYTE ();
2571 switch (op[3] & 0x00)
2572 {
2573 case 0x00:
2574 goto op_semantics_17;
2575 break;
2576 }
2577 break;
a117b0a5
YS		 2578 case 0x15:
2579 GETBYTE ();
2580 switch (op[3] & 0x00)
2581 {
2582 case 0x00:
2583 goto op_semantics_18;
2584 break;
2585 }
2586 break;
c7927a3c
NC		 2587 default: UNSUPPORTED(); break;
2588 }
2589 break;
2590 case 0xa1:
2591 GETBYTE ();
2592 switch (op[2] & 0xff)
2593 {
2594 case 0x00:
2595 GETBYTE ();
2596 switch (op[3] & 0x00)
2597 {
2598 case 0x00:
2599 goto op_semantics_7;
2600 break;
2601 }
2602 break;
2603 case 0x02:
2604 GETBYTE ();
2605 switch (op[3] & 0x00)
2606 {
2607 case 0x00:
a117b0a5 2608 goto op_semantics_19;
c7927a3c
NC		 2609 break;
2610 }
2611 break;
2612 case 0x04:
2613 GETBYTE ();
2614 switch (op[3] & 0x00)
2615 {
2616 case 0x00:
2617 goto op_semantics_8;
2618 break;
2619 }
2620 break;
2621 case 0x05:
2622 GETBYTE ();
2623 switch (op[3] & 0x00)
2624 {
2625 case 0x00:
2626 goto op_semantics_9;
2627 break;
2628 }
2629 break;
2630 case 0x06:
2631 GETBYTE ();
2632 switch (op[3] & 0x00)
2633 {
2634 case 0x00:
2635 goto op_semantics_10;
2636 break;
2637 }
2638 break;
2639 case 0x07:
2640 GETBYTE ();
2641 switch (op[3] & 0x00)
2642 {
2643 case 0x00:
2644 goto op_semantics_11;
2645 break;
2646 }
2647 break;
2648 case 0x08:
2649 GETBYTE ();
2650 switch (op[3] & 0x00)
2651 {
2652 case 0x00:
2653 goto op_semantics_12;
2654 break;
2655 }
2656 break;
2657 case 0x09:
2658 GETBYTE ();
2659 switch (op[3] & 0x00)
2660 {
2661 case 0x00:
2662 goto op_semantics_13;
2663 break;
2664 }
2665 break;
2666 case 0x0c:
2667 GETBYTE ();
2668 switch (op[3] & 0x00)
2669 {
2670 case 0x00:
2671 goto op_semantics_14;
2672 break;
2673 }
2674 break;
2675 case 0x0d:
2676 GETBYTE ();
2677 switch (op[3] & 0x00)
2678 {
2679 case 0x00:
2680 goto op_semantics_15;
2681 break;
2682 }
2683 break;
2684 case 0x10:
2685 GETBYTE ();
2686 switch (op[3] & 0x00)
2687 {
2688 case 0x00:
2689 goto op_semantics_16;
2690 break;
2691 }
2692 break;
2693 case 0x11:
2694 GETBYTE ();
2695 switch (op[3] & 0x00)
2696 {
2697 case 0x00:
2698 goto op_semantics_17;
2699 break;
2700 }
2701 break;
a117b0a5
YS		 2702 case 0x15:
2703 GETBYTE ();
2704 switch (op[3] & 0x00)
2705 {
2706 case 0x00:
2707 goto op_semantics_18;
2708 break;
2709 }
2710 break;
c7927a3c
NC		 2711 default: UNSUPPORTED(); break;
2712 }
2713 break;
2714 case 0xa2:
2715 GETBYTE ();
2716 switch (op[2] & 0xff)
2717 {
2718 case 0x00:
2719 GETBYTE ();
2720 switch (op[3] & 0x00)
2721 {
2722 case 0x00:
2723 goto op_semantics_7;
2724 break;
2725 }
2726 break;
2727 case 0x02:
2728 GETBYTE ();
2729 switch (op[3] & 0x00)
2730 {
2731 case 0x00:
a117b0a5 2732 goto op_semantics_19;
c7927a3c
NC		 2733 break;
2734 }
2735 break;
2736 case 0x04:
2737 GETBYTE ();
2738 switch (op[3] & 0x00)
2739 {
2740 case 0x00:
2741 goto op_semantics_8;
2742 break;
2743 }
2744 break;
2745 case 0x05:
2746 GETBYTE ();
2747 switch (op[3] & 0x00)
2748 {
2749 case 0x00:
2750 goto op_semantics_9;
2751 break;
2752 }
2753 break;
2754 case 0x06:
2755 GETBYTE ();
2756 switch (op[3] & 0x00)
2757 {
2758 case 0x00:
2759 goto op_semantics_10;
2760 break;
2761 }
2762 break;
2763 case 0x07:
2764 GETBYTE ();
2765 switch (op[3] & 0x00)
2766 {
2767 case 0x00:
2768 goto op_semantics_11;
2769 break;
2770 }
2771 break;
2772 case 0x08:
2773 GETBYTE ();
2774 switch (op[3] & 0x00)
2775 {
2776 case 0x00:
2777 goto op_semantics_12;
2778 break;
2779 }
2780 break;
2781 case 0x09:
2782 GETBYTE ();
2783 switch (op[3] & 0x00)
2784 {
2785 case 0x00:
2786 goto op_semantics_13;
2787 break;
2788 }
2789 break;
2790 case 0x0c:
2791 GETBYTE ();
2792 switch (op[3] & 0x00)
2793 {
2794 case 0x00:
2795 goto op_semantics_14;
2796 break;
2797 }
2798 break;
2799 case 0x0d:
2800 GETBYTE ();
2801 switch (op[3] & 0x00)
2802 {
2803 case 0x00:
2804 goto op_semantics_15;
2805 break;
2806 }
2807 break;
2808 case 0x10:
2809 GETBYTE ();
2810 switch (op[3] & 0x00)
2811 {
2812 case 0x00:
2813 goto op_semantics_16;
2814 break;
2815 }
2816 break;
2817 case 0x11:
2818 GETBYTE ();
2819 switch (op[3] & 0x00)
2820 {
2821 case 0x00:
2822 goto op_semantics_17;
2823 break;
2824 }
2825 break;
a117b0a5
YS		 2826 case 0x15:
2827 GETBYTE ();
2828 switch (op[3] & 0x00)
2829 {
2830 case 0x00:
2831 goto op_semantics_18;
2832 break;
2833 }
2834 break;
c7927a3c
NC		 2835 default: UNSUPPORTED(); break;
2836 }
2837 break;
2838 case 0xa3:
2839 GETBYTE ();
2840 switch (op[2] & 0xff)
2841 {
2842 case 0x00:
2843 GETBYTE ();
2844 switch (op[3] & 0x00)
2845 {
2846 case 0x00:
2847 goto op_semantics_7;
2848 break;
2849 }
2850 break;
2851 case 0x02:
2852 GETBYTE ();
2853 switch (op[3] & 0x00)
2854 {
2855 case 0x00:
a117b0a5 2856 goto op_semantics_19;
c7927a3c
NC		 2857 break;
2858 }
2859 break;
2860 case 0x04:
2861 GETBYTE ();
2862 switch (op[3] & 0x00)
2863 {
2864 case 0x00:
2865 goto op_semantics_8;
2866 break;
2867 }
2868 break;
2869 case 0x05:
2870 GETBYTE ();
2871 switch (op[3] & 0x00)
2872 {
2873 case 0x00:
2874 goto op_semantics_9;
2875 break;
2876 }
2877 break;
2878 case 0x06:
2879 GETBYTE ();
2880 switch (op[3] & 0x00)
2881 {
2882 case 0x00:
2883 goto op_semantics_10;
2884 break;
2885 }
2886 break;
2887 case 0x07:
2888 GETBYTE ();
2889 switch (op[3] & 0x00)
2890 {
2891 case 0x00:
2892 goto op_semantics_11;
2893 break;
2894 }
2895 break;
2896 case 0x08:
2897 GETBYTE ();
2898 switch (op[3] & 0x00)
2899 {
2900 case 0x00:
2901 goto op_semantics_12;
2902 break;
2903 }
2904 break;
2905 case 0x09:
2906 GETBYTE ();
2907 switch (op[3] & 0x00)
2908 {
2909 case 0x00:
2910 goto op_semantics_13;
2911 break;
2912 }
2913 break;
2914 case 0x0c:
2915 GETBYTE ();
2916 switch (op[3] & 0x00)
2917 {
2918 case 0x00:
2919 goto op_semantics_14;
2920 break;
2921 }
2922 break;
2923 case 0x0d:
2924 GETBYTE ();
2925 switch (op[3] & 0x00)
2926 {
2927 case 0x00:
2928 goto op_semantics_15;
2929 break;
2930 }
2931 break;
2932 case 0x10:
2933 GETBYTE ();
2934 switch (op[3] & 0x00)
2935 {
2936 case 0x00:
2937 goto op_semantics_16;
2938 break;
2939 }
2940 break;
2941 case 0x11:
2942 GETBYTE ();
2943 switch (op[3] & 0x00)
2944 {
2945 case 0x00:
2946 goto op_semantics_17;
2947 break;
2948 }
2949 break;
a117b0a5
YS		 2950 case 0x15:
2951 GETBYTE ();
2952 switch (op[3] & 0x00)
2953 {
2954 case 0x00:
2955 goto op_semantics_18;
2956 break;
2957 }
2958 break;
c7927a3c
NC		 2959 default: UNSUPPORTED(); break;
2960 }
2961 break;
2962 case 0xc0:
2963 GETBYTE ();
2964 switch (op[2] & 0x00)
2965 {
2966 case 0x00:
2967 goto op_semantics_1;
2968 break;
2969 }
2970 break;
2971 case 0xc1:
2972 GETBYTE ();
2973 switch (op[2] & 0x00)
2974 {
2975 case 0x00:
2976 goto op_semantics_1;
2977 break;
2978 }
2979 break;
2980 case 0xc2:
2981 GETBYTE ();
2982 switch (op[2] & 0x00)
2983 {
2984 case 0x00:
2985 goto op_semantics_1;
2986 break;
2987 }
2988 break;
2989 case 0xc3:
2990 GETBYTE ();
2991 switch (op[2] & 0x00)
2992 {
2993 case 0x00:
2994 goto op_semantics_1;
2995 break;
2996 }
2997 break;
2998 case 0xc4:
2999 GETBYTE ();
3000 switch (op[2] & 0x00)
3001 {
3002 case 0x00:
3003 goto op_semantics_2;
3004 break;
3005 }
3006 break;
3007 case 0xc5:
3008 GETBYTE ();
3009 switch (op[2] & 0x00)
3010 {
3011 case 0x00:
3012 goto op_semantics_2;
3013 break;
3014 }
3015 break;
3016 case 0xc6:
3017 GETBYTE ();
3018 switch (op[2] & 0x00)
3019 {
3020 case 0x00:
3021 goto op_semantics_2;
3022 break;
3023 }
3024 break;
3025 case 0xc7:
3026 GETBYTE ();
3027 switch (op[2] & 0x00)
3028 {
3029 case 0x00:
3030 goto op_semantics_2;
3031 break;
3032 }
3033 break;
3034 case 0xc8:
3035 GETBYTE ();
3036 switch (op[2] & 0x00)
3037 {
3038 case 0x00:
3039 goto op_semantics_3;
3040 break;
3041 }
3042 break;
3043 case 0xc9:
3044 GETBYTE ();
3045 switch (op[2] & 0x00)
3046 {
3047 case 0x00:
3048 goto op_semantics_3;
3049 break;
3050 }
3051 break;
3052 case 0xca:
3053 GETBYTE ();
3054 switch (op[2] & 0x00)
3055 {
3056 case 0x00:
3057 goto op_semantics_3;
3058 break;
3059 }
3060 break;
3061 case 0xcb:
3062 GETBYTE ();
3063 switch (op[2] & 0x00)
3064 {
3065 case 0x00:
3066 goto op_semantics_3;
3067 break;
3068 }
3069 break;
3070 case 0xcc:
3071 GETBYTE ();
3072 switch (op[2] & 0x00)
3073 {
3074 case 0x00:
3075 goto op_semantics_4;
3076 break;
3077 }
3078 break;
3079 case 0xcd:
3080 GETBYTE ();
3081 switch (op[2] & 0x00)
3082 {
3083 case 0x00:
3084 goto op_semantics_4;
3085 break;
3086 }
3087 break;
3088 case 0xce:
3089 GETBYTE ();
3090 switch (op[2] & 0x00)
3091 {
3092 case 0x00:
3093 goto op_semantics_4;
3094 break;
3095 }
3096 break;
3097 case 0xcf:
3098 GETBYTE ();
3099 switch (op[2] & 0x00)
3100 {
3101 case 0x00:
3102 goto op_semantics_4;
3103 break;
3104 }
3105 break;
3106 case 0xd0:
3107 GETBYTE ();
3108 switch (op[2] & 0x00)
3109 {
3110 case 0x00:
3111 goto op_semantics_5;
3112 break;
3113 }
3114 break;
3115 case 0xd1:
3116 GETBYTE ();
3117 switch (op[2] & 0x00)
3118 {
3119 case 0x00:
3120 goto op_semantics_5;
3121 break;
3122 }
3123 break;
3124 case 0xd2:
3125 GETBYTE ();
3126 switch (op[2] & 0x00)
3127 {
3128 case 0x00:
3129 goto op_semantics_5;
3130 break;
3131 }
3132 break;
3133 case 0xd3:
3134 GETBYTE ();
3135 switch (op[2] & 0x00)
3136 {
3137 case 0x00:
3138 goto op_semantics_5;
3139 break;
3140 }
3141 break;
3142 case 0xd4:
3143 GETBYTE ();
3144 switch (op[2] & 0x00)
3145 {
3146 case 0x00:
3147 goto op_semantics_6;
3148 break;
3149 }
3150 break;
3151 case 0xd5:
3152 GETBYTE ();
3153 switch (op[2] & 0x00)
3154 {
3155 case 0x00:
3156 goto op_semantics_6;
3157 break;
3158 }
3159 break;
3160 case 0xd6:
3161 GETBYTE ();
3162 switch (op[2] & 0x00)
3163 {
3164 case 0x00:
3165 goto op_semantics_6;
3166 break;
3167 }
3168 break;
3169 case 0xd7:
3170 GETBYTE ();
3171 switch (op[2] & 0x00)
3172 {
3173 case 0x00:
3174 goto op_semantics_6;
3175 break;
3176 }
3177 break;
3178 case 0xe0:
3179 GETBYTE ();
3180 switch (op[2] & 0xff)
3181 {
3182 case 0x00:
3183 GETBYTE ();
3184 switch (op[3] & 0x00)
3185 {
3186 case 0x00:
3187 goto op_semantics_7;
3188 break;
3189 }
3190 break;
3191 case 0x04:
3192 GETBYTE ();
3193 switch (op[3] & 0x00)
3194 {
3195 case 0x00:
3196 goto op_semantics_8;
3197 break;
3198 }
3199 break;
3200 case 0x05:
3201 GETBYTE ();
3202 switch (op[3] & 0x00)
3203 {
3204 case 0x00:
3205 goto op_semantics_9;
3206 break;
3207 }
3208 break;
3209 case 0x06:
3210 GETBYTE ();
3211 switch (op[3] & 0x00)
3212 {
3213 case 0x00:
3214 goto op_semantics_10;
3215 break;
3216 }
3217 break;
3218 case 0x07:
3219 GETBYTE ();
3220 switch (op[3] & 0x00)
3221 {
3222 case 0x00:
3223 goto op_semantics_11;
3224 break;
3225 }
3226 break;
3227 case 0x08:
3228 GETBYTE ();
3229 switch (op[3] & 0x00)
3230 {
3231 case 0x00:
3232 goto op_semantics_12;
3233 break;
3234 }
3235 break;
3236 case 0x09:
3237 GETBYTE ();
3238 switch (op[3] & 0x00)
3239 {
3240 case 0x00:
3241 goto op_semantics_13;
3242 break;
3243 }
3244 break;
3245 case 0x0c:
3246 GETBYTE ();
3247 switch (op[3] & 0x00)
3248 {
3249 case 0x00:
3250 goto op_semantics_14;
3251 break;
3252 }
3253 break;
3254 case 0x0d:
3255 GETBYTE ();
3256 switch (op[3] & 0x00)
3257 {
3258 case 0x00:
3259 goto op_semantics_15;
3260 break;
3261 }
3262 break;
3263 case 0x10:
3264 GETBYTE ();
3265 switch (op[3] & 0x00)
3266 {
3267 case 0x00:
3268 goto op_semantics_16;
3269 break;
3270 }
3271 break;
3272 case 0x11:
3273 GETBYTE ();
3274 switch (op[3] & 0x00)
3275 {
3276 case 0x00:
3277 goto op_semantics_17;
3278 break;
3279 }
3280 break;
a117b0a5
YS		 3281 case 0x15:
3282 GETBYTE ();
3283 switch (op[3] & 0x00)
3284 {
3285 case 0x00:
3286 goto op_semantics_18;
3287 break;
3288 }
3289 break;
c7927a3c
NC		 3290 default: UNSUPPORTED(); break;
3291 }
3292 break;
3293 case 0xe1:
3294 GETBYTE ();
3295 switch (op[2] & 0xff)
3296 {
3297 case 0x00:
3298 GETBYTE ();
3299 switch (op[3] & 0x00)
3300 {
3301 case 0x00:
3302 goto op_semantics_7;
3303 break;
3304 }
3305 break;
3306 case 0x04:
3307 GETBYTE ();
3308 switch (op[3] & 0x00)
3309 {
3310 case 0x00:
3311 goto op_semantics_8;
3312 break;
3313 }
3314 break;
3315 case 0x05:
3316 GETBYTE ();
3317 switch (op[3] & 0x00)
3318 {
3319 case 0x00:
3320 goto op_semantics_9;
3321 break;
3322 }
3323 break;
3324 case 0x06:
3325 GETBYTE ();
3326 switch (op[3] & 0x00)
3327 {
3328 case 0x00:
3329 goto op_semantics_10;
3330 break;
3331 }
3332 break;
3333 case 0x07:
3334 GETBYTE ();
3335 switch (op[3] & 0x00)
3336 {
3337 case 0x00:
3338 goto op_semantics_11;
3339 break;
3340 }
3341 break;
3342 case 0x08:
3343 GETBYTE ();
3344 switch (op[3] & 0x00)
3345 {
3346 case 0x00:
3347 goto op_semantics_12;
3348 break;
3349 }
3350 break;
3351 case 0x09:
3352 GETBYTE ();
3353 switch (op[3] & 0x00)
3354 {
3355 case 0x00:
3356 goto op_semantics_13;
3357 break;
3358 }
3359 break;
3360 case 0x0c:
3361 GETBYTE ();
3362 switch (op[3] & 0x00)
3363 {
3364 case 0x00:
3365 goto op_semantics_14;
3366 break;
3367 }
3368 break;
3369 case 0x0d:
3370 GETBYTE ();
3371 switch (op[3] & 0x00)
3372 {
3373 case 0x00:
3374 goto op_semantics_15;
3375 break;
3376 }
3377 break;
3378 case 0x10:
3379 GETBYTE ();
3380 switch (op[3] & 0x00)
3381 {
3382 case 0x00:
3383 goto op_semantics_16;
3384 break;
3385 }
3386 break;
3387 case 0x11:
3388 GETBYTE ();
3389 switch (op[3] & 0x00)
3390 {
3391 case 0x00:
3392 goto op_semantics_17;
3393 break;
3394 }
3395 break;
a117b0a5
YS		 3396 case 0x15:
3397 GETBYTE ();
3398 switch (op[3] & 0x00)
3399 {
3400 case 0x00:
3401 goto op_semantics_18;
3402 break;
3403 }
3404 break;
c7927a3c
NC		 3405 default: UNSUPPORTED(); break;
3406 }
3407 break;
3408 case 0xe2:
3409 GETBYTE ();
3410 switch (op[2] & 0xff)
3411 {
3412 case 0x00:
3413 GETBYTE ();
3414 switch (op[3] & 0x00)
3415 {
3416 case 0x00:
3417 goto op_semantics_7;
3418 break;
3419 }
3420 break;
3421 case 0x04:
3422 GETBYTE ();
3423 switch (op[3] & 0x00)
3424 {
3425 case 0x00:
3426 goto op_semantics_8;
3427 break;
3428 }
3429 break;
3430 case 0x05:
3431 GETBYTE ();
3432 switch (op[3] & 0x00)
3433 {
3434 case 0x00:
3435 goto op_semantics_9;
3436 break;
3437 }
3438 break;
3439 case 0x06:
3440 GETBYTE ();
3441 switch (op[3] & 0x00)
3442 {
3443 case 0x00:
3444 goto op_semantics_10;
3445 break;
3446 }
3447 break;
3448 case 0x07:
3449 GETBYTE ();
3450 switch (op[3] & 0x00)
3451 {
3452 case 0x00:
3453 goto op_semantics_11;
3454 break;
3455 }
3456 break;
3457 case 0x08:
3458 GETBYTE ();
3459 switch (op[3] & 0x00)
3460 {
3461 case 0x00:
3462 goto op_semantics_12;
3463 break;
3464 }
3465 break;
3466 case 0x09:
3467 GETBYTE ();
3468 switch (op[3] & 0x00)
3469 {
3470 case 0x00:
3471 goto op_semantics_13;
3472 break;
3473 }
3474 break;
3475 case 0x0c:
3476 GETBYTE ();
3477 switch (op[3] & 0x00)
3478 {
3479 case 0x00:
3480 goto op_semantics_14;
3481 break;
3482 }
3483 break;
3484 case 0x0d:
3485 GETBYTE ();
3486 switch (op[3] & 0x00)
3487 {
3488 case 0x00:
3489 goto op_semantics_15;
3490 break;
3491 }
3492 break;
3493 case 0x10:
3494 GETBYTE ();
3495 switch (op[3] & 0x00)
3496 {
3497 case 0x00:
3498 goto op_semantics_16;
3499 break;
3500 }
3501 break;
3502 case 0x11:
3503 GETBYTE ();
3504 switch (op[3] & 0x00)
3505 {
3506 case 0x00:
3507 goto op_semantics_17;
3508 break;
3509 }
3510 break;
a117b0a5
YS		 3511 case 0x15:
3512 GETBYTE ();
3513 switch (op[3] & 0x00)
3514 {
3515 case 0x00:
3516 goto op_semantics_18;
3517 break;
3518 }
3519 break;
c7927a3c
NC		 3520 default: UNSUPPORTED(); break;
3521 }
3522 break;
3523 case 0xe3:
3524 GETBYTE ();
3525 switch (op[2] & 0xff)
3526 {
3527 case 0x00:
3528 GETBYTE ();
3529 switch (op[3] & 0x00)
3530 {
3531 case 0x00:
3532 goto op_semantics_7;
3533 break;
3534 }
3535 break;
3536 case 0x04:
3537 GETBYTE ();
3538 switch (op[3] & 0x00)
3539 {
3540 case 0x00:
3541 goto op_semantics_8;
3542 break;
3543 }
3544 break;
3545 case 0x05:
3546 GETBYTE ();
3547 switch (op[3] & 0x00)
3548 {
3549 case 0x00:
3550 goto op_semantics_9;
3551 break;
3552 }
3553 break;
3554 case 0x06:
3555 GETBYTE ();
3556 switch (op[3] & 0x00)
3557 {
3558 case 0x00:
3559 goto op_semantics_10;
3560 break;
3561 }
3562 break;
3563 case 0x07:
3564 GETBYTE ();
3565 switch (op[3] & 0x00)
3566 {
3567 case 0x00:
3568 goto op_semantics_11;
3569 break;
3570 }
3571 break;
3572 case 0x08:
3573 GETBYTE ();
3574 switch (op[3] & 0x00)
3575 {
3576 case 0x00:
3577 goto op_semantics_12;
3578 break;
3579 }
3580 break;
3581 case 0x09:
3582 GETBYTE ();
3583 switch (op[3] & 0x00)
3584 {
3585 case 0x00:
3586 goto op_semantics_13;
3587 break;
3588 }
3589 break;
3590 case 0x0c:
3591 GETBYTE ();
3592 switch (op[3] & 0x00)
3593 {
3594 case 0x00:
3595 goto op_semantics_14;
3596 break;
3597 }
3598 break;
3599 case 0x0d:
3600 GETBYTE ();
3601 switch (op[3] & 0x00)
3602 {
3603 case 0x00:
3604 goto op_semantics_15;
3605 break;
3606 }
3607 break;
3608 case 0x10:
3609 GETBYTE ();
3610 switch (op[3] & 0x00)
3611 {
3612 case 0x00:
3613 goto op_semantics_16;
3614 break;
3615 }
3616 break;
3617 case 0x11:
3618 GETBYTE ();
3619 switch (op[3] & 0x00)
3620 {
3621 case 0x00:
3622 goto op_semantics_17;
3623 break;
3624 }
3625 break;
a117b0a5
YS		 3626 case 0x15:
3627 GETBYTE ();
3628 switch (op[3] & 0x00)
3629 {
3630 case 0x00:
3631 goto op_semantics_18;
3632 break;
3633 }
3634 break;
c7927a3c
NC		 3635 default: UNSUPPORTED(); break;
3636 }
3637 break;
3638 default: UNSUPPORTED(); break;
3639 }
3640 break;
3641 case 0x08:
3642 case 0x09:
3643 case 0x0a:
3644 case 0x0b:
3645 case 0x0c:
3646 case 0x0d:
3647 case 0x0e:
3648 case 0x0f:
3649 {
3650 /** 0000 1dsp bra.s %a0 */
a117b0a5 3651#line 775 "rx-decode.opc"
c7927a3c
NC		 3652 int dsp AU = op[0] & 0x07;
3653 if (trace)
3654 {
3655 printf ("\033[33m%s\033[0m %02x\n",
3656 "/** 0000 1dsp bra.s %a0 */",
3657 op[0]);
3658 printf (" dsp = 0x%x\n", dsp);
3659 }
3660 SYNTAX("bra.s %a0");
a117b0a5 3661#line 775 "rx-decode.opc"
f9c7014e 3662 ID(branch); DC(pc + dsp3map[dsp]);
43e65147 3663
c7927a3c
NC		 3664 }
3665 break;
3666 case 0x10:
3667 case 0x11:
3668 case 0x12:
3669 case 0x13:
3670 case 0x14:
3671 case 0x15:
3672 case 0x16:
3673 case 0x17:
3674 case 0x18:
3675 case 0x19:
3676 case 0x1a:
3677 case 0x1b:
3678 case 0x1c:
3679 case 0x1d:
3680 case 0x1e:
3681 case 0x1f:
3682 {
3683 /** 0001 n dsp b%1.s %a0 */
a117b0a5 3684#line 765 "rx-decode.opc"
c7927a3c 3685 int n AU = (op[0] >> 3) & 0x01;
a117b0a5 3686#line 765 "rx-decode.opc"
c7927a3c
NC		 3687 int dsp AU = op[0] & 0x07;
3688 if (trace)
3689 {
3690 printf ("\033[33m%s\033[0m %02x\n",
3691 "/** 0001 n dsp b%1.s %a0 */",
3692 op[0]);
3693 printf (" n = 0x%x,", n);
3694 printf (" dsp = 0x%x\n", dsp);
3695 }
3696 SYNTAX("b%1.s %a0");
a117b0a5 3697#line 765 "rx-decode.opc"
c7927a3c 3698 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
43e65147 3699
c7927a3c
NC		 3700 }
3701 break;
3702 case 0x20:
3703 case 0x21:
3704 case 0x22:
3705 case 0x23:
3706 case 0x24:
3707 case 0x25:
3708 case 0x26:
3709 case 0x27:
3710 case 0x28:
3711 case 0x29:
3712 case 0x2a:
3713 case 0x2b:
3714 case 0x2c:
3715 case 0x2d:
3716 case 0x2f:
3717 {
3718 /** 0010 cond b%1.b %a0 */
a117b0a5 3719#line 768 "rx-decode.opc"
c7927a3c
NC		 3720 int cond AU = op[0] & 0x0f;
3721 if (trace)
3722 {
3723 printf ("\033[33m%s\033[0m %02x\n",
3724 "/** 0010 cond b%1.b %a0 */",
3725 op[0]);
3726 printf (" cond = 0x%x\n", cond);
3727 }
3728 SYNTAX("b%1.b %a0");
a117b0a5 3729#line 768 "rx-decode.opc"
c7927a3c 3730 ID(branch); Scc(cond); DC(pc + IMMex (1));
43e65147 3731
c7927a3c
NC		 3732 }
3733 break;
3734 case 0x2e:
3735 {
3736 /** 0010 1110 bra.b %a0 */
3737 if (trace)
3738 {
3739 printf ("\033[33m%s\033[0m %02x\n",
3740 "/** 0010 1110 bra.b %a0 */",
3741 op[0]);
3742 }
3743 SYNTAX("bra.b %a0");
a117b0a5 3744#line 778 "rx-decode.opc"
f9c7014e 3745 ID(branch); DC(pc + IMMex(1));
43e65147 3746
c7927a3c
NC		 3747 }
3748 break;
3749 case 0x38:
3750 {
3751 /** 0011 1000 bra.w %a0 */
3752 if (trace)
3753 {
3754 printf ("\033[33m%s\033[0m %02x\n",
3755 "/** 0011 1000 bra.w %a0 */",
3756 op[0]);
3757 }
3758 SYNTAX("bra.w %a0");
a117b0a5 3759#line 781 "rx-decode.opc"
f9c7014e 3760 ID(branch); DC(pc + IMMex(2));
43e65147 3761
c7927a3c
NC		 3762 }
3763 break;
3764 case 0x39:
3765 {
3766 /** 0011 1001 bsr.w %a0 */
3767 if (trace)
3768 {
3769 printf ("\033[33m%s\033[0m %02x\n",
3770 "/** 0011 1001 bsr.w %a0 */",
3771 op[0]);
3772 }
3773 SYNTAX("bsr.w %a0");
a117b0a5 3774#line 797 "rx-decode.opc"
c7927a3c 3775 ID(jsr); DC(pc + IMMex(2));
43e65147 3776
c7927a3c
NC		 3777 }
3778 break;
3779 case 0x3a:
3780 case 0x3b:
3781 {
3782 /** 0011 101c b%1.w %a0 */
a117b0a5 3783#line 771 "rx-decode.opc"
c7927a3c
NC		 3784 int c AU = op[0] & 0x01;
3785 if (trace)
3786 {
3787 printf ("\033[33m%s\033[0m %02x\n",
3788 "/** 0011 101c b%1.w %a0 */",
3789 op[0]);
3790 printf (" c = 0x%x\n", c);
3791 }
3792 SYNTAX("b%1.w %a0");
a117b0a5 3793#line 771 "rx-decode.opc"
c7927a3c 3794 ID(branch); Scc(c); DC(pc + IMMex (2));
43e65147
L		 3795
3796
c7927a3c
NC		 3797 }
3798 break;
3799 case 0x3c:
3800 GETBYTE ();
3801 switch (op[1] & 0x00)
3802 {
3803 case 0x00:
a117b0a5 3804 op_semantics_20:
c7927a3c
NC		 3805 {
3806 /** 0011 11sz d dst sppp mov%s #%1, %0 */
b8985e5c 3807#line 307 "rx-decode.opc"
c7927a3c 3808 int sz AU = op[0] & 0x03;
b8985e5c 3809#line 307 "rx-decode.opc"
c7927a3c 3810 int d AU = (op[1] >> 7) & 0x01;
b8985e5c 3811#line 307 "rx-decode.opc"
c7927a3c 3812 int dst AU = (op[1] >> 4) & 0x07;
b8985e5c 3813#line 307 "rx-decode.opc"
c7927a3c
NC		 3814 int sppp AU = op[1] & 0x0f;
3815 if (trace)
3816 {
3817 printf ("\033[33m%s\033[0m %02x %02x\n",
3818 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3819 op[0], op[1]);
3820 printf (" sz = 0x%x,", sz);
3821 printf (" d = 0x%x,", d);
3822 printf (" dst = 0x%x,", dst);
3823 printf (" sppp = 0x%x\n", sppp);
3824 }
3825 SYNTAX("mov%s #%1, %0");
b8985e5c 3826#line 307 "rx-decode.opc"
3cf79a01 3827 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
43e65147 3828
c7927a3c
NC		 3829 }
3830 break;
3831 }
3832 break;
3833 case 0x3d:
3834 GETBYTE ();
3835 switch (op[1] & 0x00)
3836 {
3837 case 0x00:
a117b0a5 3838 goto op_semantics_20;
c7927a3c
NC		 3839 break;
3840 }
3841 break;
3842 case 0x3e:
3843 GETBYTE ();
3844 switch (op[1] & 0x00)
3845 {
3846 case 0x00:
a117b0a5 3847 goto op_semantics_20;
c7927a3c
NC		 3848 break;
3849 }
3850 break;
3851 case 0x3f:
3852 GETBYTE ();
3853 switch (op[1] & 0x00)
3854 {
3855 case 0x00:
3856 {
3857 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
b8985e5c 3858#line 404 "rx-decode.opc"
c7927a3c 3859 int rega AU = (op[1] >> 4) & 0x0f;
b8985e5c 3860#line 404 "rx-decode.opc"
c7927a3c
NC		 3861 int regb AU = op[1] & 0x0f;
3862 if (trace)
3863 {
3864 printf ("\033[33m%s\033[0m %02x %02x\n",
3865 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3866 op[0], op[1]);
3867 printf (" rega = 0x%x,", rega);
3868 printf (" regb = 0x%x\n", regb);
3869 }
3870 SYNTAX("rtsd #%1, %2-%0");
b8985e5c 3871#line 404 "rx-decode.opc"
c7927a3c 3872 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
43e65147 3873
c7927a3c
NC		 3874 /*----------------------------------------------------------------------*/
3875 /* AND */
43e65147 3876
c7927a3c
NC		 3877 }
3878 break;
3879 }
3880 break;
3881 case 0x40:
3882 GETBYTE ();
3883 switch (op[1] & 0x00)
3884 {
3885 case 0x00:
a117b0a5 3886 op_semantics_21:
c7927a3c
NC		 3887 {
3888 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
b8985e5c 3889#line 539 "rx-decode.opc"
c7927a3c 3890 int ss AU = op[0] & 0x03;
b8985e5c 3891#line 539 "rx-decode.opc"
c7927a3c 3892 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 3893#line 539 "rx-decode.opc"
c7927a3c
NC		 3894 int rdst AU = op[1] & 0x0f;
3895 if (trace)
3896 {
3897 printf ("\033[33m%s\033[0m %02x %02x\n",
3898 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3899 op[0], op[1]);
3900 printf (" ss = 0x%x,", ss);
3901 printf (" rsrc = 0x%x,", rsrc);
3902 printf (" rdst = 0x%x\n", rdst);
3903 }
3904 SYNTAX("sub %2%S2, %1");
b8985e5c 3905#line 539 "rx-decode.opc"
3cf79a01 3906 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
43e65147 3907
c7927a3c
NC		 3908 }
3909 break;
3910 }
3911 break;
3912 case 0x41:
3913 GETBYTE ();
3914 switch (op[1] & 0x00)
3915 {
3916 case 0x00:
a117b0a5 3917 goto op_semantics_21;
c7927a3c
NC		 3918 break;
3919 }
3920 break;
3921 case 0x42:
3922 GETBYTE ();
3923 switch (op[1] & 0x00)
3924 {
3925 case 0x00:
a117b0a5 3926 goto op_semantics_21;
c7927a3c
NC		 3927 break;
3928 }
3929 break;
3930 case 0x43:
3931 GETBYTE ();
3932 switch (op[1] & 0x00)
3933 {
3934 case 0x00:
a117b0a5 3935 goto op_semantics_21;
c7927a3c
NC		 3936 break;
3937 }
3938 break;
3939 case 0x44:
3940 GETBYTE ();
3941 switch (op[1] & 0x00)
3942 {
3943 case 0x00:
a117b0a5 3944 op_semantics_22:
c7927a3c
NC		 3945 {
3946 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
b8985e5c 3947#line 527 "rx-decode.opc"
c7927a3c 3948 int ss AU = op[0] & 0x03;
b8985e5c 3949#line 527 "rx-decode.opc"
c7927a3c 3950 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 3951#line 527 "rx-decode.opc"
c7927a3c
NC		 3952 int rdst AU = op[1] & 0x0f;
3953 if (trace)
3954 {
3955 printf ("\033[33m%s\033[0m %02x %02x\n",
3956 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3957 op[0], op[1]);
3958 printf (" ss = 0x%x,", ss);
3959 printf (" rsrc = 0x%x,", rsrc);
3960 printf (" rdst = 0x%x\n", rdst);
3961 }
3962 SYNTAX("cmp %2%S2, %1");
b8985e5c 3963#line 527 "rx-decode.opc"
3cf79a01 3964 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
43e65147 3965
c7927a3c
NC		 3966 }
3967 break;
3968 }
3969 break;
3970 case 0x45:
3971 GETBYTE ();
3972 switch (op[1] & 0x00)
3973 {
3974 case 0x00:
a117b0a5 3975 goto op_semantics_22;
c7927a3c
NC		 3976 break;
3977 }
3978 break;
3979 case 0x46:
3980 GETBYTE ();
3981 switch (op[1] & 0x00)
3982 {
3983 case 0x00:
a117b0a5 3984 goto op_semantics_22;
c7927a3c
NC		 3985 break;
3986 }
3987 break;
3988 case 0x47:
3989 GETBYTE ();
3990 switch (op[1] & 0x00)
3991 {
3992 case 0x00:
a117b0a5 3993 goto op_semantics_22;
c7927a3c
NC		 3994 break;
3995 }
3996 break;
3997 case 0x48:
3998 GETBYTE ();
3999 switch (op[1] & 0x00)
4000 {
4001 case 0x00:
a117b0a5 4002 op_semantics_23:
c7927a3c
NC		 4003 {
4004 /** 0100 10ss rsrc rdst add %1%S1, %0 */
b8985e5c 4005#line 503 "rx-decode.opc"
c7927a3c 4006 int ss AU = op[0] & 0x03;
b8985e5c 4007#line 503 "rx-decode.opc"
c7927a3c 4008 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 4009#line 503 "rx-decode.opc"
c7927a3c
NC		 4010 int rdst AU = op[1] & 0x0f;
4011 if (trace)
4012 {
4013 printf ("\033[33m%s\033[0m %02x %02x\n",
4014 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4015 op[0], op[1]);
4016 printf (" ss = 0x%x,", ss);
4017 printf (" rsrc = 0x%x,", rsrc);
4018 printf (" rdst = 0x%x\n", rdst);
4019 }
4020 SYNTAX("add %1%S1, %0");
b8985e5c 4021#line 503 "rx-decode.opc"
3cf79a01 4022 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
43e65147 4023
c7927a3c
NC		 4024 }
4025 break;
4026 }
4027 break;
4028 case 0x49:
4029 GETBYTE ();
4030 switch (op[1] & 0x00)
4031 {
4032 case 0x00:
a117b0a5 4033 goto op_semantics_23;
c7927a3c
NC		 4034 break;
4035 }
4036 break;
4037 case 0x4a:
4038 GETBYTE ();
4039 switch (op[1] & 0x00)
4040 {
4041 case 0x00:
a117b0a5 4042 goto op_semantics_23;
c7927a3c
NC		 4043 break;
4044 }
4045 break;
4046 case 0x4b:
4047 GETBYTE ();
4048 switch (op[1] & 0x00)
4049 {
4050 case 0x00:
a117b0a5 4051 goto op_semantics_23;
c7927a3c
NC		 4052 break;
4053 }
4054 break;
4055 case 0x4c:
4056 GETBYTE ();
4057 switch (op[1] & 0x00)
4058 {
4059 case 0x00:
a117b0a5 4060 op_semantics_24:
c7927a3c
NC		 4061 {
4062 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
a117b0a5 4063#line 646 "rx-decode.opc"
c7927a3c 4064 int ss AU = op[0] & 0x03;
a117b0a5 4065#line 646 "rx-decode.opc"
c7927a3c 4066 int rsrc AU = (op[1] >> 4) & 0x0f;
a117b0a5 4067#line 646 "rx-decode.opc"
c7927a3c
NC		 4068 int rdst AU = op[1] & 0x0f;
4069 if (trace)
4070 {
4071 printf ("\033[33m%s\033[0m %02x %02x\n",
4072 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4073 op[0], op[1]);
4074 printf (" ss = 0x%x,", ss);
4075 printf (" rsrc = 0x%x,", rsrc);
4076 printf (" rdst = 0x%x\n", rdst);
4077 }
4078 SYNTAX("mul %1%S1, %0");
a117b0a5 4079#line 646 "rx-decode.opc"
3cf79a01 4080 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
43e65147 4081
c7927a3c
NC		 4082 }
4083 break;
4084 }
4085 break;
4086 case 0x4d:
4087 GETBYTE ();
4088 switch (op[1] & 0x00)
4089 {
4090 case 0x00:
a117b0a5 4091 goto op_semantics_24;
c7927a3c
NC		 4092 break;
4093 }
4094 break;
4095 case 0x4e:
4096 GETBYTE ();
4097 switch (op[1] & 0x00)
4098 {
4099 case 0x00:
a117b0a5 4100 goto op_semantics_24;
c7927a3c
NC		 4101 break;
4102 }
4103 break;
4104 case 0x4f:
4105 GETBYTE ();
4106 switch (op[1] & 0x00)
4107 {
4108 case 0x00:
a117b0a5 4109 goto op_semantics_24;
c7927a3c
NC		 4110 break;
4111 }
4112 break;
4113 case 0x50:
4114 GETBYTE ();
4115 switch (op[1] & 0x00)
4116 {
4117 case 0x00:
a117b0a5 4118 op_semantics_25:
c7927a3c
NC		 4119 {
4120 /** 0101 00ss rsrc rdst and %1%S1, %0 */
b8985e5c 4121#line 416 "rx-decode.opc"
c7927a3c 4122 int ss AU = op[0] & 0x03;
b8985e5c 4123#line 416 "rx-decode.opc"
c7927a3c 4124 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 4125#line 416 "rx-decode.opc"
c7927a3c
NC		 4126 int rdst AU = op[1] & 0x0f;
4127 if (trace)
4128 {
4129 printf ("\033[33m%s\033[0m %02x %02x\n",
4130 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4131 op[0], op[1]);
4132 printf (" ss = 0x%x,", ss);
4133 printf (" rsrc = 0x%x,", rsrc);
4134 printf (" rdst = 0x%x\n", rdst);
4135 }
4136 SYNTAX("and %1%S1, %0");
b8985e5c 4137#line 416 "rx-decode.opc"
3cf79a01 4138 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 4139
c7927a3c
NC		 4140 }
4141 break;
4142 }
4143 break;
4144 case 0x51:
4145 GETBYTE ();
4146 switch (op[1] & 0x00)
4147 {
4148 case 0x00:
a117b0a5 4149 goto op_semantics_25;
c7927a3c
NC		 4150 break;
4151 }
4152 break;
4153 case 0x52:
4154 GETBYTE ();
4155 switch (op[1] & 0x00)
4156 {
4157 case 0x00:
a117b0a5 4158 goto op_semantics_25;
c7927a3c
NC		 4159 break;
4160 }
4161 break;
4162 case 0x53:
4163 GETBYTE ();
4164 switch (op[1] & 0x00)
4165 {
4166 case 0x00:
a117b0a5 4167 goto op_semantics_25;
c7927a3c
NC		 4168 break;
4169 }
4170 break;
4171 case 0x54:
4172 GETBYTE ();
4173 switch (op[1] & 0x00)
4174 {
4175 case 0x00:
a117b0a5 4176 op_semantics_26:
c7927a3c
NC		 4177 {
4178 /** 0101 01ss rsrc rdst or %1%S1, %0 */
b8985e5c 4179#line 434 "rx-decode.opc"
c7927a3c 4180 int ss AU = op[0] & 0x03;
b8985e5c 4181#line 434 "rx-decode.opc"
c7927a3c 4182 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 4183#line 434 "rx-decode.opc"
c7927a3c
NC		 4184 int rdst AU = op[1] & 0x0f;
4185 if (trace)
4186 {
4187 printf ("\033[33m%s\033[0m %02x %02x\n",
4188 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4189 op[0], op[1]);
4190 printf (" ss = 0x%x,", ss);
4191 printf (" rsrc = 0x%x,", rsrc);
4192 printf (" rdst = 0x%x\n", rdst);
4193 }
4194 SYNTAX("or %1%S1, %0");
b8985e5c 4195#line 434 "rx-decode.opc"
3cf79a01 4196 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 4197
c7927a3c
NC		 4198 }
4199 break;
4200 }
4201 break;
4202 case 0x55:
4203 GETBYTE ();
4204 switch (op[1] & 0x00)
4205 {
4206 case 0x00:
a117b0a5 4207 goto op_semantics_26;
c7927a3c
NC		 4208 break;
4209 }
4210 break;
4211 case 0x56:
4212 GETBYTE ();
4213 switch (op[1] & 0x00)
4214 {
4215 case 0x00:
a117b0a5 4216 goto op_semantics_26;
c7927a3c
NC		 4217 break;
4218 }
4219 break;
4220 case 0x57:
4221 GETBYTE ();
4222 switch (op[1] & 0x00)
4223 {
4224 case 0x00:
a117b0a5 4225 goto op_semantics_26;
c7927a3c
NC		 4226 break;
4227 }
4228 break;
4229 case 0x58:
4230 GETBYTE ();
4231 switch (op[1] & 0x00)
4232 {
4233 case 0x00:
a117b0a5 4234 op_semantics_27:
c7927a3c
NC		 4235 {
4236 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
b8985e5c 4237#line 355 "rx-decode.opc"
c7927a3c 4238 int s AU = (op[0] >> 2) & 0x01;
b8985e5c 4239#line 355 "rx-decode.opc"
c7927a3c 4240 int ss AU = op[0] & 0x03;
b8985e5c 4241#line 355 "rx-decode.opc"
c7927a3c 4242 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 4243#line 355 "rx-decode.opc"
c7927a3c
NC		 4244 int rdst AU = op[1] & 0x0f;
4245 if (trace)
4246 {
4247 printf ("\033[33m%s\033[0m %02x %02x\n",
4248 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4249 op[0], op[1]);
4250 printf (" s = 0x%x,", s);
4251 printf (" ss = 0x%x,", ss);
4252 printf (" rsrc = 0x%x,", rsrc);
4253 printf (" rdst = 0x%x\n", rdst);
4254 }
4255 SYNTAX("movu%s %1, %0");
b8985e5c 4256#line 355 "rx-decode.opc"
f04265ec 4257 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
43e65147 4258
c7927a3c
NC		 4259 }
4260 break;
4261 }
4262 break;
4263 case 0x59:
4264 GETBYTE ();
4265 switch (op[1] & 0x00)
4266 {
4267 case 0x00:
a117b0a5 4268 goto op_semantics_27;
c7927a3c
NC		 4269 break;
4270 }
4271 break;
4272 case 0x5a:
4273 GETBYTE ();
4274 switch (op[1] & 0x00)
4275 {
4276 case 0x00:
a117b0a5 4277 goto op_semantics_27;
c7927a3c
NC		 4278 break;
4279 }
4280 break;
4281 case 0x5b:
4282 GETBYTE ();
4283 switch (op[1] & 0x00)
4284 {
4285 case 0x00:
a117b0a5 4286 goto op_semantics_27;
c7927a3c
NC		 4287 break;
4288 }
4289 break;
4290 case 0x5c:
4291 GETBYTE ();
4292 switch (op[1] & 0x00)
4293 {
4294 case 0x00:
a117b0a5 4295 goto op_semantics_27;
c7927a3c
NC		 4296 break;
4297 }
4298 break;
4299 case 0x5d:
4300 GETBYTE ();
4301 switch (op[1] & 0x00)
4302 {
4303 case 0x00:
a117b0a5 4304 goto op_semantics_27;
c7927a3c
NC		 4305 break;
4306 }
4307 break;
4308 case 0x5e:
4309 GETBYTE ();
4310 switch (op[1] & 0x00)
4311 {
4312 case 0x00:
a117b0a5 4313 goto op_semantics_27;
c7927a3c
NC		 4314 break;
4315 }
4316 break;
4317 case 0x5f:
4318 GETBYTE ();
4319 switch (op[1] & 0x00)
4320 {
4321 case 0x00:
a117b0a5 4322 goto op_semantics_27;
c7927a3c
NC		 4323 break;
4324 }
4325 break;
4326 case 0x60:
4327 GETBYTE ();
4328 switch (op[1] & 0x00)
4329 {
4330 case 0x00:
4331 {
4332 /** 0110 0000 immm rdst sub #%2, %0 */
b8985e5c 4333#line 536 "rx-decode.opc"
c7927a3c 4334 int immm AU = (op[1] >> 4) & 0x0f;
b8985e5c 4335#line 536 "rx-decode.opc"
c7927a3c
NC		 4336 int rdst AU = op[1] & 0x0f;
4337 if (trace)
4338 {
4339 printf ("\033[33m%s\033[0m %02x %02x\n",
4340 "/** 0110 0000 immm rdst sub #%2, %0 */",
4341 op[0], op[1]);
4342 printf (" immm = 0x%x,", immm);
4343 printf (" rdst = 0x%x\n", rdst);
4344 }
4345 SYNTAX("sub #%2, %0");
b8985e5c 4346#line 536 "rx-decode.opc"
3cf79a01 4347 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
43e65147 4348
c7927a3c
NC		 4349 }
4350 break;
4351 }
4352 break;
4353 case 0x61:
4354 GETBYTE ();
4355 switch (op[1] & 0x00)
4356 {
4357 case 0x00:
4358 {
4359 /** 0110 0001 immm rdst cmp #%2, %1 */
b8985e5c 4360#line 518 "rx-decode.opc"
c7927a3c 4361 int immm AU = (op[1] >> 4) & 0x0f;
b8985e5c 4362#line 518 "rx-decode.opc"
c7927a3c
NC		 4363 int rdst AU = op[1] & 0x0f;
4364 if (trace)
4365 {
4366 printf ("\033[33m%s\033[0m %02x %02x\n",
4367 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4368 op[0], op[1]);
4369 printf (" immm = 0x%x,", immm);
4370 printf (" rdst = 0x%x\n", rdst);
4371 }
4372 SYNTAX("cmp #%2, %1");
b8985e5c 4373#line 518 "rx-decode.opc"
3cf79a01 4374 ID(sub); S2C(immm); SR(rdst); F_OSZC;
43e65147 4375
c7927a3c
NC		 4376 }
4377 break;
4378 }
4379 break;
4380 case 0x62:
4381 GETBYTE ();
4382 switch (op[1] & 0x00)
4383 {
4384 case 0x00:
4385 {
4386 /** 0110 0010 immm rdst add #%1, %0 */
b8985e5c 4387#line 500 "rx-decode.opc"
c7927a3c 4388 int immm AU = (op[1] >> 4) & 0x0f;
b8985e5c 4389#line 500 "rx-decode.opc"
c7927a3c
NC		 4390 int rdst AU = op[1] & 0x0f;
4391 if (trace)
4392 {
4393 printf ("\033[33m%s\033[0m %02x %02x\n",
4394 "/** 0110 0010 immm rdst add #%1, %0 */",
4395 op[0], op[1]);
4396 printf (" immm = 0x%x,", immm);
4397 printf (" rdst = 0x%x\n", rdst);
4398 }
4399 SYNTAX("add #%1, %0");
b8985e5c 4400#line 500 "rx-decode.opc"
3cf79a01 4401 ID(add); SC(immm); DR(rdst); F_OSZC;
43e65147 4402
c7927a3c
NC		 4403 }
4404 break;
4405 }
4406 break;
4407 case 0x63:
4408 GETBYTE ();
4409 switch (op[1] & 0x00)
4410 {
4411 case 0x00:
4412 {
4413 /** 0110 0011 immm rdst mul #%1, %0 */
a117b0a5 4414#line 612 "rx-decode.opc"
c7927a3c 4415 int immm AU = (op[1] >> 4) & 0x0f;
a117b0a5 4416#line 612 "rx-decode.opc"
c7927a3c
NC		 4417 int rdst AU = op[1] & 0x0f;
4418 if (trace)
4419 {
4420 printf ("\033[33m%s\033[0m %02x %02x\n",
4421 "/** 0110 0011 immm rdst mul #%1, %0 */",
4422 op[0], op[1]);
4423 printf (" immm = 0x%x,", immm);
4424 printf (" rdst = 0x%x\n", rdst);
4425 }
4426 SYNTAX("mul #%1, %0");
a117b0a5
YS		 4427#line 612 "rx-decode.opc"
4428 if (immm == 1 && rdst == 0)
4429 {
4430 ID(nop2);
4431 SYNTAX ("nop\t; mul\t#1, r0");
4432 }
4433 else
4434 {
4435 ID(mul);
4436 }
4437 DR(rdst); SC(immm); F_____;
4438
c7927a3c
NC		 4439 }
4440 break;
4441 }
4442 break;
4443 case 0x64:
4444 GETBYTE ();
4445 switch (op[1] & 0x00)
4446 {
4447 case 0x00:
4448 {
4449 /** 0110 0100 immm rdst and #%1, %0 */
b8985e5c 4450#line 410 "rx-decode.opc"
c7927a3c 4451 int immm AU = (op[1] >> 4) & 0x0f;
b8985e5c 4452#line 410 "rx-decode.opc"
c7927a3c
NC		 4453 int rdst AU = op[1] & 0x0f;
4454 if (trace)
4455 {
4456 printf ("\033[33m%s\033[0m %02x %02x\n",
4457 "/** 0110 0100 immm rdst and #%1, %0 */",
4458 op[0], op[1]);
4459 printf (" immm = 0x%x,", immm);
4460 printf (" rdst = 0x%x\n", rdst);
4461 }
4462 SYNTAX("and #%1, %0");
b8985e5c 4463#line 410 "rx-decode.opc"
3cf79a01 4464 ID(and); SC(immm); DR(rdst); F__SZ_;
43e65147 4465
c7927a3c
NC		 4466 }
4467 break;
4468 }
4469 break;
4470 case 0x65:
4471 GETBYTE ();
4472 switch (op[1] & 0x00)
4473 {
4474 case 0x00:
4475 {
4476 /** 0110 0101 immm rdst or #%1, %0 */
b8985e5c 4477#line 428 "rx-decode.opc"
c7927a3c 4478 int immm AU = (op[1] >> 4) & 0x0f;
b8985e5c 4479#line 428 "rx-decode.opc"
c7927a3c
NC		 4480 int rdst AU = op[1] & 0x0f;
4481 if (trace)
4482 {
4483 printf ("\033[33m%s\033[0m %02x %02x\n",
4484 "/** 0110 0101 immm rdst or #%1, %0 */",
4485 op[0], op[1]);
4486 printf (" immm = 0x%x,", immm);
4487 printf (" rdst = 0x%x\n", rdst);
4488 }
4489 SYNTAX("or #%1, %0");
b8985e5c 4490#line 428 "rx-decode.opc"
3cf79a01 4491 ID(or); SC(immm); DR(rdst); F__SZ_;
43e65147 4492
c7927a3c
NC		 4493 }
4494 break;
4495 }
4496 break;
4497 case 0x66:
4498 GETBYTE ();
4499 switch (op[1] & 0x00)
4500 {
4501 case 0x00:
4502 {
4503 /** 0110 0110 immm rdst mov%s #%1, %0 */
b8985e5c 4504#line 304 "rx-decode.opc"
c7927a3c 4505 int immm AU = (op[1] >> 4) & 0x0f;
b8985e5c 4506#line 304 "rx-decode.opc"
c7927a3c
NC		 4507 int rdst AU = op[1] & 0x0f;
4508 if (trace)
4509 {
4510 printf ("\033[33m%s\033[0m %02x %02x\n",
4511 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4512 op[0], op[1]);
4513 printf (" immm = 0x%x,", immm);
4514 printf (" rdst = 0x%x\n", rdst);
4515 }
4516 SYNTAX("mov%s #%1, %0");
b8985e5c 4517#line 304 "rx-decode.opc"
3cf79a01 4518 ID(mov); DR(rdst); SC(immm); F_____;
43e65147 4519
c7927a3c
NC		 4520 }
4521 break;
4522 }
4523 break;
4524 case 0x67:
4525 {
4526 /** 0110 0111 rtsd #%1 */
4527 if (trace)
4528 {
4529 printf ("\033[33m%s\033[0m %02x\n",
4530 "/** 0110 0111 rtsd #%1 */",
4531 op[0]);
4532 }
4533 SYNTAX("rtsd #%1");
b8985e5c 4534#line 401 "rx-decode.opc"
c7927a3c 4535 ID(rtsd); SC(IMM(1) * 4);
43e65147 4536
c7927a3c
NC		 4537 }
4538 break;
4539 case 0x68:
4540 GETBYTE ();
4541 switch (op[1] & 0x00)
4542 {
4543 case 0x00:
a117b0a5 4544 op_semantics_28:
c7927a3c
NC		 4545 {
4546 /** 0110 100i mmmm rdst shlr #%2, %0 */
a117b0a5 4547#line 726 "rx-decode.opc"
c7927a3c 4548 int i AU = op[0] & 0x01;
a117b0a5 4549#line 726 "rx-decode.opc"
c7927a3c 4550 int mmmm AU = (op[1] >> 4) & 0x0f;
a117b0a5 4551#line 726 "rx-decode.opc"
c7927a3c
NC		 4552 int rdst AU = op[1] & 0x0f;
4553 if (trace)
4554 {
4555 printf ("\033[33m%s\033[0m %02x %02x\n",
4556 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4557 op[0], op[1]);
4558 printf (" i = 0x%x,", i);
4559 printf (" mmmm = 0x%x,", mmmm);
4560 printf (" rdst = 0x%x\n", rdst);
4561 }
4562 SYNTAX("shlr #%2, %0");
a117b0a5 4563#line 726 "rx-decode.opc"
3cf79a01 4564 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
43e65147 4565
c7927a3c
NC		 4566 }
4567 break;
4568 }
4569 break;
4570 case 0x69:
4571 GETBYTE ();
4572 switch (op[1] & 0x00)
4573 {
4574 case 0x00:
a117b0a5 4575 goto op_semantics_28;
c7927a3c
NC		 4576 break;
4577 }
4578 break;
4579 case 0x6a:
4580 GETBYTE ();
4581 switch (op[1] & 0x00)
4582 {
4583 case 0x00:
a117b0a5 4584 op_semantics_29:
c7927a3c
NC		 4585 {
4586 /** 0110 101i mmmm rdst shar #%2, %0 */
a117b0a5 4587#line 716 "rx-decode.opc"
c7927a3c 4588 int i AU = op[0] & 0x01;
a117b0a5 4589#line 716 "rx-decode.opc"
c7927a3c 4590 int mmmm AU = (op[1] >> 4) & 0x0f;
a117b0a5 4591#line 716 "rx-decode.opc"
c7927a3c
NC		 4592 int rdst AU = op[1] & 0x0f;
4593 if (trace)
4594 {
4595 printf ("\033[33m%s\033[0m %02x %02x\n",
4596 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4597 op[0], op[1]);
4598 printf (" i = 0x%x,", i);
4599 printf (" mmmm = 0x%x,", mmmm);
4600 printf (" rdst = 0x%x\n", rdst);
4601 }
4602 SYNTAX("shar #%2, %0");
a117b0a5 4603#line 716 "rx-decode.opc"
3cf79a01 4604 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
43e65147 4605
c7927a3c
NC		 4606 }
4607 break;
4608 }
4609 break;
4610 case 0x6b:
4611 GETBYTE ();
4612 switch (op[1] & 0x00)
4613 {
4614 case 0x00:
a117b0a5 4615 goto op_semantics_29;
c7927a3c
NC		 4616 break;
4617 }
4618 break;
4619 case 0x6c:
4620 GETBYTE ();
4621 switch (op[1] & 0x00)
4622 {
4623 case 0x00:
a117b0a5 4624 op_semantics_30:
c7927a3c
NC		 4625 {
4626 /** 0110 110i mmmm rdst shll #%2, %0 */
a117b0a5 4627#line 706 "rx-decode.opc"
c7927a3c 4628 int i AU = op[0] & 0x01;
a117b0a5 4629#line 706 "rx-decode.opc"
c7927a3c 4630 int mmmm AU = (op[1] >> 4) & 0x0f;
a117b0a5 4631#line 706 "rx-decode.opc"
c7927a3c
NC		 4632 int rdst AU = op[1] & 0x0f;
4633 if (trace)
4634 {
4635 printf ("\033[33m%s\033[0m %02x %02x\n",
4636 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4637 op[0], op[1]);
4638 printf (" i = 0x%x,", i);
4639 printf (" mmmm = 0x%x,", mmmm);
4640 printf (" rdst = 0x%x\n", rdst);
4641 }
4642 SYNTAX("shll #%2, %0");
a117b0a5 4643#line 706 "rx-decode.opc"
3cf79a01 4644 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
43e65147 4645
c7927a3c
NC		 4646 }
4647 break;
4648 }
4649 break;
4650 case 0x6d:
4651 GETBYTE ();
4652 switch (op[1] & 0x00)
4653 {
4654 case 0x00:
a117b0a5 4655 goto op_semantics_30;
c7927a3c
NC		 4656 break;
4657 }
4658 break;
4659 case 0x6e:
4660 GETBYTE ();
4661 switch (op[1] & 0x00)
4662 {
4663 case 0x00:
4664 {
4665 /** 0110 1110 dsta dstb pushm %1-%2 */
b8985e5c 4666#line 368 "rx-decode.opc"
c7927a3c 4667 int dsta AU = (op[1] >> 4) & 0x0f;
b8985e5c 4668#line 368 "rx-decode.opc"
c7927a3c
NC		 4669 int dstb AU = op[1] & 0x0f;
4670 if (trace)
4671 {
4672 printf ("\033[33m%s\033[0m %02x %02x\n",
4673 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4674 op[0], op[1]);
4675 printf (" dsta = 0x%x,", dsta);
4676 printf (" dstb = 0x%x\n", dstb);
4677 }
4678 SYNTAX("pushm %1-%2");
b8985e5c 4679#line 368 "rx-decode.opc"
3cf79a01 4680 ID(pushm); SR(dsta); S2R(dstb); F_____;
43e65147 4681
c7927a3c
NC		 4682 }
4683 break;
4684 }
4685 break;
4686 case 0x6f:
4687 GETBYTE ();
4688 switch (op[1] & 0x00)
4689 {
4690 case 0x00:
4691 {
4692 /** 0110 1111 dsta dstb popm %1-%2 */
b8985e5c 4693#line 365 "rx-decode.opc"
c7927a3c 4694 int dsta AU = (op[1] >> 4) & 0x0f;
b8985e5c 4695#line 365 "rx-decode.opc"
c7927a3c
NC		 4696 int dstb AU = op[1] & 0x0f;
4697 if (trace)
4698 {
4699 printf ("\033[33m%s\033[0m %02x %02x\n",
4700 "/** 0110 1111 dsta dstb popm %1-%2 */",
4701 op[0], op[1]);
4702 printf (" dsta = 0x%x,", dsta);
4703 printf (" dstb = 0x%x\n", dstb);
4704 }
4705 SYNTAX("popm %1-%2");
b8985e5c 4706#line 365 "rx-decode.opc"
3cf79a01 4707 ID(popm); SR(dsta); S2R(dstb); F_____;
43e65147 4708
c7927a3c
NC		 4709 }
4710 break;
4711 }
4712 break;
4713 case 0x70:
4714 GETBYTE ();
4715 switch (op[1] & 0x00)
4716 {
4717 case 0x00:
a117b0a5 4718 op_semantics_31:
c7927a3c
NC		 4719 {
4720 /** 0111 00im rsrc rdst add #%1, %2, %0 */
b8985e5c 4721#line 509 "rx-decode.opc"
c7927a3c 4722 int im AU = op[0] & 0x03;
b8985e5c 4723#line 509 "rx-decode.opc"
c7927a3c 4724 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 4725#line 509 "rx-decode.opc"
c7927a3c
NC		 4726 int rdst AU = op[1] & 0x0f;
4727 if (trace)
4728 {
4729 printf ("\033[33m%s\033[0m %02x %02x\n",
4730 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4731 op[0], op[1]);
4732 printf (" im = 0x%x,", im);
4733 printf (" rsrc = 0x%x,", rsrc);
4734 printf (" rdst = 0x%x\n", rdst);
4735 }
4736 SYNTAX("add #%1, %2, %0");
b8985e5c 4737#line 509 "rx-decode.opc"
3cf79a01 4738 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
43e65147 4739
c7927a3c
NC		 4740 }
4741 break;
4742 }
4743 break;
4744 case 0x71:
4745 GETBYTE ();
4746 switch (op[1] & 0x00)
4747 {
4748 case 0x00:
a117b0a5 4749 goto op_semantics_31;
c7927a3c
NC		 4750 break;
4751 }
4752 break;
4753 case 0x72:
4754 GETBYTE ();
4755 switch (op[1] & 0x00)
4756 {
4757 case 0x00:
a117b0a5 4758 goto op_semantics_31;
c7927a3c
NC		 4759 break;
4760 }
4761 break;
4762 case 0x73:
4763 GETBYTE ();
4764 switch (op[1] & 0x00)
4765 {
4766 case 0x00:
a117b0a5 4767 goto op_semantics_31;
c7927a3c
NC		 4768 break;
4769 }
4770 break;
4771 case 0x74:
4772 GETBYTE ();
4773 switch (op[1] & 0xf0)
4774 {
4775 case 0x00:
a117b0a5 4776 op_semantics_32:
c7927a3c
NC		 4777 {
4778 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
b8985e5c 4779#line 521 "rx-decode.opc"
c7927a3c 4780 int im AU = op[0] & 0x03;
b8985e5c 4781#line 521 "rx-decode.opc"
c7927a3c
NC		 4782 int rsrc AU = op[1] & 0x0f;
4783 if (trace)
4784 {
4785 printf ("\033[33m%s\033[0m %02x %02x\n",
4786 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4787 op[0], op[1]);
4788 printf (" im = 0x%x,", im);
4789 printf (" rsrc = 0x%x\n", rsrc);
4790 }
4791 SYNTAX("cmp #%2, %1%S1");
b8985e5c 4792#line 521 "rx-decode.opc"
3cf79a01 4793 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
43e65147 4794
c7927a3c
NC		 4795 }
4796 break;
4797 case 0x10:
a117b0a5 4798 op_semantics_33:
c7927a3c
NC		 4799 {
4800 /** 0111 01im 0001rdst mul #%1, %0 */
a117b0a5 4801#line 624 "rx-decode.opc"
c7927a3c 4802 int im AU = op[0] & 0x03;
a117b0a5 4803#line 624 "rx-decode.opc"
c7927a3c
NC		 4804 int rdst AU = op[1] & 0x0f;
4805 if (trace)
4806 {
4807 printf ("\033[33m%s\033[0m %02x %02x\n",
4808 "/** 0111 01im 0001rdst mul #%1, %0 */",
4809 op[0], op[1]);
4810 printf (" im = 0x%x,", im);
4811 printf (" rdst = 0x%x\n", rdst);
4812 }
4813 SYNTAX("mul #%1, %0");
a117b0a5
YS		 4814#line 624 "rx-decode.opc"
4815 int val = IMMex(im);
4816 if (val == 1 && rdst == 0)
4817 {
4818 SYNTAX("nop\t; mul\t#1, r0");
4819 switch (im)
4820 {
4821 case 2: ID(nop4); break;
4822 case 3: ID(nop5); break;
4823 case 0: ID(nop6); break;
4824 default:
4825 ID(mul);
4826 SYNTAX("mul #%1, %0");
4827 break;
4828 }
4829 }
4830 else
4831 {
4832 ID(mul);
4833 }
4834 DR(rdst); SC(val); F_____;
43e65147 4835
c7927a3c
NC		 4836 }
4837 break;
4838 case 0x20:
a117b0a5 4839 op_semantics_34:
c7927a3c
NC		 4840 {
4841 /** 0111 01im 0010 rdst and #%1, %0 */
b8985e5c 4842#line 413 "rx-decode.opc"
c7927a3c 4843 int im AU = op[0] & 0x03;
b8985e5c 4844#line 413 "rx-decode.opc"
c7927a3c
NC		 4845 int rdst AU = op[1] & 0x0f;
4846 if (trace)
4847 {
4848 printf ("\033[33m%s\033[0m %02x %02x\n",
4849 "/** 0111 01im 0010 rdst and #%1, %0 */",
4850 op[0], op[1]);
4851 printf (" im = 0x%x,", im);
4852 printf (" rdst = 0x%x\n", rdst);
4853 }
4854 SYNTAX("and #%1, %0");
b8985e5c 4855#line 413 "rx-decode.opc"
3cf79a01 4856 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
43e65147 4857
c7927a3c
NC		 4858 }
4859 break;
4860 case 0x30:
a117b0a5 4861 op_semantics_35:
c7927a3c
NC		 4862 {
4863 /** 0111 01im 0011 rdst or #%1, %0 */
b8985e5c 4864#line 431 "rx-decode.opc"
c7927a3c 4865 int im AU = op[0] & 0x03;
b8985e5c 4866#line 431 "rx-decode.opc"
c7927a3c
NC		 4867 int rdst AU = op[1] & 0x0f;
4868 if (trace)
4869 {
4870 printf ("\033[33m%s\033[0m %02x %02x\n",
4871 "/** 0111 01im 0011 rdst or #%1, %0 */",
4872 op[0], op[1]);
4873 printf (" im = 0x%x,", im);
4874 printf (" rdst = 0x%x\n", rdst);
4875 }
4876 SYNTAX("or #%1, %0");
b8985e5c 4877#line 431 "rx-decode.opc"
3cf79a01 4878 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
43e65147 4879
c7927a3c
NC		 4880 }
4881 break;
4882 default: UNSUPPORTED(); break;
4883 }
4884 break;
4885 case 0x75:
4886 GETBYTE ();
4887 switch (op[1] & 0xff)
4888 {
4889 case 0x00:
4890 case 0x01:
4891 case 0x02:
4892 case 0x03:
4893 case 0x04:
4894 case 0x05:
4895 case 0x06:
4896 case 0x07:
4897 case 0x08:
4898 case 0x09:
4899 case 0x0a:
4900 case 0x0b:
4901 case 0x0c:
4902 case 0x0d:
4903 case 0x0e:
4904 case 0x0f:
a117b0a5 4905 goto op_semantics_32;
c7927a3c
NC		 4906 break;
4907 case 0x10:
4908 case 0x11:
4909 case 0x12:
4910 case 0x13:
4911 case 0x14:
4912 case 0x15:
4913 case 0x16:
4914 case 0x17:
4915 case 0x18:
4916 case 0x19:
4917 case 0x1a:
4918 case 0x1b:
4919 case 0x1c:
4920 case 0x1d:
4921 case 0x1e:
4922 case 0x1f:
a117b0a5 4923 goto op_semantics_33;
c7927a3c
NC		 4924 break;
4925 case 0x20:
4926 case 0x21:
4927 case 0x22:
4928 case 0x23:
4929 case 0x24:
4930 case 0x25:
4931 case 0x26:
4932 case 0x27:
4933 case 0x28:
4934 case 0x29:
4935 case 0x2a:
4936 case 0x2b:
4937 case 0x2c:
4938 case 0x2d:
4939 case 0x2e:
4940 case 0x2f:
a117b0a5 4941 goto op_semantics_34;
c7927a3c
NC		 4942 break;
4943 case 0x30:
4944 case 0x31:
4945 case 0x32:
4946 case 0x33:
4947 case 0x34:
4948 case 0x35:
4949 case 0x36:
4950 case 0x37:
4951 case 0x38:
4952 case 0x39:
4953 case 0x3a:
4954 case 0x3b:
4955 case 0x3c:
4956 case 0x3d:
4957 case 0x3e:
4958 case 0x3f:
a117b0a5 4959 goto op_semantics_35;
c7927a3c
NC		 4960 break;
4961 case 0x40:
4962 case 0x41:
4963 case 0x42:
4964 case 0x43:
4965 case 0x44:
4966 case 0x45:
4967 case 0x46:
4968 case 0x47:
4969 case 0x48:
4970 case 0x49:
4971 case 0x4a:
4972 case 0x4b:
4973 case 0x4c:
4974 case 0x4d:
4975 case 0x4e:
4976 case 0x4f:
4977 {
4978 /** 0111 0101 0100 rdst mov%s #%1, %0 */
b8985e5c 4979#line 285 "rx-decode.opc"
c7927a3c
NC		 4980 int rdst AU = op[1] & 0x0f;
4981 if (trace)
4982 {
4983 printf ("\033[33m%s\033[0m %02x %02x\n",
4984 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4985 op[0], op[1]);
4986 printf (" rdst = 0x%x\n", rdst);
4987 }
4988 SYNTAX("mov%s #%1, %0");
b8985e5c 4989#line 285 "rx-decode.opc"
3cf79a01 4990 ID(mov); DR(rdst); SC(IMM (1)); F_____;
43e65147 4991
c7927a3c
NC		 4992 }
4993 break;
4994 case 0x50:
4995 case 0x51:
4996 case 0x52:
4997 case 0x53:
4998 case 0x54:
4999 case 0x55:
5000 case 0x56:
5001 case 0x57:
5002 case 0x58:
5003 case 0x59:
5004 case 0x5a:
5005 case 0x5b:
5006 case 0x5c:
5007 case 0x5d:
5008 case 0x5e:
5009 case 0x5f:
5010 {
5011 /** 0111 0101 0101 rsrc cmp #%2, %1 */
b8985e5c 5012#line 524 "rx-decode.opc"
c7927a3c
NC		 5013 int rsrc AU = op[1] & 0x0f;
5014 if (trace)
5015 {
5016 printf ("\033[33m%s\033[0m %02x %02x\n",
5017 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5018 op[0], op[1]);
5019 printf (" rsrc = 0x%x\n", rsrc);
5020 }
5021 SYNTAX("cmp #%2, %1");
b8985e5c 5022#line 524 "rx-decode.opc"
3cf79a01 5023 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
43e65147 5024
c7927a3c
NC		 5025 }
5026 break;
5027 case 0x60:
5028 {
5029 /** 0111 0101 0110 0000 int #%1 */
5030 if (trace)
5031 {
5032 printf ("\033[33m%s\033[0m %02x %02x\n",
5033 "/** 0111 0101 0110 0000 int #%1 */",
5034 op[0], op[1]);
5035 }
5036 SYNTAX("int #%1");
a117b0a5 5037#line 1031 "rx-decode.opc"
c7927a3c 5038 ID(int); SC(IMM(1));
43e65147 5039
c7927a3c
NC		 5040 }
5041 break;
946ef196
DD		 5042 case 0x70:
5043 GETBYTE ();
5044 switch (op[2] & 0xf0)
5045 {
5046 case 0x00:
5047 {
5048 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
a117b0a5 5049#line 998 "rx-decode.opc"
946ef196
DD		 5050 int immm AU = op[2] & 0x0f;
5051 if (trace)
5052 {
5053 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5054 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5055 op[0], op[1], op[2]);
5056 printf (" immm = 0x%x\n", immm);
5057 }
5058 SYNTAX("mvtipl #%1");
a117b0a5 5059#line 998 "rx-decode.opc"
946ef196 5060 ID(mvtipl); SC(immm);
43e65147 5061
946ef196
DD		 5062 }
5063 break;
5064 default: UNSUPPORTED(); break;
5065 }
5066 break;
c7927a3c
NC		 5067 default: UNSUPPORTED(); break;
5068 }
5069 break;
5070 case 0x76:
5071 GETBYTE ();
5072 switch (op[1] & 0xf0)
5073 {
5074 case 0x00:
a117b0a5 5075 goto op_semantics_32;
c7927a3c
NC		 5076 break;
5077 case 0x10:
a117b0a5 5078 goto op_semantics_33;
c7927a3c
NC		 5079 break;
5080 case 0x20:
a117b0a5 5081 goto op_semantics_34;
c7927a3c
NC		 5082 break;
5083 case 0x30:
a117b0a5 5084 goto op_semantics_35;
c7927a3c
NC		 5085 break;
5086 default: UNSUPPORTED(); break;
5087 }
5088 break;
5089 case 0x77:
5090 GETBYTE ();
5091 switch (op[1] & 0xf0)
5092 {
5093 case 0x00:
a117b0a5 5094 goto op_semantics_32;
c7927a3c
NC		 5095 break;
5096 case 0x10:
a117b0a5 5097 goto op_semantics_33;
c7927a3c
NC		 5098 break;
5099 case 0x20:
a117b0a5 5100 goto op_semantics_34;
c7927a3c
NC		 5101 break;
5102 case 0x30:
a117b0a5 5103 goto op_semantics_35;
c7927a3c
NC		 5104 break;
5105 default: UNSUPPORTED(); break;
5106 }
5107 break;
5108 case 0x78:
5109 GETBYTE ();
5110 switch (op[1] & 0x00)
5111 {
5112 case 0x00:
a117b0a5 5113 op_semantics_36:
c7927a3c
NC		 5114 {
5115 /** 0111 100b ittt rdst bset #%1, %0 */
a117b0a5 5116#line 943 "rx-decode.opc"
c7927a3c 5117 int b AU = op[0] & 0x01;
a117b0a5 5118#line 943 "rx-decode.opc"
c7927a3c 5119 int ittt AU = (op[1] >> 4) & 0x0f;
a117b0a5 5120#line 943 "rx-decode.opc"
c7927a3c
NC		 5121 int rdst AU = op[1] & 0x0f;
5122 if (trace)
5123 {
5124 printf ("\033[33m%s\033[0m %02x %02x\n",
5125 "/** 0111 100b ittt rdst bset #%1, %0 */",
5126 op[0], op[1]);
5127 printf (" b = 0x%x,", b);
5128 printf (" ittt = 0x%x,", ittt);
5129 printf (" rdst = 0x%x\n", rdst);
5130 }
5131 SYNTAX("bset #%1, %0");
a117b0a5 5132#line 943 "rx-decode.opc"
3cf79a01 5133 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
43e65147
L		 5134
5135
c7927a3c
NC		 5136 }
5137 break;
5138 }
5139 break;
5140 case 0x79:
5141 GETBYTE ();
5142 switch (op[1] & 0x00)
5143 {
5144 case 0x00:
a117b0a5 5145 goto op_semantics_36;
c7927a3c
NC		 5146 break;
5147 }
5148 break;
5149 case 0x7a:
5150 GETBYTE ();
5151 switch (op[1] & 0x00)
5152 {
5153 case 0x00:
a117b0a5 5154 op_semantics_37:
c7927a3c
NC		 5155 {
5156 /** 0111 101b ittt rdst bclr #%1, %0 */
a117b0a5 5157#line 955 "rx-decode.opc"
c7927a3c 5158 int b AU = op[0] & 0x01;
a117b0a5 5159#line 955 "rx-decode.opc"
c7927a3c 5160 int ittt AU = (op[1] >> 4) & 0x0f;
a117b0a5 5161#line 955 "rx-decode.opc"
c7927a3c
NC		 5162 int rdst AU = op[1] & 0x0f;
5163 if (trace)
5164 {
5165 printf ("\033[33m%s\033[0m %02x %02x\n",
5166 "/** 0111 101b ittt rdst bclr #%1, %0 */",
5167 op[0], op[1]);
5168 printf (" b = 0x%x,", b);
5169 printf (" ittt = 0x%x,", ittt);
5170 printf (" rdst = 0x%x\n", rdst);
5171 }
5172 SYNTAX("bclr #%1, %0");
a117b0a5 5173#line 955 "rx-decode.opc"
3cf79a01 5174 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
43e65147
L		 5175
5176
c7927a3c
NC		 5177 }
5178 break;
5179 }
5180 break;
5181 case 0x7b:
5182 GETBYTE ();
5183 switch (op[1] & 0x00)
5184 {
5185 case 0x00:
a117b0a5 5186 goto op_semantics_37;
c7927a3c
NC		 5187 break;
5188 }
5189 break;
5190 case 0x7c:
5191 GETBYTE ();
5192 switch (op[1] & 0x00)
5193 {
5194 case 0x00:
a117b0a5 5195 op_semantics_38:
c7927a3c
NC		 5196 {
5197 /** 0111 110b ittt rdst btst #%2, %1 */
a117b0a5 5198#line 967 "rx-decode.opc"
c7927a3c 5199 int b AU = op[0] & 0x01;
a117b0a5 5200#line 967 "rx-decode.opc"
c7927a3c 5201 int ittt AU = (op[1] >> 4) & 0x0f;
a117b0a5 5202#line 967 "rx-decode.opc"
c7927a3c
NC		 5203 int rdst AU = op[1] & 0x0f;
5204 if (trace)
5205 {
5206 printf ("\033[33m%s\033[0m %02x %02x\n",
5207 "/** 0111 110b ittt rdst btst #%2, %1 */",
5208 op[0], op[1]);
5209 printf (" b = 0x%x,", b);
5210 printf (" ittt = 0x%x,", ittt);
5211 printf (" rdst = 0x%x\n", rdst);
5212 }
5213 SYNTAX("btst #%2, %1");
a117b0a5 5214#line 967 "rx-decode.opc"
3cf79a01 5215 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
43e65147
L		 5216
5217
c7927a3c
NC		 5218 }
5219 break;
5220 }
5221 break;
5222 case 0x7d:
5223 GETBYTE ();
5224 switch (op[1] & 0x00)
5225 {
5226 case 0x00:
a117b0a5 5227 goto op_semantics_38;
c7927a3c
NC		 5228 break;
5229 }
5230 break;
5231 case 0x7e:
5232 GETBYTE ();
5233 switch (op[1] & 0xf0)
5234 {
5235 case 0x00:
5236 {
5237 /** 0111 1110 0000 rdst not %0 */
b8985e5c 5238#line 458 "rx-decode.opc"
c7927a3c
NC		 5239 int rdst AU = op[1] & 0x0f;
5240 if (trace)
5241 {
5242 printf ("\033[33m%s\033[0m %02x %02x\n",
5243 "/** 0111 1110 0000 rdst not %0 */",
5244 op[0], op[1]);
5245 printf (" rdst = 0x%x\n", rdst);
5246 }
5247 SYNTAX("not %0");
b8985e5c 5248#line 458 "rx-decode.opc"
3cf79a01 5249 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
43e65147 5250
c7927a3c
NC		 5251 }
5252 break;
5253 case 0x10:
5254 {
5255 /** 0111 1110 0001 rdst neg %0 */
b8985e5c 5256#line 479 "rx-decode.opc"
c7927a3c
NC		 5257 int rdst AU = op[1] & 0x0f;
5258 if (trace)
5259 {
5260 printf ("\033[33m%s\033[0m %02x %02x\n",
5261 "/** 0111 1110 0001 rdst neg %0 */",
5262 op[0], op[1]);
5263 printf (" rdst = 0x%x\n", rdst);
5264 }
5265 SYNTAX("neg %0");
b8985e5c 5266#line 479 "rx-decode.opc"
3cf79a01 5267 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
43e65147 5268
c7927a3c
NC		 5269 }
5270 break;
5271 case 0x20:
5272 {
5273 /** 0111 1110 0010 rdst abs %0 */
b8985e5c 5274#line 561 "rx-decode.opc"
c7927a3c
NC		 5275 int rdst AU = op[1] & 0x0f;
5276 if (trace)
5277 {
5278 printf ("\033[33m%s\033[0m %02x %02x\n",
5279 "/** 0111 1110 0010 rdst abs %0 */",
5280 op[0], op[1]);
5281 printf (" rdst = 0x%x\n", rdst);
5282 }
5283 SYNTAX("abs %0");
b8985e5c 5284#line 561 "rx-decode.opc"
3cf79a01 5285 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
43e65147 5286
c7927a3c
NC		 5287 }
5288 break;
5289 case 0x30:
5290 {
5291 /** 0111 1110 0011 rdst sat %0 */
a117b0a5 5292#line 881 "rx-decode.opc"
c7927a3c
NC		 5293 int rdst AU = op[1] & 0x0f;
5294 if (trace)
5295 {
5296 printf ("\033[33m%s\033[0m %02x %02x\n",
5297 "/** 0111 1110 0011 rdst sat %0 */",
5298 op[0], op[1]);
5299 printf (" rdst = 0x%x\n", rdst);
5300 }
5301 SYNTAX("sat %0");
a117b0a5 5302#line 881 "rx-decode.opc"
c7927a3c 5303 ID(sat); DR (rdst);
43e65147 5304
c7927a3c
NC		 5305 }
5306 break;
5307 case 0x40:
5308 {
5309 /** 0111 1110 0100 rdst rorc %0 */
a117b0a5 5310#line 741 "rx-decode.opc"
c7927a3c
NC		 5311 int rdst AU = op[1] & 0x0f;
5312 if (trace)
5313 {
5314 printf ("\033[33m%s\033[0m %02x %02x\n",
5315 "/** 0111 1110 0100 rdst rorc %0 */",
5316 op[0], op[1]);
5317 printf (" rdst = 0x%x\n", rdst);
5318 }
5319 SYNTAX("rorc %0");
a117b0a5 5320#line 741 "rx-decode.opc"
3cf79a01 5321 ID(rorc); DR(rdst); F__SZC;
43e65147 5322
c7927a3c
NC		 5323 }
5324 break;
5325 case 0x50:
5326 {
5327 /** 0111 1110 0101 rdst rolc %0 */
a117b0a5 5328#line 738 "rx-decode.opc"
c7927a3c
NC		 5329 int rdst AU = op[1] & 0x0f;
5330 if (trace)
5331 {
5332 printf ("\033[33m%s\033[0m %02x %02x\n",
5333 "/** 0111 1110 0101 rdst rolc %0 */",
5334 op[0], op[1]);
5335 printf (" rdst = 0x%x\n", rdst);
5336 }
5337 SYNTAX("rolc %0");
a117b0a5 5338#line 738 "rx-decode.opc"
3cf79a01 5339 ID(rolc); DR(rdst); F__SZC;
43e65147 5340
c7927a3c
NC		 5341 }
5342 break;
5343 case 0x80:
5344 case 0x90:
5345 case 0xa0:
5346 {
5347 /** 0111 1110 10sz rsrc push%s %1 */
b8985e5c 5348#line 374 "rx-decode.opc"
c7927a3c 5349 int sz AU = (op[1] >> 4) & 0x03;
b8985e5c 5350#line 374 "rx-decode.opc"
c7927a3c
NC		 5351 int rsrc AU = op[1] & 0x0f;
5352 if (trace)
5353 {
5354 printf ("\033[33m%s\033[0m %02x %02x\n",
5355 "/** 0111 1110 10sz rsrc push%s %1 */",
5356 op[0], op[1]);
5357 printf (" sz = 0x%x,", sz);
5358 printf (" rsrc = 0x%x\n", rsrc);
5359 }
5360 SYNTAX("push%s %1");
b8985e5c 5361#line 374 "rx-decode.opc"
3cf79a01 5362 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
43e65147 5363
c7927a3c
NC		 5364 }
5365 break;
5366 case 0xb0:
5367 {
5368 /** 0111 1110 1011 rdst pop %0 */
b8985e5c 5369#line 371 "rx-decode.opc"
c7927a3c
NC		 5370 int rdst AU = op[1] & 0x0f;
5371 if (trace)
5372 {
5373 printf ("\033[33m%s\033[0m %02x %02x\n",
5374 "/** 0111 1110 1011 rdst pop %0 */",
5375 op[0], op[1]);
5376 printf (" rdst = 0x%x\n", rdst);
5377 }
5378 SYNTAX("pop %0");
b8985e5c 5379#line 371 "rx-decode.opc"
3cf79a01 5380 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
43e65147 5381
c7927a3c
NC		 5382 }
5383 break;
5384 case 0xc0:
5385 case 0xd0:
5386 {
5387 /** 0111 1110 110 crsrc pushc %1 */
a117b0a5 5388#line 1004 "rx-decode.opc"
c7927a3c
NC		 5389 int crsrc AU = op[1] & 0x1f;
5390 if (trace)
5391 {
5392 printf ("\033[33m%s\033[0m %02x %02x\n",
5393 "/** 0111 1110 110 crsrc pushc %1 */",
5394 op[0], op[1]);
5395 printf (" crsrc = 0x%x\n", crsrc);
5396 }
5397 SYNTAX("pushc %1");
a117b0a5 5398#line 1004 "rx-decode.opc"
c7927a3c 5399 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
43e65147 5400
c7927a3c
NC		 5401 }
5402 break;
5403 case 0xe0:
5404 case 0xf0:
5405 {
5406 /** 0111 1110 111 crdst popc %0 */
a117b0a5 5407#line 1001 "rx-decode.opc"
c7927a3c
NC		 5408 int crdst AU = op[1] & 0x1f;
5409 if (trace)
5410 {
5411 printf ("\033[33m%s\033[0m %02x %02x\n",
5412 "/** 0111 1110 111 crdst popc %0 */",
5413 op[0], op[1]);
5414 printf (" crdst = 0x%x\n", crdst);
5415 }
5416 SYNTAX("popc %0");
a117b0a5 5417#line 1001 "rx-decode.opc"
c7927a3c 5418 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
43e65147 5419
c7927a3c
NC		 5420 }
5421 break;
5422 default: UNSUPPORTED(); break;
5423 }
5424 break;
5425 case 0x7f:
5426 GETBYTE ();
5427 switch (op[1] & 0xff)
5428 {
5429 case 0x00:
5430 case 0x01:
5431 case 0x02:
5432 case 0x03:
5433 case 0x04:
5434 case 0x05:
5435 case 0x06:
5436 case 0x07:
5437 case 0x08:
5438 case 0x09:
5439 case 0x0a:
5440 case 0x0b:
5441 case 0x0c:
5442 case 0x0d:
5443 case 0x0e:
5444 case 0x0f:
5445 {
5446 /** 0111 1111 0000 rsrc jmp %0 */
a117b0a5 5447#line 791 "rx-decode.opc"
c7927a3c
NC		 5448 int rsrc AU = op[1] & 0x0f;
5449 if (trace)
5450 {
5451 printf ("\033[33m%s\033[0m %02x %02x\n",
5452 "/** 0111 1111 0000 rsrc jmp %0 */",
5453 op[0], op[1]);
5454 printf (" rsrc = 0x%x\n", rsrc);
5455 }
5456 SYNTAX("jmp %0");
a117b0a5 5457#line 791 "rx-decode.opc"
f9c7014e 5458 ID(branch); DR(rsrc);
43e65147 5459
c7927a3c
NC		 5460 }
5461 break;
5462 case 0x10:
5463 case 0x11:
5464 case 0x12:
5465 case 0x13:
5466 case 0x14:
5467 case 0x15:
5468 case 0x16:
5469 case 0x17:
5470 case 0x18:
5471 case 0x19:
5472 case 0x1a:
5473 case 0x1b:
5474 case 0x1c:
5475 case 0x1d:
5476 case 0x1e:
5477 case 0x1f:
5478 {
5479 /** 0111 1111 0001 rsrc jsr %0 */
a117b0a5 5480#line 794 "rx-decode.opc"
c7927a3c
NC		 5481 int rsrc AU = op[1] & 0x0f;
5482 if (trace)
5483 {
5484 printf ("\033[33m%s\033[0m %02x %02x\n",
5485 "/** 0111 1111 0001 rsrc jsr %0 */",
5486 op[0], op[1]);
5487 printf (" rsrc = 0x%x\n", rsrc);
5488 }
5489 SYNTAX("jsr %0");
a117b0a5 5490#line 794 "rx-decode.opc"
c7927a3c 5491 ID(jsr); DR(rsrc);
43e65147 5492
c7927a3c
NC		 5493 }
5494 break;
5495 case 0x40:
5496 case 0x41:
5497 case 0x42:
5498 case 0x43:
5499 case 0x44:
5500 case 0x45:
5501 case 0x46:
5502 case 0x47:
5503 case 0x48:
5504 case 0x49:
5505 case 0x4a:
5506 case 0x4b:
5507 case 0x4c:
5508 case 0x4d:
5509 case 0x4e:
5510 case 0x4f:
5511 {
5512 /** 0111 1111 0100 rsrc bra.l %0 */
a117b0a5 5513#line 787 "rx-decode.opc"
c7927a3c
NC		 5514 int rsrc AU = op[1] & 0x0f;
5515 if (trace)
5516 {
5517 printf ("\033[33m%s\033[0m %02x %02x\n",
5518 "/** 0111 1111 0100 rsrc bra.l %0 */",
5519 op[0], op[1]);
5520 printf (" rsrc = 0x%x\n", rsrc);
5521 }
5522 SYNTAX("bra.l %0");
a117b0a5 5523#line 787 "rx-decode.opc"
f9c7014e 5524 ID(branchrel); DR(rsrc);
43e65147
L		 5525
5526
c7927a3c
NC		 5527 }
5528 break;
5529 case 0x50:
5530 case 0x51:
5531 case 0x52:
5532 case 0x53:
5533 case 0x54:
5534 case 0x55:
5535 case 0x56:
5536 case 0x57:
5537 case 0x58:
5538 case 0x59:
5539 case 0x5a:
5540 case 0x5b:
5541 case 0x5c:
5542 case 0x5d:
5543 case 0x5e:
5544 case 0x5f:
5545 {
5546 /** 0111 1111 0101 rsrc bsr.l %0 */
a117b0a5 5547#line 803 "rx-decode.opc"
c7927a3c
NC		 5548 int rsrc AU = op[1] & 0x0f;
5549 if (trace)
5550 {
5551 printf ("\033[33m%s\033[0m %02x %02x\n",
5552 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5553 op[0], op[1]);
5554 printf (" rsrc = 0x%x\n", rsrc);
5555 }
5556 SYNTAX("bsr.l %0");
a117b0a5 5557#line 803 "rx-decode.opc"
c7927a3c 5558 ID(jsrrel); DR(rsrc);
43e65147 5559
c7927a3c
NC		 5560 }
5561 break;
5562 case 0x80:
5563 case 0x81:
5564 case 0x82:
5565 {
5566 /** 0111 1111 1000 00sz suntil%s */
a117b0a5 5567#line 827 "rx-decode.opc"
c7927a3c
NC		 5568 int sz AU = op[1] & 0x03;
5569 if (trace)
5570 {
5571 printf ("\033[33m%s\033[0m %02x %02x\n",
5572 "/** 0111 1111 1000 00sz suntil%s */",
5573 op[0], op[1]);
5574 printf (" sz = 0x%x\n", sz);
5575 }
5576 SYNTAX("suntil%s");
a117b0a5 5577#line 827 "rx-decode.opc"
3cf79a01 5578 ID(suntil); BWL(sz); F___ZC;
43e65147 5579
c7927a3c
NC		 5580 }
5581 break;
5582 case 0x83:
5583 {
5584 /** 0111 1111 1000 0011 scmpu */
5585 if (trace)
5586 {
5587 printf ("\033[33m%s\033[0m %02x %02x\n",
5588 "/** 0111 1111 1000 0011 scmpu */",
5589 op[0], op[1]);
5590 }
5591 SYNTAX("scmpu");
a117b0a5 5592#line 818 "rx-decode.opc"
3cf79a01 5593 ID(scmpu); F___ZC;
43e65147 5594
c7927a3c
NC		 5595 }
5596 break;
5597 case 0x84:
5598 case 0x85:
5599 case 0x86:
5600 {
5601 /** 0111 1111 1000 01sz swhile%s */
a117b0a5 5602#line 830 "rx-decode.opc"
c7927a3c
NC		 5603 int sz AU = op[1] & 0x03;
5604 if (trace)
5605 {
5606 printf ("\033[33m%s\033[0m %02x %02x\n",
5607 "/** 0111 1111 1000 01sz swhile%s */",
5608 op[0], op[1]);
5609 printf (" sz = 0x%x\n", sz);
5610 }
5611 SYNTAX("swhile%s");
a117b0a5 5612#line 830 "rx-decode.opc"
3cf79a01 5613 ID(swhile); BWL(sz); F___ZC;
43e65147 5614
c7927a3c
NC		 5615 }
5616 break;
5617 case 0x87:
5618 {
5619 /** 0111 1111 1000 0111 smovu */
5620 if (trace)
5621 {
5622 printf ("\033[33m%s\033[0m %02x %02x\n",
5623 "/** 0111 1111 1000 0111 smovu */",
5624 op[0], op[1]);
5625 }
5626 SYNTAX("smovu");
a117b0a5 5627#line 821 "rx-decode.opc"
c7927a3c 5628 ID(smovu);
43e65147 5629
c7927a3c
NC		 5630 }
5631 break;
5632 case 0x88:
5633 case 0x89:
5634 case 0x8a:
5635 {
5636 /** 0111 1111 1000 10sz sstr%s */
a117b0a5 5637#line 836 "rx-decode.opc"
c7927a3c
NC		 5638 int sz AU = op[1] & 0x03;
5639 if (trace)
5640 {
5641 printf ("\033[33m%s\033[0m %02x %02x\n",
5642 "/** 0111 1111 1000 10sz sstr%s */",
5643 op[0], op[1]);
5644 printf (" sz = 0x%x\n", sz);
5645 }
5646 SYNTAX("sstr%s");
a117b0a5 5647#line 836 "rx-decode.opc"
c7927a3c 5648 ID(sstr); BWL(sz);
43e65147 5649
c7927a3c
NC		 5650 /*----------------------------------------------------------------------*/
5651 /* RMPA */
43e65147 5652
c7927a3c
NC		 5653 }
5654 break;
5655 case 0x8b:
5656 {
5657 /** 0111 1111 1000 1011 smovb */
5658 if (trace)
5659 {
5660 printf ("\033[33m%s\033[0m %02x %02x\n",
5661 "/** 0111 1111 1000 1011 smovb */",
5662 op[0], op[1]);
5663 }
5664 SYNTAX("smovb");
a117b0a5 5665#line 824 "rx-decode.opc"
c7927a3c 5666 ID(smovb);
43e65147 5667
c7927a3c
NC		 5668 }
5669 break;
5670 case 0x8c:
5671 case 0x8d:
5672 case 0x8e:
5673 {
5674 /** 0111 1111 1000 11sz rmpa%s */
a117b0a5 5675#line 842 "rx-decode.opc"
c7927a3c
NC		 5676 int sz AU = op[1] & 0x03;
5677 if (trace)
5678 {
5679 printf ("\033[33m%s\033[0m %02x %02x\n",
5680 "/** 0111 1111 1000 11sz rmpa%s */",
5681 op[0], op[1]);
5682 printf (" sz = 0x%x\n", sz);
5683 }
5684 SYNTAX("rmpa%s");
a117b0a5 5685#line 842 "rx-decode.opc"
3cf79a01 5686 ID(rmpa); BWL(sz); F_OS__;
43e65147 5687
c7927a3c
NC		 5688 /*----------------------------------------------------------------------*/
5689 /* HI/LO stuff */
43e65147 5690
c7927a3c
NC		 5691 }
5692 break;
5693 case 0x8f:
5694 {
5695 /** 0111 1111 1000 1111 smovf */
5696 if (trace)
5697 {
5698 printf ("\033[33m%s\033[0m %02x %02x\n",
5699 "/** 0111 1111 1000 1111 smovf */",
5700 op[0], op[1]);
5701 }
5702 SYNTAX("smovf");
a117b0a5 5703#line 833 "rx-decode.opc"
c7927a3c 5704 ID(smovf);
43e65147 5705
c7927a3c
NC		 5706 }
5707 break;
5708 case 0x93:
5709 {
5710 /** 0111 1111 1001 0011 satr */
5711 if (trace)
5712 {
5713 printf ("\033[33m%s\033[0m %02x %02x\n",
5714 "/** 0111 1111 1001 0011 satr */",
5715 op[0], op[1]);
5716 }
5717 SYNTAX("satr");
a117b0a5 5718#line 884 "rx-decode.opc"
c7927a3c 5719 ID(satr);
43e65147 5720
c7927a3c
NC		 5721 /*----------------------------------------------------------------------*/
5722 /* FLOAT */
43e65147 5723
c7927a3c
NC		 5724 }
5725 break;
5726 case 0x94:
5727 {
5728 /** 0111 1111 1001 0100 rtfi */
5729 if (trace)
5730 {
5731 printf ("\033[33m%s\033[0m %02x %02x\n",
5732 "/** 0111 1111 1001 0100 rtfi */",
5733 op[0], op[1]);
5734 }
5735 SYNTAX("rtfi");
a117b0a5 5736#line 1019 "rx-decode.opc"
c7927a3c 5737 ID(rtfi);
43e65147 5738
c7927a3c
NC		 5739 }
5740 break;
5741 case 0x95:
5742 {
5743 /** 0111 1111 1001 0101 rte */
5744 if (trace)
5745 {
5746 printf ("\033[33m%s\033[0m %02x %02x\n",
5747 "/** 0111 1111 1001 0101 rte */",
5748 op[0], op[1]);
5749 }
5750 SYNTAX("rte");
a117b0a5 5751#line 1022 "rx-decode.opc"
c7927a3c 5752 ID(rte);
43e65147 5753
c7927a3c
NC		 5754 }
5755 break;
5756 case 0x96:
5757 {
5758 /** 0111 1111 1001 0110 wait */
5759 if (trace)
5760 {
5761 printf ("\033[33m%s\033[0m %02x %02x\n",
5762 "/** 0111 1111 1001 0110 wait */",
5763 op[0], op[1]);
5764 }
5765 SYNTAX("wait");
a117b0a5 5766#line 1034 "rx-decode.opc"
c7927a3c 5767 ID(wait);
43e65147 5768
c7927a3c
NC		 5769 /*----------------------------------------------------------------------*/
5770 /* SCcnd */
43e65147 5771
c7927a3c
NC		 5772 }
5773 break;
5774 case 0xa0:
5775 case 0xa1:
5776 case 0xa2:
5777 case 0xa3:
5778 case 0xa4:
5779 case 0xa5:
5780 case 0xa6:
5781 case 0xa7:
5782 case 0xa8:
5783 case 0xa9:
5784 case 0xaa:
5785 case 0xab:
5786 case 0xac:
5787 case 0xad:
5788 case 0xae:
5789 case 0xaf:
5790 {
5791 /** 0111 1111 1010 rdst setpsw %0 */
a117b0a5 5792#line 995 "rx-decode.opc"
c7927a3c
NC		 5793 int rdst AU = op[1] & 0x0f;
5794 if (trace)
5795 {
5796 printf ("\033[33m%s\033[0m %02x %02x\n",
5797 "/** 0111 1111 1010 rdst setpsw %0 */",
5798 op[0], op[1]);
5799 printf (" rdst = 0x%x\n", rdst);
5800 }
5801 SYNTAX("setpsw %0");
a117b0a5 5802#line 995 "rx-decode.opc"
c7927a3c 5803 ID(setpsw); DF(rdst);
43e65147 5804
c7927a3c
NC		 5805 }
5806 break;
5807 case 0xb0:
5808 case 0xb1:
5809 case 0xb2:
5810 case 0xb3:
5811 case 0xb4:
5812 case 0xb5:
5813 case 0xb6:
5814 case 0xb7:
5815 case 0xb8:
5816 case 0xb9:
5817 case 0xba:
5818 case 0xbb:
5819 case 0xbc:
5820 case 0xbd:
5821 case 0xbe:
5822 case 0xbf:
5823 {
5824 /** 0111 1111 1011 rdst clrpsw %0 */
a117b0a5 5825#line 992 "rx-decode.opc"
c7927a3c
NC		 5826 int rdst AU = op[1] & 0x0f;
5827 if (trace)
5828 {
5829 printf ("\033[33m%s\033[0m %02x %02x\n",
5830 "/** 0111 1111 1011 rdst clrpsw %0 */",
5831 op[0], op[1]);
5832 printf (" rdst = 0x%x\n", rdst);
5833 }
5834 SYNTAX("clrpsw %0");
a117b0a5 5835#line 992 "rx-decode.opc"
c7927a3c 5836 ID(clrpsw); DF(rdst);
43e65147 5837
c7927a3c
NC		 5838 }
5839 break;
5840 default: UNSUPPORTED(); break;
5841 }
5842 break;
5843 case 0x80:
5844 GETBYTE ();
5845 switch (op[1] & 0x00)
5846 {
5847 case 0x00:
a117b0a5 5848 op_semantics_39:
c7927a3c
NC		 5849 {
5850 /** 10sz 0dsp a dst b src mov%s %1, %0 */
b8985e5c 5851#line 332 "rx-decode.opc"
c7927a3c 5852 int sz AU = (op[0] >> 4) & 0x03;
b8985e5c 5853#line 332 "rx-decode.opc"
c7927a3c 5854 int dsp AU = op[0] & 0x07;
b8985e5c 5855#line 332 "rx-decode.opc"
c7927a3c 5856 int a AU = (op[1] >> 7) & 0x01;
b8985e5c 5857#line 332 "rx-decode.opc"
c7927a3c 5858 int dst AU = (op[1] >> 4) & 0x07;
b8985e5c 5859#line 332 "rx-decode.opc"
c7927a3c 5860 int b AU = (op[1] >> 3) & 0x01;
b8985e5c 5861#line 332 "rx-decode.opc"
c7927a3c
NC		 5862 int src AU = op[1] & 0x07;
5863 if (trace)
5864 {
5865 printf ("\033[33m%s\033[0m %02x %02x\n",
5866 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5867 op[0], op[1]);
5868 printf (" sz = 0x%x,", sz);
5869 printf (" dsp = 0x%x,", dsp);
5870 printf (" a = 0x%x,", a);
5871 printf (" dst = 0x%x,", dst);
5872 printf (" b = 0x%x,", b);
5873 printf (" src = 0x%x\n", src);
5874 }
5875 SYNTAX("mov%s %1, %0");
b8985e5c 5876#line 332 "rx-decode.opc"
3cf79a01 5877 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
43e65147 5878
c7927a3c
NC		 5879 }
5880 break;
5881 }
5882 break;
5883 case 0x81:
5884 GETBYTE ();
5885 switch (op[1] & 0x00)
5886 {
5887 case 0x00:
a117b0a5 5888 goto op_semantics_39;
c7927a3c
NC		 5889 break;
5890 }
5891 break;
5892 case 0x82:
5893 GETBYTE ();
5894 switch (op[1] & 0x00)
5895 {
5896 case 0x00:
a117b0a5 5897 goto op_semantics_39;
c7927a3c
NC		 5898 break;
5899 }
5900 break;
5901 case 0x83:
5902 GETBYTE ();
5903 switch (op[1] & 0x00)
5904 {
5905 case 0x00:
a117b0a5 5906 goto op_semantics_39;
c7927a3c
NC		 5907 break;
5908 }
5909 break;
5910 case 0x84:
5911 GETBYTE ();
5912 switch (op[1] & 0x00)
5913 {
5914 case 0x00:
a117b0a5 5915 goto op_semantics_39;
c7927a3c
NC		 5916 break;
5917 }
5918 break;
5919 case 0x85:
5920 GETBYTE ();
5921 switch (op[1] & 0x00)
5922 {
5923 case 0x00:
a117b0a5 5924 goto op_semantics_39;
c7927a3c
NC		 5925 break;
5926 }
5927 break;
5928 case 0x86:
5929 GETBYTE ();
5930 switch (op[1] & 0x00)
5931 {
5932 case 0x00:
a117b0a5 5933 goto op_semantics_39;
c7927a3c
NC		 5934 break;
5935 }
5936 break;
5937 case 0x87:
5938 GETBYTE ();
5939 switch (op[1] & 0x00)
5940 {
5941 case 0x00:
a117b0a5 5942 goto op_semantics_39;
c7927a3c
NC		 5943 break;
5944 }
5945 break;
5946 case 0x88:
5947 GETBYTE ();
5948 switch (op[1] & 0x00)
5949 {
5950 case 0x00:
a117b0a5 5951 op_semantics_40:
c7927a3c
NC		 5952 {
5953 /** 10sz 1dsp a src b dst mov%s %1, %0 */
b8985e5c 5954#line 329 "rx-decode.opc"
c7927a3c 5955 int sz AU = (op[0] >> 4) & 0x03;
b8985e5c 5956#line 329 "rx-decode.opc"
c7927a3c 5957 int dsp AU = op[0] & 0x07;
b8985e5c 5958#line 329 "rx-decode.opc"
c7927a3c 5959 int a AU = (op[1] >> 7) & 0x01;
b8985e5c 5960#line 329 "rx-decode.opc"
c7927a3c 5961 int src AU = (op[1] >> 4) & 0x07;
b8985e5c 5962#line 329 "rx-decode.opc"
c7927a3c 5963 int b AU = (op[1] >> 3) & 0x01;
b8985e5c 5964#line 329 "rx-decode.opc"
c7927a3c
NC		 5965 int dst AU = op[1] & 0x07;
5966 if (trace)
5967 {
5968 printf ("\033[33m%s\033[0m %02x %02x\n",
5969 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5970 op[0], op[1]);
5971 printf (" sz = 0x%x,", sz);
5972 printf (" dsp = 0x%x,", dsp);
5973 printf (" a = 0x%x,", a);
5974 printf (" src = 0x%x,", src);
5975 printf (" b = 0x%x,", b);
5976 printf (" dst = 0x%x\n", dst);
5977 }
5978 SYNTAX("mov%s %1, %0");
b8985e5c 5979#line 329 "rx-decode.opc"
3cf79a01 5980 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
43e65147 5981
c7927a3c
NC		 5982 }
5983 break;
5984 }
5985 break;
5986 case 0x89:
5987 GETBYTE ();
5988 switch (op[1] & 0x00)
5989 {
5990 case 0x00:
a117b0a5 5991 goto op_semantics_40;
c7927a3c
NC		 5992 break;
5993 }
5994 break;
5995 case 0x8a:
5996 GETBYTE ();
5997 switch (op[1] & 0x00)
5998 {
5999 case 0x00:
a117b0a5 6000 goto op_semantics_40;
c7927a3c
NC		 6001 break;
6002 }
6003 break;
6004 case 0x8b:
6005 GETBYTE ();
6006 switch (op[1] & 0x00)
6007 {
6008 case 0x00:
a117b0a5 6009 goto op_semantics_40;
c7927a3c
NC		 6010 break;
6011 }
6012 break;
6013 case 0x8c:
6014 GETBYTE ();
6015 switch (op[1] & 0x00)
6016 {
6017 case 0x00:
a117b0a5 6018 goto op_semantics_40;
c7927a3c
NC		 6019 break;
6020 }
6021 break;
6022 case 0x8d:
6023 GETBYTE ();
6024 switch (op[1] & 0x00)
6025 {
6026 case 0x00:
a117b0a5 6027 goto op_semantics_40;
c7927a3c
NC		 6028 break;
6029 }
6030 break;
6031 case 0x8e:
6032 GETBYTE ();
6033 switch (op[1] & 0x00)
6034 {
6035 case 0x00:
a117b0a5 6036 goto op_semantics_40;
c7927a3c
NC		 6037 break;
6038 }
6039 break;
6040 case 0x8f:
6041 GETBYTE ();
6042 switch (op[1] & 0x00)
6043 {
6044 case 0x00:
a117b0a5 6045 goto op_semantics_40;
c7927a3c
NC		 6046 break;
6047 }
6048 break;
6049 case 0x90:
6050 GETBYTE ();
6051 switch (op[1] & 0x00)
6052 {
6053 case 0x00:
a117b0a5 6054 goto op_semantics_39;
c7927a3c
NC		 6055 break;
6056 }
6057 break;
6058 case 0x91:
6059 GETBYTE ();
6060 switch (op[1] & 0x00)
6061 {
6062 case 0x00:
a117b0a5 6063 goto op_semantics_39;
c7927a3c
NC		 6064 break;
6065 }
6066 break;
6067 case 0x92:
6068 GETBYTE ();
6069 switch (op[1] & 0x00)
6070 {
6071 case 0x00:
a117b0a5 6072 goto op_semantics_39;
c7927a3c
NC		 6073 break;
6074 }
6075 break;
6076 case 0x93:
6077 GETBYTE ();
6078 switch (op[1] & 0x00)
6079 {
6080 case 0x00:
a117b0a5 6081 goto op_semantics_39;
c7927a3c
NC		 6082 break;
6083 }
6084 break;
6085 case 0x94:
6086 GETBYTE ();
6087 switch (op[1] & 0x00)
6088 {
6089 case 0x00:
a117b0a5 6090 goto op_semantics_39;
c7927a3c
NC		 6091 break;
6092 }
6093 break;
6094 case 0x95:
6095 GETBYTE ();
6096 switch (op[1] & 0x00)
6097 {
6098 case 0x00:
a117b0a5 6099 goto op_semantics_39;
c7927a3c
NC		 6100 break;
6101 }
6102 break;
6103 case 0x96:
6104 GETBYTE ();
6105 switch (op[1] & 0x00)
6106 {
6107 case 0x00:
a117b0a5 6108 goto op_semantics_39;
c7927a3c
NC		 6109 break;
6110 }
6111 break;
6112 case 0x97:
6113 GETBYTE ();
6114 switch (op[1] & 0x00)
6115 {
6116 case 0x00:
a117b0a5 6117 goto op_semantics_39;
c7927a3c
NC		 6118 break;
6119 }
6120 break;
6121 case 0x98:
6122 GETBYTE ();
6123 switch (op[1] & 0x00)
6124 {
6125 case 0x00:
a117b0a5 6126 goto op_semantics_40;
c7927a3c
NC		 6127 break;
6128 }
6129 break;
6130 case 0x99:
6131 GETBYTE ();
6132 switch (op[1] & 0x00)
6133 {
6134 case 0x00:
a117b0a5 6135 goto op_semantics_40;
c7927a3c
NC		 6136 break;
6137 }
6138 break;
6139 case 0x9a:
6140 GETBYTE ();
6141 switch (op[1] & 0x00)
6142 {
6143 case 0x00:
a117b0a5 6144 goto op_semantics_40;
c7927a3c
NC		 6145 break;
6146 }
6147 break;
6148 case 0x9b:
6149 GETBYTE ();
6150 switch (op[1] & 0x00)
6151 {
6152 case 0x00:
a117b0a5 6153 goto op_semantics_40;
c7927a3c
NC		 6154 break;
6155 }
6156 break;
6157 case 0x9c:
6158 GETBYTE ();
6159 switch (op[1] & 0x00)
6160 {
6161 case 0x00:
a117b0a5 6162 goto op_semantics_40;
c7927a3c
NC		 6163 break;
6164 }
6165 break;
6166 case 0x9d:
6167 GETBYTE ();
6168 switch (op[1] & 0x00)
6169 {
6170 case 0x00:
a117b0a5 6171 goto op_semantics_40;
c7927a3c
NC		 6172 break;
6173 }
6174 break;
6175 case 0x9e:
6176 GETBYTE ();
6177 switch (op[1] & 0x00)
6178 {
6179 case 0x00:
a117b0a5 6180 goto op_semantics_40;
c7927a3c
NC		 6181 break;
6182 }
6183 break;
6184 case 0x9f:
6185 GETBYTE ();
6186 switch (op[1] & 0x00)
6187 {
6188 case 0x00:
a117b0a5 6189 goto op_semantics_40;
c7927a3c
NC		 6190 break;
6191 }
6192 break;
6193 case 0xa0:
6194 GETBYTE ();
6195 switch (op[1] & 0x00)
6196 {
6197 case 0x00:
a117b0a5 6198 goto op_semantics_39;
c7927a3c
NC		 6199 break;
6200 }
6201 break;
6202 case 0xa1:
6203 GETBYTE ();
6204 switch (op[1] & 0x00)
6205 {
6206 case 0x00:
a117b0a5 6207 goto op_semantics_39;
c7927a3c
NC		 6208 break;
6209 }
6210 break;
6211 case 0xa2:
6212 GETBYTE ();
6213 switch (op[1] & 0x00)
6214 {
6215 case 0x00:
a117b0a5 6216 goto op_semantics_39;
c7927a3c
NC		 6217 break;
6218 }
6219 break;
6220 case 0xa3:
6221 GETBYTE ();
6222 switch (op[1] & 0x00)
6223 {
6224 case 0x00:
a117b0a5 6225 goto op_semantics_39;
c7927a3c
NC		 6226 break;
6227 }
6228 break;
6229 case 0xa4:
6230 GETBYTE ();
6231 switch (op[1] & 0x00)
6232 {
6233 case 0x00:
a117b0a5 6234 goto op_semantics_39;
c7927a3c
NC		 6235 break;
6236 }
6237 break;
6238 case 0xa5:
6239 GETBYTE ();
6240 switch (op[1] & 0x00)
6241 {
6242 case 0x00:
a117b0a5 6243 goto op_semantics_39;
c7927a3c
NC		 6244 break;
6245 }
6246 break;
6247 case 0xa6:
6248 GETBYTE ();
6249 switch (op[1] & 0x00)
6250 {
6251 case 0x00:
a117b0a5 6252 goto op_semantics_39;
c7927a3c
NC		 6253 break;
6254 }
6255 break;
6256 case 0xa7:
6257 GETBYTE ();
6258 switch (op[1] & 0x00)
6259 {
6260 case 0x00:
a117b0a5 6261 goto op_semantics_39;
c7927a3c
NC		 6262 break;
6263 }
6264 break;
6265 case 0xa8:
6266 GETBYTE ();
6267 switch (op[1] & 0x00)
6268 {
6269 case 0x00:
a117b0a5 6270 goto op_semantics_40;
c7927a3c
NC		 6271 break;
6272 }
6273 break;
6274 case 0xa9:
6275 GETBYTE ();
6276 switch (op[1] & 0x00)
6277 {
6278 case 0x00:
a117b0a5 6279 goto op_semantics_40;
c7927a3c
NC		 6280 break;
6281 }
6282 break;
6283 case 0xaa:
6284 GETBYTE ();
6285 switch (op[1] & 0x00)
6286 {
6287 case 0x00:
a117b0a5 6288 goto op_semantics_40;
c7927a3c
NC		 6289 break;
6290 }
6291 break;
6292 case 0xab:
6293 GETBYTE ();
6294 switch (op[1] & 0x00)
6295 {
6296 case 0x00:
a117b0a5 6297 goto op_semantics_40;
c7927a3c
NC		 6298 break;
6299 }
6300 break;
6301 case 0xac:
6302 GETBYTE ();
6303 switch (op[1] & 0x00)
6304 {
6305 case 0x00:
a117b0a5 6306 goto op_semantics_40;
c7927a3c
NC		 6307 break;
6308 }
6309 break;
6310 case 0xad:
6311 GETBYTE ();
6312 switch (op[1] & 0x00)
6313 {
6314 case 0x00:
a117b0a5 6315 goto op_semantics_40;
c7927a3c
NC		 6316 break;
6317 }
6318 break;
6319 case 0xae:
6320 GETBYTE ();
6321 switch (op[1] & 0x00)
6322 {
6323 case 0x00:
a117b0a5 6324 goto op_semantics_40;
c7927a3c
NC		 6325 break;
6326 }
6327 break;
6328 case 0xaf:
6329 GETBYTE ();
6330 switch (op[1] & 0x00)
6331 {
6332 case 0x00:
a117b0a5 6333 goto op_semantics_40;
c7927a3c
NC		 6334 break;
6335 }
6336 break;
6337 case 0xb0:
6338 GETBYTE ();
6339 switch (op[1] & 0x00)
6340 {
6341 case 0x00:
a117b0a5 6342 op_semantics_41:
c7927a3c
NC		 6343 {
6344 /** 1011 w dsp a src b dst movu%s %1, %0 */
b8985e5c 6345#line 352 "rx-decode.opc"
c7927a3c 6346 int w AU = (op[0] >> 3) & 0x01;
b8985e5c 6347#line 352 "rx-decode.opc"
c7927a3c 6348 int dsp AU = op[0] & 0x07;
b8985e5c 6349#line 352 "rx-decode.opc"
c7927a3c 6350 int a AU = (op[1] >> 7) & 0x01;
b8985e5c 6351#line 352 "rx-decode.opc"
c7927a3c 6352 int src AU = (op[1] >> 4) & 0x07;
b8985e5c 6353#line 352 "rx-decode.opc"
c7927a3c 6354 int b AU = (op[1] >> 3) & 0x01;
b8985e5c 6355#line 352 "rx-decode.opc"
c7927a3c
NC		 6356 int dst AU = op[1] & 0x07;
6357 if (trace)
6358 {
6359 printf ("\033[33m%s\033[0m %02x %02x\n",
6360 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6361 op[0], op[1]);
6362 printf (" w = 0x%x,", w);
6363 printf (" dsp = 0x%x,", dsp);
6364 printf (" a = 0x%x,", a);
6365 printf (" src = 0x%x,", src);
6366 printf (" b = 0x%x,", b);
6367 printf (" dst = 0x%x\n", dst);
6368 }
6369 SYNTAX("movu%s %1, %0");
b8985e5c 6370#line 352 "rx-decode.opc"
f04265ec 6371 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
43e65147 6372
c7927a3c
NC		 6373 }
6374 break;
6375 }
6376 break;
6377 case 0xb1:
6378 GETBYTE ();
6379 switch (op[1] & 0x00)
6380 {
6381 case 0x00:
a117b0a5 6382 goto op_semantics_41;
c7927a3c
NC		 6383 break;
6384 }
6385 break;
6386 case 0xb2:
6387 GETBYTE ();
6388 switch (op[1] & 0x00)
6389 {
6390 case 0x00:
a117b0a5 6391 goto op_semantics_41;
c7927a3c
NC		 6392 break;
6393 }
6394 break;
6395 case 0xb3:
6396 GETBYTE ();
6397 switch (op[1] & 0x00)
6398 {
6399 case 0x00:
a117b0a5 6400 goto op_semantics_41;
c7927a3c
NC		 6401 break;
6402 }
6403 break;
6404 case 0xb4:
6405 GETBYTE ();
6406 switch (op[1] & 0x00)
6407 {
6408 case 0x00:
a117b0a5 6409 goto op_semantics_41;
c7927a3c
NC		 6410 break;
6411 }
6412 break;
6413 case 0xb5:
6414 GETBYTE ();
6415 switch (op[1] & 0x00)
6416 {
6417 case 0x00:
a117b0a5 6418 goto op_semantics_41;
c7927a3c
NC		 6419 break;
6420 }
6421 break;
6422 case 0xb6:
6423 GETBYTE ();
6424 switch (op[1] & 0x00)
6425 {
6426 case 0x00:
a117b0a5 6427 goto op_semantics_41;
c7927a3c
NC		 6428 break;
6429 }
6430 break;
6431 case 0xb7:
6432 GETBYTE ();
6433 switch (op[1] & 0x00)
6434 {
6435 case 0x00:
a117b0a5 6436 goto op_semantics_41;
c7927a3c
NC		 6437 break;
6438 }
6439 break;
6440 case 0xb8:
6441 GETBYTE ();
6442 switch (op[1] & 0x00)
6443 {
6444 case 0x00:
a117b0a5 6445 goto op_semantics_41;
c7927a3c
NC		 6446 break;
6447 }
6448 break;
6449 case 0xb9:
6450 GETBYTE ();
6451 switch (op[1] & 0x00)
6452 {
6453 case 0x00:
a117b0a5 6454 goto op_semantics_41;
c7927a3c
NC		 6455 break;
6456 }
6457 break;
6458 case 0xba:
6459 GETBYTE ();
6460 switch (op[1] & 0x00)
6461 {
6462 case 0x00:
a117b0a5 6463 goto op_semantics_41;
c7927a3c
NC		 6464 break;
6465 }
6466 break;
6467 case 0xbb:
6468 GETBYTE ();
6469 switch (op[1] & 0x00)
6470 {
6471 case 0x00:
a117b0a5 6472 goto op_semantics_41;
c7927a3c
NC		 6473 break;
6474 }
6475 break;
6476 case 0xbc:
6477 GETBYTE ();
6478 switch (op[1] & 0x00)
6479 {
6480 case 0x00:
a117b0a5 6481 goto op_semantics_41;
c7927a3c
NC		 6482 break;
6483 }
6484 break;
6485 case 0xbd:
6486 GETBYTE ();
6487 switch (op[1] & 0x00)
6488 {
6489 case 0x00:
a117b0a5 6490 goto op_semantics_41;
c7927a3c
NC		 6491 break;
6492 }
6493 break;
6494 case 0xbe:
6495 GETBYTE ();
6496 switch (op[1] & 0x00)
6497 {
6498 case 0x00:
a117b0a5 6499 goto op_semantics_41;
c7927a3c
NC		 6500 break;
6501 }
6502 break;
6503 case 0xbf:
6504 GETBYTE ();
6505 switch (op[1] & 0x00)
6506 {
6507 case 0x00:
a117b0a5 6508 goto op_semantics_41;
c7927a3c
NC		 6509 break;
6510 }
6511 break;
6512 case 0xc0:
6513 GETBYTE ();
6514 switch (op[1] & 0x00)
6515 {
6516 case 0x00:
a117b0a5 6517 op_semantics_42:
c7927a3c
NC		 6518 {
6519 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
b8985e5c 6520#line 310 "rx-decode.opc"
c7927a3c 6521 int sz AU = (op[0] >> 4) & 0x03;
b8985e5c 6522#line 310 "rx-decode.opc"
c7927a3c 6523 int sd AU = (op[0] >> 2) & 0x03;
b8985e5c 6524#line 310 "rx-decode.opc"
c7927a3c 6525 int ss AU = op[0] & 0x03;
b8985e5c 6526#line 310 "rx-decode.opc"
c7927a3c 6527 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 6528#line 310 "rx-decode.opc"
c7927a3c
NC		 6529 int rdst AU = op[1] & 0x0f;
6530 if (trace)
6531 {
6532 printf ("\033[33m%s\033[0m %02x %02x\n",
6533 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6534 op[0], op[1]);
6535 printf (" sz = 0x%x,", sz);
6536 printf (" sd = 0x%x,", sd);
6537 printf (" ss = 0x%x,", ss);
6538 printf (" rsrc = 0x%x,", rsrc);
6539 printf (" rdst = 0x%x\n", rdst);
6540 }
6541 SYNTAX("mov%s %1, %0");
b8985e5c 6542#line 310 "rx-decode.opc"
b5e04c2b 6543 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
c7927a3c 6544 {
f9c7014e 6545 ID(nop2);
854eb72b 6546 SYNTAX ("nop\t; mov.l\tr0, r0");
c7927a3c
NC		 6547 }
6548 else
6549 {
f9c7014e
DD		 6550 ID(mov); sBWL(sz); F_____;
6551 if ((ss == 3) && (sd != 3))
a117b0a5
YS		 6552 {
6553 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6554 }
f9c7014e 6555 else
a117b0a5
YS		 6556 {
6557 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6558 }
c7927a3c 6559 }
43e65147 6560
c7927a3c
NC		 6561 }
6562 break;
6563 }
6564 break;
6565 case 0xc1:
6566 GETBYTE ();
6567 switch (op[1] & 0x00)
6568 {
6569 case 0x00:
a117b0a5 6570 goto op_semantics_42;
c7927a3c
NC		 6571 break;
6572 }
6573 break;
6574 case 0xc2:
6575 GETBYTE ();
6576 switch (op[1] & 0x00)
6577 {
6578 case 0x00:
a117b0a5 6579 goto op_semantics_42;
c7927a3c
NC		 6580 break;
6581 }
6582 break;
6583 case 0xc3:
6584 GETBYTE ();
6585 switch (op[1] & 0x00)
6586 {
6587 case 0x00:
a117b0a5 6588 goto op_semantics_42;
c7927a3c
NC		 6589 break;
6590 }
6591 break;
6592 case 0xc4:
6593 GETBYTE ();
6594 switch (op[1] & 0x00)
6595 {
6596 case 0x00:
a117b0a5 6597 goto op_semantics_42;
c7927a3c
NC		 6598 break;
6599 }
6600 break;
6601 case 0xc5:
6602 GETBYTE ();
6603 switch (op[1] & 0x00)
6604 {
6605 case 0x00:
a117b0a5 6606 goto op_semantics_42;
c7927a3c
NC		 6607 break;
6608 }
6609 break;
6610 case 0xc6:
6611 GETBYTE ();
6612 switch (op[1] & 0x00)
6613 {
6614 case 0x00:
a117b0a5 6615 goto op_semantics_42;
c7927a3c
NC		 6616 break;
6617 }
6618 break;
6619 case 0xc7:
6620 GETBYTE ();
6621 switch (op[1] & 0x00)
6622 {
6623 case 0x00:
a117b0a5 6624 goto op_semantics_42;
c7927a3c
NC		 6625 break;
6626 }
6627 break;
6628 case 0xc8:
6629 GETBYTE ();
6630 switch (op[1] & 0x00)
6631 {
6632 case 0x00:
a117b0a5 6633 goto op_semantics_42;
c7927a3c
NC		 6634 break;
6635 }
6636 break;
6637 case 0xc9:
6638 GETBYTE ();
6639 switch (op[1] & 0x00)
6640 {
6641 case 0x00:
a117b0a5 6642 goto op_semantics_42;
c7927a3c
NC		 6643 break;
6644 }
6645 break;
6646 case 0xca:
6647 GETBYTE ();
6648 switch (op[1] & 0x00)
6649 {
6650 case 0x00:
a117b0a5 6651 goto op_semantics_42;
c7927a3c
NC		 6652 break;
6653 }
6654 break;
6655 case 0xcb:
6656 GETBYTE ();
6657 switch (op[1] & 0x00)
6658 {
6659 case 0x00:
a117b0a5 6660 goto op_semantics_42;
c7927a3c
NC		 6661 break;
6662 }
6663 break;
6664 case 0xcc:
6665 GETBYTE ();
6666 switch (op[1] & 0x00)
6667 {
6668 case 0x00:
a117b0a5 6669 goto op_semantics_42;
c7927a3c
NC		 6670 break;
6671 }
6672 break;
6673 case 0xcd:
6674 GETBYTE ();
6675 switch (op[1] & 0x00)
6676 {
6677 case 0x00:
a117b0a5 6678 goto op_semantics_42;
c7927a3c
NC		 6679 break;
6680 }
6681 break;
6682 case 0xce:
6683 GETBYTE ();
6684 switch (op[1] & 0x00)
6685 {
6686 case 0x00:
a117b0a5 6687 goto op_semantics_42;
c7927a3c
NC		 6688 break;
6689 }
6690 break;
6691 case 0xcf:
6692 GETBYTE ();
6693 switch (op[1] & 0x00)
6694 {
6695 case 0x00:
a117b0a5 6696 goto op_semantics_42;
c7927a3c
NC		 6697 break;
6698 }
6699 break;
6700 case 0xd0:
6701 GETBYTE ();
6702 switch (op[1] & 0x00)
6703 {
6704 case 0x00:
a117b0a5 6705 goto op_semantics_42;
c7927a3c
NC		 6706 break;
6707 }
6708 break;
6709 case 0xd1:
6710 GETBYTE ();
6711 switch (op[1] & 0x00)
6712 {
6713 case 0x00:
a117b0a5 6714 goto op_semantics_42;
c7927a3c
NC		 6715 break;
6716 }
6717 break;
6718 case 0xd2:
6719 GETBYTE ();
6720 switch (op[1] & 0x00)
6721 {
6722 case 0x00:
a117b0a5 6723 goto op_semantics_42;
c7927a3c
NC		 6724 break;
6725 }
6726 break;
6727 case 0xd3:
6728 GETBYTE ();
6729 switch (op[1] & 0x00)
6730 {
6731 case 0x00:
a117b0a5 6732 goto op_semantics_42;
c7927a3c
NC		 6733 break;
6734 }
6735 break;
6736 case 0xd4:
6737 GETBYTE ();
6738 switch (op[1] & 0x00)
6739 {
6740 case 0x00:
a117b0a5 6741 goto op_semantics_42;
c7927a3c
NC		 6742 break;
6743 }
6744 break;
6745 case 0xd5:
6746 GETBYTE ();
6747 switch (op[1] & 0x00)
6748 {
6749 case 0x00:
a117b0a5 6750 goto op_semantics_42;
c7927a3c
NC		 6751 break;
6752 }
6753 break;
6754 case 0xd6:
6755 GETBYTE ();
6756 switch (op[1] & 0x00)
6757 {
6758 case 0x00:
a117b0a5 6759 goto op_semantics_42;
c7927a3c
NC		 6760 break;
6761 }
6762 break;
6763 case 0xd7:
6764 GETBYTE ();
6765 switch (op[1] & 0x00)
6766 {
6767 case 0x00:
a117b0a5 6768 goto op_semantics_42;
c7927a3c
NC		 6769 break;
6770 }
6771 break;
6772 case 0xd8:
6773 GETBYTE ();
6774 switch (op[1] & 0x00)
6775 {
6776 case 0x00:
a117b0a5 6777 goto op_semantics_42;
c7927a3c
NC		 6778 break;
6779 }
6780 break;
6781 case 0xd9:
6782 GETBYTE ();
6783 switch (op[1] & 0x00)
6784 {
6785 case 0x00:
a117b0a5 6786 goto op_semantics_42;
c7927a3c
NC		 6787 break;
6788 }
6789 break;
6790 case 0xda:
6791 GETBYTE ();
6792 switch (op[1] & 0x00)
6793 {
6794 case 0x00:
a117b0a5 6795 goto op_semantics_42;
c7927a3c
NC		 6796 break;
6797 }
6798 break;
6799 case 0xdb:
6800 GETBYTE ();
6801 switch (op[1] & 0x00)
6802 {
6803 case 0x00:
a117b0a5 6804 goto op_semantics_42;
c7927a3c
NC		 6805 break;
6806 }
6807 break;
6808 case 0xdc:
6809 GETBYTE ();
6810 switch (op[1] & 0x00)
6811 {
6812 case 0x00:
a117b0a5 6813 goto op_semantics_42;
c7927a3c
NC		 6814 break;
6815 }
6816 break;
6817 case 0xdd:
6818 GETBYTE ();
6819 switch (op[1] & 0x00)
6820 {
6821 case 0x00:
a117b0a5 6822 goto op_semantics_42;
c7927a3c
NC		 6823 break;
6824 }
6825 break;
6826 case 0xde:
6827 GETBYTE ();
6828 switch (op[1] & 0x00)
6829 {
6830 case 0x00:
a117b0a5 6831 goto op_semantics_42;
c7927a3c
NC		 6832 break;
6833 }
6834 break;
6835 case 0xdf:
6836 GETBYTE ();
6837 switch (op[1] & 0x00)
6838 {
6839 case 0x00:
a117b0a5 6840 goto op_semantics_42;
c7927a3c
NC		 6841 break;
6842 }
6843 break;
6844 case 0xe0:
6845 GETBYTE ();
6846 switch (op[1] & 0x00)
6847 {
6848 case 0x00:
a117b0a5 6849 goto op_semantics_42;
c7927a3c
NC		 6850 break;
6851 }
6852 break;
6853 case 0xe1:
6854 GETBYTE ();
6855 switch (op[1] & 0x00)
6856 {
6857 case 0x00:
a117b0a5 6858 goto op_semantics_42;
c7927a3c
NC		 6859 break;
6860 }
6861 break;
6862 case 0xe2:
6863 GETBYTE ();
6864 switch (op[1] & 0x00)
6865 {
6866 case 0x00:
a117b0a5 6867 goto op_semantics_42;
c7927a3c
NC		 6868 break;
6869 }
6870 break;
6871 case 0xe3:
6872 GETBYTE ();
6873 switch (op[1] & 0x00)
6874 {
6875 case 0x00:
a117b0a5 6876 goto op_semantics_42;
c7927a3c
NC		 6877 break;
6878 }
6879 break;
6880 case 0xe4:
6881 GETBYTE ();
6882 switch (op[1] & 0x00)
6883 {
6884 case 0x00:
a117b0a5 6885 goto op_semantics_42;
c7927a3c
NC		 6886 break;
6887 }
6888 break;
6889 case 0xe5:
6890 GETBYTE ();
6891 switch (op[1] & 0x00)
6892 {
6893 case 0x00:
a117b0a5 6894 goto op_semantics_42;
c7927a3c
NC		 6895 break;
6896 }
6897 break;
6898 case 0xe6:
6899 GETBYTE ();
6900 switch (op[1] & 0x00)
6901 {
6902 case 0x00:
a117b0a5 6903 goto op_semantics_42;
c7927a3c
NC		 6904 break;
6905 }
6906 break;
6907 case 0xe7:
6908 GETBYTE ();
6909 switch (op[1] & 0x00)
6910 {
6911 case 0x00:
a117b0a5 6912 goto op_semantics_42;
c7927a3c
NC		 6913 break;
6914 }
6915 break;
6916 case 0xe8:
6917 GETBYTE ();
6918 switch (op[1] & 0x00)
6919 {
6920 case 0x00:
a117b0a5 6921 goto op_semantics_42;
c7927a3c
NC		 6922 break;
6923 }
6924 break;
6925 case 0xe9:
6926 GETBYTE ();
6927 switch (op[1] & 0x00)
6928 {
6929 case 0x00:
a117b0a5 6930 goto op_semantics_42;
c7927a3c
NC		 6931 break;
6932 }
6933 break;
6934 case 0xea:
6935 GETBYTE ();
6936 switch (op[1] & 0x00)
6937 {
6938 case 0x00:
a117b0a5 6939 goto op_semantics_42;
c7927a3c
NC		 6940 break;
6941 }
6942 break;
6943 case 0xeb:
6944 GETBYTE ();
6945 switch (op[1] & 0x00)
6946 {
6947 case 0x00:
a117b0a5 6948 goto op_semantics_42;
c7927a3c
NC		 6949 break;
6950 }
6951 break;
6952 case 0xec:
6953 GETBYTE ();
6954 switch (op[1] & 0x00)
6955 {
6956 case 0x00:
a117b0a5 6957 goto op_semantics_42;
c7927a3c
NC		 6958 break;
6959 }
6960 break;
6961 case 0xed:
6962 GETBYTE ();
6963 switch (op[1] & 0x00)
6964 {
6965 case 0x00:
a117b0a5 6966 goto op_semantics_42;
c7927a3c
NC		 6967 break;
6968 }
6969 break;
6970 case 0xee:
6971 GETBYTE ();
6972 switch (op[1] & 0x00)
6973 {
6974 case 0x00:
a117b0a5 6975 goto op_semantics_42;
c7927a3c
NC		 6976 break;
6977 }
6978 break;
6979 case 0xef:
6980 GETBYTE ();
6981 switch (op[1] & 0x00)
6982 {
6983 case 0x00:
a117b0a5 6984 goto op_semantics_42;
c7927a3c
NC		 6985 break;
6986 }
6987 break;
6988 case 0xf0:
6989 GETBYTE ();
6990 switch (op[1] & 0x08)
6991 {
6992 case 0x00:
a117b0a5 6993 op_semantics_43:
c7927a3c
NC		 6994 {
6995 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
a117b0a5 6996#line 935 "rx-decode.opc"
c7927a3c 6997 int sd AU = op[0] & 0x03;
a117b0a5 6998#line 935 "rx-decode.opc"
c7927a3c 6999 int rdst AU = (op[1] >> 4) & 0x0f;
a117b0a5 7000#line 935 "rx-decode.opc"
c7927a3c
NC		 7001 int bit AU = op[1] & 0x07;
7002 if (trace)
7003 {
7004 printf ("\033[33m%s\033[0m %02x %02x\n",
7005 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
7006 op[0], op[1]);
7007 printf (" sd = 0x%x,", sd);
7008 printf (" rdst = 0x%x,", rdst);
7009 printf (" bit = 0x%x\n", bit);
7010 }
7011 SYNTAX("bset #%1, %0%S0");
a117b0a5 7012#line 935 "rx-decode.opc"
3cf79a01 7013 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
43e65147 7014
c7927a3c
NC		 7015 }
7016 break;
7017 case 0x08:
a117b0a5 7018 op_semantics_44:
c7927a3c
NC		 7019 {
7020 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
a117b0a5 7021#line 947 "rx-decode.opc"
c7927a3c 7022 int sd AU = op[0] & 0x03;
a117b0a5 7023#line 947 "rx-decode.opc"
c7927a3c 7024 int rdst AU = (op[1] >> 4) & 0x0f;
a117b0a5 7025#line 947 "rx-decode.opc"
c7927a3c
NC		 7026 int bit AU = op[1] & 0x07;
7027 if (trace)
7028 {
7029 printf ("\033[33m%s\033[0m %02x %02x\n",
7030 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
7031 op[0], op[1]);
7032 printf (" sd = 0x%x,", sd);
7033 printf (" rdst = 0x%x,", rdst);
7034 printf (" bit = 0x%x\n", bit);
7035 }
7036 SYNTAX("bclr #%1, %0%S0");
a117b0a5 7037#line 947 "rx-decode.opc"
3cf79a01 7038 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
43e65147 7039
c7927a3c
NC		 7040 }
7041 break;
7042 }
7043 break;
7044 case 0xf1:
7045 GETBYTE ();
7046 switch (op[1] & 0x08)
7047 {
7048 case 0x00:
a117b0a5 7049 goto op_semantics_43;
c7927a3c
NC		 7050 break;
7051 case 0x08:
a117b0a5 7052 goto op_semantics_44;
c7927a3c
NC		 7053 break;
7054 }
7055 break;
7056 case 0xf2:
7057 GETBYTE ();
7058 switch (op[1] & 0x08)
7059 {
7060 case 0x00:
a117b0a5 7061 goto op_semantics_43;
c7927a3c
NC		 7062 break;
7063 case 0x08:
a117b0a5 7064 goto op_semantics_44;
c7927a3c
NC		 7065 break;
7066 }
7067 break;
7068 case 0xf3:
7069 GETBYTE ();
7070 switch (op[1] & 0x08)
7071 {
7072 case 0x00:
a117b0a5 7073 goto op_semantics_43;
c7927a3c
NC		 7074 break;
7075 case 0x08:
a117b0a5 7076 goto op_semantics_44;
c7927a3c
NC		 7077 break;
7078 }
7079 break;
7080 case 0xf4:
7081 GETBYTE ();
7082 switch (op[1] & 0x0c)
7083 {
7084 case 0x00:
7085 case 0x04:
a117b0a5 7086 op_semantics_45:
c7927a3c
NC		 7087 {
7088 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
a117b0a5 7089#line 959 "rx-decode.opc"
c7927a3c 7090 int sd AU = op[0] & 0x03;
a117b0a5 7091#line 959 "rx-decode.opc"
c7927a3c 7092 int rdst AU = (op[1] >> 4) & 0x0f;
a117b0a5 7093#line 959 "rx-decode.opc"
c7927a3c
NC		 7094 int bit AU = op[1] & 0x07;
7095 if (trace)
7096 {
7097 printf ("\033[33m%s\033[0m %02x %02x\n",
7098 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
7099 op[0], op[1]);
7100 printf (" sd = 0x%x,", sd);
7101 printf (" rdst = 0x%x,", rdst);
7102 printf (" bit = 0x%x\n", bit);
7103 }
7104 SYNTAX("btst #%2, %1%S1");
a117b0a5 7105#line 959 "rx-decode.opc"
3cf79a01 7106 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
43e65147 7107
c7927a3c
NC		 7108 }
7109 break;
7110 case 0x08:
a117b0a5 7111 op_semantics_46:
c7927a3c
NC		 7112 {
7113 /** 1111 01ss rsrc 10sz push%s %1 */
b8985e5c 7114#line 377 "rx-decode.opc"
c7927a3c 7115 int ss AU = op[0] & 0x03;
b8985e5c 7116#line 377 "rx-decode.opc"
c7927a3c 7117 int rsrc AU = (op[1] >> 4) & 0x0f;
b8985e5c 7118#line 377 "rx-decode.opc"
c7927a3c
NC		 7119 int sz AU = op[1] & 0x03;
7120 if (trace)
7121 {
7122 printf ("\033[33m%s\033[0m %02x %02x\n",
7123 "/** 1111 01ss rsrc 10sz push%s %1 */",
7124 op[0], op[1]);
7125 printf (" ss = 0x%x,", ss);
7126 printf (" rsrc = 0x%x,", rsrc);
7127 printf (" sz = 0x%x\n", sz);
7128 }
7129 SYNTAX("push%s %1");
b8985e5c 7130#line 377 "rx-decode.opc"
3cf79a01 7131 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
43e65147 7132
c7927a3c
NC		 7133 /*----------------------------------------------------------------------*/
7134 /* XCHG */
43e65147 7135
c7927a3c
NC		 7136 }
7137 break;
7138 default: UNSUPPORTED(); break;
7139 }
7140 break;
7141 case 0xf5:
7142 GETBYTE ();
7143 switch (op[1] & 0x0c)
7144 {
7145 case 0x00:
7146 case 0x04:
a117b0a5 7147 goto op_semantics_45;
c7927a3c
NC		 7148 break;
7149 case 0x08:
a117b0a5 7150 goto op_semantics_46;
c7927a3c
NC		 7151 break;
7152 default: UNSUPPORTED(); break;
7153 }
7154 break;
7155 case 0xf6:
7156 GETBYTE ();
7157 switch (op[1] & 0x0c)
7158 {
7159 case 0x00:
7160 case 0x04:
a117b0a5 7161 goto op_semantics_45;
c7927a3c
NC		 7162 break;
7163 case 0x08:
a117b0a5 7164 goto op_semantics_46;
c7927a3c
NC		 7165 break;
7166 default: UNSUPPORTED(); break;
7167 }
7168 break;
7169 case 0xf7:
7170 GETBYTE ();
7171 switch (op[1] & 0x0c)
7172 {
7173 case 0x00:
7174 case 0x04:
a117b0a5 7175 goto op_semantics_45;
c7927a3c
NC		 7176 break;
7177 case 0x08:
a117b0a5 7178 goto op_semantics_46;
c7927a3c
NC		 7179 break;
7180 default: UNSUPPORTED(); break;
7181 }
7182 break;
7183 case 0xf8:
7184 GETBYTE ();
7185 switch (op[1] & 0x00)
7186 {
7187 case 0x00:
a117b0a5 7188 op_semantics_47:
c7927a3c
NC		 7189 {
7190 /** 1111 10sd rdst im sz mov%s #%1, %0 */
b8985e5c 7191#line 288 "rx-decode.opc"
c7927a3c 7192 int sd AU = op[0] & 0x03;
b8985e5c 7193#line 288 "rx-decode.opc"
c7927a3c 7194 int rdst AU = (op[1] >> 4) & 0x0f;
b8985e5c 7195#line 288 "rx-decode.opc"
c7927a3c 7196 int im AU = (op[1] >> 2) & 0x03;
b8985e5c 7197#line 288 "rx-decode.opc"
c7927a3c
NC		 7198 int sz AU = op[1] & 0x03;
7199 if (trace)
7200 {
7201 printf ("\033[33m%s\033[0m %02x %02x\n",
7202 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
7203 op[0], op[1]);
7204 printf (" sd = 0x%x,", sd);
7205 printf (" rdst = 0x%x,", rdst);
7206 printf (" im = 0x%x,", im);
7207 printf (" sz = 0x%x\n", sz);
7208 }
7209 SYNTAX("mov%s #%1, %0");
b8985e5c 7210#line 288 "rx-decode.opc"
78e98aab
DD		 7211 ID(mov); DD(sd, rdst, sz);
7212 if ((im == 1 && sz == 0)
7213 || (im == 2 && sz == 1)
7214 || (im == 0 && sz == 2))
7215 {
7216 BWL (sz);
7217 SC(IMM(im));
7218 }
7219 else
7220 {
7221 sBWL (sz);
7222 SC(IMMex(im));
7223 }
7224 F_____;
43e65147 7225
c7927a3c
NC		 7226 }
7227 break;
7228 }
7229 break;
7230 case 0xf9:
7231 GETBYTE ();
7232 switch (op[1] & 0x00)
7233 {
7234 case 0x00:
a117b0a5 7235 goto op_semantics_47;
c7927a3c
NC		 7236 break;
7237 }
7238 break;
7239 case 0xfa:
7240 GETBYTE ();
7241 switch (op[1] & 0x00)
7242 {
7243 case 0x00:
a117b0a5 7244 goto op_semantics_47;
c7927a3c
NC		 7245 break;
7246 }
7247 break;
7248 case 0xfb:
7249 GETBYTE ();
7250 switch (op[1] & 0x00)
7251 {
7252 case 0x00:
a117b0a5 7253 goto op_semantics_47;
c7927a3c
NC		 7254 break;
7255 }
7256 break;
7257 case 0xfc:
7258 GETBYTE ();
7259 switch (op[1] & 0xff)
7260 {
7261 case 0x03:
7262 GETBYTE ();
7263 switch (op[2] & 0x00)
7264 {
7265 case 0x00:
7266 {
7267 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
b8985e5c 7268#line 551 "rx-decode.opc"
c7927a3c 7269 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7270#line 551 "rx-decode.opc"
c7927a3c
NC		 7271 int rdst AU = op[2] & 0x0f;
7272 if (trace)
7273 {
7274 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7275 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7276 op[0], op[1], op[2]);
7277 printf (" rsrc = 0x%x,", rsrc);
7278 printf (" rdst = 0x%x\n", rdst);
7279 }
7280 SYNTAX("sbb %1, %0");
b8985e5c 7281#line 551 "rx-decode.opc"
3cf79a01 7282 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
43e65147 7283
c7927a3c
NC		 7284 /* FIXME: only supports .L */
7285 }
7286 break;
7287 }
7288 break;
7289 case 0x07:
7290 GETBYTE ();
7291 switch (op[2] & 0x00)
7292 {
7293 case 0x00:
7294 {
7295 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
b8985e5c 7296#line 482 "rx-decode.opc"
c7927a3c 7297 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7298#line 482 "rx-decode.opc"
c7927a3c
NC		 7299 int rdst AU = op[2] & 0x0f;
7300 if (trace)
7301 {
7302 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7303 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7304 op[0], op[1], op[2]);
7305 printf (" rsrc = 0x%x,", rsrc);
7306 printf (" rdst = 0x%x\n", rdst);
7307 }
7308 SYNTAX("neg %2, %0");
b8985e5c 7309#line 482 "rx-decode.opc"
3cf79a01 7310 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
43e65147 7311
c7927a3c
NC		 7312 /*----------------------------------------------------------------------*/
7313 /* ADC */
43e65147 7314
c7927a3c
NC		 7315 }
7316 break;
7317 }
7318 break;
7319 case 0x0b:
7320 GETBYTE ();
7321 switch (op[2] & 0x00)
7322 {
7323 case 0x00:
7324 {
7325 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
b8985e5c 7326#line 491 "rx-decode.opc"
c7927a3c 7327 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7328#line 491 "rx-decode.opc"
c7927a3c
NC		 7329 int rdst AU = op[2] & 0x0f;
7330 if (trace)
7331 {
7332 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7333 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7334 op[0], op[1], op[2]);
7335 printf (" rsrc = 0x%x,", rsrc);
7336 printf (" rdst = 0x%x\n", rdst);
7337 }
7338 SYNTAX("adc %1, %0");
b8985e5c 7339#line 491 "rx-decode.opc"
3cf79a01 7340 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
43e65147 7341
c7927a3c
NC		 7342 }
7343 break;
7344 }
7345 break;
7346 case 0x0f:
7347 GETBYTE ();
7348 switch (op[2] & 0x00)
7349 {
7350 case 0x00:
7351 {
7352 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
b8985e5c 7353#line 564 "rx-decode.opc"
c7927a3c 7354 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7355#line 564 "rx-decode.opc"
c7927a3c
NC		 7356 int rdst AU = op[2] & 0x0f;
7357 if (trace)
7358 {
7359 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7360 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7361 op[0], op[1], op[2]);
7362 printf (" rsrc = 0x%x,", rsrc);
7363 printf (" rdst = 0x%x\n", rdst);
7364 }
7365 SYNTAX("abs %1, %0");
b8985e5c 7366#line 564 "rx-decode.opc"
3cf79a01 7367 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
43e65147 7368
c7927a3c
NC		 7369 /*----------------------------------------------------------------------*/
7370 /* MAX */
43e65147 7371
c7927a3c
NC		 7372 }
7373 break;
7374 }
7375 break;
7376 case 0x10:
7377 GETBYTE ();
7378 switch (op[2] & 0x00)
7379 {
7380 case 0x00:
a117b0a5 7381 op_semantics_48:
c7927a3c
NC		 7382 {
7383 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
a117b0a5 7384#line 583 "rx-decode.opc"
c7927a3c 7385 int ss AU = op[1] & 0x03;
a117b0a5 7386#line 583 "rx-decode.opc"
c7927a3c 7387 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 7388#line 583 "rx-decode.opc"
c7927a3c
NC		 7389 int rdst AU = op[2] & 0x0f;
7390 if (trace)
7391 {
7392 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7393 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7394 op[0], op[1], op[2]);
7395 printf (" ss = 0x%x,", ss);
7396 printf (" rsrc = 0x%x,", rsrc);
7397 printf (" rdst = 0x%x\n", rdst);
7398 }
7399 SYNTAX("max %1%S1, %0");
a117b0a5 7400#line 583 "rx-decode.opc"
f9c7014e
DD		 7401 if (ss == 3 && rsrc == 0 && rdst == 0)
7402 {
7403 ID(nop3);
a117b0a5 7404 SYNTAX("nop\t; max\tr0, r0");
f9c7014e
DD		 7405 }
7406 else
7407 {
7408 ID(max); SP(ss, rsrc); DR(rdst);
7409 }
43e65147 7410
c7927a3c
NC		 7411 }
7412 break;
7413 }
7414 break;
7415 case 0x11:
7416 GETBYTE ();
7417 switch (op[2] & 0x00)
7418 {
7419 case 0x00:
a117b0a5 7420 goto op_semantics_48;
c7927a3c
NC		 7421 break;
7422 }
7423 break;
7424 case 0x12:
7425 GETBYTE ();
7426 switch (op[2] & 0x00)
7427 {
7428 case 0x00:
a117b0a5 7429 goto op_semantics_48;
c7927a3c
NC		 7430 break;
7431 }
7432 break;
7433 case 0x13:
7434 GETBYTE ();
7435 switch (op[2] & 0x00)
7436 {
7437 case 0x00:
a117b0a5 7438 goto op_semantics_48;
c7927a3c
NC		 7439 break;
7440 }
7441 break;
7442 case 0x14:
7443 GETBYTE ();
7444 switch (op[2] & 0x00)
7445 {
7446 case 0x00:
a117b0a5 7447 op_semantics_49:
c7927a3c
NC		 7448 {
7449 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
a117b0a5 7450#line 603 "rx-decode.opc"
c7927a3c 7451 int ss AU = op[1] & 0x03;
a117b0a5 7452#line 603 "rx-decode.opc"
c7927a3c 7453 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 7454#line 603 "rx-decode.opc"
c7927a3c
NC		 7455 int rdst AU = op[2] & 0x0f;
7456 if (trace)
7457 {
7458 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7459 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7460 op[0], op[1], op[2]);
7461 printf (" ss = 0x%x,", ss);
7462 printf (" rsrc = 0x%x,", rsrc);
7463 printf (" rdst = 0x%x\n", rdst);
7464 }
7465 SYNTAX("min %1%S1, %0");
a117b0a5 7466#line 603 "rx-decode.opc"
c7927a3c 7467 ID(min); SP(ss, rsrc); DR(rdst);
43e65147 7468
c7927a3c
NC		 7469 }
7470 break;
7471 }
7472 break;
7473 case 0x15:
7474 GETBYTE ();
7475 switch (op[2] & 0x00)
7476 {
7477 case 0x00:
a117b0a5 7478 goto op_semantics_49;
c7927a3c
NC		 7479 break;
7480 }
7481 break;
7482 case 0x16:
7483 GETBYTE ();
7484 switch (op[2] & 0x00)
7485 {
7486 case 0x00:
a117b0a5 7487 goto op_semantics_49;
c7927a3c
NC		 7488 break;
7489 }
7490 break;
7491 case 0x17:
7492 GETBYTE ();
7493 switch (op[2] & 0x00)
7494 {
7495 case 0x00:
a117b0a5 7496 goto op_semantics_49;
c7927a3c
NC		 7497 break;
7498 }
7499 break;
7500 case 0x18:
7501 GETBYTE ();
7502 switch (op[2] & 0x00)
7503 {
7504 case 0x00:
a117b0a5 7505 op_semantics_50:
c7927a3c
NC		 7506 {
7507 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
a117b0a5 7508#line 661 "rx-decode.opc"
c7927a3c 7509 int ss AU = op[1] & 0x03;
a117b0a5 7510#line 661 "rx-decode.opc"
c7927a3c 7511 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 7512#line 661 "rx-decode.opc"
c7927a3c
NC		 7513 int rdst AU = op[2] & 0x0f;
7514 if (trace)
7515 {
7516 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7517 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7518 op[0], op[1], op[2]);
7519 printf (" ss = 0x%x,", ss);
7520 printf (" rsrc = 0x%x,", rsrc);
7521 printf (" rdst = 0x%x\n", rdst);
7522 }
7523 SYNTAX("emul %1%S1, %0");
a117b0a5 7524#line 661 "rx-decode.opc"
c7927a3c 7525 ID(emul); SP(ss, rsrc); DR(rdst);
43e65147 7526
c7927a3c
NC		 7527 }
7528 break;
7529 }
7530 break;
7531 case 0x19:
7532 GETBYTE ();
7533 switch (op[2] & 0x00)
7534 {
7535 case 0x00:
a117b0a5 7536 goto op_semantics_50;
c7927a3c
NC		 7537 break;
7538 }
7539 break;
7540 case 0x1a:
7541 GETBYTE ();
7542 switch (op[2] & 0x00)
7543 {
7544 case 0x00:
a117b0a5 7545 goto op_semantics_50;
c7927a3c
NC		 7546 break;
7547 }
7548 break;
7549 case 0x1b:
7550 GETBYTE ();
7551 switch (op[2] & 0x00)
7552 {
7553 case 0x00:
a117b0a5 7554 goto op_semantics_50;
c7927a3c
NC		 7555 break;
7556 }
7557 break;
7558 case 0x1c:
7559 GETBYTE ();
7560 switch (op[2] & 0x00)
7561 {
7562 case 0x00:
a117b0a5 7563 op_semantics_51:
c7927a3c
NC		 7564 {
7565 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
a117b0a5 7566#line 673 "rx-decode.opc"
c7927a3c 7567 int ss AU = op[1] & 0x03;
a117b0a5 7568#line 673 "rx-decode.opc"
c7927a3c 7569 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 7570#line 673 "rx-decode.opc"
c7927a3c
NC		 7571 int rdst AU = op[2] & 0x0f;
7572 if (trace)
7573 {
7574 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7575 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7576 op[0], op[1], op[2]);
7577 printf (" ss = 0x%x,", ss);
7578 printf (" rsrc = 0x%x,", rsrc);
7579 printf (" rdst = 0x%x\n", rdst);
7580 }
7581 SYNTAX("emulu %1%S1, %0");
a117b0a5 7582#line 673 "rx-decode.opc"
c7927a3c 7583 ID(emulu); SP(ss, rsrc); DR(rdst);
43e65147 7584
c7927a3c
NC		 7585 }
7586 break;
7587 }
7588 break;
7589 case 0x1d:
7590 GETBYTE ();
7591 switch (op[2] & 0x00)
7592 {
7593 case 0x00:
a117b0a5 7594 goto op_semantics_51;
c7927a3c
NC		 7595 break;
7596 }
7597 break;
7598 case 0x1e:
7599 GETBYTE ();
7600 switch (op[2] & 0x00)
7601 {
7602 case 0x00:
a117b0a5 7603 goto op_semantics_51;
c7927a3c
NC		 7604 break;
7605 }
7606 break;
7607 case 0x1f:
7608 GETBYTE ();
7609 switch (op[2] & 0x00)
7610 {
7611 case 0x00:
a117b0a5 7612 goto op_semantics_51;
c7927a3c
NC		 7613 break;
7614 }
7615 break;
7616 case 0x20:
7617 GETBYTE ();
7618 switch (op[2] & 0x00)
7619 {
7620 case 0x00:
a117b0a5 7621 op_semantics_52:
c7927a3c
NC		 7622 {
7623 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
a117b0a5 7624#line 685 "rx-decode.opc"
c7927a3c 7625 int ss AU = op[1] & 0x03;
a117b0a5 7626#line 685 "rx-decode.opc"
c7927a3c 7627 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 7628#line 685 "rx-decode.opc"
c7927a3c
NC		 7629 int rdst AU = op[2] & 0x0f;
7630 if (trace)
7631 {
7632 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7633 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7634 op[0], op[1], op[2]);
7635 printf (" ss = 0x%x,", ss);
7636 printf (" rsrc = 0x%x,", rsrc);
7637 printf (" rdst = 0x%x\n", rdst);
7638 }
7639 SYNTAX("div %1%S1, %0");
a117b0a5 7640#line 685 "rx-decode.opc"
3cf79a01 7641 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
43e65147 7642
c7927a3c
NC		 7643 }
7644 break;
7645 }
7646 break;
7647 case 0x21:
7648 GETBYTE ();
7649 switch (op[2] & 0x00)
7650 {
7651 case 0x00:
a117b0a5 7652 goto op_semantics_52;
c7927a3c
NC		 7653 break;
7654 }
7655 break;
7656 case 0x22:
7657 GETBYTE ();
7658 switch (op[2] & 0x00)
7659 {
7660 case 0x00:
a117b0a5 7661 goto op_semantics_52;
c7927a3c
NC		 7662 break;
7663 }
7664 break;
7665 case 0x23:
7666 GETBYTE ();
7667 switch (op[2] & 0x00)
7668 {
7669 case 0x00:
a117b0a5 7670 goto op_semantics_52;
c7927a3c
NC		 7671 break;
7672 }
7673 break;
7674 case 0x24:
7675 GETBYTE ();
7676 switch (op[2] & 0x00)
7677 {
7678 case 0x00:
a117b0a5 7679 op_semantics_53:
c7927a3c
NC		 7680 {
7681 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
a117b0a5 7682#line 697 "rx-decode.opc"
c7927a3c 7683 int ss AU = op[1] & 0x03;
a117b0a5 7684#line 697 "rx-decode.opc"
c7927a3c 7685 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 7686#line 697 "rx-decode.opc"
c7927a3c
NC		 7687 int rdst AU = op[2] & 0x0f;
7688 if (trace)
7689 {
7690 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7691 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7692 op[0], op[1], op[2]);
7693 printf (" ss = 0x%x,", ss);
7694 printf (" rsrc = 0x%x,", rsrc);
7695 printf (" rdst = 0x%x\n", rdst);
7696 }
7697 SYNTAX("divu %1%S1, %0");
a117b0a5 7698#line 697 "rx-decode.opc"
3cf79a01 7699 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
43e65147 7700
c7927a3c
NC		 7701 }
7702 break;
7703 }
7704 break;
7705 case 0x25:
7706 GETBYTE ();
7707 switch (op[2] & 0x00)
7708 {
7709 case 0x00:
a117b0a5 7710 goto op_semantics_53;
c7927a3c
NC		 7711 break;
7712 }
7713 break;
7714 case 0x26:
7715 GETBYTE ();
7716 switch (op[2] & 0x00)
7717 {
7718 case 0x00:
a117b0a5 7719 goto op_semantics_53;
c7927a3c
NC		 7720 break;
7721 }
7722 break;
7723 case 0x27:
7724 GETBYTE ();
7725 switch (op[2] & 0x00)
7726 {
7727 case 0x00:
a117b0a5 7728 goto op_semantics_53;
c7927a3c
NC		 7729 break;
7730 }
7731 break;
7732 case 0x30:
7733 GETBYTE ();
7734 switch (op[2] & 0x00)
7735 {
7736 case 0x00:
a117b0a5 7737 op_semantics_54:
c7927a3c
NC		 7738 {
7739 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
b8985e5c 7740#line 470 "rx-decode.opc"
c7927a3c 7741 int ss AU = op[1] & 0x03;
b8985e5c 7742#line 470 "rx-decode.opc"
c7927a3c 7743 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7744#line 470 "rx-decode.opc"
c7927a3c
NC		 7745 int rdst AU = op[2] & 0x0f;
7746 if (trace)
7747 {
7748 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7749 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7750 op[0], op[1], op[2]);
7751 printf (" ss = 0x%x,", ss);
7752 printf (" rsrc = 0x%x,", rsrc);
7753 printf (" rdst = 0x%x\n", rdst);
7754 }
7755 SYNTAX("tst %1%S1, %2");
b8985e5c 7756#line 470 "rx-decode.opc"
3cf79a01 7757 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
43e65147 7758
c7927a3c
NC		 7759 }
7760 break;
7761 }
7762 break;
7763 case 0x31:
7764 GETBYTE ();
7765 switch (op[2] & 0x00)
7766 {
7767 case 0x00:
a117b0a5 7768 goto op_semantics_54;
c7927a3c
NC		 7769 break;
7770 }
7771 break;
7772 case 0x32:
7773 GETBYTE ();
7774 switch (op[2] & 0x00)
7775 {
7776 case 0x00:
a117b0a5 7777 goto op_semantics_54;
c7927a3c
NC		 7778 break;
7779 }
7780 break;
7781 case 0x33:
7782 GETBYTE ();
7783 switch (op[2] & 0x00)
7784 {
7785 case 0x00:
a117b0a5 7786 goto op_semantics_54;
c7927a3c
NC		 7787 break;
7788 }
7789 break;
7790 case 0x34:
7791 GETBYTE ();
7792 switch (op[2] & 0x00)
7793 {
7794 case 0x00:
a117b0a5 7795 op_semantics_55:
c7927a3c
NC		 7796 {
7797 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
b8985e5c 7798#line 449 "rx-decode.opc"
c7927a3c 7799 int ss AU = op[1] & 0x03;
b8985e5c 7800#line 449 "rx-decode.opc"
c7927a3c 7801 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7802#line 449 "rx-decode.opc"
c7927a3c
NC		 7803 int rdst AU = op[2] & 0x0f;
7804 if (trace)
7805 {
7806 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7807 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7808 op[0], op[1], op[2]);
7809 printf (" ss = 0x%x,", ss);
7810 printf (" rsrc = 0x%x,", rsrc);
7811 printf (" rdst = 0x%x\n", rdst);
7812 }
7813 SYNTAX("xor %1%S1, %0");
b8985e5c 7814#line 449 "rx-decode.opc"
3cf79a01 7815 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 7816
c7927a3c
NC		 7817 }
7818 break;
7819 }
7820 break;
7821 case 0x35:
7822 GETBYTE ();
7823 switch (op[2] & 0x00)
7824 {
7825 case 0x00:
a117b0a5 7826 goto op_semantics_55;
c7927a3c
NC		 7827 break;
7828 }
7829 break;
7830 case 0x36:
7831 GETBYTE ();
7832 switch (op[2] & 0x00)
7833 {
7834 case 0x00:
a117b0a5 7835 goto op_semantics_55;
c7927a3c
NC		 7836 break;
7837 }
7838 break;
7839 case 0x37:
7840 GETBYTE ();
7841 switch (op[2] & 0x00)
7842 {
7843 case 0x00:
a117b0a5 7844 goto op_semantics_55;
c7927a3c
NC		 7845 break;
7846 }
7847 break;
7848 case 0x3b:
7849 GETBYTE ();
7850 switch (op[2] & 0x00)
7851 {
7852 case 0x00:
7853 {
7854 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
b8985e5c 7855#line 461 "rx-decode.opc"
c7927a3c 7856 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7857#line 461 "rx-decode.opc"
c7927a3c
NC		 7858 int rdst AU = op[2] & 0x0f;
7859 if (trace)
7860 {
7861 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7862 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7863 op[0], op[1], op[2]);
7864 printf (" rsrc = 0x%x,", rsrc);
7865 printf (" rdst = 0x%x\n", rdst);
7866 }
7867 SYNTAX("not %1, %0");
b8985e5c 7868#line 461 "rx-decode.opc"
3cf79a01 7869 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
43e65147 7870
c7927a3c
NC		 7871 /*----------------------------------------------------------------------*/
7872 /* TST */
43e65147 7873
c7927a3c
NC		 7874 }
7875 break;
7876 }
7877 break;
7878 case 0x40:
7879 GETBYTE ();
7880 switch (op[2] & 0x00)
7881 {
7882 case 0x00:
a117b0a5 7883 op_semantics_56:
c7927a3c
NC		 7884 {
7885 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
b8985e5c 7886#line 383 "rx-decode.opc"
c7927a3c 7887 int ss AU = op[1] & 0x03;
b8985e5c 7888#line 383 "rx-decode.opc"
c7927a3c 7889 int rsrc AU = (op[2] >> 4) & 0x0f;
b8985e5c 7890#line 383 "rx-decode.opc"
c7927a3c
NC		 7891 int rdst AU = op[2] & 0x0f;
7892 if (trace)
7893 {
7894 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7895 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7896 op[0], op[1], op[2]);
7897 printf (" ss = 0x%x,", ss);
7898 printf (" rsrc = 0x%x,", rsrc);
7899 printf (" rdst = 0x%x\n", rdst);
7900 }
7901 SYNTAX("xchg %1%S1, %0");
b8985e5c 7902#line 383 "rx-decode.opc"
c7927a3c 7903 ID(xchg); DR(rdst); SP(ss, rsrc);
43e65147 7904
c7927a3c
NC		 7905 }
7906 break;
7907 }
7908 break;
7909 case 0x41:
7910 GETBYTE ();
7911 switch (op[2] & 0x00)
7912 {
7913 case 0x00:
a117b0a5 7914 goto op_semantics_56;
c7927a3c
NC		 7915 break;
7916 }
7917 break;
7918 case 0x42:
7919 GETBYTE ();
7920 switch (op[2] & 0x00)
7921 {
7922 case 0x00:
a117b0a5 7923 goto op_semantics_56;
c7927a3c
NC		 7924 break;
7925 }
7926 break;
7927 case 0x43:
7928 GETBYTE ();
7929 switch (op[2] & 0x00)
7930 {
7931 case 0x00:
a117b0a5 7932 goto op_semantics_56;
c7927a3c
NC		 7933 break;
7934 }
7935 break;
7936 case 0x44:
7937 GETBYTE ();
7938 switch (op[2] & 0x00)
7939 {
7940 case 0x00:
a117b0a5 7941 op_semantics_57:
c7927a3c
NC		 7942 {
7943 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
a117b0a5 7944#line 926 "rx-decode.opc"
c7927a3c 7945 int sd AU = op[1] & 0x03;
a117b0a5 7946#line 926 "rx-decode.opc"
c7927a3c 7947 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 7948#line 926 "rx-decode.opc"
c7927a3c
NC		 7949 int rdst AU = op[2] & 0x0f;
7950 if (trace)
7951 {
7952 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7953 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7954 op[0], op[1], op[2]);
7955 printf (" sd = 0x%x,", sd);
7956 printf (" rsrc = 0x%x,", rsrc);
7957 printf (" rdst = 0x%x\n", rdst);
7958 }
7959 SYNTAX("itof %1%S1, %0");
a117b0a5 7960#line 926 "rx-decode.opc"
3cf79a01 7961 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
43e65147 7962
c7927a3c
NC		 7963 }
7964 break;
7965 }
7966 break;
7967 case 0x45:
7968 GETBYTE ();
7969 switch (op[2] & 0x00)
7970 {
7971 case 0x00:
a117b0a5 7972 goto op_semantics_57;
c7927a3c
NC		 7973 break;
7974 }
7975 break;
7976 case 0x46:
7977 GETBYTE ();
7978 switch (op[2] & 0x00)
7979 {
7980 case 0x00:
a117b0a5 7981 goto op_semantics_57;
c7927a3c
NC		 7982 break;
7983 }
7984 break;
7985 case 0x47:
7986 GETBYTE ();
7987 switch (op[2] & 0x00)
7988 {
7989 case 0x00:
a117b0a5 7990 goto op_semantics_57;
c7927a3c
NC		 7991 break;
7992 }
7993 break;
a117b0a5 7994 case 0x4b:
c7927a3c
NC		 7995 GETBYTE ();
7996 switch (op[2] & 0x00)
7997 {
7998 case 0x00:
c7927a3c 7999 {
a117b0a5
YS		 8000 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
8001#line 1052 "rx-decode.opc"
8002 int rsrc AU = (op[2] >> 4) & 0x0f;
8003#line 1052 "rx-decode.opc"
8004 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 8005 if (trace)
8006 {
8007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8008 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
c7927a3c 8009 op[0], op[1], op[2]);
a117b0a5
YS		 8010 printf (" rsrc = 0x%x,", rsrc);
8011 printf (" rdst = 0x%x\n", rdst);
c7927a3c 8012 }
a117b0a5
YS		 8013 SYNTAX("stz %1, %0");
8014#line 1052 "rx-decode.opc"
8015 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
43e65147 8016
c7927a3c
NC		 8017 }
8018 break;
8019 }
8020 break;
a117b0a5 8021 case 0x4f:
c7927a3c
NC		 8022 GETBYTE ();
8023 switch (op[2] & 0x00)
8024 {
8025 case 0x00:
a117b0a5
YS		 8026 {
8027 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
8028#line 1055 "rx-decode.opc"
8029 int rsrc AU = (op[2] >> 4) & 0x0f;
8030#line 1055 "rx-decode.opc"
8031 int rdst AU = op[2] & 0x0f;
8032 if (trace)
8033 {
8034 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8035 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
8036 op[0], op[1], op[2]);
8037 printf (" rsrc = 0x%x,", rsrc);
8038 printf (" rdst = 0x%x\n", rdst);
8039 }
8040 SYNTAX("stnz %1, %0");
8041#line 1055 "rx-decode.opc"
239efab1 8042 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
a117b0a5
YS		 8043
8044 }
c7927a3c
NC		 8045 break;
8046 }
8047 break;
a117b0a5 8048 case 0x54:
c7927a3c
NC		 8049 GETBYTE ();
8050 switch (op[2] & 0x00)
8051 {
8052 case 0x00:
8053 op_semantics_58:
8054 {
a117b0a5
YS		 8055 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
8056#line 1112 "rx-decode.opc"
c7927a3c 8057 int sd AU = op[1] & 0x03;
a117b0a5
YS		 8058#line 1112 "rx-decode.opc"
8059 int rsrc AU = (op[2] >> 4) & 0x0f;
8060#line 1112 "rx-decode.opc"
8061 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 8062 if (trace)
8063 {
8064 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8065 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
c7927a3c
NC		 8066 op[0], op[1], op[2]);
8067 printf (" sd = 0x%x,", sd);
a117b0a5
YS		 8068 printf (" rsrc = 0x%x,", rsrc);
8069 printf (" rdst = 0x%x\n", rdst);
c7927a3c 8070 }
a117b0a5
YS		 8071 SYNTAX("utof %1%S1, %0");
8072#line 1112 "rx-decode.opc"
8073 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
43e65147 8074
c7927a3c
NC		 8075 }
8076 break;
8077 }
8078 break;
a117b0a5 8079 case 0x55:
c7927a3c
NC		 8080 GETBYTE ();
8081 switch (op[2] & 0x00)
8082 {
8083 case 0x00:
8084 goto op_semantics_58;
8085 break;
8086 }
8087 break;
a117b0a5 8088 case 0x56:
c7927a3c
NC		 8089 GETBYTE ();
8090 switch (op[2] & 0x00)
8091 {
8092 case 0x00:
8093 goto op_semantics_58;
8094 break;
8095 }
8096 break;
a117b0a5 8097 case 0x57:
c7927a3c
NC		 8098 GETBYTE ();
8099 switch (op[2] & 0x00)
8100 {
8101 case 0x00:
8102 goto op_semantics_58;
8103 break;
8104 }
8105 break;
a117b0a5 8106 case 0x60:
c7927a3c
NC		 8107 GETBYTE ();
8108 switch (op[2] & 0x00)
8109 {
8110 case 0x00:
8111 op_semantics_59:
8112 {
a117b0a5
YS		 8113 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
8114#line 938 "rx-decode.opc"
c7927a3c 8115 int sd AU = op[1] & 0x03;
a117b0a5 8116#line 938 "rx-decode.opc"
c7927a3c 8117 int rdst AU = (op[2] >> 4) & 0x0f;
a117b0a5 8118#line 938 "rx-decode.opc"
c7927a3c
NC		 8119 int rsrc AU = op[2] & 0x0f;
8120 if (trace)
8121 {
8122 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8123 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
c7927a3c
NC		 8124 op[0], op[1], op[2]);
8125 printf (" sd = 0x%x,", sd);
8126 printf (" rdst = 0x%x,", rdst);
8127 printf (" rsrc = 0x%x\n", rsrc);
8128 }
a117b0a5
YS		 8129 SYNTAX("bset %1, %0%S0");
8130#line 938 "rx-decode.opc"
8131 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
3531d549
DD		 8132 if (sd == 3) /* bset reg,reg */
8133 BWL(LSIZE);
43e65147 8134
c7927a3c
NC		 8135 }
8136 break;
8137 }
8138 break;
a117b0a5 8139 case 0x61:
c7927a3c
NC		 8140 GETBYTE ();
8141 switch (op[2] & 0x00)
8142 {
8143 case 0x00:
8144 goto op_semantics_59;
8145 break;
8146 }
8147 break;
a117b0a5 8148 case 0x62:
c7927a3c
NC		 8149 GETBYTE ();
8150 switch (op[2] & 0x00)
8151 {
8152 case 0x00:
8153 goto op_semantics_59;
8154 break;
8155 }
8156 break;
a117b0a5 8157 case 0x63:
c7927a3c
NC		 8158 GETBYTE ();
8159 switch (op[2] & 0x00)
8160 {
8161 case 0x00:
8162 goto op_semantics_59;
8163 break;
8164 }
8165 break;
a117b0a5 8166 case 0x64:
c7927a3c
NC		 8167 GETBYTE ();
8168 switch (op[2] & 0x00)
8169 {
8170 case 0x00:
8171 op_semantics_60:
a117b0a5
YS		 8172 {
8173 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
8174#line 950 "rx-decode.opc"
8175 int sd AU = op[1] & 0x03;
8176#line 950 "rx-decode.opc"
8177 int rdst AU = (op[2] >> 4) & 0x0f;
8178#line 950 "rx-decode.opc"
8179 int rsrc AU = op[2] & 0x0f;
8180 if (trace)
8181 {
8182 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8183 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
8184 op[0], op[1], op[2]);
8185 printf (" sd = 0x%x,", sd);
8186 printf (" rdst = 0x%x,", rdst);
8187 printf (" rsrc = 0x%x\n", rsrc);
8188 }
8189 SYNTAX("bclr %1, %0%S0");
8190#line 950 "rx-decode.opc"
8191 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8192 if (sd == 3) /* bset reg,reg */
8193 BWL(LSIZE);
8194
8195 }
8196 break;
8197 }
8198 break;
8199 case 0x65:
8200 GETBYTE ();
8201 switch (op[2] & 0x00)
8202 {
8203 case 0x00:
8204 goto op_semantics_60;
8205 break;
8206 }
8207 break;
8208 case 0x66:
8209 GETBYTE ();
8210 switch (op[2] & 0x00)
8211 {
8212 case 0x00:
8213 goto op_semantics_60;
8214 break;
8215 }
8216 break;
8217 case 0x67:
8218 GETBYTE ();
8219 switch (op[2] & 0x00)
8220 {
8221 case 0x00:
8222 goto op_semantics_60;
8223 break;
8224 }
8225 break;
8226 case 0x68:
8227 GETBYTE ();
8228 switch (op[2] & 0x00)
8229 {
8230 case 0x00:
8231 op_semantics_61:
8232 {
8233 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
8234#line 962 "rx-decode.opc"
8235 int sd AU = op[1] & 0x03;
8236#line 962 "rx-decode.opc"
8237 int rdst AU = (op[2] >> 4) & 0x0f;
8238#line 962 "rx-decode.opc"
8239 int rsrc AU = op[2] & 0x0f;
8240 if (trace)
8241 {
8242 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8243 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
8244 op[0], op[1], op[2]);
8245 printf (" sd = 0x%x,", sd);
8246 printf (" rdst = 0x%x,", rdst);
8247 printf (" rsrc = 0x%x\n", rsrc);
8248 }
8249 SYNTAX("btst %2, %1%S1");
8250#line 962 "rx-decode.opc"
8251 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8252 if (sd == 3) /* bset reg,reg */
8253 BWL(LSIZE);
8254
8255 }
8256 break;
8257 }
8258 break;
8259 case 0x69:
8260 GETBYTE ();
8261 switch (op[2] & 0x00)
8262 {
8263 case 0x00:
8264 goto op_semantics_61;
8265 break;
8266 }
8267 break;
8268 case 0x6a:
8269 GETBYTE ();
8270 switch (op[2] & 0x00)
8271 {
8272 case 0x00:
8273 goto op_semantics_61;
8274 break;
8275 }
8276 break;
8277 case 0x6b:
8278 GETBYTE ();
8279 switch (op[2] & 0x00)
8280 {
8281 case 0x00:
8282 goto op_semantics_61;
8283 break;
8284 }
8285 break;
8286 case 0x6c:
8287 GETBYTE ();
8288 switch (op[2] & 0x00)
8289 {
8290 case 0x00:
8291 op_semantics_62:
c7927a3c
NC		 8292 {
8293 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
a117b0a5 8294#line 974 "rx-decode.opc"
c7927a3c 8295 int sd AU = op[1] & 0x03;
a117b0a5 8296#line 974 "rx-decode.opc"
c7927a3c 8297 int rdst AU = (op[2] >> 4) & 0x0f;
a117b0a5 8298#line 974 "rx-decode.opc"
c7927a3c
NC		 8299 int rsrc AU = op[2] & 0x0f;
8300 if (trace)
8301 {
8302 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8303 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
8304 op[0], op[1], op[2]);
8305 printf (" sd = 0x%x,", sd);
8306 printf (" rdst = 0x%x,", rdst);
8307 printf (" rsrc = 0x%x\n", rsrc);
8308 }
8309 SYNTAX("bnot %1, %0%S0");
a117b0a5 8310#line 974 "rx-decode.opc"
c7927a3c 8311 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
3531d549
DD		 8312 if (sd == 3) /* bset reg,reg */
8313 BWL(LSIZE);
43e65147 8314
c7927a3c
NC		 8315 }
8316 break;
8317 }
8318 break;
8319 case 0x6d:
8320 GETBYTE ();
8321 switch (op[2] & 0x00)
8322 {
8323 case 0x00:
a117b0a5 8324 goto op_semantics_62;
c7927a3c
NC		 8325 break;
8326 }
8327 break;
8328 case 0x6e:
8329 GETBYTE ();
8330 switch (op[2] & 0x00)
8331 {
8332 case 0x00:
a117b0a5 8333 goto op_semantics_62;
c7927a3c
NC		 8334 break;
8335 }
8336 break;
8337 case 0x6f:
8338 GETBYTE ();
8339 switch (op[2] & 0x00)
8340 {
8341 case 0x00:
a117b0a5 8342 goto op_semantics_62;
c7927a3c
NC		 8343 break;
8344 }
8345 break;
8346 case 0x80:
8347 GETBYTE ();
8348 switch (op[2] & 0x00)
8349 {
8350 case 0x00:
a117b0a5 8351 op_semantics_63:
c7927a3c
NC		 8352 {
8353 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
a117b0a5 8354#line 905 "rx-decode.opc"
c7927a3c 8355 int sd AU = op[1] & 0x03;
a117b0a5 8356#line 905 "rx-decode.opc"
c7927a3c 8357 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 8358#line 905 "rx-decode.opc"
c7927a3c
NC		 8359 int rdst AU = op[2] & 0x0f;
8360 if (trace)
8361 {
8362 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8363 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8364 op[0], op[1], op[2]);
8365 printf (" sd = 0x%x,", sd);
8366 printf (" rsrc = 0x%x,", rsrc);
8367 printf (" rdst = 0x%x\n", rdst);
8368 }
8369 SYNTAX("fsub %1%S1, %0");
a117b0a5 8370#line 905 "rx-decode.opc"
3cf79a01 8371 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8372
c7927a3c
NC		 8373 }
8374 break;
8375 }
8376 break;
8377 case 0x81:
8378 GETBYTE ();
8379 switch (op[2] & 0x00)
8380 {
8381 case 0x00:
a117b0a5 8382 goto op_semantics_63;
c7927a3c
NC		 8383 break;
8384 }
8385 break;
8386 case 0x82:
8387 GETBYTE ();
8388 switch (op[2] & 0x00)
8389 {
8390 case 0x00:
a117b0a5 8391 goto op_semantics_63;
c7927a3c
NC		 8392 break;
8393 }
8394 break;
8395 case 0x83:
8396 GETBYTE ();
8397 switch (op[2] & 0x00)
8398 {
8399 case 0x00:
a117b0a5 8400 goto op_semantics_63;
c7927a3c
NC		 8401 break;
8402 }
8403 break;
8404 case 0x84:
8405 GETBYTE ();
8406 switch (op[2] & 0x00)
8407 {
8408 case 0x00:
a117b0a5 8409 op_semantics_64:
c7927a3c
NC		 8410 {
8411 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
a117b0a5 8412#line 899 "rx-decode.opc"
c7927a3c 8413 int sd AU = op[1] & 0x03;
a117b0a5 8414#line 899 "rx-decode.opc"
c7927a3c 8415 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 8416#line 899 "rx-decode.opc"
c7927a3c
NC		 8417 int rdst AU = op[2] & 0x0f;
8418 if (trace)
8419 {
8420 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8421 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8422 op[0], op[1], op[2]);
8423 printf (" sd = 0x%x,", sd);
8424 printf (" rsrc = 0x%x,", rsrc);
8425 printf (" rdst = 0x%x\n", rdst);
8426 }
8427 SYNTAX("fcmp %1%S1, %0");
a117b0a5 8428#line 899 "rx-decode.opc"
3cf79a01 8429 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
43e65147 8430
c7927a3c
NC		 8431 }
8432 break;
8433 }
8434 break;
8435 case 0x85:
8436 GETBYTE ();
8437 switch (op[2] & 0x00)
8438 {
8439 case 0x00:
a117b0a5 8440 goto op_semantics_64;
c7927a3c
NC		 8441 break;
8442 }
8443 break;
8444 case 0x86:
8445 GETBYTE ();
8446 switch (op[2] & 0x00)
8447 {
8448 case 0x00:
a117b0a5 8449 goto op_semantics_64;
c7927a3c
NC		 8450 break;
8451 }
8452 break;
8453 case 0x87:
8454 GETBYTE ();
8455 switch (op[2] & 0x00)
8456 {
8457 case 0x00:
a117b0a5 8458 goto op_semantics_64;
c7927a3c
NC		 8459 break;
8460 }
8461 break;
8462 case 0x88:
8463 GETBYTE ();
8464 switch (op[2] & 0x00)
8465 {
8466 case 0x00:
a117b0a5 8467 op_semantics_65:
c7927a3c
NC		 8468 {
8469 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
a117b0a5 8470#line 893 "rx-decode.opc"
c7927a3c 8471 int sd AU = op[1] & 0x03;
a117b0a5 8472#line 893 "rx-decode.opc"
c7927a3c 8473 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 8474#line 893 "rx-decode.opc"
c7927a3c
NC		 8475 int rdst AU = op[2] & 0x0f;
8476 if (trace)
8477 {
8478 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8479 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8480 op[0], op[1], op[2]);
8481 printf (" sd = 0x%x,", sd);
8482 printf (" rsrc = 0x%x,", rsrc);
8483 printf (" rdst = 0x%x\n", rdst);
8484 }
8485 SYNTAX("fadd %1%S1, %0");
a117b0a5 8486#line 893 "rx-decode.opc"
3cf79a01 8487 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8488
c7927a3c
NC		 8489 }
8490 break;
8491 }
8492 break;
8493 case 0x89:
8494 GETBYTE ();
8495 switch (op[2] & 0x00)
8496 {
8497 case 0x00:
a117b0a5 8498 goto op_semantics_65;
c7927a3c
NC		 8499 break;
8500 }
8501 break;
8502 case 0x8a:
8503 GETBYTE ();
8504 switch (op[2] & 0x00)
8505 {
8506 case 0x00:
a117b0a5 8507 goto op_semantics_65;
c7927a3c
NC		 8508 break;
8509 }
8510 break;
8511 case 0x8b:
8512 GETBYTE ();
8513 switch (op[2] & 0x00)
8514 {
8515 case 0x00:
a117b0a5 8516 goto op_semantics_65;
c7927a3c
NC		 8517 break;
8518 }
8519 break;
8520 case 0x8c:
8521 GETBYTE ();
8522 switch (op[2] & 0x00)
8523 {
8524 case 0x00:
a117b0a5 8525 op_semantics_66:
c7927a3c
NC		 8526 {
8527 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
a117b0a5 8528#line 914 "rx-decode.opc"
c7927a3c 8529 int sd AU = op[1] & 0x03;
a117b0a5 8530#line 914 "rx-decode.opc"
c7927a3c 8531 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 8532#line 914 "rx-decode.opc"
c7927a3c
NC		 8533 int rdst AU = op[2] & 0x0f;
8534 if (trace)
8535 {
8536 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8537 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8538 op[0], op[1], op[2]);
8539 printf (" sd = 0x%x,", sd);
8540 printf (" rsrc = 0x%x,", rsrc);
8541 printf (" rdst = 0x%x\n", rdst);
8542 }
8543 SYNTAX("fmul %1%S1, %0");
a117b0a5 8544#line 914 "rx-decode.opc"
3cf79a01 8545 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8546
c7927a3c
NC		 8547 }
8548 break;
8549 }
8550 break;
8551 case 0x8d:
8552 GETBYTE ();
8553 switch (op[2] & 0x00)
8554 {
8555 case 0x00:
a117b0a5 8556 goto op_semantics_66;
c7927a3c
NC		 8557 break;
8558 }
8559 break;
8560 case 0x8e:
8561 GETBYTE ();
8562 switch (op[2] & 0x00)
8563 {
8564 case 0x00:
a117b0a5 8565 goto op_semantics_66;
c7927a3c
NC		 8566 break;
8567 }
8568 break;
8569 case 0x8f:
8570 GETBYTE ();
8571 switch (op[2] & 0x00)
8572 {
8573 case 0x00:
a117b0a5 8574 goto op_semantics_66;
c7927a3c
NC		 8575 break;
8576 }
8577 break;
8578 case 0x90:
8579 GETBYTE ();
8580 switch (op[2] & 0x00)
8581 {
8582 case 0x00:
a117b0a5 8583 op_semantics_67:
c7927a3c
NC		 8584 {
8585 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
a117b0a5 8586#line 920 "rx-decode.opc"
c7927a3c 8587 int sd AU = op[1] & 0x03;
a117b0a5 8588#line 920 "rx-decode.opc"
c7927a3c 8589 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 8590#line 920 "rx-decode.opc"
c7927a3c
NC		 8591 int rdst AU = op[2] & 0x0f;
8592 if (trace)
8593 {
8594 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8595 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8596 op[0], op[1], op[2]);
8597 printf (" sd = 0x%x,", sd);
8598 printf (" rsrc = 0x%x,", rsrc);
8599 printf (" rdst = 0x%x\n", rdst);
8600 }
8601 SYNTAX("fdiv %1%S1, %0");
a117b0a5 8602#line 920 "rx-decode.opc"
3cf79a01 8603 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8604
c7927a3c
NC		 8605 }
8606 break;
8607 }
8608 break;
8609 case 0x91:
8610 GETBYTE ();
8611 switch (op[2] & 0x00)
8612 {
8613 case 0x00:
a117b0a5 8614 goto op_semantics_67;
c7927a3c
NC		 8615 break;
8616 }
8617 break;
8618 case 0x92:
8619 GETBYTE ();
8620 switch (op[2] & 0x00)
8621 {
8622 case 0x00:
a117b0a5 8623 goto op_semantics_67;
c7927a3c
NC		 8624 break;
8625 }
8626 break;
8627 case 0x93:
8628 GETBYTE ();
8629 switch (op[2] & 0x00)
8630 {
8631 case 0x00:
a117b0a5 8632 goto op_semantics_67;
c7927a3c
NC		 8633 break;
8634 }
8635 break;
8636 case 0x94:
8637 GETBYTE ();
8638 switch (op[2] & 0x00)
8639 {
8640 case 0x00:
a117b0a5 8641 op_semantics_68:
c7927a3c
NC		 8642 {
8643 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
a117b0a5 8644#line 908 "rx-decode.opc"
c7927a3c 8645 int sd AU = op[1] & 0x03;
a117b0a5 8646#line 908 "rx-decode.opc"
c7927a3c 8647 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 8648#line 908 "rx-decode.opc"
c7927a3c
NC		 8649 int rdst AU = op[2] & 0x0f;
8650 if (trace)
8651 {
8652 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8653 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8654 op[0], op[1], op[2]);
8655 printf (" sd = 0x%x,", sd);
8656 printf (" rsrc = 0x%x,", rsrc);
8657 printf (" rdst = 0x%x\n", rdst);
8658 }
8659 SYNTAX("ftoi %1%S1, %0");
a117b0a5 8660#line 908 "rx-decode.opc"
3cf79a01 8661 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8662
c7927a3c
NC		 8663 }
8664 break;
8665 }
8666 break;
8667 case 0x95:
8668 GETBYTE ();
8669 switch (op[2] & 0x00)
8670 {
8671 case 0x00:
a117b0a5 8672 goto op_semantics_68;
c7927a3c
NC		 8673 break;
8674 }
8675 break;
8676 case 0x96:
8677 GETBYTE ();
8678 switch (op[2] & 0x00)
8679 {
8680 case 0x00:
a117b0a5 8681 goto op_semantics_68;
c7927a3c
NC		 8682 break;
8683 }
8684 break;
8685 case 0x97:
8686 GETBYTE ();
8687 switch (op[2] & 0x00)
8688 {
8689 case 0x00:
a117b0a5 8690 goto op_semantics_68;
c7927a3c
NC		 8691 break;
8692 }
8693 break;
8694 case 0x98:
8695 GETBYTE ();
8696 switch (op[2] & 0x00)
8697 {
8698 case 0x00:
a117b0a5 8699 op_semantics_69:
c7927a3c
NC		 8700 {
8701 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
a117b0a5 8702#line 923 "rx-decode.opc"
c7927a3c 8703 int sd AU = op[1] & 0x03;
a117b0a5 8704#line 923 "rx-decode.opc"
c7927a3c 8705 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 8706#line 923 "rx-decode.opc"
c7927a3c
NC		 8707 int rdst AU = op[2] & 0x0f;
8708 if (trace)
8709 {
8710 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8711 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8712 op[0], op[1], op[2]);
8713 printf (" sd = 0x%x,", sd);
8714 printf (" rsrc = 0x%x,", rsrc);
8715 printf (" rdst = 0x%x\n", rdst);
8716 }
8717 SYNTAX("round %1%S1, %0");
a117b0a5 8718#line 923 "rx-decode.opc"
3cf79a01 8719 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8720
c7927a3c
NC		 8721 }
8722 break;
8723 }
8724 break;
8725 case 0x99:
8726 GETBYTE ();
8727 switch (op[2] & 0x00)
8728 {
8729 case 0x00:
a117b0a5 8730 goto op_semantics_69;
c7927a3c
NC		 8731 break;
8732 }
8733 break;
8734 case 0x9a:
8735 GETBYTE ();
8736 switch (op[2] & 0x00)
8737 {
8738 case 0x00:
a117b0a5 8739 goto op_semantics_69;
c7927a3c
NC		 8740 break;
8741 }
8742 break;
8743 case 0x9b:
8744 GETBYTE ();
8745 switch (op[2] & 0x00)
8746 {
8747 case 0x00:
a117b0a5 8748 goto op_semantics_69;
c7927a3c
NC		 8749 break;
8750 }
8751 break;
a117b0a5 8752 case 0xa0:
c7927a3c
NC		 8753 GETBYTE ();
8754 switch (op[2] & 0x00)
8755 {
8756 case 0x00:
a117b0a5 8757 op_semantics_70:
c7927a3c 8758 {
a117b0a5
YS		 8759 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
8760#line 1106 "rx-decode.opc"
c7927a3c 8761 int sd AU = op[1] & 0x03;
a117b0a5
YS		 8762#line 1106 "rx-decode.opc"
8763 int rsrc AU = (op[2] >> 4) & 0x0f;
8764#line 1106 "rx-decode.opc"
8765 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 8766 if (trace)
8767 {
8768 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8769 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
c7927a3c 8770 op[0], op[1], op[2]);
c7927a3c 8771 printf (" sd = 0x%x,", sd);
a117b0a5
YS		 8772 printf (" rsrc = 0x%x,", rsrc);
8773 printf (" rdst = 0x%x\n", rdst);
c7927a3c 8774 }
a117b0a5
YS		 8775 SYNTAX("fsqrt %1%S1, %0");
8776#line 1106 "rx-decode.opc"
8777 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8778
c7927a3c
NC		 8779 }
8780 break;
8781 }
8782 break;
a117b0a5 8783 case 0xa1:
c7927a3c
NC		 8784 GETBYTE ();
8785 switch (op[2] & 0x00)
8786 {
8787 case 0x00:
a117b0a5 8788 goto op_semantics_70;
c7927a3c
NC		 8789 break;
8790 }
8791 break;
a117b0a5 8792 case 0xa2:
c7927a3c
NC		 8793 GETBYTE ();
8794 switch (op[2] & 0x00)
8795 {
8796 case 0x00:
a117b0a5 8797 goto op_semantics_70;
c7927a3c
NC		 8798 break;
8799 }
8800 break;
a117b0a5 8801 case 0xa3:
c7927a3c
NC		 8802 GETBYTE ();
8803 switch (op[2] & 0x00)
8804 {
8805 case 0x00:
a117b0a5 8806 goto op_semantics_70;
c7927a3c
NC		 8807 break;
8808 }
8809 break;
a117b0a5 8810 case 0xa4:
c7927a3c
NC		 8811 GETBYTE ();
8812 switch (op[2] & 0x00)
8813 {
8814 case 0x00:
a117b0a5
YS		 8815 op_semantics_71:
8816 {
8817 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
8818#line 1109 "rx-decode.opc"
8819 int sd AU = op[1] & 0x03;
8820#line 1109 "rx-decode.opc"
8821 int rsrc AU = (op[2] >> 4) & 0x0f;
8822#line 1109 "rx-decode.opc"
8823 int rdst AU = op[2] & 0x0f;
8824 if (trace)
8825 {
8826 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8827 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
8828 op[0], op[1], op[2]);
8829 printf (" sd = 0x%x,", sd);
8830 printf (" rsrc = 0x%x,", rsrc);
8831 printf (" rdst = 0x%x\n", rdst);
8832 }
8833 SYNTAX("ftou %1%S1, %0");
8834#line 1109 "rx-decode.opc"
8835 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8836
8837 }
c7927a3c
NC		 8838 break;
8839 }
8840 break;
a117b0a5 8841 case 0xa5:
c7927a3c
NC		 8842 GETBYTE ();
8843 switch (op[2] & 0x00)
8844 {
8845 case 0x00:
a117b0a5 8846 goto op_semantics_71;
c7927a3c
NC		 8847 break;
8848 }
8849 break;
a117b0a5 8850 case 0xa6:
c7927a3c
NC		 8851 GETBYTE ();
8852 switch (op[2] & 0x00)
8853 {
8854 case 0x00:
a117b0a5 8855 goto op_semantics_71;
c7927a3c
NC		 8856 break;
8857 }
8858 break;
a117b0a5 8859 case 0xa7:
c7927a3c
NC		 8860 GETBYTE ();
8861 switch (op[2] & 0x00)
8862 {
8863 case 0x00:
a117b0a5 8864 goto op_semantics_71;
c7927a3c
NC		 8865 break;
8866 }
8867 break;
a117b0a5 8868 case 0xd0:
c7927a3c
NC		 8869 GETBYTE ();
8870 switch (op[2] & 0x00)
8871 {
8872 case 0x00:
a117b0a5
YS		 8873 op_semantics_72:
8874 {
8875 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8876#line 1040 "rx-decode.opc"
8877 int sz AU = (op[1] >> 2) & 0x03;
8878#line 1040 "rx-decode.opc"
8879 int sd AU = op[1] & 0x03;
8880#line 1040 "rx-decode.opc"
8881 int rdst AU = (op[2] >> 4) & 0x0f;
8882#line 1040 "rx-decode.opc"
8883 int cond AU = op[2] & 0x0f;
8884 if (trace)
8885 {
8886 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8887 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8888 op[0], op[1], op[2]);
8889 printf (" sz = 0x%x,", sz);
8890 printf (" sd = 0x%x,", sd);
8891 printf (" rdst = 0x%x,", rdst);
8892 printf (" cond = 0x%x\n", cond);
8893 }
8894 SYNTAX("sc%1%s %0");
8895#line 1040 "rx-decode.opc"
8896 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8897
8898 /*----------------------------------------------------------------------*/
8899 /* RXv2 enhanced */
8900
8901 }
8902 break;
8903 }
8904 break;
8905 case 0xd1:
8906 GETBYTE ();
c7927a3c
NC		 8907 switch (op[2] & 0x00)
8908 {
8909 case 0x00:
a117b0a5
YS		 8910 goto op_semantics_72;
8911 break;
8912 }
8913 break;
8914 case 0xd2:
8915 GETBYTE ();
8916 switch (op[2] & 0x00)
8917 {
8918 case 0x00:
8919 goto op_semantics_72;
8920 break;
8921 }
8922 break;
8923 case 0xd3:
8924 GETBYTE ();
8925 switch (op[2] & 0x00)
8926 {
8927 case 0x00:
8928 goto op_semantics_72;
8929 break;
8930 }
8931 break;
8932 case 0xd4:
8933 GETBYTE ();
8934 switch (op[2] & 0x00)
8935 {
8936 case 0x00:
8937 goto op_semantics_72;
8938 break;
8939 }
8940 break;
8941 case 0xd5:
8942 GETBYTE ();
8943 switch (op[2] & 0x00)
8944 {
8945 case 0x00:
8946 goto op_semantics_72;
8947 break;
8948 }
8949 break;
8950 case 0xd6:
8951 GETBYTE ();
8952 switch (op[2] & 0x00)
8953 {
8954 case 0x00:
8955 goto op_semantics_72;
8956 break;
8957 }
8958 break;
8959 case 0xd7:
8960 GETBYTE ();
8961 switch (op[2] & 0x00)
8962 {
8963 case 0x00:
8964 goto op_semantics_72;
8965 break;
8966 }
8967 break;
8968 case 0xd8:
8969 GETBYTE ();
8970 switch (op[2] & 0x00)
8971 {
8972 case 0x00:
8973 goto op_semantics_72;
8974 break;
8975 }
8976 break;
8977 case 0xd9:
8978 GETBYTE ();
8979 switch (op[2] & 0x00)
8980 {
8981 case 0x00:
8982 goto op_semantics_72;
8983 break;
8984 }
8985 break;
8986 case 0xda:
8987 GETBYTE ();
8988 switch (op[2] & 0x00)
8989 {
8990 case 0x00:
8991 goto op_semantics_72;
c7927a3c
NC		 8992 break;
8993 }
8994 break;
8995 case 0xdb:
8996 GETBYTE ();
8997 switch (op[2] & 0x00)
8998 {
8999 case 0x00:
a117b0a5 9000 goto op_semantics_72;
c7927a3c
NC		 9001 break;
9002 }
9003 break;
9004 case 0xe0:
9005 GETBYTE ();
9006 switch (op[2] & 0x0f)
9007 {
9008 case 0x00:
9009 case 0x01:
9010 case 0x02:
9011 case 0x03:
9012 case 0x04:
9013 case 0x05:
9014 case 0x06:
9015 case 0x07:
9016 case 0x08:
9017 case 0x09:
9018 case 0x0a:
9019 case 0x0b:
9020 case 0x0c:
9021 case 0x0d:
9022 case 0x0e:
a117b0a5 9023 op_semantics_73:
c7927a3c
NC		 9024 {
9025 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
a117b0a5 9026#line 983 "rx-decode.opc"
c7927a3c 9027 int bit AU = (op[1] >> 2) & 0x07;
a117b0a5 9028#line 983 "rx-decode.opc"
c7927a3c 9029 int sd AU = op[1] & 0x03;
a117b0a5 9030#line 983 "rx-decode.opc"
c7927a3c 9031 int rdst AU = (op[2] >> 4) & 0x0f;
a117b0a5 9032#line 983 "rx-decode.opc"
c7927a3c
NC		 9033 int cond AU = op[2] & 0x0f;
9034 if (trace)
9035 {
9036 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9037 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
9038 op[0], op[1], op[2]);
9039 printf (" bit = 0x%x,", bit);
9040 printf (" sd = 0x%x,", sd);
9041 printf (" rdst = 0x%x,", rdst);
9042 printf (" cond = 0x%x\n", cond);
9043 }
9044 SYNTAX("bm%2 #%1, %0%S0");
a117b0a5 9045#line 983 "rx-decode.opc"
c7927a3c 9046 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
43e65147 9047
c7927a3c
NC		 9048 }
9049 break;
9050 case 0x0f:
a117b0a5 9051 op_semantics_74:
c7927a3c
NC		 9052 {
9053 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
a117b0a5 9054#line 971 "rx-decode.opc"
c7927a3c 9055 int bit AU = (op[1] >> 2) & 0x07;
a117b0a5 9056#line 971 "rx-decode.opc"
c7927a3c 9057 int sd AU = op[1] & 0x03;
a117b0a5 9058#line 971 "rx-decode.opc"
c7927a3c
NC		 9059 int rdst AU = (op[2] >> 4) & 0x0f;
9060 if (trace)
9061 {
9062 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9063 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
9064 op[0], op[1], op[2]);
9065 printf (" bit = 0x%x,", bit);
9066 printf (" sd = 0x%x,", sd);
9067 printf (" rdst = 0x%x\n", rdst);
9068 }
9069 SYNTAX("bnot #%1, %0%S0");
a117b0a5 9070#line 971 "rx-decode.opc"
c7927a3c 9071 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
43e65147 9072
c7927a3c
NC		 9073 }
9074 break;
9075 }
9076 break;
9077 case 0xe1:
9078 GETBYTE ();
9079 switch (op[2] & 0x0f)
9080 {
9081 case 0x00:
9082 case 0x01:
9083 case 0x02:
9084 case 0x03:
9085 case 0x04:
9086 case 0x05:
9087 case 0x06:
9088 case 0x07:
9089 case 0x08:
9090 case 0x09:
9091 case 0x0a:
9092 case 0x0b:
9093 case 0x0c:
9094 case 0x0d:
9095 case 0x0e:
a117b0a5 9096 goto op_semantics_73;
c7927a3c
NC		 9097 break;
9098 case 0x0f:
a117b0a5 9099 goto op_semantics_74;
c7927a3c
NC		 9100 break;
9101 }
9102 break;
9103 case 0xe2:
9104 GETBYTE ();
9105 switch (op[2] & 0x0f)
9106 {
9107 case 0x00:
9108 case 0x01:
9109 case 0x02:
9110 case 0x03:
9111 case 0x04:
9112 case 0x05:
9113 case 0x06:
9114 case 0x07:
9115 case 0x08:
9116 case 0x09:
9117 case 0x0a:
9118 case 0x0b:
9119 case 0x0c:
9120 case 0x0d:
9121 case 0x0e:
a117b0a5 9122 goto op_semantics_73;
c7927a3c
NC		 9123 break;
9124 case 0x0f:
a117b0a5 9125 goto op_semantics_74;
c7927a3c
NC		 9126 break;
9127 }
9128 break;
9129 case 0xe3:
9130 GETBYTE ();
9131 switch (op[2] & 0x0f)
9132 {
9133 case 0x00:
9134 case 0x01:
9135 case 0x02:
9136 case 0x03:
9137 case 0x04:
9138 case 0x05:
9139 case 0x06:
9140 case 0x07:
9141 case 0x08:
9142 case 0x09:
9143 case 0x0a:
9144 case 0x0b:
9145 case 0x0c:
9146 case 0x0d:
9147 case 0x0e:
a117b0a5 9148 goto op_semantics_73;
c7927a3c
NC		 9149 break;
9150 case 0x0f:
a117b0a5 9151 goto op_semantics_74;
c7927a3c
NC		 9152 break;
9153 }
9154 break;
9155 case 0xe4:
9156 GETBYTE ();
9157 switch (op[2] & 0x0f)
9158 {
9159 case 0x00:
9160 case 0x01:
9161 case 0x02:
9162 case 0x03:
9163 case 0x04:
9164 case 0x05:
9165 case 0x06:
9166 case 0x07:
9167 case 0x08:
9168 case 0x09:
9169 case 0x0a:
9170 case 0x0b:
9171 case 0x0c:
9172 case 0x0d:
9173 case 0x0e:
a117b0a5 9174 goto op_semantics_73;
c7927a3c
NC		 9175 break;
9176 case 0x0f:
a117b0a5 9177 goto op_semantics_74;
c7927a3c
NC		 9178 break;
9179 }
9180 break;
9181 case 0xe5:
9182 GETBYTE ();
9183 switch (op[2] & 0x0f)
9184 {
9185 case 0x00:
9186 case 0x01:
9187 case 0x02:
9188 case 0x03:
9189 case 0x04:
9190 case 0x05:
9191 case 0x06:
9192 case 0x07:
9193 case 0x08:
9194 case 0x09:
9195 case 0x0a:
9196 case 0x0b:
9197 case 0x0c:
9198 case 0x0d:
9199 case 0x0e:
a117b0a5 9200 goto op_semantics_73;
c7927a3c
NC		 9201 break;
9202 case 0x0f:
a117b0a5 9203 goto op_semantics_74;
c7927a3c
NC		 9204 break;
9205 }
9206 break;
9207 case 0xe6:
9208 GETBYTE ();
9209 switch (op[2] & 0x0f)
9210 {
9211 case 0x00:
9212 case 0x01:
9213 case 0x02:
9214 case 0x03:
9215 case 0x04:
9216 case 0x05:
9217 case 0x06:
9218 case 0x07:
9219 case 0x08:
9220 case 0x09:
9221 case 0x0a:
9222 case 0x0b:
9223 case 0x0c:
9224 case 0x0d:
9225 case 0x0e:
a117b0a5 9226 goto op_semantics_73;
c7927a3c
NC		 9227 break;
9228 case 0x0f:
a117b0a5 9229 goto op_semantics_74;
c7927a3c
NC		 9230 break;
9231 }
9232 break;
9233 case 0xe7:
9234 GETBYTE ();
9235 switch (op[2] & 0x0f)
9236 {
9237 case 0x00:
9238 case 0x01:
9239 case 0x02:
9240 case 0x03:
9241 case 0x04:
9242 case 0x05:
9243 case 0x06:
9244 case 0x07:
9245 case 0x08:
9246 case 0x09:
9247 case 0x0a:
9248 case 0x0b:
9249 case 0x0c:
9250 case 0x0d:
9251 case 0x0e:
a117b0a5 9252 goto op_semantics_73;
c7927a3c
NC		 9253 break;
9254 case 0x0f:
a117b0a5 9255 goto op_semantics_74;
c7927a3c
NC		 9256 break;
9257 }
9258 break;
9259 case 0xe8:
9260 GETBYTE ();
9261 switch (op[2] & 0x0f)
9262 {
9263 case 0x00:
9264 case 0x01:
9265 case 0x02:
9266 case 0x03:
9267 case 0x04:
9268 case 0x05:
9269 case 0x06:
9270 case 0x07:
9271 case 0x08:
9272 case 0x09:
9273 case 0x0a:
9274 case 0x0b:
9275 case 0x0c:
9276 case 0x0d:
9277 case 0x0e:
a117b0a5 9278 goto op_semantics_73;
c7927a3c
NC		 9279 break;
9280 case 0x0f:
a117b0a5 9281 goto op_semantics_74;
c7927a3c
NC		 9282 break;
9283 }
9284 break;
9285 case 0xe9:
9286 GETBYTE ();
9287 switch (op[2] & 0x0f)
9288 {
9289 case 0x00:
9290 case 0x01:
9291 case 0x02:
9292 case 0x03:
9293 case 0x04:
9294 case 0x05:
9295 case 0x06:
9296 case 0x07:
9297 case 0x08:
9298 case 0x09:
9299 case 0x0a:
9300 case 0x0b:
9301 case 0x0c:
9302 case 0x0d:
9303 case 0x0e:
a117b0a5 9304 goto op_semantics_73;
c7927a3c
NC		 9305 break;
9306 case 0x0f:
a117b0a5 9307 goto op_semantics_74;
c7927a3c
NC		 9308 break;
9309 }
9310 break;
9311 case 0xea:
9312 GETBYTE ();
9313 switch (op[2] & 0x0f)
9314 {
9315 case 0x00:
9316 case 0x01:
9317 case 0x02:
9318 case 0x03:
9319 case 0x04:
9320 case 0x05:
9321 case 0x06:
9322 case 0x07:
9323 case 0x08:
9324 case 0x09:
9325 case 0x0a:
9326 case 0x0b:
9327 case 0x0c:
9328 case 0x0d:
9329 case 0x0e:
a117b0a5 9330 goto op_semantics_73;
c7927a3c
NC		 9331 break;
9332 case 0x0f:
a117b0a5 9333 goto op_semantics_74;
c7927a3c
NC		 9334 break;
9335 }
9336 break;
9337 case 0xeb:
9338 GETBYTE ();
9339 switch (op[2] & 0x0f)
9340 {
9341 case 0x00:
9342 case 0x01:
9343 case 0x02:
9344 case 0x03:
9345 case 0x04:
9346 case 0x05:
9347 case 0x06:
9348 case 0x07:
9349 case 0x08:
9350 case 0x09:
9351 case 0x0a:
9352 case 0x0b:
9353 case 0x0c:
9354 case 0x0d:
9355 case 0x0e:
a117b0a5 9356 goto op_semantics_73;
c7927a3c
NC		 9357 break;
9358 case 0x0f:
a117b0a5 9359 goto op_semantics_74;
c7927a3c
NC		 9360 break;
9361 }
9362 break;
9363 case 0xec:
9364 GETBYTE ();
9365 switch (op[2] & 0x0f)
9366 {
9367 case 0x00:
9368 case 0x01:
9369 case 0x02:
9370 case 0x03:
9371 case 0x04:
9372 case 0x05:
9373 case 0x06:
9374 case 0x07:
9375 case 0x08:
9376 case 0x09:
9377 case 0x0a:
9378 case 0x0b:
9379 case 0x0c:
9380 case 0x0d:
9381 case 0x0e:
a117b0a5 9382 goto op_semantics_73;
c7927a3c
NC		 9383 break;
9384 case 0x0f:
a117b0a5 9385 goto op_semantics_74;
c7927a3c
NC		 9386 break;
9387 }
9388 break;
9389 case 0xed:
9390 GETBYTE ();
9391 switch (op[2] & 0x0f)
9392 {
9393 case 0x00:
9394 case 0x01:
9395 case 0x02:
9396 case 0x03:
9397 case 0x04:
9398 case 0x05:
9399 case 0x06:
9400 case 0x07:
9401 case 0x08:
9402 case 0x09:
9403 case 0x0a:
9404 case 0x0b:
9405 case 0x0c:
9406 case 0x0d:
9407 case 0x0e:
a117b0a5 9408 goto op_semantics_73;
c7927a3c
NC		 9409 break;
9410 case 0x0f:
a117b0a5 9411 goto op_semantics_74;
c7927a3c
NC		 9412 break;
9413 }
9414 break;
9415 case 0xee:
9416 GETBYTE ();
9417 switch (op[2] & 0x0f)
9418 {
9419 case 0x00:
9420 case 0x01:
9421 case 0x02:
9422 case 0x03:
9423 case 0x04:
9424 case 0x05:
9425 case 0x06:
9426 case 0x07:
9427 case 0x08:
9428 case 0x09:
9429 case 0x0a:
9430 case 0x0b:
9431 case 0x0c:
9432 case 0x0d:
9433 case 0x0e:
a117b0a5 9434 goto op_semantics_73;
c7927a3c
NC		 9435 break;
9436 case 0x0f:
a117b0a5 9437 goto op_semantics_74;
c7927a3c
NC		 9438 break;
9439 }
9440 break;
9441 case 0xef:
9442 GETBYTE ();
9443 switch (op[2] & 0x0f)
9444 {
9445 case 0x00:
9446 case 0x01:
9447 case 0x02:
9448 case 0x03:
9449 case 0x04:
9450 case 0x05:
9451 case 0x06:
9452 case 0x07:
9453 case 0x08:
9454 case 0x09:
9455 case 0x0a:
9456 case 0x0b:
9457 case 0x0c:
9458 case 0x0d:
9459 case 0x0e:
a117b0a5 9460 goto op_semantics_73;
c7927a3c
NC		 9461 break;
9462 case 0x0f:
a117b0a5 9463 goto op_semantics_74;
c7927a3c
NC		 9464 break;
9465 }
9466 break;
9467 case 0xf0:
9468 GETBYTE ();
9469 switch (op[2] & 0x0f)
9470 {
9471 case 0x00:
9472 case 0x01:
9473 case 0x02:
9474 case 0x03:
9475 case 0x04:
9476 case 0x05:
9477 case 0x06:
9478 case 0x07:
9479 case 0x08:
9480 case 0x09:
9481 case 0x0a:
9482 case 0x0b:
9483 case 0x0c:
9484 case 0x0d:
9485 case 0x0e:
a117b0a5 9486 goto op_semantics_73;
c7927a3c
NC		 9487 break;
9488 case 0x0f:
a117b0a5 9489 goto op_semantics_74;
c7927a3c
NC		 9490 break;
9491 }
9492 break;
9493 case 0xf1:
9494 GETBYTE ();
9495 switch (op[2] & 0x0f)
9496 {
9497 case 0x00:
9498 case 0x01:
9499 case 0x02:
9500 case 0x03:
9501 case 0x04:
9502 case 0x05:
9503 case 0x06:
9504 case 0x07:
9505 case 0x08:
9506 case 0x09:
9507 case 0x0a:
9508 case 0x0b:
9509 case 0x0c:
9510 case 0x0d:
9511 case 0x0e:
a117b0a5 9512 goto op_semantics_73;
c7927a3c
NC		 9513 break;
9514 case 0x0f:
a117b0a5 9515 goto op_semantics_74;
c7927a3c
NC		 9516 break;
9517 }
9518 break;
9519 case 0xf2:
9520 GETBYTE ();
9521 switch (op[2] & 0x0f)
9522 {
9523 case 0x00:
9524 case 0x01:
9525 case 0x02:
9526 case 0x03:
9527 case 0x04:
9528 case 0x05:
9529 case 0x06:
9530 case 0x07:
9531 case 0x08:
9532 case 0x09:
9533 case 0x0a:
9534 case 0x0b:
9535 case 0x0c:
9536 case 0x0d:
9537 case 0x0e:
a117b0a5 9538 goto op_semantics_73;
c7927a3c
NC		 9539 break;
9540 case 0x0f:
a117b0a5 9541 goto op_semantics_74;
c7927a3c
NC		 9542 break;
9543 }
9544 break;
9545 case 0xf3:
9546 GETBYTE ();
9547 switch (op[2] & 0x0f)
9548 {
9549 case 0x00:
9550 case 0x01:
9551 case 0x02:
9552 case 0x03:
9553 case 0x04:
9554 case 0x05:
9555 case 0x06:
9556 case 0x07:
9557 case 0x08:
9558 case 0x09:
9559 case 0x0a:
9560 case 0x0b:
9561 case 0x0c:
9562 case 0x0d:
9563 case 0x0e:
a117b0a5 9564 goto op_semantics_73;
c7927a3c
NC		 9565 break;
9566 case 0x0f:
a117b0a5 9567 goto op_semantics_74;
c7927a3c
NC		 9568 break;
9569 }
9570 break;
9571 case 0xf4:
9572 GETBYTE ();
9573 switch (op[2] & 0x0f)
9574 {
9575 case 0x00:
9576 case 0x01:
9577 case 0x02:
9578 case 0x03:
9579 case 0x04:
9580 case 0x05:
9581 case 0x06:
9582 case 0x07:
9583 case 0x08:
9584 case 0x09:
9585 case 0x0a:
9586 case 0x0b:
9587 case 0x0c:
9588 case 0x0d:
9589 case 0x0e:
a117b0a5 9590 goto op_semantics_73;
c7927a3c
NC		 9591 break;
9592 case 0x0f:
a117b0a5 9593 goto op_semantics_74;
c7927a3c
NC		 9594 break;
9595 }
9596 break;
9597 case 0xf5:
9598 GETBYTE ();
9599 switch (op[2] & 0x0f)
9600 {
9601 case 0x00:
9602 case 0x01:
9603 case 0x02:
9604 case 0x03:
9605 case 0x04:
9606 case 0x05:
9607 case 0x06:
9608 case 0x07:
9609 case 0x08:
9610 case 0x09:
9611 case 0x0a:
9612 case 0x0b:
9613 case 0x0c:
9614 case 0x0d:
9615 case 0x0e:
a117b0a5 9616 goto op_semantics_73;
c7927a3c
NC		 9617 break;
9618 case 0x0f:
a117b0a5 9619 goto op_semantics_74;
c7927a3c
NC		 9620 break;
9621 }
9622 break;
9623 case 0xf6:
9624 GETBYTE ();
9625 switch (op[2] & 0x0f)
9626 {
9627 case 0x00:
9628 case 0x01:
9629 case 0x02:
9630 case 0x03:
9631 case 0x04:
9632 case 0x05:
9633 case 0x06:
9634 case 0x07:
9635 case 0x08:
9636 case 0x09:
9637 case 0x0a:
9638 case 0x0b:
9639 case 0x0c:
9640 case 0x0d:
9641 case 0x0e:
a117b0a5 9642 goto op_semantics_73;
c7927a3c
NC		 9643 break;
9644 case 0x0f:
a117b0a5 9645 goto op_semantics_74;
c7927a3c
NC		 9646 break;
9647 }
9648 break;
9649 case 0xf7:
9650 GETBYTE ();
9651 switch (op[2] & 0x0f)
9652 {
9653 case 0x00:
9654 case 0x01:
9655 case 0x02:
9656 case 0x03:
9657 case 0x04:
9658 case 0x05:
9659 case 0x06:
9660 case 0x07:
9661 case 0x08:
9662 case 0x09:
9663 case 0x0a:
9664 case 0x0b:
9665 case 0x0c:
9666 case 0x0d:
9667 case 0x0e:
a117b0a5 9668 goto op_semantics_73;
c7927a3c
NC		 9669 break;
9670 case 0x0f:
a117b0a5 9671 goto op_semantics_74;
c7927a3c
NC		 9672 break;
9673 }
9674 break;
9675 case 0xf8:
9676 GETBYTE ();
9677 switch (op[2] & 0x0f)
9678 {
9679 case 0x00:
9680 case 0x01:
9681 case 0x02:
9682 case 0x03:
9683 case 0x04:
9684 case 0x05:
9685 case 0x06:
9686 case 0x07:
9687 case 0x08:
9688 case 0x09:
9689 case 0x0a:
9690 case 0x0b:
9691 case 0x0c:
9692 case 0x0d:
9693 case 0x0e:
a117b0a5 9694 goto op_semantics_73;
c7927a3c
NC		 9695 break;
9696 case 0x0f:
a117b0a5 9697 goto op_semantics_74;
c7927a3c
NC		 9698 break;
9699 }
9700 break;
9701 case 0xf9:
9702 GETBYTE ();
9703 switch (op[2] & 0x0f)
9704 {
9705 case 0x00:
9706 case 0x01:
9707 case 0x02:
9708 case 0x03:
9709 case 0x04:
9710 case 0x05:
9711 case 0x06:
9712 case 0x07:
9713 case 0x08:
9714 case 0x09:
9715 case 0x0a:
9716 case 0x0b:
9717 case 0x0c:
9718 case 0x0d:
9719 case 0x0e:
a117b0a5 9720 goto op_semantics_73;
c7927a3c
NC		 9721 break;
9722 case 0x0f:
a117b0a5 9723 goto op_semantics_74;
c7927a3c
NC		 9724 break;
9725 }
9726 break;
9727 case 0xfa:
9728 GETBYTE ();
9729 switch (op[2] & 0x0f)
9730 {
9731 case 0x00:
9732 case 0x01:
9733 case 0x02:
9734 case 0x03:
9735 case 0x04:
9736 case 0x05:
9737 case 0x06:
9738 case 0x07:
9739 case 0x08:
9740 case 0x09:
9741 case 0x0a:
9742 case 0x0b:
9743 case 0x0c:
9744 case 0x0d:
9745 case 0x0e:
a117b0a5 9746 goto op_semantics_73;
c7927a3c
NC		 9747 break;
9748 case 0x0f:
a117b0a5 9749 goto op_semantics_74;
c7927a3c
NC		 9750 break;
9751 }
9752 break;
9753 case 0xfb:
9754 GETBYTE ();
9755 switch (op[2] & 0x0f)
9756 {
9757 case 0x00:
9758 case 0x01:
9759 case 0x02:
9760 case 0x03:
9761 case 0x04:
9762 case 0x05:
9763 case 0x06:
9764 case 0x07:
9765 case 0x08:
9766 case 0x09:
9767 case 0x0a:
9768 case 0x0b:
9769 case 0x0c:
9770 case 0x0d:
9771 case 0x0e:
a117b0a5 9772 goto op_semantics_73;
c7927a3c
NC		 9773 break;
9774 case 0x0f:
a117b0a5 9775 goto op_semantics_74;
c7927a3c
NC		 9776 break;
9777 }
9778 break;
9779 case 0xfc:
9780 GETBYTE ();
9781 switch (op[2] & 0x0f)
9782 {
9783 case 0x00:
9784 case 0x01:
9785 case 0x02:
9786 case 0x03:
9787 case 0x04:
9788 case 0x05:
9789 case 0x06:
9790 case 0x07:
9791 case 0x08:
9792 case 0x09:
9793 case 0x0a:
9794 case 0x0b:
9795 case 0x0c:
9796 case 0x0d:
9797 case 0x0e:
a117b0a5 9798 goto op_semantics_73;
c7927a3c
NC		 9799 break;
9800 case 0x0f:
a117b0a5 9801 goto op_semantics_74;
c7927a3c
NC		 9802 break;
9803 }
9804 break;
9805 case 0xfd:
9806 GETBYTE ();
9807 switch (op[2] & 0x0f)
9808 {
9809 case 0x00:
9810 case 0x01:
9811 case 0x02:
9812 case 0x03:
9813 case 0x04:
9814 case 0x05:
9815 case 0x06:
9816 case 0x07:
9817 case 0x08:
9818 case 0x09:
9819 case 0x0a:
9820 case 0x0b:
9821 case 0x0c:
9822 case 0x0d:
9823 case 0x0e:
a117b0a5 9824 goto op_semantics_73;
c7927a3c
NC		 9825 break;
9826 case 0x0f:
a117b0a5 9827 goto op_semantics_74;
c7927a3c
NC		 9828 break;
9829 }
9830 break;
9831 case 0xfe:
9832 GETBYTE ();
9833 switch (op[2] & 0x0f)
9834 {
9835 case 0x00:
9836 case 0x01:
9837 case 0x02:
9838 case 0x03:
9839 case 0x04:
9840 case 0x05:
9841 case 0x06:
9842 case 0x07:
9843 case 0x08:
9844 case 0x09:
9845 case 0x0a:
9846 case 0x0b:
9847 case 0x0c:
9848 case 0x0d:
9849 case 0x0e:
a117b0a5 9850 goto op_semantics_73;
c7927a3c
NC		 9851 break;
9852 case 0x0f:
a117b0a5 9853 goto op_semantics_74;
c7927a3c
NC		 9854 break;
9855 }
9856 break;
9857 case 0xff:
9858 GETBYTE ();
9859 switch (op[2] & 0x0f)
9860 {
9861 case 0x00:
9862 case 0x01:
9863 case 0x02:
9864 case 0x03:
9865 case 0x04:
9866 case 0x05:
9867 case 0x06:
9868 case 0x07:
9869 case 0x08:
9870 case 0x09:
9871 case 0x0a:
9872 case 0x0b:
9873 case 0x0c:
9874 case 0x0d:
9875 case 0x0e:
a117b0a5 9876 goto op_semantics_73;
c7927a3c
NC		 9877 break;
9878 case 0x0f:
a117b0a5 9879 goto op_semantics_74;
c7927a3c
NC		 9880 break;
9881 }
9882 break;
9883 default: UNSUPPORTED(); break;
9884 }
9885 break;
9886 case 0xfd:
9887 GETBYTE ();
9888 switch (op[1] & 0xff)
9889 {
9890 case 0x00:
9891 GETBYTE ();
9892 switch (op[2] & 0x00)
9893 {
9894 case 0x00:
a117b0a5 9895 op_semantics_75:
c7927a3c 9896 {
a117b0a5
YS		 9897 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
9898#line 848 "rx-decode.opc"
9899 int a AU = (op[1] >> 3) & 0x01;
9900#line 848 "rx-decode.opc"
c7927a3c 9901 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 9902#line 848 "rx-decode.opc"
c7927a3c
NC		 9903 int srcb AU = op[2] & 0x0f;
9904 if (trace)
9905 {
9906 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 9907 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
c7927a3c 9908 op[0], op[1], op[2]);
a117b0a5 9909 printf (" a = 0x%x,", a);
c7927a3c
NC		 9910 printf (" srca = 0x%x,", srca);
9911 printf (" srcb = 0x%x\n", srcb);
9912 }
a117b0a5
YS		 9913 SYNTAX("mulhi %1, %2, %0");
9914#line 848 "rx-decode.opc"
9915 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 9916
c7927a3c
NC		 9917 }
9918 break;
9919 }
9920 break;
9921 case 0x01:
9922 GETBYTE ();
9923 switch (op[2] & 0x00)
9924 {
9925 case 0x00:
a117b0a5 9926 op_semantics_76:
c7927a3c 9927 {
a117b0a5
YS		 9928 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
9929#line 851 "rx-decode.opc"
9930 int a AU = (op[1] >> 3) & 0x01;
9931#line 851 "rx-decode.opc"
c7927a3c 9932 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 9933#line 851 "rx-decode.opc"
c7927a3c
NC		 9934 int srcb AU = op[2] & 0x0f;
9935 if (trace)
9936 {
9937 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 9938 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
c7927a3c 9939 op[0], op[1], op[2]);
a117b0a5 9940 printf (" a = 0x%x,", a);
c7927a3c
NC		 9941 printf (" srca = 0x%x,", srca);
9942 printf (" srcb = 0x%x\n", srcb);
9943 }
a117b0a5
YS		 9944 SYNTAX("mullo %1, %2, %0");
9945#line 851 "rx-decode.opc"
9946 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 9947
c7927a3c
NC		 9948 }
9949 break;
9950 }
9951 break;
a117b0a5 9952 case 0x02:
c7927a3c
NC		 9953 GETBYTE ();
9954 switch (op[2] & 0x00)
9955 {
9956 case 0x00:
a117b0a5 9957 op_semantics_77:
c7927a3c 9958 {
a117b0a5
YS		 9959 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
9960#line 1079 "rx-decode.opc"
9961 int a AU = (op[1] >> 3) & 0x01;
9962#line 1079 "rx-decode.opc"
c7927a3c 9963 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 9964#line 1079 "rx-decode.opc"
c7927a3c
NC		 9965 int srcb AU = op[2] & 0x0f;
9966 if (trace)
9967 {
9968 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 9969 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
c7927a3c 9970 op[0], op[1], op[2]);
a117b0a5 9971 printf (" a = 0x%x,", a);
c7927a3c
NC		 9972 printf (" srca = 0x%x,", srca);
9973 printf (" srcb = 0x%x\n", srcb);
9974 }
a117b0a5
YS		 9975 SYNTAX("mullh %1, %2, %0");
9976#line 1079 "rx-decode.opc"
9977 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 9978
c7927a3c
NC		 9979 }
9980 break;
9981 }
9982 break;
a117b0a5 9983 case 0x03:
c7927a3c
NC		 9984 GETBYTE ();
9985 switch (op[2] & 0x00)
9986 {
9987 case 0x00:
a117b0a5 9988 op_semantics_78:
c7927a3c 9989 {
a117b0a5
YS		 9990 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
9991#line 1064 "rx-decode.opc"
9992 int a AU = (op[1] >> 3) & 0x01;
9993#line 1064 "rx-decode.opc"
c7927a3c 9994 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 9995#line 1064 "rx-decode.opc"
c7927a3c
NC		 9996 int srcb AU = op[2] & 0x0f;
9997 if (trace)
9998 {
9999 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10000 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
c7927a3c 10001 op[0], op[1], op[2]);
a117b0a5 10002 printf (" a = 0x%x,", a);
c7927a3c
NC		 10003 printf (" srca = 0x%x,", srca);
10004 printf (" srcb = 0x%x\n", srcb);
10005 }
a117b0a5
YS		 10006 SYNTAX("emula %1, %2, %0");
10007#line 1064 "rx-decode.opc"
10008 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10009
c7927a3c
NC		 10010 }
10011 break;
10012 }
10013 break;
a117b0a5 10014 case 0x04:
c7927a3c 10015 GETBYTE ();
a117b0a5 10016 switch (op[2] & 0x00)
c7927a3c
NC		 10017 {
10018 case 0x00:
a117b0a5 10019 op_semantics_79:
c7927a3c 10020 {
a117b0a5
YS		 10021 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
10022#line 854 "rx-decode.opc"
10023 int a AU = (op[1] >> 3) & 0x01;
10024#line 854 "rx-decode.opc"
10025 int srca AU = (op[2] >> 4) & 0x0f;
10026#line 854 "rx-decode.opc"
10027 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10028 if (trace)
10029 {
10030 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10031 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
c7927a3c 10032 op[0], op[1], op[2]);
a117b0a5
YS		 10033 printf (" a = 0x%x,", a);
10034 printf (" srca = 0x%x,", srca);
10035 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10036 }
a117b0a5
YS		 10037 SYNTAX("machi %1, %2, %0");
10038#line 854 "rx-decode.opc"
10039 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10040
c7927a3c
NC		 10041 }
10042 break;
c7927a3c
NC		 10043 }
10044 break;
a117b0a5 10045 case 0x05:
c7927a3c 10046 GETBYTE ();
a117b0a5 10047 switch (op[2] & 0x00)
c7927a3c
NC		 10048 {
10049 case 0x00:
a117b0a5 10050 op_semantics_80:
c7927a3c 10051 {
a117b0a5
YS		 10052 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
10053#line 857 "rx-decode.opc"
10054 int a AU = (op[1] >> 3) & 0x01;
10055#line 857 "rx-decode.opc"
10056 int srca AU = (op[2] >> 4) & 0x0f;
10057#line 857 "rx-decode.opc"
10058 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10059 if (trace)
10060 {
10061 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10062 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
c7927a3c 10063 op[0], op[1], op[2]);
a117b0a5
YS		 10064 printf (" a = 0x%x,", a);
10065 printf (" srca = 0x%x,", srca);
10066 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10067 }
a117b0a5
YS		 10068 SYNTAX("maclo %1, %2, %0");
10069#line 857 "rx-decode.opc"
10070 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10071
c7927a3c
NC		 10072 }
10073 break;
c7927a3c
NC		 10074 }
10075 break;
a117b0a5 10076 case 0x06:
c7927a3c 10077 GETBYTE ();
a117b0a5 10078 switch (op[2] & 0x00)
c7927a3c
NC		 10079 {
10080 case 0x00:
a117b0a5 10081 op_semantics_81:
c7927a3c 10082 {
a117b0a5
YS		 10083 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
10084#line 1067 "rx-decode.opc"
10085 int a AU = (op[1] >> 3) & 0x01;
10086#line 1067 "rx-decode.opc"
10087 int srca AU = (op[2] >> 4) & 0x0f;
10088#line 1067 "rx-decode.opc"
10089 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10090 if (trace)
10091 {
10092 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10093 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
c7927a3c 10094 op[0], op[1], op[2]);
a117b0a5
YS		 10095 printf (" a = 0x%x,", a);
10096 printf (" srca = 0x%x,", srca);
10097 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10098 }
a117b0a5
YS		 10099 SYNTAX("maclh %1, %2, %0");
10100#line 1067 "rx-decode.opc"
10101 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10102
c7927a3c
NC		 10103 }
10104 break;
c7927a3c
NC		 10105 }
10106 break;
a117b0a5 10107 case 0x07:
c7927a3c
NC		 10108 GETBYTE ();
10109 switch (op[2] & 0x00)
10110 {
10111 case 0x00:
a117b0a5 10112 op_semantics_82:
c7927a3c 10113 {
a117b0a5
YS		 10114 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
10115#line 1058 "rx-decode.opc"
10116 int a AU = (op[1] >> 3) & 0x01;
10117#line 1058 "rx-decode.opc"
10118 int srca AU = (op[2] >> 4) & 0x0f;
10119#line 1058 "rx-decode.opc"
10120 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10121 if (trace)
10122 {
10123 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10124 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
c7927a3c 10125 op[0], op[1], op[2]);
a117b0a5
YS		 10126 printf (" a = 0x%x,", a);
10127 printf (" srca = 0x%x,", srca);
10128 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10129 }
a117b0a5
YS		 10130 SYNTAX("emaca %1, %2, %0");
10131#line 1058 "rx-decode.opc"
10132 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10133
c7927a3c
NC		 10134 }
10135 break;
10136 }
10137 break;
a117b0a5 10138 case 0x08:
c7927a3c
NC		 10139 GETBYTE ();
10140 switch (op[2] & 0x00)
10141 {
10142 case 0x00:
a117b0a5 10143 goto op_semantics_75;
c7927a3c
NC		 10144 break;
10145 }
10146 break;
a117b0a5 10147 case 0x09:
c7927a3c
NC		 10148 GETBYTE ();
10149 switch (op[2] & 0x00)
10150 {
10151 case 0x00:
a117b0a5 10152 goto op_semantics_76;
c7927a3c
NC		 10153 break;
10154 }
10155 break;
a117b0a5 10156 case 0x0a:
c7927a3c
NC		 10157 GETBYTE ();
10158 switch (op[2] & 0x00)
10159 {
10160 case 0x00:
a117b0a5 10161 goto op_semantics_77;
c7927a3c
NC		 10162 break;
10163 }
10164 break;
a117b0a5 10165 case 0x0b:
c7927a3c
NC		 10166 GETBYTE ();
10167 switch (op[2] & 0x00)
10168 {
10169 case 0x00:
a117b0a5 10170 goto op_semantics_78;
c7927a3c
NC		 10171 break;
10172 }
10173 break;
a117b0a5 10174 case 0x0c:
c7927a3c
NC		 10175 GETBYTE ();
10176 switch (op[2] & 0x00)
10177 {
10178 case 0x00:
a117b0a5 10179 goto op_semantics_79;
c7927a3c
NC		 10180 break;
10181 }
10182 break;
a117b0a5 10183 case 0x0d:
c7927a3c
NC		 10184 GETBYTE ();
10185 switch (op[2] & 0x00)
10186 {
10187 case 0x00:
a117b0a5 10188 goto op_semantics_80;
c7927a3c
NC		 10189 break;
10190 }
10191 break;
a117b0a5 10192 case 0x0e:
c7927a3c
NC		 10193 GETBYTE ();
10194 switch (op[2] & 0x00)
10195 {
10196 case 0x00:
a117b0a5 10197 goto op_semantics_81;
c7927a3c
NC		 10198 break;
10199 }
10200 break;
a117b0a5 10201 case 0x0f:
c7927a3c
NC		 10202 GETBYTE ();
10203 switch (op[2] & 0x00)
10204 {
10205 case 0x00:
a117b0a5 10206 goto op_semantics_82;
c7927a3c
NC		 10207 break;
10208 }
10209 break;
a117b0a5 10210 case 0x17:
c7927a3c 10211 GETBYTE ();
a117b0a5 10212 switch (op[2] & 0x70)
c7927a3c
NC		 10213 {
10214 case 0x00:
a117b0a5
YS		 10215 {
10216 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10217#line 860 "rx-decode.opc"
10218 int a AU = (op[2] >> 7) & 0x01;
10219#line 860 "rx-decode.opc"
10220 int rsrc AU = op[2] & 0x0f;
10221 if (trace)
10222 {
10223 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10224 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
10225 op[0], op[1], op[2]);
10226 printf (" a = 0x%x,", a);
10227 printf (" rsrc = 0x%x\n", rsrc);
10228 }
10229 SYNTAX("mvtachi %1, %0");
10230#line 860 "rx-decode.opc"
10231 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10232
10233 }
c7927a3c 10234 break;
a117b0a5
YS		 10235 case 0x10:
10236 {
10237 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10238#line 863 "rx-decode.opc"
10239 int a AU = (op[2] >> 7) & 0x01;
10240#line 863 "rx-decode.opc"
10241 int rsrc AU = op[2] & 0x0f;
10242 if (trace)
10243 {
10244 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10245 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
10246 op[0], op[1], op[2]);
10247 printf (" a = 0x%x,", a);
10248 printf (" rsrc = 0x%x\n", rsrc);
10249 }
10250 SYNTAX("mvtaclo %1, %0");
10251#line 863 "rx-decode.opc"
10252 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10253
10254 }
c7927a3c 10255 break;
a117b0a5
YS		 10256 case 0x30:
10257 {
10258 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10259#line 1085 "rx-decode.opc"
10260 int a AU = (op[2] >> 7) & 0x01;
10261#line 1085 "rx-decode.opc"
10262 int rdst AU = op[2] & 0x0f;
10263 if (trace)
10264 {
10265 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10266 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
10267 op[0], op[1], op[2]);
10268 printf (" a = 0x%x,", a);
10269 printf (" rdst = 0x%x\n", rdst);
10270 }
10271 SYNTAX("mvtacgu %0, %1");
10272#line 1085 "rx-decode.opc"
239efab1 10273 ID(mvtacgu); DR(a+32); SR(rdst); F_____;
a117b0a5
YS		 10274
10275 }
c7927a3c 10276 break;
a117b0a5 10277 default: UNSUPPORTED(); break;
c7927a3c
NC		 10278 }
10279 break;
a117b0a5 10280 case 0x18:
c7927a3c 10281 GETBYTE ();
a117b0a5 10282 switch (op[2] & 0x6f)
c7927a3c
NC		 10283 {
10284 case 0x00:
c7927a3c 10285 {
a117b0a5
YS		 10286 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
10287#line 875 "rx-decode.opc"
10288 int a AU = (op[2] >> 7) & 0x01;
10289#line 875 "rx-decode.opc"
10290 int i AU = (op[2] >> 4) & 0x01;
c7927a3c
NC		 10291 if (trace)
10292 {
10293 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10294 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
c7927a3c 10295 op[0], op[1], op[2]);
a117b0a5
YS		 10296 printf (" a = 0x%x,", a);
10297 printf (" i = 0x%x\n", i);
c7927a3c 10298 }
a117b0a5
YS		 10299 SYNTAX("racw #%1, %0");
10300#line 875 "rx-decode.opc"
10301 ID(racw); SC(i+1); DR(a+32); F_____;
43e65147 10302
c7927a3c 10303 /*----------------------------------------------------------------------*/
a117b0a5 10304 /* SAT */
43e65147 10305
c7927a3c
NC		 10306 }
10307 break;
a117b0a5
YS		 10308 case 0x40:
10309 {
10310 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
10311#line 1094 "rx-decode.opc"
10312 int a AU = (op[2] >> 7) & 0x01;
10313#line 1094 "rx-decode.opc"
10314 int i AU = (op[2] >> 4) & 0x01;
10315 if (trace)
10316 {
10317 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10318 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
10319 op[0], op[1], op[2]);
10320 printf (" a = 0x%x,", a);
10321 printf (" i = 0x%x\n", i);
10322 }
10323 SYNTAX("rdacw #%1, %0");
10324#line 1094 "rx-decode.opc"
10325 ID(rdacw); SC(i+1); DR(a+32); F_____;
10326
10327 }
c7927a3c 10328 break;
a117b0a5 10329 default: UNSUPPORTED(); break;
c7927a3c
NC		 10330 }
10331 break;
a117b0a5 10332 case 0x19:
c7927a3c 10333 GETBYTE ();
a117b0a5 10334 switch (op[2] & 0x6f)
c7927a3c
NC		 10335 {
10336 case 0x00:
10337 {
a117b0a5
YS		 10338 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
10339#line 1088 "rx-decode.opc"
10340 int a AU = (op[2] >> 7) & 0x01;
10341#line 1088 "rx-decode.opc"
10342 int i AU = (op[2] >> 4) & 0x01;
c7927a3c
NC		 10343 if (trace)
10344 {
10345 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10346 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
c7927a3c 10347 op[0], op[1], op[2]);
a117b0a5
YS		 10348 printf (" a = 0x%x,", a);
10349 printf (" i = 0x%x\n", i);
c7927a3c 10350 }
a117b0a5
YS		 10351 SYNTAX("racl #%1, %0");
10352#line 1088 "rx-decode.opc"
10353 ID(racl); SC(i+1); DR(a+32); F_____;
43e65147 10354
c7927a3c
NC		 10355 }
10356 break;
a117b0a5 10357 case 0x40:
c7927a3c 10358 {
a117b0a5
YS		 10359 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
10360#line 1091 "rx-decode.opc"
10361 int a AU = (op[2] >> 7) & 0x01;
10362#line 1091 "rx-decode.opc"
10363 int i AU = (op[2] >> 4) & 0x01;
c7927a3c
NC		 10364 if (trace)
10365 {
10366 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10367 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
c7927a3c 10368 op[0], op[1], op[2]);
a117b0a5
YS		 10369 printf (" a = 0x%x,", a);
10370 printf (" i = 0x%x\n", i);
c7927a3c 10371 }
a117b0a5
YS		 10372 SYNTAX("rdacl #%1, %0");
10373#line 1091 "rx-decode.opc"
10374 ID(rdacl); SC(i+1); DR(a+32); F_____;
43e65147 10375
c7927a3c
NC		 10376 }
10377 break;
a117b0a5 10378 default: UNSUPPORTED(); break;
c7927a3c
NC		 10379 }
10380 break;
a117b0a5 10381 case 0x1e:
c7927a3c 10382 GETBYTE ();
a117b0a5 10383 switch (op[2] & 0x30)
c7927a3c
NC		 10384 {
10385 case 0x00:
a117b0a5 10386 op_semantics_83:
c7927a3c 10387 {
a117b0a5
YS		 10388 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
10389#line 866 "rx-decode.opc"
10390 int i AU = op[1] & 0x01;
10391#line 866 "rx-decode.opc"
10392 int a AU = (op[2] >> 7) & 0x01;
10393#line 866 "rx-decode.opc"
10394 int m AU = (op[2] >> 6) & 0x01;
10395#line 866 "rx-decode.opc"
c7927a3c
NC		 10396 int rdst AU = op[2] & 0x0f;
10397 if (trace)
10398 {
10399 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10400 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
c7927a3c 10401 op[0], op[1], op[2]);
a117b0a5
YS		 10402 printf (" i = 0x%x,", i);
10403 printf (" a = 0x%x,", a);
10404 printf (" m = 0x%x,", m);
c7927a3c
NC		 10405 printf (" rdst = 0x%x\n", rdst);
10406 }
a117b0a5
YS		 10407 SYNTAX("mvfachi #%2, %1, %0");
10408#line 866 "rx-decode.opc"
10409 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10410
c7927a3c
NC		 10411 }
10412 break;
a117b0a5
YS		 10413 case 0x10:
10414 op_semantics_84:
c7927a3c 10415 {
a117b0a5
YS		 10416 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
10417#line 872 "rx-decode.opc"
10418 int i AU = op[1] & 0x01;
10419#line 872 "rx-decode.opc"
10420 int a AU = (op[2] >> 7) & 0x01;
10421#line 872 "rx-decode.opc"
10422 int m AU = (op[2] >> 6) & 0x01;
10423#line 872 "rx-decode.opc"
c7927a3c
NC		 10424 int rdst AU = op[2] & 0x0f;
10425 if (trace)
10426 {
10427 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10428 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
c7927a3c 10429 op[0], op[1], op[2]);
a117b0a5
YS		 10430 printf (" i = 0x%x,", i);
10431 printf (" a = 0x%x,", a);
10432 printf (" m = 0x%x,", m);
c7927a3c
NC		 10433 printf (" rdst = 0x%x\n", rdst);
10434 }
a117b0a5
YS		 10435 SYNTAX("mvfaclo #%2, %1, %0");
10436#line 872 "rx-decode.opc"
10437 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10438
c7927a3c
NC		 10439 }
10440 break;
a117b0a5
YS		 10441 case 0x20:
10442 op_semantics_85:
c7927a3c 10443 {
a117b0a5
YS		 10444 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
10445#line 869 "rx-decode.opc"
10446 int i AU = op[1] & 0x01;
10447#line 869 "rx-decode.opc"
10448 int a AU = (op[2] >> 7) & 0x01;
10449#line 869 "rx-decode.opc"
10450 int m AU = (op[2] >> 6) & 0x01;
10451#line 869 "rx-decode.opc"
c7927a3c
NC		 10452 int rdst AU = op[2] & 0x0f;
10453 if (trace)
10454 {
10455 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10456 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
c7927a3c 10457 op[0], op[1], op[2]);
a117b0a5
YS		 10458 printf (" i = 0x%x,", i);
10459 printf (" a = 0x%x,", a);
10460 printf (" m = 0x%x,", m);
c7927a3c
NC		 10461 printf (" rdst = 0x%x\n", rdst);
10462 }
a117b0a5
YS		 10463 SYNTAX("mvfacmi #%2, %1, %0");
10464#line 869 "rx-decode.opc"
10465 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10466
c7927a3c
NC		 10467 }
10468 break;
a117b0a5
YS		 10469 case 0x30:
10470 op_semantics_86:
c7927a3c 10471 {
a117b0a5
YS		 10472 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
10473#line 1082 "rx-decode.opc"
10474 int i AU = op[1] & 0x01;
10475#line 1082 "rx-decode.opc"
10476 int a AU = (op[2] >> 7) & 0x01;
10477#line 1082 "rx-decode.opc"
10478 int m AU = (op[2] >> 6) & 0x01;
10479#line 1082 "rx-decode.opc"
c7927a3c
NC		 10480 int rdst AU = op[2] & 0x0f;
10481 if (trace)
10482 {
10483 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10484 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
c7927a3c 10485 op[0], op[1], op[2]);
a117b0a5
YS		 10486 printf (" i = 0x%x,", i);
10487 printf (" a = 0x%x,", a);
10488 printf (" m = 0x%x,", m);
c7927a3c
NC		 10489 printf (" rdst = 0x%x\n", rdst);
10490 }
a117b0a5
YS		 10491 SYNTAX("mvfacgu #%2, %1, %0");
10492#line 1082 "rx-decode.opc"
10493 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10494
c7927a3c
NC		 10495 }
10496 break;
10497 }
10498 break;
a117b0a5 10499 case 0x1f:
c7927a3c 10500 GETBYTE ();
a117b0a5 10501 switch (op[2] & 0x30)
c7927a3c
NC		 10502 {
10503 case 0x00:
a117b0a5
YS		 10504 goto op_semantics_83;
10505 break;
10506 case 0x10:
10507 goto op_semantics_84;
10508 break;
10509 case 0x20:
10510 goto op_semantics_85;
10511 break;
10512 case 0x30:
10513 goto op_semantics_86;
c7927a3c
NC		 10514 break;
10515 }
10516 break;
a117b0a5 10517 case 0x20:
c7927a3c
NC		 10518 GETBYTE ();
10519 switch (op[2] & 0x00)
10520 {
10521 case 0x00:
a117b0a5 10522 op_semantics_87:
c7927a3c 10523 {
a117b0a5
YS		 10524 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
10525#line 344 "rx-decode.opc"
10526 int p AU = (op[1] >> 2) & 0x01;
10527#line 344 "rx-decode.opc"
10528 int sz AU = op[1] & 0x03;
10529#line 344 "rx-decode.opc"
10530 int rdst AU = (op[2] >> 4) & 0x0f;
10531#line 344 "rx-decode.opc"
10532 int rsrc AU = op[2] & 0x0f;
c7927a3c
NC		 10533 if (trace)
10534 {
10535 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10536 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
c7927a3c 10537 op[0], op[1], op[2]);
a117b0a5
YS		 10538 printf (" p = 0x%x,", p);
10539 printf (" sz = 0x%x,", sz);
10540 printf (" rdst = 0x%x,", rdst);
10541 printf (" rsrc = 0x%x\n", rsrc);
c7927a3c 10542 }
a117b0a5
YS		 10543 SYNTAX("mov%s %1, %0");
10544#line 344 "rx-decode.opc"
10545 ID(mov); sBWL (sz); SR(rsrc); F_____;
10546 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
43e65147 10547
c7927a3c
NC		 10548 }
10549 break;
10550 }
10551 break;
a117b0a5 10552 case 0x21:
c7927a3c
NC		 10553 GETBYTE ();
10554 switch (op[2] & 0x00)
10555 {
10556 case 0x00:
a117b0a5 10557 goto op_semantics_87;
c7927a3c
NC		 10558 break;
10559 }
10560 break;
a117b0a5 10561 case 0x22:
c7927a3c
NC		 10562 GETBYTE ();
10563 switch (op[2] & 0x00)
10564 {
10565 case 0x00:
a117b0a5 10566 goto op_semantics_87;
c7927a3c
NC		 10567 break;
10568 }
10569 break;
a117b0a5 10570 case 0x24:
c7927a3c
NC		 10571 GETBYTE ();
10572 switch (op[2] & 0x00)
10573 {
10574 case 0x00:
a117b0a5 10575 goto op_semantics_87;
c7927a3c
NC		 10576 break;
10577 }
10578 break;
a117b0a5 10579 case 0x25:
c7927a3c
NC		 10580 GETBYTE ();
10581 switch (op[2] & 0x00)
10582 {
10583 case 0x00:
a117b0a5 10584 goto op_semantics_87;
c7927a3c
NC		 10585 break;
10586 }
10587 break;
a117b0a5 10588 case 0x26:
c7927a3c
NC		 10589 GETBYTE ();
10590 switch (op[2] & 0x00)
10591 {
10592 case 0x00:
a117b0a5 10593 goto op_semantics_87;
c7927a3c
NC		 10594 break;
10595 }
10596 break;
a117b0a5 10597 case 0x27:
c7927a3c
NC		 10598 GETBYTE ();
10599 switch (op[2] & 0x00)
10600 {
10601 case 0x00:
c7927a3c 10602 {
a117b0a5
YS		 10603 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
10604#line 1046 "rx-decode.opc"
10605 int rdst AU = (op[2] >> 4) & 0x0f;
10606#line 1046 "rx-decode.opc"
10607 int rsrc AU = op[2] & 0x0f;
10608 if (trace)
10609 {
10610 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10611 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
10612 op[0], op[1], op[2]);
10613 printf (" rdst = 0x%x,", rdst);
10614 printf (" rsrc = 0x%x\n", rsrc);
10615 }
10616 SYNTAX("movco %1, [%0]");
10617#line 1046 "rx-decode.opc"
239efab1 10618 ID(movco); SR(rsrc); DR(rdst); F_____;
a117b0a5
YS		 10619
10620 }
10621 break;
10622 }
10623 break;
10624 case 0x28:
10625 GETBYTE ();
10626 switch (op[2] & 0x00)
10627 {
10628 case 0x00:
10629 op_semantics_88:
10630 {
10631 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
10632#line 348 "rx-decode.opc"
10633 int p AU = (op[1] >> 2) & 0x01;
10634#line 348 "rx-decode.opc"
10635 int sz AU = op[1] & 0x03;
10636#line 348 "rx-decode.opc"
10637 int rsrc AU = (op[2] >> 4) & 0x0f;
10638#line 348 "rx-decode.opc"
c7927a3c
NC		 10639 int rdst AU = op[2] & 0x0f;
10640 if (trace)
10641 {
10642 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10643 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
c7927a3c 10644 op[0], op[1], op[2]);
a117b0a5
YS		 10645 printf (" p = 0x%x,", p);
10646 printf (" sz = 0x%x,", sz);
10647 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10648 printf (" rdst = 0x%x\n", rdst);
10649 }
a117b0a5
YS		 10650 SYNTAX("mov%s %1, %0");
10651#line 348 "rx-decode.opc"
10652 ID(mov); sBWL (sz); DR(rdst); F_____;
10653 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
43e65147 10654
c7927a3c
NC		 10655 }
10656 break;
10657 }
10658 break;
a117b0a5 10659 case 0x29:
c7927a3c
NC		 10660 GETBYTE ();
10661 switch (op[2] & 0x00)
10662 {
10663 case 0x00:
a117b0a5 10664 goto op_semantics_88;
c7927a3c
NC		 10665 break;
10666 }
10667 break;
a117b0a5 10668 case 0x2a:
c7927a3c 10669 GETBYTE ();
a117b0a5 10670 switch (op[2] & 0x00)
c7927a3c 10671 {
a117b0a5
YS		 10672 case 0x00:
10673 goto op_semantics_88;
10674 break;
10675 }
10676 break;
10677 case 0x2c:
10678 GETBYTE ();
10679 switch (op[2] & 0x00)
10680 {
10681 case 0x00:
10682 goto op_semantics_88;
10683 break;
10684 }
10685 break;
10686 case 0x2d:
10687 GETBYTE ();
10688 switch (op[2] & 0x00)
10689 {
10690 case 0x00:
10691 goto op_semantics_88;
10692 break;
10693 }
10694 break;
10695 case 0x2e:
10696 GETBYTE ();
10697 switch (op[2] & 0x00)
10698 {
10699 case 0x00:
10700 goto op_semantics_88;
10701 break;
10702 }
10703 break;
10704 case 0x2f:
10705 GETBYTE ();
10706 switch (op[2] & 0x00)
10707 {
10708 case 0x00:
c7927a3c 10709 {
a117b0a5
YS		 10710 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
10711#line 1049 "rx-decode.opc"
10712 int rsrc AU = (op[2] >> 4) & 0x0f;
10713#line 1049 "rx-decode.opc"
c7927a3c
NC		 10714 int rdst AU = op[2] & 0x0f;
10715 if (trace)
10716 {
10717 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10718 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
c7927a3c 10719 op[0], op[1], op[2]);
a117b0a5 10720 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10721 printf (" rdst = 0x%x\n", rdst);
10722 }
a117b0a5
YS		 10723 SYNTAX("movli [%1], %0");
10724#line 1049 "rx-decode.opc"
239efab1 10725 ID(movli); SR(rsrc); DR(rdst); F_____;
43e65147 10726
c7927a3c
NC		 10727 }
10728 break;
a117b0a5
YS		 10729 }
10730 break;
10731 case 0x38:
10732 GETBYTE ();
10733 switch (op[2] & 0x00)
10734 {
10735 case 0x00:
10736 op_semantics_89:
c7927a3c 10737 {
a117b0a5
YS		 10738 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
10739#line 358 "rx-decode.opc"
10740 int p AU = (op[1] >> 2) & 0x01;
10741#line 358 "rx-decode.opc"
10742 int sz AU = op[1] & 0x03;
10743#line 358 "rx-decode.opc"
10744 int rsrc AU = (op[2] >> 4) & 0x0f;
10745#line 358 "rx-decode.opc"
c7927a3c
NC		 10746 int rdst AU = op[2] & 0x0f;
10747 if (trace)
10748 {
10749 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10750 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
c7927a3c 10751 op[0], op[1], op[2]);
a117b0a5
YS		 10752 printf (" p = 0x%x,", p);
10753 printf (" sz = 0x%x,", sz);
10754 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10755 printf (" rdst = 0x%x\n", rdst);
10756 }
a117b0a5
YS		 10757 SYNTAX("movu%s %1, %0");
10758#line 358 "rx-decode.opc"
10759 ID(mov); uBW (sz); DR(rdst); F_____;
10760 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10761
10762 /*----------------------------------------------------------------------*/
10763 /* PUSH/POP */
10764
c7927a3c
NC		 10765 }
10766 break;
a117b0a5
YS		 10767 }
10768 break;
10769 case 0x39:
10770 GETBYTE ();
10771 switch (op[2] & 0x00)
10772 {
10773 case 0x00:
10774 goto op_semantics_89;
10775 break;
10776 }
10777 break;
10778 case 0x3a:
10779 GETBYTE ();
10780 switch (op[2] & 0x00)
10781 {
10782 case 0x00:
10783 goto op_semantics_89;
10784 break;
10785 }
10786 break;
10787 case 0x3c:
10788 GETBYTE ();
10789 switch (op[2] & 0x00)
10790 {
10791 case 0x00:
10792 goto op_semantics_89;
10793 break;
10794 }
10795 break;
10796 case 0x3d:
10797 GETBYTE ();
10798 switch (op[2] & 0x00)
10799 {
10800 case 0x00:
10801 goto op_semantics_89;
10802 break;
10803 }
10804 break;
10805 case 0x3e:
10806 GETBYTE ();
10807 switch (op[2] & 0x00)
10808 {
10809 case 0x00:
10810 goto op_semantics_89;
10811 break;
10812 }
10813 break;
10814 case 0x44:
10815 GETBYTE ();
10816 switch (op[2] & 0x00)
10817 {
10818 case 0x00:
10819 op_semantics_90:
c7927a3c 10820 {
a117b0a5
YS		 10821 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
10822#line 1070 "rx-decode.opc"
10823 int a AU = (op[1] >> 3) & 0x01;
10824#line 1070 "rx-decode.opc"
10825 int srca AU = (op[2] >> 4) & 0x0f;
10826#line 1070 "rx-decode.opc"
10827 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10828 if (trace)
10829 {
10830 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10831 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
c7927a3c 10832 op[0], op[1], op[2]);
a117b0a5
YS		 10833 printf (" a = 0x%x,", a);
10834 printf (" srca = 0x%x,", srca);
10835 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10836 }
a117b0a5
YS		 10837 SYNTAX("msbhi %1, %2, %0");
10838#line 1070 "rx-decode.opc"
10839 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10840
c7927a3c
NC		 10841 }
10842 break;
a117b0a5
YS		 10843 }
10844 break;
10845 case 0x45:
10846 GETBYTE ();
10847 switch (op[2] & 0x00)
10848 {
10849 case 0x00:
10850 op_semantics_91:
c7927a3c 10851 {
a117b0a5
YS		 10852 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
10853#line 1076 "rx-decode.opc"
10854 int a AU = (op[1] >> 3) & 0x01;
10855#line 1076 "rx-decode.opc"
10856 int srca AU = (op[2] >> 4) & 0x0f;
10857#line 1076 "rx-decode.opc"
10858 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10859 if (trace)
10860 {
10861 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10862 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
c7927a3c 10863 op[0], op[1], op[2]);
a117b0a5
YS		 10864 printf (" a = 0x%x,", a);
10865 printf (" srca = 0x%x,", srca);
10866 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10867 }
a117b0a5
YS		 10868 SYNTAX("msblo %1, %2, %0");
10869#line 1076 "rx-decode.opc"
10870 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10871
c7927a3c
NC		 10872 }
10873 break;
a117b0a5
YS		 10874 }
10875 break;
10876 case 0x46:
10877 GETBYTE ();
10878 switch (op[2] & 0x00)
10879 {
10880 case 0x00:
10881 op_semantics_92:
c7927a3c 10882 {
a117b0a5
YS		 10883 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
10884#line 1073 "rx-decode.opc"
10885 int a AU = (op[1] >> 3) & 0x01;
10886#line 1073 "rx-decode.opc"
10887 int srca AU = (op[2] >> 4) & 0x0f;
10888#line 1073 "rx-decode.opc"
10889 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10890 if (trace)
10891 {
10892 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10893 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
c7927a3c 10894 op[0], op[1], op[2]);
a117b0a5
YS		 10895 printf (" a = 0x%x,", a);
10896 printf (" srca = 0x%x,", srca);
10897 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10898 }
a117b0a5
YS		 10899 SYNTAX("msblh %1, %2, %0");
10900#line 1073 "rx-decode.opc"
10901 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10902
c7927a3c
NC		 10903 }
10904 break;
a117b0a5
YS		 10905 }
10906 break;
10907 case 0x47:
10908 GETBYTE ();
10909 switch (op[2] & 0x00)
10910 {
10911 case 0x00:
10912 op_semantics_93:
c7927a3c 10913 {
a117b0a5
YS		 10914 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
10915#line 1061 "rx-decode.opc"
10916 int a AU = (op[1] >> 3) & 0x01;
10917#line 1061 "rx-decode.opc"
10918 int srca AU = (op[2] >> 4) & 0x0f;
10919#line 1061 "rx-decode.opc"
10920 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10921 if (trace)
10922 {
10923 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10924 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
c7927a3c 10925 op[0], op[1], op[2]);
a117b0a5
YS		 10926 printf (" a = 0x%x,", a);
10927 printf (" srca = 0x%x,", srca);
10928 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10929 }
a117b0a5
YS		 10930 SYNTAX("emsba %1, %2, %0");
10931#line 1061 "rx-decode.opc"
10932 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10933
c7927a3c
NC		 10934 }
10935 break;
a117b0a5
YS		 10936 }
10937 break;
10938 case 0x4c:
10939 GETBYTE ();
10940 switch (op[2] & 0x00)
10941 {
10942 case 0x00:
10943 goto op_semantics_90;
10944 break;
10945 }
10946 break;
10947 case 0x4d:
10948 GETBYTE ();
10949 switch (op[2] & 0x00)
10950 {
10951 case 0x00:
10952 goto op_semantics_91;
10953 break;
10954 }
10955 break;
10956 case 0x4e:
10957 GETBYTE ();
10958 switch (op[2] & 0x00)
10959 {
10960 case 0x00:
10961 goto op_semantics_92;
10962 break;
10963 }
10964 break;
10965 case 0x4f:
10966 GETBYTE ();
10967 switch (op[2] & 0x00)
10968 {
10969 case 0x00:
10970 goto op_semantics_93;
10971 break;
10972 }
10973 break;
10974 case 0x60:
10975 GETBYTE ();
10976 switch (op[2] & 0x00)
10977 {
10978 case 0x00:
c7927a3c 10979 {
a117b0a5
YS		 10980 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
10981#line 729 "rx-decode.opc"
10982 int rsrc AU = (op[2] >> 4) & 0x0f;
10983#line 729 "rx-decode.opc"
c7927a3c
NC		 10984 int rdst AU = op[2] & 0x0f;
10985 if (trace)
10986 {
10987 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10988 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
c7927a3c 10989 op[0], op[1], op[2]);
a117b0a5 10990 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10991 printf (" rdst = 0x%x\n", rdst);
10992 }
a117b0a5
YS		 10993 SYNTAX("shlr %2, %0");
10994#line 729 "rx-decode.opc"
10995 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
43e65147 10996
c7927a3c
NC		 10997 }
10998 break;
a117b0a5
YS		 10999 }
11000 break;
11001 case 0x61:
11002 GETBYTE ();
11003 switch (op[2] & 0x00)
11004 {
11005 case 0x00:
c7927a3c 11006 {
a117b0a5
YS		 11007 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
11008#line 719 "rx-decode.opc"
11009 int rsrc AU = (op[2] >> 4) & 0x0f;
11010#line 719 "rx-decode.opc"
c7927a3c
NC		 11011 int rdst AU = op[2] & 0x0f;
11012 if (trace)
11013 {
11014 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11015 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
c7927a3c 11016 op[0], op[1], op[2]);
a117b0a5 11017 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11018 printf (" rdst = 0x%x\n", rdst);
11019 }
a117b0a5
YS		 11020 SYNTAX("shar %2, %0");
11021#line 719 "rx-decode.opc"
11022 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
43e65147 11023
c7927a3c
NC		 11024 }
11025 break;
a117b0a5
YS		 11026 }
11027 break;
11028 case 0x62:
11029 GETBYTE ();
11030 switch (op[2] & 0x00)
11031 {
11032 case 0x00:
c7927a3c 11033 {
a117b0a5
YS		 11034 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
11035#line 709 "rx-decode.opc"
11036 int rsrc AU = (op[2] >> 4) & 0x0f;
11037#line 709 "rx-decode.opc"
c7927a3c
NC		 11038 int rdst AU = op[2] & 0x0f;
11039 if (trace)
11040 {
11041 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11042 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
c7927a3c 11043 op[0], op[1], op[2]);
a117b0a5 11044 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11045 printf (" rdst = 0x%x\n", rdst);
11046 }
a117b0a5
YS		 11047 SYNTAX("shll %2, %0");
11048#line 709 "rx-decode.opc"
11049 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
43e65147 11050
c7927a3c
NC		 11051 }
11052 break;
a117b0a5
YS		 11053 }
11054 break;
11055 case 0x64:
11056 GETBYTE ();
11057 switch (op[2] & 0x00)
11058 {
11059 case 0x00:
c7927a3c 11060 {
a117b0a5
YS		 11061 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
11062#line 753 "rx-decode.opc"
11063 int rsrc AU = (op[2] >> 4) & 0x0f;
11064#line 753 "rx-decode.opc"
c7927a3c
NC		 11065 int rdst AU = op[2] & 0x0f;
11066 if (trace)
11067 {
11068 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11069 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
c7927a3c 11070 op[0], op[1], op[2]);
a117b0a5 11071 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11072 printf (" rdst = 0x%x\n", rdst);
11073 }
a117b0a5
YS		 11074 SYNTAX("rotr %1, %0");
11075#line 753 "rx-decode.opc"
11076 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
43e65147 11077
c7927a3c
NC		 11078 }
11079 break;
a117b0a5
YS		 11080 }
11081 break;
11082 case 0x65:
11083 GETBYTE ();
11084 switch (op[2] & 0x00)
11085 {
11086 case 0x00:
c7927a3c 11087 {
a117b0a5
YS		 11088 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
11089#line 756 "rx-decode.opc"
11090 int rsrc AU = (op[2] >> 4) & 0x0f;
11091#line 756 "rx-decode.opc"
c7927a3c
NC		 11092 int rdst AU = op[2] & 0x0f;
11093 if (trace)
11094 {
11095 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11096 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
c7927a3c 11097 op[0], op[1], op[2]);
a117b0a5 11098 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11099 printf (" rdst = 0x%x\n", rdst);
11100 }
a117b0a5
YS		 11101 SYNTAX("revw %1, %0");
11102#line 756 "rx-decode.opc"
11103 ID(revw); SR(rsrc); DR(rdst);
43e65147 11104
c7927a3c
NC		 11105 }
11106 break;
c7927a3c
NC		 11107 }
11108 break;
a117b0a5 11109 case 0x66:
c7927a3c 11110 GETBYTE ();
a117b0a5 11111 switch (op[2] & 0x00)
c7927a3c
NC		 11112 {
11113 case 0x00:
11114 {
a117b0a5
YS		 11115 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
11116#line 747 "rx-decode.opc"
11117 int rsrc AU = (op[2] >> 4) & 0x0f;
11118#line 747 "rx-decode.opc"
c7927a3c
NC		 11119 int rdst AU = op[2] & 0x0f;
11120 if (trace)
11121 {
11122 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11123 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
c7927a3c 11124 op[0], op[1], op[2]);
a117b0a5 11125 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11126 printf (" rdst = 0x%x\n", rdst);
11127 }
a117b0a5
YS		 11128 SYNTAX("rotl %1, %0");
11129#line 747 "rx-decode.opc"
11130 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
43e65147 11131
c7927a3c
NC		 11132 }
11133 break;
a117b0a5
YS		 11134 }
11135 break;
11136 case 0x67:
11137 GETBYTE ();
11138 switch (op[2] & 0x00)
11139 {
11140 case 0x00:
c7927a3c 11141 {
a117b0a5
YS		 11142 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
11143#line 759 "rx-decode.opc"
11144 int rsrc AU = (op[2] >> 4) & 0x0f;
11145#line 759 "rx-decode.opc"
c7927a3c
NC		 11146 int rdst AU = op[2] & 0x0f;
11147 if (trace)
11148 {
11149 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11150 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
c7927a3c 11151 op[0], op[1], op[2]);
a117b0a5 11152 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11153 printf (" rdst = 0x%x\n", rdst);
11154 }
a117b0a5
YS		 11155 SYNTAX("revl %1, %0");
11156#line 759 "rx-decode.opc"
11157 ID(revl); SR(rsrc); DR(rdst);
11158
11159 /*----------------------------------------------------------------------*/
11160 /* BRANCH */
43e65147 11161
c7927a3c
NC		 11162 }
11163 break;
a117b0a5
YS		 11164 }
11165 break;
11166 case 0x68:
11167 GETBYTE ();
11168 switch (op[2] & 0x00)
11169 {
11170 case 0x00:
11171 op_semantics_94:
c7927a3c 11172 {
a117b0a5
YS		 11173 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
11174#line 1010 "rx-decode.opc"
11175 int c AU = op[1] & 0x01;
11176#line 1010 "rx-decode.opc"
11177 int rsrc AU = (op[2] >> 4) & 0x0f;
11178#line 1010 "rx-decode.opc"
c7927a3c
NC		 11179 int rdst AU = op[2] & 0x0f;
11180 if (trace)
11181 {
11182 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11183 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
c7927a3c 11184 op[0], op[1], op[2]);
a117b0a5
YS		 11185 printf (" c = 0x%x,", c);
11186 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11187 printf (" rdst = 0x%x\n", rdst);
11188 }
a117b0a5
YS		 11189 SYNTAX("mvtc %1, %0");
11190#line 1010 "rx-decode.opc"
11191 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
43e65147 11192
c7927a3c
NC		 11193 }
11194 break;
a117b0a5
YS		 11195 }
11196 break;
11197 case 0x69:
11198 GETBYTE ();
11199 switch (op[2] & 0x00)
11200 {
11201 case 0x00:
11202 goto op_semantics_94;
11203 break;
11204 }
11205 break;
11206 case 0x6a:
11207 GETBYTE ();
11208 switch (op[2] & 0x00)
11209 {
11210 case 0x00:
11211 op_semantics_95:
11212 {
11213 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
11214#line 1013 "rx-decode.opc"
11215 int s AU = op[1] & 0x01;
11216#line 1013 "rx-decode.opc"
11217 int rsrc AU = (op[2] >> 4) & 0x0f;
11218#line 1013 "rx-decode.opc"
11219 int rdst AU = op[2] & 0x0f;
11220 if (trace)
11221 {
11222 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11223 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
11224 op[0], op[1], op[2]);
11225 printf (" s = 0x%x,", s);
11226 printf (" rsrc = 0x%x,", rsrc);
11227 printf (" rdst = 0x%x\n", rdst);
11228 }
11229 SYNTAX("mvfc %1, %0");
11230#line 1013 "rx-decode.opc"
11231 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11232
11233 /*----------------------------------------------------------------------*/
11234 /* INTERRUPTS */
11235
11236 }
11237 break;
11238 }
11239 break;
11240 case 0x6b:
11241 GETBYTE ();
11242 switch (op[2] & 0x00)
11243 {
11244 case 0x00:
11245 goto op_semantics_95;
11246 break;
11247 }
11248 break;
11249 case 0x6c:
11250 GETBYTE ();
11251 switch (op[2] & 0x00)
11252 {
11253 case 0x00:
11254 op_semantics_96:
11255 {
11256 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
11257#line 750 "rx-decode.opc"
11258 int i AU = op[1] & 0x01;
11259#line 750 "rx-decode.opc"
11260 int mmmm AU = (op[2] >> 4) & 0x0f;
11261#line 750 "rx-decode.opc"
11262 int rdst AU = op[2] & 0x0f;
11263 if (trace)
11264 {
11265 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11266 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
11267 op[0], op[1], op[2]);
11268 printf (" i = 0x%x,", i);
11269 printf (" mmmm = 0x%x,", mmmm);
11270 printf (" rdst = 0x%x\n", rdst);
11271 }
11272 SYNTAX("rotr #%1, %0");
11273#line 750 "rx-decode.opc"
11274 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11275
11276 }
11277 break;
11278 }
11279 break;
11280 case 0x6d:
11281 GETBYTE ();
11282 switch (op[2] & 0x00)
11283 {
11284 case 0x00:
11285 goto op_semantics_96;
11286 break;
11287 }
11288 break;
11289 case 0x6e:
11290 GETBYTE ();
11291 switch (op[2] & 0x00)
11292 {
11293 case 0x00:
11294 op_semantics_97:
11295 {
11296 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
11297#line 744 "rx-decode.opc"
11298 int i AU = op[1] & 0x01;
11299#line 744 "rx-decode.opc"
11300 int mmmm AU = (op[2] >> 4) & 0x0f;
11301#line 744 "rx-decode.opc"
11302 int rdst AU = op[2] & 0x0f;
11303 if (trace)
11304 {
11305 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11306 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
11307 op[0], op[1], op[2]);
11308 printf (" i = 0x%x,", i);
11309 printf (" mmmm = 0x%x,", mmmm);
11310 printf (" rdst = 0x%x\n", rdst);
11311 }
11312 SYNTAX("rotl #%1, %0");
11313#line 744 "rx-decode.opc"
11314 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11315
11316 }
11317 break;
11318 }
11319 break;
11320 case 0x6f:
11321 GETBYTE ();
11322 switch (op[2] & 0x00)
11323 {
11324 case 0x00:
11325 goto op_semantics_97;
11326 break;
11327 }
11328 break;
11329 case 0x70:
11330 GETBYTE ();
11331 switch (op[2] & 0xf0)
11332 {
11333 case 0x20:
11334 op_semantics_98:
11335 {
11336 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
11337#line 488 "rx-decode.opc"
11338 int im AU = (op[1] >> 2) & 0x03;
11339#line 488 "rx-decode.opc"
11340 int rdst AU = op[2] & 0x0f;
11341 if (trace)
11342 {
11343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11344 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
11345 op[0], op[1], op[2]);
11346 printf (" im = 0x%x,", im);
11347 printf (" rdst = 0x%x\n", rdst);
11348 }
11349 SYNTAX("adc #%1, %0");
11350#line 488 "rx-decode.opc"
11351 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11352
11353 }
11354 break;
11355 case 0x40:
11356 op_semantics_99:
11357 {
11358 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
11359#line 570 "rx-decode.opc"
11360 int im AU = (op[1] >> 2) & 0x03;
11361#line 570 "rx-decode.opc"
11362 int rdst AU = op[2] & 0x0f;
11363 if (trace)
11364 {
11365 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11366 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
11367 op[0], op[1], op[2]);
11368 printf (" im = 0x%x,", im);
11369 printf (" rdst = 0x%x\n", rdst);
11370 }
11371 SYNTAX("max #%1, %0");
11372#line 570 "rx-decode.opc"
11373 int val = IMMex (im);
11374 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11375 {
11376 ID (nop7);
11377 SYNTAX("nop\t; max\t#0x80000000, r0");
11378 }
11379 else
11380 {
11381 ID(max);
11382 }
11383 DR(rdst); SC(val);
11384
11385 }
11386 break;
11387 case 0x50:
11388 op_semantics_100:
11389 {
11390 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
11391#line 600 "rx-decode.opc"
11392 int im AU = (op[1] >> 2) & 0x03;
11393#line 600 "rx-decode.opc"
11394 int rdst AU = op[2] & 0x0f;
11395 if (trace)
11396 {
11397 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11398 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
11399 op[0], op[1], op[2]);
11400 printf (" im = 0x%x,", im);
11401 printf (" rdst = 0x%x\n", rdst);
11402 }
11403 SYNTAX("min #%1, %0");
11404#line 600 "rx-decode.opc"
11405 ID(min); DR(rdst); SC(IMMex(im));
11406
11407 }
11408 break;
11409 case 0x60:
11410 op_semantics_101:
11411 {
11412 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
11413#line 658 "rx-decode.opc"
11414 int im AU = (op[1] >> 2) & 0x03;
11415#line 658 "rx-decode.opc"
11416 int rdst AU = op[2] & 0x0f;
11417 if (trace)
11418 {
11419 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11420 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
11421 op[0], op[1], op[2]);
11422 printf (" im = 0x%x,", im);
11423 printf (" rdst = 0x%x\n", rdst);
11424 }
11425 SYNTAX("emul #%1, %0");
11426#line 658 "rx-decode.opc"
11427 ID(emul); DR(rdst); SC(IMMex(im));
11428
11429 }
11430 break;
11431 case 0x70:
11432 op_semantics_102:
11433 {
11434 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
11435#line 670 "rx-decode.opc"
11436 int im AU = (op[1] >> 2) & 0x03;
11437#line 670 "rx-decode.opc"
11438 int rdst AU = op[2] & 0x0f;
11439 if (trace)
11440 {
11441 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11442 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
11443 op[0], op[1], op[2]);
11444 printf (" im = 0x%x,", im);
11445 printf (" rdst = 0x%x\n", rdst);
11446 }
11447 SYNTAX("emulu #%1, %0");
11448#line 670 "rx-decode.opc"
11449 ID(emulu); DR(rdst); SC(IMMex(im));
11450
11451 }
11452 break;
11453 case 0x80:
11454 op_semantics_103:
11455 {
11456 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
11457#line 682 "rx-decode.opc"
11458 int im AU = (op[1] >> 2) & 0x03;
11459#line 682 "rx-decode.opc"
11460 int rdst AU = op[2] & 0x0f;
11461 if (trace)
11462 {
11463 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11464 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
11465 op[0], op[1], op[2]);
11466 printf (" im = 0x%x,", im);
11467 printf (" rdst = 0x%x\n", rdst);
11468 }
11469 SYNTAX("div #%1, %0");
11470#line 682 "rx-decode.opc"
11471 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11472
11473 }
11474 break;
11475 case 0x90:
11476 op_semantics_104:
11477 {
11478 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
11479#line 694 "rx-decode.opc"
11480 int im AU = (op[1] >> 2) & 0x03;
11481#line 694 "rx-decode.opc"
11482 int rdst AU = op[2] & 0x0f;
11483 if (trace)
11484 {
11485 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11486 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
11487 op[0], op[1], op[2]);
11488 printf (" im = 0x%x,", im);
11489 printf (" rdst = 0x%x\n", rdst);
11490 }
11491 SYNTAX("divu #%1, %0");
11492#line 694 "rx-decode.opc"
11493 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11494
11495 }
11496 break;
11497 case 0xc0:
11498 op_semantics_105:
11499 {
11500 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
11501#line 467 "rx-decode.opc"
11502 int im AU = (op[1] >> 2) & 0x03;
11503#line 467 "rx-decode.opc"
11504 int rdst AU = op[2] & 0x0f;
11505 if (trace)
11506 {
11507 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11508 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
11509 op[0], op[1], op[2]);
11510 printf (" im = 0x%x,", im);
11511 printf (" rdst = 0x%x\n", rdst);
11512 }
11513 SYNTAX("tst #%1, %2");
11514#line 467 "rx-decode.opc"
11515 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11516
11517 }
11518 break;
11519 case 0xd0:
11520 op_semantics_106:
11521 {
11522 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
11523#line 446 "rx-decode.opc"
11524 int im AU = (op[1] >> 2) & 0x03;
11525#line 446 "rx-decode.opc"
11526 int rdst AU = op[2] & 0x0f;
11527 if (trace)
11528 {
11529 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11530 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
11531 op[0], op[1], op[2]);
11532 printf (" im = 0x%x,", im);
11533 printf (" rdst = 0x%x\n", rdst);
11534 }
11535 SYNTAX("xor #%1, %0");
11536#line 446 "rx-decode.opc"
11537 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11538
11539 }
11540 break;
11541 case 0xe0:
11542 op_semantics_107:
11543 {
11544 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
11545#line 392 "rx-decode.opc"
11546 int im AU = (op[1] >> 2) & 0x03;
11547#line 392 "rx-decode.opc"
11548 int rdst AU = op[2] & 0x0f;
11549 if (trace)
11550 {
11551 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11552 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
11553 op[0], op[1], op[2]);
11554 printf (" im = 0x%x,", im);
11555 printf (" rdst = 0x%x\n", rdst);
11556 }
11557 SYNTAX("stz #%1, %0");
11558#line 392 "rx-decode.opc"
11559 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11560
11561 }
11562 break;
11563 case 0xf0:
11564 op_semantics_108:
11565 {
11566 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
11567#line 395 "rx-decode.opc"
11568 int im AU = (op[1] >> 2) & 0x03;
11569#line 395 "rx-decode.opc"
11570 int rdst AU = op[2] & 0x0f;
11571 if (trace)
11572 {
11573 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11574 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
11575 op[0], op[1], op[2]);
11576 printf (" im = 0x%x,", im);
11577 printf (" rdst = 0x%x\n", rdst);
11578 }
11579 SYNTAX("stnz #%1, %0");
11580#line 395 "rx-decode.opc"
11581 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11582
11583 /*----------------------------------------------------------------------*/
11584 /* RTSD */
11585
11586 }
11587 break;
11588 default: UNSUPPORTED(); break;
11589 }
11590 break;
11591 case 0x72:
11592 GETBYTE ();
11593 switch (op[2] & 0xf0)
11594 {
11595 case 0x00:
11596 {
11597 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
11598#line 902 "rx-decode.opc"
11599 int rdst AU = op[2] & 0x0f;
11600 if (trace)
11601 {
11602 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11603 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
11604 op[0], op[1], op[2]);
11605 printf (" rdst = 0x%x\n", rdst);
11606 }
11607 SYNTAX("fsub #%1, %0");
11608#line 902 "rx-decode.opc"
11609 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11610
11611 }
11612 break;
11613 case 0x10:
11614 {
11615 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
11616#line 896 "rx-decode.opc"
11617 int rdst AU = op[2] & 0x0f;
11618 if (trace)
11619 {
11620 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11621 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
11622 op[0], op[1], op[2]);
11623 printf (" rdst = 0x%x\n", rdst);
11624 }
11625 SYNTAX("fcmp #%1, %0");
11626#line 896 "rx-decode.opc"
11627 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11628
11629 }
11630 break;
11631 case 0x20:
11632 {
11633 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
11634#line 890 "rx-decode.opc"
11635 int rdst AU = op[2] & 0x0f;
11636 if (trace)
11637 {
11638 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11639 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
11640 op[0], op[1], op[2]);
11641 printf (" rdst = 0x%x\n", rdst);
11642 }
11643 SYNTAX("fadd #%1, %0");
11644#line 890 "rx-decode.opc"
11645 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11646
11647 }
11648 break;
11649 case 0x30:
11650 {
11651 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
11652#line 911 "rx-decode.opc"
11653 int rdst AU = op[2] & 0x0f;
11654 if (trace)
11655 {
11656 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
c7927a3c
NC		 11657 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
11658 op[0], op[1], op[2]);
11659 printf (" rdst = 0x%x\n", rdst);
11660 }
11661 SYNTAX("fmul #%1, %0");
a117b0a5 11662#line 911 "rx-decode.opc"
3cf79a01 11663 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
43e65147 11664
c7927a3c
NC		 11665 }
11666 break;
11667 case 0x40:
11668 {
11669 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
a117b0a5 11670#line 917 "rx-decode.opc"
c7927a3c
NC		 11671 int rdst AU = op[2] & 0x0f;
11672 if (trace)
11673 {
11674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11675 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
11676 op[0], op[1], op[2]);
11677 printf (" rdst = 0x%x\n", rdst);
11678 }
11679 SYNTAX("fdiv #%1, %0");
a117b0a5 11680#line 917 "rx-decode.opc"
3cf79a01 11681 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
43e65147 11682
c7927a3c
NC		 11683 }
11684 break;
11685 default: UNSUPPORTED(); break;
11686 }
11687 break;
11688 case 0x73:
11689 GETBYTE ();
11690 switch (op[2] & 0xe0)
11691 {
11692 case 0x00:
a117b0a5 11693 op_semantics_109:
c7927a3c
NC		 11694 {
11695 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
a117b0a5 11696#line 1007 "rx-decode.opc"
c7927a3c 11697 int im AU = (op[1] >> 2) & 0x03;
a117b0a5 11698#line 1007 "rx-decode.opc"
c7927a3c
NC		 11699 int crdst AU = op[2] & 0x1f;
11700 if (trace)
11701 {
11702 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11703 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
11704 op[0], op[1], op[2]);
11705 printf (" im = 0x%x,", im);
11706 printf (" crdst = 0x%x\n", crdst);
11707 }
11708 SYNTAX("mvtc #%1, %0");
a117b0a5 11709#line 1007 "rx-decode.opc"
c7927a3c 11710 ID(mov); SC(IMMex(im)); DR(crdst + 16);
43e65147 11711
c7927a3c
NC		 11712 }
11713 break;
11714 default: UNSUPPORTED(); break;
11715 }
11716 break;
11717 case 0x74:
11718 GETBYTE ();
11719 switch (op[2] & 0xf0)
11720 {
11721 case 0x20:
a117b0a5 11722 goto op_semantics_98;
c7927a3c
NC		 11723 break;
11724 case 0x40:
a117b0a5 11725 goto op_semantics_99;
c7927a3c
NC		 11726 break;
11727 case 0x50:
a117b0a5 11728 goto op_semantics_100;
c7927a3c
NC		 11729 break;
11730 case 0x60:
a117b0a5 11731 goto op_semantics_101;
c7927a3c
NC		 11732 break;
11733 case 0x70:
a117b0a5 11734 goto op_semantics_102;
c7927a3c
NC		 11735 break;
11736 case 0x80:
a117b0a5 11737 goto op_semantics_103;
c7927a3c
NC		 11738 break;
11739 case 0x90:
a117b0a5 11740 goto op_semantics_104;
c7927a3c
NC		 11741 break;
11742 case 0xc0:
a117b0a5 11743 goto op_semantics_105;
c7927a3c
NC		 11744 break;
11745 case 0xd0:
a117b0a5 11746 goto op_semantics_106;
c7927a3c
NC		 11747 break;
11748 case 0xe0:
a117b0a5 11749 goto op_semantics_107;
c7927a3c
NC		 11750 break;
11751 case 0xf0:
a117b0a5 11752 goto op_semantics_108;
c7927a3c
NC		 11753 break;
11754 default: UNSUPPORTED(); break;
11755 }
11756 break;
11757 case 0x77:
11758 GETBYTE ();
11759 switch (op[2] & 0xe0)
11760 {
11761 case 0x00:
a117b0a5 11762 goto op_semantics_109;
c7927a3c
NC		 11763 break;
11764 default: UNSUPPORTED(); break;
11765 }
11766 break;
11767 case 0x78:
11768 GETBYTE ();
11769 switch (op[2] & 0xf0)
11770 {
11771 case 0x20:
a117b0a5 11772 goto op_semantics_98;
c7927a3c
NC		 11773 break;
11774 case 0x40:
a117b0a5 11775 goto op_semantics_99;
c7927a3c
NC		 11776 break;
11777 case 0x50:
a117b0a5 11778 goto op_semantics_100;
c7927a3c
NC		 11779 break;
11780 case 0x60:
a117b0a5 11781 goto op_semantics_101;
c7927a3c
NC		 11782 break;
11783 case 0x70:
a117b0a5 11784 goto op_semantics_102;
c7927a3c
NC		 11785 break;
11786 case 0x80:
a117b0a5 11787 goto op_semantics_103;
c7927a3c
NC		 11788 break;
11789 case 0x90:
a117b0a5 11790 goto op_semantics_104;
c7927a3c
NC		 11791 break;
11792 case 0xc0:
a117b0a5 11793 goto op_semantics_105;
c7927a3c
NC		 11794 break;
11795 case 0xd0:
a117b0a5 11796 goto op_semantics_106;
c7927a3c
NC		 11797 break;
11798 case 0xe0:
a117b0a5 11799 goto op_semantics_107;
c7927a3c
NC		 11800 break;
11801 case 0xf0:
a117b0a5 11802 goto op_semantics_108;
c7927a3c
NC		 11803 break;
11804 default: UNSUPPORTED(); break;
11805 }
11806 break;
11807 case 0x7b:
11808 GETBYTE ();
11809 switch (op[2] & 0xe0)
11810 {
11811 case 0x00:
a117b0a5 11812 goto op_semantics_109;
c7927a3c
NC		 11813 break;
11814 default: UNSUPPORTED(); break;
11815 }
11816 break;
11817 case 0x7c:
11818 GETBYTE ();
11819 switch (op[2] & 0xf0)
11820 {
11821 case 0x20:
a117b0a5 11822 goto op_semantics_98;
c7927a3c
NC		 11823 break;
11824 case 0x40:
a117b0a5 11825 goto op_semantics_99;
c7927a3c
NC		 11826 break;
11827 case 0x50:
a117b0a5 11828 goto op_semantics_100;
c7927a3c
NC		 11829 break;
11830 case 0x60:
a117b0a5 11831 goto op_semantics_101;
c7927a3c
NC		 11832 break;
11833 case 0x70:
a117b0a5 11834 goto op_semantics_102;
c7927a3c
NC		 11835 break;
11836 case 0x80:
a117b0a5 11837 goto op_semantics_103;
c7927a3c
NC		 11838 break;
11839 case 0x90:
a117b0a5 11840 goto op_semantics_104;
c7927a3c
NC		 11841 break;
11842 case 0xc0:
a117b0a5 11843 goto op_semantics_105;
c7927a3c
NC		 11844 break;
11845 case 0xd0:
a117b0a5 11846 goto op_semantics_106;
c7927a3c
NC		 11847 break;
11848 case 0xe0:
a117b0a5 11849 goto op_semantics_107;
c7927a3c
NC		 11850 break;
11851 case 0xf0:
a117b0a5 11852 goto op_semantics_108;
c7927a3c
NC		 11853 break;
11854 default: UNSUPPORTED(); break;
11855 }
11856 break;
11857 case 0x7f:
11858 GETBYTE ();
11859 switch (op[2] & 0xe0)
11860 {
11861 case 0x00:
a117b0a5 11862 goto op_semantics_109;
c7927a3c
NC		 11863 break;
11864 default: UNSUPPORTED(); break;
11865 }
11866 break;
11867 case 0x80:
11868 GETBYTE ();
11869 switch (op[2] & 0x00)
11870 {
11871 case 0x00:
a117b0a5 11872 op_semantics_110:
c7927a3c
NC		 11873 {
11874 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
a117b0a5 11875#line 732 "rx-decode.opc"
c7927a3c 11876 int immmm AU = op[1] & 0x1f;
a117b0a5 11877#line 732 "rx-decode.opc"
c7927a3c 11878 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 11879#line 732 "rx-decode.opc"
c7927a3c
NC		 11880 int rdst AU = op[2] & 0x0f;
11881 if (trace)
11882 {
11883 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11884 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
11885 op[0], op[1], op[2]);
11886 printf (" immmm = 0x%x,", immmm);
11887 printf (" rsrc = 0x%x,", rsrc);
11888 printf (" rdst = 0x%x\n", rdst);
11889 }
11890 SYNTAX("shlr #%2, %1, %0");
a117b0a5 11891#line 732 "rx-decode.opc"
3cf79a01 11892 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
43e65147 11893
c7927a3c
NC		 11894 /*----------------------------------------------------------------------*/
11895 /* ROTATE */
43e65147 11896
c7927a3c
NC		 11897 }
11898 break;
11899 }
11900 break;
11901 case 0x81:
11902 GETBYTE ();
11903 switch (op[2] & 0x00)
11904 {
11905 case 0x00:
a117b0a5 11906 goto op_semantics_110;
c7927a3c
NC		 11907 break;
11908 }
11909 break;
11910 case 0x82:
11911 GETBYTE ();
11912 switch (op[2] & 0x00)
11913 {
11914 case 0x00:
a117b0a5 11915 goto op_semantics_110;
c7927a3c
NC		 11916 break;
11917 }
11918 break;
11919 case 0x83:
11920 GETBYTE ();
11921 switch (op[2] & 0x00)
11922 {
11923 case 0x00:
a117b0a5 11924 goto op_semantics_110;
c7927a3c
NC		 11925 break;
11926 }
11927 break;
11928 case 0x84:
11929 GETBYTE ();
11930 switch (op[2] & 0x00)
11931 {
11932 case 0x00:
a117b0a5 11933 goto op_semantics_110;
c7927a3c
NC		 11934 break;
11935 }
11936 break;
11937 case 0x85:
11938 GETBYTE ();
11939 switch (op[2] & 0x00)
11940 {
11941 case 0x00:
a117b0a5 11942 goto op_semantics_110;
c7927a3c
NC		 11943 break;
11944 }
11945 break;
11946 case 0x86:
11947 GETBYTE ();
11948 switch (op[2] & 0x00)
11949 {
11950 case 0x00:
a117b0a5 11951 goto op_semantics_110;
c7927a3c
NC		 11952 break;
11953 }
11954 break;
11955 case 0x87:
11956 GETBYTE ();
11957 switch (op[2] & 0x00)
11958 {
11959 case 0x00:
a117b0a5 11960 goto op_semantics_110;
c7927a3c
NC		 11961 break;
11962 }
11963 break;
11964 case 0x88:
11965 GETBYTE ();
11966 switch (op[2] & 0x00)
11967 {
11968 case 0x00:
a117b0a5 11969 goto op_semantics_110;
c7927a3c
NC		 11970 break;
11971 }
11972 break;
11973 case 0x89:
11974 GETBYTE ();
11975 switch (op[2] & 0x00)
11976 {
11977 case 0x00:
a117b0a5 11978 goto op_semantics_110;
c7927a3c
NC		 11979 break;
11980 }
11981 break;
11982 case 0x8a:
11983 GETBYTE ();
11984 switch (op[2] & 0x00)
11985 {
11986 case 0x00:
a117b0a5 11987 goto op_semantics_110;
c7927a3c
NC		 11988 break;
11989 }
11990 break;
11991 case 0x8b:
11992 GETBYTE ();
11993 switch (op[2] & 0x00)
11994 {
11995 case 0x00:
a117b0a5 11996 goto op_semantics_110;
c7927a3c
NC		 11997 break;
11998 }
11999 break;
12000 case 0x8c:
12001 GETBYTE ();
12002 switch (op[2] & 0x00)
12003 {
12004 case 0x00:
a117b0a5 12005 goto op_semantics_110;
c7927a3c
NC		 12006 break;
12007 }
12008 break;
12009 case 0x8d:
12010 GETBYTE ();
12011 switch (op[2] & 0x00)
12012 {
12013 case 0x00:
a117b0a5 12014 goto op_semantics_110;
c7927a3c
NC		 12015 break;
12016 }
12017 break;
12018 case 0x8e:
12019 GETBYTE ();
12020 switch (op[2] & 0x00)
12021 {
12022 case 0x00:
a117b0a5 12023 goto op_semantics_110;
c7927a3c
NC		 12024 break;
12025 }
12026 break;
12027 case 0x8f:
12028 GETBYTE ();
12029 switch (op[2] & 0x00)
12030 {
12031 case 0x00:
a117b0a5 12032 goto op_semantics_110;
c7927a3c
NC		 12033 break;
12034 }
12035 break;
12036 case 0x90:
12037 GETBYTE ();
12038 switch (op[2] & 0x00)
12039 {
12040 case 0x00:
a117b0a5 12041 goto op_semantics_110;
c7927a3c
NC		 12042 break;
12043 }
12044 break;
12045 case 0x91:
12046 GETBYTE ();
12047 switch (op[2] & 0x00)
12048 {
12049 case 0x00:
a117b0a5 12050 goto op_semantics_110;
c7927a3c
NC		 12051 break;
12052 }
12053 break;
12054 case 0x92:
12055 GETBYTE ();
12056 switch (op[2] & 0x00)
12057 {
12058 case 0x00:
a117b0a5 12059 goto op_semantics_110;
c7927a3c
NC		 12060 break;
12061 }
12062 break;
12063 case 0x93:
12064 GETBYTE ();
12065 switch (op[2] & 0x00)
12066 {
12067 case 0x00:
a117b0a5 12068 goto op_semantics_110;
c7927a3c
NC		 12069 break;
12070 }
12071 break;
12072 case 0x94:
12073 GETBYTE ();
12074 switch (op[2] & 0x00)
12075 {
12076 case 0x00:
a117b0a5 12077 goto op_semantics_110;
c7927a3c
NC		 12078 break;
12079 }
12080 break;
12081 case 0x95:
12082 GETBYTE ();
12083 switch (op[2] & 0x00)
12084 {
12085 case 0x00:
a117b0a5 12086 goto op_semantics_110;
c7927a3c
NC		 12087 break;
12088 }
12089 break;
12090 case 0x96:
12091 GETBYTE ();
12092 switch (op[2] & 0x00)
12093 {
12094 case 0x00:
a117b0a5 12095 goto op_semantics_110;
c7927a3c
NC		 12096 break;
12097 }
12098 break;
12099 case 0x97:
12100 GETBYTE ();
12101 switch (op[2] & 0x00)
12102 {
12103 case 0x00:
a117b0a5 12104 goto op_semantics_110;
c7927a3c
NC		 12105 break;
12106 }
12107 break;
12108 case 0x98:
12109 GETBYTE ();
12110 switch (op[2] & 0x00)
12111 {
12112 case 0x00:
a117b0a5 12113 goto op_semantics_110;
c7927a3c
NC		 12114 break;
12115 }
12116 break;
12117 case 0x99:
12118 GETBYTE ();
12119 switch (op[2] & 0x00)
12120 {
12121 case 0x00:
a117b0a5 12122 goto op_semantics_110;
c7927a3c
NC		 12123 break;
12124 }
12125 break;
12126 case 0x9a:
12127 GETBYTE ();
12128 switch (op[2] & 0x00)
12129 {
12130 case 0x00:
a117b0a5 12131 goto op_semantics_110;
c7927a3c
NC		 12132 break;
12133 }
12134 break;
12135 case 0x9b:
12136 GETBYTE ();
12137 switch (op[2] & 0x00)
12138 {
12139 case 0x00:
a117b0a5 12140 goto op_semantics_110;
c7927a3c
NC		 12141 break;
12142 }
12143 break;
12144 case 0x9c:
12145 GETBYTE ();
12146 switch (op[2] & 0x00)
12147 {
12148 case 0x00:
a117b0a5 12149 goto op_semantics_110;
c7927a3c
NC		 12150 break;
12151 }
12152 break;
12153 case 0x9d:
12154 GETBYTE ();
12155 switch (op[2] & 0x00)
12156 {
12157 case 0x00:
a117b0a5 12158 goto op_semantics_110;
c7927a3c
NC		 12159 break;
12160 }
12161 break;
12162 case 0x9e:
12163 GETBYTE ();
12164 switch (op[2] & 0x00)
12165 {
12166 case 0x00:
a117b0a5 12167 goto op_semantics_110;
c7927a3c
NC		 12168 break;
12169 }
12170 break;
12171 case 0x9f:
12172 GETBYTE ();
12173 switch (op[2] & 0x00)
12174 {
12175 case 0x00:
a117b0a5 12176 goto op_semantics_110;
c7927a3c
NC		 12177 break;
12178 }
12179 break;
12180 case 0xa0:
12181 GETBYTE ();
12182 switch (op[2] & 0x00)
12183 {
12184 case 0x00:
a117b0a5 12185 op_semantics_111:
c7927a3c
NC		 12186 {
12187 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
a117b0a5 12188#line 722 "rx-decode.opc"
c7927a3c 12189 int immmm AU = op[1] & 0x1f;
a117b0a5 12190#line 722 "rx-decode.opc"
c7927a3c 12191 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 12192#line 722 "rx-decode.opc"
c7927a3c
NC		 12193 int rdst AU = op[2] & 0x0f;
12194 if (trace)
12195 {
12196 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12197 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
12198 op[0], op[1], op[2]);
12199 printf (" immmm = 0x%x,", immmm);
12200 printf (" rsrc = 0x%x,", rsrc);
12201 printf (" rdst = 0x%x\n", rdst);
12202 }
12203 SYNTAX("shar #%2, %1, %0");
a117b0a5 12204#line 722 "rx-decode.opc"
3cf79a01 12205 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
43e65147
L		 12206
12207
c7927a3c
NC		 12208 }
12209 break;
12210 }
12211 break;
12212 case 0xa1:
12213 GETBYTE ();
12214 switch (op[2] & 0x00)
12215 {
12216 case 0x00:
a117b0a5 12217 goto op_semantics_111;
c7927a3c
NC		 12218 break;
12219 }
12220 break;
12221 case 0xa2:
12222 GETBYTE ();
12223 switch (op[2] & 0x00)
12224 {
12225 case 0x00:
a117b0a5 12226 goto op_semantics_111;
c7927a3c
NC		 12227 break;
12228 }
12229 break;
12230 case 0xa3:
12231 GETBYTE ();
12232 switch (op[2] & 0x00)
12233 {
12234 case 0x00:
a117b0a5 12235 goto op_semantics_111;
c7927a3c
NC		 12236 break;
12237 }
12238 break;
12239 case 0xa4:
12240 GETBYTE ();
12241 switch (op[2] & 0x00)
12242 {
12243 case 0x00:
a117b0a5 12244 goto op_semantics_111;
c7927a3c
NC		 12245 break;
12246 }
12247 break;
12248 case 0xa5:
12249 GETBYTE ();
12250 switch (op[2] & 0x00)
12251 {
12252 case 0x00:
a117b0a5 12253 goto op_semantics_111;
c7927a3c
NC		 12254 break;
12255 }
12256 break;
12257 case 0xa6:
12258 GETBYTE ();
12259 switch (op[2] & 0x00)
12260 {
12261 case 0x00:
a117b0a5 12262 goto op_semantics_111;
c7927a3c
NC		 12263 break;
12264 }
12265 break;
12266 case 0xa7:
12267 GETBYTE ();
12268 switch (op[2] & 0x00)
12269 {
12270 case 0x00:
a117b0a5 12271 goto op_semantics_111;
c7927a3c
NC		 12272 break;
12273 }
12274 break;
12275 case 0xa8:
12276 GETBYTE ();
12277 switch (op[2] & 0x00)
12278 {
12279 case 0x00:
a117b0a5 12280 goto op_semantics_111;
c7927a3c
NC		 12281 break;
12282 }
12283 break;
12284 case 0xa9:
12285 GETBYTE ();
12286 switch (op[2] & 0x00)
12287 {
12288 case 0x00:
a117b0a5 12289 goto op_semantics_111;
c7927a3c
NC		 12290 break;
12291 }
12292 break;
12293 case 0xaa:
12294 GETBYTE ();
12295 switch (op[2] & 0x00)
12296 {
12297 case 0x00:
a117b0a5 12298 goto op_semantics_111;
c7927a3c
NC		 12299 break;
12300 }
12301 break;
12302 case 0xab:
12303 GETBYTE ();
12304 switch (op[2] & 0x00)
12305 {
12306 case 0x00:
a117b0a5 12307 goto op_semantics_111;
c7927a3c
NC		 12308 break;
12309 }
12310 break;
12311 case 0xac:
12312 GETBYTE ();
12313 switch (op[2] & 0x00)
12314 {
12315 case 0x00:
a117b0a5 12316 goto op_semantics_111;
c7927a3c
NC		 12317 break;
12318 }
12319 break;
12320 case 0xad:
12321 GETBYTE ();
12322 switch (op[2] & 0x00)
12323 {
12324 case 0x00:
a117b0a5 12325 goto op_semantics_111;
c7927a3c
NC		 12326 break;
12327 }
12328 break;
12329 case 0xae:
12330 GETBYTE ();
12331 switch (op[2] & 0x00)
12332 {
12333 case 0x00:
a117b0a5 12334 goto op_semantics_111;
c7927a3c
NC		 12335 break;
12336 }
12337 break;
12338 case 0xaf:
12339 GETBYTE ();
12340 switch (op[2] & 0x00)
12341 {
12342 case 0x00:
a117b0a5 12343 goto op_semantics_111;
c7927a3c
NC		 12344 break;
12345 }
12346 break;
12347 case 0xb0:
12348 GETBYTE ();
12349 switch (op[2] & 0x00)
12350 {
12351 case 0x00:
a117b0a5 12352 goto op_semantics_111;
c7927a3c
NC		 12353 break;
12354 }
12355 break;
12356 case 0xb1:
12357 GETBYTE ();
12358 switch (op[2] & 0x00)
12359 {
12360 case 0x00:
a117b0a5 12361 goto op_semantics_111;
c7927a3c
NC		 12362 break;
12363 }
12364 break;
12365 case 0xb2:
12366 GETBYTE ();
12367 switch (op[2] & 0x00)
12368 {
12369 case 0x00:
a117b0a5 12370 goto op_semantics_111;
c7927a3c
NC		 12371 break;
12372 }
12373 break;
12374 case 0xb3:
12375 GETBYTE ();
12376 switch (op[2] & 0x00)
12377 {
12378 case 0x00:
a117b0a5 12379 goto op_semantics_111;
c7927a3c
NC		 12380 break;
12381 }
12382 break;
12383 case 0xb4:
12384 GETBYTE ();
12385 switch (op[2] & 0x00)
12386 {
12387 case 0x00:
a117b0a5 12388 goto op_semantics_111;
c7927a3c
NC		 12389 break;
12390 }
12391 break;
12392 case 0xb5:
12393 GETBYTE ();
12394 switch (op[2] & 0x00)
12395 {
12396 case 0x00:
a117b0a5 12397 goto op_semantics_111;
c7927a3c
NC		 12398 break;
12399 }
12400 break;
12401 case 0xb6:
12402 GETBYTE ();
12403 switch (op[2] & 0x00)
12404 {
12405 case 0x00:
a117b0a5 12406 goto op_semantics_111;
c7927a3c
NC		 12407 break;
12408 }
12409 break;
12410 case 0xb7:
12411 GETBYTE ();
12412 switch (op[2] & 0x00)
12413 {
12414 case 0x00:
a117b0a5 12415 goto op_semantics_111;
c7927a3c
NC		 12416 break;
12417 }
12418 break;
12419 case 0xb8:
12420 GETBYTE ();
12421 switch (op[2] & 0x00)
12422 {
12423 case 0x00:
a117b0a5 12424 goto op_semantics_111;
c7927a3c
NC		 12425 break;
12426 }
12427 break;
12428 case 0xb9:
12429 GETBYTE ();
12430 switch (op[2] & 0x00)
12431 {
12432 case 0x00:
a117b0a5 12433 goto op_semantics_111;
c7927a3c
NC		 12434 break;
12435 }
12436 break;
12437 case 0xba:
12438 GETBYTE ();
12439 switch (op[2] & 0x00)
12440 {
12441 case 0x00:
a117b0a5 12442 goto op_semantics_111;
c7927a3c
NC		 12443 break;
12444 }
12445 break;
12446 case 0xbb:
12447 GETBYTE ();
12448 switch (op[2] & 0x00)
12449 {
12450 case 0x00:
a117b0a5 12451 goto op_semantics_111;
c7927a3c
NC		 12452 break;
12453 }
12454 break;
12455 case 0xbc:
12456 GETBYTE ();
12457 switch (op[2] & 0x00)
12458 {
12459 case 0x00:
a117b0a5 12460 goto op_semantics_111;
c7927a3c
NC		 12461 break;
12462 }
12463 break;
12464 case 0xbd:
12465 GETBYTE ();
12466 switch (op[2] & 0x00)
12467 {
12468 case 0x00:
a117b0a5 12469 goto op_semantics_111;
c7927a3c
NC		 12470 break;
12471 }
12472 break;
12473 case 0xbe:
12474 GETBYTE ();
12475 switch (op[2] & 0x00)
12476 {
12477 case 0x00:
a117b0a5 12478 goto op_semantics_111;
c7927a3c
NC		 12479 break;
12480 }
12481 break;
12482 case 0xbf:
12483 GETBYTE ();
12484 switch (op[2] & 0x00)
12485 {
12486 case 0x00:
a117b0a5 12487 goto op_semantics_111;
c7927a3c
NC		 12488 break;
12489 }
12490 break;
12491 case 0xc0:
12492 GETBYTE ();
12493 switch (op[2] & 0x00)
12494 {
12495 case 0x00:
a117b0a5 12496 op_semantics_112:
c7927a3c
NC		 12497 {
12498 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
a117b0a5 12499#line 712 "rx-decode.opc"
c7927a3c 12500 int immmm AU = op[1] & 0x1f;
a117b0a5 12501#line 712 "rx-decode.opc"
c7927a3c 12502 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 12503#line 712 "rx-decode.opc"
c7927a3c
NC		 12504 int rdst AU = op[2] & 0x0f;
12505 if (trace)
12506 {
12507 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12508 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
12509 op[0], op[1], op[2]);
12510 printf (" immmm = 0x%x,", immmm);
12511 printf (" rsrc = 0x%x,", rsrc);
12512 printf (" rdst = 0x%x\n", rdst);
12513 }
12514 SYNTAX("shll #%2, %1, %0");
a117b0a5 12515#line 712 "rx-decode.opc"
3cf79a01 12516 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
43e65147
L		 12517
12518
c7927a3c
NC		 12519 }
12520 break;
12521 }
12522 break;
12523 case 0xc1:
12524 GETBYTE ();
12525 switch (op[2] & 0x00)
12526 {
12527 case 0x00:
a117b0a5 12528 goto op_semantics_112;
c7927a3c
NC		 12529 break;
12530 }
12531 break;
12532 case 0xc2:
12533 GETBYTE ();
12534 switch (op[2] & 0x00)
12535 {
12536 case 0x00:
a117b0a5 12537 goto op_semantics_112;
c7927a3c
NC		 12538 break;
12539 }
12540 break;
12541 case 0xc3:
12542 GETBYTE ();
12543 switch (op[2] & 0x00)
12544 {
12545 case 0x00:
a117b0a5
YS		 12546 goto op_semantics_112;
12547 break;
12548 }
12549 break;
12550 case 0xc4:
12551 GETBYTE ();
12552 switch (op[2] & 0x00)
12553 {
12554 case 0x00:
12555 goto op_semantics_112;
12556 break;
12557 }
12558 break;
12559 case 0xc5:
12560 GETBYTE ();
12561 switch (op[2] & 0x00)
12562 {
12563 case 0x00:
12564 goto op_semantics_112;
12565 break;
12566 }
12567 break;
12568 case 0xc6:
12569 GETBYTE ();
12570 switch (op[2] & 0x00)
12571 {
12572 case 0x00:
12573 goto op_semantics_112;
12574 break;
12575 }
12576 break;
12577 case 0xc7:
12578 GETBYTE ();
12579 switch (op[2] & 0x00)
12580 {
12581 case 0x00:
12582 goto op_semantics_112;
12583 break;
12584 }
12585 break;
12586 case 0xc8:
12587 GETBYTE ();
12588 switch (op[2] & 0x00)
12589 {
12590 case 0x00:
12591 goto op_semantics_112;
12592 break;
12593 }
12594 break;
12595 case 0xc9:
12596 GETBYTE ();
12597 switch (op[2] & 0x00)
12598 {
12599 case 0x00:
12600 goto op_semantics_112;
12601 break;
12602 }
12603 break;
12604 case 0xca:
12605 GETBYTE ();
12606 switch (op[2] & 0x00)
12607 {
12608 case 0x00:
12609 goto op_semantics_112;
12610 break;
12611 }
12612 break;
12613 case 0xcb:
12614 GETBYTE ();
12615 switch (op[2] & 0x00)
12616 {
12617 case 0x00:
12618 goto op_semantics_112;
12619 break;
12620 }
12621 break;
12622 case 0xcc:
12623 GETBYTE ();
12624 switch (op[2] & 0x00)
12625 {
12626 case 0x00:
12627 goto op_semantics_112;
12628 break;
12629 }
12630 break;
12631 case 0xcd:
12632 GETBYTE ();
12633 switch (op[2] & 0x00)
12634 {
12635 case 0x00:
12636 goto op_semantics_112;
12637 break;
12638 }
12639 break;
12640 case 0xce:
12641 GETBYTE ();
12642 switch (op[2] & 0x00)
12643 {
12644 case 0x00:
12645 goto op_semantics_112;
12646 break;
12647 }
12648 break;
12649 case 0xcf:
12650 GETBYTE ();
12651 switch (op[2] & 0x00)
12652 {
12653 case 0x00:
12654 goto op_semantics_112;
12655 break;
12656 }
12657 break;
12658 case 0xd0:
12659 GETBYTE ();
12660 switch (op[2] & 0x00)
12661 {
12662 case 0x00:
12663 goto op_semantics_112;
12664 break;
12665 }
12666 break;
12667 case 0xd1:
12668 GETBYTE ();
12669 switch (op[2] & 0x00)
12670 {
12671 case 0x00:
12672 goto op_semantics_112;
12673 break;
12674 }
12675 break;
12676 case 0xd2:
12677 GETBYTE ();
12678 switch (op[2] & 0x00)
12679 {
12680 case 0x00:
12681 goto op_semantics_112;
12682 break;
12683 }
12684 break;
12685 case 0xd3:
12686 GETBYTE ();
12687 switch (op[2] & 0x00)
12688 {
12689 case 0x00:
12690 goto op_semantics_112;
12691 break;
12692 }
12693 break;
12694 case 0xd4:
12695 GETBYTE ();
12696 switch (op[2] & 0x00)
12697 {
12698 case 0x00:
12699 goto op_semantics_112;
c7927a3c
NC		 12700 break;
12701 }
12702 break;
a117b0a5 12703 case 0xd5:
c7927a3c
NC		 12704 GETBYTE ();
12705 switch (op[2] & 0x00)
12706 {
12707 case 0x00:
a117b0a5 12708 goto op_semantics_112;
c7927a3c
NC		 12709 break;
12710 }
12711 break;
a117b0a5 12712 case 0xd6:
c7927a3c
NC		 12713 GETBYTE ();
12714 switch (op[2] & 0x00)
12715 {
12716 case 0x00:
a117b0a5 12717 goto op_semantics_112;
c7927a3c
NC		 12718 break;
12719 }
12720 break;
a117b0a5 12721 case 0xd7:
c7927a3c
NC		 12722 GETBYTE ();
12723 switch (op[2] & 0x00)
12724 {
12725 case 0x00:
a117b0a5 12726 goto op_semantics_112;
c7927a3c
NC		 12727 break;
12728 }
12729 break;
a117b0a5 12730 case 0xd8:
c7927a3c
NC		 12731 GETBYTE ();
12732 switch (op[2] & 0x00)
12733 {
12734 case 0x00:
a117b0a5 12735 goto op_semantics_112;
c7927a3c
NC		 12736 break;
12737 }
12738 break;
a117b0a5 12739 case 0xd9:
c7927a3c
NC		 12740 GETBYTE ();
12741 switch (op[2] & 0x00)
12742 {
12743 case 0x00:
a117b0a5 12744 goto op_semantics_112;
c7927a3c
NC		 12745 break;
12746 }
12747 break;
a117b0a5 12748 case 0xda:
c7927a3c
NC		 12749 GETBYTE ();
12750 switch (op[2] & 0x00)
12751 {
12752 case 0x00:
a117b0a5 12753 goto op_semantics_112;
c7927a3c
NC		 12754 break;
12755 }
12756 break;
a117b0a5 12757 case 0xdb:
c7927a3c
NC		 12758 GETBYTE ();
12759 switch (op[2] & 0x00)
12760 {
12761 case 0x00:
a117b0a5 12762 goto op_semantics_112;
c7927a3c
NC		 12763 break;
12764 }
12765 break;
a117b0a5 12766 case 0xdc:
c7927a3c
NC		 12767 GETBYTE ();
12768 switch (op[2] & 0x00)
12769 {
12770 case 0x00:
a117b0a5 12771 goto op_semantics_112;
c7927a3c
NC		 12772 break;
12773 }
12774 break;
a117b0a5 12775 case 0xdd:
c7927a3c
NC		 12776 GETBYTE ();
12777 switch (op[2] & 0x00)
12778 {
12779 case 0x00:
a117b0a5 12780 goto op_semantics_112;
c7927a3c
NC		 12781 break;
12782 }
12783 break;
a117b0a5 12784 case 0xde:
c7927a3c
NC		 12785 GETBYTE ();
12786 switch (op[2] & 0x00)
12787 {
12788 case 0x00:
a117b0a5 12789 goto op_semantics_112;
c7927a3c
NC		 12790 break;
12791 }
12792 break;
a117b0a5 12793 case 0xdf:
c7927a3c
NC		 12794 GETBYTE ();
12795 switch (op[2] & 0x00)
12796 {
12797 case 0x00:
a117b0a5 12798 goto op_semantics_112;
c7927a3c
NC		 12799 break;
12800 }
12801 break;
a117b0a5 12802 case 0xe0:
c7927a3c 12803 GETBYTE ();
a117b0a5 12804 switch (op[2] & 0xf0)
c7927a3c
NC		 12805 {
12806 case 0x00:
a117b0a5
YS		 12807 case 0x10:
12808 case 0x20:
12809 case 0x30:
12810 case 0x40:
12811 case 0x50:
12812 case 0x60:
12813 case 0x70:
12814 case 0x80:
12815 case 0x90:
12816 case 0xa0:
12817 case 0xb0:
12818 case 0xc0:
12819 case 0xd0:
12820 case 0xe0:
12821 op_semantics_113:
12822 {
12823 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
12824#line 986 "rx-decode.opc"
12825 int bittt AU = op[1] & 0x1f;
12826#line 986 "rx-decode.opc"
12827 int cond AU = (op[2] >> 4) & 0x0f;
12828#line 986 "rx-decode.opc"
12829 int rdst AU = op[2] & 0x0f;
12830 if (trace)
12831 {
12832 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12833 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
12834 op[0], op[1], op[2]);
12835 printf (" bittt = 0x%x,", bittt);
12836 printf (" cond = 0x%x,", cond);
12837 printf (" rdst = 0x%x\n", rdst);
12838 }
12839 SYNTAX("bm%2 #%1, %0%S0");
12840#line 986 "rx-decode.opc"
12841 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12842
12843 /*----------------------------------------------------------------------*/
12844 /* CONTROL REGISTERS */
12845
12846 }
12847 break;
12848 case 0xf0:
12849 op_semantics_114:
12850 {
12851 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
12852#line 979 "rx-decode.opc"
12853 int bittt AU = op[1] & 0x1f;
12854#line 979 "rx-decode.opc"
12855 int rdst AU = op[2] & 0x0f;
12856 if (trace)
12857 {
12858 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12859 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
12860 op[0], op[1], op[2]);
12861 printf (" bittt = 0x%x,", bittt);
12862 printf (" rdst = 0x%x\n", rdst);
12863 }
12864 SYNTAX("bnot #%1, %0");
12865#line 979 "rx-decode.opc"
12866 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12867
12868
12869 }
c7927a3c
NC		 12870 break;
12871 }
12872 break;
a117b0a5 12873 case 0xe1:
c7927a3c 12874 GETBYTE ();
a117b0a5 12875 switch (op[2] & 0xf0)
c7927a3c
NC		 12876 {
12877 case 0x00:
a117b0a5
YS		 12878 case 0x10:
12879 case 0x20:
12880 case 0x30:
12881 case 0x40:
12882 case 0x50:
12883 case 0x60:
12884 case 0x70:
12885 case 0x80:
12886 case 0x90:
12887 case 0xa0:
12888 case 0xb0:
12889 case 0xc0:
12890 case 0xd0:
12891 case 0xe0:
12892 goto op_semantics_113;
12893 break;
12894 case 0xf0:
12895 goto op_semantics_114;
c7927a3c
NC		 12896 break;
12897 }
12898 break;
a117b0a5 12899 case 0xe2:
c7927a3c 12900 GETBYTE ();
a117b0a5 12901 switch (op[2] & 0xf0)
c7927a3c
NC		 12902 {
12903 case 0x00:
a117b0a5
YS		 12904 case 0x10:
12905 case 0x20:
12906 case 0x30:
12907 case 0x40:
12908 case 0x50:
12909 case 0x60:
12910 case 0x70:
12911 case 0x80:
12912 case 0x90:
12913 case 0xa0:
12914 case 0xb0:
12915 case 0xc0:
12916 case 0xd0:
12917 case 0xe0:
12918 goto op_semantics_113;
12919 break;
12920 case 0xf0:
12921 goto op_semantics_114;
c7927a3c
NC		 12922 break;
12923 }
12924 break;
a117b0a5 12925 case 0xe3:
c7927a3c 12926 GETBYTE ();
a117b0a5 12927 switch (op[2] & 0xf0)
c7927a3c
NC		 12928 {
12929 case 0x00:
a117b0a5
YS		 12930 case 0x10:
12931 case 0x20:
12932 case 0x30:
12933 case 0x40:
12934 case 0x50:
12935 case 0x60:
12936 case 0x70:
12937 case 0x80:
12938 case 0x90:
12939 case 0xa0:
12940 case 0xb0:
12941 case 0xc0:
12942 case 0xd0:
12943 case 0xe0:
12944 goto op_semantics_113;
12945 break;
12946 case 0xf0:
12947 goto op_semantics_114;
c7927a3c
NC		 12948 break;
12949 }
12950 break;
a117b0a5 12951 case 0xe4:
c7927a3c 12952 GETBYTE ();
a117b0a5 12953 switch (op[2] & 0xf0)
c7927a3c
NC		 12954 {
12955 case 0x00:
a117b0a5
YS		 12956 case 0x10:
12957 case 0x20:
12958 case 0x30:
12959 case 0x40:
12960 case 0x50:
12961 case 0x60:
12962 case 0x70:
12963 case 0x80:
12964 case 0x90:
12965 case 0xa0:
12966 case 0xb0:
12967 case 0xc0:
12968 case 0xd0:
12969 case 0xe0:
12970 goto op_semantics_113;
12971 break;
12972 case 0xf0:
12973 goto op_semantics_114;
c7927a3c
NC		 12974 break;
12975 }
12976 break;
a117b0a5 12977 case 0xe5:
c7927a3c 12978 GETBYTE ();
a117b0a5 12979 switch (op[2] & 0xf0)
c7927a3c
NC		 12980 {
12981 case 0x00:
a117b0a5
YS		 12982 case 0x10:
12983 case 0x20:
12984 case 0x30:
12985 case 0x40:
12986 case 0x50:
12987 case 0x60:
12988 case 0x70:
12989 case 0x80:
12990 case 0x90:
12991 case 0xa0:
12992 case 0xb0:
12993 case 0xc0:
12994 case 0xd0:
12995 case 0xe0:
12996 goto op_semantics_113;
12997 break;
12998 case 0xf0:
12999 goto op_semantics_114;
c7927a3c
NC		 13000 break;
13001 }
13002 break;
a117b0a5 13003 case 0xe6:
c7927a3c 13004 GETBYTE ();
a117b0a5 13005 switch (op[2] & 0xf0)
c7927a3c
NC		 13006 {
13007 case 0x00:
a117b0a5
YS		 13008 case 0x10:
13009 case 0x20:
13010 case 0x30:
13011 case 0x40:
13012 case 0x50:
13013 case 0x60:
13014 case 0x70:
13015 case 0x80:
13016 case 0x90:
13017 case 0xa0:
13018 case 0xb0:
13019 case 0xc0:
13020 case 0xd0:
13021 case 0xe0:
13022 goto op_semantics_113;
13023 break;
13024 case 0xf0:
13025 goto op_semantics_114;
c7927a3c
NC		 13026 break;
13027 }
13028 break;
a117b0a5 13029 case 0xe7:
c7927a3c 13030 GETBYTE ();
a117b0a5 13031 switch (op[2] & 0xf0)
c7927a3c
NC		 13032 {
13033 case 0x00:
a117b0a5
YS		 13034 case 0x10:
13035 case 0x20:
13036 case 0x30:
13037 case 0x40:
13038 case 0x50:
13039 case 0x60:
13040 case 0x70:
13041 case 0x80:
13042 case 0x90:
13043 case 0xa0:
13044 case 0xb0:
13045 case 0xc0:
13046 case 0xd0:
13047 case 0xe0:
13048 goto op_semantics_113;
13049 break;
13050 case 0xf0:
13051 goto op_semantics_114;
c7927a3c
NC		 13052 break;
13053 }
13054 break;
a117b0a5 13055 case 0xe8:
c7927a3c 13056 GETBYTE ();
a117b0a5 13057 switch (op[2] & 0xf0)
c7927a3c
NC		 13058 {
13059 case 0x00:
a117b0a5
YS		 13060 case 0x10:
13061 case 0x20:
13062 case 0x30:
13063 case 0x40:
13064 case 0x50:
13065 case 0x60:
13066 case 0x70:
13067 case 0x80:
13068 case 0x90:
13069 case 0xa0:
13070 case 0xb0:
13071 case 0xc0:
13072 case 0xd0:
13073 case 0xe0:
13074 goto op_semantics_113;
13075 break;
13076 case 0xf0:
13077 goto op_semantics_114;
c7927a3c
NC		 13078 break;
13079 }
13080 break;
a117b0a5 13081 case 0xe9:
c7927a3c 13082 GETBYTE ();
a117b0a5 13083 switch (op[2] & 0xf0)
c7927a3c
NC		 13084 {
13085 case 0x00:
a117b0a5
YS		 13086 case 0x10:
13087 case 0x20:
13088 case 0x30:
13089 case 0x40:
13090 case 0x50:
13091 case 0x60:
13092 case 0x70:
13093 case 0x80:
13094 case 0x90:
13095 case 0xa0:
13096 case 0xb0:
13097 case 0xc0:
13098 case 0xd0:
13099 case 0xe0:
13100 goto op_semantics_113;
13101 break;
13102 case 0xf0:
13103 goto op_semantics_114;
c7927a3c
NC		 13104 break;
13105 }
13106 break;
a117b0a5 13107 case 0xea:
c7927a3c 13108 GETBYTE ();
a117b0a5 13109 switch (op[2] & 0xf0)
c7927a3c
NC		 13110 {
13111 case 0x00:
a117b0a5
YS		 13112 case 0x10:
13113 case 0x20:
13114 case 0x30:
13115 case 0x40:
13116 case 0x50:
13117 case 0x60:
13118 case 0x70:
13119 case 0x80:
13120 case 0x90:
13121 case 0xa0:
13122 case 0xb0:
13123 case 0xc0:
13124 case 0xd0:
13125 case 0xe0:
13126 goto op_semantics_113;
13127 break;
13128 case 0xf0:
13129 goto op_semantics_114;
c7927a3c
NC		 13130 break;
13131 }
13132 break;
a117b0a5 13133 case 0xeb:
c7927a3c 13134 GETBYTE ();
a117b0a5 13135 switch (op[2] & 0xf0)
c7927a3c
NC		 13136 {
13137 case 0x00:
a117b0a5
YS		 13138 case 0x10:
13139 case 0x20:
13140 case 0x30:
13141 case 0x40:
13142 case 0x50:
13143 case 0x60:
13144 case 0x70:
13145 case 0x80:
13146 case 0x90:
13147 case 0xa0:
13148 case 0xb0:
13149 case 0xc0:
13150 case 0xd0:
13151 case 0xe0:
13152 goto op_semantics_113;
13153 break;
13154 case 0xf0:
13155 goto op_semantics_114;
c7927a3c
NC		 13156 break;
13157 }
13158 break;
a117b0a5 13159 case 0xec:
c7927a3c 13160 GETBYTE ();
a117b0a5 13161 switch (op[2] & 0xf0)
c7927a3c
NC		 13162 {
13163 case 0x00:
a117b0a5
YS		 13164 case 0x10:
13165 case 0x20:
13166 case 0x30:
13167 case 0x40:
13168 case 0x50:
13169 case 0x60:
13170 case 0x70:
13171 case 0x80:
13172 case 0x90:
13173 case 0xa0:
13174 case 0xb0:
13175 case 0xc0:
13176 case 0xd0:
13177 case 0xe0:
13178 goto op_semantics_113;
13179 break;
13180 case 0xf0:
13181 goto op_semantics_114;
c7927a3c
NC		 13182 break;
13183 }
13184 break;
a117b0a5 13185 case 0xed:
c7927a3c 13186 GETBYTE ();
a117b0a5 13187 switch (op[2] & 0xf0)
c7927a3c
NC		 13188 {
13189 case 0x00:
a117b0a5
YS		 13190 case 0x10:
13191 case 0x20:
13192 case 0x30:
13193 case 0x40:
13194 case 0x50:
13195 case 0x60:
13196 case 0x70:
13197 case 0x80:
13198 case 0x90:
13199 case 0xa0:
13200 case 0xb0:
13201 case 0xc0:
13202 case 0xd0:
13203 case 0xe0:
13204 goto op_semantics_113;
13205 break;
13206 case 0xf0:
13207 goto op_semantics_114;
c7927a3c
NC		 13208 break;
13209 }
13210 break;
a117b0a5 13211 case 0xee:
c7927a3c 13212 GETBYTE ();
a117b0a5 13213 switch (op[2] & 0xf0)
c7927a3c
NC		 13214 {
13215 case 0x00:
a117b0a5
YS		 13216 case 0x10:
13217 case 0x20:
13218 case 0x30:
13219 case 0x40:
13220 case 0x50:
13221 case 0x60:
13222 case 0x70:
13223 case 0x80:
13224 case 0x90:
13225 case 0xa0:
13226 case 0xb0:
13227 case 0xc0:
13228 case 0xd0:
13229 case 0xe0:
13230 goto op_semantics_113;
13231 break;
13232 case 0xf0:
13233 goto op_semantics_114;
c7927a3c
NC		 13234 break;
13235 }
13236 break;
a117b0a5 13237 case 0xef:
c7927a3c 13238 GETBYTE ();
a117b0a5 13239 switch (op[2] & 0xf0)
c7927a3c
NC		 13240 {
13241 case 0x00:
a117b0a5
YS		 13242 case 0x10:
13243 case 0x20:
13244 case 0x30:
13245 case 0x40:
13246 case 0x50:
13247 case 0x60:
13248 case 0x70:
13249 case 0x80:
13250 case 0x90:
13251 case 0xa0:
13252 case 0xb0:
13253 case 0xc0:
13254 case 0xd0:
13255 case 0xe0:
13256 goto op_semantics_113;
13257 break;
13258 case 0xf0:
13259 goto op_semantics_114;
c7927a3c
NC		 13260 break;
13261 }
13262 break;
a117b0a5 13263 case 0xf0:
c7927a3c 13264 GETBYTE ();
a117b0a5 13265 switch (op[2] & 0xf0)
c7927a3c
NC		 13266 {
13267 case 0x00:
a117b0a5
YS		 13268 case 0x10:
13269 case 0x20:
13270 case 0x30:
13271 case 0x40:
13272 case 0x50:
13273 case 0x60:
13274 case 0x70:
13275 case 0x80:
13276 case 0x90:
13277 case 0xa0:
13278 case 0xb0:
13279 case 0xc0:
13280 case 0xd0:
13281 case 0xe0:
13282 goto op_semantics_113;
13283 break;
13284 case 0xf0:
13285 goto op_semantics_114;
c7927a3c
NC		 13286 break;
13287 }
13288 break;
a117b0a5 13289 case 0xf1:
c7927a3c
NC		 13290 GETBYTE ();
13291 switch (op[2] & 0xf0)
13292 {
13293 case 0x00:
13294 case 0x10:
13295 case 0x20:
13296 case 0x30:
13297 case 0x40:
13298 case 0x50:
13299 case 0x60:
13300 case 0x70:
13301 case 0x80:
13302 case 0x90:
13303 case 0xa0:
13304 case 0xb0:
13305 case 0xc0:
13306 case 0xd0:
13307 case 0xe0:
a117b0a5 13308 goto op_semantics_113;
c7927a3c
NC		 13309 break;
13310 case 0xf0:
a117b0a5 13311 goto op_semantics_114;
c7927a3c
NC		 13312 break;
13313 }
13314 break;
a117b0a5 13315 case 0xf2:
c7927a3c
NC		 13316 GETBYTE ();
13317 switch (op[2] & 0xf0)
13318 {
13319 case 0x00:
13320 case 0x10:
13321 case 0x20:
13322 case 0x30:
13323 case 0x40:
13324 case 0x50:
13325 case 0x60:
13326 case 0x70:
13327 case 0x80:
13328 case 0x90:
13329 case 0xa0:
13330 case 0xb0:
13331 case 0xc0:
13332 case 0xd0:
13333 case 0xe0:
a117b0a5 13334 goto op_semantics_113;
c7927a3c
NC		 13335 break;
13336 case 0xf0:
a117b0a5 13337 goto op_semantics_114;
c7927a3c
NC		 13338 break;
13339 }
13340 break;
a117b0a5 13341 case 0xf3:
c7927a3c
NC		 13342 GETBYTE ();
13343 switch (op[2] & 0xf0)
13344 {
13345 case 0x00:
13346 case 0x10:
13347 case 0x20:
13348 case 0x30:
13349 case 0x40:
13350 case 0x50:
13351 case 0x60:
13352 case 0x70:
13353 case 0x80:
13354 case 0x90:
13355 case 0xa0:
13356 case 0xb0:
13357 case 0xc0:
13358 case 0xd0:
13359 case 0xe0:
a117b0a5 13360 goto op_semantics_113;
c7927a3c
NC		 13361 break;
13362 case 0xf0:
a117b0a5 13363 goto op_semantics_114;
c7927a3c
NC		 13364 break;
13365 }
13366 break;
a117b0a5 13367 case 0xf4:
c7927a3c
NC		 13368 GETBYTE ();
13369 switch (op[2] & 0xf0)
13370 {
13371 case 0x00:
13372 case 0x10:
13373 case 0x20:
13374 case 0x30:
13375 case 0x40:
13376 case 0x50:
13377 case 0x60:
13378 case 0x70:
13379 case 0x80:
13380 case 0x90:
13381 case 0xa0:
13382 case 0xb0:
13383 case 0xc0:
13384 case 0xd0:
13385 case 0xe0:
a117b0a5 13386 goto op_semantics_113;
c7927a3c
NC		 13387 break;
13388 case 0xf0:
a117b0a5 13389 goto op_semantics_114;
c7927a3c
NC		 13390 break;
13391 }
13392 break;
a117b0a5 13393 case 0xf5:
c7927a3c
NC		 13394 GETBYTE ();
13395 switch (op[2] & 0xf0)
13396 {
13397 case 0x00:
13398 case 0x10:
13399 case 0x20:
13400 case 0x30:
13401 case 0x40:
13402 case 0x50:
13403 case 0x60:
13404 case 0x70:
13405 case 0x80:
13406 case 0x90:
13407 case 0xa0:
13408 case 0xb0:
13409 case 0xc0:
13410 case 0xd0:
13411 case 0xe0:
a117b0a5 13412 goto op_semantics_113;
c7927a3c
NC		 13413 break;
13414 case 0xf0:
a117b0a5 13415 goto op_semantics_114;
c7927a3c
NC		 13416 break;
13417 }
13418 break;
a117b0a5 13419 case 0xf6:
c7927a3c
NC		 13420 GETBYTE ();
13421 switch (op[2] & 0xf0)
13422 {
13423 case 0x00:
13424 case 0x10:
13425 case 0x20:
13426 case 0x30:
13427 case 0x40:
13428 case 0x50:
13429 case 0x60:
13430 case 0x70:
13431 case 0x80:
13432 case 0x90:
13433 case 0xa0:
13434 case 0xb0:
13435 case 0xc0:
13436 case 0xd0:
13437 case 0xe0:
a117b0a5 13438 goto op_semantics_113;
c7927a3c
NC		 13439 break;
13440 case 0xf0:
a117b0a5 13441 goto op_semantics_114;
c7927a3c
NC		 13442 break;
13443 }
13444 break;
a117b0a5 13445 case 0xf7:
c7927a3c
NC		 13446 GETBYTE ();
13447 switch (op[2] & 0xf0)
13448 {
13449 case 0x00:
13450 case 0x10:
13451 case 0x20:
13452 case 0x30:
13453 case 0x40:
13454 case 0x50:
13455 case 0x60:
13456 case 0x70:
13457 case 0x80:
13458 case 0x90:
13459 case 0xa0:
13460 case 0xb0:
13461 case 0xc0:
13462 case 0xd0:
13463 case 0xe0:
a117b0a5 13464 goto op_semantics_113;
c7927a3c
NC		 13465 break;
13466 case 0xf0:
a117b0a5 13467 goto op_semantics_114;
c7927a3c
NC		 13468 break;
13469 }
13470 break;
a117b0a5 13471 case 0xf8:
c7927a3c
NC		 13472 GETBYTE ();
13473 switch (op[2] & 0xf0)
13474 {
13475 case 0x00:
13476 case 0x10:
13477 case 0x20:
13478 case 0x30:
13479 case 0x40:
13480 case 0x50:
13481 case 0x60:
13482 case 0x70:
13483 case 0x80:
13484 case 0x90:
13485 case 0xa0:
13486 case 0xb0:
13487 case 0xc0:
13488 case 0xd0:
13489 case 0xe0:
a117b0a5 13490 goto op_semantics_113;
c7927a3c
NC		 13491 break;
13492 case 0xf0:
a117b0a5 13493 goto op_semantics_114;
c7927a3c
NC		 13494 break;
13495 }
13496 break;
a117b0a5 13497 case 0xf9:
c7927a3c
NC		 13498 GETBYTE ();
13499 switch (op[2] & 0xf0)
13500 {
13501 case 0x00:
13502 case 0x10:
13503 case 0x20:
13504 case 0x30:
13505 case 0x40:
13506 case 0x50:
13507 case 0x60:
13508 case 0x70:
13509 case 0x80:
13510 case 0x90:
13511 case 0xa0:
13512 case 0xb0:
13513 case 0xc0:
13514 case 0xd0:
13515 case 0xe0:
a117b0a5 13516 goto op_semantics_113;
c7927a3c
NC		 13517 break;
13518 case 0xf0:
a117b0a5 13519 goto op_semantics_114;
c7927a3c
NC		 13520 break;
13521 }
13522 break;
a117b0a5 13523 case 0xfa:
c7927a3c
NC		 13524 GETBYTE ();
13525 switch (op[2] & 0xf0)
13526 {
13527 case 0x00:
13528 case 0x10:
13529 case 0x20:
13530 case 0x30:
13531 case 0x40:
13532 case 0x50:
13533 case 0x60:
13534 case 0x70:
13535 case 0x80:
13536 case 0x90:
13537 case 0xa0:
13538 case 0xb0:
13539 case 0xc0:
13540 case 0xd0:
13541 case 0xe0:
a117b0a5 13542 goto op_semantics_113;
c7927a3c
NC		 13543 break;
13544 case 0xf0:
a117b0a5 13545 goto op_semantics_114;
c7927a3c
NC		 13546 break;
13547 }
13548 break;
a117b0a5 13549 case 0xfb:
c7927a3c
NC		 13550 GETBYTE ();
13551 switch (op[2] & 0xf0)
13552 {
13553 case 0x00:
13554 case 0x10:
13555 case 0x20:
13556 case 0x30:
13557 case 0x40:
13558 case 0x50:
13559 case 0x60:
13560 case 0x70:
13561 case 0x80:
13562 case 0x90:
13563 case 0xa0:
13564 case 0xb0:
13565 case 0xc0:
13566 case 0xd0:
13567 case 0xe0:
a117b0a5 13568 goto op_semantics_113;
c7927a3c
NC		 13569 break;
13570 case 0xf0:
a117b0a5 13571 goto op_semantics_114;
c7927a3c
NC		 13572 break;
13573 }
13574 break;
a117b0a5 13575 case 0xfc:
c7927a3c
NC		 13576 GETBYTE ();
13577 switch (op[2] & 0xf0)
13578 {
13579 case 0x00:
13580 case 0x10:
13581 case 0x20:
13582 case 0x30:
13583 case 0x40:
13584 case 0x50:
13585 case 0x60:
13586 case 0x70:
13587 case 0x80:
13588 case 0x90:
13589 case 0xa0:
13590 case 0xb0:
13591 case 0xc0:
13592 case 0xd0:
13593 case 0xe0:
a117b0a5 13594 goto op_semantics_113;
c7927a3c
NC		 13595 break;
13596 case 0xf0:
a117b0a5 13597 goto op_semantics_114;
c7927a3c
NC		 13598 break;
13599 }
13600 break;
a117b0a5 13601 case 0xfd:
c7927a3c
NC		 13602 GETBYTE ();
13603 switch (op[2] & 0xf0)
13604 {
13605 case 0x00:
13606 case 0x10:
13607 case 0x20:
13608 case 0x30:
13609 case 0x40:
13610 case 0x50:
13611 case 0x60:
13612 case 0x70:
13613 case 0x80:
13614 case 0x90:
13615 case 0xa0:
13616 case 0xb0:
13617 case 0xc0:
13618 case 0xd0:
13619 case 0xe0:
a117b0a5 13620 goto op_semantics_113;
c7927a3c
NC		 13621 break;
13622 case 0xf0:
a117b0a5 13623 goto op_semantics_114;
c7927a3c
NC		 13624 break;
13625 }
13626 break;
a117b0a5 13627 case 0xfe:
c7927a3c
NC		 13628 GETBYTE ();
13629 switch (op[2] & 0xf0)
13630 {
13631 case 0x00:
13632 case 0x10:
13633 case 0x20:
13634 case 0x30:
13635 case 0x40:
13636 case 0x50:
13637 case 0x60:
13638 case 0x70:
13639 case 0x80:
13640 case 0x90:
13641 case 0xa0:
13642 case 0xb0:
13643 case 0xc0:
13644 case 0xd0:
13645 case 0xe0:
a117b0a5 13646 goto op_semantics_113;
c7927a3c
NC		 13647 break;
13648 case 0xf0:
a117b0a5 13649 goto op_semantics_114;
c7927a3c
NC		 13650 break;
13651 }
13652 break;
a117b0a5 13653 case 0xff:
c7927a3c
NC		 13654 GETBYTE ();
13655 switch (op[2] & 0xf0)
13656 {
13657 case 0x00:
13658 case 0x10:
13659 case 0x20:
13660 case 0x30:
13661 case 0x40:
13662 case 0x50:
13663 case 0x60:
13664 case 0x70:
13665 case 0x80:
13666 case 0x90:
13667 case 0xa0:
13668 case 0xb0:
13669 case 0xc0:
13670 case 0xd0:
13671 case 0xe0:
a117b0a5 13672 goto op_semantics_113;
c7927a3c
NC		 13673 break;
13674 case 0xf0:
a117b0a5
YS		 13675 goto op_semantics_114;
13676 break;
13677 }
13678 break;
13679 default: UNSUPPORTED(); break;
13680 }
13681 break;
13682 case 0xfe:
13683 GETBYTE ();
13684 switch (op[1] & 0xff)
13685 {
13686 case 0x00:
13687 GETBYTE ();
13688 switch (op[2] & 0x00)
13689 {
13690 case 0x00:
13691 op_semantics_115:
13692 {
13693 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
13694#line 338 "rx-decode.opc"
13695 int sz AU = (op[1] >> 4) & 0x03;
13696#line 338 "rx-decode.opc"
13697 int isrc AU = op[1] & 0x0f;
13698#line 338 "rx-decode.opc"
13699 int bsrc AU = (op[2] >> 4) & 0x0f;
13700#line 338 "rx-decode.opc"
13701 int rdst AU = op[2] & 0x0f;
13702 if (trace)
13703 {
13704 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13705 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
13706 op[0], op[1], op[2]);
13707 printf (" sz = 0x%x,", sz);
13708 printf (" isrc = 0x%x,", isrc);
13709 printf (" bsrc = 0x%x,", bsrc);
13710 printf (" rdst = 0x%x\n", rdst);
13711 }
13712 SYNTAX("mov%s %0, [%1, %2]");
13713#line 338 "rx-decode.opc"
13714 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13715
13716 }
13717 break;
13718 }
13719 break;
13720 case 0x01:
13721 GETBYTE ();
13722 switch (op[2] & 0x00)
13723 {
13724 case 0x00:
13725 goto op_semantics_115;
13726 break;
13727 }
13728 break;
13729 case 0x02:
13730 GETBYTE ();
13731 switch (op[2] & 0x00)
13732 {
13733 case 0x00:
13734 goto op_semantics_115;
13735 break;
13736 }
13737 break;
13738 case 0x03:
13739 GETBYTE ();
13740 switch (op[2] & 0x00)
13741 {
13742 case 0x00:
13743 goto op_semantics_115;
13744 break;
13745 }
13746 break;
13747 case 0x04:
13748 GETBYTE ();
13749 switch (op[2] & 0x00)
13750 {
13751 case 0x00:
13752 goto op_semantics_115;
13753 break;
13754 }
13755 break;
13756 case 0x05:
13757 GETBYTE ();
13758 switch (op[2] & 0x00)
13759 {
13760 case 0x00:
13761 goto op_semantics_115;
13762 break;
13763 }
13764 break;
13765 case 0x06:
13766 GETBYTE ();
13767 switch (op[2] & 0x00)
13768 {
13769 case 0x00:
13770 goto op_semantics_115;
13771 break;
13772 }
13773 break;
13774 case 0x07:
13775 GETBYTE ();
13776 switch (op[2] & 0x00)
13777 {
13778 case 0x00:
13779 goto op_semantics_115;
13780 break;
13781 }
13782 break;
13783 case 0x08:
13784 GETBYTE ();
13785 switch (op[2] & 0x00)
13786 {
13787 case 0x00:
13788 goto op_semantics_115;
13789 break;
13790 }
13791 break;
13792 case 0x09:
13793 GETBYTE ();
13794 switch (op[2] & 0x00)
13795 {
13796 case 0x00:
13797 goto op_semantics_115;
13798 break;
13799 }
13800 break;
13801 case 0x0a:
13802 GETBYTE ();
13803 switch (op[2] & 0x00)
13804 {
13805 case 0x00:
13806 goto op_semantics_115;
13807 break;
13808 }
13809 break;
13810 case 0x0b:
13811 GETBYTE ();
13812 switch (op[2] & 0x00)
13813 {
13814 case 0x00:
13815 goto op_semantics_115;
13816 break;
13817 }
13818 break;
13819 case 0x0c:
13820 GETBYTE ();
13821 switch (op[2] & 0x00)
13822 {
13823 case 0x00:
13824 goto op_semantics_115;
13825 break;
13826 }
13827 break;
13828 case 0x0d:
13829 GETBYTE ();
13830 switch (op[2] & 0x00)
13831 {
13832 case 0x00:
13833 goto op_semantics_115;
13834 break;
13835 }
13836 break;
13837 case 0x0e:
13838 GETBYTE ();
13839 switch (op[2] & 0x00)
13840 {
13841 case 0x00:
13842 goto op_semantics_115;
13843 break;
13844 }
13845 break;
13846 case 0x0f:
13847 GETBYTE ();
13848 switch (op[2] & 0x00)
13849 {
13850 case 0x00:
13851 goto op_semantics_115;
13852 break;
13853 }
13854 break;
13855 case 0x10:
13856 GETBYTE ();
13857 switch (op[2] & 0x00)
13858 {
13859 case 0x00:
13860 goto op_semantics_115;
13861 break;
13862 }
13863 break;
13864 case 0x11:
13865 GETBYTE ();
13866 switch (op[2] & 0x00)
13867 {
13868 case 0x00:
13869 goto op_semantics_115;
13870 break;
13871 }
13872 break;
13873 case 0x12:
13874 GETBYTE ();
13875 switch (op[2] & 0x00)
13876 {
13877 case 0x00:
13878 goto op_semantics_115;
13879 break;
13880 }
13881 break;
13882 case 0x13:
13883 GETBYTE ();
13884 switch (op[2] & 0x00)
13885 {
13886 case 0x00:
13887 goto op_semantics_115;
13888 break;
13889 }
13890 break;
13891 case 0x14:
13892 GETBYTE ();
13893 switch (op[2] & 0x00)
13894 {
13895 case 0x00:
13896 goto op_semantics_115;
13897 break;
13898 }
13899 break;
13900 case 0x15:
13901 GETBYTE ();
13902 switch (op[2] & 0x00)
13903 {
13904 case 0x00:
13905 goto op_semantics_115;
13906 break;
13907 }
13908 break;
13909 case 0x16:
13910 GETBYTE ();
13911 switch (op[2] & 0x00)
13912 {
13913 case 0x00:
13914 goto op_semantics_115;
13915 break;
13916 }
13917 break;
13918 case 0x17:
13919 GETBYTE ();
13920 switch (op[2] & 0x00)
13921 {
13922 case 0x00:
13923 goto op_semantics_115;
13924 break;
13925 }
13926 break;
13927 case 0x18:
13928 GETBYTE ();
13929 switch (op[2] & 0x00)
13930 {
13931 case 0x00:
13932 goto op_semantics_115;
13933 break;
13934 }
13935 break;
13936 case 0x19:
13937 GETBYTE ();
13938 switch (op[2] & 0x00)
13939 {
13940 case 0x00:
13941 goto op_semantics_115;
c7927a3c
NC		 13942 break;
13943 }
13944 break;
a117b0a5 13945 case 0x1a:
c7927a3c 13946 GETBYTE ();
a117b0a5 13947 switch (op[2] & 0x00)
c7927a3c
NC		 13948 {
13949 case 0x00:
a117b0a5 13950 goto op_semantics_115;
c7927a3c
NC		 13951 break;
13952 }
13953 break;
a117b0a5 13954 case 0x1b:
c7927a3c 13955 GETBYTE ();
a117b0a5 13956 switch (op[2] & 0x00)
c7927a3c
NC		 13957 {
13958 case 0x00:
a117b0a5 13959 goto op_semantics_115;
c7927a3c
NC		 13960 break;
13961 }
13962 break;
a117b0a5 13963 case 0x1c:
c7927a3c 13964 GETBYTE ();
a117b0a5 13965 switch (op[2] & 0x00)
c7927a3c
NC		 13966 {
13967 case 0x00:
a117b0a5 13968 goto op_semantics_115;
c7927a3c
NC		 13969 break;
13970 }
13971 break;
a117b0a5 13972 case 0x1d:
c7927a3c 13973 GETBYTE ();
a117b0a5 13974 switch (op[2] & 0x00)
c7927a3c
NC		 13975 {
13976 case 0x00:
a117b0a5 13977 goto op_semantics_115;
c7927a3c
NC		 13978 break;
13979 }
13980 break;
a117b0a5 13981 case 0x1e:
c7927a3c 13982 GETBYTE ();
a117b0a5 13983 switch (op[2] & 0x00)
c7927a3c
NC		 13984 {
13985 case 0x00:
a117b0a5 13986 goto op_semantics_115;
c7927a3c
NC		 13987 break;
13988 }
13989 break;
a117b0a5 13990 case 0x1f:
c7927a3c 13991 GETBYTE ();
a117b0a5 13992 switch (op[2] & 0x00)
c7927a3c
NC		 13993 {
13994 case 0x00:
a117b0a5 13995 goto op_semantics_115;
c7927a3c
NC		 13996 break;
13997 }
13998 break;
a117b0a5 13999 case 0x20:
c7927a3c 14000 GETBYTE ();
a117b0a5 14001 switch (op[2] & 0x00)
c7927a3c
NC		 14002 {
14003 case 0x00:
a117b0a5 14004 goto op_semantics_115;
c7927a3c
NC		 14005 break;
14006 }
14007 break;
a117b0a5 14008 case 0x21:
c7927a3c 14009 GETBYTE ();
a117b0a5 14010 switch (op[2] & 0x00)
c7927a3c
NC		 14011 {
14012 case 0x00:
a117b0a5 14013 goto op_semantics_115;
c7927a3c
NC		 14014 break;
14015 }
14016 break;
a117b0a5 14017 case 0x22:
c7927a3c 14018 GETBYTE ();
a117b0a5 14019 switch (op[2] & 0x00)
c7927a3c
NC		 14020 {
14021 case 0x00:
a117b0a5 14022 goto op_semantics_115;
c7927a3c 14023 break;
a117b0a5
YS		 14024 }
14025 break;
14026 case 0x23:
14027 GETBYTE ();
14028 switch (op[2] & 0x00)
14029 {
14030 case 0x00:
14031 goto op_semantics_115;
c7927a3c
NC		 14032 break;
14033 }
14034 break;
a117b0a5 14035 case 0x24:
c7927a3c 14036 GETBYTE ();
a117b0a5 14037 switch (op[2] & 0x00)
c7927a3c
NC		 14038 {
14039 case 0x00:
a117b0a5 14040 goto op_semantics_115;
c7927a3c 14041 break;
a117b0a5
YS		 14042 }
14043 break;
14044 case 0x25:
14045 GETBYTE ();
14046 switch (op[2] & 0x00)
14047 {
14048 case 0x00:
14049 goto op_semantics_115;
c7927a3c
NC		 14050 break;
14051 }
14052 break;
a117b0a5 14053 case 0x26:
c7927a3c 14054 GETBYTE ();
a117b0a5 14055 switch (op[2] & 0x00)
c7927a3c
NC		 14056 {
14057 case 0x00:
a117b0a5 14058 goto op_semantics_115;
c7927a3c 14059 break;
a117b0a5
YS		 14060 }
14061 break;
14062 case 0x27:
14063 GETBYTE ();
14064 switch (op[2] & 0x00)
14065 {
14066 case 0x00:
14067 goto op_semantics_115;
c7927a3c
NC		 14068 break;
14069 }
14070 break;
a117b0a5 14071 case 0x28:
c7927a3c 14072 GETBYTE ();
a117b0a5 14073 switch (op[2] & 0x00)
c7927a3c
NC		 14074 {
14075 case 0x00:
a117b0a5 14076 goto op_semantics_115;
c7927a3c
NC		 14077 break;
14078 }
14079 break;
a117b0a5 14080 case 0x29:
c7927a3c 14081 GETBYTE ();
a117b0a5 14082 switch (op[2] & 0x00)
c7927a3c
NC		 14083 {
14084 case 0x00:
a117b0a5 14085 goto op_semantics_115;
c7927a3c
NC		 14086 break;
14087 }
14088 break;
a117b0a5 14089 case 0x2a:
c7927a3c 14090 GETBYTE ();
a117b0a5 14091 switch (op[2] & 0x00)
c7927a3c
NC		 14092 {
14093 case 0x00:
a117b0a5 14094 goto op_semantics_115;
c7927a3c
NC		 14095 break;
14096 }
14097 break;
a117b0a5 14098 case 0x2b:
c7927a3c 14099 GETBYTE ();
a117b0a5 14100 switch (op[2] & 0x00)
c7927a3c
NC		 14101 {
14102 case 0x00:
a117b0a5 14103 goto op_semantics_115;
c7927a3c
NC		 14104 break;
14105 }
14106 break;
a117b0a5 14107 case 0x2c:
c7927a3c 14108 GETBYTE ();
a117b0a5 14109 switch (op[2] & 0x00)
c7927a3c
NC		 14110 {
14111 case 0x00:
a117b0a5 14112 goto op_semantics_115;
c7927a3c 14113 break;
a117b0a5
YS		 14114 }
14115 break;
14116 case 0x2d:
14117 GETBYTE ();
14118 switch (op[2] & 0x00)
14119 {
14120 case 0x00:
14121 goto op_semantics_115;
c7927a3c
NC		 14122 break;
14123 }
14124 break;
a117b0a5 14125 case 0x2e:
c7927a3c 14126 GETBYTE ();
a117b0a5 14127 switch (op[2] & 0x00)
c7927a3c
NC		 14128 {
14129 case 0x00:
a117b0a5 14130 goto op_semantics_115;
c7927a3c 14131 break;
a117b0a5
YS		 14132 }
14133 break;
14134 case 0x2f:
14135 GETBYTE ();
14136 switch (op[2] & 0x00)
14137 {
14138 case 0x00:
14139 goto op_semantics_115;
c7927a3c
NC		 14140 break;
14141 }
14142 break;
a117b0a5 14143 case 0x40:
c7927a3c
NC		 14144 GETBYTE ();
14145 switch (op[2] & 0x00)
14146 {
14147 case 0x00:
a117b0a5 14148 op_semantics_116:
c7927a3c 14149 {
a117b0a5
YS		 14150 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
14151#line 335 "rx-decode.opc"
c7927a3c 14152 int sz AU = (op[1] >> 4) & 0x03;
a117b0a5 14153#line 335 "rx-decode.opc"
c7927a3c 14154 int isrc AU = op[1] & 0x0f;
a117b0a5 14155#line 335 "rx-decode.opc"
c7927a3c 14156 int bsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 14157#line 335 "rx-decode.opc"
c7927a3c
NC		 14158 int rdst AU = op[2] & 0x0f;
14159 if (trace)
14160 {
14161 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 14162 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
c7927a3c
NC		 14163 op[0], op[1], op[2]);
14164 printf (" sz = 0x%x,", sz);
14165 printf (" isrc = 0x%x,", isrc);
14166 printf (" bsrc = 0x%x,", bsrc);
14167 printf (" rdst = 0x%x\n", rdst);
14168 }
a117b0a5
YS		 14169 SYNTAX("mov%s [%1, %2], %0");
14170#line 335 "rx-decode.opc"
14171 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
43e65147 14172
c7927a3c
NC		 14173 }
14174 break;
14175 }
14176 break;
a117b0a5 14177 case 0x41:
c7927a3c
NC		 14178 GETBYTE ();
14179 switch (op[2] & 0x00)
14180 {
14181 case 0x00:
a117b0a5 14182 goto op_semantics_116;
c7927a3c
NC		 14183 break;
14184 }
14185 break;
a117b0a5 14186 case 0x42:
c7927a3c
NC		 14187 GETBYTE ();
14188 switch (op[2] & 0x00)
14189 {
14190 case 0x00:
a117b0a5 14191 goto op_semantics_116;
c7927a3c
NC		 14192 break;
14193 }
14194 break;
a117b0a5 14195 case 0x43:
c7927a3c
NC		 14196 GETBYTE ();
14197 switch (op[2] & 0x00)
14198 {
14199 case 0x00:
a117b0a5 14200 goto op_semantics_116;
c7927a3c
NC		 14201 break;
14202 }
14203 break;
a117b0a5 14204 case 0x44:
c7927a3c
NC		 14205 GETBYTE ();
14206 switch (op[2] & 0x00)
14207 {
14208 case 0x00:
a117b0a5 14209 goto op_semantics_116;
c7927a3c
NC		 14210 break;
14211 }
14212 break;
a117b0a5 14213 case 0x45:
c7927a3c
NC		 14214 GETBYTE ();
14215 switch (op[2] & 0x00)
14216 {
14217 case 0x00:
a117b0a5 14218 goto op_semantics_116;
c7927a3c
NC		 14219 break;
14220 }
14221 break;
a117b0a5 14222 case 0x46:
c7927a3c
NC		 14223 GETBYTE ();
14224 switch (op[2] & 0x00)
14225 {
14226 case 0x00:
a117b0a5 14227 goto op_semantics_116;
c7927a3c
NC		 14228 break;
14229 }
14230 break;
a117b0a5 14231 case 0x47:
c7927a3c
NC		 14232 GETBYTE ();
14233 switch (op[2] & 0x00)
14234 {
14235 case 0x00:
a117b0a5 14236 goto op_semantics_116;
c7927a3c
NC		 14237 break;
14238 }
14239 break;
a117b0a5 14240 case 0x48:
c7927a3c
NC		 14241 GETBYTE ();
14242 switch (op[2] & 0x00)
14243 {
14244 case 0x00:
a117b0a5 14245 goto op_semantics_116;
c7927a3c
NC		 14246 break;
14247 }
14248 break;
a117b0a5 14249 case 0x49:
c7927a3c
NC		 14250 GETBYTE ();
14251 switch (op[2] & 0x00)
14252 {
14253 case 0x00:
a117b0a5 14254 goto op_semantics_116;
c7927a3c
NC		 14255 break;
14256 }
14257 break;
a117b0a5 14258 case 0x4a:
c7927a3c
NC		 14259 GETBYTE ();
14260 switch (op[2] & 0x00)
14261 {
14262 case 0x00:
a117b0a5 14263 goto op_semantics_116;
c7927a3c
NC		 14264 break;
14265 }
14266 break;
a117b0a5 14267 case 0x4b:
c7927a3c
NC		 14268 GETBYTE ();
14269 switch (op[2] & 0x00)
14270 {
14271 case 0x00:
a117b0a5 14272 goto op_semantics_116;
c7927a3c
NC		 14273 break;
14274 }
14275 break;
a117b0a5 14276 case 0x4c:
c7927a3c
NC		 14277 GETBYTE ();
14278 switch (op[2] & 0x00)
14279 {
14280 case 0x00:
a117b0a5 14281 goto op_semantics_116;
c7927a3c
NC		 14282 break;
14283 }
14284 break;
a117b0a5 14285 case 0x4d:
c7927a3c
NC		 14286 GETBYTE ();
14287 switch (op[2] & 0x00)
14288 {
14289 case 0x00:
a117b0a5 14290 goto op_semantics_116;
c7927a3c
NC		 14291 break;
14292 }
14293 break;
a117b0a5 14294 case 0x4e:
c7927a3c
NC		 14295 GETBYTE ();
14296 switch (op[2] & 0x00)
14297 {
14298 case 0x00:
a117b0a5 14299 goto op_semantics_116;
c7927a3c
NC		 14300 break;
14301 }
14302 break;
a117b0a5 14303 case 0x4f:
c7927a3c
NC		 14304 GETBYTE ();
14305 switch (op[2] & 0x00)
14306 {
14307 case 0x00:
a117b0a5 14308 goto op_semantics_116;
c7927a3c
NC		 14309 break;
14310 }
14311 break;
a117b0a5 14312 case 0x50:
c7927a3c
NC		 14313 GETBYTE ();
14314 switch (op[2] & 0x00)
14315 {
14316 case 0x00:
a117b0a5 14317 goto op_semantics_116;
c7927a3c
NC		 14318 break;
14319 }
14320 break;
a117b0a5 14321 case 0x51:
c7927a3c
NC		 14322 GETBYTE ();
14323 switch (op[2] & 0x00)
14324 {
14325 case 0x00:
a117b0a5 14326 goto op_semantics_116;
c7927a3c
NC		 14327 break;
14328 }
14329 break;
a117b0a5 14330 case 0x52:
c7927a3c
NC		 14331 GETBYTE ();
14332 switch (op[2] & 0x00)
14333 {
14334 case 0x00:
a117b0a5 14335 goto op_semantics_116;
c7927a3c
NC		 14336 break;
14337 }
14338 break;
a117b0a5 14339 case 0x53:
c7927a3c
NC		 14340 GETBYTE ();
14341 switch (op[2] & 0x00)
14342 {
14343 case 0x00:
a117b0a5 14344 goto op_semantics_116;
c7927a3c
NC		 14345 break;
14346 }
14347 break;
a117b0a5 14348 case 0x54:
c7927a3c
NC		 14349 GETBYTE ();
14350 switch (op[2] & 0x00)
14351 {
14352 case 0x00:
a117b0a5 14353 goto op_semantics_116;
c7927a3c
NC		 14354 break;
14355 }
14356 break;
a117b0a5 14357 case 0x55:
c7927a3c
NC		 14358 GETBYTE ();
14359 switch (op[2] & 0x00)
14360 {
14361 case 0x00:
a117b0a5 14362 goto op_semantics_116;
c7927a3c
NC		 14363 break;
14364 }
14365 break;
a117b0a5 14366 case 0x56:
c7927a3c
NC		 14367 GETBYTE ();
14368 switch (op[2] & 0x00)
14369 {
14370 case 0x00:
a117b0a5 14371 goto op_semantics_116;
c7927a3c
NC		 14372 break;
14373 }
14374 break;
a117b0a5 14375 case 0x57:
c7927a3c
NC		 14376 GETBYTE ();
14377 switch (op[2] & 0x00)
14378 {
14379 case 0x00:
a117b0a5 14380 goto op_semantics_116;
c7927a3c
NC		 14381 break;
14382 }
14383 break;
a117b0a5 14384 case 0x58:
c7927a3c
NC		 14385 GETBYTE ();
14386 switch (op[2] & 0x00)
14387 {
14388 case 0x00:
a117b0a5 14389 goto op_semantics_116;
c7927a3c
NC		 14390 break;
14391 }
14392 break;
a117b0a5 14393 case 0x59:
c7927a3c
NC		 14394 GETBYTE ();
14395 switch (op[2] & 0x00)
14396 {
14397 case 0x00:
a117b0a5 14398 goto op_semantics_116;
c7927a3c
NC		 14399 break;
14400 }
14401 break;
a117b0a5 14402 case 0x5a:
c7927a3c
NC		 14403 GETBYTE ();
14404 switch (op[2] & 0x00)
14405 {
14406 case 0x00:
a117b0a5 14407 goto op_semantics_116;
c7927a3c
NC		 14408 break;
14409 }
14410 break;
a117b0a5 14411 case 0x5b:
c7927a3c
NC		 14412 GETBYTE ();
14413 switch (op[2] & 0x00)
14414 {
14415 case 0x00:
a117b0a5 14416 goto op_semantics_116;
c7927a3c
NC		 14417 break;
14418 }
14419 break;
a117b0a5 14420 case 0x5c:
c7927a3c
NC		 14421 GETBYTE ();
14422 switch (op[2] & 0x00)
14423 {
14424 case 0x00:
a117b0a5 14425 goto op_semantics_116;
c7927a3c
NC		 14426 break;
14427 }
14428 break;
a117b0a5 14429 case 0x5d:
c7927a3c
NC		 14430 GETBYTE ();
14431 switch (op[2] & 0x00)
14432 {
14433 case 0x00:
a117b0a5 14434 goto op_semantics_116;
c7927a3c
NC		 14435 break;
14436 }
14437 break;
a117b0a5 14438 case 0x5e:
c7927a3c
NC		 14439 GETBYTE ();
14440 switch (op[2] & 0x00)
14441 {
14442 case 0x00:
a117b0a5 14443 goto op_semantics_116;
c7927a3c
NC		 14444 break;
14445 }
14446 break;
a117b0a5 14447 case 0x5f:
c7927a3c
NC		 14448 GETBYTE ();
14449 switch (op[2] & 0x00)
14450 {
14451 case 0x00:
a117b0a5 14452 goto op_semantics_116;
c7927a3c
NC		 14453 break;
14454 }
14455 break;
a117b0a5 14456 case 0x60:
c7927a3c
NC		 14457 GETBYTE ();
14458 switch (op[2] & 0x00)
14459 {
14460 case 0x00:
a117b0a5 14461 goto op_semantics_116;
c7927a3c
NC		 14462 break;
14463 }
14464 break;
a117b0a5 14465 case 0x61:
c7927a3c
NC		 14466 GETBYTE ();
14467 switch (op[2] & 0x00)
14468 {
14469 case 0x00:
a117b0a5 14470 goto op_semantics_116;
c7927a3c
NC		 14471 break;
14472 }
14473 break;
a117b0a5 14474 case 0x62:
c7927a3c
NC		 14475 GETBYTE ();
14476 switch (op[2] & 0x00)
14477 {
14478 case 0x00:
a117b0a5 14479 goto op_semantics_116;
c7927a3c
NC		 14480 break;
14481 }
14482 break;
a117b0a5 14483 case 0x63:
c7927a3c
NC		 14484 GETBYTE ();
14485 switch (op[2] & 0x00)
14486 {
14487 case 0x00:
a117b0a5 14488 goto op_semantics_116;
c7927a3c
NC		 14489 break;
14490 }
14491 break;
a117b0a5 14492 case 0x64:
c7927a3c
NC		 14493 GETBYTE ();
14494 switch (op[2] & 0x00)
14495 {
14496 case 0x00:
a117b0a5 14497 goto op_semantics_116;
c7927a3c
NC		 14498 break;
14499 }
14500 break;
a117b0a5 14501 case 0x65:
c7927a3c
NC		 14502 GETBYTE ();
14503 switch (op[2] & 0x00)
14504 {
14505 case 0x00:
a117b0a5 14506 goto op_semantics_116;
c7927a3c
NC		 14507 break;
14508 }
14509 break;
a117b0a5 14510 case 0x66:
c7927a3c
NC		 14511 GETBYTE ();
14512 switch (op[2] & 0x00)
14513 {
14514 case 0x00:
a117b0a5 14515 goto op_semantics_116;
c7927a3c
NC		 14516 break;
14517 }
14518 break;
a117b0a5 14519 case 0x67:
c7927a3c
NC		 14520 GETBYTE ();
14521 switch (op[2] & 0x00)
14522 {
14523 case 0x00:
a117b0a5 14524 goto op_semantics_116;
c7927a3c
NC		 14525 break;
14526 }
14527 break;
a117b0a5 14528 case 0x68:
c7927a3c
NC		 14529 GETBYTE ();
14530 switch (op[2] & 0x00)
14531 {
14532 case 0x00:
a117b0a5 14533 goto op_semantics_116;
c7927a3c
NC		 14534 break;
14535 }
14536 break;
a117b0a5 14537 case 0x69:
c7927a3c
NC		 14538 GETBYTE ();
14539 switch (op[2] & 0x00)
14540 {
14541 case 0x00:
a117b0a5 14542 goto op_semantics_116;
c7927a3c
NC		 14543 break;
14544 }
14545 break;
a117b0a5 14546 case 0x6a:
c7927a3c
NC		 14547 GETBYTE ();
14548 switch (op[2] & 0x00)
14549 {
14550 case 0x00:
a117b0a5 14551 goto op_semantics_116;
c7927a3c
NC		 14552 break;
14553 }
14554 break;
a117b0a5 14555 case 0x6b:
c7927a3c
NC		 14556 GETBYTE ();
14557 switch (op[2] & 0x00)
14558 {
14559 case 0x00:
a117b0a5 14560 goto op_semantics_116;
c7927a3c
NC		 14561 break;
14562 }
14563 break;
a117b0a5 14564 case 0x6c:
c7927a3c
NC		 14565 GETBYTE ();
14566 switch (op[2] & 0x00)
14567 {
14568 case 0x00:
a117b0a5 14569 goto op_semantics_116;
c7927a3c
NC		 14570 break;
14571 }
14572 break;
a117b0a5 14573 case 0x6d:
c7927a3c
NC		 14574 GETBYTE ();
14575 switch (op[2] & 0x00)
14576 {
14577 case 0x00:
a117b0a5 14578 goto op_semantics_116;
c7927a3c
NC		 14579 break;
14580 }
14581 break;
a117b0a5 14582 case 0x6e:
c7927a3c
NC		 14583 GETBYTE ();
14584 switch (op[2] & 0x00)
14585 {
14586 case 0x00:
a117b0a5 14587 goto op_semantics_116;
c7927a3c
NC		 14588 break;
14589 }
14590 break;
a117b0a5 14591 case 0x6f:
c7927a3c
NC		 14592 GETBYTE ();
14593 switch (op[2] & 0x00)
14594 {
14595 case 0x00:
a117b0a5 14596 goto op_semantics_116;
c7927a3c
NC		 14597 break;
14598 }
14599 break;
a117b0a5 14600 case 0xc0:
c7927a3c
NC		 14601 GETBYTE ();
14602 switch (op[2] & 0x00)
14603 {
14604 case 0x00:
a117b0a5 14605 op_semantics_117:
c7927a3c 14606 {
a117b0a5
YS		 14607 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
14608#line 341 "rx-decode.opc"
c7927a3c 14609 int sz AU = (op[1] >> 4) & 0x03;
a117b0a5 14610#line 341 "rx-decode.opc"
c7927a3c 14611 int isrc AU = op[1] & 0x0f;
a117b0a5 14612#line 341 "rx-decode.opc"
c7927a3c 14613 int bsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5 14614#line 341 "rx-decode.opc"
c7927a3c
NC		 14615 int rdst AU = op[2] & 0x0f;
14616 if (trace)
14617 {
14618 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 14619 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
c7927a3c
NC		 14620 op[0], op[1], op[2]);
14621 printf (" sz = 0x%x,", sz);
14622 printf (" isrc = 0x%x,", isrc);
14623 printf (" bsrc = 0x%x,", bsrc);
14624 printf (" rdst = 0x%x\n", rdst);
14625 }
a117b0a5
YS		 14626 SYNTAX("movu%s [%1, %2], %0");
14627#line 341 "rx-decode.opc"
14628 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
43e65147 14629
c7927a3c
NC		 14630 }
14631 break;
14632 }
14633 break;
a117b0a5 14634 case 0xc1:
c7927a3c
NC		 14635 GETBYTE ();
14636 switch (op[2] & 0x00)
14637 {
14638 case 0x00:
a117b0a5 14639 goto op_semantics_117;
c7927a3c
NC		 14640 break;
14641 }
14642 break;
a117b0a5 14643 case 0xc2:
c7927a3c
NC		 14644 GETBYTE ();
14645 switch (op[2] & 0x00)
14646 {
14647 case 0x00:
a117b0a5 14648 goto op_semantics_117;
c7927a3c
NC		 14649 break;
14650 }
14651 break;
a117b0a5 14652 case 0xc3:
c7927a3c
NC		 14653 GETBYTE ();
14654 switch (op[2] & 0x00)
14655 {
14656 case 0x00:
a117b0a5 14657 goto op_semantics_117;
c7927a3c
NC		 14658 break;
14659 }
14660 break;
a117b0a5 14661 case 0xc4:
c7927a3c
NC		 14662 GETBYTE ();
14663 switch (op[2] & 0x00)
14664 {
14665 case 0x00:
a117b0a5 14666 goto op_semantics_117;
c7927a3c
NC		 14667 break;
14668 }
14669 break;
a117b0a5 14670 case 0xc5:
c7927a3c
NC		 14671 GETBYTE ();
14672 switch (op[2] & 0x00)
14673 {
14674 case 0x00:
a117b0a5 14675 goto op_semantics_117;
c7927a3c
NC		 14676 break;
14677 }
14678 break;
a117b0a5 14679 case 0xc6:
c7927a3c
NC		 14680 GETBYTE ();
14681 switch (op[2] & 0x00)
14682 {
14683 case 0x00:
a117b0a5 14684 goto op_semantics_117;
c7927a3c
NC		 14685 break;
14686 }
14687 break;
a117b0a5 14688 case 0xc7:
c7927a3c
NC		 14689 GETBYTE ();
14690 switch (op[2] & 0x00)
14691 {
14692 case 0x00:
a117b0a5 14693 goto op_semantics_117;
c7927a3c
NC		 14694 break;
14695 }
14696 break;
a117b0a5 14697 case 0xc8:
c7927a3c
NC		 14698 GETBYTE ();
14699 switch (op[2] & 0x00)
14700 {
14701 case 0x00:
a117b0a5 14702 goto op_semantics_117;
c7927a3c
NC		 14703 break;
14704 }
14705 break;
a117b0a5 14706 case 0xc9:
c7927a3c
NC		 14707 GETBYTE ();
14708 switch (op[2] & 0x00)
14709 {
14710 case 0x00:
a117b0a5 14711 goto op_semantics_117;
c7927a3c
NC		 14712 break;
14713 }
14714 break;
a117b0a5 14715 case 0xca:
c7927a3c
NC		 14716 GETBYTE ();
14717 switch (op[2] & 0x00)
14718 {
14719 case 0x00:
a117b0a5 14720 goto op_semantics_117;
c7927a3c
NC		 14721 break;
14722 }
14723 break;
a117b0a5 14724 case 0xcb:
c7927a3c
NC		 14725 GETBYTE ();
14726 switch (op[2] & 0x00)
14727 {
14728 case 0x00:
a117b0a5 14729 goto op_semantics_117;
c7927a3c
NC		 14730 break;
14731 }
14732 break;
a117b0a5 14733 case 0xcc:
c7927a3c
NC		 14734 GETBYTE ();
14735 switch (op[2] & 0x00)
14736 {
14737 case 0x00:
a117b0a5 14738 goto op_semantics_117;
c7927a3c
NC		 14739 break;
14740 }
14741 break;
a117b0a5 14742 case 0xcd:
c7927a3c
NC		 14743 GETBYTE ();
14744 switch (op[2] & 0x00)
14745 {
14746 case 0x00:
a117b0a5 14747 goto op_semantics_117;
c7927a3c
NC		 14748 break;
14749 }
14750 break;
a117b0a5 14751 case 0xce:
c7927a3c
NC		 14752 GETBYTE ();
14753 switch (op[2] & 0x00)
14754 {
14755 case 0x00:
a117b0a5 14756 goto op_semantics_117;
c7927a3c
NC		 14757 break;
14758 }
14759 break;
a117b0a5 14760 case 0xcf:
c7927a3c
NC		 14761 GETBYTE ();
14762 switch (op[2] & 0x00)
14763 {
14764 case 0x00:
a117b0a5 14765 goto op_semantics_117;
c7927a3c
NC		 14766 break;
14767 }
14768 break;
a117b0a5 14769 case 0xd0:
c7927a3c
NC		 14770 GETBYTE ();
14771 switch (op[2] & 0x00)
14772 {
14773 case 0x00:
a117b0a5 14774 goto op_semantics_117;
c7927a3c
NC		 14775 break;
14776 }
14777 break;
a117b0a5 14778 case 0xd1:
c7927a3c
NC		 14779 GETBYTE ();
14780 switch (op[2] & 0x00)
14781 {
14782 case 0x00:
a117b0a5 14783 goto op_semantics_117;
c7927a3c
NC		 14784 break;
14785 }
14786 break;
a117b0a5 14787 case 0xd2:
c7927a3c
NC		 14788 GETBYTE ();
14789 switch (op[2] & 0x00)
14790 {
14791 case 0x00:
a117b0a5 14792 goto op_semantics_117;
c7927a3c
NC		 14793 break;
14794 }
14795 break;
a117b0a5 14796 case 0xd3:
c7927a3c
NC		 14797 GETBYTE ();
14798 switch (op[2] & 0x00)
14799 {
14800 case 0x00:
a117b0a5 14801 goto op_semantics_117;
c7927a3c
NC		 14802 break;
14803 }
14804 break;
a117b0a5 14805 case 0xd4:
c7927a3c
NC		 14806 GETBYTE ();
14807 switch (op[2] & 0x00)
14808 {
14809 case 0x00:
a117b0a5 14810 goto op_semantics_117;
c7927a3c
NC		 14811 break;
14812 }
14813 break;
a117b0a5 14814 case 0xd5:
c7927a3c
NC		 14815 GETBYTE ();
14816 switch (op[2] & 0x00)
14817 {
14818 case 0x00:
a117b0a5 14819 goto op_semantics_117;
c7927a3c
NC		 14820 break;
14821 }
14822 break;
a117b0a5 14823 case 0xd6:
c7927a3c
NC		 14824 GETBYTE ();
14825 switch (op[2] & 0x00)
14826 {
14827 case 0x00:
a117b0a5 14828 goto op_semantics_117;
c7927a3c
NC		 14829 break;
14830 }
14831 break;
a117b0a5 14832 case 0xd7:
c7927a3c
NC		 14833 GETBYTE ();
14834 switch (op[2] & 0x00)
14835 {
14836 case 0x00:
a117b0a5 14837 goto op_semantics_117;
c7927a3c
NC		 14838 break;
14839 }
14840 break;
a117b0a5 14841 case 0xd8:
c7927a3c
NC		 14842 GETBYTE ();
14843 switch (op[2] & 0x00)
14844 {
14845 case 0x00:
a117b0a5 14846 goto op_semantics_117;
c7927a3c
NC		 14847 break;
14848 }
14849 break;
a117b0a5 14850 case 0xd9:
c7927a3c
NC		 14851 GETBYTE ();
14852 switch (op[2] & 0x00)
14853 {
14854 case 0x00:
a117b0a5 14855 goto op_semantics_117;
c7927a3c
NC		 14856 break;
14857 }
14858 break;
a117b0a5 14859 case 0xda:
c7927a3c
NC		 14860 GETBYTE ();
14861 switch (op[2] & 0x00)
14862 {
14863 case 0x00:
a117b0a5 14864 goto op_semantics_117;
c7927a3c
NC		 14865 break;
14866 }
14867 break;
a117b0a5 14868 case 0xdb:
c7927a3c
NC		 14869 GETBYTE ();
14870 switch (op[2] & 0x00)
14871 {
14872 case 0x00:
a117b0a5 14873 goto op_semantics_117;
c7927a3c
NC		 14874 break;
14875 }
14876 break;
a117b0a5 14877 case 0xdc:
c7927a3c
NC		 14878 GETBYTE ();
14879 switch (op[2] & 0x00)
14880 {
14881 case 0x00:
a117b0a5 14882 goto op_semantics_117;
c7927a3c
NC		 14883 break;
14884 }
14885 break;
a117b0a5 14886 case 0xdd:
c7927a3c
NC		 14887 GETBYTE ();
14888 switch (op[2] & 0x00)
14889 {
14890 case 0x00:
a117b0a5 14891 goto op_semantics_117;
c7927a3c
NC		 14892 break;
14893 }
14894 break;
a117b0a5 14895 case 0xde:
c7927a3c
NC		 14896 GETBYTE ();
14897 switch (op[2] & 0x00)
14898 {
14899 case 0x00:
a117b0a5 14900 goto op_semantics_117;
c7927a3c
NC		 14901 break;
14902 }
14903 break;
a117b0a5 14904 case 0xdf:
c7927a3c
NC		 14905 GETBYTE ();
14906 switch (op[2] & 0x00)
14907 {
14908 case 0x00:
a117b0a5 14909 goto op_semantics_117;
c7927a3c
NC		 14910 break;
14911 }
14912 break;
a117b0a5 14913 case 0xe0:
c7927a3c
NC		 14914 GETBYTE ();
14915 switch (op[2] & 0x00)
14916 {
14917 case 0x00:
a117b0a5 14918 goto op_semantics_117;
c7927a3c
NC		 14919 break;
14920 }
14921 break;
a117b0a5 14922 case 0xe1:
c7927a3c
NC		 14923 GETBYTE ();
14924 switch (op[2] & 0x00)
14925 {
14926 case 0x00:
a117b0a5 14927 goto op_semantics_117;
c7927a3c
NC		 14928 break;
14929 }
14930 break;
a117b0a5 14931 case 0xe2:
c7927a3c
NC		 14932 GETBYTE ();
14933 switch (op[2] & 0x00)
14934 {
14935 case 0x00:
a117b0a5 14936 goto op_semantics_117;
c7927a3c
NC		 14937 break;
14938 }
14939 break;
a117b0a5 14940 case 0xe3:
c7927a3c
NC		 14941 GETBYTE ();
14942 switch (op[2] & 0x00)
14943 {
14944 case 0x00:
a117b0a5 14945 goto op_semantics_117;
c7927a3c
NC		 14946 break;
14947 }
14948 break;
a117b0a5 14949 case 0xe4:
c7927a3c
NC		 14950 GETBYTE ();
14951 switch (op[2] & 0x00)
14952 {
14953 case 0x00:
a117b0a5 14954 goto op_semantics_117;
c7927a3c
NC		 14955 break;
14956 }
14957 break;
a117b0a5 14958 case 0xe5:
c7927a3c
NC		 14959 GETBYTE ();
14960 switch (op[2] & 0x00)
14961 {
14962 case 0x00:
a117b0a5 14963 goto op_semantics_117;
c7927a3c
NC		 14964 break;
14965 }
14966 break;
a117b0a5 14967 case 0xe6:
c7927a3c
NC		 14968 GETBYTE ();
14969 switch (op[2] & 0x00)
14970 {
14971 case 0x00:
a117b0a5 14972 goto op_semantics_117;
c7927a3c
NC		 14973 break;
14974 }
14975 break;
a117b0a5 14976 case 0xe7:
c7927a3c
NC		 14977 GETBYTE ();
14978 switch (op[2] & 0x00)
14979 {
14980 case 0x00:
a117b0a5 14981 goto op_semantics_117;
c7927a3c
NC		 14982 break;
14983 }
14984 break;
a117b0a5 14985 case 0xe8:
c7927a3c
NC		 14986 GETBYTE ();
14987 switch (op[2] & 0x00)
14988 {
14989 case 0x00:
a117b0a5 14990 goto op_semantics_117;
c7927a3c
NC		 14991 break;
14992 }
14993 break;
a117b0a5 14994 case 0xe9:
c7927a3c
NC		 14995 GETBYTE ();
14996 switch (op[2] & 0x00)
14997 {
14998 case 0x00:
a117b0a5 14999 goto op_semantics_117;
c7927a3c
NC		 15000 break;
15001 }
15002 break;
a117b0a5 15003 case 0xea:
c7927a3c
NC		 15004 GETBYTE ();
15005 switch (op[2] & 0x00)
15006 {
15007 case 0x00:
a117b0a5 15008 goto op_semantics_117;
c7927a3c
NC		 15009 break;
15010 }
15011 break;
a117b0a5 15012 case 0xeb:
c7927a3c
NC		 15013 GETBYTE ();
15014 switch (op[2] & 0x00)
15015 {
15016 case 0x00:
a117b0a5 15017 goto op_semantics_117;
c7927a3c
NC		 15018 break;
15019 }
15020 break;
a117b0a5 15021 case 0xec:
c7927a3c
NC		 15022 GETBYTE ();
15023 switch (op[2] & 0x00)
15024 {
15025 case 0x00:
a117b0a5 15026 goto op_semantics_117;
c7927a3c
NC		 15027 break;
15028 }
15029 break;
a117b0a5 15030 case 0xed:
c7927a3c
NC		 15031 GETBYTE ();
15032 switch (op[2] & 0x00)
15033 {
15034 case 0x00:
a117b0a5 15035 goto op_semantics_117;
c7927a3c
NC		 15036 break;
15037 }
15038 break;
a117b0a5 15039 case 0xee:
c7927a3c
NC		 15040 GETBYTE ();
15041 switch (op[2] & 0x00)
15042 {
15043 case 0x00:
a117b0a5 15044 goto op_semantics_117;
c7927a3c
NC		 15045 break;
15046 }
15047 break;
a117b0a5 15048 case 0xef:
c7927a3c
NC		 15049 GETBYTE ();
15050 switch (op[2] & 0x00)
15051 {
15052 case 0x00:
a117b0a5 15053 goto op_semantics_117;
c7927a3c
NC		 15054 break;
15055 }
15056 break;
a117b0a5
YS		 15057 default: UNSUPPORTED(); break;
15058 }
15059 break;
15060 case 0xff:
15061 GETBYTE ();
15062 switch (op[1] & 0xff)
15063 {
15064 case 0x00:
c7927a3c
NC		 15065 GETBYTE ();
15066 switch (op[2] & 0x00)
15067 {
15068 case 0x00:
a117b0a5 15069 op_semantics_118:
c7927a3c 15070 {
a117b0a5
YS		 15071 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
15072#line 545 "rx-decode.opc"
15073 int rdst AU = op[1] & 0x0f;
15074#line 545 "rx-decode.opc"
15075 int srca AU = (op[2] >> 4) & 0x0f;
15076#line 545 "rx-decode.opc"
15077 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 15078 if (trace)
15079 {
15080 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5
YS		 15081 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
15082 op[0], op[1], op[2]);
15083 printf (" rdst = 0x%x,", rdst);
15084 printf (" srca = 0x%x,", srca);
15085 printf (" srcb = 0x%x\n", srcb);
c7927a3c 15086 }
a117b0a5
YS		 15087 SYNTAX("sub %2, %1, %0");
15088#line 545 "rx-decode.opc"
15089 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15090
15091 /*----------------------------------------------------------------------*/
15092 /* SBB */
43e65147 15093
c7927a3c
NC		 15094 }
15095 break;
15096 }
15097 break;
a117b0a5 15098 case 0x01:
c7927a3c
NC		 15099 GETBYTE ();
15100 switch (op[2] & 0x00)
15101 {
15102 case 0x00:
a117b0a5 15103 goto op_semantics_118;
c7927a3c
NC		 15104 break;
15105 }
15106 break;
a117b0a5 15107 case 0x02:
c7927a3c
NC		 15108 GETBYTE ();
15109 switch (op[2] & 0x00)
15110 {
15111 case 0x00:
a117b0a5 15112 goto op_semantics_118;
c7927a3c
NC		 15113 break;
15114 }
15115 break;
a117b0a5 15116 case 0x03:
c7927a3c
NC		 15117 GETBYTE ();
15118 switch (op[2] & 0x00)
15119 {
15120 case 0x00:
a117b0a5 15121 goto op_semantics_118;
c7927a3c
NC		 15122 break;
15123 }
15124 break;
a117b0a5 15125 case 0x04:
c7927a3c
NC		 15126 GETBYTE ();
15127 switch (op[2] & 0x00)
15128 {
15129 case 0x00:
a117b0a5 15130 goto op_semantics_118;
c7927a3c
NC		 15131 break;
15132 }
15133 break;
a117b0a5 15134 case 0x05:
c7927a3c
NC		 15135 GETBYTE ();
15136 switch (op[2] & 0x00)
15137 {
15138 case 0x00:
a117b0a5 15139 goto op_semantics_118;
c7927a3c
NC		 15140 break;
15141 }
15142 break;
a117b0a5 15143 case 0x06:
c7927a3c
NC		 15144 GETBYTE ();
15145 switch (op[2] & 0x00)
15146 {
15147 case 0x00:
a117b0a5 15148 goto op_semantics_118;
c7927a3c
NC		 15149 break;
15150 }
15151 break;
a117b0a5 15152 case 0x07:
c7927a3c
NC		 15153 GETBYTE ();
15154 switch (op[2] & 0x00)
15155 {
15156 case 0x00:
a117b0a5 15157 goto op_semantics_118;
c7927a3c
NC		 15158 break;
15159 }
15160 break;
a117b0a5 15161 case 0x08:
c7927a3c
NC		 15162 GETBYTE ();
15163 switch (op[2] & 0x00)
15164 {
15165 case 0x00:
a117b0a5 15166 goto op_semantics_118;
c7927a3c
NC		 15167 break;
15168 }
15169 break;
a117b0a5 15170 case 0x09:
c7927a3c
NC		 15171 GETBYTE ();
15172 switch (op[2] & 0x00)
15173 {
15174 case 0x00:
a117b0a5 15175 goto op_semantics_118;
c7927a3c
NC		 15176 break;
15177 }
15178 break;
a117b0a5 15179 case 0x0a:
c7927a3c
NC		 15180 GETBYTE ();
15181 switch (op[2] & 0x00)
15182 {
15183 case 0x00:
a117b0a5 15184 goto op_semantics_118;
c7927a3c
NC		 15185 break;
15186 }
15187 break;
a117b0a5 15188 case 0x0b:
c7927a3c
NC		 15189 GETBYTE ();
15190 switch (op[2] & 0x00)
15191 {
15192 case 0x00:
a117b0a5 15193 goto op_semantics_118;
c7927a3c
NC		 15194 break;
15195 }
15196 break;
a117b0a5 15197 case 0x0c:
c7927a3c
NC		 15198 GETBYTE ();
15199 switch (op[2] & 0x00)
15200 {
15201 case 0x00:
a117b0a5 15202 goto op_semantics_118;
c7927a3c
NC		 15203 break;
15204 }
15205 break;
a117b0a5 15206 case 0x0d:
c7927a3c
NC		 15207 GETBYTE ();
15208 switch (op[2] & 0x00)
15209 {
15210 case 0x00:
a117b0a5 15211 goto op_semantics_118;
c7927a3c
NC		 15212 break;
15213 }
15214 break;
a117b0a5 15215 case 0x0e:
c7927a3c
NC		 15216 GETBYTE ();
15217 switch (op[2] & 0x00)
15218 {
15219 case 0x00:
a117b0a5 15220 goto op_semantics_118;
c7927a3c
NC		 15221 break;
15222 }
15223 break;
a117b0a5 15224 case 0x0f:
c7927a3c
NC		 15225 GETBYTE ();
15226 switch (op[2] & 0x00)
15227 {
15228 case 0x00:
a117b0a5 15229 goto op_semantics_118;
c7927a3c
NC		 15230 break;
15231 }
15232 break;
a117b0a5 15233 case 0x20:
c7927a3c
NC		 15234 GETBYTE ();
15235 switch (op[2] & 0x00)
15236 {
15237 case 0x00:
a117b0a5
YS		 15238 op_semantics_119:
15239 {
15240 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
15241#line 512 "rx-decode.opc"
15242 int rdst AU = op[1] & 0x0f;
15243#line 512 "rx-decode.opc"
15244 int srca AU = (op[2] >> 4) & 0x0f;
15245#line 512 "rx-decode.opc"
15246 int srcb AU = op[2] & 0x0f;
15247 if (trace)
15248 {
15249 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15250 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
15251 op[0], op[1], op[2]);
15252 printf (" rdst = 0x%x,", rdst);
15253 printf (" srca = 0x%x,", srca);
15254 printf (" srcb = 0x%x\n", srcb);
15255 }
15256 SYNTAX("add %2, %1, %0");
15257#line 512 "rx-decode.opc"
15258 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15259
15260 /*----------------------------------------------------------------------*/
15261 /* CMP */
15262
15263 }
c7927a3c
NC		 15264 break;
15265 }
15266 break;
a117b0a5 15267 case 0x21:
c7927a3c
NC		 15268 GETBYTE ();
15269 switch (op[2] & 0x00)
15270 {
15271 case 0x00:
a117b0a5 15272 goto op_semantics_119;
c7927a3c
NC		 15273 break;
15274 }
15275 break;
a117b0a5 15276 case 0x22:
c7927a3c
NC		 15277 GETBYTE ();
15278 switch (op[2] & 0x00)
15279 {
15280 case 0x00:
a117b0a5 15281 goto op_semantics_119;
c7927a3c
NC		 15282 break;
15283 }
15284 break;
a117b0a5 15285 case 0x23:
c7927a3c
NC		 15286 GETBYTE ();
15287 switch (op[2] & 0x00)
15288 {
15289 case 0x00:
a117b0a5 15290 goto op_semantics_119;
c7927a3c
NC		 15291 break;
15292 }
15293 break;
a117b0a5 15294 case 0x24:
c7927a3c
NC		 15295 GETBYTE ();
15296 switch (op[2] & 0x00)
15297 {
15298 case 0x00:
a117b0a5 15299 goto op_semantics_119;
c7927a3c
NC		 15300 break;
15301 }
15302 break;
a117b0a5 15303 case 0x25:
c7927a3c
NC		 15304 GETBYTE ();
15305 switch (op[2] & 0x00)
15306 {
15307 case 0x00:
a117b0a5 15308 goto op_semantics_119;
c7927a3c
NC		 15309 break;
15310 }
15311 break;
a117b0a5 15312 case 0x26:
c7927a3c
NC		 15313 GETBYTE ();
15314 switch (op[2] & 0x00)
15315 {
15316 case 0x00:
a117b0a5 15317 goto op_semantics_119;
c7927a3c
NC		 15318 break;
15319 }
15320 break;
a117b0a5 15321 case 0x27:
c7927a3c
NC		 15322 GETBYTE ();
15323 switch (op[2] & 0x00)
15324 {
15325 case 0x00:
a117b0a5 15326 goto op_semantics_119;
c7927a3c
NC		 15327 break;
15328 }
15329 break;
a117b0a5 15330 case 0x28:
c7927a3c
NC		 15331 GETBYTE ();
15332 switch (op[2] & 0x00)
15333 {
15334 case 0x00:
a117b0a5 15335 goto op_semantics_119;
c7927a3c
NC		 15336 break;
15337 }
15338 break;
a117b0a5 15339 case 0x29:
c7927a3c
NC		 15340 GETBYTE ();
15341 switch (op[2] & 0x00)
15342 {
15343 case 0x00:
a117b0a5 15344 goto op_semantics_119;
c7927a3c
NC		 15345 break;
15346 }
15347 break;
a117b0a5 15348 case 0x2a:
c7927a3c
NC		 15349 GETBYTE ();
15350 switch (op[2] & 0x00)
15351 {
15352 case 0x00:
a117b0a5 15353 goto op_semantics_119;
c7927a3c
NC		 15354 break;
15355 }
15356 break;
a117b0a5 15357 case 0x2b:
c7927a3c
NC		 15358 GETBYTE ();
15359 switch (op[2] & 0x00)
15360 {
15361 case 0x00:
a117b0a5 15362 goto op_semantics_119;
c7927a3c
NC		 15363 break;
15364 }
15365 break;
a117b0a5 15366 case 0x2c:
c7927a3c
NC		 15367 GETBYTE ();
15368 switch (op[2] & 0x00)
15369 {
15370 case 0x00:
a117b0a5 15371 goto op_semantics_119;
c7927a3c
NC		 15372 break;
15373 }
15374 break;
a117b0a5 15375 case 0x2d:
c7927a3c
NC		 15376 GETBYTE ();
15377 switch (op[2] & 0x00)
15378 {
15379 case 0x00:
a117b0a5 15380 goto op_semantics_119;
c7927a3c
NC		 15381 break;
15382 }
15383 break;
a117b0a5 15384 case 0x2e:
c7927a3c
NC		 15385 GETBYTE ();
15386 switch (op[2] & 0x00)
15387 {
15388 case 0x00:
a117b0a5 15389 goto op_semantics_119;
c7927a3c
NC		 15390 break;
15391 }
15392 break;
a117b0a5 15393 case 0x2f:
c7927a3c
NC		 15394 GETBYTE ();
15395 switch (op[2] & 0x00)
15396 {
15397 case 0x00:
a117b0a5 15398 goto op_semantics_119;
c7927a3c
NC		 15399 break;
15400 }
15401 break;
a117b0a5 15402 case 0x30:
c7927a3c
NC		 15403 GETBYTE ();
15404 switch (op[2] & 0x00)
15405 {
15406 case 0x00:
a117b0a5
YS		 15407 op_semantics_120:
15408 {
15409 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
15410#line 652 "rx-decode.opc"
15411 int rdst AU = op[1] & 0x0f;
15412#line 652 "rx-decode.opc"
15413 int srca AU = (op[2] >> 4) & 0x0f;
15414#line 652 "rx-decode.opc"
15415 int srcb AU = op[2] & 0x0f;
15416 if (trace)
15417 {
15418 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15419 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
15420 op[0], op[1], op[2]);
15421 printf (" rdst = 0x%x,", rdst);
15422 printf (" srca = 0x%x,", srca);
15423 printf (" srcb = 0x%x\n", srcb);
15424 }
15425 SYNTAX("mul %2, %1, %0");
15426#line 652 "rx-decode.opc"
15427 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15428
15429 /*----------------------------------------------------------------------*/
15430 /* EMUL */
15431
15432 }
c7927a3c
NC		 15433 break;
15434 }
15435 break;
a117b0a5 15436 case 0x31:
c7927a3c
NC		 15437 GETBYTE ();
15438 switch (op[2] & 0x00)
15439 {
15440 case 0x00:
a117b0a5 15441 goto op_semantics_120;
c7927a3c
NC		 15442 break;
15443 }
15444 break;
a117b0a5 15445 case 0x32:
c7927a3c
NC		 15446 GETBYTE ();
15447 switch (op[2] & 0x00)
15448 {
15449 case 0x00:
a117b0a5 15450 goto op_semantics_120;
c7927a3c
NC		 15451 break;
15452 }
15453 break;
a117b0a5 15454 case 0x33:
c7927a3c
NC		 15455 GETBYTE ();
15456 switch (op[2] & 0x00)
15457 {
15458 case 0x00:
a117b0a5 15459 goto op_semantics_120;
c7927a3c
NC		 15460 break;
15461 }
15462 break;
a117b0a5 15463 case 0x34:
c7927a3c
NC		 15464 GETBYTE ();
15465 switch (op[2] & 0x00)
15466 {
15467 case 0x00:
a117b0a5 15468 goto op_semantics_120;
c7927a3c
NC		 15469 break;
15470 }
15471 break;
a117b0a5 15472 case 0x35:
c7927a3c
NC		 15473 GETBYTE ();
15474 switch (op[2] & 0x00)
15475 {
15476 case 0x00:
a117b0a5 15477 goto op_semantics_120;
c7927a3c
NC		 15478 break;
15479 }
15480 break;
a117b0a5 15481 case 0x36:
c7927a3c
NC		 15482 GETBYTE ();
15483 switch (op[2] & 0x00)
15484 {
15485 case 0x00:
a117b0a5 15486 goto op_semantics_120;
c7927a3c
NC		 15487 break;
15488 }
15489 break;
a117b0a5 15490 case 0x37:
c7927a3c
NC		 15491 GETBYTE ();
15492 switch (op[2] & 0x00)
15493 {
15494 case 0x00:
a117b0a5 15495 goto op_semantics_120;
c7927a3c
NC		 15496 break;
15497 }
15498 break;
a117b0a5 15499 case 0x38:
c7927a3c
NC		 15500 GETBYTE ();
15501 switch (op[2] & 0x00)
15502 {
15503 case 0x00:
a117b0a5 15504 goto op_semantics_120;
c7927a3c
NC		 15505 break;
15506 }
15507 break;
a117b0a5 15508 case 0x39:
c7927a3c
NC		 15509 GETBYTE ();
15510 switch (op[2] & 0x00)
15511 {
15512 case 0x00:
a117b0a5 15513 goto op_semantics_120;
c7927a3c
NC		 15514 break;
15515 }
15516 break;
a117b0a5 15517 case 0x3a:
c7927a3c
NC		 15518 GETBYTE ();
15519 switch (op[2] & 0x00)
15520 {
15521 case 0x00:
a117b0a5 15522 goto op_semantics_120;
c7927a3c
NC		 15523 break;
15524 }
15525 break;
a117b0a5 15526 case 0x3b:
c7927a3c
NC		 15527 GETBYTE ();
15528 switch (op[2] & 0x00)
15529 {
15530 case 0x00:
a117b0a5 15531 goto op_semantics_120;
c7927a3c
NC		 15532 break;
15533 }
15534 break;
a117b0a5 15535 case 0x3c:
c7927a3c
NC		 15536 GETBYTE ();
15537 switch (op[2] & 0x00)
15538 {
15539 case 0x00:
a117b0a5 15540 goto op_semantics_120;
c7927a3c
NC		 15541 break;
15542 }
15543 break;
a117b0a5 15544 case 0x3d:
c7927a3c
NC		 15545 GETBYTE ();
15546 switch (op[2] & 0x00)
15547 {
15548 case 0x00:
a117b0a5 15549 goto op_semantics_120;
c7927a3c
NC		 15550 break;
15551 }
15552 break;
a117b0a5 15553 case 0x3e:
c7927a3c
NC		 15554 GETBYTE ();
15555 switch (op[2] & 0x00)
15556 {
15557 case 0x00:
a117b0a5 15558 goto op_semantics_120;
c7927a3c
NC		 15559 break;
15560 }
15561 break;
a117b0a5 15562 case 0x3f:
c7927a3c
NC		 15563 GETBYTE ();
15564 switch (op[2] & 0x00)
15565 {
15566 case 0x00:
a117b0a5 15567 goto op_semantics_120;
c7927a3c
NC		 15568 break;
15569 }
15570 break;
a117b0a5 15571 case 0x40:
c7927a3c
NC		 15572 GETBYTE ();
15573 switch (op[2] & 0x00)
15574 {
15575 case 0x00:
a117b0a5 15576 op_semantics_121:
c7927a3c 15577 {
a117b0a5
YS		 15578 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
15579#line 422 "rx-decode.opc"
c7927a3c 15580 int rdst AU = op[1] & 0x0f;
a117b0a5 15581#line 422 "rx-decode.opc"
c7927a3c 15582 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 15583#line 422 "rx-decode.opc"
c7927a3c
NC		 15584 int srcb AU = op[2] & 0x0f;
15585 if (trace)
15586 {
15587 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 15588 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
c7927a3c
NC		 15589 op[0], op[1], op[2]);
15590 printf (" rdst = 0x%x,", rdst);
15591 printf (" srca = 0x%x,", srca);
15592 printf (" srcb = 0x%x\n", srcb);
15593 }
a117b0a5
YS		 15594 SYNTAX("and %2, %1, %0");
15595#line 422 "rx-decode.opc"
15596 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 15597
c7927a3c 15598 /*----------------------------------------------------------------------*/
a117b0a5 15599 /* OR */
43e65147 15600
c7927a3c
NC		 15601 }
15602 break;
15603 }
15604 break;
a117b0a5 15605 case 0x41:
c7927a3c
NC		 15606 GETBYTE ();
15607 switch (op[2] & 0x00)
15608 {
15609 case 0x00:
a117b0a5 15610 goto op_semantics_121;
c7927a3c
NC		 15611 break;
15612 }
15613 break;
a117b0a5 15614 case 0x42:
c7927a3c
NC		 15615 GETBYTE ();
15616 switch (op[2] & 0x00)
15617 {
15618 case 0x00:
a117b0a5 15619 goto op_semantics_121;
c7927a3c
NC		 15620 break;
15621 }
15622 break;
a117b0a5 15623 case 0x43:
c7927a3c
NC		 15624 GETBYTE ();
15625 switch (op[2] & 0x00)
15626 {
15627 case 0x00:
a117b0a5 15628 goto op_semantics_121;
c7927a3c
NC		 15629 break;
15630 }
15631 break;
a117b0a5 15632 case 0x44:
c7927a3c
NC		 15633 GETBYTE ();
15634 switch (op[2] & 0x00)
15635 {
15636 case 0x00:
a117b0a5 15637 goto op_semantics_121;
c7927a3c
NC		 15638 break;
15639 }
15640 break;
a117b0a5 15641 case 0x45:
c7927a3c
NC		 15642 GETBYTE ();
15643 switch (op[2] & 0x00)
15644 {
15645 case 0x00:
a117b0a5 15646 goto op_semantics_121;
c7927a3c
NC		 15647 break;
15648 }
15649 break;
a117b0a5 15650 case 0x46:
c7927a3c
NC		 15651 GETBYTE ();
15652 switch (op[2] & 0x00)
15653 {
15654 case 0x00:
a117b0a5 15655 goto op_semantics_121;
c7927a3c
NC		 15656 break;
15657 }
15658 break;
a117b0a5 15659 case 0x47:
c7927a3c
NC		 15660 GETBYTE ();
15661 switch (op[2] & 0x00)
15662 {
15663 case 0x00:
a117b0a5 15664 goto op_semantics_121;
c7927a3c
NC		 15665 break;
15666 }
15667 break;
a117b0a5 15668 case 0x48:
c7927a3c
NC		 15669 GETBYTE ();
15670 switch (op[2] & 0x00)
15671 {
15672 case 0x00:
a117b0a5 15673 goto op_semantics_121;
c7927a3c
NC		 15674 break;
15675 }
15676 break;
a117b0a5 15677 case 0x49:
c7927a3c
NC		 15678 GETBYTE ();
15679 switch (op[2] & 0x00)
15680 {
15681 case 0x00:
a117b0a5 15682 goto op_semantics_121;
c7927a3c
NC		 15683 break;
15684 }
15685 break;
a117b0a5 15686 case 0x4a:
c7927a3c
NC		 15687 GETBYTE ();
15688 switch (op[2] & 0x00)
15689 {
15690 case 0x00:
a117b0a5 15691 goto op_semantics_121;
c7927a3c
NC		 15692 break;
15693 }
15694 break;
a117b0a5 15695 case 0x4b:
c7927a3c
NC		 15696 GETBYTE ();
15697 switch (op[2] & 0x00)
15698 {
15699 case 0x00:
a117b0a5 15700 goto op_semantics_121;
c7927a3c
NC		 15701 break;
15702 }
15703 break;
a117b0a5 15704 case 0x4c:
c7927a3c
NC		 15705 GETBYTE ();
15706 switch (op[2] & 0x00)
15707 {
15708 case 0x00:
a117b0a5 15709 goto op_semantics_121;
c7927a3c
NC		 15710 break;
15711 }
15712 break;
a117b0a5 15713 case 0x4d:
c7927a3c
NC		 15714 GETBYTE ();
15715 switch (op[2] & 0x00)
15716 {
15717 case 0x00:
a117b0a5 15718 goto op_semantics_121;
c7927a3c
NC		 15719 break;
15720 }
15721 break;
a117b0a5 15722 case 0x4e:
c7927a3c
NC		 15723 GETBYTE ();
15724 switch (op[2] & 0x00)
15725 {
15726 case 0x00:
a117b0a5 15727 goto op_semantics_121;
c7927a3c
NC		 15728 break;
15729 }
15730 break;
a117b0a5 15731 case 0x4f:
c7927a3c
NC		 15732 GETBYTE ();
15733 switch (op[2] & 0x00)
15734 {
15735 case 0x00:
a117b0a5 15736 goto op_semantics_121;
c7927a3c
NC		 15737 break;
15738 }
15739 break;
a117b0a5 15740 case 0x50:
c7927a3c
NC		 15741 GETBYTE ();
15742 switch (op[2] & 0x00)
15743 {
15744 case 0x00:
a117b0a5 15745 op_semantics_122:
c7927a3c 15746 {
a117b0a5
YS		 15747 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
15748#line 440 "rx-decode.opc"
c7927a3c 15749 int rdst AU = op[1] & 0x0f;
a117b0a5 15750#line 440 "rx-decode.opc"
c7927a3c 15751 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 15752#line 440 "rx-decode.opc"
c7927a3c
NC		 15753 int srcb AU = op[2] & 0x0f;
15754 if (trace)
15755 {
15756 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 15757 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
c7927a3c
NC		 15758 op[0], op[1], op[2]);
15759 printf (" rdst = 0x%x,", rdst);
15760 printf (" srca = 0x%x,", srca);
15761 printf (" srcb = 0x%x\n", srcb);
15762 }
a117b0a5
YS		 15763 SYNTAX("or %2, %1, %0");
15764#line 440 "rx-decode.opc"
15765 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 15766
c7927a3c 15767 /*----------------------------------------------------------------------*/
a117b0a5 15768 /* XOR */
43e65147 15769
c7927a3c
NC		 15770 }
15771 break;
15772 }
15773 break;
a117b0a5 15774 case 0x51:
c7927a3c
NC		 15775 GETBYTE ();
15776 switch (op[2] & 0x00)
15777 {
15778 case 0x00:
a117b0a5 15779 goto op_semantics_122;
c7927a3c
NC		 15780 break;
15781 }
15782 break;
a117b0a5 15783 case 0x52:
c7927a3c
NC		 15784 GETBYTE ();
15785 switch (op[2] & 0x00)
15786 {
15787 case 0x00:
a117b0a5 15788 goto op_semantics_122;
c7927a3c
NC		 15789 break;
15790 }
15791 break;
a117b0a5 15792 case 0x53:
c7927a3c
NC		 15793 GETBYTE ();
15794 switch (op[2] & 0x00)
15795 {
15796 case 0x00:
a117b0a5 15797 goto op_semantics_122;
c7927a3c
NC		 15798 break;
15799 }
15800 break;
a117b0a5 15801 case 0x54:
c7927a3c
NC		 15802 GETBYTE ();
15803 switch (op[2] & 0x00)
15804 {
15805 case 0x00:
a117b0a5 15806 goto op_semantics_122;
c7927a3c
NC		 15807 break;
15808 }
15809 break;
a117b0a5 15810 case 0x55:
c7927a3c
NC		 15811 GETBYTE ();
15812 switch (op[2] & 0x00)
15813 {
15814 case 0x00:
a117b0a5 15815 goto op_semantics_122;
c7927a3c
NC		 15816 break;
15817 }
15818 break;
a117b0a5 15819 case 0x56:
c7927a3c
NC		 15820 GETBYTE ();
15821 switch (op[2] & 0x00)
15822 {
15823 case 0x00:
a117b0a5 15824 goto op_semantics_122;
c7927a3c
NC		 15825 break;
15826 }
15827 break;
a117b0a5 15828 case 0x57:
c7927a3c
NC		 15829 GETBYTE ();
15830 switch (op[2] & 0x00)
15831 {
15832 case 0x00:
a117b0a5 15833 goto op_semantics_122;
c7927a3c
NC		 15834 break;
15835 }
15836 break;
a117b0a5 15837 case 0x58:
c7927a3c
NC		 15838 GETBYTE ();
15839 switch (op[2] & 0x00)
15840 {
15841 case 0x00:
a117b0a5 15842 goto op_semantics_122;
c7927a3c
NC		 15843 break;
15844 }
15845 break;
a117b0a5 15846 case 0x59:
c7927a3c
NC		 15847 GETBYTE ();
15848 switch (op[2] & 0x00)
15849 {
15850 case 0x00:
a117b0a5 15851 goto op_semantics_122;
c7927a3c
NC		 15852 break;
15853 }
15854 break;
a117b0a5 15855 case 0x5a:
c7927a3c
NC		 15856 GETBYTE ();
15857 switch (op[2] & 0x00)
15858 {
15859 case 0x00:
a117b0a5 15860 goto op_semantics_122;
c7927a3c
NC		 15861 break;
15862 }
15863 break;
a117b0a5 15864 case 0x5b:
c7927a3c
NC		 15865 GETBYTE ();
15866 switch (op[2] & 0x00)
15867 {
15868 case 0x00:
a117b0a5 15869 goto op_semantics_122;
c7927a3c
NC		 15870 break;
15871 }
15872 break;
a117b0a5 15873 case 0x5c:
c7927a3c
NC		 15874 GETBYTE ();
15875 switch (op[2] & 0x00)
15876 {
15877 case 0x00:
a117b0a5 15878 goto op_semantics_122;
c7927a3c
NC		 15879 break;
15880 }
15881 break;
a117b0a5 15882 case 0x5d:
c7927a3c
NC		 15883 GETBYTE ();
15884 switch (op[2] & 0x00)
15885 {
15886 case 0x00:
a117b0a5 15887 goto op_semantics_122;
c7927a3c
NC		 15888 break;
15889 }
15890 break;
a117b0a5 15891 case 0x5e:
c7927a3c
NC		 15892 GETBYTE ();
15893 switch (op[2] & 0x00)
15894 {
15895 case 0x00:
a117b0a5 15896 goto op_semantics_122;
c7927a3c
NC		 15897 break;
15898 }
15899 break;
a117b0a5 15900 case 0x5f:
c7927a3c
NC		 15901 GETBYTE ();
15902 switch (op[2] & 0x00)
15903 {
15904 case 0x00:
a117b0a5 15905 goto op_semantics_122;
c7927a3c
NC		 15906 break;
15907 }
15908 break;
a117b0a5 15909 case 0x80:
c7927a3c
NC		 15910 GETBYTE ();
15911 switch (op[2] & 0x00)
15912 {
15913 case 0x00:
a117b0a5 15914 op_semantics_123:
c7927a3c 15915 {
a117b0a5
YS		 15916 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
15917#line 1100 "rx-decode.opc"
c7927a3c 15918 int rdst AU = op[1] & 0x0f;
a117b0a5 15919#line 1100 "rx-decode.opc"
c7927a3c 15920 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 15921#line 1100 "rx-decode.opc"
c7927a3c
NC		 15922 int srcb AU = op[2] & 0x0f;
15923 if (trace)
15924 {
15925 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 15926 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
c7927a3c
NC		 15927 op[0], op[1], op[2]);
15928 printf (" rdst = 0x%x,", rdst);
15929 printf (" srca = 0x%x,", srca);
15930 printf (" srcb = 0x%x\n", srcb);
15931 }
a117b0a5
YS		 15932 SYNTAX("fsub %2, %1, %0");
15933#line 1100 "rx-decode.opc"
15934 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 15935
c7927a3c
NC		 15936 }
15937 break;
15938 }
15939 break;
a117b0a5 15940 case 0x81:
c7927a3c
NC		 15941 GETBYTE ();
15942 switch (op[2] & 0x00)
15943 {
15944 case 0x00:
a117b0a5 15945 goto op_semantics_123;
c7927a3c
NC		 15946 break;
15947 }
15948 break;
a117b0a5 15949 case 0x82:
c7927a3c
NC		 15950 GETBYTE ();
15951 switch (op[2] & 0x00)
15952 {
15953 case 0x00:
a117b0a5 15954 goto op_semantics_123;
c7927a3c
NC		 15955 break;
15956 }
15957 break;
a117b0a5 15958 case 0x83:
c7927a3c
NC		 15959 GETBYTE ();
15960 switch (op[2] & 0x00)
15961 {
15962 case 0x00:
a117b0a5 15963 goto op_semantics_123;
c7927a3c
NC		 15964 break;
15965 }
15966 break;
a117b0a5 15967 case 0x84:
c7927a3c
NC		 15968 GETBYTE ();
15969 switch (op[2] & 0x00)
15970 {
15971 case 0x00:
a117b0a5 15972 goto op_semantics_123;
c7927a3c
NC		 15973 break;
15974 }
15975 break;
a117b0a5 15976 case 0x85:
c7927a3c
NC		 15977 GETBYTE ();
15978 switch (op[2] & 0x00)
15979 {
15980 case 0x00:
a117b0a5 15981 goto op_semantics_123;
c7927a3c
NC		 15982 break;
15983 }
15984 break;
a117b0a5 15985 case 0x86:
c7927a3c
NC		 15986 GETBYTE ();
15987 switch (op[2] & 0x00)
15988 {
15989 case 0x00:
a117b0a5 15990 goto op_semantics_123;
c7927a3c
NC		 15991 break;
15992 }
15993 break;
a117b0a5 15994 case 0x87:
c7927a3c
NC		 15995 GETBYTE ();
15996 switch (op[2] & 0x00)
15997 {
15998 case 0x00:
a117b0a5 15999 goto op_semantics_123;
c7927a3c
NC		 16000 break;
16001 }
16002 break;
a117b0a5 16003 case 0x88:
c7927a3c
NC		 16004 GETBYTE ();
16005 switch (op[2] & 0x00)
16006 {
16007 case 0x00:
a117b0a5 16008 goto op_semantics_123;
c7927a3c
NC		 16009 break;
16010 }
16011 break;
a117b0a5 16012 case 0x89:
c7927a3c
NC		 16013 GETBYTE ();
16014 switch (op[2] & 0x00)
16015 {
16016 case 0x00:
a117b0a5 16017 goto op_semantics_123;
c7927a3c
NC		 16018 break;
16019 }
16020 break;
a117b0a5 16021 case 0x8a:
c7927a3c
NC		 16022 GETBYTE ();
16023 switch (op[2] & 0x00)
16024 {
16025 case 0x00:
a117b0a5 16026 goto op_semantics_123;
c7927a3c
NC		 16027 break;
16028 }
16029 break;
a117b0a5 16030 case 0x8b:
c7927a3c
NC		 16031 GETBYTE ();
16032 switch (op[2] & 0x00)
16033 {
16034 case 0x00:
a117b0a5 16035 goto op_semantics_123;
c7927a3c
NC		 16036 break;
16037 }
16038 break;
a117b0a5 16039 case 0x8c:
c7927a3c
NC		 16040 GETBYTE ();
16041 switch (op[2] & 0x00)
16042 {
16043 case 0x00:
a117b0a5 16044 goto op_semantics_123;
c7927a3c
NC		 16045 break;
16046 }
16047 break;
a117b0a5 16048 case 0x8d:
c7927a3c
NC		 16049 GETBYTE ();
16050 switch (op[2] & 0x00)
16051 {
16052 case 0x00:
a117b0a5 16053 goto op_semantics_123;
c7927a3c
NC		 16054 break;
16055 }
16056 break;
a117b0a5 16057 case 0x8e:
c7927a3c
NC		 16058 GETBYTE ();
16059 switch (op[2] & 0x00)
16060 {
16061 case 0x00:
a117b0a5 16062 goto op_semantics_123;
c7927a3c
NC		 16063 break;
16064 }
16065 break;
a117b0a5 16066 case 0x8f:
c7927a3c
NC		 16067 GETBYTE ();
16068 switch (op[2] & 0x00)
16069 {
16070 case 0x00:
a117b0a5 16071 goto op_semantics_123;
c7927a3c
NC		 16072 break;
16073 }
16074 break;
a117b0a5 16075 case 0xa0:
c7927a3c
NC		 16076 GETBYTE ();
16077 switch (op[2] & 0x00)
16078 {
16079 case 0x00:
a117b0a5 16080 op_semantics_124:
c7927a3c 16081 {
a117b0a5
YS		 16082 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
16083#line 1097 "rx-decode.opc"
c7927a3c 16084 int rdst AU = op[1] & 0x0f;
a117b0a5 16085#line 1097 "rx-decode.opc"
c7927a3c 16086 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 16087#line 1097 "rx-decode.opc"
c7927a3c
NC		 16088 int srcb AU = op[2] & 0x0f;
16089 if (trace)
16090 {
16091 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 16092 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
c7927a3c
NC		 16093 op[0], op[1], op[2]);
16094 printf (" rdst = 0x%x,", rdst);
16095 printf (" srca = 0x%x,", srca);
16096 printf (" srcb = 0x%x\n", srcb);
16097 }
a117b0a5
YS		 16098 SYNTAX("fadd %2, %1, %0");
16099#line 1097 "rx-decode.opc"
16100 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 16101
c7927a3c
NC		 16102 }
16103 break;
16104 }
16105 break;
a117b0a5 16106 case 0xa1:
c7927a3c
NC		 16107 GETBYTE ();
16108 switch (op[2] & 0x00)
16109 {
16110 case 0x00:
a117b0a5 16111 goto op_semantics_124;
c7927a3c
NC		 16112 break;
16113 }
16114 break;
a117b0a5 16115 case 0xa2:
c7927a3c
NC		 16116 GETBYTE ();
16117 switch (op[2] & 0x00)
16118 {
16119 case 0x00:
a117b0a5 16120 goto op_semantics_124;
c7927a3c
NC		 16121 break;
16122 }
16123 break;
a117b0a5 16124 case 0xa3:
c7927a3c
NC		 16125 GETBYTE ();
16126 switch (op[2] & 0x00)
16127 {
16128 case 0x00:
a117b0a5 16129 goto op_semantics_124;
c7927a3c
NC		 16130 break;
16131 }
16132 break;
a117b0a5 16133 case 0xa4:
c7927a3c
NC		 16134 GETBYTE ();
16135 switch (op[2] & 0x00)
16136 {
16137 case 0x00:
a117b0a5 16138 goto op_semantics_124;
c7927a3c
NC		 16139 break;
16140 }
16141 break;
a117b0a5 16142 case 0xa5:
c7927a3c
NC		 16143 GETBYTE ();
16144 switch (op[2] & 0x00)
16145 {
16146 case 0x00:
a117b0a5 16147 goto op_semantics_124;
c7927a3c
NC		 16148 break;
16149 }
16150 break;
a117b0a5 16151 case 0xa6:
c7927a3c
NC		 16152 GETBYTE ();
16153 switch (op[2] & 0x00)
16154 {
16155 case 0x00:
a117b0a5 16156 goto op_semantics_124;
c7927a3c
NC		 16157 break;
16158 }
16159 break;
a117b0a5 16160 case 0xa7:
c7927a3c
NC		 16161 GETBYTE ();
16162 switch (op[2] & 0x00)
16163 {
16164 case 0x00:
a117b0a5 16165 goto op_semantics_124;
c7927a3c
NC		 16166 break;
16167 }
16168 break;
a117b0a5 16169 case 0xa8:
c7927a3c
NC		 16170 GETBYTE ();
16171 switch (op[2] & 0x00)
16172 {
16173 case 0x00:
a117b0a5 16174 goto op_semantics_124;
c7927a3c
NC		 16175 break;
16176 }
16177 break;
a117b0a5 16178 case 0xa9:
c7927a3c
NC		 16179 GETBYTE ();
16180 switch (op[2] & 0x00)
16181 {
16182 case 0x00:
a117b0a5 16183 goto op_semantics_124;
c7927a3c
NC		 16184 break;
16185 }
16186 break;
a117b0a5 16187 case 0xaa:
c7927a3c
NC		 16188 GETBYTE ();
16189 switch (op[2] & 0x00)
16190 {
16191 case 0x00:
a117b0a5 16192 goto op_semantics_124;
c7927a3c
NC		 16193 break;
16194 }
16195 break;
a117b0a5 16196 case 0xab:
c7927a3c
NC		 16197 GETBYTE ();
16198 switch (op[2] & 0x00)
16199 {
16200 case 0x00:
a117b0a5 16201 goto op_semantics_124;
c7927a3c
NC		 16202 break;
16203 }
16204 break;
a117b0a5 16205 case 0xac:
c7927a3c
NC		 16206 GETBYTE ();
16207 switch (op[2] & 0x00)
16208 {
16209 case 0x00:
a117b0a5 16210 goto op_semantics_124;
c7927a3c
NC		 16211 break;
16212 }
16213 break;
a117b0a5 16214 case 0xad:
c7927a3c
NC		 16215 GETBYTE ();
16216 switch (op[2] & 0x00)
16217 {
16218 case 0x00:
a117b0a5 16219 goto op_semantics_124;
c7927a3c
NC		 16220 break;
16221 }
16222 break;
a117b0a5 16223 case 0xae:
c7927a3c
NC		 16224 GETBYTE ();
16225 switch (op[2] & 0x00)
16226 {
16227 case 0x00:
a117b0a5 16228 goto op_semantics_124;
c7927a3c
NC		 16229 break;
16230 }
16231 break;
a117b0a5 16232 case 0xaf:
c7927a3c
NC		 16233 GETBYTE ();
16234 switch (op[2] & 0x00)
16235 {
16236 case 0x00:
a117b0a5 16237 goto op_semantics_124;
c7927a3c
NC		 16238 break;
16239 }
16240 break;
a117b0a5 16241 case 0xb0:
c7927a3c
NC		 16242 GETBYTE ();
16243 switch (op[2] & 0x00)
16244 {
16245 case 0x00:
a117b0a5 16246 op_semantics_125:
c7927a3c 16247 {
a117b0a5
YS		 16248 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
16249#line 1103 "rx-decode.opc"
c7927a3c 16250 int rdst AU = op[1] & 0x0f;
a117b0a5 16251#line 1103 "rx-decode.opc"
c7927a3c 16252 int srca AU = (op[2] >> 4) & 0x0f;
a117b0a5 16253#line 1103 "rx-decode.opc"
c7927a3c
NC		 16254 int srcb AU = op[2] & 0x0f;
16255 if (trace)
16256 {
16257 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 16258 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
c7927a3c
NC		 16259 op[0], op[1], op[2]);
16260 printf (" rdst = 0x%x,", rdst);
16261 printf (" srca = 0x%x,", srca);
16262 printf (" srcb = 0x%x\n", srcb);
16263 }
a117b0a5
YS		 16264 SYNTAX("fmul %2, %1, %0");
16265#line 1103 "rx-decode.opc"
16266 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 16267
c7927a3c
NC		 16268 }
16269 break;
16270 }
16271 break;
a117b0a5 16272 case 0xb1:
c7927a3c
NC		 16273 GETBYTE ();
16274 switch (op[2] & 0x00)
16275 {
16276 case 0x00:
a117b0a5 16277 goto op_semantics_125;
c7927a3c
NC		 16278 break;
16279 }
16280 break;
a117b0a5 16281 case 0xb2:
c7927a3c
NC		 16282 GETBYTE ();
16283 switch (op[2] & 0x00)
16284 {
16285 case 0x00:
a117b0a5 16286 goto op_semantics_125;
c7927a3c
NC		 16287 break;
16288 }
16289 break;
a117b0a5 16290 case 0xb3:
c7927a3c
NC		 16291 GETBYTE ();
16292 switch (op[2] & 0x00)
16293 {
16294 case 0x00:
a117b0a5 16295 goto op_semantics_125;
c7927a3c
NC		 16296 break;
16297 }
16298 break;
a117b0a5 16299 case 0xb4:
c7927a3c
NC		 16300 GETBYTE ();
16301 switch (op[2] & 0x00)
16302 {
16303 case 0x00:
a117b0a5 16304 goto op_semantics_125;
c7927a3c
NC		 16305 break;
16306 }
16307 break;
a117b0a5 16308 case 0xb5:
c7927a3c
NC		 16309 GETBYTE ();
16310 switch (op[2] & 0x00)
16311 {
16312 case 0x00:
a117b0a5 16313 goto op_semantics_125;
c7927a3c
NC		 16314 break;
16315 }
16316 break;
a117b0a5 16317 case 0xb6:
c7927a3c
NC		 16318 GETBYTE ();
16319 switch (op[2] & 0x00)
16320 {
16321 case 0x00:
a117b0a5 16322 goto op_semantics_125;
c7927a3c
NC		 16323 break;
16324 }
16325 break;
a117b0a5 16326 case 0xb7:
c7927a3c
NC		 16327 GETBYTE ();
16328 switch (op[2] & 0x00)
16329 {
16330 case 0x00:
a117b0a5 16331 goto op_semantics_125;
c7927a3c
NC		 16332 break;
16333 }
16334 break;
a117b0a5 16335 case 0xb8:
c7927a3c
NC		 16336 GETBYTE ();
16337 switch (op[2] & 0x00)
16338 {
16339 case 0x00:
a117b0a5 16340 goto op_semantics_125;
c7927a3c
NC		 16341 break;
16342 }
16343 break;
a117b0a5 16344 case 0xb9:
c7927a3c
NC		 16345 GETBYTE ();
16346 switch (op[2] & 0x00)
16347 {
16348 case 0x00:
a117b0a5 16349 goto op_semantics_125;
c7927a3c
NC		 16350 break;
16351 }
16352 break;
a117b0a5 16353 case 0xba:
c7927a3c
NC		 16354 GETBYTE ();
16355 switch (op[2] & 0x00)
16356 {
16357 case 0x00:
a117b0a5 16358 goto op_semantics_125;
c7927a3c
NC		 16359 break;
16360 }
16361 break;
a117b0a5 16362 case 0xbb:
c7927a3c
NC		 16363 GETBYTE ();
16364 switch (op[2] & 0x00)
16365 {
16366 case 0x00:
a117b0a5 16367 goto op_semantics_125;
c7927a3c
NC		 16368 break;
16369 }
16370 break;
a117b0a5 16371 case 0xbc:
c7927a3c
NC		 16372 GETBYTE ();
16373 switch (op[2] & 0x00)
16374 {
16375 case 0x00:
a117b0a5 16376 goto op_semantics_125;
c7927a3c
NC		 16377 break;
16378 }
16379 break;
a117b0a5 16380 case 0xbd:
c7927a3c
NC		 16381 GETBYTE ();
16382 switch (op[2] & 0x00)
16383 {
16384 case 0x00:
a117b0a5 16385 goto op_semantics_125;
c7927a3c
NC		 16386 break;
16387 }
16388 break;
a117b0a5 16389 case 0xbe:
c7927a3c
NC		 16390 GETBYTE ();
16391 switch (op[2] & 0x00)
16392 {
16393 case 0x00:
a117b0a5 16394 goto op_semantics_125;
c7927a3c
NC		 16395 break;
16396 }
16397 break;
a117b0a5 16398 case 0xbf:
c7927a3c
NC		 16399 GETBYTE ();
16400 switch (op[2] & 0x00)
16401 {
16402 case 0x00:
a117b0a5 16403 goto op_semantics_125;
c7927a3c
NC		 16404 break;
16405 }
16406 break;
16407 default: UNSUPPORTED(); break;
16408 }
16409 break;
16410 default: UNSUPPORTED(); break;
16411 }
a117b0a5 16412#line 1118 "rx-decode.opc"
c7927a3c
NC		 16413
16414 return rx->n_bytes;
16415}
GDB Binutils - Deliverables
This page took 1.601178 seconds and 4 git commands to generate.