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