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