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