projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Have filter_results take a std::vector
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
1 /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
2 #line 1 "rx-decode.opc"
3 /* -*- c -*- */
4 /* Copyright (C) 2012-2018 Free Software Foundation, Inc.
5 Contributed by Red Hat.
6 Written by DJ Delorie.
7
8 This file is part of the GNU opcodes library.
9
10 This library is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
14
15 It is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
18 License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
24
25 #include "sysdep.h"
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include "ansidecl.h"
30 #include "opcode/rx.h"
31 #include "libiberty.h"
32
33 #define RX_OPCODE_BIG_ENDIAN 0
34
35 typedef struct
36 {
37 RX_Opcode_Decoded * rx;
38 int (* getbyte)(void *);
39 void * ptr;
40 unsigned char * op;
41 } LocalData;
42
43 static int trace = 0;
44
45 #define BSIZE 0
46 #define WSIZE 1
47 #define LSIZE 2
48
49 /* These are for when the upper bits are "don't care" or "undefined". */
50 static int bwl[4] =
51 {
52 RX_Byte,
53 RX_Word,
54 RX_Long,
55 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
56 };
57
58 static int sbwl[4] =
59 {
60 RX_SByte,
61 RX_SWord,
62 RX_Long,
63 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
64 };
65
66 static int ubw[4] =
67 {
68 RX_UByte,
69 RX_UWord,
70 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */
71 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */
72 };
73
74 static int memex[4] =
75 {
76 RX_SByte,
77 RX_SWord,
78 RX_Long,
79 RX_UWord
80 };
81
82 #define ID(x) rx->id = RXO_##x
83 #define OP(n,t,r,a) (rx->op[n].type = t, \
84 rx->op[n].reg = r, \
85 rx->op[n].addend = a )
86 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
87 rx->op[n].size = s )
88
89 /* This is for the BWL and BW bitfields. */
90 static int SCALE[] = { 1, 2, 4, 0 };
91 /* This is for the prefix size enum. */
92 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
93
94 #define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
95 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
96
97 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
98 16, 17, 0, 0, 0, 0, 0, 0 };
99
100 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
101
102 /*
103 *C a constant (immediate) c
104 *R A register
105 *I Register indirect, no offset
106 *Is Register indirect, with offset
107 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
108 *P standard displacement: type (r,[r]), reg, assumes UByte
109 *Pm memex displacement: type (r,[r]), reg, memex code
110 *cc condition code. */
111
112 #define DC(c) OP (0, RX_Operand_Immediate, 0, c)
113 #define DR(r) OP (0, RX_Operand_Register, r, 0)
114 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
115 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
116 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
117 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
118
119 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
120 #define SR(r) OP (1, RX_Operand_Register, r, 0)
121 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
122 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
123 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
124 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
125 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
126 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
127 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
128
129 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
130 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
131 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
132 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
133 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
134 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
135 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
136 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
137
138 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
139 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
140 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
141 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
142
143 #define F(f) store_flags(rx, f)
144
145 #define AU ATTRIBUTE_UNUSED
146 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
147
148 #define SYNTAX(x) rx->syntax = x
149
150 #define UNSUPPORTED() \
151 rx->syntax = "*unknown*"
152
153 #define IMM(sf) immediate (sf, 0, ld)
154 #define IMMex(sf) immediate (sf, 1, ld)
155
156 static int
157 immediate (int sfield, int ex, LocalData * ld)
158 {
159 unsigned long i = 0, j;
160
161 switch (sfield)
162 {
163 #define B ((unsigned long) GETBYTE())
164 case 0:
165 #if RX_OPCODE_BIG_ENDIAN
166 i = B;
167 if (ex && (i & 0x80))
168 i -= 0x100;
169 i <<= 24;
170 i |= B << 16;
171 i |= B << 8;
172 i |= B;
173 #else
174 i = B;
175 i |= B << 8;
176 i |= B << 16;
177 j = B;
178 if (ex && (j & 0x80))
179 j -= 0x100;
180 i |= j << 24;
181 #endif
182 break;
183 case 3:
184 #if RX_OPCODE_BIG_ENDIAN
185 i = B << 16;
186 i |= B << 8;
187 i |= B;
188 #else
189 i = B;
190 i |= B << 8;
191 i |= B << 16;
192 #endif
193 if (ex && (i & 0x800000))
194 i -= 0x1000000;
195 break;
196 case 2:
197 #if RX_OPCODE_BIG_ENDIAN
198 i |= B << 8;
199 i |= B;
200 #else
201 i |= B;
202 i |= B << 8;
203 #endif
204 if (ex && (i & 0x8000))
205 i -= 0x10000;
206 break;
207 case 1:
208 i |= B;
209 if (ex && (i & 0x80))
210 i -= 0x100;
211 break;
212 default:
213 abort();
214 }
215 return i;
216 }
217
218 static void
219 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
220 {
221 int disp;
222
223 ld->rx->op[n].reg = reg;
224 switch (type)
225 {
226 case 3:
227 ld->rx->op[n].type = RX_Operand_Register;
228 break;
229 case 0:
230 ld->rx->op[n].type = RX_Operand_Zero_Indirect;
231 ld->rx->op[n].addend = 0;
232 break;
233 case 1:
234 ld->rx->op[n].type = RX_Operand_Indirect;
235 disp = GETBYTE ();
236 ld->rx->op[n].addend = disp * GET_PSCALE (size);
237 break;
238 case 2:
239 ld->rx->op[n].type = RX_Operand_Indirect;
240 disp = GETBYTE ();
241 #if RX_OPCODE_BIG_ENDIAN
242 disp = disp * 256 + GETBYTE ();
243 #else
244 disp = disp + GETBYTE () * 256;
245 #endif
246 ld->rx->op[n].addend = disp * GET_PSCALE (size);
247 break;
248 default:
249 abort ();
250 }
251 }
252
253 #define xO 8
254 #define xS 4
255 #define xZ 2
256 #define xC 1
257
258 #define F_____
259 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
260 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
261 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
262 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
263 #define F_O___ rx->flags_0 = rx->flags_s = xO;
264 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
265 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
266 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
267
268 int
269 rx_decode_opcode (unsigned long pc AU,
270 RX_Opcode_Decoded * rx,
271 int (* getbyte)(void *),
272 void * ptr)
273 {
274 LocalData lds, * ld = &lds;
275 unsigned char op[20] = {0};
276
277 lds.rx = rx;
278 lds.getbyte = getbyte;
279 lds.ptr = ptr;
280 lds.op = op;
281
282 memset (rx, 0, sizeof (*rx));
283 BWL(LSIZE);
284
285
286 /*----------------------------------------------------------------------*/
287 /* MOV */
288
289 GETBYTE ();
290 switch (op[0] & 0xff)
291 {
292 case 0x00:
293 {
294 /** 0000 0000 brk */
295 if (trace)
296 {
297 printf ("\033[33m%s\033[0m %02x\n",
298 "/** 0000 0000 brk */",
299 op[0]);
300 }
301 SYNTAX("brk");
302 #line 1029 "rx-decode.opc"
303 ID(brk);
304
305 }
306 break;
307 case 0x01:
308 {
309 /** 0000 0001 dbt */
310 if (trace)
311 {
312 printf ("\033[33m%s\033[0m %02x\n",
313 "/** 0000 0001 dbt */",
314 op[0]);
315 }
316 SYNTAX("dbt");
317 #line 1032 "rx-decode.opc"
318 ID(dbt);
319
320 }
321 break;
322 case 0x02:
323 {
324 /** 0000 0010 rts */
325 if (trace)
326 {
327 printf ("\033[33m%s\033[0m %02x\n",
328 "/** 0000 0010 rts */",
329 op[0]);
330 }
331 SYNTAX("rts");
332 #line 810 "rx-decode.opc"
333 ID(rts);
334
335 /*----------------------------------------------------------------------*/
336 /* NOP */
337
338 }
339 break;
340 case 0x03:
341 {
342 /** 0000 0011 nop */
343 if (trace)
344 {
345 printf ("\033[33m%s\033[0m %02x\n",
346 "/** 0000 0011 nop */",
347 op[0]);
348 }
349 SYNTAX("nop");
350 #line 816 "rx-decode.opc"
351 ID(nop);
352
353 /*----------------------------------------------------------------------*/
354 /* STRING FUNCTIONS */
355
356 }
357 break;
358 case 0x04:
359 {
360 /** 0000 0100 bra.a %a0 */
361 if (trace)
362 {
363 printf ("\033[33m%s\033[0m %02x\n",
364 "/** 0000 0100 bra.a %a0 */",
365 op[0]);
366 }
367 SYNTAX("bra.a %a0");
368 #line 788 "rx-decode.opc"
369 ID(branch); DC(pc + IMMex(3));
370
371 }
372 break;
373 case 0x05:
374 {
375 /** 0000 0101 bsr.a %a0 */
376 if (trace)
377 {
378 printf ("\033[33m%s\033[0m %02x\n",
379 "/** 0000 0101 bsr.a %a0 */",
380 op[0]);
381 }
382 SYNTAX("bsr.a %a0");
383 #line 804 "rx-decode.opc"
384 ID(jsr); DC(pc + IMMex(3));
385
386 }
387 break;
388 case 0x06:
389 GETBYTE ();
390 switch (op[1] & 0xff)
391 {
392 case 0x00:
393 GETBYTE ();
394 switch (op[2] & 0x00)
395 {
396 case 0x00:
397 op_semantics_1:
398 {
399 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
400 #line 546 "rx-decode.opc"
401 int mx AU = (op[1] >> 6) & 0x03;
402 #line 546 "rx-decode.opc"
403 int ss AU = op[1] & 0x03;
404 #line 546 "rx-decode.opc"
405 int rsrc AU = (op[2] >> 4) & 0x0f;
406 #line 546 "rx-decode.opc"
407 int rdst AU = op[2] & 0x0f;
408 if (trace)
409 {
410 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
411 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
412 op[0], op[1], op[2]);
413 printf (" mx = 0x%x,", mx);
414 printf (" ss = 0x%x,", ss);
415 printf (" rsrc = 0x%x,", rsrc);
416 printf (" rdst = 0x%x\n", rdst);
417 }
418 SYNTAX("sub %2%S2, %1");
419 #line 546 "rx-decode.opc"
420 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
421
422 }
423 break;
424 }
425 break;
426 case 0x01:
427 GETBYTE ();
428 switch (op[2] & 0x00)
429 {
430 case 0x00:
431 goto op_semantics_1;
432 break;
433 }
434 break;
435 case 0x02:
436 GETBYTE ();
437 switch (op[2] & 0x00)
438 {
439 case 0x00:
440 goto op_semantics_1;
441 break;
442 }
443 break;
444 case 0x03:
445 GETBYTE ();
446 switch (op[2] & 0x00)
447 {
448 case 0x00:
449 goto op_semantics_1;
450 break;
451 }
452 break;
453 case 0x04:
454 GETBYTE ();
455 switch (op[2] & 0x00)
456 {
457 case 0x00:
458 op_semantics_2:
459 {
460 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
461 #line 534 "rx-decode.opc"
462 int mx AU = (op[1] >> 6) & 0x03;
463 #line 534 "rx-decode.opc"
464 int ss AU = op[1] & 0x03;
465 #line 534 "rx-decode.opc"
466 int rsrc AU = (op[2] >> 4) & 0x0f;
467 #line 534 "rx-decode.opc"
468 int rdst AU = op[2] & 0x0f;
469 if (trace)
470 {
471 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
472 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
473 op[0], op[1], op[2]);
474 printf (" mx = 0x%x,", mx);
475 printf (" ss = 0x%x,", ss);
476 printf (" rsrc = 0x%x,", rsrc);
477 printf (" rdst = 0x%x\n", rdst);
478 }
479 SYNTAX("cmp %2%S2, %1");
480 #line 534 "rx-decode.opc"
481 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
482
483 /*----------------------------------------------------------------------*/
484 /* SUB */
485
486 }
487 break;
488 }
489 break;
490 case 0x05:
491 GETBYTE ();
492 switch (op[2] & 0x00)
493 {
494 case 0x00:
495 goto op_semantics_2;
496 break;
497 }
498 break;
499 case 0x06:
500 GETBYTE ();
501 switch (op[2] & 0x00)
502 {
503 case 0x00:
504 goto op_semantics_2;
505 break;
506 }
507 break;
508 case 0x07:
509 GETBYTE ();
510 switch (op[2] & 0x00)
511 {
512 case 0x00:
513 goto op_semantics_2;
514 break;
515 }
516 break;
517 case 0x08:
518 GETBYTE ();
519 switch (op[2] & 0x00)
520 {
521 case 0x00:
522 op_semantics_3:
523 {
524 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
525 #line 510 "rx-decode.opc"
526 int mx AU = (op[1] >> 6) & 0x03;
527 #line 510 "rx-decode.opc"
528 int ss AU = op[1] & 0x03;
529 #line 510 "rx-decode.opc"
530 int rsrc AU = (op[2] >> 4) & 0x0f;
531 #line 510 "rx-decode.opc"
532 int rdst AU = op[2] & 0x0f;
533 if (trace)
534 {
535 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
536 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
537 op[0], op[1], op[2]);
538 printf (" mx = 0x%x,", mx);
539 printf (" ss = 0x%x,", ss);
540 printf (" rsrc = 0x%x,", rsrc);
541 printf (" rdst = 0x%x\n", rdst);
542 }
543 SYNTAX("add %1%S1, %0");
544 #line 510 "rx-decode.opc"
545 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
546
547 }
548 break;
549 }
550 break;
551 case 0x09:
552 GETBYTE ();
553 switch (op[2] & 0x00)
554 {
555 case 0x00:
556 goto op_semantics_3;
557 break;
558 }
559 break;
560 case 0x0a:
561 GETBYTE ();
562 switch (op[2] & 0x00)
563 {
564 case 0x00:
565 goto op_semantics_3;
566 break;
567 }
568 break;
569 case 0x0b:
570 GETBYTE ();
571 switch (op[2] & 0x00)
572 {
573 case 0x00:
574 goto op_semantics_3;
575 break;
576 }
577 break;
578 case 0x0c:
579 GETBYTE ();
580 switch (op[2] & 0x00)
581 {
582 case 0x00:
583 op_semantics_4:
584 {
585 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
586 #line 653 "rx-decode.opc"
587 int mx AU = (op[1] >> 6) & 0x03;
588 #line 653 "rx-decode.opc"
589 int ss AU = op[1] & 0x03;
590 #line 653 "rx-decode.opc"
591 int rsrc AU = (op[2] >> 4) & 0x0f;
592 #line 653 "rx-decode.opc"
593 int rdst AU = op[2] & 0x0f;
594 if (trace)
595 {
596 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
597 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
598 op[0], op[1], op[2]);
599 printf (" mx = 0x%x,", mx);
600 printf (" ss = 0x%x,", ss);
601 printf (" rsrc = 0x%x,", rsrc);
602 printf (" rdst = 0x%x\n", rdst);
603 }
604 SYNTAX("mul %1%S1, %0");
605 #line 653 "rx-decode.opc"
606 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
607
608 }
609 break;
610 }
611 break;
612 case 0x0d:
613 GETBYTE ();
614 switch (op[2] & 0x00)
615 {
616 case 0x00:
617 goto op_semantics_4;
618 break;
619 }
620 break;
621 case 0x0e:
622 GETBYTE ();
623 switch (op[2] & 0x00)
624 {
625 case 0x00:
626 goto op_semantics_4;
627 break;
628 }
629 break;
630 case 0x0f:
631 GETBYTE ();
632 switch (op[2] & 0x00)
633 {
634 case 0x00:
635 goto op_semantics_4;
636 break;
637 }
638 break;
639 case 0x10:
640 GETBYTE ();
641 switch (op[2] & 0x00)
642 {
643 case 0x00:
644 op_semantics_5:
645 {
646 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
647 #line 423 "rx-decode.opc"
648 int mx AU = (op[1] >> 6) & 0x03;
649 #line 423 "rx-decode.opc"
650 int ss AU = op[1] & 0x03;
651 #line 423 "rx-decode.opc"
652 int rsrc AU = (op[2] >> 4) & 0x0f;
653 #line 423 "rx-decode.opc"
654 int rdst AU = op[2] & 0x0f;
655 if (trace)
656 {
657 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
658 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
659 op[0], op[1], op[2]);
660 printf (" mx = 0x%x,", mx);
661 printf (" ss = 0x%x,", ss);
662 printf (" rsrc = 0x%x,", rsrc);
663 printf (" rdst = 0x%x\n", rdst);
664 }
665 SYNTAX("and %1%S1, %0");
666 #line 423 "rx-decode.opc"
667 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
668
669 }
670 break;
671 }
672 break;
673 case 0x11:
674 GETBYTE ();
675 switch (op[2] & 0x00)
676 {
677 case 0x00:
678 goto op_semantics_5;
679 break;
680 }
681 break;
682 case 0x12:
683 GETBYTE ();
684 switch (op[2] & 0x00)
685 {
686 case 0x00:
687 goto op_semantics_5;
688 break;
689 }
690 break;
691 case 0x13:
692 GETBYTE ();
693 switch (op[2] & 0x00)
694 {
695 case 0x00:
696 goto op_semantics_5;
697 break;
698 }
699 break;
700 case 0x14:
701 GETBYTE ();
702 switch (op[2] & 0x00)
703 {
704 case 0x00:
705 op_semantics_6:
706 {
707 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
708 #line 441 "rx-decode.opc"
709 int mx AU = (op[1] >> 6) & 0x03;
710 #line 441 "rx-decode.opc"
711 int ss AU = op[1] & 0x03;
712 #line 441 "rx-decode.opc"
713 int rsrc AU = (op[2] >> 4) & 0x0f;
714 #line 441 "rx-decode.opc"
715 int rdst AU = op[2] & 0x0f;
716 if (trace)
717 {
718 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
719 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
720 op[0], op[1], op[2]);
721 printf (" mx = 0x%x,", mx);
722 printf (" ss = 0x%x,", ss);
723 printf (" rsrc = 0x%x,", rsrc);
724 printf (" rdst = 0x%x\n", rdst);
725 }
726 SYNTAX("or %1%S1, %0");
727 #line 441 "rx-decode.opc"
728 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
729
730 }
731 break;
732 }
733 break;
734 case 0x15:
735 GETBYTE ();
736 switch (op[2] & 0x00)
737 {
738 case 0x00:
739 goto op_semantics_6;
740 break;
741 }
742 break;
743 case 0x16:
744 GETBYTE ();
745 switch (op[2] & 0x00)
746 {
747 case 0x00:
748 goto op_semantics_6;
749 break;
750 }
751 break;
752 case 0x17:
753 GETBYTE ();
754 switch (op[2] & 0x00)
755 {
756 case 0x00:
757 goto op_semantics_6;
758 break;
759 }
760 break;
761 case 0x20:
762 GETBYTE ();
763 switch (op[2] & 0xff)
764 {
765 case 0x00:
766 GETBYTE ();
767 switch (op[3] & 0x00)
768 {
769 case 0x00:
770 op_semantics_7:
771 {
772 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
773 #line 559 "rx-decode.opc"
774 int mx AU = (op[1] >> 6) & 0x03;
775 #line 559 "rx-decode.opc"
776 int sp AU = op[1] & 0x03;
777 #line 559 "rx-decode.opc"
778 int rsrc AU = (op[3] >> 4) & 0x0f;
779 #line 559 "rx-decode.opc"
780 int rdst AU = op[3] & 0x0f;
781 if (trace)
782 {
783 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
784 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
785 op[0], op[1], op[2], op[3]);
786 printf (" mx = 0x%x,", mx);
787 printf (" sp = 0x%x,", sp);
788 printf (" rsrc = 0x%x,", rsrc);
789 printf (" rdst = 0x%x\n", rdst);
790 }
791 SYNTAX("sbb %1%S1, %0");
792 #line 559 "rx-decode.opc"
793 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
794
795 /*----------------------------------------------------------------------*/
796 /* ABS */
797
798 }
799 break;
800 }
801 break;
802 case 0x04:
803 GETBYTE ();
804 switch (op[3] & 0x00)
805 {
806 case 0x00:
807 op_semantics_8:
808 {
809 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
810 #line 598 "rx-decode.opc"
811 int mx AU = (op[1] >> 6) & 0x03;
812 #line 598 "rx-decode.opc"
813 int ss AU = op[1] & 0x03;
814 #line 598 "rx-decode.opc"
815 int rsrc AU = (op[3] >> 4) & 0x0f;
816 #line 598 "rx-decode.opc"
817 int rdst AU = op[3] & 0x0f;
818 if (trace)
819 {
820 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
821 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
822 op[0], op[1], op[2], op[3]);
823 printf (" mx = 0x%x,", mx);
824 printf (" ss = 0x%x,", ss);
825 printf (" rsrc = 0x%x,", rsrc);
826 printf (" rdst = 0x%x\n", rdst);
827 }
828 SYNTAX("max %1%S1, %0");
829 #line 598 "rx-decode.opc"
830 ID(max); SPm(ss, rsrc, mx); DR(rdst);
831
832 /*----------------------------------------------------------------------*/
833 /* MIN */
834
835 }
836 break;
837 }
838 break;
839 case 0x05:
840 GETBYTE ();
841 switch (op[3] & 0x00)
842 {
843 case 0x00:
844 op_semantics_9:
845 {
846 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
847 #line 610 "rx-decode.opc"
848 int mx AU = (op[1] >> 6) & 0x03;
849 #line 610 "rx-decode.opc"
850 int ss AU = op[1] & 0x03;
851 #line 610 "rx-decode.opc"
852 int rsrc AU = (op[3] >> 4) & 0x0f;
853 #line 610 "rx-decode.opc"
854 int rdst AU = op[3] & 0x0f;
855 if (trace)
856 {
857 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
858 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
859 op[0], op[1], op[2], op[3]);
860 printf (" mx = 0x%x,", mx);
861 printf (" ss = 0x%x,", ss);
862 printf (" rsrc = 0x%x,", rsrc);
863 printf (" rdst = 0x%x\n", rdst);
864 }
865 SYNTAX("min %1%S1, %0");
866 #line 610 "rx-decode.opc"
867 ID(min); SPm(ss, rsrc, mx); DR(rdst);
868
869 /*----------------------------------------------------------------------*/
870 /* MUL */
871
872 }
873 break;
874 }
875 break;
876 case 0x06:
877 GETBYTE ();
878 switch (op[3] & 0x00)
879 {
880 case 0x00:
881 op_semantics_10:
882 {
883 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
884 #line 668 "rx-decode.opc"
885 int mx AU = (op[1] >> 6) & 0x03;
886 #line 668 "rx-decode.opc"
887 int ss AU = op[1] & 0x03;
888 #line 668 "rx-decode.opc"
889 int rsrc AU = (op[3] >> 4) & 0x0f;
890 #line 668 "rx-decode.opc"
891 int rdst AU = op[3] & 0x0f;
892 if (trace)
893 {
894 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
895 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
896 op[0], op[1], op[2], op[3]);
897 printf (" mx = 0x%x,", mx);
898 printf (" ss = 0x%x,", ss);
899 printf (" rsrc = 0x%x,", rsrc);
900 printf (" rdst = 0x%x\n", rdst);
901 }
902 SYNTAX("emul %1%S1, %0");
903 #line 668 "rx-decode.opc"
904 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
905
906 /*----------------------------------------------------------------------*/
907 /* EMULU */
908
909 }
910 break;
911 }
912 break;
913 case 0x07:
914 GETBYTE ();
915 switch (op[3] & 0x00)
916 {
917 case 0x00:
918 op_semantics_11:
919 {
920 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
921 #line 680 "rx-decode.opc"
922 int mx AU = (op[1] >> 6) & 0x03;
923 #line 680 "rx-decode.opc"
924 int ss AU = op[1] & 0x03;
925 #line 680 "rx-decode.opc"
926 int rsrc AU = (op[3] >> 4) & 0x0f;
927 #line 680 "rx-decode.opc"
928 int rdst AU = op[3] & 0x0f;
929 if (trace)
930 {
931 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
932 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
933 op[0], op[1], op[2], op[3]);
934 printf (" mx = 0x%x,", mx);
935 printf (" ss = 0x%x,", ss);
936 printf (" rsrc = 0x%x,", rsrc);
937 printf (" rdst = 0x%x\n", rdst);
938 }
939 SYNTAX("emulu %1%S1, %0");
940 #line 680 "rx-decode.opc"
941 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
942
943 /*----------------------------------------------------------------------*/
944 /* DIV */
945
946 }
947 break;
948 }
949 break;
950 case 0x08:
951 GETBYTE ();
952 switch (op[3] & 0x00)
953 {
954 case 0x00:
955 op_semantics_12:
956 {
957 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
958 #line 692 "rx-decode.opc"
959 int mx AU = (op[1] >> 6) & 0x03;
960 #line 692 "rx-decode.opc"
961 int ss AU = op[1] & 0x03;
962 #line 692 "rx-decode.opc"
963 int rsrc AU = (op[3] >> 4) & 0x0f;
964 #line 692 "rx-decode.opc"
965 int rdst AU = op[3] & 0x0f;
966 if (trace)
967 {
968 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
969 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
970 op[0], op[1], op[2], op[3]);
971 printf (" mx = 0x%x,", mx);
972 printf (" ss = 0x%x,", ss);
973 printf (" rsrc = 0x%x,", rsrc);
974 printf (" rdst = 0x%x\n", rdst);
975 }
976 SYNTAX("div %1%S1, %0");
977 #line 692 "rx-decode.opc"
978 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
979
980 /*----------------------------------------------------------------------*/
981 /* DIVU */
982
983 }
984 break;
985 }
986 break;
987 case 0x09:
988 GETBYTE ();
989 switch (op[3] & 0x00)
990 {
991 case 0x00:
992 op_semantics_13:
993 {
994 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
995 #line 704 "rx-decode.opc"
996 int mx AU = (op[1] >> 6) & 0x03;
997 #line 704 "rx-decode.opc"
998 int ss AU = op[1] & 0x03;
999 #line 704 "rx-decode.opc"
1000 int rsrc AU = (op[3] >> 4) & 0x0f;
1001 #line 704 "rx-decode.opc"
1002 int rdst AU = op[3] & 0x0f;
1003 if (trace)
1004 {
1005 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1006 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1007 op[0], op[1], op[2], op[3]);
1008 printf (" mx = 0x%x,", mx);
1009 printf (" ss = 0x%x,", ss);
1010 printf (" rsrc = 0x%x,", rsrc);
1011 printf (" rdst = 0x%x\n", rdst);
1012 }
1013 SYNTAX("divu %1%S1, %0");
1014 #line 704 "rx-decode.opc"
1015 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1016
1017 /*----------------------------------------------------------------------*/
1018 /* SHIFT */
1019
1020 }
1021 break;
1022 }
1023 break;
1024 case 0x0c:
1025 GETBYTE ();
1026 switch (op[3] & 0x00)
1027 {
1028 case 0x00:
1029 op_semantics_14:
1030 {
1031 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1032 #line 477 "rx-decode.opc"
1033 int mx AU = (op[1] >> 6) & 0x03;
1034 #line 477 "rx-decode.opc"
1035 int ss AU = op[1] & 0x03;
1036 #line 477 "rx-decode.opc"
1037 int rsrc AU = (op[3] >> 4) & 0x0f;
1038 #line 477 "rx-decode.opc"
1039 int rdst AU = op[3] & 0x0f;
1040 if (trace)
1041 {
1042 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1043 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1044 op[0], op[1], op[2], op[3]);
1045 printf (" mx = 0x%x,", mx);
1046 printf (" ss = 0x%x,", ss);
1047 printf (" rsrc = 0x%x,", rsrc);
1048 printf (" rdst = 0x%x\n", rdst);
1049 }
1050 SYNTAX("tst %1%S1, %2");
1051 #line 477 "rx-decode.opc"
1052 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1053
1054 /*----------------------------------------------------------------------*/
1055 /* NEG */
1056
1057 }
1058 break;
1059 }
1060 break;
1061 case 0x0d:
1062 GETBYTE ();
1063 switch (op[3] & 0x00)
1064 {
1065 case 0x00:
1066 op_semantics_15:
1067 {
1068 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1069 #line 456 "rx-decode.opc"
1070 int mx AU = (op[1] >> 6) & 0x03;
1071 #line 456 "rx-decode.opc"
1072 int ss AU = op[1] & 0x03;
1073 #line 456 "rx-decode.opc"
1074 int rsrc AU = (op[3] >> 4) & 0x0f;
1075 #line 456 "rx-decode.opc"
1076 int rdst AU = op[3] & 0x0f;
1077 if (trace)
1078 {
1079 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1080 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1081 op[0], op[1], op[2], op[3]);
1082 printf (" mx = 0x%x,", mx);
1083 printf (" ss = 0x%x,", ss);
1084 printf (" rsrc = 0x%x,", rsrc);
1085 printf (" rdst = 0x%x\n", rdst);
1086 }
1087 SYNTAX("xor %1%S1, %0");
1088 #line 456 "rx-decode.opc"
1089 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1090
1091 /*----------------------------------------------------------------------*/
1092 /* NOT */
1093
1094 }
1095 break;
1096 }
1097 break;
1098 case 0x10:
1099 GETBYTE ();
1100 switch (op[3] & 0x00)
1101 {
1102 case 0x00:
1103 op_semantics_16:
1104 {
1105 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1106 #line 390 "rx-decode.opc"
1107 int mx AU = (op[1] >> 6) & 0x03;
1108 #line 390 "rx-decode.opc"
1109 int ss AU = op[1] & 0x03;
1110 #line 390 "rx-decode.opc"
1111 int rsrc AU = (op[3] >> 4) & 0x0f;
1112 #line 390 "rx-decode.opc"
1113 int rdst AU = op[3] & 0x0f;
1114 if (trace)
1115 {
1116 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1117 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1118 op[0], op[1], op[2], op[3]);
1119 printf (" mx = 0x%x,", mx);
1120 printf (" ss = 0x%x,", ss);
1121 printf (" rsrc = 0x%x,", rsrc);
1122 printf (" rdst = 0x%x\n", rdst);
1123 }
1124 SYNTAX("xchg %1%S1, %0");
1125 #line 390 "rx-decode.opc"
1126 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1127
1128 /*----------------------------------------------------------------------*/
1129 /* STZ/STNZ */
1130
1131 }
1132 break;
1133 }
1134 break;
1135 case 0x11:
1136 GETBYTE ();
1137 switch (op[3] & 0x00)
1138 {
1139 case 0x00:
1140 op_semantics_17:
1141 {
1142 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1143 #line 933 "rx-decode.opc"
1144 int mx AU = (op[1] >> 6) & 0x03;
1145 #line 933 "rx-decode.opc"
1146 int sd AU = op[1] & 0x03;
1147 #line 933 "rx-decode.opc"
1148 int rsrc AU = (op[3] >> 4) & 0x0f;
1149 #line 933 "rx-decode.opc"
1150 int rdst AU = op[3] & 0x0f;
1151 if (trace)
1152 {
1153 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1154 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1155 op[0], op[1], op[2], op[3]);
1156 printf (" mx = 0x%x,", mx);
1157 printf (" sd = 0x%x,", sd);
1158 printf (" rsrc = 0x%x,", rsrc);
1159 printf (" rdst = 0x%x\n", rdst);
1160 }
1161 SYNTAX("itof %1%S1, %0");
1162 #line 933 "rx-decode.opc"
1163 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1164
1165 /*----------------------------------------------------------------------*/
1166 /* BIT OPS */
1167
1168 }
1169 break;
1170 }
1171 break;
1172 case 0x15:
1173 GETBYTE ();
1174 switch (op[3] & 0x00)
1175 {
1176 case 0x00:
1177 op_semantics_18:
1178 {
1179 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
1180 #line 1119 "rx-decode.opc"
1181 int mx AU = (op[1] >> 6) & 0x03;
1182 #line 1119 "rx-decode.opc"
1183 int sd AU = op[1] & 0x03;
1184 #line 1119 "rx-decode.opc"
1185 int rsrc AU = (op[3] >> 4) & 0x0f;
1186 #line 1119 "rx-decode.opc"
1187 int rdst AU = op[3] & 0x0f;
1188 if (trace)
1189 {
1190 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1191 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */",
1192 op[0], op[1], op[2], op[3]);
1193 printf (" mx = 0x%x,", mx);
1194 printf (" sd = 0x%x,", sd);
1195 printf (" rsrc = 0x%x,", rsrc);
1196 printf (" rdst = 0x%x\n", rdst);
1197 }
1198 SYNTAX("utof %1%S1, %0");
1199 #line 1119 "rx-decode.opc"
1200 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1201
1202 }
1203 break;
1204 }
1205 break;
1206 default: UNSUPPORTED(); break;
1207 }
1208 break;
1209 case 0x21:
1210 GETBYTE ();
1211 switch (op[2] & 0xff)
1212 {
1213 case 0x00:
1214 GETBYTE ();
1215 switch (op[3] & 0x00)
1216 {
1217 case 0x00:
1218 goto op_semantics_7;
1219 break;
1220 }
1221 break;
1222 case 0x04:
1223 GETBYTE ();
1224 switch (op[3] & 0x00)
1225 {
1226 case 0x00:
1227 goto op_semantics_8;
1228 break;
1229 }
1230 break;
1231 case 0x05:
1232 GETBYTE ();
1233 switch (op[3] & 0x00)
1234 {
1235 case 0x00:
1236 goto op_semantics_9;
1237 break;
1238 }
1239 break;
1240 case 0x06:
1241 GETBYTE ();
1242 switch (op[3] & 0x00)
1243 {
1244 case 0x00:
1245 goto op_semantics_10;
1246 break;
1247 }
1248 break;
1249 case 0x07:
1250 GETBYTE ();
1251 switch (op[3] & 0x00)
1252 {
1253 case 0x00:
1254 goto op_semantics_11;
1255 break;
1256 }
1257 break;
1258 case 0x08:
1259 GETBYTE ();
1260 switch (op[3] & 0x00)
1261 {
1262 case 0x00:
1263 goto op_semantics_12;
1264 break;
1265 }
1266 break;
1267 case 0x09:
1268 GETBYTE ();
1269 switch (op[3] & 0x00)
1270 {
1271 case 0x00:
1272 goto op_semantics_13;
1273 break;
1274 }
1275 break;
1276 case 0x0c:
1277 GETBYTE ();
1278 switch (op[3] & 0x00)
1279 {
1280 case 0x00:
1281 goto op_semantics_14;
1282 break;
1283 }
1284 break;
1285 case 0x0d:
1286 GETBYTE ();
1287 switch (op[3] & 0x00)
1288 {
1289 case 0x00:
1290 goto op_semantics_15;
1291 break;
1292 }
1293 break;
1294 case 0x10:
1295 GETBYTE ();
1296 switch (op[3] & 0x00)
1297 {
1298 case 0x00:
1299 goto op_semantics_16;
1300 break;
1301 }
1302 break;
1303 case 0x11:
1304 GETBYTE ();
1305 switch (op[3] & 0x00)
1306 {
1307 case 0x00:
1308 goto op_semantics_17;
1309 break;
1310 }
1311 break;
1312 case 0x15:
1313 GETBYTE ();
1314 switch (op[3] & 0x00)
1315 {
1316 case 0x00:
1317 goto op_semantics_18;
1318 break;
1319 }
1320 break;
1321 default: UNSUPPORTED(); break;
1322 }
1323 break;
1324 case 0x22:
1325 GETBYTE ();
1326 switch (op[2] & 0xff)
1327 {
1328 case 0x00:
1329 GETBYTE ();
1330 switch (op[3] & 0x00)
1331 {
1332 case 0x00:
1333 goto op_semantics_7;
1334 break;
1335 }
1336 break;
1337 case 0x04:
1338 GETBYTE ();
1339 switch (op[3] & 0x00)
1340 {
1341 case 0x00:
1342 goto op_semantics_8;
1343 break;
1344 }
1345 break;
1346 case 0x05:
1347 GETBYTE ();
1348 switch (op[3] & 0x00)
1349 {
1350 case 0x00:
1351 goto op_semantics_9;
1352 break;
1353 }
1354 break;
1355 case 0x06:
1356 GETBYTE ();
1357 switch (op[3] & 0x00)
1358 {
1359 case 0x00:
1360 goto op_semantics_10;
1361 break;
1362 }
1363 break;
1364 case 0x07:
1365 GETBYTE ();
1366 switch (op[3] & 0x00)
1367 {
1368 case 0x00:
1369 goto op_semantics_11;
1370 break;
1371 }
1372 break;
1373 case 0x08:
1374 GETBYTE ();
1375 switch (op[3] & 0x00)
1376 {
1377 case 0x00:
1378 goto op_semantics_12;
1379 break;
1380 }
1381 break;
1382 case 0x09:
1383 GETBYTE ();
1384 switch (op[3] & 0x00)
1385 {
1386 case 0x00:
1387 goto op_semantics_13;
1388 break;
1389 }
1390 break;
1391 case 0x0c:
1392 GETBYTE ();
1393 switch (op[3] & 0x00)
1394 {
1395 case 0x00:
1396 goto op_semantics_14;
1397 break;
1398 }
1399 break;
1400 case 0x0d:
1401 GETBYTE ();
1402 switch (op[3] & 0x00)
1403 {
1404 case 0x00:
1405 goto op_semantics_15;
1406 break;
1407 }
1408 break;
1409 case 0x10:
1410 GETBYTE ();
1411 switch (op[3] & 0x00)
1412 {
1413 case 0x00:
1414 goto op_semantics_16;
1415 break;
1416 }
1417 break;
1418 case 0x11:
1419 GETBYTE ();
1420 switch (op[3] & 0x00)
1421 {
1422 case 0x00:
1423 goto op_semantics_17;
1424 break;
1425 }
1426 break;
1427 case 0x15:
1428 GETBYTE ();
1429 switch (op[3] & 0x00)
1430 {
1431 case 0x00:
1432 goto op_semantics_18;
1433 break;
1434 }
1435 break;
1436 default: UNSUPPORTED(); break;
1437 }
1438 break;
1439 case 0x23:
1440 GETBYTE ();
1441 switch (op[2] & 0xff)
1442 {
1443 case 0x00:
1444 GETBYTE ();
1445 switch (op[3] & 0x00)
1446 {
1447 case 0x00:
1448 goto op_semantics_7;
1449 break;
1450 }
1451 break;
1452 case 0x04:
1453 GETBYTE ();
1454 switch (op[3] & 0x00)
1455 {
1456 case 0x00:
1457 goto op_semantics_8;
1458 break;
1459 }
1460 break;
1461 case 0x05:
1462 GETBYTE ();
1463 switch (op[3] & 0x00)
1464 {
1465 case 0x00:
1466 goto op_semantics_9;
1467 break;
1468 }
1469 break;
1470 case 0x06:
1471 GETBYTE ();
1472 switch (op[3] & 0x00)
1473 {
1474 case 0x00:
1475 goto op_semantics_10;
1476 break;
1477 }
1478 break;
1479 case 0x07:
1480 GETBYTE ();
1481 switch (op[3] & 0x00)
1482 {
1483 case 0x00:
1484 goto op_semantics_11;
1485 break;
1486 }
1487 break;
1488 case 0x08:
1489 GETBYTE ();
1490 switch (op[3] & 0x00)
1491 {
1492 case 0x00:
1493 goto op_semantics_12;
1494 break;
1495 }
1496 break;
1497 case 0x09:
1498 GETBYTE ();
1499 switch (op[3] & 0x00)
1500 {
1501 case 0x00:
1502 goto op_semantics_13;
1503 break;
1504 }
1505 break;
1506 case 0x0c:
1507 GETBYTE ();
1508 switch (op[3] & 0x00)
1509 {
1510 case 0x00:
1511 goto op_semantics_14;
1512 break;
1513 }
1514 break;
1515 case 0x0d:
1516 GETBYTE ();
1517 switch (op[3] & 0x00)
1518 {
1519 case 0x00:
1520 goto op_semantics_15;
1521 break;
1522 }
1523 break;
1524 case 0x10:
1525 GETBYTE ();
1526 switch (op[3] & 0x00)
1527 {
1528 case 0x00:
1529 goto op_semantics_16;
1530 break;
1531 }
1532 break;
1533 case 0x11:
1534 GETBYTE ();
1535 switch (op[3] & 0x00)
1536 {
1537 case 0x00:
1538 goto op_semantics_17;
1539 break;
1540 }
1541 break;
1542 case 0x15:
1543 GETBYTE ();
1544 switch (op[3] & 0x00)
1545 {
1546 case 0x00:
1547 goto op_semantics_18;
1548 break;
1549 }
1550 break;
1551 default: UNSUPPORTED(); break;
1552 }
1553 break;
1554 case 0x40:
1555 GETBYTE ();
1556 switch (op[2] & 0x00)
1557 {
1558 case 0x00:
1559 goto op_semantics_1;
1560 break;
1561 }
1562 break;
1563 case 0x41:
1564 GETBYTE ();
1565 switch (op[2] & 0x00)
1566 {
1567 case 0x00:
1568 goto op_semantics_1;
1569 break;
1570 }
1571 break;
1572 case 0x42:
1573 GETBYTE ();
1574 switch (op[2] & 0x00)
1575 {
1576 case 0x00:
1577 goto op_semantics_1;
1578 break;
1579 }
1580 break;
1581 case 0x43:
1582 GETBYTE ();
1583 switch (op[2] & 0x00)
1584 {
1585 case 0x00:
1586 goto op_semantics_1;
1587 break;
1588 }
1589 break;
1590 case 0x44:
1591 GETBYTE ();
1592 switch (op[2] & 0x00)
1593 {
1594 case 0x00:
1595 goto op_semantics_2;
1596 break;
1597 }
1598 break;
1599 case 0x45:
1600 GETBYTE ();
1601 switch (op[2] & 0x00)
1602 {
1603 case 0x00:
1604 goto op_semantics_2;
1605 break;
1606 }
1607 break;
1608 case 0x46:
1609 GETBYTE ();
1610 switch (op[2] & 0x00)
1611 {
1612 case 0x00:
1613 goto op_semantics_2;
1614 break;
1615 }
1616 break;
1617 case 0x47:
1618 GETBYTE ();
1619 switch (op[2] & 0x00)
1620 {
1621 case 0x00:
1622 goto op_semantics_2;
1623 break;
1624 }
1625 break;
1626 case 0x48:
1627 GETBYTE ();
1628 switch (op[2] & 0x00)
1629 {
1630 case 0x00:
1631 goto op_semantics_3;
1632 break;
1633 }
1634 break;
1635 case 0x49:
1636 GETBYTE ();
1637 switch (op[2] & 0x00)
1638 {
1639 case 0x00:
1640 goto op_semantics_3;
1641 break;
1642 }
1643 break;
1644 case 0x4a:
1645 GETBYTE ();
1646 switch (op[2] & 0x00)
1647 {
1648 case 0x00:
1649 goto op_semantics_3;
1650 break;
1651 }
1652 break;
1653 case 0x4b:
1654 GETBYTE ();
1655 switch (op[2] & 0x00)
1656 {
1657 case 0x00:
1658 goto op_semantics_3;
1659 break;
1660 }
1661 break;
1662 case 0x4c:
1663 GETBYTE ();
1664 switch (op[2] & 0x00)
1665 {
1666 case 0x00:
1667 goto op_semantics_4;
1668 break;
1669 }
1670 break;
1671 case 0x4d:
1672 GETBYTE ();
1673 switch (op[2] & 0x00)
1674 {
1675 case 0x00:
1676 goto op_semantics_4;
1677 break;
1678 }
1679 break;
1680 case 0x4e:
1681 GETBYTE ();
1682 switch (op[2] & 0x00)
1683 {
1684 case 0x00:
1685 goto op_semantics_4;
1686 break;
1687 }
1688 break;
1689 case 0x4f:
1690 GETBYTE ();
1691 switch (op[2] & 0x00)
1692 {
1693 case 0x00:
1694 goto op_semantics_4;
1695 break;
1696 }
1697 break;
1698 case 0x50:
1699 GETBYTE ();
1700 switch (op[2] & 0x00)
1701 {
1702 case 0x00:
1703 goto op_semantics_5;
1704 break;
1705 }
1706 break;
1707 case 0x51:
1708 GETBYTE ();
1709 switch (op[2] & 0x00)
1710 {
1711 case 0x00:
1712 goto op_semantics_5;
1713 break;
1714 }
1715 break;
1716 case 0x52:
1717 GETBYTE ();
1718 switch (op[2] & 0x00)
1719 {
1720 case 0x00:
1721 goto op_semantics_5;
1722 break;
1723 }
1724 break;
1725 case 0x53:
1726 GETBYTE ();
1727 switch (op[2] & 0x00)
1728 {
1729 case 0x00:
1730 goto op_semantics_5;
1731 break;
1732 }
1733 break;
1734 case 0x54:
1735 GETBYTE ();
1736 switch (op[2] & 0x00)
1737 {
1738 case 0x00:
1739 goto op_semantics_6;
1740 break;
1741 }
1742 break;
1743 case 0x55:
1744 GETBYTE ();
1745 switch (op[2] & 0x00)
1746 {
1747 case 0x00:
1748 goto op_semantics_6;
1749 break;
1750 }
1751 break;
1752 case 0x56:
1753 GETBYTE ();
1754 switch (op[2] & 0x00)
1755 {
1756 case 0x00:
1757 goto op_semantics_6;
1758 break;
1759 }
1760 break;
1761 case 0x57:
1762 GETBYTE ();
1763 switch (op[2] & 0x00)
1764 {
1765 case 0x00:
1766 goto op_semantics_6;
1767 break;
1768 }
1769 break;
1770 case 0x60:
1771 GETBYTE ();
1772 switch (op[2] & 0xff)
1773 {
1774 case 0x00:
1775 GETBYTE ();
1776 switch (op[3] & 0x00)
1777 {
1778 case 0x00:
1779 goto op_semantics_7;
1780 break;
1781 }
1782 break;
1783 case 0x04:
1784 GETBYTE ();
1785 switch (op[3] & 0x00)
1786 {
1787 case 0x00:
1788 goto op_semantics_8;
1789 break;
1790 }
1791 break;
1792 case 0x05:
1793 GETBYTE ();
1794 switch (op[3] & 0x00)
1795 {
1796 case 0x00:
1797 goto op_semantics_9;
1798 break;
1799 }
1800 break;
1801 case 0x06:
1802 GETBYTE ();
1803 switch (op[3] & 0x00)
1804 {
1805 case 0x00:
1806 goto op_semantics_10;
1807 break;
1808 }
1809 break;
1810 case 0x07:
1811 GETBYTE ();
1812 switch (op[3] & 0x00)
1813 {
1814 case 0x00:
1815 goto op_semantics_11;
1816 break;
1817 }
1818 break;
1819 case 0x08:
1820 GETBYTE ();
1821 switch (op[3] & 0x00)
1822 {
1823 case 0x00:
1824 goto op_semantics_12;
1825 break;
1826 }
1827 break;
1828 case 0x09:
1829 GETBYTE ();
1830 switch (op[3] & 0x00)
1831 {
1832 case 0x00:
1833 goto op_semantics_13;
1834 break;
1835 }
1836 break;
1837 case 0x0c:
1838 GETBYTE ();
1839 switch (op[3] & 0x00)
1840 {
1841 case 0x00:
1842 goto op_semantics_14;
1843 break;
1844 }
1845 break;
1846 case 0x0d:
1847 GETBYTE ();
1848 switch (op[3] & 0x00)
1849 {
1850 case 0x00:
1851 goto op_semantics_15;
1852 break;
1853 }
1854 break;
1855 case 0x10:
1856 GETBYTE ();
1857 switch (op[3] & 0x00)
1858 {
1859 case 0x00:
1860 goto op_semantics_16;
1861 break;
1862 }
1863 break;
1864 case 0x11:
1865 GETBYTE ();
1866 switch (op[3] & 0x00)
1867 {
1868 case 0x00:
1869 goto op_semantics_17;
1870 break;
1871 }
1872 break;
1873 case 0x15:
1874 GETBYTE ();
1875 switch (op[3] & 0x00)
1876 {
1877 case 0x00:
1878 goto op_semantics_18;
1879 break;
1880 }
1881 break;
1882 default: UNSUPPORTED(); break;
1883 }
1884 break;
1885 case 0x61:
1886 GETBYTE ();
1887 switch (op[2] & 0xff)
1888 {
1889 case 0x00:
1890 GETBYTE ();
1891 switch (op[3] & 0x00)
1892 {
1893 case 0x00:
1894 goto op_semantics_7;
1895 break;
1896 }
1897 break;
1898 case 0x04:
1899 GETBYTE ();
1900 switch (op[3] & 0x00)
1901 {
1902 case 0x00:
1903 goto op_semantics_8;
1904 break;
1905 }
1906 break;
1907 case 0x05:
1908 GETBYTE ();
1909 switch (op[3] & 0x00)
1910 {
1911 case 0x00:
1912 goto op_semantics_9;
1913 break;
1914 }
1915 break;
1916 case 0x06:
1917 GETBYTE ();
1918 switch (op[3] & 0x00)
1919 {
1920 case 0x00:
1921 goto op_semantics_10;
1922 break;
1923 }
1924 break;
1925 case 0x07:
1926 GETBYTE ();
1927 switch (op[3] & 0x00)
1928 {
1929 case 0x00:
1930 goto op_semantics_11;
1931 break;
1932 }
1933 break;
1934 case 0x08:
1935 GETBYTE ();
1936 switch (op[3] & 0x00)
1937 {
1938 case 0x00:
1939 goto op_semantics_12;
1940 break;
1941 }
1942 break;
1943 case 0x09:
1944 GETBYTE ();
1945 switch (op[3] & 0x00)
1946 {
1947 case 0x00:
1948 goto op_semantics_13;
1949 break;
1950 }
1951 break;
1952 case 0x0c:
1953 GETBYTE ();
1954 switch (op[3] & 0x00)
1955 {
1956 case 0x00:
1957 goto op_semantics_14;
1958 break;
1959 }
1960 break;
1961 case 0x0d:
1962 GETBYTE ();
1963 switch (op[3] & 0x00)
1964 {
1965 case 0x00:
1966 goto op_semantics_15;
1967 break;
1968 }
1969 break;
1970 case 0x10:
1971 GETBYTE ();
1972 switch (op[3] & 0x00)
1973 {
1974 case 0x00:
1975 goto op_semantics_16;
1976 break;
1977 }
1978 break;
1979 case 0x11:
1980 GETBYTE ();
1981 switch (op[3] & 0x00)
1982 {
1983 case 0x00:
1984 goto op_semantics_17;
1985 break;
1986 }
1987 break;
1988 case 0x15:
1989 GETBYTE ();
1990 switch (op[3] & 0x00)
1991 {
1992 case 0x00:
1993 goto op_semantics_18;
1994 break;
1995 }
1996 break;
1997 default: UNSUPPORTED(); break;
1998 }
1999 break;
2000 case 0x62:
2001 GETBYTE ();
2002 switch (op[2] & 0xff)
2003 {
2004 case 0x00:
2005 GETBYTE ();
2006 switch (op[3] & 0x00)
2007 {
2008 case 0x00:
2009 goto op_semantics_7;
2010 break;
2011 }
2012 break;
2013 case 0x04:
2014 GETBYTE ();
2015 switch (op[3] & 0x00)
2016 {
2017 case 0x00:
2018 goto op_semantics_8;
2019 break;
2020 }
2021 break;
2022 case 0x05:
2023 GETBYTE ();
2024 switch (op[3] & 0x00)
2025 {
2026 case 0x00:
2027 goto op_semantics_9;
2028 break;
2029 }
2030 break;
2031 case 0x06:
2032 GETBYTE ();
2033 switch (op[3] & 0x00)
2034 {
2035 case 0x00:
2036 goto op_semantics_10;
2037 break;
2038 }
2039 break;
2040 case 0x07:
2041 GETBYTE ();
2042 switch (op[3] & 0x00)
2043 {
2044 case 0x00:
2045 goto op_semantics_11;
2046 break;
2047 }
2048 break;
2049 case 0x08:
2050 GETBYTE ();
2051 switch (op[3] & 0x00)
2052 {
2053 case 0x00:
2054 goto op_semantics_12;
2055 break;
2056 }
2057 break;
2058 case 0x09:
2059 GETBYTE ();
2060 switch (op[3] & 0x00)
2061 {
2062 case 0x00:
2063 goto op_semantics_13;
2064 break;
2065 }
2066 break;
2067 case 0x0c:
2068 GETBYTE ();
2069 switch (op[3] & 0x00)
2070 {
2071 case 0x00:
2072 goto op_semantics_14;
2073 break;
2074 }
2075 break;
2076 case 0x0d:
2077 GETBYTE ();
2078 switch (op[3] & 0x00)
2079 {
2080 case 0x00:
2081 goto op_semantics_15;
2082 break;
2083 }
2084 break;
2085 case 0x10:
2086 GETBYTE ();
2087 switch (op[3] & 0x00)
2088 {
2089 case 0x00:
2090 goto op_semantics_16;
2091 break;
2092 }
2093 break;
2094 case 0x11:
2095 GETBYTE ();
2096 switch (op[3] & 0x00)
2097 {
2098 case 0x00:
2099 goto op_semantics_17;
2100 break;
2101 }
2102 break;
2103 case 0x15:
2104 GETBYTE ();
2105 switch (op[3] & 0x00)
2106 {
2107 case 0x00:
2108 goto op_semantics_18;
2109 break;
2110 }
2111 break;
2112 default: UNSUPPORTED(); break;
2113 }
2114 break;
2115 case 0x63:
2116 GETBYTE ();
2117 switch (op[2] & 0xff)
2118 {
2119 case 0x00:
2120 GETBYTE ();
2121 switch (op[3] & 0x00)
2122 {
2123 case 0x00:
2124 goto op_semantics_7;
2125 break;
2126 }
2127 break;
2128 case 0x04:
2129 GETBYTE ();
2130 switch (op[3] & 0x00)
2131 {
2132 case 0x00:
2133 goto op_semantics_8;
2134 break;
2135 }
2136 break;
2137 case 0x05:
2138 GETBYTE ();
2139 switch (op[3] & 0x00)
2140 {
2141 case 0x00:
2142 goto op_semantics_9;
2143 break;
2144 }
2145 break;
2146 case 0x06:
2147 GETBYTE ();
2148 switch (op[3] & 0x00)
2149 {
2150 case 0x00:
2151 goto op_semantics_10;
2152 break;
2153 }
2154 break;
2155 case 0x07:
2156 GETBYTE ();
2157 switch (op[3] & 0x00)
2158 {
2159 case 0x00:
2160 goto op_semantics_11;
2161 break;
2162 }
2163 break;
2164 case 0x08:
2165 GETBYTE ();
2166 switch (op[3] & 0x00)
2167 {
2168 case 0x00:
2169 goto op_semantics_12;
2170 break;
2171 }
2172 break;
2173 case 0x09:
2174 GETBYTE ();
2175 switch (op[3] & 0x00)
2176 {
2177 case 0x00:
2178 goto op_semantics_13;
2179 break;
2180 }
2181 break;
2182 case 0x0c:
2183 GETBYTE ();
2184 switch (op[3] & 0x00)
2185 {
2186 case 0x00:
2187 goto op_semantics_14;
2188 break;
2189 }
2190 break;
2191 case 0x0d:
2192 GETBYTE ();
2193 switch (op[3] & 0x00)
2194 {
2195 case 0x00:
2196 goto op_semantics_15;
2197 break;
2198 }
2199 break;
2200 case 0x10:
2201 GETBYTE ();
2202 switch (op[3] & 0x00)
2203 {
2204 case 0x00:
2205 goto op_semantics_16;
2206 break;
2207 }
2208 break;
2209 case 0x11:
2210 GETBYTE ();
2211 switch (op[3] & 0x00)
2212 {
2213 case 0x00:
2214 goto op_semantics_17;
2215 break;
2216 }
2217 break;
2218 case 0x15:
2219 GETBYTE ();
2220 switch (op[3] & 0x00)
2221 {
2222 case 0x00:
2223 goto op_semantics_18;
2224 break;
2225 }
2226 break;
2227 default: UNSUPPORTED(); break;
2228 }
2229 break;
2230 case 0x80:
2231 GETBYTE ();
2232 switch (op[2] & 0x00)
2233 {
2234 case 0x00:
2235 goto op_semantics_1;
2236 break;
2237 }
2238 break;
2239 case 0x81:
2240 GETBYTE ();
2241 switch (op[2] & 0x00)
2242 {
2243 case 0x00:
2244 goto op_semantics_1;
2245 break;
2246 }
2247 break;
2248 case 0x82:
2249 GETBYTE ();
2250 switch (op[2] & 0x00)
2251 {
2252 case 0x00:
2253 goto op_semantics_1;
2254 break;
2255 }
2256 break;
2257 case 0x83:
2258 GETBYTE ();
2259 switch (op[2] & 0x00)
2260 {
2261 case 0x00:
2262 goto op_semantics_1;
2263 break;
2264 }
2265 break;
2266 case 0x84:
2267 GETBYTE ();
2268 switch (op[2] & 0x00)
2269 {
2270 case 0x00:
2271 goto op_semantics_2;
2272 break;
2273 }
2274 break;
2275 case 0x85:
2276 GETBYTE ();
2277 switch (op[2] & 0x00)
2278 {
2279 case 0x00:
2280 goto op_semantics_2;
2281 break;
2282 }
2283 break;
2284 case 0x86:
2285 GETBYTE ();
2286 switch (op[2] & 0x00)
2287 {
2288 case 0x00:
2289 goto op_semantics_2;
2290 break;
2291 }
2292 break;
2293 case 0x87:
2294 GETBYTE ();
2295 switch (op[2] & 0x00)
2296 {
2297 case 0x00:
2298 goto op_semantics_2;
2299 break;
2300 }
2301 break;
2302 case 0x88:
2303 GETBYTE ();
2304 switch (op[2] & 0x00)
2305 {
2306 case 0x00:
2307 goto op_semantics_3;
2308 break;
2309 }
2310 break;
2311 case 0x89:
2312 GETBYTE ();
2313 switch (op[2] & 0x00)
2314 {
2315 case 0x00:
2316 goto op_semantics_3;
2317 break;
2318 }
2319 break;
2320 case 0x8a:
2321 GETBYTE ();
2322 switch (op[2] & 0x00)
2323 {
2324 case 0x00:
2325 goto op_semantics_3;
2326 break;
2327 }
2328 break;
2329 case 0x8b:
2330 GETBYTE ();
2331 switch (op[2] & 0x00)
2332 {
2333 case 0x00:
2334 goto op_semantics_3;
2335 break;
2336 }
2337 break;
2338 case 0x8c:
2339 GETBYTE ();
2340 switch (op[2] & 0x00)
2341 {
2342 case 0x00:
2343 goto op_semantics_4;
2344 break;
2345 }
2346 break;
2347 case 0x8d:
2348 GETBYTE ();
2349 switch (op[2] & 0x00)
2350 {
2351 case 0x00:
2352 goto op_semantics_4;
2353 break;
2354 }
2355 break;
2356 case 0x8e:
2357 GETBYTE ();
2358 switch (op[2] & 0x00)
2359 {
2360 case 0x00:
2361 goto op_semantics_4;
2362 break;
2363 }
2364 break;
2365 case 0x8f:
2366 GETBYTE ();
2367 switch (op[2] & 0x00)
2368 {
2369 case 0x00:
2370 goto op_semantics_4;
2371 break;
2372 }
2373 break;
2374 case 0x90:
2375 GETBYTE ();
2376 switch (op[2] & 0x00)
2377 {
2378 case 0x00:
2379 goto op_semantics_5;
2380 break;
2381 }
2382 break;
2383 case 0x91:
2384 GETBYTE ();
2385 switch (op[2] & 0x00)
2386 {
2387 case 0x00:
2388 goto op_semantics_5;
2389 break;
2390 }
2391 break;
2392 case 0x92:
2393 GETBYTE ();
2394 switch (op[2] & 0x00)
2395 {
2396 case 0x00:
2397 goto op_semantics_5;
2398 break;
2399 }
2400 break;
2401 case 0x93:
2402 GETBYTE ();
2403 switch (op[2] & 0x00)
2404 {
2405 case 0x00:
2406 goto op_semantics_5;
2407 break;
2408 }
2409 break;
2410 case 0x94:
2411 GETBYTE ();
2412 switch (op[2] & 0x00)
2413 {
2414 case 0x00:
2415 goto op_semantics_6;
2416 break;
2417 }
2418 break;
2419 case 0x95:
2420 GETBYTE ();
2421 switch (op[2] & 0x00)
2422 {
2423 case 0x00:
2424 goto op_semantics_6;
2425 break;
2426 }
2427 break;
2428 case 0x96:
2429 GETBYTE ();
2430 switch (op[2] & 0x00)
2431 {
2432 case 0x00:
2433 goto op_semantics_6;
2434 break;
2435 }
2436 break;
2437 case 0x97:
2438 GETBYTE ();
2439 switch (op[2] & 0x00)
2440 {
2441 case 0x00:
2442 goto op_semantics_6;
2443 break;
2444 }
2445 break;
2446 case 0xa0:
2447 GETBYTE ();
2448 switch (op[2] & 0xff)
2449 {
2450 case 0x00:
2451 GETBYTE ();
2452 switch (op[3] & 0x00)
2453 {
2454 case 0x00:
2455 goto op_semantics_7;
2456 break;
2457 }
2458 break;
2459 case 0x02:
2460 GETBYTE ();
2461 switch (op[3] & 0x00)
2462 {
2463 case 0x00:
2464 op_semantics_19:
2465 {
2466 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2467 #line 498 "rx-decode.opc"
2468 int ss AU = op[1] & 0x03;
2469 #line 498 "rx-decode.opc"
2470 int rsrc AU = (op[3] >> 4) & 0x0f;
2471 #line 498 "rx-decode.opc"
2472 int rdst AU = op[3] & 0x0f;
2473 if (trace)
2474 {
2475 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2476 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2477 op[0], op[1], op[2], op[3]);
2478 printf (" ss = 0x%x,", ss);
2479 printf (" rsrc = 0x%x,", rsrc);
2480 printf (" rdst = 0x%x\n", rdst);
2481 }
2482 SYNTAX("adc %1%S1, %0");
2483 #line 498 "rx-decode.opc"
2484 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2485
2486 /*----------------------------------------------------------------------*/
2487 /* ADD */
2488
2489 }
2490 break;
2491 }
2492 break;
2493 case 0x04:
2494 GETBYTE ();
2495 switch (op[3] & 0x00)
2496 {
2497 case 0x00:
2498 goto op_semantics_8;
2499 break;
2500 }
2501 break;
2502 case 0x05:
2503 GETBYTE ();
2504 switch (op[3] & 0x00)
2505 {
2506 case 0x00:
2507 goto op_semantics_9;
2508 break;
2509 }
2510 break;
2511 case 0x06:
2512 GETBYTE ();
2513 switch (op[3] & 0x00)
2514 {
2515 case 0x00:
2516 goto op_semantics_10;
2517 break;
2518 }
2519 break;
2520 case 0x07:
2521 GETBYTE ();
2522 switch (op[3] & 0x00)
2523 {
2524 case 0x00:
2525 goto op_semantics_11;
2526 break;
2527 }
2528 break;
2529 case 0x08:
2530 GETBYTE ();
2531 switch (op[3] & 0x00)
2532 {
2533 case 0x00:
2534 goto op_semantics_12;
2535 break;
2536 }
2537 break;
2538 case 0x09:
2539 GETBYTE ();
2540 switch (op[3] & 0x00)
2541 {
2542 case 0x00:
2543 goto op_semantics_13;
2544 break;
2545 }
2546 break;
2547 case 0x0c:
2548 GETBYTE ();
2549 switch (op[3] & 0x00)
2550 {
2551 case 0x00:
2552 goto op_semantics_14;
2553 break;
2554 }
2555 break;
2556 case 0x0d:
2557 GETBYTE ();
2558 switch (op[3] & 0x00)
2559 {
2560 case 0x00:
2561 goto op_semantics_15;
2562 break;
2563 }
2564 break;
2565 case 0x10:
2566 GETBYTE ();
2567 switch (op[3] & 0x00)
2568 {
2569 case 0x00:
2570 goto op_semantics_16;
2571 break;
2572 }
2573 break;
2574 case 0x11:
2575 GETBYTE ();
2576 switch (op[3] & 0x00)
2577 {
2578 case 0x00:
2579 goto op_semantics_17;
2580 break;
2581 }
2582 break;
2583 case 0x15:
2584 GETBYTE ();
2585 switch (op[3] & 0x00)
2586 {
2587 case 0x00:
2588 goto op_semantics_18;
2589 break;
2590 }
2591 break;
2592 default: UNSUPPORTED(); break;
2593 }
2594 break;
2595 case 0xa1:
2596 GETBYTE ();
2597 switch (op[2] & 0xff)
2598 {
2599 case 0x00:
2600 GETBYTE ();
2601 switch (op[3] & 0x00)
2602 {
2603 case 0x00:
2604 goto op_semantics_7;
2605 break;
2606 }
2607 break;
2608 case 0x02:
2609 GETBYTE ();
2610 switch (op[3] & 0x00)
2611 {
2612 case 0x00:
2613 goto op_semantics_19;
2614 break;
2615 }
2616 break;
2617 case 0x04:
2618 GETBYTE ();
2619 switch (op[3] & 0x00)
2620 {
2621 case 0x00:
2622 goto op_semantics_8;
2623 break;
2624 }
2625 break;
2626 case 0x05:
2627 GETBYTE ();
2628 switch (op[3] & 0x00)
2629 {
2630 case 0x00:
2631 goto op_semantics_9;
2632 break;
2633 }
2634 break;
2635 case 0x06:
2636 GETBYTE ();
2637 switch (op[3] & 0x00)
2638 {
2639 case 0x00:
2640 goto op_semantics_10;
2641 break;
2642 }
2643 break;
2644 case 0x07:
2645 GETBYTE ();
2646 switch (op[3] & 0x00)
2647 {
2648 case 0x00:
2649 goto op_semantics_11;
2650 break;
2651 }
2652 break;
2653 case 0x08:
2654 GETBYTE ();
2655 switch (op[3] & 0x00)
2656 {
2657 case 0x00:
2658 goto op_semantics_12;
2659 break;
2660 }
2661 break;
2662 case 0x09:
2663 GETBYTE ();
2664 switch (op[3] & 0x00)
2665 {
2666 case 0x00:
2667 goto op_semantics_13;
2668 break;
2669 }
2670 break;
2671 case 0x0c:
2672 GETBYTE ();
2673 switch (op[3] & 0x00)
2674 {
2675 case 0x00:
2676 goto op_semantics_14;
2677 break;
2678 }
2679 break;
2680 case 0x0d:
2681 GETBYTE ();
2682 switch (op[3] & 0x00)
2683 {
2684 case 0x00:
2685 goto op_semantics_15;
2686 break;
2687 }
2688 break;
2689 case 0x10:
2690 GETBYTE ();
2691 switch (op[3] & 0x00)
2692 {
2693 case 0x00:
2694 goto op_semantics_16;
2695 break;
2696 }
2697 break;
2698 case 0x11:
2699 GETBYTE ();
2700 switch (op[3] & 0x00)
2701 {
2702 case 0x00:
2703 goto op_semantics_17;
2704 break;
2705 }
2706 break;
2707 case 0x15:
2708 GETBYTE ();
2709 switch (op[3] & 0x00)
2710 {
2711 case 0x00:
2712 goto op_semantics_18;
2713 break;
2714 }
2715 break;
2716 default: UNSUPPORTED(); break;
2717 }
2718 break;
2719 case 0xa2:
2720 GETBYTE ();
2721 switch (op[2] & 0xff)
2722 {
2723 case 0x00:
2724 GETBYTE ();
2725 switch (op[3] & 0x00)
2726 {
2727 case 0x00:
2728 goto op_semantics_7;
2729 break;
2730 }
2731 break;
2732 case 0x02:
2733 GETBYTE ();
2734 switch (op[3] & 0x00)
2735 {
2736 case 0x00:
2737 goto op_semantics_19;
2738 break;
2739 }
2740 break;
2741 case 0x04:
2742 GETBYTE ();
2743 switch (op[3] & 0x00)
2744 {
2745 case 0x00:
2746 goto op_semantics_8;
2747 break;
2748 }
2749 break;
2750 case 0x05:
2751 GETBYTE ();
2752 switch (op[3] & 0x00)
2753 {
2754 case 0x00:
2755 goto op_semantics_9;
2756 break;
2757 }
2758 break;
2759 case 0x06:
2760 GETBYTE ();
2761 switch (op[3] & 0x00)
2762 {
2763 case 0x00:
2764 goto op_semantics_10;
2765 break;
2766 }
2767 break;
2768 case 0x07:
2769 GETBYTE ();
2770 switch (op[3] & 0x00)
2771 {
2772 case 0x00:
2773 goto op_semantics_11;
2774 break;
2775 }
2776 break;
2777 case 0x08:
2778 GETBYTE ();
2779 switch (op[3] & 0x00)
2780 {
2781 case 0x00:
2782 goto op_semantics_12;
2783 break;
2784 }
2785 break;
2786 case 0x09:
2787 GETBYTE ();
2788 switch (op[3] & 0x00)
2789 {
2790 case 0x00:
2791 goto op_semantics_13;
2792 break;
2793 }
2794 break;
2795 case 0x0c:
2796 GETBYTE ();
2797 switch (op[3] & 0x00)
2798 {
2799 case 0x00:
2800 goto op_semantics_14;
2801 break;
2802 }
2803 break;
2804 case 0x0d:
2805 GETBYTE ();
2806 switch (op[3] & 0x00)
2807 {
2808 case 0x00:
2809 goto op_semantics_15;
2810 break;
2811 }
2812 break;
2813 case 0x10:
2814 GETBYTE ();
2815 switch (op[3] & 0x00)
2816 {
2817 case 0x00:
2818 goto op_semantics_16;
2819 break;
2820 }
2821 break;
2822 case 0x11:
2823 GETBYTE ();
2824 switch (op[3] & 0x00)
2825 {
2826 case 0x00:
2827 goto op_semantics_17;
2828 break;
2829 }
2830 break;
2831 case 0x15:
2832 GETBYTE ();
2833 switch (op[3] & 0x00)
2834 {
2835 case 0x00:
2836 goto op_semantics_18;
2837 break;
2838 }
2839 break;
2840 default: UNSUPPORTED(); break;
2841 }
2842 break;
2843 case 0xa3:
2844 GETBYTE ();
2845 switch (op[2] & 0xff)
2846 {
2847 case 0x00:
2848 GETBYTE ();
2849 switch (op[3] & 0x00)
2850 {
2851 case 0x00:
2852 goto op_semantics_7;
2853 break;
2854 }
2855 break;
2856 case 0x02:
2857 GETBYTE ();
2858 switch (op[3] & 0x00)
2859 {
2860 case 0x00:
2861 goto op_semantics_19;
2862 break;
2863 }
2864 break;
2865 case 0x04:
2866 GETBYTE ();
2867 switch (op[3] & 0x00)
2868 {
2869 case 0x00:
2870 goto op_semantics_8;
2871 break;
2872 }
2873 break;
2874 case 0x05:
2875 GETBYTE ();
2876 switch (op[3] & 0x00)
2877 {
2878 case 0x00:
2879 goto op_semantics_9;
2880 break;
2881 }
2882 break;
2883 case 0x06:
2884 GETBYTE ();
2885 switch (op[3] & 0x00)
2886 {
2887 case 0x00:
2888 goto op_semantics_10;
2889 break;
2890 }
2891 break;
2892 case 0x07:
2893 GETBYTE ();
2894 switch (op[3] & 0x00)
2895 {
2896 case 0x00:
2897 goto op_semantics_11;
2898 break;
2899 }
2900 break;
2901 case 0x08:
2902 GETBYTE ();
2903 switch (op[3] & 0x00)
2904 {
2905 case 0x00:
2906 goto op_semantics_12;
2907 break;
2908 }
2909 break;
2910 case 0x09:
2911 GETBYTE ();
2912 switch (op[3] & 0x00)
2913 {
2914 case 0x00:
2915 goto op_semantics_13;
2916 break;
2917 }
2918 break;
2919 case 0x0c:
2920 GETBYTE ();
2921 switch (op[3] & 0x00)
2922 {
2923 case 0x00:
2924 goto op_semantics_14;
2925 break;
2926 }
2927 break;
2928 case 0x0d:
2929 GETBYTE ();
2930 switch (op[3] & 0x00)
2931 {
2932 case 0x00:
2933 goto op_semantics_15;
2934 break;
2935 }
2936 break;
2937 case 0x10:
2938 GETBYTE ();
2939 switch (op[3] & 0x00)
2940 {
2941 case 0x00:
2942 goto op_semantics_16;
2943 break;
2944 }
2945 break;
2946 case 0x11:
2947 GETBYTE ();
2948 switch (op[3] & 0x00)
2949 {
2950 case 0x00:
2951 goto op_semantics_17;
2952 break;
2953 }
2954 break;
2955 case 0x15:
2956 GETBYTE ();
2957 switch (op[3] & 0x00)
2958 {
2959 case 0x00:
2960 goto op_semantics_18;
2961 break;
2962 }
2963 break;
2964 default: UNSUPPORTED(); break;
2965 }
2966 break;
2967 case 0xc0:
2968 GETBYTE ();
2969 switch (op[2] & 0x00)
2970 {
2971 case 0x00:
2972 goto op_semantics_1;
2973 break;
2974 }
2975 break;
2976 case 0xc1:
2977 GETBYTE ();
2978 switch (op[2] & 0x00)
2979 {
2980 case 0x00:
2981 goto op_semantics_1;
2982 break;
2983 }
2984 break;
2985 case 0xc2:
2986 GETBYTE ();
2987 switch (op[2] & 0x00)
2988 {
2989 case 0x00:
2990 goto op_semantics_1;
2991 break;
2992 }
2993 break;
2994 case 0xc3:
2995 GETBYTE ();
2996 switch (op[2] & 0x00)
2997 {
2998 case 0x00:
2999 goto op_semantics_1;
3000 break;
3001 }
3002 break;
3003 case 0xc4:
3004 GETBYTE ();
3005 switch (op[2] & 0x00)
3006 {
3007 case 0x00:
3008 goto op_semantics_2;
3009 break;
3010 }
3011 break;
3012 case 0xc5:
3013 GETBYTE ();
3014 switch (op[2] & 0x00)
3015 {
3016 case 0x00:
3017 goto op_semantics_2;
3018 break;
3019 }
3020 break;
3021 case 0xc6:
3022 GETBYTE ();
3023 switch (op[2] & 0x00)
3024 {
3025 case 0x00:
3026 goto op_semantics_2;
3027 break;
3028 }
3029 break;
3030 case 0xc7:
3031 GETBYTE ();
3032 switch (op[2] & 0x00)
3033 {
3034 case 0x00:
3035 goto op_semantics_2;
3036 break;
3037 }
3038 break;
3039 case 0xc8:
3040 GETBYTE ();
3041 switch (op[2] & 0x00)
3042 {
3043 case 0x00:
3044 goto op_semantics_3;
3045 break;
3046 }
3047 break;
3048 case 0xc9:
3049 GETBYTE ();
3050 switch (op[2] & 0x00)
3051 {
3052 case 0x00:
3053 goto op_semantics_3;
3054 break;
3055 }
3056 break;
3057 case 0xca:
3058 GETBYTE ();
3059 switch (op[2] & 0x00)
3060 {
3061 case 0x00:
3062 goto op_semantics_3;
3063 break;
3064 }
3065 break;
3066 case 0xcb:
3067 GETBYTE ();
3068 switch (op[2] & 0x00)
3069 {
3070 case 0x00:
3071 goto op_semantics_3;
3072 break;
3073 }
3074 break;
3075 case 0xcc:
3076 GETBYTE ();
3077 switch (op[2] & 0x00)
3078 {
3079 case 0x00:
3080 goto op_semantics_4;
3081 break;
3082 }
3083 break;
3084 case 0xcd:
3085 GETBYTE ();
3086 switch (op[2] & 0x00)
3087 {
3088 case 0x00:
3089 goto op_semantics_4;
3090 break;
3091 }
3092 break;
3093 case 0xce:
3094 GETBYTE ();
3095 switch (op[2] & 0x00)
3096 {
3097 case 0x00:
3098 goto op_semantics_4;
3099 break;
3100 }
3101 break;
3102 case 0xcf:
3103 GETBYTE ();
3104 switch (op[2] & 0x00)
3105 {
3106 case 0x00:
3107 goto op_semantics_4;
3108 break;
3109 }
3110 break;
3111 case 0xd0:
3112 GETBYTE ();
3113 switch (op[2] & 0x00)
3114 {
3115 case 0x00:
3116 goto op_semantics_5;
3117 break;
3118 }
3119 break;
3120 case 0xd1:
3121 GETBYTE ();
3122 switch (op[2] & 0x00)
3123 {
3124 case 0x00:
3125 goto op_semantics_5;
3126 break;
3127 }
3128 break;
3129 case 0xd2:
3130 GETBYTE ();
3131 switch (op[2] & 0x00)
3132 {
3133 case 0x00:
3134 goto op_semantics_5;
3135 break;
3136 }
3137 break;
3138 case 0xd3:
3139 GETBYTE ();
3140 switch (op[2] & 0x00)
3141 {
3142 case 0x00:
3143 goto op_semantics_5;
3144 break;
3145 }
3146 break;
3147 case 0xd4:
3148 GETBYTE ();
3149 switch (op[2] & 0x00)
3150 {
3151 case 0x00:
3152 goto op_semantics_6;
3153 break;
3154 }
3155 break;
3156 case 0xd5:
3157 GETBYTE ();
3158 switch (op[2] & 0x00)
3159 {
3160 case 0x00:
3161 goto op_semantics_6;
3162 break;
3163 }
3164 break;
3165 case 0xd6:
3166 GETBYTE ();
3167 switch (op[2] & 0x00)
3168 {
3169 case 0x00:
3170 goto op_semantics_6;
3171 break;
3172 }
3173 break;
3174 case 0xd7:
3175 GETBYTE ();
3176 switch (op[2] & 0x00)
3177 {
3178 case 0x00:
3179 goto op_semantics_6;
3180 break;
3181 }
3182 break;
3183 case 0xe0:
3184 GETBYTE ();
3185 switch (op[2] & 0xff)
3186 {
3187 case 0x00:
3188 GETBYTE ();
3189 switch (op[3] & 0x00)
3190 {
3191 case 0x00:
3192 goto op_semantics_7;
3193 break;
3194 }
3195 break;
3196 case 0x04:
3197 GETBYTE ();
3198 switch (op[3] & 0x00)
3199 {
3200 case 0x00:
3201 goto op_semantics_8;
3202 break;
3203 }
3204 break;
3205 case 0x05:
3206 GETBYTE ();
3207 switch (op[3] & 0x00)
3208 {
3209 case 0x00:
3210 goto op_semantics_9;
3211 break;
3212 }
3213 break;
3214 case 0x06:
3215 GETBYTE ();
3216 switch (op[3] & 0x00)
3217 {
3218 case 0x00:
3219 goto op_semantics_10;
3220 break;
3221 }
3222 break;
3223 case 0x07:
3224 GETBYTE ();
3225 switch (op[3] & 0x00)
3226 {
3227 case 0x00:
3228 goto op_semantics_11;
3229 break;
3230 }
3231 break;
3232 case 0x08:
3233 GETBYTE ();
3234 switch (op[3] & 0x00)
3235 {
3236 case 0x00:
3237 goto op_semantics_12;
3238 break;
3239 }
3240 break;
3241 case 0x09:
3242 GETBYTE ();
3243 switch (op[3] & 0x00)
3244 {
3245 case 0x00:
3246 goto op_semantics_13;
3247 break;
3248 }
3249 break;
3250 case 0x0c:
3251 GETBYTE ();
3252 switch (op[3] & 0x00)
3253 {
3254 case 0x00:
3255 goto op_semantics_14;
3256 break;
3257 }
3258 break;
3259 case 0x0d:
3260 GETBYTE ();
3261 switch (op[3] & 0x00)
3262 {
3263 case 0x00:
3264 goto op_semantics_15;
3265 break;
3266 }
3267 break;
3268 case 0x10:
3269 GETBYTE ();
3270 switch (op[3] & 0x00)
3271 {
3272 case 0x00:
3273 goto op_semantics_16;
3274 break;
3275 }
3276 break;
3277 case 0x11:
3278 GETBYTE ();
3279 switch (op[3] & 0x00)
3280 {
3281 case 0x00:
3282 goto op_semantics_17;
3283 break;
3284 }
3285 break;
3286 case 0x15:
3287 GETBYTE ();
3288 switch (op[3] & 0x00)
3289 {
3290 case 0x00:
3291 goto op_semantics_18;
3292 break;
3293 }
3294 break;
3295 default: UNSUPPORTED(); break;
3296 }
3297 break;
3298 case 0xe1:
3299 GETBYTE ();
3300 switch (op[2] & 0xff)
3301 {
3302 case 0x00:
3303 GETBYTE ();
3304 switch (op[3] & 0x00)
3305 {
3306 case 0x00:
3307 goto op_semantics_7;
3308 break;
3309 }
3310 break;
3311 case 0x04:
3312 GETBYTE ();
3313 switch (op[3] & 0x00)
3314 {
3315 case 0x00:
3316 goto op_semantics_8;
3317 break;
3318 }
3319 break;
3320 case 0x05:
3321 GETBYTE ();
3322 switch (op[3] & 0x00)
3323 {
3324 case 0x00:
3325 goto op_semantics_9;
3326 break;
3327 }
3328 break;
3329 case 0x06:
3330 GETBYTE ();
3331 switch (op[3] & 0x00)
3332 {
3333 case 0x00:
3334 goto op_semantics_10;
3335 break;
3336 }
3337 break;
3338 case 0x07:
3339 GETBYTE ();
3340 switch (op[3] & 0x00)
3341 {
3342 case 0x00:
3343 goto op_semantics_11;
3344 break;
3345 }
3346 break;
3347 case 0x08:
3348 GETBYTE ();
3349 switch (op[3] & 0x00)
3350 {
3351 case 0x00:
3352 goto op_semantics_12;
3353 break;
3354 }
3355 break;
3356 case 0x09:
3357 GETBYTE ();
3358 switch (op[3] & 0x00)
3359 {
3360 case 0x00:
3361 goto op_semantics_13;
3362 break;
3363 }
3364 break;
3365 case 0x0c:
3366 GETBYTE ();
3367 switch (op[3] & 0x00)
3368 {
3369 case 0x00:
3370 goto op_semantics_14;
3371 break;
3372 }
3373 break;
3374 case 0x0d:
3375 GETBYTE ();
3376 switch (op[3] & 0x00)
3377 {
3378 case 0x00:
3379 goto op_semantics_15;
3380 break;
3381 }
3382 break;
3383 case 0x10:
3384 GETBYTE ();
3385 switch (op[3] & 0x00)
3386 {
3387 case 0x00:
3388 goto op_semantics_16;
3389 break;
3390 }
3391 break;
3392 case 0x11:
3393 GETBYTE ();
3394 switch (op[3] & 0x00)
3395 {
3396 case 0x00:
3397 goto op_semantics_17;
3398 break;
3399 }
3400 break;
3401 case 0x15:
3402 GETBYTE ();
3403 switch (op[3] & 0x00)
3404 {
3405 case 0x00:
3406 goto op_semantics_18;
3407 break;
3408 }
3409 break;
3410 default: UNSUPPORTED(); break;
3411 }
3412 break;
3413 case 0xe2:
3414 GETBYTE ();
3415 switch (op[2] & 0xff)
3416 {
3417 case 0x00:
3418 GETBYTE ();
3419 switch (op[3] & 0x00)
3420 {
3421 case 0x00:
3422 goto op_semantics_7;
3423 break;
3424 }
3425 break;
3426 case 0x04:
3427 GETBYTE ();
3428 switch (op[3] & 0x00)
3429 {
3430 case 0x00:
3431 goto op_semantics_8;
3432 break;
3433 }
3434 break;
3435 case 0x05:
3436 GETBYTE ();
3437 switch (op[3] & 0x00)
3438 {
3439 case 0x00:
3440 goto op_semantics_9;
3441 break;
3442 }
3443 break;
3444 case 0x06:
3445 GETBYTE ();
3446 switch (op[3] & 0x00)
3447 {
3448 case 0x00:
3449 goto op_semantics_10;
3450 break;
3451 }
3452 break;
3453 case 0x07:
3454 GETBYTE ();
3455 switch (op[3] & 0x00)
3456 {
3457 case 0x00:
3458 goto op_semantics_11;
3459 break;
3460 }
3461 break;
3462 case 0x08:
3463 GETBYTE ();
3464 switch (op[3] & 0x00)
3465 {
3466 case 0x00:
3467 goto op_semantics_12;
3468 break;
3469 }
3470 break;
3471 case 0x09:
3472 GETBYTE ();
3473 switch (op[3] & 0x00)
3474 {
3475 case 0x00:
3476 goto op_semantics_13;
3477 break;
3478 }
3479 break;
3480 case 0x0c:
3481 GETBYTE ();
3482 switch (op[3] & 0x00)
3483 {
3484 case 0x00:
3485 goto op_semantics_14;
3486 break;
3487 }
3488 break;
3489 case 0x0d:
3490 GETBYTE ();
3491 switch (op[3] & 0x00)
3492 {
3493 case 0x00:
3494 goto op_semantics_15;
3495 break;
3496 }
3497 break;
3498 case 0x10:
3499 GETBYTE ();
3500 switch (op[3] & 0x00)
3501 {
3502 case 0x00:
3503 goto op_semantics_16;
3504 break;
3505 }
3506 break;
3507 case 0x11:
3508 GETBYTE ();
3509 switch (op[3] & 0x00)
3510 {
3511 case 0x00:
3512 goto op_semantics_17;
3513 break;
3514 }
3515 break;
3516 case 0x15:
3517 GETBYTE ();
3518 switch (op[3] & 0x00)
3519 {
3520 case 0x00:
3521 goto op_semantics_18;
3522 break;
3523 }
3524 break;
3525 default: UNSUPPORTED(); break;
3526 }
3527 break;
3528 case 0xe3:
3529 GETBYTE ();
3530 switch (op[2] & 0xff)
3531 {
3532 case 0x00:
3533 GETBYTE ();
3534 switch (op[3] & 0x00)
3535 {
3536 case 0x00:
3537 goto op_semantics_7;
3538 break;
3539 }
3540 break;
3541 case 0x04:
3542 GETBYTE ();
3543 switch (op[3] & 0x00)
3544 {
3545 case 0x00:
3546 goto op_semantics_8;
3547 break;
3548 }
3549 break;
3550 case 0x05:
3551 GETBYTE ();
3552 switch (op[3] & 0x00)
3553 {
3554 case 0x00:
3555 goto op_semantics_9;
3556 break;
3557 }
3558 break;
3559 case 0x06:
3560 GETBYTE ();
3561 switch (op[3] & 0x00)
3562 {
3563 case 0x00:
3564 goto op_semantics_10;
3565 break;
3566 }
3567 break;
3568 case 0x07:
3569 GETBYTE ();
3570 switch (op[3] & 0x00)
3571 {
3572 case 0x00:
3573 goto op_semantics_11;
3574 break;
3575 }
3576 break;
3577 case 0x08:
3578 GETBYTE ();
3579 switch (op[3] & 0x00)
3580 {
3581 case 0x00:
3582 goto op_semantics_12;
3583 break;
3584 }
3585 break;
3586 case 0x09:
3587 GETBYTE ();
3588 switch (op[3] & 0x00)
3589 {
3590 case 0x00:
3591 goto op_semantics_13;
3592 break;
3593 }
3594 break;
3595 case 0x0c:
3596 GETBYTE ();
3597 switch (op[3] & 0x00)
3598 {
3599 case 0x00:
3600 goto op_semantics_14;
3601 break;
3602 }
3603 break;
3604 case 0x0d:
3605 GETBYTE ();
3606 switch (op[3] & 0x00)
3607 {
3608 case 0x00:
3609 goto op_semantics_15;
3610 break;
3611 }
3612 break;
3613 case 0x10:
3614 GETBYTE ();
3615 switch (op[3] & 0x00)
3616 {
3617 case 0x00:
3618 goto op_semantics_16;
3619 break;
3620 }
3621 break;
3622 case 0x11:
3623 GETBYTE ();
3624 switch (op[3] & 0x00)
3625 {
3626 case 0x00:
3627 goto op_semantics_17;
3628 break;
3629 }
3630 break;
3631 case 0x15:
3632 GETBYTE ();
3633 switch (op[3] & 0x00)
3634 {
3635 case 0x00:
3636 goto op_semantics_18;
3637 break;
3638 }
3639 break;
3640 default: UNSUPPORTED(); break;
3641 }
3642 break;
3643 default: UNSUPPORTED(); break;
3644 }
3645 break;
3646 case 0x08:
3647 case 0x09:
3648 case 0x0a:
3649 case 0x0b:
3650 case 0x0c:
3651 case 0x0d:
3652 case 0x0e:
3653 case 0x0f:
3654 {
3655 /** 0000 1dsp bra.s %a0 */
3656 #line 779 "rx-decode.opc"
3657 int dsp AU = op[0] & 0x07;
3658 if (trace)
3659 {
3660 printf ("\033[33m%s\033[0m %02x\n",
3661 "/** 0000 1dsp bra.s %a0 */",
3662 op[0]);
3663 printf (" dsp = 0x%x\n", dsp);
3664 }
3665 SYNTAX("bra.s %a0");
3666 #line 779 "rx-decode.opc"
3667 ID(branch); DC(pc + dsp3map[dsp]);
3668
3669 }
3670 break;
3671 case 0x10:
3672 case 0x11:
3673 case 0x12:
3674 case 0x13:
3675 case 0x14:
3676 case 0x15:
3677 case 0x16:
3678 case 0x17:
3679 case 0x18:
3680 case 0x19:
3681 case 0x1a:
3682 case 0x1b:
3683 case 0x1c:
3684 case 0x1d:
3685 case 0x1e:
3686 case 0x1f:
3687 {
3688 /** 0001 n dsp b%1.s %a0 */
3689 #line 769 "rx-decode.opc"
3690 int n AU = (op[0] >> 3) & 0x01;
3691 #line 769 "rx-decode.opc"
3692 int dsp AU = op[0] & 0x07;
3693 if (trace)
3694 {
3695 printf ("\033[33m%s\033[0m %02x\n",
3696 "/** 0001 n dsp b%1.s %a0 */",
3697 op[0]);
3698 printf (" n = 0x%x,", n);
3699 printf (" dsp = 0x%x\n", dsp);
3700 }
3701 SYNTAX("b%1.s %a0");
3702 #line 769 "rx-decode.opc"
3703 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3704
3705 }
3706 break;
3707 case 0x20:
3708 case 0x21:
3709 case 0x22:
3710 case 0x23:
3711 case 0x24:
3712 case 0x25:
3713 case 0x26:
3714 case 0x27:
3715 case 0x28:
3716 case 0x29:
3717 case 0x2a:
3718 case 0x2b:
3719 case 0x2c:
3720 case 0x2d:
3721 case 0x2f:
3722 {
3723 /** 0010 cond b%1.b %a0 */
3724 #line 772 "rx-decode.opc"
3725 int cond AU = op[0] & 0x0f;
3726 if (trace)
3727 {
3728 printf ("\033[33m%s\033[0m %02x\n",
3729 "/** 0010 cond b%1.b %a0 */",
3730 op[0]);
3731 printf (" cond = 0x%x\n", cond);
3732 }
3733 SYNTAX("b%1.b %a0");
3734 #line 772 "rx-decode.opc"
3735 ID(branch); Scc(cond); DC(pc + IMMex (1));
3736
3737 }
3738 break;
3739 case 0x2e:
3740 {
3741 /** 0010 1110 bra.b %a0 */
3742 if (trace)
3743 {
3744 printf ("\033[33m%s\033[0m %02x\n",
3745 "/** 0010 1110 bra.b %a0 */",
3746 op[0]);
3747 }
3748 SYNTAX("bra.b %a0");
3749 #line 782 "rx-decode.opc"
3750 ID(branch); DC(pc + IMMex(1));
3751
3752 }
3753 break;
3754 case 0x38:
3755 {
3756 /** 0011 1000 bra.w %a0 */
3757 if (trace)
3758 {
3759 printf ("\033[33m%s\033[0m %02x\n",
3760 "/** 0011 1000 bra.w %a0 */",
3761 op[0]);
3762 }
3763 SYNTAX("bra.w %a0");
3764 #line 785 "rx-decode.opc"
3765 ID(branch); DC(pc + IMMex(2));
3766
3767 }
3768 break;
3769 case 0x39:
3770 {
3771 /** 0011 1001 bsr.w %a0 */
3772 if (trace)
3773 {
3774 printf ("\033[33m%s\033[0m %02x\n",
3775 "/** 0011 1001 bsr.w %a0 */",
3776 op[0]);
3777 }
3778 SYNTAX("bsr.w %a0");
3779 #line 801 "rx-decode.opc"
3780 ID(jsr); DC(pc + IMMex(2));
3781
3782 }
3783 break;
3784 case 0x3a:
3785 case 0x3b:
3786 {
3787 /** 0011 101c b%1.w %a0 */
3788 #line 775 "rx-decode.opc"
3789 int c AU = op[0] & 0x01;
3790 if (trace)
3791 {
3792 printf ("\033[33m%s\033[0m %02x\n",
3793 "/** 0011 101c b%1.w %a0 */",
3794 op[0]);
3795 printf (" c = 0x%x\n", c);
3796 }
3797 SYNTAX("b%1.w %a0");
3798 #line 775 "rx-decode.opc"
3799 ID(branch); Scc(c); DC(pc + IMMex (2));
3800
3801
3802 }
3803 break;
3804 case 0x3c:
3805 GETBYTE ();
3806 switch (op[1] & 0x00)
3807 {
3808 case 0x00:
3809 op_semantics_20:
3810 {
3811 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3812 #line 311 "rx-decode.opc"
3813 int sz AU = op[0] & 0x03;
3814 #line 311 "rx-decode.opc"
3815 int d AU = (op[1] >> 7) & 0x01;
3816 #line 311 "rx-decode.opc"
3817 int dst AU = (op[1] >> 4) & 0x07;
3818 #line 311 "rx-decode.opc"
3819 int sppp AU = op[1] & 0x0f;
3820 if (trace)
3821 {
3822 printf ("\033[33m%s\033[0m %02x %02x\n",
3823 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3824 op[0], op[1]);
3825 printf (" sz = 0x%x,", sz);
3826 printf (" d = 0x%x,", d);
3827 printf (" dst = 0x%x,", dst);
3828 printf (" sppp = 0x%x\n", sppp);
3829 }
3830 SYNTAX("mov%s #%1, %0");
3831 #line 311 "rx-decode.opc"
3832 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3833
3834 }
3835 break;
3836 }
3837 break;
3838 case 0x3d:
3839 GETBYTE ();
3840 switch (op[1] & 0x00)
3841 {
3842 case 0x00:
3843 goto op_semantics_20;
3844 break;
3845 }
3846 break;
3847 case 0x3e:
3848 GETBYTE ();
3849 switch (op[1] & 0x00)
3850 {
3851 case 0x00:
3852 goto op_semantics_20;
3853 break;
3854 }
3855 break;
3856 case 0x3f:
3857 GETBYTE ();
3858 switch (op[1] & 0x00)
3859 {
3860 case 0x00:
3861 {
3862 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3863 #line 408 "rx-decode.opc"
3864 int rega AU = (op[1] >> 4) & 0x0f;
3865 #line 408 "rx-decode.opc"
3866 int regb AU = op[1] & 0x0f;
3867 if (trace)
3868 {
3869 printf ("\033[33m%s\033[0m %02x %02x\n",
3870 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3871 op[0], op[1]);
3872 printf (" rega = 0x%x,", rega);
3873 printf (" regb = 0x%x\n", regb);
3874 }
3875 SYNTAX("rtsd #%1, %2-%0");
3876 #line 408 "rx-decode.opc"
3877 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3878
3879 /*----------------------------------------------------------------------*/
3880 /* AND */
3881
3882 }
3883 break;
3884 }
3885 break;
3886 case 0x40:
3887 GETBYTE ();
3888 switch (op[1] & 0x00)
3889 {
3890 case 0x00:
3891 op_semantics_21:
3892 {
3893 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3894 #line 543 "rx-decode.opc"
3895 int ss AU = op[0] & 0x03;
3896 #line 543 "rx-decode.opc"
3897 int rsrc AU = (op[1] >> 4) & 0x0f;
3898 #line 543 "rx-decode.opc"
3899 int rdst AU = op[1] & 0x0f;
3900 if (trace)
3901 {
3902 printf ("\033[33m%s\033[0m %02x %02x\n",
3903 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3904 op[0], op[1]);
3905 printf (" ss = 0x%x,", ss);
3906 printf (" rsrc = 0x%x,", rsrc);
3907 printf (" rdst = 0x%x\n", rdst);
3908 }
3909 SYNTAX("sub %2%S2, %1");
3910 #line 543 "rx-decode.opc"
3911 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3912
3913 }
3914 break;
3915 }
3916 break;
3917 case 0x41:
3918 GETBYTE ();
3919 switch (op[1] & 0x00)
3920 {
3921 case 0x00:
3922 goto op_semantics_21;
3923 break;
3924 }
3925 break;
3926 case 0x42:
3927 GETBYTE ();
3928 switch (op[1] & 0x00)
3929 {
3930 case 0x00:
3931 goto op_semantics_21;
3932 break;
3933 }
3934 break;
3935 case 0x43:
3936 GETBYTE ();
3937 switch (op[1] & 0x00)
3938 {
3939 case 0x00:
3940 goto op_semantics_21;
3941 break;
3942 }
3943 break;
3944 case 0x44:
3945 GETBYTE ();
3946 switch (op[1] & 0x00)
3947 {
3948 case 0x00:
3949 op_semantics_22:
3950 {
3951 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3952 #line 531 "rx-decode.opc"
3953 int ss AU = op[0] & 0x03;
3954 #line 531 "rx-decode.opc"
3955 int rsrc AU = (op[1] >> 4) & 0x0f;
3956 #line 531 "rx-decode.opc"
3957 int rdst AU = op[1] & 0x0f;
3958 if (trace)
3959 {
3960 printf ("\033[33m%s\033[0m %02x %02x\n",
3961 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3962 op[0], op[1]);
3963 printf (" ss = 0x%x,", ss);
3964 printf (" rsrc = 0x%x,", rsrc);
3965 printf (" rdst = 0x%x\n", rdst);
3966 }
3967 SYNTAX("cmp %2%S2, %1");
3968 #line 531 "rx-decode.opc"
3969 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3970
3971 }
3972 break;
3973 }
3974 break;
3975 case 0x45:
3976 GETBYTE ();
3977 switch (op[1] & 0x00)
3978 {
3979 case 0x00:
3980 goto op_semantics_22;
3981 break;
3982 }
3983 break;
3984 case 0x46:
3985 GETBYTE ();
3986 switch (op[1] & 0x00)
3987 {
3988 case 0x00:
3989 goto op_semantics_22;
3990 break;
3991 }
3992 break;
3993 case 0x47:
3994 GETBYTE ();
3995 switch (op[1] & 0x00)
3996 {
3997 case 0x00:
3998 goto op_semantics_22;
3999 break;
4000 }
4001 break;
4002 case 0x48:
4003 GETBYTE ();
4004 switch (op[1] & 0x00)
4005 {
4006 case 0x00:
4007 op_semantics_23:
4008 {
4009 /** 0100 10ss rsrc rdst add %1%S1, %0 */
4010 #line 507 "rx-decode.opc"
4011 int ss AU = op[0] & 0x03;
4012 #line 507 "rx-decode.opc"
4013 int rsrc AU = (op[1] >> 4) & 0x0f;
4014 #line 507 "rx-decode.opc"
4015 int rdst AU = op[1] & 0x0f;
4016 if (trace)
4017 {
4018 printf ("\033[33m%s\033[0m %02x %02x\n",
4019 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
4020 op[0], op[1]);
4021 printf (" ss = 0x%x,", ss);
4022 printf (" rsrc = 0x%x,", rsrc);
4023 printf (" rdst = 0x%x\n", rdst);
4024 }
4025 SYNTAX("add %1%S1, %0");
4026 #line 507 "rx-decode.opc"
4027 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4028
4029 }
4030 break;
4031 }
4032 break;
4033 case 0x49:
4034 GETBYTE ();
4035 switch (op[1] & 0x00)
4036 {
4037 case 0x00:
4038 goto op_semantics_23;
4039 break;
4040 }
4041 break;
4042 case 0x4a:
4043 GETBYTE ();
4044 switch (op[1] & 0x00)
4045 {
4046 case 0x00:
4047 goto op_semantics_23;
4048 break;
4049 }
4050 break;
4051 case 0x4b:
4052 GETBYTE ();
4053 switch (op[1] & 0x00)
4054 {
4055 case 0x00:
4056 goto op_semantics_23;
4057 break;
4058 }
4059 break;
4060 case 0x4c:
4061 GETBYTE ();
4062 switch (op[1] & 0x00)
4063 {
4064 case 0x00:
4065 op_semantics_24:
4066 {
4067 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
4068 #line 650 "rx-decode.opc"
4069 int ss AU = op[0] & 0x03;
4070 #line 650 "rx-decode.opc"
4071 int rsrc AU = (op[1] >> 4) & 0x0f;
4072 #line 650 "rx-decode.opc"
4073 int rdst AU = op[1] & 0x0f;
4074 if (trace)
4075 {
4076 printf ("\033[33m%s\033[0m %02x %02x\n",
4077 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
4078 op[0], op[1]);
4079 printf (" ss = 0x%x,", ss);
4080 printf (" rsrc = 0x%x,", rsrc);
4081 printf (" rdst = 0x%x\n", rdst);
4082 }
4083 SYNTAX("mul %1%S1, %0");
4084 #line 650 "rx-decode.opc"
4085 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4086
4087 }
4088 break;
4089 }
4090 break;
4091 case 0x4d:
4092 GETBYTE ();
4093 switch (op[1] & 0x00)
4094 {
4095 case 0x00:
4096 goto op_semantics_24;
4097 break;
4098 }
4099 break;
4100 case 0x4e:
4101 GETBYTE ();
4102 switch (op[1] & 0x00)
4103 {
4104 case 0x00:
4105 goto op_semantics_24;
4106 break;
4107 }
4108 break;
4109 case 0x4f:
4110 GETBYTE ();
4111 switch (op[1] & 0x00)
4112 {
4113 case 0x00:
4114 goto op_semantics_24;
4115 break;
4116 }
4117 break;
4118 case 0x50:
4119 GETBYTE ();
4120 switch (op[1] & 0x00)
4121 {
4122 case 0x00:
4123 op_semantics_25:
4124 {
4125 /** 0101 00ss rsrc rdst and %1%S1, %0 */
4126 #line 420 "rx-decode.opc"
4127 int ss AU = op[0] & 0x03;
4128 #line 420 "rx-decode.opc"
4129 int rsrc AU = (op[1] >> 4) & 0x0f;
4130 #line 420 "rx-decode.opc"
4131 int rdst AU = op[1] & 0x0f;
4132 if (trace)
4133 {
4134 printf ("\033[33m%s\033[0m %02x %02x\n",
4135 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
4136 op[0], op[1]);
4137 printf (" ss = 0x%x,", ss);
4138 printf (" rsrc = 0x%x,", rsrc);
4139 printf (" rdst = 0x%x\n", rdst);
4140 }
4141 SYNTAX("and %1%S1, %0");
4142 #line 420 "rx-decode.opc"
4143 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4144
4145 }
4146 break;
4147 }
4148 break;
4149 case 0x51:
4150 GETBYTE ();
4151 switch (op[1] & 0x00)
4152 {
4153 case 0x00:
4154 goto op_semantics_25;
4155 break;
4156 }
4157 break;
4158 case 0x52:
4159 GETBYTE ();
4160 switch (op[1] & 0x00)
4161 {
4162 case 0x00:
4163 goto op_semantics_25;
4164 break;
4165 }
4166 break;
4167 case 0x53:
4168 GETBYTE ();
4169 switch (op[1] & 0x00)
4170 {
4171 case 0x00:
4172 goto op_semantics_25;
4173 break;
4174 }
4175 break;
4176 case 0x54:
4177 GETBYTE ();
4178 switch (op[1] & 0x00)
4179 {
4180 case 0x00:
4181 op_semantics_26:
4182 {
4183 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4184 #line 438 "rx-decode.opc"
4185 int ss AU = op[0] & 0x03;
4186 #line 438 "rx-decode.opc"
4187 int rsrc AU = (op[1] >> 4) & 0x0f;
4188 #line 438 "rx-decode.opc"
4189 int rdst AU = op[1] & 0x0f;
4190 if (trace)
4191 {
4192 printf ("\033[33m%s\033[0m %02x %02x\n",
4193 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4194 op[0], op[1]);
4195 printf (" ss = 0x%x,", ss);
4196 printf (" rsrc = 0x%x,", rsrc);
4197 printf (" rdst = 0x%x\n", rdst);
4198 }
4199 SYNTAX("or %1%S1, %0");
4200 #line 438 "rx-decode.opc"
4201 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4202
4203 }
4204 break;
4205 }
4206 break;
4207 case 0x55:
4208 GETBYTE ();
4209 switch (op[1] & 0x00)
4210 {
4211 case 0x00:
4212 goto op_semantics_26;
4213 break;
4214 }
4215 break;
4216 case 0x56:
4217 GETBYTE ();
4218 switch (op[1] & 0x00)
4219 {
4220 case 0x00:
4221 goto op_semantics_26;
4222 break;
4223 }
4224 break;
4225 case 0x57:
4226 GETBYTE ();
4227 switch (op[1] & 0x00)
4228 {
4229 case 0x00:
4230 goto op_semantics_26;
4231 break;
4232 }
4233 break;
4234 case 0x58:
4235 GETBYTE ();
4236 switch (op[1] & 0x00)
4237 {
4238 case 0x00:
4239 op_semantics_27:
4240 {
4241 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4242 #line 359 "rx-decode.opc"
4243 int s AU = (op[0] >> 2) & 0x01;
4244 #line 359 "rx-decode.opc"
4245 int ss AU = op[0] & 0x03;
4246 #line 359 "rx-decode.opc"
4247 int rsrc AU = (op[1] >> 4) & 0x0f;
4248 #line 359 "rx-decode.opc"
4249 int rdst AU = op[1] & 0x0f;
4250 if (trace)
4251 {
4252 printf ("\033[33m%s\033[0m %02x %02x\n",
4253 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4254 op[0], op[1]);
4255 printf (" s = 0x%x,", s);
4256 printf (" ss = 0x%x,", ss);
4257 printf (" rsrc = 0x%x,", rsrc);
4258 printf (" rdst = 0x%x\n", rdst);
4259 }
4260 SYNTAX("movu%s %1, %0");
4261 #line 359 "rx-decode.opc"
4262 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4263
4264 }
4265 break;
4266 }
4267 break;
4268 case 0x59:
4269 GETBYTE ();
4270 switch (op[1] & 0x00)
4271 {
4272 case 0x00:
4273 goto op_semantics_27;
4274 break;
4275 }
4276 break;
4277 case 0x5a:
4278 GETBYTE ();
4279 switch (op[1] & 0x00)
4280 {
4281 case 0x00:
4282 goto op_semantics_27;
4283 break;
4284 }
4285 break;
4286 case 0x5b:
4287 GETBYTE ();
4288 switch (op[1] & 0x00)
4289 {
4290 case 0x00:
4291 goto op_semantics_27;
4292 break;
4293 }
4294 break;
4295 case 0x5c:
4296 GETBYTE ();
4297 switch (op[1] & 0x00)
4298 {
4299 case 0x00:
4300 goto op_semantics_27;
4301 break;
4302 }
4303 break;
4304 case 0x5d:
4305 GETBYTE ();
4306 switch (op[1] & 0x00)
4307 {
4308 case 0x00:
4309 goto op_semantics_27;
4310 break;
4311 }
4312 break;
4313 case 0x5e:
4314 GETBYTE ();
4315 switch (op[1] & 0x00)
4316 {
4317 case 0x00:
4318 goto op_semantics_27;
4319 break;
4320 }
4321 break;
4322 case 0x5f:
4323 GETBYTE ();
4324 switch (op[1] & 0x00)
4325 {
4326 case 0x00:
4327 goto op_semantics_27;
4328 break;
4329 }
4330 break;
4331 case 0x60:
4332 GETBYTE ();
4333 switch (op[1] & 0x00)
4334 {
4335 case 0x00:
4336 {
4337 /** 0110 0000 immm rdst sub #%2, %0 */
4338 #line 540 "rx-decode.opc"
4339 int immm AU = (op[1] >> 4) & 0x0f;
4340 #line 540 "rx-decode.opc"
4341 int rdst AU = op[1] & 0x0f;
4342 if (trace)
4343 {
4344 printf ("\033[33m%s\033[0m %02x %02x\n",
4345 "/** 0110 0000 immm rdst sub #%2, %0 */",
4346 op[0], op[1]);
4347 printf (" immm = 0x%x,", immm);
4348 printf (" rdst = 0x%x\n", rdst);
4349 }
4350 SYNTAX("sub #%2, %0");
4351 #line 540 "rx-decode.opc"
4352 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4353
4354 }
4355 break;
4356 }
4357 break;
4358 case 0x61:
4359 GETBYTE ();
4360 switch (op[1] & 0x00)
4361 {
4362 case 0x00:
4363 {
4364 /** 0110 0001 immm rdst cmp #%2, %1 */
4365 #line 522 "rx-decode.opc"
4366 int immm AU = (op[1] >> 4) & 0x0f;
4367 #line 522 "rx-decode.opc"
4368 int rdst AU = op[1] & 0x0f;
4369 if (trace)
4370 {
4371 printf ("\033[33m%s\033[0m %02x %02x\n",
4372 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4373 op[0], op[1]);
4374 printf (" immm = 0x%x,", immm);
4375 printf (" rdst = 0x%x\n", rdst);
4376 }
4377 SYNTAX("cmp #%2, %1");
4378 #line 522 "rx-decode.opc"
4379 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4380
4381 }
4382 break;
4383 }
4384 break;
4385 case 0x62:
4386 GETBYTE ();
4387 switch (op[1] & 0x00)
4388 {
4389 case 0x00:
4390 {
4391 /** 0110 0010 immm rdst add #%1, %0 */
4392 #line 504 "rx-decode.opc"
4393 int immm AU = (op[1] >> 4) & 0x0f;
4394 #line 504 "rx-decode.opc"
4395 int rdst AU = op[1] & 0x0f;
4396 if (trace)
4397 {
4398 printf ("\033[33m%s\033[0m %02x %02x\n",
4399 "/** 0110 0010 immm rdst add #%1, %0 */",
4400 op[0], op[1]);
4401 printf (" immm = 0x%x,", immm);
4402 printf (" rdst = 0x%x\n", rdst);
4403 }
4404 SYNTAX("add #%1, %0");
4405 #line 504 "rx-decode.opc"
4406 ID(add); SC(immm); DR(rdst); F_OSZC;
4407
4408 }
4409 break;
4410 }
4411 break;
4412 case 0x63:
4413 GETBYTE ();
4414 switch (op[1] & 0x00)
4415 {
4416 case 0x00:
4417 {
4418 /** 0110 0011 immm rdst mul #%1, %0 */
4419 #line 616 "rx-decode.opc"
4420 int immm AU = (op[1] >> 4) & 0x0f;
4421 #line 616 "rx-decode.opc"
4422 int rdst AU = op[1] & 0x0f;
4423 if (trace)
4424 {
4425 printf ("\033[33m%s\033[0m %02x %02x\n",
4426 "/** 0110 0011 immm rdst mul #%1, %0 */",
4427 op[0], op[1]);
4428 printf (" immm = 0x%x,", immm);
4429 printf (" rdst = 0x%x\n", rdst);
4430 }
4431 SYNTAX("mul #%1, %0");
4432 #line 616 "rx-decode.opc"
4433 if (immm == 1 && rdst == 0)
4434 {
4435 ID(nop2);
4436 SYNTAX ("nop\t; mul\t#1, r0");
4437 }
4438 else
4439 {
4440 ID(mul);
4441 }
4442 DR(rdst); SC(immm); F_____;
4443
4444 }
4445 break;
4446 }
4447 break;
4448 case 0x64:
4449 GETBYTE ();
4450 switch (op[1] & 0x00)
4451 {
4452 case 0x00:
4453 {
4454 /** 0110 0100 immm rdst and #%1, %0 */
4455 #line 414 "rx-decode.opc"
4456 int immm AU = (op[1] >> 4) & 0x0f;
4457 #line 414 "rx-decode.opc"
4458 int rdst AU = op[1] & 0x0f;
4459 if (trace)
4460 {
4461 printf ("\033[33m%s\033[0m %02x %02x\n",
4462 "/** 0110 0100 immm rdst and #%1, %0 */",
4463 op[0], op[1]);
4464 printf (" immm = 0x%x,", immm);
4465 printf (" rdst = 0x%x\n", rdst);
4466 }
4467 SYNTAX("and #%1, %0");
4468 #line 414 "rx-decode.opc"
4469 ID(and); SC(immm); DR(rdst); F__SZ_;
4470
4471 }
4472 break;
4473 }
4474 break;
4475 case 0x65:
4476 GETBYTE ();
4477 switch (op[1] & 0x00)
4478 {
4479 case 0x00:
4480 {
4481 /** 0110 0101 immm rdst or #%1, %0 */
4482 #line 432 "rx-decode.opc"
4483 int immm AU = (op[1] >> 4) & 0x0f;
4484 #line 432 "rx-decode.opc"
4485 int rdst AU = op[1] & 0x0f;
4486 if (trace)
4487 {
4488 printf ("\033[33m%s\033[0m %02x %02x\n",
4489 "/** 0110 0101 immm rdst or #%1, %0 */",
4490 op[0], op[1]);
4491 printf (" immm = 0x%x,", immm);
4492 printf (" rdst = 0x%x\n", rdst);
4493 }
4494 SYNTAX("or #%1, %0");
4495 #line 432 "rx-decode.opc"
4496 ID(or); SC(immm); DR(rdst); F__SZ_;
4497
4498 }
4499 break;
4500 }
4501 break;
4502 case 0x66:
4503 GETBYTE ();
4504 switch (op[1] & 0x00)
4505 {
4506 case 0x00:
4507 {
4508 /** 0110 0110 immm rdst mov%s #%1, %0 */
4509 #line 308 "rx-decode.opc"
4510 int immm AU = (op[1] >> 4) & 0x0f;
4511 #line 308 "rx-decode.opc"
4512 int rdst AU = op[1] & 0x0f;
4513 if (trace)
4514 {
4515 printf ("\033[33m%s\033[0m %02x %02x\n",
4516 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4517 op[0], op[1]);
4518 printf (" immm = 0x%x,", immm);
4519 printf (" rdst = 0x%x\n", rdst);
4520 }
4521 SYNTAX("mov%s #%1, %0");
4522 #line 308 "rx-decode.opc"
4523 ID(mov); DR(rdst); SC(immm); F_____;
4524
4525 }
4526 break;
4527 }
4528 break;
4529 case 0x67:
4530 {
4531 /** 0110 0111 rtsd #%1 */
4532 if (trace)
4533 {
4534 printf ("\033[33m%s\033[0m %02x\n",
4535 "/** 0110 0111 rtsd #%1 */",
4536 op[0]);
4537 }
4538 SYNTAX("rtsd #%1");
4539 #line 405 "rx-decode.opc"
4540 ID(rtsd); SC(IMM(1) * 4);
4541
4542 }
4543 break;
4544 case 0x68:
4545 GETBYTE ();
4546 switch (op[1] & 0x00)
4547 {
4548 case 0x00:
4549 op_semantics_28:
4550 {
4551 /** 0110 100i mmmm rdst shlr #%2, %0 */
4552 #line 730 "rx-decode.opc"
4553 int i AU = op[0] & 0x01;
4554 #line 730 "rx-decode.opc"
4555 int mmmm AU = (op[1] >> 4) & 0x0f;
4556 #line 730 "rx-decode.opc"
4557 int rdst AU = op[1] & 0x0f;
4558 if (trace)
4559 {
4560 printf ("\033[33m%s\033[0m %02x %02x\n",
4561 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4562 op[0], op[1]);
4563 printf (" i = 0x%x,", i);
4564 printf (" mmmm = 0x%x,", mmmm);
4565 printf (" rdst = 0x%x\n", rdst);
4566 }
4567 SYNTAX("shlr #%2, %0");
4568 #line 730 "rx-decode.opc"
4569 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4570
4571 }
4572 break;
4573 }
4574 break;
4575 case 0x69:
4576 GETBYTE ();
4577 switch (op[1] & 0x00)
4578 {
4579 case 0x00:
4580 goto op_semantics_28;
4581 break;
4582 }
4583 break;
4584 case 0x6a:
4585 GETBYTE ();
4586 switch (op[1] & 0x00)
4587 {
4588 case 0x00:
4589 op_semantics_29:
4590 {
4591 /** 0110 101i mmmm rdst shar #%2, %0 */
4592 #line 720 "rx-decode.opc"
4593 int i AU = op[0] & 0x01;
4594 #line 720 "rx-decode.opc"
4595 int mmmm AU = (op[1] >> 4) & 0x0f;
4596 #line 720 "rx-decode.opc"
4597 int rdst AU = op[1] & 0x0f;
4598 if (trace)
4599 {
4600 printf ("\033[33m%s\033[0m %02x %02x\n",
4601 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4602 op[0], op[1]);
4603 printf (" i = 0x%x,", i);
4604 printf (" mmmm = 0x%x,", mmmm);
4605 printf (" rdst = 0x%x\n", rdst);
4606 }
4607 SYNTAX("shar #%2, %0");
4608 #line 720 "rx-decode.opc"
4609 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4610
4611 }
4612 break;
4613 }
4614 break;
4615 case 0x6b:
4616 GETBYTE ();
4617 switch (op[1] & 0x00)
4618 {
4619 case 0x00:
4620 goto op_semantics_29;
4621 break;
4622 }
4623 break;
4624 case 0x6c:
4625 GETBYTE ();
4626 switch (op[1] & 0x00)
4627 {
4628 case 0x00:
4629 op_semantics_30:
4630 {
4631 /** 0110 110i mmmm rdst shll #%2, %0 */
4632 #line 710 "rx-decode.opc"
4633 int i AU = op[0] & 0x01;
4634 #line 710 "rx-decode.opc"
4635 int mmmm AU = (op[1] >> 4) & 0x0f;
4636 #line 710 "rx-decode.opc"
4637 int rdst AU = op[1] & 0x0f;
4638 if (trace)
4639 {
4640 printf ("\033[33m%s\033[0m %02x %02x\n",
4641 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4642 op[0], op[1]);
4643 printf (" i = 0x%x,", i);
4644 printf (" mmmm = 0x%x,", mmmm);
4645 printf (" rdst = 0x%x\n", rdst);
4646 }
4647 SYNTAX("shll #%2, %0");
4648 #line 710 "rx-decode.opc"
4649 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4650
4651 }
4652 break;
4653 }
4654 break;
4655 case 0x6d:
4656 GETBYTE ();
4657 switch (op[1] & 0x00)
4658 {
4659 case 0x00:
4660 goto op_semantics_30;
4661 break;
4662 }
4663 break;
4664 case 0x6e:
4665 GETBYTE ();
4666 switch (op[1] & 0x00)
4667 {
4668 case 0x00:
4669 {
4670 /** 0110 1110 dsta dstb pushm %1-%2 */
4671 #line 372 "rx-decode.opc"
4672 int dsta AU = (op[1] >> 4) & 0x0f;
4673 #line 372 "rx-decode.opc"
4674 int dstb AU = op[1] & 0x0f;
4675 if (trace)
4676 {
4677 printf ("\033[33m%s\033[0m %02x %02x\n",
4678 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4679 op[0], op[1]);
4680 printf (" dsta = 0x%x,", dsta);
4681 printf (" dstb = 0x%x\n", dstb);
4682 }
4683 SYNTAX("pushm %1-%2");
4684 #line 372 "rx-decode.opc"
4685 ID(pushm); SR(dsta); S2R(dstb); F_____;
4686
4687 }
4688 break;
4689 }
4690 break;
4691 case 0x6f:
4692 GETBYTE ();
4693 switch (op[1] & 0x00)
4694 {
4695 case 0x00:
4696 {
4697 /** 0110 1111 dsta dstb popm %1-%2 */
4698 #line 369 "rx-decode.opc"
4699 int dsta AU = (op[1] >> 4) & 0x0f;
4700 #line 369 "rx-decode.opc"
4701 int dstb AU = op[1] & 0x0f;
4702 if (trace)
4703 {
4704 printf ("\033[33m%s\033[0m %02x %02x\n",
4705 "/** 0110 1111 dsta dstb popm %1-%2 */",
4706 op[0], op[1]);
4707 printf (" dsta = 0x%x,", dsta);
4708 printf (" dstb = 0x%x\n", dstb);
4709 }
4710 SYNTAX("popm %1-%2");
4711 #line 369 "rx-decode.opc"
4712 ID(popm); SR(dsta); S2R(dstb); F_____;
4713
4714 }
4715 break;
4716 }
4717 break;
4718 case 0x70:
4719 GETBYTE ();
4720 switch (op[1] & 0x00)
4721 {
4722 case 0x00:
4723 op_semantics_31:
4724 {
4725 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4726 #line 513 "rx-decode.opc"
4727 int im AU = op[0] & 0x03;
4728 #line 513 "rx-decode.opc"
4729 int rsrc AU = (op[1] >> 4) & 0x0f;
4730 #line 513 "rx-decode.opc"
4731 int rdst AU = op[1] & 0x0f;
4732 if (trace)
4733 {
4734 printf ("\033[33m%s\033[0m %02x %02x\n",
4735 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4736 op[0], op[1]);
4737 printf (" im = 0x%x,", im);
4738 printf (" rsrc = 0x%x,", rsrc);
4739 printf (" rdst = 0x%x\n", rdst);
4740 }
4741 SYNTAX("add #%1, %2, %0");
4742 #line 513 "rx-decode.opc"
4743 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4744
4745 }
4746 break;
4747 }
4748 break;
4749 case 0x71:
4750 GETBYTE ();
4751 switch (op[1] & 0x00)
4752 {
4753 case 0x00:
4754 goto op_semantics_31;
4755 break;
4756 }
4757 break;
4758 case 0x72:
4759 GETBYTE ();
4760 switch (op[1] & 0x00)
4761 {
4762 case 0x00:
4763 goto op_semantics_31;
4764 break;
4765 }
4766 break;
4767 case 0x73:
4768 GETBYTE ();
4769 switch (op[1] & 0x00)
4770 {
4771 case 0x00:
4772 goto op_semantics_31;
4773 break;
4774 }
4775 break;
4776 case 0x74:
4777 GETBYTE ();
4778 switch (op[1] & 0xf0)
4779 {
4780 case 0x00:
4781 op_semantics_32:
4782 {
4783 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4784 #line 525 "rx-decode.opc"
4785 int im AU = op[0] & 0x03;
4786 #line 525 "rx-decode.opc"
4787 int rsrc AU = op[1] & 0x0f;
4788 if (trace)
4789 {
4790 printf ("\033[33m%s\033[0m %02x %02x\n",
4791 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4792 op[0], op[1]);
4793 printf (" im = 0x%x,", im);
4794 printf (" rsrc = 0x%x\n", rsrc);
4795 }
4796 SYNTAX("cmp #%2, %1%S1");
4797 #line 525 "rx-decode.opc"
4798 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4799
4800 }
4801 break;
4802 case 0x10:
4803 op_semantics_33:
4804 {
4805 /** 0111 01im 0001rdst mul #%1, %0 */
4806 #line 628 "rx-decode.opc"
4807 int im AU = op[0] & 0x03;
4808 #line 628 "rx-decode.opc"
4809 int rdst AU = op[1] & 0x0f;
4810 if (trace)
4811 {
4812 printf ("\033[33m%s\033[0m %02x %02x\n",
4813 "/** 0111 01im 0001rdst mul #%1, %0 */",
4814 op[0], op[1]);
4815 printf (" im = 0x%x,", im);
4816 printf (" rdst = 0x%x\n", rdst);
4817 }
4818 SYNTAX("mul #%1, %0");
4819 #line 628 "rx-decode.opc"
4820 int val = IMMex(im);
4821 if (val == 1 && rdst == 0)
4822 {
4823 SYNTAX("nop\t; mul\t#1, r0");
4824 switch (im)
4825 {
4826 case 2: ID(nop4); break;
4827 case 3: ID(nop5); break;
4828 case 0: ID(nop6); break;
4829 default:
4830 ID(mul);
4831 SYNTAX("mul #%1, %0");
4832 break;
4833 }
4834 }
4835 else
4836 {
4837 ID(mul);
4838 }
4839 DR(rdst); SC(val); F_____;
4840
4841 }
4842 break;
4843 case 0x20:
4844 op_semantics_34:
4845 {
4846 /** 0111 01im 0010 rdst and #%1, %0 */
4847 #line 417 "rx-decode.opc"
4848 int im AU = op[0] & 0x03;
4849 #line 417 "rx-decode.opc"
4850 int rdst AU = op[1] & 0x0f;
4851 if (trace)
4852 {
4853 printf ("\033[33m%s\033[0m %02x %02x\n",
4854 "/** 0111 01im 0010 rdst and #%1, %0 */",
4855 op[0], op[1]);
4856 printf (" im = 0x%x,", im);
4857 printf (" rdst = 0x%x\n", rdst);
4858 }
4859 SYNTAX("and #%1, %0");
4860 #line 417 "rx-decode.opc"
4861 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4862
4863 }
4864 break;
4865 case 0x30:
4866 op_semantics_35:
4867 {
4868 /** 0111 01im 0011 rdst or #%1, %0 */
4869 #line 435 "rx-decode.opc"
4870 int im AU = op[0] & 0x03;
4871 #line 435 "rx-decode.opc"
4872 int rdst AU = op[1] & 0x0f;
4873 if (trace)
4874 {
4875 printf ("\033[33m%s\033[0m %02x %02x\n",
4876 "/** 0111 01im 0011 rdst or #%1, %0 */",
4877 op[0], op[1]);
4878 printf (" im = 0x%x,", im);
4879 printf (" rdst = 0x%x\n", rdst);
4880 }
4881 SYNTAX("or #%1, %0");
4882 #line 435 "rx-decode.opc"
4883 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4884
4885 }
4886 break;
4887 default: UNSUPPORTED(); break;
4888 }
4889 break;
4890 case 0x75:
4891 GETBYTE ();
4892 switch (op[1] & 0xff)
4893 {
4894 case 0x00:
4895 case 0x01:
4896 case 0x02:
4897 case 0x03:
4898 case 0x04:
4899 case 0x05:
4900 case 0x06:
4901 case 0x07:
4902 case 0x08:
4903 case 0x09:
4904 case 0x0a:
4905 case 0x0b:
4906 case 0x0c:
4907 case 0x0d:
4908 case 0x0e:
4909 case 0x0f:
4910 goto op_semantics_32;
4911 break;
4912 case 0x10:
4913 case 0x11:
4914 case 0x12:
4915 case 0x13:
4916 case 0x14:
4917 case 0x15:
4918 case 0x16:
4919 case 0x17:
4920 case 0x18:
4921 case 0x19:
4922 case 0x1a:
4923 case 0x1b:
4924 case 0x1c:
4925 case 0x1d:
4926 case 0x1e:
4927 case 0x1f:
4928 goto op_semantics_33;
4929 break;
4930 case 0x20:
4931 case 0x21:
4932 case 0x22:
4933 case 0x23:
4934 case 0x24:
4935 case 0x25:
4936 case 0x26:
4937 case 0x27:
4938 case 0x28:
4939 case 0x29:
4940 case 0x2a:
4941 case 0x2b:
4942 case 0x2c:
4943 case 0x2d:
4944 case 0x2e:
4945 case 0x2f:
4946 goto op_semantics_34;
4947 break;
4948 case 0x30:
4949 case 0x31:
4950 case 0x32:
4951 case 0x33:
4952 case 0x34:
4953 case 0x35:
4954 case 0x36:
4955 case 0x37:
4956 case 0x38:
4957 case 0x39:
4958 case 0x3a:
4959 case 0x3b:
4960 case 0x3c:
4961 case 0x3d:
4962 case 0x3e:
4963 case 0x3f:
4964 goto op_semantics_35;
4965 break;
4966 case 0x40:
4967 case 0x41:
4968 case 0x42:
4969 case 0x43:
4970 case 0x44:
4971 case 0x45:
4972 case 0x46:
4973 case 0x47:
4974 case 0x48:
4975 case 0x49:
4976 case 0x4a:
4977 case 0x4b:
4978 case 0x4c:
4979 case 0x4d:
4980 case 0x4e:
4981 case 0x4f:
4982 {
4983 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4984 #line 289 "rx-decode.opc"
4985 int rdst AU = op[1] & 0x0f;
4986 if (trace)
4987 {
4988 printf ("\033[33m%s\033[0m %02x %02x\n",
4989 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4990 op[0], op[1]);
4991 printf (" rdst = 0x%x\n", rdst);
4992 }
4993 SYNTAX("mov%s #%1, %0");
4994 #line 289 "rx-decode.opc"
4995 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4996
4997 }
4998 break;
4999 case 0x50:
5000 case 0x51:
5001 case 0x52:
5002 case 0x53:
5003 case 0x54:
5004 case 0x55:
5005 case 0x56:
5006 case 0x57:
5007 case 0x58:
5008 case 0x59:
5009 case 0x5a:
5010 case 0x5b:
5011 case 0x5c:
5012 case 0x5d:
5013 case 0x5e:
5014 case 0x5f:
5015 {
5016 /** 0111 0101 0101 rsrc cmp #%2, %1 */
5017 #line 528 "rx-decode.opc"
5018 int rsrc AU = op[1] & 0x0f;
5019 if (trace)
5020 {
5021 printf ("\033[33m%s\033[0m %02x %02x\n",
5022 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
5023 op[0], op[1]);
5024 printf (" rsrc = 0x%x\n", rsrc);
5025 }
5026 SYNTAX("cmp #%2, %1");
5027 #line 528 "rx-decode.opc"
5028 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5029
5030 }
5031 break;
5032 case 0x60:
5033 {
5034 /** 0111 0101 0110 0000 int #%1 */
5035 if (trace)
5036 {
5037 printf ("\033[33m%s\033[0m %02x %02x\n",
5038 "/** 0111 0101 0110 0000 int #%1 */",
5039 op[0], op[1]);
5040 }
5041 SYNTAX("int #%1");
5042 #line 1035 "rx-decode.opc"
5043 ID(int); SC(IMM(1));
5044
5045 }
5046 break;
5047 case 0x70:
5048 GETBYTE ();
5049 switch (op[2] & 0xf0)
5050 {
5051 case 0x00:
5052 {
5053 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
5054 #line 1002 "rx-decode.opc"
5055 int immm AU = op[2] & 0x0f;
5056 if (trace)
5057 {
5058 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5059 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
5060 op[0], op[1], op[2]);
5061 printf (" immm = 0x%x\n", immm);
5062 }
5063 SYNTAX("mvtipl #%1");
5064 #line 1002 "rx-decode.opc"
5065 ID(mvtipl); SC(immm);
5066
5067 }
5068 break;
5069 default: UNSUPPORTED(); break;
5070 }
5071 break;
5072 default: UNSUPPORTED(); break;
5073 }
5074 break;
5075 case 0x76:
5076 GETBYTE ();
5077 switch (op[1] & 0xf0)
5078 {
5079 case 0x00:
5080 goto op_semantics_32;
5081 break;
5082 case 0x10:
5083 goto op_semantics_33;
5084 break;
5085 case 0x20:
5086 goto op_semantics_34;
5087 break;
5088 case 0x30:
5089 goto op_semantics_35;
5090 break;
5091 default: UNSUPPORTED(); break;
5092 }
5093 break;
5094 case 0x77:
5095 GETBYTE ();
5096 switch (op[1] & 0xf0)
5097 {
5098 case 0x00:
5099 goto op_semantics_32;
5100 break;
5101 case 0x10:
5102 goto op_semantics_33;
5103 break;
5104 case 0x20:
5105 goto op_semantics_34;
5106 break;
5107 case 0x30:
5108 goto op_semantics_35;
5109 break;
5110 default: UNSUPPORTED(); break;
5111 }
5112 break;
5113 case 0x78:
5114 GETBYTE ();
5115 switch (op[1] & 0x00)
5116 {
5117 case 0x00:
5118 op_semantics_36:
5119 {
5120 /** 0111 100b ittt rdst bset #%1, %0 */
5121 #line 947 "rx-decode.opc"
5122 int b AU = op[0] & 0x01;
5123 #line 947 "rx-decode.opc"
5124 int ittt AU = (op[1] >> 4) & 0x0f;
5125 #line 947 "rx-decode.opc"
5126 int rdst AU = op[1] & 0x0f;
5127 if (trace)
5128 {
5129 printf ("\033[33m%s\033[0m %02x %02x\n",
5130 "/** 0111 100b ittt rdst bset #%1, %0 */",
5131 op[0], op[1]);
5132 printf (" b = 0x%x,", b);
5133 printf (" ittt = 0x%x,", ittt);
5134 printf (" rdst = 0x%x\n", rdst);
5135 }
5136 SYNTAX("bset #%1, %0");
5137 #line 947 "rx-decode.opc"
5138 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5139
5140
5141 }
5142 break;
5143 }
5144 break;
5145 case 0x79:
5146 GETBYTE ();
5147 switch (op[1] & 0x00)
5148 {
5149 case 0x00:
5150 goto op_semantics_36;
5151 break;
5152 }
5153 break;
5154 case 0x7a:
5155 GETBYTE ();
5156 switch (op[1] & 0x00)
5157 {
5158 case 0x00:
5159 op_semantics_37:
5160 {
5161 /** 0111 101b ittt rdst bclr #%1, %0 */
5162 #line 959 "rx-decode.opc"
5163 int b AU = op[0] & 0x01;
5164 #line 959 "rx-decode.opc"
5165 int ittt AU = (op[1] >> 4) & 0x0f;
5166 #line 959 "rx-decode.opc"
5167 int rdst AU = op[1] & 0x0f;
5168 if (trace)
5169 {
5170 printf ("\033[33m%s\033[0m %02x %02x\n",
5171 "/** 0111 101b ittt rdst bclr #%1, %0 */",
5172 op[0], op[1]);
5173 printf (" b = 0x%x,", b);
5174 printf (" ittt = 0x%x,", ittt);
5175 printf (" rdst = 0x%x\n", rdst);
5176 }
5177 SYNTAX("bclr #%1, %0");
5178 #line 959 "rx-decode.opc"
5179 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5180
5181
5182 }
5183 break;
5184 }
5185 break;
5186 case 0x7b:
5187 GETBYTE ();
5188 switch (op[1] & 0x00)
5189 {
5190 case 0x00:
5191 goto op_semantics_37;
5192 break;
5193 }
5194 break;
5195 case 0x7c:
5196 GETBYTE ();
5197 switch (op[1] & 0x00)
5198 {
5199 case 0x00:
5200 op_semantics_38:
5201 {
5202 /** 0111 110b ittt rdst btst #%2, %1 */
5203 #line 971 "rx-decode.opc"
5204 int b AU = op[0] & 0x01;
5205 #line 971 "rx-decode.opc"
5206 int ittt AU = (op[1] >> 4) & 0x0f;
5207 #line 971 "rx-decode.opc"
5208 int rdst AU = op[1] & 0x0f;
5209 if (trace)
5210 {
5211 printf ("\033[33m%s\033[0m %02x %02x\n",
5212 "/** 0111 110b ittt rdst btst #%2, %1 */",
5213 op[0], op[1]);
5214 printf (" b = 0x%x,", b);
5215 printf (" ittt = 0x%x,", ittt);
5216 printf (" rdst = 0x%x\n", rdst);
5217 }
5218 SYNTAX("btst #%2, %1");
5219 #line 971 "rx-decode.opc"
5220 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5221
5222
5223 }
5224 break;
5225 }
5226 break;
5227 case 0x7d:
5228 GETBYTE ();
5229 switch (op[1] & 0x00)
5230 {
5231 case 0x00:
5232 goto op_semantics_38;
5233 break;
5234 }
5235 break;
5236 case 0x7e:
5237 GETBYTE ();
5238 switch (op[1] & 0xf0)
5239 {
5240 case 0x00:
5241 {
5242 /** 0111 1110 0000 rdst not %0 */
5243 #line 462 "rx-decode.opc"
5244 int rdst AU = op[1] & 0x0f;
5245 if (trace)
5246 {
5247 printf ("\033[33m%s\033[0m %02x %02x\n",
5248 "/** 0111 1110 0000 rdst not %0 */",
5249 op[0], op[1]);
5250 printf (" rdst = 0x%x\n", rdst);
5251 }
5252 SYNTAX("not %0");
5253 #line 462 "rx-decode.opc"
5254 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5255
5256 }
5257 break;
5258 case 0x10:
5259 {
5260 /** 0111 1110 0001 rdst neg %0 */
5261 #line 483 "rx-decode.opc"
5262 int rdst AU = op[1] & 0x0f;
5263 if (trace)
5264 {
5265 printf ("\033[33m%s\033[0m %02x %02x\n",
5266 "/** 0111 1110 0001 rdst neg %0 */",
5267 op[0], op[1]);
5268 printf (" rdst = 0x%x\n", rdst);
5269 }
5270 SYNTAX("neg %0");
5271 #line 483 "rx-decode.opc"
5272 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5273
5274 }
5275 break;
5276 case 0x20:
5277 {
5278 /** 0111 1110 0010 rdst abs %0 */
5279 #line 565 "rx-decode.opc"
5280 int rdst AU = op[1] & 0x0f;
5281 if (trace)
5282 {
5283 printf ("\033[33m%s\033[0m %02x %02x\n",
5284 "/** 0111 1110 0010 rdst abs %0 */",
5285 op[0], op[1]);
5286 printf (" rdst = 0x%x\n", rdst);
5287 }
5288 SYNTAX("abs %0");
5289 #line 565 "rx-decode.opc"
5290 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5291
5292 }
5293 break;
5294 case 0x30:
5295 {
5296 /** 0111 1110 0011 rdst sat %0 */
5297 #line 885 "rx-decode.opc"
5298 int rdst AU = op[1] & 0x0f;
5299 if (trace)
5300 {
5301 printf ("\033[33m%s\033[0m %02x %02x\n",
5302 "/** 0111 1110 0011 rdst sat %0 */",
5303 op[0], op[1]);
5304 printf (" rdst = 0x%x\n", rdst);
5305 }
5306 SYNTAX("sat %0");
5307 #line 885 "rx-decode.opc"
5308 ID(sat); DR (rdst);
5309
5310 }
5311 break;
5312 case 0x40:
5313 {
5314 /** 0111 1110 0100 rdst rorc %0 */
5315 #line 745 "rx-decode.opc"
5316 int rdst AU = op[1] & 0x0f;
5317 if (trace)
5318 {
5319 printf ("\033[33m%s\033[0m %02x %02x\n",
5320 "/** 0111 1110 0100 rdst rorc %0 */",
5321 op[0], op[1]);
5322 printf (" rdst = 0x%x\n", rdst);
5323 }
5324 SYNTAX("rorc %0");
5325 #line 745 "rx-decode.opc"
5326 ID(rorc); DR(rdst); F__SZC;
5327
5328 }
5329 break;
5330 case 0x50:
5331 {
5332 /** 0111 1110 0101 rdst rolc %0 */
5333 #line 742 "rx-decode.opc"
5334 int rdst AU = op[1] & 0x0f;
5335 if (trace)
5336 {
5337 printf ("\033[33m%s\033[0m %02x %02x\n",
5338 "/** 0111 1110 0101 rdst rolc %0 */",
5339 op[0], op[1]);
5340 printf (" rdst = 0x%x\n", rdst);
5341 }
5342 SYNTAX("rolc %0");
5343 #line 742 "rx-decode.opc"
5344 ID(rolc); DR(rdst); F__SZC;
5345
5346 }
5347 break;
5348 case 0x80:
5349 case 0x90:
5350 case 0xa0:
5351 {
5352 /** 0111 1110 10sz rsrc push%s %1 */
5353 #line 378 "rx-decode.opc"
5354 int sz AU = (op[1] >> 4) & 0x03;
5355 #line 378 "rx-decode.opc"
5356 int rsrc AU = op[1] & 0x0f;
5357 if (trace)
5358 {
5359 printf ("\033[33m%s\033[0m %02x %02x\n",
5360 "/** 0111 1110 10sz rsrc push%s %1 */",
5361 op[0], op[1]);
5362 printf (" sz = 0x%x,", sz);
5363 printf (" rsrc = 0x%x\n", rsrc);
5364 }
5365 SYNTAX("push%s %1");
5366 #line 378 "rx-decode.opc"
5367 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5368
5369 }
5370 break;
5371 case 0xb0:
5372 {
5373 /** 0111 1110 1011 rdst pop %0 */
5374 #line 375 "rx-decode.opc"
5375 int rdst AU = op[1] & 0x0f;
5376 if (trace)
5377 {
5378 printf ("\033[33m%s\033[0m %02x %02x\n",
5379 "/** 0111 1110 1011 rdst pop %0 */",
5380 op[0], op[1]);
5381 printf (" rdst = 0x%x\n", rdst);
5382 }
5383 SYNTAX("pop %0");
5384 #line 375 "rx-decode.opc"
5385 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5386
5387 }
5388 break;
5389 case 0xc0:
5390 case 0xd0:
5391 {
5392 /** 0111 1110 110 crsrc pushc %1 */
5393 #line 1008 "rx-decode.opc"
5394 int crsrc AU = op[1] & 0x1f;
5395 if (trace)
5396 {
5397 printf ("\033[33m%s\033[0m %02x %02x\n",
5398 "/** 0111 1110 110 crsrc pushc %1 */",
5399 op[0], op[1]);
5400 printf (" crsrc = 0x%x\n", crsrc);
5401 }
5402 SYNTAX("pushc %1");
5403 #line 1008 "rx-decode.opc"
5404 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5405
5406 }
5407 break;
5408 case 0xe0:
5409 case 0xf0:
5410 {
5411 /** 0111 1110 111 crdst popc %0 */
5412 #line 1005 "rx-decode.opc"
5413 int crdst AU = op[1] & 0x1f;
5414 if (trace)
5415 {
5416 printf ("\033[33m%s\033[0m %02x %02x\n",
5417 "/** 0111 1110 111 crdst popc %0 */",
5418 op[0], op[1]);
5419 printf (" crdst = 0x%x\n", crdst);
5420 }
5421 SYNTAX("popc %0");
5422 #line 1005 "rx-decode.opc"
5423 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5424
5425 }
5426 break;
5427 default: UNSUPPORTED(); break;
5428 }
5429 break;
5430 case 0x7f:
5431 GETBYTE ();
5432 switch (op[1] & 0xff)
5433 {
5434 case 0x00:
5435 case 0x01:
5436 case 0x02:
5437 case 0x03:
5438 case 0x04:
5439 case 0x05:
5440 case 0x06:
5441 case 0x07:
5442 case 0x08:
5443 case 0x09:
5444 case 0x0a:
5445 case 0x0b:
5446 case 0x0c:
5447 case 0x0d:
5448 case 0x0e:
5449 case 0x0f:
5450 {
5451 /** 0111 1111 0000 rsrc jmp %0 */
5452 #line 795 "rx-decode.opc"
5453 int rsrc AU = op[1] & 0x0f;
5454 if (trace)
5455 {
5456 printf ("\033[33m%s\033[0m %02x %02x\n",
5457 "/** 0111 1111 0000 rsrc jmp %0 */",
5458 op[0], op[1]);
5459 printf (" rsrc = 0x%x\n", rsrc);
5460 }
5461 SYNTAX("jmp %0");
5462 #line 795 "rx-decode.opc"
5463 ID(branch); DR(rsrc);
5464
5465 }
5466 break;
5467 case 0x10:
5468 case 0x11:
5469 case 0x12:
5470 case 0x13:
5471 case 0x14:
5472 case 0x15:
5473 case 0x16:
5474 case 0x17:
5475 case 0x18:
5476 case 0x19:
5477 case 0x1a:
5478 case 0x1b:
5479 case 0x1c:
5480 case 0x1d:
5481 case 0x1e:
5482 case 0x1f:
5483 {
5484 /** 0111 1111 0001 rsrc jsr %0 */
5485 #line 798 "rx-decode.opc"
5486 int rsrc AU = op[1] & 0x0f;
5487 if (trace)
5488 {
5489 printf ("\033[33m%s\033[0m %02x %02x\n",
5490 "/** 0111 1111 0001 rsrc jsr %0 */",
5491 op[0], op[1]);
5492 printf (" rsrc = 0x%x\n", rsrc);
5493 }
5494 SYNTAX("jsr %0");
5495 #line 798 "rx-decode.opc"
5496 ID(jsr); DR(rsrc);
5497
5498 }
5499 break;
5500 case 0x40:
5501 case 0x41:
5502 case 0x42:
5503 case 0x43:
5504 case 0x44:
5505 case 0x45:
5506 case 0x46:
5507 case 0x47:
5508 case 0x48:
5509 case 0x49:
5510 case 0x4a:
5511 case 0x4b:
5512 case 0x4c:
5513 case 0x4d:
5514 case 0x4e:
5515 case 0x4f:
5516 {
5517 /** 0111 1111 0100 rsrc bra.l %0 */
5518 #line 791 "rx-decode.opc"
5519 int rsrc AU = op[1] & 0x0f;
5520 if (trace)
5521 {
5522 printf ("\033[33m%s\033[0m %02x %02x\n",
5523 "/** 0111 1111 0100 rsrc bra.l %0 */",
5524 op[0], op[1]);
5525 printf (" rsrc = 0x%x\n", rsrc);
5526 }
5527 SYNTAX("bra.l %0");
5528 #line 791 "rx-decode.opc"
5529 ID(branchrel); DR(rsrc);
5530
5531
5532 }
5533 break;
5534 case 0x50:
5535 case 0x51:
5536 case 0x52:
5537 case 0x53:
5538 case 0x54:
5539 case 0x55:
5540 case 0x56:
5541 case 0x57:
5542 case 0x58:
5543 case 0x59:
5544 case 0x5a:
5545 case 0x5b:
5546 case 0x5c:
5547 case 0x5d:
5548 case 0x5e:
5549 case 0x5f:
5550 {
5551 /** 0111 1111 0101 rsrc bsr.l %0 */
5552 #line 807 "rx-decode.opc"
5553 int rsrc AU = op[1] & 0x0f;
5554 if (trace)
5555 {
5556 printf ("\033[33m%s\033[0m %02x %02x\n",
5557 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5558 op[0], op[1]);
5559 printf (" rsrc = 0x%x\n", rsrc);
5560 }
5561 SYNTAX("bsr.l %0");
5562 #line 807 "rx-decode.opc"
5563 ID(jsrrel); DR(rsrc);
5564
5565 }
5566 break;
5567 case 0x80:
5568 case 0x81:
5569 case 0x82:
5570 {
5571 /** 0111 1111 1000 00sz suntil%s */
5572 #line 831 "rx-decode.opc"
5573 int sz AU = op[1] & 0x03;
5574 if (trace)
5575 {
5576 printf ("\033[33m%s\033[0m %02x %02x\n",
5577 "/** 0111 1111 1000 00sz suntil%s */",
5578 op[0], op[1]);
5579 printf (" sz = 0x%x\n", sz);
5580 }
5581 SYNTAX("suntil%s");
5582 #line 831 "rx-decode.opc"
5583 ID(suntil); BWL(sz); F___ZC;
5584
5585 }
5586 break;
5587 case 0x83:
5588 {
5589 /** 0111 1111 1000 0011 scmpu */
5590 if (trace)
5591 {
5592 printf ("\033[33m%s\033[0m %02x %02x\n",
5593 "/** 0111 1111 1000 0011 scmpu */",
5594 op[0], op[1]);
5595 }
5596 SYNTAX("scmpu");
5597 #line 822 "rx-decode.opc"
5598 ID(scmpu); F___ZC;
5599
5600 }
5601 break;
5602 case 0x84:
5603 case 0x85:
5604 case 0x86:
5605 {
5606 /** 0111 1111 1000 01sz swhile%s */
5607 #line 834 "rx-decode.opc"
5608 int sz AU = op[1] & 0x03;
5609 if (trace)
5610 {
5611 printf ("\033[33m%s\033[0m %02x %02x\n",
5612 "/** 0111 1111 1000 01sz swhile%s */",
5613 op[0], op[1]);
5614 printf (" sz = 0x%x\n", sz);
5615 }
5616 SYNTAX("swhile%s");
5617 #line 834 "rx-decode.opc"
5618 ID(swhile); BWL(sz); F___ZC;
5619
5620 }
5621 break;
5622 case 0x87:
5623 {
5624 /** 0111 1111 1000 0111 smovu */
5625 if (trace)
5626 {
5627 printf ("\033[33m%s\033[0m %02x %02x\n",
5628 "/** 0111 1111 1000 0111 smovu */",
5629 op[0], op[1]);
5630 }
5631 SYNTAX("smovu");
5632 #line 825 "rx-decode.opc"
5633 ID(smovu);
5634
5635 }
5636 break;
5637 case 0x88:
5638 case 0x89:
5639 case 0x8a:
5640 {
5641 /** 0111 1111 1000 10sz sstr%s */
5642 #line 840 "rx-decode.opc"
5643 int sz AU = op[1] & 0x03;
5644 if (trace)
5645 {
5646 printf ("\033[33m%s\033[0m %02x %02x\n",
5647 "/** 0111 1111 1000 10sz sstr%s */",
5648 op[0], op[1]);
5649 printf (" sz = 0x%x\n", sz);
5650 }
5651 SYNTAX("sstr%s");
5652 #line 840 "rx-decode.opc"
5653 ID(sstr); BWL(sz);
5654
5655 /*----------------------------------------------------------------------*/
5656 /* RMPA */
5657
5658 }
5659 break;
5660 case 0x8b:
5661 {
5662 /** 0111 1111 1000 1011 smovb */
5663 if (trace)
5664 {
5665 printf ("\033[33m%s\033[0m %02x %02x\n",
5666 "/** 0111 1111 1000 1011 smovb */",
5667 op[0], op[1]);
5668 }
5669 SYNTAX("smovb");
5670 #line 828 "rx-decode.opc"
5671 ID(smovb);
5672
5673 }
5674 break;
5675 case 0x8c:
5676 case 0x8d:
5677 case 0x8e:
5678 {
5679 /** 0111 1111 1000 11sz rmpa%s */
5680 #line 846 "rx-decode.opc"
5681 int sz AU = op[1] & 0x03;
5682 if (trace)
5683 {
5684 printf ("\033[33m%s\033[0m %02x %02x\n",
5685 "/** 0111 1111 1000 11sz rmpa%s */",
5686 op[0], op[1]);
5687 printf (" sz = 0x%x\n", sz);
5688 }
5689 SYNTAX("rmpa%s");
5690 #line 846 "rx-decode.opc"
5691 ID(rmpa); BWL(sz); F_OS__;
5692
5693 /*----------------------------------------------------------------------*/
5694 /* HI/LO stuff */
5695
5696 }
5697 break;
5698 case 0x8f:
5699 {
5700 /** 0111 1111 1000 1111 smovf */
5701 if (trace)
5702 {
5703 printf ("\033[33m%s\033[0m %02x %02x\n",
5704 "/** 0111 1111 1000 1111 smovf */",
5705 op[0], op[1]);
5706 }
5707 SYNTAX("smovf");
5708 #line 837 "rx-decode.opc"
5709 ID(smovf);
5710
5711 }
5712 break;
5713 case 0x93:
5714 {
5715 /** 0111 1111 1001 0011 satr */
5716 if (trace)
5717 {
5718 printf ("\033[33m%s\033[0m %02x %02x\n",
5719 "/** 0111 1111 1001 0011 satr */",
5720 op[0], op[1]);
5721 }
5722 SYNTAX("satr");
5723 #line 888 "rx-decode.opc"
5724 ID(satr);
5725
5726 /*----------------------------------------------------------------------*/
5727 /* FLOAT */
5728
5729 }
5730 break;
5731 case 0x94:
5732 {
5733 /** 0111 1111 1001 0100 rtfi */
5734 if (trace)
5735 {
5736 printf ("\033[33m%s\033[0m %02x %02x\n",
5737 "/** 0111 1111 1001 0100 rtfi */",
5738 op[0], op[1]);
5739 }
5740 SYNTAX("rtfi");
5741 #line 1023 "rx-decode.opc"
5742 ID(rtfi);
5743
5744 }
5745 break;
5746 case 0x95:
5747 {
5748 /** 0111 1111 1001 0101 rte */
5749 if (trace)
5750 {
5751 printf ("\033[33m%s\033[0m %02x %02x\n",
5752 "/** 0111 1111 1001 0101 rte */",
5753 op[0], op[1]);
5754 }
5755 SYNTAX("rte");
5756 #line 1026 "rx-decode.opc"
5757 ID(rte);
5758
5759 }
5760 break;
5761 case 0x96:
5762 {
5763 /** 0111 1111 1001 0110 wait */
5764 if (trace)
5765 {
5766 printf ("\033[33m%s\033[0m %02x %02x\n",
5767 "/** 0111 1111 1001 0110 wait */",
5768 op[0], op[1]);
5769 }
5770 SYNTAX("wait");
5771 #line 1038 "rx-decode.opc"
5772 ID(wait);
5773
5774 /*----------------------------------------------------------------------*/
5775 /* SCcnd */
5776
5777 }
5778 break;
5779 case 0xa0:
5780 case 0xa1:
5781 case 0xa2:
5782 case 0xa3:
5783 case 0xa4:
5784 case 0xa5:
5785 case 0xa6:
5786 case 0xa7:
5787 case 0xa8:
5788 case 0xa9:
5789 case 0xaa:
5790 case 0xab:
5791 case 0xac:
5792 case 0xad:
5793 case 0xae:
5794 case 0xaf:
5795 {
5796 /** 0111 1111 1010 rdst setpsw %0 */
5797 #line 999 "rx-decode.opc"
5798 int rdst AU = op[1] & 0x0f;
5799 if (trace)
5800 {
5801 printf ("\033[33m%s\033[0m %02x %02x\n",
5802 "/** 0111 1111 1010 rdst setpsw %0 */",
5803 op[0], op[1]);
5804 printf (" rdst = 0x%x\n", rdst);
5805 }
5806 SYNTAX("setpsw %0");
5807 #line 999 "rx-decode.opc"
5808 ID(setpsw); DF(rdst);
5809
5810 }
5811 break;
5812 case 0xb0:
5813 case 0xb1:
5814 case 0xb2:
5815 case 0xb3:
5816 case 0xb4:
5817 case 0xb5:
5818 case 0xb6:
5819 case 0xb7:
5820 case 0xb8:
5821 case 0xb9:
5822 case 0xba:
5823 case 0xbb:
5824 case 0xbc:
5825 case 0xbd:
5826 case 0xbe:
5827 case 0xbf:
5828 {
5829 /** 0111 1111 1011 rdst clrpsw %0 */
5830 #line 996 "rx-decode.opc"
5831 int rdst AU = op[1] & 0x0f;
5832 if (trace)
5833 {
5834 printf ("\033[33m%s\033[0m %02x %02x\n",
5835 "/** 0111 1111 1011 rdst clrpsw %0 */",
5836 op[0], op[1]);
5837 printf (" rdst = 0x%x\n", rdst);
5838 }
5839 SYNTAX("clrpsw %0");
5840 #line 996 "rx-decode.opc"
5841 ID(clrpsw); DF(rdst);
5842
5843 }
5844 break;
5845 default: UNSUPPORTED(); break;
5846 }
5847 break;
5848 case 0x80:
5849 GETBYTE ();
5850 switch (op[1] & 0x00)
5851 {
5852 case 0x00:
5853 op_semantics_39:
5854 {
5855 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5856 #line 336 "rx-decode.opc"
5857 int sz AU = (op[0] >> 4) & 0x03;
5858 #line 336 "rx-decode.opc"
5859 int dsp AU = op[0] & 0x07;
5860 #line 336 "rx-decode.opc"
5861 int a AU = (op[1] >> 7) & 0x01;
5862 #line 336 "rx-decode.opc"
5863 int dst AU = (op[1] >> 4) & 0x07;
5864 #line 336 "rx-decode.opc"
5865 int b AU = (op[1] >> 3) & 0x01;
5866 #line 336 "rx-decode.opc"
5867 int src AU = op[1] & 0x07;
5868 if (trace)
5869 {
5870 printf ("\033[33m%s\033[0m %02x %02x\n",
5871 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5872 op[0], op[1]);
5873 printf (" sz = 0x%x,", sz);
5874 printf (" dsp = 0x%x,", dsp);
5875 printf (" a = 0x%x,", a);
5876 printf (" dst = 0x%x,", dst);
5877 printf (" b = 0x%x,", b);
5878 printf (" src = 0x%x\n", src);
5879 }
5880 SYNTAX("mov%s %1, %0");
5881 #line 336 "rx-decode.opc"
5882 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5883
5884 }
5885 break;
5886 }
5887 break;
5888 case 0x81:
5889 GETBYTE ();
5890 switch (op[1] & 0x00)
5891 {
5892 case 0x00:
5893 goto op_semantics_39;
5894 break;
5895 }
5896 break;
5897 case 0x82:
5898 GETBYTE ();
5899 switch (op[1] & 0x00)
5900 {
5901 case 0x00:
5902 goto op_semantics_39;
5903 break;
5904 }
5905 break;
5906 case 0x83:
5907 GETBYTE ();
5908 switch (op[1] & 0x00)
5909 {
5910 case 0x00:
5911 goto op_semantics_39;
5912 break;
5913 }
5914 break;
5915 case 0x84:
5916 GETBYTE ();
5917 switch (op[1] & 0x00)
5918 {
5919 case 0x00:
5920 goto op_semantics_39;
5921 break;
5922 }
5923 break;
5924 case 0x85:
5925 GETBYTE ();
5926 switch (op[1] & 0x00)
5927 {
5928 case 0x00:
5929 goto op_semantics_39;
5930 break;
5931 }
5932 break;
5933 case 0x86:
5934 GETBYTE ();
5935 switch (op[1] & 0x00)
5936 {
5937 case 0x00:
5938 goto op_semantics_39;
5939 break;
5940 }
5941 break;
5942 case 0x87:
5943 GETBYTE ();
5944 switch (op[1] & 0x00)
5945 {
5946 case 0x00:
5947 goto op_semantics_39;
5948 break;
5949 }
5950 break;
5951 case 0x88:
5952 GETBYTE ();
5953 switch (op[1] & 0x00)
5954 {
5955 case 0x00:
5956 op_semantics_40:
5957 {
5958 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5959 #line 333 "rx-decode.opc"
5960 int sz AU = (op[0] >> 4) & 0x03;
5961 #line 333 "rx-decode.opc"
5962 int dsp AU = op[0] & 0x07;
5963 #line 333 "rx-decode.opc"
5964 int a AU = (op[1] >> 7) & 0x01;
5965 #line 333 "rx-decode.opc"
5966 int src AU = (op[1] >> 4) & 0x07;
5967 #line 333 "rx-decode.opc"
5968 int b AU = (op[1] >> 3) & 0x01;
5969 #line 333 "rx-decode.opc"
5970 int dst AU = op[1] & 0x07;
5971 if (trace)
5972 {
5973 printf ("\033[33m%s\033[0m %02x %02x\n",
5974 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5975 op[0], op[1]);
5976 printf (" sz = 0x%x,", sz);
5977 printf (" dsp = 0x%x,", dsp);
5978 printf (" a = 0x%x,", a);
5979 printf (" src = 0x%x,", src);
5980 printf (" b = 0x%x,", b);
5981 printf (" dst = 0x%x\n", dst);
5982 }
5983 SYNTAX("mov%s %1, %0");
5984 #line 333 "rx-decode.opc"
5985 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5986
5987 }
5988 break;
5989 }
5990 break;
5991 case 0x89:
5992 GETBYTE ();
5993 switch (op[1] & 0x00)
5994 {
5995 case 0x00:
5996 goto op_semantics_40;
5997 break;
5998 }
5999 break;
6000 case 0x8a:
6001 GETBYTE ();
6002 switch (op[1] & 0x00)
6003 {
6004 case 0x00:
6005 goto op_semantics_40;
6006 break;
6007 }
6008 break;
6009 case 0x8b:
6010 GETBYTE ();
6011 switch (op[1] & 0x00)
6012 {
6013 case 0x00:
6014 goto op_semantics_40;
6015 break;
6016 }
6017 break;
6018 case 0x8c:
6019 GETBYTE ();
6020 switch (op[1] & 0x00)
6021 {
6022 case 0x00:
6023 goto op_semantics_40;
6024 break;
6025 }
6026 break;
6027 case 0x8d:
6028 GETBYTE ();
6029 switch (op[1] & 0x00)
6030 {
6031 case 0x00:
6032 goto op_semantics_40;
6033 break;
6034 }
6035 break;
6036 case 0x8e:
6037 GETBYTE ();
6038 switch (op[1] & 0x00)
6039 {
6040 case 0x00:
6041 goto op_semantics_40;
6042 break;
6043 }
6044 break;
6045 case 0x8f:
6046 GETBYTE ();
6047 switch (op[1] & 0x00)
6048 {
6049 case 0x00:
6050 goto op_semantics_40;
6051 break;
6052 }
6053 break;
6054 case 0x90:
6055 GETBYTE ();
6056 switch (op[1] & 0x00)
6057 {
6058 case 0x00:
6059 goto op_semantics_39;
6060 break;
6061 }
6062 break;
6063 case 0x91:
6064 GETBYTE ();
6065 switch (op[1] & 0x00)
6066 {
6067 case 0x00:
6068 goto op_semantics_39;
6069 break;
6070 }
6071 break;
6072 case 0x92:
6073 GETBYTE ();
6074 switch (op[1] & 0x00)
6075 {
6076 case 0x00:
6077 goto op_semantics_39;
6078 break;
6079 }
6080 break;
6081 case 0x93:
6082 GETBYTE ();
6083 switch (op[1] & 0x00)
6084 {
6085 case 0x00:
6086 goto op_semantics_39;
6087 break;
6088 }
6089 break;
6090 case 0x94:
6091 GETBYTE ();
6092 switch (op[1] & 0x00)
6093 {
6094 case 0x00:
6095 goto op_semantics_39;
6096 break;
6097 }
6098 break;
6099 case 0x95:
6100 GETBYTE ();
6101 switch (op[1] & 0x00)
6102 {
6103 case 0x00:
6104 goto op_semantics_39;
6105 break;
6106 }
6107 break;
6108 case 0x96:
6109 GETBYTE ();
6110 switch (op[1] & 0x00)
6111 {
6112 case 0x00:
6113 goto op_semantics_39;
6114 break;
6115 }
6116 break;
6117 case 0x97:
6118 GETBYTE ();
6119 switch (op[1] & 0x00)
6120 {
6121 case 0x00:
6122 goto op_semantics_39;
6123 break;
6124 }
6125 break;
6126 case 0x98:
6127 GETBYTE ();
6128 switch (op[1] & 0x00)
6129 {
6130 case 0x00:
6131 goto op_semantics_40;
6132 break;
6133 }
6134 break;
6135 case 0x99:
6136 GETBYTE ();
6137 switch (op[1] & 0x00)
6138 {
6139 case 0x00:
6140 goto op_semantics_40;
6141 break;
6142 }
6143 break;
6144 case 0x9a:
6145 GETBYTE ();
6146 switch (op[1] & 0x00)
6147 {
6148 case 0x00:
6149 goto op_semantics_40;
6150 break;
6151 }
6152 break;
6153 case 0x9b:
6154 GETBYTE ();
6155 switch (op[1] & 0x00)
6156 {
6157 case 0x00:
6158 goto op_semantics_40;
6159 break;
6160 }
6161 break;
6162 case 0x9c:
6163 GETBYTE ();
6164 switch (op[1] & 0x00)
6165 {
6166 case 0x00:
6167 goto op_semantics_40;
6168 break;
6169 }
6170 break;
6171 case 0x9d:
6172 GETBYTE ();
6173 switch (op[1] & 0x00)
6174 {
6175 case 0x00:
6176 goto op_semantics_40;
6177 break;
6178 }
6179 break;
6180 case 0x9e:
6181 GETBYTE ();
6182 switch (op[1] & 0x00)
6183 {
6184 case 0x00:
6185 goto op_semantics_40;
6186 break;
6187 }
6188 break;
6189 case 0x9f:
6190 GETBYTE ();
6191 switch (op[1] & 0x00)
6192 {
6193 case 0x00:
6194 goto op_semantics_40;
6195 break;
6196 }
6197 break;
6198 case 0xa0:
6199 GETBYTE ();
6200 switch (op[1] & 0x00)
6201 {
6202 case 0x00:
6203 goto op_semantics_39;
6204 break;
6205 }
6206 break;
6207 case 0xa1:
6208 GETBYTE ();
6209 switch (op[1] & 0x00)
6210 {
6211 case 0x00:
6212 goto op_semantics_39;
6213 break;
6214 }
6215 break;
6216 case 0xa2:
6217 GETBYTE ();
6218 switch (op[1] & 0x00)
6219 {
6220 case 0x00:
6221 goto op_semantics_39;
6222 break;
6223 }
6224 break;
6225 case 0xa3:
6226 GETBYTE ();
6227 switch (op[1] & 0x00)
6228 {
6229 case 0x00:
6230 goto op_semantics_39;
6231 break;
6232 }
6233 break;
6234 case 0xa4:
6235 GETBYTE ();
6236 switch (op[1] & 0x00)
6237 {
6238 case 0x00:
6239 goto op_semantics_39;
6240 break;
6241 }
6242 break;
6243 case 0xa5:
6244 GETBYTE ();
6245 switch (op[1] & 0x00)
6246 {
6247 case 0x00:
6248 goto op_semantics_39;
6249 break;
6250 }
6251 break;
6252 case 0xa6:
6253 GETBYTE ();
6254 switch (op[1] & 0x00)
6255 {
6256 case 0x00:
6257 goto op_semantics_39;
6258 break;
6259 }
6260 break;
6261 case 0xa7:
6262 GETBYTE ();
6263 switch (op[1] & 0x00)
6264 {
6265 case 0x00:
6266 goto op_semantics_39;
6267 break;
6268 }
6269 break;
6270 case 0xa8:
6271 GETBYTE ();
6272 switch (op[1] & 0x00)
6273 {
6274 case 0x00:
6275 goto op_semantics_40;
6276 break;
6277 }
6278 break;
6279 case 0xa9:
6280 GETBYTE ();
6281 switch (op[1] & 0x00)
6282 {
6283 case 0x00:
6284 goto op_semantics_40;
6285 break;
6286 }
6287 break;
6288 case 0xaa:
6289 GETBYTE ();
6290 switch (op[1] & 0x00)
6291 {
6292 case 0x00:
6293 goto op_semantics_40;
6294 break;
6295 }
6296 break;
6297 case 0xab:
6298 GETBYTE ();
6299 switch (op[1] & 0x00)
6300 {
6301 case 0x00:
6302 goto op_semantics_40;
6303 break;
6304 }
6305 break;
6306 case 0xac:
6307 GETBYTE ();
6308 switch (op[1] & 0x00)
6309 {
6310 case 0x00:
6311 goto op_semantics_40;
6312 break;
6313 }
6314 break;
6315 case 0xad:
6316 GETBYTE ();
6317 switch (op[1] & 0x00)
6318 {
6319 case 0x00:
6320 goto op_semantics_40;
6321 break;
6322 }
6323 break;
6324 case 0xae:
6325 GETBYTE ();
6326 switch (op[1] & 0x00)
6327 {
6328 case 0x00:
6329 goto op_semantics_40;
6330 break;
6331 }
6332 break;
6333 case 0xaf:
6334 GETBYTE ();
6335 switch (op[1] & 0x00)
6336 {
6337 case 0x00:
6338 goto op_semantics_40;
6339 break;
6340 }
6341 break;
6342 case 0xb0:
6343 GETBYTE ();
6344 switch (op[1] & 0x00)
6345 {
6346 case 0x00:
6347 op_semantics_41:
6348 {
6349 /** 1011 w dsp a src b dst movu%s %1, %0 */
6350 #line 356 "rx-decode.opc"
6351 int w AU = (op[0] >> 3) & 0x01;
6352 #line 356 "rx-decode.opc"
6353 int dsp AU = op[0] & 0x07;
6354 #line 356 "rx-decode.opc"
6355 int a AU = (op[1] >> 7) & 0x01;
6356 #line 356 "rx-decode.opc"
6357 int src AU = (op[1] >> 4) & 0x07;
6358 #line 356 "rx-decode.opc"
6359 int b AU = (op[1] >> 3) & 0x01;
6360 #line 356 "rx-decode.opc"
6361 int dst AU = op[1] & 0x07;
6362 if (trace)
6363 {
6364 printf ("\033[33m%s\033[0m %02x %02x\n",
6365 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6366 op[0], op[1]);
6367 printf (" w = 0x%x,", w);
6368 printf (" dsp = 0x%x,", dsp);
6369 printf (" a = 0x%x,", a);
6370 printf (" src = 0x%x,", src);
6371 printf (" b = 0x%x,", b);
6372 printf (" dst = 0x%x\n", dst);
6373 }
6374 SYNTAX("movu%s %1, %0");
6375 #line 356 "rx-decode.opc"
6376 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6377
6378 }
6379 break;
6380 }
6381 break;
6382 case 0xb1:
6383 GETBYTE ();
6384 switch (op[1] & 0x00)
6385 {
6386 case 0x00:
6387 goto op_semantics_41;
6388 break;
6389 }
6390 break;
6391 case 0xb2:
6392 GETBYTE ();
6393 switch (op[1] & 0x00)
6394 {
6395 case 0x00:
6396 goto op_semantics_41;
6397 break;
6398 }
6399 break;
6400 case 0xb3:
6401 GETBYTE ();
6402 switch (op[1] & 0x00)
6403 {
6404 case 0x00:
6405 goto op_semantics_41;
6406 break;
6407 }
6408 break;
6409 case 0xb4:
6410 GETBYTE ();
6411 switch (op[1] & 0x00)
6412 {
6413 case 0x00:
6414 goto op_semantics_41;
6415 break;
6416 }
6417 break;
6418 case 0xb5:
6419 GETBYTE ();
6420 switch (op[1] & 0x00)
6421 {
6422 case 0x00:
6423 goto op_semantics_41;
6424 break;
6425 }
6426 break;
6427 case 0xb6:
6428 GETBYTE ();
6429 switch (op[1] & 0x00)
6430 {
6431 case 0x00:
6432 goto op_semantics_41;
6433 break;
6434 }
6435 break;
6436 case 0xb7:
6437 GETBYTE ();
6438 switch (op[1] & 0x00)
6439 {
6440 case 0x00:
6441 goto op_semantics_41;
6442 break;
6443 }
6444 break;
6445 case 0xb8:
6446 GETBYTE ();
6447 switch (op[1] & 0x00)
6448 {
6449 case 0x00:
6450 goto op_semantics_41;
6451 break;
6452 }
6453 break;
6454 case 0xb9:
6455 GETBYTE ();
6456 switch (op[1] & 0x00)
6457 {
6458 case 0x00:
6459 goto op_semantics_41;
6460 break;
6461 }
6462 break;
6463 case 0xba:
6464 GETBYTE ();
6465 switch (op[1] & 0x00)
6466 {
6467 case 0x00:
6468 goto op_semantics_41;
6469 break;
6470 }
6471 break;
6472 case 0xbb:
6473 GETBYTE ();
6474 switch (op[1] & 0x00)
6475 {
6476 case 0x00:
6477 goto op_semantics_41;
6478 break;
6479 }
6480 break;
6481 case 0xbc:
6482 GETBYTE ();
6483 switch (op[1] & 0x00)
6484 {
6485 case 0x00:
6486 goto op_semantics_41;
6487 break;
6488 }
6489 break;
6490 case 0xbd:
6491 GETBYTE ();
6492 switch (op[1] & 0x00)
6493 {
6494 case 0x00:
6495 goto op_semantics_41;
6496 break;
6497 }
6498 break;
6499 case 0xbe:
6500 GETBYTE ();
6501 switch (op[1] & 0x00)
6502 {
6503 case 0x00:
6504 goto op_semantics_41;
6505 break;
6506 }
6507 break;
6508 case 0xbf:
6509 GETBYTE ();
6510 switch (op[1] & 0x00)
6511 {
6512 case 0x00:
6513 goto op_semantics_41;
6514 break;
6515 }
6516 break;
6517 case 0xc0:
6518 GETBYTE ();
6519 switch (op[1] & 0x00)
6520 {
6521 case 0x00:
6522 op_semantics_42:
6523 {
6524 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6525 #line 314 "rx-decode.opc"
6526 int sz AU = (op[0] >> 4) & 0x03;
6527 #line 314 "rx-decode.opc"
6528 int sd AU = (op[0] >> 2) & 0x03;
6529 #line 314 "rx-decode.opc"
6530 int ss AU = op[0] & 0x03;
6531 #line 314 "rx-decode.opc"
6532 int rsrc AU = (op[1] >> 4) & 0x0f;
6533 #line 314 "rx-decode.opc"
6534 int rdst AU = op[1] & 0x0f;
6535 if (trace)
6536 {
6537 printf ("\033[33m%s\033[0m %02x %02x\n",
6538 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6539 op[0], op[1]);
6540 printf (" sz = 0x%x,", sz);
6541 printf (" sd = 0x%x,", sd);
6542 printf (" ss = 0x%x,", ss);
6543 printf (" rsrc = 0x%x,", rsrc);
6544 printf (" rdst = 0x%x\n", rdst);
6545 }
6546 SYNTAX("mov%s %1, %0");
6547 #line 314 "rx-decode.opc"
6548 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6549 {
6550 ID(nop2);
6551 SYNTAX ("nop\t; mov.l\tr0, r0");
6552 }
6553 else
6554 {
6555 ID(mov); sBWL(sz); F_____;
6556 if ((ss == 3) && (sd != 3))
6557 {
6558 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6559 }
6560 else
6561 {
6562 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6563 }
6564 }
6565
6566 }
6567 break;
6568 }
6569 break;
6570 case 0xc1:
6571 GETBYTE ();
6572 switch (op[1] & 0x00)
6573 {
6574 case 0x00:
6575 goto op_semantics_42;
6576 break;
6577 }
6578 break;
6579 case 0xc2:
6580 GETBYTE ();
6581 switch (op[1] & 0x00)
6582 {
6583 case 0x00:
6584 goto op_semantics_42;
6585 break;
6586 }
6587 break;
6588 case 0xc3:
6589 GETBYTE ();
6590 switch (op[1] & 0x00)
6591 {
6592 case 0x00:
6593 goto op_semantics_42;
6594 break;
6595 }
6596 break;
6597 case 0xc4:
6598 GETBYTE ();
6599 switch (op[1] & 0x00)
6600 {
6601 case 0x00:
6602 goto op_semantics_42;
6603 break;
6604 }
6605 break;
6606 case 0xc5:
6607 GETBYTE ();
6608 switch (op[1] & 0x00)
6609 {
6610 case 0x00:
6611 goto op_semantics_42;
6612 break;
6613 }
6614 break;
6615 case 0xc6:
6616 GETBYTE ();
6617 switch (op[1] & 0x00)
6618 {
6619 case 0x00:
6620 goto op_semantics_42;
6621 break;
6622 }
6623 break;
6624 case 0xc7:
6625 GETBYTE ();
6626 switch (op[1] & 0x00)
6627 {
6628 case 0x00:
6629 goto op_semantics_42;
6630 break;
6631 }
6632 break;
6633 case 0xc8:
6634 GETBYTE ();
6635 switch (op[1] & 0x00)
6636 {
6637 case 0x00:
6638 goto op_semantics_42;
6639 break;
6640 }
6641 break;
6642 case 0xc9:
6643 GETBYTE ();
6644 switch (op[1] & 0x00)
6645 {
6646 case 0x00:
6647 goto op_semantics_42;
6648 break;
6649 }
6650 break;
6651 case 0xca:
6652 GETBYTE ();
6653 switch (op[1] & 0x00)
6654 {
6655 case 0x00:
6656 goto op_semantics_42;
6657 break;
6658 }
6659 break;
6660 case 0xcb:
6661 GETBYTE ();
6662 switch (op[1] & 0x00)
6663 {
6664 case 0x00:
6665 goto op_semantics_42;
6666 break;
6667 }
6668 break;
6669 case 0xcc:
6670 GETBYTE ();
6671 switch (op[1] & 0x00)
6672 {
6673 case 0x00:
6674 goto op_semantics_42;
6675 break;
6676 }
6677 break;
6678 case 0xcd:
6679 GETBYTE ();
6680 switch (op[1] & 0x00)
6681 {
6682 case 0x00:
6683 goto op_semantics_42;
6684 break;
6685 }
6686 break;
6687 case 0xce:
6688 GETBYTE ();
6689 switch (op[1] & 0x00)
6690 {
6691 case 0x00:
6692 goto op_semantics_42;
6693 break;
6694 }
6695 break;
6696 case 0xcf:
6697 GETBYTE ();
6698 switch (op[1] & 0x00)
6699 {
6700 case 0x00:
6701 goto op_semantics_42;
6702 break;
6703 }
6704 break;
6705 case 0xd0:
6706 GETBYTE ();
6707 switch (op[1] & 0x00)
6708 {
6709 case 0x00:
6710 goto op_semantics_42;
6711 break;
6712 }
6713 break;
6714 case 0xd1:
6715 GETBYTE ();
6716 switch (op[1] & 0x00)
6717 {
6718 case 0x00:
6719 goto op_semantics_42;
6720 break;
6721 }
6722 break;
6723 case 0xd2:
6724 GETBYTE ();
6725 switch (op[1] & 0x00)
6726 {
6727 case 0x00:
6728 goto op_semantics_42;
6729 break;
6730 }
6731 break;
6732 case 0xd3:
6733 GETBYTE ();
6734 switch (op[1] & 0x00)
6735 {
6736 case 0x00:
6737 goto op_semantics_42;
6738 break;
6739 }
6740 break;
6741 case 0xd4:
6742 GETBYTE ();
6743 switch (op[1] & 0x00)
6744 {
6745 case 0x00:
6746 goto op_semantics_42;
6747 break;
6748 }
6749 break;
6750 case 0xd5:
6751 GETBYTE ();
6752 switch (op[1] & 0x00)
6753 {
6754 case 0x00:
6755 goto op_semantics_42;
6756 break;
6757 }
6758 break;
6759 case 0xd6:
6760 GETBYTE ();
6761 switch (op[1] & 0x00)
6762 {
6763 case 0x00:
6764 goto op_semantics_42;
6765 break;
6766 }
6767 break;
6768 case 0xd7:
6769 GETBYTE ();
6770 switch (op[1] & 0x00)
6771 {
6772 case 0x00:
6773 goto op_semantics_42;
6774 break;
6775 }
6776 break;
6777 case 0xd8:
6778 GETBYTE ();
6779 switch (op[1] & 0x00)
6780 {
6781 case 0x00:
6782 goto op_semantics_42;
6783 break;
6784 }
6785 break;
6786 case 0xd9:
6787 GETBYTE ();
6788 switch (op[1] & 0x00)
6789 {
6790 case 0x00:
6791 goto op_semantics_42;
6792 break;
6793 }
6794 break;
6795 case 0xda:
6796 GETBYTE ();
6797 switch (op[1] & 0x00)
6798 {
6799 case 0x00:
6800 goto op_semantics_42;
6801 break;
6802 }
6803 break;
6804 case 0xdb:
6805 GETBYTE ();
6806 switch (op[1] & 0x00)
6807 {
6808 case 0x00:
6809 goto op_semantics_42;
6810 break;
6811 }
6812 break;
6813 case 0xdc:
6814 GETBYTE ();
6815 switch (op[1] & 0x00)
6816 {
6817 case 0x00:
6818 goto op_semantics_42;
6819 break;
6820 }
6821 break;
6822 case 0xdd:
6823 GETBYTE ();
6824 switch (op[1] & 0x00)
6825 {
6826 case 0x00:
6827 goto op_semantics_42;
6828 break;
6829 }
6830 break;
6831 case 0xde:
6832 GETBYTE ();
6833 switch (op[1] & 0x00)
6834 {
6835 case 0x00:
6836 goto op_semantics_42;
6837 break;
6838 }
6839 break;
6840 case 0xdf:
6841 GETBYTE ();
6842 switch (op[1] & 0x00)
6843 {
6844 case 0x00:
6845 goto op_semantics_42;
6846 break;
6847 }
6848 break;
6849 case 0xe0:
6850 GETBYTE ();
6851 switch (op[1] & 0x00)
6852 {
6853 case 0x00:
6854 goto op_semantics_42;
6855 break;
6856 }
6857 break;
6858 case 0xe1:
6859 GETBYTE ();
6860 switch (op[1] & 0x00)
6861 {
6862 case 0x00:
6863 goto op_semantics_42;
6864 break;
6865 }
6866 break;
6867 case 0xe2:
6868 GETBYTE ();
6869 switch (op[1] & 0x00)
6870 {
6871 case 0x00:
6872 goto op_semantics_42;
6873 break;
6874 }
6875 break;
6876 case 0xe3:
6877 GETBYTE ();
6878 switch (op[1] & 0x00)
6879 {
6880 case 0x00:
6881 goto op_semantics_42;
6882 break;
6883 }
6884 break;
6885 case 0xe4:
6886 GETBYTE ();
6887 switch (op[1] & 0x00)
6888 {
6889 case 0x00:
6890 goto op_semantics_42;
6891 break;
6892 }
6893 break;
6894 case 0xe5:
6895 GETBYTE ();
6896 switch (op[1] & 0x00)
6897 {
6898 case 0x00:
6899 goto op_semantics_42;
6900 break;
6901 }
6902 break;
6903 case 0xe6:
6904 GETBYTE ();
6905 switch (op[1] & 0x00)
6906 {
6907 case 0x00:
6908 goto op_semantics_42;
6909 break;
6910 }
6911 break;
6912 case 0xe7:
6913 GETBYTE ();
6914 switch (op[1] & 0x00)
6915 {
6916 case 0x00:
6917 goto op_semantics_42;
6918 break;
6919 }
6920 break;
6921 case 0xe8:
6922 GETBYTE ();
6923 switch (op[1] & 0x00)
6924 {
6925 case 0x00:
6926 goto op_semantics_42;
6927 break;
6928 }
6929 break;
6930 case 0xe9:
6931 GETBYTE ();
6932 switch (op[1] & 0x00)
6933 {
6934 case 0x00:
6935 goto op_semantics_42;
6936 break;
6937 }
6938 break;
6939 case 0xea:
6940 GETBYTE ();
6941 switch (op[1] & 0x00)
6942 {
6943 case 0x00:
6944 goto op_semantics_42;
6945 break;
6946 }
6947 break;
6948 case 0xeb:
6949 GETBYTE ();
6950 switch (op[1] & 0x00)
6951 {
6952 case 0x00:
6953 goto op_semantics_42;
6954 break;
6955 }
6956 break;
6957 case 0xec:
6958 GETBYTE ();
6959 switch (op[1] & 0x00)
6960 {
6961 case 0x00:
6962 goto op_semantics_42;
6963 break;
6964 }
6965 break;
6966 case 0xed:
6967 GETBYTE ();
6968 switch (op[1] & 0x00)
6969 {
6970 case 0x00:
6971 goto op_semantics_42;
6972 break;
6973 }
6974 break;
6975 case 0xee:
6976 GETBYTE ();
6977 switch (op[1] & 0x00)
6978 {
6979 case 0x00:
6980 goto op_semantics_42;
6981 break;
6982 }
6983 break;
6984 case 0xef:
6985 GETBYTE ();
6986 switch (op[1] & 0x00)
6987 {
6988 case 0x00:
6989 goto op_semantics_42;
6990 break;
6991 }
6992 break;
6993 case 0xf0:
6994 GETBYTE ();
6995 switch (op[1] & 0x08)
6996 {
6997 case 0x00:
6998 op_semantics_43:
6999 {
7000 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
7001 #line 939 "rx-decode.opc"
7002 int sd AU = op[0] & 0x03;
7003 #line 939 "rx-decode.opc"
7004 int rdst AU = (op[1] >> 4) & 0x0f;
7005 #line 939 "rx-decode.opc"
7006 int bit AU = op[1] & 0x07;
7007 if (trace)
7008 {
7009 printf ("\033[33m%s\033[0m %02x %02x\n",
7010 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
7011 op[0], op[1]);
7012 printf (" sd = 0x%x,", sd);
7013 printf (" rdst = 0x%x,", rdst);
7014 printf (" bit = 0x%x\n", bit);
7015 }
7016 SYNTAX("bset #%1, %0%S0");
7017 #line 939 "rx-decode.opc"
7018 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7019
7020 }
7021 break;
7022 case 0x08:
7023 op_semantics_44:
7024 {
7025 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
7026 #line 951 "rx-decode.opc"
7027 int sd AU = op[0] & 0x03;
7028 #line 951 "rx-decode.opc"
7029 int rdst AU = (op[1] >> 4) & 0x0f;
7030 #line 951 "rx-decode.opc"
7031 int bit AU = op[1] & 0x07;
7032 if (trace)
7033 {
7034 printf ("\033[33m%s\033[0m %02x %02x\n",
7035 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
7036 op[0], op[1]);
7037 printf (" sd = 0x%x,", sd);
7038 printf (" rdst = 0x%x,", rdst);
7039 printf (" bit = 0x%x\n", bit);
7040 }
7041 SYNTAX("bclr #%1, %0%S0");
7042 #line 951 "rx-decode.opc"
7043 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7044
7045 }
7046 break;
7047 }
7048 break;
7049 case 0xf1:
7050 GETBYTE ();
7051 switch (op[1] & 0x08)
7052 {
7053 case 0x00:
7054 goto op_semantics_43;
7055 break;
7056 case 0x08:
7057 goto op_semantics_44;
7058 break;
7059 }
7060 break;
7061 case 0xf2:
7062 GETBYTE ();
7063 switch (op[1] & 0x08)
7064 {
7065 case 0x00:
7066 goto op_semantics_43;
7067 break;
7068 case 0x08:
7069 goto op_semantics_44;
7070 break;
7071 }
7072 break;
7073 case 0xf3:
7074 GETBYTE ();
7075 switch (op[1] & 0x08)
7076 {
7077 case 0x00:
7078 goto op_semantics_43;
7079 break;
7080 case 0x08:
7081 goto op_semantics_44;
7082 break;
7083 }
7084 break;
7085 case 0xf4:
7086 GETBYTE ();
7087 switch (op[1] & 0x0c)
7088 {
7089 case 0x00:
7090 case 0x04:
7091 op_semantics_45:
7092 {
7093 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
7094 #line 963 "rx-decode.opc"
7095 int sd AU = op[0] & 0x03;
7096 #line 963 "rx-decode.opc"
7097 int rdst AU = (op[1] >> 4) & 0x0f;
7098 #line 963 "rx-decode.opc"
7099 int bit AU = op[1] & 0x07;
7100 if (trace)
7101 {
7102 printf ("\033[33m%s\033[0m %02x %02x\n",
7103 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
7104 op[0], op[1]);
7105 printf (" sd = 0x%x,", sd);
7106 printf (" rdst = 0x%x,", rdst);
7107 printf (" bit = 0x%x\n", bit);
7108 }
7109 SYNTAX("btst #%2, %1%S1");
7110 #line 963 "rx-decode.opc"
7111 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
7112
7113 }
7114 break;
7115 case 0x08:
7116 op_semantics_46:
7117 {
7118 /** 1111 01ss rsrc 10sz push%s %1 */
7119 #line 381 "rx-decode.opc"
7120 int ss AU = op[0] & 0x03;
7121 #line 381 "rx-decode.opc"
7122 int rsrc AU = (op[1] >> 4) & 0x0f;
7123 #line 381 "rx-decode.opc"
7124 int sz AU = op[1] & 0x03;
7125 if (trace)
7126 {
7127 printf ("\033[33m%s\033[0m %02x %02x\n",
7128 "/** 1111 01ss rsrc 10sz push%s %1 */",
7129 op[0], op[1]);
7130 printf (" ss = 0x%x,", ss);
7131 printf (" rsrc = 0x%x,", rsrc);
7132 printf (" sz = 0x%x\n", sz);
7133 }
7134 SYNTAX("push%s %1");
7135 #line 381 "rx-decode.opc"
7136 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
7137
7138 /*----------------------------------------------------------------------*/
7139 /* XCHG */
7140
7141 }
7142 break;
7143 default: UNSUPPORTED(); break;
7144 }
7145 break;
7146 case 0xf5:
7147 GETBYTE ();
7148 switch (op[1] & 0x0c)
7149 {
7150 case 0x00:
7151 case 0x04:
7152 goto op_semantics_45;
7153 break;
7154 case 0x08:
7155 goto op_semantics_46;
7156 break;
7157 default: UNSUPPORTED(); break;
7158 }
7159 break;
7160 case 0xf6:
7161 GETBYTE ();
7162 switch (op[1] & 0x0c)
7163 {
7164 case 0x00:
7165 case 0x04:
7166 goto op_semantics_45;
7167 break;
7168 case 0x08:
7169 goto op_semantics_46;
7170 break;
7171 default: UNSUPPORTED(); break;
7172 }
7173 break;
7174 case 0xf7:
7175 GETBYTE ();
7176 switch (op[1] & 0x0c)
7177 {
7178 case 0x00:
7179 case 0x04:
7180 goto op_semantics_45;
7181 break;
7182 case 0x08:
7183 goto op_semantics_46;
7184 break;
7185 default: UNSUPPORTED(); break;
7186 }
7187 break;
7188 case 0xf8:
7189 GETBYTE ();
7190 switch (op[1] & 0x00)
7191 {
7192 case 0x00:
7193 op_semantics_47:
7194 {
7195 /** 1111 10sd rdst im sz mov%s #%1, %0 */
7196 #line 292 "rx-decode.opc"
7197 int sd AU = op[0] & 0x03;
7198 #line 292 "rx-decode.opc"
7199 int rdst AU = (op[1] >> 4) & 0x0f;
7200 #line 292 "rx-decode.opc"
7201 int im AU = (op[1] >> 2) & 0x03;
7202 #line 292 "rx-decode.opc"
7203 int sz AU = op[1] & 0x03;
7204 if (trace)
7205 {
7206 printf ("\033[33m%s\033[0m %02x %02x\n",
7207 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
7208 op[0], op[1]);
7209 printf (" sd = 0x%x,", sd);
7210 printf (" rdst = 0x%x,", rdst);
7211 printf (" im = 0x%x,", im);
7212 printf (" sz = 0x%x\n", sz);
7213 }
7214 SYNTAX("mov%s #%1, %0");
7215 #line 292 "rx-decode.opc"
7216 ID(mov); DD(sd, rdst, sz);
7217 if ((im == 1 && sz == 0)
7218 || (im == 2 && sz == 1)
7219 || (im == 0 && sz == 2))
7220 {
7221 BWL (sz);
7222 SC(IMM(im));
7223 }
7224 else
7225 {
7226 sBWL (sz);
7227 SC(IMMex(im));
7228 }
7229 F_____;
7230
7231 }
7232 break;
7233 }
7234 break;
7235 case 0xf9:
7236 GETBYTE ();
7237 switch (op[1] & 0x00)
7238 {
7239 case 0x00:
7240 goto op_semantics_47;
7241 break;
7242 }
7243 break;
7244 case 0xfa:
7245 GETBYTE ();
7246 switch (op[1] & 0x00)
7247 {
7248 case 0x00:
7249 goto op_semantics_47;
7250 break;
7251 }
7252 break;
7253 case 0xfb:
7254 GETBYTE ();
7255 switch (op[1] & 0x00)
7256 {
7257 case 0x00:
7258 goto op_semantics_47;
7259 break;
7260 }
7261 break;
7262 case 0xfc:
7263 GETBYTE ();
7264 switch (op[1] & 0xff)
7265 {
7266 case 0x03:
7267 GETBYTE ();
7268 switch (op[2] & 0x00)
7269 {
7270 case 0x00:
7271 {
7272 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7273 #line 555 "rx-decode.opc"
7274 int rsrc AU = (op[2] >> 4) & 0x0f;
7275 #line 555 "rx-decode.opc"
7276 int rdst AU = op[2] & 0x0f;
7277 if (trace)
7278 {
7279 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7280 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7281 op[0], op[1], op[2]);
7282 printf (" rsrc = 0x%x,", rsrc);
7283 printf (" rdst = 0x%x\n", rdst);
7284 }
7285 SYNTAX("sbb %1, %0");
7286 #line 555 "rx-decode.opc"
7287 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7288
7289 /* FIXME: only supports .L */
7290 }
7291 break;
7292 }
7293 break;
7294 case 0x07:
7295 GETBYTE ();
7296 switch (op[2] & 0x00)
7297 {
7298 case 0x00:
7299 {
7300 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7301 #line 486 "rx-decode.opc"
7302 int rsrc AU = (op[2] >> 4) & 0x0f;
7303 #line 486 "rx-decode.opc"
7304 int rdst AU = op[2] & 0x0f;
7305 if (trace)
7306 {
7307 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7308 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7309 op[0], op[1], op[2]);
7310 printf (" rsrc = 0x%x,", rsrc);
7311 printf (" rdst = 0x%x\n", rdst);
7312 }
7313 SYNTAX("neg %2, %0");
7314 #line 486 "rx-decode.opc"
7315 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7316
7317 /*----------------------------------------------------------------------*/
7318 /* ADC */
7319
7320 }
7321 break;
7322 }
7323 break;
7324 case 0x0b:
7325 GETBYTE ();
7326 switch (op[2] & 0x00)
7327 {
7328 case 0x00:
7329 {
7330 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7331 #line 495 "rx-decode.opc"
7332 int rsrc AU = (op[2] >> 4) & 0x0f;
7333 #line 495 "rx-decode.opc"
7334 int rdst AU = op[2] & 0x0f;
7335 if (trace)
7336 {
7337 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7338 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7339 op[0], op[1], op[2]);
7340 printf (" rsrc = 0x%x,", rsrc);
7341 printf (" rdst = 0x%x\n", rdst);
7342 }
7343 SYNTAX("adc %1, %0");
7344 #line 495 "rx-decode.opc"
7345 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7346
7347 }
7348 break;
7349 }
7350 break;
7351 case 0x0f:
7352 GETBYTE ();
7353 switch (op[2] & 0x00)
7354 {
7355 case 0x00:
7356 {
7357 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7358 #line 568 "rx-decode.opc"
7359 int rsrc AU = (op[2] >> 4) & 0x0f;
7360 #line 568 "rx-decode.opc"
7361 int rdst AU = op[2] & 0x0f;
7362 if (trace)
7363 {
7364 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7365 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7366 op[0], op[1], op[2]);
7367 printf (" rsrc = 0x%x,", rsrc);
7368 printf (" rdst = 0x%x\n", rdst);
7369 }
7370 SYNTAX("abs %1, %0");
7371 #line 568 "rx-decode.opc"
7372 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7373
7374 /*----------------------------------------------------------------------*/
7375 /* MAX */
7376
7377 }
7378 break;
7379 }
7380 break;
7381 case 0x10:
7382 GETBYTE ();
7383 switch (op[2] & 0x00)
7384 {
7385 case 0x00:
7386 op_semantics_48:
7387 {
7388 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7389 #line 587 "rx-decode.opc"
7390 int ss AU = op[1] & 0x03;
7391 #line 587 "rx-decode.opc"
7392 int rsrc AU = (op[2] >> 4) & 0x0f;
7393 #line 587 "rx-decode.opc"
7394 int rdst AU = op[2] & 0x0f;
7395 if (trace)
7396 {
7397 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7398 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7399 op[0], op[1], op[2]);
7400 printf (" ss = 0x%x,", ss);
7401 printf (" rsrc = 0x%x,", rsrc);
7402 printf (" rdst = 0x%x\n", rdst);
7403 }
7404 SYNTAX("max %1%S1, %0");
7405 #line 587 "rx-decode.opc"
7406 if (ss == 3 && rsrc == 0 && rdst == 0)
7407 {
7408 ID(nop3);
7409 SYNTAX("nop\t; max\tr0, r0");
7410 }
7411 else
7412 {
7413 ID(max); SP(ss, rsrc); DR(rdst);
7414 }
7415
7416 }
7417 break;
7418 }
7419 break;
7420 case 0x11:
7421 GETBYTE ();
7422 switch (op[2] & 0x00)
7423 {
7424 case 0x00:
7425 goto op_semantics_48;
7426 break;
7427 }
7428 break;
7429 case 0x12:
7430 GETBYTE ();
7431 switch (op[2] & 0x00)
7432 {
7433 case 0x00:
7434 goto op_semantics_48;
7435 break;
7436 }
7437 break;
7438 case 0x13:
7439 GETBYTE ();
7440 switch (op[2] & 0x00)
7441 {
7442 case 0x00:
7443 goto op_semantics_48;
7444 break;
7445 }
7446 break;
7447 case 0x14:
7448 GETBYTE ();
7449 switch (op[2] & 0x00)
7450 {
7451 case 0x00:
7452 op_semantics_49:
7453 {
7454 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7455 #line 607 "rx-decode.opc"
7456 int ss AU = op[1] & 0x03;
7457 #line 607 "rx-decode.opc"
7458 int rsrc AU = (op[2] >> 4) & 0x0f;
7459 #line 607 "rx-decode.opc"
7460 int rdst AU = op[2] & 0x0f;
7461 if (trace)
7462 {
7463 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7464 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7465 op[0], op[1], op[2]);
7466 printf (" ss = 0x%x,", ss);
7467 printf (" rsrc = 0x%x,", rsrc);
7468 printf (" rdst = 0x%x\n", rdst);
7469 }
7470 SYNTAX("min %1%S1, %0");
7471 #line 607 "rx-decode.opc"
7472 ID(min); SP(ss, rsrc); DR(rdst);
7473
7474 }
7475 break;
7476 }
7477 break;
7478 case 0x15:
7479 GETBYTE ();
7480 switch (op[2] & 0x00)
7481 {
7482 case 0x00:
7483 goto op_semantics_49;
7484 break;
7485 }
7486 break;
7487 case 0x16:
7488 GETBYTE ();
7489 switch (op[2] & 0x00)
7490 {
7491 case 0x00:
7492 goto op_semantics_49;
7493 break;
7494 }
7495 break;
7496 case 0x17:
7497 GETBYTE ();
7498 switch (op[2] & 0x00)
7499 {
7500 case 0x00:
7501 goto op_semantics_49;
7502 break;
7503 }
7504 break;
7505 case 0x18:
7506 GETBYTE ();
7507 switch (op[2] & 0x00)
7508 {
7509 case 0x00:
7510 op_semantics_50:
7511 {
7512 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7513 #line 665 "rx-decode.opc"
7514 int ss AU = op[1] & 0x03;
7515 #line 665 "rx-decode.opc"
7516 int rsrc AU = (op[2] >> 4) & 0x0f;
7517 #line 665 "rx-decode.opc"
7518 int rdst AU = op[2] & 0x0f;
7519 if (trace)
7520 {
7521 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7522 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7523 op[0], op[1], op[2]);
7524 printf (" ss = 0x%x,", ss);
7525 printf (" rsrc = 0x%x,", rsrc);
7526 printf (" rdst = 0x%x\n", rdst);
7527 }
7528 SYNTAX("emul %1%S1, %0");
7529 #line 665 "rx-decode.opc"
7530 ID(emul); SP(ss, rsrc); DR(rdst);
7531
7532 }
7533 break;
7534 }
7535 break;
7536 case 0x19:
7537 GETBYTE ();
7538 switch (op[2] & 0x00)
7539 {
7540 case 0x00:
7541 goto op_semantics_50;
7542 break;
7543 }
7544 break;
7545 case 0x1a:
7546 GETBYTE ();
7547 switch (op[2] & 0x00)
7548 {
7549 case 0x00:
7550 goto op_semantics_50;
7551 break;
7552 }
7553 break;
7554 case 0x1b:
7555 GETBYTE ();
7556 switch (op[2] & 0x00)
7557 {
7558 case 0x00:
7559 goto op_semantics_50;
7560 break;
7561 }
7562 break;
7563 case 0x1c:
7564 GETBYTE ();
7565 switch (op[2] & 0x00)
7566 {
7567 case 0x00:
7568 op_semantics_51:
7569 {
7570 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7571 #line 677 "rx-decode.opc"
7572 int ss AU = op[1] & 0x03;
7573 #line 677 "rx-decode.opc"
7574 int rsrc AU = (op[2] >> 4) & 0x0f;
7575 #line 677 "rx-decode.opc"
7576 int rdst AU = op[2] & 0x0f;
7577 if (trace)
7578 {
7579 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7580 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7581 op[0], op[1], op[2]);
7582 printf (" ss = 0x%x,", ss);
7583 printf (" rsrc = 0x%x,", rsrc);
7584 printf (" rdst = 0x%x\n", rdst);
7585 }
7586 SYNTAX("emulu %1%S1, %0");
7587 #line 677 "rx-decode.opc"
7588 ID(emulu); SP(ss, rsrc); DR(rdst);
7589
7590 }
7591 break;
7592 }
7593 break;
7594 case 0x1d:
7595 GETBYTE ();
7596 switch (op[2] & 0x00)
7597 {
7598 case 0x00:
7599 goto op_semantics_51;
7600 break;
7601 }
7602 break;
7603 case 0x1e:
7604 GETBYTE ();
7605 switch (op[2] & 0x00)
7606 {
7607 case 0x00:
7608 goto op_semantics_51;
7609 break;
7610 }
7611 break;
7612 case 0x1f:
7613 GETBYTE ();
7614 switch (op[2] & 0x00)
7615 {
7616 case 0x00:
7617 goto op_semantics_51;
7618 break;
7619 }
7620 break;
7621 case 0x20:
7622 GETBYTE ();
7623 switch (op[2] & 0x00)
7624 {
7625 case 0x00:
7626 op_semantics_52:
7627 {
7628 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7629 #line 689 "rx-decode.opc"
7630 int ss AU = op[1] & 0x03;
7631 #line 689 "rx-decode.opc"
7632 int rsrc AU = (op[2] >> 4) & 0x0f;
7633 #line 689 "rx-decode.opc"
7634 int rdst AU = op[2] & 0x0f;
7635 if (trace)
7636 {
7637 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7638 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7639 op[0], op[1], op[2]);
7640 printf (" ss = 0x%x,", ss);
7641 printf (" rsrc = 0x%x,", rsrc);
7642 printf (" rdst = 0x%x\n", rdst);
7643 }
7644 SYNTAX("div %1%S1, %0");
7645 #line 689 "rx-decode.opc"
7646 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7647
7648 }
7649 break;
7650 }
7651 break;
7652 case 0x21:
7653 GETBYTE ();
7654 switch (op[2] & 0x00)
7655 {
7656 case 0x00:
7657 goto op_semantics_52;
7658 break;
7659 }
7660 break;
7661 case 0x22:
7662 GETBYTE ();
7663 switch (op[2] & 0x00)
7664 {
7665 case 0x00:
7666 goto op_semantics_52;
7667 break;
7668 }
7669 break;
7670 case 0x23:
7671 GETBYTE ();
7672 switch (op[2] & 0x00)
7673 {
7674 case 0x00:
7675 goto op_semantics_52;
7676 break;
7677 }
7678 break;
7679 case 0x24:
7680 GETBYTE ();
7681 switch (op[2] & 0x00)
7682 {
7683 case 0x00:
7684 op_semantics_53:
7685 {
7686 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7687 #line 701 "rx-decode.opc"
7688 int ss AU = op[1] & 0x03;
7689 #line 701 "rx-decode.opc"
7690 int rsrc AU = (op[2] >> 4) & 0x0f;
7691 #line 701 "rx-decode.opc"
7692 int rdst AU = op[2] & 0x0f;
7693 if (trace)
7694 {
7695 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7696 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7697 op[0], op[1], op[2]);
7698 printf (" ss = 0x%x,", ss);
7699 printf (" rsrc = 0x%x,", rsrc);
7700 printf (" rdst = 0x%x\n", rdst);
7701 }
7702 SYNTAX("divu %1%S1, %0");
7703 #line 701 "rx-decode.opc"
7704 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7705
7706 }
7707 break;
7708 }
7709 break;
7710 case 0x25:
7711 GETBYTE ();
7712 switch (op[2] & 0x00)
7713 {
7714 case 0x00:
7715 goto op_semantics_53;
7716 break;
7717 }
7718 break;
7719 case 0x26:
7720 GETBYTE ();
7721 switch (op[2] & 0x00)
7722 {
7723 case 0x00:
7724 goto op_semantics_53;
7725 break;
7726 }
7727 break;
7728 case 0x27:
7729 GETBYTE ();
7730 switch (op[2] & 0x00)
7731 {
7732 case 0x00:
7733 goto op_semantics_53;
7734 break;
7735 }
7736 break;
7737 case 0x30:
7738 GETBYTE ();
7739 switch (op[2] & 0x00)
7740 {
7741 case 0x00:
7742 op_semantics_54:
7743 {
7744 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7745 #line 474 "rx-decode.opc"
7746 int ss AU = op[1] & 0x03;
7747 #line 474 "rx-decode.opc"
7748 int rsrc AU = (op[2] >> 4) & 0x0f;
7749 #line 474 "rx-decode.opc"
7750 int rdst AU = op[2] & 0x0f;
7751 if (trace)
7752 {
7753 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7754 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7755 op[0], op[1], op[2]);
7756 printf (" ss = 0x%x,", ss);
7757 printf (" rsrc = 0x%x,", rsrc);
7758 printf (" rdst = 0x%x\n", rdst);
7759 }
7760 SYNTAX("tst %1%S1, %2");
7761 #line 474 "rx-decode.opc"
7762 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7763
7764 }
7765 break;
7766 }
7767 break;
7768 case 0x31:
7769 GETBYTE ();
7770 switch (op[2] & 0x00)
7771 {
7772 case 0x00:
7773 goto op_semantics_54;
7774 break;
7775 }
7776 break;
7777 case 0x32:
7778 GETBYTE ();
7779 switch (op[2] & 0x00)
7780 {
7781 case 0x00:
7782 goto op_semantics_54;
7783 break;
7784 }
7785 break;
7786 case 0x33:
7787 GETBYTE ();
7788 switch (op[2] & 0x00)
7789 {
7790 case 0x00:
7791 goto op_semantics_54;
7792 break;
7793 }
7794 break;
7795 case 0x34:
7796 GETBYTE ();
7797 switch (op[2] & 0x00)
7798 {
7799 case 0x00:
7800 op_semantics_55:
7801 {
7802 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7803 #line 453 "rx-decode.opc"
7804 int ss AU = op[1] & 0x03;
7805 #line 453 "rx-decode.opc"
7806 int rsrc AU = (op[2] >> 4) & 0x0f;
7807 #line 453 "rx-decode.opc"
7808 int rdst AU = op[2] & 0x0f;
7809 if (trace)
7810 {
7811 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7812 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7813 op[0], op[1], op[2]);
7814 printf (" ss = 0x%x,", ss);
7815 printf (" rsrc = 0x%x,", rsrc);
7816 printf (" rdst = 0x%x\n", rdst);
7817 }
7818 SYNTAX("xor %1%S1, %0");
7819 #line 453 "rx-decode.opc"
7820 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7821
7822 }
7823 break;
7824 }
7825 break;
7826 case 0x35:
7827 GETBYTE ();
7828 switch (op[2] & 0x00)
7829 {
7830 case 0x00:
7831 goto op_semantics_55;
7832 break;
7833 }
7834 break;
7835 case 0x36:
7836 GETBYTE ();
7837 switch (op[2] & 0x00)
7838 {
7839 case 0x00:
7840 goto op_semantics_55;
7841 break;
7842 }
7843 break;
7844 case 0x37:
7845 GETBYTE ();
7846 switch (op[2] & 0x00)
7847 {
7848 case 0x00:
7849 goto op_semantics_55;
7850 break;
7851 }
7852 break;
7853 case 0x3b:
7854 GETBYTE ();
7855 switch (op[2] & 0x00)
7856 {
7857 case 0x00:
7858 {
7859 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7860 #line 465 "rx-decode.opc"
7861 int rsrc AU = (op[2] >> 4) & 0x0f;
7862 #line 465 "rx-decode.opc"
7863 int rdst AU = op[2] & 0x0f;
7864 if (trace)
7865 {
7866 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7867 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7868 op[0], op[1], op[2]);
7869 printf (" rsrc = 0x%x,", rsrc);
7870 printf (" rdst = 0x%x\n", rdst);
7871 }
7872 SYNTAX("not %1, %0");
7873 #line 465 "rx-decode.opc"
7874 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7875
7876 /*----------------------------------------------------------------------*/
7877 /* TST */
7878
7879 }
7880 break;
7881 }
7882 break;
7883 case 0x40:
7884 GETBYTE ();
7885 switch (op[2] & 0x00)
7886 {
7887 case 0x00:
7888 op_semantics_56:
7889 {
7890 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7891 #line 387 "rx-decode.opc"
7892 int ss AU = op[1] & 0x03;
7893 #line 387 "rx-decode.opc"
7894 int rsrc AU = (op[2] >> 4) & 0x0f;
7895 #line 387 "rx-decode.opc"
7896 int rdst AU = op[2] & 0x0f;
7897 if (trace)
7898 {
7899 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7900 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7901 op[0], op[1], op[2]);
7902 printf (" ss = 0x%x,", ss);
7903 printf (" rsrc = 0x%x,", rsrc);
7904 printf (" rdst = 0x%x\n", rdst);
7905 }
7906 SYNTAX("xchg %1%S1, %0");
7907 #line 387 "rx-decode.opc"
7908 ID(xchg); DR(rdst); SP(ss, rsrc);
7909
7910 }
7911 break;
7912 }
7913 break;
7914 case 0x41:
7915 GETBYTE ();
7916 switch (op[2] & 0x00)
7917 {
7918 case 0x00:
7919 goto op_semantics_56;
7920 break;
7921 }
7922 break;
7923 case 0x42:
7924 GETBYTE ();
7925 switch (op[2] & 0x00)
7926 {
7927 case 0x00:
7928 goto op_semantics_56;
7929 break;
7930 }
7931 break;
7932 case 0x43:
7933 GETBYTE ();
7934 switch (op[2] & 0x00)
7935 {
7936 case 0x00:
7937 goto op_semantics_56;
7938 break;
7939 }
7940 break;
7941 case 0x44:
7942 GETBYTE ();
7943 switch (op[2] & 0x00)
7944 {
7945 case 0x00:
7946 op_semantics_57:
7947 {
7948 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7949 #line 930 "rx-decode.opc"
7950 int sd AU = op[1] & 0x03;
7951 #line 930 "rx-decode.opc"
7952 int rsrc AU = (op[2] >> 4) & 0x0f;
7953 #line 930 "rx-decode.opc"
7954 int rdst AU = op[2] & 0x0f;
7955 if (trace)
7956 {
7957 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7958 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7959 op[0], op[1], op[2]);
7960 printf (" sd = 0x%x,", sd);
7961 printf (" rsrc = 0x%x,", rsrc);
7962 printf (" rdst = 0x%x\n", rdst);
7963 }
7964 SYNTAX("itof %1%S1, %0");
7965 #line 930 "rx-decode.opc"
7966 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7967
7968 }
7969 break;
7970 }
7971 break;
7972 case 0x45:
7973 GETBYTE ();
7974 switch (op[2] & 0x00)
7975 {
7976 case 0x00:
7977 goto op_semantics_57;
7978 break;
7979 }
7980 break;
7981 case 0x46:
7982 GETBYTE ();
7983 switch (op[2] & 0x00)
7984 {
7985 case 0x00:
7986 goto op_semantics_57;
7987 break;
7988 }
7989 break;
7990 case 0x47:
7991 GETBYTE ();
7992 switch (op[2] & 0x00)
7993 {
7994 case 0x00:
7995 goto op_semantics_57;
7996 break;
7997 }
7998 break;
7999 case 0x4b:
8000 GETBYTE ();
8001 switch (op[2] & 0x00)
8002 {
8003 case 0x00:
8004 {
8005 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
8006 #line 1056 "rx-decode.opc"
8007 int rsrc AU = (op[2] >> 4) & 0x0f;
8008 #line 1056 "rx-decode.opc"
8009 int rdst AU = op[2] & 0x0f;
8010 if (trace)
8011 {
8012 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8013 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
8014 op[0], op[1], op[2]);
8015 printf (" rsrc = 0x%x,", rsrc);
8016 printf (" rdst = 0x%x\n", rdst);
8017 }
8018 SYNTAX("stz %1, %0");
8019 #line 1056 "rx-decode.opc"
8020 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
8021
8022 }
8023 break;
8024 }
8025 break;
8026 case 0x4f:
8027 GETBYTE ();
8028 switch (op[2] & 0x00)
8029 {
8030 case 0x00:
8031 {
8032 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
8033 #line 1059 "rx-decode.opc"
8034 int rsrc AU = (op[2] >> 4) & 0x0f;
8035 #line 1059 "rx-decode.opc"
8036 int rdst AU = op[2] & 0x0f;
8037 if (trace)
8038 {
8039 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8040 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
8041 op[0], op[1], op[2]);
8042 printf (" rsrc = 0x%x,", rsrc);
8043 printf (" rdst = 0x%x\n", rdst);
8044 }
8045 SYNTAX("stnz %1, %0");
8046 #line 1059 "rx-decode.opc"
8047 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
8048
8049 }
8050 break;
8051 }
8052 break;
8053 case 0x54:
8054 GETBYTE ();
8055 switch (op[2] & 0x00)
8056 {
8057 case 0x00:
8058 op_semantics_58:
8059 {
8060 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
8061 #line 1116 "rx-decode.opc"
8062 int sd AU = op[1] & 0x03;
8063 #line 1116 "rx-decode.opc"
8064 int rsrc AU = (op[2] >> 4) & 0x0f;
8065 #line 1116 "rx-decode.opc"
8066 int rdst AU = op[2] & 0x0f;
8067 if (trace)
8068 {
8069 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8070 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
8071 op[0], op[1], op[2]);
8072 printf (" sd = 0x%x,", sd);
8073 printf (" rsrc = 0x%x,", rsrc);
8074 printf (" rdst = 0x%x\n", rdst);
8075 }
8076 SYNTAX("utof %1%S1, %0");
8077 #line 1116 "rx-decode.opc"
8078 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
8079
8080 }
8081 break;
8082 }
8083 break;
8084 case 0x55:
8085 GETBYTE ();
8086 switch (op[2] & 0x00)
8087 {
8088 case 0x00:
8089 goto op_semantics_58;
8090 break;
8091 }
8092 break;
8093 case 0x56:
8094 GETBYTE ();
8095 switch (op[2] & 0x00)
8096 {
8097 case 0x00:
8098 goto op_semantics_58;
8099 break;
8100 }
8101 break;
8102 case 0x57:
8103 GETBYTE ();
8104 switch (op[2] & 0x00)
8105 {
8106 case 0x00:
8107 goto op_semantics_58;
8108 break;
8109 }
8110 break;
8111 case 0x60:
8112 GETBYTE ();
8113 switch (op[2] & 0x00)
8114 {
8115 case 0x00:
8116 op_semantics_59:
8117 {
8118 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
8119 #line 942 "rx-decode.opc"
8120 int sd AU = op[1] & 0x03;
8121 #line 942 "rx-decode.opc"
8122 int rdst AU = (op[2] >> 4) & 0x0f;
8123 #line 942 "rx-decode.opc"
8124 int rsrc AU = op[2] & 0x0f;
8125 if (trace)
8126 {
8127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8128 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
8129 op[0], op[1], op[2]);
8130 printf (" sd = 0x%x,", sd);
8131 printf (" rdst = 0x%x,", rdst);
8132 printf (" rsrc = 0x%x\n", rsrc);
8133 }
8134 SYNTAX("bset %1, %0%S0");
8135 #line 942 "rx-decode.opc"
8136 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8137 if (sd == 3) /* bset reg,reg */
8138 BWL(LSIZE);
8139
8140 }
8141 break;
8142 }
8143 break;
8144 case 0x61:
8145 GETBYTE ();
8146 switch (op[2] & 0x00)
8147 {
8148 case 0x00:
8149 goto op_semantics_59;
8150 break;
8151 }
8152 break;
8153 case 0x62:
8154 GETBYTE ();
8155 switch (op[2] & 0x00)
8156 {
8157 case 0x00:
8158 goto op_semantics_59;
8159 break;
8160 }
8161 break;
8162 case 0x63:
8163 GETBYTE ();
8164 switch (op[2] & 0x00)
8165 {
8166 case 0x00:
8167 goto op_semantics_59;
8168 break;
8169 }
8170 break;
8171 case 0x64:
8172 GETBYTE ();
8173 switch (op[2] & 0x00)
8174 {
8175 case 0x00:
8176 op_semantics_60:
8177 {
8178 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
8179 #line 954 "rx-decode.opc"
8180 int sd AU = op[1] & 0x03;
8181 #line 954 "rx-decode.opc"
8182 int rdst AU = (op[2] >> 4) & 0x0f;
8183 #line 954 "rx-decode.opc"
8184 int rsrc AU = op[2] & 0x0f;
8185 if (trace)
8186 {
8187 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8188 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
8189 op[0], op[1], op[2]);
8190 printf (" sd = 0x%x,", sd);
8191 printf (" rdst = 0x%x,", rdst);
8192 printf (" rsrc = 0x%x\n", rsrc);
8193 }
8194 SYNTAX("bclr %1, %0%S0");
8195 #line 954 "rx-decode.opc"
8196 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8197 if (sd == 3) /* bset reg,reg */
8198 BWL(LSIZE);
8199
8200 }
8201 break;
8202 }
8203 break;
8204 case 0x65:
8205 GETBYTE ();
8206 switch (op[2] & 0x00)
8207 {
8208 case 0x00:
8209 goto op_semantics_60;
8210 break;
8211 }
8212 break;
8213 case 0x66:
8214 GETBYTE ();
8215 switch (op[2] & 0x00)
8216 {
8217 case 0x00:
8218 goto op_semantics_60;
8219 break;
8220 }
8221 break;
8222 case 0x67:
8223 GETBYTE ();
8224 switch (op[2] & 0x00)
8225 {
8226 case 0x00:
8227 goto op_semantics_60;
8228 break;
8229 }
8230 break;
8231 case 0x68:
8232 GETBYTE ();
8233 switch (op[2] & 0x00)
8234 {
8235 case 0x00:
8236 op_semantics_61:
8237 {
8238 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
8239 #line 966 "rx-decode.opc"
8240 int sd AU = op[1] & 0x03;
8241 #line 966 "rx-decode.opc"
8242 int rdst AU = (op[2] >> 4) & 0x0f;
8243 #line 966 "rx-decode.opc"
8244 int rsrc AU = op[2] & 0x0f;
8245 if (trace)
8246 {
8247 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8248 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
8249 op[0], op[1], op[2]);
8250 printf (" sd = 0x%x,", sd);
8251 printf (" rdst = 0x%x,", rdst);
8252 printf (" rsrc = 0x%x\n", rsrc);
8253 }
8254 SYNTAX("btst %2, %1%S1");
8255 #line 966 "rx-decode.opc"
8256 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8257 if (sd == 3) /* bset reg,reg */
8258 BWL(LSIZE);
8259
8260 }
8261 break;
8262 }
8263 break;
8264 case 0x69:
8265 GETBYTE ();
8266 switch (op[2] & 0x00)
8267 {
8268 case 0x00:
8269 goto op_semantics_61;
8270 break;
8271 }
8272 break;
8273 case 0x6a:
8274 GETBYTE ();
8275 switch (op[2] & 0x00)
8276 {
8277 case 0x00:
8278 goto op_semantics_61;
8279 break;
8280 }
8281 break;
8282 case 0x6b:
8283 GETBYTE ();
8284 switch (op[2] & 0x00)
8285 {
8286 case 0x00:
8287 goto op_semantics_61;
8288 break;
8289 }
8290 break;
8291 case 0x6c:
8292 GETBYTE ();
8293 switch (op[2] & 0x00)
8294 {
8295 case 0x00:
8296 op_semantics_62:
8297 {
8298 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
8299 #line 978 "rx-decode.opc"
8300 int sd AU = op[1] & 0x03;
8301 #line 978 "rx-decode.opc"
8302 int rdst AU = (op[2] >> 4) & 0x0f;
8303 #line 978 "rx-decode.opc"
8304 int rsrc AU = op[2] & 0x0f;
8305 if (trace)
8306 {
8307 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8308 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
8309 op[0], op[1], op[2]);
8310 printf (" sd = 0x%x,", sd);
8311 printf (" rdst = 0x%x,", rdst);
8312 printf (" rsrc = 0x%x\n", rsrc);
8313 }
8314 SYNTAX("bnot %1, %0%S0");
8315 #line 978 "rx-decode.opc"
8316 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8317 if (sd == 3) /* bset reg,reg */
8318 BWL(LSIZE);
8319
8320 }
8321 break;
8322 }
8323 break;
8324 case 0x6d:
8325 GETBYTE ();
8326 switch (op[2] & 0x00)
8327 {
8328 case 0x00:
8329 goto op_semantics_62;
8330 break;
8331 }
8332 break;
8333 case 0x6e:
8334 GETBYTE ();
8335 switch (op[2] & 0x00)
8336 {
8337 case 0x00:
8338 goto op_semantics_62;
8339 break;
8340 }
8341 break;
8342 case 0x6f:
8343 GETBYTE ();
8344 switch (op[2] & 0x00)
8345 {
8346 case 0x00:
8347 goto op_semantics_62;
8348 break;
8349 }
8350 break;
8351 case 0x80:
8352 GETBYTE ();
8353 switch (op[2] & 0x00)
8354 {
8355 case 0x00:
8356 op_semantics_63:
8357 {
8358 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8359 #line 909 "rx-decode.opc"
8360 int sd AU = op[1] & 0x03;
8361 #line 909 "rx-decode.opc"
8362 int rsrc AU = (op[2] >> 4) & 0x0f;
8363 #line 909 "rx-decode.opc"
8364 int rdst AU = op[2] & 0x0f;
8365 if (trace)
8366 {
8367 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8368 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8369 op[0], op[1], op[2]);
8370 printf (" sd = 0x%x,", sd);
8371 printf (" rsrc = 0x%x,", rsrc);
8372 printf (" rdst = 0x%x\n", rdst);
8373 }
8374 SYNTAX("fsub %1%S1, %0");
8375 #line 909 "rx-decode.opc"
8376 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8377
8378 }
8379 break;
8380 }
8381 break;
8382 case 0x81:
8383 GETBYTE ();
8384 switch (op[2] & 0x00)
8385 {
8386 case 0x00:
8387 goto op_semantics_63;
8388 break;
8389 }
8390 break;
8391 case 0x82:
8392 GETBYTE ();
8393 switch (op[2] & 0x00)
8394 {
8395 case 0x00:
8396 goto op_semantics_63;
8397 break;
8398 }
8399 break;
8400 case 0x83:
8401 GETBYTE ();
8402 switch (op[2] & 0x00)
8403 {
8404 case 0x00:
8405 goto op_semantics_63;
8406 break;
8407 }
8408 break;
8409 case 0x84:
8410 GETBYTE ();
8411 switch (op[2] & 0x00)
8412 {
8413 case 0x00:
8414 op_semantics_64:
8415 {
8416 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8417 #line 903 "rx-decode.opc"
8418 int sd AU = op[1] & 0x03;
8419 #line 903 "rx-decode.opc"
8420 int rsrc AU = (op[2] >> 4) & 0x0f;
8421 #line 903 "rx-decode.opc"
8422 int rdst AU = op[2] & 0x0f;
8423 if (trace)
8424 {
8425 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8426 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8427 op[0], op[1], op[2]);
8428 printf (" sd = 0x%x,", sd);
8429 printf (" rsrc = 0x%x,", rsrc);
8430 printf (" rdst = 0x%x\n", rdst);
8431 }
8432 SYNTAX("fcmp %1%S1, %0");
8433 #line 903 "rx-decode.opc"
8434 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8435
8436 }
8437 break;
8438 }
8439 break;
8440 case 0x85:
8441 GETBYTE ();
8442 switch (op[2] & 0x00)
8443 {
8444 case 0x00:
8445 goto op_semantics_64;
8446 break;
8447 }
8448 break;
8449 case 0x86:
8450 GETBYTE ();
8451 switch (op[2] & 0x00)
8452 {
8453 case 0x00:
8454 goto op_semantics_64;
8455 break;
8456 }
8457 break;
8458 case 0x87:
8459 GETBYTE ();
8460 switch (op[2] & 0x00)
8461 {
8462 case 0x00:
8463 goto op_semantics_64;
8464 break;
8465 }
8466 break;
8467 case 0x88:
8468 GETBYTE ();
8469 switch (op[2] & 0x00)
8470 {
8471 case 0x00:
8472 op_semantics_65:
8473 {
8474 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8475 #line 897 "rx-decode.opc"
8476 int sd AU = op[1] & 0x03;
8477 #line 897 "rx-decode.opc"
8478 int rsrc AU = (op[2] >> 4) & 0x0f;
8479 #line 897 "rx-decode.opc"
8480 int rdst AU = op[2] & 0x0f;
8481 if (trace)
8482 {
8483 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8484 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8485 op[0], op[1], op[2]);
8486 printf (" sd = 0x%x,", sd);
8487 printf (" rsrc = 0x%x,", rsrc);
8488 printf (" rdst = 0x%x\n", rdst);
8489 }
8490 SYNTAX("fadd %1%S1, %0");
8491 #line 897 "rx-decode.opc"
8492 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8493
8494 }
8495 break;
8496 }
8497 break;
8498 case 0x89:
8499 GETBYTE ();
8500 switch (op[2] & 0x00)
8501 {
8502 case 0x00:
8503 goto op_semantics_65;
8504 break;
8505 }
8506 break;
8507 case 0x8a:
8508 GETBYTE ();
8509 switch (op[2] & 0x00)
8510 {
8511 case 0x00:
8512 goto op_semantics_65;
8513 break;
8514 }
8515 break;
8516 case 0x8b:
8517 GETBYTE ();
8518 switch (op[2] & 0x00)
8519 {
8520 case 0x00:
8521 goto op_semantics_65;
8522 break;
8523 }
8524 break;
8525 case 0x8c:
8526 GETBYTE ();
8527 switch (op[2] & 0x00)
8528 {
8529 case 0x00:
8530 op_semantics_66:
8531 {
8532 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8533 #line 918 "rx-decode.opc"
8534 int sd AU = op[1] & 0x03;
8535 #line 918 "rx-decode.opc"
8536 int rsrc AU = (op[2] >> 4) & 0x0f;
8537 #line 918 "rx-decode.opc"
8538 int rdst AU = op[2] & 0x0f;
8539 if (trace)
8540 {
8541 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8542 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8543 op[0], op[1], op[2]);
8544 printf (" sd = 0x%x,", sd);
8545 printf (" rsrc = 0x%x,", rsrc);
8546 printf (" rdst = 0x%x\n", rdst);
8547 }
8548 SYNTAX("fmul %1%S1, %0");
8549 #line 918 "rx-decode.opc"
8550 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8551
8552 }
8553 break;
8554 }
8555 break;
8556 case 0x8d:
8557 GETBYTE ();
8558 switch (op[2] & 0x00)
8559 {
8560 case 0x00:
8561 goto op_semantics_66;
8562 break;
8563 }
8564 break;
8565 case 0x8e:
8566 GETBYTE ();
8567 switch (op[2] & 0x00)
8568 {
8569 case 0x00:
8570 goto op_semantics_66;
8571 break;
8572 }
8573 break;
8574 case 0x8f:
8575 GETBYTE ();
8576 switch (op[2] & 0x00)
8577 {
8578 case 0x00:
8579 goto op_semantics_66;
8580 break;
8581 }
8582 break;
8583 case 0x90:
8584 GETBYTE ();
8585 switch (op[2] & 0x00)
8586 {
8587 case 0x00:
8588 op_semantics_67:
8589 {
8590 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8591 #line 924 "rx-decode.opc"
8592 int sd AU = op[1] & 0x03;
8593 #line 924 "rx-decode.opc"
8594 int rsrc AU = (op[2] >> 4) & 0x0f;
8595 #line 924 "rx-decode.opc"
8596 int rdst AU = op[2] & 0x0f;
8597 if (trace)
8598 {
8599 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8600 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8601 op[0], op[1], op[2]);
8602 printf (" sd = 0x%x,", sd);
8603 printf (" rsrc = 0x%x,", rsrc);
8604 printf (" rdst = 0x%x\n", rdst);
8605 }
8606 SYNTAX("fdiv %1%S1, %0");
8607 #line 924 "rx-decode.opc"
8608 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8609
8610 }
8611 break;
8612 }
8613 break;
8614 case 0x91:
8615 GETBYTE ();
8616 switch (op[2] & 0x00)
8617 {
8618 case 0x00:
8619 goto op_semantics_67;
8620 break;
8621 }
8622 break;
8623 case 0x92:
8624 GETBYTE ();
8625 switch (op[2] & 0x00)
8626 {
8627 case 0x00:
8628 goto op_semantics_67;
8629 break;
8630 }
8631 break;
8632 case 0x93:
8633 GETBYTE ();
8634 switch (op[2] & 0x00)
8635 {
8636 case 0x00:
8637 goto op_semantics_67;
8638 break;
8639 }
8640 break;
8641 case 0x94:
8642 GETBYTE ();
8643 switch (op[2] & 0x00)
8644 {
8645 case 0x00:
8646 op_semantics_68:
8647 {
8648 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8649 #line 912 "rx-decode.opc"
8650 int sd AU = op[1] & 0x03;
8651 #line 912 "rx-decode.opc"
8652 int rsrc AU = (op[2] >> 4) & 0x0f;
8653 #line 912 "rx-decode.opc"
8654 int rdst AU = op[2] & 0x0f;
8655 if (trace)
8656 {
8657 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8658 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8659 op[0], op[1], op[2]);
8660 printf (" sd = 0x%x,", sd);
8661 printf (" rsrc = 0x%x,", rsrc);
8662 printf (" rdst = 0x%x\n", rdst);
8663 }
8664 SYNTAX("ftoi %1%S1, %0");
8665 #line 912 "rx-decode.opc"
8666 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8667
8668 }
8669 break;
8670 }
8671 break;
8672 case 0x95:
8673 GETBYTE ();
8674 switch (op[2] & 0x00)
8675 {
8676 case 0x00:
8677 goto op_semantics_68;
8678 break;
8679 }
8680 break;
8681 case 0x96:
8682 GETBYTE ();
8683 switch (op[2] & 0x00)
8684 {
8685 case 0x00:
8686 goto op_semantics_68;
8687 break;
8688 }
8689 break;
8690 case 0x97:
8691 GETBYTE ();
8692 switch (op[2] & 0x00)
8693 {
8694 case 0x00:
8695 goto op_semantics_68;
8696 break;
8697 }
8698 break;
8699 case 0x98:
8700 GETBYTE ();
8701 switch (op[2] & 0x00)
8702 {
8703 case 0x00:
8704 op_semantics_69:
8705 {
8706 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8707 #line 927 "rx-decode.opc"
8708 int sd AU = op[1] & 0x03;
8709 #line 927 "rx-decode.opc"
8710 int rsrc AU = (op[2] >> 4) & 0x0f;
8711 #line 927 "rx-decode.opc"
8712 int rdst AU = op[2] & 0x0f;
8713 if (trace)
8714 {
8715 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8716 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8717 op[0], op[1], op[2]);
8718 printf (" sd = 0x%x,", sd);
8719 printf (" rsrc = 0x%x,", rsrc);
8720 printf (" rdst = 0x%x\n", rdst);
8721 }
8722 SYNTAX("round %1%S1, %0");
8723 #line 927 "rx-decode.opc"
8724 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8725
8726 }
8727 break;
8728 }
8729 break;
8730 case 0x99:
8731 GETBYTE ();
8732 switch (op[2] & 0x00)
8733 {
8734 case 0x00:
8735 goto op_semantics_69;
8736 break;
8737 }
8738 break;
8739 case 0x9a:
8740 GETBYTE ();
8741 switch (op[2] & 0x00)
8742 {
8743 case 0x00:
8744 goto op_semantics_69;
8745 break;
8746 }
8747 break;
8748 case 0x9b:
8749 GETBYTE ();
8750 switch (op[2] & 0x00)
8751 {
8752 case 0x00:
8753 goto op_semantics_69;
8754 break;
8755 }
8756 break;
8757 case 0xa0:
8758 GETBYTE ();
8759 switch (op[2] & 0x00)
8760 {
8761 case 0x00:
8762 op_semantics_70:
8763 {
8764 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
8765 #line 1110 "rx-decode.opc"
8766 int sd AU = op[1] & 0x03;
8767 #line 1110 "rx-decode.opc"
8768 int rsrc AU = (op[2] >> 4) & 0x0f;
8769 #line 1110 "rx-decode.opc"
8770 int rdst AU = op[2] & 0x0f;
8771 if (trace)
8772 {
8773 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8774 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
8775 op[0], op[1], op[2]);
8776 printf (" sd = 0x%x,", sd);
8777 printf (" rsrc = 0x%x,", rsrc);
8778 printf (" rdst = 0x%x\n", rdst);
8779 }
8780 SYNTAX("fsqrt %1%S1, %0");
8781 #line 1110 "rx-decode.opc"
8782 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8783
8784 }
8785 break;
8786 }
8787 break;
8788 case 0xa1:
8789 GETBYTE ();
8790 switch (op[2] & 0x00)
8791 {
8792 case 0x00:
8793 goto op_semantics_70;
8794 break;
8795 }
8796 break;
8797 case 0xa2:
8798 GETBYTE ();
8799 switch (op[2] & 0x00)
8800 {
8801 case 0x00:
8802 goto op_semantics_70;
8803 break;
8804 }
8805 break;
8806 case 0xa3:
8807 GETBYTE ();
8808 switch (op[2] & 0x00)
8809 {
8810 case 0x00:
8811 goto op_semantics_70;
8812 break;
8813 }
8814 break;
8815 case 0xa4:
8816 GETBYTE ();
8817 switch (op[2] & 0x00)
8818 {
8819 case 0x00:
8820 op_semantics_71:
8821 {
8822 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
8823 #line 1113 "rx-decode.opc"
8824 int sd AU = op[1] & 0x03;
8825 #line 1113 "rx-decode.opc"
8826 int rsrc AU = (op[2] >> 4) & 0x0f;
8827 #line 1113 "rx-decode.opc"
8828 int rdst AU = op[2] & 0x0f;
8829 if (trace)
8830 {
8831 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8832 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
8833 op[0], op[1], op[2]);
8834 printf (" sd = 0x%x,", sd);
8835 printf (" rsrc = 0x%x,", rsrc);
8836 printf (" rdst = 0x%x\n", rdst);
8837 }
8838 SYNTAX("ftou %1%S1, %0");
8839 #line 1113 "rx-decode.opc"
8840 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8841
8842 }
8843 break;
8844 }
8845 break;
8846 case 0xa5:
8847 GETBYTE ();
8848 switch (op[2] & 0x00)
8849 {
8850 case 0x00:
8851 goto op_semantics_71;
8852 break;
8853 }
8854 break;
8855 case 0xa6:
8856 GETBYTE ();
8857 switch (op[2] & 0x00)
8858 {
8859 case 0x00:
8860 goto op_semantics_71;
8861 break;
8862 }
8863 break;
8864 case 0xa7:
8865 GETBYTE ();
8866 switch (op[2] & 0x00)
8867 {
8868 case 0x00:
8869 goto op_semantics_71;
8870 break;
8871 }
8872 break;
8873 case 0xd0:
8874 GETBYTE ();
8875 switch (op[2] & 0x00)
8876 {
8877 case 0x00:
8878 op_semantics_72:
8879 {
8880 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8881 #line 1044 "rx-decode.opc"
8882 int sz AU = (op[1] >> 2) & 0x03;
8883 #line 1044 "rx-decode.opc"
8884 int sd AU = op[1] & 0x03;
8885 #line 1044 "rx-decode.opc"
8886 int rdst AU = (op[2] >> 4) & 0x0f;
8887 #line 1044 "rx-decode.opc"
8888 int cond AU = op[2] & 0x0f;
8889 if (trace)
8890 {
8891 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8892 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8893 op[0], op[1], op[2]);
8894 printf (" sz = 0x%x,", sz);
8895 printf (" sd = 0x%x,", sd);
8896 printf (" rdst = 0x%x,", rdst);
8897 printf (" cond = 0x%x\n", cond);
8898 }
8899 SYNTAX("sc%1%s %0");
8900 #line 1044 "rx-decode.opc"
8901 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8902
8903 /*----------------------------------------------------------------------*/
8904 /* RXv2 enhanced */
8905
8906 }
8907 break;
8908 }
8909 break;
8910 case 0xd1:
8911 GETBYTE ();
8912 switch (op[2] & 0x00)
8913 {
8914 case 0x00:
8915 goto op_semantics_72;
8916 break;
8917 }
8918 break;
8919 case 0xd2:
8920 GETBYTE ();
8921 switch (op[2] & 0x00)
8922 {
8923 case 0x00:
8924 goto op_semantics_72;
8925 break;
8926 }
8927 break;
8928 case 0xd3:
8929 GETBYTE ();
8930 switch (op[2] & 0x00)
8931 {
8932 case 0x00:
8933 goto op_semantics_72;
8934 break;
8935 }
8936 break;
8937 case 0xd4:
8938 GETBYTE ();
8939 switch (op[2] & 0x00)
8940 {
8941 case 0x00:
8942 goto op_semantics_72;
8943 break;
8944 }
8945 break;
8946 case 0xd5:
8947 GETBYTE ();
8948 switch (op[2] & 0x00)
8949 {
8950 case 0x00:
8951 goto op_semantics_72;
8952 break;
8953 }
8954 break;
8955 case 0xd6:
8956 GETBYTE ();
8957 switch (op[2] & 0x00)
8958 {
8959 case 0x00:
8960 goto op_semantics_72;
8961 break;
8962 }
8963 break;
8964 case 0xd7:
8965 GETBYTE ();
8966 switch (op[2] & 0x00)
8967 {
8968 case 0x00:
8969 goto op_semantics_72;
8970 break;
8971 }
8972 break;
8973 case 0xd8:
8974 GETBYTE ();
8975 switch (op[2] & 0x00)
8976 {
8977 case 0x00:
8978 goto op_semantics_72;
8979 break;
8980 }
8981 break;
8982 case 0xd9:
8983 GETBYTE ();
8984 switch (op[2] & 0x00)
8985 {
8986 case 0x00:
8987 goto op_semantics_72;
8988 break;
8989 }
8990 break;
8991 case 0xda:
8992 GETBYTE ();
8993 switch (op[2] & 0x00)
8994 {
8995 case 0x00:
8996 goto op_semantics_72;
8997 break;
8998 }
8999 break;
9000 case 0xdb:
9001 GETBYTE ();
9002 switch (op[2] & 0x00)
9003 {
9004 case 0x00:
9005 goto op_semantics_72;
9006 break;
9007 }
9008 break;
9009 case 0xe0:
9010 GETBYTE ();
9011 switch (op[2] & 0x0f)
9012 {
9013 case 0x00:
9014 case 0x01:
9015 case 0x02:
9016 case 0x03:
9017 case 0x04:
9018 case 0x05:
9019 case 0x06:
9020 case 0x07:
9021 case 0x08:
9022 case 0x09:
9023 case 0x0a:
9024 case 0x0b:
9025 case 0x0c:
9026 case 0x0d:
9027 case 0x0e:
9028 op_semantics_73:
9029 {
9030 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
9031 #line 987 "rx-decode.opc"
9032 int bit AU = (op[1] >> 2) & 0x07;
9033 #line 987 "rx-decode.opc"
9034 int sd AU = op[1] & 0x03;
9035 #line 987 "rx-decode.opc"
9036 int rdst AU = (op[2] >> 4) & 0x0f;
9037 #line 987 "rx-decode.opc"
9038 int cond AU = op[2] & 0x0f;
9039 if (trace)
9040 {
9041 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9042 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
9043 op[0], op[1], op[2]);
9044 printf (" bit = 0x%x,", bit);
9045 printf (" sd = 0x%x,", sd);
9046 printf (" rdst = 0x%x,", rdst);
9047 printf (" cond = 0x%x\n", cond);
9048 }
9049 SYNTAX("bm%2 #%1, %0%S0");
9050 #line 987 "rx-decode.opc"
9051 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
9052
9053 }
9054 break;
9055 case 0x0f:
9056 op_semantics_74:
9057 {
9058 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
9059 #line 975 "rx-decode.opc"
9060 int bit AU = (op[1] >> 2) & 0x07;
9061 #line 975 "rx-decode.opc"
9062 int sd AU = op[1] & 0x03;
9063 #line 975 "rx-decode.opc"
9064 int rdst AU = (op[2] >> 4) & 0x0f;
9065 if (trace)
9066 {
9067 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9068 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
9069 op[0], op[1], op[2]);
9070 printf (" bit = 0x%x,", bit);
9071 printf (" sd = 0x%x,", sd);
9072 printf (" rdst = 0x%x\n", rdst);
9073 }
9074 SYNTAX("bnot #%1, %0%S0");
9075 #line 975 "rx-decode.opc"
9076 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
9077
9078 }
9079 break;
9080 }
9081 break;
9082 case 0xe1:
9083 GETBYTE ();
9084 switch (op[2] & 0x0f)
9085 {
9086 case 0x00:
9087 case 0x01:
9088 case 0x02:
9089 case 0x03:
9090 case 0x04:
9091 case 0x05:
9092 case 0x06:
9093 case 0x07:
9094 case 0x08:
9095 case 0x09:
9096 case 0x0a:
9097 case 0x0b:
9098 case 0x0c:
9099 case 0x0d:
9100 case 0x0e:
9101 goto op_semantics_73;
9102 break;
9103 case 0x0f:
9104 goto op_semantics_74;
9105 break;
9106 }
9107 break;
9108 case 0xe2:
9109 GETBYTE ();
9110 switch (op[2] & 0x0f)
9111 {
9112 case 0x00:
9113 case 0x01:
9114 case 0x02:
9115 case 0x03:
9116 case 0x04:
9117 case 0x05:
9118 case 0x06:
9119 case 0x07:
9120 case 0x08:
9121 case 0x09:
9122 case 0x0a:
9123 case 0x0b:
9124 case 0x0c:
9125 case 0x0d:
9126 case 0x0e:
9127 goto op_semantics_73;
9128 break;
9129 case 0x0f:
9130 goto op_semantics_74;
9131 break;
9132 }
9133 break;
9134 case 0xe3:
9135 GETBYTE ();
9136 switch (op[2] & 0x0f)
9137 {
9138 case 0x00:
9139 case 0x01:
9140 case 0x02:
9141 case 0x03:
9142 case 0x04:
9143 case 0x05:
9144 case 0x06:
9145 case 0x07:
9146 case 0x08:
9147 case 0x09:
9148 case 0x0a:
9149 case 0x0b:
9150 case 0x0c:
9151 case 0x0d:
9152 case 0x0e:
9153 goto op_semantics_73;
9154 break;
9155 case 0x0f:
9156 goto op_semantics_74;
9157 break;
9158 }
9159 break;
9160 case 0xe4:
9161 GETBYTE ();
9162 switch (op[2] & 0x0f)
9163 {
9164 case 0x00:
9165 case 0x01:
9166 case 0x02:
9167 case 0x03:
9168 case 0x04:
9169 case 0x05:
9170 case 0x06:
9171 case 0x07:
9172 case 0x08:
9173 case 0x09:
9174 case 0x0a:
9175 case 0x0b:
9176 case 0x0c:
9177 case 0x0d:
9178 case 0x0e:
9179 goto op_semantics_73;
9180 break;
9181 case 0x0f:
9182 goto op_semantics_74;
9183 break;
9184 }
9185 break;
9186 case 0xe5:
9187 GETBYTE ();
9188 switch (op[2] & 0x0f)
9189 {
9190 case 0x00:
9191 case 0x01:
9192 case 0x02:
9193 case 0x03:
9194 case 0x04:
9195 case 0x05:
9196 case 0x06:
9197 case 0x07:
9198 case 0x08:
9199 case 0x09:
9200 case 0x0a:
9201 case 0x0b:
9202 case 0x0c:
9203 case 0x0d:
9204 case 0x0e:
9205 goto op_semantics_73;
9206 break;
9207 case 0x0f:
9208 goto op_semantics_74;
9209 break;
9210 }
9211 break;
9212 case 0xe6:
9213 GETBYTE ();
9214 switch (op[2] & 0x0f)
9215 {
9216 case 0x00:
9217 case 0x01:
9218 case 0x02:
9219 case 0x03:
9220 case 0x04:
9221 case 0x05:
9222 case 0x06:
9223 case 0x07:
9224 case 0x08:
9225 case 0x09:
9226 case 0x0a:
9227 case 0x0b:
9228 case 0x0c:
9229 case 0x0d:
9230 case 0x0e:
9231 goto op_semantics_73;
9232 break;
9233 case 0x0f:
9234 goto op_semantics_74;
9235 break;
9236 }
9237 break;
9238 case 0xe7:
9239 GETBYTE ();
9240 switch (op[2] & 0x0f)
9241 {
9242 case 0x00:
9243 case 0x01:
9244 case 0x02:
9245 case 0x03:
9246 case 0x04:
9247 case 0x05:
9248 case 0x06:
9249 case 0x07:
9250 case 0x08:
9251 case 0x09:
9252 case 0x0a:
9253 case 0x0b:
9254 case 0x0c:
9255 case 0x0d:
9256 case 0x0e:
9257 goto op_semantics_73;
9258 break;
9259 case 0x0f:
9260 goto op_semantics_74;
9261 break;
9262 }
9263 break;
9264 case 0xe8:
9265 GETBYTE ();
9266 switch (op[2] & 0x0f)
9267 {
9268 case 0x00:
9269 case 0x01:
9270 case 0x02:
9271 case 0x03:
9272 case 0x04:
9273 case 0x05:
9274 case 0x06:
9275 case 0x07:
9276 case 0x08:
9277 case 0x09:
9278 case 0x0a:
9279 case 0x0b:
9280 case 0x0c:
9281 case 0x0d:
9282 case 0x0e:
9283 goto op_semantics_73;
9284 break;
9285 case 0x0f:
9286 goto op_semantics_74;
9287 break;
9288 }
9289 break;
9290 case 0xe9:
9291 GETBYTE ();
9292 switch (op[2] & 0x0f)
9293 {
9294 case 0x00:
9295 case 0x01:
9296 case 0x02:
9297 case 0x03:
9298 case 0x04:
9299 case 0x05:
9300 case 0x06:
9301 case 0x07:
9302 case 0x08:
9303 case 0x09:
9304 case 0x0a:
9305 case 0x0b:
9306 case 0x0c:
9307 case 0x0d:
9308 case 0x0e:
9309 goto op_semantics_73;
9310 break;
9311 case 0x0f:
9312 goto op_semantics_74;
9313 break;
9314 }
9315 break;
9316 case 0xea:
9317 GETBYTE ();
9318 switch (op[2] & 0x0f)
9319 {
9320 case 0x00:
9321 case 0x01:
9322 case 0x02:
9323 case 0x03:
9324 case 0x04:
9325 case 0x05:
9326 case 0x06:
9327 case 0x07:
9328 case 0x08:
9329 case 0x09:
9330 case 0x0a:
9331 case 0x0b:
9332 case 0x0c:
9333 case 0x0d:
9334 case 0x0e:
9335 goto op_semantics_73;
9336 break;
9337 case 0x0f:
9338 goto op_semantics_74;
9339 break;
9340 }
9341 break;
9342 case 0xeb:
9343 GETBYTE ();
9344 switch (op[2] & 0x0f)
9345 {
9346 case 0x00:
9347 case 0x01:
9348 case 0x02:
9349 case 0x03:
9350 case 0x04:
9351 case 0x05:
9352 case 0x06:
9353 case 0x07:
9354 case 0x08:
9355 case 0x09:
9356 case 0x0a:
9357 case 0x0b:
9358 case 0x0c:
9359 case 0x0d:
9360 case 0x0e:
9361 goto op_semantics_73;
9362 break;
9363 case 0x0f:
9364 goto op_semantics_74;
9365 break;
9366 }
9367 break;
9368 case 0xec:
9369 GETBYTE ();
9370 switch (op[2] & 0x0f)
9371 {
9372 case 0x00:
9373 case 0x01:
9374 case 0x02:
9375 case 0x03:
9376 case 0x04:
9377 case 0x05:
9378 case 0x06:
9379 case 0x07:
9380 case 0x08:
9381 case 0x09:
9382 case 0x0a:
9383 case 0x0b:
9384 case 0x0c:
9385 case 0x0d:
9386 case 0x0e:
9387 goto op_semantics_73;
9388 break;
9389 case 0x0f:
9390 goto op_semantics_74;
9391 break;
9392 }
9393 break;
9394 case 0xed:
9395 GETBYTE ();
9396 switch (op[2] & 0x0f)
9397 {
9398 case 0x00:
9399 case 0x01:
9400 case 0x02:
9401 case 0x03:
9402 case 0x04:
9403 case 0x05:
9404 case 0x06:
9405 case 0x07:
9406 case 0x08:
9407 case 0x09:
9408 case 0x0a:
9409 case 0x0b:
9410 case 0x0c:
9411 case 0x0d:
9412 case 0x0e:
9413 goto op_semantics_73;
9414 break;
9415 case 0x0f:
9416 goto op_semantics_74;
9417 break;
9418 }
9419 break;
9420 case 0xee:
9421 GETBYTE ();
9422 switch (op[2] & 0x0f)
9423 {
9424 case 0x00:
9425 case 0x01:
9426 case 0x02:
9427 case 0x03:
9428 case 0x04:
9429 case 0x05:
9430 case 0x06:
9431 case 0x07:
9432 case 0x08:
9433 case 0x09:
9434 case 0x0a:
9435 case 0x0b:
9436 case 0x0c:
9437 case 0x0d:
9438 case 0x0e:
9439 goto op_semantics_73;
9440 break;
9441 case 0x0f:
9442 goto op_semantics_74;
9443 break;
9444 }
9445 break;
9446 case 0xef:
9447 GETBYTE ();
9448 switch (op[2] & 0x0f)
9449 {
9450 case 0x00:
9451 case 0x01:
9452 case 0x02:
9453 case 0x03:
9454 case 0x04:
9455 case 0x05:
9456 case 0x06:
9457 case 0x07:
9458 case 0x08:
9459 case 0x09:
9460 case 0x0a:
9461 case 0x0b:
9462 case 0x0c:
9463 case 0x0d:
9464 case 0x0e:
9465 goto op_semantics_73;
9466 break;
9467 case 0x0f:
9468 goto op_semantics_74;
9469 break;
9470 }
9471 break;
9472 case 0xf0:
9473 GETBYTE ();
9474 switch (op[2] & 0x0f)
9475 {
9476 case 0x00:
9477 case 0x01:
9478 case 0x02:
9479 case 0x03:
9480 case 0x04:
9481 case 0x05:
9482 case 0x06:
9483 case 0x07:
9484 case 0x08:
9485 case 0x09:
9486 case 0x0a:
9487 case 0x0b:
9488 case 0x0c:
9489 case 0x0d:
9490 case 0x0e:
9491 goto op_semantics_73;
9492 break;
9493 case 0x0f:
9494 goto op_semantics_74;
9495 break;
9496 }
9497 break;
9498 case 0xf1:
9499 GETBYTE ();
9500 switch (op[2] & 0x0f)
9501 {
9502 case 0x00:
9503 case 0x01:
9504 case 0x02:
9505 case 0x03:
9506 case 0x04:
9507 case 0x05:
9508 case 0x06:
9509 case 0x07:
9510 case 0x08:
9511 case 0x09:
9512 case 0x0a:
9513 case 0x0b:
9514 case 0x0c:
9515 case 0x0d:
9516 case 0x0e:
9517 goto op_semantics_73;
9518 break;
9519 case 0x0f:
9520 goto op_semantics_74;
9521 break;
9522 }
9523 break;
9524 case 0xf2:
9525 GETBYTE ();
9526 switch (op[2] & 0x0f)
9527 {
9528 case 0x00:
9529 case 0x01:
9530 case 0x02:
9531 case 0x03:
9532 case 0x04:
9533 case 0x05:
9534 case 0x06:
9535 case 0x07:
9536 case 0x08:
9537 case 0x09:
9538 case 0x0a:
9539 case 0x0b:
9540 case 0x0c:
9541 case 0x0d:
9542 case 0x0e:
9543 goto op_semantics_73;
9544 break;
9545 case 0x0f:
9546 goto op_semantics_74;
9547 break;
9548 }
9549 break;
9550 case 0xf3:
9551 GETBYTE ();
9552 switch (op[2] & 0x0f)
9553 {
9554 case 0x00:
9555 case 0x01:
9556 case 0x02:
9557 case 0x03:
9558 case 0x04:
9559 case 0x05:
9560 case 0x06:
9561 case 0x07:
9562 case 0x08:
9563 case 0x09:
9564 case 0x0a:
9565 case 0x0b:
9566 case 0x0c:
9567 case 0x0d:
9568 case 0x0e:
9569 goto op_semantics_73;
9570 break;
9571 case 0x0f:
9572 goto op_semantics_74;
9573 break;
9574 }
9575 break;
9576 case 0xf4:
9577 GETBYTE ();
9578 switch (op[2] & 0x0f)
9579 {
9580 case 0x00:
9581 case 0x01:
9582 case 0x02:
9583 case 0x03:
9584 case 0x04:
9585 case 0x05:
9586 case 0x06:
9587 case 0x07:
9588 case 0x08:
9589 case 0x09:
9590 case 0x0a:
9591 case 0x0b:
9592 case 0x0c:
9593 case 0x0d:
9594 case 0x0e:
9595 goto op_semantics_73;
9596 break;
9597 case 0x0f:
9598 goto op_semantics_74;
9599 break;
9600 }
9601 break;
9602 case 0xf5:
9603 GETBYTE ();
9604 switch (op[2] & 0x0f)
9605 {
9606 case 0x00:
9607 case 0x01:
9608 case 0x02:
9609 case 0x03:
9610 case 0x04:
9611 case 0x05:
9612 case 0x06:
9613 case 0x07:
9614 case 0x08:
9615 case 0x09:
9616 case 0x0a:
9617 case 0x0b:
9618 case 0x0c:
9619 case 0x0d:
9620 case 0x0e:
9621 goto op_semantics_73;
9622 break;
9623 case 0x0f:
9624 goto op_semantics_74;
9625 break;
9626 }
9627 break;
9628 case 0xf6:
9629 GETBYTE ();
9630 switch (op[2] & 0x0f)
9631 {
9632 case 0x00:
9633 case 0x01:
9634 case 0x02:
9635 case 0x03:
9636 case 0x04:
9637 case 0x05:
9638 case 0x06:
9639 case 0x07:
9640 case 0x08:
9641 case 0x09:
9642 case 0x0a:
9643 case 0x0b:
9644 case 0x0c:
9645 case 0x0d:
9646 case 0x0e:
9647 goto op_semantics_73;
9648 break;
9649 case 0x0f:
9650 goto op_semantics_74;
9651 break;
9652 }
9653 break;
9654 case 0xf7:
9655 GETBYTE ();
9656 switch (op[2] & 0x0f)
9657 {
9658 case 0x00:
9659 case 0x01:
9660 case 0x02:
9661 case 0x03:
9662 case 0x04:
9663 case 0x05:
9664 case 0x06:
9665 case 0x07:
9666 case 0x08:
9667 case 0x09:
9668 case 0x0a:
9669 case 0x0b:
9670 case 0x0c:
9671 case 0x0d:
9672 case 0x0e:
9673 goto op_semantics_73;
9674 break;
9675 case 0x0f:
9676 goto op_semantics_74;
9677 break;
9678 }
9679 break;
9680 case 0xf8:
9681 GETBYTE ();
9682 switch (op[2] & 0x0f)
9683 {
9684 case 0x00:
9685 case 0x01:
9686 case 0x02:
9687 case 0x03:
9688 case 0x04:
9689 case 0x05:
9690 case 0x06:
9691 case 0x07:
9692 case 0x08:
9693 case 0x09:
9694 case 0x0a:
9695 case 0x0b:
9696 case 0x0c:
9697 case 0x0d:
9698 case 0x0e:
9699 goto op_semantics_73;
9700 break;
9701 case 0x0f:
9702 goto op_semantics_74;
9703 break;
9704 }
9705 break;
9706 case 0xf9:
9707 GETBYTE ();
9708 switch (op[2] & 0x0f)
9709 {
9710 case 0x00:
9711 case 0x01:
9712 case 0x02:
9713 case 0x03:
9714 case 0x04:
9715 case 0x05:
9716 case 0x06:
9717 case 0x07:
9718 case 0x08:
9719 case 0x09:
9720 case 0x0a:
9721 case 0x0b:
9722 case 0x0c:
9723 case 0x0d:
9724 case 0x0e:
9725 goto op_semantics_73;
9726 break;
9727 case 0x0f:
9728 goto op_semantics_74;
9729 break;
9730 }
9731 break;
9732 case 0xfa:
9733 GETBYTE ();
9734 switch (op[2] & 0x0f)
9735 {
9736 case 0x00:
9737 case 0x01:
9738 case 0x02:
9739 case 0x03:
9740 case 0x04:
9741 case 0x05:
9742 case 0x06:
9743 case 0x07:
9744 case 0x08:
9745 case 0x09:
9746 case 0x0a:
9747 case 0x0b:
9748 case 0x0c:
9749 case 0x0d:
9750 case 0x0e:
9751 goto op_semantics_73;
9752 break;
9753 case 0x0f:
9754 goto op_semantics_74;
9755 break;
9756 }
9757 break;
9758 case 0xfb:
9759 GETBYTE ();
9760 switch (op[2] & 0x0f)
9761 {
9762 case 0x00:
9763 case 0x01:
9764 case 0x02:
9765 case 0x03:
9766 case 0x04:
9767 case 0x05:
9768 case 0x06:
9769 case 0x07:
9770 case 0x08:
9771 case 0x09:
9772 case 0x0a:
9773 case 0x0b:
9774 case 0x0c:
9775 case 0x0d:
9776 case 0x0e:
9777 goto op_semantics_73;
9778 break;
9779 case 0x0f:
9780 goto op_semantics_74;
9781 break;
9782 }
9783 break;
9784 case 0xfc:
9785 GETBYTE ();
9786 switch (op[2] & 0x0f)
9787 {
9788 case 0x00:
9789 case 0x01:
9790 case 0x02:
9791 case 0x03:
9792 case 0x04:
9793 case 0x05:
9794 case 0x06:
9795 case 0x07:
9796 case 0x08:
9797 case 0x09:
9798 case 0x0a:
9799 case 0x0b:
9800 case 0x0c:
9801 case 0x0d:
9802 case 0x0e:
9803 goto op_semantics_73;
9804 break;
9805 case 0x0f:
9806 goto op_semantics_74;
9807 break;
9808 }
9809 break;
9810 case 0xfd:
9811 GETBYTE ();
9812 switch (op[2] & 0x0f)
9813 {
9814 case 0x00:
9815 case 0x01:
9816 case 0x02:
9817 case 0x03:
9818 case 0x04:
9819 case 0x05:
9820 case 0x06:
9821 case 0x07:
9822 case 0x08:
9823 case 0x09:
9824 case 0x0a:
9825 case 0x0b:
9826 case 0x0c:
9827 case 0x0d:
9828 case 0x0e:
9829 goto op_semantics_73;
9830 break;
9831 case 0x0f:
9832 goto op_semantics_74;
9833 break;
9834 }
9835 break;
9836 case 0xfe:
9837 GETBYTE ();
9838 switch (op[2] & 0x0f)
9839 {
9840 case 0x00:
9841 case 0x01:
9842 case 0x02:
9843 case 0x03:
9844 case 0x04:
9845 case 0x05:
9846 case 0x06:
9847 case 0x07:
9848 case 0x08:
9849 case 0x09:
9850 case 0x0a:
9851 case 0x0b:
9852 case 0x0c:
9853 case 0x0d:
9854 case 0x0e:
9855 goto op_semantics_73;
9856 break;
9857 case 0x0f:
9858 goto op_semantics_74;
9859 break;
9860 }
9861 break;
9862 case 0xff:
9863 GETBYTE ();
9864 switch (op[2] & 0x0f)
9865 {
9866 case 0x00:
9867 case 0x01:
9868 case 0x02:
9869 case 0x03:
9870 case 0x04:
9871 case 0x05:
9872 case 0x06:
9873 case 0x07:
9874 case 0x08:
9875 case 0x09:
9876 case 0x0a:
9877 case 0x0b:
9878 case 0x0c:
9879 case 0x0d:
9880 case 0x0e:
9881 goto op_semantics_73;
9882 break;
9883 case 0x0f:
9884 goto op_semantics_74;
9885 break;
9886 }
9887 break;
9888 default: UNSUPPORTED(); break;
9889 }
9890 break;
9891 case 0xfd:
9892 GETBYTE ();
9893 switch (op[1] & 0xff)
9894 {
9895 case 0x00:
9896 GETBYTE ();
9897 switch (op[2] & 0x00)
9898 {
9899 case 0x00:
9900 op_semantics_75:
9901 {
9902 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
9903 #line 852 "rx-decode.opc"
9904 int a AU = (op[1] >> 3) & 0x01;
9905 #line 852 "rx-decode.opc"
9906 int srca AU = (op[2] >> 4) & 0x0f;
9907 #line 852 "rx-decode.opc"
9908 int srcb AU = op[2] & 0x0f;
9909 if (trace)
9910 {
9911 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9912 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
9913 op[0], op[1], op[2]);
9914 printf (" a = 0x%x,", a);
9915 printf (" srca = 0x%x,", srca);
9916 printf (" srcb = 0x%x\n", srcb);
9917 }
9918 SYNTAX("mulhi %1, %2, %0");
9919 #line 852 "rx-decode.opc"
9920 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
9921
9922 }
9923 break;
9924 }
9925 break;
9926 case 0x01:
9927 GETBYTE ();
9928 switch (op[2] & 0x00)
9929 {
9930 case 0x00:
9931 op_semantics_76:
9932 {
9933 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
9934 #line 855 "rx-decode.opc"
9935 int a AU = (op[1] >> 3) & 0x01;
9936 #line 855 "rx-decode.opc"
9937 int srca AU = (op[2] >> 4) & 0x0f;
9938 #line 855 "rx-decode.opc"
9939 int srcb AU = op[2] & 0x0f;
9940 if (trace)
9941 {
9942 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9943 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
9944 op[0], op[1], op[2]);
9945 printf (" a = 0x%x,", a);
9946 printf (" srca = 0x%x,", srca);
9947 printf (" srcb = 0x%x\n", srcb);
9948 }
9949 SYNTAX("mullo %1, %2, %0");
9950 #line 855 "rx-decode.opc"
9951 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
9952
9953 }
9954 break;
9955 }
9956 break;
9957 case 0x02:
9958 GETBYTE ();
9959 switch (op[2] & 0x00)
9960 {
9961 case 0x00:
9962 op_semantics_77:
9963 {
9964 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
9965 #line 1083 "rx-decode.opc"
9966 int a AU = (op[1] >> 3) & 0x01;
9967 #line 1083 "rx-decode.opc"
9968 int srca AU = (op[2] >> 4) & 0x0f;
9969 #line 1083 "rx-decode.opc"
9970 int srcb AU = op[2] & 0x0f;
9971 if (trace)
9972 {
9973 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9974 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
9975 op[0], op[1], op[2]);
9976 printf (" a = 0x%x,", a);
9977 printf (" srca = 0x%x,", srca);
9978 printf (" srcb = 0x%x\n", srcb);
9979 }
9980 SYNTAX("mullh %1, %2, %0");
9981 #line 1083 "rx-decode.opc"
9982 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
9983
9984 }
9985 break;
9986 }
9987 break;
9988 case 0x03:
9989 GETBYTE ();
9990 switch (op[2] & 0x00)
9991 {
9992 case 0x00:
9993 op_semantics_78:
9994 {
9995 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
9996 #line 1068 "rx-decode.opc"
9997 int a AU = (op[1] >> 3) & 0x01;
9998 #line 1068 "rx-decode.opc"
9999 int srca AU = (op[2] >> 4) & 0x0f;
10000 #line 1068 "rx-decode.opc"
10001 int srcb AU = op[2] & 0x0f;
10002 if (trace)
10003 {
10004 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10005 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
10006 op[0], op[1], op[2]);
10007 printf (" a = 0x%x,", a);
10008 printf (" srca = 0x%x,", srca);
10009 printf (" srcb = 0x%x\n", srcb);
10010 }
10011 SYNTAX("emula %1, %2, %0");
10012 #line 1068 "rx-decode.opc"
10013 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
10014
10015 }
10016 break;
10017 }
10018 break;
10019 case 0x04:
10020 GETBYTE ();
10021 switch (op[2] & 0x00)
10022 {
10023 case 0x00:
10024 op_semantics_79:
10025 {
10026 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
10027 #line 858 "rx-decode.opc"
10028 int a AU = (op[1] >> 3) & 0x01;
10029 #line 858 "rx-decode.opc"
10030 int srca AU = (op[2] >> 4) & 0x0f;
10031 #line 858 "rx-decode.opc"
10032 int srcb AU = op[2] & 0x0f;
10033 if (trace)
10034 {
10035 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10036 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
10037 op[0], op[1], op[2]);
10038 printf (" a = 0x%x,", a);
10039 printf (" srca = 0x%x,", srca);
10040 printf (" srcb = 0x%x\n", srcb);
10041 }
10042 SYNTAX("machi %1, %2, %0");
10043 #line 858 "rx-decode.opc"
10044 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
10045
10046 }
10047 break;
10048 }
10049 break;
10050 case 0x05:
10051 GETBYTE ();
10052 switch (op[2] & 0x00)
10053 {
10054 case 0x00:
10055 op_semantics_80:
10056 {
10057 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
10058 #line 861 "rx-decode.opc"
10059 int a AU = (op[1] >> 3) & 0x01;
10060 #line 861 "rx-decode.opc"
10061 int srca AU = (op[2] >> 4) & 0x0f;
10062 #line 861 "rx-decode.opc"
10063 int srcb AU = op[2] & 0x0f;
10064 if (trace)
10065 {
10066 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10067 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
10068 op[0], op[1], op[2]);
10069 printf (" a = 0x%x,", a);
10070 printf (" srca = 0x%x,", srca);
10071 printf (" srcb = 0x%x\n", srcb);
10072 }
10073 SYNTAX("maclo %1, %2, %0");
10074 #line 861 "rx-decode.opc"
10075 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
10076
10077 }
10078 break;
10079 }
10080 break;
10081 case 0x06:
10082 GETBYTE ();
10083 switch (op[2] & 0x00)
10084 {
10085 case 0x00:
10086 op_semantics_81:
10087 {
10088 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
10089 #line 1071 "rx-decode.opc"
10090 int a AU = (op[1] >> 3) & 0x01;
10091 #line 1071 "rx-decode.opc"
10092 int srca AU = (op[2] >> 4) & 0x0f;
10093 #line 1071 "rx-decode.opc"
10094 int srcb AU = op[2] & 0x0f;
10095 if (trace)
10096 {
10097 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10098 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
10099 op[0], op[1], op[2]);
10100 printf (" a = 0x%x,", a);
10101 printf (" srca = 0x%x,", srca);
10102 printf (" srcb = 0x%x\n", srcb);
10103 }
10104 SYNTAX("maclh %1, %2, %0");
10105 #line 1071 "rx-decode.opc"
10106 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
10107
10108 }
10109 break;
10110 }
10111 break;
10112 case 0x07:
10113 GETBYTE ();
10114 switch (op[2] & 0x00)
10115 {
10116 case 0x00:
10117 op_semantics_82:
10118 {
10119 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
10120 #line 1062 "rx-decode.opc"
10121 int a AU = (op[1] >> 3) & 0x01;
10122 #line 1062 "rx-decode.opc"
10123 int srca AU = (op[2] >> 4) & 0x0f;
10124 #line 1062 "rx-decode.opc"
10125 int srcb AU = op[2] & 0x0f;
10126 if (trace)
10127 {
10128 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10129 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
10130 op[0], op[1], op[2]);
10131 printf (" a = 0x%x,", a);
10132 printf (" srca = 0x%x,", srca);
10133 printf (" srcb = 0x%x\n", srcb);
10134 }
10135 SYNTAX("emaca %1, %2, %0");
10136 #line 1062 "rx-decode.opc"
10137 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
10138
10139 }
10140 break;
10141 }
10142 break;
10143 case 0x08:
10144 GETBYTE ();
10145 switch (op[2] & 0x00)
10146 {
10147 case 0x00:
10148 goto op_semantics_75;
10149 break;
10150 }
10151 break;
10152 case 0x09:
10153 GETBYTE ();
10154 switch (op[2] & 0x00)
10155 {
10156 case 0x00:
10157 goto op_semantics_76;
10158 break;
10159 }
10160 break;
10161 case 0x0a:
10162 GETBYTE ();
10163 switch (op[2] & 0x00)
10164 {
10165 case 0x00:
10166 goto op_semantics_77;
10167 break;
10168 }
10169 break;
10170 case 0x0b:
10171 GETBYTE ();
10172 switch (op[2] & 0x00)
10173 {
10174 case 0x00:
10175 goto op_semantics_78;
10176 break;
10177 }
10178 break;
10179 case 0x0c:
10180 GETBYTE ();
10181 switch (op[2] & 0x00)
10182 {
10183 case 0x00:
10184 goto op_semantics_79;
10185 break;
10186 }
10187 break;
10188 case 0x0d:
10189 GETBYTE ();
10190 switch (op[2] & 0x00)
10191 {
10192 case 0x00:
10193 goto op_semantics_80;
10194 break;
10195 }
10196 break;
10197 case 0x0e:
10198 GETBYTE ();
10199 switch (op[2] & 0x00)
10200 {
10201 case 0x00:
10202 goto op_semantics_81;
10203 break;
10204 }
10205 break;
10206 case 0x0f:
10207 GETBYTE ();
10208 switch (op[2] & 0x00)
10209 {
10210 case 0x00:
10211 goto op_semantics_82;
10212 break;
10213 }
10214 break;
10215 case 0x17:
10216 GETBYTE ();
10217 switch (op[2] & 0x70)
10218 {
10219 case 0x00:
10220 {
10221 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10222 #line 864 "rx-decode.opc"
10223 int a AU = (op[2] >> 7) & 0x01;
10224 #line 864 "rx-decode.opc"
10225 int rsrc AU = op[2] & 0x0f;
10226 if (trace)
10227 {
10228 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10229 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
10230 op[0], op[1], op[2]);
10231 printf (" a = 0x%x,", a);
10232 printf (" rsrc = 0x%x\n", rsrc);
10233 }
10234 SYNTAX("mvtachi %1, %0");
10235 #line 864 "rx-decode.opc"
10236 ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10237
10238 }
10239 break;
10240 case 0x10:
10241 {
10242 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10243 #line 867 "rx-decode.opc"
10244 int a AU = (op[2] >> 7) & 0x01;
10245 #line 867 "rx-decode.opc"
10246 int rsrc AU = op[2] & 0x0f;
10247 if (trace)
10248 {
10249 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10250 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
10251 op[0], op[1], op[2]);
10252 printf (" a = 0x%x,", a);
10253 printf (" rsrc = 0x%x\n", rsrc);
10254 }
10255 SYNTAX("mvtaclo %1, %0");
10256 #line 867 "rx-decode.opc"
10257 ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10258
10259 }
10260 break;
10261 case 0x30:
10262 {
10263 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10264 #line 1089 "rx-decode.opc"
10265 int a AU = (op[2] >> 7) & 0x01;
10266 #line 1089 "rx-decode.opc"
10267 int rdst AU = op[2] & 0x0f;
10268 if (trace)
10269 {
10270 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10271 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
10272 op[0], op[1], op[2]);
10273 printf (" a = 0x%x,", a);
10274 printf (" rdst = 0x%x\n", rdst);
10275 }
10276 SYNTAX("mvtacgu %0, %1");
10277 #line 1089 "rx-decode.opc"
10278 ID(mvtacgu); DR(a+32); SR(rdst); F_____;
10279
10280 }
10281 break;
10282 default: UNSUPPORTED(); break;
10283 }
10284 break;
10285 case 0x18:
10286 GETBYTE ();
10287 switch (op[2] & 0x6f)
10288 {
10289 case 0x00:
10290 {
10291 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
10292 #line 879 "rx-decode.opc"
10293 int a AU = (op[2] >> 7) & 0x01;
10294 #line 879 "rx-decode.opc"
10295 int i AU = (op[2] >> 4) & 0x01;
10296 if (trace)
10297 {
10298 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10299 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
10300 op[0], op[1], op[2]);
10301 printf (" a = 0x%x,", a);
10302 printf (" i = 0x%x\n", i);
10303 }
10304 SYNTAX("racw #%1, %0");
10305 #line 879 "rx-decode.opc"
10306 ID(racw); SC(i+1); DR(a+32); F_____;
10307
10308 /*----------------------------------------------------------------------*/
10309 /* SAT */
10310
10311 }
10312 break;
10313 case 0x40:
10314 {
10315 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
10316 #line 1098 "rx-decode.opc"
10317 int a AU = (op[2] >> 7) & 0x01;
10318 #line 1098 "rx-decode.opc"
10319 int i AU = (op[2] >> 4) & 0x01;
10320 if (trace)
10321 {
10322 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10323 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
10324 op[0], op[1], op[2]);
10325 printf (" a = 0x%x,", a);
10326 printf (" i = 0x%x\n", i);
10327 }
10328 SYNTAX("rdacw #%1, %0");
10329 #line 1098 "rx-decode.opc"
10330 ID(rdacw); SC(i+1); DR(a+32); F_____;
10331
10332 }
10333 break;
10334 default: UNSUPPORTED(); break;
10335 }
10336 break;
10337 case 0x19:
10338 GETBYTE ();
10339 switch (op[2] & 0x6f)
10340 {
10341 case 0x00:
10342 {
10343 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
10344 #line 1092 "rx-decode.opc"
10345 int a AU = (op[2] >> 7) & 0x01;
10346 #line 1092 "rx-decode.opc"
10347 int i AU = (op[2] >> 4) & 0x01;
10348 if (trace)
10349 {
10350 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10351 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
10352 op[0], op[1], op[2]);
10353 printf (" a = 0x%x,", a);
10354 printf (" i = 0x%x\n", i);
10355 }
10356 SYNTAX("racl #%1, %0");
10357 #line 1092 "rx-decode.opc"
10358 ID(racl); SC(i+1); DR(a+32); F_____;
10359
10360 }
10361 break;
10362 case 0x40:
10363 {
10364 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
10365 #line 1095 "rx-decode.opc"
10366 int a AU = (op[2] >> 7) & 0x01;
10367 #line 1095 "rx-decode.opc"
10368 int i AU = (op[2] >> 4) & 0x01;
10369 if (trace)
10370 {
10371 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10372 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
10373 op[0], op[1], op[2]);
10374 printf (" a = 0x%x,", a);
10375 printf (" i = 0x%x\n", i);
10376 }
10377 SYNTAX("rdacl #%1, %0");
10378 #line 1095 "rx-decode.opc"
10379 ID(rdacl); SC(i+1); DR(a+32); F_____;
10380
10381 }
10382 break;
10383 default: UNSUPPORTED(); break;
10384 }
10385 break;
10386 case 0x1e:
10387 GETBYTE ();
10388 switch (op[2] & 0x30)
10389 {
10390 case 0x00:
10391 op_semantics_83:
10392 {
10393 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
10394 #line 870 "rx-decode.opc"
10395 int i AU = op[1] & 0x01;
10396 #line 870 "rx-decode.opc"
10397 int a AU = (op[2] >> 7) & 0x01;
10398 #line 870 "rx-decode.opc"
10399 int m AU = (op[2] >> 6) & 0x01;
10400 #line 870 "rx-decode.opc"
10401 int rdst AU = op[2] & 0x0f;
10402 if (trace)
10403 {
10404 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10405 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
10406 op[0], op[1], op[2]);
10407 printf (" i = 0x%x,", i);
10408 printf (" a = 0x%x,", a);
10409 printf (" m = 0x%x,", m);
10410 printf (" rdst = 0x%x\n", rdst);
10411 }
10412 SYNTAX("mvfachi #%2, %1, %0");
10413 #line 870 "rx-decode.opc"
10414 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10415
10416 }
10417 break;
10418 case 0x10:
10419 op_semantics_84:
10420 {
10421 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
10422 #line 876 "rx-decode.opc"
10423 int i AU = op[1] & 0x01;
10424 #line 876 "rx-decode.opc"
10425 int a AU = (op[2] >> 7) & 0x01;
10426 #line 876 "rx-decode.opc"
10427 int m AU = (op[2] >> 6) & 0x01;
10428 #line 876 "rx-decode.opc"
10429 int rdst AU = op[2] & 0x0f;
10430 if (trace)
10431 {
10432 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10433 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
10434 op[0], op[1], op[2]);
10435 printf (" i = 0x%x,", i);
10436 printf (" a = 0x%x,", a);
10437 printf (" m = 0x%x,", m);
10438 printf (" rdst = 0x%x\n", rdst);
10439 }
10440 SYNTAX("mvfaclo #%2, %1, %0");
10441 #line 876 "rx-decode.opc"
10442 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10443
10444 }
10445 break;
10446 case 0x20:
10447 op_semantics_85:
10448 {
10449 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
10450 #line 873 "rx-decode.opc"
10451 int i AU = op[1] & 0x01;
10452 #line 873 "rx-decode.opc"
10453 int a AU = (op[2] >> 7) & 0x01;
10454 #line 873 "rx-decode.opc"
10455 int m AU = (op[2] >> 6) & 0x01;
10456 #line 873 "rx-decode.opc"
10457 int rdst AU = op[2] & 0x0f;
10458 if (trace)
10459 {
10460 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10461 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
10462 op[0], op[1], op[2]);
10463 printf (" i = 0x%x,", i);
10464 printf (" a = 0x%x,", a);
10465 printf (" m = 0x%x,", m);
10466 printf (" rdst = 0x%x\n", rdst);
10467 }
10468 SYNTAX("mvfacmi #%2, %1, %0");
10469 #line 873 "rx-decode.opc"
10470 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10471
10472 }
10473 break;
10474 case 0x30:
10475 op_semantics_86:
10476 {
10477 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
10478 #line 1086 "rx-decode.opc"
10479 int i AU = op[1] & 0x01;
10480 #line 1086 "rx-decode.opc"
10481 int a AU = (op[2] >> 7) & 0x01;
10482 #line 1086 "rx-decode.opc"
10483 int m AU = (op[2] >> 6) & 0x01;
10484 #line 1086 "rx-decode.opc"
10485 int rdst AU = op[2] & 0x0f;
10486 if (trace)
10487 {
10488 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10489 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
10490 op[0], op[1], op[2]);
10491 printf (" i = 0x%x,", i);
10492 printf (" a = 0x%x,", a);
10493 printf (" m = 0x%x,", m);
10494 printf (" rdst = 0x%x\n", rdst);
10495 }
10496 SYNTAX("mvfacgu #%2, %1, %0");
10497 #line 1086 "rx-decode.opc"
10498 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10499
10500 }
10501 break;
10502 }
10503 break;
10504 case 0x1f:
10505 GETBYTE ();
10506 switch (op[2] & 0x30)
10507 {
10508 case 0x00:
10509 goto op_semantics_83;
10510 break;
10511 case 0x10:
10512 goto op_semantics_84;
10513 break;
10514 case 0x20:
10515 goto op_semantics_85;
10516 break;
10517 case 0x30:
10518 goto op_semantics_86;
10519 break;
10520 }
10521 break;
10522 case 0x20:
10523 GETBYTE ();
10524 switch (op[2] & 0x00)
10525 {
10526 case 0x00:
10527 op_semantics_87:
10528 {
10529 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
10530 #line 348 "rx-decode.opc"
10531 int p AU = (op[1] >> 2) & 0x01;
10532 #line 348 "rx-decode.opc"
10533 int sz AU = op[1] & 0x03;
10534 #line 348 "rx-decode.opc"
10535 int rdst AU = (op[2] >> 4) & 0x0f;
10536 #line 348 "rx-decode.opc"
10537 int rsrc AU = op[2] & 0x0f;
10538 if (trace)
10539 {
10540 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10541 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
10542 op[0], op[1], op[2]);
10543 printf (" p = 0x%x,", p);
10544 printf (" sz = 0x%x,", sz);
10545 printf (" rdst = 0x%x,", rdst);
10546 printf (" rsrc = 0x%x\n", rsrc);
10547 }
10548 SYNTAX("mov%s %1, %0");
10549 #line 348 "rx-decode.opc"
10550 ID(mov); sBWL (sz); SR(rsrc); F_____;
10551 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
10552
10553 }
10554 break;
10555 }
10556 break;
10557 case 0x21:
10558 GETBYTE ();
10559 switch (op[2] & 0x00)
10560 {
10561 case 0x00:
10562 goto op_semantics_87;
10563 break;
10564 }
10565 break;
10566 case 0x22:
10567 GETBYTE ();
10568 switch (op[2] & 0x00)
10569 {
10570 case 0x00:
10571 goto op_semantics_87;
10572 break;
10573 }
10574 break;
10575 case 0x24:
10576 GETBYTE ();
10577 switch (op[2] & 0x00)
10578 {
10579 case 0x00:
10580 goto op_semantics_87;
10581 break;
10582 }
10583 break;
10584 case 0x25:
10585 GETBYTE ();
10586 switch (op[2] & 0x00)
10587 {
10588 case 0x00:
10589 goto op_semantics_87;
10590 break;
10591 }
10592 break;
10593 case 0x26:
10594 GETBYTE ();
10595 switch (op[2] & 0x00)
10596 {
10597 case 0x00:
10598 goto op_semantics_87;
10599 break;
10600 }
10601 break;
10602 case 0x27:
10603 GETBYTE ();
10604 switch (op[2] & 0x00)
10605 {
10606 case 0x00:
10607 {
10608 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
10609 #line 1050 "rx-decode.opc"
10610 int rdst AU = (op[2] >> 4) & 0x0f;
10611 #line 1050 "rx-decode.opc"
10612 int rsrc AU = op[2] & 0x0f;
10613 if (trace)
10614 {
10615 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10616 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
10617 op[0], op[1], op[2]);
10618 printf (" rdst = 0x%x,", rdst);
10619 printf (" rsrc = 0x%x\n", rsrc);
10620 }
10621 SYNTAX("movco %1, [%0]");
10622 #line 1050 "rx-decode.opc"
10623 ID(movco); SR(rsrc); DR(rdst); F_____;
10624
10625 }
10626 break;
10627 }
10628 break;
10629 case 0x28:
10630 GETBYTE ();
10631 switch (op[2] & 0x00)
10632 {
10633 case 0x00:
10634 op_semantics_88:
10635 {
10636 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
10637 #line 352 "rx-decode.opc"
10638 int p AU = (op[1] >> 2) & 0x01;
10639 #line 352 "rx-decode.opc"
10640 int sz AU = op[1] & 0x03;
10641 #line 352 "rx-decode.opc"
10642 int rsrc AU = (op[2] >> 4) & 0x0f;
10643 #line 352 "rx-decode.opc"
10644 int rdst AU = op[2] & 0x0f;
10645 if (trace)
10646 {
10647 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10648 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
10649 op[0], op[1], op[2]);
10650 printf (" p = 0x%x,", p);
10651 printf (" sz = 0x%x,", sz);
10652 printf (" rsrc = 0x%x,", rsrc);
10653 printf (" rdst = 0x%x\n", rdst);
10654 }
10655 SYNTAX("mov%s %1, %0");
10656 #line 352 "rx-decode.opc"
10657 ID(mov); sBWL (sz); DR(rdst); F_____;
10658 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10659
10660 }
10661 break;
10662 }
10663 break;
10664 case 0x29:
10665 GETBYTE ();
10666 switch (op[2] & 0x00)
10667 {
10668 case 0x00:
10669 goto op_semantics_88;
10670 break;
10671 }
10672 break;
10673 case 0x2a:
10674 GETBYTE ();
10675 switch (op[2] & 0x00)
10676 {
10677 case 0x00:
10678 goto op_semantics_88;
10679 break;
10680 }
10681 break;
10682 case 0x2c:
10683 GETBYTE ();
10684 switch (op[2] & 0x00)
10685 {
10686 case 0x00:
10687 goto op_semantics_88;
10688 break;
10689 }
10690 break;
10691 case 0x2d:
10692 GETBYTE ();
10693 switch (op[2] & 0x00)
10694 {
10695 case 0x00:
10696 goto op_semantics_88;
10697 break;
10698 }
10699 break;
10700 case 0x2e:
10701 GETBYTE ();
10702 switch (op[2] & 0x00)
10703 {
10704 case 0x00:
10705 goto op_semantics_88;
10706 break;
10707 }
10708 break;
10709 case 0x2f:
10710 GETBYTE ();
10711 switch (op[2] & 0x00)
10712 {
10713 case 0x00:
10714 {
10715 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
10716 #line 1053 "rx-decode.opc"
10717 int rsrc AU = (op[2] >> 4) & 0x0f;
10718 #line 1053 "rx-decode.opc"
10719 int rdst AU = op[2] & 0x0f;
10720 if (trace)
10721 {
10722 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10723 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
10724 op[0], op[1], op[2]);
10725 printf (" rsrc = 0x%x,", rsrc);
10726 printf (" rdst = 0x%x\n", rdst);
10727 }
10728 SYNTAX("movli [%1], %0");
10729 #line 1053 "rx-decode.opc"
10730 ID(movli); SR(rsrc); DR(rdst); F_____;
10731
10732 }
10733 break;
10734 }
10735 break;
10736 case 0x38:
10737 GETBYTE ();
10738 switch (op[2] & 0x00)
10739 {
10740 case 0x00:
10741 op_semantics_89:
10742 {
10743 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
10744 #line 362 "rx-decode.opc"
10745 int p AU = (op[1] >> 2) & 0x01;
10746 #line 362 "rx-decode.opc"
10747 int sz AU = op[1] & 0x03;
10748 #line 362 "rx-decode.opc"
10749 int rsrc AU = (op[2] >> 4) & 0x0f;
10750 #line 362 "rx-decode.opc"
10751 int rdst AU = op[2] & 0x0f;
10752 if (trace)
10753 {
10754 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10755 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
10756 op[0], op[1], op[2]);
10757 printf (" p = 0x%x,", p);
10758 printf (" sz = 0x%x,", sz);
10759 printf (" rsrc = 0x%x,", rsrc);
10760 printf (" rdst = 0x%x\n", rdst);
10761 }
10762 SYNTAX("movu%s %1, %0");
10763 #line 362 "rx-decode.opc"
10764 ID(mov); uBW (sz); DR(rdst); F_____;
10765 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10766
10767 /*----------------------------------------------------------------------*/
10768 /* PUSH/POP */
10769
10770 }
10771 break;
10772 }
10773 break;
10774 case 0x39:
10775 GETBYTE ();
10776 switch (op[2] & 0x00)
10777 {
10778 case 0x00:
10779 goto op_semantics_89;
10780 break;
10781 }
10782 break;
10783 case 0x3a:
10784 GETBYTE ();
10785 switch (op[2] & 0x00)
10786 {
10787 case 0x00:
10788 goto op_semantics_89;
10789 break;
10790 }
10791 break;
10792 case 0x3c:
10793 GETBYTE ();
10794 switch (op[2] & 0x00)
10795 {
10796 case 0x00:
10797 goto op_semantics_89;
10798 break;
10799 }
10800 break;
10801 case 0x3d:
10802 GETBYTE ();
10803 switch (op[2] & 0x00)
10804 {
10805 case 0x00:
10806 goto op_semantics_89;
10807 break;
10808 }
10809 break;
10810 case 0x3e:
10811 GETBYTE ();
10812 switch (op[2] & 0x00)
10813 {
10814 case 0x00:
10815 goto op_semantics_89;
10816 break;
10817 }
10818 break;
10819 case 0x44:
10820 GETBYTE ();
10821 switch (op[2] & 0x00)
10822 {
10823 case 0x00:
10824 op_semantics_90:
10825 {
10826 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
10827 #line 1074 "rx-decode.opc"
10828 int a AU = (op[1] >> 3) & 0x01;
10829 #line 1074 "rx-decode.opc"
10830 int srca AU = (op[2] >> 4) & 0x0f;
10831 #line 1074 "rx-decode.opc"
10832 int srcb AU = op[2] & 0x0f;
10833 if (trace)
10834 {
10835 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10836 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
10837 op[0], op[1], op[2]);
10838 printf (" a = 0x%x,", a);
10839 printf (" srca = 0x%x,", srca);
10840 printf (" srcb = 0x%x\n", srcb);
10841 }
10842 SYNTAX("msbhi %1, %2, %0");
10843 #line 1074 "rx-decode.opc"
10844 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
10845
10846 }
10847 break;
10848 }
10849 break;
10850 case 0x45:
10851 GETBYTE ();
10852 switch (op[2] & 0x00)
10853 {
10854 case 0x00:
10855 op_semantics_91:
10856 {
10857 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
10858 #line 1080 "rx-decode.opc"
10859 int a AU = (op[1] >> 3) & 0x01;
10860 #line 1080 "rx-decode.opc"
10861 int srca AU = (op[2] >> 4) & 0x0f;
10862 #line 1080 "rx-decode.opc"
10863 int srcb AU = op[2] & 0x0f;
10864 if (trace)
10865 {
10866 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10867 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
10868 op[0], op[1], op[2]);
10869 printf (" a = 0x%x,", a);
10870 printf (" srca = 0x%x,", srca);
10871 printf (" srcb = 0x%x\n", srcb);
10872 }
10873 SYNTAX("msblo %1, %2, %0");
10874 #line 1080 "rx-decode.opc"
10875 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
10876
10877 }
10878 break;
10879 }
10880 break;
10881 case 0x46:
10882 GETBYTE ();
10883 switch (op[2] & 0x00)
10884 {
10885 case 0x00:
10886 op_semantics_92:
10887 {
10888 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
10889 #line 1077 "rx-decode.opc"
10890 int a AU = (op[1] >> 3) & 0x01;
10891 #line 1077 "rx-decode.opc"
10892 int srca AU = (op[2] >> 4) & 0x0f;
10893 #line 1077 "rx-decode.opc"
10894 int srcb AU = op[2] & 0x0f;
10895 if (trace)
10896 {
10897 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10898 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
10899 op[0], op[1], op[2]);
10900 printf (" a = 0x%x,", a);
10901 printf (" srca = 0x%x,", srca);
10902 printf (" srcb = 0x%x\n", srcb);
10903 }
10904 SYNTAX("msblh %1, %2, %0");
10905 #line 1077 "rx-decode.opc"
10906 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
10907
10908 }
10909 break;
10910 }
10911 break;
10912 case 0x47:
10913 GETBYTE ();
10914 switch (op[2] & 0x00)
10915 {
10916 case 0x00:
10917 op_semantics_93:
10918 {
10919 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
10920 #line 1065 "rx-decode.opc"
10921 int a AU = (op[1] >> 3) & 0x01;
10922 #line 1065 "rx-decode.opc"
10923 int srca AU = (op[2] >> 4) & 0x0f;
10924 #line 1065 "rx-decode.opc"
10925 int srcb AU = op[2] & 0x0f;
10926 if (trace)
10927 {
10928 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10929 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
10930 op[0], op[1], op[2]);
10931 printf (" a = 0x%x,", a);
10932 printf (" srca = 0x%x,", srca);
10933 printf (" srcb = 0x%x\n", srcb);
10934 }
10935 SYNTAX("emsba %1, %2, %0");
10936 #line 1065 "rx-decode.opc"
10937 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
10938
10939 }
10940 break;
10941 }
10942 break;
10943 case 0x4c:
10944 GETBYTE ();
10945 switch (op[2] & 0x00)
10946 {
10947 case 0x00:
10948 goto op_semantics_90;
10949 break;
10950 }
10951 break;
10952 case 0x4d:
10953 GETBYTE ();
10954 switch (op[2] & 0x00)
10955 {
10956 case 0x00:
10957 goto op_semantics_91;
10958 break;
10959 }
10960 break;
10961 case 0x4e:
10962 GETBYTE ();
10963 switch (op[2] & 0x00)
10964 {
10965 case 0x00:
10966 goto op_semantics_92;
10967 break;
10968 }
10969 break;
10970 case 0x4f:
10971 GETBYTE ();
10972 switch (op[2] & 0x00)
10973 {
10974 case 0x00:
10975 goto op_semantics_93;
10976 break;
10977 }
10978 break;
10979 case 0x60:
10980 GETBYTE ();
10981 switch (op[2] & 0x00)
10982 {
10983 case 0x00:
10984 {
10985 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
10986 #line 733 "rx-decode.opc"
10987 int rsrc AU = (op[2] >> 4) & 0x0f;
10988 #line 733 "rx-decode.opc"
10989 int rdst AU = op[2] & 0x0f;
10990 if (trace)
10991 {
10992 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10993 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
10994 op[0], op[1], op[2]);
10995 printf (" rsrc = 0x%x,", rsrc);
10996 printf (" rdst = 0x%x\n", rdst);
10997 }
10998 SYNTAX("shlr %2, %0");
10999 #line 733 "rx-decode.opc"
11000 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
11001
11002 }
11003 break;
11004 }
11005 break;
11006 case 0x61:
11007 GETBYTE ();
11008 switch (op[2] & 0x00)
11009 {
11010 case 0x00:
11011 {
11012 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
11013 #line 723 "rx-decode.opc"
11014 int rsrc AU = (op[2] >> 4) & 0x0f;
11015 #line 723 "rx-decode.opc"
11016 int rdst AU = op[2] & 0x0f;
11017 if (trace)
11018 {
11019 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11020 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
11021 op[0], op[1], op[2]);
11022 printf (" rsrc = 0x%x,", rsrc);
11023 printf (" rdst = 0x%x\n", rdst);
11024 }
11025 SYNTAX("shar %2, %0");
11026 #line 723 "rx-decode.opc"
11027 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
11028
11029 }
11030 break;
11031 }
11032 break;
11033 case 0x62:
11034 GETBYTE ();
11035 switch (op[2] & 0x00)
11036 {
11037 case 0x00:
11038 {
11039 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
11040 #line 713 "rx-decode.opc"
11041 int rsrc AU = (op[2] >> 4) & 0x0f;
11042 #line 713 "rx-decode.opc"
11043 int rdst AU = op[2] & 0x0f;
11044 if (trace)
11045 {
11046 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11047 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
11048 op[0], op[1], op[2]);
11049 printf (" rsrc = 0x%x,", rsrc);
11050 printf (" rdst = 0x%x\n", rdst);
11051 }
11052 SYNTAX("shll %2, %0");
11053 #line 713 "rx-decode.opc"
11054 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
11055
11056 }
11057 break;
11058 }
11059 break;
11060 case 0x64:
11061 GETBYTE ();
11062 switch (op[2] & 0x00)
11063 {
11064 case 0x00:
11065 {
11066 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
11067 #line 757 "rx-decode.opc"
11068 int rsrc AU = (op[2] >> 4) & 0x0f;
11069 #line 757 "rx-decode.opc"
11070 int rdst AU = op[2] & 0x0f;
11071 if (trace)
11072 {
11073 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11074 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
11075 op[0], op[1], op[2]);
11076 printf (" rsrc = 0x%x,", rsrc);
11077 printf (" rdst = 0x%x\n", rdst);
11078 }
11079 SYNTAX("rotr %1, %0");
11080 #line 757 "rx-decode.opc"
11081 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
11082
11083 }
11084 break;
11085 }
11086 break;
11087 case 0x65:
11088 GETBYTE ();
11089 switch (op[2] & 0x00)
11090 {
11091 case 0x00:
11092 {
11093 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
11094 #line 760 "rx-decode.opc"
11095 int rsrc AU = (op[2] >> 4) & 0x0f;
11096 #line 760 "rx-decode.opc"
11097 int rdst AU = op[2] & 0x0f;
11098 if (trace)
11099 {
11100 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11101 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
11102 op[0], op[1], op[2]);
11103 printf (" rsrc = 0x%x,", rsrc);
11104 printf (" rdst = 0x%x\n", rdst);
11105 }
11106 SYNTAX("revw %1, %0");
11107 #line 760 "rx-decode.opc"
11108 ID(revw); SR(rsrc); DR(rdst);
11109
11110 }
11111 break;
11112 }
11113 break;
11114 case 0x66:
11115 GETBYTE ();
11116 switch (op[2] & 0x00)
11117 {
11118 case 0x00:
11119 {
11120 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
11121 #line 751 "rx-decode.opc"
11122 int rsrc AU = (op[2] >> 4) & 0x0f;
11123 #line 751 "rx-decode.opc"
11124 int rdst AU = op[2] & 0x0f;
11125 if (trace)
11126 {
11127 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11128 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
11129 op[0], op[1], op[2]);
11130 printf (" rsrc = 0x%x,", rsrc);
11131 printf (" rdst = 0x%x\n", rdst);
11132 }
11133 SYNTAX("rotl %1, %0");
11134 #line 751 "rx-decode.opc"
11135 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
11136
11137 }
11138 break;
11139 }
11140 break;
11141 case 0x67:
11142 GETBYTE ();
11143 switch (op[2] & 0x00)
11144 {
11145 case 0x00:
11146 {
11147 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
11148 #line 763 "rx-decode.opc"
11149 int rsrc AU = (op[2] >> 4) & 0x0f;
11150 #line 763 "rx-decode.opc"
11151 int rdst AU = op[2] & 0x0f;
11152 if (trace)
11153 {
11154 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11155 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
11156 op[0], op[1], op[2]);
11157 printf (" rsrc = 0x%x,", rsrc);
11158 printf (" rdst = 0x%x\n", rdst);
11159 }
11160 SYNTAX("revl %1, %0");
11161 #line 763 "rx-decode.opc"
11162 ID(revl); SR(rsrc); DR(rdst);
11163
11164 /*----------------------------------------------------------------------*/
11165 /* BRANCH */
11166
11167 }
11168 break;
11169 }
11170 break;
11171 case 0x68:
11172 GETBYTE ();
11173 switch (op[2] & 0x00)
11174 {
11175 case 0x00:
11176 op_semantics_94:
11177 {
11178 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
11179 #line 1014 "rx-decode.opc"
11180 int c AU = op[1] & 0x01;
11181 #line 1014 "rx-decode.opc"
11182 int rsrc AU = (op[2] >> 4) & 0x0f;
11183 #line 1014 "rx-decode.opc"
11184 int rdst AU = op[2] & 0x0f;
11185 if (trace)
11186 {
11187 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11188 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
11189 op[0], op[1], op[2]);
11190 printf (" c = 0x%x,", c);
11191 printf (" rsrc = 0x%x,", rsrc);
11192 printf (" rdst = 0x%x\n", rdst);
11193 }
11194 SYNTAX("mvtc %1, %0");
11195 #line 1014 "rx-decode.opc"
11196 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
11197
11198 }
11199 break;
11200 }
11201 break;
11202 case 0x69:
11203 GETBYTE ();
11204 switch (op[2] & 0x00)
11205 {
11206 case 0x00:
11207 goto op_semantics_94;
11208 break;
11209 }
11210 break;
11211 case 0x6a:
11212 GETBYTE ();
11213 switch (op[2] & 0x00)
11214 {
11215 case 0x00:
11216 op_semantics_95:
11217 {
11218 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
11219 #line 1017 "rx-decode.opc"
11220 int s AU = op[1] & 0x01;
11221 #line 1017 "rx-decode.opc"
11222 int rsrc AU = (op[2] >> 4) & 0x0f;
11223 #line 1017 "rx-decode.opc"
11224 int rdst AU = op[2] & 0x0f;
11225 if (trace)
11226 {
11227 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11228 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
11229 op[0], op[1], op[2]);
11230 printf (" s = 0x%x,", s);
11231 printf (" rsrc = 0x%x,", rsrc);
11232 printf (" rdst = 0x%x\n", rdst);
11233 }
11234 SYNTAX("mvfc %1, %0");
11235 #line 1017 "rx-decode.opc"
11236 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11237
11238 /*----------------------------------------------------------------------*/
11239 /* INTERRUPTS */
11240
11241 }
11242 break;
11243 }
11244 break;
11245 case 0x6b:
11246 GETBYTE ();
11247 switch (op[2] & 0x00)
11248 {
11249 case 0x00:
11250 goto op_semantics_95;
11251 break;
11252 }
11253 break;
11254 case 0x6c:
11255 GETBYTE ();
11256 switch (op[2] & 0x00)
11257 {
11258 case 0x00:
11259 op_semantics_96:
11260 {
11261 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
11262 #line 754 "rx-decode.opc"
11263 int i AU = op[1] & 0x01;
11264 #line 754 "rx-decode.opc"
11265 int mmmm AU = (op[2] >> 4) & 0x0f;
11266 #line 754 "rx-decode.opc"
11267 int rdst AU = op[2] & 0x0f;
11268 if (trace)
11269 {
11270 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11271 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
11272 op[0], op[1], op[2]);
11273 printf (" i = 0x%x,", i);
11274 printf (" mmmm = 0x%x,", mmmm);
11275 printf (" rdst = 0x%x\n", rdst);
11276 }
11277 SYNTAX("rotr #%1, %0");
11278 #line 754 "rx-decode.opc"
11279 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11280
11281 }
11282 break;
11283 }
11284 break;
11285 case 0x6d:
11286 GETBYTE ();
11287 switch (op[2] & 0x00)
11288 {
11289 case 0x00:
11290 goto op_semantics_96;
11291 break;
11292 }
11293 break;
11294 case 0x6e:
11295 GETBYTE ();
11296 switch (op[2] & 0x00)
11297 {
11298 case 0x00:
11299 op_semantics_97:
11300 {
11301 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
11302 #line 748 "rx-decode.opc"
11303 int i AU = op[1] & 0x01;
11304 #line 748 "rx-decode.opc"
11305 int mmmm AU = (op[2] >> 4) & 0x0f;
11306 #line 748 "rx-decode.opc"
11307 int rdst AU = op[2] & 0x0f;
11308 if (trace)
11309 {
11310 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11311 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
11312 op[0], op[1], op[2]);
11313 printf (" i = 0x%x,", i);
11314 printf (" mmmm = 0x%x,", mmmm);
11315 printf (" rdst = 0x%x\n", rdst);
11316 }
11317 SYNTAX("rotl #%1, %0");
11318 #line 748 "rx-decode.opc"
11319 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11320
11321 }
11322 break;
11323 }
11324 break;
11325 case 0x6f:
11326 GETBYTE ();
11327 switch (op[2] & 0x00)
11328 {
11329 case 0x00:
11330 goto op_semantics_97;
11331 break;
11332 }
11333 break;
11334 case 0x70:
11335 GETBYTE ();
11336 switch (op[2] & 0xf0)
11337 {
11338 case 0x20:
11339 op_semantics_98:
11340 {
11341 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
11342 #line 492 "rx-decode.opc"
11343 int im AU = (op[1] >> 2) & 0x03;
11344 #line 492 "rx-decode.opc"
11345 int rdst AU = op[2] & 0x0f;
11346 if (trace)
11347 {
11348 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11349 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
11350 op[0], op[1], op[2]);
11351 printf (" im = 0x%x,", im);
11352 printf (" rdst = 0x%x\n", rdst);
11353 }
11354 SYNTAX("adc #%1, %0");
11355 #line 492 "rx-decode.opc"
11356 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11357
11358 }
11359 break;
11360 case 0x40:
11361 op_semantics_99:
11362 {
11363 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
11364 #line 574 "rx-decode.opc"
11365 int im AU = (op[1] >> 2) & 0x03;
11366 #line 574 "rx-decode.opc"
11367 int rdst AU = op[2] & 0x0f;
11368 if (trace)
11369 {
11370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11371 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
11372 op[0], op[1], op[2]);
11373 printf (" im = 0x%x,", im);
11374 printf (" rdst = 0x%x\n", rdst);
11375 }
11376 SYNTAX("max #%1, %0");
11377 #line 574 "rx-decode.opc"
11378 int val = IMMex (im);
11379 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11380 {
11381 ID (nop7);
11382 SYNTAX("nop\t; max\t#0x80000000, r0");
11383 }
11384 else
11385 {
11386 ID(max);
11387 }
11388 DR(rdst); SC(val);
11389
11390 }
11391 break;
11392 case 0x50:
11393 op_semantics_100:
11394 {
11395 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
11396 #line 604 "rx-decode.opc"
11397 int im AU = (op[1] >> 2) & 0x03;
11398 #line 604 "rx-decode.opc"
11399 int rdst AU = op[2] & 0x0f;
11400 if (trace)
11401 {
11402 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11403 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
11404 op[0], op[1], op[2]);
11405 printf (" im = 0x%x,", im);
11406 printf (" rdst = 0x%x\n", rdst);
11407 }
11408 SYNTAX("min #%1, %0");
11409 #line 604 "rx-decode.opc"
11410 ID(min); DR(rdst); SC(IMMex(im));
11411
11412 }
11413 break;
11414 case 0x60:
11415 op_semantics_101:
11416 {
11417 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
11418 #line 662 "rx-decode.opc"
11419 int im AU = (op[1] >> 2) & 0x03;
11420 #line 662 "rx-decode.opc"
11421 int rdst AU = op[2] & 0x0f;
11422 if (trace)
11423 {
11424 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11425 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
11426 op[0], op[1], op[2]);
11427 printf (" im = 0x%x,", im);
11428 printf (" rdst = 0x%x\n", rdst);
11429 }
11430 SYNTAX("emul #%1, %0");
11431 #line 662 "rx-decode.opc"
11432 ID(emul); DR(rdst); SC(IMMex(im));
11433
11434 }
11435 break;
11436 case 0x70:
11437 op_semantics_102:
11438 {
11439 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
11440 #line 674 "rx-decode.opc"
11441 int im AU = (op[1] >> 2) & 0x03;
11442 #line 674 "rx-decode.opc"
11443 int rdst AU = op[2] & 0x0f;
11444 if (trace)
11445 {
11446 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11447 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
11448 op[0], op[1], op[2]);
11449 printf (" im = 0x%x,", im);
11450 printf (" rdst = 0x%x\n", rdst);
11451 }
11452 SYNTAX("emulu #%1, %0");
11453 #line 674 "rx-decode.opc"
11454 ID(emulu); DR(rdst); SC(IMMex(im));
11455
11456 }
11457 break;
11458 case 0x80:
11459 op_semantics_103:
11460 {
11461 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
11462 #line 686 "rx-decode.opc"
11463 int im AU = (op[1] >> 2) & 0x03;
11464 #line 686 "rx-decode.opc"
11465 int rdst AU = op[2] & 0x0f;
11466 if (trace)
11467 {
11468 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11469 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
11470 op[0], op[1], op[2]);
11471 printf (" im = 0x%x,", im);
11472 printf (" rdst = 0x%x\n", rdst);
11473 }
11474 SYNTAX("div #%1, %0");
11475 #line 686 "rx-decode.opc"
11476 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11477
11478 }
11479 break;
11480 case 0x90:
11481 op_semantics_104:
11482 {
11483 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
11484 #line 698 "rx-decode.opc"
11485 int im AU = (op[1] >> 2) & 0x03;
11486 #line 698 "rx-decode.opc"
11487 int rdst AU = op[2] & 0x0f;
11488 if (trace)
11489 {
11490 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11491 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
11492 op[0], op[1], op[2]);
11493 printf (" im = 0x%x,", im);
11494 printf (" rdst = 0x%x\n", rdst);
11495 }
11496 SYNTAX("divu #%1, %0");
11497 #line 698 "rx-decode.opc"
11498 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11499
11500 }
11501 break;
11502 case 0xc0:
11503 op_semantics_105:
11504 {
11505 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
11506 #line 471 "rx-decode.opc"
11507 int im AU = (op[1] >> 2) & 0x03;
11508 #line 471 "rx-decode.opc"
11509 int rdst AU = op[2] & 0x0f;
11510 if (trace)
11511 {
11512 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11513 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
11514 op[0], op[1], op[2]);
11515 printf (" im = 0x%x,", im);
11516 printf (" rdst = 0x%x\n", rdst);
11517 }
11518 SYNTAX("tst #%1, %2");
11519 #line 471 "rx-decode.opc"
11520 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11521
11522 }
11523 break;
11524 case 0xd0:
11525 op_semantics_106:
11526 {
11527 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
11528 #line 450 "rx-decode.opc"
11529 int im AU = (op[1] >> 2) & 0x03;
11530 #line 450 "rx-decode.opc"
11531 int rdst AU = op[2] & 0x0f;
11532 if (trace)
11533 {
11534 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11535 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
11536 op[0], op[1], op[2]);
11537 printf (" im = 0x%x,", im);
11538 printf (" rdst = 0x%x\n", rdst);
11539 }
11540 SYNTAX("xor #%1, %0");
11541 #line 450 "rx-decode.opc"
11542 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11543
11544 }
11545 break;
11546 case 0xe0:
11547 op_semantics_107:
11548 {
11549 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
11550 #line 396 "rx-decode.opc"
11551 int im AU = (op[1] >> 2) & 0x03;
11552 #line 396 "rx-decode.opc"
11553 int rdst AU = op[2] & 0x0f;
11554 if (trace)
11555 {
11556 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11557 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
11558 op[0], op[1], op[2]);
11559 printf (" im = 0x%x,", im);
11560 printf (" rdst = 0x%x\n", rdst);
11561 }
11562 SYNTAX("stz #%1, %0");
11563 #line 396 "rx-decode.opc"
11564 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11565
11566 }
11567 break;
11568 case 0xf0:
11569 op_semantics_108:
11570 {
11571 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
11572 #line 399 "rx-decode.opc"
11573 int im AU = (op[1] >> 2) & 0x03;
11574 #line 399 "rx-decode.opc"
11575 int rdst AU = op[2] & 0x0f;
11576 if (trace)
11577 {
11578 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11579 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
11580 op[0], op[1], op[2]);
11581 printf (" im = 0x%x,", im);
11582 printf (" rdst = 0x%x\n", rdst);
11583 }
11584 SYNTAX("stnz #%1, %0");
11585 #line 399 "rx-decode.opc"
11586 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11587
11588 /*----------------------------------------------------------------------*/
11589 /* RTSD */
11590
11591 }
11592 break;
11593 default: UNSUPPORTED(); break;
11594 }
11595 break;
11596 case 0x72:
11597 GETBYTE ();
11598 switch (op[2] & 0xf0)
11599 {
11600 case 0x00:
11601 {
11602 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
11603 #line 906 "rx-decode.opc"
11604 int rdst AU = op[2] & 0x0f;
11605 if (trace)
11606 {
11607 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11608 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
11609 op[0], op[1], op[2]);
11610 printf (" rdst = 0x%x\n", rdst);
11611 }
11612 SYNTAX("fsub #%1, %0");
11613 #line 906 "rx-decode.opc"
11614 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11615
11616 }
11617 break;
11618 case 0x10:
11619 {
11620 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
11621 #line 900 "rx-decode.opc"
11622 int rdst AU = op[2] & 0x0f;
11623 if (trace)
11624 {
11625 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11626 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
11627 op[0], op[1], op[2]);
11628 printf (" rdst = 0x%x\n", rdst);
11629 }
11630 SYNTAX("fcmp #%1, %0");
11631 #line 900 "rx-decode.opc"
11632 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11633
11634 }
11635 break;
11636 case 0x20:
11637 {
11638 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
11639 #line 894 "rx-decode.opc"
11640 int rdst AU = op[2] & 0x0f;
11641 if (trace)
11642 {
11643 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11644 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
11645 op[0], op[1], op[2]);
11646 printf (" rdst = 0x%x\n", rdst);
11647 }
11648 SYNTAX("fadd #%1, %0");
11649 #line 894 "rx-decode.opc"
11650 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11651
11652 }
11653 break;
11654 case 0x30:
11655 {
11656 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
11657 #line 915 "rx-decode.opc"
11658 int rdst AU = op[2] & 0x0f;
11659 if (trace)
11660 {
11661 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11662 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
11663 op[0], op[1], op[2]);
11664 printf (" rdst = 0x%x\n", rdst);
11665 }
11666 SYNTAX("fmul #%1, %0");
11667 #line 915 "rx-decode.opc"
11668 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
11669
11670 }
11671 break;
11672 case 0x40:
11673 {
11674 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
11675 #line 921 "rx-decode.opc"
11676 int rdst AU = op[2] & 0x0f;
11677 if (trace)
11678 {
11679 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11680 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
11681 op[0], op[1], op[2]);
11682 printf (" rdst = 0x%x\n", rdst);
11683 }
11684 SYNTAX("fdiv #%1, %0");
11685 #line 921 "rx-decode.opc"
11686 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
11687
11688 }
11689 break;
11690 default: UNSUPPORTED(); break;
11691 }
11692 break;
11693 case 0x73:
11694 GETBYTE ();
11695 switch (op[2] & 0xe0)
11696 {
11697 case 0x00:
11698 op_semantics_109:
11699 {
11700 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
11701 #line 1011 "rx-decode.opc"
11702 int im AU = (op[1] >> 2) & 0x03;
11703 #line 1011 "rx-decode.opc"
11704 int crdst AU = op[2] & 0x1f;
11705 if (trace)
11706 {
11707 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11708 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
11709 op[0], op[1], op[2]);
11710 printf (" im = 0x%x,", im);
11711 printf (" crdst = 0x%x\n", crdst);
11712 }
11713 SYNTAX("mvtc #%1, %0");
11714 #line 1011 "rx-decode.opc"
11715 ID(mov); SC(IMMex(im)); DR(crdst + 16);
11716
11717 }
11718 break;
11719 default: UNSUPPORTED(); break;
11720 }
11721 break;
11722 case 0x74:
11723 GETBYTE ();
11724 switch (op[2] & 0xf0)
11725 {
11726 case 0x20:
11727 goto op_semantics_98;
11728 break;
11729 case 0x40:
11730 goto op_semantics_99;
11731 break;
11732 case 0x50:
11733 goto op_semantics_100;
11734 break;
11735 case 0x60:
11736 goto op_semantics_101;
11737 break;
11738 case 0x70:
11739 goto op_semantics_102;
11740 break;
11741 case 0x80:
11742 goto op_semantics_103;
11743 break;
11744 case 0x90:
11745 goto op_semantics_104;
11746 break;
11747 case 0xc0:
11748 goto op_semantics_105;
11749 break;
11750 case 0xd0:
11751 goto op_semantics_106;
11752 break;
11753 case 0xe0:
11754 goto op_semantics_107;
11755 break;
11756 case 0xf0:
11757 goto op_semantics_108;
11758 break;
11759 default: UNSUPPORTED(); break;
11760 }
11761 break;
11762 case 0x77:
11763 GETBYTE ();
11764 switch (op[2] & 0xe0)
11765 {
11766 case 0x00:
11767 goto op_semantics_109;
11768 break;
11769 default: UNSUPPORTED(); break;
11770 }
11771 break;
11772 case 0x78:
11773 GETBYTE ();
11774 switch (op[2] & 0xf0)
11775 {
11776 case 0x20:
11777 goto op_semantics_98;
11778 break;
11779 case 0x40:
11780 goto op_semantics_99;
11781 break;
11782 case 0x50:
11783 goto op_semantics_100;
11784 break;
11785 case 0x60:
11786 goto op_semantics_101;
11787 break;
11788 case 0x70:
11789 goto op_semantics_102;
11790 break;
11791 case 0x80:
11792 goto op_semantics_103;
11793 break;
11794 case 0x90:
11795 goto op_semantics_104;
11796 break;
11797 case 0xc0:
11798 goto op_semantics_105;
11799 break;
11800 case 0xd0:
11801 goto op_semantics_106;
11802 break;
11803 case 0xe0:
11804 goto op_semantics_107;
11805 break;
11806 case 0xf0:
11807 goto op_semantics_108;
11808 break;
11809 default: UNSUPPORTED(); break;
11810 }
11811 break;
11812 case 0x7b:
11813 GETBYTE ();
11814 switch (op[2] & 0xe0)
11815 {
11816 case 0x00:
11817 goto op_semantics_109;
11818 break;
11819 default: UNSUPPORTED(); break;
11820 }
11821 break;
11822 case 0x7c:
11823 GETBYTE ();
11824 switch (op[2] & 0xf0)
11825 {
11826 case 0x20:
11827 goto op_semantics_98;
11828 break;
11829 case 0x40:
11830 goto op_semantics_99;
11831 break;
11832 case 0x50:
11833 goto op_semantics_100;
11834 break;
11835 case 0x60:
11836 goto op_semantics_101;
11837 break;
11838 case 0x70:
11839 goto op_semantics_102;
11840 break;
11841 case 0x80:
11842 goto op_semantics_103;
11843 break;
11844 case 0x90:
11845 goto op_semantics_104;
11846 break;
11847 case 0xc0:
11848 goto op_semantics_105;
11849 break;
11850 case 0xd0:
11851 goto op_semantics_106;
11852 break;
11853 case 0xe0:
11854 goto op_semantics_107;
11855 break;
11856 case 0xf0:
11857 goto op_semantics_108;
11858 break;
11859 default: UNSUPPORTED(); break;
11860 }
11861 break;
11862 case 0x7f:
11863 GETBYTE ();
11864 switch (op[2] & 0xe0)
11865 {
11866 case 0x00:
11867 goto op_semantics_109;
11868 break;
11869 default: UNSUPPORTED(); break;
11870 }
11871 break;
11872 case 0x80:
11873 GETBYTE ();
11874 switch (op[2] & 0x00)
11875 {
11876 case 0x00:
11877 op_semantics_110:
11878 {
11879 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
11880 #line 736 "rx-decode.opc"
11881 int immmm AU = op[1] & 0x1f;
11882 #line 736 "rx-decode.opc"
11883 int rsrc AU = (op[2] >> 4) & 0x0f;
11884 #line 736 "rx-decode.opc"
11885 int rdst AU = op[2] & 0x0f;
11886 if (trace)
11887 {
11888 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11889 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
11890 op[0], op[1], op[2]);
11891 printf (" immmm = 0x%x,", immmm);
11892 printf (" rsrc = 0x%x,", rsrc);
11893 printf (" rdst = 0x%x\n", rdst);
11894 }
11895 SYNTAX("shlr #%2, %1, %0");
11896 #line 736 "rx-decode.opc"
11897 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
11898
11899 /*----------------------------------------------------------------------*/
11900 /* ROTATE */
11901
11902 }
11903 break;
11904 }
11905 break;
11906 case 0x81:
11907 GETBYTE ();
11908 switch (op[2] & 0x00)
11909 {
11910 case 0x00:
11911 goto op_semantics_110;
11912 break;
11913 }
11914 break;
11915 case 0x82:
11916 GETBYTE ();
11917 switch (op[2] & 0x00)
11918 {
11919 case 0x00:
11920 goto op_semantics_110;
11921 break;
11922 }
11923 break;
11924 case 0x83:
11925 GETBYTE ();
11926 switch (op[2] & 0x00)
11927 {
11928 case 0x00:
11929 goto op_semantics_110;
11930 break;
11931 }
11932 break;
11933 case 0x84:
11934 GETBYTE ();
11935 switch (op[2] & 0x00)
11936 {
11937 case 0x00:
11938 goto op_semantics_110;
11939 break;
11940 }
11941 break;
11942 case 0x85:
11943 GETBYTE ();
11944 switch (op[2] & 0x00)
11945 {
11946 case 0x00:
11947 goto op_semantics_110;
11948 break;
11949 }
11950 break;
11951 case 0x86:
11952 GETBYTE ();
11953 switch (op[2] & 0x00)
11954 {
11955 case 0x00:
11956 goto op_semantics_110;
11957 break;
11958 }
11959 break;
11960 case 0x87:
11961 GETBYTE ();
11962 switch (op[2] & 0x00)
11963 {
11964 case 0x00:
11965 goto op_semantics_110;
11966 break;
11967 }
11968 break;
11969 case 0x88:
11970 GETBYTE ();
11971 switch (op[2] & 0x00)
11972 {
11973 case 0x00:
11974 goto op_semantics_110;
11975 break;
11976 }
11977 break;
11978 case 0x89:
11979 GETBYTE ();
11980 switch (op[2] & 0x00)
11981 {
11982 case 0x00:
11983 goto op_semantics_110;
11984 break;
11985 }
11986 break;
11987 case 0x8a:
11988 GETBYTE ();
11989 switch (op[2] & 0x00)
11990 {
11991 case 0x00:
11992 goto op_semantics_110;
11993 break;
11994 }
11995 break;
11996 case 0x8b:
11997 GETBYTE ();
11998 switch (op[2] & 0x00)
11999 {
12000 case 0x00:
12001 goto op_semantics_110;
12002 break;
12003 }
12004 break;
12005 case 0x8c:
12006 GETBYTE ();
12007 switch (op[2] & 0x00)
12008 {
12009 case 0x00:
12010 goto op_semantics_110;
12011 break;
12012 }
12013 break;
12014 case 0x8d:
12015 GETBYTE ();
12016 switch (op[2] & 0x00)
12017 {
12018 case 0x00:
12019 goto op_semantics_110;
12020 break;
12021 }
12022 break;
12023 case 0x8e:
12024 GETBYTE ();
12025 switch (op[2] & 0x00)
12026 {
12027 case 0x00:
12028 goto op_semantics_110;
12029 break;
12030 }
12031 break;
12032 case 0x8f:
12033 GETBYTE ();
12034 switch (op[2] & 0x00)
12035 {
12036 case 0x00:
12037 goto op_semantics_110;
12038 break;
12039 }
12040 break;
12041 case 0x90:
12042 GETBYTE ();
12043 switch (op[2] & 0x00)
12044 {
12045 case 0x00:
12046 goto op_semantics_110;
12047 break;
12048 }
12049 break;
12050 case 0x91:
12051 GETBYTE ();
12052 switch (op[2] & 0x00)
12053 {
12054 case 0x00:
12055 goto op_semantics_110;
12056 break;
12057 }
12058 break;
12059 case 0x92:
12060 GETBYTE ();
12061 switch (op[2] & 0x00)
12062 {
12063 case 0x00:
12064 goto op_semantics_110;
12065 break;
12066 }
12067 break;
12068 case 0x93:
12069 GETBYTE ();
12070 switch (op[2] & 0x00)
12071 {
12072 case 0x00:
12073 goto op_semantics_110;
12074 break;
12075 }
12076 break;
12077 case 0x94:
12078 GETBYTE ();
12079 switch (op[2] & 0x00)
12080 {
12081 case 0x00:
12082 goto op_semantics_110;
12083 break;
12084 }
12085 break;
12086 case 0x95:
12087 GETBYTE ();
12088 switch (op[2] & 0x00)
12089 {
12090 case 0x00:
12091 goto op_semantics_110;
12092 break;
12093 }
12094 break;
12095 case 0x96:
12096 GETBYTE ();
12097 switch (op[2] & 0x00)
12098 {
12099 case 0x00:
12100 goto op_semantics_110;
12101 break;
12102 }
12103 break;
12104 case 0x97:
12105 GETBYTE ();
12106 switch (op[2] & 0x00)
12107 {
12108 case 0x00:
12109 goto op_semantics_110;
12110 break;
12111 }
12112 break;
12113 case 0x98:
12114 GETBYTE ();
12115 switch (op[2] & 0x00)
12116 {
12117 case 0x00:
12118 goto op_semantics_110;
12119 break;
12120 }
12121 break;
12122 case 0x99:
12123 GETBYTE ();
12124 switch (op[2] & 0x00)
12125 {
12126 case 0x00:
12127 goto op_semantics_110;
12128 break;
12129 }
12130 break;
12131 case 0x9a:
12132 GETBYTE ();
12133 switch (op[2] & 0x00)
12134 {
12135 case 0x00:
12136 goto op_semantics_110;
12137 break;
12138 }
12139 break;
12140 case 0x9b:
12141 GETBYTE ();
12142 switch (op[2] & 0x00)
12143 {
12144 case 0x00:
12145 goto op_semantics_110;
12146 break;
12147 }
12148 break;
12149 case 0x9c:
12150 GETBYTE ();
12151 switch (op[2] & 0x00)
12152 {
12153 case 0x00:
12154 goto op_semantics_110;
12155 break;
12156 }
12157 break;
12158 case 0x9d:
12159 GETBYTE ();
12160 switch (op[2] & 0x00)
12161 {
12162 case 0x00:
12163 goto op_semantics_110;
12164 break;
12165 }
12166 break;
12167 case 0x9e:
12168 GETBYTE ();
12169 switch (op[2] & 0x00)
12170 {
12171 case 0x00:
12172 goto op_semantics_110;
12173 break;
12174 }
12175 break;
12176 case 0x9f:
12177 GETBYTE ();
12178 switch (op[2] & 0x00)
12179 {
12180 case 0x00:
12181 goto op_semantics_110;
12182 break;
12183 }
12184 break;
12185 case 0xa0:
12186 GETBYTE ();
12187 switch (op[2] & 0x00)
12188 {
12189 case 0x00:
12190 op_semantics_111:
12191 {
12192 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
12193 #line 726 "rx-decode.opc"
12194 int immmm AU = op[1] & 0x1f;
12195 #line 726 "rx-decode.opc"
12196 int rsrc AU = (op[2] >> 4) & 0x0f;
12197 #line 726 "rx-decode.opc"
12198 int rdst AU = op[2] & 0x0f;
12199 if (trace)
12200 {
12201 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12202 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
12203 op[0], op[1], op[2]);
12204 printf (" immmm = 0x%x,", immmm);
12205 printf (" rsrc = 0x%x,", rsrc);
12206 printf (" rdst = 0x%x\n", rdst);
12207 }
12208 SYNTAX("shar #%2, %1, %0");
12209 #line 726 "rx-decode.opc"
12210 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
12211
12212
12213 }
12214 break;
12215 }
12216 break;
12217 case 0xa1:
12218 GETBYTE ();
12219 switch (op[2] & 0x00)
12220 {
12221 case 0x00:
12222 goto op_semantics_111;
12223 break;
12224 }
12225 break;
12226 case 0xa2:
12227 GETBYTE ();
12228 switch (op[2] & 0x00)
12229 {
12230 case 0x00:
12231 goto op_semantics_111;
12232 break;
12233 }
12234 break;
12235 case 0xa3:
12236 GETBYTE ();
12237 switch (op[2] & 0x00)
12238 {
12239 case 0x00:
12240 goto op_semantics_111;
12241 break;
12242 }
12243 break;
12244 case 0xa4:
12245 GETBYTE ();
12246 switch (op[2] & 0x00)
12247 {
12248 case 0x00:
12249 goto op_semantics_111;
12250 break;
12251 }
12252 break;
12253 case 0xa5:
12254 GETBYTE ();
12255 switch (op[2] & 0x00)
12256 {
12257 case 0x00:
12258 goto op_semantics_111;
12259 break;
12260 }
12261 break;
12262 case 0xa6:
12263 GETBYTE ();
12264 switch (op[2] & 0x00)
12265 {
12266 case 0x00:
12267 goto op_semantics_111;
12268 break;
12269 }
12270 break;
12271 case 0xa7:
12272 GETBYTE ();
12273 switch (op[2] & 0x00)
12274 {
12275 case 0x00:
12276 goto op_semantics_111;
12277 break;
12278 }
12279 break;
12280 case 0xa8:
12281 GETBYTE ();
12282 switch (op[2] & 0x00)
12283 {
12284 case 0x00:
12285 goto op_semantics_111;
12286 break;
12287 }
12288 break;
12289 case 0xa9:
12290 GETBYTE ();
12291 switch (op[2] & 0x00)
12292 {
12293 case 0x00:
12294 goto op_semantics_111;
12295 break;
12296 }
12297 break;
12298 case 0xaa:
12299 GETBYTE ();
12300 switch (op[2] & 0x00)
12301 {
12302 case 0x00:
12303 goto op_semantics_111;
12304 break;
12305 }
12306 break;
12307 case 0xab:
12308 GETBYTE ();
12309 switch (op[2] & 0x00)
12310 {
12311 case 0x00:
12312 goto op_semantics_111;
12313 break;
12314 }
12315 break;
12316 case 0xac:
12317 GETBYTE ();
12318 switch (op[2] & 0x00)
12319 {
12320 case 0x00:
12321 goto op_semantics_111;
12322 break;
12323 }
12324 break;
12325 case 0xad:
12326 GETBYTE ();
12327 switch (op[2] & 0x00)
12328 {
12329 case 0x00:
12330 goto op_semantics_111;
12331 break;
12332 }
12333 break;
12334 case 0xae:
12335 GETBYTE ();
12336 switch (op[2] & 0x00)
12337 {
12338 case 0x00:
12339 goto op_semantics_111;
12340 break;
12341 }
12342 break;
12343 case 0xaf:
12344 GETBYTE ();
12345 switch (op[2] & 0x00)
12346 {
12347 case 0x00:
12348 goto op_semantics_111;
12349 break;
12350 }
12351 break;
12352 case 0xb0:
12353 GETBYTE ();
12354 switch (op[2] & 0x00)
12355 {
12356 case 0x00:
12357 goto op_semantics_111;
12358 break;
12359 }
12360 break;
12361 case 0xb1:
12362 GETBYTE ();
12363 switch (op[2] & 0x00)
12364 {
12365 case 0x00:
12366 goto op_semantics_111;
12367 break;
12368 }
12369 break;
12370 case 0xb2:
12371 GETBYTE ();
12372 switch (op[2] & 0x00)
12373 {
12374 case 0x00:
12375 goto op_semantics_111;
12376 break;
12377 }
12378 break;
12379 case 0xb3:
12380 GETBYTE ();
12381 switch (op[2] & 0x00)
12382 {
12383 case 0x00:
12384 goto op_semantics_111;
12385 break;
12386 }
12387 break;
12388 case 0xb4:
12389 GETBYTE ();
12390 switch (op[2] & 0x00)
12391 {
12392 case 0x00:
12393 goto op_semantics_111;
12394 break;
12395 }
12396 break;
12397 case 0xb5:
12398 GETBYTE ();
12399 switch (op[2] & 0x00)
12400 {
12401 case 0x00:
12402 goto op_semantics_111;
12403 break;
12404 }
12405 break;
12406 case 0xb6:
12407 GETBYTE ();
12408 switch (op[2] & 0x00)
12409 {
12410 case 0x00:
12411 goto op_semantics_111;
12412 break;
12413 }
12414 break;
12415 case 0xb7:
12416 GETBYTE ();
12417 switch (op[2] & 0x00)
12418 {
12419 case 0x00:
12420 goto op_semantics_111;
12421 break;
12422 }
12423 break;
12424 case 0xb8:
12425 GETBYTE ();
12426 switch (op[2] & 0x00)
12427 {
12428 case 0x00:
12429 goto op_semantics_111;
12430 break;
12431 }
12432 break;
12433 case 0xb9:
12434 GETBYTE ();
12435 switch (op[2] & 0x00)
12436 {
12437 case 0x00:
12438 goto op_semantics_111;
12439 break;
12440 }
12441 break;
12442 case 0xba:
12443 GETBYTE ();
12444 switch (op[2] & 0x00)
12445 {
12446 case 0x00:
12447 goto op_semantics_111;
12448 break;
12449 }
12450 break;
12451 case 0xbb:
12452 GETBYTE ();
12453 switch (op[2] & 0x00)
12454 {
12455 case 0x00:
12456 goto op_semantics_111;
12457 break;
12458 }
12459 break;
12460 case 0xbc:
12461 GETBYTE ();
12462 switch (op[2] & 0x00)
12463 {
12464 case 0x00:
12465 goto op_semantics_111;
12466 break;
12467 }
12468 break;
12469 case 0xbd:
12470 GETBYTE ();
12471 switch (op[2] & 0x00)
12472 {
12473 case 0x00:
12474 goto op_semantics_111;
12475 break;
12476 }
12477 break;
12478 case 0xbe:
12479 GETBYTE ();
12480 switch (op[2] & 0x00)
12481 {
12482 case 0x00:
12483 goto op_semantics_111;
12484 break;
12485 }
12486 break;
12487 case 0xbf:
12488 GETBYTE ();
12489 switch (op[2] & 0x00)
12490 {
12491 case 0x00:
12492 goto op_semantics_111;
12493 break;
12494 }
12495 break;
12496 case 0xc0:
12497 GETBYTE ();
12498 switch (op[2] & 0x00)
12499 {
12500 case 0x00:
12501 op_semantics_112:
12502 {
12503 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
12504 #line 716 "rx-decode.opc"
12505 int immmm AU = op[1] & 0x1f;
12506 #line 716 "rx-decode.opc"
12507 int rsrc AU = (op[2] >> 4) & 0x0f;
12508 #line 716 "rx-decode.opc"
12509 int rdst AU = op[2] & 0x0f;
12510 if (trace)
12511 {
12512 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12513 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
12514 op[0], op[1], op[2]);
12515 printf (" immmm = 0x%x,", immmm);
12516 printf (" rsrc = 0x%x,", rsrc);
12517 printf (" rdst = 0x%x\n", rdst);
12518 }
12519 SYNTAX("shll #%2, %1, %0");
12520 #line 716 "rx-decode.opc"
12521 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
12522
12523
12524 }
12525 break;
12526 }
12527 break;
12528 case 0xc1:
12529 GETBYTE ();
12530 switch (op[2] & 0x00)
12531 {
12532 case 0x00:
12533 goto op_semantics_112;
12534 break;
12535 }
12536 break;
12537 case 0xc2:
12538 GETBYTE ();
12539 switch (op[2] & 0x00)
12540 {
12541 case 0x00:
12542 goto op_semantics_112;
12543 break;
12544 }
12545 break;
12546 case 0xc3:
12547 GETBYTE ();
12548 switch (op[2] & 0x00)
12549 {
12550 case 0x00:
12551 goto op_semantics_112;
12552 break;
12553 }
12554 break;
12555 case 0xc4:
12556 GETBYTE ();
12557 switch (op[2] & 0x00)
12558 {
12559 case 0x00:
12560 goto op_semantics_112;
12561 break;
12562 }
12563 break;
12564 case 0xc5:
12565 GETBYTE ();
12566 switch (op[2] & 0x00)
12567 {
12568 case 0x00:
12569 goto op_semantics_112;
12570 break;
12571 }
12572 break;
12573 case 0xc6:
12574 GETBYTE ();
12575 switch (op[2] & 0x00)
12576 {
12577 case 0x00:
12578 goto op_semantics_112;
12579 break;
12580 }
12581 break;
12582 case 0xc7:
12583 GETBYTE ();
12584 switch (op[2] & 0x00)
12585 {
12586 case 0x00:
12587 goto op_semantics_112;
12588 break;
12589 }
12590 break;
12591 case 0xc8:
12592 GETBYTE ();
12593 switch (op[2] & 0x00)
12594 {
12595 case 0x00:
12596 goto op_semantics_112;
12597 break;
12598 }
12599 break;
12600 case 0xc9:
12601 GETBYTE ();
12602 switch (op[2] & 0x00)
12603 {
12604 case 0x00:
12605 goto op_semantics_112;
12606 break;
12607 }
12608 break;
12609 case 0xca:
12610 GETBYTE ();
12611 switch (op[2] & 0x00)
12612 {
12613 case 0x00:
12614 goto op_semantics_112;
12615 break;
12616 }
12617 break;
12618 case 0xcb:
12619 GETBYTE ();
12620 switch (op[2] & 0x00)
12621 {
12622 case 0x00:
12623 goto op_semantics_112;
12624 break;
12625 }
12626 break;
12627 case 0xcc:
12628 GETBYTE ();
12629 switch (op[2] & 0x00)
12630 {
12631 case 0x00:
12632 goto op_semantics_112;
12633 break;
12634 }
12635 break;
12636 case 0xcd:
12637 GETBYTE ();
12638 switch (op[2] & 0x00)
12639 {
12640 case 0x00:
12641 goto op_semantics_112;
12642 break;
12643 }
12644 break;
12645 case 0xce:
12646 GETBYTE ();
12647 switch (op[2] & 0x00)
12648 {
12649 case 0x00:
12650 goto op_semantics_112;
12651 break;
12652 }
12653 break;
12654 case 0xcf:
12655 GETBYTE ();
12656 switch (op[2] & 0x00)
12657 {
12658 case 0x00:
12659 goto op_semantics_112;
12660 break;
12661 }
12662 break;
12663 case 0xd0:
12664 GETBYTE ();
12665 switch (op[2] & 0x00)
12666 {
12667 case 0x00:
12668 goto op_semantics_112;
12669 break;
12670 }
12671 break;
12672 case 0xd1:
12673 GETBYTE ();
12674 switch (op[2] & 0x00)
12675 {
12676 case 0x00:
12677 goto op_semantics_112;
12678 break;
12679 }
12680 break;
12681 case 0xd2:
12682 GETBYTE ();
12683 switch (op[2] & 0x00)
12684 {
12685 case 0x00:
12686 goto op_semantics_112;
12687 break;
12688 }
12689 break;
12690 case 0xd3:
12691 GETBYTE ();
12692 switch (op[2] & 0x00)
12693 {
12694 case 0x00:
12695 goto op_semantics_112;
12696 break;
12697 }
12698 break;
12699 case 0xd4:
12700 GETBYTE ();
12701 switch (op[2] & 0x00)
12702 {
12703 case 0x00:
12704 goto op_semantics_112;
12705 break;
12706 }
12707 break;
12708 case 0xd5:
12709 GETBYTE ();
12710 switch (op[2] & 0x00)
12711 {
12712 case 0x00:
12713 goto op_semantics_112;
12714 break;
12715 }
12716 break;
12717 case 0xd6:
12718 GETBYTE ();
12719 switch (op[2] & 0x00)
12720 {
12721 case 0x00:
12722 goto op_semantics_112;
12723 break;
12724 }
12725 break;
12726 case 0xd7:
12727 GETBYTE ();
12728 switch (op[2] & 0x00)
12729 {
12730 case 0x00:
12731 goto op_semantics_112;
12732 break;
12733 }
12734 break;
12735 case 0xd8:
12736 GETBYTE ();
12737 switch (op[2] & 0x00)
12738 {
12739 case 0x00:
12740 goto op_semantics_112;
12741 break;
12742 }
12743 break;
12744 case 0xd9:
12745 GETBYTE ();
12746 switch (op[2] & 0x00)
12747 {
12748 case 0x00:
12749 goto op_semantics_112;
12750 break;
12751 }
12752 break;
12753 case 0xda:
12754 GETBYTE ();
12755 switch (op[2] & 0x00)
12756 {
12757 case 0x00:
12758 goto op_semantics_112;
12759 break;
12760 }
12761 break;
12762 case 0xdb:
12763 GETBYTE ();
12764 switch (op[2] & 0x00)
12765 {
12766 case 0x00:
12767 goto op_semantics_112;
12768 break;
12769 }
12770 break;
12771 case 0xdc:
12772 GETBYTE ();
12773 switch (op[2] & 0x00)
12774 {
12775 case 0x00:
12776 goto op_semantics_112;
12777 break;
12778 }
12779 break;
12780 case 0xdd:
12781 GETBYTE ();
12782 switch (op[2] & 0x00)
12783 {
12784 case 0x00:
12785 goto op_semantics_112;
12786 break;
12787 }
12788 break;
12789 case 0xde:
12790 GETBYTE ();
12791 switch (op[2] & 0x00)
12792 {
12793 case 0x00:
12794 goto op_semantics_112;
12795 break;
12796 }
12797 break;
12798 case 0xdf:
12799 GETBYTE ();
12800 switch (op[2] & 0x00)
12801 {
12802 case 0x00:
12803 goto op_semantics_112;
12804 break;
12805 }
12806 break;
12807 case 0xe0:
12808 GETBYTE ();
12809 switch (op[2] & 0xf0)
12810 {
12811 case 0x00:
12812 case 0x10:
12813 case 0x20:
12814 case 0x30:
12815 case 0x40:
12816 case 0x50:
12817 case 0x60:
12818 case 0x70:
12819 case 0x80:
12820 case 0x90:
12821 case 0xa0:
12822 case 0xb0:
12823 case 0xc0:
12824 case 0xd0:
12825 case 0xe0:
12826 op_semantics_113:
12827 {
12828 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
12829 #line 990 "rx-decode.opc"
12830 int bittt AU = op[1] & 0x1f;
12831 #line 990 "rx-decode.opc"
12832 int cond AU = (op[2] >> 4) & 0x0f;
12833 #line 990 "rx-decode.opc"
12834 int rdst AU = op[2] & 0x0f;
12835 if (trace)
12836 {
12837 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12838 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
12839 op[0], op[1], op[2]);
12840 printf (" bittt = 0x%x,", bittt);
12841 printf (" cond = 0x%x,", cond);
12842 printf (" rdst = 0x%x\n", rdst);
12843 }
12844 SYNTAX("bm%2 #%1, %0%S0");
12845 #line 990 "rx-decode.opc"
12846 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12847
12848 /*----------------------------------------------------------------------*/
12849 /* CONTROL REGISTERS */
12850
12851 }
12852 break;
12853 case 0xf0:
12854 op_semantics_114:
12855 {
12856 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
12857 #line 983 "rx-decode.opc"
12858 int bittt AU = op[1] & 0x1f;
12859 #line 983 "rx-decode.opc"
12860 int rdst AU = op[2] & 0x0f;
12861 if (trace)
12862 {
12863 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12864 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
12865 op[0], op[1], op[2]);
12866 printf (" bittt = 0x%x,", bittt);
12867 printf (" rdst = 0x%x\n", rdst);
12868 }
12869 SYNTAX("bnot #%1, %0");
12870 #line 983 "rx-decode.opc"
12871 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12872
12873
12874 }
12875 break;
12876 }
12877 break;
12878 case 0xe1:
12879 GETBYTE ();
12880 switch (op[2] & 0xf0)
12881 {
12882 case 0x00:
12883 case 0x10:
12884 case 0x20:
12885 case 0x30:
12886 case 0x40:
12887 case 0x50:
12888 case 0x60:
12889 case 0x70:
12890 case 0x80:
12891 case 0x90:
12892 case 0xa0:
12893 case 0xb0:
12894 case 0xc0:
12895 case 0xd0:
12896 case 0xe0:
12897 goto op_semantics_113;
12898 break;
12899 case 0xf0:
12900 goto op_semantics_114;
12901 break;
12902 }
12903 break;
12904 case 0xe2:
12905 GETBYTE ();
12906 switch (op[2] & 0xf0)
12907 {
12908 case 0x00:
12909 case 0x10:
12910 case 0x20:
12911 case 0x30:
12912 case 0x40:
12913 case 0x50:
12914 case 0x60:
12915 case 0x70:
12916 case 0x80:
12917 case 0x90:
12918 case 0xa0:
12919 case 0xb0:
12920 case 0xc0:
12921 case 0xd0:
12922 case 0xe0:
12923 goto op_semantics_113;
12924 break;
12925 case 0xf0:
12926 goto op_semantics_114;
12927 break;
12928 }
12929 break;
12930 case 0xe3:
12931 GETBYTE ();
12932 switch (op[2] & 0xf0)
12933 {
12934 case 0x00:
12935 case 0x10:
12936 case 0x20:
12937 case 0x30:
12938 case 0x40:
12939 case 0x50:
12940 case 0x60:
12941 case 0x70:
12942 case 0x80:
12943 case 0x90:
12944 case 0xa0:
12945 case 0xb0:
12946 case 0xc0:
12947 case 0xd0:
12948 case 0xe0:
12949 goto op_semantics_113;
12950 break;
12951 case 0xf0:
12952 goto op_semantics_114;
12953 break;
12954 }
12955 break;
12956 case 0xe4:
12957 GETBYTE ();
12958 switch (op[2] & 0xf0)
12959 {
12960 case 0x00:
12961 case 0x10:
12962 case 0x20:
12963 case 0x30:
12964 case 0x40:
12965 case 0x50:
12966 case 0x60:
12967 case 0x70:
12968 case 0x80:
12969 case 0x90:
12970 case 0xa0:
12971 case 0xb0:
12972 case 0xc0:
12973 case 0xd0:
12974 case 0xe0:
12975 goto op_semantics_113;
12976 break;
12977 case 0xf0:
12978 goto op_semantics_114;
12979 break;
12980 }
12981 break;
12982 case 0xe5:
12983 GETBYTE ();
12984 switch (op[2] & 0xf0)
12985 {
12986 case 0x00:
12987 case 0x10:
12988 case 0x20:
12989 case 0x30:
12990 case 0x40:
12991 case 0x50:
12992 case 0x60:
12993 case 0x70:
12994 case 0x80:
12995 case 0x90:
12996 case 0xa0:
12997 case 0xb0:
12998 case 0xc0:
12999 case 0xd0:
13000 case 0xe0:
13001 goto op_semantics_113;
13002 break;
13003 case 0xf0:
13004 goto op_semantics_114;
13005 break;
13006 }
13007 break;
13008 case 0xe6:
13009 GETBYTE ();
13010 switch (op[2] & 0xf0)
13011 {
13012 case 0x00:
13013 case 0x10:
13014 case 0x20:
13015 case 0x30:
13016 case 0x40:
13017 case 0x50:
13018 case 0x60:
13019 case 0x70:
13020 case 0x80:
13021 case 0x90:
13022 case 0xa0:
13023 case 0xb0:
13024 case 0xc0:
13025 case 0xd0:
13026 case 0xe0:
13027 goto op_semantics_113;
13028 break;
13029 case 0xf0:
13030 goto op_semantics_114;
13031 break;
13032 }
13033 break;
13034 case 0xe7:
13035 GETBYTE ();
13036 switch (op[2] & 0xf0)
13037 {
13038 case 0x00:
13039 case 0x10:
13040 case 0x20:
13041 case 0x30:
13042 case 0x40:
13043 case 0x50:
13044 case 0x60:
13045 case 0x70:
13046 case 0x80:
13047 case 0x90:
13048 case 0xa0:
13049 case 0xb0:
13050 case 0xc0:
13051 case 0xd0:
13052 case 0xe0:
13053 goto op_semantics_113;
13054 break;
13055 case 0xf0:
13056 goto op_semantics_114;
13057 break;
13058 }
13059 break;
13060 case 0xe8:
13061 GETBYTE ();
13062 switch (op[2] & 0xf0)
13063 {
13064 case 0x00:
13065 case 0x10:
13066 case 0x20:
13067 case 0x30:
13068 case 0x40:
13069 case 0x50:
13070 case 0x60:
13071 case 0x70:
13072 case 0x80:
13073 case 0x90:
13074 case 0xa0:
13075 case 0xb0:
13076 case 0xc0:
13077 case 0xd0:
13078 case 0xe0:
13079 goto op_semantics_113;
13080 break;
13081 case 0xf0:
13082 goto op_semantics_114;
13083 break;
13084 }
13085 break;
13086 case 0xe9:
13087 GETBYTE ();
13088 switch (op[2] & 0xf0)
13089 {
13090 case 0x00:
13091 case 0x10:
13092 case 0x20:
13093 case 0x30:
13094 case 0x40:
13095 case 0x50:
13096 case 0x60:
13097 case 0x70:
13098 case 0x80:
13099 case 0x90:
13100 case 0xa0:
13101 case 0xb0:
13102 case 0xc0:
13103 case 0xd0:
13104 case 0xe0:
13105 goto op_semantics_113;
13106 break;
13107 case 0xf0:
13108 goto op_semantics_114;
13109 break;
13110 }
13111 break;
13112 case 0xea:
13113 GETBYTE ();
13114 switch (op[2] & 0xf0)
13115 {
13116 case 0x00:
13117 case 0x10:
13118 case 0x20:
13119 case 0x30:
13120 case 0x40:
13121 case 0x50:
13122 case 0x60:
13123 case 0x70:
13124 case 0x80:
13125 case 0x90:
13126 case 0xa0:
13127 case 0xb0:
13128 case 0xc0:
13129 case 0xd0:
13130 case 0xe0:
13131 goto op_semantics_113;
13132 break;
13133 case 0xf0:
13134 goto op_semantics_114;
13135 break;
13136 }
13137 break;
13138 case 0xeb:
13139 GETBYTE ();
13140 switch (op[2] & 0xf0)
13141 {
13142 case 0x00:
13143 case 0x10:
13144 case 0x20:
13145 case 0x30:
13146 case 0x40:
13147 case 0x50:
13148 case 0x60:
13149 case 0x70:
13150 case 0x80:
13151 case 0x90:
13152 case 0xa0:
13153 case 0xb0:
13154 case 0xc0:
13155 case 0xd0:
13156 case 0xe0:
13157 goto op_semantics_113;
13158 break;
13159 case 0xf0:
13160 goto op_semantics_114;
13161 break;
13162 }
13163 break;
13164 case 0xec:
13165 GETBYTE ();
13166 switch (op[2] & 0xf0)
13167 {
13168 case 0x00:
13169 case 0x10:
13170 case 0x20:
13171 case 0x30:
13172 case 0x40:
13173 case 0x50:
13174 case 0x60:
13175 case 0x70:
13176 case 0x80:
13177 case 0x90:
13178 case 0xa0:
13179 case 0xb0:
13180 case 0xc0:
13181 case 0xd0:
13182 case 0xe0:
13183 goto op_semantics_113;
13184 break;
13185 case 0xf0:
13186 goto op_semantics_114;
13187 break;
13188 }
13189 break;
13190 case 0xed:
13191 GETBYTE ();
13192 switch (op[2] & 0xf0)
13193 {
13194 case 0x00:
13195 case 0x10:
13196 case 0x20:
13197 case 0x30:
13198 case 0x40:
13199 case 0x50:
13200 case 0x60:
13201 case 0x70:
13202 case 0x80:
13203 case 0x90:
13204 case 0xa0:
13205 case 0xb0:
13206 case 0xc0:
13207 case 0xd0:
13208 case 0xe0:
13209 goto op_semantics_113;
13210 break;
13211 case 0xf0:
13212 goto op_semantics_114;
13213 break;
13214 }
13215 break;
13216 case 0xee:
13217 GETBYTE ();
13218 switch (op[2] & 0xf0)
13219 {
13220 case 0x00:
13221 case 0x10:
13222 case 0x20:
13223 case 0x30:
13224 case 0x40:
13225 case 0x50:
13226 case 0x60:
13227 case 0x70:
13228 case 0x80:
13229 case 0x90:
13230 case 0xa0:
13231 case 0xb0:
13232 case 0xc0:
13233 case 0xd0:
13234 case 0xe0:
13235 goto op_semantics_113;
13236 break;
13237 case 0xf0:
13238 goto op_semantics_114;
13239 break;
13240 }
13241 break;
13242 case 0xef:
13243 GETBYTE ();
13244 switch (op[2] & 0xf0)
13245 {
13246 case 0x00:
13247 case 0x10:
13248 case 0x20:
13249 case 0x30:
13250 case 0x40:
13251 case 0x50:
13252 case 0x60:
13253 case 0x70:
13254 case 0x80:
13255 case 0x90:
13256 case 0xa0:
13257 case 0xb0:
13258 case 0xc0:
13259 case 0xd0:
13260 case 0xe0:
13261 goto op_semantics_113;
13262 break;
13263 case 0xf0:
13264 goto op_semantics_114;
13265 break;
13266 }
13267 break;
13268 case 0xf0:
13269 GETBYTE ();
13270 switch (op[2] & 0xf0)
13271 {
13272 case 0x00:
13273 case 0x10:
13274 case 0x20:
13275 case 0x30:
13276 case 0x40:
13277 case 0x50:
13278 case 0x60:
13279 case 0x70:
13280 case 0x80:
13281 case 0x90:
13282 case 0xa0:
13283 case 0xb0:
13284 case 0xc0:
13285 case 0xd0:
13286 case 0xe0:
13287 goto op_semantics_113;
13288 break;
13289 case 0xf0:
13290 goto op_semantics_114;
13291 break;
13292 }
13293 break;
13294 case 0xf1:
13295 GETBYTE ();
13296 switch (op[2] & 0xf0)
13297 {
13298 case 0x00:
13299 case 0x10:
13300 case 0x20:
13301 case 0x30:
13302 case 0x40:
13303 case 0x50:
13304 case 0x60:
13305 case 0x70:
13306 case 0x80:
13307 case 0x90:
13308 case 0xa0:
13309 case 0xb0:
13310 case 0xc0:
13311 case 0xd0:
13312 case 0xe0:
13313 goto op_semantics_113;
13314 break;
13315 case 0xf0:
13316 goto op_semantics_114;
13317 break;
13318 }
13319 break;
13320 case 0xf2:
13321 GETBYTE ();
13322 switch (op[2] & 0xf0)
13323 {
13324 case 0x00:
13325 case 0x10:
13326 case 0x20:
13327 case 0x30:
13328 case 0x40:
13329 case 0x50:
13330 case 0x60:
13331 case 0x70:
13332 case 0x80:
13333 case 0x90:
13334 case 0xa0:
13335 case 0xb0:
13336 case 0xc0:
13337 case 0xd0:
13338 case 0xe0:
13339 goto op_semantics_113;
13340 break;
13341 case 0xf0:
13342 goto op_semantics_114;
13343 break;
13344 }
13345 break;
13346 case 0xf3:
13347 GETBYTE ();
13348 switch (op[2] & 0xf0)
13349 {
13350 case 0x00:
13351 case 0x10:
13352 case 0x20:
13353 case 0x30:
13354 case 0x40:
13355 case 0x50:
13356 case 0x60:
13357 case 0x70:
13358 case 0x80:
13359 case 0x90:
13360 case 0xa0:
13361 case 0xb0:
13362 case 0xc0:
13363 case 0xd0:
13364 case 0xe0:
13365 goto op_semantics_113;
13366 break;
13367 case 0xf0:
13368 goto op_semantics_114;
13369 break;
13370 }
13371 break;
13372 case 0xf4:
13373 GETBYTE ();
13374 switch (op[2] & 0xf0)
13375 {
13376 case 0x00:
13377 case 0x10:
13378 case 0x20:
13379 case 0x30:
13380 case 0x40:
13381 case 0x50:
13382 case 0x60:
13383 case 0x70:
13384 case 0x80:
13385 case 0x90:
13386 case 0xa0:
13387 case 0xb0:
13388 case 0xc0:
13389 case 0xd0:
13390 case 0xe0:
13391 goto op_semantics_113;
13392 break;
13393 case 0xf0:
13394 goto op_semantics_114;
13395 break;
13396 }
13397 break;
13398 case 0xf5:
13399 GETBYTE ();
13400 switch (op[2] & 0xf0)
13401 {
13402 case 0x00:
13403 case 0x10:
13404 case 0x20:
13405 case 0x30:
13406 case 0x40:
13407 case 0x50:
13408 case 0x60:
13409 case 0x70:
13410 case 0x80:
13411 case 0x90:
13412 case 0xa0:
13413 case 0xb0:
13414 case 0xc0:
13415 case 0xd0:
13416 case 0xe0:
13417 goto op_semantics_113;
13418 break;
13419 case 0xf0:
13420 goto op_semantics_114;
13421 break;
13422 }
13423 break;
13424 case 0xf6:
13425 GETBYTE ();
13426 switch (op[2] & 0xf0)
13427 {
13428 case 0x00:
13429 case 0x10:
13430 case 0x20:
13431 case 0x30:
13432 case 0x40:
13433 case 0x50:
13434 case 0x60:
13435 case 0x70:
13436 case 0x80:
13437 case 0x90:
13438 case 0xa0:
13439 case 0xb0:
13440 case 0xc0:
13441 case 0xd0:
13442 case 0xe0:
13443 goto op_semantics_113;
13444 break;
13445 case 0xf0:
13446 goto op_semantics_114;
13447 break;
13448 }
13449 break;
13450 case 0xf7:
13451 GETBYTE ();
13452 switch (op[2] & 0xf0)
13453 {
13454 case 0x00:
13455 case 0x10:
13456 case 0x20:
13457 case 0x30:
13458 case 0x40:
13459 case 0x50:
13460 case 0x60:
13461 case 0x70:
13462 case 0x80:
13463 case 0x90:
13464 case 0xa0:
13465 case 0xb0:
13466 case 0xc0:
13467 case 0xd0:
13468 case 0xe0:
13469 goto op_semantics_113;
13470 break;
13471 case 0xf0:
13472 goto op_semantics_114;
13473 break;
13474 }
13475 break;
13476 case 0xf8:
13477 GETBYTE ();
13478 switch (op[2] & 0xf0)
13479 {
13480 case 0x00:
13481 case 0x10:
13482 case 0x20:
13483 case 0x30:
13484 case 0x40:
13485 case 0x50:
13486 case 0x60:
13487 case 0x70:
13488 case 0x80:
13489 case 0x90:
13490 case 0xa0:
13491 case 0xb0:
13492 case 0xc0:
13493 case 0xd0:
13494 case 0xe0:
13495 goto op_semantics_113;
13496 break;
13497 case 0xf0:
13498 goto op_semantics_114;
13499 break;
13500 }
13501 break;
13502 case 0xf9:
13503 GETBYTE ();
13504 switch (op[2] & 0xf0)
13505 {
13506 case 0x00:
13507 case 0x10:
13508 case 0x20:
13509 case 0x30:
13510 case 0x40:
13511 case 0x50:
13512 case 0x60:
13513 case 0x70:
13514 case 0x80:
13515 case 0x90:
13516 case 0xa0:
13517 case 0xb0:
13518 case 0xc0:
13519 case 0xd0:
13520 case 0xe0:
13521 goto op_semantics_113;
13522 break;
13523 case 0xf0:
13524 goto op_semantics_114;
13525 break;
13526 }
13527 break;
13528 case 0xfa:
13529 GETBYTE ();
13530 switch (op[2] & 0xf0)
13531 {
13532 case 0x00:
13533 case 0x10:
13534 case 0x20:
13535 case 0x30:
13536 case 0x40:
13537 case 0x50:
13538 case 0x60:
13539 case 0x70:
13540 case 0x80:
13541 case 0x90:
13542 case 0xa0:
13543 case 0xb0:
13544 case 0xc0:
13545 case 0xd0:
13546 case 0xe0:
13547 goto op_semantics_113;
13548 break;
13549 case 0xf0:
13550 goto op_semantics_114;
13551 break;
13552 }
13553 break;
13554 case 0xfb:
13555 GETBYTE ();
13556 switch (op[2] & 0xf0)
13557 {
13558 case 0x00:
13559 case 0x10:
13560 case 0x20:
13561 case 0x30:
13562 case 0x40:
13563 case 0x50:
13564 case 0x60:
13565 case 0x70:
13566 case 0x80:
13567 case 0x90:
13568 case 0xa0:
13569 case 0xb0:
13570 case 0xc0:
13571 case 0xd0:
13572 case 0xe0:
13573 goto op_semantics_113;
13574 break;
13575 case 0xf0:
13576 goto op_semantics_114;
13577 break;
13578 }
13579 break;
13580 case 0xfc:
13581 GETBYTE ();
13582 switch (op[2] & 0xf0)
13583 {
13584 case 0x00:
13585 case 0x10:
13586 case 0x20:
13587 case 0x30:
13588 case 0x40:
13589 case 0x50:
13590 case 0x60:
13591 case 0x70:
13592 case 0x80:
13593 case 0x90:
13594 case 0xa0:
13595 case 0xb0:
13596 case 0xc0:
13597 case 0xd0:
13598 case 0xe0:
13599 goto op_semantics_113;
13600 break;
13601 case 0xf0:
13602 goto op_semantics_114;
13603 break;
13604 }
13605 break;
13606 case 0xfd:
13607 GETBYTE ();
13608 switch (op[2] & 0xf0)
13609 {
13610 case 0x00:
13611 case 0x10:
13612 case 0x20:
13613 case 0x30:
13614 case 0x40:
13615 case 0x50:
13616 case 0x60:
13617 case 0x70:
13618 case 0x80:
13619 case 0x90:
13620 case 0xa0:
13621 case 0xb0:
13622 case 0xc0:
13623 case 0xd0:
13624 case 0xe0:
13625 goto op_semantics_113;
13626 break;
13627 case 0xf0:
13628 goto op_semantics_114;
13629 break;
13630 }
13631 break;
13632 case 0xfe:
13633 GETBYTE ();
13634 switch (op[2] & 0xf0)
13635 {
13636 case 0x00:
13637 case 0x10:
13638 case 0x20:
13639 case 0x30:
13640 case 0x40:
13641 case 0x50:
13642 case 0x60:
13643 case 0x70:
13644 case 0x80:
13645 case 0x90:
13646 case 0xa0:
13647 case 0xb0:
13648 case 0xc0:
13649 case 0xd0:
13650 case 0xe0:
13651 goto op_semantics_113;
13652 break;
13653 case 0xf0:
13654 goto op_semantics_114;
13655 break;
13656 }
13657 break;
13658 case 0xff:
13659 GETBYTE ();
13660 switch (op[2] & 0xf0)
13661 {
13662 case 0x00:
13663 case 0x10:
13664 case 0x20:
13665 case 0x30:
13666 case 0x40:
13667 case 0x50:
13668 case 0x60:
13669 case 0x70:
13670 case 0x80:
13671 case 0x90:
13672 case 0xa0:
13673 case 0xb0:
13674 case 0xc0:
13675 case 0xd0:
13676 case 0xe0:
13677 goto op_semantics_113;
13678 break;
13679 case 0xf0:
13680 goto op_semantics_114;
13681 break;
13682 }
13683 break;
13684 default: UNSUPPORTED(); break;
13685 }
13686 break;
13687 case 0xfe:
13688 GETBYTE ();
13689 switch (op[1] & 0xff)
13690 {
13691 case 0x00:
13692 GETBYTE ();
13693 switch (op[2] & 0x00)
13694 {
13695 case 0x00:
13696 op_semantics_115:
13697 {
13698 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
13699 #line 342 "rx-decode.opc"
13700 int sz AU = (op[1] >> 4) & 0x03;
13701 #line 342 "rx-decode.opc"
13702 int isrc AU = op[1] & 0x0f;
13703 #line 342 "rx-decode.opc"
13704 int bsrc AU = (op[2] >> 4) & 0x0f;
13705 #line 342 "rx-decode.opc"
13706 int rdst AU = op[2] & 0x0f;
13707 if (trace)
13708 {
13709 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13710 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
13711 op[0], op[1], op[2]);
13712 printf (" sz = 0x%x,", sz);
13713 printf (" isrc = 0x%x,", isrc);
13714 printf (" bsrc = 0x%x,", bsrc);
13715 printf (" rdst = 0x%x\n", rdst);
13716 }
13717 SYNTAX("mov%s %0, [%1, %2]");
13718 #line 342 "rx-decode.opc"
13719 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13720
13721 }
13722 break;
13723 }
13724 break;
13725 case 0x01:
13726 GETBYTE ();
13727 switch (op[2] & 0x00)
13728 {
13729 case 0x00:
13730 goto op_semantics_115;
13731 break;
13732 }
13733 break;
13734 case 0x02:
13735 GETBYTE ();
13736 switch (op[2] & 0x00)
13737 {
13738 case 0x00:
13739 goto op_semantics_115;
13740 break;
13741 }
13742 break;
13743 case 0x03:
13744 GETBYTE ();
13745 switch (op[2] & 0x00)
13746 {
13747 case 0x00:
13748 goto op_semantics_115;
13749 break;
13750 }
13751 break;
13752 case 0x04:
13753 GETBYTE ();
13754 switch (op[2] & 0x00)
13755 {
13756 case 0x00:
13757 goto op_semantics_115;
13758 break;
13759 }
13760 break;
13761 case 0x05:
13762 GETBYTE ();
13763 switch (op[2] & 0x00)
13764 {
13765 case 0x00:
13766 goto op_semantics_115;
13767 break;
13768 }
13769 break;
13770 case 0x06:
13771 GETBYTE ();
13772 switch (op[2] & 0x00)
13773 {
13774 case 0x00:
13775 goto op_semantics_115;
13776 break;
13777 }
13778 break;
13779 case 0x07:
13780 GETBYTE ();
13781 switch (op[2] & 0x00)
13782 {
13783 case 0x00:
13784 goto op_semantics_115;
13785 break;
13786 }
13787 break;
13788 case 0x08:
13789 GETBYTE ();
13790 switch (op[2] & 0x00)
13791 {
13792 case 0x00:
13793 goto op_semantics_115;
13794 break;
13795 }
13796 break;
13797 case 0x09:
13798 GETBYTE ();
13799 switch (op[2] & 0x00)
13800 {
13801 case 0x00:
13802 goto op_semantics_115;
13803 break;
13804 }
13805 break;
13806 case 0x0a:
13807 GETBYTE ();
13808 switch (op[2] & 0x00)
13809 {
13810 case 0x00:
13811 goto op_semantics_115;
13812 break;
13813 }
13814 break;
13815 case 0x0b:
13816 GETBYTE ();
13817 switch (op[2] & 0x00)
13818 {
13819 case 0x00:
13820 goto op_semantics_115;
13821 break;
13822 }
13823 break;
13824 case 0x0c:
13825 GETBYTE ();
13826 switch (op[2] & 0x00)
13827 {
13828 case 0x00:
13829 goto op_semantics_115;
13830 break;
13831 }
13832 break;
13833 case 0x0d:
13834 GETBYTE ();
13835 switch (op[2] & 0x00)
13836 {
13837 case 0x00:
13838 goto op_semantics_115;
13839 break;
13840 }
13841 break;
13842 case 0x0e:
13843 GETBYTE ();
13844 switch (op[2] & 0x00)
13845 {
13846 case 0x00:
13847 goto op_semantics_115;
13848 break;
13849 }
13850 break;
13851 case 0x0f:
13852 GETBYTE ();
13853 switch (op[2] & 0x00)
13854 {
13855 case 0x00:
13856 goto op_semantics_115;
13857 break;
13858 }
13859 break;
13860 case 0x10:
13861 GETBYTE ();
13862 switch (op[2] & 0x00)
13863 {
13864 case 0x00:
13865 goto op_semantics_115;
13866 break;
13867 }
13868 break;
13869 case 0x11:
13870 GETBYTE ();
13871 switch (op[2] & 0x00)
13872 {
13873 case 0x00:
13874 goto op_semantics_115;
13875 break;
13876 }
13877 break;
13878 case 0x12:
13879 GETBYTE ();
13880 switch (op[2] & 0x00)
13881 {
13882 case 0x00:
13883 goto op_semantics_115;
13884 break;
13885 }
13886 break;
13887 case 0x13:
13888 GETBYTE ();
13889 switch (op[2] & 0x00)
13890 {
13891 case 0x00:
13892 goto op_semantics_115;
13893 break;
13894 }
13895 break;
13896 case 0x14:
13897 GETBYTE ();
13898 switch (op[2] & 0x00)
13899 {
13900 case 0x00:
13901 goto op_semantics_115;
13902 break;
13903 }
13904 break;
13905 case 0x15:
13906 GETBYTE ();
13907 switch (op[2] & 0x00)
13908 {
13909 case 0x00:
13910 goto op_semantics_115;
13911 break;
13912 }
13913 break;
13914 case 0x16:
13915 GETBYTE ();
13916 switch (op[2] & 0x00)
13917 {
13918 case 0x00:
13919 goto op_semantics_115;
13920 break;
13921 }
13922 break;
13923 case 0x17:
13924 GETBYTE ();
13925 switch (op[2] & 0x00)
13926 {
13927 case 0x00:
13928 goto op_semantics_115;
13929 break;
13930 }
13931 break;
13932 case 0x18:
13933 GETBYTE ();
13934 switch (op[2] & 0x00)
13935 {
13936 case 0x00:
13937 goto op_semantics_115;
13938 break;
13939 }
13940 break;
13941 case 0x19:
13942 GETBYTE ();
13943 switch (op[2] & 0x00)
13944 {
13945 case 0x00:
13946 goto op_semantics_115;
13947 break;
13948 }
13949 break;
13950 case 0x1a:
13951 GETBYTE ();
13952 switch (op[2] & 0x00)
13953 {
13954 case 0x00:
13955 goto op_semantics_115;
13956 break;
13957 }
13958 break;
13959 case 0x1b:
13960 GETBYTE ();
13961 switch (op[2] & 0x00)
13962 {
13963 case 0x00:
13964 goto op_semantics_115;
13965 break;
13966 }
13967 break;
13968 case 0x1c:
13969 GETBYTE ();
13970 switch (op[2] & 0x00)
13971 {
13972 case 0x00:
13973 goto op_semantics_115;
13974 break;
13975 }
13976 break;
13977 case 0x1d:
13978 GETBYTE ();
13979 switch (op[2] & 0x00)
13980 {
13981 case 0x00:
13982 goto op_semantics_115;
13983 break;
13984 }
13985 break;
13986 case 0x1e:
13987 GETBYTE ();
13988 switch (op[2] & 0x00)
13989 {
13990 case 0x00:
13991 goto op_semantics_115;
13992 break;
13993 }
13994 break;
13995 case 0x1f:
13996 GETBYTE ();
13997 switch (op[2] & 0x00)
13998 {
13999 case 0x00:
14000 goto op_semantics_115;
14001 break;
14002 }
14003 break;
14004 case 0x20:
14005 GETBYTE ();
14006 switch (op[2] & 0x00)
14007 {
14008 case 0x00:
14009 goto op_semantics_115;
14010 break;
14011 }
14012 break;
14013 case 0x21:
14014 GETBYTE ();
14015 switch (op[2] & 0x00)
14016 {
14017 case 0x00:
14018 goto op_semantics_115;
14019 break;
14020 }
14021 break;
14022 case 0x22:
14023 GETBYTE ();
14024 switch (op[2] & 0x00)
14025 {
14026 case 0x00:
14027 goto op_semantics_115;
14028 break;
14029 }
14030 break;
14031 case 0x23:
14032 GETBYTE ();
14033 switch (op[2] & 0x00)
14034 {
14035 case 0x00:
14036 goto op_semantics_115;
14037 break;
14038 }
14039 break;
14040 case 0x24:
14041 GETBYTE ();
14042 switch (op[2] & 0x00)
14043 {
14044 case 0x00:
14045 goto op_semantics_115;
14046 break;
14047 }
14048 break;
14049 case 0x25:
14050 GETBYTE ();
14051 switch (op[2] & 0x00)
14052 {
14053 case 0x00:
14054 goto op_semantics_115;
14055 break;
14056 }
14057 break;
14058 case 0x26:
14059 GETBYTE ();
14060 switch (op[2] & 0x00)
14061 {
14062 case 0x00:
14063 goto op_semantics_115;
14064 break;
14065 }
14066 break;
14067 case 0x27:
14068 GETBYTE ();
14069 switch (op[2] & 0x00)
14070 {
14071 case 0x00:
14072 goto op_semantics_115;
14073 break;
14074 }
14075 break;
14076 case 0x28:
14077 GETBYTE ();
14078 switch (op[2] & 0x00)
14079 {
14080 case 0x00:
14081 goto op_semantics_115;
14082 break;
14083 }
14084 break;
14085 case 0x29:
14086 GETBYTE ();
14087 switch (op[2] & 0x00)
14088 {
14089 case 0x00:
14090 goto op_semantics_115;
14091 break;
14092 }
14093 break;
14094 case 0x2a:
14095 GETBYTE ();
14096 switch (op[2] & 0x00)
14097 {
14098 case 0x00:
14099 goto op_semantics_115;
14100 break;
14101 }
14102 break;
14103 case 0x2b:
14104 GETBYTE ();
14105 switch (op[2] & 0x00)
14106 {
14107 case 0x00:
14108 goto op_semantics_115;
14109 break;
14110 }
14111 break;
14112 case 0x2c:
14113 GETBYTE ();
14114 switch (op[2] & 0x00)
14115 {
14116 case 0x00:
14117 goto op_semantics_115;
14118 break;
14119 }
14120 break;
14121 case 0x2d:
14122 GETBYTE ();
14123 switch (op[2] & 0x00)
14124 {
14125 case 0x00:
14126 goto op_semantics_115;
14127 break;
14128 }
14129 break;
14130 case 0x2e:
14131 GETBYTE ();
14132 switch (op[2] & 0x00)
14133 {
14134 case 0x00:
14135 goto op_semantics_115;
14136 break;
14137 }
14138 break;
14139 case 0x2f:
14140 GETBYTE ();
14141 switch (op[2] & 0x00)
14142 {
14143 case 0x00:
14144 goto op_semantics_115;
14145 break;
14146 }
14147 break;
14148 case 0x40:
14149 GETBYTE ();
14150 switch (op[2] & 0x00)
14151 {
14152 case 0x00:
14153 op_semantics_116:
14154 {
14155 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
14156 #line 339 "rx-decode.opc"
14157 int sz AU = (op[1] >> 4) & 0x03;
14158 #line 339 "rx-decode.opc"
14159 int isrc AU = op[1] & 0x0f;
14160 #line 339 "rx-decode.opc"
14161 int bsrc AU = (op[2] >> 4) & 0x0f;
14162 #line 339 "rx-decode.opc"
14163 int rdst AU = op[2] & 0x0f;
14164 if (trace)
14165 {
14166 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14167 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
14168 op[0], op[1], op[2]);
14169 printf (" sz = 0x%x,", sz);
14170 printf (" isrc = 0x%x,", isrc);
14171 printf (" bsrc = 0x%x,", bsrc);
14172 printf (" rdst = 0x%x\n", rdst);
14173 }
14174 SYNTAX("mov%s [%1, %2], %0");
14175 #line 339 "rx-decode.opc"
14176 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14177
14178 }
14179 break;
14180 }
14181 break;
14182 case 0x41:
14183 GETBYTE ();
14184 switch (op[2] & 0x00)
14185 {
14186 case 0x00:
14187 goto op_semantics_116;
14188 break;
14189 }
14190 break;
14191 case 0x42:
14192 GETBYTE ();
14193 switch (op[2] & 0x00)
14194 {
14195 case 0x00:
14196 goto op_semantics_116;
14197 break;
14198 }
14199 break;
14200 case 0x43:
14201 GETBYTE ();
14202 switch (op[2] & 0x00)
14203 {
14204 case 0x00:
14205 goto op_semantics_116;
14206 break;
14207 }
14208 break;
14209 case 0x44:
14210 GETBYTE ();
14211 switch (op[2] & 0x00)
14212 {
14213 case 0x00:
14214 goto op_semantics_116;
14215 break;
14216 }
14217 break;
14218 case 0x45:
14219 GETBYTE ();
14220 switch (op[2] & 0x00)
14221 {
14222 case 0x00:
14223 goto op_semantics_116;
14224 break;
14225 }
14226 break;
14227 case 0x46:
14228 GETBYTE ();
14229 switch (op[2] & 0x00)
14230 {
14231 case 0x00:
14232 goto op_semantics_116;
14233 break;
14234 }
14235 break;
14236 case 0x47:
14237 GETBYTE ();
14238 switch (op[2] & 0x00)
14239 {
14240 case 0x00:
14241 goto op_semantics_116;
14242 break;
14243 }
14244 break;
14245 case 0x48:
14246 GETBYTE ();
14247 switch (op[2] & 0x00)
14248 {
14249 case 0x00:
14250 goto op_semantics_116;
14251 break;
14252 }
14253 break;
14254 case 0x49:
14255 GETBYTE ();
14256 switch (op[2] & 0x00)
14257 {
14258 case 0x00:
14259 goto op_semantics_116;
14260 break;
14261 }
14262 break;
14263 case 0x4a:
14264 GETBYTE ();
14265 switch (op[2] & 0x00)
14266 {
14267 case 0x00:
14268 goto op_semantics_116;
14269 break;
14270 }
14271 break;
14272 case 0x4b:
14273 GETBYTE ();
14274 switch (op[2] & 0x00)
14275 {
14276 case 0x00:
14277 goto op_semantics_116;
14278 break;
14279 }
14280 break;
14281 case 0x4c:
14282 GETBYTE ();
14283 switch (op[2] & 0x00)
14284 {
14285 case 0x00:
14286 goto op_semantics_116;
14287 break;
14288 }
14289 break;
14290 case 0x4d:
14291 GETBYTE ();
14292 switch (op[2] & 0x00)
14293 {
14294 case 0x00:
14295 goto op_semantics_116;
14296 break;
14297 }
14298 break;
14299 case 0x4e:
14300 GETBYTE ();
14301 switch (op[2] & 0x00)
14302 {
14303 case 0x00:
14304 goto op_semantics_116;
14305 break;
14306 }
14307 break;
14308 case 0x4f:
14309 GETBYTE ();
14310 switch (op[2] & 0x00)
14311 {
14312 case 0x00:
14313 goto op_semantics_116;
14314 break;
14315 }
14316 break;
14317 case 0x50:
14318 GETBYTE ();
14319 switch (op[2] & 0x00)
14320 {
14321 case 0x00:
14322 goto op_semantics_116;
14323 break;
14324 }
14325 break;
14326 case 0x51:
14327 GETBYTE ();
14328 switch (op[2] & 0x00)
14329 {
14330 case 0x00:
14331 goto op_semantics_116;
14332 break;
14333 }
14334 break;
14335 case 0x52:
14336 GETBYTE ();
14337 switch (op[2] & 0x00)
14338 {
14339 case 0x00:
14340 goto op_semantics_116;
14341 break;
14342 }
14343 break;
14344 case 0x53:
14345 GETBYTE ();
14346 switch (op[2] & 0x00)
14347 {
14348 case 0x00:
14349 goto op_semantics_116;
14350 break;
14351 }
14352 break;
14353 case 0x54:
14354 GETBYTE ();
14355 switch (op[2] & 0x00)
14356 {
14357 case 0x00:
14358 goto op_semantics_116;
14359 break;
14360 }
14361 break;
14362 case 0x55:
14363 GETBYTE ();
14364 switch (op[2] & 0x00)
14365 {
14366 case 0x00:
14367 goto op_semantics_116;
14368 break;
14369 }
14370 break;
14371 case 0x56:
14372 GETBYTE ();
14373 switch (op[2] & 0x00)
14374 {
14375 case 0x00:
14376 goto op_semantics_116;
14377 break;
14378 }
14379 break;
14380 case 0x57:
14381 GETBYTE ();
14382 switch (op[2] & 0x00)
14383 {
14384 case 0x00:
14385 goto op_semantics_116;
14386 break;
14387 }
14388 break;
14389 case 0x58:
14390 GETBYTE ();
14391 switch (op[2] & 0x00)
14392 {
14393 case 0x00:
14394 goto op_semantics_116;
14395 break;
14396 }
14397 break;
14398 case 0x59:
14399 GETBYTE ();
14400 switch (op[2] & 0x00)
14401 {
14402 case 0x00:
14403 goto op_semantics_116;
14404 break;
14405 }
14406 break;
14407 case 0x5a:
14408 GETBYTE ();
14409 switch (op[2] & 0x00)
14410 {
14411 case 0x00:
14412 goto op_semantics_116;
14413 break;
14414 }
14415 break;
14416 case 0x5b:
14417 GETBYTE ();
14418 switch (op[2] & 0x00)
14419 {
14420 case 0x00:
14421 goto op_semantics_116;
14422 break;
14423 }
14424 break;
14425 case 0x5c:
14426 GETBYTE ();
14427 switch (op[2] & 0x00)
14428 {
14429 case 0x00:
14430 goto op_semantics_116;
14431 break;
14432 }
14433 break;
14434 case 0x5d:
14435 GETBYTE ();
14436 switch (op[2] & 0x00)
14437 {
14438 case 0x00:
14439 goto op_semantics_116;
14440 break;
14441 }
14442 break;
14443 case 0x5e:
14444 GETBYTE ();
14445 switch (op[2] & 0x00)
14446 {
14447 case 0x00:
14448 goto op_semantics_116;
14449 break;
14450 }
14451 break;
14452 case 0x5f:
14453 GETBYTE ();
14454 switch (op[2] & 0x00)
14455 {
14456 case 0x00:
14457 goto op_semantics_116;
14458 break;
14459 }
14460 break;
14461 case 0x60:
14462 GETBYTE ();
14463 switch (op[2] & 0x00)
14464 {
14465 case 0x00:
14466 goto op_semantics_116;
14467 break;
14468 }
14469 break;
14470 case 0x61:
14471 GETBYTE ();
14472 switch (op[2] & 0x00)
14473 {
14474 case 0x00:
14475 goto op_semantics_116;
14476 break;
14477 }
14478 break;
14479 case 0x62:
14480 GETBYTE ();
14481 switch (op[2] & 0x00)
14482 {
14483 case 0x00:
14484 goto op_semantics_116;
14485 break;
14486 }
14487 break;
14488 case 0x63:
14489 GETBYTE ();
14490 switch (op[2] & 0x00)
14491 {
14492 case 0x00:
14493 goto op_semantics_116;
14494 break;
14495 }
14496 break;
14497 case 0x64:
14498 GETBYTE ();
14499 switch (op[2] & 0x00)
14500 {
14501 case 0x00:
14502 goto op_semantics_116;
14503 break;
14504 }
14505 break;
14506 case 0x65:
14507 GETBYTE ();
14508 switch (op[2] & 0x00)
14509 {
14510 case 0x00:
14511 goto op_semantics_116;
14512 break;
14513 }
14514 break;
14515 case 0x66:
14516 GETBYTE ();
14517 switch (op[2] & 0x00)
14518 {
14519 case 0x00:
14520 goto op_semantics_116;
14521 break;
14522 }
14523 break;
14524 case 0x67:
14525 GETBYTE ();
14526 switch (op[2] & 0x00)
14527 {
14528 case 0x00:
14529 goto op_semantics_116;
14530 break;
14531 }
14532 break;
14533 case 0x68:
14534 GETBYTE ();
14535 switch (op[2] & 0x00)
14536 {
14537 case 0x00:
14538 goto op_semantics_116;
14539 break;
14540 }
14541 break;
14542 case 0x69:
14543 GETBYTE ();
14544 switch (op[2] & 0x00)
14545 {
14546 case 0x00:
14547 goto op_semantics_116;
14548 break;
14549 }
14550 break;
14551 case 0x6a:
14552 GETBYTE ();
14553 switch (op[2] & 0x00)
14554 {
14555 case 0x00:
14556 goto op_semantics_116;
14557 break;
14558 }
14559 break;
14560 case 0x6b:
14561 GETBYTE ();
14562 switch (op[2] & 0x00)
14563 {
14564 case 0x00:
14565 goto op_semantics_116;
14566 break;
14567 }
14568 break;
14569 case 0x6c:
14570 GETBYTE ();
14571 switch (op[2] & 0x00)
14572 {
14573 case 0x00:
14574 goto op_semantics_116;
14575 break;
14576 }
14577 break;
14578 case 0x6d:
14579 GETBYTE ();
14580 switch (op[2] & 0x00)
14581 {
14582 case 0x00:
14583 goto op_semantics_116;
14584 break;
14585 }
14586 break;
14587 case 0x6e:
14588 GETBYTE ();
14589 switch (op[2] & 0x00)
14590 {
14591 case 0x00:
14592 goto op_semantics_116;
14593 break;
14594 }
14595 break;
14596 case 0x6f:
14597 GETBYTE ();
14598 switch (op[2] & 0x00)
14599 {
14600 case 0x00:
14601 goto op_semantics_116;
14602 break;
14603 }
14604 break;
14605 case 0xc0:
14606 GETBYTE ();
14607 switch (op[2] & 0x00)
14608 {
14609 case 0x00:
14610 op_semantics_117:
14611 {
14612 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
14613 #line 345 "rx-decode.opc"
14614 int sz AU = (op[1] >> 4) & 0x03;
14615 #line 345 "rx-decode.opc"
14616 int isrc AU = op[1] & 0x0f;
14617 #line 345 "rx-decode.opc"
14618 int bsrc AU = (op[2] >> 4) & 0x0f;
14619 #line 345 "rx-decode.opc"
14620 int rdst AU = op[2] & 0x0f;
14621 if (trace)
14622 {
14623 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14624 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
14625 op[0], op[1], op[2]);
14626 printf (" sz = 0x%x,", sz);
14627 printf (" isrc = 0x%x,", isrc);
14628 printf (" bsrc = 0x%x,", bsrc);
14629 printf (" rdst = 0x%x\n", rdst);
14630 }
14631 SYNTAX("movu%s [%1, %2], %0");
14632 #line 345 "rx-decode.opc"
14633 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14634
14635 }
14636 break;
14637 }
14638 break;
14639 case 0xc1:
14640 GETBYTE ();
14641 switch (op[2] & 0x00)
14642 {
14643 case 0x00:
14644 goto op_semantics_117;
14645 break;
14646 }
14647 break;
14648 case 0xc2:
14649 GETBYTE ();
14650 switch (op[2] & 0x00)
14651 {
14652 case 0x00:
14653 goto op_semantics_117;
14654 break;
14655 }
14656 break;
14657 case 0xc3:
14658 GETBYTE ();
14659 switch (op[2] & 0x00)
14660 {
14661 case 0x00:
14662 goto op_semantics_117;
14663 break;
14664 }
14665 break;
14666 case 0xc4:
14667 GETBYTE ();
14668 switch (op[2] & 0x00)
14669 {
14670 case 0x00:
14671 goto op_semantics_117;
14672 break;
14673 }
14674 break;
14675 case 0xc5:
14676 GETBYTE ();
14677 switch (op[2] & 0x00)
14678 {
14679 case 0x00:
14680 goto op_semantics_117;
14681 break;
14682 }
14683 break;
14684 case 0xc6:
14685 GETBYTE ();
14686 switch (op[2] & 0x00)
14687 {
14688 case 0x00:
14689 goto op_semantics_117;
14690 break;
14691 }
14692 break;
14693 case 0xc7:
14694 GETBYTE ();
14695 switch (op[2] & 0x00)
14696 {
14697 case 0x00:
14698 goto op_semantics_117;
14699 break;
14700 }
14701 break;
14702 case 0xc8:
14703 GETBYTE ();
14704 switch (op[2] & 0x00)
14705 {
14706 case 0x00:
14707 goto op_semantics_117;
14708 break;
14709 }
14710 break;
14711 case 0xc9:
14712 GETBYTE ();
14713 switch (op[2] & 0x00)
14714 {
14715 case 0x00:
14716 goto op_semantics_117;
14717 break;
14718 }
14719 break;
14720 case 0xca:
14721 GETBYTE ();
14722 switch (op[2] & 0x00)
14723 {
14724 case 0x00:
14725 goto op_semantics_117;
14726 break;
14727 }
14728 break;
14729 case 0xcb:
14730 GETBYTE ();
14731 switch (op[2] & 0x00)
14732 {
14733 case 0x00:
14734 goto op_semantics_117;
14735 break;
14736 }
14737 break;
14738 case 0xcc:
14739 GETBYTE ();
14740 switch (op[2] & 0x00)
14741 {
14742 case 0x00:
14743 goto op_semantics_117;
14744 break;
14745 }
14746 break;
14747 case 0xcd:
14748 GETBYTE ();
14749 switch (op[2] & 0x00)
14750 {
14751 case 0x00:
14752 goto op_semantics_117;
14753 break;
14754 }
14755 break;
14756 case 0xce:
14757 GETBYTE ();
14758 switch (op[2] & 0x00)
14759 {
14760 case 0x00:
14761 goto op_semantics_117;
14762 break;
14763 }
14764 break;
14765 case 0xcf:
14766 GETBYTE ();
14767 switch (op[2] & 0x00)
14768 {
14769 case 0x00:
14770 goto op_semantics_117;
14771 break;
14772 }
14773 break;
14774 case 0xd0:
14775 GETBYTE ();
14776 switch (op[2] & 0x00)
14777 {
14778 case 0x00:
14779 goto op_semantics_117;
14780 break;
14781 }
14782 break;
14783 case 0xd1:
14784 GETBYTE ();
14785 switch (op[2] & 0x00)
14786 {
14787 case 0x00:
14788 goto op_semantics_117;
14789 break;
14790 }
14791 break;
14792 case 0xd2:
14793 GETBYTE ();
14794 switch (op[2] & 0x00)
14795 {
14796 case 0x00:
14797 goto op_semantics_117;
14798 break;
14799 }
14800 break;
14801 case 0xd3:
14802 GETBYTE ();
14803 switch (op[2] & 0x00)
14804 {
14805 case 0x00:
14806 goto op_semantics_117;
14807 break;
14808 }
14809 break;
14810 case 0xd4:
14811 GETBYTE ();
14812 switch (op[2] & 0x00)
14813 {
14814 case 0x00:
14815 goto op_semantics_117;
14816 break;
14817 }
14818 break;
14819 case 0xd5:
14820 GETBYTE ();
14821 switch (op[2] & 0x00)
14822 {
14823 case 0x00:
14824 goto op_semantics_117;
14825 break;
14826 }
14827 break;
14828 case 0xd6:
14829 GETBYTE ();
14830 switch (op[2] & 0x00)
14831 {
14832 case 0x00:
14833 goto op_semantics_117;
14834 break;
14835 }
14836 break;
14837 case 0xd7:
14838 GETBYTE ();
14839 switch (op[2] & 0x00)
14840 {
14841 case 0x00:
14842 goto op_semantics_117;
14843 break;
14844 }
14845 break;
14846 case 0xd8:
14847 GETBYTE ();
14848 switch (op[2] & 0x00)
14849 {
14850 case 0x00:
14851 goto op_semantics_117;
14852 break;
14853 }
14854 break;
14855 case 0xd9:
14856 GETBYTE ();
14857 switch (op[2] & 0x00)
14858 {
14859 case 0x00:
14860 goto op_semantics_117;
14861 break;
14862 }
14863 break;
14864 case 0xda:
14865 GETBYTE ();
14866 switch (op[2] & 0x00)
14867 {
14868 case 0x00:
14869 goto op_semantics_117;
14870 break;
14871 }
14872 break;
14873 case 0xdb:
14874 GETBYTE ();
14875 switch (op[2] & 0x00)
14876 {
14877 case 0x00:
14878 goto op_semantics_117;
14879 break;
14880 }
14881 break;
14882 case 0xdc:
14883 GETBYTE ();
14884 switch (op[2] & 0x00)
14885 {
14886 case 0x00:
14887 goto op_semantics_117;
14888 break;
14889 }
14890 break;
14891 case 0xdd:
14892 GETBYTE ();
14893 switch (op[2] & 0x00)
14894 {
14895 case 0x00:
14896 goto op_semantics_117;
14897 break;
14898 }
14899 break;
14900 case 0xde:
14901 GETBYTE ();
14902 switch (op[2] & 0x00)
14903 {
14904 case 0x00:
14905 goto op_semantics_117;
14906 break;
14907 }
14908 break;
14909 case 0xdf:
14910 GETBYTE ();
14911 switch (op[2] & 0x00)
14912 {
14913 case 0x00:
14914 goto op_semantics_117;
14915 break;
14916 }
14917 break;
14918 case 0xe0:
14919 GETBYTE ();
14920 switch (op[2] & 0x00)
14921 {
14922 case 0x00:
14923 goto op_semantics_117;
14924 break;
14925 }
14926 break;
14927 case 0xe1:
14928 GETBYTE ();
14929 switch (op[2] & 0x00)
14930 {
14931 case 0x00:
14932 goto op_semantics_117;
14933 break;
14934 }
14935 break;
14936 case 0xe2:
14937 GETBYTE ();
14938 switch (op[2] & 0x00)
14939 {
14940 case 0x00:
14941 goto op_semantics_117;
14942 break;
14943 }
14944 break;
14945 case 0xe3:
14946 GETBYTE ();
14947 switch (op[2] & 0x00)
14948 {
14949 case 0x00:
14950 goto op_semantics_117;
14951 break;
14952 }
14953 break;
14954 case 0xe4:
14955 GETBYTE ();
14956 switch (op[2] & 0x00)
14957 {
14958 case 0x00:
14959 goto op_semantics_117;
14960 break;
14961 }
14962 break;
14963 case 0xe5:
14964 GETBYTE ();
14965 switch (op[2] & 0x00)
14966 {
14967 case 0x00:
14968 goto op_semantics_117;
14969 break;
14970 }
14971 break;
14972 case 0xe6:
14973 GETBYTE ();
14974 switch (op[2] & 0x00)
14975 {
14976 case 0x00:
14977 goto op_semantics_117;
14978 break;
14979 }
14980 break;
14981 case 0xe7:
14982 GETBYTE ();
14983 switch (op[2] & 0x00)
14984 {
14985 case 0x00:
14986 goto op_semantics_117;
14987 break;
14988 }
14989 break;
14990 case 0xe8:
14991 GETBYTE ();
14992 switch (op[2] & 0x00)
14993 {
14994 case 0x00:
14995 goto op_semantics_117;
14996 break;
14997 }
14998 break;
14999 case 0xe9:
15000 GETBYTE ();
15001 switch (op[2] & 0x00)
15002 {
15003 case 0x00:
15004 goto op_semantics_117;
15005 break;
15006 }
15007 break;
15008 case 0xea:
15009 GETBYTE ();
15010 switch (op[2] & 0x00)
15011 {
15012 case 0x00:
15013 goto op_semantics_117;
15014 break;
15015 }
15016 break;
15017 case 0xeb:
15018 GETBYTE ();
15019 switch (op[2] & 0x00)
15020 {
15021 case 0x00:
15022 goto op_semantics_117;
15023 break;
15024 }
15025 break;
15026 case 0xec:
15027 GETBYTE ();
15028 switch (op[2] & 0x00)
15029 {
15030 case 0x00:
15031 goto op_semantics_117;
15032 break;
15033 }
15034 break;
15035 case 0xed:
15036 GETBYTE ();
15037 switch (op[2] & 0x00)
15038 {
15039 case 0x00:
15040 goto op_semantics_117;
15041 break;
15042 }
15043 break;
15044 case 0xee:
15045 GETBYTE ();
15046 switch (op[2] & 0x00)
15047 {
15048 case 0x00:
15049 goto op_semantics_117;
15050 break;
15051 }
15052 break;
15053 case 0xef:
15054 GETBYTE ();
15055 switch (op[2] & 0x00)
15056 {
15057 case 0x00:
15058 goto op_semantics_117;
15059 break;
15060 }
15061 break;
15062 default: UNSUPPORTED(); break;
15063 }
15064 break;
15065 case 0xff:
15066 GETBYTE ();
15067 switch (op[1] & 0xff)
15068 {
15069 case 0x00:
15070 GETBYTE ();
15071 switch (op[2] & 0x00)
15072 {
15073 case 0x00:
15074 op_semantics_118:
15075 {
15076 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
15077 #line 549 "rx-decode.opc"
15078 int rdst AU = op[1] & 0x0f;
15079 #line 549 "rx-decode.opc"
15080 int srca AU = (op[2] >> 4) & 0x0f;
15081 #line 549 "rx-decode.opc"
15082 int srcb AU = op[2] & 0x0f;
15083 if (trace)
15084 {
15085 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15086 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
15087 op[0], op[1], op[2]);
15088 printf (" rdst = 0x%x,", rdst);
15089 printf (" srca = 0x%x,", srca);
15090 printf (" srcb = 0x%x\n", srcb);
15091 }
15092 SYNTAX("sub %2, %1, %0");
15093 #line 549 "rx-decode.opc"
15094 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15095
15096 /*----------------------------------------------------------------------*/
15097 /* SBB */
15098
15099 }
15100 break;
15101 }
15102 break;
15103 case 0x01:
15104 GETBYTE ();
15105 switch (op[2] & 0x00)
15106 {
15107 case 0x00:
15108 goto op_semantics_118;
15109 break;
15110 }
15111 break;
15112 case 0x02:
15113 GETBYTE ();
15114 switch (op[2] & 0x00)
15115 {
15116 case 0x00:
15117 goto op_semantics_118;
15118 break;
15119 }
15120 break;
15121 case 0x03:
15122 GETBYTE ();
15123 switch (op[2] & 0x00)
15124 {
15125 case 0x00:
15126 goto op_semantics_118;
15127 break;
15128 }
15129 break;
15130 case 0x04:
15131 GETBYTE ();
15132 switch (op[2] & 0x00)
15133 {
15134 case 0x00:
15135 goto op_semantics_118;
15136 break;
15137 }
15138 break;
15139 case 0x05:
15140 GETBYTE ();
15141 switch (op[2] & 0x00)
15142 {
15143 case 0x00:
15144 goto op_semantics_118;
15145 break;
15146 }
15147 break;
15148 case 0x06:
15149 GETBYTE ();
15150 switch (op[2] & 0x00)
15151 {
15152 case 0x00:
15153 goto op_semantics_118;
15154 break;
15155 }
15156 break;
15157 case 0x07:
15158 GETBYTE ();
15159 switch (op[2] & 0x00)
15160 {
15161 case 0x00:
15162 goto op_semantics_118;
15163 break;
15164 }
15165 break;
15166 case 0x08:
15167 GETBYTE ();
15168 switch (op[2] & 0x00)
15169 {
15170 case 0x00:
15171 goto op_semantics_118;
15172 break;
15173 }
15174 break;
15175 case 0x09:
15176 GETBYTE ();
15177 switch (op[2] & 0x00)
15178 {
15179 case 0x00:
15180 goto op_semantics_118;
15181 break;
15182 }
15183 break;
15184 case 0x0a:
15185 GETBYTE ();
15186 switch (op[2] & 0x00)
15187 {
15188 case 0x00:
15189 goto op_semantics_118;
15190 break;
15191 }
15192 break;
15193 case 0x0b:
15194 GETBYTE ();
15195 switch (op[2] & 0x00)
15196 {
15197 case 0x00:
15198 goto op_semantics_118;
15199 break;
15200 }
15201 break;
15202 case 0x0c:
15203 GETBYTE ();
15204 switch (op[2] & 0x00)
15205 {
15206 case 0x00:
15207 goto op_semantics_118;
15208 break;
15209 }
15210 break;
15211 case 0x0d:
15212 GETBYTE ();
15213 switch (op[2] & 0x00)
15214 {
15215 case 0x00:
15216 goto op_semantics_118;
15217 break;
15218 }
15219 break;
15220 case 0x0e:
15221 GETBYTE ();
15222 switch (op[2] & 0x00)
15223 {
15224 case 0x00:
15225 goto op_semantics_118;
15226 break;
15227 }
15228 break;
15229 case 0x0f:
15230 GETBYTE ();
15231 switch (op[2] & 0x00)
15232 {
15233 case 0x00:
15234 goto op_semantics_118;
15235 break;
15236 }
15237 break;
15238 case 0x20:
15239 GETBYTE ();
15240 switch (op[2] & 0x00)
15241 {
15242 case 0x00:
15243 op_semantics_119:
15244 {
15245 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
15246 #line 516 "rx-decode.opc"
15247 int rdst AU = op[1] & 0x0f;
15248 #line 516 "rx-decode.opc"
15249 int srca AU = (op[2] >> 4) & 0x0f;
15250 #line 516 "rx-decode.opc"
15251 int srcb AU = op[2] & 0x0f;
15252 if (trace)
15253 {
15254 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15255 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
15256 op[0], op[1], op[2]);
15257 printf (" rdst = 0x%x,", rdst);
15258 printf (" srca = 0x%x,", srca);
15259 printf (" srcb = 0x%x\n", srcb);
15260 }
15261 SYNTAX("add %2, %1, %0");
15262 #line 516 "rx-decode.opc"
15263 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15264
15265 /*----------------------------------------------------------------------*/
15266 /* CMP */
15267
15268 }
15269 break;
15270 }
15271 break;
15272 case 0x21:
15273 GETBYTE ();
15274 switch (op[2] & 0x00)
15275 {
15276 case 0x00:
15277 goto op_semantics_119;
15278 break;
15279 }
15280 break;
15281 case 0x22:
15282 GETBYTE ();
15283 switch (op[2] & 0x00)
15284 {
15285 case 0x00:
15286 goto op_semantics_119;
15287 break;
15288 }
15289 break;
15290 case 0x23:
15291 GETBYTE ();
15292 switch (op[2] & 0x00)
15293 {
15294 case 0x00:
15295 goto op_semantics_119;
15296 break;
15297 }
15298 break;
15299 case 0x24:
15300 GETBYTE ();
15301 switch (op[2] & 0x00)
15302 {
15303 case 0x00:
15304 goto op_semantics_119;
15305 break;
15306 }
15307 break;
15308 case 0x25:
15309 GETBYTE ();
15310 switch (op[2] & 0x00)
15311 {
15312 case 0x00:
15313 goto op_semantics_119;
15314 break;
15315 }
15316 break;
15317 case 0x26:
15318 GETBYTE ();
15319 switch (op[2] & 0x00)
15320 {
15321 case 0x00:
15322 goto op_semantics_119;
15323 break;
15324 }
15325 break;
15326 case 0x27:
15327 GETBYTE ();
15328 switch (op[2] & 0x00)
15329 {
15330 case 0x00:
15331 goto op_semantics_119;
15332 break;
15333 }
15334 break;
15335 case 0x28:
15336 GETBYTE ();
15337 switch (op[2] & 0x00)
15338 {
15339 case 0x00:
15340 goto op_semantics_119;
15341 break;
15342 }
15343 break;
15344 case 0x29:
15345 GETBYTE ();
15346 switch (op[2] & 0x00)
15347 {
15348 case 0x00:
15349 goto op_semantics_119;
15350 break;
15351 }
15352 break;
15353 case 0x2a:
15354 GETBYTE ();
15355 switch (op[2] & 0x00)
15356 {
15357 case 0x00:
15358 goto op_semantics_119;
15359 break;
15360 }
15361 break;
15362 case 0x2b:
15363 GETBYTE ();
15364 switch (op[2] & 0x00)
15365 {
15366 case 0x00:
15367 goto op_semantics_119;
15368 break;
15369 }
15370 break;
15371 case 0x2c:
15372 GETBYTE ();
15373 switch (op[2] & 0x00)
15374 {
15375 case 0x00:
15376 goto op_semantics_119;
15377 break;
15378 }
15379 break;
15380 case 0x2d:
15381 GETBYTE ();
15382 switch (op[2] & 0x00)
15383 {
15384 case 0x00:
15385 goto op_semantics_119;
15386 break;
15387 }
15388 break;
15389 case 0x2e:
15390 GETBYTE ();
15391 switch (op[2] & 0x00)
15392 {
15393 case 0x00:
15394 goto op_semantics_119;
15395 break;
15396 }
15397 break;
15398 case 0x2f:
15399 GETBYTE ();
15400 switch (op[2] & 0x00)
15401 {
15402 case 0x00:
15403 goto op_semantics_119;
15404 break;
15405 }
15406 break;
15407 case 0x30:
15408 GETBYTE ();
15409 switch (op[2] & 0x00)
15410 {
15411 case 0x00:
15412 op_semantics_120:
15413 {
15414 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
15415 #line 656 "rx-decode.opc"
15416 int rdst AU = op[1] & 0x0f;
15417 #line 656 "rx-decode.opc"
15418 int srca AU = (op[2] >> 4) & 0x0f;
15419 #line 656 "rx-decode.opc"
15420 int srcb AU = op[2] & 0x0f;
15421 if (trace)
15422 {
15423 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15424 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
15425 op[0], op[1], op[2]);
15426 printf (" rdst = 0x%x,", rdst);
15427 printf (" srca = 0x%x,", srca);
15428 printf (" srcb = 0x%x\n", srcb);
15429 }
15430 SYNTAX("mul %2, %1, %0");
15431 #line 656 "rx-decode.opc"
15432 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15433
15434 /*----------------------------------------------------------------------*/
15435 /* EMUL */
15436
15437 }
15438 break;
15439 }
15440 break;
15441 case 0x31:
15442 GETBYTE ();
15443 switch (op[2] & 0x00)
15444 {
15445 case 0x00:
15446 goto op_semantics_120;
15447 break;
15448 }
15449 break;
15450 case 0x32:
15451 GETBYTE ();
15452 switch (op[2] & 0x00)
15453 {
15454 case 0x00:
15455 goto op_semantics_120;
15456 break;
15457 }
15458 break;
15459 case 0x33:
15460 GETBYTE ();
15461 switch (op[2] & 0x00)
15462 {
15463 case 0x00:
15464 goto op_semantics_120;
15465 break;
15466 }
15467 break;
15468 case 0x34:
15469 GETBYTE ();
15470 switch (op[2] & 0x00)
15471 {
15472 case 0x00:
15473 goto op_semantics_120;
15474 break;
15475 }
15476 break;
15477 case 0x35:
15478 GETBYTE ();
15479 switch (op[2] & 0x00)
15480 {
15481 case 0x00:
15482 goto op_semantics_120;
15483 break;
15484 }
15485 break;
15486 case 0x36:
15487 GETBYTE ();
15488 switch (op[2] & 0x00)
15489 {
15490 case 0x00:
15491 goto op_semantics_120;
15492 break;
15493 }
15494 break;
15495 case 0x37:
15496 GETBYTE ();
15497 switch (op[2] & 0x00)
15498 {
15499 case 0x00:
15500 goto op_semantics_120;
15501 break;
15502 }
15503 break;
15504 case 0x38:
15505 GETBYTE ();
15506 switch (op[2] & 0x00)
15507 {
15508 case 0x00:
15509 goto op_semantics_120;
15510 break;
15511 }
15512 break;
15513 case 0x39:
15514 GETBYTE ();
15515 switch (op[2] & 0x00)
15516 {
15517 case 0x00:
15518 goto op_semantics_120;
15519 break;
15520 }
15521 break;
15522 case 0x3a:
15523 GETBYTE ();
15524 switch (op[2] & 0x00)
15525 {
15526 case 0x00:
15527 goto op_semantics_120;
15528 break;
15529 }
15530 break;
15531 case 0x3b:
15532 GETBYTE ();
15533 switch (op[2] & 0x00)
15534 {
15535 case 0x00:
15536 goto op_semantics_120;
15537 break;
15538 }
15539 break;
15540 case 0x3c:
15541 GETBYTE ();
15542 switch (op[2] & 0x00)
15543 {
15544 case 0x00:
15545 goto op_semantics_120;
15546 break;
15547 }
15548 break;
15549 case 0x3d:
15550 GETBYTE ();
15551 switch (op[2] & 0x00)
15552 {
15553 case 0x00:
15554 goto op_semantics_120;
15555 break;
15556 }
15557 break;
15558 case 0x3e:
15559 GETBYTE ();
15560 switch (op[2] & 0x00)
15561 {
15562 case 0x00:
15563 goto op_semantics_120;
15564 break;
15565 }
15566 break;
15567 case 0x3f:
15568 GETBYTE ();
15569 switch (op[2] & 0x00)
15570 {
15571 case 0x00:
15572 goto op_semantics_120;
15573 break;
15574 }
15575 break;
15576 case 0x40:
15577 GETBYTE ();
15578 switch (op[2] & 0x00)
15579 {
15580 case 0x00:
15581 op_semantics_121:
15582 {
15583 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
15584 #line 426 "rx-decode.opc"
15585 int rdst AU = op[1] & 0x0f;
15586 #line 426 "rx-decode.opc"
15587 int srca AU = (op[2] >> 4) & 0x0f;
15588 #line 426 "rx-decode.opc"
15589 int srcb AU = op[2] & 0x0f;
15590 if (trace)
15591 {
15592 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15593 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
15594 op[0], op[1], op[2]);
15595 printf (" rdst = 0x%x,", rdst);
15596 printf (" srca = 0x%x,", srca);
15597 printf (" srcb = 0x%x\n", srcb);
15598 }
15599 SYNTAX("and %2, %1, %0");
15600 #line 426 "rx-decode.opc"
15601 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15602
15603 /*----------------------------------------------------------------------*/
15604 /* OR */
15605
15606 }
15607 break;
15608 }
15609 break;
15610 case 0x41:
15611 GETBYTE ();
15612 switch (op[2] & 0x00)
15613 {
15614 case 0x00:
15615 goto op_semantics_121;
15616 break;
15617 }
15618 break;
15619 case 0x42:
15620 GETBYTE ();
15621 switch (op[2] & 0x00)
15622 {
15623 case 0x00:
15624 goto op_semantics_121;
15625 break;
15626 }
15627 break;
15628 case 0x43:
15629 GETBYTE ();
15630 switch (op[2] & 0x00)
15631 {
15632 case 0x00:
15633 goto op_semantics_121;
15634 break;
15635 }
15636 break;
15637 case 0x44:
15638 GETBYTE ();
15639 switch (op[2] & 0x00)
15640 {
15641 case 0x00:
15642 goto op_semantics_121;
15643 break;
15644 }
15645 break;
15646 case 0x45:
15647 GETBYTE ();
15648 switch (op[2] & 0x00)
15649 {
15650 case 0x00:
15651 goto op_semantics_121;
15652 break;
15653 }
15654 break;
15655 case 0x46:
15656 GETBYTE ();
15657 switch (op[2] & 0x00)
15658 {
15659 case 0x00:
15660 goto op_semantics_121;
15661 break;
15662 }
15663 break;
15664 case 0x47:
15665 GETBYTE ();
15666 switch (op[2] & 0x00)
15667 {
15668 case 0x00:
15669 goto op_semantics_121;
15670 break;
15671 }
15672 break;
15673 case 0x48:
15674 GETBYTE ();
15675 switch (op[2] & 0x00)
15676 {
15677 case 0x00:
15678 goto op_semantics_121;
15679 break;
15680 }
15681 break;
15682 case 0x49:
15683 GETBYTE ();
15684 switch (op[2] & 0x00)
15685 {
15686 case 0x00:
15687 goto op_semantics_121;
15688 break;
15689 }
15690 break;
15691 case 0x4a:
15692 GETBYTE ();
15693 switch (op[2] & 0x00)
15694 {
15695 case 0x00:
15696 goto op_semantics_121;
15697 break;
15698 }
15699 break;
15700 case 0x4b:
15701 GETBYTE ();
15702 switch (op[2] & 0x00)
15703 {
15704 case 0x00:
15705 goto op_semantics_121;
15706 break;
15707 }
15708 break;
15709 case 0x4c:
15710 GETBYTE ();
15711 switch (op[2] & 0x00)
15712 {
15713 case 0x00:
15714 goto op_semantics_121;
15715 break;
15716 }
15717 break;
15718 case 0x4d:
15719 GETBYTE ();
15720 switch (op[2] & 0x00)
15721 {
15722 case 0x00:
15723 goto op_semantics_121;
15724 break;
15725 }
15726 break;
15727 case 0x4e:
15728 GETBYTE ();
15729 switch (op[2] & 0x00)
15730 {
15731 case 0x00:
15732 goto op_semantics_121;
15733 break;
15734 }
15735 break;
15736 case 0x4f:
15737 GETBYTE ();
15738 switch (op[2] & 0x00)
15739 {
15740 case 0x00:
15741 goto op_semantics_121;
15742 break;
15743 }
15744 break;
15745 case 0x50:
15746 GETBYTE ();
15747 switch (op[2] & 0x00)
15748 {
15749 case 0x00:
15750 op_semantics_122:
15751 {
15752 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
15753 #line 444 "rx-decode.opc"
15754 int rdst AU = op[1] & 0x0f;
15755 #line 444 "rx-decode.opc"
15756 int srca AU = (op[2] >> 4) & 0x0f;
15757 #line 444 "rx-decode.opc"
15758 int srcb AU = op[2] & 0x0f;
15759 if (trace)
15760 {
15761 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15762 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
15763 op[0], op[1], op[2]);
15764 printf (" rdst = 0x%x,", rdst);
15765 printf (" srca = 0x%x,", srca);
15766 printf (" srcb = 0x%x\n", srcb);
15767 }
15768 SYNTAX("or %2, %1, %0");
15769 #line 444 "rx-decode.opc"
15770 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15771
15772 /*----------------------------------------------------------------------*/
15773 /* XOR */
15774
15775 }
15776 break;
15777 }
15778 break;
15779 case 0x51:
15780 GETBYTE ();
15781 switch (op[2] & 0x00)
15782 {
15783 case 0x00:
15784 goto op_semantics_122;
15785 break;
15786 }
15787 break;
15788 case 0x52:
15789 GETBYTE ();
15790 switch (op[2] & 0x00)
15791 {
15792 case 0x00:
15793 goto op_semantics_122;
15794 break;
15795 }
15796 break;
15797 case 0x53:
15798 GETBYTE ();
15799 switch (op[2] & 0x00)
15800 {
15801 case 0x00:
15802 goto op_semantics_122;
15803 break;
15804 }
15805 break;
15806 case 0x54:
15807 GETBYTE ();
15808 switch (op[2] & 0x00)
15809 {
15810 case 0x00:
15811 goto op_semantics_122;
15812 break;
15813 }
15814 break;
15815 case 0x55:
15816 GETBYTE ();
15817 switch (op[2] & 0x00)
15818 {
15819 case 0x00:
15820 goto op_semantics_122;
15821 break;
15822 }
15823 break;
15824 case 0x56:
15825 GETBYTE ();
15826 switch (op[2] & 0x00)
15827 {
15828 case 0x00:
15829 goto op_semantics_122;
15830 break;
15831 }
15832 break;
15833 case 0x57:
15834 GETBYTE ();
15835 switch (op[2] & 0x00)
15836 {
15837 case 0x00:
15838 goto op_semantics_122;
15839 break;
15840 }
15841 break;
15842 case 0x58:
15843 GETBYTE ();
15844 switch (op[2] & 0x00)
15845 {
15846 case 0x00:
15847 goto op_semantics_122;
15848 break;
15849 }
15850 break;
15851 case 0x59:
15852 GETBYTE ();
15853 switch (op[2] & 0x00)
15854 {
15855 case 0x00:
15856 goto op_semantics_122;
15857 break;
15858 }
15859 break;
15860 case 0x5a:
15861 GETBYTE ();
15862 switch (op[2] & 0x00)
15863 {
15864 case 0x00:
15865 goto op_semantics_122;
15866 break;
15867 }
15868 break;
15869 case 0x5b:
15870 GETBYTE ();
15871 switch (op[2] & 0x00)
15872 {
15873 case 0x00:
15874 goto op_semantics_122;
15875 break;
15876 }
15877 break;
15878 case 0x5c:
15879 GETBYTE ();
15880 switch (op[2] & 0x00)
15881 {
15882 case 0x00:
15883 goto op_semantics_122;
15884 break;
15885 }
15886 break;
15887 case 0x5d:
15888 GETBYTE ();
15889 switch (op[2] & 0x00)
15890 {
15891 case 0x00:
15892 goto op_semantics_122;
15893 break;
15894 }
15895 break;
15896 case 0x5e:
15897 GETBYTE ();
15898 switch (op[2] & 0x00)
15899 {
15900 case 0x00:
15901 goto op_semantics_122;
15902 break;
15903 }
15904 break;
15905 case 0x5f:
15906 GETBYTE ();
15907 switch (op[2] & 0x00)
15908 {
15909 case 0x00:
15910 goto op_semantics_122;
15911 break;
15912 }
15913 break;
15914 case 0x80:
15915 GETBYTE ();
15916 switch (op[2] & 0x00)
15917 {
15918 case 0x00:
15919 op_semantics_123:
15920 {
15921 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */
15922 #line 1104 "rx-decode.opc"
15923 int rdst AU = op[1] & 0x0f;
15924 #line 1104 "rx-decode.opc"
15925 int srca AU = (op[2] >> 4) & 0x0f;
15926 #line 1104 "rx-decode.opc"
15927 int srcb AU = op[2] & 0x0f;
15928 if (trace)
15929 {
15930 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
15931 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */",
15932 op[0], op[1], op[2]);
15933 printf (" rdst = 0x%x,", rdst);
15934 printf (" srca = 0x%x,", srca);
15935 printf (" srcb = 0x%x\n", srcb);
15936 }
15937 SYNTAX("fsub %2, %1, %0");
15938 #line 1104 "rx-decode.opc"
15939 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15940
15941 }
15942 break;
15943 }
15944 break;
15945 case 0x81:
15946 GETBYTE ();
15947 switch (op[2] & 0x00)
15948 {
15949 case 0x00:
15950 goto op_semantics_123;
15951 break;
15952 }
15953 break;
15954 case 0x82:
15955 GETBYTE ();
15956 switch (op[2] & 0x00)
15957 {
15958 case 0x00:
15959 goto op_semantics_123;
15960 break;
15961 }
15962 break;
15963 case 0x83:
15964 GETBYTE ();
15965 switch (op[2] & 0x00)
15966 {
15967 case 0x00:
15968 goto op_semantics_123;
15969 break;
15970 }
15971 break;
15972 case 0x84:
15973 GETBYTE ();
15974 switch (op[2] & 0x00)
15975 {
15976 case 0x00:
15977 goto op_semantics_123;
15978 break;
15979 }
15980 break;
15981 case 0x85:
15982 GETBYTE ();
15983 switch (op[2] & 0x00)
15984 {
15985 case 0x00:
15986 goto op_semantics_123;
15987 break;
15988 }
15989 break;
15990 case 0x86:
15991 GETBYTE ();
15992 switch (op[2] & 0x00)
15993 {
15994 case 0x00:
15995 goto op_semantics_123;
15996 break;
15997 }
15998 break;
15999 case 0x87:
16000 GETBYTE ();
16001 switch (op[2] & 0x00)
16002 {
16003 case 0x00:
16004 goto op_semantics_123;
16005 break;
16006 }
16007 break;
16008 case 0x88:
16009 GETBYTE ();
16010 switch (op[2] & 0x00)
16011 {
16012 case 0x00:
16013 goto op_semantics_123;
16014 break;
16015 }
16016 break;
16017 case 0x89:
16018 GETBYTE ();
16019 switch (op[2] & 0x00)
16020 {
16021 case 0x00:
16022 goto op_semantics_123;
16023 break;
16024 }
16025 break;
16026 case 0x8a:
16027 GETBYTE ();
16028 switch (op[2] & 0x00)
16029 {
16030 case 0x00:
16031 goto op_semantics_123;
16032 break;
16033 }
16034 break;
16035 case 0x8b:
16036 GETBYTE ();
16037 switch (op[2] & 0x00)
16038 {
16039 case 0x00:
16040 goto op_semantics_123;
16041 break;
16042 }
16043 break;
16044 case 0x8c:
16045 GETBYTE ();
16046 switch (op[2] & 0x00)
16047 {
16048 case 0x00:
16049 goto op_semantics_123;
16050 break;
16051 }
16052 break;
16053 case 0x8d:
16054 GETBYTE ();
16055 switch (op[2] & 0x00)
16056 {
16057 case 0x00:
16058 goto op_semantics_123;
16059 break;
16060 }
16061 break;
16062 case 0x8e:
16063 GETBYTE ();
16064 switch (op[2] & 0x00)
16065 {
16066 case 0x00:
16067 goto op_semantics_123;
16068 break;
16069 }
16070 break;
16071 case 0x8f:
16072 GETBYTE ();
16073 switch (op[2] & 0x00)
16074 {
16075 case 0x00:
16076 goto op_semantics_123;
16077 break;
16078 }
16079 break;
16080 case 0xa0:
16081 GETBYTE ();
16082 switch (op[2] & 0x00)
16083 {
16084 case 0x00:
16085 op_semantics_124:
16086 {
16087 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */
16088 #line 1101 "rx-decode.opc"
16089 int rdst AU = op[1] & 0x0f;
16090 #line 1101 "rx-decode.opc"
16091 int srca AU = (op[2] >> 4) & 0x0f;
16092 #line 1101 "rx-decode.opc"
16093 int srcb AU = op[2] & 0x0f;
16094 if (trace)
16095 {
16096 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16097 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */",
16098 op[0], op[1], op[2]);
16099 printf (" rdst = 0x%x,", rdst);
16100 printf (" srca = 0x%x,", srca);
16101 printf (" srcb = 0x%x\n", srcb);
16102 }
16103 SYNTAX("fadd %2, %1, %0");
16104 #line 1101 "rx-decode.opc"
16105 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16106
16107 }
16108 break;
16109 }
16110 break;
16111 case 0xa1:
16112 GETBYTE ();
16113 switch (op[2] & 0x00)
16114 {
16115 case 0x00:
16116 goto op_semantics_124;
16117 break;
16118 }
16119 break;
16120 case 0xa2:
16121 GETBYTE ();
16122 switch (op[2] & 0x00)
16123 {
16124 case 0x00:
16125 goto op_semantics_124;
16126 break;
16127 }
16128 break;
16129 case 0xa3:
16130 GETBYTE ();
16131 switch (op[2] & 0x00)
16132 {
16133 case 0x00:
16134 goto op_semantics_124;
16135 break;
16136 }
16137 break;
16138 case 0xa4:
16139 GETBYTE ();
16140 switch (op[2] & 0x00)
16141 {
16142 case 0x00:
16143 goto op_semantics_124;
16144 break;
16145 }
16146 break;
16147 case 0xa5:
16148 GETBYTE ();
16149 switch (op[2] & 0x00)
16150 {
16151 case 0x00:
16152 goto op_semantics_124;
16153 break;
16154 }
16155 break;
16156 case 0xa6:
16157 GETBYTE ();
16158 switch (op[2] & 0x00)
16159 {
16160 case 0x00:
16161 goto op_semantics_124;
16162 break;
16163 }
16164 break;
16165 case 0xa7:
16166 GETBYTE ();
16167 switch (op[2] & 0x00)
16168 {
16169 case 0x00:
16170 goto op_semantics_124;
16171 break;
16172 }
16173 break;
16174 case 0xa8:
16175 GETBYTE ();
16176 switch (op[2] & 0x00)
16177 {
16178 case 0x00:
16179 goto op_semantics_124;
16180 break;
16181 }
16182 break;
16183 case 0xa9:
16184 GETBYTE ();
16185 switch (op[2] & 0x00)
16186 {
16187 case 0x00:
16188 goto op_semantics_124;
16189 break;
16190 }
16191 break;
16192 case 0xaa:
16193 GETBYTE ();
16194 switch (op[2] & 0x00)
16195 {
16196 case 0x00:
16197 goto op_semantics_124;
16198 break;
16199 }
16200 break;
16201 case 0xab:
16202 GETBYTE ();
16203 switch (op[2] & 0x00)
16204 {
16205 case 0x00:
16206 goto op_semantics_124;
16207 break;
16208 }
16209 break;
16210 case 0xac:
16211 GETBYTE ();
16212 switch (op[2] & 0x00)
16213 {
16214 case 0x00:
16215 goto op_semantics_124;
16216 break;
16217 }
16218 break;
16219 case 0xad:
16220 GETBYTE ();
16221 switch (op[2] & 0x00)
16222 {
16223 case 0x00:
16224 goto op_semantics_124;
16225 break;
16226 }
16227 break;
16228 case 0xae:
16229 GETBYTE ();
16230 switch (op[2] & 0x00)
16231 {
16232 case 0x00:
16233 goto op_semantics_124;
16234 break;
16235 }
16236 break;
16237 case 0xaf:
16238 GETBYTE ();
16239 switch (op[2] & 0x00)
16240 {
16241 case 0x00:
16242 goto op_semantics_124;
16243 break;
16244 }
16245 break;
16246 case 0xb0:
16247 GETBYTE ();
16248 switch (op[2] & 0x00)
16249 {
16250 case 0x00:
16251 op_semantics_125:
16252 {
16253 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */
16254 #line 1107 "rx-decode.opc"
16255 int rdst AU = op[1] & 0x0f;
16256 #line 1107 "rx-decode.opc"
16257 int srca AU = (op[2] >> 4) & 0x0f;
16258 #line 1107 "rx-decode.opc"
16259 int srcb AU = op[2] & 0x0f;
16260 if (trace)
16261 {
16262 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
16263 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */",
16264 op[0], op[1], op[2]);
16265 printf (" rdst = 0x%x,", rdst);
16266 printf (" srca = 0x%x,", srca);
16267 printf (" srcb = 0x%x\n", srcb);
16268 }
16269 SYNTAX("fmul %2, %1, %0");
16270 #line 1107 "rx-decode.opc"
16271 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16272
16273 }
16274 break;
16275 }
16276 break;
16277 case 0xb1:
16278 GETBYTE ();
16279 switch (op[2] & 0x00)
16280 {
16281 case 0x00:
16282 goto op_semantics_125;
16283 break;
16284 }
16285 break;
16286 case 0xb2:
16287 GETBYTE ();
16288 switch (op[2] & 0x00)
16289 {
16290 case 0x00:
16291 goto op_semantics_125;
16292 break;
16293 }
16294 break;
16295 case 0xb3:
16296 GETBYTE ();
16297 switch (op[2] & 0x00)
16298 {
16299 case 0x00:
16300 goto op_semantics_125;
16301 break;
16302 }
16303 break;
16304 case 0xb4:
16305 GETBYTE ();
16306 switch (op[2] & 0x00)
16307 {
16308 case 0x00:
16309 goto op_semantics_125;
16310 break;
16311 }
16312 break;
16313 case 0xb5:
16314 GETBYTE ();
16315 switch (op[2] & 0x00)
16316 {
16317 case 0x00:
16318 goto op_semantics_125;
16319 break;
16320 }
16321 break;
16322 case 0xb6:
16323 GETBYTE ();
16324 switch (op[2] & 0x00)
16325 {
16326 case 0x00:
16327 goto op_semantics_125;
16328 break;
16329 }
16330 break;
16331 case 0xb7:
16332 GETBYTE ();
16333 switch (op[2] & 0x00)
16334 {
16335 case 0x00:
16336 goto op_semantics_125;
16337 break;
16338 }
16339 break;
16340 case 0xb8:
16341 GETBYTE ();
16342 switch (op[2] & 0x00)
16343 {
16344 case 0x00:
16345 goto op_semantics_125;
16346 break;
16347 }
16348 break;
16349 case 0xb9:
16350 GETBYTE ();
16351 switch (op[2] & 0x00)
16352 {
16353 case 0x00:
16354 goto op_semantics_125;
16355 break;
16356 }
16357 break;
16358 case 0xba:
16359 GETBYTE ();
16360 switch (op[2] & 0x00)
16361 {
16362 case 0x00:
16363 goto op_semantics_125;
16364 break;
16365 }
16366 break;
16367 case 0xbb:
16368 GETBYTE ();
16369 switch (op[2] & 0x00)
16370 {
16371 case 0x00:
16372 goto op_semantics_125;
16373 break;
16374 }
16375 break;
16376 case 0xbc:
16377 GETBYTE ();
16378 switch (op[2] & 0x00)
16379 {
16380 case 0x00:
16381 goto op_semantics_125;
16382 break;
16383 }
16384 break;
16385 case 0xbd:
16386 GETBYTE ();
16387 switch (op[2] & 0x00)
16388 {
16389 case 0x00:
16390 goto op_semantics_125;
16391 break;
16392 }
16393 break;
16394 case 0xbe:
16395 GETBYTE ();
16396 switch (op[2] & 0x00)
16397 {
16398 case 0x00:
16399 goto op_semantics_125;
16400 break;
16401 }
16402 break;
16403 case 0xbf:
16404 GETBYTE ();
16405 switch (op[2] & 0x00)
16406 {
16407 case 0x00:
16408 goto op_semantics_125;
16409 break;
16410 }
16411 break;
16412 default: UNSUPPORTED(); break;
16413 }
16414 break;
16415 default: UNSUPPORTED(); break;
16416 }
16417 #line 1122 "rx-decode.opc"
16418
16419 return rx->n_bytes;
16420 }
GDB Binutils - Deliverables
This page took 0.41725 seconds and 4 git commands to generate.