projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* arc-dis.c: Include sysdep.h first, remove some redundant includes.
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
1 #line 1 "rx-decode.opc"
2 /* -*- c -*- */
3 #include "sysdep.h"
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include "ansidecl.h"
8 #include "opcode/rx.h"
9
10 #define RX_OPCODE_BIG_ENDIAN 0
11
12 typedef struct
13 {
14 RX_Opcode_Decoded * rx;
15 int (* getbyte)(void *);
16 void * ptr;
17 unsigned char * op;
18 } LocalData;
19
20 static int trace = 0;
21
22 #define BSIZE 0
23 #define WSIZE 1
24 #define LSIZE 2
25
26 /* These are for when the upper bits are "don't care" or "undefined". */
27 static int bwl[] =
28 {
29 RX_Byte,
30 RX_Word,
31 RX_Long
32 };
33
34 static int sbwl[] =
35 {
36 RX_SByte,
37 RX_SWord,
38 RX_Long
39 };
40
41 static int ubwl[] =
42 {
43 RX_UByte,
44 RX_UWord,
45 RX_Long
46 };
47
48 static int memex[] =
49 {
50 RX_SByte,
51 RX_SWord,
52 RX_Long,
53 RX_UWord
54 };
55
56 #define ID(x) rx->id = RXO_##x
57 #define OP(n,t,r,a) (rx->op[n].type = t, \
58 rx->op[n].reg = r, \
59 rx->op[n].addend = a )
60 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
61 rx->op[n].size = s )
62
63 /* This is for the BWL and BW bitfields. */
64 static int SCALE[] = { 1, 2, 4 };
65 /* This is for the prefix size enum. */
66 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
67
68 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
69 16, 17, 0, 0, 0, 0, 0, 0 };
70
71 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
72
73 /*
74 *C a constant (immediate) c
75 *R A register
76 *I Register indirect, no offset
77 *Is Register indirect, with offset
78 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
79 *P standard displacement: type (r,[r]), reg, assumes UByte
80 *Pm memex displacement: type (r,[r]), reg, memex code
81 *cc condition code. */
82
83 #define DC(c) OP (0, RX_Operand_Immediate, 0, c)
84 #define DR(r) OP (0, RX_Operand_Register, r, 0)
85 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
86 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
87 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
88 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
89
90 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
91 #define SR(r) OP (1, RX_Operand_Register, r, 0)
92 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
93 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
94 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
95 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
96 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
97 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
98 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
99
100 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
101 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
102 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
103 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
104 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
105 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
106 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
107 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
108
109 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
110 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
111 #define uBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
112 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
113
114 #define F(f) store_flags(rx, f)
115
116 #define AU ATTRIBUTE_UNUSED
117 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
118
119 #define SYNTAX(x) rx->syntax = x
120
121 #define UNSUPPORTED() \
122 rx->syntax = "*unknown*"
123
124 #define IMM(sf) immediate (sf, 0, ld)
125 #define IMMex(sf) immediate (sf, 1, ld)
126
127 static int
128 immediate (int sfield, int ex, LocalData * ld)
129 {
130 unsigned long i = 0, j;
131
132 switch (sfield)
133 {
134 #define B ((unsigned long) GETBYTE())
135 case 0:
136 #if RX_OPCODE_BIG_ENDIAN
137 i = B;
138 if (ex && (i & 0x80))
139 i -= 0x100;
140 i <<= 24;
141 i |= B << 16;
142 i |= B << 8;
143 i |= B;
144 #else
145 i = B;
146 i |= B << 8;
147 i |= B << 16;
148 j = B;
149 if (ex && (j & 0x80))
150 j -= 0x100;
151 i |= j << 24;
152 #endif
153 break;
154 case 3:
155 #if RX_OPCODE_BIG_ENDIAN
156 i = B << 16;
157 i |= B << 8;
158 i |= B;
159 #else
160 i = B;
161 i |= B << 8;
162 i |= B << 16;
163 #endif
164 if (ex && (i & 0x800000))
165 i -= 0x1000000;
166 break;
167 case 2:
168 #if RX_OPCODE_BIG_ENDIAN
169 i |= B << 8;
170 i |= B;
171 #else
172 i |= B;
173 i |= B << 8;
174 #endif
175 if (ex && (i & 0x8000))
176 i -= 0x10000;
177 break;
178 case 1:
179 i |= B;
180 if (ex && (i & 0x80))
181 i -= 0x100;
182 break;
183 default:
184 abort();
185 }
186 return i;
187 }
188
189 static void
190 rx_disp (int n, int type, int reg, int size, LocalData * ld)
191 {
192 int disp;
193
194 ld->rx->op[n].reg = reg;
195 switch (type)
196 {
197 case 3:
198 ld->rx->op[n].type = RX_Operand_Register;
199 break;
200 case 0:
201 ld->rx->op[n].type = RX_Operand_Indirect;
202 ld->rx->op[n].addend = 0;
203 break;
204 case 1:
205 ld->rx->op[n].type = RX_Operand_Indirect;
206 disp = GETBYTE ();
207 ld->rx->op[n].addend = disp * PSCALE[size];
208 break;
209 case 2:
210 ld->rx->op[n].type = RX_Operand_Indirect;
211 disp = GETBYTE ();
212 #if RX_OPCODE_BIG_ENDIAN
213 disp = disp * 256 + GETBYTE ();
214 #else
215 disp = disp + GETBYTE () * 256;
216 #endif
217 ld->rx->op[n].addend = disp * PSCALE[size];
218 break;
219 default:
220 abort ();
221 }
222 }
223
224 #define xO 8
225 #define xS 4
226 #define xZ 2
227 #define xC 1
228
229 #define F_____
230 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
231 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
232 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
233 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
234 #define F_O___ rx->flags_0 = rx->flags_s = xO;
235 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
236 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
237 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
238
239 int
240 rx_decode_opcode (unsigned long pc AU,
241 RX_Opcode_Decoded * rx,
242 int (* getbyte)(void *),
243 void * ptr)
244 {
245 LocalData lds, * ld = &lds;
246 unsigned char op[20] = {0};
247
248 lds.rx = rx;
249 lds.getbyte = getbyte;
250 lds.ptr = ptr;
251 lds.op = op;
252
253 memset (rx, 0, sizeof (*rx));
254 BWL(LSIZE);
255
256
257 /*----------------------------------------------------------------------*/
258 /* MOV */
259
260 GETBYTE ();
261 switch (op[0] & 0xff)
262 {
263 case 0x00:
264 {
265 /** 0000 0000 brk */
266 if (trace)
267 {
268 printf ("\033[33m%s\033[0m %02x\n",
269 "/** 0000 0000 brk */",
270 op[0]);
271 }
272 SYNTAX("brk");
273 #line 955 "rx-decode.opc"
274 ID(brk);
275
276 }
277 break;
278 case 0x01:
279 {
280 /** 0000 0001 dbt */
281 if (trace)
282 {
283 printf ("\033[33m%s\033[0m %02x\n",
284 "/** 0000 0001 dbt */",
285 op[0]);
286 }
287 SYNTAX("dbt");
288 #line 958 "rx-decode.opc"
289 ID(dbt);
290
291 }
292 break;
293 case 0x02:
294 {
295 /** 0000 0010 rts */
296 if (trace)
297 {
298 printf ("\033[33m%s\033[0m %02x\n",
299 "/** 0000 0010 rts */",
300 op[0]);
301 }
302 SYNTAX("rts");
303 #line 744 "rx-decode.opc"
304 ID(rts);
305
306 /*----------------------------------------------------------------------*/
307 /* NOP */
308
309 }
310 break;
311 case 0x03:
312 {
313 /** 0000 0011 nop */
314 if (trace)
315 {
316 printf ("\033[33m%s\033[0m %02x\n",
317 "/** 0000 0011 nop */",
318 op[0]);
319 }
320 SYNTAX("nop");
321 #line 750 "rx-decode.opc"
322 ID(nop);
323
324 /*----------------------------------------------------------------------*/
325 /* STRING FUNCTIONS */
326
327 }
328 break;
329 case 0x04:
330 {
331 /** 0000 0100 bra.a %a0 */
332 if (trace)
333 {
334 printf ("\033[33m%s\033[0m %02x\n",
335 "/** 0000 0100 bra.a %a0 */",
336 op[0]);
337 }
338 SYNTAX("bra.a %a0");
339 #line 722 "rx-decode.opc"
340 ID(branch); DC(pc + IMMex(3));
341
342 }
343 break;
344 case 0x05:
345 {
346 /** 0000 0101 bsr.a %a0 */
347 if (trace)
348 {
349 printf ("\033[33m%s\033[0m %02x\n",
350 "/** 0000 0101 bsr.a %a0 */",
351 op[0]);
352 }
353 SYNTAX("bsr.a %a0");
354 #line 738 "rx-decode.opc"
355 ID(jsr); DC(pc + IMMex(3));
356
357 }
358 break;
359 case 0x06:
360 GETBYTE ();
361 switch (op[1] & 0xff)
362 {
363 case 0x00:
364 GETBYTE ();
365 switch (op[2] & 0x00)
366 {
367 case 0x00:
368 op_semantics_1:
369 {
370 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
371 #line 518 "rx-decode.opc"
372 int mx AU = (op[1] >> 6) & 0x03;
373 #line 518 "rx-decode.opc"
374 int ss AU = op[1] & 0x03;
375 #line 518 "rx-decode.opc"
376 int rsrc AU = (op[2] >> 4) & 0x0f;
377 #line 518 "rx-decode.opc"
378 int rdst AU = op[2] & 0x0f;
379 if (trace)
380 {
381 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
382 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
383 op[0], op[1], op[2]);
384 printf (" mx = 0x%x,", mx);
385 printf (" ss = 0x%x,", ss);
386 printf (" rsrc = 0x%x,", rsrc);
387 printf (" rdst = 0x%x\n", rdst);
388 }
389 SYNTAX("sub %2%S2, %1");
390 #line 518 "rx-decode.opc"
391 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
392
393 }
394 break;
395 }
396 break;
397 case 0x01:
398 GETBYTE ();
399 switch (op[2] & 0x00)
400 {
401 case 0x00:
402 goto op_semantics_1;
403 break;
404 }
405 break;
406 case 0x02:
407 GETBYTE ();
408 switch (op[2] & 0x00)
409 {
410 case 0x00:
411 goto op_semantics_1;
412 break;
413 }
414 break;
415 case 0x03:
416 GETBYTE ();
417 switch (op[2] & 0x00)
418 {
419 case 0x00:
420 goto op_semantics_1;
421 break;
422 }
423 break;
424 case 0x04:
425 GETBYTE ();
426 switch (op[2] & 0x00)
427 {
428 case 0x00:
429 op_semantics_2:
430 {
431 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
432 #line 506 "rx-decode.opc"
433 int mx AU = (op[1] >> 6) & 0x03;
434 #line 506 "rx-decode.opc"
435 int ss AU = op[1] & 0x03;
436 #line 506 "rx-decode.opc"
437 int rsrc AU = (op[2] >> 4) & 0x0f;
438 #line 506 "rx-decode.opc"
439 int rdst AU = op[2] & 0x0f;
440 if (trace)
441 {
442 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
443 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
444 op[0], op[1], op[2]);
445 printf (" mx = 0x%x,", mx);
446 printf (" ss = 0x%x,", ss);
447 printf (" rsrc = 0x%x,", rsrc);
448 printf (" rdst = 0x%x\n", rdst);
449 }
450 SYNTAX("cmp %2%S2, %1");
451 #line 506 "rx-decode.opc"
452 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
453
454 /*----------------------------------------------------------------------*/
455 /* SUB */
456
457 }
458 break;
459 }
460 break;
461 case 0x05:
462 GETBYTE ();
463 switch (op[2] & 0x00)
464 {
465 case 0x00:
466 goto op_semantics_2;
467 break;
468 }
469 break;
470 case 0x06:
471 GETBYTE ();
472 switch (op[2] & 0x00)
473 {
474 case 0x00:
475 goto op_semantics_2;
476 break;
477 }
478 break;
479 case 0x07:
480 GETBYTE ();
481 switch (op[2] & 0x00)
482 {
483 case 0x00:
484 goto op_semantics_2;
485 break;
486 }
487 break;
488 case 0x08:
489 GETBYTE ();
490 switch (op[2] & 0x00)
491 {
492 case 0x00:
493 op_semantics_3:
494 {
495 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
496 #line 482 "rx-decode.opc"
497 int mx AU = (op[1] >> 6) & 0x03;
498 #line 482 "rx-decode.opc"
499 int ss AU = op[1] & 0x03;
500 #line 482 "rx-decode.opc"
501 int rsrc AU = (op[2] >> 4) & 0x0f;
502 #line 482 "rx-decode.opc"
503 int rdst AU = op[2] & 0x0f;
504 if (trace)
505 {
506 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
507 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
508 op[0], op[1], op[2]);
509 printf (" mx = 0x%x,", mx);
510 printf (" ss = 0x%x,", ss);
511 printf (" rsrc = 0x%x,", rsrc);
512 printf (" rdst = 0x%x\n", rdst);
513 }
514 SYNTAX("add %1%S1, %0");
515 #line 482 "rx-decode.opc"
516 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
517
518 }
519 break;
520 }
521 break;
522 case 0x09:
523 GETBYTE ();
524 switch (op[2] & 0x00)
525 {
526 case 0x00:
527 goto op_semantics_3;
528 break;
529 }
530 break;
531 case 0x0a:
532 GETBYTE ();
533 switch (op[2] & 0x00)
534 {
535 case 0x00:
536 goto op_semantics_3;
537 break;
538 }
539 break;
540 case 0x0b:
541 GETBYTE ();
542 switch (op[2] & 0x00)
543 {
544 case 0x00:
545 goto op_semantics_3;
546 break;
547 }
548 break;
549 case 0x0c:
550 GETBYTE ();
551 switch (op[2] & 0x00)
552 {
553 case 0x00:
554 op_semantics_4:
555 {
556 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
557 #line 587 "rx-decode.opc"
558 int mx AU = (op[1] >> 6) & 0x03;
559 #line 587 "rx-decode.opc"
560 int ss AU = op[1] & 0x03;
561 #line 587 "rx-decode.opc"
562 int rsrc AU = (op[2] >> 4) & 0x0f;
563 #line 587 "rx-decode.opc"
564 int rdst AU = op[2] & 0x0f;
565 if (trace)
566 {
567 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
568 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
569 op[0], op[1], op[2]);
570 printf (" mx = 0x%x,", mx);
571 printf (" ss = 0x%x,", ss);
572 printf (" rsrc = 0x%x,", rsrc);
573 printf (" rdst = 0x%x\n", rdst);
574 }
575 SYNTAX("mul %1%S1, %0");
576 #line 587 "rx-decode.opc"
577 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
578
579 }
580 break;
581 }
582 break;
583 case 0x0d:
584 GETBYTE ();
585 switch (op[2] & 0x00)
586 {
587 case 0x00:
588 goto op_semantics_4;
589 break;
590 }
591 break;
592 case 0x0e:
593 GETBYTE ();
594 switch (op[2] & 0x00)
595 {
596 case 0x00:
597 goto op_semantics_4;
598 break;
599 }
600 break;
601 case 0x0f:
602 GETBYTE ();
603 switch (op[2] & 0x00)
604 {
605 case 0x00:
606 goto op_semantics_4;
607 break;
608 }
609 break;
610 case 0x10:
611 GETBYTE ();
612 switch (op[2] & 0x00)
613 {
614 case 0x00:
615 op_semantics_5:
616 {
617 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
618 #line 395 "rx-decode.opc"
619 int mx AU = (op[1] >> 6) & 0x03;
620 #line 395 "rx-decode.opc"
621 int ss AU = op[1] & 0x03;
622 #line 395 "rx-decode.opc"
623 int rsrc AU = (op[2] >> 4) & 0x0f;
624 #line 395 "rx-decode.opc"
625 int rdst AU = op[2] & 0x0f;
626 if (trace)
627 {
628 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
629 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
630 op[0], op[1], op[2]);
631 printf (" mx = 0x%x,", mx);
632 printf (" ss = 0x%x,", ss);
633 printf (" rsrc = 0x%x,", rsrc);
634 printf (" rdst = 0x%x\n", rdst);
635 }
636 SYNTAX("and %1%S1, %0");
637 #line 395 "rx-decode.opc"
638 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
639
640 }
641 break;
642 }
643 break;
644 case 0x11:
645 GETBYTE ();
646 switch (op[2] & 0x00)
647 {
648 case 0x00:
649 goto op_semantics_5;
650 break;
651 }
652 break;
653 case 0x12:
654 GETBYTE ();
655 switch (op[2] & 0x00)
656 {
657 case 0x00:
658 goto op_semantics_5;
659 break;
660 }
661 break;
662 case 0x13:
663 GETBYTE ();
664 switch (op[2] & 0x00)
665 {
666 case 0x00:
667 goto op_semantics_5;
668 break;
669 }
670 break;
671 case 0x14:
672 GETBYTE ();
673 switch (op[2] & 0x00)
674 {
675 case 0x00:
676 op_semantics_6:
677 {
678 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
679 #line 413 "rx-decode.opc"
680 int mx AU = (op[1] >> 6) & 0x03;
681 #line 413 "rx-decode.opc"
682 int ss AU = op[1] & 0x03;
683 #line 413 "rx-decode.opc"
684 int rsrc AU = (op[2] >> 4) & 0x0f;
685 #line 413 "rx-decode.opc"
686 int rdst AU = op[2] & 0x0f;
687 if (trace)
688 {
689 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
690 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
691 op[0], op[1], op[2]);
692 printf (" mx = 0x%x,", mx);
693 printf (" ss = 0x%x,", ss);
694 printf (" rsrc = 0x%x,", rsrc);
695 printf (" rdst = 0x%x\n", rdst);
696 }
697 SYNTAX("or %1%S1, %0");
698 #line 413 "rx-decode.opc"
699 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
700
701 }
702 break;
703 }
704 break;
705 case 0x15:
706 GETBYTE ();
707 switch (op[2] & 0x00)
708 {
709 case 0x00:
710 goto op_semantics_6;
711 break;
712 }
713 break;
714 case 0x16:
715 GETBYTE ();
716 switch (op[2] & 0x00)
717 {
718 case 0x00:
719 goto op_semantics_6;
720 break;
721 }
722 break;
723 case 0x17:
724 GETBYTE ();
725 switch (op[2] & 0x00)
726 {
727 case 0x00:
728 goto op_semantics_6;
729 break;
730 }
731 break;
732 case 0x20:
733 GETBYTE ();
734 switch (op[2] & 0xff)
735 {
736 case 0x00:
737 GETBYTE ();
738 switch (op[3] & 0x00)
739 {
740 case 0x00:
741 op_semantics_7:
742 {
743 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
744 #line 531 "rx-decode.opc"
745 int mx AU = (op[1] >> 6) & 0x03;
746 #line 531 "rx-decode.opc"
747 int sp AU = op[1] & 0x03;
748 #line 531 "rx-decode.opc"
749 int rsrc AU = (op[3] >> 4) & 0x0f;
750 #line 531 "rx-decode.opc"
751 int rdst AU = op[3] & 0x0f;
752 if (trace)
753 {
754 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
755 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
756 op[0], op[1], op[2], op[3]);
757 printf (" mx = 0x%x,", mx);
758 printf (" sp = 0x%x,", sp);
759 printf (" rsrc = 0x%x,", rsrc);
760 printf (" rdst = 0x%x\n", rdst);
761 }
762 SYNTAX("sbb %1%S1, %0");
763 #line 531 "rx-decode.opc"
764 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
765
766 /*----------------------------------------------------------------------*/
767 /* ABS */
768
769 }
770 break;
771 }
772 break;
773 case 0x04:
774 GETBYTE ();
775 switch (op[3] & 0x00)
776 {
777 case 0x00:
778 op_semantics_8:
779 {
780 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
781 #line 560 "rx-decode.opc"
782 int mx AU = (op[1] >> 6) & 0x03;
783 #line 560 "rx-decode.opc"
784 int ss AU = op[1] & 0x03;
785 #line 560 "rx-decode.opc"
786 int rsrc AU = (op[3] >> 4) & 0x0f;
787 #line 560 "rx-decode.opc"
788 int rdst AU = op[3] & 0x0f;
789 if (trace)
790 {
791 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
792 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
793 op[0], op[1], op[2], op[3]);
794 printf (" mx = 0x%x,", mx);
795 printf (" ss = 0x%x,", ss);
796 printf (" rsrc = 0x%x,", rsrc);
797 printf (" rdst = 0x%x\n", rdst);
798 }
799 SYNTAX("max %1%S1, %0");
800 #line 560 "rx-decode.opc"
801 ID(max); SPm(ss, rsrc, mx); DR(rdst);
802
803 /*----------------------------------------------------------------------*/
804 /* MIN */
805
806 }
807 break;
808 }
809 break;
810 case 0x05:
811 GETBYTE ();
812 switch (op[3] & 0x00)
813 {
814 case 0x00:
815 op_semantics_9:
816 {
817 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
818 #line 572 "rx-decode.opc"
819 int mx AU = (op[1] >> 6) & 0x03;
820 #line 572 "rx-decode.opc"
821 int ss AU = op[1] & 0x03;
822 #line 572 "rx-decode.opc"
823 int rsrc AU = (op[3] >> 4) & 0x0f;
824 #line 572 "rx-decode.opc"
825 int rdst AU = op[3] & 0x0f;
826 if (trace)
827 {
828 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
829 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
830 op[0], op[1], op[2], op[3]);
831 printf (" mx = 0x%x,", mx);
832 printf (" ss = 0x%x,", ss);
833 printf (" rsrc = 0x%x,", rsrc);
834 printf (" rdst = 0x%x\n", rdst);
835 }
836 SYNTAX("min %1%S1, %0");
837 #line 572 "rx-decode.opc"
838 ID(min); SPm(ss, rsrc, mx); DR(rdst);
839
840 /*----------------------------------------------------------------------*/
841 /* MUL */
842
843 }
844 break;
845 }
846 break;
847 case 0x06:
848 GETBYTE ();
849 switch (op[3] & 0x00)
850 {
851 case 0x00:
852 op_semantics_10:
853 {
854 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
855 #line 602 "rx-decode.opc"
856 int mx AU = (op[1] >> 6) & 0x03;
857 #line 602 "rx-decode.opc"
858 int ss AU = op[1] & 0x03;
859 #line 602 "rx-decode.opc"
860 int rsrc AU = (op[3] >> 4) & 0x0f;
861 #line 602 "rx-decode.opc"
862 int rdst AU = op[3] & 0x0f;
863 if (trace)
864 {
865 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
866 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
867 op[0], op[1], op[2], op[3]);
868 printf (" mx = 0x%x,", mx);
869 printf (" ss = 0x%x,", ss);
870 printf (" rsrc = 0x%x,", rsrc);
871 printf (" rdst = 0x%x\n", rdst);
872 }
873 SYNTAX("emul %1%S1, %0");
874 #line 602 "rx-decode.opc"
875 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
876
877 /*----------------------------------------------------------------------*/
878 /* EMULU */
879
880 }
881 break;
882 }
883 break;
884 case 0x07:
885 GETBYTE ();
886 switch (op[3] & 0x00)
887 {
888 case 0x00:
889 op_semantics_11:
890 {
891 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
892 #line 614 "rx-decode.opc"
893 int mx AU = (op[1] >> 6) & 0x03;
894 #line 614 "rx-decode.opc"
895 int ss AU = op[1] & 0x03;
896 #line 614 "rx-decode.opc"
897 int rsrc AU = (op[3] >> 4) & 0x0f;
898 #line 614 "rx-decode.opc"
899 int rdst AU = op[3] & 0x0f;
900 if (trace)
901 {
902 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
903 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
904 op[0], op[1], op[2], op[3]);
905 printf (" mx = 0x%x,", mx);
906 printf (" ss = 0x%x,", ss);
907 printf (" rsrc = 0x%x,", rsrc);
908 printf (" rdst = 0x%x\n", rdst);
909 }
910 SYNTAX("emulu %1%S1, %0");
911 #line 614 "rx-decode.opc"
912 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
913
914 /*----------------------------------------------------------------------*/
915 /* DIV */
916
917 }
918 break;
919 }
920 break;
921 case 0x08:
922 GETBYTE ();
923 switch (op[3] & 0x00)
924 {
925 case 0x00:
926 op_semantics_12:
927 {
928 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
929 #line 626 "rx-decode.opc"
930 int mx AU = (op[1] >> 6) & 0x03;
931 #line 626 "rx-decode.opc"
932 int ss AU = op[1] & 0x03;
933 #line 626 "rx-decode.opc"
934 int rsrc AU = (op[3] >> 4) & 0x0f;
935 #line 626 "rx-decode.opc"
936 int rdst AU = op[3] & 0x0f;
937 if (trace)
938 {
939 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
940 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
941 op[0], op[1], op[2], op[3]);
942 printf (" mx = 0x%x,", mx);
943 printf (" ss = 0x%x,", ss);
944 printf (" rsrc = 0x%x,", rsrc);
945 printf (" rdst = 0x%x\n", rdst);
946 }
947 SYNTAX("div %1%S1, %0");
948 #line 626 "rx-decode.opc"
949 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
950
951 /*----------------------------------------------------------------------*/
952 /* DIVU */
953
954 }
955 break;
956 }
957 break;
958 case 0x09:
959 GETBYTE ();
960 switch (op[3] & 0x00)
961 {
962 case 0x00:
963 op_semantics_13:
964 {
965 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
966 #line 638 "rx-decode.opc"
967 int mx AU = (op[1] >> 6) & 0x03;
968 #line 638 "rx-decode.opc"
969 int ss AU = op[1] & 0x03;
970 #line 638 "rx-decode.opc"
971 int rsrc AU = (op[3] >> 4) & 0x0f;
972 #line 638 "rx-decode.opc"
973 int rdst AU = op[3] & 0x0f;
974 if (trace)
975 {
976 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
977 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
978 op[0], op[1], op[2], op[3]);
979 printf (" mx = 0x%x,", mx);
980 printf (" ss = 0x%x,", ss);
981 printf (" rsrc = 0x%x,", rsrc);
982 printf (" rdst = 0x%x\n", rdst);
983 }
984 SYNTAX("divu %1%S1, %0");
985 #line 638 "rx-decode.opc"
986 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
987
988 /*----------------------------------------------------------------------*/
989 /* SHIFT */
990
991 }
992 break;
993 }
994 break;
995 case 0x0c:
996 GETBYTE ();
997 switch (op[3] & 0x00)
998 {
999 case 0x00:
1000 op_semantics_14:
1001 {
1002 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1003 #line 449 "rx-decode.opc"
1004 int mx AU = (op[1] >> 6) & 0x03;
1005 #line 449 "rx-decode.opc"
1006 int ss AU = op[1] & 0x03;
1007 #line 449 "rx-decode.opc"
1008 int rsrc AU = (op[3] >> 4) & 0x0f;
1009 #line 449 "rx-decode.opc"
1010 int rdst AU = op[3] & 0x0f;
1011 if (trace)
1012 {
1013 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1014 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1015 op[0], op[1], op[2], op[3]);
1016 printf (" mx = 0x%x,", mx);
1017 printf (" ss = 0x%x,", ss);
1018 printf (" rsrc = 0x%x,", rsrc);
1019 printf (" rdst = 0x%x\n", rdst);
1020 }
1021 SYNTAX("tst %1%S1, %2");
1022 #line 449 "rx-decode.opc"
1023 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1024
1025 /*----------------------------------------------------------------------*/
1026 /* NEG */
1027
1028 }
1029 break;
1030 }
1031 break;
1032 case 0x0d:
1033 GETBYTE ();
1034 switch (op[3] & 0x00)
1035 {
1036 case 0x00:
1037 op_semantics_15:
1038 {
1039 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1040 #line 428 "rx-decode.opc"
1041 int mx AU = (op[1] >> 6) & 0x03;
1042 #line 428 "rx-decode.opc"
1043 int ss AU = op[1] & 0x03;
1044 #line 428 "rx-decode.opc"
1045 int rsrc AU = (op[3] >> 4) & 0x0f;
1046 #line 428 "rx-decode.opc"
1047 int rdst AU = op[3] & 0x0f;
1048 if (trace)
1049 {
1050 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1051 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1052 op[0], op[1], op[2], op[3]);
1053 printf (" mx = 0x%x,", mx);
1054 printf (" ss = 0x%x,", ss);
1055 printf (" rsrc = 0x%x,", rsrc);
1056 printf (" rdst = 0x%x\n", rdst);
1057 }
1058 SYNTAX("xor %1%S1, %0");
1059 #line 428 "rx-decode.opc"
1060 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1061
1062 /*----------------------------------------------------------------------*/
1063 /* NOT */
1064
1065 }
1066 break;
1067 }
1068 break;
1069 case 0x10:
1070 GETBYTE ();
1071 switch (op[3] & 0x00)
1072 {
1073 case 0x00:
1074 op_semantics_16:
1075 {
1076 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1077 #line 362 "rx-decode.opc"
1078 int mx AU = (op[1] >> 6) & 0x03;
1079 #line 362 "rx-decode.opc"
1080 int ss AU = op[1] & 0x03;
1081 #line 362 "rx-decode.opc"
1082 int rsrc AU = (op[3] >> 4) & 0x0f;
1083 #line 362 "rx-decode.opc"
1084 int rdst AU = op[3] & 0x0f;
1085 if (trace)
1086 {
1087 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1088 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1089 op[0], op[1], op[2], op[3]);
1090 printf (" mx = 0x%x,", mx);
1091 printf (" ss = 0x%x,", ss);
1092 printf (" rsrc = 0x%x,", rsrc);
1093 printf (" rdst = 0x%x\n", rdst);
1094 }
1095 SYNTAX("xchg %1%S1, %0");
1096 #line 362 "rx-decode.opc"
1097 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1098
1099 /*----------------------------------------------------------------------*/
1100 /* STZ/STNZ */
1101
1102 }
1103 break;
1104 }
1105 break;
1106 case 0x11:
1107 GETBYTE ();
1108 switch (op[3] & 0x00)
1109 {
1110 case 0x00:
1111 op_semantics_17:
1112 {
1113 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1114 #line 867 "rx-decode.opc"
1115 int mx AU = (op[1] >> 6) & 0x03;
1116 #line 867 "rx-decode.opc"
1117 int sd AU = op[1] & 0x03;
1118 #line 867 "rx-decode.opc"
1119 int rsrc AU = (op[3] >> 4) & 0x0f;
1120 #line 867 "rx-decode.opc"
1121 int rdst AU = op[3] & 0x0f;
1122 if (trace)
1123 {
1124 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1125 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1126 op[0], op[1], op[2], op[3]);
1127 printf (" mx = 0x%x,", mx);
1128 printf (" sd = 0x%x,", sd);
1129 printf (" rsrc = 0x%x,", rsrc);
1130 printf (" rdst = 0x%x\n", rdst);
1131 }
1132 SYNTAX("itof %1%S1, %0");
1133 #line 867 "rx-decode.opc"
1134 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1135
1136 /*----------------------------------------------------------------------*/
1137 /* BIT OPS */
1138
1139 }
1140 break;
1141 }
1142 break;
1143 default: UNSUPPORTED(); break;
1144 }
1145 break;
1146 case 0x21:
1147 GETBYTE ();
1148 switch (op[2] & 0xff)
1149 {
1150 case 0x00:
1151 GETBYTE ();
1152 switch (op[3] & 0x00)
1153 {
1154 case 0x00:
1155 goto op_semantics_7;
1156 break;
1157 }
1158 break;
1159 case 0x04:
1160 GETBYTE ();
1161 switch (op[3] & 0x00)
1162 {
1163 case 0x00:
1164 goto op_semantics_8;
1165 break;
1166 }
1167 break;
1168 case 0x05:
1169 GETBYTE ();
1170 switch (op[3] & 0x00)
1171 {
1172 case 0x00:
1173 goto op_semantics_9;
1174 break;
1175 }
1176 break;
1177 case 0x06:
1178 GETBYTE ();
1179 switch (op[3] & 0x00)
1180 {
1181 case 0x00:
1182 goto op_semantics_10;
1183 break;
1184 }
1185 break;
1186 case 0x07:
1187 GETBYTE ();
1188 switch (op[3] & 0x00)
1189 {
1190 case 0x00:
1191 goto op_semantics_11;
1192 break;
1193 }
1194 break;
1195 case 0x08:
1196 GETBYTE ();
1197 switch (op[3] & 0x00)
1198 {
1199 case 0x00:
1200 goto op_semantics_12;
1201 break;
1202 }
1203 break;
1204 case 0x09:
1205 GETBYTE ();
1206 switch (op[3] & 0x00)
1207 {
1208 case 0x00:
1209 goto op_semantics_13;
1210 break;
1211 }
1212 break;
1213 case 0x0c:
1214 GETBYTE ();
1215 switch (op[3] & 0x00)
1216 {
1217 case 0x00:
1218 goto op_semantics_14;
1219 break;
1220 }
1221 break;
1222 case 0x0d:
1223 GETBYTE ();
1224 switch (op[3] & 0x00)
1225 {
1226 case 0x00:
1227 goto op_semantics_15;
1228 break;
1229 }
1230 break;
1231 case 0x10:
1232 GETBYTE ();
1233 switch (op[3] & 0x00)
1234 {
1235 case 0x00:
1236 goto op_semantics_16;
1237 break;
1238 }
1239 break;
1240 case 0x11:
1241 GETBYTE ();
1242 switch (op[3] & 0x00)
1243 {
1244 case 0x00:
1245 goto op_semantics_17;
1246 break;
1247 }
1248 break;
1249 default: UNSUPPORTED(); break;
1250 }
1251 break;
1252 case 0x22:
1253 GETBYTE ();
1254 switch (op[2] & 0xff)
1255 {
1256 case 0x00:
1257 GETBYTE ();
1258 switch (op[3] & 0x00)
1259 {
1260 case 0x00:
1261 goto op_semantics_7;
1262 break;
1263 }
1264 break;
1265 case 0x04:
1266 GETBYTE ();
1267 switch (op[3] & 0x00)
1268 {
1269 case 0x00:
1270 goto op_semantics_8;
1271 break;
1272 }
1273 break;
1274 case 0x05:
1275 GETBYTE ();
1276 switch (op[3] & 0x00)
1277 {
1278 case 0x00:
1279 goto op_semantics_9;
1280 break;
1281 }
1282 break;
1283 case 0x06:
1284 GETBYTE ();
1285 switch (op[3] & 0x00)
1286 {
1287 case 0x00:
1288 goto op_semantics_10;
1289 break;
1290 }
1291 break;
1292 case 0x07:
1293 GETBYTE ();
1294 switch (op[3] & 0x00)
1295 {
1296 case 0x00:
1297 goto op_semantics_11;
1298 break;
1299 }
1300 break;
1301 case 0x08:
1302 GETBYTE ();
1303 switch (op[3] & 0x00)
1304 {
1305 case 0x00:
1306 goto op_semantics_12;
1307 break;
1308 }
1309 break;
1310 case 0x09:
1311 GETBYTE ();
1312 switch (op[3] & 0x00)
1313 {
1314 case 0x00:
1315 goto op_semantics_13;
1316 break;
1317 }
1318 break;
1319 case 0x0c:
1320 GETBYTE ();
1321 switch (op[3] & 0x00)
1322 {
1323 case 0x00:
1324 goto op_semantics_14;
1325 break;
1326 }
1327 break;
1328 case 0x0d:
1329 GETBYTE ();
1330 switch (op[3] & 0x00)
1331 {
1332 case 0x00:
1333 goto op_semantics_15;
1334 break;
1335 }
1336 break;
1337 case 0x10:
1338 GETBYTE ();
1339 switch (op[3] & 0x00)
1340 {
1341 case 0x00:
1342 goto op_semantics_16;
1343 break;
1344 }
1345 break;
1346 case 0x11:
1347 GETBYTE ();
1348 switch (op[3] & 0x00)
1349 {
1350 case 0x00:
1351 goto op_semantics_17;
1352 break;
1353 }
1354 break;
1355 default: UNSUPPORTED(); break;
1356 }
1357 break;
1358 case 0x23:
1359 GETBYTE ();
1360 switch (op[2] & 0xff)
1361 {
1362 case 0x00:
1363 GETBYTE ();
1364 switch (op[3] & 0x00)
1365 {
1366 case 0x00:
1367 goto op_semantics_7;
1368 break;
1369 }
1370 break;
1371 case 0x04:
1372 GETBYTE ();
1373 switch (op[3] & 0x00)
1374 {
1375 case 0x00:
1376 goto op_semantics_8;
1377 break;
1378 }
1379 break;
1380 case 0x05:
1381 GETBYTE ();
1382 switch (op[3] & 0x00)
1383 {
1384 case 0x00:
1385 goto op_semantics_9;
1386 break;
1387 }
1388 break;
1389 case 0x06:
1390 GETBYTE ();
1391 switch (op[3] & 0x00)
1392 {
1393 case 0x00:
1394 goto op_semantics_10;
1395 break;
1396 }
1397 break;
1398 case 0x07:
1399 GETBYTE ();
1400 switch (op[3] & 0x00)
1401 {
1402 case 0x00:
1403 goto op_semantics_11;
1404 break;
1405 }
1406 break;
1407 case 0x08:
1408 GETBYTE ();
1409 switch (op[3] & 0x00)
1410 {
1411 case 0x00:
1412 goto op_semantics_12;
1413 break;
1414 }
1415 break;
1416 case 0x09:
1417 GETBYTE ();
1418 switch (op[3] & 0x00)
1419 {
1420 case 0x00:
1421 goto op_semantics_13;
1422 break;
1423 }
1424 break;
1425 case 0x0c:
1426 GETBYTE ();
1427 switch (op[3] & 0x00)
1428 {
1429 case 0x00:
1430 goto op_semantics_14;
1431 break;
1432 }
1433 break;
1434 case 0x0d:
1435 GETBYTE ();
1436 switch (op[3] & 0x00)
1437 {
1438 case 0x00:
1439 goto op_semantics_15;
1440 break;
1441 }
1442 break;
1443 case 0x10:
1444 GETBYTE ();
1445 switch (op[3] & 0x00)
1446 {
1447 case 0x00:
1448 goto op_semantics_16;
1449 break;
1450 }
1451 break;
1452 case 0x11:
1453 GETBYTE ();
1454 switch (op[3] & 0x00)
1455 {
1456 case 0x00:
1457 goto op_semantics_17;
1458 break;
1459 }
1460 break;
1461 default: UNSUPPORTED(); break;
1462 }
1463 break;
1464 case 0x40:
1465 GETBYTE ();
1466 switch (op[2] & 0x00)
1467 {
1468 case 0x00:
1469 goto op_semantics_1;
1470 break;
1471 }
1472 break;
1473 case 0x41:
1474 GETBYTE ();
1475 switch (op[2] & 0x00)
1476 {
1477 case 0x00:
1478 goto op_semantics_1;
1479 break;
1480 }
1481 break;
1482 case 0x42:
1483 GETBYTE ();
1484 switch (op[2] & 0x00)
1485 {
1486 case 0x00:
1487 goto op_semantics_1;
1488 break;
1489 }
1490 break;
1491 case 0x43:
1492 GETBYTE ();
1493 switch (op[2] & 0x00)
1494 {
1495 case 0x00:
1496 goto op_semantics_1;
1497 break;
1498 }
1499 break;
1500 case 0x44:
1501 GETBYTE ();
1502 switch (op[2] & 0x00)
1503 {
1504 case 0x00:
1505 goto op_semantics_2;
1506 break;
1507 }
1508 break;
1509 case 0x45:
1510 GETBYTE ();
1511 switch (op[2] & 0x00)
1512 {
1513 case 0x00:
1514 goto op_semantics_2;
1515 break;
1516 }
1517 break;
1518 case 0x46:
1519 GETBYTE ();
1520 switch (op[2] & 0x00)
1521 {
1522 case 0x00:
1523 goto op_semantics_2;
1524 break;
1525 }
1526 break;
1527 case 0x47:
1528 GETBYTE ();
1529 switch (op[2] & 0x00)
1530 {
1531 case 0x00:
1532 goto op_semantics_2;
1533 break;
1534 }
1535 break;
1536 case 0x48:
1537 GETBYTE ();
1538 switch (op[2] & 0x00)
1539 {
1540 case 0x00:
1541 goto op_semantics_3;
1542 break;
1543 }
1544 break;
1545 case 0x49:
1546 GETBYTE ();
1547 switch (op[2] & 0x00)
1548 {
1549 case 0x00:
1550 goto op_semantics_3;
1551 break;
1552 }
1553 break;
1554 case 0x4a:
1555 GETBYTE ();
1556 switch (op[2] & 0x00)
1557 {
1558 case 0x00:
1559 goto op_semantics_3;
1560 break;
1561 }
1562 break;
1563 case 0x4b:
1564 GETBYTE ();
1565 switch (op[2] & 0x00)
1566 {
1567 case 0x00:
1568 goto op_semantics_3;
1569 break;
1570 }
1571 break;
1572 case 0x4c:
1573 GETBYTE ();
1574 switch (op[2] & 0x00)
1575 {
1576 case 0x00:
1577 goto op_semantics_4;
1578 break;
1579 }
1580 break;
1581 case 0x4d:
1582 GETBYTE ();
1583 switch (op[2] & 0x00)
1584 {
1585 case 0x00:
1586 goto op_semantics_4;
1587 break;
1588 }
1589 break;
1590 case 0x4e:
1591 GETBYTE ();
1592 switch (op[2] & 0x00)
1593 {
1594 case 0x00:
1595 goto op_semantics_4;
1596 break;
1597 }
1598 break;
1599 case 0x4f:
1600 GETBYTE ();
1601 switch (op[2] & 0x00)
1602 {
1603 case 0x00:
1604 goto op_semantics_4;
1605 break;
1606 }
1607 break;
1608 case 0x50:
1609 GETBYTE ();
1610 switch (op[2] & 0x00)
1611 {
1612 case 0x00:
1613 goto op_semantics_5;
1614 break;
1615 }
1616 break;
1617 case 0x51:
1618 GETBYTE ();
1619 switch (op[2] & 0x00)
1620 {
1621 case 0x00:
1622 goto op_semantics_5;
1623 break;
1624 }
1625 break;
1626 case 0x52:
1627 GETBYTE ();
1628 switch (op[2] & 0x00)
1629 {
1630 case 0x00:
1631 goto op_semantics_5;
1632 break;
1633 }
1634 break;
1635 case 0x53:
1636 GETBYTE ();
1637 switch (op[2] & 0x00)
1638 {
1639 case 0x00:
1640 goto op_semantics_5;
1641 break;
1642 }
1643 break;
1644 case 0x54:
1645 GETBYTE ();
1646 switch (op[2] & 0x00)
1647 {
1648 case 0x00:
1649 goto op_semantics_6;
1650 break;
1651 }
1652 break;
1653 case 0x55:
1654 GETBYTE ();
1655 switch (op[2] & 0x00)
1656 {
1657 case 0x00:
1658 goto op_semantics_6;
1659 break;
1660 }
1661 break;
1662 case 0x56:
1663 GETBYTE ();
1664 switch (op[2] & 0x00)
1665 {
1666 case 0x00:
1667 goto op_semantics_6;
1668 break;
1669 }
1670 break;
1671 case 0x57:
1672 GETBYTE ();
1673 switch (op[2] & 0x00)
1674 {
1675 case 0x00:
1676 goto op_semantics_6;
1677 break;
1678 }
1679 break;
1680 case 0x60:
1681 GETBYTE ();
1682 switch (op[2] & 0xff)
1683 {
1684 case 0x00:
1685 GETBYTE ();
1686 switch (op[3] & 0x00)
1687 {
1688 case 0x00:
1689 goto op_semantics_7;
1690 break;
1691 }
1692 break;
1693 case 0x04:
1694 GETBYTE ();
1695 switch (op[3] & 0x00)
1696 {
1697 case 0x00:
1698 goto op_semantics_8;
1699 break;
1700 }
1701 break;
1702 case 0x05:
1703 GETBYTE ();
1704 switch (op[3] & 0x00)
1705 {
1706 case 0x00:
1707 goto op_semantics_9;
1708 break;
1709 }
1710 break;
1711 case 0x06:
1712 GETBYTE ();
1713 switch (op[3] & 0x00)
1714 {
1715 case 0x00:
1716 goto op_semantics_10;
1717 break;
1718 }
1719 break;
1720 case 0x07:
1721 GETBYTE ();
1722 switch (op[3] & 0x00)
1723 {
1724 case 0x00:
1725 goto op_semantics_11;
1726 break;
1727 }
1728 break;
1729 case 0x08:
1730 GETBYTE ();
1731 switch (op[3] & 0x00)
1732 {
1733 case 0x00:
1734 goto op_semantics_12;
1735 break;
1736 }
1737 break;
1738 case 0x09:
1739 GETBYTE ();
1740 switch (op[3] & 0x00)
1741 {
1742 case 0x00:
1743 goto op_semantics_13;
1744 break;
1745 }
1746 break;
1747 case 0x0c:
1748 GETBYTE ();
1749 switch (op[3] & 0x00)
1750 {
1751 case 0x00:
1752 goto op_semantics_14;
1753 break;
1754 }
1755 break;
1756 case 0x0d:
1757 GETBYTE ();
1758 switch (op[3] & 0x00)
1759 {
1760 case 0x00:
1761 goto op_semantics_15;
1762 break;
1763 }
1764 break;
1765 case 0x10:
1766 GETBYTE ();
1767 switch (op[3] & 0x00)
1768 {
1769 case 0x00:
1770 goto op_semantics_16;
1771 break;
1772 }
1773 break;
1774 case 0x11:
1775 GETBYTE ();
1776 switch (op[3] & 0x00)
1777 {
1778 case 0x00:
1779 goto op_semantics_17;
1780 break;
1781 }
1782 break;
1783 default: UNSUPPORTED(); break;
1784 }
1785 break;
1786 case 0x61:
1787 GETBYTE ();
1788 switch (op[2] & 0xff)
1789 {
1790 case 0x00:
1791 GETBYTE ();
1792 switch (op[3] & 0x00)
1793 {
1794 case 0x00:
1795 goto op_semantics_7;
1796 break;
1797 }
1798 break;
1799 case 0x04:
1800 GETBYTE ();
1801 switch (op[3] & 0x00)
1802 {
1803 case 0x00:
1804 goto op_semantics_8;
1805 break;
1806 }
1807 break;
1808 case 0x05:
1809 GETBYTE ();
1810 switch (op[3] & 0x00)
1811 {
1812 case 0x00:
1813 goto op_semantics_9;
1814 break;
1815 }
1816 break;
1817 case 0x06:
1818 GETBYTE ();
1819 switch (op[3] & 0x00)
1820 {
1821 case 0x00:
1822 goto op_semantics_10;
1823 break;
1824 }
1825 break;
1826 case 0x07:
1827 GETBYTE ();
1828 switch (op[3] & 0x00)
1829 {
1830 case 0x00:
1831 goto op_semantics_11;
1832 break;
1833 }
1834 break;
1835 case 0x08:
1836 GETBYTE ();
1837 switch (op[3] & 0x00)
1838 {
1839 case 0x00:
1840 goto op_semantics_12;
1841 break;
1842 }
1843 break;
1844 case 0x09:
1845 GETBYTE ();
1846 switch (op[3] & 0x00)
1847 {
1848 case 0x00:
1849 goto op_semantics_13;
1850 break;
1851 }
1852 break;
1853 case 0x0c:
1854 GETBYTE ();
1855 switch (op[3] & 0x00)
1856 {
1857 case 0x00:
1858 goto op_semantics_14;
1859 break;
1860 }
1861 break;
1862 case 0x0d:
1863 GETBYTE ();
1864 switch (op[3] & 0x00)
1865 {
1866 case 0x00:
1867 goto op_semantics_15;
1868 break;
1869 }
1870 break;
1871 case 0x10:
1872 GETBYTE ();
1873 switch (op[3] & 0x00)
1874 {
1875 case 0x00:
1876 goto op_semantics_16;
1877 break;
1878 }
1879 break;
1880 case 0x11:
1881 GETBYTE ();
1882 switch (op[3] & 0x00)
1883 {
1884 case 0x00:
1885 goto op_semantics_17;
1886 break;
1887 }
1888 break;
1889 default: UNSUPPORTED(); break;
1890 }
1891 break;
1892 case 0x62:
1893 GETBYTE ();
1894 switch (op[2] & 0xff)
1895 {
1896 case 0x00:
1897 GETBYTE ();
1898 switch (op[3] & 0x00)
1899 {
1900 case 0x00:
1901 goto op_semantics_7;
1902 break;
1903 }
1904 break;
1905 case 0x04:
1906 GETBYTE ();
1907 switch (op[3] & 0x00)
1908 {
1909 case 0x00:
1910 goto op_semantics_8;
1911 break;
1912 }
1913 break;
1914 case 0x05:
1915 GETBYTE ();
1916 switch (op[3] & 0x00)
1917 {
1918 case 0x00:
1919 goto op_semantics_9;
1920 break;
1921 }
1922 break;
1923 case 0x06:
1924 GETBYTE ();
1925 switch (op[3] & 0x00)
1926 {
1927 case 0x00:
1928 goto op_semantics_10;
1929 break;
1930 }
1931 break;
1932 case 0x07:
1933 GETBYTE ();
1934 switch (op[3] & 0x00)
1935 {
1936 case 0x00:
1937 goto op_semantics_11;
1938 break;
1939 }
1940 break;
1941 case 0x08:
1942 GETBYTE ();
1943 switch (op[3] & 0x00)
1944 {
1945 case 0x00:
1946 goto op_semantics_12;
1947 break;
1948 }
1949 break;
1950 case 0x09:
1951 GETBYTE ();
1952 switch (op[3] & 0x00)
1953 {
1954 case 0x00:
1955 goto op_semantics_13;
1956 break;
1957 }
1958 break;
1959 case 0x0c:
1960 GETBYTE ();
1961 switch (op[3] & 0x00)
1962 {
1963 case 0x00:
1964 goto op_semantics_14;
1965 break;
1966 }
1967 break;
1968 case 0x0d:
1969 GETBYTE ();
1970 switch (op[3] & 0x00)
1971 {
1972 case 0x00:
1973 goto op_semantics_15;
1974 break;
1975 }
1976 break;
1977 case 0x10:
1978 GETBYTE ();
1979 switch (op[3] & 0x00)
1980 {
1981 case 0x00:
1982 goto op_semantics_16;
1983 break;
1984 }
1985 break;
1986 case 0x11:
1987 GETBYTE ();
1988 switch (op[3] & 0x00)
1989 {
1990 case 0x00:
1991 goto op_semantics_17;
1992 break;
1993 }
1994 break;
1995 default: UNSUPPORTED(); break;
1996 }
1997 break;
1998 case 0x63:
1999 GETBYTE ();
2000 switch (op[2] & 0xff)
2001 {
2002 case 0x00:
2003 GETBYTE ();
2004 switch (op[3] & 0x00)
2005 {
2006 case 0x00:
2007 goto op_semantics_7;
2008 break;
2009 }
2010 break;
2011 case 0x04:
2012 GETBYTE ();
2013 switch (op[3] & 0x00)
2014 {
2015 case 0x00:
2016 goto op_semantics_8;
2017 break;
2018 }
2019 break;
2020 case 0x05:
2021 GETBYTE ();
2022 switch (op[3] & 0x00)
2023 {
2024 case 0x00:
2025 goto op_semantics_9;
2026 break;
2027 }
2028 break;
2029 case 0x06:
2030 GETBYTE ();
2031 switch (op[3] & 0x00)
2032 {
2033 case 0x00:
2034 goto op_semantics_10;
2035 break;
2036 }
2037 break;
2038 case 0x07:
2039 GETBYTE ();
2040 switch (op[3] & 0x00)
2041 {
2042 case 0x00:
2043 goto op_semantics_11;
2044 break;
2045 }
2046 break;
2047 case 0x08:
2048 GETBYTE ();
2049 switch (op[3] & 0x00)
2050 {
2051 case 0x00:
2052 goto op_semantics_12;
2053 break;
2054 }
2055 break;
2056 case 0x09:
2057 GETBYTE ();
2058 switch (op[3] & 0x00)
2059 {
2060 case 0x00:
2061 goto op_semantics_13;
2062 break;
2063 }
2064 break;
2065 case 0x0c:
2066 GETBYTE ();
2067 switch (op[3] & 0x00)
2068 {
2069 case 0x00:
2070 goto op_semantics_14;
2071 break;
2072 }
2073 break;
2074 case 0x0d:
2075 GETBYTE ();
2076 switch (op[3] & 0x00)
2077 {
2078 case 0x00:
2079 goto op_semantics_15;
2080 break;
2081 }
2082 break;
2083 case 0x10:
2084 GETBYTE ();
2085 switch (op[3] & 0x00)
2086 {
2087 case 0x00:
2088 goto op_semantics_16;
2089 break;
2090 }
2091 break;
2092 case 0x11:
2093 GETBYTE ();
2094 switch (op[3] & 0x00)
2095 {
2096 case 0x00:
2097 goto op_semantics_17;
2098 break;
2099 }
2100 break;
2101 default: UNSUPPORTED(); break;
2102 }
2103 break;
2104 case 0x80:
2105 GETBYTE ();
2106 switch (op[2] & 0x00)
2107 {
2108 case 0x00:
2109 goto op_semantics_1;
2110 break;
2111 }
2112 break;
2113 case 0x81:
2114 GETBYTE ();
2115 switch (op[2] & 0x00)
2116 {
2117 case 0x00:
2118 goto op_semantics_1;
2119 break;
2120 }
2121 break;
2122 case 0x82:
2123 GETBYTE ();
2124 switch (op[2] & 0x00)
2125 {
2126 case 0x00:
2127 goto op_semantics_1;
2128 break;
2129 }
2130 break;
2131 case 0x83:
2132 GETBYTE ();
2133 switch (op[2] & 0x00)
2134 {
2135 case 0x00:
2136 goto op_semantics_1;
2137 break;
2138 }
2139 break;
2140 case 0x84:
2141 GETBYTE ();
2142 switch (op[2] & 0x00)
2143 {
2144 case 0x00:
2145 goto op_semantics_2;
2146 break;
2147 }
2148 break;
2149 case 0x85:
2150 GETBYTE ();
2151 switch (op[2] & 0x00)
2152 {
2153 case 0x00:
2154 goto op_semantics_2;
2155 break;
2156 }
2157 break;
2158 case 0x86:
2159 GETBYTE ();
2160 switch (op[2] & 0x00)
2161 {
2162 case 0x00:
2163 goto op_semantics_2;
2164 break;
2165 }
2166 break;
2167 case 0x87:
2168 GETBYTE ();
2169 switch (op[2] & 0x00)
2170 {
2171 case 0x00:
2172 goto op_semantics_2;
2173 break;
2174 }
2175 break;
2176 case 0x88:
2177 GETBYTE ();
2178 switch (op[2] & 0x00)
2179 {
2180 case 0x00:
2181 goto op_semantics_3;
2182 break;
2183 }
2184 break;
2185 case 0x89:
2186 GETBYTE ();
2187 switch (op[2] & 0x00)
2188 {
2189 case 0x00:
2190 goto op_semantics_3;
2191 break;
2192 }
2193 break;
2194 case 0x8a:
2195 GETBYTE ();
2196 switch (op[2] & 0x00)
2197 {
2198 case 0x00:
2199 goto op_semantics_3;
2200 break;
2201 }
2202 break;
2203 case 0x8b:
2204 GETBYTE ();
2205 switch (op[2] & 0x00)
2206 {
2207 case 0x00:
2208 goto op_semantics_3;
2209 break;
2210 }
2211 break;
2212 case 0x8c:
2213 GETBYTE ();
2214 switch (op[2] & 0x00)
2215 {
2216 case 0x00:
2217 goto op_semantics_4;
2218 break;
2219 }
2220 break;
2221 case 0x8d:
2222 GETBYTE ();
2223 switch (op[2] & 0x00)
2224 {
2225 case 0x00:
2226 goto op_semantics_4;
2227 break;
2228 }
2229 break;
2230 case 0x8e:
2231 GETBYTE ();
2232 switch (op[2] & 0x00)
2233 {
2234 case 0x00:
2235 goto op_semantics_4;
2236 break;
2237 }
2238 break;
2239 case 0x8f:
2240 GETBYTE ();
2241 switch (op[2] & 0x00)
2242 {
2243 case 0x00:
2244 goto op_semantics_4;
2245 break;
2246 }
2247 break;
2248 case 0x90:
2249 GETBYTE ();
2250 switch (op[2] & 0x00)
2251 {
2252 case 0x00:
2253 goto op_semantics_5;
2254 break;
2255 }
2256 break;
2257 case 0x91:
2258 GETBYTE ();
2259 switch (op[2] & 0x00)
2260 {
2261 case 0x00:
2262 goto op_semantics_5;
2263 break;
2264 }
2265 break;
2266 case 0x92:
2267 GETBYTE ();
2268 switch (op[2] & 0x00)
2269 {
2270 case 0x00:
2271 goto op_semantics_5;
2272 break;
2273 }
2274 break;
2275 case 0x93:
2276 GETBYTE ();
2277 switch (op[2] & 0x00)
2278 {
2279 case 0x00:
2280 goto op_semantics_5;
2281 break;
2282 }
2283 break;
2284 case 0x94:
2285 GETBYTE ();
2286 switch (op[2] & 0x00)
2287 {
2288 case 0x00:
2289 goto op_semantics_6;
2290 break;
2291 }
2292 break;
2293 case 0x95:
2294 GETBYTE ();
2295 switch (op[2] & 0x00)
2296 {
2297 case 0x00:
2298 goto op_semantics_6;
2299 break;
2300 }
2301 break;
2302 case 0x96:
2303 GETBYTE ();
2304 switch (op[2] & 0x00)
2305 {
2306 case 0x00:
2307 goto op_semantics_6;
2308 break;
2309 }
2310 break;
2311 case 0x97:
2312 GETBYTE ();
2313 switch (op[2] & 0x00)
2314 {
2315 case 0x00:
2316 goto op_semantics_6;
2317 break;
2318 }
2319 break;
2320 case 0xa0:
2321 GETBYTE ();
2322 switch (op[2] & 0xff)
2323 {
2324 case 0x00:
2325 GETBYTE ();
2326 switch (op[3] & 0x00)
2327 {
2328 case 0x00:
2329 goto op_semantics_7;
2330 break;
2331 }
2332 break;
2333 case 0x02:
2334 GETBYTE ();
2335 switch (op[3] & 0x00)
2336 {
2337 case 0x00:
2338 op_semantics_18:
2339 {
2340 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2341 #line 470 "rx-decode.opc"
2342 int ss AU = op[1] & 0x03;
2343 #line 470 "rx-decode.opc"
2344 int rsrc AU = (op[3] >> 4) & 0x0f;
2345 #line 470 "rx-decode.opc"
2346 int rdst AU = op[3] & 0x0f;
2347 if (trace)
2348 {
2349 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2350 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2351 op[0], op[1], op[2], op[3]);
2352 printf (" ss = 0x%x,", ss);
2353 printf (" rsrc = 0x%x,", rsrc);
2354 printf (" rdst = 0x%x\n", rdst);
2355 }
2356 SYNTAX("adc %1%S1, %0");
2357 #line 470 "rx-decode.opc"
2358 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2359
2360 /*----------------------------------------------------------------------*/
2361 /* ADD */
2362
2363 }
2364 break;
2365 }
2366 break;
2367 case 0x04:
2368 GETBYTE ();
2369 switch (op[3] & 0x00)
2370 {
2371 case 0x00:
2372 goto op_semantics_8;
2373 break;
2374 }
2375 break;
2376 case 0x05:
2377 GETBYTE ();
2378 switch (op[3] & 0x00)
2379 {
2380 case 0x00:
2381 goto op_semantics_9;
2382 break;
2383 }
2384 break;
2385 case 0x06:
2386 GETBYTE ();
2387 switch (op[3] & 0x00)
2388 {
2389 case 0x00:
2390 goto op_semantics_10;
2391 break;
2392 }
2393 break;
2394 case 0x07:
2395 GETBYTE ();
2396 switch (op[3] & 0x00)
2397 {
2398 case 0x00:
2399 goto op_semantics_11;
2400 break;
2401 }
2402 break;
2403 case 0x08:
2404 GETBYTE ();
2405 switch (op[3] & 0x00)
2406 {
2407 case 0x00:
2408 goto op_semantics_12;
2409 break;
2410 }
2411 break;
2412 case 0x09:
2413 GETBYTE ();
2414 switch (op[3] & 0x00)
2415 {
2416 case 0x00:
2417 goto op_semantics_13;
2418 break;
2419 }
2420 break;
2421 case 0x0c:
2422 GETBYTE ();
2423 switch (op[3] & 0x00)
2424 {
2425 case 0x00:
2426 goto op_semantics_14;
2427 break;
2428 }
2429 break;
2430 case 0x0d:
2431 GETBYTE ();
2432 switch (op[3] & 0x00)
2433 {
2434 case 0x00:
2435 goto op_semantics_15;
2436 break;
2437 }
2438 break;
2439 case 0x10:
2440 GETBYTE ();
2441 switch (op[3] & 0x00)
2442 {
2443 case 0x00:
2444 goto op_semantics_16;
2445 break;
2446 }
2447 break;
2448 case 0x11:
2449 GETBYTE ();
2450 switch (op[3] & 0x00)
2451 {
2452 case 0x00:
2453 goto op_semantics_17;
2454 break;
2455 }
2456 break;
2457 default: UNSUPPORTED(); break;
2458 }
2459 break;
2460 case 0xa1:
2461 GETBYTE ();
2462 switch (op[2] & 0xff)
2463 {
2464 case 0x00:
2465 GETBYTE ();
2466 switch (op[3] & 0x00)
2467 {
2468 case 0x00:
2469 goto op_semantics_7;
2470 break;
2471 }
2472 break;
2473 case 0x02:
2474 GETBYTE ();
2475 switch (op[3] & 0x00)
2476 {
2477 case 0x00:
2478 goto op_semantics_18;
2479 break;
2480 }
2481 break;
2482 case 0x04:
2483 GETBYTE ();
2484 switch (op[3] & 0x00)
2485 {
2486 case 0x00:
2487 goto op_semantics_8;
2488 break;
2489 }
2490 break;
2491 case 0x05:
2492 GETBYTE ();
2493 switch (op[3] & 0x00)
2494 {
2495 case 0x00:
2496 goto op_semantics_9;
2497 break;
2498 }
2499 break;
2500 case 0x06:
2501 GETBYTE ();
2502 switch (op[3] & 0x00)
2503 {
2504 case 0x00:
2505 goto op_semantics_10;
2506 break;
2507 }
2508 break;
2509 case 0x07:
2510 GETBYTE ();
2511 switch (op[3] & 0x00)
2512 {
2513 case 0x00:
2514 goto op_semantics_11;
2515 break;
2516 }
2517 break;
2518 case 0x08:
2519 GETBYTE ();
2520 switch (op[3] & 0x00)
2521 {
2522 case 0x00:
2523 goto op_semantics_12;
2524 break;
2525 }
2526 break;
2527 case 0x09:
2528 GETBYTE ();
2529 switch (op[3] & 0x00)
2530 {
2531 case 0x00:
2532 goto op_semantics_13;
2533 break;
2534 }
2535 break;
2536 case 0x0c:
2537 GETBYTE ();
2538 switch (op[3] & 0x00)
2539 {
2540 case 0x00:
2541 goto op_semantics_14;
2542 break;
2543 }
2544 break;
2545 case 0x0d:
2546 GETBYTE ();
2547 switch (op[3] & 0x00)
2548 {
2549 case 0x00:
2550 goto op_semantics_15;
2551 break;
2552 }
2553 break;
2554 case 0x10:
2555 GETBYTE ();
2556 switch (op[3] & 0x00)
2557 {
2558 case 0x00:
2559 goto op_semantics_16;
2560 break;
2561 }
2562 break;
2563 case 0x11:
2564 GETBYTE ();
2565 switch (op[3] & 0x00)
2566 {
2567 case 0x00:
2568 goto op_semantics_17;
2569 break;
2570 }
2571 break;
2572 default: UNSUPPORTED(); break;
2573 }
2574 break;
2575 case 0xa2:
2576 GETBYTE ();
2577 switch (op[2] & 0xff)
2578 {
2579 case 0x00:
2580 GETBYTE ();
2581 switch (op[3] & 0x00)
2582 {
2583 case 0x00:
2584 goto op_semantics_7;
2585 break;
2586 }
2587 break;
2588 case 0x02:
2589 GETBYTE ();
2590 switch (op[3] & 0x00)
2591 {
2592 case 0x00:
2593 goto op_semantics_18;
2594 break;
2595 }
2596 break;
2597 case 0x04:
2598 GETBYTE ();
2599 switch (op[3] & 0x00)
2600 {
2601 case 0x00:
2602 goto op_semantics_8;
2603 break;
2604 }
2605 break;
2606 case 0x05:
2607 GETBYTE ();
2608 switch (op[3] & 0x00)
2609 {
2610 case 0x00:
2611 goto op_semantics_9;
2612 break;
2613 }
2614 break;
2615 case 0x06:
2616 GETBYTE ();
2617 switch (op[3] & 0x00)
2618 {
2619 case 0x00:
2620 goto op_semantics_10;
2621 break;
2622 }
2623 break;
2624 case 0x07:
2625 GETBYTE ();
2626 switch (op[3] & 0x00)
2627 {
2628 case 0x00:
2629 goto op_semantics_11;
2630 break;
2631 }
2632 break;
2633 case 0x08:
2634 GETBYTE ();
2635 switch (op[3] & 0x00)
2636 {
2637 case 0x00:
2638 goto op_semantics_12;
2639 break;
2640 }
2641 break;
2642 case 0x09:
2643 GETBYTE ();
2644 switch (op[3] & 0x00)
2645 {
2646 case 0x00:
2647 goto op_semantics_13;
2648 break;
2649 }
2650 break;
2651 case 0x0c:
2652 GETBYTE ();
2653 switch (op[3] & 0x00)
2654 {
2655 case 0x00:
2656 goto op_semantics_14;
2657 break;
2658 }
2659 break;
2660 case 0x0d:
2661 GETBYTE ();
2662 switch (op[3] & 0x00)
2663 {
2664 case 0x00:
2665 goto op_semantics_15;
2666 break;
2667 }
2668 break;
2669 case 0x10:
2670 GETBYTE ();
2671 switch (op[3] & 0x00)
2672 {
2673 case 0x00:
2674 goto op_semantics_16;
2675 break;
2676 }
2677 break;
2678 case 0x11:
2679 GETBYTE ();
2680 switch (op[3] & 0x00)
2681 {
2682 case 0x00:
2683 goto op_semantics_17;
2684 break;
2685 }
2686 break;
2687 default: UNSUPPORTED(); break;
2688 }
2689 break;
2690 case 0xa3:
2691 GETBYTE ();
2692 switch (op[2] & 0xff)
2693 {
2694 case 0x00:
2695 GETBYTE ();
2696 switch (op[3] & 0x00)
2697 {
2698 case 0x00:
2699 goto op_semantics_7;
2700 break;
2701 }
2702 break;
2703 case 0x02:
2704 GETBYTE ();
2705 switch (op[3] & 0x00)
2706 {
2707 case 0x00:
2708 goto op_semantics_18;
2709 break;
2710 }
2711 break;
2712 case 0x04:
2713 GETBYTE ();
2714 switch (op[3] & 0x00)
2715 {
2716 case 0x00:
2717 goto op_semantics_8;
2718 break;
2719 }
2720 break;
2721 case 0x05:
2722 GETBYTE ();
2723 switch (op[3] & 0x00)
2724 {
2725 case 0x00:
2726 goto op_semantics_9;
2727 break;
2728 }
2729 break;
2730 case 0x06:
2731 GETBYTE ();
2732 switch (op[3] & 0x00)
2733 {
2734 case 0x00:
2735 goto op_semantics_10;
2736 break;
2737 }
2738 break;
2739 case 0x07:
2740 GETBYTE ();
2741 switch (op[3] & 0x00)
2742 {
2743 case 0x00:
2744 goto op_semantics_11;
2745 break;
2746 }
2747 break;
2748 case 0x08:
2749 GETBYTE ();
2750 switch (op[3] & 0x00)
2751 {
2752 case 0x00:
2753 goto op_semantics_12;
2754 break;
2755 }
2756 break;
2757 case 0x09:
2758 GETBYTE ();
2759 switch (op[3] & 0x00)
2760 {
2761 case 0x00:
2762 goto op_semantics_13;
2763 break;
2764 }
2765 break;
2766 case 0x0c:
2767 GETBYTE ();
2768 switch (op[3] & 0x00)
2769 {
2770 case 0x00:
2771 goto op_semantics_14;
2772 break;
2773 }
2774 break;
2775 case 0x0d:
2776 GETBYTE ();
2777 switch (op[3] & 0x00)
2778 {
2779 case 0x00:
2780 goto op_semantics_15;
2781 break;
2782 }
2783 break;
2784 case 0x10:
2785 GETBYTE ();
2786 switch (op[3] & 0x00)
2787 {
2788 case 0x00:
2789 goto op_semantics_16;
2790 break;
2791 }
2792 break;
2793 case 0x11:
2794 GETBYTE ();
2795 switch (op[3] & 0x00)
2796 {
2797 case 0x00:
2798 goto op_semantics_17;
2799 break;
2800 }
2801 break;
2802 default: UNSUPPORTED(); break;
2803 }
2804 break;
2805 case 0xc0:
2806 GETBYTE ();
2807 switch (op[2] & 0x00)
2808 {
2809 case 0x00:
2810 goto op_semantics_1;
2811 break;
2812 }
2813 break;
2814 case 0xc1:
2815 GETBYTE ();
2816 switch (op[2] & 0x00)
2817 {
2818 case 0x00:
2819 goto op_semantics_1;
2820 break;
2821 }
2822 break;
2823 case 0xc2:
2824 GETBYTE ();
2825 switch (op[2] & 0x00)
2826 {
2827 case 0x00:
2828 goto op_semantics_1;
2829 break;
2830 }
2831 break;
2832 case 0xc3:
2833 GETBYTE ();
2834 switch (op[2] & 0x00)
2835 {
2836 case 0x00:
2837 goto op_semantics_1;
2838 break;
2839 }
2840 break;
2841 case 0xc4:
2842 GETBYTE ();
2843 switch (op[2] & 0x00)
2844 {
2845 case 0x00:
2846 goto op_semantics_2;
2847 break;
2848 }
2849 break;
2850 case 0xc5:
2851 GETBYTE ();
2852 switch (op[2] & 0x00)
2853 {
2854 case 0x00:
2855 goto op_semantics_2;
2856 break;
2857 }
2858 break;
2859 case 0xc6:
2860 GETBYTE ();
2861 switch (op[2] & 0x00)
2862 {
2863 case 0x00:
2864 goto op_semantics_2;
2865 break;
2866 }
2867 break;
2868 case 0xc7:
2869 GETBYTE ();
2870 switch (op[2] & 0x00)
2871 {
2872 case 0x00:
2873 goto op_semantics_2;
2874 break;
2875 }
2876 break;
2877 case 0xc8:
2878 GETBYTE ();
2879 switch (op[2] & 0x00)
2880 {
2881 case 0x00:
2882 goto op_semantics_3;
2883 break;
2884 }
2885 break;
2886 case 0xc9:
2887 GETBYTE ();
2888 switch (op[2] & 0x00)
2889 {
2890 case 0x00:
2891 goto op_semantics_3;
2892 break;
2893 }
2894 break;
2895 case 0xca:
2896 GETBYTE ();
2897 switch (op[2] & 0x00)
2898 {
2899 case 0x00:
2900 goto op_semantics_3;
2901 break;
2902 }
2903 break;
2904 case 0xcb:
2905 GETBYTE ();
2906 switch (op[2] & 0x00)
2907 {
2908 case 0x00:
2909 goto op_semantics_3;
2910 break;
2911 }
2912 break;
2913 case 0xcc:
2914 GETBYTE ();
2915 switch (op[2] & 0x00)
2916 {
2917 case 0x00:
2918 goto op_semantics_4;
2919 break;
2920 }
2921 break;
2922 case 0xcd:
2923 GETBYTE ();
2924 switch (op[2] & 0x00)
2925 {
2926 case 0x00:
2927 goto op_semantics_4;
2928 break;
2929 }
2930 break;
2931 case 0xce:
2932 GETBYTE ();
2933 switch (op[2] & 0x00)
2934 {
2935 case 0x00:
2936 goto op_semantics_4;
2937 break;
2938 }
2939 break;
2940 case 0xcf:
2941 GETBYTE ();
2942 switch (op[2] & 0x00)
2943 {
2944 case 0x00:
2945 goto op_semantics_4;
2946 break;
2947 }
2948 break;
2949 case 0xd0:
2950 GETBYTE ();
2951 switch (op[2] & 0x00)
2952 {
2953 case 0x00:
2954 goto op_semantics_5;
2955 break;
2956 }
2957 break;
2958 case 0xd1:
2959 GETBYTE ();
2960 switch (op[2] & 0x00)
2961 {
2962 case 0x00:
2963 goto op_semantics_5;
2964 break;
2965 }
2966 break;
2967 case 0xd2:
2968 GETBYTE ();
2969 switch (op[2] & 0x00)
2970 {
2971 case 0x00:
2972 goto op_semantics_5;
2973 break;
2974 }
2975 break;
2976 case 0xd3:
2977 GETBYTE ();
2978 switch (op[2] & 0x00)
2979 {
2980 case 0x00:
2981 goto op_semantics_5;
2982 break;
2983 }
2984 break;
2985 case 0xd4:
2986 GETBYTE ();
2987 switch (op[2] & 0x00)
2988 {
2989 case 0x00:
2990 goto op_semantics_6;
2991 break;
2992 }
2993 break;
2994 case 0xd5:
2995 GETBYTE ();
2996 switch (op[2] & 0x00)
2997 {
2998 case 0x00:
2999 goto op_semantics_6;
3000 break;
3001 }
3002 break;
3003 case 0xd6:
3004 GETBYTE ();
3005 switch (op[2] & 0x00)
3006 {
3007 case 0x00:
3008 goto op_semantics_6;
3009 break;
3010 }
3011 break;
3012 case 0xd7:
3013 GETBYTE ();
3014 switch (op[2] & 0x00)
3015 {
3016 case 0x00:
3017 goto op_semantics_6;
3018 break;
3019 }
3020 break;
3021 case 0xe0:
3022 GETBYTE ();
3023 switch (op[2] & 0xff)
3024 {
3025 case 0x00:
3026 GETBYTE ();
3027 switch (op[3] & 0x00)
3028 {
3029 case 0x00:
3030 goto op_semantics_7;
3031 break;
3032 }
3033 break;
3034 case 0x04:
3035 GETBYTE ();
3036 switch (op[3] & 0x00)
3037 {
3038 case 0x00:
3039 goto op_semantics_8;
3040 break;
3041 }
3042 break;
3043 case 0x05:
3044 GETBYTE ();
3045 switch (op[3] & 0x00)
3046 {
3047 case 0x00:
3048 goto op_semantics_9;
3049 break;
3050 }
3051 break;
3052 case 0x06:
3053 GETBYTE ();
3054 switch (op[3] & 0x00)
3055 {
3056 case 0x00:
3057 goto op_semantics_10;
3058 break;
3059 }
3060 break;
3061 case 0x07:
3062 GETBYTE ();
3063 switch (op[3] & 0x00)
3064 {
3065 case 0x00:
3066 goto op_semantics_11;
3067 break;
3068 }
3069 break;
3070 case 0x08:
3071 GETBYTE ();
3072 switch (op[3] & 0x00)
3073 {
3074 case 0x00:
3075 goto op_semantics_12;
3076 break;
3077 }
3078 break;
3079 case 0x09:
3080 GETBYTE ();
3081 switch (op[3] & 0x00)
3082 {
3083 case 0x00:
3084 goto op_semantics_13;
3085 break;
3086 }
3087 break;
3088 case 0x0c:
3089 GETBYTE ();
3090 switch (op[3] & 0x00)
3091 {
3092 case 0x00:
3093 goto op_semantics_14;
3094 break;
3095 }
3096 break;
3097 case 0x0d:
3098 GETBYTE ();
3099 switch (op[3] & 0x00)
3100 {
3101 case 0x00:
3102 goto op_semantics_15;
3103 break;
3104 }
3105 break;
3106 case 0x10:
3107 GETBYTE ();
3108 switch (op[3] & 0x00)
3109 {
3110 case 0x00:
3111 goto op_semantics_16;
3112 break;
3113 }
3114 break;
3115 case 0x11:
3116 GETBYTE ();
3117 switch (op[3] & 0x00)
3118 {
3119 case 0x00:
3120 goto op_semantics_17;
3121 break;
3122 }
3123 break;
3124 default: UNSUPPORTED(); break;
3125 }
3126 break;
3127 case 0xe1:
3128 GETBYTE ();
3129 switch (op[2] & 0xff)
3130 {
3131 case 0x00:
3132 GETBYTE ();
3133 switch (op[3] & 0x00)
3134 {
3135 case 0x00:
3136 goto op_semantics_7;
3137 break;
3138 }
3139 break;
3140 case 0x04:
3141 GETBYTE ();
3142 switch (op[3] & 0x00)
3143 {
3144 case 0x00:
3145 goto op_semantics_8;
3146 break;
3147 }
3148 break;
3149 case 0x05:
3150 GETBYTE ();
3151 switch (op[3] & 0x00)
3152 {
3153 case 0x00:
3154 goto op_semantics_9;
3155 break;
3156 }
3157 break;
3158 case 0x06:
3159 GETBYTE ();
3160 switch (op[3] & 0x00)
3161 {
3162 case 0x00:
3163 goto op_semantics_10;
3164 break;
3165 }
3166 break;
3167 case 0x07:
3168 GETBYTE ();
3169 switch (op[3] & 0x00)
3170 {
3171 case 0x00:
3172 goto op_semantics_11;
3173 break;
3174 }
3175 break;
3176 case 0x08:
3177 GETBYTE ();
3178 switch (op[3] & 0x00)
3179 {
3180 case 0x00:
3181 goto op_semantics_12;
3182 break;
3183 }
3184 break;
3185 case 0x09:
3186 GETBYTE ();
3187 switch (op[3] & 0x00)
3188 {
3189 case 0x00:
3190 goto op_semantics_13;
3191 break;
3192 }
3193 break;
3194 case 0x0c:
3195 GETBYTE ();
3196 switch (op[3] & 0x00)
3197 {
3198 case 0x00:
3199 goto op_semantics_14;
3200 break;
3201 }
3202 break;
3203 case 0x0d:
3204 GETBYTE ();
3205 switch (op[3] & 0x00)
3206 {
3207 case 0x00:
3208 goto op_semantics_15;
3209 break;
3210 }
3211 break;
3212 case 0x10:
3213 GETBYTE ();
3214 switch (op[3] & 0x00)
3215 {
3216 case 0x00:
3217 goto op_semantics_16;
3218 break;
3219 }
3220 break;
3221 case 0x11:
3222 GETBYTE ();
3223 switch (op[3] & 0x00)
3224 {
3225 case 0x00:
3226 goto op_semantics_17;
3227 break;
3228 }
3229 break;
3230 default: UNSUPPORTED(); break;
3231 }
3232 break;
3233 case 0xe2:
3234 GETBYTE ();
3235 switch (op[2] & 0xff)
3236 {
3237 case 0x00:
3238 GETBYTE ();
3239 switch (op[3] & 0x00)
3240 {
3241 case 0x00:
3242 goto op_semantics_7;
3243 break;
3244 }
3245 break;
3246 case 0x04:
3247 GETBYTE ();
3248 switch (op[3] & 0x00)
3249 {
3250 case 0x00:
3251 goto op_semantics_8;
3252 break;
3253 }
3254 break;
3255 case 0x05:
3256 GETBYTE ();
3257 switch (op[3] & 0x00)
3258 {
3259 case 0x00:
3260 goto op_semantics_9;
3261 break;
3262 }
3263 break;
3264 case 0x06:
3265 GETBYTE ();
3266 switch (op[3] & 0x00)
3267 {
3268 case 0x00:
3269 goto op_semantics_10;
3270 break;
3271 }
3272 break;
3273 case 0x07:
3274 GETBYTE ();
3275 switch (op[3] & 0x00)
3276 {
3277 case 0x00:
3278 goto op_semantics_11;
3279 break;
3280 }
3281 break;
3282 case 0x08:
3283 GETBYTE ();
3284 switch (op[3] & 0x00)
3285 {
3286 case 0x00:
3287 goto op_semantics_12;
3288 break;
3289 }
3290 break;
3291 case 0x09:
3292 GETBYTE ();
3293 switch (op[3] & 0x00)
3294 {
3295 case 0x00:
3296 goto op_semantics_13;
3297 break;
3298 }
3299 break;
3300 case 0x0c:
3301 GETBYTE ();
3302 switch (op[3] & 0x00)
3303 {
3304 case 0x00:
3305 goto op_semantics_14;
3306 break;
3307 }
3308 break;
3309 case 0x0d:
3310 GETBYTE ();
3311 switch (op[3] & 0x00)
3312 {
3313 case 0x00:
3314 goto op_semantics_15;
3315 break;
3316 }
3317 break;
3318 case 0x10:
3319 GETBYTE ();
3320 switch (op[3] & 0x00)
3321 {
3322 case 0x00:
3323 goto op_semantics_16;
3324 break;
3325 }
3326 break;
3327 case 0x11:
3328 GETBYTE ();
3329 switch (op[3] & 0x00)
3330 {
3331 case 0x00:
3332 goto op_semantics_17;
3333 break;
3334 }
3335 break;
3336 default: UNSUPPORTED(); break;
3337 }
3338 break;
3339 case 0xe3:
3340 GETBYTE ();
3341 switch (op[2] & 0xff)
3342 {
3343 case 0x00:
3344 GETBYTE ();
3345 switch (op[3] & 0x00)
3346 {
3347 case 0x00:
3348 goto op_semantics_7;
3349 break;
3350 }
3351 break;
3352 case 0x04:
3353 GETBYTE ();
3354 switch (op[3] & 0x00)
3355 {
3356 case 0x00:
3357 goto op_semantics_8;
3358 break;
3359 }
3360 break;
3361 case 0x05:
3362 GETBYTE ();
3363 switch (op[3] & 0x00)
3364 {
3365 case 0x00:
3366 goto op_semantics_9;
3367 break;
3368 }
3369 break;
3370 case 0x06:
3371 GETBYTE ();
3372 switch (op[3] & 0x00)
3373 {
3374 case 0x00:
3375 goto op_semantics_10;
3376 break;
3377 }
3378 break;
3379 case 0x07:
3380 GETBYTE ();
3381 switch (op[3] & 0x00)
3382 {
3383 case 0x00:
3384 goto op_semantics_11;
3385 break;
3386 }
3387 break;
3388 case 0x08:
3389 GETBYTE ();
3390 switch (op[3] & 0x00)
3391 {
3392 case 0x00:
3393 goto op_semantics_12;
3394 break;
3395 }
3396 break;
3397 case 0x09:
3398 GETBYTE ();
3399 switch (op[3] & 0x00)
3400 {
3401 case 0x00:
3402 goto op_semantics_13;
3403 break;
3404 }
3405 break;
3406 case 0x0c:
3407 GETBYTE ();
3408 switch (op[3] & 0x00)
3409 {
3410 case 0x00:
3411 goto op_semantics_14;
3412 break;
3413 }
3414 break;
3415 case 0x0d:
3416 GETBYTE ();
3417 switch (op[3] & 0x00)
3418 {
3419 case 0x00:
3420 goto op_semantics_15;
3421 break;
3422 }
3423 break;
3424 case 0x10:
3425 GETBYTE ();
3426 switch (op[3] & 0x00)
3427 {
3428 case 0x00:
3429 goto op_semantics_16;
3430 break;
3431 }
3432 break;
3433 case 0x11:
3434 GETBYTE ();
3435 switch (op[3] & 0x00)
3436 {
3437 case 0x00:
3438 goto op_semantics_17;
3439 break;
3440 }
3441 break;
3442 default: UNSUPPORTED(); break;
3443 }
3444 break;
3445 default: UNSUPPORTED(); break;
3446 }
3447 break;
3448 case 0x08:
3449 case 0x09:
3450 case 0x0a:
3451 case 0x0b:
3452 case 0x0c:
3453 case 0x0d:
3454 case 0x0e:
3455 case 0x0f:
3456 {
3457 /** 0000 1dsp bra.s %a0 */
3458 #line 713 "rx-decode.opc"
3459 int dsp AU = op[0] & 0x07;
3460 if (trace)
3461 {
3462 printf ("\033[33m%s\033[0m %02x\n",
3463 "/** 0000 1dsp bra.s %a0 */",
3464 op[0]);
3465 printf (" dsp = 0x%x\n", dsp);
3466 }
3467 SYNTAX("bra.s %a0");
3468 #line 713 "rx-decode.opc"
3469 ID(branch); DC(pc + dsp3map[dsp]);
3470
3471 }
3472 break;
3473 case 0x10:
3474 case 0x11:
3475 case 0x12:
3476 case 0x13:
3477 case 0x14:
3478 case 0x15:
3479 case 0x16:
3480 case 0x17:
3481 case 0x18:
3482 case 0x19:
3483 case 0x1a:
3484 case 0x1b:
3485 case 0x1c:
3486 case 0x1d:
3487 case 0x1e:
3488 case 0x1f:
3489 {
3490 /** 0001 n dsp b%1.s %a0 */
3491 #line 703 "rx-decode.opc"
3492 int n AU = (op[0] >> 3) & 0x01;
3493 #line 703 "rx-decode.opc"
3494 int dsp AU = op[0] & 0x07;
3495 if (trace)
3496 {
3497 printf ("\033[33m%s\033[0m %02x\n",
3498 "/** 0001 n dsp b%1.s %a0 */",
3499 op[0]);
3500 printf (" n = 0x%x,", n);
3501 printf (" dsp = 0x%x\n", dsp);
3502 }
3503 SYNTAX("b%1.s %a0");
3504 #line 703 "rx-decode.opc"
3505 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3506
3507 }
3508 break;
3509 case 0x20:
3510 case 0x21:
3511 case 0x22:
3512 case 0x23:
3513 case 0x24:
3514 case 0x25:
3515 case 0x26:
3516 case 0x27:
3517 case 0x28:
3518 case 0x29:
3519 case 0x2a:
3520 case 0x2b:
3521 case 0x2c:
3522 case 0x2d:
3523 case 0x2f:
3524 {
3525 /** 0010 cond b%1.b %a0 */
3526 #line 706 "rx-decode.opc"
3527 int cond AU = op[0] & 0x0f;
3528 if (trace)
3529 {
3530 printf ("\033[33m%s\033[0m %02x\n",
3531 "/** 0010 cond b%1.b %a0 */",
3532 op[0]);
3533 printf (" cond = 0x%x\n", cond);
3534 }
3535 SYNTAX("b%1.b %a0");
3536 #line 706 "rx-decode.opc"
3537 ID(branch); Scc(cond); DC(pc + IMMex (1));
3538
3539 }
3540 break;
3541 case 0x2e:
3542 {
3543 /** 0010 1110 bra.b %a0 */
3544 if (trace)
3545 {
3546 printf ("\033[33m%s\033[0m %02x\n",
3547 "/** 0010 1110 bra.b %a0 */",
3548 op[0]);
3549 }
3550 SYNTAX("bra.b %a0");
3551 #line 716 "rx-decode.opc"
3552 ID(branch); DC(pc + IMMex(1));
3553
3554 }
3555 break;
3556 case 0x38:
3557 {
3558 /** 0011 1000 bra.w %a0 */
3559 if (trace)
3560 {
3561 printf ("\033[33m%s\033[0m %02x\n",
3562 "/** 0011 1000 bra.w %a0 */",
3563 op[0]);
3564 }
3565 SYNTAX("bra.w %a0");
3566 #line 719 "rx-decode.opc"
3567 ID(branch); DC(pc + IMMex(2));
3568
3569 }
3570 break;
3571 case 0x39:
3572 {
3573 /** 0011 1001 bsr.w %a0 */
3574 if (trace)
3575 {
3576 printf ("\033[33m%s\033[0m %02x\n",
3577 "/** 0011 1001 bsr.w %a0 */",
3578 op[0]);
3579 }
3580 SYNTAX("bsr.w %a0");
3581 #line 735 "rx-decode.opc"
3582 ID(jsr); DC(pc + IMMex(2));
3583
3584 }
3585 break;
3586 case 0x3a:
3587 case 0x3b:
3588 {
3589 /** 0011 101c b%1.w %a0 */
3590 #line 709 "rx-decode.opc"
3591 int c AU = op[0] & 0x01;
3592 if (trace)
3593 {
3594 printf ("\033[33m%s\033[0m %02x\n",
3595 "/** 0011 101c b%1.w %a0 */",
3596 op[0]);
3597 printf (" c = 0x%x\n", c);
3598 }
3599 SYNTAX("b%1.w %a0");
3600 #line 709 "rx-decode.opc"
3601 ID(branch); Scc(c); DC(pc + IMMex (2));
3602
3603
3604 }
3605 break;
3606 case 0x3c:
3607 GETBYTE ();
3608 switch (op[1] & 0x00)
3609 {
3610 case 0x00:
3611 op_semantics_19:
3612 {
3613 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3614 #line 283 "rx-decode.opc"
3615 int sz AU = op[0] & 0x03;
3616 #line 283 "rx-decode.opc"
3617 int d AU = (op[1] >> 7) & 0x01;
3618 #line 283 "rx-decode.opc"
3619 int dst AU = (op[1] >> 4) & 0x07;
3620 #line 283 "rx-decode.opc"
3621 int sppp AU = op[1] & 0x0f;
3622 if (trace)
3623 {
3624 printf ("\033[33m%s\033[0m %02x %02x\n",
3625 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3626 op[0], op[1]);
3627 printf (" sz = 0x%x,", sz);
3628 printf (" d = 0x%x,", d);
3629 printf (" dst = 0x%x,", dst);
3630 printf (" sppp = 0x%x\n", sppp);
3631 }
3632 SYNTAX("mov%s #%1, %0");
3633 #line 283 "rx-decode.opc"
3634 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3635
3636 }
3637 break;
3638 }
3639 break;
3640 case 0x3d:
3641 GETBYTE ();
3642 switch (op[1] & 0x00)
3643 {
3644 case 0x00:
3645 goto op_semantics_19;
3646 break;
3647 }
3648 break;
3649 case 0x3e:
3650 GETBYTE ();
3651 switch (op[1] & 0x00)
3652 {
3653 case 0x00:
3654 goto op_semantics_19;
3655 break;
3656 }
3657 break;
3658 case 0x3f:
3659 GETBYTE ();
3660 switch (op[1] & 0x00)
3661 {
3662 case 0x00:
3663 {
3664 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3665 #line 380 "rx-decode.opc"
3666 int rega AU = (op[1] >> 4) & 0x0f;
3667 #line 380 "rx-decode.opc"
3668 int regb AU = op[1] & 0x0f;
3669 if (trace)
3670 {
3671 printf ("\033[33m%s\033[0m %02x %02x\n",
3672 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3673 op[0], op[1]);
3674 printf (" rega = 0x%x,", rega);
3675 printf (" regb = 0x%x\n", regb);
3676 }
3677 SYNTAX("rtsd #%1, %2-%0");
3678 #line 380 "rx-decode.opc"
3679 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3680
3681 /*----------------------------------------------------------------------*/
3682 /* AND */
3683
3684 }
3685 break;
3686 }
3687 break;
3688 case 0x40:
3689 GETBYTE ();
3690 switch (op[1] & 0x00)
3691 {
3692 case 0x00:
3693 op_semantics_20:
3694 {
3695 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3696 #line 515 "rx-decode.opc"
3697 int ss AU = op[0] & 0x03;
3698 #line 515 "rx-decode.opc"
3699 int rsrc AU = (op[1] >> 4) & 0x0f;
3700 #line 515 "rx-decode.opc"
3701 int rdst AU = op[1] & 0x0f;
3702 if (trace)
3703 {
3704 printf ("\033[33m%s\033[0m %02x %02x\n",
3705 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3706 op[0], op[1]);
3707 printf (" ss = 0x%x,", ss);
3708 printf (" rsrc = 0x%x,", rsrc);
3709 printf (" rdst = 0x%x\n", rdst);
3710 }
3711 SYNTAX("sub %2%S2, %1");
3712 #line 515 "rx-decode.opc"
3713 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3714
3715 }
3716 break;
3717 }
3718 break;
3719 case 0x41:
3720 GETBYTE ();
3721 switch (op[1] & 0x00)
3722 {
3723 case 0x00:
3724 goto op_semantics_20;
3725 break;
3726 }
3727 break;
3728 case 0x42:
3729 GETBYTE ();
3730 switch (op[1] & 0x00)
3731 {
3732 case 0x00:
3733 goto op_semantics_20;
3734 break;
3735 }
3736 break;
3737 case 0x43:
3738 GETBYTE ();
3739 switch (op[1] & 0x00)
3740 {
3741 case 0x00:
3742 goto op_semantics_20;
3743 break;
3744 }
3745 break;
3746 case 0x44:
3747 GETBYTE ();
3748 switch (op[1] & 0x00)
3749 {
3750 case 0x00:
3751 op_semantics_21:
3752 {
3753 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3754 #line 503 "rx-decode.opc"
3755 int ss AU = op[0] & 0x03;
3756 #line 503 "rx-decode.opc"
3757 int rsrc AU = (op[1] >> 4) & 0x0f;
3758 #line 503 "rx-decode.opc"
3759 int rdst AU = op[1] & 0x0f;
3760 if (trace)
3761 {
3762 printf ("\033[33m%s\033[0m %02x %02x\n",
3763 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3764 op[0], op[1]);
3765 printf (" ss = 0x%x,", ss);
3766 printf (" rsrc = 0x%x,", rsrc);
3767 printf (" rdst = 0x%x\n", rdst);
3768 }
3769 SYNTAX("cmp %2%S2, %1");
3770 #line 503 "rx-decode.opc"
3771 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3772
3773 }
3774 break;
3775 }
3776 break;
3777 case 0x45:
3778 GETBYTE ();
3779 switch (op[1] & 0x00)
3780 {
3781 case 0x00:
3782 goto op_semantics_21;
3783 break;
3784 }
3785 break;
3786 case 0x46:
3787 GETBYTE ();
3788 switch (op[1] & 0x00)
3789 {
3790 case 0x00:
3791 goto op_semantics_21;
3792 break;
3793 }
3794 break;
3795 case 0x47:
3796 GETBYTE ();
3797 switch (op[1] & 0x00)
3798 {
3799 case 0x00:
3800 goto op_semantics_21;
3801 break;
3802 }
3803 break;
3804 case 0x48:
3805 GETBYTE ();
3806 switch (op[1] & 0x00)
3807 {
3808 case 0x00:
3809 op_semantics_22:
3810 {
3811 /** 0100 10ss rsrc rdst add %1%S1, %0 */
3812 #line 479 "rx-decode.opc"
3813 int ss AU = op[0] & 0x03;
3814 #line 479 "rx-decode.opc"
3815 int rsrc AU = (op[1] >> 4) & 0x0f;
3816 #line 479 "rx-decode.opc"
3817 int rdst AU = op[1] & 0x0f;
3818 if (trace)
3819 {
3820 printf ("\033[33m%s\033[0m %02x %02x\n",
3821 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3822 op[0], op[1]);
3823 printf (" ss = 0x%x,", ss);
3824 printf (" rsrc = 0x%x,", rsrc);
3825 printf (" rdst = 0x%x\n", rdst);
3826 }
3827 SYNTAX("add %1%S1, %0");
3828 #line 479 "rx-decode.opc"
3829 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
3830
3831 }
3832 break;
3833 }
3834 break;
3835 case 0x49:
3836 GETBYTE ();
3837 switch (op[1] & 0x00)
3838 {
3839 case 0x00:
3840 goto op_semantics_22;
3841 break;
3842 }
3843 break;
3844 case 0x4a:
3845 GETBYTE ();
3846 switch (op[1] & 0x00)
3847 {
3848 case 0x00:
3849 goto op_semantics_22;
3850 break;
3851 }
3852 break;
3853 case 0x4b:
3854 GETBYTE ();
3855 switch (op[1] & 0x00)
3856 {
3857 case 0x00:
3858 goto op_semantics_22;
3859 break;
3860 }
3861 break;
3862 case 0x4c:
3863 GETBYTE ();
3864 switch (op[1] & 0x00)
3865 {
3866 case 0x00:
3867 op_semantics_23:
3868 {
3869 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
3870 #line 584 "rx-decode.opc"
3871 int ss AU = op[0] & 0x03;
3872 #line 584 "rx-decode.opc"
3873 int rsrc AU = (op[1] >> 4) & 0x0f;
3874 #line 584 "rx-decode.opc"
3875 int rdst AU = op[1] & 0x0f;
3876 if (trace)
3877 {
3878 printf ("\033[33m%s\033[0m %02x %02x\n",
3879 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3880 op[0], op[1]);
3881 printf (" ss = 0x%x,", ss);
3882 printf (" rsrc = 0x%x,", rsrc);
3883 printf (" rdst = 0x%x\n", rdst);
3884 }
3885 SYNTAX("mul %1%S1, %0");
3886 #line 584 "rx-decode.opc"
3887 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
3888
3889 }
3890 break;
3891 }
3892 break;
3893 case 0x4d:
3894 GETBYTE ();
3895 switch (op[1] & 0x00)
3896 {
3897 case 0x00:
3898 goto op_semantics_23;
3899 break;
3900 }
3901 break;
3902 case 0x4e:
3903 GETBYTE ();
3904 switch (op[1] & 0x00)
3905 {
3906 case 0x00:
3907 goto op_semantics_23;
3908 break;
3909 }
3910 break;
3911 case 0x4f:
3912 GETBYTE ();
3913 switch (op[1] & 0x00)
3914 {
3915 case 0x00:
3916 goto op_semantics_23;
3917 break;
3918 }
3919 break;
3920 case 0x50:
3921 GETBYTE ();
3922 switch (op[1] & 0x00)
3923 {
3924 case 0x00:
3925 op_semantics_24:
3926 {
3927 /** 0101 00ss rsrc rdst and %1%S1, %0 */
3928 #line 392 "rx-decode.opc"
3929 int ss AU = op[0] & 0x03;
3930 #line 392 "rx-decode.opc"
3931 int rsrc AU = (op[1] >> 4) & 0x0f;
3932 #line 392 "rx-decode.opc"
3933 int rdst AU = op[1] & 0x0f;
3934 if (trace)
3935 {
3936 printf ("\033[33m%s\033[0m %02x %02x\n",
3937 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3938 op[0], op[1]);
3939 printf (" ss = 0x%x,", ss);
3940 printf (" rsrc = 0x%x,", rsrc);
3941 printf (" rdst = 0x%x\n", rdst);
3942 }
3943 SYNTAX("and %1%S1, %0");
3944 #line 392 "rx-decode.opc"
3945 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
3946
3947 }
3948 break;
3949 }
3950 break;
3951 case 0x51:
3952 GETBYTE ();
3953 switch (op[1] & 0x00)
3954 {
3955 case 0x00:
3956 goto op_semantics_24;
3957 break;
3958 }
3959 break;
3960 case 0x52:
3961 GETBYTE ();
3962 switch (op[1] & 0x00)
3963 {
3964 case 0x00:
3965 goto op_semantics_24;
3966 break;
3967 }
3968 break;
3969 case 0x53:
3970 GETBYTE ();
3971 switch (op[1] & 0x00)
3972 {
3973 case 0x00:
3974 goto op_semantics_24;
3975 break;
3976 }
3977 break;
3978 case 0x54:
3979 GETBYTE ();
3980 switch (op[1] & 0x00)
3981 {
3982 case 0x00:
3983 op_semantics_25:
3984 {
3985 /** 0101 01ss rsrc rdst or %1%S1, %0 */
3986 #line 410 "rx-decode.opc"
3987 int ss AU = op[0] & 0x03;
3988 #line 410 "rx-decode.opc"
3989 int rsrc AU = (op[1] >> 4) & 0x0f;
3990 #line 410 "rx-decode.opc"
3991 int rdst AU = op[1] & 0x0f;
3992 if (trace)
3993 {
3994 printf ("\033[33m%s\033[0m %02x %02x\n",
3995 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
3996 op[0], op[1]);
3997 printf (" ss = 0x%x,", ss);
3998 printf (" rsrc = 0x%x,", rsrc);
3999 printf (" rdst = 0x%x\n", rdst);
4000 }
4001 SYNTAX("or %1%S1, %0");
4002 #line 410 "rx-decode.opc"
4003 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4004
4005 }
4006 break;
4007 }
4008 break;
4009 case 0x55:
4010 GETBYTE ();
4011 switch (op[1] & 0x00)
4012 {
4013 case 0x00:
4014 goto op_semantics_25;
4015 break;
4016 }
4017 break;
4018 case 0x56:
4019 GETBYTE ();
4020 switch (op[1] & 0x00)
4021 {
4022 case 0x00:
4023 goto op_semantics_25;
4024 break;
4025 }
4026 break;
4027 case 0x57:
4028 GETBYTE ();
4029 switch (op[1] & 0x00)
4030 {
4031 case 0x00:
4032 goto op_semantics_25;
4033 break;
4034 }
4035 break;
4036 case 0x58:
4037 GETBYTE ();
4038 switch (op[1] & 0x00)
4039 {
4040 case 0x00:
4041 op_semantics_26:
4042 {
4043 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4044 #line 331 "rx-decode.opc"
4045 int s AU = (op[0] >> 2) & 0x01;
4046 #line 331 "rx-decode.opc"
4047 int ss AU = op[0] & 0x03;
4048 #line 331 "rx-decode.opc"
4049 int rsrc AU = (op[1] >> 4) & 0x0f;
4050 #line 331 "rx-decode.opc"
4051 int rdst AU = op[1] & 0x0f;
4052 if (trace)
4053 {
4054 printf ("\033[33m%s\033[0m %02x %02x\n",
4055 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4056 op[0], op[1]);
4057 printf (" s = 0x%x,", s);
4058 printf (" ss = 0x%x,", ss);
4059 printf (" rsrc = 0x%x,", rsrc);
4060 printf (" rdst = 0x%x\n", rdst);
4061 }
4062 SYNTAX("movu%s %1, %0");
4063 #line 331 "rx-decode.opc"
4064 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____;
4065
4066 }
4067 break;
4068 }
4069 break;
4070 case 0x59:
4071 GETBYTE ();
4072 switch (op[1] & 0x00)
4073 {
4074 case 0x00:
4075 goto op_semantics_26;
4076 break;
4077 }
4078 break;
4079 case 0x5a:
4080 GETBYTE ();
4081 switch (op[1] & 0x00)
4082 {
4083 case 0x00:
4084 goto op_semantics_26;
4085 break;
4086 }
4087 break;
4088 case 0x5b:
4089 GETBYTE ();
4090 switch (op[1] & 0x00)
4091 {
4092 case 0x00:
4093 goto op_semantics_26;
4094 break;
4095 }
4096 break;
4097 case 0x5c:
4098 GETBYTE ();
4099 switch (op[1] & 0x00)
4100 {
4101 case 0x00:
4102 goto op_semantics_26;
4103 break;
4104 }
4105 break;
4106 case 0x5d:
4107 GETBYTE ();
4108 switch (op[1] & 0x00)
4109 {
4110 case 0x00:
4111 goto op_semantics_26;
4112 break;
4113 }
4114 break;
4115 case 0x5e:
4116 GETBYTE ();
4117 switch (op[1] & 0x00)
4118 {
4119 case 0x00:
4120 goto op_semantics_26;
4121 break;
4122 }
4123 break;
4124 case 0x5f:
4125 GETBYTE ();
4126 switch (op[1] & 0x00)
4127 {
4128 case 0x00:
4129 goto op_semantics_26;
4130 break;
4131 }
4132 break;
4133 case 0x60:
4134 GETBYTE ();
4135 switch (op[1] & 0x00)
4136 {
4137 case 0x00:
4138 {
4139 /** 0110 0000 immm rdst sub #%2, %0 */
4140 #line 512 "rx-decode.opc"
4141 int immm AU = (op[1] >> 4) & 0x0f;
4142 #line 512 "rx-decode.opc"
4143 int rdst AU = op[1] & 0x0f;
4144 if (trace)
4145 {
4146 printf ("\033[33m%s\033[0m %02x %02x\n",
4147 "/** 0110 0000 immm rdst sub #%2, %0 */",
4148 op[0], op[1]);
4149 printf (" immm = 0x%x,", immm);
4150 printf (" rdst = 0x%x\n", rdst);
4151 }
4152 SYNTAX("sub #%2, %0");
4153 #line 512 "rx-decode.opc"
4154 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4155
4156 }
4157 break;
4158 }
4159 break;
4160 case 0x61:
4161 GETBYTE ();
4162 switch (op[1] & 0x00)
4163 {
4164 case 0x00:
4165 {
4166 /** 0110 0001 immm rdst cmp #%2, %1 */
4167 #line 494 "rx-decode.opc"
4168 int immm AU = (op[1] >> 4) & 0x0f;
4169 #line 494 "rx-decode.opc"
4170 int rdst AU = op[1] & 0x0f;
4171 if (trace)
4172 {
4173 printf ("\033[33m%s\033[0m %02x %02x\n",
4174 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4175 op[0], op[1]);
4176 printf (" immm = 0x%x,", immm);
4177 printf (" rdst = 0x%x\n", rdst);
4178 }
4179 SYNTAX("cmp #%2, %1");
4180 #line 494 "rx-decode.opc"
4181 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4182
4183 }
4184 break;
4185 }
4186 break;
4187 case 0x62:
4188 GETBYTE ();
4189 switch (op[1] & 0x00)
4190 {
4191 case 0x00:
4192 {
4193 /** 0110 0010 immm rdst add #%1, %0 */
4194 #line 476 "rx-decode.opc"
4195 int immm AU = (op[1] >> 4) & 0x0f;
4196 #line 476 "rx-decode.opc"
4197 int rdst AU = op[1] & 0x0f;
4198 if (trace)
4199 {
4200 printf ("\033[33m%s\033[0m %02x %02x\n",
4201 "/** 0110 0010 immm rdst add #%1, %0 */",
4202 op[0], op[1]);
4203 printf (" immm = 0x%x,", immm);
4204 printf (" rdst = 0x%x\n", rdst);
4205 }
4206 SYNTAX("add #%1, %0");
4207 #line 476 "rx-decode.opc"
4208 ID(add); SC(immm); DR(rdst); F_OSZC;
4209
4210 }
4211 break;
4212 }
4213 break;
4214 case 0x63:
4215 GETBYTE ();
4216 switch (op[1] & 0x00)
4217 {
4218 case 0x00:
4219 {
4220 /** 0110 0011 immm rdst mul #%1, %0 */
4221 #line 578 "rx-decode.opc"
4222 int immm AU = (op[1] >> 4) & 0x0f;
4223 #line 578 "rx-decode.opc"
4224 int rdst AU = op[1] & 0x0f;
4225 if (trace)
4226 {
4227 printf ("\033[33m%s\033[0m %02x %02x\n",
4228 "/** 0110 0011 immm rdst mul #%1, %0 */",
4229 op[0], op[1]);
4230 printf (" immm = 0x%x,", immm);
4231 printf (" rdst = 0x%x\n", rdst);
4232 }
4233 SYNTAX("mul #%1, %0");
4234 #line 578 "rx-decode.opc"
4235 ID(mul); DR(rdst); SC(immm); F_____;
4236
4237 }
4238 break;
4239 }
4240 break;
4241 case 0x64:
4242 GETBYTE ();
4243 switch (op[1] & 0x00)
4244 {
4245 case 0x00:
4246 {
4247 /** 0110 0100 immm rdst and #%1, %0 */
4248 #line 386 "rx-decode.opc"
4249 int immm AU = (op[1] >> 4) & 0x0f;
4250 #line 386 "rx-decode.opc"
4251 int rdst AU = op[1] & 0x0f;
4252 if (trace)
4253 {
4254 printf ("\033[33m%s\033[0m %02x %02x\n",
4255 "/** 0110 0100 immm rdst and #%1, %0 */",
4256 op[0], op[1]);
4257 printf (" immm = 0x%x,", immm);
4258 printf (" rdst = 0x%x\n", rdst);
4259 }
4260 SYNTAX("and #%1, %0");
4261 #line 386 "rx-decode.opc"
4262 ID(and); SC(immm); DR(rdst); F__SZ_;
4263
4264 }
4265 break;
4266 }
4267 break;
4268 case 0x65:
4269 GETBYTE ();
4270 switch (op[1] & 0x00)
4271 {
4272 case 0x00:
4273 {
4274 /** 0110 0101 immm rdst or #%1, %0 */
4275 #line 404 "rx-decode.opc"
4276 int immm AU = (op[1] >> 4) & 0x0f;
4277 #line 404 "rx-decode.opc"
4278 int rdst AU = op[1] & 0x0f;
4279 if (trace)
4280 {
4281 printf ("\033[33m%s\033[0m %02x %02x\n",
4282 "/** 0110 0101 immm rdst or #%1, %0 */",
4283 op[0], op[1]);
4284 printf (" immm = 0x%x,", immm);
4285 printf (" rdst = 0x%x\n", rdst);
4286 }
4287 SYNTAX("or #%1, %0");
4288 #line 404 "rx-decode.opc"
4289 ID(or); SC(immm); DR(rdst); F__SZ_;
4290
4291 }
4292 break;
4293 }
4294 break;
4295 case 0x66:
4296 GETBYTE ();
4297 switch (op[1] & 0x00)
4298 {
4299 case 0x00:
4300 {
4301 /** 0110 0110 immm rdst mov%s #%1, %0 */
4302 #line 280 "rx-decode.opc"
4303 int immm AU = (op[1] >> 4) & 0x0f;
4304 #line 280 "rx-decode.opc"
4305 int rdst AU = op[1] & 0x0f;
4306 if (trace)
4307 {
4308 printf ("\033[33m%s\033[0m %02x %02x\n",
4309 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4310 op[0], op[1]);
4311 printf (" immm = 0x%x,", immm);
4312 printf (" rdst = 0x%x\n", rdst);
4313 }
4314 SYNTAX("mov%s #%1, %0");
4315 #line 280 "rx-decode.opc"
4316 ID(mov); DR(rdst); SC(immm); F_____;
4317
4318 }
4319 break;
4320 }
4321 break;
4322 case 0x67:
4323 {
4324 /** 0110 0111 rtsd #%1 */
4325 if (trace)
4326 {
4327 printf ("\033[33m%s\033[0m %02x\n",
4328 "/** 0110 0111 rtsd #%1 */",
4329 op[0]);
4330 }
4331 SYNTAX("rtsd #%1");
4332 #line 377 "rx-decode.opc"
4333 ID(rtsd); SC(IMM(1) * 4);
4334
4335 }
4336 break;
4337 case 0x68:
4338 GETBYTE ();
4339 switch (op[1] & 0x00)
4340 {
4341 case 0x00:
4342 op_semantics_27:
4343 {
4344 /** 0110 100i mmmm rdst shlr #%2, %0 */
4345 #line 664 "rx-decode.opc"
4346 int i AU = op[0] & 0x01;
4347 #line 664 "rx-decode.opc"
4348 int mmmm AU = (op[1] >> 4) & 0x0f;
4349 #line 664 "rx-decode.opc"
4350 int rdst AU = op[1] & 0x0f;
4351 if (trace)
4352 {
4353 printf ("\033[33m%s\033[0m %02x %02x\n",
4354 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4355 op[0], op[1]);
4356 printf (" i = 0x%x,", i);
4357 printf (" mmmm = 0x%x,", mmmm);
4358 printf (" rdst = 0x%x\n", rdst);
4359 }
4360 SYNTAX("shlr #%2, %0");
4361 #line 664 "rx-decode.opc"
4362 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4363
4364 }
4365 break;
4366 }
4367 break;
4368 case 0x69:
4369 GETBYTE ();
4370 switch (op[1] & 0x00)
4371 {
4372 case 0x00:
4373 goto op_semantics_27;
4374 break;
4375 }
4376 break;
4377 case 0x6a:
4378 GETBYTE ();
4379 switch (op[1] & 0x00)
4380 {
4381 case 0x00:
4382 op_semantics_28:
4383 {
4384 /** 0110 101i mmmm rdst shar #%2, %0 */
4385 #line 654 "rx-decode.opc"
4386 int i AU = op[0] & 0x01;
4387 #line 654 "rx-decode.opc"
4388 int mmmm AU = (op[1] >> 4) & 0x0f;
4389 #line 654 "rx-decode.opc"
4390 int rdst AU = op[1] & 0x0f;
4391 if (trace)
4392 {
4393 printf ("\033[33m%s\033[0m %02x %02x\n",
4394 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4395 op[0], op[1]);
4396 printf (" i = 0x%x,", i);
4397 printf (" mmmm = 0x%x,", mmmm);
4398 printf (" rdst = 0x%x\n", rdst);
4399 }
4400 SYNTAX("shar #%2, %0");
4401 #line 654 "rx-decode.opc"
4402 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4403
4404 }
4405 break;
4406 }
4407 break;
4408 case 0x6b:
4409 GETBYTE ();
4410 switch (op[1] & 0x00)
4411 {
4412 case 0x00:
4413 goto op_semantics_28;
4414 break;
4415 }
4416 break;
4417 case 0x6c:
4418 GETBYTE ();
4419 switch (op[1] & 0x00)
4420 {
4421 case 0x00:
4422 op_semantics_29:
4423 {
4424 /** 0110 110i mmmm rdst shll #%2, %0 */
4425 #line 644 "rx-decode.opc"
4426 int i AU = op[0] & 0x01;
4427 #line 644 "rx-decode.opc"
4428 int mmmm AU = (op[1] >> 4) & 0x0f;
4429 #line 644 "rx-decode.opc"
4430 int rdst AU = op[1] & 0x0f;
4431 if (trace)
4432 {
4433 printf ("\033[33m%s\033[0m %02x %02x\n",
4434 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4435 op[0], op[1]);
4436 printf (" i = 0x%x,", i);
4437 printf (" mmmm = 0x%x,", mmmm);
4438 printf (" rdst = 0x%x\n", rdst);
4439 }
4440 SYNTAX("shll #%2, %0");
4441 #line 644 "rx-decode.opc"
4442 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4443
4444 }
4445 break;
4446 }
4447 break;
4448 case 0x6d:
4449 GETBYTE ();
4450 switch (op[1] & 0x00)
4451 {
4452 case 0x00:
4453 goto op_semantics_29;
4454 break;
4455 }
4456 break;
4457 case 0x6e:
4458 GETBYTE ();
4459 switch (op[1] & 0x00)
4460 {
4461 case 0x00:
4462 {
4463 /** 0110 1110 dsta dstb pushm %1-%2 */
4464 #line 344 "rx-decode.opc"
4465 int dsta AU = (op[1] >> 4) & 0x0f;
4466 #line 344 "rx-decode.opc"
4467 int dstb AU = op[1] & 0x0f;
4468 if (trace)
4469 {
4470 printf ("\033[33m%s\033[0m %02x %02x\n",
4471 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4472 op[0], op[1]);
4473 printf (" dsta = 0x%x,", dsta);
4474 printf (" dstb = 0x%x\n", dstb);
4475 }
4476 SYNTAX("pushm %1-%2");
4477 #line 344 "rx-decode.opc"
4478 ID(pushm); SR(dsta); S2R(dstb); F_____;
4479
4480 }
4481 break;
4482 }
4483 break;
4484 case 0x6f:
4485 GETBYTE ();
4486 switch (op[1] & 0x00)
4487 {
4488 case 0x00:
4489 {
4490 /** 0110 1111 dsta dstb popm %1-%2 */
4491 #line 341 "rx-decode.opc"
4492 int dsta AU = (op[1] >> 4) & 0x0f;
4493 #line 341 "rx-decode.opc"
4494 int dstb AU = op[1] & 0x0f;
4495 if (trace)
4496 {
4497 printf ("\033[33m%s\033[0m %02x %02x\n",
4498 "/** 0110 1111 dsta dstb popm %1-%2 */",
4499 op[0], op[1]);
4500 printf (" dsta = 0x%x,", dsta);
4501 printf (" dstb = 0x%x\n", dstb);
4502 }
4503 SYNTAX("popm %1-%2");
4504 #line 341 "rx-decode.opc"
4505 ID(popm); SR(dsta); S2R(dstb); F_____;
4506
4507 }
4508 break;
4509 }
4510 break;
4511 case 0x70:
4512 GETBYTE ();
4513 switch (op[1] & 0x00)
4514 {
4515 case 0x00:
4516 op_semantics_30:
4517 {
4518 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4519 #line 485 "rx-decode.opc"
4520 int im AU = op[0] & 0x03;
4521 #line 485 "rx-decode.opc"
4522 int rsrc AU = (op[1] >> 4) & 0x0f;
4523 #line 485 "rx-decode.opc"
4524 int rdst AU = op[1] & 0x0f;
4525 if (trace)
4526 {
4527 printf ("\033[33m%s\033[0m %02x %02x\n",
4528 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4529 op[0], op[1]);
4530 printf (" im = 0x%x,", im);
4531 printf (" rsrc = 0x%x,", rsrc);
4532 printf (" rdst = 0x%x\n", rdst);
4533 }
4534 SYNTAX("add #%1, %2, %0");
4535 #line 485 "rx-decode.opc"
4536 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4537
4538 }
4539 break;
4540 }
4541 break;
4542 case 0x71:
4543 GETBYTE ();
4544 switch (op[1] & 0x00)
4545 {
4546 case 0x00:
4547 goto op_semantics_30;
4548 break;
4549 }
4550 break;
4551 case 0x72:
4552 GETBYTE ();
4553 switch (op[1] & 0x00)
4554 {
4555 case 0x00:
4556 goto op_semantics_30;
4557 break;
4558 }
4559 break;
4560 case 0x73:
4561 GETBYTE ();
4562 switch (op[1] & 0x00)
4563 {
4564 case 0x00:
4565 goto op_semantics_30;
4566 break;
4567 }
4568 break;
4569 case 0x74:
4570 GETBYTE ();
4571 switch (op[1] & 0xf0)
4572 {
4573 case 0x00:
4574 op_semantics_31:
4575 {
4576 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4577 #line 497 "rx-decode.opc"
4578 int im AU = op[0] & 0x03;
4579 #line 497 "rx-decode.opc"
4580 int rsrc AU = op[1] & 0x0f;
4581 if (trace)
4582 {
4583 printf ("\033[33m%s\033[0m %02x %02x\n",
4584 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4585 op[0], op[1]);
4586 printf (" im = 0x%x,", im);
4587 printf (" rsrc = 0x%x\n", rsrc);
4588 }
4589 SYNTAX("cmp #%2, %1%S1");
4590 #line 497 "rx-decode.opc"
4591 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4592
4593 }
4594 break;
4595 case 0x10:
4596 op_semantics_32:
4597 {
4598 /** 0111 01im 0001rdst mul #%1, %0 */
4599 #line 581 "rx-decode.opc"
4600 int im AU = op[0] & 0x03;
4601 #line 581 "rx-decode.opc"
4602 int rdst AU = op[1] & 0x0f;
4603 if (trace)
4604 {
4605 printf ("\033[33m%s\033[0m %02x %02x\n",
4606 "/** 0111 01im 0001rdst mul #%1, %0 */",
4607 op[0], op[1]);
4608 printf (" im = 0x%x,", im);
4609 printf (" rdst = 0x%x\n", rdst);
4610 }
4611 SYNTAX("mul #%1, %0");
4612 #line 581 "rx-decode.opc"
4613 ID(mul); DR(rdst); SC(IMMex(im)); F_____;
4614
4615 }
4616 break;
4617 case 0x20:
4618 op_semantics_33:
4619 {
4620 /** 0111 01im 0010 rdst and #%1, %0 */
4621 #line 389 "rx-decode.opc"
4622 int im AU = op[0] & 0x03;
4623 #line 389 "rx-decode.opc"
4624 int rdst AU = op[1] & 0x0f;
4625 if (trace)
4626 {
4627 printf ("\033[33m%s\033[0m %02x %02x\n",
4628 "/** 0111 01im 0010 rdst and #%1, %0 */",
4629 op[0], op[1]);
4630 printf (" im = 0x%x,", im);
4631 printf (" rdst = 0x%x\n", rdst);
4632 }
4633 SYNTAX("and #%1, %0");
4634 #line 389 "rx-decode.opc"
4635 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4636
4637 }
4638 break;
4639 case 0x30:
4640 op_semantics_34:
4641 {
4642 /** 0111 01im 0011 rdst or #%1, %0 */
4643 #line 407 "rx-decode.opc"
4644 int im AU = op[0] & 0x03;
4645 #line 407 "rx-decode.opc"
4646 int rdst AU = op[1] & 0x0f;
4647 if (trace)
4648 {
4649 printf ("\033[33m%s\033[0m %02x %02x\n",
4650 "/** 0111 01im 0011 rdst or #%1, %0 */",
4651 op[0], op[1]);
4652 printf (" im = 0x%x,", im);
4653 printf (" rdst = 0x%x\n", rdst);
4654 }
4655 SYNTAX("or #%1, %0");
4656 #line 407 "rx-decode.opc"
4657 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4658
4659 }
4660 break;
4661 default: UNSUPPORTED(); break;
4662 }
4663 break;
4664 case 0x75:
4665 GETBYTE ();
4666 switch (op[1] & 0xff)
4667 {
4668 case 0x00:
4669 case 0x01:
4670 case 0x02:
4671 case 0x03:
4672 case 0x04:
4673 case 0x05:
4674 case 0x06:
4675 case 0x07:
4676 case 0x08:
4677 case 0x09:
4678 case 0x0a:
4679 case 0x0b:
4680 case 0x0c:
4681 case 0x0d:
4682 case 0x0e:
4683 case 0x0f:
4684 goto op_semantics_31;
4685 break;
4686 case 0x10:
4687 case 0x11:
4688 case 0x12:
4689 case 0x13:
4690 case 0x14:
4691 case 0x15:
4692 case 0x16:
4693 case 0x17:
4694 case 0x18:
4695 case 0x19:
4696 case 0x1a:
4697 case 0x1b:
4698 case 0x1c:
4699 case 0x1d:
4700 case 0x1e:
4701 case 0x1f:
4702 goto op_semantics_32;
4703 break;
4704 case 0x20:
4705 case 0x21:
4706 case 0x22:
4707 case 0x23:
4708 case 0x24:
4709 case 0x25:
4710 case 0x26:
4711 case 0x27:
4712 case 0x28:
4713 case 0x29:
4714 case 0x2a:
4715 case 0x2b:
4716 case 0x2c:
4717 case 0x2d:
4718 case 0x2e:
4719 case 0x2f:
4720 goto op_semantics_33;
4721 break;
4722 case 0x30:
4723 case 0x31:
4724 case 0x32:
4725 case 0x33:
4726 case 0x34:
4727 case 0x35:
4728 case 0x36:
4729 case 0x37:
4730 case 0x38:
4731 case 0x39:
4732 case 0x3a:
4733 case 0x3b:
4734 case 0x3c:
4735 case 0x3d:
4736 case 0x3e:
4737 case 0x3f:
4738 goto op_semantics_34;
4739 break;
4740 case 0x40:
4741 case 0x41:
4742 case 0x42:
4743 case 0x43:
4744 case 0x44:
4745 case 0x45:
4746 case 0x46:
4747 case 0x47:
4748 case 0x48:
4749 case 0x49:
4750 case 0x4a:
4751 case 0x4b:
4752 case 0x4c:
4753 case 0x4d:
4754 case 0x4e:
4755 case 0x4f:
4756 {
4757 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4758 #line 261 "rx-decode.opc"
4759 int rdst AU = op[1] & 0x0f;
4760 if (trace)
4761 {
4762 printf ("\033[33m%s\033[0m %02x %02x\n",
4763 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4764 op[0], op[1]);
4765 printf (" rdst = 0x%x\n", rdst);
4766 }
4767 SYNTAX("mov%s #%1, %0");
4768 #line 261 "rx-decode.opc"
4769 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4770
4771 }
4772 break;
4773 case 0x50:
4774 case 0x51:
4775 case 0x52:
4776 case 0x53:
4777 case 0x54:
4778 case 0x55:
4779 case 0x56:
4780 case 0x57:
4781 case 0x58:
4782 case 0x59:
4783 case 0x5a:
4784 case 0x5b:
4785 case 0x5c:
4786 case 0x5d:
4787 case 0x5e:
4788 case 0x5f:
4789 {
4790 /** 0111 0101 0101 rsrc cmp #%2, %1 */
4791 #line 500 "rx-decode.opc"
4792 int rsrc AU = op[1] & 0x0f;
4793 if (trace)
4794 {
4795 printf ("\033[33m%s\033[0m %02x %02x\n",
4796 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4797 op[0], op[1]);
4798 printf (" rsrc = 0x%x\n", rsrc);
4799 }
4800 SYNTAX("cmp #%2, %1");
4801 #line 500 "rx-decode.opc"
4802 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
4803
4804 }
4805 break;
4806 case 0x60:
4807 {
4808 /** 0111 0101 0110 0000 int #%1 */
4809 if (trace)
4810 {
4811 printf ("\033[33m%s\033[0m %02x %02x\n",
4812 "/** 0111 0101 0110 0000 int #%1 */",
4813 op[0], op[1]);
4814 }
4815 SYNTAX("int #%1");
4816 #line 961 "rx-decode.opc"
4817 ID(int); SC(IMM(1));
4818
4819 }
4820 break;
4821 case 0x70:
4822 GETBYTE ();
4823 switch (op[2] & 0xf0)
4824 {
4825 case 0x00:
4826 {
4827 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
4828 #line 928 "rx-decode.opc"
4829 int immm AU = op[2] & 0x0f;
4830 if (trace)
4831 {
4832 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4833 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
4834 op[0], op[1], op[2]);
4835 printf (" immm = 0x%x\n", immm);
4836 }
4837 SYNTAX("mvtipl #%1");
4838 #line 928 "rx-decode.opc"
4839 ID(mvtipl); SC(immm);
4840
4841 }
4842 break;
4843 default: UNSUPPORTED(); break;
4844 }
4845 break;
4846 default: UNSUPPORTED(); break;
4847 }
4848 break;
4849 case 0x76:
4850 GETBYTE ();
4851 switch (op[1] & 0xf0)
4852 {
4853 case 0x00:
4854 goto op_semantics_31;
4855 break;
4856 case 0x10:
4857 goto op_semantics_32;
4858 break;
4859 case 0x20:
4860 goto op_semantics_33;
4861 break;
4862 case 0x30:
4863 goto op_semantics_34;
4864 break;
4865 default: UNSUPPORTED(); break;
4866 }
4867 break;
4868 case 0x77:
4869 GETBYTE ();
4870 switch (op[1] & 0xf0)
4871 {
4872 case 0x00:
4873 goto op_semantics_31;
4874 break;
4875 case 0x10:
4876 goto op_semantics_32;
4877 break;
4878 case 0x20:
4879 goto op_semantics_33;
4880 break;
4881 case 0x30:
4882 goto op_semantics_34;
4883 break;
4884 default: UNSUPPORTED(); break;
4885 }
4886 break;
4887 case 0x78:
4888 GETBYTE ();
4889 switch (op[1] & 0x00)
4890 {
4891 case 0x00:
4892 op_semantics_35:
4893 {
4894 /** 0111 100b ittt rdst bset #%1, %0 */
4895 #line 879 "rx-decode.opc"
4896 int b AU = op[0] & 0x01;
4897 #line 879 "rx-decode.opc"
4898 int ittt AU = (op[1] >> 4) & 0x0f;
4899 #line 879 "rx-decode.opc"
4900 int rdst AU = op[1] & 0x0f;
4901 if (trace)
4902 {
4903 printf ("\033[33m%s\033[0m %02x %02x\n",
4904 "/** 0111 100b ittt rdst bset #%1, %0 */",
4905 op[0], op[1]);
4906 printf (" b = 0x%x,", b);
4907 printf (" ittt = 0x%x,", ittt);
4908 printf (" rdst = 0x%x\n", rdst);
4909 }
4910 SYNTAX("bset #%1, %0");
4911 #line 879 "rx-decode.opc"
4912 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4913
4914
4915 }
4916 break;
4917 }
4918 break;
4919 case 0x79:
4920 GETBYTE ();
4921 switch (op[1] & 0x00)
4922 {
4923 case 0x00:
4924 goto op_semantics_35;
4925 break;
4926 }
4927 break;
4928 case 0x7a:
4929 GETBYTE ();
4930 switch (op[1] & 0x00)
4931 {
4932 case 0x00:
4933 op_semantics_36:
4934 {
4935 /** 0111 101b ittt rdst bclr #%1, %0 */
4936 #line 889 "rx-decode.opc"
4937 int b AU = op[0] & 0x01;
4938 #line 889 "rx-decode.opc"
4939 int ittt AU = (op[1] >> 4) & 0x0f;
4940 #line 889 "rx-decode.opc"
4941 int rdst AU = op[1] & 0x0f;
4942 if (trace)
4943 {
4944 printf ("\033[33m%s\033[0m %02x %02x\n",
4945 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4946 op[0], op[1]);
4947 printf (" b = 0x%x,", b);
4948 printf (" ittt = 0x%x,", ittt);
4949 printf (" rdst = 0x%x\n", rdst);
4950 }
4951 SYNTAX("bclr #%1, %0");
4952 #line 889 "rx-decode.opc"
4953 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4954
4955
4956 }
4957 break;
4958 }
4959 break;
4960 case 0x7b:
4961 GETBYTE ();
4962 switch (op[1] & 0x00)
4963 {
4964 case 0x00:
4965 goto op_semantics_36;
4966 break;
4967 }
4968 break;
4969 case 0x7c:
4970 GETBYTE ();
4971 switch (op[1] & 0x00)
4972 {
4973 case 0x00:
4974 op_semantics_37:
4975 {
4976 /** 0111 110b ittt rdst btst #%2, %1 */
4977 #line 899 "rx-decode.opc"
4978 int b AU = op[0] & 0x01;
4979 #line 899 "rx-decode.opc"
4980 int ittt AU = (op[1] >> 4) & 0x0f;
4981 #line 899 "rx-decode.opc"
4982 int rdst AU = op[1] & 0x0f;
4983 if (trace)
4984 {
4985 printf ("\033[33m%s\033[0m %02x %02x\n",
4986 "/** 0111 110b ittt rdst btst #%2, %1 */",
4987 op[0], op[1]);
4988 printf (" b = 0x%x,", b);
4989 printf (" ittt = 0x%x,", ittt);
4990 printf (" rdst = 0x%x\n", rdst);
4991 }
4992 SYNTAX("btst #%2, %1");
4993 #line 899 "rx-decode.opc"
4994 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
4995
4996
4997 }
4998 break;
4999 }
5000 break;
5001 case 0x7d:
5002 GETBYTE ();
5003 switch (op[1] & 0x00)
5004 {
5005 case 0x00:
5006 goto op_semantics_37;
5007 break;
5008 }
5009 break;
5010 case 0x7e:
5011 GETBYTE ();
5012 switch (op[1] & 0xf0)
5013 {
5014 case 0x00:
5015 {
5016 /** 0111 1110 0000 rdst not %0 */
5017 #line 434 "rx-decode.opc"
5018 int rdst AU = op[1] & 0x0f;
5019 if (trace)
5020 {
5021 printf ("\033[33m%s\033[0m %02x %02x\n",
5022 "/** 0111 1110 0000 rdst not %0 */",
5023 op[0], op[1]);
5024 printf (" rdst = 0x%x\n", rdst);
5025 }
5026 SYNTAX("not %0");
5027 #line 434 "rx-decode.opc"
5028 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5029
5030 }
5031 break;
5032 case 0x10:
5033 {
5034 /** 0111 1110 0001 rdst neg %0 */
5035 #line 455 "rx-decode.opc"
5036 int rdst AU = op[1] & 0x0f;
5037 if (trace)
5038 {
5039 printf ("\033[33m%s\033[0m %02x %02x\n",
5040 "/** 0111 1110 0001 rdst neg %0 */",
5041 op[0], op[1]);
5042 printf (" rdst = 0x%x\n", rdst);
5043 }
5044 SYNTAX("neg %0");
5045 #line 455 "rx-decode.opc"
5046 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5047
5048 }
5049 break;
5050 case 0x20:
5051 {
5052 /** 0111 1110 0010 rdst abs %0 */
5053 #line 537 "rx-decode.opc"
5054 int rdst AU = op[1] & 0x0f;
5055 if (trace)
5056 {
5057 printf ("\033[33m%s\033[0m %02x %02x\n",
5058 "/** 0111 1110 0010 rdst abs %0 */",
5059 op[0], op[1]);
5060 printf (" rdst = 0x%x\n", rdst);
5061 }
5062 SYNTAX("abs %0");
5063 #line 537 "rx-decode.opc"
5064 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5065
5066 }
5067 break;
5068 case 0x30:
5069 {
5070 /** 0111 1110 0011 rdst sat %0 */
5071 #line 819 "rx-decode.opc"
5072 int rdst AU = op[1] & 0x0f;
5073 if (trace)
5074 {
5075 printf ("\033[33m%s\033[0m %02x %02x\n",
5076 "/** 0111 1110 0011 rdst sat %0 */",
5077 op[0], op[1]);
5078 printf (" rdst = 0x%x\n", rdst);
5079 }
5080 SYNTAX("sat %0");
5081 #line 819 "rx-decode.opc"
5082 ID(sat); DR (rdst);
5083
5084 }
5085 break;
5086 case 0x40:
5087 {
5088 /** 0111 1110 0100 rdst rorc %0 */
5089 #line 679 "rx-decode.opc"
5090 int rdst AU = op[1] & 0x0f;
5091 if (trace)
5092 {
5093 printf ("\033[33m%s\033[0m %02x %02x\n",
5094 "/** 0111 1110 0100 rdst rorc %0 */",
5095 op[0], op[1]);
5096 printf (" rdst = 0x%x\n", rdst);
5097 }
5098 SYNTAX("rorc %0");
5099 #line 679 "rx-decode.opc"
5100 ID(rorc); DR(rdst); F__SZC;
5101
5102 }
5103 break;
5104 case 0x50:
5105 {
5106 /** 0111 1110 0101 rdst rolc %0 */
5107 #line 676 "rx-decode.opc"
5108 int rdst AU = op[1] & 0x0f;
5109 if (trace)
5110 {
5111 printf ("\033[33m%s\033[0m %02x %02x\n",
5112 "/** 0111 1110 0101 rdst rolc %0 */",
5113 op[0], op[1]);
5114 printf (" rdst = 0x%x\n", rdst);
5115 }
5116 SYNTAX("rolc %0");
5117 #line 676 "rx-decode.opc"
5118 ID(rolc); DR(rdst); F__SZC;
5119
5120 }
5121 break;
5122 case 0x80:
5123 case 0x90:
5124 case 0xa0:
5125 {
5126 /** 0111 1110 10sz rsrc push%s %1 */
5127 #line 350 "rx-decode.opc"
5128 int sz AU = (op[1] >> 4) & 0x03;
5129 #line 350 "rx-decode.opc"
5130 int rsrc AU = op[1] & 0x0f;
5131 if (trace)
5132 {
5133 printf ("\033[33m%s\033[0m %02x %02x\n",
5134 "/** 0111 1110 10sz rsrc push%s %1 */",
5135 op[0], op[1]);
5136 printf (" sz = 0x%x,", sz);
5137 printf (" rsrc = 0x%x\n", rsrc);
5138 }
5139 SYNTAX("push%s %1");
5140 #line 350 "rx-decode.opc"
5141 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5142
5143 }
5144 break;
5145 case 0xb0:
5146 {
5147 /** 0111 1110 1011 rdst pop %0 */
5148 #line 347 "rx-decode.opc"
5149 int rdst AU = op[1] & 0x0f;
5150 if (trace)
5151 {
5152 printf ("\033[33m%s\033[0m %02x %02x\n",
5153 "/** 0111 1110 1011 rdst pop %0 */",
5154 op[0], op[1]);
5155 printf (" rdst = 0x%x\n", rdst);
5156 }
5157 SYNTAX("pop %0");
5158 #line 347 "rx-decode.opc"
5159 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5160
5161 }
5162 break;
5163 case 0xc0:
5164 case 0xd0:
5165 {
5166 /** 0111 1110 110 crsrc pushc %1 */
5167 #line 934 "rx-decode.opc"
5168 int crsrc AU = op[1] & 0x1f;
5169 if (trace)
5170 {
5171 printf ("\033[33m%s\033[0m %02x %02x\n",
5172 "/** 0111 1110 110 crsrc pushc %1 */",
5173 op[0], op[1]);
5174 printf (" crsrc = 0x%x\n", crsrc);
5175 }
5176 SYNTAX("pushc %1");
5177 #line 934 "rx-decode.opc"
5178 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5179
5180 }
5181 break;
5182 case 0xe0:
5183 case 0xf0:
5184 {
5185 /** 0111 1110 111 crdst popc %0 */
5186 #line 931 "rx-decode.opc"
5187 int crdst AU = op[1] & 0x1f;
5188 if (trace)
5189 {
5190 printf ("\033[33m%s\033[0m %02x %02x\n",
5191 "/** 0111 1110 111 crdst popc %0 */",
5192 op[0], op[1]);
5193 printf (" crdst = 0x%x\n", crdst);
5194 }
5195 SYNTAX("popc %0");
5196 #line 931 "rx-decode.opc"
5197 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5198
5199 }
5200 break;
5201 default: UNSUPPORTED(); break;
5202 }
5203 break;
5204 case 0x7f:
5205 GETBYTE ();
5206 switch (op[1] & 0xff)
5207 {
5208 case 0x00:
5209 case 0x01:
5210 case 0x02:
5211 case 0x03:
5212 case 0x04:
5213 case 0x05:
5214 case 0x06:
5215 case 0x07:
5216 case 0x08:
5217 case 0x09:
5218 case 0x0a:
5219 case 0x0b:
5220 case 0x0c:
5221 case 0x0d:
5222 case 0x0e:
5223 case 0x0f:
5224 {
5225 /** 0111 1111 0000 rsrc jmp %0 */
5226 #line 729 "rx-decode.opc"
5227 int rsrc AU = op[1] & 0x0f;
5228 if (trace)
5229 {
5230 printf ("\033[33m%s\033[0m %02x %02x\n",
5231 "/** 0111 1111 0000 rsrc jmp %0 */",
5232 op[0], op[1]);
5233 printf (" rsrc = 0x%x\n", rsrc);
5234 }
5235 SYNTAX("jmp %0");
5236 #line 729 "rx-decode.opc"
5237 ID(branch); DR(rsrc);
5238
5239 }
5240 break;
5241 case 0x10:
5242 case 0x11:
5243 case 0x12:
5244 case 0x13:
5245 case 0x14:
5246 case 0x15:
5247 case 0x16:
5248 case 0x17:
5249 case 0x18:
5250 case 0x19:
5251 case 0x1a:
5252 case 0x1b:
5253 case 0x1c:
5254 case 0x1d:
5255 case 0x1e:
5256 case 0x1f:
5257 {
5258 /** 0111 1111 0001 rsrc jsr %0 */
5259 #line 732 "rx-decode.opc"
5260 int rsrc AU = op[1] & 0x0f;
5261 if (trace)
5262 {
5263 printf ("\033[33m%s\033[0m %02x %02x\n",
5264 "/** 0111 1111 0001 rsrc jsr %0 */",
5265 op[0], op[1]);
5266 printf (" rsrc = 0x%x\n", rsrc);
5267 }
5268 SYNTAX("jsr %0");
5269 #line 732 "rx-decode.opc"
5270 ID(jsr); DR(rsrc);
5271
5272 }
5273 break;
5274 case 0x40:
5275 case 0x41:
5276 case 0x42:
5277 case 0x43:
5278 case 0x44:
5279 case 0x45:
5280 case 0x46:
5281 case 0x47:
5282 case 0x48:
5283 case 0x49:
5284 case 0x4a:
5285 case 0x4b:
5286 case 0x4c:
5287 case 0x4d:
5288 case 0x4e:
5289 case 0x4f:
5290 {
5291 /** 0111 1111 0100 rsrc bra.l %0 */
5292 #line 725 "rx-decode.opc"
5293 int rsrc AU = op[1] & 0x0f;
5294 if (trace)
5295 {
5296 printf ("\033[33m%s\033[0m %02x %02x\n",
5297 "/** 0111 1111 0100 rsrc bra.l %0 */",
5298 op[0], op[1]);
5299 printf (" rsrc = 0x%x\n", rsrc);
5300 }
5301 SYNTAX("bra.l %0");
5302 #line 725 "rx-decode.opc"
5303 ID(branchrel); DR(rsrc);
5304
5305
5306 }
5307 break;
5308 case 0x50:
5309 case 0x51:
5310 case 0x52:
5311 case 0x53:
5312 case 0x54:
5313 case 0x55:
5314 case 0x56:
5315 case 0x57:
5316 case 0x58:
5317 case 0x59:
5318 case 0x5a:
5319 case 0x5b:
5320 case 0x5c:
5321 case 0x5d:
5322 case 0x5e:
5323 case 0x5f:
5324 {
5325 /** 0111 1111 0101 rsrc bsr.l %0 */
5326 #line 741 "rx-decode.opc"
5327 int rsrc AU = op[1] & 0x0f;
5328 if (trace)
5329 {
5330 printf ("\033[33m%s\033[0m %02x %02x\n",
5331 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5332 op[0], op[1]);
5333 printf (" rsrc = 0x%x\n", rsrc);
5334 }
5335 SYNTAX("bsr.l %0");
5336 #line 741 "rx-decode.opc"
5337 ID(jsrrel); DR(rsrc);
5338
5339 }
5340 break;
5341 case 0x80:
5342 case 0x81:
5343 case 0x82:
5344 {
5345 /** 0111 1111 1000 00sz suntil%s */
5346 #line 765 "rx-decode.opc"
5347 int sz AU = op[1] & 0x03;
5348 if (trace)
5349 {
5350 printf ("\033[33m%s\033[0m %02x %02x\n",
5351 "/** 0111 1111 1000 00sz suntil%s */",
5352 op[0], op[1]);
5353 printf (" sz = 0x%x\n", sz);
5354 }
5355 SYNTAX("suntil%s");
5356 #line 765 "rx-decode.opc"
5357 ID(suntil); BWL(sz); F___ZC;
5358
5359 }
5360 break;
5361 case 0x83:
5362 {
5363 /** 0111 1111 1000 0011 scmpu */
5364 if (trace)
5365 {
5366 printf ("\033[33m%s\033[0m %02x %02x\n",
5367 "/** 0111 1111 1000 0011 scmpu */",
5368 op[0], op[1]);
5369 }
5370 SYNTAX("scmpu");
5371 #line 756 "rx-decode.opc"
5372 ID(scmpu); F___ZC;
5373
5374 }
5375 break;
5376 case 0x84:
5377 case 0x85:
5378 case 0x86:
5379 {
5380 /** 0111 1111 1000 01sz swhile%s */
5381 #line 768 "rx-decode.opc"
5382 int sz AU = op[1] & 0x03;
5383 if (trace)
5384 {
5385 printf ("\033[33m%s\033[0m %02x %02x\n",
5386 "/** 0111 1111 1000 01sz swhile%s */",
5387 op[0], op[1]);
5388 printf (" sz = 0x%x\n", sz);
5389 }
5390 SYNTAX("swhile%s");
5391 #line 768 "rx-decode.opc"
5392 ID(swhile); BWL(sz); F___ZC;
5393
5394 }
5395 break;
5396 case 0x87:
5397 {
5398 /** 0111 1111 1000 0111 smovu */
5399 if (trace)
5400 {
5401 printf ("\033[33m%s\033[0m %02x %02x\n",
5402 "/** 0111 1111 1000 0111 smovu */",
5403 op[0], op[1]);
5404 }
5405 SYNTAX("smovu");
5406 #line 759 "rx-decode.opc"
5407 ID(smovu);
5408
5409 }
5410 break;
5411 case 0x88:
5412 case 0x89:
5413 case 0x8a:
5414 {
5415 /** 0111 1111 1000 10sz sstr%s */
5416 #line 774 "rx-decode.opc"
5417 int sz AU = op[1] & 0x03;
5418 if (trace)
5419 {
5420 printf ("\033[33m%s\033[0m %02x %02x\n",
5421 "/** 0111 1111 1000 10sz sstr%s */",
5422 op[0], op[1]);
5423 printf (" sz = 0x%x\n", sz);
5424 }
5425 SYNTAX("sstr%s");
5426 #line 774 "rx-decode.opc"
5427 ID(sstr); BWL(sz);
5428
5429 /*----------------------------------------------------------------------*/
5430 /* RMPA */
5431
5432 }
5433 break;
5434 case 0x8b:
5435 {
5436 /** 0111 1111 1000 1011 smovb */
5437 if (trace)
5438 {
5439 printf ("\033[33m%s\033[0m %02x %02x\n",
5440 "/** 0111 1111 1000 1011 smovb */",
5441 op[0], op[1]);
5442 }
5443 SYNTAX("smovb");
5444 #line 762 "rx-decode.opc"
5445 ID(smovb);
5446
5447 }
5448 break;
5449 case 0x8c:
5450 case 0x8d:
5451 case 0x8e:
5452 {
5453 /** 0111 1111 1000 11sz rmpa%s */
5454 #line 780 "rx-decode.opc"
5455 int sz AU = op[1] & 0x03;
5456 if (trace)
5457 {
5458 printf ("\033[33m%s\033[0m %02x %02x\n",
5459 "/** 0111 1111 1000 11sz rmpa%s */",
5460 op[0], op[1]);
5461 printf (" sz = 0x%x\n", sz);
5462 }
5463 SYNTAX("rmpa%s");
5464 #line 780 "rx-decode.opc"
5465 ID(rmpa); BWL(sz); F_OS__;
5466
5467 /*----------------------------------------------------------------------*/
5468 /* HI/LO stuff */
5469
5470 }
5471 break;
5472 case 0x8f:
5473 {
5474 /** 0111 1111 1000 1111 smovf */
5475 if (trace)
5476 {
5477 printf ("\033[33m%s\033[0m %02x %02x\n",
5478 "/** 0111 1111 1000 1111 smovf */",
5479 op[0], op[1]);
5480 }
5481 SYNTAX("smovf");
5482 #line 771 "rx-decode.opc"
5483 ID(smovf);
5484
5485 }
5486 break;
5487 case 0x93:
5488 {
5489 /** 0111 1111 1001 0011 satr */
5490 if (trace)
5491 {
5492 printf ("\033[33m%s\033[0m %02x %02x\n",
5493 "/** 0111 1111 1001 0011 satr */",
5494 op[0], op[1]);
5495 }
5496 SYNTAX("satr");
5497 #line 822 "rx-decode.opc"
5498 ID(satr);
5499
5500 /*----------------------------------------------------------------------*/
5501 /* FLOAT */
5502
5503 }
5504 break;
5505 case 0x94:
5506 {
5507 /** 0111 1111 1001 0100 rtfi */
5508 if (trace)
5509 {
5510 printf ("\033[33m%s\033[0m %02x %02x\n",
5511 "/** 0111 1111 1001 0100 rtfi */",
5512 op[0], op[1]);
5513 }
5514 SYNTAX("rtfi");
5515 #line 949 "rx-decode.opc"
5516 ID(rtfi);
5517
5518 }
5519 break;
5520 case 0x95:
5521 {
5522 /** 0111 1111 1001 0101 rte */
5523 if (trace)
5524 {
5525 printf ("\033[33m%s\033[0m %02x %02x\n",
5526 "/** 0111 1111 1001 0101 rte */",
5527 op[0], op[1]);
5528 }
5529 SYNTAX("rte");
5530 #line 952 "rx-decode.opc"
5531 ID(rte);
5532
5533 }
5534 break;
5535 case 0x96:
5536 {
5537 /** 0111 1111 1001 0110 wait */
5538 if (trace)
5539 {
5540 printf ("\033[33m%s\033[0m %02x %02x\n",
5541 "/** 0111 1111 1001 0110 wait */",
5542 op[0], op[1]);
5543 }
5544 SYNTAX("wait");
5545 #line 964 "rx-decode.opc"
5546 ID(wait);
5547
5548 /*----------------------------------------------------------------------*/
5549 /* SCcnd */
5550
5551 }
5552 break;
5553 case 0xa0:
5554 case 0xa1:
5555 case 0xa2:
5556 case 0xa3:
5557 case 0xa4:
5558 case 0xa5:
5559 case 0xa6:
5560 case 0xa7:
5561 case 0xa8:
5562 case 0xa9:
5563 case 0xaa:
5564 case 0xab:
5565 case 0xac:
5566 case 0xad:
5567 case 0xae:
5568 case 0xaf:
5569 {
5570 /** 0111 1111 1010 rdst setpsw %0 */
5571 #line 925 "rx-decode.opc"
5572 int rdst AU = op[1] & 0x0f;
5573 if (trace)
5574 {
5575 printf ("\033[33m%s\033[0m %02x %02x\n",
5576 "/** 0111 1111 1010 rdst setpsw %0 */",
5577 op[0], op[1]);
5578 printf (" rdst = 0x%x\n", rdst);
5579 }
5580 SYNTAX("setpsw %0");
5581 #line 925 "rx-decode.opc"
5582 ID(setpsw); DF(rdst);
5583
5584 }
5585 break;
5586 case 0xb0:
5587 case 0xb1:
5588 case 0xb2:
5589 case 0xb3:
5590 case 0xb4:
5591 case 0xb5:
5592 case 0xb6:
5593 case 0xb7:
5594 case 0xb8:
5595 case 0xb9:
5596 case 0xba:
5597 case 0xbb:
5598 case 0xbc:
5599 case 0xbd:
5600 case 0xbe:
5601 case 0xbf:
5602 {
5603 /** 0111 1111 1011 rdst clrpsw %0 */
5604 #line 922 "rx-decode.opc"
5605 int rdst AU = op[1] & 0x0f;
5606 if (trace)
5607 {
5608 printf ("\033[33m%s\033[0m %02x %02x\n",
5609 "/** 0111 1111 1011 rdst clrpsw %0 */",
5610 op[0], op[1]);
5611 printf (" rdst = 0x%x\n", rdst);
5612 }
5613 SYNTAX("clrpsw %0");
5614 #line 922 "rx-decode.opc"
5615 ID(clrpsw); DF(rdst);
5616
5617 }
5618 break;
5619 default: UNSUPPORTED(); break;
5620 }
5621 break;
5622 case 0x80:
5623 GETBYTE ();
5624 switch (op[1] & 0x00)
5625 {
5626 case 0x00:
5627 op_semantics_38:
5628 {
5629 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5630 #line 308 "rx-decode.opc"
5631 int sz AU = (op[0] >> 4) & 0x03;
5632 #line 308 "rx-decode.opc"
5633 int dsp AU = op[0] & 0x07;
5634 #line 308 "rx-decode.opc"
5635 int a AU = (op[1] >> 7) & 0x01;
5636 #line 308 "rx-decode.opc"
5637 int dst AU = (op[1] >> 4) & 0x07;
5638 #line 308 "rx-decode.opc"
5639 int b AU = (op[1] >> 3) & 0x01;
5640 #line 308 "rx-decode.opc"
5641 int src AU = op[1] & 0x07;
5642 if (trace)
5643 {
5644 printf ("\033[33m%s\033[0m %02x %02x\n",
5645 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5646 op[0], op[1]);
5647 printf (" sz = 0x%x,", sz);
5648 printf (" dsp = 0x%x,", dsp);
5649 printf (" a = 0x%x,", a);
5650 printf (" dst = 0x%x,", dst);
5651 printf (" b = 0x%x,", b);
5652 printf (" src = 0x%x\n", src);
5653 }
5654 SYNTAX("mov%s %1, %0");
5655 #line 308 "rx-decode.opc"
5656 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5657
5658 }
5659 break;
5660 }
5661 break;
5662 case 0x81:
5663 GETBYTE ();
5664 switch (op[1] & 0x00)
5665 {
5666 case 0x00:
5667 goto op_semantics_38;
5668 break;
5669 }
5670 break;
5671 case 0x82:
5672 GETBYTE ();
5673 switch (op[1] & 0x00)
5674 {
5675 case 0x00:
5676 goto op_semantics_38;
5677 break;
5678 }
5679 break;
5680 case 0x83:
5681 GETBYTE ();
5682 switch (op[1] & 0x00)
5683 {
5684 case 0x00:
5685 goto op_semantics_38;
5686 break;
5687 }
5688 break;
5689 case 0x84:
5690 GETBYTE ();
5691 switch (op[1] & 0x00)
5692 {
5693 case 0x00:
5694 goto op_semantics_38;
5695 break;
5696 }
5697 break;
5698 case 0x85:
5699 GETBYTE ();
5700 switch (op[1] & 0x00)
5701 {
5702 case 0x00:
5703 goto op_semantics_38;
5704 break;
5705 }
5706 break;
5707 case 0x86:
5708 GETBYTE ();
5709 switch (op[1] & 0x00)
5710 {
5711 case 0x00:
5712 goto op_semantics_38;
5713 break;
5714 }
5715 break;
5716 case 0x87:
5717 GETBYTE ();
5718 switch (op[1] & 0x00)
5719 {
5720 case 0x00:
5721 goto op_semantics_38;
5722 break;
5723 }
5724 break;
5725 case 0x88:
5726 GETBYTE ();
5727 switch (op[1] & 0x00)
5728 {
5729 case 0x00:
5730 op_semantics_39:
5731 {
5732 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5733 #line 305 "rx-decode.opc"
5734 int sz AU = (op[0] >> 4) & 0x03;
5735 #line 305 "rx-decode.opc"
5736 int dsp AU = op[0] & 0x07;
5737 #line 305 "rx-decode.opc"
5738 int a AU = (op[1] >> 7) & 0x01;
5739 #line 305 "rx-decode.opc"
5740 int src AU = (op[1] >> 4) & 0x07;
5741 #line 305 "rx-decode.opc"
5742 int b AU = (op[1] >> 3) & 0x01;
5743 #line 305 "rx-decode.opc"
5744 int dst AU = op[1] & 0x07;
5745 if (trace)
5746 {
5747 printf ("\033[33m%s\033[0m %02x %02x\n",
5748 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5749 op[0], op[1]);
5750 printf (" sz = 0x%x,", sz);
5751 printf (" dsp = 0x%x,", dsp);
5752 printf (" a = 0x%x,", a);
5753 printf (" src = 0x%x,", src);
5754 printf (" b = 0x%x,", b);
5755 printf (" dst = 0x%x\n", dst);
5756 }
5757 SYNTAX("mov%s %1, %0");
5758 #line 305 "rx-decode.opc"
5759 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5760
5761 }
5762 break;
5763 }
5764 break;
5765 case 0x89:
5766 GETBYTE ();
5767 switch (op[1] & 0x00)
5768 {
5769 case 0x00:
5770 goto op_semantics_39;
5771 break;
5772 }
5773 break;
5774 case 0x8a:
5775 GETBYTE ();
5776 switch (op[1] & 0x00)
5777 {
5778 case 0x00:
5779 goto op_semantics_39;
5780 break;
5781 }
5782 break;
5783 case 0x8b:
5784 GETBYTE ();
5785 switch (op[1] & 0x00)
5786 {
5787 case 0x00:
5788 goto op_semantics_39;
5789 break;
5790 }
5791 break;
5792 case 0x8c:
5793 GETBYTE ();
5794 switch (op[1] & 0x00)
5795 {
5796 case 0x00:
5797 goto op_semantics_39;
5798 break;
5799 }
5800 break;
5801 case 0x8d:
5802 GETBYTE ();
5803 switch (op[1] & 0x00)
5804 {
5805 case 0x00:
5806 goto op_semantics_39;
5807 break;
5808 }
5809 break;
5810 case 0x8e:
5811 GETBYTE ();
5812 switch (op[1] & 0x00)
5813 {
5814 case 0x00:
5815 goto op_semantics_39;
5816 break;
5817 }
5818 break;
5819 case 0x8f:
5820 GETBYTE ();
5821 switch (op[1] & 0x00)
5822 {
5823 case 0x00:
5824 goto op_semantics_39;
5825 break;
5826 }
5827 break;
5828 case 0x90:
5829 GETBYTE ();
5830 switch (op[1] & 0x00)
5831 {
5832 case 0x00:
5833 goto op_semantics_38;
5834 break;
5835 }
5836 break;
5837 case 0x91:
5838 GETBYTE ();
5839 switch (op[1] & 0x00)
5840 {
5841 case 0x00:
5842 goto op_semantics_38;
5843 break;
5844 }
5845 break;
5846 case 0x92:
5847 GETBYTE ();
5848 switch (op[1] & 0x00)
5849 {
5850 case 0x00:
5851 goto op_semantics_38;
5852 break;
5853 }
5854 break;
5855 case 0x93:
5856 GETBYTE ();
5857 switch (op[1] & 0x00)
5858 {
5859 case 0x00:
5860 goto op_semantics_38;
5861 break;
5862 }
5863 break;
5864 case 0x94:
5865 GETBYTE ();
5866 switch (op[1] & 0x00)
5867 {
5868 case 0x00:
5869 goto op_semantics_38;
5870 break;
5871 }
5872 break;
5873 case 0x95:
5874 GETBYTE ();
5875 switch (op[1] & 0x00)
5876 {
5877 case 0x00:
5878 goto op_semantics_38;
5879 break;
5880 }
5881 break;
5882 case 0x96:
5883 GETBYTE ();
5884 switch (op[1] & 0x00)
5885 {
5886 case 0x00:
5887 goto op_semantics_38;
5888 break;
5889 }
5890 break;
5891 case 0x97:
5892 GETBYTE ();
5893 switch (op[1] & 0x00)
5894 {
5895 case 0x00:
5896 goto op_semantics_38;
5897 break;
5898 }
5899 break;
5900 case 0x98:
5901 GETBYTE ();
5902 switch (op[1] & 0x00)
5903 {
5904 case 0x00:
5905 goto op_semantics_39;
5906 break;
5907 }
5908 break;
5909 case 0x99:
5910 GETBYTE ();
5911 switch (op[1] & 0x00)
5912 {
5913 case 0x00:
5914 goto op_semantics_39;
5915 break;
5916 }
5917 break;
5918 case 0x9a:
5919 GETBYTE ();
5920 switch (op[1] & 0x00)
5921 {
5922 case 0x00:
5923 goto op_semantics_39;
5924 break;
5925 }
5926 break;
5927 case 0x9b:
5928 GETBYTE ();
5929 switch (op[1] & 0x00)
5930 {
5931 case 0x00:
5932 goto op_semantics_39;
5933 break;
5934 }
5935 break;
5936 case 0x9c:
5937 GETBYTE ();
5938 switch (op[1] & 0x00)
5939 {
5940 case 0x00:
5941 goto op_semantics_39;
5942 break;
5943 }
5944 break;
5945 case 0x9d:
5946 GETBYTE ();
5947 switch (op[1] & 0x00)
5948 {
5949 case 0x00:
5950 goto op_semantics_39;
5951 break;
5952 }
5953 break;
5954 case 0x9e:
5955 GETBYTE ();
5956 switch (op[1] & 0x00)
5957 {
5958 case 0x00:
5959 goto op_semantics_39;
5960 break;
5961 }
5962 break;
5963 case 0x9f:
5964 GETBYTE ();
5965 switch (op[1] & 0x00)
5966 {
5967 case 0x00:
5968 goto op_semantics_39;
5969 break;
5970 }
5971 break;
5972 case 0xa0:
5973 GETBYTE ();
5974 switch (op[1] & 0x00)
5975 {
5976 case 0x00:
5977 goto op_semantics_38;
5978 break;
5979 }
5980 break;
5981 case 0xa1:
5982 GETBYTE ();
5983 switch (op[1] & 0x00)
5984 {
5985 case 0x00:
5986 goto op_semantics_38;
5987 break;
5988 }
5989 break;
5990 case 0xa2:
5991 GETBYTE ();
5992 switch (op[1] & 0x00)
5993 {
5994 case 0x00:
5995 goto op_semantics_38;
5996 break;
5997 }
5998 break;
5999 case 0xa3:
6000 GETBYTE ();
6001 switch (op[1] & 0x00)
6002 {
6003 case 0x00:
6004 goto op_semantics_38;
6005 break;
6006 }
6007 break;
6008 case 0xa4:
6009 GETBYTE ();
6010 switch (op[1] & 0x00)
6011 {
6012 case 0x00:
6013 goto op_semantics_38;
6014 break;
6015 }
6016 break;
6017 case 0xa5:
6018 GETBYTE ();
6019 switch (op[1] & 0x00)
6020 {
6021 case 0x00:
6022 goto op_semantics_38;
6023 break;
6024 }
6025 break;
6026 case 0xa6:
6027 GETBYTE ();
6028 switch (op[1] & 0x00)
6029 {
6030 case 0x00:
6031 goto op_semantics_38;
6032 break;
6033 }
6034 break;
6035 case 0xa7:
6036 GETBYTE ();
6037 switch (op[1] & 0x00)
6038 {
6039 case 0x00:
6040 goto op_semantics_38;
6041 break;
6042 }
6043 break;
6044 case 0xa8:
6045 GETBYTE ();
6046 switch (op[1] & 0x00)
6047 {
6048 case 0x00:
6049 goto op_semantics_39;
6050 break;
6051 }
6052 break;
6053 case 0xa9:
6054 GETBYTE ();
6055 switch (op[1] & 0x00)
6056 {
6057 case 0x00:
6058 goto op_semantics_39;
6059 break;
6060 }
6061 break;
6062 case 0xaa:
6063 GETBYTE ();
6064 switch (op[1] & 0x00)
6065 {
6066 case 0x00:
6067 goto op_semantics_39;
6068 break;
6069 }
6070 break;
6071 case 0xab:
6072 GETBYTE ();
6073 switch (op[1] & 0x00)
6074 {
6075 case 0x00:
6076 goto op_semantics_39;
6077 break;
6078 }
6079 break;
6080 case 0xac:
6081 GETBYTE ();
6082 switch (op[1] & 0x00)
6083 {
6084 case 0x00:
6085 goto op_semantics_39;
6086 break;
6087 }
6088 break;
6089 case 0xad:
6090 GETBYTE ();
6091 switch (op[1] & 0x00)
6092 {
6093 case 0x00:
6094 goto op_semantics_39;
6095 break;
6096 }
6097 break;
6098 case 0xae:
6099 GETBYTE ();
6100 switch (op[1] & 0x00)
6101 {
6102 case 0x00:
6103 goto op_semantics_39;
6104 break;
6105 }
6106 break;
6107 case 0xaf:
6108 GETBYTE ();
6109 switch (op[1] & 0x00)
6110 {
6111 case 0x00:
6112 goto op_semantics_39;
6113 break;
6114 }
6115 break;
6116 case 0xb0:
6117 GETBYTE ();
6118 switch (op[1] & 0x00)
6119 {
6120 case 0x00:
6121 op_semantics_40:
6122 {
6123 /** 1011 w dsp a src b dst movu%s %1, %0 */
6124 #line 328 "rx-decode.opc"
6125 int w AU = (op[0] >> 3) & 0x01;
6126 #line 328 "rx-decode.opc"
6127 int dsp AU = op[0] & 0x07;
6128 #line 328 "rx-decode.opc"
6129 int a AU = (op[1] >> 7) & 0x01;
6130 #line 328 "rx-decode.opc"
6131 int src AU = (op[1] >> 4) & 0x07;
6132 #line 328 "rx-decode.opc"
6133 int b AU = (op[1] >> 3) & 0x01;
6134 #line 328 "rx-decode.opc"
6135 int dst AU = op[1] & 0x07;
6136 if (trace)
6137 {
6138 printf ("\033[33m%s\033[0m %02x %02x\n",
6139 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6140 op[0], op[1]);
6141 printf (" w = 0x%x,", w);
6142 printf (" dsp = 0x%x,", dsp);
6143 printf (" a = 0x%x,", a);
6144 printf (" src = 0x%x,", src);
6145 printf (" b = 0x%x,", b);
6146 printf (" dst = 0x%x\n", dst);
6147 }
6148 SYNTAX("movu%s %1, %0");
6149 #line 328 "rx-decode.opc"
6150 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6151
6152 }
6153 break;
6154 }
6155 break;
6156 case 0xb1:
6157 GETBYTE ();
6158 switch (op[1] & 0x00)
6159 {
6160 case 0x00:
6161 goto op_semantics_40;
6162 break;
6163 }
6164 break;
6165 case 0xb2:
6166 GETBYTE ();
6167 switch (op[1] & 0x00)
6168 {
6169 case 0x00:
6170 goto op_semantics_40;
6171 break;
6172 }
6173 break;
6174 case 0xb3:
6175 GETBYTE ();
6176 switch (op[1] & 0x00)
6177 {
6178 case 0x00:
6179 goto op_semantics_40;
6180 break;
6181 }
6182 break;
6183 case 0xb4:
6184 GETBYTE ();
6185 switch (op[1] & 0x00)
6186 {
6187 case 0x00:
6188 goto op_semantics_40;
6189 break;
6190 }
6191 break;
6192 case 0xb5:
6193 GETBYTE ();
6194 switch (op[1] & 0x00)
6195 {
6196 case 0x00:
6197 goto op_semantics_40;
6198 break;
6199 }
6200 break;
6201 case 0xb6:
6202 GETBYTE ();
6203 switch (op[1] & 0x00)
6204 {
6205 case 0x00:
6206 goto op_semantics_40;
6207 break;
6208 }
6209 break;
6210 case 0xb7:
6211 GETBYTE ();
6212 switch (op[1] & 0x00)
6213 {
6214 case 0x00:
6215 goto op_semantics_40;
6216 break;
6217 }
6218 break;
6219 case 0xb8:
6220 GETBYTE ();
6221 switch (op[1] & 0x00)
6222 {
6223 case 0x00:
6224 goto op_semantics_40;
6225 break;
6226 }
6227 break;
6228 case 0xb9:
6229 GETBYTE ();
6230 switch (op[1] & 0x00)
6231 {
6232 case 0x00:
6233 goto op_semantics_40;
6234 break;
6235 }
6236 break;
6237 case 0xba:
6238 GETBYTE ();
6239 switch (op[1] & 0x00)
6240 {
6241 case 0x00:
6242 goto op_semantics_40;
6243 break;
6244 }
6245 break;
6246 case 0xbb:
6247 GETBYTE ();
6248 switch (op[1] & 0x00)
6249 {
6250 case 0x00:
6251 goto op_semantics_40;
6252 break;
6253 }
6254 break;
6255 case 0xbc:
6256 GETBYTE ();
6257 switch (op[1] & 0x00)
6258 {
6259 case 0x00:
6260 goto op_semantics_40;
6261 break;
6262 }
6263 break;
6264 case 0xbd:
6265 GETBYTE ();
6266 switch (op[1] & 0x00)
6267 {
6268 case 0x00:
6269 goto op_semantics_40;
6270 break;
6271 }
6272 break;
6273 case 0xbe:
6274 GETBYTE ();
6275 switch (op[1] & 0x00)
6276 {
6277 case 0x00:
6278 goto op_semantics_40;
6279 break;
6280 }
6281 break;
6282 case 0xbf:
6283 GETBYTE ();
6284 switch (op[1] & 0x00)
6285 {
6286 case 0x00:
6287 goto op_semantics_40;
6288 break;
6289 }
6290 break;
6291 case 0xc0:
6292 GETBYTE ();
6293 switch (op[1] & 0x00)
6294 {
6295 case 0x00:
6296 op_semantics_41:
6297 {
6298 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6299 #line 286 "rx-decode.opc"
6300 int sz AU = (op[0] >> 4) & 0x03;
6301 #line 286 "rx-decode.opc"
6302 int sd AU = (op[0] >> 2) & 0x03;
6303 #line 286 "rx-decode.opc"
6304 int ss AU = op[0] & 0x03;
6305 #line 286 "rx-decode.opc"
6306 int rsrc AU = (op[1] >> 4) & 0x0f;
6307 #line 286 "rx-decode.opc"
6308 int rdst AU = op[1] & 0x0f;
6309 if (trace)
6310 {
6311 printf ("\033[33m%s\033[0m %02x %02x\n",
6312 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6313 op[0], op[1]);
6314 printf (" sz = 0x%x,", sz);
6315 printf (" sd = 0x%x,", sd);
6316 printf (" ss = 0x%x,", ss);
6317 printf (" rsrc = 0x%x,", rsrc);
6318 printf (" rdst = 0x%x\n", rdst);
6319 }
6320 SYNTAX("mov%s %1, %0");
6321 #line 286 "rx-decode.opc"
6322 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6323 {
6324 ID(nop2);
6325 rx->syntax = "nop";
6326 }
6327 else
6328 {
6329 ID(mov); sBWL(sz); F_____;
6330 if ((ss == 3) && (sd != 3))
6331 {
6332 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6333 }
6334 else
6335 {
6336 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6337 }
6338 }
6339
6340 }
6341 break;
6342 }
6343 break;
6344 case 0xc1:
6345 GETBYTE ();
6346 switch (op[1] & 0x00)
6347 {
6348 case 0x00:
6349 goto op_semantics_41;
6350 break;
6351 }
6352 break;
6353 case 0xc2:
6354 GETBYTE ();
6355 switch (op[1] & 0x00)
6356 {
6357 case 0x00:
6358 goto op_semantics_41;
6359 break;
6360 }
6361 break;
6362 case 0xc3:
6363 GETBYTE ();
6364 switch (op[1] & 0x00)
6365 {
6366 case 0x00:
6367 goto op_semantics_41;
6368 break;
6369 }
6370 break;
6371 case 0xc4:
6372 GETBYTE ();
6373 switch (op[1] & 0x00)
6374 {
6375 case 0x00:
6376 goto op_semantics_41;
6377 break;
6378 }
6379 break;
6380 case 0xc5:
6381 GETBYTE ();
6382 switch (op[1] & 0x00)
6383 {
6384 case 0x00:
6385 goto op_semantics_41;
6386 break;
6387 }
6388 break;
6389 case 0xc6:
6390 GETBYTE ();
6391 switch (op[1] & 0x00)
6392 {
6393 case 0x00:
6394 goto op_semantics_41;
6395 break;
6396 }
6397 break;
6398 case 0xc7:
6399 GETBYTE ();
6400 switch (op[1] & 0x00)
6401 {
6402 case 0x00:
6403 goto op_semantics_41;
6404 break;
6405 }
6406 break;
6407 case 0xc8:
6408 GETBYTE ();
6409 switch (op[1] & 0x00)
6410 {
6411 case 0x00:
6412 goto op_semantics_41;
6413 break;
6414 }
6415 break;
6416 case 0xc9:
6417 GETBYTE ();
6418 switch (op[1] & 0x00)
6419 {
6420 case 0x00:
6421 goto op_semantics_41;
6422 break;
6423 }
6424 break;
6425 case 0xca:
6426 GETBYTE ();
6427 switch (op[1] & 0x00)
6428 {
6429 case 0x00:
6430 goto op_semantics_41;
6431 break;
6432 }
6433 break;
6434 case 0xcb:
6435 GETBYTE ();
6436 switch (op[1] & 0x00)
6437 {
6438 case 0x00:
6439 goto op_semantics_41;
6440 break;
6441 }
6442 break;
6443 case 0xcc:
6444 GETBYTE ();
6445 switch (op[1] & 0x00)
6446 {
6447 case 0x00:
6448 goto op_semantics_41;
6449 break;
6450 }
6451 break;
6452 case 0xcd:
6453 GETBYTE ();
6454 switch (op[1] & 0x00)
6455 {
6456 case 0x00:
6457 goto op_semantics_41;
6458 break;
6459 }
6460 break;
6461 case 0xce:
6462 GETBYTE ();
6463 switch (op[1] & 0x00)
6464 {
6465 case 0x00:
6466 goto op_semantics_41;
6467 break;
6468 }
6469 break;
6470 case 0xcf:
6471 GETBYTE ();
6472 switch (op[1] & 0x00)
6473 {
6474 case 0x00:
6475 goto op_semantics_41;
6476 break;
6477 }
6478 break;
6479 case 0xd0:
6480 GETBYTE ();
6481 switch (op[1] & 0x00)
6482 {
6483 case 0x00:
6484 goto op_semantics_41;
6485 break;
6486 }
6487 break;
6488 case 0xd1:
6489 GETBYTE ();
6490 switch (op[1] & 0x00)
6491 {
6492 case 0x00:
6493 goto op_semantics_41;
6494 break;
6495 }
6496 break;
6497 case 0xd2:
6498 GETBYTE ();
6499 switch (op[1] & 0x00)
6500 {
6501 case 0x00:
6502 goto op_semantics_41;
6503 break;
6504 }
6505 break;
6506 case 0xd3:
6507 GETBYTE ();
6508 switch (op[1] & 0x00)
6509 {
6510 case 0x00:
6511 goto op_semantics_41;
6512 break;
6513 }
6514 break;
6515 case 0xd4:
6516 GETBYTE ();
6517 switch (op[1] & 0x00)
6518 {
6519 case 0x00:
6520 goto op_semantics_41;
6521 break;
6522 }
6523 break;
6524 case 0xd5:
6525 GETBYTE ();
6526 switch (op[1] & 0x00)
6527 {
6528 case 0x00:
6529 goto op_semantics_41;
6530 break;
6531 }
6532 break;
6533 case 0xd6:
6534 GETBYTE ();
6535 switch (op[1] & 0x00)
6536 {
6537 case 0x00:
6538 goto op_semantics_41;
6539 break;
6540 }
6541 break;
6542 case 0xd7:
6543 GETBYTE ();
6544 switch (op[1] & 0x00)
6545 {
6546 case 0x00:
6547 goto op_semantics_41;
6548 break;
6549 }
6550 break;
6551 case 0xd8:
6552 GETBYTE ();
6553 switch (op[1] & 0x00)
6554 {
6555 case 0x00:
6556 goto op_semantics_41;
6557 break;
6558 }
6559 break;
6560 case 0xd9:
6561 GETBYTE ();
6562 switch (op[1] & 0x00)
6563 {
6564 case 0x00:
6565 goto op_semantics_41;
6566 break;
6567 }
6568 break;
6569 case 0xda:
6570 GETBYTE ();
6571 switch (op[1] & 0x00)
6572 {
6573 case 0x00:
6574 goto op_semantics_41;
6575 break;
6576 }
6577 break;
6578 case 0xdb:
6579 GETBYTE ();
6580 switch (op[1] & 0x00)
6581 {
6582 case 0x00:
6583 goto op_semantics_41;
6584 break;
6585 }
6586 break;
6587 case 0xdc:
6588 GETBYTE ();
6589 switch (op[1] & 0x00)
6590 {
6591 case 0x00:
6592 goto op_semantics_41;
6593 break;
6594 }
6595 break;
6596 case 0xdd:
6597 GETBYTE ();
6598 switch (op[1] & 0x00)
6599 {
6600 case 0x00:
6601 goto op_semantics_41;
6602 break;
6603 }
6604 break;
6605 case 0xde:
6606 GETBYTE ();
6607 switch (op[1] & 0x00)
6608 {
6609 case 0x00:
6610 goto op_semantics_41;
6611 break;
6612 }
6613 break;
6614 case 0xdf:
6615 GETBYTE ();
6616 switch (op[1] & 0x00)
6617 {
6618 case 0x00:
6619 goto op_semantics_41;
6620 break;
6621 }
6622 break;
6623 case 0xe0:
6624 GETBYTE ();
6625 switch (op[1] & 0x00)
6626 {
6627 case 0x00:
6628 goto op_semantics_41;
6629 break;
6630 }
6631 break;
6632 case 0xe1:
6633 GETBYTE ();
6634 switch (op[1] & 0x00)
6635 {
6636 case 0x00:
6637 goto op_semantics_41;
6638 break;
6639 }
6640 break;
6641 case 0xe2:
6642 GETBYTE ();
6643 switch (op[1] & 0x00)
6644 {
6645 case 0x00:
6646 goto op_semantics_41;
6647 break;
6648 }
6649 break;
6650 case 0xe3:
6651 GETBYTE ();
6652 switch (op[1] & 0x00)
6653 {
6654 case 0x00:
6655 goto op_semantics_41;
6656 break;
6657 }
6658 break;
6659 case 0xe4:
6660 GETBYTE ();
6661 switch (op[1] & 0x00)
6662 {
6663 case 0x00:
6664 goto op_semantics_41;
6665 break;
6666 }
6667 break;
6668 case 0xe5:
6669 GETBYTE ();
6670 switch (op[1] & 0x00)
6671 {
6672 case 0x00:
6673 goto op_semantics_41;
6674 break;
6675 }
6676 break;
6677 case 0xe6:
6678 GETBYTE ();
6679 switch (op[1] & 0x00)
6680 {
6681 case 0x00:
6682 goto op_semantics_41;
6683 break;
6684 }
6685 break;
6686 case 0xe7:
6687 GETBYTE ();
6688 switch (op[1] & 0x00)
6689 {
6690 case 0x00:
6691 goto op_semantics_41;
6692 break;
6693 }
6694 break;
6695 case 0xe8:
6696 GETBYTE ();
6697 switch (op[1] & 0x00)
6698 {
6699 case 0x00:
6700 goto op_semantics_41;
6701 break;
6702 }
6703 break;
6704 case 0xe9:
6705 GETBYTE ();
6706 switch (op[1] & 0x00)
6707 {
6708 case 0x00:
6709 goto op_semantics_41;
6710 break;
6711 }
6712 break;
6713 case 0xea:
6714 GETBYTE ();
6715 switch (op[1] & 0x00)
6716 {
6717 case 0x00:
6718 goto op_semantics_41;
6719 break;
6720 }
6721 break;
6722 case 0xeb:
6723 GETBYTE ();
6724 switch (op[1] & 0x00)
6725 {
6726 case 0x00:
6727 goto op_semantics_41;
6728 break;
6729 }
6730 break;
6731 case 0xec:
6732 GETBYTE ();
6733 switch (op[1] & 0x00)
6734 {
6735 case 0x00:
6736 goto op_semantics_41;
6737 break;
6738 }
6739 break;
6740 case 0xed:
6741 GETBYTE ();
6742 switch (op[1] & 0x00)
6743 {
6744 case 0x00:
6745 goto op_semantics_41;
6746 break;
6747 }
6748 break;
6749 case 0xee:
6750 GETBYTE ();
6751 switch (op[1] & 0x00)
6752 {
6753 case 0x00:
6754 goto op_semantics_41;
6755 break;
6756 }
6757 break;
6758 case 0xef:
6759 GETBYTE ();
6760 switch (op[1] & 0x00)
6761 {
6762 case 0x00:
6763 goto op_semantics_41;
6764 break;
6765 }
6766 break;
6767 case 0xf0:
6768 GETBYTE ();
6769 switch (op[1] & 0x08)
6770 {
6771 case 0x00:
6772 op_semantics_42:
6773 {
6774 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
6775 #line 873 "rx-decode.opc"
6776 int sd AU = op[0] & 0x03;
6777 #line 873 "rx-decode.opc"
6778 int rdst AU = (op[1] >> 4) & 0x0f;
6779 #line 873 "rx-decode.opc"
6780 int bit AU = op[1] & 0x07;
6781 if (trace)
6782 {
6783 printf ("\033[33m%s\033[0m %02x %02x\n",
6784 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6785 op[0], op[1]);
6786 printf (" sd = 0x%x,", sd);
6787 printf (" rdst = 0x%x,", rdst);
6788 printf (" bit = 0x%x\n", bit);
6789 }
6790 SYNTAX("bset #%1, %0%S0");
6791 #line 873 "rx-decode.opc"
6792 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6793
6794 }
6795 break;
6796 case 0x08:
6797 op_semantics_43:
6798 {
6799 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
6800 #line 883 "rx-decode.opc"
6801 int sd AU = op[0] & 0x03;
6802 #line 883 "rx-decode.opc"
6803 int rdst AU = (op[1] >> 4) & 0x0f;
6804 #line 883 "rx-decode.opc"
6805 int bit AU = op[1] & 0x07;
6806 if (trace)
6807 {
6808 printf ("\033[33m%s\033[0m %02x %02x\n",
6809 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6810 op[0], op[1]);
6811 printf (" sd = 0x%x,", sd);
6812 printf (" rdst = 0x%x,", rdst);
6813 printf (" bit = 0x%x\n", bit);
6814 }
6815 SYNTAX("bclr #%1, %0%S0");
6816 #line 883 "rx-decode.opc"
6817 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6818
6819 }
6820 break;
6821 }
6822 break;
6823 case 0xf1:
6824 GETBYTE ();
6825 switch (op[1] & 0x08)
6826 {
6827 case 0x00:
6828 goto op_semantics_42;
6829 break;
6830 case 0x08:
6831 goto op_semantics_43;
6832 break;
6833 }
6834 break;
6835 case 0xf2:
6836 GETBYTE ();
6837 switch (op[1] & 0x08)
6838 {
6839 case 0x00:
6840 goto op_semantics_42;
6841 break;
6842 case 0x08:
6843 goto op_semantics_43;
6844 break;
6845 }
6846 break;
6847 case 0xf3:
6848 GETBYTE ();
6849 switch (op[1] & 0x08)
6850 {
6851 case 0x00:
6852 goto op_semantics_42;
6853 break;
6854 case 0x08:
6855 goto op_semantics_43;
6856 break;
6857 }
6858 break;
6859 case 0xf4:
6860 GETBYTE ();
6861 switch (op[1] & 0x0c)
6862 {
6863 case 0x00:
6864 case 0x04:
6865 op_semantics_44:
6866 {
6867 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
6868 #line 893 "rx-decode.opc"
6869 int sd AU = op[0] & 0x03;
6870 #line 893 "rx-decode.opc"
6871 int rdst AU = (op[1] >> 4) & 0x0f;
6872 #line 893 "rx-decode.opc"
6873 int bit AU = op[1] & 0x07;
6874 if (trace)
6875 {
6876 printf ("\033[33m%s\033[0m %02x %02x\n",
6877 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6878 op[0], op[1]);
6879 printf (" sd = 0x%x,", sd);
6880 printf (" rdst = 0x%x,", rdst);
6881 printf (" bit = 0x%x\n", bit);
6882 }
6883 SYNTAX("btst #%2, %1%S1");
6884 #line 893 "rx-decode.opc"
6885 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
6886
6887 }
6888 break;
6889 case 0x08:
6890 op_semantics_45:
6891 {
6892 /** 1111 01ss rsrc 10sz push%s %1 */
6893 #line 353 "rx-decode.opc"
6894 int ss AU = op[0] & 0x03;
6895 #line 353 "rx-decode.opc"
6896 int rsrc AU = (op[1] >> 4) & 0x0f;
6897 #line 353 "rx-decode.opc"
6898 int sz AU = op[1] & 0x03;
6899 if (trace)
6900 {
6901 printf ("\033[33m%s\033[0m %02x %02x\n",
6902 "/** 1111 01ss rsrc 10sz push%s %1 */",
6903 op[0], op[1]);
6904 printf (" ss = 0x%x,", ss);
6905 printf (" rsrc = 0x%x,", rsrc);
6906 printf (" sz = 0x%x\n", sz);
6907 }
6908 SYNTAX("push%s %1");
6909 #line 353 "rx-decode.opc"
6910 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
6911
6912 /*----------------------------------------------------------------------*/
6913 /* XCHG */
6914
6915 }
6916 break;
6917 default: UNSUPPORTED(); break;
6918 }
6919 break;
6920 case 0xf5:
6921 GETBYTE ();
6922 switch (op[1] & 0x0c)
6923 {
6924 case 0x00:
6925 case 0x04:
6926 goto op_semantics_44;
6927 break;
6928 case 0x08:
6929 goto op_semantics_45;
6930 break;
6931 default: UNSUPPORTED(); break;
6932 }
6933 break;
6934 case 0xf6:
6935 GETBYTE ();
6936 switch (op[1] & 0x0c)
6937 {
6938 case 0x00:
6939 case 0x04:
6940 goto op_semantics_44;
6941 break;
6942 case 0x08:
6943 goto op_semantics_45;
6944 break;
6945 default: UNSUPPORTED(); break;
6946 }
6947 break;
6948 case 0xf7:
6949 GETBYTE ();
6950 switch (op[1] & 0x0c)
6951 {
6952 case 0x00:
6953 case 0x04:
6954 goto op_semantics_44;
6955 break;
6956 case 0x08:
6957 goto op_semantics_45;
6958 break;
6959 default: UNSUPPORTED(); break;
6960 }
6961 break;
6962 case 0xf8:
6963 GETBYTE ();
6964 switch (op[1] & 0x00)
6965 {
6966 case 0x00:
6967 op_semantics_46:
6968 {
6969 /** 1111 10sd rdst im sz mov%s #%1, %0 */
6970 #line 264 "rx-decode.opc"
6971 int sd AU = op[0] & 0x03;
6972 #line 264 "rx-decode.opc"
6973 int rdst AU = (op[1] >> 4) & 0x0f;
6974 #line 264 "rx-decode.opc"
6975 int im AU = (op[1] >> 2) & 0x03;
6976 #line 264 "rx-decode.opc"
6977 int sz AU = op[1] & 0x03;
6978 if (trace)
6979 {
6980 printf ("\033[33m%s\033[0m %02x %02x\n",
6981 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
6982 op[0], op[1]);
6983 printf (" sd = 0x%x,", sd);
6984 printf (" rdst = 0x%x,", rdst);
6985 printf (" im = 0x%x,", im);
6986 printf (" sz = 0x%x\n", sz);
6987 }
6988 SYNTAX("mov%s #%1, %0");
6989 #line 264 "rx-decode.opc"
6990 ID(mov); DD(sd, rdst, sz);
6991 if ((im == 1 && sz == 0)
6992 || (im == 2 && sz == 1)
6993 || (im == 0 && sz == 2))
6994 {
6995 BWL (sz);
6996 SC(IMM(im));
6997 }
6998 else
6999 {
7000 sBWL (sz);
7001 SC(IMMex(im));
7002 }
7003 F_____;
7004
7005 }
7006 break;
7007 }
7008 break;
7009 case 0xf9:
7010 GETBYTE ();
7011 switch (op[1] & 0x00)
7012 {
7013 case 0x00:
7014 goto op_semantics_46;
7015 break;
7016 }
7017 break;
7018 case 0xfa:
7019 GETBYTE ();
7020 switch (op[1] & 0x00)
7021 {
7022 case 0x00:
7023 goto op_semantics_46;
7024 break;
7025 }
7026 break;
7027 case 0xfb:
7028 GETBYTE ();
7029 switch (op[1] & 0x00)
7030 {
7031 case 0x00:
7032 goto op_semantics_46;
7033 break;
7034 }
7035 break;
7036 case 0xfc:
7037 GETBYTE ();
7038 switch (op[1] & 0xff)
7039 {
7040 case 0x03:
7041 GETBYTE ();
7042 switch (op[2] & 0x00)
7043 {
7044 case 0x00:
7045 {
7046 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7047 #line 527 "rx-decode.opc"
7048 int rsrc AU = (op[2] >> 4) & 0x0f;
7049 #line 527 "rx-decode.opc"
7050 int rdst AU = op[2] & 0x0f;
7051 if (trace)
7052 {
7053 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7054 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7055 op[0], op[1], op[2]);
7056 printf (" rsrc = 0x%x,", rsrc);
7057 printf (" rdst = 0x%x\n", rdst);
7058 }
7059 SYNTAX("sbb %1, %0");
7060 #line 527 "rx-decode.opc"
7061 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7062
7063 /* FIXME: only supports .L */
7064 }
7065 break;
7066 }
7067 break;
7068 case 0x07:
7069 GETBYTE ();
7070 switch (op[2] & 0x00)
7071 {
7072 case 0x00:
7073 {
7074 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7075 #line 458 "rx-decode.opc"
7076 int rsrc AU = (op[2] >> 4) & 0x0f;
7077 #line 458 "rx-decode.opc"
7078 int rdst AU = op[2] & 0x0f;
7079 if (trace)
7080 {
7081 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7082 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7083 op[0], op[1], op[2]);
7084 printf (" rsrc = 0x%x,", rsrc);
7085 printf (" rdst = 0x%x\n", rdst);
7086 }
7087 SYNTAX("neg %2, %0");
7088 #line 458 "rx-decode.opc"
7089 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7090
7091 /*----------------------------------------------------------------------*/
7092 /* ADC */
7093
7094 }
7095 break;
7096 }
7097 break;
7098 case 0x0b:
7099 GETBYTE ();
7100 switch (op[2] & 0x00)
7101 {
7102 case 0x00:
7103 {
7104 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7105 #line 467 "rx-decode.opc"
7106 int rsrc AU = (op[2] >> 4) & 0x0f;
7107 #line 467 "rx-decode.opc"
7108 int rdst AU = op[2] & 0x0f;
7109 if (trace)
7110 {
7111 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7112 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7113 op[0], op[1], op[2]);
7114 printf (" rsrc = 0x%x,", rsrc);
7115 printf (" rdst = 0x%x\n", rdst);
7116 }
7117 SYNTAX("adc %1, %0");
7118 #line 467 "rx-decode.opc"
7119 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7120
7121 }
7122 break;
7123 }
7124 break;
7125 case 0x0f:
7126 GETBYTE ();
7127 switch (op[2] & 0x00)
7128 {
7129 case 0x00:
7130 {
7131 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7132 #line 540 "rx-decode.opc"
7133 int rsrc AU = (op[2] >> 4) & 0x0f;
7134 #line 540 "rx-decode.opc"
7135 int rdst AU = op[2] & 0x0f;
7136 if (trace)
7137 {
7138 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7139 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7140 op[0], op[1], op[2]);
7141 printf (" rsrc = 0x%x,", rsrc);
7142 printf (" rdst = 0x%x\n", rdst);
7143 }
7144 SYNTAX("abs %1, %0");
7145 #line 540 "rx-decode.opc"
7146 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7147
7148 /*----------------------------------------------------------------------*/
7149 /* MAX */
7150
7151 }
7152 break;
7153 }
7154 break;
7155 case 0x10:
7156 GETBYTE ();
7157 switch (op[2] & 0x00)
7158 {
7159 case 0x00:
7160 op_semantics_47:
7161 {
7162 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7163 #line 549 "rx-decode.opc"
7164 int ss AU = op[1] & 0x03;
7165 #line 549 "rx-decode.opc"
7166 int rsrc AU = (op[2] >> 4) & 0x0f;
7167 #line 549 "rx-decode.opc"
7168 int rdst AU = op[2] & 0x0f;
7169 if (trace)
7170 {
7171 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7172 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7173 op[0], op[1], op[2]);
7174 printf (" ss = 0x%x,", ss);
7175 printf (" rsrc = 0x%x,", rsrc);
7176 printf (" rdst = 0x%x\n", rdst);
7177 }
7178 SYNTAX("max %1%S1, %0");
7179 #line 549 "rx-decode.opc"
7180 if (ss == 3 && rsrc == 0 && rdst == 0)
7181 {
7182 ID(nop3);
7183 rx->syntax = "nop";
7184 }
7185 else
7186 {
7187 ID(max); SP(ss, rsrc); DR(rdst);
7188 }
7189
7190 }
7191 break;
7192 }
7193 break;
7194 case 0x11:
7195 GETBYTE ();
7196 switch (op[2] & 0x00)
7197 {
7198 case 0x00:
7199 goto op_semantics_47;
7200 break;
7201 }
7202 break;
7203 case 0x12:
7204 GETBYTE ();
7205 switch (op[2] & 0x00)
7206 {
7207 case 0x00:
7208 goto op_semantics_47;
7209 break;
7210 }
7211 break;
7212 case 0x13:
7213 GETBYTE ();
7214 switch (op[2] & 0x00)
7215 {
7216 case 0x00:
7217 goto op_semantics_47;
7218 break;
7219 }
7220 break;
7221 case 0x14:
7222 GETBYTE ();
7223 switch (op[2] & 0x00)
7224 {
7225 case 0x00:
7226 op_semantics_48:
7227 {
7228 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7229 #line 569 "rx-decode.opc"
7230 int ss AU = op[1] & 0x03;
7231 #line 569 "rx-decode.opc"
7232 int rsrc AU = (op[2] >> 4) & 0x0f;
7233 #line 569 "rx-decode.opc"
7234 int rdst AU = op[2] & 0x0f;
7235 if (trace)
7236 {
7237 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7238 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7239 op[0], op[1], op[2]);
7240 printf (" ss = 0x%x,", ss);
7241 printf (" rsrc = 0x%x,", rsrc);
7242 printf (" rdst = 0x%x\n", rdst);
7243 }
7244 SYNTAX("min %1%S1, %0");
7245 #line 569 "rx-decode.opc"
7246 ID(min); SP(ss, rsrc); DR(rdst);
7247
7248 }
7249 break;
7250 }
7251 break;
7252 case 0x15:
7253 GETBYTE ();
7254 switch (op[2] & 0x00)
7255 {
7256 case 0x00:
7257 goto op_semantics_48;
7258 break;
7259 }
7260 break;
7261 case 0x16:
7262 GETBYTE ();
7263 switch (op[2] & 0x00)
7264 {
7265 case 0x00:
7266 goto op_semantics_48;
7267 break;
7268 }
7269 break;
7270 case 0x17:
7271 GETBYTE ();
7272 switch (op[2] & 0x00)
7273 {
7274 case 0x00:
7275 goto op_semantics_48;
7276 break;
7277 }
7278 break;
7279 case 0x18:
7280 GETBYTE ();
7281 switch (op[2] & 0x00)
7282 {
7283 case 0x00:
7284 op_semantics_49:
7285 {
7286 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7287 #line 599 "rx-decode.opc"
7288 int ss AU = op[1] & 0x03;
7289 #line 599 "rx-decode.opc"
7290 int rsrc AU = (op[2] >> 4) & 0x0f;
7291 #line 599 "rx-decode.opc"
7292 int rdst AU = op[2] & 0x0f;
7293 if (trace)
7294 {
7295 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7296 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7297 op[0], op[1], op[2]);
7298 printf (" ss = 0x%x,", ss);
7299 printf (" rsrc = 0x%x,", rsrc);
7300 printf (" rdst = 0x%x\n", rdst);
7301 }
7302 SYNTAX("emul %1%S1, %0");
7303 #line 599 "rx-decode.opc"
7304 ID(emul); SP(ss, rsrc); DR(rdst);
7305
7306 }
7307 break;
7308 }
7309 break;
7310 case 0x19:
7311 GETBYTE ();
7312 switch (op[2] & 0x00)
7313 {
7314 case 0x00:
7315 goto op_semantics_49;
7316 break;
7317 }
7318 break;
7319 case 0x1a:
7320 GETBYTE ();
7321 switch (op[2] & 0x00)
7322 {
7323 case 0x00:
7324 goto op_semantics_49;
7325 break;
7326 }
7327 break;
7328 case 0x1b:
7329 GETBYTE ();
7330 switch (op[2] & 0x00)
7331 {
7332 case 0x00:
7333 goto op_semantics_49;
7334 break;
7335 }
7336 break;
7337 case 0x1c:
7338 GETBYTE ();
7339 switch (op[2] & 0x00)
7340 {
7341 case 0x00:
7342 op_semantics_50:
7343 {
7344 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7345 #line 611 "rx-decode.opc"
7346 int ss AU = op[1] & 0x03;
7347 #line 611 "rx-decode.opc"
7348 int rsrc AU = (op[2] >> 4) & 0x0f;
7349 #line 611 "rx-decode.opc"
7350 int rdst AU = op[2] & 0x0f;
7351 if (trace)
7352 {
7353 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7354 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7355 op[0], op[1], op[2]);
7356 printf (" ss = 0x%x,", ss);
7357 printf (" rsrc = 0x%x,", rsrc);
7358 printf (" rdst = 0x%x\n", rdst);
7359 }
7360 SYNTAX("emulu %1%S1, %0");
7361 #line 611 "rx-decode.opc"
7362 ID(emulu); SP(ss, rsrc); DR(rdst);
7363
7364 }
7365 break;
7366 }
7367 break;
7368 case 0x1d:
7369 GETBYTE ();
7370 switch (op[2] & 0x00)
7371 {
7372 case 0x00:
7373 goto op_semantics_50;
7374 break;
7375 }
7376 break;
7377 case 0x1e:
7378 GETBYTE ();
7379 switch (op[2] & 0x00)
7380 {
7381 case 0x00:
7382 goto op_semantics_50;
7383 break;
7384 }
7385 break;
7386 case 0x1f:
7387 GETBYTE ();
7388 switch (op[2] & 0x00)
7389 {
7390 case 0x00:
7391 goto op_semantics_50;
7392 break;
7393 }
7394 break;
7395 case 0x20:
7396 GETBYTE ();
7397 switch (op[2] & 0x00)
7398 {
7399 case 0x00:
7400 op_semantics_51:
7401 {
7402 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7403 #line 623 "rx-decode.opc"
7404 int ss AU = op[1] & 0x03;
7405 #line 623 "rx-decode.opc"
7406 int rsrc AU = (op[2] >> 4) & 0x0f;
7407 #line 623 "rx-decode.opc"
7408 int rdst AU = op[2] & 0x0f;
7409 if (trace)
7410 {
7411 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7412 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7413 op[0], op[1], op[2]);
7414 printf (" ss = 0x%x,", ss);
7415 printf (" rsrc = 0x%x,", rsrc);
7416 printf (" rdst = 0x%x\n", rdst);
7417 }
7418 SYNTAX("div %1%S1, %0");
7419 #line 623 "rx-decode.opc"
7420 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7421
7422 }
7423 break;
7424 }
7425 break;
7426 case 0x21:
7427 GETBYTE ();
7428 switch (op[2] & 0x00)
7429 {
7430 case 0x00:
7431 goto op_semantics_51;
7432 break;
7433 }
7434 break;
7435 case 0x22:
7436 GETBYTE ();
7437 switch (op[2] & 0x00)
7438 {
7439 case 0x00:
7440 goto op_semantics_51;
7441 break;
7442 }
7443 break;
7444 case 0x23:
7445 GETBYTE ();
7446 switch (op[2] & 0x00)
7447 {
7448 case 0x00:
7449 goto op_semantics_51;
7450 break;
7451 }
7452 break;
7453 case 0x24:
7454 GETBYTE ();
7455 switch (op[2] & 0x00)
7456 {
7457 case 0x00:
7458 op_semantics_52:
7459 {
7460 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7461 #line 635 "rx-decode.opc"
7462 int ss AU = op[1] & 0x03;
7463 #line 635 "rx-decode.opc"
7464 int rsrc AU = (op[2] >> 4) & 0x0f;
7465 #line 635 "rx-decode.opc"
7466 int rdst AU = op[2] & 0x0f;
7467 if (trace)
7468 {
7469 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7470 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7471 op[0], op[1], op[2]);
7472 printf (" ss = 0x%x,", ss);
7473 printf (" rsrc = 0x%x,", rsrc);
7474 printf (" rdst = 0x%x\n", rdst);
7475 }
7476 SYNTAX("divu %1%S1, %0");
7477 #line 635 "rx-decode.opc"
7478 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7479
7480 }
7481 break;
7482 }
7483 break;
7484 case 0x25:
7485 GETBYTE ();
7486 switch (op[2] & 0x00)
7487 {
7488 case 0x00:
7489 goto op_semantics_52;
7490 break;
7491 }
7492 break;
7493 case 0x26:
7494 GETBYTE ();
7495 switch (op[2] & 0x00)
7496 {
7497 case 0x00:
7498 goto op_semantics_52;
7499 break;
7500 }
7501 break;
7502 case 0x27:
7503 GETBYTE ();
7504 switch (op[2] & 0x00)
7505 {
7506 case 0x00:
7507 goto op_semantics_52;
7508 break;
7509 }
7510 break;
7511 case 0x30:
7512 GETBYTE ();
7513 switch (op[2] & 0x00)
7514 {
7515 case 0x00:
7516 op_semantics_53:
7517 {
7518 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7519 #line 446 "rx-decode.opc"
7520 int ss AU = op[1] & 0x03;
7521 #line 446 "rx-decode.opc"
7522 int rsrc AU = (op[2] >> 4) & 0x0f;
7523 #line 446 "rx-decode.opc"
7524 int rdst AU = op[2] & 0x0f;
7525 if (trace)
7526 {
7527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7528 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7529 op[0], op[1], op[2]);
7530 printf (" ss = 0x%x,", ss);
7531 printf (" rsrc = 0x%x,", rsrc);
7532 printf (" rdst = 0x%x\n", rdst);
7533 }
7534 SYNTAX("tst %1%S1, %2");
7535 #line 446 "rx-decode.opc"
7536 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7537
7538 }
7539 break;
7540 }
7541 break;
7542 case 0x31:
7543 GETBYTE ();
7544 switch (op[2] & 0x00)
7545 {
7546 case 0x00:
7547 goto op_semantics_53;
7548 break;
7549 }
7550 break;
7551 case 0x32:
7552 GETBYTE ();
7553 switch (op[2] & 0x00)
7554 {
7555 case 0x00:
7556 goto op_semantics_53;
7557 break;
7558 }
7559 break;
7560 case 0x33:
7561 GETBYTE ();
7562 switch (op[2] & 0x00)
7563 {
7564 case 0x00:
7565 goto op_semantics_53;
7566 break;
7567 }
7568 break;
7569 case 0x34:
7570 GETBYTE ();
7571 switch (op[2] & 0x00)
7572 {
7573 case 0x00:
7574 op_semantics_54:
7575 {
7576 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7577 #line 425 "rx-decode.opc"
7578 int ss AU = op[1] & 0x03;
7579 #line 425 "rx-decode.opc"
7580 int rsrc AU = (op[2] >> 4) & 0x0f;
7581 #line 425 "rx-decode.opc"
7582 int rdst AU = op[2] & 0x0f;
7583 if (trace)
7584 {
7585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7586 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7587 op[0], op[1], op[2]);
7588 printf (" ss = 0x%x,", ss);
7589 printf (" rsrc = 0x%x,", rsrc);
7590 printf (" rdst = 0x%x\n", rdst);
7591 }
7592 SYNTAX("xor %1%S1, %0");
7593 #line 425 "rx-decode.opc"
7594 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7595
7596 }
7597 break;
7598 }
7599 break;
7600 case 0x35:
7601 GETBYTE ();
7602 switch (op[2] & 0x00)
7603 {
7604 case 0x00:
7605 goto op_semantics_54;
7606 break;
7607 }
7608 break;
7609 case 0x36:
7610 GETBYTE ();
7611 switch (op[2] & 0x00)
7612 {
7613 case 0x00:
7614 goto op_semantics_54;
7615 break;
7616 }
7617 break;
7618 case 0x37:
7619 GETBYTE ();
7620 switch (op[2] & 0x00)
7621 {
7622 case 0x00:
7623 goto op_semantics_54;
7624 break;
7625 }
7626 break;
7627 case 0x3b:
7628 GETBYTE ();
7629 switch (op[2] & 0x00)
7630 {
7631 case 0x00:
7632 {
7633 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7634 #line 437 "rx-decode.opc"
7635 int rsrc AU = (op[2] >> 4) & 0x0f;
7636 #line 437 "rx-decode.opc"
7637 int rdst AU = op[2] & 0x0f;
7638 if (trace)
7639 {
7640 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7641 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7642 op[0], op[1], op[2]);
7643 printf (" rsrc = 0x%x,", rsrc);
7644 printf (" rdst = 0x%x\n", rdst);
7645 }
7646 SYNTAX("not %1, %0");
7647 #line 437 "rx-decode.opc"
7648 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7649
7650 /*----------------------------------------------------------------------*/
7651 /* TST */
7652
7653 }
7654 break;
7655 }
7656 break;
7657 case 0x40:
7658 GETBYTE ();
7659 switch (op[2] & 0x00)
7660 {
7661 case 0x00:
7662 op_semantics_55:
7663 {
7664 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7665 #line 359 "rx-decode.opc"
7666 int ss AU = op[1] & 0x03;
7667 #line 359 "rx-decode.opc"
7668 int rsrc AU = (op[2] >> 4) & 0x0f;
7669 #line 359 "rx-decode.opc"
7670 int rdst AU = op[2] & 0x0f;
7671 if (trace)
7672 {
7673 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7674 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7675 op[0], op[1], op[2]);
7676 printf (" ss = 0x%x,", ss);
7677 printf (" rsrc = 0x%x,", rsrc);
7678 printf (" rdst = 0x%x\n", rdst);
7679 }
7680 SYNTAX("xchg %1%S1, %0");
7681 #line 359 "rx-decode.opc"
7682 ID(xchg); DR(rdst); SP(ss, rsrc);
7683
7684 }
7685 break;
7686 }
7687 break;
7688 case 0x41:
7689 GETBYTE ();
7690 switch (op[2] & 0x00)
7691 {
7692 case 0x00:
7693 goto op_semantics_55;
7694 break;
7695 }
7696 break;
7697 case 0x42:
7698 GETBYTE ();
7699 switch (op[2] & 0x00)
7700 {
7701 case 0x00:
7702 goto op_semantics_55;
7703 break;
7704 }
7705 break;
7706 case 0x43:
7707 GETBYTE ();
7708 switch (op[2] & 0x00)
7709 {
7710 case 0x00:
7711 goto op_semantics_55;
7712 break;
7713 }
7714 break;
7715 case 0x44:
7716 GETBYTE ();
7717 switch (op[2] & 0x00)
7718 {
7719 case 0x00:
7720 op_semantics_56:
7721 {
7722 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7723 #line 864 "rx-decode.opc"
7724 int sd AU = op[1] & 0x03;
7725 #line 864 "rx-decode.opc"
7726 int rsrc AU = (op[2] >> 4) & 0x0f;
7727 #line 864 "rx-decode.opc"
7728 int rdst AU = op[2] & 0x0f;
7729 if (trace)
7730 {
7731 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7732 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7733 op[0], op[1], op[2]);
7734 printf (" sd = 0x%x,", sd);
7735 printf (" rsrc = 0x%x,", rsrc);
7736 printf (" rdst = 0x%x\n", rdst);
7737 }
7738 SYNTAX("itof %1%S1, %0");
7739 #line 864 "rx-decode.opc"
7740 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7741
7742 }
7743 break;
7744 }
7745 break;
7746 case 0x45:
7747 GETBYTE ();
7748 switch (op[2] & 0x00)
7749 {
7750 case 0x00:
7751 goto op_semantics_56;
7752 break;
7753 }
7754 break;
7755 case 0x46:
7756 GETBYTE ();
7757 switch (op[2] & 0x00)
7758 {
7759 case 0x00:
7760 goto op_semantics_56;
7761 break;
7762 }
7763 break;
7764 case 0x47:
7765 GETBYTE ();
7766 switch (op[2] & 0x00)
7767 {
7768 case 0x00:
7769 goto op_semantics_56;
7770 break;
7771 }
7772 break;
7773 case 0x60:
7774 GETBYTE ();
7775 switch (op[2] & 0x00)
7776 {
7777 case 0x00:
7778 op_semantics_57:
7779 {
7780 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
7781 #line 876 "rx-decode.opc"
7782 int sd AU = op[1] & 0x03;
7783 #line 876 "rx-decode.opc"
7784 int rdst AU = (op[2] >> 4) & 0x0f;
7785 #line 876 "rx-decode.opc"
7786 int rsrc AU = op[2] & 0x0f;
7787 if (trace)
7788 {
7789 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7790 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7791 op[0], op[1], op[2]);
7792 printf (" sd = 0x%x,", sd);
7793 printf (" rdst = 0x%x,", rdst);
7794 printf (" rsrc = 0x%x\n", rsrc);
7795 }
7796 SYNTAX("bset %1, %0%S0");
7797 #line 876 "rx-decode.opc"
7798 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7799
7800 }
7801 break;
7802 }
7803 break;
7804 case 0x61:
7805 GETBYTE ();
7806 switch (op[2] & 0x00)
7807 {
7808 case 0x00:
7809 goto op_semantics_57;
7810 break;
7811 }
7812 break;
7813 case 0x62:
7814 GETBYTE ();
7815 switch (op[2] & 0x00)
7816 {
7817 case 0x00:
7818 goto op_semantics_57;
7819 break;
7820 }
7821 break;
7822 case 0x63:
7823 GETBYTE ();
7824 switch (op[2] & 0x00)
7825 {
7826 case 0x00:
7827 goto op_semantics_57;
7828 break;
7829 }
7830 break;
7831 case 0x64:
7832 GETBYTE ();
7833 switch (op[2] & 0x00)
7834 {
7835 case 0x00:
7836 op_semantics_58:
7837 {
7838 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
7839 #line 886 "rx-decode.opc"
7840 int sd AU = op[1] & 0x03;
7841 #line 886 "rx-decode.opc"
7842 int rdst AU = (op[2] >> 4) & 0x0f;
7843 #line 886 "rx-decode.opc"
7844 int rsrc AU = op[2] & 0x0f;
7845 if (trace)
7846 {
7847 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7848 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7849 op[0], op[1], op[2]);
7850 printf (" sd = 0x%x,", sd);
7851 printf (" rdst = 0x%x,", rdst);
7852 printf (" rsrc = 0x%x\n", rsrc);
7853 }
7854 SYNTAX("bclr %1, %0%S0");
7855 #line 886 "rx-decode.opc"
7856 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7857
7858 }
7859 break;
7860 }
7861 break;
7862 case 0x65:
7863 GETBYTE ();
7864 switch (op[2] & 0x00)
7865 {
7866 case 0x00:
7867 goto op_semantics_58;
7868 break;
7869 }
7870 break;
7871 case 0x66:
7872 GETBYTE ();
7873 switch (op[2] & 0x00)
7874 {
7875 case 0x00:
7876 goto op_semantics_58;
7877 break;
7878 }
7879 break;
7880 case 0x67:
7881 GETBYTE ();
7882 switch (op[2] & 0x00)
7883 {
7884 case 0x00:
7885 goto op_semantics_58;
7886 break;
7887 }
7888 break;
7889 case 0x68:
7890 GETBYTE ();
7891 switch (op[2] & 0x00)
7892 {
7893 case 0x00:
7894 op_semantics_59:
7895 {
7896 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
7897 #line 896 "rx-decode.opc"
7898 int sd AU = op[1] & 0x03;
7899 #line 896 "rx-decode.opc"
7900 int rdst AU = (op[2] >> 4) & 0x0f;
7901 #line 896 "rx-decode.opc"
7902 int rsrc AU = op[2] & 0x0f;
7903 if (trace)
7904 {
7905 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7906 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7907 op[0], op[1], op[2]);
7908 printf (" sd = 0x%x,", sd);
7909 printf (" rdst = 0x%x,", rdst);
7910 printf (" rsrc = 0x%x\n", rsrc);
7911 }
7912 SYNTAX("btst %2, %1%S1");
7913 #line 896 "rx-decode.opc"
7914 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
7915
7916 }
7917 break;
7918 }
7919 break;
7920 case 0x69:
7921 GETBYTE ();
7922 switch (op[2] & 0x00)
7923 {
7924 case 0x00:
7925 goto op_semantics_59;
7926 break;
7927 }
7928 break;
7929 case 0x6a:
7930 GETBYTE ();
7931 switch (op[2] & 0x00)
7932 {
7933 case 0x00:
7934 goto op_semantics_59;
7935 break;
7936 }
7937 break;
7938 case 0x6b:
7939 GETBYTE ();
7940 switch (op[2] & 0x00)
7941 {
7942 case 0x00:
7943 goto op_semantics_59;
7944 break;
7945 }
7946 break;
7947 case 0x6c:
7948 GETBYTE ();
7949 switch (op[2] & 0x00)
7950 {
7951 case 0x00:
7952 op_semantics_60:
7953 {
7954 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
7955 #line 906 "rx-decode.opc"
7956 int sd AU = op[1] & 0x03;
7957 #line 906 "rx-decode.opc"
7958 int rdst AU = (op[2] >> 4) & 0x0f;
7959 #line 906 "rx-decode.opc"
7960 int rsrc AU = op[2] & 0x0f;
7961 if (trace)
7962 {
7963 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7964 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
7965 op[0], op[1], op[2]);
7966 printf (" sd = 0x%x,", sd);
7967 printf (" rdst = 0x%x,", rdst);
7968 printf (" rsrc = 0x%x\n", rsrc);
7969 }
7970 SYNTAX("bnot %1, %0%S0");
7971 #line 906 "rx-decode.opc"
7972 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7973
7974 }
7975 break;
7976 }
7977 break;
7978 case 0x6d:
7979 GETBYTE ();
7980 switch (op[2] & 0x00)
7981 {
7982 case 0x00:
7983 goto op_semantics_60;
7984 break;
7985 }
7986 break;
7987 case 0x6e:
7988 GETBYTE ();
7989 switch (op[2] & 0x00)
7990 {
7991 case 0x00:
7992 goto op_semantics_60;
7993 break;
7994 }
7995 break;
7996 case 0x6f:
7997 GETBYTE ();
7998 switch (op[2] & 0x00)
7999 {
8000 case 0x00:
8001 goto op_semantics_60;
8002 break;
8003 }
8004 break;
8005 case 0x80:
8006 GETBYTE ();
8007 switch (op[2] & 0x00)
8008 {
8009 case 0x00:
8010 op_semantics_61:
8011 {
8012 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8013 #line 843 "rx-decode.opc"
8014 int sd AU = op[1] & 0x03;
8015 #line 843 "rx-decode.opc"
8016 int rsrc AU = (op[2] >> 4) & 0x0f;
8017 #line 843 "rx-decode.opc"
8018 int rdst AU = op[2] & 0x0f;
8019 if (trace)
8020 {
8021 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8022 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8023 op[0], op[1], op[2]);
8024 printf (" sd = 0x%x,", sd);
8025 printf (" rsrc = 0x%x,", rsrc);
8026 printf (" rdst = 0x%x\n", rdst);
8027 }
8028 SYNTAX("fsub %1%S1, %0");
8029 #line 843 "rx-decode.opc"
8030 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8031
8032 }
8033 break;
8034 }
8035 break;
8036 case 0x81:
8037 GETBYTE ();
8038 switch (op[2] & 0x00)
8039 {
8040 case 0x00:
8041 goto op_semantics_61;
8042 break;
8043 }
8044 break;
8045 case 0x82:
8046 GETBYTE ();
8047 switch (op[2] & 0x00)
8048 {
8049 case 0x00:
8050 goto op_semantics_61;
8051 break;
8052 }
8053 break;
8054 case 0x83:
8055 GETBYTE ();
8056 switch (op[2] & 0x00)
8057 {
8058 case 0x00:
8059 goto op_semantics_61;
8060 break;
8061 }
8062 break;
8063 case 0x84:
8064 GETBYTE ();
8065 switch (op[2] & 0x00)
8066 {
8067 case 0x00:
8068 op_semantics_62:
8069 {
8070 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8071 #line 837 "rx-decode.opc"
8072 int sd AU = op[1] & 0x03;
8073 #line 837 "rx-decode.opc"
8074 int rsrc AU = (op[2] >> 4) & 0x0f;
8075 #line 837 "rx-decode.opc"
8076 int rdst AU = op[2] & 0x0f;
8077 if (trace)
8078 {
8079 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8080 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8081 op[0], op[1], op[2]);
8082 printf (" sd = 0x%x,", sd);
8083 printf (" rsrc = 0x%x,", rsrc);
8084 printf (" rdst = 0x%x\n", rdst);
8085 }
8086 SYNTAX("fcmp %1%S1, %0");
8087 #line 837 "rx-decode.opc"
8088 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8089
8090 }
8091 break;
8092 }
8093 break;
8094 case 0x85:
8095 GETBYTE ();
8096 switch (op[2] & 0x00)
8097 {
8098 case 0x00:
8099 goto op_semantics_62;
8100 break;
8101 }
8102 break;
8103 case 0x86:
8104 GETBYTE ();
8105 switch (op[2] & 0x00)
8106 {
8107 case 0x00:
8108 goto op_semantics_62;
8109 break;
8110 }
8111 break;
8112 case 0x87:
8113 GETBYTE ();
8114 switch (op[2] & 0x00)
8115 {
8116 case 0x00:
8117 goto op_semantics_62;
8118 break;
8119 }
8120 break;
8121 case 0x88:
8122 GETBYTE ();
8123 switch (op[2] & 0x00)
8124 {
8125 case 0x00:
8126 op_semantics_63:
8127 {
8128 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8129 #line 831 "rx-decode.opc"
8130 int sd AU = op[1] & 0x03;
8131 #line 831 "rx-decode.opc"
8132 int rsrc AU = (op[2] >> 4) & 0x0f;
8133 #line 831 "rx-decode.opc"
8134 int rdst AU = op[2] & 0x0f;
8135 if (trace)
8136 {
8137 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8138 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8139 op[0], op[1], op[2]);
8140 printf (" sd = 0x%x,", sd);
8141 printf (" rsrc = 0x%x,", rsrc);
8142 printf (" rdst = 0x%x\n", rdst);
8143 }
8144 SYNTAX("fadd %1%S1, %0");
8145 #line 831 "rx-decode.opc"
8146 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8147
8148 }
8149 break;
8150 }
8151 break;
8152 case 0x89:
8153 GETBYTE ();
8154 switch (op[2] & 0x00)
8155 {
8156 case 0x00:
8157 goto op_semantics_63;
8158 break;
8159 }
8160 break;
8161 case 0x8a:
8162 GETBYTE ();
8163 switch (op[2] & 0x00)
8164 {
8165 case 0x00:
8166 goto op_semantics_63;
8167 break;
8168 }
8169 break;
8170 case 0x8b:
8171 GETBYTE ();
8172 switch (op[2] & 0x00)
8173 {
8174 case 0x00:
8175 goto op_semantics_63;
8176 break;
8177 }
8178 break;
8179 case 0x8c:
8180 GETBYTE ();
8181 switch (op[2] & 0x00)
8182 {
8183 case 0x00:
8184 op_semantics_64:
8185 {
8186 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8187 #line 852 "rx-decode.opc"
8188 int sd AU = op[1] & 0x03;
8189 #line 852 "rx-decode.opc"
8190 int rsrc AU = (op[2] >> 4) & 0x0f;
8191 #line 852 "rx-decode.opc"
8192 int rdst AU = op[2] & 0x0f;
8193 if (trace)
8194 {
8195 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8196 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8197 op[0], op[1], op[2]);
8198 printf (" sd = 0x%x,", sd);
8199 printf (" rsrc = 0x%x,", rsrc);
8200 printf (" rdst = 0x%x\n", rdst);
8201 }
8202 SYNTAX("fmul %1%S1, %0");
8203 #line 852 "rx-decode.opc"
8204 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8205
8206 }
8207 break;
8208 }
8209 break;
8210 case 0x8d:
8211 GETBYTE ();
8212 switch (op[2] & 0x00)
8213 {
8214 case 0x00:
8215 goto op_semantics_64;
8216 break;
8217 }
8218 break;
8219 case 0x8e:
8220 GETBYTE ();
8221 switch (op[2] & 0x00)
8222 {
8223 case 0x00:
8224 goto op_semantics_64;
8225 break;
8226 }
8227 break;
8228 case 0x8f:
8229 GETBYTE ();
8230 switch (op[2] & 0x00)
8231 {
8232 case 0x00:
8233 goto op_semantics_64;
8234 break;
8235 }
8236 break;
8237 case 0x90:
8238 GETBYTE ();
8239 switch (op[2] & 0x00)
8240 {
8241 case 0x00:
8242 op_semantics_65:
8243 {
8244 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8245 #line 858 "rx-decode.opc"
8246 int sd AU = op[1] & 0x03;
8247 #line 858 "rx-decode.opc"
8248 int rsrc AU = (op[2] >> 4) & 0x0f;
8249 #line 858 "rx-decode.opc"
8250 int rdst AU = op[2] & 0x0f;
8251 if (trace)
8252 {
8253 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8254 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8255 op[0], op[1], op[2]);
8256 printf (" sd = 0x%x,", sd);
8257 printf (" rsrc = 0x%x,", rsrc);
8258 printf (" rdst = 0x%x\n", rdst);
8259 }
8260 SYNTAX("fdiv %1%S1, %0");
8261 #line 858 "rx-decode.opc"
8262 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8263
8264 }
8265 break;
8266 }
8267 break;
8268 case 0x91:
8269 GETBYTE ();
8270 switch (op[2] & 0x00)
8271 {
8272 case 0x00:
8273 goto op_semantics_65;
8274 break;
8275 }
8276 break;
8277 case 0x92:
8278 GETBYTE ();
8279 switch (op[2] & 0x00)
8280 {
8281 case 0x00:
8282 goto op_semantics_65;
8283 break;
8284 }
8285 break;
8286 case 0x93:
8287 GETBYTE ();
8288 switch (op[2] & 0x00)
8289 {
8290 case 0x00:
8291 goto op_semantics_65;
8292 break;
8293 }
8294 break;
8295 case 0x94:
8296 GETBYTE ();
8297 switch (op[2] & 0x00)
8298 {
8299 case 0x00:
8300 op_semantics_66:
8301 {
8302 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8303 #line 846 "rx-decode.opc"
8304 int sd AU = op[1] & 0x03;
8305 #line 846 "rx-decode.opc"
8306 int rsrc AU = (op[2] >> 4) & 0x0f;
8307 #line 846 "rx-decode.opc"
8308 int rdst AU = op[2] & 0x0f;
8309 if (trace)
8310 {
8311 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8312 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8313 op[0], op[1], op[2]);
8314 printf (" sd = 0x%x,", sd);
8315 printf (" rsrc = 0x%x,", rsrc);
8316 printf (" rdst = 0x%x\n", rdst);
8317 }
8318 SYNTAX("ftoi %1%S1, %0");
8319 #line 846 "rx-decode.opc"
8320 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8321
8322 }
8323 break;
8324 }
8325 break;
8326 case 0x95:
8327 GETBYTE ();
8328 switch (op[2] & 0x00)
8329 {
8330 case 0x00:
8331 goto op_semantics_66;
8332 break;
8333 }
8334 break;
8335 case 0x96:
8336 GETBYTE ();
8337 switch (op[2] & 0x00)
8338 {
8339 case 0x00:
8340 goto op_semantics_66;
8341 break;
8342 }
8343 break;
8344 case 0x97:
8345 GETBYTE ();
8346 switch (op[2] & 0x00)
8347 {
8348 case 0x00:
8349 goto op_semantics_66;
8350 break;
8351 }
8352 break;
8353 case 0x98:
8354 GETBYTE ();
8355 switch (op[2] & 0x00)
8356 {
8357 case 0x00:
8358 op_semantics_67:
8359 {
8360 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8361 #line 861 "rx-decode.opc"
8362 int sd AU = op[1] & 0x03;
8363 #line 861 "rx-decode.opc"
8364 int rsrc AU = (op[2] >> 4) & 0x0f;
8365 #line 861 "rx-decode.opc"
8366 int rdst AU = op[2] & 0x0f;
8367 if (trace)
8368 {
8369 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8370 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8371 op[0], op[1], op[2]);
8372 printf (" sd = 0x%x,", sd);
8373 printf (" rsrc = 0x%x,", rsrc);
8374 printf (" rdst = 0x%x\n", rdst);
8375 }
8376 SYNTAX("round %1%S1, %0");
8377 #line 861 "rx-decode.opc"
8378 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8379
8380 }
8381 break;
8382 }
8383 break;
8384 case 0x99:
8385 GETBYTE ();
8386 switch (op[2] & 0x00)
8387 {
8388 case 0x00:
8389 goto op_semantics_67;
8390 break;
8391 }
8392 break;
8393 case 0x9a:
8394 GETBYTE ();
8395 switch (op[2] & 0x00)
8396 {
8397 case 0x00:
8398 goto op_semantics_67;
8399 break;
8400 }
8401 break;
8402 case 0x9b:
8403 GETBYTE ();
8404 switch (op[2] & 0x00)
8405 {
8406 case 0x00:
8407 goto op_semantics_67;
8408 break;
8409 }
8410 break;
8411 case 0xd0:
8412 GETBYTE ();
8413 switch (op[2] & 0x00)
8414 {
8415 case 0x00:
8416 op_semantics_68:
8417 {
8418 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8419 #line 970 "rx-decode.opc"
8420 int sz AU = (op[1] >> 2) & 0x03;
8421 #line 970 "rx-decode.opc"
8422 int sd AU = op[1] & 0x03;
8423 #line 970 "rx-decode.opc"
8424 int rdst AU = (op[2] >> 4) & 0x0f;
8425 #line 970 "rx-decode.opc"
8426 int cond AU = op[2] & 0x0f;
8427 if (trace)
8428 {
8429 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8430 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8431 op[0], op[1], op[2]);
8432 printf (" sz = 0x%x,", sz);
8433 printf (" sd = 0x%x,", sd);
8434 printf (" rdst = 0x%x,", rdst);
8435 printf (" cond = 0x%x\n", cond);
8436 }
8437 SYNTAX("sc%1%s %0");
8438 #line 970 "rx-decode.opc"
8439 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8440
8441 }
8442 break;
8443 }
8444 break;
8445 case 0xd1:
8446 GETBYTE ();
8447 switch (op[2] & 0x00)
8448 {
8449 case 0x00:
8450 goto op_semantics_68;
8451 break;
8452 }
8453 break;
8454 case 0xd2:
8455 GETBYTE ();
8456 switch (op[2] & 0x00)
8457 {
8458 case 0x00:
8459 goto op_semantics_68;
8460 break;
8461 }
8462 break;
8463 case 0xd3:
8464 GETBYTE ();
8465 switch (op[2] & 0x00)
8466 {
8467 case 0x00:
8468 goto op_semantics_68;
8469 break;
8470 }
8471 break;
8472 case 0xd4:
8473 GETBYTE ();
8474 switch (op[2] & 0x00)
8475 {
8476 case 0x00:
8477 goto op_semantics_68;
8478 break;
8479 }
8480 break;
8481 case 0xd5:
8482 GETBYTE ();
8483 switch (op[2] & 0x00)
8484 {
8485 case 0x00:
8486 goto op_semantics_68;
8487 break;
8488 }
8489 break;
8490 case 0xd6:
8491 GETBYTE ();
8492 switch (op[2] & 0x00)
8493 {
8494 case 0x00:
8495 goto op_semantics_68;
8496 break;
8497 }
8498 break;
8499 case 0xd7:
8500 GETBYTE ();
8501 switch (op[2] & 0x00)
8502 {
8503 case 0x00:
8504 goto op_semantics_68;
8505 break;
8506 }
8507 break;
8508 case 0xd8:
8509 GETBYTE ();
8510 switch (op[2] & 0x00)
8511 {
8512 case 0x00:
8513 goto op_semantics_68;
8514 break;
8515 }
8516 break;
8517 case 0xd9:
8518 GETBYTE ();
8519 switch (op[2] & 0x00)
8520 {
8521 case 0x00:
8522 goto op_semantics_68;
8523 break;
8524 }
8525 break;
8526 case 0xda:
8527 GETBYTE ();
8528 switch (op[2] & 0x00)
8529 {
8530 case 0x00:
8531 goto op_semantics_68;
8532 break;
8533 }
8534 break;
8535 case 0xdb:
8536 GETBYTE ();
8537 switch (op[2] & 0x00)
8538 {
8539 case 0x00:
8540 goto op_semantics_68;
8541 break;
8542 }
8543 break;
8544 case 0xe0:
8545 GETBYTE ();
8546 switch (op[2] & 0x0f)
8547 {
8548 case 0x00:
8549 case 0x01:
8550 case 0x02:
8551 case 0x03:
8552 case 0x04:
8553 case 0x05:
8554 case 0x06:
8555 case 0x07:
8556 case 0x08:
8557 case 0x09:
8558 case 0x0a:
8559 case 0x0b:
8560 case 0x0c:
8561 case 0x0d:
8562 case 0x0e:
8563 op_semantics_69:
8564 {
8565 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
8566 #line 913 "rx-decode.opc"
8567 int bit AU = (op[1] >> 2) & 0x07;
8568 #line 913 "rx-decode.opc"
8569 int sd AU = op[1] & 0x03;
8570 #line 913 "rx-decode.opc"
8571 int rdst AU = (op[2] >> 4) & 0x0f;
8572 #line 913 "rx-decode.opc"
8573 int cond AU = op[2] & 0x0f;
8574 if (trace)
8575 {
8576 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8577 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8578 op[0], op[1], op[2]);
8579 printf (" bit = 0x%x,", bit);
8580 printf (" sd = 0x%x,", sd);
8581 printf (" rdst = 0x%x,", rdst);
8582 printf (" cond = 0x%x\n", cond);
8583 }
8584 SYNTAX("bm%2 #%1, %0%S0");
8585 #line 913 "rx-decode.opc"
8586 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8587
8588 }
8589 break;
8590 case 0x0f:
8591 op_semantics_70:
8592 {
8593 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
8594 #line 903 "rx-decode.opc"
8595 int bit AU = (op[1] >> 2) & 0x07;
8596 #line 903 "rx-decode.opc"
8597 int sd AU = op[1] & 0x03;
8598 #line 903 "rx-decode.opc"
8599 int rdst AU = (op[2] >> 4) & 0x0f;
8600 if (trace)
8601 {
8602 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8603 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8604 op[0], op[1], op[2]);
8605 printf (" bit = 0x%x,", bit);
8606 printf (" sd = 0x%x,", sd);
8607 printf (" rdst = 0x%x\n", rdst);
8608 }
8609 SYNTAX("bnot #%1, %0%S0");
8610 #line 903 "rx-decode.opc"
8611 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8612
8613 }
8614 break;
8615 }
8616 break;
8617 case 0xe1:
8618 GETBYTE ();
8619 switch (op[2] & 0x0f)
8620 {
8621 case 0x00:
8622 case 0x01:
8623 case 0x02:
8624 case 0x03:
8625 case 0x04:
8626 case 0x05:
8627 case 0x06:
8628 case 0x07:
8629 case 0x08:
8630 case 0x09:
8631 case 0x0a:
8632 case 0x0b:
8633 case 0x0c:
8634 case 0x0d:
8635 case 0x0e:
8636 goto op_semantics_69;
8637 break;
8638 case 0x0f:
8639 goto op_semantics_70;
8640 break;
8641 }
8642 break;
8643 case 0xe2:
8644 GETBYTE ();
8645 switch (op[2] & 0x0f)
8646 {
8647 case 0x00:
8648 case 0x01:
8649 case 0x02:
8650 case 0x03:
8651 case 0x04:
8652 case 0x05:
8653 case 0x06:
8654 case 0x07:
8655 case 0x08:
8656 case 0x09:
8657 case 0x0a:
8658 case 0x0b:
8659 case 0x0c:
8660 case 0x0d:
8661 case 0x0e:
8662 goto op_semantics_69;
8663 break;
8664 case 0x0f:
8665 goto op_semantics_70;
8666 break;
8667 }
8668 break;
8669 case 0xe3:
8670 GETBYTE ();
8671 switch (op[2] & 0x0f)
8672 {
8673 case 0x00:
8674 case 0x01:
8675 case 0x02:
8676 case 0x03:
8677 case 0x04:
8678 case 0x05:
8679 case 0x06:
8680 case 0x07:
8681 case 0x08:
8682 case 0x09:
8683 case 0x0a:
8684 case 0x0b:
8685 case 0x0c:
8686 case 0x0d:
8687 case 0x0e:
8688 goto op_semantics_69;
8689 break;
8690 case 0x0f:
8691 goto op_semantics_70;
8692 break;
8693 }
8694 break;
8695 case 0xe4:
8696 GETBYTE ();
8697 switch (op[2] & 0x0f)
8698 {
8699 case 0x00:
8700 case 0x01:
8701 case 0x02:
8702 case 0x03:
8703 case 0x04:
8704 case 0x05:
8705 case 0x06:
8706 case 0x07:
8707 case 0x08:
8708 case 0x09:
8709 case 0x0a:
8710 case 0x0b:
8711 case 0x0c:
8712 case 0x0d:
8713 case 0x0e:
8714 goto op_semantics_69;
8715 break;
8716 case 0x0f:
8717 goto op_semantics_70;
8718 break;
8719 }
8720 break;
8721 case 0xe5:
8722 GETBYTE ();
8723 switch (op[2] & 0x0f)
8724 {
8725 case 0x00:
8726 case 0x01:
8727 case 0x02:
8728 case 0x03:
8729 case 0x04:
8730 case 0x05:
8731 case 0x06:
8732 case 0x07:
8733 case 0x08:
8734 case 0x09:
8735 case 0x0a:
8736 case 0x0b:
8737 case 0x0c:
8738 case 0x0d:
8739 case 0x0e:
8740 goto op_semantics_69;
8741 break;
8742 case 0x0f:
8743 goto op_semantics_70;
8744 break;
8745 }
8746 break;
8747 case 0xe6:
8748 GETBYTE ();
8749 switch (op[2] & 0x0f)
8750 {
8751 case 0x00:
8752 case 0x01:
8753 case 0x02:
8754 case 0x03:
8755 case 0x04:
8756 case 0x05:
8757 case 0x06:
8758 case 0x07:
8759 case 0x08:
8760 case 0x09:
8761 case 0x0a:
8762 case 0x0b:
8763 case 0x0c:
8764 case 0x0d:
8765 case 0x0e:
8766 goto op_semantics_69;
8767 break;
8768 case 0x0f:
8769 goto op_semantics_70;
8770 break;
8771 }
8772 break;
8773 case 0xe7:
8774 GETBYTE ();
8775 switch (op[2] & 0x0f)
8776 {
8777 case 0x00:
8778 case 0x01:
8779 case 0x02:
8780 case 0x03:
8781 case 0x04:
8782 case 0x05:
8783 case 0x06:
8784 case 0x07:
8785 case 0x08:
8786 case 0x09:
8787 case 0x0a:
8788 case 0x0b:
8789 case 0x0c:
8790 case 0x0d:
8791 case 0x0e:
8792 goto op_semantics_69;
8793 break;
8794 case 0x0f:
8795 goto op_semantics_70;
8796 break;
8797 }
8798 break;
8799 case 0xe8:
8800 GETBYTE ();
8801 switch (op[2] & 0x0f)
8802 {
8803 case 0x00:
8804 case 0x01:
8805 case 0x02:
8806 case 0x03:
8807 case 0x04:
8808 case 0x05:
8809 case 0x06:
8810 case 0x07:
8811 case 0x08:
8812 case 0x09:
8813 case 0x0a:
8814 case 0x0b:
8815 case 0x0c:
8816 case 0x0d:
8817 case 0x0e:
8818 goto op_semantics_69;
8819 break;
8820 case 0x0f:
8821 goto op_semantics_70;
8822 break;
8823 }
8824 break;
8825 case 0xe9:
8826 GETBYTE ();
8827 switch (op[2] & 0x0f)
8828 {
8829 case 0x00:
8830 case 0x01:
8831 case 0x02:
8832 case 0x03:
8833 case 0x04:
8834 case 0x05:
8835 case 0x06:
8836 case 0x07:
8837 case 0x08:
8838 case 0x09:
8839 case 0x0a:
8840 case 0x0b:
8841 case 0x0c:
8842 case 0x0d:
8843 case 0x0e:
8844 goto op_semantics_69;
8845 break;
8846 case 0x0f:
8847 goto op_semantics_70;
8848 break;
8849 }
8850 break;
8851 case 0xea:
8852 GETBYTE ();
8853 switch (op[2] & 0x0f)
8854 {
8855 case 0x00:
8856 case 0x01:
8857 case 0x02:
8858 case 0x03:
8859 case 0x04:
8860 case 0x05:
8861 case 0x06:
8862 case 0x07:
8863 case 0x08:
8864 case 0x09:
8865 case 0x0a:
8866 case 0x0b:
8867 case 0x0c:
8868 case 0x0d:
8869 case 0x0e:
8870 goto op_semantics_69;
8871 break;
8872 case 0x0f:
8873 goto op_semantics_70;
8874 break;
8875 }
8876 break;
8877 case 0xeb:
8878 GETBYTE ();
8879 switch (op[2] & 0x0f)
8880 {
8881 case 0x00:
8882 case 0x01:
8883 case 0x02:
8884 case 0x03:
8885 case 0x04:
8886 case 0x05:
8887 case 0x06:
8888 case 0x07:
8889 case 0x08:
8890 case 0x09:
8891 case 0x0a:
8892 case 0x0b:
8893 case 0x0c:
8894 case 0x0d:
8895 case 0x0e:
8896 goto op_semantics_69;
8897 break;
8898 case 0x0f:
8899 goto op_semantics_70;
8900 break;
8901 }
8902 break;
8903 case 0xec:
8904 GETBYTE ();
8905 switch (op[2] & 0x0f)
8906 {
8907 case 0x00:
8908 case 0x01:
8909 case 0x02:
8910 case 0x03:
8911 case 0x04:
8912 case 0x05:
8913 case 0x06:
8914 case 0x07:
8915 case 0x08:
8916 case 0x09:
8917 case 0x0a:
8918 case 0x0b:
8919 case 0x0c:
8920 case 0x0d:
8921 case 0x0e:
8922 goto op_semantics_69;
8923 break;
8924 case 0x0f:
8925 goto op_semantics_70;
8926 break;
8927 }
8928 break;
8929 case 0xed:
8930 GETBYTE ();
8931 switch (op[2] & 0x0f)
8932 {
8933 case 0x00:
8934 case 0x01:
8935 case 0x02:
8936 case 0x03:
8937 case 0x04:
8938 case 0x05:
8939 case 0x06:
8940 case 0x07:
8941 case 0x08:
8942 case 0x09:
8943 case 0x0a:
8944 case 0x0b:
8945 case 0x0c:
8946 case 0x0d:
8947 case 0x0e:
8948 goto op_semantics_69;
8949 break;
8950 case 0x0f:
8951 goto op_semantics_70;
8952 break;
8953 }
8954 break;
8955 case 0xee:
8956 GETBYTE ();
8957 switch (op[2] & 0x0f)
8958 {
8959 case 0x00:
8960 case 0x01:
8961 case 0x02:
8962 case 0x03:
8963 case 0x04:
8964 case 0x05:
8965 case 0x06:
8966 case 0x07:
8967 case 0x08:
8968 case 0x09:
8969 case 0x0a:
8970 case 0x0b:
8971 case 0x0c:
8972 case 0x0d:
8973 case 0x0e:
8974 goto op_semantics_69;
8975 break;
8976 case 0x0f:
8977 goto op_semantics_70;
8978 break;
8979 }
8980 break;
8981 case 0xef:
8982 GETBYTE ();
8983 switch (op[2] & 0x0f)
8984 {
8985 case 0x00:
8986 case 0x01:
8987 case 0x02:
8988 case 0x03:
8989 case 0x04:
8990 case 0x05:
8991 case 0x06:
8992 case 0x07:
8993 case 0x08:
8994 case 0x09:
8995 case 0x0a:
8996 case 0x0b:
8997 case 0x0c:
8998 case 0x0d:
8999 case 0x0e:
9000 goto op_semantics_69;
9001 break;
9002 case 0x0f:
9003 goto op_semantics_70;
9004 break;
9005 }
9006 break;
9007 case 0xf0:
9008 GETBYTE ();
9009 switch (op[2] & 0x0f)
9010 {
9011 case 0x00:
9012 case 0x01:
9013 case 0x02:
9014 case 0x03:
9015 case 0x04:
9016 case 0x05:
9017 case 0x06:
9018 case 0x07:
9019 case 0x08:
9020 case 0x09:
9021 case 0x0a:
9022 case 0x0b:
9023 case 0x0c:
9024 case 0x0d:
9025 case 0x0e:
9026 goto op_semantics_69;
9027 break;
9028 case 0x0f:
9029 goto op_semantics_70;
9030 break;
9031 }
9032 break;
9033 case 0xf1:
9034 GETBYTE ();
9035 switch (op[2] & 0x0f)
9036 {
9037 case 0x00:
9038 case 0x01:
9039 case 0x02:
9040 case 0x03:
9041 case 0x04:
9042 case 0x05:
9043 case 0x06:
9044 case 0x07:
9045 case 0x08:
9046 case 0x09:
9047 case 0x0a:
9048 case 0x0b:
9049 case 0x0c:
9050 case 0x0d:
9051 case 0x0e:
9052 goto op_semantics_69;
9053 break;
9054 case 0x0f:
9055 goto op_semantics_70;
9056 break;
9057 }
9058 break;
9059 case 0xf2:
9060 GETBYTE ();
9061 switch (op[2] & 0x0f)
9062 {
9063 case 0x00:
9064 case 0x01:
9065 case 0x02:
9066 case 0x03:
9067 case 0x04:
9068 case 0x05:
9069 case 0x06:
9070 case 0x07:
9071 case 0x08:
9072 case 0x09:
9073 case 0x0a:
9074 case 0x0b:
9075 case 0x0c:
9076 case 0x0d:
9077 case 0x0e:
9078 goto op_semantics_69;
9079 break;
9080 case 0x0f:
9081 goto op_semantics_70;
9082 break;
9083 }
9084 break;
9085 case 0xf3:
9086 GETBYTE ();
9087 switch (op[2] & 0x0f)
9088 {
9089 case 0x00:
9090 case 0x01:
9091 case 0x02:
9092 case 0x03:
9093 case 0x04:
9094 case 0x05:
9095 case 0x06:
9096 case 0x07:
9097 case 0x08:
9098 case 0x09:
9099 case 0x0a:
9100 case 0x0b:
9101 case 0x0c:
9102 case 0x0d:
9103 case 0x0e:
9104 goto op_semantics_69;
9105 break;
9106 case 0x0f:
9107 goto op_semantics_70;
9108 break;
9109 }
9110 break;
9111 case 0xf4:
9112 GETBYTE ();
9113 switch (op[2] & 0x0f)
9114 {
9115 case 0x00:
9116 case 0x01:
9117 case 0x02:
9118 case 0x03:
9119 case 0x04:
9120 case 0x05:
9121 case 0x06:
9122 case 0x07:
9123 case 0x08:
9124 case 0x09:
9125 case 0x0a:
9126 case 0x0b:
9127 case 0x0c:
9128 case 0x0d:
9129 case 0x0e:
9130 goto op_semantics_69;
9131 break;
9132 case 0x0f:
9133 goto op_semantics_70;
9134 break;
9135 }
9136 break;
9137 case 0xf5:
9138 GETBYTE ();
9139 switch (op[2] & 0x0f)
9140 {
9141 case 0x00:
9142 case 0x01:
9143 case 0x02:
9144 case 0x03:
9145 case 0x04:
9146 case 0x05:
9147 case 0x06:
9148 case 0x07:
9149 case 0x08:
9150 case 0x09:
9151 case 0x0a:
9152 case 0x0b:
9153 case 0x0c:
9154 case 0x0d:
9155 case 0x0e:
9156 goto op_semantics_69;
9157 break;
9158 case 0x0f:
9159 goto op_semantics_70;
9160 break;
9161 }
9162 break;
9163 case 0xf6:
9164 GETBYTE ();
9165 switch (op[2] & 0x0f)
9166 {
9167 case 0x00:
9168 case 0x01:
9169 case 0x02:
9170 case 0x03:
9171 case 0x04:
9172 case 0x05:
9173 case 0x06:
9174 case 0x07:
9175 case 0x08:
9176 case 0x09:
9177 case 0x0a:
9178 case 0x0b:
9179 case 0x0c:
9180 case 0x0d:
9181 case 0x0e:
9182 goto op_semantics_69;
9183 break;
9184 case 0x0f:
9185 goto op_semantics_70;
9186 break;
9187 }
9188 break;
9189 case 0xf7:
9190 GETBYTE ();
9191 switch (op[2] & 0x0f)
9192 {
9193 case 0x00:
9194 case 0x01:
9195 case 0x02:
9196 case 0x03:
9197 case 0x04:
9198 case 0x05:
9199 case 0x06:
9200 case 0x07:
9201 case 0x08:
9202 case 0x09:
9203 case 0x0a:
9204 case 0x0b:
9205 case 0x0c:
9206 case 0x0d:
9207 case 0x0e:
9208 goto op_semantics_69;
9209 break;
9210 case 0x0f:
9211 goto op_semantics_70;
9212 break;
9213 }
9214 break;
9215 case 0xf8:
9216 GETBYTE ();
9217 switch (op[2] & 0x0f)
9218 {
9219 case 0x00:
9220 case 0x01:
9221 case 0x02:
9222 case 0x03:
9223 case 0x04:
9224 case 0x05:
9225 case 0x06:
9226 case 0x07:
9227 case 0x08:
9228 case 0x09:
9229 case 0x0a:
9230 case 0x0b:
9231 case 0x0c:
9232 case 0x0d:
9233 case 0x0e:
9234 goto op_semantics_69;
9235 break;
9236 case 0x0f:
9237 goto op_semantics_70;
9238 break;
9239 }
9240 break;
9241 case 0xf9:
9242 GETBYTE ();
9243 switch (op[2] & 0x0f)
9244 {
9245 case 0x00:
9246 case 0x01:
9247 case 0x02:
9248 case 0x03:
9249 case 0x04:
9250 case 0x05:
9251 case 0x06:
9252 case 0x07:
9253 case 0x08:
9254 case 0x09:
9255 case 0x0a:
9256 case 0x0b:
9257 case 0x0c:
9258 case 0x0d:
9259 case 0x0e:
9260 goto op_semantics_69;
9261 break;
9262 case 0x0f:
9263 goto op_semantics_70;
9264 break;
9265 }
9266 break;
9267 case 0xfa:
9268 GETBYTE ();
9269 switch (op[2] & 0x0f)
9270 {
9271 case 0x00:
9272 case 0x01:
9273 case 0x02:
9274 case 0x03:
9275 case 0x04:
9276 case 0x05:
9277 case 0x06:
9278 case 0x07:
9279 case 0x08:
9280 case 0x09:
9281 case 0x0a:
9282 case 0x0b:
9283 case 0x0c:
9284 case 0x0d:
9285 case 0x0e:
9286 goto op_semantics_69;
9287 break;
9288 case 0x0f:
9289 goto op_semantics_70;
9290 break;
9291 }
9292 break;
9293 case 0xfb:
9294 GETBYTE ();
9295 switch (op[2] & 0x0f)
9296 {
9297 case 0x00:
9298 case 0x01:
9299 case 0x02:
9300 case 0x03:
9301 case 0x04:
9302 case 0x05:
9303 case 0x06:
9304 case 0x07:
9305 case 0x08:
9306 case 0x09:
9307 case 0x0a:
9308 case 0x0b:
9309 case 0x0c:
9310 case 0x0d:
9311 case 0x0e:
9312 goto op_semantics_69;
9313 break;
9314 case 0x0f:
9315 goto op_semantics_70;
9316 break;
9317 }
9318 break;
9319 case 0xfc:
9320 GETBYTE ();
9321 switch (op[2] & 0x0f)
9322 {
9323 case 0x00:
9324 case 0x01:
9325 case 0x02:
9326 case 0x03:
9327 case 0x04:
9328 case 0x05:
9329 case 0x06:
9330 case 0x07:
9331 case 0x08:
9332 case 0x09:
9333 case 0x0a:
9334 case 0x0b:
9335 case 0x0c:
9336 case 0x0d:
9337 case 0x0e:
9338 goto op_semantics_69;
9339 break;
9340 case 0x0f:
9341 goto op_semantics_70;
9342 break;
9343 }
9344 break;
9345 case 0xfd:
9346 GETBYTE ();
9347 switch (op[2] & 0x0f)
9348 {
9349 case 0x00:
9350 case 0x01:
9351 case 0x02:
9352 case 0x03:
9353 case 0x04:
9354 case 0x05:
9355 case 0x06:
9356 case 0x07:
9357 case 0x08:
9358 case 0x09:
9359 case 0x0a:
9360 case 0x0b:
9361 case 0x0c:
9362 case 0x0d:
9363 case 0x0e:
9364 goto op_semantics_69;
9365 break;
9366 case 0x0f:
9367 goto op_semantics_70;
9368 break;
9369 }
9370 break;
9371 case 0xfe:
9372 GETBYTE ();
9373 switch (op[2] & 0x0f)
9374 {
9375 case 0x00:
9376 case 0x01:
9377 case 0x02:
9378 case 0x03:
9379 case 0x04:
9380 case 0x05:
9381 case 0x06:
9382 case 0x07:
9383 case 0x08:
9384 case 0x09:
9385 case 0x0a:
9386 case 0x0b:
9387 case 0x0c:
9388 case 0x0d:
9389 case 0x0e:
9390 goto op_semantics_69;
9391 break;
9392 case 0x0f:
9393 goto op_semantics_70;
9394 break;
9395 }
9396 break;
9397 case 0xff:
9398 GETBYTE ();
9399 switch (op[2] & 0x0f)
9400 {
9401 case 0x00:
9402 case 0x01:
9403 case 0x02:
9404 case 0x03:
9405 case 0x04:
9406 case 0x05:
9407 case 0x06:
9408 case 0x07:
9409 case 0x08:
9410 case 0x09:
9411 case 0x0a:
9412 case 0x0b:
9413 case 0x0c:
9414 case 0x0d:
9415 case 0x0e:
9416 goto op_semantics_69;
9417 break;
9418 case 0x0f:
9419 goto op_semantics_70;
9420 break;
9421 }
9422 break;
9423 default: UNSUPPORTED(); break;
9424 }
9425 break;
9426 case 0xfd:
9427 GETBYTE ();
9428 switch (op[1] & 0xff)
9429 {
9430 case 0x00:
9431 GETBYTE ();
9432 switch (op[2] & 0x00)
9433 {
9434 case 0x00:
9435 {
9436 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
9437 #line 786 "rx-decode.opc"
9438 int srca AU = (op[2] >> 4) & 0x0f;
9439 #line 786 "rx-decode.opc"
9440 int srcb AU = op[2] & 0x0f;
9441 if (trace)
9442 {
9443 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9444 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9445 op[0], op[1], op[2]);
9446 printf (" srca = 0x%x,", srca);
9447 printf (" srcb = 0x%x\n", srcb);
9448 }
9449 SYNTAX("mulhi %1, %2");
9450 #line 786 "rx-decode.opc"
9451 ID(mulhi); SR(srca); S2R(srcb); F_____;
9452
9453 }
9454 break;
9455 }
9456 break;
9457 case 0x01:
9458 GETBYTE ();
9459 switch (op[2] & 0x00)
9460 {
9461 case 0x00:
9462 {
9463 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
9464 #line 789 "rx-decode.opc"
9465 int srca AU = (op[2] >> 4) & 0x0f;
9466 #line 789 "rx-decode.opc"
9467 int srcb AU = op[2] & 0x0f;
9468 if (trace)
9469 {
9470 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9471 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9472 op[0], op[1], op[2]);
9473 printf (" srca = 0x%x,", srca);
9474 printf (" srcb = 0x%x\n", srcb);
9475 }
9476 SYNTAX("mullo %1, %2");
9477 #line 789 "rx-decode.opc"
9478 ID(mullo); SR(srca); S2R(srcb); F_____;
9479
9480 }
9481 break;
9482 }
9483 break;
9484 case 0x04:
9485 GETBYTE ();
9486 switch (op[2] & 0x00)
9487 {
9488 case 0x00:
9489 {
9490 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
9491 #line 792 "rx-decode.opc"
9492 int srca AU = (op[2] >> 4) & 0x0f;
9493 #line 792 "rx-decode.opc"
9494 int srcb AU = op[2] & 0x0f;
9495 if (trace)
9496 {
9497 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9498 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9499 op[0], op[1], op[2]);
9500 printf (" srca = 0x%x,", srca);
9501 printf (" srcb = 0x%x\n", srcb);
9502 }
9503 SYNTAX("machi %1, %2");
9504 #line 792 "rx-decode.opc"
9505 ID(machi); SR(srca); S2R(srcb); F_____;
9506
9507 }
9508 break;
9509 }
9510 break;
9511 case 0x05:
9512 GETBYTE ();
9513 switch (op[2] & 0x00)
9514 {
9515 case 0x00:
9516 {
9517 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
9518 #line 795 "rx-decode.opc"
9519 int srca AU = (op[2] >> 4) & 0x0f;
9520 #line 795 "rx-decode.opc"
9521 int srcb AU = op[2] & 0x0f;
9522 if (trace)
9523 {
9524 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9525 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9526 op[0], op[1], op[2]);
9527 printf (" srca = 0x%x,", srca);
9528 printf (" srcb = 0x%x\n", srcb);
9529 }
9530 SYNTAX("maclo %1, %2");
9531 #line 795 "rx-decode.opc"
9532 ID(maclo); SR(srca); S2R(srcb); F_____;
9533
9534 }
9535 break;
9536 }
9537 break;
9538 case 0x17:
9539 GETBYTE ();
9540 switch (op[2] & 0xf0)
9541 {
9542 case 0x00:
9543 {
9544 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9545 #line 798 "rx-decode.opc"
9546 int rsrc AU = op[2] & 0x0f;
9547 if (trace)
9548 {
9549 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9550 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9551 op[0], op[1], op[2]);
9552 printf (" rsrc = 0x%x\n", rsrc);
9553 }
9554 SYNTAX("mvtachi %1");
9555 #line 798 "rx-decode.opc"
9556 ID(mvtachi); SR(rsrc); F_____;
9557
9558 }
9559 break;
9560 case 0x10:
9561 {
9562 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9563 #line 801 "rx-decode.opc"
9564 int rsrc AU = op[2] & 0x0f;
9565 if (trace)
9566 {
9567 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9568 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9569 op[0], op[1], op[2]);
9570 printf (" rsrc = 0x%x\n", rsrc);
9571 }
9572 SYNTAX("mvtaclo %1");
9573 #line 801 "rx-decode.opc"
9574 ID(mvtaclo); SR(rsrc); F_____;
9575
9576 }
9577 break;
9578 default: UNSUPPORTED(); break;
9579 }
9580 break;
9581 case 0x18:
9582 GETBYTE ();
9583 switch (op[2] & 0xef)
9584 {
9585 case 0x00:
9586 {
9587 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
9588 #line 813 "rx-decode.opc"
9589 int i AU = (op[2] >> 4) & 0x01;
9590 if (trace)
9591 {
9592 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9593 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9594 op[0], op[1], op[2]);
9595 printf (" i = 0x%x\n", i);
9596 }
9597 SYNTAX("racw #%1");
9598 #line 813 "rx-decode.opc"
9599 ID(racw); SC(i+1); F_____;
9600
9601 /*----------------------------------------------------------------------*/
9602 /* SAT */
9603
9604 }
9605 break;
9606 default: UNSUPPORTED(); break;
9607 }
9608 break;
9609 case 0x1f:
9610 GETBYTE ();
9611 switch (op[2] & 0xf0)
9612 {
9613 case 0x00:
9614 {
9615 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9616 #line 804 "rx-decode.opc"
9617 int rdst AU = op[2] & 0x0f;
9618 if (trace)
9619 {
9620 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9621 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9622 op[0], op[1], op[2]);
9623 printf (" rdst = 0x%x\n", rdst);
9624 }
9625 SYNTAX("mvfachi %0");
9626 #line 804 "rx-decode.opc"
9627 ID(mvfachi); DR(rdst); F_____;
9628
9629 }
9630 break;
9631 case 0x10:
9632 {
9633 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9634 #line 810 "rx-decode.opc"
9635 int rdst AU = op[2] & 0x0f;
9636 if (trace)
9637 {
9638 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9639 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9640 op[0], op[1], op[2]);
9641 printf (" rdst = 0x%x\n", rdst);
9642 }
9643 SYNTAX("mvfaclo %0");
9644 #line 810 "rx-decode.opc"
9645 ID(mvfaclo); DR(rdst); F_____;
9646
9647 }
9648 break;
9649 case 0x20:
9650 {
9651 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9652 #line 807 "rx-decode.opc"
9653 int rdst AU = op[2] & 0x0f;
9654 if (trace)
9655 {
9656 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9657 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9658 op[0], op[1], op[2]);
9659 printf (" rdst = 0x%x\n", rdst);
9660 }
9661 SYNTAX("mvfacmi %0");
9662 #line 807 "rx-decode.opc"
9663 ID(mvfacmi); DR(rdst); F_____;
9664
9665 }
9666 break;
9667 default: UNSUPPORTED(); break;
9668 }
9669 break;
9670 case 0x20:
9671 GETBYTE ();
9672 switch (op[2] & 0x00)
9673 {
9674 case 0x00:
9675 op_semantics_71:
9676 {
9677 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
9678 #line 320 "rx-decode.opc"
9679 int p AU = (op[1] >> 2) & 0x01;
9680 #line 320 "rx-decode.opc"
9681 int sz AU = op[1] & 0x03;
9682 #line 320 "rx-decode.opc"
9683 int rdst AU = (op[2] >> 4) & 0x0f;
9684 #line 320 "rx-decode.opc"
9685 int rsrc AU = op[2] & 0x0f;
9686 if (trace)
9687 {
9688 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9689 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9690 op[0], op[1], op[2]);
9691 printf (" p = 0x%x,", p);
9692 printf (" sz = 0x%x,", sz);
9693 printf (" rdst = 0x%x,", rdst);
9694 printf (" rsrc = 0x%x\n", rsrc);
9695 }
9696 SYNTAX("mov%s %1, %0");
9697 #line 320 "rx-decode.opc"
9698 ID(mov); sBWL (sz); SR(rsrc); F_____;
9699 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9700
9701 }
9702 break;
9703 }
9704 break;
9705 case 0x21:
9706 GETBYTE ();
9707 switch (op[2] & 0x00)
9708 {
9709 case 0x00:
9710 goto op_semantics_71;
9711 break;
9712 }
9713 break;
9714 case 0x22:
9715 GETBYTE ();
9716 switch (op[2] & 0x00)
9717 {
9718 case 0x00:
9719 goto op_semantics_71;
9720 break;
9721 }
9722 break;
9723 case 0x24:
9724 GETBYTE ();
9725 switch (op[2] & 0x00)
9726 {
9727 case 0x00:
9728 goto op_semantics_71;
9729 break;
9730 }
9731 break;
9732 case 0x25:
9733 GETBYTE ();
9734 switch (op[2] & 0x00)
9735 {
9736 case 0x00:
9737 goto op_semantics_71;
9738 break;
9739 }
9740 break;
9741 case 0x26:
9742 GETBYTE ();
9743 switch (op[2] & 0x00)
9744 {
9745 case 0x00:
9746 goto op_semantics_71;
9747 break;
9748 }
9749 break;
9750 case 0x28:
9751 GETBYTE ();
9752 switch (op[2] & 0x00)
9753 {
9754 case 0x00:
9755 op_semantics_72:
9756 {
9757 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
9758 #line 324 "rx-decode.opc"
9759 int p AU = (op[1] >> 2) & 0x01;
9760 #line 324 "rx-decode.opc"
9761 int sz AU = op[1] & 0x03;
9762 #line 324 "rx-decode.opc"
9763 int rsrc AU = (op[2] >> 4) & 0x0f;
9764 #line 324 "rx-decode.opc"
9765 int rdst AU = op[2] & 0x0f;
9766 if (trace)
9767 {
9768 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9769 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9770 op[0], op[1], op[2]);
9771 printf (" p = 0x%x,", p);
9772 printf (" sz = 0x%x,", sz);
9773 printf (" rsrc = 0x%x,", rsrc);
9774 printf (" rdst = 0x%x\n", rdst);
9775 }
9776 SYNTAX("mov%s %1, %0");
9777 #line 324 "rx-decode.opc"
9778 ID(mov); sBWL (sz); DR(rdst); F_____;
9779 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9780
9781 }
9782 break;
9783 }
9784 break;
9785 case 0x29:
9786 GETBYTE ();
9787 switch (op[2] & 0x00)
9788 {
9789 case 0x00:
9790 goto op_semantics_72;
9791 break;
9792 }
9793 break;
9794 case 0x2a:
9795 GETBYTE ();
9796 switch (op[2] & 0x00)
9797 {
9798 case 0x00:
9799 goto op_semantics_72;
9800 break;
9801 }
9802 break;
9803 case 0x2c:
9804 GETBYTE ();
9805 switch (op[2] & 0x00)
9806 {
9807 case 0x00:
9808 goto op_semantics_72;
9809 break;
9810 }
9811 break;
9812 case 0x2d:
9813 GETBYTE ();
9814 switch (op[2] & 0x00)
9815 {
9816 case 0x00:
9817 goto op_semantics_72;
9818 break;
9819 }
9820 break;
9821 case 0x2e:
9822 GETBYTE ();
9823 switch (op[2] & 0x00)
9824 {
9825 case 0x00:
9826 goto op_semantics_72;
9827 break;
9828 }
9829 break;
9830 case 0x38:
9831 GETBYTE ();
9832 switch (op[2] & 0x00)
9833 {
9834 case 0x00:
9835 op_semantics_73:
9836 {
9837 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
9838 #line 334 "rx-decode.opc"
9839 int p AU = (op[1] >> 2) & 0x01;
9840 #line 334 "rx-decode.opc"
9841 int sz AU = op[1] & 0x03;
9842 #line 334 "rx-decode.opc"
9843 int rsrc AU = (op[2] >> 4) & 0x0f;
9844 #line 334 "rx-decode.opc"
9845 int rdst AU = op[2] & 0x0f;
9846 if (trace)
9847 {
9848 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9849 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9850 op[0], op[1], op[2]);
9851 printf (" p = 0x%x,", p);
9852 printf (" sz = 0x%x,", sz);
9853 printf (" rsrc = 0x%x,", rsrc);
9854 printf (" rdst = 0x%x\n", rdst);
9855 }
9856 SYNTAX("movu%s %1, %0");
9857 #line 334 "rx-decode.opc"
9858 ID(mov); uBWL (sz); DR(rdst); F_____;
9859 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9860
9861 /*----------------------------------------------------------------------*/
9862 /* PUSH/POP */
9863
9864 }
9865 break;
9866 }
9867 break;
9868 case 0x39:
9869 GETBYTE ();
9870 switch (op[2] & 0x00)
9871 {
9872 case 0x00:
9873 goto op_semantics_73;
9874 break;
9875 }
9876 break;
9877 case 0x3a:
9878 GETBYTE ();
9879 switch (op[2] & 0x00)
9880 {
9881 case 0x00:
9882 goto op_semantics_73;
9883 break;
9884 }
9885 break;
9886 case 0x3c:
9887 GETBYTE ();
9888 switch (op[2] & 0x00)
9889 {
9890 case 0x00:
9891 goto op_semantics_73;
9892 break;
9893 }
9894 break;
9895 case 0x3d:
9896 GETBYTE ();
9897 switch (op[2] & 0x00)
9898 {
9899 case 0x00:
9900 goto op_semantics_73;
9901 break;
9902 }
9903 break;
9904 case 0x3e:
9905 GETBYTE ();
9906 switch (op[2] & 0x00)
9907 {
9908 case 0x00:
9909 goto op_semantics_73;
9910 break;
9911 }
9912 break;
9913 case 0x60:
9914 GETBYTE ();
9915 switch (op[2] & 0x00)
9916 {
9917 case 0x00:
9918 {
9919 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
9920 #line 667 "rx-decode.opc"
9921 int rsrc AU = (op[2] >> 4) & 0x0f;
9922 #line 667 "rx-decode.opc"
9923 int rdst AU = op[2] & 0x0f;
9924 if (trace)
9925 {
9926 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9927 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9928 op[0], op[1], op[2]);
9929 printf (" rsrc = 0x%x,", rsrc);
9930 printf (" rdst = 0x%x\n", rdst);
9931 }
9932 SYNTAX("shlr %2, %0");
9933 #line 667 "rx-decode.opc"
9934 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
9935
9936 }
9937 break;
9938 }
9939 break;
9940 case 0x61:
9941 GETBYTE ();
9942 switch (op[2] & 0x00)
9943 {
9944 case 0x00:
9945 {
9946 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
9947 #line 657 "rx-decode.opc"
9948 int rsrc AU = (op[2] >> 4) & 0x0f;
9949 #line 657 "rx-decode.opc"
9950 int rdst AU = op[2] & 0x0f;
9951 if (trace)
9952 {
9953 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9954 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
9955 op[0], op[1], op[2]);
9956 printf (" rsrc = 0x%x,", rsrc);
9957 printf (" rdst = 0x%x\n", rdst);
9958 }
9959 SYNTAX("shar %2, %0");
9960 #line 657 "rx-decode.opc"
9961 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
9962
9963 }
9964 break;
9965 }
9966 break;
9967 case 0x62:
9968 GETBYTE ();
9969 switch (op[2] & 0x00)
9970 {
9971 case 0x00:
9972 {
9973 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
9974 #line 647 "rx-decode.opc"
9975 int rsrc AU = (op[2] >> 4) & 0x0f;
9976 #line 647 "rx-decode.opc"
9977 int rdst AU = op[2] & 0x0f;
9978 if (trace)
9979 {
9980 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9981 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
9982 op[0], op[1], op[2]);
9983 printf (" rsrc = 0x%x,", rsrc);
9984 printf (" rdst = 0x%x\n", rdst);
9985 }
9986 SYNTAX("shll %2, %0");
9987 #line 647 "rx-decode.opc"
9988 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
9989
9990 }
9991 break;
9992 }
9993 break;
9994 case 0x64:
9995 GETBYTE ();
9996 switch (op[2] & 0x00)
9997 {
9998 case 0x00:
9999 {
10000 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
10001 #line 691 "rx-decode.opc"
10002 int rsrc AU = (op[2] >> 4) & 0x0f;
10003 #line 691 "rx-decode.opc"
10004 int rdst AU = op[2] & 0x0f;
10005 if (trace)
10006 {
10007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10008 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
10009 op[0], op[1], op[2]);
10010 printf (" rsrc = 0x%x,", rsrc);
10011 printf (" rdst = 0x%x\n", rdst);
10012 }
10013 SYNTAX("rotr %1, %0");
10014 #line 691 "rx-decode.opc"
10015 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
10016
10017 }
10018 break;
10019 }
10020 break;
10021 case 0x65:
10022 GETBYTE ();
10023 switch (op[2] & 0x00)
10024 {
10025 case 0x00:
10026 {
10027 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
10028 #line 694 "rx-decode.opc"
10029 int rsrc AU = (op[2] >> 4) & 0x0f;
10030 #line 694 "rx-decode.opc"
10031 int rdst AU = op[2] & 0x0f;
10032 if (trace)
10033 {
10034 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10035 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10036 op[0], op[1], op[2]);
10037 printf (" rsrc = 0x%x,", rsrc);
10038 printf (" rdst = 0x%x\n", rdst);
10039 }
10040 SYNTAX("revw %1, %0");
10041 #line 694 "rx-decode.opc"
10042 ID(revw); SR(rsrc); DR(rdst);
10043
10044 }
10045 break;
10046 }
10047 break;
10048 case 0x66:
10049 GETBYTE ();
10050 switch (op[2] & 0x00)
10051 {
10052 case 0x00:
10053 {
10054 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
10055 #line 685 "rx-decode.opc"
10056 int rsrc AU = (op[2] >> 4) & 0x0f;
10057 #line 685 "rx-decode.opc"
10058 int rdst AU = op[2] & 0x0f;
10059 if (trace)
10060 {
10061 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10062 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10063 op[0], op[1], op[2]);
10064 printf (" rsrc = 0x%x,", rsrc);
10065 printf (" rdst = 0x%x\n", rdst);
10066 }
10067 SYNTAX("rotl %1, %0");
10068 #line 685 "rx-decode.opc"
10069 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
10070
10071 }
10072 break;
10073 }
10074 break;
10075 case 0x67:
10076 GETBYTE ();
10077 switch (op[2] & 0x00)
10078 {
10079 case 0x00:
10080 {
10081 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
10082 #line 697 "rx-decode.opc"
10083 int rsrc AU = (op[2] >> 4) & 0x0f;
10084 #line 697 "rx-decode.opc"
10085 int rdst AU = op[2] & 0x0f;
10086 if (trace)
10087 {
10088 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10089 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10090 op[0], op[1], op[2]);
10091 printf (" rsrc = 0x%x,", rsrc);
10092 printf (" rdst = 0x%x\n", rdst);
10093 }
10094 SYNTAX("revl %1, %0");
10095 #line 697 "rx-decode.opc"
10096 ID(revl); SR(rsrc); DR(rdst);
10097
10098 /*----------------------------------------------------------------------*/
10099 /* BRANCH */
10100
10101 }
10102 break;
10103 }
10104 break;
10105 case 0x68:
10106 GETBYTE ();
10107 switch (op[2] & 0x00)
10108 {
10109 case 0x00:
10110 op_semantics_74:
10111 {
10112 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
10113 #line 940 "rx-decode.opc"
10114 int c AU = op[1] & 0x01;
10115 #line 940 "rx-decode.opc"
10116 int rsrc AU = (op[2] >> 4) & 0x0f;
10117 #line 940 "rx-decode.opc"
10118 int rdst AU = op[2] & 0x0f;
10119 if (trace)
10120 {
10121 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10122 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10123 op[0], op[1], op[2]);
10124 printf (" c = 0x%x,", c);
10125 printf (" rsrc = 0x%x,", rsrc);
10126 printf (" rdst = 0x%x\n", rdst);
10127 }
10128 SYNTAX("mvtc %1, %0");
10129 #line 940 "rx-decode.opc"
10130 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10131
10132 }
10133 break;
10134 }
10135 break;
10136 case 0x69:
10137 GETBYTE ();
10138 switch (op[2] & 0x00)
10139 {
10140 case 0x00:
10141 goto op_semantics_74;
10142 break;
10143 }
10144 break;
10145 case 0x6a:
10146 GETBYTE ();
10147 switch (op[2] & 0x00)
10148 {
10149 case 0x00:
10150 op_semantics_75:
10151 {
10152 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
10153 #line 943 "rx-decode.opc"
10154 int s AU = op[1] & 0x01;
10155 #line 943 "rx-decode.opc"
10156 int rsrc AU = (op[2] >> 4) & 0x0f;
10157 #line 943 "rx-decode.opc"
10158 int rdst AU = op[2] & 0x0f;
10159 if (trace)
10160 {
10161 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10162 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10163 op[0], op[1], op[2]);
10164 printf (" s = 0x%x,", s);
10165 printf (" rsrc = 0x%x,", rsrc);
10166 printf (" rdst = 0x%x\n", rdst);
10167 }
10168 SYNTAX("mvfc %1, %0");
10169 #line 943 "rx-decode.opc"
10170 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10171
10172 /*----------------------------------------------------------------------*/
10173 /* INTERRUPTS */
10174
10175 }
10176 break;
10177 }
10178 break;
10179 case 0x6b:
10180 GETBYTE ();
10181 switch (op[2] & 0x00)
10182 {
10183 case 0x00:
10184 goto op_semantics_75;
10185 break;
10186 }
10187 break;
10188 case 0x6c:
10189 GETBYTE ();
10190 switch (op[2] & 0x00)
10191 {
10192 case 0x00:
10193 op_semantics_76:
10194 {
10195 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
10196 #line 688 "rx-decode.opc"
10197 int i AU = op[1] & 0x01;
10198 #line 688 "rx-decode.opc"
10199 int mmmm AU = (op[2] >> 4) & 0x0f;
10200 #line 688 "rx-decode.opc"
10201 int rdst AU = op[2] & 0x0f;
10202 if (trace)
10203 {
10204 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10205 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10206 op[0], op[1], op[2]);
10207 printf (" i = 0x%x,", i);
10208 printf (" mmmm = 0x%x,", mmmm);
10209 printf (" rdst = 0x%x\n", rdst);
10210 }
10211 SYNTAX("rotr #%1, %0");
10212 #line 688 "rx-decode.opc"
10213 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
10214
10215 }
10216 break;
10217 }
10218 break;
10219 case 0x6d:
10220 GETBYTE ();
10221 switch (op[2] & 0x00)
10222 {
10223 case 0x00:
10224 goto op_semantics_76;
10225 break;
10226 }
10227 break;
10228 case 0x6e:
10229 GETBYTE ();
10230 switch (op[2] & 0x00)
10231 {
10232 case 0x00:
10233 op_semantics_77:
10234 {
10235 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
10236 #line 682 "rx-decode.opc"
10237 int i AU = op[1] & 0x01;
10238 #line 682 "rx-decode.opc"
10239 int mmmm AU = (op[2] >> 4) & 0x0f;
10240 #line 682 "rx-decode.opc"
10241 int rdst AU = op[2] & 0x0f;
10242 if (trace)
10243 {
10244 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10245 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10246 op[0], op[1], op[2]);
10247 printf (" i = 0x%x,", i);
10248 printf (" mmmm = 0x%x,", mmmm);
10249 printf (" rdst = 0x%x\n", rdst);
10250 }
10251 SYNTAX("rotl #%1, %0");
10252 #line 682 "rx-decode.opc"
10253 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
10254
10255 }
10256 break;
10257 }
10258 break;
10259 case 0x6f:
10260 GETBYTE ();
10261 switch (op[2] & 0x00)
10262 {
10263 case 0x00:
10264 goto op_semantics_77;
10265 break;
10266 }
10267 break;
10268 case 0x70:
10269 GETBYTE ();
10270 switch (op[2] & 0xf0)
10271 {
10272 case 0x20:
10273 op_semantics_78:
10274 {
10275 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
10276 #line 464 "rx-decode.opc"
10277 int im AU = (op[1] >> 2) & 0x03;
10278 #line 464 "rx-decode.opc"
10279 int rdst AU = op[2] & 0x0f;
10280 if (trace)
10281 {
10282 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10283 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10284 op[0], op[1], op[2]);
10285 printf (" im = 0x%x,", im);
10286 printf (" rdst = 0x%x\n", rdst);
10287 }
10288 SYNTAX("adc #%1, %0");
10289 #line 464 "rx-decode.opc"
10290 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
10291
10292 }
10293 break;
10294 case 0x40:
10295 op_semantics_79:
10296 {
10297 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
10298 #line 546 "rx-decode.opc"
10299 int im AU = (op[1] >> 2) & 0x03;
10300 #line 546 "rx-decode.opc"
10301 int rdst AU = op[2] & 0x0f;
10302 if (trace)
10303 {
10304 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10305 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10306 op[0], op[1], op[2]);
10307 printf (" im = 0x%x,", im);
10308 printf (" rdst = 0x%x\n", rdst);
10309 }
10310 SYNTAX("max #%1, %0");
10311 #line 546 "rx-decode.opc"
10312 ID(max); DR(rdst); SC(IMMex(im));
10313
10314 }
10315 break;
10316 case 0x50:
10317 op_semantics_80:
10318 {
10319 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
10320 #line 566 "rx-decode.opc"
10321 int im AU = (op[1] >> 2) & 0x03;
10322 #line 566 "rx-decode.opc"
10323 int rdst AU = op[2] & 0x0f;
10324 if (trace)
10325 {
10326 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10327 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10328 op[0], op[1], op[2]);
10329 printf (" im = 0x%x,", im);
10330 printf (" rdst = 0x%x\n", rdst);
10331 }
10332 SYNTAX("min #%1, %0");
10333 #line 566 "rx-decode.opc"
10334 ID(min); DR(rdst); SC(IMMex(im));
10335
10336 }
10337 break;
10338 case 0x60:
10339 op_semantics_81:
10340 {
10341 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
10342 #line 596 "rx-decode.opc"
10343 int im AU = (op[1] >> 2) & 0x03;
10344 #line 596 "rx-decode.opc"
10345 int rdst AU = op[2] & 0x0f;
10346 if (trace)
10347 {
10348 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10349 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10350 op[0], op[1], op[2]);
10351 printf (" im = 0x%x,", im);
10352 printf (" rdst = 0x%x\n", rdst);
10353 }
10354 SYNTAX("emul #%1, %0");
10355 #line 596 "rx-decode.opc"
10356 ID(emul); DR(rdst); SC(IMMex(im));
10357
10358 }
10359 break;
10360 case 0x70:
10361 op_semantics_82:
10362 {
10363 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
10364 #line 608 "rx-decode.opc"
10365 int im AU = (op[1] >> 2) & 0x03;
10366 #line 608 "rx-decode.opc"
10367 int rdst AU = op[2] & 0x0f;
10368 if (trace)
10369 {
10370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10371 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10372 op[0], op[1], op[2]);
10373 printf (" im = 0x%x,", im);
10374 printf (" rdst = 0x%x\n", rdst);
10375 }
10376 SYNTAX("emulu #%1, %0");
10377 #line 608 "rx-decode.opc"
10378 ID(emulu); DR(rdst); SC(IMMex(im));
10379
10380 }
10381 break;
10382 case 0x80:
10383 op_semantics_83:
10384 {
10385 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
10386 #line 620 "rx-decode.opc"
10387 int im AU = (op[1] >> 2) & 0x03;
10388 #line 620 "rx-decode.opc"
10389 int rdst AU = op[2] & 0x0f;
10390 if (trace)
10391 {
10392 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10393 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10394 op[0], op[1], op[2]);
10395 printf (" im = 0x%x,", im);
10396 printf (" rdst = 0x%x\n", rdst);
10397 }
10398 SYNTAX("div #%1, %0");
10399 #line 620 "rx-decode.opc"
10400 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
10401
10402 }
10403 break;
10404 case 0x90:
10405 op_semantics_84:
10406 {
10407 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
10408 #line 632 "rx-decode.opc"
10409 int im AU = (op[1] >> 2) & 0x03;
10410 #line 632 "rx-decode.opc"
10411 int rdst AU = op[2] & 0x0f;
10412 if (trace)
10413 {
10414 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10415 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10416 op[0], op[1], op[2]);
10417 printf (" im = 0x%x,", im);
10418 printf (" rdst = 0x%x\n", rdst);
10419 }
10420 SYNTAX("divu #%1, %0");
10421 #line 632 "rx-decode.opc"
10422 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
10423
10424 }
10425 break;
10426 case 0xc0:
10427 op_semantics_85:
10428 {
10429 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
10430 #line 443 "rx-decode.opc"
10431 int im AU = (op[1] >> 2) & 0x03;
10432 #line 443 "rx-decode.opc"
10433 int rdst AU = op[2] & 0x0f;
10434 if (trace)
10435 {
10436 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10437 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
10438 op[0], op[1], op[2]);
10439 printf (" im = 0x%x,", im);
10440 printf (" rdst = 0x%x\n", rdst);
10441 }
10442 SYNTAX("tst #%1, %2");
10443 #line 443 "rx-decode.opc"
10444 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
10445
10446 }
10447 break;
10448 case 0xd0:
10449 op_semantics_86:
10450 {
10451 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
10452 #line 422 "rx-decode.opc"
10453 int im AU = (op[1] >> 2) & 0x03;
10454 #line 422 "rx-decode.opc"
10455 int rdst AU = op[2] & 0x0f;
10456 if (trace)
10457 {
10458 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10459 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10460 op[0], op[1], op[2]);
10461 printf (" im = 0x%x,", im);
10462 printf (" rdst = 0x%x\n", rdst);
10463 }
10464 SYNTAX("xor #%1, %0");
10465 #line 422 "rx-decode.opc"
10466 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
10467
10468 }
10469 break;
10470 case 0xe0:
10471 op_semantics_87:
10472 {
10473 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
10474 #line 368 "rx-decode.opc"
10475 int im AU = (op[1] >> 2) & 0x03;
10476 #line 368 "rx-decode.opc"
10477 int rdst AU = op[2] & 0x0f;
10478 if (trace)
10479 {
10480 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10481 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10482 op[0], op[1], op[2]);
10483 printf (" im = 0x%x,", im);
10484 printf (" rdst = 0x%x\n", rdst);
10485 }
10486 SYNTAX("stz #%1, %0");
10487 #line 368 "rx-decode.opc"
10488 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10489
10490 }
10491 break;
10492 case 0xf0:
10493 op_semantics_88:
10494 {
10495 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
10496 #line 371 "rx-decode.opc"
10497 int im AU = (op[1] >> 2) & 0x03;
10498 #line 371 "rx-decode.opc"
10499 int rdst AU = op[2] & 0x0f;
10500 if (trace)
10501 {
10502 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10503 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10504 op[0], op[1], op[2]);
10505 printf (" im = 0x%x,", im);
10506 printf (" rdst = 0x%x\n", rdst);
10507 }
10508 SYNTAX("stnz #%1, %0");
10509 #line 371 "rx-decode.opc"
10510 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10511
10512 /*----------------------------------------------------------------------*/
10513 /* RTSD */
10514
10515 }
10516 break;
10517 default: UNSUPPORTED(); break;
10518 }
10519 break;
10520 case 0x72:
10521 GETBYTE ();
10522 switch (op[2] & 0xf0)
10523 {
10524 case 0x00:
10525 {
10526 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
10527 #line 840 "rx-decode.opc"
10528 int rdst AU = op[2] & 0x0f;
10529 if (trace)
10530 {
10531 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10532 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
10533 op[0], op[1], op[2]);
10534 printf (" rdst = 0x%x\n", rdst);
10535 }
10536 SYNTAX("fsub #%1, %0");
10537 #line 840 "rx-decode.opc"
10538 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
10539
10540 }
10541 break;
10542 case 0x10:
10543 {
10544 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
10545 #line 834 "rx-decode.opc"
10546 int rdst AU = op[2] & 0x0f;
10547 if (trace)
10548 {
10549 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10550 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10551 op[0], op[1], op[2]);
10552 printf (" rdst = 0x%x\n", rdst);
10553 }
10554 SYNTAX("fcmp #%1, %0");
10555 #line 834 "rx-decode.opc"
10556 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
10557
10558 }
10559 break;
10560 case 0x20:
10561 {
10562 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
10563 #line 828 "rx-decode.opc"
10564 int rdst AU = op[2] & 0x0f;
10565 if (trace)
10566 {
10567 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10568 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10569 op[0], op[1], op[2]);
10570 printf (" rdst = 0x%x\n", rdst);
10571 }
10572 SYNTAX("fadd #%1, %0");
10573 #line 828 "rx-decode.opc"
10574 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
10575
10576 }
10577 break;
10578 case 0x30:
10579 {
10580 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
10581 #line 849 "rx-decode.opc"
10582 int rdst AU = op[2] & 0x0f;
10583 if (trace)
10584 {
10585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10586 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10587 op[0], op[1], op[2]);
10588 printf (" rdst = 0x%x\n", rdst);
10589 }
10590 SYNTAX("fmul #%1, %0");
10591 #line 849 "rx-decode.opc"
10592 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
10593
10594 }
10595 break;
10596 case 0x40:
10597 {
10598 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
10599 #line 855 "rx-decode.opc"
10600 int rdst AU = op[2] & 0x0f;
10601 if (trace)
10602 {
10603 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10604 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10605 op[0], op[1], op[2]);
10606 printf (" rdst = 0x%x\n", rdst);
10607 }
10608 SYNTAX("fdiv #%1, %0");
10609 #line 855 "rx-decode.opc"
10610 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
10611
10612 }
10613 break;
10614 default: UNSUPPORTED(); break;
10615 }
10616 break;
10617 case 0x73:
10618 GETBYTE ();
10619 switch (op[2] & 0xe0)
10620 {
10621 case 0x00:
10622 op_semantics_89:
10623 {
10624 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
10625 #line 937 "rx-decode.opc"
10626 int im AU = (op[1] >> 2) & 0x03;
10627 #line 937 "rx-decode.opc"
10628 int crdst AU = op[2] & 0x1f;
10629 if (trace)
10630 {
10631 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10632 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10633 op[0], op[1], op[2]);
10634 printf (" im = 0x%x,", im);
10635 printf (" crdst = 0x%x\n", crdst);
10636 }
10637 SYNTAX("mvtc #%1, %0");
10638 #line 937 "rx-decode.opc"
10639 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10640
10641 }
10642 break;
10643 default: UNSUPPORTED(); break;
10644 }
10645 break;
10646 case 0x74:
10647 GETBYTE ();
10648 switch (op[2] & 0xf0)
10649 {
10650 case 0x20:
10651 goto op_semantics_78;
10652 break;
10653 case 0x40:
10654 goto op_semantics_79;
10655 break;
10656 case 0x50:
10657 goto op_semantics_80;
10658 break;
10659 case 0x60:
10660 goto op_semantics_81;
10661 break;
10662 case 0x70:
10663 goto op_semantics_82;
10664 break;
10665 case 0x80:
10666 goto op_semantics_83;
10667 break;
10668 case 0x90:
10669 goto op_semantics_84;
10670 break;
10671 case 0xc0:
10672 goto op_semantics_85;
10673 break;
10674 case 0xd0:
10675 goto op_semantics_86;
10676 break;
10677 case 0xe0:
10678 goto op_semantics_87;
10679 break;
10680 case 0xf0:
10681 goto op_semantics_88;
10682 break;
10683 default: UNSUPPORTED(); break;
10684 }
10685 break;
10686 case 0x77:
10687 GETBYTE ();
10688 switch (op[2] & 0xe0)
10689 {
10690 case 0x00:
10691 goto op_semantics_89;
10692 break;
10693 default: UNSUPPORTED(); break;
10694 }
10695 break;
10696 case 0x78:
10697 GETBYTE ();
10698 switch (op[2] & 0xf0)
10699 {
10700 case 0x20:
10701 goto op_semantics_78;
10702 break;
10703 case 0x40:
10704 goto op_semantics_79;
10705 break;
10706 case 0x50:
10707 goto op_semantics_80;
10708 break;
10709 case 0x60:
10710 goto op_semantics_81;
10711 break;
10712 case 0x70:
10713 goto op_semantics_82;
10714 break;
10715 case 0x80:
10716 goto op_semantics_83;
10717 break;
10718 case 0x90:
10719 goto op_semantics_84;
10720 break;
10721 case 0xc0:
10722 goto op_semantics_85;
10723 break;
10724 case 0xd0:
10725 goto op_semantics_86;
10726 break;
10727 case 0xe0:
10728 goto op_semantics_87;
10729 break;
10730 case 0xf0:
10731 goto op_semantics_88;
10732 break;
10733 default: UNSUPPORTED(); break;
10734 }
10735 break;
10736 case 0x7b:
10737 GETBYTE ();
10738 switch (op[2] & 0xe0)
10739 {
10740 case 0x00:
10741 goto op_semantics_89;
10742 break;
10743 default: UNSUPPORTED(); break;
10744 }
10745 break;
10746 case 0x7c:
10747 GETBYTE ();
10748 switch (op[2] & 0xf0)
10749 {
10750 case 0x20:
10751 goto op_semantics_78;
10752 break;
10753 case 0x40:
10754 goto op_semantics_79;
10755 break;
10756 case 0x50:
10757 goto op_semantics_80;
10758 break;
10759 case 0x60:
10760 goto op_semantics_81;
10761 break;
10762 case 0x70:
10763 goto op_semantics_82;
10764 break;
10765 case 0x80:
10766 goto op_semantics_83;
10767 break;
10768 case 0x90:
10769 goto op_semantics_84;
10770 break;
10771 case 0xc0:
10772 goto op_semantics_85;
10773 break;
10774 case 0xd0:
10775 goto op_semantics_86;
10776 break;
10777 case 0xe0:
10778 goto op_semantics_87;
10779 break;
10780 case 0xf0:
10781 goto op_semantics_88;
10782 break;
10783 default: UNSUPPORTED(); break;
10784 }
10785 break;
10786 case 0x7f:
10787 GETBYTE ();
10788 switch (op[2] & 0xe0)
10789 {
10790 case 0x00:
10791 goto op_semantics_89;
10792 break;
10793 default: UNSUPPORTED(); break;
10794 }
10795 break;
10796 case 0x80:
10797 GETBYTE ();
10798 switch (op[2] & 0x00)
10799 {
10800 case 0x00:
10801 op_semantics_90:
10802 {
10803 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
10804 #line 670 "rx-decode.opc"
10805 int immmm AU = op[1] & 0x1f;
10806 #line 670 "rx-decode.opc"
10807 int rsrc AU = (op[2] >> 4) & 0x0f;
10808 #line 670 "rx-decode.opc"
10809 int rdst AU = op[2] & 0x0f;
10810 if (trace)
10811 {
10812 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10813 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10814 op[0], op[1], op[2]);
10815 printf (" immmm = 0x%x,", immmm);
10816 printf (" rsrc = 0x%x,", rsrc);
10817 printf (" rdst = 0x%x\n", rdst);
10818 }
10819 SYNTAX("shlr #%2, %1, %0");
10820 #line 670 "rx-decode.opc"
10821 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
10822
10823 /*----------------------------------------------------------------------*/
10824 /* ROTATE */
10825
10826 }
10827 break;
10828 }
10829 break;
10830 case 0x81:
10831 GETBYTE ();
10832 switch (op[2] & 0x00)
10833 {
10834 case 0x00:
10835 goto op_semantics_90;
10836 break;
10837 }
10838 break;
10839 case 0x82:
10840 GETBYTE ();
10841 switch (op[2] & 0x00)
10842 {
10843 case 0x00:
10844 goto op_semantics_90;
10845 break;
10846 }
10847 break;
10848 case 0x83:
10849 GETBYTE ();
10850 switch (op[2] & 0x00)
10851 {
10852 case 0x00:
10853 goto op_semantics_90;
10854 break;
10855 }
10856 break;
10857 case 0x84:
10858 GETBYTE ();
10859 switch (op[2] & 0x00)
10860 {
10861 case 0x00:
10862 goto op_semantics_90;
10863 break;
10864 }
10865 break;
10866 case 0x85:
10867 GETBYTE ();
10868 switch (op[2] & 0x00)
10869 {
10870 case 0x00:
10871 goto op_semantics_90;
10872 break;
10873 }
10874 break;
10875 case 0x86:
10876 GETBYTE ();
10877 switch (op[2] & 0x00)
10878 {
10879 case 0x00:
10880 goto op_semantics_90;
10881 break;
10882 }
10883 break;
10884 case 0x87:
10885 GETBYTE ();
10886 switch (op[2] & 0x00)
10887 {
10888 case 0x00:
10889 goto op_semantics_90;
10890 break;
10891 }
10892 break;
10893 case 0x88:
10894 GETBYTE ();
10895 switch (op[2] & 0x00)
10896 {
10897 case 0x00:
10898 goto op_semantics_90;
10899 break;
10900 }
10901 break;
10902 case 0x89:
10903 GETBYTE ();
10904 switch (op[2] & 0x00)
10905 {
10906 case 0x00:
10907 goto op_semantics_90;
10908 break;
10909 }
10910 break;
10911 case 0x8a:
10912 GETBYTE ();
10913 switch (op[2] & 0x00)
10914 {
10915 case 0x00:
10916 goto op_semantics_90;
10917 break;
10918 }
10919 break;
10920 case 0x8b:
10921 GETBYTE ();
10922 switch (op[2] & 0x00)
10923 {
10924 case 0x00:
10925 goto op_semantics_90;
10926 break;
10927 }
10928 break;
10929 case 0x8c:
10930 GETBYTE ();
10931 switch (op[2] & 0x00)
10932 {
10933 case 0x00:
10934 goto op_semantics_90;
10935 break;
10936 }
10937 break;
10938 case 0x8d:
10939 GETBYTE ();
10940 switch (op[2] & 0x00)
10941 {
10942 case 0x00:
10943 goto op_semantics_90;
10944 break;
10945 }
10946 break;
10947 case 0x8e:
10948 GETBYTE ();
10949 switch (op[2] & 0x00)
10950 {
10951 case 0x00:
10952 goto op_semantics_90;
10953 break;
10954 }
10955 break;
10956 case 0x8f:
10957 GETBYTE ();
10958 switch (op[2] & 0x00)
10959 {
10960 case 0x00:
10961 goto op_semantics_90;
10962 break;
10963 }
10964 break;
10965 case 0x90:
10966 GETBYTE ();
10967 switch (op[2] & 0x00)
10968 {
10969 case 0x00:
10970 goto op_semantics_90;
10971 break;
10972 }
10973 break;
10974 case 0x91:
10975 GETBYTE ();
10976 switch (op[2] & 0x00)
10977 {
10978 case 0x00:
10979 goto op_semantics_90;
10980 break;
10981 }
10982 break;
10983 case 0x92:
10984 GETBYTE ();
10985 switch (op[2] & 0x00)
10986 {
10987 case 0x00:
10988 goto op_semantics_90;
10989 break;
10990 }
10991 break;
10992 case 0x93:
10993 GETBYTE ();
10994 switch (op[2] & 0x00)
10995 {
10996 case 0x00:
10997 goto op_semantics_90;
10998 break;
10999 }
11000 break;
11001 case 0x94:
11002 GETBYTE ();
11003 switch (op[2] & 0x00)
11004 {
11005 case 0x00:
11006 goto op_semantics_90;
11007 break;
11008 }
11009 break;
11010 case 0x95:
11011 GETBYTE ();
11012 switch (op[2] & 0x00)
11013 {
11014 case 0x00:
11015 goto op_semantics_90;
11016 break;
11017 }
11018 break;
11019 case 0x96:
11020 GETBYTE ();
11021 switch (op[2] & 0x00)
11022 {
11023 case 0x00:
11024 goto op_semantics_90;
11025 break;
11026 }
11027 break;
11028 case 0x97:
11029 GETBYTE ();
11030 switch (op[2] & 0x00)
11031 {
11032 case 0x00:
11033 goto op_semantics_90;
11034 break;
11035 }
11036 break;
11037 case 0x98:
11038 GETBYTE ();
11039 switch (op[2] & 0x00)
11040 {
11041 case 0x00:
11042 goto op_semantics_90;
11043 break;
11044 }
11045 break;
11046 case 0x99:
11047 GETBYTE ();
11048 switch (op[2] & 0x00)
11049 {
11050 case 0x00:
11051 goto op_semantics_90;
11052 break;
11053 }
11054 break;
11055 case 0x9a:
11056 GETBYTE ();
11057 switch (op[2] & 0x00)
11058 {
11059 case 0x00:
11060 goto op_semantics_90;
11061 break;
11062 }
11063 break;
11064 case 0x9b:
11065 GETBYTE ();
11066 switch (op[2] & 0x00)
11067 {
11068 case 0x00:
11069 goto op_semantics_90;
11070 break;
11071 }
11072 break;
11073 case 0x9c:
11074 GETBYTE ();
11075 switch (op[2] & 0x00)
11076 {
11077 case 0x00:
11078 goto op_semantics_90;
11079 break;
11080 }
11081 break;
11082 case 0x9d:
11083 GETBYTE ();
11084 switch (op[2] & 0x00)
11085 {
11086 case 0x00:
11087 goto op_semantics_90;
11088 break;
11089 }
11090 break;
11091 case 0x9e:
11092 GETBYTE ();
11093 switch (op[2] & 0x00)
11094 {
11095 case 0x00:
11096 goto op_semantics_90;
11097 break;
11098 }
11099 break;
11100 case 0x9f:
11101 GETBYTE ();
11102 switch (op[2] & 0x00)
11103 {
11104 case 0x00:
11105 goto op_semantics_90;
11106 break;
11107 }
11108 break;
11109 case 0xa0:
11110 GETBYTE ();
11111 switch (op[2] & 0x00)
11112 {
11113 case 0x00:
11114 op_semantics_91:
11115 {
11116 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
11117 #line 660 "rx-decode.opc"
11118 int immmm AU = op[1] & 0x1f;
11119 #line 660 "rx-decode.opc"
11120 int rsrc AU = (op[2] >> 4) & 0x0f;
11121 #line 660 "rx-decode.opc"
11122 int rdst AU = op[2] & 0x0f;
11123 if (trace)
11124 {
11125 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11126 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11127 op[0], op[1], op[2]);
11128 printf (" immmm = 0x%x,", immmm);
11129 printf (" rsrc = 0x%x,", rsrc);
11130 printf (" rdst = 0x%x\n", rdst);
11131 }
11132 SYNTAX("shar #%2, %1, %0");
11133 #line 660 "rx-decode.opc"
11134 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
11135
11136
11137 }
11138 break;
11139 }
11140 break;
11141 case 0xa1:
11142 GETBYTE ();
11143 switch (op[2] & 0x00)
11144 {
11145 case 0x00:
11146 goto op_semantics_91;
11147 break;
11148 }
11149 break;
11150 case 0xa2:
11151 GETBYTE ();
11152 switch (op[2] & 0x00)
11153 {
11154 case 0x00:
11155 goto op_semantics_91;
11156 break;
11157 }
11158 break;
11159 case 0xa3:
11160 GETBYTE ();
11161 switch (op[2] & 0x00)
11162 {
11163 case 0x00:
11164 goto op_semantics_91;
11165 break;
11166 }
11167 break;
11168 case 0xa4:
11169 GETBYTE ();
11170 switch (op[2] & 0x00)
11171 {
11172 case 0x00:
11173 goto op_semantics_91;
11174 break;
11175 }
11176 break;
11177 case 0xa5:
11178 GETBYTE ();
11179 switch (op[2] & 0x00)
11180 {
11181 case 0x00:
11182 goto op_semantics_91;
11183 break;
11184 }
11185 break;
11186 case 0xa6:
11187 GETBYTE ();
11188 switch (op[2] & 0x00)
11189 {
11190 case 0x00:
11191 goto op_semantics_91;
11192 break;
11193 }
11194 break;
11195 case 0xa7:
11196 GETBYTE ();
11197 switch (op[2] & 0x00)
11198 {
11199 case 0x00:
11200 goto op_semantics_91;
11201 break;
11202 }
11203 break;
11204 case 0xa8:
11205 GETBYTE ();
11206 switch (op[2] & 0x00)
11207 {
11208 case 0x00:
11209 goto op_semantics_91;
11210 break;
11211 }
11212 break;
11213 case 0xa9:
11214 GETBYTE ();
11215 switch (op[2] & 0x00)
11216 {
11217 case 0x00:
11218 goto op_semantics_91;
11219 break;
11220 }
11221 break;
11222 case 0xaa:
11223 GETBYTE ();
11224 switch (op[2] & 0x00)
11225 {
11226 case 0x00:
11227 goto op_semantics_91;
11228 break;
11229 }
11230 break;
11231 case 0xab:
11232 GETBYTE ();
11233 switch (op[2] & 0x00)
11234 {
11235 case 0x00:
11236 goto op_semantics_91;
11237 break;
11238 }
11239 break;
11240 case 0xac:
11241 GETBYTE ();
11242 switch (op[2] & 0x00)
11243 {
11244 case 0x00:
11245 goto op_semantics_91;
11246 break;
11247 }
11248 break;
11249 case 0xad:
11250 GETBYTE ();
11251 switch (op[2] & 0x00)
11252 {
11253 case 0x00:
11254 goto op_semantics_91;
11255 break;
11256 }
11257 break;
11258 case 0xae:
11259 GETBYTE ();
11260 switch (op[2] & 0x00)
11261 {
11262 case 0x00:
11263 goto op_semantics_91;
11264 break;
11265 }
11266 break;
11267 case 0xaf:
11268 GETBYTE ();
11269 switch (op[2] & 0x00)
11270 {
11271 case 0x00:
11272 goto op_semantics_91;
11273 break;
11274 }
11275 break;
11276 case 0xb0:
11277 GETBYTE ();
11278 switch (op[2] & 0x00)
11279 {
11280 case 0x00:
11281 goto op_semantics_91;
11282 break;
11283 }
11284 break;
11285 case 0xb1:
11286 GETBYTE ();
11287 switch (op[2] & 0x00)
11288 {
11289 case 0x00:
11290 goto op_semantics_91;
11291 break;
11292 }
11293 break;
11294 case 0xb2:
11295 GETBYTE ();
11296 switch (op[2] & 0x00)
11297 {
11298 case 0x00:
11299 goto op_semantics_91;
11300 break;
11301 }
11302 break;
11303 case 0xb3:
11304 GETBYTE ();
11305 switch (op[2] & 0x00)
11306 {
11307 case 0x00:
11308 goto op_semantics_91;
11309 break;
11310 }
11311 break;
11312 case 0xb4:
11313 GETBYTE ();
11314 switch (op[2] & 0x00)
11315 {
11316 case 0x00:
11317 goto op_semantics_91;
11318 break;
11319 }
11320 break;
11321 case 0xb5:
11322 GETBYTE ();
11323 switch (op[2] & 0x00)
11324 {
11325 case 0x00:
11326 goto op_semantics_91;
11327 break;
11328 }
11329 break;
11330 case 0xb6:
11331 GETBYTE ();
11332 switch (op[2] & 0x00)
11333 {
11334 case 0x00:
11335 goto op_semantics_91;
11336 break;
11337 }
11338 break;
11339 case 0xb7:
11340 GETBYTE ();
11341 switch (op[2] & 0x00)
11342 {
11343 case 0x00:
11344 goto op_semantics_91;
11345 break;
11346 }
11347 break;
11348 case 0xb8:
11349 GETBYTE ();
11350 switch (op[2] & 0x00)
11351 {
11352 case 0x00:
11353 goto op_semantics_91;
11354 break;
11355 }
11356 break;
11357 case 0xb9:
11358 GETBYTE ();
11359 switch (op[2] & 0x00)
11360 {
11361 case 0x00:
11362 goto op_semantics_91;
11363 break;
11364 }
11365 break;
11366 case 0xba:
11367 GETBYTE ();
11368 switch (op[2] & 0x00)
11369 {
11370 case 0x00:
11371 goto op_semantics_91;
11372 break;
11373 }
11374 break;
11375 case 0xbb:
11376 GETBYTE ();
11377 switch (op[2] & 0x00)
11378 {
11379 case 0x00:
11380 goto op_semantics_91;
11381 break;
11382 }
11383 break;
11384 case 0xbc:
11385 GETBYTE ();
11386 switch (op[2] & 0x00)
11387 {
11388 case 0x00:
11389 goto op_semantics_91;
11390 break;
11391 }
11392 break;
11393 case 0xbd:
11394 GETBYTE ();
11395 switch (op[2] & 0x00)
11396 {
11397 case 0x00:
11398 goto op_semantics_91;
11399 break;
11400 }
11401 break;
11402 case 0xbe:
11403 GETBYTE ();
11404 switch (op[2] & 0x00)
11405 {
11406 case 0x00:
11407 goto op_semantics_91;
11408 break;
11409 }
11410 break;
11411 case 0xbf:
11412 GETBYTE ();
11413 switch (op[2] & 0x00)
11414 {
11415 case 0x00:
11416 goto op_semantics_91;
11417 break;
11418 }
11419 break;
11420 case 0xc0:
11421 GETBYTE ();
11422 switch (op[2] & 0x00)
11423 {
11424 case 0x00:
11425 op_semantics_92:
11426 {
11427 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
11428 #line 650 "rx-decode.opc"
11429 int immmm AU = op[1] & 0x1f;
11430 #line 650 "rx-decode.opc"
11431 int rsrc AU = (op[2] >> 4) & 0x0f;
11432 #line 650 "rx-decode.opc"
11433 int rdst AU = op[2] & 0x0f;
11434 if (trace)
11435 {
11436 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11437 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11438 op[0], op[1], op[2]);
11439 printf (" immmm = 0x%x,", immmm);
11440 printf (" rsrc = 0x%x,", rsrc);
11441 printf (" rdst = 0x%x\n", rdst);
11442 }
11443 SYNTAX("shll #%2, %1, %0");
11444 #line 650 "rx-decode.opc"
11445 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
11446
11447
11448 }
11449 break;
11450 }
11451 break;
11452 case 0xc1:
11453 GETBYTE ();
11454 switch (op[2] & 0x00)
11455 {
11456 case 0x00:
11457 goto op_semantics_92;
11458 break;
11459 }
11460 break;
11461 case 0xc2:
11462 GETBYTE ();
11463 switch (op[2] & 0x00)
11464 {
11465 case 0x00:
11466 goto op_semantics_92;
11467 break;
11468 }
11469 break;
11470 case 0xc3:
11471 GETBYTE ();
11472 switch (op[2] & 0x00)
11473 {
11474 case 0x00:
11475 goto op_semantics_92;
11476 break;
11477 }
11478 break;
11479 case 0xc4:
11480 GETBYTE ();
11481 switch (op[2] & 0x00)
11482 {
11483 case 0x00:
11484 goto op_semantics_92;
11485 break;
11486 }
11487 break;
11488 case 0xc5:
11489 GETBYTE ();
11490 switch (op[2] & 0x00)
11491 {
11492 case 0x00:
11493 goto op_semantics_92;
11494 break;
11495 }
11496 break;
11497 case 0xc6:
11498 GETBYTE ();
11499 switch (op[2] & 0x00)
11500 {
11501 case 0x00:
11502 goto op_semantics_92;
11503 break;
11504 }
11505 break;
11506 case 0xc7:
11507 GETBYTE ();
11508 switch (op[2] & 0x00)
11509 {
11510 case 0x00:
11511 goto op_semantics_92;
11512 break;
11513 }
11514 break;
11515 case 0xc8:
11516 GETBYTE ();
11517 switch (op[2] & 0x00)
11518 {
11519 case 0x00:
11520 goto op_semantics_92;
11521 break;
11522 }
11523 break;
11524 case 0xc9:
11525 GETBYTE ();
11526 switch (op[2] & 0x00)
11527 {
11528 case 0x00:
11529 goto op_semantics_92;
11530 break;
11531 }
11532 break;
11533 case 0xca:
11534 GETBYTE ();
11535 switch (op[2] & 0x00)
11536 {
11537 case 0x00:
11538 goto op_semantics_92;
11539 break;
11540 }
11541 break;
11542 case 0xcb:
11543 GETBYTE ();
11544 switch (op[2] & 0x00)
11545 {
11546 case 0x00:
11547 goto op_semantics_92;
11548 break;
11549 }
11550 break;
11551 case 0xcc:
11552 GETBYTE ();
11553 switch (op[2] & 0x00)
11554 {
11555 case 0x00:
11556 goto op_semantics_92;
11557 break;
11558 }
11559 break;
11560 case 0xcd:
11561 GETBYTE ();
11562 switch (op[2] & 0x00)
11563 {
11564 case 0x00:
11565 goto op_semantics_92;
11566 break;
11567 }
11568 break;
11569 case 0xce:
11570 GETBYTE ();
11571 switch (op[2] & 0x00)
11572 {
11573 case 0x00:
11574 goto op_semantics_92;
11575 break;
11576 }
11577 break;
11578 case 0xcf:
11579 GETBYTE ();
11580 switch (op[2] & 0x00)
11581 {
11582 case 0x00:
11583 goto op_semantics_92;
11584 break;
11585 }
11586 break;
11587 case 0xd0:
11588 GETBYTE ();
11589 switch (op[2] & 0x00)
11590 {
11591 case 0x00:
11592 goto op_semantics_92;
11593 break;
11594 }
11595 break;
11596 case 0xd1:
11597 GETBYTE ();
11598 switch (op[2] & 0x00)
11599 {
11600 case 0x00:
11601 goto op_semantics_92;
11602 break;
11603 }
11604 break;
11605 case 0xd2:
11606 GETBYTE ();
11607 switch (op[2] & 0x00)
11608 {
11609 case 0x00:
11610 goto op_semantics_92;
11611 break;
11612 }
11613 break;
11614 case 0xd3:
11615 GETBYTE ();
11616 switch (op[2] & 0x00)
11617 {
11618 case 0x00:
11619 goto op_semantics_92;
11620 break;
11621 }
11622 break;
11623 case 0xd4:
11624 GETBYTE ();
11625 switch (op[2] & 0x00)
11626 {
11627 case 0x00:
11628 goto op_semantics_92;
11629 break;
11630 }
11631 break;
11632 case 0xd5:
11633 GETBYTE ();
11634 switch (op[2] & 0x00)
11635 {
11636 case 0x00:
11637 goto op_semantics_92;
11638 break;
11639 }
11640 break;
11641 case 0xd6:
11642 GETBYTE ();
11643 switch (op[2] & 0x00)
11644 {
11645 case 0x00:
11646 goto op_semantics_92;
11647 break;
11648 }
11649 break;
11650 case 0xd7:
11651 GETBYTE ();
11652 switch (op[2] & 0x00)
11653 {
11654 case 0x00:
11655 goto op_semantics_92;
11656 break;
11657 }
11658 break;
11659 case 0xd8:
11660 GETBYTE ();
11661 switch (op[2] & 0x00)
11662 {
11663 case 0x00:
11664 goto op_semantics_92;
11665 break;
11666 }
11667 break;
11668 case 0xd9:
11669 GETBYTE ();
11670 switch (op[2] & 0x00)
11671 {
11672 case 0x00:
11673 goto op_semantics_92;
11674 break;
11675 }
11676 break;
11677 case 0xda:
11678 GETBYTE ();
11679 switch (op[2] & 0x00)
11680 {
11681 case 0x00:
11682 goto op_semantics_92;
11683 break;
11684 }
11685 break;
11686 case 0xdb:
11687 GETBYTE ();
11688 switch (op[2] & 0x00)
11689 {
11690 case 0x00:
11691 goto op_semantics_92;
11692 break;
11693 }
11694 break;
11695 case 0xdc:
11696 GETBYTE ();
11697 switch (op[2] & 0x00)
11698 {
11699 case 0x00:
11700 goto op_semantics_92;
11701 break;
11702 }
11703 break;
11704 case 0xdd:
11705 GETBYTE ();
11706 switch (op[2] & 0x00)
11707 {
11708 case 0x00:
11709 goto op_semantics_92;
11710 break;
11711 }
11712 break;
11713 case 0xde:
11714 GETBYTE ();
11715 switch (op[2] & 0x00)
11716 {
11717 case 0x00:
11718 goto op_semantics_92;
11719 break;
11720 }
11721 break;
11722 case 0xdf:
11723 GETBYTE ();
11724 switch (op[2] & 0x00)
11725 {
11726 case 0x00:
11727 goto op_semantics_92;
11728 break;
11729 }
11730 break;
11731 case 0xe0:
11732 GETBYTE ();
11733 switch (op[2] & 0xf0)
11734 {
11735 case 0x00:
11736 case 0x10:
11737 case 0x20:
11738 case 0x30:
11739 case 0x40:
11740 case 0x50:
11741 case 0x60:
11742 case 0x70:
11743 case 0x80:
11744 case 0x90:
11745 case 0xa0:
11746 case 0xb0:
11747 case 0xc0:
11748 case 0xd0:
11749 case 0xe0:
11750 op_semantics_93:
11751 {
11752 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
11753 #line 916 "rx-decode.opc"
11754 int bittt AU = op[1] & 0x1f;
11755 #line 916 "rx-decode.opc"
11756 int cond AU = (op[2] >> 4) & 0x0f;
11757 #line 916 "rx-decode.opc"
11758 int rdst AU = op[2] & 0x0f;
11759 if (trace)
11760 {
11761 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11762 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11763 op[0], op[1], op[2]);
11764 printf (" bittt = 0x%x,", bittt);
11765 printf (" cond = 0x%x,", cond);
11766 printf (" rdst = 0x%x\n", rdst);
11767 }
11768 SYNTAX("bm%2 #%1, %0%S0");
11769 #line 916 "rx-decode.opc"
11770 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11771
11772 /*----------------------------------------------------------------------*/
11773 /* CONTROL REGISTERS */
11774
11775 }
11776 break;
11777 case 0xf0:
11778 op_semantics_94:
11779 {
11780 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
11781 #line 909 "rx-decode.opc"
11782 int bittt AU = op[1] & 0x1f;
11783 #line 909 "rx-decode.opc"
11784 int rdst AU = op[2] & 0x0f;
11785 if (trace)
11786 {
11787 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11788 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11789 op[0], op[1], op[2]);
11790 printf (" bittt = 0x%x,", bittt);
11791 printf (" rdst = 0x%x\n", rdst);
11792 }
11793 SYNTAX("bnot #%1, %0");
11794 #line 909 "rx-decode.opc"
11795 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11796
11797
11798 }
11799 break;
11800 }
11801 break;
11802 case 0xe1:
11803 GETBYTE ();
11804 switch (op[2] & 0xf0)
11805 {
11806 case 0x00:
11807 case 0x10:
11808 case 0x20:
11809 case 0x30:
11810 case 0x40:
11811 case 0x50:
11812 case 0x60:
11813 case 0x70:
11814 case 0x80:
11815 case 0x90:
11816 case 0xa0:
11817 case 0xb0:
11818 case 0xc0:
11819 case 0xd0:
11820 case 0xe0:
11821 goto op_semantics_93;
11822 break;
11823 case 0xf0:
11824 goto op_semantics_94;
11825 break;
11826 }
11827 break;
11828 case 0xe2:
11829 GETBYTE ();
11830 switch (op[2] & 0xf0)
11831 {
11832 case 0x00:
11833 case 0x10:
11834 case 0x20:
11835 case 0x30:
11836 case 0x40:
11837 case 0x50:
11838 case 0x60:
11839 case 0x70:
11840 case 0x80:
11841 case 0x90:
11842 case 0xa0:
11843 case 0xb0:
11844 case 0xc0:
11845 case 0xd0:
11846 case 0xe0:
11847 goto op_semantics_93;
11848 break;
11849 case 0xf0:
11850 goto op_semantics_94;
11851 break;
11852 }
11853 break;
11854 case 0xe3:
11855 GETBYTE ();
11856 switch (op[2] & 0xf0)
11857 {
11858 case 0x00:
11859 case 0x10:
11860 case 0x20:
11861 case 0x30:
11862 case 0x40:
11863 case 0x50:
11864 case 0x60:
11865 case 0x70:
11866 case 0x80:
11867 case 0x90:
11868 case 0xa0:
11869 case 0xb0:
11870 case 0xc0:
11871 case 0xd0:
11872 case 0xe0:
11873 goto op_semantics_93;
11874 break;
11875 case 0xf0:
11876 goto op_semantics_94;
11877 break;
11878 }
11879 break;
11880 case 0xe4:
11881 GETBYTE ();
11882 switch (op[2] & 0xf0)
11883 {
11884 case 0x00:
11885 case 0x10:
11886 case 0x20:
11887 case 0x30:
11888 case 0x40:
11889 case 0x50:
11890 case 0x60:
11891 case 0x70:
11892 case 0x80:
11893 case 0x90:
11894 case 0xa0:
11895 case 0xb0:
11896 case 0xc0:
11897 case 0xd0:
11898 case 0xe0:
11899 goto op_semantics_93;
11900 break;
11901 case 0xf0:
11902 goto op_semantics_94;
11903 break;
11904 }
11905 break;
11906 case 0xe5:
11907 GETBYTE ();
11908 switch (op[2] & 0xf0)
11909 {
11910 case 0x00:
11911 case 0x10:
11912 case 0x20:
11913 case 0x30:
11914 case 0x40:
11915 case 0x50:
11916 case 0x60:
11917 case 0x70:
11918 case 0x80:
11919 case 0x90:
11920 case 0xa0:
11921 case 0xb0:
11922 case 0xc0:
11923 case 0xd0:
11924 case 0xe0:
11925 goto op_semantics_93;
11926 break;
11927 case 0xf0:
11928 goto op_semantics_94;
11929 break;
11930 }
11931 break;
11932 case 0xe6:
11933 GETBYTE ();
11934 switch (op[2] & 0xf0)
11935 {
11936 case 0x00:
11937 case 0x10:
11938 case 0x20:
11939 case 0x30:
11940 case 0x40:
11941 case 0x50:
11942 case 0x60:
11943 case 0x70:
11944 case 0x80:
11945 case 0x90:
11946 case 0xa0:
11947 case 0xb0:
11948 case 0xc0:
11949 case 0xd0:
11950 case 0xe0:
11951 goto op_semantics_93;
11952 break;
11953 case 0xf0:
11954 goto op_semantics_94;
11955 break;
11956 }
11957 break;
11958 case 0xe7:
11959 GETBYTE ();
11960 switch (op[2] & 0xf0)
11961 {
11962 case 0x00:
11963 case 0x10:
11964 case 0x20:
11965 case 0x30:
11966 case 0x40:
11967 case 0x50:
11968 case 0x60:
11969 case 0x70:
11970 case 0x80:
11971 case 0x90:
11972 case 0xa0:
11973 case 0xb0:
11974 case 0xc0:
11975 case 0xd0:
11976 case 0xe0:
11977 goto op_semantics_93;
11978 break;
11979 case 0xf0:
11980 goto op_semantics_94;
11981 break;
11982 }
11983 break;
11984 case 0xe8:
11985 GETBYTE ();
11986 switch (op[2] & 0xf0)
11987 {
11988 case 0x00:
11989 case 0x10:
11990 case 0x20:
11991 case 0x30:
11992 case 0x40:
11993 case 0x50:
11994 case 0x60:
11995 case 0x70:
11996 case 0x80:
11997 case 0x90:
11998 case 0xa0:
11999 case 0xb0:
12000 case 0xc0:
12001 case 0xd0:
12002 case 0xe0:
12003 goto op_semantics_93;
12004 break;
12005 case 0xf0:
12006 goto op_semantics_94;
12007 break;
12008 }
12009 break;
12010 case 0xe9:
12011 GETBYTE ();
12012 switch (op[2] & 0xf0)
12013 {
12014 case 0x00:
12015 case 0x10:
12016 case 0x20:
12017 case 0x30:
12018 case 0x40:
12019 case 0x50:
12020 case 0x60:
12021 case 0x70:
12022 case 0x80:
12023 case 0x90:
12024 case 0xa0:
12025 case 0xb0:
12026 case 0xc0:
12027 case 0xd0:
12028 case 0xe0:
12029 goto op_semantics_93;
12030 break;
12031 case 0xf0:
12032 goto op_semantics_94;
12033 break;
12034 }
12035 break;
12036 case 0xea:
12037 GETBYTE ();
12038 switch (op[2] & 0xf0)
12039 {
12040 case 0x00:
12041 case 0x10:
12042 case 0x20:
12043 case 0x30:
12044 case 0x40:
12045 case 0x50:
12046 case 0x60:
12047 case 0x70:
12048 case 0x80:
12049 case 0x90:
12050 case 0xa0:
12051 case 0xb0:
12052 case 0xc0:
12053 case 0xd0:
12054 case 0xe0:
12055 goto op_semantics_93;
12056 break;
12057 case 0xf0:
12058 goto op_semantics_94;
12059 break;
12060 }
12061 break;
12062 case 0xeb:
12063 GETBYTE ();
12064 switch (op[2] & 0xf0)
12065 {
12066 case 0x00:
12067 case 0x10:
12068 case 0x20:
12069 case 0x30:
12070 case 0x40:
12071 case 0x50:
12072 case 0x60:
12073 case 0x70:
12074 case 0x80:
12075 case 0x90:
12076 case 0xa0:
12077 case 0xb0:
12078 case 0xc0:
12079 case 0xd0:
12080 case 0xe0:
12081 goto op_semantics_93;
12082 break;
12083 case 0xf0:
12084 goto op_semantics_94;
12085 break;
12086 }
12087 break;
12088 case 0xec:
12089 GETBYTE ();
12090 switch (op[2] & 0xf0)
12091 {
12092 case 0x00:
12093 case 0x10:
12094 case 0x20:
12095 case 0x30:
12096 case 0x40:
12097 case 0x50:
12098 case 0x60:
12099 case 0x70:
12100 case 0x80:
12101 case 0x90:
12102 case 0xa0:
12103 case 0xb0:
12104 case 0xc0:
12105 case 0xd0:
12106 case 0xe0:
12107 goto op_semantics_93;
12108 break;
12109 case 0xf0:
12110 goto op_semantics_94;
12111 break;
12112 }
12113 break;
12114 case 0xed:
12115 GETBYTE ();
12116 switch (op[2] & 0xf0)
12117 {
12118 case 0x00:
12119 case 0x10:
12120 case 0x20:
12121 case 0x30:
12122 case 0x40:
12123 case 0x50:
12124 case 0x60:
12125 case 0x70:
12126 case 0x80:
12127 case 0x90:
12128 case 0xa0:
12129 case 0xb0:
12130 case 0xc0:
12131 case 0xd0:
12132 case 0xe0:
12133 goto op_semantics_93;
12134 break;
12135 case 0xf0:
12136 goto op_semantics_94;
12137 break;
12138 }
12139 break;
12140 case 0xee:
12141 GETBYTE ();
12142 switch (op[2] & 0xf0)
12143 {
12144 case 0x00:
12145 case 0x10:
12146 case 0x20:
12147 case 0x30:
12148 case 0x40:
12149 case 0x50:
12150 case 0x60:
12151 case 0x70:
12152 case 0x80:
12153 case 0x90:
12154 case 0xa0:
12155 case 0xb0:
12156 case 0xc0:
12157 case 0xd0:
12158 case 0xe0:
12159 goto op_semantics_93;
12160 break;
12161 case 0xf0:
12162 goto op_semantics_94;
12163 break;
12164 }
12165 break;
12166 case 0xef:
12167 GETBYTE ();
12168 switch (op[2] & 0xf0)
12169 {
12170 case 0x00:
12171 case 0x10:
12172 case 0x20:
12173 case 0x30:
12174 case 0x40:
12175 case 0x50:
12176 case 0x60:
12177 case 0x70:
12178 case 0x80:
12179 case 0x90:
12180 case 0xa0:
12181 case 0xb0:
12182 case 0xc0:
12183 case 0xd0:
12184 case 0xe0:
12185 goto op_semantics_93;
12186 break;
12187 case 0xf0:
12188 goto op_semantics_94;
12189 break;
12190 }
12191 break;
12192 case 0xf0:
12193 GETBYTE ();
12194 switch (op[2] & 0xf0)
12195 {
12196 case 0x00:
12197 case 0x10:
12198 case 0x20:
12199 case 0x30:
12200 case 0x40:
12201 case 0x50:
12202 case 0x60:
12203 case 0x70:
12204 case 0x80:
12205 case 0x90:
12206 case 0xa0:
12207 case 0xb0:
12208 case 0xc0:
12209 case 0xd0:
12210 case 0xe0:
12211 goto op_semantics_93;
12212 break;
12213 case 0xf0:
12214 goto op_semantics_94;
12215 break;
12216 }
12217 break;
12218 case 0xf1:
12219 GETBYTE ();
12220 switch (op[2] & 0xf0)
12221 {
12222 case 0x00:
12223 case 0x10:
12224 case 0x20:
12225 case 0x30:
12226 case 0x40:
12227 case 0x50:
12228 case 0x60:
12229 case 0x70:
12230 case 0x80:
12231 case 0x90:
12232 case 0xa0:
12233 case 0xb0:
12234 case 0xc0:
12235 case 0xd0:
12236 case 0xe0:
12237 goto op_semantics_93;
12238 break;
12239 case 0xf0:
12240 goto op_semantics_94;
12241 break;
12242 }
12243 break;
12244 case 0xf2:
12245 GETBYTE ();
12246 switch (op[2] & 0xf0)
12247 {
12248 case 0x00:
12249 case 0x10:
12250 case 0x20:
12251 case 0x30:
12252 case 0x40:
12253 case 0x50:
12254 case 0x60:
12255 case 0x70:
12256 case 0x80:
12257 case 0x90:
12258 case 0xa0:
12259 case 0xb0:
12260 case 0xc0:
12261 case 0xd0:
12262 case 0xe0:
12263 goto op_semantics_93;
12264 break;
12265 case 0xf0:
12266 goto op_semantics_94;
12267 break;
12268 }
12269 break;
12270 case 0xf3:
12271 GETBYTE ();
12272 switch (op[2] & 0xf0)
12273 {
12274 case 0x00:
12275 case 0x10:
12276 case 0x20:
12277 case 0x30:
12278 case 0x40:
12279 case 0x50:
12280 case 0x60:
12281 case 0x70:
12282 case 0x80:
12283 case 0x90:
12284 case 0xa0:
12285 case 0xb0:
12286 case 0xc0:
12287 case 0xd0:
12288 case 0xe0:
12289 goto op_semantics_93;
12290 break;
12291 case 0xf0:
12292 goto op_semantics_94;
12293 break;
12294 }
12295 break;
12296 case 0xf4:
12297 GETBYTE ();
12298 switch (op[2] & 0xf0)
12299 {
12300 case 0x00:
12301 case 0x10:
12302 case 0x20:
12303 case 0x30:
12304 case 0x40:
12305 case 0x50:
12306 case 0x60:
12307 case 0x70:
12308 case 0x80:
12309 case 0x90:
12310 case 0xa0:
12311 case 0xb0:
12312 case 0xc0:
12313 case 0xd0:
12314 case 0xe0:
12315 goto op_semantics_93;
12316 break;
12317 case 0xf0:
12318 goto op_semantics_94;
12319 break;
12320 }
12321 break;
12322 case 0xf5:
12323 GETBYTE ();
12324 switch (op[2] & 0xf0)
12325 {
12326 case 0x00:
12327 case 0x10:
12328 case 0x20:
12329 case 0x30:
12330 case 0x40:
12331 case 0x50:
12332 case 0x60:
12333 case 0x70:
12334 case 0x80:
12335 case 0x90:
12336 case 0xa0:
12337 case 0xb0:
12338 case 0xc0:
12339 case 0xd0:
12340 case 0xe0:
12341 goto op_semantics_93;
12342 break;
12343 case 0xf0:
12344 goto op_semantics_94;
12345 break;
12346 }
12347 break;
12348 case 0xf6:
12349 GETBYTE ();
12350 switch (op[2] & 0xf0)
12351 {
12352 case 0x00:
12353 case 0x10:
12354 case 0x20:
12355 case 0x30:
12356 case 0x40:
12357 case 0x50:
12358 case 0x60:
12359 case 0x70:
12360 case 0x80:
12361 case 0x90:
12362 case 0xa0:
12363 case 0xb0:
12364 case 0xc0:
12365 case 0xd0:
12366 case 0xe0:
12367 goto op_semantics_93;
12368 break;
12369 case 0xf0:
12370 goto op_semantics_94;
12371 break;
12372 }
12373 break;
12374 case 0xf7:
12375 GETBYTE ();
12376 switch (op[2] & 0xf0)
12377 {
12378 case 0x00:
12379 case 0x10:
12380 case 0x20:
12381 case 0x30:
12382 case 0x40:
12383 case 0x50:
12384 case 0x60:
12385 case 0x70:
12386 case 0x80:
12387 case 0x90:
12388 case 0xa0:
12389 case 0xb0:
12390 case 0xc0:
12391 case 0xd0:
12392 case 0xe0:
12393 goto op_semantics_93;
12394 break;
12395 case 0xf0:
12396 goto op_semantics_94;
12397 break;
12398 }
12399 break;
12400 case 0xf8:
12401 GETBYTE ();
12402 switch (op[2] & 0xf0)
12403 {
12404 case 0x00:
12405 case 0x10:
12406 case 0x20:
12407 case 0x30:
12408 case 0x40:
12409 case 0x50:
12410 case 0x60:
12411 case 0x70:
12412 case 0x80:
12413 case 0x90:
12414 case 0xa0:
12415 case 0xb0:
12416 case 0xc0:
12417 case 0xd0:
12418 case 0xe0:
12419 goto op_semantics_93;
12420 break;
12421 case 0xf0:
12422 goto op_semantics_94;
12423 break;
12424 }
12425 break;
12426 case 0xf9:
12427 GETBYTE ();
12428 switch (op[2] & 0xf0)
12429 {
12430 case 0x00:
12431 case 0x10:
12432 case 0x20:
12433 case 0x30:
12434 case 0x40:
12435 case 0x50:
12436 case 0x60:
12437 case 0x70:
12438 case 0x80:
12439 case 0x90:
12440 case 0xa0:
12441 case 0xb0:
12442 case 0xc0:
12443 case 0xd0:
12444 case 0xe0:
12445 goto op_semantics_93;
12446 break;
12447 case 0xf0:
12448 goto op_semantics_94;
12449 break;
12450 }
12451 break;
12452 case 0xfa:
12453 GETBYTE ();
12454 switch (op[2] & 0xf0)
12455 {
12456 case 0x00:
12457 case 0x10:
12458 case 0x20:
12459 case 0x30:
12460 case 0x40:
12461 case 0x50:
12462 case 0x60:
12463 case 0x70:
12464 case 0x80:
12465 case 0x90:
12466 case 0xa0:
12467 case 0xb0:
12468 case 0xc0:
12469 case 0xd0:
12470 case 0xe0:
12471 goto op_semantics_93;
12472 break;
12473 case 0xf0:
12474 goto op_semantics_94;
12475 break;
12476 }
12477 break;
12478 case 0xfb:
12479 GETBYTE ();
12480 switch (op[2] & 0xf0)
12481 {
12482 case 0x00:
12483 case 0x10:
12484 case 0x20:
12485 case 0x30:
12486 case 0x40:
12487 case 0x50:
12488 case 0x60:
12489 case 0x70:
12490 case 0x80:
12491 case 0x90:
12492 case 0xa0:
12493 case 0xb0:
12494 case 0xc0:
12495 case 0xd0:
12496 case 0xe0:
12497 goto op_semantics_93;
12498 break;
12499 case 0xf0:
12500 goto op_semantics_94;
12501 break;
12502 }
12503 break;
12504 case 0xfc:
12505 GETBYTE ();
12506 switch (op[2] & 0xf0)
12507 {
12508 case 0x00:
12509 case 0x10:
12510 case 0x20:
12511 case 0x30:
12512 case 0x40:
12513 case 0x50:
12514 case 0x60:
12515 case 0x70:
12516 case 0x80:
12517 case 0x90:
12518 case 0xa0:
12519 case 0xb0:
12520 case 0xc0:
12521 case 0xd0:
12522 case 0xe0:
12523 goto op_semantics_93;
12524 break;
12525 case 0xf0:
12526 goto op_semantics_94;
12527 break;
12528 }
12529 break;
12530 case 0xfd:
12531 GETBYTE ();
12532 switch (op[2] & 0xf0)
12533 {
12534 case 0x00:
12535 case 0x10:
12536 case 0x20:
12537 case 0x30:
12538 case 0x40:
12539 case 0x50:
12540 case 0x60:
12541 case 0x70:
12542 case 0x80:
12543 case 0x90:
12544 case 0xa0:
12545 case 0xb0:
12546 case 0xc0:
12547 case 0xd0:
12548 case 0xe0:
12549 goto op_semantics_93;
12550 break;
12551 case 0xf0:
12552 goto op_semantics_94;
12553 break;
12554 }
12555 break;
12556 case 0xfe:
12557 GETBYTE ();
12558 switch (op[2] & 0xf0)
12559 {
12560 case 0x00:
12561 case 0x10:
12562 case 0x20:
12563 case 0x30:
12564 case 0x40:
12565 case 0x50:
12566 case 0x60:
12567 case 0x70:
12568 case 0x80:
12569 case 0x90:
12570 case 0xa0:
12571 case 0xb0:
12572 case 0xc0:
12573 case 0xd0:
12574 case 0xe0:
12575 goto op_semantics_93;
12576 break;
12577 case 0xf0:
12578 goto op_semantics_94;
12579 break;
12580 }
12581 break;
12582 case 0xff:
12583 GETBYTE ();
12584 switch (op[2] & 0xf0)
12585 {
12586 case 0x00:
12587 case 0x10:
12588 case 0x20:
12589 case 0x30:
12590 case 0x40:
12591 case 0x50:
12592 case 0x60:
12593 case 0x70:
12594 case 0x80:
12595 case 0x90:
12596 case 0xa0:
12597 case 0xb0:
12598 case 0xc0:
12599 case 0xd0:
12600 case 0xe0:
12601 goto op_semantics_93;
12602 break;
12603 case 0xf0:
12604 goto op_semantics_94;
12605 break;
12606 }
12607 break;
12608 default: UNSUPPORTED(); break;
12609 }
12610 break;
12611 case 0xfe:
12612 GETBYTE ();
12613 switch (op[1] & 0xff)
12614 {
12615 case 0x00:
12616 GETBYTE ();
12617 switch (op[2] & 0x00)
12618 {
12619 case 0x00:
12620 op_semantics_95:
12621 {
12622 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
12623 #line 314 "rx-decode.opc"
12624 int sz AU = (op[1] >> 4) & 0x03;
12625 #line 314 "rx-decode.opc"
12626 int isrc AU = op[1] & 0x0f;
12627 #line 314 "rx-decode.opc"
12628 int bsrc AU = (op[2] >> 4) & 0x0f;
12629 #line 314 "rx-decode.opc"
12630 int rdst AU = op[2] & 0x0f;
12631 if (trace)
12632 {
12633 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12634 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12635 op[0], op[1], op[2]);
12636 printf (" sz = 0x%x,", sz);
12637 printf (" isrc = 0x%x,", isrc);
12638 printf (" bsrc = 0x%x,", bsrc);
12639 printf (" rdst = 0x%x\n", rdst);
12640 }
12641 SYNTAX("mov%s %0, [%1, %2]");
12642 #line 314 "rx-decode.opc"
12643 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
12644
12645 }
12646 break;
12647 }
12648 break;
12649 case 0x01:
12650 GETBYTE ();
12651 switch (op[2] & 0x00)
12652 {
12653 case 0x00:
12654 goto op_semantics_95;
12655 break;
12656 }
12657 break;
12658 case 0x02:
12659 GETBYTE ();
12660 switch (op[2] & 0x00)
12661 {
12662 case 0x00:
12663 goto op_semantics_95;
12664 break;
12665 }
12666 break;
12667 case 0x03:
12668 GETBYTE ();
12669 switch (op[2] & 0x00)
12670 {
12671 case 0x00:
12672 goto op_semantics_95;
12673 break;
12674 }
12675 break;
12676 case 0x04:
12677 GETBYTE ();
12678 switch (op[2] & 0x00)
12679 {
12680 case 0x00:
12681 goto op_semantics_95;
12682 break;
12683 }
12684 break;
12685 case 0x05:
12686 GETBYTE ();
12687 switch (op[2] & 0x00)
12688 {
12689 case 0x00:
12690 goto op_semantics_95;
12691 break;
12692 }
12693 break;
12694 case 0x06:
12695 GETBYTE ();
12696 switch (op[2] & 0x00)
12697 {
12698 case 0x00:
12699 goto op_semantics_95;
12700 break;
12701 }
12702 break;
12703 case 0x07:
12704 GETBYTE ();
12705 switch (op[2] & 0x00)
12706 {
12707 case 0x00:
12708 goto op_semantics_95;
12709 break;
12710 }
12711 break;
12712 case 0x08:
12713 GETBYTE ();
12714 switch (op[2] & 0x00)
12715 {
12716 case 0x00:
12717 goto op_semantics_95;
12718 break;
12719 }
12720 break;
12721 case 0x09:
12722 GETBYTE ();
12723 switch (op[2] & 0x00)
12724 {
12725 case 0x00:
12726 goto op_semantics_95;
12727 break;
12728 }
12729 break;
12730 case 0x0a:
12731 GETBYTE ();
12732 switch (op[2] & 0x00)
12733 {
12734 case 0x00:
12735 goto op_semantics_95;
12736 break;
12737 }
12738 break;
12739 case 0x0b:
12740 GETBYTE ();
12741 switch (op[2] & 0x00)
12742 {
12743 case 0x00:
12744 goto op_semantics_95;
12745 break;
12746 }
12747 break;
12748 case 0x0c:
12749 GETBYTE ();
12750 switch (op[2] & 0x00)
12751 {
12752 case 0x00:
12753 goto op_semantics_95;
12754 break;
12755 }
12756 break;
12757 case 0x0d:
12758 GETBYTE ();
12759 switch (op[2] & 0x00)
12760 {
12761 case 0x00:
12762 goto op_semantics_95;
12763 break;
12764 }
12765 break;
12766 case 0x0e:
12767 GETBYTE ();
12768 switch (op[2] & 0x00)
12769 {
12770 case 0x00:
12771 goto op_semantics_95;
12772 break;
12773 }
12774 break;
12775 case 0x0f:
12776 GETBYTE ();
12777 switch (op[2] & 0x00)
12778 {
12779 case 0x00:
12780 goto op_semantics_95;
12781 break;
12782 }
12783 break;
12784 case 0x10:
12785 GETBYTE ();
12786 switch (op[2] & 0x00)
12787 {
12788 case 0x00:
12789 goto op_semantics_95;
12790 break;
12791 }
12792 break;
12793 case 0x11:
12794 GETBYTE ();
12795 switch (op[2] & 0x00)
12796 {
12797 case 0x00:
12798 goto op_semantics_95;
12799 break;
12800 }
12801 break;
12802 case 0x12:
12803 GETBYTE ();
12804 switch (op[2] & 0x00)
12805 {
12806 case 0x00:
12807 goto op_semantics_95;
12808 break;
12809 }
12810 break;
12811 case 0x13:
12812 GETBYTE ();
12813 switch (op[2] & 0x00)
12814 {
12815 case 0x00:
12816 goto op_semantics_95;
12817 break;
12818 }
12819 break;
12820 case 0x14:
12821 GETBYTE ();
12822 switch (op[2] & 0x00)
12823 {
12824 case 0x00:
12825 goto op_semantics_95;
12826 break;
12827 }
12828 break;
12829 case 0x15:
12830 GETBYTE ();
12831 switch (op[2] & 0x00)
12832 {
12833 case 0x00:
12834 goto op_semantics_95;
12835 break;
12836 }
12837 break;
12838 case 0x16:
12839 GETBYTE ();
12840 switch (op[2] & 0x00)
12841 {
12842 case 0x00:
12843 goto op_semantics_95;
12844 break;
12845 }
12846 break;
12847 case 0x17:
12848 GETBYTE ();
12849 switch (op[2] & 0x00)
12850 {
12851 case 0x00:
12852 goto op_semantics_95;
12853 break;
12854 }
12855 break;
12856 case 0x18:
12857 GETBYTE ();
12858 switch (op[2] & 0x00)
12859 {
12860 case 0x00:
12861 goto op_semantics_95;
12862 break;
12863 }
12864 break;
12865 case 0x19:
12866 GETBYTE ();
12867 switch (op[2] & 0x00)
12868 {
12869 case 0x00:
12870 goto op_semantics_95;
12871 break;
12872 }
12873 break;
12874 case 0x1a:
12875 GETBYTE ();
12876 switch (op[2] & 0x00)
12877 {
12878 case 0x00:
12879 goto op_semantics_95;
12880 break;
12881 }
12882 break;
12883 case 0x1b:
12884 GETBYTE ();
12885 switch (op[2] & 0x00)
12886 {
12887 case 0x00:
12888 goto op_semantics_95;
12889 break;
12890 }
12891 break;
12892 case 0x1c:
12893 GETBYTE ();
12894 switch (op[2] & 0x00)
12895 {
12896 case 0x00:
12897 goto op_semantics_95;
12898 break;
12899 }
12900 break;
12901 case 0x1d:
12902 GETBYTE ();
12903 switch (op[2] & 0x00)
12904 {
12905 case 0x00:
12906 goto op_semantics_95;
12907 break;
12908 }
12909 break;
12910 case 0x1e:
12911 GETBYTE ();
12912 switch (op[2] & 0x00)
12913 {
12914 case 0x00:
12915 goto op_semantics_95;
12916 break;
12917 }
12918 break;
12919 case 0x1f:
12920 GETBYTE ();
12921 switch (op[2] & 0x00)
12922 {
12923 case 0x00:
12924 goto op_semantics_95;
12925 break;
12926 }
12927 break;
12928 case 0x20:
12929 GETBYTE ();
12930 switch (op[2] & 0x00)
12931 {
12932 case 0x00:
12933 goto op_semantics_95;
12934 break;
12935 }
12936 break;
12937 case 0x21:
12938 GETBYTE ();
12939 switch (op[2] & 0x00)
12940 {
12941 case 0x00:
12942 goto op_semantics_95;
12943 break;
12944 }
12945 break;
12946 case 0x22:
12947 GETBYTE ();
12948 switch (op[2] & 0x00)
12949 {
12950 case 0x00:
12951 goto op_semantics_95;
12952 break;
12953 }
12954 break;
12955 case 0x23:
12956 GETBYTE ();
12957 switch (op[2] & 0x00)
12958 {
12959 case 0x00:
12960 goto op_semantics_95;
12961 break;
12962 }
12963 break;
12964 case 0x24:
12965 GETBYTE ();
12966 switch (op[2] & 0x00)
12967 {
12968 case 0x00:
12969 goto op_semantics_95;
12970 break;
12971 }
12972 break;
12973 case 0x25:
12974 GETBYTE ();
12975 switch (op[2] & 0x00)
12976 {
12977 case 0x00:
12978 goto op_semantics_95;
12979 break;
12980 }
12981 break;
12982 case 0x26:
12983 GETBYTE ();
12984 switch (op[2] & 0x00)
12985 {
12986 case 0x00:
12987 goto op_semantics_95;
12988 break;
12989 }
12990 break;
12991 case 0x27:
12992 GETBYTE ();
12993 switch (op[2] & 0x00)
12994 {
12995 case 0x00:
12996 goto op_semantics_95;
12997 break;
12998 }
12999 break;
13000 case 0x28:
13001 GETBYTE ();
13002 switch (op[2] & 0x00)
13003 {
13004 case 0x00:
13005 goto op_semantics_95;
13006 break;
13007 }
13008 break;
13009 case 0x29:
13010 GETBYTE ();
13011 switch (op[2] & 0x00)
13012 {
13013 case 0x00:
13014 goto op_semantics_95;
13015 break;
13016 }
13017 break;
13018 case 0x2a:
13019 GETBYTE ();
13020 switch (op[2] & 0x00)
13021 {
13022 case 0x00:
13023 goto op_semantics_95;
13024 break;
13025 }
13026 break;
13027 case 0x2b:
13028 GETBYTE ();
13029 switch (op[2] & 0x00)
13030 {
13031 case 0x00:
13032 goto op_semantics_95;
13033 break;
13034 }
13035 break;
13036 case 0x2c:
13037 GETBYTE ();
13038 switch (op[2] & 0x00)
13039 {
13040 case 0x00:
13041 goto op_semantics_95;
13042 break;
13043 }
13044 break;
13045 case 0x2d:
13046 GETBYTE ();
13047 switch (op[2] & 0x00)
13048 {
13049 case 0x00:
13050 goto op_semantics_95;
13051 break;
13052 }
13053 break;
13054 case 0x2e:
13055 GETBYTE ();
13056 switch (op[2] & 0x00)
13057 {
13058 case 0x00:
13059 goto op_semantics_95;
13060 break;
13061 }
13062 break;
13063 case 0x2f:
13064 GETBYTE ();
13065 switch (op[2] & 0x00)
13066 {
13067 case 0x00:
13068 goto op_semantics_95;
13069 break;
13070 }
13071 break;
13072 case 0x40:
13073 GETBYTE ();
13074 switch (op[2] & 0x00)
13075 {
13076 case 0x00:
13077 op_semantics_96:
13078 {
13079 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
13080 #line 311 "rx-decode.opc"
13081 int sz AU = (op[1] >> 4) & 0x03;
13082 #line 311 "rx-decode.opc"
13083 int isrc AU = op[1] & 0x0f;
13084 #line 311 "rx-decode.opc"
13085 int bsrc AU = (op[2] >> 4) & 0x0f;
13086 #line 311 "rx-decode.opc"
13087 int rdst AU = op[2] & 0x0f;
13088 if (trace)
13089 {
13090 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13091 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13092 op[0], op[1], op[2]);
13093 printf (" sz = 0x%x,", sz);
13094 printf (" isrc = 0x%x,", isrc);
13095 printf (" bsrc = 0x%x,", bsrc);
13096 printf (" rdst = 0x%x\n", rdst);
13097 }
13098 SYNTAX("mov%s [%1, %2], %0");
13099 #line 311 "rx-decode.opc"
13100 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13101
13102 }
13103 break;
13104 }
13105 break;
13106 case 0x41:
13107 GETBYTE ();
13108 switch (op[2] & 0x00)
13109 {
13110 case 0x00:
13111 goto op_semantics_96;
13112 break;
13113 }
13114 break;
13115 case 0x42:
13116 GETBYTE ();
13117 switch (op[2] & 0x00)
13118 {
13119 case 0x00:
13120 goto op_semantics_96;
13121 break;
13122 }
13123 break;
13124 case 0x43:
13125 GETBYTE ();
13126 switch (op[2] & 0x00)
13127 {
13128 case 0x00:
13129 goto op_semantics_96;
13130 break;
13131 }
13132 break;
13133 case 0x44:
13134 GETBYTE ();
13135 switch (op[2] & 0x00)
13136 {
13137 case 0x00:
13138 goto op_semantics_96;
13139 break;
13140 }
13141 break;
13142 case 0x45:
13143 GETBYTE ();
13144 switch (op[2] & 0x00)
13145 {
13146 case 0x00:
13147 goto op_semantics_96;
13148 break;
13149 }
13150 break;
13151 case 0x46:
13152 GETBYTE ();
13153 switch (op[2] & 0x00)
13154 {
13155 case 0x00:
13156 goto op_semantics_96;
13157 break;
13158 }
13159 break;
13160 case 0x47:
13161 GETBYTE ();
13162 switch (op[2] & 0x00)
13163 {
13164 case 0x00:
13165 goto op_semantics_96;
13166 break;
13167 }
13168 break;
13169 case 0x48:
13170 GETBYTE ();
13171 switch (op[2] & 0x00)
13172 {
13173 case 0x00:
13174 goto op_semantics_96;
13175 break;
13176 }
13177 break;
13178 case 0x49:
13179 GETBYTE ();
13180 switch (op[2] & 0x00)
13181 {
13182 case 0x00:
13183 goto op_semantics_96;
13184 break;
13185 }
13186 break;
13187 case 0x4a:
13188 GETBYTE ();
13189 switch (op[2] & 0x00)
13190 {
13191 case 0x00:
13192 goto op_semantics_96;
13193 break;
13194 }
13195 break;
13196 case 0x4b:
13197 GETBYTE ();
13198 switch (op[2] & 0x00)
13199 {
13200 case 0x00:
13201 goto op_semantics_96;
13202 break;
13203 }
13204 break;
13205 case 0x4c:
13206 GETBYTE ();
13207 switch (op[2] & 0x00)
13208 {
13209 case 0x00:
13210 goto op_semantics_96;
13211 break;
13212 }
13213 break;
13214 case 0x4d:
13215 GETBYTE ();
13216 switch (op[2] & 0x00)
13217 {
13218 case 0x00:
13219 goto op_semantics_96;
13220 break;
13221 }
13222 break;
13223 case 0x4e:
13224 GETBYTE ();
13225 switch (op[2] & 0x00)
13226 {
13227 case 0x00:
13228 goto op_semantics_96;
13229 break;
13230 }
13231 break;
13232 case 0x4f:
13233 GETBYTE ();
13234 switch (op[2] & 0x00)
13235 {
13236 case 0x00:
13237 goto op_semantics_96;
13238 break;
13239 }
13240 break;
13241 case 0x50:
13242 GETBYTE ();
13243 switch (op[2] & 0x00)
13244 {
13245 case 0x00:
13246 goto op_semantics_96;
13247 break;
13248 }
13249 break;
13250 case 0x51:
13251 GETBYTE ();
13252 switch (op[2] & 0x00)
13253 {
13254 case 0x00:
13255 goto op_semantics_96;
13256 break;
13257 }
13258 break;
13259 case 0x52:
13260 GETBYTE ();
13261 switch (op[2] & 0x00)
13262 {
13263 case 0x00:
13264 goto op_semantics_96;
13265 break;
13266 }
13267 break;
13268 case 0x53:
13269 GETBYTE ();
13270 switch (op[2] & 0x00)
13271 {
13272 case 0x00:
13273 goto op_semantics_96;
13274 break;
13275 }
13276 break;
13277 case 0x54:
13278 GETBYTE ();
13279 switch (op[2] & 0x00)
13280 {
13281 case 0x00:
13282 goto op_semantics_96;
13283 break;
13284 }
13285 break;
13286 case 0x55:
13287 GETBYTE ();
13288 switch (op[2] & 0x00)
13289 {
13290 case 0x00:
13291 goto op_semantics_96;
13292 break;
13293 }
13294 break;
13295 case 0x56:
13296 GETBYTE ();
13297 switch (op[2] & 0x00)
13298 {
13299 case 0x00:
13300 goto op_semantics_96;
13301 break;
13302 }
13303 break;
13304 case 0x57:
13305 GETBYTE ();
13306 switch (op[2] & 0x00)
13307 {
13308 case 0x00:
13309 goto op_semantics_96;
13310 break;
13311 }
13312 break;
13313 case 0x58:
13314 GETBYTE ();
13315 switch (op[2] & 0x00)
13316 {
13317 case 0x00:
13318 goto op_semantics_96;
13319 break;
13320 }
13321 break;
13322 case 0x59:
13323 GETBYTE ();
13324 switch (op[2] & 0x00)
13325 {
13326 case 0x00:
13327 goto op_semantics_96;
13328 break;
13329 }
13330 break;
13331 case 0x5a:
13332 GETBYTE ();
13333 switch (op[2] & 0x00)
13334 {
13335 case 0x00:
13336 goto op_semantics_96;
13337 break;
13338 }
13339 break;
13340 case 0x5b:
13341 GETBYTE ();
13342 switch (op[2] & 0x00)
13343 {
13344 case 0x00:
13345 goto op_semantics_96;
13346 break;
13347 }
13348 break;
13349 case 0x5c:
13350 GETBYTE ();
13351 switch (op[2] & 0x00)
13352 {
13353 case 0x00:
13354 goto op_semantics_96;
13355 break;
13356 }
13357 break;
13358 case 0x5d:
13359 GETBYTE ();
13360 switch (op[2] & 0x00)
13361 {
13362 case 0x00:
13363 goto op_semantics_96;
13364 break;
13365 }
13366 break;
13367 case 0x5e:
13368 GETBYTE ();
13369 switch (op[2] & 0x00)
13370 {
13371 case 0x00:
13372 goto op_semantics_96;
13373 break;
13374 }
13375 break;
13376 case 0x5f:
13377 GETBYTE ();
13378 switch (op[2] & 0x00)
13379 {
13380 case 0x00:
13381 goto op_semantics_96;
13382 break;
13383 }
13384 break;
13385 case 0x60:
13386 GETBYTE ();
13387 switch (op[2] & 0x00)
13388 {
13389 case 0x00:
13390 goto op_semantics_96;
13391 break;
13392 }
13393 break;
13394 case 0x61:
13395 GETBYTE ();
13396 switch (op[2] & 0x00)
13397 {
13398 case 0x00:
13399 goto op_semantics_96;
13400 break;
13401 }
13402 break;
13403 case 0x62:
13404 GETBYTE ();
13405 switch (op[2] & 0x00)
13406 {
13407 case 0x00:
13408 goto op_semantics_96;
13409 break;
13410 }
13411 break;
13412 case 0x63:
13413 GETBYTE ();
13414 switch (op[2] & 0x00)
13415 {
13416 case 0x00:
13417 goto op_semantics_96;
13418 break;
13419 }
13420 break;
13421 case 0x64:
13422 GETBYTE ();
13423 switch (op[2] & 0x00)
13424 {
13425 case 0x00:
13426 goto op_semantics_96;
13427 break;
13428 }
13429 break;
13430 case 0x65:
13431 GETBYTE ();
13432 switch (op[2] & 0x00)
13433 {
13434 case 0x00:
13435 goto op_semantics_96;
13436 break;
13437 }
13438 break;
13439 case 0x66:
13440 GETBYTE ();
13441 switch (op[2] & 0x00)
13442 {
13443 case 0x00:
13444 goto op_semantics_96;
13445 break;
13446 }
13447 break;
13448 case 0x67:
13449 GETBYTE ();
13450 switch (op[2] & 0x00)
13451 {
13452 case 0x00:
13453 goto op_semantics_96;
13454 break;
13455 }
13456 break;
13457 case 0x68:
13458 GETBYTE ();
13459 switch (op[2] & 0x00)
13460 {
13461 case 0x00:
13462 goto op_semantics_96;
13463 break;
13464 }
13465 break;
13466 case 0x69:
13467 GETBYTE ();
13468 switch (op[2] & 0x00)
13469 {
13470 case 0x00:
13471 goto op_semantics_96;
13472 break;
13473 }
13474 break;
13475 case 0x6a:
13476 GETBYTE ();
13477 switch (op[2] & 0x00)
13478 {
13479 case 0x00:
13480 goto op_semantics_96;
13481 break;
13482 }
13483 break;
13484 case 0x6b:
13485 GETBYTE ();
13486 switch (op[2] & 0x00)
13487 {
13488 case 0x00:
13489 goto op_semantics_96;
13490 break;
13491 }
13492 break;
13493 case 0x6c:
13494 GETBYTE ();
13495 switch (op[2] & 0x00)
13496 {
13497 case 0x00:
13498 goto op_semantics_96;
13499 break;
13500 }
13501 break;
13502 case 0x6d:
13503 GETBYTE ();
13504 switch (op[2] & 0x00)
13505 {
13506 case 0x00:
13507 goto op_semantics_96;
13508 break;
13509 }
13510 break;
13511 case 0x6e:
13512 GETBYTE ();
13513 switch (op[2] & 0x00)
13514 {
13515 case 0x00:
13516 goto op_semantics_96;
13517 break;
13518 }
13519 break;
13520 case 0x6f:
13521 GETBYTE ();
13522 switch (op[2] & 0x00)
13523 {
13524 case 0x00:
13525 goto op_semantics_96;
13526 break;
13527 }
13528 break;
13529 case 0xc0:
13530 GETBYTE ();
13531 switch (op[2] & 0x00)
13532 {
13533 case 0x00:
13534 op_semantics_97:
13535 {
13536 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
13537 #line 317 "rx-decode.opc"
13538 int sz AU = (op[1] >> 4) & 0x03;
13539 #line 317 "rx-decode.opc"
13540 int isrc AU = op[1] & 0x0f;
13541 #line 317 "rx-decode.opc"
13542 int bsrc AU = (op[2] >> 4) & 0x0f;
13543 #line 317 "rx-decode.opc"
13544 int rdst AU = op[2] & 0x0f;
13545 if (trace)
13546 {
13547 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13548 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13549 op[0], op[1], op[2]);
13550 printf (" sz = 0x%x,", sz);
13551 printf (" isrc = 0x%x,", isrc);
13552 printf (" bsrc = 0x%x,", bsrc);
13553 printf (" rdst = 0x%x\n", rdst);
13554 }
13555 SYNTAX("movu%s [%1, %2], %0");
13556 #line 317 "rx-decode.opc"
13557 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13558
13559 }
13560 break;
13561 }
13562 break;
13563 case 0xc1:
13564 GETBYTE ();
13565 switch (op[2] & 0x00)
13566 {
13567 case 0x00:
13568 goto op_semantics_97;
13569 break;
13570 }
13571 break;
13572 case 0xc2:
13573 GETBYTE ();
13574 switch (op[2] & 0x00)
13575 {
13576 case 0x00:
13577 goto op_semantics_97;
13578 break;
13579 }
13580 break;
13581 case 0xc3:
13582 GETBYTE ();
13583 switch (op[2] & 0x00)
13584 {
13585 case 0x00:
13586 goto op_semantics_97;
13587 break;
13588 }
13589 break;
13590 case 0xc4:
13591 GETBYTE ();
13592 switch (op[2] & 0x00)
13593 {
13594 case 0x00:
13595 goto op_semantics_97;
13596 break;
13597 }
13598 break;
13599 case 0xc5:
13600 GETBYTE ();
13601 switch (op[2] & 0x00)
13602 {
13603 case 0x00:
13604 goto op_semantics_97;
13605 break;
13606 }
13607 break;
13608 case 0xc6:
13609 GETBYTE ();
13610 switch (op[2] & 0x00)
13611 {
13612 case 0x00:
13613 goto op_semantics_97;
13614 break;
13615 }
13616 break;
13617 case 0xc7:
13618 GETBYTE ();
13619 switch (op[2] & 0x00)
13620 {
13621 case 0x00:
13622 goto op_semantics_97;
13623 break;
13624 }
13625 break;
13626 case 0xc8:
13627 GETBYTE ();
13628 switch (op[2] & 0x00)
13629 {
13630 case 0x00:
13631 goto op_semantics_97;
13632 break;
13633 }
13634 break;
13635 case 0xc9:
13636 GETBYTE ();
13637 switch (op[2] & 0x00)
13638 {
13639 case 0x00:
13640 goto op_semantics_97;
13641 break;
13642 }
13643 break;
13644 case 0xca:
13645 GETBYTE ();
13646 switch (op[2] & 0x00)
13647 {
13648 case 0x00:
13649 goto op_semantics_97;
13650 break;
13651 }
13652 break;
13653 case 0xcb:
13654 GETBYTE ();
13655 switch (op[2] & 0x00)
13656 {
13657 case 0x00:
13658 goto op_semantics_97;
13659 break;
13660 }
13661 break;
13662 case 0xcc:
13663 GETBYTE ();
13664 switch (op[2] & 0x00)
13665 {
13666 case 0x00:
13667 goto op_semantics_97;
13668 break;
13669 }
13670 break;
13671 case 0xcd:
13672 GETBYTE ();
13673 switch (op[2] & 0x00)
13674 {
13675 case 0x00:
13676 goto op_semantics_97;
13677 break;
13678 }
13679 break;
13680 case 0xce:
13681 GETBYTE ();
13682 switch (op[2] & 0x00)
13683 {
13684 case 0x00:
13685 goto op_semantics_97;
13686 break;
13687 }
13688 break;
13689 case 0xcf:
13690 GETBYTE ();
13691 switch (op[2] & 0x00)
13692 {
13693 case 0x00:
13694 goto op_semantics_97;
13695 break;
13696 }
13697 break;
13698 case 0xd0:
13699 GETBYTE ();
13700 switch (op[2] & 0x00)
13701 {
13702 case 0x00:
13703 goto op_semantics_97;
13704 break;
13705 }
13706 break;
13707 case 0xd1:
13708 GETBYTE ();
13709 switch (op[2] & 0x00)
13710 {
13711 case 0x00:
13712 goto op_semantics_97;
13713 break;
13714 }
13715 break;
13716 case 0xd2:
13717 GETBYTE ();
13718 switch (op[2] & 0x00)
13719 {
13720 case 0x00:
13721 goto op_semantics_97;
13722 break;
13723 }
13724 break;
13725 case 0xd3:
13726 GETBYTE ();
13727 switch (op[2] & 0x00)
13728 {
13729 case 0x00:
13730 goto op_semantics_97;
13731 break;
13732 }
13733 break;
13734 case 0xd4:
13735 GETBYTE ();
13736 switch (op[2] & 0x00)
13737 {
13738 case 0x00:
13739 goto op_semantics_97;
13740 break;
13741 }
13742 break;
13743 case 0xd5:
13744 GETBYTE ();
13745 switch (op[2] & 0x00)
13746 {
13747 case 0x00:
13748 goto op_semantics_97;
13749 break;
13750 }
13751 break;
13752 case 0xd6:
13753 GETBYTE ();
13754 switch (op[2] & 0x00)
13755 {
13756 case 0x00:
13757 goto op_semantics_97;
13758 break;
13759 }
13760 break;
13761 case 0xd7:
13762 GETBYTE ();
13763 switch (op[2] & 0x00)
13764 {
13765 case 0x00:
13766 goto op_semantics_97;
13767 break;
13768 }
13769 break;
13770 case 0xd8:
13771 GETBYTE ();
13772 switch (op[2] & 0x00)
13773 {
13774 case 0x00:
13775 goto op_semantics_97;
13776 break;
13777 }
13778 break;
13779 case 0xd9:
13780 GETBYTE ();
13781 switch (op[2] & 0x00)
13782 {
13783 case 0x00:
13784 goto op_semantics_97;
13785 break;
13786 }
13787 break;
13788 case 0xda:
13789 GETBYTE ();
13790 switch (op[2] & 0x00)
13791 {
13792 case 0x00:
13793 goto op_semantics_97;
13794 break;
13795 }
13796 break;
13797 case 0xdb:
13798 GETBYTE ();
13799 switch (op[2] & 0x00)
13800 {
13801 case 0x00:
13802 goto op_semantics_97;
13803 break;
13804 }
13805 break;
13806 case 0xdc:
13807 GETBYTE ();
13808 switch (op[2] & 0x00)
13809 {
13810 case 0x00:
13811 goto op_semantics_97;
13812 break;
13813 }
13814 break;
13815 case 0xdd:
13816 GETBYTE ();
13817 switch (op[2] & 0x00)
13818 {
13819 case 0x00:
13820 goto op_semantics_97;
13821 break;
13822 }
13823 break;
13824 case 0xde:
13825 GETBYTE ();
13826 switch (op[2] & 0x00)
13827 {
13828 case 0x00:
13829 goto op_semantics_97;
13830 break;
13831 }
13832 break;
13833 case 0xdf:
13834 GETBYTE ();
13835 switch (op[2] & 0x00)
13836 {
13837 case 0x00:
13838 goto op_semantics_97;
13839 break;
13840 }
13841 break;
13842 case 0xe0:
13843 GETBYTE ();
13844 switch (op[2] & 0x00)
13845 {
13846 case 0x00:
13847 goto op_semantics_97;
13848 break;
13849 }
13850 break;
13851 case 0xe1:
13852 GETBYTE ();
13853 switch (op[2] & 0x00)
13854 {
13855 case 0x00:
13856 goto op_semantics_97;
13857 break;
13858 }
13859 break;
13860 case 0xe2:
13861 GETBYTE ();
13862 switch (op[2] & 0x00)
13863 {
13864 case 0x00:
13865 goto op_semantics_97;
13866 break;
13867 }
13868 break;
13869 case 0xe3:
13870 GETBYTE ();
13871 switch (op[2] & 0x00)
13872 {
13873 case 0x00:
13874 goto op_semantics_97;
13875 break;
13876 }
13877 break;
13878 case 0xe4:
13879 GETBYTE ();
13880 switch (op[2] & 0x00)
13881 {
13882 case 0x00:
13883 goto op_semantics_97;
13884 break;
13885 }
13886 break;
13887 case 0xe5:
13888 GETBYTE ();
13889 switch (op[2] & 0x00)
13890 {
13891 case 0x00:
13892 goto op_semantics_97;
13893 break;
13894 }
13895 break;
13896 case 0xe6:
13897 GETBYTE ();
13898 switch (op[2] & 0x00)
13899 {
13900 case 0x00:
13901 goto op_semantics_97;
13902 break;
13903 }
13904 break;
13905 case 0xe7:
13906 GETBYTE ();
13907 switch (op[2] & 0x00)
13908 {
13909 case 0x00:
13910 goto op_semantics_97;
13911 break;
13912 }
13913 break;
13914 case 0xe8:
13915 GETBYTE ();
13916 switch (op[2] & 0x00)
13917 {
13918 case 0x00:
13919 goto op_semantics_97;
13920 break;
13921 }
13922 break;
13923 case 0xe9:
13924 GETBYTE ();
13925 switch (op[2] & 0x00)
13926 {
13927 case 0x00:
13928 goto op_semantics_97;
13929 break;
13930 }
13931 break;
13932 case 0xea:
13933 GETBYTE ();
13934 switch (op[2] & 0x00)
13935 {
13936 case 0x00:
13937 goto op_semantics_97;
13938 break;
13939 }
13940 break;
13941 case 0xeb:
13942 GETBYTE ();
13943 switch (op[2] & 0x00)
13944 {
13945 case 0x00:
13946 goto op_semantics_97;
13947 break;
13948 }
13949 break;
13950 case 0xec:
13951 GETBYTE ();
13952 switch (op[2] & 0x00)
13953 {
13954 case 0x00:
13955 goto op_semantics_97;
13956 break;
13957 }
13958 break;
13959 case 0xed:
13960 GETBYTE ();
13961 switch (op[2] & 0x00)
13962 {
13963 case 0x00:
13964 goto op_semantics_97;
13965 break;
13966 }
13967 break;
13968 case 0xee:
13969 GETBYTE ();
13970 switch (op[2] & 0x00)
13971 {
13972 case 0x00:
13973 goto op_semantics_97;
13974 break;
13975 }
13976 break;
13977 case 0xef:
13978 GETBYTE ();
13979 switch (op[2] & 0x00)
13980 {
13981 case 0x00:
13982 goto op_semantics_97;
13983 break;
13984 }
13985 break;
13986 default: UNSUPPORTED(); break;
13987 }
13988 break;
13989 case 0xff:
13990 GETBYTE ();
13991 switch (op[1] & 0xff)
13992 {
13993 case 0x00:
13994 GETBYTE ();
13995 switch (op[2] & 0x00)
13996 {
13997 case 0x00:
13998 op_semantics_98:
13999 {
14000 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
14001 #line 521 "rx-decode.opc"
14002 int rdst AU = op[1] & 0x0f;
14003 #line 521 "rx-decode.opc"
14004 int srca AU = (op[2] >> 4) & 0x0f;
14005 #line 521 "rx-decode.opc"
14006 int srcb AU = op[2] & 0x0f;
14007 if (trace)
14008 {
14009 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14010 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
14011 op[0], op[1], op[2]);
14012 printf (" rdst = 0x%x,", rdst);
14013 printf (" srca = 0x%x,", srca);
14014 printf (" srcb = 0x%x\n", srcb);
14015 }
14016 SYNTAX("sub %2, %1, %0");
14017 #line 521 "rx-decode.opc"
14018 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14019
14020 /*----------------------------------------------------------------------*/
14021 /* SBB */
14022
14023 }
14024 break;
14025 }
14026 break;
14027 case 0x01:
14028 GETBYTE ();
14029 switch (op[2] & 0x00)
14030 {
14031 case 0x00:
14032 goto op_semantics_98;
14033 break;
14034 }
14035 break;
14036 case 0x02:
14037 GETBYTE ();
14038 switch (op[2] & 0x00)
14039 {
14040 case 0x00:
14041 goto op_semantics_98;
14042 break;
14043 }
14044 break;
14045 case 0x03:
14046 GETBYTE ();
14047 switch (op[2] & 0x00)
14048 {
14049 case 0x00:
14050 goto op_semantics_98;
14051 break;
14052 }
14053 break;
14054 case 0x04:
14055 GETBYTE ();
14056 switch (op[2] & 0x00)
14057 {
14058 case 0x00:
14059 goto op_semantics_98;
14060 break;
14061 }
14062 break;
14063 case 0x05:
14064 GETBYTE ();
14065 switch (op[2] & 0x00)
14066 {
14067 case 0x00:
14068 goto op_semantics_98;
14069 break;
14070 }
14071 break;
14072 case 0x06:
14073 GETBYTE ();
14074 switch (op[2] & 0x00)
14075 {
14076 case 0x00:
14077 goto op_semantics_98;
14078 break;
14079 }
14080 break;
14081 case 0x07:
14082 GETBYTE ();
14083 switch (op[2] & 0x00)
14084 {
14085 case 0x00:
14086 goto op_semantics_98;
14087 break;
14088 }
14089 break;
14090 case 0x08:
14091 GETBYTE ();
14092 switch (op[2] & 0x00)
14093 {
14094 case 0x00:
14095 goto op_semantics_98;
14096 break;
14097 }
14098 break;
14099 case 0x09:
14100 GETBYTE ();
14101 switch (op[2] & 0x00)
14102 {
14103 case 0x00:
14104 goto op_semantics_98;
14105 break;
14106 }
14107 break;
14108 case 0x0a:
14109 GETBYTE ();
14110 switch (op[2] & 0x00)
14111 {
14112 case 0x00:
14113 goto op_semantics_98;
14114 break;
14115 }
14116 break;
14117 case 0x0b:
14118 GETBYTE ();
14119 switch (op[2] & 0x00)
14120 {
14121 case 0x00:
14122 goto op_semantics_98;
14123 break;
14124 }
14125 break;
14126 case 0x0c:
14127 GETBYTE ();
14128 switch (op[2] & 0x00)
14129 {
14130 case 0x00:
14131 goto op_semantics_98;
14132 break;
14133 }
14134 break;
14135 case 0x0d:
14136 GETBYTE ();
14137 switch (op[2] & 0x00)
14138 {
14139 case 0x00:
14140 goto op_semantics_98;
14141 break;
14142 }
14143 break;
14144 case 0x0e:
14145 GETBYTE ();
14146 switch (op[2] & 0x00)
14147 {
14148 case 0x00:
14149 goto op_semantics_98;
14150 break;
14151 }
14152 break;
14153 case 0x0f:
14154 GETBYTE ();
14155 switch (op[2] & 0x00)
14156 {
14157 case 0x00:
14158 goto op_semantics_98;
14159 break;
14160 }
14161 break;
14162 case 0x20:
14163 GETBYTE ();
14164 switch (op[2] & 0x00)
14165 {
14166 case 0x00:
14167 op_semantics_99:
14168 {
14169 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
14170 #line 488 "rx-decode.opc"
14171 int rdst AU = op[1] & 0x0f;
14172 #line 488 "rx-decode.opc"
14173 int srca AU = (op[2] >> 4) & 0x0f;
14174 #line 488 "rx-decode.opc"
14175 int srcb AU = op[2] & 0x0f;
14176 if (trace)
14177 {
14178 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14179 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14180 op[0], op[1], op[2]);
14181 printf (" rdst = 0x%x,", rdst);
14182 printf (" srca = 0x%x,", srca);
14183 printf (" srcb = 0x%x\n", srcb);
14184 }
14185 SYNTAX("add %2, %1, %0");
14186 #line 488 "rx-decode.opc"
14187 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14188
14189 /*----------------------------------------------------------------------*/
14190 /* CMP */
14191
14192 }
14193 break;
14194 }
14195 break;
14196 case 0x21:
14197 GETBYTE ();
14198 switch (op[2] & 0x00)
14199 {
14200 case 0x00:
14201 goto op_semantics_99;
14202 break;
14203 }
14204 break;
14205 case 0x22:
14206 GETBYTE ();
14207 switch (op[2] & 0x00)
14208 {
14209 case 0x00:
14210 goto op_semantics_99;
14211 break;
14212 }
14213 break;
14214 case 0x23:
14215 GETBYTE ();
14216 switch (op[2] & 0x00)
14217 {
14218 case 0x00:
14219 goto op_semantics_99;
14220 break;
14221 }
14222 break;
14223 case 0x24:
14224 GETBYTE ();
14225 switch (op[2] & 0x00)
14226 {
14227 case 0x00:
14228 goto op_semantics_99;
14229 break;
14230 }
14231 break;
14232 case 0x25:
14233 GETBYTE ();
14234 switch (op[2] & 0x00)
14235 {
14236 case 0x00:
14237 goto op_semantics_99;
14238 break;
14239 }
14240 break;
14241 case 0x26:
14242 GETBYTE ();
14243 switch (op[2] & 0x00)
14244 {
14245 case 0x00:
14246 goto op_semantics_99;
14247 break;
14248 }
14249 break;
14250 case 0x27:
14251 GETBYTE ();
14252 switch (op[2] & 0x00)
14253 {
14254 case 0x00:
14255 goto op_semantics_99;
14256 break;
14257 }
14258 break;
14259 case 0x28:
14260 GETBYTE ();
14261 switch (op[2] & 0x00)
14262 {
14263 case 0x00:
14264 goto op_semantics_99;
14265 break;
14266 }
14267 break;
14268 case 0x29:
14269 GETBYTE ();
14270 switch (op[2] & 0x00)
14271 {
14272 case 0x00:
14273 goto op_semantics_99;
14274 break;
14275 }
14276 break;
14277 case 0x2a:
14278 GETBYTE ();
14279 switch (op[2] & 0x00)
14280 {
14281 case 0x00:
14282 goto op_semantics_99;
14283 break;
14284 }
14285 break;
14286 case 0x2b:
14287 GETBYTE ();
14288 switch (op[2] & 0x00)
14289 {
14290 case 0x00:
14291 goto op_semantics_99;
14292 break;
14293 }
14294 break;
14295 case 0x2c:
14296 GETBYTE ();
14297 switch (op[2] & 0x00)
14298 {
14299 case 0x00:
14300 goto op_semantics_99;
14301 break;
14302 }
14303 break;
14304 case 0x2d:
14305 GETBYTE ();
14306 switch (op[2] & 0x00)
14307 {
14308 case 0x00:
14309 goto op_semantics_99;
14310 break;
14311 }
14312 break;
14313 case 0x2e:
14314 GETBYTE ();
14315 switch (op[2] & 0x00)
14316 {
14317 case 0x00:
14318 goto op_semantics_99;
14319 break;
14320 }
14321 break;
14322 case 0x2f:
14323 GETBYTE ();
14324 switch (op[2] & 0x00)
14325 {
14326 case 0x00:
14327 goto op_semantics_99;
14328 break;
14329 }
14330 break;
14331 case 0x30:
14332 GETBYTE ();
14333 switch (op[2] & 0x00)
14334 {
14335 case 0x00:
14336 op_semantics_100:
14337 {
14338 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
14339 #line 590 "rx-decode.opc"
14340 int rdst AU = op[1] & 0x0f;
14341 #line 590 "rx-decode.opc"
14342 int srca AU = (op[2] >> 4) & 0x0f;
14343 #line 590 "rx-decode.opc"
14344 int srcb AU = op[2] & 0x0f;
14345 if (trace)
14346 {
14347 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14348 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14349 op[0], op[1], op[2]);
14350 printf (" rdst = 0x%x,", rdst);
14351 printf (" srca = 0x%x,", srca);
14352 printf (" srcb = 0x%x\n", srcb);
14353 }
14354 SYNTAX("mul %2, %1, %0");
14355 #line 590 "rx-decode.opc"
14356 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
14357
14358 /*----------------------------------------------------------------------*/
14359 /* EMUL */
14360
14361 }
14362 break;
14363 }
14364 break;
14365 case 0x31:
14366 GETBYTE ();
14367 switch (op[2] & 0x00)
14368 {
14369 case 0x00:
14370 goto op_semantics_100;
14371 break;
14372 }
14373 break;
14374 case 0x32:
14375 GETBYTE ();
14376 switch (op[2] & 0x00)
14377 {
14378 case 0x00:
14379 goto op_semantics_100;
14380 break;
14381 }
14382 break;
14383 case 0x33:
14384 GETBYTE ();
14385 switch (op[2] & 0x00)
14386 {
14387 case 0x00:
14388 goto op_semantics_100;
14389 break;
14390 }
14391 break;
14392 case 0x34:
14393 GETBYTE ();
14394 switch (op[2] & 0x00)
14395 {
14396 case 0x00:
14397 goto op_semantics_100;
14398 break;
14399 }
14400 break;
14401 case 0x35:
14402 GETBYTE ();
14403 switch (op[2] & 0x00)
14404 {
14405 case 0x00:
14406 goto op_semantics_100;
14407 break;
14408 }
14409 break;
14410 case 0x36:
14411 GETBYTE ();
14412 switch (op[2] & 0x00)
14413 {
14414 case 0x00:
14415 goto op_semantics_100;
14416 break;
14417 }
14418 break;
14419 case 0x37:
14420 GETBYTE ();
14421 switch (op[2] & 0x00)
14422 {
14423 case 0x00:
14424 goto op_semantics_100;
14425 break;
14426 }
14427 break;
14428 case 0x38:
14429 GETBYTE ();
14430 switch (op[2] & 0x00)
14431 {
14432 case 0x00:
14433 goto op_semantics_100;
14434 break;
14435 }
14436 break;
14437 case 0x39:
14438 GETBYTE ();
14439 switch (op[2] & 0x00)
14440 {
14441 case 0x00:
14442 goto op_semantics_100;
14443 break;
14444 }
14445 break;
14446 case 0x3a:
14447 GETBYTE ();
14448 switch (op[2] & 0x00)
14449 {
14450 case 0x00:
14451 goto op_semantics_100;
14452 break;
14453 }
14454 break;
14455 case 0x3b:
14456 GETBYTE ();
14457 switch (op[2] & 0x00)
14458 {
14459 case 0x00:
14460 goto op_semantics_100;
14461 break;
14462 }
14463 break;
14464 case 0x3c:
14465 GETBYTE ();
14466 switch (op[2] & 0x00)
14467 {
14468 case 0x00:
14469 goto op_semantics_100;
14470 break;
14471 }
14472 break;
14473 case 0x3d:
14474 GETBYTE ();
14475 switch (op[2] & 0x00)
14476 {
14477 case 0x00:
14478 goto op_semantics_100;
14479 break;
14480 }
14481 break;
14482 case 0x3e:
14483 GETBYTE ();
14484 switch (op[2] & 0x00)
14485 {
14486 case 0x00:
14487 goto op_semantics_100;
14488 break;
14489 }
14490 break;
14491 case 0x3f:
14492 GETBYTE ();
14493 switch (op[2] & 0x00)
14494 {
14495 case 0x00:
14496 goto op_semantics_100;
14497 break;
14498 }
14499 break;
14500 case 0x40:
14501 GETBYTE ();
14502 switch (op[2] & 0x00)
14503 {
14504 case 0x00:
14505 op_semantics_101:
14506 {
14507 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
14508 #line 398 "rx-decode.opc"
14509 int rdst AU = op[1] & 0x0f;
14510 #line 398 "rx-decode.opc"
14511 int srca AU = (op[2] >> 4) & 0x0f;
14512 #line 398 "rx-decode.opc"
14513 int srcb AU = op[2] & 0x0f;
14514 if (trace)
14515 {
14516 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14517 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14518 op[0], op[1], op[2]);
14519 printf (" rdst = 0x%x,", rdst);
14520 printf (" srca = 0x%x,", srca);
14521 printf (" srcb = 0x%x\n", srcb);
14522 }
14523 SYNTAX("and %2, %1, %0");
14524 #line 398 "rx-decode.opc"
14525 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14526
14527 /*----------------------------------------------------------------------*/
14528 /* OR */
14529
14530 }
14531 break;
14532 }
14533 break;
14534 case 0x41:
14535 GETBYTE ();
14536 switch (op[2] & 0x00)
14537 {
14538 case 0x00:
14539 goto op_semantics_101;
14540 break;
14541 }
14542 break;
14543 case 0x42:
14544 GETBYTE ();
14545 switch (op[2] & 0x00)
14546 {
14547 case 0x00:
14548 goto op_semantics_101;
14549 break;
14550 }
14551 break;
14552 case 0x43:
14553 GETBYTE ();
14554 switch (op[2] & 0x00)
14555 {
14556 case 0x00:
14557 goto op_semantics_101;
14558 break;
14559 }
14560 break;
14561 case 0x44:
14562 GETBYTE ();
14563 switch (op[2] & 0x00)
14564 {
14565 case 0x00:
14566 goto op_semantics_101;
14567 break;
14568 }
14569 break;
14570 case 0x45:
14571 GETBYTE ();
14572 switch (op[2] & 0x00)
14573 {
14574 case 0x00:
14575 goto op_semantics_101;
14576 break;
14577 }
14578 break;
14579 case 0x46:
14580 GETBYTE ();
14581 switch (op[2] & 0x00)
14582 {
14583 case 0x00:
14584 goto op_semantics_101;
14585 break;
14586 }
14587 break;
14588 case 0x47:
14589 GETBYTE ();
14590 switch (op[2] & 0x00)
14591 {
14592 case 0x00:
14593 goto op_semantics_101;
14594 break;
14595 }
14596 break;
14597 case 0x48:
14598 GETBYTE ();
14599 switch (op[2] & 0x00)
14600 {
14601 case 0x00:
14602 goto op_semantics_101;
14603 break;
14604 }
14605 break;
14606 case 0x49:
14607 GETBYTE ();
14608 switch (op[2] & 0x00)
14609 {
14610 case 0x00:
14611 goto op_semantics_101;
14612 break;
14613 }
14614 break;
14615 case 0x4a:
14616 GETBYTE ();
14617 switch (op[2] & 0x00)
14618 {
14619 case 0x00:
14620 goto op_semantics_101;
14621 break;
14622 }
14623 break;
14624 case 0x4b:
14625 GETBYTE ();
14626 switch (op[2] & 0x00)
14627 {
14628 case 0x00:
14629 goto op_semantics_101;
14630 break;
14631 }
14632 break;
14633 case 0x4c:
14634 GETBYTE ();
14635 switch (op[2] & 0x00)
14636 {
14637 case 0x00:
14638 goto op_semantics_101;
14639 break;
14640 }
14641 break;
14642 case 0x4d:
14643 GETBYTE ();
14644 switch (op[2] & 0x00)
14645 {
14646 case 0x00:
14647 goto op_semantics_101;
14648 break;
14649 }
14650 break;
14651 case 0x4e:
14652 GETBYTE ();
14653 switch (op[2] & 0x00)
14654 {
14655 case 0x00:
14656 goto op_semantics_101;
14657 break;
14658 }
14659 break;
14660 case 0x4f:
14661 GETBYTE ();
14662 switch (op[2] & 0x00)
14663 {
14664 case 0x00:
14665 goto op_semantics_101;
14666 break;
14667 }
14668 break;
14669 case 0x50:
14670 GETBYTE ();
14671 switch (op[2] & 0x00)
14672 {
14673 case 0x00:
14674 op_semantics_102:
14675 {
14676 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
14677 #line 416 "rx-decode.opc"
14678 int rdst AU = op[1] & 0x0f;
14679 #line 416 "rx-decode.opc"
14680 int srca AU = (op[2] >> 4) & 0x0f;
14681 #line 416 "rx-decode.opc"
14682 int srcb AU = op[2] & 0x0f;
14683 if (trace)
14684 {
14685 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14686 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14687 op[0], op[1], op[2]);
14688 printf (" rdst = 0x%x,", rdst);
14689 printf (" srca = 0x%x,", srca);
14690 printf (" srcb = 0x%x\n", srcb);
14691 }
14692 SYNTAX("or %2, %1, %0");
14693 #line 416 "rx-decode.opc"
14694 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14695
14696 /*----------------------------------------------------------------------*/
14697 /* XOR */
14698
14699 }
14700 break;
14701 }
14702 break;
14703 case 0x51:
14704 GETBYTE ();
14705 switch (op[2] & 0x00)
14706 {
14707 case 0x00:
14708 goto op_semantics_102;
14709 break;
14710 }
14711 break;
14712 case 0x52:
14713 GETBYTE ();
14714 switch (op[2] & 0x00)
14715 {
14716 case 0x00:
14717 goto op_semantics_102;
14718 break;
14719 }
14720 break;
14721 case 0x53:
14722 GETBYTE ();
14723 switch (op[2] & 0x00)
14724 {
14725 case 0x00:
14726 goto op_semantics_102;
14727 break;
14728 }
14729 break;
14730 case 0x54:
14731 GETBYTE ();
14732 switch (op[2] & 0x00)
14733 {
14734 case 0x00:
14735 goto op_semantics_102;
14736 break;
14737 }
14738 break;
14739 case 0x55:
14740 GETBYTE ();
14741 switch (op[2] & 0x00)
14742 {
14743 case 0x00:
14744 goto op_semantics_102;
14745 break;
14746 }
14747 break;
14748 case 0x56:
14749 GETBYTE ();
14750 switch (op[2] & 0x00)
14751 {
14752 case 0x00:
14753 goto op_semantics_102;
14754 break;
14755 }
14756 break;
14757 case 0x57:
14758 GETBYTE ();
14759 switch (op[2] & 0x00)
14760 {
14761 case 0x00:
14762 goto op_semantics_102;
14763 break;
14764 }
14765 break;
14766 case 0x58:
14767 GETBYTE ();
14768 switch (op[2] & 0x00)
14769 {
14770 case 0x00:
14771 goto op_semantics_102;
14772 break;
14773 }
14774 break;
14775 case 0x59:
14776 GETBYTE ();
14777 switch (op[2] & 0x00)
14778 {
14779 case 0x00:
14780 goto op_semantics_102;
14781 break;
14782 }
14783 break;
14784 case 0x5a:
14785 GETBYTE ();
14786 switch (op[2] & 0x00)
14787 {
14788 case 0x00:
14789 goto op_semantics_102;
14790 break;
14791 }
14792 break;
14793 case 0x5b:
14794 GETBYTE ();
14795 switch (op[2] & 0x00)
14796 {
14797 case 0x00:
14798 goto op_semantics_102;
14799 break;
14800 }
14801 break;
14802 case 0x5c:
14803 GETBYTE ();
14804 switch (op[2] & 0x00)
14805 {
14806 case 0x00:
14807 goto op_semantics_102;
14808 break;
14809 }
14810 break;
14811 case 0x5d:
14812 GETBYTE ();
14813 switch (op[2] & 0x00)
14814 {
14815 case 0x00:
14816 goto op_semantics_102;
14817 break;
14818 }
14819 break;
14820 case 0x5e:
14821 GETBYTE ();
14822 switch (op[2] & 0x00)
14823 {
14824 case 0x00:
14825 goto op_semantics_102;
14826 break;
14827 }
14828 break;
14829 case 0x5f:
14830 GETBYTE ();
14831 switch (op[2] & 0x00)
14832 {
14833 case 0x00:
14834 goto op_semantics_102;
14835 break;
14836 }
14837 break;
14838 default: UNSUPPORTED(); break;
14839 }
14840 break;
14841 default: UNSUPPORTED(); break;
14842 }
14843 #line 973 "rx-decode.opc"
14844
14845 return rx->n_bytes;
14846 }
GDB Binutils - Deliverables
This page took 0.392279 seconds and 5 git commands to generate.