projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ubsan: m32r: left shift of negative value
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
CommitLineData
a6743a54 1/* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
f282425e 2#line 1 "rx-decode.opc"
c7927a3c 3/* -*- c -*- */
b3adc24a 4/* Copyright (C) 2012-2020 Free Software Foundation, Inc.
5bf135a7
NC		 5 Contributed by Red Hat.
6 Written by DJ Delorie.
7
8 This file is part of the GNU opcodes library.
9
10 This library is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
14
15 It is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
18 License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
24
df7b86aa 25#include "sysdep.h"
c7927a3c
NC		 26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
c7927a3c
NC		 29#include "ansidecl.h"
30#include "opcode/rx.h"
db5fa770 31#include "libiberty.h"
c7927a3c
NC		 32
33#define RX_OPCODE_BIG_ENDIAN 0
34
35typedef struct
36{
37 RX_Opcode_Decoded * rx;
38 int (* getbyte)(void *);
39 void * ptr;
40 unsigned char * op;
41} LocalData;
42
43static int trace = 0;
44
45#define BSIZE 0
46#define WSIZE 1
47#define LSIZE 2
4ce8c66d 48#define DSIZE 3
c7927a3c
NC		 49
50/* These are for when the upper bits are "don't care" or "undefined". */
db5fa770 51static int bwl[4] =
c7927a3c
NC		 52{
53 RX_Byte,
54 RX_Word,
b8985e5c 55 RX_Long,
f04265ec 56 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 57};
58
db5fa770 59static int sbwl[4] =
c7927a3c
NC		 60{
61 RX_SByte,
62 RX_SWord,
b8985e5c 63 RX_Long,
f04265ec 64 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 65};
66
db5fa770 67static int ubw[4] =
c7927a3c
NC		 68{
69 RX_UByte,
70 RX_UWord,
f04265ec
NC		 71 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
72 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 73};
74
db5fa770 75static int memex[4] =
c7927a3c
NC		 76{
77 RX_SByte,
78 RX_SWord,
79 RX_Long,
80 RX_UWord
81};
82
4ce8c66d
YS		 83static int _ld[2] =
84{
85 RX_Long,
86 RX_Double
87};
88
c7927a3c
NC		 89#define ID(x) rx->id = RXO_##x
90#define OP(n,t,r,a) (rx->op[n].type = t, \
91 rx->op[n].reg = r, \
92 rx->op[n].addend = a )
93#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
94 rx->op[n].size = s )
95
96/* This is for the BWL and BW bitfields. */
b8985e5c 97static int SCALE[] = { 1, 2, 4, 0 };
c7927a3c 98/* This is for the prefix size enum. */
4ce8c66d 99static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4, 8 };
c7927a3c 100
db5fa770
NC		 101#define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
102#define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
103
c7927a3c
NC		 104static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
105 16, 17, 0, 0, 0, 0, 0, 0 };
106
107static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
108
109/*
110 *C a constant (immediate) c
111 *R A register
112 *I Register indirect, no offset
113 *Is Register indirect, with offset
114 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
115 *P standard displacement: type (r,[r]), reg, assumes UByte
116 *Pm memex displacement: type (r,[r]), reg, memex code
117 *cc condition code. */
118
119#define DC(c) OP (0, RX_Operand_Immediate, 0, c)
120#define DR(r) OP (0, RX_Operand_Register, r, 0)
121#define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
db5fa770 122#define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
c7927a3c
NC		 123#define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
124#define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
4ce8c66d
YS		 125#define DCR(r) OP (0, RX_Operand_DoubleCReg, r, 0)
126#define DDR(r) OP (0, RX_Operand_DoubleReg, r, 0)
127#define DDRH(r) OP (0, RX_Operand_DoubleRegH, r, 0)
128#define DDRL(r) OP (0, RX_Operand_DoubleRegL, r, 0)
129#define DCND(r) OP (0, RX_Operand_DoubleCond, r, 0)
c7927a3c
NC		 130
131#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
132#define SR(r) OP (1, RX_Operand_Register, r, 0)
f9c7014e 133#define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
c7927a3c 134#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
db5fa770 135#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
c7927a3c
NC		 136#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
137#define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
138#define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
139#define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
4ce8c66d
YS		 140#define SCR(r) OP (1, RX_Operand_DoubleCReg, r, 0)
141#define SDR(r) OP (1, RX_Operand_DoubleReg, r, 0)
142#define SDRH(r) OP (1, RX_Operand_DoubleRegH, r, 0)
143#define SDRL(r) OP (1, RX_Operand_DoubleRegL, r, 0)
c7927a3c
NC		 144
145#define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
146#define S2R(r) OP (2, RX_Operand_Register, r, 0)
147#define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
db5fa770 148#define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
c7927a3c
NC		 149#define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
150#define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
151#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
152#define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
4ce8c66d
YS		 153#define S2DR(r) OP (2, RX_Operand_DoubleReg, r, 0)
154#define S2CR(r) OP (2, RX_Operand_DoubleCReg, r, 0)
155
156#define SDD(t,r,s) rx_disp (1, t, r, bwl, ld);
c7927a3c
NC		 157
158#define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
159#define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
f04265ec 160#define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
c7927a3c 161#define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
4ce8c66d 162#define DL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz]
c7927a3c
NC		 163
164#define F(f) store_flags(rx, f)
165
166#define AU ATTRIBUTE_UNUSED
167#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
168
169#define SYNTAX(x) rx->syntax = x
170
171#define UNSUPPORTED() \
172 rx->syntax = "*unknown*"
173
174#define IMM(sf) immediate (sf, 0, ld)
175#define IMMex(sf) immediate (sf, 1, ld)
176
177static int
178immediate (int sfield, int ex, LocalData * ld)
179{
180 unsigned long i = 0, j;
181
182 switch (sfield)
183 {
184#define B ((unsigned long) GETBYTE())
185 case 0:
186#if RX_OPCODE_BIG_ENDIAN
187 i = B;
188 if (ex && (i & 0x80))
189 i -= 0x100;
190 i <<= 24;
191 i |= B << 16;
192 i |= B << 8;
193 i |= B;
194#else
195 i = B;
196 i |= B << 8;
197 i |= B << 16;
198 j = B;
199 if (ex && (j & 0x80))
200 j -= 0x100;
201 i |= j << 24;
202#endif
203 break;
204 case 3:
205#if RX_OPCODE_BIG_ENDIAN
206 i = B << 16;
207 i |= B << 8;
208 i |= B;
209#else
210 i = B;
211 i |= B << 8;
212 i |= B << 16;
213#endif
214 if (ex && (i & 0x800000))
215 i -= 0x1000000;
216 break;
217 case 2:
218#if RX_OPCODE_BIG_ENDIAN
219 i |= B << 8;
220 i |= B;
221#else
222 i |= B;
223 i |= B << 8;
224#endif
225 if (ex && (i & 0x8000))
226 i -= 0x10000;
227 break;
228 case 1:
229 i |= B;
230 if (ex && (i & 0x80))
231 i -= 0x100;
232 break;
233 default:
234 abort();
235 }
236 return i;
237}
238
239static void
db5fa770 240rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
c7927a3c
NC		 241{
242 int disp;
243
244 ld->rx->op[n].reg = reg;
245 switch (type)
246 {
247 case 3:
248 ld->rx->op[n].type = RX_Operand_Register;
249 break;
250 case 0:
e292aa7a 251 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
c7927a3c
NC		 252 ld->rx->op[n].addend = 0;
253 break;
254 case 1:
255 ld->rx->op[n].type = RX_Operand_Indirect;
256 disp = GETBYTE ();
db5fa770 257 ld->rx->op[n].addend = disp * GET_PSCALE (size);
c7927a3c
NC		 258 break;
259 case 2:
260 ld->rx->op[n].type = RX_Operand_Indirect;
261 disp = GETBYTE ();
262#if RX_OPCODE_BIG_ENDIAN
263 disp = disp * 256 + GETBYTE ();
264#else
265 disp = disp + GETBYTE () * 256;
266#endif
db5fa770 267 ld->rx->op[n].addend = disp * GET_PSCALE (size);
c7927a3c
NC		 268 break;
269 default:
270 abort ();
271 }
272}
273
3cf79a01
DD		 274#define xO 8
275#define xS 4
276#define xZ 2
277#define xC 1
c7927a3c 278
43e65147 279#define F_____
3cf79a01
DD		 280#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
281#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
282#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
283#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
284#define F_O___ rx->flags_0 = rx->flags_s = xO;
285#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
286#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
287#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
c7927a3c
NC		 288
289int
290rx_decode_opcode (unsigned long pc AU,
291 RX_Opcode_Decoded * rx,
292 int (* getbyte)(void *),
293 void * ptr)
294{
295 LocalData lds, * ld = &lds;
296 unsigned char op[20] = {0};
297
298 lds.rx = rx;
299 lds.getbyte = getbyte;
300 lds.ptr = ptr;
301 lds.op = op;
302
303 memset (rx, 0, sizeof (*rx));
304 BWL(LSIZE);
305
306
307/*----------------------------------------------------------------------*/
308/* MOV */
309
310 GETBYTE ();
311 switch (op[0] & 0xff)
312 {
313 case 0x00:
314 {
315 /** 0000 0000 brk */
316 if (trace)
317 {
318 printf ("\033[33m%s\033[0m %02x\n",
319 "/** 0000 0000 brk */",
320 op[0]);
321 }
322 SYNTAX("brk");
4ce8c66d 323#line 1050 "rx-decode.opc"
c7927a3c 324 ID(brk);
43e65147 325
c7927a3c
NC		 326 }
327 break;
328 case 0x01:
329 {
330 /** 0000 0001 dbt */
331 if (trace)
332 {
333 printf ("\033[33m%s\033[0m %02x\n",
334 "/** 0000 0001 dbt */",
335 op[0]);
336 }
337 SYNTAX("dbt");
4ce8c66d 338#line 1053 "rx-decode.opc"
c7927a3c 339 ID(dbt);
43e65147 340
c7927a3c
NC		 341 }
342 break;
343 case 0x02:
344 {
345 /** 0000 0010 rts */
346 if (trace)
347 {
348 printf ("\033[33m%s\033[0m %02x\n",
349 "/** 0000 0010 rts */",
350 op[0]);
351 }
352 SYNTAX("rts");
4ce8c66d 353#line 831 "rx-decode.opc"
c7927a3c 354 ID(rts);
43e65147 355
c7927a3c
NC		 356 /*----------------------------------------------------------------------*/
357 /* NOP */
43e65147 358
c7927a3c
NC		 359 }
360 break;
361 case 0x03:
362 {
363 /** 0000 0011 nop */
364 if (trace)
365 {
366 printf ("\033[33m%s\033[0m %02x\n",
367 "/** 0000 0011 nop */",
368 op[0]);
369 }
370 SYNTAX("nop");
4ce8c66d 371#line 837 "rx-decode.opc"
c7927a3c 372 ID(nop);
43e65147 373
c7927a3c
NC		 374 /*----------------------------------------------------------------------*/
375 /* STRING FUNCTIONS */
43e65147 376
c7927a3c
NC		 377 }
378 break;
379 case 0x04:
380 {
381 /** 0000 0100 bra.a %a0 */
382 if (trace)
383 {
384 printf ("\033[33m%s\033[0m %02x\n",
385 "/** 0000 0100 bra.a %a0 */",
386 op[0]);
387 }
388 SYNTAX("bra.a %a0");
4ce8c66d 389#line 809 "rx-decode.opc"
f9c7014e 390 ID(branch); DC(pc + IMMex(3));
43e65147 391
c7927a3c
NC		 392 }
393 break;
394 case 0x05:
395 {
396 /** 0000 0101 bsr.a %a0 */
397 if (trace)
398 {
399 printf ("\033[33m%s\033[0m %02x\n",
400 "/** 0000 0101 bsr.a %a0 */",
401 op[0]);
402 }
403 SYNTAX("bsr.a %a0");
4ce8c66d 404#line 825 "rx-decode.opc"
c7927a3c 405 ID(jsr); DC(pc + IMMex(3));
43e65147 406
c7927a3c
NC		 407 }
408 break;
409 case 0x06:
410 GETBYTE ();
411 switch (op[1] & 0xff)
412 {
413 case 0x00:
414 GETBYTE ();
415 switch (op[2] & 0x00)
416 {
417 case 0x00:
418 op_semantics_1:
419 {
420 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
4ce8c66d 421#line 567 "rx-decode.opc"
c7927a3c 422 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 423#line 567 "rx-decode.opc"
c7927a3c 424 int ss AU = op[1] & 0x03;
4ce8c66d 425#line 567 "rx-decode.opc"
c7927a3c 426 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 427#line 567 "rx-decode.opc"
c7927a3c
NC		 428 int rdst AU = op[2] & 0x0f;
429 if (trace)
430 {
431 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
432 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
433 op[0], op[1], op[2]);
434 printf (" mx = 0x%x,", mx);
435 printf (" ss = 0x%x,", ss);
436 printf (" rsrc = 0x%x,", rsrc);
437 printf (" rdst = 0x%x\n", rdst);
438 }
439 SYNTAX("sub %2%S2, %1");
4ce8c66d 440#line 567 "rx-decode.opc"
3cf79a01 441 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
43e65147 442
c7927a3c
NC		 443 }
444 break;
445 }
446 break;
447 case 0x01:
448 GETBYTE ();
449 switch (op[2] & 0x00)
450 {
451 case 0x00:
452 goto op_semantics_1;
453 break;
454 }
455 break;
456 case 0x02:
457 GETBYTE ();
458 switch (op[2] & 0x00)
459 {
460 case 0x00:
461 goto op_semantics_1;
462 break;
463 }
464 break;
465 case 0x03:
466 GETBYTE ();
467 switch (op[2] & 0x00)
468 {
469 case 0x00:
470 goto op_semantics_1;
471 break;
472 }
473 break;
474 case 0x04:
475 GETBYTE ();
476 switch (op[2] & 0x00)
477 {
478 case 0x00:
479 op_semantics_2:
480 {
481 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
4ce8c66d 482#line 555 "rx-decode.opc"
c7927a3c 483 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 484#line 555 "rx-decode.opc"
c7927a3c 485 int ss AU = op[1] & 0x03;
4ce8c66d 486#line 555 "rx-decode.opc"
c7927a3c 487 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 488#line 555 "rx-decode.opc"
c7927a3c
NC		 489 int rdst AU = op[2] & 0x0f;
490 if (trace)
491 {
492 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
493 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
494 op[0], op[1], op[2]);
495 printf (" mx = 0x%x,", mx);
496 printf (" ss = 0x%x,", ss);
497 printf (" rsrc = 0x%x,", rsrc);
498 printf (" rdst = 0x%x\n", rdst);
499 }
500 SYNTAX("cmp %2%S2, %1");
4ce8c66d 501#line 555 "rx-decode.opc"
3cf79a01 502 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
43e65147 503
c7927a3c
NC		 504 /*----------------------------------------------------------------------*/
505 /* SUB */
43e65147 506
c7927a3c
NC		 507 }
508 break;
509 }
510 break;
511 case 0x05:
512 GETBYTE ();
513 switch (op[2] & 0x00)
514 {
515 case 0x00:
516 goto op_semantics_2;
517 break;
518 }
519 break;
520 case 0x06:
521 GETBYTE ();
522 switch (op[2] & 0x00)
523 {
524 case 0x00:
525 goto op_semantics_2;
526 break;
527 }
528 break;
529 case 0x07:
530 GETBYTE ();
531 switch (op[2] & 0x00)
532 {
533 case 0x00:
534 goto op_semantics_2;
535 break;
536 }
537 break;
538 case 0x08:
539 GETBYTE ();
540 switch (op[2] & 0x00)
541 {
542 case 0x00:
543 op_semantics_3:
544 {
545 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
4ce8c66d 546#line 531 "rx-decode.opc"
c7927a3c 547 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 548#line 531 "rx-decode.opc"
c7927a3c 549 int ss AU = op[1] & 0x03;
4ce8c66d 550#line 531 "rx-decode.opc"
c7927a3c 551 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 552#line 531 "rx-decode.opc"
c7927a3c
NC		 553 int rdst AU = op[2] & 0x0f;
554 if (trace)
555 {
556 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
557 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
558 op[0], op[1], op[2]);
559 printf (" mx = 0x%x,", mx);
560 printf (" ss = 0x%x,", ss);
561 printf (" rsrc = 0x%x,", rsrc);
562 printf (" rdst = 0x%x\n", rdst);
563 }
564 SYNTAX("add %1%S1, %0");
4ce8c66d 565#line 531 "rx-decode.opc"
3cf79a01 566 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
43e65147 567
c7927a3c
NC		 568 }
569 break;
570 }
571 break;
572 case 0x09:
573 GETBYTE ();
574 switch (op[2] & 0x00)
575 {
576 case 0x00:
577 goto op_semantics_3;
578 break;
579 }
580 break;
581 case 0x0a:
582 GETBYTE ();
583 switch (op[2] & 0x00)
584 {
585 case 0x00:
586 goto op_semantics_3;
587 break;
588 }
589 break;
590 case 0x0b:
591 GETBYTE ();
592 switch (op[2] & 0x00)
593 {
594 case 0x00:
595 goto op_semantics_3;
596 break;
597 }
598 break;
599 case 0x0c:
600 GETBYTE ();
601 switch (op[2] & 0x00)
602 {
603 case 0x00:
604 op_semantics_4:
605 {
606 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
4ce8c66d 607#line 674 "rx-decode.opc"
c7927a3c 608 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 609#line 674 "rx-decode.opc"
c7927a3c 610 int ss AU = op[1] & 0x03;
4ce8c66d 611#line 674 "rx-decode.opc"
c7927a3c 612 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 613#line 674 "rx-decode.opc"
c7927a3c
NC		 614 int rdst AU = op[2] & 0x0f;
615 if (trace)
616 {
617 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
618 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
619 op[0], op[1], op[2]);
620 printf (" mx = 0x%x,", mx);
621 printf (" ss = 0x%x,", ss);
622 printf (" rsrc = 0x%x,", rsrc);
623 printf (" rdst = 0x%x\n", rdst);
624 }
625 SYNTAX("mul %1%S1, %0");
4ce8c66d 626#line 674 "rx-decode.opc"
3cf79a01 627 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
43e65147 628
c7927a3c
NC		 629 }
630 break;
631 }
632 break;
633 case 0x0d:
634 GETBYTE ();
635 switch (op[2] & 0x00)
636 {
637 case 0x00:
638 goto op_semantics_4;
639 break;
640 }
641 break;
642 case 0x0e:
643 GETBYTE ();
644 switch (op[2] & 0x00)
645 {
646 case 0x00:
647 goto op_semantics_4;
648 break;
649 }
650 break;
651 case 0x0f:
652 GETBYTE ();
653 switch (op[2] & 0x00)
654 {
655 case 0x00:
656 goto op_semantics_4;
657 break;
658 }
659 break;
660 case 0x10:
661 GETBYTE ();
662 switch (op[2] & 0x00)
663 {
664 case 0x00:
665 op_semantics_5:
666 {
667 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
4ce8c66d 668#line 444 "rx-decode.opc"
c7927a3c 669 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 670#line 444 "rx-decode.opc"
c7927a3c 671 int ss AU = op[1] & 0x03;
4ce8c66d 672#line 444 "rx-decode.opc"
c7927a3c 673 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 674#line 444 "rx-decode.opc"
c7927a3c
NC		 675 int rdst AU = op[2] & 0x0f;
676 if (trace)
677 {
678 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
679 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
680 op[0], op[1], op[2]);
681 printf (" mx = 0x%x,", mx);
682 printf (" ss = 0x%x,", ss);
683 printf (" rsrc = 0x%x,", rsrc);
684 printf (" rdst = 0x%x\n", rdst);
685 }
686 SYNTAX("and %1%S1, %0");
4ce8c66d 687#line 444 "rx-decode.opc"
3cf79a01 688 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 689
c7927a3c
NC		 690 }
691 break;
692 }
693 break;
694 case 0x11:
695 GETBYTE ();
696 switch (op[2] & 0x00)
697 {
698 case 0x00:
699 goto op_semantics_5;
700 break;
701 }
702 break;
703 case 0x12:
704 GETBYTE ();
705 switch (op[2] & 0x00)
706 {
707 case 0x00:
708 goto op_semantics_5;
709 break;
710 }
711 break;
712 case 0x13:
713 GETBYTE ();
714 switch (op[2] & 0x00)
715 {
716 case 0x00:
717 goto op_semantics_5;
718 break;
719 }
720 break;
721 case 0x14:
722 GETBYTE ();
723 switch (op[2] & 0x00)
724 {
725 case 0x00:
726 op_semantics_6:
727 {
728 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
4ce8c66d 729#line 462 "rx-decode.opc"
c7927a3c 730 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 731#line 462 "rx-decode.opc"
c7927a3c 732 int ss AU = op[1] & 0x03;
4ce8c66d 733#line 462 "rx-decode.opc"
c7927a3c 734 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 735#line 462 "rx-decode.opc"
c7927a3c
NC		 736 int rdst AU = op[2] & 0x0f;
737 if (trace)
738 {
739 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
740 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
741 op[0], op[1], op[2]);
742 printf (" mx = 0x%x,", mx);
743 printf (" ss = 0x%x,", ss);
744 printf (" rsrc = 0x%x,", rsrc);
745 printf (" rdst = 0x%x\n", rdst);
746 }
747 SYNTAX("or %1%S1, %0");
4ce8c66d 748#line 462 "rx-decode.opc"
3cf79a01 749 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 750
c7927a3c
NC		 751 }
752 break;
753 }
754 break;
755 case 0x15:
756 GETBYTE ();
757 switch (op[2] & 0x00)
758 {
759 case 0x00:
760 goto op_semantics_6;
761 break;
762 }
763 break;
764 case 0x16:
765 GETBYTE ();
766 switch (op[2] & 0x00)
767 {
768 case 0x00:
769 goto op_semantics_6;
770 break;
771 }
772 break;
773 case 0x17:
774 GETBYTE ();
775 switch (op[2] & 0x00)
776 {
777 case 0x00:
778 goto op_semantics_6;
779 break;
780 }
781 break;
782 case 0x20:
783 GETBYTE ();
784 switch (op[2] & 0xff)
785 {
786 case 0x00:
787 GETBYTE ();
788 switch (op[3] & 0x00)
789 {
790 case 0x00:
791 op_semantics_7:
792 {
793 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
4ce8c66d 794#line 580 "rx-decode.opc"
c7927a3c 795 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 796#line 580 "rx-decode.opc"
c7927a3c 797 int sp AU = op[1] & 0x03;
4ce8c66d 798#line 580 "rx-decode.opc"
c7927a3c 799 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 800#line 580 "rx-decode.opc"
c7927a3c
NC		 801 int rdst AU = op[3] & 0x0f;
802 if (trace)
803 {
804 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
805 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
806 op[0], op[1], op[2], op[3]);
807 printf (" mx = 0x%x,", mx);
808 printf (" sp = 0x%x,", sp);
809 printf (" rsrc = 0x%x,", rsrc);
810 printf (" rdst = 0x%x\n", rdst);
811 }
812 SYNTAX("sbb %1%S1, %0");
4ce8c66d 813#line 580 "rx-decode.opc"
3cf79a01 814 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
43e65147 815
c7927a3c
NC		 816 /*----------------------------------------------------------------------*/
817 /* ABS */
43e65147 818
c7927a3c
NC		 819 }
820 break;
821 }
822 break;
823 case 0x04:
824 GETBYTE ();
825 switch (op[3] & 0x00)
826 {
827 case 0x00:
828 op_semantics_8:
829 {
830 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
4ce8c66d 831#line 619 "rx-decode.opc"
c7927a3c 832 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 833#line 619 "rx-decode.opc"
c7927a3c 834 int ss AU = op[1] & 0x03;
4ce8c66d 835#line 619 "rx-decode.opc"
c7927a3c 836 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 837#line 619 "rx-decode.opc"
c7927a3c
NC		 838 int rdst AU = op[3] & 0x0f;
839 if (trace)
840 {
841 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
842 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
843 op[0], op[1], op[2], op[3]);
844 printf (" mx = 0x%x,", mx);
845 printf (" ss = 0x%x,", ss);
846 printf (" rsrc = 0x%x,", rsrc);
847 printf (" rdst = 0x%x\n", rdst);
848 }
849 SYNTAX("max %1%S1, %0");
4ce8c66d 850#line 619 "rx-decode.opc"
c7927a3c 851 ID(max); SPm(ss, rsrc, mx); DR(rdst);
43e65147 852
c7927a3c
NC		 853 /*----------------------------------------------------------------------*/
854 /* MIN */
43e65147 855
c7927a3c
NC		 856 }
857 break;
858 }
859 break;
860 case 0x05:
861 GETBYTE ();
862 switch (op[3] & 0x00)
863 {
864 case 0x00:
865 op_semantics_9:
866 {
867 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
4ce8c66d 868#line 631 "rx-decode.opc"
c7927a3c 869 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 870#line 631 "rx-decode.opc"
c7927a3c 871 int ss AU = op[1] & 0x03;
4ce8c66d 872#line 631 "rx-decode.opc"
c7927a3c 873 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 874#line 631 "rx-decode.opc"
c7927a3c
NC		 875 int rdst AU = op[3] & 0x0f;
876 if (trace)
877 {
878 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
879 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
880 op[0], op[1], op[2], op[3]);
881 printf (" mx = 0x%x,", mx);
882 printf (" ss = 0x%x,", ss);
883 printf (" rsrc = 0x%x,", rsrc);
884 printf (" rdst = 0x%x\n", rdst);
885 }
886 SYNTAX("min %1%S1, %0");
4ce8c66d 887#line 631 "rx-decode.opc"
c7927a3c 888 ID(min); SPm(ss, rsrc, mx); DR(rdst);
43e65147 889
c7927a3c
NC		 890 /*----------------------------------------------------------------------*/
891 /* MUL */
43e65147 892
c7927a3c
NC		 893 }
894 break;
895 }
896 break;
897 case 0x06:
898 GETBYTE ();
899 switch (op[3] & 0x00)
900 {
901 case 0x00:
902 op_semantics_10:
903 {
904 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
4ce8c66d 905#line 689 "rx-decode.opc"
c7927a3c 906 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 907#line 689 "rx-decode.opc"
c7927a3c 908 int ss AU = op[1] & 0x03;
4ce8c66d 909#line 689 "rx-decode.opc"
c7927a3c 910 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 911#line 689 "rx-decode.opc"
c7927a3c
NC		 912 int rdst AU = op[3] & 0x0f;
913 if (trace)
914 {
915 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
916 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
917 op[0], op[1], op[2], op[3]);
918 printf (" mx = 0x%x,", mx);
919 printf (" ss = 0x%x,", ss);
920 printf (" rsrc = 0x%x,", rsrc);
921 printf (" rdst = 0x%x\n", rdst);
922 }
923 SYNTAX("emul %1%S1, %0");
4ce8c66d 924#line 689 "rx-decode.opc"
c7927a3c 925 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
43e65147 926
c7927a3c
NC		 927 /*----------------------------------------------------------------------*/
928 /* EMULU */
43e65147 929
c7927a3c
NC		 930 }
931 break;
932 }
933 break;
934 case 0x07:
935 GETBYTE ();
936 switch (op[3] & 0x00)
937 {
938 case 0x00:
939 op_semantics_11:
940 {
941 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
4ce8c66d 942#line 701 "rx-decode.opc"
c7927a3c 943 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 944#line 701 "rx-decode.opc"
c7927a3c 945 int ss AU = op[1] & 0x03;
4ce8c66d 946#line 701 "rx-decode.opc"
c7927a3c 947 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 948#line 701 "rx-decode.opc"
c7927a3c
NC		 949 int rdst AU = op[3] & 0x0f;
950 if (trace)
951 {
952 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
953 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
954 op[0], op[1], op[2], op[3]);
955 printf (" mx = 0x%x,", mx);
956 printf (" ss = 0x%x,", ss);
957 printf (" rsrc = 0x%x,", rsrc);
958 printf (" rdst = 0x%x\n", rdst);
959 }
960 SYNTAX("emulu %1%S1, %0");
4ce8c66d 961#line 701 "rx-decode.opc"
c7927a3c 962 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
43e65147 963
c7927a3c
NC		 964 /*----------------------------------------------------------------------*/
965 /* DIV */
43e65147 966
c7927a3c
NC		 967 }
968 break;
969 }
970 break;
971 case 0x08:
972 GETBYTE ();
973 switch (op[3] & 0x00)
974 {
975 case 0x00:
976 op_semantics_12:
977 {
978 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
4ce8c66d 979#line 713 "rx-decode.opc"
c7927a3c 980 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 981#line 713 "rx-decode.opc"
c7927a3c 982 int ss AU = op[1] & 0x03;
4ce8c66d 983#line 713 "rx-decode.opc"
c7927a3c 984 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 985#line 713 "rx-decode.opc"
c7927a3c
NC		 986 int rdst AU = op[3] & 0x0f;
987 if (trace)
988 {
989 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
990 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
991 op[0], op[1], op[2], op[3]);
992 printf (" mx = 0x%x,", mx);
993 printf (" ss = 0x%x,", ss);
994 printf (" rsrc = 0x%x,", rsrc);
995 printf (" rdst = 0x%x\n", rdst);
996 }
997 SYNTAX("div %1%S1, %0");
4ce8c66d 998#line 713 "rx-decode.opc"
3cf79a01 999 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
43e65147 1000
c7927a3c
NC		 1001 /*----------------------------------------------------------------------*/
1002 /* DIVU */
43e65147 1003
c7927a3c
NC		 1004 }
1005 break;
1006 }
1007 break;
1008 case 0x09:
1009 GETBYTE ();
1010 switch (op[3] & 0x00)
1011 {
1012 case 0x00:
1013 op_semantics_13:
1014 {
1015 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
4ce8c66d 1016#line 725 "rx-decode.opc"
c7927a3c 1017 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 1018#line 725 "rx-decode.opc"
c7927a3c 1019 int ss AU = op[1] & 0x03;
4ce8c66d 1020#line 725 "rx-decode.opc"
c7927a3c 1021 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 1022#line 725 "rx-decode.opc"
c7927a3c
NC		 1023 int rdst AU = op[3] & 0x0f;
1024 if (trace)
1025 {
1026 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1027 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1028 op[0], op[1], op[2], op[3]);
1029 printf (" mx = 0x%x,", mx);
1030 printf (" ss = 0x%x,", ss);
1031 printf (" rsrc = 0x%x,", rsrc);
1032 printf (" rdst = 0x%x\n", rdst);
1033 }
1034 SYNTAX("divu %1%S1, %0");
4ce8c66d 1035#line 725 "rx-decode.opc"
3cf79a01 1036 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
43e65147 1037
c7927a3c
NC		 1038 /*----------------------------------------------------------------------*/
1039 /* SHIFT */
43e65147 1040
c7927a3c
NC		 1041 }
1042 break;
1043 }
1044 break;
1045 case 0x0c:
1046 GETBYTE ();
1047 switch (op[3] & 0x00)
1048 {
1049 case 0x00:
1050 op_semantics_14:
1051 {
1052 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
4ce8c66d 1053#line 498 "rx-decode.opc"
c7927a3c 1054 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 1055#line 498 "rx-decode.opc"
c7927a3c 1056 int ss AU = op[1] & 0x03;
4ce8c66d 1057#line 498 "rx-decode.opc"
c7927a3c 1058 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 1059#line 498 "rx-decode.opc"
c7927a3c
NC		 1060 int rdst AU = op[3] & 0x0f;
1061 if (trace)
1062 {
1063 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1064 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1065 op[0], op[1], op[2], op[3]);
1066 printf (" mx = 0x%x,", mx);
1067 printf (" ss = 0x%x,", ss);
1068 printf (" rsrc = 0x%x,", rsrc);
1069 printf (" rdst = 0x%x\n", rdst);
1070 }
1071 SYNTAX("tst %1%S1, %2");
4ce8c66d 1072#line 498 "rx-decode.opc"
3cf79a01 1073 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
43e65147 1074
c7927a3c
NC		 1075 /*----------------------------------------------------------------------*/
1076 /* NEG */
43e65147 1077
c7927a3c
NC		 1078 }
1079 break;
1080 }
1081 break;
1082 case 0x0d:
1083 GETBYTE ();
1084 switch (op[3] & 0x00)
1085 {
1086 case 0x00:
1087 op_semantics_15:
1088 {
1089 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
4ce8c66d 1090#line 477 "rx-decode.opc"
c7927a3c 1091 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 1092#line 477 "rx-decode.opc"
c7927a3c 1093 int ss AU = op[1] & 0x03;
4ce8c66d 1094#line 477 "rx-decode.opc"
c7927a3c 1095 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 1096#line 477 "rx-decode.opc"
c7927a3c
NC		 1097 int rdst AU = op[3] & 0x0f;
1098 if (trace)
1099 {
1100 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1101 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1102 op[0], op[1], op[2], op[3]);
1103 printf (" mx = 0x%x,", mx);
1104 printf (" ss = 0x%x,", ss);
1105 printf (" rsrc = 0x%x,", rsrc);
1106 printf (" rdst = 0x%x\n", rdst);
1107 }
1108 SYNTAX("xor %1%S1, %0");
4ce8c66d 1109#line 477 "rx-decode.opc"
3cf79a01 1110 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 1111
c7927a3c
NC		 1112 /*----------------------------------------------------------------------*/
1113 /* NOT */
43e65147 1114
c7927a3c
NC		 1115 }
1116 break;
1117 }
1118 break;
1119 case 0x10:
1120 GETBYTE ();
1121 switch (op[3] & 0x00)
1122 {
1123 case 0x00:
1124 op_semantics_16:
1125 {
1126 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
4ce8c66d 1127#line 411 "rx-decode.opc"
c7927a3c 1128 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 1129#line 411 "rx-decode.opc"
c7927a3c 1130 int ss AU = op[1] & 0x03;
4ce8c66d 1131#line 411 "rx-decode.opc"
c7927a3c 1132 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 1133#line 411 "rx-decode.opc"
c7927a3c
NC		 1134 int rdst AU = op[3] & 0x0f;
1135 if (trace)
1136 {
1137 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1138 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1139 op[0], op[1], op[2], op[3]);
1140 printf (" mx = 0x%x,", mx);
1141 printf (" ss = 0x%x,", ss);
1142 printf (" rsrc = 0x%x,", rsrc);
1143 printf (" rdst = 0x%x\n", rdst);
1144 }
1145 SYNTAX("xchg %1%S1, %0");
4ce8c66d 1146#line 411 "rx-decode.opc"
c7927a3c 1147 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
43e65147 1148
c7927a3c
NC		 1149 /*----------------------------------------------------------------------*/
1150 /* STZ/STNZ */
43e65147 1151
c7927a3c
NC		 1152 }
1153 break;
1154 }
1155 break;
1156 case 0x11:
1157 GETBYTE ();
1158 switch (op[3] & 0x00)
1159 {
1160 case 0x00:
1161 op_semantics_17:
1162 {
1163 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
4ce8c66d 1164#line 954 "rx-decode.opc"
c7927a3c 1165 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 1166#line 954 "rx-decode.opc"
c7927a3c 1167 int sd AU = op[1] & 0x03;
4ce8c66d 1168#line 954 "rx-decode.opc"
c7927a3c 1169 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 1170#line 954 "rx-decode.opc"
c7927a3c
NC		 1171 int rdst AU = op[3] & 0x0f;
1172 if (trace)
1173 {
1174 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1175 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1176 op[0], op[1], op[2], op[3]);
1177 printf (" mx = 0x%x,", mx);
1178 printf (" sd = 0x%x,", sd);
1179 printf (" rsrc = 0x%x,", rsrc);
1180 printf (" rdst = 0x%x\n", rdst);
1181 }
1182 SYNTAX("itof %1%S1, %0");
4ce8c66d 1183#line 954 "rx-decode.opc"
3cf79a01 1184 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
43e65147 1185
c7927a3c
NC		 1186 /*----------------------------------------------------------------------*/
1187 /* BIT OPS */
43e65147 1188
a117b0a5
YS		 1189 }
1190 break;
1191 }
1192 break;
1193 case 0x15:
1194 GETBYTE ();
1195 switch (op[3] & 0x00)
1196 {
1197 case 0x00:
1198 op_semantics_18:
1199 {
1200 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
4ce8c66d 1201#line 1140 "rx-decode.opc"
a117b0a5 1202 int mx AU = (op[1] >> 6) & 0x03;
4ce8c66d 1203#line 1140 "rx-decode.opc"
a117b0a5 1204 int sd AU = op[1] & 0x03;
4ce8c66d 1205#line 1140 "rx-decode.opc"
a117b0a5 1206 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 1207#line 1140 "rx-decode.opc"
a117b0a5
YS		 1208 int rdst AU = op[3] & 0x0f;
1209 if (trace)
1210 {
1211 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1212 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1213 op[0], op[1], op[2], op[3]);
1214 printf (" mx = 0x%x,", mx);
1215 printf (" sd = 0x%x,", sd);
1216 printf (" rsrc = 0x%x,", rsrc);
1217 printf (" rdst = 0x%x\n", rdst);
1218 }
1219 SYNTAX("utof %1%S1, %0");
4ce8c66d 1220#line 1140 "rx-decode.opc"
a117b0a5
YS		 1221 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1222
4ce8c66d
YS		 1223 /*----------------------------------------------------------------------*/
1224 /* RXv3 enhanced */
1225
c7927a3c
NC		 1226 }
1227 break;
1228 }
1229 break;
1230 default: UNSUPPORTED(); break;
1231 }
1232 break;
1233 case 0x21:
1234 GETBYTE ();
1235 switch (op[2] & 0xff)
1236 {
1237 case 0x00:
1238 GETBYTE ();
1239 switch (op[3] & 0x00)
1240 {
1241 case 0x00:
1242 goto op_semantics_7;
1243 break;
1244 }
1245 break;
1246 case 0x04:
1247 GETBYTE ();
1248 switch (op[3] & 0x00)
1249 {
1250 case 0x00:
1251 goto op_semantics_8;
1252 break;
1253 }
1254 break;
1255 case 0x05:
1256 GETBYTE ();
1257 switch (op[3] & 0x00)
1258 {
1259 case 0x00:
1260 goto op_semantics_9;
1261 break;
1262 }
1263 break;
1264 case 0x06:
1265 GETBYTE ();
1266 switch (op[3] & 0x00)
1267 {
1268 case 0x00:
1269 goto op_semantics_10;
1270 break;
1271 }
1272 break;
1273 case 0x07:
1274 GETBYTE ();
1275 switch (op[3] & 0x00)
1276 {
1277 case 0x00:
1278 goto op_semantics_11;
1279 break;
1280 }
1281 break;
1282 case 0x08:
1283 GETBYTE ();
1284 switch (op[3] & 0x00)
1285 {
1286 case 0x00:
1287 goto op_semantics_12;
1288 break;
1289 }
1290 break;
1291 case 0x09:
1292 GETBYTE ();
1293 switch (op[3] & 0x00)
1294 {
1295 case 0x00:
1296 goto op_semantics_13;
1297 break;
1298 }
1299 break;
1300 case 0x0c:
1301 GETBYTE ();
1302 switch (op[3] & 0x00)
1303 {
1304 case 0x00:
1305 goto op_semantics_14;
1306 break;
1307 }
1308 break;
1309 case 0x0d:
1310 GETBYTE ();
1311 switch (op[3] & 0x00)
1312 {
1313 case 0x00:
1314 goto op_semantics_15;
1315 break;
1316 }
1317 break;
1318 case 0x10:
1319 GETBYTE ();
1320 switch (op[3] & 0x00)
1321 {
1322 case 0x00:
1323 goto op_semantics_16;
1324 break;
1325 }
1326 break;
1327 case 0x11:
1328 GETBYTE ();
1329 switch (op[3] & 0x00)
1330 {
1331 case 0x00:
1332 goto op_semantics_17;
1333 break;
1334 }
1335 break;
a117b0a5
YS		 1336 case 0x15:
1337 GETBYTE ();
1338 switch (op[3] & 0x00)
1339 {
1340 case 0x00:
1341 goto op_semantics_18;
1342 break;
1343 }
1344 break;
c7927a3c
NC		 1345 default: UNSUPPORTED(); break;
1346 }
1347 break;
1348 case 0x22:
1349 GETBYTE ();
1350 switch (op[2] & 0xff)
1351 {
1352 case 0x00:
1353 GETBYTE ();
1354 switch (op[3] & 0x00)
1355 {
1356 case 0x00:
1357 goto op_semantics_7;
1358 break;
1359 }
1360 break;
1361 case 0x04:
1362 GETBYTE ();
1363 switch (op[3] & 0x00)
1364 {
1365 case 0x00:
1366 goto op_semantics_8;
1367 break;
1368 }
1369 break;
1370 case 0x05:
1371 GETBYTE ();
1372 switch (op[3] & 0x00)
1373 {
1374 case 0x00:
1375 goto op_semantics_9;
1376 break;
1377 }
1378 break;
1379 case 0x06:
1380 GETBYTE ();
1381 switch (op[3] & 0x00)
1382 {
1383 case 0x00:
1384 goto op_semantics_10;
1385 break;
1386 }
1387 break;
1388 case 0x07:
1389 GETBYTE ();
1390 switch (op[3] & 0x00)
1391 {
1392 case 0x00:
1393 goto op_semantics_11;
1394 break;
1395 }
1396 break;
1397 case 0x08:
1398 GETBYTE ();
1399 switch (op[3] & 0x00)
1400 {
1401 case 0x00:
1402 goto op_semantics_12;
1403 break;
1404 }
1405 break;
1406 case 0x09:
1407 GETBYTE ();
1408 switch (op[3] & 0x00)
1409 {
1410 case 0x00:
1411 goto op_semantics_13;
1412 break;
1413 }
1414 break;
1415 case 0x0c:
1416 GETBYTE ();
1417 switch (op[3] & 0x00)
1418 {
1419 case 0x00:
1420 goto op_semantics_14;
1421 break;
1422 }
1423 break;
1424 case 0x0d:
1425 GETBYTE ();
1426 switch (op[3] & 0x00)
1427 {
1428 case 0x00:
1429 goto op_semantics_15;
1430 break;
1431 }
1432 break;
1433 case 0x10:
1434 GETBYTE ();
1435 switch (op[3] & 0x00)
1436 {
1437 case 0x00:
1438 goto op_semantics_16;
1439 break;
1440 }
1441 break;
1442 case 0x11:
1443 GETBYTE ();
1444 switch (op[3] & 0x00)
1445 {
1446 case 0x00:
1447 goto op_semantics_17;
1448 break;
1449 }
1450 break;
a117b0a5
YS		 1451 case 0x15:
1452 GETBYTE ();
1453 switch (op[3] & 0x00)
1454 {
1455 case 0x00:
1456 goto op_semantics_18;
1457 break;
1458 }
1459 break;
c7927a3c
NC		 1460 default: UNSUPPORTED(); break;
1461 }
1462 break;
1463 case 0x23:
1464 GETBYTE ();
1465 switch (op[2] & 0xff)
1466 {
1467 case 0x00:
1468 GETBYTE ();
1469 switch (op[3] & 0x00)
1470 {
1471 case 0x00:
1472 goto op_semantics_7;
1473 break;
1474 }
1475 break;
1476 case 0x04:
1477 GETBYTE ();
1478 switch (op[3] & 0x00)
1479 {
1480 case 0x00:
1481 goto op_semantics_8;
1482 break;
1483 }
1484 break;
1485 case 0x05:
1486 GETBYTE ();
1487 switch (op[3] & 0x00)
1488 {
1489 case 0x00:
1490 goto op_semantics_9;
1491 break;
1492 }
1493 break;
1494 case 0x06:
1495 GETBYTE ();
1496 switch (op[3] & 0x00)
1497 {
1498 case 0x00:
1499 goto op_semantics_10;
1500 break;
1501 }
1502 break;
1503 case 0x07:
1504 GETBYTE ();
1505 switch (op[3] & 0x00)
1506 {
1507 case 0x00:
1508 goto op_semantics_11;
1509 break;
1510 }
1511 break;
1512 case 0x08:
1513 GETBYTE ();
1514 switch (op[3] & 0x00)
1515 {
1516 case 0x00:
1517 goto op_semantics_12;
1518 break;
1519 }
1520 break;
1521 case 0x09:
1522 GETBYTE ();
1523 switch (op[3] & 0x00)
1524 {
1525 case 0x00:
1526 goto op_semantics_13;
1527 break;
1528 }
1529 break;
1530 case 0x0c:
1531 GETBYTE ();
1532 switch (op[3] & 0x00)
1533 {
1534 case 0x00:
1535 goto op_semantics_14;
1536 break;
1537 }
1538 break;
1539 case 0x0d:
1540 GETBYTE ();
1541 switch (op[3] & 0x00)
1542 {
1543 case 0x00:
1544 goto op_semantics_15;
1545 break;
1546 }
1547 break;
1548 case 0x10:
1549 GETBYTE ();
1550 switch (op[3] & 0x00)
1551 {
1552 case 0x00:
1553 goto op_semantics_16;
1554 break;
1555 }
1556 break;
1557 case 0x11:
1558 GETBYTE ();
1559 switch (op[3] & 0x00)
1560 {
1561 case 0x00:
1562 goto op_semantics_17;
1563 break;
1564 }
1565 break;
a117b0a5
YS		 1566 case 0x15:
1567 GETBYTE ();
1568 switch (op[3] & 0x00)
1569 {
1570 case 0x00:
1571 goto op_semantics_18;
1572 break;
1573 }
1574 break;
c7927a3c
NC		 1575 default: UNSUPPORTED(); break;
1576 }
1577 break;
1578 case 0x40:
1579 GETBYTE ();
1580 switch (op[2] & 0x00)
1581 {
1582 case 0x00:
1583 goto op_semantics_1;
1584 break;
1585 }
1586 break;
1587 case 0x41:
1588 GETBYTE ();
1589 switch (op[2] & 0x00)
1590 {
1591 case 0x00:
1592 goto op_semantics_1;
1593 break;
1594 }
1595 break;
1596 case 0x42:
1597 GETBYTE ();
1598 switch (op[2] & 0x00)
1599 {
1600 case 0x00:
1601 goto op_semantics_1;
1602 break;
1603 }
1604 break;
1605 case 0x43:
1606 GETBYTE ();
1607 switch (op[2] & 0x00)
1608 {
1609 case 0x00:
1610 goto op_semantics_1;
1611 break;
1612 }
1613 break;
1614 case 0x44:
1615 GETBYTE ();
1616 switch (op[2] & 0x00)
1617 {
1618 case 0x00:
1619 goto op_semantics_2;
1620 break;
1621 }
1622 break;
1623 case 0x45:
1624 GETBYTE ();
1625 switch (op[2] & 0x00)
1626 {
1627 case 0x00:
1628 goto op_semantics_2;
1629 break;
1630 }
1631 break;
1632 case 0x46:
1633 GETBYTE ();
1634 switch (op[2] & 0x00)
1635 {
1636 case 0x00:
1637 goto op_semantics_2;
1638 break;
1639 }
1640 break;
1641 case 0x47:
1642 GETBYTE ();
1643 switch (op[2] & 0x00)
1644 {
1645 case 0x00:
1646 goto op_semantics_2;
1647 break;
1648 }
1649 break;
1650 case 0x48:
1651 GETBYTE ();
1652 switch (op[2] & 0x00)
1653 {
1654 case 0x00:
1655 goto op_semantics_3;
1656 break;
1657 }
1658 break;
1659 case 0x49:
1660 GETBYTE ();
1661 switch (op[2] & 0x00)
1662 {
1663 case 0x00:
1664 goto op_semantics_3;
1665 break;
1666 }
1667 break;
1668 case 0x4a:
1669 GETBYTE ();
1670 switch (op[2] & 0x00)
1671 {
1672 case 0x00:
1673 goto op_semantics_3;
1674 break;
1675 }
1676 break;
1677 case 0x4b:
1678 GETBYTE ();
1679 switch (op[2] & 0x00)
1680 {
1681 case 0x00:
1682 goto op_semantics_3;
1683 break;
1684 }
1685 break;
1686 case 0x4c:
1687 GETBYTE ();
1688 switch (op[2] & 0x00)
1689 {
1690 case 0x00:
1691 goto op_semantics_4;
1692 break;
1693 }
1694 break;
1695 case 0x4d:
1696 GETBYTE ();
1697 switch (op[2] & 0x00)
1698 {
1699 case 0x00:
1700 goto op_semantics_4;
1701 break;
1702 }
1703 break;
1704 case 0x4e:
1705 GETBYTE ();
1706 switch (op[2] & 0x00)
1707 {
1708 case 0x00:
1709 goto op_semantics_4;
1710 break;
1711 }
1712 break;
1713 case 0x4f:
1714 GETBYTE ();
1715 switch (op[2] & 0x00)
1716 {
1717 case 0x00:
1718 goto op_semantics_4;
1719 break;
1720 }
1721 break;
1722 case 0x50:
1723 GETBYTE ();
1724 switch (op[2] & 0x00)
1725 {
1726 case 0x00:
1727 goto op_semantics_5;
1728 break;
1729 }
1730 break;
1731 case 0x51:
1732 GETBYTE ();
1733 switch (op[2] & 0x00)
1734 {
1735 case 0x00:
1736 goto op_semantics_5;
1737 break;
1738 }
1739 break;
1740 case 0x52:
1741 GETBYTE ();
1742 switch (op[2] & 0x00)
1743 {
1744 case 0x00:
1745 goto op_semantics_5;
1746 break;
1747 }
1748 break;
1749 case 0x53:
1750 GETBYTE ();
1751 switch (op[2] & 0x00)
1752 {
1753 case 0x00:
1754 goto op_semantics_5;
1755 break;
1756 }
1757 break;
1758 case 0x54:
1759 GETBYTE ();
1760 switch (op[2] & 0x00)
1761 {
1762 case 0x00:
1763 goto op_semantics_6;
1764 break;
1765 }
1766 break;
1767 case 0x55:
1768 GETBYTE ();
1769 switch (op[2] & 0x00)
1770 {
1771 case 0x00:
1772 goto op_semantics_6;
1773 break;
1774 }
1775 break;
1776 case 0x56:
1777 GETBYTE ();
1778 switch (op[2] & 0x00)
1779 {
1780 case 0x00:
1781 goto op_semantics_6;
1782 break;
1783 }
1784 break;
1785 case 0x57:
1786 GETBYTE ();
1787 switch (op[2] & 0x00)
1788 {
1789 case 0x00:
1790 goto op_semantics_6;
1791 break;
1792 }
1793 break;
1794 case 0x60:
1795 GETBYTE ();
1796 switch (op[2] & 0xff)
1797 {
1798 case 0x00:
1799 GETBYTE ();
1800 switch (op[3] & 0x00)
1801 {
1802 case 0x00:
1803 goto op_semantics_7;
1804 break;
1805 }
1806 break;
1807 case 0x04:
1808 GETBYTE ();
1809 switch (op[3] & 0x00)
1810 {
1811 case 0x00:
1812 goto op_semantics_8;
1813 break;
1814 }
1815 break;
1816 case 0x05:
1817 GETBYTE ();
1818 switch (op[3] & 0x00)
1819 {
1820 case 0x00:
1821 goto op_semantics_9;
1822 break;
1823 }
1824 break;
1825 case 0x06:
1826 GETBYTE ();
1827 switch (op[3] & 0x00)
1828 {
1829 case 0x00:
1830 goto op_semantics_10;
1831 break;
1832 }
1833 break;
1834 case 0x07:
1835 GETBYTE ();
1836 switch (op[3] & 0x00)
1837 {
1838 case 0x00:
1839 goto op_semantics_11;
1840 break;
1841 }
1842 break;
1843 case 0x08:
1844 GETBYTE ();
1845 switch (op[3] & 0x00)
1846 {
1847 case 0x00:
1848 goto op_semantics_12;
1849 break;
1850 }
1851 break;
1852 case 0x09:
1853 GETBYTE ();
1854 switch (op[3] & 0x00)
1855 {
1856 case 0x00:
1857 goto op_semantics_13;
1858 break;
1859 }
1860 break;
1861 case 0x0c:
1862 GETBYTE ();
1863 switch (op[3] & 0x00)
1864 {
1865 case 0x00:
1866 goto op_semantics_14;
1867 break;
1868 }
1869 break;
1870 case 0x0d:
1871 GETBYTE ();
1872 switch (op[3] & 0x00)
1873 {
1874 case 0x00:
1875 goto op_semantics_15;
1876 break;
1877 }
1878 break;
1879 case 0x10:
1880 GETBYTE ();
1881 switch (op[3] & 0x00)
1882 {
1883 case 0x00:
1884 goto op_semantics_16;
1885 break;
1886 }
1887 break;
1888 case 0x11:
1889 GETBYTE ();
1890 switch (op[3] & 0x00)
1891 {
1892 case 0x00:
1893 goto op_semantics_17;
1894 break;
1895 }
1896 break;
a117b0a5
YS		 1897 case 0x15:
1898 GETBYTE ();
1899 switch (op[3] & 0x00)
1900 {
1901 case 0x00:
1902 goto op_semantics_18;
1903 break;
1904 }
1905 break;
c7927a3c
NC		 1906 default: UNSUPPORTED(); break;
1907 }
1908 break;
1909 case 0x61:
1910 GETBYTE ();
1911 switch (op[2] & 0xff)
1912 {
1913 case 0x00:
1914 GETBYTE ();
1915 switch (op[3] & 0x00)
1916 {
1917 case 0x00:
1918 goto op_semantics_7;
1919 break;
1920 }
1921 break;
1922 case 0x04:
1923 GETBYTE ();
1924 switch (op[3] & 0x00)
1925 {
1926 case 0x00:
1927 goto op_semantics_8;
1928 break;
1929 }
1930 break;
1931 case 0x05:
1932 GETBYTE ();
1933 switch (op[3] & 0x00)
1934 {
1935 case 0x00:
1936 goto op_semantics_9;
1937 break;
1938 }
1939 break;
1940 case 0x06:
1941 GETBYTE ();
1942 switch (op[3] & 0x00)
1943 {
1944 case 0x00:
1945 goto op_semantics_10;
1946 break;
1947 }
1948 break;
1949 case 0x07:
1950 GETBYTE ();
1951 switch (op[3] & 0x00)
1952 {
1953 case 0x00:
1954 goto op_semantics_11;
1955 break;
1956 }
1957 break;
1958 case 0x08:
1959 GETBYTE ();
1960 switch (op[3] & 0x00)
1961 {
1962 case 0x00:
1963 goto op_semantics_12;
1964 break;
1965 }
1966 break;
1967 case 0x09:
1968 GETBYTE ();
1969 switch (op[3] & 0x00)
1970 {
1971 case 0x00:
1972 goto op_semantics_13;
1973 break;
1974 }
1975 break;
1976 case 0x0c:
1977 GETBYTE ();
1978 switch (op[3] & 0x00)
1979 {
1980 case 0x00:
1981 goto op_semantics_14;
1982 break;
1983 }
1984 break;
1985 case 0x0d:
1986 GETBYTE ();
1987 switch (op[3] & 0x00)
1988 {
1989 case 0x00:
1990 goto op_semantics_15;
1991 break;
1992 }
1993 break;
1994 case 0x10:
1995 GETBYTE ();
1996 switch (op[3] & 0x00)
1997 {
1998 case 0x00:
1999 goto op_semantics_16;
2000 break;
2001 }
2002 break;
2003 case 0x11:
2004 GETBYTE ();
2005 switch (op[3] & 0x00)
2006 {
2007 case 0x00:
2008 goto op_semantics_17;
2009 break;
2010 }
2011 break;
a117b0a5
YS		 2012 case 0x15:
2013 GETBYTE ();
2014 switch (op[3] & 0x00)
2015 {
2016 case 0x00:
2017 goto op_semantics_18;
2018 break;
2019 }
2020 break;
c7927a3c
NC		 2021 default: UNSUPPORTED(); break;
2022 }
2023 break;
2024 case 0x62:
2025 GETBYTE ();
2026 switch (op[2] & 0xff)
2027 {
2028 case 0x00:
2029 GETBYTE ();
2030 switch (op[3] & 0x00)
2031 {
2032 case 0x00:
2033 goto op_semantics_7;
2034 break;
2035 }
2036 break;
2037 case 0x04:
2038 GETBYTE ();
2039 switch (op[3] & 0x00)
2040 {
2041 case 0x00:
2042 goto op_semantics_8;
2043 break;
2044 }
2045 break;
2046 case 0x05:
2047 GETBYTE ();
2048 switch (op[3] & 0x00)
2049 {
2050 case 0x00:
2051 goto op_semantics_9;
2052 break;
2053 }
2054 break;
2055 case 0x06:
2056 GETBYTE ();
2057 switch (op[3] & 0x00)
2058 {
2059 case 0x00:
2060 goto op_semantics_10;
2061 break;
2062 }
2063 break;
2064 case 0x07:
2065 GETBYTE ();
2066 switch (op[3] & 0x00)
2067 {
2068 case 0x00:
2069 goto op_semantics_11;
2070 break;
2071 }
2072 break;
2073 case 0x08:
2074 GETBYTE ();
2075 switch (op[3] & 0x00)
2076 {
2077 case 0x00:
2078 goto op_semantics_12;
2079 break;
2080 }
2081 break;
2082 case 0x09:
2083 GETBYTE ();
2084 switch (op[3] & 0x00)
2085 {
2086 case 0x00:
2087 goto op_semantics_13;
2088 break;
2089 }
2090 break;
2091 case 0x0c:
2092 GETBYTE ();
2093 switch (op[3] & 0x00)
2094 {
2095 case 0x00:
2096 goto op_semantics_14;
2097 break;
2098 }
2099 break;
2100 case 0x0d:
2101 GETBYTE ();
2102 switch (op[3] & 0x00)
2103 {
2104 case 0x00:
2105 goto op_semantics_15;
2106 break;
2107 }
2108 break;
2109 case 0x10:
2110 GETBYTE ();
2111 switch (op[3] & 0x00)
2112 {
2113 case 0x00:
2114 goto op_semantics_16;
2115 break;
2116 }
2117 break;
2118 case 0x11:
2119 GETBYTE ();
2120 switch (op[3] & 0x00)
2121 {
2122 case 0x00:
2123 goto op_semantics_17;
2124 break;
2125 }
2126 break;
a117b0a5
YS		 2127 case 0x15:
2128 GETBYTE ();
2129 switch (op[3] & 0x00)
2130 {
2131 case 0x00:
2132 goto op_semantics_18;
2133 break;
2134 }
2135 break;
c7927a3c
NC		 2136 default: UNSUPPORTED(); break;
2137 }
2138 break;
2139 case 0x63:
2140 GETBYTE ();
2141 switch (op[2] & 0xff)
2142 {
2143 case 0x00:
2144 GETBYTE ();
2145 switch (op[3] & 0x00)
2146 {
2147 case 0x00:
2148 goto op_semantics_7;
2149 break;
2150 }
2151 break;
2152 case 0x04:
2153 GETBYTE ();
2154 switch (op[3] & 0x00)
2155 {
2156 case 0x00:
2157 goto op_semantics_8;
2158 break;
2159 }
2160 break;
2161 case 0x05:
2162 GETBYTE ();
2163 switch (op[3] & 0x00)
2164 {
2165 case 0x00:
2166 goto op_semantics_9;
2167 break;
2168 }
2169 break;
2170 case 0x06:
2171 GETBYTE ();
2172 switch (op[3] & 0x00)
2173 {
2174 case 0x00:
2175 goto op_semantics_10;
2176 break;
2177 }
2178 break;
2179 case 0x07:
2180 GETBYTE ();
2181 switch (op[3] & 0x00)
2182 {
2183 case 0x00:
2184 goto op_semantics_11;
2185 break;
2186 }
2187 break;
2188 case 0x08:
2189 GETBYTE ();
2190 switch (op[3] & 0x00)
2191 {
2192 case 0x00:
2193 goto op_semantics_12;
2194 break;
2195 }
2196 break;
2197 case 0x09:
2198 GETBYTE ();
2199 switch (op[3] & 0x00)
2200 {
2201 case 0x00:
2202 goto op_semantics_13;
2203 break;
2204 }
2205 break;
2206 case 0x0c:
2207 GETBYTE ();
2208 switch (op[3] & 0x00)
2209 {
2210 case 0x00:
2211 goto op_semantics_14;
2212 break;
2213 }
2214 break;
2215 case 0x0d:
2216 GETBYTE ();
2217 switch (op[3] & 0x00)
2218 {
2219 case 0x00:
2220 goto op_semantics_15;
2221 break;
2222 }
2223 break;
2224 case 0x10:
2225 GETBYTE ();
2226 switch (op[3] & 0x00)
2227 {
2228 case 0x00:
2229 goto op_semantics_16;
2230 break;
2231 }
2232 break;
2233 case 0x11:
2234 GETBYTE ();
2235 switch (op[3] & 0x00)
2236 {
2237 case 0x00:
2238 goto op_semantics_17;
2239 break;
2240 }
2241 break;
a117b0a5
YS		 2242 case 0x15:
2243 GETBYTE ();
2244 switch (op[3] & 0x00)
2245 {
2246 case 0x00:
2247 goto op_semantics_18;
2248 break;
2249 }
2250 break;
c7927a3c
NC		 2251 default: UNSUPPORTED(); break;
2252 }
2253 break;
2254 case 0x80:
2255 GETBYTE ();
2256 switch (op[2] & 0x00)
2257 {
2258 case 0x00:
2259 goto op_semantics_1;
2260 break;
2261 }
2262 break;
2263 case 0x81:
2264 GETBYTE ();
2265 switch (op[2] & 0x00)
2266 {
2267 case 0x00:
2268 goto op_semantics_1;
2269 break;
2270 }
2271 break;
2272 case 0x82:
2273 GETBYTE ();
2274 switch (op[2] & 0x00)
2275 {
2276 case 0x00:
2277 goto op_semantics_1;
2278 break;
2279 }
2280 break;
2281 case 0x83:
2282 GETBYTE ();
2283 switch (op[2] & 0x00)
2284 {
2285 case 0x00:
2286 goto op_semantics_1;
2287 break;
2288 }
2289 break;
2290 case 0x84:
2291 GETBYTE ();
2292 switch (op[2] & 0x00)
2293 {
2294 case 0x00:
2295 goto op_semantics_2;
2296 break;
2297 }
2298 break;
2299 case 0x85:
2300 GETBYTE ();
2301 switch (op[2] & 0x00)
2302 {
2303 case 0x00:
2304 goto op_semantics_2;
2305 break;
2306 }
2307 break;
2308 case 0x86:
2309 GETBYTE ();
2310 switch (op[2] & 0x00)
2311 {
2312 case 0x00:
2313 goto op_semantics_2;
2314 break;
2315 }
2316 break;
2317 case 0x87:
2318 GETBYTE ();
2319 switch (op[2] & 0x00)
2320 {
2321 case 0x00:
2322 goto op_semantics_2;
2323 break;
2324 }
2325 break;
2326 case 0x88:
2327 GETBYTE ();
2328 switch (op[2] & 0x00)
2329 {
2330 case 0x00:
2331 goto op_semantics_3;
2332 break;
2333 }
2334 break;
2335 case 0x89:
2336 GETBYTE ();
2337 switch (op[2] & 0x00)
2338 {
2339 case 0x00:
2340 goto op_semantics_3;
2341 break;
2342 }
2343 break;
2344 case 0x8a:
2345 GETBYTE ();
2346 switch (op[2] & 0x00)
2347 {
2348 case 0x00:
2349 goto op_semantics_3;
2350 break;
2351 }
2352 break;
2353 case 0x8b:
2354 GETBYTE ();
2355 switch (op[2] & 0x00)
2356 {
2357 case 0x00:
2358 goto op_semantics_3;
2359 break;
2360 }
2361 break;
2362 case 0x8c:
2363 GETBYTE ();
2364 switch (op[2] & 0x00)
2365 {
2366 case 0x00:
2367 goto op_semantics_4;
2368 break;
2369 }
2370 break;
2371 case 0x8d:
2372 GETBYTE ();
2373 switch (op[2] & 0x00)
2374 {
2375 case 0x00:
2376 goto op_semantics_4;
2377 break;
2378 }
2379 break;
2380 case 0x8e:
2381 GETBYTE ();
2382 switch (op[2] & 0x00)
2383 {
2384 case 0x00:
2385 goto op_semantics_4;
2386 break;
2387 }
2388 break;
2389 case 0x8f:
2390 GETBYTE ();
2391 switch (op[2] & 0x00)
2392 {
2393 case 0x00:
2394 goto op_semantics_4;
2395 break;
2396 }
2397 break;
2398 case 0x90:
2399 GETBYTE ();
2400 switch (op[2] & 0x00)
2401 {
2402 case 0x00:
2403 goto op_semantics_5;
2404 break;
2405 }
2406 break;
2407 case 0x91:
2408 GETBYTE ();
2409 switch (op[2] & 0x00)
2410 {
2411 case 0x00:
2412 goto op_semantics_5;
2413 break;
2414 }
2415 break;
2416 case 0x92:
2417 GETBYTE ();
2418 switch (op[2] & 0x00)
2419 {
2420 case 0x00:
2421 goto op_semantics_5;
2422 break;
2423 }
2424 break;
2425 case 0x93:
2426 GETBYTE ();
2427 switch (op[2] & 0x00)
2428 {
2429 case 0x00:
2430 goto op_semantics_5;
2431 break;
2432 }
2433 break;
2434 case 0x94:
2435 GETBYTE ();
2436 switch (op[2] & 0x00)
2437 {
2438 case 0x00:
2439 goto op_semantics_6;
2440 break;
2441 }
2442 break;
2443 case 0x95:
2444 GETBYTE ();
2445 switch (op[2] & 0x00)
2446 {
2447 case 0x00:
2448 goto op_semantics_6;
2449 break;
2450 }
2451 break;
2452 case 0x96:
2453 GETBYTE ();
2454 switch (op[2] & 0x00)
2455 {
2456 case 0x00:
2457 goto op_semantics_6;
2458 break;
2459 }
2460 break;
2461 case 0x97:
2462 GETBYTE ();
2463 switch (op[2] & 0x00)
2464 {
2465 case 0x00:
2466 goto op_semantics_6;
2467 break;
2468 }
2469 break;
2470 case 0xa0:
2471 GETBYTE ();
2472 switch (op[2] & 0xff)
2473 {
2474 case 0x00:
2475 GETBYTE ();
2476 switch (op[3] & 0x00)
2477 {
2478 case 0x00:
2479 goto op_semantics_7;
2480 break;
2481 }
2482 break;
2483 case 0x02:
2484 GETBYTE ();
2485 switch (op[3] & 0x00)
2486 {
2487 case 0x00:
a117b0a5 2488 op_semantics_19:
c7927a3c
NC		 2489 {
2490 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
4ce8c66d 2491#line 519 "rx-decode.opc"
c7927a3c 2492 int ss AU = op[1] & 0x03;
4ce8c66d 2493#line 519 "rx-decode.opc"
c7927a3c 2494 int rsrc AU = (op[3] >> 4) & 0x0f;
4ce8c66d 2495#line 519 "rx-decode.opc"
c7927a3c
NC		 2496 int rdst AU = op[3] & 0x0f;
2497 if (trace)
2498 {
2499 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2500 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2501 op[0], op[1], op[2], op[3]);
2502 printf (" ss = 0x%x,", ss);
2503 printf (" rsrc = 0x%x,", rsrc);
2504 printf (" rdst = 0x%x\n", rdst);
2505 }
2506 SYNTAX("adc %1%S1, %0");
4ce8c66d 2507#line 519 "rx-decode.opc"
3cf79a01 2508 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
43e65147 2509
c7927a3c
NC		 2510 /*----------------------------------------------------------------------*/
2511 /* ADD */
43e65147 2512
c7927a3c
NC		 2513 }
2514 break;
2515 }
2516 break;
2517 case 0x04:
2518 GETBYTE ();
2519 switch (op[3] & 0x00)
2520 {
2521 case 0x00:
2522 goto op_semantics_8;
2523 break;
2524 }
2525 break;
2526 case 0x05:
2527 GETBYTE ();
2528 switch (op[3] & 0x00)
2529 {
2530 case 0x00:
2531 goto op_semantics_9;
2532 break;
2533 }
2534 break;
2535 case 0x06:
2536 GETBYTE ();
2537 switch (op[3] & 0x00)
2538 {
2539 case 0x00:
2540 goto op_semantics_10;
2541 break;
2542 }
2543 break;
2544 case 0x07:
2545 GETBYTE ();
2546 switch (op[3] & 0x00)
2547 {
2548 case 0x00:
2549 goto op_semantics_11;
2550 break;
2551 }
2552 break;
2553 case 0x08:
2554 GETBYTE ();
2555 switch (op[3] & 0x00)
2556 {
2557 case 0x00:
2558 goto op_semantics_12;
2559 break;
2560 }
2561 break;
2562 case 0x09:
2563 GETBYTE ();
2564 switch (op[3] & 0x00)
2565 {
2566 case 0x00:
2567 goto op_semantics_13;
2568 break;
2569 }
2570 break;
2571 case 0x0c:
2572 GETBYTE ();
2573 switch (op[3] & 0x00)
2574 {
2575 case 0x00:
2576 goto op_semantics_14;
2577 break;
2578 }
2579 break;
2580 case 0x0d:
2581 GETBYTE ();
2582 switch (op[3] & 0x00)
2583 {
2584 case 0x00:
2585 goto op_semantics_15;
2586 break;
2587 }
2588 break;
2589 case 0x10:
2590 GETBYTE ();
2591 switch (op[3] & 0x00)
2592 {
2593 case 0x00:
2594 goto op_semantics_16;
2595 break;
2596 }
2597 break;
2598 case 0x11:
2599 GETBYTE ();
2600 switch (op[3] & 0x00)
2601 {
2602 case 0x00:
2603 goto op_semantics_17;
2604 break;
2605 }
2606 break;
a117b0a5
YS		 2607 case 0x15:
2608 GETBYTE ();
2609 switch (op[3] & 0x00)
2610 {
2611 case 0x00:
2612 goto op_semantics_18;
2613 break;
2614 }
2615 break;
c7927a3c
NC		 2616 default: UNSUPPORTED(); break;
2617 }
2618 break;
2619 case 0xa1:
2620 GETBYTE ();
2621 switch (op[2] & 0xff)
2622 {
2623 case 0x00:
2624 GETBYTE ();
2625 switch (op[3] & 0x00)
2626 {
2627 case 0x00:
2628 goto op_semantics_7;
2629 break;
2630 }
2631 break;
2632 case 0x02:
2633 GETBYTE ();
2634 switch (op[3] & 0x00)
2635 {
2636 case 0x00:
a117b0a5 2637 goto op_semantics_19;
c7927a3c
NC		 2638 break;
2639 }
2640 break;
2641 case 0x04:
2642 GETBYTE ();
2643 switch (op[3] & 0x00)
2644 {
2645 case 0x00:
2646 goto op_semantics_8;
2647 break;
2648 }
2649 break;
2650 case 0x05:
2651 GETBYTE ();
2652 switch (op[3] & 0x00)
2653 {
2654 case 0x00:
2655 goto op_semantics_9;
2656 break;
2657 }
2658 break;
2659 case 0x06:
2660 GETBYTE ();
2661 switch (op[3] & 0x00)
2662 {
2663 case 0x00:
2664 goto op_semantics_10;
2665 break;
2666 }
2667 break;
2668 case 0x07:
2669 GETBYTE ();
2670 switch (op[3] & 0x00)
2671 {
2672 case 0x00:
2673 goto op_semantics_11;
2674 break;
2675 }
2676 break;
2677 case 0x08:
2678 GETBYTE ();
2679 switch (op[3] & 0x00)
2680 {
2681 case 0x00:
2682 goto op_semantics_12;
2683 break;
2684 }
2685 break;
2686 case 0x09:
2687 GETBYTE ();
2688 switch (op[3] & 0x00)
2689 {
2690 case 0x00:
2691 goto op_semantics_13;
2692 break;
2693 }
2694 break;
2695 case 0x0c:
2696 GETBYTE ();
2697 switch (op[3] & 0x00)
2698 {
2699 case 0x00:
2700 goto op_semantics_14;
2701 break;
2702 }
2703 break;
2704 case 0x0d:
2705 GETBYTE ();
2706 switch (op[3] & 0x00)
2707 {
2708 case 0x00:
2709 goto op_semantics_15;
2710 break;
2711 }
2712 break;
2713 case 0x10:
2714 GETBYTE ();
2715 switch (op[3] & 0x00)
2716 {
2717 case 0x00:
2718 goto op_semantics_16;
2719 break;
2720 }
2721 break;
2722 case 0x11:
2723 GETBYTE ();
2724 switch (op[3] & 0x00)
2725 {
2726 case 0x00:
2727 goto op_semantics_17;
2728 break;
2729 }
2730 break;
a117b0a5
YS		 2731 case 0x15:
2732 GETBYTE ();
2733 switch (op[3] & 0x00)
2734 {
2735 case 0x00:
2736 goto op_semantics_18;
2737 break;
2738 }
2739 break;
c7927a3c
NC		 2740 default: UNSUPPORTED(); break;
2741 }
2742 break;
2743 case 0xa2:
2744 GETBYTE ();
2745 switch (op[2] & 0xff)
2746 {
2747 case 0x00:
2748 GETBYTE ();
2749 switch (op[3] & 0x00)
2750 {
2751 case 0x00:
2752 goto op_semantics_7;
2753 break;
2754 }
2755 break;
2756 case 0x02:
2757 GETBYTE ();
2758 switch (op[3] & 0x00)
2759 {
2760 case 0x00:
a117b0a5 2761 goto op_semantics_19;
c7927a3c
NC		 2762 break;
2763 }
2764 break;
2765 case 0x04:
2766 GETBYTE ();
2767 switch (op[3] & 0x00)
2768 {
2769 case 0x00:
2770 goto op_semantics_8;
2771 break;
2772 }
2773 break;
2774 case 0x05:
2775 GETBYTE ();
2776 switch (op[3] & 0x00)
2777 {
2778 case 0x00:
2779 goto op_semantics_9;
2780 break;
2781 }
2782 break;
2783 case 0x06:
2784 GETBYTE ();
2785 switch (op[3] & 0x00)
2786 {
2787 case 0x00:
2788 goto op_semantics_10;
2789 break;
2790 }
2791 break;
2792 case 0x07:
2793 GETBYTE ();
2794 switch (op[3] & 0x00)
2795 {
2796 case 0x00:
2797 goto op_semantics_11;
2798 break;
2799 }
2800 break;
2801 case 0x08:
2802 GETBYTE ();
2803 switch (op[3] & 0x00)
2804 {
2805 case 0x00:
2806 goto op_semantics_12;
2807 break;
2808 }
2809 break;
2810 case 0x09:
2811 GETBYTE ();
2812 switch (op[3] & 0x00)
2813 {
2814 case 0x00:
2815 goto op_semantics_13;
2816 break;
2817 }
2818 break;
2819 case 0x0c:
2820 GETBYTE ();
2821 switch (op[3] & 0x00)
2822 {
2823 case 0x00:
2824 goto op_semantics_14;
2825 break;
2826 }
2827 break;
2828 case 0x0d:
2829 GETBYTE ();
2830 switch (op[3] & 0x00)
2831 {
2832 case 0x00:
2833 goto op_semantics_15;
2834 break;
2835 }
2836 break;
2837 case 0x10:
2838 GETBYTE ();
2839 switch (op[3] & 0x00)
2840 {
2841 case 0x00:
2842 goto op_semantics_16;
2843 break;
2844 }
2845 break;
2846 case 0x11:
2847 GETBYTE ();
2848 switch (op[3] & 0x00)
2849 {
2850 case 0x00:
2851 goto op_semantics_17;
2852 break;
2853 }
2854 break;
a117b0a5
YS		 2855 case 0x15:
2856 GETBYTE ();
2857 switch (op[3] & 0x00)
2858 {
2859 case 0x00:
2860 goto op_semantics_18;
2861 break;
2862 }
2863 break;
c7927a3c
NC		 2864 default: UNSUPPORTED(); break;
2865 }
2866 break;
2867 case 0xa3:
2868 GETBYTE ();
2869 switch (op[2] & 0xff)
2870 {
2871 case 0x00:
2872 GETBYTE ();
2873 switch (op[3] & 0x00)
2874 {
2875 case 0x00:
2876 goto op_semantics_7;
2877 break;
2878 }
2879 break;
2880 case 0x02:
2881 GETBYTE ();
2882 switch (op[3] & 0x00)
2883 {
2884 case 0x00:
a117b0a5 2885 goto op_semantics_19;
c7927a3c
NC		 2886 break;
2887 }
2888 break;
2889 case 0x04:
2890 GETBYTE ();
2891 switch (op[3] & 0x00)
2892 {
2893 case 0x00:
2894 goto op_semantics_8;
2895 break;
2896 }
2897 break;
2898 case 0x05:
2899 GETBYTE ();
2900 switch (op[3] & 0x00)
2901 {
2902 case 0x00:
2903 goto op_semantics_9;
2904 break;
2905 }
2906 break;
2907 case 0x06:
2908 GETBYTE ();
2909 switch (op[3] & 0x00)
2910 {
2911 case 0x00:
2912 goto op_semantics_10;
2913 break;
2914 }
2915 break;
2916 case 0x07:
2917 GETBYTE ();
2918 switch (op[3] & 0x00)
2919 {
2920 case 0x00:
2921 goto op_semantics_11;
2922 break;
2923 }
2924 break;
2925 case 0x08:
2926 GETBYTE ();
2927 switch (op[3] & 0x00)
2928 {
2929 case 0x00:
2930 goto op_semantics_12;
2931 break;
2932 }
2933 break;
2934 case 0x09:
2935 GETBYTE ();
2936 switch (op[3] & 0x00)
2937 {
2938 case 0x00:
2939 goto op_semantics_13;
2940 break;
2941 }
2942 break;
2943 case 0x0c:
2944 GETBYTE ();
2945 switch (op[3] & 0x00)
2946 {
2947 case 0x00:
2948 goto op_semantics_14;
2949 break;
2950 }
2951 break;
2952 case 0x0d:
2953 GETBYTE ();
2954 switch (op[3] & 0x00)
2955 {
2956 case 0x00:
2957 goto op_semantics_15;
2958 break;
2959 }
2960 break;
2961 case 0x10:
2962 GETBYTE ();
2963 switch (op[3] & 0x00)
2964 {
2965 case 0x00:
2966 goto op_semantics_16;
2967 break;
2968 }
2969 break;
2970 case 0x11:
2971 GETBYTE ();
2972 switch (op[3] & 0x00)
2973 {
2974 case 0x00:
2975 goto op_semantics_17;
2976 break;
2977 }
2978 break;
a117b0a5
YS		 2979 case 0x15:
2980 GETBYTE ();
2981 switch (op[3] & 0x00)
2982 {
2983 case 0x00:
2984 goto op_semantics_18;
2985 break;
2986 }
2987 break;
c7927a3c
NC		 2988 default: UNSUPPORTED(); break;
2989 }
2990 break;
2991 case 0xc0:
2992 GETBYTE ();
2993 switch (op[2] & 0x00)
2994 {
2995 case 0x00:
2996 goto op_semantics_1;
2997 break;
2998 }
2999 break;
3000 case 0xc1:
3001 GETBYTE ();
3002 switch (op[2] & 0x00)
3003 {
3004 case 0x00:
3005 goto op_semantics_1;
3006 break;
3007 }
3008 break;
3009 case 0xc2:
3010 GETBYTE ();
3011 switch (op[2] & 0x00)
3012 {
3013 case 0x00:
3014 goto op_semantics_1;
3015 break;
3016 }
3017 break;
3018 case 0xc3:
3019 GETBYTE ();
3020 switch (op[2] & 0x00)
3021 {
3022 case 0x00:
3023 goto op_semantics_1;
3024 break;
3025 }
3026 break;
3027 case 0xc4:
3028 GETBYTE ();
3029 switch (op[2] & 0x00)
3030 {
3031 case 0x00:
3032 goto op_semantics_2;
3033 break;
3034 }
3035 break;
3036 case 0xc5:
3037 GETBYTE ();
3038 switch (op[2] & 0x00)
3039 {
3040 case 0x00:
3041 goto op_semantics_2;
3042 break;
3043 }
3044 break;
3045 case 0xc6:
3046 GETBYTE ();
3047 switch (op[2] & 0x00)
3048 {
3049 case 0x00:
3050 goto op_semantics_2;
3051 break;
3052 }
3053 break;
3054 case 0xc7:
3055 GETBYTE ();
3056 switch (op[2] & 0x00)
3057 {
3058 case 0x00:
3059 goto op_semantics_2;
3060 break;
3061 }
3062 break;
3063 case 0xc8:
3064 GETBYTE ();
3065 switch (op[2] & 0x00)
3066 {
3067 case 0x00:
3068 goto op_semantics_3;
3069 break;
3070 }
3071 break;
3072 case 0xc9:
3073 GETBYTE ();
3074 switch (op[2] & 0x00)
3075 {
3076 case 0x00:
3077 goto op_semantics_3;
3078 break;
3079 }
3080 break;
3081 case 0xca:
3082 GETBYTE ();
3083 switch (op[2] & 0x00)
3084 {
3085 case 0x00:
3086 goto op_semantics_3;
3087 break;
3088 }
3089 break;
3090 case 0xcb:
3091 GETBYTE ();
3092 switch (op[2] & 0x00)
3093 {
3094 case 0x00:
3095 goto op_semantics_3;
3096 break;
3097 }
3098 break;
3099 case 0xcc:
3100 GETBYTE ();
3101 switch (op[2] & 0x00)
3102 {
3103 case 0x00:
3104 goto op_semantics_4;
3105 break;
3106 }
3107 break;
3108 case 0xcd:
3109 GETBYTE ();
3110 switch (op[2] & 0x00)
3111 {
3112 case 0x00:
3113 goto op_semantics_4;
3114 break;
3115 }
3116 break;
3117 case 0xce:
3118 GETBYTE ();
3119 switch (op[2] & 0x00)
3120 {
3121 case 0x00:
3122 goto op_semantics_4;
3123 break;
3124 }
3125 break;
3126 case 0xcf:
3127 GETBYTE ();
3128 switch (op[2] & 0x00)
3129 {
3130 case 0x00:
3131 goto op_semantics_4;
3132 break;
3133 }
3134 break;
3135 case 0xd0:
3136 GETBYTE ();
3137 switch (op[2] & 0x00)
3138 {
3139 case 0x00:
3140 goto op_semantics_5;
3141 break;
3142 }
3143 break;
3144 case 0xd1:
3145 GETBYTE ();
3146 switch (op[2] & 0x00)
3147 {
3148 case 0x00:
3149 goto op_semantics_5;
3150 break;
3151 }
3152 break;
3153 case 0xd2:
3154 GETBYTE ();
3155 switch (op[2] & 0x00)
3156 {
3157 case 0x00:
3158 goto op_semantics_5;
3159 break;
3160 }
3161 break;
3162 case 0xd3:
3163 GETBYTE ();
3164 switch (op[2] & 0x00)
3165 {
3166 case 0x00:
3167 goto op_semantics_5;
3168 break;
3169 }
3170 break;
3171 case 0xd4:
3172 GETBYTE ();
3173 switch (op[2] & 0x00)
3174 {
3175 case 0x00:
3176 goto op_semantics_6;
3177 break;
3178 }
3179 break;
3180 case 0xd5:
3181 GETBYTE ();
3182 switch (op[2] & 0x00)
3183 {
3184 case 0x00:
3185 goto op_semantics_6;
3186 break;
3187 }
3188 break;
3189 case 0xd6:
3190 GETBYTE ();
3191 switch (op[2] & 0x00)
3192 {
3193 case 0x00:
3194 goto op_semantics_6;
3195 break;
3196 }
3197 break;
3198 case 0xd7:
3199 GETBYTE ();
3200 switch (op[2] & 0x00)
3201 {
3202 case 0x00:
3203 goto op_semantics_6;
3204 break;
3205 }
3206 break;
3207 case 0xe0:
3208 GETBYTE ();
3209 switch (op[2] & 0xff)
3210 {
3211 case 0x00:
3212 GETBYTE ();
3213 switch (op[3] & 0x00)
3214 {
3215 case 0x00:
3216 goto op_semantics_7;
3217 break;
3218 }
3219 break;
3220 case 0x04:
3221 GETBYTE ();
3222 switch (op[3] & 0x00)
3223 {
3224 case 0x00:
3225 goto op_semantics_8;
3226 break;
3227 }
3228 break;
3229 case 0x05:
3230 GETBYTE ();
3231 switch (op[3] & 0x00)
3232 {
3233 case 0x00:
3234 goto op_semantics_9;
3235 break;
3236 }
3237 break;
3238 case 0x06:
3239 GETBYTE ();
3240 switch (op[3] & 0x00)
3241 {
3242 case 0x00:
3243 goto op_semantics_10;
3244 break;
3245 }
3246 break;
3247 case 0x07:
3248 GETBYTE ();
3249 switch (op[3] & 0x00)
3250 {
3251 case 0x00:
3252 goto op_semantics_11;
3253 break;
3254 }
3255 break;
3256 case 0x08:
3257 GETBYTE ();
3258 switch (op[3] & 0x00)
3259 {
3260 case 0x00:
3261 goto op_semantics_12;
3262 break;
3263 }
3264 break;
3265 case 0x09:
3266 GETBYTE ();
3267 switch (op[3] & 0x00)
3268 {
3269 case 0x00:
3270 goto op_semantics_13;
3271 break;
3272 }
3273 break;
3274 case 0x0c:
3275 GETBYTE ();
3276 switch (op[3] & 0x00)
3277 {
3278 case 0x00:
3279 goto op_semantics_14;
3280 break;
3281 }
3282 break;
3283 case 0x0d:
3284 GETBYTE ();
3285 switch (op[3] & 0x00)
3286 {
3287 case 0x00:
3288 goto op_semantics_15;
3289 break;
3290 }
3291 break;
3292 case 0x10:
3293 GETBYTE ();
3294 switch (op[3] & 0x00)
3295 {
3296 case 0x00:
3297 goto op_semantics_16;
3298 break;
3299 }
3300 break;
3301 case 0x11:
3302 GETBYTE ();
3303 switch (op[3] & 0x00)
3304 {
3305 case 0x00:
3306 goto op_semantics_17;
3307 break;
3308 }
3309 break;
a117b0a5
YS		 3310 case 0x15:
3311 GETBYTE ();
3312 switch (op[3] & 0x00)
3313 {
3314 case 0x00:
3315 goto op_semantics_18;
3316 break;
3317 }
3318 break;
c7927a3c
NC		 3319 default: UNSUPPORTED(); break;
3320 }
3321 break;
3322 case 0xe1:
3323 GETBYTE ();
3324 switch (op[2] & 0xff)
3325 {
3326 case 0x00:
3327 GETBYTE ();
3328 switch (op[3] & 0x00)
3329 {
3330 case 0x00:
3331 goto op_semantics_7;
3332 break;
3333 }
3334 break;
3335 case 0x04:
3336 GETBYTE ();
3337 switch (op[3] & 0x00)
3338 {
3339 case 0x00:
3340 goto op_semantics_8;
3341 break;
3342 }
3343 break;
3344 case 0x05:
3345 GETBYTE ();
3346 switch (op[3] & 0x00)
3347 {
3348 case 0x00:
3349 goto op_semantics_9;
3350 break;
3351 }
3352 break;
3353 case 0x06:
3354 GETBYTE ();
3355 switch (op[3] & 0x00)
3356 {
3357 case 0x00:
3358 goto op_semantics_10;
3359 break;
3360 }
3361 break;
3362 case 0x07:
3363 GETBYTE ();
3364 switch (op[3] & 0x00)
3365 {
3366 case 0x00:
3367 goto op_semantics_11;
3368 break;
3369 }
3370 break;
3371 case 0x08:
3372 GETBYTE ();
3373 switch (op[3] & 0x00)
3374 {
3375 case 0x00:
3376 goto op_semantics_12;
3377 break;
3378 }
3379 break;
3380 case 0x09:
3381 GETBYTE ();
3382 switch (op[3] & 0x00)
3383 {
3384 case 0x00:
3385 goto op_semantics_13;
3386 break;
3387 }
3388 break;
3389 case 0x0c:
3390 GETBYTE ();
3391 switch (op[3] & 0x00)
3392 {
3393 case 0x00:
3394 goto op_semantics_14;
3395 break;
3396 }
3397 break;
3398 case 0x0d:
3399 GETBYTE ();
3400 switch (op[3] & 0x00)
3401 {
3402 case 0x00:
3403 goto op_semantics_15;
3404 break;
3405 }
3406 break;
3407 case 0x10:
3408 GETBYTE ();
3409 switch (op[3] & 0x00)
3410 {
3411 case 0x00:
3412 goto op_semantics_16;
3413 break;
3414 }
3415 break;
3416 case 0x11:
3417 GETBYTE ();
3418 switch (op[3] & 0x00)
3419 {
3420 case 0x00:
3421 goto op_semantics_17;
3422 break;
3423 }
3424 break;
a117b0a5
YS		 3425 case 0x15:
3426 GETBYTE ();
3427 switch (op[3] & 0x00)
3428 {
3429 case 0x00:
3430 goto op_semantics_18;
3431 break;
3432 }
3433 break;
c7927a3c
NC		 3434 default: UNSUPPORTED(); break;
3435 }
3436 break;
3437 case 0xe2:
3438 GETBYTE ();
3439 switch (op[2] & 0xff)
3440 {
3441 case 0x00:
3442 GETBYTE ();
3443 switch (op[3] & 0x00)
3444 {
3445 case 0x00:
3446 goto op_semantics_7;
3447 break;
3448 }
3449 break;
3450 case 0x04:
3451 GETBYTE ();
3452 switch (op[3] & 0x00)
3453 {
3454 case 0x00:
3455 goto op_semantics_8;
3456 break;
3457 }
3458 break;
3459 case 0x05:
3460 GETBYTE ();
3461 switch (op[3] & 0x00)
3462 {
3463 case 0x00:
3464 goto op_semantics_9;
3465 break;
3466 }
3467 break;
3468 case 0x06:
3469 GETBYTE ();
3470 switch (op[3] & 0x00)
3471 {
3472 case 0x00:
3473 goto op_semantics_10;
3474 break;
3475 }
3476 break;
3477 case 0x07:
3478 GETBYTE ();
3479 switch (op[3] & 0x00)
3480 {
3481 case 0x00:
3482 goto op_semantics_11;
3483 break;
3484 }
3485 break;
3486 case 0x08:
3487 GETBYTE ();
3488 switch (op[3] & 0x00)
3489 {
3490 case 0x00:
3491 goto op_semantics_12;
3492 break;
3493 }
3494 break;
3495 case 0x09:
3496 GETBYTE ();
3497 switch (op[3] & 0x00)
3498 {
3499 case 0x00:
3500 goto op_semantics_13;
3501 break;
3502 }
3503 break;
3504 case 0x0c:
3505 GETBYTE ();
3506 switch (op[3] & 0x00)
3507 {
3508 case 0x00:
3509 goto op_semantics_14;
3510 break;
3511 }
3512 break;
3513 case 0x0d:
3514 GETBYTE ();
3515 switch (op[3] & 0x00)
3516 {
3517 case 0x00:
3518 goto op_semantics_15;
3519 break;
3520 }
3521 break;
3522 case 0x10:
3523 GETBYTE ();
3524 switch (op[3] & 0x00)
3525 {
3526 case 0x00:
3527 goto op_semantics_16;
3528 break;
3529 }
3530 break;
3531 case 0x11:
3532 GETBYTE ();
3533 switch (op[3] & 0x00)
3534 {
3535 case 0x00:
3536 goto op_semantics_17;
3537 break;
3538 }
3539 break;
a117b0a5
YS		 3540 case 0x15:
3541 GETBYTE ();
3542 switch (op[3] & 0x00)
3543 {
3544 case 0x00:
3545 goto op_semantics_18;
3546 break;
3547 }
3548 break;
c7927a3c
NC		 3549 default: UNSUPPORTED(); break;
3550 }
3551 break;
3552 case 0xe3:
3553 GETBYTE ();
3554 switch (op[2] & 0xff)
3555 {
3556 case 0x00:
3557 GETBYTE ();
3558 switch (op[3] & 0x00)
3559 {
3560 case 0x00:
3561 goto op_semantics_7;
3562 break;
3563 }
3564 break;
3565 case 0x04:
3566 GETBYTE ();
3567 switch (op[3] & 0x00)
3568 {
3569 case 0x00:
3570 goto op_semantics_8;
3571 break;
3572 }
3573 break;
3574 case 0x05:
3575 GETBYTE ();
3576 switch (op[3] & 0x00)
3577 {
3578 case 0x00:
3579 goto op_semantics_9;
3580 break;
3581 }
3582 break;
3583 case 0x06:
3584 GETBYTE ();
3585 switch (op[3] & 0x00)
3586 {
3587 case 0x00:
3588 goto op_semantics_10;
3589 break;
3590 }
3591 break;
3592 case 0x07:
3593 GETBYTE ();
3594 switch (op[3] & 0x00)
3595 {
3596 case 0x00:
3597 goto op_semantics_11;
3598 break;
3599 }
3600 break;
3601 case 0x08:
3602 GETBYTE ();
3603 switch (op[3] & 0x00)
3604 {
3605 case 0x00:
3606 goto op_semantics_12;
3607 break;
3608 }
3609 break;
3610 case 0x09:
3611 GETBYTE ();
3612 switch (op[3] & 0x00)
3613 {
3614 case 0x00:
3615 goto op_semantics_13;
3616 break;
3617 }
3618 break;
3619 case 0x0c:
3620 GETBYTE ();
3621 switch (op[3] & 0x00)
3622 {
3623 case 0x00:
3624 goto op_semantics_14;
3625 break;
3626 }
3627 break;
3628 case 0x0d:
3629 GETBYTE ();
3630 switch (op[3] & 0x00)
3631 {
3632 case 0x00:
3633 goto op_semantics_15;
3634 break;
3635 }
3636 break;
3637 case 0x10:
3638 GETBYTE ();
3639 switch (op[3] & 0x00)
3640 {
3641 case 0x00:
3642 goto op_semantics_16;
3643 break;
3644 }
3645 break;
3646 case 0x11:
3647 GETBYTE ();
3648 switch (op[3] & 0x00)
3649 {
3650 case 0x00:
3651 goto op_semantics_17;
3652 break;
3653 }
3654 break;
a117b0a5
YS		 3655 case 0x15:
3656 GETBYTE ();
3657 switch (op[3] & 0x00)
3658 {
3659 case 0x00:
3660 goto op_semantics_18;
3661 break;
3662 }
3663 break;
c7927a3c
NC		 3664 default: UNSUPPORTED(); break;
3665 }
3666 break;
3667 default: UNSUPPORTED(); break;
3668 }
3669 break;
3670 case 0x08:
3671 case 0x09:
3672 case 0x0a:
3673 case 0x0b:
3674 case 0x0c:
3675 case 0x0d:
3676 case 0x0e:
3677 case 0x0f:
3678 {
3679 /** 0000 1dsp bra.s %a0 */
4ce8c66d 3680#line 800 "rx-decode.opc"
c7927a3c
NC		 3681 int dsp AU = op[0] & 0x07;
3682 if (trace)
3683 {
3684 printf ("\033[33m%s\033[0m %02x\n",
3685 "/** 0000 1dsp bra.s %a0 */",
3686 op[0]);
3687 printf (" dsp = 0x%x\n", dsp);
3688 }
3689 SYNTAX("bra.s %a0");
4ce8c66d 3690#line 800 "rx-decode.opc"
f9c7014e 3691 ID(branch); DC(pc + dsp3map[dsp]);
43e65147 3692
c7927a3c
NC		 3693 }
3694 break;
3695 case 0x10:
3696 case 0x11:
3697 case 0x12:
3698 case 0x13:
3699 case 0x14:
3700 case 0x15:
3701 case 0x16:
3702 case 0x17:
3703 case 0x18:
3704 case 0x19:
3705 case 0x1a:
3706 case 0x1b:
3707 case 0x1c:
3708 case 0x1d:
3709 case 0x1e:
3710 case 0x1f:
3711 {
3712 /** 0001 n dsp b%1.s %a0 */
4ce8c66d 3713#line 790 "rx-decode.opc"
c7927a3c 3714 int n AU = (op[0] >> 3) & 0x01;
4ce8c66d 3715#line 790 "rx-decode.opc"
c7927a3c
NC		 3716 int dsp AU = op[0] & 0x07;
3717 if (trace)
3718 {
3719 printf ("\033[33m%s\033[0m %02x\n",
3720 "/** 0001 n dsp b%1.s %a0 */",
3721 op[0]);
3722 printf (" n = 0x%x,", n);
3723 printf (" dsp = 0x%x\n", dsp);
3724 }
3725 SYNTAX("b%1.s %a0");
4ce8c66d 3726#line 790 "rx-decode.opc"
c7927a3c 3727 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
43e65147 3728
c7927a3c
NC		 3729 }
3730 break;
3731 case 0x20:
3732 case 0x21:
3733 case 0x22:
3734 case 0x23:
3735 case 0x24:
3736 case 0x25:
3737 case 0x26:
3738 case 0x27:
3739 case 0x28:
3740 case 0x29:
3741 case 0x2a:
3742 case 0x2b:
3743 case 0x2c:
3744 case 0x2d:
3745 case 0x2f:
3746 {
3747 /** 0010 cond b%1.b %a0 */
4ce8c66d 3748#line 793 "rx-decode.opc"
c7927a3c
NC		 3749 int cond AU = op[0] & 0x0f;
3750 if (trace)
3751 {
3752 printf ("\033[33m%s\033[0m %02x\n",
3753 "/** 0010 cond b%1.b %a0 */",
3754 op[0]);
3755 printf (" cond = 0x%x\n", cond);
3756 }
3757 SYNTAX("b%1.b %a0");
4ce8c66d 3758#line 793 "rx-decode.opc"
c7927a3c 3759 ID(branch); Scc(cond); DC(pc + IMMex (1));
43e65147 3760
c7927a3c
NC		 3761 }
3762 break;
3763 case 0x2e:
3764 {
3765 /** 0010 1110 bra.b %a0 */
3766 if (trace)
3767 {
3768 printf ("\033[33m%s\033[0m %02x\n",
3769 "/** 0010 1110 bra.b %a0 */",
3770 op[0]);
3771 }
3772 SYNTAX("bra.b %a0");
4ce8c66d 3773#line 803 "rx-decode.opc"
f9c7014e 3774 ID(branch); DC(pc + IMMex(1));
43e65147 3775
c7927a3c
NC		 3776 }
3777 break;
3778 case 0x38:
3779 {
3780 /** 0011 1000 bra.w %a0 */
3781 if (trace)
3782 {
3783 printf ("\033[33m%s\033[0m %02x\n",
3784 "/** 0011 1000 bra.w %a0 */",
3785 op[0]);
3786 }
3787 SYNTAX("bra.w %a0");
4ce8c66d 3788#line 806 "rx-decode.opc"
f9c7014e 3789 ID(branch); DC(pc + IMMex(2));
43e65147 3790
c7927a3c
NC		 3791 }
3792 break;
3793 case 0x39:
3794 {
3795 /** 0011 1001 bsr.w %a0 */
3796 if (trace)
3797 {
3798 printf ("\033[33m%s\033[0m %02x\n",
3799 "/** 0011 1001 bsr.w %a0 */",
3800 op[0]);
3801 }
3802 SYNTAX("bsr.w %a0");
4ce8c66d 3803#line 822 "rx-decode.opc"
c7927a3c 3804 ID(jsr); DC(pc + IMMex(2));
43e65147 3805
c7927a3c
NC		 3806 }
3807 break;
3808 case 0x3a:
3809 case 0x3b:
3810 {
3811 /** 0011 101c b%1.w %a0 */
4ce8c66d 3812#line 796 "rx-decode.opc"
c7927a3c
NC		 3813 int c AU = op[0] & 0x01;
3814 if (trace)
3815 {
3816 printf ("\033[33m%s\033[0m %02x\n",
3817 "/** 0011 101c b%1.w %a0 */",
3818 op[0]);
3819 printf (" c = 0x%x\n", c);
3820 }
3821 SYNTAX("b%1.w %a0");
4ce8c66d 3822#line 796 "rx-decode.opc"
c7927a3c 3823 ID(branch); Scc(c); DC(pc + IMMex (2));
43e65147
L		 3824
3825
c7927a3c
NC		 3826 }
3827 break;
3828 case 0x3c:
3829 GETBYTE ();
3830 switch (op[1] & 0x00)
3831 {
3832 case 0x00:
a117b0a5 3833 op_semantics_20:
c7927a3c
NC		 3834 {
3835 /** 0011 11sz d dst sppp mov%s #%1, %0 */
4ce8c66d 3836#line 332 "rx-decode.opc"
c7927a3c 3837 int sz AU = op[0] & 0x03;
4ce8c66d 3838#line 332 "rx-decode.opc"
c7927a3c 3839 int d AU = (op[1] >> 7) & 0x01;
4ce8c66d 3840#line 332 "rx-decode.opc"
c7927a3c 3841 int dst AU = (op[1] >> 4) & 0x07;
4ce8c66d 3842#line 332 "rx-decode.opc"
c7927a3c
NC		 3843 int sppp AU = op[1] & 0x0f;
3844 if (trace)
3845 {
3846 printf ("\033[33m%s\033[0m %02x %02x\n",
3847 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3848 op[0], op[1]);
3849 printf (" sz = 0x%x,", sz);
3850 printf (" d = 0x%x,", d);
3851 printf (" dst = 0x%x,", dst);
3852 printf (" sppp = 0x%x\n", sppp);
3853 }
3854 SYNTAX("mov%s #%1, %0");
4ce8c66d 3855#line 332 "rx-decode.opc"
3cf79a01 3856 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
43e65147 3857
c7927a3c
NC		 3858 }
3859 break;
3860 }
3861 break;
3862 case 0x3d:
3863 GETBYTE ();
3864 switch (op[1] & 0x00)
3865 {
3866 case 0x00:
a117b0a5 3867 goto op_semantics_20;
c7927a3c
NC		 3868 break;
3869 }
3870 break;
3871 case 0x3e:
3872 GETBYTE ();
3873 switch (op[1] & 0x00)
3874 {
3875 case 0x00:
a117b0a5 3876 goto op_semantics_20;
c7927a3c
NC		 3877 break;
3878 }
3879 break;
3880 case 0x3f:
3881 GETBYTE ();
3882 switch (op[1] & 0x00)
3883 {
3884 case 0x00:
3885 {
3886 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
4ce8c66d 3887#line 429 "rx-decode.opc"
c7927a3c 3888 int rega AU = (op[1] >> 4) & 0x0f;
4ce8c66d 3889#line 429 "rx-decode.opc"
c7927a3c
NC		 3890 int regb AU = op[1] & 0x0f;
3891 if (trace)
3892 {
3893 printf ("\033[33m%s\033[0m %02x %02x\n",
3894 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3895 op[0], op[1]);
3896 printf (" rega = 0x%x,", rega);
3897 printf (" regb = 0x%x\n", regb);
3898 }
3899 SYNTAX("rtsd #%1, %2-%0");
4ce8c66d 3900#line 429 "rx-decode.opc"
c7927a3c 3901 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
43e65147 3902
c7927a3c
NC		 3903 /*----------------------------------------------------------------------*/
3904 /* AND */
43e65147 3905
c7927a3c
NC		 3906 }
3907 break;
3908 }
3909 break;
3910 case 0x40:
3911 GETBYTE ();
3912 switch (op[1] & 0x00)
3913 {
3914 case 0x00:
a117b0a5 3915 op_semantics_21:
c7927a3c
NC		 3916 {
3917 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
4ce8c66d 3918#line 564 "rx-decode.opc"
c7927a3c 3919 int ss AU = op[0] & 0x03;
4ce8c66d 3920#line 564 "rx-decode.opc"
c7927a3c 3921 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 3922#line 564 "rx-decode.opc"
c7927a3c
NC		 3923 int rdst AU = op[1] & 0x0f;
3924 if (trace)
3925 {
3926 printf ("\033[33m%s\033[0m %02x %02x\n",
3927 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3928 op[0], op[1]);
3929 printf (" ss = 0x%x,", ss);
3930 printf (" rsrc = 0x%x,", rsrc);
3931 printf (" rdst = 0x%x\n", rdst);
3932 }
3933 SYNTAX("sub %2%S2, %1");
4ce8c66d 3934#line 564 "rx-decode.opc"
3cf79a01 3935 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
43e65147 3936
c7927a3c
NC		 3937 }
3938 break;
3939 }
3940 break;
3941 case 0x41:
3942 GETBYTE ();
3943 switch (op[1] & 0x00)
3944 {
3945 case 0x00:
a117b0a5 3946 goto op_semantics_21;
c7927a3c
NC		 3947 break;
3948 }
3949 break;
3950 case 0x42:
3951 GETBYTE ();
3952 switch (op[1] & 0x00)
3953 {
3954 case 0x00:
a117b0a5 3955 goto op_semantics_21;
c7927a3c
NC		 3956 break;
3957 }
3958 break;
3959 case 0x43:
3960 GETBYTE ();
3961 switch (op[1] & 0x00)
3962 {
3963 case 0x00:
a117b0a5 3964 goto op_semantics_21;
c7927a3c
NC		 3965 break;
3966 }
3967 break;
3968 case 0x44:
3969 GETBYTE ();
3970 switch (op[1] & 0x00)
3971 {
3972 case 0x00:
a117b0a5 3973 op_semantics_22:
c7927a3c
NC		 3974 {
3975 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
4ce8c66d 3976#line 552 "rx-decode.opc"
c7927a3c 3977 int ss AU = op[0] & 0x03;
4ce8c66d 3978#line 552 "rx-decode.opc"
c7927a3c 3979 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 3980#line 552 "rx-decode.opc"
c7927a3c
NC		 3981 int rdst AU = op[1] & 0x0f;
3982 if (trace)
3983 {
3984 printf ("\033[33m%s\033[0m %02x %02x\n",
3985 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3986 op[0], op[1]);
3987 printf (" ss = 0x%x,", ss);
3988 printf (" rsrc = 0x%x,", rsrc);
3989 printf (" rdst = 0x%x\n", rdst);
3990 }
3991 SYNTAX("cmp %2%S2, %1");
4ce8c66d 3992#line 552 "rx-decode.opc"
3cf79a01 3993 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
43e65147 3994
c7927a3c
NC		 3995 }
3996 break;
3997 }
3998 break;
3999 case 0x45:
4000 GETBYTE ();
4001 switch (op[1] & 0x00)
4002 {
4003 case 0x00:
a117b0a5 4004 goto op_semantics_22;
c7927a3c
NC		 4005 break;
4006 }
4007 break;
4008 case 0x46:
4009 GETBYTE ();
4010 switch (op[1] & 0x00)
4011 {
4012 case 0x00:
a117b0a5 4013 goto op_semantics_22;
c7927a3c
NC		 4014 break;
4015 }
4016 break;
4017 case 0x47:
4018 GETBYTE ();
4019 switch (op[1] & 0x00)
4020 {
4021 case 0x00:
a117b0a5 4022 goto op_semantics_22;
c7927a3c
NC		 4023 break;
4024 }
4025 break;
4026 case 0x48:
4027 GETBYTE ();
4028 switch (op[1] & 0x00)
4029 {
4030 case 0x00:
a117b0a5 4031 op_semantics_23:
c7927a3c
NC		 4032 {
4033 /** 0100 10ss rsrc rdst add %1%S1, %0 */
4ce8c66d 4034#line 528 "rx-decode.opc"
c7927a3c 4035 int ss AU = op[0] & 0x03;
4ce8c66d 4036#line 528 "rx-decode.opc"
c7927a3c 4037 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4038#line 528 "rx-decode.opc"
c7927a3c
NC		 4039 int rdst AU = op[1] & 0x0f;
4040 if (trace)
4041 {
4042 printf ("\033[33m%s\033[0m %02x %02x\n",
4043 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4044 op[0], op[1]);
4045 printf (" ss = 0x%x,", ss);
4046 printf (" rsrc = 0x%x,", rsrc);
4047 printf (" rdst = 0x%x\n", rdst);
4048 }
4049 SYNTAX("add %1%S1, %0");
4ce8c66d 4050#line 528 "rx-decode.opc"
3cf79a01 4051 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
43e65147 4052
c7927a3c
NC		 4053 }
4054 break;
4055 }
4056 break;
4057 case 0x49:
4058 GETBYTE ();
4059 switch (op[1] & 0x00)
4060 {
4061 case 0x00:
a117b0a5 4062 goto op_semantics_23;
c7927a3c
NC		 4063 break;
4064 }
4065 break;
4066 case 0x4a:
4067 GETBYTE ();
4068 switch (op[1] & 0x00)
4069 {
4070 case 0x00:
a117b0a5 4071 goto op_semantics_23;
c7927a3c
NC		 4072 break;
4073 }
4074 break;
4075 case 0x4b:
4076 GETBYTE ();
4077 switch (op[1] & 0x00)
4078 {
4079 case 0x00:
a117b0a5 4080 goto op_semantics_23;
c7927a3c
NC		 4081 break;
4082 }
4083 break;
4084 case 0x4c:
4085 GETBYTE ();
4086 switch (op[1] & 0x00)
4087 {
4088 case 0x00:
a117b0a5 4089 op_semantics_24:
c7927a3c
NC		 4090 {
4091 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
4ce8c66d 4092#line 671 "rx-decode.opc"
c7927a3c 4093 int ss AU = op[0] & 0x03;
4ce8c66d 4094#line 671 "rx-decode.opc"
c7927a3c 4095 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4096#line 671 "rx-decode.opc"
c7927a3c
NC		 4097 int rdst AU = op[1] & 0x0f;
4098 if (trace)
4099 {
4100 printf ("\033[33m%s\033[0m %02x %02x\n",
4101 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4102 op[0], op[1]);
4103 printf (" ss = 0x%x,", ss);
4104 printf (" rsrc = 0x%x,", rsrc);
4105 printf (" rdst = 0x%x\n", rdst);
4106 }
4107 SYNTAX("mul %1%S1, %0");
4ce8c66d 4108#line 671 "rx-decode.opc"
3cf79a01 4109 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
43e65147 4110
c7927a3c
NC		 4111 }
4112 break;
4113 }
4114 break;
4115 case 0x4d:
4116 GETBYTE ();
4117 switch (op[1] & 0x00)
4118 {
4119 case 0x00:
a117b0a5 4120 goto op_semantics_24;
c7927a3c
NC		 4121 break;
4122 }
4123 break;
4124 case 0x4e:
4125 GETBYTE ();
4126 switch (op[1] & 0x00)
4127 {
4128 case 0x00:
a117b0a5 4129 goto op_semantics_24;
c7927a3c
NC		 4130 break;
4131 }
4132 break;
4133 case 0x4f:
4134 GETBYTE ();
4135 switch (op[1] & 0x00)
4136 {
4137 case 0x00:
a117b0a5 4138 goto op_semantics_24;
c7927a3c
NC		 4139 break;
4140 }
4141 break;
4142 case 0x50:
4143 GETBYTE ();
4144 switch (op[1] & 0x00)
4145 {
4146 case 0x00:
a117b0a5 4147 op_semantics_25:
c7927a3c
NC		 4148 {
4149 /** 0101 00ss rsrc rdst and %1%S1, %0 */
4ce8c66d 4150#line 441 "rx-decode.opc"
c7927a3c 4151 int ss AU = op[0] & 0x03;
4ce8c66d 4152#line 441 "rx-decode.opc"
c7927a3c 4153 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4154#line 441 "rx-decode.opc"
c7927a3c
NC		 4155 int rdst AU = op[1] & 0x0f;
4156 if (trace)
4157 {
4158 printf ("\033[33m%s\033[0m %02x %02x\n",
4159 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4160 op[0], op[1]);
4161 printf (" ss = 0x%x,", ss);
4162 printf (" rsrc = 0x%x,", rsrc);
4163 printf (" rdst = 0x%x\n", rdst);
4164 }
4165 SYNTAX("and %1%S1, %0");
4ce8c66d 4166#line 441 "rx-decode.opc"
3cf79a01 4167 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 4168
c7927a3c
NC		 4169 }
4170 break;
4171 }
4172 break;
4173 case 0x51:
4174 GETBYTE ();
4175 switch (op[1] & 0x00)
4176 {
4177 case 0x00:
a117b0a5 4178 goto op_semantics_25;
c7927a3c
NC		 4179 break;
4180 }
4181 break;
4182 case 0x52:
4183 GETBYTE ();
4184 switch (op[1] & 0x00)
4185 {
4186 case 0x00:
a117b0a5 4187 goto op_semantics_25;
c7927a3c
NC		 4188 break;
4189 }
4190 break;
4191 case 0x53:
4192 GETBYTE ();
4193 switch (op[1] & 0x00)
4194 {
4195 case 0x00:
a117b0a5 4196 goto op_semantics_25;
c7927a3c
NC		 4197 break;
4198 }
4199 break;
4200 case 0x54:
4201 GETBYTE ();
4202 switch (op[1] & 0x00)
4203 {
4204 case 0x00:
a117b0a5 4205 op_semantics_26:
c7927a3c
NC		 4206 {
4207 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4ce8c66d 4208#line 459 "rx-decode.opc"
c7927a3c 4209 int ss AU = op[0] & 0x03;
4ce8c66d 4210#line 459 "rx-decode.opc"
c7927a3c 4211 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4212#line 459 "rx-decode.opc"
c7927a3c
NC		 4213 int rdst AU = op[1] & 0x0f;
4214 if (trace)
4215 {
4216 printf ("\033[33m%s\033[0m %02x %02x\n",
4217 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4218 op[0], op[1]);
4219 printf (" ss = 0x%x,", ss);
4220 printf (" rsrc = 0x%x,", rsrc);
4221 printf (" rdst = 0x%x\n", rdst);
4222 }
4223 SYNTAX("or %1%S1, %0");
4ce8c66d 4224#line 459 "rx-decode.opc"
3cf79a01 4225 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 4226
c7927a3c
NC		 4227 }
4228 break;
4229 }
4230 break;
4231 case 0x55:
4232 GETBYTE ();
4233 switch (op[1] & 0x00)
4234 {
4235 case 0x00:
a117b0a5 4236 goto op_semantics_26;
c7927a3c
NC		 4237 break;
4238 }
4239 break;
4240 case 0x56:
4241 GETBYTE ();
4242 switch (op[1] & 0x00)
4243 {
4244 case 0x00:
a117b0a5 4245 goto op_semantics_26;
c7927a3c
NC		 4246 break;
4247 }
4248 break;
4249 case 0x57:
4250 GETBYTE ();
4251 switch (op[1] & 0x00)
4252 {
4253 case 0x00:
a117b0a5 4254 goto op_semantics_26;
c7927a3c
NC		 4255 break;
4256 }
4257 break;
4258 case 0x58:
4259 GETBYTE ();
4260 switch (op[1] & 0x00)
4261 {
4262 case 0x00:
a117b0a5 4263 op_semantics_27:
c7927a3c
NC		 4264 {
4265 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4ce8c66d 4266#line 380 "rx-decode.opc"
c7927a3c 4267 int s AU = (op[0] >> 2) & 0x01;
4ce8c66d 4268#line 380 "rx-decode.opc"
c7927a3c 4269 int ss AU = op[0] & 0x03;
4ce8c66d 4270#line 380 "rx-decode.opc"
c7927a3c 4271 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4272#line 380 "rx-decode.opc"
c7927a3c
NC		 4273 int rdst AU = op[1] & 0x0f;
4274 if (trace)
4275 {
4276 printf ("\033[33m%s\033[0m %02x %02x\n",
4277 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4278 op[0], op[1]);
4279 printf (" s = 0x%x,", s);
4280 printf (" ss = 0x%x,", ss);
4281 printf (" rsrc = 0x%x,", rsrc);
4282 printf (" rdst = 0x%x\n", rdst);
4283 }
4284 SYNTAX("movu%s %1, %0");
4ce8c66d 4285#line 380 "rx-decode.opc"
f04265ec 4286 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
43e65147 4287
c7927a3c
NC		 4288 }
4289 break;
4290 }
4291 break;
4292 case 0x59:
4293 GETBYTE ();
4294 switch (op[1] & 0x00)
4295 {
4296 case 0x00:
a117b0a5 4297 goto op_semantics_27;
c7927a3c
NC		 4298 break;
4299 }
4300 break;
4301 case 0x5a:
4302 GETBYTE ();
4303 switch (op[1] & 0x00)
4304 {
4305 case 0x00:
a117b0a5 4306 goto op_semantics_27;
c7927a3c
NC		 4307 break;
4308 }
4309 break;
4310 case 0x5b:
4311 GETBYTE ();
4312 switch (op[1] & 0x00)
4313 {
4314 case 0x00:
a117b0a5 4315 goto op_semantics_27;
c7927a3c
NC		 4316 break;
4317 }
4318 break;
4319 case 0x5c:
4320 GETBYTE ();
4321 switch (op[1] & 0x00)
4322 {
4323 case 0x00:
a117b0a5 4324 goto op_semantics_27;
c7927a3c
NC		 4325 break;
4326 }
4327 break;
4328 case 0x5d:
4329 GETBYTE ();
4330 switch (op[1] & 0x00)
4331 {
4332 case 0x00:
a117b0a5 4333 goto op_semantics_27;
c7927a3c
NC		 4334 break;
4335 }
4336 break;
4337 case 0x5e:
4338 GETBYTE ();
4339 switch (op[1] & 0x00)
4340 {
4341 case 0x00:
a117b0a5 4342 goto op_semantics_27;
c7927a3c
NC		 4343 break;
4344 }
4345 break;
4346 case 0x5f:
4347 GETBYTE ();
4348 switch (op[1] & 0x00)
4349 {
4350 case 0x00:
a117b0a5 4351 goto op_semantics_27;
c7927a3c
NC		 4352 break;
4353 }
4354 break;
4355 case 0x60:
4356 GETBYTE ();
4357 switch (op[1] & 0x00)
4358 {
4359 case 0x00:
4360 {
4361 /** 0110 0000 immm rdst sub #%2, %0 */
4ce8c66d 4362#line 561 "rx-decode.opc"
c7927a3c 4363 int immm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4364#line 561 "rx-decode.opc"
c7927a3c
NC		 4365 int rdst AU = op[1] & 0x0f;
4366 if (trace)
4367 {
4368 printf ("\033[33m%s\033[0m %02x %02x\n",
4369 "/** 0110 0000 immm rdst sub #%2, %0 */",
4370 op[0], op[1]);
4371 printf (" immm = 0x%x,", immm);
4372 printf (" rdst = 0x%x\n", rdst);
4373 }
4374 SYNTAX("sub #%2, %0");
4ce8c66d 4375#line 561 "rx-decode.opc"
3cf79a01 4376 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
43e65147 4377
c7927a3c
NC		 4378 }
4379 break;
4380 }
4381 break;
4382 case 0x61:
4383 GETBYTE ();
4384 switch (op[1] & 0x00)
4385 {
4386 case 0x00:
4387 {
4388 /** 0110 0001 immm rdst cmp #%2, %1 */
4ce8c66d 4389#line 543 "rx-decode.opc"
c7927a3c 4390 int immm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4391#line 543 "rx-decode.opc"
c7927a3c
NC		 4392 int rdst AU = op[1] & 0x0f;
4393 if (trace)
4394 {
4395 printf ("\033[33m%s\033[0m %02x %02x\n",
4396 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4397 op[0], op[1]);
4398 printf (" immm = 0x%x,", immm);
4399 printf (" rdst = 0x%x\n", rdst);
4400 }
4401 SYNTAX("cmp #%2, %1");
4ce8c66d 4402#line 543 "rx-decode.opc"
3cf79a01 4403 ID(sub); S2C(immm); SR(rdst); F_OSZC;
43e65147 4404
c7927a3c
NC		 4405 }
4406 break;
4407 }
4408 break;
4409 case 0x62:
4410 GETBYTE ();
4411 switch (op[1] & 0x00)
4412 {
4413 case 0x00:
4414 {
4415 /** 0110 0010 immm rdst add #%1, %0 */
4ce8c66d 4416#line 525 "rx-decode.opc"
c7927a3c 4417 int immm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4418#line 525 "rx-decode.opc"
c7927a3c
NC		 4419 int rdst AU = op[1] & 0x0f;
4420 if (trace)
4421 {
4422 printf ("\033[33m%s\033[0m %02x %02x\n",
4423 "/** 0110 0010 immm rdst add #%1, %0 */",
4424 op[0], op[1]);
4425 printf (" immm = 0x%x,", immm);
4426 printf (" rdst = 0x%x\n", rdst);
4427 }
4428 SYNTAX("add #%1, %0");
4ce8c66d 4429#line 525 "rx-decode.opc"
3cf79a01 4430 ID(add); SC(immm); DR(rdst); F_OSZC;
43e65147 4431
c7927a3c
NC		 4432 }
4433 break;
4434 }
4435 break;
4436 case 0x63:
4437 GETBYTE ();
4438 switch (op[1] & 0x00)
4439 {
4440 case 0x00:
4441 {
4442 /** 0110 0011 immm rdst mul #%1, %0 */
4ce8c66d 4443#line 637 "rx-decode.opc"
c7927a3c 4444 int immm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4445#line 637 "rx-decode.opc"
c7927a3c
NC		 4446 int rdst AU = op[1] & 0x0f;
4447 if (trace)
4448 {
4449 printf ("\033[33m%s\033[0m %02x %02x\n",
4450 "/** 0110 0011 immm rdst mul #%1, %0 */",
4451 op[0], op[1]);
4452 printf (" immm = 0x%x,", immm);
4453 printf (" rdst = 0x%x\n", rdst);
4454 }
4455 SYNTAX("mul #%1, %0");
4ce8c66d 4456#line 637 "rx-decode.opc"
a117b0a5
YS		 4457 if (immm == 1 && rdst == 0)
4458 {
4459 ID(nop2);
4460 SYNTAX ("nop\t; mul\t#1, r0");
4461 }
4462 else
4463 {
4464 ID(mul);
4465 }
4466 DR(rdst); SC(immm); F_____;
4467
c7927a3c
NC		 4468 }
4469 break;
4470 }
4471 break;
4472 case 0x64:
4473 GETBYTE ();
4474 switch (op[1] & 0x00)
4475 {
4476 case 0x00:
4477 {
4478 /** 0110 0100 immm rdst and #%1, %0 */
4ce8c66d 4479#line 435 "rx-decode.opc"
c7927a3c 4480 int immm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4481#line 435 "rx-decode.opc"
c7927a3c
NC		 4482 int rdst AU = op[1] & 0x0f;
4483 if (trace)
4484 {
4485 printf ("\033[33m%s\033[0m %02x %02x\n",
4486 "/** 0110 0100 immm rdst and #%1, %0 */",
4487 op[0], op[1]);
4488 printf (" immm = 0x%x,", immm);
4489 printf (" rdst = 0x%x\n", rdst);
4490 }
4491 SYNTAX("and #%1, %0");
4ce8c66d 4492#line 435 "rx-decode.opc"
3cf79a01 4493 ID(and); SC(immm); DR(rdst); F__SZ_;
43e65147 4494
c7927a3c
NC		 4495 }
4496 break;
4497 }
4498 break;
4499 case 0x65:
4500 GETBYTE ();
4501 switch (op[1] & 0x00)
4502 {
4503 case 0x00:
4504 {
4505 /** 0110 0101 immm rdst or #%1, %0 */
4ce8c66d 4506#line 453 "rx-decode.opc"
c7927a3c 4507 int immm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4508#line 453 "rx-decode.opc"
c7927a3c
NC		 4509 int rdst AU = op[1] & 0x0f;
4510 if (trace)
4511 {
4512 printf ("\033[33m%s\033[0m %02x %02x\n",
4513 "/** 0110 0101 immm rdst or #%1, %0 */",
4514 op[0], op[1]);
4515 printf (" immm = 0x%x,", immm);
4516 printf (" rdst = 0x%x\n", rdst);
4517 }
4518 SYNTAX("or #%1, %0");
4ce8c66d 4519#line 453 "rx-decode.opc"
3cf79a01 4520 ID(or); SC(immm); DR(rdst); F__SZ_;
43e65147 4521
c7927a3c
NC		 4522 }
4523 break;
4524 }
4525 break;
4526 case 0x66:
4527 GETBYTE ();
4528 switch (op[1] & 0x00)
4529 {
4530 case 0x00:
4531 {
4532 /** 0110 0110 immm rdst mov%s #%1, %0 */
4ce8c66d 4533#line 329 "rx-decode.opc"
c7927a3c 4534 int immm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4535#line 329 "rx-decode.opc"
c7927a3c
NC		 4536 int rdst AU = op[1] & 0x0f;
4537 if (trace)
4538 {
4539 printf ("\033[33m%s\033[0m %02x %02x\n",
4540 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4541 op[0], op[1]);
4542 printf (" immm = 0x%x,", immm);
4543 printf (" rdst = 0x%x\n", rdst);
4544 }
4545 SYNTAX("mov%s #%1, %0");
4ce8c66d 4546#line 329 "rx-decode.opc"
3cf79a01 4547 ID(mov); DR(rdst); SC(immm); F_____;
43e65147 4548
c7927a3c
NC		 4549 }
4550 break;
4551 }
4552 break;
4553 case 0x67:
4554 {
4555 /** 0110 0111 rtsd #%1 */
4556 if (trace)
4557 {
4558 printf ("\033[33m%s\033[0m %02x\n",
4559 "/** 0110 0111 rtsd #%1 */",
4560 op[0]);
4561 }
4562 SYNTAX("rtsd #%1");
4ce8c66d 4563#line 426 "rx-decode.opc"
c7927a3c 4564 ID(rtsd); SC(IMM(1) * 4);
43e65147 4565
c7927a3c
NC		 4566 }
4567 break;
4568 case 0x68:
4569 GETBYTE ();
4570 switch (op[1] & 0x00)
4571 {
4572 case 0x00:
a117b0a5 4573 op_semantics_28:
c7927a3c
NC		 4574 {
4575 /** 0110 100i mmmm rdst shlr #%2, %0 */
4ce8c66d 4576#line 751 "rx-decode.opc"
c7927a3c 4577 int i AU = op[0] & 0x01;
4ce8c66d 4578#line 751 "rx-decode.opc"
c7927a3c 4579 int mmmm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4580#line 751 "rx-decode.opc"
c7927a3c
NC		 4581 int rdst AU = op[1] & 0x0f;
4582 if (trace)
4583 {
4584 printf ("\033[33m%s\033[0m %02x %02x\n",
4585 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4586 op[0], op[1]);
4587 printf (" i = 0x%x,", i);
4588 printf (" mmmm = 0x%x,", mmmm);
4589 printf (" rdst = 0x%x\n", rdst);
4590 }
4591 SYNTAX("shlr #%2, %0");
4ce8c66d 4592#line 751 "rx-decode.opc"
3cf79a01 4593 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
43e65147 4594
c7927a3c
NC		 4595 }
4596 break;
4597 }
4598 break;
4599 case 0x69:
4600 GETBYTE ();
4601 switch (op[1] & 0x00)
4602 {
4603 case 0x00:
a117b0a5 4604 goto op_semantics_28;
c7927a3c
NC		 4605 break;
4606 }
4607 break;
4608 case 0x6a:
4609 GETBYTE ();
4610 switch (op[1] & 0x00)
4611 {
4612 case 0x00:
a117b0a5 4613 op_semantics_29:
c7927a3c
NC		 4614 {
4615 /** 0110 101i mmmm rdst shar #%2, %0 */
4ce8c66d 4616#line 741 "rx-decode.opc"
c7927a3c 4617 int i AU = op[0] & 0x01;
4ce8c66d 4618#line 741 "rx-decode.opc"
c7927a3c 4619 int mmmm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4620#line 741 "rx-decode.opc"
c7927a3c
NC		 4621 int rdst AU = op[1] & 0x0f;
4622 if (trace)
4623 {
4624 printf ("\033[33m%s\033[0m %02x %02x\n",
4625 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4626 op[0], op[1]);
4627 printf (" i = 0x%x,", i);
4628 printf (" mmmm = 0x%x,", mmmm);
4629 printf (" rdst = 0x%x\n", rdst);
4630 }
4631 SYNTAX("shar #%2, %0");
4ce8c66d 4632#line 741 "rx-decode.opc"
3cf79a01 4633 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
43e65147 4634
c7927a3c
NC		 4635 }
4636 break;
4637 }
4638 break;
4639 case 0x6b:
4640 GETBYTE ();
4641 switch (op[1] & 0x00)
4642 {
4643 case 0x00:
a117b0a5 4644 goto op_semantics_29;
c7927a3c
NC		 4645 break;
4646 }
4647 break;
4648 case 0x6c:
4649 GETBYTE ();
4650 switch (op[1] & 0x00)
4651 {
4652 case 0x00:
a117b0a5 4653 op_semantics_30:
c7927a3c
NC		 4654 {
4655 /** 0110 110i mmmm rdst shll #%2, %0 */
4ce8c66d 4656#line 731 "rx-decode.opc"
c7927a3c 4657 int i AU = op[0] & 0x01;
4ce8c66d 4658#line 731 "rx-decode.opc"
c7927a3c 4659 int mmmm AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4660#line 731 "rx-decode.opc"
c7927a3c
NC		 4661 int rdst AU = op[1] & 0x0f;
4662 if (trace)
4663 {
4664 printf ("\033[33m%s\033[0m %02x %02x\n",
4665 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4666 op[0], op[1]);
4667 printf (" i = 0x%x,", i);
4668 printf (" mmmm = 0x%x,", mmmm);
4669 printf (" rdst = 0x%x\n", rdst);
4670 }
4671 SYNTAX("shll #%2, %0");
4ce8c66d 4672#line 731 "rx-decode.opc"
3cf79a01 4673 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
43e65147 4674
c7927a3c
NC		 4675 }
4676 break;
4677 }
4678 break;
4679 case 0x6d:
4680 GETBYTE ();
4681 switch (op[1] & 0x00)
4682 {
4683 case 0x00:
a117b0a5 4684 goto op_semantics_30;
c7927a3c
NC		 4685 break;
4686 }
4687 break;
4688 case 0x6e:
4689 GETBYTE ();
4690 switch (op[1] & 0x00)
4691 {
4692 case 0x00:
4693 {
4694 /** 0110 1110 dsta dstb pushm %1-%2 */
4ce8c66d 4695#line 393 "rx-decode.opc"
c7927a3c 4696 int dsta AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4697#line 393 "rx-decode.opc"
c7927a3c
NC		 4698 int dstb AU = op[1] & 0x0f;
4699 if (trace)
4700 {
4701 printf ("\033[33m%s\033[0m %02x %02x\n",
4702 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4703 op[0], op[1]);
4704 printf (" dsta = 0x%x,", dsta);
4705 printf (" dstb = 0x%x\n", dstb);
4706 }
4707 SYNTAX("pushm %1-%2");
4ce8c66d 4708#line 393 "rx-decode.opc"
3cf79a01 4709 ID(pushm); SR(dsta); S2R(dstb); F_____;
43e65147 4710
c7927a3c
NC		 4711 }
4712 break;
4713 }
4714 break;
4715 case 0x6f:
4716 GETBYTE ();
4717 switch (op[1] & 0x00)
4718 {
4719 case 0x00:
4720 {
4721 /** 0110 1111 dsta dstb popm %1-%2 */
4ce8c66d 4722#line 390 "rx-decode.opc"
c7927a3c 4723 int dsta AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4724#line 390 "rx-decode.opc"
c7927a3c
NC		 4725 int dstb AU = op[1] & 0x0f;
4726 if (trace)
4727 {
4728 printf ("\033[33m%s\033[0m %02x %02x\n",
4729 "/** 0110 1111 dsta dstb popm %1-%2 */",
4730 op[0], op[1]);
4731 printf (" dsta = 0x%x,", dsta);
4732 printf (" dstb = 0x%x\n", dstb);
4733 }
4734 SYNTAX("popm %1-%2");
4ce8c66d 4735#line 390 "rx-decode.opc"
3cf79a01 4736 ID(popm); SR(dsta); S2R(dstb); F_____;
43e65147 4737
c7927a3c
NC		 4738 }
4739 break;
4740 }
4741 break;
4742 case 0x70:
4743 GETBYTE ();
4744 switch (op[1] & 0x00)
4745 {
4746 case 0x00:
a117b0a5 4747 op_semantics_31:
c7927a3c
NC		 4748 {
4749 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4ce8c66d 4750#line 534 "rx-decode.opc"
c7927a3c 4751 int im AU = op[0] & 0x03;
4ce8c66d 4752#line 534 "rx-decode.opc"
c7927a3c 4753 int rsrc AU = (op[1] >> 4) & 0x0f;
4ce8c66d 4754#line 534 "rx-decode.opc"
c7927a3c
NC		 4755 int rdst AU = op[1] & 0x0f;
4756 if (trace)
4757 {
4758 printf ("\033[33m%s\033[0m %02x %02x\n",
4759 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4760 op[0], op[1]);
4761 printf (" im = 0x%x,", im);
4762 printf (" rsrc = 0x%x,", rsrc);
4763 printf (" rdst = 0x%x\n", rdst);
4764 }
4765 SYNTAX("add #%1, %2, %0");
4ce8c66d 4766#line 534 "rx-decode.opc"
3cf79a01 4767 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
43e65147 4768
c7927a3c
NC		 4769 }
4770 break;
4771 }
4772 break;
4773 case 0x71:
4774 GETBYTE ();
4775 switch (op[1] & 0x00)
4776 {
4777 case 0x00:
a117b0a5 4778 goto op_semantics_31;
c7927a3c
NC		 4779 break;
4780 }
4781 break;
4782 case 0x72:
4783 GETBYTE ();
4784 switch (op[1] & 0x00)
4785 {
4786 case 0x00:
a117b0a5 4787 goto op_semantics_31;
c7927a3c
NC		 4788 break;
4789 }
4790 break;
4791 case 0x73:
4792 GETBYTE ();
4793 switch (op[1] & 0x00)
4794 {
4795 case 0x00:
a117b0a5 4796 goto op_semantics_31;
c7927a3c
NC		 4797 break;
4798 }
4799 break;
4800 case 0x74:
4801 GETBYTE ();
4802 switch (op[1] & 0xf0)
4803 {
4804 case 0x00:
a117b0a5 4805 op_semantics_32:
c7927a3c
NC		 4806 {
4807 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4ce8c66d 4808#line 546 "rx-decode.opc"
c7927a3c 4809 int im AU = op[0] & 0x03;
4ce8c66d 4810#line 546 "rx-decode.opc"
c7927a3c
NC		 4811 int rsrc AU = op[1] & 0x0f;
4812 if (trace)
4813 {
4814 printf ("\033[33m%s\033[0m %02x %02x\n",
4815 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4816 op[0], op[1]);
4817 printf (" im = 0x%x,", im);
4818 printf (" rsrc = 0x%x\n", rsrc);
4819 }
4820 SYNTAX("cmp #%2, %1%S1");
4ce8c66d 4821#line 546 "rx-decode.opc"
3cf79a01 4822 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
43e65147 4823
c7927a3c
NC		 4824 }
4825 break;
4826 case 0x10:
a117b0a5 4827 op_semantics_33:
c7927a3c
NC		 4828 {
4829 /** 0111 01im 0001rdst mul #%1, %0 */
4ce8c66d 4830#line 649 "rx-decode.opc"
c7927a3c 4831 int im AU = op[0] & 0x03;
4ce8c66d 4832#line 649 "rx-decode.opc"
c7927a3c
NC		 4833 int rdst AU = op[1] & 0x0f;
4834 if (trace)
4835 {
4836 printf ("\033[33m%s\033[0m %02x %02x\n",
4837 "/** 0111 01im 0001rdst mul #%1, %0 */",
4838 op[0], op[1]);
4839 printf (" im = 0x%x,", im);
4840 printf (" rdst = 0x%x\n", rdst);
4841 }
4842 SYNTAX("mul #%1, %0");
4ce8c66d 4843#line 649 "rx-decode.opc"
a117b0a5
YS		 4844 int val = IMMex(im);
4845 if (val == 1 && rdst == 0)
4846 {
4847 SYNTAX("nop\t; mul\t#1, r0");
4848 switch (im)
4849 {
4850 case 2: ID(nop4); break;
4851 case 3: ID(nop5); break;
4852 case 0: ID(nop6); break;
4853 default:
4854 ID(mul);
4855 SYNTAX("mul #%1, %0");
4856 break;
4857 }
4858 }
4859 else
4860 {
4861 ID(mul);
4862 }
4863 DR(rdst); SC(val); F_____;
43e65147 4864
c7927a3c
NC		 4865 }
4866 break;
4867 case 0x20:
a117b0a5 4868 op_semantics_34:
c7927a3c
NC		 4869 {
4870 /** 0111 01im 0010 rdst and #%1, %0 */
4ce8c66d 4871#line 438 "rx-decode.opc"
c7927a3c 4872 int im AU = op[0] & 0x03;
4ce8c66d 4873#line 438 "rx-decode.opc"
c7927a3c
NC		 4874 int rdst AU = op[1] & 0x0f;
4875 if (trace)
4876 {
4877 printf ("\033[33m%s\033[0m %02x %02x\n",
4878 "/** 0111 01im 0010 rdst and #%1, %0 */",
4879 op[0], op[1]);
4880 printf (" im = 0x%x,", im);
4881 printf (" rdst = 0x%x\n", rdst);
4882 }
4883 SYNTAX("and #%1, %0");
4ce8c66d 4884#line 438 "rx-decode.opc"
3cf79a01 4885 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
43e65147 4886
c7927a3c
NC		 4887 }
4888 break;
4889 case 0x30:
a117b0a5 4890 op_semantics_35:
c7927a3c
NC		 4891 {
4892 /** 0111 01im 0011 rdst or #%1, %0 */
4ce8c66d 4893#line 456 "rx-decode.opc"
c7927a3c 4894 int im AU = op[0] & 0x03;
4ce8c66d 4895#line 456 "rx-decode.opc"
c7927a3c
NC		 4896 int rdst AU = op[1] & 0x0f;
4897 if (trace)
4898 {
4899 printf ("\033[33m%s\033[0m %02x %02x\n",
4900 "/** 0111 01im 0011 rdst or #%1, %0 */",
4901 op[0], op[1]);
4902 printf (" im = 0x%x,", im);
4903 printf (" rdst = 0x%x\n", rdst);
4904 }
4905 SYNTAX("or #%1, %0");
4ce8c66d 4906#line 456 "rx-decode.opc"
3cf79a01 4907 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
43e65147 4908
c7927a3c
NC		 4909 }
4910 break;
4911 default: UNSUPPORTED(); break;
4912 }
4913 break;
4914 case 0x75:
4915 GETBYTE ();
4916 switch (op[1] & 0xff)
4917 {
4918 case 0x00:
4919 case 0x01:
4920 case 0x02:
4921 case 0x03:
4922 case 0x04:
4923 case 0x05:
4924 case 0x06:
4925 case 0x07:
4926 case 0x08:
4927 case 0x09:
4928 case 0x0a:
4929 case 0x0b:
4930 case 0x0c:
4931 case 0x0d:
4932 case 0x0e:
4933 case 0x0f:
a117b0a5 4934 goto op_semantics_32;
c7927a3c
NC		 4935 break;
4936 case 0x10:
4937 case 0x11:
4938 case 0x12:
4939 case 0x13:
4940 case 0x14:
4941 case 0x15:
4942 case 0x16:
4943 case 0x17:
4944 case 0x18:
4945 case 0x19:
4946 case 0x1a:
4947 case 0x1b:
4948 case 0x1c:
4949 case 0x1d:
4950 case 0x1e:
4951 case 0x1f:
a117b0a5 4952 goto op_semantics_33;
c7927a3c
NC		 4953 break;
4954 case 0x20:
4955 case 0x21:
4956 case 0x22:
4957 case 0x23:
4958 case 0x24:
4959 case 0x25:
4960 case 0x26:
4961 case 0x27:
4962 case 0x28:
4963 case 0x29:
4964 case 0x2a:
4965 case 0x2b:
4966 case 0x2c:
4967 case 0x2d:
4968 case 0x2e:
4969 case 0x2f:
a117b0a5 4970 goto op_semantics_34;
c7927a3c
NC		 4971 break;
4972 case 0x30:
4973 case 0x31:
4974 case 0x32:
4975 case 0x33:
4976 case 0x34:
4977 case 0x35:
4978 case 0x36:
4979 case 0x37:
4980 case 0x38:
4981 case 0x39:
4982 case 0x3a:
4983 case 0x3b:
4984 case 0x3c:
4985 case 0x3d:
4986 case 0x3e:
4987 case 0x3f:
a117b0a5 4988 goto op_semantics_35;
c7927a3c
NC		 4989 break;
4990 case 0x40:
4991 case 0x41:
4992 case 0x42:
4993 case 0x43:
4994 case 0x44:
4995 case 0x45:
4996 case 0x46:
4997 case 0x47:
4998 case 0x48:
4999 case 0x49:
5000 case 0x4a:
5001 case 0x4b:
5002 case 0x4c:
5003 case 0x4d:
5004 case 0x4e:
5005 case 0x4f:
5006 {
5007 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4ce8c66d 5008#line 310 "rx-decode.opc"
c7927a3c
NC		 5009 int rdst AU = op[1] & 0x0f;
5010 if (trace)
5011 {
5012 printf ("\033[33m%s\033[0m %02x %02x\n",
5013 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
5014 op[0], op[1]);
5015 printf (" rdst = 0x%x\n", rdst);
5016 }
5017 SYNTAX("mov%s #%1, %0");
4ce8c66d 5018#line 310 "rx-decode.opc"
3cf79a01 5019 ID(mov); DR(rdst); SC(IMM (1)); F_____;
43e65147 5020
c7927a3c
NC		 5021 }
5022 break;
5023 case 0x50:
5024 case 0x51:
5025 case 0x52:
5026 case 0x53:
5027 case 0x54:
5028 case 0x55:
5029 case 0x56:
5030 case 0x57:
5031 case 0x58:
5032 case 0x59:
5033 case 0x5a:
5034 case 0x5b:
5035 case 0x5c:
5036 case 0x5d:
5037 case 0x5e:
5038 case 0x5f:
5039 {
5040 /** 0111 0101 0101 rsrc cmp #%2, %1 */
4ce8c66d 5041#line 549 "rx-decode.opc"
c7927a3c
NC		 5042 int rsrc AU = op[1] & 0x0f;
5043 if (trace)
5044 {
5045 printf ("\033[33m%s\033[0m %02x %02x\n",
5046 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5047 op[0], op[1]);
5048 printf (" rsrc = 0x%x\n", rsrc);
5049 }
5050 SYNTAX("cmp #%2, %1");
4ce8c66d 5051#line 549 "rx-decode.opc"
3cf79a01 5052 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
43e65147 5053
c7927a3c
NC		 5054 }
5055 break;
5056 case 0x60:
5057 {
5058 /** 0111 0101 0110 0000 int #%1 */
5059 if (trace)
5060 {
5061 printf ("\033[33m%s\033[0m %02x %02x\n",
5062 "/** 0111 0101 0110 0000 int #%1 */",
5063 op[0], op[1]);
5064 }
5065 SYNTAX("int #%1");
4ce8c66d 5066#line 1056 "rx-decode.opc"
c7927a3c 5067 ID(int); SC(IMM(1));
43e65147 5068
c7927a3c
NC		 5069 }
5070 break;
946ef196
DD		 5071 case 0x70:
5072 GETBYTE ();
5073 switch (op[2] & 0xf0)
5074 {
5075 case 0x00:
5076 {
5077 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
4ce8c66d 5078#line 1023 "rx-decode.opc"
946ef196
DD		 5079 int immm AU = op[2] & 0x0f;
5080 if (trace)
5081 {
5082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5083 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5084 op[0], op[1], op[2]);
5085 printf (" immm = 0x%x\n", immm);
5086 }
5087 SYNTAX("mvtipl #%1");
4ce8c66d 5088#line 1023 "rx-decode.opc"
946ef196 5089 ID(mvtipl); SC(immm);
43e65147 5090
946ef196
DD		 5091 }
5092 break;
5093 default: UNSUPPORTED(); break;
5094 }
5095 break;
4ce8c66d
YS		 5096 case 0x90:
5097 GETBYTE ();
5098 switch (op[2] & 0xff)
5099 {
5100 case 0x1b:
5101 {
5102 /** 0111 0101 1001 0000 0001 1011 mvfdr */
5103 if (trace)
5104 {
5105 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5106 "/** 0111 0101 1001 0000 0001 1011 mvfdr */",
5107 op[0], op[1], op[2]);
5108 }
5109 SYNTAX("mvfdr");
5110#line 1229 "rx-decode.opc"
5111 ID(mvfdr); F_____;
5112
5113 }
5114 break;
5115 default: UNSUPPORTED(); break;
5116 }
c7927a3c 5117 break;
4ce8c66d
YS		 5118 case 0xa0:
5119 GETBYTE ();
5120 switch (op[2] & 0x00)
c7927a3c 5121 {
4ce8c66d
YS		 5122 case 0x00:
5123 {
5124 /** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */
5125#line 1223 "rx-decode.opc"
5126 int rdst AU = (op[2] >> 4) & 0x0f;
5127#line 1223 "rx-decode.opc"
5128 int rnum AU = op[2] & 0x0f;
5129 if (trace)
5130 {
5131 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5132 "/** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */",
5133 op[0], op[1], op[2]);
5134 printf (" rdst = 0x%x,", rdst);
5135 printf (" rnum = 0x%x\n", rnum);
5136 }
5137 SYNTAX("dpushm.l %1-%2");
5138#line 1223 "rx-decode.opc"
5139 ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____;
43e65147 5140
4ce8c66d
YS		 5141 }
5142 break;
c7927a3c
NC		 5143 }
5144 break;
4ce8c66d
YS		 5145 case 0xa8:
5146 GETBYTE ();
5147 switch (op[2] & 0x00)
c7927a3c 5148 {
4ce8c66d
YS		 5149 case 0x00:
5150 {
5151 /** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */
5152#line 1217 "rx-decode.opc"
5153 int rdst AU = (op[2] >> 4) & 0x0f;
5154#line 1217 "rx-decode.opc"
5155 int rnum AU = op[2] & 0x0f;
5156 if (trace)
5157 {
5158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5159 "/** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */",
5160 op[0], op[1], op[2]);
5161 printf (" rdst = 0x%x,", rdst);
5162 printf (" rnum = 0x%x\n", rnum);
5163 }
5164 SYNTAX("dpopm.l %1-%2");
5165#line 1217 "rx-decode.opc"
5166 ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____;
43e65147 5167
4ce8c66d
YS		 5168 }
5169 break;
c7927a3c
NC		 5170 }
5171 break;
4ce8c66d
YS		 5172 case 0xb0:
5173 GETBYTE ();
5174 switch (op[2] & 0x00)
c7927a3c 5175 {
4ce8c66d
YS		 5176 case 0x00:
5177 {
5178 /** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */
5179#line 1220 "rx-decode.opc"
5180 int rdst AU = (op[2] >> 4) & 0x0f;
5181#line 1220 "rx-decode.opc"
5182 int rnum AU = op[2] & 0x0f;
5183 if (trace)
5184 {
5185 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5186 "/** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */",
5187 op[0], op[1], op[2]);
5188 printf (" rdst = 0x%x,", rdst);
5189 printf (" rnum = 0x%x\n", rnum);
5190 }
5191 SYNTAX("dpushm.d %1-%2");
5192#line 1220 "rx-decode.opc"
5193 ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____;
43e65147 5194
4ce8c66d
YS		 5195 }
5196 break;
c7927a3c
NC		 5197 }
5198 break;
4ce8c66d
YS		 5199 case 0xb8:
5200 GETBYTE ();
5201 switch (op[2] & 0x00)
5202 {
5203 case 0x00:
5204 {
5205 /** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */
5206#line 1214 "rx-decode.opc"
5207 int rdst AU = (op[2] >> 4) & 0x0f;
5208#line 1214 "rx-decode.opc"
5209 int rnum AU = op[2] & 0x0f;
5210 if (trace)
5211 {
5212 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5213 "/** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */",
5214 op[0], op[1], op[2]);
5215 printf (" rdst = 0x%x,", rdst);
5216 printf (" rnum = 0x%x\n", rnum);
5217 }
5218 SYNTAX("dpopm.d %1-%2");
5219#line 1214 "rx-decode.opc"
5220 ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____;
5221
5222 }
5223 break;
5224 }
c7927a3c 5225 break;
4ce8c66d 5226 default: UNSUPPORTED(); break;
c7927a3c
NC		 5227 }
5228 break;
4ce8c66d 5229 case 0x76:
c7927a3c 5230 GETBYTE ();
4ce8c66d 5231 switch (op[1] & 0xff)
c7927a3c
NC		 5232 {
5233 case 0x00:
4ce8c66d
YS		 5234 case 0x01:
5235 case 0x02:
5236 case 0x03:
5237 case 0x04:
5238 case 0x05:
5239 case 0x06:
5240 case 0x07:
5241 case 0x08:
5242 case 0x09:
5243 case 0x0a:
5244 case 0x0b:
5245 case 0x0c:
5246 case 0x0d:
5247 case 0x0e:
5248 case 0x0f:
5249 goto op_semantics_32;
c7927a3c
NC		 5250 break;
5251 case 0x10:
4ce8c66d
YS		 5252 case 0x11:
5253 case 0x12:
5254 case 0x13:
5255 case 0x14:
5256 case 0x15:
5257 case 0x16:
5258 case 0x17:
5259 case 0x18:
5260 case 0x19:
5261 case 0x1a:
5262 case 0x1b:
5263 case 0x1c:
5264 case 0x1d:
5265 case 0x1e:
5266 case 0x1f:
5267 goto op_semantics_33;
c7927a3c
NC		 5268 break;
5269 case 0x20:
4ce8c66d
YS		 5270 case 0x21:
5271 case 0x22:
5272 case 0x23:
5273 case 0x24:
5274 case 0x25:
5275 case 0x26:
5276 case 0x27:
5277 case 0x28:
5278 case 0x29:
5279 case 0x2a:
5280 case 0x2b:
5281 case 0x2c:
5282 case 0x2d:
5283 case 0x2e:
5284 case 0x2f:
5285 goto op_semantics_34;
5286 break;
5287 case 0x30:
5288 case 0x31:
5289 case 0x32:
5290 case 0x33:
5291 case 0x34:
5292 case 0x35:
5293 case 0x36:
5294 case 0x37:
5295 case 0x38:
5296 case 0x39:
5297 case 0x3a:
5298 case 0x3b:
5299 case 0x3c:
5300 case 0x3d:
5301 case 0x3e:
5302 case 0x3f:
5303 goto op_semantics_35;
5304 break;
5305 case 0x90:
5306 GETBYTE ();
5307 switch (op[2] & 0xff)
5308 {
5309 case 0x00:
5310 GETBYTE ();
5311 switch (op[3] & 0x00)
5312 {
5313 case 0x00:
5314 op_semantics_36:
5315 {
5316 /** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */
5317#line 1238 "rx-decode.opc"
5318 int srcb AU = (op[2] >> 4) & 0x0f;
5319#line 1238 "rx-decode.opc"
5320 int rdst AU = (op[3] >> 4) & 0x0f;
5321#line 1238 "rx-decode.opc"
5322 int srca AU = op[3] & 0x0f;
5323 if (trace)
5324 {
5325 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5326 "/** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */",
5327 op[0], op[1], op[2], op[3]);
5328 printf (" srcb = 0x%x,", srcb);
5329 printf (" rdst = 0x%x,", rdst);
5330 printf (" srca = 0x%x\n", srca);
5331 }
5332 SYNTAX("dadd %1, %2, %0");
5333#line 1238 "rx-decode.opc"
5334 ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5335
5336 }
5337 break;
5338 }
5339 break;
5340 case 0x01:
5341 GETBYTE ();
5342 switch (op[3] & 0x00)
5343 {
5344 case 0x00:
5345 op_semantics_37:
5346 {
5347 /** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */
5348#line 1259 "rx-decode.opc"
5349 int srcb AU = (op[2] >> 4) & 0x0f;
5350#line 1259 "rx-decode.opc"
5351 int rdst AU = (op[3] >> 4) & 0x0f;
5352#line 1259 "rx-decode.opc"
5353 int srca AU = op[3] & 0x0f;
5354 if (trace)
5355 {
5356 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5357 "/** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */",
5358 op[0], op[1], op[2], op[3]);
5359 printf (" srcb = 0x%x,", srcb);
5360 printf (" rdst = 0x%x,", rdst);
5361 printf (" srca = 0x%x\n", srca);
5362 }
5363 SYNTAX("dsub %1, %2, %0");
5364#line 1259 "rx-decode.opc"
5365 ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5366
5367 }
5368 break;
5369 }
5370 break;
5371 case 0x02:
5372 GETBYTE ();
5373 switch (op[3] & 0x00)
5374 {
5375 case 0x00:
5376 op_semantics_38:
5377 {
5378 /** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */
5379#line 1247 "rx-decode.opc"
5380 int srcb AU = (op[2] >> 4) & 0x0f;
5381#line 1247 "rx-decode.opc"
5382 int rdst AU = (op[3] >> 4) & 0x0f;
5383#line 1247 "rx-decode.opc"
5384 int srca AU = op[3] & 0x0f;
5385 if (trace)
5386 {
5387 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5388 "/** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */",
5389 op[0], op[1], op[2], op[3]);
5390 printf (" srcb = 0x%x,", srcb);
5391 printf (" rdst = 0x%x,", rdst);
5392 printf (" srca = 0x%x\n", srca);
5393 }
5394 SYNTAX("dmul %1, %2, %0");
5395#line 1247 "rx-decode.opc"
5396 ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5397
5398 }
5399 break;
5400 }
5401 break;
5402 case 0x05:
5403 GETBYTE ();
5404 switch (op[3] & 0x00)
5405 {
5406 case 0x00:
5407 op_semantics_39:
5408 {
5409 /** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */
5410#line 1244 "rx-decode.opc"
5411 int srcb AU = (op[2] >> 4) & 0x0f;
5412#line 1244 "rx-decode.opc"
5413 int rdst AU = (op[3] >> 4) & 0x0f;
5414#line 1244 "rx-decode.opc"
5415 int srca AU = op[3] & 0x0f;
5416 if (trace)
5417 {
5418 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5419 "/** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */",
5420 op[0], op[1], op[2], op[3]);
5421 printf (" srcb = 0x%x,", srcb);
5422 printf (" rdst = 0x%x,", rdst);
5423 printf (" srca = 0x%x\n", srca);
5424 }
5425 SYNTAX("ddiv %1, %2, %0");
5426#line 1244 "rx-decode.opc"
5427 ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5428
5429 }
5430 break;
5431 }
5432 break;
5433 case 0x08:
5434 GETBYTE ();
5435 switch (op[3] & 0x00)
5436 {
5437 case 0x00:
5438 op_semantics_40:
5439 {
5440 /** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */
5441#line 1241 "rx-decode.opc"
5442 int srcb AU = (op[2] >> 4) & 0x0f;
5443#line 1241 "rx-decode.opc"
5444 int cond AU = (op[3] >> 4) & 0x0f;
5445#line 1241 "rx-decode.opc"
5446 int srca AU = op[3] & 0x0f;
5447 if (trace)
5448 {
5449 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5450 "/** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */",
5451 op[0], op[1], op[2], op[3]);
5452 printf (" srcb = 0x%x,", srcb);
5453 printf (" cond = 0x%x,", cond);
5454 printf (" srca = 0x%x\n", srca);
5455 }
5456 SYNTAX("dcmp%0 %1, %2");
5457#line 1241 "rx-decode.opc"
5458 ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____;
5459
5460 }
5461 break;
5462 }
5463 break;
5464 case 0x0c:
5465 GETBYTE ();
5466 switch (op[3] & 0x0f)
5467 {
5468 case 0x00:
5469 op_semantics_41:
5470 {
5471 /** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */
5472#line 1179 "rx-decode.opc"
5473 int rsrc AU = (op[2] >> 4) & 0x0f;
5474#line 1179 "rx-decode.opc"
5475 int rdst AU = (op[3] >> 4) & 0x0f;
5476 if (trace)
5477 {
5478 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5479 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */",
5480 op[0], op[1], op[2], op[3]);
5481 printf (" rsrc = 0x%x,", rsrc);
5482 printf (" rdst = 0x%x\n", rdst);
5483 }
5484 SYNTAX("dmov.d %1, %0");
5485#line 1179 "rx-decode.opc"
5486 ID(dmov); DDR(rdst); SDR(rsrc); F_____;
5487
5488 }
5489 break;
5490 case 0x01:
5491 op_semantics_42:
5492 {
5493 /** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */
5494#line 1235 "rx-decode.opc"
5495 int rsrc AU = (op[2] >> 4) & 0x0f;
5496#line 1235 "rx-decode.opc"
5497 int rdst AU = (op[3] >> 4) & 0x0f;
5498 if (trace)
5499 {
5500 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5501 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */",
5502 op[0], op[1], op[2], op[3]);
5503 printf (" rsrc = 0x%x,", rsrc);
5504 printf (" rdst = 0x%x\n", rdst);
5505 }
5506 SYNTAX("dabs %1, %0");
5507#line 1235 "rx-decode.opc"
5508 ID(dabs); DDR(rdst); SDR(rsrc); F_____;
5509
5510 }
5511 break;
5512 case 0x02:
5513 op_semantics_43:
5514 {
5515 /** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */
5516#line 1250 "rx-decode.opc"
5517 int rsrc AU = (op[2] >> 4) & 0x0f;
5518#line 1250 "rx-decode.opc"
5519 int rdst AU = (op[3] >> 4) & 0x0f;
5520 if (trace)
5521 {
5522 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5523 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */",
5524 op[0], op[1], op[2], op[3]);
5525 printf (" rsrc = 0x%x,", rsrc);
5526 printf (" rdst = 0x%x\n", rdst);
5527 }
5528 SYNTAX("dneg %1, %0");
5529#line 1250 "rx-decode.opc"
5530 ID(dneg); DDR(rdst); SDR(rsrc); F_____;
5531
5532 }
5533 break;
5534 default: UNSUPPORTED(); break;
5535 }
5536 break;
5537 case 0x0d:
5538 GETBYTE ();
5539 switch (op[3] & 0x0f)
5540 {
5541 case 0x00:
5542 op_semantics_44:
5543 {
5544 /** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */
5545#line 1256 "rx-decode.opc"
5546 int rsrc AU = (op[2] >> 4) & 0x0f;
5547#line 1256 "rx-decode.opc"
5548 int rdst AU = (op[3] >> 4) & 0x0f;
5549 if (trace)
5550 {
5551 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5552 "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */",
5553 op[0], op[1], op[2], op[3]);
5554 printf (" rsrc = 0x%x,", rsrc);
5555 printf (" rdst = 0x%x\n", rdst);
5556 }
5557 SYNTAX("dsqrt %1, %0");
5558#line 1256 "rx-decode.opc"
5559 ID(dsqrt); DDR(rdst); SDR(rsrc); F_____;
5560
5561 }
5562 break;
5563 case 0x08:
5564 op_semantics_45:
5565 {
5566 /** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */
5567#line 1265 "rx-decode.opc"
5568 int rsrc AU = (op[2] >> 4) & 0x0f;
5569#line 1265 "rx-decode.opc"
5570 int rdst AU = (op[3] >> 4) & 0x0f;
5571 if (trace)
5572 {
5573 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5574 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */",
5575 op[0], op[1], op[2], op[3]);
5576 printf (" rsrc = 0x%x,", rsrc);
5577 printf (" rdst = 0x%x\n", rdst);
5578 }
5579 SYNTAX("dtoi %1, %0");
5580#line 1265 "rx-decode.opc"
5581 ID(dtoi); DDR(rdst); SDR(rsrc); F_____;
5582
5583 }
5584 break;
5585 case 0x09:
5586 op_semantics_46:
5587 {
5588 /** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */
5589#line 1268 "rx-decode.opc"
5590 int rsrc AU = (op[2] >> 4) & 0x0f;
5591#line 1268 "rx-decode.opc"
5592 int rdst AU = (op[3] >> 4) & 0x0f;
5593 if (trace)
5594 {
5595 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5596 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */",
5597 op[0], op[1], op[2], op[3]);
5598 printf (" rsrc = 0x%x,", rsrc);
5599 printf (" rdst = 0x%x\n", rdst);
5600 }
5601 SYNTAX("dtou %1, %0");
5602#line 1268 "rx-decode.opc"
5603 ID(dtou); DDR(rdst); SDR(rsrc); F_____;
5604
5605 }
5606 break;
5607 case 0x0c:
5608 op_semantics_47:
5609 {
5610 /** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */
5611#line 1262 "rx-decode.opc"
5612 int rsrc AU = (op[2] >> 4) & 0x0f;
5613#line 1262 "rx-decode.opc"
5614 int rdst AU = (op[3] >> 4) & 0x0f;
5615 if (trace)
5616 {
5617 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5618 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */",
5619 op[0], op[1], op[2], op[3]);
5620 printf (" rsrc = 0x%x,", rsrc);
5621 printf (" rdst = 0x%x\n", rdst);
5622 }
5623 SYNTAX("dtof %1, %0");
5624#line 1262 "rx-decode.opc"
5625 ID(dtof); DDR(rdst); SDR(rsrc); F_____;
5626
5627 }
5628 break;
5629 case 0x0d:
5630 op_semantics_48:
5631 {
5632 /** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */
5633#line 1253 "rx-decode.opc"
5634 int rsrc AU = (op[2] >> 4) & 0x0f;
5635#line 1253 "rx-decode.opc"
5636 int rdst AU = (op[3] >> 4) & 0x0f;
5637 if (trace)
5638 {
5639 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5640 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */",
5641 op[0], op[1], op[2], op[3]);
5642 printf (" rsrc = 0x%x,", rsrc);
5643 printf (" rdst = 0x%x\n", rdst);
5644 }
5645 SYNTAX("dround %1, %0");
5646#line 1253 "rx-decode.opc"
5647 ID(dround); DDR(rdst); SDR(rsrc); F_____;
5648
5649 }
5650 break;
5651 default: UNSUPPORTED(); break;
5652 }
5653 break;
5654 case 0x10:
5655 GETBYTE ();
5656 switch (op[3] & 0x00)
5657 {
5658 case 0x00:
5659 goto op_semantics_36;
5660 break;
5661 }
5662 break;
5663 case 0x11:
5664 GETBYTE ();
5665 switch (op[3] & 0x00)
5666 {
5667 case 0x00:
5668 goto op_semantics_37;
5669 break;
5670 }
5671 break;
5672 case 0x12:
5673 GETBYTE ();
5674 switch (op[3] & 0x00)
5675 {
5676 case 0x00:
5677 goto op_semantics_38;
5678 break;
5679 }
5680 break;
5681 case 0x15:
5682 GETBYTE ();
5683 switch (op[3] & 0x00)
5684 {
5685 case 0x00:
5686 goto op_semantics_39;
5687 break;
5688 }
5689 break;
5690 case 0x18:
5691 GETBYTE ();
5692 switch (op[3] & 0x00)
5693 {
5694 case 0x00:
5695 goto op_semantics_40;
5696 break;
5697 }
5698 break;
5699 case 0x1c:
5700 GETBYTE ();
5701 switch (op[3] & 0x0f)
5702 {
5703 case 0x00:
5704 goto op_semantics_41;
5705 break;
5706 case 0x01:
5707 goto op_semantics_42;
5708 break;
5709 case 0x02:
5710 goto op_semantics_43;
5711 break;
5712 default: UNSUPPORTED(); break;
5713 }
5714 break;
5715 case 0x1d:
5716 GETBYTE ();
5717 switch (op[3] & 0x0f)
5718 {
5719 case 0x00:
5720 goto op_semantics_44;
5721 break;
5722 case 0x08:
5723 goto op_semantics_45;
5724 break;
5725 case 0x09:
5726 goto op_semantics_46;
5727 break;
5728 case 0x0c:
5729 goto op_semantics_47;
5730 break;
5731 case 0x0d:
5732 goto op_semantics_48;
5733 break;
5734 default: UNSUPPORTED(); break;
5735 }
5736 break;
5737 case 0x20:
5738 GETBYTE ();
5739 switch (op[3] & 0x00)
5740 {
5741 case 0x00:
5742 goto op_semantics_36;
5743 break;
5744 }
5745 break;
5746 case 0x21:
5747 GETBYTE ();
5748 switch (op[3] & 0x00)
5749 {
5750 case 0x00:
5751 goto op_semantics_37;
5752 break;
5753 }
5754 break;
5755 case 0x22:
5756 GETBYTE ();
5757 switch (op[3] & 0x00)
5758 {
5759 case 0x00:
5760 goto op_semantics_38;
5761 break;
5762 }
5763 break;
5764 case 0x25:
5765 GETBYTE ();
5766 switch (op[3] & 0x00)
5767 {
5768 case 0x00:
5769 goto op_semantics_39;
5770 break;
5771 }
5772 break;
5773 case 0x28:
5774 GETBYTE ();
5775 switch (op[3] & 0x00)
5776 {
5777 case 0x00:
5778 goto op_semantics_40;
5779 break;
5780 }
5781 break;
5782 case 0x2c:
5783 GETBYTE ();
5784 switch (op[3] & 0x0f)
5785 {
5786 case 0x00:
5787 goto op_semantics_41;
5788 break;
5789 case 0x01:
5790 goto op_semantics_42;
5791 break;
5792 case 0x02:
5793 goto op_semantics_43;
5794 break;
5795 default: UNSUPPORTED(); break;
5796 }
5797 break;
5798 case 0x2d:
5799 GETBYTE ();
5800 switch (op[3] & 0x0f)
5801 {
5802 case 0x00:
5803 goto op_semantics_44;
5804 break;
5805 case 0x08:
5806 goto op_semantics_45;
5807 break;
5808 case 0x09:
5809 goto op_semantics_46;
5810 break;
5811 case 0x0c:
5812 goto op_semantics_47;
5813 break;
5814 case 0x0d:
5815 goto op_semantics_48;
5816 break;
5817 default: UNSUPPORTED(); break;
5818 }
5819 break;
5820 case 0x30:
5821 GETBYTE ();
5822 switch (op[3] & 0x00)
5823 {
5824 case 0x00:
5825 goto op_semantics_36;
5826 break;
5827 }
5828 break;
5829 case 0x31:
5830 GETBYTE ();
5831 switch (op[3] & 0x00)
5832 {
5833 case 0x00:
5834 goto op_semantics_37;
5835 break;
5836 }
5837 break;
5838 case 0x32:
5839 GETBYTE ();
5840 switch (op[3] & 0x00)
5841 {
5842 case 0x00:
5843 goto op_semantics_38;
5844 break;
5845 }
5846 break;
5847 case 0x35:
5848 GETBYTE ();
5849 switch (op[3] & 0x00)
5850 {
5851 case 0x00:
5852 goto op_semantics_39;
5853 break;
5854 }
5855 break;
5856 case 0x38:
5857 GETBYTE ();
5858 switch (op[3] & 0x00)
5859 {
5860 case 0x00:
5861 goto op_semantics_40;
5862 break;
5863 }
5864 break;
5865 case 0x3c:
5866 GETBYTE ();
5867 switch (op[3] & 0x0f)
5868 {
5869 case 0x00:
5870 goto op_semantics_41;
5871 break;
5872 case 0x01:
5873 goto op_semantics_42;
5874 break;
5875 case 0x02:
5876 goto op_semantics_43;
5877 break;
5878 default: UNSUPPORTED(); break;
5879 }
5880 break;
5881 case 0x3d:
5882 GETBYTE ();
5883 switch (op[3] & 0x0f)
5884 {
5885 case 0x00:
5886 goto op_semantics_44;
5887 break;
5888 case 0x08:
5889 goto op_semantics_45;
5890 break;
5891 case 0x09:
5892 goto op_semantics_46;
5893 break;
5894 case 0x0c:
5895 goto op_semantics_47;
5896 break;
5897 case 0x0d:
5898 goto op_semantics_48;
5899 break;
5900 default: UNSUPPORTED(); break;
5901 }
5902 break;
5903 case 0x40:
5904 GETBYTE ();
5905 switch (op[3] & 0x00)
5906 {
5907 case 0x00:
5908 goto op_semantics_36;
5909 break;
5910 }
5911 break;
5912 case 0x41:
5913 GETBYTE ();
5914 switch (op[3] & 0x00)
5915 {
5916 case 0x00:
5917 goto op_semantics_37;
5918 break;
5919 }
5920 break;
5921 case 0x42:
5922 GETBYTE ();
5923 switch (op[3] & 0x00)
5924 {
5925 case 0x00:
5926 goto op_semantics_38;
5927 break;
5928 }
5929 break;
5930 case 0x45:
5931 GETBYTE ();
5932 switch (op[3] & 0x00)
5933 {
5934 case 0x00:
5935 goto op_semantics_39;
5936 break;
5937 }
5938 break;
5939 case 0x48:
5940 GETBYTE ();
5941 switch (op[3] & 0x00)
5942 {
5943 case 0x00:
5944 goto op_semantics_40;
5945 break;
5946 }
5947 break;
5948 case 0x4c:
5949 GETBYTE ();
5950 switch (op[3] & 0x0f)
5951 {
5952 case 0x00:
5953 goto op_semantics_41;
5954 break;
5955 case 0x01:
5956 goto op_semantics_42;
5957 break;
5958 case 0x02:
5959 goto op_semantics_43;
5960 break;
5961 default: UNSUPPORTED(); break;
5962 }
5963 break;
5964 case 0x4d:
5965 GETBYTE ();
5966 switch (op[3] & 0x0f)
5967 {
5968 case 0x00:
5969 goto op_semantics_44;
5970 break;
5971 case 0x08:
5972 goto op_semantics_45;
5973 break;
5974 case 0x09:
5975 goto op_semantics_46;
5976 break;
5977 case 0x0c:
5978 goto op_semantics_47;
5979 break;
5980 case 0x0d:
5981 goto op_semantics_48;
5982 break;
5983 default: UNSUPPORTED(); break;
5984 }
5985 break;
5986 case 0x50:
5987 GETBYTE ();
5988 switch (op[3] & 0x00)
5989 {
5990 case 0x00:
5991 goto op_semantics_36;
5992 break;
5993 }
5994 break;
5995 case 0x51:
5996 GETBYTE ();
5997 switch (op[3] & 0x00)
5998 {
5999 case 0x00:
6000 goto op_semantics_37;
6001 break;
6002 }
6003 break;
6004 case 0x52:
6005 GETBYTE ();
6006 switch (op[3] & 0x00)
6007 {
6008 case 0x00:
6009 goto op_semantics_38;
6010 break;
6011 }
6012 break;
6013 case 0x55:
6014 GETBYTE ();
6015 switch (op[3] & 0x00)
6016 {
6017 case 0x00:
6018 goto op_semantics_39;
6019 break;
6020 }
6021 break;
6022 case 0x58:
6023 GETBYTE ();
6024 switch (op[3] & 0x00)
6025 {
6026 case 0x00:
6027 goto op_semantics_40;
6028 break;
6029 }
6030 break;
6031 case 0x5c:
6032 GETBYTE ();
6033 switch (op[3] & 0x0f)
6034 {
6035 case 0x00:
6036 goto op_semantics_41;
6037 break;
6038 case 0x01:
6039 goto op_semantics_42;
6040 break;
6041 case 0x02:
6042 goto op_semantics_43;
6043 break;
6044 default: UNSUPPORTED(); break;
6045 }
6046 break;
6047 case 0x5d:
6048 GETBYTE ();
6049 switch (op[3] & 0x0f)
6050 {
6051 case 0x00:
6052 goto op_semantics_44;
6053 break;
6054 case 0x08:
6055 goto op_semantics_45;
6056 break;
6057 case 0x09:
6058 goto op_semantics_46;
6059 break;
6060 case 0x0c:
6061 goto op_semantics_47;
6062 break;
6063 case 0x0d:
6064 goto op_semantics_48;
6065 break;
6066 default: UNSUPPORTED(); break;
6067 }
6068 break;
6069 case 0x60:
6070 GETBYTE ();
6071 switch (op[3] & 0x00)
6072 {
6073 case 0x00:
6074 goto op_semantics_36;
6075 break;
6076 }
6077 break;
6078 case 0x61:
6079 GETBYTE ();
6080 switch (op[3] & 0x00)
6081 {
6082 case 0x00:
6083 goto op_semantics_37;
6084 break;
6085 }
6086 break;
6087 case 0x62:
6088 GETBYTE ();
6089 switch (op[3] & 0x00)
6090 {
6091 case 0x00:
6092 goto op_semantics_38;
6093 break;
6094 }
6095 break;
6096 case 0x65:
6097 GETBYTE ();
6098 switch (op[3] & 0x00)
6099 {
6100 case 0x00:
6101 goto op_semantics_39;
6102 break;
6103 }
6104 break;
6105 case 0x68:
6106 GETBYTE ();
6107 switch (op[3] & 0x00)
6108 {
6109 case 0x00:
6110 goto op_semantics_40;
6111 break;
6112 }
6113 break;
6114 case 0x6c:
6115 GETBYTE ();
6116 switch (op[3] & 0x0f)
6117 {
6118 case 0x00:
6119 goto op_semantics_41;
6120 break;
6121 case 0x01:
6122 goto op_semantics_42;
6123 break;
6124 case 0x02:
6125 goto op_semantics_43;
6126 break;
6127 default: UNSUPPORTED(); break;
6128 }
6129 break;
6130 case 0x6d:
6131 GETBYTE ();
6132 switch (op[3] & 0x0f)
6133 {
6134 case 0x00:
6135 goto op_semantics_44;
6136 break;
6137 case 0x08:
6138 goto op_semantics_45;
6139 break;
6140 case 0x09:
6141 goto op_semantics_46;
6142 break;
6143 case 0x0c:
6144 goto op_semantics_47;
6145 break;
6146 case 0x0d:
6147 goto op_semantics_48;
6148 break;
6149 default: UNSUPPORTED(); break;
6150 }
6151 break;
6152 case 0x70:
6153 GETBYTE ();
6154 switch (op[3] & 0x00)
6155 {
6156 case 0x00:
6157 goto op_semantics_36;
6158 break;
6159 }
6160 break;
6161 case 0x71:
6162 GETBYTE ();
6163 switch (op[3] & 0x00)
6164 {
6165 case 0x00:
6166 goto op_semantics_37;
6167 break;
6168 }
6169 break;
6170 case 0x72:
6171 GETBYTE ();
6172 switch (op[3] & 0x00)
6173 {
6174 case 0x00:
6175 goto op_semantics_38;
6176 break;
6177 }
6178 break;
6179 case 0x75:
6180 GETBYTE ();
6181 switch (op[3] & 0x00)
6182 {
6183 case 0x00:
6184 goto op_semantics_39;
6185 break;
6186 }
6187 break;
6188 case 0x78:
6189 GETBYTE ();
6190 switch (op[3] & 0x00)
6191 {
6192 case 0x00:
6193 goto op_semantics_40;
6194 break;
6195 }
6196 break;
6197 case 0x7c:
6198 GETBYTE ();
6199 switch (op[3] & 0x0f)
6200 {
6201 case 0x00:
6202 goto op_semantics_41;
6203 break;
6204 case 0x01:
6205 goto op_semantics_42;
6206 break;
6207 case 0x02:
6208 goto op_semantics_43;
6209 break;
6210 default: UNSUPPORTED(); break;
6211 }
6212 break;
6213 case 0x7d:
6214 GETBYTE ();
6215 switch (op[3] & 0x0f)
6216 {
6217 case 0x00:
6218 goto op_semantics_44;
6219 break;
6220 case 0x08:
6221 goto op_semantics_45;
6222 break;
6223 case 0x09:
6224 goto op_semantics_46;
6225 break;
6226 case 0x0c:
6227 goto op_semantics_47;
6228 break;
6229 case 0x0d:
6230 goto op_semantics_48;
6231 break;
6232 default: UNSUPPORTED(); break;
6233 }
6234 break;
6235 case 0x80:
6236 GETBYTE ();
6237 switch (op[3] & 0x00)
6238 {
6239 case 0x00:
6240 goto op_semantics_36;
6241 break;
6242 }
6243 break;
6244 case 0x81:
6245 GETBYTE ();
6246 switch (op[3] & 0x00)
6247 {
6248 case 0x00:
6249 goto op_semantics_37;
6250 break;
6251 }
6252 break;
6253 case 0x82:
6254 GETBYTE ();
6255 switch (op[3] & 0x00)
6256 {
6257 case 0x00:
6258 goto op_semantics_38;
6259 break;
6260 }
6261 break;
6262 case 0x85:
6263 GETBYTE ();
6264 switch (op[3] & 0x00)
6265 {
6266 case 0x00:
6267 goto op_semantics_39;
6268 break;
6269 }
6270 break;
6271 case 0x88:
6272 GETBYTE ();
6273 switch (op[3] & 0x00)
6274 {
6275 case 0x00:
6276 goto op_semantics_40;
6277 break;
6278 }
6279 break;
6280 case 0x8c:
6281 GETBYTE ();
6282 switch (op[3] & 0x0f)
6283 {
6284 case 0x00:
6285 goto op_semantics_41;
6286 break;
6287 case 0x01:
6288 goto op_semantics_42;
6289 break;
6290 case 0x02:
6291 goto op_semantics_43;
6292 break;
6293 default: UNSUPPORTED(); break;
6294 }
6295 break;
6296 case 0x8d:
6297 GETBYTE ();
6298 switch (op[3] & 0x0f)
6299 {
6300 case 0x00:
6301 goto op_semantics_44;
6302 break;
6303 case 0x08:
6304 goto op_semantics_45;
6305 break;
6306 case 0x09:
6307 goto op_semantics_46;
6308 break;
6309 case 0x0c:
6310 goto op_semantics_47;
6311 break;
6312 case 0x0d:
6313 goto op_semantics_48;
6314 break;
6315 default: UNSUPPORTED(); break;
6316 }
6317 break;
6318 case 0x90:
6319 GETBYTE ();
6320 switch (op[3] & 0x00)
6321 {
6322 case 0x00:
6323 goto op_semantics_36;
6324 break;
6325 }
6326 break;
6327 case 0x91:
6328 GETBYTE ();
6329 switch (op[3] & 0x00)
6330 {
6331 case 0x00:
6332 goto op_semantics_37;
6333 break;
6334 }
6335 break;
6336 case 0x92:
6337 GETBYTE ();
6338 switch (op[3] & 0x00)
6339 {
6340 case 0x00:
6341 goto op_semantics_38;
6342 break;
6343 }
6344 break;
6345 case 0x95:
6346 GETBYTE ();
6347 switch (op[3] & 0x00)
6348 {
6349 case 0x00:
6350 goto op_semantics_39;
6351 break;
6352 }
6353 break;
6354 case 0x98:
6355 GETBYTE ();
6356 switch (op[3] & 0x00)
6357 {
6358 case 0x00:
6359 goto op_semantics_40;
6360 break;
6361 }
6362 break;
6363 case 0x9c:
6364 GETBYTE ();
6365 switch (op[3] & 0x0f)
6366 {
6367 case 0x00:
6368 goto op_semantics_41;
6369 break;
6370 case 0x01:
6371 goto op_semantics_42;
6372 break;
6373 case 0x02:
6374 goto op_semantics_43;
6375 break;
6376 default: UNSUPPORTED(); break;
6377 }
6378 break;
6379 case 0x9d:
6380 GETBYTE ();
6381 switch (op[3] & 0x0f)
6382 {
6383 case 0x00:
6384 goto op_semantics_44;
6385 break;
6386 case 0x08:
6387 goto op_semantics_45;
6388 break;
6389 case 0x09:
6390 goto op_semantics_46;
6391 break;
6392 case 0x0c:
6393 goto op_semantics_47;
6394 break;
6395 case 0x0d:
6396 goto op_semantics_48;
6397 break;
6398 default: UNSUPPORTED(); break;
6399 }
6400 break;
6401 case 0xa0:
6402 GETBYTE ();
6403 switch (op[3] & 0x00)
6404 {
6405 case 0x00:
6406 goto op_semantics_36;
6407 break;
6408 }
6409 break;
6410 case 0xa1:
6411 GETBYTE ();
6412 switch (op[3] & 0x00)
6413 {
6414 case 0x00:
6415 goto op_semantics_37;
6416 break;
6417 }
6418 break;
6419 case 0xa2:
6420 GETBYTE ();
6421 switch (op[3] & 0x00)
6422 {
6423 case 0x00:
6424 goto op_semantics_38;
6425 break;
6426 }
6427 break;
6428 case 0xa5:
6429 GETBYTE ();
6430 switch (op[3] & 0x00)
6431 {
6432 case 0x00:
6433 goto op_semantics_39;
6434 break;
6435 }
6436 break;
6437 case 0xa8:
6438 GETBYTE ();
6439 switch (op[3] & 0x00)
6440 {
6441 case 0x00:
6442 goto op_semantics_40;
6443 break;
6444 }
6445 break;
6446 case 0xac:
6447 GETBYTE ();
6448 switch (op[3] & 0x0f)
6449 {
6450 case 0x00:
6451 goto op_semantics_41;
6452 break;
6453 case 0x01:
6454 goto op_semantics_42;
6455 break;
6456 case 0x02:
6457 goto op_semantics_43;
6458 break;
6459 default: UNSUPPORTED(); break;
6460 }
6461 break;
6462 case 0xad:
6463 GETBYTE ();
6464 switch (op[3] & 0x0f)
6465 {
6466 case 0x00:
6467 goto op_semantics_44;
6468 break;
6469 case 0x08:
6470 goto op_semantics_45;
6471 break;
6472 case 0x09:
6473 goto op_semantics_46;
6474 break;
6475 case 0x0c:
6476 goto op_semantics_47;
6477 break;
6478 case 0x0d:
6479 goto op_semantics_48;
6480 break;
6481 default: UNSUPPORTED(); break;
6482 }
6483 break;
6484 case 0xb0:
6485 GETBYTE ();
6486 switch (op[3] & 0x00)
6487 {
6488 case 0x00:
6489 goto op_semantics_36;
6490 break;
6491 }
6492 break;
6493 case 0xb1:
6494 GETBYTE ();
6495 switch (op[3] & 0x00)
6496 {
6497 case 0x00:
6498 goto op_semantics_37;
6499 break;
6500 }
6501 break;
6502 case 0xb2:
6503 GETBYTE ();
6504 switch (op[3] & 0x00)
6505 {
6506 case 0x00:
6507 goto op_semantics_38;
6508 break;
6509 }
6510 break;
6511 case 0xb5:
6512 GETBYTE ();
6513 switch (op[3] & 0x00)
6514 {
6515 case 0x00:
6516 goto op_semantics_39;
6517 break;
6518 }
6519 break;
6520 case 0xb8:
6521 GETBYTE ();
6522 switch (op[3] & 0x00)
6523 {
6524 case 0x00:
6525 goto op_semantics_40;
6526 break;
6527 }
6528 break;
6529 case 0xbc:
6530 GETBYTE ();
6531 switch (op[3] & 0x0f)
6532 {
6533 case 0x00:
6534 goto op_semantics_41;
6535 break;
6536 case 0x01:
6537 goto op_semantics_42;
6538 break;
6539 case 0x02:
6540 goto op_semantics_43;
6541 break;
6542 default: UNSUPPORTED(); break;
6543 }
6544 break;
6545 case 0xbd:
6546 GETBYTE ();
6547 switch (op[3] & 0x0f)
6548 {
6549 case 0x00:
6550 goto op_semantics_44;
6551 break;
6552 case 0x08:
6553 goto op_semantics_45;
6554 break;
6555 case 0x09:
6556 goto op_semantics_46;
6557 break;
6558 case 0x0c:
6559 goto op_semantics_47;
6560 break;
6561 case 0x0d:
6562 goto op_semantics_48;
6563 break;
6564 default: UNSUPPORTED(); break;
6565 }
6566 break;
6567 case 0xc0:
6568 GETBYTE ();
6569 switch (op[3] & 0x00)
6570 {
6571 case 0x00:
6572 goto op_semantics_36;
6573 break;
6574 }
6575 break;
6576 case 0xc1:
6577 GETBYTE ();
6578 switch (op[3] & 0x00)
6579 {
6580 case 0x00:
6581 goto op_semantics_37;
6582 break;
6583 }
6584 break;
6585 case 0xc2:
6586 GETBYTE ();
6587 switch (op[3] & 0x00)
6588 {
6589 case 0x00:
6590 goto op_semantics_38;
6591 break;
6592 }
6593 break;
6594 case 0xc5:
6595 GETBYTE ();
6596 switch (op[3] & 0x00)
6597 {
6598 case 0x00:
6599 goto op_semantics_39;
6600 break;
6601 }
6602 break;
6603 case 0xc8:
6604 GETBYTE ();
6605 switch (op[3] & 0x00)
6606 {
6607 case 0x00:
6608 goto op_semantics_40;
6609 break;
6610 }
6611 break;
6612 case 0xcc:
6613 GETBYTE ();
6614 switch (op[3] & 0x0f)
6615 {
6616 case 0x00:
6617 goto op_semantics_41;
6618 break;
6619 case 0x01:
6620 goto op_semantics_42;
6621 break;
6622 case 0x02:
6623 goto op_semantics_43;
6624 break;
6625 default: UNSUPPORTED(); break;
6626 }
6627 break;
6628 case 0xcd:
6629 GETBYTE ();
6630 switch (op[3] & 0x0f)
6631 {
6632 case 0x00:
6633 goto op_semantics_44;
6634 break;
6635 case 0x08:
6636 goto op_semantics_45;
6637 break;
6638 case 0x09:
6639 goto op_semantics_46;
6640 break;
6641 case 0x0c:
6642 goto op_semantics_47;
6643 break;
6644 case 0x0d:
6645 goto op_semantics_48;
6646 break;
6647 default: UNSUPPORTED(); break;
6648 }
6649 break;
6650 case 0xd0:
6651 GETBYTE ();
6652 switch (op[3] & 0x00)
6653 {
6654 case 0x00:
6655 goto op_semantics_36;
6656 break;
6657 }
6658 break;
6659 case 0xd1:
6660 GETBYTE ();
6661 switch (op[3] & 0x00)
6662 {
6663 case 0x00:
6664 goto op_semantics_37;
6665 break;
6666 }
6667 break;
6668 case 0xd2:
6669 GETBYTE ();
6670 switch (op[3] & 0x00)
6671 {
6672 case 0x00:
6673 goto op_semantics_38;
6674 break;
6675 }
6676 break;
6677 case 0xd5:
6678 GETBYTE ();
6679 switch (op[3] & 0x00)
6680 {
6681 case 0x00:
6682 goto op_semantics_39;
6683 break;
6684 }
6685 break;
6686 case 0xd8:
6687 GETBYTE ();
6688 switch (op[3] & 0x00)
6689 {
6690 case 0x00:
6691 goto op_semantics_40;
6692 break;
6693 }
6694 break;
6695 case 0xdc:
6696 GETBYTE ();
6697 switch (op[3] & 0x0f)
6698 {
6699 case 0x00:
6700 goto op_semantics_41;
6701 break;
6702 case 0x01:
6703 goto op_semantics_42;
6704 break;
6705 case 0x02:
6706 goto op_semantics_43;
6707 break;
6708 default: UNSUPPORTED(); break;
6709 }
6710 break;
6711 case 0xdd:
6712 GETBYTE ();
6713 switch (op[3] & 0x0f)
6714 {
6715 case 0x00:
6716 goto op_semantics_44;
6717 break;
6718 case 0x08:
6719 goto op_semantics_45;
6720 break;
6721 case 0x09:
6722 goto op_semantics_46;
6723 break;
6724 case 0x0c:
6725 goto op_semantics_47;
6726 break;
6727 case 0x0d:
6728 goto op_semantics_48;
6729 break;
6730 default: UNSUPPORTED(); break;
6731 }
6732 break;
6733 case 0xe0:
6734 GETBYTE ();
6735 switch (op[3] & 0x00)
6736 {
6737 case 0x00:
6738 goto op_semantics_36;
6739 break;
6740 }
6741 break;
6742 case 0xe1:
6743 GETBYTE ();
6744 switch (op[3] & 0x00)
6745 {
6746 case 0x00:
6747 goto op_semantics_37;
6748 break;
6749 }
6750 break;
6751 case 0xe2:
6752 GETBYTE ();
6753 switch (op[3] & 0x00)
6754 {
6755 case 0x00:
6756 goto op_semantics_38;
6757 break;
6758 }
6759 break;
6760 case 0xe5:
6761 GETBYTE ();
6762 switch (op[3] & 0x00)
6763 {
6764 case 0x00:
6765 goto op_semantics_39;
6766 break;
6767 }
6768 break;
6769 case 0xe8:
6770 GETBYTE ();
6771 switch (op[3] & 0x00)
6772 {
6773 case 0x00:
6774 goto op_semantics_40;
6775 break;
6776 }
6777 break;
6778 case 0xec:
6779 GETBYTE ();
6780 switch (op[3] & 0x0f)
6781 {
6782 case 0x00:
6783 goto op_semantics_41;
6784 break;
6785 case 0x01:
6786 goto op_semantics_42;
6787 break;
6788 case 0x02:
6789 goto op_semantics_43;
6790 break;
6791 default: UNSUPPORTED(); break;
6792 }
6793 break;
6794 case 0xed:
6795 GETBYTE ();
6796 switch (op[3] & 0x0f)
6797 {
6798 case 0x00:
6799 goto op_semantics_44;
6800 break;
6801 case 0x08:
6802 goto op_semantics_45;
6803 break;
6804 case 0x09:
6805 goto op_semantics_46;
6806 break;
6807 case 0x0c:
6808 goto op_semantics_47;
6809 break;
6810 case 0x0d:
6811 goto op_semantics_48;
6812 break;
6813 default: UNSUPPORTED(); break;
6814 }
6815 break;
6816 case 0xf0:
6817 GETBYTE ();
6818 switch (op[3] & 0x00)
6819 {
6820 case 0x00:
6821 goto op_semantics_36;
6822 break;
6823 }
6824 break;
6825 case 0xf1:
6826 GETBYTE ();
6827 switch (op[3] & 0x00)
6828 {
6829 case 0x00:
6830 goto op_semantics_37;
6831 break;
6832 }
6833 break;
6834 case 0xf2:
6835 GETBYTE ();
6836 switch (op[3] & 0x00)
6837 {
6838 case 0x00:
6839 goto op_semantics_38;
6840 break;
6841 }
6842 break;
6843 case 0xf5:
6844 GETBYTE ();
6845 switch (op[3] & 0x00)
6846 {
6847 case 0x00:
6848 goto op_semantics_39;
6849 break;
6850 }
6851 break;
6852 case 0xf8:
6853 GETBYTE ();
6854 switch (op[3] & 0x00)
6855 {
6856 case 0x00:
6857 goto op_semantics_40;
6858 break;
6859 }
6860 break;
6861 case 0xfc:
6862 GETBYTE ();
6863 switch (op[3] & 0x0f)
6864 {
6865 case 0x00:
6866 goto op_semantics_41;
6867 break;
6868 case 0x01:
6869 goto op_semantics_42;
6870 break;
6871 case 0x02:
6872 goto op_semantics_43;
6873 break;
6874 default: UNSUPPORTED(); break;
6875 }
6876 break;
6877 case 0xfd:
6878 GETBYTE ();
6879 switch (op[3] & 0x0f)
6880 {
6881 case 0x00:
6882 goto op_semantics_44;
6883 break;
6884 case 0x08:
6885 goto op_semantics_45;
6886 break;
6887 case 0x09:
6888 goto op_semantics_46;
6889 break;
6890 case 0x0c:
6891 goto op_semantics_47;
6892 break;
6893 case 0x0d:
6894 goto op_semantics_48;
6895 break;
6896 default: UNSUPPORTED(); break;
6897 }
6898 break;
6899 default: UNSUPPORTED(); break;
6900 }
6901 break;
6902 default: UNSUPPORTED(); break;
6903 }
6904 break;
6905 case 0x77:
6906 GETBYTE ();
6907 switch (op[1] & 0xf0)
6908 {
6909 case 0x00:
6910 goto op_semantics_32;
6911 break;
6912 case 0x10:
6913 goto op_semantics_33;
6914 break;
6915 case 0x20:
6916 goto op_semantics_34;
6917 break;
6918 case 0x30:
6919 goto op_semantics_35;
6920 break;
6921 default: UNSUPPORTED(); break;
6922 }
6923 break;
6924 case 0x78:
6925 GETBYTE ();
6926 switch (op[1] & 0x00)
6927 {
6928 case 0x00:
6929 op_semantics_49:
6930 {
6931 /** 0111 100b ittt rdst bset #%1, %0 */
6932#line 968 "rx-decode.opc"
6933 int b AU = op[0] & 0x01;
6934#line 968 "rx-decode.opc"
6935 int ittt AU = (op[1] >> 4) & 0x0f;
6936#line 968 "rx-decode.opc"
6937 int rdst AU = op[1] & 0x0f;
6938 if (trace)
6939 {
6940 printf ("\033[33m%s\033[0m %02x %02x\n",
6941 "/** 0111 100b ittt rdst bset #%1, %0 */",
6942 op[0], op[1]);
6943 printf (" b = 0x%x,", b);
6944 printf (" ittt = 0x%x,", ittt);
6945 printf (" rdst = 0x%x\n", rdst);
6946 }
6947 SYNTAX("bset #%1, %0");
6948#line 968 "rx-decode.opc"
6949 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6950
6951
6952 }
6953 break;
6954 }
6955 break;
6956 case 0x79:
6957 GETBYTE ();
6958 switch (op[1] & 0x00)
6959 {
6960 case 0x00:
6961 goto op_semantics_49;
6962 break;
6963 }
6964 break;
6965 case 0x7a:
6966 GETBYTE ();
6967 switch (op[1] & 0x00)
6968 {
6969 case 0x00:
6970 op_semantics_50:
6971 {
6972 /** 0111 101b ittt rdst bclr #%1, %0 */
6973#line 980 "rx-decode.opc"
6974 int b AU = op[0] & 0x01;
6975#line 980 "rx-decode.opc"
6976 int ittt AU = (op[1] >> 4) & 0x0f;
6977#line 980 "rx-decode.opc"
6978 int rdst AU = op[1] & 0x0f;
6979 if (trace)
6980 {
6981 printf ("\033[33m%s\033[0m %02x %02x\n",
6982 "/** 0111 101b ittt rdst bclr #%1, %0 */",
6983 op[0], op[1]);
6984 printf (" b = 0x%x,", b);
6985 printf (" ittt = 0x%x,", ittt);
6986 printf (" rdst = 0x%x\n", rdst);
6987 }
6988 SYNTAX("bclr #%1, %0");
6989#line 980 "rx-decode.opc"
6990 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6991
6992
6993 }
6994 break;
6995 }
6996 break;
6997 case 0x7b:
6998 GETBYTE ();
6999 switch (op[1] & 0x00)
7000 {
7001 case 0x00:
7002 goto op_semantics_50;
7003 break;
7004 }
7005 break;
7006 case 0x7c:
7007 GETBYTE ();
7008 switch (op[1] & 0x00)
7009 {
7010 case 0x00:
7011 op_semantics_51:
7012 {
7013 /** 0111 110b ittt rdst btst #%2, %1 */
7014#line 992 "rx-decode.opc"
7015 int b AU = op[0] & 0x01;
7016#line 992 "rx-decode.opc"
7017 int ittt AU = (op[1] >> 4) & 0x0f;
7018#line 992 "rx-decode.opc"
7019 int rdst AU = op[1] & 0x0f;
7020 if (trace)
7021 {
7022 printf ("\033[33m%s\033[0m %02x %02x\n",
7023 "/** 0111 110b ittt rdst btst #%2, %1 */",
7024 op[0], op[1]);
7025 printf (" b = 0x%x,", b);
7026 printf (" ittt = 0x%x,", ittt);
7027 printf (" rdst = 0x%x\n", rdst);
7028 }
7029 SYNTAX("btst #%2, %1");
7030#line 992 "rx-decode.opc"
7031 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
7032
7033
7034 }
7035 break;
7036 }
7037 break;
7038 case 0x7d:
7039 GETBYTE ();
7040 switch (op[1] & 0x00)
7041 {
7042 case 0x00:
7043 goto op_semantics_51;
7044 break;
7045 }
7046 break;
7047 case 0x7e:
7048 GETBYTE ();
7049 switch (op[1] & 0xf0)
7050 {
7051 case 0x00:
7052 {
7053 /** 0111 1110 0000 rdst not %0 */
7054#line 483 "rx-decode.opc"
c7927a3c
NC		 7055 int rdst AU = op[1] & 0x0f;
7056 if (trace)
7057 {
7058 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d
YS		 7059 "/** 0111 1110 0000 rdst not %0 */",
7060 op[0], op[1]);
7061 printf (" rdst = 0x%x\n", rdst);
7062 }
7063 SYNTAX("not %0");
7064#line 483 "rx-decode.opc"
7065 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
7066
7067 }
7068 break;
7069 case 0x10:
7070 {
7071 /** 0111 1110 0001 rdst neg %0 */
7072#line 504 "rx-decode.opc"
7073 int rdst AU = op[1] & 0x0f;
7074 if (trace)
7075 {
7076 printf ("\033[33m%s\033[0m %02x %02x\n",
7077 "/** 0111 1110 0001 rdst neg %0 */",
7078 op[0], op[1]);
7079 printf (" rdst = 0x%x\n", rdst);
7080 }
7081 SYNTAX("neg %0");
7082#line 504 "rx-decode.opc"
7083 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
7084
7085 }
7086 break;
7087 case 0x20:
7088 {
7089 /** 0111 1110 0010 rdst abs %0 */
7090#line 586 "rx-decode.opc"
7091 int rdst AU = op[1] & 0x0f;
7092 if (trace)
7093 {
7094 printf ("\033[33m%s\033[0m %02x %02x\n",
7095 "/** 0111 1110 0010 rdst abs %0 */",
7096 op[0], op[1]);
7097 printf (" rdst = 0x%x\n", rdst);
7098 }
7099 SYNTAX("abs %0");
7100#line 586 "rx-decode.opc"
7101 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
7102
7103 }
7104 break;
7105 case 0x30:
7106 {
7107 /** 0111 1110 0011 rdst sat %0 */
7108#line 906 "rx-decode.opc"
7109 int rdst AU = op[1] & 0x0f;
7110 if (trace)
7111 {
7112 printf ("\033[33m%s\033[0m %02x %02x\n",
7113 "/** 0111 1110 0011 rdst sat %0 */",
7114 op[0], op[1]);
7115 printf (" rdst = 0x%x\n", rdst);
7116 }
7117 SYNTAX("sat %0");
7118#line 906 "rx-decode.opc"
7119 ID(sat); DR (rdst);
7120
7121 }
7122 break;
7123 case 0x40:
7124 {
7125 /** 0111 1110 0100 rdst rorc %0 */
7126#line 766 "rx-decode.opc"
7127 int rdst AU = op[1] & 0x0f;
7128 if (trace)
7129 {
7130 printf ("\033[33m%s\033[0m %02x %02x\n",
7131 "/** 0111 1110 0100 rdst rorc %0 */",
7132 op[0], op[1]);
7133 printf (" rdst = 0x%x\n", rdst);
7134 }
7135 SYNTAX("rorc %0");
7136#line 766 "rx-decode.opc"
7137 ID(rorc); DR(rdst); F__SZC;
7138
7139 }
7140 break;
7141 case 0x50:
7142 {
7143 /** 0111 1110 0101 rdst rolc %0 */
7144#line 763 "rx-decode.opc"
7145 int rdst AU = op[1] & 0x0f;
7146 if (trace)
7147 {
7148 printf ("\033[33m%s\033[0m %02x %02x\n",
7149 "/** 0111 1110 0101 rdst rolc %0 */",
7150 op[0], op[1]);
7151 printf (" rdst = 0x%x\n", rdst);
7152 }
7153 SYNTAX("rolc %0");
7154#line 763 "rx-decode.opc"
7155 ID(rolc); DR(rdst); F__SZC;
7156
7157 }
7158 break;
7159 case 0x80:
7160 case 0x90:
7161 case 0xa0:
7162 {
7163 /** 0111 1110 10sz rsrc push%s %1 */
7164#line 399 "rx-decode.opc"
7165 int sz AU = (op[1] >> 4) & 0x03;
7166#line 399 "rx-decode.opc"
7167 int rsrc AU = op[1] & 0x0f;
7168 if (trace)
7169 {
7170 printf ("\033[33m%s\033[0m %02x %02x\n",
7171 "/** 0111 1110 10sz rsrc push%s %1 */",
7172 op[0], op[1]);
7173 printf (" sz = 0x%x,", sz);
7174 printf (" rsrc = 0x%x\n", rsrc);
7175 }
7176 SYNTAX("push%s %1");
7177#line 399 "rx-decode.opc"
7178 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7179
7180 }
7181 break;
7182 case 0xb0:
7183 {
7184 /** 0111 1110 1011 rdst pop %0 */
7185#line 396 "rx-decode.opc"
7186 int rdst AU = op[1] & 0x0f;
7187 if (trace)
7188 {
7189 printf ("\033[33m%s\033[0m %02x %02x\n",
7190 "/** 0111 1110 1011 rdst pop %0 */",
7191 op[0], op[1]);
7192 printf (" rdst = 0x%x\n", rdst);
7193 }
7194 SYNTAX("pop %0");
7195#line 396 "rx-decode.opc"
7196 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7197
7198 }
7199 break;
7200 case 0xc0:
7201 case 0xd0:
7202 {
7203 /** 0111 1110 110 crsrc pushc %1 */
7204#line 1029 "rx-decode.opc"
7205 int crsrc AU = op[1] & 0x1f;
7206 if (trace)
7207 {
7208 printf ("\033[33m%s\033[0m %02x %02x\n",
7209 "/** 0111 1110 110 crsrc pushc %1 */",
7210 op[0], op[1]);
7211 printf (" crsrc = 0x%x\n", crsrc);
7212 }
7213 SYNTAX("pushc %1");
7214#line 1029 "rx-decode.opc"
7215 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7216
7217 }
7218 break;
7219 case 0xe0:
7220 case 0xf0:
7221 {
7222 /** 0111 1110 111 crdst popc %0 */
7223#line 1026 "rx-decode.opc"
7224 int crdst AU = op[1] & 0x1f;
7225 if (trace)
7226 {
7227 printf ("\033[33m%s\033[0m %02x %02x\n",
7228 "/** 0111 1110 111 crdst popc %0 */",
7229 op[0], op[1]);
7230 printf (" crdst = 0x%x\n", crdst);
7231 }
7232 SYNTAX("popc %0");
7233#line 1026 "rx-decode.opc"
7234 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7235
7236 }
7237 break;
7238 default: UNSUPPORTED(); break;
7239 }
7240 break;
7241 case 0x7f:
7242 GETBYTE ();
7243 switch (op[1] & 0xff)
7244 {
7245 case 0x00:
7246 case 0x01:
7247 case 0x02:
7248 case 0x03:
7249 case 0x04:
7250 case 0x05:
7251 case 0x06:
7252 case 0x07:
7253 case 0x08:
7254 case 0x09:
7255 case 0x0a:
7256 case 0x0b:
7257 case 0x0c:
7258 case 0x0d:
7259 case 0x0e:
7260 case 0x0f:
7261 {
7262 /** 0111 1111 0000 rsrc jmp %0 */
7263#line 816 "rx-decode.opc"
7264 int rsrc AU = op[1] & 0x0f;
7265 if (trace)
7266 {
7267 printf ("\033[33m%s\033[0m %02x %02x\n",
7268 "/** 0111 1111 0000 rsrc jmp %0 */",
7269 op[0], op[1]);
7270 printf (" rsrc = 0x%x\n", rsrc);
7271 }
7272 SYNTAX("jmp %0");
7273#line 816 "rx-decode.opc"
7274 ID(branch); DR(rsrc);
7275
7276 }
7277 break;
7278 case 0x10:
7279 case 0x11:
7280 case 0x12:
7281 case 0x13:
7282 case 0x14:
7283 case 0x15:
7284 case 0x16:
7285 case 0x17:
7286 case 0x18:
7287 case 0x19:
7288 case 0x1a:
7289 case 0x1b:
7290 case 0x1c:
7291 case 0x1d:
7292 case 0x1e:
7293 case 0x1f:
7294 {
7295 /** 0111 1111 0001 rsrc jsr %0 */
7296#line 819 "rx-decode.opc"
7297 int rsrc AU = op[1] & 0x0f;
7298 if (trace)
7299 {
7300 printf ("\033[33m%s\033[0m %02x %02x\n",
7301 "/** 0111 1111 0001 rsrc jsr %0 */",
7302 op[0], op[1]);
7303 printf (" rsrc = 0x%x\n", rsrc);
7304 }
7305 SYNTAX("jsr %0");
7306#line 819 "rx-decode.opc"
7307 ID(jsr); DR(rsrc);
7308
7309 }
7310 break;
7311 case 0x40:
7312 case 0x41:
7313 case 0x42:
7314 case 0x43:
7315 case 0x44:
7316 case 0x45:
7317 case 0x46:
7318 case 0x47:
7319 case 0x48:
7320 case 0x49:
7321 case 0x4a:
7322 case 0x4b:
7323 case 0x4c:
7324 case 0x4d:
7325 case 0x4e:
7326 case 0x4f:
7327 {
7328 /** 0111 1111 0100 rsrc bra.l %0 */
7329#line 812 "rx-decode.opc"
7330 int rsrc AU = op[1] & 0x0f;
7331 if (trace)
7332 {
7333 printf ("\033[33m%s\033[0m %02x %02x\n",
7334 "/** 0111 1111 0100 rsrc bra.l %0 */",
7335 op[0], op[1]);
7336 printf (" rsrc = 0x%x\n", rsrc);
7337 }
7338 SYNTAX("bra.l %0");
7339#line 812 "rx-decode.opc"
7340 ID(branchrel); DR(rsrc);
7341
7342
7343 }
7344 break;
7345 case 0x50:
7346 case 0x51:
7347 case 0x52:
7348 case 0x53:
7349 case 0x54:
7350 case 0x55:
7351 case 0x56:
7352 case 0x57:
7353 case 0x58:
7354 case 0x59:
7355 case 0x5a:
7356 case 0x5b:
7357 case 0x5c:
7358 case 0x5d:
7359 case 0x5e:
7360 case 0x5f:
7361 {
7362 /** 0111 1111 0101 rsrc bsr.l %0 */
7363#line 828 "rx-decode.opc"
7364 int rsrc AU = op[1] & 0x0f;
7365 if (trace)
7366 {
7367 printf ("\033[33m%s\033[0m %02x %02x\n",
7368 "/** 0111 1111 0101 rsrc bsr.l %0 */",
7369 op[0], op[1]);
7370 printf (" rsrc = 0x%x\n", rsrc);
7371 }
7372 SYNTAX("bsr.l %0");
7373#line 828 "rx-decode.opc"
7374 ID(jsrrel); DR(rsrc);
7375
7376 }
7377 break;
7378 case 0x80:
7379 case 0x81:
7380 case 0x82:
7381 {
7382 /** 0111 1111 1000 00sz suntil%s */
7383#line 852 "rx-decode.opc"
7384 int sz AU = op[1] & 0x03;
7385 if (trace)
7386 {
7387 printf ("\033[33m%s\033[0m %02x %02x\n",
7388 "/** 0111 1111 1000 00sz suntil%s */",
7389 op[0], op[1]);
7390 printf (" sz = 0x%x\n", sz);
7391 }
7392 SYNTAX("suntil%s");
7393#line 852 "rx-decode.opc"
7394 ID(suntil); BWL(sz); F___ZC;
7395
7396 }
7397 break;
7398 case 0x83:
7399 {
7400 /** 0111 1111 1000 0011 scmpu */
7401 if (trace)
7402 {
7403 printf ("\033[33m%s\033[0m %02x %02x\n",
7404 "/** 0111 1111 1000 0011 scmpu */",
7405 op[0], op[1]);
7406 }
7407 SYNTAX("scmpu");
7408#line 843 "rx-decode.opc"
7409 ID(scmpu); F___ZC;
7410
7411 }
7412 break;
7413 case 0x84:
7414 case 0x85:
7415 case 0x86:
7416 {
7417 /** 0111 1111 1000 01sz swhile%s */
7418#line 855 "rx-decode.opc"
7419 int sz AU = op[1] & 0x03;
7420 if (trace)
7421 {
7422 printf ("\033[33m%s\033[0m %02x %02x\n",
7423 "/** 0111 1111 1000 01sz swhile%s */",
7424 op[0], op[1]);
7425 printf (" sz = 0x%x\n", sz);
7426 }
7427 SYNTAX("swhile%s");
7428#line 855 "rx-decode.opc"
7429 ID(swhile); BWL(sz); F___ZC;
7430
7431 }
7432 break;
7433 case 0x87:
7434 {
7435 /** 0111 1111 1000 0111 smovu */
7436 if (trace)
7437 {
7438 printf ("\033[33m%s\033[0m %02x %02x\n",
7439 "/** 0111 1111 1000 0111 smovu */",
7440 op[0], op[1]);
7441 }
7442 SYNTAX("smovu");
7443#line 846 "rx-decode.opc"
7444 ID(smovu);
7445
7446 }
7447 break;
7448 case 0x88:
7449 case 0x89:
7450 case 0x8a:
7451 {
7452 /** 0111 1111 1000 10sz sstr%s */
7453#line 861 "rx-decode.opc"
7454 int sz AU = op[1] & 0x03;
7455 if (trace)
7456 {
7457 printf ("\033[33m%s\033[0m %02x %02x\n",
7458 "/** 0111 1111 1000 10sz sstr%s */",
c7927a3c 7459 op[0], op[1]);
4ce8c66d 7460 printf (" sz = 0x%x\n", sz);
c7927a3c 7461 }
4ce8c66d
YS		 7462 SYNTAX("sstr%s");
7463#line 861 "rx-decode.opc"
7464 ID(sstr); BWL(sz);
7465
7466 /*----------------------------------------------------------------------*/
7467 /* RMPA */
43e65147 7468
c7927a3c
NC		 7469 }
7470 break;
4ce8c66d 7471 case 0x8b:
c7927a3c 7472 {
4ce8c66d 7473 /** 0111 1111 1000 1011 smovb */
c7927a3c
NC		 7474 if (trace)
7475 {
7476 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7477 "/** 0111 1111 1000 1011 smovb */",
c7927a3c 7478 op[0], op[1]);
c7927a3c 7479 }
4ce8c66d
YS		 7480 SYNTAX("smovb");
7481#line 849 "rx-decode.opc"
7482 ID(smovb);
43e65147 7483
c7927a3c
NC		 7484 }
7485 break;
4ce8c66d
YS		 7486 case 0x8c:
7487 case 0x8d:
7488 case 0x8e:
c7927a3c 7489 {
4ce8c66d
YS		 7490 /** 0111 1111 1000 11sz rmpa%s */
7491#line 867 "rx-decode.opc"
7492 int sz AU = op[1] & 0x03;
c7927a3c
NC		 7493 if (trace)
7494 {
7495 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7496 "/** 0111 1111 1000 11sz rmpa%s */",
c7927a3c 7497 op[0], op[1]);
4ce8c66d 7498 printf (" sz = 0x%x\n", sz);
c7927a3c 7499 }
4ce8c66d
YS		 7500 SYNTAX("rmpa%s");
7501#line 867 "rx-decode.opc"
7502 ID(rmpa); BWL(sz); F_OS__;
7503
7504 /*----------------------------------------------------------------------*/
7505 /* HI/LO stuff */
43e65147 7506
c7927a3c
NC		 7507 }
7508 break;
4ce8c66d 7509 case 0x8f:
c7927a3c 7510 {
4ce8c66d 7511 /** 0111 1111 1000 1111 smovf */
c7927a3c
NC		 7512 if (trace)
7513 {
7514 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7515 "/** 0111 1111 1000 1111 smovf */",
c7927a3c 7516 op[0], op[1]);
c7927a3c 7517 }
4ce8c66d
YS		 7518 SYNTAX("smovf");
7519#line 858 "rx-decode.opc"
7520 ID(smovf);
43e65147 7521
c7927a3c
NC		 7522 }
7523 break;
4ce8c66d 7524 case 0x93:
c7927a3c 7525 {
4ce8c66d 7526 /** 0111 1111 1001 0011 satr */
c7927a3c
NC		 7527 if (trace)
7528 {
7529 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7530 "/** 0111 1111 1001 0011 satr */",
c7927a3c 7531 op[0], op[1]);
c7927a3c 7532 }
4ce8c66d
YS		 7533 SYNTAX("satr");
7534#line 909 "rx-decode.opc"
7535 ID(satr);
7536
7537 /*----------------------------------------------------------------------*/
7538 /* FLOAT */
43e65147 7539
c7927a3c
NC		 7540 }
7541 break;
4ce8c66d 7542 case 0x94:
c7927a3c 7543 {
4ce8c66d 7544 /** 0111 1111 1001 0100 rtfi */
c7927a3c
NC		 7545 if (trace)
7546 {
7547 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7548 "/** 0111 1111 1001 0100 rtfi */",
c7927a3c 7549 op[0], op[1]);
c7927a3c 7550 }
4ce8c66d
YS		 7551 SYNTAX("rtfi");
7552#line 1044 "rx-decode.opc"
7553 ID(rtfi);
43e65147 7554
c7927a3c
NC		 7555 }
7556 break;
4ce8c66d 7557 case 0x95:
c7927a3c 7558 {
4ce8c66d 7559 /** 0111 1111 1001 0101 rte */
c7927a3c
NC		 7560 if (trace)
7561 {
7562 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7563 "/** 0111 1111 1001 0101 rte */",
c7927a3c 7564 op[0], op[1]);
c7927a3c 7565 }
4ce8c66d
YS		 7566 SYNTAX("rte");
7567#line 1047 "rx-decode.opc"
7568 ID(rte);
43e65147 7569
c7927a3c
NC		 7570 }
7571 break;
4ce8c66d 7572 case 0x96:
c7927a3c 7573 {
4ce8c66d 7574 /** 0111 1111 1001 0110 wait */
c7927a3c
NC		 7575 if (trace)
7576 {
7577 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7578 "/** 0111 1111 1001 0110 wait */",
c7927a3c 7579 op[0], op[1]);
c7927a3c 7580 }
4ce8c66d
YS		 7581 SYNTAX("wait");
7582#line 1059 "rx-decode.opc"
7583 ID(wait);
7584
7585 /*----------------------------------------------------------------------*/
7586 /* SCcnd */
43e65147 7587
c7927a3c
NC		 7588 }
7589 break;
4ce8c66d
YS		 7590 case 0xa0:
7591 case 0xa1:
7592 case 0xa2:
7593 case 0xa3:
7594 case 0xa4:
7595 case 0xa5:
7596 case 0xa6:
7597 case 0xa7:
7598 case 0xa8:
7599 case 0xa9:
7600 case 0xaa:
7601 case 0xab:
7602 case 0xac:
7603 case 0xad:
7604 case 0xae:
7605 case 0xaf:
c7927a3c 7606 {
4ce8c66d
YS		 7607 /** 0111 1111 1010 rdst setpsw %0 */
7608#line 1020 "rx-decode.opc"
7609 int rdst AU = op[1] & 0x0f;
c7927a3c
NC		 7610 if (trace)
7611 {
7612 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7613 "/** 0111 1111 1010 rdst setpsw %0 */",
c7927a3c 7614 op[0], op[1]);
4ce8c66d 7615 printf (" rdst = 0x%x\n", rdst);
c7927a3c 7616 }
4ce8c66d
YS		 7617 SYNTAX("setpsw %0");
7618#line 1020 "rx-decode.opc"
7619 ID(setpsw); DF(rdst);
43e65147 7620
c7927a3c
NC		 7621 }
7622 break;
4ce8c66d
YS		 7623 case 0xb0:
7624 case 0xb1:
7625 case 0xb2:
7626 case 0xb3:
7627 case 0xb4:
7628 case 0xb5:
7629 case 0xb6:
7630 case 0xb7:
7631 case 0xb8:
7632 case 0xb9:
7633 case 0xba:
7634 case 0xbb:
7635 case 0xbc:
7636 case 0xbd:
7637 case 0xbe:
7638 case 0xbf:
c7927a3c 7639 {
4ce8c66d
YS		 7640 /** 0111 1111 1011 rdst clrpsw %0 */
7641#line 1017 "rx-decode.opc"
7642 int rdst AU = op[1] & 0x0f;
7643 if (trace)
7644 {
7645 printf ("\033[33m%s\033[0m %02x %02x\n",
7646 "/** 0111 1111 1011 rdst clrpsw %0 */",
7647 op[0], op[1]);
7648 printf (" rdst = 0x%x\n", rdst);
7649 }
7650 SYNTAX("clrpsw %0");
7651#line 1017 "rx-decode.opc"
7652 ID(clrpsw); DF(rdst);
7653
7654 }
7655 break;
7656 default: UNSUPPORTED(); break;
7657 }
7658 break;
7659 case 0x80:
7660 GETBYTE ();
7661 switch (op[1] & 0x00)
7662 {
7663 case 0x00:
7664 op_semantics_52:
7665 {
7666 /** 10sz 0dsp a dst b src mov%s %1, %0 */
7667#line 357 "rx-decode.opc"
7668 int sz AU = (op[0] >> 4) & 0x03;
7669#line 357 "rx-decode.opc"
7670 int dsp AU = op[0] & 0x07;
7671#line 357 "rx-decode.opc"
7672 int a AU = (op[1] >> 7) & 0x01;
7673#line 357 "rx-decode.opc"
7674 int dst AU = (op[1] >> 4) & 0x07;
7675#line 357 "rx-decode.opc"
7676 int b AU = (op[1] >> 3) & 0x01;
7677#line 357 "rx-decode.opc"
7678 int src AU = op[1] & 0x07;
c7927a3c
NC		 7679 if (trace)
7680 {
7681 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7682 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
c7927a3c 7683 op[0], op[1]);
4ce8c66d
YS		 7684 printf (" sz = 0x%x,", sz);
7685 printf (" dsp = 0x%x,", dsp);
7686 printf (" a = 0x%x,", a);
7687 printf (" dst = 0x%x,", dst);
7688 printf (" b = 0x%x,", b);
7689 printf (" src = 0x%x\n", src);
c7927a3c 7690 }
4ce8c66d
YS		 7691 SYNTAX("mov%s %1, %0");
7692#line 357 "rx-decode.opc"
7693 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
43e65147 7694
c7927a3c
NC		 7695 }
7696 break;
4ce8c66d
YS		 7697 }
7698 break;
7699 case 0x81:
7700 GETBYTE ();
7701 switch (op[1] & 0x00)
7702 {
7703 case 0x00:
7704 goto op_semantics_52;
7705 break;
7706 }
7707 break;
7708 case 0x82:
7709 GETBYTE ();
7710 switch (op[1] & 0x00)
7711 {
7712 case 0x00:
7713 goto op_semantics_52;
7714 break;
7715 }
7716 break;
7717 case 0x83:
7718 GETBYTE ();
7719 switch (op[1] & 0x00)
7720 {
7721 case 0x00:
7722 goto op_semantics_52;
7723 break;
7724 }
7725 break;
7726 case 0x84:
7727 GETBYTE ();
7728 switch (op[1] & 0x00)
7729 {
7730 case 0x00:
7731 goto op_semantics_52;
7732 break;
7733 }
7734 break;
7735 case 0x85:
7736 GETBYTE ();
7737 switch (op[1] & 0x00)
7738 {
7739 case 0x00:
7740 goto op_semantics_52;
7741 break;
7742 }
7743 break;
7744 case 0x86:
7745 GETBYTE ();
7746 switch (op[1] & 0x00)
7747 {
7748 case 0x00:
7749 goto op_semantics_52;
7750 break;
7751 }
7752 break;
7753 case 0x87:
7754 GETBYTE ();
7755 switch (op[1] & 0x00)
7756 {
7757 case 0x00:
7758 goto op_semantics_52;
7759 break;
7760 }
7761 break;
7762 case 0x88:
7763 GETBYTE ();
7764 switch (op[1] & 0x00)
7765 {
7766 case 0x00:
7767 op_semantics_53:
c7927a3c 7768 {
4ce8c66d
YS		 7769 /** 10sz 1dsp a src b dst mov%s %1, %0 */
7770#line 354 "rx-decode.opc"
7771 int sz AU = (op[0] >> 4) & 0x03;
7772#line 354 "rx-decode.opc"
7773 int dsp AU = op[0] & 0x07;
7774#line 354 "rx-decode.opc"
7775 int a AU = (op[1] >> 7) & 0x01;
7776#line 354 "rx-decode.opc"
7777 int src AU = (op[1] >> 4) & 0x07;
7778#line 354 "rx-decode.opc"
7779 int b AU = (op[1] >> 3) & 0x01;
7780#line 354 "rx-decode.opc"
7781 int dst AU = op[1] & 0x07;
c7927a3c
NC		 7782 if (trace)
7783 {
7784 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 7785 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
c7927a3c 7786 op[0], op[1]);
4ce8c66d
YS		 7787 printf (" sz = 0x%x,", sz);
7788 printf (" dsp = 0x%x,", dsp);
7789 printf (" a = 0x%x,", a);
7790 printf (" src = 0x%x,", src);
7791 printf (" b = 0x%x,", b);
7792 printf (" dst = 0x%x\n", dst);
c7927a3c 7793 }
4ce8c66d
YS		 7794 SYNTAX("mov%s %1, %0");
7795#line 354 "rx-decode.opc"
7796 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
43e65147 7797
c7927a3c
NC		 7798 }
7799 break;
4ce8c66d
YS		 7800 }
7801 break;
7802 case 0x89:
7803 GETBYTE ();
7804 switch (op[1] & 0x00)
7805 {
7806 case 0x00:
7807 goto op_semantics_53;
7808 break;
7809 }
7810 break;
7811 case 0x8a:
7812 GETBYTE ();
7813 switch (op[1] & 0x00)
7814 {
7815 case 0x00:
7816 goto op_semantics_53;
7817 break;
7818 }
7819 break;
7820 case 0x8b:
7821 GETBYTE ();
7822 switch (op[1] & 0x00)
7823 {
7824 case 0x00:
7825 goto op_semantics_53;
7826 break;
7827 }
7828 break;
7829 case 0x8c:
7830 GETBYTE ();
7831 switch (op[1] & 0x00)
7832 {
7833 case 0x00:
7834 goto op_semantics_53;
7835 break;
7836 }
7837 break;
7838 case 0x8d:
7839 GETBYTE ();
7840 switch (op[1] & 0x00)
7841 {
7842 case 0x00:
7843 goto op_semantics_53;
7844 break;
7845 }
7846 break;
7847 case 0x8e:
7848 GETBYTE ();
7849 switch (op[1] & 0x00)
7850 {
7851 case 0x00:
7852 goto op_semantics_53;
7853 break;
7854 }
7855 break;
7856 case 0x8f:
7857 GETBYTE ();
7858 switch (op[1] & 0x00)
7859 {
7860 case 0x00:
7861 goto op_semantics_53;
7862 break;
7863 }
7864 break;
7865 case 0x90:
7866 GETBYTE ();
7867 switch (op[1] & 0x00)
7868 {
7869 case 0x00:
7870 goto op_semantics_52;
7871 break;
7872 }
7873 break;
7874 case 0x91:
7875 GETBYTE ();
7876 switch (op[1] & 0x00)
7877 {
7878 case 0x00:
7879 goto op_semantics_52;
7880 break;
7881 }
7882 break;
7883 case 0x92:
7884 GETBYTE ();
7885 switch (op[1] & 0x00)
7886 {
7887 case 0x00:
7888 goto op_semantics_52;
7889 break;
7890 }
7891 break;
7892 case 0x93:
7893 GETBYTE ();
7894 switch (op[1] & 0x00)
7895 {
7896 case 0x00:
7897 goto op_semantics_52;
7898 break;
7899 }
7900 break;
7901 case 0x94:
7902 GETBYTE ();
7903 switch (op[1] & 0x00)
7904 {
7905 case 0x00:
7906 goto op_semantics_52;
7907 break;
7908 }
7909 break;
7910 case 0x95:
7911 GETBYTE ();
7912 switch (op[1] & 0x00)
7913 {
7914 case 0x00:
7915 goto op_semantics_52;
7916 break;
7917 }
7918 break;
7919 case 0x96:
7920 GETBYTE ();
7921 switch (op[1] & 0x00)
7922 {
7923 case 0x00:
7924 goto op_semantics_52;
7925 break;
7926 }
7927 break;
7928 case 0x97:
7929 GETBYTE ();
7930 switch (op[1] & 0x00)
7931 {
7932 case 0x00:
7933 goto op_semantics_52;
7934 break;
7935 }
7936 break;
7937 case 0x98:
7938 GETBYTE ();
7939 switch (op[1] & 0x00)
7940 {
7941 case 0x00:
7942 goto op_semantics_53;
7943 break;
7944 }
7945 break;
7946 case 0x99:
7947 GETBYTE ();
7948 switch (op[1] & 0x00)
7949 {
7950 case 0x00:
7951 goto op_semantics_53;
7952 break;
7953 }
7954 break;
7955 case 0x9a:
7956 GETBYTE ();
7957 switch (op[1] & 0x00)
7958 {
7959 case 0x00:
7960 goto op_semantics_53;
c7927a3c 7961 break;
4ce8c66d
YS		 7962 }
7963 break;
7964 case 0x9b:
7965 GETBYTE ();
7966 switch (op[1] & 0x00)
7967 {
7968 case 0x00:
7969 goto op_semantics_53;
c7927a3c 7970 break;
4ce8c66d
YS		 7971 }
7972 break;
7973 case 0x9c:
7974 GETBYTE ();
7975 switch (op[1] & 0x00)
7976 {
7977 case 0x00:
7978 goto op_semantics_53;
c7927a3c 7979 break;
4ce8c66d
YS		 7980 }
7981 break;
7982 case 0x9d:
7983 GETBYTE ();
7984 switch (op[1] & 0x00)
7985 {
7986 case 0x00:
7987 goto op_semantics_53;
c7927a3c 7988 break;
4ce8c66d
YS		 7989 }
7990 break;
7991 case 0x9e:
7992 GETBYTE ();
7993 switch (op[1] & 0x00)
7994 {
7995 case 0x00:
7996 goto op_semantics_53;
c7927a3c 7997 break;
4ce8c66d
YS		 7998 }
7999 break;
8000 case 0x9f:
8001 GETBYTE ();
8002 switch (op[1] & 0x00)
8003 {
8004 case 0x00:
8005 goto op_semantics_53;
c7927a3c 8006 break;
4ce8c66d
YS		 8007 }
8008 break;
8009 case 0xa0:
8010 GETBYTE ();
8011 switch (op[1] & 0x00)
8012 {
8013 case 0x00:
8014 goto op_semantics_52;
c7927a3c 8015 break;
4ce8c66d
YS		 8016 }
8017 break;
8018 case 0xa1:
8019 GETBYTE ();
8020 switch (op[1] & 0x00)
8021 {
8022 case 0x00:
8023 goto op_semantics_52;
c7927a3c 8024 break;
4ce8c66d
YS		 8025 }
8026 break;
8027 case 0xa2:
8028 GETBYTE ();
8029 switch (op[1] & 0x00)
8030 {
8031 case 0x00:
8032 goto op_semantics_52;
c7927a3c 8033 break;
4ce8c66d
YS		 8034 }
8035 break;
8036 case 0xa3:
8037 GETBYTE ();
8038 switch (op[1] & 0x00)
8039 {
8040 case 0x00:
8041 goto op_semantics_52;
c7927a3c 8042 break;
4ce8c66d
YS		 8043 }
8044 break;
8045 case 0xa4:
8046 GETBYTE ();
8047 switch (op[1] & 0x00)
8048 {
8049 case 0x00:
8050 goto op_semantics_52;
c7927a3c 8051 break;
4ce8c66d
YS		 8052 }
8053 break;
8054 case 0xa5:
8055 GETBYTE ();
8056 switch (op[1] & 0x00)
8057 {
8058 case 0x00:
8059 goto op_semantics_52;
c7927a3c 8060 break;
4ce8c66d
YS		 8061 }
8062 break;
8063 case 0xa6:
8064 GETBYTE ();
8065 switch (op[1] & 0x00)
8066 {
8067 case 0x00:
8068 goto op_semantics_52;
c7927a3c 8069 break;
4ce8c66d
YS		 8070 }
8071 break;
8072 case 0xa7:
8073 GETBYTE ();
8074 switch (op[1] & 0x00)
8075 {
8076 case 0x00:
8077 goto op_semantics_52;
c7927a3c 8078 break;
c7927a3c
NC		 8079 }
8080 break;
4ce8c66d 8081 case 0xa8:
c7927a3c
NC		 8082 GETBYTE ();
8083 switch (op[1] & 0x00)
8084 {
8085 case 0x00:
4ce8c66d 8086 goto op_semantics_53;
c7927a3c
NC		 8087 break;
8088 }
8089 break;
4ce8c66d 8090 case 0xa9:
c7927a3c
NC		 8091 GETBYTE ();
8092 switch (op[1] & 0x00)
8093 {
8094 case 0x00:
4ce8c66d 8095 goto op_semantics_53;
c7927a3c
NC		 8096 break;
8097 }
8098 break;
4ce8c66d 8099 case 0xaa:
c7927a3c
NC		 8100 GETBYTE ();
8101 switch (op[1] & 0x00)
8102 {
8103 case 0x00:
4ce8c66d 8104 goto op_semantics_53;
c7927a3c
NC		 8105 break;
8106 }
8107 break;
4ce8c66d 8108 case 0xab:
c7927a3c
NC		 8109 GETBYTE ();
8110 switch (op[1] & 0x00)
8111 {
8112 case 0x00:
4ce8c66d 8113 goto op_semantics_53;
c7927a3c
NC		 8114 break;
8115 }
8116 break;
4ce8c66d 8117 case 0xac:
c7927a3c
NC		 8118 GETBYTE ();
8119 switch (op[1] & 0x00)
8120 {
8121 case 0x00:
4ce8c66d 8122 goto op_semantics_53;
c7927a3c
NC		 8123 break;
8124 }
8125 break;
4ce8c66d 8126 case 0xad:
c7927a3c
NC		 8127 GETBYTE ();
8128 switch (op[1] & 0x00)
8129 {
8130 case 0x00:
4ce8c66d 8131 goto op_semantics_53;
c7927a3c
NC		 8132 break;
8133 }
8134 break;
4ce8c66d 8135 case 0xae:
c7927a3c
NC		 8136 GETBYTE ();
8137 switch (op[1] & 0x00)
8138 {
8139 case 0x00:
4ce8c66d 8140 goto op_semantics_53;
c7927a3c
NC		 8141 break;
8142 }
8143 break;
4ce8c66d 8144 case 0xaf:
c7927a3c
NC		 8145 GETBYTE ();
8146 switch (op[1] & 0x00)
8147 {
8148 case 0x00:
4ce8c66d 8149 goto op_semantics_53;
c7927a3c
NC		 8150 break;
8151 }
8152 break;
4ce8c66d 8153 case 0xb0:
c7927a3c
NC		 8154 GETBYTE ();
8155 switch (op[1] & 0x00)
8156 {
8157 case 0x00:
4ce8c66d 8158 op_semantics_54:
c7927a3c 8159 {
4ce8c66d
YS		 8160 /** 1011 w dsp a src b dst movu%s %1, %0 */
8161#line 377 "rx-decode.opc"
8162 int w AU = (op[0] >> 3) & 0x01;
8163#line 377 "rx-decode.opc"
c7927a3c 8164 int dsp AU = op[0] & 0x07;
4ce8c66d 8165#line 377 "rx-decode.opc"
c7927a3c 8166 int a AU = (op[1] >> 7) & 0x01;
4ce8c66d 8167#line 377 "rx-decode.opc"
c7927a3c 8168 int src AU = (op[1] >> 4) & 0x07;
4ce8c66d 8169#line 377 "rx-decode.opc"
c7927a3c 8170 int b AU = (op[1] >> 3) & 0x01;
4ce8c66d 8171#line 377 "rx-decode.opc"
c7927a3c
NC		 8172 int dst AU = op[1] & 0x07;
8173 if (trace)
8174 {
8175 printf ("\033[33m%s\033[0m %02x %02x\n",
4ce8c66d 8176 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
c7927a3c 8177 op[0], op[1]);
4ce8c66d 8178 printf (" w = 0x%x,", w);
c7927a3c
NC		 8179 printf (" dsp = 0x%x,", dsp);
8180 printf (" a = 0x%x,", a);
8181 printf (" src = 0x%x,", src);
8182 printf (" b = 0x%x,", b);
8183 printf (" dst = 0x%x\n", dst);
8184 }
4ce8c66d
YS		 8185 SYNTAX("movu%s %1, %0");
8186#line 377 "rx-decode.opc"
8187 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
43e65147 8188
c7927a3c
NC		 8189 }
8190 break;
8191 }
8192 break;
4ce8c66d 8193 case 0xb1:
c7927a3c
NC		 8194 GETBYTE ();
8195 switch (op[1] & 0x00)
8196 {
8197 case 0x00:
4ce8c66d 8198 goto op_semantics_54;
c7927a3c
NC		 8199 break;
8200 }
8201 break;
4ce8c66d 8202 case 0xb2:
c7927a3c
NC		 8203 GETBYTE ();
8204 switch (op[1] & 0x00)
8205 {
8206 case 0x00:
4ce8c66d 8207 goto op_semantics_54;
c7927a3c
NC		 8208 break;
8209 }
8210 break;
4ce8c66d 8211 case 0xb3:
c7927a3c
NC		 8212 GETBYTE ();
8213 switch (op[1] & 0x00)
8214 {
8215 case 0x00:
4ce8c66d 8216 goto op_semantics_54;
c7927a3c
NC		 8217 break;
8218 }
8219 break;
4ce8c66d 8220 case 0xb4:
c7927a3c
NC		 8221 GETBYTE ();
8222 switch (op[1] & 0x00)
8223 {
8224 case 0x00:
4ce8c66d 8225 goto op_semantics_54;
c7927a3c
NC		 8226 break;
8227 }
8228 break;
4ce8c66d 8229 case 0xb5:
c7927a3c
NC		 8230 GETBYTE ();
8231 switch (op[1] & 0x00)
8232 {
8233 case 0x00:
4ce8c66d 8234 goto op_semantics_54;
c7927a3c
NC		 8235 break;
8236 }
8237 break;
4ce8c66d 8238 case 0xb6:
c7927a3c
NC		 8239 GETBYTE ();
8240 switch (op[1] & 0x00)
8241 {
8242 case 0x00:
4ce8c66d 8243 goto op_semantics_54;
c7927a3c
NC		 8244 break;
8245 }
8246 break;
4ce8c66d 8247 case 0xb7:
c7927a3c
NC		 8248 GETBYTE ();
8249 switch (op[1] & 0x00)
8250 {
8251 case 0x00:
4ce8c66d 8252 goto op_semantics_54;
c7927a3c
NC		 8253 break;
8254 }
8255 break;
4ce8c66d 8256 case 0xb8:
c7927a3c
NC		 8257 GETBYTE ();
8258 switch (op[1] & 0x00)
8259 {
8260 case 0x00:
4ce8c66d 8261 goto op_semantics_54;
c7927a3c
NC		 8262 break;
8263 }
8264 break;
4ce8c66d 8265 case 0xb9:
c7927a3c
NC		 8266 GETBYTE ();
8267 switch (op[1] & 0x00)
8268 {
8269 case 0x00:
4ce8c66d 8270 goto op_semantics_54;
c7927a3c
NC		 8271 break;
8272 }
8273 break;
4ce8c66d 8274 case 0xba:
c7927a3c
NC		 8275 GETBYTE ();
8276 switch (op[1] & 0x00)
8277 {
8278 case 0x00:
4ce8c66d 8279 goto op_semantics_54;
c7927a3c
NC		 8280 break;
8281 }
8282 break;
4ce8c66d 8283 case 0xbb:
c7927a3c
NC		 8284 GETBYTE ();
8285 switch (op[1] & 0x00)
8286 {
8287 case 0x00:
4ce8c66d 8288 goto op_semantics_54;
c7927a3c
NC		 8289 break;
8290 }
8291 break;
4ce8c66d 8292 case 0xbc:
c7927a3c
NC		 8293 GETBYTE ();
8294 switch (op[1] & 0x00)
8295 {
8296 case 0x00:
4ce8c66d 8297 goto op_semantics_54;
c7927a3c
NC		 8298 break;
8299 }
8300 break;
4ce8c66d 8301 case 0xbd:
c7927a3c
NC		 8302 GETBYTE ();
8303 switch (op[1] & 0x00)
8304 {
8305 case 0x00:
4ce8c66d 8306 goto op_semantics_54;
c7927a3c
NC		 8307 break;
8308 }
8309 break;
4ce8c66d 8310 case 0xbe:
c7927a3c
NC		 8311 GETBYTE ();
8312 switch (op[1] & 0x00)
8313 {
8314 case 0x00:
4ce8c66d 8315 goto op_semantics_54;
c7927a3c
NC		 8316 break;
8317 }
8318 break;
4ce8c66d 8319 case 0xbf:
c7927a3c
NC		 8320 GETBYTE ();
8321 switch (op[1] & 0x00)
8322 {
8323 case 0x00:
4ce8c66d 8324 goto op_semantics_54;
c7927a3c
NC		 8325 break;
8326 }
8327 break;
4ce8c66d 8328 case 0xc0:
c7927a3c
NC		 8329 GETBYTE ();
8330 switch (op[1] & 0x00)
8331 {
8332 case 0x00:
4ce8c66d
YS		 8333 op_semantics_55:
8334 {
8335 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
8336#line 335 "rx-decode.opc"
8337 int sz AU = (op[0] >> 4) & 0x03;
8338#line 335 "rx-decode.opc"
8339 int sd AU = (op[0] >> 2) & 0x03;
8340#line 335 "rx-decode.opc"
8341 int ss AU = op[0] & 0x03;
8342#line 335 "rx-decode.opc"
8343 int rsrc AU = (op[1] >> 4) & 0x0f;
8344#line 335 "rx-decode.opc"
8345 int rdst AU = op[1] & 0x0f;
8346 if (trace)
8347 {
8348 printf ("\033[33m%s\033[0m %02x %02x\n",
8349 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
8350 op[0], op[1]);
8351 printf (" sz = 0x%x,", sz);
8352 printf (" sd = 0x%x,", sd);
8353 printf (" ss = 0x%x,", ss);
8354 printf (" rsrc = 0x%x,", rsrc);
8355 printf (" rdst = 0x%x\n", rdst);
8356 }
8357 SYNTAX("mov%s %1, %0");
8358#line 335 "rx-decode.opc"
8359 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
8360 {
8361 ID(nop2);
8362 SYNTAX ("nop\t; mov.l\tr0, r0");
8363 }
8364 else
8365 {
8366 ID(mov); sBWL(sz); F_____;
8367 if ((ss == 3) && (sd != 3))
8368 {
8369 SD(ss, rdst, sz); DD(sd, rsrc, sz);
8370 }
8371 else
8372 {
8373 SD(ss, rsrc, sz); DD(sd, rdst, sz);
8374 }
8375 }
8376
8377 }
c7927a3c
NC		 8378 break;
8379 }
8380 break;
4ce8c66d 8381 case 0xc1:
c7927a3c
NC		 8382 GETBYTE ();
8383 switch (op[1] & 0x00)
8384 {
8385 case 0x00:
4ce8c66d 8386 goto op_semantics_55;
c7927a3c
NC		 8387 break;
8388 }
8389 break;
4ce8c66d 8390 case 0xc2:
c7927a3c
NC		 8391 GETBYTE ();
8392 switch (op[1] & 0x00)
8393 {
8394 case 0x00:
4ce8c66d 8395 goto op_semantics_55;
c7927a3c
NC		 8396 break;
8397 }
8398 break;
4ce8c66d 8399 case 0xc3:
c7927a3c
NC		 8400 GETBYTE ();
8401 switch (op[1] & 0x00)
8402 {
8403 case 0x00:
4ce8c66d 8404 goto op_semantics_55;
c7927a3c
NC		 8405 break;
8406 }
8407 break;
4ce8c66d 8408 case 0xc4:
c7927a3c
NC		 8409 GETBYTE ();
8410 switch (op[1] & 0x00)
8411 {
8412 case 0x00:
4ce8c66d 8413 goto op_semantics_55;
c7927a3c
NC		 8414 break;
8415 }
8416 break;
4ce8c66d 8417 case 0xc5:
c7927a3c
NC		 8418 GETBYTE ();
8419 switch (op[1] & 0x00)
8420 {
8421 case 0x00:
4ce8c66d 8422 goto op_semantics_55;
c7927a3c
NC		 8423 break;
8424 }
8425 break;
4ce8c66d 8426 case 0xc6:
c7927a3c
NC		 8427 GETBYTE ();
8428 switch (op[1] & 0x00)
8429 {
8430 case 0x00:
4ce8c66d 8431 goto op_semantics_55;
c7927a3c
NC		 8432 break;
8433 }
8434 break;
4ce8c66d 8435 case 0xc7:
c7927a3c
NC		 8436 GETBYTE ();
8437 switch (op[1] & 0x00)
8438 {
8439 case 0x00:
4ce8c66d 8440 goto op_semantics_55;
c7927a3c
NC		 8441 break;
8442 }
8443 break;
4ce8c66d 8444 case 0xc8:
c7927a3c
NC		 8445 GETBYTE ();
8446 switch (op[1] & 0x00)
8447 {
8448 case 0x00:
4ce8c66d 8449 goto op_semantics_55;
c7927a3c
NC		 8450 break;
8451 }
8452 break;
4ce8c66d 8453 case 0xc9:
c7927a3c
NC		 8454 GETBYTE ();
8455 switch (op[1] & 0x00)
8456 {
8457 case 0x00:
4ce8c66d 8458 goto op_semantics_55;
c7927a3c
NC		 8459 break;
8460 }
8461 break;
4ce8c66d 8462 case 0xca:
c7927a3c
NC		 8463 GETBYTE ();
8464 switch (op[1] & 0x00)
8465 {
8466 case 0x00:
4ce8c66d 8467 goto op_semantics_55;
c7927a3c
NC		 8468 break;
8469 }
8470 break;
4ce8c66d 8471 case 0xcb:
c7927a3c
NC		 8472 GETBYTE ();
8473 switch (op[1] & 0x00)
8474 {
8475 case 0x00:
4ce8c66d 8476 goto op_semantics_55;
c7927a3c
NC		 8477 break;
8478 }
8479 break;
4ce8c66d 8480 case 0xcc:
c7927a3c
NC		 8481 GETBYTE ();
8482 switch (op[1] & 0x00)
8483 {
8484 case 0x00:
4ce8c66d 8485 goto op_semantics_55;
c7927a3c
NC		 8486 break;
8487 }
8488 break;
4ce8c66d 8489 case 0xcd:
c7927a3c
NC		 8490 GETBYTE ();
8491 switch (op[1] & 0x00)
8492 {
8493 case 0x00:
4ce8c66d 8494 goto op_semantics_55;
c7927a3c
NC		 8495 break;
8496 }
8497 break;
4ce8c66d 8498 case 0xce:
c7927a3c
NC		 8499 GETBYTE ();
8500 switch (op[1] & 0x00)
8501 {
8502 case 0x00:
4ce8c66d 8503 goto op_semantics_55;
c7927a3c
NC		 8504 break;
8505 }
8506 break;
4ce8c66d 8507 case 0xcf:
c7927a3c
NC		 8508 GETBYTE ();
8509 switch (op[1] & 0x00)
8510 {
8511 case 0x00:
4ce8c66d 8512 goto op_semantics_55;
c7927a3c
NC		 8513 break;
8514 }
8515 break;
4ce8c66d 8516 case 0xd0:
c7927a3c
NC		 8517 GETBYTE ();
8518 switch (op[1] & 0x00)
8519 {
8520 case 0x00:
4ce8c66d 8521 goto op_semantics_55;
c7927a3c
NC		 8522 break;
8523 }
8524 break;
4ce8c66d 8525 case 0xd1:
c7927a3c
NC		 8526 GETBYTE ();
8527 switch (op[1] & 0x00)
8528 {
8529 case 0x00:
4ce8c66d 8530 goto op_semantics_55;
c7927a3c
NC		 8531 break;
8532 }
8533 break;
4ce8c66d 8534 case 0xd2:
c7927a3c
NC		 8535 GETBYTE ();
8536 switch (op[1] & 0x00)
8537 {
8538 case 0x00:
4ce8c66d 8539 goto op_semantics_55;
c7927a3c
NC		 8540 break;
8541 }
8542 break;
4ce8c66d 8543 case 0xd3:
c7927a3c
NC		 8544 GETBYTE ();
8545 switch (op[1] & 0x00)
8546 {
8547 case 0x00:
4ce8c66d 8548 goto op_semantics_55;
c7927a3c
NC		 8549 break;
8550 }
8551 break;
4ce8c66d 8552 case 0xd4:
c7927a3c
NC		 8553 GETBYTE ();
8554 switch (op[1] & 0x00)
8555 {
8556 case 0x00:
4ce8c66d 8557 goto op_semantics_55;
c7927a3c
NC		 8558 break;
8559 }
8560 break;
4ce8c66d 8561 case 0xd5:
c7927a3c
NC		 8562 GETBYTE ();
8563 switch (op[1] & 0x00)
8564 {
8565 case 0x00:
4ce8c66d 8566 goto op_semantics_55;
c7927a3c
NC		 8567 break;
8568 }
8569 break;
4ce8c66d 8570 case 0xd6:
c7927a3c
NC		 8571 GETBYTE ();
8572 switch (op[1] & 0x00)
8573 {
8574 case 0x00:
4ce8c66d 8575 goto op_semantics_55;
c7927a3c
NC		 8576 break;
8577 }
8578 break;
4ce8c66d 8579 case 0xd7:
c7927a3c
NC		 8580 GETBYTE ();
8581 switch (op[1] & 0x00)
8582 {
8583 case 0x00:
4ce8c66d 8584 goto op_semantics_55;
c7927a3c
NC		 8585 break;
8586 }
8587 break;
4ce8c66d 8588 case 0xd8:
c7927a3c
NC		 8589 GETBYTE ();
8590 switch (op[1] & 0x00)
8591 {
8592 case 0x00:
4ce8c66d 8593 goto op_semantics_55;
c7927a3c
NC		 8594 break;
8595 }
8596 break;
4ce8c66d 8597 case 0xd9:
c7927a3c
NC		 8598 GETBYTE ();
8599 switch (op[1] & 0x00)
8600 {
8601 case 0x00:
4ce8c66d 8602 goto op_semantics_55;
c7927a3c
NC		 8603 break;
8604 }
8605 break;
4ce8c66d 8606 case 0xda:
c7927a3c
NC		 8607 GETBYTE ();
8608 switch (op[1] & 0x00)
8609 {
8610 case 0x00:
4ce8c66d 8611 goto op_semantics_55;
c7927a3c
NC		 8612 break;
8613 }
8614 break;
4ce8c66d 8615 case 0xdb:
c7927a3c
NC		 8616 GETBYTE ();
8617 switch (op[1] & 0x00)
8618 {
8619 case 0x00:
4ce8c66d 8620 goto op_semantics_55;
c7927a3c
NC		 8621 break;
8622 }
8623 break;
4ce8c66d 8624 case 0xdc:
c7927a3c
NC		 8625 GETBYTE ();
8626 switch (op[1] & 0x00)
8627 {
8628 case 0x00:
4ce8c66d 8629 goto op_semantics_55;
c7927a3c
NC		 8630 break;
8631 }
8632 break;
4ce8c66d 8633 case 0xdd:
c7927a3c
NC		 8634 GETBYTE ();
8635 switch (op[1] & 0x00)
8636 {
8637 case 0x00:
4ce8c66d 8638 goto op_semantics_55;
c7927a3c
NC		 8639 break;
8640 }
8641 break;
4ce8c66d 8642 case 0xde:
c7927a3c
NC		 8643 GETBYTE ();
8644 switch (op[1] & 0x00)
8645 {
8646 case 0x00:
4ce8c66d 8647 goto op_semantics_55;
c7927a3c
NC		 8648 break;
8649 }
8650 break;
4ce8c66d 8651 case 0xdf:
c7927a3c
NC		 8652 GETBYTE ();
8653 switch (op[1] & 0x00)
8654 {
8655 case 0x00:
4ce8c66d 8656 goto op_semantics_55;
c7927a3c
NC		 8657 break;
8658 }
8659 break;
4ce8c66d 8660 case 0xe0:
c7927a3c
NC		 8661 GETBYTE ();
8662 switch (op[1] & 0x00)
8663 {
8664 case 0x00:
4ce8c66d 8665 goto op_semantics_55;
c7927a3c
NC		 8666 break;
8667 }
8668 break;
4ce8c66d 8669 case 0xe1:
c7927a3c
NC		 8670 GETBYTE ();
8671 switch (op[1] & 0x00)
8672 {
8673 case 0x00:
4ce8c66d 8674 goto op_semantics_55;
c7927a3c
NC		 8675 break;
8676 }
8677 break;
4ce8c66d 8678 case 0xe2:
c7927a3c
NC		 8679 GETBYTE ();
8680 switch (op[1] & 0x00)
8681 {
8682 case 0x00:
4ce8c66d 8683 goto op_semantics_55;
c7927a3c
NC		 8684 break;
8685 }
8686 break;
4ce8c66d 8687 case 0xe3:
c7927a3c
NC		 8688 GETBYTE ();
8689 switch (op[1] & 0x00)
8690 {
8691 case 0x00:
4ce8c66d 8692 goto op_semantics_55;
c7927a3c
NC		 8693 break;
8694 }
8695 break;
4ce8c66d 8696 case 0xe4:
c7927a3c
NC		 8697 GETBYTE ();
8698 switch (op[1] & 0x00)
8699 {
8700 case 0x00:
4ce8c66d 8701 goto op_semantics_55;
c7927a3c
NC		 8702 break;
8703 }
8704 break;
4ce8c66d 8705 case 0xe5:
c7927a3c
NC		 8706 GETBYTE ();
8707 switch (op[1] & 0x00)
8708 {
8709 case 0x00:
4ce8c66d 8710 goto op_semantics_55;
c7927a3c
NC		 8711 break;
8712 }
8713 break;
4ce8c66d 8714 case 0xe6:
c7927a3c
NC		 8715 GETBYTE ();
8716 switch (op[1] & 0x00)
8717 {
8718 case 0x00:
4ce8c66d 8719 goto op_semantics_55;
c7927a3c
NC		 8720 break;
8721 }
8722 break;
4ce8c66d 8723 case 0xe7:
c7927a3c
NC		 8724 GETBYTE ();
8725 switch (op[1] & 0x00)
8726 {
8727 case 0x00:
4ce8c66d 8728 goto op_semantics_55;
c7927a3c
NC		 8729 break;
8730 }
8731 break;
4ce8c66d 8732 case 0xe8:
c7927a3c
NC		 8733 GETBYTE ();
8734 switch (op[1] & 0x00)
8735 {
8736 case 0x00:
4ce8c66d 8737 goto op_semantics_55;
c7927a3c
NC		 8738 break;
8739 }
8740 break;
4ce8c66d 8741 case 0xe9:
c7927a3c
NC		 8742 GETBYTE ();
8743 switch (op[1] & 0x00)
8744 {
8745 case 0x00:
4ce8c66d 8746 goto op_semantics_55;
c7927a3c
NC		 8747 break;
8748 }
8749 break;
4ce8c66d 8750 case 0xea:
c7927a3c
NC		 8751 GETBYTE ();
8752 switch (op[1] & 0x00)
8753 {
8754 case 0x00:
4ce8c66d 8755 goto op_semantics_55;
c7927a3c
NC		 8756 break;
8757 }
8758 break;
4ce8c66d 8759 case 0xeb:
c7927a3c
NC		 8760 GETBYTE ();
8761 switch (op[1] & 0x00)
8762 {
8763 case 0x00:
4ce8c66d 8764 goto op_semantics_55;
c7927a3c
NC		 8765 break;
8766 }
8767 break;
4ce8c66d 8768 case 0xec:
c7927a3c
NC		 8769 GETBYTE ();
8770 switch (op[1] & 0x00)
8771 {
8772 case 0x00:
4ce8c66d 8773 goto op_semantics_55;
c7927a3c
NC		 8774 break;
8775 }
8776 break;
4ce8c66d 8777 case 0xed:
c7927a3c
NC		 8778 GETBYTE ();
8779 switch (op[1] & 0x00)
8780 {
8781 case 0x00:
4ce8c66d 8782 goto op_semantics_55;
c7927a3c
NC		 8783 break;
8784 }
8785 break;
4ce8c66d 8786 case 0xee:
c7927a3c
NC		 8787 GETBYTE ();
8788 switch (op[1] & 0x00)
8789 {
8790 case 0x00:
4ce8c66d 8791 goto op_semantics_55;
c7927a3c
NC		 8792 break;
8793 }
8794 break;
4ce8c66d 8795 case 0xef:
c7927a3c
NC		 8796 GETBYTE ();
8797 switch (op[1] & 0x00)
8798 {
8799 case 0x00:
4ce8c66d 8800 goto op_semantics_55;
c7927a3c
NC		 8801 break;
8802 }
8803 break;
4ce8c66d 8804 case 0xf0:
c7927a3c 8805 GETBYTE ();
4ce8c66d 8806 switch (op[1] & 0x08)
c7927a3c
NC		 8807 {
8808 case 0x00:
4ce8c66d
YS		 8809 op_semantics_56:
8810 {
8811 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
8812#line 960 "rx-decode.opc"
8813 int sd AU = op[0] & 0x03;
8814#line 960 "rx-decode.opc"
8815 int rdst AU = (op[1] >> 4) & 0x0f;
8816#line 960 "rx-decode.opc"
8817 int bit AU = op[1] & 0x07;
8818 if (trace)
8819 {
8820 printf ("\033[33m%s\033[0m %02x %02x\n",
8821 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
8822 op[0], op[1]);
8823 printf (" sd = 0x%x,", sd);
8824 printf (" rdst = 0x%x,", rdst);
8825 printf (" bit = 0x%x\n", bit);
8826 }
8827 SYNTAX("bset #%1, %0%S0");
8828#line 960 "rx-decode.opc"
8829 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8830
8831 }
8832 break;
8833 case 0x08:
8834 op_semantics_57:
8835 {
8836 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
8837#line 972 "rx-decode.opc"
8838 int sd AU = op[0] & 0x03;
8839#line 972 "rx-decode.opc"
8840 int rdst AU = (op[1] >> 4) & 0x0f;
8841#line 972 "rx-decode.opc"
8842 int bit AU = op[1] & 0x07;
8843 if (trace)
8844 {
8845 printf ("\033[33m%s\033[0m %02x %02x\n",
8846 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
8847 op[0], op[1]);
8848 printf (" sd = 0x%x,", sd);
8849 printf (" rdst = 0x%x,", rdst);
8850 printf (" bit = 0x%x\n", bit);
8851 }
8852 SYNTAX("bclr #%1, %0%S0");
8853#line 972 "rx-decode.opc"
8854 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8855
8856 }
c7927a3c
NC		 8857 break;
8858 }
8859 break;
4ce8c66d 8860 case 0xf1:
c7927a3c 8861 GETBYTE ();
4ce8c66d 8862 switch (op[1] & 0x08)
c7927a3c
NC		 8863 {
8864 case 0x00:
4ce8c66d
YS		 8865 goto op_semantics_56;
8866 break;
8867 case 0x08:
8868 goto op_semantics_57;
c7927a3c
NC		 8869 break;
8870 }
8871 break;
4ce8c66d 8872 case 0xf2:
c7927a3c 8873 GETBYTE ();
4ce8c66d 8874 switch (op[1] & 0x08)
c7927a3c
NC		 8875 {
8876 case 0x00:
4ce8c66d
YS		 8877 goto op_semantics_56;
8878 break;
8879 case 0x08:
8880 goto op_semantics_57;
c7927a3c
NC		 8881 break;
8882 }
8883 break;
4ce8c66d 8884 case 0xf3:
c7927a3c 8885 GETBYTE ();
4ce8c66d 8886 switch (op[1] & 0x08)
c7927a3c
NC		 8887 {
8888 case 0x00:
4ce8c66d
YS		 8889 goto op_semantics_56;
8890 break;
8891 case 0x08:
8892 goto op_semantics_57;
c7927a3c
NC		 8893 break;
8894 }
8895 break;
4ce8c66d 8896 case 0xf4:
c7927a3c 8897 GETBYTE ();
4ce8c66d 8898 switch (op[1] & 0x0c)
c7927a3c
NC		 8899 {
8900 case 0x00:
4ce8c66d
YS		 8901 case 0x04:
8902 op_semantics_58:
8903 {
8904 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
8905#line 984 "rx-decode.opc"
8906 int sd AU = op[0] & 0x03;
8907#line 984 "rx-decode.opc"
8908 int rdst AU = (op[1] >> 4) & 0x0f;
8909#line 984 "rx-decode.opc"
8910 int bit AU = op[1] & 0x07;
8911 if (trace)
8912 {
8913 printf ("\033[33m%s\033[0m %02x %02x\n",
8914 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
8915 op[0], op[1]);
8916 printf (" sd = 0x%x,", sd);
8917 printf (" rdst = 0x%x,", rdst);
8918 printf (" bit = 0x%x\n", bit);
8919 }
8920 SYNTAX("btst #%2, %1%S1");
8921#line 984 "rx-decode.opc"
8922 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
8923
8924 }
8925 break;
8926 case 0x08:
8927 op_semantics_59:
8928 {
8929 /** 1111 01ss rsrc 10sz push%s %1 */
8930#line 402 "rx-decode.opc"
8931 int ss AU = op[0] & 0x03;
8932#line 402 "rx-decode.opc"
8933 int rsrc AU = (op[1] >> 4) & 0x0f;
8934#line 402 "rx-decode.opc"
8935 int sz AU = op[1] & 0x03;
8936 if (trace)
8937 {
8938 printf ("\033[33m%s\033[0m %02x %02x\n",
8939 "/** 1111 01ss rsrc 10sz push%s %1 */",
8940 op[0], op[1]);
8941 printf (" ss = 0x%x,", ss);
8942 printf (" rsrc = 0x%x,", rsrc);
8943 printf (" sz = 0x%x\n", sz);
8944 }
8945 SYNTAX("push%s %1");
8946#line 402 "rx-decode.opc"
8947 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
8948
8949 /*----------------------------------------------------------------------*/
8950 /* XCHG */
8951
8952 }
c7927a3c 8953 break;
4ce8c66d 8954 default: UNSUPPORTED(); break;
c7927a3c
NC		 8955 }
8956 break;
4ce8c66d 8957 case 0xf5:
c7927a3c 8958 GETBYTE ();
4ce8c66d 8959 switch (op[1] & 0x0c)
c7927a3c
NC		 8960 {
8961 case 0x00:
4ce8c66d
YS		 8962 case 0x04:
8963 goto op_semantics_58;
c7927a3c 8964 break;
4ce8c66d
YS		 8965 case 0x08:
8966 goto op_semantics_59;
8967 break;
8968 default: UNSUPPORTED(); break;
c7927a3c
NC		 8969 }
8970 break;
4ce8c66d 8971 case 0xf6:
c7927a3c 8972 GETBYTE ();
4ce8c66d 8973 switch (op[1] & 0x0c)
c7927a3c
NC		 8974 {
8975 case 0x00:
4ce8c66d
YS		 8976 case 0x04:
8977 goto op_semantics_58;
c7927a3c 8978 break;
4ce8c66d
YS		 8979 case 0x08:
8980 goto op_semantics_59;
8981 break;
8982 default: UNSUPPORTED(); break;
c7927a3c
NC		 8983 }
8984 break;
4ce8c66d 8985 case 0xf7:
c7927a3c 8986 GETBYTE ();
4ce8c66d 8987 switch (op[1] & 0x0c)
c7927a3c
NC		 8988 {
8989 case 0x00:
4ce8c66d
YS		 8990 case 0x04:
8991 goto op_semantics_58;
c7927a3c 8992 break;
4ce8c66d
YS		 8993 case 0x08:
8994 goto op_semantics_59;
8995 break;
8996 default: UNSUPPORTED(); break;
c7927a3c
NC		 8997 }
8998 break;
4ce8c66d 8999 case 0xf8:
c7927a3c
NC		 9000 GETBYTE ();
9001 switch (op[1] & 0x00)
9002 {
9003 case 0x00:
4ce8c66d
YS		 9004 op_semantics_60:
9005 {
9006 /** 1111 10sd rdst im sz mov%s #%1, %0 */
9007#line 313 "rx-decode.opc"
9008 int sd AU = op[0] & 0x03;
9009#line 313 "rx-decode.opc"
9010 int rdst AU = (op[1] >> 4) & 0x0f;
9011#line 313 "rx-decode.opc"
9012 int im AU = (op[1] >> 2) & 0x03;
9013#line 313 "rx-decode.opc"
9014 int sz AU = op[1] & 0x03;
9015 if (trace)
9016 {
9017 printf ("\033[33m%s\033[0m %02x %02x\n",
9018 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
9019 op[0], op[1]);
9020 printf (" sd = 0x%x,", sd);
9021 printf (" rdst = 0x%x,", rdst);
9022 printf (" im = 0x%x,", im);
9023 printf (" sz = 0x%x\n", sz);
9024 }
9025 SYNTAX("mov%s #%1, %0");
9026#line 313 "rx-decode.opc"
9027 ID(mov); DD(sd, rdst, sz);
9028 if ((im == 1 && sz == 0)
9029 || (im == 2 && sz == 1)
9030 || (im == 0 && sz == 2))
9031 {
9032 BWL (sz);
9033 SC(IMM(im));
9034 }
9035 else
9036 {
9037 sBWL (sz);
9038 SC(IMMex(im));
9039 }
9040 F_____;
9041
9042 }
c7927a3c
NC		 9043 break;
9044 }
9045 break;
4ce8c66d 9046 case 0xf9:
c7927a3c 9047 GETBYTE ();
4ce8c66d 9048 switch (op[1] & 0xff)
c7927a3c
NC		 9049 {
9050 case 0x00:
4ce8c66d
YS		 9051 case 0x01:
9052 case 0x02:
9053 case 0x04:
9054 case 0x05:
9055 case 0x06:
9056 case 0x08:
9057 case 0x09:
9058 case 0x0a:
9059 case 0x0c:
9060 case 0x0d:
9061 case 0x0e:
9062 case 0x10:
9063 case 0x11:
9064 case 0x12:
9065 case 0x14:
9066 case 0x15:
9067 case 0x16:
9068 case 0x18:
9069 case 0x19:
9070 case 0x1a:
9071 case 0x1c:
9072 case 0x1d:
9073 case 0x1e:
9074 case 0x20:
9075 case 0x21:
9076 case 0x22:
9077 case 0x24:
9078 case 0x25:
9079 case 0x26:
9080 case 0x28:
9081 case 0x29:
9082 case 0x2a:
9083 case 0x2c:
9084 case 0x2d:
9085 case 0x2e:
9086 case 0x30:
9087 case 0x31:
9088 case 0x32:
9089 case 0x34:
9090 case 0x35:
9091 case 0x36:
9092 case 0x38:
9093 case 0x39:
9094 case 0x3a:
9095 case 0x3c:
9096 case 0x3d:
9097 case 0x3e:
9098 case 0x40:
9099 case 0x41:
9100 case 0x42:
9101 case 0x44:
9102 case 0x45:
9103 case 0x46:
9104 case 0x48:
9105 case 0x49:
9106 case 0x4a:
9107 case 0x4c:
9108 case 0x4d:
9109 case 0x4e:
9110 case 0x50:
9111 case 0x51:
9112 case 0x52:
9113 case 0x54:
9114 case 0x55:
9115 case 0x56:
9116 case 0x58:
9117 case 0x59:
9118 case 0x5a:
9119 case 0x5c:
9120 case 0x5d:
9121 case 0x5e:
9122 case 0x60:
9123 case 0x61:
9124 case 0x62:
9125 case 0x64:
9126 case 0x65:
9127 case 0x66:
9128 case 0x68:
9129 case 0x69:
9130 case 0x6a:
9131 case 0x6c:
9132 case 0x6d:
9133 case 0x6e:
9134 case 0x70:
9135 case 0x71:
9136 case 0x72:
9137 case 0x74:
9138 case 0x75:
9139 case 0x76:
9140 case 0x78:
9141 case 0x79:
9142 case 0x7a:
9143 case 0x7c:
9144 case 0x7d:
9145 case 0x7e:
9146 case 0x80:
9147 case 0x81:
9148 case 0x82:
9149 case 0x84:
9150 case 0x85:
9151 case 0x86:
9152 case 0x88:
9153 case 0x89:
9154 case 0x8a:
9155 case 0x8c:
9156 case 0x8d:
9157 case 0x8e:
9158 case 0x90:
9159 case 0x91:
9160 case 0x92:
9161 case 0x94:
9162 case 0x95:
9163 case 0x96:
9164 case 0x98:
9165 case 0x99:
9166 case 0x9a:
9167 case 0x9c:
9168 case 0x9d:
9169 case 0x9e:
9170 case 0xa0:
9171 case 0xa1:
9172 case 0xa2:
9173 case 0xa4:
9174 case 0xa5:
9175 case 0xa6:
9176 case 0xa8:
9177 case 0xa9:
9178 case 0xaa:
9179 case 0xac:
9180 case 0xad:
9181 case 0xae:
9182 case 0xb0:
9183 case 0xb1:
9184 case 0xb2:
9185 case 0xb4:
9186 case 0xb5:
9187 case 0xb6:
9188 case 0xb8:
9189 case 0xb9:
9190 case 0xba:
9191 case 0xbc:
9192 case 0xbd:
9193 case 0xbe:
9194 case 0xc0:
9195 case 0xc1:
9196 case 0xc2:
9197 case 0xc4:
9198 case 0xc5:
9199 case 0xc6:
9200 case 0xc8:
9201 case 0xc9:
9202 case 0xca:
9203 case 0xcc:
9204 case 0xcd:
9205 case 0xce:
9206 case 0xd0:
9207 case 0xd1:
9208 case 0xd2:
9209 case 0xd4:
9210 case 0xd5:
9211 case 0xd6:
9212 case 0xd8:
9213 case 0xd9:
9214 case 0xda:
9215 case 0xdc:
9216 case 0xdd:
9217 case 0xde:
9218 case 0xe0:
9219 case 0xe1:
9220 case 0xe2:
9221 case 0xe4:
9222 case 0xe5:
9223 case 0xe6:
9224 case 0xe8:
9225 case 0xe9:
9226 case 0xea:
9227 case 0xec:
9228 case 0xed:
9229 case 0xee:
9230 case 0xf0:
9231 case 0xf1:
9232 case 0xf2:
9233 case 0xf4:
9234 case 0xf5:
9235 case 0xf6:
9236 case 0xf8:
9237 case 0xf9:
9238 case 0xfa:
9239 case 0xfc:
9240 case 0xfd:
9241 case 0xfe:
9242 goto op_semantics_60;
9243 break;
9244 case 0x03:
9245 GETBYTE ();
9246 switch (op[2] & 0x0f)
9247 {
9248 case 0x00:
9249 {
9250 /** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */
9251#line 1211 "rx-decode.opc"
9252 int rdst AU = (op[2] >> 4) & 0x0f;
9253 if (trace)
9254 {
9255 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9256 "/** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */",
9257 op[0], op[1], op[2]);
9258 printf (" rdst = 0x%x\n", rdst);
9259 }
9260 SYNTAX("dmov.l #%1, %0");
9261#line 1211 "rx-decode.opc"
9262 ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____;
9263
9264 }
9265 break;
9266 case 0x02:
9267 case 0x03:
9268 {
9269 /** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */
9270#line 1208 "rx-decode.opc"
9271 int rdst AU = (op[2] >> 4) & 0x0f;
9272#line 1208 "rx-decode.opc"
9273 int s AU = op[2] & 0x01;
9274 if (trace)
9275 {
9276 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9277 "/** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */",
9278 op[0], op[1], op[2]);
9279 printf (" rdst = 0x%x,", rdst);
9280 printf (" s = 0x%x\n", s);
9281 }
9282 SYNTAX("dmov%s #%1, %0");
9283#line 1208 "rx-decode.opc"
9284 ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____;
9285
9286 }
9287 break;
9288 default: UNSUPPORTED(); break;
9289 }
c7927a3c 9290 break;
4ce8c66d 9291 default: UNSUPPORTED(); break;
c7927a3c
NC		 9292 }
9293 break;
4ce8c66d 9294 case 0xfa:
c7927a3c
NC		 9295 GETBYTE ();
9296 switch (op[1] & 0x00)
9297 {
9298 case 0x00:
4ce8c66d 9299 goto op_semantics_60;
c7927a3c
NC		 9300 break;
9301 }
9302 break;
4ce8c66d 9303 case 0xfb:
c7927a3c
NC		 9304 GETBYTE ();
9305 switch (op[1] & 0x00)
9306 {
9307 case 0x00:
4ce8c66d 9308 goto op_semantics_60;
c7927a3c
NC		 9309 break;
9310 }
9311 break;
4ce8c66d 9312 case 0xfc:
c7927a3c 9313 GETBYTE ();
4ce8c66d 9314 switch (op[1] & 0xff)
c7927a3c 9315 {
4ce8c66d
YS		 9316 case 0x03:
9317 GETBYTE ();
9318 switch (op[2] & 0x00)
9319 {
9320 case 0x00:
9321 {
9322 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
9323#line 576 "rx-decode.opc"
9324 int rsrc AU = (op[2] >> 4) & 0x0f;
9325#line 576 "rx-decode.opc"
9326 int rdst AU = op[2] & 0x0f;
9327 if (trace)
9328 {
9329 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9330 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
9331 op[0], op[1], op[2]);
9332 printf (" rsrc = 0x%x,", rsrc);
9333 printf (" rdst = 0x%x\n", rdst);
9334 }
9335 SYNTAX("sbb %1, %0");
9336#line 576 "rx-decode.opc"
9337 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
9338
9339 /* FIXME: only supports .L */
9340 }
9341 break;
9342 }
c7927a3c 9343 break;
4ce8c66d
YS		 9344 case 0x07:
9345 GETBYTE ();
9346 switch (op[2] & 0x00)
9347 {
9348 case 0x00:
9349 {
9350 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
9351#line 507 "rx-decode.opc"
9352 int rsrc AU = (op[2] >> 4) & 0x0f;
9353#line 507 "rx-decode.opc"
9354 int rdst AU = op[2] & 0x0f;
9355 if (trace)
9356 {
9357 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9358 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
9359 op[0], op[1], op[2]);
9360 printf (" rsrc = 0x%x,", rsrc);
9361 printf (" rdst = 0x%x\n", rdst);
9362 }
9363 SYNTAX("neg %2, %0");
9364#line 507 "rx-decode.opc"
9365 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
9366
9367 /*----------------------------------------------------------------------*/
9368 /* ADC */
9369
9370 }
9371 break;
9372 }
c7927a3c 9373 break;
4ce8c66d
YS		 9374 case 0x0b:
9375 GETBYTE ();
9376 switch (op[2] & 0x00)
9377 {
9378 case 0x00:
9379 {
9380 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
9381#line 516 "rx-decode.opc"
9382 int rsrc AU = (op[2] >> 4) & 0x0f;
9383#line 516 "rx-decode.opc"
9384 int rdst AU = op[2] & 0x0f;
9385 if (trace)
9386 {
9387 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9388 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
9389 op[0], op[1], op[2]);
9390 printf (" rsrc = 0x%x,", rsrc);
9391 printf (" rdst = 0x%x\n", rdst);
9392 }
9393 SYNTAX("adc %1, %0");
9394#line 516 "rx-decode.opc"
9395 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
9396
9397 }
9398 break;
9399 }
c7927a3c 9400 break;
4ce8c66d
YS		 9401 case 0x0f:
9402 GETBYTE ();
9403 switch (op[2] & 0x00)
9404 {
9405 case 0x00:
9406 {
9407 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
9408#line 589 "rx-decode.opc"
9409 int rsrc AU = (op[2] >> 4) & 0x0f;
9410#line 589 "rx-decode.opc"
9411 int rdst AU = op[2] & 0x0f;
9412 if (trace)
9413 {
9414 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9415 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
9416 op[0], op[1], op[2]);
9417 printf (" rsrc = 0x%x,", rsrc);
9418 printf (" rdst = 0x%x\n", rdst);
9419 }
9420 SYNTAX("abs %1, %0");
9421#line 589 "rx-decode.opc"
9422 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
9423
9424 /*----------------------------------------------------------------------*/
9425 /* MAX */
9426
9427 }
9428 break;
9429 }
c7927a3c 9430 break;
4ce8c66d
YS		 9431 case 0x10:
9432 GETBYTE ();
9433 switch (op[2] & 0x00)
9434 {
9435 case 0x00:
9436 op_semantics_61:
9437 {
9438 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
9439#line 608 "rx-decode.opc"
9440 int ss AU = op[1] & 0x03;
9441#line 608 "rx-decode.opc"
9442 int rsrc AU = (op[2] >> 4) & 0x0f;
9443#line 608 "rx-decode.opc"
9444 int rdst AU = op[2] & 0x0f;
9445 if (trace)
9446 {
9447 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9448 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
9449 op[0], op[1], op[2]);
9450 printf (" ss = 0x%x,", ss);
9451 printf (" rsrc = 0x%x,", rsrc);
9452 printf (" rdst = 0x%x\n", rdst);
9453 }
9454 SYNTAX("max %1%S1, %0");
9455#line 608 "rx-decode.opc"
9456 if (ss == 3 && rsrc == 0 && rdst == 0)
9457 {
9458 ID(nop3);
9459 SYNTAX("nop\t; max\tr0, r0");
9460 }
9461 else
9462 {
9463 ID(max); SP(ss, rsrc); DR(rdst);
9464 }
9465
9466 }
9467 break;
9468 }
c7927a3c 9469 break;
4ce8c66d
YS		 9470 case 0x11:
9471 GETBYTE ();
9472 switch (op[2] & 0x00)
9473 {
9474 case 0x00:
9475 goto op_semantics_61;
9476 break;
9477 }
c7927a3c 9478 break;
4ce8c66d
YS		 9479 case 0x12:
9480 GETBYTE ();
9481 switch (op[2] & 0x00)
9482 {
9483 case 0x00:
9484 goto op_semantics_61;
9485 break;
9486 }
c7927a3c 9487 break;
4ce8c66d
YS		 9488 case 0x13:
9489 GETBYTE ();
9490 switch (op[2] & 0x00)
9491 {
9492 case 0x00:
9493 goto op_semantics_61;
9494 break;
9495 }
c7927a3c 9496 break;
4ce8c66d
YS		 9497 case 0x14:
9498 GETBYTE ();
9499 switch (op[2] & 0x00)
9500 {
9501 case 0x00:
9502 op_semantics_62:
9503 {
9504 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
9505#line 628 "rx-decode.opc"
9506 int ss AU = op[1] & 0x03;
9507#line 628 "rx-decode.opc"
9508 int rsrc AU = (op[2] >> 4) & 0x0f;
9509#line 628 "rx-decode.opc"
9510 int rdst AU = op[2] & 0x0f;
9511 if (trace)
9512 {
9513 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9514 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
9515 op[0], op[1], op[2]);
9516 printf (" ss = 0x%x,", ss);
9517 printf (" rsrc = 0x%x,", rsrc);
9518 printf (" rdst = 0x%x\n", rdst);
9519 }
9520 SYNTAX("min %1%S1, %0");
9521#line 628 "rx-decode.opc"
9522 ID(min); SP(ss, rsrc); DR(rdst);
9523
9524 }
9525 break;
9526 }
c7927a3c 9527 break;
4ce8c66d
YS		 9528 case 0x15:
9529 GETBYTE ();
9530 switch (op[2] & 0x00)
9531 {
9532 case 0x00:
9533 goto op_semantics_62;
9534 break;
9535 }
c7927a3c 9536 break;
4ce8c66d
YS		 9537 case 0x16:
9538 GETBYTE ();
9539 switch (op[2] & 0x00)
9540 {
9541 case 0x00:
9542 goto op_semantics_62;
9543 break;
9544 }
c7927a3c 9545 break;
4ce8c66d
YS		 9546 case 0x17:
9547 GETBYTE ();
9548 switch (op[2] & 0x00)
9549 {
9550 case 0x00:
9551 goto op_semantics_62;
9552 break;
9553 }
c7927a3c 9554 break;
4ce8c66d
YS		 9555 case 0x18:
9556 GETBYTE ();
9557 switch (op[2] & 0x00)
9558 {
9559 case 0x00:
9560 op_semantics_63:
9561 {
9562 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
9563#line 686 "rx-decode.opc"
9564 int ss AU = op[1] & 0x03;
9565#line 686 "rx-decode.opc"
9566 int rsrc AU = (op[2] >> 4) & 0x0f;
9567#line 686 "rx-decode.opc"
9568 int rdst AU = op[2] & 0x0f;
9569 if (trace)
9570 {
9571 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9572 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
9573 op[0], op[1], op[2]);
9574 printf (" ss = 0x%x,", ss);
9575 printf (" rsrc = 0x%x,", rsrc);
9576 printf (" rdst = 0x%x\n", rdst);
9577 }
9578 SYNTAX("emul %1%S1, %0");
9579#line 686 "rx-decode.opc"
9580 ID(emul); SP(ss, rsrc); DR(rdst);
9581
9582 }
9583 break;
9584 }
c7927a3c 9585 break;
4ce8c66d
YS		 9586 case 0x19:
9587 GETBYTE ();
9588 switch (op[2] & 0x00)
9589 {
9590 case 0x00:
9591 goto op_semantics_63;
9592 break;
9593 }
c7927a3c 9594 break;
4ce8c66d
YS		 9595 case 0x1a:
9596 GETBYTE ();
9597 switch (op[2] & 0x00)
9598 {
9599 case 0x00:
9600 goto op_semantics_63;
9601 break;
9602 }
c7927a3c 9603 break;
4ce8c66d
YS		 9604 case 0x1b:
9605 GETBYTE ();
9606 switch (op[2] & 0x00)
9607 {
9608 case 0x00:
9609 goto op_semantics_63;
9610 break;
9611 }
c7927a3c 9612 break;
4ce8c66d
YS		 9613 case 0x1c:
9614 GETBYTE ();
9615 switch (op[2] & 0x00)
9616 {
9617 case 0x00:
9618 op_semantics_64:
9619 {
9620 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
9621#line 698 "rx-decode.opc"
9622 int ss AU = op[1] & 0x03;
9623#line 698 "rx-decode.opc"
9624 int rsrc AU = (op[2] >> 4) & 0x0f;
9625#line 698 "rx-decode.opc"
9626 int rdst AU = op[2] & 0x0f;
9627 if (trace)
9628 {
9629 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9630 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
9631 op[0], op[1], op[2]);
9632 printf (" ss = 0x%x,", ss);
9633 printf (" rsrc = 0x%x,", rsrc);
9634 printf (" rdst = 0x%x\n", rdst);
9635 }
9636 SYNTAX("emulu %1%S1, %0");
9637#line 698 "rx-decode.opc"
9638 ID(emulu); SP(ss, rsrc); DR(rdst);
9639
9640 }
9641 break;
9642 }
c7927a3c 9643 break;
4ce8c66d
YS		 9644 case 0x1d:
9645 GETBYTE ();
9646 switch (op[2] & 0x00)
9647 {
9648 case 0x00:
9649 goto op_semantics_64;
9650 break;
9651 }
c7927a3c 9652 break;
4ce8c66d
YS		 9653 case 0x1e:
9654 GETBYTE ();
9655 switch (op[2] & 0x00)
9656 {
9657 case 0x00:
9658 goto op_semantics_64;
9659 break;
9660 }
c7927a3c 9661 break;
4ce8c66d
YS		 9662 case 0x1f:
9663 GETBYTE ();
9664 switch (op[2] & 0x00)
9665 {
9666 case 0x00:
9667 goto op_semantics_64;
9668 break;
9669 }
c7927a3c 9670 break;
4ce8c66d
YS		 9671 case 0x20:
9672 GETBYTE ();
9673 switch (op[2] & 0x00)
9674 {
9675 case 0x00:
9676 op_semantics_65:
9677 {
9678 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
9679#line 710 "rx-decode.opc"
9680 int ss AU = op[1] & 0x03;
9681#line 710 "rx-decode.opc"
9682 int rsrc AU = (op[2] >> 4) & 0x0f;
9683#line 710 "rx-decode.opc"
9684 int rdst AU = op[2] & 0x0f;
9685 if (trace)
9686 {
9687 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9688 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
9689 op[0], op[1], op[2]);
9690 printf (" ss = 0x%x,", ss);
9691 printf (" rsrc = 0x%x,", rsrc);
9692 printf (" rdst = 0x%x\n", rdst);
9693 }
9694 SYNTAX("div %1%S1, %0");
9695#line 710 "rx-decode.opc"
9696 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
9697
9698 }
9699 break;
9700 }
c7927a3c 9701 break;
4ce8c66d
YS		 9702 case 0x21:
9703 GETBYTE ();
9704 switch (op[2] & 0x00)
9705 {
9706 case 0x00:
9707 goto op_semantics_65;
9708 break;
9709 }
c7927a3c 9710 break;
4ce8c66d
YS		 9711 case 0x22:
9712 GETBYTE ();
9713 switch (op[2] & 0x00)
9714 {
9715 case 0x00:
9716 goto op_semantics_65;
9717 break;
9718 }
c7927a3c 9719 break;
4ce8c66d
YS		 9720 case 0x23:
9721 GETBYTE ();
9722 switch (op[2] & 0x00)
9723 {
9724 case 0x00:
9725 goto op_semantics_65;
9726 break;
9727 }
c7927a3c 9728 break;
4ce8c66d
YS		 9729 case 0x24:
9730 GETBYTE ();
9731 switch (op[2] & 0x00)
9732 {
9733 case 0x00:
9734 op_semantics_66:
9735 {
9736 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
9737#line 722 "rx-decode.opc"
9738 int ss AU = op[1] & 0x03;
9739#line 722 "rx-decode.opc"
9740 int rsrc AU = (op[2] >> 4) & 0x0f;
9741#line 722 "rx-decode.opc"
9742 int rdst AU = op[2] & 0x0f;
9743 if (trace)
9744 {
9745 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9746 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
9747 op[0], op[1], op[2]);
9748 printf (" ss = 0x%x,", ss);
9749 printf (" rsrc = 0x%x,", rsrc);
9750 printf (" rdst = 0x%x\n", rdst);
9751 }
9752 SYNTAX("divu %1%S1, %0");
9753#line 722 "rx-decode.opc"
9754 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
9755
9756 }
9757 break;
9758 }
c7927a3c 9759 break;
4ce8c66d
YS		 9760 case 0x25:
9761 GETBYTE ();
9762 switch (op[2] & 0x00)
9763 {
9764 case 0x00:
9765 goto op_semantics_66;
9766 break;
9767 }
c7927a3c 9768 break;
4ce8c66d
YS		 9769 case 0x26:
9770 GETBYTE ();
9771 switch (op[2] & 0x00)
9772 {
9773 case 0x00:
9774 goto op_semantics_66;
9775 break;
9776 }
c7927a3c 9777 break;
4ce8c66d
YS		 9778 case 0x27:
9779 GETBYTE ();
9780 switch (op[2] & 0x00)
c7927a3c 9781 {
4ce8c66d
YS		 9782 case 0x00:
9783 goto op_semantics_66;
9784 break;
c7927a3c
NC		 9785 }
9786 break;
4ce8c66d
YS		 9787 case 0x30:
9788 GETBYTE ();
9789 switch (op[2] & 0x00)
c7927a3c 9790 {
4ce8c66d
YS		 9791 case 0x00:
9792 op_semantics_67:
9793 {
9794 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
9795#line 495 "rx-decode.opc"
9796 int ss AU = op[1] & 0x03;
9797#line 495 "rx-decode.opc"
9798 int rsrc AU = (op[2] >> 4) & 0x0f;
9799#line 495 "rx-decode.opc"
9800 int rdst AU = op[2] & 0x0f;
9801 if (trace)
9802 {
9803 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9804 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
9805 op[0], op[1], op[2]);
9806 printf (" ss = 0x%x,", ss);
9807 printf (" rsrc = 0x%x,", rsrc);
9808 printf (" rdst = 0x%x\n", rdst);
9809 }
9810 SYNTAX("tst %1%S1, %2");
9811#line 495 "rx-decode.opc"
9812 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
43e65147 9813
4ce8c66d
YS		 9814 }
9815 break;
c7927a3c
NC		 9816 }
9817 break;
4ce8c66d
YS		 9818 case 0x31:
9819 GETBYTE ();
9820 switch (op[2] & 0x00)
9821 {
9822 case 0x00:
9823 goto op_semantics_67;
9824 break;
9825 }
c7927a3c 9826 break;
4ce8c66d
YS		 9827 case 0x32:
9828 GETBYTE ();
9829 switch (op[2] & 0x00)
9830 {
9831 case 0x00:
9832 goto op_semantics_67;
9833 break;
9834 }
c7927a3c 9835 break;
4ce8c66d
YS		 9836 case 0x33:
9837 GETBYTE ();
9838 switch (op[2] & 0x00)
9839 {
9840 case 0x00:
9841 goto op_semantics_67;
9842 break;
9843 }
c7927a3c 9844 break;
4ce8c66d
YS		 9845 case 0x34:
9846 GETBYTE ();
9847 switch (op[2] & 0x00)
9848 {
9849 case 0x00:
9850 op_semantics_68:
9851 {
9852 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
9853#line 474 "rx-decode.opc"
9854 int ss AU = op[1] & 0x03;
9855#line 474 "rx-decode.opc"
9856 int rsrc AU = (op[2] >> 4) & 0x0f;
9857#line 474 "rx-decode.opc"
9858 int rdst AU = op[2] & 0x0f;
9859 if (trace)
9860 {
9861 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9862 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
9863 op[0], op[1], op[2]);
9864 printf (" ss = 0x%x,", ss);
9865 printf (" rsrc = 0x%x,", rsrc);
9866 printf (" rdst = 0x%x\n", rdst);
9867 }
9868 SYNTAX("xor %1%S1, %0");
9869#line 474 "rx-decode.opc"
9870 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
9871
9872 }
9873 break;
9874 }
c7927a3c 9875 break;
4ce8c66d
YS		 9876 case 0x35:
9877 GETBYTE ();
9878 switch (op[2] & 0x00)
9879 {
9880 case 0x00:
9881 goto op_semantics_68;
9882 break;
9883 }
c7927a3c 9884 break;
4ce8c66d
YS		 9885 case 0x36:
9886 GETBYTE ();
9887 switch (op[2] & 0x00)
9888 {
9889 case 0x00:
9890 goto op_semantics_68;
9891 break;
9892 }
c7927a3c 9893 break;
4ce8c66d
YS		 9894 case 0x37:
9895 GETBYTE ();
9896 switch (op[2] & 0x00)
c7927a3c 9897 {
4ce8c66d
YS		 9898 case 0x00:
9899 goto op_semantics_68;
9900 break;
c7927a3c
NC		 9901 }
9902 break;
4ce8c66d
YS		 9903 case 0x3b:
9904 GETBYTE ();
9905 switch (op[2] & 0x00)
c7927a3c 9906 {
4ce8c66d
YS		 9907 case 0x00:
9908 {
9909 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
9910#line 486 "rx-decode.opc"
9911 int rsrc AU = (op[2] >> 4) & 0x0f;
9912#line 486 "rx-decode.opc"
9913 int rdst AU = op[2] & 0x0f;
9914 if (trace)
9915 {
9916 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9917 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
9918 op[0], op[1], op[2]);
9919 printf (" rsrc = 0x%x,", rsrc);
9920 printf (" rdst = 0x%x\n", rdst);
9921 }
9922 SYNTAX("not %1, %0");
9923#line 486 "rx-decode.opc"
9924 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
43e65147 9925
4ce8c66d
YS		 9926 /*----------------------------------------------------------------------*/
9927 /* TST */
43e65147 9928
4ce8c66d
YS		 9929 }
9930 break;
c7927a3c
NC		 9931 }
9932 break;
4ce8c66d
YS		 9933 case 0x40:
9934 GETBYTE ();
9935 switch (op[2] & 0x00)
9936 {
9937 case 0x00:
9938 op_semantics_69:
9939 {
9940 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
9941#line 408 "rx-decode.opc"
9942 int ss AU = op[1] & 0x03;
9943#line 408 "rx-decode.opc"
9944 int rsrc AU = (op[2] >> 4) & 0x0f;
9945#line 408 "rx-decode.opc"
9946 int rdst AU = op[2] & 0x0f;
9947 if (trace)
9948 {
9949 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9950 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
9951 op[0], op[1], op[2]);
9952 printf (" ss = 0x%x,", ss);
9953 printf (" rsrc = 0x%x,", rsrc);
9954 printf (" rdst = 0x%x\n", rdst);
9955 }
9956 SYNTAX("xchg %1%S1, %0");
9957#line 408 "rx-decode.opc"
9958 ID(xchg); DR(rdst); SP(ss, rsrc);
9959
9960 }
9961 break;
9962 }
c7927a3c 9963 break;
4ce8c66d
YS		 9964 case 0x41:
9965 GETBYTE ();
9966 switch (op[2] & 0x00)
9967 {
9968 case 0x00:
9969 goto op_semantics_69;
9970 break;
9971 }
c7927a3c 9972 break;
4ce8c66d
YS		 9973 case 0x42:
9974 GETBYTE ();
9975 switch (op[2] & 0x00)
9976 {
9977 case 0x00:
9978 goto op_semantics_69;
9979 break;
9980 }
c7927a3c 9981 break;
4ce8c66d
YS		 9982 case 0x43:
9983 GETBYTE ();
9984 switch (op[2] & 0x00)
9985 {
9986 case 0x00:
9987 goto op_semantics_69;
9988 break;
9989 }
c7927a3c 9990 break;
4ce8c66d
YS		 9991 case 0x44:
9992 GETBYTE ();
9993 switch (op[2] & 0x00)
c7927a3c 9994 {
4ce8c66d
YS		 9995 case 0x00:
9996 op_semantics_70:
9997 {
9998 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
9999#line 951 "rx-decode.opc"
10000 int sd AU = op[1] & 0x03;
10001#line 951 "rx-decode.opc"
10002 int rsrc AU = (op[2] >> 4) & 0x0f;
10003#line 951 "rx-decode.opc"
10004 int rdst AU = op[2] & 0x0f;
10005 if (trace)
10006 {
10007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10008 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
10009 op[0], op[1], op[2]);
10010 printf (" sd = 0x%x,", sd);
10011 printf (" rsrc = 0x%x,", rsrc);
10012 printf (" rdst = 0x%x\n", rdst);
10013 }
10014 SYNTAX("itof %1%S1, %0");
10015#line 951 "rx-decode.opc"
10016 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
43e65147 10017
4ce8c66d
YS		 10018 }
10019 break;
c7927a3c
NC		 10020 }
10021 break;
4ce8c66d
YS		 10022 case 0x45:
10023 GETBYTE ();
10024 switch (op[2] & 0x00)
10025 {
10026 case 0x00:
10027 goto op_semantics_70;
10028 break;
10029 }
c7927a3c 10030 break;
4ce8c66d
YS		 10031 case 0x46:
10032 GETBYTE ();
10033 switch (op[2] & 0x00)
10034 {
10035 case 0x00:
10036 goto op_semantics_70;
10037 break;
10038 }
c7927a3c 10039 break;
4ce8c66d
YS		 10040 case 0x47:
10041 GETBYTE ();
10042 switch (op[2] & 0x00)
10043 {
10044 case 0x00:
10045 goto op_semantics_70;
10046 break;
10047 }
c7927a3c 10048 break;
4ce8c66d 10049 case 0x4b:
c7927a3c
NC		 10050 GETBYTE ();
10051 switch (op[2] & 0x00)
10052 {
10053 case 0x00:
10054 {
4ce8c66d
YS		 10055 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
10056#line 1077 "rx-decode.opc"
c7927a3c 10057 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10058#line 1077 "rx-decode.opc"
c7927a3c
NC		 10059 int rdst AU = op[2] & 0x0f;
10060 if (trace)
10061 {
10062 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10063 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
c7927a3c
NC		 10064 op[0], op[1], op[2]);
10065 printf (" rsrc = 0x%x,", rsrc);
10066 printf (" rdst = 0x%x\n", rdst);
10067 }
4ce8c66d
YS		 10068 SYNTAX("stz %1, %0");
10069#line 1077 "rx-decode.opc"
10070 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
43e65147 10071
c7927a3c
NC		 10072 }
10073 break;
10074 }
10075 break;
4ce8c66d 10076 case 0x4f:
c7927a3c
NC		 10077 GETBYTE ();
10078 switch (op[2] & 0x00)
10079 {
10080 case 0x00:
10081 {
4ce8c66d
YS		 10082 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
10083#line 1080 "rx-decode.opc"
c7927a3c 10084 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10085#line 1080 "rx-decode.opc"
c7927a3c
NC		 10086 int rdst AU = op[2] & 0x0f;
10087 if (trace)
10088 {
10089 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10090 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
c7927a3c
NC		 10091 op[0], op[1], op[2]);
10092 printf (" rsrc = 0x%x,", rsrc);
10093 printf (" rdst = 0x%x\n", rdst);
10094 }
4ce8c66d
YS		 10095 SYNTAX("stnz %1, %0");
10096#line 1080 "rx-decode.opc"
10097 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
43e65147 10098
c7927a3c
NC		 10099 }
10100 break;
10101 }
10102 break;
4ce8c66d 10103 case 0x54:
c7927a3c
NC		 10104 GETBYTE ();
10105 switch (op[2] & 0x00)
10106 {
10107 case 0x00:
4ce8c66d 10108 op_semantics_71:
c7927a3c 10109 {
4ce8c66d
YS		 10110 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
10111#line 1137 "rx-decode.opc"
10112 int sd AU = op[1] & 0x03;
10113#line 1137 "rx-decode.opc"
c7927a3c 10114 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10115#line 1137 "rx-decode.opc"
c7927a3c
NC		 10116 int rdst AU = op[2] & 0x0f;
10117 if (trace)
10118 {
10119 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10120 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
c7927a3c 10121 op[0], op[1], op[2]);
4ce8c66d 10122 printf (" sd = 0x%x,", sd);
c7927a3c
NC		 10123 printf (" rsrc = 0x%x,", rsrc);
10124 printf (" rdst = 0x%x\n", rdst);
10125 }
4ce8c66d
YS		 10126 SYNTAX("utof %1%S1, %0");
10127#line 1137 "rx-decode.opc"
10128 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
43e65147 10129
c7927a3c
NC		 10130 }
10131 break;
10132 }
10133 break;
4ce8c66d
YS		 10134 case 0x55:
10135 GETBYTE ();
10136 switch (op[2] & 0x00)
10137 {
10138 case 0x00:
10139 goto op_semantics_71;
10140 break;
10141 }
10142 break;
10143 case 0x56:
10144 GETBYTE ();
10145 switch (op[2] & 0x00)
10146 {
10147 case 0x00:
10148 goto op_semantics_71;
10149 break;
10150 }
10151 break;
10152 case 0x57:
10153 GETBYTE ();
10154 switch (op[2] & 0x00)
10155 {
10156 case 0x00:
10157 goto op_semantics_71;
10158 break;
10159 }
10160 break;
10161 case 0x5a:
c7927a3c
NC		 10162 GETBYTE ();
10163 switch (op[2] & 0x00)
10164 {
10165 case 0x00:
10166 {
4ce8c66d
YS		 10167 /** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */
10168#line 1152 "rx-decode.opc"
c7927a3c 10169 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10170#line 1152 "rx-decode.opc"
c7927a3c
NC		 10171 int rdst AU = op[2] & 0x0f;
10172 if (trace)
10173 {
10174 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10175 "/** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */",
c7927a3c
NC		 10176 op[0], op[1], op[2]);
10177 printf (" rsrc = 0x%x,", rsrc);
10178 printf (" rdst = 0x%x\n", rdst);
10179 }
4ce8c66d
YS		 10180 SYNTAX("bfmovz %bf");
10181#line 1152 "rx-decode.opc"
10182 ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
43e65147 10183
c7927a3c
NC		 10184 }
10185 break;
10186 }
10187 break;
4ce8c66d 10188 case 0x5e:
c7927a3c
NC		 10189 GETBYTE ();
10190 switch (op[2] & 0x00)
10191 {
10192 case 0x00:
c7927a3c 10193 {
4ce8c66d
YS		 10194 /** 1111 1100 0101 1110 rsrc rdst bfmov %bf */
10195#line 1149 "rx-decode.opc"
c7927a3c 10196 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10197#line 1149 "rx-decode.opc"
c7927a3c
NC		 10198 int rdst AU = op[2] & 0x0f;
10199 if (trace)
10200 {
10201 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10202 "/** 1111 1100 0101 1110 rsrc rdst bfmov %bf */",
c7927a3c 10203 op[0], op[1], op[2]);
c7927a3c
NC		 10204 printf (" rsrc = 0x%x,", rsrc);
10205 printf (" rdst = 0x%x\n", rdst);
10206 }
4ce8c66d
YS		 10207 SYNTAX("bfmov %bf");
10208#line 1149 "rx-decode.opc"
10209 ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10210
10211 }
10212 break;
10213 }
10214 break;
10215 case 0x60:
10216 GETBYTE ();
10217 switch (op[2] & 0x00)
10218 {
10219 case 0x00:
10220 op_semantics_72:
10221 {
10222 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
10223#line 963 "rx-decode.opc"
10224 int sd AU = op[1] & 0x03;
10225#line 963 "rx-decode.opc"
10226 int rdst AU = (op[2] >> 4) & 0x0f;
10227#line 963 "rx-decode.opc"
10228 int rsrc AU = op[2] & 0x0f;
10229 if (trace)
f9c7014e 10230 {
4ce8c66d
YS		 10231 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10232 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
10233 op[0], op[1], op[2]);
10234 printf (" sd = 0x%x,", sd);
10235 printf (" rdst = 0x%x,", rdst);
10236 printf (" rsrc = 0x%x\n", rsrc);
f9c7014e 10237 }
4ce8c66d
YS		 10238 SYNTAX("bset %1, %0%S0");
10239#line 963 "rx-decode.opc"
10240 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10241 if (sd == 3) /* bset reg,reg */
10242 BWL(LSIZE);
43e65147 10243
c7927a3c
NC		 10244 }
10245 break;
10246 }
10247 break;
4ce8c66d 10248 case 0x61:
c7927a3c
NC		 10249 GETBYTE ();
10250 switch (op[2] & 0x00)
10251 {
10252 case 0x00:
4ce8c66d 10253 goto op_semantics_72;
c7927a3c
NC		 10254 break;
10255 }
10256 break;
4ce8c66d 10257 case 0x62:
c7927a3c
NC		 10258 GETBYTE ();
10259 switch (op[2] & 0x00)
10260 {
10261 case 0x00:
4ce8c66d 10262 goto op_semantics_72;
c7927a3c
NC		 10263 break;
10264 }
10265 break;
4ce8c66d 10266 case 0x63:
c7927a3c
NC		 10267 GETBYTE ();
10268 switch (op[2] & 0x00)
10269 {
10270 case 0x00:
4ce8c66d 10271 goto op_semantics_72;
c7927a3c
NC		 10272 break;
10273 }
10274 break;
4ce8c66d 10275 case 0x64:
c7927a3c
NC		 10276 GETBYTE ();
10277 switch (op[2] & 0x00)
10278 {
10279 case 0x00:
4ce8c66d 10280 op_semantics_73:
c7927a3c 10281 {
4ce8c66d
YS		 10282 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
10283#line 975 "rx-decode.opc"
10284 int sd AU = op[1] & 0x03;
10285#line 975 "rx-decode.opc"
10286 int rdst AU = (op[2] >> 4) & 0x0f;
10287#line 975 "rx-decode.opc"
10288 int rsrc AU = op[2] & 0x0f;
c7927a3c
NC		 10289 if (trace)
10290 {
10291 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10292 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
c7927a3c 10293 op[0], op[1], op[2]);
4ce8c66d
YS		 10294 printf (" sd = 0x%x,", sd);
10295 printf (" rdst = 0x%x,", rdst);
10296 printf (" rsrc = 0x%x\n", rsrc);
c7927a3c 10297 }
4ce8c66d
YS		 10298 SYNTAX("bclr %1, %0%S0");
10299#line 975 "rx-decode.opc"
10300 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10301 if (sd == 3) /* bset reg,reg */
10302 BWL(LSIZE);
43e65147 10303
c7927a3c
NC		 10304 }
10305 break;
10306 }
10307 break;
4ce8c66d 10308 case 0x65:
c7927a3c
NC		 10309 GETBYTE ();
10310 switch (op[2] & 0x00)
10311 {
10312 case 0x00:
4ce8c66d 10313 goto op_semantics_73;
c7927a3c
NC		 10314 break;
10315 }
10316 break;
4ce8c66d 10317 case 0x66:
c7927a3c
NC		 10318 GETBYTE ();
10319 switch (op[2] & 0x00)
10320 {
10321 case 0x00:
4ce8c66d 10322 goto op_semantics_73;
c7927a3c
NC		 10323 break;
10324 }
10325 break;
4ce8c66d 10326 case 0x67:
c7927a3c
NC		 10327 GETBYTE ();
10328 switch (op[2] & 0x00)
10329 {
10330 case 0x00:
4ce8c66d 10331 goto op_semantics_73;
c7927a3c
NC		 10332 break;
10333 }
10334 break;
4ce8c66d 10335 case 0x68:
c7927a3c
NC		 10336 GETBYTE ();
10337 switch (op[2] & 0x00)
10338 {
10339 case 0x00:
4ce8c66d 10340 op_semantics_74:
c7927a3c 10341 {
4ce8c66d
YS		 10342 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
10343#line 987 "rx-decode.opc"
10344 int sd AU = op[1] & 0x03;
10345#line 987 "rx-decode.opc"
10346 int rdst AU = (op[2] >> 4) & 0x0f;
10347#line 987 "rx-decode.opc"
10348 int rsrc AU = op[2] & 0x0f;
c7927a3c
NC		 10349 if (trace)
10350 {
10351 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10352 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
c7927a3c 10353 op[0], op[1], op[2]);
4ce8c66d
YS		 10354 printf (" sd = 0x%x,", sd);
10355 printf (" rdst = 0x%x,", rdst);
10356 printf (" rsrc = 0x%x\n", rsrc);
c7927a3c 10357 }
4ce8c66d
YS		 10358 SYNTAX("btst %2, %1%S1");
10359#line 987 "rx-decode.opc"
10360 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
10361 if (sd == 3) /* bset reg,reg */
10362 BWL(LSIZE);
43e65147 10363
c7927a3c
NC		 10364 }
10365 break;
10366 }
10367 break;
4ce8c66d 10368 case 0x69:
c7927a3c
NC		 10369 GETBYTE ();
10370 switch (op[2] & 0x00)
10371 {
10372 case 0x00:
4ce8c66d 10373 goto op_semantics_74;
c7927a3c
NC		 10374 break;
10375 }
10376 break;
4ce8c66d 10377 case 0x6a:
c7927a3c
NC		 10378 GETBYTE ();
10379 switch (op[2] & 0x00)
10380 {
10381 case 0x00:
4ce8c66d 10382 goto op_semantics_74;
c7927a3c
NC		 10383 break;
10384 }
10385 break;
4ce8c66d 10386 case 0x6b:
c7927a3c
NC		 10387 GETBYTE ();
10388 switch (op[2] & 0x00)
10389 {
10390 case 0x00:
4ce8c66d 10391 goto op_semantics_74;
c7927a3c
NC		 10392 break;
10393 }
10394 break;
4ce8c66d 10395 case 0x6c:
c7927a3c
NC		 10396 GETBYTE ();
10397 switch (op[2] & 0x00)
10398 {
10399 case 0x00:
4ce8c66d 10400 op_semantics_75:
c7927a3c 10401 {
4ce8c66d
YS		 10402 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
10403#line 999 "rx-decode.opc"
10404 int sd AU = op[1] & 0x03;
10405#line 999 "rx-decode.opc"
10406 int rdst AU = (op[2] >> 4) & 0x0f;
10407#line 999 "rx-decode.opc"
10408 int rsrc AU = op[2] & 0x0f;
c7927a3c
NC		 10409 if (trace)
10410 {
10411 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10412 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
c7927a3c 10413 op[0], op[1], op[2]);
4ce8c66d
YS		 10414 printf (" sd = 0x%x,", sd);
10415 printf (" rdst = 0x%x,", rdst);
10416 printf (" rsrc = 0x%x\n", rsrc);
c7927a3c 10417 }
4ce8c66d
YS		 10418 SYNTAX("bnot %1, %0%S0");
10419#line 999 "rx-decode.opc"
10420 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
10421 if (sd == 3) /* bset reg,reg */
10422 BWL(LSIZE);
43e65147 10423
c7927a3c
NC		 10424 }
10425 break;
10426 }
10427 break;
4ce8c66d 10428 case 0x6d:
c7927a3c
NC		 10429 GETBYTE ();
10430 switch (op[2] & 0x00)
10431 {
10432 case 0x00:
4ce8c66d 10433 goto op_semantics_75;
c7927a3c
NC		 10434 break;
10435 }
10436 break;
4ce8c66d 10437 case 0x6e:
c7927a3c
NC		 10438 GETBYTE ();
10439 switch (op[2] & 0x00)
10440 {
10441 case 0x00:
4ce8c66d 10442 goto op_semantics_75;
c7927a3c
NC		 10443 break;
10444 }
10445 break;
4ce8c66d 10446 case 0x6f:
c7927a3c
NC		 10447 GETBYTE ();
10448 switch (op[2] & 0x00)
10449 {
10450 case 0x00:
4ce8c66d 10451 goto op_semantics_75;
c7927a3c
NC		 10452 break;
10453 }
10454 break;
4ce8c66d 10455 case 0x78:
c7927a3c 10456 GETBYTE ();
4ce8c66d 10457 switch (op[2] & 0x0f)
c7927a3c 10458 {
4ce8c66d
YS		 10459 case 0x08:
10460 op_semantics_76:
c7927a3c 10461 {
4ce8c66d
YS		 10462 /** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */
10463#line 1185 "rx-decode.opc"
10464 int sz AU = op[1] & 0x03;
10465#line 1185 "rx-decode.opc"
10466 int rdst AU = (op[2] >> 4) & 0x0f;
c7927a3c
NC		 10467 if (trace)
10468 {
10469 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10470 "/** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */",
c7927a3c 10471 op[0], op[1], op[2]);
4ce8c66d 10472 printf (" sz = 0x%x,", sz);
c7927a3c
NC		 10473 printf (" rdst = 0x%x\n", rdst);
10474 }
4ce8c66d
YS		 10475 SYNTAX("dmov.d %1, %0");
10476#line 1185 "rx-decode.opc"
10477 int rsrc;
10478 rx_disp(0, sz, rdst, RX_Double, ld);
10479 rsrc = GETBYTE();
10480 if (rsrc & 0x0f)
10481 UNSUPPORTED();
10482 else {
10483 ID(dmov); SDR(rsrc >> 4); F_____;
10484 }
43e65147 10485
c7927a3c
NC		 10486 }
10487 break;
4ce8c66d 10488 default: UNSUPPORTED(); break;
c7927a3c
NC		 10489 }
10490 break;
4ce8c66d 10491 case 0x79:
c7927a3c 10492 GETBYTE ();
4ce8c66d 10493 switch (op[2] & 0x0f)
c7927a3c 10494 {
4ce8c66d
YS		 10495 case 0x08:
10496 goto op_semantics_76;
c7927a3c 10497 break;
4ce8c66d 10498 default: UNSUPPORTED(); break;
c7927a3c
NC		 10499 }
10500 break;
4ce8c66d 10501 case 0x7a:
c7927a3c 10502 GETBYTE ();
4ce8c66d 10503 switch (op[2] & 0x0f)
c7927a3c 10504 {
4ce8c66d
YS		 10505 case 0x08:
10506 goto op_semantics_76;
c7927a3c 10507 break;
4ce8c66d 10508 default: UNSUPPORTED(); break;
c7927a3c
NC		 10509 }
10510 break;
4ce8c66d 10511 case 0x80:
c7927a3c
NC		 10512 GETBYTE ();
10513 switch (op[2] & 0x00)
10514 {
10515 case 0x00:
4ce8c66d 10516 op_semantics_77:
c7927a3c 10517 {
4ce8c66d
YS		 10518 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
10519#line 930 "rx-decode.opc"
10520 int sd AU = op[1] & 0x03;
10521#line 930 "rx-decode.opc"
c7927a3c 10522 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10523#line 930 "rx-decode.opc"
c7927a3c
NC		 10524 int rdst AU = op[2] & 0x0f;
10525 if (trace)
10526 {
10527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10528 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
c7927a3c 10529 op[0], op[1], op[2]);
4ce8c66d 10530 printf (" sd = 0x%x,", sd);
c7927a3c
NC		 10531 printf (" rsrc = 0x%x,", rsrc);
10532 printf (" rdst = 0x%x\n", rdst);
10533 }
4ce8c66d
YS		 10534 SYNTAX("fsub %1%S1, %0");
10535#line 930 "rx-decode.opc"
10536 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 10537
c7927a3c
NC		 10538 }
10539 break;
10540 }
10541 break;
4ce8c66d 10542 case 0x81:
c7927a3c
NC		 10543 GETBYTE ();
10544 switch (op[2] & 0x00)
10545 {
10546 case 0x00:
4ce8c66d 10547 goto op_semantics_77;
c7927a3c
NC		 10548 break;
10549 }
10550 break;
4ce8c66d 10551 case 0x82:
c7927a3c
NC		 10552 GETBYTE ();
10553 switch (op[2] & 0x00)
10554 {
10555 case 0x00:
4ce8c66d 10556 goto op_semantics_77;
c7927a3c
NC		 10557 break;
10558 }
10559 break;
4ce8c66d 10560 case 0x83:
c7927a3c
NC		 10561 GETBYTE ();
10562 switch (op[2] & 0x00)
10563 {
10564 case 0x00:
4ce8c66d 10565 goto op_semantics_77;
c7927a3c
NC		 10566 break;
10567 }
10568 break;
4ce8c66d 10569 case 0x84:
c7927a3c
NC		 10570 GETBYTE ();
10571 switch (op[2] & 0x00)
10572 {
10573 case 0x00:
4ce8c66d 10574 op_semantics_78:
c7927a3c 10575 {
4ce8c66d
YS		 10576 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
10577#line 924 "rx-decode.opc"
10578 int sd AU = op[1] & 0x03;
10579#line 924 "rx-decode.opc"
c7927a3c 10580 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10581#line 924 "rx-decode.opc"
c7927a3c
NC		 10582 int rdst AU = op[2] & 0x0f;
10583 if (trace)
10584 {
10585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10586 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
c7927a3c 10587 op[0], op[1], op[2]);
4ce8c66d 10588 printf (" sd = 0x%x,", sd);
c7927a3c
NC		 10589 printf (" rsrc = 0x%x,", rsrc);
10590 printf (" rdst = 0x%x\n", rdst);
10591 }
4ce8c66d
YS		 10592 SYNTAX("fcmp %1%S1, %0");
10593#line 924 "rx-decode.opc"
10594 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
43e65147 10595
c7927a3c
NC		 10596 }
10597 break;
10598 }
10599 break;
4ce8c66d 10600 case 0x85:
c7927a3c
NC		 10601 GETBYTE ();
10602 switch (op[2] & 0x00)
10603 {
10604 case 0x00:
4ce8c66d 10605 goto op_semantics_78;
c7927a3c
NC		 10606 break;
10607 }
10608 break;
4ce8c66d 10609 case 0x86:
c7927a3c
NC		 10610 GETBYTE ();
10611 switch (op[2] & 0x00)
10612 {
10613 case 0x00:
4ce8c66d 10614 goto op_semantics_78;
c7927a3c
NC		 10615 break;
10616 }
10617 break;
4ce8c66d 10618 case 0x87:
c7927a3c
NC		 10619 GETBYTE ();
10620 switch (op[2] & 0x00)
10621 {
10622 case 0x00:
4ce8c66d 10623 goto op_semantics_78;
c7927a3c
NC		 10624 break;
10625 }
10626 break;
4ce8c66d 10627 case 0x88:
c7927a3c
NC		 10628 GETBYTE ();
10629 switch (op[2] & 0x00)
10630 {
10631 case 0x00:
4ce8c66d 10632 op_semantics_79:
c7927a3c 10633 {
4ce8c66d
YS		 10634 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
10635#line 918 "rx-decode.opc"
10636 int sd AU = op[1] & 0x03;
10637#line 918 "rx-decode.opc"
c7927a3c 10638 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10639#line 918 "rx-decode.opc"
c7927a3c
NC		 10640 int rdst AU = op[2] & 0x0f;
10641 if (trace)
10642 {
10643 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10644 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
c7927a3c 10645 op[0], op[1], op[2]);
4ce8c66d 10646 printf (" sd = 0x%x,", sd);
c7927a3c
NC		 10647 printf (" rsrc = 0x%x,", rsrc);
10648 printf (" rdst = 0x%x\n", rdst);
10649 }
4ce8c66d
YS		 10650 SYNTAX("fadd %1%S1, %0");
10651#line 918 "rx-decode.opc"
10652 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 10653
c7927a3c
NC		 10654 }
10655 break;
10656 }
10657 break;
4ce8c66d 10658 case 0x89:
c7927a3c
NC		 10659 GETBYTE ();
10660 switch (op[2] & 0x00)
10661 {
10662 case 0x00:
4ce8c66d 10663 goto op_semantics_79;
c7927a3c
NC		 10664 break;
10665 }
10666 break;
4ce8c66d 10667 case 0x8a:
c7927a3c
NC		 10668 GETBYTE ();
10669 switch (op[2] & 0x00)
10670 {
10671 case 0x00:
4ce8c66d 10672 goto op_semantics_79;
c7927a3c
NC		 10673 break;
10674 }
10675 break;
4ce8c66d 10676 case 0x8b:
c7927a3c
NC		 10677 GETBYTE ();
10678 switch (op[2] & 0x00)
10679 {
10680 case 0x00:
4ce8c66d 10681 goto op_semantics_79;
c7927a3c
NC		 10682 break;
10683 }
10684 break;
4ce8c66d 10685 case 0x8c:
c7927a3c
NC		 10686 GETBYTE ();
10687 switch (op[2] & 0x00)
10688 {
10689 case 0x00:
4ce8c66d 10690 op_semantics_80:
c7927a3c 10691 {
4ce8c66d
YS		 10692 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
10693#line 939 "rx-decode.opc"
10694 int sd AU = op[1] & 0x03;
10695#line 939 "rx-decode.opc"
c7927a3c 10696 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10697#line 939 "rx-decode.opc"
c7927a3c
NC		 10698 int rdst AU = op[2] & 0x0f;
10699 if (trace)
10700 {
10701 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10702 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
c7927a3c 10703 op[0], op[1], op[2]);
4ce8c66d 10704 printf (" sd = 0x%x,", sd);
c7927a3c
NC		 10705 printf (" rsrc = 0x%x,", rsrc);
10706 printf (" rdst = 0x%x\n", rdst);
10707 }
4ce8c66d
YS		 10708 SYNTAX("fmul %1%S1, %0");
10709#line 939 "rx-decode.opc"
10710 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 10711
c7927a3c
NC		 10712 }
10713 break;
10714 }
10715 break;
4ce8c66d 10716 case 0x8d:
c7927a3c
NC		 10717 GETBYTE ();
10718 switch (op[2] & 0x00)
10719 {
10720 case 0x00:
4ce8c66d 10721 goto op_semantics_80;
c7927a3c
NC		 10722 break;
10723 }
10724 break;
4ce8c66d 10725 case 0x8e:
c7927a3c
NC		 10726 GETBYTE ();
10727 switch (op[2] & 0x00)
10728 {
10729 case 0x00:
4ce8c66d 10730 goto op_semantics_80;
c7927a3c
NC		 10731 break;
10732 }
10733 break;
4ce8c66d 10734 case 0x8f:
c7927a3c
NC		 10735 GETBYTE ();
10736 switch (op[2] & 0x00)
10737 {
10738 case 0x00:
4ce8c66d 10739 goto op_semantics_80;
c7927a3c
NC		 10740 break;
10741 }
10742 break;
4ce8c66d 10743 case 0x90:
c7927a3c
NC		 10744 GETBYTE ();
10745 switch (op[2] & 0x00)
10746 {
10747 case 0x00:
4ce8c66d 10748 op_semantics_81:
c7927a3c 10749 {
4ce8c66d
YS		 10750 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
10751#line 945 "rx-decode.opc"
c7927a3c 10752 int sd AU = op[1] & 0x03;
4ce8c66d 10753#line 945 "rx-decode.opc"
c7927a3c 10754 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10755#line 945 "rx-decode.opc"
c7927a3c
NC		 10756 int rdst AU = op[2] & 0x0f;
10757 if (trace)
10758 {
10759 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10760 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
c7927a3c
NC		 10761 op[0], op[1], op[2]);
10762 printf (" sd = 0x%x,", sd);
10763 printf (" rsrc = 0x%x,", rsrc);
10764 printf (" rdst = 0x%x\n", rdst);
10765 }
4ce8c66d
YS		 10766 SYNTAX("fdiv %1%S1, %0");
10767#line 945 "rx-decode.opc"
10768 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 10769
c7927a3c
NC		 10770 }
10771 break;
10772 }
10773 break;
4ce8c66d 10774 case 0x91:
c7927a3c
NC		 10775 GETBYTE ();
10776 switch (op[2] & 0x00)
10777 {
10778 case 0x00:
4ce8c66d 10779 goto op_semantics_81;
c7927a3c
NC		 10780 break;
10781 }
10782 break;
4ce8c66d 10783 case 0x92:
c7927a3c
NC		 10784 GETBYTE ();
10785 switch (op[2] & 0x00)
10786 {
10787 case 0x00:
4ce8c66d 10788 goto op_semantics_81;
c7927a3c
NC		 10789 break;
10790 }
10791 break;
4ce8c66d 10792 case 0x93:
c7927a3c
NC		 10793 GETBYTE ();
10794 switch (op[2] & 0x00)
10795 {
10796 case 0x00:
4ce8c66d 10797 goto op_semantics_81;
c7927a3c
NC		 10798 break;
10799 }
10800 break;
4ce8c66d 10801 case 0x94:
c7927a3c
NC		 10802 GETBYTE ();
10803 switch (op[2] & 0x00)
10804 {
10805 case 0x00:
4ce8c66d 10806 op_semantics_82:
c7927a3c 10807 {
4ce8c66d
YS		 10808 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
10809#line 933 "rx-decode.opc"
10810 int sd AU = op[1] & 0x03;
10811#line 933 "rx-decode.opc"
a117b0a5 10812 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10813#line 933 "rx-decode.opc"
a117b0a5 10814 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 10815 if (trace)
10816 {
10817 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10818 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
c7927a3c 10819 op[0], op[1], op[2]);
4ce8c66d 10820 printf (" sd = 0x%x,", sd);
a117b0a5
YS		 10821 printf (" rsrc = 0x%x,", rsrc);
10822 printf (" rdst = 0x%x\n", rdst);
c7927a3c 10823 }
4ce8c66d
YS		 10824 SYNTAX("ftoi %1%S1, %0");
10825#line 933 "rx-decode.opc"
10826 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 10827
c7927a3c
NC		 10828 }
10829 break;
10830 }
10831 break;
4ce8c66d 10832 case 0x95:
c7927a3c
NC		 10833 GETBYTE ();
10834 switch (op[2] & 0x00)
10835 {
10836 case 0x00:
4ce8c66d 10837 goto op_semantics_82;
c7927a3c
NC		 10838 break;
10839 }
10840 break;
4ce8c66d
YS		 10841 case 0x96:
10842 GETBYTE ();
10843 switch (op[2] & 0x00)
10844 {
10845 case 0x00:
10846 goto op_semantics_82;
10847 break;
10848 }
10849 break;
10850 case 0x97:
10851 GETBYTE ();
10852 switch (op[2] & 0x00)
10853 {
10854 case 0x00:
10855 goto op_semantics_82;
10856 break;
10857 }
10858 break;
10859 case 0x98:
c7927a3c
NC		 10860 GETBYTE ();
10861 switch (op[2] & 0x00)
10862 {
10863 case 0x00:
4ce8c66d 10864 op_semantics_83:
c7927a3c 10865 {
4ce8c66d
YS		 10866 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
10867#line 948 "rx-decode.opc"
c7927a3c 10868 int sd AU = op[1] & 0x03;
4ce8c66d 10869#line 948 "rx-decode.opc"
a117b0a5 10870 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 10871#line 948 "rx-decode.opc"
a117b0a5 10872 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 10873 if (trace)
10874 {
10875 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10876 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
c7927a3c
NC		 10877 op[0], op[1], op[2]);
10878 printf (" sd = 0x%x,", sd);
a117b0a5
YS		 10879 printf (" rsrc = 0x%x,", rsrc);
10880 printf (" rdst = 0x%x\n", rdst);
c7927a3c 10881 }
4ce8c66d
YS		 10882 SYNTAX("round %1%S1, %0");
10883#line 948 "rx-decode.opc"
10884 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 10885
c7927a3c
NC		 10886 }
10887 break;
10888 }
10889 break;
4ce8c66d 10890 case 0x99:
c7927a3c
NC		 10891 GETBYTE ();
10892 switch (op[2] & 0x00)
10893 {
10894 case 0x00:
4ce8c66d 10895 goto op_semantics_83;
c7927a3c
NC		 10896 break;
10897 }
10898 break;
4ce8c66d 10899 case 0x9a:
c7927a3c
NC		 10900 GETBYTE ();
10901 switch (op[2] & 0x00)
10902 {
10903 case 0x00:
4ce8c66d 10904 goto op_semantics_83;
c7927a3c
NC		 10905 break;
10906 }
10907 break;
4ce8c66d 10908 case 0x9b:
c7927a3c
NC		 10909 GETBYTE ();
10910 switch (op[2] & 0x00)
10911 {
10912 case 0x00:
4ce8c66d 10913 goto op_semantics_83;
c7927a3c
NC		 10914 break;
10915 }
10916 break;
4ce8c66d 10917 case 0xa0:
c7927a3c
NC		 10918 GETBYTE ();
10919 switch (op[2] & 0x00)
10920 {
10921 case 0x00:
4ce8c66d 10922 op_semantics_84:
c7927a3c 10923 {
4ce8c66d
YS		 10924 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
10925#line 1131 "rx-decode.opc"
c7927a3c 10926 int sd AU = op[1] & 0x03;
4ce8c66d
YS		 10927#line 1131 "rx-decode.opc"
10928 int rsrc AU = (op[2] >> 4) & 0x0f;
10929#line 1131 "rx-decode.opc"
10930 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 10931 if (trace)
10932 {
10933 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10934 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
c7927a3c
NC		 10935 op[0], op[1], op[2]);
10936 printf (" sd = 0x%x,", sd);
4ce8c66d
YS		 10937 printf (" rsrc = 0x%x,", rsrc);
10938 printf (" rdst = 0x%x\n", rdst);
c7927a3c 10939 }
4ce8c66d
YS		 10940 SYNTAX("fsqrt %1%S1, %0");
10941#line 1131 "rx-decode.opc"
10942 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 10943
c7927a3c
NC		 10944 }
10945 break;
10946 }
10947 break;
4ce8c66d 10948 case 0xa1:
c7927a3c
NC		 10949 GETBYTE ();
10950 switch (op[2] & 0x00)
10951 {
10952 case 0x00:
4ce8c66d 10953 goto op_semantics_84;
c7927a3c
NC		 10954 break;
10955 }
10956 break;
4ce8c66d 10957 case 0xa2:
c7927a3c
NC		 10958 GETBYTE ();
10959 switch (op[2] & 0x00)
10960 {
10961 case 0x00:
4ce8c66d 10962 goto op_semantics_84;
c7927a3c
NC		 10963 break;
10964 }
10965 break;
4ce8c66d 10966 case 0xa3:
c7927a3c
NC		 10967 GETBYTE ();
10968 switch (op[2] & 0x00)
10969 {
10970 case 0x00:
4ce8c66d 10971 goto op_semantics_84;
c7927a3c
NC		 10972 break;
10973 }
10974 break;
4ce8c66d 10975 case 0xa4:
c7927a3c
NC		 10976 GETBYTE ();
10977 switch (op[2] & 0x00)
10978 {
10979 case 0x00:
4ce8c66d 10980 op_semantics_85:
a117b0a5 10981 {
4ce8c66d
YS		 10982 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
10983#line 1134 "rx-decode.opc"
a117b0a5 10984 int sd AU = op[1] & 0x03;
4ce8c66d
YS		 10985#line 1134 "rx-decode.opc"
10986 int rsrc AU = (op[2] >> 4) & 0x0f;
10987#line 1134 "rx-decode.opc"
10988 int rdst AU = op[2] & 0x0f;
a117b0a5
YS		 10989 if (trace)
10990 {
10991 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 10992 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
a117b0a5
YS		 10993 op[0], op[1], op[2]);
10994 printf (" sd = 0x%x,", sd);
4ce8c66d
YS		 10995 printf (" rsrc = 0x%x,", rsrc);
10996 printf (" rdst = 0x%x\n", rdst);
a117b0a5 10997 }
4ce8c66d
YS		 10998 SYNTAX("ftou %1%S1, %0");
10999#line 1134 "rx-decode.opc"
11000 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
a117b0a5
YS		 11001
11002 }
11003 break;
11004 }
11005 break;
4ce8c66d 11006 case 0xa5:
a117b0a5
YS		 11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11009 {
11010 case 0x00:
4ce8c66d 11011 goto op_semantics_85;
a117b0a5
YS		 11012 break;
11013 }
11014 break;
4ce8c66d 11015 case 0xa6:
a117b0a5
YS		 11016 GETBYTE ();
11017 switch (op[2] & 0x00)
11018 {
11019 case 0x00:
4ce8c66d 11020 goto op_semantics_85;
a117b0a5
YS		 11021 break;
11022 }
11023 break;
4ce8c66d 11024 case 0xa7:
a117b0a5
YS		 11025 GETBYTE ();
11026 switch (op[2] & 0x00)
11027 {
11028 case 0x00:
4ce8c66d 11029 goto op_semantics_85;
a117b0a5
YS		 11030 break;
11031 }
11032 break;
4ce8c66d 11033 case 0xc8:
a117b0a5 11034 GETBYTE ();
4ce8c66d 11035 switch (op[2] & 0x0f)
a117b0a5 11036 {
4ce8c66d
YS		 11037 case 0x08:
11038 op_semantics_86:
a117b0a5 11039 {
4ce8c66d
YS		 11040 /** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */
11041#line 1198 "rx-decode.opc"
11042 int sz AU = op[1] & 0x03;
11043#line 1198 "rx-decode.opc"
11044 int rsrc AU = (op[2] >> 4) & 0x0f;
a117b0a5
YS		 11045 if (trace)
11046 {
11047 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 11048 "/** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */",
a117b0a5 11049 op[0], op[1], op[2]);
4ce8c66d 11050 printf (" sz = 0x%x,", sz);
a117b0a5
YS		 11051 printf (" rsrc = 0x%x\n", rsrc);
11052 }
4ce8c66d
YS		 11053 SYNTAX("dmov.d %1, %0");
11054#line 1198 "rx-decode.opc"
11055 int rdst;
11056 rx_disp(1, sz, rsrc, RX_Double, ld);
11057 rdst = GETBYTE();
11058 if (rdst & 0x0f)
11059 UNSUPPORTED();
11060 else {
11061 ID(dmov); DDR(rdst >> 4); F_____;
11062 }
a117b0a5
YS		 11063
11064 }
11065 break;
4ce8c66d 11066 default: UNSUPPORTED(); break;
a117b0a5
YS		 11067 }
11068 break;
4ce8c66d 11069 case 0xc9:
a117b0a5 11070 GETBYTE ();
4ce8c66d 11071 switch (op[2] & 0x0f)
a117b0a5 11072 {
4ce8c66d
YS		 11073 case 0x08:
11074 goto op_semantics_86;
a117b0a5 11075 break;
4ce8c66d 11076 default: UNSUPPORTED(); break;
a117b0a5
YS		 11077 }
11078 break;
4ce8c66d 11079 case 0xca:
a117b0a5 11080 GETBYTE ();
4ce8c66d 11081 switch (op[2] & 0x0f)
a117b0a5 11082 {
4ce8c66d
YS		 11083 case 0x08:
11084 goto op_semantics_86;
a117b0a5 11085 break;
4ce8c66d 11086 default: UNSUPPORTED(); break;
a117b0a5
YS		 11087 }
11088 break;
4ce8c66d 11089 case 0xd0:
a117b0a5
YS		 11090 GETBYTE ();
11091 switch (op[2] & 0x00)
11092 {
11093 case 0x00:
4ce8c66d 11094 op_semantics_87:
c7927a3c 11095 {
4ce8c66d
YS		 11096 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
11097#line 1065 "rx-decode.opc"
11098 int sz AU = (op[1] >> 2) & 0x03;
11099#line 1065 "rx-decode.opc"
c7927a3c 11100 int sd AU = op[1] & 0x03;
4ce8c66d 11101#line 1065 "rx-decode.opc"
c7927a3c 11102 int rdst AU = (op[2] >> 4) & 0x0f;
4ce8c66d
YS		 11103#line 1065 "rx-decode.opc"
11104 int cond AU = op[2] & 0x0f;
c7927a3c
NC		 11105 if (trace)
11106 {
11107 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 11108 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
c7927a3c 11109 op[0], op[1], op[2]);
4ce8c66d 11110 printf (" sz = 0x%x,", sz);
c7927a3c
NC		 11111 printf (" sd = 0x%x,", sd);
11112 printf (" rdst = 0x%x,", rdst);
4ce8c66d 11113 printf (" cond = 0x%x\n", cond);
c7927a3c 11114 }
4ce8c66d
YS		 11115 SYNTAX("sc%1%s %0");
11116#line 1065 "rx-decode.opc"
11117 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
11118
11119 /*----------------------------------------------------------------------*/
11120 /* RXv2 enhanced */
43e65147 11121
c7927a3c
NC		 11122 }
11123 break;
11124 }
11125 break;
4ce8c66d 11126 case 0xd1:
c7927a3c
NC		 11127 GETBYTE ();
11128 switch (op[2] & 0x00)
11129 {
11130 case 0x00:
4ce8c66d 11131 goto op_semantics_87;
c7927a3c
NC		 11132 break;
11133 }
11134 break;
4ce8c66d 11135 case 0xd2:
c7927a3c
NC		 11136 GETBYTE ();
11137 switch (op[2] & 0x00)
11138 {
11139 case 0x00:
4ce8c66d 11140 goto op_semantics_87;
c7927a3c
NC		 11141 break;
11142 }
11143 break;
4ce8c66d 11144 case 0xd3:
c7927a3c
NC		 11145 GETBYTE ();
11146 switch (op[2] & 0x00)
11147 {
11148 case 0x00:
4ce8c66d 11149 goto op_semantics_87;
c7927a3c
NC		 11150 break;
11151 }
11152 break;
4ce8c66d 11153 case 0xd4:
c7927a3c
NC		 11154 GETBYTE ();
11155 switch (op[2] & 0x00)
11156 {
11157 case 0x00:
4ce8c66d 11158 goto op_semantics_87;
c7927a3c
NC		 11159 break;
11160 }
11161 break;
4ce8c66d 11162 case 0xd5:
c7927a3c
NC		 11163 GETBYTE ();
11164 switch (op[2] & 0x00)
11165 {
11166 case 0x00:
4ce8c66d 11167 goto op_semantics_87;
c7927a3c
NC		 11168 break;
11169 }
11170 break;
4ce8c66d 11171 case 0xd6:
c7927a3c
NC		 11172 GETBYTE ();
11173 switch (op[2] & 0x00)
11174 {
11175 case 0x00:
4ce8c66d 11176 goto op_semantics_87;
c7927a3c
NC		 11177 break;
11178 }
11179 break;
4ce8c66d 11180 case 0xd7:
c7927a3c
NC		 11181 GETBYTE ();
11182 switch (op[2] & 0x00)
11183 {
11184 case 0x00:
4ce8c66d 11185 goto op_semantics_87;
c7927a3c
NC		 11186 break;
11187 }
11188 break;
4ce8c66d 11189 case 0xd8:
c7927a3c
NC		 11190 GETBYTE ();
11191 switch (op[2] & 0x00)
11192 {
11193 case 0x00:
4ce8c66d 11194 goto op_semantics_87;
c7927a3c
NC		 11195 break;
11196 }
11197 break;
4ce8c66d 11198 case 0xd9:
c7927a3c
NC		 11199 GETBYTE ();
11200 switch (op[2] & 0x00)
11201 {
11202 case 0x00:
4ce8c66d 11203 goto op_semantics_87;
c7927a3c
NC		 11204 break;
11205 }
11206 break;
4ce8c66d 11207 case 0xda:
c7927a3c
NC		 11208 GETBYTE ();
11209 switch (op[2] & 0x00)
11210 {
11211 case 0x00:
4ce8c66d 11212 goto op_semantics_87;
c7927a3c
NC		 11213 break;
11214 }
11215 break;
4ce8c66d 11216 case 0xdb:
c7927a3c
NC		 11217 GETBYTE ();
11218 switch (op[2] & 0x00)
11219 {
11220 case 0x00:
4ce8c66d 11221 goto op_semantics_87;
c7927a3c
NC		 11222 break;
11223 }
11224 break;
4ce8c66d 11225 case 0xe0:
c7927a3c 11226 GETBYTE ();
4ce8c66d 11227 switch (op[2] & 0x0f)
c7927a3c
NC		 11228 {
11229 case 0x00:
4ce8c66d
YS		 11230 case 0x01:
11231 case 0x02:
11232 case 0x03:
11233 case 0x04:
11234 case 0x05:
11235 case 0x06:
11236 case 0x07:
11237 case 0x08:
11238 case 0x09:
11239 case 0x0a:
11240 case 0x0b:
11241 case 0x0c:
11242 case 0x0d:
11243 case 0x0e:
11244 op_semantics_88:
c7927a3c 11245 {
4ce8c66d
YS		 11246 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
11247#line 1008 "rx-decode.opc"
11248 int bit AU = (op[1] >> 2) & 0x07;
11249#line 1008 "rx-decode.opc"
c7927a3c 11250 int sd AU = op[1] & 0x03;
4ce8c66d
YS		 11251#line 1008 "rx-decode.opc"
11252 int rdst AU = (op[2] >> 4) & 0x0f;
11253#line 1008 "rx-decode.opc"
11254 int cond AU = op[2] & 0x0f;
c7927a3c
NC		 11255 if (trace)
11256 {
11257 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 11258 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
c7927a3c 11259 op[0], op[1], op[2]);
4ce8c66d
YS		 11260 printf (" bit = 0x%x,", bit);
11261 printf (" sd = 0x%x,", sd);
11262 printf (" rdst = 0x%x,", rdst);
11263 printf (" cond = 0x%x\n", cond);
11264 }
11265 SYNTAX("bm%2 #%1, %0%S0");
11266#line 1008 "rx-decode.opc"
11267 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
11268
11269 }
11270 break;
11271 case 0x0f:
11272 op_semantics_89:
11273 {
11274 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
11275#line 996 "rx-decode.opc"
11276 int bit AU = (op[1] >> 2) & 0x07;
11277#line 996 "rx-decode.opc"
11278 int sd AU = op[1] & 0x03;
11279#line 996 "rx-decode.opc"
11280 int rdst AU = (op[2] >> 4) & 0x0f;
11281 if (trace)
11282 {
11283 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11284 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
11285 op[0], op[1], op[2]);
11286 printf (" bit = 0x%x,", bit);
c7927a3c 11287 printf (" sd = 0x%x,", sd);
c7927a3c
NC		 11288 printf (" rdst = 0x%x\n", rdst);
11289 }
4ce8c66d
YS		 11290 SYNTAX("bnot #%1, %0%S0");
11291#line 996 "rx-decode.opc"
11292 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
43e65147 11293
c7927a3c
NC		 11294 }
11295 break;
11296 }
11297 break;
4ce8c66d 11298 case 0xe1:
c7927a3c 11299 GETBYTE ();
4ce8c66d 11300 switch (op[2] & 0x0f)
c7927a3c
NC		 11301 {
11302 case 0x00:
4ce8c66d
YS		 11303 case 0x01:
11304 case 0x02:
11305 case 0x03:
11306 case 0x04:
11307 case 0x05:
11308 case 0x06:
11309 case 0x07:
11310 case 0x08:
11311 case 0x09:
11312 case 0x0a:
11313 case 0x0b:
11314 case 0x0c:
11315 case 0x0d:
11316 case 0x0e:
11317 goto op_semantics_88;
11318 break;
11319 case 0x0f:
11320 goto op_semantics_89;
c7927a3c
NC		 11321 break;
11322 }
11323 break;
4ce8c66d 11324 case 0xe2:
c7927a3c 11325 GETBYTE ();
4ce8c66d 11326 switch (op[2] & 0x0f)
c7927a3c
NC		 11327 {
11328 case 0x00:
4ce8c66d
YS		 11329 case 0x01:
11330 case 0x02:
11331 case 0x03:
11332 case 0x04:
11333 case 0x05:
11334 case 0x06:
11335 case 0x07:
11336 case 0x08:
11337 case 0x09:
11338 case 0x0a:
11339 case 0x0b:
11340 case 0x0c:
11341 case 0x0d:
11342 case 0x0e:
11343 goto op_semantics_88;
11344 break;
11345 case 0x0f:
11346 goto op_semantics_89;
c7927a3c
NC		 11347 break;
11348 }
11349 break;
4ce8c66d 11350 case 0xe3:
c7927a3c 11351 GETBYTE ();
4ce8c66d 11352 switch (op[2] & 0x0f)
c7927a3c
NC		 11353 {
11354 case 0x00:
4ce8c66d
YS		 11355 case 0x01:
11356 case 0x02:
11357 case 0x03:
11358 case 0x04:
11359 case 0x05:
11360 case 0x06:
11361 case 0x07:
11362 case 0x08:
11363 case 0x09:
11364 case 0x0a:
11365 case 0x0b:
11366 case 0x0c:
11367 case 0x0d:
11368 case 0x0e:
11369 goto op_semantics_88;
11370 break;
11371 case 0x0f:
11372 goto op_semantics_89;
c7927a3c
NC		 11373 break;
11374 }
11375 break;
4ce8c66d 11376 case 0xe4:
c7927a3c 11377 GETBYTE ();
4ce8c66d 11378 switch (op[2] & 0x0f)
c7927a3c
NC		 11379 {
11380 case 0x00:
4ce8c66d
YS		 11381 case 0x01:
11382 case 0x02:
11383 case 0x03:
11384 case 0x04:
11385 case 0x05:
11386 case 0x06:
11387 case 0x07:
11388 case 0x08:
11389 case 0x09:
11390 case 0x0a:
11391 case 0x0b:
11392 case 0x0c:
11393 case 0x0d:
11394 case 0x0e:
11395 goto op_semantics_88;
11396 break;
11397 case 0x0f:
11398 goto op_semantics_89;
c7927a3c
NC		 11399 break;
11400 }
11401 break;
4ce8c66d 11402 case 0xe5:
c7927a3c 11403 GETBYTE ();
4ce8c66d 11404 switch (op[2] & 0x0f)
c7927a3c
NC		 11405 {
11406 case 0x00:
4ce8c66d
YS		 11407 case 0x01:
11408 case 0x02:
11409 case 0x03:
11410 case 0x04:
11411 case 0x05:
11412 case 0x06:
11413 case 0x07:
11414 case 0x08:
11415 case 0x09:
11416 case 0x0a:
11417 case 0x0b:
11418 case 0x0c:
11419 case 0x0d:
11420 case 0x0e:
11421 goto op_semantics_88;
11422 break;
11423 case 0x0f:
11424 goto op_semantics_89;
c7927a3c
NC		 11425 break;
11426 }
11427 break;
4ce8c66d 11428 case 0xe6:
c7927a3c 11429 GETBYTE ();
4ce8c66d 11430 switch (op[2] & 0x0f)
c7927a3c
NC		 11431 {
11432 case 0x00:
4ce8c66d
YS		 11433 case 0x01:
11434 case 0x02:
11435 case 0x03:
11436 case 0x04:
11437 case 0x05:
11438 case 0x06:
11439 case 0x07:
11440 case 0x08:
11441 case 0x09:
11442 case 0x0a:
11443 case 0x0b:
11444 case 0x0c:
11445 case 0x0d:
11446 case 0x0e:
11447 goto op_semantics_88;
11448 break;
11449 case 0x0f:
11450 goto op_semantics_89;
c7927a3c
NC		 11451 break;
11452 }
11453 break;
4ce8c66d 11454 case 0xe7:
c7927a3c 11455 GETBYTE ();
4ce8c66d 11456 switch (op[2] & 0x0f)
c7927a3c
NC		 11457 {
11458 case 0x00:
4ce8c66d
YS		 11459 case 0x01:
11460 case 0x02:
11461 case 0x03:
11462 case 0x04:
11463 case 0x05:
11464 case 0x06:
11465 case 0x07:
11466 case 0x08:
11467 case 0x09:
11468 case 0x0a:
11469 case 0x0b:
11470 case 0x0c:
11471 case 0x0d:
11472 case 0x0e:
11473 goto op_semantics_88;
11474 break;
11475 case 0x0f:
11476 goto op_semantics_89;
c7927a3c
NC		 11477 break;
11478 }
11479 break;
4ce8c66d 11480 case 0xe8:
c7927a3c 11481 GETBYTE ();
4ce8c66d 11482 switch (op[2] & 0x0f)
c7927a3c
NC		 11483 {
11484 case 0x00:
4ce8c66d
YS		 11485 case 0x01:
11486 case 0x02:
11487 case 0x03:
11488 case 0x04:
11489 case 0x05:
11490 case 0x06:
11491 case 0x07:
11492 case 0x08:
11493 case 0x09:
11494 case 0x0a:
11495 case 0x0b:
11496 case 0x0c:
11497 case 0x0d:
11498 case 0x0e:
11499 goto op_semantics_88;
11500 break;
11501 case 0x0f:
11502 goto op_semantics_89;
c7927a3c
NC		 11503 break;
11504 }
11505 break;
4ce8c66d 11506 case 0xe9:
c7927a3c 11507 GETBYTE ();
4ce8c66d 11508 switch (op[2] & 0x0f)
c7927a3c
NC		 11509 {
11510 case 0x00:
4ce8c66d
YS		 11511 case 0x01:
11512 case 0x02:
11513 case 0x03:
11514 case 0x04:
11515 case 0x05:
11516 case 0x06:
11517 case 0x07:
11518 case 0x08:
11519 case 0x09:
11520 case 0x0a:
11521 case 0x0b:
11522 case 0x0c:
11523 case 0x0d:
11524 case 0x0e:
11525 goto op_semantics_88;
11526 break;
11527 case 0x0f:
11528 goto op_semantics_89;
c7927a3c
NC		 11529 break;
11530 }
11531 break;
4ce8c66d 11532 case 0xea:
c7927a3c 11533 GETBYTE ();
4ce8c66d 11534 switch (op[2] & 0x0f)
c7927a3c
NC		 11535 {
11536 case 0x00:
4ce8c66d
YS		 11537 case 0x01:
11538 case 0x02:
11539 case 0x03:
11540 case 0x04:
11541 case 0x05:
11542 case 0x06:
11543 case 0x07:
11544 case 0x08:
11545 case 0x09:
11546 case 0x0a:
11547 case 0x0b:
11548 case 0x0c:
11549 case 0x0d:
11550 case 0x0e:
11551 goto op_semantics_88;
11552 break;
11553 case 0x0f:
11554 goto op_semantics_89;
c7927a3c
NC		 11555 break;
11556 }
11557 break;
4ce8c66d 11558 case 0xeb:
c7927a3c 11559 GETBYTE ();
4ce8c66d 11560 switch (op[2] & 0x0f)
c7927a3c
NC		 11561 {
11562 case 0x00:
4ce8c66d
YS		 11563 case 0x01:
11564 case 0x02:
11565 case 0x03:
11566 case 0x04:
11567 case 0x05:
11568 case 0x06:
11569 case 0x07:
11570 case 0x08:
11571 case 0x09:
11572 case 0x0a:
11573 case 0x0b:
11574 case 0x0c:
11575 case 0x0d:
11576 case 0x0e:
11577 goto op_semantics_88;
11578 break;
11579 case 0x0f:
11580 goto op_semantics_89;
c7927a3c
NC		 11581 break;
11582 }
11583 break;
4ce8c66d 11584 case 0xec:
c7927a3c 11585 GETBYTE ();
4ce8c66d 11586 switch (op[2] & 0x0f)
c7927a3c
NC		 11587 {
11588 case 0x00:
4ce8c66d
YS		 11589 case 0x01:
11590 case 0x02:
11591 case 0x03:
11592 case 0x04:
11593 case 0x05:
11594 case 0x06:
11595 case 0x07:
11596 case 0x08:
11597 case 0x09:
11598 case 0x0a:
11599 case 0x0b:
11600 case 0x0c:
11601 case 0x0d:
11602 case 0x0e:
11603 goto op_semantics_88;
11604 break;
11605 case 0x0f:
11606 goto op_semantics_89;
c7927a3c
NC		 11607 break;
11608 }
11609 break;
4ce8c66d 11610 case 0xed:
c7927a3c 11611 GETBYTE ();
4ce8c66d 11612 switch (op[2] & 0x0f)
c7927a3c
NC		 11613 {
11614 case 0x00:
4ce8c66d
YS		 11615 case 0x01:
11616 case 0x02:
11617 case 0x03:
11618 case 0x04:
11619 case 0x05:
11620 case 0x06:
11621 case 0x07:
11622 case 0x08:
11623 case 0x09:
11624 case 0x0a:
11625 case 0x0b:
11626 case 0x0c:
11627 case 0x0d:
11628 case 0x0e:
11629 goto op_semantics_88;
11630 break;
11631 case 0x0f:
11632 goto op_semantics_89;
c7927a3c
NC		 11633 break;
11634 }
11635 break;
4ce8c66d 11636 case 0xee:
c7927a3c 11637 GETBYTE ();
4ce8c66d 11638 switch (op[2] & 0x0f)
c7927a3c
NC		 11639 {
11640 case 0x00:
4ce8c66d
YS		 11641 case 0x01:
11642 case 0x02:
11643 case 0x03:
11644 case 0x04:
11645 case 0x05:
11646 case 0x06:
11647 case 0x07:
11648 case 0x08:
11649 case 0x09:
11650 case 0x0a:
11651 case 0x0b:
11652 case 0x0c:
11653 case 0x0d:
11654 case 0x0e:
11655 goto op_semantics_88;
c7927a3c 11656 break;
4ce8c66d
YS		 11657 case 0x0f:
11658 goto op_semantics_89;
c7927a3c
NC		 11659 break;
11660 }
11661 break;
4ce8c66d 11662 case 0xef:
c7927a3c 11663 GETBYTE ();
4ce8c66d 11664 switch (op[2] & 0x0f)
c7927a3c
NC		 11665 {
11666 case 0x00:
4ce8c66d
YS		 11667 case 0x01:
11668 case 0x02:
11669 case 0x03:
11670 case 0x04:
11671 case 0x05:
11672 case 0x06:
11673 case 0x07:
11674 case 0x08:
11675 case 0x09:
11676 case 0x0a:
11677 case 0x0b:
11678 case 0x0c:
11679 case 0x0d:
11680 case 0x0e:
11681 goto op_semantics_88;
11682 break;
11683 case 0x0f:
11684 goto op_semantics_89;
c7927a3c
NC		 11685 break;
11686 }
11687 break;
4ce8c66d 11688 case 0xf0:
c7927a3c 11689 GETBYTE ();
4ce8c66d 11690 switch (op[2] & 0x0f)
c7927a3c
NC		 11691 {
11692 case 0x00:
4ce8c66d
YS		 11693 case 0x01:
11694 case 0x02:
11695 case 0x03:
11696 case 0x04:
11697 case 0x05:
11698 case 0x06:
11699 case 0x07:
11700 case 0x08:
11701 case 0x09:
11702 case 0x0a:
11703 case 0x0b:
11704 case 0x0c:
11705 case 0x0d:
11706 case 0x0e:
11707 goto op_semantics_88;
11708 break;
11709 case 0x0f:
11710 goto op_semantics_89;
c7927a3c
NC		 11711 break;
11712 }
11713 break;
4ce8c66d 11714 case 0xf1:
c7927a3c 11715 GETBYTE ();
4ce8c66d 11716 switch (op[2] & 0x0f)
c7927a3c
NC		 11717 {
11718 case 0x00:
4ce8c66d
YS		 11719 case 0x01:
11720 case 0x02:
11721 case 0x03:
11722 case 0x04:
11723 case 0x05:
11724 case 0x06:
11725 case 0x07:
11726 case 0x08:
11727 case 0x09:
11728 case 0x0a:
11729 case 0x0b:
11730 case 0x0c:
11731 case 0x0d:
11732 case 0x0e:
11733 goto op_semantics_88;
11734 break;
11735 case 0x0f:
11736 goto op_semantics_89;
c7927a3c
NC		 11737 break;
11738 }
11739 break;
4ce8c66d 11740 case 0xf2:
c7927a3c 11741 GETBYTE ();
4ce8c66d 11742 switch (op[2] & 0x0f)
c7927a3c
NC		 11743 {
11744 case 0x00:
4ce8c66d
YS		 11745 case 0x01:
11746 case 0x02:
11747 case 0x03:
11748 case 0x04:
11749 case 0x05:
11750 case 0x06:
11751 case 0x07:
11752 case 0x08:
11753 case 0x09:
11754 case 0x0a:
11755 case 0x0b:
11756 case 0x0c:
11757 case 0x0d:
11758 case 0x0e:
11759 goto op_semantics_88;
11760 break;
11761 case 0x0f:
11762 goto op_semantics_89;
c7927a3c
NC		 11763 break;
11764 }
11765 break;
4ce8c66d 11766 case 0xf3:
c7927a3c 11767 GETBYTE ();
4ce8c66d 11768 switch (op[2] & 0x0f)
c7927a3c
NC		 11769 {
11770 case 0x00:
4ce8c66d
YS		 11771 case 0x01:
11772 case 0x02:
11773 case 0x03:
11774 case 0x04:
11775 case 0x05:
11776 case 0x06:
11777 case 0x07:
11778 case 0x08:
11779 case 0x09:
11780 case 0x0a:
11781 case 0x0b:
11782 case 0x0c:
11783 case 0x0d:
11784 case 0x0e:
11785 goto op_semantics_88;
11786 break;
11787 case 0x0f:
11788 goto op_semantics_89;
c7927a3c
NC		 11789 break;
11790 }
11791 break;
4ce8c66d 11792 case 0xf4:
c7927a3c 11793 GETBYTE ();
4ce8c66d 11794 switch (op[2] & 0x0f)
c7927a3c
NC		 11795 {
11796 case 0x00:
4ce8c66d
YS		 11797 case 0x01:
11798 case 0x02:
11799 case 0x03:
11800 case 0x04:
11801 case 0x05:
11802 case 0x06:
11803 case 0x07:
11804 case 0x08:
11805 case 0x09:
11806 case 0x0a:
11807 case 0x0b:
11808 case 0x0c:
11809 case 0x0d:
11810 case 0x0e:
11811 goto op_semantics_88;
11812 break;
11813 case 0x0f:
11814 goto op_semantics_89;
c7927a3c
NC		 11815 break;
11816 }
11817 break;
4ce8c66d 11818 case 0xf5:
c7927a3c 11819 GETBYTE ();
4ce8c66d 11820 switch (op[2] & 0x0f)
c7927a3c
NC		 11821 {
11822 case 0x00:
4ce8c66d
YS		 11823 case 0x01:
11824 case 0x02:
11825 case 0x03:
11826 case 0x04:
11827 case 0x05:
11828 case 0x06:
11829 case 0x07:
11830 case 0x08:
11831 case 0x09:
11832 case 0x0a:
11833 case 0x0b:
11834 case 0x0c:
11835 case 0x0d:
11836 case 0x0e:
11837 goto op_semantics_88;
11838 break;
11839 case 0x0f:
11840 goto op_semantics_89;
c7927a3c
NC		 11841 break;
11842 }
11843 break;
4ce8c66d 11844 case 0xf6:
c7927a3c 11845 GETBYTE ();
4ce8c66d 11846 switch (op[2] & 0x0f)
c7927a3c
NC		 11847 {
11848 case 0x00:
4ce8c66d
YS		 11849 case 0x01:
11850 case 0x02:
11851 case 0x03:
11852 case 0x04:
11853 case 0x05:
11854 case 0x06:
11855 case 0x07:
11856 case 0x08:
11857 case 0x09:
11858 case 0x0a:
11859 case 0x0b:
11860 case 0x0c:
11861 case 0x0d:
11862 case 0x0e:
11863 goto op_semantics_88;
11864 break;
11865 case 0x0f:
11866 goto op_semantics_89;
c7927a3c
NC		 11867 break;
11868 }
11869 break;
4ce8c66d 11870 case 0xf7:
c7927a3c 11871 GETBYTE ();
4ce8c66d 11872 switch (op[2] & 0x0f)
c7927a3c
NC		 11873 {
11874 case 0x00:
4ce8c66d
YS		 11875 case 0x01:
11876 case 0x02:
11877 case 0x03:
11878 case 0x04:
11879 case 0x05:
11880 case 0x06:
11881 case 0x07:
11882 case 0x08:
11883 case 0x09:
11884 case 0x0a:
11885 case 0x0b:
11886 case 0x0c:
11887 case 0x0d:
11888 case 0x0e:
11889 goto op_semantics_88;
11890 break;
11891 case 0x0f:
11892 goto op_semantics_89;
c7927a3c
NC		 11893 break;
11894 }
11895 break;
4ce8c66d 11896 case 0xf8:
c7927a3c 11897 GETBYTE ();
4ce8c66d 11898 switch (op[2] & 0x0f)
c7927a3c
NC		 11899 {
11900 case 0x00:
4ce8c66d
YS		 11901 case 0x01:
11902 case 0x02:
11903 case 0x03:
11904 case 0x04:
11905 case 0x05:
11906 case 0x06:
11907 case 0x07:
11908 case 0x08:
11909 case 0x09:
11910 case 0x0a:
11911 case 0x0b:
11912 case 0x0c:
11913 case 0x0d:
11914 case 0x0e:
11915 goto op_semantics_88;
11916 break;
11917 case 0x0f:
11918 goto op_semantics_89;
c7927a3c
NC		 11919 break;
11920 }
11921 break;
4ce8c66d 11922 case 0xf9:
c7927a3c 11923 GETBYTE ();
4ce8c66d 11924 switch (op[2] & 0x0f)
c7927a3c
NC		 11925 {
11926 case 0x00:
4ce8c66d
YS		 11927 case 0x01:
11928 case 0x02:
11929 case 0x03:
11930 case 0x04:
11931 case 0x05:
11932 case 0x06:
11933 case 0x07:
11934 case 0x08:
11935 case 0x09:
11936 case 0x0a:
11937 case 0x0b:
11938 case 0x0c:
11939 case 0x0d:
11940 case 0x0e:
11941 goto op_semantics_88;
11942 break;
11943 case 0x0f:
11944 goto op_semantics_89;
c7927a3c
NC		 11945 break;
11946 }
11947 break;
4ce8c66d 11948 case 0xfa:
c7927a3c 11949 GETBYTE ();
4ce8c66d 11950 switch (op[2] & 0x0f)
c7927a3c
NC		 11951 {
11952 case 0x00:
4ce8c66d
YS		 11953 case 0x01:
11954 case 0x02:
11955 case 0x03:
11956 case 0x04:
11957 case 0x05:
11958 case 0x06:
11959 case 0x07:
11960 case 0x08:
11961 case 0x09:
11962 case 0x0a:
11963 case 0x0b:
11964 case 0x0c:
11965 case 0x0d:
11966 case 0x0e:
11967 goto op_semantics_88;
11968 break;
11969 case 0x0f:
11970 goto op_semantics_89;
c7927a3c
NC		 11971 break;
11972 }
11973 break;
4ce8c66d 11974 case 0xfb:
c7927a3c 11975 GETBYTE ();
4ce8c66d 11976 switch (op[2] & 0x0f)
c7927a3c
NC		 11977 {
11978 case 0x00:
4ce8c66d
YS		 11979 case 0x01:
11980 case 0x02:
11981 case 0x03:
11982 case 0x04:
11983 case 0x05:
11984 case 0x06:
11985 case 0x07:
11986 case 0x08:
11987 case 0x09:
11988 case 0x0a:
11989 case 0x0b:
11990 case 0x0c:
11991 case 0x0d:
11992 case 0x0e:
11993 goto op_semantics_88;
11994 break;
11995 case 0x0f:
11996 goto op_semantics_89;
a117b0a5
YS		 11997 break;
11998 }
11999 break;
4ce8c66d 12000 case 0xfc:
a117b0a5 12001 GETBYTE ();
4ce8c66d 12002 switch (op[2] & 0x0f)
c7927a3c
NC		 12003 {
12004 case 0x00:
4ce8c66d
YS		 12005 case 0x01:
12006 case 0x02:
12007 case 0x03:
12008 case 0x04:
12009 case 0x05:
12010 case 0x06:
12011 case 0x07:
12012 case 0x08:
12013 case 0x09:
12014 case 0x0a:
12015 case 0x0b:
12016 case 0x0c:
12017 case 0x0d:
12018 case 0x0e:
12019 goto op_semantics_88;
12020 break;
12021 case 0x0f:
12022 goto op_semantics_89;
a117b0a5
YS		 12023 break;
12024 }
12025 break;
4ce8c66d 12026 case 0xfd:
a117b0a5 12027 GETBYTE ();
4ce8c66d 12028 switch (op[2] & 0x0f)
a117b0a5
YS		 12029 {
12030 case 0x00:
4ce8c66d
YS		 12031 case 0x01:
12032 case 0x02:
12033 case 0x03:
12034 case 0x04:
12035 case 0x05:
12036 case 0x06:
12037 case 0x07:
12038 case 0x08:
12039 case 0x09:
12040 case 0x0a:
12041 case 0x0b:
12042 case 0x0c:
12043 case 0x0d:
12044 case 0x0e:
12045 goto op_semantics_88;
12046 break;
12047 case 0x0f:
12048 goto op_semantics_89;
a117b0a5
YS		 12049 break;
12050 }
12051 break;
4ce8c66d 12052 case 0xfe:
a117b0a5 12053 GETBYTE ();
4ce8c66d 12054 switch (op[2] & 0x0f)
a117b0a5
YS		 12055 {
12056 case 0x00:
4ce8c66d
YS		 12057 case 0x01:
12058 case 0x02:
12059 case 0x03:
12060 case 0x04:
12061 case 0x05:
12062 case 0x06:
12063 case 0x07:
12064 case 0x08:
12065 case 0x09:
12066 case 0x0a:
12067 case 0x0b:
12068 case 0x0c:
12069 case 0x0d:
12070 case 0x0e:
12071 goto op_semantics_88;
12072 break;
12073 case 0x0f:
12074 goto op_semantics_89;
a117b0a5
YS		 12075 break;
12076 }
12077 break;
4ce8c66d 12078 case 0xff:
a117b0a5 12079 GETBYTE ();
4ce8c66d 12080 switch (op[2] & 0x0f)
a117b0a5
YS		 12081 {
12082 case 0x00:
4ce8c66d
YS		 12083 case 0x01:
12084 case 0x02:
12085 case 0x03:
12086 case 0x04:
12087 case 0x05:
12088 case 0x06:
12089 case 0x07:
12090 case 0x08:
12091 case 0x09:
12092 case 0x0a:
12093 case 0x0b:
12094 case 0x0c:
12095 case 0x0d:
12096 case 0x0e:
12097 goto op_semantics_88;
12098 break;
12099 case 0x0f:
12100 goto op_semantics_89;
a117b0a5
YS		 12101 break;
12102 }
12103 break;
4ce8c66d
YS		 12104 default: UNSUPPORTED(); break;
12105 }
12106 break;
12107 case 0xfd:
12108 GETBYTE ();
12109 switch (op[1] & 0xff)
12110 {
12111 case 0x00:
a117b0a5
YS		 12112 GETBYTE ();
12113 switch (op[2] & 0x00)
12114 {
12115 case 0x00:
4ce8c66d
YS		 12116 op_semantics_90:
12117 {
12118 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
12119#line 873 "rx-decode.opc"
12120 int a AU = (op[1] >> 3) & 0x01;
12121#line 873 "rx-decode.opc"
12122 int srca AU = (op[2] >> 4) & 0x0f;
12123#line 873 "rx-decode.opc"
12124 int srcb AU = op[2] & 0x0f;
12125 if (trace)
12126 {
12127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12128 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
12129 op[0], op[1], op[2]);
12130 printf (" a = 0x%x,", a);
12131 printf (" srca = 0x%x,", srca);
12132 printf (" srcb = 0x%x\n", srcb);
12133 }
12134 SYNTAX("mulhi %1, %2, %0");
12135#line 873 "rx-decode.opc"
12136 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
12137
12138 }
a117b0a5
YS		 12139 break;
12140 }
12141 break;
4ce8c66d 12142 case 0x01:
a117b0a5
YS		 12143 GETBYTE ();
12144 switch (op[2] & 0x00)
12145 {
12146 case 0x00:
4ce8c66d
YS		 12147 op_semantics_91:
12148 {
12149 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
12150#line 876 "rx-decode.opc"
12151 int a AU = (op[1] >> 3) & 0x01;
12152#line 876 "rx-decode.opc"
12153 int srca AU = (op[2] >> 4) & 0x0f;
12154#line 876 "rx-decode.opc"
12155 int srcb AU = op[2] & 0x0f;
12156 if (trace)
12157 {
12158 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12159 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
12160 op[0], op[1], op[2]);
12161 printf (" a = 0x%x,", a);
12162 printf (" srca = 0x%x,", srca);
12163 printf (" srcb = 0x%x\n", srcb);
12164 }
12165 SYNTAX("mullo %1, %2, %0");
12166#line 876 "rx-decode.opc"
12167 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
12168
12169 }
a117b0a5
YS		 12170 break;
12171 }
12172 break;
4ce8c66d 12173 case 0x02:
a117b0a5
YS		 12174 GETBYTE ();
12175 switch (op[2] & 0x00)
12176 {
12177 case 0x00:
4ce8c66d
YS		 12178 op_semantics_92:
12179 {
12180 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
12181#line 1104 "rx-decode.opc"
12182 int a AU = (op[1] >> 3) & 0x01;
12183#line 1104 "rx-decode.opc"
12184 int srca AU = (op[2] >> 4) & 0x0f;
12185#line 1104 "rx-decode.opc"
12186 int srcb AU = op[2] & 0x0f;
12187 if (trace)
12188 {
12189 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12190 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
12191 op[0], op[1], op[2]);
12192 printf (" a = 0x%x,", a);
12193 printf (" srca = 0x%x,", srca);
12194 printf (" srcb = 0x%x\n", srcb);
12195 }
12196 SYNTAX("mullh %1, %2, %0");
12197#line 1104 "rx-decode.opc"
12198 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
12199
12200 }
a117b0a5
YS		 12201 break;
12202 }
12203 break;
4ce8c66d 12204 case 0x03:
a117b0a5
YS		 12205 GETBYTE ();
12206 switch (op[2] & 0x00)
12207 {
12208 case 0x00:
4ce8c66d
YS		 12209 op_semantics_93:
12210 {
12211 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
12212#line 1089 "rx-decode.opc"
12213 int a AU = (op[1] >> 3) & 0x01;
12214#line 1089 "rx-decode.opc"
12215 int srca AU = (op[2] >> 4) & 0x0f;
12216#line 1089 "rx-decode.opc"
12217 int srcb AU = op[2] & 0x0f;
12218 if (trace)
12219 {
12220 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12221 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
12222 op[0], op[1], op[2]);
12223 printf (" a = 0x%x,", a);
12224 printf (" srca = 0x%x,", srca);
12225 printf (" srcb = 0x%x\n", srcb);
12226 }
12227 SYNTAX("emula %1, %2, %0");
12228#line 1089 "rx-decode.opc"
12229 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
12230
12231 }
a117b0a5
YS		 12232 break;
12233 }
12234 break;
4ce8c66d 12235 case 0x04:
a117b0a5
YS		 12236 GETBYTE ();
12237 switch (op[2] & 0x00)
12238 {
12239 case 0x00:
4ce8c66d
YS		 12240 op_semantics_94:
12241 {
12242 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
12243#line 879 "rx-decode.opc"
12244 int a AU = (op[1] >> 3) & 0x01;
12245#line 879 "rx-decode.opc"
12246 int srca AU = (op[2] >> 4) & 0x0f;
12247#line 879 "rx-decode.opc"
12248 int srcb AU = op[2] & 0x0f;
12249 if (trace)
12250 {
12251 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12252 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
12253 op[0], op[1], op[2]);
12254 printf (" a = 0x%x,", a);
12255 printf (" srca = 0x%x,", srca);
12256 printf (" srcb = 0x%x\n", srcb);
12257 }
12258 SYNTAX("machi %1, %2, %0");
12259#line 879 "rx-decode.opc"
12260 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
12261
12262 }
a117b0a5
YS		 12263 break;
12264 }
12265 break;
4ce8c66d 12266 case 0x05:
a117b0a5
YS		 12267 GETBYTE ();
12268 switch (op[2] & 0x00)
12269 {
12270 case 0x00:
4ce8c66d
YS		 12271 op_semantics_95:
12272 {
12273 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
12274#line 882 "rx-decode.opc"
12275 int a AU = (op[1] >> 3) & 0x01;
12276#line 882 "rx-decode.opc"
12277 int srca AU = (op[2] >> 4) & 0x0f;
12278#line 882 "rx-decode.opc"
12279 int srcb AU = op[2] & 0x0f;
12280 if (trace)
12281 {
12282 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12283 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
12284 op[0], op[1], op[2]);
12285 printf (" a = 0x%x,", a);
12286 printf (" srca = 0x%x,", srca);
12287 printf (" srcb = 0x%x\n", srcb);
12288 }
12289 SYNTAX("maclo %1, %2, %0");
12290#line 882 "rx-decode.opc"
12291 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
12292
12293 }
c7927a3c
NC		 12294 break;
12295 }
12296 break;
4ce8c66d 12297 case 0x06:
c7927a3c
NC		 12298 GETBYTE ();
12299 switch (op[2] & 0x00)
12300 {
12301 case 0x00:
4ce8c66d 12302 op_semantics_96:
c7927a3c 12303 {
4ce8c66d
YS		 12304 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
12305#line 1092 "rx-decode.opc"
12306 int a AU = (op[1] >> 3) & 0x01;
12307#line 1092 "rx-decode.opc"
12308 int srca AU = (op[2] >> 4) & 0x0f;
12309#line 1092 "rx-decode.opc"
12310 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 12311 if (trace)
12312 {
12313 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 12314 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
c7927a3c 12315 op[0], op[1], op[2]);
4ce8c66d
YS		 12316 printf (" a = 0x%x,", a);
12317 printf (" srca = 0x%x,", srca);
12318 printf (" srcb = 0x%x\n", srcb);
c7927a3c 12319 }
4ce8c66d
YS		 12320 SYNTAX("maclh %1, %2, %0");
12321#line 1092 "rx-decode.opc"
12322 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 12323
c7927a3c
NC		 12324 }
12325 break;
4ce8c66d
YS		 12326 }
12327 break;
12328 case 0x07:
12329 GETBYTE ();
12330 switch (op[2] & 0x00)
12331 {
12332 case 0x00:
12333 op_semantics_97:
c7927a3c 12334 {
4ce8c66d
YS		 12335 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
12336#line 1083 "rx-decode.opc"
12337 int a AU = (op[1] >> 3) & 0x01;
12338#line 1083 "rx-decode.opc"
12339 int srca AU = (op[2] >> 4) & 0x0f;
12340#line 1083 "rx-decode.opc"
12341 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 12342 if (trace)
12343 {
12344 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 12345 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
c7927a3c 12346 op[0], op[1], op[2]);
4ce8c66d
YS		 12347 printf (" a = 0x%x,", a);
12348 printf (" srca = 0x%x,", srca);
12349 printf (" srcb = 0x%x\n", srcb);
c7927a3c 12350 }
4ce8c66d
YS		 12351 SYNTAX("emaca %1, %2, %0");
12352#line 1083 "rx-decode.opc"
12353 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 12354
c7927a3c
NC		 12355 }
12356 break;
12357 }
12358 break;
4ce8c66d 12359 case 0x08:
c7927a3c 12360 GETBYTE ();
4ce8c66d 12361 switch (op[2] & 0x00)
c7927a3c
NC		 12362 {
12363 case 0x00:
4ce8c66d 12364 goto op_semantics_90;
c7927a3c
NC		 12365 break;
12366 }
12367 break;
4ce8c66d 12368 case 0x09:
c7927a3c 12369 GETBYTE ();
4ce8c66d 12370 switch (op[2] & 0x00)
c7927a3c
NC		 12371 {
12372 case 0x00:
4ce8c66d 12373 goto op_semantics_91;
c7927a3c
NC		 12374 break;
12375 }
12376 break;
4ce8c66d 12377 case 0x0a:
c7927a3c 12378 GETBYTE ();
4ce8c66d 12379 switch (op[2] & 0x00)
c7927a3c
NC		 12380 {
12381 case 0x00:
4ce8c66d 12382 goto op_semantics_92;
c7927a3c 12383 break;
4ce8c66d
YS		 12384 }
12385 break;
12386 case 0x0b:
12387 GETBYTE ();
12388 switch (op[2] & 0x00)
12389 {
12390 case 0x00:
12391 goto op_semantics_93;
c7927a3c
NC		 12392 break;
12393 }
12394 break;
4ce8c66d 12395 case 0x0c:
c7927a3c 12396 GETBYTE ();
4ce8c66d 12397 switch (op[2] & 0x00)
c7927a3c
NC		 12398 {
12399 case 0x00:
4ce8c66d 12400 goto op_semantics_94;
c7927a3c 12401 break;
4ce8c66d
YS		 12402 }
12403 break;
12404 case 0x0d:
12405 GETBYTE ();
12406 switch (op[2] & 0x00)
12407 {
12408 case 0x00:
12409 goto op_semantics_95;
c7927a3c
NC		 12410 break;
12411 }
12412 break;
4ce8c66d 12413 case 0x0e:
c7927a3c 12414 GETBYTE ();
4ce8c66d 12415 switch (op[2] & 0x00)
c7927a3c
NC		 12416 {
12417 case 0x00:
4ce8c66d 12418 goto op_semantics_96;
c7927a3c 12419 break;
4ce8c66d
YS		 12420 }
12421 break;
12422 case 0x0f:
12423 GETBYTE ();
12424 switch (op[2] & 0x00)
12425 {
12426 case 0x00:
12427 goto op_semantics_97;
c7927a3c
NC		 12428 break;
12429 }
12430 break;
4ce8c66d 12431 case 0x17:
c7927a3c 12432 GETBYTE ();
4ce8c66d 12433 switch (op[2] & 0x70)
c7927a3c
NC		 12434 {
12435 case 0x00:
4ce8c66d
YS		 12436 {
12437 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
12438#line 885 "rx-decode.opc"
12439 int a AU = (op[2] >> 7) & 0x01;
12440#line 885 "rx-decode.opc"
12441 int rsrc AU = op[2] & 0x0f;
12442 if (trace)
12443 {
12444 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12445 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
12446 op[0], op[1], op[2]);
12447 printf (" a = 0x%x,", a);
12448 printf (" rsrc = 0x%x\n", rsrc);
12449 }
12450 SYNTAX("mvtachi %1, %0");
12451#line 885 "rx-decode.opc"
12452 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
12453
12454 }
c7927a3c 12455 break;
4ce8c66d
YS		 12456 case 0x10:
12457 {
12458 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
12459#line 888 "rx-decode.opc"
12460 int a AU = (op[2] >> 7) & 0x01;
12461#line 888 "rx-decode.opc"
12462 int rsrc AU = op[2] & 0x0f;
12463 if (trace)
12464 {
12465 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12466 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
12467 op[0], op[1], op[2]);
12468 printf (" a = 0x%x,", a);
12469 printf (" rsrc = 0x%x\n", rsrc);
12470 }
12471 SYNTAX("mvtaclo %1, %0");
12472#line 888 "rx-decode.opc"
12473 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
12474
12475 }
12476 break;
12477 case 0x30:
12478 {
12479 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
12480#line 1110 "rx-decode.opc"
12481 int a AU = (op[2] >> 7) & 0x01;
12482#line 1110 "rx-decode.opc"
12483 int rdst AU = op[2] & 0x0f;
12484 if (trace)
12485 {
12486 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12487 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
12488 op[0], op[1], op[2]);
12489 printf (" a = 0x%x,", a);
12490 printf (" rdst = 0x%x\n", rdst);
12491 }
12492 SYNTAX("mvtacgu %0, %1");
12493#line 1110 "rx-decode.opc"
12494 ID(mvtacgu); DR(a+32); SR(rdst); F_____;
12495
12496 }
c7927a3c 12497 break;
4ce8c66d 12498 default: UNSUPPORTED(); break;
c7927a3c
NC		 12499 }
12500 break;
4ce8c66d 12501 case 0x18:
c7927a3c 12502 GETBYTE ();
4ce8c66d 12503 switch (op[2] & 0x6f)
c7927a3c
NC		 12504 {
12505 case 0x00:
4ce8c66d
YS		 12506 {
12507 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
12508#line 900 "rx-decode.opc"
12509 int a AU = (op[2] >> 7) & 0x01;
12510#line 900 "rx-decode.opc"
12511 int i AU = (op[2] >> 4) & 0x01;
12512 if (trace)
12513 {
12514 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12515 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
12516 op[0], op[1], op[2]);
12517 printf (" a = 0x%x,", a);
12518 printf (" i = 0x%x\n", i);
12519 }
12520 SYNTAX("racw #%1, %0");
12521#line 900 "rx-decode.opc"
12522 ID(racw); SC(i+1); DR(a+32); F_____;
12523
12524 /*----------------------------------------------------------------------*/
12525 /* SAT */
12526
12527 }
c7927a3c 12528 break;
4ce8c66d
YS		 12529 case 0x40:
12530 {
12531 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
12532#line 1119 "rx-decode.opc"
12533 int a AU = (op[2] >> 7) & 0x01;
12534#line 1119 "rx-decode.opc"
12535 int i AU = (op[2] >> 4) & 0x01;
12536 if (trace)
12537 {
12538 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12539 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
12540 op[0], op[1], op[2]);
12541 printf (" a = 0x%x,", a);
12542 printf (" i = 0x%x\n", i);
12543 }
12544 SYNTAX("rdacw #%1, %0");
12545#line 1119 "rx-decode.opc"
12546 ID(rdacw); SC(i+1); DR(a+32); F_____;
12547
12548 }
c7927a3c 12549 break;
4ce8c66d 12550 default: UNSUPPORTED(); break;
c7927a3c
NC		 12551 }
12552 break;
4ce8c66d 12553 case 0x19:
c7927a3c 12554 GETBYTE ();
4ce8c66d 12555 switch (op[2] & 0x6f)
c7927a3c
NC		 12556 {
12557 case 0x00:
4ce8c66d
YS		 12558 {
12559 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
12560#line 1113 "rx-decode.opc"
12561 int a AU = (op[2] >> 7) & 0x01;
12562#line 1113 "rx-decode.opc"
12563 int i AU = (op[2] >> 4) & 0x01;
12564 if (trace)
12565 {
12566 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12567 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
12568 op[0], op[1], op[2]);
12569 printf (" a = 0x%x,", a);
12570 printf (" i = 0x%x\n", i);
12571 }
12572 SYNTAX("racl #%1, %0");
12573#line 1113 "rx-decode.opc"
12574 ID(racl); SC(i+1); DR(a+32); F_____;
12575
12576 }
c7927a3c 12577 break;
4ce8c66d
YS		 12578 case 0x40:
12579 {
12580 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
12581#line 1116 "rx-decode.opc"
12582 int a AU = (op[2] >> 7) & 0x01;
12583#line 1116 "rx-decode.opc"
12584 int i AU = (op[2] >> 4) & 0x01;
12585 if (trace)
12586 {
12587 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12588 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
12589 op[0], op[1], op[2]);
12590 printf (" a = 0x%x,", a);
12591 printf (" i = 0x%x\n", i);
12592 }
12593 SYNTAX("rdacl #%1, %0");
12594#line 1116 "rx-decode.opc"
12595 ID(rdacl); SC(i+1); DR(a+32); F_____;
12596
12597 }
c7927a3c 12598 break;
4ce8c66d 12599 default: UNSUPPORTED(); break;
c7927a3c
NC		 12600 }
12601 break;
4ce8c66d 12602 case 0x1e:
c7927a3c 12603 GETBYTE ();
4ce8c66d 12604 switch (op[2] & 0x30)
c7927a3c
NC		 12605 {
12606 case 0x00:
4ce8c66d
YS		 12607 op_semantics_98:
12608 {
12609 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
12610#line 891 "rx-decode.opc"
12611 int i AU = op[1] & 0x01;
12612#line 891 "rx-decode.opc"
12613 int a AU = (op[2] >> 7) & 0x01;
12614#line 891 "rx-decode.opc"
12615 int m AU = (op[2] >> 6) & 0x01;
12616#line 891 "rx-decode.opc"
12617 int rdst AU = op[2] & 0x0f;
12618 if (trace)
12619 {
12620 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12621 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
12622 op[0], op[1], op[2]);
12623 printf (" i = 0x%x,", i);
12624 printf (" a = 0x%x,", a);
12625 printf (" m = 0x%x,", m);
12626 printf (" rdst = 0x%x\n", rdst);
12627 }
12628 SYNTAX("mvfachi #%2, %1, %0");
12629#line 891 "rx-decode.opc"
12630 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12631
12632 }
c7927a3c 12633 break;
4ce8c66d
YS		 12634 case 0x10:
12635 op_semantics_99:
12636 {
12637 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
12638#line 897 "rx-decode.opc"
12639 int i AU = op[1] & 0x01;
12640#line 897 "rx-decode.opc"
12641 int a AU = (op[2] >> 7) & 0x01;
12642#line 897 "rx-decode.opc"
12643 int m AU = (op[2] >> 6) & 0x01;
12644#line 897 "rx-decode.opc"
12645 int rdst AU = op[2] & 0x0f;
12646 if (trace)
12647 {
12648 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12649 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
12650 op[0], op[1], op[2]);
12651 printf (" i = 0x%x,", i);
12652 printf (" a = 0x%x,", a);
12653 printf (" m = 0x%x,", m);
12654 printf (" rdst = 0x%x\n", rdst);
12655 }
12656 SYNTAX("mvfaclo #%2, %1, %0");
12657#line 897 "rx-decode.opc"
12658 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12659
12660 }
c7927a3c 12661 break;
4ce8c66d
YS		 12662 case 0x20:
12663 op_semantics_100:
12664 {
12665 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
12666#line 894 "rx-decode.opc"
12667 int i AU = op[1] & 0x01;
12668#line 894 "rx-decode.opc"
12669 int a AU = (op[2] >> 7) & 0x01;
12670#line 894 "rx-decode.opc"
12671 int m AU = (op[2] >> 6) & 0x01;
12672#line 894 "rx-decode.opc"
12673 int rdst AU = op[2] & 0x0f;
12674 if (trace)
12675 {
12676 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12677 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
12678 op[0], op[1], op[2]);
12679 printf (" i = 0x%x,", i);
12680 printf (" a = 0x%x,", a);
12681 printf (" m = 0x%x,", m);
12682 printf (" rdst = 0x%x\n", rdst);
12683 }
12684 SYNTAX("mvfacmi #%2, %1, %0");
12685#line 894 "rx-decode.opc"
12686 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12687
12688 }
c7927a3c 12689 break;
4ce8c66d
YS		 12690 case 0x30:
12691 op_semantics_101:
12692 {
12693 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
12694#line 1107 "rx-decode.opc"
12695 int i AU = op[1] & 0x01;
12696#line 1107 "rx-decode.opc"
12697 int a AU = (op[2] >> 7) & 0x01;
12698#line 1107 "rx-decode.opc"
12699 int m AU = (op[2] >> 6) & 0x01;
12700#line 1107 "rx-decode.opc"
12701 int rdst AU = op[2] & 0x0f;
12702 if (trace)
12703 {
12704 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12705 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
12706 op[0], op[1], op[2]);
12707 printf (" i = 0x%x,", i);
12708 printf (" a = 0x%x,", a);
12709 printf (" m = 0x%x,", m);
12710 printf (" rdst = 0x%x\n", rdst);
12711 }
12712 SYNTAX("mvfacgu #%2, %1, %0");
12713#line 1107 "rx-decode.opc"
12714 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12715
12716 }
c7927a3c
NC		 12717 break;
12718 }
12719 break;
4ce8c66d 12720 case 0x1f:
c7927a3c 12721 GETBYTE ();
4ce8c66d
YS		 12722 switch (op[2] & 0x30)
12723 {
12724 case 0x00:
12725 goto op_semantics_98;
c7927a3c 12726 break;
4ce8c66d
YS		 12727 case 0x10:
12728 goto op_semantics_99;
12729 break;
12730 case 0x20:
12731 goto op_semantics_100;
12732 break;
12733 case 0x30:
12734 goto op_semantics_101;
c7927a3c
NC		 12735 break;
12736 }
12737 break;
4ce8c66d 12738 case 0x20:
c7927a3c 12739 GETBYTE ();
4ce8c66d 12740 switch (op[2] & 0x00)
c7927a3c
NC		 12741 {
12742 case 0x00:
4ce8c66d
YS		 12743 op_semantics_102:
12744 {
12745 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
12746#line 369 "rx-decode.opc"
12747 int p AU = (op[1] >> 2) & 0x01;
12748#line 369 "rx-decode.opc"
12749 int sz AU = op[1] & 0x03;
12750#line 369 "rx-decode.opc"
12751 int rdst AU = (op[2] >> 4) & 0x0f;
12752#line 369 "rx-decode.opc"
12753 int rsrc AU = op[2] & 0x0f;
12754 if (trace)
12755 {
12756 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12757 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
12758 op[0], op[1], op[2]);
12759 printf (" p = 0x%x,", p);
12760 printf (" sz = 0x%x,", sz);
12761 printf (" rdst = 0x%x,", rdst);
12762 printf (" rsrc = 0x%x\n", rsrc);
12763 }
12764 SYNTAX("mov%s %1, %0");
12765#line 369 "rx-decode.opc"
12766 ID(mov); sBWL (sz); SR(rsrc); F_____;
12767 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
12768
12769 }
c7927a3c
NC		 12770 break;
12771 }
12772 break;
4ce8c66d 12773 case 0x21:
c7927a3c 12774 GETBYTE ();
4ce8c66d 12775 switch (op[2] & 0x00)
c7927a3c
NC		 12776 {
12777 case 0x00:
4ce8c66d 12778 goto op_semantics_102;
c7927a3c
NC		 12779 break;
12780 }
12781 break;
4ce8c66d 12782 case 0x22:
c7927a3c 12783 GETBYTE ();
4ce8c66d 12784 switch (op[2] & 0x00)
c7927a3c
NC		 12785 {
12786 case 0x00:
4ce8c66d 12787 goto op_semantics_102;
c7927a3c
NC		 12788 break;
12789 }
12790 break;
4ce8c66d 12791 case 0x24:
c7927a3c 12792 GETBYTE ();
4ce8c66d 12793 switch (op[2] & 0x00)
c7927a3c
NC		 12794 {
12795 case 0x00:
4ce8c66d 12796 goto op_semantics_102;
c7927a3c
NC		 12797 break;
12798 }
12799 break;
4ce8c66d 12800 case 0x25:
c7927a3c 12801 GETBYTE ();
4ce8c66d 12802 switch (op[2] & 0x00)
c7927a3c
NC		 12803 {
12804 case 0x00:
4ce8c66d 12805 goto op_semantics_102;
c7927a3c
NC		 12806 break;
12807 }
12808 break;
4ce8c66d 12809 case 0x26:
c7927a3c 12810 GETBYTE ();
4ce8c66d 12811 switch (op[2] & 0x00)
c7927a3c
NC		 12812 {
12813 case 0x00:
4ce8c66d 12814 goto op_semantics_102;
c7927a3c
NC		 12815 break;
12816 }
12817 break;
4ce8c66d 12818 case 0x27:
c7927a3c 12819 GETBYTE ();
4ce8c66d 12820 switch (op[2] & 0x00)
c7927a3c
NC		 12821 {
12822 case 0x00:
4ce8c66d
YS		 12823 {
12824 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
12825#line 1071 "rx-decode.opc"
12826 int rdst AU = (op[2] >> 4) & 0x0f;
12827#line 1071 "rx-decode.opc"
12828 int rsrc AU = op[2] & 0x0f;
12829 if (trace)
12830 {
12831 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12832 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
12833 op[0], op[1], op[2]);
12834 printf (" rdst = 0x%x,", rdst);
12835 printf (" rsrc = 0x%x\n", rsrc);
12836 }
12837 SYNTAX("movco %1, [%0]");
12838#line 1071 "rx-decode.opc"
12839 ID(movco); SR(rsrc); DR(rdst); F_____;
12840
12841 }
c7927a3c
NC		 12842 break;
12843 }
12844 break;
4ce8c66d 12845 case 0x28:
c7927a3c 12846 GETBYTE ();
4ce8c66d 12847 switch (op[2] & 0x00)
c7927a3c
NC		 12848 {
12849 case 0x00:
4ce8c66d
YS		 12850 op_semantics_103:
12851 {
12852 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
12853#line 373 "rx-decode.opc"
12854 int p AU = (op[1] >> 2) & 0x01;
12855#line 373 "rx-decode.opc"
12856 int sz AU = op[1] & 0x03;
12857#line 373 "rx-decode.opc"
12858 int rsrc AU = (op[2] >> 4) & 0x0f;
12859#line 373 "rx-decode.opc"
12860 int rdst AU = op[2] & 0x0f;
12861 if (trace)
12862 {
12863 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12864 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
12865 op[0], op[1], op[2]);
12866 printf (" p = 0x%x,", p);
12867 printf (" sz = 0x%x,", sz);
12868 printf (" rsrc = 0x%x,", rsrc);
12869 printf (" rdst = 0x%x\n", rdst);
12870 }
12871 SYNTAX("mov%s %1, %0");
12872#line 373 "rx-decode.opc"
12873 ID(mov); sBWL (sz); DR(rdst); F_____;
12874 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12875
12876 }
c7927a3c
NC		 12877 break;
12878 }
12879 break;
4ce8c66d 12880 case 0x29:
c7927a3c 12881 GETBYTE ();
4ce8c66d 12882 switch (op[2] & 0x00)
c7927a3c
NC		 12883 {
12884 case 0x00:
4ce8c66d 12885 goto op_semantics_103;
c7927a3c
NC		 12886 break;
12887 }
12888 break;
4ce8c66d 12889 case 0x2a:
c7927a3c 12890 GETBYTE ();
4ce8c66d 12891 switch (op[2] & 0x00)
c7927a3c
NC		 12892 {
12893 case 0x00:
4ce8c66d 12894 goto op_semantics_103;
c7927a3c
NC		 12895 break;
12896 }
12897 break;
4ce8c66d 12898 case 0x2c:
c7927a3c 12899 GETBYTE ();
4ce8c66d 12900 switch (op[2] & 0x00)
c7927a3c
NC		 12901 {
12902 case 0x00:
4ce8c66d 12903 goto op_semantics_103;
c7927a3c
NC		 12904 break;
12905 }
12906 break;
4ce8c66d 12907 case 0x2d:
c7927a3c 12908 GETBYTE ();
4ce8c66d 12909 switch (op[2] & 0x00)
c7927a3c
NC		 12910 {
12911 case 0x00:
4ce8c66d 12912 goto op_semantics_103;
c7927a3c
NC		 12913 break;
12914 }
12915 break;
4ce8c66d 12916 case 0x2e:
c7927a3c 12917 GETBYTE ();
4ce8c66d 12918 switch (op[2] & 0x00)
c7927a3c
NC		 12919 {
12920 case 0x00:
4ce8c66d 12921 goto op_semantics_103;
c7927a3c
NC		 12922 break;
12923 }
12924 break;
4ce8c66d 12925 case 0x2f:
c7927a3c 12926 GETBYTE ();
4ce8c66d 12927 switch (op[2] & 0x00)
c7927a3c
NC		 12928 {
12929 case 0x00:
4ce8c66d
YS		 12930 {
12931 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
12932#line 1074 "rx-decode.opc"
12933 int rsrc AU = (op[2] >> 4) & 0x0f;
12934#line 1074 "rx-decode.opc"
12935 int rdst AU = op[2] & 0x0f;
12936 if (trace)
12937 {
12938 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12939 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
12940 op[0], op[1], op[2]);
12941 printf (" rsrc = 0x%x,", rsrc);
12942 printf (" rdst = 0x%x\n", rdst);
12943 }
12944 SYNTAX("movli [%1], %0");
12945#line 1074 "rx-decode.opc"
12946 ID(movli); SR(rsrc); DR(rdst); F_____;
12947
12948 }
c7927a3c
NC		 12949 break;
12950 }
12951 break;
4ce8c66d 12952 case 0x38:
c7927a3c 12953 GETBYTE ();
4ce8c66d 12954 switch (op[2] & 0x00)
c7927a3c
NC		 12955 {
12956 case 0x00:
4ce8c66d
YS		 12957 op_semantics_104:
12958 {
12959 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
12960#line 383 "rx-decode.opc"
12961 int p AU = (op[1] >> 2) & 0x01;
12962#line 383 "rx-decode.opc"
12963 int sz AU = op[1] & 0x03;
12964#line 383 "rx-decode.opc"
12965 int rsrc AU = (op[2] >> 4) & 0x0f;
12966#line 383 "rx-decode.opc"
12967 int rdst AU = op[2] & 0x0f;
12968 if (trace)
12969 {
12970 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12971 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
12972 op[0], op[1], op[2]);
12973 printf (" p = 0x%x,", p);
12974 printf (" sz = 0x%x,", sz);
12975 printf (" rsrc = 0x%x,", rsrc);
12976 printf (" rdst = 0x%x\n", rdst);
12977 }
12978 SYNTAX("movu%s %1, %0");
12979#line 383 "rx-decode.opc"
12980 ID(mov); uBW (sz); DR(rdst); F_____;
12981 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12982
12983 /*----------------------------------------------------------------------*/
12984 /* PUSH/POP */
12985
12986 }
c7927a3c
NC		 12987 break;
12988 }
12989 break;
4ce8c66d 12990 case 0x39:
c7927a3c 12991 GETBYTE ();
4ce8c66d 12992 switch (op[2] & 0x00)
c7927a3c
NC		 12993 {
12994 case 0x00:
4ce8c66d 12995 goto op_semantics_104;
c7927a3c
NC		 12996 break;
12997 }
12998 break;
4ce8c66d 12999 case 0x3a:
c7927a3c 13000 GETBYTE ();
4ce8c66d
YS		 13001 switch (op[2] & 0x00)
13002 {
13003 case 0x00:
13004 goto op_semantics_104;
c7927a3c
NC		 13005 break;
13006 }
13007 break;
4ce8c66d 13008 case 0x3c:
c7927a3c 13009 GETBYTE ();
4ce8c66d 13010 switch (op[2] & 0x00)
c7927a3c
NC		 13011 {
13012 case 0x00:
4ce8c66d 13013 goto op_semantics_104;
c7927a3c
NC		 13014 break;
13015 }
13016 break;
4ce8c66d 13017 case 0x3d:
c7927a3c 13018 GETBYTE ();
4ce8c66d 13019 switch (op[2] & 0x00)
c7927a3c
NC		 13020 {
13021 case 0x00:
4ce8c66d 13022 goto op_semantics_104;
c7927a3c
NC		 13023 break;
13024 }
13025 break;
4ce8c66d 13026 case 0x3e:
c7927a3c 13027 GETBYTE ();
4ce8c66d 13028 switch (op[2] & 0x00)
c7927a3c
NC		 13029 {
13030 case 0x00:
4ce8c66d 13031 goto op_semantics_104;
c7927a3c 13032 break;
4ce8c66d
YS		 13033 }
13034 break;
13035 case 0x44:
13036 GETBYTE ();
13037 switch (op[2] & 0x00)
13038 {
13039 case 0x00:
13040 op_semantics_105:
13041 {
13042 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
13043#line 1095 "rx-decode.opc"
13044 int a AU = (op[1] >> 3) & 0x01;
13045#line 1095 "rx-decode.opc"
13046 int srca AU = (op[2] >> 4) & 0x0f;
13047#line 1095 "rx-decode.opc"
13048 int srcb AU = op[2] & 0x0f;
13049 if (trace)
13050 {
13051 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13052 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
13053 op[0], op[1], op[2]);
13054 printf (" a = 0x%x,", a);
13055 printf (" srca = 0x%x,", srca);
13056 printf (" srcb = 0x%x\n", srcb);
13057 }
13058 SYNTAX("msbhi %1, %2, %0");
13059#line 1095 "rx-decode.opc"
13060 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13061
13062 }
c7927a3c
NC		 13063 break;
13064 }
13065 break;
4ce8c66d 13066 case 0x45:
c7927a3c
NC		 13067 GETBYTE ();
13068 switch (op[2] & 0x00)
13069 {
13070 case 0x00:
4ce8c66d 13071 op_semantics_106:
c7927a3c 13072 {
4ce8c66d
YS		 13073 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
13074#line 1101 "rx-decode.opc"
a117b0a5 13075 int a AU = (op[1] >> 3) & 0x01;
4ce8c66d 13076#line 1101 "rx-decode.opc"
c7927a3c 13077 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 13078#line 1101 "rx-decode.opc"
c7927a3c
NC		 13079 int srcb AU = op[2] & 0x0f;
13080 if (trace)
13081 {
13082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13083 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
c7927a3c 13084 op[0], op[1], op[2]);
a117b0a5 13085 printf (" a = 0x%x,", a);
c7927a3c
NC		 13086 printf (" srca = 0x%x,", srca);
13087 printf (" srcb = 0x%x\n", srcb);
13088 }
4ce8c66d
YS		 13089 SYNTAX("msblo %1, %2, %0");
13090#line 1101 "rx-decode.opc"
13091 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 13092
c7927a3c
NC		 13093 }
13094 break;
13095 }
13096 break;
4ce8c66d 13097 case 0x46:
c7927a3c
NC		 13098 GETBYTE ();
13099 switch (op[2] & 0x00)
13100 {
13101 case 0x00:
4ce8c66d 13102 op_semantics_107:
c7927a3c 13103 {
4ce8c66d
YS		 13104 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
13105#line 1098 "rx-decode.opc"
a117b0a5 13106 int a AU = (op[1] >> 3) & 0x01;
4ce8c66d 13107#line 1098 "rx-decode.opc"
c7927a3c 13108 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 13109#line 1098 "rx-decode.opc"
c7927a3c
NC		 13110 int srcb AU = op[2] & 0x0f;
13111 if (trace)
13112 {
13113 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13114 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
c7927a3c 13115 op[0], op[1], op[2]);
a117b0a5 13116 printf (" a = 0x%x,", a);
c7927a3c
NC		 13117 printf (" srca = 0x%x,", srca);
13118 printf (" srcb = 0x%x\n", srcb);
13119 }
4ce8c66d
YS		 13120 SYNTAX("msblh %1, %2, %0");
13121#line 1098 "rx-decode.opc"
13122 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 13123
c7927a3c
NC		 13124 }
13125 break;
13126 }
13127 break;
4ce8c66d 13128 case 0x47:
c7927a3c
NC		 13129 GETBYTE ();
13130 switch (op[2] & 0x00)
13131 {
13132 case 0x00:
4ce8c66d 13133 op_semantics_108:
c7927a3c 13134 {
4ce8c66d
YS		 13135 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
13136#line 1086 "rx-decode.opc"
a117b0a5 13137 int a AU = (op[1] >> 3) & 0x01;
4ce8c66d 13138#line 1086 "rx-decode.opc"
c7927a3c 13139 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 13140#line 1086 "rx-decode.opc"
c7927a3c
NC		 13141 int srcb AU = op[2] & 0x0f;
13142 if (trace)
13143 {
13144 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13145 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
c7927a3c 13146 op[0], op[1], op[2]);
a117b0a5 13147 printf (" a = 0x%x,", a);
c7927a3c
NC		 13148 printf (" srca = 0x%x,", srca);
13149 printf (" srcb = 0x%x\n", srcb);
13150 }
4ce8c66d
YS		 13151 SYNTAX("emsba %1, %2, %0");
13152#line 1086 "rx-decode.opc"
13153 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 13154
c7927a3c
NC		 13155 }
13156 break;
13157 }
13158 break;
4ce8c66d
YS		 13159 case 0x4c:
13160 GETBYTE ();
13161 switch (op[2] & 0x00)
13162 {
13163 case 0x00:
13164 goto op_semantics_105;
13165 break;
13166 }
13167 break;
13168 case 0x4d:
13169 GETBYTE ();
13170 switch (op[2] & 0x00)
13171 {
13172 case 0x00:
13173 goto op_semantics_106;
13174 break;
13175 }
13176 break;
13177 case 0x4e:
13178 GETBYTE ();
13179 switch (op[2] & 0x00)
13180 {
13181 case 0x00:
13182 goto op_semantics_107;
13183 break;
13184 }
13185 break;
13186 case 0x4f:
13187 GETBYTE ();
13188 switch (op[2] & 0x00)
13189 {
13190 case 0x00:
13191 goto op_semantics_108;
13192 break;
13193 }
13194 break;
13195 case 0x60:
13196 GETBYTE ();
13197 switch (op[2] & 0x00)
13198 {
13199 case 0x00:
13200 {
13201 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
13202#line 754 "rx-decode.opc"
13203 int rsrc AU = (op[2] >> 4) & 0x0f;
13204#line 754 "rx-decode.opc"
13205 int rdst AU = op[2] & 0x0f;
13206 if (trace)
13207 {
13208 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13209 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
13210 op[0], op[1], op[2]);
13211 printf (" rsrc = 0x%x,", rsrc);
13212 printf (" rdst = 0x%x\n", rdst);
13213 }
13214 SYNTAX("shlr %2, %0");
13215#line 754 "rx-decode.opc"
13216 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
13217
13218 }
13219 break;
13220 }
13221 break;
13222 case 0x61:
13223 GETBYTE ();
13224 switch (op[2] & 0x00)
13225 {
13226 case 0x00:
13227 {
13228 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
13229#line 744 "rx-decode.opc"
13230 int rsrc AU = (op[2] >> 4) & 0x0f;
13231#line 744 "rx-decode.opc"
13232 int rdst AU = op[2] & 0x0f;
13233 if (trace)
13234 {
13235 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13236 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
13237 op[0], op[1], op[2]);
13238 printf (" rsrc = 0x%x,", rsrc);
13239 printf (" rdst = 0x%x\n", rdst);
13240 }
13241 SYNTAX("shar %2, %0");
13242#line 744 "rx-decode.opc"
13243 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
13244
13245 }
13246 break;
13247 }
13248 break;
13249 case 0x62:
c7927a3c
NC		 13250 GETBYTE ();
13251 switch (op[2] & 0x00)
13252 {
13253 case 0x00:
13254 {
4ce8c66d
YS		 13255 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
13256#line 734 "rx-decode.opc"
13257 int rsrc AU = (op[2] >> 4) & 0x0f;
13258#line 734 "rx-decode.opc"
13259 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13260 if (trace)
13261 {
13262 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13263 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
c7927a3c 13264 op[0], op[1], op[2]);
4ce8c66d
YS		 13265 printf (" rsrc = 0x%x,", rsrc);
13266 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13267 }
4ce8c66d
YS		 13268 SYNTAX("shll %2, %0");
13269#line 734 "rx-decode.opc"
13270 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
43e65147 13271
c7927a3c
NC		 13272 }
13273 break;
13274 }
13275 break;
4ce8c66d 13276 case 0x64:
c7927a3c 13277 GETBYTE ();
a117b0a5 13278 switch (op[2] & 0x00)
c7927a3c
NC		 13279 {
13280 case 0x00:
13281 {
4ce8c66d
YS		 13282 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
13283#line 778 "rx-decode.opc"
13284 int rsrc AU = (op[2] >> 4) & 0x0f;
13285#line 778 "rx-decode.opc"
13286 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13287 if (trace)
13288 {
13289 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13290 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
c7927a3c 13291 op[0], op[1], op[2]);
4ce8c66d
YS		 13292 printf (" rsrc = 0x%x,", rsrc);
13293 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13294 }
4ce8c66d
YS		 13295 SYNTAX("rotr %1, %0");
13296#line 778 "rx-decode.opc"
13297 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
43e65147 13298
c7927a3c
NC		 13299 }
13300 break;
c7927a3c
NC		 13301 }
13302 break;
4ce8c66d 13303 case 0x65:
c7927a3c 13304 GETBYTE ();
a117b0a5 13305 switch (op[2] & 0x00)
c7927a3c
NC		 13306 {
13307 case 0x00:
13308 {
4ce8c66d
YS		 13309 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
13310#line 781 "rx-decode.opc"
13311 int rsrc AU = (op[2] >> 4) & 0x0f;
13312#line 781 "rx-decode.opc"
13313 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13314 if (trace)
13315 {
13316 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13317 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
c7927a3c 13318 op[0], op[1], op[2]);
4ce8c66d
YS		 13319 printf (" rsrc = 0x%x,", rsrc);
13320 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13321 }
4ce8c66d
YS		 13322 SYNTAX("revw %1, %0");
13323#line 781 "rx-decode.opc"
13324 ID(revw); SR(rsrc); DR(rdst);
43e65147 13325
c7927a3c
NC		 13326 }
13327 break;
c7927a3c
NC		 13328 }
13329 break;
4ce8c66d 13330 case 0x66:
c7927a3c 13331 GETBYTE ();
a117b0a5 13332 switch (op[2] & 0x00)
c7927a3c
NC		 13333 {
13334 case 0x00:
13335 {
4ce8c66d
YS		 13336 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
13337#line 772 "rx-decode.opc"
13338 int rsrc AU = (op[2] >> 4) & 0x0f;
13339#line 772 "rx-decode.opc"
13340 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13341 if (trace)
13342 {
13343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13344 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
c7927a3c 13345 op[0], op[1], op[2]);
4ce8c66d
YS		 13346 printf (" rsrc = 0x%x,", rsrc);
13347 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13348 }
4ce8c66d
YS		 13349 SYNTAX("rotl %1, %0");
13350#line 772 "rx-decode.opc"
13351 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
43e65147 13352
c7927a3c
NC		 13353 }
13354 break;
c7927a3c
NC		 13355 }
13356 break;
4ce8c66d 13357 case 0x67:
c7927a3c
NC		 13358 GETBYTE ();
13359 switch (op[2] & 0x00)
13360 {
13361 case 0x00:
c7927a3c 13362 {
4ce8c66d
YS		 13363 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
13364#line 784 "rx-decode.opc"
13365 int rsrc AU = (op[2] >> 4) & 0x0f;
13366#line 784 "rx-decode.opc"
13367 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13368 if (trace)
13369 {
13370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13371 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
c7927a3c 13372 op[0], op[1], op[2]);
4ce8c66d
YS		 13373 printf (" rsrc = 0x%x,", rsrc);
13374 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13375 }
4ce8c66d
YS		 13376 SYNTAX("revl %1, %0");
13377#line 784 "rx-decode.opc"
13378 ID(revl); SR(rsrc); DR(rdst);
13379
13380 /*----------------------------------------------------------------------*/
13381 /* BRANCH */
43e65147 13382
c7927a3c
NC		 13383 }
13384 break;
13385 }
13386 break;
4ce8c66d 13387 case 0x68:
c7927a3c
NC		 13388 GETBYTE ();
13389 switch (op[2] & 0x00)
13390 {
13391 case 0x00:
4ce8c66d
YS		 13392 op_semantics_109:
13393 {
13394 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
13395#line 1035 "rx-decode.opc"
13396 int c AU = op[1] & 0x01;
13397#line 1035 "rx-decode.opc"
13398 int rsrc AU = (op[2] >> 4) & 0x0f;
13399#line 1035 "rx-decode.opc"
13400 int rdst AU = op[2] & 0x0f;
13401 if (trace)
13402 {
13403 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13404 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
13405 op[0], op[1], op[2]);
13406 printf (" c = 0x%x,", c);
13407 printf (" rsrc = 0x%x,", rsrc);
13408 printf (" rdst = 0x%x\n", rdst);
13409 }
13410 SYNTAX("mvtc %1, %0");
13411#line 1035 "rx-decode.opc"
13412 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
13413
13414 }
c7927a3c
NC		 13415 break;
13416 }
13417 break;
4ce8c66d 13418 case 0x69:
c7927a3c
NC		 13419 GETBYTE ();
13420 switch (op[2] & 0x00)
13421 {
13422 case 0x00:
4ce8c66d 13423 goto op_semantics_109;
c7927a3c
NC		 13424 break;
13425 }
13426 break;
4ce8c66d 13427 case 0x6a:
c7927a3c
NC		 13428 GETBYTE ();
13429 switch (op[2] & 0x00)
13430 {
13431 case 0x00:
4ce8c66d
YS		 13432 op_semantics_110:
13433 {
13434 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
13435#line 1038 "rx-decode.opc"
13436 int s AU = op[1] & 0x01;
13437#line 1038 "rx-decode.opc"
13438 int rsrc AU = (op[2] >> 4) & 0x0f;
13439#line 1038 "rx-decode.opc"
13440 int rdst AU = op[2] & 0x0f;
13441 if (trace)
13442 {
13443 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13444 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
13445 op[0], op[1], op[2]);
13446 printf (" s = 0x%x,", s);
13447 printf (" rsrc = 0x%x,", rsrc);
13448 printf (" rdst = 0x%x\n", rdst);
13449 }
13450 SYNTAX("mvfc %1, %0");
13451#line 1038 "rx-decode.opc"
13452 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
13453
13454 /*----------------------------------------------------------------------*/
13455 /* INTERRUPTS */
13456
13457 }
c7927a3c
NC		 13458 break;
13459 }
13460 break;
4ce8c66d 13461 case 0x6b:
c7927a3c
NC		 13462 GETBYTE ();
13463 switch (op[2] & 0x00)
13464 {
13465 case 0x00:
4ce8c66d 13466 goto op_semantics_110;
c7927a3c
NC		 13467 break;
13468 }
13469 break;
4ce8c66d 13470 case 0x6c:
c7927a3c
NC		 13471 GETBYTE ();
13472 switch (op[2] & 0x00)
13473 {
13474 case 0x00:
4ce8c66d
YS		 13475 op_semantics_111:
13476 {
13477 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
13478#line 775 "rx-decode.opc"
13479 int i AU = op[1] & 0x01;
13480#line 775 "rx-decode.opc"
13481 int mmmm AU = (op[2] >> 4) & 0x0f;
13482#line 775 "rx-decode.opc"
13483 int rdst AU = op[2] & 0x0f;
13484 if (trace)
13485 {
13486 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13487 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
13488 op[0], op[1], op[2]);
13489 printf (" i = 0x%x,", i);
13490 printf (" mmmm = 0x%x,", mmmm);
13491 printf (" rdst = 0x%x\n", rdst);
13492 }
13493 SYNTAX("rotr #%1, %0");
13494#line 775 "rx-decode.opc"
13495 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
13496
13497 }
c7927a3c
NC		 13498 break;
13499 }
13500 break;
4ce8c66d 13501 case 0x6d:
c7927a3c
NC		 13502 GETBYTE ();
13503 switch (op[2] & 0x00)
13504 {
13505 case 0x00:
4ce8c66d 13506 goto op_semantics_111;
c7927a3c
NC		 13507 break;
13508 }
13509 break;
4ce8c66d 13510 case 0x6e:
c7927a3c
NC		 13511 GETBYTE ();
13512 switch (op[2] & 0x00)
13513 {
13514 case 0x00:
4ce8c66d
YS		 13515 op_semantics_112:
13516 {
13517 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
13518#line 769 "rx-decode.opc"
13519 int i AU = op[1] & 0x01;
13520#line 769 "rx-decode.opc"
13521 int mmmm AU = (op[2] >> 4) & 0x0f;
13522#line 769 "rx-decode.opc"
13523 int rdst AU = op[2] & 0x0f;
13524 if (trace)
13525 {
13526 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13527 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
13528 op[0], op[1], op[2]);
13529 printf (" i = 0x%x,", i);
13530 printf (" mmmm = 0x%x,", mmmm);
13531 printf (" rdst = 0x%x\n", rdst);
13532 }
13533 SYNTAX("rotl #%1, %0");
13534#line 769 "rx-decode.opc"
13535 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
13536
13537 }
c7927a3c
NC		 13538 break;
13539 }
13540 break;
4ce8c66d 13541 case 0x6f:
c7927a3c
NC		 13542 GETBYTE ();
13543 switch (op[2] & 0x00)
13544 {
13545 case 0x00:
4ce8c66d 13546 goto op_semantics_112;
c7927a3c
NC		 13547 break;
13548 }
13549 break;
4ce8c66d 13550 case 0x70:
c7927a3c 13551 GETBYTE ();
4ce8c66d 13552 switch (op[2] & 0xf0)
c7927a3c 13553 {
4ce8c66d
YS		 13554 case 0x20:
13555 op_semantics_113:
a117b0a5 13556 {
4ce8c66d
YS		 13557 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
13558#line 513 "rx-decode.opc"
13559 int im AU = (op[1] >> 2) & 0x03;
13560#line 513 "rx-decode.opc"
13561 int rdst AU = op[2] & 0x0f;
a117b0a5
YS		 13562 if (trace)
13563 {
13564 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13565 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
a117b0a5 13566 op[0], op[1], op[2]);
4ce8c66d
YS		 13567 printf (" im = 0x%x,", im);
13568 printf (" rdst = 0x%x\n", rdst);
a117b0a5 13569 }
4ce8c66d
YS		 13570 SYNTAX("adc #%1, %0");
13571#line 513 "rx-decode.opc"
13572 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
a117b0a5
YS		 13573
13574 }
c7927a3c 13575 break;
4ce8c66d
YS		 13576 case 0x40:
13577 op_semantics_114:
a117b0a5 13578 {
4ce8c66d
YS		 13579 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
13580#line 595 "rx-decode.opc"
13581 int im AU = (op[1] >> 2) & 0x03;
13582#line 595 "rx-decode.opc"
13583 int rdst AU = op[2] & 0x0f;
a117b0a5
YS		 13584 if (trace)
13585 {
13586 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13587 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
a117b0a5 13588 op[0], op[1], op[2]);
4ce8c66d
YS		 13589 printf (" im = 0x%x,", im);
13590 printf (" rdst = 0x%x\n", rdst);
a117b0a5 13591 }
4ce8c66d
YS		 13592 SYNTAX("max #%1, %0");
13593#line 595 "rx-decode.opc"
13594 int val = IMMex (im);
13595 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
13596 {
13597 ID (nop7);
13598 SYNTAX("nop\t; max\t#0x80000000, r0");
13599 }
13600 else
13601 {
13602 ID(max);
13603 }
13604 DR(rdst); SC(val);
a117b0a5
YS		 13605
13606 }
c7927a3c 13607 break;
4ce8c66d
YS		 13608 case 0x50:
13609 op_semantics_115:
a117b0a5 13610 {
4ce8c66d
YS		 13611 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
13612#line 625 "rx-decode.opc"
13613 int im AU = (op[1] >> 2) & 0x03;
13614#line 625 "rx-decode.opc"
a117b0a5
YS		 13615 int rdst AU = op[2] & 0x0f;
13616 if (trace)
13617 {
13618 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13619 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
a117b0a5 13620 op[0], op[1], op[2]);
4ce8c66d 13621 printf (" im = 0x%x,", im);
a117b0a5
YS		 13622 printf (" rdst = 0x%x\n", rdst);
13623 }
4ce8c66d
YS		 13624 SYNTAX("min #%1, %0");
13625#line 625 "rx-decode.opc"
13626 ID(min); DR(rdst); SC(IMMex(im));
a117b0a5
YS		 13627
13628 }
c7927a3c 13629 break;
4ce8c66d
YS		 13630 case 0x60:
13631 op_semantics_116:
c7927a3c 13632 {
4ce8c66d
YS		 13633 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
13634#line 683 "rx-decode.opc"
13635 int im AU = (op[1] >> 2) & 0x03;
13636#line 683 "rx-decode.opc"
13637 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13638 if (trace)
13639 {
13640 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13641 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
c7927a3c 13642 op[0], op[1], op[2]);
4ce8c66d
YS		 13643 printf (" im = 0x%x,", im);
13644 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13645 }
4ce8c66d
YS		 13646 SYNTAX("emul #%1, %0");
13647#line 683 "rx-decode.opc"
13648 ID(emul); DR(rdst); SC(IMMex(im));
43e65147 13649
c7927a3c
NC		 13650 }
13651 break;
4ce8c66d
YS		 13652 case 0x70:
13653 op_semantics_117:
a117b0a5 13654 {
4ce8c66d
YS		 13655 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
13656#line 695 "rx-decode.opc"
13657 int im AU = (op[1] >> 2) & 0x03;
13658#line 695 "rx-decode.opc"
13659 int rdst AU = op[2] & 0x0f;
a117b0a5
YS		 13660 if (trace)
13661 {
13662 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13663 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
a117b0a5 13664 op[0], op[1], op[2]);
4ce8c66d
YS		 13665 printf (" im = 0x%x,", im);
13666 printf (" rdst = 0x%x\n", rdst);
a117b0a5 13667 }
4ce8c66d
YS		 13668 SYNTAX("emulu #%1, %0");
13669#line 695 "rx-decode.opc"
13670 ID(emulu); DR(rdst); SC(IMMex(im));
a117b0a5
YS		 13671
13672 }
c7927a3c 13673 break;
4ce8c66d
YS		 13674 case 0x80:
13675 op_semantics_118:
c7927a3c 13676 {
4ce8c66d
YS		 13677 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
13678#line 707 "rx-decode.opc"
13679 int im AU = (op[1] >> 2) & 0x03;
13680#line 707 "rx-decode.opc"
13681 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13682 if (trace)
13683 {
13684 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13685 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
c7927a3c 13686 op[0], op[1], op[2]);
4ce8c66d
YS		 13687 printf (" im = 0x%x,", im);
13688 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13689 }
4ce8c66d
YS		 13690 SYNTAX("div #%1, %0");
13691#line 707 "rx-decode.opc"
13692 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
43e65147 13693
c7927a3c
NC		 13694 }
13695 break;
4ce8c66d
YS		 13696 case 0x90:
13697 op_semantics_119:
c7927a3c 13698 {
4ce8c66d
YS		 13699 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
13700#line 719 "rx-decode.opc"
13701 int im AU = (op[1] >> 2) & 0x03;
13702#line 719 "rx-decode.opc"
13703 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13704 if (trace)
13705 {
13706 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13707 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
c7927a3c 13708 op[0], op[1], op[2]);
4ce8c66d
YS		 13709 printf (" im = 0x%x,", im);
13710 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13711 }
4ce8c66d
YS		 13712 SYNTAX("divu #%1, %0");
13713#line 719 "rx-decode.opc"
13714 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
43e65147 13715
c7927a3c
NC		 13716 }
13717 break;
4ce8c66d
YS		 13718 case 0xc0:
13719 op_semantics_120:
c7927a3c 13720 {
4ce8c66d
YS		 13721 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
13722#line 492 "rx-decode.opc"
13723 int im AU = (op[1] >> 2) & 0x03;
13724#line 492 "rx-decode.opc"
c7927a3c
NC		 13725 int rdst AU = op[2] & 0x0f;
13726 if (trace)
13727 {
13728 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13729 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
c7927a3c 13730 op[0], op[1], op[2]);
4ce8c66d 13731 printf (" im = 0x%x,", im);
c7927a3c
NC		 13732 printf (" rdst = 0x%x\n", rdst);
13733 }
4ce8c66d
YS		 13734 SYNTAX("tst #%1, %2");
13735#line 492 "rx-decode.opc"
13736 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
43e65147 13737
c7927a3c
NC		 13738 }
13739 break;
4ce8c66d
YS		 13740 case 0xd0:
13741 op_semantics_121:
c7927a3c 13742 {
4ce8c66d
YS		 13743 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
13744#line 471 "rx-decode.opc"
13745 int im AU = (op[1] >> 2) & 0x03;
13746#line 471 "rx-decode.opc"
c7927a3c
NC		 13747 int rdst AU = op[2] & 0x0f;
13748 if (trace)
13749 {
13750 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13751 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
c7927a3c 13752 op[0], op[1], op[2]);
4ce8c66d 13753 printf (" im = 0x%x,", im);
c7927a3c
NC		 13754 printf (" rdst = 0x%x\n", rdst);
13755 }
4ce8c66d
YS		 13756 SYNTAX("xor #%1, %0");
13757#line 471 "rx-decode.opc"
13758 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
43e65147 13759
c7927a3c
NC		 13760 }
13761 break;
4ce8c66d
YS		 13762 case 0xe0:
13763 op_semantics_122:
c7927a3c 13764 {
4ce8c66d
YS		 13765 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
13766#line 417 "rx-decode.opc"
13767 int im AU = (op[1] >> 2) & 0x03;
13768#line 417 "rx-decode.opc"
c7927a3c
NC		 13769 int rdst AU = op[2] & 0x0f;
13770 if (trace)
13771 {
13772 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13773 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
c7927a3c 13774 op[0], op[1], op[2]);
4ce8c66d 13775 printf (" im = 0x%x,", im);
c7927a3c
NC		 13776 printf (" rdst = 0x%x\n", rdst);
13777 }
4ce8c66d
YS		 13778 SYNTAX("stz #%1, %0");
13779#line 417 "rx-decode.opc"
13780 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
43e65147 13781
c7927a3c
NC		 13782 }
13783 break;
4ce8c66d
YS		 13784 case 0xf0:
13785 op_semantics_123:
c7927a3c 13786 {
4ce8c66d
YS		 13787 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
13788#line 420 "rx-decode.opc"
13789 int im AU = (op[1] >> 2) & 0x03;
13790#line 420 "rx-decode.opc"
c7927a3c
NC		 13791 int rdst AU = op[2] & 0x0f;
13792 if (trace)
13793 {
13794 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13795 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
c7927a3c 13796 op[0], op[1], op[2]);
4ce8c66d 13797 printf (" im = 0x%x,", im);
c7927a3c
NC		 13798 printf (" rdst = 0x%x\n", rdst);
13799 }
4ce8c66d
YS		 13800 SYNTAX("stnz #%1, %0");
13801#line 420 "rx-decode.opc"
13802 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
13803
13804 /*----------------------------------------------------------------------*/
13805 /* RTSD */
43e65147 13806
c7927a3c
NC		 13807 }
13808 break;
4ce8c66d 13809 default: UNSUPPORTED(); break;
c7927a3c
NC		 13810 }
13811 break;
4ce8c66d 13812 case 0x72:
c7927a3c 13813 GETBYTE ();
4ce8c66d 13814 switch (op[2] & 0xf0)
c7927a3c
NC		 13815 {
13816 case 0x00:
4ce8c66d
YS		 13817 {
13818 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
13819#line 927 "rx-decode.opc"
13820 int rdst AU = op[2] & 0x0f;
13821 if (trace)
13822 {
13823 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13824 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
13825 op[0], op[1], op[2]);
13826 printf (" rdst = 0x%x\n", rdst);
13827 }
13828 SYNTAX("fsub #%1, %0");
13829#line 927 "rx-decode.opc"
13830 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
13831
13832 }
a117b0a5
YS		 13833 break;
13834 case 0x10:
c7927a3c 13835 {
4ce8c66d
YS		 13836 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
13837#line 921 "rx-decode.opc"
13838 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 13839 if (trace)
13840 {
13841 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13842 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
c7927a3c 13843 op[0], op[1], op[2]);
4ce8c66d 13844 printf (" rdst = 0x%x\n", rdst);
c7927a3c 13845 }
4ce8c66d
YS		 13846 SYNTAX("fcmp #%1, %0");
13847#line 921 "rx-decode.opc"
13848 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
43e65147 13849
c7927a3c
NC		 13850 }
13851 break;
4ce8c66d 13852 case 0x20:
c7927a3c 13853 {
4ce8c66d
YS		 13854 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
13855#line 915 "rx-decode.opc"
13856 int rdst AU = op[2] & 0x0f;
a117b0a5
YS		 13857 if (trace)
13858 {
13859 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13860 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
a117b0a5 13861 op[0], op[1], op[2]);
4ce8c66d 13862 printf (" rdst = 0x%x\n", rdst);
a117b0a5 13863 }
4ce8c66d
YS		 13864 SYNTAX("fadd #%1, %0");
13865#line 915 "rx-decode.opc"
13866 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
a117b0a5
YS		 13867
13868 }
13869 break;
4ce8c66d 13870 case 0x30:
a117b0a5 13871 {
4ce8c66d
YS		 13872 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
13873#line 936 "rx-decode.opc"
c7927a3c
NC		 13874 int rdst AU = op[2] & 0x0f;
13875 if (trace)
13876 {
13877 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13878 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
c7927a3c 13879 op[0], op[1], op[2]);
c7927a3c
NC		 13880 printf (" rdst = 0x%x\n", rdst);
13881 }
4ce8c66d
YS		 13882 SYNTAX("fmul #%1, %0");
13883#line 936 "rx-decode.opc"
13884 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
43e65147 13885
c7927a3c
NC		 13886 }
13887 break;
4ce8c66d 13888 case 0x40:
c7927a3c 13889 {
4ce8c66d
YS		 13890 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
13891#line 942 "rx-decode.opc"
c7927a3c
NC		 13892 int rdst AU = op[2] & 0x0f;
13893 if (trace)
13894 {
13895 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13896 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
c7927a3c 13897 op[0], op[1], op[2]);
c7927a3c
NC		 13898 printf (" rdst = 0x%x\n", rdst);
13899 }
4ce8c66d
YS		 13900 SYNTAX("fdiv #%1, %0");
13901#line 942 "rx-decode.opc"
13902 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
43e65147 13903
c7927a3c
NC		 13904 }
13905 break;
4ce8c66d 13906 default: UNSUPPORTED(); break;
a117b0a5
YS		 13907 }
13908 break;
4ce8c66d 13909 case 0x73:
a117b0a5 13910 GETBYTE ();
4ce8c66d 13911 switch (op[2] & 0xe0)
a117b0a5
YS		 13912 {
13913 case 0x00:
4ce8c66d 13914 op_semantics_124:
c7927a3c 13915 {
4ce8c66d
YS		 13916 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
13917#line 1032 "rx-decode.opc"
13918 int im AU = (op[1] >> 2) & 0x03;
13919#line 1032 "rx-decode.opc"
13920 int crdst AU = op[2] & 0x1f;
c7927a3c
NC		 13921 if (trace)
13922 {
13923 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 13924 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
c7927a3c 13925 op[0], op[1], op[2]);
4ce8c66d
YS		 13926 printf (" im = 0x%x,", im);
13927 printf (" crdst = 0x%x\n", crdst);
c7927a3c 13928 }
4ce8c66d
YS		 13929 SYNTAX("mvtc #%1, %0");
13930#line 1032 "rx-decode.opc"
13931 ID(mov); SC(IMMex(im)); DR(crdst + 16);
a117b0a5 13932
c7927a3c
NC		 13933 }
13934 break;
4ce8c66d 13935 default: UNSUPPORTED(); break;
a117b0a5
YS		 13936 }
13937 break;
4ce8c66d 13938 case 0x74:
a117b0a5 13939 GETBYTE ();
4ce8c66d 13940 switch (op[2] & 0xf0)
a117b0a5 13941 {
4ce8c66d
YS		 13942 case 0x20:
13943 goto op_semantics_113;
a117b0a5 13944 break;
4ce8c66d
YS		 13945 case 0x40:
13946 goto op_semantics_114;
a117b0a5 13947 break;
4ce8c66d
YS		 13948 case 0x50:
13949 goto op_semantics_115;
a117b0a5 13950 break;
4ce8c66d
YS		 13951 case 0x60:
13952 goto op_semantics_116;
a117b0a5 13953 break;
4ce8c66d
YS		 13954 case 0x70:
13955 goto op_semantics_117;
13956 break;
13957 case 0x80:
13958 goto op_semantics_118;
13959 break;
13960 case 0x90:
13961 goto op_semantics_119;
13962 break;
13963 case 0xc0:
13964 goto op_semantics_120;
13965 break;
13966 case 0xd0:
13967 goto op_semantics_121;
13968 break;
13969 case 0xe0:
13970 goto op_semantics_122;
a117b0a5 13971 break;
4ce8c66d
YS		 13972 case 0xf0:
13973 goto op_semantics_123;
13974 break;
13975 default: UNSUPPORTED(); break;
a117b0a5
YS		 13976 }
13977 break;
4ce8c66d 13978 case 0x75:
a117b0a5 13979 GETBYTE ();
4ce8c66d 13980 switch (op[2] & 0xff)
a117b0a5 13981 {
4ce8c66d
YS		 13982 case 0x80:
13983 GETBYTE ();
13984 switch (op[3] & 0x0f)
c7927a3c 13985 {
4ce8c66d
YS		 13986 case 0x00:
13987 op_semantics_125:
13988 {
13989 /** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */
13990#line 1176 "rx-decode.opc"
13991 int rdst AU = op[2] & 0x0f;
13992#line 1176 "rx-decode.opc"
13993 int rsrc AU = (op[3] >> 4) & 0x0f;
13994 if (trace)
13995 {
13996 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
13997 "/** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */",
13998 op[0], op[1], op[2], op[3]);
13999 printf (" rdst = 0x%x,", rdst);
14000 printf (" rsrc = 0x%x\n", rsrc);
14001 }
14002 SYNTAX("dmov.l %1, %0");
14003#line 1176 "rx-decode.opc"
14004 ID(dmov); DR(rdst); SDRL(rsrc); F_____;
14005
14006 }
14007 break;
14008 case 0x02:
14009 op_semantics_126:
14010 {
14011 /** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */
14012#line 1173 "rx-decode.opc"
14013 int rdst AU = op[2] & 0x0f;
14014#line 1173 "rx-decode.opc"
14015 int rsrc AU = (op[3] >> 4) & 0x0f;
14016 if (trace)
14017 {
14018 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14019 "/** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */",
14020 op[0], op[1], op[2], op[3]);
14021 printf (" rdst = 0x%x,", rdst);
14022 printf (" rsrc = 0x%x\n", rsrc);
14023 }
14024 SYNTAX("dmov.l %1, %0");
14025#line 1173 "rx-decode.opc"
14026 ID(dmov); DR(rdst); SDRH(rsrc); F_____;
43e65147 14027
4ce8c66d
YS		 14028 }
14029 break;
14030 case 0x04:
14031 op_semantics_127:
14032 {
14033 /** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */
14034#line 1226 "rx-decode.opc"
14035 int rdst AU = op[2] & 0x0f;
14036#line 1226 "rx-decode.opc"
14037 int rsrc AU = (op[3] >> 4) & 0x0f;
14038 if (trace)
14039 {
14040 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14041 "/** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */",
14042 op[0], op[1], op[2], op[3]);
14043 printf (" rdst = 0x%x,", rdst);
14044 printf (" rsrc = 0x%x\n", rsrc);
14045 }
14046 SYNTAX("mvfdc %1, %0");
14047#line 1226 "rx-decode.opc"
14048 ID(mvfdc); DR(rdst); SCR(rsrc); F_____;
14049
14050 }
14051 break;
14052 default: UNSUPPORTED(); break;
c7927a3c
NC		 14053 }
14054 break;
4ce8c66d
YS		 14055 case 0x81:
14056 GETBYTE ();
14057 switch (op[3] & 0x0f)
c7927a3c 14058 {
4ce8c66d
YS		 14059 case 0x00:
14060 goto op_semantics_125;
14061 break;
14062 case 0x02:
14063 goto op_semantics_126;
14064 break;
14065 case 0x04:
14066 goto op_semantics_127;
14067 break;
14068 default: UNSUPPORTED(); break;
14069 }
14070 break;
14071 case 0x82:
14072 GETBYTE ();
14073 switch (op[3] & 0x0f)
14074 {
14075 case 0x00:
14076 goto op_semantics_125;
14077 break;
14078 case 0x02:
14079 goto op_semantics_126;
14080 break;
14081 case 0x04:
14082 goto op_semantics_127;
14083 break;
14084 default: UNSUPPORTED(); break;
14085 }
14086 break;
14087 case 0x83:
14088 GETBYTE ();
14089 switch (op[3] & 0x0f)
14090 {
14091 case 0x00:
14092 goto op_semantics_125;
14093 break;
14094 case 0x02:
14095 goto op_semantics_126;
14096 break;
14097 case 0x04:
14098 goto op_semantics_127;
14099 break;
14100 default: UNSUPPORTED(); break;
14101 }
14102 break;
14103 case 0x84:
14104 GETBYTE ();
14105 switch (op[3] & 0x0f)
14106 {
14107 case 0x00:
14108 goto op_semantics_125;
14109 break;
14110 case 0x02:
14111 goto op_semantics_126;
14112 break;
14113 case 0x04:
14114 goto op_semantics_127;
14115 break;
14116 default: UNSUPPORTED(); break;
14117 }
14118 break;
14119 case 0x85:
14120 GETBYTE ();
14121 switch (op[3] & 0x0f)
14122 {
14123 case 0x00:
14124 goto op_semantics_125;
14125 break;
14126 case 0x02:
14127 goto op_semantics_126;
14128 break;
14129 case 0x04:
14130 goto op_semantics_127;
14131 break;
14132 default: UNSUPPORTED(); break;
14133 }
14134 break;
14135 case 0x86:
14136 GETBYTE ();
14137 switch (op[3] & 0x0f)
14138 {
14139 case 0x00:
14140 goto op_semantics_125;
14141 break;
14142 case 0x02:
14143 goto op_semantics_126;
14144 break;
14145 case 0x04:
14146 goto op_semantics_127;
14147 break;
14148 default: UNSUPPORTED(); break;
14149 }
14150 break;
14151 case 0x87:
14152 GETBYTE ();
14153 switch (op[3] & 0x0f)
14154 {
14155 case 0x00:
14156 goto op_semantics_125;
14157 break;
14158 case 0x02:
14159 goto op_semantics_126;
14160 break;
14161 case 0x04:
14162 goto op_semantics_127;
14163 break;
14164 default: UNSUPPORTED(); break;
14165 }
14166 break;
14167 case 0x88:
14168 GETBYTE ();
14169 switch (op[3] & 0x0f)
14170 {
14171 case 0x00:
14172 goto op_semantics_125;
14173 break;
14174 case 0x02:
14175 goto op_semantics_126;
14176 break;
14177 case 0x04:
14178 goto op_semantics_127;
14179 break;
14180 default: UNSUPPORTED(); break;
14181 }
14182 break;
14183 case 0x89:
14184 GETBYTE ();
14185 switch (op[3] & 0x0f)
14186 {
14187 case 0x00:
14188 goto op_semantics_125;
14189 break;
14190 case 0x02:
14191 goto op_semantics_126;
14192 break;
14193 case 0x04:
14194 goto op_semantics_127;
14195 break;
14196 default: UNSUPPORTED(); break;
14197 }
14198 break;
14199 case 0x8a:
14200 GETBYTE ();
14201 switch (op[3] & 0x0f)
14202 {
14203 case 0x00:
14204 goto op_semantics_125;
14205 break;
14206 case 0x02:
14207 goto op_semantics_126;
14208 break;
14209 case 0x04:
14210 goto op_semantics_127;
14211 break;
14212 default: UNSUPPORTED(); break;
c7927a3c
NC		 14213 }
14214 break;
4ce8c66d
YS		 14215 case 0x8b:
14216 GETBYTE ();
14217 switch (op[3] & 0x0f)
c7927a3c 14218 {
4ce8c66d
YS		 14219 case 0x00:
14220 goto op_semantics_125;
14221 break;
14222 case 0x02:
14223 goto op_semantics_126;
14224 break;
14225 case 0x04:
14226 goto op_semantics_127;
14227 break;
14228 default: UNSUPPORTED(); break;
c7927a3c
NC		 14229 }
14230 break;
4ce8c66d
YS		 14231 case 0x8c:
14232 GETBYTE ();
14233 switch (op[3] & 0x0f)
c7927a3c 14234 {
4ce8c66d
YS		 14235 case 0x00:
14236 goto op_semantics_125;
14237 break;
14238 case 0x02:
14239 goto op_semantics_126;
14240 break;
14241 case 0x04:
14242 goto op_semantics_127;
14243 break;
14244 default: UNSUPPORTED(); break;
c7927a3c
NC		 14245 }
14246 break;
4ce8c66d
YS		 14247 case 0x8d:
14248 GETBYTE ();
14249 switch (op[3] & 0x0f)
14250 {
14251 case 0x00:
14252 goto op_semantics_125;
14253 break;
14254 case 0x02:
14255 goto op_semantics_126;
14256 break;
14257 case 0x04:
14258 goto op_semantics_127;
14259 break;
14260 default: UNSUPPORTED(); break;
14261 }
a117b0a5 14262 break;
4ce8c66d
YS		 14263 case 0x8e:
14264 GETBYTE ();
14265 switch (op[3] & 0x0f)
14266 {
14267 case 0x00:
14268 goto op_semantics_125;
14269 break;
14270 case 0x02:
14271 goto op_semantics_126;
14272 break;
14273 case 0x04:
14274 goto op_semantics_127;
14275 break;
14276 default: UNSUPPORTED(); break;
14277 }
a117b0a5 14278 break;
4ce8c66d
YS		 14279 case 0x8f:
14280 GETBYTE ();
14281 switch (op[3] & 0x0f)
14282 {
14283 case 0x00:
14284 goto op_semantics_125;
14285 break;
14286 case 0x02:
14287 goto op_semantics_126;
14288 break;
14289 case 0x04:
14290 goto op_semantics_127;
14291 break;
14292 default: UNSUPPORTED(); break;
14293 }
a117b0a5 14294 break;
4ce8c66d 14295 default: UNSUPPORTED(); break;
a117b0a5
YS		 14296 }
14297 break;
4ce8c66d 14298 case 0x76:
a117b0a5 14299 GETBYTE ();
4ce8c66d 14300 switch (op[2] & 0xff)
a117b0a5 14301 {
4ce8c66d
YS		 14302 case 0xc0:
14303 GETBYTE ();
14304 switch (op[3] & 0xff)
c7927a3c 14305 {
4ce8c66d
YS		 14306 case 0x00:
14307 op_semantics_128:
14308 {
14309 /** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */
14310#line 1161 "rx-decode.opc"
14311 int rsrc AU = op[2] & 0x0f;
14312 if (trace)
14313 {
14314 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14315 "/** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */",
14316 op[0], op[1], op[2], op[3]);
14317 printf (" rsrc = 0x%x\n", rsrc);
14318 }
14319 SYNTAX("save %1");
14320#line 1161 "rx-decode.opc"
14321 ID(save); SR(rsrc); F_____;
43e65147 14322
4ce8c66d
YS		 14323 }
14324 break;
14325 default: UNSUPPORTED(); break;
c7927a3c
NC		 14326 }
14327 break;
4ce8c66d
YS		 14328 case 0xc1:
14329 GETBYTE ();
14330 switch (op[3] & 0xff)
c7927a3c 14331 {
4ce8c66d
YS		 14332 case 0x00:
14333 goto op_semantics_128;
14334 break;
14335 default: UNSUPPORTED(); break;
c7927a3c
NC		 14336 }
14337 break;
4ce8c66d
YS		 14338 case 0xc2:
14339 GETBYTE ();
14340 switch (op[3] & 0xff)
c7927a3c 14341 {
4ce8c66d
YS		 14342 case 0x00:
14343 goto op_semantics_128;
14344 break;
14345 default: UNSUPPORTED(); break;
c7927a3c
NC		 14346 }
14347 break;
4ce8c66d
YS		 14348 case 0xc3:
14349 GETBYTE ();
14350 switch (op[3] & 0xff)
c7927a3c 14351 {
4ce8c66d
YS		 14352 case 0x00:
14353 goto op_semantics_128;
14354 break;
14355 default: UNSUPPORTED(); break;
c7927a3c
NC		 14356 }
14357 break;
4ce8c66d
YS		 14358 case 0xc4:
14359 GETBYTE ();
14360 switch (op[3] & 0xff)
c7927a3c 14361 {
4ce8c66d
YS		 14362 case 0x00:
14363 goto op_semantics_128;
14364 break;
14365 default: UNSUPPORTED(); break;
c7927a3c
NC		 14366 }
14367 break;
4ce8c66d
YS		 14368 case 0xc5:
14369 GETBYTE ();
14370 switch (op[3] & 0xff)
c7927a3c 14371 {
4ce8c66d
YS		 14372 case 0x00:
14373 goto op_semantics_128;
14374 break;
14375 default: UNSUPPORTED(); break;
c7927a3c
NC		 14376 }
14377 break;
4ce8c66d
YS		 14378 case 0xc6:
14379 GETBYTE ();
14380 switch (op[3] & 0xff)
c7927a3c 14381 {
4ce8c66d
YS		 14382 case 0x00:
14383 goto op_semantics_128;
14384 break;
14385 default: UNSUPPORTED(); break;
c7927a3c
NC		 14386 }
14387 break;
4ce8c66d
YS		 14388 case 0xc7:
14389 GETBYTE ();
14390 switch (op[3] & 0xff)
c7927a3c 14391 {
4ce8c66d
YS		 14392 case 0x00:
14393 goto op_semantics_128;
14394 break;
14395 default: UNSUPPORTED(); break;
c7927a3c
NC		 14396 }
14397 break;
4ce8c66d
YS		 14398 case 0xc8:
14399 GETBYTE ();
14400 switch (op[3] & 0xff)
14401 {
14402 case 0x00:
14403 goto op_semantics_128;
14404 break;
14405 default: UNSUPPORTED(); break;
14406 }
a117b0a5 14407 break;
4ce8c66d
YS		 14408 case 0xc9:
14409 GETBYTE ();
14410 switch (op[3] & 0xff)
a117b0a5 14411 {
4ce8c66d
YS		 14412 case 0x00:
14413 goto op_semantics_128;
14414 break;
14415 default: UNSUPPORTED(); break;
a117b0a5
YS		 14416 }
14417 break;
4ce8c66d
YS		 14418 case 0xca:
14419 GETBYTE ();
14420 switch (op[3] & 0xff)
14421 {
14422 case 0x00:
14423 goto op_semantics_128;
14424 break;
14425 default: UNSUPPORTED(); break;
14426 }
a117b0a5 14427 break;
4ce8c66d
YS		 14428 case 0xcb:
14429 GETBYTE ();
14430 switch (op[3] & 0xff)
a117b0a5 14431 {
4ce8c66d
YS		 14432 case 0x00:
14433 goto op_semantics_128;
14434 break;
14435 default: UNSUPPORTED(); break;
a117b0a5
YS		 14436 }
14437 break;
4ce8c66d
YS		 14438 case 0xcc:
14439 GETBYTE ();
14440 switch (op[3] & 0xff)
14441 {
14442 case 0x00:
14443 goto op_semantics_128;
14444 break;
14445 default: UNSUPPORTED(); break;
14446 }
a117b0a5 14447 break;
4ce8c66d
YS		 14448 case 0xcd:
14449 GETBYTE ();
14450 switch (op[3] & 0xff)
a117b0a5 14451 {
4ce8c66d
YS		 14452 case 0x00:
14453 goto op_semantics_128;
14454 break;
14455 default: UNSUPPORTED(); break;
a117b0a5
YS		 14456 }
14457 break;
4ce8c66d
YS		 14458 case 0xce:
14459 GETBYTE ();
14460 switch (op[3] & 0xff)
14461 {
14462 case 0x00:
14463 goto op_semantics_128;
14464 break;
14465 default: UNSUPPORTED(); break;
14466 }
a117b0a5 14467 break;
4ce8c66d
YS		 14468 case 0xcf:
14469 GETBYTE ();
14470 switch (op[3] & 0xff)
a117b0a5 14471 {
4ce8c66d
YS		 14472 case 0x00:
14473 goto op_semantics_128;
14474 break;
14475 default: UNSUPPORTED(); break;
a117b0a5
YS		 14476 }
14477 break;
4ce8c66d
YS		 14478 case 0xd0:
14479 GETBYTE ();
14480 switch (op[3] & 0xff)
a117b0a5 14481 {
4ce8c66d
YS		 14482 case 0x00:
14483 op_semantics_129:
14484 {
14485 /** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */
14486#line 1155 "rx-decode.opc"
14487 int rsrc AU = op[2] & 0x0f;
14488 if (trace)
14489 {
14490 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14491 "/** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */",
14492 op[0], op[1], op[2], op[3]);
14493 printf (" rsrc = 0x%x\n", rsrc);
14494 }
14495 SYNTAX("rstr %1");
14496#line 1155 "rx-decode.opc"
14497 ID(rstr); SR(rsrc); F_____;
a117b0a5 14498
4ce8c66d
YS		 14499 }
14500 break;
14501 default: UNSUPPORTED(); break;
a117b0a5
YS		 14502 }
14503 break;
4ce8c66d
YS		 14504 case 0xd1:
14505 GETBYTE ();
14506 switch (op[3] & 0xff)
a117b0a5 14507 {
4ce8c66d
YS		 14508 case 0x00:
14509 goto op_semantics_129;
14510 break;
14511 default: UNSUPPORTED(); break;
a117b0a5
YS		 14512 }
14513 break;
4ce8c66d
YS		 14514 case 0xd2:
14515 GETBYTE ();
14516 switch (op[3] & 0xff)
a117b0a5 14517 {
4ce8c66d
YS		 14518 case 0x00:
14519 goto op_semantics_129;
14520 break;
14521 default: UNSUPPORTED(); break;
a117b0a5
YS		 14522 }
14523 break;
4ce8c66d
YS		 14524 case 0xd3:
14525 GETBYTE ();
14526 switch (op[3] & 0xff)
a117b0a5 14527 {
4ce8c66d
YS		 14528 case 0x00:
14529 goto op_semantics_129;
14530 break;
14531 default: UNSUPPORTED(); break;
a117b0a5
YS		 14532 }
14533 break;
4ce8c66d
YS		 14534 case 0xd4:
14535 GETBYTE ();
14536 switch (op[3] & 0xff)
a117b0a5 14537 {
4ce8c66d
YS		 14538 case 0x00:
14539 goto op_semantics_129;
14540 break;
14541 default: UNSUPPORTED(); break;
a117b0a5
YS		 14542 }
14543 break;
4ce8c66d
YS		 14544 case 0xd5:
14545 GETBYTE ();
14546 switch (op[3] & 0xff)
a117b0a5 14547 {
4ce8c66d
YS		 14548 case 0x00:
14549 goto op_semantics_129;
14550 break;
14551 default: UNSUPPORTED(); break;
a117b0a5
YS		 14552 }
14553 break;
4ce8c66d
YS		 14554 case 0xd6:
14555 GETBYTE ();
14556 switch (op[3] & 0xff)
a117b0a5 14557 {
4ce8c66d
YS		 14558 case 0x00:
14559 goto op_semantics_129;
14560 break;
14561 default: UNSUPPORTED(); break;
a117b0a5
YS		 14562 }
14563 break;
4ce8c66d
YS		 14564 case 0xd7:
14565 GETBYTE ();
14566 switch (op[3] & 0xff)
a117b0a5 14567 {
4ce8c66d
YS		 14568 case 0x00:
14569 goto op_semantics_129;
14570 break;
14571 default: UNSUPPORTED(); break;
a117b0a5
YS		 14572 }
14573 break;
4ce8c66d
YS		 14574 case 0xd8:
14575 GETBYTE ();
14576 switch (op[3] & 0xff)
a117b0a5 14577 {
4ce8c66d
YS		 14578 case 0x00:
14579 goto op_semantics_129;
14580 break;
14581 default: UNSUPPORTED(); break;
a117b0a5
YS		 14582 }
14583 break;
4ce8c66d
YS		 14584 case 0xd9:
14585 GETBYTE ();
14586 switch (op[3] & 0xff)
a117b0a5 14587 {
4ce8c66d
YS		 14588 case 0x00:
14589 goto op_semantics_129;
14590 break;
14591 default: UNSUPPORTED(); break;
a117b0a5
YS		 14592 }
14593 break;
4ce8c66d
YS		 14594 case 0xda:
14595 GETBYTE ();
14596 switch (op[3] & 0xff)
a117b0a5 14597 {
4ce8c66d
YS		 14598 case 0x00:
14599 goto op_semantics_129;
14600 break;
14601 default: UNSUPPORTED(); break;
14602 }
14603 break;
14604 case 0xdb:
14605 GETBYTE ();
14606 switch (op[3] & 0xff)
14607 {
14608 case 0x00:
14609 goto op_semantics_129;
14610 break;
14611 default: UNSUPPORTED(); break;
a117b0a5
YS		 14612 }
14613 break;
4ce8c66d
YS		 14614 case 0xdc:
14615 GETBYTE ();
14616 switch (op[3] & 0xff)
a117b0a5 14617 {
4ce8c66d
YS		 14618 case 0x00:
14619 goto op_semantics_129;
14620 break;
14621 default: UNSUPPORTED(); break;
a117b0a5
YS		 14622 }
14623 break;
4ce8c66d
YS		 14624 case 0xdd:
14625 GETBYTE ();
14626 switch (op[3] & 0xff)
a117b0a5 14627 {
4ce8c66d
YS		 14628 case 0x00:
14629 goto op_semantics_129;
14630 break;
14631 default: UNSUPPORTED(); break;
a117b0a5
YS		 14632 }
14633 break;
4ce8c66d
YS		 14634 case 0xde:
14635 GETBYTE ();
14636 switch (op[3] & 0xff)
a117b0a5 14637 {
4ce8c66d
YS		 14638 case 0x00:
14639 goto op_semantics_129;
14640 break;
14641 default: UNSUPPORTED(); break;
14642 }
14643 break;
14644 case 0xdf:
14645 GETBYTE ();
14646 switch (op[3] & 0xff)
14647 {
14648 case 0x00:
14649 goto op_semantics_129;
14650 break;
14651 default: UNSUPPORTED(); break;
14652 }
14653 break;
14654 case 0xe0:
14655 {
14656 /** 1111 1101 0111 0110 1110 0000 save #%1 */
a117b0a5
YS		 14657 if (trace)
14658 {
14659 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 14660 "/** 1111 1101 0111 0110 1110 0000 save #%1 */",
c7927a3c 14661 op[0], op[1], op[2]);
c7927a3c 14662 }
4ce8c66d
YS		 14663 SYNTAX("save #%1");
14664#line 1164 "rx-decode.opc"
14665 ID(save); SC(IMM(1)); F_____;
43e65147 14666
c7927a3c
NC		 14667 }
14668 break;
4ce8c66d 14669 case 0xf0:
c7927a3c 14670 {
4ce8c66d 14671 /** 1111 1101 0111 0110 1111 0000 rstr #%1 */
c7927a3c
NC		 14672 if (trace)
14673 {
14674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4ce8c66d 14675 "/** 1111 1101 0111 0110 1111 0000 rstr #%1 */",
c7927a3c 14676 op[0], op[1], op[2]);
c7927a3c 14677 }
4ce8c66d
YS		 14678 SYNTAX("rstr #%1");
14679#line 1158 "rx-decode.opc"
14680 ID(rstr); SC(IMM(1)); F_____;
43e65147 14681
c7927a3c
NC		 14682 }
14683 break;
14684 default: UNSUPPORTED(); break;
14685 }
14686 break;
4ce8c66d 14687 case 0x77:
c7927a3c 14688 GETBYTE ();
4ce8c66d 14689 switch (op[2] & 0xff)
c7927a3c
NC		 14690 {
14691 case 0x00:
4ce8c66d
YS		 14692 case 0x01:
14693 case 0x02:
14694 case 0x03:
14695 case 0x04:
14696 case 0x05:
14697 case 0x06:
14698 case 0x07:
14699 case 0x08:
14700 case 0x09:
14701 case 0x0a:
14702 case 0x0b:
14703 case 0x0c:
14704 case 0x0d:
14705 case 0x0e:
14706 case 0x0f:
14707 case 0x10:
14708 case 0x11:
14709 case 0x12:
14710 case 0x13:
14711 case 0x14:
14712 case 0x15:
14713 case 0x16:
14714 case 0x17:
14715 case 0x18:
14716 case 0x19:
14717 case 0x1a:
14718 case 0x1b:
14719 case 0x1c:
14720 case 0x1d:
14721 case 0x1e:
14722 case 0x1f:
14723 goto op_semantics_124;
14724 break;
14725 case 0x80:
14726 GETBYTE ();
14727 switch (op[3] & 0x0f)
c7927a3c 14728 {
4ce8c66d
YS		 14729 case 0x00:
14730 op_semantics_130:
14731 {
14732 /** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */
14733#line 1170 "rx-decode.opc"
14734 int rsrc AU = op[2] & 0x0f;
14735#line 1170 "rx-decode.opc"
14736 int rdst AU = (op[3] >> 4) & 0x0f;
14737 if (trace)
14738 {
14739 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14740 "/** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */",
14741 op[0], op[1], op[2], op[3]);
14742 printf (" rsrc = 0x%x,", rsrc);
14743 printf (" rdst = 0x%x\n", rdst);
14744 }
14745 SYNTAX("dmov.l %1, %0");
14746#line 1170 "rx-decode.opc"
14747 ID(dmov); DDRL(rdst); SR(rsrc); F_____;
14748
14749 }
14750 break;
14751 case 0x02:
14752 case 0x03:
14753 op_semantics_131:
14754 {
14755 /** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */
14756#line 1167 "rx-decode.opc"
14757 int rsrc AU = op[2] & 0x0f;
14758#line 1167 "rx-decode.opc"
14759 int rdst AU = (op[3] >> 4) & 0x0f;
14760#line 1167 "rx-decode.opc"
14761 int s AU = op[3] & 0x01;
14762 if (trace)
14763 {
14764 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14765 "/** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */",
14766 op[0], op[1], op[2], op[3]);
14767 printf (" rsrc = 0x%x,", rsrc);
14768 printf (" rdst = 0x%x,", rdst);
14769 printf (" s = 0x%x\n", s);
14770 }
14771 SYNTAX("dmov%s %1, %0");
14772#line 1167 "rx-decode.opc"
14773 ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____;
14774
14775 }
14776 break;
14777 case 0x04:
14778 op_semantics_132:
14779 {
14780 /** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */
14781#line 1232 "rx-decode.opc"
14782 int rdst AU = op[2] & 0x0f;
14783#line 1232 "rx-decode.opc"
14784 int rsrc AU = (op[3] >> 4) & 0x0f;
14785 if (trace)
14786 {
14787 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14788 "/** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */",
14789 op[0], op[1], op[2], op[3]);
14790 printf (" rdst = 0x%x,", rdst);
14791 printf (" rsrc = 0x%x\n", rsrc);
14792 }
14793 SYNTAX("mvtdc %1, %0");
14794#line 1232 "rx-decode.opc"
14795 ID(mvtdc); DCR(rdst); SR(rsrc); F_____;
14796
14797 }
14798 break;
14799 case 0x09:
14800 op_semantics_133:
14801 {
14802 /** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */
14803#line 1274 "rx-decode.opc"
14804 int rsrc AU = op[2] & 0x0f;
14805#line 1274 "rx-decode.opc"
14806 int rdst AU = (op[3] >> 4) & 0x0f;
14807 if (trace)
14808 {
14809 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14810 "/** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */",
14811 op[0], op[1], op[2], op[3]);
14812 printf (" rsrc = 0x%x,", rsrc);
14813 printf (" rdst = 0x%x\n", rdst);
14814 }
14815 SYNTAX("itod %1, %0");
14816#line 1274 "rx-decode.opc"
14817 ID(itod); DDR(rdst); SR(rsrc); F_____;
14818
14819 }
14820 break;
14821 case 0x0a:
14822 op_semantics_134:
14823 {
14824 /** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */
14825#line 1271 "rx-decode.opc"
14826 int rsrc AU = op[2] & 0x0f;
14827#line 1271 "rx-decode.opc"
14828 int rdst AU = (op[3] >> 4) & 0x0f;
14829 if (trace)
14830 {
14831 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14832 "/** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */",
14833 op[0], op[1], op[2], op[3]);
14834 printf (" rsrc = 0x%x,", rsrc);
14835 printf (" rdst = 0x%x\n", rdst);
14836 }
14837 SYNTAX("ftod %1, %0");
14838#line 1271 "rx-decode.opc"
14839 ID(ftod); DDR(rdst); SR(rsrc); F_____;
14840
14841 }
14842 break;
14843 case 0x0d:
14844 op_semantics_135:
14845 {
14846 /** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */
14847#line 1277 "rx-decode.opc"
14848 int rsrc AU = op[2] & 0x0f;
14849#line 1277 "rx-decode.opc"
14850 int rdst AU = (op[3] >> 4) & 0x0f;
14851 if (trace)
14852 {
14853 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14854 "/** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */",
14855 op[0], op[1], op[2], op[3]);
14856 printf (" rsrc = 0x%x,", rsrc);
14857 printf (" rdst = 0x%x\n", rdst);
14858 }
14859 SYNTAX("utod %1, %0");
14860#line 1277 "rx-decode.opc"
14861 ID(dsqrt); DDR(rdst); SR(rsrc); F_____;
43e65147 14862
4ce8c66d
YS		 14863 }
14864 break;
14865 default: UNSUPPORTED(); break;
c7927a3c
NC		 14866 }
14867 break;
4ce8c66d
YS		 14868 case 0x81:
14869 GETBYTE ();
14870 switch (op[3] & 0x0f)
14871 {
14872 case 0x00:
14873 goto op_semantics_130;
14874 break;
14875 case 0x02:
14876 case 0x03:
14877 goto op_semantics_131;
14878 break;
14879 case 0x04:
14880 goto op_semantics_132;
14881 break;
14882 case 0x09:
14883 goto op_semantics_133;
14884 break;
14885 case 0x0a:
14886 goto op_semantics_134;
14887 break;
14888 case 0x0d:
14889 goto op_semantics_135;
14890 break;
14891 default: UNSUPPORTED(); break;
14892 }
c7927a3c 14893 break;
4ce8c66d
YS		 14894 case 0x82:
14895 GETBYTE ();
14896 switch (op[3] & 0x0f)
14897 {
14898 case 0x00:
14899 goto op_semantics_130;
14900 break;
14901 case 0x02:
14902 case 0x03:
14903 goto op_semantics_131;
14904 break;
14905 case 0x04:
14906 goto op_semantics_132;
14907 break;
14908 case 0x09:
14909 goto op_semantics_133;
14910 break;
14911 case 0x0a:
14912 goto op_semantics_134;
14913 break;
14914 case 0x0d:
14915 goto op_semantics_135;
14916 break;
14917 default: UNSUPPORTED(); break;
14918 }
c7927a3c 14919 break;
4ce8c66d
YS		 14920 case 0x83:
14921 GETBYTE ();
14922 switch (op[3] & 0x0f)
14923 {
14924 case 0x00:
14925 goto op_semantics_130;
14926 break;
14927 case 0x02:
14928 case 0x03:
14929 goto op_semantics_131;
14930 break;
14931 case 0x04:
14932 goto op_semantics_132;
14933 break;
14934 case 0x09:
14935 goto op_semantics_133;
14936 break;
14937 case 0x0a:
14938 goto op_semantics_134;
14939 break;
14940 case 0x0d:
14941 goto op_semantics_135;
14942 break;
14943 default: UNSUPPORTED(); break;
14944 }
c7927a3c 14945 break;
4ce8c66d
YS		 14946 case 0x84:
14947 GETBYTE ();
14948 switch (op[3] & 0x0f)
14949 {
14950 case 0x00:
14951 goto op_semantics_130;
14952 break;
14953 case 0x02:
14954 case 0x03:
14955 goto op_semantics_131;
14956 break;
14957 case 0x04:
14958 goto op_semantics_132;
14959 break;
14960 case 0x09:
14961 goto op_semantics_133;
14962 break;
14963 case 0x0a:
14964 goto op_semantics_134;
14965 break;
14966 case 0x0d:
14967 goto op_semantics_135;
14968 break;
14969 default: UNSUPPORTED(); break;
14970 }
14971 break;
14972 case 0x85:
14973 GETBYTE ();
14974 switch (op[3] & 0x0f)
14975 {
14976 case 0x00:
14977 goto op_semantics_130;
14978 break;
14979 case 0x02:
14980 case 0x03:
14981 goto op_semantics_131;
14982 break;
14983 case 0x04:
14984 goto op_semantics_132;
14985 break;
14986 case 0x09:
14987 goto op_semantics_133;
14988 break;
14989 case 0x0a:
14990 goto op_semantics_134;
14991 break;
14992 case 0x0d:
14993 goto op_semantics_135;
14994 break;
14995 default: UNSUPPORTED(); break;
14996 }
14997 break;
14998 case 0x86:
14999 GETBYTE ();
15000 switch (op[3] & 0x0f)
15001 {
15002 case 0x00:
15003 goto op_semantics_130;
15004 break;
15005 case 0x02:
15006 case 0x03:
15007 goto op_semantics_131;
15008 break;
15009 case 0x04:
15010 goto op_semantics_132;
15011 break;
15012 case 0x09:
15013 goto op_semantics_133;
15014 break;
15015 case 0x0a:
15016 goto op_semantics_134;
15017 break;
15018 case 0x0d:
15019 goto op_semantics_135;
15020 break;
15021 default: UNSUPPORTED(); break;
15022 }
15023 break;
15024 case 0x87:
15025 GETBYTE ();
15026 switch (op[3] & 0x0f)
15027 {
15028 case 0x00:
15029 goto op_semantics_130;
15030 break;
15031 case 0x02:
15032 case 0x03:
15033 goto op_semantics_131;
15034 break;
15035 case 0x04:
15036 goto op_semantics_132;
15037 break;
15038 case 0x09:
15039 goto op_semantics_133;
15040 break;
15041 case 0x0a:
15042 goto op_semantics_134;
15043 break;
15044 case 0x0d:
15045 goto op_semantics_135;
15046 break;
15047 default: UNSUPPORTED(); break;
15048 }
c7927a3c 15049 break;
4ce8c66d
YS		 15050 case 0x88:
15051 GETBYTE ();
15052 switch (op[3] & 0x0f)
15053 {
15054 case 0x00:
15055 goto op_semantics_130;
15056 break;
15057 case 0x02:
15058 case 0x03:
15059 goto op_semantics_131;
15060 break;
15061 case 0x04:
15062 goto op_semantics_132;
15063 break;
15064 case 0x09:
15065 goto op_semantics_133;
15066 break;
15067 case 0x0a:
15068 goto op_semantics_134;
15069 break;
15070 case 0x0d:
15071 goto op_semantics_135;
15072 break;
15073 default: UNSUPPORTED(); break;
15074 }
c7927a3c 15075 break;
4ce8c66d
YS		 15076 case 0x89:
15077 GETBYTE ();
15078 switch (op[3] & 0x0f)
15079 {
15080 case 0x00:
15081 goto op_semantics_130;
15082 break;
15083 case 0x02:
15084 case 0x03:
15085 goto op_semantics_131;
15086 break;
15087 case 0x04:
15088 goto op_semantics_132;
15089 break;
15090 case 0x09:
15091 goto op_semantics_133;
15092 break;
15093 case 0x0a:
15094 goto op_semantics_134;
15095 break;
15096 case 0x0d:
15097 goto op_semantics_135;
15098 break;
15099 default: UNSUPPORTED(); break;
15100 }
c7927a3c 15101 break;
4ce8c66d
YS		 15102 case 0x8a:
15103 GETBYTE ();
15104 switch (op[3] & 0x0f)
15105 {
15106 case 0x00:
15107 goto op_semantics_130;
15108 break;
15109 case 0x02:
15110 case 0x03:
15111 goto op_semantics_131;
15112 break;
15113 case 0x04:
15114 goto op_semantics_132;
15115 break;
15116 case 0x09:
15117 goto op_semantics_133;
15118 break;
15119 case 0x0a:
15120 goto op_semantics_134;
15121 break;
15122 case 0x0d:
15123 goto op_semantics_135;
15124 break;
15125 default: UNSUPPORTED(); break;
15126 }
c7927a3c 15127 break;
4ce8c66d
YS		 15128 case 0x8b:
15129 GETBYTE ();
15130 switch (op[3] & 0x0f)
15131 {
15132 case 0x00:
15133 goto op_semantics_130;
15134 break;
15135 case 0x02:
15136 case 0x03:
15137 goto op_semantics_131;
15138 break;
15139 case 0x04:
15140 goto op_semantics_132;
15141 break;
15142 case 0x09:
15143 goto op_semantics_133;
15144 break;
15145 case 0x0a:
15146 goto op_semantics_134;
15147 break;
15148 case 0x0d:
15149 goto op_semantics_135;
15150 break;
15151 default: UNSUPPORTED(); break;
15152 }
c7927a3c 15153 break;
4ce8c66d
YS		 15154 case 0x8c:
15155 GETBYTE ();
15156 switch (op[3] & 0x0f)
15157 {
15158 case 0x00:
15159 goto op_semantics_130;
15160 break;
15161 case 0x02:
15162 case 0x03:
15163 goto op_semantics_131;
15164 break;
15165 case 0x04:
15166 goto op_semantics_132;
15167 break;
15168 case 0x09:
15169 goto op_semantics_133;
15170 break;
15171 case 0x0a:
15172 goto op_semantics_134;
15173 break;
15174 case 0x0d:
15175 goto op_semantics_135;
15176 break;
15177 default: UNSUPPORTED(); break;
15178 }
c7927a3c 15179 break;
4ce8c66d
YS		 15180 case 0x8d:
15181 GETBYTE ();
15182 switch (op[3] & 0x0f)
15183 {
15184 case 0x00:
15185 goto op_semantics_130;
15186 break;
15187 case 0x02:
15188 case 0x03:
15189 goto op_semantics_131;
15190 break;
15191 case 0x04:
15192 goto op_semantics_132;
15193 break;
15194 case 0x09:
15195 goto op_semantics_133;
15196 break;
15197 case 0x0a:
15198 goto op_semantics_134;
15199 break;
15200 case 0x0d:
15201 goto op_semantics_135;
15202 break;
15203 default: UNSUPPORTED(); break;
15204 }
c7927a3c 15205 break;
4ce8c66d
YS		 15206 case 0x8e:
15207 GETBYTE ();
15208 switch (op[3] & 0x0f)
15209 {
15210 case 0x00:
15211 goto op_semantics_130;
15212 break;
15213 case 0x02:
15214 case 0x03:
15215 goto op_semantics_131;
15216 break;
15217 case 0x04:
15218 goto op_semantics_132;
15219 break;
15220 case 0x09:
15221 goto op_semantics_133;
15222 break;
15223 case 0x0a:
15224 goto op_semantics_134;
15225 break;
15226 case 0x0d:
15227 goto op_semantics_135;
15228 break;
15229 default: UNSUPPORTED(); break;
15230 }
c7927a3c 15231 break;
4ce8c66d
YS		 15232 case 0x8f:
15233 GETBYTE ();
15234 switch (op[3] & 0x0f)
15235 {
15236 case 0x00:
15237 goto op_semantics_130;
15238 break;
15239 case 0x02:
15240 case 0x03:
15241 goto op_semantics_131;
15242 break;
15243 case 0x04:
15244 goto op_semantics_132;
15245 break;
15246 case 0x09:
15247 goto op_semantics_133;
15248 break;
15249 case 0x0a:
15250 goto op_semantics_134;
15251 break;
15252 case 0x0d:
15253 goto op_semantics_135;
15254 break;
15255 default: UNSUPPORTED(); break;
15256 }
c7927a3c
NC		 15257 break;
15258 default: UNSUPPORTED(); break;
15259 }
15260 break;
15261 case 0x78:
15262 GETBYTE ();
15263 switch (op[2] & 0xf0)
15264 {
15265 case 0x20:
4ce8c66d 15266 goto op_semantics_113;
c7927a3c
NC		 15267 break;
15268 case 0x40:
4ce8c66d 15269 goto op_semantics_114;
c7927a3c
NC		 15270 break;
15271 case 0x50:
4ce8c66d 15272 goto op_semantics_115;
c7927a3c
NC		 15273 break;
15274 case 0x60:
4ce8c66d 15275 goto op_semantics_116;
c7927a3c
NC		 15276 break;
15277 case 0x70:
4ce8c66d 15278 goto op_semantics_117;
c7927a3c
NC		 15279 break;
15280 case 0x80:
4ce8c66d 15281 goto op_semantics_118;
c7927a3c
NC		 15282 break;
15283 case 0x90:
4ce8c66d 15284 goto op_semantics_119;
c7927a3c
NC		 15285 break;
15286 case 0xc0:
4ce8c66d 15287 goto op_semantics_120;
c7927a3c
NC		 15288 break;
15289 case 0xd0:
4ce8c66d 15290 goto op_semantics_121;
c7927a3c
NC		 15291 break;
15292 case 0xe0:
4ce8c66d 15293 goto op_semantics_122;
c7927a3c
NC		 15294 break;
15295 case 0xf0:
4ce8c66d 15296 goto op_semantics_123;
c7927a3c
NC		 15297 break;
15298 default: UNSUPPORTED(); break;
15299 }
15300 break;
15301 case 0x7b:
15302 GETBYTE ();
15303 switch (op[2] & 0xe0)
15304 {
15305 case 0x00:
4ce8c66d 15306 goto op_semantics_124;
c7927a3c
NC		 15307 break;
15308 default: UNSUPPORTED(); break;
15309 }
15310 break;
15311 case 0x7c:
15312 GETBYTE ();
15313 switch (op[2] & 0xf0)
15314 {
15315 case 0x20:
4ce8c66d 15316 goto op_semantics_113;
c7927a3c
NC		 15317 break;
15318 case 0x40:
4ce8c66d 15319 goto op_semantics_114;
c7927a3c
NC		 15320 break;
15321 case 0x50:
4ce8c66d 15322 goto op_semantics_115;
c7927a3c
NC		 15323 break;
15324 case 0x60:
4ce8c66d 15325 goto op_semantics_116;
c7927a3c
NC		 15326 break;
15327 case 0x70:
4ce8c66d 15328 goto op_semantics_117;
c7927a3c
NC		 15329 break;
15330 case 0x80:
4ce8c66d 15331 goto op_semantics_118;
c7927a3c
NC		 15332 break;
15333 case 0x90:
4ce8c66d 15334 goto op_semantics_119;
c7927a3c
NC		 15335 break;
15336 case 0xc0:
4ce8c66d 15337 goto op_semantics_120;
c7927a3c
NC		 15338 break;
15339 case 0xd0:
4ce8c66d 15340 goto op_semantics_121;
c7927a3c
NC		 15341 break;
15342 case 0xe0:
4ce8c66d 15343 goto op_semantics_122;
c7927a3c
NC		 15344 break;
15345 case 0xf0:
4ce8c66d 15346 goto op_semantics_123;
c7927a3c
NC		 15347 break;
15348 default: UNSUPPORTED(); break;
15349 }
15350 break;
15351 case 0x7f:
15352 GETBYTE ();
15353 switch (op[2] & 0xe0)
15354 {
15355 case 0x00:
4ce8c66d 15356 goto op_semantics_124;
c7927a3c
NC		 15357 break;
15358 default: UNSUPPORTED(); break;
15359 }
15360 break;
15361 case 0x80:
15362 GETBYTE ();
15363 switch (op[2] & 0x00)
15364 {
15365 case 0x00:
4ce8c66d 15366 op_semantics_136:
c7927a3c
NC		 15367 {
15368 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
4ce8c66d 15369#line 757 "rx-decode.opc"
c7927a3c 15370 int immmm AU = op[1] & 0x1f;
4ce8c66d 15371#line 757 "rx-decode.opc"
c7927a3c 15372 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 15373#line 757 "rx-decode.opc"
c7927a3c
NC		 15374 int rdst AU = op[2] & 0x0f;
15375 if (trace)
15376 {
15377 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15378 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
15379 op[0], op[1], op[2]);
15380 printf (" immmm = 0x%x,", immmm);
15381 printf (" rsrc = 0x%x,", rsrc);
15382 printf (" rdst = 0x%x\n", rdst);
15383 }
15384 SYNTAX("shlr #%2, %1, %0");
4ce8c66d 15385#line 757 "rx-decode.opc"
3cf79a01 15386 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
43e65147 15387
c7927a3c
NC		 15388 /*----------------------------------------------------------------------*/
15389 /* ROTATE */
43e65147 15390
c7927a3c
NC		 15391 }
15392 break;
15393 }
15394 break;
15395 case 0x81:
15396 GETBYTE ();
15397 switch (op[2] & 0x00)
15398 {
15399 case 0x00:
4ce8c66d 15400 goto op_semantics_136;
c7927a3c
NC		 15401 break;
15402 }
15403 break;
15404 case 0x82:
15405 GETBYTE ();
15406 switch (op[2] & 0x00)
15407 {
15408 case 0x00:
4ce8c66d 15409 goto op_semantics_136;
c7927a3c
NC		 15410 break;
15411 }
15412 break;
15413 case 0x83:
15414 GETBYTE ();
15415 switch (op[2] & 0x00)
15416 {
15417 case 0x00:
4ce8c66d 15418 goto op_semantics_136;
c7927a3c
NC		 15419 break;
15420 }
15421 break;
15422 case 0x84:
15423 GETBYTE ();
15424 switch (op[2] & 0x00)
15425 {
15426 case 0x00:
4ce8c66d 15427 goto op_semantics_136;
c7927a3c
NC		 15428 break;
15429 }
15430 break;
15431 case 0x85:
15432 GETBYTE ();
15433 switch (op[2] & 0x00)
15434 {
15435 case 0x00:
4ce8c66d 15436 goto op_semantics_136;
c7927a3c
NC		 15437 break;
15438 }
15439 break;
15440 case 0x86:
15441 GETBYTE ();
15442 switch (op[2] & 0x00)
15443 {
15444 case 0x00:
4ce8c66d 15445 goto op_semantics_136;
c7927a3c
NC		 15446 break;
15447 }
15448 break;
15449 case 0x87:
15450 GETBYTE ();
15451 switch (op[2] & 0x00)
15452 {
15453 case 0x00:
4ce8c66d 15454 goto op_semantics_136;
c7927a3c
NC		 15455 break;
15456 }
15457 break;
15458 case 0x88:
15459 GETBYTE ();
15460 switch (op[2] & 0x00)
15461 {
15462 case 0x00:
4ce8c66d 15463 goto op_semantics_136;
c7927a3c
NC		 15464 break;
15465 }
15466 break;
15467 case 0x89:
15468 GETBYTE ();
15469 switch (op[2] & 0x00)
15470 {
15471 case 0x00:
4ce8c66d 15472 goto op_semantics_136;
c7927a3c
NC		 15473 break;
15474 }
15475 break;
15476 case 0x8a:
15477 GETBYTE ();
15478 switch (op[2] & 0x00)
15479 {
15480 case 0x00:
4ce8c66d 15481 goto op_semantics_136;
c7927a3c
NC		 15482 break;
15483 }
15484 break;
15485 case 0x8b:
15486 GETBYTE ();
15487 switch (op[2] & 0x00)
15488 {
15489 case 0x00:
4ce8c66d 15490 goto op_semantics_136;
c7927a3c
NC		 15491 break;
15492 }
15493 break;
15494 case 0x8c:
15495 GETBYTE ();
15496 switch (op[2] & 0x00)
15497 {
15498 case 0x00:
4ce8c66d 15499 goto op_semantics_136;
c7927a3c
NC		 15500 break;
15501 }
15502 break;
15503 case 0x8d:
15504 GETBYTE ();
15505 switch (op[2] & 0x00)
15506 {
15507 case 0x00:
4ce8c66d 15508 goto op_semantics_136;
c7927a3c
NC		 15509 break;
15510 }
15511 break;
15512 case 0x8e:
15513 GETBYTE ();
15514 switch (op[2] & 0x00)
15515 {
15516 case 0x00:
4ce8c66d 15517 goto op_semantics_136;
c7927a3c
NC		 15518 break;
15519 }
15520 break;
15521 case 0x8f:
15522 GETBYTE ();
15523 switch (op[2] & 0x00)
15524 {
15525 case 0x00:
4ce8c66d 15526 goto op_semantics_136;
c7927a3c
NC		 15527 break;
15528 }
15529 break;
15530 case 0x90:
15531 GETBYTE ();
15532 switch (op[2] & 0x00)
15533 {
15534 case 0x00:
4ce8c66d 15535 goto op_semantics_136;
c7927a3c
NC		 15536 break;
15537 }
15538 break;
15539 case 0x91:
15540 GETBYTE ();
15541 switch (op[2] & 0x00)
15542 {
15543 case 0x00:
4ce8c66d 15544 goto op_semantics_136;
c7927a3c
NC		 15545 break;
15546 }
15547 break;
15548 case 0x92:
15549 GETBYTE ();
15550 switch (op[2] & 0x00)
15551 {
15552 case 0x00:
4ce8c66d 15553 goto op_semantics_136;
c7927a3c
NC		 15554 break;
15555 }
15556 break;
15557 case 0x93:
15558 GETBYTE ();
15559 switch (op[2] & 0x00)
15560 {
15561 case 0x00:
4ce8c66d 15562 goto op_semantics_136;
c7927a3c
NC		 15563 break;
15564 }
15565 break;
15566 case 0x94:
15567 GETBYTE ();
15568 switch (op[2] & 0x00)
15569 {
15570 case 0x00:
4ce8c66d 15571 goto op_semantics_136;
c7927a3c
NC		 15572 break;
15573 }
15574 break;
15575 case 0x95:
15576 GETBYTE ();
15577 switch (op[2] & 0x00)
15578 {
15579 case 0x00:
4ce8c66d 15580 goto op_semantics_136;
c7927a3c
NC		 15581 break;
15582 }
15583 break;
15584 case 0x96:
15585 GETBYTE ();
15586 switch (op[2] & 0x00)
15587 {
15588 case 0x00:
4ce8c66d 15589 goto op_semantics_136;
c7927a3c
NC		 15590 break;
15591 }
15592 break;
15593 case 0x97:
15594 GETBYTE ();
15595 switch (op[2] & 0x00)
15596 {
15597 case 0x00:
4ce8c66d 15598 goto op_semantics_136;
c7927a3c
NC		 15599 break;
15600 }
15601 break;
15602 case 0x98:
15603 GETBYTE ();
15604 switch (op[2] & 0x00)
15605 {
15606 case 0x00:
4ce8c66d 15607 goto op_semantics_136;
c7927a3c
NC		 15608 break;
15609 }
15610 break;
15611 case 0x99:
15612 GETBYTE ();
15613 switch (op[2] & 0x00)
15614 {
15615 case 0x00:
4ce8c66d 15616 goto op_semantics_136;
c7927a3c
NC		 15617 break;
15618 }
15619 break;
15620 case 0x9a:
15621 GETBYTE ();
15622 switch (op[2] & 0x00)
15623 {
15624 case 0x00:
4ce8c66d 15625 goto op_semantics_136;
c7927a3c
NC		 15626 break;
15627 }
15628 break;
15629 case 0x9b:
15630 GETBYTE ();
15631 switch (op[2] & 0x00)
15632 {
15633 case 0x00:
4ce8c66d 15634 goto op_semantics_136;
c7927a3c
NC		 15635 break;
15636 }
15637 break;
15638 case 0x9c:
15639 GETBYTE ();
15640 switch (op[2] & 0x00)
15641 {
15642 case 0x00:
4ce8c66d 15643 goto op_semantics_136;
c7927a3c
NC		 15644 break;
15645 }
15646 break;
15647 case 0x9d:
15648 GETBYTE ();
15649 switch (op[2] & 0x00)
15650 {
15651 case 0x00:
4ce8c66d 15652 goto op_semantics_136;
c7927a3c
NC		 15653 break;
15654 }
15655 break;
15656 case 0x9e:
15657 GETBYTE ();
15658 switch (op[2] & 0x00)
15659 {
15660 case 0x00:
4ce8c66d 15661 goto op_semantics_136;
c7927a3c
NC		 15662 break;
15663 }
15664 break;
15665 case 0x9f:
15666 GETBYTE ();
15667 switch (op[2] & 0x00)
15668 {
15669 case 0x00:
4ce8c66d 15670 goto op_semantics_136;
c7927a3c
NC		 15671 break;
15672 }
15673 break;
15674 case 0xa0:
15675 GETBYTE ();
15676 switch (op[2] & 0x00)
15677 {
15678 case 0x00:
4ce8c66d 15679 op_semantics_137:
c7927a3c
NC		 15680 {
15681 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
4ce8c66d 15682#line 747 "rx-decode.opc"
c7927a3c 15683 int immmm AU = op[1] & 0x1f;
4ce8c66d 15684#line 747 "rx-decode.opc"
c7927a3c 15685 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 15686#line 747 "rx-decode.opc"
c7927a3c
NC		 15687 int rdst AU = op[2] & 0x0f;
15688 if (trace)
15689 {
15690 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15691 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
15692 op[0], op[1], op[2]);
15693 printf (" immmm = 0x%x,", immmm);
15694 printf (" rsrc = 0x%x,", rsrc);
15695 printf (" rdst = 0x%x\n", rdst);
15696 }
15697 SYNTAX("shar #%2, %1, %0");
4ce8c66d 15698#line 747 "rx-decode.opc"
3cf79a01 15699 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
43e65147
L		 15700
15701
c7927a3c
NC		 15702 }
15703 break;
15704 }
15705 break;
15706 case 0xa1:
15707 GETBYTE ();
15708 switch (op[2] & 0x00)
15709 {
15710 case 0x00:
4ce8c66d 15711 goto op_semantics_137;
c7927a3c
NC		 15712 break;
15713 }
15714 break;
15715 case 0xa2:
15716 GETBYTE ();
15717 switch (op[2] & 0x00)
15718 {
15719 case 0x00:
4ce8c66d 15720 goto op_semantics_137;
c7927a3c
NC		 15721 break;
15722 }
15723 break;
15724 case 0xa3:
15725 GETBYTE ();
15726 switch (op[2] & 0x00)
15727 {
15728 case 0x00:
4ce8c66d 15729 goto op_semantics_137;
c7927a3c
NC		 15730 break;
15731 }
15732 break;
15733 case 0xa4:
15734 GETBYTE ();
15735 switch (op[2] & 0x00)
15736 {
15737 case 0x00:
4ce8c66d 15738 goto op_semantics_137;
c7927a3c
NC		 15739 break;
15740 }
15741 break;
15742 case 0xa5:
15743 GETBYTE ();
15744 switch (op[2] & 0x00)
15745 {
15746 case 0x00:
4ce8c66d 15747 goto op_semantics_137;
c7927a3c
NC		 15748 break;
15749 }
15750 break;
15751 case 0xa6:
15752 GETBYTE ();
15753 switch (op[2] & 0x00)
15754 {
15755 case 0x00:
4ce8c66d 15756 goto op_semantics_137;
c7927a3c
NC		 15757 break;
15758 }
15759 break;
15760 case 0xa7:
15761 GETBYTE ();
15762 switch (op[2] & 0x00)
15763 {
15764 case 0x00:
4ce8c66d 15765 goto op_semantics_137;
c7927a3c
NC		 15766 break;
15767 }
15768 break;
15769 case 0xa8:
15770 GETBYTE ();
15771 switch (op[2] & 0x00)
15772 {
15773 case 0x00:
4ce8c66d 15774 goto op_semantics_137;
c7927a3c
NC		 15775 break;
15776 }
15777 break;
15778 case 0xa9:
15779 GETBYTE ();
15780 switch (op[2] & 0x00)
15781 {
15782 case 0x00:
4ce8c66d 15783 goto op_semantics_137;
c7927a3c
NC		 15784 break;
15785 }
15786 break;
15787 case 0xaa:
15788 GETBYTE ();
15789 switch (op[2] & 0x00)
15790 {
15791 case 0x00:
4ce8c66d 15792 goto op_semantics_137;
c7927a3c
NC		 15793 break;
15794 }
15795 break;
15796 case 0xab:
15797 GETBYTE ();
15798 switch (op[2] & 0x00)
15799 {
15800 case 0x00:
4ce8c66d 15801 goto op_semantics_137;
c7927a3c
NC		 15802 break;
15803 }
15804 break;
15805 case 0xac:
15806 GETBYTE ();
15807 switch (op[2] & 0x00)
15808 {
15809 case 0x00:
4ce8c66d 15810 goto op_semantics_137;
c7927a3c
NC		 15811 break;
15812 }
15813 break;
15814 case 0xad:
15815 GETBYTE ();
15816 switch (op[2] & 0x00)
15817 {
15818 case 0x00:
4ce8c66d 15819 goto op_semantics_137;
c7927a3c
NC		 15820 break;
15821 }
15822 break;
15823 case 0xae:
15824 GETBYTE ();
15825 switch (op[2] & 0x00)
15826 {
15827 case 0x00:
4ce8c66d 15828 goto op_semantics_137;
c7927a3c
NC		 15829 break;
15830 }
15831 break;
15832 case 0xaf:
15833 GETBYTE ();
15834 switch (op[2] & 0x00)
15835 {
15836 case 0x00:
4ce8c66d 15837 goto op_semantics_137;
c7927a3c
NC		 15838 break;
15839 }
15840 break;
15841 case 0xb0:
15842 GETBYTE ();
15843 switch (op[2] & 0x00)
15844 {
15845 case 0x00:
4ce8c66d 15846 goto op_semantics_137;
c7927a3c
NC		 15847 break;
15848 }
15849 break;
15850 case 0xb1:
15851 GETBYTE ();
15852 switch (op[2] & 0x00)
15853 {
15854 case 0x00:
4ce8c66d 15855 goto op_semantics_137;
c7927a3c
NC		 15856 break;
15857 }
15858 break;
15859 case 0xb2:
15860 GETBYTE ();
15861 switch (op[2] & 0x00)
15862 {
15863 case 0x00:
4ce8c66d 15864 goto op_semantics_137;
c7927a3c
NC		 15865 break;
15866 }
15867 break;
15868 case 0xb3:
15869 GETBYTE ();
15870 switch (op[2] & 0x00)
15871 {
15872 case 0x00:
4ce8c66d 15873 goto op_semantics_137;
c7927a3c
NC		 15874 break;
15875 }
15876 break;
15877 case 0xb4:
15878 GETBYTE ();
15879 switch (op[2] & 0x00)
15880 {
15881 case 0x00:
4ce8c66d 15882 goto op_semantics_137;
c7927a3c
NC		 15883 break;
15884 }
15885 break;
15886 case 0xb5:
15887 GETBYTE ();
15888 switch (op[2] & 0x00)
15889 {
15890 case 0x00:
4ce8c66d 15891 goto op_semantics_137;
c7927a3c
NC		 15892 break;
15893 }
15894 break;
15895 case 0xb6:
15896 GETBYTE ();
15897 switch (op[2] & 0x00)
15898 {
15899 case 0x00:
4ce8c66d 15900 goto op_semantics_137;
c7927a3c
NC		 15901 break;
15902 }
15903 break;
15904 case 0xb7:
15905 GETBYTE ();
15906 switch (op[2] & 0x00)
15907 {
15908 case 0x00:
4ce8c66d 15909 goto op_semantics_137;
c7927a3c
NC		 15910 break;
15911 }
15912 break;
15913 case 0xb8:
15914 GETBYTE ();
15915 switch (op[2] & 0x00)
15916 {
15917 case 0x00:
4ce8c66d 15918 goto op_semantics_137;
c7927a3c
NC		 15919 break;
15920 }
15921 break;
15922 case 0xb9:
15923 GETBYTE ();
15924 switch (op[2] & 0x00)
15925 {
15926 case 0x00:
4ce8c66d 15927 goto op_semantics_137;
c7927a3c
NC		 15928 break;
15929 }
15930 break;
15931 case 0xba:
15932 GETBYTE ();
15933 switch (op[2] & 0x00)
15934 {
15935 case 0x00:
4ce8c66d 15936 goto op_semantics_137;
c7927a3c
NC		 15937 break;
15938 }
15939 break;
15940 case 0xbb:
15941 GETBYTE ();
15942 switch (op[2] & 0x00)
15943 {
15944 case 0x00:
4ce8c66d 15945 goto op_semantics_137;
c7927a3c
NC		 15946 break;
15947 }
15948 break;
15949 case 0xbc:
15950 GETBYTE ();
15951 switch (op[2] & 0x00)
15952 {
15953 case 0x00:
4ce8c66d 15954 goto op_semantics_137;
c7927a3c
NC		 15955 break;
15956 }
15957 break;
15958 case 0xbd:
15959 GETBYTE ();
15960 switch (op[2] & 0x00)
15961 {
15962 case 0x00:
4ce8c66d 15963 goto op_semantics_137;
c7927a3c
NC		 15964 break;
15965 }
15966 break;
15967 case 0xbe:
15968 GETBYTE ();
15969 switch (op[2] & 0x00)
15970 {
15971 case 0x00:
4ce8c66d 15972 goto op_semantics_137;
c7927a3c
NC		 15973 break;
15974 }
15975 break;
15976 case 0xbf:
15977 GETBYTE ();
15978 switch (op[2] & 0x00)
15979 {
15980 case 0x00:
4ce8c66d 15981 goto op_semantics_137;
c7927a3c
NC		 15982 break;
15983 }
15984 break;
15985 case 0xc0:
15986 GETBYTE ();
15987 switch (op[2] & 0x00)
15988 {
15989 case 0x00:
4ce8c66d 15990 op_semantics_138:
c7927a3c
NC		 15991 {
15992 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
4ce8c66d 15993#line 737 "rx-decode.opc"
c7927a3c 15994 int immmm AU = op[1] & 0x1f;
4ce8c66d 15995#line 737 "rx-decode.opc"
c7927a3c 15996 int rsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 15997#line 737 "rx-decode.opc"
c7927a3c
NC		 15998 int rdst AU = op[2] & 0x0f;
15999 if (trace)
16000 {
16001 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16002 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
16003 op[0], op[1], op[2]);
16004 printf (" immmm = 0x%x,", immmm);
16005 printf (" rsrc = 0x%x,", rsrc);
16006 printf (" rdst = 0x%x\n", rdst);
16007 }
16008 SYNTAX("shll #%2, %1, %0");
4ce8c66d 16009#line 737 "rx-decode.opc"
3cf79a01 16010 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
43e65147
L		 16011
16012
c7927a3c
NC		 16013 }
16014 break;
16015 }
16016 break;
16017 case 0xc1:
16018 GETBYTE ();
16019 switch (op[2] & 0x00)
16020 {
16021 case 0x00:
4ce8c66d 16022 goto op_semantics_138;
c7927a3c
NC		 16023 break;
16024 }
16025 break;
16026 case 0xc2:
16027 GETBYTE ();
16028 switch (op[2] & 0x00)
16029 {
16030 case 0x00:
4ce8c66d 16031 goto op_semantics_138;
c7927a3c
NC		 16032 break;
16033 }
16034 break;
16035 case 0xc3:
16036 GETBYTE ();
16037 switch (op[2] & 0x00)
16038 {
16039 case 0x00:
4ce8c66d 16040 goto op_semantics_138;
a117b0a5
YS		 16041 break;
16042 }
16043 break;
16044 case 0xc4:
16045 GETBYTE ();
16046 switch (op[2] & 0x00)
16047 {
16048 case 0x00:
4ce8c66d 16049 goto op_semantics_138;
a117b0a5
YS		 16050 break;
16051 }
16052 break;
16053 case 0xc5:
16054 GETBYTE ();
16055 switch (op[2] & 0x00)
16056 {
16057 case 0x00:
4ce8c66d 16058 goto op_semantics_138;
a117b0a5
YS		 16059 break;
16060 }
16061 break;
16062 case 0xc6:
16063 GETBYTE ();
16064 switch (op[2] & 0x00)
16065 {
16066 case 0x00:
4ce8c66d 16067 goto op_semantics_138;
a117b0a5
YS		 16068 break;
16069 }
16070 break;
16071 case 0xc7:
16072 GETBYTE ();
16073 switch (op[2] & 0x00)
16074 {
16075 case 0x00:
4ce8c66d 16076 goto op_semantics_138;
a117b0a5
YS		 16077 break;
16078 }
16079 break;
16080 case 0xc8:
16081 GETBYTE ();
16082 switch (op[2] & 0x00)
16083 {
16084 case 0x00:
4ce8c66d 16085 goto op_semantics_138;
a117b0a5
YS		 16086 break;
16087 }
16088 break;
16089 case 0xc9:
16090 GETBYTE ();
16091 switch (op[2] & 0x00)
16092 {
16093 case 0x00:
4ce8c66d 16094 goto op_semantics_138;
a117b0a5
YS		 16095 break;
16096 }
16097 break;
16098 case 0xca:
16099 GETBYTE ();
16100 switch (op[2] & 0x00)
16101 {
16102 case 0x00:
4ce8c66d 16103 goto op_semantics_138;
a117b0a5
YS		 16104 break;
16105 }
16106 break;
16107 case 0xcb:
16108 GETBYTE ();
16109 switch (op[2] & 0x00)
16110 {
16111 case 0x00:
4ce8c66d 16112 goto op_semantics_138;
a117b0a5
YS		 16113 break;
16114 }
16115 break;
16116 case 0xcc:
16117 GETBYTE ();
16118 switch (op[2] & 0x00)
16119 {
16120 case 0x00:
4ce8c66d 16121 goto op_semantics_138;
a117b0a5
YS		 16122 break;
16123 }
16124 break;
16125 case 0xcd:
16126 GETBYTE ();
16127 switch (op[2] & 0x00)
16128 {
16129 case 0x00:
4ce8c66d 16130 goto op_semantics_138;
a117b0a5
YS		 16131 break;
16132 }
16133 break;
16134 case 0xce:
16135 GETBYTE ();
16136 switch (op[2] & 0x00)
16137 {
16138 case 0x00:
4ce8c66d 16139 goto op_semantics_138;
a117b0a5
YS		 16140 break;
16141 }
16142 break;
16143 case 0xcf:
16144 GETBYTE ();
16145 switch (op[2] & 0x00)
16146 {
16147 case 0x00:
4ce8c66d 16148 goto op_semantics_138;
a117b0a5
YS		 16149 break;
16150 }
16151 break;
16152 case 0xd0:
16153 GETBYTE ();
16154 switch (op[2] & 0x00)
16155 {
16156 case 0x00:
4ce8c66d 16157 goto op_semantics_138;
a117b0a5
YS		 16158 break;
16159 }
16160 break;
16161 case 0xd1:
16162 GETBYTE ();
16163 switch (op[2] & 0x00)
16164 {
16165 case 0x00:
4ce8c66d 16166 goto op_semantics_138;
a117b0a5
YS		 16167 break;
16168 }
16169 break;
16170 case 0xd2:
16171 GETBYTE ();
16172 switch (op[2] & 0x00)
16173 {
16174 case 0x00:
4ce8c66d 16175 goto op_semantics_138;
a117b0a5
YS		 16176 break;
16177 }
16178 break;
16179 case 0xd3:
16180 GETBYTE ();
16181 switch (op[2] & 0x00)
16182 {
16183 case 0x00:
4ce8c66d 16184 goto op_semantics_138;
a117b0a5
YS		 16185 break;
16186 }
16187 break;
16188 case 0xd4:
16189 GETBYTE ();
16190 switch (op[2] & 0x00)
16191 {
16192 case 0x00:
4ce8c66d 16193 goto op_semantics_138;
c7927a3c
NC		 16194 break;
16195 }
16196 break;
a117b0a5 16197 case 0xd5:
c7927a3c
NC		 16198 GETBYTE ();
16199 switch (op[2] & 0x00)
16200 {
16201 case 0x00:
4ce8c66d 16202 goto op_semantics_138;
c7927a3c
NC		 16203 break;
16204 }
16205 break;
a117b0a5 16206 case 0xd6:
c7927a3c
NC		 16207 GETBYTE ();
16208 switch (op[2] & 0x00)
16209 {
16210 case 0x00:
4ce8c66d 16211 goto op_semantics_138;
c7927a3c
NC		 16212 break;
16213 }
16214 break;
a117b0a5 16215 case 0xd7:
c7927a3c
NC		 16216 GETBYTE ();
16217 switch (op[2] & 0x00)
16218 {
16219 case 0x00:
4ce8c66d 16220 goto op_semantics_138;
c7927a3c
NC		 16221 break;
16222 }
16223 break;
a117b0a5 16224 case 0xd8:
c7927a3c
NC		 16225 GETBYTE ();
16226 switch (op[2] & 0x00)
16227 {
16228 case 0x00:
4ce8c66d 16229 goto op_semantics_138;
c7927a3c
NC		 16230 break;
16231 }
16232 break;
a117b0a5 16233 case 0xd9:
c7927a3c
NC		 16234 GETBYTE ();
16235 switch (op[2] & 0x00)
16236 {
16237 case 0x00:
4ce8c66d 16238 goto op_semantics_138;
c7927a3c
NC		 16239 break;
16240 }
16241 break;
a117b0a5 16242 case 0xda:
c7927a3c
NC		 16243 GETBYTE ();
16244 switch (op[2] & 0x00)
16245 {
16246 case 0x00:
4ce8c66d 16247 goto op_semantics_138;
c7927a3c
NC		 16248 break;
16249 }
16250 break;
a117b0a5 16251 case 0xdb:
c7927a3c
NC		 16252 GETBYTE ();
16253 switch (op[2] & 0x00)
16254 {
16255 case 0x00:
4ce8c66d 16256 goto op_semantics_138;
c7927a3c
NC		 16257 break;
16258 }
16259 break;
a117b0a5 16260 case 0xdc:
c7927a3c
NC		 16261 GETBYTE ();
16262 switch (op[2] & 0x00)
16263 {
16264 case 0x00:
4ce8c66d 16265 goto op_semantics_138;
c7927a3c
NC		 16266 break;
16267 }
16268 break;
a117b0a5 16269 case 0xdd:
c7927a3c
NC		 16270 GETBYTE ();
16271 switch (op[2] & 0x00)
16272 {
16273 case 0x00:
4ce8c66d 16274 goto op_semantics_138;
c7927a3c
NC		 16275 break;
16276 }
16277 break;
a117b0a5 16278 case 0xde:
c7927a3c
NC		 16279 GETBYTE ();
16280 switch (op[2] & 0x00)
16281 {
16282 case 0x00:
4ce8c66d 16283 goto op_semantics_138;
c7927a3c
NC		 16284 break;
16285 }
16286 break;
a117b0a5 16287 case 0xdf:
c7927a3c
NC		 16288 GETBYTE ();
16289 switch (op[2] & 0x00)
16290 {
16291 case 0x00:
4ce8c66d 16292 goto op_semantics_138;
c7927a3c
NC		 16293 break;
16294 }
16295 break;
a117b0a5 16296 case 0xe0:
c7927a3c 16297 GETBYTE ();
a117b0a5 16298 switch (op[2] & 0xf0)
c7927a3c
NC		 16299 {
16300 case 0x00:
a117b0a5
YS		 16301 case 0x10:
16302 case 0x20:
16303 case 0x30:
16304 case 0x40:
16305 case 0x50:
16306 case 0x60:
16307 case 0x70:
16308 case 0x80:
16309 case 0x90:
16310 case 0xa0:
16311 case 0xb0:
16312 case 0xc0:
16313 case 0xd0:
16314 case 0xe0:
4ce8c66d 16315 op_semantics_139:
a117b0a5
YS		 16316 {
16317 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
4ce8c66d 16318#line 1011 "rx-decode.opc"
a117b0a5 16319 int bittt AU = op[1] & 0x1f;
4ce8c66d 16320#line 1011 "rx-decode.opc"
a117b0a5 16321 int cond AU = (op[2] >> 4) & 0x0f;
4ce8c66d 16322#line 1011 "rx-decode.opc"
a117b0a5
YS		 16323 int rdst AU = op[2] & 0x0f;
16324 if (trace)
16325 {
16326 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16327 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
16328 op[0], op[1], op[2]);
16329 printf (" bittt = 0x%x,", bittt);
16330 printf (" cond = 0x%x,", cond);
16331 printf (" rdst = 0x%x\n", rdst);
16332 }
16333 SYNTAX("bm%2 #%1, %0%S0");
4ce8c66d 16334#line 1011 "rx-decode.opc"
a117b0a5
YS		 16335 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
16336
16337 /*----------------------------------------------------------------------*/
16338 /* CONTROL REGISTERS */
16339
16340 }
16341 break;
16342 case 0xf0:
4ce8c66d 16343 op_semantics_140:
a117b0a5
YS		 16344 {
16345 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
4ce8c66d 16346#line 1004 "rx-decode.opc"
a117b0a5 16347 int bittt AU = op[1] & 0x1f;
4ce8c66d 16348#line 1004 "rx-decode.opc"
a117b0a5
YS		 16349 int rdst AU = op[2] & 0x0f;
16350 if (trace)
16351 {
16352 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16353 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
16354 op[0], op[1], op[2]);
16355 printf (" bittt = 0x%x,", bittt);
16356 printf (" rdst = 0x%x\n", rdst);
16357 }
16358 SYNTAX("bnot #%1, %0");
4ce8c66d 16359#line 1004 "rx-decode.opc"
a117b0a5
YS		 16360 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
16361
16362
16363 }
c7927a3c
NC		 16364 break;
16365 }
16366 break;
a117b0a5 16367 case 0xe1:
c7927a3c 16368 GETBYTE ();
a117b0a5 16369 switch (op[2] & 0xf0)
c7927a3c
NC		 16370 {
16371 case 0x00:
a117b0a5
YS		 16372 case 0x10:
16373 case 0x20:
16374 case 0x30:
16375 case 0x40:
16376 case 0x50:
16377 case 0x60:
16378 case 0x70:
16379 case 0x80:
16380 case 0x90:
16381 case 0xa0:
16382 case 0xb0:
16383 case 0xc0:
16384 case 0xd0:
16385 case 0xe0:
4ce8c66d 16386 goto op_semantics_139;
a117b0a5
YS		 16387 break;
16388 case 0xf0:
4ce8c66d 16389 goto op_semantics_140;
c7927a3c
NC		 16390 break;
16391 }
16392 break;
a117b0a5 16393 case 0xe2:
c7927a3c 16394 GETBYTE ();
a117b0a5 16395 switch (op[2] & 0xf0)
c7927a3c
NC		 16396 {
16397 case 0x00:
a117b0a5
YS		 16398 case 0x10:
16399 case 0x20:
16400 case 0x30:
16401 case 0x40:
16402 case 0x50:
16403 case 0x60:
16404 case 0x70:
16405 case 0x80:
16406 case 0x90:
16407 case 0xa0:
16408 case 0xb0:
16409 case 0xc0:
16410 case 0xd0:
16411 case 0xe0:
4ce8c66d 16412 goto op_semantics_139;
a117b0a5
YS		 16413 break;
16414 case 0xf0:
4ce8c66d 16415 goto op_semantics_140;
c7927a3c
NC		 16416 break;
16417 }
16418 break;
a117b0a5 16419 case 0xe3:
c7927a3c 16420 GETBYTE ();
a117b0a5 16421 switch (op[2] & 0xf0)
c7927a3c
NC		 16422 {
16423 case 0x00:
a117b0a5
YS		 16424 case 0x10:
16425 case 0x20:
16426 case 0x30:
16427 case 0x40:
16428 case 0x50:
16429 case 0x60:
16430 case 0x70:
16431 case 0x80:
16432 case 0x90:
16433 case 0xa0:
16434 case 0xb0:
16435 case 0xc0:
16436 case 0xd0:
16437 case 0xe0:
4ce8c66d 16438 goto op_semantics_139;
a117b0a5
YS		 16439 break;
16440 case 0xf0:
4ce8c66d 16441 goto op_semantics_140;
c7927a3c
NC		 16442 break;
16443 }
16444 break;
a117b0a5 16445 case 0xe4:
c7927a3c 16446 GETBYTE ();
a117b0a5 16447 switch (op[2] & 0xf0)
c7927a3c
NC		 16448 {
16449 case 0x00:
a117b0a5
YS		 16450 case 0x10:
16451 case 0x20:
16452 case 0x30:
16453 case 0x40:
16454 case 0x50:
16455 case 0x60:
16456 case 0x70:
16457 case 0x80:
16458 case 0x90:
16459 case 0xa0:
16460 case 0xb0:
16461 case 0xc0:
16462 case 0xd0:
16463 case 0xe0:
4ce8c66d 16464 goto op_semantics_139;
a117b0a5
YS		 16465 break;
16466 case 0xf0:
4ce8c66d 16467 goto op_semantics_140;
c7927a3c
NC		 16468 break;
16469 }
16470 break;
a117b0a5 16471 case 0xe5:
c7927a3c 16472 GETBYTE ();
a117b0a5 16473 switch (op[2] & 0xf0)
c7927a3c
NC		 16474 {
16475 case 0x00:
a117b0a5
YS		 16476 case 0x10:
16477 case 0x20:
16478 case 0x30:
16479 case 0x40:
16480 case 0x50:
16481 case 0x60:
16482 case 0x70:
16483 case 0x80:
16484 case 0x90:
16485 case 0xa0:
16486 case 0xb0:
16487 case 0xc0:
16488 case 0xd0:
16489 case 0xe0:
4ce8c66d 16490 goto op_semantics_139;
a117b0a5
YS		 16491 break;
16492 case 0xf0:
4ce8c66d 16493 goto op_semantics_140;
c7927a3c
NC		 16494 break;
16495 }
16496 break;
a117b0a5 16497 case 0xe6:
c7927a3c 16498 GETBYTE ();
a117b0a5 16499 switch (op[2] & 0xf0)
c7927a3c
NC		 16500 {
16501 case 0x00:
a117b0a5
YS		 16502 case 0x10:
16503 case 0x20:
16504 case 0x30:
16505 case 0x40:
16506 case 0x50:
16507 case 0x60:
16508 case 0x70:
16509 case 0x80:
16510 case 0x90:
16511 case 0xa0:
16512 case 0xb0:
16513 case 0xc0:
16514 case 0xd0:
16515 case 0xe0:
4ce8c66d 16516 goto op_semantics_139;
a117b0a5
YS		 16517 break;
16518 case 0xf0:
4ce8c66d 16519 goto op_semantics_140;
c7927a3c
NC		 16520 break;
16521 }
16522 break;
a117b0a5 16523 case 0xe7:
c7927a3c 16524 GETBYTE ();
a117b0a5 16525 switch (op[2] & 0xf0)
c7927a3c
NC		 16526 {
16527 case 0x00:
a117b0a5
YS		 16528 case 0x10:
16529 case 0x20:
16530 case 0x30:
16531 case 0x40:
16532 case 0x50:
16533 case 0x60:
16534 case 0x70:
16535 case 0x80:
16536 case 0x90:
16537 case 0xa0:
16538 case 0xb0:
16539 case 0xc0:
16540 case 0xd0:
16541 case 0xe0:
4ce8c66d 16542 goto op_semantics_139;
a117b0a5
YS		 16543 break;
16544 case 0xf0:
4ce8c66d 16545 goto op_semantics_140;
c7927a3c
NC		 16546 break;
16547 }
16548 break;
a117b0a5 16549 case 0xe8:
c7927a3c 16550 GETBYTE ();
a117b0a5 16551 switch (op[2] & 0xf0)
c7927a3c
NC		 16552 {
16553 case 0x00:
a117b0a5
YS		 16554 case 0x10:
16555 case 0x20:
16556 case 0x30:
16557 case 0x40:
16558 case 0x50:
16559 case 0x60:
16560 case 0x70:
16561 case 0x80:
16562 case 0x90:
16563 case 0xa0:
16564 case 0xb0:
16565 case 0xc0:
16566 case 0xd0:
16567 case 0xe0:
4ce8c66d 16568 goto op_semantics_139;
a117b0a5
YS		 16569 break;
16570 case 0xf0:
4ce8c66d 16571 goto op_semantics_140;
c7927a3c
NC		 16572 break;
16573 }
16574 break;
a117b0a5 16575 case 0xe9:
c7927a3c 16576 GETBYTE ();
a117b0a5 16577 switch (op[2] & 0xf0)
c7927a3c
NC		 16578 {
16579 case 0x00:
a117b0a5
YS		 16580 case 0x10:
16581 case 0x20:
16582 case 0x30:
16583 case 0x40:
16584 case 0x50:
16585 case 0x60:
16586 case 0x70:
16587 case 0x80:
16588 case 0x90:
16589 case 0xa0:
16590 case 0xb0:
16591 case 0xc0:
16592 case 0xd0:
16593 case 0xe0:
4ce8c66d 16594 goto op_semantics_139;
a117b0a5
YS		 16595 break;
16596 case 0xf0:
4ce8c66d 16597 goto op_semantics_140;
c7927a3c
NC		 16598 break;
16599 }
16600 break;
a117b0a5 16601 case 0xea:
c7927a3c 16602 GETBYTE ();
a117b0a5 16603 switch (op[2] & 0xf0)
c7927a3c
NC		 16604 {
16605 case 0x00:
a117b0a5
YS		 16606 case 0x10:
16607 case 0x20:
16608 case 0x30:
16609 case 0x40:
16610 case 0x50:
16611 case 0x60:
16612 case 0x70:
16613 case 0x80:
16614 case 0x90:
16615 case 0xa0:
16616 case 0xb0:
16617 case 0xc0:
16618 case 0xd0:
16619 case 0xe0:
4ce8c66d 16620 goto op_semantics_139;
a117b0a5
YS		 16621 break;
16622 case 0xf0:
4ce8c66d 16623 goto op_semantics_140;
c7927a3c
NC		 16624 break;
16625 }
16626 break;
a117b0a5 16627 case 0xeb:
c7927a3c 16628 GETBYTE ();
a117b0a5 16629 switch (op[2] & 0xf0)
c7927a3c
NC		 16630 {
16631 case 0x00:
a117b0a5
YS		 16632 case 0x10:
16633 case 0x20:
16634 case 0x30:
16635 case 0x40:
16636 case 0x50:
16637 case 0x60:
16638 case 0x70:
16639 case 0x80:
16640 case 0x90:
16641 case 0xa0:
16642 case 0xb0:
16643 case 0xc0:
16644 case 0xd0:
16645 case 0xe0:
4ce8c66d 16646 goto op_semantics_139;
a117b0a5
YS		 16647 break;
16648 case 0xf0:
4ce8c66d 16649 goto op_semantics_140;
c7927a3c
NC		 16650 break;
16651 }
16652 break;
a117b0a5 16653 case 0xec:
c7927a3c 16654 GETBYTE ();
a117b0a5 16655 switch (op[2] & 0xf0)
c7927a3c
NC		 16656 {
16657 case 0x00:
a117b0a5
YS		 16658 case 0x10:
16659 case 0x20:
16660 case 0x30:
16661 case 0x40:
16662 case 0x50:
16663 case 0x60:
16664 case 0x70:
16665 case 0x80:
16666 case 0x90:
16667 case 0xa0:
16668 case 0xb0:
16669 case 0xc0:
16670 case 0xd0:
16671 case 0xe0:
4ce8c66d 16672 goto op_semantics_139;
a117b0a5
YS		 16673 break;
16674 case 0xf0:
4ce8c66d 16675 goto op_semantics_140;
c7927a3c
NC		 16676 break;
16677 }
16678 break;
a117b0a5 16679 case 0xed:
c7927a3c 16680 GETBYTE ();
a117b0a5 16681 switch (op[2] & 0xf0)
c7927a3c
NC		 16682 {
16683 case 0x00:
a117b0a5
YS		 16684 case 0x10:
16685 case 0x20:
16686 case 0x30:
16687 case 0x40:
16688 case 0x50:
16689 case 0x60:
16690 case 0x70:
16691 case 0x80:
16692 case 0x90:
16693 case 0xa0:
16694 case 0xb0:
16695 case 0xc0:
16696 case 0xd0:
16697 case 0xe0:
4ce8c66d 16698 goto op_semantics_139;
a117b0a5
YS		 16699 break;
16700 case 0xf0:
4ce8c66d 16701 goto op_semantics_140;
c7927a3c
NC		 16702 break;
16703 }
16704 break;
a117b0a5 16705 case 0xee:
c7927a3c 16706 GETBYTE ();
a117b0a5 16707 switch (op[2] & 0xf0)
c7927a3c
NC		 16708 {
16709 case 0x00:
a117b0a5
YS		 16710 case 0x10:
16711 case 0x20:
16712 case 0x30:
16713 case 0x40:
16714 case 0x50:
16715 case 0x60:
16716 case 0x70:
16717 case 0x80:
16718 case 0x90:
16719 case 0xa0:
16720 case 0xb0:
16721 case 0xc0:
16722 case 0xd0:
16723 case 0xe0:
4ce8c66d 16724 goto op_semantics_139;
a117b0a5
YS		 16725 break;
16726 case 0xf0:
4ce8c66d 16727 goto op_semantics_140;
c7927a3c
NC		 16728 break;
16729 }
16730 break;
a117b0a5 16731 case 0xef:
c7927a3c 16732 GETBYTE ();
a117b0a5 16733 switch (op[2] & 0xf0)
c7927a3c
NC		 16734 {
16735 case 0x00:
a117b0a5
YS		 16736 case 0x10:
16737 case 0x20:
16738 case 0x30:
16739 case 0x40:
16740 case 0x50:
16741 case 0x60:
16742 case 0x70:
16743 case 0x80:
16744 case 0x90:
16745 case 0xa0:
16746 case 0xb0:
16747 case 0xc0:
16748 case 0xd0:
16749 case 0xe0:
4ce8c66d 16750 goto op_semantics_139;
a117b0a5
YS		 16751 break;
16752 case 0xf0:
4ce8c66d 16753 goto op_semantics_140;
c7927a3c
NC		 16754 break;
16755 }
16756 break;
a117b0a5 16757 case 0xf0:
c7927a3c 16758 GETBYTE ();
a117b0a5 16759 switch (op[2] & 0xf0)
c7927a3c
NC		 16760 {
16761 case 0x00:
a117b0a5
YS		 16762 case 0x10:
16763 case 0x20:
16764 case 0x30:
16765 case 0x40:
16766 case 0x50:
16767 case 0x60:
16768 case 0x70:
16769 case 0x80:
16770 case 0x90:
16771 case 0xa0:
16772 case 0xb0:
16773 case 0xc0:
16774 case 0xd0:
16775 case 0xe0:
4ce8c66d 16776 goto op_semantics_139;
a117b0a5
YS		 16777 break;
16778 case 0xf0:
4ce8c66d 16779 goto op_semantics_140;
c7927a3c
NC		 16780 break;
16781 }
16782 break;
a117b0a5 16783 case 0xf1:
c7927a3c
NC		 16784 GETBYTE ();
16785 switch (op[2] & 0xf0)
16786 {
16787 case 0x00:
16788 case 0x10:
16789 case 0x20:
16790 case 0x30:
16791 case 0x40:
16792 case 0x50:
16793 case 0x60:
16794 case 0x70:
16795 case 0x80:
16796 case 0x90:
16797 case 0xa0:
16798 case 0xb0:
16799 case 0xc0:
16800 case 0xd0:
16801 case 0xe0:
4ce8c66d 16802 goto op_semantics_139;
c7927a3c
NC		 16803 break;
16804 case 0xf0:
4ce8c66d 16805 goto op_semantics_140;
c7927a3c
NC		 16806 break;
16807 }
16808 break;
a117b0a5 16809 case 0xf2:
c7927a3c
NC		 16810 GETBYTE ();
16811 switch (op[2] & 0xf0)
16812 {
16813 case 0x00:
16814 case 0x10:
16815 case 0x20:
16816 case 0x30:
16817 case 0x40:
16818 case 0x50:
16819 case 0x60:
16820 case 0x70:
16821 case 0x80:
16822 case 0x90:
16823 case 0xa0:
16824 case 0xb0:
16825 case 0xc0:
16826 case 0xd0:
16827 case 0xe0:
4ce8c66d 16828 goto op_semantics_139;
c7927a3c
NC		 16829 break;
16830 case 0xf0:
4ce8c66d 16831 goto op_semantics_140;
c7927a3c
NC		 16832 break;
16833 }
16834 break;
a117b0a5 16835 case 0xf3:
c7927a3c
NC		 16836 GETBYTE ();
16837 switch (op[2] & 0xf0)
16838 {
16839 case 0x00:
16840 case 0x10:
16841 case 0x20:
16842 case 0x30:
16843 case 0x40:
16844 case 0x50:
16845 case 0x60:
16846 case 0x70:
16847 case 0x80:
16848 case 0x90:
16849 case 0xa0:
16850 case 0xb0:
16851 case 0xc0:
16852 case 0xd0:
16853 case 0xe0:
4ce8c66d 16854 goto op_semantics_139;
c7927a3c
NC		 16855 break;
16856 case 0xf0:
4ce8c66d 16857 goto op_semantics_140;
c7927a3c
NC		 16858 break;
16859 }
16860 break;
a117b0a5 16861 case 0xf4:
c7927a3c
NC		 16862 GETBYTE ();
16863 switch (op[2] & 0xf0)
16864 {
16865 case 0x00:
16866 case 0x10:
16867 case 0x20:
16868 case 0x30:
16869 case 0x40:
16870 case 0x50:
16871 case 0x60:
16872 case 0x70:
16873 case 0x80:
16874 case 0x90:
16875 case 0xa0:
16876 case 0xb0:
16877 case 0xc0:
16878 case 0xd0:
16879 case 0xe0:
4ce8c66d 16880 goto op_semantics_139;
c7927a3c
NC		 16881 break;
16882 case 0xf0:
4ce8c66d 16883 goto op_semantics_140;
c7927a3c
NC		 16884 break;
16885 }
16886 break;
a117b0a5 16887 case 0xf5:
c7927a3c
NC		 16888 GETBYTE ();
16889 switch (op[2] & 0xf0)
16890 {
16891 case 0x00:
16892 case 0x10:
16893 case 0x20:
16894 case 0x30:
16895 case 0x40:
16896 case 0x50:
16897 case 0x60:
16898 case 0x70:
16899 case 0x80:
16900 case 0x90:
16901 case 0xa0:
16902 case 0xb0:
16903 case 0xc0:
16904 case 0xd0:
16905 case 0xe0:
4ce8c66d 16906 goto op_semantics_139;
c7927a3c
NC		 16907 break;
16908 case 0xf0:
4ce8c66d 16909 goto op_semantics_140;
c7927a3c
NC		 16910 break;
16911 }
16912 break;
a117b0a5 16913 case 0xf6:
c7927a3c
NC		 16914 GETBYTE ();
16915 switch (op[2] & 0xf0)
16916 {
16917 case 0x00:
16918 case 0x10:
16919 case 0x20:
16920 case 0x30:
16921 case 0x40:
16922 case 0x50:
16923 case 0x60:
16924 case 0x70:
16925 case 0x80:
16926 case 0x90:
16927 case 0xa0:
16928 case 0xb0:
16929 case 0xc0:
16930 case 0xd0:
16931 case 0xe0:
4ce8c66d 16932 goto op_semantics_139;
c7927a3c
NC		 16933 break;
16934 case 0xf0:
4ce8c66d 16935 goto op_semantics_140;
c7927a3c
NC		 16936 break;
16937 }
16938 break;
a117b0a5 16939 case 0xf7:
c7927a3c
NC		 16940 GETBYTE ();
16941 switch (op[2] & 0xf0)
16942 {
16943 case 0x00:
16944 case 0x10:
16945 case 0x20:
16946 case 0x30:
16947 case 0x40:
16948 case 0x50:
16949 case 0x60:
16950 case 0x70:
16951 case 0x80:
16952 case 0x90:
16953 case 0xa0:
16954 case 0xb0:
16955 case 0xc0:
16956 case 0xd0:
16957 case 0xe0:
4ce8c66d 16958 goto op_semantics_139;
c7927a3c
NC		 16959 break;
16960 case 0xf0:
4ce8c66d 16961 goto op_semantics_140;
c7927a3c
NC		 16962 break;
16963 }
16964 break;
a117b0a5 16965 case 0xf8:
c7927a3c
NC		 16966 GETBYTE ();
16967 switch (op[2] & 0xf0)
16968 {
16969 case 0x00:
16970 case 0x10:
16971 case 0x20:
16972 case 0x30:
16973 case 0x40:
16974 case 0x50:
16975 case 0x60:
16976 case 0x70:
16977 case 0x80:
16978 case 0x90:
16979 case 0xa0:
16980 case 0xb0:
16981 case 0xc0:
16982 case 0xd0:
16983 case 0xe0:
4ce8c66d 16984 goto op_semantics_139;
c7927a3c
NC		 16985 break;
16986 case 0xf0:
4ce8c66d 16987 goto op_semantics_140;
c7927a3c
NC		 16988 break;
16989 }
16990 break;
a117b0a5 16991 case 0xf9:
c7927a3c
NC		 16992 GETBYTE ();
16993 switch (op[2] & 0xf0)
16994 {
16995 case 0x00:
16996 case 0x10:
16997 case 0x20:
16998 case 0x30:
16999 case 0x40:
17000 case 0x50:
17001 case 0x60:
17002 case 0x70:
17003 case 0x80:
17004 case 0x90:
17005 case 0xa0:
17006 case 0xb0:
17007 case 0xc0:
17008 case 0xd0:
17009 case 0xe0:
4ce8c66d 17010 goto op_semantics_139;
c7927a3c
NC		 17011 break;
17012 case 0xf0:
4ce8c66d 17013 goto op_semantics_140;
c7927a3c
NC		 17014 break;
17015 }
17016 break;
a117b0a5 17017 case 0xfa:
c7927a3c
NC		 17018 GETBYTE ();
17019 switch (op[2] & 0xf0)
17020 {
17021 case 0x00:
17022 case 0x10:
17023 case 0x20:
17024 case 0x30:
17025 case 0x40:
17026 case 0x50:
17027 case 0x60:
17028 case 0x70:
17029 case 0x80:
17030 case 0x90:
17031 case 0xa0:
17032 case 0xb0:
17033 case 0xc0:
17034 case 0xd0:
17035 case 0xe0:
4ce8c66d 17036 goto op_semantics_139;
c7927a3c
NC		 17037 break;
17038 case 0xf0:
4ce8c66d 17039 goto op_semantics_140;
c7927a3c
NC		 17040 break;
17041 }
17042 break;
a117b0a5 17043 case 0xfb:
c7927a3c
NC		 17044 GETBYTE ();
17045 switch (op[2] & 0xf0)
17046 {
17047 case 0x00:
17048 case 0x10:
17049 case 0x20:
17050 case 0x30:
17051 case 0x40:
17052 case 0x50:
17053 case 0x60:
17054 case 0x70:
17055 case 0x80:
17056 case 0x90:
17057 case 0xa0:
17058 case 0xb0:
17059 case 0xc0:
17060 case 0xd0:
17061 case 0xe0:
4ce8c66d 17062 goto op_semantics_139;
c7927a3c
NC		 17063 break;
17064 case 0xf0:
4ce8c66d 17065 goto op_semantics_140;
c7927a3c
NC		 17066 break;
17067 }
17068 break;
a117b0a5 17069 case 0xfc:
c7927a3c
NC		 17070 GETBYTE ();
17071 switch (op[2] & 0xf0)
17072 {
17073 case 0x00:
17074 case 0x10:
17075 case 0x20:
17076 case 0x30:
17077 case 0x40:
17078 case 0x50:
17079 case 0x60:
17080 case 0x70:
17081 case 0x80:
17082 case 0x90:
17083 case 0xa0:
17084 case 0xb0:
17085 case 0xc0:
17086 case 0xd0:
17087 case 0xe0:
4ce8c66d 17088 goto op_semantics_139;
c7927a3c
NC		 17089 break;
17090 case 0xf0:
4ce8c66d 17091 goto op_semantics_140;
c7927a3c
NC		 17092 break;
17093 }
17094 break;
a117b0a5 17095 case 0xfd:
c7927a3c
NC		 17096 GETBYTE ();
17097 switch (op[2] & 0xf0)
17098 {
17099 case 0x00:
17100 case 0x10:
17101 case 0x20:
17102 case 0x30:
17103 case 0x40:
17104 case 0x50:
17105 case 0x60:
17106 case 0x70:
17107 case 0x80:
17108 case 0x90:
17109 case 0xa0:
17110 case 0xb0:
17111 case 0xc0:
17112 case 0xd0:
17113 case 0xe0:
4ce8c66d 17114 goto op_semantics_139;
c7927a3c
NC		 17115 break;
17116 case 0xf0:
4ce8c66d 17117 goto op_semantics_140;
c7927a3c
NC		 17118 break;
17119 }
17120 break;
a117b0a5 17121 case 0xfe:
c7927a3c
NC		 17122 GETBYTE ();
17123 switch (op[2] & 0xf0)
17124 {
17125 case 0x00:
17126 case 0x10:
17127 case 0x20:
17128 case 0x30:
17129 case 0x40:
17130 case 0x50:
17131 case 0x60:
17132 case 0x70:
17133 case 0x80:
17134 case 0x90:
17135 case 0xa0:
17136 case 0xb0:
17137 case 0xc0:
17138 case 0xd0:
17139 case 0xe0:
4ce8c66d 17140 goto op_semantics_139;
c7927a3c
NC		 17141 break;
17142 case 0xf0:
4ce8c66d 17143 goto op_semantics_140;
c7927a3c
NC		 17144 break;
17145 }
17146 break;
a117b0a5 17147 case 0xff:
c7927a3c
NC		 17148 GETBYTE ();
17149 switch (op[2] & 0xf0)
17150 {
17151 case 0x00:
17152 case 0x10:
17153 case 0x20:
17154 case 0x30:
17155 case 0x40:
17156 case 0x50:
17157 case 0x60:
17158 case 0x70:
17159 case 0x80:
17160 case 0x90:
17161 case 0xa0:
17162 case 0xb0:
17163 case 0xc0:
17164 case 0xd0:
17165 case 0xe0:
4ce8c66d 17166 goto op_semantics_139;
c7927a3c
NC		 17167 break;
17168 case 0xf0:
4ce8c66d 17169 goto op_semantics_140;
a117b0a5
YS		 17170 break;
17171 }
17172 break;
17173 default: UNSUPPORTED(); break;
17174 }
17175 break;
17176 case 0xfe:
17177 GETBYTE ();
17178 switch (op[1] & 0xff)
17179 {
17180 case 0x00:
17181 GETBYTE ();
17182 switch (op[2] & 0x00)
17183 {
17184 case 0x00:
4ce8c66d 17185 op_semantics_141:
a117b0a5
YS		 17186 {
17187 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
4ce8c66d 17188#line 363 "rx-decode.opc"
a117b0a5 17189 int sz AU = (op[1] >> 4) & 0x03;
4ce8c66d 17190#line 363 "rx-decode.opc"
a117b0a5 17191 int isrc AU = op[1] & 0x0f;
4ce8c66d 17192#line 363 "rx-decode.opc"
a117b0a5 17193 int bsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 17194#line 363 "rx-decode.opc"
a117b0a5
YS		 17195 int rdst AU = op[2] & 0x0f;
17196 if (trace)
17197 {
17198 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
17199 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
17200 op[0], op[1], op[2]);
17201 printf (" sz = 0x%x,", sz);
17202 printf (" isrc = 0x%x,", isrc);
17203 printf (" bsrc = 0x%x,", bsrc);
17204 printf (" rdst = 0x%x\n", rdst);
17205 }
17206 SYNTAX("mov%s %0, [%1, %2]");
4ce8c66d 17207#line 363 "rx-decode.opc"
a117b0a5
YS		 17208 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17209
17210 }
17211 break;
17212 }
17213 break;
17214 case 0x01:
17215 GETBYTE ();
17216 switch (op[2] & 0x00)
17217 {
17218 case 0x00:
4ce8c66d 17219 goto op_semantics_141;
a117b0a5
YS		 17220 break;
17221 }
17222 break;
17223 case 0x02:
17224 GETBYTE ();
17225 switch (op[2] & 0x00)
17226 {
17227 case 0x00:
4ce8c66d 17228 goto op_semantics_141;
a117b0a5
YS		 17229 break;
17230 }
17231 break;
17232 case 0x03:
17233 GETBYTE ();
17234 switch (op[2] & 0x00)
17235 {
17236 case 0x00:
4ce8c66d 17237 goto op_semantics_141;
a117b0a5
YS		 17238 break;
17239 }
17240 break;
17241 case 0x04:
17242 GETBYTE ();
17243 switch (op[2] & 0x00)
17244 {
17245 case 0x00:
4ce8c66d 17246 goto op_semantics_141;
a117b0a5
YS		 17247 break;
17248 }
17249 break;
17250 case 0x05:
17251 GETBYTE ();
17252 switch (op[2] & 0x00)
17253 {
17254 case 0x00:
4ce8c66d 17255 goto op_semantics_141;
a117b0a5
YS		 17256 break;
17257 }
17258 break;
17259 case 0x06:
17260 GETBYTE ();
17261 switch (op[2] & 0x00)
17262 {
17263 case 0x00:
4ce8c66d 17264 goto op_semantics_141;
a117b0a5
YS		 17265 break;
17266 }
17267 break;
17268 case 0x07:
17269 GETBYTE ();
17270 switch (op[2] & 0x00)
17271 {
17272 case 0x00:
4ce8c66d 17273 goto op_semantics_141;
a117b0a5
YS		 17274 break;
17275 }
17276 break;
17277 case 0x08:
17278 GETBYTE ();
17279 switch (op[2] & 0x00)
17280 {
17281 case 0x00:
4ce8c66d 17282 goto op_semantics_141;
a117b0a5
YS		 17283 break;
17284 }
17285 break;
17286 case 0x09:
17287 GETBYTE ();
17288 switch (op[2] & 0x00)
17289 {
17290 case 0x00:
4ce8c66d 17291 goto op_semantics_141;
a117b0a5
YS		 17292 break;
17293 }
17294 break;
17295 case 0x0a:
17296 GETBYTE ();
17297 switch (op[2] & 0x00)
17298 {
17299 case 0x00:
4ce8c66d 17300 goto op_semantics_141;
a117b0a5
YS		 17301 break;
17302 }
17303 break;
17304 case 0x0b:
17305 GETBYTE ();
17306 switch (op[2] & 0x00)
17307 {
17308 case 0x00:
4ce8c66d 17309 goto op_semantics_141;
a117b0a5
YS		 17310 break;
17311 }
17312 break;
17313 case 0x0c:
17314 GETBYTE ();
17315 switch (op[2] & 0x00)
17316 {
17317 case 0x00:
4ce8c66d 17318 goto op_semantics_141;
a117b0a5
YS		 17319 break;
17320 }
17321 break;
17322 case 0x0d:
17323 GETBYTE ();
17324 switch (op[2] & 0x00)
17325 {
17326 case 0x00:
4ce8c66d 17327 goto op_semantics_141;
a117b0a5
YS		 17328 break;
17329 }
17330 break;
17331 case 0x0e:
17332 GETBYTE ();
17333 switch (op[2] & 0x00)
17334 {
17335 case 0x00:
4ce8c66d 17336 goto op_semantics_141;
a117b0a5
YS		 17337 break;
17338 }
17339 break;
17340 case 0x0f:
17341 GETBYTE ();
17342 switch (op[2] & 0x00)
17343 {
17344 case 0x00:
4ce8c66d 17345 goto op_semantics_141;
a117b0a5
YS		 17346 break;
17347 }
17348 break;
17349 case 0x10:
17350 GETBYTE ();
17351 switch (op[2] & 0x00)
17352 {
17353 case 0x00:
4ce8c66d 17354 goto op_semantics_141;
a117b0a5
YS		 17355 break;
17356 }
17357 break;
17358 case 0x11:
17359 GETBYTE ();
17360 switch (op[2] & 0x00)
17361 {
17362 case 0x00:
4ce8c66d 17363 goto op_semantics_141;
a117b0a5
YS		 17364 break;
17365 }
17366 break;
17367 case 0x12:
17368 GETBYTE ();
17369 switch (op[2] & 0x00)
17370 {
17371 case 0x00:
4ce8c66d 17372 goto op_semantics_141;
a117b0a5
YS		 17373 break;
17374 }
17375 break;
17376 case 0x13:
17377 GETBYTE ();
17378 switch (op[2] & 0x00)
17379 {
17380 case 0x00:
4ce8c66d 17381 goto op_semantics_141;
a117b0a5
YS		 17382 break;
17383 }
17384 break;
17385 case 0x14:
17386 GETBYTE ();
17387 switch (op[2] & 0x00)
17388 {
17389 case 0x00:
4ce8c66d 17390 goto op_semantics_141;
a117b0a5
YS		 17391 break;
17392 }
17393 break;
17394 case 0x15:
17395 GETBYTE ();
17396 switch (op[2] & 0x00)
17397 {
17398 case 0x00:
4ce8c66d 17399 goto op_semantics_141;
a117b0a5
YS		 17400 break;
17401 }
17402 break;
17403 case 0x16:
17404 GETBYTE ();
17405 switch (op[2] & 0x00)
17406 {
17407 case 0x00:
4ce8c66d 17408 goto op_semantics_141;
a117b0a5
YS		 17409 break;
17410 }
17411 break;
17412 case 0x17:
17413 GETBYTE ();
17414 switch (op[2] & 0x00)
17415 {
17416 case 0x00:
4ce8c66d 17417 goto op_semantics_141;
a117b0a5
YS		 17418 break;
17419 }
17420 break;
17421 case 0x18:
17422 GETBYTE ();
17423 switch (op[2] & 0x00)
17424 {
17425 case 0x00:
4ce8c66d 17426 goto op_semantics_141;
a117b0a5
YS		 17427 break;
17428 }
17429 break;
17430 case 0x19:
17431 GETBYTE ();
17432 switch (op[2] & 0x00)
17433 {
17434 case 0x00:
4ce8c66d 17435 goto op_semantics_141;
c7927a3c
NC		 17436 break;
17437 }
17438 break;
a117b0a5 17439 case 0x1a:
c7927a3c 17440 GETBYTE ();
a117b0a5 17441 switch (op[2] & 0x00)
c7927a3c
NC		 17442 {
17443 case 0x00:
4ce8c66d 17444 goto op_semantics_141;
c7927a3c
NC		 17445 break;
17446 }
17447 break;
a117b0a5 17448 case 0x1b:
c7927a3c 17449 GETBYTE ();
a117b0a5 17450 switch (op[2] & 0x00)
c7927a3c
NC		 17451 {
17452 case 0x00:
4ce8c66d 17453 goto op_semantics_141;
c7927a3c
NC		 17454 break;
17455 }
17456 break;
a117b0a5 17457 case 0x1c:
c7927a3c 17458 GETBYTE ();
a117b0a5 17459 switch (op[2] & 0x00)
c7927a3c
NC		 17460 {
17461 case 0x00:
4ce8c66d 17462 goto op_semantics_141;
c7927a3c
NC		 17463 break;
17464 }
17465 break;
a117b0a5 17466 case 0x1d:
c7927a3c 17467 GETBYTE ();
a117b0a5 17468 switch (op[2] & 0x00)
c7927a3c
NC		 17469 {
17470 case 0x00:
4ce8c66d 17471 goto op_semantics_141;
c7927a3c
NC		 17472 break;
17473 }
17474 break;
a117b0a5 17475 case 0x1e:
c7927a3c 17476 GETBYTE ();
a117b0a5 17477 switch (op[2] & 0x00)
c7927a3c
NC		 17478 {
17479 case 0x00:
4ce8c66d 17480 goto op_semantics_141;
c7927a3c
NC		 17481 break;
17482 }
17483 break;
a117b0a5 17484 case 0x1f:
c7927a3c 17485 GETBYTE ();
a117b0a5 17486 switch (op[2] & 0x00)
c7927a3c
NC		 17487 {
17488 case 0x00:
4ce8c66d 17489 goto op_semantics_141;
c7927a3c
NC		 17490 break;
17491 }
17492 break;
a117b0a5 17493 case 0x20:
c7927a3c 17494 GETBYTE ();
a117b0a5 17495 switch (op[2] & 0x00)
c7927a3c
NC		 17496 {
17497 case 0x00:
4ce8c66d 17498 goto op_semantics_141;
c7927a3c
NC		 17499 break;
17500 }
17501 break;
a117b0a5 17502 case 0x21:
c7927a3c 17503 GETBYTE ();
a117b0a5 17504 switch (op[2] & 0x00)
c7927a3c
NC		 17505 {
17506 case 0x00:
4ce8c66d 17507 goto op_semantics_141;
c7927a3c
NC		 17508 break;
17509 }
17510 break;
a117b0a5 17511 case 0x22:
c7927a3c 17512 GETBYTE ();
a117b0a5 17513 switch (op[2] & 0x00)
c7927a3c
NC		 17514 {
17515 case 0x00:
4ce8c66d 17516 goto op_semantics_141;
c7927a3c 17517 break;
a117b0a5
YS		 17518 }
17519 break;
17520 case 0x23:
17521 GETBYTE ();
17522 switch (op[2] & 0x00)
17523 {
17524 case 0x00:
4ce8c66d 17525 goto op_semantics_141;
c7927a3c
NC		 17526 break;
17527 }
17528 break;
a117b0a5 17529 case 0x24:
c7927a3c 17530 GETBYTE ();
a117b0a5 17531 switch (op[2] & 0x00)
c7927a3c
NC		 17532 {
17533 case 0x00:
4ce8c66d 17534 goto op_semantics_141;
c7927a3c 17535 break;
a117b0a5
YS		 17536 }
17537 break;
17538 case 0x25:
17539 GETBYTE ();
17540 switch (op[2] & 0x00)
17541 {
17542 case 0x00:
4ce8c66d 17543 goto op_semantics_141;
c7927a3c
NC		 17544 break;
17545 }
17546 break;
a117b0a5 17547 case 0x26:
c7927a3c 17548 GETBYTE ();
a117b0a5 17549 switch (op[2] & 0x00)
c7927a3c
NC		 17550 {
17551 case 0x00:
4ce8c66d 17552 goto op_semantics_141;
c7927a3c 17553 break;
a117b0a5
YS		 17554 }
17555 break;
17556 case 0x27:
17557 GETBYTE ();
17558 switch (op[2] & 0x00)
17559 {
17560 case 0x00:
4ce8c66d 17561 goto op_semantics_141;
c7927a3c
NC		 17562 break;
17563 }
17564 break;
a117b0a5 17565 case 0x28:
c7927a3c 17566 GETBYTE ();
a117b0a5 17567 switch (op[2] & 0x00)
c7927a3c
NC		 17568 {
17569 case 0x00:
4ce8c66d 17570 goto op_semantics_141;
c7927a3c
NC		 17571 break;
17572 }
17573 break;
a117b0a5 17574 case 0x29:
c7927a3c 17575 GETBYTE ();
a117b0a5 17576 switch (op[2] & 0x00)
c7927a3c
NC		 17577 {
17578 case 0x00:
4ce8c66d 17579 goto op_semantics_141;
c7927a3c
NC		 17580 break;
17581 }
17582 break;
a117b0a5 17583 case 0x2a:
c7927a3c 17584 GETBYTE ();
a117b0a5 17585 switch (op[2] & 0x00)
c7927a3c
NC		 17586 {
17587 case 0x00:
4ce8c66d 17588 goto op_semantics_141;
c7927a3c
NC		 17589 break;
17590 }
17591 break;
a117b0a5 17592 case 0x2b:
c7927a3c 17593 GETBYTE ();
a117b0a5 17594 switch (op[2] & 0x00)
c7927a3c
NC		 17595 {
17596 case 0x00:
4ce8c66d 17597 goto op_semantics_141;
c7927a3c
NC		 17598 break;
17599 }
17600 break;
a117b0a5 17601 case 0x2c:
c7927a3c 17602 GETBYTE ();
a117b0a5 17603 switch (op[2] & 0x00)
c7927a3c
NC		 17604 {
17605 case 0x00:
4ce8c66d 17606 goto op_semantics_141;
c7927a3c 17607 break;
a117b0a5
YS		 17608 }
17609 break;
17610 case 0x2d:
17611 GETBYTE ();
17612 switch (op[2] & 0x00)
17613 {
17614 case 0x00:
4ce8c66d 17615 goto op_semantics_141;
c7927a3c
NC		 17616 break;
17617 }
17618 break;
a117b0a5 17619 case 0x2e:
c7927a3c 17620 GETBYTE ();
a117b0a5 17621 switch (op[2] & 0x00)
c7927a3c
NC		 17622 {
17623 case 0x00:
4ce8c66d 17624 goto op_semantics_141;
c7927a3c 17625 break;
a117b0a5
YS		 17626 }
17627 break;
17628 case 0x2f:
17629 GETBYTE ();
17630 switch (op[2] & 0x00)
17631 {
17632 case 0x00:
4ce8c66d 17633 goto op_semantics_141;
c7927a3c
NC		 17634 break;
17635 }
17636 break;
a117b0a5 17637 case 0x40:
c7927a3c
NC		 17638 GETBYTE ();
17639 switch (op[2] & 0x00)
17640 {
17641 case 0x00:
4ce8c66d 17642 op_semantics_142:
c7927a3c 17643 {
a117b0a5 17644 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
4ce8c66d 17645#line 360 "rx-decode.opc"
c7927a3c 17646 int sz AU = (op[1] >> 4) & 0x03;
4ce8c66d 17647#line 360 "rx-decode.opc"
c7927a3c 17648 int isrc AU = op[1] & 0x0f;
4ce8c66d 17649#line 360 "rx-decode.opc"
c7927a3c 17650 int bsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 17651#line 360 "rx-decode.opc"
c7927a3c
NC		 17652 int rdst AU = op[2] & 0x0f;
17653 if (trace)
17654 {
17655 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 17656 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
c7927a3c
NC		 17657 op[0], op[1], op[2]);
17658 printf (" sz = 0x%x,", sz);
17659 printf (" isrc = 0x%x,", isrc);
17660 printf (" bsrc = 0x%x,", bsrc);
17661 printf (" rdst = 0x%x\n", rdst);
17662 }
a117b0a5 17663 SYNTAX("mov%s [%1, %2], %0");
4ce8c66d 17664#line 360 "rx-decode.opc"
a117b0a5 17665 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
43e65147 17666
c7927a3c
NC		 17667 }
17668 break;
17669 }
17670 break;
a117b0a5 17671 case 0x41:
c7927a3c
NC		 17672 GETBYTE ();
17673 switch (op[2] & 0x00)
17674 {
17675 case 0x00:
4ce8c66d 17676 goto op_semantics_142;
c7927a3c
NC		 17677 break;
17678 }
17679 break;
a117b0a5 17680 case 0x42:
c7927a3c
NC		 17681 GETBYTE ();
17682 switch (op[2] & 0x00)
17683 {
17684 case 0x00:
4ce8c66d 17685 goto op_semantics_142;
c7927a3c
NC		 17686 break;
17687 }
17688 break;
a117b0a5 17689 case 0x43:
c7927a3c
NC		 17690 GETBYTE ();
17691 switch (op[2] & 0x00)
17692 {
17693 case 0x00:
4ce8c66d 17694 goto op_semantics_142;
c7927a3c
NC		 17695 break;
17696 }
17697 break;
a117b0a5 17698 case 0x44:
c7927a3c
NC		 17699 GETBYTE ();
17700 switch (op[2] & 0x00)
17701 {
17702 case 0x00:
4ce8c66d 17703 goto op_semantics_142;
c7927a3c
NC		 17704 break;
17705 }
17706 break;
a117b0a5 17707 case 0x45:
c7927a3c
NC		 17708 GETBYTE ();
17709 switch (op[2] & 0x00)
17710 {
17711 case 0x00:
4ce8c66d 17712 goto op_semantics_142;
c7927a3c
NC		 17713 break;
17714 }
17715 break;
a117b0a5 17716 case 0x46:
c7927a3c
NC		 17717 GETBYTE ();
17718 switch (op[2] & 0x00)
17719 {
17720 case 0x00:
4ce8c66d 17721 goto op_semantics_142;
c7927a3c
NC		 17722 break;
17723 }
17724 break;
a117b0a5 17725 case 0x47:
c7927a3c
NC		 17726 GETBYTE ();
17727 switch (op[2] & 0x00)
17728 {
17729 case 0x00:
4ce8c66d 17730 goto op_semantics_142;
c7927a3c
NC		 17731 break;
17732 }
17733 break;
a117b0a5 17734 case 0x48:
c7927a3c
NC		 17735 GETBYTE ();
17736 switch (op[2] & 0x00)
17737 {
17738 case 0x00:
4ce8c66d 17739 goto op_semantics_142;
c7927a3c
NC		 17740 break;
17741 }
17742 break;
a117b0a5 17743 case 0x49:
c7927a3c
NC		 17744 GETBYTE ();
17745 switch (op[2] & 0x00)
17746 {
17747 case 0x00:
4ce8c66d 17748 goto op_semantics_142;
c7927a3c
NC		 17749 break;
17750 }
17751 break;
a117b0a5 17752 case 0x4a:
c7927a3c
NC		 17753 GETBYTE ();
17754 switch (op[2] & 0x00)
17755 {
17756 case 0x00:
4ce8c66d 17757 goto op_semantics_142;
c7927a3c
NC		 17758 break;
17759 }
17760 break;
a117b0a5 17761 case 0x4b:
c7927a3c
NC		 17762 GETBYTE ();
17763 switch (op[2] & 0x00)
17764 {
17765 case 0x00:
4ce8c66d 17766 goto op_semantics_142;
c7927a3c
NC		 17767 break;
17768 }
17769 break;
a117b0a5 17770 case 0x4c:
c7927a3c
NC		 17771 GETBYTE ();
17772 switch (op[2] & 0x00)
17773 {
17774 case 0x00:
4ce8c66d 17775 goto op_semantics_142;
c7927a3c
NC		 17776 break;
17777 }
17778 break;
a117b0a5 17779 case 0x4d:
c7927a3c
NC		 17780 GETBYTE ();
17781 switch (op[2] & 0x00)
17782 {
17783 case 0x00:
4ce8c66d 17784 goto op_semantics_142;
c7927a3c
NC		 17785 break;
17786 }
17787 break;
a117b0a5 17788 case 0x4e:
c7927a3c
NC		 17789 GETBYTE ();
17790 switch (op[2] & 0x00)
17791 {
17792 case 0x00:
4ce8c66d 17793 goto op_semantics_142;
c7927a3c
NC		 17794 break;
17795 }
17796 break;
a117b0a5 17797 case 0x4f:
c7927a3c
NC		 17798 GETBYTE ();
17799 switch (op[2] & 0x00)
17800 {
17801 case 0x00:
4ce8c66d 17802 goto op_semantics_142;
c7927a3c
NC		 17803 break;
17804 }
17805 break;
a117b0a5 17806 case 0x50:
c7927a3c
NC		 17807 GETBYTE ();
17808 switch (op[2] & 0x00)
17809 {
17810 case 0x00:
4ce8c66d 17811 goto op_semantics_142;
c7927a3c
NC		 17812 break;
17813 }
17814 break;
a117b0a5 17815 case 0x51:
c7927a3c
NC		 17816 GETBYTE ();
17817 switch (op[2] & 0x00)
17818 {
17819 case 0x00:
4ce8c66d 17820 goto op_semantics_142;
c7927a3c
NC		 17821 break;
17822 }
17823 break;
a117b0a5 17824 case 0x52:
c7927a3c
NC		 17825 GETBYTE ();
17826 switch (op[2] & 0x00)
17827 {
17828 case 0x00:
4ce8c66d 17829 goto op_semantics_142;
c7927a3c
NC		 17830 break;
17831 }
17832 break;
a117b0a5 17833 case 0x53:
c7927a3c
NC		 17834 GETBYTE ();
17835 switch (op[2] & 0x00)
17836 {
17837 case 0x00:
4ce8c66d 17838 goto op_semantics_142;
c7927a3c
NC		 17839 break;
17840 }
17841 break;
a117b0a5 17842 case 0x54:
c7927a3c
NC		 17843 GETBYTE ();
17844 switch (op[2] & 0x00)
17845 {
17846 case 0x00:
4ce8c66d 17847 goto op_semantics_142;
c7927a3c
NC		 17848 break;
17849 }
17850 break;
a117b0a5 17851 case 0x55:
c7927a3c
NC		 17852 GETBYTE ();
17853 switch (op[2] & 0x00)
17854 {
17855 case 0x00:
4ce8c66d 17856 goto op_semantics_142;
c7927a3c
NC		 17857 break;
17858 }
17859 break;
a117b0a5 17860 case 0x56:
c7927a3c
NC		 17861 GETBYTE ();
17862 switch (op[2] & 0x00)
17863 {
17864 case 0x00:
4ce8c66d 17865 goto op_semantics_142;
c7927a3c
NC		 17866 break;
17867 }
17868 break;
a117b0a5 17869 case 0x57:
c7927a3c
NC		 17870 GETBYTE ();
17871 switch (op[2] & 0x00)
17872 {
17873 case 0x00:
4ce8c66d 17874 goto op_semantics_142;
c7927a3c
NC		 17875 break;
17876 }
17877 break;
a117b0a5 17878 case 0x58:
c7927a3c
NC		 17879 GETBYTE ();
17880 switch (op[2] & 0x00)
17881 {
17882 case 0x00:
4ce8c66d 17883 goto op_semantics_142;
c7927a3c
NC		 17884 break;
17885 }
17886 break;
a117b0a5 17887 case 0x59:
c7927a3c
NC		 17888 GETBYTE ();
17889 switch (op[2] & 0x00)
17890 {
17891 case 0x00:
4ce8c66d 17892 goto op_semantics_142;
c7927a3c
NC		 17893 break;
17894 }
17895 break;
a117b0a5 17896 case 0x5a:
c7927a3c
NC		 17897 GETBYTE ();
17898 switch (op[2] & 0x00)
17899 {
17900 case 0x00:
4ce8c66d 17901 goto op_semantics_142;
c7927a3c
NC		 17902 break;
17903 }
17904 break;
a117b0a5 17905 case 0x5b:
c7927a3c
NC		 17906 GETBYTE ();
17907 switch (op[2] & 0x00)
17908 {
17909 case 0x00:
4ce8c66d 17910 goto op_semantics_142;
c7927a3c
NC		 17911 break;
17912 }
17913 break;
a117b0a5 17914 case 0x5c:
c7927a3c
NC		 17915 GETBYTE ();
17916 switch (op[2] & 0x00)
17917 {
17918 case 0x00:
4ce8c66d 17919 goto op_semantics_142;
c7927a3c
NC		 17920 break;
17921 }
17922 break;
a117b0a5 17923 case 0x5d:
c7927a3c
NC		 17924 GETBYTE ();
17925 switch (op[2] & 0x00)
17926 {
17927 case 0x00:
4ce8c66d 17928 goto op_semantics_142;
c7927a3c
NC		 17929 break;
17930 }
17931 break;
a117b0a5 17932 case 0x5e:
c7927a3c
NC		 17933 GETBYTE ();
17934 switch (op[2] & 0x00)
17935 {
17936 case 0x00:
4ce8c66d 17937 goto op_semantics_142;
c7927a3c
NC		 17938 break;
17939 }
17940 break;
a117b0a5 17941 case 0x5f:
c7927a3c
NC		 17942 GETBYTE ();
17943 switch (op[2] & 0x00)
17944 {
17945 case 0x00:
4ce8c66d 17946 goto op_semantics_142;
c7927a3c
NC		 17947 break;
17948 }
17949 break;
a117b0a5 17950 case 0x60:
c7927a3c
NC		 17951 GETBYTE ();
17952 switch (op[2] & 0x00)
17953 {
17954 case 0x00:
4ce8c66d 17955 goto op_semantics_142;
c7927a3c
NC		 17956 break;
17957 }
17958 break;
a117b0a5 17959 case 0x61:
c7927a3c
NC		 17960 GETBYTE ();
17961 switch (op[2] & 0x00)
17962 {
17963 case 0x00:
4ce8c66d 17964 goto op_semantics_142;
c7927a3c
NC		 17965 break;
17966 }
17967 break;
a117b0a5 17968 case 0x62:
c7927a3c
NC		 17969 GETBYTE ();
17970 switch (op[2] & 0x00)
17971 {
17972 case 0x00:
4ce8c66d 17973 goto op_semantics_142;
c7927a3c
NC		 17974 break;
17975 }
17976 break;
a117b0a5 17977 case 0x63:
c7927a3c
NC		 17978 GETBYTE ();
17979 switch (op[2] & 0x00)
17980 {
17981 case 0x00:
4ce8c66d 17982 goto op_semantics_142;
c7927a3c
NC		 17983 break;
17984 }
17985 break;
a117b0a5 17986 case 0x64:
c7927a3c
NC		 17987 GETBYTE ();
17988 switch (op[2] & 0x00)
17989 {
17990 case 0x00:
4ce8c66d 17991 goto op_semantics_142;
c7927a3c
NC		 17992 break;
17993 }
17994 break;
a117b0a5 17995 case 0x65:
c7927a3c
NC		 17996 GETBYTE ();
17997 switch (op[2] & 0x00)
17998 {
17999 case 0x00:
4ce8c66d 18000 goto op_semantics_142;
c7927a3c
NC		 18001 break;
18002 }
18003 break;
a117b0a5 18004 case 0x66:
c7927a3c
NC		 18005 GETBYTE ();
18006 switch (op[2] & 0x00)
18007 {
18008 case 0x00:
4ce8c66d 18009 goto op_semantics_142;
c7927a3c
NC		 18010 break;
18011 }
18012 break;
a117b0a5 18013 case 0x67:
c7927a3c
NC		 18014 GETBYTE ();
18015 switch (op[2] & 0x00)
18016 {
18017 case 0x00:
4ce8c66d 18018 goto op_semantics_142;
c7927a3c
NC		 18019 break;
18020 }
18021 break;
a117b0a5 18022 case 0x68:
c7927a3c
NC		 18023 GETBYTE ();
18024 switch (op[2] & 0x00)
18025 {
18026 case 0x00:
4ce8c66d 18027 goto op_semantics_142;
c7927a3c
NC		 18028 break;
18029 }
18030 break;
a117b0a5 18031 case 0x69:
c7927a3c
NC		 18032 GETBYTE ();
18033 switch (op[2] & 0x00)
18034 {
18035 case 0x00:
4ce8c66d 18036 goto op_semantics_142;
c7927a3c
NC		 18037 break;
18038 }
18039 break;
a117b0a5 18040 case 0x6a:
c7927a3c
NC		 18041 GETBYTE ();
18042 switch (op[2] & 0x00)
18043 {
18044 case 0x00:
4ce8c66d 18045 goto op_semantics_142;
c7927a3c
NC		 18046 break;
18047 }
18048 break;
a117b0a5 18049 case 0x6b:
c7927a3c
NC		 18050 GETBYTE ();
18051 switch (op[2] & 0x00)
18052 {
18053 case 0x00:
4ce8c66d 18054 goto op_semantics_142;
c7927a3c
NC		 18055 break;
18056 }
18057 break;
a117b0a5 18058 case 0x6c:
c7927a3c
NC		 18059 GETBYTE ();
18060 switch (op[2] & 0x00)
18061 {
18062 case 0x00:
4ce8c66d 18063 goto op_semantics_142;
c7927a3c
NC		 18064 break;
18065 }
18066 break;
a117b0a5 18067 case 0x6d:
c7927a3c
NC		 18068 GETBYTE ();
18069 switch (op[2] & 0x00)
18070 {
18071 case 0x00:
4ce8c66d 18072 goto op_semantics_142;
c7927a3c
NC		 18073 break;
18074 }
18075 break;
a117b0a5 18076 case 0x6e:
c7927a3c
NC		 18077 GETBYTE ();
18078 switch (op[2] & 0x00)
18079 {
18080 case 0x00:
4ce8c66d 18081 goto op_semantics_142;
c7927a3c
NC		 18082 break;
18083 }
18084 break;
a117b0a5 18085 case 0x6f:
c7927a3c
NC		 18086 GETBYTE ();
18087 switch (op[2] & 0x00)
18088 {
18089 case 0x00:
4ce8c66d 18090 goto op_semantics_142;
c7927a3c
NC		 18091 break;
18092 }
18093 break;
a117b0a5 18094 case 0xc0:
c7927a3c
NC		 18095 GETBYTE ();
18096 switch (op[2] & 0x00)
18097 {
18098 case 0x00:
4ce8c66d 18099 op_semantics_143:
c7927a3c 18100 {
a117b0a5 18101 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
4ce8c66d 18102#line 366 "rx-decode.opc"
c7927a3c 18103 int sz AU = (op[1] >> 4) & 0x03;
4ce8c66d 18104#line 366 "rx-decode.opc"
c7927a3c 18105 int isrc AU = op[1] & 0x0f;
4ce8c66d 18106#line 366 "rx-decode.opc"
c7927a3c 18107 int bsrc AU = (op[2] >> 4) & 0x0f;
4ce8c66d 18108#line 366 "rx-decode.opc"
c7927a3c
NC		 18109 int rdst AU = op[2] & 0x0f;
18110 if (trace)
18111 {
18112 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 18113 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
c7927a3c
NC		 18114 op[0], op[1], op[2]);
18115 printf (" sz = 0x%x,", sz);
18116 printf (" isrc = 0x%x,", isrc);
18117 printf (" bsrc = 0x%x,", bsrc);
18118 printf (" rdst = 0x%x\n", rdst);
18119 }
a117b0a5 18120 SYNTAX("movu%s [%1, %2], %0");
4ce8c66d 18121#line 366 "rx-decode.opc"
a117b0a5 18122 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
43e65147 18123
c7927a3c
NC		 18124 }
18125 break;
18126 }
18127 break;
a117b0a5 18128 case 0xc1:
c7927a3c
NC		 18129 GETBYTE ();
18130 switch (op[2] & 0x00)
18131 {
18132 case 0x00:
4ce8c66d 18133 goto op_semantics_143;
c7927a3c
NC		 18134 break;
18135 }
18136 break;
a117b0a5 18137 case 0xc2:
c7927a3c
NC		 18138 GETBYTE ();
18139 switch (op[2] & 0x00)
18140 {
18141 case 0x00:
4ce8c66d 18142 goto op_semantics_143;
c7927a3c
NC		 18143 break;
18144 }
18145 break;
a117b0a5 18146 case 0xc3:
c7927a3c
NC		 18147 GETBYTE ();
18148 switch (op[2] & 0x00)
18149 {
18150 case 0x00:
4ce8c66d 18151 goto op_semantics_143;
c7927a3c
NC		 18152 break;
18153 }
18154 break;
a117b0a5 18155 case 0xc4:
c7927a3c
NC		 18156 GETBYTE ();
18157 switch (op[2] & 0x00)
18158 {
18159 case 0x00:
4ce8c66d 18160 goto op_semantics_143;
c7927a3c
NC		 18161 break;
18162 }
18163 break;
a117b0a5 18164 case 0xc5:
c7927a3c
NC		 18165 GETBYTE ();
18166 switch (op[2] & 0x00)
18167 {
18168 case 0x00:
4ce8c66d 18169 goto op_semantics_143;
c7927a3c
NC		 18170 break;
18171 }
18172 break;
a117b0a5 18173 case 0xc6:
c7927a3c
NC		 18174 GETBYTE ();
18175 switch (op[2] & 0x00)
18176 {
18177 case 0x00:
4ce8c66d 18178 goto op_semantics_143;
c7927a3c
NC		 18179 break;
18180 }
18181 break;
a117b0a5 18182 case 0xc7:
c7927a3c
NC		 18183 GETBYTE ();
18184 switch (op[2] & 0x00)
18185 {
18186 case 0x00:
4ce8c66d 18187 goto op_semantics_143;
c7927a3c
NC		 18188 break;
18189 }
18190 break;
a117b0a5 18191 case 0xc8:
c7927a3c
NC		 18192 GETBYTE ();
18193 switch (op[2] & 0x00)
18194 {
18195 case 0x00:
4ce8c66d 18196 goto op_semantics_143;
c7927a3c
NC		 18197 break;
18198 }
18199 break;
a117b0a5 18200 case 0xc9:
c7927a3c
NC		 18201 GETBYTE ();
18202 switch (op[2] & 0x00)
18203 {
18204 case 0x00:
4ce8c66d 18205 goto op_semantics_143;
c7927a3c
NC		 18206 break;
18207 }
18208 break;
a117b0a5 18209 case 0xca:
c7927a3c
NC		 18210 GETBYTE ();
18211 switch (op[2] & 0x00)
18212 {
18213 case 0x00:
4ce8c66d 18214 goto op_semantics_143;
c7927a3c
NC		 18215 break;
18216 }
18217 break;
a117b0a5 18218 case 0xcb:
c7927a3c
NC		 18219 GETBYTE ();
18220 switch (op[2] & 0x00)
18221 {
18222 case 0x00:
4ce8c66d 18223 goto op_semantics_143;
c7927a3c
NC		 18224 break;
18225 }
18226 break;
a117b0a5 18227 case 0xcc:
c7927a3c
NC		 18228 GETBYTE ();
18229 switch (op[2] & 0x00)
18230 {
18231 case 0x00:
4ce8c66d 18232 goto op_semantics_143;
c7927a3c
NC		 18233 break;
18234 }
18235 break;
a117b0a5 18236 case 0xcd:
c7927a3c
NC		 18237 GETBYTE ();
18238 switch (op[2] & 0x00)
18239 {
18240 case 0x00:
4ce8c66d 18241 goto op_semantics_143;
c7927a3c
NC		 18242 break;
18243 }
18244 break;
a117b0a5 18245 case 0xce:
c7927a3c
NC		 18246 GETBYTE ();
18247 switch (op[2] & 0x00)
18248 {
18249 case 0x00:
4ce8c66d 18250 goto op_semantics_143;
c7927a3c
NC		 18251 break;
18252 }
18253 break;
a117b0a5 18254 case 0xcf:
c7927a3c
NC		 18255 GETBYTE ();
18256 switch (op[2] & 0x00)
18257 {
18258 case 0x00:
4ce8c66d 18259 goto op_semantics_143;
c7927a3c
NC		 18260 break;
18261 }
18262 break;
a117b0a5 18263 case 0xd0:
c7927a3c
NC		 18264 GETBYTE ();
18265 switch (op[2] & 0x00)
18266 {
18267 case 0x00:
4ce8c66d 18268 goto op_semantics_143;
c7927a3c
NC		 18269 break;
18270 }
18271 break;
a117b0a5 18272 case 0xd1:
c7927a3c
NC		 18273 GETBYTE ();
18274 switch (op[2] & 0x00)
18275 {
18276 case 0x00:
4ce8c66d 18277 goto op_semantics_143;
c7927a3c
NC		 18278 break;
18279 }
18280 break;
a117b0a5 18281 case 0xd2:
c7927a3c
NC		 18282 GETBYTE ();
18283 switch (op[2] & 0x00)
18284 {
18285 case 0x00:
4ce8c66d 18286 goto op_semantics_143;
c7927a3c
NC		 18287 break;
18288 }
18289 break;
a117b0a5 18290 case 0xd3:
c7927a3c
NC		 18291 GETBYTE ();
18292 switch (op[2] & 0x00)
18293 {
18294 case 0x00:
4ce8c66d 18295 goto op_semantics_143;
c7927a3c
NC		 18296 break;
18297 }
18298 break;
a117b0a5 18299 case 0xd4:
c7927a3c
NC		 18300 GETBYTE ();
18301 switch (op[2] & 0x00)
18302 {
18303 case 0x00:
4ce8c66d 18304 goto op_semantics_143;
c7927a3c
NC		 18305 break;
18306 }
18307 break;
a117b0a5 18308 case 0xd5:
c7927a3c
NC		 18309 GETBYTE ();
18310 switch (op[2] & 0x00)
18311 {
18312 case 0x00:
4ce8c66d 18313 goto op_semantics_143;
c7927a3c
NC		 18314 break;
18315 }
18316 break;
a117b0a5 18317 case 0xd6:
c7927a3c
NC		 18318 GETBYTE ();
18319 switch (op[2] & 0x00)
18320 {
18321 case 0x00:
4ce8c66d 18322 goto op_semantics_143;
c7927a3c
NC		 18323 break;
18324 }
18325 break;
a117b0a5 18326 case 0xd7:
c7927a3c
NC		 18327 GETBYTE ();
18328 switch (op[2] & 0x00)
18329 {
18330 case 0x00:
4ce8c66d 18331 goto op_semantics_143;
c7927a3c
NC		 18332 break;
18333 }
18334 break;
a117b0a5 18335 case 0xd8:
c7927a3c
NC		 18336 GETBYTE ();
18337 switch (op[2] & 0x00)
18338 {
18339 case 0x00:
4ce8c66d 18340 goto op_semantics_143;
c7927a3c
NC		 18341 break;
18342 }
18343 break;
a117b0a5 18344 case 0xd9:
c7927a3c
NC		 18345 GETBYTE ();
18346 switch (op[2] & 0x00)
18347 {
18348 case 0x00:
4ce8c66d 18349 goto op_semantics_143;
c7927a3c
NC		 18350 break;
18351 }
18352 break;
a117b0a5 18353 case 0xda:
c7927a3c
NC		 18354 GETBYTE ();
18355 switch (op[2] & 0x00)
18356 {
18357 case 0x00:
4ce8c66d 18358 goto op_semantics_143;
c7927a3c
NC		 18359 break;
18360 }
18361 break;
a117b0a5 18362 case 0xdb:
c7927a3c
NC		 18363 GETBYTE ();
18364 switch (op[2] & 0x00)
18365 {
18366 case 0x00:
4ce8c66d 18367 goto op_semantics_143;
c7927a3c
NC		 18368 break;
18369 }
18370 break;
a117b0a5 18371 case 0xdc:
c7927a3c
NC		 18372 GETBYTE ();
18373 switch (op[2] & 0x00)
18374 {
18375 case 0x00:
4ce8c66d 18376 goto op_semantics_143;
c7927a3c
NC		 18377 break;
18378 }
18379 break;
a117b0a5 18380 case 0xdd:
c7927a3c
NC		 18381 GETBYTE ();
18382 switch (op[2] & 0x00)
18383 {
18384 case 0x00:
4ce8c66d 18385 goto op_semantics_143;
c7927a3c
NC		 18386 break;
18387 }
18388 break;
a117b0a5 18389 case 0xde:
c7927a3c
NC		 18390 GETBYTE ();
18391 switch (op[2] & 0x00)
18392 {
18393 case 0x00:
4ce8c66d 18394 goto op_semantics_143;
c7927a3c
NC		 18395 break;
18396 }
18397 break;
a117b0a5 18398 case 0xdf:
c7927a3c
NC		 18399 GETBYTE ();
18400 switch (op[2] & 0x00)
18401 {
18402 case 0x00:
4ce8c66d 18403 goto op_semantics_143;
c7927a3c
NC		 18404 break;
18405 }
18406 break;
a117b0a5 18407 case 0xe0:
c7927a3c
NC		 18408 GETBYTE ();
18409 switch (op[2] & 0x00)
18410 {
18411 case 0x00:
4ce8c66d 18412 goto op_semantics_143;
c7927a3c
NC		 18413 break;
18414 }
18415 break;
a117b0a5 18416 case 0xe1:
c7927a3c
NC		 18417 GETBYTE ();
18418 switch (op[2] & 0x00)
18419 {
18420 case 0x00:
4ce8c66d 18421 goto op_semantics_143;
c7927a3c
NC		 18422 break;
18423 }
18424 break;
a117b0a5 18425 case 0xe2:
c7927a3c
NC		 18426 GETBYTE ();
18427 switch (op[2] & 0x00)
18428 {
18429 case 0x00:
4ce8c66d 18430 goto op_semantics_143;
c7927a3c
NC		 18431 break;
18432 }
18433 break;
a117b0a5 18434 case 0xe3:
c7927a3c
NC		 18435 GETBYTE ();
18436 switch (op[2] & 0x00)
18437 {
18438 case 0x00:
4ce8c66d 18439 goto op_semantics_143;
c7927a3c
NC		 18440 break;
18441 }
18442 break;
a117b0a5 18443 case 0xe4:
c7927a3c
NC		 18444 GETBYTE ();
18445 switch (op[2] & 0x00)
18446 {
18447 case 0x00:
4ce8c66d 18448 goto op_semantics_143;
c7927a3c
NC		 18449 break;
18450 }
18451 break;
a117b0a5 18452 case 0xe5:
c7927a3c
NC		 18453 GETBYTE ();
18454 switch (op[2] & 0x00)
18455 {
18456 case 0x00:
4ce8c66d 18457 goto op_semantics_143;
c7927a3c
NC		 18458 break;
18459 }
18460 break;
a117b0a5 18461 case 0xe6:
c7927a3c
NC		 18462 GETBYTE ();
18463 switch (op[2] & 0x00)
18464 {
18465 case 0x00:
4ce8c66d 18466 goto op_semantics_143;
c7927a3c
NC		 18467 break;
18468 }
18469 break;
a117b0a5 18470 case 0xe7:
c7927a3c
NC		 18471 GETBYTE ();
18472 switch (op[2] & 0x00)
18473 {
18474 case 0x00:
4ce8c66d 18475 goto op_semantics_143;
c7927a3c
NC		 18476 break;
18477 }
18478 break;
a117b0a5 18479 case 0xe8:
c7927a3c
NC		 18480 GETBYTE ();
18481 switch (op[2] & 0x00)
18482 {
18483 case 0x00:
4ce8c66d 18484 goto op_semantics_143;
c7927a3c
NC		 18485 break;
18486 }
18487 break;
a117b0a5 18488 case 0xe9:
c7927a3c
NC		 18489 GETBYTE ();
18490 switch (op[2] & 0x00)
18491 {
18492 case 0x00:
4ce8c66d 18493 goto op_semantics_143;
c7927a3c
NC		 18494 break;
18495 }
18496 break;
a117b0a5 18497 case 0xea:
c7927a3c
NC		 18498 GETBYTE ();
18499 switch (op[2] & 0x00)
18500 {
18501 case 0x00:
4ce8c66d 18502 goto op_semantics_143;
c7927a3c
NC		 18503 break;
18504 }
18505 break;
a117b0a5 18506 case 0xeb:
c7927a3c
NC		 18507 GETBYTE ();
18508 switch (op[2] & 0x00)
18509 {
18510 case 0x00:
4ce8c66d 18511 goto op_semantics_143;
c7927a3c
NC		 18512 break;
18513 }
18514 break;
a117b0a5 18515 case 0xec:
c7927a3c
NC		 18516 GETBYTE ();
18517 switch (op[2] & 0x00)
18518 {
18519 case 0x00:
4ce8c66d 18520 goto op_semantics_143;
c7927a3c
NC		 18521 break;
18522 }
18523 break;
a117b0a5 18524 case 0xed:
c7927a3c
NC		 18525 GETBYTE ();
18526 switch (op[2] & 0x00)
18527 {
18528 case 0x00:
4ce8c66d 18529 goto op_semantics_143;
c7927a3c
NC		 18530 break;
18531 }
18532 break;
a117b0a5 18533 case 0xee:
c7927a3c
NC		 18534 GETBYTE ();
18535 switch (op[2] & 0x00)
18536 {
18537 case 0x00:
4ce8c66d 18538 goto op_semantics_143;
c7927a3c
NC		 18539 break;
18540 }
18541 break;
a117b0a5 18542 case 0xef:
c7927a3c
NC		 18543 GETBYTE ();
18544 switch (op[2] & 0x00)
18545 {
18546 case 0x00:
4ce8c66d 18547 goto op_semantics_143;
c7927a3c
NC		 18548 break;
18549 }
18550 break;
a117b0a5
YS		 18551 default: UNSUPPORTED(); break;
18552 }
18553 break;
18554 case 0xff:
18555 GETBYTE ();
18556 switch (op[1] & 0xff)
18557 {
18558 case 0x00:
c7927a3c
NC		 18559 GETBYTE ();
18560 switch (op[2] & 0x00)
18561 {
18562 case 0x00:
4ce8c66d 18563 op_semantics_144:
c7927a3c 18564 {
a117b0a5 18565 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
4ce8c66d 18566#line 570 "rx-decode.opc"
a117b0a5 18567 int rdst AU = op[1] & 0x0f;
4ce8c66d 18568#line 570 "rx-decode.opc"
a117b0a5 18569 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 18570#line 570 "rx-decode.opc"
a117b0a5 18571 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 18572 if (trace)
18573 {
18574 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5
YS		 18575 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
18576 op[0], op[1], op[2]);
18577 printf (" rdst = 0x%x,", rdst);
18578 printf (" srca = 0x%x,", srca);
18579 printf (" srcb = 0x%x\n", srcb);
c7927a3c 18580 }
a117b0a5 18581 SYNTAX("sub %2, %1, %0");
4ce8c66d 18582#line 570 "rx-decode.opc"
a117b0a5
YS		 18583 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18584
18585 /*----------------------------------------------------------------------*/
18586 /* SBB */
43e65147 18587
c7927a3c
NC		 18588 }
18589 break;
18590 }
18591 break;
a117b0a5 18592 case 0x01:
c7927a3c
NC		 18593 GETBYTE ();
18594 switch (op[2] & 0x00)
18595 {
18596 case 0x00:
4ce8c66d 18597 goto op_semantics_144;
c7927a3c
NC		 18598 break;
18599 }
18600 break;
a117b0a5 18601 case 0x02:
c7927a3c
NC		 18602 GETBYTE ();
18603 switch (op[2] & 0x00)
18604 {
18605 case 0x00:
4ce8c66d 18606 goto op_semantics_144;
c7927a3c
NC		 18607 break;
18608 }
18609 break;
a117b0a5 18610 case 0x03:
c7927a3c
NC		 18611 GETBYTE ();
18612 switch (op[2] & 0x00)
18613 {
18614 case 0x00:
4ce8c66d 18615 goto op_semantics_144;
c7927a3c
NC		 18616 break;
18617 }
18618 break;
a117b0a5 18619 case 0x04:
c7927a3c
NC		 18620 GETBYTE ();
18621 switch (op[2] & 0x00)
18622 {
18623 case 0x00:
4ce8c66d 18624 goto op_semantics_144;
c7927a3c
NC		 18625 break;
18626 }
18627 break;
a117b0a5 18628 case 0x05:
c7927a3c
NC		 18629 GETBYTE ();
18630 switch (op[2] & 0x00)
18631 {
18632 case 0x00:
4ce8c66d 18633 goto op_semantics_144;
c7927a3c
NC		 18634 break;
18635 }
18636 break;
a117b0a5 18637 case 0x06:
c7927a3c
NC		 18638 GETBYTE ();
18639 switch (op[2] & 0x00)
18640 {
18641 case 0x00:
4ce8c66d 18642 goto op_semantics_144;
c7927a3c
NC		 18643 break;
18644 }
18645 break;
a117b0a5 18646 case 0x07:
c7927a3c
NC		 18647 GETBYTE ();
18648 switch (op[2] & 0x00)
18649 {
18650 case 0x00:
4ce8c66d 18651 goto op_semantics_144;
c7927a3c
NC		 18652 break;
18653 }
18654 break;
a117b0a5 18655 case 0x08:
c7927a3c
NC		 18656 GETBYTE ();
18657 switch (op[2] & 0x00)
18658 {
18659 case 0x00:
4ce8c66d 18660 goto op_semantics_144;
c7927a3c
NC		 18661 break;
18662 }
18663 break;
a117b0a5 18664 case 0x09:
c7927a3c
NC		 18665 GETBYTE ();
18666 switch (op[2] & 0x00)
18667 {
18668 case 0x00:
4ce8c66d 18669 goto op_semantics_144;
c7927a3c
NC		 18670 break;
18671 }
18672 break;
a117b0a5 18673 case 0x0a:
c7927a3c
NC		 18674 GETBYTE ();
18675 switch (op[2] & 0x00)
18676 {
18677 case 0x00:
4ce8c66d 18678 goto op_semantics_144;
c7927a3c
NC		 18679 break;
18680 }
18681 break;
a117b0a5 18682 case 0x0b:
c7927a3c
NC		 18683 GETBYTE ();
18684 switch (op[2] & 0x00)
18685 {
18686 case 0x00:
4ce8c66d 18687 goto op_semantics_144;
c7927a3c
NC		 18688 break;
18689 }
18690 break;
a117b0a5 18691 case 0x0c:
c7927a3c
NC		 18692 GETBYTE ();
18693 switch (op[2] & 0x00)
18694 {
18695 case 0x00:
4ce8c66d 18696 goto op_semantics_144;
c7927a3c
NC		 18697 break;
18698 }
18699 break;
a117b0a5 18700 case 0x0d:
c7927a3c
NC		 18701 GETBYTE ();
18702 switch (op[2] & 0x00)
18703 {
18704 case 0x00:
4ce8c66d 18705 goto op_semantics_144;
c7927a3c
NC		 18706 break;
18707 }
18708 break;
a117b0a5 18709 case 0x0e:
c7927a3c
NC		 18710 GETBYTE ();
18711 switch (op[2] & 0x00)
18712 {
18713 case 0x00:
4ce8c66d 18714 goto op_semantics_144;
c7927a3c
NC		 18715 break;
18716 }
18717 break;
a117b0a5 18718 case 0x0f:
c7927a3c
NC		 18719 GETBYTE ();
18720 switch (op[2] & 0x00)
18721 {
18722 case 0x00:
4ce8c66d 18723 goto op_semantics_144;
c7927a3c
NC		 18724 break;
18725 }
18726 break;
a117b0a5 18727 case 0x20:
c7927a3c
NC		 18728 GETBYTE ();
18729 switch (op[2] & 0x00)
18730 {
18731 case 0x00:
4ce8c66d 18732 op_semantics_145:
a117b0a5
YS		 18733 {
18734 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
4ce8c66d 18735#line 537 "rx-decode.opc"
a117b0a5 18736 int rdst AU = op[1] & 0x0f;
4ce8c66d 18737#line 537 "rx-decode.opc"
a117b0a5 18738 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 18739#line 537 "rx-decode.opc"
a117b0a5
YS		 18740 int srcb AU = op[2] & 0x0f;
18741 if (trace)
18742 {
18743 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18744 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
18745 op[0], op[1], op[2]);
18746 printf (" rdst = 0x%x,", rdst);
18747 printf (" srca = 0x%x,", srca);
18748 printf (" srcb = 0x%x\n", srcb);
18749 }
18750 SYNTAX("add %2, %1, %0");
4ce8c66d 18751#line 537 "rx-decode.opc"
a117b0a5
YS		 18752 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18753
18754 /*----------------------------------------------------------------------*/
18755 /* CMP */
18756
18757 }
c7927a3c
NC		 18758 break;
18759 }
18760 break;
a117b0a5 18761 case 0x21:
c7927a3c
NC		 18762 GETBYTE ();
18763 switch (op[2] & 0x00)
18764 {
18765 case 0x00:
4ce8c66d 18766 goto op_semantics_145;
c7927a3c
NC		 18767 break;
18768 }
18769 break;
a117b0a5 18770 case 0x22:
c7927a3c
NC		 18771 GETBYTE ();
18772 switch (op[2] & 0x00)
18773 {
18774 case 0x00:
4ce8c66d 18775 goto op_semantics_145;
c7927a3c
NC		 18776 break;
18777 }
18778 break;
a117b0a5 18779 case 0x23:
c7927a3c
NC		 18780 GETBYTE ();
18781 switch (op[2] & 0x00)
18782 {
18783 case 0x00:
4ce8c66d 18784 goto op_semantics_145;
c7927a3c
NC		 18785 break;
18786 }
18787 break;
a117b0a5 18788 case 0x24:
c7927a3c
NC		 18789 GETBYTE ();
18790 switch (op[2] & 0x00)
18791 {
18792 case 0x00:
4ce8c66d 18793 goto op_semantics_145;
c7927a3c
NC		 18794 break;
18795 }
18796 break;
a117b0a5 18797 case 0x25:
c7927a3c
NC		 18798 GETBYTE ();
18799 switch (op[2] & 0x00)
18800 {
18801 case 0x00:
4ce8c66d 18802 goto op_semantics_145;
c7927a3c
NC		 18803 break;
18804 }
18805 break;
a117b0a5 18806 case 0x26:
c7927a3c
NC		 18807 GETBYTE ();
18808 switch (op[2] & 0x00)
18809 {
18810 case 0x00:
4ce8c66d 18811 goto op_semantics_145;
c7927a3c
NC		 18812 break;
18813 }
18814 break;
a117b0a5 18815 case 0x27:
c7927a3c
NC		 18816 GETBYTE ();
18817 switch (op[2] & 0x00)
18818 {
18819 case 0x00:
4ce8c66d 18820 goto op_semantics_145;
c7927a3c
NC		 18821 break;
18822 }
18823 break;
a117b0a5 18824 case 0x28:
c7927a3c
NC		 18825 GETBYTE ();
18826 switch (op[2] & 0x00)
18827 {
18828 case 0x00:
4ce8c66d 18829 goto op_semantics_145;
c7927a3c
NC		 18830 break;
18831 }
18832 break;
a117b0a5 18833 case 0x29:
c7927a3c
NC		 18834 GETBYTE ();
18835 switch (op[2] & 0x00)
18836 {
18837 case 0x00:
4ce8c66d 18838 goto op_semantics_145;
c7927a3c
NC		 18839 break;
18840 }
18841 break;
a117b0a5 18842 case 0x2a:
c7927a3c
NC		 18843 GETBYTE ();
18844 switch (op[2] & 0x00)
18845 {
18846 case 0x00:
4ce8c66d 18847 goto op_semantics_145;
c7927a3c
NC		 18848 break;
18849 }
18850 break;
a117b0a5 18851 case 0x2b:
c7927a3c
NC		 18852 GETBYTE ();
18853 switch (op[2] & 0x00)
18854 {
18855 case 0x00:
4ce8c66d 18856 goto op_semantics_145;
c7927a3c
NC		 18857 break;
18858 }
18859 break;
a117b0a5 18860 case 0x2c:
c7927a3c
NC		 18861 GETBYTE ();
18862 switch (op[2] & 0x00)
18863 {
18864 case 0x00:
4ce8c66d 18865 goto op_semantics_145;
c7927a3c
NC		 18866 break;
18867 }
18868 break;
a117b0a5 18869 case 0x2d:
c7927a3c
NC		 18870 GETBYTE ();
18871 switch (op[2] & 0x00)
18872 {
18873 case 0x00:
4ce8c66d 18874 goto op_semantics_145;
c7927a3c
NC		 18875 break;
18876 }
18877 break;
a117b0a5 18878 case 0x2e:
c7927a3c
NC		 18879 GETBYTE ();
18880 switch (op[2] & 0x00)
18881 {
18882 case 0x00:
4ce8c66d 18883 goto op_semantics_145;
c7927a3c
NC		 18884 break;
18885 }
18886 break;
a117b0a5 18887 case 0x2f:
c7927a3c
NC		 18888 GETBYTE ();
18889 switch (op[2] & 0x00)
18890 {
18891 case 0x00:
4ce8c66d 18892 goto op_semantics_145;
c7927a3c
NC		 18893 break;
18894 }
18895 break;
a117b0a5 18896 case 0x30:
c7927a3c
NC		 18897 GETBYTE ();
18898 switch (op[2] & 0x00)
18899 {
18900 case 0x00:
4ce8c66d 18901 op_semantics_146:
a117b0a5
YS		 18902 {
18903 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
4ce8c66d 18904#line 677 "rx-decode.opc"
a117b0a5 18905 int rdst AU = op[1] & 0x0f;
4ce8c66d 18906#line 677 "rx-decode.opc"
a117b0a5 18907 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 18908#line 677 "rx-decode.opc"
a117b0a5
YS		 18909 int srcb AU = op[2] & 0x0f;
18910 if (trace)
18911 {
18912 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
18913 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
18914 op[0], op[1], op[2]);
18915 printf (" rdst = 0x%x,", rdst);
18916 printf (" srca = 0x%x,", srca);
18917 printf (" srcb = 0x%x\n", srcb);
18918 }
18919 SYNTAX("mul %2, %1, %0");
4ce8c66d 18920#line 677 "rx-decode.opc"
a117b0a5
YS		 18921 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
18922
18923 /*----------------------------------------------------------------------*/
18924 /* EMUL */
18925
18926 }
c7927a3c
NC		 18927 break;
18928 }
18929 break;
a117b0a5 18930 case 0x31:
c7927a3c
NC		 18931 GETBYTE ();
18932 switch (op[2] & 0x00)
18933 {
18934 case 0x00:
4ce8c66d 18935 goto op_semantics_146;
c7927a3c
NC		 18936 break;
18937 }
18938 break;
a117b0a5 18939 case 0x32:
c7927a3c
NC		 18940 GETBYTE ();
18941 switch (op[2] & 0x00)
18942 {
18943 case 0x00:
4ce8c66d 18944 goto op_semantics_146;
c7927a3c
NC		 18945 break;
18946 }
18947 break;
a117b0a5 18948 case 0x33:
c7927a3c
NC		 18949 GETBYTE ();
18950 switch (op[2] & 0x00)
18951 {
18952 case 0x00:
4ce8c66d 18953 goto op_semantics_146;
c7927a3c
NC		 18954 break;
18955 }
18956 break;
a117b0a5 18957 case 0x34:
c7927a3c
NC		 18958 GETBYTE ();
18959 switch (op[2] & 0x00)
18960 {
18961 case 0x00:
4ce8c66d 18962 goto op_semantics_146;
c7927a3c
NC		 18963 break;
18964 }
18965 break;
a117b0a5 18966 case 0x35:
c7927a3c
NC		 18967 GETBYTE ();
18968 switch (op[2] & 0x00)
18969 {
18970 case 0x00:
4ce8c66d 18971 goto op_semantics_146;
c7927a3c
NC		 18972 break;
18973 }
18974 break;
a117b0a5 18975 case 0x36:
c7927a3c
NC		 18976 GETBYTE ();
18977 switch (op[2] & 0x00)
18978 {
18979 case 0x00:
4ce8c66d 18980 goto op_semantics_146;
c7927a3c
NC		 18981 break;
18982 }
18983 break;
a117b0a5 18984 case 0x37:
c7927a3c
NC		 18985 GETBYTE ();
18986 switch (op[2] & 0x00)
18987 {
18988 case 0x00:
4ce8c66d 18989 goto op_semantics_146;
c7927a3c
NC		 18990 break;
18991 }
18992 break;
a117b0a5 18993 case 0x38:
c7927a3c
NC		 18994 GETBYTE ();
18995 switch (op[2] & 0x00)
18996 {
18997 case 0x00:
4ce8c66d 18998 goto op_semantics_146;
c7927a3c
NC		 18999 break;
19000 }
19001 break;
a117b0a5 19002 case 0x39:
c7927a3c
NC		 19003 GETBYTE ();
19004 switch (op[2] & 0x00)
19005 {
19006 case 0x00:
4ce8c66d 19007 goto op_semantics_146;
c7927a3c
NC		 19008 break;
19009 }
19010 break;
a117b0a5 19011 case 0x3a:
c7927a3c
NC		 19012 GETBYTE ();
19013 switch (op[2] & 0x00)
19014 {
19015 case 0x00:
4ce8c66d 19016 goto op_semantics_146;
c7927a3c
NC		 19017 break;
19018 }
19019 break;
a117b0a5 19020 case 0x3b:
c7927a3c
NC		 19021 GETBYTE ();
19022 switch (op[2] & 0x00)
19023 {
19024 case 0x00:
4ce8c66d 19025 goto op_semantics_146;
c7927a3c
NC		 19026 break;
19027 }
19028 break;
a117b0a5 19029 case 0x3c:
c7927a3c
NC		 19030 GETBYTE ();
19031 switch (op[2] & 0x00)
19032 {
19033 case 0x00:
4ce8c66d 19034 goto op_semantics_146;
c7927a3c
NC		 19035 break;
19036 }
19037 break;
a117b0a5 19038 case 0x3d:
c7927a3c
NC		 19039 GETBYTE ();
19040 switch (op[2] & 0x00)
19041 {
19042 case 0x00:
4ce8c66d 19043 goto op_semantics_146;
c7927a3c
NC		 19044 break;
19045 }
19046 break;
a117b0a5 19047 case 0x3e:
c7927a3c
NC		 19048 GETBYTE ();
19049 switch (op[2] & 0x00)
19050 {
19051 case 0x00:
4ce8c66d 19052 goto op_semantics_146;
c7927a3c
NC		 19053 break;
19054 }
19055 break;
a117b0a5 19056 case 0x3f:
c7927a3c
NC		 19057 GETBYTE ();
19058 switch (op[2] & 0x00)
19059 {
19060 case 0x00:
4ce8c66d 19061 goto op_semantics_146;
c7927a3c
NC		 19062 break;
19063 }
19064 break;
a117b0a5 19065 case 0x40:
c7927a3c
NC		 19066 GETBYTE ();
19067 switch (op[2] & 0x00)
19068 {
19069 case 0x00:
4ce8c66d 19070 op_semantics_147:
c7927a3c 19071 {
a117b0a5 19072 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
4ce8c66d 19073#line 447 "rx-decode.opc"
c7927a3c 19074 int rdst AU = op[1] & 0x0f;
4ce8c66d 19075#line 447 "rx-decode.opc"
c7927a3c 19076 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 19077#line 447 "rx-decode.opc"
c7927a3c
NC		 19078 int srcb AU = op[2] & 0x0f;
19079 if (trace)
19080 {
19081 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 19082 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
c7927a3c
NC		 19083 op[0], op[1], op[2]);
19084 printf (" rdst = 0x%x,", rdst);
19085 printf (" srca = 0x%x,", srca);
19086 printf (" srcb = 0x%x\n", srcb);
19087 }
a117b0a5 19088 SYNTAX("and %2, %1, %0");
4ce8c66d 19089#line 447 "rx-decode.opc"
a117b0a5 19090 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 19091
c7927a3c 19092 /*----------------------------------------------------------------------*/
a117b0a5 19093 /* OR */
43e65147 19094
c7927a3c
NC		 19095 }
19096 break;
19097 }
19098 break;
a117b0a5 19099 case 0x41:
c7927a3c
NC		 19100 GETBYTE ();
19101 switch (op[2] & 0x00)
19102 {
19103 case 0x00:
4ce8c66d 19104 goto op_semantics_147;
c7927a3c
NC		 19105 break;
19106 }
19107 break;
a117b0a5 19108 case 0x42:
c7927a3c
NC		 19109 GETBYTE ();
19110 switch (op[2] & 0x00)
19111 {
19112 case 0x00:
4ce8c66d 19113 goto op_semantics_147;
c7927a3c
NC		 19114 break;
19115 }
19116 break;
a117b0a5 19117 case 0x43:
c7927a3c
NC		 19118 GETBYTE ();
19119 switch (op[2] & 0x00)
19120 {
19121 case 0x00:
4ce8c66d 19122 goto op_semantics_147;
c7927a3c
NC		 19123 break;
19124 }
19125 break;
a117b0a5 19126 case 0x44:
c7927a3c
NC		 19127 GETBYTE ();
19128 switch (op[2] & 0x00)
19129 {
19130 case 0x00:
4ce8c66d 19131 goto op_semantics_147;
c7927a3c
NC		 19132 break;
19133 }
19134 break;
a117b0a5 19135 case 0x45:
c7927a3c
NC		 19136 GETBYTE ();
19137 switch (op[2] & 0x00)
19138 {
19139 case 0x00:
4ce8c66d 19140 goto op_semantics_147;
c7927a3c
NC		 19141 break;
19142 }
19143 break;
a117b0a5 19144 case 0x46:
c7927a3c
NC		 19145 GETBYTE ();
19146 switch (op[2] & 0x00)
19147 {
19148 case 0x00:
4ce8c66d 19149 goto op_semantics_147;
c7927a3c
NC		 19150 break;
19151 }
19152 break;
a117b0a5 19153 case 0x47:
c7927a3c
NC		 19154 GETBYTE ();
19155 switch (op[2] & 0x00)
19156 {
19157 case 0x00:
4ce8c66d 19158 goto op_semantics_147;
c7927a3c
NC		 19159 break;
19160 }
19161 break;
a117b0a5 19162 case 0x48:
c7927a3c
NC		 19163 GETBYTE ();
19164 switch (op[2] & 0x00)
19165 {
19166 case 0x00:
4ce8c66d 19167 goto op_semantics_147;
c7927a3c
NC		 19168 break;
19169 }
19170 break;
a117b0a5 19171 case 0x49:
c7927a3c
NC		 19172 GETBYTE ();
19173 switch (op[2] & 0x00)
19174 {
19175 case 0x00:
4ce8c66d 19176 goto op_semantics_147;
c7927a3c
NC		 19177 break;
19178 }
19179 break;
a117b0a5 19180 case 0x4a:
c7927a3c
NC		 19181 GETBYTE ();
19182 switch (op[2] & 0x00)
19183 {
19184 case 0x00:
4ce8c66d 19185 goto op_semantics_147;
c7927a3c
NC		 19186 break;
19187 }
19188 break;
a117b0a5 19189 case 0x4b:
c7927a3c
NC		 19190 GETBYTE ();
19191 switch (op[2] & 0x00)
19192 {
19193 case 0x00:
4ce8c66d 19194 goto op_semantics_147;
c7927a3c
NC		 19195 break;
19196 }
19197 break;
a117b0a5 19198 case 0x4c:
c7927a3c
NC		 19199 GETBYTE ();
19200 switch (op[2] & 0x00)
19201 {
19202 case 0x00:
4ce8c66d 19203 goto op_semantics_147;
c7927a3c
NC		 19204 break;
19205 }
19206 break;
a117b0a5 19207 case 0x4d:
c7927a3c
NC		 19208 GETBYTE ();
19209 switch (op[2] & 0x00)
19210 {
19211 case 0x00:
4ce8c66d 19212 goto op_semantics_147;
c7927a3c
NC		 19213 break;
19214 }
19215 break;
a117b0a5 19216 case 0x4e:
c7927a3c
NC		 19217 GETBYTE ();
19218 switch (op[2] & 0x00)
19219 {
19220 case 0x00:
4ce8c66d 19221 goto op_semantics_147;
c7927a3c
NC		 19222 break;
19223 }
19224 break;
a117b0a5 19225 case 0x4f:
c7927a3c
NC		 19226 GETBYTE ();
19227 switch (op[2] & 0x00)
19228 {
19229 case 0x00:
4ce8c66d 19230 goto op_semantics_147;
c7927a3c
NC		 19231 break;
19232 }
19233 break;
a117b0a5 19234 case 0x50:
c7927a3c
NC		 19235 GETBYTE ();
19236 switch (op[2] & 0x00)
19237 {
19238 case 0x00:
4ce8c66d 19239 op_semantics_148:
c7927a3c 19240 {
a117b0a5 19241 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
4ce8c66d 19242#line 465 "rx-decode.opc"
c7927a3c 19243 int rdst AU = op[1] & 0x0f;
4ce8c66d 19244#line 465 "rx-decode.opc"
c7927a3c 19245 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 19246#line 465 "rx-decode.opc"
c7927a3c
NC		 19247 int srcb AU = op[2] & 0x0f;
19248 if (trace)
19249 {
19250 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 19251 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
c7927a3c
NC		 19252 op[0], op[1], op[2]);
19253 printf (" rdst = 0x%x,", rdst);
19254 printf (" srca = 0x%x,", srca);
19255 printf (" srcb = 0x%x\n", srcb);
19256 }
a117b0a5 19257 SYNTAX("or %2, %1, %0");
4ce8c66d 19258#line 465 "rx-decode.opc"
a117b0a5 19259 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 19260
c7927a3c 19261 /*----------------------------------------------------------------------*/
a117b0a5 19262 /* XOR */
43e65147 19263
c7927a3c
NC		 19264 }
19265 break;
19266 }
19267 break;
a117b0a5 19268 case 0x51:
c7927a3c
NC		 19269 GETBYTE ();
19270 switch (op[2] & 0x00)
19271 {
19272 case 0x00:
4ce8c66d 19273 goto op_semantics_148;
c7927a3c
NC		 19274 break;
19275 }
19276 break;
a117b0a5 19277 case 0x52:
c7927a3c
NC		 19278 GETBYTE ();
19279 switch (op[2] & 0x00)
19280 {
19281 case 0x00:
4ce8c66d 19282 goto op_semantics_148;
c7927a3c
NC		 19283 break;
19284 }
19285 break;
a117b0a5 19286 case 0x53:
c7927a3c
NC		 19287 GETBYTE ();
19288 switch (op[2] & 0x00)
19289 {
19290 case 0x00:
4ce8c66d 19291 goto op_semantics_148;
c7927a3c
NC		 19292 break;
19293 }
19294 break;
a117b0a5 19295 case 0x54:
c7927a3c
NC		 19296 GETBYTE ();
19297 switch (op[2] & 0x00)
19298 {
19299 case 0x00:
4ce8c66d 19300 goto op_semantics_148;
c7927a3c
NC		 19301 break;
19302 }
19303 break;
a117b0a5 19304 case 0x55:
c7927a3c
NC		 19305 GETBYTE ();
19306 switch (op[2] & 0x00)
19307 {
19308 case 0x00:
4ce8c66d 19309 goto op_semantics_148;
c7927a3c
NC		 19310 break;
19311 }
19312 break;
a117b0a5 19313 case 0x56:
c7927a3c
NC		 19314 GETBYTE ();
19315 switch (op[2] & 0x00)
19316 {
19317 case 0x00:
4ce8c66d 19318 goto op_semantics_148;
c7927a3c
NC		 19319 break;
19320 }
19321 break;
a117b0a5 19322 case 0x57:
c7927a3c
NC		 19323 GETBYTE ();
19324 switch (op[2] & 0x00)
19325 {
19326 case 0x00:
4ce8c66d 19327 goto op_semantics_148;
c7927a3c
NC		 19328 break;
19329 }
19330 break;
a117b0a5 19331 case 0x58:
c7927a3c
NC		 19332 GETBYTE ();
19333 switch (op[2] & 0x00)
19334 {
19335 case 0x00:
4ce8c66d 19336 goto op_semantics_148;
c7927a3c
NC		 19337 break;
19338 }
19339 break;
a117b0a5 19340 case 0x59:
c7927a3c
NC		 19341 GETBYTE ();
19342 switch (op[2] & 0x00)
19343 {
19344 case 0x00:
4ce8c66d 19345 goto op_semantics_148;
c7927a3c
NC		 19346 break;
19347 }
19348 break;
a117b0a5 19349 case 0x5a:
c7927a3c
NC		 19350 GETBYTE ();
19351 switch (op[2] & 0x00)
19352 {
19353 case 0x00:
4ce8c66d 19354 goto op_semantics_148;
c7927a3c
NC		 19355 break;
19356 }
19357 break;
a117b0a5 19358 case 0x5b:
c7927a3c
NC		 19359 GETBYTE ();
19360 switch (op[2] & 0x00)
19361 {
19362 case 0x00:
4ce8c66d 19363 goto op_semantics_148;
c7927a3c
NC		 19364 break;
19365 }
19366 break;
a117b0a5 19367 case 0x5c:
c7927a3c
NC		 19368 GETBYTE ();
19369 switch (op[2] & 0x00)
19370 {
19371 case 0x00:
4ce8c66d 19372 goto op_semantics_148;
c7927a3c
NC		 19373 break;
19374 }
19375 break;
a117b0a5 19376 case 0x5d:
c7927a3c
NC		 19377 GETBYTE ();
19378 switch (op[2] & 0x00)
19379 {
19380 case 0x00:
4ce8c66d 19381 goto op_semantics_148;
c7927a3c
NC		 19382 break;
19383 }
19384 break;
a117b0a5 19385 case 0x5e:
c7927a3c
NC		 19386 GETBYTE ();
19387 switch (op[2] & 0x00)
19388 {
19389 case 0x00:
4ce8c66d 19390 goto op_semantics_148;
c7927a3c
NC		 19391 break;
19392 }
19393 break;
a117b0a5 19394 case 0x5f:
c7927a3c
NC		 19395 GETBYTE ();
19396 switch (op[2] & 0x00)
19397 {
19398 case 0x00:
4ce8c66d
YS		 19399 goto op_semantics_148;
19400 break;
19401 }
19402 break;
19403 case 0x60:
19404 GETBYTE ();
19405 switch (op[2] & 0x00)
19406 {
19407 case 0x00:
19408 op_semantics_149:
19409 {
19410 /** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */
19411#line 1146 "rx-decode.opc"
19412 int rdst AU = op[1] & 0x0f;
19413#line 1146 "rx-decode.opc"
19414 int srca AU = (op[2] >> 4) & 0x0f;
19415#line 1146 "rx-decode.opc"
19416 int srcb AU = op[2] & 0x0f;
19417 if (trace)
19418 {
19419 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
19420 "/** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */",
19421 op[0], op[1], op[2]);
19422 printf (" rdst = 0x%x,", rdst);
19423 printf (" srca = 0x%x,", srca);
19424 printf (" srcb = 0x%x\n", srcb);
19425 }
19426 SYNTAX("xor %2, %1, %0");
19427#line 1146 "rx-decode.opc"
19428 ID(xor); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19429
19430 }
19431 break;
19432 }
19433 break;
19434 case 0x61:
19435 GETBYTE ();
19436 switch (op[2] & 0x00)
19437 {
19438 case 0x00:
19439 goto op_semantics_149;
19440 break;
19441 }
19442 break;
19443 case 0x62:
19444 GETBYTE ();
19445 switch (op[2] & 0x00)
19446 {
19447 case 0x00:
19448 goto op_semantics_149;
19449 break;
19450 }
19451 break;
19452 case 0x63:
19453 GETBYTE ();
19454 switch (op[2] & 0x00)
19455 {
19456 case 0x00:
19457 goto op_semantics_149;
19458 break;
19459 }
19460 break;
19461 case 0x64:
19462 GETBYTE ();
19463 switch (op[2] & 0x00)
19464 {
19465 case 0x00:
19466 goto op_semantics_149;
19467 break;
19468 }
19469 break;
19470 case 0x65:
19471 GETBYTE ();
19472 switch (op[2] & 0x00)
19473 {
19474 case 0x00:
19475 goto op_semantics_149;
19476 break;
19477 }
19478 break;
19479 case 0x66:
19480 GETBYTE ();
19481 switch (op[2] & 0x00)
19482 {
19483 case 0x00:
19484 goto op_semantics_149;
19485 break;
19486 }
19487 break;
19488 case 0x67:
19489 GETBYTE ();
19490 switch (op[2] & 0x00)
19491 {
19492 case 0x00:
19493 goto op_semantics_149;
19494 break;
19495 }
19496 break;
19497 case 0x68:
19498 GETBYTE ();
19499 switch (op[2] & 0x00)
19500 {
19501 case 0x00:
19502 goto op_semantics_149;
19503 break;
19504 }
19505 break;
19506 case 0x69:
19507 GETBYTE ();
19508 switch (op[2] & 0x00)
19509 {
19510 case 0x00:
19511 goto op_semantics_149;
19512 break;
19513 }
19514 break;
19515 case 0x6a:
19516 GETBYTE ();
19517 switch (op[2] & 0x00)
19518 {
19519 case 0x00:
19520 goto op_semantics_149;
19521 break;
19522 }
19523 break;
19524 case 0x6b:
19525 GETBYTE ();
19526 switch (op[2] & 0x00)
19527 {
19528 case 0x00:
19529 goto op_semantics_149;
19530 break;
19531 }
19532 break;
19533 case 0x6c:
19534 GETBYTE ();
19535 switch (op[2] & 0x00)
19536 {
19537 case 0x00:
19538 goto op_semantics_149;
19539 break;
19540 }
19541 break;
19542 case 0x6d:
19543 GETBYTE ();
19544 switch (op[2] & 0x00)
19545 {
19546 case 0x00:
19547 goto op_semantics_149;
19548 break;
19549 }
19550 break;
19551 case 0x6e:
19552 GETBYTE ();
19553 switch (op[2] & 0x00)
19554 {
19555 case 0x00:
19556 goto op_semantics_149;
19557 break;
19558 }
19559 break;
19560 case 0x6f:
19561 GETBYTE ();
19562 switch (op[2] & 0x00)
19563 {
19564 case 0x00:
19565 goto op_semantics_149;
c7927a3c
NC		 19566 break;
19567 }
19568 break;
a117b0a5 19569 case 0x80:
c7927a3c
NC		 19570 GETBYTE ();
19571 switch (op[2] & 0x00)
19572 {
19573 case 0x00:
4ce8c66d 19574 op_semantics_150:
c7927a3c 19575 {
a117b0a5 19576 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
4ce8c66d 19577#line 1125 "rx-decode.opc"
c7927a3c 19578 int rdst AU = op[1] & 0x0f;
4ce8c66d 19579#line 1125 "rx-decode.opc"
c7927a3c 19580 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 19581#line 1125 "rx-decode.opc"
c7927a3c
NC		 19582 int srcb AU = op[2] & 0x0f;
19583 if (trace)
19584 {
19585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 19586 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
c7927a3c
NC		 19587 op[0], op[1], op[2]);
19588 printf (" rdst = 0x%x,", rdst);
19589 printf (" srca = 0x%x,", srca);
19590 printf (" srcb = 0x%x\n", srcb);
19591 }
a117b0a5 19592 SYNTAX("fsub %2, %1, %0");
4ce8c66d 19593#line 1125 "rx-decode.opc"
a117b0a5 19594 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 19595
c7927a3c
NC		 19596 }
19597 break;
19598 }
19599 break;
a117b0a5 19600 case 0x81:
c7927a3c
NC		 19601 GETBYTE ();
19602 switch (op[2] & 0x00)
19603 {
19604 case 0x00:
4ce8c66d 19605 goto op_semantics_150;
c7927a3c
NC		 19606 break;
19607 }
19608 break;
a117b0a5 19609 case 0x82:
c7927a3c
NC		 19610 GETBYTE ();
19611 switch (op[2] & 0x00)
19612 {
19613 case 0x00:
4ce8c66d 19614 goto op_semantics_150;
c7927a3c
NC		 19615 break;
19616 }
19617 break;
a117b0a5 19618 case 0x83:
c7927a3c
NC		 19619 GETBYTE ();
19620 switch (op[2] & 0x00)
19621 {
19622 case 0x00:
4ce8c66d 19623 goto op_semantics_150;
c7927a3c
NC		 19624 break;
19625 }
19626 break;
a117b0a5 19627 case 0x84:
c7927a3c
NC		 19628 GETBYTE ();
19629 switch (op[2] & 0x00)
19630 {
19631 case 0x00:
4ce8c66d 19632 goto op_semantics_150;
c7927a3c
NC		 19633 break;
19634 }
19635 break;
a117b0a5 19636 case 0x85:
c7927a3c
NC		 19637 GETBYTE ();
19638 switch (op[2] & 0x00)
19639 {
19640 case 0x00:
4ce8c66d 19641 goto op_semantics_150;
c7927a3c
NC		 19642 break;
19643 }
19644 break;
a117b0a5 19645 case 0x86:
c7927a3c
NC		 19646 GETBYTE ();
19647 switch (op[2] & 0x00)
19648 {
19649 case 0x00:
4ce8c66d 19650 goto op_semantics_150;
c7927a3c
NC		 19651 break;
19652 }
19653 break;
a117b0a5 19654 case 0x87:
c7927a3c
NC		 19655 GETBYTE ();
19656 switch (op[2] & 0x00)
19657 {
19658 case 0x00:
4ce8c66d 19659 goto op_semantics_150;
c7927a3c
NC		 19660 break;
19661 }
19662 break;
a117b0a5 19663 case 0x88:
c7927a3c
NC		 19664 GETBYTE ();
19665 switch (op[2] & 0x00)
19666 {
19667 case 0x00:
4ce8c66d 19668 goto op_semantics_150;
c7927a3c
NC		 19669 break;
19670 }
19671 break;
a117b0a5 19672 case 0x89:
c7927a3c
NC		 19673 GETBYTE ();
19674 switch (op[2] & 0x00)
19675 {
19676 case 0x00:
4ce8c66d 19677 goto op_semantics_150;
c7927a3c
NC		 19678 break;
19679 }
19680 break;
a117b0a5 19681 case 0x8a:
c7927a3c
NC		 19682 GETBYTE ();
19683 switch (op[2] & 0x00)
19684 {
19685 case 0x00:
4ce8c66d 19686 goto op_semantics_150;
c7927a3c
NC		 19687 break;
19688 }
19689 break;
a117b0a5 19690 case 0x8b:
c7927a3c
NC		 19691 GETBYTE ();
19692 switch (op[2] & 0x00)
19693 {
19694 case 0x00:
4ce8c66d 19695 goto op_semantics_150;
c7927a3c
NC		 19696 break;
19697 }
19698 break;
a117b0a5 19699 case 0x8c:
c7927a3c
NC		 19700 GETBYTE ();
19701 switch (op[2] & 0x00)
19702 {
19703 case 0x00:
4ce8c66d 19704 goto op_semantics_150;
c7927a3c
NC		 19705 break;
19706 }
19707 break;
a117b0a5 19708 case 0x8d:
c7927a3c
NC		 19709 GETBYTE ();
19710 switch (op[2] & 0x00)
19711 {
19712 case 0x00:
4ce8c66d 19713 goto op_semantics_150;
c7927a3c
NC		 19714 break;
19715 }
19716 break;
a117b0a5 19717 case 0x8e:
c7927a3c
NC		 19718 GETBYTE ();
19719 switch (op[2] & 0x00)
19720 {
19721 case 0x00:
4ce8c66d 19722 goto op_semantics_150;
c7927a3c
NC		 19723 break;
19724 }
19725 break;
a117b0a5 19726 case 0x8f:
c7927a3c
NC		 19727 GETBYTE ();
19728 switch (op[2] & 0x00)
19729 {
19730 case 0x00:
4ce8c66d 19731 goto op_semantics_150;
c7927a3c
NC		 19732 break;
19733 }
19734 break;
a117b0a5 19735 case 0xa0:
c7927a3c
NC		 19736 GETBYTE ();
19737 switch (op[2] & 0x00)
19738 {
19739 case 0x00:
4ce8c66d 19740 op_semantics_151:
c7927a3c 19741 {
a117b0a5 19742 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
4ce8c66d 19743#line 1122 "rx-decode.opc"
c7927a3c 19744 int rdst AU = op[1] & 0x0f;
4ce8c66d 19745#line 1122 "rx-decode.opc"
c7927a3c 19746 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 19747#line 1122 "rx-decode.opc"
c7927a3c
NC		 19748 int srcb AU = op[2] & 0x0f;
19749 if (trace)
19750 {
19751 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 19752 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
c7927a3c
NC		 19753 op[0], op[1], op[2]);
19754 printf (" rdst = 0x%x,", rdst);
19755 printf (" srca = 0x%x,", srca);
19756 printf (" srcb = 0x%x\n", srcb);
19757 }
a117b0a5 19758 SYNTAX("fadd %2, %1, %0");
4ce8c66d 19759#line 1122 "rx-decode.opc"
a117b0a5 19760 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 19761
c7927a3c
NC		 19762 }
19763 break;
19764 }
19765 break;
a117b0a5 19766 case 0xa1:
c7927a3c
NC		 19767 GETBYTE ();
19768 switch (op[2] & 0x00)
19769 {
19770 case 0x00:
4ce8c66d 19771 goto op_semantics_151;
c7927a3c
NC		 19772 break;
19773 }
19774 break;
a117b0a5 19775 case 0xa2:
c7927a3c
NC		 19776 GETBYTE ();
19777 switch (op[2] & 0x00)
19778 {
19779 case 0x00:
4ce8c66d 19780 goto op_semantics_151;
c7927a3c
NC		 19781 break;
19782 }
19783 break;
a117b0a5 19784 case 0xa3:
c7927a3c
NC		 19785 GETBYTE ();
19786 switch (op[2] & 0x00)
19787 {
19788 case 0x00:
4ce8c66d 19789 goto op_semantics_151;
c7927a3c
NC		 19790 break;
19791 }
19792 break;
a117b0a5 19793 case 0xa4:
c7927a3c
NC		 19794 GETBYTE ();
19795 switch (op[2] & 0x00)
19796 {
19797 case 0x00:
4ce8c66d 19798 goto op_semantics_151;
c7927a3c
NC		 19799 break;
19800 }
19801 break;
a117b0a5 19802 case 0xa5:
c7927a3c
NC		 19803 GETBYTE ();
19804 switch (op[2] & 0x00)
19805 {
19806 case 0x00:
4ce8c66d 19807 goto op_semantics_151;
c7927a3c
NC		 19808 break;
19809 }
19810 break;
a117b0a5 19811 case 0xa6:
c7927a3c
NC		 19812 GETBYTE ();
19813 switch (op[2] & 0x00)
19814 {
19815 case 0x00:
4ce8c66d 19816 goto op_semantics_151;
c7927a3c
NC		 19817 break;
19818 }
19819 break;
a117b0a5 19820 case 0xa7:
c7927a3c
NC		 19821 GETBYTE ();
19822 switch (op[2] & 0x00)
19823 {
19824 case 0x00:
4ce8c66d 19825 goto op_semantics_151;
c7927a3c
NC		 19826 break;
19827 }
19828 break;
a117b0a5 19829 case 0xa8:
c7927a3c
NC		 19830 GETBYTE ();
19831 switch (op[2] & 0x00)
19832 {
19833 case 0x00:
4ce8c66d 19834 goto op_semantics_151;
c7927a3c
NC		 19835 break;
19836 }
19837 break;
a117b0a5 19838 case 0xa9:
c7927a3c
NC		 19839 GETBYTE ();
19840 switch (op[2] & 0x00)
19841 {
19842 case 0x00:
4ce8c66d 19843 goto op_semantics_151;
c7927a3c
NC		 19844 break;
19845 }
19846 break;
a117b0a5 19847 case 0xaa:
c7927a3c
NC		 19848 GETBYTE ();
19849 switch (op[2] & 0x00)
19850 {
19851 case 0x00:
4ce8c66d 19852 goto op_semantics_151;
c7927a3c
NC		 19853 break;
19854 }
19855 break;
a117b0a5 19856 case 0xab:
c7927a3c
NC		 19857 GETBYTE ();
19858 switch (op[2] & 0x00)
19859 {
19860 case 0x00:
4ce8c66d 19861 goto op_semantics_151;
c7927a3c
NC		 19862 break;
19863 }
19864 break;
a117b0a5 19865 case 0xac:
c7927a3c
NC		 19866 GETBYTE ();
19867 switch (op[2] & 0x00)
19868 {
19869 case 0x00:
4ce8c66d 19870 goto op_semantics_151;
c7927a3c
NC		 19871 break;
19872 }
19873 break;
a117b0a5 19874 case 0xad:
c7927a3c
NC		 19875 GETBYTE ();
19876 switch (op[2] & 0x00)
19877 {
19878 case 0x00:
4ce8c66d 19879 goto op_semantics_151;
c7927a3c
NC		 19880 break;
19881 }
19882 break;
a117b0a5 19883 case 0xae:
c7927a3c
NC		 19884 GETBYTE ();
19885 switch (op[2] & 0x00)
19886 {
19887 case 0x00:
4ce8c66d 19888 goto op_semantics_151;
c7927a3c
NC		 19889 break;
19890 }
19891 break;
a117b0a5 19892 case 0xaf:
c7927a3c
NC		 19893 GETBYTE ();
19894 switch (op[2] & 0x00)
19895 {
19896 case 0x00:
4ce8c66d 19897 goto op_semantics_151;
c7927a3c
NC		 19898 break;
19899 }
19900 break;
a117b0a5 19901 case 0xb0:
c7927a3c
NC		 19902 GETBYTE ();
19903 switch (op[2] & 0x00)
19904 {
19905 case 0x00:
4ce8c66d 19906 op_semantics_152:
c7927a3c 19907 {
a117b0a5 19908 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
4ce8c66d 19909#line 1128 "rx-decode.opc"
c7927a3c 19910 int rdst AU = op[1] & 0x0f;
4ce8c66d 19911#line 1128 "rx-decode.opc"
c7927a3c 19912 int srca AU = (op[2] >> 4) & 0x0f;
4ce8c66d 19913#line 1128 "rx-decode.opc"
c7927a3c
NC		 19914 int srcb AU = op[2] & 0x0f;
19915 if (trace)
19916 {
19917 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 19918 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
c7927a3c
NC		 19919 op[0], op[1], op[2]);
19920 printf (" rdst = 0x%x,", rdst);
19921 printf (" srca = 0x%x,", srca);
19922 printf (" srcb = 0x%x\n", srcb);
19923 }
a117b0a5 19924 SYNTAX("fmul %2, %1, %0");
4ce8c66d 19925#line 1128 "rx-decode.opc"
a117b0a5 19926 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 19927
c7927a3c
NC		 19928 }
19929 break;
19930 }
19931 break;
a117b0a5 19932 case 0xb1:
c7927a3c
NC		 19933 GETBYTE ();
19934 switch (op[2] & 0x00)
19935 {
19936 case 0x00:
4ce8c66d 19937 goto op_semantics_152;
c7927a3c
NC		 19938 break;
19939 }
19940 break;
a117b0a5 19941 case 0xb2:
c7927a3c
NC		 19942 GETBYTE ();
19943 switch (op[2] & 0x00)
19944 {
19945 case 0x00:
4ce8c66d 19946 goto op_semantics_152;
c7927a3c
NC		 19947 break;
19948 }
19949 break;
a117b0a5 19950 case 0xb3:
c7927a3c
NC		 19951 GETBYTE ();
19952 switch (op[2] & 0x00)
19953 {
19954 case 0x00:
4ce8c66d 19955 goto op_semantics_152;
c7927a3c
NC		 19956 break;
19957 }
19958 break;
a117b0a5 19959 case 0xb4:
c7927a3c
NC		 19960 GETBYTE ();
19961 switch (op[2] & 0x00)
19962 {
19963 case 0x00:
4ce8c66d 19964 goto op_semantics_152;
c7927a3c
NC		 19965 break;
19966 }
19967 break;
a117b0a5 19968 case 0xb5:
c7927a3c
NC		 19969 GETBYTE ();
19970 switch (op[2] & 0x00)
19971 {
19972 case 0x00:
4ce8c66d 19973 goto op_semantics_152;
c7927a3c
NC		 19974 break;
19975 }
19976 break;
a117b0a5 19977 case 0xb6:
c7927a3c
NC		 19978 GETBYTE ();
19979 switch (op[2] & 0x00)
19980 {
19981 case 0x00:
4ce8c66d 19982 goto op_semantics_152;
c7927a3c
NC		 19983 break;
19984 }
19985 break;
a117b0a5 19986 case 0xb7:
c7927a3c
NC		 19987 GETBYTE ();
19988 switch (op[2] & 0x00)
19989 {
19990 case 0x00:
4ce8c66d 19991 goto op_semantics_152;
c7927a3c
NC		 19992 break;
19993 }
19994 break;
a117b0a5 19995 case 0xb8:
c7927a3c
NC		 19996 GETBYTE ();
19997 switch (op[2] & 0x00)
19998 {
19999 case 0x00:
4ce8c66d 20000 goto op_semantics_152;
c7927a3c
NC		 20001 break;
20002 }
20003 break;
a117b0a5 20004 case 0xb9:
c7927a3c
NC		 20005 GETBYTE ();
20006 switch (op[2] & 0x00)
20007 {
20008 case 0x00:
4ce8c66d 20009 goto op_semantics_152;
c7927a3c
NC		 20010 break;
20011 }
20012 break;
a117b0a5 20013 case 0xba:
c7927a3c
NC		 20014 GETBYTE ();
20015 switch (op[2] & 0x00)
20016 {
20017 case 0x00:
4ce8c66d 20018 goto op_semantics_152;
c7927a3c
NC		 20019 break;
20020 }
20021 break;
a117b0a5 20022 case 0xbb:
c7927a3c
NC		 20023 GETBYTE ();
20024 switch (op[2] & 0x00)
20025 {
20026 case 0x00:
4ce8c66d 20027 goto op_semantics_152;
c7927a3c
NC		 20028 break;
20029 }
20030 break;
a117b0a5 20031 case 0xbc:
c7927a3c
NC		 20032 GETBYTE ();
20033 switch (op[2] & 0x00)
20034 {
20035 case 0x00:
4ce8c66d 20036 goto op_semantics_152;
c7927a3c
NC		 20037 break;
20038 }
20039 break;
a117b0a5 20040 case 0xbd:
c7927a3c
NC		 20041 GETBYTE ();
20042 switch (op[2] & 0x00)
20043 {
20044 case 0x00:
4ce8c66d 20045 goto op_semantics_152;
c7927a3c
NC		 20046 break;
20047 }
20048 break;
a117b0a5 20049 case 0xbe:
c7927a3c
NC		 20050 GETBYTE ();
20051 switch (op[2] & 0x00)
20052 {
20053 case 0x00:
4ce8c66d 20054 goto op_semantics_152;
c7927a3c
NC		 20055 break;
20056 }
20057 break;
a117b0a5 20058 case 0xbf:
c7927a3c
NC		 20059 GETBYTE ();
20060 switch (op[2] & 0x00)
20061 {
20062 case 0x00:
4ce8c66d 20063 goto op_semantics_152;
c7927a3c
NC		 20064 break;
20065 }
20066 break;
20067 default: UNSUPPORTED(); break;
20068 }
20069 break;
20070 default: UNSUPPORTED(); break;
20071 }
4ce8c66d 20072#line 1280 "rx-decode.opc"
c7927a3c
NC		 20073
20074 return rx->n_bytes;
20075}
GDB Binutils - Deliverables
This page took 1.832061 seconds and 4 git commands to generate.