projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* lib/ld-lib.exp (run_dump_test): For options "warning" and
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
CommitLineData
f282425e 1#line 1 "rx-decode.opc"
c7927a3c
NC		 2/* -*- c -*- */
3#include <stdio.h>
4#include <stdlib.h>
5#include <string.h>
6
7#include "config.h"
8#include "ansidecl.h"
9#include "opcode/rx.h"
10
11#define RX_OPCODE_BIG_ENDIAN 0
12
13typedef struct
14{
15 RX_Opcode_Decoded * rx;
16 int (* getbyte)(void *);
17 void * ptr;
18 unsigned char * op;
19} LocalData;
20
21static int trace = 0;
22
23#define BSIZE 0
24#define WSIZE 1
25#define LSIZE 2
26
27/* These are for when the upper bits are "don't care" or "undefined". */
28static int bwl[] =
29{
30 RX_Byte,
31 RX_Word,
32 RX_Long
33};
34
35static int sbwl[] =
36{
37 RX_SByte,
38 RX_SWord,
39 RX_Long
40};
41
42static int ubwl[] =
43{
44 RX_UByte,
45 RX_UWord,
46 RX_Long
47};
48
49static int memex[] =
50{
51 RX_SByte,
52 RX_SWord,
53 RX_Long,
54 RX_UWord
55};
56
57#define ID(x) rx->id = RXO_##x
58#define OP(n,t,r,a) (rx->op[n].type = t, \
59 rx->op[n].reg = r, \
60 rx->op[n].addend = a )
61#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
62 rx->op[n].size = s )
63
64/* This is for the BWL and BW bitfields. */
65static int SCALE[] = { 1, 2, 4 };
66/* This is for the prefix size enum. */
67static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
68
69static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
70 16, 17, 0, 0, 0, 0, 0, 0 };
71
72static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
73
74/*
75 *C a constant (immediate) c
76 *R A register
77 *I Register indirect, no offset
78 *Is Register indirect, with offset
79 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
80 *P standard displacement: type (r,[r]), reg, assumes UByte
81 *Pm memex displacement: type (r,[r]), reg, memex code
82 *cc condition code. */
83
84#define DC(c) OP (0, RX_Operand_Immediate, 0, c)
85#define DR(r) OP (0, RX_Operand_Register, r, 0)
86#define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
87#define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
88#define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
89#define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
90
91#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
92#define SR(r) OP (1, RX_Operand_Register, r, 0)
f9c7014e 93#define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
c7927a3c
NC		 94#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
95#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
96#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
97#define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
98#define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
99#define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
100
101#define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
102#define S2R(r) OP (2, RX_Operand_Register, r, 0)
103#define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
104#define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
105#define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
106#define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
107#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
108#define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
109
110#define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
111#define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
112#define uBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
113#define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
114
115#define F(f) store_flags(rx, f)
116
117#define AU ATTRIBUTE_UNUSED
118#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
119
120#define SYNTAX(x) rx->syntax = x
121
122#define UNSUPPORTED() \
123 rx->syntax = "*unknown*"
124
125#define IMM(sf) immediate (sf, 0, ld)
126#define IMMex(sf) immediate (sf, 1, ld)
127
128static int
129immediate (int sfield, int ex, LocalData * ld)
130{
131 unsigned long i = 0, j;
132
133 switch (sfield)
134 {
135#define B ((unsigned long) GETBYTE())
136 case 0:
137#if RX_OPCODE_BIG_ENDIAN
138 i = B;
139 if (ex && (i & 0x80))
140 i -= 0x100;
141 i <<= 24;
142 i |= B << 16;
143 i |= B << 8;
144 i |= B;
145#else
146 i = B;
147 i |= B << 8;
148 i |= B << 16;
149 j = B;
150 if (ex && (j & 0x80))
151 j -= 0x100;
152 i |= j << 24;
153#endif
154 break;
155 case 3:
156#if RX_OPCODE_BIG_ENDIAN
157 i = B << 16;
158 i |= B << 8;
159 i |= B;
160#else
161 i = B;
162 i |= B << 8;
163 i |= B << 16;
164#endif
165 if (ex && (i & 0x800000))
166 i -= 0x1000000;
167 break;
168 case 2:
169#if RX_OPCODE_BIG_ENDIAN
170 i |= B << 8;
171 i |= B;
172#else
173 i |= B;
174 i |= B << 8;
175#endif
176 if (ex && (i & 0x8000))
177 i -= 0x10000;
178 break;
179 case 1:
180 i |= B;
181 if (ex && (i & 0x80))
182 i -= 0x100;
183 break;
184 default:
185 abort();
186 }
187 return i;
188}
189
190static void
191rx_disp (int n, int type, int reg, int size, LocalData * ld)
192{
193 int disp;
194
195 ld->rx->op[n].reg = reg;
196 switch (type)
197 {
198 case 3:
199 ld->rx->op[n].type = RX_Operand_Register;
200 break;
201 case 0:
202 ld->rx->op[n].type = RX_Operand_Indirect;
203 ld->rx->op[n].addend = 0;
204 break;
205 case 1:
206 ld->rx->op[n].type = RX_Operand_Indirect;
207 disp = GETBYTE ();
208 ld->rx->op[n].addend = disp * PSCALE[size];
209 break;
210 case 2:
211 ld->rx->op[n].type = RX_Operand_Indirect;
212 disp = GETBYTE ();
213#if RX_OPCODE_BIG_ENDIAN
214 disp = disp * 256 + GETBYTE ();
215#else
216 disp = disp + GETBYTE () * 256;
217#endif
218 ld->rx->op[n].addend = disp * PSCALE[size];
219 break;
220 default:
221 abort ();
222 }
223}
224
3cf79a01
DD		 225#define xO 8
226#define xS 4
227#define xZ 2
228#define xC 1
c7927a3c 229
3cf79a01
DD		 230#define F_____
231#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
232#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
233#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
234#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
235#define F_O___ rx->flags_0 = rx->flags_s = xO;
236#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
237#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
238#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
c7927a3c
NC		 239
240int
241rx_decode_opcode (unsigned long pc AU,
242 RX_Opcode_Decoded * rx,
243 int (* getbyte)(void *),
244 void * ptr)
245{
246 LocalData lds, * ld = &lds;
247 unsigned char op[20] = {0};
248
249 lds.rx = rx;
250 lds.getbyte = getbyte;
251 lds.ptr = ptr;
252 lds.op = op;
253
254 memset (rx, 0, sizeof (*rx));
255 BWL(LSIZE);
256
257
258/*----------------------------------------------------------------------*/
259/* MOV */
260
261 GETBYTE ();
262 switch (op[0] & 0xff)
263 {
264 case 0x00:
265 {
266 /** 0000 0000 brk */
267 if (trace)
268 {
269 printf ("\033[33m%s\033[0m %02x\n",
270 "/** 0000 0000 brk */",
271 op[0]);
272 }
273 SYNTAX("brk");
78e98aab 274#line 956 "rx-decode.opc"
c7927a3c
NC		 275 ID(brk);
276
277 }
278 break;
279 case 0x01:
280 {
281 /** 0000 0001 dbt */
282 if (trace)
283 {
284 printf ("\033[33m%s\033[0m %02x\n",
285 "/** 0000 0001 dbt */",
286 op[0]);
287 }
288 SYNTAX("dbt");
78e98aab 289#line 959 "rx-decode.opc"
c7927a3c
NC		 290 ID(dbt);
291
292 }
293 break;
294 case 0x02:
295 {
296 /** 0000 0010 rts */
297 if (trace)
298 {
299 printf ("\033[33m%s\033[0m %02x\n",
300 "/** 0000 0010 rts */",
301 op[0]);
302 }
303 SYNTAX("rts");
78e98aab 304#line 745 "rx-decode.opc"
c7927a3c
NC		 305 ID(rts);
306
307 /*----------------------------------------------------------------------*/
308 /* NOP */
309
310 }
311 break;
312 case 0x03:
313 {
314 /** 0000 0011 nop */
315 if (trace)
316 {
317 printf ("\033[33m%s\033[0m %02x\n",
318 "/** 0000 0011 nop */",
319 op[0]);
320 }
321 SYNTAX("nop");
78e98aab 322#line 751 "rx-decode.opc"
c7927a3c
NC		 323 ID(nop);
324
325 /*----------------------------------------------------------------------*/
326 /* STRING FUNCTIONS */
327
328 }
329 break;
330 case 0x04:
331 {
332 /** 0000 0100 bra.a %a0 */
333 if (trace)
334 {
335 printf ("\033[33m%s\033[0m %02x\n",
336 "/** 0000 0100 bra.a %a0 */",
337 op[0]);
338 }
339 SYNTAX("bra.a %a0");
78e98aab 340#line 723 "rx-decode.opc"
f9c7014e 341 ID(branch); DC(pc + IMMex(3));
c7927a3c
NC		 342
343 }
344 break;
345 case 0x05:
346 {
347 /** 0000 0101 bsr.a %a0 */
348 if (trace)
349 {
350 printf ("\033[33m%s\033[0m %02x\n",
351 "/** 0000 0101 bsr.a %a0 */",
352 op[0]);
353 }
354 SYNTAX("bsr.a %a0");
78e98aab 355#line 739 "rx-decode.opc"
c7927a3c
NC		 356 ID(jsr); DC(pc + IMMex(3));
357
358 }
359 break;
360 case 0x06:
361 GETBYTE ();
362 switch (op[1] & 0xff)
363 {
364 case 0x00:
365 GETBYTE ();
366 switch (op[2] & 0x00)
367 {
368 case 0x00:
369 op_semantics_1:
370 {
371 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
78e98aab 372#line 519 "rx-decode.opc"
c7927a3c 373 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 374#line 519 "rx-decode.opc"
c7927a3c 375 int ss AU = op[1] & 0x03;
78e98aab 376#line 519 "rx-decode.opc"
c7927a3c 377 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 378#line 519 "rx-decode.opc"
c7927a3c
NC		 379 int rdst AU = op[2] & 0x0f;
380 if (trace)
381 {
382 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
383 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
384 op[0], op[1], op[2]);
385 printf (" mx = 0x%x,", mx);
386 printf (" ss = 0x%x,", ss);
387 printf (" rsrc = 0x%x,", rsrc);
388 printf (" rdst = 0x%x\n", rdst);
389 }
390 SYNTAX("sub %2%S2, %1");
78e98aab 391#line 519 "rx-decode.opc"
3cf79a01 392 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 393
394 }
395 break;
396 }
397 break;
398 case 0x01:
399 GETBYTE ();
400 switch (op[2] & 0x00)
401 {
402 case 0x00:
403 goto op_semantics_1;
404 break;
405 }
406 break;
407 case 0x02:
408 GETBYTE ();
409 switch (op[2] & 0x00)
410 {
411 case 0x00:
412 goto op_semantics_1;
413 break;
414 }
415 break;
416 case 0x03:
417 GETBYTE ();
418 switch (op[2] & 0x00)
419 {
420 case 0x00:
421 goto op_semantics_1;
422 break;
423 }
424 break;
425 case 0x04:
426 GETBYTE ();
427 switch (op[2] & 0x00)
428 {
429 case 0x00:
430 op_semantics_2:
431 {
432 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
78e98aab 433#line 507 "rx-decode.opc"
c7927a3c 434 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 435#line 507 "rx-decode.opc"
c7927a3c 436 int ss AU = op[1] & 0x03;
78e98aab 437#line 507 "rx-decode.opc"
c7927a3c 438 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 439#line 507 "rx-decode.opc"
c7927a3c
NC		 440 int rdst AU = op[2] & 0x0f;
441 if (trace)
442 {
443 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
444 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
445 op[0], op[1], op[2]);
446 printf (" mx = 0x%x,", mx);
447 printf (" ss = 0x%x,", ss);
448 printf (" rsrc = 0x%x,", rsrc);
449 printf (" rdst = 0x%x\n", rdst);
450 }
451 SYNTAX("cmp %2%S2, %1");
78e98aab 452#line 507 "rx-decode.opc"
3cf79a01 453 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
c7927a3c
NC		 454
455 /*----------------------------------------------------------------------*/
456 /* SUB */
457
458 }
459 break;
460 }
461 break;
462 case 0x05:
463 GETBYTE ();
464 switch (op[2] & 0x00)
465 {
466 case 0x00:
467 goto op_semantics_2;
468 break;
469 }
470 break;
471 case 0x06:
472 GETBYTE ();
473 switch (op[2] & 0x00)
474 {
475 case 0x00:
476 goto op_semantics_2;
477 break;
478 }
479 break;
480 case 0x07:
481 GETBYTE ();
482 switch (op[2] & 0x00)
483 {
484 case 0x00:
485 goto op_semantics_2;
486 break;
487 }
488 break;
489 case 0x08:
490 GETBYTE ();
491 switch (op[2] & 0x00)
492 {
493 case 0x00:
494 op_semantics_3:
495 {
496 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
78e98aab 497#line 483 "rx-decode.opc"
c7927a3c 498 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 499#line 483 "rx-decode.opc"
c7927a3c 500 int ss AU = op[1] & 0x03;
78e98aab 501#line 483 "rx-decode.opc"
c7927a3c 502 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 503#line 483 "rx-decode.opc"
c7927a3c
NC		 504 int rdst AU = op[2] & 0x0f;
505 if (trace)
506 {
507 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
508 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
509 op[0], op[1], op[2]);
510 printf (" mx = 0x%x,", mx);
511 printf (" ss = 0x%x,", ss);
512 printf (" rsrc = 0x%x,", rsrc);
513 printf (" rdst = 0x%x\n", rdst);
514 }
515 SYNTAX("add %1%S1, %0");
78e98aab 516#line 483 "rx-decode.opc"
3cf79a01 517 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
c7927a3c
NC		 518
519 }
520 break;
521 }
522 break;
523 case 0x09:
524 GETBYTE ();
525 switch (op[2] & 0x00)
526 {
527 case 0x00:
528 goto op_semantics_3;
529 break;
530 }
531 break;
532 case 0x0a:
533 GETBYTE ();
534 switch (op[2] & 0x00)
535 {
536 case 0x00:
537 goto op_semantics_3;
538 break;
539 }
540 break;
541 case 0x0b:
542 GETBYTE ();
543 switch (op[2] & 0x00)
544 {
545 case 0x00:
546 goto op_semantics_3;
547 break;
548 }
549 break;
550 case 0x0c:
551 GETBYTE ();
552 switch (op[2] & 0x00)
553 {
554 case 0x00:
555 op_semantics_4:
556 {
557 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
78e98aab 558#line 588 "rx-decode.opc"
c7927a3c 559 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 560#line 588 "rx-decode.opc"
c7927a3c 561 int ss AU = op[1] & 0x03;
78e98aab 562#line 588 "rx-decode.opc"
c7927a3c 563 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 564#line 588 "rx-decode.opc"
c7927a3c
NC		 565 int rdst AU = op[2] & 0x0f;
566 if (trace)
567 {
568 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
569 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
570 op[0], op[1], op[2]);
571 printf (" mx = 0x%x,", mx);
572 printf (" ss = 0x%x,", ss);
573 printf (" rsrc = 0x%x,", rsrc);
574 printf (" rdst = 0x%x\n", rdst);
575 }
576 SYNTAX("mul %1%S1, %0");
78e98aab 577#line 588 "rx-decode.opc"
3cf79a01 578 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
c7927a3c
NC		 579
580 }
581 break;
582 }
583 break;
584 case 0x0d:
585 GETBYTE ();
586 switch (op[2] & 0x00)
587 {
588 case 0x00:
589 goto op_semantics_4;
590 break;
591 }
592 break;
593 case 0x0e:
594 GETBYTE ();
595 switch (op[2] & 0x00)
596 {
597 case 0x00:
598 goto op_semantics_4;
599 break;
600 }
601 break;
602 case 0x0f:
603 GETBYTE ();
604 switch (op[2] & 0x00)
605 {
606 case 0x00:
607 goto op_semantics_4;
608 break;
609 }
610 break;
611 case 0x10:
612 GETBYTE ();
613 switch (op[2] & 0x00)
614 {
615 case 0x00:
616 op_semantics_5:
617 {
618 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
78e98aab 619#line 396 "rx-decode.opc"
c7927a3c 620 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 621#line 396 "rx-decode.opc"
c7927a3c 622 int ss AU = op[1] & 0x03;
78e98aab 623#line 396 "rx-decode.opc"
c7927a3c 624 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 625#line 396 "rx-decode.opc"
c7927a3c
NC		 626 int rdst AU = op[2] & 0x0f;
627 if (trace)
628 {
629 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
630 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
631 op[0], op[1], op[2]);
632 printf (" mx = 0x%x,", mx);
633 printf (" ss = 0x%x,", ss);
634 printf (" rsrc = 0x%x,", rsrc);
635 printf (" rdst = 0x%x\n", rdst);
636 }
637 SYNTAX("and %1%S1, %0");
78e98aab 638#line 396 "rx-decode.opc"
3cf79a01 639 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
c7927a3c
NC		 640
641 }
642 break;
643 }
644 break;
645 case 0x11:
646 GETBYTE ();
647 switch (op[2] & 0x00)
648 {
649 case 0x00:
650 goto op_semantics_5;
651 break;
652 }
653 break;
654 case 0x12:
655 GETBYTE ();
656 switch (op[2] & 0x00)
657 {
658 case 0x00:
659 goto op_semantics_5;
660 break;
661 }
662 break;
663 case 0x13:
664 GETBYTE ();
665 switch (op[2] & 0x00)
666 {
667 case 0x00:
668 goto op_semantics_5;
669 break;
670 }
671 break;
672 case 0x14:
673 GETBYTE ();
674 switch (op[2] & 0x00)
675 {
676 case 0x00:
677 op_semantics_6:
678 {
679 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
78e98aab 680#line 414 "rx-decode.opc"
c7927a3c 681 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 682#line 414 "rx-decode.opc"
c7927a3c 683 int ss AU = op[1] & 0x03;
78e98aab 684#line 414 "rx-decode.opc"
c7927a3c 685 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 686#line 414 "rx-decode.opc"
c7927a3c
NC		 687 int rdst AU = op[2] & 0x0f;
688 if (trace)
689 {
690 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
691 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
692 op[0], op[1], op[2]);
693 printf (" mx = 0x%x,", mx);
694 printf (" ss = 0x%x,", ss);
695 printf (" rsrc = 0x%x,", rsrc);
696 printf (" rdst = 0x%x\n", rdst);
697 }
698 SYNTAX("or %1%S1, %0");
78e98aab 699#line 414 "rx-decode.opc"
3cf79a01 700 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
c7927a3c
NC		 701
702 }
703 break;
704 }
705 break;
706 case 0x15:
707 GETBYTE ();
708 switch (op[2] & 0x00)
709 {
710 case 0x00:
711 goto op_semantics_6;
712 break;
713 }
714 break;
715 case 0x16:
716 GETBYTE ();
717 switch (op[2] & 0x00)
718 {
719 case 0x00:
720 goto op_semantics_6;
721 break;
722 }
723 break;
724 case 0x17:
725 GETBYTE ();
726 switch (op[2] & 0x00)
727 {
728 case 0x00:
729 goto op_semantics_6;
730 break;
731 }
732 break;
733 case 0x20:
734 GETBYTE ();
735 switch (op[2] & 0xff)
736 {
737 case 0x00:
738 GETBYTE ();
739 switch (op[3] & 0x00)
740 {
741 case 0x00:
742 op_semantics_7:
743 {
744 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
78e98aab 745#line 532 "rx-decode.opc"
c7927a3c 746 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 747#line 532 "rx-decode.opc"
c7927a3c 748 int sp AU = op[1] & 0x03;
78e98aab 749#line 532 "rx-decode.opc"
c7927a3c 750 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 751#line 532 "rx-decode.opc"
c7927a3c
NC		 752 int rdst AU = op[3] & 0x0f;
753 if (trace)
754 {
755 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
756 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
757 op[0], op[1], op[2], op[3]);
758 printf (" mx = 0x%x,", mx);
759 printf (" sp = 0x%x,", sp);
760 printf (" rsrc = 0x%x,", rsrc);
761 printf (" rdst = 0x%x\n", rdst);
762 }
763 SYNTAX("sbb %1%S1, %0");
78e98aab 764#line 532 "rx-decode.opc"
3cf79a01 765 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
c7927a3c
NC		 766
767 /*----------------------------------------------------------------------*/
768 /* ABS */
769
770 }
771 break;
772 }
773 break;
774 case 0x04:
775 GETBYTE ();
776 switch (op[3] & 0x00)
777 {
778 case 0x00:
779 op_semantics_8:
780 {
781 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
78e98aab 782#line 561 "rx-decode.opc"
c7927a3c 783 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 784#line 561 "rx-decode.opc"
c7927a3c 785 int ss AU = op[1] & 0x03;
78e98aab 786#line 561 "rx-decode.opc"
c7927a3c 787 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 788#line 561 "rx-decode.opc"
c7927a3c
NC		 789 int rdst AU = op[3] & 0x0f;
790 if (trace)
791 {
792 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
793 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
794 op[0], op[1], op[2], op[3]);
795 printf (" mx = 0x%x,", mx);
796 printf (" ss = 0x%x,", ss);
797 printf (" rsrc = 0x%x,", rsrc);
798 printf (" rdst = 0x%x\n", rdst);
799 }
800 SYNTAX("max %1%S1, %0");
78e98aab 801#line 561 "rx-decode.opc"
c7927a3c
NC		 802 ID(max); SPm(ss, rsrc, mx); DR(rdst);
803
804 /*----------------------------------------------------------------------*/
805 /* MIN */
806
807 }
808 break;
809 }
810 break;
811 case 0x05:
812 GETBYTE ();
813 switch (op[3] & 0x00)
814 {
815 case 0x00:
816 op_semantics_9:
817 {
818 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
78e98aab 819#line 573 "rx-decode.opc"
c7927a3c 820 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 821#line 573 "rx-decode.opc"
c7927a3c 822 int ss AU = op[1] & 0x03;
78e98aab 823#line 573 "rx-decode.opc"
c7927a3c 824 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 825#line 573 "rx-decode.opc"
c7927a3c
NC		 826 int rdst AU = op[3] & 0x0f;
827 if (trace)
828 {
829 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
830 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
831 op[0], op[1], op[2], op[3]);
832 printf (" mx = 0x%x,", mx);
833 printf (" ss = 0x%x,", ss);
834 printf (" rsrc = 0x%x,", rsrc);
835 printf (" rdst = 0x%x\n", rdst);
836 }
837 SYNTAX("min %1%S1, %0");
78e98aab 838#line 573 "rx-decode.opc"
c7927a3c
NC		 839 ID(min); SPm(ss, rsrc, mx); DR(rdst);
840
841 /*----------------------------------------------------------------------*/
842 /* MUL */
843
844 }
845 break;
846 }
847 break;
848 case 0x06:
849 GETBYTE ();
850 switch (op[3] & 0x00)
851 {
852 case 0x00:
853 op_semantics_10:
854 {
855 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
78e98aab 856#line 603 "rx-decode.opc"
c7927a3c 857 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 858#line 603 "rx-decode.opc"
c7927a3c 859 int ss AU = op[1] & 0x03;
78e98aab 860#line 603 "rx-decode.opc"
c7927a3c 861 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 862#line 603 "rx-decode.opc"
c7927a3c
NC		 863 int rdst AU = op[3] & 0x0f;
864 if (trace)
865 {
866 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
867 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
868 op[0], op[1], op[2], op[3]);
869 printf (" mx = 0x%x,", mx);
870 printf (" ss = 0x%x,", ss);
871 printf (" rsrc = 0x%x,", rsrc);
872 printf (" rdst = 0x%x\n", rdst);
873 }
874 SYNTAX("emul %1%S1, %0");
78e98aab 875#line 603 "rx-decode.opc"
c7927a3c
NC		 876 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
877
878 /*----------------------------------------------------------------------*/
879 /* EMULU */
880
881 }
882 break;
883 }
884 break;
885 case 0x07:
886 GETBYTE ();
887 switch (op[3] & 0x00)
888 {
889 case 0x00:
890 op_semantics_11:
891 {
892 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
78e98aab 893#line 615 "rx-decode.opc"
c7927a3c 894 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 895#line 615 "rx-decode.opc"
c7927a3c 896 int ss AU = op[1] & 0x03;
78e98aab 897#line 615 "rx-decode.opc"
c7927a3c 898 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 899#line 615 "rx-decode.opc"
c7927a3c
NC		 900 int rdst AU = op[3] & 0x0f;
901 if (trace)
902 {
903 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
904 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
905 op[0], op[1], op[2], op[3]);
906 printf (" mx = 0x%x,", mx);
907 printf (" ss = 0x%x,", ss);
908 printf (" rsrc = 0x%x,", rsrc);
909 printf (" rdst = 0x%x\n", rdst);
910 }
911 SYNTAX("emulu %1%S1, %0");
78e98aab 912#line 615 "rx-decode.opc"
c7927a3c
NC		 913 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
914
915 /*----------------------------------------------------------------------*/
916 /* DIV */
917
918 }
919 break;
920 }
921 break;
922 case 0x08:
923 GETBYTE ();
924 switch (op[3] & 0x00)
925 {
926 case 0x00:
927 op_semantics_12:
928 {
929 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
78e98aab 930#line 627 "rx-decode.opc"
c7927a3c 931 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 932#line 627 "rx-decode.opc"
c7927a3c 933 int ss AU = op[1] & 0x03;
78e98aab 934#line 627 "rx-decode.opc"
c7927a3c 935 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 936#line 627 "rx-decode.opc"
c7927a3c
NC		 937 int rdst AU = op[3] & 0x0f;
938 if (trace)
939 {
940 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
941 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
942 op[0], op[1], op[2], op[3]);
943 printf (" mx = 0x%x,", mx);
944 printf (" ss = 0x%x,", ss);
945 printf (" rsrc = 0x%x,", rsrc);
946 printf (" rdst = 0x%x\n", rdst);
947 }
948 SYNTAX("div %1%S1, %0");
78e98aab 949#line 627 "rx-decode.opc"
3cf79a01 950 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
c7927a3c
NC		 951
952 /*----------------------------------------------------------------------*/
953 /* DIVU */
954
955 }
956 break;
957 }
958 break;
959 case 0x09:
960 GETBYTE ();
961 switch (op[3] & 0x00)
962 {
963 case 0x00:
964 op_semantics_13:
965 {
966 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
78e98aab 967#line 639 "rx-decode.opc"
c7927a3c 968 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 969#line 639 "rx-decode.opc"
c7927a3c 970 int ss AU = op[1] & 0x03;
78e98aab 971#line 639 "rx-decode.opc"
c7927a3c 972 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 973#line 639 "rx-decode.opc"
c7927a3c
NC		 974 int rdst AU = op[3] & 0x0f;
975 if (trace)
976 {
977 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
978 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
979 op[0], op[1], op[2], op[3]);
980 printf (" mx = 0x%x,", mx);
981 printf (" ss = 0x%x,", ss);
982 printf (" rsrc = 0x%x,", rsrc);
983 printf (" rdst = 0x%x\n", rdst);
984 }
985 SYNTAX("divu %1%S1, %0");
78e98aab 986#line 639 "rx-decode.opc"
3cf79a01 987 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
c7927a3c
NC		 988
989 /*----------------------------------------------------------------------*/
990 /* SHIFT */
991
992 }
993 break;
994 }
995 break;
996 case 0x0c:
997 GETBYTE ();
998 switch (op[3] & 0x00)
999 {
1000 case 0x00:
1001 op_semantics_14:
1002 {
1003 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
78e98aab 1004#line 450 "rx-decode.opc"
c7927a3c 1005 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 1006#line 450 "rx-decode.opc"
c7927a3c 1007 int ss AU = op[1] & 0x03;
78e98aab 1008#line 450 "rx-decode.opc"
c7927a3c 1009 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 1010#line 450 "rx-decode.opc"
c7927a3c
NC		 1011 int rdst AU = op[3] & 0x0f;
1012 if (trace)
1013 {
1014 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1015 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1016 op[0], op[1], op[2], op[3]);
1017 printf (" mx = 0x%x,", mx);
1018 printf (" ss = 0x%x,", ss);
1019 printf (" rsrc = 0x%x,", rsrc);
1020 printf (" rdst = 0x%x\n", rdst);
1021 }
1022 SYNTAX("tst %1%S1, %2");
78e98aab 1023#line 450 "rx-decode.opc"
3cf79a01 1024 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
c7927a3c
NC		 1025
1026 /*----------------------------------------------------------------------*/
1027 /* NEG */
1028
1029 }
1030 break;
1031 }
1032 break;
1033 case 0x0d:
1034 GETBYTE ();
1035 switch (op[3] & 0x00)
1036 {
1037 case 0x00:
1038 op_semantics_15:
1039 {
1040 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
78e98aab 1041#line 429 "rx-decode.opc"
c7927a3c 1042 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 1043#line 429 "rx-decode.opc"
c7927a3c 1044 int ss AU = op[1] & 0x03;
78e98aab 1045#line 429 "rx-decode.opc"
c7927a3c 1046 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 1047#line 429 "rx-decode.opc"
c7927a3c
NC		 1048 int rdst AU = op[3] & 0x0f;
1049 if (trace)
1050 {
1051 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1052 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1053 op[0], op[1], op[2], op[3]);
1054 printf (" mx = 0x%x,", mx);
1055 printf (" ss = 0x%x,", ss);
1056 printf (" rsrc = 0x%x,", rsrc);
1057 printf (" rdst = 0x%x\n", rdst);
1058 }
1059 SYNTAX("xor %1%S1, %0");
78e98aab 1060#line 429 "rx-decode.opc"
3cf79a01 1061 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
c7927a3c
NC		 1062
1063 /*----------------------------------------------------------------------*/
1064 /* NOT */
1065
1066 }
1067 break;
1068 }
1069 break;
1070 case 0x10:
1071 GETBYTE ();
1072 switch (op[3] & 0x00)
1073 {
1074 case 0x00:
1075 op_semantics_16:
1076 {
1077 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
78e98aab 1078#line 363 "rx-decode.opc"
c7927a3c 1079 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 1080#line 363 "rx-decode.opc"
c7927a3c 1081 int ss AU = op[1] & 0x03;
78e98aab 1082#line 363 "rx-decode.opc"
c7927a3c 1083 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 1084#line 363 "rx-decode.opc"
c7927a3c
NC		 1085 int rdst AU = op[3] & 0x0f;
1086 if (trace)
1087 {
1088 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1089 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1090 op[0], op[1], op[2], op[3]);
1091 printf (" mx = 0x%x,", mx);
1092 printf (" ss = 0x%x,", ss);
1093 printf (" rsrc = 0x%x,", rsrc);
1094 printf (" rdst = 0x%x\n", rdst);
1095 }
1096 SYNTAX("xchg %1%S1, %0");
78e98aab 1097#line 363 "rx-decode.opc"
c7927a3c
NC		 1098 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1099
1100 /*----------------------------------------------------------------------*/
1101 /* STZ/STNZ */
1102
1103 }
1104 break;
1105 }
1106 break;
1107 case 0x11:
1108 GETBYTE ();
1109 switch (op[3] & 0x00)
1110 {
1111 case 0x00:
1112 op_semantics_17:
1113 {
1114 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
78e98aab 1115#line 868 "rx-decode.opc"
c7927a3c 1116 int mx AU = (op[1] >> 6) & 0x03;
78e98aab 1117#line 868 "rx-decode.opc"
c7927a3c 1118 int sd AU = op[1] & 0x03;
78e98aab 1119#line 868 "rx-decode.opc"
c7927a3c 1120 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 1121#line 868 "rx-decode.opc"
c7927a3c
NC		 1122 int rdst AU = op[3] & 0x0f;
1123 if (trace)
1124 {
1125 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1126 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1127 op[0], op[1], op[2], op[3]);
1128 printf (" mx = 0x%x,", mx);
1129 printf (" sd = 0x%x,", sd);
1130 printf (" rsrc = 0x%x,", rsrc);
1131 printf (" rdst = 0x%x\n", rdst);
1132 }
1133 SYNTAX("itof %1%S1, %0");
78e98aab 1134#line 868 "rx-decode.opc"
3cf79a01 1135 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
c7927a3c
NC		 1136
1137 /*----------------------------------------------------------------------*/
1138 /* BIT OPS */
1139
1140 }
1141 break;
1142 }
1143 break;
1144 default: UNSUPPORTED(); break;
1145 }
1146 break;
1147 case 0x21:
1148 GETBYTE ();
1149 switch (op[2] & 0xff)
1150 {
1151 case 0x00:
1152 GETBYTE ();
1153 switch (op[3] & 0x00)
1154 {
1155 case 0x00:
1156 goto op_semantics_7;
1157 break;
1158 }
1159 break;
1160 case 0x04:
1161 GETBYTE ();
1162 switch (op[3] & 0x00)
1163 {
1164 case 0x00:
1165 goto op_semantics_8;
1166 break;
1167 }
1168 break;
1169 case 0x05:
1170 GETBYTE ();
1171 switch (op[3] & 0x00)
1172 {
1173 case 0x00:
1174 goto op_semantics_9;
1175 break;
1176 }
1177 break;
1178 case 0x06:
1179 GETBYTE ();
1180 switch (op[3] & 0x00)
1181 {
1182 case 0x00:
1183 goto op_semantics_10;
1184 break;
1185 }
1186 break;
1187 case 0x07:
1188 GETBYTE ();
1189 switch (op[3] & 0x00)
1190 {
1191 case 0x00:
1192 goto op_semantics_11;
1193 break;
1194 }
1195 break;
1196 case 0x08:
1197 GETBYTE ();
1198 switch (op[3] & 0x00)
1199 {
1200 case 0x00:
1201 goto op_semantics_12;
1202 break;
1203 }
1204 break;
1205 case 0x09:
1206 GETBYTE ();
1207 switch (op[3] & 0x00)
1208 {
1209 case 0x00:
1210 goto op_semantics_13;
1211 break;
1212 }
1213 break;
1214 case 0x0c:
1215 GETBYTE ();
1216 switch (op[3] & 0x00)
1217 {
1218 case 0x00:
1219 goto op_semantics_14;
1220 break;
1221 }
1222 break;
1223 case 0x0d:
1224 GETBYTE ();
1225 switch (op[3] & 0x00)
1226 {
1227 case 0x00:
1228 goto op_semantics_15;
1229 break;
1230 }
1231 break;
1232 case 0x10:
1233 GETBYTE ();
1234 switch (op[3] & 0x00)
1235 {
1236 case 0x00:
1237 goto op_semantics_16;
1238 break;
1239 }
1240 break;
1241 case 0x11:
1242 GETBYTE ();
1243 switch (op[3] & 0x00)
1244 {
1245 case 0x00:
1246 goto op_semantics_17;
1247 break;
1248 }
1249 break;
1250 default: UNSUPPORTED(); break;
1251 }
1252 break;
1253 case 0x22:
1254 GETBYTE ();
1255 switch (op[2] & 0xff)
1256 {
1257 case 0x00:
1258 GETBYTE ();
1259 switch (op[3] & 0x00)
1260 {
1261 case 0x00:
1262 goto op_semantics_7;
1263 break;
1264 }
1265 break;
1266 case 0x04:
1267 GETBYTE ();
1268 switch (op[3] & 0x00)
1269 {
1270 case 0x00:
1271 goto op_semantics_8;
1272 break;
1273 }
1274 break;
1275 case 0x05:
1276 GETBYTE ();
1277 switch (op[3] & 0x00)
1278 {
1279 case 0x00:
1280 goto op_semantics_9;
1281 break;
1282 }
1283 break;
1284 case 0x06:
1285 GETBYTE ();
1286 switch (op[3] & 0x00)
1287 {
1288 case 0x00:
1289 goto op_semantics_10;
1290 break;
1291 }
1292 break;
1293 case 0x07:
1294 GETBYTE ();
1295 switch (op[3] & 0x00)
1296 {
1297 case 0x00:
1298 goto op_semantics_11;
1299 break;
1300 }
1301 break;
1302 case 0x08:
1303 GETBYTE ();
1304 switch (op[3] & 0x00)
1305 {
1306 case 0x00:
1307 goto op_semantics_12;
1308 break;
1309 }
1310 break;
1311 case 0x09:
1312 GETBYTE ();
1313 switch (op[3] & 0x00)
1314 {
1315 case 0x00:
1316 goto op_semantics_13;
1317 break;
1318 }
1319 break;
1320 case 0x0c:
1321 GETBYTE ();
1322 switch (op[3] & 0x00)
1323 {
1324 case 0x00:
1325 goto op_semantics_14;
1326 break;
1327 }
1328 break;
1329 case 0x0d:
1330 GETBYTE ();
1331 switch (op[3] & 0x00)
1332 {
1333 case 0x00:
1334 goto op_semantics_15;
1335 break;
1336 }
1337 break;
1338 case 0x10:
1339 GETBYTE ();
1340 switch (op[3] & 0x00)
1341 {
1342 case 0x00:
1343 goto op_semantics_16;
1344 break;
1345 }
1346 break;
1347 case 0x11:
1348 GETBYTE ();
1349 switch (op[3] & 0x00)
1350 {
1351 case 0x00:
1352 goto op_semantics_17;
1353 break;
1354 }
1355 break;
1356 default: UNSUPPORTED(); break;
1357 }
1358 break;
1359 case 0x23:
1360 GETBYTE ();
1361 switch (op[2] & 0xff)
1362 {
1363 case 0x00:
1364 GETBYTE ();
1365 switch (op[3] & 0x00)
1366 {
1367 case 0x00:
1368 goto op_semantics_7;
1369 break;
1370 }
1371 break;
1372 case 0x04:
1373 GETBYTE ();
1374 switch (op[3] & 0x00)
1375 {
1376 case 0x00:
1377 goto op_semantics_8;
1378 break;
1379 }
1380 break;
1381 case 0x05:
1382 GETBYTE ();
1383 switch (op[3] & 0x00)
1384 {
1385 case 0x00:
1386 goto op_semantics_9;
1387 break;
1388 }
1389 break;
1390 case 0x06:
1391 GETBYTE ();
1392 switch (op[3] & 0x00)
1393 {
1394 case 0x00:
1395 goto op_semantics_10;
1396 break;
1397 }
1398 break;
1399 case 0x07:
1400 GETBYTE ();
1401 switch (op[3] & 0x00)
1402 {
1403 case 0x00:
1404 goto op_semantics_11;
1405 break;
1406 }
1407 break;
1408 case 0x08:
1409 GETBYTE ();
1410 switch (op[3] & 0x00)
1411 {
1412 case 0x00:
1413 goto op_semantics_12;
1414 break;
1415 }
1416 break;
1417 case 0x09:
1418 GETBYTE ();
1419 switch (op[3] & 0x00)
1420 {
1421 case 0x00:
1422 goto op_semantics_13;
1423 break;
1424 }
1425 break;
1426 case 0x0c:
1427 GETBYTE ();
1428 switch (op[3] & 0x00)
1429 {
1430 case 0x00:
1431 goto op_semantics_14;
1432 break;
1433 }
1434 break;
1435 case 0x0d:
1436 GETBYTE ();
1437 switch (op[3] & 0x00)
1438 {
1439 case 0x00:
1440 goto op_semantics_15;
1441 break;
1442 }
1443 break;
1444 case 0x10:
1445 GETBYTE ();
1446 switch (op[3] & 0x00)
1447 {
1448 case 0x00:
1449 goto op_semantics_16;
1450 break;
1451 }
1452 break;
1453 case 0x11:
1454 GETBYTE ();
1455 switch (op[3] & 0x00)
1456 {
1457 case 0x00:
1458 goto op_semantics_17;
1459 break;
1460 }
1461 break;
1462 default: UNSUPPORTED(); break;
1463 }
1464 break;
1465 case 0x40:
1466 GETBYTE ();
1467 switch (op[2] & 0x00)
1468 {
1469 case 0x00:
1470 goto op_semantics_1;
1471 break;
1472 }
1473 break;
1474 case 0x41:
1475 GETBYTE ();
1476 switch (op[2] & 0x00)
1477 {
1478 case 0x00:
1479 goto op_semantics_1;
1480 break;
1481 }
1482 break;
1483 case 0x42:
1484 GETBYTE ();
1485 switch (op[2] & 0x00)
1486 {
1487 case 0x00:
1488 goto op_semantics_1;
1489 break;
1490 }
1491 break;
1492 case 0x43:
1493 GETBYTE ();
1494 switch (op[2] & 0x00)
1495 {
1496 case 0x00:
1497 goto op_semantics_1;
1498 break;
1499 }
1500 break;
1501 case 0x44:
1502 GETBYTE ();
1503 switch (op[2] & 0x00)
1504 {
1505 case 0x00:
1506 goto op_semantics_2;
1507 break;
1508 }
1509 break;
1510 case 0x45:
1511 GETBYTE ();
1512 switch (op[2] & 0x00)
1513 {
1514 case 0x00:
1515 goto op_semantics_2;
1516 break;
1517 }
1518 break;
1519 case 0x46:
1520 GETBYTE ();
1521 switch (op[2] & 0x00)
1522 {
1523 case 0x00:
1524 goto op_semantics_2;
1525 break;
1526 }
1527 break;
1528 case 0x47:
1529 GETBYTE ();
1530 switch (op[2] & 0x00)
1531 {
1532 case 0x00:
1533 goto op_semantics_2;
1534 break;
1535 }
1536 break;
1537 case 0x48:
1538 GETBYTE ();
1539 switch (op[2] & 0x00)
1540 {
1541 case 0x00:
1542 goto op_semantics_3;
1543 break;
1544 }
1545 break;
1546 case 0x49:
1547 GETBYTE ();
1548 switch (op[2] & 0x00)
1549 {
1550 case 0x00:
1551 goto op_semantics_3;
1552 break;
1553 }
1554 break;
1555 case 0x4a:
1556 GETBYTE ();
1557 switch (op[2] & 0x00)
1558 {
1559 case 0x00:
1560 goto op_semantics_3;
1561 break;
1562 }
1563 break;
1564 case 0x4b:
1565 GETBYTE ();
1566 switch (op[2] & 0x00)
1567 {
1568 case 0x00:
1569 goto op_semantics_3;
1570 break;
1571 }
1572 break;
1573 case 0x4c:
1574 GETBYTE ();
1575 switch (op[2] & 0x00)
1576 {
1577 case 0x00:
1578 goto op_semantics_4;
1579 break;
1580 }
1581 break;
1582 case 0x4d:
1583 GETBYTE ();
1584 switch (op[2] & 0x00)
1585 {
1586 case 0x00:
1587 goto op_semantics_4;
1588 break;
1589 }
1590 break;
1591 case 0x4e:
1592 GETBYTE ();
1593 switch (op[2] & 0x00)
1594 {
1595 case 0x00:
1596 goto op_semantics_4;
1597 break;
1598 }
1599 break;
1600 case 0x4f:
1601 GETBYTE ();
1602 switch (op[2] & 0x00)
1603 {
1604 case 0x00:
1605 goto op_semantics_4;
1606 break;
1607 }
1608 break;
1609 case 0x50:
1610 GETBYTE ();
1611 switch (op[2] & 0x00)
1612 {
1613 case 0x00:
1614 goto op_semantics_5;
1615 break;
1616 }
1617 break;
1618 case 0x51:
1619 GETBYTE ();
1620 switch (op[2] & 0x00)
1621 {
1622 case 0x00:
1623 goto op_semantics_5;
1624 break;
1625 }
1626 break;
1627 case 0x52:
1628 GETBYTE ();
1629 switch (op[2] & 0x00)
1630 {
1631 case 0x00:
1632 goto op_semantics_5;
1633 break;
1634 }
1635 break;
1636 case 0x53:
1637 GETBYTE ();
1638 switch (op[2] & 0x00)
1639 {
1640 case 0x00:
1641 goto op_semantics_5;
1642 break;
1643 }
1644 break;
1645 case 0x54:
1646 GETBYTE ();
1647 switch (op[2] & 0x00)
1648 {
1649 case 0x00:
1650 goto op_semantics_6;
1651 break;
1652 }
1653 break;
1654 case 0x55:
1655 GETBYTE ();
1656 switch (op[2] & 0x00)
1657 {
1658 case 0x00:
1659 goto op_semantics_6;
1660 break;
1661 }
1662 break;
1663 case 0x56:
1664 GETBYTE ();
1665 switch (op[2] & 0x00)
1666 {
1667 case 0x00:
1668 goto op_semantics_6;
1669 break;
1670 }
1671 break;
1672 case 0x57:
1673 GETBYTE ();
1674 switch (op[2] & 0x00)
1675 {
1676 case 0x00:
1677 goto op_semantics_6;
1678 break;
1679 }
1680 break;
1681 case 0x60:
1682 GETBYTE ();
1683 switch (op[2] & 0xff)
1684 {
1685 case 0x00:
1686 GETBYTE ();
1687 switch (op[3] & 0x00)
1688 {
1689 case 0x00:
1690 goto op_semantics_7;
1691 break;
1692 }
1693 break;
1694 case 0x04:
1695 GETBYTE ();
1696 switch (op[3] & 0x00)
1697 {
1698 case 0x00:
1699 goto op_semantics_8;
1700 break;
1701 }
1702 break;
1703 case 0x05:
1704 GETBYTE ();
1705 switch (op[3] & 0x00)
1706 {
1707 case 0x00:
1708 goto op_semantics_9;
1709 break;
1710 }
1711 break;
1712 case 0x06:
1713 GETBYTE ();
1714 switch (op[3] & 0x00)
1715 {
1716 case 0x00:
1717 goto op_semantics_10;
1718 break;
1719 }
1720 break;
1721 case 0x07:
1722 GETBYTE ();
1723 switch (op[3] & 0x00)
1724 {
1725 case 0x00:
1726 goto op_semantics_11;
1727 break;
1728 }
1729 break;
1730 case 0x08:
1731 GETBYTE ();
1732 switch (op[3] & 0x00)
1733 {
1734 case 0x00:
1735 goto op_semantics_12;
1736 break;
1737 }
1738 break;
1739 case 0x09:
1740 GETBYTE ();
1741 switch (op[3] & 0x00)
1742 {
1743 case 0x00:
1744 goto op_semantics_13;
1745 break;
1746 }
1747 break;
1748 case 0x0c:
1749 GETBYTE ();
1750 switch (op[3] & 0x00)
1751 {
1752 case 0x00:
1753 goto op_semantics_14;
1754 break;
1755 }
1756 break;
1757 case 0x0d:
1758 GETBYTE ();
1759 switch (op[3] & 0x00)
1760 {
1761 case 0x00:
1762 goto op_semantics_15;
1763 break;
1764 }
1765 break;
1766 case 0x10:
1767 GETBYTE ();
1768 switch (op[3] & 0x00)
1769 {
1770 case 0x00:
1771 goto op_semantics_16;
1772 break;
1773 }
1774 break;
1775 case 0x11:
1776 GETBYTE ();
1777 switch (op[3] & 0x00)
1778 {
1779 case 0x00:
1780 goto op_semantics_17;
1781 break;
1782 }
1783 break;
1784 default: UNSUPPORTED(); break;
1785 }
1786 break;
1787 case 0x61:
1788 GETBYTE ();
1789 switch (op[2] & 0xff)
1790 {
1791 case 0x00:
1792 GETBYTE ();
1793 switch (op[3] & 0x00)
1794 {
1795 case 0x00:
1796 goto op_semantics_7;
1797 break;
1798 }
1799 break;
1800 case 0x04:
1801 GETBYTE ();
1802 switch (op[3] & 0x00)
1803 {
1804 case 0x00:
1805 goto op_semantics_8;
1806 break;
1807 }
1808 break;
1809 case 0x05:
1810 GETBYTE ();
1811 switch (op[3] & 0x00)
1812 {
1813 case 0x00:
1814 goto op_semantics_9;
1815 break;
1816 }
1817 break;
1818 case 0x06:
1819 GETBYTE ();
1820 switch (op[3] & 0x00)
1821 {
1822 case 0x00:
1823 goto op_semantics_10;
1824 break;
1825 }
1826 break;
1827 case 0x07:
1828 GETBYTE ();
1829 switch (op[3] & 0x00)
1830 {
1831 case 0x00:
1832 goto op_semantics_11;
1833 break;
1834 }
1835 break;
1836 case 0x08:
1837 GETBYTE ();
1838 switch (op[3] & 0x00)
1839 {
1840 case 0x00:
1841 goto op_semantics_12;
1842 break;
1843 }
1844 break;
1845 case 0x09:
1846 GETBYTE ();
1847 switch (op[3] & 0x00)
1848 {
1849 case 0x00:
1850 goto op_semantics_13;
1851 break;
1852 }
1853 break;
1854 case 0x0c:
1855 GETBYTE ();
1856 switch (op[3] & 0x00)
1857 {
1858 case 0x00:
1859 goto op_semantics_14;
1860 break;
1861 }
1862 break;
1863 case 0x0d:
1864 GETBYTE ();
1865 switch (op[3] & 0x00)
1866 {
1867 case 0x00:
1868 goto op_semantics_15;
1869 break;
1870 }
1871 break;
1872 case 0x10:
1873 GETBYTE ();
1874 switch (op[3] & 0x00)
1875 {
1876 case 0x00:
1877 goto op_semantics_16;
1878 break;
1879 }
1880 break;
1881 case 0x11:
1882 GETBYTE ();
1883 switch (op[3] & 0x00)
1884 {
1885 case 0x00:
1886 goto op_semantics_17;
1887 break;
1888 }
1889 break;
1890 default: UNSUPPORTED(); break;
1891 }
1892 break;
1893 case 0x62:
1894 GETBYTE ();
1895 switch (op[2] & 0xff)
1896 {
1897 case 0x00:
1898 GETBYTE ();
1899 switch (op[3] & 0x00)
1900 {
1901 case 0x00:
1902 goto op_semantics_7;
1903 break;
1904 }
1905 break;
1906 case 0x04:
1907 GETBYTE ();
1908 switch (op[3] & 0x00)
1909 {
1910 case 0x00:
1911 goto op_semantics_8;
1912 break;
1913 }
1914 break;
1915 case 0x05:
1916 GETBYTE ();
1917 switch (op[3] & 0x00)
1918 {
1919 case 0x00:
1920 goto op_semantics_9;
1921 break;
1922 }
1923 break;
1924 case 0x06:
1925 GETBYTE ();
1926 switch (op[3] & 0x00)
1927 {
1928 case 0x00:
1929 goto op_semantics_10;
1930 break;
1931 }
1932 break;
1933 case 0x07:
1934 GETBYTE ();
1935 switch (op[3] & 0x00)
1936 {
1937 case 0x00:
1938 goto op_semantics_11;
1939 break;
1940 }
1941 break;
1942 case 0x08:
1943 GETBYTE ();
1944 switch (op[3] & 0x00)
1945 {
1946 case 0x00:
1947 goto op_semantics_12;
1948 break;
1949 }
1950 break;
1951 case 0x09:
1952 GETBYTE ();
1953 switch (op[3] & 0x00)
1954 {
1955 case 0x00:
1956 goto op_semantics_13;
1957 break;
1958 }
1959 break;
1960 case 0x0c:
1961 GETBYTE ();
1962 switch (op[3] & 0x00)
1963 {
1964 case 0x00:
1965 goto op_semantics_14;
1966 break;
1967 }
1968 break;
1969 case 0x0d:
1970 GETBYTE ();
1971 switch (op[3] & 0x00)
1972 {
1973 case 0x00:
1974 goto op_semantics_15;
1975 break;
1976 }
1977 break;
1978 case 0x10:
1979 GETBYTE ();
1980 switch (op[3] & 0x00)
1981 {
1982 case 0x00:
1983 goto op_semantics_16;
1984 break;
1985 }
1986 break;
1987 case 0x11:
1988 GETBYTE ();
1989 switch (op[3] & 0x00)
1990 {
1991 case 0x00:
1992 goto op_semantics_17;
1993 break;
1994 }
1995 break;
1996 default: UNSUPPORTED(); break;
1997 }
1998 break;
1999 case 0x63:
2000 GETBYTE ();
2001 switch (op[2] & 0xff)
2002 {
2003 case 0x00:
2004 GETBYTE ();
2005 switch (op[3] & 0x00)
2006 {
2007 case 0x00:
2008 goto op_semantics_7;
2009 break;
2010 }
2011 break;
2012 case 0x04:
2013 GETBYTE ();
2014 switch (op[3] & 0x00)
2015 {
2016 case 0x00:
2017 goto op_semantics_8;
2018 break;
2019 }
2020 break;
2021 case 0x05:
2022 GETBYTE ();
2023 switch (op[3] & 0x00)
2024 {
2025 case 0x00:
2026 goto op_semantics_9;
2027 break;
2028 }
2029 break;
2030 case 0x06:
2031 GETBYTE ();
2032 switch (op[3] & 0x00)
2033 {
2034 case 0x00:
2035 goto op_semantics_10;
2036 break;
2037 }
2038 break;
2039 case 0x07:
2040 GETBYTE ();
2041 switch (op[3] & 0x00)
2042 {
2043 case 0x00:
2044 goto op_semantics_11;
2045 break;
2046 }
2047 break;
2048 case 0x08:
2049 GETBYTE ();
2050 switch (op[3] & 0x00)
2051 {
2052 case 0x00:
2053 goto op_semantics_12;
2054 break;
2055 }
2056 break;
2057 case 0x09:
2058 GETBYTE ();
2059 switch (op[3] & 0x00)
2060 {
2061 case 0x00:
2062 goto op_semantics_13;
2063 break;
2064 }
2065 break;
2066 case 0x0c:
2067 GETBYTE ();
2068 switch (op[3] & 0x00)
2069 {
2070 case 0x00:
2071 goto op_semantics_14;
2072 break;
2073 }
2074 break;
2075 case 0x0d:
2076 GETBYTE ();
2077 switch (op[3] & 0x00)
2078 {
2079 case 0x00:
2080 goto op_semantics_15;
2081 break;
2082 }
2083 break;
2084 case 0x10:
2085 GETBYTE ();
2086 switch (op[3] & 0x00)
2087 {
2088 case 0x00:
2089 goto op_semantics_16;
2090 break;
2091 }
2092 break;
2093 case 0x11:
2094 GETBYTE ();
2095 switch (op[3] & 0x00)
2096 {
2097 case 0x00:
2098 goto op_semantics_17;
2099 break;
2100 }
2101 break;
2102 default: UNSUPPORTED(); break;
2103 }
2104 break;
2105 case 0x80:
2106 GETBYTE ();
2107 switch (op[2] & 0x00)
2108 {
2109 case 0x00:
2110 goto op_semantics_1;
2111 break;
2112 }
2113 break;
2114 case 0x81:
2115 GETBYTE ();
2116 switch (op[2] & 0x00)
2117 {
2118 case 0x00:
2119 goto op_semantics_1;
2120 break;
2121 }
2122 break;
2123 case 0x82:
2124 GETBYTE ();
2125 switch (op[2] & 0x00)
2126 {
2127 case 0x00:
2128 goto op_semantics_1;
2129 break;
2130 }
2131 break;
2132 case 0x83:
2133 GETBYTE ();
2134 switch (op[2] & 0x00)
2135 {
2136 case 0x00:
2137 goto op_semantics_1;
2138 break;
2139 }
2140 break;
2141 case 0x84:
2142 GETBYTE ();
2143 switch (op[2] & 0x00)
2144 {
2145 case 0x00:
2146 goto op_semantics_2;
2147 break;
2148 }
2149 break;
2150 case 0x85:
2151 GETBYTE ();
2152 switch (op[2] & 0x00)
2153 {
2154 case 0x00:
2155 goto op_semantics_2;
2156 break;
2157 }
2158 break;
2159 case 0x86:
2160 GETBYTE ();
2161 switch (op[2] & 0x00)
2162 {
2163 case 0x00:
2164 goto op_semantics_2;
2165 break;
2166 }
2167 break;
2168 case 0x87:
2169 GETBYTE ();
2170 switch (op[2] & 0x00)
2171 {
2172 case 0x00:
2173 goto op_semantics_2;
2174 break;
2175 }
2176 break;
2177 case 0x88:
2178 GETBYTE ();
2179 switch (op[2] & 0x00)
2180 {
2181 case 0x00:
2182 goto op_semantics_3;
2183 break;
2184 }
2185 break;
2186 case 0x89:
2187 GETBYTE ();
2188 switch (op[2] & 0x00)
2189 {
2190 case 0x00:
2191 goto op_semantics_3;
2192 break;
2193 }
2194 break;
2195 case 0x8a:
2196 GETBYTE ();
2197 switch (op[2] & 0x00)
2198 {
2199 case 0x00:
2200 goto op_semantics_3;
2201 break;
2202 }
2203 break;
2204 case 0x8b:
2205 GETBYTE ();
2206 switch (op[2] & 0x00)
2207 {
2208 case 0x00:
2209 goto op_semantics_3;
2210 break;
2211 }
2212 break;
2213 case 0x8c:
2214 GETBYTE ();
2215 switch (op[2] & 0x00)
2216 {
2217 case 0x00:
2218 goto op_semantics_4;
2219 break;
2220 }
2221 break;
2222 case 0x8d:
2223 GETBYTE ();
2224 switch (op[2] & 0x00)
2225 {
2226 case 0x00:
2227 goto op_semantics_4;
2228 break;
2229 }
2230 break;
2231 case 0x8e:
2232 GETBYTE ();
2233 switch (op[2] & 0x00)
2234 {
2235 case 0x00:
2236 goto op_semantics_4;
2237 break;
2238 }
2239 break;
2240 case 0x8f:
2241 GETBYTE ();
2242 switch (op[2] & 0x00)
2243 {
2244 case 0x00:
2245 goto op_semantics_4;
2246 break;
2247 }
2248 break;
2249 case 0x90:
2250 GETBYTE ();
2251 switch (op[2] & 0x00)
2252 {
2253 case 0x00:
2254 goto op_semantics_5;
2255 break;
2256 }
2257 break;
2258 case 0x91:
2259 GETBYTE ();
2260 switch (op[2] & 0x00)
2261 {
2262 case 0x00:
2263 goto op_semantics_5;
2264 break;
2265 }
2266 break;
2267 case 0x92:
2268 GETBYTE ();
2269 switch (op[2] & 0x00)
2270 {
2271 case 0x00:
2272 goto op_semantics_5;
2273 break;
2274 }
2275 break;
2276 case 0x93:
2277 GETBYTE ();
2278 switch (op[2] & 0x00)
2279 {
2280 case 0x00:
2281 goto op_semantics_5;
2282 break;
2283 }
2284 break;
2285 case 0x94:
2286 GETBYTE ();
2287 switch (op[2] & 0x00)
2288 {
2289 case 0x00:
2290 goto op_semantics_6;
2291 break;
2292 }
2293 break;
2294 case 0x95:
2295 GETBYTE ();
2296 switch (op[2] & 0x00)
2297 {
2298 case 0x00:
2299 goto op_semantics_6;
2300 break;
2301 }
2302 break;
2303 case 0x96:
2304 GETBYTE ();
2305 switch (op[2] & 0x00)
2306 {
2307 case 0x00:
2308 goto op_semantics_6;
2309 break;
2310 }
2311 break;
2312 case 0x97:
2313 GETBYTE ();
2314 switch (op[2] & 0x00)
2315 {
2316 case 0x00:
2317 goto op_semantics_6;
2318 break;
2319 }
2320 break;
2321 case 0xa0:
2322 GETBYTE ();
2323 switch (op[2] & 0xff)
2324 {
2325 case 0x00:
2326 GETBYTE ();
2327 switch (op[3] & 0x00)
2328 {
2329 case 0x00:
2330 goto op_semantics_7;
2331 break;
2332 }
2333 break;
2334 case 0x02:
2335 GETBYTE ();
2336 switch (op[3] & 0x00)
2337 {
2338 case 0x00:
2339 op_semantics_18:
2340 {
2341 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
78e98aab 2342#line 471 "rx-decode.opc"
c7927a3c 2343 int ss AU = op[1] & 0x03;
78e98aab 2344#line 471 "rx-decode.opc"
c7927a3c 2345 int rsrc AU = (op[3] >> 4) & 0x0f;
78e98aab 2346#line 471 "rx-decode.opc"
c7927a3c
NC		 2347 int rdst AU = op[3] & 0x0f;
2348 if (trace)
2349 {
2350 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2351 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2352 op[0], op[1], op[2], op[3]);
2353 printf (" ss = 0x%x,", ss);
2354 printf (" rsrc = 0x%x,", rsrc);
2355 printf (" rdst = 0x%x\n", rdst);
2356 }
2357 SYNTAX("adc %1%S1, %0");
78e98aab 2358#line 471 "rx-decode.opc"
3cf79a01 2359 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
c7927a3c
NC		 2360
2361 /*----------------------------------------------------------------------*/
2362 /* ADD */
2363
2364 }
2365 break;
2366 }
2367 break;
2368 case 0x04:
2369 GETBYTE ();
2370 switch (op[3] & 0x00)
2371 {
2372 case 0x00:
2373 goto op_semantics_8;
2374 break;
2375 }
2376 break;
2377 case 0x05:
2378 GETBYTE ();
2379 switch (op[3] & 0x00)
2380 {
2381 case 0x00:
2382 goto op_semantics_9;
2383 break;
2384 }
2385 break;
2386 case 0x06:
2387 GETBYTE ();
2388 switch (op[3] & 0x00)
2389 {
2390 case 0x00:
2391 goto op_semantics_10;
2392 break;
2393 }
2394 break;
2395 case 0x07:
2396 GETBYTE ();
2397 switch (op[3] & 0x00)
2398 {
2399 case 0x00:
2400 goto op_semantics_11;
2401 break;
2402 }
2403 break;
2404 case 0x08:
2405 GETBYTE ();
2406 switch (op[3] & 0x00)
2407 {
2408 case 0x00:
2409 goto op_semantics_12;
2410 break;
2411 }
2412 break;
2413 case 0x09:
2414 GETBYTE ();
2415 switch (op[3] & 0x00)
2416 {
2417 case 0x00:
2418 goto op_semantics_13;
2419 break;
2420 }
2421 break;
2422 case 0x0c:
2423 GETBYTE ();
2424 switch (op[3] & 0x00)
2425 {
2426 case 0x00:
2427 goto op_semantics_14;
2428 break;
2429 }
2430 break;
2431 case 0x0d:
2432 GETBYTE ();
2433 switch (op[3] & 0x00)
2434 {
2435 case 0x00:
2436 goto op_semantics_15;
2437 break;
2438 }
2439 break;
2440 case 0x10:
2441 GETBYTE ();
2442 switch (op[3] & 0x00)
2443 {
2444 case 0x00:
2445 goto op_semantics_16;
2446 break;
2447 }
2448 break;
2449 case 0x11:
2450 GETBYTE ();
2451 switch (op[3] & 0x00)
2452 {
2453 case 0x00:
2454 goto op_semantics_17;
2455 break;
2456 }
2457 break;
2458 default: UNSUPPORTED(); break;
2459 }
2460 break;
2461 case 0xa1:
2462 GETBYTE ();
2463 switch (op[2] & 0xff)
2464 {
2465 case 0x00:
2466 GETBYTE ();
2467 switch (op[3] & 0x00)
2468 {
2469 case 0x00:
2470 goto op_semantics_7;
2471 break;
2472 }
2473 break;
2474 case 0x02:
2475 GETBYTE ();
2476 switch (op[3] & 0x00)
2477 {
2478 case 0x00:
2479 goto op_semantics_18;
2480 break;
2481 }
2482 break;
2483 case 0x04:
2484 GETBYTE ();
2485 switch (op[3] & 0x00)
2486 {
2487 case 0x00:
2488 goto op_semantics_8;
2489 break;
2490 }
2491 break;
2492 case 0x05:
2493 GETBYTE ();
2494 switch (op[3] & 0x00)
2495 {
2496 case 0x00:
2497 goto op_semantics_9;
2498 break;
2499 }
2500 break;
2501 case 0x06:
2502 GETBYTE ();
2503 switch (op[3] & 0x00)
2504 {
2505 case 0x00:
2506 goto op_semantics_10;
2507 break;
2508 }
2509 break;
2510 case 0x07:
2511 GETBYTE ();
2512 switch (op[3] & 0x00)
2513 {
2514 case 0x00:
2515 goto op_semantics_11;
2516 break;
2517 }
2518 break;
2519 case 0x08:
2520 GETBYTE ();
2521 switch (op[3] & 0x00)
2522 {
2523 case 0x00:
2524 goto op_semantics_12;
2525 break;
2526 }
2527 break;
2528 case 0x09:
2529 GETBYTE ();
2530 switch (op[3] & 0x00)
2531 {
2532 case 0x00:
2533 goto op_semantics_13;
2534 break;
2535 }
2536 break;
2537 case 0x0c:
2538 GETBYTE ();
2539 switch (op[3] & 0x00)
2540 {
2541 case 0x00:
2542 goto op_semantics_14;
2543 break;
2544 }
2545 break;
2546 case 0x0d:
2547 GETBYTE ();
2548 switch (op[3] & 0x00)
2549 {
2550 case 0x00:
2551 goto op_semantics_15;
2552 break;
2553 }
2554 break;
2555 case 0x10:
2556 GETBYTE ();
2557 switch (op[3] & 0x00)
2558 {
2559 case 0x00:
2560 goto op_semantics_16;
2561 break;
2562 }
2563 break;
2564 case 0x11:
2565 GETBYTE ();
2566 switch (op[3] & 0x00)
2567 {
2568 case 0x00:
2569 goto op_semantics_17;
2570 break;
2571 }
2572 break;
2573 default: UNSUPPORTED(); break;
2574 }
2575 break;
2576 case 0xa2:
2577 GETBYTE ();
2578 switch (op[2] & 0xff)
2579 {
2580 case 0x00:
2581 GETBYTE ();
2582 switch (op[3] & 0x00)
2583 {
2584 case 0x00:
2585 goto op_semantics_7;
2586 break;
2587 }
2588 break;
2589 case 0x02:
2590 GETBYTE ();
2591 switch (op[3] & 0x00)
2592 {
2593 case 0x00:
2594 goto op_semantics_18;
2595 break;
2596 }
2597 break;
2598 case 0x04:
2599 GETBYTE ();
2600 switch (op[3] & 0x00)
2601 {
2602 case 0x00:
2603 goto op_semantics_8;
2604 break;
2605 }
2606 break;
2607 case 0x05:
2608 GETBYTE ();
2609 switch (op[3] & 0x00)
2610 {
2611 case 0x00:
2612 goto op_semantics_9;
2613 break;
2614 }
2615 break;
2616 case 0x06:
2617 GETBYTE ();
2618 switch (op[3] & 0x00)
2619 {
2620 case 0x00:
2621 goto op_semantics_10;
2622 break;
2623 }
2624 break;
2625 case 0x07:
2626 GETBYTE ();
2627 switch (op[3] & 0x00)
2628 {
2629 case 0x00:
2630 goto op_semantics_11;
2631 break;
2632 }
2633 break;
2634 case 0x08:
2635 GETBYTE ();
2636 switch (op[3] & 0x00)
2637 {
2638 case 0x00:
2639 goto op_semantics_12;
2640 break;
2641 }
2642 break;
2643 case 0x09:
2644 GETBYTE ();
2645 switch (op[3] & 0x00)
2646 {
2647 case 0x00:
2648 goto op_semantics_13;
2649 break;
2650 }
2651 break;
2652 case 0x0c:
2653 GETBYTE ();
2654 switch (op[3] & 0x00)
2655 {
2656 case 0x00:
2657 goto op_semantics_14;
2658 break;
2659 }
2660 break;
2661 case 0x0d:
2662 GETBYTE ();
2663 switch (op[3] & 0x00)
2664 {
2665 case 0x00:
2666 goto op_semantics_15;
2667 break;
2668 }
2669 break;
2670 case 0x10:
2671 GETBYTE ();
2672 switch (op[3] & 0x00)
2673 {
2674 case 0x00:
2675 goto op_semantics_16;
2676 break;
2677 }
2678 break;
2679 case 0x11:
2680 GETBYTE ();
2681 switch (op[3] & 0x00)
2682 {
2683 case 0x00:
2684 goto op_semantics_17;
2685 break;
2686 }
2687 break;
2688 default: UNSUPPORTED(); break;
2689 }
2690 break;
2691 case 0xa3:
2692 GETBYTE ();
2693 switch (op[2] & 0xff)
2694 {
2695 case 0x00:
2696 GETBYTE ();
2697 switch (op[3] & 0x00)
2698 {
2699 case 0x00:
2700 goto op_semantics_7;
2701 break;
2702 }
2703 break;
2704 case 0x02:
2705 GETBYTE ();
2706 switch (op[3] & 0x00)
2707 {
2708 case 0x00:
2709 goto op_semantics_18;
2710 break;
2711 }
2712 break;
2713 case 0x04:
2714 GETBYTE ();
2715 switch (op[3] & 0x00)
2716 {
2717 case 0x00:
2718 goto op_semantics_8;
2719 break;
2720 }
2721 break;
2722 case 0x05:
2723 GETBYTE ();
2724 switch (op[3] & 0x00)
2725 {
2726 case 0x00:
2727 goto op_semantics_9;
2728 break;
2729 }
2730 break;
2731 case 0x06:
2732 GETBYTE ();
2733 switch (op[3] & 0x00)
2734 {
2735 case 0x00:
2736 goto op_semantics_10;
2737 break;
2738 }
2739 break;
2740 case 0x07:
2741 GETBYTE ();
2742 switch (op[3] & 0x00)
2743 {
2744 case 0x00:
2745 goto op_semantics_11;
2746 break;
2747 }
2748 break;
2749 case 0x08:
2750 GETBYTE ();
2751 switch (op[3] & 0x00)
2752 {
2753 case 0x00:
2754 goto op_semantics_12;
2755 break;
2756 }
2757 break;
2758 case 0x09:
2759 GETBYTE ();
2760 switch (op[3] & 0x00)
2761 {
2762 case 0x00:
2763 goto op_semantics_13;
2764 break;
2765 }
2766 break;
2767 case 0x0c:
2768 GETBYTE ();
2769 switch (op[3] & 0x00)
2770 {
2771 case 0x00:
2772 goto op_semantics_14;
2773 break;
2774 }
2775 break;
2776 case 0x0d:
2777 GETBYTE ();
2778 switch (op[3] & 0x00)
2779 {
2780 case 0x00:
2781 goto op_semantics_15;
2782 break;
2783 }
2784 break;
2785 case 0x10:
2786 GETBYTE ();
2787 switch (op[3] & 0x00)
2788 {
2789 case 0x00:
2790 goto op_semantics_16;
2791 break;
2792 }
2793 break;
2794 case 0x11:
2795 GETBYTE ();
2796 switch (op[3] & 0x00)
2797 {
2798 case 0x00:
2799 goto op_semantics_17;
2800 break;
2801 }
2802 break;
2803 default: UNSUPPORTED(); break;
2804 }
2805 break;
2806 case 0xc0:
2807 GETBYTE ();
2808 switch (op[2] & 0x00)
2809 {
2810 case 0x00:
2811 goto op_semantics_1;
2812 break;
2813 }
2814 break;
2815 case 0xc1:
2816 GETBYTE ();
2817 switch (op[2] & 0x00)
2818 {
2819 case 0x00:
2820 goto op_semantics_1;
2821 break;
2822 }
2823 break;
2824 case 0xc2:
2825 GETBYTE ();
2826 switch (op[2] & 0x00)
2827 {
2828 case 0x00:
2829 goto op_semantics_1;
2830 break;
2831 }
2832 break;
2833 case 0xc3:
2834 GETBYTE ();
2835 switch (op[2] & 0x00)
2836 {
2837 case 0x00:
2838 goto op_semantics_1;
2839 break;
2840 }
2841 break;
2842 case 0xc4:
2843 GETBYTE ();
2844 switch (op[2] & 0x00)
2845 {
2846 case 0x00:
2847 goto op_semantics_2;
2848 break;
2849 }
2850 break;
2851 case 0xc5:
2852 GETBYTE ();
2853 switch (op[2] & 0x00)
2854 {
2855 case 0x00:
2856 goto op_semantics_2;
2857 break;
2858 }
2859 break;
2860 case 0xc6:
2861 GETBYTE ();
2862 switch (op[2] & 0x00)
2863 {
2864 case 0x00:
2865 goto op_semantics_2;
2866 break;
2867 }
2868 break;
2869 case 0xc7:
2870 GETBYTE ();
2871 switch (op[2] & 0x00)
2872 {
2873 case 0x00:
2874 goto op_semantics_2;
2875 break;
2876 }
2877 break;
2878 case 0xc8:
2879 GETBYTE ();
2880 switch (op[2] & 0x00)
2881 {
2882 case 0x00:
2883 goto op_semantics_3;
2884 break;
2885 }
2886 break;
2887 case 0xc9:
2888 GETBYTE ();
2889 switch (op[2] & 0x00)
2890 {
2891 case 0x00:
2892 goto op_semantics_3;
2893 break;
2894 }
2895 break;
2896 case 0xca:
2897 GETBYTE ();
2898 switch (op[2] & 0x00)
2899 {
2900 case 0x00:
2901 goto op_semantics_3;
2902 break;
2903 }
2904 break;
2905 case 0xcb:
2906 GETBYTE ();
2907 switch (op[2] & 0x00)
2908 {
2909 case 0x00:
2910 goto op_semantics_3;
2911 break;
2912 }
2913 break;
2914 case 0xcc:
2915 GETBYTE ();
2916 switch (op[2] & 0x00)
2917 {
2918 case 0x00:
2919 goto op_semantics_4;
2920 break;
2921 }
2922 break;
2923 case 0xcd:
2924 GETBYTE ();
2925 switch (op[2] & 0x00)
2926 {
2927 case 0x00:
2928 goto op_semantics_4;
2929 break;
2930 }
2931 break;
2932 case 0xce:
2933 GETBYTE ();
2934 switch (op[2] & 0x00)
2935 {
2936 case 0x00:
2937 goto op_semantics_4;
2938 break;
2939 }
2940 break;
2941 case 0xcf:
2942 GETBYTE ();
2943 switch (op[2] & 0x00)
2944 {
2945 case 0x00:
2946 goto op_semantics_4;
2947 break;
2948 }
2949 break;
2950 case 0xd0:
2951 GETBYTE ();
2952 switch (op[2] & 0x00)
2953 {
2954 case 0x00:
2955 goto op_semantics_5;
2956 break;
2957 }
2958 break;
2959 case 0xd1:
2960 GETBYTE ();
2961 switch (op[2] & 0x00)
2962 {
2963 case 0x00:
2964 goto op_semantics_5;
2965 break;
2966 }
2967 break;
2968 case 0xd2:
2969 GETBYTE ();
2970 switch (op[2] & 0x00)
2971 {
2972 case 0x00:
2973 goto op_semantics_5;
2974 break;
2975 }
2976 break;
2977 case 0xd3:
2978 GETBYTE ();
2979 switch (op[2] & 0x00)
2980 {
2981 case 0x00:
2982 goto op_semantics_5;
2983 break;
2984 }
2985 break;
2986 case 0xd4:
2987 GETBYTE ();
2988 switch (op[2] & 0x00)
2989 {
2990 case 0x00:
2991 goto op_semantics_6;
2992 break;
2993 }
2994 break;
2995 case 0xd5:
2996 GETBYTE ();
2997 switch (op[2] & 0x00)
2998 {
2999 case 0x00:
3000 goto op_semantics_6;
3001 break;
3002 }
3003 break;
3004 case 0xd6:
3005 GETBYTE ();
3006 switch (op[2] & 0x00)
3007 {
3008 case 0x00:
3009 goto op_semantics_6;
3010 break;
3011 }
3012 break;
3013 case 0xd7:
3014 GETBYTE ();
3015 switch (op[2] & 0x00)
3016 {
3017 case 0x00:
3018 goto op_semantics_6;
3019 break;
3020 }
3021 break;
3022 case 0xe0:
3023 GETBYTE ();
3024 switch (op[2] & 0xff)
3025 {
3026 case 0x00:
3027 GETBYTE ();
3028 switch (op[3] & 0x00)
3029 {
3030 case 0x00:
3031 goto op_semantics_7;
3032 break;
3033 }
3034 break;
3035 case 0x04:
3036 GETBYTE ();
3037 switch (op[3] & 0x00)
3038 {
3039 case 0x00:
3040 goto op_semantics_8;
3041 break;
3042 }
3043 break;
3044 case 0x05:
3045 GETBYTE ();
3046 switch (op[3] & 0x00)
3047 {
3048 case 0x00:
3049 goto op_semantics_9;
3050 break;
3051 }
3052 break;
3053 case 0x06:
3054 GETBYTE ();
3055 switch (op[3] & 0x00)
3056 {
3057 case 0x00:
3058 goto op_semantics_10;
3059 break;
3060 }
3061 break;
3062 case 0x07:
3063 GETBYTE ();
3064 switch (op[3] & 0x00)
3065 {
3066 case 0x00:
3067 goto op_semantics_11;
3068 break;
3069 }
3070 break;
3071 case 0x08:
3072 GETBYTE ();
3073 switch (op[3] & 0x00)
3074 {
3075 case 0x00:
3076 goto op_semantics_12;
3077 break;
3078 }
3079 break;
3080 case 0x09:
3081 GETBYTE ();
3082 switch (op[3] & 0x00)
3083 {
3084 case 0x00:
3085 goto op_semantics_13;
3086 break;
3087 }
3088 break;
3089 case 0x0c:
3090 GETBYTE ();
3091 switch (op[3] & 0x00)
3092 {
3093 case 0x00:
3094 goto op_semantics_14;
3095 break;
3096 }
3097 break;
3098 case 0x0d:
3099 GETBYTE ();
3100 switch (op[3] & 0x00)
3101 {
3102 case 0x00:
3103 goto op_semantics_15;
3104 break;
3105 }
3106 break;
3107 case 0x10:
3108 GETBYTE ();
3109 switch (op[3] & 0x00)
3110 {
3111 case 0x00:
3112 goto op_semantics_16;
3113 break;
3114 }
3115 break;
3116 case 0x11:
3117 GETBYTE ();
3118 switch (op[3] & 0x00)
3119 {
3120 case 0x00:
3121 goto op_semantics_17;
3122 break;
3123 }
3124 break;
3125 default: UNSUPPORTED(); break;
3126 }
3127 break;
3128 case 0xe1:
3129 GETBYTE ();
3130 switch (op[2] & 0xff)
3131 {
3132 case 0x00:
3133 GETBYTE ();
3134 switch (op[3] & 0x00)
3135 {
3136 case 0x00:
3137 goto op_semantics_7;
3138 break;
3139 }
3140 break;
3141 case 0x04:
3142 GETBYTE ();
3143 switch (op[3] & 0x00)
3144 {
3145 case 0x00:
3146 goto op_semantics_8;
3147 break;
3148 }
3149 break;
3150 case 0x05:
3151 GETBYTE ();
3152 switch (op[3] & 0x00)
3153 {
3154 case 0x00:
3155 goto op_semantics_9;
3156 break;
3157 }
3158 break;
3159 case 0x06:
3160 GETBYTE ();
3161 switch (op[3] & 0x00)
3162 {
3163 case 0x00:
3164 goto op_semantics_10;
3165 break;
3166 }
3167 break;
3168 case 0x07:
3169 GETBYTE ();
3170 switch (op[3] & 0x00)
3171 {
3172 case 0x00:
3173 goto op_semantics_11;
3174 break;
3175 }
3176 break;
3177 case 0x08:
3178 GETBYTE ();
3179 switch (op[3] & 0x00)
3180 {
3181 case 0x00:
3182 goto op_semantics_12;
3183 break;
3184 }
3185 break;
3186 case 0x09:
3187 GETBYTE ();
3188 switch (op[3] & 0x00)
3189 {
3190 case 0x00:
3191 goto op_semantics_13;
3192 break;
3193 }
3194 break;
3195 case 0x0c:
3196 GETBYTE ();
3197 switch (op[3] & 0x00)
3198 {
3199 case 0x00:
3200 goto op_semantics_14;
3201 break;
3202 }
3203 break;
3204 case 0x0d:
3205 GETBYTE ();
3206 switch (op[3] & 0x00)
3207 {
3208 case 0x00:
3209 goto op_semantics_15;
3210 break;
3211 }
3212 break;
3213 case 0x10:
3214 GETBYTE ();
3215 switch (op[3] & 0x00)
3216 {
3217 case 0x00:
3218 goto op_semantics_16;
3219 break;
3220 }
3221 break;
3222 case 0x11:
3223 GETBYTE ();
3224 switch (op[3] & 0x00)
3225 {
3226 case 0x00:
3227 goto op_semantics_17;
3228 break;
3229 }
3230 break;
3231 default: UNSUPPORTED(); break;
3232 }
3233 break;
3234 case 0xe2:
3235 GETBYTE ();
3236 switch (op[2] & 0xff)
3237 {
3238 case 0x00:
3239 GETBYTE ();
3240 switch (op[3] & 0x00)
3241 {
3242 case 0x00:
3243 goto op_semantics_7;
3244 break;
3245 }
3246 break;
3247 case 0x04:
3248 GETBYTE ();
3249 switch (op[3] & 0x00)
3250 {
3251 case 0x00:
3252 goto op_semantics_8;
3253 break;
3254 }
3255 break;
3256 case 0x05:
3257 GETBYTE ();
3258 switch (op[3] & 0x00)
3259 {
3260 case 0x00:
3261 goto op_semantics_9;
3262 break;
3263 }
3264 break;
3265 case 0x06:
3266 GETBYTE ();
3267 switch (op[3] & 0x00)
3268 {
3269 case 0x00:
3270 goto op_semantics_10;
3271 break;
3272 }
3273 break;
3274 case 0x07:
3275 GETBYTE ();
3276 switch (op[3] & 0x00)
3277 {
3278 case 0x00:
3279 goto op_semantics_11;
3280 break;
3281 }
3282 break;
3283 case 0x08:
3284 GETBYTE ();
3285 switch (op[3] & 0x00)
3286 {
3287 case 0x00:
3288 goto op_semantics_12;
3289 break;
3290 }
3291 break;
3292 case 0x09:
3293 GETBYTE ();
3294 switch (op[3] & 0x00)
3295 {
3296 case 0x00:
3297 goto op_semantics_13;
3298 break;
3299 }
3300 break;
3301 case 0x0c:
3302 GETBYTE ();
3303 switch (op[3] & 0x00)
3304 {
3305 case 0x00:
3306 goto op_semantics_14;
3307 break;
3308 }
3309 break;
3310 case 0x0d:
3311 GETBYTE ();
3312 switch (op[3] & 0x00)
3313 {
3314 case 0x00:
3315 goto op_semantics_15;
3316 break;
3317 }
3318 break;
3319 case 0x10:
3320 GETBYTE ();
3321 switch (op[3] & 0x00)
3322 {
3323 case 0x00:
3324 goto op_semantics_16;
3325 break;
3326 }
3327 break;
3328 case 0x11:
3329 GETBYTE ();
3330 switch (op[3] & 0x00)
3331 {
3332 case 0x00:
3333 goto op_semantics_17;
3334 break;
3335 }
3336 break;
3337 default: UNSUPPORTED(); break;
3338 }
3339 break;
3340 case 0xe3:
3341 GETBYTE ();
3342 switch (op[2] & 0xff)
3343 {
3344 case 0x00:
3345 GETBYTE ();
3346 switch (op[3] & 0x00)
3347 {
3348 case 0x00:
3349 goto op_semantics_7;
3350 break;
3351 }
3352 break;
3353 case 0x04:
3354 GETBYTE ();
3355 switch (op[3] & 0x00)
3356 {
3357 case 0x00:
3358 goto op_semantics_8;
3359 break;
3360 }
3361 break;
3362 case 0x05:
3363 GETBYTE ();
3364 switch (op[3] & 0x00)
3365 {
3366 case 0x00:
3367 goto op_semantics_9;
3368 break;
3369 }
3370 break;
3371 case 0x06:
3372 GETBYTE ();
3373 switch (op[3] & 0x00)
3374 {
3375 case 0x00:
3376 goto op_semantics_10;
3377 break;
3378 }
3379 break;
3380 case 0x07:
3381 GETBYTE ();
3382 switch (op[3] & 0x00)
3383 {
3384 case 0x00:
3385 goto op_semantics_11;
3386 break;
3387 }
3388 break;
3389 case 0x08:
3390 GETBYTE ();
3391 switch (op[3] & 0x00)
3392 {
3393 case 0x00:
3394 goto op_semantics_12;
3395 break;
3396 }
3397 break;
3398 case 0x09:
3399 GETBYTE ();
3400 switch (op[3] & 0x00)
3401 {
3402 case 0x00:
3403 goto op_semantics_13;
3404 break;
3405 }
3406 break;
3407 case 0x0c:
3408 GETBYTE ();
3409 switch (op[3] & 0x00)
3410 {
3411 case 0x00:
3412 goto op_semantics_14;
3413 break;
3414 }
3415 break;
3416 case 0x0d:
3417 GETBYTE ();
3418 switch (op[3] & 0x00)
3419 {
3420 case 0x00:
3421 goto op_semantics_15;
3422 break;
3423 }
3424 break;
3425 case 0x10:
3426 GETBYTE ();
3427 switch (op[3] & 0x00)
3428 {
3429 case 0x00:
3430 goto op_semantics_16;
3431 break;
3432 }
3433 break;
3434 case 0x11:
3435 GETBYTE ();
3436 switch (op[3] & 0x00)
3437 {
3438 case 0x00:
3439 goto op_semantics_17;
3440 break;
3441 }
3442 break;
3443 default: UNSUPPORTED(); break;
3444 }
3445 break;
3446 default: UNSUPPORTED(); break;
3447 }
3448 break;
3449 case 0x08:
3450 case 0x09:
3451 case 0x0a:
3452 case 0x0b:
3453 case 0x0c:
3454 case 0x0d:
3455 case 0x0e:
3456 case 0x0f:
3457 {
3458 /** 0000 1dsp bra.s %a0 */
78e98aab 3459#line 714 "rx-decode.opc"
c7927a3c
NC		 3460 int dsp AU = op[0] & 0x07;
3461 if (trace)
3462 {
3463 printf ("\033[33m%s\033[0m %02x\n",
3464 "/** 0000 1dsp bra.s %a0 */",
3465 op[0]);
3466 printf (" dsp = 0x%x\n", dsp);
3467 }
3468 SYNTAX("bra.s %a0");
78e98aab 3469#line 714 "rx-decode.opc"
f9c7014e 3470 ID(branch); DC(pc + dsp3map[dsp]);
c7927a3c
NC		 3471
3472 }
3473 break;
3474 case 0x10:
3475 case 0x11:
3476 case 0x12:
3477 case 0x13:
3478 case 0x14:
3479 case 0x15:
3480 case 0x16:
3481 case 0x17:
3482 case 0x18:
3483 case 0x19:
3484 case 0x1a:
3485 case 0x1b:
3486 case 0x1c:
3487 case 0x1d:
3488 case 0x1e:
3489 case 0x1f:
3490 {
3491 /** 0001 n dsp b%1.s %a0 */
78e98aab 3492#line 704 "rx-decode.opc"
c7927a3c 3493 int n AU = (op[0] >> 3) & 0x01;
78e98aab 3494#line 704 "rx-decode.opc"
c7927a3c
NC		 3495 int dsp AU = op[0] & 0x07;
3496 if (trace)
3497 {
3498 printf ("\033[33m%s\033[0m %02x\n",
3499 "/** 0001 n dsp b%1.s %a0 */",
3500 op[0]);
3501 printf (" n = 0x%x,", n);
3502 printf (" dsp = 0x%x\n", dsp);
3503 }
3504 SYNTAX("b%1.s %a0");
78e98aab 3505#line 704 "rx-decode.opc"
c7927a3c
NC		 3506 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3507
3508 }
3509 break;
3510 case 0x20:
3511 case 0x21:
3512 case 0x22:
3513 case 0x23:
3514 case 0x24:
3515 case 0x25:
3516 case 0x26:
3517 case 0x27:
3518 case 0x28:
3519 case 0x29:
3520 case 0x2a:
3521 case 0x2b:
3522 case 0x2c:
3523 case 0x2d:
3524 case 0x2f:
3525 {
3526 /** 0010 cond b%1.b %a0 */
78e98aab 3527#line 707 "rx-decode.opc"
c7927a3c
NC		 3528 int cond AU = op[0] & 0x0f;
3529 if (trace)
3530 {
3531 printf ("\033[33m%s\033[0m %02x\n",
3532 "/** 0010 cond b%1.b %a0 */",
3533 op[0]);
3534 printf (" cond = 0x%x\n", cond);
3535 }
3536 SYNTAX("b%1.b %a0");
78e98aab 3537#line 707 "rx-decode.opc"
c7927a3c
NC		 3538 ID(branch); Scc(cond); DC(pc + IMMex (1));
3539
3540 }
3541 break;
3542 case 0x2e:
3543 {
3544 /** 0010 1110 bra.b %a0 */
3545 if (trace)
3546 {
3547 printf ("\033[33m%s\033[0m %02x\n",
3548 "/** 0010 1110 bra.b %a0 */",
3549 op[0]);
3550 }
3551 SYNTAX("bra.b %a0");
78e98aab 3552#line 717 "rx-decode.opc"
f9c7014e 3553 ID(branch); DC(pc + IMMex(1));
c7927a3c
NC		 3554
3555 }
3556 break;
3557 case 0x38:
3558 {
3559 /** 0011 1000 bra.w %a0 */
3560 if (trace)
3561 {
3562 printf ("\033[33m%s\033[0m %02x\n",
3563 "/** 0011 1000 bra.w %a0 */",
3564 op[0]);
3565 }
3566 SYNTAX("bra.w %a0");
78e98aab 3567#line 720 "rx-decode.opc"
f9c7014e 3568 ID(branch); DC(pc + IMMex(2));
c7927a3c
NC		 3569
3570 }
3571 break;
3572 case 0x39:
3573 {
3574 /** 0011 1001 bsr.w %a0 */
3575 if (trace)
3576 {
3577 printf ("\033[33m%s\033[0m %02x\n",
3578 "/** 0011 1001 bsr.w %a0 */",
3579 op[0]);
3580 }
3581 SYNTAX("bsr.w %a0");
78e98aab 3582#line 736 "rx-decode.opc"
c7927a3c
NC		 3583 ID(jsr); DC(pc + IMMex(2));
3584
3585 }
3586 break;
3587 case 0x3a:
3588 case 0x3b:
3589 {
3590 /** 0011 101c b%1.w %a0 */
78e98aab 3591#line 710 "rx-decode.opc"
c7927a3c
NC		 3592 int c AU = op[0] & 0x01;
3593 if (trace)
3594 {
3595 printf ("\033[33m%s\033[0m %02x\n",
3596 "/** 0011 101c b%1.w %a0 */",
3597 op[0]);
3598 printf (" c = 0x%x\n", c);
3599 }
3600 SYNTAX("b%1.w %a0");
78e98aab 3601#line 710 "rx-decode.opc"
c7927a3c
NC		 3602 ID(branch); Scc(c); DC(pc + IMMex (2));
3603
3604
3605 }
3606 break;
3607 case 0x3c:
3608 GETBYTE ();
3609 switch (op[1] & 0x00)
3610 {
3611 case 0x00:
3612 op_semantics_19:
3613 {
3614 /** 0011 11sz d dst sppp mov%s #%1, %0 */
78e98aab 3615#line 284 "rx-decode.opc"
c7927a3c 3616 int sz AU = op[0] & 0x03;
78e98aab 3617#line 284 "rx-decode.opc"
c7927a3c 3618 int d AU = (op[1] >> 7) & 0x01;
78e98aab 3619#line 284 "rx-decode.opc"
c7927a3c 3620 int dst AU = (op[1] >> 4) & 0x07;
78e98aab 3621#line 284 "rx-decode.opc"
c7927a3c
NC		 3622 int sppp AU = op[1] & 0x0f;
3623 if (trace)
3624 {
3625 printf ("\033[33m%s\033[0m %02x %02x\n",
3626 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3627 op[0], op[1]);
3628 printf (" sz = 0x%x,", sz);
3629 printf (" d = 0x%x,", d);
3630 printf (" dst = 0x%x,", dst);
3631 printf (" sppp = 0x%x\n", sppp);
3632 }
3633 SYNTAX("mov%s #%1, %0");
78e98aab 3634#line 284 "rx-decode.opc"
3cf79a01 3635 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
c7927a3c
NC		 3636
3637 }
3638 break;
3639 }
3640 break;
3641 case 0x3d:
3642 GETBYTE ();
3643 switch (op[1] & 0x00)
3644 {
3645 case 0x00:
3646 goto op_semantics_19;
3647 break;
3648 }
3649 break;
3650 case 0x3e:
3651 GETBYTE ();
3652 switch (op[1] & 0x00)
3653 {
3654 case 0x00:
3655 goto op_semantics_19;
3656 break;
3657 }
3658 break;
3659 case 0x3f:
3660 GETBYTE ();
3661 switch (op[1] & 0x00)
3662 {
3663 case 0x00:
3664 {
3665 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
78e98aab 3666#line 381 "rx-decode.opc"
c7927a3c 3667 int rega AU = (op[1] >> 4) & 0x0f;
78e98aab 3668#line 381 "rx-decode.opc"
c7927a3c
NC		 3669 int regb AU = op[1] & 0x0f;
3670 if (trace)
3671 {
3672 printf ("\033[33m%s\033[0m %02x %02x\n",
3673 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3674 op[0], op[1]);
3675 printf (" rega = 0x%x,", rega);
3676 printf (" regb = 0x%x\n", regb);
3677 }
3678 SYNTAX("rtsd #%1, %2-%0");
78e98aab 3679#line 381 "rx-decode.opc"
c7927a3c
NC		 3680 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3681
3682 /*----------------------------------------------------------------------*/
3683 /* AND */
3684
3685 }
3686 break;
3687 }
3688 break;
3689 case 0x40:
3690 GETBYTE ();
3691 switch (op[1] & 0x00)
3692 {
3693 case 0x00:
3694 op_semantics_20:
3695 {
3696 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
78e98aab 3697#line 516 "rx-decode.opc"
c7927a3c 3698 int ss AU = op[0] & 0x03;
78e98aab 3699#line 516 "rx-decode.opc"
c7927a3c 3700 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 3701#line 516 "rx-decode.opc"
c7927a3c
NC		 3702 int rdst AU = op[1] & 0x0f;
3703 if (trace)
3704 {
3705 printf ("\033[33m%s\033[0m %02x %02x\n",
3706 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3707 op[0], op[1]);
3708 printf (" ss = 0x%x,", ss);
3709 printf (" rsrc = 0x%x,", rsrc);
3710 printf (" rdst = 0x%x\n", rdst);
3711 }
3712 SYNTAX("sub %2%S2, %1");
78e98aab 3713#line 516 "rx-decode.opc"
3cf79a01 3714 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 3715
3716 }
3717 break;
3718 }
3719 break;
3720 case 0x41:
3721 GETBYTE ();
3722 switch (op[1] & 0x00)
3723 {
3724 case 0x00:
3725 goto op_semantics_20;
3726 break;
3727 }
3728 break;
3729 case 0x42:
3730 GETBYTE ();
3731 switch (op[1] & 0x00)
3732 {
3733 case 0x00:
3734 goto op_semantics_20;
3735 break;
3736 }
3737 break;
3738 case 0x43:
3739 GETBYTE ();
3740 switch (op[1] & 0x00)
3741 {
3742 case 0x00:
3743 goto op_semantics_20;
3744 break;
3745 }
3746 break;
3747 case 0x44:
3748 GETBYTE ();
3749 switch (op[1] & 0x00)
3750 {
3751 case 0x00:
3752 op_semantics_21:
3753 {
3754 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
78e98aab 3755#line 504 "rx-decode.opc"
c7927a3c 3756 int ss AU = op[0] & 0x03;
78e98aab 3757#line 504 "rx-decode.opc"
c7927a3c 3758 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 3759#line 504 "rx-decode.opc"
c7927a3c
NC		 3760 int rdst AU = op[1] & 0x0f;
3761 if (trace)
3762 {
3763 printf ("\033[33m%s\033[0m %02x %02x\n",
3764 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3765 op[0], op[1]);
3766 printf (" ss = 0x%x,", ss);
3767 printf (" rsrc = 0x%x,", rsrc);
3768 printf (" rdst = 0x%x\n", rdst);
3769 }
3770 SYNTAX("cmp %2%S2, %1");
78e98aab 3771#line 504 "rx-decode.opc"
3cf79a01 3772 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
c7927a3c
NC		 3773
3774 }
3775 break;
3776 }
3777 break;
3778 case 0x45:
3779 GETBYTE ();
3780 switch (op[1] & 0x00)
3781 {
3782 case 0x00:
3783 goto op_semantics_21;
3784 break;
3785 }
3786 break;
3787 case 0x46:
3788 GETBYTE ();
3789 switch (op[1] & 0x00)
3790 {
3791 case 0x00:
3792 goto op_semantics_21;
3793 break;
3794 }
3795 break;
3796 case 0x47:
3797 GETBYTE ();
3798 switch (op[1] & 0x00)
3799 {
3800 case 0x00:
3801 goto op_semantics_21;
3802 break;
3803 }
3804 break;
3805 case 0x48:
3806 GETBYTE ();
3807 switch (op[1] & 0x00)
3808 {
3809 case 0x00:
3810 op_semantics_22:
3811 {
3812 /** 0100 10ss rsrc rdst add %1%S1, %0 */
78e98aab 3813#line 480 "rx-decode.opc"
c7927a3c 3814 int ss AU = op[0] & 0x03;
78e98aab 3815#line 480 "rx-decode.opc"
c7927a3c 3816 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 3817#line 480 "rx-decode.opc"
c7927a3c
NC		 3818 int rdst AU = op[1] & 0x0f;
3819 if (trace)
3820 {
3821 printf ("\033[33m%s\033[0m %02x %02x\n",
3822 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3823 op[0], op[1]);
3824 printf (" ss = 0x%x,", ss);
3825 printf (" rsrc = 0x%x,", rsrc);
3826 printf (" rdst = 0x%x\n", rdst);
3827 }
3828 SYNTAX("add %1%S1, %0");
78e98aab 3829#line 480 "rx-decode.opc"
3cf79a01 3830 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 3831
3832 }
3833 break;
3834 }
3835 break;
3836 case 0x49:
3837 GETBYTE ();
3838 switch (op[1] & 0x00)
3839 {
3840 case 0x00:
3841 goto op_semantics_22;
3842 break;
3843 }
3844 break;
3845 case 0x4a:
3846 GETBYTE ();
3847 switch (op[1] & 0x00)
3848 {
3849 case 0x00:
3850 goto op_semantics_22;
3851 break;
3852 }
3853 break;
3854 case 0x4b:
3855 GETBYTE ();
3856 switch (op[1] & 0x00)
3857 {
3858 case 0x00:
3859 goto op_semantics_22;
3860 break;
3861 }
3862 break;
3863 case 0x4c:
3864 GETBYTE ();
3865 switch (op[1] & 0x00)
3866 {
3867 case 0x00:
3868 op_semantics_23:
3869 {
3870 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
78e98aab 3871#line 585 "rx-decode.opc"
c7927a3c 3872 int ss AU = op[0] & 0x03;
78e98aab 3873#line 585 "rx-decode.opc"
c7927a3c 3874 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 3875#line 585 "rx-decode.opc"
c7927a3c
NC		 3876 int rdst AU = op[1] & 0x0f;
3877 if (trace)
3878 {
3879 printf ("\033[33m%s\033[0m %02x %02x\n",
3880 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3881 op[0], op[1]);
3882 printf (" ss = 0x%x,", ss);
3883 printf (" rsrc = 0x%x,", rsrc);
3884 printf (" rdst = 0x%x\n", rdst);
3885 }
3886 SYNTAX("mul %1%S1, %0");
78e98aab 3887#line 585 "rx-decode.opc"
3cf79a01 3888 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
c7927a3c
NC		 3889
3890 }
3891 break;
3892 }
3893 break;
3894 case 0x4d:
3895 GETBYTE ();
3896 switch (op[1] & 0x00)
3897 {
3898 case 0x00:
3899 goto op_semantics_23;
3900 break;
3901 }
3902 break;
3903 case 0x4e:
3904 GETBYTE ();
3905 switch (op[1] & 0x00)
3906 {
3907 case 0x00:
3908 goto op_semantics_23;
3909 break;
3910 }
3911 break;
3912 case 0x4f:
3913 GETBYTE ();
3914 switch (op[1] & 0x00)
3915 {
3916 case 0x00:
3917 goto op_semantics_23;
3918 break;
3919 }
3920 break;
3921 case 0x50:
3922 GETBYTE ();
3923 switch (op[1] & 0x00)
3924 {
3925 case 0x00:
3926 op_semantics_24:
3927 {
3928 /** 0101 00ss rsrc rdst and %1%S1, %0 */
78e98aab 3929#line 393 "rx-decode.opc"
c7927a3c 3930 int ss AU = op[0] & 0x03;
78e98aab 3931#line 393 "rx-decode.opc"
c7927a3c 3932 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 3933#line 393 "rx-decode.opc"
c7927a3c
NC		 3934 int rdst AU = op[1] & 0x0f;
3935 if (trace)
3936 {
3937 printf ("\033[33m%s\033[0m %02x %02x\n",
3938 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3939 op[0], op[1]);
3940 printf (" ss = 0x%x,", ss);
3941 printf (" rsrc = 0x%x,", rsrc);
3942 printf (" rdst = 0x%x\n", rdst);
3943 }
3944 SYNTAX("and %1%S1, %0");
78e98aab 3945#line 393 "rx-decode.opc"
3cf79a01 3946 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
c7927a3c
NC		 3947
3948 }
3949 break;
3950 }
3951 break;
3952 case 0x51:
3953 GETBYTE ();
3954 switch (op[1] & 0x00)
3955 {
3956 case 0x00:
3957 goto op_semantics_24;
3958 break;
3959 }
3960 break;
3961 case 0x52:
3962 GETBYTE ();
3963 switch (op[1] & 0x00)
3964 {
3965 case 0x00:
3966 goto op_semantics_24;
3967 break;
3968 }
3969 break;
3970 case 0x53:
3971 GETBYTE ();
3972 switch (op[1] & 0x00)
3973 {
3974 case 0x00:
3975 goto op_semantics_24;
3976 break;
3977 }
3978 break;
3979 case 0x54:
3980 GETBYTE ();
3981 switch (op[1] & 0x00)
3982 {
3983 case 0x00:
3984 op_semantics_25:
3985 {
3986 /** 0101 01ss rsrc rdst or %1%S1, %0 */
78e98aab 3987#line 411 "rx-decode.opc"
c7927a3c 3988 int ss AU = op[0] & 0x03;
78e98aab 3989#line 411 "rx-decode.opc"
c7927a3c 3990 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 3991#line 411 "rx-decode.opc"
c7927a3c
NC		 3992 int rdst AU = op[1] & 0x0f;
3993 if (trace)
3994 {
3995 printf ("\033[33m%s\033[0m %02x %02x\n",
3996 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
3997 op[0], op[1]);
3998 printf (" ss = 0x%x,", ss);
3999 printf (" rsrc = 0x%x,", rsrc);
4000 printf (" rdst = 0x%x\n", rdst);
4001 }
4002 SYNTAX("or %1%S1, %0");
78e98aab 4003#line 411 "rx-decode.opc"
3cf79a01 4004 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
c7927a3c
NC		 4005
4006 }
4007 break;
4008 }
4009 break;
4010 case 0x55:
4011 GETBYTE ();
4012 switch (op[1] & 0x00)
4013 {
4014 case 0x00:
4015 goto op_semantics_25;
4016 break;
4017 }
4018 break;
4019 case 0x56:
4020 GETBYTE ();
4021 switch (op[1] & 0x00)
4022 {
4023 case 0x00:
4024 goto op_semantics_25;
4025 break;
4026 }
4027 break;
4028 case 0x57:
4029 GETBYTE ();
4030 switch (op[1] & 0x00)
4031 {
4032 case 0x00:
4033 goto op_semantics_25;
4034 break;
4035 }
4036 break;
4037 case 0x58:
4038 GETBYTE ();
4039 switch (op[1] & 0x00)
4040 {
4041 case 0x00:
4042 op_semantics_26:
4043 {
4044 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
78e98aab 4045#line 332 "rx-decode.opc"
c7927a3c 4046 int s AU = (op[0] >> 2) & 0x01;
78e98aab 4047#line 332 "rx-decode.opc"
c7927a3c 4048 int ss AU = op[0] & 0x03;
78e98aab 4049#line 332 "rx-decode.opc"
c7927a3c 4050 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 4051#line 332 "rx-decode.opc"
c7927a3c
NC		 4052 int rdst AU = op[1] & 0x0f;
4053 if (trace)
4054 {
4055 printf ("\033[33m%s\033[0m %02x %02x\n",
4056 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4057 op[0], op[1]);
4058 printf (" s = 0x%x,", s);
4059 printf (" ss = 0x%x,", ss);
4060 printf (" rsrc = 0x%x,", rsrc);
4061 printf (" rdst = 0x%x\n", rdst);
4062 }
4063 SYNTAX("movu%s %1, %0");
78e98aab 4064#line 332 "rx-decode.opc"
3cf79a01 4065 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____;
c7927a3c
NC		 4066
4067 }
4068 break;
4069 }
4070 break;
4071 case 0x59:
4072 GETBYTE ();
4073 switch (op[1] & 0x00)
4074 {
4075 case 0x00:
4076 goto op_semantics_26;
4077 break;
4078 }
4079 break;
4080 case 0x5a:
4081 GETBYTE ();
4082 switch (op[1] & 0x00)
4083 {
4084 case 0x00:
4085 goto op_semantics_26;
4086 break;
4087 }
4088 break;
4089 case 0x5b:
4090 GETBYTE ();
4091 switch (op[1] & 0x00)
4092 {
4093 case 0x00:
4094 goto op_semantics_26;
4095 break;
4096 }
4097 break;
4098 case 0x5c:
4099 GETBYTE ();
4100 switch (op[1] & 0x00)
4101 {
4102 case 0x00:
4103 goto op_semantics_26;
4104 break;
4105 }
4106 break;
4107 case 0x5d:
4108 GETBYTE ();
4109 switch (op[1] & 0x00)
4110 {
4111 case 0x00:
4112 goto op_semantics_26;
4113 break;
4114 }
4115 break;
4116 case 0x5e:
4117 GETBYTE ();
4118 switch (op[1] & 0x00)
4119 {
4120 case 0x00:
4121 goto op_semantics_26;
4122 break;
4123 }
4124 break;
4125 case 0x5f:
4126 GETBYTE ();
4127 switch (op[1] & 0x00)
4128 {
4129 case 0x00:
4130 goto op_semantics_26;
4131 break;
4132 }
4133 break;
4134 case 0x60:
4135 GETBYTE ();
4136 switch (op[1] & 0x00)
4137 {
4138 case 0x00:
4139 {
4140 /** 0110 0000 immm rdst sub #%2, %0 */
78e98aab 4141#line 513 "rx-decode.opc"
c7927a3c 4142 int immm AU = (op[1] >> 4) & 0x0f;
78e98aab 4143#line 513 "rx-decode.opc"
c7927a3c
NC		 4144 int rdst AU = op[1] & 0x0f;
4145 if (trace)
4146 {
4147 printf ("\033[33m%s\033[0m %02x %02x\n",
4148 "/** 0110 0000 immm rdst sub #%2, %0 */",
4149 op[0], op[1]);
4150 printf (" immm = 0x%x,", immm);
4151 printf (" rdst = 0x%x\n", rdst);
4152 }
4153 SYNTAX("sub #%2, %0");
78e98aab 4154#line 513 "rx-decode.opc"
3cf79a01 4155 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 4156
4157 }
4158 break;
4159 }
4160 break;
4161 case 0x61:
4162 GETBYTE ();
4163 switch (op[1] & 0x00)
4164 {
4165 case 0x00:
4166 {
4167 /** 0110 0001 immm rdst cmp #%2, %1 */
78e98aab 4168#line 495 "rx-decode.opc"
c7927a3c 4169 int immm AU = (op[1] >> 4) & 0x0f;
78e98aab 4170#line 495 "rx-decode.opc"
c7927a3c
NC		 4171 int rdst AU = op[1] & 0x0f;
4172 if (trace)
4173 {
4174 printf ("\033[33m%s\033[0m %02x %02x\n",
4175 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4176 op[0], op[1]);
4177 printf (" immm = 0x%x,", immm);
4178 printf (" rdst = 0x%x\n", rdst);
4179 }
4180 SYNTAX("cmp #%2, %1");
78e98aab 4181#line 495 "rx-decode.opc"
3cf79a01 4182 ID(sub); S2C(immm); SR(rdst); F_OSZC;
c7927a3c
NC		 4183
4184 }
4185 break;
4186 }
4187 break;
4188 case 0x62:
4189 GETBYTE ();
4190 switch (op[1] & 0x00)
4191 {
4192 case 0x00:
4193 {
4194 /** 0110 0010 immm rdst add #%1, %0 */
78e98aab 4195#line 477 "rx-decode.opc"
c7927a3c 4196 int immm AU = (op[1] >> 4) & 0x0f;
78e98aab 4197#line 477 "rx-decode.opc"
c7927a3c
NC		 4198 int rdst AU = op[1] & 0x0f;
4199 if (trace)
4200 {
4201 printf ("\033[33m%s\033[0m %02x %02x\n",
4202 "/** 0110 0010 immm rdst add #%1, %0 */",
4203 op[0], op[1]);
4204 printf (" immm = 0x%x,", immm);
4205 printf (" rdst = 0x%x\n", rdst);
4206 }
4207 SYNTAX("add #%1, %0");
78e98aab 4208#line 477 "rx-decode.opc"
3cf79a01 4209 ID(add); SC(immm); DR(rdst); F_OSZC;
c7927a3c
NC		 4210
4211 }
4212 break;
4213 }
4214 break;
4215 case 0x63:
4216 GETBYTE ();
4217 switch (op[1] & 0x00)
4218 {
4219 case 0x00:
4220 {
4221 /** 0110 0011 immm rdst mul #%1, %0 */
78e98aab 4222#line 579 "rx-decode.opc"
c7927a3c 4223 int immm AU = (op[1] >> 4) & 0x0f;
78e98aab 4224#line 579 "rx-decode.opc"
c7927a3c
NC		 4225 int rdst AU = op[1] & 0x0f;
4226 if (trace)
4227 {
4228 printf ("\033[33m%s\033[0m %02x %02x\n",
4229 "/** 0110 0011 immm rdst mul #%1, %0 */",
4230 op[0], op[1]);
4231 printf (" immm = 0x%x,", immm);
4232 printf (" rdst = 0x%x\n", rdst);
4233 }
4234 SYNTAX("mul #%1, %0");
78e98aab 4235#line 579 "rx-decode.opc"
3cf79a01 4236 ID(mul); DR(rdst); SC(immm); F_____;
c7927a3c
NC		 4237
4238 }
4239 break;
4240 }
4241 break;
4242 case 0x64:
4243 GETBYTE ();
4244 switch (op[1] & 0x00)
4245 {
4246 case 0x00:
4247 {
4248 /** 0110 0100 immm rdst and #%1, %0 */
78e98aab 4249#line 387 "rx-decode.opc"
c7927a3c 4250 int immm AU = (op[1] >> 4) & 0x0f;
78e98aab 4251#line 387 "rx-decode.opc"
c7927a3c
NC		 4252 int rdst AU = op[1] & 0x0f;
4253 if (trace)
4254 {
4255 printf ("\033[33m%s\033[0m %02x %02x\n",
4256 "/** 0110 0100 immm rdst and #%1, %0 */",
4257 op[0], op[1]);
4258 printf (" immm = 0x%x,", immm);
4259 printf (" rdst = 0x%x\n", rdst);
4260 }
4261 SYNTAX("and #%1, %0");
78e98aab 4262#line 387 "rx-decode.opc"
3cf79a01 4263 ID(and); SC(immm); DR(rdst); F__SZ_;
c7927a3c
NC		 4264
4265 }
4266 break;
4267 }
4268 break;
4269 case 0x65:
4270 GETBYTE ();
4271 switch (op[1] & 0x00)
4272 {
4273 case 0x00:
4274 {
4275 /** 0110 0101 immm rdst or #%1, %0 */
78e98aab 4276#line 405 "rx-decode.opc"
c7927a3c 4277 int immm AU = (op[1] >> 4) & 0x0f;
78e98aab 4278#line 405 "rx-decode.opc"
c7927a3c
NC		 4279 int rdst AU = op[1] & 0x0f;
4280 if (trace)
4281 {
4282 printf ("\033[33m%s\033[0m %02x %02x\n",
4283 "/** 0110 0101 immm rdst or #%1, %0 */",
4284 op[0], op[1]);
4285 printf (" immm = 0x%x,", immm);
4286 printf (" rdst = 0x%x\n", rdst);
4287 }
4288 SYNTAX("or #%1, %0");
78e98aab 4289#line 405 "rx-decode.opc"
3cf79a01 4290 ID(or); SC(immm); DR(rdst); F__SZ_;
c7927a3c
NC		 4291
4292 }
4293 break;
4294 }
4295 break;
4296 case 0x66:
4297 GETBYTE ();
4298 switch (op[1] & 0x00)
4299 {
4300 case 0x00:
4301 {
4302 /** 0110 0110 immm rdst mov%s #%1, %0 */
78e98aab 4303#line 281 "rx-decode.opc"
c7927a3c 4304 int immm AU = (op[1] >> 4) & 0x0f;
78e98aab 4305#line 281 "rx-decode.opc"
c7927a3c
NC		 4306 int rdst AU = op[1] & 0x0f;
4307 if (trace)
4308 {
4309 printf ("\033[33m%s\033[0m %02x %02x\n",
4310 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4311 op[0], op[1]);
4312 printf (" immm = 0x%x,", immm);
4313 printf (" rdst = 0x%x\n", rdst);
4314 }
4315 SYNTAX("mov%s #%1, %0");
78e98aab 4316#line 281 "rx-decode.opc"
3cf79a01 4317 ID(mov); DR(rdst); SC(immm); F_____;
c7927a3c
NC		 4318
4319 }
4320 break;
4321 }
4322 break;
4323 case 0x67:
4324 {
4325 /** 0110 0111 rtsd #%1 */
4326 if (trace)
4327 {
4328 printf ("\033[33m%s\033[0m %02x\n",
4329 "/** 0110 0111 rtsd #%1 */",
4330 op[0]);
4331 }
4332 SYNTAX("rtsd #%1");
78e98aab 4333#line 378 "rx-decode.opc"
c7927a3c
NC		 4334 ID(rtsd); SC(IMM(1) * 4);
4335
4336 }
4337 break;
4338 case 0x68:
4339 GETBYTE ();
4340 switch (op[1] & 0x00)
4341 {
4342 case 0x00:
4343 op_semantics_27:
4344 {
4345 /** 0110 100i mmmm rdst shlr #%2, %0 */
78e98aab 4346#line 665 "rx-decode.opc"
c7927a3c 4347 int i AU = op[0] & 0x01;
78e98aab 4348#line 665 "rx-decode.opc"
c7927a3c 4349 int mmmm AU = (op[1] >> 4) & 0x0f;
78e98aab 4350#line 665 "rx-decode.opc"
c7927a3c
NC		 4351 int rdst AU = op[1] & 0x0f;
4352 if (trace)
4353 {
4354 printf ("\033[33m%s\033[0m %02x %02x\n",
4355 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4356 op[0], op[1]);
4357 printf (" i = 0x%x,", i);
4358 printf (" mmmm = 0x%x,", mmmm);
4359 printf (" rdst = 0x%x\n", rdst);
4360 }
4361 SYNTAX("shlr #%2, %0");
78e98aab 4362#line 665 "rx-decode.opc"
3cf79a01 4363 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
c7927a3c
NC		 4364
4365 }
4366 break;
4367 }
4368 break;
4369 case 0x69:
4370 GETBYTE ();
4371 switch (op[1] & 0x00)
4372 {
4373 case 0x00:
4374 goto op_semantics_27;
4375 break;
4376 }
4377 break;
4378 case 0x6a:
4379 GETBYTE ();
4380 switch (op[1] & 0x00)
4381 {
4382 case 0x00:
4383 op_semantics_28:
4384 {
4385 /** 0110 101i mmmm rdst shar #%2, %0 */
78e98aab 4386#line 655 "rx-decode.opc"
c7927a3c 4387 int i AU = op[0] & 0x01;
78e98aab 4388#line 655 "rx-decode.opc"
c7927a3c 4389 int mmmm AU = (op[1] >> 4) & 0x0f;
78e98aab 4390#line 655 "rx-decode.opc"
c7927a3c
NC		 4391 int rdst AU = op[1] & 0x0f;
4392 if (trace)
4393 {
4394 printf ("\033[33m%s\033[0m %02x %02x\n",
4395 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4396 op[0], op[1]);
4397 printf (" i = 0x%x,", i);
4398 printf (" mmmm = 0x%x,", mmmm);
4399 printf (" rdst = 0x%x\n", rdst);
4400 }
4401 SYNTAX("shar #%2, %0");
78e98aab 4402#line 655 "rx-decode.opc"
3cf79a01 4403 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
c7927a3c
NC		 4404
4405 }
4406 break;
4407 }
4408 break;
4409 case 0x6b:
4410 GETBYTE ();
4411 switch (op[1] & 0x00)
4412 {
4413 case 0x00:
4414 goto op_semantics_28;
4415 break;
4416 }
4417 break;
4418 case 0x6c:
4419 GETBYTE ();
4420 switch (op[1] & 0x00)
4421 {
4422 case 0x00:
4423 op_semantics_29:
4424 {
4425 /** 0110 110i mmmm rdst shll #%2, %0 */
78e98aab 4426#line 645 "rx-decode.opc"
c7927a3c 4427 int i AU = op[0] & 0x01;
78e98aab 4428#line 645 "rx-decode.opc"
c7927a3c 4429 int mmmm AU = (op[1] >> 4) & 0x0f;
78e98aab 4430#line 645 "rx-decode.opc"
c7927a3c
NC		 4431 int rdst AU = op[1] & 0x0f;
4432 if (trace)
4433 {
4434 printf ("\033[33m%s\033[0m %02x %02x\n",
4435 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4436 op[0], op[1]);
4437 printf (" i = 0x%x,", i);
4438 printf (" mmmm = 0x%x,", mmmm);
4439 printf (" rdst = 0x%x\n", rdst);
4440 }
4441 SYNTAX("shll #%2, %0");
78e98aab 4442#line 645 "rx-decode.opc"
3cf79a01 4443 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 4444
4445 }
4446 break;
4447 }
4448 break;
4449 case 0x6d:
4450 GETBYTE ();
4451 switch (op[1] & 0x00)
4452 {
4453 case 0x00:
4454 goto op_semantics_29;
4455 break;
4456 }
4457 break;
4458 case 0x6e:
4459 GETBYTE ();
4460 switch (op[1] & 0x00)
4461 {
4462 case 0x00:
4463 {
4464 /** 0110 1110 dsta dstb pushm %1-%2 */
78e98aab 4465#line 345 "rx-decode.opc"
c7927a3c 4466 int dsta AU = (op[1] >> 4) & 0x0f;
78e98aab 4467#line 345 "rx-decode.opc"
c7927a3c
NC		 4468 int dstb AU = op[1] & 0x0f;
4469 if (trace)
4470 {
4471 printf ("\033[33m%s\033[0m %02x %02x\n",
4472 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4473 op[0], op[1]);
4474 printf (" dsta = 0x%x,", dsta);
4475 printf (" dstb = 0x%x\n", dstb);
4476 }
4477 SYNTAX("pushm %1-%2");
78e98aab 4478#line 345 "rx-decode.opc"
3cf79a01 4479 ID(pushm); SR(dsta); S2R(dstb); F_____;
c7927a3c
NC		 4480
4481 }
4482 break;
4483 }
4484 break;
4485 case 0x6f:
4486 GETBYTE ();
4487 switch (op[1] & 0x00)
4488 {
4489 case 0x00:
4490 {
4491 /** 0110 1111 dsta dstb popm %1-%2 */
78e98aab 4492#line 342 "rx-decode.opc"
c7927a3c 4493 int dsta AU = (op[1] >> 4) & 0x0f;
78e98aab 4494#line 342 "rx-decode.opc"
c7927a3c
NC		 4495 int dstb AU = op[1] & 0x0f;
4496 if (trace)
4497 {
4498 printf ("\033[33m%s\033[0m %02x %02x\n",
4499 "/** 0110 1111 dsta dstb popm %1-%2 */",
4500 op[0], op[1]);
4501 printf (" dsta = 0x%x,", dsta);
4502 printf (" dstb = 0x%x\n", dstb);
4503 }
4504 SYNTAX("popm %1-%2");
78e98aab 4505#line 342 "rx-decode.opc"
3cf79a01 4506 ID(popm); SR(dsta); S2R(dstb); F_____;
c7927a3c
NC		 4507
4508 }
4509 break;
4510 }
4511 break;
4512 case 0x70:
4513 GETBYTE ();
4514 switch (op[1] & 0x00)
4515 {
4516 case 0x00:
4517 op_semantics_30:
4518 {
4519 /** 0111 00im rsrc rdst add #%1, %2, %0 */
78e98aab 4520#line 486 "rx-decode.opc"
c7927a3c 4521 int im AU = op[0] & 0x03;
78e98aab 4522#line 486 "rx-decode.opc"
c7927a3c 4523 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 4524#line 486 "rx-decode.opc"
c7927a3c
NC		 4525 int rdst AU = op[1] & 0x0f;
4526 if (trace)
4527 {
4528 printf ("\033[33m%s\033[0m %02x %02x\n",
4529 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4530 op[0], op[1]);
4531 printf (" im = 0x%x,", im);
4532 printf (" rsrc = 0x%x,", rsrc);
4533 printf (" rdst = 0x%x\n", rdst);
4534 }
4535 SYNTAX("add #%1, %2, %0");
78e98aab 4536#line 486 "rx-decode.opc"
3cf79a01 4537 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 4538
4539 }
4540 break;
4541 }
4542 break;
4543 case 0x71:
4544 GETBYTE ();
4545 switch (op[1] & 0x00)
4546 {
4547 case 0x00:
4548 goto op_semantics_30;
4549 break;
4550 }
4551 break;
4552 case 0x72:
4553 GETBYTE ();
4554 switch (op[1] & 0x00)
4555 {
4556 case 0x00:
4557 goto op_semantics_30;
4558 break;
4559 }
4560 break;
4561 case 0x73:
4562 GETBYTE ();
4563 switch (op[1] & 0x00)
4564 {
4565 case 0x00:
4566 goto op_semantics_30;
4567 break;
4568 }
4569 break;
4570 case 0x74:
4571 GETBYTE ();
4572 switch (op[1] & 0xf0)
4573 {
4574 case 0x00:
4575 op_semantics_31:
4576 {
4577 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
78e98aab 4578#line 498 "rx-decode.opc"
c7927a3c 4579 int im AU = op[0] & 0x03;
78e98aab 4580#line 498 "rx-decode.opc"
c7927a3c
NC		 4581 int rsrc AU = op[1] & 0x0f;
4582 if (trace)
4583 {
4584 printf ("\033[33m%s\033[0m %02x %02x\n",
4585 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4586 op[0], op[1]);
4587 printf (" im = 0x%x,", im);
4588 printf (" rsrc = 0x%x\n", rsrc);
4589 }
4590 SYNTAX("cmp #%2, %1%S1");
78e98aab 4591#line 498 "rx-decode.opc"
3cf79a01 4592 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
c7927a3c
NC		 4593
4594 }
4595 break;
4596 case 0x10:
4597 op_semantics_32:
4598 {
4599 /** 0111 01im 0001rdst mul #%1, %0 */
78e98aab 4600#line 582 "rx-decode.opc"
c7927a3c 4601 int im AU = op[0] & 0x03;
78e98aab 4602#line 582 "rx-decode.opc"
c7927a3c
NC		 4603 int rdst AU = op[1] & 0x0f;
4604 if (trace)
4605 {
4606 printf ("\033[33m%s\033[0m %02x %02x\n",
4607 "/** 0111 01im 0001rdst mul #%1, %0 */",
4608 op[0], op[1]);
4609 printf (" im = 0x%x,", im);
4610 printf (" rdst = 0x%x\n", rdst);
4611 }
4612 SYNTAX("mul #%1, %0");
78e98aab 4613#line 582 "rx-decode.opc"
3cf79a01 4614 ID(mul); DR(rdst); SC(IMMex(im)); F_____;
c7927a3c
NC		 4615
4616 }
4617 break;
4618 case 0x20:
4619 op_semantics_33:
4620 {
4621 /** 0111 01im 0010 rdst and #%1, %0 */
78e98aab 4622#line 390 "rx-decode.opc"
c7927a3c 4623 int im AU = op[0] & 0x03;
78e98aab 4624#line 390 "rx-decode.opc"
c7927a3c
NC		 4625 int rdst AU = op[1] & 0x0f;
4626 if (trace)
4627 {
4628 printf ("\033[33m%s\033[0m %02x %02x\n",
4629 "/** 0111 01im 0010 rdst and #%1, %0 */",
4630 op[0], op[1]);
4631 printf (" im = 0x%x,", im);
4632 printf (" rdst = 0x%x\n", rdst);
4633 }
4634 SYNTAX("and #%1, %0");
78e98aab 4635#line 390 "rx-decode.opc"
3cf79a01 4636 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
c7927a3c
NC		 4637
4638 }
4639 break;
4640 case 0x30:
4641 op_semantics_34:
4642 {
4643 /** 0111 01im 0011 rdst or #%1, %0 */
78e98aab 4644#line 408 "rx-decode.opc"
c7927a3c 4645 int im AU = op[0] & 0x03;
78e98aab 4646#line 408 "rx-decode.opc"
c7927a3c
NC		 4647 int rdst AU = op[1] & 0x0f;
4648 if (trace)
4649 {
4650 printf ("\033[33m%s\033[0m %02x %02x\n",
4651 "/** 0111 01im 0011 rdst or #%1, %0 */",
4652 op[0], op[1]);
4653 printf (" im = 0x%x,", im);
4654 printf (" rdst = 0x%x\n", rdst);
4655 }
4656 SYNTAX("or #%1, %0");
78e98aab 4657#line 408 "rx-decode.opc"
3cf79a01 4658 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
c7927a3c
NC		 4659
4660 }
4661 break;
4662 default: UNSUPPORTED(); break;
4663 }
4664 break;
4665 case 0x75:
4666 GETBYTE ();
4667 switch (op[1] & 0xff)
4668 {
4669 case 0x00:
4670 case 0x01:
4671 case 0x02:
4672 case 0x03:
4673 case 0x04:
4674 case 0x05:
4675 case 0x06:
4676 case 0x07:
4677 case 0x08:
4678 case 0x09:
4679 case 0x0a:
4680 case 0x0b:
4681 case 0x0c:
4682 case 0x0d:
4683 case 0x0e:
4684 case 0x0f:
4685 goto op_semantics_31;
4686 break;
4687 case 0x10:
4688 case 0x11:
4689 case 0x12:
4690 case 0x13:
4691 case 0x14:
4692 case 0x15:
4693 case 0x16:
4694 case 0x17:
4695 case 0x18:
4696 case 0x19:
4697 case 0x1a:
4698 case 0x1b:
4699 case 0x1c:
4700 case 0x1d:
4701 case 0x1e:
4702 case 0x1f:
4703 goto op_semantics_32;
4704 break;
4705 case 0x20:
4706 case 0x21:
4707 case 0x22:
4708 case 0x23:
4709 case 0x24:
4710 case 0x25:
4711 case 0x26:
4712 case 0x27:
4713 case 0x28:
4714 case 0x29:
4715 case 0x2a:
4716 case 0x2b:
4717 case 0x2c:
4718 case 0x2d:
4719 case 0x2e:
4720 case 0x2f:
4721 goto op_semantics_33;
4722 break;
4723 case 0x30:
4724 case 0x31:
4725 case 0x32:
4726 case 0x33:
4727 case 0x34:
4728 case 0x35:
4729 case 0x36:
4730 case 0x37:
4731 case 0x38:
4732 case 0x39:
4733 case 0x3a:
4734 case 0x3b:
4735 case 0x3c:
4736 case 0x3d:
4737 case 0x3e:
4738 case 0x3f:
4739 goto op_semantics_34;
4740 break;
4741 case 0x40:
4742 case 0x41:
4743 case 0x42:
4744 case 0x43:
4745 case 0x44:
4746 case 0x45:
4747 case 0x46:
4748 case 0x47:
4749 case 0x48:
4750 case 0x49:
4751 case 0x4a:
4752 case 0x4b:
4753 case 0x4c:
4754 case 0x4d:
4755 case 0x4e:
4756 case 0x4f:
4757 {
4758 /** 0111 0101 0100 rdst mov%s #%1, %0 */
f9c7014e 4759#line 262 "rx-decode.opc"
c7927a3c
NC		 4760 int rdst AU = op[1] & 0x0f;
4761 if (trace)
4762 {
4763 printf ("\033[33m%s\033[0m %02x %02x\n",
4764 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4765 op[0], op[1]);
4766 printf (" rdst = 0x%x\n", rdst);
4767 }
4768 SYNTAX("mov%s #%1, %0");
f9c7014e 4769#line 262 "rx-decode.opc"
3cf79a01 4770 ID(mov); DR(rdst); SC(IMM (1)); F_____;
c7927a3c
NC		 4771
4772 }
4773 break;
4774 case 0x50:
4775 case 0x51:
4776 case 0x52:
4777 case 0x53:
4778 case 0x54:
4779 case 0x55:
4780 case 0x56:
4781 case 0x57:
4782 case 0x58:
4783 case 0x59:
4784 case 0x5a:
4785 case 0x5b:
4786 case 0x5c:
4787 case 0x5d:
4788 case 0x5e:
4789 case 0x5f:
4790 {
4791 /** 0111 0101 0101 rsrc cmp #%2, %1 */
78e98aab 4792#line 501 "rx-decode.opc"
c7927a3c
NC		 4793 int rsrc AU = op[1] & 0x0f;
4794 if (trace)
4795 {
4796 printf ("\033[33m%s\033[0m %02x %02x\n",
4797 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4798 op[0], op[1]);
4799 printf (" rsrc = 0x%x\n", rsrc);
4800 }
4801 SYNTAX("cmp #%2, %1");
78e98aab 4802#line 501 "rx-decode.opc"
3cf79a01 4803 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
c7927a3c
NC		 4804
4805 }
4806 break;
4807 case 0x60:
4808 {
4809 /** 0111 0101 0110 0000 int #%1 */
4810 if (trace)
4811 {
4812 printf ("\033[33m%s\033[0m %02x %02x\n",
4813 "/** 0111 0101 0110 0000 int #%1 */",
4814 op[0], op[1]);
4815 }
4816 SYNTAX("int #%1");
78e98aab 4817#line 962 "rx-decode.opc"
c7927a3c
NC		 4818 ID(int); SC(IMM(1));
4819
4820 }
4821 break;
946ef196
DD		 4822 case 0x70:
4823 GETBYTE ();
4824 switch (op[2] & 0xf0)
4825 {
4826 case 0x00:
4827 {
4828 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
78e98aab 4829#line 929 "rx-decode.opc"
946ef196
DD		 4830 int immm AU = op[2] & 0x0f;
4831 if (trace)
4832 {
4833 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4834 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
4835 op[0], op[1], op[2]);
4836 printf (" immm = 0x%x\n", immm);
4837 }
4838 SYNTAX("mvtipl #%1");
78e98aab 4839#line 929 "rx-decode.opc"
946ef196
DD		 4840 ID(mvtipl); SC(immm);
4841
4842 }
4843 break;
4844 default: UNSUPPORTED(); break;
4845 }
4846 break;
c7927a3c
NC		 4847 default: UNSUPPORTED(); break;
4848 }
4849 break;
4850 case 0x76:
4851 GETBYTE ();
4852 switch (op[1] & 0xf0)
4853 {
4854 case 0x00:
4855 goto op_semantics_31;
4856 break;
4857 case 0x10:
4858 goto op_semantics_32;
4859 break;
4860 case 0x20:
4861 goto op_semantics_33;
4862 break;
4863 case 0x30:
4864 goto op_semantics_34;
4865 break;
4866 default: UNSUPPORTED(); break;
4867 }
4868 break;
4869 case 0x77:
4870 GETBYTE ();
4871 switch (op[1] & 0xf0)
4872 {
4873 case 0x00:
4874 goto op_semantics_31;
4875 break;
4876 case 0x10:
4877 goto op_semantics_32;
4878 break;
4879 case 0x20:
4880 goto op_semantics_33;
4881 break;
4882 case 0x30:
4883 goto op_semantics_34;
4884 break;
4885 default: UNSUPPORTED(); break;
4886 }
4887 break;
4888 case 0x78:
4889 GETBYTE ();
4890 switch (op[1] & 0x00)
4891 {
4892 case 0x00:
4893 op_semantics_35:
4894 {
4895 /** 0111 100b ittt rdst bset #%1, %0 */
78e98aab 4896#line 880 "rx-decode.opc"
c7927a3c 4897 int b AU = op[0] & 0x01;
78e98aab 4898#line 880 "rx-decode.opc"
c7927a3c 4899 int ittt AU = (op[1] >> 4) & 0x0f;
78e98aab 4900#line 880 "rx-decode.opc"
c7927a3c
NC		 4901 int rdst AU = op[1] & 0x0f;
4902 if (trace)
4903 {
4904 printf ("\033[33m%s\033[0m %02x %02x\n",
4905 "/** 0111 100b ittt rdst bset #%1, %0 */",
4906 op[0], op[1]);
4907 printf (" b = 0x%x,", b);
4908 printf (" ittt = 0x%x,", ittt);
4909 printf (" rdst = 0x%x\n", rdst);
4910 }
4911 SYNTAX("bset #%1, %0");
78e98aab 4912#line 880 "rx-decode.opc"
3cf79a01 4913 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
c7927a3c
NC		 4914
4915
4916 }
4917 break;
4918 }
4919 break;
4920 case 0x79:
4921 GETBYTE ();
4922 switch (op[1] & 0x00)
4923 {
4924 case 0x00:
4925 goto op_semantics_35;
4926 break;
4927 }
4928 break;
4929 case 0x7a:
4930 GETBYTE ();
4931 switch (op[1] & 0x00)
4932 {
4933 case 0x00:
4934 op_semantics_36:
4935 {
4936 /** 0111 101b ittt rdst bclr #%1, %0 */
78e98aab 4937#line 890 "rx-decode.opc"
c7927a3c 4938 int b AU = op[0] & 0x01;
78e98aab 4939#line 890 "rx-decode.opc"
c7927a3c 4940 int ittt AU = (op[1] >> 4) & 0x0f;
78e98aab 4941#line 890 "rx-decode.opc"
c7927a3c
NC		 4942 int rdst AU = op[1] & 0x0f;
4943 if (trace)
4944 {
4945 printf ("\033[33m%s\033[0m %02x %02x\n",
4946 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4947 op[0], op[1]);
4948 printf (" b = 0x%x,", b);
4949 printf (" ittt = 0x%x,", ittt);
4950 printf (" rdst = 0x%x\n", rdst);
4951 }
4952 SYNTAX("bclr #%1, %0");
78e98aab 4953#line 890 "rx-decode.opc"
3cf79a01 4954 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
c7927a3c
NC		 4955
4956
4957 }
4958 break;
4959 }
4960 break;
4961 case 0x7b:
4962 GETBYTE ();
4963 switch (op[1] & 0x00)
4964 {
4965 case 0x00:
4966 goto op_semantics_36;
4967 break;
4968 }
4969 break;
4970 case 0x7c:
4971 GETBYTE ();
4972 switch (op[1] & 0x00)
4973 {
4974 case 0x00:
4975 op_semantics_37:
4976 {
4977 /** 0111 110b ittt rdst btst #%2, %1 */
78e98aab 4978#line 900 "rx-decode.opc"
c7927a3c 4979 int b AU = op[0] & 0x01;
78e98aab 4980#line 900 "rx-decode.opc"
c7927a3c 4981 int ittt AU = (op[1] >> 4) & 0x0f;
78e98aab 4982#line 900 "rx-decode.opc"
c7927a3c
NC		 4983 int rdst AU = op[1] & 0x0f;
4984 if (trace)
4985 {
4986 printf ("\033[33m%s\033[0m %02x %02x\n",
4987 "/** 0111 110b ittt rdst btst #%2, %1 */",
4988 op[0], op[1]);
4989 printf (" b = 0x%x,", b);
4990 printf (" ittt = 0x%x,", ittt);
4991 printf (" rdst = 0x%x\n", rdst);
4992 }
4993 SYNTAX("btst #%2, %1");
78e98aab 4994#line 900 "rx-decode.opc"
3cf79a01 4995 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
c7927a3c
NC		 4996
4997
4998 }
4999 break;
5000 }
5001 break;
5002 case 0x7d:
5003 GETBYTE ();
5004 switch (op[1] & 0x00)
5005 {
5006 case 0x00:
5007 goto op_semantics_37;
5008 break;
5009 }
5010 break;
5011 case 0x7e:
5012 GETBYTE ();
5013 switch (op[1] & 0xf0)
5014 {
5015 case 0x00:
5016 {
5017 /** 0111 1110 0000 rdst not %0 */
78e98aab 5018#line 435 "rx-decode.opc"
c7927a3c
NC		 5019 int rdst AU = op[1] & 0x0f;
5020 if (trace)
5021 {
5022 printf ("\033[33m%s\033[0m %02x %02x\n",
5023 "/** 0111 1110 0000 rdst not %0 */",
5024 op[0], op[1]);
5025 printf (" rdst = 0x%x\n", rdst);
5026 }
5027 SYNTAX("not %0");
78e98aab 5028#line 435 "rx-decode.opc"
3cf79a01 5029 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
c7927a3c
NC		 5030
5031 }
5032 break;
5033 case 0x10:
5034 {
5035 /** 0111 1110 0001 rdst neg %0 */
78e98aab 5036#line 456 "rx-decode.opc"
c7927a3c
NC		 5037 int rdst AU = op[1] & 0x0f;
5038 if (trace)
5039 {
5040 printf ("\033[33m%s\033[0m %02x %02x\n",
5041 "/** 0111 1110 0001 rdst neg %0 */",
5042 op[0], op[1]);
5043 printf (" rdst = 0x%x\n", rdst);
5044 }
5045 SYNTAX("neg %0");
78e98aab 5046#line 456 "rx-decode.opc"
3cf79a01 5047 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
c7927a3c
NC		 5048
5049 }
5050 break;
5051 case 0x20:
5052 {
5053 /** 0111 1110 0010 rdst abs %0 */
78e98aab 5054#line 538 "rx-decode.opc"
c7927a3c
NC		 5055 int rdst AU = op[1] & 0x0f;
5056 if (trace)
5057 {
5058 printf ("\033[33m%s\033[0m %02x %02x\n",
5059 "/** 0111 1110 0010 rdst abs %0 */",
5060 op[0], op[1]);
5061 printf (" rdst = 0x%x\n", rdst);
5062 }
5063 SYNTAX("abs %0");
78e98aab 5064#line 538 "rx-decode.opc"
3cf79a01 5065 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
c7927a3c
NC		 5066
5067 }
5068 break;
5069 case 0x30:
5070 {
5071 /** 0111 1110 0011 rdst sat %0 */
78e98aab 5072#line 820 "rx-decode.opc"
c7927a3c
NC		 5073 int rdst AU = op[1] & 0x0f;
5074 if (trace)
5075 {
5076 printf ("\033[33m%s\033[0m %02x %02x\n",
5077 "/** 0111 1110 0011 rdst sat %0 */",
5078 op[0], op[1]);
5079 printf (" rdst = 0x%x\n", rdst);
5080 }
5081 SYNTAX("sat %0");
78e98aab 5082#line 820 "rx-decode.opc"
c7927a3c
NC		 5083 ID(sat); DR (rdst);
5084
5085 }
5086 break;
5087 case 0x40:
5088 {
5089 /** 0111 1110 0100 rdst rorc %0 */
78e98aab 5090#line 680 "rx-decode.opc"
c7927a3c
NC		 5091 int rdst AU = op[1] & 0x0f;
5092 if (trace)
5093 {
5094 printf ("\033[33m%s\033[0m %02x %02x\n",
5095 "/** 0111 1110 0100 rdst rorc %0 */",
5096 op[0], op[1]);
5097 printf (" rdst = 0x%x\n", rdst);
5098 }
5099 SYNTAX("rorc %0");
78e98aab 5100#line 680 "rx-decode.opc"
3cf79a01 5101 ID(rorc); DR(rdst); F__SZC;
c7927a3c
NC		 5102
5103 }
5104 break;
5105 case 0x50:
5106 {
5107 /** 0111 1110 0101 rdst rolc %0 */
78e98aab 5108#line 677 "rx-decode.opc"
c7927a3c
NC		 5109 int rdst AU = op[1] & 0x0f;
5110 if (trace)
5111 {
5112 printf ("\033[33m%s\033[0m %02x %02x\n",
5113 "/** 0111 1110 0101 rdst rolc %0 */",
5114 op[0], op[1]);
5115 printf (" rdst = 0x%x\n", rdst);
5116 }
5117 SYNTAX("rolc %0");
78e98aab 5118#line 677 "rx-decode.opc"
3cf79a01 5119 ID(rolc); DR(rdst); F__SZC;
c7927a3c
NC		 5120
5121 }
5122 break;
5123 case 0x80:
5124 case 0x90:
5125 case 0xa0:
5126 {
5127 /** 0111 1110 10sz rsrc push%s %1 */
78e98aab 5128#line 351 "rx-decode.opc"
c7927a3c 5129 int sz AU = (op[1] >> 4) & 0x03;
78e98aab 5130#line 351 "rx-decode.opc"
c7927a3c
NC		 5131 int rsrc AU = op[1] & 0x0f;
5132 if (trace)
5133 {
5134 printf ("\033[33m%s\033[0m %02x %02x\n",
5135 "/** 0111 1110 10sz rsrc push%s %1 */",
5136 op[0], op[1]);
5137 printf (" sz = 0x%x,", sz);
5138 printf (" rsrc = 0x%x\n", rsrc);
5139 }
5140 SYNTAX("push%s %1");
78e98aab 5141#line 351 "rx-decode.opc"
3cf79a01 5142 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
c7927a3c
NC		 5143
5144 }
5145 break;
5146 case 0xb0:
5147 {
5148 /** 0111 1110 1011 rdst pop %0 */
78e98aab 5149#line 348 "rx-decode.opc"
c7927a3c
NC		 5150 int rdst AU = op[1] & 0x0f;
5151 if (trace)
5152 {
5153 printf ("\033[33m%s\033[0m %02x %02x\n",
5154 "/** 0111 1110 1011 rdst pop %0 */",
5155 op[0], op[1]);
5156 printf (" rdst = 0x%x\n", rdst);
5157 }
5158 SYNTAX("pop %0");
78e98aab 5159#line 348 "rx-decode.opc"
3cf79a01 5160 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
c7927a3c
NC		 5161
5162 }
5163 break;
5164 case 0xc0:
5165 case 0xd0:
5166 {
5167 /** 0111 1110 110 crsrc pushc %1 */
78e98aab 5168#line 935 "rx-decode.opc"
c7927a3c
NC		 5169 int crsrc AU = op[1] & 0x1f;
5170 if (trace)
5171 {
5172 printf ("\033[33m%s\033[0m %02x %02x\n",
5173 "/** 0111 1110 110 crsrc pushc %1 */",
5174 op[0], op[1]);
5175 printf (" crsrc = 0x%x\n", crsrc);
5176 }
5177 SYNTAX("pushc %1");
78e98aab 5178#line 935 "rx-decode.opc"
c7927a3c
NC		 5179 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5180
5181 }
5182 break;
5183 case 0xe0:
5184 case 0xf0:
5185 {
5186 /** 0111 1110 111 crdst popc %0 */
78e98aab 5187#line 932 "rx-decode.opc"
c7927a3c
NC		 5188 int crdst AU = op[1] & 0x1f;
5189 if (trace)
5190 {
5191 printf ("\033[33m%s\033[0m %02x %02x\n",
5192 "/** 0111 1110 111 crdst popc %0 */",
5193 op[0], op[1]);
5194 printf (" crdst = 0x%x\n", crdst);
5195 }
5196 SYNTAX("popc %0");
78e98aab 5197#line 932 "rx-decode.opc"
c7927a3c
NC		 5198 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5199
5200 }
5201 break;
5202 default: UNSUPPORTED(); break;
5203 }
5204 break;
5205 case 0x7f:
5206 GETBYTE ();
5207 switch (op[1] & 0xff)
5208 {
5209 case 0x00:
5210 case 0x01:
5211 case 0x02:
5212 case 0x03:
5213 case 0x04:
5214 case 0x05:
5215 case 0x06:
5216 case 0x07:
5217 case 0x08:
5218 case 0x09:
5219 case 0x0a:
5220 case 0x0b:
5221 case 0x0c:
5222 case 0x0d:
5223 case 0x0e:
5224 case 0x0f:
5225 {
5226 /** 0111 1111 0000 rsrc jmp %0 */
78e98aab 5227#line 730 "rx-decode.opc"
c7927a3c
NC		 5228 int rsrc AU = op[1] & 0x0f;
5229 if (trace)
5230 {
5231 printf ("\033[33m%s\033[0m %02x %02x\n",
5232 "/** 0111 1111 0000 rsrc jmp %0 */",
5233 op[0], op[1]);
5234 printf (" rsrc = 0x%x\n", rsrc);
5235 }
5236 SYNTAX("jmp %0");
78e98aab 5237#line 730 "rx-decode.opc"
f9c7014e 5238 ID(branch); DR(rsrc);
c7927a3c
NC		 5239
5240 }
5241 break;
5242 case 0x10:
5243 case 0x11:
5244 case 0x12:
5245 case 0x13:
5246 case 0x14:
5247 case 0x15:
5248 case 0x16:
5249 case 0x17:
5250 case 0x18:
5251 case 0x19:
5252 case 0x1a:
5253 case 0x1b:
5254 case 0x1c:
5255 case 0x1d:
5256 case 0x1e:
5257 case 0x1f:
5258 {
5259 /** 0111 1111 0001 rsrc jsr %0 */
78e98aab 5260#line 733 "rx-decode.opc"
c7927a3c
NC		 5261 int rsrc AU = op[1] & 0x0f;
5262 if (trace)
5263 {
5264 printf ("\033[33m%s\033[0m %02x %02x\n",
5265 "/** 0111 1111 0001 rsrc jsr %0 */",
5266 op[0], op[1]);
5267 printf (" rsrc = 0x%x\n", rsrc);
5268 }
5269 SYNTAX("jsr %0");
78e98aab 5270#line 733 "rx-decode.opc"
c7927a3c
NC		 5271 ID(jsr); DR(rsrc);
5272
5273 }
5274 break;
5275 case 0x40:
5276 case 0x41:
5277 case 0x42:
5278 case 0x43:
5279 case 0x44:
5280 case 0x45:
5281 case 0x46:
5282 case 0x47:
5283 case 0x48:
5284 case 0x49:
5285 case 0x4a:
5286 case 0x4b:
5287 case 0x4c:
5288 case 0x4d:
5289 case 0x4e:
5290 case 0x4f:
5291 {
5292 /** 0111 1111 0100 rsrc bra.l %0 */
78e98aab 5293#line 726 "rx-decode.opc"
c7927a3c
NC		 5294 int rsrc AU = op[1] & 0x0f;
5295 if (trace)
5296 {
5297 printf ("\033[33m%s\033[0m %02x %02x\n",
5298 "/** 0111 1111 0100 rsrc bra.l %0 */",
5299 op[0], op[1]);
5300 printf (" rsrc = 0x%x\n", rsrc);
5301 }
5302 SYNTAX("bra.l %0");
78e98aab 5303#line 726 "rx-decode.opc"
f9c7014e 5304 ID(branchrel); DR(rsrc);
c7927a3c
NC		 5305
5306
5307 }
5308 break;
5309 case 0x50:
5310 case 0x51:
5311 case 0x52:
5312 case 0x53:
5313 case 0x54:
5314 case 0x55:
5315 case 0x56:
5316 case 0x57:
5317 case 0x58:
5318 case 0x59:
5319 case 0x5a:
5320 case 0x5b:
5321 case 0x5c:
5322 case 0x5d:
5323 case 0x5e:
5324 case 0x5f:
5325 {
5326 /** 0111 1111 0101 rsrc bsr.l %0 */
78e98aab 5327#line 742 "rx-decode.opc"
c7927a3c
NC		 5328 int rsrc AU = op[1] & 0x0f;
5329 if (trace)
5330 {
5331 printf ("\033[33m%s\033[0m %02x %02x\n",
5332 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5333 op[0], op[1]);
5334 printf (" rsrc = 0x%x\n", rsrc);
5335 }
5336 SYNTAX("bsr.l %0");
78e98aab 5337#line 742 "rx-decode.opc"
c7927a3c
NC		 5338 ID(jsrrel); DR(rsrc);
5339
5340 }
5341 break;
5342 case 0x80:
5343 case 0x81:
5344 case 0x82:
5345 {
5346 /** 0111 1111 1000 00sz suntil%s */
78e98aab 5347#line 766 "rx-decode.opc"
c7927a3c
NC		 5348 int sz AU = op[1] & 0x03;
5349 if (trace)
5350 {
5351 printf ("\033[33m%s\033[0m %02x %02x\n",
5352 "/** 0111 1111 1000 00sz suntil%s */",
5353 op[0], op[1]);
5354 printf (" sz = 0x%x\n", sz);
5355 }
5356 SYNTAX("suntil%s");
78e98aab 5357#line 766 "rx-decode.opc"
3cf79a01 5358 ID(suntil); BWL(sz); F___ZC;
c7927a3c
NC		 5359
5360 }
5361 break;
5362 case 0x83:
5363 {
5364 /** 0111 1111 1000 0011 scmpu */
5365 if (trace)
5366 {
5367 printf ("\033[33m%s\033[0m %02x %02x\n",
5368 "/** 0111 1111 1000 0011 scmpu */",
5369 op[0], op[1]);
5370 }
5371 SYNTAX("scmpu");
78e98aab 5372#line 757 "rx-decode.opc"
3cf79a01 5373 ID(scmpu); F___ZC;
c7927a3c
NC		 5374
5375 }
5376 break;
5377 case 0x84:
5378 case 0x85:
5379 case 0x86:
5380 {
5381 /** 0111 1111 1000 01sz swhile%s */
78e98aab 5382#line 769 "rx-decode.opc"
c7927a3c
NC		 5383 int sz AU = op[1] & 0x03;
5384 if (trace)
5385 {
5386 printf ("\033[33m%s\033[0m %02x %02x\n",
5387 "/** 0111 1111 1000 01sz swhile%s */",
5388 op[0], op[1]);
5389 printf (" sz = 0x%x\n", sz);
5390 }
5391 SYNTAX("swhile%s");
78e98aab 5392#line 769 "rx-decode.opc"
3cf79a01 5393 ID(swhile); BWL(sz); F___ZC;
c7927a3c
NC		 5394
5395 }
5396 break;
5397 case 0x87:
5398 {
5399 /** 0111 1111 1000 0111 smovu */
5400 if (trace)
5401 {
5402 printf ("\033[33m%s\033[0m %02x %02x\n",
5403 "/** 0111 1111 1000 0111 smovu */",
5404 op[0], op[1]);
5405 }
5406 SYNTAX("smovu");
78e98aab 5407#line 760 "rx-decode.opc"
c7927a3c
NC		 5408 ID(smovu);
5409
5410 }
5411 break;
5412 case 0x88:
5413 case 0x89:
5414 case 0x8a:
5415 {
5416 /** 0111 1111 1000 10sz sstr%s */
78e98aab 5417#line 775 "rx-decode.opc"
c7927a3c
NC		 5418 int sz AU = op[1] & 0x03;
5419 if (trace)
5420 {
5421 printf ("\033[33m%s\033[0m %02x %02x\n",
5422 "/** 0111 1111 1000 10sz sstr%s */",
5423 op[0], op[1]);
5424 printf (" sz = 0x%x\n", sz);
5425 }
5426 SYNTAX("sstr%s");
78e98aab 5427#line 775 "rx-decode.opc"
c7927a3c
NC		 5428 ID(sstr); BWL(sz);
5429
5430 /*----------------------------------------------------------------------*/
5431 /* RMPA */
5432
5433 }
5434 break;
5435 case 0x8b:
5436 {
5437 /** 0111 1111 1000 1011 smovb */
5438 if (trace)
5439 {
5440 printf ("\033[33m%s\033[0m %02x %02x\n",
5441 "/** 0111 1111 1000 1011 smovb */",
5442 op[0], op[1]);
5443 }
5444 SYNTAX("smovb");
78e98aab 5445#line 763 "rx-decode.opc"
c7927a3c
NC		 5446 ID(smovb);
5447
5448 }
5449 break;
5450 case 0x8c:
5451 case 0x8d:
5452 case 0x8e:
5453 {
5454 /** 0111 1111 1000 11sz rmpa%s */
78e98aab 5455#line 781 "rx-decode.opc"
c7927a3c
NC		 5456 int sz AU = op[1] & 0x03;
5457 if (trace)
5458 {
5459 printf ("\033[33m%s\033[0m %02x %02x\n",
5460 "/** 0111 1111 1000 11sz rmpa%s */",
5461 op[0], op[1]);
5462 printf (" sz = 0x%x\n", sz);
5463 }
5464 SYNTAX("rmpa%s");
78e98aab 5465#line 781 "rx-decode.opc"
3cf79a01 5466 ID(rmpa); BWL(sz); F_OS__;
c7927a3c
NC		 5467
5468 /*----------------------------------------------------------------------*/
5469 /* HI/LO stuff */
5470
5471 }
5472 break;
5473 case 0x8f:
5474 {
5475 /** 0111 1111 1000 1111 smovf */
5476 if (trace)
5477 {
5478 printf ("\033[33m%s\033[0m %02x %02x\n",
5479 "/** 0111 1111 1000 1111 smovf */",
5480 op[0], op[1]);
5481 }
5482 SYNTAX("smovf");
78e98aab 5483#line 772 "rx-decode.opc"
c7927a3c
NC		 5484 ID(smovf);
5485
5486 }
5487 break;
5488 case 0x93:
5489 {
5490 /** 0111 1111 1001 0011 satr */
5491 if (trace)
5492 {
5493 printf ("\033[33m%s\033[0m %02x %02x\n",
5494 "/** 0111 1111 1001 0011 satr */",
5495 op[0], op[1]);
5496 }
5497 SYNTAX("satr");
78e98aab 5498#line 823 "rx-decode.opc"
c7927a3c
NC		 5499 ID(satr);
5500
5501 /*----------------------------------------------------------------------*/
5502 /* FLOAT */
5503
5504 }
5505 break;
5506 case 0x94:
5507 {
5508 /** 0111 1111 1001 0100 rtfi */
5509 if (trace)
5510 {
5511 printf ("\033[33m%s\033[0m %02x %02x\n",
5512 "/** 0111 1111 1001 0100 rtfi */",
5513 op[0], op[1]);
5514 }
5515 SYNTAX("rtfi");
78e98aab 5516#line 950 "rx-decode.opc"
c7927a3c
NC		 5517 ID(rtfi);
5518
5519 }
5520 break;
5521 case 0x95:
5522 {
5523 /** 0111 1111 1001 0101 rte */
5524 if (trace)
5525 {
5526 printf ("\033[33m%s\033[0m %02x %02x\n",
5527 "/** 0111 1111 1001 0101 rte */",
5528 op[0], op[1]);
5529 }
5530 SYNTAX("rte");
78e98aab 5531#line 953 "rx-decode.opc"
c7927a3c
NC		 5532 ID(rte);
5533
5534 }
5535 break;
5536 case 0x96:
5537 {
5538 /** 0111 1111 1001 0110 wait */
5539 if (trace)
5540 {
5541 printf ("\033[33m%s\033[0m %02x %02x\n",
5542 "/** 0111 1111 1001 0110 wait */",
5543 op[0], op[1]);
5544 }
5545 SYNTAX("wait");
78e98aab 5546#line 965 "rx-decode.opc"
c7927a3c
NC		 5547 ID(wait);
5548
5549 /*----------------------------------------------------------------------*/
5550 /* SCcnd */
5551
5552 }
5553 break;
5554 case 0xa0:
5555 case 0xa1:
5556 case 0xa2:
5557 case 0xa3:
5558 case 0xa4:
5559 case 0xa5:
5560 case 0xa6:
5561 case 0xa7:
5562 case 0xa8:
5563 case 0xa9:
5564 case 0xaa:
5565 case 0xab:
5566 case 0xac:
5567 case 0xad:
5568 case 0xae:
5569 case 0xaf:
5570 {
5571 /** 0111 1111 1010 rdst setpsw %0 */
78e98aab 5572#line 926 "rx-decode.opc"
c7927a3c
NC		 5573 int rdst AU = op[1] & 0x0f;
5574 if (trace)
5575 {
5576 printf ("\033[33m%s\033[0m %02x %02x\n",
5577 "/** 0111 1111 1010 rdst setpsw %0 */",
5578 op[0], op[1]);
5579 printf (" rdst = 0x%x\n", rdst);
5580 }
5581 SYNTAX("setpsw %0");
78e98aab 5582#line 926 "rx-decode.opc"
c7927a3c
NC		 5583 ID(setpsw); DF(rdst);
5584
5585 }
5586 break;
5587 case 0xb0:
5588 case 0xb1:
5589 case 0xb2:
5590 case 0xb3:
5591 case 0xb4:
5592 case 0xb5:
5593 case 0xb6:
5594 case 0xb7:
5595 case 0xb8:
5596 case 0xb9:
5597 case 0xba:
5598 case 0xbb:
5599 case 0xbc:
5600 case 0xbd:
5601 case 0xbe:
5602 case 0xbf:
5603 {
5604 /** 0111 1111 1011 rdst clrpsw %0 */
78e98aab 5605#line 923 "rx-decode.opc"
c7927a3c
NC		 5606 int rdst AU = op[1] & 0x0f;
5607 if (trace)
5608 {
5609 printf ("\033[33m%s\033[0m %02x %02x\n",
5610 "/** 0111 1111 1011 rdst clrpsw %0 */",
5611 op[0], op[1]);
5612 printf (" rdst = 0x%x\n", rdst);
5613 }
5614 SYNTAX("clrpsw %0");
78e98aab 5615#line 923 "rx-decode.opc"
c7927a3c
NC		 5616 ID(clrpsw); DF(rdst);
5617
5618 }
5619 break;
5620 default: UNSUPPORTED(); break;
5621 }
5622 break;
5623 case 0x80:
5624 GETBYTE ();
5625 switch (op[1] & 0x00)
5626 {
5627 case 0x00:
5628 op_semantics_38:
5629 {
5630 /** 10sz 0dsp a dst b src mov%s %1, %0 */
78e98aab 5631#line 309 "rx-decode.opc"
c7927a3c 5632 int sz AU = (op[0] >> 4) & 0x03;
78e98aab 5633#line 309 "rx-decode.opc"
c7927a3c 5634 int dsp AU = op[0] & 0x07;
78e98aab 5635#line 309 "rx-decode.opc"
c7927a3c 5636 int a AU = (op[1] >> 7) & 0x01;
78e98aab 5637#line 309 "rx-decode.opc"
c7927a3c 5638 int dst AU = (op[1] >> 4) & 0x07;
78e98aab 5639#line 309 "rx-decode.opc"
c7927a3c 5640 int b AU = (op[1] >> 3) & 0x01;
78e98aab 5641#line 309 "rx-decode.opc"
c7927a3c
NC		 5642 int src AU = op[1] & 0x07;
5643 if (trace)
5644 {
5645 printf ("\033[33m%s\033[0m %02x %02x\n",
5646 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5647 op[0], op[1]);
5648 printf (" sz = 0x%x,", sz);
5649 printf (" dsp = 0x%x,", dsp);
5650 printf (" a = 0x%x,", a);
5651 printf (" dst = 0x%x,", dst);
5652 printf (" b = 0x%x,", b);
5653 printf (" src = 0x%x\n", src);
5654 }
5655 SYNTAX("mov%s %1, %0");
78e98aab 5656#line 309 "rx-decode.opc"
3cf79a01 5657 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
c7927a3c
NC		 5658
5659 }
5660 break;
5661 }
5662 break;
5663 case 0x81:
5664 GETBYTE ();
5665 switch (op[1] & 0x00)
5666 {
5667 case 0x00:
5668 goto op_semantics_38;
5669 break;
5670 }
5671 break;
5672 case 0x82:
5673 GETBYTE ();
5674 switch (op[1] & 0x00)
5675 {
5676 case 0x00:
5677 goto op_semantics_38;
5678 break;
5679 }
5680 break;
5681 case 0x83:
5682 GETBYTE ();
5683 switch (op[1] & 0x00)
5684 {
5685 case 0x00:
5686 goto op_semantics_38;
5687 break;
5688 }
5689 break;
5690 case 0x84:
5691 GETBYTE ();
5692 switch (op[1] & 0x00)
5693 {
5694 case 0x00:
5695 goto op_semantics_38;
5696 break;
5697 }
5698 break;
5699 case 0x85:
5700 GETBYTE ();
5701 switch (op[1] & 0x00)
5702 {
5703 case 0x00:
5704 goto op_semantics_38;
5705 break;
5706 }
5707 break;
5708 case 0x86:
5709 GETBYTE ();
5710 switch (op[1] & 0x00)
5711 {
5712 case 0x00:
5713 goto op_semantics_38;
5714 break;
5715 }
5716 break;
5717 case 0x87:
5718 GETBYTE ();
5719 switch (op[1] & 0x00)
5720 {
5721 case 0x00:
5722 goto op_semantics_38;
5723 break;
5724 }
5725 break;
5726 case 0x88:
5727 GETBYTE ();
5728 switch (op[1] & 0x00)
5729 {
5730 case 0x00:
5731 op_semantics_39:
5732 {
5733 /** 10sz 1dsp a src b dst mov%s %1, %0 */
78e98aab 5734#line 306 "rx-decode.opc"
c7927a3c 5735 int sz AU = (op[0] >> 4) & 0x03;
78e98aab 5736#line 306 "rx-decode.opc"
c7927a3c 5737 int dsp AU = op[0] & 0x07;
78e98aab 5738#line 306 "rx-decode.opc"
c7927a3c 5739 int a AU = (op[1] >> 7) & 0x01;
78e98aab 5740#line 306 "rx-decode.opc"
c7927a3c 5741 int src AU = (op[1] >> 4) & 0x07;
78e98aab 5742#line 306 "rx-decode.opc"
c7927a3c 5743 int b AU = (op[1] >> 3) & 0x01;
78e98aab 5744#line 306 "rx-decode.opc"
c7927a3c
NC		 5745 int dst AU = op[1] & 0x07;
5746 if (trace)
5747 {
5748 printf ("\033[33m%s\033[0m %02x %02x\n",
5749 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5750 op[0], op[1]);
5751 printf (" sz = 0x%x,", sz);
5752 printf (" dsp = 0x%x,", dsp);
5753 printf (" a = 0x%x,", a);
5754 printf (" src = 0x%x,", src);
5755 printf (" b = 0x%x,", b);
5756 printf (" dst = 0x%x\n", dst);
5757 }
5758 SYNTAX("mov%s %1, %0");
78e98aab 5759#line 306 "rx-decode.opc"
3cf79a01 5760 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
c7927a3c
NC		 5761
5762 }
5763 break;
5764 }
5765 break;
5766 case 0x89:
5767 GETBYTE ();
5768 switch (op[1] & 0x00)
5769 {
5770 case 0x00:
5771 goto op_semantics_39;
5772 break;
5773 }
5774 break;
5775 case 0x8a:
5776 GETBYTE ();
5777 switch (op[1] & 0x00)
5778 {
5779 case 0x00:
5780 goto op_semantics_39;
5781 break;
5782 }
5783 break;
5784 case 0x8b:
5785 GETBYTE ();
5786 switch (op[1] & 0x00)
5787 {
5788 case 0x00:
5789 goto op_semantics_39;
5790 break;
5791 }
5792 break;
5793 case 0x8c:
5794 GETBYTE ();
5795 switch (op[1] & 0x00)
5796 {
5797 case 0x00:
5798 goto op_semantics_39;
5799 break;
5800 }
5801 break;
5802 case 0x8d:
5803 GETBYTE ();
5804 switch (op[1] & 0x00)
5805 {
5806 case 0x00:
5807 goto op_semantics_39;
5808 break;
5809 }
5810 break;
5811 case 0x8e:
5812 GETBYTE ();
5813 switch (op[1] & 0x00)
5814 {
5815 case 0x00:
5816 goto op_semantics_39;
5817 break;
5818 }
5819 break;
5820 case 0x8f:
5821 GETBYTE ();
5822 switch (op[1] & 0x00)
5823 {
5824 case 0x00:
5825 goto op_semantics_39;
5826 break;
5827 }
5828 break;
5829 case 0x90:
5830 GETBYTE ();
5831 switch (op[1] & 0x00)
5832 {
5833 case 0x00:
5834 goto op_semantics_38;
5835 break;
5836 }
5837 break;
5838 case 0x91:
5839 GETBYTE ();
5840 switch (op[1] & 0x00)
5841 {
5842 case 0x00:
5843 goto op_semantics_38;
5844 break;
5845 }
5846 break;
5847 case 0x92:
5848 GETBYTE ();
5849 switch (op[1] & 0x00)
5850 {
5851 case 0x00:
5852 goto op_semantics_38;
5853 break;
5854 }
5855 break;
5856 case 0x93:
5857 GETBYTE ();
5858 switch (op[1] & 0x00)
5859 {
5860 case 0x00:
5861 goto op_semantics_38;
5862 break;
5863 }
5864 break;
5865 case 0x94:
5866 GETBYTE ();
5867 switch (op[1] & 0x00)
5868 {
5869 case 0x00:
5870 goto op_semantics_38;
5871 break;
5872 }
5873 break;
5874 case 0x95:
5875 GETBYTE ();
5876 switch (op[1] & 0x00)
5877 {
5878 case 0x00:
5879 goto op_semantics_38;
5880 break;
5881 }
5882 break;
5883 case 0x96:
5884 GETBYTE ();
5885 switch (op[1] & 0x00)
5886 {
5887 case 0x00:
5888 goto op_semantics_38;
5889 break;
5890 }
5891 break;
5892 case 0x97:
5893 GETBYTE ();
5894 switch (op[1] & 0x00)
5895 {
5896 case 0x00:
5897 goto op_semantics_38;
5898 break;
5899 }
5900 break;
5901 case 0x98:
5902 GETBYTE ();
5903 switch (op[1] & 0x00)
5904 {
5905 case 0x00:
5906 goto op_semantics_39;
5907 break;
5908 }
5909 break;
5910 case 0x99:
5911 GETBYTE ();
5912 switch (op[1] & 0x00)
5913 {
5914 case 0x00:
5915 goto op_semantics_39;
5916 break;
5917 }
5918 break;
5919 case 0x9a:
5920 GETBYTE ();
5921 switch (op[1] & 0x00)
5922 {
5923 case 0x00:
5924 goto op_semantics_39;
5925 break;
5926 }
5927 break;
5928 case 0x9b:
5929 GETBYTE ();
5930 switch (op[1] & 0x00)
5931 {
5932 case 0x00:
5933 goto op_semantics_39;
5934 break;
5935 }
5936 break;
5937 case 0x9c:
5938 GETBYTE ();
5939 switch (op[1] & 0x00)
5940 {
5941 case 0x00:
5942 goto op_semantics_39;
5943 break;
5944 }
5945 break;
5946 case 0x9d:
5947 GETBYTE ();
5948 switch (op[1] & 0x00)
5949 {
5950 case 0x00:
5951 goto op_semantics_39;
5952 break;
5953 }
5954 break;
5955 case 0x9e:
5956 GETBYTE ();
5957 switch (op[1] & 0x00)
5958 {
5959 case 0x00:
5960 goto op_semantics_39;
5961 break;
5962 }
5963 break;
5964 case 0x9f:
5965 GETBYTE ();
5966 switch (op[1] & 0x00)
5967 {
5968 case 0x00:
5969 goto op_semantics_39;
5970 break;
5971 }
5972 break;
5973 case 0xa0:
5974 GETBYTE ();
5975 switch (op[1] & 0x00)
5976 {
5977 case 0x00:
5978 goto op_semantics_38;
5979 break;
5980 }
5981 break;
5982 case 0xa1:
5983 GETBYTE ();
5984 switch (op[1] & 0x00)
5985 {
5986 case 0x00:
5987 goto op_semantics_38;
5988 break;
5989 }
5990 break;
5991 case 0xa2:
5992 GETBYTE ();
5993 switch (op[1] & 0x00)
5994 {
5995 case 0x00:
5996 goto op_semantics_38;
5997 break;
5998 }
5999 break;
6000 case 0xa3:
6001 GETBYTE ();
6002 switch (op[1] & 0x00)
6003 {
6004 case 0x00:
6005 goto op_semantics_38;
6006 break;
6007 }
6008 break;
6009 case 0xa4:
6010 GETBYTE ();
6011 switch (op[1] & 0x00)
6012 {
6013 case 0x00:
6014 goto op_semantics_38;
6015 break;
6016 }
6017 break;
6018 case 0xa5:
6019 GETBYTE ();
6020 switch (op[1] & 0x00)
6021 {
6022 case 0x00:
6023 goto op_semantics_38;
6024 break;
6025 }
6026 break;
6027 case 0xa6:
6028 GETBYTE ();
6029 switch (op[1] & 0x00)
6030 {
6031 case 0x00:
6032 goto op_semantics_38;
6033 break;
6034 }
6035 break;
6036 case 0xa7:
6037 GETBYTE ();
6038 switch (op[1] & 0x00)
6039 {
6040 case 0x00:
6041 goto op_semantics_38;
6042 break;
6043 }
6044 break;
6045 case 0xa8:
6046 GETBYTE ();
6047 switch (op[1] & 0x00)
6048 {
6049 case 0x00:
6050 goto op_semantics_39;
6051 break;
6052 }
6053 break;
6054 case 0xa9:
6055 GETBYTE ();
6056 switch (op[1] & 0x00)
6057 {
6058 case 0x00:
6059 goto op_semantics_39;
6060 break;
6061 }
6062 break;
6063 case 0xaa:
6064 GETBYTE ();
6065 switch (op[1] & 0x00)
6066 {
6067 case 0x00:
6068 goto op_semantics_39;
6069 break;
6070 }
6071 break;
6072 case 0xab:
6073 GETBYTE ();
6074 switch (op[1] & 0x00)
6075 {
6076 case 0x00:
6077 goto op_semantics_39;
6078 break;
6079 }
6080 break;
6081 case 0xac:
6082 GETBYTE ();
6083 switch (op[1] & 0x00)
6084 {
6085 case 0x00:
6086 goto op_semantics_39;
6087 break;
6088 }
6089 break;
6090 case 0xad:
6091 GETBYTE ();
6092 switch (op[1] & 0x00)
6093 {
6094 case 0x00:
6095 goto op_semantics_39;
6096 break;
6097 }
6098 break;
6099 case 0xae:
6100 GETBYTE ();
6101 switch (op[1] & 0x00)
6102 {
6103 case 0x00:
6104 goto op_semantics_39;
6105 break;
6106 }
6107 break;
6108 case 0xaf:
6109 GETBYTE ();
6110 switch (op[1] & 0x00)
6111 {
6112 case 0x00:
6113 goto op_semantics_39;
6114 break;
6115 }
6116 break;
6117 case 0xb0:
6118 GETBYTE ();
6119 switch (op[1] & 0x00)
6120 {
6121 case 0x00:
6122 op_semantics_40:
6123 {
6124 /** 1011 w dsp a src b dst movu%s %1, %0 */
78e98aab 6125#line 329 "rx-decode.opc"
c7927a3c 6126 int w AU = (op[0] >> 3) & 0x01;
78e98aab 6127#line 329 "rx-decode.opc"
c7927a3c 6128 int dsp AU = op[0] & 0x07;
78e98aab 6129#line 329 "rx-decode.opc"
c7927a3c 6130 int a AU = (op[1] >> 7) & 0x01;
78e98aab 6131#line 329 "rx-decode.opc"
c7927a3c 6132 int src AU = (op[1] >> 4) & 0x07;
78e98aab 6133#line 329 "rx-decode.opc"
c7927a3c 6134 int b AU = (op[1] >> 3) & 0x01;
78e98aab 6135#line 329 "rx-decode.opc"
c7927a3c
NC		 6136 int dst AU = op[1] & 0x07;
6137 if (trace)
6138 {
6139 printf ("\033[33m%s\033[0m %02x %02x\n",
6140 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6141 op[0], op[1]);
6142 printf (" w = 0x%x,", w);
6143 printf (" dsp = 0x%x,", dsp);
6144 printf (" a = 0x%x,", a);
6145 printf (" src = 0x%x,", src);
6146 printf (" b = 0x%x,", b);
6147 printf (" dst = 0x%x\n", dst);
6148 }
6149 SYNTAX("movu%s %1, %0");
78e98aab 6150#line 329 "rx-decode.opc"
3cf79a01 6151 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
c7927a3c
NC		 6152
6153 }
6154 break;
6155 }
6156 break;
6157 case 0xb1:
6158 GETBYTE ();
6159 switch (op[1] & 0x00)
6160 {
6161 case 0x00:
6162 goto op_semantics_40;
6163 break;
6164 }
6165 break;
6166 case 0xb2:
6167 GETBYTE ();
6168 switch (op[1] & 0x00)
6169 {
6170 case 0x00:
6171 goto op_semantics_40;
6172 break;
6173 }
6174 break;
6175 case 0xb3:
6176 GETBYTE ();
6177 switch (op[1] & 0x00)
6178 {
6179 case 0x00:
6180 goto op_semantics_40;
6181 break;
6182 }
6183 break;
6184 case 0xb4:
6185 GETBYTE ();
6186 switch (op[1] & 0x00)
6187 {
6188 case 0x00:
6189 goto op_semantics_40;
6190 break;
6191 }
6192 break;
6193 case 0xb5:
6194 GETBYTE ();
6195 switch (op[1] & 0x00)
6196 {
6197 case 0x00:
6198 goto op_semantics_40;
6199 break;
6200 }
6201 break;
6202 case 0xb6:
6203 GETBYTE ();
6204 switch (op[1] & 0x00)
6205 {
6206 case 0x00:
6207 goto op_semantics_40;
6208 break;
6209 }
6210 break;
6211 case 0xb7:
6212 GETBYTE ();
6213 switch (op[1] & 0x00)
6214 {
6215 case 0x00:
6216 goto op_semantics_40;
6217 break;
6218 }
6219 break;
6220 case 0xb8:
6221 GETBYTE ();
6222 switch (op[1] & 0x00)
6223 {
6224 case 0x00:
6225 goto op_semantics_40;
6226 break;
6227 }
6228 break;
6229 case 0xb9:
6230 GETBYTE ();
6231 switch (op[1] & 0x00)
6232 {
6233 case 0x00:
6234 goto op_semantics_40;
6235 break;
6236 }
6237 break;
6238 case 0xba:
6239 GETBYTE ();
6240 switch (op[1] & 0x00)
6241 {
6242 case 0x00:
6243 goto op_semantics_40;
6244 break;
6245 }
6246 break;
6247 case 0xbb:
6248 GETBYTE ();
6249 switch (op[1] & 0x00)
6250 {
6251 case 0x00:
6252 goto op_semantics_40;
6253 break;
6254 }
6255 break;
6256 case 0xbc:
6257 GETBYTE ();
6258 switch (op[1] & 0x00)
6259 {
6260 case 0x00:
6261 goto op_semantics_40;
6262 break;
6263 }
6264 break;
6265 case 0xbd:
6266 GETBYTE ();
6267 switch (op[1] & 0x00)
6268 {
6269 case 0x00:
6270 goto op_semantics_40;
6271 break;
6272 }
6273 break;
6274 case 0xbe:
6275 GETBYTE ();
6276 switch (op[1] & 0x00)
6277 {
6278 case 0x00:
6279 goto op_semantics_40;
6280 break;
6281 }
6282 break;
6283 case 0xbf:
6284 GETBYTE ();
6285 switch (op[1] & 0x00)
6286 {
6287 case 0x00:
6288 goto op_semantics_40;
6289 break;
6290 }
6291 break;
6292 case 0xc0:
6293 GETBYTE ();
6294 switch (op[1] & 0x00)
6295 {
6296 case 0x00:
6297 op_semantics_41:
6298 {
6299 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
78e98aab 6300#line 287 "rx-decode.opc"
c7927a3c 6301 int sz AU = (op[0] >> 4) & 0x03;
78e98aab 6302#line 287 "rx-decode.opc"
c7927a3c 6303 int sd AU = (op[0] >> 2) & 0x03;
78e98aab 6304#line 287 "rx-decode.opc"
c7927a3c 6305 int ss AU = op[0] & 0x03;
78e98aab 6306#line 287 "rx-decode.opc"
c7927a3c 6307 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 6308#line 287 "rx-decode.opc"
c7927a3c
NC		 6309 int rdst AU = op[1] & 0x0f;
6310 if (trace)
6311 {
6312 printf ("\033[33m%s\033[0m %02x %02x\n",
6313 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6314 op[0], op[1]);
6315 printf (" sz = 0x%x,", sz);
6316 printf (" sd = 0x%x,", sd);
6317 printf (" ss = 0x%x,", ss);
6318 printf (" rsrc = 0x%x,", rsrc);
6319 printf (" rdst = 0x%x\n", rdst);
6320 }
6321 SYNTAX("mov%s %1, %0");
78e98aab 6322#line 287 "rx-decode.opc"
f9c7014e 6323 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
c7927a3c 6324 {
f9c7014e 6325 ID(nop2);
9887672f 6326 rx->syntax = "nop";
c7927a3c
NC		 6327 }
6328 else
6329 {
f9c7014e
DD		 6330 ID(mov); sBWL(sz); F_____;
6331 if ((ss == 3) && (sd != 3))
6332 {
6333 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6334 }
6335 else
6336 {
6337 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6338 }
c7927a3c
NC		 6339 }
6340
6341 }
6342 break;
6343 }
6344 break;
6345 case 0xc1:
6346 GETBYTE ();
6347 switch (op[1] & 0x00)
6348 {
6349 case 0x00:
6350 goto op_semantics_41;
6351 break;
6352 }
6353 break;
6354 case 0xc2:
6355 GETBYTE ();
6356 switch (op[1] & 0x00)
6357 {
6358 case 0x00:
6359 goto op_semantics_41;
6360 break;
6361 }
6362 break;
6363 case 0xc3:
6364 GETBYTE ();
6365 switch (op[1] & 0x00)
6366 {
6367 case 0x00:
6368 goto op_semantics_41;
6369 break;
6370 }
6371 break;
6372 case 0xc4:
6373 GETBYTE ();
6374 switch (op[1] & 0x00)
6375 {
6376 case 0x00:
6377 goto op_semantics_41;
6378 break;
6379 }
6380 break;
6381 case 0xc5:
6382 GETBYTE ();
6383 switch (op[1] & 0x00)
6384 {
6385 case 0x00:
6386 goto op_semantics_41;
6387 break;
6388 }
6389 break;
6390 case 0xc6:
6391 GETBYTE ();
6392 switch (op[1] & 0x00)
6393 {
6394 case 0x00:
6395 goto op_semantics_41;
6396 break;
6397 }
6398 break;
6399 case 0xc7:
6400 GETBYTE ();
6401 switch (op[1] & 0x00)
6402 {
6403 case 0x00:
6404 goto op_semantics_41;
6405 break;
6406 }
6407 break;
6408 case 0xc8:
6409 GETBYTE ();
6410 switch (op[1] & 0x00)
6411 {
6412 case 0x00:
6413 goto op_semantics_41;
6414 break;
6415 }
6416 break;
6417 case 0xc9:
6418 GETBYTE ();
6419 switch (op[1] & 0x00)
6420 {
6421 case 0x00:
6422 goto op_semantics_41;
6423 break;
6424 }
6425 break;
6426 case 0xca:
6427 GETBYTE ();
6428 switch (op[1] & 0x00)
6429 {
6430 case 0x00:
6431 goto op_semantics_41;
6432 break;
6433 }
6434 break;
6435 case 0xcb:
6436 GETBYTE ();
6437 switch (op[1] & 0x00)
6438 {
6439 case 0x00:
6440 goto op_semantics_41;
6441 break;
6442 }
6443 break;
6444 case 0xcc:
6445 GETBYTE ();
6446 switch (op[1] & 0x00)
6447 {
6448 case 0x00:
6449 goto op_semantics_41;
6450 break;
6451 }
6452 break;
6453 case 0xcd:
6454 GETBYTE ();
6455 switch (op[1] & 0x00)
6456 {
6457 case 0x00:
6458 goto op_semantics_41;
6459 break;
6460 }
6461 break;
6462 case 0xce:
6463 GETBYTE ();
6464 switch (op[1] & 0x00)
6465 {
6466 case 0x00:
6467 goto op_semantics_41;
6468 break;
6469 }
6470 break;
6471 case 0xcf:
6472 GETBYTE ();
6473 switch (op[1] & 0x00)
6474 {
6475 case 0x00:
6476 goto op_semantics_41;
6477 break;
6478 }
6479 break;
6480 case 0xd0:
6481 GETBYTE ();
6482 switch (op[1] & 0x00)
6483 {
6484 case 0x00:
6485 goto op_semantics_41;
6486 break;
6487 }
6488 break;
6489 case 0xd1:
6490 GETBYTE ();
6491 switch (op[1] & 0x00)
6492 {
6493 case 0x00:
6494 goto op_semantics_41;
6495 break;
6496 }
6497 break;
6498 case 0xd2:
6499 GETBYTE ();
6500 switch (op[1] & 0x00)
6501 {
6502 case 0x00:
6503 goto op_semantics_41;
6504 break;
6505 }
6506 break;
6507 case 0xd3:
6508 GETBYTE ();
6509 switch (op[1] & 0x00)
6510 {
6511 case 0x00:
6512 goto op_semantics_41;
6513 break;
6514 }
6515 break;
6516 case 0xd4:
6517 GETBYTE ();
6518 switch (op[1] & 0x00)
6519 {
6520 case 0x00:
6521 goto op_semantics_41;
6522 break;
6523 }
6524 break;
6525 case 0xd5:
6526 GETBYTE ();
6527 switch (op[1] & 0x00)
6528 {
6529 case 0x00:
6530 goto op_semantics_41;
6531 break;
6532 }
6533 break;
6534 case 0xd6:
6535 GETBYTE ();
6536 switch (op[1] & 0x00)
6537 {
6538 case 0x00:
6539 goto op_semantics_41;
6540 break;
6541 }
6542 break;
6543 case 0xd7:
6544 GETBYTE ();
6545 switch (op[1] & 0x00)
6546 {
6547 case 0x00:
6548 goto op_semantics_41;
6549 break;
6550 }
6551 break;
6552 case 0xd8:
6553 GETBYTE ();
6554 switch (op[1] & 0x00)
6555 {
6556 case 0x00:
6557 goto op_semantics_41;
6558 break;
6559 }
6560 break;
6561 case 0xd9:
6562 GETBYTE ();
6563 switch (op[1] & 0x00)
6564 {
6565 case 0x00:
6566 goto op_semantics_41;
6567 break;
6568 }
6569 break;
6570 case 0xda:
6571 GETBYTE ();
6572 switch (op[1] & 0x00)
6573 {
6574 case 0x00:
6575 goto op_semantics_41;
6576 break;
6577 }
6578 break;
6579 case 0xdb:
6580 GETBYTE ();
6581 switch (op[1] & 0x00)
6582 {
6583 case 0x00:
6584 goto op_semantics_41;
6585 break;
6586 }
6587 break;
6588 case 0xdc:
6589 GETBYTE ();
6590 switch (op[1] & 0x00)
6591 {
6592 case 0x00:
6593 goto op_semantics_41;
6594 break;
6595 }
6596 break;
6597 case 0xdd:
6598 GETBYTE ();
6599 switch (op[1] & 0x00)
6600 {
6601 case 0x00:
6602 goto op_semantics_41;
6603 break;
6604 }
6605 break;
6606 case 0xde:
6607 GETBYTE ();
6608 switch (op[1] & 0x00)
6609 {
6610 case 0x00:
6611 goto op_semantics_41;
6612 break;
6613 }
6614 break;
6615 case 0xdf:
6616 GETBYTE ();
6617 switch (op[1] & 0x00)
6618 {
6619 case 0x00:
6620 goto op_semantics_41;
6621 break;
6622 }
6623 break;
6624 case 0xe0:
6625 GETBYTE ();
6626 switch (op[1] & 0x00)
6627 {
6628 case 0x00:
6629 goto op_semantics_41;
6630 break;
6631 }
6632 break;
6633 case 0xe1:
6634 GETBYTE ();
6635 switch (op[1] & 0x00)
6636 {
6637 case 0x00:
6638 goto op_semantics_41;
6639 break;
6640 }
6641 break;
6642 case 0xe2:
6643 GETBYTE ();
6644 switch (op[1] & 0x00)
6645 {
6646 case 0x00:
6647 goto op_semantics_41;
6648 break;
6649 }
6650 break;
6651 case 0xe3:
6652 GETBYTE ();
6653 switch (op[1] & 0x00)
6654 {
6655 case 0x00:
6656 goto op_semantics_41;
6657 break;
6658 }
6659 break;
6660 case 0xe4:
6661 GETBYTE ();
6662 switch (op[1] & 0x00)
6663 {
6664 case 0x00:
6665 goto op_semantics_41;
6666 break;
6667 }
6668 break;
6669 case 0xe5:
6670 GETBYTE ();
6671 switch (op[1] & 0x00)
6672 {
6673 case 0x00:
6674 goto op_semantics_41;
6675 break;
6676 }
6677 break;
6678 case 0xe6:
6679 GETBYTE ();
6680 switch (op[1] & 0x00)
6681 {
6682 case 0x00:
6683 goto op_semantics_41;
6684 break;
6685 }
6686 break;
6687 case 0xe7:
6688 GETBYTE ();
6689 switch (op[1] & 0x00)
6690 {
6691 case 0x00:
6692 goto op_semantics_41;
6693 break;
6694 }
6695 break;
6696 case 0xe8:
6697 GETBYTE ();
6698 switch (op[1] & 0x00)
6699 {
6700 case 0x00:
6701 goto op_semantics_41;
6702 break;
6703 }
6704 break;
6705 case 0xe9:
6706 GETBYTE ();
6707 switch (op[1] & 0x00)
6708 {
6709 case 0x00:
6710 goto op_semantics_41;
6711 break;
6712 }
6713 break;
6714 case 0xea:
6715 GETBYTE ();
6716 switch (op[1] & 0x00)
6717 {
6718 case 0x00:
6719 goto op_semantics_41;
6720 break;
6721 }
6722 break;
6723 case 0xeb:
6724 GETBYTE ();
6725 switch (op[1] & 0x00)
6726 {
6727 case 0x00:
6728 goto op_semantics_41;
6729 break;
6730 }
6731 break;
6732 case 0xec:
6733 GETBYTE ();
6734 switch (op[1] & 0x00)
6735 {
6736 case 0x00:
6737 goto op_semantics_41;
6738 break;
6739 }
6740 break;
6741 case 0xed:
6742 GETBYTE ();
6743 switch (op[1] & 0x00)
6744 {
6745 case 0x00:
6746 goto op_semantics_41;
6747 break;
6748 }
6749 break;
6750 case 0xee:
6751 GETBYTE ();
6752 switch (op[1] & 0x00)
6753 {
6754 case 0x00:
6755 goto op_semantics_41;
6756 break;
6757 }
6758 break;
6759 case 0xef:
6760 GETBYTE ();
6761 switch (op[1] & 0x00)
6762 {
6763 case 0x00:
6764 goto op_semantics_41;
6765 break;
6766 }
6767 break;
6768 case 0xf0:
6769 GETBYTE ();
6770 switch (op[1] & 0x08)
6771 {
6772 case 0x00:
6773 op_semantics_42:
6774 {
6775 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
78e98aab 6776#line 874 "rx-decode.opc"
c7927a3c 6777 int sd AU = op[0] & 0x03;
78e98aab 6778#line 874 "rx-decode.opc"
c7927a3c 6779 int rdst AU = (op[1] >> 4) & 0x0f;
78e98aab 6780#line 874 "rx-decode.opc"
c7927a3c
NC		 6781 int bit AU = op[1] & 0x07;
6782 if (trace)
6783 {
6784 printf ("\033[33m%s\033[0m %02x %02x\n",
6785 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6786 op[0], op[1]);
6787 printf (" sd = 0x%x,", sd);
6788 printf (" rdst = 0x%x,", rdst);
6789 printf (" bit = 0x%x\n", bit);
6790 }
6791 SYNTAX("bset #%1, %0%S0");
78e98aab 6792#line 874 "rx-decode.opc"
3cf79a01 6793 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 6794
6795 }
6796 break;
6797 case 0x08:
6798 op_semantics_43:
6799 {
6800 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
78e98aab 6801#line 884 "rx-decode.opc"
c7927a3c 6802 int sd AU = op[0] & 0x03;
78e98aab 6803#line 884 "rx-decode.opc"
c7927a3c 6804 int rdst AU = (op[1] >> 4) & 0x0f;
78e98aab 6805#line 884 "rx-decode.opc"
c7927a3c
NC		 6806 int bit AU = op[1] & 0x07;
6807 if (trace)
6808 {
6809 printf ("\033[33m%s\033[0m %02x %02x\n",
6810 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6811 op[0], op[1]);
6812 printf (" sd = 0x%x,", sd);
6813 printf (" rdst = 0x%x,", rdst);
6814 printf (" bit = 0x%x\n", bit);
6815 }
6816 SYNTAX("bclr #%1, %0%S0");
78e98aab 6817#line 884 "rx-decode.opc"
3cf79a01 6818 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 6819
6820 }
6821 break;
6822 }
6823 break;
6824 case 0xf1:
6825 GETBYTE ();
6826 switch (op[1] & 0x08)
6827 {
6828 case 0x00:
6829 goto op_semantics_42;
6830 break;
6831 case 0x08:
6832 goto op_semantics_43;
6833 break;
6834 }
6835 break;
6836 case 0xf2:
6837 GETBYTE ();
6838 switch (op[1] & 0x08)
6839 {
6840 case 0x00:
6841 goto op_semantics_42;
6842 break;
6843 case 0x08:
6844 goto op_semantics_43;
6845 break;
6846 }
6847 break;
6848 case 0xf3:
6849 GETBYTE ();
6850 switch (op[1] & 0x08)
6851 {
6852 case 0x00:
6853 goto op_semantics_42;
6854 break;
6855 case 0x08:
6856 goto op_semantics_43;
6857 break;
6858 }
6859 break;
6860 case 0xf4:
6861 GETBYTE ();
6862 switch (op[1] & 0x0c)
6863 {
6864 case 0x00:
6865 case 0x04:
6866 op_semantics_44:
6867 {
6868 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
78e98aab 6869#line 894 "rx-decode.opc"
c7927a3c 6870 int sd AU = op[0] & 0x03;
78e98aab 6871#line 894 "rx-decode.opc"
c7927a3c 6872 int rdst AU = (op[1] >> 4) & 0x0f;
78e98aab 6873#line 894 "rx-decode.opc"
c7927a3c
NC		 6874 int bit AU = op[1] & 0x07;
6875 if (trace)
6876 {
6877 printf ("\033[33m%s\033[0m %02x %02x\n",
6878 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6879 op[0], op[1]);
6880 printf (" sd = 0x%x,", sd);
6881 printf (" rdst = 0x%x,", rdst);
6882 printf (" bit = 0x%x\n", bit);
6883 }
6884 SYNTAX("btst #%2, %1%S1");
78e98aab 6885#line 894 "rx-decode.opc"
3cf79a01 6886 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
c7927a3c
NC		 6887
6888 }
6889 break;
6890 case 0x08:
6891 op_semantics_45:
6892 {
6893 /** 1111 01ss rsrc 10sz push%s %1 */
78e98aab 6894#line 354 "rx-decode.opc"
c7927a3c 6895 int ss AU = op[0] & 0x03;
78e98aab 6896#line 354 "rx-decode.opc"
c7927a3c 6897 int rsrc AU = (op[1] >> 4) & 0x0f;
78e98aab 6898#line 354 "rx-decode.opc"
c7927a3c
NC		 6899 int sz AU = op[1] & 0x03;
6900 if (trace)
6901 {
6902 printf ("\033[33m%s\033[0m %02x %02x\n",
6903 "/** 1111 01ss rsrc 10sz push%s %1 */",
6904 op[0], op[1]);
6905 printf (" ss = 0x%x,", ss);
6906 printf (" rsrc = 0x%x,", rsrc);
6907 printf (" sz = 0x%x\n", sz);
6908 }
6909 SYNTAX("push%s %1");
78e98aab 6910#line 354 "rx-decode.opc"
3cf79a01 6911 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
c7927a3c
NC		 6912
6913 /*----------------------------------------------------------------------*/
6914 /* XCHG */
6915
6916 }
6917 break;
6918 default: UNSUPPORTED(); break;
6919 }
6920 break;
6921 case 0xf5:
6922 GETBYTE ();
6923 switch (op[1] & 0x0c)
6924 {
6925 case 0x00:
6926 case 0x04:
6927 goto op_semantics_44;
6928 break;
6929 case 0x08:
6930 goto op_semantics_45;
6931 break;
6932 default: UNSUPPORTED(); break;
6933 }
6934 break;
6935 case 0xf6:
6936 GETBYTE ();
6937 switch (op[1] & 0x0c)
6938 {
6939 case 0x00:
6940 case 0x04:
6941 goto op_semantics_44;
6942 break;
6943 case 0x08:
6944 goto op_semantics_45;
6945 break;
6946 default: UNSUPPORTED(); break;
6947 }
6948 break;
6949 case 0xf7:
6950 GETBYTE ();
6951 switch (op[1] & 0x0c)
6952 {
6953 case 0x00:
6954 case 0x04:
6955 goto op_semantics_44;
6956 break;
6957 case 0x08:
6958 goto op_semantics_45;
6959 break;
6960 default: UNSUPPORTED(); break;
6961 }
6962 break;
6963 case 0xf8:
6964 GETBYTE ();
6965 switch (op[1] & 0x00)
6966 {
6967 case 0x00:
6968 op_semantics_46:
6969 {
6970 /** 1111 10sd rdst im sz mov%s #%1, %0 */
f9c7014e 6971#line 265 "rx-decode.opc"
c7927a3c 6972 int sd AU = op[0] & 0x03;
f9c7014e 6973#line 265 "rx-decode.opc"
c7927a3c 6974 int rdst AU = (op[1] >> 4) & 0x0f;
f9c7014e 6975#line 265 "rx-decode.opc"
c7927a3c 6976 int im AU = (op[1] >> 2) & 0x03;
f9c7014e 6977#line 265 "rx-decode.opc"
c7927a3c
NC		 6978 int sz AU = op[1] & 0x03;
6979 if (trace)
6980 {
6981 printf ("\033[33m%s\033[0m %02x %02x\n",
6982 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
6983 op[0], op[1]);
6984 printf (" sd = 0x%x,", sd);
6985 printf (" rdst = 0x%x,", rdst);
6986 printf (" im = 0x%x,", im);
6987 printf (" sz = 0x%x\n", sz);
6988 }
6989 SYNTAX("mov%s #%1, %0");
f9c7014e 6990#line 265 "rx-decode.opc"
78e98aab
DD		 6991 ID(mov); DD(sd, rdst, sz);
6992 if ((im == 1 && sz == 0)
6993 || (im == 2 && sz == 1)
6994 || (im == 0 && sz == 2))
6995 {
6996 BWL (sz);
6997 SC(IMM(im));
6998 }
6999 else
7000 {
7001 sBWL (sz);
7002 SC(IMMex(im));
7003 }
7004 F_____;
c7927a3c
NC		 7005
7006 }
7007 break;
7008 }
7009 break;
7010 case 0xf9:
7011 GETBYTE ();
7012 switch (op[1] & 0x00)
7013 {
7014 case 0x00:
7015 goto op_semantics_46;
7016 break;
7017 }
7018 break;
7019 case 0xfa:
7020 GETBYTE ();
7021 switch (op[1] & 0x00)
7022 {
7023 case 0x00:
7024 goto op_semantics_46;
7025 break;
7026 }
7027 break;
7028 case 0xfb:
7029 GETBYTE ();
7030 switch (op[1] & 0x00)
7031 {
7032 case 0x00:
7033 goto op_semantics_46;
7034 break;
7035 }
7036 break;
7037 case 0xfc:
7038 GETBYTE ();
7039 switch (op[1] & 0xff)
7040 {
7041 case 0x03:
7042 GETBYTE ();
7043 switch (op[2] & 0x00)
7044 {
7045 case 0x00:
7046 {
7047 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
78e98aab 7048#line 528 "rx-decode.opc"
c7927a3c 7049 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7050#line 528 "rx-decode.opc"
c7927a3c
NC		 7051 int rdst AU = op[2] & 0x0f;
7052 if (trace)
7053 {
7054 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7055 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7056 op[0], op[1], op[2]);
7057 printf (" rsrc = 0x%x,", rsrc);
7058 printf (" rdst = 0x%x\n", rdst);
7059 }
7060 SYNTAX("sbb %1, %0");
78e98aab 7061#line 528 "rx-decode.opc"
3cf79a01 7062 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 7063
7064 /* FIXME: only supports .L */
7065 }
7066 break;
7067 }
7068 break;
7069 case 0x07:
7070 GETBYTE ();
7071 switch (op[2] & 0x00)
7072 {
7073 case 0x00:
7074 {
7075 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
78e98aab 7076#line 459 "rx-decode.opc"
c7927a3c 7077 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7078#line 459 "rx-decode.opc"
c7927a3c
NC		 7079 int rdst AU = op[2] & 0x0f;
7080 if (trace)
7081 {
7082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7083 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7084 op[0], op[1], op[2]);
7085 printf (" rsrc = 0x%x,", rsrc);
7086 printf (" rdst = 0x%x\n", rdst);
7087 }
7088 SYNTAX("neg %2, %0");
78e98aab 7089#line 459 "rx-decode.opc"
3cf79a01 7090 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
c7927a3c
NC		 7091
7092 /*----------------------------------------------------------------------*/
7093 /* ADC */
7094
7095 }
7096 break;
7097 }
7098 break;
7099 case 0x0b:
7100 GETBYTE ();
7101 switch (op[2] & 0x00)
7102 {
7103 case 0x00:
7104 {
7105 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
78e98aab 7106#line 468 "rx-decode.opc"
c7927a3c 7107 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7108#line 468 "rx-decode.opc"
c7927a3c
NC		 7109 int rdst AU = op[2] & 0x0f;
7110 if (trace)
7111 {
7112 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7113 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7114 op[0], op[1], op[2]);
7115 printf (" rsrc = 0x%x,", rsrc);
7116 printf (" rdst = 0x%x\n", rdst);
7117 }
7118 SYNTAX("adc %1, %0");
78e98aab 7119#line 468 "rx-decode.opc"
3cf79a01 7120 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 7121
7122 }
7123 break;
7124 }
7125 break;
7126 case 0x0f:
7127 GETBYTE ();
7128 switch (op[2] & 0x00)
7129 {
7130 case 0x00:
7131 {
7132 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
78e98aab 7133#line 541 "rx-decode.opc"
c7927a3c 7134 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7135#line 541 "rx-decode.opc"
c7927a3c
NC		 7136 int rdst AU = op[2] & 0x0f;
7137 if (trace)
7138 {
7139 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7140 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7141 op[0], op[1], op[2]);
7142 printf (" rsrc = 0x%x,", rsrc);
7143 printf (" rdst = 0x%x\n", rdst);
7144 }
7145 SYNTAX("abs %1, %0");
78e98aab 7146#line 541 "rx-decode.opc"
3cf79a01 7147 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
c7927a3c
NC		 7148
7149 /*----------------------------------------------------------------------*/
7150 /* MAX */
7151
7152 }
7153 break;
7154 }
7155 break;
7156 case 0x10:
7157 GETBYTE ();
7158 switch (op[2] & 0x00)
7159 {
7160 case 0x00:
7161 op_semantics_47:
7162 {
7163 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
78e98aab 7164#line 550 "rx-decode.opc"
c7927a3c 7165 int ss AU = op[1] & 0x03;
78e98aab 7166#line 550 "rx-decode.opc"
c7927a3c 7167 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7168#line 550 "rx-decode.opc"
c7927a3c
NC		 7169 int rdst AU = op[2] & 0x0f;
7170 if (trace)
7171 {
7172 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7173 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7174 op[0], op[1], op[2]);
7175 printf (" ss = 0x%x,", ss);
7176 printf (" rsrc = 0x%x,", rsrc);
7177 printf (" rdst = 0x%x\n", rdst);
7178 }
7179 SYNTAX("max %1%S1, %0");
78e98aab 7180#line 550 "rx-decode.opc"
f9c7014e
DD		 7181 if (ss == 3 && rsrc == 0 && rdst == 0)
7182 {
7183 ID(nop3);
9887672f 7184 rx->syntax = "nop";
f9c7014e
DD		 7185 }
7186 else
7187 {
7188 ID(max); SP(ss, rsrc); DR(rdst);
7189 }
c7927a3c
NC		 7190
7191 }
7192 break;
7193 }
7194 break;
7195 case 0x11:
7196 GETBYTE ();
7197 switch (op[2] & 0x00)
7198 {
7199 case 0x00:
7200 goto op_semantics_47;
7201 break;
7202 }
7203 break;
7204 case 0x12:
7205 GETBYTE ();
7206 switch (op[2] & 0x00)
7207 {
7208 case 0x00:
7209 goto op_semantics_47;
7210 break;
7211 }
7212 break;
7213 case 0x13:
7214 GETBYTE ();
7215 switch (op[2] & 0x00)
7216 {
7217 case 0x00:
7218 goto op_semantics_47;
7219 break;
7220 }
7221 break;
7222 case 0x14:
7223 GETBYTE ();
7224 switch (op[2] & 0x00)
7225 {
7226 case 0x00:
7227 op_semantics_48:
7228 {
7229 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
78e98aab 7230#line 570 "rx-decode.opc"
c7927a3c 7231 int ss AU = op[1] & 0x03;
78e98aab 7232#line 570 "rx-decode.opc"
c7927a3c 7233 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7234#line 570 "rx-decode.opc"
c7927a3c
NC		 7235 int rdst AU = op[2] & 0x0f;
7236 if (trace)
7237 {
7238 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7239 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7240 op[0], op[1], op[2]);
7241 printf (" ss = 0x%x,", ss);
7242 printf (" rsrc = 0x%x,", rsrc);
7243 printf (" rdst = 0x%x\n", rdst);
7244 }
7245 SYNTAX("min %1%S1, %0");
78e98aab 7246#line 570 "rx-decode.opc"
c7927a3c
NC		 7247 ID(min); SP(ss, rsrc); DR(rdst);
7248
7249 }
7250 break;
7251 }
7252 break;
7253 case 0x15:
7254 GETBYTE ();
7255 switch (op[2] & 0x00)
7256 {
7257 case 0x00:
7258 goto op_semantics_48;
7259 break;
7260 }
7261 break;
7262 case 0x16:
7263 GETBYTE ();
7264 switch (op[2] & 0x00)
7265 {
7266 case 0x00:
7267 goto op_semantics_48;
7268 break;
7269 }
7270 break;
7271 case 0x17:
7272 GETBYTE ();
7273 switch (op[2] & 0x00)
7274 {
7275 case 0x00:
7276 goto op_semantics_48;
7277 break;
7278 }
7279 break;
7280 case 0x18:
7281 GETBYTE ();
7282 switch (op[2] & 0x00)
7283 {
7284 case 0x00:
7285 op_semantics_49:
7286 {
7287 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
78e98aab 7288#line 600 "rx-decode.opc"
c7927a3c 7289 int ss AU = op[1] & 0x03;
78e98aab 7290#line 600 "rx-decode.opc"
c7927a3c 7291 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7292#line 600 "rx-decode.opc"
c7927a3c
NC		 7293 int rdst AU = op[2] & 0x0f;
7294 if (trace)
7295 {
7296 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7297 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7298 op[0], op[1], op[2]);
7299 printf (" ss = 0x%x,", ss);
7300 printf (" rsrc = 0x%x,", rsrc);
7301 printf (" rdst = 0x%x\n", rdst);
7302 }
7303 SYNTAX("emul %1%S1, %0");
78e98aab 7304#line 600 "rx-decode.opc"
c7927a3c
NC		 7305 ID(emul); SP(ss, rsrc); DR(rdst);
7306
7307 }
7308 break;
7309 }
7310 break;
7311 case 0x19:
7312 GETBYTE ();
7313 switch (op[2] & 0x00)
7314 {
7315 case 0x00:
7316 goto op_semantics_49;
7317 break;
7318 }
7319 break;
7320 case 0x1a:
7321 GETBYTE ();
7322 switch (op[2] & 0x00)
7323 {
7324 case 0x00:
7325 goto op_semantics_49;
7326 break;
7327 }
7328 break;
7329 case 0x1b:
7330 GETBYTE ();
7331 switch (op[2] & 0x00)
7332 {
7333 case 0x00:
7334 goto op_semantics_49;
7335 break;
7336 }
7337 break;
7338 case 0x1c:
7339 GETBYTE ();
7340 switch (op[2] & 0x00)
7341 {
7342 case 0x00:
7343 op_semantics_50:
7344 {
7345 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
78e98aab 7346#line 612 "rx-decode.opc"
c7927a3c 7347 int ss AU = op[1] & 0x03;
78e98aab 7348#line 612 "rx-decode.opc"
c7927a3c 7349 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7350#line 612 "rx-decode.opc"
c7927a3c
NC		 7351 int rdst AU = op[2] & 0x0f;
7352 if (trace)
7353 {
7354 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7355 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7356 op[0], op[1], op[2]);
7357 printf (" ss = 0x%x,", ss);
7358 printf (" rsrc = 0x%x,", rsrc);
7359 printf (" rdst = 0x%x\n", rdst);
7360 }
7361 SYNTAX("emulu %1%S1, %0");
78e98aab 7362#line 612 "rx-decode.opc"
c7927a3c
NC		 7363 ID(emulu); SP(ss, rsrc); DR(rdst);
7364
7365 }
7366 break;
7367 }
7368 break;
7369 case 0x1d:
7370 GETBYTE ();
7371 switch (op[2] & 0x00)
7372 {
7373 case 0x00:
7374 goto op_semantics_50;
7375 break;
7376 }
7377 break;
7378 case 0x1e:
7379 GETBYTE ();
7380 switch (op[2] & 0x00)
7381 {
7382 case 0x00:
7383 goto op_semantics_50;
7384 break;
7385 }
7386 break;
7387 case 0x1f:
7388 GETBYTE ();
7389 switch (op[2] & 0x00)
7390 {
7391 case 0x00:
7392 goto op_semantics_50;
7393 break;
7394 }
7395 break;
7396 case 0x20:
7397 GETBYTE ();
7398 switch (op[2] & 0x00)
7399 {
7400 case 0x00:
7401 op_semantics_51:
7402 {
7403 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
78e98aab 7404#line 624 "rx-decode.opc"
c7927a3c 7405 int ss AU = op[1] & 0x03;
78e98aab 7406#line 624 "rx-decode.opc"
c7927a3c 7407 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7408#line 624 "rx-decode.opc"
c7927a3c
NC		 7409 int rdst AU = op[2] & 0x0f;
7410 if (trace)
7411 {
7412 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7413 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7414 op[0], op[1], op[2]);
7415 printf (" ss = 0x%x,", ss);
7416 printf (" rsrc = 0x%x,", rsrc);
7417 printf (" rdst = 0x%x\n", rdst);
7418 }
7419 SYNTAX("div %1%S1, %0");
78e98aab 7420#line 624 "rx-decode.opc"
3cf79a01 7421 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
c7927a3c
NC		 7422
7423 }
7424 break;
7425 }
7426 break;
7427 case 0x21:
7428 GETBYTE ();
7429 switch (op[2] & 0x00)
7430 {
7431 case 0x00:
7432 goto op_semantics_51;
7433 break;
7434 }
7435 break;
7436 case 0x22:
7437 GETBYTE ();
7438 switch (op[2] & 0x00)
7439 {
7440 case 0x00:
7441 goto op_semantics_51;
7442 break;
7443 }
7444 break;
7445 case 0x23:
7446 GETBYTE ();
7447 switch (op[2] & 0x00)
7448 {
7449 case 0x00:
7450 goto op_semantics_51;
7451 break;
7452 }
7453 break;
7454 case 0x24:
7455 GETBYTE ();
7456 switch (op[2] & 0x00)
7457 {
7458 case 0x00:
7459 op_semantics_52:
7460 {
7461 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
78e98aab 7462#line 636 "rx-decode.opc"
c7927a3c 7463 int ss AU = op[1] & 0x03;
78e98aab 7464#line 636 "rx-decode.opc"
c7927a3c 7465 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7466#line 636 "rx-decode.opc"
c7927a3c
NC		 7467 int rdst AU = op[2] & 0x0f;
7468 if (trace)
7469 {
7470 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7471 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7472 op[0], op[1], op[2]);
7473 printf (" ss = 0x%x,", ss);
7474 printf (" rsrc = 0x%x,", rsrc);
7475 printf (" rdst = 0x%x\n", rdst);
7476 }
7477 SYNTAX("divu %1%S1, %0");
78e98aab 7478#line 636 "rx-decode.opc"
3cf79a01 7479 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
c7927a3c
NC		 7480
7481 }
7482 break;
7483 }
7484 break;
7485 case 0x25:
7486 GETBYTE ();
7487 switch (op[2] & 0x00)
7488 {
7489 case 0x00:
7490 goto op_semantics_52;
7491 break;
7492 }
7493 break;
7494 case 0x26:
7495 GETBYTE ();
7496 switch (op[2] & 0x00)
7497 {
7498 case 0x00:
7499 goto op_semantics_52;
7500 break;
7501 }
7502 break;
7503 case 0x27:
7504 GETBYTE ();
7505 switch (op[2] & 0x00)
7506 {
7507 case 0x00:
7508 goto op_semantics_52;
7509 break;
7510 }
7511 break;
7512 case 0x30:
7513 GETBYTE ();
7514 switch (op[2] & 0x00)
7515 {
7516 case 0x00:
7517 op_semantics_53:
7518 {
7519 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
78e98aab 7520#line 447 "rx-decode.opc"
c7927a3c 7521 int ss AU = op[1] & 0x03;
78e98aab 7522#line 447 "rx-decode.opc"
c7927a3c 7523 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7524#line 447 "rx-decode.opc"
c7927a3c
NC		 7525 int rdst AU = op[2] & 0x0f;
7526 if (trace)
7527 {
7528 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7529 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7530 op[0], op[1], op[2]);
7531 printf (" ss = 0x%x,", ss);
7532 printf (" rsrc = 0x%x,", rsrc);
7533 printf (" rdst = 0x%x\n", rdst);
7534 }
7535 SYNTAX("tst %1%S1, %2");
78e98aab 7536#line 447 "rx-decode.opc"
3cf79a01 7537 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
c7927a3c
NC		 7538
7539 }
7540 break;
7541 }
7542 break;
7543 case 0x31:
7544 GETBYTE ();
7545 switch (op[2] & 0x00)
7546 {
7547 case 0x00:
7548 goto op_semantics_53;
7549 break;
7550 }
7551 break;
7552 case 0x32:
7553 GETBYTE ();
7554 switch (op[2] & 0x00)
7555 {
7556 case 0x00:
7557 goto op_semantics_53;
7558 break;
7559 }
7560 break;
7561 case 0x33:
7562 GETBYTE ();
7563 switch (op[2] & 0x00)
7564 {
7565 case 0x00:
7566 goto op_semantics_53;
7567 break;
7568 }
7569 break;
7570 case 0x34:
7571 GETBYTE ();
7572 switch (op[2] & 0x00)
7573 {
7574 case 0x00:
7575 op_semantics_54:
7576 {
7577 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
78e98aab 7578#line 426 "rx-decode.opc"
c7927a3c 7579 int ss AU = op[1] & 0x03;
78e98aab 7580#line 426 "rx-decode.opc"
c7927a3c 7581 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7582#line 426 "rx-decode.opc"
c7927a3c
NC		 7583 int rdst AU = op[2] & 0x0f;
7584 if (trace)
7585 {
7586 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7587 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7588 op[0], op[1], op[2]);
7589 printf (" ss = 0x%x,", ss);
7590 printf (" rsrc = 0x%x,", rsrc);
7591 printf (" rdst = 0x%x\n", rdst);
7592 }
7593 SYNTAX("xor %1%S1, %0");
78e98aab 7594#line 426 "rx-decode.opc"
3cf79a01 7595 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
c7927a3c
NC		 7596
7597 }
7598 break;
7599 }
7600 break;
7601 case 0x35:
7602 GETBYTE ();
7603 switch (op[2] & 0x00)
7604 {
7605 case 0x00:
7606 goto op_semantics_54;
7607 break;
7608 }
7609 break;
7610 case 0x36:
7611 GETBYTE ();
7612 switch (op[2] & 0x00)
7613 {
7614 case 0x00:
7615 goto op_semantics_54;
7616 break;
7617 }
7618 break;
7619 case 0x37:
7620 GETBYTE ();
7621 switch (op[2] & 0x00)
7622 {
7623 case 0x00:
7624 goto op_semantics_54;
7625 break;
7626 }
7627 break;
7628 case 0x3b:
7629 GETBYTE ();
7630 switch (op[2] & 0x00)
7631 {
7632 case 0x00:
7633 {
7634 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
78e98aab 7635#line 438 "rx-decode.opc"
c7927a3c 7636 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7637#line 438 "rx-decode.opc"
c7927a3c
NC		 7638 int rdst AU = op[2] & 0x0f;
7639 if (trace)
7640 {
7641 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7642 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7643 op[0], op[1], op[2]);
7644 printf (" rsrc = 0x%x,", rsrc);
7645 printf (" rdst = 0x%x\n", rdst);
7646 }
7647 SYNTAX("not %1, %0");
78e98aab 7648#line 438 "rx-decode.opc"
3cf79a01 7649 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
c7927a3c
NC		 7650
7651 /*----------------------------------------------------------------------*/
7652 /* TST */
7653
7654 }
7655 break;
7656 }
7657 break;
7658 case 0x40:
7659 GETBYTE ();
7660 switch (op[2] & 0x00)
7661 {
7662 case 0x00:
7663 op_semantics_55:
7664 {
7665 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
78e98aab 7666#line 360 "rx-decode.opc"
c7927a3c 7667 int ss AU = op[1] & 0x03;
78e98aab 7668#line 360 "rx-decode.opc"
c7927a3c 7669 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7670#line 360 "rx-decode.opc"
c7927a3c
NC		 7671 int rdst AU = op[2] & 0x0f;
7672 if (trace)
7673 {
7674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7675 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7676 op[0], op[1], op[2]);
7677 printf (" ss = 0x%x,", ss);
7678 printf (" rsrc = 0x%x,", rsrc);
7679 printf (" rdst = 0x%x\n", rdst);
7680 }
7681 SYNTAX("xchg %1%S1, %0");
78e98aab 7682#line 360 "rx-decode.opc"
c7927a3c
NC		 7683 ID(xchg); DR(rdst); SP(ss, rsrc);
7684
7685 }
7686 break;
7687 }
7688 break;
7689 case 0x41:
7690 GETBYTE ();
7691 switch (op[2] & 0x00)
7692 {
7693 case 0x00:
7694 goto op_semantics_55;
7695 break;
7696 }
7697 break;
7698 case 0x42:
7699 GETBYTE ();
7700 switch (op[2] & 0x00)
7701 {
7702 case 0x00:
7703 goto op_semantics_55;
7704 break;
7705 }
7706 break;
7707 case 0x43:
7708 GETBYTE ();
7709 switch (op[2] & 0x00)
7710 {
7711 case 0x00:
7712 goto op_semantics_55;
7713 break;
7714 }
7715 break;
7716 case 0x44:
7717 GETBYTE ();
7718 switch (op[2] & 0x00)
7719 {
7720 case 0x00:
7721 op_semantics_56:
7722 {
7723 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
78e98aab 7724#line 865 "rx-decode.opc"
c7927a3c 7725 int sd AU = op[1] & 0x03;
78e98aab 7726#line 865 "rx-decode.opc"
c7927a3c 7727 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 7728#line 865 "rx-decode.opc"
c7927a3c
NC		 7729 int rdst AU = op[2] & 0x0f;
7730 if (trace)
7731 {
7732 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7733 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7734 op[0], op[1], op[2]);
7735 printf (" sd = 0x%x,", sd);
7736 printf (" rsrc = 0x%x,", rsrc);
7737 printf (" rdst = 0x%x\n", rdst);
7738 }
7739 SYNTAX("itof %1%S1, %0");
78e98aab 7740#line 865 "rx-decode.opc"
3cf79a01 7741 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
c7927a3c
NC		 7742
7743 }
7744 break;
7745 }
7746 break;
7747 case 0x45:
7748 GETBYTE ();
7749 switch (op[2] & 0x00)
7750 {
7751 case 0x00:
7752 goto op_semantics_56;
7753 break;
7754 }
7755 break;
7756 case 0x46:
7757 GETBYTE ();
7758 switch (op[2] & 0x00)
7759 {
7760 case 0x00:
7761 goto op_semantics_56;
7762 break;
7763 }
7764 break;
7765 case 0x47:
7766 GETBYTE ();
7767 switch (op[2] & 0x00)
7768 {
7769 case 0x00:
7770 goto op_semantics_56;
7771 break;
7772 }
7773 break;
7774 case 0x60:
7775 GETBYTE ();
7776 switch (op[2] & 0x00)
7777 {
7778 case 0x00:
7779 op_semantics_57:
7780 {
7781 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
78e98aab 7782#line 877 "rx-decode.opc"
c7927a3c 7783 int sd AU = op[1] & 0x03;
78e98aab 7784#line 877 "rx-decode.opc"
c7927a3c 7785 int rdst AU = (op[2] >> 4) & 0x0f;
78e98aab 7786#line 877 "rx-decode.opc"
c7927a3c
NC		 7787 int rsrc AU = op[2] & 0x0f;
7788 if (trace)
7789 {
7790 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7791 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7792 op[0], op[1], op[2]);
7793 printf (" sd = 0x%x,", sd);
7794 printf (" rdst = 0x%x,", rdst);
7795 printf (" rsrc = 0x%x\n", rsrc);
7796 }
7797 SYNTAX("bset %1, %0%S0");
78e98aab 7798#line 877 "rx-decode.opc"
3cf79a01 7799 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 7800
7801 }
7802 break;
7803 }
7804 break;
7805 case 0x61:
7806 GETBYTE ();
7807 switch (op[2] & 0x00)
7808 {
7809 case 0x00:
7810 goto op_semantics_57;
7811 break;
7812 }
7813 break;
7814 case 0x62:
7815 GETBYTE ();
7816 switch (op[2] & 0x00)
7817 {
7818 case 0x00:
7819 goto op_semantics_57;
7820 break;
7821 }
7822 break;
7823 case 0x63:
7824 GETBYTE ();
7825 switch (op[2] & 0x00)
7826 {
7827 case 0x00:
7828 goto op_semantics_57;
7829 break;
7830 }
7831 break;
7832 case 0x64:
7833 GETBYTE ();
7834 switch (op[2] & 0x00)
7835 {
7836 case 0x00:
7837 op_semantics_58:
7838 {
7839 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
78e98aab 7840#line 887 "rx-decode.opc"
c7927a3c 7841 int sd AU = op[1] & 0x03;
78e98aab 7842#line 887 "rx-decode.opc"
c7927a3c 7843 int rdst AU = (op[2] >> 4) & 0x0f;
78e98aab 7844#line 887 "rx-decode.opc"
c7927a3c
NC		 7845 int rsrc AU = op[2] & 0x0f;
7846 if (trace)
7847 {
7848 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7849 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7850 op[0], op[1], op[2]);
7851 printf (" sd = 0x%x,", sd);
7852 printf (" rdst = 0x%x,", rdst);
7853 printf (" rsrc = 0x%x\n", rsrc);
7854 }
7855 SYNTAX("bclr %1, %0%S0");
78e98aab 7856#line 887 "rx-decode.opc"
3cf79a01 7857 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
c7927a3c
NC		 7858
7859 }
7860 break;
7861 }
7862 break;
7863 case 0x65:
7864 GETBYTE ();
7865 switch (op[2] & 0x00)
7866 {
7867 case 0x00:
7868 goto op_semantics_58;
7869 break;
7870 }
7871 break;
7872 case 0x66:
7873 GETBYTE ();
7874 switch (op[2] & 0x00)
7875 {
7876 case 0x00:
7877 goto op_semantics_58;
7878 break;
7879 }
7880 break;
7881 case 0x67:
7882 GETBYTE ();
7883 switch (op[2] & 0x00)
7884 {
7885 case 0x00:
7886 goto op_semantics_58;
7887 break;
7888 }
7889 break;
7890 case 0x68:
7891 GETBYTE ();
7892 switch (op[2] & 0x00)
7893 {
7894 case 0x00:
7895 op_semantics_59:
7896 {
7897 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
78e98aab 7898#line 897 "rx-decode.opc"
c7927a3c 7899 int sd AU = op[1] & 0x03;
78e98aab 7900#line 897 "rx-decode.opc"
c7927a3c 7901 int rdst AU = (op[2] >> 4) & 0x0f;
78e98aab 7902#line 897 "rx-decode.opc"
c7927a3c
NC		 7903 int rsrc AU = op[2] & 0x0f;
7904 if (trace)
7905 {
7906 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7907 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7908 op[0], op[1], op[2]);
7909 printf (" sd = 0x%x,", sd);
7910 printf (" rdst = 0x%x,", rdst);
7911 printf (" rsrc = 0x%x\n", rsrc);
7912 }
7913 SYNTAX("btst %2, %1%S1");
78e98aab 7914#line 897 "rx-decode.opc"
3cf79a01 7915 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
c7927a3c
NC		 7916
7917 }
7918 break;
7919 }
7920 break;
7921 case 0x69:
7922 GETBYTE ();
7923 switch (op[2] & 0x00)
7924 {
7925 case 0x00:
7926 goto op_semantics_59;
7927 break;
7928 }
7929 break;
7930 case 0x6a:
7931 GETBYTE ();
7932 switch (op[2] & 0x00)
7933 {
7934 case 0x00:
7935 goto op_semantics_59;
7936 break;
7937 }
7938 break;
7939 case 0x6b:
7940 GETBYTE ();
7941 switch (op[2] & 0x00)
7942 {
7943 case 0x00:
7944 goto op_semantics_59;
7945 break;
7946 }
7947 break;
7948 case 0x6c:
7949 GETBYTE ();
7950 switch (op[2] & 0x00)
7951 {
7952 case 0x00:
7953 op_semantics_60:
7954 {
7955 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
78e98aab 7956#line 907 "rx-decode.opc"
c7927a3c 7957 int sd AU = op[1] & 0x03;
78e98aab 7958#line 907 "rx-decode.opc"
c7927a3c 7959 int rdst AU = (op[2] >> 4) & 0x0f;
78e98aab 7960#line 907 "rx-decode.opc"
c7927a3c
NC		 7961 int rsrc AU = op[2] & 0x0f;
7962 if (trace)
7963 {
7964 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7965 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
7966 op[0], op[1], op[2]);
7967 printf (" sd = 0x%x,", sd);
7968 printf (" rdst = 0x%x,", rdst);
7969 printf (" rsrc = 0x%x\n", rsrc);
7970 }
7971 SYNTAX("bnot %1, %0%S0");
78e98aab 7972#line 907 "rx-decode.opc"
c7927a3c
NC		 7973 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7974
7975 }
7976 break;
7977 }
7978 break;
7979 case 0x6d:
7980 GETBYTE ();
7981 switch (op[2] & 0x00)
7982 {
7983 case 0x00:
7984 goto op_semantics_60;
7985 break;
7986 }
7987 break;
7988 case 0x6e:
7989 GETBYTE ();
7990 switch (op[2] & 0x00)
7991 {
7992 case 0x00:
7993 goto op_semantics_60;
7994 break;
7995 }
7996 break;
7997 case 0x6f:
7998 GETBYTE ();
7999 switch (op[2] & 0x00)
8000 {
8001 case 0x00:
8002 goto op_semantics_60;
8003 break;
8004 }
8005 break;
8006 case 0x80:
8007 GETBYTE ();
8008 switch (op[2] & 0x00)
8009 {
8010 case 0x00:
8011 op_semantics_61:
8012 {
8013 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
78e98aab 8014#line 844 "rx-decode.opc"
c7927a3c 8015 int sd AU = op[1] & 0x03;
78e98aab 8016#line 844 "rx-decode.opc"
c7927a3c 8017 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 8018#line 844 "rx-decode.opc"
c7927a3c
NC		 8019 int rdst AU = op[2] & 0x0f;
8020 if (trace)
8021 {
8022 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8023 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8024 op[0], op[1], op[2]);
8025 printf (" sd = 0x%x,", sd);
8026 printf (" rsrc = 0x%x,", rsrc);
8027 printf (" rdst = 0x%x\n", rdst);
8028 }
8029 SYNTAX("fsub %1%S1, %0");
78e98aab 8030#line 844 "rx-decode.opc"
3cf79a01 8031 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8032
8033 }
8034 break;
8035 }
8036 break;
8037 case 0x81:
8038 GETBYTE ();
8039 switch (op[2] & 0x00)
8040 {
8041 case 0x00:
8042 goto op_semantics_61;
8043 break;
8044 }
8045 break;
8046 case 0x82:
8047 GETBYTE ();
8048 switch (op[2] & 0x00)
8049 {
8050 case 0x00:
8051 goto op_semantics_61;
8052 break;
8053 }
8054 break;
8055 case 0x83:
8056 GETBYTE ();
8057 switch (op[2] & 0x00)
8058 {
8059 case 0x00:
8060 goto op_semantics_61;
8061 break;
8062 }
8063 break;
8064 case 0x84:
8065 GETBYTE ();
8066 switch (op[2] & 0x00)
8067 {
8068 case 0x00:
8069 op_semantics_62:
8070 {
8071 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
78e98aab 8072#line 838 "rx-decode.opc"
c7927a3c 8073 int sd AU = op[1] & 0x03;
78e98aab 8074#line 838 "rx-decode.opc"
c7927a3c 8075 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 8076#line 838 "rx-decode.opc"
c7927a3c
NC		 8077 int rdst AU = op[2] & 0x0f;
8078 if (trace)
8079 {
8080 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8081 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8082 op[0], op[1], op[2]);
8083 printf (" sd = 0x%x,", sd);
8084 printf (" rsrc = 0x%x,", rsrc);
8085 printf (" rdst = 0x%x\n", rdst);
8086 }
8087 SYNTAX("fcmp %1%S1, %0");
78e98aab 8088#line 838 "rx-decode.opc"
3cf79a01 8089 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
c7927a3c
NC		 8090
8091 }
8092 break;
8093 }
8094 break;
8095 case 0x85:
8096 GETBYTE ();
8097 switch (op[2] & 0x00)
8098 {
8099 case 0x00:
8100 goto op_semantics_62;
8101 break;
8102 }
8103 break;
8104 case 0x86:
8105 GETBYTE ();
8106 switch (op[2] & 0x00)
8107 {
8108 case 0x00:
8109 goto op_semantics_62;
8110 break;
8111 }
8112 break;
8113 case 0x87:
8114 GETBYTE ();
8115 switch (op[2] & 0x00)
8116 {
8117 case 0x00:
8118 goto op_semantics_62;
8119 break;
8120 }
8121 break;
8122 case 0x88:
8123 GETBYTE ();
8124 switch (op[2] & 0x00)
8125 {
8126 case 0x00:
8127 op_semantics_63:
8128 {
8129 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
78e98aab 8130#line 832 "rx-decode.opc"
c7927a3c 8131 int sd AU = op[1] & 0x03;
78e98aab 8132#line 832 "rx-decode.opc"
c7927a3c 8133 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 8134#line 832 "rx-decode.opc"
c7927a3c
NC		 8135 int rdst AU = op[2] & 0x0f;
8136 if (trace)
8137 {
8138 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8139 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8140 op[0], op[1], op[2]);
8141 printf (" sd = 0x%x,", sd);
8142 printf (" rsrc = 0x%x,", rsrc);
8143 printf (" rdst = 0x%x\n", rdst);
8144 }
8145 SYNTAX("fadd %1%S1, %0");
78e98aab 8146#line 832 "rx-decode.opc"
3cf79a01 8147 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8148
8149 }
8150 break;
8151 }
8152 break;
8153 case 0x89:
8154 GETBYTE ();
8155 switch (op[2] & 0x00)
8156 {
8157 case 0x00:
8158 goto op_semantics_63;
8159 break;
8160 }
8161 break;
8162 case 0x8a:
8163 GETBYTE ();
8164 switch (op[2] & 0x00)
8165 {
8166 case 0x00:
8167 goto op_semantics_63;
8168 break;
8169 }
8170 break;
8171 case 0x8b:
8172 GETBYTE ();
8173 switch (op[2] & 0x00)
8174 {
8175 case 0x00:
8176 goto op_semantics_63;
8177 break;
8178 }
8179 break;
8180 case 0x8c:
8181 GETBYTE ();
8182 switch (op[2] & 0x00)
8183 {
8184 case 0x00:
8185 op_semantics_64:
8186 {
8187 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
78e98aab 8188#line 853 "rx-decode.opc"
c7927a3c 8189 int sd AU = op[1] & 0x03;
78e98aab 8190#line 853 "rx-decode.opc"
c7927a3c 8191 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 8192#line 853 "rx-decode.opc"
c7927a3c
NC		 8193 int rdst AU = op[2] & 0x0f;
8194 if (trace)
8195 {
8196 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8197 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8198 op[0], op[1], op[2]);
8199 printf (" sd = 0x%x,", sd);
8200 printf (" rsrc = 0x%x,", rsrc);
8201 printf (" rdst = 0x%x\n", rdst);
8202 }
8203 SYNTAX("fmul %1%S1, %0");
78e98aab 8204#line 853 "rx-decode.opc"
3cf79a01 8205 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8206
8207 }
8208 break;
8209 }
8210 break;
8211 case 0x8d:
8212 GETBYTE ();
8213 switch (op[2] & 0x00)
8214 {
8215 case 0x00:
8216 goto op_semantics_64;
8217 break;
8218 }
8219 break;
8220 case 0x8e:
8221 GETBYTE ();
8222 switch (op[2] & 0x00)
8223 {
8224 case 0x00:
8225 goto op_semantics_64;
8226 break;
8227 }
8228 break;
8229 case 0x8f:
8230 GETBYTE ();
8231 switch (op[2] & 0x00)
8232 {
8233 case 0x00:
8234 goto op_semantics_64;
8235 break;
8236 }
8237 break;
8238 case 0x90:
8239 GETBYTE ();
8240 switch (op[2] & 0x00)
8241 {
8242 case 0x00:
8243 op_semantics_65:
8244 {
8245 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
78e98aab 8246#line 859 "rx-decode.opc"
c7927a3c 8247 int sd AU = op[1] & 0x03;
78e98aab 8248#line 859 "rx-decode.opc"
c7927a3c 8249 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 8250#line 859 "rx-decode.opc"
c7927a3c
NC		 8251 int rdst AU = op[2] & 0x0f;
8252 if (trace)
8253 {
8254 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8255 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8256 op[0], op[1], op[2]);
8257 printf (" sd = 0x%x,", sd);
8258 printf (" rsrc = 0x%x,", rsrc);
8259 printf (" rdst = 0x%x\n", rdst);
8260 }
8261 SYNTAX("fdiv %1%S1, %0");
78e98aab 8262#line 859 "rx-decode.opc"
3cf79a01 8263 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8264
8265 }
8266 break;
8267 }
8268 break;
8269 case 0x91:
8270 GETBYTE ();
8271 switch (op[2] & 0x00)
8272 {
8273 case 0x00:
8274 goto op_semantics_65;
8275 break;
8276 }
8277 break;
8278 case 0x92:
8279 GETBYTE ();
8280 switch (op[2] & 0x00)
8281 {
8282 case 0x00:
8283 goto op_semantics_65;
8284 break;
8285 }
8286 break;
8287 case 0x93:
8288 GETBYTE ();
8289 switch (op[2] & 0x00)
8290 {
8291 case 0x00:
8292 goto op_semantics_65;
8293 break;
8294 }
8295 break;
8296 case 0x94:
8297 GETBYTE ();
8298 switch (op[2] & 0x00)
8299 {
8300 case 0x00:
8301 op_semantics_66:
8302 {
8303 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
78e98aab 8304#line 847 "rx-decode.opc"
c7927a3c 8305 int sd AU = op[1] & 0x03;
78e98aab 8306#line 847 "rx-decode.opc"
c7927a3c 8307 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 8308#line 847 "rx-decode.opc"
c7927a3c
NC		 8309 int rdst AU = op[2] & 0x0f;
8310 if (trace)
8311 {
8312 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8313 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8314 op[0], op[1], op[2]);
8315 printf (" sd = 0x%x,", sd);
8316 printf (" rsrc = 0x%x,", rsrc);
8317 printf (" rdst = 0x%x\n", rdst);
8318 }
8319 SYNTAX("ftoi %1%S1, %0");
78e98aab 8320#line 847 "rx-decode.opc"
3cf79a01 8321 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8322
8323 }
8324 break;
8325 }
8326 break;
8327 case 0x95:
8328 GETBYTE ();
8329 switch (op[2] & 0x00)
8330 {
8331 case 0x00:
8332 goto op_semantics_66;
8333 break;
8334 }
8335 break;
8336 case 0x96:
8337 GETBYTE ();
8338 switch (op[2] & 0x00)
8339 {
8340 case 0x00:
8341 goto op_semantics_66;
8342 break;
8343 }
8344 break;
8345 case 0x97:
8346 GETBYTE ();
8347 switch (op[2] & 0x00)
8348 {
8349 case 0x00:
8350 goto op_semantics_66;
8351 break;
8352 }
8353 break;
8354 case 0x98:
8355 GETBYTE ();
8356 switch (op[2] & 0x00)
8357 {
8358 case 0x00:
8359 op_semantics_67:
8360 {
8361 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
78e98aab 8362#line 862 "rx-decode.opc"
c7927a3c 8363 int sd AU = op[1] & 0x03;
78e98aab 8364#line 862 "rx-decode.opc"
c7927a3c 8365 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 8366#line 862 "rx-decode.opc"
c7927a3c
NC		 8367 int rdst AU = op[2] & 0x0f;
8368 if (trace)
8369 {
8370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8371 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8372 op[0], op[1], op[2]);
8373 printf (" sd = 0x%x,", sd);
8374 printf (" rsrc = 0x%x,", rsrc);
8375 printf (" rdst = 0x%x\n", rdst);
8376 }
8377 SYNTAX("round %1%S1, %0");
78e98aab 8378#line 862 "rx-decode.opc"
3cf79a01 8379 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
c7927a3c
NC		 8380
8381 }
8382 break;
8383 }
8384 break;
8385 case 0x99:
8386 GETBYTE ();
8387 switch (op[2] & 0x00)
8388 {
8389 case 0x00:
8390 goto op_semantics_67;
8391 break;
8392 }
8393 break;
8394 case 0x9a:
8395 GETBYTE ();
8396 switch (op[2] & 0x00)
8397 {
8398 case 0x00:
8399 goto op_semantics_67;
8400 break;
8401 }
8402 break;
8403 case 0x9b:
8404 GETBYTE ();
8405 switch (op[2] & 0x00)
8406 {
8407 case 0x00:
8408 goto op_semantics_67;
8409 break;
8410 }
8411 break;
8412 case 0xd0:
8413 GETBYTE ();
8414 switch (op[2] & 0x00)
8415 {
8416 case 0x00:
8417 op_semantics_68:
8418 {
8419 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
78e98aab 8420#line 971 "rx-decode.opc"
c7927a3c 8421 int sz AU = (op[1] >> 2) & 0x03;
78e98aab 8422#line 971 "rx-decode.opc"
c7927a3c 8423 int sd AU = op[1] & 0x03;
78e98aab 8424#line 971 "rx-decode.opc"
c7927a3c 8425 int rdst AU = (op[2] >> 4) & 0x0f;
78e98aab 8426#line 971 "rx-decode.opc"
c7927a3c
NC		 8427 int cond AU = op[2] & 0x0f;
8428 if (trace)
8429 {
8430 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8431 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8432 op[0], op[1], op[2]);
8433 printf (" sz = 0x%x,", sz);
8434 printf (" sd = 0x%x,", sd);
8435 printf (" rdst = 0x%x,", rdst);
8436 printf (" cond = 0x%x\n", cond);
8437 }
8438 SYNTAX("sc%1%s %0");
78e98aab 8439#line 971 "rx-decode.opc"
c7927a3c
NC		 8440 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8441
8442 }
8443 break;
8444 }
8445 break;
8446 case 0xd1:
8447 GETBYTE ();
8448 switch (op[2] & 0x00)
8449 {
8450 case 0x00:
8451 goto op_semantics_68;
8452 break;
8453 }
8454 break;
8455 case 0xd2:
8456 GETBYTE ();
8457 switch (op[2] & 0x00)
8458 {
8459 case 0x00:
8460 goto op_semantics_68;
8461 break;
8462 }
8463 break;
8464 case 0xd3:
8465 GETBYTE ();
8466 switch (op[2] & 0x00)
8467 {
8468 case 0x00:
8469 goto op_semantics_68;
8470 break;
8471 }
8472 break;
8473 case 0xd4:
8474 GETBYTE ();
8475 switch (op[2] & 0x00)
8476 {
8477 case 0x00:
8478 goto op_semantics_68;
8479 break;
8480 }
8481 break;
8482 case 0xd5:
8483 GETBYTE ();
8484 switch (op[2] & 0x00)
8485 {
8486 case 0x00:
8487 goto op_semantics_68;
8488 break;
8489 }
8490 break;
8491 case 0xd6:
8492 GETBYTE ();
8493 switch (op[2] & 0x00)
8494 {
8495 case 0x00:
8496 goto op_semantics_68;
8497 break;
8498 }
8499 break;
8500 case 0xd7:
8501 GETBYTE ();
8502 switch (op[2] & 0x00)
8503 {
8504 case 0x00:
8505 goto op_semantics_68;
8506 break;
8507 }
8508 break;
8509 case 0xd8:
8510 GETBYTE ();
8511 switch (op[2] & 0x00)
8512 {
8513 case 0x00:
8514 goto op_semantics_68;
8515 break;
8516 }
8517 break;
8518 case 0xd9:
8519 GETBYTE ();
8520 switch (op[2] & 0x00)
8521 {
8522 case 0x00:
8523 goto op_semantics_68;
8524 break;
8525 }
8526 break;
8527 case 0xda:
8528 GETBYTE ();
8529 switch (op[2] & 0x00)
8530 {
8531 case 0x00:
8532 goto op_semantics_68;
8533 break;
8534 }
8535 break;
8536 case 0xdb:
8537 GETBYTE ();
8538 switch (op[2] & 0x00)
8539 {
8540 case 0x00:
8541 goto op_semantics_68;
8542 break;
8543 }
8544 break;
8545 case 0xe0:
8546 GETBYTE ();
8547 switch (op[2] & 0x0f)
8548 {
8549 case 0x00:
8550 case 0x01:
8551 case 0x02:
8552 case 0x03:
8553 case 0x04:
8554 case 0x05:
8555 case 0x06:
8556 case 0x07:
8557 case 0x08:
8558 case 0x09:
8559 case 0x0a:
8560 case 0x0b:
8561 case 0x0c:
8562 case 0x0d:
8563 case 0x0e:
8564 op_semantics_69:
8565 {
8566 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
78e98aab 8567#line 914 "rx-decode.opc"
c7927a3c 8568 int bit AU = (op[1] >> 2) & 0x07;
78e98aab 8569#line 914 "rx-decode.opc"
c7927a3c 8570 int sd AU = op[1] & 0x03;
78e98aab 8571#line 914 "rx-decode.opc"
c7927a3c 8572 int rdst AU = (op[2] >> 4) & 0x0f;
78e98aab 8573#line 914 "rx-decode.opc"
c7927a3c
NC		 8574 int cond AU = op[2] & 0x0f;
8575 if (trace)
8576 {
8577 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8578 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8579 op[0], op[1], op[2]);
8580 printf (" bit = 0x%x,", bit);
8581 printf (" sd = 0x%x,", sd);
8582 printf (" rdst = 0x%x,", rdst);
8583 printf (" cond = 0x%x\n", cond);
8584 }
8585 SYNTAX("bm%2 #%1, %0%S0");
78e98aab 8586#line 914 "rx-decode.opc"
c7927a3c
NC		 8587 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8588
8589 }
8590 break;
8591 case 0x0f:
8592 op_semantics_70:
8593 {
8594 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
78e98aab 8595#line 904 "rx-decode.opc"
c7927a3c 8596 int bit AU = (op[1] >> 2) & 0x07;
78e98aab 8597#line 904 "rx-decode.opc"
c7927a3c 8598 int sd AU = op[1] & 0x03;
78e98aab 8599#line 904 "rx-decode.opc"
c7927a3c
NC		 8600 int rdst AU = (op[2] >> 4) & 0x0f;
8601 if (trace)
8602 {
8603 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8604 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8605 op[0], op[1], op[2]);
8606 printf (" bit = 0x%x,", bit);
8607 printf (" sd = 0x%x,", sd);
8608 printf (" rdst = 0x%x\n", rdst);
8609 }
8610 SYNTAX("bnot #%1, %0%S0");
78e98aab 8611#line 904 "rx-decode.opc"
c7927a3c
NC		 8612 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8613
8614 }
8615 break;
8616 }
8617 break;
8618 case 0xe1:
8619 GETBYTE ();
8620 switch (op[2] & 0x0f)
8621 {
8622 case 0x00:
8623 case 0x01:
8624 case 0x02:
8625 case 0x03:
8626 case 0x04:
8627 case 0x05:
8628 case 0x06:
8629 case 0x07:
8630 case 0x08:
8631 case 0x09:
8632 case 0x0a:
8633 case 0x0b:
8634 case 0x0c:
8635 case 0x0d:
8636 case 0x0e:
8637 goto op_semantics_69;
8638 break;
8639 case 0x0f:
8640 goto op_semantics_70;
8641 break;
8642 }
8643 break;
8644 case 0xe2:
8645 GETBYTE ();
8646 switch (op[2] & 0x0f)
8647 {
8648 case 0x00:
8649 case 0x01:
8650 case 0x02:
8651 case 0x03:
8652 case 0x04:
8653 case 0x05:
8654 case 0x06:
8655 case 0x07:
8656 case 0x08:
8657 case 0x09:
8658 case 0x0a:
8659 case 0x0b:
8660 case 0x0c:
8661 case 0x0d:
8662 case 0x0e:
8663 goto op_semantics_69;
8664 break;
8665 case 0x0f:
8666 goto op_semantics_70;
8667 break;
8668 }
8669 break;
8670 case 0xe3:
8671 GETBYTE ();
8672 switch (op[2] & 0x0f)
8673 {
8674 case 0x00:
8675 case 0x01:
8676 case 0x02:
8677 case 0x03:
8678 case 0x04:
8679 case 0x05:
8680 case 0x06:
8681 case 0x07:
8682 case 0x08:
8683 case 0x09:
8684 case 0x0a:
8685 case 0x0b:
8686 case 0x0c:
8687 case 0x0d:
8688 case 0x0e:
8689 goto op_semantics_69;
8690 break;
8691 case 0x0f:
8692 goto op_semantics_70;
8693 break;
8694 }
8695 break;
8696 case 0xe4:
8697 GETBYTE ();
8698 switch (op[2] & 0x0f)
8699 {
8700 case 0x00:
8701 case 0x01:
8702 case 0x02:
8703 case 0x03:
8704 case 0x04:
8705 case 0x05:
8706 case 0x06:
8707 case 0x07:
8708 case 0x08:
8709 case 0x09:
8710 case 0x0a:
8711 case 0x0b:
8712 case 0x0c:
8713 case 0x0d:
8714 case 0x0e:
8715 goto op_semantics_69;
8716 break;
8717 case 0x0f:
8718 goto op_semantics_70;
8719 break;
8720 }
8721 break;
8722 case 0xe5:
8723 GETBYTE ();
8724 switch (op[2] & 0x0f)
8725 {
8726 case 0x00:
8727 case 0x01:
8728 case 0x02:
8729 case 0x03:
8730 case 0x04:
8731 case 0x05:
8732 case 0x06:
8733 case 0x07:
8734 case 0x08:
8735 case 0x09:
8736 case 0x0a:
8737 case 0x0b:
8738 case 0x0c:
8739 case 0x0d:
8740 case 0x0e:
8741 goto op_semantics_69;
8742 break;
8743 case 0x0f:
8744 goto op_semantics_70;
8745 break;
8746 }
8747 break;
8748 case 0xe6:
8749 GETBYTE ();
8750 switch (op[2] & 0x0f)
8751 {
8752 case 0x00:
8753 case 0x01:
8754 case 0x02:
8755 case 0x03:
8756 case 0x04:
8757 case 0x05:
8758 case 0x06:
8759 case 0x07:
8760 case 0x08:
8761 case 0x09:
8762 case 0x0a:
8763 case 0x0b:
8764 case 0x0c:
8765 case 0x0d:
8766 case 0x0e:
8767 goto op_semantics_69;
8768 break;
8769 case 0x0f:
8770 goto op_semantics_70;
8771 break;
8772 }
8773 break;
8774 case 0xe7:
8775 GETBYTE ();
8776 switch (op[2] & 0x0f)
8777 {
8778 case 0x00:
8779 case 0x01:
8780 case 0x02:
8781 case 0x03:
8782 case 0x04:
8783 case 0x05:
8784 case 0x06:
8785 case 0x07:
8786 case 0x08:
8787 case 0x09:
8788 case 0x0a:
8789 case 0x0b:
8790 case 0x0c:
8791 case 0x0d:
8792 case 0x0e:
8793 goto op_semantics_69;
8794 break;
8795 case 0x0f:
8796 goto op_semantics_70;
8797 break;
8798 }
8799 break;
8800 case 0xe8:
8801 GETBYTE ();
8802 switch (op[2] & 0x0f)
8803 {
8804 case 0x00:
8805 case 0x01:
8806 case 0x02:
8807 case 0x03:
8808 case 0x04:
8809 case 0x05:
8810 case 0x06:
8811 case 0x07:
8812 case 0x08:
8813 case 0x09:
8814 case 0x0a:
8815 case 0x0b:
8816 case 0x0c:
8817 case 0x0d:
8818 case 0x0e:
8819 goto op_semantics_69;
8820 break;
8821 case 0x0f:
8822 goto op_semantics_70;
8823 break;
8824 }
8825 break;
8826 case 0xe9:
8827 GETBYTE ();
8828 switch (op[2] & 0x0f)
8829 {
8830 case 0x00:
8831 case 0x01:
8832 case 0x02:
8833 case 0x03:
8834 case 0x04:
8835 case 0x05:
8836 case 0x06:
8837 case 0x07:
8838 case 0x08:
8839 case 0x09:
8840 case 0x0a:
8841 case 0x0b:
8842 case 0x0c:
8843 case 0x0d:
8844 case 0x0e:
8845 goto op_semantics_69;
8846 break;
8847 case 0x0f:
8848 goto op_semantics_70;
8849 break;
8850 }
8851 break;
8852 case 0xea:
8853 GETBYTE ();
8854 switch (op[2] & 0x0f)
8855 {
8856 case 0x00:
8857 case 0x01:
8858 case 0x02:
8859 case 0x03:
8860 case 0x04:
8861 case 0x05:
8862 case 0x06:
8863 case 0x07:
8864 case 0x08:
8865 case 0x09:
8866 case 0x0a:
8867 case 0x0b:
8868 case 0x0c:
8869 case 0x0d:
8870 case 0x0e:
8871 goto op_semantics_69;
8872 break;
8873 case 0x0f:
8874 goto op_semantics_70;
8875 break;
8876 }
8877 break;
8878 case 0xeb:
8879 GETBYTE ();
8880 switch (op[2] & 0x0f)
8881 {
8882 case 0x00:
8883 case 0x01:
8884 case 0x02:
8885 case 0x03:
8886 case 0x04:
8887 case 0x05:
8888 case 0x06:
8889 case 0x07:
8890 case 0x08:
8891 case 0x09:
8892 case 0x0a:
8893 case 0x0b:
8894 case 0x0c:
8895 case 0x0d:
8896 case 0x0e:
8897 goto op_semantics_69;
8898 break;
8899 case 0x0f:
8900 goto op_semantics_70;
8901 break;
8902 }
8903 break;
8904 case 0xec:
8905 GETBYTE ();
8906 switch (op[2] & 0x0f)
8907 {
8908 case 0x00:
8909 case 0x01:
8910 case 0x02:
8911 case 0x03:
8912 case 0x04:
8913 case 0x05:
8914 case 0x06:
8915 case 0x07:
8916 case 0x08:
8917 case 0x09:
8918 case 0x0a:
8919 case 0x0b:
8920 case 0x0c:
8921 case 0x0d:
8922 case 0x0e:
8923 goto op_semantics_69;
8924 break;
8925 case 0x0f:
8926 goto op_semantics_70;
8927 break;
8928 }
8929 break;
8930 case 0xed:
8931 GETBYTE ();
8932 switch (op[2] & 0x0f)
8933 {
8934 case 0x00:
8935 case 0x01:
8936 case 0x02:
8937 case 0x03:
8938 case 0x04:
8939 case 0x05:
8940 case 0x06:
8941 case 0x07:
8942 case 0x08:
8943 case 0x09:
8944 case 0x0a:
8945 case 0x0b:
8946 case 0x0c:
8947 case 0x0d:
8948 case 0x0e:
8949 goto op_semantics_69;
8950 break;
8951 case 0x0f:
8952 goto op_semantics_70;
8953 break;
8954 }
8955 break;
8956 case 0xee:
8957 GETBYTE ();
8958 switch (op[2] & 0x0f)
8959 {
8960 case 0x00:
8961 case 0x01:
8962 case 0x02:
8963 case 0x03:
8964 case 0x04:
8965 case 0x05:
8966 case 0x06:
8967 case 0x07:
8968 case 0x08:
8969 case 0x09:
8970 case 0x0a:
8971 case 0x0b:
8972 case 0x0c:
8973 case 0x0d:
8974 case 0x0e:
8975 goto op_semantics_69;
8976 break;
8977 case 0x0f:
8978 goto op_semantics_70;
8979 break;
8980 }
8981 break;
8982 case 0xef:
8983 GETBYTE ();
8984 switch (op[2] & 0x0f)
8985 {
8986 case 0x00:
8987 case 0x01:
8988 case 0x02:
8989 case 0x03:
8990 case 0x04:
8991 case 0x05:
8992 case 0x06:
8993 case 0x07:
8994 case 0x08:
8995 case 0x09:
8996 case 0x0a:
8997 case 0x0b:
8998 case 0x0c:
8999 case 0x0d:
9000 case 0x0e:
9001 goto op_semantics_69;
9002 break;
9003 case 0x0f:
9004 goto op_semantics_70;
9005 break;
9006 }
9007 break;
9008 case 0xf0:
9009 GETBYTE ();
9010 switch (op[2] & 0x0f)
9011 {
9012 case 0x00:
9013 case 0x01:
9014 case 0x02:
9015 case 0x03:
9016 case 0x04:
9017 case 0x05:
9018 case 0x06:
9019 case 0x07:
9020 case 0x08:
9021 case 0x09:
9022 case 0x0a:
9023 case 0x0b:
9024 case 0x0c:
9025 case 0x0d:
9026 case 0x0e:
9027 goto op_semantics_69;
9028 break;
9029 case 0x0f:
9030 goto op_semantics_70;
9031 break;
9032 }
9033 break;
9034 case 0xf1:
9035 GETBYTE ();
9036 switch (op[2] & 0x0f)
9037 {
9038 case 0x00:
9039 case 0x01:
9040 case 0x02:
9041 case 0x03:
9042 case 0x04:
9043 case 0x05:
9044 case 0x06:
9045 case 0x07:
9046 case 0x08:
9047 case 0x09:
9048 case 0x0a:
9049 case 0x0b:
9050 case 0x0c:
9051 case 0x0d:
9052 case 0x0e:
9053 goto op_semantics_69;
9054 break;
9055 case 0x0f:
9056 goto op_semantics_70;
9057 break;
9058 }
9059 break;
9060 case 0xf2:
9061 GETBYTE ();
9062 switch (op[2] & 0x0f)
9063 {
9064 case 0x00:
9065 case 0x01:
9066 case 0x02:
9067 case 0x03:
9068 case 0x04:
9069 case 0x05:
9070 case 0x06:
9071 case 0x07:
9072 case 0x08:
9073 case 0x09:
9074 case 0x0a:
9075 case 0x0b:
9076 case 0x0c:
9077 case 0x0d:
9078 case 0x0e:
9079 goto op_semantics_69;
9080 break;
9081 case 0x0f:
9082 goto op_semantics_70;
9083 break;
9084 }
9085 break;
9086 case 0xf3:
9087 GETBYTE ();
9088 switch (op[2] & 0x0f)
9089 {
9090 case 0x00:
9091 case 0x01:
9092 case 0x02:
9093 case 0x03:
9094 case 0x04:
9095 case 0x05:
9096 case 0x06:
9097 case 0x07:
9098 case 0x08:
9099 case 0x09:
9100 case 0x0a:
9101 case 0x0b:
9102 case 0x0c:
9103 case 0x0d:
9104 case 0x0e:
9105 goto op_semantics_69;
9106 break;
9107 case 0x0f:
9108 goto op_semantics_70;
9109 break;
9110 }
9111 break;
9112 case 0xf4:
9113 GETBYTE ();
9114 switch (op[2] & 0x0f)
9115 {
9116 case 0x00:
9117 case 0x01:
9118 case 0x02:
9119 case 0x03:
9120 case 0x04:
9121 case 0x05:
9122 case 0x06:
9123 case 0x07:
9124 case 0x08:
9125 case 0x09:
9126 case 0x0a:
9127 case 0x0b:
9128 case 0x0c:
9129 case 0x0d:
9130 case 0x0e:
9131 goto op_semantics_69;
9132 break;
9133 case 0x0f:
9134 goto op_semantics_70;
9135 break;
9136 }
9137 break;
9138 case 0xf5:
9139 GETBYTE ();
9140 switch (op[2] & 0x0f)
9141 {
9142 case 0x00:
9143 case 0x01:
9144 case 0x02:
9145 case 0x03:
9146 case 0x04:
9147 case 0x05:
9148 case 0x06:
9149 case 0x07:
9150 case 0x08:
9151 case 0x09:
9152 case 0x0a:
9153 case 0x0b:
9154 case 0x0c:
9155 case 0x0d:
9156 case 0x0e:
9157 goto op_semantics_69;
9158 break;
9159 case 0x0f:
9160 goto op_semantics_70;
9161 break;
9162 }
9163 break;
9164 case 0xf6:
9165 GETBYTE ();
9166 switch (op[2] & 0x0f)
9167 {
9168 case 0x00:
9169 case 0x01:
9170 case 0x02:
9171 case 0x03:
9172 case 0x04:
9173 case 0x05:
9174 case 0x06:
9175 case 0x07:
9176 case 0x08:
9177 case 0x09:
9178 case 0x0a:
9179 case 0x0b:
9180 case 0x0c:
9181 case 0x0d:
9182 case 0x0e:
9183 goto op_semantics_69;
9184 break;
9185 case 0x0f:
9186 goto op_semantics_70;
9187 break;
9188 }
9189 break;
9190 case 0xf7:
9191 GETBYTE ();
9192 switch (op[2] & 0x0f)
9193 {
9194 case 0x00:
9195 case 0x01:
9196 case 0x02:
9197 case 0x03:
9198 case 0x04:
9199 case 0x05:
9200 case 0x06:
9201 case 0x07:
9202 case 0x08:
9203 case 0x09:
9204 case 0x0a:
9205 case 0x0b:
9206 case 0x0c:
9207 case 0x0d:
9208 case 0x0e:
9209 goto op_semantics_69;
9210 break;
9211 case 0x0f:
9212 goto op_semantics_70;
9213 break;
9214 }
9215 break;
9216 case 0xf8:
9217 GETBYTE ();
9218 switch (op[2] & 0x0f)
9219 {
9220 case 0x00:
9221 case 0x01:
9222 case 0x02:
9223 case 0x03:
9224 case 0x04:
9225 case 0x05:
9226 case 0x06:
9227 case 0x07:
9228 case 0x08:
9229 case 0x09:
9230 case 0x0a:
9231 case 0x0b:
9232 case 0x0c:
9233 case 0x0d:
9234 case 0x0e:
9235 goto op_semantics_69;
9236 break;
9237 case 0x0f:
9238 goto op_semantics_70;
9239 break;
9240 }
9241 break;
9242 case 0xf9:
9243 GETBYTE ();
9244 switch (op[2] & 0x0f)
9245 {
9246 case 0x00:
9247 case 0x01:
9248 case 0x02:
9249 case 0x03:
9250 case 0x04:
9251 case 0x05:
9252 case 0x06:
9253 case 0x07:
9254 case 0x08:
9255 case 0x09:
9256 case 0x0a:
9257 case 0x0b:
9258 case 0x0c:
9259 case 0x0d:
9260 case 0x0e:
9261 goto op_semantics_69;
9262 break;
9263 case 0x0f:
9264 goto op_semantics_70;
9265 break;
9266 }
9267 break;
9268 case 0xfa:
9269 GETBYTE ();
9270 switch (op[2] & 0x0f)
9271 {
9272 case 0x00:
9273 case 0x01:
9274 case 0x02:
9275 case 0x03:
9276 case 0x04:
9277 case 0x05:
9278 case 0x06:
9279 case 0x07:
9280 case 0x08:
9281 case 0x09:
9282 case 0x0a:
9283 case 0x0b:
9284 case 0x0c:
9285 case 0x0d:
9286 case 0x0e:
9287 goto op_semantics_69;
9288 break;
9289 case 0x0f:
9290 goto op_semantics_70;
9291 break;
9292 }
9293 break;
9294 case 0xfb:
9295 GETBYTE ();
9296 switch (op[2] & 0x0f)
9297 {
9298 case 0x00:
9299 case 0x01:
9300 case 0x02:
9301 case 0x03:
9302 case 0x04:
9303 case 0x05:
9304 case 0x06:
9305 case 0x07:
9306 case 0x08:
9307 case 0x09:
9308 case 0x0a:
9309 case 0x0b:
9310 case 0x0c:
9311 case 0x0d:
9312 case 0x0e:
9313 goto op_semantics_69;
9314 break;
9315 case 0x0f:
9316 goto op_semantics_70;
9317 break;
9318 }
9319 break;
9320 case 0xfc:
9321 GETBYTE ();
9322 switch (op[2] & 0x0f)
9323 {
9324 case 0x00:
9325 case 0x01:
9326 case 0x02:
9327 case 0x03:
9328 case 0x04:
9329 case 0x05:
9330 case 0x06:
9331 case 0x07:
9332 case 0x08:
9333 case 0x09:
9334 case 0x0a:
9335 case 0x0b:
9336 case 0x0c:
9337 case 0x0d:
9338 case 0x0e:
9339 goto op_semantics_69;
9340 break;
9341 case 0x0f:
9342 goto op_semantics_70;
9343 break;
9344 }
9345 break;
9346 case 0xfd:
9347 GETBYTE ();
9348 switch (op[2] & 0x0f)
9349 {
9350 case 0x00:
9351 case 0x01:
9352 case 0x02:
9353 case 0x03:
9354 case 0x04:
9355 case 0x05:
9356 case 0x06:
9357 case 0x07:
9358 case 0x08:
9359 case 0x09:
9360 case 0x0a:
9361 case 0x0b:
9362 case 0x0c:
9363 case 0x0d:
9364 case 0x0e:
9365 goto op_semantics_69;
9366 break;
9367 case 0x0f:
9368 goto op_semantics_70;
9369 break;
9370 }
9371 break;
9372 case 0xfe:
9373 GETBYTE ();
9374 switch (op[2] & 0x0f)
9375 {
9376 case 0x00:
9377 case 0x01:
9378 case 0x02:
9379 case 0x03:
9380 case 0x04:
9381 case 0x05:
9382 case 0x06:
9383 case 0x07:
9384 case 0x08:
9385 case 0x09:
9386 case 0x0a:
9387 case 0x0b:
9388 case 0x0c:
9389 case 0x0d:
9390 case 0x0e:
9391 goto op_semantics_69;
9392 break;
9393 case 0x0f:
9394 goto op_semantics_70;
9395 break;
9396 }
9397 break;
9398 case 0xff:
9399 GETBYTE ();
9400 switch (op[2] & 0x0f)
9401 {
9402 case 0x00:
9403 case 0x01:
9404 case 0x02:
9405 case 0x03:
9406 case 0x04:
9407 case 0x05:
9408 case 0x06:
9409 case 0x07:
9410 case 0x08:
9411 case 0x09:
9412 case 0x0a:
9413 case 0x0b:
9414 case 0x0c:
9415 case 0x0d:
9416 case 0x0e:
9417 goto op_semantics_69;
9418 break;
9419 case 0x0f:
9420 goto op_semantics_70;
9421 break;
9422 }
9423 break;
9424 default: UNSUPPORTED(); break;
9425 }
9426 break;
9427 case 0xfd:
9428 GETBYTE ();
9429 switch (op[1] & 0xff)
9430 {
9431 case 0x00:
9432 GETBYTE ();
9433 switch (op[2] & 0x00)
9434 {
9435 case 0x00:
9436 {
9437 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
78e98aab 9438#line 787 "rx-decode.opc"
c7927a3c 9439 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 9440#line 787 "rx-decode.opc"
c7927a3c
NC		 9441 int srcb AU = op[2] & 0x0f;
9442 if (trace)
9443 {
9444 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9445 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9446 op[0], op[1], op[2]);
9447 printf (" srca = 0x%x,", srca);
9448 printf (" srcb = 0x%x\n", srcb);
9449 }
9450 SYNTAX("mulhi %1, %2");
78e98aab 9451#line 787 "rx-decode.opc"
3cf79a01 9452 ID(mulhi); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9453
9454 }
9455 break;
9456 }
9457 break;
9458 case 0x01:
9459 GETBYTE ();
9460 switch (op[2] & 0x00)
9461 {
9462 case 0x00:
9463 {
9464 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
78e98aab 9465#line 790 "rx-decode.opc"
c7927a3c 9466 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 9467#line 790 "rx-decode.opc"
c7927a3c
NC		 9468 int srcb AU = op[2] & 0x0f;
9469 if (trace)
9470 {
9471 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9472 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9473 op[0], op[1], op[2]);
9474 printf (" srca = 0x%x,", srca);
9475 printf (" srcb = 0x%x\n", srcb);
9476 }
9477 SYNTAX("mullo %1, %2");
78e98aab 9478#line 790 "rx-decode.opc"
3cf79a01 9479 ID(mullo); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9480
9481 }
9482 break;
9483 }
9484 break;
9485 case 0x04:
9486 GETBYTE ();
9487 switch (op[2] & 0x00)
9488 {
9489 case 0x00:
9490 {
9491 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
78e98aab 9492#line 793 "rx-decode.opc"
c7927a3c 9493 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 9494#line 793 "rx-decode.opc"
c7927a3c
NC		 9495 int srcb AU = op[2] & 0x0f;
9496 if (trace)
9497 {
9498 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9499 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9500 op[0], op[1], op[2]);
9501 printf (" srca = 0x%x,", srca);
9502 printf (" srcb = 0x%x\n", srcb);
9503 }
9504 SYNTAX("machi %1, %2");
78e98aab 9505#line 793 "rx-decode.opc"
3cf79a01 9506 ID(machi); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9507
9508 }
9509 break;
9510 }
9511 break;
9512 case 0x05:
9513 GETBYTE ();
9514 switch (op[2] & 0x00)
9515 {
9516 case 0x00:
9517 {
9518 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
78e98aab 9519#line 796 "rx-decode.opc"
c7927a3c 9520 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 9521#line 796 "rx-decode.opc"
c7927a3c
NC		 9522 int srcb AU = op[2] & 0x0f;
9523 if (trace)
9524 {
9525 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9526 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9527 op[0], op[1], op[2]);
9528 printf (" srca = 0x%x,", srca);
9529 printf (" srcb = 0x%x\n", srcb);
9530 }
9531 SYNTAX("maclo %1, %2");
78e98aab 9532#line 796 "rx-decode.opc"
3cf79a01 9533 ID(maclo); SR(srca); S2R(srcb); F_____;
c7927a3c
NC		 9534
9535 }
9536 break;
9537 }
9538 break;
9539 case 0x17:
9540 GETBYTE ();
9541 switch (op[2] & 0xf0)
9542 {
9543 case 0x00:
9544 {
9545 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
78e98aab 9546#line 799 "rx-decode.opc"
c7927a3c
NC		 9547 int rsrc AU = op[2] & 0x0f;
9548 if (trace)
9549 {
9550 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9551 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9552 op[0], op[1], op[2]);
9553 printf (" rsrc = 0x%x\n", rsrc);
9554 }
9555 SYNTAX("mvtachi %1");
78e98aab 9556#line 799 "rx-decode.opc"
3cf79a01 9557 ID(mvtachi); SR(rsrc); F_____;
c7927a3c
NC		 9558
9559 }
9560 break;
9561 case 0x10:
9562 {
9563 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
78e98aab 9564#line 802 "rx-decode.opc"
c7927a3c
NC		 9565 int rsrc AU = op[2] & 0x0f;
9566 if (trace)
9567 {
9568 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9569 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9570 op[0], op[1], op[2]);
9571 printf (" rsrc = 0x%x\n", rsrc);
9572 }
9573 SYNTAX("mvtaclo %1");
78e98aab 9574#line 802 "rx-decode.opc"
3cf79a01 9575 ID(mvtaclo); SR(rsrc); F_____;
c7927a3c
NC		 9576
9577 }
9578 break;
9579 default: UNSUPPORTED(); break;
9580 }
9581 break;
9582 case 0x18:
9583 GETBYTE ();
9584 switch (op[2] & 0xef)
9585 {
9586 case 0x00:
9587 {
9588 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
78e98aab 9589#line 814 "rx-decode.opc"
c7927a3c
NC		 9590 int i AU = (op[2] >> 4) & 0x01;
9591 if (trace)
9592 {
9593 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9594 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9595 op[0], op[1], op[2]);
9596 printf (" i = 0x%x\n", i);
9597 }
9598 SYNTAX("racw #%1");
78e98aab 9599#line 814 "rx-decode.opc"
3cf79a01 9600 ID(racw); SC(i+1); F_____;
c7927a3c
NC		 9601
9602 /*----------------------------------------------------------------------*/
9603 /* SAT */
9604
9605 }
9606 break;
9607 default: UNSUPPORTED(); break;
9608 }
9609 break;
9610 case 0x1f:
9611 GETBYTE ();
9612 switch (op[2] & 0xf0)
9613 {
9614 case 0x00:
9615 {
9616 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
78e98aab 9617#line 805 "rx-decode.opc"
c7927a3c
NC		 9618 int rdst AU = op[2] & 0x0f;
9619 if (trace)
9620 {
9621 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9622 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9623 op[0], op[1], op[2]);
9624 printf (" rdst = 0x%x\n", rdst);
9625 }
9626 SYNTAX("mvfachi %0");
78e98aab 9627#line 805 "rx-decode.opc"
3cf79a01 9628 ID(mvfachi); DR(rdst); F_____;
c7927a3c
NC		 9629
9630 }
9631 break;
9632 case 0x10:
9633 {
9634 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
78e98aab 9635#line 811 "rx-decode.opc"
c7927a3c
NC		 9636 int rdst AU = op[2] & 0x0f;
9637 if (trace)
9638 {
9639 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9640 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9641 op[0], op[1], op[2]);
9642 printf (" rdst = 0x%x\n", rdst);
9643 }
9644 SYNTAX("mvfaclo %0");
78e98aab 9645#line 811 "rx-decode.opc"
3cf79a01 9646 ID(mvfaclo); DR(rdst); F_____;
c7927a3c
NC		 9647
9648 }
9649 break;
9650 case 0x20:
9651 {
9652 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
78e98aab 9653#line 808 "rx-decode.opc"
c7927a3c
NC		 9654 int rdst AU = op[2] & 0x0f;
9655 if (trace)
9656 {
9657 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9658 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9659 op[0], op[1], op[2]);
9660 printf (" rdst = 0x%x\n", rdst);
9661 }
9662 SYNTAX("mvfacmi %0");
78e98aab 9663#line 808 "rx-decode.opc"
3cf79a01 9664 ID(mvfacmi); DR(rdst); F_____;
c7927a3c
NC		 9665
9666 }
9667 break;
9668 default: UNSUPPORTED(); break;
9669 }
9670 break;
9671 case 0x20:
9672 GETBYTE ();
9673 switch (op[2] & 0x00)
9674 {
9675 case 0x00:
9676 op_semantics_71:
9677 {
9678 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
78e98aab 9679#line 321 "rx-decode.opc"
c7927a3c 9680 int p AU = (op[1] >> 2) & 0x01;
78e98aab 9681#line 321 "rx-decode.opc"
c7927a3c 9682 int sz AU = op[1] & 0x03;
78e98aab 9683#line 321 "rx-decode.opc"
c7927a3c 9684 int rdst AU = (op[2] >> 4) & 0x0f;
78e98aab 9685#line 321 "rx-decode.opc"
c7927a3c
NC		 9686 int rsrc AU = op[2] & 0x0f;
9687 if (trace)
9688 {
9689 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9690 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9691 op[0], op[1], op[2]);
9692 printf (" p = 0x%x,", p);
9693 printf (" sz = 0x%x,", sz);
9694 printf (" rdst = 0x%x,", rdst);
9695 printf (" rsrc = 0x%x\n", rsrc);
9696 }
9697 SYNTAX("mov%s %1, %0");
78e98aab 9698#line 321 "rx-decode.opc"
3cf79a01 9699 ID(mov); sBWL (sz); SR(rsrc); F_____;
c7927a3c
NC		 9700 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9701
9702 }
9703 break;
9704 }
9705 break;
9706 case 0x21:
9707 GETBYTE ();
9708 switch (op[2] & 0x00)
9709 {
9710 case 0x00:
9711 goto op_semantics_71;
9712 break;
9713 }
9714 break;
9715 case 0x22:
9716 GETBYTE ();
9717 switch (op[2] & 0x00)
9718 {
9719 case 0x00:
9720 goto op_semantics_71;
9721 break;
9722 }
9723 break;
9724 case 0x24:
9725 GETBYTE ();
9726 switch (op[2] & 0x00)
9727 {
9728 case 0x00:
9729 goto op_semantics_71;
9730 break;
9731 }
9732 break;
9733 case 0x25:
9734 GETBYTE ();
9735 switch (op[2] & 0x00)
9736 {
9737 case 0x00:
9738 goto op_semantics_71;
9739 break;
9740 }
9741 break;
9742 case 0x26:
9743 GETBYTE ();
9744 switch (op[2] & 0x00)
9745 {
9746 case 0x00:
9747 goto op_semantics_71;
9748 break;
9749 }
9750 break;
9751 case 0x28:
9752 GETBYTE ();
9753 switch (op[2] & 0x00)
9754 {
9755 case 0x00:
9756 op_semantics_72:
9757 {
9758 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
78e98aab 9759#line 325 "rx-decode.opc"
c7927a3c 9760 int p AU = (op[1] >> 2) & 0x01;
78e98aab 9761#line 325 "rx-decode.opc"
c7927a3c 9762 int sz AU = op[1] & 0x03;
78e98aab 9763#line 325 "rx-decode.opc"
c7927a3c 9764 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 9765#line 325 "rx-decode.opc"
c7927a3c
NC		 9766 int rdst AU = op[2] & 0x0f;
9767 if (trace)
9768 {
9769 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9770 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9771 op[0], op[1], op[2]);
9772 printf (" p = 0x%x,", p);
9773 printf (" sz = 0x%x,", sz);
9774 printf (" rsrc = 0x%x,", rsrc);
9775 printf (" rdst = 0x%x\n", rdst);
9776 }
9777 SYNTAX("mov%s %1, %0");
78e98aab 9778#line 325 "rx-decode.opc"
3cf79a01 9779 ID(mov); sBWL (sz); DR(rdst); F_____;
c7927a3c
NC		 9780 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9781
9782 }
9783 break;
9784 }
9785 break;
9786 case 0x29:
9787 GETBYTE ();
9788 switch (op[2] & 0x00)
9789 {
9790 case 0x00:
9791 goto op_semantics_72;
9792 break;
9793 }
9794 break;
9795 case 0x2a:
9796 GETBYTE ();
9797 switch (op[2] & 0x00)
9798 {
9799 case 0x00:
9800 goto op_semantics_72;
9801 break;
9802 }
9803 break;
9804 case 0x2c:
9805 GETBYTE ();
9806 switch (op[2] & 0x00)
9807 {
9808 case 0x00:
9809 goto op_semantics_72;
9810 break;
9811 }
9812 break;
9813 case 0x2d:
9814 GETBYTE ();
9815 switch (op[2] & 0x00)
9816 {
9817 case 0x00:
9818 goto op_semantics_72;
9819 break;
9820 }
9821 break;
9822 case 0x2e:
9823 GETBYTE ();
9824 switch (op[2] & 0x00)
9825 {
9826 case 0x00:
9827 goto op_semantics_72;
9828 break;
9829 }
9830 break;
9831 case 0x38:
9832 GETBYTE ();
9833 switch (op[2] & 0x00)
9834 {
9835 case 0x00:
9836 op_semantics_73:
9837 {
9838 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
78e98aab 9839#line 335 "rx-decode.opc"
c7927a3c 9840 int p AU = (op[1] >> 2) & 0x01;
78e98aab 9841#line 335 "rx-decode.opc"
c7927a3c 9842 int sz AU = op[1] & 0x03;
78e98aab 9843#line 335 "rx-decode.opc"
c7927a3c 9844 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 9845#line 335 "rx-decode.opc"
c7927a3c
NC		 9846 int rdst AU = op[2] & 0x0f;
9847 if (trace)
9848 {
9849 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9850 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9851 op[0], op[1], op[2]);
9852 printf (" p = 0x%x,", p);
9853 printf (" sz = 0x%x,", sz);
9854 printf (" rsrc = 0x%x,", rsrc);
9855 printf (" rdst = 0x%x\n", rdst);
9856 }
9857 SYNTAX("movu%s %1, %0");
78e98aab 9858#line 335 "rx-decode.opc"
3cf79a01 9859 ID(mov); uBWL (sz); DR(rdst); F_____;
c7927a3c
NC		 9860 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9861
9862 /*----------------------------------------------------------------------*/
9863 /* PUSH/POP */
9864
9865 }
9866 break;
9867 }
9868 break;
9869 case 0x39:
9870 GETBYTE ();
9871 switch (op[2] & 0x00)
9872 {
9873 case 0x00:
9874 goto op_semantics_73;
9875 break;
9876 }
9877 break;
9878 case 0x3a:
9879 GETBYTE ();
9880 switch (op[2] & 0x00)
9881 {
9882 case 0x00:
9883 goto op_semantics_73;
9884 break;
9885 }
9886 break;
9887 case 0x3c:
9888 GETBYTE ();
9889 switch (op[2] & 0x00)
9890 {
9891 case 0x00:
9892 goto op_semantics_73;
9893 break;
9894 }
9895 break;
9896 case 0x3d:
9897 GETBYTE ();
9898 switch (op[2] & 0x00)
9899 {
9900 case 0x00:
9901 goto op_semantics_73;
9902 break;
9903 }
9904 break;
9905 case 0x3e:
9906 GETBYTE ();
9907 switch (op[2] & 0x00)
9908 {
9909 case 0x00:
9910 goto op_semantics_73;
9911 break;
9912 }
9913 break;
9914 case 0x60:
9915 GETBYTE ();
9916 switch (op[2] & 0x00)
9917 {
9918 case 0x00:
9919 {
9920 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
78e98aab 9921#line 668 "rx-decode.opc"
c7927a3c 9922 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 9923#line 668 "rx-decode.opc"
c7927a3c
NC		 9924 int rdst AU = op[2] & 0x0f;
9925 if (trace)
9926 {
9927 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9928 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9929 op[0], op[1], op[2]);
9930 printf (" rsrc = 0x%x,", rsrc);
9931 printf (" rdst = 0x%x\n", rdst);
9932 }
9933 SYNTAX("shlr %2, %0");
78e98aab 9934#line 668 "rx-decode.opc"
3cf79a01 9935 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
c7927a3c
NC		 9936
9937 }
9938 break;
9939 }
9940 break;
9941 case 0x61:
9942 GETBYTE ();
9943 switch (op[2] & 0x00)
9944 {
9945 case 0x00:
9946 {
9947 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
78e98aab 9948#line 658 "rx-decode.opc"
c7927a3c 9949 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 9950#line 658 "rx-decode.opc"
c7927a3c
NC		 9951 int rdst AU = op[2] & 0x0f;
9952 if (trace)
9953 {
9954 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9955 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
9956 op[0], op[1], op[2]);
9957 printf (" rsrc = 0x%x,", rsrc);
9958 printf (" rdst = 0x%x\n", rdst);
9959 }
9960 SYNTAX("shar %2, %0");
78e98aab 9961#line 658 "rx-decode.opc"
3cf79a01 9962 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
c7927a3c
NC		 9963
9964 }
9965 break;
9966 }
9967 break;
9968 case 0x62:
9969 GETBYTE ();
9970 switch (op[2] & 0x00)
9971 {
9972 case 0x00:
9973 {
9974 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
78e98aab 9975#line 648 "rx-decode.opc"
c7927a3c 9976 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 9977#line 648 "rx-decode.opc"
c7927a3c
NC		 9978 int rdst AU = op[2] & 0x0f;
9979 if (trace)
9980 {
9981 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9982 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
9983 op[0], op[1], op[2]);
9984 printf (" rsrc = 0x%x,", rsrc);
9985 printf (" rdst = 0x%x\n", rdst);
9986 }
9987 SYNTAX("shll %2, %0");
78e98aab 9988#line 648 "rx-decode.opc"
3cf79a01 9989 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
c7927a3c
NC		 9990
9991 }
9992 break;
9993 }
9994 break;
9995 case 0x64:
9996 GETBYTE ();
9997 switch (op[2] & 0x00)
9998 {
9999 case 0x00:
10000 {
10001 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
78e98aab 10002#line 692 "rx-decode.opc"
c7927a3c 10003 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 10004#line 692 "rx-decode.opc"
c7927a3c
NC		 10005 int rdst AU = op[2] & 0x0f;
10006 if (trace)
10007 {
10008 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10009 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
10010 op[0], op[1], op[2]);
10011 printf (" rsrc = 0x%x,", rsrc);
10012 printf (" rdst = 0x%x\n", rdst);
10013 }
10014 SYNTAX("rotr %1, %0");
78e98aab 10015#line 692 "rx-decode.opc"
3cf79a01 10016 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
c7927a3c
NC		 10017
10018 }
10019 break;
10020 }
10021 break;
10022 case 0x65:
10023 GETBYTE ();
10024 switch (op[2] & 0x00)
10025 {
10026 case 0x00:
10027 {
10028 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
78e98aab 10029#line 695 "rx-decode.opc"
c7927a3c 10030 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 10031#line 695 "rx-decode.opc"
c7927a3c
NC		 10032 int rdst AU = op[2] & 0x0f;
10033 if (trace)
10034 {
10035 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10036 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10037 op[0], op[1], op[2]);
10038 printf (" rsrc = 0x%x,", rsrc);
10039 printf (" rdst = 0x%x\n", rdst);
10040 }
10041 SYNTAX("revw %1, %0");
78e98aab 10042#line 695 "rx-decode.opc"
c7927a3c
NC		 10043 ID(revw); SR(rsrc); DR(rdst);
10044
10045 }
10046 break;
10047 }
10048 break;
10049 case 0x66:
10050 GETBYTE ();
10051 switch (op[2] & 0x00)
10052 {
10053 case 0x00:
10054 {
10055 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
78e98aab 10056#line 686 "rx-decode.opc"
c7927a3c 10057 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 10058#line 686 "rx-decode.opc"
c7927a3c
NC		 10059 int rdst AU = op[2] & 0x0f;
10060 if (trace)
10061 {
10062 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10063 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10064 op[0], op[1], op[2]);
10065 printf (" rsrc = 0x%x,", rsrc);
10066 printf (" rdst = 0x%x\n", rdst);
10067 }
10068 SYNTAX("rotl %1, %0");
78e98aab 10069#line 686 "rx-decode.opc"
3cf79a01 10070 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
c7927a3c
NC		 10071
10072 }
10073 break;
10074 }
10075 break;
10076 case 0x67:
10077 GETBYTE ();
10078 switch (op[2] & 0x00)
10079 {
10080 case 0x00:
10081 {
10082 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
78e98aab 10083#line 698 "rx-decode.opc"
c7927a3c 10084 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 10085#line 698 "rx-decode.opc"
c7927a3c
NC		 10086 int rdst AU = op[2] & 0x0f;
10087 if (trace)
10088 {
10089 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10090 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10091 op[0], op[1], op[2]);
10092 printf (" rsrc = 0x%x,", rsrc);
10093 printf (" rdst = 0x%x\n", rdst);
10094 }
10095 SYNTAX("revl %1, %0");
78e98aab 10096#line 698 "rx-decode.opc"
c7927a3c
NC		 10097 ID(revl); SR(rsrc); DR(rdst);
10098
10099 /*----------------------------------------------------------------------*/
10100 /* BRANCH */
10101
10102 }
10103 break;
10104 }
10105 break;
10106 case 0x68:
10107 GETBYTE ();
10108 switch (op[2] & 0x00)
10109 {
10110 case 0x00:
10111 op_semantics_74:
10112 {
10113 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
78e98aab 10114#line 941 "rx-decode.opc"
c7927a3c 10115 int c AU = op[1] & 0x01;
78e98aab 10116#line 941 "rx-decode.opc"
c7927a3c 10117 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 10118#line 941 "rx-decode.opc"
c7927a3c
NC		 10119 int rdst AU = op[2] & 0x0f;
10120 if (trace)
10121 {
10122 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10123 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10124 op[0], op[1], op[2]);
10125 printf (" c = 0x%x,", c);
10126 printf (" rsrc = 0x%x,", rsrc);
10127 printf (" rdst = 0x%x\n", rdst);
10128 }
10129 SYNTAX("mvtc %1, %0");
78e98aab 10130#line 941 "rx-decode.opc"
c7927a3c
NC		 10131 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10132
10133 }
10134 break;
10135 }
10136 break;
10137 case 0x69:
10138 GETBYTE ();
10139 switch (op[2] & 0x00)
10140 {
10141 case 0x00:
10142 goto op_semantics_74;
10143 break;
10144 }
10145 break;
10146 case 0x6a:
10147 GETBYTE ();
10148 switch (op[2] & 0x00)
10149 {
10150 case 0x00:
10151 op_semantics_75:
10152 {
10153 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
78e98aab 10154#line 944 "rx-decode.opc"
c7927a3c 10155 int s AU = op[1] & 0x01;
78e98aab 10156#line 944 "rx-decode.opc"
c7927a3c 10157 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 10158#line 944 "rx-decode.opc"
c7927a3c
NC		 10159 int rdst AU = op[2] & 0x0f;
10160 if (trace)
10161 {
10162 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10163 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10164 op[0], op[1], op[2]);
10165 printf (" s = 0x%x,", s);
10166 printf (" rsrc = 0x%x,", rsrc);
10167 printf (" rdst = 0x%x\n", rdst);
10168 }
10169 SYNTAX("mvfc %1, %0");
78e98aab 10170#line 944 "rx-decode.opc"
c7927a3c
NC		 10171 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10172
946ef196
DD		 10173 /*----------------------------------------------------------------------*/
10174 /* INTERRUPTS */
10175
c7927a3c
NC		 10176 }
10177 break;
10178 }
10179 break;
10180 case 0x6b:
10181 GETBYTE ();
10182 switch (op[2] & 0x00)
10183 {
10184 case 0x00:
10185 goto op_semantics_75;
10186 break;
10187 }
10188 break;
10189 case 0x6c:
10190 GETBYTE ();
10191 switch (op[2] & 0x00)
10192 {
10193 case 0x00:
10194 op_semantics_76:
10195 {
10196 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
78e98aab 10197#line 689 "rx-decode.opc"
c7927a3c 10198 int i AU = op[1] & 0x01;
78e98aab 10199#line 689 "rx-decode.opc"
c7927a3c 10200 int mmmm AU = (op[2] >> 4) & 0x0f;
78e98aab 10201#line 689 "rx-decode.opc"
c7927a3c
NC		 10202 int rdst AU = op[2] & 0x0f;
10203 if (trace)
10204 {
10205 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10206 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10207 op[0], op[1], op[2]);
10208 printf (" i = 0x%x,", i);
10209 printf (" mmmm = 0x%x,", mmmm);
10210 printf (" rdst = 0x%x\n", rdst);
10211 }
10212 SYNTAX("rotr #%1, %0");
78e98aab 10213#line 689 "rx-decode.opc"
3cf79a01 10214 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
c7927a3c
NC		 10215
10216 }
10217 break;
10218 }
10219 break;
10220 case 0x6d:
10221 GETBYTE ();
10222 switch (op[2] & 0x00)
10223 {
10224 case 0x00:
10225 goto op_semantics_76;
10226 break;
10227 }
10228 break;
10229 case 0x6e:
10230 GETBYTE ();
10231 switch (op[2] & 0x00)
10232 {
10233 case 0x00:
10234 op_semantics_77:
10235 {
10236 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
78e98aab 10237#line 683 "rx-decode.opc"
c7927a3c 10238 int i AU = op[1] & 0x01;
78e98aab 10239#line 683 "rx-decode.opc"
c7927a3c 10240 int mmmm AU = (op[2] >> 4) & 0x0f;
78e98aab 10241#line 683 "rx-decode.opc"
c7927a3c
NC		 10242 int rdst AU = op[2] & 0x0f;
10243 if (trace)
10244 {
10245 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10246 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10247 op[0], op[1], op[2]);
10248 printf (" i = 0x%x,", i);
10249 printf (" mmmm = 0x%x,", mmmm);
10250 printf (" rdst = 0x%x\n", rdst);
10251 }
10252 SYNTAX("rotl #%1, %0");
78e98aab 10253#line 683 "rx-decode.opc"
3cf79a01 10254 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
c7927a3c
NC		 10255
10256 }
10257 break;
10258 }
10259 break;
10260 case 0x6f:
10261 GETBYTE ();
10262 switch (op[2] & 0x00)
10263 {
10264 case 0x00:
10265 goto op_semantics_77;
10266 break;
10267 }
10268 break;
10269 case 0x70:
10270 GETBYTE ();
10271 switch (op[2] & 0xf0)
10272 {
10273 case 0x20:
10274 op_semantics_78:
10275 {
10276 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
78e98aab 10277#line 465 "rx-decode.opc"
c7927a3c 10278 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10279#line 465 "rx-decode.opc"
c7927a3c
NC		 10280 int rdst AU = op[2] & 0x0f;
10281 if (trace)
10282 {
10283 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10284 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10285 op[0], op[1], op[2]);
10286 printf (" im = 0x%x,", im);
10287 printf (" rdst = 0x%x\n", rdst);
10288 }
10289 SYNTAX("adc #%1, %0");
78e98aab 10290#line 465 "rx-decode.opc"
3cf79a01 10291 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
c7927a3c
NC		 10292
10293 }
10294 break;
10295 case 0x40:
10296 op_semantics_79:
10297 {
10298 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
78e98aab 10299#line 547 "rx-decode.opc"
c7927a3c 10300 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10301#line 547 "rx-decode.opc"
c7927a3c
NC		 10302 int rdst AU = op[2] & 0x0f;
10303 if (trace)
10304 {
10305 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10306 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10307 op[0], op[1], op[2]);
10308 printf (" im = 0x%x,", im);
10309 printf (" rdst = 0x%x\n", rdst);
10310 }
10311 SYNTAX("max #%1, %0");
78e98aab 10312#line 547 "rx-decode.opc"
c7927a3c
NC		 10313 ID(max); DR(rdst); SC(IMMex(im));
10314
10315 }
10316 break;
10317 case 0x50:
10318 op_semantics_80:
10319 {
10320 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
78e98aab 10321#line 567 "rx-decode.opc"
c7927a3c 10322 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10323#line 567 "rx-decode.opc"
c7927a3c
NC		 10324 int rdst AU = op[2] & 0x0f;
10325 if (trace)
10326 {
10327 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10328 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10329 op[0], op[1], op[2]);
10330 printf (" im = 0x%x,", im);
10331 printf (" rdst = 0x%x\n", rdst);
10332 }
10333 SYNTAX("min #%1, %0");
78e98aab 10334#line 567 "rx-decode.opc"
c7927a3c
NC		 10335 ID(min); DR(rdst); SC(IMMex(im));
10336
10337 }
10338 break;
10339 case 0x60:
10340 op_semantics_81:
10341 {
10342 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
78e98aab 10343#line 597 "rx-decode.opc"
c7927a3c 10344 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10345#line 597 "rx-decode.opc"
c7927a3c
NC		 10346 int rdst AU = op[2] & 0x0f;
10347 if (trace)
10348 {
10349 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10350 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10351 op[0], op[1], op[2]);
10352 printf (" im = 0x%x,", im);
10353 printf (" rdst = 0x%x\n", rdst);
10354 }
10355 SYNTAX("emul #%1, %0");
78e98aab 10356#line 597 "rx-decode.opc"
c7927a3c
NC		 10357 ID(emul); DR(rdst); SC(IMMex(im));
10358
10359 }
10360 break;
10361 case 0x70:
10362 op_semantics_82:
10363 {
10364 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
78e98aab 10365#line 609 "rx-decode.opc"
c7927a3c 10366 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10367#line 609 "rx-decode.opc"
c7927a3c
NC		 10368 int rdst AU = op[2] & 0x0f;
10369 if (trace)
10370 {
10371 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10372 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10373 op[0], op[1], op[2]);
10374 printf (" im = 0x%x,", im);
10375 printf (" rdst = 0x%x\n", rdst);
10376 }
10377 SYNTAX("emulu #%1, %0");
78e98aab 10378#line 609 "rx-decode.opc"
c7927a3c
NC		 10379 ID(emulu); DR(rdst); SC(IMMex(im));
10380
10381 }
10382 break;
10383 case 0x80:
10384 op_semantics_83:
10385 {
10386 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
78e98aab 10387#line 621 "rx-decode.opc"
c7927a3c 10388 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10389#line 621 "rx-decode.opc"
c7927a3c
NC		 10390 int rdst AU = op[2] & 0x0f;
10391 if (trace)
10392 {
10393 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10394 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10395 op[0], op[1], op[2]);
10396 printf (" im = 0x%x,", im);
10397 printf (" rdst = 0x%x\n", rdst);
10398 }
10399 SYNTAX("div #%1, %0");
78e98aab 10400#line 621 "rx-decode.opc"
3cf79a01 10401 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
c7927a3c
NC		 10402
10403 }
10404 break;
10405 case 0x90:
10406 op_semantics_84:
10407 {
10408 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
78e98aab 10409#line 633 "rx-decode.opc"
c7927a3c 10410 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10411#line 633 "rx-decode.opc"
c7927a3c
NC		 10412 int rdst AU = op[2] & 0x0f;
10413 if (trace)
10414 {
10415 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10416 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10417 op[0], op[1], op[2]);
10418 printf (" im = 0x%x,", im);
10419 printf (" rdst = 0x%x\n", rdst);
10420 }
10421 SYNTAX("divu #%1, %0");
78e98aab 10422#line 633 "rx-decode.opc"
3cf79a01 10423 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
c7927a3c
NC		 10424
10425 }
10426 break;
10427 case 0xc0:
10428 op_semantics_85:
10429 {
10430 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
78e98aab 10431#line 444 "rx-decode.opc"
c7927a3c 10432 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10433#line 444 "rx-decode.opc"
c7927a3c
NC		 10434 int rdst AU = op[2] & 0x0f;
10435 if (trace)
10436 {
10437 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10438 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
10439 op[0], op[1], op[2]);
10440 printf (" im = 0x%x,", im);
10441 printf (" rdst = 0x%x\n", rdst);
10442 }
10443 SYNTAX("tst #%1, %2");
78e98aab 10444#line 444 "rx-decode.opc"
3cf79a01 10445 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
c7927a3c
NC		 10446
10447 }
10448 break;
10449 case 0xd0:
10450 op_semantics_86:
10451 {
10452 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
78e98aab 10453#line 423 "rx-decode.opc"
c7927a3c 10454 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10455#line 423 "rx-decode.opc"
c7927a3c
NC		 10456 int rdst AU = op[2] & 0x0f;
10457 if (trace)
10458 {
10459 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10460 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10461 op[0], op[1], op[2]);
10462 printf (" im = 0x%x,", im);
10463 printf (" rdst = 0x%x\n", rdst);
10464 }
10465 SYNTAX("xor #%1, %0");
78e98aab 10466#line 423 "rx-decode.opc"
3cf79a01 10467 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
c7927a3c
NC		 10468
10469 }
10470 break;
10471 case 0xe0:
10472 op_semantics_87:
10473 {
10474 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
78e98aab 10475#line 369 "rx-decode.opc"
c7927a3c 10476 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10477#line 369 "rx-decode.opc"
c7927a3c
NC		 10478 int rdst AU = op[2] & 0x0f;
10479 if (trace)
10480 {
10481 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10482 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10483 op[0], op[1], op[2]);
10484 printf (" im = 0x%x,", im);
10485 printf (" rdst = 0x%x\n", rdst);
10486 }
10487 SYNTAX("stz #%1, %0");
78e98aab 10488#line 369 "rx-decode.opc"
c7927a3c
NC		 10489 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10490
10491 }
10492 break;
10493 case 0xf0:
10494 op_semantics_88:
10495 {
10496 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
78e98aab 10497#line 372 "rx-decode.opc"
c7927a3c 10498 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10499#line 372 "rx-decode.opc"
c7927a3c
NC		 10500 int rdst AU = op[2] & 0x0f;
10501 if (trace)
10502 {
10503 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10504 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10505 op[0], op[1], op[2]);
10506 printf (" im = 0x%x,", im);
10507 printf (" rdst = 0x%x\n", rdst);
10508 }
10509 SYNTAX("stnz #%1, %0");
78e98aab 10510#line 372 "rx-decode.opc"
c7927a3c
NC		 10511 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10512
10513 /*----------------------------------------------------------------------*/
10514 /* RTSD */
10515
10516 }
10517 break;
10518 default: UNSUPPORTED(); break;
10519 }
10520 break;
10521 case 0x72:
10522 GETBYTE ();
10523 switch (op[2] & 0xf0)
10524 {
10525 case 0x00:
10526 {
10527 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
78e98aab 10528#line 841 "rx-decode.opc"
c7927a3c
NC		 10529 int rdst AU = op[2] & 0x0f;
10530 if (trace)
10531 {
10532 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10533 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
10534 op[0], op[1], op[2]);
10535 printf (" rdst = 0x%x\n", rdst);
10536 }
10537 SYNTAX("fsub #%1, %0");
78e98aab 10538#line 841 "rx-decode.opc"
3cf79a01 10539 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10540
10541 }
10542 break;
10543 case 0x10:
10544 {
10545 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
78e98aab 10546#line 835 "rx-decode.opc"
c7927a3c
NC		 10547 int rdst AU = op[2] & 0x0f;
10548 if (trace)
10549 {
10550 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10551 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10552 op[0], op[1], op[2]);
10553 printf (" rdst = 0x%x\n", rdst);
10554 }
10555 SYNTAX("fcmp #%1, %0");
78e98aab 10556#line 835 "rx-decode.opc"
3cf79a01 10557 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
c7927a3c
NC		 10558
10559 }
10560 break;
10561 case 0x20:
10562 {
10563 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
78e98aab 10564#line 829 "rx-decode.opc"
c7927a3c
NC		 10565 int rdst AU = op[2] & 0x0f;
10566 if (trace)
10567 {
10568 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10569 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10570 op[0], op[1], op[2]);
10571 printf (" rdst = 0x%x\n", rdst);
10572 }
10573 SYNTAX("fadd #%1, %0");
78e98aab 10574#line 829 "rx-decode.opc"
3cf79a01 10575 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10576
10577 }
10578 break;
10579 case 0x30:
10580 {
10581 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
78e98aab 10582#line 850 "rx-decode.opc"
c7927a3c
NC		 10583 int rdst AU = op[2] & 0x0f;
10584 if (trace)
10585 {
10586 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10587 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10588 op[0], op[1], op[2]);
10589 printf (" rdst = 0x%x\n", rdst);
10590 }
10591 SYNTAX("fmul #%1, %0");
78e98aab 10592#line 850 "rx-decode.opc"
3cf79a01 10593 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10594
10595 }
10596 break;
10597 case 0x40:
10598 {
10599 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
78e98aab 10600#line 856 "rx-decode.opc"
c7927a3c
NC		 10601 int rdst AU = op[2] & 0x0f;
10602 if (trace)
10603 {
10604 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10605 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10606 op[0], op[1], op[2]);
10607 printf (" rdst = 0x%x\n", rdst);
10608 }
10609 SYNTAX("fdiv #%1, %0");
78e98aab 10610#line 856 "rx-decode.opc"
3cf79a01 10611 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
c7927a3c
NC		 10612
10613 }
10614 break;
10615 default: UNSUPPORTED(); break;
10616 }
10617 break;
10618 case 0x73:
10619 GETBYTE ();
10620 switch (op[2] & 0xe0)
10621 {
10622 case 0x00:
10623 op_semantics_89:
10624 {
10625 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
78e98aab 10626#line 938 "rx-decode.opc"
c7927a3c 10627 int im AU = (op[1] >> 2) & 0x03;
78e98aab 10628#line 938 "rx-decode.opc"
c7927a3c
NC		 10629 int crdst AU = op[2] & 0x1f;
10630 if (trace)
10631 {
10632 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10633 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10634 op[0], op[1], op[2]);
10635 printf (" im = 0x%x,", im);
10636 printf (" crdst = 0x%x\n", crdst);
10637 }
10638 SYNTAX("mvtc #%1, %0");
78e98aab 10639#line 938 "rx-decode.opc"
c7927a3c
NC		 10640 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10641
10642 }
10643 break;
10644 default: UNSUPPORTED(); break;
10645 }
10646 break;
10647 case 0x74:
10648 GETBYTE ();
10649 switch (op[2] & 0xf0)
10650 {
10651 case 0x20:
10652 goto op_semantics_78;
10653 break;
10654 case 0x40:
10655 goto op_semantics_79;
10656 break;
10657 case 0x50:
10658 goto op_semantics_80;
10659 break;
10660 case 0x60:
10661 goto op_semantics_81;
10662 break;
10663 case 0x70:
10664 goto op_semantics_82;
10665 break;
10666 case 0x80:
10667 goto op_semantics_83;
10668 break;
10669 case 0x90:
10670 goto op_semantics_84;
10671 break;
10672 case 0xc0:
10673 goto op_semantics_85;
10674 break;
10675 case 0xd0:
10676 goto op_semantics_86;
10677 break;
10678 case 0xe0:
10679 goto op_semantics_87;
10680 break;
10681 case 0xf0:
10682 goto op_semantics_88;
10683 break;
10684 default: UNSUPPORTED(); break;
10685 }
10686 break;
10687 case 0x77:
10688 GETBYTE ();
10689 switch (op[2] & 0xe0)
10690 {
10691 case 0x00:
10692 goto op_semantics_89;
10693 break;
10694 default: UNSUPPORTED(); break;
10695 }
10696 break;
10697 case 0x78:
10698 GETBYTE ();
10699 switch (op[2] & 0xf0)
10700 {
10701 case 0x20:
10702 goto op_semantics_78;
10703 break;
10704 case 0x40:
10705 goto op_semantics_79;
10706 break;
10707 case 0x50:
10708 goto op_semantics_80;
10709 break;
10710 case 0x60:
10711 goto op_semantics_81;
10712 break;
10713 case 0x70:
10714 goto op_semantics_82;
10715 break;
10716 case 0x80:
10717 goto op_semantics_83;
10718 break;
10719 case 0x90:
10720 goto op_semantics_84;
10721 break;
10722 case 0xc0:
10723 goto op_semantics_85;
10724 break;
10725 case 0xd0:
10726 goto op_semantics_86;
10727 break;
10728 case 0xe0:
10729 goto op_semantics_87;
10730 break;
10731 case 0xf0:
10732 goto op_semantics_88;
10733 break;
10734 default: UNSUPPORTED(); break;
10735 }
10736 break;
10737 case 0x7b:
10738 GETBYTE ();
10739 switch (op[2] & 0xe0)
10740 {
10741 case 0x00:
10742 goto op_semantics_89;
10743 break;
10744 default: UNSUPPORTED(); break;
10745 }
10746 break;
10747 case 0x7c:
10748 GETBYTE ();
10749 switch (op[2] & 0xf0)
10750 {
10751 case 0x20:
10752 goto op_semantics_78;
10753 break;
10754 case 0x40:
10755 goto op_semantics_79;
10756 break;
10757 case 0x50:
10758 goto op_semantics_80;
10759 break;
10760 case 0x60:
10761 goto op_semantics_81;
10762 break;
10763 case 0x70:
10764 goto op_semantics_82;
10765 break;
10766 case 0x80:
10767 goto op_semantics_83;
10768 break;
10769 case 0x90:
10770 goto op_semantics_84;
10771 break;
10772 case 0xc0:
10773 goto op_semantics_85;
10774 break;
10775 case 0xd0:
10776 goto op_semantics_86;
10777 break;
10778 case 0xe0:
10779 goto op_semantics_87;
10780 break;
10781 case 0xf0:
10782 goto op_semantics_88;
10783 break;
10784 default: UNSUPPORTED(); break;
10785 }
10786 break;
10787 case 0x7f:
10788 GETBYTE ();
10789 switch (op[2] & 0xe0)
10790 {
10791 case 0x00:
10792 goto op_semantics_89;
10793 break;
10794 default: UNSUPPORTED(); break;
10795 }
10796 break;
10797 case 0x80:
10798 GETBYTE ();
10799 switch (op[2] & 0x00)
10800 {
10801 case 0x00:
10802 op_semantics_90:
10803 {
10804 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
78e98aab 10805#line 671 "rx-decode.opc"
c7927a3c 10806 int immmm AU = op[1] & 0x1f;
78e98aab 10807#line 671 "rx-decode.opc"
c7927a3c 10808 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 10809#line 671 "rx-decode.opc"
c7927a3c
NC		 10810 int rdst AU = op[2] & 0x0f;
10811 if (trace)
10812 {
10813 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10814 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10815 op[0], op[1], op[2]);
10816 printf (" immmm = 0x%x,", immmm);
10817 printf (" rsrc = 0x%x,", rsrc);
10818 printf (" rdst = 0x%x\n", rdst);
10819 }
10820 SYNTAX("shlr #%2, %1, %0");
78e98aab 10821#line 671 "rx-decode.opc"
3cf79a01 10822 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
c7927a3c
NC		 10823
10824 /*----------------------------------------------------------------------*/
10825 /* ROTATE */
10826
10827 }
10828 break;
10829 }
10830 break;
10831 case 0x81:
10832 GETBYTE ();
10833 switch (op[2] & 0x00)
10834 {
10835 case 0x00:
10836 goto op_semantics_90;
10837 break;
10838 }
10839 break;
10840 case 0x82:
10841 GETBYTE ();
10842 switch (op[2] & 0x00)
10843 {
10844 case 0x00:
10845 goto op_semantics_90;
10846 break;
10847 }
10848 break;
10849 case 0x83:
10850 GETBYTE ();
10851 switch (op[2] & 0x00)
10852 {
10853 case 0x00:
10854 goto op_semantics_90;
10855 break;
10856 }
10857 break;
10858 case 0x84:
10859 GETBYTE ();
10860 switch (op[2] & 0x00)
10861 {
10862 case 0x00:
10863 goto op_semantics_90;
10864 break;
10865 }
10866 break;
10867 case 0x85:
10868 GETBYTE ();
10869 switch (op[2] & 0x00)
10870 {
10871 case 0x00:
10872 goto op_semantics_90;
10873 break;
10874 }
10875 break;
10876 case 0x86:
10877 GETBYTE ();
10878 switch (op[2] & 0x00)
10879 {
10880 case 0x00:
10881 goto op_semantics_90;
10882 break;
10883 }
10884 break;
10885 case 0x87:
10886 GETBYTE ();
10887 switch (op[2] & 0x00)
10888 {
10889 case 0x00:
10890 goto op_semantics_90;
10891 break;
10892 }
10893 break;
10894 case 0x88:
10895 GETBYTE ();
10896 switch (op[2] & 0x00)
10897 {
10898 case 0x00:
10899 goto op_semantics_90;
10900 break;
10901 }
10902 break;
10903 case 0x89:
10904 GETBYTE ();
10905 switch (op[2] & 0x00)
10906 {
10907 case 0x00:
10908 goto op_semantics_90;
10909 break;
10910 }
10911 break;
10912 case 0x8a:
10913 GETBYTE ();
10914 switch (op[2] & 0x00)
10915 {
10916 case 0x00:
10917 goto op_semantics_90;
10918 break;
10919 }
10920 break;
10921 case 0x8b:
10922 GETBYTE ();
10923 switch (op[2] & 0x00)
10924 {
10925 case 0x00:
10926 goto op_semantics_90;
10927 break;
10928 }
10929 break;
10930 case 0x8c:
10931 GETBYTE ();
10932 switch (op[2] & 0x00)
10933 {
10934 case 0x00:
10935 goto op_semantics_90;
10936 break;
10937 }
10938 break;
10939 case 0x8d:
10940 GETBYTE ();
10941 switch (op[2] & 0x00)
10942 {
10943 case 0x00:
10944 goto op_semantics_90;
10945 break;
10946 }
10947 break;
10948 case 0x8e:
10949 GETBYTE ();
10950 switch (op[2] & 0x00)
10951 {
10952 case 0x00:
10953 goto op_semantics_90;
10954 break;
10955 }
10956 break;
10957 case 0x8f:
10958 GETBYTE ();
10959 switch (op[2] & 0x00)
10960 {
10961 case 0x00:
10962 goto op_semantics_90;
10963 break;
10964 }
10965 break;
10966 case 0x90:
10967 GETBYTE ();
10968 switch (op[2] & 0x00)
10969 {
10970 case 0x00:
10971 goto op_semantics_90;
10972 break;
10973 }
10974 break;
10975 case 0x91:
10976 GETBYTE ();
10977 switch (op[2] & 0x00)
10978 {
10979 case 0x00:
10980 goto op_semantics_90;
10981 break;
10982 }
10983 break;
10984 case 0x92:
10985 GETBYTE ();
10986 switch (op[2] & 0x00)
10987 {
10988 case 0x00:
10989 goto op_semantics_90;
10990 break;
10991 }
10992 break;
10993 case 0x93:
10994 GETBYTE ();
10995 switch (op[2] & 0x00)
10996 {
10997 case 0x00:
10998 goto op_semantics_90;
10999 break;
11000 }
11001 break;
11002 case 0x94:
11003 GETBYTE ();
11004 switch (op[2] & 0x00)
11005 {
11006 case 0x00:
11007 goto op_semantics_90;
11008 break;
11009 }
11010 break;
11011 case 0x95:
11012 GETBYTE ();
11013 switch (op[2] & 0x00)
11014 {
11015 case 0x00:
11016 goto op_semantics_90;
11017 break;
11018 }
11019 break;
11020 case 0x96:
11021 GETBYTE ();
11022 switch (op[2] & 0x00)
11023 {
11024 case 0x00:
11025 goto op_semantics_90;
11026 break;
11027 }
11028 break;
11029 case 0x97:
11030 GETBYTE ();
11031 switch (op[2] & 0x00)
11032 {
11033 case 0x00:
11034 goto op_semantics_90;
11035 break;
11036 }
11037 break;
11038 case 0x98:
11039 GETBYTE ();
11040 switch (op[2] & 0x00)
11041 {
11042 case 0x00:
11043 goto op_semantics_90;
11044 break;
11045 }
11046 break;
11047 case 0x99:
11048 GETBYTE ();
11049 switch (op[2] & 0x00)
11050 {
11051 case 0x00:
11052 goto op_semantics_90;
11053 break;
11054 }
11055 break;
11056 case 0x9a:
11057 GETBYTE ();
11058 switch (op[2] & 0x00)
11059 {
11060 case 0x00:
11061 goto op_semantics_90;
11062 break;
11063 }
11064 break;
11065 case 0x9b:
11066 GETBYTE ();
11067 switch (op[2] & 0x00)
11068 {
11069 case 0x00:
11070 goto op_semantics_90;
11071 break;
11072 }
11073 break;
11074 case 0x9c:
11075 GETBYTE ();
11076 switch (op[2] & 0x00)
11077 {
11078 case 0x00:
11079 goto op_semantics_90;
11080 break;
11081 }
11082 break;
11083 case 0x9d:
11084 GETBYTE ();
11085 switch (op[2] & 0x00)
11086 {
11087 case 0x00:
11088 goto op_semantics_90;
11089 break;
11090 }
11091 break;
11092 case 0x9e:
11093 GETBYTE ();
11094 switch (op[2] & 0x00)
11095 {
11096 case 0x00:
11097 goto op_semantics_90;
11098 break;
11099 }
11100 break;
11101 case 0x9f:
11102 GETBYTE ();
11103 switch (op[2] & 0x00)
11104 {
11105 case 0x00:
11106 goto op_semantics_90;
11107 break;
11108 }
11109 break;
11110 case 0xa0:
11111 GETBYTE ();
11112 switch (op[2] & 0x00)
11113 {
11114 case 0x00:
11115 op_semantics_91:
11116 {
11117 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
78e98aab 11118#line 661 "rx-decode.opc"
c7927a3c 11119 int immmm AU = op[1] & 0x1f;
78e98aab 11120#line 661 "rx-decode.opc"
c7927a3c 11121 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 11122#line 661 "rx-decode.opc"
c7927a3c
NC		 11123 int rdst AU = op[2] & 0x0f;
11124 if (trace)
11125 {
11126 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11127 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11128 op[0], op[1], op[2]);
11129 printf (" immmm = 0x%x,", immmm);
11130 printf (" rsrc = 0x%x,", rsrc);
11131 printf (" rdst = 0x%x\n", rdst);
11132 }
11133 SYNTAX("shar #%2, %1, %0");
78e98aab 11134#line 661 "rx-decode.opc"
3cf79a01 11135 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
c7927a3c
NC		 11136
11137
11138 }
11139 break;
11140 }
11141 break;
11142 case 0xa1:
11143 GETBYTE ();
11144 switch (op[2] & 0x00)
11145 {
11146 case 0x00:
11147 goto op_semantics_91;
11148 break;
11149 }
11150 break;
11151 case 0xa2:
11152 GETBYTE ();
11153 switch (op[2] & 0x00)
11154 {
11155 case 0x00:
11156 goto op_semantics_91;
11157 break;
11158 }
11159 break;
11160 case 0xa3:
11161 GETBYTE ();
11162 switch (op[2] & 0x00)
11163 {
11164 case 0x00:
11165 goto op_semantics_91;
11166 break;
11167 }
11168 break;
11169 case 0xa4:
11170 GETBYTE ();
11171 switch (op[2] & 0x00)
11172 {
11173 case 0x00:
11174 goto op_semantics_91;
11175 break;
11176 }
11177 break;
11178 case 0xa5:
11179 GETBYTE ();
11180 switch (op[2] & 0x00)
11181 {
11182 case 0x00:
11183 goto op_semantics_91;
11184 break;
11185 }
11186 break;
11187 case 0xa6:
11188 GETBYTE ();
11189 switch (op[2] & 0x00)
11190 {
11191 case 0x00:
11192 goto op_semantics_91;
11193 break;
11194 }
11195 break;
11196 case 0xa7:
11197 GETBYTE ();
11198 switch (op[2] & 0x00)
11199 {
11200 case 0x00:
11201 goto op_semantics_91;
11202 break;
11203 }
11204 break;
11205 case 0xa8:
11206 GETBYTE ();
11207 switch (op[2] & 0x00)
11208 {
11209 case 0x00:
11210 goto op_semantics_91;
11211 break;
11212 }
11213 break;
11214 case 0xa9:
11215 GETBYTE ();
11216 switch (op[2] & 0x00)
11217 {
11218 case 0x00:
11219 goto op_semantics_91;
11220 break;
11221 }
11222 break;
11223 case 0xaa:
11224 GETBYTE ();
11225 switch (op[2] & 0x00)
11226 {
11227 case 0x00:
11228 goto op_semantics_91;
11229 break;
11230 }
11231 break;
11232 case 0xab:
11233 GETBYTE ();
11234 switch (op[2] & 0x00)
11235 {
11236 case 0x00:
11237 goto op_semantics_91;
11238 break;
11239 }
11240 break;
11241 case 0xac:
11242 GETBYTE ();
11243 switch (op[2] & 0x00)
11244 {
11245 case 0x00:
11246 goto op_semantics_91;
11247 break;
11248 }
11249 break;
11250 case 0xad:
11251 GETBYTE ();
11252 switch (op[2] & 0x00)
11253 {
11254 case 0x00:
11255 goto op_semantics_91;
11256 break;
11257 }
11258 break;
11259 case 0xae:
11260 GETBYTE ();
11261 switch (op[2] & 0x00)
11262 {
11263 case 0x00:
11264 goto op_semantics_91;
11265 break;
11266 }
11267 break;
11268 case 0xaf:
11269 GETBYTE ();
11270 switch (op[2] & 0x00)
11271 {
11272 case 0x00:
11273 goto op_semantics_91;
11274 break;
11275 }
11276 break;
11277 case 0xb0:
11278 GETBYTE ();
11279 switch (op[2] & 0x00)
11280 {
11281 case 0x00:
11282 goto op_semantics_91;
11283 break;
11284 }
11285 break;
11286 case 0xb1:
11287 GETBYTE ();
11288 switch (op[2] & 0x00)
11289 {
11290 case 0x00:
11291 goto op_semantics_91;
11292 break;
11293 }
11294 break;
11295 case 0xb2:
11296 GETBYTE ();
11297 switch (op[2] & 0x00)
11298 {
11299 case 0x00:
11300 goto op_semantics_91;
11301 break;
11302 }
11303 break;
11304 case 0xb3:
11305 GETBYTE ();
11306 switch (op[2] & 0x00)
11307 {
11308 case 0x00:
11309 goto op_semantics_91;
11310 break;
11311 }
11312 break;
11313 case 0xb4:
11314 GETBYTE ();
11315 switch (op[2] & 0x00)
11316 {
11317 case 0x00:
11318 goto op_semantics_91;
11319 break;
11320 }
11321 break;
11322 case 0xb5:
11323 GETBYTE ();
11324 switch (op[2] & 0x00)
11325 {
11326 case 0x00:
11327 goto op_semantics_91;
11328 break;
11329 }
11330 break;
11331 case 0xb6:
11332 GETBYTE ();
11333 switch (op[2] & 0x00)
11334 {
11335 case 0x00:
11336 goto op_semantics_91;
11337 break;
11338 }
11339 break;
11340 case 0xb7:
11341 GETBYTE ();
11342 switch (op[2] & 0x00)
11343 {
11344 case 0x00:
11345 goto op_semantics_91;
11346 break;
11347 }
11348 break;
11349 case 0xb8:
11350 GETBYTE ();
11351 switch (op[2] & 0x00)
11352 {
11353 case 0x00:
11354 goto op_semantics_91;
11355 break;
11356 }
11357 break;
11358 case 0xb9:
11359 GETBYTE ();
11360 switch (op[2] & 0x00)
11361 {
11362 case 0x00:
11363 goto op_semantics_91;
11364 break;
11365 }
11366 break;
11367 case 0xba:
11368 GETBYTE ();
11369 switch (op[2] & 0x00)
11370 {
11371 case 0x00:
11372 goto op_semantics_91;
11373 break;
11374 }
11375 break;
11376 case 0xbb:
11377 GETBYTE ();
11378 switch (op[2] & 0x00)
11379 {
11380 case 0x00:
11381 goto op_semantics_91;
11382 break;
11383 }
11384 break;
11385 case 0xbc:
11386 GETBYTE ();
11387 switch (op[2] & 0x00)
11388 {
11389 case 0x00:
11390 goto op_semantics_91;
11391 break;
11392 }
11393 break;
11394 case 0xbd:
11395 GETBYTE ();
11396 switch (op[2] & 0x00)
11397 {
11398 case 0x00:
11399 goto op_semantics_91;
11400 break;
11401 }
11402 break;
11403 case 0xbe:
11404 GETBYTE ();
11405 switch (op[2] & 0x00)
11406 {
11407 case 0x00:
11408 goto op_semantics_91;
11409 break;
11410 }
11411 break;
11412 case 0xbf:
11413 GETBYTE ();
11414 switch (op[2] & 0x00)
11415 {
11416 case 0x00:
11417 goto op_semantics_91;
11418 break;
11419 }
11420 break;
11421 case 0xc0:
11422 GETBYTE ();
11423 switch (op[2] & 0x00)
11424 {
11425 case 0x00:
11426 op_semantics_92:
11427 {
11428 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
78e98aab 11429#line 651 "rx-decode.opc"
c7927a3c 11430 int immmm AU = op[1] & 0x1f;
78e98aab 11431#line 651 "rx-decode.opc"
c7927a3c 11432 int rsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 11433#line 651 "rx-decode.opc"
c7927a3c
NC		 11434 int rdst AU = op[2] & 0x0f;
11435 if (trace)
11436 {
11437 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11438 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11439 op[0], op[1], op[2]);
11440 printf (" immmm = 0x%x,", immmm);
11441 printf (" rsrc = 0x%x,", rsrc);
11442 printf (" rdst = 0x%x\n", rdst);
11443 }
11444 SYNTAX("shll #%2, %1, %0");
78e98aab 11445#line 651 "rx-decode.opc"
3cf79a01 11446 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
c7927a3c
NC		 11447
11448
11449 }
11450 break;
11451 }
11452 break;
11453 case 0xc1:
11454 GETBYTE ();
11455 switch (op[2] & 0x00)
11456 {
11457 case 0x00:
11458 goto op_semantics_92;
11459 break;
11460 }
11461 break;
11462 case 0xc2:
11463 GETBYTE ();
11464 switch (op[2] & 0x00)
11465 {
11466 case 0x00:
11467 goto op_semantics_92;
11468 break;
11469 }
11470 break;
11471 case 0xc3:
11472 GETBYTE ();
11473 switch (op[2] & 0x00)
11474 {
11475 case 0x00:
11476 goto op_semantics_92;
11477 break;
11478 }
11479 break;
11480 case 0xc4:
11481 GETBYTE ();
11482 switch (op[2] & 0x00)
11483 {
11484 case 0x00:
11485 goto op_semantics_92;
11486 break;
11487 }
11488 break;
11489 case 0xc5:
11490 GETBYTE ();
11491 switch (op[2] & 0x00)
11492 {
11493 case 0x00:
11494 goto op_semantics_92;
11495 break;
11496 }
11497 break;
11498 case 0xc6:
11499 GETBYTE ();
11500 switch (op[2] & 0x00)
11501 {
11502 case 0x00:
11503 goto op_semantics_92;
11504 break;
11505 }
11506 break;
11507 case 0xc7:
11508 GETBYTE ();
11509 switch (op[2] & 0x00)
11510 {
11511 case 0x00:
11512 goto op_semantics_92;
11513 break;
11514 }
11515 break;
11516 case 0xc8:
11517 GETBYTE ();
11518 switch (op[2] & 0x00)
11519 {
11520 case 0x00:
11521 goto op_semantics_92;
11522 break;
11523 }
11524 break;
11525 case 0xc9:
11526 GETBYTE ();
11527 switch (op[2] & 0x00)
11528 {
11529 case 0x00:
11530 goto op_semantics_92;
11531 break;
11532 }
11533 break;
11534 case 0xca:
11535 GETBYTE ();
11536 switch (op[2] & 0x00)
11537 {
11538 case 0x00:
11539 goto op_semantics_92;
11540 break;
11541 }
11542 break;
11543 case 0xcb:
11544 GETBYTE ();
11545 switch (op[2] & 0x00)
11546 {
11547 case 0x00:
11548 goto op_semantics_92;
11549 break;
11550 }
11551 break;
11552 case 0xcc:
11553 GETBYTE ();
11554 switch (op[2] & 0x00)
11555 {
11556 case 0x00:
11557 goto op_semantics_92;
11558 break;
11559 }
11560 break;
11561 case 0xcd:
11562 GETBYTE ();
11563 switch (op[2] & 0x00)
11564 {
11565 case 0x00:
11566 goto op_semantics_92;
11567 break;
11568 }
11569 break;
11570 case 0xce:
11571 GETBYTE ();
11572 switch (op[2] & 0x00)
11573 {
11574 case 0x00:
11575 goto op_semantics_92;
11576 break;
11577 }
11578 break;
11579 case 0xcf:
11580 GETBYTE ();
11581 switch (op[2] & 0x00)
11582 {
11583 case 0x00:
11584 goto op_semantics_92;
11585 break;
11586 }
11587 break;
11588 case 0xd0:
11589 GETBYTE ();
11590 switch (op[2] & 0x00)
11591 {
11592 case 0x00:
11593 goto op_semantics_92;
11594 break;
11595 }
11596 break;
11597 case 0xd1:
11598 GETBYTE ();
11599 switch (op[2] & 0x00)
11600 {
11601 case 0x00:
11602 goto op_semantics_92;
11603 break;
11604 }
11605 break;
11606 case 0xd2:
11607 GETBYTE ();
11608 switch (op[2] & 0x00)
11609 {
11610 case 0x00:
11611 goto op_semantics_92;
11612 break;
11613 }
11614 break;
11615 case 0xd3:
11616 GETBYTE ();
11617 switch (op[2] & 0x00)
11618 {
11619 case 0x00:
11620 goto op_semantics_92;
11621 break;
11622 }
11623 break;
11624 case 0xd4:
11625 GETBYTE ();
11626 switch (op[2] & 0x00)
11627 {
11628 case 0x00:
11629 goto op_semantics_92;
11630 break;
11631 }
11632 break;
11633 case 0xd5:
11634 GETBYTE ();
11635 switch (op[2] & 0x00)
11636 {
11637 case 0x00:
11638 goto op_semantics_92;
11639 break;
11640 }
11641 break;
11642 case 0xd6:
11643 GETBYTE ();
11644 switch (op[2] & 0x00)
11645 {
11646 case 0x00:
11647 goto op_semantics_92;
11648 break;
11649 }
11650 break;
11651 case 0xd7:
11652 GETBYTE ();
11653 switch (op[2] & 0x00)
11654 {
11655 case 0x00:
11656 goto op_semantics_92;
11657 break;
11658 }
11659 break;
11660 case 0xd8:
11661 GETBYTE ();
11662 switch (op[2] & 0x00)
11663 {
11664 case 0x00:
11665 goto op_semantics_92;
11666 break;
11667 }
11668 break;
11669 case 0xd9:
11670 GETBYTE ();
11671 switch (op[2] & 0x00)
11672 {
11673 case 0x00:
11674 goto op_semantics_92;
11675 break;
11676 }
11677 break;
11678 case 0xda:
11679 GETBYTE ();
11680 switch (op[2] & 0x00)
11681 {
11682 case 0x00:
11683 goto op_semantics_92;
11684 break;
11685 }
11686 break;
11687 case 0xdb:
11688 GETBYTE ();
11689 switch (op[2] & 0x00)
11690 {
11691 case 0x00:
11692 goto op_semantics_92;
11693 break;
11694 }
11695 break;
11696 case 0xdc:
11697 GETBYTE ();
11698 switch (op[2] & 0x00)
11699 {
11700 case 0x00:
11701 goto op_semantics_92;
11702 break;
11703 }
11704 break;
11705 case 0xdd:
11706 GETBYTE ();
11707 switch (op[2] & 0x00)
11708 {
11709 case 0x00:
11710 goto op_semantics_92;
11711 break;
11712 }
11713 break;
11714 case 0xde:
11715 GETBYTE ();
11716 switch (op[2] & 0x00)
11717 {
11718 case 0x00:
11719 goto op_semantics_92;
11720 break;
11721 }
11722 break;
11723 case 0xdf:
11724 GETBYTE ();
11725 switch (op[2] & 0x00)
11726 {
11727 case 0x00:
11728 goto op_semantics_92;
11729 break;
11730 }
11731 break;
11732 case 0xe0:
11733 GETBYTE ();
11734 switch (op[2] & 0xf0)
11735 {
11736 case 0x00:
11737 case 0x10:
11738 case 0x20:
11739 case 0x30:
11740 case 0x40:
11741 case 0x50:
11742 case 0x60:
11743 case 0x70:
11744 case 0x80:
11745 case 0x90:
11746 case 0xa0:
11747 case 0xb0:
11748 case 0xc0:
11749 case 0xd0:
11750 case 0xe0:
11751 op_semantics_93:
11752 {
11753 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
78e98aab 11754#line 917 "rx-decode.opc"
c7927a3c 11755 int bittt AU = op[1] & 0x1f;
78e98aab 11756#line 917 "rx-decode.opc"
c7927a3c 11757 int cond AU = (op[2] >> 4) & 0x0f;
78e98aab 11758#line 917 "rx-decode.opc"
c7927a3c
NC		 11759 int rdst AU = op[2] & 0x0f;
11760 if (trace)
11761 {
11762 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11763 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11764 op[0], op[1], op[2]);
11765 printf (" bittt = 0x%x,", bittt);
11766 printf (" cond = 0x%x,", cond);
11767 printf (" rdst = 0x%x\n", rdst);
11768 }
11769 SYNTAX("bm%2 #%1, %0%S0");
78e98aab 11770#line 917 "rx-decode.opc"
c7927a3c
NC		 11771 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11772
11773 /*----------------------------------------------------------------------*/
11774 /* CONTROL REGISTERS */
11775
11776 }
11777 break;
11778 case 0xf0:
11779 op_semantics_94:
11780 {
11781 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
78e98aab 11782#line 910 "rx-decode.opc"
c7927a3c 11783 int bittt AU = op[1] & 0x1f;
78e98aab 11784#line 910 "rx-decode.opc"
c7927a3c
NC		 11785 int rdst AU = op[2] & 0x0f;
11786 if (trace)
11787 {
11788 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11789 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11790 op[0], op[1], op[2]);
11791 printf (" bittt = 0x%x,", bittt);
11792 printf (" rdst = 0x%x\n", rdst);
11793 }
11794 SYNTAX("bnot #%1, %0");
78e98aab 11795#line 910 "rx-decode.opc"
c7927a3c
NC		 11796 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11797
11798
11799 }
11800 break;
11801 }
11802 break;
11803 case 0xe1:
11804 GETBYTE ();
11805 switch (op[2] & 0xf0)
11806 {
11807 case 0x00:
11808 case 0x10:
11809 case 0x20:
11810 case 0x30:
11811 case 0x40:
11812 case 0x50:
11813 case 0x60:
11814 case 0x70:
11815 case 0x80:
11816 case 0x90:
11817 case 0xa0:
11818 case 0xb0:
11819 case 0xc0:
11820 case 0xd0:
11821 case 0xe0:
11822 goto op_semantics_93;
11823 break;
11824 case 0xf0:
11825 goto op_semantics_94;
11826 break;
11827 }
11828 break;
11829 case 0xe2:
11830 GETBYTE ();
11831 switch (op[2] & 0xf0)
11832 {
11833 case 0x00:
11834 case 0x10:
11835 case 0x20:
11836 case 0x30:
11837 case 0x40:
11838 case 0x50:
11839 case 0x60:
11840 case 0x70:
11841 case 0x80:
11842 case 0x90:
11843 case 0xa0:
11844 case 0xb0:
11845 case 0xc0:
11846 case 0xd0:
11847 case 0xe0:
11848 goto op_semantics_93;
11849 break;
11850 case 0xf0:
11851 goto op_semantics_94;
11852 break;
11853 }
11854 break;
11855 case 0xe3:
11856 GETBYTE ();
11857 switch (op[2] & 0xf0)
11858 {
11859 case 0x00:
11860 case 0x10:
11861 case 0x20:
11862 case 0x30:
11863 case 0x40:
11864 case 0x50:
11865 case 0x60:
11866 case 0x70:
11867 case 0x80:
11868 case 0x90:
11869 case 0xa0:
11870 case 0xb0:
11871 case 0xc0:
11872 case 0xd0:
11873 case 0xe0:
11874 goto op_semantics_93;
11875 break;
11876 case 0xf0:
11877 goto op_semantics_94;
11878 break;
11879 }
11880 break;
11881 case 0xe4:
11882 GETBYTE ();
11883 switch (op[2] & 0xf0)
11884 {
11885 case 0x00:
11886 case 0x10:
11887 case 0x20:
11888 case 0x30:
11889 case 0x40:
11890 case 0x50:
11891 case 0x60:
11892 case 0x70:
11893 case 0x80:
11894 case 0x90:
11895 case 0xa0:
11896 case 0xb0:
11897 case 0xc0:
11898 case 0xd0:
11899 case 0xe0:
11900 goto op_semantics_93;
11901 break;
11902 case 0xf0:
11903 goto op_semantics_94;
11904 break;
11905 }
11906 break;
11907 case 0xe5:
11908 GETBYTE ();
11909 switch (op[2] & 0xf0)
11910 {
11911 case 0x00:
11912 case 0x10:
11913 case 0x20:
11914 case 0x30:
11915 case 0x40:
11916 case 0x50:
11917 case 0x60:
11918 case 0x70:
11919 case 0x80:
11920 case 0x90:
11921 case 0xa0:
11922 case 0xb0:
11923 case 0xc0:
11924 case 0xd0:
11925 case 0xe0:
11926 goto op_semantics_93;
11927 break;
11928 case 0xf0:
11929 goto op_semantics_94;
11930 break;
11931 }
11932 break;
11933 case 0xe6:
11934 GETBYTE ();
11935 switch (op[2] & 0xf0)
11936 {
11937 case 0x00:
11938 case 0x10:
11939 case 0x20:
11940 case 0x30:
11941 case 0x40:
11942 case 0x50:
11943 case 0x60:
11944 case 0x70:
11945 case 0x80:
11946 case 0x90:
11947 case 0xa0:
11948 case 0xb0:
11949 case 0xc0:
11950 case 0xd0:
11951 case 0xe0:
11952 goto op_semantics_93;
11953 break;
11954 case 0xf0:
11955 goto op_semantics_94;
11956 break;
11957 }
11958 break;
11959 case 0xe7:
11960 GETBYTE ();
11961 switch (op[2] & 0xf0)
11962 {
11963 case 0x00:
11964 case 0x10:
11965 case 0x20:
11966 case 0x30:
11967 case 0x40:
11968 case 0x50:
11969 case 0x60:
11970 case 0x70:
11971 case 0x80:
11972 case 0x90:
11973 case 0xa0:
11974 case 0xb0:
11975 case 0xc0:
11976 case 0xd0:
11977 case 0xe0:
11978 goto op_semantics_93;
11979 break;
11980 case 0xf0:
11981 goto op_semantics_94;
11982 break;
11983 }
11984 break;
11985 case 0xe8:
11986 GETBYTE ();
11987 switch (op[2] & 0xf0)
11988 {
11989 case 0x00:
11990 case 0x10:
11991 case 0x20:
11992 case 0x30:
11993 case 0x40:
11994 case 0x50:
11995 case 0x60:
11996 case 0x70:
11997 case 0x80:
11998 case 0x90:
11999 case 0xa0:
12000 case 0xb0:
12001 case 0xc0:
12002 case 0xd0:
12003 case 0xe0:
12004 goto op_semantics_93;
12005 break;
12006 case 0xf0:
12007 goto op_semantics_94;
12008 break;
12009 }
12010 break;
12011 case 0xe9:
12012 GETBYTE ();
12013 switch (op[2] & 0xf0)
12014 {
12015 case 0x00:
12016 case 0x10:
12017 case 0x20:
12018 case 0x30:
12019 case 0x40:
12020 case 0x50:
12021 case 0x60:
12022 case 0x70:
12023 case 0x80:
12024 case 0x90:
12025 case 0xa0:
12026 case 0xb0:
12027 case 0xc0:
12028 case 0xd0:
12029 case 0xe0:
12030 goto op_semantics_93;
12031 break;
12032 case 0xf0:
12033 goto op_semantics_94;
12034 break;
12035 }
12036 break;
12037 case 0xea:
12038 GETBYTE ();
12039 switch (op[2] & 0xf0)
12040 {
12041 case 0x00:
12042 case 0x10:
12043 case 0x20:
12044 case 0x30:
12045 case 0x40:
12046 case 0x50:
12047 case 0x60:
12048 case 0x70:
12049 case 0x80:
12050 case 0x90:
12051 case 0xa0:
12052 case 0xb0:
12053 case 0xc0:
12054 case 0xd0:
12055 case 0xe0:
12056 goto op_semantics_93;
12057 break;
12058 case 0xf0:
12059 goto op_semantics_94;
12060 break;
12061 }
12062 break;
12063 case 0xeb:
12064 GETBYTE ();
12065 switch (op[2] & 0xf0)
12066 {
12067 case 0x00:
12068 case 0x10:
12069 case 0x20:
12070 case 0x30:
12071 case 0x40:
12072 case 0x50:
12073 case 0x60:
12074 case 0x70:
12075 case 0x80:
12076 case 0x90:
12077 case 0xa0:
12078 case 0xb0:
12079 case 0xc0:
12080 case 0xd0:
12081 case 0xe0:
12082 goto op_semantics_93;
12083 break;
12084 case 0xf0:
12085 goto op_semantics_94;
12086 break;
12087 }
12088 break;
12089 case 0xec:
12090 GETBYTE ();
12091 switch (op[2] & 0xf0)
12092 {
12093 case 0x00:
12094 case 0x10:
12095 case 0x20:
12096 case 0x30:
12097 case 0x40:
12098 case 0x50:
12099 case 0x60:
12100 case 0x70:
12101 case 0x80:
12102 case 0x90:
12103 case 0xa0:
12104 case 0xb0:
12105 case 0xc0:
12106 case 0xd0:
12107 case 0xe0:
12108 goto op_semantics_93;
12109 break;
12110 case 0xf0:
12111 goto op_semantics_94;
12112 break;
12113 }
12114 break;
12115 case 0xed:
12116 GETBYTE ();
12117 switch (op[2] & 0xf0)
12118 {
12119 case 0x00:
12120 case 0x10:
12121 case 0x20:
12122 case 0x30:
12123 case 0x40:
12124 case 0x50:
12125 case 0x60:
12126 case 0x70:
12127 case 0x80:
12128 case 0x90:
12129 case 0xa0:
12130 case 0xb0:
12131 case 0xc0:
12132 case 0xd0:
12133 case 0xe0:
12134 goto op_semantics_93;
12135 break;
12136 case 0xf0:
12137 goto op_semantics_94;
12138 break;
12139 }
12140 break;
12141 case 0xee:
12142 GETBYTE ();
12143 switch (op[2] & 0xf0)
12144 {
12145 case 0x00:
12146 case 0x10:
12147 case 0x20:
12148 case 0x30:
12149 case 0x40:
12150 case 0x50:
12151 case 0x60:
12152 case 0x70:
12153 case 0x80:
12154 case 0x90:
12155 case 0xa0:
12156 case 0xb0:
12157 case 0xc0:
12158 case 0xd0:
12159 case 0xe0:
12160 goto op_semantics_93;
12161 break;
12162 case 0xf0:
12163 goto op_semantics_94;
12164 break;
12165 }
12166 break;
12167 case 0xef:
12168 GETBYTE ();
12169 switch (op[2] & 0xf0)
12170 {
12171 case 0x00:
12172 case 0x10:
12173 case 0x20:
12174 case 0x30:
12175 case 0x40:
12176 case 0x50:
12177 case 0x60:
12178 case 0x70:
12179 case 0x80:
12180 case 0x90:
12181 case 0xa0:
12182 case 0xb0:
12183 case 0xc0:
12184 case 0xd0:
12185 case 0xe0:
12186 goto op_semantics_93;
12187 break;
12188 case 0xf0:
12189 goto op_semantics_94;
12190 break;
12191 }
12192 break;
12193 case 0xf0:
12194 GETBYTE ();
12195 switch (op[2] & 0xf0)
12196 {
12197 case 0x00:
12198 case 0x10:
12199 case 0x20:
12200 case 0x30:
12201 case 0x40:
12202 case 0x50:
12203 case 0x60:
12204 case 0x70:
12205 case 0x80:
12206 case 0x90:
12207 case 0xa0:
12208 case 0xb0:
12209 case 0xc0:
12210 case 0xd0:
12211 case 0xe0:
12212 goto op_semantics_93;
12213 break;
12214 case 0xf0:
12215 goto op_semantics_94;
12216 break;
12217 }
12218 break;
12219 case 0xf1:
12220 GETBYTE ();
12221 switch (op[2] & 0xf0)
12222 {
12223 case 0x00:
12224 case 0x10:
12225 case 0x20:
12226 case 0x30:
12227 case 0x40:
12228 case 0x50:
12229 case 0x60:
12230 case 0x70:
12231 case 0x80:
12232 case 0x90:
12233 case 0xa0:
12234 case 0xb0:
12235 case 0xc0:
12236 case 0xd0:
12237 case 0xe0:
12238 goto op_semantics_93;
12239 break;
12240 case 0xf0:
12241 goto op_semantics_94;
12242 break;
12243 }
12244 break;
12245 case 0xf2:
12246 GETBYTE ();
12247 switch (op[2] & 0xf0)
12248 {
12249 case 0x00:
12250 case 0x10:
12251 case 0x20:
12252 case 0x30:
12253 case 0x40:
12254 case 0x50:
12255 case 0x60:
12256 case 0x70:
12257 case 0x80:
12258 case 0x90:
12259 case 0xa0:
12260 case 0xb0:
12261 case 0xc0:
12262 case 0xd0:
12263 case 0xe0:
12264 goto op_semantics_93;
12265 break;
12266 case 0xf0:
12267 goto op_semantics_94;
12268 break;
12269 }
12270 break;
12271 case 0xf3:
12272 GETBYTE ();
12273 switch (op[2] & 0xf0)
12274 {
12275 case 0x00:
12276 case 0x10:
12277 case 0x20:
12278 case 0x30:
12279 case 0x40:
12280 case 0x50:
12281 case 0x60:
12282 case 0x70:
12283 case 0x80:
12284 case 0x90:
12285 case 0xa0:
12286 case 0xb0:
12287 case 0xc0:
12288 case 0xd0:
12289 case 0xe0:
12290 goto op_semantics_93;
12291 break;
12292 case 0xf0:
12293 goto op_semantics_94;
12294 break;
12295 }
12296 break;
12297 case 0xf4:
12298 GETBYTE ();
12299 switch (op[2] & 0xf0)
12300 {
12301 case 0x00:
12302 case 0x10:
12303 case 0x20:
12304 case 0x30:
12305 case 0x40:
12306 case 0x50:
12307 case 0x60:
12308 case 0x70:
12309 case 0x80:
12310 case 0x90:
12311 case 0xa0:
12312 case 0xb0:
12313 case 0xc0:
12314 case 0xd0:
12315 case 0xe0:
12316 goto op_semantics_93;
12317 break;
12318 case 0xf0:
12319 goto op_semantics_94;
12320 break;
12321 }
12322 break;
12323 case 0xf5:
12324 GETBYTE ();
12325 switch (op[2] & 0xf0)
12326 {
12327 case 0x00:
12328 case 0x10:
12329 case 0x20:
12330 case 0x30:
12331 case 0x40:
12332 case 0x50:
12333 case 0x60:
12334 case 0x70:
12335 case 0x80:
12336 case 0x90:
12337 case 0xa0:
12338 case 0xb0:
12339 case 0xc0:
12340 case 0xd0:
12341 case 0xe0:
12342 goto op_semantics_93;
12343 break;
12344 case 0xf0:
12345 goto op_semantics_94;
12346 break;
12347 }
12348 break;
12349 case 0xf6:
12350 GETBYTE ();
12351 switch (op[2] & 0xf0)
12352 {
12353 case 0x00:
12354 case 0x10:
12355 case 0x20:
12356 case 0x30:
12357 case 0x40:
12358 case 0x50:
12359 case 0x60:
12360 case 0x70:
12361 case 0x80:
12362 case 0x90:
12363 case 0xa0:
12364 case 0xb0:
12365 case 0xc0:
12366 case 0xd0:
12367 case 0xe0:
12368 goto op_semantics_93;
12369 break;
12370 case 0xf0:
12371 goto op_semantics_94;
12372 break;
12373 }
12374 break;
12375 case 0xf7:
12376 GETBYTE ();
12377 switch (op[2] & 0xf0)
12378 {
12379 case 0x00:
12380 case 0x10:
12381 case 0x20:
12382 case 0x30:
12383 case 0x40:
12384 case 0x50:
12385 case 0x60:
12386 case 0x70:
12387 case 0x80:
12388 case 0x90:
12389 case 0xa0:
12390 case 0xb0:
12391 case 0xc0:
12392 case 0xd0:
12393 case 0xe0:
12394 goto op_semantics_93;
12395 break;
12396 case 0xf0:
12397 goto op_semantics_94;
12398 break;
12399 }
12400 break;
12401 case 0xf8:
12402 GETBYTE ();
12403 switch (op[2] & 0xf0)
12404 {
12405 case 0x00:
12406 case 0x10:
12407 case 0x20:
12408 case 0x30:
12409 case 0x40:
12410 case 0x50:
12411 case 0x60:
12412 case 0x70:
12413 case 0x80:
12414 case 0x90:
12415 case 0xa0:
12416 case 0xb0:
12417 case 0xc0:
12418 case 0xd0:
12419 case 0xe0:
12420 goto op_semantics_93;
12421 break;
12422 case 0xf0:
12423 goto op_semantics_94;
12424 break;
12425 }
12426 break;
12427 case 0xf9:
12428 GETBYTE ();
12429 switch (op[2] & 0xf0)
12430 {
12431 case 0x00:
12432 case 0x10:
12433 case 0x20:
12434 case 0x30:
12435 case 0x40:
12436 case 0x50:
12437 case 0x60:
12438 case 0x70:
12439 case 0x80:
12440 case 0x90:
12441 case 0xa0:
12442 case 0xb0:
12443 case 0xc0:
12444 case 0xd0:
12445 case 0xe0:
12446 goto op_semantics_93;
12447 break;
12448 case 0xf0:
12449 goto op_semantics_94;
12450 break;
12451 }
12452 break;
12453 case 0xfa:
12454 GETBYTE ();
12455 switch (op[2] & 0xf0)
12456 {
12457 case 0x00:
12458 case 0x10:
12459 case 0x20:
12460 case 0x30:
12461 case 0x40:
12462 case 0x50:
12463 case 0x60:
12464 case 0x70:
12465 case 0x80:
12466 case 0x90:
12467 case 0xa0:
12468 case 0xb0:
12469 case 0xc0:
12470 case 0xd0:
12471 case 0xe0:
12472 goto op_semantics_93;
12473 break;
12474 case 0xf0:
12475 goto op_semantics_94;
12476 break;
12477 }
12478 break;
12479 case 0xfb:
12480 GETBYTE ();
12481 switch (op[2] & 0xf0)
12482 {
12483 case 0x00:
12484 case 0x10:
12485 case 0x20:
12486 case 0x30:
12487 case 0x40:
12488 case 0x50:
12489 case 0x60:
12490 case 0x70:
12491 case 0x80:
12492 case 0x90:
12493 case 0xa0:
12494 case 0xb0:
12495 case 0xc0:
12496 case 0xd0:
12497 case 0xe0:
12498 goto op_semantics_93;
12499 break;
12500 case 0xf0:
12501 goto op_semantics_94;
12502 break;
12503 }
12504 break;
12505 case 0xfc:
12506 GETBYTE ();
12507 switch (op[2] & 0xf0)
12508 {
12509 case 0x00:
12510 case 0x10:
12511 case 0x20:
12512 case 0x30:
12513 case 0x40:
12514 case 0x50:
12515 case 0x60:
12516 case 0x70:
12517 case 0x80:
12518 case 0x90:
12519 case 0xa0:
12520 case 0xb0:
12521 case 0xc0:
12522 case 0xd0:
12523 case 0xe0:
12524 goto op_semantics_93;
12525 break;
12526 case 0xf0:
12527 goto op_semantics_94;
12528 break;
12529 }
12530 break;
12531 case 0xfd:
12532 GETBYTE ();
12533 switch (op[2] & 0xf0)
12534 {
12535 case 0x00:
12536 case 0x10:
12537 case 0x20:
12538 case 0x30:
12539 case 0x40:
12540 case 0x50:
12541 case 0x60:
12542 case 0x70:
12543 case 0x80:
12544 case 0x90:
12545 case 0xa0:
12546 case 0xb0:
12547 case 0xc0:
12548 case 0xd0:
12549 case 0xe0:
12550 goto op_semantics_93;
12551 break;
12552 case 0xf0:
12553 goto op_semantics_94;
12554 break;
12555 }
12556 break;
12557 case 0xfe:
12558 GETBYTE ();
12559 switch (op[2] & 0xf0)
12560 {
12561 case 0x00:
12562 case 0x10:
12563 case 0x20:
12564 case 0x30:
12565 case 0x40:
12566 case 0x50:
12567 case 0x60:
12568 case 0x70:
12569 case 0x80:
12570 case 0x90:
12571 case 0xa0:
12572 case 0xb0:
12573 case 0xc0:
12574 case 0xd0:
12575 case 0xe0:
12576 goto op_semantics_93;
12577 break;
12578 case 0xf0:
12579 goto op_semantics_94;
12580 break;
12581 }
12582 break;
12583 case 0xff:
12584 GETBYTE ();
12585 switch (op[2] & 0xf0)
12586 {
12587 case 0x00:
12588 case 0x10:
12589 case 0x20:
12590 case 0x30:
12591 case 0x40:
12592 case 0x50:
12593 case 0x60:
12594 case 0x70:
12595 case 0x80:
12596 case 0x90:
12597 case 0xa0:
12598 case 0xb0:
12599 case 0xc0:
12600 case 0xd0:
12601 case 0xe0:
12602 goto op_semantics_93;
12603 break;
12604 case 0xf0:
12605 goto op_semantics_94;
12606 break;
12607 }
12608 break;
12609 default: UNSUPPORTED(); break;
12610 }
12611 break;
12612 case 0xfe:
12613 GETBYTE ();
12614 switch (op[1] & 0xff)
12615 {
12616 case 0x00:
12617 GETBYTE ();
12618 switch (op[2] & 0x00)
12619 {
12620 case 0x00:
12621 op_semantics_95:
12622 {
12623 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
78e98aab 12624#line 315 "rx-decode.opc"
c7927a3c 12625 int sz AU = (op[1] >> 4) & 0x03;
78e98aab 12626#line 315 "rx-decode.opc"
c7927a3c 12627 int isrc AU = op[1] & 0x0f;
78e98aab 12628#line 315 "rx-decode.opc"
c7927a3c 12629 int bsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 12630#line 315 "rx-decode.opc"
c7927a3c
NC		 12631 int rdst AU = op[2] & 0x0f;
12632 if (trace)
12633 {
12634 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12635 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12636 op[0], op[1], op[2]);
12637 printf (" sz = 0x%x,", sz);
12638 printf (" isrc = 0x%x,", isrc);
12639 printf (" bsrc = 0x%x,", bsrc);
12640 printf (" rdst = 0x%x\n", rdst);
12641 }
12642 SYNTAX("mov%s %0, [%1, %2]");
78e98aab 12643#line 315 "rx-decode.opc"
f9c7014e 12644 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
c7927a3c
NC		 12645
12646 }
12647 break;
12648 }
12649 break;
12650 case 0x01:
12651 GETBYTE ();
12652 switch (op[2] & 0x00)
12653 {
12654 case 0x00:
12655 goto op_semantics_95;
12656 break;
12657 }
12658 break;
12659 case 0x02:
12660 GETBYTE ();
12661 switch (op[2] & 0x00)
12662 {
12663 case 0x00:
12664 goto op_semantics_95;
12665 break;
12666 }
12667 break;
12668 case 0x03:
12669 GETBYTE ();
12670 switch (op[2] & 0x00)
12671 {
12672 case 0x00:
12673 goto op_semantics_95;
12674 break;
12675 }
12676 break;
12677 case 0x04:
12678 GETBYTE ();
12679 switch (op[2] & 0x00)
12680 {
12681 case 0x00:
12682 goto op_semantics_95;
12683 break;
12684 }
12685 break;
12686 case 0x05:
12687 GETBYTE ();
12688 switch (op[2] & 0x00)
12689 {
12690 case 0x00:
12691 goto op_semantics_95;
12692 break;
12693 }
12694 break;
12695 case 0x06:
12696 GETBYTE ();
12697 switch (op[2] & 0x00)
12698 {
12699 case 0x00:
12700 goto op_semantics_95;
12701 break;
12702 }
12703 break;
12704 case 0x07:
12705 GETBYTE ();
12706 switch (op[2] & 0x00)
12707 {
12708 case 0x00:
12709 goto op_semantics_95;
12710 break;
12711 }
12712 break;
12713 case 0x08:
12714 GETBYTE ();
12715 switch (op[2] & 0x00)
12716 {
12717 case 0x00:
12718 goto op_semantics_95;
12719 break;
12720 }
12721 break;
12722 case 0x09:
12723 GETBYTE ();
12724 switch (op[2] & 0x00)
12725 {
12726 case 0x00:
12727 goto op_semantics_95;
12728 break;
12729 }
12730 break;
12731 case 0x0a:
12732 GETBYTE ();
12733 switch (op[2] & 0x00)
12734 {
12735 case 0x00:
12736 goto op_semantics_95;
12737 break;
12738 }
12739 break;
12740 case 0x0b:
12741 GETBYTE ();
12742 switch (op[2] & 0x00)
12743 {
12744 case 0x00:
12745 goto op_semantics_95;
12746 break;
12747 }
12748 break;
12749 case 0x0c:
12750 GETBYTE ();
12751 switch (op[2] & 0x00)
12752 {
12753 case 0x00:
12754 goto op_semantics_95;
12755 break;
12756 }
12757 break;
12758 case 0x0d:
12759 GETBYTE ();
12760 switch (op[2] & 0x00)
12761 {
12762 case 0x00:
12763 goto op_semantics_95;
12764 break;
12765 }
12766 break;
12767 case 0x0e:
12768 GETBYTE ();
12769 switch (op[2] & 0x00)
12770 {
12771 case 0x00:
12772 goto op_semantics_95;
12773 break;
12774 }
12775 break;
12776 case 0x0f:
12777 GETBYTE ();
12778 switch (op[2] & 0x00)
12779 {
12780 case 0x00:
12781 goto op_semantics_95;
12782 break;
12783 }
12784 break;
12785 case 0x10:
12786 GETBYTE ();
12787 switch (op[2] & 0x00)
12788 {
12789 case 0x00:
12790 goto op_semantics_95;
12791 break;
12792 }
12793 break;
12794 case 0x11:
12795 GETBYTE ();
12796 switch (op[2] & 0x00)
12797 {
12798 case 0x00:
12799 goto op_semantics_95;
12800 break;
12801 }
12802 break;
12803 case 0x12:
12804 GETBYTE ();
12805 switch (op[2] & 0x00)
12806 {
12807 case 0x00:
12808 goto op_semantics_95;
12809 break;
12810 }
12811 break;
12812 case 0x13:
12813 GETBYTE ();
12814 switch (op[2] & 0x00)
12815 {
12816 case 0x00:
12817 goto op_semantics_95;
12818 break;
12819 }
12820 break;
12821 case 0x14:
12822 GETBYTE ();
12823 switch (op[2] & 0x00)
12824 {
12825 case 0x00:
12826 goto op_semantics_95;
12827 break;
12828 }
12829 break;
12830 case 0x15:
12831 GETBYTE ();
12832 switch (op[2] & 0x00)
12833 {
12834 case 0x00:
12835 goto op_semantics_95;
12836 break;
12837 }
12838 break;
12839 case 0x16:
12840 GETBYTE ();
12841 switch (op[2] & 0x00)
12842 {
12843 case 0x00:
12844 goto op_semantics_95;
12845 break;
12846 }
12847 break;
12848 case 0x17:
12849 GETBYTE ();
12850 switch (op[2] & 0x00)
12851 {
12852 case 0x00:
12853 goto op_semantics_95;
12854 break;
12855 }
12856 break;
12857 case 0x18:
12858 GETBYTE ();
12859 switch (op[2] & 0x00)
12860 {
12861 case 0x00:
12862 goto op_semantics_95;
12863 break;
12864 }
12865 break;
12866 case 0x19:
12867 GETBYTE ();
12868 switch (op[2] & 0x00)
12869 {
12870 case 0x00:
12871 goto op_semantics_95;
12872 break;
12873 }
12874 break;
12875 case 0x1a:
12876 GETBYTE ();
12877 switch (op[2] & 0x00)
12878 {
12879 case 0x00:
12880 goto op_semantics_95;
12881 break;
12882 }
12883 break;
12884 case 0x1b:
12885 GETBYTE ();
12886 switch (op[2] & 0x00)
12887 {
12888 case 0x00:
12889 goto op_semantics_95;
12890 break;
12891 }
12892 break;
12893 case 0x1c:
12894 GETBYTE ();
12895 switch (op[2] & 0x00)
12896 {
12897 case 0x00:
12898 goto op_semantics_95;
12899 break;
12900 }
12901 break;
12902 case 0x1d:
12903 GETBYTE ();
12904 switch (op[2] & 0x00)
12905 {
12906 case 0x00:
12907 goto op_semantics_95;
12908 break;
12909 }
12910 break;
12911 case 0x1e:
12912 GETBYTE ();
12913 switch (op[2] & 0x00)
12914 {
12915 case 0x00:
12916 goto op_semantics_95;
12917 break;
12918 }
12919 break;
12920 case 0x1f:
12921 GETBYTE ();
12922 switch (op[2] & 0x00)
12923 {
12924 case 0x00:
12925 goto op_semantics_95;
12926 break;
12927 }
12928 break;
12929 case 0x20:
12930 GETBYTE ();
12931 switch (op[2] & 0x00)
12932 {
12933 case 0x00:
12934 goto op_semantics_95;
12935 break;
12936 }
12937 break;
12938 case 0x21:
12939 GETBYTE ();
12940 switch (op[2] & 0x00)
12941 {
12942 case 0x00:
12943 goto op_semantics_95;
12944 break;
12945 }
12946 break;
12947 case 0x22:
12948 GETBYTE ();
12949 switch (op[2] & 0x00)
12950 {
12951 case 0x00:
12952 goto op_semantics_95;
12953 break;
12954 }
12955 break;
12956 case 0x23:
12957 GETBYTE ();
12958 switch (op[2] & 0x00)
12959 {
12960 case 0x00:
12961 goto op_semantics_95;
12962 break;
12963 }
12964 break;
12965 case 0x24:
12966 GETBYTE ();
12967 switch (op[2] & 0x00)
12968 {
12969 case 0x00:
12970 goto op_semantics_95;
12971 break;
12972 }
12973 break;
12974 case 0x25:
12975 GETBYTE ();
12976 switch (op[2] & 0x00)
12977 {
12978 case 0x00:
12979 goto op_semantics_95;
12980 break;
12981 }
12982 break;
12983 case 0x26:
12984 GETBYTE ();
12985 switch (op[2] & 0x00)
12986 {
12987 case 0x00:
12988 goto op_semantics_95;
12989 break;
12990 }
12991 break;
12992 case 0x27:
12993 GETBYTE ();
12994 switch (op[2] & 0x00)
12995 {
12996 case 0x00:
12997 goto op_semantics_95;
12998 break;
12999 }
13000 break;
13001 case 0x28:
13002 GETBYTE ();
13003 switch (op[2] & 0x00)
13004 {
13005 case 0x00:
13006 goto op_semantics_95;
13007 break;
13008 }
13009 break;
13010 case 0x29:
13011 GETBYTE ();
13012 switch (op[2] & 0x00)
13013 {
13014 case 0x00:
13015 goto op_semantics_95;
13016 break;
13017 }
13018 break;
13019 case 0x2a:
13020 GETBYTE ();
13021 switch (op[2] & 0x00)
13022 {
13023 case 0x00:
13024 goto op_semantics_95;
13025 break;
13026 }
13027 break;
13028 case 0x2b:
13029 GETBYTE ();
13030 switch (op[2] & 0x00)
13031 {
13032 case 0x00:
13033 goto op_semantics_95;
13034 break;
13035 }
13036 break;
13037 case 0x2c:
13038 GETBYTE ();
13039 switch (op[2] & 0x00)
13040 {
13041 case 0x00:
13042 goto op_semantics_95;
13043 break;
13044 }
13045 break;
13046 case 0x2d:
13047 GETBYTE ();
13048 switch (op[2] & 0x00)
13049 {
13050 case 0x00:
13051 goto op_semantics_95;
13052 break;
13053 }
13054 break;
13055 case 0x2e:
13056 GETBYTE ();
13057 switch (op[2] & 0x00)
13058 {
13059 case 0x00:
13060 goto op_semantics_95;
13061 break;
13062 }
13063 break;
13064 case 0x2f:
13065 GETBYTE ();
13066 switch (op[2] & 0x00)
13067 {
13068 case 0x00:
13069 goto op_semantics_95;
13070 break;
13071 }
13072 break;
13073 case 0x40:
13074 GETBYTE ();
13075 switch (op[2] & 0x00)
13076 {
13077 case 0x00:
13078 op_semantics_96:
13079 {
13080 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
78e98aab 13081#line 312 "rx-decode.opc"
c7927a3c 13082 int sz AU = (op[1] >> 4) & 0x03;
78e98aab 13083#line 312 "rx-decode.opc"
c7927a3c 13084 int isrc AU = op[1] & 0x0f;
78e98aab 13085#line 312 "rx-decode.opc"
c7927a3c 13086 int bsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 13087#line 312 "rx-decode.opc"
c7927a3c
NC		 13088 int rdst AU = op[2] & 0x0f;
13089 if (trace)
13090 {
13091 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13092 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13093 op[0], op[1], op[2]);
13094 printf (" sz = 0x%x,", sz);
13095 printf (" isrc = 0x%x,", isrc);
13096 printf (" bsrc = 0x%x,", bsrc);
13097 printf (" rdst = 0x%x\n", rdst);
13098 }
13099 SYNTAX("mov%s [%1, %2], %0");
78e98aab 13100#line 312 "rx-decode.opc"
f9c7014e 13101 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
c7927a3c
NC		 13102
13103 }
13104 break;
13105 }
13106 break;
13107 case 0x41:
13108 GETBYTE ();
13109 switch (op[2] & 0x00)
13110 {
13111 case 0x00:
13112 goto op_semantics_96;
13113 break;
13114 }
13115 break;
13116 case 0x42:
13117 GETBYTE ();
13118 switch (op[2] & 0x00)
13119 {
13120 case 0x00:
13121 goto op_semantics_96;
13122 break;
13123 }
13124 break;
13125 case 0x43:
13126 GETBYTE ();
13127 switch (op[2] & 0x00)
13128 {
13129 case 0x00:
13130 goto op_semantics_96;
13131 break;
13132 }
13133 break;
13134 case 0x44:
13135 GETBYTE ();
13136 switch (op[2] & 0x00)
13137 {
13138 case 0x00:
13139 goto op_semantics_96;
13140 break;
13141 }
13142 break;
13143 case 0x45:
13144 GETBYTE ();
13145 switch (op[2] & 0x00)
13146 {
13147 case 0x00:
13148 goto op_semantics_96;
13149 break;
13150 }
13151 break;
13152 case 0x46:
13153 GETBYTE ();
13154 switch (op[2] & 0x00)
13155 {
13156 case 0x00:
13157 goto op_semantics_96;
13158 break;
13159 }
13160 break;
13161 case 0x47:
13162 GETBYTE ();
13163 switch (op[2] & 0x00)
13164 {
13165 case 0x00:
13166 goto op_semantics_96;
13167 break;
13168 }
13169 break;
13170 case 0x48:
13171 GETBYTE ();
13172 switch (op[2] & 0x00)
13173 {
13174 case 0x00:
13175 goto op_semantics_96;
13176 break;
13177 }
13178 break;
13179 case 0x49:
13180 GETBYTE ();
13181 switch (op[2] & 0x00)
13182 {
13183 case 0x00:
13184 goto op_semantics_96;
13185 break;
13186 }
13187 break;
13188 case 0x4a:
13189 GETBYTE ();
13190 switch (op[2] & 0x00)
13191 {
13192 case 0x00:
13193 goto op_semantics_96;
13194 break;
13195 }
13196 break;
13197 case 0x4b:
13198 GETBYTE ();
13199 switch (op[2] & 0x00)
13200 {
13201 case 0x00:
13202 goto op_semantics_96;
13203 break;
13204 }
13205 break;
13206 case 0x4c:
13207 GETBYTE ();
13208 switch (op[2] & 0x00)
13209 {
13210 case 0x00:
13211 goto op_semantics_96;
13212 break;
13213 }
13214 break;
13215 case 0x4d:
13216 GETBYTE ();
13217 switch (op[2] & 0x00)
13218 {
13219 case 0x00:
13220 goto op_semantics_96;
13221 break;
13222 }
13223 break;
13224 case 0x4e:
13225 GETBYTE ();
13226 switch (op[2] & 0x00)
13227 {
13228 case 0x00:
13229 goto op_semantics_96;
13230 break;
13231 }
13232 break;
13233 case 0x4f:
13234 GETBYTE ();
13235 switch (op[2] & 0x00)
13236 {
13237 case 0x00:
13238 goto op_semantics_96;
13239 break;
13240 }
13241 break;
13242 case 0x50:
13243 GETBYTE ();
13244 switch (op[2] & 0x00)
13245 {
13246 case 0x00:
13247 goto op_semantics_96;
13248 break;
13249 }
13250 break;
13251 case 0x51:
13252 GETBYTE ();
13253 switch (op[2] & 0x00)
13254 {
13255 case 0x00:
13256 goto op_semantics_96;
13257 break;
13258 }
13259 break;
13260 case 0x52:
13261 GETBYTE ();
13262 switch (op[2] & 0x00)
13263 {
13264 case 0x00:
13265 goto op_semantics_96;
13266 break;
13267 }
13268 break;
13269 case 0x53:
13270 GETBYTE ();
13271 switch (op[2] & 0x00)
13272 {
13273 case 0x00:
13274 goto op_semantics_96;
13275 break;
13276 }
13277 break;
13278 case 0x54:
13279 GETBYTE ();
13280 switch (op[2] & 0x00)
13281 {
13282 case 0x00:
13283 goto op_semantics_96;
13284 break;
13285 }
13286 break;
13287 case 0x55:
13288 GETBYTE ();
13289 switch (op[2] & 0x00)
13290 {
13291 case 0x00:
13292 goto op_semantics_96;
13293 break;
13294 }
13295 break;
13296 case 0x56:
13297 GETBYTE ();
13298 switch (op[2] & 0x00)
13299 {
13300 case 0x00:
13301 goto op_semantics_96;
13302 break;
13303 }
13304 break;
13305 case 0x57:
13306 GETBYTE ();
13307 switch (op[2] & 0x00)
13308 {
13309 case 0x00:
13310 goto op_semantics_96;
13311 break;
13312 }
13313 break;
13314 case 0x58:
13315 GETBYTE ();
13316 switch (op[2] & 0x00)
13317 {
13318 case 0x00:
13319 goto op_semantics_96;
13320 break;
13321 }
13322 break;
13323 case 0x59:
13324 GETBYTE ();
13325 switch (op[2] & 0x00)
13326 {
13327 case 0x00:
13328 goto op_semantics_96;
13329 break;
13330 }
13331 break;
13332 case 0x5a:
13333 GETBYTE ();
13334 switch (op[2] & 0x00)
13335 {
13336 case 0x00:
13337 goto op_semantics_96;
13338 break;
13339 }
13340 break;
13341 case 0x5b:
13342 GETBYTE ();
13343 switch (op[2] & 0x00)
13344 {
13345 case 0x00:
13346 goto op_semantics_96;
13347 break;
13348 }
13349 break;
13350 case 0x5c:
13351 GETBYTE ();
13352 switch (op[2] & 0x00)
13353 {
13354 case 0x00:
13355 goto op_semantics_96;
13356 break;
13357 }
13358 break;
13359 case 0x5d:
13360 GETBYTE ();
13361 switch (op[2] & 0x00)
13362 {
13363 case 0x00:
13364 goto op_semantics_96;
13365 break;
13366 }
13367 break;
13368 case 0x5e:
13369 GETBYTE ();
13370 switch (op[2] & 0x00)
13371 {
13372 case 0x00:
13373 goto op_semantics_96;
13374 break;
13375 }
13376 break;
13377 case 0x5f:
13378 GETBYTE ();
13379 switch (op[2] & 0x00)
13380 {
13381 case 0x00:
13382 goto op_semantics_96;
13383 break;
13384 }
13385 break;
13386 case 0x60:
13387 GETBYTE ();
13388 switch (op[2] & 0x00)
13389 {
13390 case 0x00:
13391 goto op_semantics_96;
13392 break;
13393 }
13394 break;
13395 case 0x61:
13396 GETBYTE ();
13397 switch (op[2] & 0x00)
13398 {
13399 case 0x00:
13400 goto op_semantics_96;
13401 break;
13402 }
13403 break;
13404 case 0x62:
13405 GETBYTE ();
13406 switch (op[2] & 0x00)
13407 {
13408 case 0x00:
13409 goto op_semantics_96;
13410 break;
13411 }
13412 break;
13413 case 0x63:
13414 GETBYTE ();
13415 switch (op[2] & 0x00)
13416 {
13417 case 0x00:
13418 goto op_semantics_96;
13419 break;
13420 }
13421 break;
13422 case 0x64:
13423 GETBYTE ();
13424 switch (op[2] & 0x00)
13425 {
13426 case 0x00:
13427 goto op_semantics_96;
13428 break;
13429 }
13430 break;
13431 case 0x65:
13432 GETBYTE ();
13433 switch (op[2] & 0x00)
13434 {
13435 case 0x00:
13436 goto op_semantics_96;
13437 break;
13438 }
13439 break;
13440 case 0x66:
13441 GETBYTE ();
13442 switch (op[2] & 0x00)
13443 {
13444 case 0x00:
13445 goto op_semantics_96;
13446 break;
13447 }
13448 break;
13449 case 0x67:
13450 GETBYTE ();
13451 switch (op[2] & 0x00)
13452 {
13453 case 0x00:
13454 goto op_semantics_96;
13455 break;
13456 }
13457 break;
13458 case 0x68:
13459 GETBYTE ();
13460 switch (op[2] & 0x00)
13461 {
13462 case 0x00:
13463 goto op_semantics_96;
13464 break;
13465 }
13466 break;
13467 case 0x69:
13468 GETBYTE ();
13469 switch (op[2] & 0x00)
13470 {
13471 case 0x00:
13472 goto op_semantics_96;
13473 break;
13474 }
13475 break;
13476 case 0x6a:
13477 GETBYTE ();
13478 switch (op[2] & 0x00)
13479 {
13480 case 0x00:
13481 goto op_semantics_96;
13482 break;
13483 }
13484 break;
13485 case 0x6b:
13486 GETBYTE ();
13487 switch (op[2] & 0x00)
13488 {
13489 case 0x00:
13490 goto op_semantics_96;
13491 break;
13492 }
13493 break;
13494 case 0x6c:
13495 GETBYTE ();
13496 switch (op[2] & 0x00)
13497 {
13498 case 0x00:
13499 goto op_semantics_96;
13500 break;
13501 }
13502 break;
13503 case 0x6d:
13504 GETBYTE ();
13505 switch (op[2] & 0x00)
13506 {
13507 case 0x00:
13508 goto op_semantics_96;
13509 break;
13510 }
13511 break;
13512 case 0x6e:
13513 GETBYTE ();
13514 switch (op[2] & 0x00)
13515 {
13516 case 0x00:
13517 goto op_semantics_96;
13518 break;
13519 }
13520 break;
13521 case 0x6f:
13522 GETBYTE ();
13523 switch (op[2] & 0x00)
13524 {
13525 case 0x00:
13526 goto op_semantics_96;
13527 break;
13528 }
13529 break;
13530 case 0xc0:
13531 GETBYTE ();
13532 switch (op[2] & 0x00)
13533 {
13534 case 0x00:
13535 op_semantics_97:
13536 {
13537 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
78e98aab 13538#line 318 "rx-decode.opc"
c7927a3c 13539 int sz AU = (op[1] >> 4) & 0x03;
78e98aab 13540#line 318 "rx-decode.opc"
c7927a3c 13541 int isrc AU = op[1] & 0x0f;
78e98aab 13542#line 318 "rx-decode.opc"
c7927a3c 13543 int bsrc AU = (op[2] >> 4) & 0x0f;
78e98aab 13544#line 318 "rx-decode.opc"
c7927a3c
NC		 13545 int rdst AU = op[2] & 0x0f;
13546 if (trace)
13547 {
13548 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13549 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13550 op[0], op[1], op[2]);
13551 printf (" sz = 0x%x,", sz);
13552 printf (" isrc = 0x%x,", isrc);
13553 printf (" bsrc = 0x%x,", bsrc);
13554 printf (" rdst = 0x%x\n", rdst);
13555 }
13556 SYNTAX("movu%s [%1, %2], %0");
78e98aab 13557#line 318 "rx-decode.opc"
f9c7014e 13558 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
c7927a3c
NC		 13559
13560 }
13561 break;
13562 }
13563 break;
13564 case 0xc1:
13565 GETBYTE ();
13566 switch (op[2] & 0x00)
13567 {
13568 case 0x00:
13569 goto op_semantics_97;
13570 break;
13571 }
13572 break;
13573 case 0xc2:
13574 GETBYTE ();
13575 switch (op[2] & 0x00)
13576 {
13577 case 0x00:
13578 goto op_semantics_97;
13579 break;
13580 }
13581 break;
13582 case 0xc3:
13583 GETBYTE ();
13584 switch (op[2] & 0x00)
13585 {
13586 case 0x00:
13587 goto op_semantics_97;
13588 break;
13589 }
13590 break;
13591 case 0xc4:
13592 GETBYTE ();
13593 switch (op[2] & 0x00)
13594 {
13595 case 0x00:
13596 goto op_semantics_97;
13597 break;
13598 }
13599 break;
13600 case 0xc5:
13601 GETBYTE ();
13602 switch (op[2] & 0x00)
13603 {
13604 case 0x00:
13605 goto op_semantics_97;
13606 break;
13607 }
13608 break;
13609 case 0xc6:
13610 GETBYTE ();
13611 switch (op[2] & 0x00)
13612 {
13613 case 0x00:
13614 goto op_semantics_97;
13615 break;
13616 }
13617 break;
13618 case 0xc7:
13619 GETBYTE ();
13620 switch (op[2] & 0x00)
13621 {
13622 case 0x00:
13623 goto op_semantics_97;
13624 break;
13625 }
13626 break;
13627 case 0xc8:
13628 GETBYTE ();
13629 switch (op[2] & 0x00)
13630 {
13631 case 0x00:
13632 goto op_semantics_97;
13633 break;
13634 }
13635 break;
13636 case 0xc9:
13637 GETBYTE ();
13638 switch (op[2] & 0x00)
13639 {
13640 case 0x00:
13641 goto op_semantics_97;
13642 break;
13643 }
13644 break;
13645 case 0xca:
13646 GETBYTE ();
13647 switch (op[2] & 0x00)
13648 {
13649 case 0x00:
13650 goto op_semantics_97;
13651 break;
13652 }
13653 break;
13654 case 0xcb:
13655 GETBYTE ();
13656 switch (op[2] & 0x00)
13657 {
13658 case 0x00:
13659 goto op_semantics_97;
13660 break;
13661 }
13662 break;
13663 case 0xcc:
13664 GETBYTE ();
13665 switch (op[2] & 0x00)
13666 {
13667 case 0x00:
13668 goto op_semantics_97;
13669 break;
13670 }
13671 break;
13672 case 0xcd:
13673 GETBYTE ();
13674 switch (op[2] & 0x00)
13675 {
13676 case 0x00:
13677 goto op_semantics_97;
13678 break;
13679 }
13680 break;
13681 case 0xce:
13682 GETBYTE ();
13683 switch (op[2] & 0x00)
13684 {
13685 case 0x00:
13686 goto op_semantics_97;
13687 break;
13688 }
13689 break;
13690 case 0xcf:
13691 GETBYTE ();
13692 switch (op[2] & 0x00)
13693 {
13694 case 0x00:
13695 goto op_semantics_97;
13696 break;
13697 }
13698 break;
13699 case 0xd0:
13700 GETBYTE ();
13701 switch (op[2] & 0x00)
13702 {
13703 case 0x00:
13704 goto op_semantics_97;
13705 break;
13706 }
13707 break;
13708 case 0xd1:
13709 GETBYTE ();
13710 switch (op[2] & 0x00)
13711 {
13712 case 0x00:
13713 goto op_semantics_97;
13714 break;
13715 }
13716 break;
13717 case 0xd2:
13718 GETBYTE ();
13719 switch (op[2] & 0x00)
13720 {
13721 case 0x00:
13722 goto op_semantics_97;
13723 break;
13724 }
13725 break;
13726 case 0xd3:
13727 GETBYTE ();
13728 switch (op[2] & 0x00)
13729 {
13730 case 0x00:
13731 goto op_semantics_97;
13732 break;
13733 }
13734 break;
13735 case 0xd4:
13736 GETBYTE ();
13737 switch (op[2] & 0x00)
13738 {
13739 case 0x00:
13740 goto op_semantics_97;
13741 break;
13742 }
13743 break;
13744 case 0xd5:
13745 GETBYTE ();
13746 switch (op[2] & 0x00)
13747 {
13748 case 0x00:
13749 goto op_semantics_97;
13750 break;
13751 }
13752 break;
13753 case 0xd6:
13754 GETBYTE ();
13755 switch (op[2] & 0x00)
13756 {
13757 case 0x00:
13758 goto op_semantics_97;
13759 break;
13760 }
13761 break;
13762 case 0xd7:
13763 GETBYTE ();
13764 switch (op[2] & 0x00)
13765 {
13766 case 0x00:
13767 goto op_semantics_97;
13768 break;
13769 }
13770 break;
13771 case 0xd8:
13772 GETBYTE ();
13773 switch (op[2] & 0x00)
13774 {
13775 case 0x00:
13776 goto op_semantics_97;
13777 break;
13778 }
13779 break;
13780 case 0xd9:
13781 GETBYTE ();
13782 switch (op[2] & 0x00)
13783 {
13784 case 0x00:
13785 goto op_semantics_97;
13786 break;
13787 }
13788 break;
13789 case 0xda:
13790 GETBYTE ();
13791 switch (op[2] & 0x00)
13792 {
13793 case 0x00:
13794 goto op_semantics_97;
13795 break;
13796 }
13797 break;
13798 case 0xdb:
13799 GETBYTE ();
13800 switch (op[2] & 0x00)
13801 {
13802 case 0x00:
13803 goto op_semantics_97;
13804 break;
13805 }
13806 break;
13807 case 0xdc:
13808 GETBYTE ();
13809 switch (op[2] & 0x00)
13810 {
13811 case 0x00:
13812 goto op_semantics_97;
13813 break;
13814 }
13815 break;
13816 case 0xdd:
13817 GETBYTE ();
13818 switch (op[2] & 0x00)
13819 {
13820 case 0x00:
13821 goto op_semantics_97;
13822 break;
13823 }
13824 break;
13825 case 0xde:
13826 GETBYTE ();
13827 switch (op[2] & 0x00)
13828 {
13829 case 0x00:
13830 goto op_semantics_97;
13831 break;
13832 }
13833 break;
13834 case 0xdf:
13835 GETBYTE ();
13836 switch (op[2] & 0x00)
13837 {
13838 case 0x00:
13839 goto op_semantics_97;
13840 break;
13841 }
13842 break;
13843 case 0xe0:
13844 GETBYTE ();
13845 switch (op[2] & 0x00)
13846 {
13847 case 0x00:
13848 goto op_semantics_97;
13849 break;
13850 }
13851 break;
13852 case 0xe1:
13853 GETBYTE ();
13854 switch (op[2] & 0x00)
13855 {
13856 case 0x00:
13857 goto op_semantics_97;
13858 break;
13859 }
13860 break;
13861 case 0xe2:
13862 GETBYTE ();
13863 switch (op[2] & 0x00)
13864 {
13865 case 0x00:
13866 goto op_semantics_97;
13867 break;
13868 }
13869 break;
13870 case 0xe3:
13871 GETBYTE ();
13872 switch (op[2] & 0x00)
13873 {
13874 case 0x00:
13875 goto op_semantics_97;
13876 break;
13877 }
13878 break;
13879 case 0xe4:
13880 GETBYTE ();
13881 switch (op[2] & 0x00)
13882 {
13883 case 0x00:
13884 goto op_semantics_97;
13885 break;
13886 }
13887 break;
13888 case 0xe5:
13889 GETBYTE ();
13890 switch (op[2] & 0x00)
13891 {
13892 case 0x00:
13893 goto op_semantics_97;
13894 break;
13895 }
13896 break;
13897 case 0xe6:
13898 GETBYTE ();
13899 switch (op[2] & 0x00)
13900 {
13901 case 0x00:
13902 goto op_semantics_97;
13903 break;
13904 }
13905 break;
13906 case 0xe7:
13907 GETBYTE ();
13908 switch (op[2] & 0x00)
13909 {
13910 case 0x00:
13911 goto op_semantics_97;
13912 break;
13913 }
13914 break;
13915 case 0xe8:
13916 GETBYTE ();
13917 switch (op[2] & 0x00)
13918 {
13919 case 0x00:
13920 goto op_semantics_97;
13921 break;
13922 }
13923 break;
13924 case 0xe9:
13925 GETBYTE ();
13926 switch (op[2] & 0x00)
13927 {
13928 case 0x00:
13929 goto op_semantics_97;
13930 break;
13931 }
13932 break;
13933 case 0xea:
13934 GETBYTE ();
13935 switch (op[2] & 0x00)
13936 {
13937 case 0x00:
13938 goto op_semantics_97;
13939 break;
13940 }
13941 break;
13942 case 0xeb:
13943 GETBYTE ();
13944 switch (op[2] & 0x00)
13945 {
13946 case 0x00:
13947 goto op_semantics_97;
13948 break;
13949 }
13950 break;
13951 case 0xec:
13952 GETBYTE ();
13953 switch (op[2] & 0x00)
13954 {
13955 case 0x00:
13956 goto op_semantics_97;
13957 break;
13958 }
13959 break;
13960 case 0xed:
13961 GETBYTE ();
13962 switch (op[2] & 0x00)
13963 {
13964 case 0x00:
13965 goto op_semantics_97;
13966 break;
13967 }
13968 break;
13969 case 0xee:
13970 GETBYTE ();
13971 switch (op[2] & 0x00)
13972 {
13973 case 0x00:
13974 goto op_semantics_97;
13975 break;
13976 }
13977 break;
13978 case 0xef:
13979 GETBYTE ();
13980 switch (op[2] & 0x00)
13981 {
13982 case 0x00:
13983 goto op_semantics_97;
13984 break;
13985 }
13986 break;
13987 default: UNSUPPORTED(); break;
13988 }
13989 break;
13990 case 0xff:
13991 GETBYTE ();
13992 switch (op[1] & 0xff)
13993 {
13994 case 0x00:
13995 GETBYTE ();
13996 switch (op[2] & 0x00)
13997 {
13998 case 0x00:
13999 op_semantics_98:
14000 {
14001 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
78e98aab 14002#line 522 "rx-decode.opc"
c7927a3c 14003 int rdst AU = op[1] & 0x0f;
78e98aab 14004#line 522 "rx-decode.opc"
c7927a3c 14005 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 14006#line 522 "rx-decode.opc"
c7927a3c
NC		 14007 int srcb AU = op[2] & 0x0f;
14008 if (trace)
14009 {
14010 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14011 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
14012 op[0], op[1], op[2]);
14013 printf (" rdst = 0x%x,", rdst);
14014 printf (" srca = 0x%x,", srca);
14015 printf (" srcb = 0x%x\n", srcb);
14016 }
14017 SYNTAX("sub %2, %1, %0");
78e98aab 14018#line 522 "rx-decode.opc"
3cf79a01 14019 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
c7927a3c
NC		 14020
14021 /*----------------------------------------------------------------------*/
14022 /* SBB */
14023
14024 }
14025 break;
14026 }
14027 break;
14028 case 0x01:
14029 GETBYTE ();
14030 switch (op[2] & 0x00)
14031 {
14032 case 0x00:
14033 goto op_semantics_98;
14034 break;
14035 }
14036 break;
14037 case 0x02:
14038 GETBYTE ();
14039 switch (op[2] & 0x00)
14040 {
14041 case 0x00:
14042 goto op_semantics_98;
14043 break;
14044 }
14045 break;
14046 case 0x03:
14047 GETBYTE ();
14048 switch (op[2] & 0x00)
14049 {
14050 case 0x00:
14051 goto op_semantics_98;
14052 break;
14053 }
14054 break;
14055 case 0x04:
14056 GETBYTE ();
14057 switch (op[2] & 0x00)
14058 {
14059 case 0x00:
14060 goto op_semantics_98;
14061 break;
14062 }
14063 break;
14064 case 0x05:
14065 GETBYTE ();
14066 switch (op[2] & 0x00)
14067 {
14068 case 0x00:
14069 goto op_semantics_98;
14070 break;
14071 }
14072 break;
14073 case 0x06:
14074 GETBYTE ();
14075 switch (op[2] & 0x00)
14076 {
14077 case 0x00:
14078 goto op_semantics_98;
14079 break;
14080 }
14081 break;
14082 case 0x07:
14083 GETBYTE ();
14084 switch (op[2] & 0x00)
14085 {
14086 case 0x00:
14087 goto op_semantics_98;
14088 break;
14089 }
14090 break;
14091 case 0x08:
14092 GETBYTE ();
14093 switch (op[2] & 0x00)
14094 {
14095 case 0x00:
14096 goto op_semantics_98;
14097 break;
14098 }
14099 break;
14100 case 0x09:
14101 GETBYTE ();
14102 switch (op[2] & 0x00)
14103 {
14104 case 0x00:
14105 goto op_semantics_98;
14106 break;
14107 }
14108 break;
14109 case 0x0a:
14110 GETBYTE ();
14111 switch (op[2] & 0x00)
14112 {
14113 case 0x00:
14114 goto op_semantics_98;
14115 break;
14116 }
14117 break;
14118 case 0x0b:
14119 GETBYTE ();
14120 switch (op[2] & 0x00)
14121 {
14122 case 0x00:
14123 goto op_semantics_98;
14124 break;
14125 }
14126 break;
14127 case 0x0c:
14128 GETBYTE ();
14129 switch (op[2] & 0x00)
14130 {
14131 case 0x00:
14132 goto op_semantics_98;
14133 break;
14134 }
14135 break;
14136 case 0x0d:
14137 GETBYTE ();
14138 switch (op[2] & 0x00)
14139 {
14140 case 0x00:
14141 goto op_semantics_98;
14142 break;
14143 }
14144 break;
14145 case 0x0e:
14146 GETBYTE ();
14147 switch (op[2] & 0x00)
14148 {
14149 case 0x00:
14150 goto op_semantics_98;
14151 break;
14152 }
14153 break;
14154 case 0x0f:
14155 GETBYTE ();
14156 switch (op[2] & 0x00)
14157 {
14158 case 0x00:
14159 goto op_semantics_98;
14160 break;
14161 }
14162 break;
14163 case 0x20:
14164 GETBYTE ();
14165 switch (op[2] & 0x00)
14166 {
14167 case 0x00:
14168 op_semantics_99:
14169 {
14170 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
78e98aab 14171#line 489 "rx-decode.opc"
c7927a3c 14172 int rdst AU = op[1] & 0x0f;
78e98aab 14173#line 489 "rx-decode.opc"
c7927a3c 14174 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 14175#line 489 "rx-decode.opc"
c7927a3c
NC		 14176 int srcb AU = op[2] & 0x0f;
14177 if (trace)
14178 {
14179 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14180 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14181 op[0], op[1], op[2]);
14182 printf (" rdst = 0x%x,", rdst);
14183 printf (" srca = 0x%x,", srca);
14184 printf (" srcb = 0x%x\n", srcb);
14185 }
14186 SYNTAX("add %2, %1, %0");
78e98aab 14187#line 489 "rx-decode.opc"
3cf79a01 14188 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
c7927a3c
NC		 14189
14190 /*----------------------------------------------------------------------*/
14191 /* CMP */
14192
14193 }
14194 break;
14195 }
14196 break;
14197 case 0x21:
14198 GETBYTE ();
14199 switch (op[2] & 0x00)
14200 {
14201 case 0x00:
14202 goto op_semantics_99;
14203 break;
14204 }
14205 break;
14206 case 0x22:
14207 GETBYTE ();
14208 switch (op[2] & 0x00)
14209 {
14210 case 0x00:
14211 goto op_semantics_99;
14212 break;
14213 }
14214 break;
14215 case 0x23:
14216 GETBYTE ();
14217 switch (op[2] & 0x00)
14218 {
14219 case 0x00:
14220 goto op_semantics_99;
14221 break;
14222 }
14223 break;
14224 case 0x24:
14225 GETBYTE ();
14226 switch (op[2] & 0x00)
14227 {
14228 case 0x00:
14229 goto op_semantics_99;
14230 break;
14231 }
14232 break;
14233 case 0x25:
14234 GETBYTE ();
14235 switch (op[2] & 0x00)
14236 {
14237 case 0x00:
14238 goto op_semantics_99;
14239 break;
14240 }
14241 break;
14242 case 0x26:
14243 GETBYTE ();
14244 switch (op[2] & 0x00)
14245 {
14246 case 0x00:
14247 goto op_semantics_99;
14248 break;
14249 }
14250 break;
14251 case 0x27:
14252 GETBYTE ();
14253 switch (op[2] & 0x00)
14254 {
14255 case 0x00:
14256 goto op_semantics_99;
14257 break;
14258 }
14259 break;
14260 case 0x28:
14261 GETBYTE ();
14262 switch (op[2] & 0x00)
14263 {
14264 case 0x00:
14265 goto op_semantics_99;
14266 break;
14267 }
14268 break;
14269 case 0x29:
14270 GETBYTE ();
14271 switch (op[2] & 0x00)
14272 {
14273 case 0x00:
14274 goto op_semantics_99;
14275 break;
14276 }
14277 break;
14278 case 0x2a:
14279 GETBYTE ();
14280 switch (op[2] & 0x00)
14281 {
14282 case 0x00:
14283 goto op_semantics_99;
14284 break;
14285 }
14286 break;
14287 case 0x2b:
14288 GETBYTE ();
14289 switch (op[2] & 0x00)
14290 {
14291 case 0x00:
14292 goto op_semantics_99;
14293 break;
14294 }
14295 break;
14296 case 0x2c:
14297 GETBYTE ();
14298 switch (op[2] & 0x00)
14299 {
14300 case 0x00:
14301 goto op_semantics_99;
14302 break;
14303 }
14304 break;
14305 case 0x2d:
14306 GETBYTE ();
14307 switch (op[2] & 0x00)
14308 {
14309 case 0x00:
14310 goto op_semantics_99;
14311 break;
14312 }
14313 break;
14314 case 0x2e:
14315 GETBYTE ();
14316 switch (op[2] & 0x00)
14317 {
14318 case 0x00:
14319 goto op_semantics_99;
14320 break;
14321 }
14322 break;
14323 case 0x2f:
14324 GETBYTE ();
14325 switch (op[2] & 0x00)
14326 {
14327 case 0x00:
14328 goto op_semantics_99;
14329 break;
14330 }
14331 break;
14332 case 0x30:
14333 GETBYTE ();
14334 switch (op[2] & 0x00)
14335 {
14336 case 0x00:
14337 op_semantics_100:
14338 {
14339 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
78e98aab 14340#line 591 "rx-decode.opc"
c7927a3c 14341 int rdst AU = op[1] & 0x0f;
78e98aab 14342#line 591 "rx-decode.opc"
c7927a3c 14343 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 14344#line 591 "rx-decode.opc"
c7927a3c
NC		 14345 int srcb AU = op[2] & 0x0f;
14346 if (trace)
14347 {
14348 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14349 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14350 op[0], op[1], op[2]);
14351 printf (" rdst = 0x%x,", rdst);
14352 printf (" srca = 0x%x,", srca);
14353 printf (" srcb = 0x%x\n", srcb);
14354 }
14355 SYNTAX("mul %2, %1, %0");
78e98aab 14356#line 591 "rx-decode.opc"
3cf79a01 14357 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
c7927a3c
NC		 14358
14359 /*----------------------------------------------------------------------*/
14360 /* EMUL */
14361
14362 }
14363 break;
14364 }
14365 break;
14366 case 0x31:
14367 GETBYTE ();
14368 switch (op[2] & 0x00)
14369 {
14370 case 0x00:
14371 goto op_semantics_100;
14372 break;
14373 }
14374 break;
14375 case 0x32:
14376 GETBYTE ();
14377 switch (op[2] & 0x00)
14378 {
14379 case 0x00:
14380 goto op_semantics_100;
14381 break;
14382 }
14383 break;
14384 case 0x33:
14385 GETBYTE ();
14386 switch (op[2] & 0x00)
14387 {
14388 case 0x00:
14389 goto op_semantics_100;
14390 break;
14391 }
14392 break;
14393 case 0x34:
14394 GETBYTE ();
14395 switch (op[2] & 0x00)
14396 {
14397 case 0x00:
14398 goto op_semantics_100;
14399 break;
14400 }
14401 break;
14402 case 0x35:
14403 GETBYTE ();
14404 switch (op[2] & 0x00)
14405 {
14406 case 0x00:
14407 goto op_semantics_100;
14408 break;
14409 }
14410 break;
14411 case 0x36:
14412 GETBYTE ();
14413 switch (op[2] & 0x00)
14414 {
14415 case 0x00:
14416 goto op_semantics_100;
14417 break;
14418 }
14419 break;
14420 case 0x37:
14421 GETBYTE ();
14422 switch (op[2] & 0x00)
14423 {
14424 case 0x00:
14425 goto op_semantics_100;
14426 break;
14427 }
14428 break;
14429 case 0x38:
14430 GETBYTE ();
14431 switch (op[2] & 0x00)
14432 {
14433 case 0x00:
14434 goto op_semantics_100;
14435 break;
14436 }
14437 break;
14438 case 0x39:
14439 GETBYTE ();
14440 switch (op[2] & 0x00)
14441 {
14442 case 0x00:
14443 goto op_semantics_100;
14444 break;
14445 }
14446 break;
14447 case 0x3a:
14448 GETBYTE ();
14449 switch (op[2] & 0x00)
14450 {
14451 case 0x00:
14452 goto op_semantics_100;
14453 break;
14454 }
14455 break;
14456 case 0x3b:
14457 GETBYTE ();
14458 switch (op[2] & 0x00)
14459 {
14460 case 0x00:
14461 goto op_semantics_100;
14462 break;
14463 }
14464 break;
14465 case 0x3c:
14466 GETBYTE ();
14467 switch (op[2] & 0x00)
14468 {
14469 case 0x00:
14470 goto op_semantics_100;
14471 break;
14472 }
14473 break;
14474 case 0x3d:
14475 GETBYTE ();
14476 switch (op[2] & 0x00)
14477 {
14478 case 0x00:
14479 goto op_semantics_100;
14480 break;
14481 }
14482 break;
14483 case 0x3e:
14484 GETBYTE ();
14485 switch (op[2] & 0x00)
14486 {
14487 case 0x00:
14488 goto op_semantics_100;
14489 break;
14490 }
14491 break;
14492 case 0x3f:
14493 GETBYTE ();
14494 switch (op[2] & 0x00)
14495 {
14496 case 0x00:
14497 goto op_semantics_100;
14498 break;
14499 }
14500 break;
14501 case 0x40:
14502 GETBYTE ();
14503 switch (op[2] & 0x00)
14504 {
14505 case 0x00:
14506 op_semantics_101:
14507 {
14508 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
78e98aab 14509#line 399 "rx-decode.opc"
c7927a3c 14510 int rdst AU = op[1] & 0x0f;
78e98aab 14511#line 399 "rx-decode.opc"
c7927a3c 14512 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 14513#line 399 "rx-decode.opc"
c7927a3c
NC		 14514 int srcb AU = op[2] & 0x0f;
14515 if (trace)
14516 {
14517 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14518 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14519 op[0], op[1], op[2]);
14520 printf (" rdst = 0x%x,", rdst);
14521 printf (" srca = 0x%x,", srca);
14522 printf (" srcb = 0x%x\n", srcb);
14523 }
14524 SYNTAX("and %2, %1, %0");
78e98aab 14525#line 399 "rx-decode.opc"
3cf79a01 14526 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
c7927a3c
NC		 14527
14528 /*----------------------------------------------------------------------*/
14529 /* OR */
14530
14531 }
14532 break;
14533 }
14534 break;
14535 case 0x41:
14536 GETBYTE ();
14537 switch (op[2] & 0x00)
14538 {
14539 case 0x00:
14540 goto op_semantics_101;
14541 break;
14542 }
14543 break;
14544 case 0x42:
14545 GETBYTE ();
14546 switch (op[2] & 0x00)
14547 {
14548 case 0x00:
14549 goto op_semantics_101;
14550 break;
14551 }
14552 break;
14553 case 0x43:
14554 GETBYTE ();
14555 switch (op[2] & 0x00)
14556 {
14557 case 0x00:
14558 goto op_semantics_101;
14559 break;
14560 }
14561 break;
14562 case 0x44:
14563 GETBYTE ();
14564 switch (op[2] & 0x00)
14565 {
14566 case 0x00:
14567 goto op_semantics_101;
14568 break;
14569 }
14570 break;
14571 case 0x45:
14572 GETBYTE ();
14573 switch (op[2] & 0x00)
14574 {
14575 case 0x00:
14576 goto op_semantics_101;
14577 break;
14578 }
14579 break;
14580 case 0x46:
14581 GETBYTE ();
14582 switch (op[2] & 0x00)
14583 {
14584 case 0x00:
14585 goto op_semantics_101;
14586 break;
14587 }
14588 break;
14589 case 0x47:
14590 GETBYTE ();
14591 switch (op[2] & 0x00)
14592 {
14593 case 0x00:
14594 goto op_semantics_101;
14595 break;
14596 }
14597 break;
14598 case 0x48:
14599 GETBYTE ();
14600 switch (op[2] & 0x00)
14601 {
14602 case 0x00:
14603 goto op_semantics_101;
14604 break;
14605 }
14606 break;
14607 case 0x49:
14608 GETBYTE ();
14609 switch (op[2] & 0x00)
14610 {
14611 case 0x00:
14612 goto op_semantics_101;
14613 break;
14614 }
14615 break;
14616 case 0x4a:
14617 GETBYTE ();
14618 switch (op[2] & 0x00)
14619 {
14620 case 0x00:
14621 goto op_semantics_101;
14622 break;
14623 }
14624 break;
14625 case 0x4b:
14626 GETBYTE ();
14627 switch (op[2] & 0x00)
14628 {
14629 case 0x00:
14630 goto op_semantics_101;
14631 break;
14632 }
14633 break;
14634 case 0x4c:
14635 GETBYTE ();
14636 switch (op[2] & 0x00)
14637 {
14638 case 0x00:
14639 goto op_semantics_101;
14640 break;
14641 }
14642 break;
14643 case 0x4d:
14644 GETBYTE ();
14645 switch (op[2] & 0x00)
14646 {
14647 case 0x00:
14648 goto op_semantics_101;
14649 break;
14650 }
14651 break;
14652 case 0x4e:
14653 GETBYTE ();
14654 switch (op[2] & 0x00)
14655 {
14656 case 0x00:
14657 goto op_semantics_101;
14658 break;
14659 }
14660 break;
14661 case 0x4f:
14662 GETBYTE ();
14663 switch (op[2] & 0x00)
14664 {
14665 case 0x00:
14666 goto op_semantics_101;
14667 break;
14668 }
14669 break;
14670 case 0x50:
14671 GETBYTE ();
14672 switch (op[2] & 0x00)
14673 {
14674 case 0x00:
14675 op_semantics_102:
14676 {
14677 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
78e98aab 14678#line 417 "rx-decode.opc"
c7927a3c 14679 int rdst AU = op[1] & 0x0f;
78e98aab 14680#line 417 "rx-decode.opc"
c7927a3c 14681 int srca AU = (op[2] >> 4) & 0x0f;
78e98aab 14682#line 417 "rx-decode.opc"
c7927a3c
NC		 14683 int srcb AU = op[2] & 0x0f;
14684 if (trace)
14685 {
14686 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14687 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14688 op[0], op[1], op[2]);
14689 printf (" rdst = 0x%x,", rdst);
14690 printf (" srca = 0x%x,", srca);
14691 printf (" srcb = 0x%x\n", srcb);
14692 }
14693 SYNTAX("or %2, %1, %0");
78e98aab 14694#line 417 "rx-decode.opc"
3cf79a01 14695 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
c7927a3c
NC		 14696
14697 /*----------------------------------------------------------------------*/
14698 /* XOR */
14699
14700 }
14701 break;
14702 }
14703 break;
14704 case 0x51:
14705 GETBYTE ();
14706 switch (op[2] & 0x00)
14707 {
14708 case 0x00:
14709 goto op_semantics_102;
14710 break;
14711 }
14712 break;
14713 case 0x52:
14714 GETBYTE ();
14715 switch (op[2] & 0x00)
14716 {
14717 case 0x00:
14718 goto op_semantics_102;
14719 break;
14720 }
14721 break;
14722 case 0x53:
14723 GETBYTE ();
14724 switch (op[2] & 0x00)
14725 {
14726 case 0x00:
14727 goto op_semantics_102;
14728 break;
14729 }
14730 break;
14731 case 0x54:
14732 GETBYTE ();
14733 switch (op[2] & 0x00)
14734 {
14735 case 0x00:
14736 goto op_semantics_102;
14737 break;
14738 }
14739 break;
14740 case 0x55:
14741 GETBYTE ();
14742 switch (op[2] & 0x00)
14743 {
14744 case 0x00:
14745 goto op_semantics_102;
14746 break;
14747 }
14748 break;
14749 case 0x56:
14750 GETBYTE ();
14751 switch (op[2] & 0x00)
14752 {
14753 case 0x00:
14754 goto op_semantics_102;
14755 break;
14756 }
14757 break;
14758 case 0x57:
14759 GETBYTE ();
14760 switch (op[2] & 0x00)
14761 {
14762 case 0x00:
14763 goto op_semantics_102;
14764 break;
14765 }
14766 break;
14767 case 0x58:
14768 GETBYTE ();
14769 switch (op[2] & 0x00)
14770 {
14771 case 0x00:
14772 goto op_semantics_102;
14773 break;
14774 }
14775 break;
14776 case 0x59:
14777 GETBYTE ();
14778 switch (op[2] & 0x00)
14779 {
14780 case 0x00:
14781 goto op_semantics_102;
14782 break;
14783 }
14784 break;
14785 case 0x5a:
14786 GETBYTE ();
14787 switch (op[2] & 0x00)
14788 {
14789 case 0x00:
14790 goto op_semantics_102;
14791 break;
14792 }
14793 break;
14794 case 0x5b:
14795 GETBYTE ();
14796 switch (op[2] & 0x00)
14797 {
14798 case 0x00:
14799 goto op_semantics_102;
14800 break;
14801 }
14802 break;
14803 case 0x5c:
14804 GETBYTE ();
14805 switch (op[2] & 0x00)
14806 {
14807 case 0x00:
14808 goto op_semantics_102;
14809 break;
14810 }
14811 break;
14812 case 0x5d:
14813 GETBYTE ();
14814 switch (op[2] & 0x00)
14815 {
14816 case 0x00:
14817 goto op_semantics_102;
14818 break;
14819 }
14820 break;
14821 case 0x5e:
14822 GETBYTE ();
14823 switch (op[2] & 0x00)
14824 {
14825 case 0x00:
14826 goto op_semantics_102;
14827 break;
14828 }
14829 break;
14830 case 0x5f:
14831 GETBYTE ();
14832 switch (op[2] & 0x00)
14833 {
14834 case 0x00:
14835 goto op_semantics_102;
14836 break;
14837 }
14838 break;
14839 default: UNSUPPORTED(); break;
14840 }
14841 break;
14842 default: UNSUPPORTED(); break;
14843 }
78e98aab 14844#line 974 "rx-decode.opc"
c7927a3c
NC		 14845
14846 return rx->n_bytes;
14847}
GDB Binutils - Deliverables
This page took 0.980324 seconds and 4 git commands to generate.