]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - opcodes/rx-decode.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ifunc.exp: Always build static_nonifunc_prog
[thirdparty/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 -*- */
219d1afa 4/* Copyright (C) 2012-2018 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
48
49/* These are for when the upper bits are "don't care" or "undefined". */
db5fa770 50static int bwl[4] =
c7927a3c
NC		 51{
52 RX_Byte,
53 RX_Word,
b8985e5c 54 RX_Long,
f04265ec 55 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 56};
57
db5fa770 58static int sbwl[4] =
c7927a3c
NC		 59{
60 RX_SByte,
61 RX_SWord,
b8985e5c 62 RX_Long,
f04265ec 63 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 64};
65
db5fa770 66static int ubw[4] =
c7927a3c
NC		 67{
68 RX_UByte,
69 RX_UWord,
f04265ec
NC		 70 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
71 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
c7927a3c
NC		 72};
73
db5fa770 74static int memex[4] =
c7927a3c
NC		 75{
76 RX_SByte,
77 RX_SWord,
78 RX_Long,
79 RX_UWord
80};
81
82#define ID(x) rx->id = RXO_##x
83#define OP(n,t,r,a) (rx->op[n].type = t, \
84 rx->op[n].reg = r, \
85 rx->op[n].addend = a )
86#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
87 rx->op[n].size = s )
88
89/* This is for the BWL and BW bitfields. */
b8985e5c 90static int SCALE[] = { 1, 2, 4, 0 };
c7927a3c
NC		 91/* This is for the prefix size enum. */
92static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
93
db5fa770
NC		 94#define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
95#define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
96
c7927a3c
NC		 97static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
98 16, 17, 0, 0, 0, 0, 0, 0 };
99
100static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
101
102/*
103 *C a constant (immediate) c
104 *R A register
105 *I Register indirect, no offset
106 *Is Register indirect, with offset
107 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
108 *P standard displacement: type (r,[r]), reg, assumes UByte
109 *Pm memex displacement: type (r,[r]), reg, memex code
110 *cc condition code. */
111
112#define DC(c) OP (0, RX_Operand_Immediate, 0, c)
113#define DR(r) OP (0, RX_Operand_Register, r, 0)
114#define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
db5fa770 115#define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
c7927a3c
NC		 116#define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
117#define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
118
119#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
120#define SR(r) OP (1, RX_Operand_Register, r, 0)
f9c7014e 121#define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
c7927a3c 122#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
db5fa770 123#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
c7927a3c
NC		 124#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
125#define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
126#define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
127#define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
128
129#define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
130#define S2R(r) OP (2, RX_Operand_Register, r, 0)
131#define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
db5fa770 132#define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
c7927a3c
NC		 133#define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
134#define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
135#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
136#define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
137
138#define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
139#define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
f04265ec 140#define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
c7927a3c
NC		 141#define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
142
143#define F(f) store_flags(rx, f)
144
145#define AU ATTRIBUTE_UNUSED
146#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
147
148#define SYNTAX(x) rx->syntax = x
149
150#define UNSUPPORTED() \
151 rx->syntax = "*unknown*"
152
153#define IMM(sf) immediate (sf, 0, ld)
154#define IMMex(sf) immediate (sf, 1, ld)
155
156static int
157immediate (int sfield, int ex, LocalData * ld)
158{
159 unsigned long i = 0, j;
160
161 switch (sfield)
162 {
163#define B ((unsigned long) GETBYTE())
164 case 0:
165#if RX_OPCODE_BIG_ENDIAN
166 i = B;
167 if (ex && (i & 0x80))
168 i -= 0x100;
169 i <<= 24;
170 i |= B << 16;
171 i |= B << 8;
172 i |= B;
173#else
174 i = B;
175 i |= B << 8;
176 i |= B << 16;
177 j = B;
178 if (ex && (j & 0x80))
179 j -= 0x100;
180 i |= j << 24;
181#endif
182 break;
183 case 3:
184#if RX_OPCODE_BIG_ENDIAN
185 i = B << 16;
186 i |= B << 8;
187 i |= B;
188#else
189 i = B;
190 i |= B << 8;
191 i |= B << 16;
192#endif
193 if (ex && (i & 0x800000))
194 i -= 0x1000000;
195 break;
196 case 2:
197#if RX_OPCODE_BIG_ENDIAN
198 i |= B << 8;
199 i |= B;
200#else
201 i |= B;
202 i |= B << 8;
203#endif
204 if (ex && (i & 0x8000))
205 i -= 0x10000;
206 break;
207 case 1:
208 i |= B;
209 if (ex && (i & 0x80))
210 i -= 0x100;
211 break;
212 default:
213 abort();
214 }
215 return i;
216}
217
218static void
db5fa770 219rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
c7927a3c
NC		 220{
221 int disp;
222
223 ld->rx->op[n].reg = reg;
224 switch (type)
225 {
226 case 3:
227 ld->rx->op[n].type = RX_Operand_Register;
228 break;
229 case 0:
e292aa7a 230 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
c7927a3c
NC		 231 ld->rx->op[n].addend = 0;
232 break;
233 case 1:
234 ld->rx->op[n].type = RX_Operand_Indirect;
235 disp = GETBYTE ();
db5fa770 236 ld->rx->op[n].addend = disp * GET_PSCALE (size);
c7927a3c
NC		 237 break;
238 case 2:
239 ld->rx->op[n].type = RX_Operand_Indirect;
240 disp = GETBYTE ();
241#if RX_OPCODE_BIG_ENDIAN
242 disp = disp * 256 + GETBYTE ();
243#else
244 disp = disp + GETBYTE () * 256;
245#endif
db5fa770 246 ld->rx->op[n].addend = disp * GET_PSCALE (size);
c7927a3c
NC		 247 break;
248 default:
249 abort ();
250 }
251}
252
3cf79a01
DD		 253#define xO 8
254#define xS 4
255#define xZ 2
256#define xC 1
c7927a3c 257
43e65147 258#define F_____
3cf79a01
DD		 259#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
260#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
261#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
262#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
263#define F_O___ rx->flags_0 = rx->flags_s = xO;
264#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
265#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
266#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
c7927a3c
NC		 267
268int
269rx_decode_opcode (unsigned long pc AU,
270 RX_Opcode_Decoded * rx,
271 int (* getbyte)(void *),
272 void * ptr)
273{
274 LocalData lds, * ld = &lds;
275 unsigned char op[20] = {0};
276
277 lds.rx = rx;
278 lds.getbyte = getbyte;
279 lds.ptr = ptr;
280 lds.op = op;
281
282 memset (rx, 0, sizeof (*rx));
283 BWL(LSIZE);
284
285
286/*----------------------------------------------------------------------*/
287/* MOV */
288
289 GETBYTE ();
290 switch (op[0] & 0xff)
291 {
292 case 0x00:
293 {
294 /** 0000 0000 brk */
295 if (trace)
296 {
297 printf ("\033[33m%s\033[0m %02x\n",
298 "/** 0000 0000 brk */",
299 op[0]);
300 }
301 SYNTAX("brk");
e197589b 302#line 1029 "rx-decode.opc"
c7927a3c 303 ID(brk);
43e65147 304
c7927a3c
NC		 305 }
306 break;
307 case 0x01:
308 {
309 /** 0000 0001 dbt */
310 if (trace)
311 {
312 printf ("\033[33m%s\033[0m %02x\n",
313 "/** 0000 0001 dbt */",
314 op[0]);
315 }
316 SYNTAX("dbt");
e197589b 317#line 1032 "rx-decode.opc"
c7927a3c 318 ID(dbt);
43e65147 319
c7927a3c
NC		 320 }
321 break;
322 case 0x02:
323 {
324 /** 0000 0010 rts */
325 if (trace)
326 {
327 printf ("\033[33m%s\033[0m %02x\n",
328 "/** 0000 0010 rts */",
329 op[0]);
330 }
331 SYNTAX("rts");
e197589b 332#line 810 "rx-decode.opc"
c7927a3c 333 ID(rts);
43e65147 334
c7927a3c
NC		 335 /*----------------------------------------------------------------------*/
336 /* NOP */
43e65147 337
c7927a3c
NC		 338 }
339 break;
340 case 0x03:
341 {
342 /** 0000 0011 nop */
343 if (trace)
344 {
345 printf ("\033[33m%s\033[0m %02x\n",
346 "/** 0000 0011 nop */",
347 op[0]);
348 }
349 SYNTAX("nop");
e197589b 350#line 816 "rx-decode.opc"
c7927a3c 351 ID(nop);
43e65147 352
c7927a3c
NC		 353 /*----------------------------------------------------------------------*/
354 /* STRING FUNCTIONS */
43e65147 355
c7927a3c
NC		 356 }
357 break;
358 case 0x04:
359 {
360 /** 0000 0100 bra.a %a0 */
361 if (trace)
362 {
363 printf ("\033[33m%s\033[0m %02x\n",
364 "/** 0000 0100 bra.a %a0 */",
365 op[0]);
366 }
367 SYNTAX("bra.a %a0");
e197589b 368#line 788 "rx-decode.opc"
f9c7014e 369 ID(branch); DC(pc + IMMex(3));
43e65147 370
c7927a3c
NC		 371 }
372 break;
373 case 0x05:
374 {
375 /** 0000 0101 bsr.a %a0 */
376 if (trace)
377 {
378 printf ("\033[33m%s\033[0m %02x\n",
379 "/** 0000 0101 bsr.a %a0 */",
380 op[0]);
381 }
382 SYNTAX("bsr.a %a0");
e197589b 383#line 804 "rx-decode.opc"
c7927a3c 384 ID(jsr); DC(pc + IMMex(3));
43e65147 385
c7927a3c
NC		 386 }
387 break;
388 case 0x06:
389 GETBYTE ();
390 switch (op[1] & 0xff)
391 {
392 case 0x00:
393 GETBYTE ();
394 switch (op[2] & 0x00)
395 {
396 case 0x00:
397 op_semantics_1:
398 {
399 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
e197589b 400#line 546 "rx-decode.opc"
c7927a3c 401 int mx AU = (op[1] >> 6) & 0x03;
e197589b 402#line 546 "rx-decode.opc"
c7927a3c 403 int ss AU = op[1] & 0x03;
e197589b 404#line 546 "rx-decode.opc"
c7927a3c 405 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 406#line 546 "rx-decode.opc"
c7927a3c
NC		 407 int rdst AU = op[2] & 0x0f;
408 if (trace)
409 {
410 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
411 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
412 op[0], op[1], op[2]);
413 printf (" mx = 0x%x,", mx);
414 printf (" ss = 0x%x,", ss);
415 printf (" rsrc = 0x%x,", rsrc);
416 printf (" rdst = 0x%x\n", rdst);
417 }
418 SYNTAX("sub %2%S2, %1");
e197589b 419#line 546 "rx-decode.opc"
3cf79a01 420 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
43e65147 421
c7927a3c
NC		 422 }
423 break;
424 }
425 break;
426 case 0x01:
427 GETBYTE ();
428 switch (op[2] & 0x00)
429 {
430 case 0x00:
431 goto op_semantics_1;
432 break;
433 }
434 break;
435 case 0x02:
436 GETBYTE ();
437 switch (op[2] & 0x00)
438 {
439 case 0x00:
440 goto op_semantics_1;
441 break;
442 }
443 break;
444 case 0x03:
445 GETBYTE ();
446 switch (op[2] & 0x00)
447 {
448 case 0x00:
449 goto op_semantics_1;
450 break;
451 }
452 break;
453 case 0x04:
454 GETBYTE ();
455 switch (op[2] & 0x00)
456 {
457 case 0x00:
458 op_semantics_2:
459 {
460 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
e197589b 461#line 534 "rx-decode.opc"
c7927a3c 462 int mx AU = (op[1] >> 6) & 0x03;
e197589b 463#line 534 "rx-decode.opc"
c7927a3c 464 int ss AU = op[1] & 0x03;
e197589b 465#line 534 "rx-decode.opc"
c7927a3c 466 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 467#line 534 "rx-decode.opc"
c7927a3c
NC		 468 int rdst AU = op[2] & 0x0f;
469 if (trace)
470 {
471 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
472 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
473 op[0], op[1], op[2]);
474 printf (" mx = 0x%x,", mx);
475 printf (" ss = 0x%x,", ss);
476 printf (" rsrc = 0x%x,", rsrc);
477 printf (" rdst = 0x%x\n", rdst);
478 }
479 SYNTAX("cmp %2%S2, %1");
e197589b 480#line 534 "rx-decode.opc"
3cf79a01 481 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
43e65147 482
c7927a3c
NC		 483 /*----------------------------------------------------------------------*/
484 /* SUB */
43e65147 485
c7927a3c
NC		 486 }
487 break;
488 }
489 break;
490 case 0x05:
491 GETBYTE ();
492 switch (op[2] & 0x00)
493 {
494 case 0x00:
495 goto op_semantics_2;
496 break;
497 }
498 break;
499 case 0x06:
500 GETBYTE ();
501 switch (op[2] & 0x00)
502 {
503 case 0x00:
504 goto op_semantics_2;
505 break;
506 }
507 break;
508 case 0x07:
509 GETBYTE ();
510 switch (op[2] & 0x00)
511 {
512 case 0x00:
513 goto op_semantics_2;
514 break;
515 }
516 break;
517 case 0x08:
518 GETBYTE ();
519 switch (op[2] & 0x00)
520 {
521 case 0x00:
522 op_semantics_3:
523 {
524 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
e197589b 525#line 510 "rx-decode.opc"
c7927a3c 526 int mx AU = (op[1] >> 6) & 0x03;
e197589b 527#line 510 "rx-decode.opc"
c7927a3c 528 int ss AU = op[1] & 0x03;
e197589b 529#line 510 "rx-decode.opc"
c7927a3c 530 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 531#line 510 "rx-decode.opc"
c7927a3c
NC		 532 int rdst AU = op[2] & 0x0f;
533 if (trace)
534 {
535 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
536 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
537 op[0], op[1], op[2]);
538 printf (" mx = 0x%x,", mx);
539 printf (" ss = 0x%x,", ss);
540 printf (" rsrc = 0x%x,", rsrc);
541 printf (" rdst = 0x%x\n", rdst);
542 }
543 SYNTAX("add %1%S1, %0");
e197589b 544#line 510 "rx-decode.opc"
3cf79a01 545 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
43e65147 546
c7927a3c
NC		 547 }
548 break;
549 }
550 break;
551 case 0x09:
552 GETBYTE ();
553 switch (op[2] & 0x00)
554 {
555 case 0x00:
556 goto op_semantics_3;
557 break;
558 }
559 break;
560 case 0x0a:
561 GETBYTE ();
562 switch (op[2] & 0x00)
563 {
564 case 0x00:
565 goto op_semantics_3;
566 break;
567 }
568 break;
569 case 0x0b:
570 GETBYTE ();
571 switch (op[2] & 0x00)
572 {
573 case 0x00:
574 goto op_semantics_3;
575 break;
576 }
577 break;
578 case 0x0c:
579 GETBYTE ();
580 switch (op[2] & 0x00)
581 {
582 case 0x00:
583 op_semantics_4:
584 {
585 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
e197589b 586#line 653 "rx-decode.opc"
c7927a3c 587 int mx AU = (op[1] >> 6) & 0x03;
e197589b 588#line 653 "rx-decode.opc"
c7927a3c 589 int ss AU = op[1] & 0x03;
e197589b 590#line 653 "rx-decode.opc"
c7927a3c 591 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 592#line 653 "rx-decode.opc"
c7927a3c
NC		 593 int rdst AU = op[2] & 0x0f;
594 if (trace)
595 {
596 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
597 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
598 op[0], op[1], op[2]);
599 printf (" mx = 0x%x,", mx);
600 printf (" ss = 0x%x,", ss);
601 printf (" rsrc = 0x%x,", rsrc);
602 printf (" rdst = 0x%x\n", rdst);
603 }
604 SYNTAX("mul %1%S1, %0");
e197589b 605#line 653 "rx-decode.opc"
3cf79a01 606 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
43e65147 607
c7927a3c
NC		 608 }
609 break;
610 }
611 break;
612 case 0x0d:
613 GETBYTE ();
614 switch (op[2] & 0x00)
615 {
616 case 0x00:
617 goto op_semantics_4;
618 break;
619 }
620 break;
621 case 0x0e:
622 GETBYTE ();
623 switch (op[2] & 0x00)
624 {
625 case 0x00:
626 goto op_semantics_4;
627 break;
628 }
629 break;
630 case 0x0f:
631 GETBYTE ();
632 switch (op[2] & 0x00)
633 {
634 case 0x00:
635 goto op_semantics_4;
636 break;
637 }
638 break;
639 case 0x10:
640 GETBYTE ();
641 switch (op[2] & 0x00)
642 {
643 case 0x00:
644 op_semantics_5:
645 {
646 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
e197589b 647#line 423 "rx-decode.opc"
c7927a3c 648 int mx AU = (op[1] >> 6) & 0x03;
e197589b 649#line 423 "rx-decode.opc"
c7927a3c 650 int ss AU = op[1] & 0x03;
e197589b 651#line 423 "rx-decode.opc"
c7927a3c 652 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 653#line 423 "rx-decode.opc"
c7927a3c
NC		 654 int rdst AU = op[2] & 0x0f;
655 if (trace)
656 {
657 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
658 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
659 op[0], op[1], op[2]);
660 printf (" mx = 0x%x,", mx);
661 printf (" ss = 0x%x,", ss);
662 printf (" rsrc = 0x%x,", rsrc);
663 printf (" rdst = 0x%x\n", rdst);
664 }
665 SYNTAX("and %1%S1, %0");
e197589b 666#line 423 "rx-decode.opc"
3cf79a01 667 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 668
c7927a3c
NC		 669 }
670 break;
671 }
672 break;
673 case 0x11:
674 GETBYTE ();
675 switch (op[2] & 0x00)
676 {
677 case 0x00:
678 goto op_semantics_5;
679 break;
680 }
681 break;
682 case 0x12:
683 GETBYTE ();
684 switch (op[2] & 0x00)
685 {
686 case 0x00:
687 goto op_semantics_5;
688 break;
689 }
690 break;
691 case 0x13:
692 GETBYTE ();
693 switch (op[2] & 0x00)
694 {
695 case 0x00:
696 goto op_semantics_5;
697 break;
698 }
699 break;
700 case 0x14:
701 GETBYTE ();
702 switch (op[2] & 0x00)
703 {
704 case 0x00:
705 op_semantics_6:
706 {
707 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
e197589b 708#line 441 "rx-decode.opc"
c7927a3c 709 int mx AU = (op[1] >> 6) & 0x03;
e197589b 710#line 441 "rx-decode.opc"
c7927a3c 711 int ss AU = op[1] & 0x03;
e197589b 712#line 441 "rx-decode.opc"
c7927a3c 713 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 714#line 441 "rx-decode.opc"
c7927a3c
NC		 715 int rdst AU = op[2] & 0x0f;
716 if (trace)
717 {
718 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
719 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
720 op[0], op[1], op[2]);
721 printf (" mx = 0x%x,", mx);
722 printf (" ss = 0x%x,", ss);
723 printf (" rsrc = 0x%x,", rsrc);
724 printf (" rdst = 0x%x\n", rdst);
725 }
726 SYNTAX("or %1%S1, %0");
e197589b 727#line 441 "rx-decode.opc"
3cf79a01 728 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 729
c7927a3c
NC		 730 }
731 break;
732 }
733 break;
734 case 0x15:
735 GETBYTE ();
736 switch (op[2] & 0x00)
737 {
738 case 0x00:
739 goto op_semantics_6;
740 break;
741 }
742 break;
743 case 0x16:
744 GETBYTE ();
745 switch (op[2] & 0x00)
746 {
747 case 0x00:
748 goto op_semantics_6;
749 break;
750 }
751 break;
752 case 0x17:
753 GETBYTE ();
754 switch (op[2] & 0x00)
755 {
756 case 0x00:
757 goto op_semantics_6;
758 break;
759 }
760 break;
761 case 0x20:
762 GETBYTE ();
763 switch (op[2] & 0xff)
764 {
765 case 0x00:
766 GETBYTE ();
767 switch (op[3] & 0x00)
768 {
769 case 0x00:
770 op_semantics_7:
771 {
772 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
e197589b 773#line 559 "rx-decode.opc"
c7927a3c 774 int mx AU = (op[1] >> 6) & 0x03;
e197589b 775#line 559 "rx-decode.opc"
c7927a3c 776 int sp AU = op[1] & 0x03;
e197589b 777#line 559 "rx-decode.opc"
c7927a3c 778 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 779#line 559 "rx-decode.opc"
c7927a3c
NC		 780 int rdst AU = op[3] & 0x0f;
781 if (trace)
782 {
783 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
784 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
785 op[0], op[1], op[2], op[3]);
786 printf (" mx = 0x%x,", mx);
787 printf (" sp = 0x%x,", sp);
788 printf (" rsrc = 0x%x,", rsrc);
789 printf (" rdst = 0x%x\n", rdst);
790 }
791 SYNTAX("sbb %1%S1, %0");
e197589b 792#line 559 "rx-decode.opc"
3cf79a01 793 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
43e65147 794
c7927a3c
NC		 795 /*----------------------------------------------------------------------*/
796 /* ABS */
43e65147 797
c7927a3c
NC		 798 }
799 break;
800 }
801 break;
802 case 0x04:
803 GETBYTE ();
804 switch (op[3] & 0x00)
805 {
806 case 0x00:
807 op_semantics_8:
808 {
809 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
e197589b 810#line 598 "rx-decode.opc"
c7927a3c 811 int mx AU = (op[1] >> 6) & 0x03;
e197589b 812#line 598 "rx-decode.opc"
c7927a3c 813 int ss AU = op[1] & 0x03;
e197589b 814#line 598 "rx-decode.opc"
c7927a3c 815 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 816#line 598 "rx-decode.opc"
c7927a3c
NC		 817 int rdst AU = op[3] & 0x0f;
818 if (trace)
819 {
820 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
821 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
822 op[0], op[1], op[2], op[3]);
823 printf (" mx = 0x%x,", mx);
824 printf (" ss = 0x%x,", ss);
825 printf (" rsrc = 0x%x,", rsrc);
826 printf (" rdst = 0x%x\n", rdst);
827 }
828 SYNTAX("max %1%S1, %0");
e197589b 829#line 598 "rx-decode.opc"
c7927a3c 830 ID(max); SPm(ss, rsrc, mx); DR(rdst);
43e65147 831
c7927a3c
NC		 832 /*----------------------------------------------------------------------*/
833 /* MIN */
43e65147 834
c7927a3c
NC		 835 }
836 break;
837 }
838 break;
839 case 0x05:
840 GETBYTE ();
841 switch (op[3] & 0x00)
842 {
843 case 0x00:
844 op_semantics_9:
845 {
846 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
e197589b 847#line 610 "rx-decode.opc"
c7927a3c 848 int mx AU = (op[1] >> 6) & 0x03;
e197589b 849#line 610 "rx-decode.opc"
c7927a3c 850 int ss AU = op[1] & 0x03;
e197589b 851#line 610 "rx-decode.opc"
c7927a3c 852 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 853#line 610 "rx-decode.opc"
c7927a3c
NC		 854 int rdst AU = op[3] & 0x0f;
855 if (trace)
856 {
857 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
858 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
859 op[0], op[1], op[2], op[3]);
860 printf (" mx = 0x%x,", mx);
861 printf (" ss = 0x%x,", ss);
862 printf (" rsrc = 0x%x,", rsrc);
863 printf (" rdst = 0x%x\n", rdst);
864 }
865 SYNTAX("min %1%S1, %0");
e197589b 866#line 610 "rx-decode.opc"
c7927a3c 867 ID(min); SPm(ss, rsrc, mx); DR(rdst);
43e65147 868
c7927a3c
NC		 869 /*----------------------------------------------------------------------*/
870 /* MUL */
43e65147 871
c7927a3c
NC		 872 }
873 break;
874 }
875 break;
876 case 0x06:
877 GETBYTE ();
878 switch (op[3] & 0x00)
879 {
880 case 0x00:
881 op_semantics_10:
882 {
883 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
e197589b 884#line 668 "rx-decode.opc"
c7927a3c 885 int mx AU = (op[1] >> 6) & 0x03;
e197589b 886#line 668 "rx-decode.opc"
c7927a3c 887 int ss AU = op[1] & 0x03;
e197589b 888#line 668 "rx-decode.opc"
c7927a3c 889 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 890#line 668 "rx-decode.opc"
c7927a3c
NC		 891 int rdst AU = op[3] & 0x0f;
892 if (trace)
893 {
894 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
895 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
896 op[0], op[1], op[2], op[3]);
897 printf (" mx = 0x%x,", mx);
898 printf (" ss = 0x%x,", ss);
899 printf (" rsrc = 0x%x,", rsrc);
900 printf (" rdst = 0x%x\n", rdst);
901 }
902 SYNTAX("emul %1%S1, %0");
e197589b 903#line 668 "rx-decode.opc"
c7927a3c 904 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
43e65147 905
c7927a3c
NC		 906 /*----------------------------------------------------------------------*/
907 /* EMULU */
43e65147 908
c7927a3c
NC		 909 }
910 break;
911 }
912 break;
913 case 0x07:
914 GETBYTE ();
915 switch (op[3] & 0x00)
916 {
917 case 0x00:
918 op_semantics_11:
919 {
920 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
e197589b 921#line 680 "rx-decode.opc"
c7927a3c 922 int mx AU = (op[1] >> 6) & 0x03;
e197589b 923#line 680 "rx-decode.opc"
c7927a3c 924 int ss AU = op[1] & 0x03;
e197589b 925#line 680 "rx-decode.opc"
c7927a3c 926 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 927#line 680 "rx-decode.opc"
c7927a3c
NC		 928 int rdst AU = op[3] & 0x0f;
929 if (trace)
930 {
931 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
932 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
933 op[0], op[1], op[2], op[3]);
934 printf (" mx = 0x%x,", mx);
935 printf (" ss = 0x%x,", ss);
936 printf (" rsrc = 0x%x,", rsrc);
937 printf (" rdst = 0x%x\n", rdst);
938 }
939 SYNTAX("emulu %1%S1, %0");
e197589b 940#line 680 "rx-decode.opc"
c7927a3c 941 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
43e65147 942
c7927a3c
NC		 943 /*----------------------------------------------------------------------*/
944 /* DIV */
43e65147 945
c7927a3c
NC		 946 }
947 break;
948 }
949 break;
950 case 0x08:
951 GETBYTE ();
952 switch (op[3] & 0x00)
953 {
954 case 0x00:
955 op_semantics_12:
956 {
957 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
e197589b 958#line 692 "rx-decode.opc"
c7927a3c 959 int mx AU = (op[1] >> 6) & 0x03;
e197589b 960#line 692 "rx-decode.opc"
c7927a3c 961 int ss AU = op[1] & 0x03;
e197589b 962#line 692 "rx-decode.opc"
c7927a3c 963 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 964#line 692 "rx-decode.opc"
c7927a3c
NC		 965 int rdst AU = op[3] & 0x0f;
966 if (trace)
967 {
968 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
969 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
970 op[0], op[1], op[2], op[3]);
971 printf (" mx = 0x%x,", mx);
972 printf (" ss = 0x%x,", ss);
973 printf (" rsrc = 0x%x,", rsrc);
974 printf (" rdst = 0x%x\n", rdst);
975 }
976 SYNTAX("div %1%S1, %0");
e197589b 977#line 692 "rx-decode.opc"
3cf79a01 978 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
43e65147 979
c7927a3c
NC		 980 /*----------------------------------------------------------------------*/
981 /* DIVU */
43e65147 982
c7927a3c
NC		 983 }
984 break;
985 }
986 break;
987 case 0x09:
988 GETBYTE ();
989 switch (op[3] & 0x00)
990 {
991 case 0x00:
992 op_semantics_13:
993 {
994 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
e197589b 995#line 704 "rx-decode.opc"
c7927a3c 996 int mx AU = (op[1] >> 6) & 0x03;
e197589b 997#line 704 "rx-decode.opc"
c7927a3c 998 int ss AU = op[1] & 0x03;
e197589b 999#line 704 "rx-decode.opc"
c7927a3c 1000 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 1001#line 704 "rx-decode.opc"
c7927a3c
NC		 1002 int rdst AU = op[3] & 0x0f;
1003 if (trace)
1004 {
1005 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1006 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1007 op[0], op[1], op[2], op[3]);
1008 printf (" mx = 0x%x,", mx);
1009 printf (" ss = 0x%x,", ss);
1010 printf (" rsrc = 0x%x,", rsrc);
1011 printf (" rdst = 0x%x\n", rdst);
1012 }
1013 SYNTAX("divu %1%S1, %0");
e197589b 1014#line 704 "rx-decode.opc"
3cf79a01 1015 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
43e65147 1016
c7927a3c
NC		 1017 /*----------------------------------------------------------------------*/
1018 /* SHIFT */
43e65147 1019
c7927a3c
NC		 1020 }
1021 break;
1022 }
1023 break;
1024 case 0x0c:
1025 GETBYTE ();
1026 switch (op[3] & 0x00)
1027 {
1028 case 0x00:
1029 op_semantics_14:
1030 {
1031 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
e197589b 1032#line 477 "rx-decode.opc"
c7927a3c 1033 int mx AU = (op[1] >> 6) & 0x03;
e197589b 1034#line 477 "rx-decode.opc"
c7927a3c 1035 int ss AU = op[1] & 0x03;
e197589b 1036#line 477 "rx-decode.opc"
c7927a3c 1037 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 1038#line 477 "rx-decode.opc"
c7927a3c
NC		 1039 int rdst AU = op[3] & 0x0f;
1040 if (trace)
1041 {
1042 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1043 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1044 op[0], op[1], op[2], op[3]);
1045 printf (" mx = 0x%x,", mx);
1046 printf (" ss = 0x%x,", ss);
1047 printf (" rsrc = 0x%x,", rsrc);
1048 printf (" rdst = 0x%x\n", rdst);
1049 }
1050 SYNTAX("tst %1%S1, %2");
e197589b 1051#line 477 "rx-decode.opc"
3cf79a01 1052 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
43e65147 1053
c7927a3c
NC		 1054 /*----------------------------------------------------------------------*/
1055 /* NEG */
43e65147 1056
c7927a3c
NC		 1057 }
1058 break;
1059 }
1060 break;
1061 case 0x0d:
1062 GETBYTE ();
1063 switch (op[3] & 0x00)
1064 {
1065 case 0x00:
1066 op_semantics_15:
1067 {
1068 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
e197589b 1069#line 456 "rx-decode.opc"
c7927a3c 1070 int mx AU = (op[1] >> 6) & 0x03;
e197589b 1071#line 456 "rx-decode.opc"
c7927a3c 1072 int ss AU = op[1] & 0x03;
e197589b 1073#line 456 "rx-decode.opc"
c7927a3c 1074 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 1075#line 456 "rx-decode.opc"
c7927a3c
NC		 1076 int rdst AU = op[3] & 0x0f;
1077 if (trace)
1078 {
1079 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1080 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1081 op[0], op[1], op[2], op[3]);
1082 printf (" mx = 0x%x,", mx);
1083 printf (" ss = 0x%x,", ss);
1084 printf (" rsrc = 0x%x,", rsrc);
1085 printf (" rdst = 0x%x\n", rdst);
1086 }
1087 SYNTAX("xor %1%S1, %0");
e197589b 1088#line 456 "rx-decode.opc"
3cf79a01 1089 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
43e65147 1090
c7927a3c
NC		 1091 /*----------------------------------------------------------------------*/
1092 /* NOT */
43e65147 1093
c7927a3c
NC		 1094 }
1095 break;
1096 }
1097 break;
1098 case 0x10:
1099 GETBYTE ();
1100 switch (op[3] & 0x00)
1101 {
1102 case 0x00:
1103 op_semantics_16:
1104 {
1105 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
e197589b 1106#line 390 "rx-decode.opc"
c7927a3c 1107 int mx AU = (op[1] >> 6) & 0x03;
e197589b 1108#line 390 "rx-decode.opc"
c7927a3c 1109 int ss AU = op[1] & 0x03;
e197589b 1110#line 390 "rx-decode.opc"
c7927a3c 1111 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 1112#line 390 "rx-decode.opc"
c7927a3c
NC		 1113 int rdst AU = op[3] & 0x0f;
1114 if (trace)
1115 {
1116 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1117 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1118 op[0], op[1], op[2], op[3]);
1119 printf (" mx = 0x%x,", mx);
1120 printf (" ss = 0x%x,", ss);
1121 printf (" rsrc = 0x%x,", rsrc);
1122 printf (" rdst = 0x%x\n", rdst);
1123 }
1124 SYNTAX("xchg %1%S1, %0");
e197589b 1125#line 390 "rx-decode.opc"
c7927a3c 1126 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
43e65147 1127
c7927a3c
NC		 1128 /*----------------------------------------------------------------------*/
1129 /* STZ/STNZ */
43e65147 1130
c7927a3c
NC		 1131 }
1132 break;
1133 }
1134 break;
1135 case 0x11:
1136 GETBYTE ();
1137 switch (op[3] & 0x00)
1138 {
1139 case 0x00:
1140 op_semantics_17:
1141 {
1142 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
e197589b 1143#line 933 "rx-decode.opc"
c7927a3c 1144 int mx AU = (op[1] >> 6) & 0x03;
e197589b 1145#line 933 "rx-decode.opc"
c7927a3c 1146 int sd AU = op[1] & 0x03;
e197589b 1147#line 933 "rx-decode.opc"
c7927a3c 1148 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 1149#line 933 "rx-decode.opc"
c7927a3c
NC		 1150 int rdst AU = op[3] & 0x0f;
1151 if (trace)
1152 {
1153 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1154 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1155 op[0], op[1], op[2], op[3]);
1156 printf (" mx = 0x%x,", mx);
1157 printf (" sd = 0x%x,", sd);
1158 printf (" rsrc = 0x%x,", rsrc);
1159 printf (" rdst = 0x%x\n", rdst);
1160 }
1161 SYNTAX("itof %1%S1, %0");
e197589b 1162#line 933 "rx-decode.opc"
3cf79a01 1163 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
43e65147 1164
c7927a3c
NC		 1165 /*----------------------------------------------------------------------*/
1166 /* BIT OPS */
43e65147 1167
a117b0a5
YS		 1168 }
1169 break;
1170 }
1171 break;
1172 case 0x15:
1173 GETBYTE ();
1174 switch (op[3] & 0x00)
1175 {
1176 case 0x00:
1177 op_semantics_18:
1178 {
1179 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
e197589b 1180#line 1119 "rx-decode.opc"
a117b0a5 1181 int mx AU = (op[1] >> 6) & 0x03;
e197589b 1182#line 1119 "rx-decode.opc"
a117b0a5 1183 int sd AU = op[1] & 0x03;
e197589b 1184#line 1119 "rx-decode.opc"
a117b0a5 1185 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 1186#line 1119 "rx-decode.opc"
a117b0a5
YS		 1187 int rdst AU = op[3] & 0x0f;
1188 if (trace)
1189 {
1190 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1191 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1192 op[0], op[1], op[2], op[3]);
1193 printf (" mx = 0x%x,", mx);
1194 printf (" sd = 0x%x,", sd);
1195 printf (" rsrc = 0x%x,", rsrc);
1196 printf (" rdst = 0x%x\n", rdst);
1197 }
1198 SYNTAX("utof %1%S1, %0");
e197589b 1199#line 1119 "rx-decode.opc"
a117b0a5
YS		 1200 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1201
c7927a3c
NC		 1202 }
1203 break;
1204 }
1205 break;
1206 default: UNSUPPORTED(); break;
1207 }
1208 break;
1209 case 0x21:
1210 GETBYTE ();
1211 switch (op[2] & 0xff)
1212 {
1213 case 0x00:
1214 GETBYTE ();
1215 switch (op[3] & 0x00)
1216 {
1217 case 0x00:
1218 goto op_semantics_7;
1219 break;
1220 }
1221 break;
1222 case 0x04:
1223 GETBYTE ();
1224 switch (op[3] & 0x00)
1225 {
1226 case 0x00:
1227 goto op_semantics_8;
1228 break;
1229 }
1230 break;
1231 case 0x05:
1232 GETBYTE ();
1233 switch (op[3] & 0x00)
1234 {
1235 case 0x00:
1236 goto op_semantics_9;
1237 break;
1238 }
1239 break;
1240 case 0x06:
1241 GETBYTE ();
1242 switch (op[3] & 0x00)
1243 {
1244 case 0x00:
1245 goto op_semantics_10;
1246 break;
1247 }
1248 break;
1249 case 0x07:
1250 GETBYTE ();
1251 switch (op[3] & 0x00)
1252 {
1253 case 0x00:
1254 goto op_semantics_11;
1255 break;
1256 }
1257 break;
1258 case 0x08:
1259 GETBYTE ();
1260 switch (op[3] & 0x00)
1261 {
1262 case 0x00:
1263 goto op_semantics_12;
1264 break;
1265 }
1266 break;
1267 case 0x09:
1268 GETBYTE ();
1269 switch (op[3] & 0x00)
1270 {
1271 case 0x00:
1272 goto op_semantics_13;
1273 break;
1274 }
1275 break;
1276 case 0x0c:
1277 GETBYTE ();
1278 switch (op[3] & 0x00)
1279 {
1280 case 0x00:
1281 goto op_semantics_14;
1282 break;
1283 }
1284 break;
1285 case 0x0d:
1286 GETBYTE ();
1287 switch (op[3] & 0x00)
1288 {
1289 case 0x00:
1290 goto op_semantics_15;
1291 break;
1292 }
1293 break;
1294 case 0x10:
1295 GETBYTE ();
1296 switch (op[3] & 0x00)
1297 {
1298 case 0x00:
1299 goto op_semantics_16;
1300 break;
1301 }
1302 break;
1303 case 0x11:
1304 GETBYTE ();
1305 switch (op[3] & 0x00)
1306 {
1307 case 0x00:
1308 goto op_semantics_17;
1309 break;
1310 }
1311 break;
a117b0a5
YS		 1312 case 0x15:
1313 GETBYTE ();
1314 switch (op[3] & 0x00)
1315 {
1316 case 0x00:
1317 goto op_semantics_18;
1318 break;
1319 }
1320 break;
c7927a3c
NC		 1321 default: UNSUPPORTED(); break;
1322 }
1323 break;
1324 case 0x22:
1325 GETBYTE ();
1326 switch (op[2] & 0xff)
1327 {
1328 case 0x00:
1329 GETBYTE ();
1330 switch (op[3] & 0x00)
1331 {
1332 case 0x00:
1333 goto op_semantics_7;
1334 break;
1335 }
1336 break;
1337 case 0x04:
1338 GETBYTE ();
1339 switch (op[3] & 0x00)
1340 {
1341 case 0x00:
1342 goto op_semantics_8;
1343 break;
1344 }
1345 break;
1346 case 0x05:
1347 GETBYTE ();
1348 switch (op[3] & 0x00)
1349 {
1350 case 0x00:
1351 goto op_semantics_9;
1352 break;
1353 }
1354 break;
1355 case 0x06:
1356 GETBYTE ();
1357 switch (op[3] & 0x00)
1358 {
1359 case 0x00:
1360 goto op_semantics_10;
1361 break;
1362 }
1363 break;
1364 case 0x07:
1365 GETBYTE ();
1366 switch (op[3] & 0x00)
1367 {
1368 case 0x00:
1369 goto op_semantics_11;
1370 break;
1371 }
1372 break;
1373 case 0x08:
1374 GETBYTE ();
1375 switch (op[3] & 0x00)
1376 {
1377 case 0x00:
1378 goto op_semantics_12;
1379 break;
1380 }
1381 break;
1382 case 0x09:
1383 GETBYTE ();
1384 switch (op[3] & 0x00)
1385 {
1386 case 0x00:
1387 goto op_semantics_13;
1388 break;
1389 }
1390 break;
1391 case 0x0c:
1392 GETBYTE ();
1393 switch (op[3] & 0x00)
1394 {
1395 case 0x00:
1396 goto op_semantics_14;
1397 break;
1398 }
1399 break;
1400 case 0x0d:
1401 GETBYTE ();
1402 switch (op[3] & 0x00)
1403 {
1404 case 0x00:
1405 goto op_semantics_15;
1406 break;
1407 }
1408 break;
1409 case 0x10:
1410 GETBYTE ();
1411 switch (op[3] & 0x00)
1412 {
1413 case 0x00:
1414 goto op_semantics_16;
1415 break;
1416 }
1417 break;
1418 case 0x11:
1419 GETBYTE ();
1420 switch (op[3] & 0x00)
1421 {
1422 case 0x00:
1423 goto op_semantics_17;
1424 break;
1425 }
1426 break;
a117b0a5
YS		 1427 case 0x15:
1428 GETBYTE ();
1429 switch (op[3] & 0x00)
1430 {
1431 case 0x00:
1432 goto op_semantics_18;
1433 break;
1434 }
1435 break;
c7927a3c
NC		 1436 default: UNSUPPORTED(); break;
1437 }
1438 break;
1439 case 0x23:
1440 GETBYTE ();
1441 switch (op[2] & 0xff)
1442 {
1443 case 0x00:
1444 GETBYTE ();
1445 switch (op[3] & 0x00)
1446 {
1447 case 0x00:
1448 goto op_semantics_7;
1449 break;
1450 }
1451 break;
1452 case 0x04:
1453 GETBYTE ();
1454 switch (op[3] & 0x00)
1455 {
1456 case 0x00:
1457 goto op_semantics_8;
1458 break;
1459 }
1460 break;
1461 case 0x05:
1462 GETBYTE ();
1463 switch (op[3] & 0x00)
1464 {
1465 case 0x00:
1466 goto op_semantics_9;
1467 break;
1468 }
1469 break;
1470 case 0x06:
1471 GETBYTE ();
1472 switch (op[3] & 0x00)
1473 {
1474 case 0x00:
1475 goto op_semantics_10;
1476 break;
1477 }
1478 break;
1479 case 0x07:
1480 GETBYTE ();
1481 switch (op[3] & 0x00)
1482 {
1483 case 0x00:
1484 goto op_semantics_11;
1485 break;
1486 }
1487 break;
1488 case 0x08:
1489 GETBYTE ();
1490 switch (op[3] & 0x00)
1491 {
1492 case 0x00:
1493 goto op_semantics_12;
1494 break;
1495 }
1496 break;
1497 case 0x09:
1498 GETBYTE ();
1499 switch (op[3] & 0x00)
1500 {
1501 case 0x00:
1502 goto op_semantics_13;
1503 break;
1504 }
1505 break;
1506 case 0x0c:
1507 GETBYTE ();
1508 switch (op[3] & 0x00)
1509 {
1510 case 0x00:
1511 goto op_semantics_14;
1512 break;
1513 }
1514 break;
1515 case 0x0d:
1516 GETBYTE ();
1517 switch (op[3] & 0x00)
1518 {
1519 case 0x00:
1520 goto op_semantics_15;
1521 break;
1522 }
1523 break;
1524 case 0x10:
1525 GETBYTE ();
1526 switch (op[3] & 0x00)
1527 {
1528 case 0x00:
1529 goto op_semantics_16;
1530 break;
1531 }
1532 break;
1533 case 0x11:
1534 GETBYTE ();
1535 switch (op[3] & 0x00)
1536 {
1537 case 0x00:
1538 goto op_semantics_17;
1539 break;
1540 }
1541 break;
a117b0a5
YS		 1542 case 0x15:
1543 GETBYTE ();
1544 switch (op[3] & 0x00)
1545 {
1546 case 0x00:
1547 goto op_semantics_18;
1548 break;
1549 }
1550 break;
c7927a3c
NC		 1551 default: UNSUPPORTED(); break;
1552 }
1553 break;
1554 case 0x40:
1555 GETBYTE ();
1556 switch (op[2] & 0x00)
1557 {
1558 case 0x00:
1559 goto op_semantics_1;
1560 break;
1561 }
1562 break;
1563 case 0x41:
1564 GETBYTE ();
1565 switch (op[2] & 0x00)
1566 {
1567 case 0x00:
1568 goto op_semantics_1;
1569 break;
1570 }
1571 break;
1572 case 0x42:
1573 GETBYTE ();
1574 switch (op[2] & 0x00)
1575 {
1576 case 0x00:
1577 goto op_semantics_1;
1578 break;
1579 }
1580 break;
1581 case 0x43:
1582 GETBYTE ();
1583 switch (op[2] & 0x00)
1584 {
1585 case 0x00:
1586 goto op_semantics_1;
1587 break;
1588 }
1589 break;
1590 case 0x44:
1591 GETBYTE ();
1592 switch (op[2] & 0x00)
1593 {
1594 case 0x00:
1595 goto op_semantics_2;
1596 break;
1597 }
1598 break;
1599 case 0x45:
1600 GETBYTE ();
1601 switch (op[2] & 0x00)
1602 {
1603 case 0x00:
1604 goto op_semantics_2;
1605 break;
1606 }
1607 break;
1608 case 0x46:
1609 GETBYTE ();
1610 switch (op[2] & 0x00)
1611 {
1612 case 0x00:
1613 goto op_semantics_2;
1614 break;
1615 }
1616 break;
1617 case 0x47:
1618 GETBYTE ();
1619 switch (op[2] & 0x00)
1620 {
1621 case 0x00:
1622 goto op_semantics_2;
1623 break;
1624 }
1625 break;
1626 case 0x48:
1627 GETBYTE ();
1628 switch (op[2] & 0x00)
1629 {
1630 case 0x00:
1631 goto op_semantics_3;
1632 break;
1633 }
1634 break;
1635 case 0x49:
1636 GETBYTE ();
1637 switch (op[2] & 0x00)
1638 {
1639 case 0x00:
1640 goto op_semantics_3;
1641 break;
1642 }
1643 break;
1644 case 0x4a:
1645 GETBYTE ();
1646 switch (op[2] & 0x00)
1647 {
1648 case 0x00:
1649 goto op_semantics_3;
1650 break;
1651 }
1652 break;
1653 case 0x4b:
1654 GETBYTE ();
1655 switch (op[2] & 0x00)
1656 {
1657 case 0x00:
1658 goto op_semantics_3;
1659 break;
1660 }
1661 break;
1662 case 0x4c:
1663 GETBYTE ();
1664 switch (op[2] & 0x00)
1665 {
1666 case 0x00:
1667 goto op_semantics_4;
1668 break;
1669 }
1670 break;
1671 case 0x4d:
1672 GETBYTE ();
1673 switch (op[2] & 0x00)
1674 {
1675 case 0x00:
1676 goto op_semantics_4;
1677 break;
1678 }
1679 break;
1680 case 0x4e:
1681 GETBYTE ();
1682 switch (op[2] & 0x00)
1683 {
1684 case 0x00:
1685 goto op_semantics_4;
1686 break;
1687 }
1688 break;
1689 case 0x4f:
1690 GETBYTE ();
1691 switch (op[2] & 0x00)
1692 {
1693 case 0x00:
1694 goto op_semantics_4;
1695 break;
1696 }
1697 break;
1698 case 0x50:
1699 GETBYTE ();
1700 switch (op[2] & 0x00)
1701 {
1702 case 0x00:
1703 goto op_semantics_5;
1704 break;
1705 }
1706 break;
1707 case 0x51:
1708 GETBYTE ();
1709 switch (op[2] & 0x00)
1710 {
1711 case 0x00:
1712 goto op_semantics_5;
1713 break;
1714 }
1715 break;
1716 case 0x52:
1717 GETBYTE ();
1718 switch (op[2] & 0x00)
1719 {
1720 case 0x00:
1721 goto op_semantics_5;
1722 break;
1723 }
1724 break;
1725 case 0x53:
1726 GETBYTE ();
1727 switch (op[2] & 0x00)
1728 {
1729 case 0x00:
1730 goto op_semantics_5;
1731 break;
1732 }
1733 break;
1734 case 0x54:
1735 GETBYTE ();
1736 switch (op[2] & 0x00)
1737 {
1738 case 0x00:
1739 goto op_semantics_6;
1740 break;
1741 }
1742 break;
1743 case 0x55:
1744 GETBYTE ();
1745 switch (op[2] & 0x00)
1746 {
1747 case 0x00:
1748 goto op_semantics_6;
1749 break;
1750 }
1751 break;
1752 case 0x56:
1753 GETBYTE ();
1754 switch (op[2] & 0x00)
1755 {
1756 case 0x00:
1757 goto op_semantics_6;
1758 break;
1759 }
1760 break;
1761 case 0x57:
1762 GETBYTE ();
1763 switch (op[2] & 0x00)
1764 {
1765 case 0x00:
1766 goto op_semantics_6;
1767 break;
1768 }
1769 break;
1770 case 0x60:
1771 GETBYTE ();
1772 switch (op[2] & 0xff)
1773 {
1774 case 0x00:
1775 GETBYTE ();
1776 switch (op[3] & 0x00)
1777 {
1778 case 0x00:
1779 goto op_semantics_7;
1780 break;
1781 }
1782 break;
1783 case 0x04:
1784 GETBYTE ();
1785 switch (op[3] & 0x00)
1786 {
1787 case 0x00:
1788 goto op_semantics_8;
1789 break;
1790 }
1791 break;
1792 case 0x05:
1793 GETBYTE ();
1794 switch (op[3] & 0x00)
1795 {
1796 case 0x00:
1797 goto op_semantics_9;
1798 break;
1799 }
1800 break;
1801 case 0x06:
1802 GETBYTE ();
1803 switch (op[3] & 0x00)
1804 {
1805 case 0x00:
1806 goto op_semantics_10;
1807 break;
1808 }
1809 break;
1810 case 0x07:
1811 GETBYTE ();
1812 switch (op[3] & 0x00)
1813 {
1814 case 0x00:
1815 goto op_semantics_11;
1816 break;
1817 }
1818 break;
1819 case 0x08:
1820 GETBYTE ();
1821 switch (op[3] & 0x00)
1822 {
1823 case 0x00:
1824 goto op_semantics_12;
1825 break;
1826 }
1827 break;
1828 case 0x09:
1829 GETBYTE ();
1830 switch (op[3] & 0x00)
1831 {
1832 case 0x00:
1833 goto op_semantics_13;
1834 break;
1835 }
1836 break;
1837 case 0x0c:
1838 GETBYTE ();
1839 switch (op[3] & 0x00)
1840 {
1841 case 0x00:
1842 goto op_semantics_14;
1843 break;
1844 }
1845 break;
1846 case 0x0d:
1847 GETBYTE ();
1848 switch (op[3] & 0x00)
1849 {
1850 case 0x00:
1851 goto op_semantics_15;
1852 break;
1853 }
1854 break;
1855 case 0x10:
1856 GETBYTE ();
1857 switch (op[3] & 0x00)
1858 {
1859 case 0x00:
1860 goto op_semantics_16;
1861 break;
1862 }
1863 break;
1864 case 0x11:
1865 GETBYTE ();
1866 switch (op[3] & 0x00)
1867 {
1868 case 0x00:
1869 goto op_semantics_17;
1870 break;
1871 }
1872 break;
a117b0a5
YS		 1873 case 0x15:
1874 GETBYTE ();
1875 switch (op[3] & 0x00)
1876 {
1877 case 0x00:
1878 goto op_semantics_18;
1879 break;
1880 }
1881 break;
c7927a3c
NC		 1882 default: UNSUPPORTED(); break;
1883 }
1884 break;
1885 case 0x61:
1886 GETBYTE ();
1887 switch (op[2] & 0xff)
1888 {
1889 case 0x00:
1890 GETBYTE ();
1891 switch (op[3] & 0x00)
1892 {
1893 case 0x00:
1894 goto op_semantics_7;
1895 break;
1896 }
1897 break;
1898 case 0x04:
1899 GETBYTE ();
1900 switch (op[3] & 0x00)
1901 {
1902 case 0x00:
1903 goto op_semantics_8;
1904 break;
1905 }
1906 break;
1907 case 0x05:
1908 GETBYTE ();
1909 switch (op[3] & 0x00)
1910 {
1911 case 0x00:
1912 goto op_semantics_9;
1913 break;
1914 }
1915 break;
1916 case 0x06:
1917 GETBYTE ();
1918 switch (op[3] & 0x00)
1919 {
1920 case 0x00:
1921 goto op_semantics_10;
1922 break;
1923 }
1924 break;
1925 case 0x07:
1926 GETBYTE ();
1927 switch (op[3] & 0x00)
1928 {
1929 case 0x00:
1930 goto op_semantics_11;
1931 break;
1932 }
1933 break;
1934 case 0x08:
1935 GETBYTE ();
1936 switch (op[3] & 0x00)
1937 {
1938 case 0x00:
1939 goto op_semantics_12;
1940 break;
1941 }
1942 break;
1943 case 0x09:
1944 GETBYTE ();
1945 switch (op[3] & 0x00)
1946 {
1947 case 0x00:
1948 goto op_semantics_13;
1949 break;
1950 }
1951 break;
1952 case 0x0c:
1953 GETBYTE ();
1954 switch (op[3] & 0x00)
1955 {
1956 case 0x00:
1957 goto op_semantics_14;
1958 break;
1959 }
1960 break;
1961 case 0x0d:
1962 GETBYTE ();
1963 switch (op[3] & 0x00)
1964 {
1965 case 0x00:
1966 goto op_semantics_15;
1967 break;
1968 }
1969 break;
1970 case 0x10:
1971 GETBYTE ();
1972 switch (op[3] & 0x00)
1973 {
1974 case 0x00:
1975 goto op_semantics_16;
1976 break;
1977 }
1978 break;
1979 case 0x11:
1980 GETBYTE ();
1981 switch (op[3] & 0x00)
1982 {
1983 case 0x00:
1984 goto op_semantics_17;
1985 break;
1986 }
1987 break;
a117b0a5
YS		 1988 case 0x15:
1989 GETBYTE ();
1990 switch (op[3] & 0x00)
1991 {
1992 case 0x00:
1993 goto op_semantics_18;
1994 break;
1995 }
1996 break;
c7927a3c
NC		 1997 default: UNSUPPORTED(); break;
1998 }
1999 break;
2000 case 0x62:
2001 GETBYTE ();
2002 switch (op[2] & 0xff)
2003 {
2004 case 0x00:
2005 GETBYTE ();
2006 switch (op[3] & 0x00)
2007 {
2008 case 0x00:
2009 goto op_semantics_7;
2010 break;
2011 }
2012 break;
2013 case 0x04:
2014 GETBYTE ();
2015 switch (op[3] & 0x00)
2016 {
2017 case 0x00:
2018 goto op_semantics_8;
2019 break;
2020 }
2021 break;
2022 case 0x05:
2023 GETBYTE ();
2024 switch (op[3] & 0x00)
2025 {
2026 case 0x00:
2027 goto op_semantics_9;
2028 break;
2029 }
2030 break;
2031 case 0x06:
2032 GETBYTE ();
2033 switch (op[3] & 0x00)
2034 {
2035 case 0x00:
2036 goto op_semantics_10;
2037 break;
2038 }
2039 break;
2040 case 0x07:
2041 GETBYTE ();
2042 switch (op[3] & 0x00)
2043 {
2044 case 0x00:
2045 goto op_semantics_11;
2046 break;
2047 }
2048 break;
2049 case 0x08:
2050 GETBYTE ();
2051 switch (op[3] & 0x00)
2052 {
2053 case 0x00:
2054 goto op_semantics_12;
2055 break;
2056 }
2057 break;
2058 case 0x09:
2059 GETBYTE ();
2060 switch (op[3] & 0x00)
2061 {
2062 case 0x00:
2063 goto op_semantics_13;
2064 break;
2065 }
2066 break;
2067 case 0x0c:
2068 GETBYTE ();
2069 switch (op[3] & 0x00)
2070 {
2071 case 0x00:
2072 goto op_semantics_14;
2073 break;
2074 }
2075 break;
2076 case 0x0d:
2077 GETBYTE ();
2078 switch (op[3] & 0x00)
2079 {
2080 case 0x00:
2081 goto op_semantics_15;
2082 break;
2083 }
2084 break;
2085 case 0x10:
2086 GETBYTE ();
2087 switch (op[3] & 0x00)
2088 {
2089 case 0x00:
2090 goto op_semantics_16;
2091 break;
2092 }
2093 break;
2094 case 0x11:
2095 GETBYTE ();
2096 switch (op[3] & 0x00)
2097 {
2098 case 0x00:
2099 goto op_semantics_17;
2100 break;
2101 }
2102 break;
a117b0a5
YS		 2103 case 0x15:
2104 GETBYTE ();
2105 switch (op[3] & 0x00)
2106 {
2107 case 0x00:
2108 goto op_semantics_18;
2109 break;
2110 }
2111 break;
c7927a3c
NC		 2112 default: UNSUPPORTED(); break;
2113 }
2114 break;
2115 case 0x63:
2116 GETBYTE ();
2117 switch (op[2] & 0xff)
2118 {
2119 case 0x00:
2120 GETBYTE ();
2121 switch (op[3] & 0x00)
2122 {
2123 case 0x00:
2124 goto op_semantics_7;
2125 break;
2126 }
2127 break;
2128 case 0x04:
2129 GETBYTE ();
2130 switch (op[3] & 0x00)
2131 {
2132 case 0x00:
2133 goto op_semantics_8;
2134 break;
2135 }
2136 break;
2137 case 0x05:
2138 GETBYTE ();
2139 switch (op[3] & 0x00)
2140 {
2141 case 0x00:
2142 goto op_semantics_9;
2143 break;
2144 }
2145 break;
2146 case 0x06:
2147 GETBYTE ();
2148 switch (op[3] & 0x00)
2149 {
2150 case 0x00:
2151 goto op_semantics_10;
2152 break;
2153 }
2154 break;
2155 case 0x07:
2156 GETBYTE ();
2157 switch (op[3] & 0x00)
2158 {
2159 case 0x00:
2160 goto op_semantics_11;
2161 break;
2162 }
2163 break;
2164 case 0x08:
2165 GETBYTE ();
2166 switch (op[3] & 0x00)
2167 {
2168 case 0x00:
2169 goto op_semantics_12;
2170 break;
2171 }
2172 break;
2173 case 0x09:
2174 GETBYTE ();
2175 switch (op[3] & 0x00)
2176 {
2177 case 0x00:
2178 goto op_semantics_13;
2179 break;
2180 }
2181 break;
2182 case 0x0c:
2183 GETBYTE ();
2184 switch (op[3] & 0x00)
2185 {
2186 case 0x00:
2187 goto op_semantics_14;
2188 break;
2189 }
2190 break;
2191 case 0x0d:
2192 GETBYTE ();
2193 switch (op[3] & 0x00)
2194 {
2195 case 0x00:
2196 goto op_semantics_15;
2197 break;
2198 }
2199 break;
2200 case 0x10:
2201 GETBYTE ();
2202 switch (op[3] & 0x00)
2203 {
2204 case 0x00:
2205 goto op_semantics_16;
2206 break;
2207 }
2208 break;
2209 case 0x11:
2210 GETBYTE ();
2211 switch (op[3] & 0x00)
2212 {
2213 case 0x00:
2214 goto op_semantics_17;
2215 break;
2216 }
2217 break;
a117b0a5
YS		 2218 case 0x15:
2219 GETBYTE ();
2220 switch (op[3] & 0x00)
2221 {
2222 case 0x00:
2223 goto op_semantics_18;
2224 break;
2225 }
2226 break;
c7927a3c
NC		 2227 default: UNSUPPORTED(); break;
2228 }
2229 break;
2230 case 0x80:
2231 GETBYTE ();
2232 switch (op[2] & 0x00)
2233 {
2234 case 0x00:
2235 goto op_semantics_1;
2236 break;
2237 }
2238 break;
2239 case 0x81:
2240 GETBYTE ();
2241 switch (op[2] & 0x00)
2242 {
2243 case 0x00:
2244 goto op_semantics_1;
2245 break;
2246 }
2247 break;
2248 case 0x82:
2249 GETBYTE ();
2250 switch (op[2] & 0x00)
2251 {
2252 case 0x00:
2253 goto op_semantics_1;
2254 break;
2255 }
2256 break;
2257 case 0x83:
2258 GETBYTE ();
2259 switch (op[2] & 0x00)
2260 {
2261 case 0x00:
2262 goto op_semantics_1;
2263 break;
2264 }
2265 break;
2266 case 0x84:
2267 GETBYTE ();
2268 switch (op[2] & 0x00)
2269 {
2270 case 0x00:
2271 goto op_semantics_2;
2272 break;
2273 }
2274 break;
2275 case 0x85:
2276 GETBYTE ();
2277 switch (op[2] & 0x00)
2278 {
2279 case 0x00:
2280 goto op_semantics_2;
2281 break;
2282 }
2283 break;
2284 case 0x86:
2285 GETBYTE ();
2286 switch (op[2] & 0x00)
2287 {
2288 case 0x00:
2289 goto op_semantics_2;
2290 break;
2291 }
2292 break;
2293 case 0x87:
2294 GETBYTE ();
2295 switch (op[2] & 0x00)
2296 {
2297 case 0x00:
2298 goto op_semantics_2;
2299 break;
2300 }
2301 break;
2302 case 0x88:
2303 GETBYTE ();
2304 switch (op[2] & 0x00)
2305 {
2306 case 0x00:
2307 goto op_semantics_3;
2308 break;
2309 }
2310 break;
2311 case 0x89:
2312 GETBYTE ();
2313 switch (op[2] & 0x00)
2314 {
2315 case 0x00:
2316 goto op_semantics_3;
2317 break;
2318 }
2319 break;
2320 case 0x8a:
2321 GETBYTE ();
2322 switch (op[2] & 0x00)
2323 {
2324 case 0x00:
2325 goto op_semantics_3;
2326 break;
2327 }
2328 break;
2329 case 0x8b:
2330 GETBYTE ();
2331 switch (op[2] & 0x00)
2332 {
2333 case 0x00:
2334 goto op_semantics_3;
2335 break;
2336 }
2337 break;
2338 case 0x8c:
2339 GETBYTE ();
2340 switch (op[2] & 0x00)
2341 {
2342 case 0x00:
2343 goto op_semantics_4;
2344 break;
2345 }
2346 break;
2347 case 0x8d:
2348 GETBYTE ();
2349 switch (op[2] & 0x00)
2350 {
2351 case 0x00:
2352 goto op_semantics_4;
2353 break;
2354 }
2355 break;
2356 case 0x8e:
2357 GETBYTE ();
2358 switch (op[2] & 0x00)
2359 {
2360 case 0x00:
2361 goto op_semantics_4;
2362 break;
2363 }
2364 break;
2365 case 0x8f:
2366 GETBYTE ();
2367 switch (op[2] & 0x00)
2368 {
2369 case 0x00:
2370 goto op_semantics_4;
2371 break;
2372 }
2373 break;
2374 case 0x90:
2375 GETBYTE ();
2376 switch (op[2] & 0x00)
2377 {
2378 case 0x00:
2379 goto op_semantics_5;
2380 break;
2381 }
2382 break;
2383 case 0x91:
2384 GETBYTE ();
2385 switch (op[2] & 0x00)
2386 {
2387 case 0x00:
2388 goto op_semantics_5;
2389 break;
2390 }
2391 break;
2392 case 0x92:
2393 GETBYTE ();
2394 switch (op[2] & 0x00)
2395 {
2396 case 0x00:
2397 goto op_semantics_5;
2398 break;
2399 }
2400 break;
2401 case 0x93:
2402 GETBYTE ();
2403 switch (op[2] & 0x00)
2404 {
2405 case 0x00:
2406 goto op_semantics_5;
2407 break;
2408 }
2409 break;
2410 case 0x94:
2411 GETBYTE ();
2412 switch (op[2] & 0x00)
2413 {
2414 case 0x00:
2415 goto op_semantics_6;
2416 break;
2417 }
2418 break;
2419 case 0x95:
2420 GETBYTE ();
2421 switch (op[2] & 0x00)
2422 {
2423 case 0x00:
2424 goto op_semantics_6;
2425 break;
2426 }
2427 break;
2428 case 0x96:
2429 GETBYTE ();
2430 switch (op[2] & 0x00)
2431 {
2432 case 0x00:
2433 goto op_semantics_6;
2434 break;
2435 }
2436 break;
2437 case 0x97:
2438 GETBYTE ();
2439 switch (op[2] & 0x00)
2440 {
2441 case 0x00:
2442 goto op_semantics_6;
2443 break;
2444 }
2445 break;
2446 case 0xa0:
2447 GETBYTE ();
2448 switch (op[2] & 0xff)
2449 {
2450 case 0x00:
2451 GETBYTE ();
2452 switch (op[3] & 0x00)
2453 {
2454 case 0x00:
2455 goto op_semantics_7;
2456 break;
2457 }
2458 break;
2459 case 0x02:
2460 GETBYTE ();
2461 switch (op[3] & 0x00)
2462 {
2463 case 0x00:
a117b0a5 2464 op_semantics_19:
c7927a3c
NC		 2465 {
2466 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
e197589b 2467#line 498 "rx-decode.opc"
c7927a3c 2468 int ss AU = op[1] & 0x03;
e197589b 2469#line 498 "rx-decode.opc"
c7927a3c 2470 int rsrc AU = (op[3] >> 4) & 0x0f;
e197589b 2471#line 498 "rx-decode.opc"
c7927a3c
NC		 2472 int rdst AU = op[3] & 0x0f;
2473 if (trace)
2474 {
2475 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2476 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2477 op[0], op[1], op[2], op[3]);
2478 printf (" ss = 0x%x,", ss);
2479 printf (" rsrc = 0x%x,", rsrc);
2480 printf (" rdst = 0x%x\n", rdst);
2481 }
2482 SYNTAX("adc %1%S1, %0");
e197589b 2483#line 498 "rx-decode.opc"
3cf79a01 2484 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
43e65147 2485
c7927a3c
NC		 2486 /*----------------------------------------------------------------------*/
2487 /* ADD */
43e65147 2488
c7927a3c
NC		 2489 }
2490 break;
2491 }
2492 break;
2493 case 0x04:
2494 GETBYTE ();
2495 switch (op[3] & 0x00)
2496 {
2497 case 0x00:
2498 goto op_semantics_8;
2499 break;
2500 }
2501 break;
2502 case 0x05:
2503 GETBYTE ();
2504 switch (op[3] & 0x00)
2505 {
2506 case 0x00:
2507 goto op_semantics_9;
2508 break;
2509 }
2510 break;
2511 case 0x06:
2512 GETBYTE ();
2513 switch (op[3] & 0x00)
2514 {
2515 case 0x00:
2516 goto op_semantics_10;
2517 break;
2518 }
2519 break;
2520 case 0x07:
2521 GETBYTE ();
2522 switch (op[3] & 0x00)
2523 {
2524 case 0x00:
2525 goto op_semantics_11;
2526 break;
2527 }
2528 break;
2529 case 0x08:
2530 GETBYTE ();
2531 switch (op[3] & 0x00)
2532 {
2533 case 0x00:
2534 goto op_semantics_12;
2535 break;
2536 }
2537 break;
2538 case 0x09:
2539 GETBYTE ();
2540 switch (op[3] & 0x00)
2541 {
2542 case 0x00:
2543 goto op_semantics_13;
2544 break;
2545 }
2546 break;
2547 case 0x0c:
2548 GETBYTE ();
2549 switch (op[3] & 0x00)
2550 {
2551 case 0x00:
2552 goto op_semantics_14;
2553 break;
2554 }
2555 break;
2556 case 0x0d:
2557 GETBYTE ();
2558 switch (op[3] & 0x00)
2559 {
2560 case 0x00:
2561 goto op_semantics_15;
2562 break;
2563 }
2564 break;
2565 case 0x10:
2566 GETBYTE ();
2567 switch (op[3] & 0x00)
2568 {
2569 case 0x00:
2570 goto op_semantics_16;
2571 break;
2572 }
2573 break;
2574 case 0x11:
2575 GETBYTE ();
2576 switch (op[3] & 0x00)
2577 {
2578 case 0x00:
2579 goto op_semantics_17;
2580 break;
2581 }
2582 break;
a117b0a5
YS		 2583 case 0x15:
2584 GETBYTE ();
2585 switch (op[3] & 0x00)
2586 {
2587 case 0x00:
2588 goto op_semantics_18;
2589 break;
2590 }
2591 break;
c7927a3c
NC		 2592 default: UNSUPPORTED(); break;
2593 }
2594 break;
2595 case 0xa1:
2596 GETBYTE ();
2597 switch (op[2] & 0xff)
2598 {
2599 case 0x00:
2600 GETBYTE ();
2601 switch (op[3] & 0x00)
2602 {
2603 case 0x00:
2604 goto op_semantics_7;
2605 break;
2606 }
2607 break;
2608 case 0x02:
2609 GETBYTE ();
2610 switch (op[3] & 0x00)
2611 {
2612 case 0x00:
a117b0a5 2613 goto op_semantics_19;
c7927a3c
NC		 2614 break;
2615 }
2616 break;
2617 case 0x04:
2618 GETBYTE ();
2619 switch (op[3] & 0x00)
2620 {
2621 case 0x00:
2622 goto op_semantics_8;
2623 break;
2624 }
2625 break;
2626 case 0x05:
2627 GETBYTE ();
2628 switch (op[3] & 0x00)
2629 {
2630 case 0x00:
2631 goto op_semantics_9;
2632 break;
2633 }
2634 break;
2635 case 0x06:
2636 GETBYTE ();
2637 switch (op[3] & 0x00)
2638 {
2639 case 0x00:
2640 goto op_semantics_10;
2641 break;
2642 }
2643 break;
2644 case 0x07:
2645 GETBYTE ();
2646 switch (op[3] & 0x00)
2647 {
2648 case 0x00:
2649 goto op_semantics_11;
2650 break;
2651 }
2652 break;
2653 case 0x08:
2654 GETBYTE ();
2655 switch (op[3] & 0x00)
2656 {
2657 case 0x00:
2658 goto op_semantics_12;
2659 break;
2660 }
2661 break;
2662 case 0x09:
2663 GETBYTE ();
2664 switch (op[3] & 0x00)
2665 {
2666 case 0x00:
2667 goto op_semantics_13;
2668 break;
2669 }
2670 break;
2671 case 0x0c:
2672 GETBYTE ();
2673 switch (op[3] & 0x00)
2674 {
2675 case 0x00:
2676 goto op_semantics_14;
2677 break;
2678 }
2679 break;
2680 case 0x0d:
2681 GETBYTE ();
2682 switch (op[3] & 0x00)
2683 {
2684 case 0x00:
2685 goto op_semantics_15;
2686 break;
2687 }
2688 break;
2689 case 0x10:
2690 GETBYTE ();
2691 switch (op[3] & 0x00)
2692 {
2693 case 0x00:
2694 goto op_semantics_16;
2695 break;
2696 }
2697 break;
2698 case 0x11:
2699 GETBYTE ();
2700 switch (op[3] & 0x00)
2701 {
2702 case 0x00:
2703 goto op_semantics_17;
2704 break;
2705 }
2706 break;
a117b0a5
YS		 2707 case 0x15:
2708 GETBYTE ();
2709 switch (op[3] & 0x00)
2710 {
2711 case 0x00:
2712 goto op_semantics_18;
2713 break;
2714 }
2715 break;
c7927a3c
NC		 2716 default: UNSUPPORTED(); break;
2717 }
2718 break;
2719 case 0xa2:
2720 GETBYTE ();
2721 switch (op[2] & 0xff)
2722 {
2723 case 0x00:
2724 GETBYTE ();
2725 switch (op[3] & 0x00)
2726 {
2727 case 0x00:
2728 goto op_semantics_7;
2729 break;
2730 }
2731 break;
2732 case 0x02:
2733 GETBYTE ();
2734 switch (op[3] & 0x00)
2735 {
2736 case 0x00:
a117b0a5 2737 goto op_semantics_19;
c7927a3c
NC		 2738 break;
2739 }
2740 break;
2741 case 0x04:
2742 GETBYTE ();
2743 switch (op[3] & 0x00)
2744 {
2745 case 0x00:
2746 goto op_semantics_8;
2747 break;
2748 }
2749 break;
2750 case 0x05:
2751 GETBYTE ();
2752 switch (op[3] & 0x00)
2753 {
2754 case 0x00:
2755 goto op_semantics_9;
2756 break;
2757 }
2758 break;
2759 case 0x06:
2760 GETBYTE ();
2761 switch (op[3] & 0x00)
2762 {
2763 case 0x00:
2764 goto op_semantics_10;
2765 break;
2766 }
2767 break;
2768 case 0x07:
2769 GETBYTE ();
2770 switch (op[3] & 0x00)
2771 {
2772 case 0x00:
2773 goto op_semantics_11;
2774 break;
2775 }
2776 break;
2777 case 0x08:
2778 GETBYTE ();
2779 switch (op[3] & 0x00)
2780 {
2781 case 0x00:
2782 goto op_semantics_12;
2783 break;
2784 }
2785 break;
2786 case 0x09:
2787 GETBYTE ();
2788 switch (op[3] & 0x00)
2789 {
2790 case 0x00:
2791 goto op_semantics_13;
2792 break;
2793 }
2794 break;
2795 case 0x0c:
2796 GETBYTE ();
2797 switch (op[3] & 0x00)
2798 {
2799 case 0x00:
2800 goto op_semantics_14;
2801 break;
2802 }
2803 break;
2804 case 0x0d:
2805 GETBYTE ();
2806 switch (op[3] & 0x00)
2807 {
2808 case 0x00:
2809 goto op_semantics_15;
2810 break;
2811 }
2812 break;
2813 case 0x10:
2814 GETBYTE ();
2815 switch (op[3] & 0x00)
2816 {
2817 case 0x00:
2818 goto op_semantics_16;
2819 break;
2820 }
2821 break;
2822 case 0x11:
2823 GETBYTE ();
2824 switch (op[3] & 0x00)
2825 {
2826 case 0x00:
2827 goto op_semantics_17;
2828 break;
2829 }
2830 break;
a117b0a5
YS		 2831 case 0x15:
2832 GETBYTE ();
2833 switch (op[3] & 0x00)
2834 {
2835 case 0x00:
2836 goto op_semantics_18;
2837 break;
2838 }
2839 break;
c7927a3c
NC		 2840 default: UNSUPPORTED(); break;
2841 }
2842 break;
2843 case 0xa3:
2844 GETBYTE ();
2845 switch (op[2] & 0xff)
2846 {
2847 case 0x00:
2848 GETBYTE ();
2849 switch (op[3] & 0x00)
2850 {
2851 case 0x00:
2852 goto op_semantics_7;
2853 break;
2854 }
2855 break;
2856 case 0x02:
2857 GETBYTE ();
2858 switch (op[3] & 0x00)
2859 {
2860 case 0x00:
a117b0a5 2861 goto op_semantics_19;
c7927a3c
NC		 2862 break;
2863 }
2864 break;
2865 case 0x04:
2866 GETBYTE ();
2867 switch (op[3] & 0x00)
2868 {
2869 case 0x00:
2870 goto op_semantics_8;
2871 break;
2872 }
2873 break;
2874 case 0x05:
2875 GETBYTE ();
2876 switch (op[3] & 0x00)
2877 {
2878 case 0x00:
2879 goto op_semantics_9;
2880 break;
2881 }
2882 break;
2883 case 0x06:
2884 GETBYTE ();
2885 switch (op[3] & 0x00)
2886 {
2887 case 0x00:
2888 goto op_semantics_10;
2889 break;
2890 }
2891 break;
2892 case 0x07:
2893 GETBYTE ();
2894 switch (op[3] & 0x00)
2895 {
2896 case 0x00:
2897 goto op_semantics_11;
2898 break;
2899 }
2900 break;
2901 case 0x08:
2902 GETBYTE ();
2903 switch (op[3] & 0x00)
2904 {
2905 case 0x00:
2906 goto op_semantics_12;
2907 break;
2908 }
2909 break;
2910 case 0x09:
2911 GETBYTE ();
2912 switch (op[3] & 0x00)
2913 {
2914 case 0x00:
2915 goto op_semantics_13;
2916 break;
2917 }
2918 break;
2919 case 0x0c:
2920 GETBYTE ();
2921 switch (op[3] & 0x00)
2922 {
2923 case 0x00:
2924 goto op_semantics_14;
2925 break;
2926 }
2927 break;
2928 case 0x0d:
2929 GETBYTE ();
2930 switch (op[3] & 0x00)
2931 {
2932 case 0x00:
2933 goto op_semantics_15;
2934 break;
2935 }
2936 break;
2937 case 0x10:
2938 GETBYTE ();
2939 switch (op[3] & 0x00)
2940 {
2941 case 0x00:
2942 goto op_semantics_16;
2943 break;
2944 }
2945 break;
2946 case 0x11:
2947 GETBYTE ();
2948 switch (op[3] & 0x00)
2949 {
2950 case 0x00:
2951 goto op_semantics_17;
2952 break;
2953 }
2954 break;
a117b0a5
YS		 2955 case 0x15:
2956 GETBYTE ();
2957 switch (op[3] & 0x00)
2958 {
2959 case 0x00:
2960 goto op_semantics_18;
2961 break;
2962 }
2963 break;
c7927a3c
NC		 2964 default: UNSUPPORTED(); break;
2965 }
2966 break;
2967 case 0xc0:
2968 GETBYTE ();
2969 switch (op[2] & 0x00)
2970 {
2971 case 0x00:
2972 goto op_semantics_1;
2973 break;
2974 }
2975 break;
2976 case 0xc1:
2977 GETBYTE ();
2978 switch (op[2] & 0x00)
2979 {
2980 case 0x00:
2981 goto op_semantics_1;
2982 break;
2983 }
2984 break;
2985 case 0xc2:
2986 GETBYTE ();
2987 switch (op[2] & 0x00)
2988 {
2989 case 0x00:
2990 goto op_semantics_1;
2991 break;
2992 }
2993 break;
2994 case 0xc3:
2995 GETBYTE ();
2996 switch (op[2] & 0x00)
2997 {
2998 case 0x00:
2999 goto op_semantics_1;
3000 break;
3001 }
3002 break;
3003 case 0xc4:
3004 GETBYTE ();
3005 switch (op[2] & 0x00)
3006 {
3007 case 0x00:
3008 goto op_semantics_2;
3009 break;
3010 }
3011 break;
3012 case 0xc5:
3013 GETBYTE ();
3014 switch (op[2] & 0x00)
3015 {
3016 case 0x00:
3017 goto op_semantics_2;
3018 break;
3019 }
3020 break;
3021 case 0xc6:
3022 GETBYTE ();
3023 switch (op[2] & 0x00)
3024 {
3025 case 0x00:
3026 goto op_semantics_2;
3027 break;
3028 }
3029 break;
3030 case 0xc7:
3031 GETBYTE ();
3032 switch (op[2] & 0x00)
3033 {
3034 case 0x00:
3035 goto op_semantics_2;
3036 break;
3037 }
3038 break;
3039 case 0xc8:
3040 GETBYTE ();
3041 switch (op[2] & 0x00)
3042 {
3043 case 0x00:
3044 goto op_semantics_3;
3045 break;
3046 }
3047 break;
3048 case 0xc9:
3049 GETBYTE ();
3050 switch (op[2] & 0x00)
3051 {
3052 case 0x00:
3053 goto op_semantics_3;
3054 break;
3055 }
3056 break;
3057 case 0xca:
3058 GETBYTE ();
3059 switch (op[2] & 0x00)
3060 {
3061 case 0x00:
3062 goto op_semantics_3;
3063 break;
3064 }
3065 break;
3066 case 0xcb:
3067 GETBYTE ();
3068 switch (op[2] & 0x00)
3069 {
3070 case 0x00:
3071 goto op_semantics_3;
3072 break;
3073 }
3074 break;
3075 case 0xcc:
3076 GETBYTE ();
3077 switch (op[2] & 0x00)
3078 {
3079 case 0x00:
3080 goto op_semantics_4;
3081 break;
3082 }
3083 break;
3084 case 0xcd:
3085 GETBYTE ();
3086 switch (op[2] & 0x00)
3087 {
3088 case 0x00:
3089 goto op_semantics_4;
3090 break;
3091 }
3092 break;
3093 case 0xce:
3094 GETBYTE ();
3095 switch (op[2] & 0x00)
3096 {
3097 case 0x00:
3098 goto op_semantics_4;
3099 break;
3100 }
3101 break;
3102 case 0xcf:
3103 GETBYTE ();
3104 switch (op[2] & 0x00)
3105 {
3106 case 0x00:
3107 goto op_semantics_4;
3108 break;
3109 }
3110 break;
3111 case 0xd0:
3112 GETBYTE ();
3113 switch (op[2] & 0x00)
3114 {
3115 case 0x00:
3116 goto op_semantics_5;
3117 break;
3118 }
3119 break;
3120 case 0xd1:
3121 GETBYTE ();
3122 switch (op[2] & 0x00)
3123 {
3124 case 0x00:
3125 goto op_semantics_5;
3126 break;
3127 }
3128 break;
3129 case 0xd2:
3130 GETBYTE ();
3131 switch (op[2] & 0x00)
3132 {
3133 case 0x00:
3134 goto op_semantics_5;
3135 break;
3136 }
3137 break;
3138 case 0xd3:
3139 GETBYTE ();
3140 switch (op[2] & 0x00)
3141 {
3142 case 0x00:
3143 goto op_semantics_5;
3144 break;
3145 }
3146 break;
3147 case 0xd4:
3148 GETBYTE ();
3149 switch (op[2] & 0x00)
3150 {
3151 case 0x00:
3152 goto op_semantics_6;
3153 break;
3154 }
3155 break;
3156 case 0xd5:
3157 GETBYTE ();
3158 switch (op[2] & 0x00)
3159 {
3160 case 0x00:
3161 goto op_semantics_6;
3162 break;
3163 }
3164 break;
3165 case 0xd6:
3166 GETBYTE ();
3167 switch (op[2] & 0x00)
3168 {
3169 case 0x00:
3170 goto op_semantics_6;
3171 break;
3172 }
3173 break;
3174 case 0xd7:
3175 GETBYTE ();
3176 switch (op[2] & 0x00)
3177 {
3178 case 0x00:
3179 goto op_semantics_6;
3180 break;
3181 }
3182 break;
3183 case 0xe0:
3184 GETBYTE ();
3185 switch (op[2] & 0xff)
3186 {
3187 case 0x00:
3188 GETBYTE ();
3189 switch (op[3] & 0x00)
3190 {
3191 case 0x00:
3192 goto op_semantics_7;
3193 break;
3194 }
3195 break;
3196 case 0x04:
3197 GETBYTE ();
3198 switch (op[3] & 0x00)
3199 {
3200 case 0x00:
3201 goto op_semantics_8;
3202 break;
3203 }
3204 break;
3205 case 0x05:
3206 GETBYTE ();
3207 switch (op[3] & 0x00)
3208 {
3209 case 0x00:
3210 goto op_semantics_9;
3211 break;
3212 }
3213 break;
3214 case 0x06:
3215 GETBYTE ();
3216 switch (op[3] & 0x00)
3217 {
3218 case 0x00:
3219 goto op_semantics_10;
3220 break;
3221 }
3222 break;
3223 case 0x07:
3224 GETBYTE ();
3225 switch (op[3] & 0x00)
3226 {
3227 case 0x00:
3228 goto op_semantics_11;
3229 break;
3230 }
3231 break;
3232 case 0x08:
3233 GETBYTE ();
3234 switch (op[3] & 0x00)
3235 {
3236 case 0x00:
3237 goto op_semantics_12;
3238 break;
3239 }
3240 break;
3241 case 0x09:
3242 GETBYTE ();
3243 switch (op[3] & 0x00)
3244 {
3245 case 0x00:
3246 goto op_semantics_13;
3247 break;
3248 }
3249 break;
3250 case 0x0c:
3251 GETBYTE ();
3252 switch (op[3] & 0x00)
3253 {
3254 case 0x00:
3255 goto op_semantics_14;
3256 break;
3257 }
3258 break;
3259 case 0x0d:
3260 GETBYTE ();
3261 switch (op[3] & 0x00)
3262 {
3263 case 0x00:
3264 goto op_semantics_15;
3265 break;
3266 }
3267 break;
3268 case 0x10:
3269 GETBYTE ();
3270 switch (op[3] & 0x00)
3271 {
3272 case 0x00:
3273 goto op_semantics_16;
3274 break;
3275 }
3276 break;
3277 case 0x11:
3278 GETBYTE ();
3279 switch (op[3] & 0x00)
3280 {
3281 case 0x00:
3282 goto op_semantics_17;
3283 break;
3284 }
3285 break;
a117b0a5
YS		 3286 case 0x15:
3287 GETBYTE ();
3288 switch (op[3] & 0x00)
3289 {
3290 case 0x00:
3291 goto op_semantics_18;
3292 break;
3293 }
3294 break;
c7927a3c
NC		 3295 default: UNSUPPORTED(); break;
3296 }
3297 break;
3298 case 0xe1:
3299 GETBYTE ();
3300 switch (op[2] & 0xff)
3301 {
3302 case 0x00:
3303 GETBYTE ();
3304 switch (op[3] & 0x00)
3305 {
3306 case 0x00:
3307 goto op_semantics_7;
3308 break;
3309 }
3310 break;
3311 case 0x04:
3312 GETBYTE ();
3313 switch (op[3] & 0x00)
3314 {
3315 case 0x00:
3316 goto op_semantics_8;
3317 break;
3318 }
3319 break;
3320 case 0x05:
3321 GETBYTE ();
3322 switch (op[3] & 0x00)
3323 {
3324 case 0x00:
3325 goto op_semantics_9;
3326 break;
3327 }
3328 break;
3329 case 0x06:
3330 GETBYTE ();
3331 switch (op[3] & 0x00)
3332 {
3333 case 0x00:
3334 goto op_semantics_10;
3335 break;
3336 }
3337 break;
3338 case 0x07:
3339 GETBYTE ();
3340 switch (op[3] & 0x00)
3341 {
3342 case 0x00:
3343 goto op_semantics_11;
3344 break;
3345 }
3346 break;
3347 case 0x08:
3348 GETBYTE ();
3349 switch (op[3] & 0x00)
3350 {
3351 case 0x00:
3352 goto op_semantics_12;
3353 break;
3354 }
3355 break;
3356 case 0x09:
3357 GETBYTE ();
3358 switch (op[3] & 0x00)
3359 {
3360 case 0x00:
3361 goto op_semantics_13;
3362 break;
3363 }
3364 break;
3365 case 0x0c:
3366 GETBYTE ();
3367 switch (op[3] & 0x00)
3368 {
3369 case 0x00:
3370 goto op_semantics_14;
3371 break;
3372 }
3373 break;
3374 case 0x0d:
3375 GETBYTE ();
3376 switch (op[3] & 0x00)
3377 {
3378 case 0x00:
3379 goto op_semantics_15;
3380 break;
3381 }
3382 break;
3383 case 0x10:
3384 GETBYTE ();
3385 switch (op[3] & 0x00)
3386 {
3387 case 0x00:
3388 goto op_semantics_16;
3389 break;
3390 }
3391 break;
3392 case 0x11:
3393 GETBYTE ();
3394 switch (op[3] & 0x00)
3395 {
3396 case 0x00:
3397 goto op_semantics_17;
3398 break;
3399 }
3400 break;
a117b0a5
YS		 3401 case 0x15:
3402 GETBYTE ();
3403 switch (op[3] & 0x00)
3404 {
3405 case 0x00:
3406 goto op_semantics_18;
3407 break;
3408 }
3409 break;
c7927a3c
NC		 3410 default: UNSUPPORTED(); break;
3411 }
3412 break;
3413 case 0xe2:
3414 GETBYTE ();
3415 switch (op[2] & 0xff)
3416 {
3417 case 0x00:
3418 GETBYTE ();
3419 switch (op[3] & 0x00)
3420 {
3421 case 0x00:
3422 goto op_semantics_7;
3423 break;
3424 }
3425 break;
3426 case 0x04:
3427 GETBYTE ();
3428 switch (op[3] & 0x00)
3429 {
3430 case 0x00:
3431 goto op_semantics_8;
3432 break;
3433 }
3434 break;
3435 case 0x05:
3436 GETBYTE ();
3437 switch (op[3] & 0x00)
3438 {
3439 case 0x00:
3440 goto op_semantics_9;
3441 break;
3442 }
3443 break;
3444 case 0x06:
3445 GETBYTE ();
3446 switch (op[3] & 0x00)
3447 {
3448 case 0x00:
3449 goto op_semantics_10;
3450 break;
3451 }
3452 break;
3453 case 0x07:
3454 GETBYTE ();
3455 switch (op[3] & 0x00)
3456 {
3457 case 0x00:
3458 goto op_semantics_11;
3459 break;
3460 }
3461 break;
3462 case 0x08:
3463 GETBYTE ();
3464 switch (op[3] & 0x00)
3465 {
3466 case 0x00:
3467 goto op_semantics_12;
3468 break;
3469 }
3470 break;
3471 case 0x09:
3472 GETBYTE ();
3473 switch (op[3] & 0x00)
3474 {
3475 case 0x00:
3476 goto op_semantics_13;
3477 break;
3478 }
3479 break;
3480 case 0x0c:
3481 GETBYTE ();
3482 switch (op[3] & 0x00)
3483 {
3484 case 0x00:
3485 goto op_semantics_14;
3486 break;
3487 }
3488 break;
3489 case 0x0d:
3490 GETBYTE ();
3491 switch (op[3] & 0x00)
3492 {
3493 case 0x00:
3494 goto op_semantics_15;
3495 break;
3496 }
3497 break;
3498 case 0x10:
3499 GETBYTE ();
3500 switch (op[3] & 0x00)
3501 {
3502 case 0x00:
3503 goto op_semantics_16;
3504 break;
3505 }
3506 break;
3507 case 0x11:
3508 GETBYTE ();
3509 switch (op[3] & 0x00)
3510 {
3511 case 0x00:
3512 goto op_semantics_17;
3513 break;
3514 }
3515 break;
a117b0a5
YS		 3516 case 0x15:
3517 GETBYTE ();
3518 switch (op[3] & 0x00)
3519 {
3520 case 0x00:
3521 goto op_semantics_18;
3522 break;
3523 }
3524 break;
c7927a3c
NC		 3525 default: UNSUPPORTED(); break;
3526 }
3527 break;
3528 case 0xe3:
3529 GETBYTE ();
3530 switch (op[2] & 0xff)
3531 {
3532 case 0x00:
3533 GETBYTE ();
3534 switch (op[3] & 0x00)
3535 {
3536 case 0x00:
3537 goto op_semantics_7;
3538 break;
3539 }
3540 break;
3541 case 0x04:
3542 GETBYTE ();
3543 switch (op[3] & 0x00)
3544 {
3545 case 0x00:
3546 goto op_semantics_8;
3547 break;
3548 }
3549 break;
3550 case 0x05:
3551 GETBYTE ();
3552 switch (op[3] & 0x00)
3553 {
3554 case 0x00:
3555 goto op_semantics_9;
3556 break;
3557 }
3558 break;
3559 case 0x06:
3560 GETBYTE ();
3561 switch (op[3] & 0x00)
3562 {
3563 case 0x00:
3564 goto op_semantics_10;
3565 break;
3566 }
3567 break;
3568 case 0x07:
3569 GETBYTE ();
3570 switch (op[3] & 0x00)
3571 {
3572 case 0x00:
3573 goto op_semantics_11;
3574 break;
3575 }
3576 break;
3577 case 0x08:
3578 GETBYTE ();
3579 switch (op[3] & 0x00)
3580 {
3581 case 0x00:
3582 goto op_semantics_12;
3583 break;
3584 }
3585 break;
3586 case 0x09:
3587 GETBYTE ();
3588 switch (op[3] & 0x00)
3589 {
3590 case 0x00:
3591 goto op_semantics_13;
3592 break;
3593 }
3594 break;
3595 case 0x0c:
3596 GETBYTE ();
3597 switch (op[3] & 0x00)
3598 {
3599 case 0x00:
3600 goto op_semantics_14;
3601 break;
3602 }
3603 break;
3604 case 0x0d:
3605 GETBYTE ();
3606 switch (op[3] & 0x00)
3607 {
3608 case 0x00:
3609 goto op_semantics_15;
3610 break;
3611 }
3612 break;
3613 case 0x10:
3614 GETBYTE ();
3615 switch (op[3] & 0x00)
3616 {
3617 case 0x00:
3618 goto op_semantics_16;
3619 break;
3620 }
3621 break;
3622 case 0x11:
3623 GETBYTE ();
3624 switch (op[3] & 0x00)
3625 {
3626 case 0x00:
3627 goto op_semantics_17;
3628 break;
3629 }
3630 break;
a117b0a5
YS		 3631 case 0x15:
3632 GETBYTE ();
3633 switch (op[3] & 0x00)
3634 {
3635 case 0x00:
3636 goto op_semantics_18;
3637 break;
3638 }
3639 break;
c7927a3c
NC		 3640 default: UNSUPPORTED(); break;
3641 }
3642 break;
3643 default: UNSUPPORTED(); break;
3644 }
3645 break;
3646 case 0x08:
3647 case 0x09:
3648 case 0x0a:
3649 case 0x0b:
3650 case 0x0c:
3651 case 0x0d:
3652 case 0x0e:
3653 case 0x0f:
3654 {
3655 /** 0000 1dsp bra.s %a0 */
e197589b 3656#line 779 "rx-decode.opc"
c7927a3c
NC		 3657 int dsp AU = op[0] & 0x07;
3658 if (trace)
3659 {
3660 printf ("\033[33m%s\033[0m %02x\n",
3661 "/** 0000 1dsp bra.s %a0 */",
3662 op[0]);
3663 printf (" dsp = 0x%x\n", dsp);
3664 }
3665 SYNTAX("bra.s %a0");
e197589b 3666#line 779 "rx-decode.opc"
f9c7014e 3667 ID(branch); DC(pc + dsp3map[dsp]);
43e65147 3668
c7927a3c
NC		 3669 }
3670 break;
3671 case 0x10:
3672 case 0x11:
3673 case 0x12:
3674 case 0x13:
3675 case 0x14:
3676 case 0x15:
3677 case 0x16:
3678 case 0x17:
3679 case 0x18:
3680 case 0x19:
3681 case 0x1a:
3682 case 0x1b:
3683 case 0x1c:
3684 case 0x1d:
3685 case 0x1e:
3686 case 0x1f:
3687 {
3688 /** 0001 n dsp b%1.s %a0 */
e197589b 3689#line 769 "rx-decode.opc"
c7927a3c 3690 int n AU = (op[0] >> 3) & 0x01;
e197589b 3691#line 769 "rx-decode.opc"
c7927a3c
NC		 3692 int dsp AU = op[0] & 0x07;
3693 if (trace)
3694 {
3695 printf ("\033[33m%s\033[0m %02x\n",
3696 "/** 0001 n dsp b%1.s %a0 */",
3697 op[0]);
3698 printf (" n = 0x%x,", n);
3699 printf (" dsp = 0x%x\n", dsp);
3700 }
3701 SYNTAX("b%1.s %a0");
e197589b 3702#line 769 "rx-decode.opc"
c7927a3c 3703 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
43e65147 3704
c7927a3c
NC		 3705 }
3706 break;
3707 case 0x20:
3708 case 0x21:
3709 case 0x22:
3710 case 0x23:
3711 case 0x24:
3712 case 0x25:
3713 case 0x26:
3714 case 0x27:
3715 case 0x28:
3716 case 0x29:
3717 case 0x2a:
3718 case 0x2b:
3719 case 0x2c:
3720 case 0x2d:
3721 case 0x2f:
3722 {
3723 /** 0010 cond b%1.b %a0 */
e197589b 3724#line 772 "rx-decode.opc"
c7927a3c
NC		 3725 int cond AU = op[0] & 0x0f;
3726 if (trace)
3727 {
3728 printf ("\033[33m%s\033[0m %02x\n",
3729 "/** 0010 cond b%1.b %a0 */",
3730 op[0]);
3731 printf (" cond = 0x%x\n", cond);
3732 }
3733 SYNTAX("b%1.b %a0");
e197589b 3734#line 772 "rx-decode.opc"
c7927a3c 3735 ID(branch); Scc(cond); DC(pc + IMMex (1));
43e65147 3736
c7927a3c
NC		 3737 }
3738 break;
3739 case 0x2e:
3740 {
3741 /** 0010 1110 bra.b %a0 */
3742 if (trace)
3743 {
3744 printf ("\033[33m%s\033[0m %02x\n",
3745 "/** 0010 1110 bra.b %a0 */",
3746 op[0]);
3747 }
3748 SYNTAX("bra.b %a0");
e197589b 3749#line 782 "rx-decode.opc"
f9c7014e 3750 ID(branch); DC(pc + IMMex(1));
43e65147 3751
c7927a3c
NC		 3752 }
3753 break;
3754 case 0x38:
3755 {
3756 /** 0011 1000 bra.w %a0 */
3757 if (trace)
3758 {
3759 printf ("\033[33m%s\033[0m %02x\n",
3760 "/** 0011 1000 bra.w %a0 */",
3761 op[0]);
3762 }
3763 SYNTAX("bra.w %a0");
e197589b 3764#line 785 "rx-decode.opc"
f9c7014e 3765 ID(branch); DC(pc + IMMex(2));
43e65147 3766
c7927a3c
NC		 3767 }
3768 break;
3769 case 0x39:
3770 {
3771 /** 0011 1001 bsr.w %a0 */
3772 if (trace)
3773 {
3774 printf ("\033[33m%s\033[0m %02x\n",
3775 "/** 0011 1001 bsr.w %a0 */",
3776 op[0]);
3777 }
3778 SYNTAX("bsr.w %a0");
e197589b 3779#line 801 "rx-decode.opc"
c7927a3c 3780 ID(jsr); DC(pc + IMMex(2));
43e65147 3781
c7927a3c
NC		 3782 }
3783 break;
3784 case 0x3a:
3785 case 0x3b:
3786 {
3787 /** 0011 101c b%1.w %a0 */
e197589b 3788#line 775 "rx-decode.opc"
c7927a3c
NC		 3789 int c AU = op[0] & 0x01;
3790 if (trace)
3791 {
3792 printf ("\033[33m%s\033[0m %02x\n",
3793 "/** 0011 101c b%1.w %a0 */",
3794 op[0]);
3795 printf (" c = 0x%x\n", c);
3796 }
3797 SYNTAX("b%1.w %a0");
e197589b 3798#line 775 "rx-decode.opc"
c7927a3c 3799 ID(branch); Scc(c); DC(pc + IMMex (2));
43e65147
L		 3800
3801
c7927a3c
NC		 3802 }
3803 break;
3804 case 0x3c:
3805 GETBYTE ();
3806 switch (op[1] & 0x00)
3807 {
3808 case 0x00:
a117b0a5 3809 op_semantics_20:
c7927a3c
NC		 3810 {
3811 /** 0011 11sz d dst sppp mov%s #%1, %0 */
e197589b 3812#line 311 "rx-decode.opc"
c7927a3c 3813 int sz AU = op[0] & 0x03;
e197589b 3814#line 311 "rx-decode.opc"
c7927a3c 3815 int d AU = (op[1] >> 7) & 0x01;
e197589b 3816#line 311 "rx-decode.opc"
c7927a3c 3817 int dst AU = (op[1] >> 4) & 0x07;
e197589b 3818#line 311 "rx-decode.opc"
c7927a3c
NC		 3819 int sppp AU = op[1] & 0x0f;
3820 if (trace)
3821 {
3822 printf ("\033[33m%s\033[0m %02x %02x\n",
3823 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3824 op[0], op[1]);
3825 printf (" sz = 0x%x,", sz);
3826 printf (" d = 0x%x,", d);
3827 printf (" dst = 0x%x,", dst);
3828 printf (" sppp = 0x%x\n", sppp);
3829 }
3830 SYNTAX("mov%s #%1, %0");
e197589b 3831#line 311 "rx-decode.opc"
3cf79a01 3832 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
43e65147 3833
c7927a3c
NC		 3834 }
3835 break;
3836 }
3837 break;
3838 case 0x3d:
3839 GETBYTE ();
3840 switch (op[1] & 0x00)
3841 {
3842 case 0x00:
a117b0a5 3843 goto op_semantics_20;
c7927a3c
NC		 3844 break;
3845 }
3846 break;
3847 case 0x3e:
3848 GETBYTE ();
3849 switch (op[1] & 0x00)
3850 {
3851 case 0x00:
a117b0a5 3852 goto op_semantics_20;
c7927a3c
NC		 3853 break;
3854 }
3855 break;
3856 case 0x3f:
3857 GETBYTE ();
3858 switch (op[1] & 0x00)
3859 {
3860 case 0x00:
3861 {
3862 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
e197589b 3863#line 408 "rx-decode.opc"
c7927a3c 3864 int rega AU = (op[1] >> 4) & 0x0f;
e197589b 3865#line 408 "rx-decode.opc"
c7927a3c
NC		 3866 int regb AU = op[1] & 0x0f;
3867 if (trace)
3868 {
3869 printf ("\033[33m%s\033[0m %02x %02x\n",
3870 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3871 op[0], op[1]);
3872 printf (" rega = 0x%x,", rega);
3873 printf (" regb = 0x%x\n", regb);
3874 }
3875 SYNTAX("rtsd #%1, %2-%0");
e197589b 3876#line 408 "rx-decode.opc"
c7927a3c 3877 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
43e65147 3878
c7927a3c
NC		 3879 /*----------------------------------------------------------------------*/
3880 /* AND */
43e65147 3881
c7927a3c
NC		 3882 }
3883 break;
3884 }
3885 break;
3886 case 0x40:
3887 GETBYTE ();
3888 switch (op[1] & 0x00)
3889 {
3890 case 0x00:
a117b0a5 3891 op_semantics_21:
c7927a3c
NC		 3892 {
3893 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
e197589b 3894#line 543 "rx-decode.opc"
c7927a3c 3895 int ss AU = op[0] & 0x03;
e197589b 3896#line 543 "rx-decode.opc"
c7927a3c 3897 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 3898#line 543 "rx-decode.opc"
c7927a3c
NC		 3899 int rdst AU = op[1] & 0x0f;
3900 if (trace)
3901 {
3902 printf ("\033[33m%s\033[0m %02x %02x\n",
3903 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3904 op[0], op[1]);
3905 printf (" ss = 0x%x,", ss);
3906 printf (" rsrc = 0x%x,", rsrc);
3907 printf (" rdst = 0x%x\n", rdst);
3908 }
3909 SYNTAX("sub %2%S2, %1");
e197589b 3910#line 543 "rx-decode.opc"
3cf79a01 3911 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
43e65147 3912
c7927a3c
NC		 3913 }
3914 break;
3915 }
3916 break;
3917 case 0x41:
3918 GETBYTE ();
3919 switch (op[1] & 0x00)
3920 {
3921 case 0x00:
a117b0a5 3922 goto op_semantics_21;
c7927a3c
NC		 3923 break;
3924 }
3925 break;
3926 case 0x42:
3927 GETBYTE ();
3928 switch (op[1] & 0x00)
3929 {
3930 case 0x00:
a117b0a5 3931 goto op_semantics_21;
c7927a3c
NC		 3932 break;
3933 }
3934 break;
3935 case 0x43:
3936 GETBYTE ();
3937 switch (op[1] & 0x00)
3938 {
3939 case 0x00:
a117b0a5 3940 goto op_semantics_21;
c7927a3c
NC		 3941 break;
3942 }
3943 break;
3944 case 0x44:
3945 GETBYTE ();
3946 switch (op[1] & 0x00)
3947 {
3948 case 0x00:
a117b0a5 3949 op_semantics_22:
c7927a3c
NC		 3950 {
3951 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
e197589b 3952#line 531 "rx-decode.opc"
c7927a3c 3953 int ss AU = op[0] & 0x03;
e197589b 3954#line 531 "rx-decode.opc"
c7927a3c 3955 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 3956#line 531 "rx-decode.opc"
c7927a3c
NC		 3957 int rdst AU = op[1] & 0x0f;
3958 if (trace)
3959 {
3960 printf ("\033[33m%s\033[0m %02x %02x\n",
3961 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3962 op[0], op[1]);
3963 printf (" ss = 0x%x,", ss);
3964 printf (" rsrc = 0x%x,", rsrc);
3965 printf (" rdst = 0x%x\n", rdst);
3966 }
3967 SYNTAX("cmp %2%S2, %1");
e197589b 3968#line 531 "rx-decode.opc"
3cf79a01 3969 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
43e65147 3970
c7927a3c
NC		 3971 }
3972 break;
3973 }
3974 break;
3975 case 0x45:
3976 GETBYTE ();
3977 switch (op[1] & 0x00)
3978 {
3979 case 0x00:
a117b0a5 3980 goto op_semantics_22;
c7927a3c
NC		 3981 break;
3982 }
3983 break;
3984 case 0x46:
3985 GETBYTE ();
3986 switch (op[1] & 0x00)
3987 {
3988 case 0x00:
a117b0a5 3989 goto op_semantics_22;
c7927a3c
NC		 3990 break;
3991 }
3992 break;
3993 case 0x47:
3994 GETBYTE ();
3995 switch (op[1] & 0x00)
3996 {
3997 case 0x00:
a117b0a5 3998 goto op_semantics_22;
c7927a3c
NC		 3999 break;
4000 }
4001 break;
4002 case 0x48:
4003 GETBYTE ();
4004 switch (op[1] & 0x00)
4005 {
4006 case 0x00:
a117b0a5 4007 op_semantics_23:
c7927a3c
NC		 4008 {
4009 /** 0100 10ss rsrc rdst add %1%S1, %0 */
e197589b 4010#line 507 "rx-decode.opc"
c7927a3c 4011 int ss AU = op[0] & 0x03;
e197589b 4012#line 507 "rx-decode.opc"
c7927a3c 4013 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 4014#line 507 "rx-decode.opc"
c7927a3c
NC		 4015 int rdst AU = op[1] & 0x0f;
4016 if (trace)
4017 {
4018 printf ("\033[33m%s\033[0m %02x %02x\n",
4019 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4020 op[0], op[1]);
4021 printf (" ss = 0x%x,", ss);
4022 printf (" rsrc = 0x%x,", rsrc);
4023 printf (" rdst = 0x%x\n", rdst);
4024 }
4025 SYNTAX("add %1%S1, %0");
e197589b 4026#line 507 "rx-decode.opc"
3cf79a01 4027 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
43e65147 4028
c7927a3c
NC		 4029 }
4030 break;
4031 }
4032 break;
4033 case 0x49:
4034 GETBYTE ();
4035 switch (op[1] & 0x00)
4036 {
4037 case 0x00:
a117b0a5 4038 goto op_semantics_23;
c7927a3c
NC		 4039 break;
4040 }
4041 break;
4042 case 0x4a:
4043 GETBYTE ();
4044 switch (op[1] & 0x00)
4045 {
4046 case 0x00:
a117b0a5 4047 goto op_semantics_23;
c7927a3c
NC		 4048 break;
4049 }
4050 break;
4051 case 0x4b:
4052 GETBYTE ();
4053 switch (op[1] & 0x00)
4054 {
4055 case 0x00:
a117b0a5 4056 goto op_semantics_23;
c7927a3c
NC		 4057 break;
4058 }
4059 break;
4060 case 0x4c:
4061 GETBYTE ();
4062 switch (op[1] & 0x00)
4063 {
4064 case 0x00:
a117b0a5 4065 op_semantics_24:
c7927a3c
NC		 4066 {
4067 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
e197589b 4068#line 650 "rx-decode.opc"
c7927a3c 4069 int ss AU = op[0] & 0x03;
e197589b 4070#line 650 "rx-decode.opc"
c7927a3c 4071 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 4072#line 650 "rx-decode.opc"
c7927a3c
NC		 4073 int rdst AU = op[1] & 0x0f;
4074 if (trace)
4075 {
4076 printf ("\033[33m%s\033[0m %02x %02x\n",
4077 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4078 op[0], op[1]);
4079 printf (" ss = 0x%x,", ss);
4080 printf (" rsrc = 0x%x,", rsrc);
4081 printf (" rdst = 0x%x\n", rdst);
4082 }
4083 SYNTAX("mul %1%S1, %0");
e197589b 4084#line 650 "rx-decode.opc"
3cf79a01 4085 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
43e65147 4086
c7927a3c
NC		 4087 }
4088 break;
4089 }
4090 break;
4091 case 0x4d:
4092 GETBYTE ();
4093 switch (op[1] & 0x00)
4094 {
4095 case 0x00:
a117b0a5 4096 goto op_semantics_24;
c7927a3c
NC		 4097 break;
4098 }
4099 break;
4100 case 0x4e:
4101 GETBYTE ();
4102 switch (op[1] & 0x00)
4103 {
4104 case 0x00:
a117b0a5 4105 goto op_semantics_24;
c7927a3c
NC		 4106 break;
4107 }
4108 break;
4109 case 0x4f:
4110 GETBYTE ();
4111 switch (op[1] & 0x00)
4112 {
4113 case 0x00:
a117b0a5 4114 goto op_semantics_24;
c7927a3c
NC		 4115 break;
4116 }
4117 break;
4118 case 0x50:
4119 GETBYTE ();
4120 switch (op[1] & 0x00)
4121 {
4122 case 0x00:
a117b0a5 4123 op_semantics_25:
c7927a3c
NC		 4124 {
4125 /** 0101 00ss rsrc rdst and %1%S1, %0 */
e197589b 4126#line 420 "rx-decode.opc"
c7927a3c 4127 int ss AU = op[0] & 0x03;
e197589b 4128#line 420 "rx-decode.opc"
c7927a3c 4129 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 4130#line 420 "rx-decode.opc"
c7927a3c
NC		 4131 int rdst AU = op[1] & 0x0f;
4132 if (trace)
4133 {
4134 printf ("\033[33m%s\033[0m %02x %02x\n",
4135 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4136 op[0], op[1]);
4137 printf (" ss = 0x%x,", ss);
4138 printf (" rsrc = 0x%x,", rsrc);
4139 printf (" rdst = 0x%x\n", rdst);
4140 }
4141 SYNTAX("and %1%S1, %0");
e197589b 4142#line 420 "rx-decode.opc"
3cf79a01 4143 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 4144
c7927a3c
NC		 4145 }
4146 break;
4147 }
4148 break;
4149 case 0x51:
4150 GETBYTE ();
4151 switch (op[1] & 0x00)
4152 {
4153 case 0x00:
a117b0a5 4154 goto op_semantics_25;
c7927a3c
NC		 4155 break;
4156 }
4157 break;
4158 case 0x52:
4159 GETBYTE ();
4160 switch (op[1] & 0x00)
4161 {
4162 case 0x00:
a117b0a5 4163 goto op_semantics_25;
c7927a3c
NC		 4164 break;
4165 }
4166 break;
4167 case 0x53:
4168 GETBYTE ();
4169 switch (op[1] & 0x00)
4170 {
4171 case 0x00:
a117b0a5 4172 goto op_semantics_25;
c7927a3c
NC		 4173 break;
4174 }
4175 break;
4176 case 0x54:
4177 GETBYTE ();
4178 switch (op[1] & 0x00)
4179 {
4180 case 0x00:
a117b0a5 4181 op_semantics_26:
c7927a3c
NC		 4182 {
4183 /** 0101 01ss rsrc rdst or %1%S1, %0 */
e197589b 4184#line 438 "rx-decode.opc"
c7927a3c 4185 int ss AU = op[0] & 0x03;
e197589b 4186#line 438 "rx-decode.opc"
c7927a3c 4187 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 4188#line 438 "rx-decode.opc"
c7927a3c
NC		 4189 int rdst AU = op[1] & 0x0f;
4190 if (trace)
4191 {
4192 printf ("\033[33m%s\033[0m %02x %02x\n",
4193 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4194 op[0], op[1]);
4195 printf (" ss = 0x%x,", ss);
4196 printf (" rsrc = 0x%x,", rsrc);
4197 printf (" rdst = 0x%x\n", rdst);
4198 }
4199 SYNTAX("or %1%S1, %0");
e197589b 4200#line 438 "rx-decode.opc"
3cf79a01 4201 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 4202
c7927a3c
NC		 4203 }
4204 break;
4205 }
4206 break;
4207 case 0x55:
4208 GETBYTE ();
4209 switch (op[1] & 0x00)
4210 {
4211 case 0x00:
a117b0a5 4212 goto op_semantics_26;
c7927a3c
NC		 4213 break;
4214 }
4215 break;
4216 case 0x56:
4217 GETBYTE ();
4218 switch (op[1] & 0x00)
4219 {
4220 case 0x00:
a117b0a5 4221 goto op_semantics_26;
c7927a3c
NC		 4222 break;
4223 }
4224 break;
4225 case 0x57:
4226 GETBYTE ();
4227 switch (op[1] & 0x00)
4228 {
4229 case 0x00:
a117b0a5 4230 goto op_semantics_26;
c7927a3c
NC		 4231 break;
4232 }
4233 break;
4234 case 0x58:
4235 GETBYTE ();
4236 switch (op[1] & 0x00)
4237 {
4238 case 0x00:
a117b0a5 4239 op_semantics_27:
c7927a3c
NC		 4240 {
4241 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
e197589b 4242#line 359 "rx-decode.opc"
c7927a3c 4243 int s AU = (op[0] >> 2) & 0x01;
e197589b 4244#line 359 "rx-decode.opc"
c7927a3c 4245 int ss AU = op[0] & 0x03;
e197589b 4246#line 359 "rx-decode.opc"
c7927a3c 4247 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 4248#line 359 "rx-decode.opc"
c7927a3c
NC		 4249 int rdst AU = op[1] & 0x0f;
4250 if (trace)
4251 {
4252 printf ("\033[33m%s\033[0m %02x %02x\n",
4253 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4254 op[0], op[1]);
4255 printf (" s = 0x%x,", s);
4256 printf (" ss = 0x%x,", ss);
4257 printf (" rsrc = 0x%x,", rsrc);
4258 printf (" rdst = 0x%x\n", rdst);
4259 }
4260 SYNTAX("movu%s %1, %0");
e197589b 4261#line 359 "rx-decode.opc"
f04265ec 4262 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
43e65147 4263
c7927a3c
NC		 4264 }
4265 break;
4266 }
4267 break;
4268 case 0x59:
4269 GETBYTE ();
4270 switch (op[1] & 0x00)
4271 {
4272 case 0x00:
a117b0a5 4273 goto op_semantics_27;
c7927a3c
NC		 4274 break;
4275 }
4276 break;
4277 case 0x5a:
4278 GETBYTE ();
4279 switch (op[1] & 0x00)
4280 {
4281 case 0x00:
a117b0a5 4282 goto op_semantics_27;
c7927a3c
NC		 4283 break;
4284 }
4285 break;
4286 case 0x5b:
4287 GETBYTE ();
4288 switch (op[1] & 0x00)
4289 {
4290 case 0x00:
a117b0a5 4291 goto op_semantics_27;
c7927a3c
NC		 4292 break;
4293 }
4294 break;
4295 case 0x5c:
4296 GETBYTE ();
4297 switch (op[1] & 0x00)
4298 {
4299 case 0x00:
a117b0a5 4300 goto op_semantics_27;
c7927a3c
NC		 4301 break;
4302 }
4303 break;
4304 case 0x5d:
4305 GETBYTE ();
4306 switch (op[1] & 0x00)
4307 {
4308 case 0x00:
a117b0a5 4309 goto op_semantics_27;
c7927a3c
NC		 4310 break;
4311 }
4312 break;
4313 case 0x5e:
4314 GETBYTE ();
4315 switch (op[1] & 0x00)
4316 {
4317 case 0x00:
a117b0a5 4318 goto op_semantics_27;
c7927a3c
NC		 4319 break;
4320 }
4321 break;
4322 case 0x5f:
4323 GETBYTE ();
4324 switch (op[1] & 0x00)
4325 {
4326 case 0x00:
a117b0a5 4327 goto op_semantics_27;
c7927a3c
NC		 4328 break;
4329 }
4330 break;
4331 case 0x60:
4332 GETBYTE ();
4333 switch (op[1] & 0x00)
4334 {
4335 case 0x00:
4336 {
4337 /** 0110 0000 immm rdst sub #%2, %0 */
e197589b 4338#line 540 "rx-decode.opc"
c7927a3c 4339 int immm AU = (op[1] >> 4) & 0x0f;
e197589b 4340#line 540 "rx-decode.opc"
c7927a3c
NC		 4341 int rdst AU = op[1] & 0x0f;
4342 if (trace)
4343 {
4344 printf ("\033[33m%s\033[0m %02x %02x\n",
4345 "/** 0110 0000 immm rdst sub #%2, %0 */",
4346 op[0], op[1]);
4347 printf (" immm = 0x%x,", immm);
4348 printf (" rdst = 0x%x\n", rdst);
4349 }
4350 SYNTAX("sub #%2, %0");
e197589b 4351#line 540 "rx-decode.opc"
3cf79a01 4352 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
43e65147 4353
c7927a3c
NC		 4354 }
4355 break;
4356 }
4357 break;
4358 case 0x61:
4359 GETBYTE ();
4360 switch (op[1] & 0x00)
4361 {
4362 case 0x00:
4363 {
4364 /** 0110 0001 immm rdst cmp #%2, %1 */
e197589b 4365#line 522 "rx-decode.opc"
c7927a3c 4366 int immm AU = (op[1] >> 4) & 0x0f;
e197589b 4367#line 522 "rx-decode.opc"
c7927a3c
NC		 4368 int rdst AU = op[1] & 0x0f;
4369 if (trace)
4370 {
4371 printf ("\033[33m%s\033[0m %02x %02x\n",
4372 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4373 op[0], op[1]);
4374 printf (" immm = 0x%x,", immm);
4375 printf (" rdst = 0x%x\n", rdst);
4376 }
4377 SYNTAX("cmp #%2, %1");
e197589b 4378#line 522 "rx-decode.opc"
3cf79a01 4379 ID(sub); S2C(immm); SR(rdst); F_OSZC;
43e65147 4380
c7927a3c
NC		 4381 }
4382 break;
4383 }
4384 break;
4385 case 0x62:
4386 GETBYTE ();
4387 switch (op[1] & 0x00)
4388 {
4389 case 0x00:
4390 {
4391 /** 0110 0010 immm rdst add #%1, %0 */
e197589b 4392#line 504 "rx-decode.opc"
c7927a3c 4393 int immm AU = (op[1] >> 4) & 0x0f;
e197589b 4394#line 504 "rx-decode.opc"
c7927a3c
NC		 4395 int rdst AU = op[1] & 0x0f;
4396 if (trace)
4397 {
4398 printf ("\033[33m%s\033[0m %02x %02x\n",
4399 "/** 0110 0010 immm rdst add #%1, %0 */",
4400 op[0], op[1]);
4401 printf (" immm = 0x%x,", immm);
4402 printf (" rdst = 0x%x\n", rdst);
4403 }
4404 SYNTAX("add #%1, %0");
e197589b 4405#line 504 "rx-decode.opc"
3cf79a01 4406 ID(add); SC(immm); DR(rdst); F_OSZC;
43e65147 4407
c7927a3c
NC		 4408 }
4409 break;
4410 }
4411 break;
4412 case 0x63:
4413 GETBYTE ();
4414 switch (op[1] & 0x00)
4415 {
4416 case 0x00:
4417 {
4418 /** 0110 0011 immm rdst mul #%1, %0 */
e197589b 4419#line 616 "rx-decode.opc"
c7927a3c 4420 int immm AU = (op[1] >> 4) & 0x0f;
e197589b 4421#line 616 "rx-decode.opc"
c7927a3c
NC		 4422 int rdst AU = op[1] & 0x0f;
4423 if (trace)
4424 {
4425 printf ("\033[33m%s\033[0m %02x %02x\n",
4426 "/** 0110 0011 immm rdst mul #%1, %0 */",
4427 op[0], op[1]);
4428 printf (" immm = 0x%x,", immm);
4429 printf (" rdst = 0x%x\n", rdst);
4430 }
4431 SYNTAX("mul #%1, %0");
e197589b 4432#line 616 "rx-decode.opc"
a117b0a5
YS		 4433 if (immm == 1 && rdst == 0)
4434 {
4435 ID(nop2);
4436 SYNTAX ("nop\t; mul\t#1, r0");
4437 }
4438 else
4439 {
4440 ID(mul);
4441 }
4442 DR(rdst); SC(immm); F_____;
4443
c7927a3c
NC		 4444 }
4445 break;
4446 }
4447 break;
4448 case 0x64:
4449 GETBYTE ();
4450 switch (op[1] & 0x00)
4451 {
4452 case 0x00:
4453 {
4454 /** 0110 0100 immm rdst and #%1, %0 */
e197589b 4455#line 414 "rx-decode.opc"
c7927a3c 4456 int immm AU = (op[1] >> 4) & 0x0f;
e197589b 4457#line 414 "rx-decode.opc"
c7927a3c
NC		 4458 int rdst AU = op[1] & 0x0f;
4459 if (trace)
4460 {
4461 printf ("\033[33m%s\033[0m %02x %02x\n",
4462 "/** 0110 0100 immm rdst and #%1, %0 */",
4463 op[0], op[1]);
4464 printf (" immm = 0x%x,", immm);
4465 printf (" rdst = 0x%x\n", rdst);
4466 }
4467 SYNTAX("and #%1, %0");
e197589b 4468#line 414 "rx-decode.opc"
3cf79a01 4469 ID(and); SC(immm); DR(rdst); F__SZ_;
43e65147 4470
c7927a3c
NC		 4471 }
4472 break;
4473 }
4474 break;
4475 case 0x65:
4476 GETBYTE ();
4477 switch (op[1] & 0x00)
4478 {
4479 case 0x00:
4480 {
4481 /** 0110 0101 immm rdst or #%1, %0 */
e197589b 4482#line 432 "rx-decode.opc"
c7927a3c 4483 int immm AU = (op[1] >> 4) & 0x0f;
e197589b 4484#line 432 "rx-decode.opc"
c7927a3c
NC		 4485 int rdst AU = op[1] & 0x0f;
4486 if (trace)
4487 {
4488 printf ("\033[33m%s\033[0m %02x %02x\n",
4489 "/** 0110 0101 immm rdst or #%1, %0 */",
4490 op[0], op[1]);
4491 printf (" immm = 0x%x,", immm);
4492 printf (" rdst = 0x%x\n", rdst);
4493 }
4494 SYNTAX("or #%1, %0");
e197589b 4495#line 432 "rx-decode.opc"
3cf79a01 4496 ID(or); SC(immm); DR(rdst); F__SZ_;
43e65147 4497
c7927a3c
NC		 4498 }
4499 break;
4500 }
4501 break;
4502 case 0x66:
4503 GETBYTE ();
4504 switch (op[1] & 0x00)
4505 {
4506 case 0x00:
4507 {
4508 /** 0110 0110 immm rdst mov%s #%1, %0 */
e197589b 4509#line 308 "rx-decode.opc"
c7927a3c 4510 int immm AU = (op[1] >> 4) & 0x0f;
e197589b 4511#line 308 "rx-decode.opc"
c7927a3c
NC		 4512 int rdst AU = op[1] & 0x0f;
4513 if (trace)
4514 {
4515 printf ("\033[33m%s\033[0m %02x %02x\n",
4516 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4517 op[0], op[1]);
4518 printf (" immm = 0x%x,", immm);
4519 printf (" rdst = 0x%x\n", rdst);
4520 }
4521 SYNTAX("mov%s #%1, %0");
e197589b 4522#line 308 "rx-decode.opc"
3cf79a01 4523 ID(mov); DR(rdst); SC(immm); F_____;
43e65147 4524
c7927a3c
NC		 4525 }
4526 break;
4527 }
4528 break;
4529 case 0x67:
4530 {
4531 /** 0110 0111 rtsd #%1 */
4532 if (trace)
4533 {
4534 printf ("\033[33m%s\033[0m %02x\n",
4535 "/** 0110 0111 rtsd #%1 */",
4536 op[0]);
4537 }
4538 SYNTAX("rtsd #%1");
e197589b 4539#line 405 "rx-decode.opc"
c7927a3c 4540 ID(rtsd); SC(IMM(1) * 4);
43e65147 4541
c7927a3c
NC		 4542 }
4543 break;
4544 case 0x68:
4545 GETBYTE ();
4546 switch (op[1] & 0x00)
4547 {
4548 case 0x00:
a117b0a5 4549 op_semantics_28:
c7927a3c
NC		 4550 {
4551 /** 0110 100i mmmm rdst shlr #%2, %0 */
e197589b 4552#line 730 "rx-decode.opc"
c7927a3c 4553 int i AU = op[0] & 0x01;
e197589b 4554#line 730 "rx-decode.opc"
c7927a3c 4555 int mmmm AU = (op[1] >> 4) & 0x0f;
e197589b 4556#line 730 "rx-decode.opc"
c7927a3c
NC		 4557 int rdst AU = op[1] & 0x0f;
4558 if (trace)
4559 {
4560 printf ("\033[33m%s\033[0m %02x %02x\n",
4561 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4562 op[0], op[1]);
4563 printf (" i = 0x%x,", i);
4564 printf (" mmmm = 0x%x,", mmmm);
4565 printf (" rdst = 0x%x\n", rdst);
4566 }
4567 SYNTAX("shlr #%2, %0");
e197589b 4568#line 730 "rx-decode.opc"
3cf79a01 4569 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
43e65147 4570
c7927a3c
NC		 4571 }
4572 break;
4573 }
4574 break;
4575 case 0x69:
4576 GETBYTE ();
4577 switch (op[1] & 0x00)
4578 {
4579 case 0x00:
a117b0a5 4580 goto op_semantics_28;
c7927a3c
NC		 4581 break;
4582 }
4583 break;
4584 case 0x6a:
4585 GETBYTE ();
4586 switch (op[1] & 0x00)
4587 {
4588 case 0x00:
a117b0a5 4589 op_semantics_29:
c7927a3c
NC		 4590 {
4591 /** 0110 101i mmmm rdst shar #%2, %0 */
e197589b 4592#line 720 "rx-decode.opc"
c7927a3c 4593 int i AU = op[0] & 0x01;
e197589b 4594#line 720 "rx-decode.opc"
c7927a3c 4595 int mmmm AU = (op[1] >> 4) & 0x0f;
e197589b 4596#line 720 "rx-decode.opc"
c7927a3c
NC		 4597 int rdst AU = op[1] & 0x0f;
4598 if (trace)
4599 {
4600 printf ("\033[33m%s\033[0m %02x %02x\n",
4601 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4602 op[0], op[1]);
4603 printf (" i = 0x%x,", i);
4604 printf (" mmmm = 0x%x,", mmmm);
4605 printf (" rdst = 0x%x\n", rdst);
4606 }
4607 SYNTAX("shar #%2, %0");
e197589b 4608#line 720 "rx-decode.opc"
3cf79a01 4609 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
43e65147 4610
c7927a3c
NC		 4611 }
4612 break;
4613 }
4614 break;
4615 case 0x6b:
4616 GETBYTE ();
4617 switch (op[1] & 0x00)
4618 {
4619 case 0x00:
a117b0a5 4620 goto op_semantics_29;
c7927a3c
NC		 4621 break;
4622 }
4623 break;
4624 case 0x6c:
4625 GETBYTE ();
4626 switch (op[1] & 0x00)
4627 {
4628 case 0x00:
a117b0a5 4629 op_semantics_30:
c7927a3c
NC		 4630 {
4631 /** 0110 110i mmmm rdst shll #%2, %0 */
e197589b 4632#line 710 "rx-decode.opc"
c7927a3c 4633 int i AU = op[0] & 0x01;
e197589b 4634#line 710 "rx-decode.opc"
c7927a3c 4635 int mmmm AU = (op[1] >> 4) & 0x0f;
e197589b 4636#line 710 "rx-decode.opc"
c7927a3c
NC		 4637 int rdst AU = op[1] & 0x0f;
4638 if (trace)
4639 {
4640 printf ("\033[33m%s\033[0m %02x %02x\n",
4641 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4642 op[0], op[1]);
4643 printf (" i = 0x%x,", i);
4644 printf (" mmmm = 0x%x,", mmmm);
4645 printf (" rdst = 0x%x\n", rdst);
4646 }
4647 SYNTAX("shll #%2, %0");
e197589b 4648#line 710 "rx-decode.opc"
3cf79a01 4649 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
43e65147 4650
c7927a3c
NC		 4651 }
4652 break;
4653 }
4654 break;
4655 case 0x6d:
4656 GETBYTE ();
4657 switch (op[1] & 0x00)
4658 {
4659 case 0x00:
a117b0a5 4660 goto op_semantics_30;
c7927a3c
NC		 4661 break;
4662 }
4663 break;
4664 case 0x6e:
4665 GETBYTE ();
4666 switch (op[1] & 0x00)
4667 {
4668 case 0x00:
4669 {
4670 /** 0110 1110 dsta dstb pushm %1-%2 */
e197589b 4671#line 372 "rx-decode.opc"
c7927a3c 4672 int dsta AU = (op[1] >> 4) & 0x0f;
e197589b 4673#line 372 "rx-decode.opc"
c7927a3c
NC		 4674 int dstb AU = op[1] & 0x0f;
4675 if (trace)
4676 {
4677 printf ("\033[33m%s\033[0m %02x %02x\n",
4678 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4679 op[0], op[1]);
4680 printf (" dsta = 0x%x,", dsta);
4681 printf (" dstb = 0x%x\n", dstb);
4682 }
4683 SYNTAX("pushm %1-%2");
e197589b 4684#line 372 "rx-decode.opc"
3cf79a01 4685 ID(pushm); SR(dsta); S2R(dstb); F_____;
43e65147 4686
c7927a3c
NC		 4687 }
4688 break;
4689 }
4690 break;
4691 case 0x6f:
4692 GETBYTE ();
4693 switch (op[1] & 0x00)
4694 {
4695 case 0x00:
4696 {
4697 /** 0110 1111 dsta dstb popm %1-%2 */
e197589b 4698#line 369 "rx-decode.opc"
c7927a3c 4699 int dsta AU = (op[1] >> 4) & 0x0f;
e197589b 4700#line 369 "rx-decode.opc"
c7927a3c
NC		 4701 int dstb AU = op[1] & 0x0f;
4702 if (trace)
4703 {
4704 printf ("\033[33m%s\033[0m %02x %02x\n",
4705 "/** 0110 1111 dsta dstb popm %1-%2 */",
4706 op[0], op[1]);
4707 printf (" dsta = 0x%x,", dsta);
4708 printf (" dstb = 0x%x\n", dstb);
4709 }
4710 SYNTAX("popm %1-%2");
e197589b 4711#line 369 "rx-decode.opc"
3cf79a01 4712 ID(popm); SR(dsta); S2R(dstb); F_____;
43e65147 4713
c7927a3c
NC		 4714 }
4715 break;
4716 }
4717 break;
4718 case 0x70:
4719 GETBYTE ();
4720 switch (op[1] & 0x00)
4721 {
4722 case 0x00:
a117b0a5 4723 op_semantics_31:
c7927a3c
NC		 4724 {
4725 /** 0111 00im rsrc rdst add #%1, %2, %0 */
e197589b 4726#line 513 "rx-decode.opc"
c7927a3c 4727 int im AU = op[0] & 0x03;
e197589b 4728#line 513 "rx-decode.opc"
c7927a3c 4729 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 4730#line 513 "rx-decode.opc"
c7927a3c
NC		 4731 int rdst AU = op[1] & 0x0f;
4732 if (trace)
4733 {
4734 printf ("\033[33m%s\033[0m %02x %02x\n",
4735 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4736 op[0], op[1]);
4737 printf (" im = 0x%x,", im);
4738 printf (" rsrc = 0x%x,", rsrc);
4739 printf (" rdst = 0x%x\n", rdst);
4740 }
4741 SYNTAX("add #%1, %2, %0");
e197589b 4742#line 513 "rx-decode.opc"
3cf79a01 4743 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
43e65147 4744
c7927a3c
NC		 4745 }
4746 break;
4747 }
4748 break;
4749 case 0x71:
4750 GETBYTE ();
4751 switch (op[1] & 0x00)
4752 {
4753 case 0x00:
a117b0a5 4754 goto op_semantics_31;
c7927a3c
NC		 4755 break;
4756 }
4757 break;
4758 case 0x72:
4759 GETBYTE ();
4760 switch (op[1] & 0x00)
4761 {
4762 case 0x00:
a117b0a5 4763 goto op_semantics_31;
c7927a3c
NC		 4764 break;
4765 }
4766 break;
4767 case 0x73:
4768 GETBYTE ();
4769 switch (op[1] & 0x00)
4770 {
4771 case 0x00:
a117b0a5 4772 goto op_semantics_31;
c7927a3c
NC		 4773 break;
4774 }
4775 break;
4776 case 0x74:
4777 GETBYTE ();
4778 switch (op[1] & 0xf0)
4779 {
4780 case 0x00:
a117b0a5 4781 op_semantics_32:
c7927a3c
NC		 4782 {
4783 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
e197589b 4784#line 525 "rx-decode.opc"
c7927a3c 4785 int im AU = op[0] & 0x03;
e197589b 4786#line 525 "rx-decode.opc"
c7927a3c
NC		 4787 int rsrc AU = op[1] & 0x0f;
4788 if (trace)
4789 {
4790 printf ("\033[33m%s\033[0m %02x %02x\n",
4791 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4792 op[0], op[1]);
4793 printf (" im = 0x%x,", im);
4794 printf (" rsrc = 0x%x\n", rsrc);
4795 }
4796 SYNTAX("cmp #%2, %1%S1");
e197589b 4797#line 525 "rx-decode.opc"
3cf79a01 4798 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
43e65147 4799
c7927a3c
NC		 4800 }
4801 break;
4802 case 0x10:
a117b0a5 4803 op_semantics_33:
c7927a3c
NC		 4804 {
4805 /** 0111 01im 0001rdst mul #%1, %0 */
e197589b 4806#line 628 "rx-decode.opc"
c7927a3c 4807 int im AU = op[0] & 0x03;
e197589b 4808#line 628 "rx-decode.opc"
c7927a3c
NC		 4809 int rdst AU = op[1] & 0x0f;
4810 if (trace)
4811 {
4812 printf ("\033[33m%s\033[0m %02x %02x\n",
4813 "/** 0111 01im 0001rdst mul #%1, %0 */",
4814 op[0], op[1]);
4815 printf (" im = 0x%x,", im);
4816 printf (" rdst = 0x%x\n", rdst);
4817 }
4818 SYNTAX("mul #%1, %0");
e197589b 4819#line 628 "rx-decode.opc"
a117b0a5
YS		 4820 int val = IMMex(im);
4821 if (val == 1 && rdst == 0)
4822 {
4823 SYNTAX("nop\t; mul\t#1, r0");
4824 switch (im)
4825 {
4826 case 2: ID(nop4); break;
4827 case 3: ID(nop5); break;
4828 case 0: ID(nop6); break;
4829 default:
4830 ID(mul);
4831 SYNTAX("mul #%1, %0");
4832 break;
4833 }
4834 }
4835 else
4836 {
4837 ID(mul);
4838 }
4839 DR(rdst); SC(val); F_____;
43e65147 4840
c7927a3c
NC		 4841 }
4842 break;
4843 case 0x20:
a117b0a5 4844 op_semantics_34:
c7927a3c
NC		 4845 {
4846 /** 0111 01im 0010 rdst and #%1, %0 */
e197589b 4847#line 417 "rx-decode.opc"
c7927a3c 4848 int im AU = op[0] & 0x03;
e197589b 4849#line 417 "rx-decode.opc"
c7927a3c
NC		 4850 int rdst AU = op[1] & 0x0f;
4851 if (trace)
4852 {
4853 printf ("\033[33m%s\033[0m %02x %02x\n",
4854 "/** 0111 01im 0010 rdst and #%1, %0 */",
4855 op[0], op[1]);
4856 printf (" im = 0x%x,", im);
4857 printf (" rdst = 0x%x\n", rdst);
4858 }
4859 SYNTAX("and #%1, %0");
e197589b 4860#line 417 "rx-decode.opc"
3cf79a01 4861 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
43e65147 4862
c7927a3c
NC		 4863 }
4864 break;
4865 case 0x30:
a117b0a5 4866 op_semantics_35:
c7927a3c
NC		 4867 {
4868 /** 0111 01im 0011 rdst or #%1, %0 */
e197589b 4869#line 435 "rx-decode.opc"
c7927a3c 4870 int im AU = op[0] & 0x03;
e197589b 4871#line 435 "rx-decode.opc"
c7927a3c
NC		 4872 int rdst AU = op[1] & 0x0f;
4873 if (trace)
4874 {
4875 printf ("\033[33m%s\033[0m %02x %02x\n",
4876 "/** 0111 01im 0011 rdst or #%1, %0 */",
4877 op[0], op[1]);
4878 printf (" im = 0x%x,", im);
4879 printf (" rdst = 0x%x\n", rdst);
4880 }
4881 SYNTAX("or #%1, %0");
e197589b 4882#line 435 "rx-decode.opc"
3cf79a01 4883 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
43e65147 4884
c7927a3c
NC		 4885 }
4886 break;
4887 default: UNSUPPORTED(); break;
4888 }
4889 break;
4890 case 0x75:
4891 GETBYTE ();
4892 switch (op[1] & 0xff)
4893 {
4894 case 0x00:
4895 case 0x01:
4896 case 0x02:
4897 case 0x03:
4898 case 0x04:
4899 case 0x05:
4900 case 0x06:
4901 case 0x07:
4902 case 0x08:
4903 case 0x09:
4904 case 0x0a:
4905 case 0x0b:
4906 case 0x0c:
4907 case 0x0d:
4908 case 0x0e:
4909 case 0x0f:
a117b0a5 4910 goto op_semantics_32;
c7927a3c
NC		 4911 break;
4912 case 0x10:
4913 case 0x11:
4914 case 0x12:
4915 case 0x13:
4916 case 0x14:
4917 case 0x15:
4918 case 0x16:
4919 case 0x17:
4920 case 0x18:
4921 case 0x19:
4922 case 0x1a:
4923 case 0x1b:
4924 case 0x1c:
4925 case 0x1d:
4926 case 0x1e:
4927 case 0x1f:
a117b0a5 4928 goto op_semantics_33;
c7927a3c
NC		 4929 break;
4930 case 0x20:
4931 case 0x21:
4932 case 0x22:
4933 case 0x23:
4934 case 0x24:
4935 case 0x25:
4936 case 0x26:
4937 case 0x27:
4938 case 0x28:
4939 case 0x29:
4940 case 0x2a:
4941 case 0x2b:
4942 case 0x2c:
4943 case 0x2d:
4944 case 0x2e:
4945 case 0x2f:
a117b0a5 4946 goto op_semantics_34;
c7927a3c
NC		 4947 break;
4948 case 0x30:
4949 case 0x31:
4950 case 0x32:
4951 case 0x33:
4952 case 0x34:
4953 case 0x35:
4954 case 0x36:
4955 case 0x37:
4956 case 0x38:
4957 case 0x39:
4958 case 0x3a:
4959 case 0x3b:
4960 case 0x3c:
4961 case 0x3d:
4962 case 0x3e:
4963 case 0x3f:
a117b0a5 4964 goto op_semantics_35;
c7927a3c
NC		 4965 break;
4966 case 0x40:
4967 case 0x41:
4968 case 0x42:
4969 case 0x43:
4970 case 0x44:
4971 case 0x45:
4972 case 0x46:
4973 case 0x47:
4974 case 0x48:
4975 case 0x49:
4976 case 0x4a:
4977 case 0x4b:
4978 case 0x4c:
4979 case 0x4d:
4980 case 0x4e:
4981 case 0x4f:
4982 {
4983 /** 0111 0101 0100 rdst mov%s #%1, %0 */
e197589b 4984#line 289 "rx-decode.opc"
c7927a3c
NC		 4985 int rdst AU = op[1] & 0x0f;
4986 if (trace)
4987 {
4988 printf ("\033[33m%s\033[0m %02x %02x\n",
4989 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4990 op[0], op[1]);
4991 printf (" rdst = 0x%x\n", rdst);
4992 }
4993 SYNTAX("mov%s #%1, %0");
e197589b 4994#line 289 "rx-decode.opc"
3cf79a01 4995 ID(mov); DR(rdst); SC(IMM (1)); F_____;
43e65147 4996
c7927a3c
NC		 4997 }
4998 break;
4999 case 0x50:
5000 case 0x51:
5001 case 0x52:
5002 case 0x53:
5003 case 0x54:
5004 case 0x55:
5005 case 0x56:
5006 case 0x57:
5007 case 0x58:
5008 case 0x59:
5009 case 0x5a:
5010 case 0x5b:
5011 case 0x5c:
5012 case 0x5d:
5013 case 0x5e:
5014 case 0x5f:
5015 {
5016 /** 0111 0101 0101 rsrc cmp #%2, %1 */
e197589b 5017#line 528 "rx-decode.opc"
c7927a3c
NC		 5018 int rsrc AU = op[1] & 0x0f;
5019 if (trace)
5020 {
5021 printf ("\033[33m%s\033[0m %02x %02x\n",
5022 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5023 op[0], op[1]);
5024 printf (" rsrc = 0x%x\n", rsrc);
5025 }
5026 SYNTAX("cmp #%2, %1");
e197589b 5027#line 528 "rx-decode.opc"
3cf79a01 5028 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
43e65147 5029
c7927a3c
NC		 5030 }
5031 break;
5032 case 0x60:
5033 {
5034 /** 0111 0101 0110 0000 int #%1 */
5035 if (trace)
5036 {
5037 printf ("\033[33m%s\033[0m %02x %02x\n",
5038 "/** 0111 0101 0110 0000 int #%1 */",
5039 op[0], op[1]);
5040 }
5041 SYNTAX("int #%1");
e197589b 5042#line 1035 "rx-decode.opc"
c7927a3c 5043 ID(int); SC(IMM(1));
43e65147 5044
c7927a3c
NC		 5045 }
5046 break;
946ef196
DD		 5047 case 0x70:
5048 GETBYTE ();
5049 switch (op[2] & 0xf0)
5050 {
5051 case 0x00:
5052 {
5053 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
e197589b 5054#line 1002 "rx-decode.opc"
946ef196
DD		 5055 int immm AU = op[2] & 0x0f;
5056 if (trace)
5057 {
5058 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5059 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5060 op[0], op[1], op[2]);
5061 printf (" immm = 0x%x\n", immm);
5062 }
5063 SYNTAX("mvtipl #%1");
e197589b 5064#line 1002 "rx-decode.opc"
946ef196 5065 ID(mvtipl); SC(immm);
43e65147 5066
946ef196
DD		 5067 }
5068 break;
5069 default: UNSUPPORTED(); break;
5070 }
5071 break;
c7927a3c
NC		 5072 default: UNSUPPORTED(); break;
5073 }
5074 break;
5075 case 0x76:
5076 GETBYTE ();
5077 switch (op[1] & 0xf0)
5078 {
5079 case 0x00:
a117b0a5 5080 goto op_semantics_32;
c7927a3c
NC		 5081 break;
5082 case 0x10:
a117b0a5 5083 goto op_semantics_33;
c7927a3c
NC		 5084 break;
5085 case 0x20:
a117b0a5 5086 goto op_semantics_34;
c7927a3c
NC		 5087 break;
5088 case 0x30:
a117b0a5 5089 goto op_semantics_35;
c7927a3c
NC		 5090 break;
5091 default: UNSUPPORTED(); break;
5092 }
5093 break;
5094 case 0x77:
5095 GETBYTE ();
5096 switch (op[1] & 0xf0)
5097 {
5098 case 0x00:
a117b0a5 5099 goto op_semantics_32;
c7927a3c
NC		 5100 break;
5101 case 0x10:
a117b0a5 5102 goto op_semantics_33;
c7927a3c
NC		 5103 break;
5104 case 0x20:
a117b0a5 5105 goto op_semantics_34;
c7927a3c
NC		 5106 break;
5107 case 0x30:
a117b0a5 5108 goto op_semantics_35;
c7927a3c
NC		 5109 break;
5110 default: UNSUPPORTED(); break;
5111 }
5112 break;
5113 case 0x78:
5114 GETBYTE ();
5115 switch (op[1] & 0x00)
5116 {
5117 case 0x00:
a117b0a5 5118 op_semantics_36:
c7927a3c
NC		 5119 {
5120 /** 0111 100b ittt rdst bset #%1, %0 */
e197589b 5121#line 947 "rx-decode.opc"
c7927a3c 5122 int b AU = op[0] & 0x01;
e197589b 5123#line 947 "rx-decode.opc"
c7927a3c 5124 int ittt AU = (op[1] >> 4) & 0x0f;
e197589b 5125#line 947 "rx-decode.opc"
c7927a3c
NC		 5126 int rdst AU = op[1] & 0x0f;
5127 if (trace)
5128 {
5129 printf ("\033[33m%s\033[0m %02x %02x\n",
5130 "/** 0111 100b ittt rdst bset #%1, %0 */",
5131 op[0], op[1]);
5132 printf (" b = 0x%x,", b);
5133 printf (" ittt = 0x%x,", ittt);
5134 printf (" rdst = 0x%x\n", rdst);
5135 }
5136 SYNTAX("bset #%1, %0");
e197589b 5137#line 947 "rx-decode.opc"
3cf79a01 5138 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
43e65147
L		 5139
5140
c7927a3c
NC		 5141 }
5142 break;
5143 }
5144 break;
5145 case 0x79:
5146 GETBYTE ();
5147 switch (op[1] & 0x00)
5148 {
5149 case 0x00:
a117b0a5 5150 goto op_semantics_36;
c7927a3c
NC		 5151 break;
5152 }
5153 break;
5154 case 0x7a:
5155 GETBYTE ();
5156 switch (op[1] & 0x00)
5157 {
5158 case 0x00:
a117b0a5 5159 op_semantics_37:
c7927a3c
NC		 5160 {
5161 /** 0111 101b ittt rdst bclr #%1, %0 */
e197589b 5162#line 959 "rx-decode.opc"
c7927a3c 5163 int b AU = op[0] & 0x01;
e197589b 5164#line 959 "rx-decode.opc"
c7927a3c 5165 int ittt AU = (op[1] >> 4) & 0x0f;
e197589b 5166#line 959 "rx-decode.opc"
c7927a3c
NC		 5167 int rdst AU = op[1] & 0x0f;
5168 if (trace)
5169 {
5170 printf ("\033[33m%s\033[0m %02x %02x\n",
5171 "/** 0111 101b ittt rdst bclr #%1, %0 */",
5172 op[0], op[1]);
5173 printf (" b = 0x%x,", b);
5174 printf (" ittt = 0x%x,", ittt);
5175 printf (" rdst = 0x%x\n", rdst);
5176 }
5177 SYNTAX("bclr #%1, %0");
e197589b 5178#line 959 "rx-decode.opc"
3cf79a01 5179 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
43e65147
L		 5180
5181
c7927a3c
NC		 5182 }
5183 break;
5184 }
5185 break;
5186 case 0x7b:
5187 GETBYTE ();
5188 switch (op[1] & 0x00)
5189 {
5190 case 0x00:
a117b0a5 5191 goto op_semantics_37;
c7927a3c
NC		 5192 break;
5193 }
5194 break;
5195 case 0x7c:
5196 GETBYTE ();
5197 switch (op[1] & 0x00)
5198 {
5199 case 0x00:
a117b0a5 5200 op_semantics_38:
c7927a3c
NC		 5201 {
5202 /** 0111 110b ittt rdst btst #%2, %1 */
e197589b 5203#line 971 "rx-decode.opc"
c7927a3c 5204 int b AU = op[0] & 0x01;
e197589b 5205#line 971 "rx-decode.opc"
c7927a3c 5206 int ittt AU = (op[1] >> 4) & 0x0f;
e197589b 5207#line 971 "rx-decode.opc"
c7927a3c
NC		 5208 int rdst AU = op[1] & 0x0f;
5209 if (trace)
5210 {
5211 printf ("\033[33m%s\033[0m %02x %02x\n",
5212 "/** 0111 110b ittt rdst btst #%2, %1 */",
5213 op[0], op[1]);
5214 printf (" b = 0x%x,", b);
5215 printf (" ittt = 0x%x,", ittt);
5216 printf (" rdst = 0x%x\n", rdst);
5217 }
5218 SYNTAX("btst #%2, %1");
e197589b 5219#line 971 "rx-decode.opc"
3cf79a01 5220 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
43e65147
L		 5221
5222
c7927a3c
NC		 5223 }
5224 break;
5225 }
5226 break;
5227 case 0x7d:
5228 GETBYTE ();
5229 switch (op[1] & 0x00)
5230 {
5231 case 0x00:
a117b0a5 5232 goto op_semantics_38;
c7927a3c
NC		 5233 break;
5234 }
5235 break;
5236 case 0x7e:
5237 GETBYTE ();
5238 switch (op[1] & 0xf0)
5239 {
5240 case 0x00:
5241 {
5242 /** 0111 1110 0000 rdst not %0 */
e197589b 5243#line 462 "rx-decode.opc"
c7927a3c
NC		 5244 int rdst AU = op[1] & 0x0f;
5245 if (trace)
5246 {
5247 printf ("\033[33m%s\033[0m %02x %02x\n",
5248 "/** 0111 1110 0000 rdst not %0 */",
5249 op[0], op[1]);
5250 printf (" rdst = 0x%x\n", rdst);
5251 }
5252 SYNTAX("not %0");
e197589b 5253#line 462 "rx-decode.opc"
3cf79a01 5254 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
43e65147 5255
c7927a3c
NC		 5256 }
5257 break;
5258 case 0x10:
5259 {
5260 /** 0111 1110 0001 rdst neg %0 */
e197589b 5261#line 483 "rx-decode.opc"
c7927a3c
NC		 5262 int rdst AU = op[1] & 0x0f;
5263 if (trace)
5264 {
5265 printf ("\033[33m%s\033[0m %02x %02x\n",
5266 "/** 0111 1110 0001 rdst neg %0 */",
5267 op[0], op[1]);
5268 printf (" rdst = 0x%x\n", rdst);
5269 }
5270 SYNTAX("neg %0");
e197589b 5271#line 483 "rx-decode.opc"
3cf79a01 5272 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
43e65147 5273
c7927a3c
NC		 5274 }
5275 break;
5276 case 0x20:
5277 {
5278 /** 0111 1110 0010 rdst abs %0 */
e197589b 5279#line 565 "rx-decode.opc"
c7927a3c
NC		 5280 int rdst AU = op[1] & 0x0f;
5281 if (trace)
5282 {
5283 printf ("\033[33m%s\033[0m %02x %02x\n",
5284 "/** 0111 1110 0010 rdst abs %0 */",
5285 op[0], op[1]);
5286 printf (" rdst = 0x%x\n", rdst);
5287 }
5288 SYNTAX("abs %0");
e197589b 5289#line 565 "rx-decode.opc"
3cf79a01 5290 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
43e65147 5291
c7927a3c
NC		 5292 }
5293 break;
5294 case 0x30:
5295 {
5296 /** 0111 1110 0011 rdst sat %0 */
e197589b 5297#line 885 "rx-decode.opc"
c7927a3c
NC		 5298 int rdst AU = op[1] & 0x0f;
5299 if (trace)
5300 {
5301 printf ("\033[33m%s\033[0m %02x %02x\n",
5302 "/** 0111 1110 0011 rdst sat %0 */",
5303 op[0], op[1]);
5304 printf (" rdst = 0x%x\n", rdst);
5305 }
5306 SYNTAX("sat %0");
e197589b 5307#line 885 "rx-decode.opc"
c7927a3c 5308 ID(sat); DR (rdst);
43e65147 5309
c7927a3c
NC		 5310 }
5311 break;
5312 case 0x40:
5313 {
5314 /** 0111 1110 0100 rdst rorc %0 */
e197589b 5315#line 745 "rx-decode.opc"
c7927a3c
NC		 5316 int rdst AU = op[1] & 0x0f;
5317 if (trace)
5318 {
5319 printf ("\033[33m%s\033[0m %02x %02x\n",
5320 "/** 0111 1110 0100 rdst rorc %0 */",
5321 op[0], op[1]);
5322 printf (" rdst = 0x%x\n", rdst);
5323 }
5324 SYNTAX("rorc %0");
e197589b 5325#line 745 "rx-decode.opc"
3cf79a01 5326 ID(rorc); DR(rdst); F__SZC;
43e65147 5327
c7927a3c
NC		 5328 }
5329 break;
5330 case 0x50:
5331 {
5332 /** 0111 1110 0101 rdst rolc %0 */
e197589b 5333#line 742 "rx-decode.opc"
c7927a3c
NC		 5334 int rdst AU = op[1] & 0x0f;
5335 if (trace)
5336 {
5337 printf ("\033[33m%s\033[0m %02x %02x\n",
5338 "/** 0111 1110 0101 rdst rolc %0 */",
5339 op[0], op[1]);
5340 printf (" rdst = 0x%x\n", rdst);
5341 }
5342 SYNTAX("rolc %0");
e197589b 5343#line 742 "rx-decode.opc"
3cf79a01 5344 ID(rolc); DR(rdst); F__SZC;
43e65147 5345
c7927a3c
NC		 5346 }
5347 break;
5348 case 0x80:
5349 case 0x90:
5350 case 0xa0:
5351 {
5352 /** 0111 1110 10sz rsrc push%s %1 */
e197589b 5353#line 378 "rx-decode.opc"
c7927a3c 5354 int sz AU = (op[1] >> 4) & 0x03;
e197589b 5355#line 378 "rx-decode.opc"
c7927a3c
NC		 5356 int rsrc AU = op[1] & 0x0f;
5357 if (trace)
5358 {
5359 printf ("\033[33m%s\033[0m %02x %02x\n",
5360 "/** 0111 1110 10sz rsrc push%s %1 */",
5361 op[0], op[1]);
5362 printf (" sz = 0x%x,", sz);
5363 printf (" rsrc = 0x%x\n", rsrc);
5364 }
5365 SYNTAX("push%s %1");
e197589b 5366#line 378 "rx-decode.opc"
3cf79a01 5367 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
43e65147 5368
c7927a3c
NC		 5369 }
5370 break;
5371 case 0xb0:
5372 {
5373 /** 0111 1110 1011 rdst pop %0 */
e197589b 5374#line 375 "rx-decode.opc"
c7927a3c
NC		 5375 int rdst AU = op[1] & 0x0f;
5376 if (trace)
5377 {
5378 printf ("\033[33m%s\033[0m %02x %02x\n",
5379 "/** 0111 1110 1011 rdst pop %0 */",
5380 op[0], op[1]);
5381 printf (" rdst = 0x%x\n", rdst);
5382 }
5383 SYNTAX("pop %0");
e197589b 5384#line 375 "rx-decode.opc"
3cf79a01 5385 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
43e65147 5386
c7927a3c
NC		 5387 }
5388 break;
5389 case 0xc0:
5390 case 0xd0:
5391 {
5392 /** 0111 1110 110 crsrc pushc %1 */
e197589b 5393#line 1008 "rx-decode.opc"
c7927a3c
NC		 5394 int crsrc AU = op[1] & 0x1f;
5395 if (trace)
5396 {
5397 printf ("\033[33m%s\033[0m %02x %02x\n",
5398 "/** 0111 1110 110 crsrc pushc %1 */",
5399 op[0], op[1]);
5400 printf (" crsrc = 0x%x\n", crsrc);
5401 }
5402 SYNTAX("pushc %1");
e197589b 5403#line 1008 "rx-decode.opc"
c7927a3c 5404 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
43e65147 5405
c7927a3c
NC		 5406 }
5407 break;
5408 case 0xe0:
5409 case 0xf0:
5410 {
5411 /** 0111 1110 111 crdst popc %0 */
e197589b 5412#line 1005 "rx-decode.opc"
c7927a3c
NC		 5413 int crdst AU = op[1] & 0x1f;
5414 if (trace)
5415 {
5416 printf ("\033[33m%s\033[0m %02x %02x\n",
5417 "/** 0111 1110 111 crdst popc %0 */",
5418 op[0], op[1]);
5419 printf (" crdst = 0x%x\n", crdst);
5420 }
5421 SYNTAX("popc %0");
e197589b 5422#line 1005 "rx-decode.opc"
c7927a3c 5423 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
43e65147 5424
c7927a3c
NC		 5425 }
5426 break;
5427 default: UNSUPPORTED(); break;
5428 }
5429 break;
5430 case 0x7f:
5431 GETBYTE ();
5432 switch (op[1] & 0xff)
5433 {
5434 case 0x00:
5435 case 0x01:
5436 case 0x02:
5437 case 0x03:
5438 case 0x04:
5439 case 0x05:
5440 case 0x06:
5441 case 0x07:
5442 case 0x08:
5443 case 0x09:
5444 case 0x0a:
5445 case 0x0b:
5446 case 0x0c:
5447 case 0x0d:
5448 case 0x0e:
5449 case 0x0f:
5450 {
5451 /** 0111 1111 0000 rsrc jmp %0 */
e197589b 5452#line 795 "rx-decode.opc"
c7927a3c
NC		 5453 int rsrc AU = op[1] & 0x0f;
5454 if (trace)
5455 {
5456 printf ("\033[33m%s\033[0m %02x %02x\n",
5457 "/** 0111 1111 0000 rsrc jmp %0 */",
5458 op[0], op[1]);
5459 printf (" rsrc = 0x%x\n", rsrc);
5460 }
5461 SYNTAX("jmp %0");
e197589b 5462#line 795 "rx-decode.opc"
f9c7014e 5463 ID(branch); DR(rsrc);
43e65147 5464
c7927a3c
NC		 5465 }
5466 break;
5467 case 0x10:
5468 case 0x11:
5469 case 0x12:
5470 case 0x13:
5471 case 0x14:
5472 case 0x15:
5473 case 0x16:
5474 case 0x17:
5475 case 0x18:
5476 case 0x19:
5477 case 0x1a:
5478 case 0x1b:
5479 case 0x1c:
5480 case 0x1d:
5481 case 0x1e:
5482 case 0x1f:
5483 {
5484 /** 0111 1111 0001 rsrc jsr %0 */
e197589b 5485#line 798 "rx-decode.opc"
c7927a3c
NC		 5486 int rsrc AU = op[1] & 0x0f;
5487 if (trace)
5488 {
5489 printf ("\033[33m%s\033[0m %02x %02x\n",
5490 "/** 0111 1111 0001 rsrc jsr %0 */",
5491 op[0], op[1]);
5492 printf (" rsrc = 0x%x\n", rsrc);
5493 }
5494 SYNTAX("jsr %0");
e197589b 5495#line 798 "rx-decode.opc"
c7927a3c 5496 ID(jsr); DR(rsrc);
43e65147 5497
c7927a3c
NC		 5498 }
5499 break;
5500 case 0x40:
5501 case 0x41:
5502 case 0x42:
5503 case 0x43:
5504 case 0x44:
5505 case 0x45:
5506 case 0x46:
5507 case 0x47:
5508 case 0x48:
5509 case 0x49:
5510 case 0x4a:
5511 case 0x4b:
5512 case 0x4c:
5513 case 0x4d:
5514 case 0x4e:
5515 case 0x4f:
5516 {
5517 /** 0111 1111 0100 rsrc bra.l %0 */
e197589b 5518#line 791 "rx-decode.opc"
c7927a3c
NC		 5519 int rsrc AU = op[1] & 0x0f;
5520 if (trace)
5521 {
5522 printf ("\033[33m%s\033[0m %02x %02x\n",
5523 "/** 0111 1111 0100 rsrc bra.l %0 */",
5524 op[0], op[1]);
5525 printf (" rsrc = 0x%x\n", rsrc);
5526 }
5527 SYNTAX("bra.l %0");
e197589b 5528#line 791 "rx-decode.opc"
f9c7014e 5529 ID(branchrel); DR(rsrc);
43e65147
L		 5530
5531
c7927a3c
NC		 5532 }
5533 break;
5534 case 0x50:
5535 case 0x51:
5536 case 0x52:
5537 case 0x53:
5538 case 0x54:
5539 case 0x55:
5540 case 0x56:
5541 case 0x57:
5542 case 0x58:
5543 case 0x59:
5544 case 0x5a:
5545 case 0x5b:
5546 case 0x5c:
5547 case 0x5d:
5548 case 0x5e:
5549 case 0x5f:
5550 {
5551 /** 0111 1111 0101 rsrc bsr.l %0 */
e197589b 5552#line 807 "rx-decode.opc"
c7927a3c
NC		 5553 int rsrc AU = op[1] & 0x0f;
5554 if (trace)
5555 {
5556 printf ("\033[33m%s\033[0m %02x %02x\n",
5557 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5558 op[0], op[1]);
5559 printf (" rsrc = 0x%x\n", rsrc);
5560 }
5561 SYNTAX("bsr.l %0");
e197589b 5562#line 807 "rx-decode.opc"
c7927a3c 5563 ID(jsrrel); DR(rsrc);
43e65147 5564
c7927a3c
NC		 5565 }
5566 break;
5567 case 0x80:
5568 case 0x81:
5569 case 0x82:
5570 {
5571 /** 0111 1111 1000 00sz suntil%s */
e197589b 5572#line 831 "rx-decode.opc"
c7927a3c
NC		 5573 int sz AU = op[1] & 0x03;
5574 if (trace)
5575 {
5576 printf ("\033[33m%s\033[0m %02x %02x\n",
5577 "/** 0111 1111 1000 00sz suntil%s */",
5578 op[0], op[1]);
5579 printf (" sz = 0x%x\n", sz);
5580 }
5581 SYNTAX("suntil%s");
e197589b 5582#line 831 "rx-decode.opc"
3cf79a01 5583 ID(suntil); BWL(sz); F___ZC;
43e65147 5584
c7927a3c
NC		 5585 }
5586 break;
5587 case 0x83:
5588 {
5589 /** 0111 1111 1000 0011 scmpu */
5590 if (trace)
5591 {
5592 printf ("\033[33m%s\033[0m %02x %02x\n",
5593 "/** 0111 1111 1000 0011 scmpu */",
5594 op[0], op[1]);
5595 }
5596 SYNTAX("scmpu");
e197589b 5597#line 822 "rx-decode.opc"
3cf79a01 5598 ID(scmpu); F___ZC;
43e65147 5599
c7927a3c
NC		 5600 }
5601 break;
5602 case 0x84:
5603 case 0x85:
5604 case 0x86:
5605 {
5606 /** 0111 1111 1000 01sz swhile%s */
e197589b 5607#line 834 "rx-decode.opc"
c7927a3c
NC		 5608 int sz AU = op[1] & 0x03;
5609 if (trace)
5610 {
5611 printf ("\033[33m%s\033[0m %02x %02x\n",
5612 "/** 0111 1111 1000 01sz swhile%s */",
5613 op[0], op[1]);
5614 printf (" sz = 0x%x\n", sz);
5615 }
5616 SYNTAX("swhile%s");
e197589b 5617#line 834 "rx-decode.opc"
3cf79a01 5618 ID(swhile); BWL(sz); F___ZC;
43e65147 5619
c7927a3c
NC		 5620 }
5621 break;
5622 case 0x87:
5623 {
5624 /** 0111 1111 1000 0111 smovu */
5625 if (trace)
5626 {
5627 printf ("\033[33m%s\033[0m %02x %02x\n",
5628 "/** 0111 1111 1000 0111 smovu */",
5629 op[0], op[1]);
5630 }
5631 SYNTAX("smovu");
e197589b 5632#line 825 "rx-decode.opc"
c7927a3c 5633 ID(smovu);
43e65147 5634
c7927a3c
NC		 5635 }
5636 break;
5637 case 0x88:
5638 case 0x89:
5639 case 0x8a:
5640 {
5641 /** 0111 1111 1000 10sz sstr%s */
e197589b 5642#line 840 "rx-decode.opc"
c7927a3c
NC		 5643 int sz AU = op[1] & 0x03;
5644 if (trace)
5645 {
5646 printf ("\033[33m%s\033[0m %02x %02x\n",
5647 "/** 0111 1111 1000 10sz sstr%s */",
5648 op[0], op[1]);
5649 printf (" sz = 0x%x\n", sz);
5650 }
5651 SYNTAX("sstr%s");
e197589b 5652#line 840 "rx-decode.opc"
c7927a3c 5653 ID(sstr); BWL(sz);
43e65147 5654
c7927a3c
NC		 5655 /*----------------------------------------------------------------------*/
5656 /* RMPA */
43e65147 5657
c7927a3c
NC		 5658 }
5659 break;
5660 case 0x8b:
5661 {
5662 /** 0111 1111 1000 1011 smovb */
5663 if (trace)
5664 {
5665 printf ("\033[33m%s\033[0m %02x %02x\n",
5666 "/** 0111 1111 1000 1011 smovb */",
5667 op[0], op[1]);
5668 }
5669 SYNTAX("smovb");
e197589b 5670#line 828 "rx-decode.opc"
c7927a3c 5671 ID(smovb);
43e65147 5672
c7927a3c
NC		 5673 }
5674 break;
5675 case 0x8c:
5676 case 0x8d:
5677 case 0x8e:
5678 {
5679 /** 0111 1111 1000 11sz rmpa%s */
e197589b 5680#line 846 "rx-decode.opc"
c7927a3c
NC		 5681 int sz AU = op[1] & 0x03;
5682 if (trace)
5683 {
5684 printf ("\033[33m%s\033[0m %02x %02x\n",
5685 "/** 0111 1111 1000 11sz rmpa%s */",
5686 op[0], op[1]);
5687 printf (" sz = 0x%x\n", sz);
5688 }
5689 SYNTAX("rmpa%s");
e197589b 5690#line 846 "rx-decode.opc"
3cf79a01 5691 ID(rmpa); BWL(sz); F_OS__;
43e65147 5692
c7927a3c
NC		 5693 /*----------------------------------------------------------------------*/
5694 /* HI/LO stuff */
43e65147 5695
c7927a3c
NC		 5696 }
5697 break;
5698 case 0x8f:
5699 {
5700 /** 0111 1111 1000 1111 smovf */
5701 if (trace)
5702 {
5703 printf ("\033[33m%s\033[0m %02x %02x\n",
5704 "/** 0111 1111 1000 1111 smovf */",
5705 op[0], op[1]);
5706 }
5707 SYNTAX("smovf");
e197589b 5708#line 837 "rx-decode.opc"
c7927a3c 5709 ID(smovf);
43e65147 5710
c7927a3c
NC		 5711 }
5712 break;
5713 case 0x93:
5714 {
5715 /** 0111 1111 1001 0011 satr */
5716 if (trace)
5717 {
5718 printf ("\033[33m%s\033[0m %02x %02x\n",
5719 "/** 0111 1111 1001 0011 satr */",
5720 op[0], op[1]);
5721 }
5722 SYNTAX("satr");
e197589b 5723#line 888 "rx-decode.opc"
c7927a3c 5724 ID(satr);
43e65147 5725
c7927a3c
NC		 5726 /*----------------------------------------------------------------------*/
5727 /* FLOAT */
43e65147 5728
c7927a3c
NC		 5729 }
5730 break;
5731 case 0x94:
5732 {
5733 /** 0111 1111 1001 0100 rtfi */
5734 if (trace)
5735 {
5736 printf ("\033[33m%s\033[0m %02x %02x\n",
5737 "/** 0111 1111 1001 0100 rtfi */",
5738 op[0], op[1]);
5739 }
5740 SYNTAX("rtfi");
e197589b 5741#line 1023 "rx-decode.opc"
c7927a3c 5742 ID(rtfi);
43e65147 5743
c7927a3c
NC		 5744 }
5745 break;
5746 case 0x95:
5747 {
5748 /** 0111 1111 1001 0101 rte */
5749 if (trace)
5750 {
5751 printf ("\033[33m%s\033[0m %02x %02x\n",
5752 "/** 0111 1111 1001 0101 rte */",
5753 op[0], op[1]);
5754 }
5755 SYNTAX("rte");
e197589b 5756#line 1026 "rx-decode.opc"
c7927a3c 5757 ID(rte);
43e65147 5758
c7927a3c
NC		 5759 }
5760 break;
5761 case 0x96:
5762 {
5763 /** 0111 1111 1001 0110 wait */
5764 if (trace)
5765 {
5766 printf ("\033[33m%s\033[0m %02x %02x\n",
5767 "/** 0111 1111 1001 0110 wait */",
5768 op[0], op[1]);
5769 }
5770 SYNTAX("wait");
e197589b 5771#line 1038 "rx-decode.opc"
c7927a3c 5772 ID(wait);
43e65147 5773
c7927a3c
NC		 5774 /*----------------------------------------------------------------------*/
5775 /* SCcnd */
43e65147 5776
c7927a3c
NC		 5777 }
5778 break;
5779 case 0xa0:
5780 case 0xa1:
5781 case 0xa2:
5782 case 0xa3:
5783 case 0xa4:
5784 case 0xa5:
5785 case 0xa6:
5786 case 0xa7:
5787 case 0xa8:
5788 case 0xa9:
5789 case 0xaa:
5790 case 0xab:
5791 case 0xac:
5792 case 0xad:
5793 case 0xae:
5794 case 0xaf:
5795 {
5796 /** 0111 1111 1010 rdst setpsw %0 */
e197589b 5797#line 999 "rx-decode.opc"
c7927a3c
NC		 5798 int rdst AU = op[1] & 0x0f;
5799 if (trace)
5800 {
5801 printf ("\033[33m%s\033[0m %02x %02x\n",
5802 "/** 0111 1111 1010 rdst setpsw %0 */",
5803 op[0], op[1]);
5804 printf (" rdst = 0x%x\n", rdst);
5805 }
5806 SYNTAX("setpsw %0");
e197589b 5807#line 999 "rx-decode.opc"
c7927a3c 5808 ID(setpsw); DF(rdst);
43e65147 5809
c7927a3c
NC		 5810 }
5811 break;
5812 case 0xb0:
5813 case 0xb1:
5814 case 0xb2:
5815 case 0xb3:
5816 case 0xb4:
5817 case 0xb5:
5818 case 0xb6:
5819 case 0xb7:
5820 case 0xb8:
5821 case 0xb9:
5822 case 0xba:
5823 case 0xbb:
5824 case 0xbc:
5825 case 0xbd:
5826 case 0xbe:
5827 case 0xbf:
5828 {
5829 /** 0111 1111 1011 rdst clrpsw %0 */
e197589b 5830#line 996 "rx-decode.opc"
c7927a3c
NC		 5831 int rdst AU = op[1] & 0x0f;
5832 if (trace)
5833 {
5834 printf ("\033[33m%s\033[0m %02x %02x\n",
5835 "/** 0111 1111 1011 rdst clrpsw %0 */",
5836 op[0], op[1]);
5837 printf (" rdst = 0x%x\n", rdst);
5838 }
5839 SYNTAX("clrpsw %0");
e197589b 5840#line 996 "rx-decode.opc"
c7927a3c 5841 ID(clrpsw); DF(rdst);
43e65147 5842
c7927a3c
NC		 5843 }
5844 break;
5845 default: UNSUPPORTED(); break;
5846 }
5847 break;
5848 case 0x80:
5849 GETBYTE ();
5850 switch (op[1] & 0x00)
5851 {
5852 case 0x00:
a117b0a5 5853 op_semantics_39:
c7927a3c
NC		 5854 {
5855 /** 10sz 0dsp a dst b src mov%s %1, %0 */
e197589b 5856#line 336 "rx-decode.opc"
c7927a3c 5857 int sz AU = (op[0] >> 4) & 0x03;
e197589b 5858#line 336 "rx-decode.opc"
c7927a3c 5859 int dsp AU = op[0] & 0x07;
e197589b 5860#line 336 "rx-decode.opc"
c7927a3c 5861 int a AU = (op[1] >> 7) & 0x01;
e197589b 5862#line 336 "rx-decode.opc"
c7927a3c 5863 int dst AU = (op[1] >> 4) & 0x07;
e197589b 5864#line 336 "rx-decode.opc"
c7927a3c 5865 int b AU = (op[1] >> 3) & 0x01;
e197589b 5866#line 336 "rx-decode.opc"
c7927a3c
NC		 5867 int src AU = op[1] & 0x07;
5868 if (trace)
5869 {
5870 printf ("\033[33m%s\033[0m %02x %02x\n",
5871 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5872 op[0], op[1]);
5873 printf (" sz = 0x%x,", sz);
5874 printf (" dsp = 0x%x,", dsp);
5875 printf (" a = 0x%x,", a);
5876 printf (" dst = 0x%x,", dst);
5877 printf (" b = 0x%x,", b);
5878 printf (" src = 0x%x\n", src);
5879 }
5880 SYNTAX("mov%s %1, %0");
e197589b 5881#line 336 "rx-decode.opc"
3cf79a01 5882 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
43e65147 5883
c7927a3c
NC		 5884 }
5885 break;
5886 }
5887 break;
5888 case 0x81:
5889 GETBYTE ();
5890 switch (op[1] & 0x00)
5891 {
5892 case 0x00:
a117b0a5 5893 goto op_semantics_39;
c7927a3c
NC		 5894 break;
5895 }
5896 break;
5897 case 0x82:
5898 GETBYTE ();
5899 switch (op[1] & 0x00)
5900 {
5901 case 0x00:
a117b0a5 5902 goto op_semantics_39;
c7927a3c
NC		 5903 break;
5904 }
5905 break;
5906 case 0x83:
5907 GETBYTE ();
5908 switch (op[1] & 0x00)
5909 {
5910 case 0x00:
a117b0a5 5911 goto op_semantics_39;
c7927a3c
NC		 5912 break;
5913 }
5914 break;
5915 case 0x84:
5916 GETBYTE ();
5917 switch (op[1] & 0x00)
5918 {
5919 case 0x00:
a117b0a5 5920 goto op_semantics_39;
c7927a3c
NC		 5921 break;
5922 }
5923 break;
5924 case 0x85:
5925 GETBYTE ();
5926 switch (op[1] & 0x00)
5927 {
5928 case 0x00:
a117b0a5 5929 goto op_semantics_39;
c7927a3c
NC		 5930 break;
5931 }
5932 break;
5933 case 0x86:
5934 GETBYTE ();
5935 switch (op[1] & 0x00)
5936 {
5937 case 0x00:
a117b0a5 5938 goto op_semantics_39;
c7927a3c
NC		 5939 break;
5940 }
5941 break;
5942 case 0x87:
5943 GETBYTE ();
5944 switch (op[1] & 0x00)
5945 {
5946 case 0x00:
a117b0a5 5947 goto op_semantics_39;
c7927a3c
NC		 5948 break;
5949 }
5950 break;
5951 case 0x88:
5952 GETBYTE ();
5953 switch (op[1] & 0x00)
5954 {
5955 case 0x00:
a117b0a5 5956 op_semantics_40:
c7927a3c
NC		 5957 {
5958 /** 10sz 1dsp a src b dst mov%s %1, %0 */
e197589b 5959#line 333 "rx-decode.opc"
c7927a3c 5960 int sz AU = (op[0] >> 4) & 0x03;
e197589b 5961#line 333 "rx-decode.opc"
c7927a3c 5962 int dsp AU = op[0] & 0x07;
e197589b 5963#line 333 "rx-decode.opc"
c7927a3c 5964 int a AU = (op[1] >> 7) & 0x01;
e197589b 5965#line 333 "rx-decode.opc"
c7927a3c 5966 int src AU = (op[1] >> 4) & 0x07;
e197589b 5967#line 333 "rx-decode.opc"
c7927a3c 5968 int b AU = (op[1] >> 3) & 0x01;
e197589b 5969#line 333 "rx-decode.opc"
c7927a3c
NC		 5970 int dst AU = op[1] & 0x07;
5971 if (trace)
5972 {
5973 printf ("\033[33m%s\033[0m %02x %02x\n",
5974 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5975 op[0], op[1]);
5976 printf (" sz = 0x%x,", sz);
5977 printf (" dsp = 0x%x,", dsp);
5978 printf (" a = 0x%x,", a);
5979 printf (" src = 0x%x,", src);
5980 printf (" b = 0x%x,", b);
5981 printf (" dst = 0x%x\n", dst);
5982 }
5983 SYNTAX("mov%s %1, %0");
e197589b 5984#line 333 "rx-decode.opc"
3cf79a01 5985 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
43e65147 5986
c7927a3c
NC		 5987 }
5988 break;
5989 }
5990 break;
5991 case 0x89:
5992 GETBYTE ();
5993 switch (op[1] & 0x00)
5994 {
5995 case 0x00:
a117b0a5 5996 goto op_semantics_40;
c7927a3c
NC		 5997 break;
5998 }
5999 break;
6000 case 0x8a:
6001 GETBYTE ();
6002 switch (op[1] & 0x00)
6003 {
6004 case 0x00:
a117b0a5 6005 goto op_semantics_40;
c7927a3c
NC		 6006 break;
6007 }
6008 break;
6009 case 0x8b:
6010 GETBYTE ();
6011 switch (op[1] & 0x00)
6012 {
6013 case 0x00:
a117b0a5 6014 goto op_semantics_40;
c7927a3c
NC		 6015 break;
6016 }
6017 break;
6018 case 0x8c:
6019 GETBYTE ();
6020 switch (op[1] & 0x00)
6021 {
6022 case 0x00:
a117b0a5 6023 goto op_semantics_40;
c7927a3c
NC		 6024 break;
6025 }
6026 break;
6027 case 0x8d:
6028 GETBYTE ();
6029 switch (op[1] & 0x00)
6030 {
6031 case 0x00:
a117b0a5 6032 goto op_semantics_40;
c7927a3c
NC		 6033 break;
6034 }
6035 break;
6036 case 0x8e:
6037 GETBYTE ();
6038 switch (op[1] & 0x00)
6039 {
6040 case 0x00:
a117b0a5 6041 goto op_semantics_40;
c7927a3c
NC		 6042 break;
6043 }
6044 break;
6045 case 0x8f:
6046 GETBYTE ();
6047 switch (op[1] & 0x00)
6048 {
6049 case 0x00:
a117b0a5 6050 goto op_semantics_40;
c7927a3c
NC		 6051 break;
6052 }
6053 break;
6054 case 0x90:
6055 GETBYTE ();
6056 switch (op[1] & 0x00)
6057 {
6058 case 0x00:
a117b0a5 6059 goto op_semantics_39;
c7927a3c
NC		 6060 break;
6061 }
6062 break;
6063 case 0x91:
6064 GETBYTE ();
6065 switch (op[1] & 0x00)
6066 {
6067 case 0x00:
a117b0a5 6068 goto op_semantics_39;
c7927a3c
NC		 6069 break;
6070 }
6071 break;
6072 case 0x92:
6073 GETBYTE ();
6074 switch (op[1] & 0x00)
6075 {
6076 case 0x00:
a117b0a5 6077 goto op_semantics_39;
c7927a3c
NC		 6078 break;
6079 }
6080 break;
6081 case 0x93:
6082 GETBYTE ();
6083 switch (op[1] & 0x00)
6084 {
6085 case 0x00:
a117b0a5 6086 goto op_semantics_39;
c7927a3c
NC		 6087 break;
6088 }
6089 break;
6090 case 0x94:
6091 GETBYTE ();
6092 switch (op[1] & 0x00)
6093 {
6094 case 0x00:
a117b0a5 6095 goto op_semantics_39;
c7927a3c
NC		 6096 break;
6097 }
6098 break;
6099 case 0x95:
6100 GETBYTE ();
6101 switch (op[1] & 0x00)
6102 {
6103 case 0x00:
a117b0a5 6104 goto op_semantics_39;
c7927a3c
NC		 6105 break;
6106 }
6107 break;
6108 case 0x96:
6109 GETBYTE ();
6110 switch (op[1] & 0x00)
6111 {
6112 case 0x00:
a117b0a5 6113 goto op_semantics_39;
c7927a3c
NC		 6114 break;
6115 }
6116 break;
6117 case 0x97:
6118 GETBYTE ();
6119 switch (op[1] & 0x00)
6120 {
6121 case 0x00:
a117b0a5 6122 goto op_semantics_39;
c7927a3c
NC		 6123 break;
6124 }
6125 break;
6126 case 0x98:
6127 GETBYTE ();
6128 switch (op[1] & 0x00)
6129 {
6130 case 0x00:
a117b0a5 6131 goto op_semantics_40;
c7927a3c
NC		 6132 break;
6133 }
6134 break;
6135 case 0x99:
6136 GETBYTE ();
6137 switch (op[1] & 0x00)
6138 {
6139 case 0x00:
a117b0a5 6140 goto op_semantics_40;
c7927a3c
NC		 6141 break;
6142 }
6143 break;
6144 case 0x9a:
6145 GETBYTE ();
6146 switch (op[1] & 0x00)
6147 {
6148 case 0x00:
a117b0a5 6149 goto op_semantics_40;
c7927a3c
NC		 6150 break;
6151 }
6152 break;
6153 case 0x9b:
6154 GETBYTE ();
6155 switch (op[1] & 0x00)
6156 {
6157 case 0x00:
a117b0a5 6158 goto op_semantics_40;
c7927a3c
NC		 6159 break;
6160 }
6161 break;
6162 case 0x9c:
6163 GETBYTE ();
6164 switch (op[1] & 0x00)
6165 {
6166 case 0x00:
a117b0a5 6167 goto op_semantics_40;
c7927a3c
NC		 6168 break;
6169 }
6170 break;
6171 case 0x9d:
6172 GETBYTE ();
6173 switch (op[1] & 0x00)
6174 {
6175 case 0x00:
a117b0a5 6176 goto op_semantics_40;
c7927a3c
NC		 6177 break;
6178 }
6179 break;
6180 case 0x9e:
6181 GETBYTE ();
6182 switch (op[1] & 0x00)
6183 {
6184 case 0x00:
a117b0a5 6185 goto op_semantics_40;
c7927a3c
NC		 6186 break;
6187 }
6188 break;
6189 case 0x9f:
6190 GETBYTE ();
6191 switch (op[1] & 0x00)
6192 {
6193 case 0x00:
a117b0a5 6194 goto op_semantics_40;
c7927a3c
NC		 6195 break;
6196 }
6197 break;
6198 case 0xa0:
6199 GETBYTE ();
6200 switch (op[1] & 0x00)
6201 {
6202 case 0x00:
a117b0a5 6203 goto op_semantics_39;
c7927a3c
NC		 6204 break;
6205 }
6206 break;
6207 case 0xa1:
6208 GETBYTE ();
6209 switch (op[1] & 0x00)
6210 {
6211 case 0x00:
a117b0a5 6212 goto op_semantics_39;
c7927a3c
NC		 6213 break;
6214 }
6215 break;
6216 case 0xa2:
6217 GETBYTE ();
6218 switch (op[1] & 0x00)
6219 {
6220 case 0x00:
a117b0a5 6221 goto op_semantics_39;
c7927a3c
NC		 6222 break;
6223 }
6224 break;
6225 case 0xa3:
6226 GETBYTE ();
6227 switch (op[1] & 0x00)
6228 {
6229 case 0x00:
a117b0a5 6230 goto op_semantics_39;
c7927a3c
NC		 6231 break;
6232 }
6233 break;
6234 case 0xa4:
6235 GETBYTE ();
6236 switch (op[1] & 0x00)
6237 {
6238 case 0x00:
a117b0a5 6239 goto op_semantics_39;
c7927a3c
NC		 6240 break;
6241 }
6242 break;
6243 case 0xa5:
6244 GETBYTE ();
6245 switch (op[1] & 0x00)
6246 {
6247 case 0x00:
a117b0a5 6248 goto op_semantics_39;
c7927a3c
NC		 6249 break;
6250 }
6251 break;
6252 case 0xa6:
6253 GETBYTE ();
6254 switch (op[1] & 0x00)
6255 {
6256 case 0x00:
a117b0a5 6257 goto op_semantics_39;
c7927a3c
NC		 6258 break;
6259 }
6260 break;
6261 case 0xa7:
6262 GETBYTE ();
6263 switch (op[1] & 0x00)
6264 {
6265 case 0x00:
a117b0a5 6266 goto op_semantics_39;
c7927a3c
NC		 6267 break;
6268 }
6269 break;
6270 case 0xa8:
6271 GETBYTE ();
6272 switch (op[1] & 0x00)
6273 {
6274 case 0x00:
a117b0a5 6275 goto op_semantics_40;
c7927a3c
NC		 6276 break;
6277 }
6278 break;
6279 case 0xa9:
6280 GETBYTE ();
6281 switch (op[1] & 0x00)
6282 {
6283 case 0x00:
a117b0a5 6284 goto op_semantics_40;
c7927a3c
NC		 6285 break;
6286 }
6287 break;
6288 case 0xaa:
6289 GETBYTE ();
6290 switch (op[1] & 0x00)
6291 {
6292 case 0x00:
a117b0a5 6293 goto op_semantics_40;
c7927a3c
NC		 6294 break;
6295 }
6296 break;
6297 case 0xab:
6298 GETBYTE ();
6299 switch (op[1] & 0x00)
6300 {
6301 case 0x00:
a117b0a5 6302 goto op_semantics_40;
c7927a3c
NC		 6303 break;
6304 }
6305 break;
6306 case 0xac:
6307 GETBYTE ();
6308 switch (op[1] & 0x00)
6309 {
6310 case 0x00:
a117b0a5 6311 goto op_semantics_40;
c7927a3c
NC		 6312 break;
6313 }
6314 break;
6315 case 0xad:
6316 GETBYTE ();
6317 switch (op[1] & 0x00)
6318 {
6319 case 0x00:
a117b0a5 6320 goto op_semantics_40;
c7927a3c
NC		 6321 break;
6322 }
6323 break;
6324 case 0xae:
6325 GETBYTE ();
6326 switch (op[1] & 0x00)
6327 {
6328 case 0x00:
a117b0a5 6329 goto op_semantics_40;
c7927a3c
NC		 6330 break;
6331 }
6332 break;
6333 case 0xaf:
6334 GETBYTE ();
6335 switch (op[1] & 0x00)
6336 {
6337 case 0x00:
a117b0a5 6338 goto op_semantics_40;
c7927a3c
NC		 6339 break;
6340 }
6341 break;
6342 case 0xb0:
6343 GETBYTE ();
6344 switch (op[1] & 0x00)
6345 {
6346 case 0x00:
a117b0a5 6347 op_semantics_41:
c7927a3c
NC		 6348 {
6349 /** 1011 w dsp a src b dst movu%s %1, %0 */
e197589b 6350#line 356 "rx-decode.opc"
c7927a3c 6351 int w AU = (op[0] >> 3) & 0x01;
e197589b 6352#line 356 "rx-decode.opc"
c7927a3c 6353 int dsp AU = op[0] & 0x07;
e197589b 6354#line 356 "rx-decode.opc"
c7927a3c 6355 int a AU = (op[1] >> 7) & 0x01;
e197589b 6356#line 356 "rx-decode.opc"
c7927a3c 6357 int src AU = (op[1] >> 4) & 0x07;
e197589b 6358#line 356 "rx-decode.opc"
c7927a3c 6359 int b AU = (op[1] >> 3) & 0x01;
e197589b 6360#line 356 "rx-decode.opc"
c7927a3c
NC		 6361 int dst AU = op[1] & 0x07;
6362 if (trace)
6363 {
6364 printf ("\033[33m%s\033[0m %02x %02x\n",
6365 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6366 op[0], op[1]);
6367 printf (" w = 0x%x,", w);
6368 printf (" dsp = 0x%x,", dsp);
6369 printf (" a = 0x%x,", a);
6370 printf (" src = 0x%x,", src);
6371 printf (" b = 0x%x,", b);
6372 printf (" dst = 0x%x\n", dst);
6373 }
6374 SYNTAX("movu%s %1, %0");
e197589b 6375#line 356 "rx-decode.opc"
f04265ec 6376 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
43e65147 6377
c7927a3c
NC		 6378 }
6379 break;
6380 }
6381 break;
6382 case 0xb1:
6383 GETBYTE ();
6384 switch (op[1] & 0x00)
6385 {
6386 case 0x00:
a117b0a5 6387 goto op_semantics_41;
c7927a3c
NC		 6388 break;
6389 }
6390 break;
6391 case 0xb2:
6392 GETBYTE ();
6393 switch (op[1] & 0x00)
6394 {
6395 case 0x00:
a117b0a5 6396 goto op_semantics_41;
c7927a3c
NC		 6397 break;
6398 }
6399 break;
6400 case 0xb3:
6401 GETBYTE ();
6402 switch (op[1] & 0x00)
6403 {
6404 case 0x00:
a117b0a5 6405 goto op_semantics_41;
c7927a3c
NC		 6406 break;
6407 }
6408 break;
6409 case 0xb4:
6410 GETBYTE ();
6411 switch (op[1] & 0x00)
6412 {
6413 case 0x00:
a117b0a5 6414 goto op_semantics_41;
c7927a3c
NC		 6415 break;
6416 }
6417 break;
6418 case 0xb5:
6419 GETBYTE ();
6420 switch (op[1] & 0x00)
6421 {
6422 case 0x00:
a117b0a5 6423 goto op_semantics_41;
c7927a3c
NC		 6424 break;
6425 }
6426 break;
6427 case 0xb6:
6428 GETBYTE ();
6429 switch (op[1] & 0x00)
6430 {
6431 case 0x00:
a117b0a5 6432 goto op_semantics_41;
c7927a3c
NC		 6433 break;
6434 }
6435 break;
6436 case 0xb7:
6437 GETBYTE ();
6438 switch (op[1] & 0x00)
6439 {
6440 case 0x00:
a117b0a5 6441 goto op_semantics_41;
c7927a3c
NC		 6442 break;
6443 }
6444 break;
6445 case 0xb8:
6446 GETBYTE ();
6447 switch (op[1] & 0x00)
6448 {
6449 case 0x00:
a117b0a5 6450 goto op_semantics_41;
c7927a3c
NC		 6451 break;
6452 }
6453 break;
6454 case 0xb9:
6455 GETBYTE ();
6456 switch (op[1] & 0x00)
6457 {
6458 case 0x00:
a117b0a5 6459 goto op_semantics_41;
c7927a3c
NC		 6460 break;
6461 }
6462 break;
6463 case 0xba:
6464 GETBYTE ();
6465 switch (op[1] & 0x00)
6466 {
6467 case 0x00:
a117b0a5 6468 goto op_semantics_41;
c7927a3c
NC		 6469 break;
6470 }
6471 break;
6472 case 0xbb:
6473 GETBYTE ();
6474 switch (op[1] & 0x00)
6475 {
6476 case 0x00:
a117b0a5 6477 goto op_semantics_41;
c7927a3c
NC		 6478 break;
6479 }
6480 break;
6481 case 0xbc:
6482 GETBYTE ();
6483 switch (op[1] & 0x00)
6484 {
6485 case 0x00:
a117b0a5 6486 goto op_semantics_41;
c7927a3c
NC		 6487 break;
6488 }
6489 break;
6490 case 0xbd:
6491 GETBYTE ();
6492 switch (op[1] & 0x00)
6493 {
6494 case 0x00:
a117b0a5 6495 goto op_semantics_41;
c7927a3c
NC		 6496 break;
6497 }
6498 break;
6499 case 0xbe:
6500 GETBYTE ();
6501 switch (op[1] & 0x00)
6502 {
6503 case 0x00:
a117b0a5 6504 goto op_semantics_41;
c7927a3c
NC		 6505 break;
6506 }
6507 break;
6508 case 0xbf:
6509 GETBYTE ();
6510 switch (op[1] & 0x00)
6511 {
6512 case 0x00:
a117b0a5 6513 goto op_semantics_41;
c7927a3c
NC		 6514 break;
6515 }
6516 break;
6517 case 0xc0:
6518 GETBYTE ();
6519 switch (op[1] & 0x00)
6520 {
6521 case 0x00:
a117b0a5 6522 op_semantics_42:
c7927a3c
NC		 6523 {
6524 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
e197589b 6525#line 314 "rx-decode.opc"
c7927a3c 6526 int sz AU = (op[0] >> 4) & 0x03;
e197589b 6527#line 314 "rx-decode.opc"
c7927a3c 6528 int sd AU = (op[0] >> 2) & 0x03;
e197589b 6529#line 314 "rx-decode.opc"
c7927a3c 6530 int ss AU = op[0] & 0x03;
e197589b 6531#line 314 "rx-decode.opc"
c7927a3c 6532 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 6533#line 314 "rx-decode.opc"
c7927a3c
NC		 6534 int rdst AU = op[1] & 0x0f;
6535 if (trace)
6536 {
6537 printf ("\033[33m%s\033[0m %02x %02x\n",
6538 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6539 op[0], op[1]);
6540 printf (" sz = 0x%x,", sz);
6541 printf (" sd = 0x%x,", sd);
6542 printf (" ss = 0x%x,", ss);
6543 printf (" rsrc = 0x%x,", rsrc);
6544 printf (" rdst = 0x%x\n", rdst);
6545 }
6546 SYNTAX("mov%s %1, %0");
e197589b 6547#line 314 "rx-decode.opc"
b5e04c2b 6548 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
c7927a3c 6549 {
f9c7014e 6550 ID(nop2);
854eb72b 6551 SYNTAX ("nop\t; mov.l\tr0, r0");
c7927a3c
NC		 6552 }
6553 else
6554 {
f9c7014e
DD		 6555 ID(mov); sBWL(sz); F_____;
6556 if ((ss == 3) && (sd != 3))
a117b0a5
YS		 6557 {
6558 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6559 }
f9c7014e 6560 else
a117b0a5
YS		 6561 {
6562 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6563 }
c7927a3c 6564 }
43e65147 6565
c7927a3c
NC		 6566 }
6567 break;
6568 }
6569 break;
6570 case 0xc1:
6571 GETBYTE ();
6572 switch (op[1] & 0x00)
6573 {
6574 case 0x00:
a117b0a5 6575 goto op_semantics_42;
c7927a3c
NC		 6576 break;
6577 }
6578 break;
6579 case 0xc2:
6580 GETBYTE ();
6581 switch (op[1] & 0x00)
6582 {
6583 case 0x00:
a117b0a5 6584 goto op_semantics_42;
c7927a3c
NC		 6585 break;
6586 }
6587 break;
6588 case 0xc3:
6589 GETBYTE ();
6590 switch (op[1] & 0x00)
6591 {
6592 case 0x00:
a117b0a5 6593 goto op_semantics_42;
c7927a3c
NC		 6594 break;
6595 }
6596 break;
6597 case 0xc4:
6598 GETBYTE ();
6599 switch (op[1] & 0x00)
6600 {
6601 case 0x00:
a117b0a5 6602 goto op_semantics_42;
c7927a3c
NC		 6603 break;
6604 }
6605 break;
6606 case 0xc5:
6607 GETBYTE ();
6608 switch (op[1] & 0x00)
6609 {
6610 case 0x00:
a117b0a5 6611 goto op_semantics_42;
c7927a3c
NC		 6612 break;
6613 }
6614 break;
6615 case 0xc6:
6616 GETBYTE ();
6617 switch (op[1] & 0x00)
6618 {
6619 case 0x00:
a117b0a5 6620 goto op_semantics_42;
c7927a3c
NC		 6621 break;
6622 }
6623 break;
6624 case 0xc7:
6625 GETBYTE ();
6626 switch (op[1] & 0x00)
6627 {
6628 case 0x00:
a117b0a5 6629 goto op_semantics_42;
c7927a3c
NC		 6630 break;
6631 }
6632 break;
6633 case 0xc8:
6634 GETBYTE ();
6635 switch (op[1] & 0x00)
6636 {
6637 case 0x00:
a117b0a5 6638 goto op_semantics_42;
c7927a3c
NC		 6639 break;
6640 }
6641 break;
6642 case 0xc9:
6643 GETBYTE ();
6644 switch (op[1] & 0x00)
6645 {
6646 case 0x00:
a117b0a5 6647 goto op_semantics_42;
c7927a3c
NC		 6648 break;
6649 }
6650 break;
6651 case 0xca:
6652 GETBYTE ();
6653 switch (op[1] & 0x00)
6654 {
6655 case 0x00:
a117b0a5 6656 goto op_semantics_42;
c7927a3c
NC		 6657 break;
6658 }
6659 break;
6660 case 0xcb:
6661 GETBYTE ();
6662 switch (op[1] & 0x00)
6663 {
6664 case 0x00:
a117b0a5 6665 goto op_semantics_42;
c7927a3c
NC		 6666 break;
6667 }
6668 break;
6669 case 0xcc:
6670 GETBYTE ();
6671 switch (op[1] & 0x00)
6672 {
6673 case 0x00:
a117b0a5 6674 goto op_semantics_42;
c7927a3c
NC		 6675 break;
6676 }
6677 break;
6678 case 0xcd:
6679 GETBYTE ();
6680 switch (op[1] & 0x00)
6681 {
6682 case 0x00:
a117b0a5 6683 goto op_semantics_42;
c7927a3c
NC		 6684 break;
6685 }
6686 break;
6687 case 0xce:
6688 GETBYTE ();
6689 switch (op[1] & 0x00)
6690 {
6691 case 0x00:
a117b0a5 6692 goto op_semantics_42;
c7927a3c
NC		 6693 break;
6694 }
6695 break;
6696 case 0xcf:
6697 GETBYTE ();
6698 switch (op[1] & 0x00)
6699 {
6700 case 0x00:
a117b0a5 6701 goto op_semantics_42;
c7927a3c
NC		 6702 break;
6703 }
6704 break;
6705 case 0xd0:
6706 GETBYTE ();
6707 switch (op[1] & 0x00)
6708 {
6709 case 0x00:
a117b0a5 6710 goto op_semantics_42;
c7927a3c
NC		 6711 break;
6712 }
6713 break;
6714 case 0xd1:
6715 GETBYTE ();
6716 switch (op[1] & 0x00)
6717 {
6718 case 0x00:
a117b0a5 6719 goto op_semantics_42;
c7927a3c
NC		 6720 break;
6721 }
6722 break;
6723 case 0xd2:
6724 GETBYTE ();
6725 switch (op[1] & 0x00)
6726 {
6727 case 0x00:
a117b0a5 6728 goto op_semantics_42;
c7927a3c
NC		 6729 break;
6730 }
6731 break;
6732 case 0xd3:
6733 GETBYTE ();
6734 switch (op[1] & 0x00)
6735 {
6736 case 0x00:
a117b0a5 6737 goto op_semantics_42;
c7927a3c
NC		 6738 break;
6739 }
6740 break;
6741 case 0xd4:
6742 GETBYTE ();
6743 switch (op[1] & 0x00)
6744 {
6745 case 0x00:
a117b0a5 6746 goto op_semantics_42;
c7927a3c
NC		 6747 break;
6748 }
6749 break;
6750 case 0xd5:
6751 GETBYTE ();
6752 switch (op[1] & 0x00)
6753 {
6754 case 0x00:
a117b0a5 6755 goto op_semantics_42;
c7927a3c
NC		 6756 break;
6757 }
6758 break;
6759 case 0xd6:
6760 GETBYTE ();
6761 switch (op[1] & 0x00)
6762 {
6763 case 0x00:
a117b0a5 6764 goto op_semantics_42;
c7927a3c
NC		 6765 break;
6766 }
6767 break;
6768 case 0xd7:
6769 GETBYTE ();
6770 switch (op[1] & 0x00)
6771 {
6772 case 0x00:
a117b0a5 6773 goto op_semantics_42;
c7927a3c
NC		 6774 break;
6775 }
6776 break;
6777 case 0xd8:
6778 GETBYTE ();
6779 switch (op[1] & 0x00)
6780 {
6781 case 0x00:
a117b0a5 6782 goto op_semantics_42;
c7927a3c
NC		 6783 break;
6784 }
6785 break;
6786 case 0xd9:
6787 GETBYTE ();
6788 switch (op[1] & 0x00)
6789 {
6790 case 0x00:
a117b0a5 6791 goto op_semantics_42;
c7927a3c
NC		 6792 break;
6793 }
6794 break;
6795 case 0xda:
6796 GETBYTE ();
6797 switch (op[1] & 0x00)
6798 {
6799 case 0x00:
a117b0a5 6800 goto op_semantics_42;
c7927a3c
NC		 6801 break;
6802 }
6803 break;
6804 case 0xdb:
6805 GETBYTE ();
6806 switch (op[1] & 0x00)
6807 {
6808 case 0x00:
a117b0a5 6809 goto op_semantics_42;
c7927a3c
NC		 6810 break;
6811 }
6812 break;
6813 case 0xdc:
6814 GETBYTE ();
6815 switch (op[1] & 0x00)
6816 {
6817 case 0x00:
a117b0a5 6818 goto op_semantics_42;
c7927a3c
NC		 6819 break;
6820 }
6821 break;
6822 case 0xdd:
6823 GETBYTE ();
6824 switch (op[1] & 0x00)
6825 {
6826 case 0x00:
a117b0a5 6827 goto op_semantics_42;
c7927a3c
NC		 6828 break;
6829 }
6830 break;
6831 case 0xde:
6832 GETBYTE ();
6833 switch (op[1] & 0x00)
6834 {
6835 case 0x00:
a117b0a5 6836 goto op_semantics_42;
c7927a3c
NC		 6837 break;
6838 }
6839 break;
6840 case 0xdf:
6841 GETBYTE ();
6842 switch (op[1] & 0x00)
6843 {
6844 case 0x00:
a117b0a5 6845 goto op_semantics_42;
c7927a3c
NC		 6846 break;
6847 }
6848 break;
6849 case 0xe0:
6850 GETBYTE ();
6851 switch (op[1] & 0x00)
6852 {
6853 case 0x00:
a117b0a5 6854 goto op_semantics_42;
c7927a3c
NC		 6855 break;
6856 }
6857 break;
6858 case 0xe1:
6859 GETBYTE ();
6860 switch (op[1] & 0x00)
6861 {
6862 case 0x00:
a117b0a5 6863 goto op_semantics_42;
c7927a3c
NC		 6864 break;
6865 }
6866 break;
6867 case 0xe2:
6868 GETBYTE ();
6869 switch (op[1] & 0x00)
6870 {
6871 case 0x00:
a117b0a5 6872 goto op_semantics_42;
c7927a3c
NC		 6873 break;
6874 }
6875 break;
6876 case 0xe3:
6877 GETBYTE ();
6878 switch (op[1] & 0x00)
6879 {
6880 case 0x00:
a117b0a5 6881 goto op_semantics_42;
c7927a3c
NC		 6882 break;
6883 }
6884 break;
6885 case 0xe4:
6886 GETBYTE ();
6887 switch (op[1] & 0x00)
6888 {
6889 case 0x00:
a117b0a5 6890 goto op_semantics_42;
c7927a3c
NC		 6891 break;
6892 }
6893 break;
6894 case 0xe5:
6895 GETBYTE ();
6896 switch (op[1] & 0x00)
6897 {
6898 case 0x00:
a117b0a5 6899 goto op_semantics_42;
c7927a3c
NC		 6900 break;
6901 }
6902 break;
6903 case 0xe6:
6904 GETBYTE ();
6905 switch (op[1] & 0x00)
6906 {
6907 case 0x00:
a117b0a5 6908 goto op_semantics_42;
c7927a3c
NC		 6909 break;
6910 }
6911 break;
6912 case 0xe7:
6913 GETBYTE ();
6914 switch (op[1] & 0x00)
6915 {
6916 case 0x00:
a117b0a5 6917 goto op_semantics_42;
c7927a3c
NC		 6918 break;
6919 }
6920 break;
6921 case 0xe8:
6922 GETBYTE ();
6923 switch (op[1] & 0x00)
6924 {
6925 case 0x00:
a117b0a5 6926 goto op_semantics_42;
c7927a3c
NC		 6927 break;
6928 }
6929 break;
6930 case 0xe9:
6931 GETBYTE ();
6932 switch (op[1] & 0x00)
6933 {
6934 case 0x00:
a117b0a5 6935 goto op_semantics_42;
c7927a3c
NC		 6936 break;
6937 }
6938 break;
6939 case 0xea:
6940 GETBYTE ();
6941 switch (op[1] & 0x00)
6942 {
6943 case 0x00:
a117b0a5 6944 goto op_semantics_42;
c7927a3c
NC		 6945 break;
6946 }
6947 break;
6948 case 0xeb:
6949 GETBYTE ();
6950 switch (op[1] & 0x00)
6951 {
6952 case 0x00:
a117b0a5 6953 goto op_semantics_42;
c7927a3c
NC		 6954 break;
6955 }
6956 break;
6957 case 0xec:
6958 GETBYTE ();
6959 switch (op[1] & 0x00)
6960 {
6961 case 0x00:
a117b0a5 6962 goto op_semantics_42;
c7927a3c
NC		 6963 break;
6964 }
6965 break;
6966 case 0xed:
6967 GETBYTE ();
6968 switch (op[1] & 0x00)
6969 {
6970 case 0x00:
a117b0a5 6971 goto op_semantics_42;
c7927a3c
NC		 6972 break;
6973 }
6974 break;
6975 case 0xee:
6976 GETBYTE ();
6977 switch (op[1] & 0x00)
6978 {
6979 case 0x00:
a117b0a5 6980 goto op_semantics_42;
c7927a3c
NC		 6981 break;
6982 }
6983 break;
6984 case 0xef:
6985 GETBYTE ();
6986 switch (op[1] & 0x00)
6987 {
6988 case 0x00:
a117b0a5 6989 goto op_semantics_42;
c7927a3c
NC		 6990 break;
6991 }
6992 break;
6993 case 0xf0:
6994 GETBYTE ();
6995 switch (op[1] & 0x08)
6996 {
6997 case 0x00:
a117b0a5 6998 op_semantics_43:
c7927a3c
NC		 6999 {
7000 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
e197589b 7001#line 939 "rx-decode.opc"
c7927a3c 7002 int sd AU = op[0] & 0x03;
e197589b 7003#line 939 "rx-decode.opc"
c7927a3c 7004 int rdst AU = (op[1] >> 4) & 0x0f;
e197589b 7005#line 939 "rx-decode.opc"
c7927a3c
NC		 7006 int bit AU = op[1] & 0x07;
7007 if (trace)
7008 {
7009 printf ("\033[33m%s\033[0m %02x %02x\n",
7010 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
7011 op[0], op[1]);
7012 printf (" sd = 0x%x,", sd);
7013 printf (" rdst = 0x%x,", rdst);
7014 printf (" bit = 0x%x\n", bit);
7015 }
7016 SYNTAX("bset #%1, %0%S0");
e197589b 7017#line 939 "rx-decode.opc"
3cf79a01 7018 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
43e65147 7019
c7927a3c
NC		 7020 }
7021 break;
7022 case 0x08:
a117b0a5 7023 op_semantics_44:
c7927a3c
NC		 7024 {
7025 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
e197589b 7026#line 951 "rx-decode.opc"
c7927a3c 7027 int sd AU = op[0] & 0x03;
e197589b 7028#line 951 "rx-decode.opc"
c7927a3c 7029 int rdst AU = (op[1] >> 4) & 0x0f;
e197589b 7030#line 951 "rx-decode.opc"
c7927a3c
NC		 7031 int bit AU = op[1] & 0x07;
7032 if (trace)
7033 {
7034 printf ("\033[33m%s\033[0m %02x %02x\n",
7035 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
7036 op[0], op[1]);
7037 printf (" sd = 0x%x,", sd);
7038 printf (" rdst = 0x%x,", rdst);
7039 printf (" bit = 0x%x\n", bit);
7040 }
7041 SYNTAX("bclr #%1, %0%S0");
e197589b 7042#line 951 "rx-decode.opc"
3cf79a01 7043 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
43e65147 7044
c7927a3c
NC		 7045 }
7046 break;
7047 }
7048 break;
7049 case 0xf1:
7050 GETBYTE ();
7051 switch (op[1] & 0x08)
7052 {
7053 case 0x00:
a117b0a5 7054 goto op_semantics_43;
c7927a3c
NC		 7055 break;
7056 case 0x08:
a117b0a5 7057 goto op_semantics_44;
c7927a3c
NC		 7058 break;
7059 }
7060 break;
7061 case 0xf2:
7062 GETBYTE ();
7063 switch (op[1] & 0x08)
7064 {
7065 case 0x00:
a117b0a5 7066 goto op_semantics_43;
c7927a3c
NC		 7067 break;
7068 case 0x08:
a117b0a5 7069 goto op_semantics_44;
c7927a3c
NC		 7070 break;
7071 }
7072 break;
7073 case 0xf3:
7074 GETBYTE ();
7075 switch (op[1] & 0x08)
7076 {
7077 case 0x00:
a117b0a5 7078 goto op_semantics_43;
c7927a3c
NC		 7079 break;
7080 case 0x08:
a117b0a5 7081 goto op_semantics_44;
c7927a3c
NC		 7082 break;
7083 }
7084 break;
7085 case 0xf4:
7086 GETBYTE ();
7087 switch (op[1] & 0x0c)
7088 {
7089 case 0x00:
7090 case 0x04:
a117b0a5 7091 op_semantics_45:
c7927a3c
NC		 7092 {
7093 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
e197589b 7094#line 963 "rx-decode.opc"
c7927a3c 7095 int sd AU = op[0] & 0x03;
e197589b 7096#line 963 "rx-decode.opc"
c7927a3c 7097 int rdst AU = (op[1] >> 4) & 0x0f;
e197589b 7098#line 963 "rx-decode.opc"
c7927a3c
NC		 7099 int bit AU = op[1] & 0x07;
7100 if (trace)
7101 {
7102 printf ("\033[33m%s\033[0m %02x %02x\n",
7103 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
7104 op[0], op[1]);
7105 printf (" sd = 0x%x,", sd);
7106 printf (" rdst = 0x%x,", rdst);
7107 printf (" bit = 0x%x\n", bit);
7108 }
7109 SYNTAX("btst #%2, %1%S1");
e197589b 7110#line 963 "rx-decode.opc"
3cf79a01 7111 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
43e65147 7112
c7927a3c
NC		 7113 }
7114 break;
7115 case 0x08:
a117b0a5 7116 op_semantics_46:
c7927a3c
NC		 7117 {
7118 /** 1111 01ss rsrc 10sz push%s %1 */
e197589b 7119#line 381 "rx-decode.opc"
c7927a3c 7120 int ss AU = op[0] & 0x03;
e197589b 7121#line 381 "rx-decode.opc"
c7927a3c 7122 int rsrc AU = (op[1] >> 4) & 0x0f;
e197589b 7123#line 381 "rx-decode.opc"
c7927a3c
NC		 7124 int sz AU = op[1] & 0x03;
7125 if (trace)
7126 {
7127 printf ("\033[33m%s\033[0m %02x %02x\n",
7128 "/** 1111 01ss rsrc 10sz push%s %1 */",
7129 op[0], op[1]);
7130 printf (" ss = 0x%x,", ss);
7131 printf (" rsrc = 0x%x,", rsrc);
7132 printf (" sz = 0x%x\n", sz);
7133 }
7134 SYNTAX("push%s %1");
e197589b 7135#line 381 "rx-decode.opc"
3cf79a01 7136 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
43e65147 7137
c7927a3c
NC		 7138 /*----------------------------------------------------------------------*/
7139 /* XCHG */
43e65147 7140
c7927a3c
NC		 7141 }
7142 break;
7143 default: UNSUPPORTED(); break;
7144 }
7145 break;
7146 case 0xf5:
7147 GETBYTE ();
7148 switch (op[1] & 0x0c)
7149 {
7150 case 0x00:
7151 case 0x04:
a117b0a5 7152 goto op_semantics_45;
c7927a3c
NC		 7153 break;
7154 case 0x08:
a117b0a5 7155 goto op_semantics_46;
c7927a3c
NC		 7156 break;
7157 default: UNSUPPORTED(); break;
7158 }
7159 break;
7160 case 0xf6:
7161 GETBYTE ();
7162 switch (op[1] & 0x0c)
7163 {
7164 case 0x00:
7165 case 0x04:
a117b0a5 7166 goto op_semantics_45;
c7927a3c
NC		 7167 break;
7168 case 0x08:
a117b0a5 7169 goto op_semantics_46;
c7927a3c
NC		 7170 break;
7171 default: UNSUPPORTED(); break;
7172 }
7173 break;
7174 case 0xf7:
7175 GETBYTE ();
7176 switch (op[1] & 0x0c)
7177 {
7178 case 0x00:
7179 case 0x04:
a117b0a5 7180 goto op_semantics_45;
c7927a3c
NC		 7181 break;
7182 case 0x08:
a117b0a5 7183 goto op_semantics_46;
c7927a3c
NC		 7184 break;
7185 default: UNSUPPORTED(); break;
7186 }
7187 break;
7188 case 0xf8:
7189 GETBYTE ();
7190 switch (op[1] & 0x00)
7191 {
7192 case 0x00:
a117b0a5 7193 op_semantics_47:
c7927a3c
NC		 7194 {
7195 /** 1111 10sd rdst im sz mov%s #%1, %0 */
e197589b 7196#line 292 "rx-decode.opc"
c7927a3c 7197 int sd AU = op[0] & 0x03;
e197589b 7198#line 292 "rx-decode.opc"
c7927a3c 7199 int rdst AU = (op[1] >> 4) & 0x0f;
e197589b 7200#line 292 "rx-decode.opc"
c7927a3c 7201 int im AU = (op[1] >> 2) & 0x03;
e197589b 7202#line 292 "rx-decode.opc"
c7927a3c
NC		 7203 int sz AU = op[1] & 0x03;
7204 if (trace)
7205 {
7206 printf ("\033[33m%s\033[0m %02x %02x\n",
7207 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
7208 op[0], op[1]);
7209 printf (" sd = 0x%x,", sd);
7210 printf (" rdst = 0x%x,", rdst);
7211 printf (" im = 0x%x,", im);
7212 printf (" sz = 0x%x\n", sz);
7213 }
7214 SYNTAX("mov%s #%1, %0");
e197589b 7215#line 292 "rx-decode.opc"
78e98aab
DD		 7216 ID(mov); DD(sd, rdst, sz);
7217 if ((im == 1 && sz == 0)
7218 || (im == 2 && sz == 1)
7219 || (im == 0 && sz == 2))
7220 {
7221 BWL (sz);
7222 SC(IMM(im));
7223 }
7224 else
7225 {
7226 sBWL (sz);
7227 SC(IMMex(im));
7228 }
7229 F_____;
43e65147 7230
c7927a3c
NC		 7231 }
7232 break;
7233 }
7234 break;
7235 case 0xf9:
7236 GETBYTE ();
7237 switch (op[1] & 0x00)
7238 {
7239 case 0x00:
a117b0a5 7240 goto op_semantics_47;
c7927a3c
NC		 7241 break;
7242 }
7243 break;
7244 case 0xfa:
7245 GETBYTE ();
7246 switch (op[1] & 0x00)
7247 {
7248 case 0x00:
a117b0a5 7249 goto op_semantics_47;
c7927a3c
NC		 7250 break;
7251 }
7252 break;
7253 case 0xfb:
7254 GETBYTE ();
7255 switch (op[1] & 0x00)
7256 {
7257 case 0x00:
a117b0a5 7258 goto op_semantics_47;
c7927a3c
NC		 7259 break;
7260 }
7261 break;
7262 case 0xfc:
7263 GETBYTE ();
7264 switch (op[1] & 0xff)
7265 {
7266 case 0x03:
7267 GETBYTE ();
7268 switch (op[2] & 0x00)
7269 {
7270 case 0x00:
7271 {
7272 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
e197589b 7273#line 555 "rx-decode.opc"
c7927a3c 7274 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7275#line 555 "rx-decode.opc"
c7927a3c
NC		 7276 int rdst AU = op[2] & 0x0f;
7277 if (trace)
7278 {
7279 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7280 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7281 op[0], op[1], op[2]);
7282 printf (" rsrc = 0x%x,", rsrc);
7283 printf (" rdst = 0x%x\n", rdst);
7284 }
7285 SYNTAX("sbb %1, %0");
e197589b 7286#line 555 "rx-decode.opc"
3cf79a01 7287 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
43e65147 7288
c7927a3c
NC		 7289 /* FIXME: only supports .L */
7290 }
7291 break;
7292 }
7293 break;
7294 case 0x07:
7295 GETBYTE ();
7296 switch (op[2] & 0x00)
7297 {
7298 case 0x00:
7299 {
7300 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
e197589b 7301#line 486 "rx-decode.opc"
c7927a3c 7302 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7303#line 486 "rx-decode.opc"
c7927a3c
NC		 7304 int rdst AU = op[2] & 0x0f;
7305 if (trace)
7306 {
7307 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7308 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7309 op[0], op[1], op[2]);
7310 printf (" rsrc = 0x%x,", rsrc);
7311 printf (" rdst = 0x%x\n", rdst);
7312 }
7313 SYNTAX("neg %2, %0");
e197589b 7314#line 486 "rx-decode.opc"
3cf79a01 7315 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
43e65147 7316
c7927a3c
NC		 7317 /*----------------------------------------------------------------------*/
7318 /* ADC */
43e65147 7319
c7927a3c
NC		 7320 }
7321 break;
7322 }
7323 break;
7324 case 0x0b:
7325 GETBYTE ();
7326 switch (op[2] & 0x00)
7327 {
7328 case 0x00:
7329 {
7330 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
e197589b 7331#line 495 "rx-decode.opc"
c7927a3c 7332 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7333#line 495 "rx-decode.opc"
c7927a3c
NC		 7334 int rdst AU = op[2] & 0x0f;
7335 if (trace)
7336 {
7337 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7338 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7339 op[0], op[1], op[2]);
7340 printf (" rsrc = 0x%x,", rsrc);
7341 printf (" rdst = 0x%x\n", rdst);
7342 }
7343 SYNTAX("adc %1, %0");
e197589b 7344#line 495 "rx-decode.opc"
3cf79a01 7345 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
43e65147 7346
c7927a3c
NC		 7347 }
7348 break;
7349 }
7350 break;
7351 case 0x0f:
7352 GETBYTE ();
7353 switch (op[2] & 0x00)
7354 {
7355 case 0x00:
7356 {
7357 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
e197589b 7358#line 568 "rx-decode.opc"
c7927a3c 7359 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7360#line 568 "rx-decode.opc"
c7927a3c
NC		 7361 int rdst AU = op[2] & 0x0f;
7362 if (trace)
7363 {
7364 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7365 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7366 op[0], op[1], op[2]);
7367 printf (" rsrc = 0x%x,", rsrc);
7368 printf (" rdst = 0x%x\n", rdst);
7369 }
7370 SYNTAX("abs %1, %0");
e197589b 7371#line 568 "rx-decode.opc"
3cf79a01 7372 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
43e65147 7373
c7927a3c
NC		 7374 /*----------------------------------------------------------------------*/
7375 /* MAX */
43e65147 7376
c7927a3c
NC		 7377 }
7378 break;
7379 }
7380 break;
7381 case 0x10:
7382 GETBYTE ();
7383 switch (op[2] & 0x00)
7384 {
7385 case 0x00:
a117b0a5 7386 op_semantics_48:
c7927a3c
NC		 7387 {
7388 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
e197589b 7389#line 587 "rx-decode.opc"
c7927a3c 7390 int ss AU = op[1] & 0x03;
e197589b 7391#line 587 "rx-decode.opc"
c7927a3c 7392 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7393#line 587 "rx-decode.opc"
c7927a3c
NC		 7394 int rdst AU = op[2] & 0x0f;
7395 if (trace)
7396 {
7397 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7398 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7399 op[0], op[1], op[2]);
7400 printf (" ss = 0x%x,", ss);
7401 printf (" rsrc = 0x%x,", rsrc);
7402 printf (" rdst = 0x%x\n", rdst);
7403 }
7404 SYNTAX("max %1%S1, %0");
e197589b 7405#line 587 "rx-decode.opc"
f9c7014e
DD		 7406 if (ss == 3 && rsrc == 0 && rdst == 0)
7407 {
7408 ID(nop3);
a117b0a5 7409 SYNTAX("nop\t; max\tr0, r0");
f9c7014e
DD		 7410 }
7411 else
7412 {
7413 ID(max); SP(ss, rsrc); DR(rdst);
7414 }
43e65147 7415
c7927a3c
NC		 7416 }
7417 break;
7418 }
7419 break;
7420 case 0x11:
7421 GETBYTE ();
7422 switch (op[2] & 0x00)
7423 {
7424 case 0x00:
a117b0a5 7425 goto op_semantics_48;
c7927a3c
NC		 7426 break;
7427 }
7428 break;
7429 case 0x12:
7430 GETBYTE ();
7431 switch (op[2] & 0x00)
7432 {
7433 case 0x00:
a117b0a5 7434 goto op_semantics_48;
c7927a3c
NC		 7435 break;
7436 }
7437 break;
7438 case 0x13:
7439 GETBYTE ();
7440 switch (op[2] & 0x00)
7441 {
7442 case 0x00:
a117b0a5 7443 goto op_semantics_48;
c7927a3c
NC		 7444 break;
7445 }
7446 break;
7447 case 0x14:
7448 GETBYTE ();
7449 switch (op[2] & 0x00)
7450 {
7451 case 0x00:
a117b0a5 7452 op_semantics_49:
c7927a3c
NC		 7453 {
7454 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
e197589b 7455#line 607 "rx-decode.opc"
c7927a3c 7456 int ss AU = op[1] & 0x03;
e197589b 7457#line 607 "rx-decode.opc"
c7927a3c 7458 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7459#line 607 "rx-decode.opc"
c7927a3c
NC		 7460 int rdst AU = op[2] & 0x0f;
7461 if (trace)
7462 {
7463 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7464 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7465 op[0], op[1], op[2]);
7466 printf (" ss = 0x%x,", ss);
7467 printf (" rsrc = 0x%x,", rsrc);
7468 printf (" rdst = 0x%x\n", rdst);
7469 }
7470 SYNTAX("min %1%S1, %0");
e197589b 7471#line 607 "rx-decode.opc"
c7927a3c 7472 ID(min); SP(ss, rsrc); DR(rdst);
43e65147 7473
c7927a3c
NC		 7474 }
7475 break;
7476 }
7477 break;
7478 case 0x15:
7479 GETBYTE ();
7480 switch (op[2] & 0x00)
7481 {
7482 case 0x00:
a117b0a5 7483 goto op_semantics_49;
c7927a3c
NC		 7484 break;
7485 }
7486 break;
7487 case 0x16:
7488 GETBYTE ();
7489 switch (op[2] & 0x00)
7490 {
7491 case 0x00:
a117b0a5 7492 goto op_semantics_49;
c7927a3c
NC		 7493 break;
7494 }
7495 break;
7496 case 0x17:
7497 GETBYTE ();
7498 switch (op[2] & 0x00)
7499 {
7500 case 0x00:
a117b0a5 7501 goto op_semantics_49;
c7927a3c
NC		 7502 break;
7503 }
7504 break;
7505 case 0x18:
7506 GETBYTE ();
7507 switch (op[2] & 0x00)
7508 {
7509 case 0x00:
a117b0a5 7510 op_semantics_50:
c7927a3c
NC		 7511 {
7512 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
e197589b 7513#line 665 "rx-decode.opc"
c7927a3c 7514 int ss AU = op[1] & 0x03;
e197589b 7515#line 665 "rx-decode.opc"
c7927a3c 7516 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7517#line 665 "rx-decode.opc"
c7927a3c
NC		 7518 int rdst AU = op[2] & 0x0f;
7519 if (trace)
7520 {
7521 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7522 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7523 op[0], op[1], op[2]);
7524 printf (" ss = 0x%x,", ss);
7525 printf (" rsrc = 0x%x,", rsrc);
7526 printf (" rdst = 0x%x\n", rdst);
7527 }
7528 SYNTAX("emul %1%S1, %0");
e197589b 7529#line 665 "rx-decode.opc"
c7927a3c 7530 ID(emul); SP(ss, rsrc); DR(rdst);
43e65147 7531
c7927a3c
NC		 7532 }
7533 break;
7534 }
7535 break;
7536 case 0x19:
7537 GETBYTE ();
7538 switch (op[2] & 0x00)
7539 {
7540 case 0x00:
a117b0a5 7541 goto op_semantics_50;
c7927a3c
NC		 7542 break;
7543 }
7544 break;
7545 case 0x1a:
7546 GETBYTE ();
7547 switch (op[2] & 0x00)
7548 {
7549 case 0x00:
a117b0a5 7550 goto op_semantics_50;
c7927a3c
NC		 7551 break;
7552 }
7553 break;
7554 case 0x1b:
7555 GETBYTE ();
7556 switch (op[2] & 0x00)
7557 {
7558 case 0x00:
a117b0a5 7559 goto op_semantics_50;
c7927a3c
NC		 7560 break;
7561 }
7562 break;
7563 case 0x1c:
7564 GETBYTE ();
7565 switch (op[2] & 0x00)
7566 {
7567 case 0x00:
a117b0a5 7568 op_semantics_51:
c7927a3c
NC		 7569 {
7570 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
e197589b 7571#line 677 "rx-decode.opc"
c7927a3c 7572 int ss AU = op[1] & 0x03;
e197589b 7573#line 677 "rx-decode.opc"
c7927a3c 7574 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7575#line 677 "rx-decode.opc"
c7927a3c
NC		 7576 int rdst AU = op[2] & 0x0f;
7577 if (trace)
7578 {
7579 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7580 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7581 op[0], op[1], op[2]);
7582 printf (" ss = 0x%x,", ss);
7583 printf (" rsrc = 0x%x,", rsrc);
7584 printf (" rdst = 0x%x\n", rdst);
7585 }
7586 SYNTAX("emulu %1%S1, %0");
e197589b 7587#line 677 "rx-decode.opc"
c7927a3c 7588 ID(emulu); SP(ss, rsrc); DR(rdst);
43e65147 7589
c7927a3c
NC		 7590 }
7591 break;
7592 }
7593 break;
7594 case 0x1d:
7595 GETBYTE ();
7596 switch (op[2] & 0x00)
7597 {
7598 case 0x00:
a117b0a5 7599 goto op_semantics_51;
c7927a3c
NC		 7600 break;
7601 }
7602 break;
7603 case 0x1e:
7604 GETBYTE ();
7605 switch (op[2] & 0x00)
7606 {
7607 case 0x00:
a117b0a5 7608 goto op_semantics_51;
c7927a3c
NC		 7609 break;
7610 }
7611 break;
7612 case 0x1f:
7613 GETBYTE ();
7614 switch (op[2] & 0x00)
7615 {
7616 case 0x00:
a117b0a5 7617 goto op_semantics_51;
c7927a3c
NC		 7618 break;
7619 }
7620 break;
7621 case 0x20:
7622 GETBYTE ();
7623 switch (op[2] & 0x00)
7624 {
7625 case 0x00:
a117b0a5 7626 op_semantics_52:
c7927a3c
NC		 7627 {
7628 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
e197589b 7629#line 689 "rx-decode.opc"
c7927a3c 7630 int ss AU = op[1] & 0x03;
e197589b 7631#line 689 "rx-decode.opc"
c7927a3c 7632 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7633#line 689 "rx-decode.opc"
c7927a3c
NC		 7634 int rdst AU = op[2] & 0x0f;
7635 if (trace)
7636 {
7637 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7638 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7639 op[0], op[1], op[2]);
7640 printf (" ss = 0x%x,", ss);
7641 printf (" rsrc = 0x%x,", rsrc);
7642 printf (" rdst = 0x%x\n", rdst);
7643 }
7644 SYNTAX("div %1%S1, %0");
e197589b 7645#line 689 "rx-decode.opc"
3cf79a01 7646 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
43e65147 7647
c7927a3c
NC		 7648 }
7649 break;
7650 }
7651 break;
7652 case 0x21:
7653 GETBYTE ();
7654 switch (op[2] & 0x00)
7655 {
7656 case 0x00:
a117b0a5 7657 goto op_semantics_52;
c7927a3c
NC		 7658 break;
7659 }
7660 break;
7661 case 0x22:
7662 GETBYTE ();
7663 switch (op[2] & 0x00)
7664 {
7665 case 0x00:
a117b0a5 7666 goto op_semantics_52;
c7927a3c
NC		 7667 break;
7668 }
7669 break;
7670 case 0x23:
7671 GETBYTE ();
7672 switch (op[2] & 0x00)
7673 {
7674 case 0x00:
a117b0a5 7675 goto op_semantics_52;
c7927a3c
NC		 7676 break;
7677 }
7678 break;
7679 case 0x24:
7680 GETBYTE ();
7681 switch (op[2] & 0x00)
7682 {
7683 case 0x00:
a117b0a5 7684 op_semantics_53:
c7927a3c
NC		 7685 {
7686 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
e197589b 7687#line 701 "rx-decode.opc"
c7927a3c 7688 int ss AU = op[1] & 0x03;
e197589b 7689#line 701 "rx-decode.opc"
c7927a3c 7690 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7691#line 701 "rx-decode.opc"
c7927a3c
NC		 7692 int rdst AU = op[2] & 0x0f;
7693 if (trace)
7694 {
7695 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7696 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7697 op[0], op[1], op[2]);
7698 printf (" ss = 0x%x,", ss);
7699 printf (" rsrc = 0x%x,", rsrc);
7700 printf (" rdst = 0x%x\n", rdst);
7701 }
7702 SYNTAX("divu %1%S1, %0");
e197589b 7703#line 701 "rx-decode.opc"
3cf79a01 7704 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
43e65147 7705
c7927a3c
NC		 7706 }
7707 break;
7708 }
7709 break;
7710 case 0x25:
7711 GETBYTE ();
7712 switch (op[2] & 0x00)
7713 {
7714 case 0x00:
a117b0a5 7715 goto op_semantics_53;
c7927a3c
NC		 7716 break;
7717 }
7718 break;
7719 case 0x26:
7720 GETBYTE ();
7721 switch (op[2] & 0x00)
7722 {
7723 case 0x00:
a117b0a5 7724 goto op_semantics_53;
c7927a3c
NC		 7725 break;
7726 }
7727 break;
7728 case 0x27:
7729 GETBYTE ();
7730 switch (op[2] & 0x00)
7731 {
7732 case 0x00:
a117b0a5 7733 goto op_semantics_53;
c7927a3c
NC		 7734 break;
7735 }
7736 break;
7737 case 0x30:
7738 GETBYTE ();
7739 switch (op[2] & 0x00)
7740 {
7741 case 0x00:
a117b0a5 7742 op_semantics_54:
c7927a3c
NC		 7743 {
7744 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
e197589b 7745#line 474 "rx-decode.opc"
c7927a3c 7746 int ss AU = op[1] & 0x03;
e197589b 7747#line 474 "rx-decode.opc"
c7927a3c 7748 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7749#line 474 "rx-decode.opc"
c7927a3c
NC		 7750 int rdst AU = op[2] & 0x0f;
7751 if (trace)
7752 {
7753 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7754 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7755 op[0], op[1], op[2]);
7756 printf (" ss = 0x%x,", ss);
7757 printf (" rsrc = 0x%x,", rsrc);
7758 printf (" rdst = 0x%x\n", rdst);
7759 }
7760 SYNTAX("tst %1%S1, %2");
e197589b 7761#line 474 "rx-decode.opc"
3cf79a01 7762 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
43e65147 7763
c7927a3c
NC		 7764 }
7765 break;
7766 }
7767 break;
7768 case 0x31:
7769 GETBYTE ();
7770 switch (op[2] & 0x00)
7771 {
7772 case 0x00:
a117b0a5 7773 goto op_semantics_54;
c7927a3c
NC		 7774 break;
7775 }
7776 break;
7777 case 0x32:
7778 GETBYTE ();
7779 switch (op[2] & 0x00)
7780 {
7781 case 0x00:
a117b0a5 7782 goto op_semantics_54;
c7927a3c
NC		 7783 break;
7784 }
7785 break;
7786 case 0x33:
7787 GETBYTE ();
7788 switch (op[2] & 0x00)
7789 {
7790 case 0x00:
a117b0a5 7791 goto op_semantics_54;
c7927a3c
NC		 7792 break;
7793 }
7794 break;
7795 case 0x34:
7796 GETBYTE ();
7797 switch (op[2] & 0x00)
7798 {
7799 case 0x00:
a117b0a5 7800 op_semantics_55:
c7927a3c
NC		 7801 {
7802 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
e197589b 7803#line 453 "rx-decode.opc"
c7927a3c 7804 int ss AU = op[1] & 0x03;
e197589b 7805#line 453 "rx-decode.opc"
c7927a3c 7806 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7807#line 453 "rx-decode.opc"
c7927a3c
NC		 7808 int rdst AU = op[2] & 0x0f;
7809 if (trace)
7810 {
7811 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7812 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7813 op[0], op[1], op[2]);
7814 printf (" ss = 0x%x,", ss);
7815 printf (" rsrc = 0x%x,", rsrc);
7816 printf (" rdst = 0x%x\n", rdst);
7817 }
7818 SYNTAX("xor %1%S1, %0");
e197589b 7819#line 453 "rx-decode.opc"
3cf79a01 7820 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
43e65147 7821
c7927a3c
NC		 7822 }
7823 break;
7824 }
7825 break;
7826 case 0x35:
7827 GETBYTE ();
7828 switch (op[2] & 0x00)
7829 {
7830 case 0x00:
a117b0a5 7831 goto op_semantics_55;
c7927a3c
NC		 7832 break;
7833 }
7834 break;
7835 case 0x36:
7836 GETBYTE ();
7837 switch (op[2] & 0x00)
7838 {
7839 case 0x00:
a117b0a5 7840 goto op_semantics_55;
c7927a3c
NC		 7841 break;
7842 }
7843 break;
7844 case 0x37:
7845 GETBYTE ();
7846 switch (op[2] & 0x00)
7847 {
7848 case 0x00:
a117b0a5 7849 goto op_semantics_55;
c7927a3c
NC		 7850 break;
7851 }
7852 break;
7853 case 0x3b:
7854 GETBYTE ();
7855 switch (op[2] & 0x00)
7856 {
7857 case 0x00:
7858 {
7859 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
e197589b 7860#line 465 "rx-decode.opc"
c7927a3c 7861 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7862#line 465 "rx-decode.opc"
c7927a3c
NC		 7863 int rdst AU = op[2] & 0x0f;
7864 if (trace)
7865 {
7866 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7867 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7868 op[0], op[1], op[2]);
7869 printf (" rsrc = 0x%x,", rsrc);
7870 printf (" rdst = 0x%x\n", rdst);
7871 }
7872 SYNTAX("not %1, %0");
e197589b 7873#line 465 "rx-decode.opc"
3cf79a01 7874 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
43e65147 7875
c7927a3c
NC		 7876 /*----------------------------------------------------------------------*/
7877 /* TST */
43e65147 7878
c7927a3c
NC		 7879 }
7880 break;
7881 }
7882 break;
7883 case 0x40:
7884 GETBYTE ();
7885 switch (op[2] & 0x00)
7886 {
7887 case 0x00:
a117b0a5 7888 op_semantics_56:
c7927a3c
NC		 7889 {
7890 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
e197589b 7891#line 387 "rx-decode.opc"
c7927a3c 7892 int ss AU = op[1] & 0x03;
e197589b 7893#line 387 "rx-decode.opc"
c7927a3c 7894 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7895#line 387 "rx-decode.opc"
c7927a3c
NC		 7896 int rdst AU = op[2] & 0x0f;
7897 if (trace)
7898 {
7899 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7900 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7901 op[0], op[1], op[2]);
7902 printf (" ss = 0x%x,", ss);
7903 printf (" rsrc = 0x%x,", rsrc);
7904 printf (" rdst = 0x%x\n", rdst);
7905 }
7906 SYNTAX("xchg %1%S1, %0");
e197589b 7907#line 387 "rx-decode.opc"
c7927a3c 7908 ID(xchg); DR(rdst); SP(ss, rsrc);
43e65147 7909
c7927a3c
NC		 7910 }
7911 break;
7912 }
7913 break;
7914 case 0x41:
7915 GETBYTE ();
7916 switch (op[2] & 0x00)
7917 {
7918 case 0x00:
a117b0a5 7919 goto op_semantics_56;
c7927a3c
NC		 7920 break;
7921 }
7922 break;
7923 case 0x42:
7924 GETBYTE ();
7925 switch (op[2] & 0x00)
7926 {
7927 case 0x00:
a117b0a5 7928 goto op_semantics_56;
c7927a3c
NC		 7929 break;
7930 }
7931 break;
7932 case 0x43:
7933 GETBYTE ();
7934 switch (op[2] & 0x00)
7935 {
7936 case 0x00:
a117b0a5 7937 goto op_semantics_56;
c7927a3c
NC		 7938 break;
7939 }
7940 break;
7941 case 0x44:
7942 GETBYTE ();
7943 switch (op[2] & 0x00)
7944 {
7945 case 0x00:
a117b0a5 7946 op_semantics_57:
c7927a3c
NC		 7947 {
7948 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
e197589b 7949#line 930 "rx-decode.opc"
c7927a3c 7950 int sd AU = op[1] & 0x03;
e197589b 7951#line 930 "rx-decode.opc"
c7927a3c 7952 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 7953#line 930 "rx-decode.opc"
c7927a3c
NC		 7954 int rdst AU = op[2] & 0x0f;
7955 if (trace)
7956 {
7957 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7958 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7959 op[0], op[1], op[2]);
7960 printf (" sd = 0x%x,", sd);
7961 printf (" rsrc = 0x%x,", rsrc);
7962 printf (" rdst = 0x%x\n", rdst);
7963 }
7964 SYNTAX("itof %1%S1, %0");
e197589b 7965#line 930 "rx-decode.opc"
3cf79a01 7966 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
43e65147 7967
c7927a3c
NC		 7968 }
7969 break;
7970 }
7971 break;
7972 case 0x45:
7973 GETBYTE ();
7974 switch (op[2] & 0x00)
7975 {
7976 case 0x00:
a117b0a5 7977 goto op_semantics_57;
c7927a3c
NC		 7978 break;
7979 }
7980 break;
7981 case 0x46:
7982 GETBYTE ();
7983 switch (op[2] & 0x00)
7984 {
7985 case 0x00:
a117b0a5 7986 goto op_semantics_57;
c7927a3c
NC		 7987 break;
7988 }
7989 break;
7990 case 0x47:
7991 GETBYTE ();
7992 switch (op[2] & 0x00)
7993 {
7994 case 0x00:
a117b0a5 7995 goto op_semantics_57;
c7927a3c
NC		 7996 break;
7997 }
7998 break;
a117b0a5 7999 case 0x4b:
c7927a3c
NC		 8000 GETBYTE ();
8001 switch (op[2] & 0x00)
8002 {
8003 case 0x00:
c7927a3c 8004 {
a117b0a5 8005 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
e197589b 8006#line 1056 "rx-decode.opc"
a117b0a5 8007 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8008#line 1056 "rx-decode.opc"
a117b0a5 8009 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 8010 if (trace)
8011 {
8012 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8013 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
c7927a3c 8014 op[0], op[1], op[2]);
a117b0a5
YS		 8015 printf (" rsrc = 0x%x,", rsrc);
8016 printf (" rdst = 0x%x\n", rdst);
c7927a3c 8017 }
a117b0a5 8018 SYNTAX("stz %1, %0");
e197589b 8019#line 1056 "rx-decode.opc"
a117b0a5 8020 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
43e65147 8021
c7927a3c
NC		 8022 }
8023 break;
8024 }
8025 break;
a117b0a5 8026 case 0x4f:
c7927a3c
NC		 8027 GETBYTE ();
8028 switch (op[2] & 0x00)
8029 {
8030 case 0x00:
a117b0a5
YS		 8031 {
8032 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
e197589b 8033#line 1059 "rx-decode.opc"
a117b0a5 8034 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8035#line 1059 "rx-decode.opc"
a117b0a5
YS		 8036 int rdst AU = op[2] & 0x0f;
8037 if (trace)
8038 {
8039 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8040 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
8041 op[0], op[1], op[2]);
8042 printf (" rsrc = 0x%x,", rsrc);
8043 printf (" rdst = 0x%x\n", rdst);
8044 }
8045 SYNTAX("stnz %1, %0");
e197589b 8046#line 1059 "rx-decode.opc"
239efab1 8047 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
a117b0a5
YS		 8048
8049 }
c7927a3c
NC		 8050 break;
8051 }
8052 break;
a117b0a5 8053 case 0x54:
c7927a3c
NC		 8054 GETBYTE ();
8055 switch (op[2] & 0x00)
8056 {
8057 case 0x00:
8058 op_semantics_58:
8059 {
a117b0a5 8060 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
e197589b 8061#line 1116 "rx-decode.opc"
c7927a3c 8062 int sd AU = op[1] & 0x03;
e197589b 8063#line 1116 "rx-decode.opc"
a117b0a5 8064 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8065#line 1116 "rx-decode.opc"
a117b0a5 8066 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 8067 if (trace)
8068 {
8069 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8070 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
c7927a3c
NC		 8071 op[0], op[1], op[2]);
8072 printf (" sd = 0x%x,", sd);
a117b0a5
YS		 8073 printf (" rsrc = 0x%x,", rsrc);
8074 printf (" rdst = 0x%x\n", rdst);
c7927a3c 8075 }
a117b0a5 8076 SYNTAX("utof %1%S1, %0");
e197589b 8077#line 1116 "rx-decode.opc"
a117b0a5 8078 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
43e65147 8079
c7927a3c
NC		 8080 }
8081 break;
8082 }
8083 break;
a117b0a5 8084 case 0x55:
c7927a3c
NC		 8085 GETBYTE ();
8086 switch (op[2] & 0x00)
8087 {
8088 case 0x00:
8089 goto op_semantics_58;
8090 break;
8091 }
8092 break;
a117b0a5 8093 case 0x56:
c7927a3c
NC		 8094 GETBYTE ();
8095 switch (op[2] & 0x00)
8096 {
8097 case 0x00:
8098 goto op_semantics_58;
8099 break;
8100 }
8101 break;
a117b0a5 8102 case 0x57:
c7927a3c
NC		 8103 GETBYTE ();
8104 switch (op[2] & 0x00)
8105 {
8106 case 0x00:
8107 goto op_semantics_58;
8108 break;
8109 }
8110 break;
a117b0a5 8111 case 0x60:
c7927a3c
NC		 8112 GETBYTE ();
8113 switch (op[2] & 0x00)
8114 {
8115 case 0x00:
8116 op_semantics_59:
8117 {
a117b0a5 8118 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
e197589b 8119#line 942 "rx-decode.opc"
c7927a3c 8120 int sd AU = op[1] & 0x03;
e197589b 8121#line 942 "rx-decode.opc"
c7927a3c 8122 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 8123#line 942 "rx-decode.opc"
c7927a3c
NC		 8124 int rsrc AU = op[2] & 0x0f;
8125 if (trace)
8126 {
8127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8128 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
c7927a3c
NC		 8129 op[0], op[1], op[2]);
8130 printf (" sd = 0x%x,", sd);
8131 printf (" rdst = 0x%x,", rdst);
8132 printf (" rsrc = 0x%x\n", rsrc);
8133 }
a117b0a5 8134 SYNTAX("bset %1, %0%S0");
e197589b 8135#line 942 "rx-decode.opc"
a117b0a5 8136 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
3531d549
DD		 8137 if (sd == 3) /* bset reg,reg */
8138 BWL(LSIZE);
43e65147 8139
c7927a3c
NC		 8140 }
8141 break;
8142 }
8143 break;
a117b0a5 8144 case 0x61:
c7927a3c
NC		 8145 GETBYTE ();
8146 switch (op[2] & 0x00)
8147 {
8148 case 0x00:
8149 goto op_semantics_59;
8150 break;
8151 }
8152 break;
a117b0a5 8153 case 0x62:
c7927a3c
NC		 8154 GETBYTE ();
8155 switch (op[2] & 0x00)
8156 {
8157 case 0x00:
8158 goto op_semantics_59;
8159 break;
8160 }
8161 break;
a117b0a5 8162 case 0x63:
c7927a3c
NC		 8163 GETBYTE ();
8164 switch (op[2] & 0x00)
8165 {
8166 case 0x00:
8167 goto op_semantics_59;
8168 break;
8169 }
8170 break;
a117b0a5 8171 case 0x64:
c7927a3c
NC		 8172 GETBYTE ();
8173 switch (op[2] & 0x00)
8174 {
8175 case 0x00:
8176 op_semantics_60:
a117b0a5
YS		 8177 {
8178 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
e197589b 8179#line 954 "rx-decode.opc"
a117b0a5 8180 int sd AU = op[1] & 0x03;
e197589b 8181#line 954 "rx-decode.opc"
a117b0a5 8182 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 8183#line 954 "rx-decode.opc"
a117b0a5
YS		 8184 int rsrc AU = op[2] & 0x0f;
8185 if (trace)
8186 {
8187 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8188 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
8189 op[0], op[1], op[2]);
8190 printf (" sd = 0x%x,", sd);
8191 printf (" rdst = 0x%x,", rdst);
8192 printf (" rsrc = 0x%x\n", rsrc);
8193 }
8194 SYNTAX("bclr %1, %0%S0");
e197589b 8195#line 954 "rx-decode.opc"
a117b0a5
YS		 8196 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8197 if (sd == 3) /* bset reg,reg */
8198 BWL(LSIZE);
8199
8200 }
8201 break;
8202 }
8203 break;
8204 case 0x65:
8205 GETBYTE ();
8206 switch (op[2] & 0x00)
8207 {
8208 case 0x00:
8209 goto op_semantics_60;
8210 break;
8211 }
8212 break;
8213 case 0x66:
8214 GETBYTE ();
8215 switch (op[2] & 0x00)
8216 {
8217 case 0x00:
8218 goto op_semantics_60;
8219 break;
8220 }
8221 break;
8222 case 0x67:
8223 GETBYTE ();
8224 switch (op[2] & 0x00)
8225 {
8226 case 0x00:
8227 goto op_semantics_60;
8228 break;
8229 }
8230 break;
8231 case 0x68:
8232 GETBYTE ();
8233 switch (op[2] & 0x00)
8234 {
8235 case 0x00:
8236 op_semantics_61:
8237 {
8238 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
e197589b 8239#line 966 "rx-decode.opc"
a117b0a5 8240 int sd AU = op[1] & 0x03;
e197589b 8241#line 966 "rx-decode.opc"
a117b0a5 8242 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 8243#line 966 "rx-decode.opc"
a117b0a5
YS		 8244 int rsrc AU = op[2] & 0x0f;
8245 if (trace)
8246 {
8247 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8248 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
8249 op[0], op[1], op[2]);
8250 printf (" sd = 0x%x,", sd);
8251 printf (" rdst = 0x%x,", rdst);
8252 printf (" rsrc = 0x%x\n", rsrc);
8253 }
8254 SYNTAX("btst %2, %1%S1");
e197589b 8255#line 966 "rx-decode.opc"
a117b0a5
YS		 8256 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8257 if (sd == 3) /* bset reg,reg */
8258 BWL(LSIZE);
8259
8260 }
8261 break;
8262 }
8263 break;
8264 case 0x69:
8265 GETBYTE ();
8266 switch (op[2] & 0x00)
8267 {
8268 case 0x00:
8269 goto op_semantics_61;
8270 break;
8271 }
8272 break;
8273 case 0x6a:
8274 GETBYTE ();
8275 switch (op[2] & 0x00)
8276 {
8277 case 0x00:
8278 goto op_semantics_61;
8279 break;
8280 }
8281 break;
8282 case 0x6b:
8283 GETBYTE ();
8284 switch (op[2] & 0x00)
8285 {
8286 case 0x00:
8287 goto op_semantics_61;
8288 break;
8289 }
8290 break;
8291 case 0x6c:
8292 GETBYTE ();
8293 switch (op[2] & 0x00)
8294 {
8295 case 0x00:
8296 op_semantics_62:
c7927a3c
NC		 8297 {
8298 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
e197589b 8299#line 978 "rx-decode.opc"
c7927a3c 8300 int sd AU = op[1] & 0x03;
e197589b 8301#line 978 "rx-decode.opc"
c7927a3c 8302 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 8303#line 978 "rx-decode.opc"
c7927a3c
NC		 8304 int rsrc AU = op[2] & 0x0f;
8305 if (trace)
8306 {
8307 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8308 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
8309 op[0], op[1], op[2]);
8310 printf (" sd = 0x%x,", sd);
8311 printf (" rdst = 0x%x,", rdst);
8312 printf (" rsrc = 0x%x\n", rsrc);
8313 }
8314 SYNTAX("bnot %1, %0%S0");
e197589b 8315#line 978 "rx-decode.opc"
c7927a3c 8316 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
3531d549
DD		 8317 if (sd == 3) /* bset reg,reg */
8318 BWL(LSIZE);
43e65147 8319
c7927a3c
NC		 8320 }
8321 break;
8322 }
8323 break;
8324 case 0x6d:
8325 GETBYTE ();
8326 switch (op[2] & 0x00)
8327 {
8328 case 0x00:
a117b0a5 8329 goto op_semantics_62;
c7927a3c
NC		 8330 break;
8331 }
8332 break;
8333 case 0x6e:
8334 GETBYTE ();
8335 switch (op[2] & 0x00)
8336 {
8337 case 0x00:
a117b0a5 8338 goto op_semantics_62;
c7927a3c
NC		 8339 break;
8340 }
8341 break;
8342 case 0x6f:
8343 GETBYTE ();
8344 switch (op[2] & 0x00)
8345 {
8346 case 0x00:
a117b0a5 8347 goto op_semantics_62;
c7927a3c
NC		 8348 break;
8349 }
8350 break;
8351 case 0x80:
8352 GETBYTE ();
8353 switch (op[2] & 0x00)
8354 {
8355 case 0x00:
a117b0a5 8356 op_semantics_63:
c7927a3c
NC		 8357 {
8358 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
e197589b 8359#line 909 "rx-decode.opc"
c7927a3c 8360 int sd AU = op[1] & 0x03;
e197589b 8361#line 909 "rx-decode.opc"
c7927a3c 8362 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8363#line 909 "rx-decode.opc"
c7927a3c
NC		 8364 int rdst AU = op[2] & 0x0f;
8365 if (trace)
8366 {
8367 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8368 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8369 op[0], op[1], op[2]);
8370 printf (" sd = 0x%x,", sd);
8371 printf (" rsrc = 0x%x,", rsrc);
8372 printf (" rdst = 0x%x\n", rdst);
8373 }
8374 SYNTAX("fsub %1%S1, %0");
e197589b 8375#line 909 "rx-decode.opc"
3cf79a01 8376 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8377
c7927a3c
NC		 8378 }
8379 break;
8380 }
8381 break;
8382 case 0x81:
8383 GETBYTE ();
8384 switch (op[2] & 0x00)
8385 {
8386 case 0x00:
a117b0a5 8387 goto op_semantics_63;
c7927a3c
NC		 8388 break;
8389 }
8390 break;
8391 case 0x82:
8392 GETBYTE ();
8393 switch (op[2] & 0x00)
8394 {
8395 case 0x00:
a117b0a5 8396 goto op_semantics_63;
c7927a3c
NC		 8397 break;
8398 }
8399 break;
8400 case 0x83:
8401 GETBYTE ();
8402 switch (op[2] & 0x00)
8403 {
8404 case 0x00:
a117b0a5 8405 goto op_semantics_63;
c7927a3c
NC		 8406 break;
8407 }
8408 break;
8409 case 0x84:
8410 GETBYTE ();
8411 switch (op[2] & 0x00)
8412 {
8413 case 0x00:
a117b0a5 8414 op_semantics_64:
c7927a3c
NC		 8415 {
8416 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
e197589b 8417#line 903 "rx-decode.opc"
c7927a3c 8418 int sd AU = op[1] & 0x03;
e197589b 8419#line 903 "rx-decode.opc"
c7927a3c 8420 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8421#line 903 "rx-decode.opc"
c7927a3c
NC		 8422 int rdst AU = op[2] & 0x0f;
8423 if (trace)
8424 {
8425 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8426 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8427 op[0], op[1], op[2]);
8428 printf (" sd = 0x%x,", sd);
8429 printf (" rsrc = 0x%x,", rsrc);
8430 printf (" rdst = 0x%x\n", rdst);
8431 }
8432 SYNTAX("fcmp %1%S1, %0");
e197589b 8433#line 903 "rx-decode.opc"
3cf79a01 8434 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
43e65147 8435
c7927a3c
NC		 8436 }
8437 break;
8438 }
8439 break;
8440 case 0x85:
8441 GETBYTE ();
8442 switch (op[2] & 0x00)
8443 {
8444 case 0x00:
a117b0a5 8445 goto op_semantics_64;
c7927a3c
NC		 8446 break;
8447 }
8448 break;
8449 case 0x86:
8450 GETBYTE ();
8451 switch (op[2] & 0x00)
8452 {
8453 case 0x00:
a117b0a5 8454 goto op_semantics_64;
c7927a3c
NC		 8455 break;
8456 }
8457 break;
8458 case 0x87:
8459 GETBYTE ();
8460 switch (op[2] & 0x00)
8461 {
8462 case 0x00:
a117b0a5 8463 goto op_semantics_64;
c7927a3c
NC		 8464 break;
8465 }
8466 break;
8467 case 0x88:
8468 GETBYTE ();
8469 switch (op[2] & 0x00)
8470 {
8471 case 0x00:
a117b0a5 8472 op_semantics_65:
c7927a3c
NC		 8473 {
8474 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
e197589b 8475#line 897 "rx-decode.opc"
c7927a3c 8476 int sd AU = op[1] & 0x03;
e197589b 8477#line 897 "rx-decode.opc"
c7927a3c 8478 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8479#line 897 "rx-decode.opc"
c7927a3c
NC		 8480 int rdst AU = op[2] & 0x0f;
8481 if (trace)
8482 {
8483 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8484 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8485 op[0], op[1], op[2]);
8486 printf (" sd = 0x%x,", sd);
8487 printf (" rsrc = 0x%x,", rsrc);
8488 printf (" rdst = 0x%x\n", rdst);
8489 }
8490 SYNTAX("fadd %1%S1, %0");
e197589b 8491#line 897 "rx-decode.opc"
3cf79a01 8492 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8493
c7927a3c
NC		 8494 }
8495 break;
8496 }
8497 break;
8498 case 0x89:
8499 GETBYTE ();
8500 switch (op[2] & 0x00)
8501 {
8502 case 0x00:
a117b0a5 8503 goto op_semantics_65;
c7927a3c
NC		 8504 break;
8505 }
8506 break;
8507 case 0x8a:
8508 GETBYTE ();
8509 switch (op[2] & 0x00)
8510 {
8511 case 0x00:
a117b0a5 8512 goto op_semantics_65;
c7927a3c
NC		 8513 break;
8514 }
8515 break;
8516 case 0x8b:
8517 GETBYTE ();
8518 switch (op[2] & 0x00)
8519 {
8520 case 0x00:
a117b0a5 8521 goto op_semantics_65;
c7927a3c
NC		 8522 break;
8523 }
8524 break;
8525 case 0x8c:
8526 GETBYTE ();
8527 switch (op[2] & 0x00)
8528 {
8529 case 0x00:
a117b0a5 8530 op_semantics_66:
c7927a3c
NC		 8531 {
8532 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
e197589b 8533#line 918 "rx-decode.opc"
c7927a3c 8534 int sd AU = op[1] & 0x03;
e197589b 8535#line 918 "rx-decode.opc"
c7927a3c 8536 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8537#line 918 "rx-decode.opc"
c7927a3c
NC		 8538 int rdst AU = op[2] & 0x0f;
8539 if (trace)
8540 {
8541 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8542 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8543 op[0], op[1], op[2]);
8544 printf (" sd = 0x%x,", sd);
8545 printf (" rsrc = 0x%x,", rsrc);
8546 printf (" rdst = 0x%x\n", rdst);
8547 }
8548 SYNTAX("fmul %1%S1, %0");
e197589b 8549#line 918 "rx-decode.opc"
3cf79a01 8550 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8551
c7927a3c
NC		 8552 }
8553 break;
8554 }
8555 break;
8556 case 0x8d:
8557 GETBYTE ();
8558 switch (op[2] & 0x00)
8559 {
8560 case 0x00:
a117b0a5 8561 goto op_semantics_66;
c7927a3c
NC		 8562 break;
8563 }
8564 break;
8565 case 0x8e:
8566 GETBYTE ();
8567 switch (op[2] & 0x00)
8568 {
8569 case 0x00:
a117b0a5 8570 goto op_semantics_66;
c7927a3c
NC		 8571 break;
8572 }
8573 break;
8574 case 0x8f:
8575 GETBYTE ();
8576 switch (op[2] & 0x00)
8577 {
8578 case 0x00:
a117b0a5 8579 goto op_semantics_66;
c7927a3c
NC		 8580 break;
8581 }
8582 break;
8583 case 0x90:
8584 GETBYTE ();
8585 switch (op[2] & 0x00)
8586 {
8587 case 0x00:
a117b0a5 8588 op_semantics_67:
c7927a3c
NC		 8589 {
8590 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
e197589b 8591#line 924 "rx-decode.opc"
c7927a3c 8592 int sd AU = op[1] & 0x03;
e197589b 8593#line 924 "rx-decode.opc"
c7927a3c 8594 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8595#line 924 "rx-decode.opc"
c7927a3c
NC		 8596 int rdst AU = op[2] & 0x0f;
8597 if (trace)
8598 {
8599 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8600 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8601 op[0], op[1], op[2]);
8602 printf (" sd = 0x%x,", sd);
8603 printf (" rsrc = 0x%x,", rsrc);
8604 printf (" rdst = 0x%x\n", rdst);
8605 }
8606 SYNTAX("fdiv %1%S1, %0");
e197589b 8607#line 924 "rx-decode.opc"
3cf79a01 8608 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8609
c7927a3c
NC		 8610 }
8611 break;
8612 }
8613 break;
8614 case 0x91:
8615 GETBYTE ();
8616 switch (op[2] & 0x00)
8617 {
8618 case 0x00:
a117b0a5 8619 goto op_semantics_67;
c7927a3c
NC		 8620 break;
8621 }
8622 break;
8623 case 0x92:
8624 GETBYTE ();
8625 switch (op[2] & 0x00)
8626 {
8627 case 0x00:
a117b0a5 8628 goto op_semantics_67;
c7927a3c
NC		 8629 break;
8630 }
8631 break;
8632 case 0x93:
8633 GETBYTE ();
8634 switch (op[2] & 0x00)
8635 {
8636 case 0x00:
a117b0a5 8637 goto op_semantics_67;
c7927a3c
NC		 8638 break;
8639 }
8640 break;
8641 case 0x94:
8642 GETBYTE ();
8643 switch (op[2] & 0x00)
8644 {
8645 case 0x00:
a117b0a5 8646 op_semantics_68:
c7927a3c
NC		 8647 {
8648 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
e197589b 8649#line 912 "rx-decode.opc"
c7927a3c 8650 int sd AU = op[1] & 0x03;
e197589b 8651#line 912 "rx-decode.opc"
c7927a3c 8652 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8653#line 912 "rx-decode.opc"
c7927a3c
NC		 8654 int rdst AU = op[2] & 0x0f;
8655 if (trace)
8656 {
8657 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8658 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8659 op[0], op[1], op[2]);
8660 printf (" sd = 0x%x,", sd);
8661 printf (" rsrc = 0x%x,", rsrc);
8662 printf (" rdst = 0x%x\n", rdst);
8663 }
8664 SYNTAX("ftoi %1%S1, %0");
e197589b 8665#line 912 "rx-decode.opc"
3cf79a01 8666 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8667
c7927a3c
NC		 8668 }
8669 break;
8670 }
8671 break;
8672 case 0x95:
8673 GETBYTE ();
8674 switch (op[2] & 0x00)
8675 {
8676 case 0x00:
a117b0a5 8677 goto op_semantics_68;
c7927a3c
NC		 8678 break;
8679 }
8680 break;
8681 case 0x96:
8682 GETBYTE ();
8683 switch (op[2] & 0x00)
8684 {
8685 case 0x00:
a117b0a5 8686 goto op_semantics_68;
c7927a3c
NC		 8687 break;
8688 }
8689 break;
8690 case 0x97:
8691 GETBYTE ();
8692 switch (op[2] & 0x00)
8693 {
8694 case 0x00:
a117b0a5 8695 goto op_semantics_68;
c7927a3c
NC		 8696 break;
8697 }
8698 break;
8699 case 0x98:
8700 GETBYTE ();
8701 switch (op[2] & 0x00)
8702 {
8703 case 0x00:
a117b0a5 8704 op_semantics_69:
c7927a3c
NC		 8705 {
8706 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
e197589b 8707#line 927 "rx-decode.opc"
c7927a3c 8708 int sd AU = op[1] & 0x03;
e197589b 8709#line 927 "rx-decode.opc"
c7927a3c 8710 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8711#line 927 "rx-decode.opc"
c7927a3c
NC		 8712 int rdst AU = op[2] & 0x0f;
8713 if (trace)
8714 {
8715 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8716 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8717 op[0], op[1], op[2]);
8718 printf (" sd = 0x%x,", sd);
8719 printf (" rsrc = 0x%x,", rsrc);
8720 printf (" rdst = 0x%x\n", rdst);
8721 }
8722 SYNTAX("round %1%S1, %0");
e197589b 8723#line 927 "rx-decode.opc"
3cf79a01 8724 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8725
c7927a3c
NC		 8726 }
8727 break;
8728 }
8729 break;
8730 case 0x99:
8731 GETBYTE ();
8732 switch (op[2] & 0x00)
8733 {
8734 case 0x00:
a117b0a5 8735 goto op_semantics_69;
c7927a3c
NC		 8736 break;
8737 }
8738 break;
8739 case 0x9a:
8740 GETBYTE ();
8741 switch (op[2] & 0x00)
8742 {
8743 case 0x00:
a117b0a5 8744 goto op_semantics_69;
c7927a3c
NC		 8745 break;
8746 }
8747 break;
8748 case 0x9b:
8749 GETBYTE ();
8750 switch (op[2] & 0x00)
8751 {
8752 case 0x00:
a117b0a5 8753 goto op_semantics_69;
c7927a3c
NC		 8754 break;
8755 }
8756 break;
a117b0a5 8757 case 0xa0:
c7927a3c
NC		 8758 GETBYTE ();
8759 switch (op[2] & 0x00)
8760 {
8761 case 0x00:
a117b0a5 8762 op_semantics_70:
c7927a3c 8763 {
a117b0a5 8764 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
e197589b 8765#line 1110 "rx-decode.opc"
c7927a3c 8766 int sd AU = op[1] & 0x03;
e197589b 8767#line 1110 "rx-decode.opc"
a117b0a5 8768 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8769#line 1110 "rx-decode.opc"
a117b0a5 8770 int rdst AU = op[2] & 0x0f;
c7927a3c
NC		 8771 if (trace)
8772 {
8773 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 8774 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
c7927a3c 8775 op[0], op[1], op[2]);
c7927a3c 8776 printf (" sd = 0x%x,", sd);
a117b0a5
YS		 8777 printf (" rsrc = 0x%x,", rsrc);
8778 printf (" rdst = 0x%x\n", rdst);
c7927a3c 8779 }
a117b0a5 8780 SYNTAX("fsqrt %1%S1, %0");
e197589b 8781#line 1110 "rx-decode.opc"
a117b0a5 8782 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
43e65147 8783
c7927a3c
NC		 8784 }
8785 break;
8786 }
8787 break;
a117b0a5 8788 case 0xa1:
c7927a3c
NC		 8789 GETBYTE ();
8790 switch (op[2] & 0x00)
8791 {
8792 case 0x00:
a117b0a5 8793 goto op_semantics_70;
c7927a3c
NC		 8794 break;
8795 }
8796 break;
a117b0a5 8797 case 0xa2:
c7927a3c
NC		 8798 GETBYTE ();
8799 switch (op[2] & 0x00)
8800 {
8801 case 0x00:
a117b0a5 8802 goto op_semantics_70;
c7927a3c
NC		 8803 break;
8804 }
8805 break;
a117b0a5 8806 case 0xa3:
c7927a3c
NC		 8807 GETBYTE ();
8808 switch (op[2] & 0x00)
8809 {
8810 case 0x00:
a117b0a5 8811 goto op_semantics_70;
c7927a3c
NC		 8812 break;
8813 }
8814 break;
a117b0a5 8815 case 0xa4:
c7927a3c
NC		 8816 GETBYTE ();
8817 switch (op[2] & 0x00)
8818 {
8819 case 0x00:
a117b0a5
YS		 8820 op_semantics_71:
8821 {
8822 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
e197589b 8823#line 1113 "rx-decode.opc"
a117b0a5 8824 int sd AU = op[1] & 0x03;
e197589b 8825#line 1113 "rx-decode.opc"
a117b0a5 8826 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 8827#line 1113 "rx-decode.opc"
a117b0a5
YS		 8828 int rdst AU = op[2] & 0x0f;
8829 if (trace)
8830 {
8831 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8832 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
8833 op[0], op[1], op[2]);
8834 printf (" sd = 0x%x,", sd);
8835 printf (" rsrc = 0x%x,", rsrc);
8836 printf (" rdst = 0x%x\n", rdst);
8837 }
8838 SYNTAX("ftou %1%S1, %0");
e197589b 8839#line 1113 "rx-decode.opc"
a117b0a5
YS		 8840 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8841
8842 }
c7927a3c
NC		 8843 break;
8844 }
8845 break;
a117b0a5 8846 case 0xa5:
c7927a3c
NC		 8847 GETBYTE ();
8848 switch (op[2] & 0x00)
8849 {
8850 case 0x00:
a117b0a5 8851 goto op_semantics_71;
c7927a3c
NC		 8852 break;
8853 }
8854 break;
a117b0a5 8855 case 0xa6:
c7927a3c
NC		 8856 GETBYTE ();
8857 switch (op[2] & 0x00)
8858 {
8859 case 0x00:
a117b0a5 8860 goto op_semantics_71;
c7927a3c
NC		 8861 break;
8862 }
8863 break;
a117b0a5 8864 case 0xa7:
c7927a3c
NC		 8865 GETBYTE ();
8866 switch (op[2] & 0x00)
8867 {
8868 case 0x00:
a117b0a5 8869 goto op_semantics_71;
c7927a3c
NC		 8870 break;
8871 }
8872 break;
a117b0a5 8873 case 0xd0:
c7927a3c
NC		 8874 GETBYTE ();
8875 switch (op[2] & 0x00)
8876 {
8877 case 0x00:
a117b0a5
YS		 8878 op_semantics_72:
8879 {
8880 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
e197589b 8881#line 1044 "rx-decode.opc"
a117b0a5 8882 int sz AU = (op[1] >> 2) & 0x03;
e197589b 8883#line 1044 "rx-decode.opc"
a117b0a5 8884 int sd AU = op[1] & 0x03;
e197589b 8885#line 1044 "rx-decode.opc"
a117b0a5 8886 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 8887#line 1044 "rx-decode.opc"
a117b0a5
YS		 8888 int cond AU = op[2] & 0x0f;
8889 if (trace)
8890 {
8891 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8892 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8893 op[0], op[1], op[2]);
8894 printf (" sz = 0x%x,", sz);
8895 printf (" sd = 0x%x,", sd);
8896 printf (" rdst = 0x%x,", rdst);
8897 printf (" cond = 0x%x\n", cond);
8898 }
8899 SYNTAX("sc%1%s %0");
e197589b 8900#line 1044 "rx-decode.opc"
a117b0a5
YS		 8901 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8902
8903 /*----------------------------------------------------------------------*/
8904 /* RXv2 enhanced */
8905
8906 }
8907 break;
8908 }
8909 break;
8910 case 0xd1:
8911 GETBYTE ();
c7927a3c
NC		 8912 switch (op[2] & 0x00)
8913 {
8914 case 0x00:
a117b0a5
YS		 8915 goto op_semantics_72;
8916 break;
8917 }
8918 break;
8919 case 0xd2:
8920 GETBYTE ();
8921 switch (op[2] & 0x00)
8922 {
8923 case 0x00:
8924 goto op_semantics_72;
8925 break;
8926 }
8927 break;
8928 case 0xd3:
8929 GETBYTE ();
8930 switch (op[2] & 0x00)
8931 {
8932 case 0x00:
8933 goto op_semantics_72;
8934 break;
8935 }
8936 break;
8937 case 0xd4:
8938 GETBYTE ();
8939 switch (op[2] & 0x00)
8940 {
8941 case 0x00:
8942 goto op_semantics_72;
8943 break;
8944 }
8945 break;
8946 case 0xd5:
8947 GETBYTE ();
8948 switch (op[2] & 0x00)
8949 {
8950 case 0x00:
8951 goto op_semantics_72;
8952 break;
8953 }
8954 break;
8955 case 0xd6:
8956 GETBYTE ();
8957 switch (op[2] & 0x00)
8958 {
8959 case 0x00:
8960 goto op_semantics_72;
8961 break;
8962 }
8963 break;
8964 case 0xd7:
8965 GETBYTE ();
8966 switch (op[2] & 0x00)
8967 {
8968 case 0x00:
8969 goto op_semantics_72;
8970 break;
8971 }
8972 break;
8973 case 0xd8:
8974 GETBYTE ();
8975 switch (op[2] & 0x00)
8976 {
8977 case 0x00:
8978 goto op_semantics_72;
8979 break;
8980 }
8981 break;
8982 case 0xd9:
8983 GETBYTE ();
8984 switch (op[2] & 0x00)
8985 {
8986 case 0x00:
8987 goto op_semantics_72;
8988 break;
8989 }
8990 break;
8991 case 0xda:
8992 GETBYTE ();
8993 switch (op[2] & 0x00)
8994 {
8995 case 0x00:
8996 goto op_semantics_72;
c7927a3c
NC		 8997 break;
8998 }
8999 break;
9000 case 0xdb:
9001 GETBYTE ();
9002 switch (op[2] & 0x00)
9003 {
9004 case 0x00:
a117b0a5 9005 goto op_semantics_72;
c7927a3c
NC		 9006 break;
9007 }
9008 break;
9009 case 0xe0:
9010 GETBYTE ();
9011 switch (op[2] & 0x0f)
9012 {
9013 case 0x00:
9014 case 0x01:
9015 case 0x02:
9016 case 0x03:
9017 case 0x04:
9018 case 0x05:
9019 case 0x06:
9020 case 0x07:
9021 case 0x08:
9022 case 0x09:
9023 case 0x0a:
9024 case 0x0b:
9025 case 0x0c:
9026 case 0x0d:
9027 case 0x0e:
a117b0a5 9028 op_semantics_73:
c7927a3c
NC		 9029 {
9030 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
e197589b 9031#line 987 "rx-decode.opc"
c7927a3c 9032 int bit AU = (op[1] >> 2) & 0x07;
e197589b 9033#line 987 "rx-decode.opc"
c7927a3c 9034 int sd AU = op[1] & 0x03;
e197589b 9035#line 987 "rx-decode.opc"
c7927a3c 9036 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 9037#line 987 "rx-decode.opc"
c7927a3c
NC		 9038 int cond AU = op[2] & 0x0f;
9039 if (trace)
9040 {
9041 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9042 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
9043 op[0], op[1], op[2]);
9044 printf (" bit = 0x%x,", bit);
9045 printf (" sd = 0x%x,", sd);
9046 printf (" rdst = 0x%x,", rdst);
9047 printf (" cond = 0x%x\n", cond);
9048 }
9049 SYNTAX("bm%2 #%1, %0%S0");
e197589b 9050#line 987 "rx-decode.opc"
c7927a3c 9051 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
43e65147 9052
c7927a3c
NC		 9053 }
9054 break;
9055 case 0x0f:
a117b0a5 9056 op_semantics_74:
c7927a3c
NC		 9057 {
9058 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
e197589b 9059#line 975 "rx-decode.opc"
c7927a3c 9060 int bit AU = (op[1] >> 2) & 0x07;
e197589b 9061#line 975 "rx-decode.opc"
c7927a3c 9062 int sd AU = op[1] & 0x03;
e197589b 9063#line 975 "rx-decode.opc"
c7927a3c
NC		 9064 int rdst AU = (op[2] >> 4) & 0x0f;
9065 if (trace)
9066 {
9067 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9068 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
9069 op[0], op[1], op[2]);
9070 printf (" bit = 0x%x,", bit);
9071 printf (" sd = 0x%x,", sd);
9072 printf (" rdst = 0x%x\n", rdst);
9073 }
9074 SYNTAX("bnot #%1, %0%S0");
e197589b 9075#line 975 "rx-decode.opc"
c7927a3c 9076 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
43e65147 9077
c7927a3c
NC		 9078 }
9079 break;
9080 }
9081 break;
9082 case 0xe1:
9083 GETBYTE ();
9084 switch (op[2] & 0x0f)
9085 {
9086 case 0x00:
9087 case 0x01:
9088 case 0x02:
9089 case 0x03:
9090 case 0x04:
9091 case 0x05:
9092 case 0x06:
9093 case 0x07:
9094 case 0x08:
9095 case 0x09:
9096 case 0x0a:
9097 case 0x0b:
9098 case 0x0c:
9099 case 0x0d:
9100 case 0x0e:
a117b0a5 9101 goto op_semantics_73;
c7927a3c
NC		 9102 break;
9103 case 0x0f:
a117b0a5 9104 goto op_semantics_74;
c7927a3c
NC		 9105 break;
9106 }
9107 break;
9108 case 0xe2:
9109 GETBYTE ();
9110 switch (op[2] & 0x0f)
9111 {
9112 case 0x00:
9113 case 0x01:
9114 case 0x02:
9115 case 0x03:
9116 case 0x04:
9117 case 0x05:
9118 case 0x06:
9119 case 0x07:
9120 case 0x08:
9121 case 0x09:
9122 case 0x0a:
9123 case 0x0b:
9124 case 0x0c:
9125 case 0x0d:
9126 case 0x0e:
a117b0a5 9127 goto op_semantics_73;
c7927a3c
NC		 9128 break;
9129 case 0x0f:
a117b0a5 9130 goto op_semantics_74;
c7927a3c
NC		 9131 break;
9132 }
9133 break;
9134 case 0xe3:
9135 GETBYTE ();
9136 switch (op[2] & 0x0f)
9137 {
9138 case 0x00:
9139 case 0x01:
9140 case 0x02:
9141 case 0x03:
9142 case 0x04:
9143 case 0x05:
9144 case 0x06:
9145 case 0x07:
9146 case 0x08:
9147 case 0x09:
9148 case 0x0a:
9149 case 0x0b:
9150 case 0x0c:
9151 case 0x0d:
9152 case 0x0e:
a117b0a5 9153 goto op_semantics_73;
c7927a3c
NC		 9154 break;
9155 case 0x0f:
a117b0a5 9156 goto op_semantics_74;
c7927a3c
NC		 9157 break;
9158 }
9159 break;
9160 case 0xe4:
9161 GETBYTE ();
9162 switch (op[2] & 0x0f)
9163 {
9164 case 0x00:
9165 case 0x01:
9166 case 0x02:
9167 case 0x03:
9168 case 0x04:
9169 case 0x05:
9170 case 0x06:
9171 case 0x07:
9172 case 0x08:
9173 case 0x09:
9174 case 0x0a:
9175 case 0x0b:
9176 case 0x0c:
9177 case 0x0d:
9178 case 0x0e:
a117b0a5 9179 goto op_semantics_73;
c7927a3c
NC		 9180 break;
9181 case 0x0f:
a117b0a5 9182 goto op_semantics_74;
c7927a3c
NC		 9183 break;
9184 }
9185 break;
9186 case 0xe5:
9187 GETBYTE ();
9188 switch (op[2] & 0x0f)
9189 {
9190 case 0x00:
9191 case 0x01:
9192 case 0x02:
9193 case 0x03:
9194 case 0x04:
9195 case 0x05:
9196 case 0x06:
9197 case 0x07:
9198 case 0x08:
9199 case 0x09:
9200 case 0x0a:
9201 case 0x0b:
9202 case 0x0c:
9203 case 0x0d:
9204 case 0x0e:
a117b0a5 9205 goto op_semantics_73;
c7927a3c
NC		 9206 break;
9207 case 0x0f:
a117b0a5 9208 goto op_semantics_74;
c7927a3c
NC		 9209 break;
9210 }
9211 break;
9212 case 0xe6:
9213 GETBYTE ();
9214 switch (op[2] & 0x0f)
9215 {
9216 case 0x00:
9217 case 0x01:
9218 case 0x02:
9219 case 0x03:
9220 case 0x04:
9221 case 0x05:
9222 case 0x06:
9223 case 0x07:
9224 case 0x08:
9225 case 0x09:
9226 case 0x0a:
9227 case 0x0b:
9228 case 0x0c:
9229 case 0x0d:
9230 case 0x0e:
a117b0a5 9231 goto op_semantics_73;
c7927a3c
NC		 9232 break;
9233 case 0x0f:
a117b0a5 9234 goto op_semantics_74;
c7927a3c
NC		 9235 break;
9236 }
9237 break;
9238 case 0xe7:
9239 GETBYTE ();
9240 switch (op[2] & 0x0f)
9241 {
9242 case 0x00:
9243 case 0x01:
9244 case 0x02:
9245 case 0x03:
9246 case 0x04:
9247 case 0x05:
9248 case 0x06:
9249 case 0x07:
9250 case 0x08:
9251 case 0x09:
9252 case 0x0a:
9253 case 0x0b:
9254 case 0x0c:
9255 case 0x0d:
9256 case 0x0e:
a117b0a5 9257 goto op_semantics_73;
c7927a3c
NC		 9258 break;
9259 case 0x0f:
a117b0a5 9260 goto op_semantics_74;
c7927a3c
NC		 9261 break;
9262 }
9263 break;
9264 case 0xe8:
9265 GETBYTE ();
9266 switch (op[2] & 0x0f)
9267 {
9268 case 0x00:
9269 case 0x01:
9270 case 0x02:
9271 case 0x03:
9272 case 0x04:
9273 case 0x05:
9274 case 0x06:
9275 case 0x07:
9276 case 0x08:
9277 case 0x09:
9278 case 0x0a:
9279 case 0x0b:
9280 case 0x0c:
9281 case 0x0d:
9282 case 0x0e:
a117b0a5 9283 goto op_semantics_73;
c7927a3c
NC		 9284 break;
9285 case 0x0f:
a117b0a5 9286 goto op_semantics_74;
c7927a3c
NC		 9287 break;
9288 }
9289 break;
9290 case 0xe9:
9291 GETBYTE ();
9292 switch (op[2] & 0x0f)
9293 {
9294 case 0x00:
9295 case 0x01:
9296 case 0x02:
9297 case 0x03:
9298 case 0x04:
9299 case 0x05:
9300 case 0x06:
9301 case 0x07:
9302 case 0x08:
9303 case 0x09:
9304 case 0x0a:
9305 case 0x0b:
9306 case 0x0c:
9307 case 0x0d:
9308 case 0x0e:
a117b0a5 9309 goto op_semantics_73;
c7927a3c
NC		 9310 break;
9311 case 0x0f:
a117b0a5 9312 goto op_semantics_74;
c7927a3c
NC		 9313 break;
9314 }
9315 break;
9316 case 0xea:
9317 GETBYTE ();
9318 switch (op[2] & 0x0f)
9319 {
9320 case 0x00:
9321 case 0x01:
9322 case 0x02:
9323 case 0x03:
9324 case 0x04:
9325 case 0x05:
9326 case 0x06:
9327 case 0x07:
9328 case 0x08:
9329 case 0x09:
9330 case 0x0a:
9331 case 0x0b:
9332 case 0x0c:
9333 case 0x0d:
9334 case 0x0e:
a117b0a5 9335 goto op_semantics_73;
c7927a3c
NC		 9336 break;
9337 case 0x0f:
a117b0a5 9338 goto op_semantics_74;
c7927a3c
NC		 9339 break;
9340 }
9341 break;
9342 case 0xeb:
9343 GETBYTE ();
9344 switch (op[2] & 0x0f)
9345 {
9346 case 0x00:
9347 case 0x01:
9348 case 0x02:
9349 case 0x03:
9350 case 0x04:
9351 case 0x05:
9352 case 0x06:
9353 case 0x07:
9354 case 0x08:
9355 case 0x09:
9356 case 0x0a:
9357 case 0x0b:
9358 case 0x0c:
9359 case 0x0d:
9360 case 0x0e:
a117b0a5 9361 goto op_semantics_73;
c7927a3c
NC		 9362 break;
9363 case 0x0f:
a117b0a5 9364 goto op_semantics_74;
c7927a3c
NC		 9365 break;
9366 }
9367 break;
9368 case 0xec:
9369 GETBYTE ();
9370 switch (op[2] & 0x0f)
9371 {
9372 case 0x00:
9373 case 0x01:
9374 case 0x02:
9375 case 0x03:
9376 case 0x04:
9377 case 0x05:
9378 case 0x06:
9379 case 0x07:
9380 case 0x08:
9381 case 0x09:
9382 case 0x0a:
9383 case 0x0b:
9384 case 0x0c:
9385 case 0x0d:
9386 case 0x0e:
a117b0a5 9387 goto op_semantics_73;
c7927a3c
NC		 9388 break;
9389 case 0x0f:
a117b0a5 9390 goto op_semantics_74;
c7927a3c
NC		 9391 break;
9392 }
9393 break;
9394 case 0xed:
9395 GETBYTE ();
9396 switch (op[2] & 0x0f)
9397 {
9398 case 0x00:
9399 case 0x01:
9400 case 0x02:
9401 case 0x03:
9402 case 0x04:
9403 case 0x05:
9404 case 0x06:
9405 case 0x07:
9406 case 0x08:
9407 case 0x09:
9408 case 0x0a:
9409 case 0x0b:
9410 case 0x0c:
9411 case 0x0d:
9412 case 0x0e:
a117b0a5 9413 goto op_semantics_73;
c7927a3c
NC		 9414 break;
9415 case 0x0f:
a117b0a5 9416 goto op_semantics_74;
c7927a3c
NC		 9417 break;
9418 }
9419 break;
9420 case 0xee:
9421 GETBYTE ();
9422 switch (op[2] & 0x0f)
9423 {
9424 case 0x00:
9425 case 0x01:
9426 case 0x02:
9427 case 0x03:
9428 case 0x04:
9429 case 0x05:
9430 case 0x06:
9431 case 0x07:
9432 case 0x08:
9433 case 0x09:
9434 case 0x0a:
9435 case 0x0b:
9436 case 0x0c:
9437 case 0x0d:
9438 case 0x0e:
a117b0a5 9439 goto op_semantics_73;
c7927a3c
NC		 9440 break;
9441 case 0x0f:
a117b0a5 9442 goto op_semantics_74;
c7927a3c
NC		 9443 break;
9444 }
9445 break;
9446 case 0xef:
9447 GETBYTE ();
9448 switch (op[2] & 0x0f)
9449 {
9450 case 0x00:
9451 case 0x01:
9452 case 0x02:
9453 case 0x03:
9454 case 0x04:
9455 case 0x05:
9456 case 0x06:
9457 case 0x07:
9458 case 0x08:
9459 case 0x09:
9460 case 0x0a:
9461 case 0x0b:
9462 case 0x0c:
9463 case 0x0d:
9464 case 0x0e:
a117b0a5 9465 goto op_semantics_73;
c7927a3c
NC		 9466 break;
9467 case 0x0f:
a117b0a5 9468 goto op_semantics_74;
c7927a3c
NC		 9469 break;
9470 }
9471 break;
9472 case 0xf0:
9473 GETBYTE ();
9474 switch (op[2] & 0x0f)
9475 {
9476 case 0x00:
9477 case 0x01:
9478 case 0x02:
9479 case 0x03:
9480 case 0x04:
9481 case 0x05:
9482 case 0x06:
9483 case 0x07:
9484 case 0x08:
9485 case 0x09:
9486 case 0x0a:
9487 case 0x0b:
9488 case 0x0c:
9489 case 0x0d:
9490 case 0x0e:
a117b0a5 9491 goto op_semantics_73;
c7927a3c
NC		 9492 break;
9493 case 0x0f:
a117b0a5 9494 goto op_semantics_74;
c7927a3c
NC		 9495 break;
9496 }
9497 break;
9498 case 0xf1:
9499 GETBYTE ();
9500 switch (op[2] & 0x0f)
9501 {
9502 case 0x00:
9503 case 0x01:
9504 case 0x02:
9505 case 0x03:
9506 case 0x04:
9507 case 0x05:
9508 case 0x06:
9509 case 0x07:
9510 case 0x08:
9511 case 0x09:
9512 case 0x0a:
9513 case 0x0b:
9514 case 0x0c:
9515 case 0x0d:
9516 case 0x0e:
a117b0a5 9517 goto op_semantics_73;
c7927a3c
NC		 9518 break;
9519 case 0x0f:
a117b0a5 9520 goto op_semantics_74;
c7927a3c
NC		 9521 break;
9522 }
9523 break;
9524 case 0xf2:
9525 GETBYTE ();
9526 switch (op[2] & 0x0f)
9527 {
9528 case 0x00:
9529 case 0x01:
9530 case 0x02:
9531 case 0x03:
9532 case 0x04:
9533 case 0x05:
9534 case 0x06:
9535 case 0x07:
9536 case 0x08:
9537 case 0x09:
9538 case 0x0a:
9539 case 0x0b:
9540 case 0x0c:
9541 case 0x0d:
9542 case 0x0e:
a117b0a5 9543 goto op_semantics_73;
c7927a3c
NC		 9544 break;
9545 case 0x0f:
a117b0a5 9546 goto op_semantics_74;
c7927a3c
NC		 9547 break;
9548 }
9549 break;
9550 case 0xf3:
9551 GETBYTE ();
9552 switch (op[2] & 0x0f)
9553 {
9554 case 0x00:
9555 case 0x01:
9556 case 0x02:
9557 case 0x03:
9558 case 0x04:
9559 case 0x05:
9560 case 0x06:
9561 case 0x07:
9562 case 0x08:
9563 case 0x09:
9564 case 0x0a:
9565 case 0x0b:
9566 case 0x0c:
9567 case 0x0d:
9568 case 0x0e:
a117b0a5 9569 goto op_semantics_73;
c7927a3c
NC		 9570 break;
9571 case 0x0f:
a117b0a5 9572 goto op_semantics_74;
c7927a3c
NC		 9573 break;
9574 }
9575 break;
9576 case 0xf4:
9577 GETBYTE ();
9578 switch (op[2] & 0x0f)
9579 {
9580 case 0x00:
9581 case 0x01:
9582 case 0x02:
9583 case 0x03:
9584 case 0x04:
9585 case 0x05:
9586 case 0x06:
9587 case 0x07:
9588 case 0x08:
9589 case 0x09:
9590 case 0x0a:
9591 case 0x0b:
9592 case 0x0c:
9593 case 0x0d:
9594 case 0x0e:
a117b0a5 9595 goto op_semantics_73;
c7927a3c
NC		 9596 break;
9597 case 0x0f:
a117b0a5 9598 goto op_semantics_74;
c7927a3c
NC		 9599 break;
9600 }
9601 break;
9602 case 0xf5:
9603 GETBYTE ();
9604 switch (op[2] & 0x0f)
9605 {
9606 case 0x00:
9607 case 0x01:
9608 case 0x02:
9609 case 0x03:
9610 case 0x04:
9611 case 0x05:
9612 case 0x06:
9613 case 0x07:
9614 case 0x08:
9615 case 0x09:
9616 case 0x0a:
9617 case 0x0b:
9618 case 0x0c:
9619 case 0x0d:
9620 case 0x0e:
a117b0a5 9621 goto op_semantics_73;
c7927a3c
NC		 9622 break;
9623 case 0x0f:
a117b0a5 9624 goto op_semantics_74;
c7927a3c
NC		 9625 break;
9626 }
9627 break;
9628 case 0xf6:
9629 GETBYTE ();
9630 switch (op[2] & 0x0f)
9631 {
9632 case 0x00:
9633 case 0x01:
9634 case 0x02:
9635 case 0x03:
9636 case 0x04:
9637 case 0x05:
9638 case 0x06:
9639 case 0x07:
9640 case 0x08:
9641 case 0x09:
9642 case 0x0a:
9643 case 0x0b:
9644 case 0x0c:
9645 case 0x0d:
9646 case 0x0e:
a117b0a5 9647 goto op_semantics_73;
c7927a3c
NC		 9648 break;
9649 case 0x0f:
a117b0a5 9650 goto op_semantics_74;
c7927a3c
NC		 9651 break;
9652 }
9653 break;
9654 case 0xf7:
9655 GETBYTE ();
9656 switch (op[2] & 0x0f)
9657 {
9658 case 0x00:
9659 case 0x01:
9660 case 0x02:
9661 case 0x03:
9662 case 0x04:
9663 case 0x05:
9664 case 0x06:
9665 case 0x07:
9666 case 0x08:
9667 case 0x09:
9668 case 0x0a:
9669 case 0x0b:
9670 case 0x0c:
9671 case 0x0d:
9672 case 0x0e:
a117b0a5 9673 goto op_semantics_73;
c7927a3c
NC		 9674 break;
9675 case 0x0f:
a117b0a5 9676 goto op_semantics_74;
c7927a3c
NC		 9677 break;
9678 }
9679 break;
9680 case 0xf8:
9681 GETBYTE ();
9682 switch (op[2] & 0x0f)
9683 {
9684 case 0x00:
9685 case 0x01:
9686 case 0x02:
9687 case 0x03:
9688 case 0x04:
9689 case 0x05:
9690 case 0x06:
9691 case 0x07:
9692 case 0x08:
9693 case 0x09:
9694 case 0x0a:
9695 case 0x0b:
9696 case 0x0c:
9697 case 0x0d:
9698 case 0x0e:
a117b0a5 9699 goto op_semantics_73;
c7927a3c
NC		 9700 break;
9701 case 0x0f:
a117b0a5 9702 goto op_semantics_74;
c7927a3c
NC		 9703 break;
9704 }
9705 break;
9706 case 0xf9:
9707 GETBYTE ();
9708 switch (op[2] & 0x0f)
9709 {
9710 case 0x00:
9711 case 0x01:
9712 case 0x02:
9713 case 0x03:
9714 case 0x04:
9715 case 0x05:
9716 case 0x06:
9717 case 0x07:
9718 case 0x08:
9719 case 0x09:
9720 case 0x0a:
9721 case 0x0b:
9722 case 0x0c:
9723 case 0x0d:
9724 case 0x0e:
a117b0a5 9725 goto op_semantics_73;
c7927a3c
NC		 9726 break;
9727 case 0x0f:
a117b0a5 9728 goto op_semantics_74;
c7927a3c
NC		 9729 break;
9730 }
9731 break;
9732 case 0xfa:
9733 GETBYTE ();
9734 switch (op[2] & 0x0f)
9735 {
9736 case 0x00:
9737 case 0x01:
9738 case 0x02:
9739 case 0x03:
9740 case 0x04:
9741 case 0x05:
9742 case 0x06:
9743 case 0x07:
9744 case 0x08:
9745 case 0x09:
9746 case 0x0a:
9747 case 0x0b:
9748 case 0x0c:
9749 case 0x0d:
9750 case 0x0e:
a117b0a5 9751 goto op_semantics_73;
c7927a3c
NC		 9752 break;
9753 case 0x0f:
a117b0a5 9754 goto op_semantics_74;
c7927a3c
NC		 9755 break;
9756 }
9757 break;
9758 case 0xfb:
9759 GETBYTE ();
9760 switch (op[2] & 0x0f)
9761 {
9762 case 0x00:
9763 case 0x01:
9764 case 0x02:
9765 case 0x03:
9766 case 0x04:
9767 case 0x05:
9768 case 0x06:
9769 case 0x07:
9770 case 0x08:
9771 case 0x09:
9772 case 0x0a:
9773 case 0x0b:
9774 case 0x0c:
9775 case 0x0d:
9776 case 0x0e:
a117b0a5 9777 goto op_semantics_73;
c7927a3c
NC		 9778 break;
9779 case 0x0f:
a117b0a5 9780 goto op_semantics_74;
c7927a3c
NC		 9781 break;
9782 }
9783 break;
9784 case 0xfc:
9785 GETBYTE ();
9786 switch (op[2] & 0x0f)
9787 {
9788 case 0x00:
9789 case 0x01:
9790 case 0x02:
9791 case 0x03:
9792 case 0x04:
9793 case 0x05:
9794 case 0x06:
9795 case 0x07:
9796 case 0x08:
9797 case 0x09:
9798 case 0x0a:
9799 case 0x0b:
9800 case 0x0c:
9801 case 0x0d:
9802 case 0x0e:
a117b0a5 9803 goto op_semantics_73;
c7927a3c
NC		 9804 break;
9805 case 0x0f:
a117b0a5 9806 goto op_semantics_74;
c7927a3c
NC		 9807 break;
9808 }
9809 break;
9810 case 0xfd:
9811 GETBYTE ();
9812 switch (op[2] & 0x0f)
9813 {
9814 case 0x00:
9815 case 0x01:
9816 case 0x02:
9817 case 0x03:
9818 case 0x04:
9819 case 0x05:
9820 case 0x06:
9821 case 0x07:
9822 case 0x08:
9823 case 0x09:
9824 case 0x0a:
9825 case 0x0b:
9826 case 0x0c:
9827 case 0x0d:
9828 case 0x0e:
a117b0a5 9829 goto op_semantics_73;
c7927a3c
NC		 9830 break;
9831 case 0x0f:
a117b0a5 9832 goto op_semantics_74;
c7927a3c
NC		 9833 break;
9834 }
9835 break;
9836 case 0xfe:
9837 GETBYTE ();
9838 switch (op[2] & 0x0f)
9839 {
9840 case 0x00:
9841 case 0x01:
9842 case 0x02:
9843 case 0x03:
9844 case 0x04:
9845 case 0x05:
9846 case 0x06:
9847 case 0x07:
9848 case 0x08:
9849 case 0x09:
9850 case 0x0a:
9851 case 0x0b:
9852 case 0x0c:
9853 case 0x0d:
9854 case 0x0e:
a117b0a5 9855 goto op_semantics_73;
c7927a3c
NC		 9856 break;
9857 case 0x0f:
a117b0a5 9858 goto op_semantics_74;
c7927a3c
NC		 9859 break;
9860 }
9861 break;
9862 case 0xff:
9863 GETBYTE ();
9864 switch (op[2] & 0x0f)
9865 {
9866 case 0x00:
9867 case 0x01:
9868 case 0x02:
9869 case 0x03:
9870 case 0x04:
9871 case 0x05:
9872 case 0x06:
9873 case 0x07:
9874 case 0x08:
9875 case 0x09:
9876 case 0x0a:
9877 case 0x0b:
9878 case 0x0c:
9879 case 0x0d:
9880 case 0x0e:
a117b0a5 9881 goto op_semantics_73;
c7927a3c
NC		 9882 break;
9883 case 0x0f:
a117b0a5 9884 goto op_semantics_74;
c7927a3c
NC		 9885 break;
9886 }
9887 break;
9888 default: UNSUPPORTED(); break;
9889 }
9890 break;
9891 case 0xfd:
9892 GETBYTE ();
9893 switch (op[1] & 0xff)
9894 {
9895 case 0x00:
9896 GETBYTE ();
9897 switch (op[2] & 0x00)
9898 {
9899 case 0x00:
a117b0a5 9900 op_semantics_75:
c7927a3c 9901 {
a117b0a5 9902 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
e197589b 9903#line 852 "rx-decode.opc"
a117b0a5 9904 int a AU = (op[1] >> 3) & 0x01;
e197589b 9905#line 852 "rx-decode.opc"
c7927a3c 9906 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 9907#line 852 "rx-decode.opc"
c7927a3c
NC		 9908 int srcb AU = op[2] & 0x0f;
9909 if (trace)
9910 {
9911 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 9912 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
c7927a3c 9913 op[0], op[1], op[2]);
a117b0a5 9914 printf (" a = 0x%x,", a);
c7927a3c
NC		 9915 printf (" srca = 0x%x,", srca);
9916 printf (" srcb = 0x%x\n", srcb);
9917 }
a117b0a5 9918 SYNTAX("mulhi %1, %2, %0");
e197589b 9919#line 852 "rx-decode.opc"
a117b0a5 9920 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 9921
c7927a3c
NC		 9922 }
9923 break;
9924 }
9925 break;
9926 case 0x01:
9927 GETBYTE ();
9928 switch (op[2] & 0x00)
9929 {
9930 case 0x00:
a117b0a5 9931 op_semantics_76:
c7927a3c 9932 {
a117b0a5 9933 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
e197589b 9934#line 855 "rx-decode.opc"
a117b0a5 9935 int a AU = (op[1] >> 3) & 0x01;
e197589b 9936#line 855 "rx-decode.opc"
c7927a3c 9937 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 9938#line 855 "rx-decode.opc"
c7927a3c
NC		 9939 int srcb AU = op[2] & 0x0f;
9940 if (trace)
9941 {
9942 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 9943 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
c7927a3c 9944 op[0], op[1], op[2]);
a117b0a5 9945 printf (" a = 0x%x,", a);
c7927a3c
NC		 9946 printf (" srca = 0x%x,", srca);
9947 printf (" srcb = 0x%x\n", srcb);
9948 }
a117b0a5 9949 SYNTAX("mullo %1, %2, %0");
e197589b 9950#line 855 "rx-decode.opc"
a117b0a5 9951 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 9952
c7927a3c
NC		 9953 }
9954 break;
9955 }
9956 break;
a117b0a5 9957 case 0x02:
c7927a3c
NC		 9958 GETBYTE ();
9959 switch (op[2] & 0x00)
9960 {
9961 case 0x00:
a117b0a5 9962 op_semantics_77:
c7927a3c 9963 {
a117b0a5 9964 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
e197589b 9965#line 1083 "rx-decode.opc"
a117b0a5 9966 int a AU = (op[1] >> 3) & 0x01;
e197589b 9967#line 1083 "rx-decode.opc"
c7927a3c 9968 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 9969#line 1083 "rx-decode.opc"
c7927a3c
NC		 9970 int srcb AU = op[2] & 0x0f;
9971 if (trace)
9972 {
9973 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 9974 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
c7927a3c 9975 op[0], op[1], op[2]);
a117b0a5 9976 printf (" a = 0x%x,", a);
c7927a3c
NC		 9977 printf (" srca = 0x%x,", srca);
9978 printf (" srcb = 0x%x\n", srcb);
9979 }
a117b0a5 9980 SYNTAX("mullh %1, %2, %0");
e197589b 9981#line 1083 "rx-decode.opc"
a117b0a5 9982 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 9983
c7927a3c
NC		 9984 }
9985 break;
9986 }
9987 break;
a117b0a5 9988 case 0x03:
c7927a3c
NC		 9989 GETBYTE ();
9990 switch (op[2] & 0x00)
9991 {
9992 case 0x00:
a117b0a5 9993 op_semantics_78:
c7927a3c 9994 {
a117b0a5 9995 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
e197589b 9996#line 1068 "rx-decode.opc"
a117b0a5 9997 int a AU = (op[1] >> 3) & 0x01;
e197589b 9998#line 1068 "rx-decode.opc"
c7927a3c 9999 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10000#line 1068 "rx-decode.opc"
c7927a3c
NC		 10001 int srcb AU = op[2] & 0x0f;
10002 if (trace)
10003 {
10004 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10005 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
c7927a3c 10006 op[0], op[1], op[2]);
a117b0a5 10007 printf (" a = 0x%x,", a);
c7927a3c
NC		 10008 printf (" srca = 0x%x,", srca);
10009 printf (" srcb = 0x%x\n", srcb);
10010 }
a117b0a5 10011 SYNTAX("emula %1, %2, %0");
e197589b 10012#line 1068 "rx-decode.opc"
a117b0a5 10013 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10014
c7927a3c
NC		 10015 }
10016 break;
10017 }
10018 break;
a117b0a5 10019 case 0x04:
c7927a3c 10020 GETBYTE ();
a117b0a5 10021 switch (op[2] & 0x00)
c7927a3c
NC		 10022 {
10023 case 0x00:
a117b0a5 10024 op_semantics_79:
c7927a3c 10025 {
a117b0a5 10026 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
e197589b 10027#line 858 "rx-decode.opc"
a117b0a5 10028 int a AU = (op[1] >> 3) & 0x01;
e197589b 10029#line 858 "rx-decode.opc"
a117b0a5 10030 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10031#line 858 "rx-decode.opc"
a117b0a5 10032 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10033 if (trace)
10034 {
10035 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10036 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
c7927a3c 10037 op[0], op[1], op[2]);
a117b0a5
YS		 10038 printf (" a = 0x%x,", a);
10039 printf (" srca = 0x%x,", srca);
10040 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10041 }
a117b0a5 10042 SYNTAX("machi %1, %2, %0");
e197589b 10043#line 858 "rx-decode.opc"
a117b0a5 10044 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10045
c7927a3c
NC		 10046 }
10047 break;
c7927a3c
NC		 10048 }
10049 break;
a117b0a5 10050 case 0x05:
c7927a3c 10051 GETBYTE ();
a117b0a5 10052 switch (op[2] & 0x00)
c7927a3c
NC		 10053 {
10054 case 0x00:
a117b0a5 10055 op_semantics_80:
c7927a3c 10056 {
a117b0a5 10057 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
e197589b 10058#line 861 "rx-decode.opc"
a117b0a5 10059 int a AU = (op[1] >> 3) & 0x01;
e197589b 10060#line 861 "rx-decode.opc"
a117b0a5 10061 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10062#line 861 "rx-decode.opc"
a117b0a5 10063 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10064 if (trace)
10065 {
10066 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10067 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
c7927a3c 10068 op[0], op[1], op[2]);
a117b0a5
YS		 10069 printf (" a = 0x%x,", a);
10070 printf (" srca = 0x%x,", srca);
10071 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10072 }
a117b0a5 10073 SYNTAX("maclo %1, %2, %0");
e197589b 10074#line 861 "rx-decode.opc"
a117b0a5 10075 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10076
c7927a3c
NC		 10077 }
10078 break;
c7927a3c
NC		 10079 }
10080 break;
a117b0a5 10081 case 0x06:
c7927a3c 10082 GETBYTE ();
a117b0a5 10083 switch (op[2] & 0x00)
c7927a3c
NC		 10084 {
10085 case 0x00:
a117b0a5 10086 op_semantics_81:
c7927a3c 10087 {
a117b0a5 10088 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
e197589b 10089#line 1071 "rx-decode.opc"
a117b0a5 10090 int a AU = (op[1] >> 3) & 0x01;
e197589b 10091#line 1071 "rx-decode.opc"
a117b0a5 10092 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10093#line 1071 "rx-decode.opc"
a117b0a5 10094 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10095 if (trace)
10096 {
10097 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10098 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
c7927a3c 10099 op[0], op[1], op[2]);
a117b0a5
YS		 10100 printf (" a = 0x%x,", a);
10101 printf (" srca = 0x%x,", srca);
10102 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10103 }
a117b0a5 10104 SYNTAX("maclh %1, %2, %0");
e197589b 10105#line 1071 "rx-decode.opc"
a117b0a5 10106 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10107
c7927a3c
NC		 10108 }
10109 break;
c7927a3c
NC		 10110 }
10111 break;
a117b0a5 10112 case 0x07:
c7927a3c
NC		 10113 GETBYTE ();
10114 switch (op[2] & 0x00)
10115 {
10116 case 0x00:
a117b0a5 10117 op_semantics_82:
c7927a3c 10118 {
a117b0a5 10119 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
e197589b 10120#line 1062 "rx-decode.opc"
a117b0a5 10121 int a AU = (op[1] >> 3) & 0x01;
e197589b 10122#line 1062 "rx-decode.opc"
a117b0a5 10123 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10124#line 1062 "rx-decode.opc"
a117b0a5 10125 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10126 if (trace)
10127 {
10128 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10129 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
c7927a3c 10130 op[0], op[1], op[2]);
a117b0a5
YS		 10131 printf (" a = 0x%x,", a);
10132 printf (" srca = 0x%x,", srca);
10133 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10134 }
a117b0a5 10135 SYNTAX("emaca %1, %2, %0");
e197589b 10136#line 1062 "rx-decode.opc"
a117b0a5 10137 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10138
c7927a3c
NC		 10139 }
10140 break;
10141 }
10142 break;
a117b0a5 10143 case 0x08:
c7927a3c
NC		 10144 GETBYTE ();
10145 switch (op[2] & 0x00)
10146 {
10147 case 0x00:
a117b0a5 10148 goto op_semantics_75;
c7927a3c
NC		 10149 break;
10150 }
10151 break;
a117b0a5 10152 case 0x09:
c7927a3c
NC		 10153 GETBYTE ();
10154 switch (op[2] & 0x00)
10155 {
10156 case 0x00:
a117b0a5 10157 goto op_semantics_76;
c7927a3c
NC		 10158 break;
10159 }
10160 break;
a117b0a5 10161 case 0x0a:
c7927a3c
NC		 10162 GETBYTE ();
10163 switch (op[2] & 0x00)
10164 {
10165 case 0x00:
a117b0a5 10166 goto op_semantics_77;
c7927a3c
NC		 10167 break;
10168 }
10169 break;
a117b0a5 10170 case 0x0b:
c7927a3c
NC		 10171 GETBYTE ();
10172 switch (op[2] & 0x00)
10173 {
10174 case 0x00:
a117b0a5 10175 goto op_semantics_78;
c7927a3c
NC		 10176 break;
10177 }
10178 break;
a117b0a5 10179 case 0x0c:
c7927a3c
NC		 10180 GETBYTE ();
10181 switch (op[2] & 0x00)
10182 {
10183 case 0x00:
a117b0a5 10184 goto op_semantics_79;
c7927a3c
NC		 10185 break;
10186 }
10187 break;
a117b0a5 10188 case 0x0d:
c7927a3c
NC		 10189 GETBYTE ();
10190 switch (op[2] & 0x00)
10191 {
10192 case 0x00:
a117b0a5 10193 goto op_semantics_80;
c7927a3c
NC		 10194 break;
10195 }
10196 break;
a117b0a5 10197 case 0x0e:
c7927a3c
NC		 10198 GETBYTE ();
10199 switch (op[2] & 0x00)
10200 {
10201 case 0x00:
a117b0a5 10202 goto op_semantics_81;
c7927a3c
NC		 10203 break;
10204 }
10205 break;
a117b0a5 10206 case 0x0f:
c7927a3c
NC		 10207 GETBYTE ();
10208 switch (op[2] & 0x00)
10209 {
10210 case 0x00:
a117b0a5 10211 goto op_semantics_82;
c7927a3c
NC		 10212 break;
10213 }
10214 break;
a117b0a5 10215 case 0x17:
c7927a3c 10216 GETBYTE ();
a117b0a5 10217 switch (op[2] & 0x70)
c7927a3c
NC		 10218 {
10219 case 0x00:
a117b0a5
YS		 10220 {
10221 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
e197589b 10222#line 864 "rx-decode.opc"
a117b0a5 10223 int a AU = (op[2] >> 7) & 0x01;
e197589b 10224#line 864 "rx-decode.opc"
a117b0a5
YS		 10225 int rsrc AU = op[2] & 0x0f;
10226 if (trace)
10227 {
10228 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10229 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
10230 op[0], op[1], op[2]);
10231 printf (" a = 0x%x,", a);
10232 printf (" rsrc = 0x%x\n", rsrc);
10233 }
10234 SYNTAX("mvtachi %1, %0");
e197589b 10235#line 864 "rx-decode.opc"
a117b0a5
YS		 10236 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10237
10238 }
c7927a3c 10239 break;
a117b0a5
YS		 10240 case 0x10:
10241 {
10242 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
e197589b 10243#line 867 "rx-decode.opc"
a117b0a5 10244 int a AU = (op[2] >> 7) & 0x01;
e197589b 10245#line 867 "rx-decode.opc"
a117b0a5
YS		 10246 int rsrc AU = op[2] & 0x0f;
10247 if (trace)
10248 {
10249 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10250 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
10251 op[0], op[1], op[2]);
10252 printf (" a = 0x%x,", a);
10253 printf (" rsrc = 0x%x\n", rsrc);
10254 }
10255 SYNTAX("mvtaclo %1, %0");
e197589b 10256#line 867 "rx-decode.opc"
a117b0a5
YS		 10257 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10258
10259 }
c7927a3c 10260 break;
a117b0a5
YS		 10261 case 0x30:
10262 {
10263 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
e197589b 10264#line 1089 "rx-decode.opc"
a117b0a5 10265 int a AU = (op[2] >> 7) & 0x01;
e197589b 10266#line 1089 "rx-decode.opc"
a117b0a5
YS		 10267 int rdst AU = op[2] & 0x0f;
10268 if (trace)
10269 {
10270 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10271 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
10272 op[0], op[1], op[2]);
10273 printf (" a = 0x%x,", a);
10274 printf (" rdst = 0x%x\n", rdst);
10275 }
10276 SYNTAX("mvtacgu %0, %1");
e197589b 10277#line 1089 "rx-decode.opc"
239efab1 10278 ID(mvtacgu); DR(a+32); SR(rdst); F_____;
a117b0a5
YS		 10279
10280 }
c7927a3c 10281 break;
a117b0a5 10282 default: UNSUPPORTED(); break;
c7927a3c
NC		 10283 }
10284 break;
a117b0a5 10285 case 0x18:
c7927a3c 10286 GETBYTE ();
a117b0a5 10287 switch (op[2] & 0x6f)
c7927a3c
NC		 10288 {
10289 case 0x00:
c7927a3c 10290 {
a117b0a5 10291 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
e197589b 10292#line 879 "rx-decode.opc"
a117b0a5 10293 int a AU = (op[2] >> 7) & 0x01;
e197589b 10294#line 879 "rx-decode.opc"
a117b0a5 10295 int i AU = (op[2] >> 4) & 0x01;
c7927a3c
NC		 10296 if (trace)
10297 {
10298 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10299 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
c7927a3c 10300 op[0], op[1], op[2]);
a117b0a5
YS		 10301 printf (" a = 0x%x,", a);
10302 printf (" i = 0x%x\n", i);
c7927a3c 10303 }
a117b0a5 10304 SYNTAX("racw #%1, %0");
e197589b 10305#line 879 "rx-decode.opc"
a117b0a5 10306 ID(racw); SC(i+1); DR(a+32); F_____;
43e65147 10307
c7927a3c 10308 /*----------------------------------------------------------------------*/
a117b0a5 10309 /* SAT */
43e65147 10310
c7927a3c
NC		 10311 }
10312 break;
a117b0a5
YS		 10313 case 0x40:
10314 {
10315 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
e197589b 10316#line 1098 "rx-decode.opc"
a117b0a5 10317 int a AU = (op[2] >> 7) & 0x01;
e197589b 10318#line 1098 "rx-decode.opc"
a117b0a5
YS		 10319 int i AU = (op[2] >> 4) & 0x01;
10320 if (trace)
10321 {
10322 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10323 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
10324 op[0], op[1], op[2]);
10325 printf (" a = 0x%x,", a);
10326 printf (" i = 0x%x\n", i);
10327 }
10328 SYNTAX("rdacw #%1, %0");
e197589b 10329#line 1098 "rx-decode.opc"
a117b0a5
YS		 10330 ID(rdacw); SC(i+1); DR(a+32); F_____;
10331
10332 }
c7927a3c 10333 break;
a117b0a5 10334 default: UNSUPPORTED(); break;
c7927a3c
NC		 10335 }
10336 break;
a117b0a5 10337 case 0x19:
c7927a3c 10338 GETBYTE ();
a117b0a5 10339 switch (op[2] & 0x6f)
c7927a3c
NC		 10340 {
10341 case 0x00:
10342 {
a117b0a5 10343 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
e197589b 10344#line 1092 "rx-decode.opc"
a117b0a5 10345 int a AU = (op[2] >> 7) & 0x01;
e197589b 10346#line 1092 "rx-decode.opc"
a117b0a5 10347 int i AU = (op[2] >> 4) & 0x01;
c7927a3c
NC		 10348 if (trace)
10349 {
10350 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10351 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
c7927a3c 10352 op[0], op[1], op[2]);
a117b0a5
YS		 10353 printf (" a = 0x%x,", a);
10354 printf (" i = 0x%x\n", i);
c7927a3c 10355 }
a117b0a5 10356 SYNTAX("racl #%1, %0");
e197589b 10357#line 1092 "rx-decode.opc"
a117b0a5 10358 ID(racl); SC(i+1); DR(a+32); F_____;
43e65147 10359
c7927a3c
NC		 10360 }
10361 break;
a117b0a5 10362 case 0x40:
c7927a3c 10363 {
a117b0a5 10364 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
e197589b 10365#line 1095 "rx-decode.opc"
a117b0a5 10366 int a AU = (op[2] >> 7) & 0x01;
e197589b 10367#line 1095 "rx-decode.opc"
a117b0a5 10368 int i AU = (op[2] >> 4) & 0x01;
c7927a3c
NC		 10369 if (trace)
10370 {
10371 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10372 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
c7927a3c 10373 op[0], op[1], op[2]);
a117b0a5
YS		 10374 printf (" a = 0x%x,", a);
10375 printf (" i = 0x%x\n", i);
c7927a3c 10376 }
a117b0a5 10377 SYNTAX("rdacl #%1, %0");
e197589b 10378#line 1095 "rx-decode.opc"
a117b0a5 10379 ID(rdacl); SC(i+1); DR(a+32); F_____;
43e65147 10380
c7927a3c
NC		 10381 }
10382 break;
a117b0a5 10383 default: UNSUPPORTED(); break;
c7927a3c
NC		 10384 }
10385 break;
a117b0a5 10386 case 0x1e:
c7927a3c 10387 GETBYTE ();
a117b0a5 10388 switch (op[2] & 0x30)
c7927a3c
NC		 10389 {
10390 case 0x00:
a117b0a5 10391 op_semantics_83:
c7927a3c 10392 {
a117b0a5 10393 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
e197589b 10394#line 870 "rx-decode.opc"
a117b0a5 10395 int i AU = op[1] & 0x01;
e197589b 10396#line 870 "rx-decode.opc"
a117b0a5 10397 int a AU = (op[2] >> 7) & 0x01;
e197589b 10398#line 870 "rx-decode.opc"
a117b0a5 10399 int m AU = (op[2] >> 6) & 0x01;
e197589b 10400#line 870 "rx-decode.opc"
c7927a3c
NC		 10401 int rdst AU = op[2] & 0x0f;
10402 if (trace)
10403 {
10404 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10405 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
c7927a3c 10406 op[0], op[1], op[2]);
a117b0a5
YS		 10407 printf (" i = 0x%x,", i);
10408 printf (" a = 0x%x,", a);
10409 printf (" m = 0x%x,", m);
c7927a3c
NC		 10410 printf (" rdst = 0x%x\n", rdst);
10411 }
a117b0a5 10412 SYNTAX("mvfachi #%2, %1, %0");
e197589b 10413#line 870 "rx-decode.opc"
a117b0a5 10414 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10415
c7927a3c
NC		 10416 }
10417 break;
a117b0a5
YS		 10418 case 0x10:
10419 op_semantics_84:
c7927a3c 10420 {
a117b0a5 10421 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
e197589b 10422#line 876 "rx-decode.opc"
a117b0a5 10423 int i AU = op[1] & 0x01;
e197589b 10424#line 876 "rx-decode.opc"
a117b0a5 10425 int a AU = (op[2] >> 7) & 0x01;
e197589b 10426#line 876 "rx-decode.opc"
a117b0a5 10427 int m AU = (op[2] >> 6) & 0x01;
e197589b 10428#line 876 "rx-decode.opc"
c7927a3c
NC		 10429 int rdst AU = op[2] & 0x0f;
10430 if (trace)
10431 {
10432 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10433 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
c7927a3c 10434 op[0], op[1], op[2]);
a117b0a5
YS		 10435 printf (" i = 0x%x,", i);
10436 printf (" a = 0x%x,", a);
10437 printf (" m = 0x%x,", m);
c7927a3c
NC		 10438 printf (" rdst = 0x%x\n", rdst);
10439 }
a117b0a5 10440 SYNTAX("mvfaclo #%2, %1, %0");
e197589b 10441#line 876 "rx-decode.opc"
a117b0a5 10442 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10443
c7927a3c
NC		 10444 }
10445 break;
a117b0a5
YS		 10446 case 0x20:
10447 op_semantics_85:
c7927a3c 10448 {
a117b0a5 10449 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
e197589b 10450#line 873 "rx-decode.opc"
a117b0a5 10451 int i AU = op[1] & 0x01;
e197589b 10452#line 873 "rx-decode.opc"
a117b0a5 10453 int a AU = (op[2] >> 7) & 0x01;
e197589b 10454#line 873 "rx-decode.opc"
a117b0a5 10455 int m AU = (op[2] >> 6) & 0x01;
e197589b 10456#line 873 "rx-decode.opc"
c7927a3c
NC		 10457 int rdst AU = op[2] & 0x0f;
10458 if (trace)
10459 {
10460 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10461 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
c7927a3c 10462 op[0], op[1], op[2]);
a117b0a5
YS		 10463 printf (" i = 0x%x,", i);
10464 printf (" a = 0x%x,", a);
10465 printf (" m = 0x%x,", m);
c7927a3c
NC		 10466 printf (" rdst = 0x%x\n", rdst);
10467 }
a117b0a5 10468 SYNTAX("mvfacmi #%2, %1, %0");
e197589b 10469#line 873 "rx-decode.opc"
a117b0a5 10470 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10471
c7927a3c
NC		 10472 }
10473 break;
a117b0a5
YS		 10474 case 0x30:
10475 op_semantics_86:
c7927a3c 10476 {
a117b0a5 10477 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
e197589b 10478#line 1086 "rx-decode.opc"
a117b0a5 10479 int i AU = op[1] & 0x01;
e197589b 10480#line 1086 "rx-decode.opc"
a117b0a5 10481 int a AU = (op[2] >> 7) & 0x01;
e197589b 10482#line 1086 "rx-decode.opc"
a117b0a5 10483 int m AU = (op[2] >> 6) & 0x01;
e197589b 10484#line 1086 "rx-decode.opc"
c7927a3c
NC		 10485 int rdst AU = op[2] & 0x0f;
10486 if (trace)
10487 {
10488 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10489 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
c7927a3c 10490 op[0], op[1], op[2]);
a117b0a5
YS		 10491 printf (" i = 0x%x,", i);
10492 printf (" a = 0x%x,", a);
10493 printf (" m = 0x%x,", m);
c7927a3c
NC		 10494 printf (" rdst = 0x%x\n", rdst);
10495 }
a117b0a5 10496 SYNTAX("mvfacgu #%2, %1, %0");
e197589b 10497#line 1086 "rx-decode.opc"
a117b0a5 10498 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
43e65147 10499
c7927a3c
NC		 10500 }
10501 break;
10502 }
10503 break;
a117b0a5 10504 case 0x1f:
c7927a3c 10505 GETBYTE ();
a117b0a5 10506 switch (op[2] & 0x30)
c7927a3c
NC		 10507 {
10508 case 0x00:
a117b0a5
YS		 10509 goto op_semantics_83;
10510 break;
10511 case 0x10:
10512 goto op_semantics_84;
10513 break;
10514 case 0x20:
10515 goto op_semantics_85;
10516 break;
10517 case 0x30:
10518 goto op_semantics_86;
c7927a3c
NC		 10519 break;
10520 }
10521 break;
a117b0a5 10522 case 0x20:
c7927a3c
NC		 10523 GETBYTE ();
10524 switch (op[2] & 0x00)
10525 {
10526 case 0x00:
a117b0a5 10527 op_semantics_87:
c7927a3c 10528 {
a117b0a5 10529 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
e197589b 10530#line 348 "rx-decode.opc"
a117b0a5 10531 int p AU = (op[1] >> 2) & 0x01;
e197589b 10532#line 348 "rx-decode.opc"
a117b0a5 10533 int sz AU = op[1] & 0x03;
e197589b 10534#line 348 "rx-decode.opc"
a117b0a5 10535 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 10536#line 348 "rx-decode.opc"
a117b0a5 10537 int rsrc AU = op[2] & 0x0f;
c7927a3c
NC		 10538 if (trace)
10539 {
10540 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10541 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
c7927a3c 10542 op[0], op[1], op[2]);
a117b0a5
YS		 10543 printf (" p = 0x%x,", p);
10544 printf (" sz = 0x%x,", sz);
10545 printf (" rdst = 0x%x,", rdst);
10546 printf (" rsrc = 0x%x\n", rsrc);
c7927a3c 10547 }
a117b0a5 10548 SYNTAX("mov%s %1, %0");
e197589b 10549#line 348 "rx-decode.opc"
a117b0a5
YS		 10550 ID(mov); sBWL (sz); SR(rsrc); F_____;
10551 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
43e65147 10552
c7927a3c
NC		 10553 }
10554 break;
10555 }
10556 break;
a117b0a5 10557 case 0x21:
c7927a3c
NC		 10558 GETBYTE ();
10559 switch (op[2] & 0x00)
10560 {
10561 case 0x00:
a117b0a5 10562 goto op_semantics_87;
c7927a3c
NC		 10563 break;
10564 }
10565 break;
a117b0a5 10566 case 0x22:
c7927a3c
NC		 10567 GETBYTE ();
10568 switch (op[2] & 0x00)
10569 {
10570 case 0x00:
a117b0a5 10571 goto op_semantics_87;
c7927a3c
NC		 10572 break;
10573 }
10574 break;
a117b0a5 10575 case 0x24:
c7927a3c
NC		 10576 GETBYTE ();
10577 switch (op[2] & 0x00)
10578 {
10579 case 0x00:
a117b0a5 10580 goto op_semantics_87;
c7927a3c
NC		 10581 break;
10582 }
10583 break;
a117b0a5 10584 case 0x25:
c7927a3c
NC		 10585 GETBYTE ();
10586 switch (op[2] & 0x00)
10587 {
10588 case 0x00:
a117b0a5 10589 goto op_semantics_87;
c7927a3c
NC		 10590 break;
10591 }
10592 break;
a117b0a5 10593 case 0x26:
c7927a3c
NC		 10594 GETBYTE ();
10595 switch (op[2] & 0x00)
10596 {
10597 case 0x00:
a117b0a5 10598 goto op_semantics_87;
c7927a3c
NC		 10599 break;
10600 }
10601 break;
a117b0a5 10602 case 0x27:
c7927a3c
NC		 10603 GETBYTE ();
10604 switch (op[2] & 0x00)
10605 {
10606 case 0x00:
c7927a3c 10607 {
a117b0a5 10608 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
e197589b 10609#line 1050 "rx-decode.opc"
a117b0a5 10610 int rdst AU = (op[2] >> 4) & 0x0f;
e197589b 10611#line 1050 "rx-decode.opc"
a117b0a5
YS		 10612 int rsrc AU = op[2] & 0x0f;
10613 if (trace)
10614 {
10615 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10616 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
10617 op[0], op[1], op[2]);
10618 printf (" rdst = 0x%x,", rdst);
10619 printf (" rsrc = 0x%x\n", rsrc);
10620 }
10621 SYNTAX("movco %1, [%0]");
e197589b 10622#line 1050 "rx-decode.opc"
239efab1 10623 ID(movco); SR(rsrc); DR(rdst); F_____;
a117b0a5
YS		 10624
10625 }
10626 break;
10627 }
10628 break;
10629 case 0x28:
10630 GETBYTE ();
10631 switch (op[2] & 0x00)
10632 {
10633 case 0x00:
10634 op_semantics_88:
10635 {
10636 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
e197589b 10637#line 352 "rx-decode.opc"
a117b0a5 10638 int p AU = (op[1] >> 2) & 0x01;
e197589b 10639#line 352 "rx-decode.opc"
a117b0a5 10640 int sz AU = op[1] & 0x03;
e197589b 10641#line 352 "rx-decode.opc"
a117b0a5 10642 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 10643#line 352 "rx-decode.opc"
c7927a3c
NC		 10644 int rdst AU = op[2] & 0x0f;
10645 if (trace)
10646 {
10647 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10648 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
c7927a3c 10649 op[0], op[1], op[2]);
a117b0a5
YS		 10650 printf (" p = 0x%x,", p);
10651 printf (" sz = 0x%x,", sz);
10652 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10653 printf (" rdst = 0x%x\n", rdst);
10654 }
a117b0a5 10655 SYNTAX("mov%s %1, %0");
e197589b 10656#line 352 "rx-decode.opc"
a117b0a5
YS		 10657 ID(mov); sBWL (sz); DR(rdst); F_____;
10658 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
43e65147 10659
c7927a3c
NC		 10660 }
10661 break;
10662 }
10663 break;
a117b0a5 10664 case 0x29:
c7927a3c
NC		 10665 GETBYTE ();
10666 switch (op[2] & 0x00)
10667 {
10668 case 0x00:
a117b0a5 10669 goto op_semantics_88;
c7927a3c
NC		 10670 break;
10671 }
10672 break;
a117b0a5 10673 case 0x2a:
c7927a3c 10674 GETBYTE ();
a117b0a5 10675 switch (op[2] & 0x00)
c7927a3c 10676 {
a117b0a5
YS		 10677 case 0x00:
10678 goto op_semantics_88;
10679 break;
10680 }
10681 break;
10682 case 0x2c:
10683 GETBYTE ();
10684 switch (op[2] & 0x00)
10685 {
10686 case 0x00:
10687 goto op_semantics_88;
10688 break;
10689 }
10690 break;
10691 case 0x2d:
10692 GETBYTE ();
10693 switch (op[2] & 0x00)
10694 {
10695 case 0x00:
10696 goto op_semantics_88;
10697 break;
10698 }
10699 break;
10700 case 0x2e:
10701 GETBYTE ();
10702 switch (op[2] & 0x00)
10703 {
10704 case 0x00:
10705 goto op_semantics_88;
10706 break;
10707 }
10708 break;
10709 case 0x2f:
10710 GETBYTE ();
10711 switch (op[2] & 0x00)
10712 {
10713 case 0x00:
c7927a3c 10714 {
a117b0a5 10715 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
e197589b 10716#line 1053 "rx-decode.opc"
a117b0a5 10717 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 10718#line 1053 "rx-decode.opc"
c7927a3c
NC		 10719 int rdst AU = op[2] & 0x0f;
10720 if (trace)
10721 {
10722 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10723 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
c7927a3c 10724 op[0], op[1], op[2]);
a117b0a5 10725 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10726 printf (" rdst = 0x%x\n", rdst);
10727 }
a117b0a5 10728 SYNTAX("movli [%1], %0");
e197589b 10729#line 1053 "rx-decode.opc"
239efab1 10730 ID(movli); SR(rsrc); DR(rdst); F_____;
43e65147 10731
c7927a3c
NC		 10732 }
10733 break;
a117b0a5
YS		 10734 }
10735 break;
10736 case 0x38:
10737 GETBYTE ();
10738 switch (op[2] & 0x00)
10739 {
10740 case 0x00:
10741 op_semantics_89:
c7927a3c 10742 {
a117b0a5 10743 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
e197589b 10744#line 362 "rx-decode.opc"
a117b0a5 10745 int p AU = (op[1] >> 2) & 0x01;
e197589b 10746#line 362 "rx-decode.opc"
a117b0a5 10747 int sz AU = op[1] & 0x03;
e197589b 10748#line 362 "rx-decode.opc"
a117b0a5 10749 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 10750#line 362 "rx-decode.opc"
c7927a3c
NC		 10751 int rdst AU = op[2] & 0x0f;
10752 if (trace)
10753 {
10754 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10755 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
c7927a3c 10756 op[0], op[1], op[2]);
a117b0a5
YS		 10757 printf (" p = 0x%x,", p);
10758 printf (" sz = 0x%x,", sz);
10759 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10760 printf (" rdst = 0x%x\n", rdst);
10761 }
a117b0a5 10762 SYNTAX("movu%s %1, %0");
e197589b 10763#line 362 "rx-decode.opc"
a117b0a5
YS		 10764 ID(mov); uBW (sz); DR(rdst); F_____;
10765 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10766
10767 /*----------------------------------------------------------------------*/
10768 /* PUSH/POP */
10769
c7927a3c
NC		 10770 }
10771 break;
a117b0a5
YS		 10772 }
10773 break;
10774 case 0x39:
10775 GETBYTE ();
10776 switch (op[2] & 0x00)
10777 {
10778 case 0x00:
10779 goto op_semantics_89;
10780 break;
10781 }
10782 break;
10783 case 0x3a:
10784 GETBYTE ();
10785 switch (op[2] & 0x00)
10786 {
10787 case 0x00:
10788 goto op_semantics_89;
10789 break;
10790 }
10791 break;
10792 case 0x3c:
10793 GETBYTE ();
10794 switch (op[2] & 0x00)
10795 {
10796 case 0x00:
10797 goto op_semantics_89;
10798 break;
10799 }
10800 break;
10801 case 0x3d:
10802 GETBYTE ();
10803 switch (op[2] & 0x00)
10804 {
10805 case 0x00:
10806 goto op_semantics_89;
10807 break;
10808 }
10809 break;
10810 case 0x3e:
10811 GETBYTE ();
10812 switch (op[2] & 0x00)
10813 {
10814 case 0x00:
10815 goto op_semantics_89;
10816 break;
10817 }
10818 break;
10819 case 0x44:
10820 GETBYTE ();
10821 switch (op[2] & 0x00)
10822 {
10823 case 0x00:
10824 op_semantics_90:
c7927a3c 10825 {
a117b0a5 10826 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
e197589b 10827#line 1074 "rx-decode.opc"
a117b0a5 10828 int a AU = (op[1] >> 3) & 0x01;
e197589b 10829#line 1074 "rx-decode.opc"
a117b0a5 10830 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10831#line 1074 "rx-decode.opc"
a117b0a5 10832 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10833 if (trace)
10834 {
10835 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10836 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
c7927a3c 10837 op[0], op[1], op[2]);
a117b0a5
YS		 10838 printf (" a = 0x%x,", a);
10839 printf (" srca = 0x%x,", srca);
10840 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10841 }
a117b0a5 10842 SYNTAX("msbhi %1, %2, %0");
e197589b 10843#line 1074 "rx-decode.opc"
a117b0a5 10844 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10845
c7927a3c
NC		 10846 }
10847 break;
a117b0a5
YS		 10848 }
10849 break;
10850 case 0x45:
10851 GETBYTE ();
10852 switch (op[2] & 0x00)
10853 {
10854 case 0x00:
10855 op_semantics_91:
c7927a3c 10856 {
a117b0a5 10857 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
e197589b 10858#line 1080 "rx-decode.opc"
a117b0a5 10859 int a AU = (op[1] >> 3) & 0x01;
e197589b 10860#line 1080 "rx-decode.opc"
a117b0a5 10861 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10862#line 1080 "rx-decode.opc"
a117b0a5 10863 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10864 if (trace)
10865 {
10866 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10867 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
c7927a3c 10868 op[0], op[1], op[2]);
a117b0a5
YS		 10869 printf (" a = 0x%x,", a);
10870 printf (" srca = 0x%x,", srca);
10871 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10872 }
a117b0a5 10873 SYNTAX("msblo %1, %2, %0");
e197589b 10874#line 1080 "rx-decode.opc"
a117b0a5 10875 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10876
c7927a3c
NC		 10877 }
10878 break;
a117b0a5
YS		 10879 }
10880 break;
10881 case 0x46:
10882 GETBYTE ();
10883 switch (op[2] & 0x00)
10884 {
10885 case 0x00:
10886 op_semantics_92:
c7927a3c 10887 {
a117b0a5 10888 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
e197589b 10889#line 1077 "rx-decode.opc"
a117b0a5 10890 int a AU = (op[1] >> 3) & 0x01;
e197589b 10891#line 1077 "rx-decode.opc"
a117b0a5 10892 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10893#line 1077 "rx-decode.opc"
a117b0a5 10894 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10895 if (trace)
10896 {
10897 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10898 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
c7927a3c 10899 op[0], op[1], op[2]);
a117b0a5
YS		 10900 printf (" a = 0x%x,", a);
10901 printf (" srca = 0x%x,", srca);
10902 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10903 }
a117b0a5 10904 SYNTAX("msblh %1, %2, %0");
e197589b 10905#line 1077 "rx-decode.opc"
a117b0a5 10906 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10907
c7927a3c
NC		 10908 }
10909 break;
a117b0a5
YS		 10910 }
10911 break;
10912 case 0x47:
10913 GETBYTE ();
10914 switch (op[2] & 0x00)
10915 {
10916 case 0x00:
10917 op_semantics_93:
c7927a3c 10918 {
a117b0a5 10919 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
e197589b 10920#line 1065 "rx-decode.opc"
a117b0a5 10921 int a AU = (op[1] >> 3) & 0x01;
e197589b 10922#line 1065 "rx-decode.opc"
a117b0a5 10923 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 10924#line 1065 "rx-decode.opc"
a117b0a5 10925 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 10926 if (trace)
10927 {
10928 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10929 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
c7927a3c 10930 op[0], op[1], op[2]);
a117b0a5
YS		 10931 printf (" a = 0x%x,", a);
10932 printf (" srca = 0x%x,", srca);
10933 printf (" srcb = 0x%x\n", srcb);
c7927a3c 10934 }
a117b0a5 10935 SYNTAX("emsba %1, %2, %0");
e197589b 10936#line 1065 "rx-decode.opc"
a117b0a5 10937 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
43e65147 10938
c7927a3c
NC		 10939 }
10940 break;
a117b0a5
YS		 10941 }
10942 break;
10943 case 0x4c:
10944 GETBYTE ();
10945 switch (op[2] & 0x00)
10946 {
10947 case 0x00:
10948 goto op_semantics_90;
10949 break;
10950 }
10951 break;
10952 case 0x4d:
10953 GETBYTE ();
10954 switch (op[2] & 0x00)
10955 {
10956 case 0x00:
10957 goto op_semantics_91;
10958 break;
10959 }
10960 break;
10961 case 0x4e:
10962 GETBYTE ();
10963 switch (op[2] & 0x00)
10964 {
10965 case 0x00:
10966 goto op_semantics_92;
10967 break;
10968 }
10969 break;
10970 case 0x4f:
10971 GETBYTE ();
10972 switch (op[2] & 0x00)
10973 {
10974 case 0x00:
10975 goto op_semantics_93;
10976 break;
10977 }
10978 break;
10979 case 0x60:
10980 GETBYTE ();
10981 switch (op[2] & 0x00)
10982 {
10983 case 0x00:
c7927a3c 10984 {
a117b0a5 10985 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
e197589b 10986#line 733 "rx-decode.opc"
a117b0a5 10987 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 10988#line 733 "rx-decode.opc"
c7927a3c
NC		 10989 int rdst AU = op[2] & 0x0f;
10990 if (trace)
10991 {
10992 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 10993 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
c7927a3c 10994 op[0], op[1], op[2]);
a117b0a5 10995 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 10996 printf (" rdst = 0x%x\n", rdst);
10997 }
a117b0a5 10998 SYNTAX("shlr %2, %0");
e197589b 10999#line 733 "rx-decode.opc"
a117b0a5 11000 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
43e65147 11001
c7927a3c
NC		 11002 }
11003 break;
a117b0a5
YS		 11004 }
11005 break;
11006 case 0x61:
11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11009 {
11010 case 0x00:
c7927a3c 11011 {
a117b0a5 11012 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
e197589b 11013#line 723 "rx-decode.opc"
a117b0a5 11014 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11015#line 723 "rx-decode.opc"
c7927a3c
NC		 11016 int rdst AU = op[2] & 0x0f;
11017 if (trace)
11018 {
11019 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11020 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
c7927a3c 11021 op[0], op[1], op[2]);
a117b0a5 11022 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11023 printf (" rdst = 0x%x\n", rdst);
11024 }
a117b0a5 11025 SYNTAX("shar %2, %0");
e197589b 11026#line 723 "rx-decode.opc"
a117b0a5 11027 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
43e65147 11028
c7927a3c
NC		 11029 }
11030 break;
a117b0a5
YS		 11031 }
11032 break;
11033 case 0x62:
11034 GETBYTE ();
11035 switch (op[2] & 0x00)
11036 {
11037 case 0x00:
c7927a3c 11038 {
a117b0a5 11039 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
e197589b 11040#line 713 "rx-decode.opc"
a117b0a5 11041 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11042#line 713 "rx-decode.opc"
c7927a3c
NC		 11043 int rdst AU = op[2] & 0x0f;
11044 if (trace)
11045 {
11046 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11047 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
c7927a3c 11048 op[0], op[1], op[2]);
a117b0a5 11049 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11050 printf (" rdst = 0x%x\n", rdst);
11051 }
a117b0a5 11052 SYNTAX("shll %2, %0");
e197589b 11053#line 713 "rx-decode.opc"
a117b0a5 11054 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
43e65147 11055
c7927a3c
NC		 11056 }
11057 break;
a117b0a5
YS		 11058 }
11059 break;
11060 case 0x64:
11061 GETBYTE ();
11062 switch (op[2] & 0x00)
11063 {
11064 case 0x00:
c7927a3c 11065 {
a117b0a5 11066 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
e197589b 11067#line 757 "rx-decode.opc"
a117b0a5 11068 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11069#line 757 "rx-decode.opc"
c7927a3c
NC		 11070 int rdst AU = op[2] & 0x0f;
11071 if (trace)
11072 {
11073 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11074 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
c7927a3c 11075 op[0], op[1], op[2]);
a117b0a5 11076 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11077 printf (" rdst = 0x%x\n", rdst);
11078 }
a117b0a5 11079 SYNTAX("rotr %1, %0");
e197589b 11080#line 757 "rx-decode.opc"
a117b0a5 11081 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
43e65147 11082
c7927a3c
NC		 11083 }
11084 break;
a117b0a5
YS		 11085 }
11086 break;
11087 case 0x65:
11088 GETBYTE ();
11089 switch (op[2] & 0x00)
11090 {
11091 case 0x00:
c7927a3c 11092 {
a117b0a5 11093 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
e197589b 11094#line 760 "rx-decode.opc"
a117b0a5 11095 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11096#line 760 "rx-decode.opc"
c7927a3c
NC		 11097 int rdst AU = op[2] & 0x0f;
11098 if (trace)
11099 {
11100 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11101 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
c7927a3c 11102 op[0], op[1], op[2]);
a117b0a5 11103 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11104 printf (" rdst = 0x%x\n", rdst);
11105 }
a117b0a5 11106 SYNTAX("revw %1, %0");
e197589b 11107#line 760 "rx-decode.opc"
a117b0a5 11108 ID(revw); SR(rsrc); DR(rdst);
43e65147 11109
c7927a3c
NC		 11110 }
11111 break;
c7927a3c
NC		 11112 }
11113 break;
a117b0a5 11114 case 0x66:
c7927a3c 11115 GETBYTE ();
a117b0a5 11116 switch (op[2] & 0x00)
c7927a3c
NC		 11117 {
11118 case 0x00:
11119 {
a117b0a5 11120 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
e197589b 11121#line 751 "rx-decode.opc"
a117b0a5 11122 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11123#line 751 "rx-decode.opc"
c7927a3c
NC		 11124 int rdst AU = op[2] & 0x0f;
11125 if (trace)
11126 {
11127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11128 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
c7927a3c 11129 op[0], op[1], op[2]);
a117b0a5 11130 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11131 printf (" rdst = 0x%x\n", rdst);
11132 }
a117b0a5 11133 SYNTAX("rotl %1, %0");
e197589b 11134#line 751 "rx-decode.opc"
a117b0a5 11135 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
43e65147 11136
c7927a3c
NC		 11137 }
11138 break;
a117b0a5
YS		 11139 }
11140 break;
11141 case 0x67:
11142 GETBYTE ();
11143 switch (op[2] & 0x00)
11144 {
11145 case 0x00:
c7927a3c 11146 {
a117b0a5 11147 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
e197589b 11148#line 763 "rx-decode.opc"
a117b0a5 11149 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11150#line 763 "rx-decode.opc"
c7927a3c
NC		 11151 int rdst AU = op[2] & 0x0f;
11152 if (trace)
11153 {
11154 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11155 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
c7927a3c 11156 op[0], op[1], op[2]);
a117b0a5 11157 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11158 printf (" rdst = 0x%x\n", rdst);
11159 }
a117b0a5 11160 SYNTAX("revl %1, %0");
e197589b 11161#line 763 "rx-decode.opc"
a117b0a5
YS		 11162 ID(revl); SR(rsrc); DR(rdst);
11163
11164 /*----------------------------------------------------------------------*/
11165 /* BRANCH */
43e65147 11166
c7927a3c
NC		 11167 }
11168 break;
a117b0a5
YS		 11169 }
11170 break;
11171 case 0x68:
11172 GETBYTE ();
11173 switch (op[2] & 0x00)
11174 {
11175 case 0x00:
11176 op_semantics_94:
c7927a3c 11177 {
a117b0a5 11178 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
e197589b 11179#line 1014 "rx-decode.opc"
a117b0a5 11180 int c AU = op[1] & 0x01;
e197589b 11181#line 1014 "rx-decode.opc"
a117b0a5 11182 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11183#line 1014 "rx-decode.opc"
c7927a3c
NC		 11184 int rdst AU = op[2] & 0x0f;
11185 if (trace)
11186 {
11187 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 11188 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
c7927a3c 11189 op[0], op[1], op[2]);
a117b0a5
YS		 11190 printf (" c = 0x%x,", c);
11191 printf (" rsrc = 0x%x,", rsrc);
c7927a3c
NC		 11192 printf (" rdst = 0x%x\n", rdst);
11193 }
a117b0a5 11194 SYNTAX("mvtc %1, %0");
e197589b 11195#line 1014 "rx-decode.opc"
a117b0a5 11196 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
43e65147 11197
c7927a3c
NC		 11198 }
11199 break;
a117b0a5
YS		 11200 }
11201 break;
11202 case 0x69:
11203 GETBYTE ();
11204 switch (op[2] & 0x00)
11205 {
11206 case 0x00:
11207 goto op_semantics_94;
11208 break;
11209 }
11210 break;
11211 case 0x6a:
11212 GETBYTE ();
11213 switch (op[2] & 0x00)
11214 {
11215 case 0x00:
11216 op_semantics_95:
11217 {
11218 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
e197589b 11219#line 1017 "rx-decode.opc"
a117b0a5 11220 int s AU = op[1] & 0x01;
e197589b 11221#line 1017 "rx-decode.opc"
a117b0a5 11222 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11223#line 1017 "rx-decode.opc"
a117b0a5
YS		 11224 int rdst AU = op[2] & 0x0f;
11225 if (trace)
11226 {
11227 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11228 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
11229 op[0], op[1], op[2]);
11230 printf (" s = 0x%x,", s);
11231 printf (" rsrc = 0x%x,", rsrc);
11232 printf (" rdst = 0x%x\n", rdst);
11233 }
11234 SYNTAX("mvfc %1, %0");
e197589b 11235#line 1017 "rx-decode.opc"
a117b0a5
YS		 11236 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11237
11238 /*----------------------------------------------------------------------*/
11239 /* INTERRUPTS */
11240
11241 }
11242 break;
11243 }
11244 break;
11245 case 0x6b:
11246 GETBYTE ();
11247 switch (op[2] & 0x00)
11248 {
11249 case 0x00:
11250 goto op_semantics_95;
11251 break;
11252 }
11253 break;
11254 case 0x6c:
11255 GETBYTE ();
11256 switch (op[2] & 0x00)
11257 {
11258 case 0x00:
11259 op_semantics_96:
11260 {
11261 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
e197589b 11262#line 754 "rx-decode.opc"
a117b0a5 11263 int i AU = op[1] & 0x01;
e197589b 11264#line 754 "rx-decode.opc"
a117b0a5 11265 int mmmm AU = (op[2] >> 4) & 0x0f;
e197589b 11266#line 754 "rx-decode.opc"
a117b0a5
YS		 11267 int rdst AU = op[2] & 0x0f;
11268 if (trace)
11269 {
11270 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11271 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
11272 op[0], op[1], op[2]);
11273 printf (" i = 0x%x,", i);
11274 printf (" mmmm = 0x%x,", mmmm);
11275 printf (" rdst = 0x%x\n", rdst);
11276 }
11277 SYNTAX("rotr #%1, %0");
e197589b 11278#line 754 "rx-decode.opc"
a117b0a5
YS		 11279 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11280
11281 }
11282 break;
11283 }
11284 break;
11285 case 0x6d:
11286 GETBYTE ();
11287 switch (op[2] & 0x00)
11288 {
11289 case 0x00:
11290 goto op_semantics_96;
11291 break;
11292 }
11293 break;
11294 case 0x6e:
11295 GETBYTE ();
11296 switch (op[2] & 0x00)
11297 {
11298 case 0x00:
11299 op_semantics_97:
11300 {
11301 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
e197589b 11302#line 748 "rx-decode.opc"
a117b0a5 11303 int i AU = op[1] & 0x01;
e197589b 11304#line 748 "rx-decode.opc"
a117b0a5 11305 int mmmm AU = (op[2] >> 4) & 0x0f;
e197589b 11306#line 748 "rx-decode.opc"
a117b0a5
YS		 11307 int rdst AU = op[2] & 0x0f;
11308 if (trace)
11309 {
11310 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11311 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
11312 op[0], op[1], op[2]);
11313 printf (" i = 0x%x,", i);
11314 printf (" mmmm = 0x%x,", mmmm);
11315 printf (" rdst = 0x%x\n", rdst);
11316 }
11317 SYNTAX("rotl #%1, %0");
e197589b 11318#line 748 "rx-decode.opc"
a117b0a5
YS		 11319 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11320
11321 }
11322 break;
11323 }
11324 break;
11325 case 0x6f:
11326 GETBYTE ();
11327 switch (op[2] & 0x00)
11328 {
11329 case 0x00:
11330 goto op_semantics_97;
11331 break;
11332 }
11333 break;
11334 case 0x70:
11335 GETBYTE ();
11336 switch (op[2] & 0xf0)
11337 {
11338 case 0x20:
11339 op_semantics_98:
11340 {
11341 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
e197589b 11342#line 492 "rx-decode.opc"
a117b0a5 11343 int im AU = (op[1] >> 2) & 0x03;
e197589b 11344#line 492 "rx-decode.opc"
a117b0a5
YS		 11345 int rdst AU = op[2] & 0x0f;
11346 if (trace)
11347 {
11348 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11349 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
11350 op[0], op[1], op[2]);
11351 printf (" im = 0x%x,", im);
11352 printf (" rdst = 0x%x\n", rdst);
11353 }
11354 SYNTAX("adc #%1, %0");
e197589b 11355#line 492 "rx-decode.opc"
a117b0a5
YS		 11356 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11357
11358 }
11359 break;
11360 case 0x40:
11361 op_semantics_99:
11362 {
11363 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
e197589b 11364#line 574 "rx-decode.opc"
a117b0a5 11365 int im AU = (op[1] >> 2) & 0x03;
e197589b 11366#line 574 "rx-decode.opc"
a117b0a5
YS		 11367 int rdst AU = op[2] & 0x0f;
11368 if (trace)
11369 {
11370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11371 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
11372 op[0], op[1], op[2]);
11373 printf (" im = 0x%x,", im);
11374 printf (" rdst = 0x%x\n", rdst);
11375 }
11376 SYNTAX("max #%1, %0");
e197589b 11377#line 574 "rx-decode.opc"
a117b0a5
YS		 11378 int val = IMMex (im);
11379 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11380 {
11381 ID (nop7);
11382 SYNTAX("nop\t; max\t#0x80000000, r0");
11383 }
11384 else
11385 {
11386 ID(max);
11387 }
11388 DR(rdst); SC(val);
11389
11390 }
11391 break;
11392 case 0x50:
11393 op_semantics_100:
11394 {
11395 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
e197589b 11396#line 604 "rx-decode.opc"
a117b0a5 11397 int im AU = (op[1] >> 2) & 0x03;
e197589b 11398#line 604 "rx-decode.opc"
a117b0a5
YS		 11399 int rdst AU = op[2] & 0x0f;
11400 if (trace)
11401 {
11402 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11403 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
11404 op[0], op[1], op[2]);
11405 printf (" im = 0x%x,", im);
11406 printf (" rdst = 0x%x\n", rdst);
11407 }
11408 SYNTAX("min #%1, %0");
e197589b 11409#line 604 "rx-decode.opc"
a117b0a5
YS		 11410 ID(min); DR(rdst); SC(IMMex(im));
11411
11412 }
11413 break;
11414 case 0x60:
11415 op_semantics_101:
11416 {
11417 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
e197589b 11418#line 662 "rx-decode.opc"
a117b0a5 11419 int im AU = (op[1] >> 2) & 0x03;
e197589b 11420#line 662 "rx-decode.opc"
a117b0a5
YS		 11421 int rdst AU = op[2] & 0x0f;
11422 if (trace)
11423 {
11424 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11425 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
11426 op[0], op[1], op[2]);
11427 printf (" im = 0x%x,", im);
11428 printf (" rdst = 0x%x\n", rdst);
11429 }
11430 SYNTAX("emul #%1, %0");
e197589b 11431#line 662 "rx-decode.opc"
a117b0a5
YS		 11432 ID(emul); DR(rdst); SC(IMMex(im));
11433
11434 }
11435 break;
11436 case 0x70:
11437 op_semantics_102:
11438 {
11439 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
e197589b 11440#line 674 "rx-decode.opc"
a117b0a5 11441 int im AU = (op[1] >> 2) & 0x03;
e197589b 11442#line 674 "rx-decode.opc"
a117b0a5
YS		 11443 int rdst AU = op[2] & 0x0f;
11444 if (trace)
11445 {
11446 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11447 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
11448 op[0], op[1], op[2]);
11449 printf (" im = 0x%x,", im);
11450 printf (" rdst = 0x%x\n", rdst);
11451 }
11452 SYNTAX("emulu #%1, %0");
e197589b 11453#line 674 "rx-decode.opc"
a117b0a5
YS		 11454 ID(emulu); DR(rdst); SC(IMMex(im));
11455
11456 }
11457 break;
11458 case 0x80:
11459 op_semantics_103:
11460 {
11461 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
e197589b 11462#line 686 "rx-decode.opc"
a117b0a5 11463 int im AU = (op[1] >> 2) & 0x03;
e197589b 11464#line 686 "rx-decode.opc"
a117b0a5
YS		 11465 int rdst AU = op[2] & 0x0f;
11466 if (trace)
11467 {
11468 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11469 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
11470 op[0], op[1], op[2]);
11471 printf (" im = 0x%x,", im);
11472 printf (" rdst = 0x%x\n", rdst);
11473 }
11474 SYNTAX("div #%1, %0");
e197589b 11475#line 686 "rx-decode.opc"
a117b0a5
YS		 11476 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11477
11478 }
11479 break;
11480 case 0x90:
11481 op_semantics_104:
11482 {
11483 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
e197589b 11484#line 698 "rx-decode.opc"
a117b0a5 11485 int im AU = (op[1] >> 2) & 0x03;
e197589b 11486#line 698 "rx-decode.opc"
a117b0a5
YS		 11487 int rdst AU = op[2] & 0x0f;
11488 if (trace)
11489 {
11490 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11491 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
11492 op[0], op[1], op[2]);
11493 printf (" im = 0x%x,", im);
11494 printf (" rdst = 0x%x\n", rdst);
11495 }
11496 SYNTAX("divu #%1, %0");
e197589b 11497#line 698 "rx-decode.opc"
a117b0a5
YS		 11498 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11499
11500 }
11501 break;
11502 case 0xc0:
11503 op_semantics_105:
11504 {
11505 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
e197589b 11506#line 471 "rx-decode.opc"
a117b0a5 11507 int im AU = (op[1] >> 2) & 0x03;
e197589b 11508#line 471 "rx-decode.opc"
a117b0a5
YS		 11509 int rdst AU = op[2] & 0x0f;
11510 if (trace)
11511 {
11512 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11513 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
11514 op[0], op[1], op[2]);
11515 printf (" im = 0x%x,", im);
11516 printf (" rdst = 0x%x\n", rdst);
11517 }
11518 SYNTAX("tst #%1, %2");
e197589b 11519#line 471 "rx-decode.opc"
a117b0a5
YS		 11520 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11521
11522 }
11523 break;
11524 case 0xd0:
11525 op_semantics_106:
11526 {
11527 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
e197589b 11528#line 450 "rx-decode.opc"
a117b0a5 11529 int im AU = (op[1] >> 2) & 0x03;
e197589b 11530#line 450 "rx-decode.opc"
a117b0a5
YS		 11531 int rdst AU = op[2] & 0x0f;
11532 if (trace)
11533 {
11534 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11535 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
11536 op[0], op[1], op[2]);
11537 printf (" im = 0x%x,", im);
11538 printf (" rdst = 0x%x\n", rdst);
11539 }
11540 SYNTAX("xor #%1, %0");
e197589b 11541#line 450 "rx-decode.opc"
a117b0a5
YS		 11542 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11543
11544 }
11545 break;
11546 case 0xe0:
11547 op_semantics_107:
11548 {
11549 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
e197589b 11550#line 396 "rx-decode.opc"
a117b0a5 11551 int im AU = (op[1] >> 2) & 0x03;
e197589b 11552#line 396 "rx-decode.opc"
a117b0a5
YS		 11553 int rdst AU = op[2] & 0x0f;
11554 if (trace)
11555 {
11556 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11557 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
11558 op[0], op[1], op[2]);
11559 printf (" im = 0x%x,", im);
11560 printf (" rdst = 0x%x\n", rdst);
11561 }
11562 SYNTAX("stz #%1, %0");
e197589b 11563#line 396 "rx-decode.opc"
a117b0a5
YS		 11564 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11565
11566 }
11567 break;
11568 case 0xf0:
11569 op_semantics_108:
11570 {
11571 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
e197589b 11572#line 399 "rx-decode.opc"
a117b0a5 11573 int im AU = (op[1] >> 2) & 0x03;
e197589b 11574#line 399 "rx-decode.opc"
a117b0a5
YS		 11575 int rdst AU = op[2] & 0x0f;
11576 if (trace)
11577 {
11578 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11579 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
11580 op[0], op[1], op[2]);
11581 printf (" im = 0x%x,", im);
11582 printf (" rdst = 0x%x\n", rdst);
11583 }
11584 SYNTAX("stnz #%1, %0");
e197589b 11585#line 399 "rx-decode.opc"
a117b0a5
YS		 11586 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11587
11588 /*----------------------------------------------------------------------*/
11589 /* RTSD */
11590
11591 }
11592 break;
11593 default: UNSUPPORTED(); break;
11594 }
11595 break;
11596 case 0x72:
11597 GETBYTE ();
11598 switch (op[2] & 0xf0)
11599 {
11600 case 0x00:
11601 {
11602 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
e197589b 11603#line 906 "rx-decode.opc"
a117b0a5
YS		 11604 int rdst AU = op[2] & 0x0f;
11605 if (trace)
11606 {
11607 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11608 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
11609 op[0], op[1], op[2]);
11610 printf (" rdst = 0x%x\n", rdst);
11611 }
11612 SYNTAX("fsub #%1, %0");
e197589b 11613#line 906 "rx-decode.opc"
a117b0a5
YS		 11614 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11615
11616 }
11617 break;
11618 case 0x10:
11619 {
11620 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
e197589b 11621#line 900 "rx-decode.opc"
a117b0a5
YS		 11622 int rdst AU = op[2] & 0x0f;
11623 if (trace)
11624 {
11625 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11626 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
11627 op[0], op[1], op[2]);
11628 printf (" rdst = 0x%x\n", rdst);
11629 }
11630 SYNTAX("fcmp #%1, %0");
e197589b 11631#line 900 "rx-decode.opc"
a117b0a5
YS		 11632 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11633
11634 }
11635 break;
11636 case 0x20:
11637 {
11638 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
e197589b 11639#line 894 "rx-decode.opc"
a117b0a5
YS		 11640 int rdst AU = op[2] & 0x0f;
11641 if (trace)
11642 {
11643 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11644 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
11645 op[0], op[1], op[2]);
11646 printf (" rdst = 0x%x\n", rdst);
11647 }
11648 SYNTAX("fadd #%1, %0");
e197589b 11649#line 894 "rx-decode.opc"
a117b0a5
YS		 11650 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11651
11652 }
11653 break;
11654 case 0x30:
11655 {
11656 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
e197589b 11657#line 915 "rx-decode.opc"
a117b0a5
YS		 11658 int rdst AU = op[2] & 0x0f;
11659 if (trace)
11660 {
11661 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
c7927a3c
NC		 11662 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
11663 op[0], op[1], op[2]);
11664 printf (" rdst = 0x%x\n", rdst);
11665 }
11666 SYNTAX("fmul #%1, %0");
e197589b 11667#line 915 "rx-decode.opc"
3cf79a01 11668 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
43e65147 11669
c7927a3c
NC		 11670 }
11671 break;
11672 case 0x40:
11673 {
11674 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
e197589b 11675#line 921 "rx-decode.opc"
c7927a3c
NC		 11676 int rdst AU = op[2] & 0x0f;
11677 if (trace)
11678 {
11679 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11680 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
11681 op[0], op[1], op[2]);
11682 printf (" rdst = 0x%x\n", rdst);
11683 }
11684 SYNTAX("fdiv #%1, %0");
e197589b 11685#line 921 "rx-decode.opc"
3cf79a01 11686 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
43e65147 11687
c7927a3c
NC		 11688 }
11689 break;
11690 default: UNSUPPORTED(); break;
11691 }
11692 break;
11693 case 0x73:
11694 GETBYTE ();
11695 switch (op[2] & 0xe0)
11696 {
11697 case 0x00:
a117b0a5 11698 op_semantics_109:
c7927a3c
NC		 11699 {
11700 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
e197589b 11701#line 1011 "rx-decode.opc"
c7927a3c 11702 int im AU = (op[1] >> 2) & 0x03;
e197589b 11703#line 1011 "rx-decode.opc"
c7927a3c
NC		 11704 int crdst AU = op[2] & 0x1f;
11705 if (trace)
11706 {
11707 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11708 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
11709 op[0], op[1], op[2]);
11710 printf (" im = 0x%x,", im);
11711 printf (" crdst = 0x%x\n", crdst);
11712 }
11713 SYNTAX("mvtc #%1, %0");
e197589b 11714#line 1011 "rx-decode.opc"
c7927a3c 11715 ID(mov); SC(IMMex(im)); DR(crdst + 16);
43e65147 11716
c7927a3c
NC		 11717 }
11718 break;
11719 default: UNSUPPORTED(); break;
11720 }
11721 break;
11722 case 0x74:
11723 GETBYTE ();
11724 switch (op[2] & 0xf0)
11725 {
11726 case 0x20:
a117b0a5 11727 goto op_semantics_98;
c7927a3c
NC		 11728 break;
11729 case 0x40:
a117b0a5 11730 goto op_semantics_99;
c7927a3c
NC		 11731 break;
11732 case 0x50:
a117b0a5 11733 goto op_semantics_100;
c7927a3c
NC		 11734 break;
11735 case 0x60:
a117b0a5 11736 goto op_semantics_101;
c7927a3c
NC		 11737 break;
11738 case 0x70:
a117b0a5 11739 goto op_semantics_102;
c7927a3c
NC		 11740 break;
11741 case 0x80:
a117b0a5 11742 goto op_semantics_103;
c7927a3c
NC		 11743 break;
11744 case 0x90:
a117b0a5 11745 goto op_semantics_104;
c7927a3c
NC		 11746 break;
11747 case 0xc0:
a117b0a5 11748 goto op_semantics_105;
c7927a3c
NC		 11749 break;
11750 case 0xd0:
a117b0a5 11751 goto op_semantics_106;
c7927a3c
NC		 11752 break;
11753 case 0xe0:
a117b0a5 11754 goto op_semantics_107;
c7927a3c
NC		 11755 break;
11756 case 0xf0:
a117b0a5 11757 goto op_semantics_108;
c7927a3c
NC		 11758 break;
11759 default: UNSUPPORTED(); break;
11760 }
11761 break;
11762 case 0x77:
11763 GETBYTE ();
11764 switch (op[2] & 0xe0)
11765 {
11766 case 0x00:
a117b0a5 11767 goto op_semantics_109;
c7927a3c
NC		 11768 break;
11769 default: UNSUPPORTED(); break;
11770 }
11771 break;
11772 case 0x78:
11773 GETBYTE ();
11774 switch (op[2] & 0xf0)
11775 {
11776 case 0x20:
a117b0a5 11777 goto op_semantics_98;
c7927a3c
NC		 11778 break;
11779 case 0x40:
a117b0a5 11780 goto op_semantics_99;
c7927a3c
NC		 11781 break;
11782 case 0x50:
a117b0a5 11783 goto op_semantics_100;
c7927a3c
NC		 11784 break;
11785 case 0x60:
a117b0a5 11786 goto op_semantics_101;
c7927a3c
NC		 11787 break;
11788 case 0x70:
a117b0a5 11789 goto op_semantics_102;
c7927a3c
NC		 11790 break;
11791 case 0x80:
a117b0a5 11792 goto op_semantics_103;
c7927a3c
NC		 11793 break;
11794 case 0x90:
a117b0a5 11795 goto op_semantics_104;
c7927a3c
NC		 11796 break;
11797 case 0xc0:
a117b0a5 11798 goto op_semantics_105;
c7927a3c
NC		 11799 break;
11800 case 0xd0:
a117b0a5 11801 goto op_semantics_106;
c7927a3c
NC		 11802 break;
11803 case 0xe0:
a117b0a5 11804 goto op_semantics_107;
c7927a3c
NC		 11805 break;
11806 case 0xf0:
a117b0a5 11807 goto op_semantics_108;
c7927a3c
NC		 11808 break;
11809 default: UNSUPPORTED(); break;
11810 }
11811 break;
11812 case 0x7b:
11813 GETBYTE ();
11814 switch (op[2] & 0xe0)
11815 {
11816 case 0x00:
a117b0a5 11817 goto op_semantics_109;
c7927a3c
NC		 11818 break;
11819 default: UNSUPPORTED(); break;
11820 }
11821 break;
11822 case 0x7c:
11823 GETBYTE ();
11824 switch (op[2] & 0xf0)
11825 {
11826 case 0x20:
a117b0a5 11827 goto op_semantics_98;
c7927a3c
NC		 11828 break;
11829 case 0x40:
a117b0a5 11830 goto op_semantics_99;
c7927a3c
NC		 11831 break;
11832 case 0x50:
a117b0a5 11833 goto op_semantics_100;
c7927a3c
NC		 11834 break;
11835 case 0x60:
a117b0a5 11836 goto op_semantics_101;
c7927a3c
NC		 11837 break;
11838 case 0x70:
a117b0a5 11839 goto op_semantics_102;
c7927a3c
NC		 11840 break;
11841 case 0x80:
a117b0a5 11842 goto op_semantics_103;
c7927a3c
NC		 11843 break;
11844 case 0x90:
a117b0a5 11845 goto op_semantics_104;
c7927a3c
NC		 11846 break;
11847 case 0xc0:
a117b0a5 11848 goto op_semantics_105;
c7927a3c
NC		 11849 break;
11850 case 0xd0:
a117b0a5 11851 goto op_semantics_106;
c7927a3c
NC		 11852 break;
11853 case 0xe0:
a117b0a5 11854 goto op_semantics_107;
c7927a3c
NC		 11855 break;
11856 case 0xf0:
a117b0a5 11857 goto op_semantics_108;
c7927a3c
NC		 11858 break;
11859 default: UNSUPPORTED(); break;
11860 }
11861 break;
11862 case 0x7f:
11863 GETBYTE ();
11864 switch (op[2] & 0xe0)
11865 {
11866 case 0x00:
a117b0a5 11867 goto op_semantics_109;
c7927a3c
NC		 11868 break;
11869 default: UNSUPPORTED(); break;
11870 }
11871 break;
11872 case 0x80:
11873 GETBYTE ();
11874 switch (op[2] & 0x00)
11875 {
11876 case 0x00:
a117b0a5 11877 op_semantics_110:
c7927a3c
NC		 11878 {
11879 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
e197589b 11880#line 736 "rx-decode.opc"
c7927a3c 11881 int immmm AU = op[1] & 0x1f;
e197589b 11882#line 736 "rx-decode.opc"
c7927a3c 11883 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 11884#line 736 "rx-decode.opc"
c7927a3c
NC		 11885 int rdst AU = op[2] & 0x0f;
11886 if (trace)
11887 {
11888 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11889 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
11890 op[0], op[1], op[2]);
11891 printf (" immmm = 0x%x,", immmm);
11892 printf (" rsrc = 0x%x,", rsrc);
11893 printf (" rdst = 0x%x\n", rdst);
11894 }
11895 SYNTAX("shlr #%2, %1, %0");
e197589b 11896#line 736 "rx-decode.opc"
3cf79a01 11897 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
43e65147 11898
c7927a3c
NC		 11899 /*----------------------------------------------------------------------*/
11900 /* ROTATE */
43e65147 11901
c7927a3c
NC		 11902 }
11903 break;
11904 }
11905 break;
11906 case 0x81:
11907 GETBYTE ();
11908 switch (op[2] & 0x00)
11909 {
11910 case 0x00:
a117b0a5 11911 goto op_semantics_110;
c7927a3c
NC		 11912 break;
11913 }
11914 break;
11915 case 0x82:
11916 GETBYTE ();
11917 switch (op[2] & 0x00)
11918 {
11919 case 0x00:
a117b0a5 11920 goto op_semantics_110;
c7927a3c
NC		 11921 break;
11922 }
11923 break;
11924 case 0x83:
11925 GETBYTE ();
11926 switch (op[2] & 0x00)
11927 {
11928 case 0x00:
a117b0a5 11929 goto op_semantics_110;
c7927a3c
NC		 11930 break;
11931 }
11932 break;
11933 case 0x84:
11934 GETBYTE ();
11935 switch (op[2] & 0x00)
11936 {
11937 case 0x00:
a117b0a5 11938 goto op_semantics_110;
c7927a3c
NC		 11939 break;
11940 }
11941 break;
11942 case 0x85:
11943 GETBYTE ();
11944 switch (op[2] & 0x00)
11945 {
11946 case 0x00:
a117b0a5 11947 goto op_semantics_110;
c7927a3c
NC		 11948 break;
11949 }
11950 break;
11951 case 0x86:
11952 GETBYTE ();
11953 switch (op[2] & 0x00)
11954 {
11955 case 0x00:
a117b0a5 11956 goto op_semantics_110;
c7927a3c
NC		 11957 break;
11958 }
11959 break;
11960 case 0x87:
11961 GETBYTE ();
11962 switch (op[2] & 0x00)
11963 {
11964 case 0x00:
a117b0a5 11965 goto op_semantics_110;
c7927a3c
NC		 11966 break;
11967 }
11968 break;
11969 case 0x88:
11970 GETBYTE ();
11971 switch (op[2] & 0x00)
11972 {
11973 case 0x00:
a117b0a5 11974 goto op_semantics_110;
c7927a3c
NC		 11975 break;
11976 }
11977 break;
11978 case 0x89:
11979 GETBYTE ();
11980 switch (op[2] & 0x00)
11981 {
11982 case 0x00:
a117b0a5 11983 goto op_semantics_110;
c7927a3c
NC		 11984 break;
11985 }
11986 break;
11987 case 0x8a:
11988 GETBYTE ();
11989 switch (op[2] & 0x00)
11990 {
11991 case 0x00:
a117b0a5 11992 goto op_semantics_110;
c7927a3c
NC		 11993 break;
11994 }
11995 break;
11996 case 0x8b:
11997 GETBYTE ();
11998 switch (op[2] & 0x00)
11999 {
12000 case 0x00:
a117b0a5 12001 goto op_semantics_110;
c7927a3c
NC		 12002 break;
12003 }
12004 break;
12005 case 0x8c:
12006 GETBYTE ();
12007 switch (op[2] & 0x00)
12008 {
12009 case 0x00:
a117b0a5 12010 goto op_semantics_110;
c7927a3c
NC		 12011 break;
12012 }
12013 break;
12014 case 0x8d:
12015 GETBYTE ();
12016 switch (op[2] & 0x00)
12017 {
12018 case 0x00:
a117b0a5 12019 goto op_semantics_110;
c7927a3c
NC		 12020 break;
12021 }
12022 break;
12023 case 0x8e:
12024 GETBYTE ();
12025 switch (op[2] & 0x00)
12026 {
12027 case 0x00:
a117b0a5 12028 goto op_semantics_110;
c7927a3c
NC		 12029 break;
12030 }
12031 break;
12032 case 0x8f:
12033 GETBYTE ();
12034 switch (op[2] & 0x00)
12035 {
12036 case 0x00:
a117b0a5 12037 goto op_semantics_110;
c7927a3c
NC		 12038 break;
12039 }
12040 break;
12041 case 0x90:
12042 GETBYTE ();
12043 switch (op[2] & 0x00)
12044 {
12045 case 0x00:
a117b0a5 12046 goto op_semantics_110;
c7927a3c
NC		 12047 break;
12048 }
12049 break;
12050 case 0x91:
12051 GETBYTE ();
12052 switch (op[2] & 0x00)
12053 {
12054 case 0x00:
a117b0a5 12055 goto op_semantics_110;
c7927a3c
NC		 12056 break;
12057 }
12058 break;
12059 case 0x92:
12060 GETBYTE ();
12061 switch (op[2] & 0x00)
12062 {
12063 case 0x00:
a117b0a5 12064 goto op_semantics_110;
c7927a3c
NC		 12065 break;
12066 }
12067 break;
12068 case 0x93:
12069 GETBYTE ();
12070 switch (op[2] & 0x00)
12071 {
12072 case 0x00:
a117b0a5 12073 goto op_semantics_110;
c7927a3c
NC		 12074 break;
12075 }
12076 break;
12077 case 0x94:
12078 GETBYTE ();
12079 switch (op[2] & 0x00)
12080 {
12081 case 0x00:
a117b0a5 12082 goto op_semantics_110;
c7927a3c
NC		 12083 break;
12084 }
12085 break;
12086 case 0x95:
12087 GETBYTE ();
12088 switch (op[2] & 0x00)
12089 {
12090 case 0x00:
a117b0a5 12091 goto op_semantics_110;
c7927a3c
NC		 12092 break;
12093 }
12094 break;
12095 case 0x96:
12096 GETBYTE ();
12097 switch (op[2] & 0x00)
12098 {
12099 case 0x00:
a117b0a5 12100 goto op_semantics_110;
c7927a3c
NC		 12101 break;
12102 }
12103 break;
12104 case 0x97:
12105 GETBYTE ();
12106 switch (op[2] & 0x00)
12107 {
12108 case 0x00:
a117b0a5 12109 goto op_semantics_110;
c7927a3c
NC		 12110 break;
12111 }
12112 break;
12113 case 0x98:
12114 GETBYTE ();
12115 switch (op[2] & 0x00)
12116 {
12117 case 0x00:
a117b0a5 12118 goto op_semantics_110;
c7927a3c
NC		 12119 break;
12120 }
12121 break;
12122 case 0x99:
12123 GETBYTE ();
12124 switch (op[2] & 0x00)
12125 {
12126 case 0x00:
a117b0a5 12127 goto op_semantics_110;
c7927a3c
NC		 12128 break;
12129 }
12130 break;
12131 case 0x9a:
12132 GETBYTE ();
12133 switch (op[2] & 0x00)
12134 {
12135 case 0x00:
a117b0a5 12136 goto op_semantics_110;
c7927a3c
NC		 12137 break;
12138 }
12139 break;
12140 case 0x9b:
12141 GETBYTE ();
12142 switch (op[2] & 0x00)
12143 {
12144 case 0x00:
a117b0a5 12145 goto op_semantics_110;
c7927a3c
NC		 12146 break;
12147 }
12148 break;
12149 case 0x9c:
12150 GETBYTE ();
12151 switch (op[2] & 0x00)
12152 {
12153 case 0x00:
a117b0a5 12154 goto op_semantics_110;
c7927a3c
NC		 12155 break;
12156 }
12157 break;
12158 case 0x9d:
12159 GETBYTE ();
12160 switch (op[2] & 0x00)
12161 {
12162 case 0x00:
a117b0a5 12163 goto op_semantics_110;
c7927a3c
NC		 12164 break;
12165 }
12166 break;
12167 case 0x9e:
12168 GETBYTE ();
12169 switch (op[2] & 0x00)
12170 {
12171 case 0x00:
a117b0a5 12172 goto op_semantics_110;
c7927a3c
NC		 12173 break;
12174 }
12175 break;
12176 case 0x9f:
12177 GETBYTE ();
12178 switch (op[2] & 0x00)
12179 {
12180 case 0x00:
a117b0a5 12181 goto op_semantics_110;
c7927a3c
NC		 12182 break;
12183 }
12184 break;
12185 case 0xa0:
12186 GETBYTE ();
12187 switch (op[2] & 0x00)
12188 {
12189 case 0x00:
a117b0a5 12190 op_semantics_111:
c7927a3c
NC		 12191 {
12192 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
e197589b 12193#line 726 "rx-decode.opc"
c7927a3c 12194 int immmm AU = op[1] & 0x1f;
e197589b 12195#line 726 "rx-decode.opc"
c7927a3c 12196 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 12197#line 726 "rx-decode.opc"
c7927a3c
NC		 12198 int rdst AU = op[2] & 0x0f;
12199 if (trace)
12200 {
12201 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12202 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
12203 op[0], op[1], op[2]);
12204 printf (" immmm = 0x%x,", immmm);
12205 printf (" rsrc = 0x%x,", rsrc);
12206 printf (" rdst = 0x%x\n", rdst);
12207 }
12208 SYNTAX("shar #%2, %1, %0");
e197589b 12209#line 726 "rx-decode.opc"
3cf79a01 12210 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
43e65147
L		 12211
12212
c7927a3c
NC		 12213 }
12214 break;
12215 }
12216 break;
12217 case 0xa1:
12218 GETBYTE ();
12219 switch (op[2] & 0x00)
12220 {
12221 case 0x00:
a117b0a5 12222 goto op_semantics_111;
c7927a3c
NC		 12223 break;
12224 }
12225 break;
12226 case 0xa2:
12227 GETBYTE ();
12228 switch (op[2] & 0x00)
12229 {
12230 case 0x00:
a117b0a5 12231 goto op_semantics_111;
c7927a3c
NC		 12232 break;
12233 }
12234 break;
12235 case 0xa3:
12236 GETBYTE ();
12237 switch (op[2] & 0x00)
12238 {
12239 case 0x00:
a117b0a5 12240 goto op_semantics_111;
c7927a3c
NC		 12241 break;
12242 }
12243 break;
12244 case 0xa4:
12245 GETBYTE ();
12246 switch (op[2] & 0x00)
12247 {
12248 case 0x00:
a117b0a5 12249 goto op_semantics_111;
c7927a3c
NC		 12250 break;
12251 }
12252 break;
12253 case 0xa5:
12254 GETBYTE ();
12255 switch (op[2] & 0x00)
12256 {
12257 case 0x00:
a117b0a5 12258 goto op_semantics_111;
c7927a3c
NC		 12259 break;
12260 }
12261 break;
12262 case 0xa6:
12263 GETBYTE ();
12264 switch (op[2] & 0x00)
12265 {
12266 case 0x00:
a117b0a5 12267 goto op_semantics_111;
c7927a3c
NC		 12268 break;
12269 }
12270 break;
12271 case 0xa7:
12272 GETBYTE ();
12273 switch (op[2] & 0x00)
12274 {
12275 case 0x00:
a117b0a5 12276 goto op_semantics_111;
c7927a3c
NC		 12277 break;
12278 }
12279 break;
12280 case 0xa8:
12281 GETBYTE ();
12282 switch (op[2] & 0x00)
12283 {
12284 case 0x00:
a117b0a5 12285 goto op_semantics_111;
c7927a3c
NC		 12286 break;
12287 }
12288 break;
12289 case 0xa9:
12290 GETBYTE ();
12291 switch (op[2] & 0x00)
12292 {
12293 case 0x00:
a117b0a5 12294 goto op_semantics_111;
c7927a3c
NC		 12295 break;
12296 }
12297 break;
12298 case 0xaa:
12299 GETBYTE ();
12300 switch (op[2] & 0x00)
12301 {
12302 case 0x00:
a117b0a5 12303 goto op_semantics_111;
c7927a3c
NC		 12304 break;
12305 }
12306 break;
12307 case 0xab:
12308 GETBYTE ();
12309 switch (op[2] & 0x00)
12310 {
12311 case 0x00:
a117b0a5 12312 goto op_semantics_111;
c7927a3c
NC		 12313 break;
12314 }
12315 break;
12316 case 0xac:
12317 GETBYTE ();
12318 switch (op[2] & 0x00)
12319 {
12320 case 0x00:
a117b0a5 12321 goto op_semantics_111;
c7927a3c
NC		 12322 break;
12323 }
12324 break;
12325 case 0xad:
12326 GETBYTE ();
12327 switch (op[2] & 0x00)
12328 {
12329 case 0x00:
a117b0a5 12330 goto op_semantics_111;
c7927a3c
NC		 12331 break;
12332 }
12333 break;
12334 case 0xae:
12335 GETBYTE ();
12336 switch (op[2] & 0x00)
12337 {
12338 case 0x00:
a117b0a5 12339 goto op_semantics_111;
c7927a3c
NC		 12340 break;
12341 }
12342 break;
12343 case 0xaf:
12344 GETBYTE ();
12345 switch (op[2] & 0x00)
12346 {
12347 case 0x00:
a117b0a5 12348 goto op_semantics_111;
c7927a3c
NC		 12349 break;
12350 }
12351 break;
12352 case 0xb0:
12353 GETBYTE ();
12354 switch (op[2] & 0x00)
12355 {
12356 case 0x00:
a117b0a5 12357 goto op_semantics_111;
c7927a3c
NC		 12358 break;
12359 }
12360 break;
12361 case 0xb1:
12362 GETBYTE ();
12363 switch (op[2] & 0x00)
12364 {
12365 case 0x00:
a117b0a5 12366 goto op_semantics_111;
c7927a3c
NC		 12367 break;
12368 }
12369 break;
12370 case 0xb2:
12371 GETBYTE ();
12372 switch (op[2] & 0x00)
12373 {
12374 case 0x00:
a117b0a5 12375 goto op_semantics_111;
c7927a3c
NC		 12376 break;
12377 }
12378 break;
12379 case 0xb3:
12380 GETBYTE ();
12381 switch (op[2] & 0x00)
12382 {
12383 case 0x00:
a117b0a5 12384 goto op_semantics_111;
c7927a3c
NC		 12385 break;
12386 }
12387 break;
12388 case 0xb4:
12389 GETBYTE ();
12390 switch (op[2] & 0x00)
12391 {
12392 case 0x00:
a117b0a5 12393 goto op_semantics_111;
c7927a3c
NC		 12394 break;
12395 }
12396 break;
12397 case 0xb5:
12398 GETBYTE ();
12399 switch (op[2] & 0x00)
12400 {
12401 case 0x00:
a117b0a5 12402 goto op_semantics_111;
c7927a3c
NC		 12403 break;
12404 }
12405 break;
12406 case 0xb6:
12407 GETBYTE ();
12408 switch (op[2] & 0x00)
12409 {
12410 case 0x00:
a117b0a5 12411 goto op_semantics_111;
c7927a3c
NC		 12412 break;
12413 }
12414 break;
12415 case 0xb7:
12416 GETBYTE ();
12417 switch (op[2] & 0x00)
12418 {
12419 case 0x00:
a117b0a5 12420 goto op_semantics_111;
c7927a3c
NC		 12421 break;
12422 }
12423 break;
12424 case 0xb8:
12425 GETBYTE ();
12426 switch (op[2] & 0x00)
12427 {
12428 case 0x00:
a117b0a5 12429 goto op_semantics_111;
c7927a3c
NC		 12430 break;
12431 }
12432 break;
12433 case 0xb9:
12434 GETBYTE ();
12435 switch (op[2] & 0x00)
12436 {
12437 case 0x00:
a117b0a5 12438 goto op_semantics_111;
c7927a3c
NC		 12439 break;
12440 }
12441 break;
12442 case 0xba:
12443 GETBYTE ();
12444 switch (op[2] & 0x00)
12445 {
12446 case 0x00:
a117b0a5 12447 goto op_semantics_111;
c7927a3c
NC		 12448 break;
12449 }
12450 break;
12451 case 0xbb:
12452 GETBYTE ();
12453 switch (op[2] & 0x00)
12454 {
12455 case 0x00:
a117b0a5 12456 goto op_semantics_111;
c7927a3c
NC		 12457 break;
12458 }
12459 break;
12460 case 0xbc:
12461 GETBYTE ();
12462 switch (op[2] & 0x00)
12463 {
12464 case 0x00:
a117b0a5 12465 goto op_semantics_111;
c7927a3c
NC		 12466 break;
12467 }
12468 break;
12469 case 0xbd:
12470 GETBYTE ();
12471 switch (op[2] & 0x00)
12472 {
12473 case 0x00:
a117b0a5 12474 goto op_semantics_111;
c7927a3c
NC		 12475 break;
12476 }
12477 break;
12478 case 0xbe:
12479 GETBYTE ();
12480 switch (op[2] & 0x00)
12481 {
12482 case 0x00:
a117b0a5 12483 goto op_semantics_111;
c7927a3c
NC		 12484 break;
12485 }
12486 break;
12487 case 0xbf:
12488 GETBYTE ();
12489 switch (op[2] & 0x00)
12490 {
12491 case 0x00:
a117b0a5 12492 goto op_semantics_111;
c7927a3c
NC		 12493 break;
12494 }
12495 break;
12496 case 0xc0:
12497 GETBYTE ();
12498 switch (op[2] & 0x00)
12499 {
12500 case 0x00:
a117b0a5 12501 op_semantics_112:
c7927a3c
NC		 12502 {
12503 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
e197589b 12504#line 716 "rx-decode.opc"
c7927a3c 12505 int immmm AU = op[1] & 0x1f;
e197589b 12506#line 716 "rx-decode.opc"
c7927a3c 12507 int rsrc AU = (op[2] >> 4) & 0x0f;
e197589b 12508#line 716 "rx-decode.opc"
c7927a3c
NC		 12509 int rdst AU = op[2] & 0x0f;
12510 if (trace)
12511 {
12512 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12513 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
12514 op[0], op[1], op[2]);
12515 printf (" immmm = 0x%x,", immmm);
12516 printf (" rsrc = 0x%x,", rsrc);
12517 printf (" rdst = 0x%x\n", rdst);
12518 }
12519 SYNTAX("shll #%2, %1, %0");
e197589b 12520#line 716 "rx-decode.opc"
3cf79a01 12521 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
43e65147
L		 12522
12523
c7927a3c
NC		 12524 }
12525 break;
12526 }
12527 break;
12528 case 0xc1:
12529 GETBYTE ();
12530 switch (op[2] & 0x00)
12531 {
12532 case 0x00:
a117b0a5 12533 goto op_semantics_112;
c7927a3c
NC		 12534 break;
12535 }
12536 break;
12537 case 0xc2:
12538 GETBYTE ();
12539 switch (op[2] & 0x00)
12540 {
12541 case 0x00:
a117b0a5 12542 goto op_semantics_112;
c7927a3c
NC		 12543 break;
12544 }
12545 break;
12546 case 0xc3:
12547 GETBYTE ();
12548 switch (op[2] & 0x00)
12549 {
12550 case 0x00:
a117b0a5
YS		 12551 goto op_semantics_112;
12552 break;
12553 }
12554 break;
12555 case 0xc4:
12556 GETBYTE ();
12557 switch (op[2] & 0x00)
12558 {
12559 case 0x00:
12560 goto op_semantics_112;
12561 break;
12562 }
12563 break;
12564 case 0xc5:
12565 GETBYTE ();
12566 switch (op[2] & 0x00)
12567 {
12568 case 0x00:
12569 goto op_semantics_112;
12570 break;
12571 }
12572 break;
12573 case 0xc6:
12574 GETBYTE ();
12575 switch (op[2] & 0x00)
12576 {
12577 case 0x00:
12578 goto op_semantics_112;
12579 break;
12580 }
12581 break;
12582 case 0xc7:
12583 GETBYTE ();
12584 switch (op[2] & 0x00)
12585 {
12586 case 0x00:
12587 goto op_semantics_112;
12588 break;
12589 }
12590 break;
12591 case 0xc8:
12592 GETBYTE ();
12593 switch (op[2] & 0x00)
12594 {
12595 case 0x00:
12596 goto op_semantics_112;
12597 break;
12598 }
12599 break;
12600 case 0xc9:
12601 GETBYTE ();
12602 switch (op[2] & 0x00)
12603 {
12604 case 0x00:
12605 goto op_semantics_112;
12606 break;
12607 }
12608 break;
12609 case 0xca:
12610 GETBYTE ();
12611 switch (op[2] & 0x00)
12612 {
12613 case 0x00:
12614 goto op_semantics_112;
12615 break;
12616 }
12617 break;
12618 case 0xcb:
12619 GETBYTE ();
12620 switch (op[2] & 0x00)
12621 {
12622 case 0x00:
12623 goto op_semantics_112;
12624 break;
12625 }
12626 break;
12627 case 0xcc:
12628 GETBYTE ();
12629 switch (op[2] & 0x00)
12630 {
12631 case 0x00:
12632 goto op_semantics_112;
12633 break;
12634 }
12635 break;
12636 case 0xcd:
12637 GETBYTE ();
12638 switch (op[2] & 0x00)
12639 {
12640 case 0x00:
12641 goto op_semantics_112;
12642 break;
12643 }
12644 break;
12645 case 0xce:
12646 GETBYTE ();
12647 switch (op[2] & 0x00)
12648 {
12649 case 0x00:
12650 goto op_semantics_112;
12651 break;
12652 }
12653 break;
12654 case 0xcf:
12655 GETBYTE ();
12656 switch (op[2] & 0x00)
12657 {
12658 case 0x00:
12659 goto op_semantics_112;
12660 break;
12661 }
12662 break;
12663 case 0xd0:
12664 GETBYTE ();
12665 switch (op[2] & 0x00)
12666 {
12667 case 0x00:
12668 goto op_semantics_112;
12669 break;
12670 }
12671 break;
12672 case 0xd1:
12673 GETBYTE ();
12674 switch (op[2] & 0x00)
12675 {
12676 case 0x00:
12677 goto op_semantics_112;
12678 break;
12679 }
12680 break;
12681 case 0xd2:
12682 GETBYTE ();
12683 switch (op[2] & 0x00)
12684 {
12685 case 0x00:
12686 goto op_semantics_112;
12687 break;
12688 }
12689 break;
12690 case 0xd3:
12691 GETBYTE ();
12692 switch (op[2] & 0x00)
12693 {
12694 case 0x00:
12695 goto op_semantics_112;
12696 break;
12697 }
12698 break;
12699 case 0xd4:
12700 GETBYTE ();
12701 switch (op[2] & 0x00)
12702 {
12703 case 0x00:
12704 goto op_semantics_112;
c7927a3c
NC		 12705 break;
12706 }
12707 break;
a117b0a5 12708 case 0xd5:
c7927a3c
NC		 12709 GETBYTE ();
12710 switch (op[2] & 0x00)
12711 {
12712 case 0x00:
a117b0a5 12713 goto op_semantics_112;
c7927a3c
NC		 12714 break;
12715 }
12716 break;
a117b0a5 12717 case 0xd6:
c7927a3c
NC		 12718 GETBYTE ();
12719 switch (op[2] & 0x00)
12720 {
12721 case 0x00:
a117b0a5 12722 goto op_semantics_112;
c7927a3c
NC		 12723 break;
12724 }
12725 break;
a117b0a5 12726 case 0xd7:
c7927a3c
NC		 12727 GETBYTE ();
12728 switch (op[2] & 0x00)
12729 {
12730 case 0x00:
a117b0a5 12731 goto op_semantics_112;
c7927a3c
NC		 12732 break;
12733 }
12734 break;
a117b0a5 12735 case 0xd8:
c7927a3c
NC		 12736 GETBYTE ();
12737 switch (op[2] & 0x00)
12738 {
12739 case 0x00:
a117b0a5 12740 goto op_semantics_112;
c7927a3c
NC		 12741 break;
12742 }
12743 break;
a117b0a5 12744 case 0xd9:
c7927a3c
NC		 12745 GETBYTE ();
12746 switch (op[2] & 0x00)
12747 {
12748 case 0x00:
a117b0a5 12749 goto op_semantics_112;
c7927a3c
NC		 12750 break;
12751 }
12752 break;
a117b0a5 12753 case 0xda:
c7927a3c
NC		 12754 GETBYTE ();
12755 switch (op[2] & 0x00)
12756 {
12757 case 0x00:
a117b0a5 12758 goto op_semantics_112;
c7927a3c
NC		 12759 break;
12760 }
12761 break;
a117b0a5 12762 case 0xdb:
c7927a3c
NC		 12763 GETBYTE ();
12764 switch (op[2] & 0x00)
12765 {
12766 case 0x00:
a117b0a5 12767 goto op_semantics_112;
c7927a3c
NC		 12768 break;
12769 }
12770 break;
a117b0a5 12771 case 0xdc:
c7927a3c
NC		 12772 GETBYTE ();
12773 switch (op[2] & 0x00)
12774 {
12775 case 0x00:
a117b0a5 12776 goto op_semantics_112;
c7927a3c
NC		 12777 break;
12778 }
12779 break;
a117b0a5 12780 case 0xdd:
c7927a3c
NC		 12781 GETBYTE ();
12782 switch (op[2] & 0x00)
12783 {
12784 case 0x00:
a117b0a5 12785 goto op_semantics_112;
c7927a3c
NC		 12786 break;
12787 }
12788 break;
a117b0a5 12789 case 0xde:
c7927a3c
NC		 12790 GETBYTE ();
12791 switch (op[2] & 0x00)
12792 {
12793 case 0x00:
a117b0a5 12794 goto op_semantics_112;
c7927a3c
NC		 12795 break;
12796 }
12797 break;
a117b0a5 12798 case 0xdf:
c7927a3c
NC		 12799 GETBYTE ();
12800 switch (op[2] & 0x00)
12801 {
12802 case 0x00:
a117b0a5 12803 goto op_semantics_112;
c7927a3c
NC		 12804 break;
12805 }
12806 break;
a117b0a5 12807 case 0xe0:
c7927a3c 12808 GETBYTE ();
a117b0a5 12809 switch (op[2] & 0xf0)
c7927a3c
NC		 12810 {
12811 case 0x00:
a117b0a5
YS		 12812 case 0x10:
12813 case 0x20:
12814 case 0x30:
12815 case 0x40:
12816 case 0x50:
12817 case 0x60:
12818 case 0x70:
12819 case 0x80:
12820 case 0x90:
12821 case 0xa0:
12822 case 0xb0:
12823 case 0xc0:
12824 case 0xd0:
12825 case 0xe0:
12826 op_semantics_113:
12827 {
12828 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
e197589b 12829#line 990 "rx-decode.opc"
a117b0a5 12830 int bittt AU = op[1] & 0x1f;
e197589b 12831#line 990 "rx-decode.opc"
a117b0a5 12832 int cond AU = (op[2] >> 4) & 0x0f;
e197589b 12833#line 990 "rx-decode.opc"
a117b0a5
YS		 12834 int rdst AU = op[2] & 0x0f;
12835 if (trace)
12836 {
12837 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12838 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
12839 op[0], op[1], op[2]);
12840 printf (" bittt = 0x%x,", bittt);
12841 printf (" cond = 0x%x,", cond);
12842 printf (" rdst = 0x%x\n", rdst);
12843 }
12844 SYNTAX("bm%2 #%1, %0%S0");
e197589b 12845#line 990 "rx-decode.opc"
a117b0a5
YS		 12846 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12847
12848 /*----------------------------------------------------------------------*/
12849 /* CONTROL REGISTERS */
12850
12851 }
12852 break;
12853 case 0xf0:
12854 op_semantics_114:
12855 {
12856 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
e197589b 12857#line 983 "rx-decode.opc"
a117b0a5 12858 int bittt AU = op[1] & 0x1f;
e197589b 12859#line 983 "rx-decode.opc"
a117b0a5
YS		 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 111bittt 1111 rdst bnot #%1, %0 */",
12865 op[0], op[1], op[2]);
12866 printf (" bittt = 0x%x,", bittt);
12867 printf (" rdst = 0x%x\n", rdst);
12868 }
12869 SYNTAX("bnot #%1, %0");
e197589b 12870#line 983 "rx-decode.opc"
a117b0a5
YS		 12871 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12872
12873
12874 }
c7927a3c
NC		 12875 break;
12876 }
12877 break;
a117b0a5 12878 case 0xe1:
c7927a3c 12879 GETBYTE ();
a117b0a5 12880 switch (op[2] & 0xf0)
c7927a3c
NC		 12881 {
12882 case 0x00:
a117b0a5
YS		 12883 case 0x10:
12884 case 0x20:
12885 case 0x30:
12886 case 0x40:
12887 case 0x50:
12888 case 0x60:
12889 case 0x70:
12890 case 0x80:
12891 case 0x90:
12892 case 0xa0:
12893 case 0xb0:
12894 case 0xc0:
12895 case 0xd0:
12896 case 0xe0:
12897 goto op_semantics_113;
12898 break;
12899 case 0xf0:
12900 goto op_semantics_114;
c7927a3c
NC		 12901 break;
12902 }
12903 break;
a117b0a5 12904 case 0xe2:
c7927a3c 12905 GETBYTE ();
a117b0a5 12906 switch (op[2] & 0xf0)
c7927a3c
NC		 12907 {
12908 case 0x00:
a117b0a5
YS		 12909 case 0x10:
12910 case 0x20:
12911 case 0x30:
12912 case 0x40:
12913 case 0x50:
12914 case 0x60:
12915 case 0x70:
12916 case 0x80:
12917 case 0x90:
12918 case 0xa0:
12919 case 0xb0:
12920 case 0xc0:
12921 case 0xd0:
12922 case 0xe0:
12923 goto op_semantics_113;
12924 break;
12925 case 0xf0:
12926 goto op_semantics_114;
c7927a3c
NC		 12927 break;
12928 }
12929 break;
a117b0a5 12930 case 0xe3:
c7927a3c 12931 GETBYTE ();
a117b0a5 12932 switch (op[2] & 0xf0)
c7927a3c
NC		 12933 {
12934 case 0x00:
a117b0a5
YS		 12935 case 0x10:
12936 case 0x20:
12937 case 0x30:
12938 case 0x40:
12939 case 0x50:
12940 case 0x60:
12941 case 0x70:
12942 case 0x80:
12943 case 0x90:
12944 case 0xa0:
12945 case 0xb0:
12946 case 0xc0:
12947 case 0xd0:
12948 case 0xe0:
12949 goto op_semantics_113;
12950 break;
12951 case 0xf0:
12952 goto op_semantics_114;
c7927a3c
NC		 12953 break;
12954 }
12955 break;
a117b0a5 12956 case 0xe4:
c7927a3c 12957 GETBYTE ();
a117b0a5 12958 switch (op[2] & 0xf0)
c7927a3c
NC		 12959 {
12960 case 0x00:
a117b0a5
YS		 12961 case 0x10:
12962 case 0x20:
12963 case 0x30:
12964 case 0x40:
12965 case 0x50:
12966 case 0x60:
12967 case 0x70:
12968 case 0x80:
12969 case 0x90:
12970 case 0xa0:
12971 case 0xb0:
12972 case 0xc0:
12973 case 0xd0:
12974 case 0xe0:
12975 goto op_semantics_113;
12976 break;
12977 case 0xf0:
12978 goto op_semantics_114;
c7927a3c
NC		 12979 break;
12980 }
12981 break;
a117b0a5 12982 case 0xe5:
c7927a3c 12983 GETBYTE ();
a117b0a5 12984 switch (op[2] & 0xf0)
c7927a3c
NC		 12985 {
12986 case 0x00:
a117b0a5
YS		 12987 case 0x10:
12988 case 0x20:
12989 case 0x30:
12990 case 0x40:
12991 case 0x50:
12992 case 0x60:
12993 case 0x70:
12994 case 0x80:
12995 case 0x90:
12996 case 0xa0:
12997 case 0xb0:
12998 case 0xc0:
12999 case 0xd0:
13000 case 0xe0:
13001 goto op_semantics_113;
13002 break;
13003 case 0xf0:
13004 goto op_semantics_114;
c7927a3c
NC		 13005 break;
13006 }
13007 break;
a117b0a5 13008 case 0xe6:
c7927a3c 13009 GETBYTE ();
a117b0a5 13010 switch (op[2] & 0xf0)
c7927a3c
NC		 13011 {
13012 case 0x00:
a117b0a5
YS		 13013 case 0x10:
13014 case 0x20:
13015 case 0x30:
13016 case 0x40:
13017 case 0x50:
13018 case 0x60:
13019 case 0x70:
13020 case 0x80:
13021 case 0x90:
13022 case 0xa0:
13023 case 0xb0:
13024 case 0xc0:
13025 case 0xd0:
13026 case 0xe0:
13027 goto op_semantics_113;
13028 break;
13029 case 0xf0:
13030 goto op_semantics_114;
c7927a3c
NC		 13031 break;
13032 }
13033 break;
a117b0a5 13034 case 0xe7:
c7927a3c 13035 GETBYTE ();
a117b0a5 13036 switch (op[2] & 0xf0)
c7927a3c
NC		 13037 {
13038 case 0x00:
a117b0a5
YS		 13039 case 0x10:
13040 case 0x20:
13041 case 0x30:
13042 case 0x40:
13043 case 0x50:
13044 case 0x60:
13045 case 0x70:
13046 case 0x80:
13047 case 0x90:
13048 case 0xa0:
13049 case 0xb0:
13050 case 0xc0:
13051 case 0xd0:
13052 case 0xe0:
13053 goto op_semantics_113;
13054 break;
13055 case 0xf0:
13056 goto op_semantics_114;
c7927a3c
NC		 13057 break;
13058 }
13059 break;
a117b0a5 13060 case 0xe8:
c7927a3c 13061 GETBYTE ();
a117b0a5 13062 switch (op[2] & 0xf0)
c7927a3c
NC		 13063 {
13064 case 0x00:
a117b0a5
YS		 13065 case 0x10:
13066 case 0x20:
13067 case 0x30:
13068 case 0x40:
13069 case 0x50:
13070 case 0x60:
13071 case 0x70:
13072 case 0x80:
13073 case 0x90:
13074 case 0xa0:
13075 case 0xb0:
13076 case 0xc0:
13077 case 0xd0:
13078 case 0xe0:
13079 goto op_semantics_113;
13080 break;
13081 case 0xf0:
13082 goto op_semantics_114;
c7927a3c
NC		 13083 break;
13084 }
13085 break;
a117b0a5 13086 case 0xe9:
c7927a3c 13087 GETBYTE ();
a117b0a5 13088 switch (op[2] & 0xf0)
c7927a3c
NC		 13089 {
13090 case 0x00:
a117b0a5
YS		 13091 case 0x10:
13092 case 0x20:
13093 case 0x30:
13094 case 0x40:
13095 case 0x50:
13096 case 0x60:
13097 case 0x70:
13098 case 0x80:
13099 case 0x90:
13100 case 0xa0:
13101 case 0xb0:
13102 case 0xc0:
13103 case 0xd0:
13104 case 0xe0:
13105 goto op_semantics_113;
13106 break;
13107 case 0xf0:
13108 goto op_semantics_114;
c7927a3c
NC		 13109 break;
13110 }
13111 break;
a117b0a5 13112 case 0xea:
c7927a3c 13113 GETBYTE ();
a117b0a5 13114 switch (op[2] & 0xf0)
c7927a3c
NC		 13115 {
13116 case 0x00:
a117b0a5
YS		 13117 case 0x10:
13118 case 0x20:
13119 case 0x30:
13120 case 0x40:
13121 case 0x50:
13122 case 0x60:
13123 case 0x70:
13124 case 0x80:
13125 case 0x90:
13126 case 0xa0:
13127 case 0xb0:
13128 case 0xc0:
13129 case 0xd0:
13130 case 0xe0:
13131 goto op_semantics_113;
13132 break;
13133 case 0xf0:
13134 goto op_semantics_114;
c7927a3c
NC		 13135 break;
13136 }
13137 break;
a117b0a5 13138 case 0xeb:
c7927a3c 13139 GETBYTE ();
a117b0a5 13140 switch (op[2] & 0xf0)
c7927a3c
NC		 13141 {
13142 case 0x00:
a117b0a5
YS		 13143 case 0x10:
13144 case 0x20:
13145 case 0x30:
13146 case 0x40:
13147 case 0x50:
13148 case 0x60:
13149 case 0x70:
13150 case 0x80:
13151 case 0x90:
13152 case 0xa0:
13153 case 0xb0:
13154 case 0xc0:
13155 case 0xd0:
13156 case 0xe0:
13157 goto op_semantics_113;
13158 break;
13159 case 0xf0:
13160 goto op_semantics_114;
c7927a3c
NC		 13161 break;
13162 }
13163 break;
a117b0a5 13164 case 0xec:
c7927a3c 13165 GETBYTE ();
a117b0a5 13166 switch (op[2] & 0xf0)
c7927a3c
NC		 13167 {
13168 case 0x00:
a117b0a5
YS		 13169 case 0x10:
13170 case 0x20:
13171 case 0x30:
13172 case 0x40:
13173 case 0x50:
13174 case 0x60:
13175 case 0x70:
13176 case 0x80:
13177 case 0x90:
13178 case 0xa0:
13179 case 0xb0:
13180 case 0xc0:
13181 case 0xd0:
13182 case 0xe0:
13183 goto op_semantics_113;
13184 break;
13185 case 0xf0:
13186 goto op_semantics_114;
c7927a3c
NC		 13187 break;
13188 }
13189 break;
a117b0a5 13190 case 0xed:
c7927a3c 13191 GETBYTE ();
a117b0a5 13192 switch (op[2] & 0xf0)
c7927a3c
NC		 13193 {
13194 case 0x00:
a117b0a5
YS		 13195 case 0x10:
13196 case 0x20:
13197 case 0x30:
13198 case 0x40:
13199 case 0x50:
13200 case 0x60:
13201 case 0x70:
13202 case 0x80:
13203 case 0x90:
13204 case 0xa0:
13205 case 0xb0:
13206 case 0xc0:
13207 case 0xd0:
13208 case 0xe0:
13209 goto op_semantics_113;
13210 break;
13211 case 0xf0:
13212 goto op_semantics_114;
c7927a3c
NC		 13213 break;
13214 }
13215 break;
a117b0a5 13216 case 0xee:
c7927a3c 13217 GETBYTE ();
a117b0a5 13218 switch (op[2] & 0xf0)
c7927a3c
NC		 13219 {
13220 case 0x00:
a117b0a5
YS		 13221 case 0x10:
13222 case 0x20:
13223 case 0x30:
13224 case 0x40:
13225 case 0x50:
13226 case 0x60:
13227 case 0x70:
13228 case 0x80:
13229 case 0x90:
13230 case 0xa0:
13231 case 0xb0:
13232 case 0xc0:
13233 case 0xd0:
13234 case 0xe0:
13235 goto op_semantics_113;
13236 break;
13237 case 0xf0:
13238 goto op_semantics_114;
c7927a3c
NC		 13239 break;
13240 }
13241 break;
a117b0a5 13242 case 0xef:
c7927a3c 13243 GETBYTE ();
a117b0a5 13244 switch (op[2] & 0xf0)
c7927a3c
NC		 13245 {
13246 case 0x00:
a117b0a5
YS		 13247 case 0x10:
13248 case 0x20:
13249 case 0x30:
13250 case 0x40:
13251 case 0x50:
13252 case 0x60:
13253 case 0x70:
13254 case 0x80:
13255 case 0x90:
13256 case 0xa0:
13257 case 0xb0:
13258 case 0xc0:
13259 case 0xd0:
13260 case 0xe0:
13261 goto op_semantics_113;
13262 break;
13263 case 0xf0:
13264 goto op_semantics_114;
c7927a3c
NC		 13265 break;
13266 }
13267 break;
a117b0a5 13268 case 0xf0:
c7927a3c 13269 GETBYTE ();
a117b0a5 13270 switch (op[2] & 0xf0)
c7927a3c
NC		 13271 {
13272 case 0x00:
a117b0a5
YS		 13273 case 0x10:
13274 case 0x20:
13275 case 0x30:
13276 case 0x40:
13277 case 0x50:
13278 case 0x60:
13279 case 0x70:
13280 case 0x80:
13281 case 0x90:
13282 case 0xa0:
13283 case 0xb0:
13284 case 0xc0:
13285 case 0xd0:
13286 case 0xe0:
13287 goto op_semantics_113;
13288 break;
13289 case 0xf0:
13290 goto op_semantics_114;
c7927a3c
NC		 13291 break;
13292 }
13293 break;
a117b0a5 13294 case 0xf1:
c7927a3c
NC		 13295 GETBYTE ();
13296 switch (op[2] & 0xf0)
13297 {
13298 case 0x00:
13299 case 0x10:
13300 case 0x20:
13301 case 0x30:
13302 case 0x40:
13303 case 0x50:
13304 case 0x60:
13305 case 0x70:
13306 case 0x80:
13307 case 0x90:
13308 case 0xa0:
13309 case 0xb0:
13310 case 0xc0:
13311 case 0xd0:
13312 case 0xe0:
a117b0a5 13313 goto op_semantics_113;
c7927a3c
NC		 13314 break;
13315 case 0xf0:
a117b0a5 13316 goto op_semantics_114;
c7927a3c
NC		 13317 break;
13318 }
13319 break;
a117b0a5 13320 case 0xf2:
c7927a3c
NC		 13321 GETBYTE ();
13322 switch (op[2] & 0xf0)
13323 {
13324 case 0x00:
13325 case 0x10:
13326 case 0x20:
13327 case 0x30:
13328 case 0x40:
13329 case 0x50:
13330 case 0x60:
13331 case 0x70:
13332 case 0x80:
13333 case 0x90:
13334 case 0xa0:
13335 case 0xb0:
13336 case 0xc0:
13337 case 0xd0:
13338 case 0xe0:
a117b0a5 13339 goto op_semantics_113;
c7927a3c
NC		 13340 break;
13341 case 0xf0:
a117b0a5 13342 goto op_semantics_114;
c7927a3c
NC		 13343 break;
13344 }
13345 break;
a117b0a5 13346 case 0xf3:
c7927a3c
NC		 13347 GETBYTE ();
13348 switch (op[2] & 0xf0)
13349 {
13350 case 0x00:
13351 case 0x10:
13352 case 0x20:
13353 case 0x30:
13354 case 0x40:
13355 case 0x50:
13356 case 0x60:
13357 case 0x70:
13358 case 0x80:
13359 case 0x90:
13360 case 0xa0:
13361 case 0xb0:
13362 case 0xc0:
13363 case 0xd0:
13364 case 0xe0:
a117b0a5 13365 goto op_semantics_113;
c7927a3c
NC		 13366 break;
13367 case 0xf0:
a117b0a5 13368 goto op_semantics_114;
c7927a3c
NC		 13369 break;
13370 }
13371 break;
a117b0a5 13372 case 0xf4:
c7927a3c
NC		 13373 GETBYTE ();
13374 switch (op[2] & 0xf0)
13375 {
13376 case 0x00:
13377 case 0x10:
13378 case 0x20:
13379 case 0x30:
13380 case 0x40:
13381 case 0x50:
13382 case 0x60:
13383 case 0x70:
13384 case 0x80:
13385 case 0x90:
13386 case 0xa0:
13387 case 0xb0:
13388 case 0xc0:
13389 case 0xd0:
13390 case 0xe0:
a117b0a5 13391 goto op_semantics_113;
c7927a3c
NC		 13392 break;
13393 case 0xf0:
a117b0a5 13394 goto op_semantics_114;
c7927a3c
NC		 13395 break;
13396 }
13397 break;
a117b0a5 13398 case 0xf5:
c7927a3c
NC		 13399 GETBYTE ();
13400 switch (op[2] & 0xf0)
13401 {
13402 case 0x00:
13403 case 0x10:
13404 case 0x20:
13405 case 0x30:
13406 case 0x40:
13407 case 0x50:
13408 case 0x60:
13409 case 0x70:
13410 case 0x80:
13411 case 0x90:
13412 case 0xa0:
13413 case 0xb0:
13414 case 0xc0:
13415 case 0xd0:
13416 case 0xe0:
a117b0a5 13417 goto op_semantics_113;
c7927a3c
NC		 13418 break;
13419 case 0xf0:
a117b0a5 13420 goto op_semantics_114;
c7927a3c
NC		 13421 break;
13422 }
13423 break;
a117b0a5 13424 case 0xf6:
c7927a3c
NC		 13425 GETBYTE ();
13426 switch (op[2] & 0xf0)
13427 {
13428 case 0x00:
13429 case 0x10:
13430 case 0x20:
13431 case 0x30:
13432 case 0x40:
13433 case 0x50:
13434 case 0x60:
13435 case 0x70:
13436 case 0x80:
13437 case 0x90:
13438 case 0xa0:
13439 case 0xb0:
13440 case 0xc0:
13441 case 0xd0:
13442 case 0xe0:
a117b0a5 13443 goto op_semantics_113;
c7927a3c
NC		 13444 break;
13445 case 0xf0:
a117b0a5 13446 goto op_semantics_114;
c7927a3c
NC		 13447 break;
13448 }
13449 break;
a117b0a5 13450 case 0xf7:
c7927a3c
NC		 13451 GETBYTE ();
13452 switch (op[2] & 0xf0)
13453 {
13454 case 0x00:
13455 case 0x10:
13456 case 0x20:
13457 case 0x30:
13458 case 0x40:
13459 case 0x50:
13460 case 0x60:
13461 case 0x70:
13462 case 0x80:
13463 case 0x90:
13464 case 0xa0:
13465 case 0xb0:
13466 case 0xc0:
13467 case 0xd0:
13468 case 0xe0:
a117b0a5 13469 goto op_semantics_113;
c7927a3c
NC		 13470 break;
13471 case 0xf0:
a117b0a5 13472 goto op_semantics_114;
c7927a3c
NC		 13473 break;
13474 }
13475 break;
a117b0a5 13476 case 0xf8:
c7927a3c
NC		 13477 GETBYTE ();
13478 switch (op[2] & 0xf0)
13479 {
13480 case 0x00:
13481 case 0x10:
13482 case 0x20:
13483 case 0x30:
13484 case 0x40:
13485 case 0x50:
13486 case 0x60:
13487 case 0x70:
13488 case 0x80:
13489 case 0x90:
13490 case 0xa0:
13491 case 0xb0:
13492 case 0xc0:
13493 case 0xd0:
13494 case 0xe0:
a117b0a5 13495 goto op_semantics_113;
c7927a3c
NC		 13496 break;
13497 case 0xf0:
a117b0a5 13498 goto op_semantics_114;
c7927a3c
NC		 13499 break;
13500 }
13501 break;
a117b0a5 13502 case 0xf9:
c7927a3c
NC		 13503 GETBYTE ();
13504 switch (op[2] & 0xf0)
13505 {
13506 case 0x00:
13507 case 0x10:
13508 case 0x20:
13509 case 0x30:
13510 case 0x40:
13511 case 0x50:
13512 case 0x60:
13513 case 0x70:
13514 case 0x80:
13515 case 0x90:
13516 case 0xa0:
13517 case 0xb0:
13518 case 0xc0:
13519 case 0xd0:
13520 case 0xe0:
a117b0a5 13521 goto op_semantics_113;
c7927a3c
NC		 13522 break;
13523 case 0xf0:
a117b0a5 13524 goto op_semantics_114;
c7927a3c
NC		 13525 break;
13526 }
13527 break;
a117b0a5 13528 case 0xfa:
c7927a3c
NC		 13529 GETBYTE ();
13530 switch (op[2] & 0xf0)
13531 {
13532 case 0x00:
13533 case 0x10:
13534 case 0x20:
13535 case 0x30:
13536 case 0x40:
13537 case 0x50:
13538 case 0x60:
13539 case 0x70:
13540 case 0x80:
13541 case 0x90:
13542 case 0xa0:
13543 case 0xb0:
13544 case 0xc0:
13545 case 0xd0:
13546 case 0xe0:
a117b0a5 13547 goto op_semantics_113;
c7927a3c
NC		 13548 break;
13549 case 0xf0:
a117b0a5 13550 goto op_semantics_114;
c7927a3c
NC		 13551 break;
13552 }
13553 break;
a117b0a5 13554 case 0xfb:
c7927a3c
NC		 13555 GETBYTE ();
13556 switch (op[2] & 0xf0)
13557 {
13558 case 0x00:
13559 case 0x10:
13560 case 0x20:
13561 case 0x30:
13562 case 0x40:
13563 case 0x50:
13564 case 0x60:
13565 case 0x70:
13566 case 0x80:
13567 case 0x90:
13568 case 0xa0:
13569 case 0xb0:
13570 case 0xc0:
13571 case 0xd0:
13572 case 0xe0:
a117b0a5 13573 goto op_semantics_113;
c7927a3c
NC		 13574 break;
13575 case 0xf0:
a117b0a5 13576 goto op_semantics_114;
c7927a3c
NC		 13577 break;
13578 }
13579 break;
a117b0a5 13580 case 0xfc:
c7927a3c
NC		 13581 GETBYTE ();
13582 switch (op[2] & 0xf0)
13583 {
13584 case 0x00:
13585 case 0x10:
13586 case 0x20:
13587 case 0x30:
13588 case 0x40:
13589 case 0x50:
13590 case 0x60:
13591 case 0x70:
13592 case 0x80:
13593 case 0x90:
13594 case 0xa0:
13595 case 0xb0:
13596 case 0xc0:
13597 case 0xd0:
13598 case 0xe0:
a117b0a5 13599 goto op_semantics_113;
c7927a3c
NC		 13600 break;
13601 case 0xf0:
a117b0a5 13602 goto op_semantics_114;
c7927a3c
NC		 13603 break;
13604 }
13605 break;
a117b0a5 13606 case 0xfd:
c7927a3c
NC		 13607 GETBYTE ();
13608 switch (op[2] & 0xf0)
13609 {
13610 case 0x00:
13611 case 0x10:
13612 case 0x20:
13613 case 0x30:
13614 case 0x40:
13615 case 0x50:
13616 case 0x60:
13617 case 0x70:
13618 case 0x80:
13619 case 0x90:
13620 case 0xa0:
13621 case 0xb0:
13622 case 0xc0:
13623 case 0xd0:
13624 case 0xe0:
a117b0a5 13625 goto op_semantics_113;
c7927a3c
NC		 13626 break;
13627 case 0xf0:
a117b0a5 13628 goto op_semantics_114;
c7927a3c
NC		 13629 break;
13630 }
13631 break;
a117b0a5 13632 case 0xfe:
c7927a3c
NC		 13633 GETBYTE ();
13634 switch (op[2] & 0xf0)
13635 {
13636 case 0x00:
13637 case 0x10:
13638 case 0x20:
13639 case 0x30:
13640 case 0x40:
13641 case 0x50:
13642 case 0x60:
13643 case 0x70:
13644 case 0x80:
13645 case 0x90:
13646 case 0xa0:
13647 case 0xb0:
13648 case 0xc0:
13649 case 0xd0:
13650 case 0xe0:
a117b0a5 13651 goto op_semantics_113;
c7927a3c
NC		 13652 break;
13653 case 0xf0:
a117b0a5 13654 goto op_semantics_114;
c7927a3c
NC		 13655 break;
13656 }
13657 break;
a117b0a5 13658 case 0xff:
c7927a3c
NC		 13659 GETBYTE ();
13660 switch (op[2] & 0xf0)
13661 {
13662 case 0x00:
13663 case 0x10:
13664 case 0x20:
13665 case 0x30:
13666 case 0x40:
13667 case 0x50:
13668 case 0x60:
13669 case 0x70:
13670 case 0x80:
13671 case 0x90:
13672 case 0xa0:
13673 case 0xb0:
13674 case 0xc0:
13675 case 0xd0:
13676 case 0xe0:
a117b0a5 13677 goto op_semantics_113;
c7927a3c
NC		 13678 break;
13679 case 0xf0:
a117b0a5
YS		 13680 goto op_semantics_114;
13681 break;
13682 }
13683 break;
13684 default: UNSUPPORTED(); break;
13685 }
13686 break;
13687 case 0xfe:
13688 GETBYTE ();
13689 switch (op[1] & 0xff)
13690 {
13691 case 0x00:
13692 GETBYTE ();
13693 switch (op[2] & 0x00)
13694 {
13695 case 0x00:
13696 op_semantics_115:
13697 {
13698 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
e197589b 13699#line 342 "rx-decode.opc"
a117b0a5 13700 int sz AU = (op[1] >> 4) & 0x03;
e197589b 13701#line 342 "rx-decode.opc"
a117b0a5 13702 int isrc AU = op[1] & 0x0f;
e197589b 13703#line 342 "rx-decode.opc"
a117b0a5 13704 int bsrc AU = (op[2] >> 4) & 0x0f;
e197589b 13705#line 342 "rx-decode.opc"
a117b0a5
YS		 13706 int rdst AU = op[2] & 0x0f;
13707 if (trace)
13708 {
13709 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13710 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
13711 op[0], op[1], op[2]);
13712 printf (" sz = 0x%x,", sz);
13713 printf (" isrc = 0x%x,", isrc);
13714 printf (" bsrc = 0x%x,", bsrc);
13715 printf (" rdst = 0x%x\n", rdst);
13716 }
13717 SYNTAX("mov%s %0, [%1, %2]");
e197589b 13718#line 342 "rx-decode.opc"
a117b0a5
YS		 13719 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13720
13721 }
13722 break;
13723 }
13724 break;
13725 case 0x01:
13726 GETBYTE ();
13727 switch (op[2] & 0x00)
13728 {
13729 case 0x00:
13730 goto op_semantics_115;
13731 break;
13732 }
13733 break;
13734 case 0x02:
13735 GETBYTE ();
13736 switch (op[2] & 0x00)
13737 {
13738 case 0x00:
13739 goto op_semantics_115;
13740 break;
13741 }
13742 break;
13743 case 0x03:
13744 GETBYTE ();
13745 switch (op[2] & 0x00)
13746 {
13747 case 0x00:
13748 goto op_semantics_115;
13749 break;
13750 }
13751 break;
13752 case 0x04:
13753 GETBYTE ();
13754 switch (op[2] & 0x00)
13755 {
13756 case 0x00:
13757 goto op_semantics_115;
13758 break;
13759 }
13760 break;
13761 case 0x05:
13762 GETBYTE ();
13763 switch (op[2] & 0x00)
13764 {
13765 case 0x00:
13766 goto op_semantics_115;
13767 break;
13768 }
13769 break;
13770 case 0x06:
13771 GETBYTE ();
13772 switch (op[2] & 0x00)
13773 {
13774 case 0x00:
13775 goto op_semantics_115;
13776 break;
13777 }
13778 break;
13779 case 0x07:
13780 GETBYTE ();
13781 switch (op[2] & 0x00)
13782 {
13783 case 0x00:
13784 goto op_semantics_115;
13785 break;
13786 }
13787 break;
13788 case 0x08:
13789 GETBYTE ();
13790 switch (op[2] & 0x00)
13791 {
13792 case 0x00:
13793 goto op_semantics_115;
13794 break;
13795 }
13796 break;
13797 case 0x09:
13798 GETBYTE ();
13799 switch (op[2] & 0x00)
13800 {
13801 case 0x00:
13802 goto op_semantics_115;
13803 break;
13804 }
13805 break;
13806 case 0x0a:
13807 GETBYTE ();
13808 switch (op[2] & 0x00)
13809 {
13810 case 0x00:
13811 goto op_semantics_115;
13812 break;
13813 }
13814 break;
13815 case 0x0b:
13816 GETBYTE ();
13817 switch (op[2] & 0x00)
13818 {
13819 case 0x00:
13820 goto op_semantics_115;
13821 break;
13822 }
13823 break;
13824 case 0x0c:
13825 GETBYTE ();
13826 switch (op[2] & 0x00)
13827 {
13828 case 0x00:
13829 goto op_semantics_115;
13830 break;
13831 }
13832 break;
13833 case 0x0d:
13834 GETBYTE ();
13835 switch (op[2] & 0x00)
13836 {
13837 case 0x00:
13838 goto op_semantics_115;
13839 break;
13840 }
13841 break;
13842 case 0x0e:
13843 GETBYTE ();
13844 switch (op[2] & 0x00)
13845 {
13846 case 0x00:
13847 goto op_semantics_115;
13848 break;
13849 }
13850 break;
13851 case 0x0f:
13852 GETBYTE ();
13853 switch (op[2] & 0x00)
13854 {
13855 case 0x00:
13856 goto op_semantics_115;
13857 break;
13858 }
13859 break;
13860 case 0x10:
13861 GETBYTE ();
13862 switch (op[2] & 0x00)
13863 {
13864 case 0x00:
13865 goto op_semantics_115;
13866 break;
13867 }
13868 break;
13869 case 0x11:
13870 GETBYTE ();
13871 switch (op[2] & 0x00)
13872 {
13873 case 0x00:
13874 goto op_semantics_115;
13875 break;
13876 }
13877 break;
13878 case 0x12:
13879 GETBYTE ();
13880 switch (op[2] & 0x00)
13881 {
13882 case 0x00:
13883 goto op_semantics_115;
13884 break;
13885 }
13886 break;
13887 case 0x13:
13888 GETBYTE ();
13889 switch (op[2] & 0x00)
13890 {
13891 case 0x00:
13892 goto op_semantics_115;
13893 break;
13894 }
13895 break;
13896 case 0x14:
13897 GETBYTE ();
13898 switch (op[2] & 0x00)
13899 {
13900 case 0x00:
13901 goto op_semantics_115;
13902 break;
13903 }
13904 break;
13905 case 0x15:
13906 GETBYTE ();
13907 switch (op[2] & 0x00)
13908 {
13909 case 0x00:
13910 goto op_semantics_115;
13911 break;
13912 }
13913 break;
13914 case 0x16:
13915 GETBYTE ();
13916 switch (op[2] & 0x00)
13917 {
13918 case 0x00:
13919 goto op_semantics_115;
13920 break;
13921 }
13922 break;
13923 case 0x17:
13924 GETBYTE ();
13925 switch (op[2] & 0x00)
13926 {
13927 case 0x00:
13928 goto op_semantics_115;
13929 break;
13930 }
13931 break;
13932 case 0x18:
13933 GETBYTE ();
13934 switch (op[2] & 0x00)
13935 {
13936 case 0x00:
13937 goto op_semantics_115;
13938 break;
13939 }
13940 break;
13941 case 0x19:
13942 GETBYTE ();
13943 switch (op[2] & 0x00)
13944 {
13945 case 0x00:
13946 goto op_semantics_115;
c7927a3c
NC		 13947 break;
13948 }
13949 break;
a117b0a5 13950 case 0x1a:
c7927a3c 13951 GETBYTE ();
a117b0a5 13952 switch (op[2] & 0x00)
c7927a3c
NC		 13953 {
13954 case 0x00:
a117b0a5 13955 goto op_semantics_115;
c7927a3c
NC		 13956 break;
13957 }
13958 break;
a117b0a5 13959 case 0x1b:
c7927a3c 13960 GETBYTE ();
a117b0a5 13961 switch (op[2] & 0x00)
c7927a3c
NC		 13962 {
13963 case 0x00:
a117b0a5 13964 goto op_semantics_115;
c7927a3c
NC		 13965 break;
13966 }
13967 break;
a117b0a5 13968 case 0x1c:
c7927a3c 13969 GETBYTE ();
a117b0a5 13970 switch (op[2] & 0x00)
c7927a3c
NC		 13971 {
13972 case 0x00:
a117b0a5 13973 goto op_semantics_115;
c7927a3c
NC		 13974 break;
13975 }
13976 break;
a117b0a5 13977 case 0x1d:
c7927a3c 13978 GETBYTE ();
a117b0a5 13979 switch (op[2] & 0x00)
c7927a3c
NC		 13980 {
13981 case 0x00:
a117b0a5 13982 goto op_semantics_115;
c7927a3c
NC		 13983 break;
13984 }
13985 break;
a117b0a5 13986 case 0x1e:
c7927a3c 13987 GETBYTE ();
a117b0a5 13988 switch (op[2] & 0x00)
c7927a3c
NC		 13989 {
13990 case 0x00:
a117b0a5 13991 goto op_semantics_115;
c7927a3c
NC		 13992 break;
13993 }
13994 break;
a117b0a5 13995 case 0x1f:
c7927a3c 13996 GETBYTE ();
a117b0a5 13997 switch (op[2] & 0x00)
c7927a3c
NC		 13998 {
13999 case 0x00:
a117b0a5 14000 goto op_semantics_115;
c7927a3c
NC		 14001 break;
14002 }
14003 break;
a117b0a5 14004 case 0x20:
c7927a3c 14005 GETBYTE ();
a117b0a5 14006 switch (op[2] & 0x00)
c7927a3c
NC		 14007 {
14008 case 0x00:
a117b0a5 14009 goto op_semantics_115;
c7927a3c
NC		 14010 break;
14011 }
14012 break;
a117b0a5 14013 case 0x21:
c7927a3c 14014 GETBYTE ();
a117b0a5 14015 switch (op[2] & 0x00)
c7927a3c
NC		 14016 {
14017 case 0x00:
a117b0a5 14018 goto op_semantics_115;
c7927a3c
NC		 14019 break;
14020 }
14021 break;
a117b0a5 14022 case 0x22:
c7927a3c 14023 GETBYTE ();
a117b0a5 14024 switch (op[2] & 0x00)
c7927a3c
NC		 14025 {
14026 case 0x00:
a117b0a5 14027 goto op_semantics_115;
c7927a3c 14028 break;
a117b0a5
YS		 14029 }
14030 break;
14031 case 0x23:
14032 GETBYTE ();
14033 switch (op[2] & 0x00)
14034 {
14035 case 0x00:
14036 goto op_semantics_115;
c7927a3c
NC		 14037 break;
14038 }
14039 break;
a117b0a5 14040 case 0x24:
c7927a3c 14041 GETBYTE ();
a117b0a5 14042 switch (op[2] & 0x00)
c7927a3c
NC		 14043 {
14044 case 0x00:
a117b0a5 14045 goto op_semantics_115;
c7927a3c 14046 break;
a117b0a5
YS		 14047 }
14048 break;
14049 case 0x25:
14050 GETBYTE ();
14051 switch (op[2] & 0x00)
14052 {
14053 case 0x00:
14054 goto op_semantics_115;
c7927a3c
NC		 14055 break;
14056 }
14057 break;
a117b0a5 14058 case 0x26:
c7927a3c 14059 GETBYTE ();
a117b0a5 14060 switch (op[2] & 0x00)
c7927a3c
NC		 14061 {
14062 case 0x00:
a117b0a5 14063 goto op_semantics_115;
c7927a3c 14064 break;
a117b0a5
YS		 14065 }
14066 break;
14067 case 0x27:
14068 GETBYTE ();
14069 switch (op[2] & 0x00)
14070 {
14071 case 0x00:
14072 goto op_semantics_115;
c7927a3c
NC		 14073 break;
14074 }
14075 break;
a117b0a5 14076 case 0x28:
c7927a3c 14077 GETBYTE ();
a117b0a5 14078 switch (op[2] & 0x00)
c7927a3c
NC		 14079 {
14080 case 0x00:
a117b0a5 14081 goto op_semantics_115;
c7927a3c
NC		 14082 break;
14083 }
14084 break;
a117b0a5 14085 case 0x29:
c7927a3c 14086 GETBYTE ();
a117b0a5 14087 switch (op[2] & 0x00)
c7927a3c
NC		 14088 {
14089 case 0x00:
a117b0a5 14090 goto op_semantics_115;
c7927a3c
NC		 14091 break;
14092 }
14093 break;
a117b0a5 14094 case 0x2a:
c7927a3c 14095 GETBYTE ();
a117b0a5 14096 switch (op[2] & 0x00)
c7927a3c
NC		 14097 {
14098 case 0x00:
a117b0a5 14099 goto op_semantics_115;
c7927a3c
NC		 14100 break;
14101 }
14102 break;
a117b0a5 14103 case 0x2b:
c7927a3c 14104 GETBYTE ();
a117b0a5 14105 switch (op[2] & 0x00)
c7927a3c
NC		 14106 {
14107 case 0x00:
a117b0a5 14108 goto op_semantics_115;
c7927a3c
NC		 14109 break;
14110 }
14111 break;
a117b0a5 14112 case 0x2c:
c7927a3c 14113 GETBYTE ();
a117b0a5 14114 switch (op[2] & 0x00)
c7927a3c
NC		 14115 {
14116 case 0x00:
a117b0a5 14117 goto op_semantics_115;
c7927a3c 14118 break;
a117b0a5
YS		 14119 }
14120 break;
14121 case 0x2d:
14122 GETBYTE ();
14123 switch (op[2] & 0x00)
14124 {
14125 case 0x00:
14126 goto op_semantics_115;
c7927a3c
NC		 14127 break;
14128 }
14129 break;
a117b0a5 14130 case 0x2e:
c7927a3c 14131 GETBYTE ();
a117b0a5 14132 switch (op[2] & 0x00)
c7927a3c
NC		 14133 {
14134 case 0x00:
a117b0a5 14135 goto op_semantics_115;
c7927a3c 14136 break;
a117b0a5
YS		 14137 }
14138 break;
14139 case 0x2f:
14140 GETBYTE ();
14141 switch (op[2] & 0x00)
14142 {
14143 case 0x00:
14144 goto op_semantics_115;
c7927a3c
NC		 14145 break;
14146 }
14147 break;
a117b0a5 14148 case 0x40:
c7927a3c
NC		 14149 GETBYTE ();
14150 switch (op[2] & 0x00)
14151 {
14152 case 0x00:
a117b0a5 14153 op_semantics_116:
c7927a3c 14154 {
a117b0a5 14155 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
e197589b 14156#line 339 "rx-decode.opc"
c7927a3c 14157 int sz AU = (op[1] >> 4) & 0x03;
e197589b 14158#line 339 "rx-decode.opc"
c7927a3c 14159 int isrc AU = op[1] & 0x0f;
e197589b 14160#line 339 "rx-decode.opc"
c7927a3c 14161 int bsrc AU = (op[2] >> 4) & 0x0f;
e197589b 14162#line 339 "rx-decode.opc"
c7927a3c
NC		 14163 int rdst AU = op[2] & 0x0f;
14164 if (trace)
14165 {
14166 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 14167 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
c7927a3c
NC		 14168 op[0], op[1], op[2]);
14169 printf (" sz = 0x%x,", sz);
14170 printf (" isrc = 0x%x,", isrc);
14171 printf (" bsrc = 0x%x,", bsrc);
14172 printf (" rdst = 0x%x\n", rdst);
14173 }
a117b0a5 14174 SYNTAX("mov%s [%1, %2], %0");
e197589b 14175#line 339 "rx-decode.opc"
a117b0a5 14176 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
43e65147 14177
c7927a3c
NC		 14178 }
14179 break;
14180 }
14181 break;
a117b0a5 14182 case 0x41:
c7927a3c
NC		 14183 GETBYTE ();
14184 switch (op[2] & 0x00)
14185 {
14186 case 0x00:
a117b0a5 14187 goto op_semantics_116;
c7927a3c
NC		 14188 break;
14189 }
14190 break;
a117b0a5 14191 case 0x42:
c7927a3c
NC		 14192 GETBYTE ();
14193 switch (op[2] & 0x00)
14194 {
14195 case 0x00:
a117b0a5 14196 goto op_semantics_116;
c7927a3c
NC		 14197 break;
14198 }
14199 break;
a117b0a5 14200 case 0x43:
c7927a3c
NC		 14201 GETBYTE ();
14202 switch (op[2] & 0x00)
14203 {
14204 case 0x00:
a117b0a5 14205 goto op_semantics_116;
c7927a3c
NC		 14206 break;
14207 }
14208 break;
a117b0a5 14209 case 0x44:
c7927a3c
NC		 14210 GETBYTE ();
14211 switch (op[2] & 0x00)
14212 {
14213 case 0x00:
a117b0a5 14214 goto op_semantics_116;
c7927a3c
NC		 14215 break;
14216 }
14217 break;
a117b0a5 14218 case 0x45:
c7927a3c
NC		 14219 GETBYTE ();
14220 switch (op[2] & 0x00)
14221 {
14222 case 0x00:
a117b0a5 14223 goto op_semantics_116;
c7927a3c
NC		 14224 break;
14225 }
14226 break;
a117b0a5 14227 case 0x46:
c7927a3c
NC		 14228 GETBYTE ();
14229 switch (op[2] & 0x00)
14230 {
14231 case 0x00:
a117b0a5 14232 goto op_semantics_116;
c7927a3c
NC		 14233 break;
14234 }
14235 break;
a117b0a5 14236 case 0x47:
c7927a3c
NC		 14237 GETBYTE ();
14238 switch (op[2] & 0x00)
14239 {
14240 case 0x00:
a117b0a5 14241 goto op_semantics_116;
c7927a3c
NC		 14242 break;
14243 }
14244 break;
a117b0a5 14245 case 0x48:
c7927a3c
NC		 14246 GETBYTE ();
14247 switch (op[2] & 0x00)
14248 {
14249 case 0x00:
a117b0a5 14250 goto op_semantics_116;
c7927a3c
NC		 14251 break;
14252 }
14253 break;
a117b0a5 14254 case 0x49:
c7927a3c
NC		 14255 GETBYTE ();
14256 switch (op[2] & 0x00)
14257 {
14258 case 0x00:
a117b0a5 14259 goto op_semantics_116;
c7927a3c
NC		 14260 break;
14261 }
14262 break;
a117b0a5 14263 case 0x4a:
c7927a3c
NC		 14264 GETBYTE ();
14265 switch (op[2] & 0x00)
14266 {
14267 case 0x00:
a117b0a5 14268 goto op_semantics_116;
c7927a3c
NC		 14269 break;
14270 }
14271 break;
a117b0a5 14272 case 0x4b:
c7927a3c
NC		 14273 GETBYTE ();
14274 switch (op[2] & 0x00)
14275 {
14276 case 0x00:
a117b0a5 14277 goto op_semantics_116;
c7927a3c
NC		 14278 break;
14279 }
14280 break;
a117b0a5 14281 case 0x4c:
c7927a3c
NC		 14282 GETBYTE ();
14283 switch (op[2] & 0x00)
14284 {
14285 case 0x00:
a117b0a5 14286 goto op_semantics_116;
c7927a3c
NC		 14287 break;
14288 }
14289 break;
a117b0a5 14290 case 0x4d:
c7927a3c
NC		 14291 GETBYTE ();
14292 switch (op[2] & 0x00)
14293 {
14294 case 0x00:
a117b0a5 14295 goto op_semantics_116;
c7927a3c
NC		 14296 break;
14297 }
14298 break;
a117b0a5 14299 case 0x4e:
c7927a3c
NC		 14300 GETBYTE ();
14301 switch (op[2] & 0x00)
14302 {
14303 case 0x00:
a117b0a5 14304 goto op_semantics_116;
c7927a3c
NC		 14305 break;
14306 }
14307 break;
a117b0a5 14308 case 0x4f:
c7927a3c
NC		 14309 GETBYTE ();
14310 switch (op[2] & 0x00)
14311 {
14312 case 0x00:
a117b0a5 14313 goto op_semantics_116;
c7927a3c
NC		 14314 break;
14315 }
14316 break;
a117b0a5 14317 case 0x50:
c7927a3c
NC		 14318 GETBYTE ();
14319 switch (op[2] & 0x00)
14320 {
14321 case 0x00:
a117b0a5 14322 goto op_semantics_116;
c7927a3c
NC		 14323 break;
14324 }
14325 break;
a117b0a5 14326 case 0x51:
c7927a3c
NC		 14327 GETBYTE ();
14328 switch (op[2] & 0x00)
14329 {
14330 case 0x00:
a117b0a5 14331 goto op_semantics_116;
c7927a3c
NC		 14332 break;
14333 }
14334 break;
a117b0a5 14335 case 0x52:
c7927a3c
NC		 14336 GETBYTE ();
14337 switch (op[2] & 0x00)
14338 {
14339 case 0x00:
a117b0a5 14340 goto op_semantics_116;
c7927a3c
NC		 14341 break;
14342 }
14343 break;
a117b0a5 14344 case 0x53:
c7927a3c
NC		 14345 GETBYTE ();
14346 switch (op[2] & 0x00)
14347 {
14348 case 0x00:
a117b0a5 14349 goto op_semantics_116;
c7927a3c
NC		 14350 break;
14351 }
14352 break;
a117b0a5 14353 case 0x54:
c7927a3c
NC		 14354 GETBYTE ();
14355 switch (op[2] & 0x00)
14356 {
14357 case 0x00:
a117b0a5 14358 goto op_semantics_116;
c7927a3c
NC		 14359 break;
14360 }
14361 break;
a117b0a5 14362 case 0x55:
c7927a3c
NC		 14363 GETBYTE ();
14364 switch (op[2] & 0x00)
14365 {
14366 case 0x00:
a117b0a5 14367 goto op_semantics_116;
c7927a3c
NC		 14368 break;
14369 }
14370 break;
a117b0a5 14371 case 0x56:
c7927a3c
NC		 14372 GETBYTE ();
14373 switch (op[2] & 0x00)
14374 {
14375 case 0x00:
a117b0a5 14376 goto op_semantics_116;
c7927a3c
NC		 14377 break;
14378 }
14379 break;
a117b0a5 14380 case 0x57:
c7927a3c
NC		 14381 GETBYTE ();
14382 switch (op[2] & 0x00)
14383 {
14384 case 0x00:
a117b0a5 14385 goto op_semantics_116;
c7927a3c
NC		 14386 break;
14387 }
14388 break;
a117b0a5 14389 case 0x58:
c7927a3c
NC		 14390 GETBYTE ();
14391 switch (op[2] & 0x00)
14392 {
14393 case 0x00:
a117b0a5 14394 goto op_semantics_116;
c7927a3c
NC		 14395 break;
14396 }
14397 break;
a117b0a5 14398 case 0x59:
c7927a3c
NC		 14399 GETBYTE ();
14400 switch (op[2] & 0x00)
14401 {
14402 case 0x00:
a117b0a5 14403 goto op_semantics_116;
c7927a3c
NC		 14404 break;
14405 }
14406 break;
a117b0a5 14407 case 0x5a:
c7927a3c
NC		 14408 GETBYTE ();
14409 switch (op[2] & 0x00)
14410 {
14411 case 0x00:
a117b0a5 14412 goto op_semantics_116;
c7927a3c
NC		 14413 break;
14414 }
14415 break;
a117b0a5 14416 case 0x5b:
c7927a3c
NC		 14417 GETBYTE ();
14418 switch (op[2] & 0x00)
14419 {
14420 case 0x00:
a117b0a5 14421 goto op_semantics_116;
c7927a3c
NC		 14422 break;
14423 }
14424 break;
a117b0a5 14425 case 0x5c:
c7927a3c
NC		 14426 GETBYTE ();
14427 switch (op[2] & 0x00)
14428 {
14429 case 0x00:
a117b0a5 14430 goto op_semantics_116;
c7927a3c
NC		 14431 break;
14432 }
14433 break;
a117b0a5 14434 case 0x5d:
c7927a3c
NC		 14435 GETBYTE ();
14436 switch (op[2] & 0x00)
14437 {
14438 case 0x00:
a117b0a5 14439 goto op_semantics_116;
c7927a3c
NC		 14440 break;
14441 }
14442 break;
a117b0a5 14443 case 0x5e:
c7927a3c
NC		 14444 GETBYTE ();
14445 switch (op[2] & 0x00)
14446 {
14447 case 0x00:
a117b0a5 14448 goto op_semantics_116;
c7927a3c
NC		 14449 break;
14450 }
14451 break;
a117b0a5 14452 case 0x5f:
c7927a3c
NC		 14453 GETBYTE ();
14454 switch (op[2] & 0x00)
14455 {
14456 case 0x00:
a117b0a5 14457 goto op_semantics_116;
c7927a3c
NC		 14458 break;
14459 }
14460 break;
a117b0a5 14461 case 0x60:
c7927a3c
NC		 14462 GETBYTE ();
14463 switch (op[2] & 0x00)
14464 {
14465 case 0x00:
a117b0a5 14466 goto op_semantics_116;
c7927a3c
NC		 14467 break;
14468 }
14469 break;
a117b0a5 14470 case 0x61:
c7927a3c
NC		 14471 GETBYTE ();
14472 switch (op[2] & 0x00)
14473 {
14474 case 0x00:
a117b0a5 14475 goto op_semantics_116;
c7927a3c
NC		 14476 break;
14477 }
14478 break;
a117b0a5 14479 case 0x62:
c7927a3c
NC		 14480 GETBYTE ();
14481 switch (op[2] & 0x00)
14482 {
14483 case 0x00:
a117b0a5 14484 goto op_semantics_116;
c7927a3c
NC		 14485 break;
14486 }
14487 break;
a117b0a5 14488 case 0x63:
c7927a3c
NC		 14489 GETBYTE ();
14490 switch (op[2] & 0x00)
14491 {
14492 case 0x00:
a117b0a5 14493 goto op_semantics_116;
c7927a3c
NC		 14494 break;
14495 }
14496 break;
a117b0a5 14497 case 0x64:
c7927a3c
NC		 14498 GETBYTE ();
14499 switch (op[2] & 0x00)
14500 {
14501 case 0x00:
a117b0a5 14502 goto op_semantics_116;
c7927a3c
NC		 14503 break;
14504 }
14505 break;
a117b0a5 14506 case 0x65:
c7927a3c
NC		 14507 GETBYTE ();
14508 switch (op[2] & 0x00)
14509 {
14510 case 0x00:
a117b0a5 14511 goto op_semantics_116;
c7927a3c
NC		 14512 break;
14513 }
14514 break;
a117b0a5 14515 case 0x66:
c7927a3c
NC		 14516 GETBYTE ();
14517 switch (op[2] & 0x00)
14518 {
14519 case 0x00:
a117b0a5 14520 goto op_semantics_116;
c7927a3c
NC		 14521 break;
14522 }
14523 break;
a117b0a5 14524 case 0x67:
c7927a3c
NC		 14525 GETBYTE ();
14526 switch (op[2] & 0x00)
14527 {
14528 case 0x00:
a117b0a5 14529 goto op_semantics_116;
c7927a3c
NC		 14530 break;
14531 }
14532 break;
a117b0a5 14533 case 0x68:
c7927a3c
NC		 14534 GETBYTE ();
14535 switch (op[2] & 0x00)
14536 {
14537 case 0x00:
a117b0a5 14538 goto op_semantics_116;
c7927a3c
NC		 14539 break;
14540 }
14541 break;
a117b0a5 14542 case 0x69:
c7927a3c
NC		 14543 GETBYTE ();
14544 switch (op[2] & 0x00)
14545 {
14546 case 0x00:
a117b0a5 14547 goto op_semantics_116;
c7927a3c
NC		 14548 break;
14549 }
14550 break;
a117b0a5 14551 case 0x6a:
c7927a3c
NC		 14552 GETBYTE ();
14553 switch (op[2] & 0x00)
14554 {
14555 case 0x00:
a117b0a5 14556 goto op_semantics_116;
c7927a3c
NC		 14557 break;
14558 }
14559 break;
a117b0a5 14560 case 0x6b:
c7927a3c
NC		 14561 GETBYTE ();
14562 switch (op[2] & 0x00)
14563 {
14564 case 0x00:
a117b0a5 14565 goto op_semantics_116;
c7927a3c
NC		 14566 break;
14567 }
14568 break;
a117b0a5 14569 case 0x6c:
c7927a3c
NC		 14570 GETBYTE ();
14571 switch (op[2] & 0x00)
14572 {
14573 case 0x00:
a117b0a5 14574 goto op_semantics_116;
c7927a3c
NC		 14575 break;
14576 }
14577 break;
a117b0a5 14578 case 0x6d:
c7927a3c
NC		 14579 GETBYTE ();
14580 switch (op[2] & 0x00)
14581 {
14582 case 0x00:
a117b0a5 14583 goto op_semantics_116;
c7927a3c
NC		 14584 break;
14585 }
14586 break;
a117b0a5 14587 case 0x6e:
c7927a3c
NC		 14588 GETBYTE ();
14589 switch (op[2] & 0x00)
14590 {
14591 case 0x00:
a117b0a5 14592 goto op_semantics_116;
c7927a3c
NC		 14593 break;
14594 }
14595 break;
a117b0a5 14596 case 0x6f:
c7927a3c
NC		 14597 GETBYTE ();
14598 switch (op[2] & 0x00)
14599 {
14600 case 0x00:
a117b0a5 14601 goto op_semantics_116;
c7927a3c
NC		 14602 break;
14603 }
14604 break;
a117b0a5 14605 case 0xc0:
c7927a3c
NC		 14606 GETBYTE ();
14607 switch (op[2] & 0x00)
14608 {
14609 case 0x00:
a117b0a5 14610 op_semantics_117:
c7927a3c 14611 {
a117b0a5 14612 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
e197589b 14613#line 345 "rx-decode.opc"
c7927a3c 14614 int sz AU = (op[1] >> 4) & 0x03;
e197589b 14615#line 345 "rx-decode.opc"
c7927a3c 14616 int isrc AU = op[1] & 0x0f;
e197589b 14617#line 345 "rx-decode.opc"
c7927a3c 14618 int bsrc AU = (op[2] >> 4) & 0x0f;
e197589b 14619#line 345 "rx-decode.opc"
c7927a3c
NC		 14620 int rdst AU = op[2] & 0x0f;
14621 if (trace)
14622 {
14623 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 14624 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
c7927a3c
NC		 14625 op[0], op[1], op[2]);
14626 printf (" sz = 0x%x,", sz);
14627 printf (" isrc = 0x%x,", isrc);
14628 printf (" bsrc = 0x%x,", bsrc);
14629 printf (" rdst = 0x%x\n", rdst);
14630 }
a117b0a5 14631 SYNTAX("movu%s [%1, %2], %0");
e197589b 14632#line 345 "rx-decode.opc"
a117b0a5 14633 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
43e65147 14634
c7927a3c
NC		 14635 }
14636 break;
14637 }
14638 break;
a117b0a5 14639 case 0xc1:
c7927a3c
NC		 14640 GETBYTE ();
14641 switch (op[2] & 0x00)
14642 {
14643 case 0x00:
a117b0a5 14644 goto op_semantics_117;
c7927a3c
NC		 14645 break;
14646 }
14647 break;
a117b0a5 14648 case 0xc2:
c7927a3c
NC		 14649 GETBYTE ();
14650 switch (op[2] & 0x00)
14651 {
14652 case 0x00:
a117b0a5 14653 goto op_semantics_117;
c7927a3c
NC		 14654 break;
14655 }
14656 break;
a117b0a5 14657 case 0xc3:
c7927a3c
NC		 14658 GETBYTE ();
14659 switch (op[2] & 0x00)
14660 {
14661 case 0x00:
a117b0a5 14662 goto op_semantics_117;
c7927a3c
NC		 14663 break;
14664 }
14665 break;
a117b0a5 14666 case 0xc4:
c7927a3c
NC		 14667 GETBYTE ();
14668 switch (op[2] & 0x00)
14669 {
14670 case 0x00:
a117b0a5 14671 goto op_semantics_117;
c7927a3c
NC		 14672 break;
14673 }
14674 break;
a117b0a5 14675 case 0xc5:
c7927a3c
NC		 14676 GETBYTE ();
14677 switch (op[2] & 0x00)
14678 {
14679 case 0x00:
a117b0a5 14680 goto op_semantics_117;
c7927a3c
NC		 14681 break;
14682 }
14683 break;
a117b0a5 14684 case 0xc6:
c7927a3c
NC		 14685 GETBYTE ();
14686 switch (op[2] & 0x00)
14687 {
14688 case 0x00:
a117b0a5 14689 goto op_semantics_117;
c7927a3c
NC		 14690 break;
14691 }
14692 break;
a117b0a5 14693 case 0xc7:
c7927a3c
NC		 14694 GETBYTE ();
14695 switch (op[2] & 0x00)
14696 {
14697 case 0x00:
a117b0a5 14698 goto op_semantics_117;
c7927a3c
NC		 14699 break;
14700 }
14701 break;
a117b0a5 14702 case 0xc8:
c7927a3c
NC		 14703 GETBYTE ();
14704 switch (op[2] & 0x00)
14705 {
14706 case 0x00:
a117b0a5 14707 goto op_semantics_117;
c7927a3c
NC		 14708 break;
14709 }
14710 break;
a117b0a5 14711 case 0xc9:
c7927a3c
NC		 14712 GETBYTE ();
14713 switch (op[2] & 0x00)
14714 {
14715 case 0x00:
a117b0a5 14716 goto op_semantics_117;
c7927a3c
NC		 14717 break;
14718 }
14719 break;
a117b0a5 14720 case 0xca:
c7927a3c
NC		 14721 GETBYTE ();
14722 switch (op[2] & 0x00)
14723 {
14724 case 0x00:
a117b0a5 14725 goto op_semantics_117;
c7927a3c
NC		 14726 break;
14727 }
14728 break;
a117b0a5 14729 case 0xcb:
c7927a3c
NC		 14730 GETBYTE ();
14731 switch (op[2] & 0x00)
14732 {
14733 case 0x00:
a117b0a5 14734 goto op_semantics_117;
c7927a3c
NC		 14735 break;
14736 }
14737 break;
a117b0a5 14738 case 0xcc:
c7927a3c
NC		 14739 GETBYTE ();
14740 switch (op[2] & 0x00)
14741 {
14742 case 0x00:
a117b0a5 14743 goto op_semantics_117;
c7927a3c
NC		 14744 break;
14745 }
14746 break;
a117b0a5 14747 case 0xcd:
c7927a3c
NC		 14748 GETBYTE ();
14749 switch (op[2] & 0x00)
14750 {
14751 case 0x00:
a117b0a5 14752 goto op_semantics_117;
c7927a3c
NC		 14753 break;
14754 }
14755 break;
a117b0a5 14756 case 0xce:
c7927a3c
NC		 14757 GETBYTE ();
14758 switch (op[2] & 0x00)
14759 {
14760 case 0x00:
a117b0a5 14761 goto op_semantics_117;
c7927a3c
NC		 14762 break;
14763 }
14764 break;
a117b0a5 14765 case 0xcf:
c7927a3c
NC		 14766 GETBYTE ();
14767 switch (op[2] & 0x00)
14768 {
14769 case 0x00:
a117b0a5 14770 goto op_semantics_117;
c7927a3c
NC		 14771 break;
14772 }
14773 break;
a117b0a5 14774 case 0xd0:
c7927a3c
NC		 14775 GETBYTE ();
14776 switch (op[2] & 0x00)
14777 {
14778 case 0x00:
a117b0a5 14779 goto op_semantics_117;
c7927a3c
NC		 14780 break;
14781 }
14782 break;
a117b0a5 14783 case 0xd1:
c7927a3c
NC		 14784 GETBYTE ();
14785 switch (op[2] & 0x00)
14786 {
14787 case 0x00:
a117b0a5 14788 goto op_semantics_117;
c7927a3c
NC		 14789 break;
14790 }
14791 break;
a117b0a5 14792 case 0xd2:
c7927a3c
NC		 14793 GETBYTE ();
14794 switch (op[2] & 0x00)
14795 {
14796 case 0x00:
a117b0a5 14797 goto op_semantics_117;
c7927a3c
NC		 14798 break;
14799 }
14800 break;
a117b0a5 14801 case 0xd3:
c7927a3c
NC		 14802 GETBYTE ();
14803 switch (op[2] & 0x00)
14804 {
14805 case 0x00:
a117b0a5 14806 goto op_semantics_117;
c7927a3c
NC		 14807 break;
14808 }
14809 break;
a117b0a5 14810 case 0xd4:
c7927a3c
NC		 14811 GETBYTE ();
14812 switch (op[2] & 0x00)
14813 {
14814 case 0x00:
a117b0a5 14815 goto op_semantics_117;
c7927a3c
NC		 14816 break;
14817 }
14818 break;
a117b0a5 14819 case 0xd5:
c7927a3c
NC		 14820 GETBYTE ();
14821 switch (op[2] & 0x00)
14822 {
14823 case 0x00:
a117b0a5 14824 goto op_semantics_117;
c7927a3c
NC		 14825 break;
14826 }
14827 break;
a117b0a5 14828 case 0xd6:
c7927a3c
NC		 14829 GETBYTE ();
14830 switch (op[2] & 0x00)
14831 {
14832 case 0x00:
a117b0a5 14833 goto op_semantics_117;
c7927a3c
NC		 14834 break;
14835 }
14836 break;
a117b0a5 14837 case 0xd7:
c7927a3c
NC		 14838 GETBYTE ();
14839 switch (op[2] & 0x00)
14840 {
14841 case 0x00:
a117b0a5 14842 goto op_semantics_117;
c7927a3c
NC		 14843 break;
14844 }
14845 break;
a117b0a5 14846 case 0xd8:
c7927a3c
NC		 14847 GETBYTE ();
14848 switch (op[2] & 0x00)
14849 {
14850 case 0x00:
a117b0a5 14851 goto op_semantics_117;
c7927a3c
NC		 14852 break;
14853 }
14854 break;
a117b0a5 14855 case 0xd9:
c7927a3c
NC		 14856 GETBYTE ();
14857 switch (op[2] & 0x00)
14858 {
14859 case 0x00:
a117b0a5 14860 goto op_semantics_117;
c7927a3c
NC		 14861 break;
14862 }
14863 break;
a117b0a5 14864 case 0xda:
c7927a3c
NC		 14865 GETBYTE ();
14866 switch (op[2] & 0x00)
14867 {
14868 case 0x00:
a117b0a5 14869 goto op_semantics_117;
c7927a3c
NC		 14870 break;
14871 }
14872 break;
a117b0a5 14873 case 0xdb:
c7927a3c
NC		 14874 GETBYTE ();
14875 switch (op[2] & 0x00)
14876 {
14877 case 0x00:
a117b0a5 14878 goto op_semantics_117;
c7927a3c
NC		 14879 break;
14880 }
14881 break;
a117b0a5 14882 case 0xdc:
c7927a3c
NC		 14883 GETBYTE ();
14884 switch (op[2] & 0x00)
14885 {
14886 case 0x00:
a117b0a5 14887 goto op_semantics_117;
c7927a3c
NC		 14888 break;
14889 }
14890 break;
a117b0a5 14891 case 0xdd:
c7927a3c
NC		 14892 GETBYTE ();
14893 switch (op[2] & 0x00)
14894 {
14895 case 0x00:
a117b0a5 14896 goto op_semantics_117;
c7927a3c
NC		 14897 break;
14898 }
14899 break;
a117b0a5 14900 case 0xde:
c7927a3c
NC		 14901 GETBYTE ();
14902 switch (op[2] & 0x00)
14903 {
14904 case 0x00:
a117b0a5 14905 goto op_semantics_117;
c7927a3c
NC		 14906 break;
14907 }
14908 break;
a117b0a5 14909 case 0xdf:
c7927a3c
NC		 14910 GETBYTE ();
14911 switch (op[2] & 0x00)
14912 {
14913 case 0x00:
a117b0a5 14914 goto op_semantics_117;
c7927a3c
NC		 14915 break;
14916 }
14917 break;
a117b0a5 14918 case 0xe0:
c7927a3c
NC		 14919 GETBYTE ();
14920 switch (op[2] & 0x00)
14921 {
14922 case 0x00:
a117b0a5 14923 goto op_semantics_117;
c7927a3c
NC		 14924 break;
14925 }
14926 break;
a117b0a5 14927 case 0xe1:
c7927a3c
NC		 14928 GETBYTE ();
14929 switch (op[2] & 0x00)
14930 {
14931 case 0x00:
a117b0a5 14932 goto op_semantics_117;
c7927a3c
NC		 14933 break;
14934 }
14935 break;
a117b0a5 14936 case 0xe2:
c7927a3c
NC		 14937 GETBYTE ();
14938 switch (op[2] & 0x00)
14939 {
14940 case 0x00:
a117b0a5 14941 goto op_semantics_117;
c7927a3c
NC		 14942 break;
14943 }
14944 break;
a117b0a5 14945 case 0xe3:
c7927a3c
NC		 14946 GETBYTE ();
14947 switch (op[2] & 0x00)
14948 {
14949 case 0x00:
a117b0a5 14950 goto op_semantics_117;
c7927a3c
NC		 14951 break;
14952 }
14953 break;
a117b0a5 14954 case 0xe4:
c7927a3c
NC		 14955 GETBYTE ();
14956 switch (op[2] & 0x00)
14957 {
14958 case 0x00:
a117b0a5 14959 goto op_semantics_117;
c7927a3c
NC		 14960 break;
14961 }
14962 break;
a117b0a5 14963 case 0xe5:
c7927a3c
NC		 14964 GETBYTE ();
14965 switch (op[2] & 0x00)
14966 {
14967 case 0x00:
a117b0a5 14968 goto op_semantics_117;
c7927a3c
NC		 14969 break;
14970 }
14971 break;
a117b0a5 14972 case 0xe6:
c7927a3c
NC		 14973 GETBYTE ();
14974 switch (op[2] & 0x00)
14975 {
14976 case 0x00:
a117b0a5 14977 goto op_semantics_117;
c7927a3c
NC		 14978 break;
14979 }
14980 break;
a117b0a5 14981 case 0xe7:
c7927a3c
NC		 14982 GETBYTE ();
14983 switch (op[2] & 0x00)
14984 {
14985 case 0x00:
a117b0a5 14986 goto op_semantics_117;
c7927a3c
NC		 14987 break;
14988 }
14989 break;
a117b0a5 14990 case 0xe8:
c7927a3c
NC		 14991 GETBYTE ();
14992 switch (op[2] & 0x00)
14993 {
14994 case 0x00:
a117b0a5 14995 goto op_semantics_117;
c7927a3c
NC		 14996 break;
14997 }
14998 break;
a117b0a5 14999 case 0xe9:
c7927a3c
NC		 15000 GETBYTE ();
15001 switch (op[2] & 0x00)
15002 {
15003 case 0x00:
a117b0a5 15004 goto op_semantics_117;
c7927a3c
NC		 15005 break;
15006 }
15007 break;
a117b0a5 15008 case 0xea:
c7927a3c
NC		 15009 GETBYTE ();
15010 switch (op[2] & 0x00)
15011 {
15012 case 0x00:
a117b0a5 15013 goto op_semantics_117;
c7927a3c
NC		 15014 break;
15015 }
15016 break;
a117b0a5 15017 case 0xeb:
c7927a3c
NC		 15018 GETBYTE ();
15019 switch (op[2] & 0x00)
15020 {
15021 case 0x00:
a117b0a5 15022 goto op_semantics_117;
c7927a3c
NC		 15023 break;
15024 }
15025 break;
a117b0a5 15026 case 0xec:
c7927a3c
NC		 15027 GETBYTE ();
15028 switch (op[2] & 0x00)
15029 {
15030 case 0x00:
a117b0a5 15031 goto op_semantics_117;
c7927a3c
NC		 15032 break;
15033 }
15034 break;
a117b0a5 15035 case 0xed:
c7927a3c
NC		 15036 GETBYTE ();
15037 switch (op[2] & 0x00)
15038 {
15039 case 0x00:
a117b0a5 15040 goto op_semantics_117;
c7927a3c
NC		 15041 break;
15042 }
15043 break;
a117b0a5 15044 case 0xee:
c7927a3c
NC		 15045 GETBYTE ();
15046 switch (op[2] & 0x00)
15047 {
15048 case 0x00:
a117b0a5 15049 goto op_semantics_117;
c7927a3c
NC		 15050 break;
15051 }
15052 break;
a117b0a5 15053 case 0xef:
c7927a3c
NC		 15054 GETBYTE ();
15055 switch (op[2] & 0x00)
15056 {
15057 case 0x00:
a117b0a5 15058 goto op_semantics_117;
c7927a3c
NC		 15059 break;
15060 }
15061 break;
a117b0a5
YS		 15062 default: UNSUPPORTED(); break;
15063 }
15064 break;
15065 case 0xff:
15066 GETBYTE ();
15067 switch (op[1] & 0xff)
15068 {
15069 case 0x00:
c7927a3c
NC		 15070 GETBYTE ();
15071 switch (op[2] & 0x00)
15072 {
15073 case 0x00:
a117b0a5 15074 op_semantics_118:
c7927a3c 15075 {
a117b0a5 15076 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
e197589b 15077#line 549 "rx-decode.opc"
a117b0a5 15078 int rdst AU = op[1] & 0x0f;
e197589b 15079#line 549 "rx-decode.opc"
a117b0a5 15080 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 15081#line 549 "rx-decode.opc"
a117b0a5 15082 int srcb AU = op[2] & 0x0f;
c7927a3c
NC		 15083 if (trace)
15084 {
15085 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5
YS		 15086 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
15087 op[0], op[1], op[2]);
15088 printf (" rdst = 0x%x,", rdst);
15089 printf (" srca = 0x%x,", srca);
15090 printf (" srcb = 0x%x\n", srcb);
c7927a3c 15091 }
a117b0a5 15092 SYNTAX("sub %2, %1, %0");
e197589b 15093#line 549 "rx-decode.opc"
a117b0a5
YS		 15094 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15095
15096 /*----------------------------------------------------------------------*/
15097 /* SBB */
43e65147 15098
c7927a3c
NC		 15099 }
15100 break;
15101 }
15102 break;
a117b0a5 15103 case 0x01:
c7927a3c
NC		 15104 GETBYTE ();
15105 switch (op[2] & 0x00)
15106 {
15107 case 0x00:
a117b0a5 15108 goto op_semantics_118;
c7927a3c
NC		 15109 break;
15110 }
15111 break;
a117b0a5 15112 case 0x02:
c7927a3c
NC		 15113 GETBYTE ();
15114 switch (op[2] & 0x00)
15115 {
15116 case 0x00:
a117b0a5 15117 goto op_semantics_118;
c7927a3c
NC		 15118 break;
15119 }
15120 break;
a117b0a5 15121 case 0x03:
c7927a3c
NC		 15122 GETBYTE ();
15123 switch (op[2] & 0x00)
15124 {
15125 case 0x00:
a117b0a5 15126 goto op_semantics_118;
c7927a3c
NC		 15127 break;
15128 }
15129 break;
a117b0a5 15130 case 0x04:
c7927a3c
NC		 15131 GETBYTE ();
15132 switch (op[2] & 0x00)
15133 {
15134 case 0x00:
a117b0a5 15135 goto op_semantics_118;
c7927a3c
NC		 15136 break;
15137 }
15138 break;
a117b0a5 15139 case 0x05:
c7927a3c
NC		 15140 GETBYTE ();
15141 switch (op[2] & 0x00)
15142 {
15143 case 0x00:
a117b0a5 15144 goto op_semantics_118;
c7927a3c
NC		 15145 break;
15146 }
15147 break;
a117b0a5 15148 case 0x06:
c7927a3c
NC		 15149 GETBYTE ();
15150 switch (op[2] & 0x00)
15151 {
15152 case 0x00:
a117b0a5 15153 goto op_semantics_118;
c7927a3c
NC		 15154 break;
15155 }
15156 break;
a117b0a5 15157 case 0x07:
c7927a3c
NC		 15158 GETBYTE ();
15159 switch (op[2] & 0x00)
15160 {
15161 case 0x00:
a117b0a5 15162 goto op_semantics_118;
c7927a3c
NC		 15163 break;
15164 }
15165 break;
a117b0a5 15166 case 0x08:
c7927a3c
NC		 15167 GETBYTE ();
15168 switch (op[2] & 0x00)
15169 {
15170 case 0x00:
a117b0a5 15171 goto op_semantics_118;
c7927a3c
NC		 15172 break;
15173 }
15174 break;
a117b0a5 15175 case 0x09:
c7927a3c
NC		 15176 GETBYTE ();
15177 switch (op[2] & 0x00)
15178 {
15179 case 0x00:
a117b0a5 15180 goto op_semantics_118;
c7927a3c
NC		 15181 break;
15182 }
15183 break;
a117b0a5 15184 case 0x0a:
c7927a3c
NC		 15185 GETBYTE ();
15186 switch (op[2] & 0x00)
15187 {
15188 case 0x00:
a117b0a5 15189 goto op_semantics_118;
c7927a3c
NC		 15190 break;
15191 }
15192 break;
a117b0a5 15193 case 0x0b:
c7927a3c
NC		 15194 GETBYTE ();
15195 switch (op[2] & 0x00)
15196 {
15197 case 0x00:
a117b0a5 15198 goto op_semantics_118;
c7927a3c
NC		 15199 break;
15200 }
15201 break;
a117b0a5 15202 case 0x0c:
c7927a3c
NC		 15203 GETBYTE ();
15204 switch (op[2] & 0x00)
15205 {
15206 case 0x00:
a117b0a5 15207 goto op_semantics_118;
c7927a3c
NC		 15208 break;
15209 }
15210 break;
a117b0a5 15211 case 0x0d:
c7927a3c
NC		 15212 GETBYTE ();
15213 switch (op[2] & 0x00)
15214 {
15215 case 0x00:
a117b0a5 15216 goto op_semantics_118;
c7927a3c
NC		 15217 break;
15218 }
15219 break;
a117b0a5 15220 case 0x0e:
c7927a3c
NC		 15221 GETBYTE ();
15222 switch (op[2] & 0x00)
15223 {
15224 case 0x00:
a117b0a5 15225 goto op_semantics_118;
c7927a3c
NC		 15226 break;
15227 }
15228 break;
a117b0a5 15229 case 0x0f:
c7927a3c
NC		 15230 GETBYTE ();
15231 switch (op[2] & 0x00)
15232 {
15233 case 0x00:
a117b0a5 15234 goto op_semantics_118;
c7927a3c
NC		 15235 break;
15236 }
15237 break;
a117b0a5 15238 case 0x20:
c7927a3c
NC		 15239 GETBYTE ();
15240 switch (op[2] & 0x00)
15241 {
15242 case 0x00:
a117b0a5
YS		 15243 op_semantics_119:
15244 {
15245 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
e197589b 15246#line 516 "rx-decode.opc"
a117b0a5 15247 int rdst AU = op[1] & 0x0f;
e197589b 15248#line 516 "rx-decode.opc"
a117b0a5 15249 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 15250#line 516 "rx-decode.opc"
a117b0a5
YS		 15251 int srcb AU = op[2] & 0x0f;
15252 if (trace)
15253 {
15254 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15255 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
15256 op[0], op[1], op[2]);
15257 printf (" rdst = 0x%x,", rdst);
15258 printf (" srca = 0x%x,", srca);
15259 printf (" srcb = 0x%x\n", srcb);
15260 }
15261 SYNTAX("add %2, %1, %0");
e197589b 15262#line 516 "rx-decode.opc"
a117b0a5
YS		 15263 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15264
15265 /*----------------------------------------------------------------------*/
15266 /* CMP */
15267
15268 }
c7927a3c
NC		 15269 break;
15270 }
15271 break;
a117b0a5 15272 case 0x21:
c7927a3c
NC		 15273 GETBYTE ();
15274 switch (op[2] & 0x00)
15275 {
15276 case 0x00:
a117b0a5 15277 goto op_semantics_119;
c7927a3c
NC		 15278 break;
15279 }
15280 break;
a117b0a5 15281 case 0x22:
c7927a3c
NC		 15282 GETBYTE ();
15283 switch (op[2] & 0x00)
15284 {
15285 case 0x00:
a117b0a5 15286 goto op_semantics_119;
c7927a3c
NC		 15287 break;
15288 }
15289 break;
a117b0a5 15290 case 0x23:
c7927a3c
NC		 15291 GETBYTE ();
15292 switch (op[2] & 0x00)
15293 {
15294 case 0x00:
a117b0a5 15295 goto op_semantics_119;
c7927a3c
NC		 15296 break;
15297 }
15298 break;
a117b0a5 15299 case 0x24:
c7927a3c
NC		 15300 GETBYTE ();
15301 switch (op[2] & 0x00)
15302 {
15303 case 0x00:
a117b0a5 15304 goto op_semantics_119;
c7927a3c
NC		 15305 break;
15306 }
15307 break;
a117b0a5 15308 case 0x25:
c7927a3c
NC		 15309 GETBYTE ();
15310 switch (op[2] & 0x00)
15311 {
15312 case 0x00:
a117b0a5 15313 goto op_semantics_119;
c7927a3c
NC		 15314 break;
15315 }
15316 break;
a117b0a5 15317 case 0x26:
c7927a3c
NC		 15318 GETBYTE ();
15319 switch (op[2] & 0x00)
15320 {
15321 case 0x00:
a117b0a5 15322 goto op_semantics_119;
c7927a3c
NC		 15323 break;
15324 }
15325 break;
a117b0a5 15326 case 0x27:
c7927a3c
NC		 15327 GETBYTE ();
15328 switch (op[2] & 0x00)
15329 {
15330 case 0x00:
a117b0a5 15331 goto op_semantics_119;
c7927a3c
NC		 15332 break;
15333 }
15334 break;
a117b0a5 15335 case 0x28:
c7927a3c
NC		 15336 GETBYTE ();
15337 switch (op[2] & 0x00)
15338 {
15339 case 0x00:
a117b0a5 15340 goto op_semantics_119;
c7927a3c
NC		 15341 break;
15342 }
15343 break;
a117b0a5 15344 case 0x29:
c7927a3c
NC		 15345 GETBYTE ();
15346 switch (op[2] & 0x00)
15347 {
15348 case 0x00:
a117b0a5 15349 goto op_semantics_119;
c7927a3c
NC		 15350 break;
15351 }
15352 break;
a117b0a5 15353 case 0x2a:
c7927a3c
NC		 15354 GETBYTE ();
15355 switch (op[2] & 0x00)
15356 {
15357 case 0x00:
a117b0a5 15358 goto op_semantics_119;
c7927a3c
NC		 15359 break;
15360 }
15361 break;
a117b0a5 15362 case 0x2b:
c7927a3c
NC		 15363 GETBYTE ();
15364 switch (op[2] & 0x00)
15365 {
15366 case 0x00:
a117b0a5 15367 goto op_semantics_119;
c7927a3c
NC		 15368 break;
15369 }
15370 break;
a117b0a5 15371 case 0x2c:
c7927a3c
NC		 15372 GETBYTE ();
15373 switch (op[2] & 0x00)
15374 {
15375 case 0x00:
a117b0a5 15376 goto op_semantics_119;
c7927a3c
NC		 15377 break;
15378 }
15379 break;
a117b0a5 15380 case 0x2d:
c7927a3c
NC		 15381 GETBYTE ();
15382 switch (op[2] & 0x00)
15383 {
15384 case 0x00:
a117b0a5 15385 goto op_semantics_119;
c7927a3c
NC		 15386 break;
15387 }
15388 break;
a117b0a5 15389 case 0x2e:
c7927a3c
NC		 15390 GETBYTE ();
15391 switch (op[2] & 0x00)
15392 {
15393 case 0x00:
a117b0a5 15394 goto op_semantics_119;
c7927a3c
NC		 15395 break;
15396 }
15397 break;
a117b0a5 15398 case 0x2f:
c7927a3c
NC		 15399 GETBYTE ();
15400 switch (op[2] & 0x00)
15401 {
15402 case 0x00:
a117b0a5 15403 goto op_semantics_119;
c7927a3c
NC		 15404 break;
15405 }
15406 break;
a117b0a5 15407 case 0x30:
c7927a3c
NC		 15408 GETBYTE ();
15409 switch (op[2] & 0x00)
15410 {
15411 case 0x00:
a117b0a5
YS		 15412 op_semantics_120:
15413 {
15414 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
e197589b 15415#line 656 "rx-decode.opc"
a117b0a5 15416 int rdst AU = op[1] & 0x0f;
e197589b 15417#line 656 "rx-decode.opc"
a117b0a5 15418 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 15419#line 656 "rx-decode.opc"
a117b0a5
YS		 15420 int srcb AU = op[2] & 0x0f;
15421 if (trace)
15422 {
15423 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15424 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
15425 op[0], op[1], op[2]);
15426 printf (" rdst = 0x%x,", rdst);
15427 printf (" srca = 0x%x,", srca);
15428 printf (" srcb = 0x%x\n", srcb);
15429 }
15430 SYNTAX("mul %2, %1, %0");
e197589b 15431#line 656 "rx-decode.opc"
a117b0a5
YS		 15432 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15433
15434 /*----------------------------------------------------------------------*/
15435 /* EMUL */
15436
15437 }
c7927a3c
NC		 15438 break;
15439 }
15440 break;
a117b0a5 15441 case 0x31:
c7927a3c
NC		 15442 GETBYTE ();
15443 switch (op[2] & 0x00)
15444 {
15445 case 0x00:
a117b0a5 15446 goto op_semantics_120;
c7927a3c
NC		 15447 break;
15448 }
15449 break;
a117b0a5 15450 case 0x32:
c7927a3c
NC		 15451 GETBYTE ();
15452 switch (op[2] & 0x00)
15453 {
15454 case 0x00:
a117b0a5 15455 goto op_semantics_120;
c7927a3c
NC		 15456 break;
15457 }
15458 break;
a117b0a5 15459 case 0x33:
c7927a3c
NC		 15460 GETBYTE ();
15461 switch (op[2] & 0x00)
15462 {
15463 case 0x00:
a117b0a5 15464 goto op_semantics_120;
c7927a3c
NC		 15465 break;
15466 }
15467 break;
a117b0a5 15468 case 0x34:
c7927a3c
NC		 15469 GETBYTE ();
15470 switch (op[2] & 0x00)
15471 {
15472 case 0x00:
a117b0a5 15473 goto op_semantics_120;
c7927a3c
NC		 15474 break;
15475 }
15476 break;
a117b0a5 15477 case 0x35:
c7927a3c
NC		 15478 GETBYTE ();
15479 switch (op[2] & 0x00)
15480 {
15481 case 0x00:
a117b0a5 15482 goto op_semantics_120;
c7927a3c
NC		 15483 break;
15484 }
15485 break;
a117b0a5 15486 case 0x36:
c7927a3c
NC		 15487 GETBYTE ();
15488 switch (op[2] & 0x00)
15489 {
15490 case 0x00:
a117b0a5 15491 goto op_semantics_120;
c7927a3c
NC		 15492 break;
15493 }
15494 break;
a117b0a5 15495 case 0x37:
c7927a3c
NC		 15496 GETBYTE ();
15497 switch (op[2] & 0x00)
15498 {
15499 case 0x00:
a117b0a5 15500 goto op_semantics_120;
c7927a3c
NC		 15501 break;
15502 }
15503 break;
a117b0a5 15504 case 0x38:
c7927a3c
NC		 15505 GETBYTE ();
15506 switch (op[2] & 0x00)
15507 {
15508 case 0x00:
a117b0a5 15509 goto op_semantics_120;
c7927a3c
NC		 15510 break;
15511 }
15512 break;
a117b0a5 15513 case 0x39:
c7927a3c
NC		 15514 GETBYTE ();
15515 switch (op[2] & 0x00)
15516 {
15517 case 0x00:
a117b0a5 15518 goto op_semantics_120;
c7927a3c
NC		 15519 break;
15520 }
15521 break;
a117b0a5 15522 case 0x3a:
c7927a3c
NC		 15523 GETBYTE ();
15524 switch (op[2] & 0x00)
15525 {
15526 case 0x00:
a117b0a5 15527 goto op_semantics_120;
c7927a3c
NC		 15528 break;
15529 }
15530 break;
a117b0a5 15531 case 0x3b:
c7927a3c
NC		 15532 GETBYTE ();
15533 switch (op[2] & 0x00)
15534 {
15535 case 0x00:
a117b0a5 15536 goto op_semantics_120;
c7927a3c
NC		 15537 break;
15538 }
15539 break;
a117b0a5 15540 case 0x3c:
c7927a3c
NC		 15541 GETBYTE ();
15542 switch (op[2] & 0x00)
15543 {
15544 case 0x00:
a117b0a5 15545 goto op_semantics_120;
c7927a3c
NC		 15546 break;
15547 }
15548 break;
a117b0a5 15549 case 0x3d:
c7927a3c
NC		 15550 GETBYTE ();
15551 switch (op[2] & 0x00)
15552 {
15553 case 0x00:
a117b0a5 15554 goto op_semantics_120;
c7927a3c
NC		 15555 break;
15556 }
15557 break;
a117b0a5 15558 case 0x3e:
c7927a3c
NC		 15559 GETBYTE ();
15560 switch (op[2] & 0x00)
15561 {
15562 case 0x00:
a117b0a5 15563 goto op_semantics_120;
c7927a3c
NC		 15564 break;
15565 }
15566 break;
a117b0a5 15567 case 0x3f:
c7927a3c
NC		 15568 GETBYTE ();
15569 switch (op[2] & 0x00)
15570 {
15571 case 0x00:
a117b0a5 15572 goto op_semantics_120;
c7927a3c
NC		 15573 break;
15574 }
15575 break;
a117b0a5 15576 case 0x40:
c7927a3c
NC		 15577 GETBYTE ();
15578 switch (op[2] & 0x00)
15579 {
15580 case 0x00:
a117b0a5 15581 op_semantics_121:
c7927a3c 15582 {
a117b0a5 15583 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
e197589b 15584#line 426 "rx-decode.opc"
c7927a3c 15585 int rdst AU = op[1] & 0x0f;
e197589b 15586#line 426 "rx-decode.opc"
c7927a3c 15587 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 15588#line 426 "rx-decode.opc"
c7927a3c
NC		 15589 int srcb AU = op[2] & 0x0f;
15590 if (trace)
15591 {
15592 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 15593 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
c7927a3c
NC		 15594 op[0], op[1], op[2]);
15595 printf (" rdst = 0x%x,", rdst);
15596 printf (" srca = 0x%x,", srca);
15597 printf (" srcb = 0x%x\n", srcb);
15598 }
a117b0a5 15599 SYNTAX("and %2, %1, %0");
e197589b 15600#line 426 "rx-decode.opc"
a117b0a5 15601 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 15602
c7927a3c 15603 /*----------------------------------------------------------------------*/
a117b0a5 15604 /* OR */
43e65147 15605
c7927a3c
NC		 15606 }
15607 break;
15608 }
15609 break;
a117b0a5 15610 case 0x41:
c7927a3c
NC		 15611 GETBYTE ();
15612 switch (op[2] & 0x00)
15613 {
15614 case 0x00:
a117b0a5 15615 goto op_semantics_121;
c7927a3c
NC		 15616 break;
15617 }
15618 break;
a117b0a5 15619 case 0x42:
c7927a3c
NC		 15620 GETBYTE ();
15621 switch (op[2] & 0x00)
15622 {
15623 case 0x00:
a117b0a5 15624 goto op_semantics_121;
c7927a3c
NC		 15625 break;
15626 }
15627 break;
a117b0a5 15628 case 0x43:
c7927a3c
NC		 15629 GETBYTE ();
15630 switch (op[2] & 0x00)
15631 {
15632 case 0x00:
a117b0a5 15633 goto op_semantics_121;
c7927a3c
NC		 15634 break;
15635 }
15636 break;
a117b0a5 15637 case 0x44:
c7927a3c
NC		 15638 GETBYTE ();
15639 switch (op[2] & 0x00)
15640 {
15641 case 0x00:
a117b0a5 15642 goto op_semantics_121;
c7927a3c
NC		 15643 break;
15644 }
15645 break;
a117b0a5 15646 case 0x45:
c7927a3c
NC		 15647 GETBYTE ();
15648 switch (op[2] & 0x00)
15649 {
15650 case 0x00:
a117b0a5 15651 goto op_semantics_121;
c7927a3c
NC		 15652 break;
15653 }
15654 break;
a117b0a5 15655 case 0x46:
c7927a3c
NC		 15656 GETBYTE ();
15657 switch (op[2] & 0x00)
15658 {
15659 case 0x00:
a117b0a5 15660 goto op_semantics_121;
c7927a3c
NC		 15661 break;
15662 }
15663 break;
a117b0a5 15664 case 0x47:
c7927a3c
NC		 15665 GETBYTE ();
15666 switch (op[2] & 0x00)
15667 {
15668 case 0x00:
a117b0a5 15669 goto op_semantics_121;
c7927a3c
NC		 15670 break;
15671 }
15672 break;
a117b0a5 15673 case 0x48:
c7927a3c
NC		 15674 GETBYTE ();
15675 switch (op[2] & 0x00)
15676 {
15677 case 0x00:
a117b0a5 15678 goto op_semantics_121;
c7927a3c
NC		 15679 break;
15680 }
15681 break;
a117b0a5 15682 case 0x49:
c7927a3c
NC		 15683 GETBYTE ();
15684 switch (op[2] & 0x00)
15685 {
15686 case 0x00:
a117b0a5 15687 goto op_semantics_121;
c7927a3c
NC		 15688 break;
15689 }
15690 break;
a117b0a5 15691 case 0x4a:
c7927a3c
NC		 15692 GETBYTE ();
15693 switch (op[2] & 0x00)
15694 {
15695 case 0x00:
a117b0a5 15696 goto op_semantics_121;
c7927a3c
NC		 15697 break;
15698 }
15699 break;
a117b0a5 15700 case 0x4b:
c7927a3c
NC		 15701 GETBYTE ();
15702 switch (op[2] & 0x00)
15703 {
15704 case 0x00:
a117b0a5 15705 goto op_semantics_121;
c7927a3c
NC		 15706 break;
15707 }
15708 break;
a117b0a5 15709 case 0x4c:
c7927a3c
NC		 15710 GETBYTE ();
15711 switch (op[2] & 0x00)
15712 {
15713 case 0x00:
a117b0a5 15714 goto op_semantics_121;
c7927a3c
NC		 15715 break;
15716 }
15717 break;
a117b0a5 15718 case 0x4d:
c7927a3c
NC		 15719 GETBYTE ();
15720 switch (op[2] & 0x00)
15721 {
15722 case 0x00:
a117b0a5 15723 goto op_semantics_121;
c7927a3c
NC		 15724 break;
15725 }
15726 break;
a117b0a5 15727 case 0x4e:
c7927a3c
NC		 15728 GETBYTE ();
15729 switch (op[2] & 0x00)
15730 {
15731 case 0x00:
a117b0a5 15732 goto op_semantics_121;
c7927a3c
NC		 15733 break;
15734 }
15735 break;
a117b0a5 15736 case 0x4f:
c7927a3c
NC		 15737 GETBYTE ();
15738 switch (op[2] & 0x00)
15739 {
15740 case 0x00:
a117b0a5 15741 goto op_semantics_121;
c7927a3c
NC		 15742 break;
15743 }
15744 break;
a117b0a5 15745 case 0x50:
c7927a3c
NC		 15746 GETBYTE ();
15747 switch (op[2] & 0x00)
15748 {
15749 case 0x00:
a117b0a5 15750 op_semantics_122:
c7927a3c 15751 {
a117b0a5 15752 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
e197589b 15753#line 444 "rx-decode.opc"
c7927a3c 15754 int rdst AU = op[1] & 0x0f;
e197589b 15755#line 444 "rx-decode.opc"
c7927a3c 15756 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 15757#line 444 "rx-decode.opc"
c7927a3c
NC		 15758 int srcb AU = op[2] & 0x0f;
15759 if (trace)
15760 {
15761 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 15762 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
c7927a3c
NC		 15763 op[0], op[1], op[2]);
15764 printf (" rdst = 0x%x,", rdst);
15765 printf (" srca = 0x%x,", srca);
15766 printf (" srcb = 0x%x\n", srcb);
15767 }
a117b0a5 15768 SYNTAX("or %2, %1, %0");
e197589b 15769#line 444 "rx-decode.opc"
a117b0a5 15770 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 15771
c7927a3c 15772 /*----------------------------------------------------------------------*/
a117b0a5 15773 /* XOR */
43e65147 15774
c7927a3c
NC		 15775 }
15776 break;
15777 }
15778 break;
a117b0a5 15779 case 0x51:
c7927a3c
NC		 15780 GETBYTE ();
15781 switch (op[2] & 0x00)
15782 {
15783 case 0x00:
a117b0a5 15784 goto op_semantics_122;
c7927a3c
NC		 15785 break;
15786 }
15787 break;
a117b0a5 15788 case 0x52:
c7927a3c
NC		 15789 GETBYTE ();
15790 switch (op[2] & 0x00)
15791 {
15792 case 0x00:
a117b0a5 15793 goto op_semantics_122;
c7927a3c
NC		 15794 break;
15795 }
15796 break;
a117b0a5 15797 case 0x53:
c7927a3c
NC		 15798 GETBYTE ();
15799 switch (op[2] & 0x00)
15800 {
15801 case 0x00:
a117b0a5 15802 goto op_semantics_122;
c7927a3c
NC		 15803 break;
15804 }
15805 break;
a117b0a5 15806 case 0x54:
c7927a3c
NC		 15807 GETBYTE ();
15808 switch (op[2] & 0x00)
15809 {
15810 case 0x00:
a117b0a5 15811 goto op_semantics_122;
c7927a3c
NC		 15812 break;
15813 }
15814 break;
a117b0a5 15815 case 0x55:
c7927a3c
NC		 15816 GETBYTE ();
15817 switch (op[2] & 0x00)
15818 {
15819 case 0x00:
a117b0a5 15820 goto op_semantics_122;
c7927a3c
NC		 15821 break;
15822 }
15823 break;
a117b0a5 15824 case 0x56:
c7927a3c
NC		 15825 GETBYTE ();
15826 switch (op[2] & 0x00)
15827 {
15828 case 0x00:
a117b0a5 15829 goto op_semantics_122;
c7927a3c
NC		 15830 break;
15831 }
15832 break;
a117b0a5 15833 case 0x57:
c7927a3c
NC		 15834 GETBYTE ();
15835 switch (op[2] & 0x00)
15836 {
15837 case 0x00:
a117b0a5 15838 goto op_semantics_122;
c7927a3c
NC		 15839 break;
15840 }
15841 break;
a117b0a5 15842 case 0x58:
c7927a3c
NC		 15843 GETBYTE ();
15844 switch (op[2] & 0x00)
15845 {
15846 case 0x00:
a117b0a5 15847 goto op_semantics_122;
c7927a3c
NC		 15848 break;
15849 }
15850 break;
a117b0a5 15851 case 0x59:
c7927a3c
NC		 15852 GETBYTE ();
15853 switch (op[2] & 0x00)
15854 {
15855 case 0x00:
a117b0a5 15856 goto op_semantics_122;
c7927a3c
NC		 15857 break;
15858 }
15859 break;
a117b0a5 15860 case 0x5a:
c7927a3c
NC		 15861 GETBYTE ();
15862 switch (op[2] & 0x00)
15863 {
15864 case 0x00:
a117b0a5 15865 goto op_semantics_122;
c7927a3c
NC		 15866 break;
15867 }
15868 break;
a117b0a5 15869 case 0x5b:
c7927a3c
NC		 15870 GETBYTE ();
15871 switch (op[2] & 0x00)
15872 {
15873 case 0x00:
a117b0a5 15874 goto op_semantics_122;
c7927a3c
NC		 15875 break;
15876 }
15877 break;
a117b0a5 15878 case 0x5c:
c7927a3c
NC		 15879 GETBYTE ();
15880 switch (op[2] & 0x00)
15881 {
15882 case 0x00:
a117b0a5 15883 goto op_semantics_122;
c7927a3c
NC		 15884 break;
15885 }
15886 break;
a117b0a5 15887 case 0x5d:
c7927a3c
NC		 15888 GETBYTE ();
15889 switch (op[2] & 0x00)
15890 {
15891 case 0x00:
a117b0a5 15892 goto op_semantics_122;
c7927a3c
NC		 15893 break;
15894 }
15895 break;
a117b0a5 15896 case 0x5e:
c7927a3c
NC		 15897 GETBYTE ();
15898 switch (op[2] & 0x00)
15899 {
15900 case 0x00:
a117b0a5 15901 goto op_semantics_122;
c7927a3c
NC		 15902 break;
15903 }
15904 break;
a117b0a5 15905 case 0x5f:
c7927a3c
NC		 15906 GETBYTE ();
15907 switch (op[2] & 0x00)
15908 {
15909 case 0x00:
a117b0a5 15910 goto op_semantics_122;
c7927a3c
NC		 15911 break;
15912 }
15913 break;
a117b0a5 15914 case 0x80:
c7927a3c
NC		 15915 GETBYTE ();
15916 switch (op[2] & 0x00)
15917 {
15918 case 0x00:
a117b0a5 15919 op_semantics_123:
c7927a3c 15920 {
a117b0a5 15921 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
e197589b 15922#line 1104 "rx-decode.opc"
c7927a3c 15923 int rdst AU = op[1] & 0x0f;
e197589b 15924#line 1104 "rx-decode.opc"
c7927a3c 15925 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 15926#line 1104 "rx-decode.opc"
c7927a3c
NC		 15927 int srcb AU = op[2] & 0x0f;
15928 if (trace)
15929 {
15930 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 15931 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
c7927a3c
NC		 15932 op[0], op[1], op[2]);
15933 printf (" rdst = 0x%x,", rdst);
15934 printf (" srca = 0x%x,", srca);
15935 printf (" srcb = 0x%x\n", srcb);
15936 }
a117b0a5 15937 SYNTAX("fsub %2, %1, %0");
e197589b 15938#line 1104 "rx-decode.opc"
a117b0a5 15939 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 15940
c7927a3c
NC		 15941 }
15942 break;
15943 }
15944 break;
a117b0a5 15945 case 0x81:
c7927a3c
NC		 15946 GETBYTE ();
15947 switch (op[2] & 0x00)
15948 {
15949 case 0x00:
a117b0a5 15950 goto op_semantics_123;
c7927a3c
NC		 15951 break;
15952 }
15953 break;
a117b0a5 15954 case 0x82:
c7927a3c
NC		 15955 GETBYTE ();
15956 switch (op[2] & 0x00)
15957 {
15958 case 0x00:
a117b0a5 15959 goto op_semantics_123;
c7927a3c
NC		 15960 break;
15961 }
15962 break;
a117b0a5 15963 case 0x83:
c7927a3c
NC		 15964 GETBYTE ();
15965 switch (op[2] & 0x00)
15966 {
15967 case 0x00:
a117b0a5 15968 goto op_semantics_123;
c7927a3c
NC		 15969 break;
15970 }
15971 break;
a117b0a5 15972 case 0x84:
c7927a3c
NC		 15973 GETBYTE ();
15974 switch (op[2] & 0x00)
15975 {
15976 case 0x00:
a117b0a5 15977 goto op_semantics_123;
c7927a3c
NC		 15978 break;
15979 }
15980 break;
a117b0a5 15981 case 0x85:
c7927a3c
NC		 15982 GETBYTE ();
15983 switch (op[2] & 0x00)
15984 {
15985 case 0x00:
a117b0a5 15986 goto op_semantics_123;
c7927a3c
NC		 15987 break;
15988 }
15989 break;
a117b0a5 15990 case 0x86:
c7927a3c
NC		 15991 GETBYTE ();
15992 switch (op[2] & 0x00)
15993 {
15994 case 0x00:
a117b0a5 15995 goto op_semantics_123;
c7927a3c
NC		 15996 break;
15997 }
15998 break;
a117b0a5 15999 case 0x87:
c7927a3c
NC		 16000 GETBYTE ();
16001 switch (op[2] & 0x00)
16002 {
16003 case 0x00:
a117b0a5 16004 goto op_semantics_123;
c7927a3c
NC		 16005 break;
16006 }
16007 break;
a117b0a5 16008 case 0x88:
c7927a3c
NC		 16009 GETBYTE ();
16010 switch (op[2] & 0x00)
16011 {
16012 case 0x00:
a117b0a5 16013 goto op_semantics_123;
c7927a3c
NC		 16014 break;
16015 }
16016 break;
a117b0a5 16017 case 0x89:
c7927a3c
NC		 16018 GETBYTE ();
16019 switch (op[2] & 0x00)
16020 {
16021 case 0x00:
a117b0a5 16022 goto op_semantics_123;
c7927a3c
NC		 16023 break;
16024 }
16025 break;
a117b0a5 16026 case 0x8a:
c7927a3c
NC		 16027 GETBYTE ();
16028 switch (op[2] & 0x00)
16029 {
16030 case 0x00:
a117b0a5 16031 goto op_semantics_123;
c7927a3c
NC		 16032 break;
16033 }
16034 break;
a117b0a5 16035 case 0x8b:
c7927a3c
NC		 16036 GETBYTE ();
16037 switch (op[2] & 0x00)
16038 {
16039 case 0x00:
a117b0a5 16040 goto op_semantics_123;
c7927a3c
NC		 16041 break;
16042 }
16043 break;
a117b0a5 16044 case 0x8c:
c7927a3c
NC		 16045 GETBYTE ();
16046 switch (op[2] & 0x00)
16047 {
16048 case 0x00:
a117b0a5 16049 goto op_semantics_123;
c7927a3c
NC		 16050 break;
16051 }
16052 break;
a117b0a5 16053 case 0x8d:
c7927a3c
NC		 16054 GETBYTE ();
16055 switch (op[2] & 0x00)
16056 {
16057 case 0x00:
a117b0a5 16058 goto op_semantics_123;
c7927a3c
NC		 16059 break;
16060 }
16061 break;
a117b0a5 16062 case 0x8e:
c7927a3c
NC		 16063 GETBYTE ();
16064 switch (op[2] & 0x00)
16065 {
16066 case 0x00:
a117b0a5 16067 goto op_semantics_123;
c7927a3c
NC		 16068 break;
16069 }
16070 break;
a117b0a5 16071 case 0x8f:
c7927a3c
NC		 16072 GETBYTE ();
16073 switch (op[2] & 0x00)
16074 {
16075 case 0x00:
a117b0a5 16076 goto op_semantics_123;
c7927a3c
NC		 16077 break;
16078 }
16079 break;
a117b0a5 16080 case 0xa0:
c7927a3c
NC		 16081 GETBYTE ();
16082 switch (op[2] & 0x00)
16083 {
16084 case 0x00:
a117b0a5 16085 op_semantics_124:
c7927a3c 16086 {
a117b0a5 16087 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
e197589b 16088#line 1101 "rx-decode.opc"
c7927a3c 16089 int rdst AU = op[1] & 0x0f;
e197589b 16090#line 1101 "rx-decode.opc"
c7927a3c 16091 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 16092#line 1101 "rx-decode.opc"
c7927a3c
NC		 16093 int srcb AU = op[2] & 0x0f;
16094 if (trace)
16095 {
16096 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 16097 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
c7927a3c
NC		 16098 op[0], op[1], op[2]);
16099 printf (" rdst = 0x%x,", rdst);
16100 printf (" srca = 0x%x,", srca);
16101 printf (" srcb = 0x%x\n", srcb);
16102 }
a117b0a5 16103 SYNTAX("fadd %2, %1, %0");
e197589b 16104#line 1101 "rx-decode.opc"
a117b0a5 16105 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 16106
c7927a3c
NC		 16107 }
16108 break;
16109 }
16110 break;
a117b0a5 16111 case 0xa1:
c7927a3c
NC		 16112 GETBYTE ();
16113 switch (op[2] & 0x00)
16114 {
16115 case 0x00:
a117b0a5 16116 goto op_semantics_124;
c7927a3c
NC		 16117 break;
16118 }
16119 break;
a117b0a5 16120 case 0xa2:
c7927a3c
NC		 16121 GETBYTE ();
16122 switch (op[2] & 0x00)
16123 {
16124 case 0x00:
a117b0a5 16125 goto op_semantics_124;
c7927a3c
NC		 16126 break;
16127 }
16128 break;
a117b0a5 16129 case 0xa3:
c7927a3c
NC		 16130 GETBYTE ();
16131 switch (op[2] & 0x00)
16132 {
16133 case 0x00:
a117b0a5 16134 goto op_semantics_124;
c7927a3c
NC		 16135 break;
16136 }
16137 break;
a117b0a5 16138 case 0xa4:
c7927a3c
NC		 16139 GETBYTE ();
16140 switch (op[2] & 0x00)
16141 {
16142 case 0x00:
a117b0a5 16143 goto op_semantics_124;
c7927a3c
NC		 16144 break;
16145 }
16146 break;
a117b0a5 16147 case 0xa5:
c7927a3c
NC		 16148 GETBYTE ();
16149 switch (op[2] & 0x00)
16150 {
16151 case 0x00:
a117b0a5 16152 goto op_semantics_124;
c7927a3c
NC		 16153 break;
16154 }
16155 break;
a117b0a5 16156 case 0xa6:
c7927a3c
NC		 16157 GETBYTE ();
16158 switch (op[2] & 0x00)
16159 {
16160 case 0x00:
a117b0a5 16161 goto op_semantics_124;
c7927a3c
NC		 16162 break;
16163 }
16164 break;
a117b0a5 16165 case 0xa7:
c7927a3c
NC		 16166 GETBYTE ();
16167 switch (op[2] & 0x00)
16168 {
16169 case 0x00:
a117b0a5 16170 goto op_semantics_124;
c7927a3c
NC		 16171 break;
16172 }
16173 break;
a117b0a5 16174 case 0xa8:
c7927a3c
NC		 16175 GETBYTE ();
16176 switch (op[2] & 0x00)
16177 {
16178 case 0x00:
a117b0a5 16179 goto op_semantics_124;
c7927a3c
NC		 16180 break;
16181 }
16182 break;
a117b0a5 16183 case 0xa9:
c7927a3c
NC		 16184 GETBYTE ();
16185 switch (op[2] & 0x00)
16186 {
16187 case 0x00:
a117b0a5 16188 goto op_semantics_124;
c7927a3c
NC		 16189 break;
16190 }
16191 break;
a117b0a5 16192 case 0xaa:
c7927a3c
NC		 16193 GETBYTE ();
16194 switch (op[2] & 0x00)
16195 {
16196 case 0x00:
a117b0a5 16197 goto op_semantics_124;
c7927a3c
NC		 16198 break;
16199 }
16200 break;
a117b0a5 16201 case 0xab:
c7927a3c
NC		 16202 GETBYTE ();
16203 switch (op[2] & 0x00)
16204 {
16205 case 0x00:
a117b0a5 16206 goto op_semantics_124;
c7927a3c
NC		 16207 break;
16208 }
16209 break;
a117b0a5 16210 case 0xac:
c7927a3c
NC		 16211 GETBYTE ();
16212 switch (op[2] & 0x00)
16213 {
16214 case 0x00:
a117b0a5 16215 goto op_semantics_124;
c7927a3c
NC		 16216 break;
16217 }
16218 break;
a117b0a5 16219 case 0xad:
c7927a3c
NC		 16220 GETBYTE ();
16221 switch (op[2] & 0x00)
16222 {
16223 case 0x00:
a117b0a5 16224 goto op_semantics_124;
c7927a3c
NC		 16225 break;
16226 }
16227 break;
a117b0a5 16228 case 0xae:
c7927a3c
NC		 16229 GETBYTE ();
16230 switch (op[2] & 0x00)
16231 {
16232 case 0x00:
a117b0a5 16233 goto op_semantics_124;
c7927a3c
NC		 16234 break;
16235 }
16236 break;
a117b0a5 16237 case 0xaf:
c7927a3c
NC		 16238 GETBYTE ();
16239 switch (op[2] & 0x00)
16240 {
16241 case 0x00:
a117b0a5 16242 goto op_semantics_124;
c7927a3c
NC		 16243 break;
16244 }
16245 break;
a117b0a5 16246 case 0xb0:
c7927a3c
NC		 16247 GETBYTE ();
16248 switch (op[2] & 0x00)
16249 {
16250 case 0x00:
a117b0a5 16251 op_semantics_125:
c7927a3c 16252 {
a117b0a5 16253 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
e197589b 16254#line 1107 "rx-decode.opc"
c7927a3c 16255 int rdst AU = op[1] & 0x0f;
e197589b 16256#line 1107 "rx-decode.opc"
c7927a3c 16257 int srca AU = (op[2] >> 4) & 0x0f;
e197589b 16258#line 1107 "rx-decode.opc"
c7927a3c
NC		 16259 int srcb AU = op[2] & 0x0f;
16260 if (trace)
16261 {
16262 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
a117b0a5 16263 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
c7927a3c
NC		 16264 op[0], op[1], op[2]);
16265 printf (" rdst = 0x%x,", rdst);
16266 printf (" srca = 0x%x,", srca);
16267 printf (" srcb = 0x%x\n", srcb);
16268 }
a117b0a5 16269 SYNTAX("fmul %2, %1, %0");
e197589b 16270#line 1107 "rx-decode.opc"
a117b0a5 16271 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
43e65147 16272
c7927a3c
NC		 16273 }
16274 break;
16275 }
16276 break;
a117b0a5 16277 case 0xb1:
c7927a3c
NC		 16278 GETBYTE ();
16279 switch (op[2] & 0x00)
16280 {
16281 case 0x00:
a117b0a5 16282 goto op_semantics_125;
c7927a3c
NC		 16283 break;
16284 }
16285 break;
a117b0a5 16286 case 0xb2:
c7927a3c
NC		 16287 GETBYTE ();
16288 switch (op[2] & 0x00)
16289 {
16290 case 0x00:
a117b0a5 16291 goto op_semantics_125;
c7927a3c
NC		 16292 break;
16293 }
16294 break;
a117b0a5 16295 case 0xb3:
c7927a3c
NC		 16296 GETBYTE ();
16297 switch (op[2] & 0x00)
16298 {
16299 case 0x00:
a117b0a5 16300 goto op_semantics_125;
c7927a3c
NC		 16301 break;
16302 }
16303 break;
a117b0a5 16304 case 0xb4:
c7927a3c
NC		 16305 GETBYTE ();
16306 switch (op[2] & 0x00)
16307 {
16308 case 0x00:
a117b0a5 16309 goto op_semantics_125;
c7927a3c
NC		 16310 break;
16311 }
16312 break;
a117b0a5 16313 case 0xb5:
c7927a3c
NC		 16314 GETBYTE ();
16315 switch (op[2] & 0x00)
16316 {
16317 case 0x00:
a117b0a5 16318 goto op_semantics_125;
c7927a3c
NC		 16319 break;
16320 }
16321 break;
a117b0a5 16322 case 0xb6:
c7927a3c
NC		 16323 GETBYTE ();
16324 switch (op[2] & 0x00)
16325 {
16326 case 0x00:
a117b0a5 16327 goto op_semantics_125;
c7927a3c
NC		 16328 break;
16329 }
16330 break;
a117b0a5 16331 case 0xb7:
c7927a3c
NC		 16332 GETBYTE ();
16333 switch (op[2] & 0x00)
16334 {
16335 case 0x00:
a117b0a5 16336 goto op_semantics_125;
c7927a3c
NC		 16337 break;
16338 }
16339 break;
a117b0a5 16340 case 0xb8:
c7927a3c
NC		 16341 GETBYTE ();
16342 switch (op[2] & 0x00)
16343 {
16344 case 0x00:
a117b0a5 16345 goto op_semantics_125;
c7927a3c
NC		 16346 break;
16347 }
16348 break;
a117b0a5 16349 case 0xb9:
c7927a3c
NC		 16350 GETBYTE ();
16351 switch (op[2] & 0x00)
16352 {
16353 case 0x00:
a117b0a5 16354 goto op_semantics_125;
c7927a3c
NC		 16355 break;
16356 }
16357 break;
a117b0a5 16358 case 0xba:
c7927a3c
NC		 16359 GETBYTE ();
16360 switch (op[2] & 0x00)
16361 {
16362 case 0x00:
a117b0a5 16363 goto op_semantics_125;
c7927a3c
NC		 16364 break;
16365 }
16366 break;
a117b0a5 16367 case 0xbb:
c7927a3c
NC		 16368 GETBYTE ();
16369 switch (op[2] & 0x00)
16370 {
16371 case 0x00:
a117b0a5 16372 goto op_semantics_125;
c7927a3c
NC		 16373 break;
16374 }
16375 break;
a117b0a5 16376 case 0xbc:
c7927a3c
NC		 16377 GETBYTE ();
16378 switch (op[2] & 0x00)
16379 {
16380 case 0x00:
a117b0a5 16381 goto op_semantics_125;
c7927a3c
NC		 16382 break;
16383 }
16384 break;
a117b0a5 16385 case 0xbd:
c7927a3c
NC		 16386 GETBYTE ();
16387 switch (op[2] & 0x00)
16388 {
16389 case 0x00:
a117b0a5 16390 goto op_semantics_125;
c7927a3c
NC		 16391 break;
16392 }
16393 break;
a117b0a5 16394 case 0xbe:
c7927a3c
NC		 16395 GETBYTE ();
16396 switch (op[2] & 0x00)
16397 {
16398 case 0x00:
a117b0a5 16399 goto op_semantics_125;
c7927a3c
NC		 16400 break;
16401 }
16402 break;
a117b0a5 16403 case 0xbf:
c7927a3c
NC		 16404 GETBYTE ();
16405 switch (op[2] & 0x00)
16406 {
16407 case 0x00:
a117b0a5 16408 goto op_semantics_125;
c7927a3c
NC		 16409 break;
16410 }
16411 break;
16412 default: UNSUPPORTED(); break;
16413 }
16414 break;
16415 default: UNSUPPORTED(); break;
16416 }
e197589b 16417#line 1122 "rx-decode.opc"
c7927a3c
NC		 16418
16419 return rx->n_bytes;
16420}
A mirror of the official binutils-gdb repository