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