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