projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Regen rx-decode.c
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
1 #line 1 "rx-decode.opc"
2 /* -*- c -*- */
3 /* Copyright (C) 2012-2017 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 #include "libiberty.h"
31
32 #define RX_OPCODE_BIG_ENDIAN 0
33
34 typedef struct
35 {
36 RX_Opcode_Decoded * rx;
37 int (* getbyte)(void *);
38 void * ptr;
39 unsigned char * op;
40 } LocalData;
41
42 static int trace = 0;
43
44 #define BSIZE 0
45 #define WSIZE 1
46 #define LSIZE 2
47
48 /* These are for when the upper bits are "don't care" or "undefined". */
49 static int bwl[4] =
50 {
51 RX_Byte,
52 RX_Word,
53 RX_Long,
54 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
55 };
56
57 static int sbwl[4] =
58 {
59 RX_SByte,
60 RX_SWord,
61 RX_Long,
62 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
63 };
64
65 static int ubw[4] =
66 {
67 RX_UByte,
68 RX_UWord,
69 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
70 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
71 };
72
73 static int memex[4] =
74 {
75 RX_SByte,
76 RX_SWord,
77 RX_Long,
78 RX_UWord
79 };
80
81 #define ID(x) rx->id = RXO_##x
82 #define OP(n,t,r,a) (rx->op[n].type = t, \
83 rx->op[n].reg = r, \
84 rx->op[n].addend = a )
85 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
86 rx->op[n].size = s )
87
88 /* This is for the BWL and BW bitfields. */
89 static int SCALE[] = { 1, 2, 4, 0 };
90 /* This is for the prefix size enum. */
91 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
92
93 #define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
94 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
95
96 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
97 16, 17, 0, 0, 0, 0, 0, 0 };
98
99 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
100
101 /*
102 *C a constant (immediate) c
103 *R A register
104 *I Register indirect, no offset
105 *Is Register indirect, with offset
106 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
107 *P standard displacement: type (r,[r]), reg, assumes UByte
108 *Pm memex displacement: type (r,[r]), reg, memex code
109 *cc condition code. */
110
111 #define DC(c) OP (0, RX_Operand_Immediate, 0, c)
112 #define DR(r) OP (0, RX_Operand_Register, r, 0)
113 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
114 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
115 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
116 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
117
118 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
119 #define SR(r) OP (1, RX_Operand_Register, r, 0)
120 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
121 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
122 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
123 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
124 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
125 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
126 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
127
128 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
129 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
130 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
131 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
132 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
133 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
134 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
135 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
136
137 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
138 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
139 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
140 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
141
142 #define F(f) store_flags(rx, f)
143
144 #define AU ATTRIBUTE_UNUSED
145 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
146
147 #define SYNTAX(x) rx->syntax = x
148
149 #define UNSUPPORTED() \
150 rx->syntax = "*unknown*"
151
152 #define IMM(sf) immediate (sf, 0, ld)
153 #define IMMex(sf) immediate (sf, 1, ld)
154
155 static int
156 immediate (int sfield, int ex, LocalData * ld)
157 {
158 unsigned long i = 0, j;
159
160 switch (sfield)
161 {
162 #define B ((unsigned long) GETBYTE())
163 case 0:
164 #if RX_OPCODE_BIG_ENDIAN
165 i = B;
166 if (ex && (i & 0x80))
167 i -= 0x100;
168 i <<= 24;
169 i |= B << 16;
170 i |= B << 8;
171 i |= B;
172 #else
173 i = B;
174 i |= B << 8;
175 i |= B << 16;
176 j = B;
177 if (ex && (j & 0x80))
178 j -= 0x100;
179 i |= j << 24;
180 #endif
181 break;
182 case 3:
183 #if RX_OPCODE_BIG_ENDIAN
184 i = B << 16;
185 i |= B << 8;
186 i |= B;
187 #else
188 i = B;
189 i |= B << 8;
190 i |= B << 16;
191 #endif
192 if (ex && (i & 0x800000))
193 i -= 0x1000000;
194 break;
195 case 2:
196 #if RX_OPCODE_BIG_ENDIAN
197 i |= B << 8;
198 i |= B;
199 #else
200 i |= B;
201 i |= B << 8;
202 #endif
203 if (ex && (i & 0x8000))
204 i -= 0x10000;
205 break;
206 case 1:
207 i |= B;
208 if (ex && (i & 0x80))
209 i -= 0x100;
210 break;
211 default:
212 abort();
213 }
214 return i;
215 }
216
217 static void
218 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
219 {
220 int disp;
221
222 ld->rx->op[n].reg = reg;
223 switch (type)
224 {
225 case 3:
226 ld->rx->op[n].type = RX_Operand_Register;
227 break;
228 case 0:
229 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
230 ld->rx->op[n].addend = 0;
231 break;
232 case 1:
233 ld->rx->op[n].type = RX_Operand_Indirect;
234 disp = GETBYTE ();
235 ld->rx->op[n].addend = disp * GET_PSCALE (size);
236 break;
237 case 2:
238 ld->rx->op[n].type = RX_Operand_Indirect;
239 disp = GETBYTE ();
240 #if RX_OPCODE_BIG_ENDIAN
241 disp = disp * 256 + GETBYTE ();
242 #else
243 disp = disp + GETBYTE () * 256;
244 #endif
245 ld->rx->op[n].addend = disp * GET_PSCALE (size);
246 break;
247 default:
248 abort ();
249 }
250 }
251
252 #define xO 8
253 #define xS 4
254 #define xZ 2
255 #define xC 1
256
257 #define F_____
258 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
259 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
260 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
261 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
262 #define F_O___ rx->flags_0 = rx->flags_s = xO;
263 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
264 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
265 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
266
267 int
268 rx_decode_opcode (unsigned long pc AU,
269 RX_Opcode_Decoded * rx,
270 int (* getbyte)(void *),
271 void * ptr)
272 {
273 LocalData lds, * ld = &lds;
274 unsigned char op[20] = {0};
275
276 lds.rx = rx;
277 lds.getbyte = getbyte;
278 lds.ptr = ptr;
279 lds.op = op;
280
281 memset (rx, 0, sizeof (*rx));
282 BWL(LSIZE);
283
284
285 /*----------------------------------------------------------------------*/
286 /* MOV */
287
288 GETBYTE ();
289 switch (op[0] & 0xff)
290 {
291 case 0x00:
292 {
293 /** 0000 0000 brk */
294 if (trace)
295 {
296 printf ("\033[33m%s\033[0m %02x\n",
297 "/** 0000 0000 brk */",
298 op[0]);
299 }
300 SYNTAX("brk");
301 #line 1029 "rx-decode.opc"
302 ID(brk);
303
304 }
305 break;
306 case 0x01:
307 {
308 /** 0000 0001 dbt */
309 if (trace)
310 {
311 printf ("\033[33m%s\033[0m %02x\n",
312 "/** 0000 0001 dbt */",
313 op[0]);
314 }
315 SYNTAX("dbt");
316 #line 1032 "rx-decode.opc"
317 ID(dbt);
318
319 }
320 break;
321 case 0x02:
322 {
323 /** 0000 0010 rts */
324 if (trace)
325 {
326 printf ("\033[33m%s\033[0m %02x\n",
327 "/** 0000 0010 rts */",
328 op[0]);
329 }
330 SYNTAX("rts");
331 #line 810 "rx-decode.opc"
332 ID(rts);
333
334 /*----------------------------------------------------------------------*/
335 /* NOP */
336
337 }
338 break;
339 case 0x03:
340 {
341 /** 0000 0011 nop */
342 if (trace)
343 {
344 printf ("\033[33m%s\033[0m %02x\n",
345 "/** 0000 0011 nop */",
346 op[0]);
347 }
348 SYNTAX("nop");
349 #line 816 "rx-decode.opc"
350 ID(nop);
351
352 /*----------------------------------------------------------------------*/
353 /* STRING FUNCTIONS */
354
355 }
356 break;
357 case 0x04:
358 {
359 /** 0000 0100 bra.a %a0 */
360 if (trace)
361 {
362 printf ("\033[33m%s\033[0m %02x\n",
363 "/** 0000 0100 bra.a %a0 */",
364 op[0]);
365 }
366 SYNTAX("bra.a %a0");
367 #line 788 "rx-decode.opc"
368 ID(branch); DC(pc + IMMex(3));
369
370 }
371 break;
372 case 0x05:
373 {
374 /** 0000 0101 bsr.a %a0 */
375 if (trace)
376 {
377 printf ("\033[33m%s\033[0m %02x\n",
378 "/** 0000 0101 bsr.a %a0 */",
379 op[0]);
380 }
381 SYNTAX("bsr.a %a0");
382 #line 804 "rx-decode.opc"
383 ID(jsr); DC(pc + IMMex(3));
384
385 }
386 break;
387 case 0x06:
388 GETBYTE ();
389 switch (op[1] & 0xff)
390 {
391 case 0x00:
392 GETBYTE ();
393 switch (op[2] & 0x00)
394 {
395 case 0x00:
396 op_semantics_1:
397 {
398 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
399 #line 546 "rx-decode.opc"
400 int mx AU = (op[1] >> 6) & 0x03;
401 #line 546 "rx-decode.opc"
402 int ss AU = op[1] & 0x03;
403 #line 546 "rx-decode.opc"
404 int rsrc AU = (op[2] >> 4) & 0x0f;
405 #line 546 "rx-decode.opc"
406 int rdst AU = op[2] & 0x0f;
407 if (trace)
408 {
409 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
410 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
411 op[0], op[1], op[2]);
412 printf (" mx = 0x%x,", mx);
413 printf (" ss = 0x%x,", ss);
414 printf (" rsrc = 0x%x,", rsrc);
415 printf (" rdst = 0x%x\n", rdst);
416 }
417 SYNTAX("sub %2%S2, %1");
418 #line 546 "rx-decode.opc"
419 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
420
421 }
422 break;
423 }
424 break;
425 case 0x01:
426 GETBYTE ();
427 switch (op[2] & 0x00)
428 {
429 case 0x00:
430 goto op_semantics_1;
431 break;
432 }
433 break;
434 case 0x02:
435 GETBYTE ();
436 switch (op[2] & 0x00)
437 {
438 case 0x00:
439 goto op_semantics_1;
440 break;
441 }
442 break;
443 case 0x03:
444 GETBYTE ();
445 switch (op[2] & 0x00)
446 {
447 case 0x00:
448 goto op_semantics_1;
449 break;
450 }
451 break;
452 case 0x04:
453 GETBYTE ();
454 switch (op[2] & 0x00)
455 {
456 case 0x00:
457 op_semantics_2:
458 {
459 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
460 #line 534 "rx-decode.opc"
461 int mx AU = (op[1] >> 6) & 0x03;
462 #line 534 "rx-decode.opc"
463 int ss AU = op[1] & 0x03;
464 #line 534 "rx-decode.opc"
465 int rsrc AU = (op[2] >> 4) & 0x0f;
466 #line 534 "rx-decode.opc"
467 int rdst AU = op[2] & 0x0f;
468 if (trace)
469 {
470 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
471 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
472 op[0], op[1], op[2]);
473 printf (" mx = 0x%x,", mx);
474 printf (" ss = 0x%x,", ss);
475 printf (" rsrc = 0x%x,", rsrc);
476 printf (" rdst = 0x%x\n", rdst);
477 }
478 SYNTAX("cmp %2%S2, %1");
479 #line 534 "rx-decode.opc"
480 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
481
482 /*----------------------------------------------------------------------*/
483 /* SUB */
484
485 }
486 break;
487 }
488 break;
489 case 0x05:
490 GETBYTE ();
491 switch (op[2] & 0x00)
492 {
493 case 0x00:
494 goto op_semantics_2;
495 break;
496 }
497 break;
498 case 0x06:
499 GETBYTE ();
500 switch (op[2] & 0x00)
501 {
502 case 0x00:
503 goto op_semantics_2;
504 break;
505 }
506 break;
507 case 0x07:
508 GETBYTE ();
509 switch (op[2] & 0x00)
510 {
511 case 0x00:
512 goto op_semantics_2;
513 break;
514 }
515 break;
516 case 0x08:
517 GETBYTE ();
518 switch (op[2] & 0x00)
519 {
520 case 0x00:
521 op_semantics_3:
522 {
523 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
524 #line 510 "rx-decode.opc"
525 int mx AU = (op[1] >> 6) & 0x03;
526 #line 510 "rx-decode.opc"
527 int ss AU = op[1] & 0x03;
528 #line 510 "rx-decode.opc"
529 int rsrc AU = (op[2] >> 4) & 0x0f;
530 #line 510 "rx-decode.opc"
531 int rdst AU = op[2] & 0x0f;
532 if (trace)
533 {
534 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
535 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
536 op[0], op[1], op[2]);
537 printf (" mx = 0x%x,", mx);
538 printf (" ss = 0x%x,", ss);
539 printf (" rsrc = 0x%x,", rsrc);
540 printf (" rdst = 0x%x\n", rdst);
541 }
542 SYNTAX("add %1%S1, %0");
543 #line 510 "rx-decode.opc"
544 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
545
546 }
547 break;
548 }
549 break;
550 case 0x09:
551 GETBYTE ();
552 switch (op[2] & 0x00)
553 {
554 case 0x00:
555 goto op_semantics_3;
556 break;
557 }
558 break;
559 case 0x0a:
560 GETBYTE ();
561 switch (op[2] & 0x00)
562 {
563 case 0x00:
564 goto op_semantics_3;
565 break;
566 }
567 break;
568 case 0x0b:
569 GETBYTE ();
570 switch (op[2] & 0x00)
571 {
572 case 0x00:
573 goto op_semantics_3;
574 break;
575 }
576 break;
577 case 0x0c:
578 GETBYTE ();
579 switch (op[2] & 0x00)
580 {
581 case 0x00:
582 op_semantics_4:
583 {
584 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
585 #line 653 "rx-decode.opc"
586 int mx AU = (op[1] >> 6) & 0x03;
587 #line 653 "rx-decode.opc"
588 int ss AU = op[1] & 0x03;
589 #line 653 "rx-decode.opc"
590 int rsrc AU = (op[2] >> 4) & 0x0f;
591 #line 653 "rx-decode.opc"
592 int rdst AU = op[2] & 0x0f;
593 if (trace)
594 {
595 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
596 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
597 op[0], op[1], op[2]);
598 printf (" mx = 0x%x,", mx);
599 printf (" ss = 0x%x,", ss);
600 printf (" rsrc = 0x%x,", rsrc);
601 printf (" rdst = 0x%x\n", rdst);
602 }
603 SYNTAX("mul %1%S1, %0");
604 #line 653 "rx-decode.opc"
605 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
606
607 }
608 break;
609 }
610 break;
611 case 0x0d:
612 GETBYTE ();
613 switch (op[2] & 0x00)
614 {
615 case 0x00:
616 goto op_semantics_4;
617 break;
618 }
619 break;
620 case 0x0e:
621 GETBYTE ();
622 switch (op[2] & 0x00)
623 {
624 case 0x00:
625 goto op_semantics_4;
626 break;
627 }
628 break;
629 case 0x0f:
630 GETBYTE ();
631 switch (op[2] & 0x00)
632 {
633 case 0x00:
634 goto op_semantics_4;
635 break;
636 }
637 break;
638 case 0x10:
639 GETBYTE ();
640 switch (op[2] & 0x00)
641 {
642 case 0x00:
643 op_semantics_5:
644 {
645 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
646 #line 423 "rx-decode.opc"
647 int mx AU = (op[1] >> 6) & 0x03;
648 #line 423 "rx-decode.opc"
649 int ss AU = op[1] & 0x03;
650 #line 423 "rx-decode.opc"
651 int rsrc AU = (op[2] >> 4) & 0x0f;
652 #line 423 "rx-decode.opc"
653 int rdst AU = op[2] & 0x0f;
654 if (trace)
655 {
656 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
657 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
658 op[0], op[1], op[2]);
659 printf (" mx = 0x%x,", mx);
660 printf (" ss = 0x%x,", ss);
661 printf (" rsrc = 0x%x,", rsrc);
662 printf (" rdst = 0x%x\n", rdst);
663 }
664 SYNTAX("and %1%S1, %0");
665 #line 423 "rx-decode.opc"
666 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
667
668 }
669 break;
670 }
671 break;
672 case 0x11:
673 GETBYTE ();
674 switch (op[2] & 0x00)
675 {
676 case 0x00:
677 goto op_semantics_5;
678 break;
679 }
680 break;
681 case 0x12:
682 GETBYTE ();
683 switch (op[2] & 0x00)
684 {
685 case 0x00:
686 goto op_semantics_5;
687 break;
688 }
689 break;
690 case 0x13:
691 GETBYTE ();
692 switch (op[2] & 0x00)
693 {
694 case 0x00:
695 goto op_semantics_5;
696 break;
697 }
698 break;
699 case 0x14:
700 GETBYTE ();
701 switch (op[2] & 0x00)
702 {
703 case 0x00:
704 op_semantics_6:
705 {
706 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
707 #line 441 "rx-decode.opc"
708 int mx AU = (op[1] >> 6) & 0x03;
709 #line 441 "rx-decode.opc"
710 int ss AU = op[1] & 0x03;
711 #line 441 "rx-decode.opc"
712 int rsrc AU = (op[2] >> 4) & 0x0f;
713 #line 441 "rx-decode.opc"
714 int rdst AU = op[2] & 0x0f;
715 if (trace)
716 {
717 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
718 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
719 op[0], op[1], op[2]);
720 printf (" mx = 0x%x,", mx);
721 printf (" ss = 0x%x,", ss);
722 printf (" rsrc = 0x%x,", rsrc);
723 printf (" rdst = 0x%x\n", rdst);
724 }
725 SYNTAX("or %1%S1, %0");
726 #line 441 "rx-decode.opc"
727 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
728
729 }
730 break;
731 }
732 break;
733 case 0x15:
734 GETBYTE ();
735 switch (op[2] & 0x00)
736 {
737 case 0x00:
738 goto op_semantics_6;
739 break;
740 }
741 break;
742 case 0x16:
743 GETBYTE ();
744 switch (op[2] & 0x00)
745 {
746 case 0x00:
747 goto op_semantics_6;
748 break;
749 }
750 break;
751 case 0x17:
752 GETBYTE ();
753 switch (op[2] & 0x00)
754 {
755 case 0x00:
756 goto op_semantics_6;
757 break;
758 }
759 break;
760 case 0x20:
761 GETBYTE ();
762 switch (op[2] & 0xff)
763 {
764 case 0x00:
765 GETBYTE ();
766 switch (op[3] & 0x00)
767 {
768 case 0x00:
769 op_semantics_7:
770 {
771 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
772 #line 559 "rx-decode.opc"
773 int mx AU = (op[1] >> 6) & 0x03;
774 #line 559 "rx-decode.opc"
775 int sp AU = op[1] & 0x03;
776 #line 559 "rx-decode.opc"
777 int rsrc AU = (op[3] >> 4) & 0x0f;
778 #line 559 "rx-decode.opc"
779 int rdst AU = op[3] & 0x0f;
780 if (trace)
781 {
782 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
783 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
784 op[0], op[1], op[2], op[3]);
785 printf (" mx = 0x%x,", mx);
786 printf (" sp = 0x%x,", sp);
787 printf (" rsrc = 0x%x,", rsrc);
788 printf (" rdst = 0x%x\n", rdst);
789 }
790 SYNTAX("sbb %1%S1, %0");
791 #line 559 "rx-decode.opc"
792 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
793
794 /*----------------------------------------------------------------------*/
795 /* ABS */
796
797 }
798 break;
799 }
800 break;
801 case 0x04:
802 GETBYTE ();
803 switch (op[3] & 0x00)
804 {
805 case 0x00:
806 op_semantics_8:
807 {
808 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
809 #line 598 "rx-decode.opc"
810 int mx AU = (op[1] >> 6) & 0x03;
811 #line 598 "rx-decode.opc"
812 int ss AU = op[1] & 0x03;
813 #line 598 "rx-decode.opc"
814 int rsrc AU = (op[3] >> 4) & 0x0f;
815 #line 598 "rx-decode.opc"
816 int rdst AU = op[3] & 0x0f;
817 if (trace)
818 {
819 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
820 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
821 op[0], op[1], op[2], op[3]);
822 printf (" mx = 0x%x,", mx);
823 printf (" ss = 0x%x,", ss);
824 printf (" rsrc = 0x%x,", rsrc);
825 printf (" rdst = 0x%x\n", rdst);
826 }
827 SYNTAX("max %1%S1, %0");
828 #line 598 "rx-decode.opc"
829 ID(max); SPm(ss, rsrc, mx); DR(rdst);
830
831 /*----------------------------------------------------------------------*/
832 /* MIN */
833
834 }
835 break;
836 }
837 break;
838 case 0x05:
839 GETBYTE ();
840 switch (op[3] & 0x00)
841 {
842 case 0x00:
843 op_semantics_9:
844 {
845 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
846 #line 610 "rx-decode.opc"
847 int mx AU = (op[1] >> 6) & 0x03;
848 #line 610 "rx-decode.opc"
849 int ss AU = op[1] & 0x03;
850 #line 610 "rx-decode.opc"
851 int rsrc AU = (op[3] >> 4) & 0x0f;
852 #line 610 "rx-decode.opc"
853 int rdst AU = op[3] & 0x0f;
854 if (trace)
855 {
856 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
857 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
858 op[0], op[1], op[2], op[3]);
859 printf (" mx = 0x%x,", mx);
860 printf (" ss = 0x%x,", ss);
861 printf (" rsrc = 0x%x,", rsrc);
862 printf (" rdst = 0x%x\n", rdst);
863 }
864 SYNTAX("min %1%S1, %0");
865 #line 610 "rx-decode.opc"
866 ID(min); SPm(ss, rsrc, mx); DR(rdst);
867
868 /*----------------------------------------------------------------------*/
869 /* MUL */
870
871 }
872 break;
873 }
874 break;
875 case 0x06:
876 GETBYTE ();
877 switch (op[3] & 0x00)
878 {
879 case 0x00:
880 op_semantics_10:
881 {
882 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
883 #line 668 "rx-decode.opc"
884 int mx AU = (op[1] >> 6) & 0x03;
885 #line 668 "rx-decode.opc"
886 int ss AU = op[1] & 0x03;
887 #line 668 "rx-decode.opc"
888 int rsrc AU = (op[3] >> 4) & 0x0f;
889 #line 668 "rx-decode.opc"
890 int rdst AU = op[3] & 0x0f;
891 if (trace)
892 {
893 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
894 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
895 op[0], op[1], op[2], op[3]);
896 printf (" mx = 0x%x,", mx);
897 printf (" ss = 0x%x,", ss);
898 printf (" rsrc = 0x%x,", rsrc);
899 printf (" rdst = 0x%x\n", rdst);
900 }
901 SYNTAX("emul %1%S1, %0");
902 #line 668 "rx-decode.opc"
903 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
904
905 /*----------------------------------------------------------------------*/
906 /* EMULU */
907
908 }
909 break;
910 }
911 break;
912 case 0x07:
913 GETBYTE ();
914 switch (op[3] & 0x00)
915 {
916 case 0x00:
917 op_semantics_11:
918 {
919 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
920 #line 680 "rx-decode.opc"
921 int mx AU = (op[1] >> 6) & 0x03;
922 #line 680 "rx-decode.opc"
923 int ss AU = op[1] & 0x03;
924 #line 680 "rx-decode.opc"
925 int rsrc AU = (op[3] >> 4) & 0x0f;
926 #line 680 "rx-decode.opc"
927 int rdst AU = op[3] & 0x0f;
928 if (trace)
929 {
930 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
931 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
932 op[0], op[1], op[2], op[3]);
933 printf (" mx = 0x%x,", mx);
934 printf (" ss = 0x%x,", ss);
935 printf (" rsrc = 0x%x,", rsrc);
936 printf (" rdst = 0x%x\n", rdst);
937 }
938 SYNTAX("emulu %1%S1, %0");
939 #line 680 "rx-decode.opc"
940 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
941
942 /*----------------------------------------------------------------------*/
943 /* DIV */
944
945 }
946 break;
947 }
948 break;
949 case 0x08:
950 GETBYTE ();
951 switch (op[3] & 0x00)
952 {
953 case 0x00:
954 op_semantics_12:
955 {
956 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
957 #line 692 "rx-decode.opc"
958 int mx AU = (op[1] >> 6) & 0x03;
959 #line 692 "rx-decode.opc"
960 int ss AU = op[1] & 0x03;
961 #line 692 "rx-decode.opc"
962 int rsrc AU = (op[3] >> 4) & 0x0f;
963 #line 692 "rx-decode.opc"
964 int rdst AU = op[3] & 0x0f;
965 if (trace)
966 {
967 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
968 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
969 op[0], op[1], op[2], op[3]);
970 printf (" mx = 0x%x,", mx);
971 printf (" ss = 0x%x,", ss);
972 printf (" rsrc = 0x%x,", rsrc);
973 printf (" rdst = 0x%x\n", rdst);
974 }
975 SYNTAX("div %1%S1, %0");
976 #line 692 "rx-decode.opc"
977 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
978
979 /*----------------------------------------------------------------------*/
980 /* DIVU */
981
982 }
983 break;
984 }
985 break;
986 case 0x09:
987 GETBYTE ();
988 switch (op[3] & 0x00)
989 {
990 case 0x00:
991 op_semantics_13:
992 {
993 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
994 #line 704 "rx-decode.opc"
995 int mx AU = (op[1] >> 6) & 0x03;
996 #line 704 "rx-decode.opc"
997 int ss AU = op[1] & 0x03;
998 #line 704 "rx-decode.opc"
999 int rsrc AU = (op[3] >> 4) & 0x0f;
1000 #line 704 "rx-decode.opc"
1001 int rdst AU = op[3] & 0x0f;
1002 if (trace)
1003 {
1004 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1005 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1006 op[0], op[1], op[2], op[3]);
1007 printf (" mx = 0x%x,", mx);
1008 printf (" ss = 0x%x,", ss);
1009 printf (" rsrc = 0x%x,", rsrc);
1010 printf (" rdst = 0x%x\n", rdst);
1011 }
1012 SYNTAX("divu %1%S1, %0");
1013 #line 704 "rx-decode.opc"
1014 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1015
1016 /*----------------------------------------------------------------------*/
1017 /* SHIFT */
1018
1019 }
1020 break;
1021 }
1022 break;
1023 case 0x0c:
1024 GETBYTE ();
1025 switch (op[3] & 0x00)
1026 {
1027 case 0x00:
1028 op_semantics_14:
1029 {
1030 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1031 #line 477 "rx-decode.opc"
1032 int mx AU = (op[1] >> 6) & 0x03;
1033 #line 477 "rx-decode.opc"
1034 int ss AU = op[1] & 0x03;
1035 #line 477 "rx-decode.opc"
1036 int rsrc AU = (op[3] >> 4) & 0x0f;
1037 #line 477 "rx-decode.opc"
1038 int rdst AU = op[3] & 0x0f;
1039 if (trace)
1040 {
1041 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1042 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1043 op[0], op[1], op[2], op[3]);
1044 printf (" mx = 0x%x,", mx);
1045 printf (" ss = 0x%x,", ss);
1046 printf (" rsrc = 0x%x,", rsrc);
1047 printf (" rdst = 0x%x\n", rdst);
1048 }
1049 SYNTAX("tst %1%S1, %2");
1050 #line 477 "rx-decode.opc"
1051 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1052
1053 /*----------------------------------------------------------------------*/
1054 /* NEG */
1055
1056 }
1057 break;
1058 }
1059 break;
1060 case 0x0d:
1061 GETBYTE ();
1062 switch (op[3] & 0x00)
1063 {
1064 case 0x00:
1065 op_semantics_15:
1066 {
1067 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1068 #line 456 "rx-decode.opc"
1069 int mx AU = (op[1] >> 6) & 0x03;
1070 #line 456 "rx-decode.opc"
1071 int ss AU = op[1] & 0x03;
1072 #line 456 "rx-decode.opc"
1073 int rsrc AU = (op[3] >> 4) & 0x0f;
1074 #line 456 "rx-decode.opc"
1075 int rdst AU = op[3] & 0x0f;
1076 if (trace)
1077 {
1078 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1079 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1080 op[0], op[1], op[2], op[3]);
1081 printf (" mx = 0x%x,", mx);
1082 printf (" ss = 0x%x,", ss);
1083 printf (" rsrc = 0x%x,", rsrc);
1084 printf (" rdst = 0x%x\n", rdst);
1085 }
1086 SYNTAX("xor %1%S1, %0");
1087 #line 456 "rx-decode.opc"
1088 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1089
1090 /*----------------------------------------------------------------------*/
1091 /* NOT */
1092
1093 }
1094 break;
1095 }
1096 break;
1097 case 0x10:
1098 GETBYTE ();
1099 switch (op[3] & 0x00)
1100 {
1101 case 0x00:
1102 op_semantics_16:
1103 {
1104 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1105 #line 390 "rx-decode.opc"
1106 int mx AU = (op[1] >> 6) & 0x03;
1107 #line 390 "rx-decode.opc"
1108 int ss AU = op[1] & 0x03;
1109 #line 390 "rx-decode.opc"
1110 int rsrc AU = (op[3] >> 4) & 0x0f;
1111 #line 390 "rx-decode.opc"
1112 int rdst AU = op[3] & 0x0f;
1113 if (trace)
1114 {
1115 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1116 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1117 op[0], op[1], op[2], op[3]);
1118 printf (" mx = 0x%x,", mx);
1119 printf (" ss = 0x%x,", ss);
1120 printf (" rsrc = 0x%x,", rsrc);
1121 printf (" rdst = 0x%x\n", rdst);
1122 }
1123 SYNTAX("xchg %1%S1, %0");
1124 #line 390 "rx-decode.opc"
1125 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1126
1127 /*----------------------------------------------------------------------*/
1128 /* STZ/STNZ */
1129
1130 }
1131 break;
1132 }
1133 break;
1134 case 0x11:
1135 GETBYTE ();
1136 switch (op[3] & 0x00)
1137 {
1138 case 0x00:
1139 op_semantics_17:
1140 {
1141 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1142 #line 933 "rx-decode.opc"
1143 int mx AU = (op[1] >> 6) & 0x03;
1144 #line 933 "rx-decode.opc"
1145 int sd AU = op[1] & 0x03;
1146 #line 933 "rx-decode.opc"
1147 int rsrc AU = (op[3] >> 4) & 0x0f;
1148 #line 933 "rx-decode.opc"
1149 int rdst AU = op[3] & 0x0f;
1150 if (trace)
1151 {
1152 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1153 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1154 op[0], op[1], op[2], op[3]);
1155 printf (" mx = 0x%x,", mx);
1156 printf (" sd = 0x%x,", sd);
1157 printf (" rsrc = 0x%x,", rsrc);
1158 printf (" rdst = 0x%x\n", rdst);
1159 }
1160 SYNTAX("itof %1%S1, %0");
1161 #line 933 "rx-decode.opc"
1162 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1163
1164 /*----------------------------------------------------------------------*/
1165 /* BIT OPS */
1166
1167 }
1168 break;
1169 }
1170 break;
1171 case 0x15:
1172 GETBYTE ();
1173 switch (op[3] & 0x00)
1174 {
1175 case 0x00:
1176 op_semantics_18:
1177 {
1178 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
1179 #line 1119 "rx-decode.opc"
1180 int mx AU = (op[1] >> 6) & 0x03;
1181 #line 1119 "rx-decode.opc"
1182 int sd AU = op[1] & 0x03;
1183 #line 1119 "rx-decode.opc"
1184 int rsrc AU = (op[3] >> 4) & 0x0f;
1185 #line 1119 "rx-decode.opc"
1186 int rdst AU = op[3] & 0x0f;
1187 if (trace)
1188 {
1189 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1190 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1191 op[0], op[1], op[2], op[3]);
1192 printf (" mx = 0x%x,", mx);
1193 printf (" sd = 0x%x,", sd);
1194 printf (" rsrc = 0x%x,", rsrc);
1195 printf (" rdst = 0x%x\n", rdst);
1196 }
1197 SYNTAX("utof %1%S1, %0");
1198 #line 1119 "rx-decode.opc"
1199 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1200
1201 }
1202 break;
1203 }
1204 break;
1205 default: UNSUPPORTED(); break;
1206 }
1207 break;
1208 case 0x21:
1209 GETBYTE ();
1210 switch (op[2] & 0xff)
1211 {
1212 case 0x00:
1213 GETBYTE ();
1214 switch (op[3] & 0x00)
1215 {
1216 case 0x00:
1217 goto op_semantics_7;
1218 break;
1219 }
1220 break;
1221 case 0x04:
1222 GETBYTE ();
1223 switch (op[3] & 0x00)
1224 {
1225 case 0x00:
1226 goto op_semantics_8;
1227 break;
1228 }
1229 break;
1230 case 0x05:
1231 GETBYTE ();
1232 switch (op[3] & 0x00)
1233 {
1234 case 0x00:
1235 goto op_semantics_9;
1236 break;
1237 }
1238 break;
1239 case 0x06:
1240 GETBYTE ();
1241 switch (op[3] & 0x00)
1242 {
1243 case 0x00:
1244 goto op_semantics_10;
1245 break;
1246 }
1247 break;
1248 case 0x07:
1249 GETBYTE ();
1250 switch (op[3] & 0x00)
1251 {
1252 case 0x00:
1253 goto op_semantics_11;
1254 break;
1255 }
1256 break;
1257 case 0x08:
1258 GETBYTE ();
1259 switch (op[3] & 0x00)
1260 {
1261 case 0x00:
1262 goto op_semantics_12;
1263 break;
1264 }
1265 break;
1266 case 0x09:
1267 GETBYTE ();
1268 switch (op[3] & 0x00)
1269 {
1270 case 0x00:
1271 goto op_semantics_13;
1272 break;
1273 }
1274 break;
1275 case 0x0c:
1276 GETBYTE ();
1277 switch (op[3] & 0x00)
1278 {
1279 case 0x00:
1280 goto op_semantics_14;
1281 break;
1282 }
1283 break;
1284 case 0x0d:
1285 GETBYTE ();
1286 switch (op[3] & 0x00)
1287 {
1288 case 0x00:
1289 goto op_semantics_15;
1290 break;
1291 }
1292 break;
1293 case 0x10:
1294 GETBYTE ();
1295 switch (op[3] & 0x00)
1296 {
1297 case 0x00:
1298 goto op_semantics_16;
1299 break;
1300 }
1301 break;
1302 case 0x11:
1303 GETBYTE ();
1304 switch (op[3] & 0x00)
1305 {
1306 case 0x00:
1307 goto op_semantics_17;
1308 break;
1309 }
1310 break;
1311 case 0x15:
1312 GETBYTE ();
1313 switch (op[3] & 0x00)
1314 {
1315 case 0x00:
1316 goto op_semantics_18;
1317 break;
1318 }
1319 break;
1320 default: UNSUPPORTED(); break;
1321 }
1322 break;
1323 case 0x22:
1324 GETBYTE ();
1325 switch (op[2] & 0xff)
1326 {
1327 case 0x00:
1328 GETBYTE ();
1329 switch (op[3] & 0x00)
1330 {
1331 case 0x00:
1332 goto op_semantics_7;
1333 break;
1334 }
1335 break;
1336 case 0x04:
1337 GETBYTE ();
1338 switch (op[3] & 0x00)
1339 {
1340 case 0x00:
1341 goto op_semantics_8;
1342 break;
1343 }
1344 break;
1345 case 0x05:
1346 GETBYTE ();
1347 switch (op[3] & 0x00)
1348 {
1349 case 0x00:
1350 goto op_semantics_9;
1351 break;
1352 }
1353 break;
1354 case 0x06:
1355 GETBYTE ();
1356 switch (op[3] & 0x00)
1357 {
1358 case 0x00:
1359 goto op_semantics_10;
1360 break;
1361 }
1362 break;
1363 case 0x07:
1364 GETBYTE ();
1365 switch (op[3] & 0x00)
1366 {
1367 case 0x00:
1368 goto op_semantics_11;
1369 break;
1370 }
1371 break;
1372 case 0x08:
1373 GETBYTE ();
1374 switch (op[3] & 0x00)
1375 {
1376 case 0x00:
1377 goto op_semantics_12;
1378 break;
1379 }
1380 break;
1381 case 0x09:
1382 GETBYTE ();
1383 switch (op[3] & 0x00)
1384 {
1385 case 0x00:
1386 goto op_semantics_13;
1387 break;
1388 }
1389 break;
1390 case 0x0c:
1391 GETBYTE ();
1392 switch (op[3] & 0x00)
1393 {
1394 case 0x00:
1395 goto op_semantics_14;
1396 break;
1397 }
1398 break;
1399 case 0x0d:
1400 GETBYTE ();
1401 switch (op[3] & 0x00)
1402 {
1403 case 0x00:
1404 goto op_semantics_15;
1405 break;
1406 }
1407 break;
1408 case 0x10:
1409 GETBYTE ();
1410 switch (op[3] & 0x00)
1411 {
1412 case 0x00:
1413 goto op_semantics_16;
1414 break;
1415 }
1416 break;
1417 case 0x11:
1418 GETBYTE ();
1419 switch (op[3] & 0x00)
1420 {
1421 case 0x00:
1422 goto op_semantics_17;
1423 break;
1424 }
1425 break;
1426 case 0x15:
1427 GETBYTE ();
1428 switch (op[3] & 0x00)
1429 {
1430 case 0x00:
1431 goto op_semantics_18;
1432 break;
1433 }
1434 break;
1435 default: UNSUPPORTED(); break;
1436 }
1437 break;
1438 case 0x23:
1439 GETBYTE ();
1440 switch (op[2] & 0xff)
1441 {
1442 case 0x00:
1443 GETBYTE ();
1444 switch (op[3] & 0x00)
1445 {
1446 case 0x00:
1447 goto op_semantics_7;
1448 break;
1449 }
1450 break;
1451 case 0x04:
1452 GETBYTE ();
1453 switch (op[3] & 0x00)
1454 {
1455 case 0x00:
1456 goto op_semantics_8;
1457 break;
1458 }
1459 break;
1460 case 0x05:
1461 GETBYTE ();
1462 switch (op[3] & 0x00)
1463 {
1464 case 0x00:
1465 goto op_semantics_9;
1466 break;
1467 }
1468 break;
1469 case 0x06:
1470 GETBYTE ();
1471 switch (op[3] & 0x00)
1472 {
1473 case 0x00:
1474 goto op_semantics_10;
1475 break;
1476 }
1477 break;
1478 case 0x07:
1479 GETBYTE ();
1480 switch (op[3] & 0x00)
1481 {
1482 case 0x00:
1483 goto op_semantics_11;
1484 break;
1485 }
1486 break;
1487 case 0x08:
1488 GETBYTE ();
1489 switch (op[3] & 0x00)
1490 {
1491 case 0x00:
1492 goto op_semantics_12;
1493 break;
1494 }
1495 break;
1496 case 0x09:
1497 GETBYTE ();
1498 switch (op[3] & 0x00)
1499 {
1500 case 0x00:
1501 goto op_semantics_13;
1502 break;
1503 }
1504 break;
1505 case 0x0c:
1506 GETBYTE ();
1507 switch (op[3] & 0x00)
1508 {
1509 case 0x00:
1510 goto op_semantics_14;
1511 break;
1512 }
1513 break;
1514 case 0x0d:
1515 GETBYTE ();
1516 switch (op[3] & 0x00)
1517 {
1518 case 0x00:
1519 goto op_semantics_15;
1520 break;
1521 }
1522 break;
1523 case 0x10:
1524 GETBYTE ();
1525 switch (op[3] & 0x00)
1526 {
1527 case 0x00:
1528 goto op_semantics_16;
1529 break;
1530 }
1531 break;
1532 case 0x11:
1533 GETBYTE ();
1534 switch (op[3] & 0x00)
1535 {
1536 case 0x00:
1537 goto op_semantics_17;
1538 break;
1539 }
1540 break;
1541 case 0x15:
1542 GETBYTE ();
1543 switch (op[3] & 0x00)
1544 {
1545 case 0x00:
1546 goto op_semantics_18;
1547 break;
1548 }
1549 break;
1550 default: UNSUPPORTED(); break;
1551 }
1552 break;
1553 case 0x40:
1554 GETBYTE ();
1555 switch (op[2] & 0x00)
1556 {
1557 case 0x00:
1558 goto op_semantics_1;
1559 break;
1560 }
1561 break;
1562 case 0x41:
1563 GETBYTE ();
1564 switch (op[2] & 0x00)
1565 {
1566 case 0x00:
1567 goto op_semantics_1;
1568 break;
1569 }
1570 break;
1571 case 0x42:
1572 GETBYTE ();
1573 switch (op[2] & 0x00)
1574 {
1575 case 0x00:
1576 goto op_semantics_1;
1577 break;
1578 }
1579 break;
1580 case 0x43:
1581 GETBYTE ();
1582 switch (op[2] & 0x00)
1583 {
1584 case 0x00:
1585 goto op_semantics_1;
1586 break;
1587 }
1588 break;
1589 case 0x44:
1590 GETBYTE ();
1591 switch (op[2] & 0x00)
1592 {
1593 case 0x00:
1594 goto op_semantics_2;
1595 break;
1596 }
1597 break;
1598 case 0x45:
1599 GETBYTE ();
1600 switch (op[2] & 0x00)
1601 {
1602 case 0x00:
1603 goto op_semantics_2;
1604 break;
1605 }
1606 break;
1607 case 0x46:
1608 GETBYTE ();
1609 switch (op[2] & 0x00)
1610 {
1611 case 0x00:
1612 goto op_semantics_2;
1613 break;
1614 }
1615 break;
1616 case 0x47:
1617 GETBYTE ();
1618 switch (op[2] & 0x00)
1619 {
1620 case 0x00:
1621 goto op_semantics_2;
1622 break;
1623 }
1624 break;
1625 case 0x48:
1626 GETBYTE ();
1627 switch (op[2] & 0x00)
1628 {
1629 case 0x00:
1630 goto op_semantics_3;
1631 break;
1632 }
1633 break;
1634 case 0x49:
1635 GETBYTE ();
1636 switch (op[2] & 0x00)
1637 {
1638 case 0x00:
1639 goto op_semantics_3;
1640 break;
1641 }
1642 break;
1643 case 0x4a:
1644 GETBYTE ();
1645 switch (op[2] & 0x00)
1646 {
1647 case 0x00:
1648 goto op_semantics_3;
1649 break;
1650 }
1651 break;
1652 case 0x4b:
1653 GETBYTE ();
1654 switch (op[2] & 0x00)
1655 {
1656 case 0x00:
1657 goto op_semantics_3;
1658 break;
1659 }
1660 break;
1661 case 0x4c:
1662 GETBYTE ();
1663 switch (op[2] & 0x00)
1664 {
1665 case 0x00:
1666 goto op_semantics_4;
1667 break;
1668 }
1669 break;
1670 case 0x4d:
1671 GETBYTE ();
1672 switch (op[2] & 0x00)
1673 {
1674 case 0x00:
1675 goto op_semantics_4;
1676 break;
1677 }
1678 break;
1679 case 0x4e:
1680 GETBYTE ();
1681 switch (op[2] & 0x00)
1682 {
1683 case 0x00:
1684 goto op_semantics_4;
1685 break;
1686 }
1687 break;
1688 case 0x4f:
1689 GETBYTE ();
1690 switch (op[2] & 0x00)
1691 {
1692 case 0x00:
1693 goto op_semantics_4;
1694 break;
1695 }
1696 break;
1697 case 0x50:
1698 GETBYTE ();
1699 switch (op[2] & 0x00)
1700 {
1701 case 0x00:
1702 goto op_semantics_5;
1703 break;
1704 }
1705 break;
1706 case 0x51:
1707 GETBYTE ();
1708 switch (op[2] & 0x00)
1709 {
1710 case 0x00:
1711 goto op_semantics_5;
1712 break;
1713 }
1714 break;
1715 case 0x52:
1716 GETBYTE ();
1717 switch (op[2] & 0x00)
1718 {
1719 case 0x00:
1720 goto op_semantics_5;
1721 break;
1722 }
1723 break;
1724 case 0x53:
1725 GETBYTE ();
1726 switch (op[2] & 0x00)
1727 {
1728 case 0x00:
1729 goto op_semantics_5;
1730 break;
1731 }
1732 break;
1733 case 0x54:
1734 GETBYTE ();
1735 switch (op[2] & 0x00)
1736 {
1737 case 0x00:
1738 goto op_semantics_6;
1739 break;
1740 }
1741 break;
1742 case 0x55:
1743 GETBYTE ();
1744 switch (op[2] & 0x00)
1745 {
1746 case 0x00:
1747 goto op_semantics_6;
1748 break;
1749 }
1750 break;
1751 case 0x56:
1752 GETBYTE ();
1753 switch (op[2] & 0x00)
1754 {
1755 case 0x00:
1756 goto op_semantics_6;
1757 break;
1758 }
1759 break;
1760 case 0x57:
1761 GETBYTE ();
1762 switch (op[2] & 0x00)
1763 {
1764 case 0x00:
1765 goto op_semantics_6;
1766 break;
1767 }
1768 break;
1769 case 0x60:
1770 GETBYTE ();
1771 switch (op[2] & 0xff)
1772 {
1773 case 0x00:
1774 GETBYTE ();
1775 switch (op[3] & 0x00)
1776 {
1777 case 0x00:
1778 goto op_semantics_7;
1779 break;
1780 }
1781 break;
1782 case 0x04:
1783 GETBYTE ();
1784 switch (op[3] & 0x00)
1785 {
1786 case 0x00:
1787 goto op_semantics_8;
1788 break;
1789 }
1790 break;
1791 case 0x05:
1792 GETBYTE ();
1793 switch (op[3] & 0x00)
1794 {
1795 case 0x00:
1796 goto op_semantics_9;
1797 break;
1798 }
1799 break;
1800 case 0x06:
1801 GETBYTE ();
1802 switch (op[3] & 0x00)
1803 {
1804 case 0x00:
1805 goto op_semantics_10;
1806 break;
1807 }
1808 break;
1809 case 0x07:
1810 GETBYTE ();
1811 switch (op[3] & 0x00)
1812 {
1813 case 0x00:
1814 goto op_semantics_11;
1815 break;
1816 }
1817 break;
1818 case 0x08:
1819 GETBYTE ();
1820 switch (op[3] & 0x00)
1821 {
1822 case 0x00:
1823 goto op_semantics_12;
1824 break;
1825 }
1826 break;
1827 case 0x09:
1828 GETBYTE ();
1829 switch (op[3] & 0x00)
1830 {
1831 case 0x00:
1832 goto op_semantics_13;
1833 break;
1834 }
1835 break;
1836 case 0x0c:
1837 GETBYTE ();
1838 switch (op[3] & 0x00)
1839 {
1840 case 0x00:
1841 goto op_semantics_14;
1842 break;
1843 }
1844 break;
1845 case 0x0d:
1846 GETBYTE ();
1847 switch (op[3] & 0x00)
1848 {
1849 case 0x00:
1850 goto op_semantics_15;
1851 break;
1852 }
1853 break;
1854 case 0x10:
1855 GETBYTE ();
1856 switch (op[3] & 0x00)
1857 {
1858 case 0x00:
1859 goto op_semantics_16;
1860 break;
1861 }
1862 break;
1863 case 0x11:
1864 GETBYTE ();
1865 switch (op[3] & 0x00)
1866 {
1867 case 0x00:
1868 goto op_semantics_17;
1869 break;
1870 }
1871 break;
1872 case 0x15:
1873 GETBYTE ();
1874 switch (op[3] & 0x00)
1875 {
1876 case 0x00:
1877 goto op_semantics_18;
1878 break;
1879 }
1880 break;
1881 default: UNSUPPORTED(); break;
1882 }
1883 break;
1884 case 0x61:
1885 GETBYTE ();
1886 switch (op[2] & 0xff)
1887 {
1888 case 0x00:
1889 GETBYTE ();
1890 switch (op[3] & 0x00)
1891 {
1892 case 0x00:
1893 goto op_semantics_7;
1894 break;
1895 }
1896 break;
1897 case 0x04:
1898 GETBYTE ();
1899 switch (op[3] & 0x00)
1900 {
1901 case 0x00:
1902 goto op_semantics_8;
1903 break;
1904 }
1905 break;
1906 case 0x05:
1907 GETBYTE ();
1908 switch (op[3] & 0x00)
1909 {
1910 case 0x00:
1911 goto op_semantics_9;
1912 break;
1913 }
1914 break;
1915 case 0x06:
1916 GETBYTE ();
1917 switch (op[3] & 0x00)
1918 {
1919 case 0x00:
1920 goto op_semantics_10;
1921 break;
1922 }
1923 break;
1924 case 0x07:
1925 GETBYTE ();
1926 switch (op[3] & 0x00)
1927 {
1928 case 0x00:
1929 goto op_semantics_11;
1930 break;
1931 }
1932 break;
1933 case 0x08:
1934 GETBYTE ();
1935 switch (op[3] & 0x00)
1936 {
1937 case 0x00:
1938 goto op_semantics_12;
1939 break;
1940 }
1941 break;
1942 case 0x09:
1943 GETBYTE ();
1944 switch (op[3] & 0x00)
1945 {
1946 case 0x00:
1947 goto op_semantics_13;
1948 break;
1949 }
1950 break;
1951 case 0x0c:
1952 GETBYTE ();
1953 switch (op[3] & 0x00)
1954 {
1955 case 0x00:
1956 goto op_semantics_14;
1957 break;
1958 }
1959 break;
1960 case 0x0d:
1961 GETBYTE ();
1962 switch (op[3] & 0x00)
1963 {
1964 case 0x00:
1965 goto op_semantics_15;
1966 break;
1967 }
1968 break;
1969 case 0x10:
1970 GETBYTE ();
1971 switch (op[3] & 0x00)
1972 {
1973 case 0x00:
1974 goto op_semantics_16;
1975 break;
1976 }
1977 break;
1978 case 0x11:
1979 GETBYTE ();
1980 switch (op[3] & 0x00)
1981 {
1982 case 0x00:
1983 goto op_semantics_17;
1984 break;
1985 }
1986 break;
1987 case 0x15:
1988 GETBYTE ();
1989 switch (op[3] & 0x00)
1990 {
1991 case 0x00:
1992 goto op_semantics_18;
1993 break;
1994 }
1995 break;
1996 default: UNSUPPORTED(); break;
1997 }
1998 break;
1999 case 0x62:
2000 GETBYTE ();
2001 switch (op[2] & 0xff)
2002 {
2003 case 0x00:
2004 GETBYTE ();
2005 switch (op[3] & 0x00)
2006 {
2007 case 0x00:
2008 goto op_semantics_7;
2009 break;
2010 }
2011 break;
2012 case 0x04:
2013 GETBYTE ();
2014 switch (op[3] & 0x00)
2015 {
2016 case 0x00:
2017 goto op_semantics_8;
2018 break;
2019 }
2020 break;
2021 case 0x05:
2022 GETBYTE ();
2023 switch (op[3] & 0x00)
2024 {
2025 case 0x00:
2026 goto op_semantics_9;
2027 break;
2028 }
2029 break;
2030 case 0x06:
2031 GETBYTE ();
2032 switch (op[3] & 0x00)
2033 {
2034 case 0x00:
2035 goto op_semantics_10;
2036 break;
2037 }
2038 break;
2039 case 0x07:
2040 GETBYTE ();
2041 switch (op[3] & 0x00)
2042 {
2043 case 0x00:
2044 goto op_semantics_11;
2045 break;
2046 }
2047 break;
2048 case 0x08:
2049 GETBYTE ();
2050 switch (op[3] & 0x00)
2051 {
2052 case 0x00:
2053 goto op_semantics_12;
2054 break;
2055 }
2056 break;
2057 case 0x09:
2058 GETBYTE ();
2059 switch (op[3] & 0x00)
2060 {
2061 case 0x00:
2062 goto op_semantics_13;
2063 break;
2064 }
2065 break;
2066 case 0x0c:
2067 GETBYTE ();
2068 switch (op[3] & 0x00)
2069 {
2070 case 0x00:
2071 goto op_semantics_14;
2072 break;
2073 }
2074 break;
2075 case 0x0d:
2076 GETBYTE ();
2077 switch (op[3] & 0x00)
2078 {
2079 case 0x00:
2080 goto op_semantics_15;
2081 break;
2082 }
2083 break;
2084 case 0x10:
2085 GETBYTE ();
2086 switch (op[3] & 0x00)
2087 {
2088 case 0x00:
2089 goto op_semantics_16;
2090 break;
2091 }
2092 break;
2093 case 0x11:
2094 GETBYTE ();
2095 switch (op[3] & 0x00)
2096 {
2097 case 0x00:
2098 goto op_semantics_17;
2099 break;
2100 }
2101 break;
2102 case 0x15:
2103 GETBYTE ();
2104 switch (op[3] & 0x00)
2105 {
2106 case 0x00:
2107 goto op_semantics_18;
2108 break;
2109 }
2110 break;
2111 default: UNSUPPORTED(); break;
2112 }
2113 break;
2114 case 0x63:
2115 GETBYTE ();
2116 switch (op[2] & 0xff)
2117 {
2118 case 0x00:
2119 GETBYTE ();
2120 switch (op[3] & 0x00)
2121 {
2122 case 0x00:
2123 goto op_semantics_7;
2124 break;
2125 }
2126 break;
2127 case 0x04:
2128 GETBYTE ();
2129 switch (op[3] & 0x00)
2130 {
2131 case 0x00:
2132 goto op_semantics_8;
2133 break;
2134 }
2135 break;
2136 case 0x05:
2137 GETBYTE ();
2138 switch (op[3] & 0x00)
2139 {
2140 case 0x00:
2141 goto op_semantics_9;
2142 break;
2143 }
2144 break;
2145 case 0x06:
2146 GETBYTE ();
2147 switch (op[3] & 0x00)
2148 {
2149 case 0x00:
2150 goto op_semantics_10;
2151 break;
2152 }
2153 break;
2154 case 0x07:
2155 GETBYTE ();
2156 switch (op[3] & 0x00)
2157 {
2158 case 0x00:
2159 goto op_semantics_11;
2160 break;
2161 }
2162 break;
2163 case 0x08:
2164 GETBYTE ();
2165 switch (op[3] & 0x00)
2166 {
2167 case 0x00:
2168 goto op_semantics_12;
2169 break;
2170 }
2171 break;
2172 case 0x09:
2173 GETBYTE ();
2174 switch (op[3] & 0x00)
2175 {
2176 case 0x00:
2177 goto op_semantics_13;
2178 break;
2179 }
2180 break;
2181 case 0x0c:
2182 GETBYTE ();
2183 switch (op[3] & 0x00)
2184 {
2185 case 0x00:
2186 goto op_semantics_14;
2187 break;
2188 }
2189 break;
2190 case 0x0d:
2191 GETBYTE ();
2192 switch (op[3] & 0x00)
2193 {
2194 case 0x00:
2195 goto op_semantics_15;
2196 break;
2197 }
2198 break;
2199 case 0x10:
2200 GETBYTE ();
2201 switch (op[3] & 0x00)
2202 {
2203 case 0x00:
2204 goto op_semantics_16;
2205 break;
2206 }
2207 break;
2208 case 0x11:
2209 GETBYTE ();
2210 switch (op[3] & 0x00)
2211 {
2212 case 0x00:
2213 goto op_semantics_17;
2214 break;
2215 }
2216 break;
2217 case 0x15:
2218 GETBYTE ();
2219 switch (op[3] & 0x00)
2220 {
2221 case 0x00:
2222 goto op_semantics_18;
2223 break;
2224 }
2225 break;
2226 default: UNSUPPORTED(); break;
2227 }
2228 break;
2229 case 0x80:
2230 GETBYTE ();
2231 switch (op[2] & 0x00)
2232 {
2233 case 0x00:
2234 goto op_semantics_1;
2235 break;
2236 }
2237 break;
2238 case 0x81:
2239 GETBYTE ();
2240 switch (op[2] & 0x00)
2241 {
2242 case 0x00:
2243 goto op_semantics_1;
2244 break;
2245 }
2246 break;
2247 case 0x82:
2248 GETBYTE ();
2249 switch (op[2] & 0x00)
2250 {
2251 case 0x00:
2252 goto op_semantics_1;
2253 break;
2254 }
2255 break;
2256 case 0x83:
2257 GETBYTE ();
2258 switch (op[2] & 0x00)
2259 {
2260 case 0x00:
2261 goto op_semantics_1;
2262 break;
2263 }
2264 break;
2265 case 0x84:
2266 GETBYTE ();
2267 switch (op[2] & 0x00)
2268 {
2269 case 0x00:
2270 goto op_semantics_2;
2271 break;
2272 }
2273 break;
2274 case 0x85:
2275 GETBYTE ();
2276 switch (op[2] & 0x00)
2277 {
2278 case 0x00:
2279 goto op_semantics_2;
2280 break;
2281 }
2282 break;
2283 case 0x86:
2284 GETBYTE ();
2285 switch (op[2] & 0x00)
2286 {
2287 case 0x00:
2288 goto op_semantics_2;
2289 break;
2290 }
2291 break;
2292 case 0x87:
2293 GETBYTE ();
2294 switch (op[2] & 0x00)
2295 {
2296 case 0x00:
2297 goto op_semantics_2;
2298 break;
2299 }
2300 break;
2301 case 0x88:
2302 GETBYTE ();
2303 switch (op[2] & 0x00)
2304 {
2305 case 0x00:
2306 goto op_semantics_3;
2307 break;
2308 }
2309 break;
2310 case 0x89:
2311 GETBYTE ();
2312 switch (op[2] & 0x00)
2313 {
2314 case 0x00:
2315 goto op_semantics_3;
2316 break;
2317 }
2318 break;
2319 case 0x8a:
2320 GETBYTE ();
2321 switch (op[2] & 0x00)
2322 {
2323 case 0x00:
2324 goto op_semantics_3;
2325 break;
2326 }
2327 break;
2328 case 0x8b:
2329 GETBYTE ();
2330 switch (op[2] & 0x00)
2331 {
2332 case 0x00:
2333 goto op_semantics_3;
2334 break;
2335 }
2336 break;
2337 case 0x8c:
2338 GETBYTE ();
2339 switch (op[2] & 0x00)
2340 {
2341 case 0x00:
2342 goto op_semantics_4;
2343 break;
2344 }
2345 break;
2346 case 0x8d:
2347 GETBYTE ();
2348 switch (op[2] & 0x00)
2349 {
2350 case 0x00:
2351 goto op_semantics_4;
2352 break;
2353 }
2354 break;
2355 case 0x8e:
2356 GETBYTE ();
2357 switch (op[2] & 0x00)
2358 {
2359 case 0x00:
2360 goto op_semantics_4;
2361 break;
2362 }
2363 break;
2364 case 0x8f:
2365 GETBYTE ();
2366 switch (op[2] & 0x00)
2367 {
2368 case 0x00:
2369 goto op_semantics_4;
2370 break;
2371 }
2372 break;
2373 case 0x90:
2374 GETBYTE ();
2375 switch (op[2] & 0x00)
2376 {
2377 case 0x00:
2378 goto op_semantics_5;
2379 break;
2380 }
2381 break;
2382 case 0x91:
2383 GETBYTE ();
2384 switch (op[2] & 0x00)
2385 {
2386 case 0x00:
2387 goto op_semantics_5;
2388 break;
2389 }
2390 break;
2391 case 0x92:
2392 GETBYTE ();
2393 switch (op[2] & 0x00)
2394 {
2395 case 0x00:
2396 goto op_semantics_5;
2397 break;
2398 }
2399 break;
2400 case 0x93:
2401 GETBYTE ();
2402 switch (op[2] & 0x00)
2403 {
2404 case 0x00:
2405 goto op_semantics_5;
2406 break;
2407 }
2408 break;
2409 case 0x94:
2410 GETBYTE ();
2411 switch (op[2] & 0x00)
2412 {
2413 case 0x00:
2414 goto op_semantics_6;
2415 break;
2416 }
2417 break;
2418 case 0x95:
2419 GETBYTE ();
2420 switch (op[2] & 0x00)
2421 {
2422 case 0x00:
2423 goto op_semantics_6;
2424 break;
2425 }
2426 break;
2427 case 0x96:
2428 GETBYTE ();
2429 switch (op[2] & 0x00)
2430 {
2431 case 0x00:
2432 goto op_semantics_6;
2433 break;
2434 }
2435 break;
2436 case 0x97:
2437 GETBYTE ();
2438 switch (op[2] & 0x00)
2439 {
2440 case 0x00:
2441 goto op_semantics_6;
2442 break;
2443 }
2444 break;
2445 case 0xa0:
2446 GETBYTE ();
2447 switch (op[2] & 0xff)
2448 {
2449 case 0x00:
2450 GETBYTE ();
2451 switch (op[3] & 0x00)
2452 {
2453 case 0x00:
2454 goto op_semantics_7;
2455 break;
2456 }
2457 break;
2458 case 0x02:
2459 GETBYTE ();
2460 switch (op[3] & 0x00)
2461 {
2462 case 0x00:
2463 op_semantics_19:
2464 {
2465 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2466 #line 498 "rx-decode.opc"
2467 int ss AU = op[1] & 0x03;
2468 #line 498 "rx-decode.opc"
2469 int rsrc AU = (op[3] >> 4) & 0x0f;
2470 #line 498 "rx-decode.opc"
2471 int rdst AU = op[3] & 0x0f;
2472 if (trace)
2473 {
2474 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2475 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2476 op[0], op[1], op[2], op[3]);
2477 printf (" ss = 0x%x,", ss);
2478 printf (" rsrc = 0x%x,", rsrc);
2479 printf (" rdst = 0x%x\n", rdst);
2480 }
2481 SYNTAX("adc %1%S1, %0");
2482 #line 498 "rx-decode.opc"
2483 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2484
2485 /*----------------------------------------------------------------------*/
2486 /* ADD */
2487
2488 }
2489 break;
2490 }
2491 break;
2492 case 0x04:
2493 GETBYTE ();
2494 switch (op[3] & 0x00)
2495 {
2496 case 0x00:
2497 goto op_semantics_8;
2498 break;
2499 }
2500 break;
2501 case 0x05:
2502 GETBYTE ();
2503 switch (op[3] & 0x00)
2504 {
2505 case 0x00:
2506 goto op_semantics_9;
2507 break;
2508 }
2509 break;
2510 case 0x06:
2511 GETBYTE ();
2512 switch (op[3] & 0x00)
2513 {
2514 case 0x00:
2515 goto op_semantics_10;
2516 break;
2517 }
2518 break;
2519 case 0x07:
2520 GETBYTE ();
2521 switch (op[3] & 0x00)
2522 {
2523 case 0x00:
2524 goto op_semantics_11;
2525 break;
2526 }
2527 break;
2528 case 0x08:
2529 GETBYTE ();
2530 switch (op[3] & 0x00)
2531 {
2532 case 0x00:
2533 goto op_semantics_12;
2534 break;
2535 }
2536 break;
2537 case 0x09:
2538 GETBYTE ();
2539 switch (op[3] & 0x00)
2540 {
2541 case 0x00:
2542 goto op_semantics_13;
2543 break;
2544 }
2545 break;
2546 case 0x0c:
2547 GETBYTE ();
2548 switch (op[3] & 0x00)
2549 {
2550 case 0x00:
2551 goto op_semantics_14;
2552 break;
2553 }
2554 break;
2555 case 0x0d:
2556 GETBYTE ();
2557 switch (op[3] & 0x00)
2558 {
2559 case 0x00:
2560 goto op_semantics_15;
2561 break;
2562 }
2563 break;
2564 case 0x10:
2565 GETBYTE ();
2566 switch (op[3] & 0x00)
2567 {
2568 case 0x00:
2569 goto op_semantics_16;
2570 break;
2571 }
2572 break;
2573 case 0x11:
2574 GETBYTE ();
2575 switch (op[3] & 0x00)
2576 {
2577 case 0x00:
2578 goto op_semantics_17;
2579 break;
2580 }
2581 break;
2582 case 0x15:
2583 GETBYTE ();
2584 switch (op[3] & 0x00)
2585 {
2586 case 0x00:
2587 goto op_semantics_18;
2588 break;
2589 }
2590 break;
2591 default: UNSUPPORTED(); break;
2592 }
2593 break;
2594 case 0xa1:
2595 GETBYTE ();
2596 switch (op[2] & 0xff)
2597 {
2598 case 0x00:
2599 GETBYTE ();
2600 switch (op[3] & 0x00)
2601 {
2602 case 0x00:
2603 goto op_semantics_7;
2604 break;
2605 }
2606 break;
2607 case 0x02:
2608 GETBYTE ();
2609 switch (op[3] & 0x00)
2610 {
2611 case 0x00:
2612 goto op_semantics_19;
2613 break;
2614 }
2615 break;
2616 case 0x04:
2617 GETBYTE ();
2618 switch (op[3] & 0x00)
2619 {
2620 case 0x00:
2621 goto op_semantics_8;
2622 break;
2623 }
2624 break;
2625 case 0x05:
2626 GETBYTE ();
2627 switch (op[3] & 0x00)
2628 {
2629 case 0x00:
2630 goto op_semantics_9;
2631 break;
2632 }
2633 break;
2634 case 0x06:
2635 GETBYTE ();
2636 switch (op[3] & 0x00)
2637 {
2638 case 0x00:
2639 goto op_semantics_10;
2640 break;
2641 }
2642 break;
2643 case 0x07:
2644 GETBYTE ();
2645 switch (op[3] & 0x00)
2646 {
2647 case 0x00:
2648 goto op_semantics_11;
2649 break;
2650 }
2651 break;
2652 case 0x08:
2653 GETBYTE ();
2654 switch (op[3] & 0x00)
2655 {
2656 case 0x00:
2657 goto op_semantics_12;
2658 break;
2659 }
2660 break;
2661 case 0x09:
2662 GETBYTE ();
2663 switch (op[3] & 0x00)
2664 {
2665 case 0x00:
2666 goto op_semantics_13;
2667 break;
2668 }
2669 break;
2670 case 0x0c:
2671 GETBYTE ();
2672 switch (op[3] & 0x00)
2673 {
2674 case 0x00:
2675 goto op_semantics_14;
2676 break;
2677 }
2678 break;
2679 case 0x0d:
2680 GETBYTE ();
2681 switch (op[3] & 0x00)
2682 {
2683 case 0x00:
2684 goto op_semantics_15;
2685 break;
2686 }
2687 break;
2688 case 0x10:
2689 GETBYTE ();
2690 switch (op[3] & 0x00)
2691 {
2692 case 0x00:
2693 goto op_semantics_16;
2694 break;
2695 }
2696 break;
2697 case 0x11:
2698 GETBYTE ();
2699 switch (op[3] & 0x00)
2700 {
2701 case 0x00:
2702 goto op_semantics_17;
2703 break;
2704 }
2705 break;
2706 case 0x15:
2707 GETBYTE ();
2708 switch (op[3] & 0x00)
2709 {
2710 case 0x00:
2711 goto op_semantics_18;
2712 break;
2713 }
2714 break;
2715 default: UNSUPPORTED(); break;
2716 }
2717 break;
2718 case 0xa2:
2719 GETBYTE ();
2720 switch (op[2] & 0xff)
2721 {
2722 case 0x00:
2723 GETBYTE ();
2724 switch (op[3] & 0x00)
2725 {
2726 case 0x00:
2727 goto op_semantics_7;
2728 break;
2729 }
2730 break;
2731 case 0x02:
2732 GETBYTE ();
2733 switch (op[3] & 0x00)
2734 {
2735 case 0x00:
2736 goto op_semantics_19;
2737 break;
2738 }
2739 break;
2740 case 0x04:
2741 GETBYTE ();
2742 switch (op[3] & 0x00)
2743 {
2744 case 0x00:
2745 goto op_semantics_8;
2746 break;
2747 }
2748 break;
2749 case 0x05:
2750 GETBYTE ();
2751 switch (op[3] & 0x00)
2752 {
2753 case 0x00:
2754 goto op_semantics_9;
2755 break;
2756 }
2757 break;
2758 case 0x06:
2759 GETBYTE ();
2760 switch (op[3] & 0x00)
2761 {
2762 case 0x00:
2763 goto op_semantics_10;
2764 break;
2765 }
2766 break;
2767 case 0x07:
2768 GETBYTE ();
2769 switch (op[3] & 0x00)
2770 {
2771 case 0x00:
2772 goto op_semantics_11;
2773 break;
2774 }
2775 break;
2776 case 0x08:
2777 GETBYTE ();
2778 switch (op[3] & 0x00)
2779 {
2780 case 0x00:
2781 goto op_semantics_12;
2782 break;
2783 }
2784 break;
2785 case 0x09:
2786 GETBYTE ();
2787 switch (op[3] & 0x00)
2788 {
2789 case 0x00:
2790 goto op_semantics_13;
2791 break;
2792 }
2793 break;
2794 case 0x0c:
2795 GETBYTE ();
2796 switch (op[3] & 0x00)
2797 {
2798 case 0x00:
2799 goto op_semantics_14;
2800 break;
2801 }
2802 break;
2803 case 0x0d:
2804 GETBYTE ();
2805 switch (op[3] & 0x00)
2806 {
2807 case 0x00:
2808 goto op_semantics_15;
2809 break;
2810 }
2811 break;
2812 case 0x10:
2813 GETBYTE ();
2814 switch (op[3] & 0x00)
2815 {
2816 case 0x00:
2817 goto op_semantics_16;
2818 break;
2819 }
2820 break;
2821 case 0x11:
2822 GETBYTE ();
2823 switch (op[3] & 0x00)
2824 {
2825 case 0x00:
2826 goto op_semantics_17;
2827 break;
2828 }
2829 break;
2830 case 0x15:
2831 GETBYTE ();
2832 switch (op[3] & 0x00)
2833 {
2834 case 0x00:
2835 goto op_semantics_18;
2836 break;
2837 }
2838 break;
2839 default: UNSUPPORTED(); break;
2840 }
2841 break;
2842 case 0xa3:
2843 GETBYTE ();
2844 switch (op[2] & 0xff)
2845 {
2846 case 0x00:
2847 GETBYTE ();
2848 switch (op[3] & 0x00)
2849 {
2850 case 0x00:
2851 goto op_semantics_7;
2852 break;
2853 }
2854 break;
2855 case 0x02:
2856 GETBYTE ();
2857 switch (op[3] & 0x00)
2858 {
2859 case 0x00:
2860 goto op_semantics_19;
2861 break;
2862 }
2863 break;
2864 case 0x04:
2865 GETBYTE ();
2866 switch (op[3] & 0x00)
2867 {
2868 case 0x00:
2869 goto op_semantics_8;
2870 break;
2871 }
2872 break;
2873 case 0x05:
2874 GETBYTE ();
2875 switch (op[3] & 0x00)
2876 {
2877 case 0x00:
2878 goto op_semantics_9;
2879 break;
2880 }
2881 break;
2882 case 0x06:
2883 GETBYTE ();
2884 switch (op[3] & 0x00)
2885 {
2886 case 0x00:
2887 goto op_semantics_10;
2888 break;
2889 }
2890 break;
2891 case 0x07:
2892 GETBYTE ();
2893 switch (op[3] & 0x00)
2894 {
2895 case 0x00:
2896 goto op_semantics_11;
2897 break;
2898 }
2899 break;
2900 case 0x08:
2901 GETBYTE ();
2902 switch (op[3] & 0x00)
2903 {
2904 case 0x00:
2905 goto op_semantics_12;
2906 break;
2907 }
2908 break;
2909 case 0x09:
2910 GETBYTE ();
2911 switch (op[3] & 0x00)
2912 {
2913 case 0x00:
2914 goto op_semantics_13;
2915 break;
2916 }
2917 break;
2918 case 0x0c:
2919 GETBYTE ();
2920 switch (op[3] & 0x00)
2921 {
2922 case 0x00:
2923 goto op_semantics_14;
2924 break;
2925 }
2926 break;
2927 case 0x0d:
2928 GETBYTE ();
2929 switch (op[3] & 0x00)
2930 {
2931 case 0x00:
2932 goto op_semantics_15;
2933 break;
2934 }
2935 break;
2936 case 0x10:
2937 GETBYTE ();
2938 switch (op[3] & 0x00)
2939 {
2940 case 0x00:
2941 goto op_semantics_16;
2942 break;
2943 }
2944 break;
2945 case 0x11:
2946 GETBYTE ();
2947 switch (op[3] & 0x00)
2948 {
2949 case 0x00:
2950 goto op_semantics_17;
2951 break;
2952 }
2953 break;
2954 case 0x15:
2955 GETBYTE ();
2956 switch (op[3] & 0x00)
2957 {
2958 case 0x00:
2959 goto op_semantics_18;
2960 break;
2961 }
2962 break;
2963 default: UNSUPPORTED(); break;
2964 }
2965 break;
2966 case 0xc0:
2967 GETBYTE ();
2968 switch (op[2] & 0x00)
2969 {
2970 case 0x00:
2971 goto op_semantics_1;
2972 break;
2973 }
2974 break;
2975 case 0xc1:
2976 GETBYTE ();
2977 switch (op[2] & 0x00)
2978 {
2979 case 0x00:
2980 goto op_semantics_1;
2981 break;
2982 }
2983 break;
2984 case 0xc2:
2985 GETBYTE ();
2986 switch (op[2] & 0x00)
2987 {
2988 case 0x00:
2989 goto op_semantics_1;
2990 break;
2991 }
2992 break;
2993 case 0xc3:
2994 GETBYTE ();
2995 switch (op[2] & 0x00)
2996 {
2997 case 0x00:
2998 goto op_semantics_1;
2999 break;
3000 }
3001 break;
3002 case 0xc4:
3003 GETBYTE ();
3004 switch (op[2] & 0x00)
3005 {
3006 case 0x00:
3007 goto op_semantics_2;
3008 break;
3009 }
3010 break;
3011 case 0xc5:
3012 GETBYTE ();
3013 switch (op[2] & 0x00)
3014 {
3015 case 0x00:
3016 goto op_semantics_2;
3017 break;
3018 }
3019 break;
3020 case 0xc6:
3021 GETBYTE ();
3022 switch (op[2] & 0x00)
3023 {
3024 case 0x00:
3025 goto op_semantics_2;
3026 break;
3027 }
3028 break;
3029 case 0xc7:
3030 GETBYTE ();
3031 switch (op[2] & 0x00)
3032 {
3033 case 0x00:
3034 goto op_semantics_2;
3035 break;
3036 }
3037 break;
3038 case 0xc8:
3039 GETBYTE ();
3040 switch (op[2] & 0x00)
3041 {
3042 case 0x00:
3043 goto op_semantics_3;
3044 break;
3045 }
3046 break;
3047 case 0xc9:
3048 GETBYTE ();
3049 switch (op[2] & 0x00)
3050 {
3051 case 0x00:
3052 goto op_semantics_3;
3053 break;
3054 }
3055 break;
3056 case 0xca:
3057 GETBYTE ();
3058 switch (op[2] & 0x00)
3059 {
3060 case 0x00:
3061 goto op_semantics_3;
3062 break;
3063 }
3064 break;
3065 case 0xcb:
3066 GETBYTE ();
3067 switch (op[2] & 0x00)
3068 {
3069 case 0x00:
3070 goto op_semantics_3;
3071 break;
3072 }
3073 break;
3074 case 0xcc:
3075 GETBYTE ();
3076 switch (op[2] & 0x00)
3077 {
3078 case 0x00:
3079 goto op_semantics_4;
3080 break;
3081 }
3082 break;
3083 case 0xcd:
3084 GETBYTE ();
3085 switch (op[2] & 0x00)
3086 {
3087 case 0x00:
3088 goto op_semantics_4;
3089 break;
3090 }
3091 break;
3092 case 0xce:
3093 GETBYTE ();
3094 switch (op[2] & 0x00)
3095 {
3096 case 0x00:
3097 goto op_semantics_4;
3098 break;
3099 }
3100 break;
3101 case 0xcf:
3102 GETBYTE ();
3103 switch (op[2] & 0x00)
3104 {
3105 case 0x00:
3106 goto op_semantics_4;
3107 break;
3108 }
3109 break;
3110 case 0xd0:
3111 GETBYTE ();
3112 switch (op[2] & 0x00)
3113 {
3114 case 0x00:
3115 goto op_semantics_5;
3116 break;
3117 }
3118 break;
3119 case 0xd1:
3120 GETBYTE ();
3121 switch (op[2] & 0x00)
3122 {
3123 case 0x00:
3124 goto op_semantics_5;
3125 break;
3126 }
3127 break;
3128 case 0xd2:
3129 GETBYTE ();
3130 switch (op[2] & 0x00)
3131 {
3132 case 0x00:
3133 goto op_semantics_5;
3134 break;
3135 }
3136 break;
3137 case 0xd3:
3138 GETBYTE ();
3139 switch (op[2] & 0x00)
3140 {
3141 case 0x00:
3142 goto op_semantics_5;
3143 break;
3144 }
3145 break;
3146 case 0xd4:
3147 GETBYTE ();
3148 switch (op[2] & 0x00)
3149 {
3150 case 0x00:
3151 goto op_semantics_6;
3152 break;
3153 }
3154 break;
3155 case 0xd5:
3156 GETBYTE ();
3157 switch (op[2] & 0x00)
3158 {
3159 case 0x00:
3160 goto op_semantics_6;
3161 break;
3162 }
3163 break;
3164 case 0xd6:
3165 GETBYTE ();
3166 switch (op[2] & 0x00)
3167 {
3168 case 0x00:
3169 goto op_semantics_6;
3170 break;
3171 }
3172 break;
3173 case 0xd7:
3174 GETBYTE ();
3175 switch (op[2] & 0x00)
3176 {
3177 case 0x00:
3178 goto op_semantics_6;
3179 break;
3180 }
3181 break;
3182 case 0xe0:
3183 GETBYTE ();
3184 switch (op[2] & 0xff)
3185 {
3186 case 0x00:
3187 GETBYTE ();
3188 switch (op[3] & 0x00)
3189 {
3190 case 0x00:
3191 goto op_semantics_7;
3192 break;
3193 }
3194 break;
3195 case 0x04:
3196 GETBYTE ();
3197 switch (op[3] & 0x00)
3198 {
3199 case 0x00:
3200 goto op_semantics_8;
3201 break;
3202 }
3203 break;
3204 case 0x05:
3205 GETBYTE ();
3206 switch (op[3] & 0x00)
3207 {
3208 case 0x00:
3209 goto op_semantics_9;
3210 break;
3211 }
3212 break;
3213 case 0x06:
3214 GETBYTE ();
3215 switch (op[3] & 0x00)
3216 {
3217 case 0x00:
3218 goto op_semantics_10;
3219 break;
3220 }
3221 break;
3222 case 0x07:
3223 GETBYTE ();
3224 switch (op[3] & 0x00)
3225 {
3226 case 0x00:
3227 goto op_semantics_11;
3228 break;
3229 }
3230 break;
3231 case 0x08:
3232 GETBYTE ();
3233 switch (op[3] & 0x00)
3234 {
3235 case 0x00:
3236 goto op_semantics_12;
3237 break;
3238 }
3239 break;
3240 case 0x09:
3241 GETBYTE ();
3242 switch (op[3] & 0x00)
3243 {
3244 case 0x00:
3245 goto op_semantics_13;
3246 break;
3247 }
3248 break;
3249 case 0x0c:
3250 GETBYTE ();
3251 switch (op[3] & 0x00)
3252 {
3253 case 0x00:
3254 goto op_semantics_14;
3255 break;
3256 }
3257 break;
3258 case 0x0d:
3259 GETBYTE ();
3260 switch (op[3] & 0x00)
3261 {
3262 case 0x00:
3263 goto op_semantics_15;
3264 break;
3265 }
3266 break;
3267 case 0x10:
3268 GETBYTE ();
3269 switch (op[3] & 0x00)
3270 {
3271 case 0x00:
3272 goto op_semantics_16;
3273 break;
3274 }
3275 break;
3276 case 0x11:
3277 GETBYTE ();
3278 switch (op[3] & 0x00)
3279 {
3280 case 0x00:
3281 goto op_semantics_17;
3282 break;
3283 }
3284 break;
3285 case 0x15:
3286 GETBYTE ();
3287 switch (op[3] & 0x00)
3288 {
3289 case 0x00:
3290 goto op_semantics_18;
3291 break;
3292 }
3293 break;
3294 default: UNSUPPORTED(); break;
3295 }
3296 break;
3297 case 0xe1:
3298 GETBYTE ();
3299 switch (op[2] & 0xff)
3300 {
3301 case 0x00:
3302 GETBYTE ();
3303 switch (op[3] & 0x00)
3304 {
3305 case 0x00:
3306 goto op_semantics_7;
3307 break;
3308 }
3309 break;
3310 case 0x04:
3311 GETBYTE ();
3312 switch (op[3] & 0x00)
3313 {
3314 case 0x00:
3315 goto op_semantics_8;
3316 break;
3317 }
3318 break;
3319 case 0x05:
3320 GETBYTE ();
3321 switch (op[3] & 0x00)
3322 {
3323 case 0x00:
3324 goto op_semantics_9;
3325 break;
3326 }
3327 break;
3328 case 0x06:
3329 GETBYTE ();
3330 switch (op[3] & 0x00)
3331 {
3332 case 0x00:
3333 goto op_semantics_10;
3334 break;
3335 }
3336 break;
3337 case 0x07:
3338 GETBYTE ();
3339 switch (op[3] & 0x00)
3340 {
3341 case 0x00:
3342 goto op_semantics_11;
3343 break;
3344 }
3345 break;
3346 case 0x08:
3347 GETBYTE ();
3348 switch (op[3] & 0x00)
3349 {
3350 case 0x00:
3351 goto op_semantics_12;
3352 break;
3353 }
3354 break;
3355 case 0x09:
3356 GETBYTE ();
3357 switch (op[3] & 0x00)
3358 {
3359 case 0x00:
3360 goto op_semantics_13;
3361 break;
3362 }
3363 break;
3364 case 0x0c:
3365 GETBYTE ();
3366 switch (op[3] & 0x00)
3367 {
3368 case 0x00:
3369 goto op_semantics_14;
3370 break;
3371 }
3372 break;
3373 case 0x0d:
3374 GETBYTE ();
3375 switch (op[3] & 0x00)
3376 {
3377 case 0x00:
3378 goto op_semantics_15;
3379 break;
3380 }
3381 break;
3382 case 0x10:
3383 GETBYTE ();
3384 switch (op[3] & 0x00)
3385 {
3386 case 0x00:
3387 goto op_semantics_16;
3388 break;
3389 }
3390 break;
3391 case 0x11:
3392 GETBYTE ();
3393 switch (op[3] & 0x00)
3394 {
3395 case 0x00:
3396 goto op_semantics_17;
3397 break;
3398 }
3399 break;
3400 case 0x15:
3401 GETBYTE ();
3402 switch (op[3] & 0x00)
3403 {
3404 case 0x00:
3405 goto op_semantics_18;
3406 break;
3407 }
3408 break;
3409 default: UNSUPPORTED(); break;
3410 }
3411 break;
3412 case 0xe2:
3413 GETBYTE ();
3414 switch (op[2] & 0xff)
3415 {
3416 case 0x00:
3417 GETBYTE ();
3418 switch (op[3] & 0x00)
3419 {
3420 case 0x00:
3421 goto op_semantics_7;
3422 break;
3423 }
3424 break;
3425 case 0x04:
3426 GETBYTE ();
3427 switch (op[3] & 0x00)
3428 {
3429 case 0x00:
3430 goto op_semantics_8;
3431 break;
3432 }
3433 break;
3434 case 0x05:
3435 GETBYTE ();
3436 switch (op[3] & 0x00)
3437 {
3438 case 0x00:
3439 goto op_semantics_9;
3440 break;
3441 }
3442 break;
3443 case 0x06:
3444 GETBYTE ();
3445 switch (op[3] & 0x00)
3446 {
3447 case 0x00:
3448 goto op_semantics_10;
3449 break;
3450 }
3451 break;
3452 case 0x07:
3453 GETBYTE ();
3454 switch (op[3] & 0x00)
3455 {
3456 case 0x00:
3457 goto op_semantics_11;
3458 break;
3459 }
3460 break;
3461 case 0x08:
3462 GETBYTE ();
3463 switch (op[3] & 0x00)
3464 {
3465 case 0x00:
3466 goto op_semantics_12;
3467 break;
3468 }
3469 break;
3470 case 0x09:
3471 GETBYTE ();
3472 switch (op[3] & 0x00)
3473 {
3474 case 0x00:
3475 goto op_semantics_13;
3476 break;
3477 }
3478 break;
3479 case 0x0c:
3480 GETBYTE ();
3481 switch (op[3] & 0x00)
3482 {
3483 case 0x00:
3484 goto op_semantics_14;
3485 break;
3486 }
3487 break;
3488 case 0x0d:
3489 GETBYTE ();
3490 switch (op[3] & 0x00)
3491 {
3492 case 0x00:
3493 goto op_semantics_15;
3494 break;
3495 }
3496 break;
3497 case 0x10:
3498 GETBYTE ();
3499 switch (op[3] & 0x00)
3500 {
3501 case 0x00:
3502 goto op_semantics_16;
3503 break;
3504 }
3505 break;
3506 case 0x11:
3507 GETBYTE ();
3508 switch (op[3] & 0x00)
3509 {
3510 case 0x00:
3511 goto op_semantics_17;
3512 break;
3513 }
3514 break;
3515 case 0x15:
3516 GETBYTE ();
3517 switch (op[3] & 0x00)
3518 {
3519 case 0x00:
3520 goto op_semantics_18;
3521 break;
3522 }
3523 break;
3524 default: UNSUPPORTED(); break;
3525 }
3526 break;
3527 case 0xe3:
3528 GETBYTE ();
3529 switch (op[2] & 0xff)
3530 {
3531 case 0x00:
3532 GETBYTE ();
3533 switch (op[3] & 0x00)
3534 {
3535 case 0x00:
3536 goto op_semantics_7;
3537 break;
3538 }
3539 break;
3540 case 0x04:
3541 GETBYTE ();
3542 switch (op[3] & 0x00)
3543 {
3544 case 0x00:
3545 goto op_semantics_8;
3546 break;
3547 }
3548 break;
3549 case 0x05:
3550 GETBYTE ();
3551 switch (op[3] & 0x00)
3552 {
3553 case 0x00:
3554 goto op_semantics_9;
3555 break;
3556 }
3557 break;
3558 case 0x06:
3559 GETBYTE ();
3560 switch (op[3] & 0x00)
3561 {
3562 case 0x00:
3563 goto op_semantics_10;
3564 break;
3565 }
3566 break;
3567 case 0x07:
3568 GETBYTE ();
3569 switch (op[3] & 0x00)
3570 {
3571 case 0x00:
3572 goto op_semantics_11;
3573 break;
3574 }
3575 break;
3576 case 0x08:
3577 GETBYTE ();
3578 switch (op[3] & 0x00)
3579 {
3580 case 0x00:
3581 goto op_semantics_12;
3582 break;
3583 }
3584 break;
3585 case 0x09:
3586 GETBYTE ();
3587 switch (op[3] & 0x00)
3588 {
3589 case 0x00:
3590 goto op_semantics_13;
3591 break;
3592 }
3593 break;
3594 case 0x0c:
3595 GETBYTE ();
3596 switch (op[3] & 0x00)
3597 {
3598 case 0x00:
3599 goto op_semantics_14;
3600 break;
3601 }
3602 break;
3603 case 0x0d:
3604 GETBYTE ();
3605 switch (op[3] & 0x00)
3606 {
3607 case 0x00:
3608 goto op_semantics_15;
3609 break;
3610 }
3611 break;
3612 case 0x10:
3613 GETBYTE ();
3614 switch (op[3] & 0x00)
3615 {
3616 case 0x00:
3617 goto op_semantics_16;
3618 break;
3619 }
3620 break;
3621 case 0x11:
3622 GETBYTE ();
3623 switch (op[3] & 0x00)
3624 {
3625 case 0x00:
3626 goto op_semantics_17;
3627 break;
3628 }
3629 break;
3630 case 0x15:
3631 GETBYTE ();
3632 switch (op[3] & 0x00)
3633 {
3634 case 0x00:
3635 goto op_semantics_18;
3636 break;
3637 }
3638 break;
3639 default: UNSUPPORTED(); break;
3640 }
3641 break;
3642 default: UNSUPPORTED(); break;
3643 }
3644 break;
3645 case 0x08:
3646 case 0x09:
3647 case 0x0a:
3648 case 0x0b:
3649 case 0x0c:
3650 case 0x0d:
3651 case 0x0e:
3652 case 0x0f:
3653 {
3654 /** 0000 1dsp bra.s %a0 */
3655 #line 779 "rx-decode.opc"
3656 int dsp AU = op[0] & 0x07;
3657 if (trace)
3658 {
3659 printf ("\033[33m%s\033[0m %02x\n",
3660 "/** 0000 1dsp bra.s %a0 */",
3661 op[0]);
3662 printf (" dsp = 0x%x\n", dsp);
3663 }
3664 SYNTAX("bra.s %a0");
3665 #line 779 "rx-decode.opc"
3666 ID(branch); DC(pc + dsp3map[dsp]);
3667
3668 }
3669 break;
3670 case 0x10:
3671 case 0x11:
3672 case 0x12:
3673 case 0x13:
3674 case 0x14:
3675 case 0x15:
3676 case 0x16:
3677 case 0x17:
3678 case 0x18:
3679 case 0x19:
3680 case 0x1a:
3681 case 0x1b:
3682 case 0x1c:
3683 case 0x1d:
3684 case 0x1e:
3685 case 0x1f:
3686 {
3687 /** 0001 n dsp b%1.s %a0 */
3688 #line 769 "rx-decode.opc"
3689 int n AU = (op[0] >> 3) & 0x01;
3690 #line 769 "rx-decode.opc"
3691 int dsp AU = op[0] & 0x07;
3692 if (trace)
3693 {
3694 printf ("\033[33m%s\033[0m %02x\n",
3695 "/** 0001 n dsp b%1.s %a0 */",
3696 op[0]);
3697 printf (" n = 0x%x,", n);
3698 printf (" dsp = 0x%x\n", dsp);
3699 }
3700 SYNTAX("b%1.s %a0");
3701 #line 769 "rx-decode.opc"
3702 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3703
3704 }
3705 break;
3706 case 0x20:
3707 case 0x21:
3708 case 0x22:
3709 case 0x23:
3710 case 0x24:
3711 case 0x25:
3712 case 0x26:
3713 case 0x27:
3714 case 0x28:
3715 case 0x29:
3716 case 0x2a:
3717 case 0x2b:
3718 case 0x2c:
3719 case 0x2d:
3720 case 0x2f:
3721 {
3722 /** 0010 cond b%1.b %a0 */
3723 #line 772 "rx-decode.opc"
3724 int cond AU = op[0] & 0x0f;
3725 if (trace)
3726 {
3727 printf ("\033[33m%s\033[0m %02x\n",
3728 "/** 0010 cond b%1.b %a0 */",
3729 op[0]);
3730 printf (" cond = 0x%x\n", cond);
3731 }
3732 SYNTAX("b%1.b %a0");
3733 #line 772 "rx-decode.opc"
3734 ID(branch); Scc(cond); DC(pc + IMMex (1));
3735
3736 }
3737 break;
3738 case 0x2e:
3739 {
3740 /** 0010 1110 bra.b %a0 */
3741 if (trace)
3742 {
3743 printf ("\033[33m%s\033[0m %02x\n",
3744 "/** 0010 1110 bra.b %a0 */",
3745 op[0]);
3746 }
3747 SYNTAX("bra.b %a0");
3748 #line 782 "rx-decode.opc"
3749 ID(branch); DC(pc + IMMex(1));
3750
3751 }
3752 break;
3753 case 0x38:
3754 {
3755 /** 0011 1000 bra.w %a0 */
3756 if (trace)
3757 {
3758 printf ("\033[33m%s\033[0m %02x\n",
3759 "/** 0011 1000 bra.w %a0 */",
3760 op[0]);
3761 }
3762 SYNTAX("bra.w %a0");
3763 #line 785 "rx-decode.opc"
3764 ID(branch); DC(pc + IMMex(2));
3765
3766 }
3767 break;
3768 case 0x39:
3769 {
3770 /** 0011 1001 bsr.w %a0 */
3771 if (trace)
3772 {
3773 printf ("\033[33m%s\033[0m %02x\n",
3774 "/** 0011 1001 bsr.w %a0 */",
3775 op[0]);
3776 }
3777 SYNTAX("bsr.w %a0");
3778 #line 801 "rx-decode.opc"
3779 ID(jsr); DC(pc + IMMex(2));
3780
3781 }
3782 break;
3783 case 0x3a:
3784 case 0x3b:
3785 {
3786 /** 0011 101c b%1.w %a0 */
3787 #line 775 "rx-decode.opc"
3788 int c AU = op[0] & 0x01;
3789 if (trace)
3790 {
3791 printf ("\033[33m%s\033[0m %02x\n",
3792 "/** 0011 101c b%1.w %a0 */",
3793 op[0]);
3794 printf (" c = 0x%x\n", c);
3795 }
3796 SYNTAX("b%1.w %a0");
3797 #line 775 "rx-decode.opc"
3798 ID(branch); Scc(c); DC(pc + IMMex (2));
3799
3800
3801 }
3802 break;
3803 case 0x3c:
3804 GETBYTE ();
3805 switch (op[1] & 0x00)
3806 {
3807 case 0x00:
3808 op_semantics_20:
3809 {
3810 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3811 #line 311 "rx-decode.opc"
3812 int sz AU = op[0] & 0x03;
3813 #line 311 "rx-decode.opc"
3814 int d AU = (op[1] >> 7) & 0x01;
3815 #line 311 "rx-decode.opc"
3816 int dst AU = (op[1] >> 4) & 0x07;
3817 #line 311 "rx-decode.opc"
3818 int sppp AU = op[1] & 0x0f;
3819 if (trace)
3820 {
3821 printf ("\033[33m%s\033[0m %02x %02x\n",
3822 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3823 op[0], op[1]);
3824 printf (" sz = 0x%x,", sz);
3825 printf (" d = 0x%x,", d);
3826 printf (" dst = 0x%x,", dst);
3827 printf (" sppp = 0x%x\n", sppp);
3828 }
3829 SYNTAX("mov%s #%1, %0");
3830 #line 311 "rx-decode.opc"
3831 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3832
3833 }
3834 break;
3835 }
3836 break;
3837 case 0x3d:
3838 GETBYTE ();
3839 switch (op[1] & 0x00)
3840 {
3841 case 0x00:
3842 goto op_semantics_20;
3843 break;
3844 }
3845 break;
3846 case 0x3e:
3847 GETBYTE ();
3848 switch (op[1] & 0x00)
3849 {
3850 case 0x00:
3851 goto op_semantics_20;
3852 break;
3853 }
3854 break;
3855 case 0x3f:
3856 GETBYTE ();
3857 switch (op[1] & 0x00)
3858 {
3859 case 0x00:
3860 {
3861 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3862 #line 408 "rx-decode.opc"
3863 int rega AU = (op[1] >> 4) & 0x0f;
3864 #line 408 "rx-decode.opc"
3865 int regb AU = op[1] & 0x0f;
3866 if (trace)
3867 {
3868 printf ("\033[33m%s\033[0m %02x %02x\n",
3869 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3870 op[0], op[1]);
3871 printf (" rega = 0x%x,", rega);
3872 printf (" regb = 0x%x\n", regb);
3873 }
3874 SYNTAX("rtsd #%1, %2-%0");
3875 #line 408 "rx-decode.opc"
3876 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3877
3878 /*----------------------------------------------------------------------*/
3879 /* AND */
3880
3881 }
3882 break;
3883 }
3884 break;
3885 case 0x40:
3886 GETBYTE ();
3887 switch (op[1] & 0x00)
3888 {
3889 case 0x00:
3890 op_semantics_21:
3891 {
3892 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3893 #line 543 "rx-decode.opc"
3894 int ss AU = op[0] & 0x03;
3895 #line 543 "rx-decode.opc"
3896 int rsrc AU = (op[1] >> 4) & 0x0f;
3897 #line 543 "rx-decode.opc"
3898 int rdst AU = op[1] & 0x0f;
3899 if (trace)
3900 {
3901 printf ("\033[33m%s\033[0m %02x %02x\n",
3902 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3903 op[0], op[1]);
3904 printf (" ss = 0x%x,", ss);
3905 printf (" rsrc = 0x%x,", rsrc);
3906 printf (" rdst = 0x%x\n", rdst);
3907 }
3908 SYNTAX("sub %2%S2, %1");
3909 #line 543 "rx-decode.opc"
3910 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3911
3912 }
3913 break;
3914 }
3915 break;
3916 case 0x41:
3917 GETBYTE ();
3918 switch (op[1] & 0x00)
3919 {
3920 case 0x00:
3921 goto op_semantics_21;
3922 break;
3923 }
3924 break;
3925 case 0x42:
3926 GETBYTE ();
3927 switch (op[1] & 0x00)
3928 {
3929 case 0x00:
3930 goto op_semantics_21;
3931 break;
3932 }
3933 break;
3934 case 0x43:
3935 GETBYTE ();
3936 switch (op[1] & 0x00)
3937 {
3938 case 0x00:
3939 goto op_semantics_21;
3940 break;
3941 }
3942 break;
3943 case 0x44:
3944 GETBYTE ();
3945 switch (op[1] & 0x00)
3946 {
3947 case 0x00:
3948 op_semantics_22:
3949 {
3950 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3951 #line 531 "rx-decode.opc"
3952 int ss AU = op[0] & 0x03;
3953 #line 531 "rx-decode.opc"
3954 int rsrc AU = (op[1] >> 4) & 0x0f;
3955 #line 531 "rx-decode.opc"
3956 int rdst AU = op[1] & 0x0f;
3957 if (trace)
3958 {
3959 printf ("\033[33m%s\033[0m %02x %02x\n",
3960 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3961 op[0], op[1]);
3962 printf (" ss = 0x%x,", ss);
3963 printf (" rsrc = 0x%x,", rsrc);
3964 printf (" rdst = 0x%x\n", rdst);
3965 }
3966 SYNTAX("cmp %2%S2, %1");
3967 #line 531 "rx-decode.opc"
3968 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3969
3970 }
3971 break;
3972 }
3973 break;
3974 case 0x45:
3975 GETBYTE ();
3976 switch (op[1] & 0x00)
3977 {
3978 case 0x00:
3979 goto op_semantics_22;
3980 break;
3981 }
3982 break;
3983 case 0x46:
3984 GETBYTE ();
3985 switch (op[1] & 0x00)
3986 {
3987 case 0x00:
3988 goto op_semantics_22;
3989 break;
3990 }
3991 break;
3992 case 0x47:
3993 GETBYTE ();
3994 switch (op[1] & 0x00)
3995 {
3996 case 0x00:
3997 goto op_semantics_22;
3998 break;
3999 }
4000 break;
4001 case 0x48:
4002 GETBYTE ();
4003 switch (op[1] & 0x00)
4004 {
4005 case 0x00:
4006 op_semantics_23:
4007 {
4008 /** 0100 10ss rsrc rdst add %1%S1, %0 */
4009 #line 507 "rx-decode.opc"
4010 int ss AU = op[0] & 0x03;
4011 #line 507 "rx-decode.opc"
4012 int rsrc AU = (op[1] >> 4) & 0x0f;
4013 #line 507 "rx-decode.opc"
4014 int rdst AU = op[1] & 0x0f;
4015 if (trace)
4016 {
4017 printf ("\033[33m%s\033[0m %02x %02x\n",
4018 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4019 op[0], op[1]);
4020 printf (" ss = 0x%x,", ss);
4021 printf (" rsrc = 0x%x,", rsrc);
4022 printf (" rdst = 0x%x\n", rdst);
4023 }
4024 SYNTAX("add %1%S1, %0");
4025 #line 507 "rx-decode.opc"
4026 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4027
4028 }
4029 break;
4030 }
4031 break;
4032 case 0x49:
4033 GETBYTE ();
4034 switch (op[1] & 0x00)
4035 {
4036 case 0x00:
4037 goto op_semantics_23;
4038 break;
4039 }
4040 break;
4041 case 0x4a:
4042 GETBYTE ();
4043 switch (op[1] & 0x00)
4044 {
4045 case 0x00:
4046 goto op_semantics_23;
4047 break;
4048 }
4049 break;
4050 case 0x4b:
4051 GETBYTE ();
4052 switch (op[1] & 0x00)
4053 {
4054 case 0x00:
4055 goto op_semantics_23;
4056 break;
4057 }
4058 break;
4059 case 0x4c:
4060 GETBYTE ();
4061 switch (op[1] & 0x00)
4062 {
4063 case 0x00:
4064 op_semantics_24:
4065 {
4066 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
4067 #line 650 "rx-decode.opc"
4068 int ss AU = op[0] & 0x03;
4069 #line 650 "rx-decode.opc"
4070 int rsrc AU = (op[1] >> 4) & 0x0f;
4071 #line 650 "rx-decode.opc"
4072 int rdst AU = op[1] & 0x0f;
4073 if (trace)
4074 {
4075 printf ("\033[33m%s\033[0m %02x %02x\n",
4076 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4077 op[0], op[1]);
4078 printf (" ss = 0x%x,", ss);
4079 printf (" rsrc = 0x%x,", rsrc);
4080 printf (" rdst = 0x%x\n", rdst);
4081 }
4082 SYNTAX("mul %1%S1, %0");
4083 #line 650 "rx-decode.opc"
4084 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4085
4086 }
4087 break;
4088 }
4089 break;
4090 case 0x4d:
4091 GETBYTE ();
4092 switch (op[1] & 0x00)
4093 {
4094 case 0x00:
4095 goto op_semantics_24;
4096 break;
4097 }
4098 break;
4099 case 0x4e:
4100 GETBYTE ();
4101 switch (op[1] & 0x00)
4102 {
4103 case 0x00:
4104 goto op_semantics_24;
4105 break;
4106 }
4107 break;
4108 case 0x4f:
4109 GETBYTE ();
4110 switch (op[1] & 0x00)
4111 {
4112 case 0x00:
4113 goto op_semantics_24;
4114 break;
4115 }
4116 break;
4117 case 0x50:
4118 GETBYTE ();
4119 switch (op[1] & 0x00)
4120 {
4121 case 0x00:
4122 op_semantics_25:
4123 {
4124 /** 0101 00ss rsrc rdst and %1%S1, %0 */
4125 #line 420 "rx-decode.opc"
4126 int ss AU = op[0] & 0x03;
4127 #line 420 "rx-decode.opc"
4128 int rsrc AU = (op[1] >> 4) & 0x0f;
4129 #line 420 "rx-decode.opc"
4130 int rdst AU = op[1] & 0x0f;
4131 if (trace)
4132 {
4133 printf ("\033[33m%s\033[0m %02x %02x\n",
4134 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4135 op[0], op[1]);
4136 printf (" ss = 0x%x,", ss);
4137 printf (" rsrc = 0x%x,", rsrc);
4138 printf (" rdst = 0x%x\n", rdst);
4139 }
4140 SYNTAX("and %1%S1, %0");
4141 #line 420 "rx-decode.opc"
4142 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4143
4144 }
4145 break;
4146 }
4147 break;
4148 case 0x51:
4149 GETBYTE ();
4150 switch (op[1] & 0x00)
4151 {
4152 case 0x00:
4153 goto op_semantics_25;
4154 break;
4155 }
4156 break;
4157 case 0x52:
4158 GETBYTE ();
4159 switch (op[1] & 0x00)
4160 {
4161 case 0x00:
4162 goto op_semantics_25;
4163 break;
4164 }
4165 break;
4166 case 0x53:
4167 GETBYTE ();
4168 switch (op[1] & 0x00)
4169 {
4170 case 0x00:
4171 goto op_semantics_25;
4172 break;
4173 }
4174 break;
4175 case 0x54:
4176 GETBYTE ();
4177 switch (op[1] & 0x00)
4178 {
4179 case 0x00:
4180 op_semantics_26:
4181 {
4182 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4183 #line 438 "rx-decode.opc"
4184 int ss AU = op[0] & 0x03;
4185 #line 438 "rx-decode.opc"
4186 int rsrc AU = (op[1] >> 4) & 0x0f;
4187 #line 438 "rx-decode.opc"
4188 int rdst AU = op[1] & 0x0f;
4189 if (trace)
4190 {
4191 printf ("\033[33m%s\033[0m %02x %02x\n",
4192 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4193 op[0], op[1]);
4194 printf (" ss = 0x%x,", ss);
4195 printf (" rsrc = 0x%x,", rsrc);
4196 printf (" rdst = 0x%x\n", rdst);
4197 }
4198 SYNTAX("or %1%S1, %0");
4199 #line 438 "rx-decode.opc"
4200 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4201
4202 }
4203 break;
4204 }
4205 break;
4206 case 0x55:
4207 GETBYTE ();
4208 switch (op[1] & 0x00)
4209 {
4210 case 0x00:
4211 goto op_semantics_26;
4212 break;
4213 }
4214 break;
4215 case 0x56:
4216 GETBYTE ();
4217 switch (op[1] & 0x00)
4218 {
4219 case 0x00:
4220 goto op_semantics_26;
4221 break;
4222 }
4223 break;
4224 case 0x57:
4225 GETBYTE ();
4226 switch (op[1] & 0x00)
4227 {
4228 case 0x00:
4229 goto op_semantics_26;
4230 break;
4231 }
4232 break;
4233 case 0x58:
4234 GETBYTE ();
4235 switch (op[1] & 0x00)
4236 {
4237 case 0x00:
4238 op_semantics_27:
4239 {
4240 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4241 #line 359 "rx-decode.opc"
4242 int s AU = (op[0] >> 2) & 0x01;
4243 #line 359 "rx-decode.opc"
4244 int ss AU = op[0] & 0x03;
4245 #line 359 "rx-decode.opc"
4246 int rsrc AU = (op[1] >> 4) & 0x0f;
4247 #line 359 "rx-decode.opc"
4248 int rdst AU = op[1] & 0x0f;
4249 if (trace)
4250 {
4251 printf ("\033[33m%s\033[0m %02x %02x\n",
4252 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4253 op[0], op[1]);
4254 printf (" s = 0x%x,", s);
4255 printf (" ss = 0x%x,", ss);
4256 printf (" rsrc = 0x%x,", rsrc);
4257 printf (" rdst = 0x%x\n", rdst);
4258 }
4259 SYNTAX("movu%s %1, %0");
4260 #line 359 "rx-decode.opc"
4261 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4262
4263 }
4264 break;
4265 }
4266 break;
4267 case 0x59:
4268 GETBYTE ();
4269 switch (op[1] & 0x00)
4270 {
4271 case 0x00:
4272 goto op_semantics_27;
4273 break;
4274 }
4275 break;
4276 case 0x5a:
4277 GETBYTE ();
4278 switch (op[1] & 0x00)
4279 {
4280 case 0x00:
4281 goto op_semantics_27;
4282 break;
4283 }
4284 break;
4285 case 0x5b:
4286 GETBYTE ();
4287 switch (op[1] & 0x00)
4288 {
4289 case 0x00:
4290 goto op_semantics_27;
4291 break;
4292 }
4293 break;
4294 case 0x5c:
4295 GETBYTE ();
4296 switch (op[1] & 0x00)
4297 {
4298 case 0x00:
4299 goto op_semantics_27;
4300 break;
4301 }
4302 break;
4303 case 0x5d:
4304 GETBYTE ();
4305 switch (op[1] & 0x00)
4306 {
4307 case 0x00:
4308 goto op_semantics_27;
4309 break;
4310 }
4311 break;
4312 case 0x5e:
4313 GETBYTE ();
4314 switch (op[1] & 0x00)
4315 {
4316 case 0x00:
4317 goto op_semantics_27;
4318 break;
4319 }
4320 break;
4321 case 0x5f:
4322 GETBYTE ();
4323 switch (op[1] & 0x00)
4324 {
4325 case 0x00:
4326 goto op_semantics_27;
4327 break;
4328 }
4329 break;
4330 case 0x60:
4331 GETBYTE ();
4332 switch (op[1] & 0x00)
4333 {
4334 case 0x00:
4335 {
4336 /** 0110 0000 immm rdst sub #%2, %0 */
4337 #line 540 "rx-decode.opc"
4338 int immm AU = (op[1] >> 4) & 0x0f;
4339 #line 540 "rx-decode.opc"
4340 int rdst AU = op[1] & 0x0f;
4341 if (trace)
4342 {
4343 printf ("\033[33m%s\033[0m %02x %02x\n",
4344 "/** 0110 0000 immm rdst sub #%2, %0 */",
4345 op[0], op[1]);
4346 printf (" immm = 0x%x,", immm);
4347 printf (" rdst = 0x%x\n", rdst);
4348 }
4349 SYNTAX("sub #%2, %0");
4350 #line 540 "rx-decode.opc"
4351 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4352
4353 }
4354 break;
4355 }
4356 break;
4357 case 0x61:
4358 GETBYTE ();
4359 switch (op[1] & 0x00)
4360 {
4361 case 0x00:
4362 {
4363 /** 0110 0001 immm rdst cmp #%2, %1 */
4364 #line 522 "rx-decode.opc"
4365 int immm AU = (op[1] >> 4) & 0x0f;
4366 #line 522 "rx-decode.opc"
4367 int rdst AU = op[1] & 0x0f;
4368 if (trace)
4369 {
4370 printf ("\033[33m%s\033[0m %02x %02x\n",
4371 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4372 op[0], op[1]);
4373 printf (" immm = 0x%x,", immm);
4374 printf (" rdst = 0x%x\n", rdst);
4375 }
4376 SYNTAX("cmp #%2, %1");
4377 #line 522 "rx-decode.opc"
4378 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4379
4380 }
4381 break;
4382 }
4383 break;
4384 case 0x62:
4385 GETBYTE ();
4386 switch (op[1] & 0x00)
4387 {
4388 case 0x00:
4389 {
4390 /** 0110 0010 immm rdst add #%1, %0 */
4391 #line 504 "rx-decode.opc"
4392 int immm AU = (op[1] >> 4) & 0x0f;
4393 #line 504 "rx-decode.opc"
4394 int rdst AU = op[1] & 0x0f;
4395 if (trace)
4396 {
4397 printf ("\033[33m%s\033[0m %02x %02x\n",
4398 "/** 0110 0010 immm rdst add #%1, %0 */",
4399 op[0], op[1]);
4400 printf (" immm = 0x%x,", immm);
4401 printf (" rdst = 0x%x\n", rdst);
4402 }
4403 SYNTAX("add #%1, %0");
4404 #line 504 "rx-decode.opc"
4405 ID(add); SC(immm); DR(rdst); F_OSZC;
4406
4407 }
4408 break;
4409 }
4410 break;
4411 case 0x63:
4412 GETBYTE ();
4413 switch (op[1] & 0x00)
4414 {
4415 case 0x00:
4416 {
4417 /** 0110 0011 immm rdst mul #%1, %0 */
4418 #line 616 "rx-decode.opc"
4419 int immm AU = (op[1] >> 4) & 0x0f;
4420 #line 616 "rx-decode.opc"
4421 int rdst AU = op[1] & 0x0f;
4422 if (trace)
4423 {
4424 printf ("\033[33m%s\033[0m %02x %02x\n",
4425 "/** 0110 0011 immm rdst mul #%1, %0 */",
4426 op[0], op[1]);
4427 printf (" immm = 0x%x,", immm);
4428 printf (" rdst = 0x%x\n", rdst);
4429 }
4430 SYNTAX("mul #%1, %0");
4431 #line 616 "rx-decode.opc"
4432 if (immm == 1 && rdst == 0)
4433 {
4434 ID(nop2);
4435 SYNTAX ("nop\t; mul\t#1, r0");
4436 }
4437 else
4438 {
4439 ID(mul);
4440 }
4441 DR(rdst); SC(immm); F_____;
4442
4443 }
4444 break;
4445 }
4446 break;
4447 case 0x64:
4448 GETBYTE ();
4449 switch (op[1] & 0x00)
4450 {
4451 case 0x00:
4452 {
4453 /** 0110 0100 immm rdst and #%1, %0 */
4454 #line 414 "rx-decode.opc"
4455 int immm AU = (op[1] >> 4) & 0x0f;
4456 #line 414 "rx-decode.opc"
4457 int rdst AU = op[1] & 0x0f;
4458 if (trace)
4459 {
4460 printf ("\033[33m%s\033[0m %02x %02x\n",
4461 "/** 0110 0100 immm rdst and #%1, %0 */",
4462 op[0], op[1]);
4463 printf (" immm = 0x%x,", immm);
4464 printf (" rdst = 0x%x\n", rdst);
4465 }
4466 SYNTAX("and #%1, %0");
4467 #line 414 "rx-decode.opc"
4468 ID(and); SC(immm); DR(rdst); F__SZ_;
4469
4470 }
4471 break;
4472 }
4473 break;
4474 case 0x65:
4475 GETBYTE ();
4476 switch (op[1] & 0x00)
4477 {
4478 case 0x00:
4479 {
4480 /** 0110 0101 immm rdst or #%1, %0 */
4481 #line 432 "rx-decode.opc"
4482 int immm AU = (op[1] >> 4) & 0x0f;
4483 #line 432 "rx-decode.opc"
4484 int rdst AU = op[1] & 0x0f;
4485 if (trace)
4486 {
4487 printf ("\033[33m%s\033[0m %02x %02x\n",
4488 "/** 0110 0101 immm rdst or #%1, %0 */",
4489 op[0], op[1]);
4490 printf (" immm = 0x%x,", immm);
4491 printf (" rdst = 0x%x\n", rdst);
4492 }
4493 SYNTAX("or #%1, %0");
4494 #line 432 "rx-decode.opc"
4495 ID(or); SC(immm); DR(rdst); F__SZ_;
4496
4497 }
4498 break;
4499 }
4500 break;
4501 case 0x66:
4502 GETBYTE ();
4503 switch (op[1] & 0x00)
4504 {
4505 case 0x00:
4506 {
4507 /** 0110 0110 immm rdst mov%s #%1, %0 */
4508 #line 308 "rx-decode.opc"
4509 int immm AU = (op[1] >> 4) & 0x0f;
4510 #line 308 "rx-decode.opc"
4511 int rdst AU = op[1] & 0x0f;
4512 if (trace)
4513 {
4514 printf ("\033[33m%s\033[0m %02x %02x\n",
4515 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4516 op[0], op[1]);
4517 printf (" immm = 0x%x,", immm);
4518 printf (" rdst = 0x%x\n", rdst);
4519 }
4520 SYNTAX("mov%s #%1, %0");
4521 #line 308 "rx-decode.opc"
4522 ID(mov); DR(rdst); SC(immm); F_____;
4523
4524 }
4525 break;
4526 }
4527 break;
4528 case 0x67:
4529 {
4530 /** 0110 0111 rtsd #%1 */
4531 if (trace)
4532 {
4533 printf ("\033[33m%s\033[0m %02x\n",
4534 "/** 0110 0111 rtsd #%1 */",
4535 op[0]);
4536 }
4537 SYNTAX("rtsd #%1");
4538 #line 405 "rx-decode.opc"
4539 ID(rtsd); SC(IMM(1) * 4);
4540
4541 }
4542 break;
4543 case 0x68:
4544 GETBYTE ();
4545 switch (op[1] & 0x00)
4546 {
4547 case 0x00:
4548 op_semantics_28:
4549 {
4550 /** 0110 100i mmmm rdst shlr #%2, %0 */
4551 #line 730 "rx-decode.opc"
4552 int i AU = op[0] & 0x01;
4553 #line 730 "rx-decode.opc"
4554 int mmmm AU = (op[1] >> 4) & 0x0f;
4555 #line 730 "rx-decode.opc"
4556 int rdst AU = op[1] & 0x0f;
4557 if (trace)
4558 {
4559 printf ("\033[33m%s\033[0m %02x %02x\n",
4560 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4561 op[0], op[1]);
4562 printf (" i = 0x%x,", i);
4563 printf (" mmmm = 0x%x,", mmmm);
4564 printf (" rdst = 0x%x\n", rdst);
4565 }
4566 SYNTAX("shlr #%2, %0");
4567 #line 730 "rx-decode.opc"
4568 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4569
4570 }
4571 break;
4572 }
4573 break;
4574 case 0x69:
4575 GETBYTE ();
4576 switch (op[1] & 0x00)
4577 {
4578 case 0x00:
4579 goto op_semantics_28;
4580 break;
4581 }
4582 break;
4583 case 0x6a:
4584 GETBYTE ();
4585 switch (op[1] & 0x00)
4586 {
4587 case 0x00:
4588 op_semantics_29:
4589 {
4590 /** 0110 101i mmmm rdst shar #%2, %0 */
4591 #line 720 "rx-decode.opc"
4592 int i AU = op[0] & 0x01;
4593 #line 720 "rx-decode.opc"
4594 int mmmm AU = (op[1] >> 4) & 0x0f;
4595 #line 720 "rx-decode.opc"
4596 int rdst AU = op[1] & 0x0f;
4597 if (trace)
4598 {
4599 printf ("\033[33m%s\033[0m %02x %02x\n",
4600 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4601 op[0], op[1]);
4602 printf (" i = 0x%x,", i);
4603 printf (" mmmm = 0x%x,", mmmm);
4604 printf (" rdst = 0x%x\n", rdst);
4605 }
4606 SYNTAX("shar #%2, %0");
4607 #line 720 "rx-decode.opc"
4608 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4609
4610 }
4611 break;
4612 }
4613 break;
4614 case 0x6b:
4615 GETBYTE ();
4616 switch (op[1] & 0x00)
4617 {
4618 case 0x00:
4619 goto op_semantics_29;
4620 break;
4621 }
4622 break;
4623 case 0x6c:
4624 GETBYTE ();
4625 switch (op[1] & 0x00)
4626 {
4627 case 0x00:
4628 op_semantics_30:
4629 {
4630 /** 0110 110i mmmm rdst shll #%2, %0 */
4631 #line 710 "rx-decode.opc"
4632 int i AU = op[0] & 0x01;
4633 #line 710 "rx-decode.opc"
4634 int mmmm AU = (op[1] >> 4) & 0x0f;
4635 #line 710 "rx-decode.opc"
4636 int rdst AU = op[1] & 0x0f;
4637 if (trace)
4638 {
4639 printf ("\033[33m%s\033[0m %02x %02x\n",
4640 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4641 op[0], op[1]);
4642 printf (" i = 0x%x,", i);
4643 printf (" mmmm = 0x%x,", mmmm);
4644 printf (" rdst = 0x%x\n", rdst);
4645 }
4646 SYNTAX("shll #%2, %0");
4647 #line 710 "rx-decode.opc"
4648 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4649
4650 }
4651 break;
4652 }
4653 break;
4654 case 0x6d:
4655 GETBYTE ();
4656 switch (op[1] & 0x00)
4657 {
4658 case 0x00:
4659 goto op_semantics_30;
4660 break;
4661 }
4662 break;
4663 case 0x6e:
4664 GETBYTE ();
4665 switch (op[1] & 0x00)
4666 {
4667 case 0x00:
4668 {
4669 /** 0110 1110 dsta dstb pushm %1-%2 */
4670 #line 372 "rx-decode.opc"
4671 int dsta AU = (op[1] >> 4) & 0x0f;
4672 #line 372 "rx-decode.opc"
4673 int dstb AU = op[1] & 0x0f;
4674 if (trace)
4675 {
4676 printf ("\033[33m%s\033[0m %02x %02x\n",
4677 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4678 op[0], op[1]);
4679 printf (" dsta = 0x%x,", dsta);
4680 printf (" dstb = 0x%x\n", dstb);
4681 }
4682 SYNTAX("pushm %1-%2");
4683 #line 372 "rx-decode.opc"
4684 ID(pushm); SR(dsta); S2R(dstb); F_____;
4685
4686 }
4687 break;
4688 }
4689 break;
4690 case 0x6f:
4691 GETBYTE ();
4692 switch (op[1] & 0x00)
4693 {
4694 case 0x00:
4695 {
4696 /** 0110 1111 dsta dstb popm %1-%2 */
4697 #line 369 "rx-decode.opc"
4698 int dsta AU = (op[1] >> 4) & 0x0f;
4699 #line 369 "rx-decode.opc"
4700 int dstb AU = op[1] & 0x0f;
4701 if (trace)
4702 {
4703 printf ("\033[33m%s\033[0m %02x %02x\n",
4704 "/** 0110 1111 dsta dstb popm %1-%2 */",
4705 op[0], op[1]);
4706 printf (" dsta = 0x%x,", dsta);
4707 printf (" dstb = 0x%x\n", dstb);
4708 }
4709 SYNTAX("popm %1-%2");
4710 #line 369 "rx-decode.opc"
4711 ID(popm); SR(dsta); S2R(dstb); F_____;
4712
4713 }
4714 break;
4715 }
4716 break;
4717 case 0x70:
4718 GETBYTE ();
4719 switch (op[1] & 0x00)
4720 {
4721 case 0x00:
4722 op_semantics_31:
4723 {
4724 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4725 #line 513 "rx-decode.opc"
4726 int im AU = op[0] & 0x03;
4727 #line 513 "rx-decode.opc"
4728 int rsrc AU = (op[1] >> 4) & 0x0f;
4729 #line 513 "rx-decode.opc"
4730 int rdst AU = op[1] & 0x0f;
4731 if (trace)
4732 {
4733 printf ("\033[33m%s\033[0m %02x %02x\n",
4734 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4735 op[0], op[1]);
4736 printf (" im = 0x%x,", im);
4737 printf (" rsrc = 0x%x,", rsrc);
4738 printf (" rdst = 0x%x\n", rdst);
4739 }
4740 SYNTAX("add #%1, %2, %0");
4741 #line 513 "rx-decode.opc"
4742 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4743
4744 }
4745 break;
4746 }
4747 break;
4748 case 0x71:
4749 GETBYTE ();
4750 switch (op[1] & 0x00)
4751 {
4752 case 0x00:
4753 goto op_semantics_31;
4754 break;
4755 }
4756 break;
4757 case 0x72:
4758 GETBYTE ();
4759 switch (op[1] & 0x00)
4760 {
4761 case 0x00:
4762 goto op_semantics_31;
4763 break;
4764 }
4765 break;
4766 case 0x73:
4767 GETBYTE ();
4768 switch (op[1] & 0x00)
4769 {
4770 case 0x00:
4771 goto op_semantics_31;
4772 break;
4773 }
4774 break;
4775 case 0x74:
4776 GETBYTE ();
4777 switch (op[1] & 0xf0)
4778 {
4779 case 0x00:
4780 op_semantics_32:
4781 {
4782 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4783 #line 525 "rx-decode.opc"
4784 int im AU = op[0] & 0x03;
4785 #line 525 "rx-decode.opc"
4786 int rsrc AU = op[1] & 0x0f;
4787 if (trace)
4788 {
4789 printf ("\033[33m%s\033[0m %02x %02x\n",
4790 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4791 op[0], op[1]);
4792 printf (" im = 0x%x,", im);
4793 printf (" rsrc = 0x%x\n", rsrc);
4794 }
4795 SYNTAX("cmp #%2, %1%S1");
4796 #line 525 "rx-decode.opc"
4797 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4798
4799 }
4800 break;
4801 case 0x10:
4802 op_semantics_33:
4803 {
4804 /** 0111 01im 0001rdst mul #%1, %0 */
4805 #line 628 "rx-decode.opc"
4806 int im AU = op[0] & 0x03;
4807 #line 628 "rx-decode.opc"
4808 int rdst AU = op[1] & 0x0f;
4809 if (trace)
4810 {
4811 printf ("\033[33m%s\033[0m %02x %02x\n",
4812 "/** 0111 01im 0001rdst mul #%1, %0 */",
4813 op[0], op[1]);
4814 printf (" im = 0x%x,", im);
4815 printf (" rdst = 0x%x\n", rdst);
4816 }
4817 SYNTAX("mul #%1, %0");
4818 #line 628 "rx-decode.opc"
4819 int val = IMMex(im);
4820 if (val == 1 && rdst == 0)
4821 {
4822 SYNTAX("nop\t; mul\t#1, r0");
4823 switch (im)
4824 {
4825 case 2: ID(nop4); break;
4826 case 3: ID(nop5); break;
4827 case 0: ID(nop6); break;
4828 default:
4829 ID(mul);
4830 SYNTAX("mul #%1, %0");
4831 break;
4832 }
4833 }
4834 else
4835 {
4836 ID(mul);
4837 }
4838 DR(rdst); SC(val); F_____;
4839
4840 }
4841 break;
4842 case 0x20:
4843 op_semantics_34:
4844 {
4845 /** 0111 01im 0010 rdst and #%1, %0 */
4846 #line 417 "rx-decode.opc"
4847 int im AU = op[0] & 0x03;
4848 #line 417 "rx-decode.opc"
4849 int rdst AU = op[1] & 0x0f;
4850 if (trace)
4851 {
4852 printf ("\033[33m%s\033[0m %02x %02x\n",
4853 "/** 0111 01im 0010 rdst and #%1, %0 */",
4854 op[0], op[1]);
4855 printf (" im = 0x%x,", im);
4856 printf (" rdst = 0x%x\n", rdst);
4857 }
4858 SYNTAX("and #%1, %0");
4859 #line 417 "rx-decode.opc"
4860 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4861
4862 }
4863 break;
4864 case 0x30:
4865 op_semantics_35:
4866 {
4867 /** 0111 01im 0011 rdst or #%1, %0 */
4868 #line 435 "rx-decode.opc"
4869 int im AU = op[0] & 0x03;
4870 #line 435 "rx-decode.opc"
4871 int rdst AU = op[1] & 0x0f;
4872 if (trace)
4873 {
4874 printf ("\033[33m%s\033[0m %02x %02x\n",
4875 "/** 0111 01im 0011 rdst or #%1, %0 */",
4876 op[0], op[1]);
4877 printf (" im = 0x%x,", im);
4878 printf (" rdst = 0x%x\n", rdst);
4879 }
4880 SYNTAX("or #%1, %0");
4881 #line 435 "rx-decode.opc"
4882 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4883
4884 }
4885 break;
4886 default: UNSUPPORTED(); break;
4887 }
4888 break;
4889 case 0x75:
4890 GETBYTE ();
4891 switch (op[1] & 0xff)
4892 {
4893 case 0x00:
4894 case 0x01:
4895 case 0x02:
4896 case 0x03:
4897 case 0x04:
4898 case 0x05:
4899 case 0x06:
4900 case 0x07:
4901 case 0x08:
4902 case 0x09:
4903 case 0x0a:
4904 case 0x0b:
4905 case 0x0c:
4906 case 0x0d:
4907 case 0x0e:
4908 case 0x0f:
4909 goto op_semantics_32;
4910 break;
4911 case 0x10:
4912 case 0x11:
4913 case 0x12:
4914 case 0x13:
4915 case 0x14:
4916 case 0x15:
4917 case 0x16:
4918 case 0x17:
4919 case 0x18:
4920 case 0x19:
4921 case 0x1a:
4922 case 0x1b:
4923 case 0x1c:
4924 case 0x1d:
4925 case 0x1e:
4926 case 0x1f:
4927 goto op_semantics_33;
4928 break;
4929 case 0x20:
4930 case 0x21:
4931 case 0x22:
4932 case 0x23:
4933 case 0x24:
4934 case 0x25:
4935 case 0x26:
4936 case 0x27:
4937 case 0x28:
4938 case 0x29:
4939 case 0x2a:
4940 case 0x2b:
4941 case 0x2c:
4942 case 0x2d:
4943 case 0x2e:
4944 case 0x2f:
4945 goto op_semantics_34;
4946 break;
4947 case 0x30:
4948 case 0x31:
4949 case 0x32:
4950 case 0x33:
4951 case 0x34:
4952 case 0x35:
4953 case 0x36:
4954 case 0x37:
4955 case 0x38:
4956 case 0x39:
4957 case 0x3a:
4958 case 0x3b:
4959 case 0x3c:
4960 case 0x3d:
4961 case 0x3e:
4962 case 0x3f:
4963 goto op_semantics_35;
4964 break;
4965 case 0x40:
4966 case 0x41:
4967 case 0x42:
4968 case 0x43:
4969 case 0x44:
4970 case 0x45:
4971 case 0x46:
4972 case 0x47:
4973 case 0x48:
4974 case 0x49:
4975 case 0x4a:
4976 case 0x4b:
4977 case 0x4c:
4978 case 0x4d:
4979 case 0x4e:
4980 case 0x4f:
4981 {
4982 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4983 #line 289 "rx-decode.opc"
4984 int rdst AU = op[1] & 0x0f;
4985 if (trace)
4986 {
4987 printf ("\033[33m%s\033[0m %02x %02x\n",
4988 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4989 op[0], op[1]);
4990 printf (" rdst = 0x%x\n", rdst);
4991 }
4992 SYNTAX("mov%s #%1, %0");
4993 #line 289 "rx-decode.opc"
4994 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4995
4996 }
4997 break;
4998 case 0x50:
4999 case 0x51:
5000 case 0x52:
5001 case 0x53:
5002 case 0x54:
5003 case 0x55:
5004 case 0x56:
5005 case 0x57:
5006 case 0x58:
5007 case 0x59:
5008 case 0x5a:
5009 case 0x5b:
5010 case 0x5c:
5011 case 0x5d:
5012 case 0x5e:
5013 case 0x5f:
5014 {
5015 /** 0111 0101 0101 rsrc cmp #%2, %1 */
5016 #line 528 "rx-decode.opc"
5017 int rsrc AU = op[1] & 0x0f;
5018 if (trace)
5019 {
5020 printf ("\033[33m%s\033[0m %02x %02x\n",
5021 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5022 op[0], op[1]);
5023 printf (" rsrc = 0x%x\n", rsrc);
5024 }
5025 SYNTAX("cmp #%2, %1");
5026 #line 528 "rx-decode.opc"
5027 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5028
5029 }
5030 break;
5031 case 0x60:
5032 {
5033 /** 0111 0101 0110 0000 int #%1 */
5034 if (trace)
5035 {
5036 printf ("\033[33m%s\033[0m %02x %02x\n",
5037 "/** 0111 0101 0110 0000 int #%1 */",
5038 op[0], op[1]);
5039 }
5040 SYNTAX("int #%1");
5041 #line 1035 "rx-decode.opc"
5042 ID(int); SC(IMM(1));
5043
5044 }
5045 break;
5046 case 0x70:
5047 GETBYTE ();
5048 switch (op[2] & 0xf0)
5049 {
5050 case 0x00:
5051 {
5052 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
5053 #line 1002 "rx-decode.opc"
5054 int immm AU = op[2] & 0x0f;
5055 if (trace)
5056 {
5057 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5058 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5059 op[0], op[1], op[2]);
5060 printf (" immm = 0x%x\n", immm);
5061 }
5062 SYNTAX("mvtipl #%1");
5063 #line 1002 "rx-decode.opc"
5064 ID(mvtipl); SC(immm);
5065
5066 }
5067 break;
5068 default: UNSUPPORTED(); break;
5069 }
5070 break;
5071 default: UNSUPPORTED(); break;
5072 }
5073 break;
5074 case 0x76:
5075 GETBYTE ();
5076 switch (op[1] & 0xf0)
5077 {
5078 case 0x00:
5079 goto op_semantics_32;
5080 break;
5081 case 0x10:
5082 goto op_semantics_33;
5083 break;
5084 case 0x20:
5085 goto op_semantics_34;
5086 break;
5087 case 0x30:
5088 goto op_semantics_35;
5089 break;
5090 default: UNSUPPORTED(); break;
5091 }
5092 break;
5093 case 0x77:
5094 GETBYTE ();
5095 switch (op[1] & 0xf0)
5096 {
5097 case 0x00:
5098 goto op_semantics_32;
5099 break;
5100 case 0x10:
5101 goto op_semantics_33;
5102 break;
5103 case 0x20:
5104 goto op_semantics_34;
5105 break;
5106 case 0x30:
5107 goto op_semantics_35;
5108 break;
5109 default: UNSUPPORTED(); break;
5110 }
5111 break;
5112 case 0x78:
5113 GETBYTE ();
5114 switch (op[1] & 0x00)
5115 {
5116 case 0x00:
5117 op_semantics_36:
5118 {
5119 /** 0111 100b ittt rdst bset #%1, %0 */
5120 #line 947 "rx-decode.opc"
5121 int b AU = op[0] & 0x01;
5122 #line 947 "rx-decode.opc"
5123 int ittt AU = (op[1] >> 4) & 0x0f;
5124 #line 947 "rx-decode.opc"
5125 int rdst AU = op[1] & 0x0f;
5126 if (trace)
5127 {
5128 printf ("\033[33m%s\033[0m %02x %02x\n",
5129 "/** 0111 100b ittt rdst bset #%1, %0 */",
5130 op[0], op[1]);
5131 printf (" b = 0x%x,", b);
5132 printf (" ittt = 0x%x,", ittt);
5133 printf (" rdst = 0x%x\n", rdst);
5134 }
5135 SYNTAX("bset #%1, %0");
5136 #line 947 "rx-decode.opc"
5137 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5138
5139
5140 }
5141 break;
5142 }
5143 break;
5144 case 0x79:
5145 GETBYTE ();
5146 switch (op[1] & 0x00)
5147 {
5148 case 0x00:
5149 goto op_semantics_36;
5150 break;
5151 }
5152 break;
5153 case 0x7a:
5154 GETBYTE ();
5155 switch (op[1] & 0x00)
5156 {
5157 case 0x00:
5158 op_semantics_37:
5159 {
5160 /** 0111 101b ittt rdst bclr #%1, %0 */
5161 #line 959 "rx-decode.opc"
5162 int b AU = op[0] & 0x01;
5163 #line 959 "rx-decode.opc"
5164 int ittt AU = (op[1] >> 4) & 0x0f;
5165 #line 959 "rx-decode.opc"
5166 int rdst AU = op[1] & 0x0f;
5167 if (trace)
5168 {
5169 printf ("\033[33m%s\033[0m %02x %02x\n",
5170 "/** 0111 101b ittt rdst bclr #%1, %0 */",
5171 op[0], op[1]);
5172 printf (" b = 0x%x,", b);
5173 printf (" ittt = 0x%x,", ittt);
5174 printf (" rdst = 0x%x\n", rdst);
5175 }
5176 SYNTAX("bclr #%1, %0");
5177 #line 959 "rx-decode.opc"
5178 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5179
5180
5181 }
5182 break;
5183 }
5184 break;
5185 case 0x7b:
5186 GETBYTE ();
5187 switch (op[1] & 0x00)
5188 {
5189 case 0x00:
5190 goto op_semantics_37;
5191 break;
5192 }
5193 break;
5194 case 0x7c:
5195 GETBYTE ();
5196 switch (op[1] & 0x00)
5197 {
5198 case 0x00:
5199 op_semantics_38:
5200 {
5201 /** 0111 110b ittt rdst btst #%2, %1 */
5202 #line 971 "rx-decode.opc"
5203 int b AU = op[0] & 0x01;
5204 #line 971 "rx-decode.opc"
5205 int ittt AU = (op[1] >> 4) & 0x0f;
5206 #line 971 "rx-decode.opc"
5207 int rdst AU = op[1] & 0x0f;
5208 if (trace)
5209 {
5210 printf ("\033[33m%s\033[0m %02x %02x\n",
5211 "/** 0111 110b ittt rdst btst #%2, %1 */",
5212 op[0], op[1]);
5213 printf (" b = 0x%x,", b);
5214 printf (" ittt = 0x%x,", ittt);
5215 printf (" rdst = 0x%x\n", rdst);
5216 }
5217 SYNTAX("btst #%2, %1");
5218 #line 971 "rx-decode.opc"
5219 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5220
5221
5222 }
5223 break;
5224 }
5225 break;
5226 case 0x7d:
5227 GETBYTE ();
5228 switch (op[1] & 0x00)
5229 {
5230 case 0x00:
5231 goto op_semantics_38;
5232 break;
5233 }
5234 break;
5235 case 0x7e:
5236 GETBYTE ();
5237 switch (op[1] & 0xf0)
5238 {
5239 case 0x00:
5240 {
5241 /** 0111 1110 0000 rdst not %0 */
5242 #line 462 "rx-decode.opc"
5243 int rdst AU = op[1] & 0x0f;
5244 if (trace)
5245 {
5246 printf ("\033[33m%s\033[0m %02x %02x\n",
5247 "/** 0111 1110 0000 rdst not %0 */",
5248 op[0], op[1]);
5249 printf (" rdst = 0x%x\n", rdst);
5250 }
5251 SYNTAX("not %0");
5252 #line 462 "rx-decode.opc"
5253 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5254
5255 }
5256 break;
5257 case 0x10:
5258 {
5259 /** 0111 1110 0001 rdst neg %0 */
5260 #line 483 "rx-decode.opc"
5261 int rdst AU = op[1] & 0x0f;
5262 if (trace)
5263 {
5264 printf ("\033[33m%s\033[0m %02x %02x\n",
5265 "/** 0111 1110 0001 rdst neg %0 */",
5266 op[0], op[1]);
5267 printf (" rdst = 0x%x\n", rdst);
5268 }
5269 SYNTAX("neg %0");
5270 #line 483 "rx-decode.opc"
5271 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5272
5273 }
5274 break;
5275 case 0x20:
5276 {
5277 /** 0111 1110 0010 rdst abs %0 */
5278 #line 565 "rx-decode.opc"
5279 int rdst AU = op[1] & 0x0f;
5280 if (trace)
5281 {
5282 printf ("\033[33m%s\033[0m %02x %02x\n",
5283 "/** 0111 1110 0010 rdst abs %0 */",
5284 op[0], op[1]);
5285 printf (" rdst = 0x%x\n", rdst);
5286 }
5287 SYNTAX("abs %0");
5288 #line 565 "rx-decode.opc"
5289 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5290
5291 }
5292 break;
5293 case 0x30:
5294 {
5295 /** 0111 1110 0011 rdst sat %0 */
5296 #line 885 "rx-decode.opc"
5297 int rdst AU = op[1] & 0x0f;
5298 if (trace)
5299 {
5300 printf ("\033[33m%s\033[0m %02x %02x\n",
5301 "/** 0111 1110 0011 rdst sat %0 */",
5302 op[0], op[1]);
5303 printf (" rdst = 0x%x\n", rdst);
5304 }
5305 SYNTAX("sat %0");
5306 #line 885 "rx-decode.opc"
5307 ID(sat); DR (rdst);
5308
5309 }
5310 break;
5311 case 0x40:
5312 {
5313 /** 0111 1110 0100 rdst rorc %0 */
5314 #line 745 "rx-decode.opc"
5315 int rdst AU = op[1] & 0x0f;
5316 if (trace)
5317 {
5318 printf ("\033[33m%s\033[0m %02x %02x\n",
5319 "/** 0111 1110 0100 rdst rorc %0 */",
5320 op[0], op[1]);
5321 printf (" rdst = 0x%x\n", rdst);
5322 }
5323 SYNTAX("rorc %0");
5324 #line 745 "rx-decode.opc"
5325 ID(rorc); DR(rdst); F__SZC;
5326
5327 }
5328 break;
5329 case 0x50:
5330 {
5331 /** 0111 1110 0101 rdst rolc %0 */
5332 #line 742 "rx-decode.opc"
5333 int rdst AU = op[1] & 0x0f;
5334 if (trace)
5335 {
5336 printf ("\033[33m%s\033[0m %02x %02x\n",
5337 "/** 0111 1110 0101 rdst rolc %0 */",
5338 op[0], op[1]);
5339 printf (" rdst = 0x%x\n", rdst);
5340 }
5341 SYNTAX("rolc %0");
5342 #line 742 "rx-decode.opc"
5343 ID(rolc); DR(rdst); F__SZC;
5344
5345 }
5346 break;
5347 case 0x80:
5348 case 0x90:
5349 case 0xa0:
5350 {
5351 /** 0111 1110 10sz rsrc push%s %1 */
5352 #line 378 "rx-decode.opc"
5353 int sz AU = (op[1] >> 4) & 0x03;
5354 #line 378 "rx-decode.opc"
5355 int rsrc AU = op[1] & 0x0f;
5356 if (trace)
5357 {
5358 printf ("\033[33m%s\033[0m %02x %02x\n",
5359 "/** 0111 1110 10sz rsrc push%s %1 */",
5360 op[0], op[1]);
5361 printf (" sz = 0x%x,", sz);
5362 printf (" rsrc = 0x%x\n", rsrc);
5363 }
5364 SYNTAX("push%s %1");
5365 #line 378 "rx-decode.opc"
5366 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5367
5368 }
5369 break;
5370 case 0xb0:
5371 {
5372 /** 0111 1110 1011 rdst pop %0 */
5373 #line 375 "rx-decode.opc"
5374 int rdst AU = op[1] & 0x0f;
5375 if (trace)
5376 {
5377 printf ("\033[33m%s\033[0m %02x %02x\n",
5378 "/** 0111 1110 1011 rdst pop %0 */",
5379 op[0], op[1]);
5380 printf (" rdst = 0x%x\n", rdst);
5381 }
5382 SYNTAX("pop %0");
5383 #line 375 "rx-decode.opc"
5384 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5385
5386 }
5387 break;
5388 case 0xc0:
5389 case 0xd0:
5390 {
5391 /** 0111 1110 110 crsrc pushc %1 */
5392 #line 1008 "rx-decode.opc"
5393 int crsrc AU = op[1] & 0x1f;
5394 if (trace)
5395 {
5396 printf ("\033[33m%s\033[0m %02x %02x\n",
5397 "/** 0111 1110 110 crsrc pushc %1 */",
5398 op[0], op[1]);
5399 printf (" crsrc = 0x%x\n", crsrc);
5400 }
5401 SYNTAX("pushc %1");
5402 #line 1008 "rx-decode.opc"
5403 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5404
5405 }
5406 break;
5407 case 0xe0:
5408 case 0xf0:
5409 {
5410 /** 0111 1110 111 crdst popc %0 */
5411 #line 1005 "rx-decode.opc"
5412 int crdst AU = op[1] & 0x1f;
5413 if (trace)
5414 {
5415 printf ("\033[33m%s\033[0m %02x %02x\n",
5416 "/** 0111 1110 111 crdst popc %0 */",
5417 op[0], op[1]);
5418 printf (" crdst = 0x%x\n", crdst);
5419 }
5420 SYNTAX("popc %0");
5421 #line 1005 "rx-decode.opc"
5422 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5423
5424 }
5425 break;
5426 default: UNSUPPORTED(); break;
5427 }
5428 break;
5429 case 0x7f:
5430 GETBYTE ();
5431 switch (op[1] & 0xff)
5432 {
5433 case 0x00:
5434 case 0x01:
5435 case 0x02:
5436 case 0x03:
5437 case 0x04:
5438 case 0x05:
5439 case 0x06:
5440 case 0x07:
5441 case 0x08:
5442 case 0x09:
5443 case 0x0a:
5444 case 0x0b:
5445 case 0x0c:
5446 case 0x0d:
5447 case 0x0e:
5448 case 0x0f:
5449 {
5450 /** 0111 1111 0000 rsrc jmp %0 */
5451 #line 795 "rx-decode.opc"
5452 int rsrc AU = op[1] & 0x0f;
5453 if (trace)
5454 {
5455 printf ("\033[33m%s\033[0m %02x %02x\n",
5456 "/** 0111 1111 0000 rsrc jmp %0 */",
5457 op[0], op[1]);
5458 printf (" rsrc = 0x%x\n", rsrc);
5459 }
5460 SYNTAX("jmp %0");
5461 #line 795 "rx-decode.opc"
5462 ID(branch); DR(rsrc);
5463
5464 }
5465 break;
5466 case 0x10:
5467 case 0x11:
5468 case 0x12:
5469 case 0x13:
5470 case 0x14:
5471 case 0x15:
5472 case 0x16:
5473 case 0x17:
5474 case 0x18:
5475 case 0x19:
5476 case 0x1a:
5477 case 0x1b:
5478 case 0x1c:
5479 case 0x1d:
5480 case 0x1e:
5481 case 0x1f:
5482 {
5483 /** 0111 1111 0001 rsrc jsr %0 */
5484 #line 798 "rx-decode.opc"
5485 int rsrc AU = op[1] & 0x0f;
5486 if (trace)
5487 {
5488 printf ("\033[33m%s\033[0m %02x %02x\n",
5489 "/** 0111 1111 0001 rsrc jsr %0 */",
5490 op[0], op[1]);
5491 printf (" rsrc = 0x%x\n", rsrc);
5492 }
5493 SYNTAX("jsr %0");
5494 #line 798 "rx-decode.opc"
5495 ID(jsr); DR(rsrc);
5496
5497 }
5498 break;
5499 case 0x40:
5500 case 0x41:
5501 case 0x42:
5502 case 0x43:
5503 case 0x44:
5504 case 0x45:
5505 case 0x46:
5506 case 0x47:
5507 case 0x48:
5508 case 0x49:
5509 case 0x4a:
5510 case 0x4b:
5511 case 0x4c:
5512 case 0x4d:
5513 case 0x4e:
5514 case 0x4f:
5515 {
5516 /** 0111 1111 0100 rsrc bra.l %0 */
5517 #line 791 "rx-decode.opc"
5518 int rsrc AU = op[1] & 0x0f;
5519 if (trace)
5520 {
5521 printf ("\033[33m%s\033[0m %02x %02x\n",
5522 "/** 0111 1111 0100 rsrc bra.l %0 */",
5523 op[0], op[1]);
5524 printf (" rsrc = 0x%x\n", rsrc);
5525 }
5526 SYNTAX("bra.l %0");
5527 #line 791 "rx-decode.opc"
5528 ID(branchrel); DR(rsrc);
5529
5530
5531 }
5532 break;
5533 case 0x50:
5534 case 0x51:
5535 case 0x52:
5536 case 0x53:
5537 case 0x54:
5538 case 0x55:
5539 case 0x56:
5540 case 0x57:
5541 case 0x58:
5542 case 0x59:
5543 case 0x5a:
5544 case 0x5b:
5545 case 0x5c:
5546 case 0x5d:
5547 case 0x5e:
5548 case 0x5f:
5549 {
5550 /** 0111 1111 0101 rsrc bsr.l %0 */
5551 #line 807 "rx-decode.opc"
5552 int rsrc AU = op[1] & 0x0f;
5553 if (trace)
5554 {
5555 printf ("\033[33m%s\033[0m %02x %02x\n",
5556 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5557 op[0], op[1]);
5558 printf (" rsrc = 0x%x\n", rsrc);
5559 }
5560 SYNTAX("bsr.l %0");
5561 #line 807 "rx-decode.opc"
5562 ID(jsrrel); DR(rsrc);
5563
5564 }
5565 break;
5566 case 0x80:
5567 case 0x81:
5568 case 0x82:
5569 {
5570 /** 0111 1111 1000 00sz suntil%s */
5571 #line 831 "rx-decode.opc"
5572 int sz AU = op[1] & 0x03;
5573 if (trace)
5574 {
5575 printf ("\033[33m%s\033[0m %02x %02x\n",
5576 "/** 0111 1111 1000 00sz suntil%s */",
5577 op[0], op[1]);
5578 printf (" sz = 0x%x\n", sz);
5579 }
5580 SYNTAX("suntil%s");
5581 #line 831 "rx-decode.opc"
5582 ID(suntil); BWL(sz); F___ZC;
5583
5584 }
5585 break;
5586 case 0x83:
5587 {
5588 /** 0111 1111 1000 0011 scmpu */
5589 if (trace)
5590 {
5591 printf ("\033[33m%s\033[0m %02x %02x\n",
5592 "/** 0111 1111 1000 0011 scmpu */",
5593 op[0], op[1]);
5594 }
5595 SYNTAX("scmpu");
5596 #line 822 "rx-decode.opc"
5597 ID(scmpu); F___ZC;
5598
5599 }
5600 break;
5601 case 0x84:
5602 case 0x85:
5603 case 0x86:
5604 {
5605 /** 0111 1111 1000 01sz swhile%s */
5606 #line 834 "rx-decode.opc"
5607 int sz AU = op[1] & 0x03;
5608 if (trace)
5609 {
5610 printf ("\033[33m%s\033[0m %02x %02x\n",
5611 "/** 0111 1111 1000 01sz swhile%s */",
5612 op[0], op[1]);
5613 printf (" sz = 0x%x\n", sz);
5614 }
5615 SYNTAX("swhile%s");
5616 #line 834 "rx-decode.opc"
5617 ID(swhile); BWL(sz); F___ZC;
5618
5619 }
5620 break;
5621 case 0x87:
5622 {
5623 /** 0111 1111 1000 0111 smovu */
5624 if (trace)
5625 {
5626 printf ("\033[33m%s\033[0m %02x %02x\n",
5627 "/** 0111 1111 1000 0111 smovu */",
5628 op[0], op[1]);
5629 }
5630 SYNTAX("smovu");
5631 #line 825 "rx-decode.opc"
5632 ID(smovu);
5633
5634 }
5635 break;
5636 case 0x88:
5637 case 0x89:
5638 case 0x8a:
5639 {
5640 /** 0111 1111 1000 10sz sstr%s */
5641 #line 840 "rx-decode.opc"
5642 int sz AU = op[1] & 0x03;
5643 if (trace)
5644 {
5645 printf ("\033[33m%s\033[0m %02x %02x\n",
5646 "/** 0111 1111 1000 10sz sstr%s */",
5647 op[0], op[1]);
5648 printf (" sz = 0x%x\n", sz);
5649 }
5650 SYNTAX("sstr%s");
5651 #line 840 "rx-decode.opc"
5652 ID(sstr); BWL(sz);
5653
5654 /*----------------------------------------------------------------------*/
5655 /* RMPA */
5656
5657 }
5658 break;
5659 case 0x8b:
5660 {
5661 /** 0111 1111 1000 1011 smovb */
5662 if (trace)
5663 {
5664 printf ("\033[33m%s\033[0m %02x %02x\n",
5665 "/** 0111 1111 1000 1011 smovb */",
5666 op[0], op[1]);
5667 }
5668 SYNTAX("smovb");
5669 #line 828 "rx-decode.opc"
5670 ID(smovb);
5671
5672 }
5673 break;
5674 case 0x8c:
5675 case 0x8d:
5676 case 0x8e:
5677 {
5678 /** 0111 1111 1000 11sz rmpa%s */
5679 #line 846 "rx-decode.opc"
5680 int sz AU = op[1] & 0x03;
5681 if (trace)
5682 {
5683 printf ("\033[33m%s\033[0m %02x %02x\n",
5684 "/** 0111 1111 1000 11sz rmpa%s */",
5685 op[0], op[1]);
5686 printf (" sz = 0x%x\n", sz);
5687 }
5688 SYNTAX("rmpa%s");
5689 #line 846 "rx-decode.opc"
5690 ID(rmpa); BWL(sz); F_OS__;
5691
5692 /*----------------------------------------------------------------------*/
5693 /* HI/LO stuff */
5694
5695 }
5696 break;
5697 case 0x8f:
5698 {
5699 /** 0111 1111 1000 1111 smovf */
5700 if (trace)
5701 {
5702 printf ("\033[33m%s\033[0m %02x %02x\n",
5703 "/** 0111 1111 1000 1111 smovf */",
5704 op[0], op[1]);
5705 }
5706 SYNTAX("smovf");
5707 #line 837 "rx-decode.opc"
5708 ID(smovf);
5709
5710 }
5711 break;
5712 case 0x93:
5713 {
5714 /** 0111 1111 1001 0011 satr */
5715 if (trace)
5716 {
5717 printf ("\033[33m%s\033[0m %02x %02x\n",
5718 "/** 0111 1111 1001 0011 satr */",
5719 op[0], op[1]);
5720 }
5721 SYNTAX("satr");
5722 #line 888 "rx-decode.opc"
5723 ID(satr);
5724
5725 /*----------------------------------------------------------------------*/
5726 /* FLOAT */
5727
5728 }
5729 break;
5730 case 0x94:
5731 {
5732 /** 0111 1111 1001 0100 rtfi */
5733 if (trace)
5734 {
5735 printf ("\033[33m%s\033[0m %02x %02x\n",
5736 "/** 0111 1111 1001 0100 rtfi */",
5737 op[0], op[1]);
5738 }
5739 SYNTAX("rtfi");
5740 #line 1023 "rx-decode.opc"
5741 ID(rtfi);
5742
5743 }
5744 break;
5745 case 0x95:
5746 {
5747 /** 0111 1111 1001 0101 rte */
5748 if (trace)
5749 {
5750 printf ("\033[33m%s\033[0m %02x %02x\n",
5751 "/** 0111 1111 1001 0101 rte */",
5752 op[0], op[1]);
5753 }
5754 SYNTAX("rte");
5755 #line 1026 "rx-decode.opc"
5756 ID(rte);
5757
5758 }
5759 break;
5760 case 0x96:
5761 {
5762 /** 0111 1111 1001 0110 wait */
5763 if (trace)
5764 {
5765 printf ("\033[33m%s\033[0m %02x %02x\n",
5766 "/** 0111 1111 1001 0110 wait */",
5767 op[0], op[1]);
5768 }
5769 SYNTAX("wait");
5770 #line 1038 "rx-decode.opc"
5771 ID(wait);
5772
5773 /*----------------------------------------------------------------------*/
5774 /* SCcnd */
5775
5776 }
5777 break;
5778 case 0xa0:
5779 case 0xa1:
5780 case 0xa2:
5781 case 0xa3:
5782 case 0xa4:
5783 case 0xa5:
5784 case 0xa6:
5785 case 0xa7:
5786 case 0xa8:
5787 case 0xa9:
5788 case 0xaa:
5789 case 0xab:
5790 case 0xac:
5791 case 0xad:
5792 case 0xae:
5793 case 0xaf:
5794 {
5795 /** 0111 1111 1010 rdst setpsw %0 */
5796 #line 999 "rx-decode.opc"
5797 int rdst AU = op[1] & 0x0f;
5798 if (trace)
5799 {
5800 printf ("\033[33m%s\033[0m %02x %02x\n",
5801 "/** 0111 1111 1010 rdst setpsw %0 */",
5802 op[0], op[1]);
5803 printf (" rdst = 0x%x\n", rdst);
5804 }
5805 SYNTAX("setpsw %0");
5806 #line 999 "rx-decode.opc"
5807 ID(setpsw); DF(rdst);
5808
5809 }
5810 break;
5811 case 0xb0:
5812 case 0xb1:
5813 case 0xb2:
5814 case 0xb3:
5815 case 0xb4:
5816 case 0xb5:
5817 case 0xb6:
5818 case 0xb7:
5819 case 0xb8:
5820 case 0xb9:
5821 case 0xba:
5822 case 0xbb:
5823 case 0xbc:
5824 case 0xbd:
5825 case 0xbe:
5826 case 0xbf:
5827 {
5828 /** 0111 1111 1011 rdst clrpsw %0 */
5829 #line 996 "rx-decode.opc"
5830 int rdst AU = op[1] & 0x0f;
5831 if (trace)
5832 {
5833 printf ("\033[33m%s\033[0m %02x %02x\n",
5834 "/** 0111 1111 1011 rdst clrpsw %0 */",
5835 op[0], op[1]);
5836 printf (" rdst = 0x%x\n", rdst);
5837 }
5838 SYNTAX("clrpsw %0");
5839 #line 996 "rx-decode.opc"
5840 ID(clrpsw); DF(rdst);
5841
5842 }
5843 break;
5844 default: UNSUPPORTED(); break;
5845 }
5846 break;
5847 case 0x80:
5848 GETBYTE ();
5849 switch (op[1] & 0x00)
5850 {
5851 case 0x00:
5852 op_semantics_39:
5853 {
5854 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5855 #line 336 "rx-decode.opc"
5856 int sz AU = (op[0] >> 4) & 0x03;
5857 #line 336 "rx-decode.opc"
5858 int dsp AU = op[0] & 0x07;
5859 #line 336 "rx-decode.opc"
5860 int a AU = (op[1] >> 7) & 0x01;
5861 #line 336 "rx-decode.opc"
5862 int dst AU = (op[1] >> 4) & 0x07;
5863 #line 336 "rx-decode.opc"
5864 int b AU = (op[1] >> 3) & 0x01;
5865 #line 336 "rx-decode.opc"
5866 int src AU = op[1] & 0x07;
5867 if (trace)
5868 {
5869 printf ("\033[33m%s\033[0m %02x %02x\n",
5870 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5871 op[0], op[1]);
5872 printf (" sz = 0x%x,", sz);
5873 printf (" dsp = 0x%x,", dsp);
5874 printf (" a = 0x%x,", a);
5875 printf (" dst = 0x%x,", dst);
5876 printf (" b = 0x%x,", b);
5877 printf (" src = 0x%x\n", src);
5878 }
5879 SYNTAX("mov%s %1, %0");
5880 #line 336 "rx-decode.opc"
5881 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5882
5883 }
5884 break;
5885 }
5886 break;
5887 case 0x81:
5888 GETBYTE ();
5889 switch (op[1] & 0x00)
5890 {
5891 case 0x00:
5892 goto op_semantics_39;
5893 break;
5894 }
5895 break;
5896 case 0x82:
5897 GETBYTE ();
5898 switch (op[1] & 0x00)
5899 {
5900 case 0x00:
5901 goto op_semantics_39;
5902 break;
5903 }
5904 break;
5905 case 0x83:
5906 GETBYTE ();
5907 switch (op[1] & 0x00)
5908 {
5909 case 0x00:
5910 goto op_semantics_39;
5911 break;
5912 }
5913 break;
5914 case 0x84:
5915 GETBYTE ();
5916 switch (op[1] & 0x00)
5917 {
5918 case 0x00:
5919 goto op_semantics_39;
5920 break;
5921 }
5922 break;
5923 case 0x85:
5924 GETBYTE ();
5925 switch (op[1] & 0x00)
5926 {
5927 case 0x00:
5928 goto op_semantics_39;
5929 break;
5930 }
5931 break;
5932 case 0x86:
5933 GETBYTE ();
5934 switch (op[1] & 0x00)
5935 {
5936 case 0x00:
5937 goto op_semantics_39;
5938 break;
5939 }
5940 break;
5941 case 0x87:
5942 GETBYTE ();
5943 switch (op[1] & 0x00)
5944 {
5945 case 0x00:
5946 goto op_semantics_39;
5947 break;
5948 }
5949 break;
5950 case 0x88:
5951 GETBYTE ();
5952 switch (op[1] & 0x00)
5953 {
5954 case 0x00:
5955 op_semantics_40:
5956 {
5957 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5958 #line 333 "rx-decode.opc"
5959 int sz AU = (op[0] >> 4) & 0x03;
5960 #line 333 "rx-decode.opc"
5961 int dsp AU = op[0] & 0x07;
5962 #line 333 "rx-decode.opc"
5963 int a AU = (op[1] >> 7) & 0x01;
5964 #line 333 "rx-decode.opc"
5965 int src AU = (op[1] >> 4) & 0x07;
5966 #line 333 "rx-decode.opc"
5967 int b AU = (op[1] >> 3) & 0x01;
5968 #line 333 "rx-decode.opc"
5969 int dst AU = op[1] & 0x07;
5970 if (trace)
5971 {
5972 printf ("\033[33m%s\033[0m %02x %02x\n",
5973 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5974 op[0], op[1]);
5975 printf (" sz = 0x%x,", sz);
5976 printf (" dsp = 0x%x,", dsp);
5977 printf (" a = 0x%x,", a);
5978 printf (" src = 0x%x,", src);
5979 printf (" b = 0x%x,", b);
5980 printf (" dst = 0x%x\n", dst);
5981 }
5982 SYNTAX("mov%s %1, %0");
5983 #line 333 "rx-decode.opc"
5984 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5985
5986 }
5987 break;
5988 }
5989 break;
5990 case 0x89:
5991 GETBYTE ();
5992 switch (op[1] & 0x00)
5993 {
5994 case 0x00:
5995 goto op_semantics_40;
5996 break;
5997 }
5998 break;
5999 case 0x8a:
6000 GETBYTE ();
6001 switch (op[1] & 0x00)
6002 {
6003 case 0x00:
6004 goto op_semantics_40;
6005 break;
6006 }
6007 break;
6008 case 0x8b:
6009 GETBYTE ();
6010 switch (op[1] & 0x00)
6011 {
6012 case 0x00:
6013 goto op_semantics_40;
6014 break;
6015 }
6016 break;
6017 case 0x8c:
6018 GETBYTE ();
6019 switch (op[1] & 0x00)
6020 {
6021 case 0x00:
6022 goto op_semantics_40;
6023 break;
6024 }
6025 break;
6026 case 0x8d:
6027 GETBYTE ();
6028 switch (op[1] & 0x00)
6029 {
6030 case 0x00:
6031 goto op_semantics_40;
6032 break;
6033 }
6034 break;
6035 case 0x8e:
6036 GETBYTE ();
6037 switch (op[1] & 0x00)
6038 {
6039 case 0x00:
6040 goto op_semantics_40;
6041 break;
6042 }
6043 break;
6044 case 0x8f:
6045 GETBYTE ();
6046 switch (op[1] & 0x00)
6047 {
6048 case 0x00:
6049 goto op_semantics_40;
6050 break;
6051 }
6052 break;
6053 case 0x90:
6054 GETBYTE ();
6055 switch (op[1] & 0x00)
6056 {
6057 case 0x00:
6058 goto op_semantics_39;
6059 break;
6060 }
6061 break;
6062 case 0x91:
6063 GETBYTE ();
6064 switch (op[1] & 0x00)
6065 {
6066 case 0x00:
6067 goto op_semantics_39;
6068 break;
6069 }
6070 break;
6071 case 0x92:
6072 GETBYTE ();
6073 switch (op[1] & 0x00)
6074 {
6075 case 0x00:
6076 goto op_semantics_39;
6077 break;
6078 }
6079 break;
6080 case 0x93:
6081 GETBYTE ();
6082 switch (op[1] & 0x00)
6083 {
6084 case 0x00:
6085 goto op_semantics_39;
6086 break;
6087 }
6088 break;
6089 case 0x94:
6090 GETBYTE ();
6091 switch (op[1] & 0x00)
6092 {
6093 case 0x00:
6094 goto op_semantics_39;
6095 break;
6096 }
6097 break;
6098 case 0x95:
6099 GETBYTE ();
6100 switch (op[1] & 0x00)
6101 {
6102 case 0x00:
6103 goto op_semantics_39;
6104 break;
6105 }
6106 break;
6107 case 0x96:
6108 GETBYTE ();
6109 switch (op[1] & 0x00)
6110 {
6111 case 0x00:
6112 goto op_semantics_39;
6113 break;
6114 }
6115 break;
6116 case 0x97:
6117 GETBYTE ();
6118 switch (op[1] & 0x00)
6119 {
6120 case 0x00:
6121 goto op_semantics_39;
6122 break;
6123 }
6124 break;
6125 case 0x98:
6126 GETBYTE ();
6127 switch (op[1] & 0x00)
6128 {
6129 case 0x00:
6130 goto op_semantics_40;
6131 break;
6132 }
6133 break;
6134 case 0x99:
6135 GETBYTE ();
6136 switch (op[1] & 0x00)
6137 {
6138 case 0x00:
6139 goto op_semantics_40;
6140 break;
6141 }
6142 break;
6143 case 0x9a:
6144 GETBYTE ();
6145 switch (op[1] & 0x00)
6146 {
6147 case 0x00:
6148 goto op_semantics_40;
6149 break;
6150 }
6151 break;
6152 case 0x9b:
6153 GETBYTE ();
6154 switch (op[1] & 0x00)
6155 {
6156 case 0x00:
6157 goto op_semantics_40;
6158 break;
6159 }
6160 break;
6161 case 0x9c:
6162 GETBYTE ();
6163 switch (op[1] & 0x00)
6164 {
6165 case 0x00:
6166 goto op_semantics_40;
6167 break;
6168 }
6169 break;
6170 case 0x9d:
6171 GETBYTE ();
6172 switch (op[1] & 0x00)
6173 {
6174 case 0x00:
6175 goto op_semantics_40;
6176 break;
6177 }
6178 break;
6179 case 0x9e:
6180 GETBYTE ();
6181 switch (op[1] & 0x00)
6182 {
6183 case 0x00:
6184 goto op_semantics_40;
6185 break;
6186 }
6187 break;
6188 case 0x9f:
6189 GETBYTE ();
6190 switch (op[1] & 0x00)
6191 {
6192 case 0x00:
6193 goto op_semantics_40;
6194 break;
6195 }
6196 break;
6197 case 0xa0:
6198 GETBYTE ();
6199 switch (op[1] & 0x00)
6200 {
6201 case 0x00:
6202 goto op_semantics_39;
6203 break;
6204 }
6205 break;
6206 case 0xa1:
6207 GETBYTE ();
6208 switch (op[1] & 0x00)
6209 {
6210 case 0x00:
6211 goto op_semantics_39;
6212 break;
6213 }
6214 break;
6215 case 0xa2:
6216 GETBYTE ();
6217 switch (op[1] & 0x00)
6218 {
6219 case 0x00:
6220 goto op_semantics_39;
6221 break;
6222 }
6223 break;
6224 case 0xa3:
6225 GETBYTE ();
6226 switch (op[1] & 0x00)
6227 {
6228 case 0x00:
6229 goto op_semantics_39;
6230 break;
6231 }
6232 break;
6233 case 0xa4:
6234 GETBYTE ();
6235 switch (op[1] & 0x00)
6236 {
6237 case 0x00:
6238 goto op_semantics_39;
6239 break;
6240 }
6241 break;
6242 case 0xa5:
6243 GETBYTE ();
6244 switch (op[1] & 0x00)
6245 {
6246 case 0x00:
6247 goto op_semantics_39;
6248 break;
6249 }
6250 break;
6251 case 0xa6:
6252 GETBYTE ();
6253 switch (op[1] & 0x00)
6254 {
6255 case 0x00:
6256 goto op_semantics_39;
6257 break;
6258 }
6259 break;
6260 case 0xa7:
6261 GETBYTE ();
6262 switch (op[1] & 0x00)
6263 {
6264 case 0x00:
6265 goto op_semantics_39;
6266 break;
6267 }
6268 break;
6269 case 0xa8:
6270 GETBYTE ();
6271 switch (op[1] & 0x00)
6272 {
6273 case 0x00:
6274 goto op_semantics_40;
6275 break;
6276 }
6277 break;
6278 case 0xa9:
6279 GETBYTE ();
6280 switch (op[1] & 0x00)
6281 {
6282 case 0x00:
6283 goto op_semantics_40;
6284 break;
6285 }
6286 break;
6287 case 0xaa:
6288 GETBYTE ();
6289 switch (op[1] & 0x00)
6290 {
6291 case 0x00:
6292 goto op_semantics_40;
6293 break;
6294 }
6295 break;
6296 case 0xab:
6297 GETBYTE ();
6298 switch (op[1] & 0x00)
6299 {
6300 case 0x00:
6301 goto op_semantics_40;
6302 break;
6303 }
6304 break;
6305 case 0xac:
6306 GETBYTE ();
6307 switch (op[1] & 0x00)
6308 {
6309 case 0x00:
6310 goto op_semantics_40;
6311 break;
6312 }
6313 break;
6314 case 0xad:
6315 GETBYTE ();
6316 switch (op[1] & 0x00)
6317 {
6318 case 0x00:
6319 goto op_semantics_40;
6320 break;
6321 }
6322 break;
6323 case 0xae:
6324 GETBYTE ();
6325 switch (op[1] & 0x00)
6326 {
6327 case 0x00:
6328 goto op_semantics_40;
6329 break;
6330 }
6331 break;
6332 case 0xaf:
6333 GETBYTE ();
6334 switch (op[1] & 0x00)
6335 {
6336 case 0x00:
6337 goto op_semantics_40;
6338 break;
6339 }
6340 break;
6341 case 0xb0:
6342 GETBYTE ();
6343 switch (op[1] & 0x00)
6344 {
6345 case 0x00:
6346 op_semantics_41:
6347 {
6348 /** 1011 w dsp a src b dst movu%s %1, %0 */
6349 #line 356 "rx-decode.opc"
6350 int w AU = (op[0] >> 3) & 0x01;
6351 #line 356 "rx-decode.opc"
6352 int dsp AU = op[0] & 0x07;
6353 #line 356 "rx-decode.opc"
6354 int a AU = (op[1] >> 7) & 0x01;
6355 #line 356 "rx-decode.opc"
6356 int src AU = (op[1] >> 4) & 0x07;
6357 #line 356 "rx-decode.opc"
6358 int b AU = (op[1] >> 3) & 0x01;
6359 #line 356 "rx-decode.opc"
6360 int dst AU = op[1] & 0x07;
6361 if (trace)
6362 {
6363 printf ("\033[33m%s\033[0m %02x %02x\n",
6364 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6365 op[0], op[1]);
6366 printf (" w = 0x%x,", w);
6367 printf (" dsp = 0x%x,", dsp);
6368 printf (" a = 0x%x,", a);
6369 printf (" src = 0x%x,", src);
6370 printf (" b = 0x%x,", b);
6371 printf (" dst = 0x%x\n", dst);
6372 }
6373 SYNTAX("movu%s %1, %0");
6374 #line 356 "rx-decode.opc"
6375 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6376
6377 }
6378 break;
6379 }
6380 break;
6381 case 0xb1:
6382 GETBYTE ();
6383 switch (op[1] & 0x00)
6384 {
6385 case 0x00:
6386 goto op_semantics_41;
6387 break;
6388 }
6389 break;
6390 case 0xb2:
6391 GETBYTE ();
6392 switch (op[1] & 0x00)
6393 {
6394 case 0x00:
6395 goto op_semantics_41;
6396 break;
6397 }
6398 break;
6399 case 0xb3:
6400 GETBYTE ();
6401 switch (op[1] & 0x00)
6402 {
6403 case 0x00:
6404 goto op_semantics_41;
6405 break;
6406 }
6407 break;
6408 case 0xb4:
6409 GETBYTE ();
6410 switch (op[1] & 0x00)
6411 {
6412 case 0x00:
6413 goto op_semantics_41;
6414 break;
6415 }
6416 break;
6417 case 0xb5:
6418 GETBYTE ();
6419 switch (op[1] & 0x00)
6420 {
6421 case 0x00:
6422 goto op_semantics_41;
6423 break;
6424 }
6425 break;
6426 case 0xb6:
6427 GETBYTE ();
6428 switch (op[1] & 0x00)
6429 {
6430 case 0x00:
6431 goto op_semantics_41;
6432 break;
6433 }
6434 break;
6435 case 0xb7:
6436 GETBYTE ();
6437 switch (op[1] & 0x00)
6438 {
6439 case 0x00:
6440 goto op_semantics_41;
6441 break;
6442 }
6443 break;
6444 case 0xb8:
6445 GETBYTE ();
6446 switch (op[1] & 0x00)
6447 {
6448 case 0x00:
6449 goto op_semantics_41;
6450 break;
6451 }
6452 break;
6453 case 0xb9:
6454 GETBYTE ();
6455 switch (op[1] & 0x00)
6456 {
6457 case 0x00:
6458 goto op_semantics_41;
6459 break;
6460 }
6461 break;
6462 case 0xba:
6463 GETBYTE ();
6464 switch (op[1] & 0x00)
6465 {
6466 case 0x00:
6467 goto op_semantics_41;
6468 break;
6469 }
6470 break;
6471 case 0xbb:
6472 GETBYTE ();
6473 switch (op[1] & 0x00)
6474 {
6475 case 0x00:
6476 goto op_semantics_41;
6477 break;
6478 }
6479 break;
6480 case 0xbc:
6481 GETBYTE ();
6482 switch (op[1] & 0x00)
6483 {
6484 case 0x00:
6485 goto op_semantics_41;
6486 break;
6487 }
6488 break;
6489 case 0xbd:
6490 GETBYTE ();
6491 switch (op[1] & 0x00)
6492 {
6493 case 0x00:
6494 goto op_semantics_41;
6495 break;
6496 }
6497 break;
6498 case 0xbe:
6499 GETBYTE ();
6500 switch (op[1] & 0x00)
6501 {
6502 case 0x00:
6503 goto op_semantics_41;
6504 break;
6505 }
6506 break;
6507 case 0xbf:
6508 GETBYTE ();
6509 switch (op[1] & 0x00)
6510 {
6511 case 0x00:
6512 goto op_semantics_41;
6513 break;
6514 }
6515 break;
6516 case 0xc0:
6517 GETBYTE ();
6518 switch (op[1] & 0x00)
6519 {
6520 case 0x00:
6521 op_semantics_42:
6522 {
6523 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6524 #line 314 "rx-decode.opc"
6525 int sz AU = (op[0] >> 4) & 0x03;
6526 #line 314 "rx-decode.opc"
6527 int sd AU = (op[0] >> 2) & 0x03;
6528 #line 314 "rx-decode.opc"
6529 int ss AU = op[0] & 0x03;
6530 #line 314 "rx-decode.opc"
6531 int rsrc AU = (op[1] >> 4) & 0x0f;
6532 #line 314 "rx-decode.opc"
6533 int rdst AU = op[1] & 0x0f;
6534 if (trace)
6535 {
6536 printf ("\033[33m%s\033[0m %02x %02x\n",
6537 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6538 op[0], op[1]);
6539 printf (" sz = 0x%x,", sz);
6540 printf (" sd = 0x%x,", sd);
6541 printf (" ss = 0x%x,", ss);
6542 printf (" rsrc = 0x%x,", rsrc);
6543 printf (" rdst = 0x%x\n", rdst);
6544 }
6545 SYNTAX("mov%s %1, %0");
6546 #line 314 "rx-decode.opc"
6547 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6548 {
6549 ID(nop2);
6550 SYNTAX ("nop\t; mov.l\tr0, r0");
6551 }
6552 else
6553 {
6554 ID(mov); sBWL(sz); F_____;
6555 if ((ss == 3) && (sd != 3))
6556 {
6557 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6558 }
6559 else
6560 {
6561 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6562 }
6563 }
6564
6565 }
6566 break;
6567 }
6568 break;
6569 case 0xc1:
6570 GETBYTE ();
6571 switch (op[1] & 0x00)
6572 {
6573 case 0x00:
6574 goto op_semantics_42;
6575 break;
6576 }
6577 break;
6578 case 0xc2:
6579 GETBYTE ();
6580 switch (op[1] & 0x00)
6581 {
6582 case 0x00:
6583 goto op_semantics_42;
6584 break;
6585 }
6586 break;
6587 case 0xc3:
6588 GETBYTE ();
6589 switch (op[1] & 0x00)
6590 {
6591 case 0x00:
6592 goto op_semantics_42;
6593 break;
6594 }
6595 break;
6596 case 0xc4:
6597 GETBYTE ();
6598 switch (op[1] & 0x00)
6599 {
6600 case 0x00:
6601 goto op_semantics_42;
6602 break;
6603 }
6604 break;
6605 case 0xc5:
6606 GETBYTE ();
6607 switch (op[1] & 0x00)
6608 {
6609 case 0x00:
6610 goto op_semantics_42;
6611 break;
6612 }
6613 break;
6614 case 0xc6:
6615 GETBYTE ();
6616 switch (op[1] & 0x00)
6617 {
6618 case 0x00:
6619 goto op_semantics_42;
6620 break;
6621 }
6622 break;
6623 case 0xc7:
6624 GETBYTE ();
6625 switch (op[1] & 0x00)
6626 {
6627 case 0x00:
6628 goto op_semantics_42;
6629 break;
6630 }
6631 break;
6632 case 0xc8:
6633 GETBYTE ();
6634 switch (op[1] & 0x00)
6635 {
6636 case 0x00:
6637 goto op_semantics_42;
6638 break;
6639 }
6640 break;
6641 case 0xc9:
6642 GETBYTE ();
6643 switch (op[1] & 0x00)
6644 {
6645 case 0x00:
6646 goto op_semantics_42;
6647 break;
6648 }
6649 break;
6650 case 0xca:
6651 GETBYTE ();
6652 switch (op[1] & 0x00)
6653 {
6654 case 0x00:
6655 goto op_semantics_42;
6656 break;
6657 }
6658 break;
6659 case 0xcb:
6660 GETBYTE ();
6661 switch (op[1] & 0x00)
6662 {
6663 case 0x00:
6664 goto op_semantics_42;
6665 break;
6666 }
6667 break;
6668 case 0xcc:
6669 GETBYTE ();
6670 switch (op[1] & 0x00)
6671 {
6672 case 0x00:
6673 goto op_semantics_42;
6674 break;
6675 }
6676 break;
6677 case 0xcd:
6678 GETBYTE ();
6679 switch (op[1] & 0x00)
6680 {
6681 case 0x00:
6682 goto op_semantics_42;
6683 break;
6684 }
6685 break;
6686 case 0xce:
6687 GETBYTE ();
6688 switch (op[1] & 0x00)
6689 {
6690 case 0x00:
6691 goto op_semantics_42;
6692 break;
6693 }
6694 break;
6695 case 0xcf:
6696 GETBYTE ();
6697 switch (op[1] & 0x00)
6698 {
6699 case 0x00:
6700 goto op_semantics_42;
6701 break;
6702 }
6703 break;
6704 case 0xd0:
6705 GETBYTE ();
6706 switch (op[1] & 0x00)
6707 {
6708 case 0x00:
6709 goto op_semantics_42;
6710 break;
6711 }
6712 break;
6713 case 0xd1:
6714 GETBYTE ();
6715 switch (op[1] & 0x00)
6716 {
6717 case 0x00:
6718 goto op_semantics_42;
6719 break;
6720 }
6721 break;
6722 case 0xd2:
6723 GETBYTE ();
6724 switch (op[1] & 0x00)
6725 {
6726 case 0x00:
6727 goto op_semantics_42;
6728 break;
6729 }
6730 break;
6731 case 0xd3:
6732 GETBYTE ();
6733 switch (op[1] & 0x00)
6734 {
6735 case 0x00:
6736 goto op_semantics_42;
6737 break;
6738 }
6739 break;
6740 case 0xd4:
6741 GETBYTE ();
6742 switch (op[1] & 0x00)
6743 {
6744 case 0x00:
6745 goto op_semantics_42;
6746 break;
6747 }
6748 break;
6749 case 0xd5:
6750 GETBYTE ();
6751 switch (op[1] & 0x00)
6752 {
6753 case 0x00:
6754 goto op_semantics_42;
6755 break;
6756 }
6757 break;
6758 case 0xd6:
6759 GETBYTE ();
6760 switch (op[1] & 0x00)
6761 {
6762 case 0x00:
6763 goto op_semantics_42;
6764 break;
6765 }
6766 break;
6767 case 0xd7:
6768 GETBYTE ();
6769 switch (op[1] & 0x00)
6770 {
6771 case 0x00:
6772 goto op_semantics_42;
6773 break;
6774 }
6775 break;
6776 case 0xd8:
6777 GETBYTE ();
6778 switch (op[1] & 0x00)
6779 {
6780 case 0x00:
6781 goto op_semantics_42;
6782 break;
6783 }
6784 break;
6785 case 0xd9:
6786 GETBYTE ();
6787 switch (op[1] & 0x00)
6788 {
6789 case 0x00:
6790 goto op_semantics_42;
6791 break;
6792 }
6793 break;
6794 case 0xda:
6795 GETBYTE ();
6796 switch (op[1] & 0x00)
6797 {
6798 case 0x00:
6799 goto op_semantics_42;
6800 break;
6801 }
6802 break;
6803 case 0xdb:
6804 GETBYTE ();
6805 switch (op[1] & 0x00)
6806 {
6807 case 0x00:
6808 goto op_semantics_42;
6809 break;
6810 }
6811 break;
6812 case 0xdc:
6813 GETBYTE ();
6814 switch (op[1] & 0x00)
6815 {
6816 case 0x00:
6817 goto op_semantics_42;
6818 break;
6819 }
6820 break;
6821 case 0xdd:
6822 GETBYTE ();
6823 switch (op[1] & 0x00)
6824 {
6825 case 0x00:
6826 goto op_semantics_42;
6827 break;
6828 }
6829 break;
6830 case 0xde:
6831 GETBYTE ();
6832 switch (op[1] & 0x00)
6833 {
6834 case 0x00:
6835 goto op_semantics_42;
6836 break;
6837 }
6838 break;
6839 case 0xdf:
6840 GETBYTE ();
6841 switch (op[1] & 0x00)
6842 {
6843 case 0x00:
6844 goto op_semantics_42;
6845 break;
6846 }
6847 break;
6848 case 0xe0:
6849 GETBYTE ();
6850 switch (op[1] & 0x00)
6851 {
6852 case 0x00:
6853 goto op_semantics_42;
6854 break;
6855 }
6856 break;
6857 case 0xe1:
6858 GETBYTE ();
6859 switch (op[1] & 0x00)
6860 {
6861 case 0x00:
6862 goto op_semantics_42;
6863 break;
6864 }
6865 break;
6866 case 0xe2:
6867 GETBYTE ();
6868 switch (op[1] & 0x00)
6869 {
6870 case 0x00:
6871 goto op_semantics_42;
6872 break;
6873 }
6874 break;
6875 case 0xe3:
6876 GETBYTE ();
6877 switch (op[1] & 0x00)
6878 {
6879 case 0x00:
6880 goto op_semantics_42;
6881 break;
6882 }
6883 break;
6884 case 0xe4:
6885 GETBYTE ();
6886 switch (op[1] & 0x00)
6887 {
6888 case 0x00:
6889 goto op_semantics_42;
6890 break;
6891 }
6892 break;
6893 case 0xe5:
6894 GETBYTE ();
6895 switch (op[1] & 0x00)
6896 {
6897 case 0x00:
6898 goto op_semantics_42;
6899 break;
6900 }
6901 break;
6902 case 0xe6:
6903 GETBYTE ();
6904 switch (op[1] & 0x00)
6905 {
6906 case 0x00:
6907 goto op_semantics_42;
6908 break;
6909 }
6910 break;
6911 case 0xe7:
6912 GETBYTE ();
6913 switch (op[1] & 0x00)
6914 {
6915 case 0x00:
6916 goto op_semantics_42;
6917 break;
6918 }
6919 break;
6920 case 0xe8:
6921 GETBYTE ();
6922 switch (op[1] & 0x00)
6923 {
6924 case 0x00:
6925 goto op_semantics_42;
6926 break;
6927 }
6928 break;
6929 case 0xe9:
6930 GETBYTE ();
6931 switch (op[1] & 0x00)
6932 {
6933 case 0x00:
6934 goto op_semantics_42;
6935 break;
6936 }
6937 break;
6938 case 0xea:
6939 GETBYTE ();
6940 switch (op[1] & 0x00)
6941 {
6942 case 0x00:
6943 goto op_semantics_42;
6944 break;
6945 }
6946 break;
6947 case 0xeb:
6948 GETBYTE ();
6949 switch (op[1] & 0x00)
6950 {
6951 case 0x00:
6952 goto op_semantics_42;
6953 break;
6954 }
6955 break;
6956 case 0xec:
6957 GETBYTE ();
6958 switch (op[1] & 0x00)
6959 {
6960 case 0x00:
6961 goto op_semantics_42;
6962 break;
6963 }
6964 break;
6965 case 0xed:
6966 GETBYTE ();
6967 switch (op[1] & 0x00)
6968 {
6969 case 0x00:
6970 goto op_semantics_42;
6971 break;
6972 }
6973 break;
6974 case 0xee:
6975 GETBYTE ();
6976 switch (op[1] & 0x00)
6977 {
6978 case 0x00:
6979 goto op_semantics_42;
6980 break;
6981 }
6982 break;
6983 case 0xef:
6984 GETBYTE ();
6985 switch (op[1] & 0x00)
6986 {
6987 case 0x00:
6988 goto op_semantics_42;
6989 break;
6990 }
6991 break;
6992 case 0xf0:
6993 GETBYTE ();
6994 switch (op[1] & 0x08)
6995 {
6996 case 0x00:
6997 op_semantics_43:
6998 {
6999 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
7000 #line 939 "rx-decode.opc"
7001 int sd AU = op[0] & 0x03;
7002 #line 939 "rx-decode.opc"
7003 int rdst AU = (op[1] >> 4) & 0x0f;
7004 #line 939 "rx-decode.opc"
7005 int bit AU = op[1] & 0x07;
7006 if (trace)
7007 {
7008 printf ("\033[33m%s\033[0m %02x %02x\n",
7009 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
7010 op[0], op[1]);
7011 printf (" sd = 0x%x,", sd);
7012 printf (" rdst = 0x%x,", rdst);
7013 printf (" bit = 0x%x\n", bit);
7014 }
7015 SYNTAX("bset #%1, %0%S0");
7016 #line 939 "rx-decode.opc"
7017 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7018
7019 }
7020 break;
7021 case 0x08:
7022 op_semantics_44:
7023 {
7024 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
7025 #line 951 "rx-decode.opc"
7026 int sd AU = op[0] & 0x03;
7027 #line 951 "rx-decode.opc"
7028 int rdst AU = (op[1] >> 4) & 0x0f;
7029 #line 951 "rx-decode.opc"
7030 int bit AU = op[1] & 0x07;
7031 if (trace)
7032 {
7033 printf ("\033[33m%s\033[0m %02x %02x\n",
7034 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
7035 op[0], op[1]);
7036 printf (" sd = 0x%x,", sd);
7037 printf (" rdst = 0x%x,", rdst);
7038 printf (" bit = 0x%x\n", bit);
7039 }
7040 SYNTAX("bclr #%1, %0%S0");
7041 #line 951 "rx-decode.opc"
7042 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7043
7044 }
7045 break;
7046 }
7047 break;
7048 case 0xf1:
7049 GETBYTE ();
7050 switch (op[1] & 0x08)
7051 {
7052 case 0x00:
7053 goto op_semantics_43;
7054 break;
7055 case 0x08:
7056 goto op_semantics_44;
7057 break;
7058 }
7059 break;
7060 case 0xf2:
7061 GETBYTE ();
7062 switch (op[1] & 0x08)
7063 {
7064 case 0x00:
7065 goto op_semantics_43;
7066 break;
7067 case 0x08:
7068 goto op_semantics_44;
7069 break;
7070 }
7071 break;
7072 case 0xf3:
7073 GETBYTE ();
7074 switch (op[1] & 0x08)
7075 {
7076 case 0x00:
7077 goto op_semantics_43;
7078 break;
7079 case 0x08:
7080 goto op_semantics_44;
7081 break;
7082 }
7083 break;
7084 case 0xf4:
7085 GETBYTE ();
7086 switch (op[1] & 0x0c)
7087 {
7088 case 0x00:
7089 case 0x04:
7090 op_semantics_45:
7091 {
7092 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
7093 #line 963 "rx-decode.opc"
7094 int sd AU = op[0] & 0x03;
7095 #line 963 "rx-decode.opc"
7096 int rdst AU = (op[1] >> 4) & 0x0f;
7097 #line 963 "rx-decode.opc"
7098 int bit AU = op[1] & 0x07;
7099 if (trace)
7100 {
7101 printf ("\033[33m%s\033[0m %02x %02x\n",
7102 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
7103 op[0], op[1]);
7104 printf (" sd = 0x%x,", sd);
7105 printf (" rdst = 0x%x,", rdst);
7106 printf (" bit = 0x%x\n", bit);
7107 }
7108 SYNTAX("btst #%2, %1%S1");
7109 #line 963 "rx-decode.opc"
7110 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
7111
7112 }
7113 break;
7114 case 0x08:
7115 op_semantics_46:
7116 {
7117 /** 1111 01ss rsrc 10sz push%s %1 */
7118 #line 381 "rx-decode.opc"
7119 int ss AU = op[0] & 0x03;
7120 #line 381 "rx-decode.opc"
7121 int rsrc AU = (op[1] >> 4) & 0x0f;
7122 #line 381 "rx-decode.opc"
7123 int sz AU = op[1] & 0x03;
7124 if (trace)
7125 {
7126 printf ("\033[33m%s\033[0m %02x %02x\n",
7127 "/** 1111 01ss rsrc 10sz push%s %1 */",
7128 op[0], op[1]);
7129 printf (" ss = 0x%x,", ss);
7130 printf (" rsrc = 0x%x,", rsrc);
7131 printf (" sz = 0x%x\n", sz);
7132 }
7133 SYNTAX("push%s %1");
7134 #line 381 "rx-decode.opc"
7135 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
7136
7137 /*----------------------------------------------------------------------*/
7138 /* XCHG */
7139
7140 }
7141 break;
7142 default: UNSUPPORTED(); break;
7143 }
7144 break;
7145 case 0xf5:
7146 GETBYTE ();
7147 switch (op[1] & 0x0c)
7148 {
7149 case 0x00:
7150 case 0x04:
7151 goto op_semantics_45;
7152 break;
7153 case 0x08:
7154 goto op_semantics_46;
7155 break;
7156 default: UNSUPPORTED(); break;
7157 }
7158 break;
7159 case 0xf6:
7160 GETBYTE ();
7161 switch (op[1] & 0x0c)
7162 {
7163 case 0x00:
7164 case 0x04:
7165 goto op_semantics_45;
7166 break;
7167 case 0x08:
7168 goto op_semantics_46;
7169 break;
7170 default: UNSUPPORTED(); break;
7171 }
7172 break;
7173 case 0xf7:
7174 GETBYTE ();
7175 switch (op[1] & 0x0c)
7176 {
7177 case 0x00:
7178 case 0x04:
7179 goto op_semantics_45;
7180 break;
7181 case 0x08:
7182 goto op_semantics_46;
7183 break;
7184 default: UNSUPPORTED(); break;
7185 }
7186 break;
7187 case 0xf8:
7188 GETBYTE ();
7189 switch (op[1] & 0x00)
7190 {
7191 case 0x00:
7192 op_semantics_47:
7193 {
7194 /** 1111 10sd rdst im sz mov%s #%1, %0 */
7195 #line 292 "rx-decode.opc"
7196 int sd AU = op[0] & 0x03;
7197 #line 292 "rx-decode.opc"
7198 int rdst AU = (op[1] >> 4) & 0x0f;
7199 #line 292 "rx-decode.opc"
7200 int im AU = (op[1] >> 2) & 0x03;
7201 #line 292 "rx-decode.opc"
7202 int sz AU = op[1] & 0x03;
7203 if (trace)
7204 {
7205 printf ("\033[33m%s\033[0m %02x %02x\n",
7206 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
7207 op[0], op[1]);
7208 printf (" sd = 0x%x,", sd);
7209 printf (" rdst = 0x%x,", rdst);
7210 printf (" im = 0x%x,", im);
7211 printf (" sz = 0x%x\n", sz);
7212 }
7213 SYNTAX("mov%s #%1, %0");
7214 #line 292 "rx-decode.opc"
7215 ID(mov); DD(sd, rdst, sz);
7216 if ((im == 1 && sz == 0)
7217 || (im == 2 && sz == 1)
7218 || (im == 0 && sz == 2))
7219 {
7220 BWL (sz);
7221 SC(IMM(im));
7222 }
7223 else
7224 {
7225 sBWL (sz);
7226 SC(IMMex(im));
7227 }
7228 F_____;
7229
7230 }
7231 break;
7232 }
7233 break;
7234 case 0xf9:
7235 GETBYTE ();
7236 switch (op[1] & 0x00)
7237 {
7238 case 0x00:
7239 goto op_semantics_47;
7240 break;
7241 }
7242 break;
7243 case 0xfa:
7244 GETBYTE ();
7245 switch (op[1] & 0x00)
7246 {
7247 case 0x00:
7248 goto op_semantics_47;
7249 break;
7250 }
7251 break;
7252 case 0xfb:
7253 GETBYTE ();
7254 switch (op[1] & 0x00)
7255 {
7256 case 0x00:
7257 goto op_semantics_47;
7258 break;
7259 }
7260 break;
7261 case 0xfc:
7262 GETBYTE ();
7263 switch (op[1] & 0xff)
7264 {
7265 case 0x03:
7266 GETBYTE ();
7267 switch (op[2] & 0x00)
7268 {
7269 case 0x00:
7270 {
7271 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7272 #line 555 "rx-decode.opc"
7273 int rsrc AU = (op[2] >> 4) & 0x0f;
7274 #line 555 "rx-decode.opc"
7275 int rdst AU = op[2] & 0x0f;
7276 if (trace)
7277 {
7278 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7279 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7280 op[0], op[1], op[2]);
7281 printf (" rsrc = 0x%x,", rsrc);
7282 printf (" rdst = 0x%x\n", rdst);
7283 }
7284 SYNTAX("sbb %1, %0");
7285 #line 555 "rx-decode.opc"
7286 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7287
7288 /* FIXME: only supports .L */
7289 }
7290 break;
7291 }
7292 break;
7293 case 0x07:
7294 GETBYTE ();
7295 switch (op[2] & 0x00)
7296 {
7297 case 0x00:
7298 {
7299 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7300 #line 486 "rx-decode.opc"
7301 int rsrc AU = (op[2] >> 4) & 0x0f;
7302 #line 486 "rx-decode.opc"
7303 int rdst AU = op[2] & 0x0f;
7304 if (trace)
7305 {
7306 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7307 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7308 op[0], op[1], op[2]);
7309 printf (" rsrc = 0x%x,", rsrc);
7310 printf (" rdst = 0x%x\n", rdst);
7311 }
7312 SYNTAX("neg %2, %0");
7313 #line 486 "rx-decode.opc"
7314 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7315
7316 /*----------------------------------------------------------------------*/
7317 /* ADC */
7318
7319 }
7320 break;
7321 }
7322 break;
7323 case 0x0b:
7324 GETBYTE ();
7325 switch (op[2] & 0x00)
7326 {
7327 case 0x00:
7328 {
7329 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7330 #line 495 "rx-decode.opc"
7331 int rsrc AU = (op[2] >> 4) & 0x0f;
7332 #line 495 "rx-decode.opc"
7333 int rdst AU = op[2] & 0x0f;
7334 if (trace)
7335 {
7336 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7337 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7338 op[0], op[1], op[2]);
7339 printf (" rsrc = 0x%x,", rsrc);
7340 printf (" rdst = 0x%x\n", rdst);
7341 }
7342 SYNTAX("adc %1, %0");
7343 #line 495 "rx-decode.opc"
7344 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7345
7346 }
7347 break;
7348 }
7349 break;
7350 case 0x0f:
7351 GETBYTE ();
7352 switch (op[2] & 0x00)
7353 {
7354 case 0x00:
7355 {
7356 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7357 #line 568 "rx-decode.opc"
7358 int rsrc AU = (op[2] >> 4) & 0x0f;
7359 #line 568 "rx-decode.opc"
7360 int rdst AU = op[2] & 0x0f;
7361 if (trace)
7362 {
7363 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7364 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7365 op[0], op[1], op[2]);
7366 printf (" rsrc = 0x%x,", rsrc);
7367 printf (" rdst = 0x%x\n", rdst);
7368 }
7369 SYNTAX("abs %1, %0");
7370 #line 568 "rx-decode.opc"
7371 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7372
7373 /*----------------------------------------------------------------------*/
7374 /* MAX */
7375
7376 }
7377 break;
7378 }
7379 break;
7380 case 0x10:
7381 GETBYTE ();
7382 switch (op[2] & 0x00)
7383 {
7384 case 0x00:
7385 op_semantics_48:
7386 {
7387 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7388 #line 587 "rx-decode.opc"
7389 int ss AU = op[1] & 0x03;
7390 #line 587 "rx-decode.opc"
7391 int rsrc AU = (op[2] >> 4) & 0x0f;
7392 #line 587 "rx-decode.opc"
7393 int rdst AU = op[2] & 0x0f;
7394 if (trace)
7395 {
7396 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7397 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7398 op[0], op[1], op[2]);
7399 printf (" ss = 0x%x,", ss);
7400 printf (" rsrc = 0x%x,", rsrc);
7401 printf (" rdst = 0x%x\n", rdst);
7402 }
7403 SYNTAX("max %1%S1, %0");
7404 #line 587 "rx-decode.opc"
7405 if (ss == 3 && rsrc == 0 && rdst == 0)
7406 {
7407 ID(nop3);
7408 SYNTAX("nop\t; max\tr0, r0");
7409 }
7410 else
7411 {
7412 ID(max); SP(ss, rsrc); DR(rdst);
7413 }
7414
7415 }
7416 break;
7417 }
7418 break;
7419 case 0x11:
7420 GETBYTE ();
7421 switch (op[2] & 0x00)
7422 {
7423 case 0x00:
7424 goto op_semantics_48;
7425 break;
7426 }
7427 break;
7428 case 0x12:
7429 GETBYTE ();
7430 switch (op[2] & 0x00)
7431 {
7432 case 0x00:
7433 goto op_semantics_48;
7434 break;
7435 }
7436 break;
7437 case 0x13:
7438 GETBYTE ();
7439 switch (op[2] & 0x00)
7440 {
7441 case 0x00:
7442 goto op_semantics_48;
7443 break;
7444 }
7445 break;
7446 case 0x14:
7447 GETBYTE ();
7448 switch (op[2] & 0x00)
7449 {
7450 case 0x00:
7451 op_semantics_49:
7452 {
7453 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7454 #line 607 "rx-decode.opc"
7455 int ss AU = op[1] & 0x03;
7456 #line 607 "rx-decode.opc"
7457 int rsrc AU = (op[2] >> 4) & 0x0f;
7458 #line 607 "rx-decode.opc"
7459 int rdst AU = op[2] & 0x0f;
7460 if (trace)
7461 {
7462 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7463 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7464 op[0], op[1], op[2]);
7465 printf (" ss = 0x%x,", ss);
7466 printf (" rsrc = 0x%x,", rsrc);
7467 printf (" rdst = 0x%x\n", rdst);
7468 }
7469 SYNTAX("min %1%S1, %0");
7470 #line 607 "rx-decode.opc"
7471 ID(min); SP(ss, rsrc); DR(rdst);
7472
7473 }
7474 break;
7475 }
7476 break;
7477 case 0x15:
7478 GETBYTE ();
7479 switch (op[2] & 0x00)
7480 {
7481 case 0x00:
7482 goto op_semantics_49;
7483 break;
7484 }
7485 break;
7486 case 0x16:
7487 GETBYTE ();
7488 switch (op[2] & 0x00)
7489 {
7490 case 0x00:
7491 goto op_semantics_49;
7492 break;
7493 }
7494 break;
7495 case 0x17:
7496 GETBYTE ();
7497 switch (op[2] & 0x00)
7498 {
7499 case 0x00:
7500 goto op_semantics_49;
7501 break;
7502 }
7503 break;
7504 case 0x18:
7505 GETBYTE ();
7506 switch (op[2] & 0x00)
7507 {
7508 case 0x00:
7509 op_semantics_50:
7510 {
7511 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7512 #line 665 "rx-decode.opc"
7513 int ss AU = op[1] & 0x03;
7514 #line 665 "rx-decode.opc"
7515 int rsrc AU = (op[2] >> 4) & 0x0f;
7516 #line 665 "rx-decode.opc"
7517 int rdst AU = op[2] & 0x0f;
7518 if (trace)
7519 {
7520 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7521 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7522 op[0], op[1], op[2]);
7523 printf (" ss = 0x%x,", ss);
7524 printf (" rsrc = 0x%x,", rsrc);
7525 printf (" rdst = 0x%x\n", rdst);
7526 }
7527 SYNTAX("emul %1%S1, %0");
7528 #line 665 "rx-decode.opc"
7529 ID(emul); SP(ss, rsrc); DR(rdst);
7530
7531 }
7532 break;
7533 }
7534 break;
7535 case 0x19:
7536 GETBYTE ();
7537 switch (op[2] & 0x00)
7538 {
7539 case 0x00:
7540 goto op_semantics_50;
7541 break;
7542 }
7543 break;
7544 case 0x1a:
7545 GETBYTE ();
7546 switch (op[2] & 0x00)
7547 {
7548 case 0x00:
7549 goto op_semantics_50;
7550 break;
7551 }
7552 break;
7553 case 0x1b:
7554 GETBYTE ();
7555 switch (op[2] & 0x00)
7556 {
7557 case 0x00:
7558 goto op_semantics_50;
7559 break;
7560 }
7561 break;
7562 case 0x1c:
7563 GETBYTE ();
7564 switch (op[2] & 0x00)
7565 {
7566 case 0x00:
7567 op_semantics_51:
7568 {
7569 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7570 #line 677 "rx-decode.opc"
7571 int ss AU = op[1] & 0x03;
7572 #line 677 "rx-decode.opc"
7573 int rsrc AU = (op[2] >> 4) & 0x0f;
7574 #line 677 "rx-decode.opc"
7575 int rdst AU = op[2] & 0x0f;
7576 if (trace)
7577 {
7578 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7579 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7580 op[0], op[1], op[2]);
7581 printf (" ss = 0x%x,", ss);
7582 printf (" rsrc = 0x%x,", rsrc);
7583 printf (" rdst = 0x%x\n", rdst);
7584 }
7585 SYNTAX("emulu %1%S1, %0");
7586 #line 677 "rx-decode.opc"
7587 ID(emulu); SP(ss, rsrc); DR(rdst);
7588
7589 }
7590 break;
7591 }
7592 break;
7593 case 0x1d:
7594 GETBYTE ();
7595 switch (op[2] & 0x00)
7596 {
7597 case 0x00:
7598 goto op_semantics_51;
7599 break;
7600 }
7601 break;
7602 case 0x1e:
7603 GETBYTE ();
7604 switch (op[2] & 0x00)
7605 {
7606 case 0x00:
7607 goto op_semantics_51;
7608 break;
7609 }
7610 break;
7611 case 0x1f:
7612 GETBYTE ();
7613 switch (op[2] & 0x00)
7614 {
7615 case 0x00:
7616 goto op_semantics_51;
7617 break;
7618 }
7619 break;
7620 case 0x20:
7621 GETBYTE ();
7622 switch (op[2] & 0x00)
7623 {
7624 case 0x00:
7625 op_semantics_52:
7626 {
7627 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7628 #line 689 "rx-decode.opc"
7629 int ss AU = op[1] & 0x03;
7630 #line 689 "rx-decode.opc"
7631 int rsrc AU = (op[2] >> 4) & 0x0f;
7632 #line 689 "rx-decode.opc"
7633 int rdst AU = op[2] & 0x0f;
7634 if (trace)
7635 {
7636 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7637 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7638 op[0], op[1], op[2]);
7639 printf (" ss = 0x%x,", ss);
7640 printf (" rsrc = 0x%x,", rsrc);
7641 printf (" rdst = 0x%x\n", rdst);
7642 }
7643 SYNTAX("div %1%S1, %0");
7644 #line 689 "rx-decode.opc"
7645 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7646
7647 }
7648 break;
7649 }
7650 break;
7651 case 0x21:
7652 GETBYTE ();
7653 switch (op[2] & 0x00)
7654 {
7655 case 0x00:
7656 goto op_semantics_52;
7657 break;
7658 }
7659 break;
7660 case 0x22:
7661 GETBYTE ();
7662 switch (op[2] & 0x00)
7663 {
7664 case 0x00:
7665 goto op_semantics_52;
7666 break;
7667 }
7668 break;
7669 case 0x23:
7670 GETBYTE ();
7671 switch (op[2] & 0x00)
7672 {
7673 case 0x00:
7674 goto op_semantics_52;
7675 break;
7676 }
7677 break;
7678 case 0x24:
7679 GETBYTE ();
7680 switch (op[2] & 0x00)
7681 {
7682 case 0x00:
7683 op_semantics_53:
7684 {
7685 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7686 #line 701 "rx-decode.opc"
7687 int ss AU = op[1] & 0x03;
7688 #line 701 "rx-decode.opc"
7689 int rsrc AU = (op[2] >> 4) & 0x0f;
7690 #line 701 "rx-decode.opc"
7691 int rdst AU = op[2] & 0x0f;
7692 if (trace)
7693 {
7694 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7695 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7696 op[0], op[1], op[2]);
7697 printf (" ss = 0x%x,", ss);
7698 printf (" rsrc = 0x%x,", rsrc);
7699 printf (" rdst = 0x%x\n", rdst);
7700 }
7701 SYNTAX("divu %1%S1, %0");
7702 #line 701 "rx-decode.opc"
7703 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7704
7705 }
7706 break;
7707 }
7708 break;
7709 case 0x25:
7710 GETBYTE ();
7711 switch (op[2] & 0x00)
7712 {
7713 case 0x00:
7714 goto op_semantics_53;
7715 break;
7716 }
7717 break;
7718 case 0x26:
7719 GETBYTE ();
7720 switch (op[2] & 0x00)
7721 {
7722 case 0x00:
7723 goto op_semantics_53;
7724 break;
7725 }
7726 break;
7727 case 0x27:
7728 GETBYTE ();
7729 switch (op[2] & 0x00)
7730 {
7731 case 0x00:
7732 goto op_semantics_53;
7733 break;
7734 }
7735 break;
7736 case 0x30:
7737 GETBYTE ();
7738 switch (op[2] & 0x00)
7739 {
7740 case 0x00:
7741 op_semantics_54:
7742 {
7743 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7744 #line 474 "rx-decode.opc"
7745 int ss AU = op[1] & 0x03;
7746 #line 474 "rx-decode.opc"
7747 int rsrc AU = (op[2] >> 4) & 0x0f;
7748 #line 474 "rx-decode.opc"
7749 int rdst AU = op[2] & 0x0f;
7750 if (trace)
7751 {
7752 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7753 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7754 op[0], op[1], op[2]);
7755 printf (" ss = 0x%x,", ss);
7756 printf (" rsrc = 0x%x,", rsrc);
7757 printf (" rdst = 0x%x\n", rdst);
7758 }
7759 SYNTAX("tst %1%S1, %2");
7760 #line 474 "rx-decode.opc"
7761 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7762
7763 }
7764 break;
7765 }
7766 break;
7767 case 0x31:
7768 GETBYTE ();
7769 switch (op[2] & 0x00)
7770 {
7771 case 0x00:
7772 goto op_semantics_54;
7773 break;
7774 }
7775 break;
7776 case 0x32:
7777 GETBYTE ();
7778 switch (op[2] & 0x00)
7779 {
7780 case 0x00:
7781 goto op_semantics_54;
7782 break;
7783 }
7784 break;
7785 case 0x33:
7786 GETBYTE ();
7787 switch (op[2] & 0x00)
7788 {
7789 case 0x00:
7790 goto op_semantics_54;
7791 break;
7792 }
7793 break;
7794 case 0x34:
7795 GETBYTE ();
7796 switch (op[2] & 0x00)
7797 {
7798 case 0x00:
7799 op_semantics_55:
7800 {
7801 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7802 #line 453 "rx-decode.opc"
7803 int ss AU = op[1] & 0x03;
7804 #line 453 "rx-decode.opc"
7805 int rsrc AU = (op[2] >> 4) & 0x0f;
7806 #line 453 "rx-decode.opc"
7807 int rdst AU = op[2] & 0x0f;
7808 if (trace)
7809 {
7810 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7811 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7812 op[0], op[1], op[2]);
7813 printf (" ss = 0x%x,", ss);
7814 printf (" rsrc = 0x%x,", rsrc);
7815 printf (" rdst = 0x%x\n", rdst);
7816 }
7817 SYNTAX("xor %1%S1, %0");
7818 #line 453 "rx-decode.opc"
7819 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7820
7821 }
7822 break;
7823 }
7824 break;
7825 case 0x35:
7826 GETBYTE ();
7827 switch (op[2] & 0x00)
7828 {
7829 case 0x00:
7830 goto op_semantics_55;
7831 break;
7832 }
7833 break;
7834 case 0x36:
7835 GETBYTE ();
7836 switch (op[2] & 0x00)
7837 {
7838 case 0x00:
7839 goto op_semantics_55;
7840 break;
7841 }
7842 break;
7843 case 0x37:
7844 GETBYTE ();
7845 switch (op[2] & 0x00)
7846 {
7847 case 0x00:
7848 goto op_semantics_55;
7849 break;
7850 }
7851 break;
7852 case 0x3b:
7853 GETBYTE ();
7854 switch (op[2] & 0x00)
7855 {
7856 case 0x00:
7857 {
7858 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7859 #line 465 "rx-decode.opc"
7860 int rsrc AU = (op[2] >> 4) & 0x0f;
7861 #line 465 "rx-decode.opc"
7862 int rdst AU = op[2] & 0x0f;
7863 if (trace)
7864 {
7865 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7866 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7867 op[0], op[1], op[2]);
7868 printf (" rsrc = 0x%x,", rsrc);
7869 printf (" rdst = 0x%x\n", rdst);
7870 }
7871 SYNTAX("not %1, %0");
7872 #line 465 "rx-decode.opc"
7873 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7874
7875 /*----------------------------------------------------------------------*/
7876 /* TST */
7877
7878 }
7879 break;
7880 }
7881 break;
7882 case 0x40:
7883 GETBYTE ();
7884 switch (op[2] & 0x00)
7885 {
7886 case 0x00:
7887 op_semantics_56:
7888 {
7889 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7890 #line 387 "rx-decode.opc"
7891 int ss AU = op[1] & 0x03;
7892 #line 387 "rx-decode.opc"
7893 int rsrc AU = (op[2] >> 4) & 0x0f;
7894 #line 387 "rx-decode.opc"
7895 int rdst AU = op[2] & 0x0f;
7896 if (trace)
7897 {
7898 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7899 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7900 op[0], op[1], op[2]);
7901 printf (" ss = 0x%x,", ss);
7902 printf (" rsrc = 0x%x,", rsrc);
7903 printf (" rdst = 0x%x\n", rdst);
7904 }
7905 SYNTAX("xchg %1%S1, %0");
7906 #line 387 "rx-decode.opc"
7907 ID(xchg); DR(rdst); SP(ss, rsrc);
7908
7909 }
7910 break;
7911 }
7912 break;
7913 case 0x41:
7914 GETBYTE ();
7915 switch (op[2] & 0x00)
7916 {
7917 case 0x00:
7918 goto op_semantics_56;
7919 break;
7920 }
7921 break;
7922 case 0x42:
7923 GETBYTE ();
7924 switch (op[2] & 0x00)
7925 {
7926 case 0x00:
7927 goto op_semantics_56;
7928 break;
7929 }
7930 break;
7931 case 0x43:
7932 GETBYTE ();
7933 switch (op[2] & 0x00)
7934 {
7935 case 0x00:
7936 goto op_semantics_56;
7937 break;
7938 }
7939 break;
7940 case 0x44:
7941 GETBYTE ();
7942 switch (op[2] & 0x00)
7943 {
7944 case 0x00:
7945 op_semantics_57:
7946 {
7947 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7948 #line 930 "rx-decode.opc"
7949 int sd AU = op[1] & 0x03;
7950 #line 930 "rx-decode.opc"
7951 int rsrc AU = (op[2] >> 4) & 0x0f;
7952 #line 930 "rx-decode.opc"
7953 int rdst AU = op[2] & 0x0f;
7954 if (trace)
7955 {
7956 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7957 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7958 op[0], op[1], op[2]);
7959 printf (" sd = 0x%x,", sd);
7960 printf (" rsrc = 0x%x,", rsrc);
7961 printf (" rdst = 0x%x\n", rdst);
7962 }
7963 SYNTAX("itof %1%S1, %0");
7964 #line 930 "rx-decode.opc"
7965 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7966
7967 }
7968 break;
7969 }
7970 break;
7971 case 0x45:
7972 GETBYTE ();
7973 switch (op[2] & 0x00)
7974 {
7975 case 0x00:
7976 goto op_semantics_57;
7977 break;
7978 }
7979 break;
7980 case 0x46:
7981 GETBYTE ();
7982 switch (op[2] & 0x00)
7983 {
7984 case 0x00:
7985 goto op_semantics_57;
7986 break;
7987 }
7988 break;
7989 case 0x47:
7990 GETBYTE ();
7991 switch (op[2] & 0x00)
7992 {
7993 case 0x00:
7994 goto op_semantics_57;
7995 break;
7996 }
7997 break;
7998 case 0x4b:
7999 GETBYTE ();
8000 switch (op[2] & 0x00)
8001 {
8002 case 0x00:
8003 {
8004 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
8005 #line 1056 "rx-decode.opc"
8006 int rsrc AU = (op[2] >> 4) & 0x0f;
8007 #line 1056 "rx-decode.opc"
8008 int rdst AU = op[2] & 0x0f;
8009 if (trace)
8010 {
8011 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8012 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
8013 op[0], op[1], op[2]);
8014 printf (" rsrc = 0x%x,", rsrc);
8015 printf (" rdst = 0x%x\n", rdst);
8016 }
8017 SYNTAX("stz %1, %0");
8018 #line 1056 "rx-decode.opc"
8019 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
8020
8021 }
8022 break;
8023 }
8024 break;
8025 case 0x4f:
8026 GETBYTE ();
8027 switch (op[2] & 0x00)
8028 {
8029 case 0x00:
8030 {
8031 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
8032 #line 1059 "rx-decode.opc"
8033 int rsrc AU = (op[2] >> 4) & 0x0f;
8034 #line 1059 "rx-decode.opc"
8035 int rdst AU = op[2] & 0x0f;
8036 if (trace)
8037 {
8038 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8039 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
8040 op[0], op[1], op[2]);
8041 printf (" rsrc = 0x%x,", rsrc);
8042 printf (" rdst = 0x%x\n", rdst);
8043 }
8044 SYNTAX("stnz %1, %0");
8045 #line 1059 "rx-decode.opc"
8046 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
8047
8048 }
8049 break;
8050 }
8051 break;
8052 case 0x54:
8053 GETBYTE ();
8054 switch (op[2] & 0x00)
8055 {
8056 case 0x00:
8057 op_semantics_58:
8058 {
8059 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
8060 #line 1116 "rx-decode.opc"
8061 int sd AU = op[1] & 0x03;
8062 #line 1116 "rx-decode.opc"
8063 int rsrc AU = (op[2] >> 4) & 0x0f;
8064 #line 1116 "rx-decode.opc"
8065 int rdst AU = op[2] & 0x0f;
8066 if (trace)
8067 {
8068 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8069 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
8070 op[0], op[1], op[2]);
8071 printf (" sd = 0x%x,", sd);
8072 printf (" rsrc = 0x%x,", rsrc);
8073 printf (" rdst = 0x%x\n", rdst);
8074 }
8075 SYNTAX("utof %1%S1, %0");
8076 #line 1116 "rx-decode.opc"
8077 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
8078
8079 }
8080 break;
8081 }
8082 break;
8083 case 0x55:
8084 GETBYTE ();
8085 switch (op[2] & 0x00)
8086 {
8087 case 0x00:
8088 goto op_semantics_58;
8089 break;
8090 }
8091 break;
8092 case 0x56:
8093 GETBYTE ();
8094 switch (op[2] & 0x00)
8095 {
8096 case 0x00:
8097 goto op_semantics_58;
8098 break;
8099 }
8100 break;
8101 case 0x57:
8102 GETBYTE ();
8103 switch (op[2] & 0x00)
8104 {
8105 case 0x00:
8106 goto op_semantics_58;
8107 break;
8108 }
8109 break;
8110 case 0x60:
8111 GETBYTE ();
8112 switch (op[2] & 0x00)
8113 {
8114 case 0x00:
8115 op_semantics_59:
8116 {
8117 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
8118 #line 942 "rx-decode.opc"
8119 int sd AU = op[1] & 0x03;
8120 #line 942 "rx-decode.opc"
8121 int rdst AU = (op[2] >> 4) & 0x0f;
8122 #line 942 "rx-decode.opc"
8123 int rsrc AU = op[2] & 0x0f;
8124 if (trace)
8125 {
8126 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8127 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
8128 op[0], op[1], op[2]);
8129 printf (" sd = 0x%x,", sd);
8130 printf (" rdst = 0x%x,", rdst);
8131 printf (" rsrc = 0x%x\n", rsrc);
8132 }
8133 SYNTAX("bset %1, %0%S0");
8134 #line 942 "rx-decode.opc"
8135 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8136 if (sd == 3) /* bset reg,reg */
8137 BWL(LSIZE);
8138
8139 }
8140 break;
8141 }
8142 break;
8143 case 0x61:
8144 GETBYTE ();
8145 switch (op[2] & 0x00)
8146 {
8147 case 0x00:
8148 goto op_semantics_59;
8149 break;
8150 }
8151 break;
8152 case 0x62:
8153 GETBYTE ();
8154 switch (op[2] & 0x00)
8155 {
8156 case 0x00:
8157 goto op_semantics_59;
8158 break;
8159 }
8160 break;
8161 case 0x63:
8162 GETBYTE ();
8163 switch (op[2] & 0x00)
8164 {
8165 case 0x00:
8166 goto op_semantics_59;
8167 break;
8168 }
8169 break;
8170 case 0x64:
8171 GETBYTE ();
8172 switch (op[2] & 0x00)
8173 {
8174 case 0x00:
8175 op_semantics_60:
8176 {
8177 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
8178 #line 954 "rx-decode.opc"
8179 int sd AU = op[1] & 0x03;
8180 #line 954 "rx-decode.opc"
8181 int rdst AU = (op[2] >> 4) & 0x0f;
8182 #line 954 "rx-decode.opc"
8183 int rsrc AU = op[2] & 0x0f;
8184 if (trace)
8185 {
8186 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8187 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
8188 op[0], op[1], op[2]);
8189 printf (" sd = 0x%x,", sd);
8190 printf (" rdst = 0x%x,", rdst);
8191 printf (" rsrc = 0x%x\n", rsrc);
8192 }
8193 SYNTAX("bclr %1, %0%S0");
8194 #line 954 "rx-decode.opc"
8195 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8196 if (sd == 3) /* bset reg,reg */
8197 BWL(LSIZE);
8198
8199 }
8200 break;
8201 }
8202 break;
8203 case 0x65:
8204 GETBYTE ();
8205 switch (op[2] & 0x00)
8206 {
8207 case 0x00:
8208 goto op_semantics_60;
8209 break;
8210 }
8211 break;
8212 case 0x66:
8213 GETBYTE ();
8214 switch (op[2] & 0x00)
8215 {
8216 case 0x00:
8217 goto op_semantics_60;
8218 break;
8219 }
8220 break;
8221 case 0x67:
8222 GETBYTE ();
8223 switch (op[2] & 0x00)
8224 {
8225 case 0x00:
8226 goto op_semantics_60;
8227 break;
8228 }
8229 break;
8230 case 0x68:
8231 GETBYTE ();
8232 switch (op[2] & 0x00)
8233 {
8234 case 0x00:
8235 op_semantics_61:
8236 {
8237 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
8238 #line 966 "rx-decode.opc"
8239 int sd AU = op[1] & 0x03;
8240 #line 966 "rx-decode.opc"
8241 int rdst AU = (op[2] >> 4) & 0x0f;
8242 #line 966 "rx-decode.opc"
8243 int rsrc AU = op[2] & 0x0f;
8244 if (trace)
8245 {
8246 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8247 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
8248 op[0], op[1], op[2]);
8249 printf (" sd = 0x%x,", sd);
8250 printf (" rdst = 0x%x,", rdst);
8251 printf (" rsrc = 0x%x\n", rsrc);
8252 }
8253 SYNTAX("btst %2, %1%S1");
8254 #line 966 "rx-decode.opc"
8255 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8256 if (sd == 3) /* bset reg,reg */
8257 BWL(LSIZE);
8258
8259 }
8260 break;
8261 }
8262 break;
8263 case 0x69:
8264 GETBYTE ();
8265 switch (op[2] & 0x00)
8266 {
8267 case 0x00:
8268 goto op_semantics_61;
8269 break;
8270 }
8271 break;
8272 case 0x6a:
8273 GETBYTE ();
8274 switch (op[2] & 0x00)
8275 {
8276 case 0x00:
8277 goto op_semantics_61;
8278 break;
8279 }
8280 break;
8281 case 0x6b:
8282 GETBYTE ();
8283 switch (op[2] & 0x00)
8284 {
8285 case 0x00:
8286 goto op_semantics_61;
8287 break;
8288 }
8289 break;
8290 case 0x6c:
8291 GETBYTE ();
8292 switch (op[2] & 0x00)
8293 {
8294 case 0x00:
8295 op_semantics_62:
8296 {
8297 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
8298 #line 978 "rx-decode.opc"
8299 int sd AU = op[1] & 0x03;
8300 #line 978 "rx-decode.opc"
8301 int rdst AU = (op[2] >> 4) & 0x0f;
8302 #line 978 "rx-decode.opc"
8303 int rsrc AU = op[2] & 0x0f;
8304 if (trace)
8305 {
8306 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8307 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
8308 op[0], op[1], op[2]);
8309 printf (" sd = 0x%x,", sd);
8310 printf (" rdst = 0x%x,", rdst);
8311 printf (" rsrc = 0x%x\n", rsrc);
8312 }
8313 SYNTAX("bnot %1, %0%S0");
8314 #line 978 "rx-decode.opc"
8315 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8316 if (sd == 3) /* bset reg,reg */
8317 BWL(LSIZE);
8318
8319 }
8320 break;
8321 }
8322 break;
8323 case 0x6d:
8324 GETBYTE ();
8325 switch (op[2] & 0x00)
8326 {
8327 case 0x00:
8328 goto op_semantics_62;
8329 break;
8330 }
8331 break;
8332 case 0x6e:
8333 GETBYTE ();
8334 switch (op[2] & 0x00)
8335 {
8336 case 0x00:
8337 goto op_semantics_62;
8338 break;
8339 }
8340 break;
8341 case 0x6f:
8342 GETBYTE ();
8343 switch (op[2] & 0x00)
8344 {
8345 case 0x00:
8346 goto op_semantics_62;
8347 break;
8348 }
8349 break;
8350 case 0x80:
8351 GETBYTE ();
8352 switch (op[2] & 0x00)
8353 {
8354 case 0x00:
8355 op_semantics_63:
8356 {
8357 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8358 #line 909 "rx-decode.opc"
8359 int sd AU = op[1] & 0x03;
8360 #line 909 "rx-decode.opc"
8361 int rsrc AU = (op[2] >> 4) & 0x0f;
8362 #line 909 "rx-decode.opc"
8363 int rdst AU = op[2] & 0x0f;
8364 if (trace)
8365 {
8366 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8367 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8368 op[0], op[1], op[2]);
8369 printf (" sd = 0x%x,", sd);
8370 printf (" rsrc = 0x%x,", rsrc);
8371 printf (" rdst = 0x%x\n", rdst);
8372 }
8373 SYNTAX("fsub %1%S1, %0");
8374 #line 909 "rx-decode.opc"
8375 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8376
8377 }
8378 break;
8379 }
8380 break;
8381 case 0x81:
8382 GETBYTE ();
8383 switch (op[2] & 0x00)
8384 {
8385 case 0x00:
8386 goto op_semantics_63;
8387 break;
8388 }
8389 break;
8390 case 0x82:
8391 GETBYTE ();
8392 switch (op[2] & 0x00)
8393 {
8394 case 0x00:
8395 goto op_semantics_63;
8396 break;
8397 }
8398 break;
8399 case 0x83:
8400 GETBYTE ();
8401 switch (op[2] & 0x00)
8402 {
8403 case 0x00:
8404 goto op_semantics_63;
8405 break;
8406 }
8407 break;
8408 case 0x84:
8409 GETBYTE ();
8410 switch (op[2] & 0x00)
8411 {
8412 case 0x00:
8413 op_semantics_64:
8414 {
8415 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8416 #line 903 "rx-decode.opc"
8417 int sd AU = op[1] & 0x03;
8418 #line 903 "rx-decode.opc"
8419 int rsrc AU = (op[2] >> 4) & 0x0f;
8420 #line 903 "rx-decode.opc"
8421 int rdst AU = op[2] & 0x0f;
8422 if (trace)
8423 {
8424 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8425 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8426 op[0], op[1], op[2]);
8427 printf (" sd = 0x%x,", sd);
8428 printf (" rsrc = 0x%x,", rsrc);
8429 printf (" rdst = 0x%x\n", rdst);
8430 }
8431 SYNTAX("fcmp %1%S1, %0");
8432 #line 903 "rx-decode.opc"
8433 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8434
8435 }
8436 break;
8437 }
8438 break;
8439 case 0x85:
8440 GETBYTE ();
8441 switch (op[2] & 0x00)
8442 {
8443 case 0x00:
8444 goto op_semantics_64;
8445 break;
8446 }
8447 break;
8448 case 0x86:
8449 GETBYTE ();
8450 switch (op[2] & 0x00)
8451 {
8452 case 0x00:
8453 goto op_semantics_64;
8454 break;
8455 }
8456 break;
8457 case 0x87:
8458 GETBYTE ();
8459 switch (op[2] & 0x00)
8460 {
8461 case 0x00:
8462 goto op_semantics_64;
8463 break;
8464 }
8465 break;
8466 case 0x88:
8467 GETBYTE ();
8468 switch (op[2] & 0x00)
8469 {
8470 case 0x00:
8471 op_semantics_65:
8472 {
8473 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8474 #line 897 "rx-decode.opc"
8475 int sd AU = op[1] & 0x03;
8476 #line 897 "rx-decode.opc"
8477 int rsrc AU = (op[2] >> 4) & 0x0f;
8478 #line 897 "rx-decode.opc"
8479 int rdst AU = op[2] & 0x0f;
8480 if (trace)
8481 {
8482 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8483 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8484 op[0], op[1], op[2]);
8485 printf (" sd = 0x%x,", sd);
8486 printf (" rsrc = 0x%x,", rsrc);
8487 printf (" rdst = 0x%x\n", rdst);
8488 }
8489 SYNTAX("fadd %1%S1, %0");
8490 #line 897 "rx-decode.opc"
8491 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8492
8493 }
8494 break;
8495 }
8496 break;
8497 case 0x89:
8498 GETBYTE ();
8499 switch (op[2] & 0x00)
8500 {
8501 case 0x00:
8502 goto op_semantics_65;
8503 break;
8504 }
8505 break;
8506 case 0x8a:
8507 GETBYTE ();
8508 switch (op[2] & 0x00)
8509 {
8510 case 0x00:
8511 goto op_semantics_65;
8512 break;
8513 }
8514 break;
8515 case 0x8b:
8516 GETBYTE ();
8517 switch (op[2] & 0x00)
8518 {
8519 case 0x00:
8520 goto op_semantics_65;
8521 break;
8522 }
8523 break;
8524 case 0x8c:
8525 GETBYTE ();
8526 switch (op[2] & 0x00)
8527 {
8528 case 0x00:
8529 op_semantics_66:
8530 {
8531 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8532 #line 918 "rx-decode.opc"
8533 int sd AU = op[1] & 0x03;
8534 #line 918 "rx-decode.opc"
8535 int rsrc AU = (op[2] >> 4) & 0x0f;
8536 #line 918 "rx-decode.opc"
8537 int rdst AU = op[2] & 0x0f;
8538 if (trace)
8539 {
8540 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8541 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8542 op[0], op[1], op[2]);
8543 printf (" sd = 0x%x,", sd);
8544 printf (" rsrc = 0x%x,", rsrc);
8545 printf (" rdst = 0x%x\n", rdst);
8546 }
8547 SYNTAX("fmul %1%S1, %0");
8548 #line 918 "rx-decode.opc"
8549 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8550
8551 }
8552 break;
8553 }
8554 break;
8555 case 0x8d:
8556 GETBYTE ();
8557 switch (op[2] & 0x00)
8558 {
8559 case 0x00:
8560 goto op_semantics_66;
8561 break;
8562 }
8563 break;
8564 case 0x8e:
8565 GETBYTE ();
8566 switch (op[2] & 0x00)
8567 {
8568 case 0x00:
8569 goto op_semantics_66;
8570 break;
8571 }
8572 break;
8573 case 0x8f:
8574 GETBYTE ();
8575 switch (op[2] & 0x00)
8576 {
8577 case 0x00:
8578 goto op_semantics_66;
8579 break;
8580 }
8581 break;
8582 case 0x90:
8583 GETBYTE ();
8584 switch (op[2] & 0x00)
8585 {
8586 case 0x00:
8587 op_semantics_67:
8588 {
8589 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8590 #line 924 "rx-decode.opc"
8591 int sd AU = op[1] & 0x03;
8592 #line 924 "rx-decode.opc"
8593 int rsrc AU = (op[2] >> 4) & 0x0f;
8594 #line 924 "rx-decode.opc"
8595 int rdst AU = op[2] & 0x0f;
8596 if (trace)
8597 {
8598 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8599 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8600 op[0], op[1], op[2]);
8601 printf (" sd = 0x%x,", sd);
8602 printf (" rsrc = 0x%x,", rsrc);
8603 printf (" rdst = 0x%x\n", rdst);
8604 }
8605 SYNTAX("fdiv %1%S1, %0");
8606 #line 924 "rx-decode.opc"
8607 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8608
8609 }
8610 break;
8611 }
8612 break;
8613 case 0x91:
8614 GETBYTE ();
8615 switch (op[2] & 0x00)
8616 {
8617 case 0x00:
8618 goto op_semantics_67;
8619 break;
8620 }
8621 break;
8622 case 0x92:
8623 GETBYTE ();
8624 switch (op[2] & 0x00)
8625 {
8626 case 0x00:
8627 goto op_semantics_67;
8628 break;
8629 }
8630 break;
8631 case 0x93:
8632 GETBYTE ();
8633 switch (op[2] & 0x00)
8634 {
8635 case 0x00:
8636 goto op_semantics_67;
8637 break;
8638 }
8639 break;
8640 case 0x94:
8641 GETBYTE ();
8642 switch (op[2] & 0x00)
8643 {
8644 case 0x00:
8645 op_semantics_68:
8646 {
8647 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8648 #line 912 "rx-decode.opc"
8649 int sd AU = op[1] & 0x03;
8650 #line 912 "rx-decode.opc"
8651 int rsrc AU = (op[2] >> 4) & 0x0f;
8652 #line 912 "rx-decode.opc"
8653 int rdst AU = op[2] & 0x0f;
8654 if (trace)
8655 {
8656 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8657 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8658 op[0], op[1], op[2]);
8659 printf (" sd = 0x%x,", sd);
8660 printf (" rsrc = 0x%x,", rsrc);
8661 printf (" rdst = 0x%x\n", rdst);
8662 }
8663 SYNTAX("ftoi %1%S1, %0");
8664 #line 912 "rx-decode.opc"
8665 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8666
8667 }
8668 break;
8669 }
8670 break;
8671 case 0x95:
8672 GETBYTE ();
8673 switch (op[2] & 0x00)
8674 {
8675 case 0x00:
8676 goto op_semantics_68;
8677 break;
8678 }
8679 break;
8680 case 0x96:
8681 GETBYTE ();
8682 switch (op[2] & 0x00)
8683 {
8684 case 0x00:
8685 goto op_semantics_68;
8686 break;
8687 }
8688 break;
8689 case 0x97:
8690 GETBYTE ();
8691 switch (op[2] & 0x00)
8692 {
8693 case 0x00:
8694 goto op_semantics_68;
8695 break;
8696 }
8697 break;
8698 case 0x98:
8699 GETBYTE ();
8700 switch (op[2] & 0x00)
8701 {
8702 case 0x00:
8703 op_semantics_69:
8704 {
8705 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8706 #line 927 "rx-decode.opc"
8707 int sd AU = op[1] & 0x03;
8708 #line 927 "rx-decode.opc"
8709 int rsrc AU = (op[2] >> 4) & 0x0f;
8710 #line 927 "rx-decode.opc"
8711 int rdst AU = op[2] & 0x0f;
8712 if (trace)
8713 {
8714 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8715 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8716 op[0], op[1], op[2]);
8717 printf (" sd = 0x%x,", sd);
8718 printf (" rsrc = 0x%x,", rsrc);
8719 printf (" rdst = 0x%x\n", rdst);
8720 }
8721 SYNTAX("round %1%S1, %0");
8722 #line 927 "rx-decode.opc"
8723 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8724
8725 }
8726 break;
8727 }
8728 break;
8729 case 0x99:
8730 GETBYTE ();
8731 switch (op[2] & 0x00)
8732 {
8733 case 0x00:
8734 goto op_semantics_69;
8735 break;
8736 }
8737 break;
8738 case 0x9a:
8739 GETBYTE ();
8740 switch (op[2] & 0x00)
8741 {
8742 case 0x00:
8743 goto op_semantics_69;
8744 break;
8745 }
8746 break;
8747 case 0x9b:
8748 GETBYTE ();
8749 switch (op[2] & 0x00)
8750 {
8751 case 0x00:
8752 goto op_semantics_69;
8753 break;
8754 }
8755 break;
8756 case 0xa0:
8757 GETBYTE ();
8758 switch (op[2] & 0x00)
8759 {
8760 case 0x00:
8761 op_semantics_70:
8762 {
8763 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
8764 #line 1110 "rx-decode.opc"
8765 int sd AU = op[1] & 0x03;
8766 #line 1110 "rx-decode.opc"
8767 int rsrc AU = (op[2] >> 4) & 0x0f;
8768 #line 1110 "rx-decode.opc"
8769 int rdst AU = op[2] & 0x0f;
8770 if (trace)
8771 {
8772 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8773 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
8774 op[0], op[1], op[2]);
8775 printf (" sd = 0x%x,", sd);
8776 printf (" rsrc = 0x%x,", rsrc);
8777 printf (" rdst = 0x%x\n", rdst);
8778 }
8779 SYNTAX("fsqrt %1%S1, %0");
8780 #line 1110 "rx-decode.opc"
8781 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8782
8783 }
8784 break;
8785 }
8786 break;
8787 case 0xa1:
8788 GETBYTE ();
8789 switch (op[2] & 0x00)
8790 {
8791 case 0x00:
8792 goto op_semantics_70;
8793 break;
8794 }
8795 break;
8796 case 0xa2:
8797 GETBYTE ();
8798 switch (op[2] & 0x00)
8799 {
8800 case 0x00:
8801 goto op_semantics_70;
8802 break;
8803 }
8804 break;
8805 case 0xa3:
8806 GETBYTE ();
8807 switch (op[2] & 0x00)
8808 {
8809 case 0x00:
8810 goto op_semantics_70;
8811 break;
8812 }
8813 break;
8814 case 0xa4:
8815 GETBYTE ();
8816 switch (op[2] & 0x00)
8817 {
8818 case 0x00:
8819 op_semantics_71:
8820 {
8821 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
8822 #line 1113 "rx-decode.opc"
8823 int sd AU = op[1] & 0x03;
8824 #line 1113 "rx-decode.opc"
8825 int rsrc AU = (op[2] >> 4) & 0x0f;
8826 #line 1113 "rx-decode.opc"
8827 int rdst AU = op[2] & 0x0f;
8828 if (trace)
8829 {
8830 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8831 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
8832 op[0], op[1], op[2]);
8833 printf (" sd = 0x%x,", sd);
8834 printf (" rsrc = 0x%x,", rsrc);
8835 printf (" rdst = 0x%x\n", rdst);
8836 }
8837 SYNTAX("ftou %1%S1, %0");
8838 #line 1113 "rx-decode.opc"
8839 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8840
8841 }
8842 break;
8843 }
8844 break;
8845 case 0xa5:
8846 GETBYTE ();
8847 switch (op[2] & 0x00)
8848 {
8849 case 0x00:
8850 goto op_semantics_71;
8851 break;
8852 }
8853 break;
8854 case 0xa6:
8855 GETBYTE ();
8856 switch (op[2] & 0x00)
8857 {
8858 case 0x00:
8859 goto op_semantics_71;
8860 break;
8861 }
8862 break;
8863 case 0xa7:
8864 GETBYTE ();
8865 switch (op[2] & 0x00)
8866 {
8867 case 0x00:
8868 goto op_semantics_71;
8869 break;
8870 }
8871 break;
8872 case 0xd0:
8873 GETBYTE ();
8874 switch (op[2] & 0x00)
8875 {
8876 case 0x00:
8877 op_semantics_72:
8878 {
8879 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8880 #line 1044 "rx-decode.opc"
8881 int sz AU = (op[1] >> 2) & 0x03;
8882 #line 1044 "rx-decode.opc"
8883 int sd AU = op[1] & 0x03;
8884 #line 1044 "rx-decode.opc"
8885 int rdst AU = (op[2] >> 4) & 0x0f;
8886 #line 1044 "rx-decode.opc"
8887 int cond AU = op[2] & 0x0f;
8888 if (trace)
8889 {
8890 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8891 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8892 op[0], op[1], op[2]);
8893 printf (" sz = 0x%x,", sz);
8894 printf (" sd = 0x%x,", sd);
8895 printf (" rdst = 0x%x,", rdst);
8896 printf (" cond = 0x%x\n", cond);
8897 }
8898 SYNTAX("sc%1%s %0");
8899 #line 1044 "rx-decode.opc"
8900 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8901
8902 /*----------------------------------------------------------------------*/
8903 /* RXv2 enhanced */
8904
8905 }
8906 break;
8907 }
8908 break;
8909 case 0xd1:
8910 GETBYTE ();
8911 switch (op[2] & 0x00)
8912 {
8913 case 0x00:
8914 goto op_semantics_72;
8915 break;
8916 }
8917 break;
8918 case 0xd2:
8919 GETBYTE ();
8920 switch (op[2] & 0x00)
8921 {
8922 case 0x00:
8923 goto op_semantics_72;
8924 break;
8925 }
8926 break;
8927 case 0xd3:
8928 GETBYTE ();
8929 switch (op[2] & 0x00)
8930 {
8931 case 0x00:
8932 goto op_semantics_72;
8933 break;
8934 }
8935 break;
8936 case 0xd4:
8937 GETBYTE ();
8938 switch (op[2] & 0x00)
8939 {
8940 case 0x00:
8941 goto op_semantics_72;
8942 break;
8943 }
8944 break;
8945 case 0xd5:
8946 GETBYTE ();
8947 switch (op[2] & 0x00)
8948 {
8949 case 0x00:
8950 goto op_semantics_72;
8951 break;
8952 }
8953 break;
8954 case 0xd6:
8955 GETBYTE ();
8956 switch (op[2] & 0x00)
8957 {
8958 case 0x00:
8959 goto op_semantics_72;
8960 break;
8961 }
8962 break;
8963 case 0xd7:
8964 GETBYTE ();
8965 switch (op[2] & 0x00)
8966 {
8967 case 0x00:
8968 goto op_semantics_72;
8969 break;
8970 }
8971 break;
8972 case 0xd8:
8973 GETBYTE ();
8974 switch (op[2] & 0x00)
8975 {
8976 case 0x00:
8977 goto op_semantics_72;
8978 break;
8979 }
8980 break;
8981 case 0xd9:
8982 GETBYTE ();
8983 switch (op[2] & 0x00)
8984 {
8985 case 0x00:
8986 goto op_semantics_72;
8987 break;
8988 }
8989 break;
8990 case 0xda:
8991 GETBYTE ();
8992 switch (op[2] & 0x00)
8993 {
8994 case 0x00:
8995 goto op_semantics_72;
8996 break;
8997 }
8998 break;
8999 case 0xdb:
9000 GETBYTE ();
9001 switch (op[2] & 0x00)
9002 {
9003 case 0x00:
9004 goto op_semantics_72;
9005 break;
9006 }
9007 break;
9008 case 0xe0:
9009 GETBYTE ();
9010 switch (op[2] & 0x0f)
9011 {
9012 case 0x00:
9013 case 0x01:
9014 case 0x02:
9015 case 0x03:
9016 case 0x04:
9017 case 0x05:
9018 case 0x06:
9019 case 0x07:
9020 case 0x08:
9021 case 0x09:
9022 case 0x0a:
9023 case 0x0b:
9024 case 0x0c:
9025 case 0x0d:
9026 case 0x0e:
9027 op_semantics_73:
9028 {
9029 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
9030 #line 987 "rx-decode.opc"
9031 int bit AU = (op[1] >> 2) & 0x07;
9032 #line 987 "rx-decode.opc"
9033 int sd AU = op[1] & 0x03;
9034 #line 987 "rx-decode.opc"
9035 int rdst AU = (op[2] >> 4) & 0x0f;
9036 #line 987 "rx-decode.opc"
9037 int cond AU = op[2] & 0x0f;
9038 if (trace)
9039 {
9040 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9041 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
9042 op[0], op[1], op[2]);
9043 printf (" bit = 0x%x,", bit);
9044 printf (" sd = 0x%x,", sd);
9045 printf (" rdst = 0x%x,", rdst);
9046 printf (" cond = 0x%x\n", cond);
9047 }
9048 SYNTAX("bm%2 #%1, %0%S0");
9049 #line 987 "rx-decode.opc"
9050 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
9051
9052 }
9053 break;
9054 case 0x0f:
9055 op_semantics_74:
9056 {
9057 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
9058 #line 975 "rx-decode.opc"
9059 int bit AU = (op[1] >> 2) & 0x07;
9060 #line 975 "rx-decode.opc"
9061 int sd AU = op[1] & 0x03;
9062 #line 975 "rx-decode.opc"
9063 int rdst AU = (op[2] >> 4) & 0x0f;
9064 if (trace)
9065 {
9066 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9067 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
9068 op[0], op[1], op[2]);
9069 printf (" bit = 0x%x,", bit);
9070 printf (" sd = 0x%x,", sd);
9071 printf (" rdst = 0x%x\n", rdst);
9072 }
9073 SYNTAX("bnot #%1, %0%S0");
9074 #line 975 "rx-decode.opc"
9075 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
9076
9077 }
9078 break;
9079 }
9080 break;
9081 case 0xe1:
9082 GETBYTE ();
9083 switch (op[2] & 0x0f)
9084 {
9085 case 0x00:
9086 case 0x01:
9087 case 0x02:
9088 case 0x03:
9089 case 0x04:
9090 case 0x05:
9091 case 0x06:
9092 case 0x07:
9093 case 0x08:
9094 case 0x09:
9095 case 0x0a:
9096 case 0x0b:
9097 case 0x0c:
9098 case 0x0d:
9099 case 0x0e:
9100 goto op_semantics_73;
9101 break;
9102 case 0x0f:
9103 goto op_semantics_74;
9104 break;
9105 }
9106 break;
9107 case 0xe2:
9108 GETBYTE ();
9109 switch (op[2] & 0x0f)
9110 {
9111 case 0x00:
9112 case 0x01:
9113 case 0x02:
9114 case 0x03:
9115 case 0x04:
9116 case 0x05:
9117 case 0x06:
9118 case 0x07:
9119 case 0x08:
9120 case 0x09:
9121 case 0x0a:
9122 case 0x0b:
9123 case 0x0c:
9124 case 0x0d:
9125 case 0x0e:
9126 goto op_semantics_73;
9127 break;
9128 case 0x0f:
9129 goto op_semantics_74;
9130 break;
9131 }
9132 break;
9133 case 0xe3:
9134 GETBYTE ();
9135 switch (op[2] & 0x0f)
9136 {
9137 case 0x00:
9138 case 0x01:
9139 case 0x02:
9140 case 0x03:
9141 case 0x04:
9142 case 0x05:
9143 case 0x06:
9144 case 0x07:
9145 case 0x08:
9146 case 0x09:
9147 case 0x0a:
9148 case 0x0b:
9149 case 0x0c:
9150 case 0x0d:
9151 case 0x0e:
9152 goto op_semantics_73;
9153 break;
9154 case 0x0f:
9155 goto op_semantics_74;
9156 break;
9157 }
9158 break;
9159 case 0xe4:
9160 GETBYTE ();
9161 switch (op[2] & 0x0f)
9162 {
9163 case 0x00:
9164 case 0x01:
9165 case 0x02:
9166 case 0x03:
9167 case 0x04:
9168 case 0x05:
9169 case 0x06:
9170 case 0x07:
9171 case 0x08:
9172 case 0x09:
9173 case 0x0a:
9174 case 0x0b:
9175 case 0x0c:
9176 case 0x0d:
9177 case 0x0e:
9178 goto op_semantics_73;
9179 break;
9180 case 0x0f:
9181 goto op_semantics_74;
9182 break;
9183 }
9184 break;
9185 case 0xe5:
9186 GETBYTE ();
9187 switch (op[2] & 0x0f)
9188 {
9189 case 0x00:
9190 case 0x01:
9191 case 0x02:
9192 case 0x03:
9193 case 0x04:
9194 case 0x05:
9195 case 0x06:
9196 case 0x07:
9197 case 0x08:
9198 case 0x09:
9199 case 0x0a:
9200 case 0x0b:
9201 case 0x0c:
9202 case 0x0d:
9203 case 0x0e:
9204 goto op_semantics_73;
9205 break;
9206 case 0x0f:
9207 goto op_semantics_74;
9208 break;
9209 }
9210 break;
9211 case 0xe6:
9212 GETBYTE ();
9213 switch (op[2] & 0x0f)
9214 {
9215 case 0x00:
9216 case 0x01:
9217 case 0x02:
9218 case 0x03:
9219 case 0x04:
9220 case 0x05:
9221 case 0x06:
9222 case 0x07:
9223 case 0x08:
9224 case 0x09:
9225 case 0x0a:
9226 case 0x0b:
9227 case 0x0c:
9228 case 0x0d:
9229 case 0x0e:
9230 goto op_semantics_73;
9231 break;
9232 case 0x0f:
9233 goto op_semantics_74;
9234 break;
9235 }
9236 break;
9237 case 0xe7:
9238 GETBYTE ();
9239 switch (op[2] & 0x0f)
9240 {
9241 case 0x00:
9242 case 0x01:
9243 case 0x02:
9244 case 0x03:
9245 case 0x04:
9246 case 0x05:
9247 case 0x06:
9248 case 0x07:
9249 case 0x08:
9250 case 0x09:
9251 case 0x0a:
9252 case 0x0b:
9253 case 0x0c:
9254 case 0x0d:
9255 case 0x0e:
9256 goto op_semantics_73;
9257 break;
9258 case 0x0f:
9259 goto op_semantics_74;
9260 break;
9261 }
9262 break;
9263 case 0xe8:
9264 GETBYTE ();
9265 switch (op[2] & 0x0f)
9266 {
9267 case 0x00:
9268 case 0x01:
9269 case 0x02:
9270 case 0x03:
9271 case 0x04:
9272 case 0x05:
9273 case 0x06:
9274 case 0x07:
9275 case 0x08:
9276 case 0x09:
9277 case 0x0a:
9278 case 0x0b:
9279 case 0x0c:
9280 case 0x0d:
9281 case 0x0e:
9282 goto op_semantics_73;
9283 break;
9284 case 0x0f:
9285 goto op_semantics_74;
9286 break;
9287 }
9288 break;
9289 case 0xe9:
9290 GETBYTE ();
9291 switch (op[2] & 0x0f)
9292 {
9293 case 0x00:
9294 case 0x01:
9295 case 0x02:
9296 case 0x03:
9297 case 0x04:
9298 case 0x05:
9299 case 0x06:
9300 case 0x07:
9301 case 0x08:
9302 case 0x09:
9303 case 0x0a:
9304 case 0x0b:
9305 case 0x0c:
9306 case 0x0d:
9307 case 0x0e:
9308 goto op_semantics_73;
9309 break;
9310 case 0x0f:
9311 goto op_semantics_74;
9312 break;
9313 }
9314 break;
9315 case 0xea:
9316 GETBYTE ();
9317 switch (op[2] & 0x0f)
9318 {
9319 case 0x00:
9320 case 0x01:
9321 case 0x02:
9322 case 0x03:
9323 case 0x04:
9324 case 0x05:
9325 case 0x06:
9326 case 0x07:
9327 case 0x08:
9328 case 0x09:
9329 case 0x0a:
9330 case 0x0b:
9331 case 0x0c:
9332 case 0x0d:
9333 case 0x0e:
9334 goto op_semantics_73;
9335 break;
9336 case 0x0f:
9337 goto op_semantics_74;
9338 break;
9339 }
9340 break;
9341 case 0xeb:
9342 GETBYTE ();
9343 switch (op[2] & 0x0f)
9344 {
9345 case 0x00:
9346 case 0x01:
9347 case 0x02:
9348 case 0x03:
9349 case 0x04:
9350 case 0x05:
9351 case 0x06:
9352 case 0x07:
9353 case 0x08:
9354 case 0x09:
9355 case 0x0a:
9356 case 0x0b:
9357 case 0x0c:
9358 case 0x0d:
9359 case 0x0e:
9360 goto op_semantics_73;
9361 break;
9362 case 0x0f:
9363 goto op_semantics_74;
9364 break;
9365 }
9366 break;
9367 case 0xec:
9368 GETBYTE ();
9369 switch (op[2] & 0x0f)
9370 {
9371 case 0x00:
9372 case 0x01:
9373 case 0x02:
9374 case 0x03:
9375 case 0x04:
9376 case 0x05:
9377 case 0x06:
9378 case 0x07:
9379 case 0x08:
9380 case 0x09:
9381 case 0x0a:
9382 case 0x0b:
9383 case 0x0c:
9384 case 0x0d:
9385 case 0x0e:
9386 goto op_semantics_73;
9387 break;
9388 case 0x0f:
9389 goto op_semantics_74;
9390 break;
9391 }
9392 break;
9393 case 0xed:
9394 GETBYTE ();
9395 switch (op[2] & 0x0f)
9396 {
9397 case 0x00:
9398 case 0x01:
9399 case 0x02:
9400 case 0x03:
9401 case 0x04:
9402 case 0x05:
9403 case 0x06:
9404 case 0x07:
9405 case 0x08:
9406 case 0x09:
9407 case 0x0a:
9408 case 0x0b:
9409 case 0x0c:
9410 case 0x0d:
9411 case 0x0e:
9412 goto op_semantics_73;
9413 break;
9414 case 0x0f:
9415 goto op_semantics_74;
9416 break;
9417 }
9418 break;
9419 case 0xee:
9420 GETBYTE ();
9421 switch (op[2] & 0x0f)
9422 {
9423 case 0x00:
9424 case 0x01:
9425 case 0x02:
9426 case 0x03:
9427 case 0x04:
9428 case 0x05:
9429 case 0x06:
9430 case 0x07:
9431 case 0x08:
9432 case 0x09:
9433 case 0x0a:
9434 case 0x0b:
9435 case 0x0c:
9436 case 0x0d:
9437 case 0x0e:
9438 goto op_semantics_73;
9439 break;
9440 case 0x0f:
9441 goto op_semantics_74;
9442 break;
9443 }
9444 break;
9445 case 0xef:
9446 GETBYTE ();
9447 switch (op[2] & 0x0f)
9448 {
9449 case 0x00:
9450 case 0x01:
9451 case 0x02:
9452 case 0x03:
9453 case 0x04:
9454 case 0x05:
9455 case 0x06:
9456 case 0x07:
9457 case 0x08:
9458 case 0x09:
9459 case 0x0a:
9460 case 0x0b:
9461 case 0x0c:
9462 case 0x0d:
9463 case 0x0e:
9464 goto op_semantics_73;
9465 break;
9466 case 0x0f:
9467 goto op_semantics_74;
9468 break;
9469 }
9470 break;
9471 case 0xf0:
9472 GETBYTE ();
9473 switch (op[2] & 0x0f)
9474 {
9475 case 0x00:
9476 case 0x01:
9477 case 0x02:
9478 case 0x03:
9479 case 0x04:
9480 case 0x05:
9481 case 0x06:
9482 case 0x07:
9483 case 0x08:
9484 case 0x09:
9485 case 0x0a:
9486 case 0x0b:
9487 case 0x0c:
9488 case 0x0d:
9489 case 0x0e:
9490 goto op_semantics_73;
9491 break;
9492 case 0x0f:
9493 goto op_semantics_74;
9494 break;
9495 }
9496 break;
9497 case 0xf1:
9498 GETBYTE ();
9499 switch (op[2] & 0x0f)
9500 {
9501 case 0x00:
9502 case 0x01:
9503 case 0x02:
9504 case 0x03:
9505 case 0x04:
9506 case 0x05:
9507 case 0x06:
9508 case 0x07:
9509 case 0x08:
9510 case 0x09:
9511 case 0x0a:
9512 case 0x0b:
9513 case 0x0c:
9514 case 0x0d:
9515 case 0x0e:
9516 goto op_semantics_73;
9517 break;
9518 case 0x0f:
9519 goto op_semantics_74;
9520 break;
9521 }
9522 break;
9523 case 0xf2:
9524 GETBYTE ();
9525 switch (op[2] & 0x0f)
9526 {
9527 case 0x00:
9528 case 0x01:
9529 case 0x02:
9530 case 0x03:
9531 case 0x04:
9532 case 0x05:
9533 case 0x06:
9534 case 0x07:
9535 case 0x08:
9536 case 0x09:
9537 case 0x0a:
9538 case 0x0b:
9539 case 0x0c:
9540 case 0x0d:
9541 case 0x0e:
9542 goto op_semantics_73;
9543 break;
9544 case 0x0f:
9545 goto op_semantics_74;
9546 break;
9547 }
9548 break;
9549 case 0xf3:
9550 GETBYTE ();
9551 switch (op[2] & 0x0f)
9552 {
9553 case 0x00:
9554 case 0x01:
9555 case 0x02:
9556 case 0x03:
9557 case 0x04:
9558 case 0x05:
9559 case 0x06:
9560 case 0x07:
9561 case 0x08:
9562 case 0x09:
9563 case 0x0a:
9564 case 0x0b:
9565 case 0x0c:
9566 case 0x0d:
9567 case 0x0e:
9568 goto op_semantics_73;
9569 break;
9570 case 0x0f:
9571 goto op_semantics_74;
9572 break;
9573 }
9574 break;
9575 case 0xf4:
9576 GETBYTE ();
9577 switch (op[2] & 0x0f)
9578 {
9579 case 0x00:
9580 case 0x01:
9581 case 0x02:
9582 case 0x03:
9583 case 0x04:
9584 case 0x05:
9585 case 0x06:
9586 case 0x07:
9587 case 0x08:
9588 case 0x09:
9589 case 0x0a:
9590 case 0x0b:
9591 case 0x0c:
9592 case 0x0d:
9593 case 0x0e:
9594 goto op_semantics_73;
9595 break;
9596 case 0x0f:
9597 goto op_semantics_74;
9598 break;
9599 }
9600 break;
9601 case 0xf5:
9602 GETBYTE ();
9603 switch (op[2] & 0x0f)
9604 {
9605 case 0x00:
9606 case 0x01:
9607 case 0x02:
9608 case 0x03:
9609 case 0x04:
9610 case 0x05:
9611 case 0x06:
9612 case 0x07:
9613 case 0x08:
9614 case 0x09:
9615 case 0x0a:
9616 case 0x0b:
9617 case 0x0c:
9618 case 0x0d:
9619 case 0x0e:
9620 goto op_semantics_73;
9621 break;
9622 case 0x0f:
9623 goto op_semantics_74;
9624 break;
9625 }
9626 break;
9627 case 0xf6:
9628 GETBYTE ();
9629 switch (op[2] & 0x0f)
9630 {
9631 case 0x00:
9632 case 0x01:
9633 case 0x02:
9634 case 0x03:
9635 case 0x04:
9636 case 0x05:
9637 case 0x06:
9638 case 0x07:
9639 case 0x08:
9640 case 0x09:
9641 case 0x0a:
9642 case 0x0b:
9643 case 0x0c:
9644 case 0x0d:
9645 case 0x0e:
9646 goto op_semantics_73;
9647 break;
9648 case 0x0f:
9649 goto op_semantics_74;
9650 break;
9651 }
9652 break;
9653 case 0xf7:
9654 GETBYTE ();
9655 switch (op[2] & 0x0f)
9656 {
9657 case 0x00:
9658 case 0x01:
9659 case 0x02:
9660 case 0x03:
9661 case 0x04:
9662 case 0x05:
9663 case 0x06:
9664 case 0x07:
9665 case 0x08:
9666 case 0x09:
9667 case 0x0a:
9668 case 0x0b:
9669 case 0x0c:
9670 case 0x0d:
9671 case 0x0e:
9672 goto op_semantics_73;
9673 break;
9674 case 0x0f:
9675 goto op_semantics_74;
9676 break;
9677 }
9678 break;
9679 case 0xf8:
9680 GETBYTE ();
9681 switch (op[2] & 0x0f)
9682 {
9683 case 0x00:
9684 case 0x01:
9685 case 0x02:
9686 case 0x03:
9687 case 0x04:
9688 case 0x05:
9689 case 0x06:
9690 case 0x07:
9691 case 0x08:
9692 case 0x09:
9693 case 0x0a:
9694 case 0x0b:
9695 case 0x0c:
9696 case 0x0d:
9697 case 0x0e:
9698 goto op_semantics_73;
9699 break;
9700 case 0x0f:
9701 goto op_semantics_74;
9702 break;
9703 }
9704 break;
9705 case 0xf9:
9706 GETBYTE ();
9707 switch (op[2] & 0x0f)
9708 {
9709 case 0x00:
9710 case 0x01:
9711 case 0x02:
9712 case 0x03:
9713 case 0x04:
9714 case 0x05:
9715 case 0x06:
9716 case 0x07:
9717 case 0x08:
9718 case 0x09:
9719 case 0x0a:
9720 case 0x0b:
9721 case 0x0c:
9722 case 0x0d:
9723 case 0x0e:
9724 goto op_semantics_73;
9725 break;
9726 case 0x0f:
9727 goto op_semantics_74;
9728 break;
9729 }
9730 break;
9731 case 0xfa:
9732 GETBYTE ();
9733 switch (op[2] & 0x0f)
9734 {
9735 case 0x00:
9736 case 0x01:
9737 case 0x02:
9738 case 0x03:
9739 case 0x04:
9740 case 0x05:
9741 case 0x06:
9742 case 0x07:
9743 case 0x08:
9744 case 0x09:
9745 case 0x0a:
9746 case 0x0b:
9747 case 0x0c:
9748 case 0x0d:
9749 case 0x0e:
9750 goto op_semantics_73;
9751 break;
9752 case 0x0f:
9753 goto op_semantics_74;
9754 break;
9755 }
9756 break;
9757 case 0xfb:
9758 GETBYTE ();
9759 switch (op[2] & 0x0f)
9760 {
9761 case 0x00:
9762 case 0x01:
9763 case 0x02:
9764 case 0x03:
9765 case 0x04:
9766 case 0x05:
9767 case 0x06:
9768 case 0x07:
9769 case 0x08:
9770 case 0x09:
9771 case 0x0a:
9772 case 0x0b:
9773 case 0x0c:
9774 case 0x0d:
9775 case 0x0e:
9776 goto op_semantics_73;
9777 break;
9778 case 0x0f:
9779 goto op_semantics_74;
9780 break;
9781 }
9782 break;
9783 case 0xfc:
9784 GETBYTE ();
9785 switch (op[2] & 0x0f)
9786 {
9787 case 0x00:
9788 case 0x01:
9789 case 0x02:
9790 case 0x03:
9791 case 0x04:
9792 case 0x05:
9793 case 0x06:
9794 case 0x07:
9795 case 0x08:
9796 case 0x09:
9797 case 0x0a:
9798 case 0x0b:
9799 case 0x0c:
9800 case 0x0d:
9801 case 0x0e:
9802 goto op_semantics_73;
9803 break;
9804 case 0x0f:
9805 goto op_semantics_74;
9806 break;
9807 }
9808 break;
9809 case 0xfd:
9810 GETBYTE ();
9811 switch (op[2] & 0x0f)
9812 {
9813 case 0x00:
9814 case 0x01:
9815 case 0x02:
9816 case 0x03:
9817 case 0x04:
9818 case 0x05:
9819 case 0x06:
9820 case 0x07:
9821 case 0x08:
9822 case 0x09:
9823 case 0x0a:
9824 case 0x0b:
9825 case 0x0c:
9826 case 0x0d:
9827 case 0x0e:
9828 goto op_semantics_73;
9829 break;
9830 case 0x0f:
9831 goto op_semantics_74;
9832 break;
9833 }
9834 break;
9835 case 0xfe:
9836 GETBYTE ();
9837 switch (op[2] & 0x0f)
9838 {
9839 case 0x00:
9840 case 0x01:
9841 case 0x02:
9842 case 0x03:
9843 case 0x04:
9844 case 0x05:
9845 case 0x06:
9846 case 0x07:
9847 case 0x08:
9848 case 0x09:
9849 case 0x0a:
9850 case 0x0b:
9851 case 0x0c:
9852 case 0x0d:
9853 case 0x0e:
9854 goto op_semantics_73;
9855 break;
9856 case 0x0f:
9857 goto op_semantics_74;
9858 break;
9859 }
9860 break;
9861 case 0xff:
9862 GETBYTE ();
9863 switch (op[2] & 0x0f)
9864 {
9865 case 0x00:
9866 case 0x01:
9867 case 0x02:
9868 case 0x03:
9869 case 0x04:
9870 case 0x05:
9871 case 0x06:
9872 case 0x07:
9873 case 0x08:
9874 case 0x09:
9875 case 0x0a:
9876 case 0x0b:
9877 case 0x0c:
9878 case 0x0d:
9879 case 0x0e:
9880 goto op_semantics_73;
9881 break;
9882 case 0x0f:
9883 goto op_semantics_74;
9884 break;
9885 }
9886 break;
9887 default: UNSUPPORTED(); break;
9888 }
9889 break;
9890 case 0xfd:
9891 GETBYTE ();
9892 switch (op[1] & 0xff)
9893 {
9894 case 0x00:
9895 GETBYTE ();
9896 switch (op[2] & 0x00)
9897 {
9898 case 0x00:
9899 op_semantics_75:
9900 {
9901 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
9902 #line 852 "rx-decode.opc"
9903 int a AU = (op[1] >> 3) & 0x01;
9904 #line 852 "rx-decode.opc"
9905 int srca AU = (op[2] >> 4) & 0x0f;
9906 #line 852 "rx-decode.opc"
9907 int srcb AU = op[2] & 0x0f;
9908 if (trace)
9909 {
9910 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9911 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
9912 op[0], op[1], op[2]);
9913 printf (" a = 0x%x,", a);
9914 printf (" srca = 0x%x,", srca);
9915 printf (" srcb = 0x%x\n", srcb);
9916 }
9917 SYNTAX("mulhi %1, %2, %0");
9918 #line 852 "rx-decode.opc"
9919 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
9920
9921 }
9922 break;
9923 }
9924 break;
9925 case 0x01:
9926 GETBYTE ();
9927 switch (op[2] & 0x00)
9928 {
9929 case 0x00:
9930 op_semantics_76:
9931 {
9932 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
9933 #line 855 "rx-decode.opc"
9934 int a AU = (op[1] >> 3) & 0x01;
9935 #line 855 "rx-decode.opc"
9936 int srca AU = (op[2] >> 4) & 0x0f;
9937 #line 855 "rx-decode.opc"
9938 int srcb AU = op[2] & 0x0f;
9939 if (trace)
9940 {
9941 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9942 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
9943 op[0], op[1], op[2]);
9944 printf (" a = 0x%x,", a);
9945 printf (" srca = 0x%x,", srca);
9946 printf (" srcb = 0x%x\n", srcb);
9947 }
9948 SYNTAX("mullo %1, %2, %0");
9949 #line 855 "rx-decode.opc"
9950 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
9951
9952 }
9953 break;
9954 }
9955 break;
9956 case 0x02:
9957 GETBYTE ();
9958 switch (op[2] & 0x00)
9959 {
9960 case 0x00:
9961 op_semantics_77:
9962 {
9963 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
9964 #line 1083 "rx-decode.opc"
9965 int a AU = (op[1] >> 3) & 0x01;
9966 #line 1083 "rx-decode.opc"
9967 int srca AU = (op[2] >> 4) & 0x0f;
9968 #line 1083 "rx-decode.opc"
9969 int srcb AU = op[2] & 0x0f;
9970 if (trace)
9971 {
9972 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9973 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
9974 op[0], op[1], op[2]);
9975 printf (" a = 0x%x,", a);
9976 printf (" srca = 0x%x,", srca);
9977 printf (" srcb = 0x%x\n", srcb);
9978 }
9979 SYNTAX("mullh %1, %2, %0");
9980 #line 1083 "rx-decode.opc"
9981 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
9982
9983 }
9984 break;
9985 }
9986 break;
9987 case 0x03:
9988 GETBYTE ();
9989 switch (op[2] & 0x00)
9990 {
9991 case 0x00:
9992 op_semantics_78:
9993 {
9994 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
9995 #line 1068 "rx-decode.opc"
9996 int a AU = (op[1] >> 3) & 0x01;
9997 #line 1068 "rx-decode.opc"
9998 int srca AU = (op[2] >> 4) & 0x0f;
9999 #line 1068 "rx-decode.opc"
10000 int srcb AU = op[2] & 0x0f;
10001 if (trace)
10002 {
10003 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10004 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
10005 op[0], op[1], op[2]);
10006 printf (" a = 0x%x,", a);
10007 printf (" srca = 0x%x,", srca);
10008 printf (" srcb = 0x%x\n", srcb);
10009 }
10010 SYNTAX("emula %1, %2, %0");
10011 #line 1068 "rx-decode.opc"
10012 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
10013
10014 }
10015 break;
10016 }
10017 break;
10018 case 0x04:
10019 GETBYTE ();
10020 switch (op[2] & 0x00)
10021 {
10022 case 0x00:
10023 op_semantics_79:
10024 {
10025 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
10026 #line 858 "rx-decode.opc"
10027 int a AU = (op[1] >> 3) & 0x01;
10028 #line 858 "rx-decode.opc"
10029 int srca AU = (op[2] >> 4) & 0x0f;
10030 #line 858 "rx-decode.opc"
10031 int srcb AU = op[2] & 0x0f;
10032 if (trace)
10033 {
10034 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10035 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
10036 op[0], op[1], op[2]);
10037 printf (" a = 0x%x,", a);
10038 printf (" srca = 0x%x,", srca);
10039 printf (" srcb = 0x%x\n", srcb);
10040 }
10041 SYNTAX("machi %1, %2, %0");
10042 #line 858 "rx-decode.opc"
10043 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
10044
10045 }
10046 break;
10047 }
10048 break;
10049 case 0x05:
10050 GETBYTE ();
10051 switch (op[2] & 0x00)
10052 {
10053 case 0x00:
10054 op_semantics_80:
10055 {
10056 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
10057 #line 861 "rx-decode.opc"
10058 int a AU = (op[1] >> 3) & 0x01;
10059 #line 861 "rx-decode.opc"
10060 int srca AU = (op[2] >> 4) & 0x0f;
10061 #line 861 "rx-decode.opc"
10062 int srcb AU = op[2] & 0x0f;
10063 if (trace)
10064 {
10065 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10066 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
10067 op[0], op[1], op[2]);
10068 printf (" a = 0x%x,", a);
10069 printf (" srca = 0x%x,", srca);
10070 printf (" srcb = 0x%x\n", srcb);
10071 }
10072 SYNTAX("maclo %1, %2, %0");
10073 #line 861 "rx-decode.opc"
10074 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
10075
10076 }
10077 break;
10078 }
10079 break;
10080 case 0x06:
10081 GETBYTE ();
10082 switch (op[2] & 0x00)
10083 {
10084 case 0x00:
10085 op_semantics_81:
10086 {
10087 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
10088 #line 1071 "rx-decode.opc"
10089 int a AU = (op[1] >> 3) & 0x01;
10090 #line 1071 "rx-decode.opc"
10091 int srca AU = (op[2] >> 4) & 0x0f;
10092 #line 1071 "rx-decode.opc"
10093 int srcb AU = op[2] & 0x0f;
10094 if (trace)
10095 {
10096 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10097 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
10098 op[0], op[1], op[2]);
10099 printf (" a = 0x%x,", a);
10100 printf (" srca = 0x%x,", srca);
10101 printf (" srcb = 0x%x\n", srcb);
10102 }
10103 SYNTAX("maclh %1, %2, %0");
10104 #line 1071 "rx-decode.opc"
10105 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
10106
10107 }
10108 break;
10109 }
10110 break;
10111 case 0x07:
10112 GETBYTE ();
10113 switch (op[2] & 0x00)
10114 {
10115 case 0x00:
10116 op_semantics_82:
10117 {
10118 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
10119 #line 1062 "rx-decode.opc"
10120 int a AU = (op[1] >> 3) & 0x01;
10121 #line 1062 "rx-decode.opc"
10122 int srca AU = (op[2] >> 4) & 0x0f;
10123 #line 1062 "rx-decode.opc"
10124 int srcb AU = op[2] & 0x0f;
10125 if (trace)
10126 {
10127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10128 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
10129 op[0], op[1], op[2]);
10130 printf (" a = 0x%x,", a);
10131 printf (" srca = 0x%x,", srca);
10132 printf (" srcb = 0x%x\n", srcb);
10133 }
10134 SYNTAX("emaca %1, %2, %0");
10135 #line 1062 "rx-decode.opc"
10136 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
10137
10138 }
10139 break;
10140 }
10141 break;
10142 case 0x08:
10143 GETBYTE ();
10144 switch (op[2] & 0x00)
10145 {
10146 case 0x00:
10147 goto op_semantics_75;
10148 break;
10149 }
10150 break;
10151 case 0x09:
10152 GETBYTE ();
10153 switch (op[2] & 0x00)
10154 {
10155 case 0x00:
10156 goto op_semantics_76;
10157 break;
10158 }
10159 break;
10160 case 0x0a:
10161 GETBYTE ();
10162 switch (op[2] & 0x00)
10163 {
10164 case 0x00:
10165 goto op_semantics_77;
10166 break;
10167 }
10168 break;
10169 case 0x0b:
10170 GETBYTE ();
10171 switch (op[2] & 0x00)
10172 {
10173 case 0x00:
10174 goto op_semantics_78;
10175 break;
10176 }
10177 break;
10178 case 0x0c:
10179 GETBYTE ();
10180 switch (op[2] & 0x00)
10181 {
10182 case 0x00:
10183 goto op_semantics_79;
10184 break;
10185 }
10186 break;
10187 case 0x0d:
10188 GETBYTE ();
10189 switch (op[2] & 0x00)
10190 {
10191 case 0x00:
10192 goto op_semantics_80;
10193 break;
10194 }
10195 break;
10196 case 0x0e:
10197 GETBYTE ();
10198 switch (op[2] & 0x00)
10199 {
10200 case 0x00:
10201 goto op_semantics_81;
10202 break;
10203 }
10204 break;
10205 case 0x0f:
10206 GETBYTE ();
10207 switch (op[2] & 0x00)
10208 {
10209 case 0x00:
10210 goto op_semantics_82;
10211 break;
10212 }
10213 break;
10214 case 0x17:
10215 GETBYTE ();
10216 switch (op[2] & 0x70)
10217 {
10218 case 0x00:
10219 {
10220 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10221 #line 864 "rx-decode.opc"
10222 int a AU = (op[2] >> 7) & 0x01;
10223 #line 864 "rx-decode.opc"
10224 int rsrc AU = op[2] & 0x0f;
10225 if (trace)
10226 {
10227 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10228 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
10229 op[0], op[1], op[2]);
10230 printf (" a = 0x%x,", a);
10231 printf (" rsrc = 0x%x\n", rsrc);
10232 }
10233 SYNTAX("mvtachi %1, %0");
10234 #line 864 "rx-decode.opc"
10235 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10236
10237 }
10238 break;
10239 case 0x10:
10240 {
10241 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10242 #line 867 "rx-decode.opc"
10243 int a AU = (op[2] >> 7) & 0x01;
10244 #line 867 "rx-decode.opc"
10245 int rsrc AU = op[2] & 0x0f;
10246 if (trace)
10247 {
10248 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10249 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
10250 op[0], op[1], op[2]);
10251 printf (" a = 0x%x,", a);
10252 printf (" rsrc = 0x%x\n", rsrc);
10253 }
10254 SYNTAX("mvtaclo %1, %0");
10255 #line 867 "rx-decode.opc"
10256 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10257
10258 }
10259 break;
10260 case 0x30:
10261 {
10262 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10263 #line 1089 "rx-decode.opc"
10264 int a AU = (op[2] >> 7) & 0x01;
10265 #line 1089 "rx-decode.opc"
10266 int rdst AU = op[2] & 0x0f;
10267 if (trace)
10268 {
10269 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10270 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
10271 op[0], op[1], op[2]);
10272 printf (" a = 0x%x,", a);
10273 printf (" rdst = 0x%x\n", rdst);
10274 }
10275 SYNTAX("mvtacgu %0, %1");
10276 #line 1089 "rx-decode.opc"
10277 ID(mvtacgu); DR(a+32); SR(rdst); F_____;
10278
10279 }
10280 break;
10281 default: UNSUPPORTED(); break;
10282 }
10283 break;
10284 case 0x18:
10285 GETBYTE ();
10286 switch (op[2] & 0x6f)
10287 {
10288 case 0x00:
10289 {
10290 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
10291 #line 879 "rx-decode.opc"
10292 int a AU = (op[2] >> 7) & 0x01;
10293 #line 879 "rx-decode.opc"
10294 int i AU = (op[2] >> 4) & 0x01;
10295 if (trace)
10296 {
10297 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10298 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
10299 op[0], op[1], op[2]);
10300 printf (" a = 0x%x,", a);
10301 printf (" i = 0x%x\n", i);
10302 }
10303 SYNTAX("racw #%1, %0");
10304 #line 879 "rx-decode.opc"
10305 ID(racw); SC(i+1); DR(a+32); F_____;
10306
10307 /*----------------------------------------------------------------------*/
10308 /* SAT */
10309
10310 }
10311 break;
10312 case 0x40:
10313 {
10314 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
10315 #line 1098 "rx-decode.opc"
10316 int a AU = (op[2] >> 7) & 0x01;
10317 #line 1098 "rx-decode.opc"
10318 int i AU = (op[2] >> 4) & 0x01;
10319 if (trace)
10320 {
10321 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10322 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
10323 op[0], op[1], op[2]);
10324 printf (" a = 0x%x,", a);
10325 printf (" i = 0x%x\n", i);
10326 }
10327 SYNTAX("rdacw #%1, %0");
10328 #line 1098 "rx-decode.opc"
10329 ID(rdacw); SC(i+1); DR(a+32); F_____;
10330
10331 }
10332 break;
10333 default: UNSUPPORTED(); break;
10334 }
10335 break;
10336 case 0x19:
10337 GETBYTE ();
10338 switch (op[2] & 0x6f)
10339 {
10340 case 0x00:
10341 {
10342 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
10343 #line 1092 "rx-decode.opc"
10344 int a AU = (op[2] >> 7) & 0x01;
10345 #line 1092 "rx-decode.opc"
10346 int i AU = (op[2] >> 4) & 0x01;
10347 if (trace)
10348 {
10349 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10350 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
10351 op[0], op[1], op[2]);
10352 printf (" a = 0x%x,", a);
10353 printf (" i = 0x%x\n", i);
10354 }
10355 SYNTAX("racl #%1, %0");
10356 #line 1092 "rx-decode.opc"
10357 ID(racl); SC(i+1); DR(a+32); F_____;
10358
10359 }
10360 break;
10361 case 0x40:
10362 {
10363 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
10364 #line 1095 "rx-decode.opc"
10365 int a AU = (op[2] >> 7) & 0x01;
10366 #line 1095 "rx-decode.opc"
10367 int i AU = (op[2] >> 4) & 0x01;
10368 if (trace)
10369 {
10370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10371 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
10372 op[0], op[1], op[2]);
10373 printf (" a = 0x%x,", a);
10374 printf (" i = 0x%x\n", i);
10375 }
10376 SYNTAX("rdacl #%1, %0");
10377 #line 1095 "rx-decode.opc"
10378 ID(rdacl); SC(i+1); DR(a+32); F_____;
10379
10380 }
10381 break;
10382 default: UNSUPPORTED(); break;
10383 }
10384 break;
10385 case 0x1e:
10386 GETBYTE ();
10387 switch (op[2] & 0x30)
10388 {
10389 case 0x00:
10390 op_semantics_83:
10391 {
10392 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
10393 #line 870 "rx-decode.opc"
10394 int i AU = op[1] & 0x01;
10395 #line 870 "rx-decode.opc"
10396 int a AU = (op[2] >> 7) & 0x01;
10397 #line 870 "rx-decode.opc"
10398 int m AU = (op[2] >> 6) & 0x01;
10399 #line 870 "rx-decode.opc"
10400 int rdst AU = op[2] & 0x0f;
10401 if (trace)
10402 {
10403 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10404 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
10405 op[0], op[1], op[2]);
10406 printf (" i = 0x%x,", i);
10407 printf (" a = 0x%x,", a);
10408 printf (" m = 0x%x,", m);
10409 printf (" rdst = 0x%x\n", rdst);
10410 }
10411 SYNTAX("mvfachi #%2, %1, %0");
10412 #line 870 "rx-decode.opc"
10413 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10414
10415 }
10416 break;
10417 case 0x10:
10418 op_semantics_84:
10419 {
10420 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
10421 #line 876 "rx-decode.opc"
10422 int i AU = op[1] & 0x01;
10423 #line 876 "rx-decode.opc"
10424 int a AU = (op[2] >> 7) & 0x01;
10425 #line 876 "rx-decode.opc"
10426 int m AU = (op[2] >> 6) & 0x01;
10427 #line 876 "rx-decode.opc"
10428 int rdst AU = op[2] & 0x0f;
10429 if (trace)
10430 {
10431 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10432 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
10433 op[0], op[1], op[2]);
10434 printf (" i = 0x%x,", i);
10435 printf (" a = 0x%x,", a);
10436 printf (" m = 0x%x,", m);
10437 printf (" rdst = 0x%x\n", rdst);
10438 }
10439 SYNTAX("mvfaclo #%2, %1, %0");
10440 #line 876 "rx-decode.opc"
10441 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10442
10443 }
10444 break;
10445 case 0x20:
10446 op_semantics_85:
10447 {
10448 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
10449 #line 873 "rx-decode.opc"
10450 int i AU = op[1] & 0x01;
10451 #line 873 "rx-decode.opc"
10452 int a AU = (op[2] >> 7) & 0x01;
10453 #line 873 "rx-decode.opc"
10454 int m AU = (op[2] >> 6) & 0x01;
10455 #line 873 "rx-decode.opc"
10456 int rdst AU = op[2] & 0x0f;
10457 if (trace)
10458 {
10459 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10460 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
10461 op[0], op[1], op[2]);
10462 printf (" i = 0x%x,", i);
10463 printf (" a = 0x%x,", a);
10464 printf (" m = 0x%x,", m);
10465 printf (" rdst = 0x%x\n", rdst);
10466 }
10467 SYNTAX("mvfacmi #%2, %1, %0");
10468 #line 873 "rx-decode.opc"
10469 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10470
10471 }
10472 break;
10473 case 0x30:
10474 op_semantics_86:
10475 {
10476 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
10477 #line 1086 "rx-decode.opc"
10478 int i AU = op[1] & 0x01;
10479 #line 1086 "rx-decode.opc"
10480 int a AU = (op[2] >> 7) & 0x01;
10481 #line 1086 "rx-decode.opc"
10482 int m AU = (op[2] >> 6) & 0x01;
10483 #line 1086 "rx-decode.opc"
10484 int rdst AU = op[2] & 0x0f;
10485 if (trace)
10486 {
10487 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10488 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
10489 op[0], op[1], op[2]);
10490 printf (" i = 0x%x,", i);
10491 printf (" a = 0x%x,", a);
10492 printf (" m = 0x%x,", m);
10493 printf (" rdst = 0x%x\n", rdst);
10494 }
10495 SYNTAX("mvfacgu #%2, %1, %0");
10496 #line 1086 "rx-decode.opc"
10497 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10498
10499 }
10500 break;
10501 }
10502 break;
10503 case 0x1f:
10504 GETBYTE ();
10505 switch (op[2] & 0x30)
10506 {
10507 case 0x00:
10508 goto op_semantics_83;
10509 break;
10510 case 0x10:
10511 goto op_semantics_84;
10512 break;
10513 case 0x20:
10514 goto op_semantics_85;
10515 break;
10516 case 0x30:
10517 goto op_semantics_86;
10518 break;
10519 }
10520 break;
10521 case 0x20:
10522 GETBYTE ();
10523 switch (op[2] & 0x00)
10524 {
10525 case 0x00:
10526 op_semantics_87:
10527 {
10528 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
10529 #line 348 "rx-decode.opc"
10530 int p AU = (op[1] >> 2) & 0x01;
10531 #line 348 "rx-decode.opc"
10532 int sz AU = op[1] & 0x03;
10533 #line 348 "rx-decode.opc"
10534 int rdst AU = (op[2] >> 4) & 0x0f;
10535 #line 348 "rx-decode.opc"
10536 int rsrc AU = op[2] & 0x0f;
10537 if (trace)
10538 {
10539 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10540 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
10541 op[0], op[1], op[2]);
10542 printf (" p = 0x%x,", p);
10543 printf (" sz = 0x%x,", sz);
10544 printf (" rdst = 0x%x,", rdst);
10545 printf (" rsrc = 0x%x\n", rsrc);
10546 }
10547 SYNTAX("mov%s %1, %0");
10548 #line 348 "rx-decode.opc"
10549 ID(mov); sBWL (sz); SR(rsrc); F_____;
10550 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
10551
10552 }
10553 break;
10554 }
10555 break;
10556 case 0x21:
10557 GETBYTE ();
10558 switch (op[2] & 0x00)
10559 {
10560 case 0x00:
10561 goto op_semantics_87;
10562 break;
10563 }
10564 break;
10565 case 0x22:
10566 GETBYTE ();
10567 switch (op[2] & 0x00)
10568 {
10569 case 0x00:
10570 goto op_semantics_87;
10571 break;
10572 }
10573 break;
10574 case 0x24:
10575 GETBYTE ();
10576 switch (op[2] & 0x00)
10577 {
10578 case 0x00:
10579 goto op_semantics_87;
10580 break;
10581 }
10582 break;
10583 case 0x25:
10584 GETBYTE ();
10585 switch (op[2] & 0x00)
10586 {
10587 case 0x00:
10588 goto op_semantics_87;
10589 break;
10590 }
10591 break;
10592 case 0x26:
10593 GETBYTE ();
10594 switch (op[2] & 0x00)
10595 {
10596 case 0x00:
10597 goto op_semantics_87;
10598 break;
10599 }
10600 break;
10601 case 0x27:
10602 GETBYTE ();
10603 switch (op[2] & 0x00)
10604 {
10605 case 0x00:
10606 {
10607 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
10608 #line 1050 "rx-decode.opc"
10609 int rdst AU = (op[2] >> 4) & 0x0f;
10610 #line 1050 "rx-decode.opc"
10611 int rsrc AU = op[2] & 0x0f;
10612 if (trace)
10613 {
10614 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10615 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
10616 op[0], op[1], op[2]);
10617 printf (" rdst = 0x%x,", rdst);
10618 printf (" rsrc = 0x%x\n", rsrc);
10619 }
10620 SYNTAX("movco %1, [%0]");
10621 #line 1050 "rx-decode.opc"
10622 ID(movco); SR(rsrc); DR(rdst); F_____;
10623
10624 }
10625 break;
10626 }
10627 break;
10628 case 0x28:
10629 GETBYTE ();
10630 switch (op[2] & 0x00)
10631 {
10632 case 0x00:
10633 op_semantics_88:
10634 {
10635 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
10636 #line 352 "rx-decode.opc"
10637 int p AU = (op[1] >> 2) & 0x01;
10638 #line 352 "rx-decode.opc"
10639 int sz AU = op[1] & 0x03;
10640 #line 352 "rx-decode.opc"
10641 int rsrc AU = (op[2] >> 4) & 0x0f;
10642 #line 352 "rx-decode.opc"
10643 int rdst AU = op[2] & 0x0f;
10644 if (trace)
10645 {
10646 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10647 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
10648 op[0], op[1], op[2]);
10649 printf (" p = 0x%x,", p);
10650 printf (" sz = 0x%x,", sz);
10651 printf (" rsrc = 0x%x,", rsrc);
10652 printf (" rdst = 0x%x\n", rdst);
10653 }
10654 SYNTAX("mov%s %1, %0");
10655 #line 352 "rx-decode.opc"
10656 ID(mov); sBWL (sz); DR(rdst); F_____;
10657 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10658
10659 }
10660 break;
10661 }
10662 break;
10663 case 0x29:
10664 GETBYTE ();
10665 switch (op[2] & 0x00)
10666 {
10667 case 0x00:
10668 goto op_semantics_88;
10669 break;
10670 }
10671 break;
10672 case 0x2a:
10673 GETBYTE ();
10674 switch (op[2] & 0x00)
10675 {
10676 case 0x00:
10677 goto op_semantics_88;
10678 break;
10679 }
10680 break;
10681 case 0x2c:
10682 GETBYTE ();
10683 switch (op[2] & 0x00)
10684 {
10685 case 0x00:
10686 goto op_semantics_88;
10687 break;
10688 }
10689 break;
10690 case 0x2d:
10691 GETBYTE ();
10692 switch (op[2] & 0x00)
10693 {
10694 case 0x00:
10695 goto op_semantics_88;
10696 break;
10697 }
10698 break;
10699 case 0x2e:
10700 GETBYTE ();
10701 switch (op[2] & 0x00)
10702 {
10703 case 0x00:
10704 goto op_semantics_88;
10705 break;
10706 }
10707 break;
10708 case 0x2f:
10709 GETBYTE ();
10710 switch (op[2] & 0x00)
10711 {
10712 case 0x00:
10713 {
10714 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
10715 #line 1053 "rx-decode.opc"
10716 int rsrc AU = (op[2] >> 4) & 0x0f;
10717 #line 1053 "rx-decode.opc"
10718 int rdst AU = op[2] & 0x0f;
10719 if (trace)
10720 {
10721 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10722 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
10723 op[0], op[1], op[2]);
10724 printf (" rsrc = 0x%x,", rsrc);
10725 printf (" rdst = 0x%x\n", rdst);
10726 }
10727 SYNTAX("movli [%1], %0");
10728 #line 1053 "rx-decode.opc"
10729 ID(movli); SR(rsrc); DR(rdst); F_____;
10730
10731 }
10732 break;
10733 }
10734 break;
10735 case 0x38:
10736 GETBYTE ();
10737 switch (op[2] & 0x00)
10738 {
10739 case 0x00:
10740 op_semantics_89:
10741 {
10742 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
10743 #line 362 "rx-decode.opc"
10744 int p AU = (op[1] >> 2) & 0x01;
10745 #line 362 "rx-decode.opc"
10746 int sz AU = op[1] & 0x03;
10747 #line 362 "rx-decode.opc"
10748 int rsrc AU = (op[2] >> 4) & 0x0f;
10749 #line 362 "rx-decode.opc"
10750 int rdst AU = op[2] & 0x0f;
10751 if (trace)
10752 {
10753 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10754 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
10755 op[0], op[1], op[2]);
10756 printf (" p = 0x%x,", p);
10757 printf (" sz = 0x%x,", sz);
10758 printf (" rsrc = 0x%x,", rsrc);
10759 printf (" rdst = 0x%x\n", rdst);
10760 }
10761 SYNTAX("movu%s %1, %0");
10762 #line 362 "rx-decode.opc"
10763 ID(mov); uBW (sz); DR(rdst); F_____;
10764 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10765
10766 /*----------------------------------------------------------------------*/
10767 /* PUSH/POP */
10768
10769 }
10770 break;
10771 }
10772 break;
10773 case 0x39:
10774 GETBYTE ();
10775 switch (op[2] & 0x00)
10776 {
10777 case 0x00:
10778 goto op_semantics_89;
10779 break;
10780 }
10781 break;
10782 case 0x3a:
10783 GETBYTE ();
10784 switch (op[2] & 0x00)
10785 {
10786 case 0x00:
10787 goto op_semantics_89;
10788 break;
10789 }
10790 break;
10791 case 0x3c:
10792 GETBYTE ();
10793 switch (op[2] & 0x00)
10794 {
10795 case 0x00:
10796 goto op_semantics_89;
10797 break;
10798 }
10799 break;
10800 case 0x3d:
10801 GETBYTE ();
10802 switch (op[2] & 0x00)
10803 {
10804 case 0x00:
10805 goto op_semantics_89;
10806 break;
10807 }
10808 break;
10809 case 0x3e:
10810 GETBYTE ();
10811 switch (op[2] & 0x00)
10812 {
10813 case 0x00:
10814 goto op_semantics_89;
10815 break;
10816 }
10817 break;
10818 case 0x44:
10819 GETBYTE ();
10820 switch (op[2] & 0x00)
10821 {
10822 case 0x00:
10823 op_semantics_90:
10824 {
10825 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
10826 #line 1074 "rx-decode.opc"
10827 int a AU = (op[1] >> 3) & 0x01;
10828 #line 1074 "rx-decode.opc"
10829 int srca AU = (op[2] >> 4) & 0x0f;
10830 #line 1074 "rx-decode.opc"
10831 int srcb AU = op[2] & 0x0f;
10832 if (trace)
10833 {
10834 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10835 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
10836 op[0], op[1], op[2]);
10837 printf (" a = 0x%x,", a);
10838 printf (" srca = 0x%x,", srca);
10839 printf (" srcb = 0x%x\n", srcb);
10840 }
10841 SYNTAX("msbhi %1, %2, %0");
10842 #line 1074 "rx-decode.opc"
10843 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
10844
10845 }
10846 break;
10847 }
10848 break;
10849 case 0x45:
10850 GETBYTE ();
10851 switch (op[2] & 0x00)
10852 {
10853 case 0x00:
10854 op_semantics_91:
10855 {
10856 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
10857 #line 1080 "rx-decode.opc"
10858 int a AU = (op[1] >> 3) & 0x01;
10859 #line 1080 "rx-decode.opc"
10860 int srca AU = (op[2] >> 4) & 0x0f;
10861 #line 1080 "rx-decode.opc"
10862 int srcb AU = op[2] & 0x0f;
10863 if (trace)
10864 {
10865 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10866 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
10867 op[0], op[1], op[2]);
10868 printf (" a = 0x%x,", a);
10869 printf (" srca = 0x%x,", srca);
10870 printf (" srcb = 0x%x\n", srcb);
10871 }
10872 SYNTAX("msblo %1, %2, %0");
10873 #line 1080 "rx-decode.opc"
10874 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
10875
10876 }
10877 break;
10878 }
10879 break;
10880 case 0x46:
10881 GETBYTE ();
10882 switch (op[2] & 0x00)
10883 {
10884 case 0x00:
10885 op_semantics_92:
10886 {
10887 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
10888 #line 1077 "rx-decode.opc"
10889 int a AU = (op[1] >> 3) & 0x01;
10890 #line 1077 "rx-decode.opc"
10891 int srca AU = (op[2] >> 4) & 0x0f;
10892 #line 1077 "rx-decode.opc"
10893 int srcb AU = op[2] & 0x0f;
10894 if (trace)
10895 {
10896 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10897 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
10898 op[0], op[1], op[2]);
10899 printf (" a = 0x%x,", a);
10900 printf (" srca = 0x%x,", srca);
10901 printf (" srcb = 0x%x\n", srcb);
10902 }
10903 SYNTAX("msblh %1, %2, %0");
10904 #line 1077 "rx-decode.opc"
10905 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
10906
10907 }
10908 break;
10909 }
10910 break;
10911 case 0x47:
10912 GETBYTE ();
10913 switch (op[2] & 0x00)
10914 {
10915 case 0x00:
10916 op_semantics_93:
10917 {
10918 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
10919 #line 1065 "rx-decode.opc"
10920 int a AU = (op[1] >> 3) & 0x01;
10921 #line 1065 "rx-decode.opc"
10922 int srca AU = (op[2] >> 4) & 0x0f;
10923 #line 1065 "rx-decode.opc"
10924 int srcb AU = op[2] & 0x0f;
10925 if (trace)
10926 {
10927 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10928 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
10929 op[0], op[1], op[2]);
10930 printf (" a = 0x%x,", a);
10931 printf (" srca = 0x%x,", srca);
10932 printf (" srcb = 0x%x\n", srcb);
10933 }
10934 SYNTAX("emsba %1, %2, %0");
10935 #line 1065 "rx-decode.opc"
10936 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
10937
10938 }
10939 break;
10940 }
10941 break;
10942 case 0x4c:
10943 GETBYTE ();
10944 switch (op[2] & 0x00)
10945 {
10946 case 0x00:
10947 goto op_semantics_90;
10948 break;
10949 }
10950 break;
10951 case 0x4d:
10952 GETBYTE ();
10953 switch (op[2] & 0x00)
10954 {
10955 case 0x00:
10956 goto op_semantics_91;
10957 break;
10958 }
10959 break;
10960 case 0x4e:
10961 GETBYTE ();
10962 switch (op[2] & 0x00)
10963 {
10964 case 0x00:
10965 goto op_semantics_92;
10966 break;
10967 }
10968 break;
10969 case 0x4f:
10970 GETBYTE ();
10971 switch (op[2] & 0x00)
10972 {
10973 case 0x00:
10974 goto op_semantics_93;
10975 break;
10976 }
10977 break;
10978 case 0x60:
10979 GETBYTE ();
10980 switch (op[2] & 0x00)
10981 {
10982 case 0x00:
10983 {
10984 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
10985 #line 733 "rx-decode.opc"
10986 int rsrc AU = (op[2] >> 4) & 0x0f;
10987 #line 733 "rx-decode.opc"
10988 int rdst AU = op[2] & 0x0f;
10989 if (trace)
10990 {
10991 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10992 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
10993 op[0], op[1], op[2]);
10994 printf (" rsrc = 0x%x,", rsrc);
10995 printf (" rdst = 0x%x\n", rdst);
10996 }
10997 SYNTAX("shlr %2, %0");
10998 #line 733 "rx-decode.opc"
10999 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
11000
11001 }
11002 break;
11003 }
11004 break;
11005 case 0x61:
11006 GETBYTE ();
11007 switch (op[2] & 0x00)
11008 {
11009 case 0x00:
11010 {
11011 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
11012 #line 723 "rx-decode.opc"
11013 int rsrc AU = (op[2] >> 4) & 0x0f;
11014 #line 723 "rx-decode.opc"
11015 int rdst AU = op[2] & 0x0f;
11016 if (trace)
11017 {
11018 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11019 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
11020 op[0], op[1], op[2]);
11021 printf (" rsrc = 0x%x,", rsrc);
11022 printf (" rdst = 0x%x\n", rdst);
11023 }
11024 SYNTAX("shar %2, %0");
11025 #line 723 "rx-decode.opc"
11026 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
11027
11028 }
11029 break;
11030 }
11031 break;
11032 case 0x62:
11033 GETBYTE ();
11034 switch (op[2] & 0x00)
11035 {
11036 case 0x00:
11037 {
11038 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
11039 #line 713 "rx-decode.opc"
11040 int rsrc AU = (op[2] >> 4) & 0x0f;
11041 #line 713 "rx-decode.opc"
11042 int rdst AU = op[2] & 0x0f;
11043 if (trace)
11044 {
11045 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11046 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
11047 op[0], op[1], op[2]);
11048 printf (" rsrc = 0x%x,", rsrc);
11049 printf (" rdst = 0x%x\n", rdst);
11050 }
11051 SYNTAX("shll %2, %0");
11052 #line 713 "rx-decode.opc"
11053 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
11054
11055 }
11056 break;
11057 }
11058 break;
11059 case 0x64:
11060 GETBYTE ();
11061 switch (op[2] & 0x00)
11062 {
11063 case 0x00:
11064 {
11065 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
11066 #line 757 "rx-decode.opc"
11067 int rsrc AU = (op[2] >> 4) & 0x0f;
11068 #line 757 "rx-decode.opc"
11069 int rdst AU = op[2] & 0x0f;
11070 if (trace)
11071 {
11072 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11073 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
11074 op[0], op[1], op[2]);
11075 printf (" rsrc = 0x%x,", rsrc);
11076 printf (" rdst = 0x%x\n", rdst);
11077 }
11078 SYNTAX("rotr %1, %0");
11079 #line 757 "rx-decode.opc"
11080 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
11081
11082 }
11083 break;
11084 }
11085 break;
11086 case 0x65:
11087 GETBYTE ();
11088 switch (op[2] & 0x00)
11089 {
11090 case 0x00:
11091 {
11092 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
11093 #line 760 "rx-decode.opc"
11094 int rsrc AU = (op[2] >> 4) & 0x0f;
11095 #line 760 "rx-decode.opc"
11096 int rdst AU = op[2] & 0x0f;
11097 if (trace)
11098 {
11099 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11100 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
11101 op[0], op[1], op[2]);
11102 printf (" rsrc = 0x%x,", rsrc);
11103 printf (" rdst = 0x%x\n", rdst);
11104 }
11105 SYNTAX("revw %1, %0");
11106 #line 760 "rx-decode.opc"
11107 ID(revw); SR(rsrc); DR(rdst);
11108
11109 }
11110 break;
11111 }
11112 break;
11113 case 0x66:
11114 GETBYTE ();
11115 switch (op[2] & 0x00)
11116 {
11117 case 0x00:
11118 {
11119 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
11120 #line 751 "rx-decode.opc"
11121 int rsrc AU = (op[2] >> 4) & 0x0f;
11122 #line 751 "rx-decode.opc"
11123 int rdst AU = op[2] & 0x0f;
11124 if (trace)
11125 {
11126 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11127 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
11128 op[0], op[1], op[2]);
11129 printf (" rsrc = 0x%x,", rsrc);
11130 printf (" rdst = 0x%x\n", rdst);
11131 }
11132 SYNTAX("rotl %1, %0");
11133 #line 751 "rx-decode.opc"
11134 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
11135
11136 }
11137 break;
11138 }
11139 break;
11140 case 0x67:
11141 GETBYTE ();
11142 switch (op[2] & 0x00)
11143 {
11144 case 0x00:
11145 {
11146 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
11147 #line 763 "rx-decode.opc"
11148 int rsrc AU = (op[2] >> 4) & 0x0f;
11149 #line 763 "rx-decode.opc"
11150 int rdst AU = op[2] & 0x0f;
11151 if (trace)
11152 {
11153 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11154 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
11155 op[0], op[1], op[2]);
11156 printf (" rsrc = 0x%x,", rsrc);
11157 printf (" rdst = 0x%x\n", rdst);
11158 }
11159 SYNTAX("revl %1, %0");
11160 #line 763 "rx-decode.opc"
11161 ID(revl); SR(rsrc); DR(rdst);
11162
11163 /*----------------------------------------------------------------------*/
11164 /* BRANCH */
11165
11166 }
11167 break;
11168 }
11169 break;
11170 case 0x68:
11171 GETBYTE ();
11172 switch (op[2] & 0x00)
11173 {
11174 case 0x00:
11175 op_semantics_94:
11176 {
11177 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
11178 #line 1014 "rx-decode.opc"
11179 int c AU = op[1] & 0x01;
11180 #line 1014 "rx-decode.opc"
11181 int rsrc AU = (op[2] >> 4) & 0x0f;
11182 #line 1014 "rx-decode.opc"
11183 int rdst AU = op[2] & 0x0f;
11184 if (trace)
11185 {
11186 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11187 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
11188 op[0], op[1], op[2]);
11189 printf (" c = 0x%x,", c);
11190 printf (" rsrc = 0x%x,", rsrc);
11191 printf (" rdst = 0x%x\n", rdst);
11192 }
11193 SYNTAX("mvtc %1, %0");
11194 #line 1014 "rx-decode.opc"
11195 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
11196
11197 }
11198 break;
11199 }
11200 break;
11201 case 0x69:
11202 GETBYTE ();
11203 switch (op[2] & 0x00)
11204 {
11205 case 0x00:
11206 goto op_semantics_94;
11207 break;
11208 }
11209 break;
11210 case 0x6a:
11211 GETBYTE ();
11212 switch (op[2] & 0x00)
11213 {
11214 case 0x00:
11215 op_semantics_95:
11216 {
11217 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
11218 #line 1017 "rx-decode.opc"
11219 int s AU = op[1] & 0x01;
11220 #line 1017 "rx-decode.opc"
11221 int rsrc AU = (op[2] >> 4) & 0x0f;
11222 #line 1017 "rx-decode.opc"
11223 int rdst AU = op[2] & 0x0f;
11224 if (trace)
11225 {
11226 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11227 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
11228 op[0], op[1], op[2]);
11229 printf (" s = 0x%x,", s);
11230 printf (" rsrc = 0x%x,", rsrc);
11231 printf (" rdst = 0x%x\n", rdst);
11232 }
11233 SYNTAX("mvfc %1, %0");
11234 #line 1017 "rx-decode.opc"
11235 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11236
11237 /*----------------------------------------------------------------------*/
11238 /* INTERRUPTS */
11239
11240 }
11241 break;
11242 }
11243 break;
11244 case 0x6b:
11245 GETBYTE ();
11246 switch (op[2] & 0x00)
11247 {
11248 case 0x00:
11249 goto op_semantics_95;
11250 break;
11251 }
11252 break;
11253 case 0x6c:
11254 GETBYTE ();
11255 switch (op[2] & 0x00)
11256 {
11257 case 0x00:
11258 op_semantics_96:
11259 {
11260 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
11261 #line 754 "rx-decode.opc"
11262 int i AU = op[1] & 0x01;
11263 #line 754 "rx-decode.opc"
11264 int mmmm AU = (op[2] >> 4) & 0x0f;
11265 #line 754 "rx-decode.opc"
11266 int rdst AU = op[2] & 0x0f;
11267 if (trace)
11268 {
11269 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11270 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
11271 op[0], op[1], op[2]);
11272 printf (" i = 0x%x,", i);
11273 printf (" mmmm = 0x%x,", mmmm);
11274 printf (" rdst = 0x%x\n", rdst);
11275 }
11276 SYNTAX("rotr #%1, %0");
11277 #line 754 "rx-decode.opc"
11278 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11279
11280 }
11281 break;
11282 }
11283 break;
11284 case 0x6d:
11285 GETBYTE ();
11286 switch (op[2] & 0x00)
11287 {
11288 case 0x00:
11289 goto op_semantics_96;
11290 break;
11291 }
11292 break;
11293 case 0x6e:
11294 GETBYTE ();
11295 switch (op[2] & 0x00)
11296 {
11297 case 0x00:
11298 op_semantics_97:
11299 {
11300 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
11301 #line 748 "rx-decode.opc"
11302 int i AU = op[1] & 0x01;
11303 #line 748 "rx-decode.opc"
11304 int mmmm AU = (op[2] >> 4) & 0x0f;
11305 #line 748 "rx-decode.opc"
11306 int rdst AU = op[2] & 0x0f;
11307 if (trace)
11308 {
11309 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11310 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
11311 op[0], op[1], op[2]);
11312 printf (" i = 0x%x,", i);
11313 printf (" mmmm = 0x%x,", mmmm);
11314 printf (" rdst = 0x%x\n", rdst);
11315 }
11316 SYNTAX("rotl #%1, %0");
11317 #line 748 "rx-decode.opc"
11318 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11319
11320 }
11321 break;
11322 }
11323 break;
11324 case 0x6f:
11325 GETBYTE ();
11326 switch (op[2] & 0x00)
11327 {
11328 case 0x00:
11329 goto op_semantics_97;
11330 break;
11331 }
11332 break;
11333 case 0x70:
11334 GETBYTE ();
11335 switch (op[2] & 0xf0)
11336 {
11337 case 0x20:
11338 op_semantics_98:
11339 {
11340 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
11341 #line 492 "rx-decode.opc"
11342 int im AU = (op[1] >> 2) & 0x03;
11343 #line 492 "rx-decode.opc"
11344 int rdst AU = op[2] & 0x0f;
11345 if (trace)
11346 {
11347 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11348 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
11349 op[0], op[1], op[2]);
11350 printf (" im = 0x%x,", im);
11351 printf (" rdst = 0x%x\n", rdst);
11352 }
11353 SYNTAX("adc #%1, %0");
11354 #line 492 "rx-decode.opc"
11355 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11356
11357 }
11358 break;
11359 case 0x40:
11360 op_semantics_99:
11361 {
11362 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
11363 #line 574 "rx-decode.opc"
11364 int im AU = (op[1] >> 2) & 0x03;
11365 #line 574 "rx-decode.opc"
11366 int rdst AU = op[2] & 0x0f;
11367 if (trace)
11368 {
11369 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11370 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
11371 op[0], op[1], op[2]);
11372 printf (" im = 0x%x,", im);
11373 printf (" rdst = 0x%x\n", rdst);
11374 }
11375 SYNTAX("max #%1, %0");
11376 #line 574 "rx-decode.opc"
11377 int val = IMMex (im);
11378 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11379 {
11380 ID (nop7);
11381 SYNTAX("nop\t; max\t#0x80000000, r0");
11382 }
11383 else
11384 {
11385 ID(max);
11386 }
11387 DR(rdst); SC(val);
11388
11389 }
11390 break;
11391 case 0x50:
11392 op_semantics_100:
11393 {
11394 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
11395 #line 604 "rx-decode.opc"
11396 int im AU = (op[1] >> 2) & 0x03;
11397 #line 604 "rx-decode.opc"
11398 int rdst AU = op[2] & 0x0f;
11399 if (trace)
11400 {
11401 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11402 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
11403 op[0], op[1], op[2]);
11404 printf (" im = 0x%x,", im);
11405 printf (" rdst = 0x%x\n", rdst);
11406 }
11407 SYNTAX("min #%1, %0");
11408 #line 604 "rx-decode.opc"
11409 ID(min); DR(rdst); SC(IMMex(im));
11410
11411 }
11412 break;
11413 case 0x60:
11414 op_semantics_101:
11415 {
11416 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
11417 #line 662 "rx-decode.opc"
11418 int im AU = (op[1] >> 2) & 0x03;
11419 #line 662 "rx-decode.opc"
11420 int rdst AU = op[2] & 0x0f;
11421 if (trace)
11422 {
11423 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11424 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
11425 op[0], op[1], op[2]);
11426 printf (" im = 0x%x,", im);
11427 printf (" rdst = 0x%x\n", rdst);
11428 }
11429 SYNTAX("emul #%1, %0");
11430 #line 662 "rx-decode.opc"
11431 ID(emul); DR(rdst); SC(IMMex(im));
11432
11433 }
11434 break;
11435 case 0x70:
11436 op_semantics_102:
11437 {
11438 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
11439 #line 674 "rx-decode.opc"
11440 int im AU = (op[1] >> 2) & 0x03;
11441 #line 674 "rx-decode.opc"
11442 int rdst AU = op[2] & 0x0f;
11443 if (trace)
11444 {
11445 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11446 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
11447 op[0], op[1], op[2]);
11448 printf (" im = 0x%x,", im);
11449 printf (" rdst = 0x%x\n", rdst);
11450 }
11451 SYNTAX("emulu #%1, %0");
11452 #line 674 "rx-decode.opc"
11453 ID(emulu); DR(rdst); SC(IMMex(im));
11454
11455 }
11456 break;
11457 case 0x80:
11458 op_semantics_103:
11459 {
11460 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
11461 #line 686 "rx-decode.opc"
11462 int im AU = (op[1] >> 2) & 0x03;
11463 #line 686 "rx-decode.opc"
11464 int rdst AU = op[2] & 0x0f;
11465 if (trace)
11466 {
11467 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11468 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
11469 op[0], op[1], op[2]);
11470 printf (" im = 0x%x,", im);
11471 printf (" rdst = 0x%x\n", rdst);
11472 }
11473 SYNTAX("div #%1, %0");
11474 #line 686 "rx-decode.opc"
11475 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11476
11477 }
11478 break;
11479 case 0x90:
11480 op_semantics_104:
11481 {
11482 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
11483 #line 698 "rx-decode.opc"
11484 int im AU = (op[1] >> 2) & 0x03;
11485 #line 698 "rx-decode.opc"
11486 int rdst AU = op[2] & 0x0f;
11487 if (trace)
11488 {
11489 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11490 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
11491 op[0], op[1], op[2]);
11492 printf (" im = 0x%x,", im);
11493 printf (" rdst = 0x%x\n", rdst);
11494 }
11495 SYNTAX("divu #%1, %0");
11496 #line 698 "rx-decode.opc"
11497 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11498
11499 }
11500 break;
11501 case 0xc0:
11502 op_semantics_105:
11503 {
11504 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
11505 #line 471 "rx-decode.opc"
11506 int im AU = (op[1] >> 2) & 0x03;
11507 #line 471 "rx-decode.opc"
11508 int rdst AU = op[2] & 0x0f;
11509 if (trace)
11510 {
11511 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11512 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
11513 op[0], op[1], op[2]);
11514 printf (" im = 0x%x,", im);
11515 printf (" rdst = 0x%x\n", rdst);
11516 }
11517 SYNTAX("tst #%1, %2");
11518 #line 471 "rx-decode.opc"
11519 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11520
11521 }
11522 break;
11523 case 0xd0:
11524 op_semantics_106:
11525 {
11526 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
11527 #line 450 "rx-decode.opc"
11528 int im AU = (op[1] >> 2) & 0x03;
11529 #line 450 "rx-decode.opc"
11530 int rdst AU = op[2] & 0x0f;
11531 if (trace)
11532 {
11533 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11534 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
11535 op[0], op[1], op[2]);
11536 printf (" im = 0x%x,", im);
11537 printf (" rdst = 0x%x\n", rdst);
11538 }
11539 SYNTAX("xor #%1, %0");
11540 #line 450 "rx-decode.opc"
11541 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11542
11543 }
11544 break;
11545 case 0xe0:
11546 op_semantics_107:
11547 {
11548 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
11549 #line 396 "rx-decode.opc"
11550 int im AU = (op[1] >> 2) & 0x03;
11551 #line 396 "rx-decode.opc"
11552 int rdst AU = op[2] & 0x0f;
11553 if (trace)
11554 {
11555 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11556 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
11557 op[0], op[1], op[2]);
11558 printf (" im = 0x%x,", im);
11559 printf (" rdst = 0x%x\n", rdst);
11560 }
11561 SYNTAX("stz #%1, %0");
11562 #line 396 "rx-decode.opc"
11563 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11564
11565 }
11566 break;
11567 case 0xf0:
11568 op_semantics_108:
11569 {
11570 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
11571 #line 399 "rx-decode.opc"
11572 int im AU = (op[1] >> 2) & 0x03;
11573 #line 399 "rx-decode.opc"
11574 int rdst AU = op[2] & 0x0f;
11575 if (trace)
11576 {
11577 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11578 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
11579 op[0], op[1], op[2]);
11580 printf (" im = 0x%x,", im);
11581 printf (" rdst = 0x%x\n", rdst);
11582 }
11583 SYNTAX("stnz #%1, %0");
11584 #line 399 "rx-decode.opc"
11585 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11586
11587 /*----------------------------------------------------------------------*/
11588 /* RTSD */
11589
11590 }
11591 break;
11592 default: UNSUPPORTED(); break;
11593 }
11594 break;
11595 case 0x72:
11596 GETBYTE ();
11597 switch (op[2] & 0xf0)
11598 {
11599 case 0x00:
11600 {
11601 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
11602 #line 906 "rx-decode.opc"
11603 int rdst AU = op[2] & 0x0f;
11604 if (trace)
11605 {
11606 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11607 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
11608 op[0], op[1], op[2]);
11609 printf (" rdst = 0x%x\n", rdst);
11610 }
11611 SYNTAX("fsub #%1, %0");
11612 #line 906 "rx-decode.opc"
11613 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11614
11615 }
11616 break;
11617 case 0x10:
11618 {
11619 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
11620 #line 900 "rx-decode.opc"
11621 int rdst AU = op[2] & 0x0f;
11622 if (trace)
11623 {
11624 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11625 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
11626 op[0], op[1], op[2]);
11627 printf (" rdst = 0x%x\n", rdst);
11628 }
11629 SYNTAX("fcmp #%1, %0");
11630 #line 900 "rx-decode.opc"
11631 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11632
11633 }
11634 break;
11635 case 0x20:
11636 {
11637 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
11638 #line 894 "rx-decode.opc"
11639 int rdst AU = op[2] & 0x0f;
11640 if (trace)
11641 {
11642 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11643 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
11644 op[0], op[1], op[2]);
11645 printf (" rdst = 0x%x\n", rdst);
11646 }
11647 SYNTAX("fadd #%1, %0");
11648 #line 894 "rx-decode.opc"
11649 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11650
11651 }
11652 break;
11653 case 0x30:
11654 {
11655 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
11656 #line 915 "rx-decode.opc"
11657 int rdst AU = op[2] & 0x0f;
11658 if (trace)
11659 {
11660 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11661 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
11662 op[0], op[1], op[2]);
11663 printf (" rdst = 0x%x\n", rdst);
11664 }
11665 SYNTAX("fmul #%1, %0");
11666 #line 915 "rx-decode.opc"
11667 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
11668
11669 }
11670 break;
11671 case 0x40:
11672 {
11673 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
11674 #line 921 "rx-decode.opc"
11675 int rdst AU = op[2] & 0x0f;
11676 if (trace)
11677 {
11678 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11679 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
11680 op[0], op[1], op[2]);
11681 printf (" rdst = 0x%x\n", rdst);
11682 }
11683 SYNTAX("fdiv #%1, %0");
11684 #line 921 "rx-decode.opc"
11685 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
11686
11687 }
11688 break;
11689 default: UNSUPPORTED(); break;
11690 }
11691 break;
11692 case 0x73:
11693 GETBYTE ();
11694 switch (op[2] & 0xe0)
11695 {
11696 case 0x00:
11697 op_semantics_109:
11698 {
11699 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
11700 #line 1011 "rx-decode.opc"
11701 int im AU = (op[1] >> 2) & 0x03;
11702 #line 1011 "rx-decode.opc"
11703 int crdst AU = op[2] & 0x1f;
11704 if (trace)
11705 {
11706 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11707 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
11708 op[0], op[1], op[2]);
11709 printf (" im = 0x%x,", im);
11710 printf (" crdst = 0x%x\n", crdst);
11711 }
11712 SYNTAX("mvtc #%1, %0");
11713 #line 1011 "rx-decode.opc"
11714 ID(mov); SC(IMMex(im)); DR(crdst + 16);
11715
11716 }
11717 break;
11718 default: UNSUPPORTED(); break;
11719 }
11720 break;
11721 case 0x74:
11722 GETBYTE ();
11723 switch (op[2] & 0xf0)
11724 {
11725 case 0x20:
11726 goto op_semantics_98;
11727 break;
11728 case 0x40:
11729 goto op_semantics_99;
11730 break;
11731 case 0x50:
11732 goto op_semantics_100;
11733 break;
11734 case 0x60:
11735 goto op_semantics_101;
11736 break;
11737 case 0x70:
11738 goto op_semantics_102;
11739 break;
11740 case 0x80:
11741 goto op_semantics_103;
11742 break;
11743 case 0x90:
11744 goto op_semantics_104;
11745 break;
11746 case 0xc0:
11747 goto op_semantics_105;
11748 break;
11749 case 0xd0:
11750 goto op_semantics_106;
11751 break;
11752 case 0xe0:
11753 goto op_semantics_107;
11754 break;
11755 case 0xf0:
11756 goto op_semantics_108;
11757 break;
11758 default: UNSUPPORTED(); break;
11759 }
11760 break;
11761 case 0x77:
11762 GETBYTE ();
11763 switch (op[2] & 0xe0)
11764 {
11765 case 0x00:
11766 goto op_semantics_109;
11767 break;
11768 default: UNSUPPORTED(); break;
11769 }
11770 break;
11771 case 0x78:
11772 GETBYTE ();
11773 switch (op[2] & 0xf0)
11774 {
11775 case 0x20:
11776 goto op_semantics_98;
11777 break;
11778 case 0x40:
11779 goto op_semantics_99;
11780 break;
11781 case 0x50:
11782 goto op_semantics_100;
11783 break;
11784 case 0x60:
11785 goto op_semantics_101;
11786 break;
11787 case 0x70:
11788 goto op_semantics_102;
11789 break;
11790 case 0x80:
11791 goto op_semantics_103;
11792 break;
11793 case 0x90:
11794 goto op_semantics_104;
11795 break;
11796 case 0xc0:
11797 goto op_semantics_105;
11798 break;
11799 case 0xd0:
11800 goto op_semantics_106;
11801 break;
11802 case 0xe0:
11803 goto op_semantics_107;
11804 break;
11805 case 0xf0:
11806 goto op_semantics_108;
11807 break;
11808 default: UNSUPPORTED(); break;
11809 }
11810 break;
11811 case 0x7b:
11812 GETBYTE ();
11813 switch (op[2] & 0xe0)
11814 {
11815 case 0x00:
11816 goto op_semantics_109;
11817 break;
11818 default: UNSUPPORTED(); break;
11819 }
11820 break;
11821 case 0x7c:
11822 GETBYTE ();
11823 switch (op[2] & 0xf0)
11824 {
11825 case 0x20:
11826 goto op_semantics_98;
11827 break;
11828 case 0x40:
11829 goto op_semantics_99;
11830 break;
11831 case 0x50:
11832 goto op_semantics_100;
11833 break;
11834 case 0x60:
11835 goto op_semantics_101;
11836 break;
11837 case 0x70:
11838 goto op_semantics_102;
11839 break;
11840 case 0x80:
11841 goto op_semantics_103;
11842 break;
11843 case 0x90:
11844 goto op_semantics_104;
11845 break;
11846 case 0xc0:
11847 goto op_semantics_105;
11848 break;
11849 case 0xd0:
11850 goto op_semantics_106;
11851 break;
11852 case 0xe0:
11853 goto op_semantics_107;
11854 break;
11855 case 0xf0:
11856 goto op_semantics_108;
11857 break;
11858 default: UNSUPPORTED(); break;
11859 }
11860 break;
11861 case 0x7f:
11862 GETBYTE ();
11863 switch (op[2] & 0xe0)
11864 {
11865 case 0x00:
11866 goto op_semantics_109;
11867 break;
11868 default: UNSUPPORTED(); break;
11869 }
11870 break;
11871 case 0x80:
11872 GETBYTE ();
11873 switch (op[2] & 0x00)
11874 {
11875 case 0x00:
11876 op_semantics_110:
11877 {
11878 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
11879 #line 736 "rx-decode.opc"
11880 int immmm AU = op[1] & 0x1f;
11881 #line 736 "rx-decode.opc"
11882 int rsrc AU = (op[2] >> 4) & 0x0f;
11883 #line 736 "rx-decode.opc"
11884 int rdst AU = op[2] & 0x0f;
11885 if (trace)
11886 {
11887 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11888 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
11889 op[0], op[1], op[2]);
11890 printf (" immmm = 0x%x,", immmm);
11891 printf (" rsrc = 0x%x,", rsrc);
11892 printf (" rdst = 0x%x\n", rdst);
11893 }
11894 SYNTAX("shlr #%2, %1, %0");
11895 #line 736 "rx-decode.opc"
11896 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
11897
11898 /*----------------------------------------------------------------------*/
11899 /* ROTATE */
11900
11901 }
11902 break;
11903 }
11904 break;
11905 case 0x81:
11906 GETBYTE ();
11907 switch (op[2] & 0x00)
11908 {
11909 case 0x00:
11910 goto op_semantics_110;
11911 break;
11912 }
11913 break;
11914 case 0x82:
11915 GETBYTE ();
11916 switch (op[2] & 0x00)
11917 {
11918 case 0x00:
11919 goto op_semantics_110;
11920 break;
11921 }
11922 break;
11923 case 0x83:
11924 GETBYTE ();
11925 switch (op[2] & 0x00)
11926 {
11927 case 0x00:
11928 goto op_semantics_110;
11929 break;
11930 }
11931 break;
11932 case 0x84:
11933 GETBYTE ();
11934 switch (op[2] & 0x00)
11935 {
11936 case 0x00:
11937 goto op_semantics_110;
11938 break;
11939 }
11940 break;
11941 case 0x85:
11942 GETBYTE ();
11943 switch (op[2] & 0x00)
11944 {
11945 case 0x00:
11946 goto op_semantics_110;
11947 break;
11948 }
11949 break;
11950 case 0x86:
11951 GETBYTE ();
11952 switch (op[2] & 0x00)
11953 {
11954 case 0x00:
11955 goto op_semantics_110;
11956 break;
11957 }
11958 break;
11959 case 0x87:
11960 GETBYTE ();
11961 switch (op[2] & 0x00)
11962 {
11963 case 0x00:
11964 goto op_semantics_110;
11965 break;
11966 }
11967 break;
11968 case 0x88:
11969 GETBYTE ();
11970 switch (op[2] & 0x00)
11971 {
11972 case 0x00:
11973 goto op_semantics_110;
11974 break;
11975 }
11976 break;
11977 case 0x89:
11978 GETBYTE ();
11979 switch (op[2] & 0x00)
11980 {
11981 case 0x00:
11982 goto op_semantics_110;
11983 break;
11984 }
11985 break;
11986 case 0x8a:
11987 GETBYTE ();
11988 switch (op[2] & 0x00)
11989 {
11990 case 0x00:
11991 goto op_semantics_110;
11992 break;
11993 }
11994 break;
11995 case 0x8b:
11996 GETBYTE ();
11997 switch (op[2] & 0x00)
11998 {
11999 case 0x00:
12000 goto op_semantics_110;
12001 break;
12002 }
12003 break;
12004 case 0x8c:
12005 GETBYTE ();
12006 switch (op[2] & 0x00)
12007 {
12008 case 0x00:
12009 goto op_semantics_110;
12010 break;
12011 }
12012 break;
12013 case 0x8d:
12014 GETBYTE ();
12015 switch (op[2] & 0x00)
12016 {
12017 case 0x00:
12018 goto op_semantics_110;
12019 break;
12020 }
12021 break;
12022 case 0x8e:
12023 GETBYTE ();
12024 switch (op[2] & 0x00)
12025 {
12026 case 0x00:
12027 goto op_semantics_110;
12028 break;
12029 }
12030 break;
12031 case 0x8f:
12032 GETBYTE ();
12033 switch (op[2] & 0x00)
12034 {
12035 case 0x00:
12036 goto op_semantics_110;
12037 break;
12038 }
12039 break;
12040 case 0x90:
12041 GETBYTE ();
12042 switch (op[2] & 0x00)
12043 {
12044 case 0x00:
12045 goto op_semantics_110;
12046 break;
12047 }
12048 break;
12049 case 0x91:
12050 GETBYTE ();
12051 switch (op[2] & 0x00)
12052 {
12053 case 0x00:
12054 goto op_semantics_110;
12055 break;
12056 }
12057 break;
12058 case 0x92:
12059 GETBYTE ();
12060 switch (op[2] & 0x00)
12061 {
12062 case 0x00:
12063 goto op_semantics_110;
12064 break;
12065 }
12066 break;
12067 case 0x93:
12068 GETBYTE ();
12069 switch (op[2] & 0x00)
12070 {
12071 case 0x00:
12072 goto op_semantics_110;
12073 break;
12074 }
12075 break;
12076 case 0x94:
12077 GETBYTE ();
12078 switch (op[2] & 0x00)
12079 {
12080 case 0x00:
12081 goto op_semantics_110;
12082 break;
12083 }
12084 break;
12085 case 0x95:
12086 GETBYTE ();
12087 switch (op[2] & 0x00)
12088 {
12089 case 0x00:
12090 goto op_semantics_110;
12091 break;
12092 }
12093 break;
12094 case 0x96:
12095 GETBYTE ();
12096 switch (op[2] & 0x00)
12097 {
12098 case 0x00:
12099 goto op_semantics_110;
12100 break;
12101 }
12102 break;
12103 case 0x97:
12104 GETBYTE ();
12105 switch (op[2] & 0x00)
12106 {
12107 case 0x00:
12108 goto op_semantics_110;
12109 break;
12110 }
12111 break;
12112 case 0x98:
12113 GETBYTE ();
12114 switch (op[2] & 0x00)
12115 {
12116 case 0x00:
12117 goto op_semantics_110;
12118 break;
12119 }
12120 break;
12121 case 0x99:
12122 GETBYTE ();
12123 switch (op[2] & 0x00)
12124 {
12125 case 0x00:
12126 goto op_semantics_110;
12127 break;
12128 }
12129 break;
12130 case 0x9a:
12131 GETBYTE ();
12132 switch (op[2] & 0x00)
12133 {
12134 case 0x00:
12135 goto op_semantics_110;
12136 break;
12137 }
12138 break;
12139 case 0x9b:
12140 GETBYTE ();
12141 switch (op[2] & 0x00)
12142 {
12143 case 0x00:
12144 goto op_semantics_110;
12145 break;
12146 }
12147 break;
12148 case 0x9c:
12149 GETBYTE ();
12150 switch (op[2] & 0x00)
12151 {
12152 case 0x00:
12153 goto op_semantics_110;
12154 break;
12155 }
12156 break;
12157 case 0x9d:
12158 GETBYTE ();
12159 switch (op[2] & 0x00)
12160 {
12161 case 0x00:
12162 goto op_semantics_110;
12163 break;
12164 }
12165 break;
12166 case 0x9e:
12167 GETBYTE ();
12168 switch (op[2] & 0x00)
12169 {
12170 case 0x00:
12171 goto op_semantics_110;
12172 break;
12173 }
12174 break;
12175 case 0x9f:
12176 GETBYTE ();
12177 switch (op[2] & 0x00)
12178 {
12179 case 0x00:
12180 goto op_semantics_110;
12181 break;
12182 }
12183 break;
12184 case 0xa0:
12185 GETBYTE ();
12186 switch (op[2] & 0x00)
12187 {
12188 case 0x00:
12189 op_semantics_111:
12190 {
12191 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
12192 #line 726 "rx-decode.opc"
12193 int immmm AU = op[1] & 0x1f;
12194 #line 726 "rx-decode.opc"
12195 int rsrc AU = (op[2] >> 4) & 0x0f;
12196 #line 726 "rx-decode.opc"
12197 int rdst AU = op[2] & 0x0f;
12198 if (trace)
12199 {
12200 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12201 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
12202 op[0], op[1], op[2]);
12203 printf (" immmm = 0x%x,", immmm);
12204 printf (" rsrc = 0x%x,", rsrc);
12205 printf (" rdst = 0x%x\n", rdst);
12206 }
12207 SYNTAX("shar #%2, %1, %0");
12208 #line 726 "rx-decode.opc"
12209 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
12210
12211
12212 }
12213 break;
12214 }
12215 break;
12216 case 0xa1:
12217 GETBYTE ();
12218 switch (op[2] & 0x00)
12219 {
12220 case 0x00:
12221 goto op_semantics_111;
12222 break;
12223 }
12224 break;
12225 case 0xa2:
12226 GETBYTE ();
12227 switch (op[2] & 0x00)
12228 {
12229 case 0x00:
12230 goto op_semantics_111;
12231 break;
12232 }
12233 break;
12234 case 0xa3:
12235 GETBYTE ();
12236 switch (op[2] & 0x00)
12237 {
12238 case 0x00:
12239 goto op_semantics_111;
12240 break;
12241 }
12242 break;
12243 case 0xa4:
12244 GETBYTE ();
12245 switch (op[2] & 0x00)
12246 {
12247 case 0x00:
12248 goto op_semantics_111;
12249 break;
12250 }
12251 break;
12252 case 0xa5:
12253 GETBYTE ();
12254 switch (op[2] & 0x00)
12255 {
12256 case 0x00:
12257 goto op_semantics_111;
12258 break;
12259 }
12260 break;
12261 case 0xa6:
12262 GETBYTE ();
12263 switch (op[2] & 0x00)
12264 {
12265 case 0x00:
12266 goto op_semantics_111;
12267 break;
12268 }
12269 break;
12270 case 0xa7:
12271 GETBYTE ();
12272 switch (op[2] & 0x00)
12273 {
12274 case 0x00:
12275 goto op_semantics_111;
12276 break;
12277 }
12278 break;
12279 case 0xa8:
12280 GETBYTE ();
12281 switch (op[2] & 0x00)
12282 {
12283 case 0x00:
12284 goto op_semantics_111;
12285 break;
12286 }
12287 break;
12288 case 0xa9:
12289 GETBYTE ();
12290 switch (op[2] & 0x00)
12291 {
12292 case 0x00:
12293 goto op_semantics_111;
12294 break;
12295 }
12296 break;
12297 case 0xaa:
12298 GETBYTE ();
12299 switch (op[2] & 0x00)
12300 {
12301 case 0x00:
12302 goto op_semantics_111;
12303 break;
12304 }
12305 break;
12306 case 0xab:
12307 GETBYTE ();
12308 switch (op[2] & 0x00)
12309 {
12310 case 0x00:
12311 goto op_semantics_111;
12312 break;
12313 }
12314 break;
12315 case 0xac:
12316 GETBYTE ();
12317 switch (op[2] & 0x00)
12318 {
12319 case 0x00:
12320 goto op_semantics_111;
12321 break;
12322 }
12323 break;
12324 case 0xad:
12325 GETBYTE ();
12326 switch (op[2] & 0x00)
12327 {
12328 case 0x00:
12329 goto op_semantics_111;
12330 break;
12331 }
12332 break;
12333 case 0xae:
12334 GETBYTE ();
12335 switch (op[2] & 0x00)
12336 {
12337 case 0x00:
12338 goto op_semantics_111;
12339 break;
12340 }
12341 break;
12342 case 0xaf:
12343 GETBYTE ();
12344 switch (op[2] & 0x00)
12345 {
12346 case 0x00:
12347 goto op_semantics_111;
12348 break;
12349 }
12350 break;
12351 case 0xb0:
12352 GETBYTE ();
12353 switch (op[2] & 0x00)
12354 {
12355 case 0x00:
12356 goto op_semantics_111;
12357 break;
12358 }
12359 break;
12360 case 0xb1:
12361 GETBYTE ();
12362 switch (op[2] & 0x00)
12363 {
12364 case 0x00:
12365 goto op_semantics_111;
12366 break;
12367 }
12368 break;
12369 case 0xb2:
12370 GETBYTE ();
12371 switch (op[2] & 0x00)
12372 {
12373 case 0x00:
12374 goto op_semantics_111;
12375 break;
12376 }
12377 break;
12378 case 0xb3:
12379 GETBYTE ();
12380 switch (op[2] & 0x00)
12381 {
12382 case 0x00:
12383 goto op_semantics_111;
12384 break;
12385 }
12386 break;
12387 case 0xb4:
12388 GETBYTE ();
12389 switch (op[2] & 0x00)
12390 {
12391 case 0x00:
12392 goto op_semantics_111;
12393 break;
12394 }
12395 break;
12396 case 0xb5:
12397 GETBYTE ();
12398 switch (op[2] & 0x00)
12399 {
12400 case 0x00:
12401 goto op_semantics_111;
12402 break;
12403 }
12404 break;
12405 case 0xb6:
12406 GETBYTE ();
12407 switch (op[2] & 0x00)
12408 {
12409 case 0x00:
12410 goto op_semantics_111;
12411 break;
12412 }
12413 break;
12414 case 0xb7:
12415 GETBYTE ();
12416 switch (op[2] & 0x00)
12417 {
12418 case 0x00:
12419 goto op_semantics_111;
12420 break;
12421 }
12422 break;
12423 case 0xb8:
12424 GETBYTE ();
12425 switch (op[2] & 0x00)
12426 {
12427 case 0x00:
12428 goto op_semantics_111;
12429 break;
12430 }
12431 break;
12432 case 0xb9:
12433 GETBYTE ();
12434 switch (op[2] & 0x00)
12435 {
12436 case 0x00:
12437 goto op_semantics_111;
12438 break;
12439 }
12440 break;
12441 case 0xba:
12442 GETBYTE ();
12443 switch (op[2] & 0x00)
12444 {
12445 case 0x00:
12446 goto op_semantics_111;
12447 break;
12448 }
12449 break;
12450 case 0xbb:
12451 GETBYTE ();
12452 switch (op[2] & 0x00)
12453 {
12454 case 0x00:
12455 goto op_semantics_111;
12456 break;
12457 }
12458 break;
12459 case 0xbc:
12460 GETBYTE ();
12461 switch (op[2] & 0x00)
12462 {
12463 case 0x00:
12464 goto op_semantics_111;
12465 break;
12466 }
12467 break;
12468 case 0xbd:
12469 GETBYTE ();
12470 switch (op[2] & 0x00)
12471 {
12472 case 0x00:
12473 goto op_semantics_111;
12474 break;
12475 }
12476 break;
12477 case 0xbe:
12478 GETBYTE ();
12479 switch (op[2] & 0x00)
12480 {
12481 case 0x00:
12482 goto op_semantics_111;
12483 break;
12484 }
12485 break;
12486 case 0xbf:
12487 GETBYTE ();
12488 switch (op[2] & 0x00)
12489 {
12490 case 0x00:
12491 goto op_semantics_111;
12492 break;
12493 }
12494 break;
12495 case 0xc0:
12496 GETBYTE ();
12497 switch (op[2] & 0x00)
12498 {
12499 case 0x00:
12500 op_semantics_112:
12501 {
12502 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
12503 #line 716 "rx-decode.opc"
12504 int immmm AU = op[1] & 0x1f;
12505 #line 716 "rx-decode.opc"
12506 int rsrc AU = (op[2] >> 4) & 0x0f;
12507 #line 716 "rx-decode.opc"
12508 int rdst AU = op[2] & 0x0f;
12509 if (trace)
12510 {
12511 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12512 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
12513 op[0], op[1], op[2]);
12514 printf (" immmm = 0x%x,", immmm);
12515 printf (" rsrc = 0x%x,", rsrc);
12516 printf (" rdst = 0x%x\n", rdst);
12517 }
12518 SYNTAX("shll #%2, %1, %0");
12519 #line 716 "rx-decode.opc"
12520 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
12521
12522
12523 }
12524 break;
12525 }
12526 break;
12527 case 0xc1:
12528 GETBYTE ();
12529 switch (op[2] & 0x00)
12530 {
12531 case 0x00:
12532 goto op_semantics_112;
12533 break;
12534 }
12535 break;
12536 case 0xc2:
12537 GETBYTE ();
12538 switch (op[2] & 0x00)
12539 {
12540 case 0x00:
12541 goto op_semantics_112;
12542 break;
12543 }
12544 break;
12545 case 0xc3:
12546 GETBYTE ();
12547 switch (op[2] & 0x00)
12548 {
12549 case 0x00:
12550 goto op_semantics_112;
12551 break;
12552 }
12553 break;
12554 case 0xc4:
12555 GETBYTE ();
12556 switch (op[2] & 0x00)
12557 {
12558 case 0x00:
12559 goto op_semantics_112;
12560 break;
12561 }
12562 break;
12563 case 0xc5:
12564 GETBYTE ();
12565 switch (op[2] & 0x00)
12566 {
12567 case 0x00:
12568 goto op_semantics_112;
12569 break;
12570 }
12571 break;
12572 case 0xc6:
12573 GETBYTE ();
12574 switch (op[2] & 0x00)
12575 {
12576 case 0x00:
12577 goto op_semantics_112;
12578 break;
12579 }
12580 break;
12581 case 0xc7:
12582 GETBYTE ();
12583 switch (op[2] & 0x00)
12584 {
12585 case 0x00:
12586 goto op_semantics_112;
12587 break;
12588 }
12589 break;
12590 case 0xc8:
12591 GETBYTE ();
12592 switch (op[2] & 0x00)
12593 {
12594 case 0x00:
12595 goto op_semantics_112;
12596 break;
12597 }
12598 break;
12599 case 0xc9:
12600 GETBYTE ();
12601 switch (op[2] & 0x00)
12602 {
12603 case 0x00:
12604 goto op_semantics_112;
12605 break;
12606 }
12607 break;
12608 case 0xca:
12609 GETBYTE ();
12610 switch (op[2] & 0x00)
12611 {
12612 case 0x00:
12613 goto op_semantics_112;
12614 break;
12615 }
12616 break;
12617 case 0xcb:
12618 GETBYTE ();
12619 switch (op[2] & 0x00)
12620 {
12621 case 0x00:
12622 goto op_semantics_112;
12623 break;
12624 }
12625 break;
12626 case 0xcc:
12627 GETBYTE ();
12628 switch (op[2] & 0x00)
12629 {
12630 case 0x00:
12631 goto op_semantics_112;
12632 break;
12633 }
12634 break;
12635 case 0xcd:
12636 GETBYTE ();
12637 switch (op[2] & 0x00)
12638 {
12639 case 0x00:
12640 goto op_semantics_112;
12641 break;
12642 }
12643 break;
12644 case 0xce:
12645 GETBYTE ();
12646 switch (op[2] & 0x00)
12647 {
12648 case 0x00:
12649 goto op_semantics_112;
12650 break;
12651 }
12652 break;
12653 case 0xcf:
12654 GETBYTE ();
12655 switch (op[2] & 0x00)
12656 {
12657 case 0x00:
12658 goto op_semantics_112;
12659 break;
12660 }
12661 break;
12662 case 0xd0:
12663 GETBYTE ();
12664 switch (op[2] & 0x00)
12665 {
12666 case 0x00:
12667 goto op_semantics_112;
12668 break;
12669 }
12670 break;
12671 case 0xd1:
12672 GETBYTE ();
12673 switch (op[2] & 0x00)
12674 {
12675 case 0x00:
12676 goto op_semantics_112;
12677 break;
12678 }
12679 break;
12680 case 0xd2:
12681 GETBYTE ();
12682 switch (op[2] & 0x00)
12683 {
12684 case 0x00:
12685 goto op_semantics_112;
12686 break;
12687 }
12688 break;
12689 case 0xd3:
12690 GETBYTE ();
12691 switch (op[2] & 0x00)
12692 {
12693 case 0x00:
12694 goto op_semantics_112;
12695 break;
12696 }
12697 break;
12698 case 0xd4:
12699 GETBYTE ();
12700 switch (op[2] & 0x00)
12701 {
12702 case 0x00:
12703 goto op_semantics_112;
12704 break;
12705 }
12706 break;
12707 case 0xd5:
12708 GETBYTE ();
12709 switch (op[2] & 0x00)
12710 {
12711 case 0x00:
12712 goto op_semantics_112;
12713 break;
12714 }
12715 break;
12716 case 0xd6:
12717 GETBYTE ();
12718 switch (op[2] & 0x00)
12719 {
12720 case 0x00:
12721 goto op_semantics_112;
12722 break;
12723 }
12724 break;
12725 case 0xd7:
12726 GETBYTE ();
12727 switch (op[2] & 0x00)
12728 {
12729 case 0x00:
12730 goto op_semantics_112;
12731 break;
12732 }
12733 break;
12734 case 0xd8:
12735 GETBYTE ();
12736 switch (op[2] & 0x00)
12737 {
12738 case 0x00:
12739 goto op_semantics_112;
12740 break;
12741 }
12742 break;
12743 case 0xd9:
12744 GETBYTE ();
12745 switch (op[2] & 0x00)
12746 {
12747 case 0x00:
12748 goto op_semantics_112;
12749 break;
12750 }
12751 break;
12752 case 0xda:
12753 GETBYTE ();
12754 switch (op[2] & 0x00)
12755 {
12756 case 0x00:
12757 goto op_semantics_112;
12758 break;
12759 }
12760 break;
12761 case 0xdb:
12762 GETBYTE ();
12763 switch (op[2] & 0x00)
12764 {
12765 case 0x00:
12766 goto op_semantics_112;
12767 break;
12768 }
12769 break;
12770 case 0xdc:
12771 GETBYTE ();
12772 switch (op[2] & 0x00)
12773 {
12774 case 0x00:
12775 goto op_semantics_112;
12776 break;
12777 }
12778 break;
12779 case 0xdd:
12780 GETBYTE ();
12781 switch (op[2] & 0x00)
12782 {
12783 case 0x00:
12784 goto op_semantics_112;
12785 break;
12786 }
12787 break;
12788 case 0xde:
12789 GETBYTE ();
12790 switch (op[2] & 0x00)
12791 {
12792 case 0x00:
12793 goto op_semantics_112;
12794 break;
12795 }
12796 break;
12797 case 0xdf:
12798 GETBYTE ();
12799 switch (op[2] & 0x00)
12800 {
12801 case 0x00:
12802 goto op_semantics_112;
12803 break;
12804 }
12805 break;
12806 case 0xe0:
12807 GETBYTE ();
12808 switch (op[2] & 0xf0)
12809 {
12810 case 0x00:
12811 case 0x10:
12812 case 0x20:
12813 case 0x30:
12814 case 0x40:
12815 case 0x50:
12816 case 0x60:
12817 case 0x70:
12818 case 0x80:
12819 case 0x90:
12820 case 0xa0:
12821 case 0xb0:
12822 case 0xc0:
12823 case 0xd0:
12824 case 0xe0:
12825 op_semantics_113:
12826 {
12827 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
12828 #line 990 "rx-decode.opc"
12829 int bittt AU = op[1] & 0x1f;
12830 #line 990 "rx-decode.opc"
12831 int cond AU = (op[2] >> 4) & 0x0f;
12832 #line 990 "rx-decode.opc"
12833 int rdst AU = op[2] & 0x0f;
12834 if (trace)
12835 {
12836 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12837 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
12838 op[0], op[1], op[2]);
12839 printf (" bittt = 0x%x,", bittt);
12840 printf (" cond = 0x%x,", cond);
12841 printf (" rdst = 0x%x\n", rdst);
12842 }
12843 SYNTAX("bm%2 #%1, %0%S0");
12844 #line 990 "rx-decode.opc"
12845 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12846
12847 /*----------------------------------------------------------------------*/
12848 /* CONTROL REGISTERS */
12849
12850 }
12851 break;
12852 case 0xf0:
12853 op_semantics_114:
12854 {
12855 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
12856 #line 983 "rx-decode.opc"
12857 int bittt AU = op[1] & 0x1f;
12858 #line 983 "rx-decode.opc"
12859 int rdst AU = op[2] & 0x0f;
12860 if (trace)
12861 {
12862 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12863 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
12864 op[0], op[1], op[2]);
12865 printf (" bittt = 0x%x,", bittt);
12866 printf (" rdst = 0x%x\n", rdst);
12867 }
12868 SYNTAX("bnot #%1, %0");
12869 #line 983 "rx-decode.opc"
12870 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12871
12872
12873 }
12874 break;
12875 }
12876 break;
12877 case 0xe1:
12878 GETBYTE ();
12879 switch (op[2] & 0xf0)
12880 {
12881 case 0x00:
12882 case 0x10:
12883 case 0x20:
12884 case 0x30:
12885 case 0x40:
12886 case 0x50:
12887 case 0x60:
12888 case 0x70:
12889 case 0x80:
12890 case 0x90:
12891 case 0xa0:
12892 case 0xb0:
12893 case 0xc0:
12894 case 0xd0:
12895 case 0xe0:
12896 goto op_semantics_113;
12897 break;
12898 case 0xf0:
12899 goto op_semantics_114;
12900 break;
12901 }
12902 break;
12903 case 0xe2:
12904 GETBYTE ();
12905 switch (op[2] & 0xf0)
12906 {
12907 case 0x00:
12908 case 0x10:
12909 case 0x20:
12910 case 0x30:
12911 case 0x40:
12912 case 0x50:
12913 case 0x60:
12914 case 0x70:
12915 case 0x80:
12916 case 0x90:
12917 case 0xa0:
12918 case 0xb0:
12919 case 0xc0:
12920 case 0xd0:
12921 case 0xe0:
12922 goto op_semantics_113;
12923 break;
12924 case 0xf0:
12925 goto op_semantics_114;
12926 break;
12927 }
12928 break;
12929 case 0xe3:
12930 GETBYTE ();
12931 switch (op[2] & 0xf0)
12932 {
12933 case 0x00:
12934 case 0x10:
12935 case 0x20:
12936 case 0x30:
12937 case 0x40:
12938 case 0x50:
12939 case 0x60:
12940 case 0x70:
12941 case 0x80:
12942 case 0x90:
12943 case 0xa0:
12944 case 0xb0:
12945 case 0xc0:
12946 case 0xd0:
12947 case 0xe0:
12948 goto op_semantics_113;
12949 break;
12950 case 0xf0:
12951 goto op_semantics_114;
12952 break;
12953 }
12954 break;
12955 case 0xe4:
12956 GETBYTE ();
12957 switch (op[2] & 0xf0)
12958 {
12959 case 0x00:
12960 case 0x10:
12961 case 0x20:
12962 case 0x30:
12963 case 0x40:
12964 case 0x50:
12965 case 0x60:
12966 case 0x70:
12967 case 0x80:
12968 case 0x90:
12969 case 0xa0:
12970 case 0xb0:
12971 case 0xc0:
12972 case 0xd0:
12973 case 0xe0:
12974 goto op_semantics_113;
12975 break;
12976 case 0xf0:
12977 goto op_semantics_114;
12978 break;
12979 }
12980 break;
12981 case 0xe5:
12982 GETBYTE ();
12983 switch (op[2] & 0xf0)
12984 {
12985 case 0x00:
12986 case 0x10:
12987 case 0x20:
12988 case 0x30:
12989 case 0x40:
12990 case 0x50:
12991 case 0x60:
12992 case 0x70:
12993 case 0x80:
12994 case 0x90:
12995 case 0xa0:
12996 case 0xb0:
12997 case 0xc0:
12998 case 0xd0:
12999 case 0xe0:
13000 goto op_semantics_113;
13001 break;
13002 case 0xf0:
13003 goto op_semantics_114;
13004 break;
13005 }
13006 break;
13007 case 0xe6:
13008 GETBYTE ();
13009 switch (op[2] & 0xf0)
13010 {
13011 case 0x00:
13012 case 0x10:
13013 case 0x20:
13014 case 0x30:
13015 case 0x40:
13016 case 0x50:
13017 case 0x60:
13018 case 0x70:
13019 case 0x80:
13020 case 0x90:
13021 case 0xa0:
13022 case 0xb0:
13023 case 0xc0:
13024 case 0xd0:
13025 case 0xe0:
13026 goto op_semantics_113;
13027 break;
13028 case 0xf0:
13029 goto op_semantics_114;
13030 break;
13031 }
13032 break;
13033 case 0xe7:
13034 GETBYTE ();
13035 switch (op[2] & 0xf0)
13036 {
13037 case 0x00:
13038 case 0x10:
13039 case 0x20:
13040 case 0x30:
13041 case 0x40:
13042 case 0x50:
13043 case 0x60:
13044 case 0x70:
13045 case 0x80:
13046 case 0x90:
13047 case 0xa0:
13048 case 0xb0:
13049 case 0xc0:
13050 case 0xd0:
13051 case 0xe0:
13052 goto op_semantics_113;
13053 break;
13054 case 0xf0:
13055 goto op_semantics_114;
13056 break;
13057 }
13058 break;
13059 case 0xe8:
13060 GETBYTE ();
13061 switch (op[2] & 0xf0)
13062 {
13063 case 0x00:
13064 case 0x10:
13065 case 0x20:
13066 case 0x30:
13067 case 0x40:
13068 case 0x50:
13069 case 0x60:
13070 case 0x70:
13071 case 0x80:
13072 case 0x90:
13073 case 0xa0:
13074 case 0xb0:
13075 case 0xc0:
13076 case 0xd0:
13077 case 0xe0:
13078 goto op_semantics_113;
13079 break;
13080 case 0xf0:
13081 goto op_semantics_114;
13082 break;
13083 }
13084 break;
13085 case 0xe9:
13086 GETBYTE ();
13087 switch (op[2] & 0xf0)
13088 {
13089 case 0x00:
13090 case 0x10:
13091 case 0x20:
13092 case 0x30:
13093 case 0x40:
13094 case 0x50:
13095 case 0x60:
13096 case 0x70:
13097 case 0x80:
13098 case 0x90:
13099 case 0xa0:
13100 case 0xb0:
13101 case 0xc0:
13102 case 0xd0:
13103 case 0xe0:
13104 goto op_semantics_113;
13105 break;
13106 case 0xf0:
13107 goto op_semantics_114;
13108 break;
13109 }
13110 break;
13111 case 0xea:
13112 GETBYTE ();
13113 switch (op[2] & 0xf0)
13114 {
13115 case 0x00:
13116 case 0x10:
13117 case 0x20:
13118 case 0x30:
13119 case 0x40:
13120 case 0x50:
13121 case 0x60:
13122 case 0x70:
13123 case 0x80:
13124 case 0x90:
13125 case 0xa0:
13126 case 0xb0:
13127 case 0xc0:
13128 case 0xd0:
13129 case 0xe0:
13130 goto op_semantics_113;
13131 break;
13132 case 0xf0:
13133 goto op_semantics_114;
13134 break;
13135 }
13136 break;
13137 case 0xeb:
13138 GETBYTE ();
13139 switch (op[2] & 0xf0)
13140 {
13141 case 0x00:
13142 case 0x10:
13143 case 0x20:
13144 case 0x30:
13145 case 0x40:
13146 case 0x50:
13147 case 0x60:
13148 case 0x70:
13149 case 0x80:
13150 case 0x90:
13151 case 0xa0:
13152 case 0xb0:
13153 case 0xc0:
13154 case 0xd0:
13155 case 0xe0:
13156 goto op_semantics_113;
13157 break;
13158 case 0xf0:
13159 goto op_semantics_114;
13160 break;
13161 }
13162 break;
13163 case 0xec:
13164 GETBYTE ();
13165 switch (op[2] & 0xf0)
13166 {
13167 case 0x00:
13168 case 0x10:
13169 case 0x20:
13170 case 0x30:
13171 case 0x40:
13172 case 0x50:
13173 case 0x60:
13174 case 0x70:
13175 case 0x80:
13176 case 0x90:
13177 case 0xa0:
13178 case 0xb0:
13179 case 0xc0:
13180 case 0xd0:
13181 case 0xe0:
13182 goto op_semantics_113;
13183 break;
13184 case 0xf0:
13185 goto op_semantics_114;
13186 break;
13187 }
13188 break;
13189 case 0xed:
13190 GETBYTE ();
13191 switch (op[2] & 0xf0)
13192 {
13193 case 0x00:
13194 case 0x10:
13195 case 0x20:
13196 case 0x30:
13197 case 0x40:
13198 case 0x50:
13199 case 0x60:
13200 case 0x70:
13201 case 0x80:
13202 case 0x90:
13203 case 0xa0:
13204 case 0xb0:
13205 case 0xc0:
13206 case 0xd0:
13207 case 0xe0:
13208 goto op_semantics_113;
13209 break;
13210 case 0xf0:
13211 goto op_semantics_114;
13212 break;
13213 }
13214 break;
13215 case 0xee:
13216 GETBYTE ();
13217 switch (op[2] & 0xf0)
13218 {
13219 case 0x00:
13220 case 0x10:
13221 case 0x20:
13222 case 0x30:
13223 case 0x40:
13224 case 0x50:
13225 case 0x60:
13226 case 0x70:
13227 case 0x80:
13228 case 0x90:
13229 case 0xa0:
13230 case 0xb0:
13231 case 0xc0:
13232 case 0xd0:
13233 case 0xe0:
13234 goto op_semantics_113;
13235 break;
13236 case 0xf0:
13237 goto op_semantics_114;
13238 break;
13239 }
13240 break;
13241 case 0xef:
13242 GETBYTE ();
13243 switch (op[2] & 0xf0)
13244 {
13245 case 0x00:
13246 case 0x10:
13247 case 0x20:
13248 case 0x30:
13249 case 0x40:
13250 case 0x50:
13251 case 0x60:
13252 case 0x70:
13253 case 0x80:
13254 case 0x90:
13255 case 0xa0:
13256 case 0xb0:
13257 case 0xc0:
13258 case 0xd0:
13259 case 0xe0:
13260 goto op_semantics_113;
13261 break;
13262 case 0xf0:
13263 goto op_semantics_114;
13264 break;
13265 }
13266 break;
13267 case 0xf0:
13268 GETBYTE ();
13269 switch (op[2] & 0xf0)
13270 {
13271 case 0x00:
13272 case 0x10:
13273 case 0x20:
13274 case 0x30:
13275 case 0x40:
13276 case 0x50:
13277 case 0x60:
13278 case 0x70:
13279 case 0x80:
13280 case 0x90:
13281 case 0xa0:
13282 case 0xb0:
13283 case 0xc0:
13284 case 0xd0:
13285 case 0xe0:
13286 goto op_semantics_113;
13287 break;
13288 case 0xf0:
13289 goto op_semantics_114;
13290 break;
13291 }
13292 break;
13293 case 0xf1:
13294 GETBYTE ();
13295 switch (op[2] & 0xf0)
13296 {
13297 case 0x00:
13298 case 0x10:
13299 case 0x20:
13300 case 0x30:
13301 case 0x40:
13302 case 0x50:
13303 case 0x60:
13304 case 0x70:
13305 case 0x80:
13306 case 0x90:
13307 case 0xa0:
13308 case 0xb0:
13309 case 0xc0:
13310 case 0xd0:
13311 case 0xe0:
13312 goto op_semantics_113;
13313 break;
13314 case 0xf0:
13315 goto op_semantics_114;
13316 break;
13317 }
13318 break;
13319 case 0xf2:
13320 GETBYTE ();
13321 switch (op[2] & 0xf0)
13322 {
13323 case 0x00:
13324 case 0x10:
13325 case 0x20:
13326 case 0x30:
13327 case 0x40:
13328 case 0x50:
13329 case 0x60:
13330 case 0x70:
13331 case 0x80:
13332 case 0x90:
13333 case 0xa0:
13334 case 0xb0:
13335 case 0xc0:
13336 case 0xd0:
13337 case 0xe0:
13338 goto op_semantics_113;
13339 break;
13340 case 0xf0:
13341 goto op_semantics_114;
13342 break;
13343 }
13344 break;
13345 case 0xf3:
13346 GETBYTE ();
13347 switch (op[2] & 0xf0)
13348 {
13349 case 0x00:
13350 case 0x10:
13351 case 0x20:
13352 case 0x30:
13353 case 0x40:
13354 case 0x50:
13355 case 0x60:
13356 case 0x70:
13357 case 0x80:
13358 case 0x90:
13359 case 0xa0:
13360 case 0xb0:
13361 case 0xc0:
13362 case 0xd0:
13363 case 0xe0:
13364 goto op_semantics_113;
13365 break;
13366 case 0xf0:
13367 goto op_semantics_114;
13368 break;
13369 }
13370 break;
13371 case 0xf4:
13372 GETBYTE ();
13373 switch (op[2] & 0xf0)
13374 {
13375 case 0x00:
13376 case 0x10:
13377 case 0x20:
13378 case 0x30:
13379 case 0x40:
13380 case 0x50:
13381 case 0x60:
13382 case 0x70:
13383 case 0x80:
13384 case 0x90:
13385 case 0xa0:
13386 case 0xb0:
13387 case 0xc0:
13388 case 0xd0:
13389 case 0xe0:
13390 goto op_semantics_113;
13391 break;
13392 case 0xf0:
13393 goto op_semantics_114;
13394 break;
13395 }
13396 break;
13397 case 0xf5:
13398 GETBYTE ();
13399 switch (op[2] & 0xf0)
13400 {
13401 case 0x00:
13402 case 0x10:
13403 case 0x20:
13404 case 0x30:
13405 case 0x40:
13406 case 0x50:
13407 case 0x60:
13408 case 0x70:
13409 case 0x80:
13410 case 0x90:
13411 case 0xa0:
13412 case 0xb0:
13413 case 0xc0:
13414 case 0xd0:
13415 case 0xe0:
13416 goto op_semantics_113;
13417 break;
13418 case 0xf0:
13419 goto op_semantics_114;
13420 break;
13421 }
13422 break;
13423 case 0xf6:
13424 GETBYTE ();
13425 switch (op[2] & 0xf0)
13426 {
13427 case 0x00:
13428 case 0x10:
13429 case 0x20:
13430 case 0x30:
13431 case 0x40:
13432 case 0x50:
13433 case 0x60:
13434 case 0x70:
13435 case 0x80:
13436 case 0x90:
13437 case 0xa0:
13438 case 0xb0:
13439 case 0xc0:
13440 case 0xd0:
13441 case 0xe0:
13442 goto op_semantics_113;
13443 break;
13444 case 0xf0:
13445 goto op_semantics_114;
13446 break;
13447 }
13448 break;
13449 case 0xf7:
13450 GETBYTE ();
13451 switch (op[2] & 0xf0)
13452 {
13453 case 0x00:
13454 case 0x10:
13455 case 0x20:
13456 case 0x30:
13457 case 0x40:
13458 case 0x50:
13459 case 0x60:
13460 case 0x70:
13461 case 0x80:
13462 case 0x90:
13463 case 0xa0:
13464 case 0xb0:
13465 case 0xc0:
13466 case 0xd0:
13467 case 0xe0:
13468 goto op_semantics_113;
13469 break;
13470 case 0xf0:
13471 goto op_semantics_114;
13472 break;
13473 }
13474 break;
13475 case 0xf8:
13476 GETBYTE ();
13477 switch (op[2] & 0xf0)
13478 {
13479 case 0x00:
13480 case 0x10:
13481 case 0x20:
13482 case 0x30:
13483 case 0x40:
13484 case 0x50:
13485 case 0x60:
13486 case 0x70:
13487 case 0x80:
13488 case 0x90:
13489 case 0xa0:
13490 case 0xb0:
13491 case 0xc0:
13492 case 0xd0:
13493 case 0xe0:
13494 goto op_semantics_113;
13495 break;
13496 case 0xf0:
13497 goto op_semantics_114;
13498 break;
13499 }
13500 break;
13501 case 0xf9:
13502 GETBYTE ();
13503 switch (op[2] & 0xf0)
13504 {
13505 case 0x00:
13506 case 0x10:
13507 case 0x20:
13508 case 0x30:
13509 case 0x40:
13510 case 0x50:
13511 case 0x60:
13512 case 0x70:
13513 case 0x80:
13514 case 0x90:
13515 case 0xa0:
13516 case 0xb0:
13517 case 0xc0:
13518 case 0xd0:
13519 case 0xe0:
13520 goto op_semantics_113;
13521 break;
13522 case 0xf0:
13523 goto op_semantics_114;
13524 break;
13525 }
13526 break;
13527 case 0xfa:
13528 GETBYTE ();
13529 switch (op[2] & 0xf0)
13530 {
13531 case 0x00:
13532 case 0x10:
13533 case 0x20:
13534 case 0x30:
13535 case 0x40:
13536 case 0x50:
13537 case 0x60:
13538 case 0x70:
13539 case 0x80:
13540 case 0x90:
13541 case 0xa0:
13542 case 0xb0:
13543 case 0xc0:
13544 case 0xd0:
13545 case 0xe0:
13546 goto op_semantics_113;
13547 break;
13548 case 0xf0:
13549 goto op_semantics_114;
13550 break;
13551 }
13552 break;
13553 case 0xfb:
13554 GETBYTE ();
13555 switch (op[2] & 0xf0)
13556 {
13557 case 0x00:
13558 case 0x10:
13559 case 0x20:
13560 case 0x30:
13561 case 0x40:
13562 case 0x50:
13563 case 0x60:
13564 case 0x70:
13565 case 0x80:
13566 case 0x90:
13567 case 0xa0:
13568 case 0xb0:
13569 case 0xc0:
13570 case 0xd0:
13571 case 0xe0:
13572 goto op_semantics_113;
13573 break;
13574 case 0xf0:
13575 goto op_semantics_114;
13576 break;
13577 }
13578 break;
13579 case 0xfc:
13580 GETBYTE ();
13581 switch (op[2] & 0xf0)
13582 {
13583 case 0x00:
13584 case 0x10:
13585 case 0x20:
13586 case 0x30:
13587 case 0x40:
13588 case 0x50:
13589 case 0x60:
13590 case 0x70:
13591 case 0x80:
13592 case 0x90:
13593 case 0xa0:
13594 case 0xb0:
13595 case 0xc0:
13596 case 0xd0:
13597 case 0xe0:
13598 goto op_semantics_113;
13599 break;
13600 case 0xf0:
13601 goto op_semantics_114;
13602 break;
13603 }
13604 break;
13605 case 0xfd:
13606 GETBYTE ();
13607 switch (op[2] & 0xf0)
13608 {
13609 case 0x00:
13610 case 0x10:
13611 case 0x20:
13612 case 0x30:
13613 case 0x40:
13614 case 0x50:
13615 case 0x60:
13616 case 0x70:
13617 case 0x80:
13618 case 0x90:
13619 case 0xa0:
13620 case 0xb0:
13621 case 0xc0:
13622 case 0xd0:
13623 case 0xe0:
13624 goto op_semantics_113;
13625 break;
13626 case 0xf0:
13627 goto op_semantics_114;
13628 break;
13629 }
13630 break;
13631 case 0xfe:
13632 GETBYTE ();
13633 switch (op[2] & 0xf0)
13634 {
13635 case 0x00:
13636 case 0x10:
13637 case 0x20:
13638 case 0x30:
13639 case 0x40:
13640 case 0x50:
13641 case 0x60:
13642 case 0x70:
13643 case 0x80:
13644 case 0x90:
13645 case 0xa0:
13646 case 0xb0:
13647 case 0xc0:
13648 case 0xd0:
13649 case 0xe0:
13650 goto op_semantics_113;
13651 break;
13652 case 0xf0:
13653 goto op_semantics_114;
13654 break;
13655 }
13656 break;
13657 case 0xff:
13658 GETBYTE ();
13659 switch (op[2] & 0xf0)
13660 {
13661 case 0x00:
13662 case 0x10:
13663 case 0x20:
13664 case 0x30:
13665 case 0x40:
13666 case 0x50:
13667 case 0x60:
13668 case 0x70:
13669 case 0x80:
13670 case 0x90:
13671 case 0xa0:
13672 case 0xb0:
13673 case 0xc0:
13674 case 0xd0:
13675 case 0xe0:
13676 goto op_semantics_113;
13677 break;
13678 case 0xf0:
13679 goto op_semantics_114;
13680 break;
13681 }
13682 break;
13683 default: UNSUPPORTED(); break;
13684 }
13685 break;
13686 case 0xfe:
13687 GETBYTE ();
13688 switch (op[1] & 0xff)
13689 {
13690 case 0x00:
13691 GETBYTE ();
13692 switch (op[2] & 0x00)
13693 {
13694 case 0x00:
13695 op_semantics_115:
13696 {
13697 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
13698 #line 342 "rx-decode.opc"
13699 int sz AU = (op[1] >> 4) & 0x03;
13700 #line 342 "rx-decode.opc"
13701 int isrc AU = op[1] & 0x0f;
13702 #line 342 "rx-decode.opc"
13703 int bsrc AU = (op[2] >> 4) & 0x0f;
13704 #line 342 "rx-decode.opc"
13705 int rdst AU = op[2] & 0x0f;
13706 if (trace)
13707 {
13708 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13709 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
13710 op[0], op[1], op[2]);
13711 printf (" sz = 0x%x,", sz);
13712 printf (" isrc = 0x%x,", isrc);
13713 printf (" bsrc = 0x%x,", bsrc);
13714 printf (" rdst = 0x%x\n", rdst);
13715 }
13716 SYNTAX("mov%s %0, [%1, %2]");
13717 #line 342 "rx-decode.opc"
13718 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13719
13720 }
13721 break;
13722 }
13723 break;
13724 case 0x01:
13725 GETBYTE ();
13726 switch (op[2] & 0x00)
13727 {
13728 case 0x00:
13729 goto op_semantics_115;
13730 break;
13731 }
13732 break;
13733 case 0x02:
13734 GETBYTE ();
13735 switch (op[2] & 0x00)
13736 {
13737 case 0x00:
13738 goto op_semantics_115;
13739 break;
13740 }
13741 break;
13742 case 0x03:
13743 GETBYTE ();
13744 switch (op[2] & 0x00)
13745 {
13746 case 0x00:
13747 goto op_semantics_115;
13748 break;
13749 }
13750 break;
13751 case 0x04:
13752 GETBYTE ();
13753 switch (op[2] & 0x00)
13754 {
13755 case 0x00:
13756 goto op_semantics_115;
13757 break;
13758 }
13759 break;
13760 case 0x05:
13761 GETBYTE ();
13762 switch (op[2] & 0x00)
13763 {
13764 case 0x00:
13765 goto op_semantics_115;
13766 break;
13767 }
13768 break;
13769 case 0x06:
13770 GETBYTE ();
13771 switch (op[2] & 0x00)
13772 {
13773 case 0x00:
13774 goto op_semantics_115;
13775 break;
13776 }
13777 break;
13778 case 0x07:
13779 GETBYTE ();
13780 switch (op[2] & 0x00)
13781 {
13782 case 0x00:
13783 goto op_semantics_115;
13784 break;
13785 }
13786 break;
13787 case 0x08:
13788 GETBYTE ();
13789 switch (op[2] & 0x00)
13790 {
13791 case 0x00:
13792 goto op_semantics_115;
13793 break;
13794 }
13795 break;
13796 case 0x09:
13797 GETBYTE ();
13798 switch (op[2] & 0x00)
13799 {
13800 case 0x00:
13801 goto op_semantics_115;
13802 break;
13803 }
13804 break;
13805 case 0x0a:
13806 GETBYTE ();
13807 switch (op[2] & 0x00)
13808 {
13809 case 0x00:
13810 goto op_semantics_115;
13811 break;
13812 }
13813 break;
13814 case 0x0b:
13815 GETBYTE ();
13816 switch (op[2] & 0x00)
13817 {
13818 case 0x00:
13819 goto op_semantics_115;
13820 break;
13821 }
13822 break;
13823 case 0x0c:
13824 GETBYTE ();
13825 switch (op[2] & 0x00)
13826 {
13827 case 0x00:
13828 goto op_semantics_115;
13829 break;
13830 }
13831 break;
13832 case 0x0d:
13833 GETBYTE ();
13834 switch (op[2] & 0x00)
13835 {
13836 case 0x00:
13837 goto op_semantics_115;
13838 break;
13839 }
13840 break;
13841 case 0x0e:
13842 GETBYTE ();
13843 switch (op[2] & 0x00)
13844 {
13845 case 0x00:
13846 goto op_semantics_115;
13847 break;
13848 }
13849 break;
13850 case 0x0f:
13851 GETBYTE ();
13852 switch (op[2] & 0x00)
13853 {
13854 case 0x00:
13855 goto op_semantics_115;
13856 break;
13857 }
13858 break;
13859 case 0x10:
13860 GETBYTE ();
13861 switch (op[2] & 0x00)
13862 {
13863 case 0x00:
13864 goto op_semantics_115;
13865 break;
13866 }
13867 break;
13868 case 0x11:
13869 GETBYTE ();
13870 switch (op[2] & 0x00)
13871 {
13872 case 0x00:
13873 goto op_semantics_115;
13874 break;
13875 }
13876 break;
13877 case 0x12:
13878 GETBYTE ();
13879 switch (op[2] & 0x00)
13880 {
13881 case 0x00:
13882 goto op_semantics_115;
13883 break;
13884 }
13885 break;
13886 case 0x13:
13887 GETBYTE ();
13888 switch (op[2] & 0x00)
13889 {
13890 case 0x00:
13891 goto op_semantics_115;
13892 break;
13893 }
13894 break;
13895 case 0x14:
13896 GETBYTE ();
13897 switch (op[2] & 0x00)
13898 {
13899 case 0x00:
13900 goto op_semantics_115;
13901 break;
13902 }
13903 break;
13904 case 0x15:
13905 GETBYTE ();
13906 switch (op[2] & 0x00)
13907 {
13908 case 0x00:
13909 goto op_semantics_115;
13910 break;
13911 }
13912 break;
13913 case 0x16:
13914 GETBYTE ();
13915 switch (op[2] & 0x00)
13916 {
13917 case 0x00:
13918 goto op_semantics_115;
13919 break;
13920 }
13921 break;
13922 case 0x17:
13923 GETBYTE ();
13924 switch (op[2] & 0x00)
13925 {
13926 case 0x00:
13927 goto op_semantics_115;
13928 break;
13929 }
13930 break;
13931 case 0x18:
13932 GETBYTE ();
13933 switch (op[2] & 0x00)
13934 {
13935 case 0x00:
13936 goto op_semantics_115;
13937 break;
13938 }
13939 break;
13940 case 0x19:
13941 GETBYTE ();
13942 switch (op[2] & 0x00)
13943 {
13944 case 0x00:
13945 goto op_semantics_115;
13946 break;
13947 }
13948 break;
13949 case 0x1a:
13950 GETBYTE ();
13951 switch (op[2] & 0x00)
13952 {
13953 case 0x00:
13954 goto op_semantics_115;
13955 break;
13956 }
13957 break;
13958 case 0x1b:
13959 GETBYTE ();
13960 switch (op[2] & 0x00)
13961 {
13962 case 0x00:
13963 goto op_semantics_115;
13964 break;
13965 }
13966 break;
13967 case 0x1c:
13968 GETBYTE ();
13969 switch (op[2] & 0x00)
13970 {
13971 case 0x00:
13972 goto op_semantics_115;
13973 break;
13974 }
13975 break;
13976 case 0x1d:
13977 GETBYTE ();
13978 switch (op[2] & 0x00)
13979 {
13980 case 0x00:
13981 goto op_semantics_115;
13982 break;
13983 }
13984 break;
13985 case 0x1e:
13986 GETBYTE ();
13987 switch (op[2] & 0x00)
13988 {
13989 case 0x00:
13990 goto op_semantics_115;
13991 break;
13992 }
13993 break;
13994 case 0x1f:
13995 GETBYTE ();
13996 switch (op[2] & 0x00)
13997 {
13998 case 0x00:
13999 goto op_semantics_115;
14000 break;
14001 }
14002 break;
14003 case 0x20:
14004 GETBYTE ();
14005 switch (op[2] & 0x00)
14006 {
14007 case 0x00:
14008 goto op_semantics_115;
14009 break;
14010 }
14011 break;
14012 case 0x21:
14013 GETBYTE ();
14014 switch (op[2] & 0x00)
14015 {
14016 case 0x00:
14017 goto op_semantics_115;
14018 break;
14019 }
14020 break;
14021 case 0x22:
14022 GETBYTE ();
14023 switch (op[2] & 0x00)
14024 {
14025 case 0x00:
14026 goto op_semantics_115;
14027 break;
14028 }
14029 break;
14030 case 0x23:
14031 GETBYTE ();
14032 switch (op[2] & 0x00)
14033 {
14034 case 0x00:
14035 goto op_semantics_115;
14036 break;
14037 }
14038 break;
14039 case 0x24:
14040 GETBYTE ();
14041 switch (op[2] & 0x00)
14042 {
14043 case 0x00:
14044 goto op_semantics_115;
14045 break;
14046 }
14047 break;
14048 case 0x25:
14049 GETBYTE ();
14050 switch (op[2] & 0x00)
14051 {
14052 case 0x00:
14053 goto op_semantics_115;
14054 break;
14055 }
14056 break;
14057 case 0x26:
14058 GETBYTE ();
14059 switch (op[2] & 0x00)
14060 {
14061 case 0x00:
14062 goto op_semantics_115;
14063 break;
14064 }
14065 break;
14066 case 0x27:
14067 GETBYTE ();
14068 switch (op[2] & 0x00)
14069 {
14070 case 0x00:
14071 goto op_semantics_115;
14072 break;
14073 }
14074 break;
14075 case 0x28:
14076 GETBYTE ();
14077 switch (op[2] & 0x00)
14078 {
14079 case 0x00:
14080 goto op_semantics_115;
14081 break;
14082 }
14083 break;
14084 case 0x29:
14085 GETBYTE ();
14086 switch (op[2] & 0x00)
14087 {
14088 case 0x00:
14089 goto op_semantics_115;
14090 break;
14091 }
14092 break;
14093 case 0x2a:
14094 GETBYTE ();
14095 switch (op[2] & 0x00)
14096 {
14097 case 0x00:
14098 goto op_semantics_115;
14099 break;
14100 }
14101 break;
14102 case 0x2b:
14103 GETBYTE ();
14104 switch (op[2] & 0x00)
14105 {
14106 case 0x00:
14107 goto op_semantics_115;
14108 break;
14109 }
14110 break;
14111 case 0x2c:
14112 GETBYTE ();
14113 switch (op[2] & 0x00)
14114 {
14115 case 0x00:
14116 goto op_semantics_115;
14117 break;
14118 }
14119 break;
14120 case 0x2d:
14121 GETBYTE ();
14122 switch (op[2] & 0x00)
14123 {
14124 case 0x00:
14125 goto op_semantics_115;
14126 break;
14127 }
14128 break;
14129 case 0x2e:
14130 GETBYTE ();
14131 switch (op[2] & 0x00)
14132 {
14133 case 0x00:
14134 goto op_semantics_115;
14135 break;
14136 }
14137 break;
14138 case 0x2f:
14139 GETBYTE ();
14140 switch (op[2] & 0x00)
14141 {
14142 case 0x00:
14143 goto op_semantics_115;
14144 break;
14145 }
14146 break;
14147 case 0x40:
14148 GETBYTE ();
14149 switch (op[2] & 0x00)
14150 {
14151 case 0x00:
14152 op_semantics_116:
14153 {
14154 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
14155 #line 339 "rx-decode.opc"
14156 int sz AU = (op[1] >> 4) & 0x03;
14157 #line 339 "rx-decode.opc"
14158 int isrc AU = op[1] & 0x0f;
14159 #line 339 "rx-decode.opc"
14160 int bsrc AU = (op[2] >> 4) & 0x0f;
14161 #line 339 "rx-decode.opc"
14162 int rdst AU = op[2] & 0x0f;
14163 if (trace)
14164 {
14165 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14166 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
14167 op[0], op[1], op[2]);
14168 printf (" sz = 0x%x,", sz);
14169 printf (" isrc = 0x%x,", isrc);
14170 printf (" bsrc = 0x%x,", bsrc);
14171 printf (" rdst = 0x%x\n", rdst);
14172 }
14173 SYNTAX("mov%s [%1, %2], %0");
14174 #line 339 "rx-decode.opc"
14175 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14176
14177 }
14178 break;
14179 }
14180 break;
14181 case 0x41:
14182 GETBYTE ();
14183 switch (op[2] & 0x00)
14184 {
14185 case 0x00:
14186 goto op_semantics_116;
14187 break;
14188 }
14189 break;
14190 case 0x42:
14191 GETBYTE ();
14192 switch (op[2] & 0x00)
14193 {
14194 case 0x00:
14195 goto op_semantics_116;
14196 break;
14197 }
14198 break;
14199 case 0x43:
14200 GETBYTE ();
14201 switch (op[2] & 0x00)
14202 {
14203 case 0x00:
14204 goto op_semantics_116;
14205 break;
14206 }
14207 break;
14208 case 0x44:
14209 GETBYTE ();
14210 switch (op[2] & 0x00)
14211 {
14212 case 0x00:
14213 goto op_semantics_116;
14214 break;
14215 }
14216 break;
14217 case 0x45:
14218 GETBYTE ();
14219 switch (op[2] & 0x00)
14220 {
14221 case 0x00:
14222 goto op_semantics_116;
14223 break;
14224 }
14225 break;
14226 case 0x46:
14227 GETBYTE ();
14228 switch (op[2] & 0x00)
14229 {
14230 case 0x00:
14231 goto op_semantics_116;
14232 break;
14233 }
14234 break;
14235 case 0x47:
14236 GETBYTE ();
14237 switch (op[2] & 0x00)
14238 {
14239 case 0x00:
14240 goto op_semantics_116;
14241 break;
14242 }
14243 break;
14244 case 0x48:
14245 GETBYTE ();
14246 switch (op[2] & 0x00)
14247 {
14248 case 0x00:
14249 goto op_semantics_116;
14250 break;
14251 }
14252 break;
14253 case 0x49:
14254 GETBYTE ();
14255 switch (op[2] & 0x00)
14256 {
14257 case 0x00:
14258 goto op_semantics_116;
14259 break;
14260 }
14261 break;
14262 case 0x4a:
14263 GETBYTE ();
14264 switch (op[2] & 0x00)
14265 {
14266 case 0x00:
14267 goto op_semantics_116;
14268 break;
14269 }
14270 break;
14271 case 0x4b:
14272 GETBYTE ();
14273 switch (op[2] & 0x00)
14274 {
14275 case 0x00:
14276 goto op_semantics_116;
14277 break;
14278 }
14279 break;
14280 case 0x4c:
14281 GETBYTE ();
14282 switch (op[2] & 0x00)
14283 {
14284 case 0x00:
14285 goto op_semantics_116;
14286 break;
14287 }
14288 break;
14289 case 0x4d:
14290 GETBYTE ();
14291 switch (op[2] & 0x00)
14292 {
14293 case 0x00:
14294 goto op_semantics_116;
14295 break;
14296 }
14297 break;
14298 case 0x4e:
14299 GETBYTE ();
14300 switch (op[2] & 0x00)
14301 {
14302 case 0x00:
14303 goto op_semantics_116;
14304 break;
14305 }
14306 break;
14307 case 0x4f:
14308 GETBYTE ();
14309 switch (op[2] & 0x00)
14310 {
14311 case 0x00:
14312 goto op_semantics_116;
14313 break;
14314 }
14315 break;
14316 case 0x50:
14317 GETBYTE ();
14318 switch (op[2] & 0x00)
14319 {
14320 case 0x00:
14321 goto op_semantics_116;
14322 break;
14323 }
14324 break;
14325 case 0x51:
14326 GETBYTE ();
14327 switch (op[2] & 0x00)
14328 {
14329 case 0x00:
14330 goto op_semantics_116;
14331 break;
14332 }
14333 break;
14334 case 0x52:
14335 GETBYTE ();
14336 switch (op[2] & 0x00)
14337 {
14338 case 0x00:
14339 goto op_semantics_116;
14340 break;
14341 }
14342 break;
14343 case 0x53:
14344 GETBYTE ();
14345 switch (op[2] & 0x00)
14346 {
14347 case 0x00:
14348 goto op_semantics_116;
14349 break;
14350 }
14351 break;
14352 case 0x54:
14353 GETBYTE ();
14354 switch (op[2] & 0x00)
14355 {
14356 case 0x00:
14357 goto op_semantics_116;
14358 break;
14359 }
14360 break;
14361 case 0x55:
14362 GETBYTE ();
14363 switch (op[2] & 0x00)
14364 {
14365 case 0x00:
14366 goto op_semantics_116;
14367 break;
14368 }
14369 break;
14370 case 0x56:
14371 GETBYTE ();
14372 switch (op[2] & 0x00)
14373 {
14374 case 0x00:
14375 goto op_semantics_116;
14376 break;
14377 }
14378 break;
14379 case 0x57:
14380 GETBYTE ();
14381 switch (op[2] & 0x00)
14382 {
14383 case 0x00:
14384 goto op_semantics_116;
14385 break;
14386 }
14387 break;
14388 case 0x58:
14389 GETBYTE ();
14390 switch (op[2] & 0x00)
14391 {
14392 case 0x00:
14393 goto op_semantics_116;
14394 break;
14395 }
14396 break;
14397 case 0x59:
14398 GETBYTE ();
14399 switch (op[2] & 0x00)
14400 {
14401 case 0x00:
14402 goto op_semantics_116;
14403 break;
14404 }
14405 break;
14406 case 0x5a:
14407 GETBYTE ();
14408 switch (op[2] & 0x00)
14409 {
14410 case 0x00:
14411 goto op_semantics_116;
14412 break;
14413 }
14414 break;
14415 case 0x5b:
14416 GETBYTE ();
14417 switch (op[2] & 0x00)
14418 {
14419 case 0x00:
14420 goto op_semantics_116;
14421 break;
14422 }
14423 break;
14424 case 0x5c:
14425 GETBYTE ();
14426 switch (op[2] & 0x00)
14427 {
14428 case 0x00:
14429 goto op_semantics_116;
14430 break;
14431 }
14432 break;
14433 case 0x5d:
14434 GETBYTE ();
14435 switch (op[2] & 0x00)
14436 {
14437 case 0x00:
14438 goto op_semantics_116;
14439 break;
14440 }
14441 break;
14442 case 0x5e:
14443 GETBYTE ();
14444 switch (op[2] & 0x00)
14445 {
14446 case 0x00:
14447 goto op_semantics_116;
14448 break;
14449 }
14450 break;
14451 case 0x5f:
14452 GETBYTE ();
14453 switch (op[2] & 0x00)
14454 {
14455 case 0x00:
14456 goto op_semantics_116;
14457 break;
14458 }
14459 break;
14460 case 0x60:
14461 GETBYTE ();
14462 switch (op[2] & 0x00)
14463 {
14464 case 0x00:
14465 goto op_semantics_116;
14466 break;
14467 }
14468 break;
14469 case 0x61:
14470 GETBYTE ();
14471 switch (op[2] & 0x00)
14472 {
14473 case 0x00:
14474 goto op_semantics_116;
14475 break;
14476 }
14477 break;
14478 case 0x62:
14479 GETBYTE ();
14480 switch (op[2] & 0x00)
14481 {
14482 case 0x00:
14483 goto op_semantics_116;
14484 break;
14485 }
14486 break;
14487 case 0x63:
14488 GETBYTE ();
14489 switch (op[2] & 0x00)
14490 {
14491 case 0x00:
14492 goto op_semantics_116;
14493 break;
14494 }
14495 break;
14496 case 0x64:
14497 GETBYTE ();
14498 switch (op[2] & 0x00)
14499 {
14500 case 0x00:
14501 goto op_semantics_116;
14502 break;
14503 }
14504 break;
14505 case 0x65:
14506 GETBYTE ();
14507 switch (op[2] & 0x00)
14508 {
14509 case 0x00:
14510 goto op_semantics_116;
14511 break;
14512 }
14513 break;
14514 case 0x66:
14515 GETBYTE ();
14516 switch (op[2] & 0x00)
14517 {
14518 case 0x00:
14519 goto op_semantics_116;
14520 break;
14521 }
14522 break;
14523 case 0x67:
14524 GETBYTE ();
14525 switch (op[2] & 0x00)
14526 {
14527 case 0x00:
14528 goto op_semantics_116;
14529 break;
14530 }
14531 break;
14532 case 0x68:
14533 GETBYTE ();
14534 switch (op[2] & 0x00)
14535 {
14536 case 0x00:
14537 goto op_semantics_116;
14538 break;
14539 }
14540 break;
14541 case 0x69:
14542 GETBYTE ();
14543 switch (op[2] & 0x00)
14544 {
14545 case 0x00:
14546 goto op_semantics_116;
14547 break;
14548 }
14549 break;
14550 case 0x6a:
14551 GETBYTE ();
14552 switch (op[2] & 0x00)
14553 {
14554 case 0x00:
14555 goto op_semantics_116;
14556 break;
14557 }
14558 break;
14559 case 0x6b:
14560 GETBYTE ();
14561 switch (op[2] & 0x00)
14562 {
14563 case 0x00:
14564 goto op_semantics_116;
14565 break;
14566 }
14567 break;
14568 case 0x6c:
14569 GETBYTE ();
14570 switch (op[2] & 0x00)
14571 {
14572 case 0x00:
14573 goto op_semantics_116;
14574 break;
14575 }
14576 break;
14577 case 0x6d:
14578 GETBYTE ();
14579 switch (op[2] & 0x00)
14580 {
14581 case 0x00:
14582 goto op_semantics_116;
14583 break;
14584 }
14585 break;
14586 case 0x6e:
14587 GETBYTE ();
14588 switch (op[2] & 0x00)
14589 {
14590 case 0x00:
14591 goto op_semantics_116;
14592 break;
14593 }
14594 break;
14595 case 0x6f:
14596 GETBYTE ();
14597 switch (op[2] & 0x00)
14598 {
14599 case 0x00:
14600 goto op_semantics_116;
14601 break;
14602 }
14603 break;
14604 case 0xc0:
14605 GETBYTE ();
14606 switch (op[2] & 0x00)
14607 {
14608 case 0x00:
14609 op_semantics_117:
14610 {
14611 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
14612 #line 345 "rx-decode.opc"
14613 int sz AU = (op[1] >> 4) & 0x03;
14614 #line 345 "rx-decode.opc"
14615 int isrc AU = op[1] & 0x0f;
14616 #line 345 "rx-decode.opc"
14617 int bsrc AU = (op[2] >> 4) & 0x0f;
14618 #line 345 "rx-decode.opc"
14619 int rdst AU = op[2] & 0x0f;
14620 if (trace)
14621 {
14622 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14623 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
14624 op[0], op[1], op[2]);
14625 printf (" sz = 0x%x,", sz);
14626 printf (" isrc = 0x%x,", isrc);
14627 printf (" bsrc = 0x%x,", bsrc);
14628 printf (" rdst = 0x%x\n", rdst);
14629 }
14630 SYNTAX("movu%s [%1, %2], %0");
14631 #line 345 "rx-decode.opc"
14632 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14633
14634 }
14635 break;
14636 }
14637 break;
14638 case 0xc1:
14639 GETBYTE ();
14640 switch (op[2] & 0x00)
14641 {
14642 case 0x00:
14643 goto op_semantics_117;
14644 break;
14645 }
14646 break;
14647 case 0xc2:
14648 GETBYTE ();
14649 switch (op[2] & 0x00)
14650 {
14651 case 0x00:
14652 goto op_semantics_117;
14653 break;
14654 }
14655 break;
14656 case 0xc3:
14657 GETBYTE ();
14658 switch (op[2] & 0x00)
14659 {
14660 case 0x00:
14661 goto op_semantics_117;
14662 break;
14663 }
14664 break;
14665 case 0xc4:
14666 GETBYTE ();
14667 switch (op[2] & 0x00)
14668 {
14669 case 0x00:
14670 goto op_semantics_117;
14671 break;
14672 }
14673 break;
14674 case 0xc5:
14675 GETBYTE ();
14676 switch (op[2] & 0x00)
14677 {
14678 case 0x00:
14679 goto op_semantics_117;
14680 break;
14681 }
14682 break;
14683 case 0xc6:
14684 GETBYTE ();
14685 switch (op[2] & 0x00)
14686 {
14687 case 0x00:
14688 goto op_semantics_117;
14689 break;
14690 }
14691 break;
14692 case 0xc7:
14693 GETBYTE ();
14694 switch (op[2] & 0x00)
14695 {
14696 case 0x00:
14697 goto op_semantics_117;
14698 break;
14699 }
14700 break;
14701 case 0xc8:
14702 GETBYTE ();
14703 switch (op[2] & 0x00)
14704 {
14705 case 0x00:
14706 goto op_semantics_117;
14707 break;
14708 }
14709 break;
14710 case 0xc9:
14711 GETBYTE ();
14712 switch (op[2] & 0x00)
14713 {
14714 case 0x00:
14715 goto op_semantics_117;
14716 break;
14717 }
14718 break;
14719 case 0xca:
14720 GETBYTE ();
14721 switch (op[2] & 0x00)
14722 {
14723 case 0x00:
14724 goto op_semantics_117;
14725 break;
14726 }
14727 break;
14728 case 0xcb:
14729 GETBYTE ();
14730 switch (op[2] & 0x00)
14731 {
14732 case 0x00:
14733 goto op_semantics_117;
14734 break;
14735 }
14736 break;
14737 case 0xcc:
14738 GETBYTE ();
14739 switch (op[2] & 0x00)
14740 {
14741 case 0x00:
14742 goto op_semantics_117;
14743 break;
14744 }
14745 break;
14746 case 0xcd:
14747 GETBYTE ();
14748 switch (op[2] & 0x00)
14749 {
14750 case 0x00:
14751 goto op_semantics_117;
14752 break;
14753 }
14754 break;
14755 case 0xce:
14756 GETBYTE ();
14757 switch (op[2] & 0x00)
14758 {
14759 case 0x00:
14760 goto op_semantics_117;
14761 break;
14762 }
14763 break;
14764 case 0xcf:
14765 GETBYTE ();
14766 switch (op[2] & 0x00)
14767 {
14768 case 0x00:
14769 goto op_semantics_117;
14770 break;
14771 }
14772 break;
14773 case 0xd0:
14774 GETBYTE ();
14775 switch (op[2] & 0x00)
14776 {
14777 case 0x00:
14778 goto op_semantics_117;
14779 break;
14780 }
14781 break;
14782 case 0xd1:
14783 GETBYTE ();
14784 switch (op[2] & 0x00)
14785 {
14786 case 0x00:
14787 goto op_semantics_117;
14788 break;
14789 }
14790 break;
14791 case 0xd2:
14792 GETBYTE ();
14793 switch (op[2] & 0x00)
14794 {
14795 case 0x00:
14796 goto op_semantics_117;
14797 break;
14798 }
14799 break;
14800 case 0xd3:
14801 GETBYTE ();
14802 switch (op[2] & 0x00)
14803 {
14804 case 0x00:
14805 goto op_semantics_117;
14806 break;
14807 }
14808 break;
14809 case 0xd4:
14810 GETBYTE ();
14811 switch (op[2] & 0x00)
14812 {
14813 case 0x00:
14814 goto op_semantics_117;
14815 break;
14816 }
14817 break;
14818 case 0xd5:
14819 GETBYTE ();
14820 switch (op[2] & 0x00)
14821 {
14822 case 0x00:
14823 goto op_semantics_117;
14824 break;
14825 }
14826 break;
14827 case 0xd6:
14828 GETBYTE ();
14829 switch (op[2] & 0x00)
14830 {
14831 case 0x00:
14832 goto op_semantics_117;
14833 break;
14834 }
14835 break;
14836 case 0xd7:
14837 GETBYTE ();
14838 switch (op[2] & 0x00)
14839 {
14840 case 0x00:
14841 goto op_semantics_117;
14842 break;
14843 }
14844 break;
14845 case 0xd8:
14846 GETBYTE ();
14847 switch (op[2] & 0x00)
14848 {
14849 case 0x00:
14850 goto op_semantics_117;
14851 break;
14852 }
14853 break;
14854 case 0xd9:
14855 GETBYTE ();
14856 switch (op[2] & 0x00)
14857 {
14858 case 0x00:
14859 goto op_semantics_117;
14860 break;
14861 }
14862 break;
14863 case 0xda:
14864 GETBYTE ();
14865 switch (op[2] & 0x00)
14866 {
14867 case 0x00:
14868 goto op_semantics_117;
14869 break;
14870 }
14871 break;
14872 case 0xdb:
14873 GETBYTE ();
14874 switch (op[2] & 0x00)
14875 {
14876 case 0x00:
14877 goto op_semantics_117;
14878 break;
14879 }
14880 break;
14881 case 0xdc:
14882 GETBYTE ();
14883 switch (op[2] & 0x00)
14884 {
14885 case 0x00:
14886 goto op_semantics_117;
14887 break;
14888 }
14889 break;
14890 case 0xdd:
14891 GETBYTE ();
14892 switch (op[2] & 0x00)
14893 {
14894 case 0x00:
14895 goto op_semantics_117;
14896 break;
14897 }
14898 break;
14899 case 0xde:
14900 GETBYTE ();
14901 switch (op[2] & 0x00)
14902 {
14903 case 0x00:
14904 goto op_semantics_117;
14905 break;
14906 }
14907 break;
14908 case 0xdf:
14909 GETBYTE ();
14910 switch (op[2] & 0x00)
14911 {
14912 case 0x00:
14913 goto op_semantics_117;
14914 break;
14915 }
14916 break;
14917 case 0xe0:
14918 GETBYTE ();
14919 switch (op[2] & 0x00)
14920 {
14921 case 0x00:
14922 goto op_semantics_117;
14923 break;
14924 }
14925 break;
14926 case 0xe1:
14927 GETBYTE ();
14928 switch (op[2] & 0x00)
14929 {
14930 case 0x00:
14931 goto op_semantics_117;
14932 break;
14933 }
14934 break;
14935 case 0xe2:
14936 GETBYTE ();
14937 switch (op[2] & 0x00)
14938 {
14939 case 0x00:
14940 goto op_semantics_117;
14941 break;
14942 }
14943 break;
14944 case 0xe3:
14945 GETBYTE ();
14946 switch (op[2] & 0x00)
14947 {
14948 case 0x00:
14949 goto op_semantics_117;
14950 break;
14951 }
14952 break;
14953 case 0xe4:
14954 GETBYTE ();
14955 switch (op[2] & 0x00)
14956 {
14957 case 0x00:
14958 goto op_semantics_117;
14959 break;
14960 }
14961 break;
14962 case 0xe5:
14963 GETBYTE ();
14964 switch (op[2] & 0x00)
14965 {
14966 case 0x00:
14967 goto op_semantics_117;
14968 break;
14969 }
14970 break;
14971 case 0xe6:
14972 GETBYTE ();
14973 switch (op[2] & 0x00)
14974 {
14975 case 0x00:
14976 goto op_semantics_117;
14977 break;
14978 }
14979 break;
14980 case 0xe7:
14981 GETBYTE ();
14982 switch (op[2] & 0x00)
14983 {
14984 case 0x00:
14985 goto op_semantics_117;
14986 break;
14987 }
14988 break;
14989 case 0xe8:
14990 GETBYTE ();
14991 switch (op[2] & 0x00)
14992 {
14993 case 0x00:
14994 goto op_semantics_117;
14995 break;
14996 }
14997 break;
14998 case 0xe9:
14999 GETBYTE ();
15000 switch (op[2] & 0x00)
15001 {
15002 case 0x00:
15003 goto op_semantics_117;
15004 break;
15005 }
15006 break;
15007 case 0xea:
15008 GETBYTE ();
15009 switch (op[2] & 0x00)
15010 {
15011 case 0x00:
15012 goto op_semantics_117;
15013 break;
15014 }
15015 break;
15016 case 0xeb:
15017 GETBYTE ();
15018 switch (op[2] & 0x00)
15019 {
15020 case 0x00:
15021 goto op_semantics_117;
15022 break;
15023 }
15024 break;
15025 case 0xec:
15026 GETBYTE ();
15027 switch (op[2] & 0x00)
15028 {
15029 case 0x00:
15030 goto op_semantics_117;
15031 break;
15032 }
15033 break;
15034 case 0xed:
15035 GETBYTE ();
15036 switch (op[2] & 0x00)
15037 {
15038 case 0x00:
15039 goto op_semantics_117;
15040 break;
15041 }
15042 break;
15043 case 0xee:
15044 GETBYTE ();
15045 switch (op[2] & 0x00)
15046 {
15047 case 0x00:
15048 goto op_semantics_117;
15049 break;
15050 }
15051 break;
15052 case 0xef:
15053 GETBYTE ();
15054 switch (op[2] & 0x00)
15055 {
15056 case 0x00:
15057 goto op_semantics_117;
15058 break;
15059 }
15060 break;
15061 default: UNSUPPORTED(); break;
15062 }
15063 break;
15064 case 0xff:
15065 GETBYTE ();
15066 switch (op[1] & 0xff)
15067 {
15068 case 0x00:
15069 GETBYTE ();
15070 switch (op[2] & 0x00)
15071 {
15072 case 0x00:
15073 op_semantics_118:
15074 {
15075 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
15076 #line 549 "rx-decode.opc"
15077 int rdst AU = op[1] & 0x0f;
15078 #line 549 "rx-decode.opc"
15079 int srca AU = (op[2] >> 4) & 0x0f;
15080 #line 549 "rx-decode.opc"
15081 int srcb AU = op[2] & 0x0f;
15082 if (trace)
15083 {
15084 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15085 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
15086 op[0], op[1], op[2]);
15087 printf (" rdst = 0x%x,", rdst);
15088 printf (" srca = 0x%x,", srca);
15089 printf (" srcb = 0x%x\n", srcb);
15090 }
15091 SYNTAX("sub %2, %1, %0");
15092 #line 549 "rx-decode.opc"
15093 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15094
15095 /*----------------------------------------------------------------------*/
15096 /* SBB */
15097
15098 }
15099 break;
15100 }
15101 break;
15102 case 0x01:
15103 GETBYTE ();
15104 switch (op[2] & 0x00)
15105 {
15106 case 0x00:
15107 goto op_semantics_118;
15108 break;
15109 }
15110 break;
15111 case 0x02:
15112 GETBYTE ();
15113 switch (op[2] & 0x00)
15114 {
15115 case 0x00:
15116 goto op_semantics_118;
15117 break;
15118 }
15119 break;
15120 case 0x03:
15121 GETBYTE ();
15122 switch (op[2] & 0x00)
15123 {
15124 case 0x00:
15125 goto op_semantics_118;
15126 break;
15127 }
15128 break;
15129 case 0x04:
15130 GETBYTE ();
15131 switch (op[2] & 0x00)
15132 {
15133 case 0x00:
15134 goto op_semantics_118;
15135 break;
15136 }
15137 break;
15138 case 0x05:
15139 GETBYTE ();
15140 switch (op[2] & 0x00)
15141 {
15142 case 0x00:
15143 goto op_semantics_118;
15144 break;
15145 }
15146 break;
15147 case 0x06:
15148 GETBYTE ();
15149 switch (op[2] & 0x00)
15150 {
15151 case 0x00:
15152 goto op_semantics_118;
15153 break;
15154 }
15155 break;
15156 case 0x07:
15157 GETBYTE ();
15158 switch (op[2] & 0x00)
15159 {
15160 case 0x00:
15161 goto op_semantics_118;
15162 break;
15163 }
15164 break;
15165 case 0x08:
15166 GETBYTE ();
15167 switch (op[2] & 0x00)
15168 {
15169 case 0x00:
15170 goto op_semantics_118;
15171 break;
15172 }
15173 break;
15174 case 0x09:
15175 GETBYTE ();
15176 switch (op[2] & 0x00)
15177 {
15178 case 0x00:
15179 goto op_semantics_118;
15180 break;
15181 }
15182 break;
15183 case 0x0a:
15184 GETBYTE ();
15185 switch (op[2] & 0x00)
15186 {
15187 case 0x00:
15188 goto op_semantics_118;
15189 break;
15190 }
15191 break;
15192 case 0x0b:
15193 GETBYTE ();
15194 switch (op[2] & 0x00)
15195 {
15196 case 0x00:
15197 goto op_semantics_118;
15198 break;
15199 }
15200 break;
15201 case 0x0c:
15202 GETBYTE ();
15203 switch (op[2] & 0x00)
15204 {
15205 case 0x00:
15206 goto op_semantics_118;
15207 break;
15208 }
15209 break;
15210 case 0x0d:
15211 GETBYTE ();
15212 switch (op[2] & 0x00)
15213 {
15214 case 0x00:
15215 goto op_semantics_118;
15216 break;
15217 }
15218 break;
15219 case 0x0e:
15220 GETBYTE ();
15221 switch (op[2] & 0x00)
15222 {
15223 case 0x00:
15224 goto op_semantics_118;
15225 break;
15226 }
15227 break;
15228 case 0x0f:
15229 GETBYTE ();
15230 switch (op[2] & 0x00)
15231 {
15232 case 0x00:
15233 goto op_semantics_118;
15234 break;
15235 }
15236 break;
15237 case 0x20:
15238 GETBYTE ();
15239 switch (op[2] & 0x00)
15240 {
15241 case 0x00:
15242 op_semantics_119:
15243 {
15244 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
15245 #line 516 "rx-decode.opc"
15246 int rdst AU = op[1] & 0x0f;
15247 #line 516 "rx-decode.opc"
15248 int srca AU = (op[2] >> 4) & 0x0f;
15249 #line 516 "rx-decode.opc"
15250 int srcb AU = op[2] & 0x0f;
15251 if (trace)
15252 {
15253 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15254 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
15255 op[0], op[1], op[2]);
15256 printf (" rdst = 0x%x,", rdst);
15257 printf (" srca = 0x%x,", srca);
15258 printf (" srcb = 0x%x\n", srcb);
15259 }
15260 SYNTAX("add %2, %1, %0");
15261 #line 516 "rx-decode.opc"
15262 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15263
15264 /*----------------------------------------------------------------------*/
15265 /* CMP */
15266
15267 }
15268 break;
15269 }
15270 break;
15271 case 0x21:
15272 GETBYTE ();
15273 switch (op[2] & 0x00)
15274 {
15275 case 0x00:
15276 goto op_semantics_119;
15277 break;
15278 }
15279 break;
15280 case 0x22:
15281 GETBYTE ();
15282 switch (op[2] & 0x00)
15283 {
15284 case 0x00:
15285 goto op_semantics_119;
15286 break;
15287 }
15288 break;
15289 case 0x23:
15290 GETBYTE ();
15291 switch (op[2] & 0x00)
15292 {
15293 case 0x00:
15294 goto op_semantics_119;
15295 break;
15296 }
15297 break;
15298 case 0x24:
15299 GETBYTE ();
15300 switch (op[2] & 0x00)
15301 {
15302 case 0x00:
15303 goto op_semantics_119;
15304 break;
15305 }
15306 break;
15307 case 0x25:
15308 GETBYTE ();
15309 switch (op[2] & 0x00)
15310 {
15311 case 0x00:
15312 goto op_semantics_119;
15313 break;
15314 }
15315 break;
15316 case 0x26:
15317 GETBYTE ();
15318 switch (op[2] & 0x00)
15319 {
15320 case 0x00:
15321 goto op_semantics_119;
15322 break;
15323 }
15324 break;
15325 case 0x27:
15326 GETBYTE ();
15327 switch (op[2] & 0x00)
15328 {
15329 case 0x00:
15330 goto op_semantics_119;
15331 break;
15332 }
15333 break;
15334 case 0x28:
15335 GETBYTE ();
15336 switch (op[2] & 0x00)
15337 {
15338 case 0x00:
15339 goto op_semantics_119;
15340 break;
15341 }
15342 break;
15343 case 0x29:
15344 GETBYTE ();
15345 switch (op[2] & 0x00)
15346 {
15347 case 0x00:
15348 goto op_semantics_119;
15349 break;
15350 }
15351 break;
15352 case 0x2a:
15353 GETBYTE ();
15354 switch (op[2] & 0x00)
15355 {
15356 case 0x00:
15357 goto op_semantics_119;
15358 break;
15359 }
15360 break;
15361 case 0x2b:
15362 GETBYTE ();
15363 switch (op[2] & 0x00)
15364 {
15365 case 0x00:
15366 goto op_semantics_119;
15367 break;
15368 }
15369 break;
15370 case 0x2c:
15371 GETBYTE ();
15372 switch (op[2] & 0x00)
15373 {
15374 case 0x00:
15375 goto op_semantics_119;
15376 break;
15377 }
15378 break;
15379 case 0x2d:
15380 GETBYTE ();
15381 switch (op[2] & 0x00)
15382 {
15383 case 0x00:
15384 goto op_semantics_119;
15385 break;
15386 }
15387 break;
15388 case 0x2e:
15389 GETBYTE ();
15390 switch (op[2] & 0x00)
15391 {
15392 case 0x00:
15393 goto op_semantics_119;
15394 break;
15395 }
15396 break;
15397 case 0x2f:
15398 GETBYTE ();
15399 switch (op[2] & 0x00)
15400 {
15401 case 0x00:
15402 goto op_semantics_119;
15403 break;
15404 }
15405 break;
15406 case 0x30:
15407 GETBYTE ();
15408 switch (op[2] & 0x00)
15409 {
15410 case 0x00:
15411 op_semantics_120:
15412 {
15413 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
15414 #line 656 "rx-decode.opc"
15415 int rdst AU = op[1] & 0x0f;
15416 #line 656 "rx-decode.opc"
15417 int srca AU = (op[2] >> 4) & 0x0f;
15418 #line 656 "rx-decode.opc"
15419 int srcb AU = op[2] & 0x0f;
15420 if (trace)
15421 {
15422 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15423 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
15424 op[0], op[1], op[2]);
15425 printf (" rdst = 0x%x,", rdst);
15426 printf (" srca = 0x%x,", srca);
15427 printf (" srcb = 0x%x\n", srcb);
15428 }
15429 SYNTAX("mul %2, %1, %0");
15430 #line 656 "rx-decode.opc"
15431 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15432
15433 /*----------------------------------------------------------------------*/
15434 /* EMUL */
15435
15436 }
15437 break;
15438 }
15439 break;
15440 case 0x31:
15441 GETBYTE ();
15442 switch (op[2] & 0x00)
15443 {
15444 case 0x00:
15445 goto op_semantics_120;
15446 break;
15447 }
15448 break;
15449 case 0x32:
15450 GETBYTE ();
15451 switch (op[2] & 0x00)
15452 {
15453 case 0x00:
15454 goto op_semantics_120;
15455 break;
15456 }
15457 break;
15458 case 0x33:
15459 GETBYTE ();
15460 switch (op[2] & 0x00)
15461 {
15462 case 0x00:
15463 goto op_semantics_120;
15464 break;
15465 }
15466 break;
15467 case 0x34:
15468 GETBYTE ();
15469 switch (op[2] & 0x00)
15470 {
15471 case 0x00:
15472 goto op_semantics_120;
15473 break;
15474 }
15475 break;
15476 case 0x35:
15477 GETBYTE ();
15478 switch (op[2] & 0x00)
15479 {
15480 case 0x00:
15481 goto op_semantics_120;
15482 break;
15483 }
15484 break;
15485 case 0x36:
15486 GETBYTE ();
15487 switch (op[2] & 0x00)
15488 {
15489 case 0x00:
15490 goto op_semantics_120;
15491 break;
15492 }
15493 break;
15494 case 0x37:
15495 GETBYTE ();
15496 switch (op[2] & 0x00)
15497 {
15498 case 0x00:
15499 goto op_semantics_120;
15500 break;
15501 }
15502 break;
15503 case 0x38:
15504 GETBYTE ();
15505 switch (op[2] & 0x00)
15506 {
15507 case 0x00:
15508 goto op_semantics_120;
15509 break;
15510 }
15511 break;
15512 case 0x39:
15513 GETBYTE ();
15514 switch (op[2] & 0x00)
15515 {
15516 case 0x00:
15517 goto op_semantics_120;
15518 break;
15519 }
15520 break;
15521 case 0x3a:
15522 GETBYTE ();
15523 switch (op[2] & 0x00)
15524 {
15525 case 0x00:
15526 goto op_semantics_120;
15527 break;
15528 }
15529 break;
15530 case 0x3b:
15531 GETBYTE ();
15532 switch (op[2] & 0x00)
15533 {
15534 case 0x00:
15535 goto op_semantics_120;
15536 break;
15537 }
15538 break;
15539 case 0x3c:
15540 GETBYTE ();
15541 switch (op[2] & 0x00)
15542 {
15543 case 0x00:
15544 goto op_semantics_120;
15545 break;
15546 }
15547 break;
15548 case 0x3d:
15549 GETBYTE ();
15550 switch (op[2] & 0x00)
15551 {
15552 case 0x00:
15553 goto op_semantics_120;
15554 break;
15555 }
15556 break;
15557 case 0x3e:
15558 GETBYTE ();
15559 switch (op[2] & 0x00)
15560 {
15561 case 0x00:
15562 goto op_semantics_120;
15563 break;
15564 }
15565 break;
15566 case 0x3f:
15567 GETBYTE ();
15568 switch (op[2] & 0x00)
15569 {
15570 case 0x00:
15571 goto op_semantics_120;
15572 break;
15573 }
15574 break;
15575 case 0x40:
15576 GETBYTE ();
15577 switch (op[2] & 0x00)
15578 {
15579 case 0x00:
15580 op_semantics_121:
15581 {
15582 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
15583 #line 426 "rx-decode.opc"
15584 int rdst AU = op[1] & 0x0f;
15585 #line 426 "rx-decode.opc"
15586 int srca AU = (op[2] >> 4) & 0x0f;
15587 #line 426 "rx-decode.opc"
15588 int srcb AU = op[2] & 0x0f;
15589 if (trace)
15590 {
15591 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15592 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
15593 op[0], op[1], op[2]);
15594 printf (" rdst = 0x%x,", rdst);
15595 printf (" srca = 0x%x,", srca);
15596 printf (" srcb = 0x%x\n", srcb);
15597 }
15598 SYNTAX("and %2, %1, %0");
15599 #line 426 "rx-decode.opc"
15600 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15601
15602 /*----------------------------------------------------------------------*/
15603 /* OR */
15604
15605 }
15606 break;
15607 }
15608 break;
15609 case 0x41:
15610 GETBYTE ();
15611 switch (op[2] & 0x00)
15612 {
15613 case 0x00:
15614 goto op_semantics_121;
15615 break;
15616 }
15617 break;
15618 case 0x42:
15619 GETBYTE ();
15620 switch (op[2] & 0x00)
15621 {
15622 case 0x00:
15623 goto op_semantics_121;
15624 break;
15625 }
15626 break;
15627 case 0x43:
15628 GETBYTE ();
15629 switch (op[2] & 0x00)
15630 {
15631 case 0x00:
15632 goto op_semantics_121;
15633 break;
15634 }
15635 break;
15636 case 0x44:
15637 GETBYTE ();
15638 switch (op[2] & 0x00)
15639 {
15640 case 0x00:
15641 goto op_semantics_121;
15642 break;
15643 }
15644 break;
15645 case 0x45:
15646 GETBYTE ();
15647 switch (op[2] & 0x00)
15648 {
15649 case 0x00:
15650 goto op_semantics_121;
15651 break;
15652 }
15653 break;
15654 case 0x46:
15655 GETBYTE ();
15656 switch (op[2] & 0x00)
15657 {
15658 case 0x00:
15659 goto op_semantics_121;
15660 break;
15661 }
15662 break;
15663 case 0x47:
15664 GETBYTE ();
15665 switch (op[2] & 0x00)
15666 {
15667 case 0x00:
15668 goto op_semantics_121;
15669 break;
15670 }
15671 break;
15672 case 0x48:
15673 GETBYTE ();
15674 switch (op[2] & 0x00)
15675 {
15676 case 0x00:
15677 goto op_semantics_121;
15678 break;
15679 }
15680 break;
15681 case 0x49:
15682 GETBYTE ();
15683 switch (op[2] & 0x00)
15684 {
15685 case 0x00:
15686 goto op_semantics_121;
15687 break;
15688 }
15689 break;
15690 case 0x4a:
15691 GETBYTE ();
15692 switch (op[2] & 0x00)
15693 {
15694 case 0x00:
15695 goto op_semantics_121;
15696 break;
15697 }
15698 break;
15699 case 0x4b:
15700 GETBYTE ();
15701 switch (op[2] & 0x00)
15702 {
15703 case 0x00:
15704 goto op_semantics_121;
15705 break;
15706 }
15707 break;
15708 case 0x4c:
15709 GETBYTE ();
15710 switch (op[2] & 0x00)
15711 {
15712 case 0x00:
15713 goto op_semantics_121;
15714 break;
15715 }
15716 break;
15717 case 0x4d:
15718 GETBYTE ();
15719 switch (op[2] & 0x00)
15720 {
15721 case 0x00:
15722 goto op_semantics_121;
15723 break;
15724 }
15725 break;
15726 case 0x4e:
15727 GETBYTE ();
15728 switch (op[2] & 0x00)
15729 {
15730 case 0x00:
15731 goto op_semantics_121;
15732 break;
15733 }
15734 break;
15735 case 0x4f:
15736 GETBYTE ();
15737 switch (op[2] & 0x00)
15738 {
15739 case 0x00:
15740 goto op_semantics_121;
15741 break;
15742 }
15743 break;
15744 case 0x50:
15745 GETBYTE ();
15746 switch (op[2] & 0x00)
15747 {
15748 case 0x00:
15749 op_semantics_122:
15750 {
15751 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
15752 #line 444 "rx-decode.opc"
15753 int rdst AU = op[1] & 0x0f;
15754 #line 444 "rx-decode.opc"
15755 int srca AU = (op[2] >> 4) & 0x0f;
15756 #line 444 "rx-decode.opc"
15757 int srcb AU = op[2] & 0x0f;
15758 if (trace)
15759 {
15760 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15761 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
15762 op[0], op[1], op[2]);
15763 printf (" rdst = 0x%x,", rdst);
15764 printf (" srca = 0x%x,", srca);
15765 printf (" srcb = 0x%x\n", srcb);
15766 }
15767 SYNTAX("or %2, %1, %0");
15768 #line 444 "rx-decode.opc"
15769 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15770
15771 /*----------------------------------------------------------------------*/
15772 /* XOR */
15773
15774 }
15775 break;
15776 }
15777 break;
15778 case 0x51:
15779 GETBYTE ();
15780 switch (op[2] & 0x00)
15781 {
15782 case 0x00:
15783 goto op_semantics_122;
15784 break;
15785 }
15786 break;
15787 case 0x52:
15788 GETBYTE ();
15789 switch (op[2] & 0x00)
15790 {
15791 case 0x00:
15792 goto op_semantics_122;
15793 break;
15794 }
15795 break;
15796 case 0x53:
15797 GETBYTE ();
15798 switch (op[2] & 0x00)
15799 {
15800 case 0x00:
15801 goto op_semantics_122;
15802 break;
15803 }
15804 break;
15805 case 0x54:
15806 GETBYTE ();
15807 switch (op[2] & 0x00)
15808 {
15809 case 0x00:
15810 goto op_semantics_122;
15811 break;
15812 }
15813 break;
15814 case 0x55:
15815 GETBYTE ();
15816 switch (op[2] & 0x00)
15817 {
15818 case 0x00:
15819 goto op_semantics_122;
15820 break;
15821 }
15822 break;
15823 case 0x56:
15824 GETBYTE ();
15825 switch (op[2] & 0x00)
15826 {
15827 case 0x00:
15828 goto op_semantics_122;
15829 break;
15830 }
15831 break;
15832 case 0x57:
15833 GETBYTE ();
15834 switch (op[2] & 0x00)
15835 {
15836 case 0x00:
15837 goto op_semantics_122;
15838 break;
15839 }
15840 break;
15841 case 0x58:
15842 GETBYTE ();
15843 switch (op[2] & 0x00)
15844 {
15845 case 0x00:
15846 goto op_semantics_122;
15847 break;
15848 }
15849 break;
15850 case 0x59:
15851 GETBYTE ();
15852 switch (op[2] & 0x00)
15853 {
15854 case 0x00:
15855 goto op_semantics_122;
15856 break;
15857 }
15858 break;
15859 case 0x5a:
15860 GETBYTE ();
15861 switch (op[2] & 0x00)
15862 {
15863 case 0x00:
15864 goto op_semantics_122;
15865 break;
15866 }
15867 break;
15868 case 0x5b:
15869 GETBYTE ();
15870 switch (op[2] & 0x00)
15871 {
15872 case 0x00:
15873 goto op_semantics_122;
15874 break;
15875 }
15876 break;
15877 case 0x5c:
15878 GETBYTE ();
15879 switch (op[2] & 0x00)
15880 {
15881 case 0x00:
15882 goto op_semantics_122;
15883 break;
15884 }
15885 break;
15886 case 0x5d:
15887 GETBYTE ();
15888 switch (op[2] & 0x00)
15889 {
15890 case 0x00:
15891 goto op_semantics_122;
15892 break;
15893 }
15894 break;
15895 case 0x5e:
15896 GETBYTE ();
15897 switch (op[2] & 0x00)
15898 {
15899 case 0x00:
15900 goto op_semantics_122;
15901 break;
15902 }
15903 break;
15904 case 0x5f:
15905 GETBYTE ();
15906 switch (op[2] & 0x00)
15907 {
15908 case 0x00:
15909 goto op_semantics_122;
15910 break;
15911 }
15912 break;
15913 case 0x80:
15914 GETBYTE ();
15915 switch (op[2] & 0x00)
15916 {
15917 case 0x00:
15918 op_semantics_123:
15919 {
15920 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
15921 #line 1104 "rx-decode.opc"
15922 int rdst AU = op[1] & 0x0f;
15923 #line 1104 "rx-decode.opc"
15924 int srca AU = (op[2] >> 4) & 0x0f;
15925 #line 1104 "rx-decode.opc"
15926 int srcb AU = op[2] & 0x0f;
15927 if (trace)
15928 {
15929 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15930 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
15931 op[0], op[1], op[2]);
15932 printf (" rdst = 0x%x,", rdst);
15933 printf (" srca = 0x%x,", srca);
15934 printf (" srcb = 0x%x\n", srcb);
15935 }
15936 SYNTAX("fsub %2, %1, %0");
15937 #line 1104 "rx-decode.opc"
15938 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15939
15940 }
15941 break;
15942 }
15943 break;
15944 case 0x81:
15945 GETBYTE ();
15946 switch (op[2] & 0x00)
15947 {
15948 case 0x00:
15949 goto op_semantics_123;
15950 break;
15951 }
15952 break;
15953 case 0x82:
15954 GETBYTE ();
15955 switch (op[2] & 0x00)
15956 {
15957 case 0x00:
15958 goto op_semantics_123;
15959 break;
15960 }
15961 break;
15962 case 0x83:
15963 GETBYTE ();
15964 switch (op[2] & 0x00)
15965 {
15966 case 0x00:
15967 goto op_semantics_123;
15968 break;
15969 }
15970 break;
15971 case 0x84:
15972 GETBYTE ();
15973 switch (op[2] & 0x00)
15974 {
15975 case 0x00:
15976 goto op_semantics_123;
15977 break;
15978 }
15979 break;
15980 case 0x85:
15981 GETBYTE ();
15982 switch (op[2] & 0x00)
15983 {
15984 case 0x00:
15985 goto op_semantics_123;
15986 break;
15987 }
15988 break;
15989 case 0x86:
15990 GETBYTE ();
15991 switch (op[2] & 0x00)
15992 {
15993 case 0x00:
15994 goto op_semantics_123;
15995 break;
15996 }
15997 break;
15998 case 0x87:
15999 GETBYTE ();
16000 switch (op[2] & 0x00)
16001 {
16002 case 0x00:
16003 goto op_semantics_123;
16004 break;
16005 }
16006 break;
16007 case 0x88:
16008 GETBYTE ();
16009 switch (op[2] & 0x00)
16010 {
16011 case 0x00:
16012 goto op_semantics_123;
16013 break;
16014 }
16015 break;
16016 case 0x89:
16017 GETBYTE ();
16018 switch (op[2] & 0x00)
16019 {
16020 case 0x00:
16021 goto op_semantics_123;
16022 break;
16023 }
16024 break;
16025 case 0x8a:
16026 GETBYTE ();
16027 switch (op[2] & 0x00)
16028 {
16029 case 0x00:
16030 goto op_semantics_123;
16031 break;
16032 }
16033 break;
16034 case 0x8b:
16035 GETBYTE ();
16036 switch (op[2] & 0x00)
16037 {
16038 case 0x00:
16039 goto op_semantics_123;
16040 break;
16041 }
16042 break;
16043 case 0x8c:
16044 GETBYTE ();
16045 switch (op[2] & 0x00)
16046 {
16047 case 0x00:
16048 goto op_semantics_123;
16049 break;
16050 }
16051 break;
16052 case 0x8d:
16053 GETBYTE ();
16054 switch (op[2] & 0x00)
16055 {
16056 case 0x00:
16057 goto op_semantics_123;
16058 break;
16059 }
16060 break;
16061 case 0x8e:
16062 GETBYTE ();
16063 switch (op[2] & 0x00)
16064 {
16065 case 0x00:
16066 goto op_semantics_123;
16067 break;
16068 }
16069 break;
16070 case 0x8f:
16071 GETBYTE ();
16072 switch (op[2] & 0x00)
16073 {
16074 case 0x00:
16075 goto op_semantics_123;
16076 break;
16077 }
16078 break;
16079 case 0xa0:
16080 GETBYTE ();
16081 switch (op[2] & 0x00)
16082 {
16083 case 0x00:
16084 op_semantics_124:
16085 {
16086 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
16087 #line 1101 "rx-decode.opc"
16088 int rdst AU = op[1] & 0x0f;
16089 #line 1101 "rx-decode.opc"
16090 int srca AU = (op[2] >> 4) & 0x0f;
16091 #line 1101 "rx-decode.opc"
16092 int srcb AU = op[2] & 0x0f;
16093 if (trace)
16094 {
16095 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16096 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
16097 op[0], op[1], op[2]);
16098 printf (" rdst = 0x%x,", rdst);
16099 printf (" srca = 0x%x,", srca);
16100 printf (" srcb = 0x%x\n", srcb);
16101 }
16102 SYNTAX("fadd %2, %1, %0");
16103 #line 1101 "rx-decode.opc"
16104 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16105
16106 }
16107 break;
16108 }
16109 break;
16110 case 0xa1:
16111 GETBYTE ();
16112 switch (op[2] & 0x00)
16113 {
16114 case 0x00:
16115 goto op_semantics_124;
16116 break;
16117 }
16118 break;
16119 case 0xa2:
16120 GETBYTE ();
16121 switch (op[2] & 0x00)
16122 {
16123 case 0x00:
16124 goto op_semantics_124;
16125 break;
16126 }
16127 break;
16128 case 0xa3:
16129 GETBYTE ();
16130 switch (op[2] & 0x00)
16131 {
16132 case 0x00:
16133 goto op_semantics_124;
16134 break;
16135 }
16136 break;
16137 case 0xa4:
16138 GETBYTE ();
16139 switch (op[2] & 0x00)
16140 {
16141 case 0x00:
16142 goto op_semantics_124;
16143 break;
16144 }
16145 break;
16146 case 0xa5:
16147 GETBYTE ();
16148 switch (op[2] & 0x00)
16149 {
16150 case 0x00:
16151 goto op_semantics_124;
16152 break;
16153 }
16154 break;
16155 case 0xa6:
16156 GETBYTE ();
16157 switch (op[2] & 0x00)
16158 {
16159 case 0x00:
16160 goto op_semantics_124;
16161 break;
16162 }
16163 break;
16164 case 0xa7:
16165 GETBYTE ();
16166 switch (op[2] & 0x00)
16167 {
16168 case 0x00:
16169 goto op_semantics_124;
16170 break;
16171 }
16172 break;
16173 case 0xa8:
16174 GETBYTE ();
16175 switch (op[2] & 0x00)
16176 {
16177 case 0x00:
16178 goto op_semantics_124;
16179 break;
16180 }
16181 break;
16182 case 0xa9:
16183 GETBYTE ();
16184 switch (op[2] & 0x00)
16185 {
16186 case 0x00:
16187 goto op_semantics_124;
16188 break;
16189 }
16190 break;
16191 case 0xaa:
16192 GETBYTE ();
16193 switch (op[2] & 0x00)
16194 {
16195 case 0x00:
16196 goto op_semantics_124;
16197 break;
16198 }
16199 break;
16200 case 0xab:
16201 GETBYTE ();
16202 switch (op[2] & 0x00)
16203 {
16204 case 0x00:
16205 goto op_semantics_124;
16206 break;
16207 }
16208 break;
16209 case 0xac:
16210 GETBYTE ();
16211 switch (op[2] & 0x00)
16212 {
16213 case 0x00:
16214 goto op_semantics_124;
16215 break;
16216 }
16217 break;
16218 case 0xad:
16219 GETBYTE ();
16220 switch (op[2] & 0x00)
16221 {
16222 case 0x00:
16223 goto op_semantics_124;
16224 break;
16225 }
16226 break;
16227 case 0xae:
16228 GETBYTE ();
16229 switch (op[2] & 0x00)
16230 {
16231 case 0x00:
16232 goto op_semantics_124;
16233 break;
16234 }
16235 break;
16236 case 0xaf:
16237 GETBYTE ();
16238 switch (op[2] & 0x00)
16239 {
16240 case 0x00:
16241 goto op_semantics_124;
16242 break;
16243 }
16244 break;
16245 case 0xb0:
16246 GETBYTE ();
16247 switch (op[2] & 0x00)
16248 {
16249 case 0x00:
16250 op_semantics_125:
16251 {
16252 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
16253 #line 1107 "rx-decode.opc"
16254 int rdst AU = op[1] & 0x0f;
16255 #line 1107 "rx-decode.opc"
16256 int srca AU = (op[2] >> 4) & 0x0f;
16257 #line 1107 "rx-decode.opc"
16258 int srcb AU = op[2] & 0x0f;
16259 if (trace)
16260 {
16261 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16262 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
16263 op[0], op[1], op[2]);
16264 printf (" rdst = 0x%x,", rdst);
16265 printf (" srca = 0x%x,", srca);
16266 printf (" srcb = 0x%x\n", srcb);
16267 }
16268 SYNTAX("fmul %2, %1, %0");
16269 #line 1107 "rx-decode.opc"
16270 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16271
16272 }
16273 break;
16274 }
16275 break;
16276 case 0xb1:
16277 GETBYTE ();
16278 switch (op[2] & 0x00)
16279 {
16280 case 0x00:
16281 goto op_semantics_125;
16282 break;
16283 }
16284 break;
16285 case 0xb2:
16286 GETBYTE ();
16287 switch (op[2] & 0x00)
16288 {
16289 case 0x00:
16290 goto op_semantics_125;
16291 break;
16292 }
16293 break;
16294 case 0xb3:
16295 GETBYTE ();
16296 switch (op[2] & 0x00)
16297 {
16298 case 0x00:
16299 goto op_semantics_125;
16300 break;
16301 }
16302 break;
16303 case 0xb4:
16304 GETBYTE ();
16305 switch (op[2] & 0x00)
16306 {
16307 case 0x00:
16308 goto op_semantics_125;
16309 break;
16310 }
16311 break;
16312 case 0xb5:
16313 GETBYTE ();
16314 switch (op[2] & 0x00)
16315 {
16316 case 0x00:
16317 goto op_semantics_125;
16318 break;
16319 }
16320 break;
16321 case 0xb6:
16322 GETBYTE ();
16323 switch (op[2] & 0x00)
16324 {
16325 case 0x00:
16326 goto op_semantics_125;
16327 break;
16328 }
16329 break;
16330 case 0xb7:
16331 GETBYTE ();
16332 switch (op[2] & 0x00)
16333 {
16334 case 0x00:
16335 goto op_semantics_125;
16336 break;
16337 }
16338 break;
16339 case 0xb8:
16340 GETBYTE ();
16341 switch (op[2] & 0x00)
16342 {
16343 case 0x00:
16344 goto op_semantics_125;
16345 break;
16346 }
16347 break;
16348 case 0xb9:
16349 GETBYTE ();
16350 switch (op[2] & 0x00)
16351 {
16352 case 0x00:
16353 goto op_semantics_125;
16354 break;
16355 }
16356 break;
16357 case 0xba:
16358 GETBYTE ();
16359 switch (op[2] & 0x00)
16360 {
16361 case 0x00:
16362 goto op_semantics_125;
16363 break;
16364 }
16365 break;
16366 case 0xbb:
16367 GETBYTE ();
16368 switch (op[2] & 0x00)
16369 {
16370 case 0x00:
16371 goto op_semantics_125;
16372 break;
16373 }
16374 break;
16375 case 0xbc:
16376 GETBYTE ();
16377 switch (op[2] & 0x00)
16378 {
16379 case 0x00:
16380 goto op_semantics_125;
16381 break;
16382 }
16383 break;
16384 case 0xbd:
16385 GETBYTE ();
16386 switch (op[2] & 0x00)
16387 {
16388 case 0x00:
16389 goto op_semantics_125;
16390 break;
16391 }
16392 break;
16393 case 0xbe:
16394 GETBYTE ();
16395 switch (op[2] & 0x00)
16396 {
16397 case 0x00:
16398 goto op_semantics_125;
16399 break;
16400 }
16401 break;
16402 case 0xbf:
16403 GETBYTE ();
16404 switch (op[2] & 0x00)
16405 {
16406 case 0x00:
16407 goto op_semantics_125;
16408 break;
16409 }
16410 break;
16411 default: UNSUPPORTED(); break;
16412 }
16413 break;
16414 default: UNSUPPORTED(); break;
16415 }
16416 #line 1122 "rx-decode.opc"
16417
16418 return rx->n_bytes;
16419 }
GDB Binutils - Deliverables
This page took 0.448198 seconds and 4 git commands to generate.