projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* opc2c.c: Include "libiberty.h" and <errno.h>.
[deliverable/binutils-gdb.git] / opcodes / rx-decode.c
1 #line 2 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2 /* -*- c -*- */
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
6
7 #include "config.h"
8 #include "ansidecl.h"
9 #include "opcode/rx.h"
10
11 #define RX_OPCODE_BIG_ENDIAN 0
12
13 typedef struct
14 {
15 RX_Opcode_Decoded * rx;
16 int (* getbyte)(void *);
17 void * ptr;
18 unsigned char * op;
19 } LocalData;
20
21 static int trace = 0;
22
23 #define BSIZE 0
24 #define WSIZE 1
25 #define LSIZE 2
26
27 /* These are for when the upper bits are "don't care" or "undefined". */
28 static int bwl[] =
29 {
30 RX_Byte,
31 RX_Word,
32 RX_Long
33 };
34
35 static int sbwl[] =
36 {
37 RX_SByte,
38 RX_SWord,
39 RX_Long
40 };
41
42 static int ubwl[] =
43 {
44 RX_UByte,
45 RX_UWord,
46 RX_Long
47 };
48
49 static int memex[] =
50 {
51 RX_SByte,
52 RX_SWord,
53 RX_Long,
54 RX_UWord
55 };
56
57 #define ID(x) rx->id = RXO_##x
58 #define OP(n,t,r,a) (rx->op[n].type = t, \
59 rx->op[n].reg = r, \
60 rx->op[n].addend = a )
61 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
62 rx->op[n].size = s )
63
64 /* This is for the BWL and BW bitfields. */
65 static int SCALE[] = { 1, 2, 4 };
66 /* This is for the prefix size enum. */
67 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
68
69 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
70 16, 17, 0, 0, 0, 0, 0, 0 };
71
72 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
73
74 /*
75 *C a constant (immediate) c
76 *R A register
77 *I Register indirect, no offset
78 *Is Register indirect, with offset
79 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
80 *P standard displacement: type (r,[r]), reg, assumes UByte
81 *Pm memex displacement: type (r,[r]), reg, memex code
82 *cc condition code. */
83
84 #define DC(c) OP (0, RX_Operand_Immediate, 0, c)
85 #define DR(r) OP (0, RX_Operand_Register, r, 0)
86 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a)
87 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s])
88 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
89 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
90
91 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
92 #define SR(r) OP (1, RX_Operand_Register, r, 0)
93 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
94 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
95 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
96 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
97 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
98 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
99
100 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
101 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
102 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a)
103 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s])
104 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld);
105 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
106 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
107 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
108
109 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
110 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
111 #define uBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
112 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
113
114 #define F(f) store_flags(rx, f)
115
116 #define AU ATTRIBUTE_UNUSED
117 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
118
119 #define SYNTAX(x) rx->syntax = x
120
121 #define UNSUPPORTED() \
122 rx->syntax = "*unknown*"
123
124 #define IMM(sf) immediate (sf, 0, ld)
125 #define IMMex(sf) immediate (sf, 1, ld)
126
127 static int
128 immediate (int sfield, int ex, LocalData * ld)
129 {
130 unsigned long i = 0, j;
131
132 switch (sfield)
133 {
134 #define B ((unsigned long) GETBYTE())
135 case 0:
136 #if RX_OPCODE_BIG_ENDIAN
137 i = B;
138 if (ex && (i & 0x80))
139 i -= 0x100;
140 i <<= 24;
141 i |= B << 16;
142 i |= B << 8;
143 i |= B;
144 #else
145 i = B;
146 i |= B << 8;
147 i |= B << 16;
148 j = B;
149 if (ex && (j & 0x80))
150 j -= 0x100;
151 i |= j << 24;
152 #endif
153 break;
154 case 3:
155 #if RX_OPCODE_BIG_ENDIAN
156 i = B << 16;
157 i |= B << 8;
158 i |= B;
159 #else
160 i = B;
161 i |= B << 8;
162 i |= B << 16;
163 #endif
164 if (ex && (i & 0x800000))
165 i -= 0x1000000;
166 break;
167 case 2:
168 #if RX_OPCODE_BIG_ENDIAN
169 i |= B << 8;
170 i |= B;
171 #else
172 i |= B;
173 i |= B << 8;
174 #endif
175 if (ex && (i & 0x8000))
176 i -= 0x10000;
177 break;
178 case 1:
179 i |= B;
180 if (ex && (i & 0x80))
181 i -= 0x100;
182 break;
183 default:
184 abort();
185 }
186 return i;
187 }
188
189 static void
190 rx_disp (int n, int type, int reg, int size, LocalData * ld)
191 {
192 int disp;
193
194 ld->rx->op[n].reg = reg;
195 switch (type)
196 {
197 case 3:
198 ld->rx->op[n].type = RX_Operand_Register;
199 break;
200 case 0:
201 ld->rx->op[n].type = RX_Operand_Indirect;
202 ld->rx->op[n].addend = 0;
203 break;
204 case 1:
205 ld->rx->op[n].type = RX_Operand_Indirect;
206 disp = GETBYTE ();
207 ld->rx->op[n].addend = disp * PSCALE[size];
208 break;
209 case 2:
210 ld->rx->op[n].type = RX_Operand_Indirect;
211 disp = GETBYTE ();
212 #if RX_OPCODE_BIG_ENDIAN
213 disp = disp * 256 + GETBYTE ();
214 #else
215 disp = disp + GETBYTE () * 256;
216 #endif
217 ld->rx->op[n].addend = disp * PSCALE[size];
218 break;
219 default:
220 abort ();
221 }
222 }
223
224 /* The syntax is "OSZC" where each character is one of the following:
225 - = flag unchanged
226 0 = flag cleared
227 1 = flag set
228 ? = flag undefined
229 x = flag set (any letter will do, use it for hints :). */
230
231 static void
232 store_flags (RX_Opcode_Decoded * rx, char * str)
233 {
234 int i, mask;
235 rx->flags_0 = 0;
236 rx->flags_1 = 0;
237 rx->flags_s = 0;
238
239 for (i = 0; i < 4; i++)
240 {
241 mask = 8 >> i;
242 switch (str[i])
243 {
244 case 0:
245 abort ();
246 case '-':
247 break;
248 case '0':
249 rx->flags_0 |= mask;
250 break;
251 case '1':
252 rx->flags_1 |= mask;
253 break;
254 case '?':
255 break;
256 default:
257 rx->flags_0 |= mask;
258 rx->flags_s |= mask;
259 break;
260 }
261 }
262 }
263
264 int
265 rx_decode_opcode (unsigned long pc AU,
266 RX_Opcode_Decoded * rx,
267 int (* getbyte)(void *),
268 void * ptr)
269 {
270 LocalData lds, * ld = &lds;
271 unsigned char op[20] = {0};
272
273 lds.rx = rx;
274 lds.getbyte = getbyte;
275 lds.ptr = ptr;
276 lds.op = op;
277
278 memset (rx, 0, sizeof (*rx));
279 BWL(LSIZE);
280
281
282 /*----------------------------------------------------------------------*/
283 /* MOV */
284
285 GETBYTE ();
286 switch (op[0] & 0xff)
287 {
288 case 0x00:
289 {
290 /** 0000 0000 brk */
291 if (trace)
292 {
293 printf ("\033[33m%s\033[0m %02x\n",
294 "/** 0000 0000 brk */",
295 op[0]);
296 }
297 SYNTAX("brk");
298 #line 957 "/work/sources/gcc/current/opcodes/rx-decode.opc"
299 ID(brk);
300
301 }
302 break;
303 case 0x01:
304 {
305 /** 0000 0001 dbt */
306 if (trace)
307 {
308 printf ("\033[33m%s\033[0m %02x\n",
309 "/** 0000 0001 dbt */",
310 op[0]);
311 }
312 SYNTAX("dbt");
313 #line 960 "/work/sources/gcc/current/opcodes/rx-decode.opc"
314 ID(dbt);
315
316 }
317 break;
318 case 0x02:
319 {
320 /** 0000 0010 rts */
321 if (trace)
322 {
323 printf ("\033[33m%s\033[0m %02x\n",
324 "/** 0000 0010 rts */",
325 op[0]);
326 }
327 SYNTAX("rts");
328 #line 740 "/work/sources/gcc/current/opcodes/rx-decode.opc"
329 ID(rts);
330
331 /*----------------------------------------------------------------------*/
332 /* NOP */
333
334 }
335 break;
336 case 0x03:
337 {
338 /** 0000 0011 nop */
339 if (trace)
340 {
341 printf ("\033[33m%s\033[0m %02x\n",
342 "/** 0000 0011 nop */",
343 op[0]);
344 }
345 SYNTAX("nop");
346 #line 746 "/work/sources/gcc/current/opcodes/rx-decode.opc"
347 ID(nop);
348
349 /*----------------------------------------------------------------------*/
350 /* STRING FUNCTIONS */
351
352 }
353 break;
354 case 0x04:
355 {
356 /** 0000 0100 bra.a %a0 */
357 if (trace)
358 {
359 printf ("\033[33m%s\033[0m %02x\n",
360 "/** 0000 0100 bra.a %a0 */",
361 op[0]);
362 }
363 SYNTAX("bra.a %a0");
364 #line 718 "/work/sources/gcc/current/opcodes/rx-decode.opc"
365 ID(branch); Scc(RXC_always); DC(pc + IMMex(3));
366
367 }
368 break;
369 case 0x05:
370 {
371 /** 0000 0101 bsr.a %a0 */
372 if (trace)
373 {
374 printf ("\033[33m%s\033[0m %02x\n",
375 "/** 0000 0101 bsr.a %a0 */",
376 op[0]);
377 }
378 SYNTAX("bsr.a %a0");
379 #line 734 "/work/sources/gcc/current/opcodes/rx-decode.opc"
380 ID(jsr); DC(pc + IMMex(3));
381
382 }
383 break;
384 case 0x06:
385 GETBYTE ();
386 switch (op[1] & 0xff)
387 {
388 case 0x00:
389 GETBYTE ();
390 switch (op[2] & 0x00)
391 {
392 case 0x00:
393 op_semantics_1:
394 {
395 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
396 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
397 int mx AU = (op[1] >> 6) & 0x03;
398 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
399 int ss AU = op[1] & 0x03;
400 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
401 int rsrc AU = (op[2] >> 4) & 0x0f;
402 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
403 int rdst AU = op[2] & 0x0f;
404 if (trace)
405 {
406 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
407 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
408 op[0], op[1], op[2]);
409 printf (" mx = 0x%x,", mx);
410 printf (" ss = 0x%x,", ss);
411 printf (" rsrc = 0x%x,", rsrc);
412 printf (" rdst = 0x%x\n", rdst);
413 }
414 SYNTAX("sub %2%S2, %1");
415 #line 522 "/work/sources/gcc/current/opcodes/rx-decode.opc"
416 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F("OSZC");
417
418 }
419 break;
420 }
421 break;
422 case 0x01:
423 GETBYTE ();
424 switch (op[2] & 0x00)
425 {
426 case 0x00:
427 goto op_semantics_1;
428 break;
429 }
430 break;
431 case 0x02:
432 GETBYTE ();
433 switch (op[2] & 0x00)
434 {
435 case 0x00:
436 goto op_semantics_1;
437 break;
438 }
439 break;
440 case 0x03:
441 GETBYTE ();
442 switch (op[2] & 0x00)
443 {
444 case 0x00:
445 goto op_semantics_1;
446 break;
447 }
448 break;
449 case 0x04:
450 GETBYTE ();
451 switch (op[2] & 0x00)
452 {
453 case 0x00:
454 op_semantics_2:
455 {
456 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
457 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
458 int mx AU = (op[1] >> 6) & 0x03;
459 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
460 int ss AU = op[1] & 0x03;
461 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
462 int rsrc AU = (op[2] >> 4) & 0x0f;
463 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
464 int rdst AU = op[2] & 0x0f;
465 if (trace)
466 {
467 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
468 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
469 op[0], op[1], op[2]);
470 printf (" mx = 0x%x,", mx);
471 printf (" ss = 0x%x,", ss);
472 printf (" rsrc = 0x%x,", rsrc);
473 printf (" rdst = 0x%x\n", rdst);
474 }
475 SYNTAX("cmp %2%S2, %1");
476 #line 510 "/work/sources/gcc/current/opcodes/rx-decode.opc"
477 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F("OSZC");
478
479 /*----------------------------------------------------------------------*/
480 /* SUB */
481
482 }
483 break;
484 }
485 break;
486 case 0x05:
487 GETBYTE ();
488 switch (op[2] & 0x00)
489 {
490 case 0x00:
491 goto op_semantics_2;
492 break;
493 }
494 break;
495 case 0x06:
496 GETBYTE ();
497 switch (op[2] & 0x00)
498 {
499 case 0x00:
500 goto op_semantics_2;
501 break;
502 }
503 break;
504 case 0x07:
505 GETBYTE ();
506 switch (op[2] & 0x00)
507 {
508 case 0x00:
509 goto op_semantics_2;
510 break;
511 }
512 break;
513 case 0x08:
514 GETBYTE ();
515 switch (op[2] & 0x00)
516 {
517 case 0x00:
518 op_semantics_3:
519 {
520 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
521 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
522 int mx AU = (op[1] >> 6) & 0x03;
523 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
524 int ss AU = op[1] & 0x03;
525 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
526 int rsrc AU = (op[2] >> 4) & 0x0f;
527 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
528 int rdst AU = op[2] & 0x0f;
529 if (trace)
530 {
531 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
532 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
533 op[0], op[1], op[2]);
534 printf (" mx = 0x%x,", mx);
535 printf (" ss = 0x%x,", ss);
536 printf (" rsrc = 0x%x,", rsrc);
537 printf (" rdst = 0x%x\n", rdst);
538 }
539 SYNTAX("add %1%S1, %0");
540 #line 486 "/work/sources/gcc/current/opcodes/rx-decode.opc"
541 ID(add); SPm(ss, rsrc, mx); DR(rdst); F("OSZC");
542
543 }
544 break;
545 }
546 break;
547 case 0x09:
548 GETBYTE ();
549 switch (op[2] & 0x00)
550 {
551 case 0x00:
552 goto op_semantics_3;
553 break;
554 }
555 break;
556 case 0x0a:
557 GETBYTE ();
558 switch (op[2] & 0x00)
559 {
560 case 0x00:
561 goto op_semantics_3;
562 break;
563 }
564 break;
565 case 0x0b:
566 GETBYTE ();
567 switch (op[2] & 0x00)
568 {
569 case 0x00:
570 goto op_semantics_3;
571 break;
572 }
573 break;
574 case 0x0c:
575 GETBYTE ();
576 switch (op[2] & 0x00)
577 {
578 case 0x00:
579 op_semantics_4:
580 {
581 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
582 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
583 int mx AU = (op[1] >> 6) & 0x03;
584 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
585 int ss AU = op[1] & 0x03;
586 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
587 int rsrc AU = (op[2] >> 4) & 0x0f;
588 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
589 int rdst AU = op[2] & 0x0f;
590 if (trace)
591 {
592 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
593 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
594 op[0], op[1], op[2]);
595 printf (" mx = 0x%x,", mx);
596 printf (" ss = 0x%x,", ss);
597 printf (" rsrc = 0x%x,", rsrc);
598 printf (" rdst = 0x%x\n", rdst);
599 }
600 SYNTAX("mul %1%S1, %0");
601 #line 583 "/work/sources/gcc/current/opcodes/rx-decode.opc"
602 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F("O---");
603
604 }
605 break;
606 }
607 break;
608 case 0x0d:
609 GETBYTE ();
610 switch (op[2] & 0x00)
611 {
612 case 0x00:
613 goto op_semantics_4;
614 break;
615 }
616 break;
617 case 0x0e:
618 GETBYTE ();
619 switch (op[2] & 0x00)
620 {
621 case 0x00:
622 goto op_semantics_4;
623 break;
624 }
625 break;
626 case 0x0f:
627 GETBYTE ();
628 switch (op[2] & 0x00)
629 {
630 case 0x00:
631 goto op_semantics_4;
632 break;
633 }
634 break;
635 case 0x10:
636 GETBYTE ();
637 switch (op[2] & 0x00)
638 {
639 case 0x00:
640 op_semantics_5:
641 {
642 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
643 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
644 int mx AU = (op[1] >> 6) & 0x03;
645 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
646 int ss AU = op[1] & 0x03;
647 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
648 int rsrc AU = (op[2] >> 4) & 0x0f;
649 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
650 int rdst AU = op[2] & 0x0f;
651 if (trace)
652 {
653 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
654 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
655 op[0], op[1], op[2]);
656 printf (" mx = 0x%x,", mx);
657 printf (" ss = 0x%x,", ss);
658 printf (" rsrc = 0x%x,", rsrc);
659 printf (" rdst = 0x%x\n", rdst);
660 }
661 SYNTAX("and %1%S1, %0");
662 #line 399 "/work/sources/gcc/current/opcodes/rx-decode.opc"
663 ID(and); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
664
665 }
666 break;
667 }
668 break;
669 case 0x11:
670 GETBYTE ();
671 switch (op[2] & 0x00)
672 {
673 case 0x00:
674 goto op_semantics_5;
675 break;
676 }
677 break;
678 case 0x12:
679 GETBYTE ();
680 switch (op[2] & 0x00)
681 {
682 case 0x00:
683 goto op_semantics_5;
684 break;
685 }
686 break;
687 case 0x13:
688 GETBYTE ();
689 switch (op[2] & 0x00)
690 {
691 case 0x00:
692 goto op_semantics_5;
693 break;
694 }
695 break;
696 case 0x14:
697 GETBYTE ();
698 switch (op[2] & 0x00)
699 {
700 case 0x00:
701 op_semantics_6:
702 {
703 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
704 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
705 int mx AU = (op[1] >> 6) & 0x03;
706 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
707 int ss AU = op[1] & 0x03;
708 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
709 int rsrc AU = (op[2] >> 4) & 0x0f;
710 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
711 int rdst AU = op[2] & 0x0f;
712 if (trace)
713 {
714 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
715 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
716 op[0], op[1], op[2]);
717 printf (" mx = 0x%x,", mx);
718 printf (" ss = 0x%x,", ss);
719 printf (" rsrc = 0x%x,", rsrc);
720 printf (" rdst = 0x%x\n", rdst);
721 }
722 SYNTAX("or %1%S1, %0");
723 #line 417 "/work/sources/gcc/current/opcodes/rx-decode.opc"
724 ID(or); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
725
726 }
727 break;
728 }
729 break;
730 case 0x15:
731 GETBYTE ();
732 switch (op[2] & 0x00)
733 {
734 case 0x00:
735 goto op_semantics_6;
736 break;
737 }
738 break;
739 case 0x16:
740 GETBYTE ();
741 switch (op[2] & 0x00)
742 {
743 case 0x00:
744 goto op_semantics_6;
745 break;
746 }
747 break;
748 case 0x17:
749 GETBYTE ();
750 switch (op[2] & 0x00)
751 {
752 case 0x00:
753 goto op_semantics_6;
754 break;
755 }
756 break;
757 case 0x20:
758 GETBYTE ();
759 switch (op[2] & 0xff)
760 {
761 case 0x00:
762 GETBYTE ();
763 switch (op[3] & 0x00)
764 {
765 case 0x00:
766 op_semantics_7:
767 {
768 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
769 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
770 int mx AU = (op[1] >> 6) & 0x03;
771 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
772 int sp AU = op[1] & 0x03;
773 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
774 int rsrc AU = (op[3] >> 4) & 0x0f;
775 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
776 int rdst AU = op[3] & 0x0f;
777 if (trace)
778 {
779 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
780 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
781 op[0], op[1], op[2], op[3]);
782 printf (" mx = 0x%x,", mx);
783 printf (" sp = 0x%x,", sp);
784 printf (" rsrc = 0x%x,", rsrc);
785 printf (" rdst = 0x%x\n", rdst);
786 }
787 SYNTAX("sbb %1%S1, %0");
788 #line 535 "/work/sources/gcc/current/opcodes/rx-decode.opc"
789 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F("OSZC");
790
791 /*----------------------------------------------------------------------*/
792 /* ABS */
793
794 }
795 break;
796 }
797 break;
798 case 0x04:
799 GETBYTE ();
800 switch (op[3] & 0x00)
801 {
802 case 0x00:
803 op_semantics_8:
804 {
805 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
806 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
807 int mx AU = (op[1] >> 6) & 0x03;
808 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
809 int ss AU = op[1] & 0x03;
810 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
811 int rsrc AU = (op[3] >> 4) & 0x0f;
812 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
813 int rdst AU = op[3] & 0x0f;
814 if (trace)
815 {
816 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
817 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
818 op[0], op[1], op[2], op[3]);
819 printf (" mx = 0x%x,", mx);
820 printf (" ss = 0x%x,", ss);
821 printf (" rsrc = 0x%x,", rsrc);
822 printf (" rdst = 0x%x\n", rdst);
823 }
824 SYNTAX("max %1%S1, %0");
825 #line 556 "/work/sources/gcc/current/opcodes/rx-decode.opc"
826 ID(max); SPm(ss, rsrc, mx); DR(rdst);
827
828 /*----------------------------------------------------------------------*/
829 /* MIN */
830
831 }
832 break;
833 }
834 break;
835 case 0x05:
836 GETBYTE ();
837 switch (op[3] & 0x00)
838 {
839 case 0x00:
840 op_semantics_9:
841 {
842 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
843 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
844 int mx AU = (op[1] >> 6) & 0x03;
845 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
846 int ss AU = op[1] & 0x03;
847 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
848 int rsrc AU = (op[3] >> 4) & 0x0f;
849 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
850 int rdst AU = op[3] & 0x0f;
851 if (trace)
852 {
853 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
854 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
855 op[0], op[1], op[2], op[3]);
856 printf (" mx = 0x%x,", mx);
857 printf (" ss = 0x%x,", ss);
858 printf (" rsrc = 0x%x,", rsrc);
859 printf (" rdst = 0x%x\n", rdst);
860 }
861 SYNTAX("min %1%S1, %0");
862 #line 568 "/work/sources/gcc/current/opcodes/rx-decode.opc"
863 ID(min); SPm(ss, rsrc, mx); DR(rdst);
864
865 /*----------------------------------------------------------------------*/
866 /* MUL */
867
868 }
869 break;
870 }
871 break;
872 case 0x06:
873 GETBYTE ();
874 switch (op[3] & 0x00)
875 {
876 case 0x00:
877 op_semantics_10:
878 {
879 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
880 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
881 int mx AU = (op[1] >> 6) & 0x03;
882 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
883 int ss AU = op[1] & 0x03;
884 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
885 int rsrc AU = (op[3] >> 4) & 0x0f;
886 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
887 int rdst AU = op[3] & 0x0f;
888 if (trace)
889 {
890 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
891 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */",
892 op[0], op[1], op[2], op[3]);
893 printf (" mx = 0x%x,", mx);
894 printf (" ss = 0x%x,", ss);
895 printf (" rsrc = 0x%x,", rsrc);
896 printf (" rdst = 0x%x\n", rdst);
897 }
898 SYNTAX("emul %1%S1, %0");
899 #line 598 "/work/sources/gcc/current/opcodes/rx-decode.opc"
900 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
901
902 /*----------------------------------------------------------------------*/
903 /* EMULU */
904
905 }
906 break;
907 }
908 break;
909 case 0x07:
910 GETBYTE ();
911 switch (op[3] & 0x00)
912 {
913 case 0x00:
914 op_semantics_11:
915 {
916 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
917 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
918 int mx AU = (op[1] >> 6) & 0x03;
919 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
920 int ss AU = op[1] & 0x03;
921 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
922 int rsrc AU = (op[3] >> 4) & 0x0f;
923 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
924 int rdst AU = op[3] & 0x0f;
925 if (trace)
926 {
927 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
928 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
929 op[0], op[1], op[2], op[3]);
930 printf (" mx = 0x%x,", mx);
931 printf (" ss = 0x%x,", ss);
932 printf (" rsrc = 0x%x,", rsrc);
933 printf (" rdst = 0x%x\n", rdst);
934 }
935 SYNTAX("emulu %1%S1, %0");
936 #line 610 "/work/sources/gcc/current/opcodes/rx-decode.opc"
937 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
938
939 /*----------------------------------------------------------------------*/
940 /* DIV */
941
942 }
943 break;
944 }
945 break;
946 case 0x08:
947 GETBYTE ();
948 switch (op[3] & 0x00)
949 {
950 case 0x00:
951 op_semantics_12:
952 {
953 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
954 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
955 int mx AU = (op[1] >> 6) & 0x03;
956 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
957 int ss AU = op[1] & 0x03;
958 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
959 int rsrc AU = (op[3] >> 4) & 0x0f;
960 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
961 int rdst AU = op[3] & 0x0f;
962 if (trace)
963 {
964 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
965 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
966 op[0], op[1], op[2], op[3]);
967 printf (" mx = 0x%x,", mx);
968 printf (" ss = 0x%x,", ss);
969 printf (" rsrc = 0x%x,", rsrc);
970 printf (" rdst = 0x%x\n", rdst);
971 }
972 SYNTAX("div %1%S1, %0");
973 #line 622 "/work/sources/gcc/current/opcodes/rx-decode.opc"
974 ID(div); SPm(ss, rsrc, mx); DR(rdst); F("O---");
975
976 /*----------------------------------------------------------------------*/
977 /* DIVU */
978
979 }
980 break;
981 }
982 break;
983 case 0x09:
984 GETBYTE ();
985 switch (op[3] & 0x00)
986 {
987 case 0x00:
988 op_semantics_13:
989 {
990 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
991 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
992 int mx AU = (op[1] >> 6) & 0x03;
993 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
994 int ss AU = op[1] & 0x03;
995 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
996 int rsrc AU = (op[3] >> 4) & 0x0f;
997 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
998 int rdst AU = op[3] & 0x0f;
999 if (trace)
1000 {
1001 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1002 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */",
1003 op[0], op[1], op[2], op[3]);
1004 printf (" mx = 0x%x,", mx);
1005 printf (" ss = 0x%x,", ss);
1006 printf (" rsrc = 0x%x,", rsrc);
1007 printf (" rdst = 0x%x\n", rdst);
1008 }
1009 SYNTAX("divu %1%S1, %0");
1010 #line 634 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1011 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F("O---");
1012
1013 /*----------------------------------------------------------------------*/
1014 /* SHIFT */
1015
1016 }
1017 break;
1018 }
1019 break;
1020 case 0x0c:
1021 GETBYTE ();
1022 switch (op[3] & 0x00)
1023 {
1024 case 0x00:
1025 op_semantics_14:
1026 {
1027 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1028 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1029 int mx AU = (op[1] >> 6) & 0x03;
1030 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1031 int ss AU = op[1] & 0x03;
1032 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1033 int rsrc AU = (op[3] >> 4) & 0x0f;
1034 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1035 int rdst AU = op[3] & 0x0f;
1036 if (trace)
1037 {
1038 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1039 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1040 op[0], op[1], op[2], op[3]);
1041 printf (" mx = 0x%x,", mx);
1042 printf (" ss = 0x%x,", ss);
1043 printf (" rsrc = 0x%x,", rsrc);
1044 printf (" rdst = 0x%x\n", rdst);
1045 }
1046 SYNTAX("tst %1%S1, %2");
1047 #line 453 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1048 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F("-SZ-");
1049
1050 /*----------------------------------------------------------------------*/
1051 /* NEG */
1052
1053 }
1054 break;
1055 }
1056 break;
1057 case 0x0d:
1058 GETBYTE ();
1059 switch (op[3] & 0x00)
1060 {
1061 case 0x00:
1062 op_semantics_15:
1063 {
1064 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1065 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1066 int mx AU = (op[1] >> 6) & 0x03;
1067 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1068 int ss AU = op[1] & 0x03;
1069 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1070 int rsrc AU = (op[3] >> 4) & 0x0f;
1071 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1072 int rdst AU = op[3] & 0x0f;
1073 if (trace)
1074 {
1075 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1076 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1077 op[0], op[1], op[2], op[3]);
1078 printf (" mx = 0x%x,", mx);
1079 printf (" ss = 0x%x,", ss);
1080 printf (" rsrc = 0x%x,", rsrc);
1081 printf (" rdst = 0x%x\n", rdst);
1082 }
1083 SYNTAX("xor %1%S1, %0");
1084 #line 432 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1085 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
1086
1087 /*----------------------------------------------------------------------*/
1088 /* NOT */
1089
1090 }
1091 break;
1092 }
1093 break;
1094 case 0x10:
1095 GETBYTE ();
1096 switch (op[3] & 0x00)
1097 {
1098 case 0x00:
1099 op_semantics_16:
1100 {
1101 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1102 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1103 int mx AU = (op[1] >> 6) & 0x03;
1104 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1105 int ss AU = op[1] & 0x03;
1106 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1107 int rsrc AU = (op[3] >> 4) & 0x0f;
1108 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1109 int rdst AU = op[3] & 0x0f;
1110 if (trace)
1111 {
1112 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1113 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */",
1114 op[0], op[1], op[2], op[3]);
1115 printf (" mx = 0x%x,", mx);
1116 printf (" ss = 0x%x,", ss);
1117 printf (" rsrc = 0x%x,", rsrc);
1118 printf (" rdst = 0x%x\n", rdst);
1119 }
1120 SYNTAX("xchg %1%S1, %0");
1121 #line 366 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1122 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1123
1124 /*----------------------------------------------------------------------*/
1125 /* STZ/STNZ */
1126
1127 }
1128 break;
1129 }
1130 break;
1131 case 0x11:
1132 GETBYTE ();
1133 switch (op[3] & 0x00)
1134 {
1135 case 0x00:
1136 op_semantics_17:
1137 {
1138 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1139 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1140 int mx AU = (op[1] >> 6) & 0x03;
1141 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1142 int sd AU = op[1] & 0x03;
1143 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1144 int rsrc AU = (op[3] >> 4) & 0x0f;
1145 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1146 int rdst AU = op[3] & 0x0f;
1147 if (trace)
1148 {
1149 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
1150 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */",
1151 op[0], op[1], op[2], op[3]);
1152 printf (" mx = 0x%x,", mx);
1153 printf (" sd = 0x%x,", sd);
1154 printf (" rsrc = 0x%x,", rsrc);
1155 printf (" rdst = 0x%x\n", rdst);
1156 }
1157 SYNTAX("itof %1%S1, %0");
1158 #line 863 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1159 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F("-SZ-");
1160
1161 /*----------------------------------------------------------------------*/
1162 /* BIT OPS */
1163
1164 }
1165 break;
1166 }
1167 break;
1168 default: UNSUPPORTED(); break;
1169 }
1170 break;
1171 case 0x21:
1172 GETBYTE ();
1173 switch (op[2] & 0xff)
1174 {
1175 case 0x00:
1176 GETBYTE ();
1177 switch (op[3] & 0x00)
1178 {
1179 case 0x00:
1180 goto op_semantics_7;
1181 break;
1182 }
1183 break;
1184 case 0x04:
1185 GETBYTE ();
1186 switch (op[3] & 0x00)
1187 {
1188 case 0x00:
1189 goto op_semantics_8;
1190 break;
1191 }
1192 break;
1193 case 0x05:
1194 GETBYTE ();
1195 switch (op[3] & 0x00)
1196 {
1197 case 0x00:
1198 goto op_semantics_9;
1199 break;
1200 }
1201 break;
1202 case 0x06:
1203 GETBYTE ();
1204 switch (op[3] & 0x00)
1205 {
1206 case 0x00:
1207 goto op_semantics_10;
1208 break;
1209 }
1210 break;
1211 case 0x07:
1212 GETBYTE ();
1213 switch (op[3] & 0x00)
1214 {
1215 case 0x00:
1216 goto op_semantics_11;
1217 break;
1218 }
1219 break;
1220 case 0x08:
1221 GETBYTE ();
1222 switch (op[3] & 0x00)
1223 {
1224 case 0x00:
1225 goto op_semantics_12;
1226 break;
1227 }
1228 break;
1229 case 0x09:
1230 GETBYTE ();
1231 switch (op[3] & 0x00)
1232 {
1233 case 0x00:
1234 goto op_semantics_13;
1235 break;
1236 }
1237 break;
1238 case 0x0c:
1239 GETBYTE ();
1240 switch (op[3] & 0x00)
1241 {
1242 case 0x00:
1243 goto op_semantics_14;
1244 break;
1245 }
1246 break;
1247 case 0x0d:
1248 GETBYTE ();
1249 switch (op[3] & 0x00)
1250 {
1251 case 0x00:
1252 goto op_semantics_15;
1253 break;
1254 }
1255 break;
1256 case 0x10:
1257 GETBYTE ();
1258 switch (op[3] & 0x00)
1259 {
1260 case 0x00:
1261 goto op_semantics_16;
1262 break;
1263 }
1264 break;
1265 case 0x11:
1266 GETBYTE ();
1267 switch (op[3] & 0x00)
1268 {
1269 case 0x00:
1270 goto op_semantics_17;
1271 break;
1272 }
1273 break;
1274 default: UNSUPPORTED(); break;
1275 }
1276 break;
1277 case 0x22:
1278 GETBYTE ();
1279 switch (op[2] & 0xff)
1280 {
1281 case 0x00:
1282 GETBYTE ();
1283 switch (op[3] & 0x00)
1284 {
1285 case 0x00:
1286 goto op_semantics_7;
1287 break;
1288 }
1289 break;
1290 case 0x04:
1291 GETBYTE ();
1292 switch (op[3] & 0x00)
1293 {
1294 case 0x00:
1295 goto op_semantics_8;
1296 break;
1297 }
1298 break;
1299 case 0x05:
1300 GETBYTE ();
1301 switch (op[3] & 0x00)
1302 {
1303 case 0x00:
1304 goto op_semantics_9;
1305 break;
1306 }
1307 break;
1308 case 0x06:
1309 GETBYTE ();
1310 switch (op[3] & 0x00)
1311 {
1312 case 0x00:
1313 goto op_semantics_10;
1314 break;
1315 }
1316 break;
1317 case 0x07:
1318 GETBYTE ();
1319 switch (op[3] & 0x00)
1320 {
1321 case 0x00:
1322 goto op_semantics_11;
1323 break;
1324 }
1325 break;
1326 case 0x08:
1327 GETBYTE ();
1328 switch (op[3] & 0x00)
1329 {
1330 case 0x00:
1331 goto op_semantics_12;
1332 break;
1333 }
1334 break;
1335 case 0x09:
1336 GETBYTE ();
1337 switch (op[3] & 0x00)
1338 {
1339 case 0x00:
1340 goto op_semantics_13;
1341 break;
1342 }
1343 break;
1344 case 0x0c:
1345 GETBYTE ();
1346 switch (op[3] & 0x00)
1347 {
1348 case 0x00:
1349 goto op_semantics_14;
1350 break;
1351 }
1352 break;
1353 case 0x0d:
1354 GETBYTE ();
1355 switch (op[3] & 0x00)
1356 {
1357 case 0x00:
1358 goto op_semantics_15;
1359 break;
1360 }
1361 break;
1362 case 0x10:
1363 GETBYTE ();
1364 switch (op[3] & 0x00)
1365 {
1366 case 0x00:
1367 goto op_semantics_16;
1368 break;
1369 }
1370 break;
1371 case 0x11:
1372 GETBYTE ();
1373 switch (op[3] & 0x00)
1374 {
1375 case 0x00:
1376 goto op_semantics_17;
1377 break;
1378 }
1379 break;
1380 default: UNSUPPORTED(); break;
1381 }
1382 break;
1383 case 0x23:
1384 GETBYTE ();
1385 switch (op[2] & 0xff)
1386 {
1387 case 0x00:
1388 GETBYTE ();
1389 switch (op[3] & 0x00)
1390 {
1391 case 0x00:
1392 goto op_semantics_7;
1393 break;
1394 }
1395 break;
1396 case 0x04:
1397 GETBYTE ();
1398 switch (op[3] & 0x00)
1399 {
1400 case 0x00:
1401 goto op_semantics_8;
1402 break;
1403 }
1404 break;
1405 case 0x05:
1406 GETBYTE ();
1407 switch (op[3] & 0x00)
1408 {
1409 case 0x00:
1410 goto op_semantics_9;
1411 break;
1412 }
1413 break;
1414 case 0x06:
1415 GETBYTE ();
1416 switch (op[3] & 0x00)
1417 {
1418 case 0x00:
1419 goto op_semantics_10;
1420 break;
1421 }
1422 break;
1423 case 0x07:
1424 GETBYTE ();
1425 switch (op[3] & 0x00)
1426 {
1427 case 0x00:
1428 goto op_semantics_11;
1429 break;
1430 }
1431 break;
1432 case 0x08:
1433 GETBYTE ();
1434 switch (op[3] & 0x00)
1435 {
1436 case 0x00:
1437 goto op_semantics_12;
1438 break;
1439 }
1440 break;
1441 case 0x09:
1442 GETBYTE ();
1443 switch (op[3] & 0x00)
1444 {
1445 case 0x00:
1446 goto op_semantics_13;
1447 break;
1448 }
1449 break;
1450 case 0x0c:
1451 GETBYTE ();
1452 switch (op[3] & 0x00)
1453 {
1454 case 0x00:
1455 goto op_semantics_14;
1456 break;
1457 }
1458 break;
1459 case 0x0d:
1460 GETBYTE ();
1461 switch (op[3] & 0x00)
1462 {
1463 case 0x00:
1464 goto op_semantics_15;
1465 break;
1466 }
1467 break;
1468 case 0x10:
1469 GETBYTE ();
1470 switch (op[3] & 0x00)
1471 {
1472 case 0x00:
1473 goto op_semantics_16;
1474 break;
1475 }
1476 break;
1477 case 0x11:
1478 GETBYTE ();
1479 switch (op[3] & 0x00)
1480 {
1481 case 0x00:
1482 goto op_semantics_17;
1483 break;
1484 }
1485 break;
1486 default: UNSUPPORTED(); break;
1487 }
1488 break;
1489 case 0x40:
1490 GETBYTE ();
1491 switch (op[2] & 0x00)
1492 {
1493 case 0x00:
1494 goto op_semantics_1;
1495 break;
1496 }
1497 break;
1498 case 0x41:
1499 GETBYTE ();
1500 switch (op[2] & 0x00)
1501 {
1502 case 0x00:
1503 goto op_semantics_1;
1504 break;
1505 }
1506 break;
1507 case 0x42:
1508 GETBYTE ();
1509 switch (op[2] & 0x00)
1510 {
1511 case 0x00:
1512 goto op_semantics_1;
1513 break;
1514 }
1515 break;
1516 case 0x43:
1517 GETBYTE ();
1518 switch (op[2] & 0x00)
1519 {
1520 case 0x00:
1521 goto op_semantics_1;
1522 break;
1523 }
1524 break;
1525 case 0x44:
1526 GETBYTE ();
1527 switch (op[2] & 0x00)
1528 {
1529 case 0x00:
1530 goto op_semantics_2;
1531 break;
1532 }
1533 break;
1534 case 0x45:
1535 GETBYTE ();
1536 switch (op[2] & 0x00)
1537 {
1538 case 0x00:
1539 goto op_semantics_2;
1540 break;
1541 }
1542 break;
1543 case 0x46:
1544 GETBYTE ();
1545 switch (op[2] & 0x00)
1546 {
1547 case 0x00:
1548 goto op_semantics_2;
1549 break;
1550 }
1551 break;
1552 case 0x47:
1553 GETBYTE ();
1554 switch (op[2] & 0x00)
1555 {
1556 case 0x00:
1557 goto op_semantics_2;
1558 break;
1559 }
1560 break;
1561 case 0x48:
1562 GETBYTE ();
1563 switch (op[2] & 0x00)
1564 {
1565 case 0x00:
1566 goto op_semantics_3;
1567 break;
1568 }
1569 break;
1570 case 0x49:
1571 GETBYTE ();
1572 switch (op[2] & 0x00)
1573 {
1574 case 0x00:
1575 goto op_semantics_3;
1576 break;
1577 }
1578 break;
1579 case 0x4a:
1580 GETBYTE ();
1581 switch (op[2] & 0x00)
1582 {
1583 case 0x00:
1584 goto op_semantics_3;
1585 break;
1586 }
1587 break;
1588 case 0x4b:
1589 GETBYTE ();
1590 switch (op[2] & 0x00)
1591 {
1592 case 0x00:
1593 goto op_semantics_3;
1594 break;
1595 }
1596 break;
1597 case 0x4c:
1598 GETBYTE ();
1599 switch (op[2] & 0x00)
1600 {
1601 case 0x00:
1602 goto op_semantics_4;
1603 break;
1604 }
1605 break;
1606 case 0x4d:
1607 GETBYTE ();
1608 switch (op[2] & 0x00)
1609 {
1610 case 0x00:
1611 goto op_semantics_4;
1612 break;
1613 }
1614 break;
1615 case 0x4e:
1616 GETBYTE ();
1617 switch (op[2] & 0x00)
1618 {
1619 case 0x00:
1620 goto op_semantics_4;
1621 break;
1622 }
1623 break;
1624 case 0x4f:
1625 GETBYTE ();
1626 switch (op[2] & 0x00)
1627 {
1628 case 0x00:
1629 goto op_semantics_4;
1630 break;
1631 }
1632 break;
1633 case 0x50:
1634 GETBYTE ();
1635 switch (op[2] & 0x00)
1636 {
1637 case 0x00:
1638 goto op_semantics_5;
1639 break;
1640 }
1641 break;
1642 case 0x51:
1643 GETBYTE ();
1644 switch (op[2] & 0x00)
1645 {
1646 case 0x00:
1647 goto op_semantics_5;
1648 break;
1649 }
1650 break;
1651 case 0x52:
1652 GETBYTE ();
1653 switch (op[2] & 0x00)
1654 {
1655 case 0x00:
1656 goto op_semantics_5;
1657 break;
1658 }
1659 break;
1660 case 0x53:
1661 GETBYTE ();
1662 switch (op[2] & 0x00)
1663 {
1664 case 0x00:
1665 goto op_semantics_5;
1666 break;
1667 }
1668 break;
1669 case 0x54:
1670 GETBYTE ();
1671 switch (op[2] & 0x00)
1672 {
1673 case 0x00:
1674 goto op_semantics_6;
1675 break;
1676 }
1677 break;
1678 case 0x55:
1679 GETBYTE ();
1680 switch (op[2] & 0x00)
1681 {
1682 case 0x00:
1683 goto op_semantics_6;
1684 break;
1685 }
1686 break;
1687 case 0x56:
1688 GETBYTE ();
1689 switch (op[2] & 0x00)
1690 {
1691 case 0x00:
1692 goto op_semantics_6;
1693 break;
1694 }
1695 break;
1696 case 0x57:
1697 GETBYTE ();
1698 switch (op[2] & 0x00)
1699 {
1700 case 0x00:
1701 goto op_semantics_6;
1702 break;
1703 }
1704 break;
1705 case 0x60:
1706 GETBYTE ();
1707 switch (op[2] & 0xff)
1708 {
1709 case 0x00:
1710 GETBYTE ();
1711 switch (op[3] & 0x00)
1712 {
1713 case 0x00:
1714 goto op_semantics_7;
1715 break;
1716 }
1717 break;
1718 case 0x04:
1719 GETBYTE ();
1720 switch (op[3] & 0x00)
1721 {
1722 case 0x00:
1723 goto op_semantics_8;
1724 break;
1725 }
1726 break;
1727 case 0x05:
1728 GETBYTE ();
1729 switch (op[3] & 0x00)
1730 {
1731 case 0x00:
1732 goto op_semantics_9;
1733 break;
1734 }
1735 break;
1736 case 0x06:
1737 GETBYTE ();
1738 switch (op[3] & 0x00)
1739 {
1740 case 0x00:
1741 goto op_semantics_10;
1742 break;
1743 }
1744 break;
1745 case 0x07:
1746 GETBYTE ();
1747 switch (op[3] & 0x00)
1748 {
1749 case 0x00:
1750 goto op_semantics_11;
1751 break;
1752 }
1753 break;
1754 case 0x08:
1755 GETBYTE ();
1756 switch (op[3] & 0x00)
1757 {
1758 case 0x00:
1759 goto op_semantics_12;
1760 break;
1761 }
1762 break;
1763 case 0x09:
1764 GETBYTE ();
1765 switch (op[3] & 0x00)
1766 {
1767 case 0x00:
1768 goto op_semantics_13;
1769 break;
1770 }
1771 break;
1772 case 0x0c:
1773 GETBYTE ();
1774 switch (op[3] & 0x00)
1775 {
1776 case 0x00:
1777 goto op_semantics_14;
1778 break;
1779 }
1780 break;
1781 case 0x0d:
1782 GETBYTE ();
1783 switch (op[3] & 0x00)
1784 {
1785 case 0x00:
1786 goto op_semantics_15;
1787 break;
1788 }
1789 break;
1790 case 0x10:
1791 GETBYTE ();
1792 switch (op[3] & 0x00)
1793 {
1794 case 0x00:
1795 goto op_semantics_16;
1796 break;
1797 }
1798 break;
1799 case 0x11:
1800 GETBYTE ();
1801 switch (op[3] & 0x00)
1802 {
1803 case 0x00:
1804 goto op_semantics_17;
1805 break;
1806 }
1807 break;
1808 default: UNSUPPORTED(); break;
1809 }
1810 break;
1811 case 0x61:
1812 GETBYTE ();
1813 switch (op[2] & 0xff)
1814 {
1815 case 0x00:
1816 GETBYTE ();
1817 switch (op[3] & 0x00)
1818 {
1819 case 0x00:
1820 goto op_semantics_7;
1821 break;
1822 }
1823 break;
1824 case 0x04:
1825 GETBYTE ();
1826 switch (op[3] & 0x00)
1827 {
1828 case 0x00:
1829 goto op_semantics_8;
1830 break;
1831 }
1832 break;
1833 case 0x05:
1834 GETBYTE ();
1835 switch (op[3] & 0x00)
1836 {
1837 case 0x00:
1838 goto op_semantics_9;
1839 break;
1840 }
1841 break;
1842 case 0x06:
1843 GETBYTE ();
1844 switch (op[3] & 0x00)
1845 {
1846 case 0x00:
1847 goto op_semantics_10;
1848 break;
1849 }
1850 break;
1851 case 0x07:
1852 GETBYTE ();
1853 switch (op[3] & 0x00)
1854 {
1855 case 0x00:
1856 goto op_semantics_11;
1857 break;
1858 }
1859 break;
1860 case 0x08:
1861 GETBYTE ();
1862 switch (op[3] & 0x00)
1863 {
1864 case 0x00:
1865 goto op_semantics_12;
1866 break;
1867 }
1868 break;
1869 case 0x09:
1870 GETBYTE ();
1871 switch (op[3] & 0x00)
1872 {
1873 case 0x00:
1874 goto op_semantics_13;
1875 break;
1876 }
1877 break;
1878 case 0x0c:
1879 GETBYTE ();
1880 switch (op[3] & 0x00)
1881 {
1882 case 0x00:
1883 goto op_semantics_14;
1884 break;
1885 }
1886 break;
1887 case 0x0d:
1888 GETBYTE ();
1889 switch (op[3] & 0x00)
1890 {
1891 case 0x00:
1892 goto op_semantics_15;
1893 break;
1894 }
1895 break;
1896 case 0x10:
1897 GETBYTE ();
1898 switch (op[3] & 0x00)
1899 {
1900 case 0x00:
1901 goto op_semantics_16;
1902 break;
1903 }
1904 break;
1905 case 0x11:
1906 GETBYTE ();
1907 switch (op[3] & 0x00)
1908 {
1909 case 0x00:
1910 goto op_semantics_17;
1911 break;
1912 }
1913 break;
1914 default: UNSUPPORTED(); break;
1915 }
1916 break;
1917 case 0x62:
1918 GETBYTE ();
1919 switch (op[2] & 0xff)
1920 {
1921 case 0x00:
1922 GETBYTE ();
1923 switch (op[3] & 0x00)
1924 {
1925 case 0x00:
1926 goto op_semantics_7;
1927 break;
1928 }
1929 break;
1930 case 0x04:
1931 GETBYTE ();
1932 switch (op[3] & 0x00)
1933 {
1934 case 0x00:
1935 goto op_semantics_8;
1936 break;
1937 }
1938 break;
1939 case 0x05:
1940 GETBYTE ();
1941 switch (op[3] & 0x00)
1942 {
1943 case 0x00:
1944 goto op_semantics_9;
1945 break;
1946 }
1947 break;
1948 case 0x06:
1949 GETBYTE ();
1950 switch (op[3] & 0x00)
1951 {
1952 case 0x00:
1953 goto op_semantics_10;
1954 break;
1955 }
1956 break;
1957 case 0x07:
1958 GETBYTE ();
1959 switch (op[3] & 0x00)
1960 {
1961 case 0x00:
1962 goto op_semantics_11;
1963 break;
1964 }
1965 break;
1966 case 0x08:
1967 GETBYTE ();
1968 switch (op[3] & 0x00)
1969 {
1970 case 0x00:
1971 goto op_semantics_12;
1972 break;
1973 }
1974 break;
1975 case 0x09:
1976 GETBYTE ();
1977 switch (op[3] & 0x00)
1978 {
1979 case 0x00:
1980 goto op_semantics_13;
1981 break;
1982 }
1983 break;
1984 case 0x0c:
1985 GETBYTE ();
1986 switch (op[3] & 0x00)
1987 {
1988 case 0x00:
1989 goto op_semantics_14;
1990 break;
1991 }
1992 break;
1993 case 0x0d:
1994 GETBYTE ();
1995 switch (op[3] & 0x00)
1996 {
1997 case 0x00:
1998 goto op_semantics_15;
1999 break;
2000 }
2001 break;
2002 case 0x10:
2003 GETBYTE ();
2004 switch (op[3] & 0x00)
2005 {
2006 case 0x00:
2007 goto op_semantics_16;
2008 break;
2009 }
2010 break;
2011 case 0x11:
2012 GETBYTE ();
2013 switch (op[3] & 0x00)
2014 {
2015 case 0x00:
2016 goto op_semantics_17;
2017 break;
2018 }
2019 break;
2020 default: UNSUPPORTED(); break;
2021 }
2022 break;
2023 case 0x63:
2024 GETBYTE ();
2025 switch (op[2] & 0xff)
2026 {
2027 case 0x00:
2028 GETBYTE ();
2029 switch (op[3] & 0x00)
2030 {
2031 case 0x00:
2032 goto op_semantics_7;
2033 break;
2034 }
2035 break;
2036 case 0x04:
2037 GETBYTE ();
2038 switch (op[3] & 0x00)
2039 {
2040 case 0x00:
2041 goto op_semantics_8;
2042 break;
2043 }
2044 break;
2045 case 0x05:
2046 GETBYTE ();
2047 switch (op[3] & 0x00)
2048 {
2049 case 0x00:
2050 goto op_semantics_9;
2051 break;
2052 }
2053 break;
2054 case 0x06:
2055 GETBYTE ();
2056 switch (op[3] & 0x00)
2057 {
2058 case 0x00:
2059 goto op_semantics_10;
2060 break;
2061 }
2062 break;
2063 case 0x07:
2064 GETBYTE ();
2065 switch (op[3] & 0x00)
2066 {
2067 case 0x00:
2068 goto op_semantics_11;
2069 break;
2070 }
2071 break;
2072 case 0x08:
2073 GETBYTE ();
2074 switch (op[3] & 0x00)
2075 {
2076 case 0x00:
2077 goto op_semantics_12;
2078 break;
2079 }
2080 break;
2081 case 0x09:
2082 GETBYTE ();
2083 switch (op[3] & 0x00)
2084 {
2085 case 0x00:
2086 goto op_semantics_13;
2087 break;
2088 }
2089 break;
2090 case 0x0c:
2091 GETBYTE ();
2092 switch (op[3] & 0x00)
2093 {
2094 case 0x00:
2095 goto op_semantics_14;
2096 break;
2097 }
2098 break;
2099 case 0x0d:
2100 GETBYTE ();
2101 switch (op[3] & 0x00)
2102 {
2103 case 0x00:
2104 goto op_semantics_15;
2105 break;
2106 }
2107 break;
2108 case 0x10:
2109 GETBYTE ();
2110 switch (op[3] & 0x00)
2111 {
2112 case 0x00:
2113 goto op_semantics_16;
2114 break;
2115 }
2116 break;
2117 case 0x11:
2118 GETBYTE ();
2119 switch (op[3] & 0x00)
2120 {
2121 case 0x00:
2122 goto op_semantics_17;
2123 break;
2124 }
2125 break;
2126 default: UNSUPPORTED(); break;
2127 }
2128 break;
2129 case 0x80:
2130 GETBYTE ();
2131 switch (op[2] & 0x00)
2132 {
2133 case 0x00:
2134 goto op_semantics_1;
2135 break;
2136 }
2137 break;
2138 case 0x81:
2139 GETBYTE ();
2140 switch (op[2] & 0x00)
2141 {
2142 case 0x00:
2143 goto op_semantics_1;
2144 break;
2145 }
2146 break;
2147 case 0x82:
2148 GETBYTE ();
2149 switch (op[2] & 0x00)
2150 {
2151 case 0x00:
2152 goto op_semantics_1;
2153 break;
2154 }
2155 break;
2156 case 0x83:
2157 GETBYTE ();
2158 switch (op[2] & 0x00)
2159 {
2160 case 0x00:
2161 goto op_semantics_1;
2162 break;
2163 }
2164 break;
2165 case 0x84:
2166 GETBYTE ();
2167 switch (op[2] & 0x00)
2168 {
2169 case 0x00:
2170 goto op_semantics_2;
2171 break;
2172 }
2173 break;
2174 case 0x85:
2175 GETBYTE ();
2176 switch (op[2] & 0x00)
2177 {
2178 case 0x00:
2179 goto op_semantics_2;
2180 break;
2181 }
2182 break;
2183 case 0x86:
2184 GETBYTE ();
2185 switch (op[2] & 0x00)
2186 {
2187 case 0x00:
2188 goto op_semantics_2;
2189 break;
2190 }
2191 break;
2192 case 0x87:
2193 GETBYTE ();
2194 switch (op[2] & 0x00)
2195 {
2196 case 0x00:
2197 goto op_semantics_2;
2198 break;
2199 }
2200 break;
2201 case 0x88:
2202 GETBYTE ();
2203 switch (op[2] & 0x00)
2204 {
2205 case 0x00:
2206 goto op_semantics_3;
2207 break;
2208 }
2209 break;
2210 case 0x89:
2211 GETBYTE ();
2212 switch (op[2] & 0x00)
2213 {
2214 case 0x00:
2215 goto op_semantics_3;
2216 break;
2217 }
2218 break;
2219 case 0x8a:
2220 GETBYTE ();
2221 switch (op[2] & 0x00)
2222 {
2223 case 0x00:
2224 goto op_semantics_3;
2225 break;
2226 }
2227 break;
2228 case 0x8b:
2229 GETBYTE ();
2230 switch (op[2] & 0x00)
2231 {
2232 case 0x00:
2233 goto op_semantics_3;
2234 break;
2235 }
2236 break;
2237 case 0x8c:
2238 GETBYTE ();
2239 switch (op[2] & 0x00)
2240 {
2241 case 0x00:
2242 goto op_semantics_4;
2243 break;
2244 }
2245 break;
2246 case 0x8d:
2247 GETBYTE ();
2248 switch (op[2] & 0x00)
2249 {
2250 case 0x00:
2251 goto op_semantics_4;
2252 break;
2253 }
2254 break;
2255 case 0x8e:
2256 GETBYTE ();
2257 switch (op[2] & 0x00)
2258 {
2259 case 0x00:
2260 goto op_semantics_4;
2261 break;
2262 }
2263 break;
2264 case 0x8f:
2265 GETBYTE ();
2266 switch (op[2] & 0x00)
2267 {
2268 case 0x00:
2269 goto op_semantics_4;
2270 break;
2271 }
2272 break;
2273 case 0x90:
2274 GETBYTE ();
2275 switch (op[2] & 0x00)
2276 {
2277 case 0x00:
2278 goto op_semantics_5;
2279 break;
2280 }
2281 break;
2282 case 0x91:
2283 GETBYTE ();
2284 switch (op[2] & 0x00)
2285 {
2286 case 0x00:
2287 goto op_semantics_5;
2288 break;
2289 }
2290 break;
2291 case 0x92:
2292 GETBYTE ();
2293 switch (op[2] & 0x00)
2294 {
2295 case 0x00:
2296 goto op_semantics_5;
2297 break;
2298 }
2299 break;
2300 case 0x93:
2301 GETBYTE ();
2302 switch (op[2] & 0x00)
2303 {
2304 case 0x00:
2305 goto op_semantics_5;
2306 break;
2307 }
2308 break;
2309 case 0x94:
2310 GETBYTE ();
2311 switch (op[2] & 0x00)
2312 {
2313 case 0x00:
2314 goto op_semantics_6;
2315 break;
2316 }
2317 break;
2318 case 0x95:
2319 GETBYTE ();
2320 switch (op[2] & 0x00)
2321 {
2322 case 0x00:
2323 goto op_semantics_6;
2324 break;
2325 }
2326 break;
2327 case 0x96:
2328 GETBYTE ();
2329 switch (op[2] & 0x00)
2330 {
2331 case 0x00:
2332 goto op_semantics_6;
2333 break;
2334 }
2335 break;
2336 case 0x97:
2337 GETBYTE ();
2338 switch (op[2] & 0x00)
2339 {
2340 case 0x00:
2341 goto op_semantics_6;
2342 break;
2343 }
2344 break;
2345 case 0xa0:
2346 GETBYTE ();
2347 switch (op[2] & 0xff)
2348 {
2349 case 0x00:
2350 GETBYTE ();
2351 switch (op[3] & 0x00)
2352 {
2353 case 0x00:
2354 goto op_semantics_7;
2355 break;
2356 }
2357 break;
2358 case 0x02:
2359 GETBYTE ();
2360 switch (op[3] & 0x00)
2361 {
2362 case 0x00:
2363 op_semantics_18:
2364 {
2365 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2366 #line 473 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2367 int ss AU = op[1] & 0x03;
2368 #line 473 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2369 int rsrc AU = (op[3] >> 4) & 0x0f;
2370 #line 473 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2371 int rdst AU = op[3] & 0x0f;
2372 if (trace)
2373 {
2374 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
2375 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2376 op[0], op[1], op[2], op[3]);
2377 printf (" ss = 0x%x,", ss);
2378 printf (" rsrc = 0x%x,", rsrc);
2379 printf (" rdst = 0x%x\n", rdst);
2380 }
2381 SYNTAX("adc %1%S1, %0");
2382 #line 474 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2383 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F("OSZC");
2384
2385 /*----------------------------------------------------------------------*/
2386 /* ADD */
2387
2388 }
2389 break;
2390 }
2391 break;
2392 case 0x04:
2393 GETBYTE ();
2394 switch (op[3] & 0x00)
2395 {
2396 case 0x00:
2397 goto op_semantics_8;
2398 break;
2399 }
2400 break;
2401 case 0x05:
2402 GETBYTE ();
2403 switch (op[3] & 0x00)
2404 {
2405 case 0x00:
2406 goto op_semantics_9;
2407 break;
2408 }
2409 break;
2410 case 0x06:
2411 GETBYTE ();
2412 switch (op[3] & 0x00)
2413 {
2414 case 0x00:
2415 goto op_semantics_10;
2416 break;
2417 }
2418 break;
2419 case 0x07:
2420 GETBYTE ();
2421 switch (op[3] & 0x00)
2422 {
2423 case 0x00:
2424 goto op_semantics_11;
2425 break;
2426 }
2427 break;
2428 case 0x08:
2429 GETBYTE ();
2430 switch (op[3] & 0x00)
2431 {
2432 case 0x00:
2433 goto op_semantics_12;
2434 break;
2435 }
2436 break;
2437 case 0x09:
2438 GETBYTE ();
2439 switch (op[3] & 0x00)
2440 {
2441 case 0x00:
2442 goto op_semantics_13;
2443 break;
2444 }
2445 break;
2446 case 0x0c:
2447 GETBYTE ();
2448 switch (op[3] & 0x00)
2449 {
2450 case 0x00:
2451 goto op_semantics_14;
2452 break;
2453 }
2454 break;
2455 case 0x0d:
2456 GETBYTE ();
2457 switch (op[3] & 0x00)
2458 {
2459 case 0x00:
2460 goto op_semantics_15;
2461 break;
2462 }
2463 break;
2464 case 0x10:
2465 GETBYTE ();
2466 switch (op[3] & 0x00)
2467 {
2468 case 0x00:
2469 goto op_semantics_16;
2470 break;
2471 }
2472 break;
2473 case 0x11:
2474 GETBYTE ();
2475 switch (op[3] & 0x00)
2476 {
2477 case 0x00:
2478 goto op_semantics_17;
2479 break;
2480 }
2481 break;
2482 default: UNSUPPORTED(); break;
2483 }
2484 break;
2485 case 0xa1:
2486 GETBYTE ();
2487 switch (op[2] & 0xff)
2488 {
2489 case 0x00:
2490 GETBYTE ();
2491 switch (op[3] & 0x00)
2492 {
2493 case 0x00:
2494 goto op_semantics_7;
2495 break;
2496 }
2497 break;
2498 case 0x02:
2499 GETBYTE ();
2500 switch (op[3] & 0x00)
2501 {
2502 case 0x00:
2503 goto op_semantics_18;
2504 break;
2505 }
2506 break;
2507 case 0x04:
2508 GETBYTE ();
2509 switch (op[3] & 0x00)
2510 {
2511 case 0x00:
2512 goto op_semantics_8;
2513 break;
2514 }
2515 break;
2516 case 0x05:
2517 GETBYTE ();
2518 switch (op[3] & 0x00)
2519 {
2520 case 0x00:
2521 goto op_semantics_9;
2522 break;
2523 }
2524 break;
2525 case 0x06:
2526 GETBYTE ();
2527 switch (op[3] & 0x00)
2528 {
2529 case 0x00:
2530 goto op_semantics_10;
2531 break;
2532 }
2533 break;
2534 case 0x07:
2535 GETBYTE ();
2536 switch (op[3] & 0x00)
2537 {
2538 case 0x00:
2539 goto op_semantics_11;
2540 break;
2541 }
2542 break;
2543 case 0x08:
2544 GETBYTE ();
2545 switch (op[3] & 0x00)
2546 {
2547 case 0x00:
2548 goto op_semantics_12;
2549 break;
2550 }
2551 break;
2552 case 0x09:
2553 GETBYTE ();
2554 switch (op[3] & 0x00)
2555 {
2556 case 0x00:
2557 goto op_semantics_13;
2558 break;
2559 }
2560 break;
2561 case 0x0c:
2562 GETBYTE ();
2563 switch (op[3] & 0x00)
2564 {
2565 case 0x00:
2566 goto op_semantics_14;
2567 break;
2568 }
2569 break;
2570 case 0x0d:
2571 GETBYTE ();
2572 switch (op[3] & 0x00)
2573 {
2574 case 0x00:
2575 goto op_semantics_15;
2576 break;
2577 }
2578 break;
2579 case 0x10:
2580 GETBYTE ();
2581 switch (op[3] & 0x00)
2582 {
2583 case 0x00:
2584 goto op_semantics_16;
2585 break;
2586 }
2587 break;
2588 case 0x11:
2589 GETBYTE ();
2590 switch (op[3] & 0x00)
2591 {
2592 case 0x00:
2593 goto op_semantics_17;
2594 break;
2595 }
2596 break;
2597 default: UNSUPPORTED(); break;
2598 }
2599 break;
2600 case 0xa2:
2601 GETBYTE ();
2602 switch (op[2] & 0xff)
2603 {
2604 case 0x00:
2605 GETBYTE ();
2606 switch (op[3] & 0x00)
2607 {
2608 case 0x00:
2609 goto op_semantics_7;
2610 break;
2611 }
2612 break;
2613 case 0x02:
2614 GETBYTE ();
2615 switch (op[3] & 0x00)
2616 {
2617 case 0x00:
2618 goto op_semantics_18;
2619 break;
2620 }
2621 break;
2622 case 0x04:
2623 GETBYTE ();
2624 switch (op[3] & 0x00)
2625 {
2626 case 0x00:
2627 goto op_semantics_8;
2628 break;
2629 }
2630 break;
2631 case 0x05:
2632 GETBYTE ();
2633 switch (op[3] & 0x00)
2634 {
2635 case 0x00:
2636 goto op_semantics_9;
2637 break;
2638 }
2639 break;
2640 case 0x06:
2641 GETBYTE ();
2642 switch (op[3] & 0x00)
2643 {
2644 case 0x00:
2645 goto op_semantics_10;
2646 break;
2647 }
2648 break;
2649 case 0x07:
2650 GETBYTE ();
2651 switch (op[3] & 0x00)
2652 {
2653 case 0x00:
2654 goto op_semantics_11;
2655 break;
2656 }
2657 break;
2658 case 0x08:
2659 GETBYTE ();
2660 switch (op[3] & 0x00)
2661 {
2662 case 0x00:
2663 goto op_semantics_12;
2664 break;
2665 }
2666 break;
2667 case 0x09:
2668 GETBYTE ();
2669 switch (op[3] & 0x00)
2670 {
2671 case 0x00:
2672 goto op_semantics_13;
2673 break;
2674 }
2675 break;
2676 case 0x0c:
2677 GETBYTE ();
2678 switch (op[3] & 0x00)
2679 {
2680 case 0x00:
2681 goto op_semantics_14;
2682 break;
2683 }
2684 break;
2685 case 0x0d:
2686 GETBYTE ();
2687 switch (op[3] & 0x00)
2688 {
2689 case 0x00:
2690 goto op_semantics_15;
2691 break;
2692 }
2693 break;
2694 case 0x10:
2695 GETBYTE ();
2696 switch (op[3] & 0x00)
2697 {
2698 case 0x00:
2699 goto op_semantics_16;
2700 break;
2701 }
2702 break;
2703 case 0x11:
2704 GETBYTE ();
2705 switch (op[3] & 0x00)
2706 {
2707 case 0x00:
2708 goto op_semantics_17;
2709 break;
2710 }
2711 break;
2712 default: UNSUPPORTED(); break;
2713 }
2714 break;
2715 case 0xa3:
2716 GETBYTE ();
2717 switch (op[2] & 0xff)
2718 {
2719 case 0x00:
2720 GETBYTE ();
2721 switch (op[3] & 0x00)
2722 {
2723 case 0x00:
2724 goto op_semantics_7;
2725 break;
2726 }
2727 break;
2728 case 0x02:
2729 GETBYTE ();
2730 switch (op[3] & 0x00)
2731 {
2732 case 0x00:
2733 goto op_semantics_18;
2734 break;
2735 }
2736 break;
2737 case 0x04:
2738 GETBYTE ();
2739 switch (op[3] & 0x00)
2740 {
2741 case 0x00:
2742 goto op_semantics_8;
2743 break;
2744 }
2745 break;
2746 case 0x05:
2747 GETBYTE ();
2748 switch (op[3] & 0x00)
2749 {
2750 case 0x00:
2751 goto op_semantics_9;
2752 break;
2753 }
2754 break;
2755 case 0x06:
2756 GETBYTE ();
2757 switch (op[3] & 0x00)
2758 {
2759 case 0x00:
2760 goto op_semantics_10;
2761 break;
2762 }
2763 break;
2764 case 0x07:
2765 GETBYTE ();
2766 switch (op[3] & 0x00)
2767 {
2768 case 0x00:
2769 goto op_semantics_11;
2770 break;
2771 }
2772 break;
2773 case 0x08:
2774 GETBYTE ();
2775 switch (op[3] & 0x00)
2776 {
2777 case 0x00:
2778 goto op_semantics_12;
2779 break;
2780 }
2781 break;
2782 case 0x09:
2783 GETBYTE ();
2784 switch (op[3] & 0x00)
2785 {
2786 case 0x00:
2787 goto op_semantics_13;
2788 break;
2789 }
2790 break;
2791 case 0x0c:
2792 GETBYTE ();
2793 switch (op[3] & 0x00)
2794 {
2795 case 0x00:
2796 goto op_semantics_14;
2797 break;
2798 }
2799 break;
2800 case 0x0d:
2801 GETBYTE ();
2802 switch (op[3] & 0x00)
2803 {
2804 case 0x00:
2805 goto op_semantics_15;
2806 break;
2807 }
2808 break;
2809 case 0x10:
2810 GETBYTE ();
2811 switch (op[3] & 0x00)
2812 {
2813 case 0x00:
2814 goto op_semantics_16;
2815 break;
2816 }
2817 break;
2818 case 0x11:
2819 GETBYTE ();
2820 switch (op[3] & 0x00)
2821 {
2822 case 0x00:
2823 goto op_semantics_17;
2824 break;
2825 }
2826 break;
2827 default: UNSUPPORTED(); break;
2828 }
2829 break;
2830 case 0xc0:
2831 GETBYTE ();
2832 switch (op[2] & 0x00)
2833 {
2834 case 0x00:
2835 goto op_semantics_1;
2836 break;
2837 }
2838 break;
2839 case 0xc1:
2840 GETBYTE ();
2841 switch (op[2] & 0x00)
2842 {
2843 case 0x00:
2844 goto op_semantics_1;
2845 break;
2846 }
2847 break;
2848 case 0xc2:
2849 GETBYTE ();
2850 switch (op[2] & 0x00)
2851 {
2852 case 0x00:
2853 goto op_semantics_1;
2854 break;
2855 }
2856 break;
2857 case 0xc3:
2858 GETBYTE ();
2859 switch (op[2] & 0x00)
2860 {
2861 case 0x00:
2862 goto op_semantics_1;
2863 break;
2864 }
2865 break;
2866 case 0xc4:
2867 GETBYTE ();
2868 switch (op[2] & 0x00)
2869 {
2870 case 0x00:
2871 goto op_semantics_2;
2872 break;
2873 }
2874 break;
2875 case 0xc5:
2876 GETBYTE ();
2877 switch (op[2] & 0x00)
2878 {
2879 case 0x00:
2880 goto op_semantics_2;
2881 break;
2882 }
2883 break;
2884 case 0xc6:
2885 GETBYTE ();
2886 switch (op[2] & 0x00)
2887 {
2888 case 0x00:
2889 goto op_semantics_2;
2890 break;
2891 }
2892 break;
2893 case 0xc7:
2894 GETBYTE ();
2895 switch (op[2] & 0x00)
2896 {
2897 case 0x00:
2898 goto op_semantics_2;
2899 break;
2900 }
2901 break;
2902 case 0xc8:
2903 GETBYTE ();
2904 switch (op[2] & 0x00)
2905 {
2906 case 0x00:
2907 goto op_semantics_3;
2908 break;
2909 }
2910 break;
2911 case 0xc9:
2912 GETBYTE ();
2913 switch (op[2] & 0x00)
2914 {
2915 case 0x00:
2916 goto op_semantics_3;
2917 break;
2918 }
2919 break;
2920 case 0xca:
2921 GETBYTE ();
2922 switch (op[2] & 0x00)
2923 {
2924 case 0x00:
2925 goto op_semantics_3;
2926 break;
2927 }
2928 break;
2929 case 0xcb:
2930 GETBYTE ();
2931 switch (op[2] & 0x00)
2932 {
2933 case 0x00:
2934 goto op_semantics_3;
2935 break;
2936 }
2937 break;
2938 case 0xcc:
2939 GETBYTE ();
2940 switch (op[2] & 0x00)
2941 {
2942 case 0x00:
2943 goto op_semantics_4;
2944 break;
2945 }
2946 break;
2947 case 0xcd:
2948 GETBYTE ();
2949 switch (op[2] & 0x00)
2950 {
2951 case 0x00:
2952 goto op_semantics_4;
2953 break;
2954 }
2955 break;
2956 case 0xce:
2957 GETBYTE ();
2958 switch (op[2] & 0x00)
2959 {
2960 case 0x00:
2961 goto op_semantics_4;
2962 break;
2963 }
2964 break;
2965 case 0xcf:
2966 GETBYTE ();
2967 switch (op[2] & 0x00)
2968 {
2969 case 0x00:
2970 goto op_semantics_4;
2971 break;
2972 }
2973 break;
2974 case 0xd0:
2975 GETBYTE ();
2976 switch (op[2] & 0x00)
2977 {
2978 case 0x00:
2979 goto op_semantics_5;
2980 break;
2981 }
2982 break;
2983 case 0xd1:
2984 GETBYTE ();
2985 switch (op[2] & 0x00)
2986 {
2987 case 0x00:
2988 goto op_semantics_5;
2989 break;
2990 }
2991 break;
2992 case 0xd2:
2993 GETBYTE ();
2994 switch (op[2] & 0x00)
2995 {
2996 case 0x00:
2997 goto op_semantics_5;
2998 break;
2999 }
3000 break;
3001 case 0xd3:
3002 GETBYTE ();
3003 switch (op[2] & 0x00)
3004 {
3005 case 0x00:
3006 goto op_semantics_5;
3007 break;
3008 }
3009 break;
3010 case 0xd4:
3011 GETBYTE ();
3012 switch (op[2] & 0x00)
3013 {
3014 case 0x00:
3015 goto op_semantics_6;
3016 break;
3017 }
3018 break;
3019 case 0xd5:
3020 GETBYTE ();
3021 switch (op[2] & 0x00)
3022 {
3023 case 0x00:
3024 goto op_semantics_6;
3025 break;
3026 }
3027 break;
3028 case 0xd6:
3029 GETBYTE ();
3030 switch (op[2] & 0x00)
3031 {
3032 case 0x00:
3033 goto op_semantics_6;
3034 break;
3035 }
3036 break;
3037 case 0xd7:
3038 GETBYTE ();
3039 switch (op[2] & 0x00)
3040 {
3041 case 0x00:
3042 goto op_semantics_6;
3043 break;
3044 }
3045 break;
3046 case 0xe0:
3047 GETBYTE ();
3048 switch (op[2] & 0xff)
3049 {
3050 case 0x00:
3051 GETBYTE ();
3052 switch (op[3] & 0x00)
3053 {
3054 case 0x00:
3055 goto op_semantics_7;
3056 break;
3057 }
3058 break;
3059 case 0x04:
3060 GETBYTE ();
3061 switch (op[3] & 0x00)
3062 {
3063 case 0x00:
3064 goto op_semantics_8;
3065 break;
3066 }
3067 break;
3068 case 0x05:
3069 GETBYTE ();
3070 switch (op[3] & 0x00)
3071 {
3072 case 0x00:
3073 goto op_semantics_9;
3074 break;
3075 }
3076 break;
3077 case 0x06:
3078 GETBYTE ();
3079 switch (op[3] & 0x00)
3080 {
3081 case 0x00:
3082 goto op_semantics_10;
3083 break;
3084 }
3085 break;
3086 case 0x07:
3087 GETBYTE ();
3088 switch (op[3] & 0x00)
3089 {
3090 case 0x00:
3091 goto op_semantics_11;
3092 break;
3093 }
3094 break;
3095 case 0x08:
3096 GETBYTE ();
3097 switch (op[3] & 0x00)
3098 {
3099 case 0x00:
3100 goto op_semantics_12;
3101 break;
3102 }
3103 break;
3104 case 0x09:
3105 GETBYTE ();
3106 switch (op[3] & 0x00)
3107 {
3108 case 0x00:
3109 goto op_semantics_13;
3110 break;
3111 }
3112 break;
3113 case 0x0c:
3114 GETBYTE ();
3115 switch (op[3] & 0x00)
3116 {
3117 case 0x00:
3118 goto op_semantics_14;
3119 break;
3120 }
3121 break;
3122 case 0x0d:
3123 GETBYTE ();
3124 switch (op[3] & 0x00)
3125 {
3126 case 0x00:
3127 goto op_semantics_15;
3128 break;
3129 }
3130 break;
3131 case 0x10:
3132 GETBYTE ();
3133 switch (op[3] & 0x00)
3134 {
3135 case 0x00:
3136 goto op_semantics_16;
3137 break;
3138 }
3139 break;
3140 case 0x11:
3141 GETBYTE ();
3142 switch (op[3] & 0x00)
3143 {
3144 case 0x00:
3145 goto op_semantics_17;
3146 break;
3147 }
3148 break;
3149 default: UNSUPPORTED(); break;
3150 }
3151 break;
3152 case 0xe1:
3153 GETBYTE ();
3154 switch (op[2] & 0xff)
3155 {
3156 case 0x00:
3157 GETBYTE ();
3158 switch (op[3] & 0x00)
3159 {
3160 case 0x00:
3161 goto op_semantics_7;
3162 break;
3163 }
3164 break;
3165 case 0x04:
3166 GETBYTE ();
3167 switch (op[3] & 0x00)
3168 {
3169 case 0x00:
3170 goto op_semantics_8;
3171 break;
3172 }
3173 break;
3174 case 0x05:
3175 GETBYTE ();
3176 switch (op[3] & 0x00)
3177 {
3178 case 0x00:
3179 goto op_semantics_9;
3180 break;
3181 }
3182 break;
3183 case 0x06:
3184 GETBYTE ();
3185 switch (op[3] & 0x00)
3186 {
3187 case 0x00:
3188 goto op_semantics_10;
3189 break;
3190 }
3191 break;
3192 case 0x07:
3193 GETBYTE ();
3194 switch (op[3] & 0x00)
3195 {
3196 case 0x00:
3197 goto op_semantics_11;
3198 break;
3199 }
3200 break;
3201 case 0x08:
3202 GETBYTE ();
3203 switch (op[3] & 0x00)
3204 {
3205 case 0x00:
3206 goto op_semantics_12;
3207 break;
3208 }
3209 break;
3210 case 0x09:
3211 GETBYTE ();
3212 switch (op[3] & 0x00)
3213 {
3214 case 0x00:
3215 goto op_semantics_13;
3216 break;
3217 }
3218 break;
3219 case 0x0c:
3220 GETBYTE ();
3221 switch (op[3] & 0x00)
3222 {
3223 case 0x00:
3224 goto op_semantics_14;
3225 break;
3226 }
3227 break;
3228 case 0x0d:
3229 GETBYTE ();
3230 switch (op[3] & 0x00)
3231 {
3232 case 0x00:
3233 goto op_semantics_15;
3234 break;
3235 }
3236 break;
3237 case 0x10:
3238 GETBYTE ();
3239 switch (op[3] & 0x00)
3240 {
3241 case 0x00:
3242 goto op_semantics_16;
3243 break;
3244 }
3245 break;
3246 case 0x11:
3247 GETBYTE ();
3248 switch (op[3] & 0x00)
3249 {
3250 case 0x00:
3251 goto op_semantics_17;
3252 break;
3253 }
3254 break;
3255 default: UNSUPPORTED(); break;
3256 }
3257 break;
3258 case 0xe2:
3259 GETBYTE ();
3260 switch (op[2] & 0xff)
3261 {
3262 case 0x00:
3263 GETBYTE ();
3264 switch (op[3] & 0x00)
3265 {
3266 case 0x00:
3267 goto op_semantics_7;
3268 break;
3269 }
3270 break;
3271 case 0x04:
3272 GETBYTE ();
3273 switch (op[3] & 0x00)
3274 {
3275 case 0x00:
3276 goto op_semantics_8;
3277 break;
3278 }
3279 break;
3280 case 0x05:
3281 GETBYTE ();
3282 switch (op[3] & 0x00)
3283 {
3284 case 0x00:
3285 goto op_semantics_9;
3286 break;
3287 }
3288 break;
3289 case 0x06:
3290 GETBYTE ();
3291 switch (op[3] & 0x00)
3292 {
3293 case 0x00:
3294 goto op_semantics_10;
3295 break;
3296 }
3297 break;
3298 case 0x07:
3299 GETBYTE ();
3300 switch (op[3] & 0x00)
3301 {
3302 case 0x00:
3303 goto op_semantics_11;
3304 break;
3305 }
3306 break;
3307 case 0x08:
3308 GETBYTE ();
3309 switch (op[3] & 0x00)
3310 {
3311 case 0x00:
3312 goto op_semantics_12;
3313 break;
3314 }
3315 break;
3316 case 0x09:
3317 GETBYTE ();
3318 switch (op[3] & 0x00)
3319 {
3320 case 0x00:
3321 goto op_semantics_13;
3322 break;
3323 }
3324 break;
3325 case 0x0c:
3326 GETBYTE ();
3327 switch (op[3] & 0x00)
3328 {
3329 case 0x00:
3330 goto op_semantics_14;
3331 break;
3332 }
3333 break;
3334 case 0x0d:
3335 GETBYTE ();
3336 switch (op[3] & 0x00)
3337 {
3338 case 0x00:
3339 goto op_semantics_15;
3340 break;
3341 }
3342 break;
3343 case 0x10:
3344 GETBYTE ();
3345 switch (op[3] & 0x00)
3346 {
3347 case 0x00:
3348 goto op_semantics_16;
3349 break;
3350 }
3351 break;
3352 case 0x11:
3353 GETBYTE ();
3354 switch (op[3] & 0x00)
3355 {
3356 case 0x00:
3357 goto op_semantics_17;
3358 break;
3359 }
3360 break;
3361 default: UNSUPPORTED(); break;
3362 }
3363 break;
3364 case 0xe3:
3365 GETBYTE ();
3366 switch (op[2] & 0xff)
3367 {
3368 case 0x00:
3369 GETBYTE ();
3370 switch (op[3] & 0x00)
3371 {
3372 case 0x00:
3373 goto op_semantics_7;
3374 break;
3375 }
3376 break;
3377 case 0x04:
3378 GETBYTE ();
3379 switch (op[3] & 0x00)
3380 {
3381 case 0x00:
3382 goto op_semantics_8;
3383 break;
3384 }
3385 break;
3386 case 0x05:
3387 GETBYTE ();
3388 switch (op[3] & 0x00)
3389 {
3390 case 0x00:
3391 goto op_semantics_9;
3392 break;
3393 }
3394 break;
3395 case 0x06:
3396 GETBYTE ();
3397 switch (op[3] & 0x00)
3398 {
3399 case 0x00:
3400 goto op_semantics_10;
3401 break;
3402 }
3403 break;
3404 case 0x07:
3405 GETBYTE ();
3406 switch (op[3] & 0x00)
3407 {
3408 case 0x00:
3409 goto op_semantics_11;
3410 break;
3411 }
3412 break;
3413 case 0x08:
3414 GETBYTE ();
3415 switch (op[3] & 0x00)
3416 {
3417 case 0x00:
3418 goto op_semantics_12;
3419 break;
3420 }
3421 break;
3422 case 0x09:
3423 GETBYTE ();
3424 switch (op[3] & 0x00)
3425 {
3426 case 0x00:
3427 goto op_semantics_13;
3428 break;
3429 }
3430 break;
3431 case 0x0c:
3432 GETBYTE ();
3433 switch (op[3] & 0x00)
3434 {
3435 case 0x00:
3436 goto op_semantics_14;
3437 break;
3438 }
3439 break;
3440 case 0x0d:
3441 GETBYTE ();
3442 switch (op[3] & 0x00)
3443 {
3444 case 0x00:
3445 goto op_semantics_15;
3446 break;
3447 }
3448 break;
3449 case 0x10:
3450 GETBYTE ();
3451 switch (op[3] & 0x00)
3452 {
3453 case 0x00:
3454 goto op_semantics_16;
3455 break;
3456 }
3457 break;
3458 case 0x11:
3459 GETBYTE ();
3460 switch (op[3] & 0x00)
3461 {
3462 case 0x00:
3463 goto op_semantics_17;
3464 break;
3465 }
3466 break;
3467 default: UNSUPPORTED(); break;
3468 }
3469 break;
3470 default: UNSUPPORTED(); break;
3471 }
3472 break;
3473 case 0x08:
3474 case 0x09:
3475 case 0x0a:
3476 case 0x0b:
3477 case 0x0c:
3478 case 0x0d:
3479 case 0x0e:
3480 case 0x0f:
3481 {
3482 /** 0000 1dsp bra.s %a0 */
3483 #line 708 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3484 int dsp AU = op[0] & 0x07;
3485 if (trace)
3486 {
3487 printf ("\033[33m%s\033[0m %02x\n",
3488 "/** 0000 1dsp bra.s %a0 */",
3489 op[0]);
3490 printf (" dsp = 0x%x\n", dsp);
3491 }
3492 SYNTAX("bra.s %a0");
3493 #line 709 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3494 ID(branch); Scc(RXC_always); DC(pc + dsp3map[dsp]);
3495
3496 }
3497 break;
3498 case 0x10:
3499 case 0x11:
3500 case 0x12:
3501 case 0x13:
3502 case 0x14:
3503 case 0x15:
3504 case 0x16:
3505 case 0x17:
3506 case 0x18:
3507 case 0x19:
3508 case 0x1a:
3509 case 0x1b:
3510 case 0x1c:
3511 case 0x1d:
3512 case 0x1e:
3513 case 0x1f:
3514 {
3515 /** 0001 n dsp b%1.s %a0 */
3516 #line 698 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3517 int n AU = (op[0] >> 3) & 0x01;
3518 #line 698 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3519 int dsp AU = op[0] & 0x07;
3520 if (trace)
3521 {
3522 printf ("\033[33m%s\033[0m %02x\n",
3523 "/** 0001 n dsp b%1.s %a0 */",
3524 op[0]);
3525 printf (" n = 0x%x,", n);
3526 printf (" dsp = 0x%x\n", dsp);
3527 }
3528 SYNTAX("b%1.s %a0");
3529 #line 699 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3530 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3531
3532 }
3533 break;
3534 case 0x20:
3535 case 0x21:
3536 case 0x22:
3537 case 0x23:
3538 case 0x24:
3539 case 0x25:
3540 case 0x26:
3541 case 0x27:
3542 case 0x28:
3543 case 0x29:
3544 case 0x2a:
3545 case 0x2b:
3546 case 0x2c:
3547 case 0x2d:
3548 case 0x2f:
3549 {
3550 /** 0010 cond b%1.b %a0 */
3551 #line 701 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3552 int cond AU = op[0] & 0x0f;
3553 if (trace)
3554 {
3555 printf ("\033[33m%s\033[0m %02x\n",
3556 "/** 0010 cond b%1.b %a0 */",
3557 op[0]);
3558 printf (" cond = 0x%x\n", cond);
3559 }
3560 SYNTAX("b%1.b %a0");
3561 #line 702 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3562 ID(branch); Scc(cond); DC(pc + IMMex (1));
3563
3564 }
3565 break;
3566 case 0x2e:
3567 {
3568 /** 0010 1110 bra.b %a0 */
3569 if (trace)
3570 {
3571 printf ("\033[33m%s\033[0m %02x\n",
3572 "/** 0010 1110 bra.b %a0 */",
3573 op[0]);
3574 }
3575 SYNTAX("bra.b %a0");
3576 #line 712 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3577 ID(branch); Scc(RXC_always); DC(pc + IMMex(1));
3578
3579 }
3580 break;
3581 case 0x38:
3582 {
3583 /** 0011 1000 bra.w %a0 */
3584 if (trace)
3585 {
3586 printf ("\033[33m%s\033[0m %02x\n",
3587 "/** 0011 1000 bra.w %a0 */",
3588 op[0]);
3589 }
3590 SYNTAX("bra.w %a0");
3591 #line 715 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3592 ID(branch); Scc(RXC_always); DC(pc + IMMex(2));
3593
3594 }
3595 break;
3596 case 0x39:
3597 {
3598 /** 0011 1001 bsr.w %a0 */
3599 if (trace)
3600 {
3601 printf ("\033[33m%s\033[0m %02x\n",
3602 "/** 0011 1001 bsr.w %a0 */",
3603 op[0]);
3604 }
3605 SYNTAX("bsr.w %a0");
3606 #line 731 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3607 ID(jsr); DC(pc + IMMex(2));
3608
3609 }
3610 break;
3611 case 0x3a:
3612 case 0x3b:
3613 {
3614 /** 0011 101c b%1.w %a0 */
3615 #line 704 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3616 int c AU = op[0] & 0x01;
3617 if (trace)
3618 {
3619 printf ("\033[33m%s\033[0m %02x\n",
3620 "/** 0011 101c b%1.w %a0 */",
3621 op[0]);
3622 printf (" c = 0x%x\n", c);
3623 }
3624 SYNTAX("b%1.w %a0");
3625 #line 705 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3626 ID(branch); Scc(c); DC(pc + IMMex (2));
3627
3628
3629 }
3630 break;
3631 case 0x3c:
3632 GETBYTE ();
3633 switch (op[1] & 0x00)
3634 {
3635 case 0x00:
3636 op_semantics_19:
3637 {
3638 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3639 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3640 int sz AU = op[0] & 0x03;
3641 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3642 int d AU = (op[1] >> 7) & 0x01;
3643 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3644 int dst AU = (op[1] >> 4) & 0x07;
3645 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3646 int sppp AU = op[1] & 0x0f;
3647 if (trace)
3648 {
3649 printf ("\033[33m%s\033[0m %02x %02x\n",
3650 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3651 op[0], op[1]);
3652 printf (" sz = 0x%x,", sz);
3653 printf (" d = 0x%x,", d);
3654 printf (" dst = 0x%x,", dst);
3655 printf (" sppp = 0x%x\n", sppp);
3656 }
3657 SYNTAX("mov%s #%1, %0");
3658 #line 295 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3659 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F("----");
3660
3661 }
3662 break;
3663 }
3664 break;
3665 case 0x3d:
3666 GETBYTE ();
3667 switch (op[1] & 0x00)
3668 {
3669 case 0x00:
3670 goto op_semantics_19;
3671 break;
3672 }
3673 break;
3674 case 0x3e:
3675 GETBYTE ();
3676 switch (op[1] & 0x00)
3677 {
3678 case 0x00:
3679 goto op_semantics_19;
3680 break;
3681 }
3682 break;
3683 case 0x3f:
3684 GETBYTE ();
3685 switch (op[1] & 0x00)
3686 {
3687 case 0x00:
3688 {
3689 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3690 #line 383 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3691 int rega AU = (op[1] >> 4) & 0x0f;
3692 #line 383 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3693 int regb AU = op[1] & 0x0f;
3694 if (trace)
3695 {
3696 printf ("\033[33m%s\033[0m %02x %02x\n",
3697 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */",
3698 op[0], op[1]);
3699 printf (" rega = 0x%x,", rega);
3700 printf (" regb = 0x%x\n", regb);
3701 }
3702 SYNTAX("rtsd #%1, %2-%0");
3703 #line 384 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3704 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3705
3706 /*----------------------------------------------------------------------*/
3707 /* AND */
3708
3709 }
3710 break;
3711 }
3712 break;
3713 case 0x40:
3714 GETBYTE ();
3715 switch (op[1] & 0x00)
3716 {
3717 case 0x00:
3718 op_semantics_20:
3719 {
3720 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3721 #line 518 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3722 int ss AU = op[0] & 0x03;
3723 #line 518 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3724 int rsrc AU = (op[1] >> 4) & 0x0f;
3725 #line 518 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3726 int rdst AU = op[1] & 0x0f;
3727 if (trace)
3728 {
3729 printf ("\033[33m%s\033[0m %02x %02x\n",
3730 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3731 op[0], op[1]);
3732 printf (" ss = 0x%x,", ss);
3733 printf (" rsrc = 0x%x,", rsrc);
3734 printf (" rdst = 0x%x\n", rdst);
3735 }
3736 SYNTAX("sub %2%S2, %1");
3737 #line 519 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3738 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F("OSZC");
3739
3740 }
3741 break;
3742 }
3743 break;
3744 case 0x41:
3745 GETBYTE ();
3746 switch (op[1] & 0x00)
3747 {
3748 case 0x00:
3749 goto op_semantics_20;
3750 break;
3751 }
3752 break;
3753 case 0x42:
3754 GETBYTE ();
3755 switch (op[1] & 0x00)
3756 {
3757 case 0x00:
3758 goto op_semantics_20;
3759 break;
3760 }
3761 break;
3762 case 0x43:
3763 GETBYTE ();
3764 switch (op[1] & 0x00)
3765 {
3766 case 0x00:
3767 goto op_semantics_20;
3768 break;
3769 }
3770 break;
3771 case 0x44:
3772 GETBYTE ();
3773 switch (op[1] & 0x00)
3774 {
3775 case 0x00:
3776 op_semantics_21:
3777 {
3778 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3779 #line 506 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3780 int ss AU = op[0] & 0x03;
3781 #line 506 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3782 int rsrc AU = (op[1] >> 4) & 0x0f;
3783 #line 506 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3784 int rdst AU = op[1] & 0x0f;
3785 if (trace)
3786 {
3787 printf ("\033[33m%s\033[0m %02x %02x\n",
3788 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */",
3789 op[0], op[1]);
3790 printf (" ss = 0x%x,", ss);
3791 printf (" rsrc = 0x%x,", rsrc);
3792 printf (" rdst = 0x%x\n", rdst);
3793 }
3794 SYNTAX("cmp %2%S2, %1");
3795 #line 507 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3796 ID(sub); S2P(ss, rsrc); SR(rdst); F("OSZC");
3797
3798 }
3799 break;
3800 }
3801 break;
3802 case 0x45:
3803 GETBYTE ();
3804 switch (op[1] & 0x00)
3805 {
3806 case 0x00:
3807 goto op_semantics_21;
3808 break;
3809 }
3810 break;
3811 case 0x46:
3812 GETBYTE ();
3813 switch (op[1] & 0x00)
3814 {
3815 case 0x00:
3816 goto op_semantics_21;
3817 break;
3818 }
3819 break;
3820 case 0x47:
3821 GETBYTE ();
3822 switch (op[1] & 0x00)
3823 {
3824 case 0x00:
3825 goto op_semantics_21;
3826 break;
3827 }
3828 break;
3829 case 0x48:
3830 GETBYTE ();
3831 switch (op[1] & 0x00)
3832 {
3833 case 0x00:
3834 op_semantics_22:
3835 {
3836 /** 0100 10ss rsrc rdst add %1%S1, %0 */
3837 #line 482 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3838 int ss AU = op[0] & 0x03;
3839 #line 482 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3840 int rsrc AU = (op[1] >> 4) & 0x0f;
3841 #line 482 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3842 int rdst AU = op[1] & 0x0f;
3843 if (trace)
3844 {
3845 printf ("\033[33m%s\033[0m %02x %02x\n",
3846 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3847 op[0], op[1]);
3848 printf (" ss = 0x%x,", ss);
3849 printf (" rsrc = 0x%x,", rsrc);
3850 printf (" rdst = 0x%x\n", rdst);
3851 }
3852 SYNTAX("add %1%S1, %0");
3853 #line 483 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3854 ID(add); SP(ss, rsrc); DR(rdst); F("OSZC");
3855
3856 }
3857 break;
3858 }
3859 break;
3860 case 0x49:
3861 GETBYTE ();
3862 switch (op[1] & 0x00)
3863 {
3864 case 0x00:
3865 goto op_semantics_22;
3866 break;
3867 }
3868 break;
3869 case 0x4a:
3870 GETBYTE ();
3871 switch (op[1] & 0x00)
3872 {
3873 case 0x00:
3874 goto op_semantics_22;
3875 break;
3876 }
3877 break;
3878 case 0x4b:
3879 GETBYTE ();
3880 switch (op[1] & 0x00)
3881 {
3882 case 0x00:
3883 goto op_semantics_22;
3884 break;
3885 }
3886 break;
3887 case 0x4c:
3888 GETBYTE ();
3889 switch (op[1] & 0x00)
3890 {
3891 case 0x00:
3892 op_semantics_23:
3893 {
3894 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
3895 #line 579 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3896 int ss AU = op[0] & 0x03;
3897 #line 579 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3898 int rsrc AU = (op[1] >> 4) & 0x0f;
3899 #line 579 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3900 int rdst AU = op[1] & 0x0f;
3901 if (trace)
3902 {
3903 printf ("\033[33m%s\033[0m %02x %02x\n",
3904 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3905 op[0], op[1]);
3906 printf (" ss = 0x%x,", ss);
3907 printf (" rsrc = 0x%x,", rsrc);
3908 printf (" rdst = 0x%x\n", rdst);
3909 }
3910 SYNTAX("mul %1%S1, %0");
3911 #line 580 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3912 ID(mul); SP(ss, rsrc); DR(rdst); F("O---");
3913
3914 }
3915 break;
3916 }
3917 break;
3918 case 0x4d:
3919 GETBYTE ();
3920 switch (op[1] & 0x00)
3921 {
3922 case 0x00:
3923 goto op_semantics_23;
3924 break;
3925 }
3926 break;
3927 case 0x4e:
3928 GETBYTE ();
3929 switch (op[1] & 0x00)
3930 {
3931 case 0x00:
3932 goto op_semantics_23;
3933 break;
3934 }
3935 break;
3936 case 0x4f:
3937 GETBYTE ();
3938 switch (op[1] & 0x00)
3939 {
3940 case 0x00:
3941 goto op_semantics_23;
3942 break;
3943 }
3944 break;
3945 case 0x50:
3946 GETBYTE ();
3947 switch (op[1] & 0x00)
3948 {
3949 case 0x00:
3950 op_semantics_24:
3951 {
3952 /** 0101 00ss rsrc rdst and %1%S1, %0 */
3953 #line 395 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3954 int ss AU = op[0] & 0x03;
3955 #line 395 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3956 int rsrc AU = (op[1] >> 4) & 0x0f;
3957 #line 395 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3958 int rdst AU = op[1] & 0x0f;
3959 if (trace)
3960 {
3961 printf ("\033[33m%s\033[0m %02x %02x\n",
3962 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3963 op[0], op[1]);
3964 printf (" ss = 0x%x,", ss);
3965 printf (" rsrc = 0x%x,", rsrc);
3966 printf (" rdst = 0x%x\n", rdst);
3967 }
3968 SYNTAX("and %1%S1, %0");
3969 #line 396 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3970 ID(and); SP(ss, rsrc); DR(rdst); F("-SZ-");
3971
3972 }
3973 break;
3974 }
3975 break;
3976 case 0x51:
3977 GETBYTE ();
3978 switch (op[1] & 0x00)
3979 {
3980 case 0x00:
3981 goto op_semantics_24;
3982 break;
3983 }
3984 break;
3985 case 0x52:
3986 GETBYTE ();
3987 switch (op[1] & 0x00)
3988 {
3989 case 0x00:
3990 goto op_semantics_24;
3991 break;
3992 }
3993 break;
3994 case 0x53:
3995 GETBYTE ();
3996 switch (op[1] & 0x00)
3997 {
3998 case 0x00:
3999 goto op_semantics_24;
4000 break;
4001 }
4002 break;
4003 case 0x54:
4004 GETBYTE ();
4005 switch (op[1] & 0x00)
4006 {
4007 case 0x00:
4008 op_semantics_25:
4009 {
4010 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4011 #line 413 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4012 int ss AU = op[0] & 0x03;
4013 #line 413 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4014 int rsrc AU = (op[1] >> 4) & 0x0f;
4015 #line 413 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4016 int rdst AU = op[1] & 0x0f;
4017 if (trace)
4018 {
4019 printf ("\033[33m%s\033[0m %02x %02x\n",
4020 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
4021 op[0], op[1]);
4022 printf (" ss = 0x%x,", ss);
4023 printf (" rsrc = 0x%x,", rsrc);
4024 printf (" rdst = 0x%x\n", rdst);
4025 }
4026 SYNTAX("or %1%S1, %0");
4027 #line 414 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4028 ID(or); SP(ss, rsrc); DR(rdst); F("-SZ-");
4029
4030 }
4031 break;
4032 }
4033 break;
4034 case 0x55:
4035 GETBYTE ();
4036 switch (op[1] & 0x00)
4037 {
4038 case 0x00:
4039 goto op_semantics_25;
4040 break;
4041 }
4042 break;
4043 case 0x56:
4044 GETBYTE ();
4045 switch (op[1] & 0x00)
4046 {
4047 case 0x00:
4048 goto op_semantics_25;
4049 break;
4050 }
4051 break;
4052 case 0x57:
4053 GETBYTE ();
4054 switch (op[1] & 0x00)
4055 {
4056 case 0x00:
4057 goto op_semantics_25;
4058 break;
4059 }
4060 break;
4061 case 0x58:
4062 GETBYTE ();
4063 switch (op[1] & 0x00)
4064 {
4065 case 0x00:
4066 op_semantics_26:
4067 {
4068 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4069 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4070 int s AU = (op[0] >> 2) & 0x01;
4071 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4072 int ss AU = op[0] & 0x03;
4073 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4074 int rsrc AU = (op[1] >> 4) & 0x0f;
4075 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4076 int rdst AU = op[1] & 0x0f;
4077 if (trace)
4078 {
4079 printf ("\033[33m%s\033[0m %02x %02x\n",
4080 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4081 op[0], op[1]);
4082 printf (" s = 0x%x,", s);
4083 printf (" ss = 0x%x,", ss);
4084 printf (" rsrc = 0x%x,", rsrc);
4085 printf (" rdst = 0x%x\n", rdst);
4086 }
4087 SYNTAX("movu%s %1, %0");
4088 #line 335 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4089 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F("----");
4090
4091 }
4092 break;
4093 }
4094 break;
4095 case 0x59:
4096 GETBYTE ();
4097 switch (op[1] & 0x00)
4098 {
4099 case 0x00:
4100 goto op_semantics_26;
4101 break;
4102 }
4103 break;
4104 case 0x5a:
4105 GETBYTE ();
4106 switch (op[1] & 0x00)
4107 {
4108 case 0x00:
4109 goto op_semantics_26;
4110 break;
4111 }
4112 break;
4113 case 0x5b:
4114 GETBYTE ();
4115 switch (op[1] & 0x00)
4116 {
4117 case 0x00:
4118 goto op_semantics_26;
4119 break;
4120 }
4121 break;
4122 case 0x5c:
4123 GETBYTE ();
4124 switch (op[1] & 0x00)
4125 {
4126 case 0x00:
4127 goto op_semantics_26;
4128 break;
4129 }
4130 break;
4131 case 0x5d:
4132 GETBYTE ();
4133 switch (op[1] & 0x00)
4134 {
4135 case 0x00:
4136 goto op_semantics_26;
4137 break;
4138 }
4139 break;
4140 case 0x5e:
4141 GETBYTE ();
4142 switch (op[1] & 0x00)
4143 {
4144 case 0x00:
4145 goto op_semantics_26;
4146 break;
4147 }
4148 break;
4149 case 0x5f:
4150 GETBYTE ();
4151 switch (op[1] & 0x00)
4152 {
4153 case 0x00:
4154 goto op_semantics_26;
4155 break;
4156 }
4157 break;
4158 case 0x60:
4159 GETBYTE ();
4160 switch (op[1] & 0x00)
4161 {
4162 case 0x00:
4163 {
4164 /** 0110 0000 immm rdst sub #%2, %0 */
4165 #line 515 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4166 int immm AU = (op[1] >> 4) & 0x0f;
4167 #line 515 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4168 int rdst AU = op[1] & 0x0f;
4169 if (trace)
4170 {
4171 printf ("\033[33m%s\033[0m %02x %02x\n",
4172 "/** 0110 0000 immm rdst sub #%2, %0 */",
4173 op[0], op[1]);
4174 printf (" immm = 0x%x,", immm);
4175 printf (" rdst = 0x%x\n", rdst);
4176 }
4177 SYNTAX("sub #%2, %0");
4178 #line 516 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4179 ID(sub); S2C(immm); SR(rdst); DR(rdst); F("OSZC");
4180
4181 }
4182 break;
4183 }
4184 break;
4185 case 0x61:
4186 GETBYTE ();
4187 switch (op[1] & 0x00)
4188 {
4189 case 0x00:
4190 {
4191 /** 0110 0001 immm rdst cmp #%2, %1 */
4192 #line 497 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4193 int immm AU = (op[1] >> 4) & 0x0f;
4194 #line 497 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4195 int rdst AU = op[1] & 0x0f;
4196 if (trace)
4197 {
4198 printf ("\033[33m%s\033[0m %02x %02x\n",
4199 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4200 op[0], op[1]);
4201 printf (" immm = 0x%x,", immm);
4202 printf (" rdst = 0x%x\n", rdst);
4203 }
4204 SYNTAX("cmp #%2, %1");
4205 #line 498 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4206 ID(sub); S2C(immm); SR(rdst); F("OSZC");
4207
4208 }
4209 break;
4210 }
4211 break;
4212 case 0x62:
4213 GETBYTE ();
4214 switch (op[1] & 0x00)
4215 {
4216 case 0x00:
4217 {
4218 /** 0110 0010 immm rdst add #%1, %0 */
4219 #line 479 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4220 int immm AU = (op[1] >> 4) & 0x0f;
4221 #line 479 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4222 int rdst AU = op[1] & 0x0f;
4223 if (trace)
4224 {
4225 printf ("\033[33m%s\033[0m %02x %02x\n",
4226 "/** 0110 0010 immm rdst add #%1, %0 */",
4227 op[0], op[1]);
4228 printf (" immm = 0x%x,", immm);
4229 printf (" rdst = 0x%x\n", rdst);
4230 }
4231 SYNTAX("add #%1, %0");
4232 #line 480 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4233 ID(add); SC(immm); DR(rdst); F("OSZC");
4234
4235 }
4236 break;
4237 }
4238 break;
4239 case 0x63:
4240 GETBYTE ();
4241 switch (op[1] & 0x00)
4242 {
4243 case 0x00:
4244 {
4245 /** 0110 0011 immm rdst mul #%1, %0 */
4246 #line 573 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4247 int immm AU = (op[1] >> 4) & 0x0f;
4248 #line 573 "/work/sources/gcc/current/opcodes/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 "/** 0110 0011 immm rdst mul #%1, %0 */",
4254 op[0], op[1]);
4255 printf (" immm = 0x%x,", immm);
4256 printf (" rdst = 0x%x\n", rdst);
4257 }
4258 SYNTAX("mul #%1, %0");
4259 #line 574 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4260 ID(mul); DR(rdst); SC(immm); F("O---");
4261
4262 }
4263 break;
4264 }
4265 break;
4266 case 0x64:
4267 GETBYTE ();
4268 switch (op[1] & 0x00)
4269 {
4270 case 0x00:
4271 {
4272 /** 0110 0100 immm rdst and #%1, %0 */
4273 #line 389 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4274 int immm AU = (op[1] >> 4) & 0x0f;
4275 #line 389 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4276 int rdst AU = op[1] & 0x0f;
4277 if (trace)
4278 {
4279 printf ("\033[33m%s\033[0m %02x %02x\n",
4280 "/** 0110 0100 immm rdst and #%1, %0 */",
4281 op[0], op[1]);
4282 printf (" immm = 0x%x,", immm);
4283 printf (" rdst = 0x%x\n", rdst);
4284 }
4285 SYNTAX("and #%1, %0");
4286 #line 390 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4287 ID(and); SC(immm); DR(rdst); F("-SZ-");
4288
4289 }
4290 break;
4291 }
4292 break;
4293 case 0x65:
4294 GETBYTE ();
4295 switch (op[1] & 0x00)
4296 {
4297 case 0x00:
4298 {
4299 /** 0110 0101 immm rdst or #%1, %0 */
4300 #line 407 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4301 int immm AU = (op[1] >> 4) & 0x0f;
4302 #line 407 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4303 int rdst AU = op[1] & 0x0f;
4304 if (trace)
4305 {
4306 printf ("\033[33m%s\033[0m %02x %02x\n",
4307 "/** 0110 0101 immm rdst or #%1, %0 */",
4308 op[0], op[1]);
4309 printf (" immm = 0x%x,", immm);
4310 printf (" rdst = 0x%x\n", rdst);
4311 }
4312 SYNTAX("or #%1, %0");
4313 #line 408 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4314 ID(or); SC(immm); DR(rdst); F("-SZ-");
4315
4316 }
4317 break;
4318 }
4319 break;
4320 case 0x66:
4321 GETBYTE ();
4322 switch (op[1] & 0x00)
4323 {
4324 case 0x00:
4325 {
4326 /** 0110 0110 immm rdst mov%s #%1, %0 */
4327 #line 291 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4328 int immm AU = (op[1] >> 4) & 0x0f;
4329 #line 291 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4330 int rdst AU = op[1] & 0x0f;
4331 if (trace)
4332 {
4333 printf ("\033[33m%s\033[0m %02x %02x\n",
4334 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4335 op[0], op[1]);
4336 printf (" immm = 0x%x,", immm);
4337 printf (" rdst = 0x%x\n", rdst);
4338 }
4339 SYNTAX("mov%s #%1, %0");
4340 #line 292 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4341 ID(mov); DR(rdst); SC(immm); F("----");
4342
4343 }
4344 break;
4345 }
4346 break;
4347 case 0x67:
4348 {
4349 /** 0110 0111 rtsd #%1 */
4350 if (trace)
4351 {
4352 printf ("\033[33m%s\033[0m %02x\n",
4353 "/** 0110 0111 rtsd #%1 */",
4354 op[0]);
4355 }
4356 SYNTAX("rtsd #%1");
4357 #line 381 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4358 ID(rtsd); SC(IMM(1) * 4);
4359
4360 }
4361 break;
4362 case 0x68:
4363 GETBYTE ();
4364 switch (op[1] & 0x00)
4365 {
4366 case 0x00:
4367 op_semantics_27:
4368 {
4369 /** 0110 100i mmmm rdst shlr #%2, %0 */
4370 #line 659 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4371 int i AU = op[0] & 0x01;
4372 #line 659 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4373 int mmmm AU = (op[1] >> 4) & 0x0f;
4374 #line 659 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4375 int rdst AU = op[1] & 0x0f;
4376 if (trace)
4377 {
4378 printf ("\033[33m%s\033[0m %02x %02x\n",
4379 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4380 op[0], op[1]);
4381 printf (" i = 0x%x,", i);
4382 printf (" mmmm = 0x%x,", mmmm);
4383 printf (" rdst = 0x%x\n", rdst);
4384 }
4385 SYNTAX("shlr #%2, %0");
4386 #line 660 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4387 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("-SZC");
4388
4389 }
4390 break;
4391 }
4392 break;
4393 case 0x69:
4394 GETBYTE ();
4395 switch (op[1] & 0x00)
4396 {
4397 case 0x00:
4398 goto op_semantics_27;
4399 break;
4400 }
4401 break;
4402 case 0x6a:
4403 GETBYTE ();
4404 switch (op[1] & 0x00)
4405 {
4406 case 0x00:
4407 op_semantics_28:
4408 {
4409 /** 0110 101i mmmm rdst shar #%2, %0 */
4410 #line 649 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4411 int i AU = op[0] & 0x01;
4412 #line 649 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4413 int mmmm AU = (op[1] >> 4) & 0x0f;
4414 #line 649 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4415 int rdst AU = op[1] & 0x0f;
4416 if (trace)
4417 {
4418 printf ("\033[33m%s\033[0m %02x %02x\n",
4419 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4420 op[0], op[1]);
4421 printf (" i = 0x%x,", i);
4422 printf (" mmmm = 0x%x,", mmmm);
4423 printf (" rdst = 0x%x\n", rdst);
4424 }
4425 SYNTAX("shar #%2, %0");
4426 #line 650 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4427 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("0SZC");
4428
4429 }
4430 break;
4431 }
4432 break;
4433 case 0x6b:
4434 GETBYTE ();
4435 switch (op[1] & 0x00)
4436 {
4437 case 0x00:
4438 goto op_semantics_28;
4439 break;
4440 }
4441 break;
4442 case 0x6c:
4443 GETBYTE ();
4444 switch (op[1] & 0x00)
4445 {
4446 case 0x00:
4447 op_semantics_29:
4448 {
4449 /** 0110 110i mmmm rdst shll #%2, %0 */
4450 #line 639 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4451 int i AU = op[0] & 0x01;
4452 #line 639 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4453 int mmmm AU = (op[1] >> 4) & 0x0f;
4454 #line 639 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4455 int rdst AU = op[1] & 0x0f;
4456 if (trace)
4457 {
4458 printf ("\033[33m%s\033[0m %02x %02x\n",
4459 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4460 op[0], op[1]);
4461 printf (" i = 0x%x,", i);
4462 printf (" mmmm = 0x%x,", mmmm);
4463 printf (" rdst = 0x%x\n", rdst);
4464 }
4465 SYNTAX("shll #%2, %0");
4466 #line 640 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4467 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("OSZC");
4468
4469 }
4470 break;
4471 }
4472 break;
4473 case 0x6d:
4474 GETBYTE ();
4475 switch (op[1] & 0x00)
4476 {
4477 case 0x00:
4478 goto op_semantics_29;
4479 break;
4480 }
4481 break;
4482 case 0x6e:
4483 GETBYTE ();
4484 switch (op[1] & 0x00)
4485 {
4486 case 0x00:
4487 {
4488 /** 0110 1110 dsta dstb pushm %1-%2 */
4489 #line 347 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4490 int dsta AU = (op[1] >> 4) & 0x0f;
4491 #line 347 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4492 int dstb AU = op[1] & 0x0f;
4493 if (trace)
4494 {
4495 printf ("\033[33m%s\033[0m %02x %02x\n",
4496 "/** 0110 1110 dsta dstb pushm %1-%2 */",
4497 op[0], op[1]);
4498 printf (" dsta = 0x%x,", dsta);
4499 printf (" dstb = 0x%x\n", dstb);
4500 }
4501 SYNTAX("pushm %1-%2");
4502 #line 348 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4503 ID(pushm); SR(dsta); S2R(dstb); F("----");
4504
4505 }
4506 break;
4507 }
4508 break;
4509 case 0x6f:
4510 GETBYTE ();
4511 switch (op[1] & 0x00)
4512 {
4513 case 0x00:
4514 {
4515 /** 0110 1111 dsta dstb popm %1-%2 */
4516 #line 344 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4517 int dsta AU = (op[1] >> 4) & 0x0f;
4518 #line 344 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4519 int dstb AU = op[1] & 0x0f;
4520 if (trace)
4521 {
4522 printf ("\033[33m%s\033[0m %02x %02x\n",
4523 "/** 0110 1111 dsta dstb popm %1-%2 */",
4524 op[0], op[1]);
4525 printf (" dsta = 0x%x,", dsta);
4526 printf (" dstb = 0x%x\n", dstb);
4527 }
4528 SYNTAX("popm %1-%2");
4529 #line 345 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4530 ID(popm); SR(dsta); S2R(dstb); F("----");
4531
4532 }
4533 break;
4534 }
4535 break;
4536 case 0x70:
4537 GETBYTE ();
4538 switch (op[1] & 0x00)
4539 {
4540 case 0x00:
4541 op_semantics_30:
4542 {
4543 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4544 #line 488 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4545 int im AU = op[0] & 0x03;
4546 #line 488 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4547 int rsrc AU = (op[1] >> 4) & 0x0f;
4548 #line 488 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4549 int rdst AU = op[1] & 0x0f;
4550 if (trace)
4551 {
4552 printf ("\033[33m%s\033[0m %02x %02x\n",
4553 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4554 op[0], op[1]);
4555 printf (" im = 0x%x,", im);
4556 printf (" rsrc = 0x%x,", rsrc);
4557 printf (" rdst = 0x%x\n", rdst);
4558 }
4559 SYNTAX("add #%1, %2, %0");
4560 #line 489 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4561 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F("OSZC");
4562
4563 }
4564 break;
4565 }
4566 break;
4567 case 0x71:
4568 GETBYTE ();
4569 switch (op[1] & 0x00)
4570 {
4571 case 0x00:
4572 goto op_semantics_30;
4573 break;
4574 }
4575 break;
4576 case 0x72:
4577 GETBYTE ();
4578 switch (op[1] & 0x00)
4579 {
4580 case 0x00:
4581 goto op_semantics_30;
4582 break;
4583 }
4584 break;
4585 case 0x73:
4586 GETBYTE ();
4587 switch (op[1] & 0x00)
4588 {
4589 case 0x00:
4590 goto op_semantics_30;
4591 break;
4592 }
4593 break;
4594 case 0x74:
4595 GETBYTE ();
4596 switch (op[1] & 0xf0)
4597 {
4598 case 0x00:
4599 op_semantics_31:
4600 {
4601 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4602 #line 500 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4603 int im AU = op[0] & 0x03;
4604 #line 500 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4605 int rsrc AU = op[1] & 0x0f;
4606 if (trace)
4607 {
4608 printf ("\033[33m%s\033[0m %02x %02x\n",
4609 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */",
4610 op[0], op[1]);
4611 printf (" im = 0x%x,", im);
4612 printf (" rsrc = 0x%x\n", rsrc);
4613 }
4614 SYNTAX("cmp #%2, %1%S1");
4615 #line 501 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4616 ID(sub); SR(rsrc); S2C(IMMex(im)); F("OSZC");
4617
4618 }
4619 break;
4620 case 0x10:
4621 op_semantics_32:
4622 {
4623 /** 0111 01im 0001rdst mul #%1, %0 */
4624 #line 576 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4625 int im AU = op[0] & 0x03;
4626 #line 576 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4627 int rdst AU = op[1] & 0x0f;
4628 if (trace)
4629 {
4630 printf ("\033[33m%s\033[0m %02x %02x\n",
4631 "/** 0111 01im 0001rdst mul #%1, %0 */",
4632 op[0], op[1]);
4633 printf (" im = 0x%x,", im);
4634 printf (" rdst = 0x%x\n", rdst);
4635 }
4636 SYNTAX("mul #%1, %0");
4637 #line 577 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4638 ID(mul); DR(rdst); SC(IMMex(im)); F("O---");
4639
4640 }
4641 break;
4642 case 0x20:
4643 op_semantics_33:
4644 {
4645 /** 0111 01im 0010 rdst and #%1, %0 */
4646 #line 392 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4647 int im AU = op[0] & 0x03;
4648 #line 392 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4649 int rdst AU = op[1] & 0x0f;
4650 if (trace)
4651 {
4652 printf ("\033[33m%s\033[0m %02x %02x\n",
4653 "/** 0111 01im 0010 rdst and #%1, %0 */",
4654 op[0], op[1]);
4655 printf (" im = 0x%x,", im);
4656 printf (" rdst = 0x%x\n", rdst);
4657 }
4658 SYNTAX("and #%1, %0");
4659 #line 393 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4660 ID(and); SC(IMMex(im)); DR(rdst); F("-SZ-");
4661
4662 }
4663 break;
4664 case 0x30:
4665 op_semantics_34:
4666 {
4667 /** 0111 01im 0011 rdst or #%1, %0 */
4668 #line 410 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4669 int im AU = op[0] & 0x03;
4670 #line 410 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4671 int rdst AU = op[1] & 0x0f;
4672 if (trace)
4673 {
4674 printf ("\033[33m%s\033[0m %02x %02x\n",
4675 "/** 0111 01im 0011 rdst or #%1, %0 */",
4676 op[0], op[1]);
4677 printf (" im = 0x%x,", im);
4678 printf (" rdst = 0x%x\n", rdst);
4679 }
4680 SYNTAX("or #%1, %0");
4681 #line 411 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4682 ID(or); SC(IMMex(im)); DR(rdst); F("-SZ-");
4683
4684 }
4685 break;
4686 default: UNSUPPORTED(); break;
4687 }
4688 break;
4689 case 0x75:
4690 GETBYTE ();
4691 switch (op[1] & 0xff)
4692 {
4693 case 0x00:
4694 case 0x01:
4695 case 0x02:
4696 case 0x03:
4697 case 0x04:
4698 case 0x05:
4699 case 0x06:
4700 case 0x07:
4701 case 0x08:
4702 case 0x09:
4703 case 0x0a:
4704 case 0x0b:
4705 case 0x0c:
4706 case 0x0d:
4707 case 0x0e:
4708 case 0x0f:
4709 goto op_semantics_31;
4710 break;
4711 case 0x10:
4712 case 0x11:
4713 case 0x12:
4714 case 0x13:
4715 case 0x14:
4716 case 0x15:
4717 case 0x16:
4718 case 0x17:
4719 case 0x18:
4720 case 0x19:
4721 case 0x1a:
4722 case 0x1b:
4723 case 0x1c:
4724 case 0x1d:
4725 case 0x1e:
4726 case 0x1f:
4727 goto op_semantics_32;
4728 break;
4729 case 0x20:
4730 case 0x21:
4731 case 0x22:
4732 case 0x23:
4733 case 0x24:
4734 case 0x25:
4735 case 0x26:
4736 case 0x27:
4737 case 0x28:
4738 case 0x29:
4739 case 0x2a:
4740 case 0x2b:
4741 case 0x2c:
4742 case 0x2d:
4743 case 0x2e:
4744 case 0x2f:
4745 goto op_semantics_33;
4746 break;
4747 case 0x30:
4748 case 0x31:
4749 case 0x32:
4750 case 0x33:
4751 case 0x34:
4752 case 0x35:
4753 case 0x36:
4754 case 0x37:
4755 case 0x38:
4756 case 0x39:
4757 case 0x3a:
4758 case 0x3b:
4759 case 0x3c:
4760 case 0x3d:
4761 case 0x3e:
4762 case 0x3f:
4763 goto op_semantics_34;
4764 break;
4765 case 0x40:
4766 case 0x41:
4767 case 0x42:
4768 case 0x43:
4769 case 0x44:
4770 case 0x45:
4771 case 0x46:
4772 case 0x47:
4773 case 0x48:
4774 case 0x49:
4775 case 0x4a:
4776 case 0x4b:
4777 case 0x4c:
4778 case 0x4d:
4779 case 0x4e:
4780 case 0x4f:
4781 {
4782 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4783 #line 285 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4784 int rdst AU = op[1] & 0x0f;
4785 if (trace)
4786 {
4787 printf ("\033[33m%s\033[0m %02x %02x\n",
4788 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4789 op[0], op[1]);
4790 printf (" rdst = 0x%x\n", rdst);
4791 }
4792 SYNTAX("mov%s #%1, %0");
4793 #line 286 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4794 ID(mov); DR(rdst); SC(IMM (1)); F("----");
4795
4796 }
4797 break;
4798 case 0x50:
4799 case 0x51:
4800 case 0x52:
4801 case 0x53:
4802 case 0x54:
4803 case 0x55:
4804 case 0x56:
4805 case 0x57:
4806 case 0x58:
4807 case 0x59:
4808 case 0x5a:
4809 case 0x5b:
4810 case 0x5c:
4811 case 0x5d:
4812 case 0x5e:
4813 case 0x5f:
4814 {
4815 /** 0111 0101 0101 rsrc cmp #%2, %1 */
4816 #line 503 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4817 int rsrc AU = op[1] & 0x0f;
4818 if (trace)
4819 {
4820 printf ("\033[33m%s\033[0m %02x %02x\n",
4821 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4822 op[0], op[1]);
4823 printf (" rsrc = 0x%x\n", rsrc);
4824 }
4825 SYNTAX("cmp #%2, %1");
4826 #line 504 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4827 ID(sub); SR(rsrc); S2C(IMM(1)); F("OSZC");
4828
4829 }
4830 break;
4831 case 0x60:
4832 {
4833 /** 0111 0101 0110 0000 int #%1 */
4834 if (trace)
4835 {
4836 printf ("\033[33m%s\033[0m %02x %02x\n",
4837 "/** 0111 0101 0110 0000 int #%1 */",
4838 op[0], op[1]);
4839 }
4840 SYNTAX("int #%1");
4841 #line 963 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4842 ID(int); SC(IMM(1));
4843
4844 }
4845 break;
4846 default: UNSUPPORTED(); break;
4847 }
4848 break;
4849 case 0x76:
4850 GETBYTE ();
4851 switch (op[1] & 0xf0)
4852 {
4853 case 0x00:
4854 goto op_semantics_31;
4855 break;
4856 case 0x10:
4857 goto op_semantics_32;
4858 break;
4859 case 0x20:
4860 goto op_semantics_33;
4861 break;
4862 case 0x30:
4863 goto op_semantics_34;
4864 break;
4865 default: UNSUPPORTED(); break;
4866 }
4867 break;
4868 case 0x77:
4869 GETBYTE ();
4870 switch (op[1] & 0xf0)
4871 {
4872 case 0x00:
4873 goto op_semantics_31;
4874 break;
4875 case 0x10:
4876 goto op_semantics_32;
4877 break;
4878 case 0x20:
4879 goto op_semantics_33;
4880 break;
4881 case 0x30:
4882 goto op_semantics_34;
4883 break;
4884 default: UNSUPPORTED(); break;
4885 }
4886 break;
4887 case 0x78:
4888 GETBYTE ();
4889 switch (op[1] & 0x00)
4890 {
4891 case 0x00:
4892 op_semantics_35:
4893 {
4894 /** 0111 100b ittt rdst bset #%1, %0 */
4895 #line 874 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4896 int b AU = op[0] & 0x01;
4897 #line 874 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4898 int ittt AU = (op[1] >> 4) & 0x0f;
4899 #line 874 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4900 int rdst AU = op[1] & 0x0f;
4901 if (trace)
4902 {
4903 printf ("\033[33m%s\033[0m %02x %02x\n",
4904 "/** 0111 100b ittt rdst bset #%1, %0 */",
4905 op[0], op[1]);
4906 printf (" b = 0x%x,", b);
4907 printf (" ittt = 0x%x,", ittt);
4908 printf (" rdst = 0x%x\n", rdst);
4909 }
4910 SYNTAX("bset #%1, %0");
4911 #line 875 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4912 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4913
4914
4915 }
4916 break;
4917 }
4918 break;
4919 case 0x79:
4920 GETBYTE ();
4921 switch (op[1] & 0x00)
4922 {
4923 case 0x00:
4924 goto op_semantics_35;
4925 break;
4926 }
4927 break;
4928 case 0x7a:
4929 GETBYTE ();
4930 switch (op[1] & 0x00)
4931 {
4932 case 0x00:
4933 op_semantics_36:
4934 {
4935 /** 0111 101b ittt rdst bclr #%1, %0 */
4936 #line 884 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4937 int b AU = op[0] & 0x01;
4938 #line 884 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4939 int ittt AU = (op[1] >> 4) & 0x0f;
4940 #line 884 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4941 int rdst AU = op[1] & 0x0f;
4942 if (trace)
4943 {
4944 printf ("\033[33m%s\033[0m %02x %02x\n",
4945 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4946 op[0], op[1]);
4947 printf (" b = 0x%x,", b);
4948 printf (" ittt = 0x%x,", ittt);
4949 printf (" rdst = 0x%x\n", rdst);
4950 }
4951 SYNTAX("bclr #%1, %0");
4952 #line 885 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4953 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4954
4955
4956 }
4957 break;
4958 }
4959 break;
4960 case 0x7b:
4961 GETBYTE ();
4962 switch (op[1] & 0x00)
4963 {
4964 case 0x00:
4965 goto op_semantics_36;
4966 break;
4967 }
4968 break;
4969 case 0x7c:
4970 GETBYTE ();
4971 switch (op[1] & 0x00)
4972 {
4973 case 0x00:
4974 op_semantics_37:
4975 {
4976 /** 0111 110b ittt rdst btst #%2, %1 */
4977 #line 894 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4978 int b AU = op[0] & 0x01;
4979 #line 894 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4980 int ittt AU = (op[1] >> 4) & 0x0f;
4981 #line 894 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4982 int rdst AU = op[1] & 0x0f;
4983 if (trace)
4984 {
4985 printf ("\033[33m%s\033[0m %02x %02x\n",
4986 "/** 0111 110b ittt rdst btst #%2, %1 */",
4987 op[0], op[1]);
4988 printf (" b = 0x%x,", b);
4989 printf (" ittt = 0x%x,", ittt);
4990 printf (" rdst = 0x%x\n", rdst);
4991 }
4992 SYNTAX("btst #%2, %1");
4993 #line 895 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4994 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F("--ZC");
4995
4996
4997 }
4998 break;
4999 }
5000 break;
5001 case 0x7d:
5002 GETBYTE ();
5003 switch (op[1] & 0x00)
5004 {
5005 case 0x00:
5006 goto op_semantics_37;
5007 break;
5008 }
5009 break;
5010 case 0x7e:
5011 GETBYTE ();
5012 switch (op[1] & 0xf0)
5013 {
5014 case 0x00:
5015 {
5016 /** 0111 1110 0000 rdst not %0 */
5017 #line 437 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5018 int rdst AU = op[1] & 0x0f;
5019 if (trace)
5020 {
5021 printf ("\033[33m%s\033[0m %02x %02x\n",
5022 "/** 0111 1110 0000 rdst not %0 */",
5023 op[0], op[1]);
5024 printf (" rdst = 0x%x\n", rdst);
5025 }
5026 SYNTAX("not %0");
5027 #line 438 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5028 ID(xor); DR(rdst); SR(rdst); S2C(~0); F("-SZ-");
5029
5030 }
5031 break;
5032 case 0x10:
5033 {
5034 /** 0111 1110 0001 rdst neg %0 */
5035 #line 458 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5036 int rdst AU = op[1] & 0x0f;
5037 if (trace)
5038 {
5039 printf ("\033[33m%s\033[0m %02x %02x\n",
5040 "/** 0111 1110 0001 rdst neg %0 */",
5041 op[0], op[1]);
5042 printf (" rdst = 0x%x\n", rdst);
5043 }
5044 SYNTAX("neg %0");
5045 #line 459 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5046 ID(sub); DR(rdst); SC(0); S2R(rdst); F("OSZC");
5047
5048 }
5049 break;
5050 case 0x20:
5051 {
5052 /** 0111 1110 0010 rdst abs %0 */
5053 #line 540 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5054 int rdst AU = op[1] & 0x0f;
5055 if (trace)
5056 {
5057 printf ("\033[33m%s\033[0m %02x %02x\n",
5058 "/** 0111 1110 0010 rdst abs %0 */",
5059 op[0], op[1]);
5060 printf (" rdst = 0x%x\n", rdst);
5061 }
5062 SYNTAX("abs %0");
5063 #line 541 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5064 ID(abs); DR(rdst); SR(rdst); F("OSZ-");
5065
5066 }
5067 break;
5068 case 0x30:
5069 {
5070 /** 0111 1110 0011 rdst sat %0 */
5071 #line 814 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5072 int rdst AU = op[1] & 0x0f;
5073 if (trace)
5074 {
5075 printf ("\033[33m%s\033[0m %02x %02x\n",
5076 "/** 0111 1110 0011 rdst sat %0 */",
5077 op[0], op[1]);
5078 printf (" rdst = 0x%x\n", rdst);
5079 }
5080 SYNTAX("sat %0");
5081 #line 815 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5082 ID(sat); DR (rdst);
5083
5084 }
5085 break;
5086 case 0x40:
5087 {
5088 /** 0111 1110 0100 rdst rorc %0 */
5089 #line 674 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5090 int rdst AU = op[1] & 0x0f;
5091 if (trace)
5092 {
5093 printf ("\033[33m%s\033[0m %02x %02x\n",
5094 "/** 0111 1110 0100 rdst rorc %0 */",
5095 op[0], op[1]);
5096 printf (" rdst = 0x%x\n", rdst);
5097 }
5098 SYNTAX("rorc %0");
5099 #line 675 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5100 ID(rorc); DR(rdst); F("-SZC");
5101
5102 }
5103 break;
5104 case 0x50:
5105 {
5106 /** 0111 1110 0101 rdst rolc %0 */
5107 #line 671 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5108 int rdst AU = op[1] & 0x0f;
5109 if (trace)
5110 {
5111 printf ("\033[33m%s\033[0m %02x %02x\n",
5112 "/** 0111 1110 0101 rdst rolc %0 */",
5113 op[0], op[1]);
5114 printf (" rdst = 0x%x\n", rdst);
5115 }
5116 SYNTAX("rolc %0");
5117 #line 672 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5118 ID(rolc); DR(rdst); F("-SZC");
5119
5120 }
5121 break;
5122 case 0x80:
5123 case 0x90:
5124 case 0xa0:
5125 {
5126 /** 0111 1110 10sz rsrc push%s %1 */
5127 #line 353 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5128 int sz AU = (op[1] >> 4) & 0x03;
5129 #line 353 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5130 int rsrc AU = op[1] & 0x0f;
5131 if (trace)
5132 {
5133 printf ("\033[33m%s\033[0m %02x %02x\n",
5134 "/** 0111 1110 10sz rsrc push%s %1 */",
5135 op[0], op[1]);
5136 printf (" sz = 0x%x,", sz);
5137 printf (" rsrc = 0x%x\n", rsrc);
5138 }
5139 SYNTAX("push%s %1");
5140 #line 354 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5141 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F("----");
5142
5143 }
5144 break;
5145 case 0xb0:
5146 {
5147 /** 0111 1110 1011 rdst pop %0 */
5148 #line 350 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5149 int rdst AU = op[1] & 0x0f;
5150 if (trace)
5151 {
5152 printf ("\033[33m%s\033[0m %02x %02x\n",
5153 "/** 0111 1110 1011 rdst pop %0 */",
5154 op[0], op[1]);
5155 printf (" rdst = 0x%x\n", rdst);
5156 }
5157 SYNTAX("pop %0");
5158 #line 351 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5159 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F("----");
5160
5161 }
5162 break;
5163 case 0xc0:
5164 case 0xd0:
5165 {
5166 /** 0111 1110 110 crsrc pushc %1 */
5167 #line 926 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5168 int crsrc AU = op[1] & 0x1f;
5169 if (trace)
5170 {
5171 printf ("\033[33m%s\033[0m %02x %02x\n",
5172 "/** 0111 1110 110 crsrc pushc %1 */",
5173 op[0], op[1]);
5174 printf (" crsrc = 0x%x\n", crsrc);
5175 }
5176 SYNTAX("pushc %1");
5177 #line 927 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5178 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5179
5180 }
5181 break;
5182 case 0xe0:
5183 case 0xf0:
5184 {
5185 /** 0111 1110 111 crdst popc %0 */
5186 #line 923 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5187 int crdst AU = op[1] & 0x1f;
5188 if (trace)
5189 {
5190 printf ("\033[33m%s\033[0m %02x %02x\n",
5191 "/** 0111 1110 111 crdst popc %0 */",
5192 op[0], op[1]);
5193 printf (" crdst = 0x%x\n", crdst);
5194 }
5195 SYNTAX("popc %0");
5196 #line 924 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5197 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5198
5199 }
5200 break;
5201 default: UNSUPPORTED(); break;
5202 }
5203 break;
5204 case 0x7f:
5205 GETBYTE ();
5206 switch (op[1] & 0xff)
5207 {
5208 case 0x00:
5209 case 0x01:
5210 case 0x02:
5211 case 0x03:
5212 case 0x04:
5213 case 0x05:
5214 case 0x06:
5215 case 0x07:
5216 case 0x08:
5217 case 0x09:
5218 case 0x0a:
5219 case 0x0b:
5220 case 0x0c:
5221 case 0x0d:
5222 case 0x0e:
5223 case 0x0f:
5224 {
5225 /** 0111 1111 0000 rsrc jmp %0 */
5226 #line 724 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5227 int rsrc AU = op[1] & 0x0f;
5228 if (trace)
5229 {
5230 printf ("\033[33m%s\033[0m %02x %02x\n",
5231 "/** 0111 1111 0000 rsrc jmp %0 */",
5232 op[0], op[1]);
5233 printf (" rsrc = 0x%x\n", rsrc);
5234 }
5235 SYNTAX("jmp %0");
5236 #line 725 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5237 ID(branch); Scc(RXC_always); DR(rsrc);
5238
5239 }
5240 break;
5241 case 0x10:
5242 case 0x11:
5243 case 0x12:
5244 case 0x13:
5245 case 0x14:
5246 case 0x15:
5247 case 0x16:
5248 case 0x17:
5249 case 0x18:
5250 case 0x19:
5251 case 0x1a:
5252 case 0x1b:
5253 case 0x1c:
5254 case 0x1d:
5255 case 0x1e:
5256 case 0x1f:
5257 {
5258 /** 0111 1111 0001 rsrc jsr %0 */
5259 #line 727 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5260 int rsrc AU = op[1] & 0x0f;
5261 if (trace)
5262 {
5263 printf ("\033[33m%s\033[0m %02x %02x\n",
5264 "/** 0111 1111 0001 rsrc jsr %0 */",
5265 op[0], op[1]);
5266 printf (" rsrc = 0x%x\n", rsrc);
5267 }
5268 SYNTAX("jsr %0");
5269 #line 728 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5270 ID(jsr); DR(rsrc);
5271
5272 }
5273 break;
5274 case 0x40:
5275 case 0x41:
5276 case 0x42:
5277 case 0x43:
5278 case 0x44:
5279 case 0x45:
5280 case 0x46:
5281 case 0x47:
5282 case 0x48:
5283 case 0x49:
5284 case 0x4a:
5285 case 0x4b:
5286 case 0x4c:
5287 case 0x4d:
5288 case 0x4e:
5289 case 0x4f:
5290 {
5291 /** 0111 1111 0100 rsrc bra.l %0 */
5292 #line 720 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5293 int rsrc AU = op[1] & 0x0f;
5294 if (trace)
5295 {
5296 printf ("\033[33m%s\033[0m %02x %02x\n",
5297 "/** 0111 1111 0100 rsrc bra.l %0 */",
5298 op[0], op[1]);
5299 printf (" rsrc = 0x%x\n", rsrc);
5300 }
5301 SYNTAX("bra.l %0");
5302 #line 721 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5303 ID(branchrel); Scc(RXC_always); DR(rsrc);
5304
5305
5306 }
5307 break;
5308 case 0x50:
5309 case 0x51:
5310 case 0x52:
5311 case 0x53:
5312 case 0x54:
5313 case 0x55:
5314 case 0x56:
5315 case 0x57:
5316 case 0x58:
5317 case 0x59:
5318 case 0x5a:
5319 case 0x5b:
5320 case 0x5c:
5321 case 0x5d:
5322 case 0x5e:
5323 case 0x5f:
5324 {
5325 /** 0111 1111 0101 rsrc bsr.l %0 */
5326 #line 736 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5327 int rsrc AU = op[1] & 0x0f;
5328 if (trace)
5329 {
5330 printf ("\033[33m%s\033[0m %02x %02x\n",
5331 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5332 op[0], op[1]);
5333 printf (" rsrc = 0x%x\n", rsrc);
5334 }
5335 SYNTAX("bsr.l %0");
5336 #line 737 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5337 ID(jsrrel); DR(rsrc);
5338
5339 }
5340 break;
5341 case 0x80:
5342 case 0x81:
5343 case 0x82:
5344 {
5345 /** 0111 1111 1000 00sz suntil%s */
5346 #line 760 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5347 int sz AU = op[1] & 0x03;
5348 if (trace)
5349 {
5350 printf ("\033[33m%s\033[0m %02x %02x\n",
5351 "/** 0111 1111 1000 00sz suntil%s */",
5352 op[0], op[1]);
5353 printf (" sz = 0x%x\n", sz);
5354 }
5355 SYNTAX("suntil%s");
5356 #line 761 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5357 ID(suntil); BWL(sz); F("OSZC");
5358
5359 }
5360 break;
5361 case 0x83:
5362 {
5363 /** 0111 1111 1000 0011 scmpu */
5364 if (trace)
5365 {
5366 printf ("\033[33m%s\033[0m %02x %02x\n",
5367 "/** 0111 1111 1000 0011 scmpu */",
5368 op[0], op[1]);
5369 }
5370 SYNTAX("scmpu");
5371 #line 752 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5372 ID(scmpu); F("--ZC");
5373
5374 }
5375 break;
5376 case 0x84:
5377 case 0x85:
5378 case 0x86:
5379 {
5380 /** 0111 1111 1000 01sz swhile%s */
5381 #line 763 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5382 int sz AU = op[1] & 0x03;
5383 if (trace)
5384 {
5385 printf ("\033[33m%s\033[0m %02x %02x\n",
5386 "/** 0111 1111 1000 01sz swhile%s */",
5387 op[0], op[1]);
5388 printf (" sz = 0x%x\n", sz);
5389 }
5390 SYNTAX("swhile%s");
5391 #line 764 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5392 ID(swhile); BWL(sz); F("OSZC");
5393
5394 }
5395 break;
5396 case 0x87:
5397 {
5398 /** 0111 1111 1000 0111 smovu */
5399 if (trace)
5400 {
5401 printf ("\033[33m%s\033[0m %02x %02x\n",
5402 "/** 0111 1111 1000 0111 smovu */",
5403 op[0], op[1]);
5404 }
5405 SYNTAX("smovu");
5406 #line 755 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5407 ID(smovu);
5408
5409 }
5410 break;
5411 case 0x88:
5412 case 0x89:
5413 case 0x8a:
5414 {
5415 /** 0111 1111 1000 10sz sstr%s */
5416 #line 769 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5417 int sz AU = op[1] & 0x03;
5418 if (trace)
5419 {
5420 printf ("\033[33m%s\033[0m %02x %02x\n",
5421 "/** 0111 1111 1000 10sz sstr%s */",
5422 op[0], op[1]);
5423 printf (" sz = 0x%x\n", sz);
5424 }
5425 SYNTAX("sstr%s");
5426 #line 770 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5427 ID(sstr); BWL(sz);
5428
5429 /*----------------------------------------------------------------------*/
5430 /* RMPA */
5431
5432 }
5433 break;
5434 case 0x8b:
5435 {
5436 /** 0111 1111 1000 1011 smovb */
5437 if (trace)
5438 {
5439 printf ("\033[33m%s\033[0m %02x %02x\n",
5440 "/** 0111 1111 1000 1011 smovb */",
5441 op[0], op[1]);
5442 }
5443 SYNTAX("smovb");
5444 #line 758 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5445 ID(smovb);
5446
5447 }
5448 break;
5449 case 0x8c:
5450 case 0x8d:
5451 case 0x8e:
5452 {
5453 /** 0111 1111 1000 11sz rmpa%s */
5454 #line 775 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5455 int sz AU = op[1] & 0x03;
5456 if (trace)
5457 {
5458 printf ("\033[33m%s\033[0m %02x %02x\n",
5459 "/** 0111 1111 1000 11sz rmpa%s */",
5460 op[0], op[1]);
5461 printf (" sz = 0x%x\n", sz);
5462 }
5463 SYNTAX("rmpa%s");
5464 #line 776 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5465 ID(rmpa); BWL(sz); F("OS--");
5466
5467 /*----------------------------------------------------------------------*/
5468 /* HI/LO stuff */
5469
5470 }
5471 break;
5472 case 0x8f:
5473 {
5474 /** 0111 1111 1000 1111 smovf */
5475 if (trace)
5476 {
5477 printf ("\033[33m%s\033[0m %02x %02x\n",
5478 "/** 0111 1111 1000 1111 smovf */",
5479 op[0], op[1]);
5480 }
5481 SYNTAX("smovf");
5482 #line 767 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5483 ID(smovf);
5484
5485 }
5486 break;
5487 case 0x93:
5488 {
5489 /** 0111 1111 1001 0011 satr */
5490 if (trace)
5491 {
5492 printf ("\033[33m%s\033[0m %02x %02x\n",
5493 "/** 0111 1111 1001 0011 satr */",
5494 op[0], op[1]);
5495 }
5496 SYNTAX("satr");
5497 #line 818 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5498 ID(satr);
5499
5500 /*----------------------------------------------------------------------*/
5501 /* FLOAT */
5502
5503 }
5504 break;
5505 case 0x94:
5506 {
5507 /** 0111 1111 1001 0100 rtfi */
5508 if (trace)
5509 {
5510 printf ("\033[33m%s\033[0m %02x %02x\n",
5511 "/** 0111 1111 1001 0100 rtfi */",
5512 op[0], op[1]);
5513 }
5514 SYNTAX("rtfi");
5515 #line 951 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5516 ID(rtfi);
5517
5518 }
5519 break;
5520 case 0x95:
5521 {
5522 /** 0111 1111 1001 0101 rte */
5523 if (trace)
5524 {
5525 printf ("\033[33m%s\033[0m %02x %02x\n",
5526 "/** 0111 1111 1001 0101 rte */",
5527 op[0], op[1]);
5528 }
5529 SYNTAX("rte");
5530 #line 954 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5531 ID(rte);
5532
5533 }
5534 break;
5535 case 0x96:
5536 {
5537 /** 0111 1111 1001 0110 wait */
5538 if (trace)
5539 {
5540 printf ("\033[33m%s\033[0m %02x %02x\n",
5541 "/** 0111 1111 1001 0110 wait */",
5542 op[0], op[1]);
5543 }
5544 SYNTAX("wait");
5545 #line 966 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5546 ID(wait);
5547
5548 /*----------------------------------------------------------------------*/
5549 /* SCcnd */
5550
5551 }
5552 break;
5553 case 0xa0:
5554 case 0xa1:
5555 case 0xa2:
5556 case 0xa3:
5557 case 0xa4:
5558 case 0xa5:
5559 case 0xa6:
5560 case 0xa7:
5561 case 0xa8:
5562 case 0xa9:
5563 case 0xaa:
5564 case 0xab:
5565 case 0xac:
5566 case 0xad:
5567 case 0xae:
5568 case 0xaf:
5569 {
5570 /** 0111 1111 1010 rdst setpsw %0 */
5571 #line 920 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5572 int rdst AU = op[1] & 0x0f;
5573 if (trace)
5574 {
5575 printf ("\033[33m%s\033[0m %02x %02x\n",
5576 "/** 0111 1111 1010 rdst setpsw %0 */",
5577 op[0], op[1]);
5578 printf (" rdst = 0x%x\n", rdst);
5579 }
5580 SYNTAX("setpsw %0");
5581 #line 921 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5582 ID(setpsw); DF(rdst);
5583
5584 }
5585 break;
5586 case 0xb0:
5587 case 0xb1:
5588 case 0xb2:
5589 case 0xb3:
5590 case 0xb4:
5591 case 0xb5:
5592 case 0xb6:
5593 case 0xb7:
5594 case 0xb8:
5595 case 0xb9:
5596 case 0xba:
5597 case 0xbb:
5598 case 0xbc:
5599 case 0xbd:
5600 case 0xbe:
5601 case 0xbf:
5602 {
5603 /** 0111 1111 1011 rdst clrpsw %0 */
5604 #line 917 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5605 int rdst AU = op[1] & 0x0f;
5606 if (trace)
5607 {
5608 printf ("\033[33m%s\033[0m %02x %02x\n",
5609 "/** 0111 1111 1011 rdst clrpsw %0 */",
5610 op[0], op[1]);
5611 printf (" rdst = 0x%x\n", rdst);
5612 }
5613 SYNTAX("clrpsw %0");
5614 #line 918 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5615 ID(clrpsw); DF(rdst);
5616
5617 }
5618 break;
5619 default: UNSUPPORTED(); break;
5620 }
5621 break;
5622 case 0x80:
5623 GETBYTE ();
5624 switch (op[1] & 0x00)
5625 {
5626 case 0x00:
5627 op_semantics_38:
5628 {
5629 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5630 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5631 int sz AU = (op[0] >> 4) & 0x03;
5632 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5633 int dsp AU = op[0] & 0x07;
5634 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5635 int a AU = (op[1] >> 7) & 0x01;
5636 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5637 int dst AU = (op[1] >> 4) & 0x07;
5638 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5639 int b AU = (op[1] >> 3) & 0x01;
5640 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5641 int src AU = op[1] & 0x07;
5642 if (trace)
5643 {
5644 printf ("\033[33m%s\033[0m %02x %02x\n",
5645 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5646 op[0], op[1]);
5647 printf (" sz = 0x%x,", sz);
5648 printf (" dsp = 0x%x,", dsp);
5649 printf (" a = 0x%x,", a);
5650 printf (" dst = 0x%x,", dst);
5651 printf (" b = 0x%x,", b);
5652 printf (" src = 0x%x\n", src);
5653 }
5654 SYNTAX("mov%s %1, %0");
5655 #line 312 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5656 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F("----");
5657
5658 }
5659 break;
5660 }
5661 break;
5662 case 0x81:
5663 GETBYTE ();
5664 switch (op[1] & 0x00)
5665 {
5666 case 0x00:
5667 goto op_semantics_38;
5668 break;
5669 }
5670 break;
5671 case 0x82:
5672 GETBYTE ();
5673 switch (op[1] & 0x00)
5674 {
5675 case 0x00:
5676 goto op_semantics_38;
5677 break;
5678 }
5679 break;
5680 case 0x83:
5681 GETBYTE ();
5682 switch (op[1] & 0x00)
5683 {
5684 case 0x00:
5685 goto op_semantics_38;
5686 break;
5687 }
5688 break;
5689 case 0x84:
5690 GETBYTE ();
5691 switch (op[1] & 0x00)
5692 {
5693 case 0x00:
5694 goto op_semantics_38;
5695 break;
5696 }
5697 break;
5698 case 0x85:
5699 GETBYTE ();
5700 switch (op[1] & 0x00)
5701 {
5702 case 0x00:
5703 goto op_semantics_38;
5704 break;
5705 }
5706 break;
5707 case 0x86:
5708 GETBYTE ();
5709 switch (op[1] & 0x00)
5710 {
5711 case 0x00:
5712 goto op_semantics_38;
5713 break;
5714 }
5715 break;
5716 case 0x87:
5717 GETBYTE ();
5718 switch (op[1] & 0x00)
5719 {
5720 case 0x00:
5721 goto op_semantics_38;
5722 break;
5723 }
5724 break;
5725 case 0x88:
5726 GETBYTE ();
5727 switch (op[1] & 0x00)
5728 {
5729 case 0x00:
5730 op_semantics_39:
5731 {
5732 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5733 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5734 int sz AU = (op[0] >> 4) & 0x03;
5735 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5736 int dsp AU = op[0] & 0x07;
5737 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5738 int a AU = (op[1] >> 7) & 0x01;
5739 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5740 int src AU = (op[1] >> 4) & 0x07;
5741 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5742 int b AU = (op[1] >> 3) & 0x01;
5743 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5744 int dst AU = op[1] & 0x07;
5745 if (trace)
5746 {
5747 printf ("\033[33m%s\033[0m %02x %02x\n",
5748 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5749 op[0], op[1]);
5750 printf (" sz = 0x%x,", sz);
5751 printf (" dsp = 0x%x,", dsp);
5752 printf (" a = 0x%x,", a);
5753 printf (" src = 0x%x,", src);
5754 printf (" b = 0x%x,", b);
5755 printf (" dst = 0x%x\n", dst);
5756 }
5757 SYNTAX("mov%s %1, %0");
5758 #line 309 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5759 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F("----");
5760
5761 }
5762 break;
5763 }
5764 break;
5765 case 0x89:
5766 GETBYTE ();
5767 switch (op[1] & 0x00)
5768 {
5769 case 0x00:
5770 goto op_semantics_39;
5771 break;
5772 }
5773 break;
5774 case 0x8a:
5775 GETBYTE ();
5776 switch (op[1] & 0x00)
5777 {
5778 case 0x00:
5779 goto op_semantics_39;
5780 break;
5781 }
5782 break;
5783 case 0x8b:
5784 GETBYTE ();
5785 switch (op[1] & 0x00)
5786 {
5787 case 0x00:
5788 goto op_semantics_39;
5789 break;
5790 }
5791 break;
5792 case 0x8c:
5793 GETBYTE ();
5794 switch (op[1] & 0x00)
5795 {
5796 case 0x00:
5797 goto op_semantics_39;
5798 break;
5799 }
5800 break;
5801 case 0x8d:
5802 GETBYTE ();
5803 switch (op[1] & 0x00)
5804 {
5805 case 0x00:
5806 goto op_semantics_39;
5807 break;
5808 }
5809 break;
5810 case 0x8e:
5811 GETBYTE ();
5812 switch (op[1] & 0x00)
5813 {
5814 case 0x00:
5815 goto op_semantics_39;
5816 break;
5817 }
5818 break;
5819 case 0x8f:
5820 GETBYTE ();
5821 switch (op[1] & 0x00)
5822 {
5823 case 0x00:
5824 goto op_semantics_39;
5825 break;
5826 }
5827 break;
5828 case 0x90:
5829 GETBYTE ();
5830 switch (op[1] & 0x00)
5831 {
5832 case 0x00:
5833 goto op_semantics_38;
5834 break;
5835 }
5836 break;
5837 case 0x91:
5838 GETBYTE ();
5839 switch (op[1] & 0x00)
5840 {
5841 case 0x00:
5842 goto op_semantics_38;
5843 break;
5844 }
5845 break;
5846 case 0x92:
5847 GETBYTE ();
5848 switch (op[1] & 0x00)
5849 {
5850 case 0x00:
5851 goto op_semantics_38;
5852 break;
5853 }
5854 break;
5855 case 0x93:
5856 GETBYTE ();
5857 switch (op[1] & 0x00)
5858 {
5859 case 0x00:
5860 goto op_semantics_38;
5861 break;
5862 }
5863 break;
5864 case 0x94:
5865 GETBYTE ();
5866 switch (op[1] & 0x00)
5867 {
5868 case 0x00:
5869 goto op_semantics_38;
5870 break;
5871 }
5872 break;
5873 case 0x95:
5874 GETBYTE ();
5875 switch (op[1] & 0x00)
5876 {
5877 case 0x00:
5878 goto op_semantics_38;
5879 break;
5880 }
5881 break;
5882 case 0x96:
5883 GETBYTE ();
5884 switch (op[1] & 0x00)
5885 {
5886 case 0x00:
5887 goto op_semantics_38;
5888 break;
5889 }
5890 break;
5891 case 0x97:
5892 GETBYTE ();
5893 switch (op[1] & 0x00)
5894 {
5895 case 0x00:
5896 goto op_semantics_38;
5897 break;
5898 }
5899 break;
5900 case 0x98:
5901 GETBYTE ();
5902 switch (op[1] & 0x00)
5903 {
5904 case 0x00:
5905 goto op_semantics_39;
5906 break;
5907 }
5908 break;
5909 case 0x99:
5910 GETBYTE ();
5911 switch (op[1] & 0x00)
5912 {
5913 case 0x00:
5914 goto op_semantics_39;
5915 break;
5916 }
5917 break;
5918 case 0x9a:
5919 GETBYTE ();
5920 switch (op[1] & 0x00)
5921 {
5922 case 0x00:
5923 goto op_semantics_39;
5924 break;
5925 }
5926 break;
5927 case 0x9b:
5928 GETBYTE ();
5929 switch (op[1] & 0x00)
5930 {
5931 case 0x00:
5932 goto op_semantics_39;
5933 break;
5934 }
5935 break;
5936 case 0x9c:
5937 GETBYTE ();
5938 switch (op[1] & 0x00)
5939 {
5940 case 0x00:
5941 goto op_semantics_39;
5942 break;
5943 }
5944 break;
5945 case 0x9d:
5946 GETBYTE ();
5947 switch (op[1] & 0x00)
5948 {
5949 case 0x00:
5950 goto op_semantics_39;
5951 break;
5952 }
5953 break;
5954 case 0x9e:
5955 GETBYTE ();
5956 switch (op[1] & 0x00)
5957 {
5958 case 0x00:
5959 goto op_semantics_39;
5960 break;
5961 }
5962 break;
5963 case 0x9f:
5964 GETBYTE ();
5965 switch (op[1] & 0x00)
5966 {
5967 case 0x00:
5968 goto op_semantics_39;
5969 break;
5970 }
5971 break;
5972 case 0xa0:
5973 GETBYTE ();
5974 switch (op[1] & 0x00)
5975 {
5976 case 0x00:
5977 goto op_semantics_38;
5978 break;
5979 }
5980 break;
5981 case 0xa1:
5982 GETBYTE ();
5983 switch (op[1] & 0x00)
5984 {
5985 case 0x00:
5986 goto op_semantics_38;
5987 break;
5988 }
5989 break;
5990 case 0xa2:
5991 GETBYTE ();
5992 switch (op[1] & 0x00)
5993 {
5994 case 0x00:
5995 goto op_semantics_38;
5996 break;
5997 }
5998 break;
5999 case 0xa3:
6000 GETBYTE ();
6001 switch (op[1] & 0x00)
6002 {
6003 case 0x00:
6004 goto op_semantics_38;
6005 break;
6006 }
6007 break;
6008 case 0xa4:
6009 GETBYTE ();
6010 switch (op[1] & 0x00)
6011 {
6012 case 0x00:
6013 goto op_semantics_38;
6014 break;
6015 }
6016 break;
6017 case 0xa5:
6018 GETBYTE ();
6019 switch (op[1] & 0x00)
6020 {
6021 case 0x00:
6022 goto op_semantics_38;
6023 break;
6024 }
6025 break;
6026 case 0xa6:
6027 GETBYTE ();
6028 switch (op[1] & 0x00)
6029 {
6030 case 0x00:
6031 goto op_semantics_38;
6032 break;
6033 }
6034 break;
6035 case 0xa7:
6036 GETBYTE ();
6037 switch (op[1] & 0x00)
6038 {
6039 case 0x00:
6040 goto op_semantics_38;
6041 break;
6042 }
6043 break;
6044 case 0xa8:
6045 GETBYTE ();
6046 switch (op[1] & 0x00)
6047 {
6048 case 0x00:
6049 goto op_semantics_39;
6050 break;
6051 }
6052 break;
6053 case 0xa9:
6054 GETBYTE ();
6055 switch (op[1] & 0x00)
6056 {
6057 case 0x00:
6058 goto op_semantics_39;
6059 break;
6060 }
6061 break;
6062 case 0xaa:
6063 GETBYTE ();
6064 switch (op[1] & 0x00)
6065 {
6066 case 0x00:
6067 goto op_semantics_39;
6068 break;
6069 }
6070 break;
6071 case 0xab:
6072 GETBYTE ();
6073 switch (op[1] & 0x00)
6074 {
6075 case 0x00:
6076 goto op_semantics_39;
6077 break;
6078 }
6079 break;
6080 case 0xac:
6081 GETBYTE ();
6082 switch (op[1] & 0x00)
6083 {
6084 case 0x00:
6085 goto op_semantics_39;
6086 break;
6087 }
6088 break;
6089 case 0xad:
6090 GETBYTE ();
6091 switch (op[1] & 0x00)
6092 {
6093 case 0x00:
6094 goto op_semantics_39;
6095 break;
6096 }
6097 break;
6098 case 0xae:
6099 GETBYTE ();
6100 switch (op[1] & 0x00)
6101 {
6102 case 0x00:
6103 goto op_semantics_39;
6104 break;
6105 }
6106 break;
6107 case 0xaf:
6108 GETBYTE ();
6109 switch (op[1] & 0x00)
6110 {
6111 case 0x00:
6112 goto op_semantics_39;
6113 break;
6114 }
6115 break;
6116 case 0xb0:
6117 GETBYTE ();
6118 switch (op[1] & 0x00)
6119 {
6120 case 0x00:
6121 op_semantics_40:
6122 {
6123 /** 1011 w dsp a src b dst movu%s %1, %0 */
6124 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6125 int w AU = (op[0] >> 3) & 0x01;
6126 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6127 int dsp AU = op[0] & 0x07;
6128 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6129 int a AU = (op[1] >> 7) & 0x01;
6130 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6131 int src AU = (op[1] >> 4) & 0x07;
6132 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6133 int b AU = (op[1] >> 3) & 0x01;
6134 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6135 int dst AU = op[1] & 0x07;
6136 if (trace)
6137 {
6138 printf ("\033[33m%s\033[0m %02x %02x\n",
6139 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6140 op[0], op[1]);
6141 printf (" w = 0x%x,", w);
6142 printf (" dsp = 0x%x,", dsp);
6143 printf (" a = 0x%x,", a);
6144 printf (" src = 0x%x,", src);
6145 printf (" b = 0x%x,", b);
6146 printf (" dst = 0x%x\n", dst);
6147 }
6148 SYNTAX("movu%s %1, %0");
6149 #line 332 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6150 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F("----");
6151
6152 }
6153 break;
6154 }
6155 break;
6156 case 0xb1:
6157 GETBYTE ();
6158 switch (op[1] & 0x00)
6159 {
6160 case 0x00:
6161 goto op_semantics_40;
6162 break;
6163 }
6164 break;
6165 case 0xb2:
6166 GETBYTE ();
6167 switch (op[1] & 0x00)
6168 {
6169 case 0x00:
6170 goto op_semantics_40;
6171 break;
6172 }
6173 break;
6174 case 0xb3:
6175 GETBYTE ();
6176 switch (op[1] & 0x00)
6177 {
6178 case 0x00:
6179 goto op_semantics_40;
6180 break;
6181 }
6182 break;
6183 case 0xb4:
6184 GETBYTE ();
6185 switch (op[1] & 0x00)
6186 {
6187 case 0x00:
6188 goto op_semantics_40;
6189 break;
6190 }
6191 break;
6192 case 0xb5:
6193 GETBYTE ();
6194 switch (op[1] & 0x00)
6195 {
6196 case 0x00:
6197 goto op_semantics_40;
6198 break;
6199 }
6200 break;
6201 case 0xb6:
6202 GETBYTE ();
6203 switch (op[1] & 0x00)
6204 {
6205 case 0x00:
6206 goto op_semantics_40;
6207 break;
6208 }
6209 break;
6210 case 0xb7:
6211 GETBYTE ();
6212 switch (op[1] & 0x00)
6213 {
6214 case 0x00:
6215 goto op_semantics_40;
6216 break;
6217 }
6218 break;
6219 case 0xb8:
6220 GETBYTE ();
6221 switch (op[1] & 0x00)
6222 {
6223 case 0x00:
6224 goto op_semantics_40;
6225 break;
6226 }
6227 break;
6228 case 0xb9:
6229 GETBYTE ();
6230 switch (op[1] & 0x00)
6231 {
6232 case 0x00:
6233 goto op_semantics_40;
6234 break;
6235 }
6236 break;
6237 case 0xba:
6238 GETBYTE ();
6239 switch (op[1] & 0x00)
6240 {
6241 case 0x00:
6242 goto op_semantics_40;
6243 break;
6244 }
6245 break;
6246 case 0xbb:
6247 GETBYTE ();
6248 switch (op[1] & 0x00)
6249 {
6250 case 0x00:
6251 goto op_semantics_40;
6252 break;
6253 }
6254 break;
6255 case 0xbc:
6256 GETBYTE ();
6257 switch (op[1] & 0x00)
6258 {
6259 case 0x00:
6260 goto op_semantics_40;
6261 break;
6262 }
6263 break;
6264 case 0xbd:
6265 GETBYTE ();
6266 switch (op[1] & 0x00)
6267 {
6268 case 0x00:
6269 goto op_semantics_40;
6270 break;
6271 }
6272 break;
6273 case 0xbe:
6274 GETBYTE ();
6275 switch (op[1] & 0x00)
6276 {
6277 case 0x00:
6278 goto op_semantics_40;
6279 break;
6280 }
6281 break;
6282 case 0xbf:
6283 GETBYTE ();
6284 switch (op[1] & 0x00)
6285 {
6286 case 0x00:
6287 goto op_semantics_40;
6288 break;
6289 }
6290 break;
6291 case 0xc0:
6292 GETBYTE ();
6293 switch (op[1] & 0x00)
6294 {
6295 case 0x00:
6296 op_semantics_41:
6297 {
6298 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6299 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6300 int sz AU = (op[0] >> 4) & 0x03;
6301 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6302 int sd AU = (op[0] >> 2) & 0x03;
6303 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6304 int ss AU = op[0] & 0x03;
6305 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6306 int rsrc AU = (op[1] >> 4) & 0x0f;
6307 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6308 int rdst AU = op[1] & 0x0f;
6309 if (trace)
6310 {
6311 printf ("\033[33m%s\033[0m %02x %02x\n",
6312 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6313 op[0], op[1]);
6314 printf (" sz = 0x%x,", sz);
6315 printf (" sd = 0x%x,", sd);
6316 printf (" ss = 0x%x,", ss);
6317 printf (" rsrc = 0x%x,", rsrc);
6318 printf (" rdst = 0x%x\n", rdst);
6319 }
6320 SYNTAX("mov%s %1, %0");
6321 #line 298 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6322 ID(mov); sBWL(sz); F("----");
6323 if ((ss == 3) && (sd != 3))
6324 {
6325 SD(ss, rdst, sz); DD(sd, rsrc, sz);
6326 }
6327 else
6328 {
6329 SD(ss, rsrc, sz); DD(sd, rdst, sz);
6330 }
6331
6332 }
6333 break;
6334 }
6335 break;
6336 case 0xc1:
6337 GETBYTE ();
6338 switch (op[1] & 0x00)
6339 {
6340 case 0x00:
6341 goto op_semantics_41;
6342 break;
6343 }
6344 break;
6345 case 0xc2:
6346 GETBYTE ();
6347 switch (op[1] & 0x00)
6348 {
6349 case 0x00:
6350 goto op_semantics_41;
6351 break;
6352 }
6353 break;
6354 case 0xc3:
6355 GETBYTE ();
6356 switch (op[1] & 0x00)
6357 {
6358 case 0x00:
6359 goto op_semantics_41;
6360 break;
6361 }
6362 break;
6363 case 0xc4:
6364 GETBYTE ();
6365 switch (op[1] & 0x00)
6366 {
6367 case 0x00:
6368 goto op_semantics_41;
6369 break;
6370 }
6371 break;
6372 case 0xc5:
6373 GETBYTE ();
6374 switch (op[1] & 0x00)
6375 {
6376 case 0x00:
6377 goto op_semantics_41;
6378 break;
6379 }
6380 break;
6381 case 0xc6:
6382 GETBYTE ();
6383 switch (op[1] & 0x00)
6384 {
6385 case 0x00:
6386 goto op_semantics_41;
6387 break;
6388 }
6389 break;
6390 case 0xc7:
6391 GETBYTE ();
6392 switch (op[1] & 0x00)
6393 {
6394 case 0x00:
6395 goto op_semantics_41;
6396 break;
6397 }
6398 break;
6399 case 0xc8:
6400 GETBYTE ();
6401 switch (op[1] & 0x00)
6402 {
6403 case 0x00:
6404 goto op_semantics_41;
6405 break;
6406 }
6407 break;
6408 case 0xc9:
6409 GETBYTE ();
6410 switch (op[1] & 0x00)
6411 {
6412 case 0x00:
6413 goto op_semantics_41;
6414 break;
6415 }
6416 break;
6417 case 0xca:
6418 GETBYTE ();
6419 switch (op[1] & 0x00)
6420 {
6421 case 0x00:
6422 goto op_semantics_41;
6423 break;
6424 }
6425 break;
6426 case 0xcb:
6427 GETBYTE ();
6428 switch (op[1] & 0x00)
6429 {
6430 case 0x00:
6431 goto op_semantics_41;
6432 break;
6433 }
6434 break;
6435 case 0xcc:
6436 GETBYTE ();
6437 switch (op[1] & 0x00)
6438 {
6439 case 0x00:
6440 goto op_semantics_41;
6441 break;
6442 }
6443 break;
6444 case 0xcd:
6445 GETBYTE ();
6446 switch (op[1] & 0x00)
6447 {
6448 case 0x00:
6449 goto op_semantics_41;
6450 break;
6451 }
6452 break;
6453 case 0xce:
6454 GETBYTE ();
6455 switch (op[1] & 0x00)
6456 {
6457 case 0x00:
6458 goto op_semantics_41;
6459 break;
6460 }
6461 break;
6462 case 0xcf:
6463 GETBYTE ();
6464 switch (op[1] & 0x00)
6465 {
6466 case 0x00:
6467 goto op_semantics_41;
6468 break;
6469 }
6470 break;
6471 case 0xd0:
6472 GETBYTE ();
6473 switch (op[1] & 0x00)
6474 {
6475 case 0x00:
6476 goto op_semantics_41;
6477 break;
6478 }
6479 break;
6480 case 0xd1:
6481 GETBYTE ();
6482 switch (op[1] & 0x00)
6483 {
6484 case 0x00:
6485 goto op_semantics_41;
6486 break;
6487 }
6488 break;
6489 case 0xd2:
6490 GETBYTE ();
6491 switch (op[1] & 0x00)
6492 {
6493 case 0x00:
6494 goto op_semantics_41;
6495 break;
6496 }
6497 break;
6498 case 0xd3:
6499 GETBYTE ();
6500 switch (op[1] & 0x00)
6501 {
6502 case 0x00:
6503 goto op_semantics_41;
6504 break;
6505 }
6506 break;
6507 case 0xd4:
6508 GETBYTE ();
6509 switch (op[1] & 0x00)
6510 {
6511 case 0x00:
6512 goto op_semantics_41;
6513 break;
6514 }
6515 break;
6516 case 0xd5:
6517 GETBYTE ();
6518 switch (op[1] & 0x00)
6519 {
6520 case 0x00:
6521 goto op_semantics_41;
6522 break;
6523 }
6524 break;
6525 case 0xd6:
6526 GETBYTE ();
6527 switch (op[1] & 0x00)
6528 {
6529 case 0x00:
6530 goto op_semantics_41;
6531 break;
6532 }
6533 break;
6534 case 0xd7:
6535 GETBYTE ();
6536 switch (op[1] & 0x00)
6537 {
6538 case 0x00:
6539 goto op_semantics_41;
6540 break;
6541 }
6542 break;
6543 case 0xd8:
6544 GETBYTE ();
6545 switch (op[1] & 0x00)
6546 {
6547 case 0x00:
6548 goto op_semantics_41;
6549 break;
6550 }
6551 break;
6552 case 0xd9:
6553 GETBYTE ();
6554 switch (op[1] & 0x00)
6555 {
6556 case 0x00:
6557 goto op_semantics_41;
6558 break;
6559 }
6560 break;
6561 case 0xda:
6562 GETBYTE ();
6563 switch (op[1] & 0x00)
6564 {
6565 case 0x00:
6566 goto op_semantics_41;
6567 break;
6568 }
6569 break;
6570 case 0xdb:
6571 GETBYTE ();
6572 switch (op[1] & 0x00)
6573 {
6574 case 0x00:
6575 goto op_semantics_41;
6576 break;
6577 }
6578 break;
6579 case 0xdc:
6580 GETBYTE ();
6581 switch (op[1] & 0x00)
6582 {
6583 case 0x00:
6584 goto op_semantics_41;
6585 break;
6586 }
6587 break;
6588 case 0xdd:
6589 GETBYTE ();
6590 switch (op[1] & 0x00)
6591 {
6592 case 0x00:
6593 goto op_semantics_41;
6594 break;
6595 }
6596 break;
6597 case 0xde:
6598 GETBYTE ();
6599 switch (op[1] & 0x00)
6600 {
6601 case 0x00:
6602 goto op_semantics_41;
6603 break;
6604 }
6605 break;
6606 case 0xdf:
6607 GETBYTE ();
6608 switch (op[1] & 0x00)
6609 {
6610 case 0x00:
6611 goto op_semantics_41;
6612 break;
6613 }
6614 break;
6615 case 0xe0:
6616 GETBYTE ();
6617 switch (op[1] & 0x00)
6618 {
6619 case 0x00:
6620 goto op_semantics_41;
6621 break;
6622 }
6623 break;
6624 case 0xe1:
6625 GETBYTE ();
6626 switch (op[1] & 0x00)
6627 {
6628 case 0x00:
6629 goto op_semantics_41;
6630 break;
6631 }
6632 break;
6633 case 0xe2:
6634 GETBYTE ();
6635 switch (op[1] & 0x00)
6636 {
6637 case 0x00:
6638 goto op_semantics_41;
6639 break;
6640 }
6641 break;
6642 case 0xe3:
6643 GETBYTE ();
6644 switch (op[1] & 0x00)
6645 {
6646 case 0x00:
6647 goto op_semantics_41;
6648 break;
6649 }
6650 break;
6651 case 0xe4:
6652 GETBYTE ();
6653 switch (op[1] & 0x00)
6654 {
6655 case 0x00:
6656 goto op_semantics_41;
6657 break;
6658 }
6659 break;
6660 case 0xe5:
6661 GETBYTE ();
6662 switch (op[1] & 0x00)
6663 {
6664 case 0x00:
6665 goto op_semantics_41;
6666 break;
6667 }
6668 break;
6669 case 0xe6:
6670 GETBYTE ();
6671 switch (op[1] & 0x00)
6672 {
6673 case 0x00:
6674 goto op_semantics_41;
6675 break;
6676 }
6677 break;
6678 case 0xe7:
6679 GETBYTE ();
6680 switch (op[1] & 0x00)
6681 {
6682 case 0x00:
6683 goto op_semantics_41;
6684 break;
6685 }
6686 break;
6687 case 0xe8:
6688 GETBYTE ();
6689 switch (op[1] & 0x00)
6690 {
6691 case 0x00:
6692 goto op_semantics_41;
6693 break;
6694 }
6695 break;
6696 case 0xe9:
6697 GETBYTE ();
6698 switch (op[1] & 0x00)
6699 {
6700 case 0x00:
6701 goto op_semantics_41;
6702 break;
6703 }
6704 break;
6705 case 0xea:
6706 GETBYTE ();
6707 switch (op[1] & 0x00)
6708 {
6709 case 0x00:
6710 goto op_semantics_41;
6711 break;
6712 }
6713 break;
6714 case 0xeb:
6715 GETBYTE ();
6716 switch (op[1] & 0x00)
6717 {
6718 case 0x00:
6719 goto op_semantics_41;
6720 break;
6721 }
6722 break;
6723 case 0xec:
6724 GETBYTE ();
6725 switch (op[1] & 0x00)
6726 {
6727 case 0x00:
6728 goto op_semantics_41;
6729 break;
6730 }
6731 break;
6732 case 0xed:
6733 GETBYTE ();
6734 switch (op[1] & 0x00)
6735 {
6736 case 0x00:
6737 goto op_semantics_41;
6738 break;
6739 }
6740 break;
6741 case 0xee:
6742 GETBYTE ();
6743 switch (op[1] & 0x00)
6744 {
6745 case 0x00:
6746 goto op_semantics_41;
6747 break;
6748 }
6749 break;
6750 case 0xef:
6751 GETBYTE ();
6752 switch (op[1] & 0x00)
6753 {
6754 case 0x00:
6755 goto op_semantics_41;
6756 break;
6757 }
6758 break;
6759 case 0xf0:
6760 GETBYTE ();
6761 switch (op[1] & 0x08)
6762 {
6763 case 0x00:
6764 op_semantics_42:
6765 {
6766 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
6767 #line 868 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6768 int sd AU = op[0] & 0x03;
6769 #line 868 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6770 int rdst AU = (op[1] >> 4) & 0x0f;
6771 #line 868 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6772 int bit AU = op[1] & 0x07;
6773 if (trace)
6774 {
6775 printf ("\033[33m%s\033[0m %02x %02x\n",
6776 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6777 op[0], op[1]);
6778 printf (" sd = 0x%x,", sd);
6779 printf (" rdst = 0x%x,", rdst);
6780 printf (" bit = 0x%x\n", bit);
6781 }
6782 SYNTAX("bset #%1, %0%S0");
6783 #line 869 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6784 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6785
6786 }
6787 break;
6788 case 0x08:
6789 op_semantics_43:
6790 {
6791 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
6792 #line 878 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6793 int sd AU = op[0] & 0x03;
6794 #line 878 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6795 int rdst AU = (op[1] >> 4) & 0x0f;
6796 #line 878 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6797 int bit AU = op[1] & 0x07;
6798 if (trace)
6799 {
6800 printf ("\033[33m%s\033[0m %02x %02x\n",
6801 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6802 op[0], op[1]);
6803 printf (" sd = 0x%x,", sd);
6804 printf (" rdst = 0x%x,", rdst);
6805 printf (" bit = 0x%x\n", bit);
6806 }
6807 SYNTAX("bclr #%1, %0%S0");
6808 #line 879 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6809 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6810
6811 }
6812 break;
6813 }
6814 break;
6815 case 0xf1:
6816 GETBYTE ();
6817 switch (op[1] & 0x08)
6818 {
6819 case 0x00:
6820 goto op_semantics_42;
6821 break;
6822 case 0x08:
6823 goto op_semantics_43;
6824 break;
6825 }
6826 break;
6827 case 0xf2:
6828 GETBYTE ();
6829 switch (op[1] & 0x08)
6830 {
6831 case 0x00:
6832 goto op_semantics_42;
6833 break;
6834 case 0x08:
6835 goto op_semantics_43;
6836 break;
6837 }
6838 break;
6839 case 0xf3:
6840 GETBYTE ();
6841 switch (op[1] & 0x08)
6842 {
6843 case 0x00:
6844 goto op_semantics_42;
6845 break;
6846 case 0x08:
6847 goto op_semantics_43;
6848 break;
6849 }
6850 break;
6851 case 0xf4:
6852 GETBYTE ();
6853 switch (op[1] & 0x0c)
6854 {
6855 case 0x00:
6856 case 0x04:
6857 op_semantics_44:
6858 {
6859 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
6860 #line 888 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6861 int sd AU = op[0] & 0x03;
6862 #line 888 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6863 int rdst AU = (op[1] >> 4) & 0x0f;
6864 #line 888 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6865 int bit AU = op[1] & 0x07;
6866 if (trace)
6867 {
6868 printf ("\033[33m%s\033[0m %02x %02x\n",
6869 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6870 op[0], op[1]);
6871 printf (" sd = 0x%x,", sd);
6872 printf (" rdst = 0x%x,", rdst);
6873 printf (" bit = 0x%x\n", bit);
6874 }
6875 SYNTAX("btst #%2, %1%S1");
6876 #line 889 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6877 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F("--ZC");
6878
6879 }
6880 break;
6881 case 0x08:
6882 op_semantics_45:
6883 {
6884 /** 1111 01ss rsrc 10sz push%s %1 */
6885 #line 356 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6886 int ss AU = op[0] & 0x03;
6887 #line 356 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6888 int rsrc AU = (op[1] >> 4) & 0x0f;
6889 #line 356 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6890 int sz AU = op[1] & 0x03;
6891 if (trace)
6892 {
6893 printf ("\033[33m%s\033[0m %02x %02x\n",
6894 "/** 1111 01ss rsrc 10sz push%s %1 */",
6895 op[0], op[1]);
6896 printf (" ss = 0x%x,", ss);
6897 printf (" rsrc = 0x%x,", rsrc);
6898 printf (" sz = 0x%x\n", sz);
6899 }
6900 SYNTAX("push%s %1");
6901 #line 357 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6902 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F("----");
6903
6904 /*----------------------------------------------------------------------*/
6905 /* XCHG */
6906
6907 }
6908 break;
6909 default: UNSUPPORTED(); break;
6910 }
6911 break;
6912 case 0xf5:
6913 GETBYTE ();
6914 switch (op[1] & 0x0c)
6915 {
6916 case 0x00:
6917 case 0x04:
6918 goto op_semantics_44;
6919 break;
6920 case 0x08:
6921 goto op_semantics_45;
6922 break;
6923 default: UNSUPPORTED(); break;
6924 }
6925 break;
6926 case 0xf6:
6927 GETBYTE ();
6928 switch (op[1] & 0x0c)
6929 {
6930 case 0x00:
6931 case 0x04:
6932 goto op_semantics_44;
6933 break;
6934 case 0x08:
6935 goto op_semantics_45;
6936 break;
6937 default: UNSUPPORTED(); break;
6938 }
6939 break;
6940 case 0xf7:
6941 GETBYTE ();
6942 switch (op[1] & 0x0c)
6943 {
6944 case 0x00:
6945 case 0x04:
6946 goto op_semantics_44;
6947 break;
6948 case 0x08:
6949 goto op_semantics_45;
6950 break;
6951 default: UNSUPPORTED(); break;
6952 }
6953 break;
6954 case 0xf8:
6955 GETBYTE ();
6956 switch (op[1] & 0x00)
6957 {
6958 case 0x00:
6959 op_semantics_46:
6960 {
6961 /** 1111 10sd rdst im sz mov%s #%1, %0 */
6962 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6963 int sd AU = op[0] & 0x03;
6964 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6965 int rdst AU = (op[1] >> 4) & 0x0f;
6966 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6967 int im AU = (op[1] >> 2) & 0x03;
6968 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6969 int sz AU = op[1] & 0x03;
6970 if (trace)
6971 {
6972 printf ("\033[33m%s\033[0m %02x %02x\n",
6973 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
6974 op[0], op[1]);
6975 printf (" sd = 0x%x,", sd);
6976 printf (" rdst = 0x%x,", rdst);
6977 printf (" im = 0x%x,", im);
6978 printf (" sz = 0x%x\n", sz);
6979 }
6980 SYNTAX("mov%s #%1, %0");
6981 #line 289 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6982 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F("----");
6983
6984 }
6985 break;
6986 }
6987 break;
6988 case 0xf9:
6989 GETBYTE ();
6990 switch (op[1] & 0x00)
6991 {
6992 case 0x00:
6993 goto op_semantics_46;
6994 break;
6995 }
6996 break;
6997 case 0xfa:
6998 GETBYTE ();
6999 switch (op[1] & 0x00)
7000 {
7001 case 0x00:
7002 goto op_semantics_46;
7003 break;
7004 }
7005 break;
7006 case 0xfb:
7007 GETBYTE ();
7008 switch (op[1] & 0x00)
7009 {
7010 case 0x00:
7011 goto op_semantics_46;
7012 break;
7013 }
7014 break;
7015 case 0xfc:
7016 GETBYTE ();
7017 switch (op[1] & 0xff)
7018 {
7019 case 0x03:
7020 GETBYTE ();
7021 switch (op[2] & 0x00)
7022 {
7023 case 0x00:
7024 {
7025 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7026 #line 530 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7027 int rsrc AU = (op[2] >> 4) & 0x0f;
7028 #line 530 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7029 int rdst AU = op[2] & 0x0f;
7030 if (trace)
7031 {
7032 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7033 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7034 op[0], op[1], op[2]);
7035 printf (" rsrc = 0x%x,", rsrc);
7036 printf (" rdst = 0x%x\n", rdst);
7037 }
7038 SYNTAX("sbb %1, %0");
7039 #line 531 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7040 ID(sbb); SR (rsrc); DR(rdst); F("OSZC");
7041
7042 /* FIXME: only supports .L */
7043 }
7044 break;
7045 }
7046 break;
7047 case 0x07:
7048 GETBYTE ();
7049 switch (op[2] & 0x00)
7050 {
7051 case 0x00:
7052 {
7053 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7054 #line 461 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7055 int rsrc AU = (op[2] >> 4) & 0x0f;
7056 #line 461 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7057 int rdst AU = op[2] & 0x0f;
7058 if (trace)
7059 {
7060 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7061 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7062 op[0], op[1], op[2]);
7063 printf (" rsrc = 0x%x,", rsrc);
7064 printf (" rdst = 0x%x\n", rdst);
7065 }
7066 SYNTAX("neg %2, %0");
7067 #line 462 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7068 ID(sub); DR(rdst); SC(0); S2R(rsrc); F("OSZC");
7069
7070 /*----------------------------------------------------------------------*/
7071 /* ADC */
7072
7073 }
7074 break;
7075 }
7076 break;
7077 case 0x0b:
7078 GETBYTE ();
7079 switch (op[2] & 0x00)
7080 {
7081 case 0x00:
7082 {
7083 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7084 #line 470 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7085 int rsrc AU = (op[2] >> 4) & 0x0f;
7086 #line 470 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7087 int rdst AU = op[2] & 0x0f;
7088 if (trace)
7089 {
7090 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7091 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7092 op[0], op[1], op[2]);
7093 printf (" rsrc = 0x%x,", rsrc);
7094 printf (" rdst = 0x%x\n", rdst);
7095 }
7096 SYNTAX("adc %1, %0");
7097 #line 471 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7098 ID(adc); SR(rsrc); DR(rdst); F("OSZC");
7099
7100 }
7101 break;
7102 }
7103 break;
7104 case 0x0f:
7105 GETBYTE ();
7106 switch (op[2] & 0x00)
7107 {
7108 case 0x00:
7109 {
7110 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7111 #line 543 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7112 int rsrc AU = (op[2] >> 4) & 0x0f;
7113 #line 543 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7114 int rdst AU = op[2] & 0x0f;
7115 if (trace)
7116 {
7117 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7118 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7119 op[0], op[1], op[2]);
7120 printf (" rsrc = 0x%x,", rsrc);
7121 printf (" rdst = 0x%x\n", rdst);
7122 }
7123 SYNTAX("abs %1, %0");
7124 #line 544 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7125 ID(abs); DR(rdst); SR(rsrc); F("OSZ-");
7126
7127 /*----------------------------------------------------------------------*/
7128 /* MAX */
7129
7130 }
7131 break;
7132 }
7133 break;
7134 case 0x10:
7135 GETBYTE ();
7136 switch (op[2] & 0x00)
7137 {
7138 case 0x00:
7139 op_semantics_47:
7140 {
7141 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7142 #line 552 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7143 int ss AU = op[1] & 0x03;
7144 #line 552 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7145 int rsrc AU = (op[2] >> 4) & 0x0f;
7146 #line 552 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7147 int rdst AU = op[2] & 0x0f;
7148 if (trace)
7149 {
7150 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7151 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7152 op[0], op[1], op[2]);
7153 printf (" ss = 0x%x,", ss);
7154 printf (" rsrc = 0x%x,", rsrc);
7155 printf (" rdst = 0x%x\n", rdst);
7156 }
7157 SYNTAX("max %1%S1, %0");
7158 #line 553 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7159 ID(max); SP(ss, rsrc); DR(rdst);
7160
7161 }
7162 break;
7163 }
7164 break;
7165 case 0x11:
7166 GETBYTE ();
7167 switch (op[2] & 0x00)
7168 {
7169 case 0x00:
7170 goto op_semantics_47;
7171 break;
7172 }
7173 break;
7174 case 0x12:
7175 GETBYTE ();
7176 switch (op[2] & 0x00)
7177 {
7178 case 0x00:
7179 goto op_semantics_47;
7180 break;
7181 }
7182 break;
7183 case 0x13:
7184 GETBYTE ();
7185 switch (op[2] & 0x00)
7186 {
7187 case 0x00:
7188 goto op_semantics_47;
7189 break;
7190 }
7191 break;
7192 case 0x14:
7193 GETBYTE ();
7194 switch (op[2] & 0x00)
7195 {
7196 case 0x00:
7197 op_semantics_48:
7198 {
7199 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7200 #line 564 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7201 int ss AU = op[1] & 0x03;
7202 #line 564 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7203 int rsrc AU = (op[2] >> 4) & 0x0f;
7204 #line 564 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7205 int rdst AU = op[2] & 0x0f;
7206 if (trace)
7207 {
7208 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7209 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7210 op[0], op[1], op[2]);
7211 printf (" ss = 0x%x,", ss);
7212 printf (" rsrc = 0x%x,", rsrc);
7213 printf (" rdst = 0x%x\n", rdst);
7214 }
7215 SYNTAX("min %1%S1, %0");
7216 #line 565 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7217 ID(min); SP(ss, rsrc); DR(rdst);
7218
7219 }
7220 break;
7221 }
7222 break;
7223 case 0x15:
7224 GETBYTE ();
7225 switch (op[2] & 0x00)
7226 {
7227 case 0x00:
7228 goto op_semantics_48;
7229 break;
7230 }
7231 break;
7232 case 0x16:
7233 GETBYTE ();
7234 switch (op[2] & 0x00)
7235 {
7236 case 0x00:
7237 goto op_semantics_48;
7238 break;
7239 }
7240 break;
7241 case 0x17:
7242 GETBYTE ();
7243 switch (op[2] & 0x00)
7244 {
7245 case 0x00:
7246 goto op_semantics_48;
7247 break;
7248 }
7249 break;
7250 case 0x18:
7251 GETBYTE ();
7252 switch (op[2] & 0x00)
7253 {
7254 case 0x00:
7255 op_semantics_49:
7256 {
7257 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7258 #line 594 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7259 int ss AU = op[1] & 0x03;
7260 #line 594 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7261 int rsrc AU = (op[2] >> 4) & 0x0f;
7262 #line 594 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7263 int rdst AU = op[2] & 0x0f;
7264 if (trace)
7265 {
7266 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7267 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7268 op[0], op[1], op[2]);
7269 printf (" ss = 0x%x,", ss);
7270 printf (" rsrc = 0x%x,", rsrc);
7271 printf (" rdst = 0x%x\n", rdst);
7272 }
7273 SYNTAX("emul %1%S1, %0");
7274 #line 595 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7275 ID(emul); SP(ss, rsrc); DR(rdst);
7276
7277 }
7278 break;
7279 }
7280 break;
7281 case 0x19:
7282 GETBYTE ();
7283 switch (op[2] & 0x00)
7284 {
7285 case 0x00:
7286 goto op_semantics_49;
7287 break;
7288 }
7289 break;
7290 case 0x1a:
7291 GETBYTE ();
7292 switch (op[2] & 0x00)
7293 {
7294 case 0x00:
7295 goto op_semantics_49;
7296 break;
7297 }
7298 break;
7299 case 0x1b:
7300 GETBYTE ();
7301 switch (op[2] & 0x00)
7302 {
7303 case 0x00:
7304 goto op_semantics_49;
7305 break;
7306 }
7307 break;
7308 case 0x1c:
7309 GETBYTE ();
7310 switch (op[2] & 0x00)
7311 {
7312 case 0x00:
7313 op_semantics_50:
7314 {
7315 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7316 #line 606 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7317 int ss AU = op[1] & 0x03;
7318 #line 606 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7319 int rsrc AU = (op[2] >> 4) & 0x0f;
7320 #line 606 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7321 int rdst AU = op[2] & 0x0f;
7322 if (trace)
7323 {
7324 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7325 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7326 op[0], op[1], op[2]);
7327 printf (" ss = 0x%x,", ss);
7328 printf (" rsrc = 0x%x,", rsrc);
7329 printf (" rdst = 0x%x\n", rdst);
7330 }
7331 SYNTAX("emulu %1%S1, %0");
7332 #line 607 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7333 ID(emulu); SP(ss, rsrc); DR(rdst);
7334
7335 }
7336 break;
7337 }
7338 break;
7339 case 0x1d:
7340 GETBYTE ();
7341 switch (op[2] & 0x00)
7342 {
7343 case 0x00:
7344 goto op_semantics_50;
7345 break;
7346 }
7347 break;
7348 case 0x1e:
7349 GETBYTE ();
7350 switch (op[2] & 0x00)
7351 {
7352 case 0x00:
7353 goto op_semantics_50;
7354 break;
7355 }
7356 break;
7357 case 0x1f:
7358 GETBYTE ();
7359 switch (op[2] & 0x00)
7360 {
7361 case 0x00:
7362 goto op_semantics_50;
7363 break;
7364 }
7365 break;
7366 case 0x20:
7367 GETBYTE ();
7368 switch (op[2] & 0x00)
7369 {
7370 case 0x00:
7371 op_semantics_51:
7372 {
7373 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7374 #line 618 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7375 int ss AU = op[1] & 0x03;
7376 #line 618 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7377 int rsrc AU = (op[2] >> 4) & 0x0f;
7378 #line 618 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7379 int rdst AU = op[2] & 0x0f;
7380 if (trace)
7381 {
7382 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7383 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7384 op[0], op[1], op[2]);
7385 printf (" ss = 0x%x,", ss);
7386 printf (" rsrc = 0x%x,", rsrc);
7387 printf (" rdst = 0x%x\n", rdst);
7388 }
7389 SYNTAX("div %1%S1, %0");
7390 #line 619 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7391 ID(div); SP(ss, rsrc); DR(rdst); F("O---");
7392
7393 }
7394 break;
7395 }
7396 break;
7397 case 0x21:
7398 GETBYTE ();
7399 switch (op[2] & 0x00)
7400 {
7401 case 0x00:
7402 goto op_semantics_51;
7403 break;
7404 }
7405 break;
7406 case 0x22:
7407 GETBYTE ();
7408 switch (op[2] & 0x00)
7409 {
7410 case 0x00:
7411 goto op_semantics_51;
7412 break;
7413 }
7414 break;
7415 case 0x23:
7416 GETBYTE ();
7417 switch (op[2] & 0x00)
7418 {
7419 case 0x00:
7420 goto op_semantics_51;
7421 break;
7422 }
7423 break;
7424 case 0x24:
7425 GETBYTE ();
7426 switch (op[2] & 0x00)
7427 {
7428 case 0x00:
7429 op_semantics_52:
7430 {
7431 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7432 #line 630 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7433 int ss AU = op[1] & 0x03;
7434 #line 630 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7435 int rsrc AU = (op[2] >> 4) & 0x0f;
7436 #line 630 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7437 int rdst AU = op[2] & 0x0f;
7438 if (trace)
7439 {
7440 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7441 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7442 op[0], op[1], op[2]);
7443 printf (" ss = 0x%x,", ss);
7444 printf (" rsrc = 0x%x,", rsrc);
7445 printf (" rdst = 0x%x\n", rdst);
7446 }
7447 SYNTAX("divu %1%S1, %0");
7448 #line 631 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7449 ID(divu); SP(ss, rsrc); DR(rdst); F("O---");
7450
7451 }
7452 break;
7453 }
7454 break;
7455 case 0x25:
7456 GETBYTE ();
7457 switch (op[2] & 0x00)
7458 {
7459 case 0x00:
7460 goto op_semantics_52;
7461 break;
7462 }
7463 break;
7464 case 0x26:
7465 GETBYTE ();
7466 switch (op[2] & 0x00)
7467 {
7468 case 0x00:
7469 goto op_semantics_52;
7470 break;
7471 }
7472 break;
7473 case 0x27:
7474 GETBYTE ();
7475 switch (op[2] & 0x00)
7476 {
7477 case 0x00:
7478 goto op_semantics_52;
7479 break;
7480 }
7481 break;
7482 case 0x30:
7483 GETBYTE ();
7484 switch (op[2] & 0x00)
7485 {
7486 case 0x00:
7487 op_semantics_53:
7488 {
7489 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7490 #line 449 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7491 int ss AU = op[1] & 0x03;
7492 #line 449 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7493 int rsrc AU = (op[2] >> 4) & 0x0f;
7494 #line 449 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7495 int rdst AU = op[2] & 0x0f;
7496 if (trace)
7497 {
7498 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7499 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7500 op[0], op[1], op[2]);
7501 printf (" ss = 0x%x,", ss);
7502 printf (" rsrc = 0x%x,", rsrc);
7503 printf (" rdst = 0x%x\n", rdst);
7504 }
7505 SYNTAX("tst %1%S1, %2");
7506 #line 450 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7507 ID(and); SP(ss, rsrc); S2R(rdst); F("-SZ-");
7508
7509 }
7510 break;
7511 }
7512 break;
7513 case 0x31:
7514 GETBYTE ();
7515 switch (op[2] & 0x00)
7516 {
7517 case 0x00:
7518 goto op_semantics_53;
7519 break;
7520 }
7521 break;
7522 case 0x32:
7523 GETBYTE ();
7524 switch (op[2] & 0x00)
7525 {
7526 case 0x00:
7527 goto op_semantics_53;
7528 break;
7529 }
7530 break;
7531 case 0x33:
7532 GETBYTE ();
7533 switch (op[2] & 0x00)
7534 {
7535 case 0x00:
7536 goto op_semantics_53;
7537 break;
7538 }
7539 break;
7540 case 0x34:
7541 GETBYTE ();
7542 switch (op[2] & 0x00)
7543 {
7544 case 0x00:
7545 op_semantics_54:
7546 {
7547 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7548 #line 428 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7549 int ss AU = op[1] & 0x03;
7550 #line 428 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7551 int rsrc AU = (op[2] >> 4) & 0x0f;
7552 #line 428 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7553 int rdst AU = op[2] & 0x0f;
7554 if (trace)
7555 {
7556 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7557 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7558 op[0], op[1], op[2]);
7559 printf (" ss = 0x%x,", ss);
7560 printf (" rsrc = 0x%x,", rsrc);
7561 printf (" rdst = 0x%x\n", rdst);
7562 }
7563 SYNTAX("xor %1%S1, %0");
7564 #line 429 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7565 ID(xor); SP(ss, rsrc); DR(rdst); F("-SZ-");
7566
7567 }
7568 break;
7569 }
7570 break;
7571 case 0x35:
7572 GETBYTE ();
7573 switch (op[2] & 0x00)
7574 {
7575 case 0x00:
7576 goto op_semantics_54;
7577 break;
7578 }
7579 break;
7580 case 0x36:
7581 GETBYTE ();
7582 switch (op[2] & 0x00)
7583 {
7584 case 0x00:
7585 goto op_semantics_54;
7586 break;
7587 }
7588 break;
7589 case 0x37:
7590 GETBYTE ();
7591 switch (op[2] & 0x00)
7592 {
7593 case 0x00:
7594 goto op_semantics_54;
7595 break;
7596 }
7597 break;
7598 case 0x3b:
7599 GETBYTE ();
7600 switch (op[2] & 0x00)
7601 {
7602 case 0x00:
7603 {
7604 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7605 #line 440 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7606 int rsrc AU = (op[2] >> 4) & 0x0f;
7607 #line 440 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7608 int rdst AU = op[2] & 0x0f;
7609 if (trace)
7610 {
7611 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7612 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7613 op[0], op[1], op[2]);
7614 printf (" rsrc = 0x%x,", rsrc);
7615 printf (" rdst = 0x%x\n", rdst);
7616 }
7617 SYNTAX("not %1, %0");
7618 #line 441 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7619 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F("-SZ-");
7620
7621 /*----------------------------------------------------------------------*/
7622 /* TST */
7623
7624 }
7625 break;
7626 }
7627 break;
7628 case 0x40:
7629 GETBYTE ();
7630 switch (op[2] & 0x00)
7631 {
7632 case 0x00:
7633 op_semantics_55:
7634 {
7635 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7636 #line 362 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7637 int ss AU = op[1] & 0x03;
7638 #line 362 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7639 int rsrc AU = (op[2] >> 4) & 0x0f;
7640 #line 362 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7641 int rdst AU = op[2] & 0x0f;
7642 if (trace)
7643 {
7644 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7645 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7646 op[0], op[1], op[2]);
7647 printf (" ss = 0x%x,", ss);
7648 printf (" rsrc = 0x%x,", rsrc);
7649 printf (" rdst = 0x%x\n", rdst);
7650 }
7651 SYNTAX("xchg %1%S1, %0");
7652 #line 363 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7653 ID(xchg); DR(rdst); SP(ss, rsrc);
7654
7655 }
7656 break;
7657 }
7658 break;
7659 case 0x41:
7660 GETBYTE ();
7661 switch (op[2] & 0x00)
7662 {
7663 case 0x00:
7664 goto op_semantics_55;
7665 break;
7666 }
7667 break;
7668 case 0x42:
7669 GETBYTE ();
7670 switch (op[2] & 0x00)
7671 {
7672 case 0x00:
7673 goto op_semantics_55;
7674 break;
7675 }
7676 break;
7677 case 0x43:
7678 GETBYTE ();
7679 switch (op[2] & 0x00)
7680 {
7681 case 0x00:
7682 goto op_semantics_55;
7683 break;
7684 }
7685 break;
7686 case 0x44:
7687 GETBYTE ();
7688 switch (op[2] & 0x00)
7689 {
7690 case 0x00:
7691 op_semantics_56:
7692 {
7693 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7694 #line 859 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7695 int sd AU = op[1] & 0x03;
7696 #line 859 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7697 int rsrc AU = (op[2] >> 4) & 0x0f;
7698 #line 859 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7699 int rdst AU = op[2] & 0x0f;
7700 if (trace)
7701 {
7702 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7703 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7704 op[0], op[1], op[2]);
7705 printf (" sd = 0x%x,", sd);
7706 printf (" rsrc = 0x%x,", rsrc);
7707 printf (" rdst = 0x%x\n", rdst);
7708 }
7709 SYNTAX("itof %1%S1, %0");
7710 #line 860 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7711 ID(itof); DR (rdst); SP(sd, rsrc); F("-SZ-");
7712
7713 }
7714 break;
7715 }
7716 break;
7717 case 0x45:
7718 GETBYTE ();
7719 switch (op[2] & 0x00)
7720 {
7721 case 0x00:
7722 goto op_semantics_56;
7723 break;
7724 }
7725 break;
7726 case 0x46:
7727 GETBYTE ();
7728 switch (op[2] & 0x00)
7729 {
7730 case 0x00:
7731 goto op_semantics_56;
7732 break;
7733 }
7734 break;
7735 case 0x47:
7736 GETBYTE ();
7737 switch (op[2] & 0x00)
7738 {
7739 case 0x00:
7740 goto op_semantics_56;
7741 break;
7742 }
7743 break;
7744 case 0x60:
7745 GETBYTE ();
7746 switch (op[2] & 0x00)
7747 {
7748 case 0x00:
7749 op_semantics_57:
7750 {
7751 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
7752 #line 871 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7753 int sd AU = op[1] & 0x03;
7754 #line 871 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7755 int rdst AU = (op[2] >> 4) & 0x0f;
7756 #line 871 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7757 int rsrc AU = op[2] & 0x0f;
7758 if (trace)
7759 {
7760 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7761 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7762 op[0], op[1], op[2]);
7763 printf (" sd = 0x%x,", sd);
7764 printf (" rdst = 0x%x,", rdst);
7765 printf (" rsrc = 0x%x\n", rsrc);
7766 }
7767 SYNTAX("bset %1, %0%S0");
7768 #line 872 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7769 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7770
7771 }
7772 break;
7773 }
7774 break;
7775 case 0x61:
7776 GETBYTE ();
7777 switch (op[2] & 0x00)
7778 {
7779 case 0x00:
7780 goto op_semantics_57;
7781 break;
7782 }
7783 break;
7784 case 0x62:
7785 GETBYTE ();
7786 switch (op[2] & 0x00)
7787 {
7788 case 0x00:
7789 goto op_semantics_57;
7790 break;
7791 }
7792 break;
7793 case 0x63:
7794 GETBYTE ();
7795 switch (op[2] & 0x00)
7796 {
7797 case 0x00:
7798 goto op_semantics_57;
7799 break;
7800 }
7801 break;
7802 case 0x64:
7803 GETBYTE ();
7804 switch (op[2] & 0x00)
7805 {
7806 case 0x00:
7807 op_semantics_58:
7808 {
7809 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
7810 #line 881 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7811 int sd AU = op[1] & 0x03;
7812 #line 881 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7813 int rdst AU = (op[2] >> 4) & 0x0f;
7814 #line 881 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7815 int rsrc AU = op[2] & 0x0f;
7816 if (trace)
7817 {
7818 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7819 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7820 op[0], op[1], op[2]);
7821 printf (" sd = 0x%x,", sd);
7822 printf (" rdst = 0x%x,", rdst);
7823 printf (" rsrc = 0x%x\n", rsrc);
7824 }
7825 SYNTAX("bclr %1, %0%S0");
7826 #line 882 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7827 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7828
7829 }
7830 break;
7831 }
7832 break;
7833 case 0x65:
7834 GETBYTE ();
7835 switch (op[2] & 0x00)
7836 {
7837 case 0x00:
7838 goto op_semantics_58;
7839 break;
7840 }
7841 break;
7842 case 0x66:
7843 GETBYTE ();
7844 switch (op[2] & 0x00)
7845 {
7846 case 0x00:
7847 goto op_semantics_58;
7848 break;
7849 }
7850 break;
7851 case 0x67:
7852 GETBYTE ();
7853 switch (op[2] & 0x00)
7854 {
7855 case 0x00:
7856 goto op_semantics_58;
7857 break;
7858 }
7859 break;
7860 case 0x68:
7861 GETBYTE ();
7862 switch (op[2] & 0x00)
7863 {
7864 case 0x00:
7865 op_semantics_59:
7866 {
7867 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
7868 #line 891 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7869 int sd AU = op[1] & 0x03;
7870 #line 891 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7871 int rdst AU = (op[2] >> 4) & 0x0f;
7872 #line 891 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7873 int rsrc AU = op[2] & 0x0f;
7874 if (trace)
7875 {
7876 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7877 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7878 op[0], op[1], op[2]);
7879 printf (" sd = 0x%x,", sd);
7880 printf (" rdst = 0x%x,", rdst);
7881 printf (" rsrc = 0x%x\n", rsrc);
7882 }
7883 SYNTAX("btst %2, %1%S1");
7884 #line 892 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7885 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F("--ZC");
7886
7887 }
7888 break;
7889 }
7890 break;
7891 case 0x69:
7892 GETBYTE ();
7893 switch (op[2] & 0x00)
7894 {
7895 case 0x00:
7896 goto op_semantics_59;
7897 break;
7898 }
7899 break;
7900 case 0x6a:
7901 GETBYTE ();
7902 switch (op[2] & 0x00)
7903 {
7904 case 0x00:
7905 goto op_semantics_59;
7906 break;
7907 }
7908 break;
7909 case 0x6b:
7910 GETBYTE ();
7911 switch (op[2] & 0x00)
7912 {
7913 case 0x00:
7914 goto op_semantics_59;
7915 break;
7916 }
7917 break;
7918 case 0x6c:
7919 GETBYTE ();
7920 switch (op[2] & 0x00)
7921 {
7922 case 0x00:
7923 op_semantics_60:
7924 {
7925 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
7926 #line 901 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7927 int sd AU = op[1] & 0x03;
7928 #line 901 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7929 int rdst AU = (op[2] >> 4) & 0x0f;
7930 #line 901 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7931 int rsrc AU = op[2] & 0x0f;
7932 if (trace)
7933 {
7934 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7935 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
7936 op[0], op[1], op[2]);
7937 printf (" sd = 0x%x,", sd);
7938 printf (" rdst = 0x%x,", rdst);
7939 printf (" rsrc = 0x%x\n", rsrc);
7940 }
7941 SYNTAX("bnot %1, %0%S0");
7942 #line 902 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7943 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7944
7945 }
7946 break;
7947 }
7948 break;
7949 case 0x6d:
7950 GETBYTE ();
7951 switch (op[2] & 0x00)
7952 {
7953 case 0x00:
7954 goto op_semantics_60;
7955 break;
7956 }
7957 break;
7958 case 0x6e:
7959 GETBYTE ();
7960 switch (op[2] & 0x00)
7961 {
7962 case 0x00:
7963 goto op_semantics_60;
7964 break;
7965 }
7966 break;
7967 case 0x6f:
7968 GETBYTE ();
7969 switch (op[2] & 0x00)
7970 {
7971 case 0x00:
7972 goto op_semantics_60;
7973 break;
7974 }
7975 break;
7976 case 0x80:
7977 GETBYTE ();
7978 switch (op[2] & 0x00)
7979 {
7980 case 0x00:
7981 op_semantics_61:
7982 {
7983 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
7984 #line 838 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7985 int sd AU = op[1] & 0x03;
7986 #line 838 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7987 int rsrc AU = (op[2] >> 4) & 0x0f;
7988 #line 838 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7989 int rdst AU = op[2] & 0x0f;
7990 if (trace)
7991 {
7992 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7993 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
7994 op[0], op[1], op[2]);
7995 printf (" sd = 0x%x,", sd);
7996 printf (" rsrc = 0x%x,", rsrc);
7997 printf (" rdst = 0x%x\n", rdst);
7998 }
7999 SYNTAX("fsub %1%S1, %0");
8000 #line 839 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8001 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8002
8003 }
8004 break;
8005 }
8006 break;
8007 case 0x81:
8008 GETBYTE ();
8009 switch (op[2] & 0x00)
8010 {
8011 case 0x00:
8012 goto op_semantics_61;
8013 break;
8014 }
8015 break;
8016 case 0x82:
8017 GETBYTE ();
8018 switch (op[2] & 0x00)
8019 {
8020 case 0x00:
8021 goto op_semantics_61;
8022 break;
8023 }
8024 break;
8025 case 0x83:
8026 GETBYTE ();
8027 switch (op[2] & 0x00)
8028 {
8029 case 0x00:
8030 goto op_semantics_61;
8031 break;
8032 }
8033 break;
8034 case 0x84:
8035 GETBYTE ();
8036 switch (op[2] & 0x00)
8037 {
8038 case 0x00:
8039 op_semantics_62:
8040 {
8041 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8042 #line 832 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8043 int sd AU = op[1] & 0x03;
8044 #line 832 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8045 int rsrc AU = (op[2] >> 4) & 0x0f;
8046 #line 832 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8047 int rdst AU = op[2] & 0x0f;
8048 if (trace)
8049 {
8050 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8051 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8052 op[0], op[1], op[2]);
8053 printf (" sd = 0x%x,", sd);
8054 printf (" rsrc = 0x%x,", rsrc);
8055 printf (" rdst = 0x%x\n", rdst);
8056 }
8057 SYNTAX("fcmp %1%S1, %0");
8058 #line 833 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8059 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F("OSZ-");
8060
8061 }
8062 break;
8063 }
8064 break;
8065 case 0x85:
8066 GETBYTE ();
8067 switch (op[2] & 0x00)
8068 {
8069 case 0x00:
8070 goto op_semantics_62;
8071 break;
8072 }
8073 break;
8074 case 0x86:
8075 GETBYTE ();
8076 switch (op[2] & 0x00)
8077 {
8078 case 0x00:
8079 goto op_semantics_62;
8080 break;
8081 }
8082 break;
8083 case 0x87:
8084 GETBYTE ();
8085 switch (op[2] & 0x00)
8086 {
8087 case 0x00:
8088 goto op_semantics_62;
8089 break;
8090 }
8091 break;
8092 case 0x88:
8093 GETBYTE ();
8094 switch (op[2] & 0x00)
8095 {
8096 case 0x00:
8097 op_semantics_63:
8098 {
8099 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8100 #line 826 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8101 int sd AU = op[1] & 0x03;
8102 #line 826 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8103 int rsrc AU = (op[2] >> 4) & 0x0f;
8104 #line 826 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8105 int rdst AU = op[2] & 0x0f;
8106 if (trace)
8107 {
8108 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8109 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8110 op[0], op[1], op[2]);
8111 printf (" sd = 0x%x,", sd);
8112 printf (" rsrc = 0x%x,", rsrc);
8113 printf (" rdst = 0x%x\n", rdst);
8114 }
8115 SYNTAX("fadd %1%S1, %0");
8116 #line 827 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8117 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8118
8119 }
8120 break;
8121 }
8122 break;
8123 case 0x89:
8124 GETBYTE ();
8125 switch (op[2] & 0x00)
8126 {
8127 case 0x00:
8128 goto op_semantics_63;
8129 break;
8130 }
8131 break;
8132 case 0x8a:
8133 GETBYTE ();
8134 switch (op[2] & 0x00)
8135 {
8136 case 0x00:
8137 goto op_semantics_63;
8138 break;
8139 }
8140 break;
8141 case 0x8b:
8142 GETBYTE ();
8143 switch (op[2] & 0x00)
8144 {
8145 case 0x00:
8146 goto op_semantics_63;
8147 break;
8148 }
8149 break;
8150 case 0x8c:
8151 GETBYTE ();
8152 switch (op[2] & 0x00)
8153 {
8154 case 0x00:
8155 op_semantics_64:
8156 {
8157 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8158 #line 847 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8159 int sd AU = op[1] & 0x03;
8160 #line 847 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8161 int rsrc AU = (op[2] >> 4) & 0x0f;
8162 #line 847 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8163 int rdst AU = op[2] & 0x0f;
8164 if (trace)
8165 {
8166 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8167 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8168 op[0], op[1], op[2]);
8169 printf (" sd = 0x%x,", sd);
8170 printf (" rsrc = 0x%x,", rsrc);
8171 printf (" rdst = 0x%x\n", rdst);
8172 }
8173 SYNTAX("fmul %1%S1, %0");
8174 #line 848 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8175 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8176
8177 }
8178 break;
8179 }
8180 break;
8181 case 0x8d:
8182 GETBYTE ();
8183 switch (op[2] & 0x00)
8184 {
8185 case 0x00:
8186 goto op_semantics_64;
8187 break;
8188 }
8189 break;
8190 case 0x8e:
8191 GETBYTE ();
8192 switch (op[2] & 0x00)
8193 {
8194 case 0x00:
8195 goto op_semantics_64;
8196 break;
8197 }
8198 break;
8199 case 0x8f:
8200 GETBYTE ();
8201 switch (op[2] & 0x00)
8202 {
8203 case 0x00:
8204 goto op_semantics_64;
8205 break;
8206 }
8207 break;
8208 case 0x90:
8209 GETBYTE ();
8210 switch (op[2] & 0x00)
8211 {
8212 case 0x00:
8213 op_semantics_65:
8214 {
8215 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8216 #line 853 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8217 int sd AU = op[1] & 0x03;
8218 #line 853 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8219 int rsrc AU = (op[2] >> 4) & 0x0f;
8220 #line 853 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8221 int rdst AU = op[2] & 0x0f;
8222 if (trace)
8223 {
8224 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8225 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8226 op[0], op[1], op[2]);
8227 printf (" sd = 0x%x,", sd);
8228 printf (" rsrc = 0x%x,", rsrc);
8229 printf (" rdst = 0x%x\n", rdst);
8230 }
8231 SYNTAX("fdiv %1%S1, %0");
8232 #line 854 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8233 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8234
8235 }
8236 break;
8237 }
8238 break;
8239 case 0x91:
8240 GETBYTE ();
8241 switch (op[2] & 0x00)
8242 {
8243 case 0x00:
8244 goto op_semantics_65;
8245 break;
8246 }
8247 break;
8248 case 0x92:
8249 GETBYTE ();
8250 switch (op[2] & 0x00)
8251 {
8252 case 0x00:
8253 goto op_semantics_65;
8254 break;
8255 }
8256 break;
8257 case 0x93:
8258 GETBYTE ();
8259 switch (op[2] & 0x00)
8260 {
8261 case 0x00:
8262 goto op_semantics_65;
8263 break;
8264 }
8265 break;
8266 case 0x94:
8267 GETBYTE ();
8268 switch (op[2] & 0x00)
8269 {
8270 case 0x00:
8271 op_semantics_66:
8272 {
8273 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8274 #line 841 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8275 int sd AU = op[1] & 0x03;
8276 #line 841 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8277 int rsrc AU = (op[2] >> 4) & 0x0f;
8278 #line 841 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8279 int rdst AU = op[2] & 0x0f;
8280 if (trace)
8281 {
8282 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8283 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8284 op[0], op[1], op[2]);
8285 printf (" sd = 0x%x,", sd);
8286 printf (" rsrc = 0x%x,", rsrc);
8287 printf (" rdst = 0x%x\n", rdst);
8288 }
8289 SYNTAX("ftoi %1%S1, %0");
8290 #line 842 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8291 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8292
8293 }
8294 break;
8295 }
8296 break;
8297 case 0x95:
8298 GETBYTE ();
8299 switch (op[2] & 0x00)
8300 {
8301 case 0x00:
8302 goto op_semantics_66;
8303 break;
8304 }
8305 break;
8306 case 0x96:
8307 GETBYTE ();
8308 switch (op[2] & 0x00)
8309 {
8310 case 0x00:
8311 goto op_semantics_66;
8312 break;
8313 }
8314 break;
8315 case 0x97:
8316 GETBYTE ();
8317 switch (op[2] & 0x00)
8318 {
8319 case 0x00:
8320 goto op_semantics_66;
8321 break;
8322 }
8323 break;
8324 case 0x98:
8325 GETBYTE ();
8326 switch (op[2] & 0x00)
8327 {
8328 case 0x00:
8329 op_semantics_67:
8330 {
8331 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8332 #line 856 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8333 int sd AU = op[1] & 0x03;
8334 #line 856 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8335 int rsrc AU = (op[2] >> 4) & 0x0f;
8336 #line 856 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8337 int rdst AU = op[2] & 0x0f;
8338 if (trace)
8339 {
8340 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8341 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8342 op[0], op[1], op[2]);
8343 printf (" sd = 0x%x,", sd);
8344 printf (" rsrc = 0x%x,", rsrc);
8345 printf (" rdst = 0x%x\n", rdst);
8346 }
8347 SYNTAX("round %1%S1, %0");
8348 #line 857 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8349 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8350
8351 }
8352 break;
8353 }
8354 break;
8355 case 0x99:
8356 GETBYTE ();
8357 switch (op[2] & 0x00)
8358 {
8359 case 0x00:
8360 goto op_semantics_67;
8361 break;
8362 }
8363 break;
8364 case 0x9a:
8365 GETBYTE ();
8366 switch (op[2] & 0x00)
8367 {
8368 case 0x00:
8369 goto op_semantics_67;
8370 break;
8371 }
8372 break;
8373 case 0x9b:
8374 GETBYTE ();
8375 switch (op[2] & 0x00)
8376 {
8377 case 0x00:
8378 goto op_semantics_67;
8379 break;
8380 }
8381 break;
8382 case 0xd0:
8383 GETBYTE ();
8384 switch (op[2] & 0x00)
8385 {
8386 case 0x00:
8387 op_semantics_68:
8388 {
8389 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8390 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8391 int sz AU = (op[1] >> 2) & 0x03;
8392 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8393 int sd AU = op[1] & 0x03;
8394 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8395 int rdst AU = (op[2] >> 4) & 0x0f;
8396 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8397 int cond AU = op[2] & 0x0f;
8398 if (trace)
8399 {
8400 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8401 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8402 op[0], op[1], op[2]);
8403 printf (" sz = 0x%x,", sz);
8404 printf (" sd = 0x%x,", sd);
8405 printf (" rdst = 0x%x,", rdst);
8406 printf (" cond = 0x%x\n", cond);
8407 }
8408 SYNTAX("sc%1%s %0");
8409 #line 972 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8410 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8411
8412 }
8413 break;
8414 }
8415 break;
8416 case 0xd1:
8417 GETBYTE ();
8418 switch (op[2] & 0x00)
8419 {
8420 case 0x00:
8421 goto op_semantics_68;
8422 break;
8423 }
8424 break;
8425 case 0xd2:
8426 GETBYTE ();
8427 switch (op[2] & 0x00)
8428 {
8429 case 0x00:
8430 goto op_semantics_68;
8431 break;
8432 }
8433 break;
8434 case 0xd3:
8435 GETBYTE ();
8436 switch (op[2] & 0x00)
8437 {
8438 case 0x00:
8439 goto op_semantics_68;
8440 break;
8441 }
8442 break;
8443 case 0xd4:
8444 GETBYTE ();
8445 switch (op[2] & 0x00)
8446 {
8447 case 0x00:
8448 goto op_semantics_68;
8449 break;
8450 }
8451 break;
8452 case 0xd5:
8453 GETBYTE ();
8454 switch (op[2] & 0x00)
8455 {
8456 case 0x00:
8457 goto op_semantics_68;
8458 break;
8459 }
8460 break;
8461 case 0xd6:
8462 GETBYTE ();
8463 switch (op[2] & 0x00)
8464 {
8465 case 0x00:
8466 goto op_semantics_68;
8467 break;
8468 }
8469 break;
8470 case 0xd7:
8471 GETBYTE ();
8472 switch (op[2] & 0x00)
8473 {
8474 case 0x00:
8475 goto op_semantics_68;
8476 break;
8477 }
8478 break;
8479 case 0xd8:
8480 GETBYTE ();
8481 switch (op[2] & 0x00)
8482 {
8483 case 0x00:
8484 goto op_semantics_68;
8485 break;
8486 }
8487 break;
8488 case 0xd9:
8489 GETBYTE ();
8490 switch (op[2] & 0x00)
8491 {
8492 case 0x00:
8493 goto op_semantics_68;
8494 break;
8495 }
8496 break;
8497 case 0xda:
8498 GETBYTE ();
8499 switch (op[2] & 0x00)
8500 {
8501 case 0x00:
8502 goto op_semantics_68;
8503 break;
8504 }
8505 break;
8506 case 0xdb:
8507 GETBYTE ();
8508 switch (op[2] & 0x00)
8509 {
8510 case 0x00:
8511 goto op_semantics_68;
8512 break;
8513 }
8514 break;
8515 case 0xe0:
8516 GETBYTE ();
8517 switch (op[2] & 0x0f)
8518 {
8519 case 0x00:
8520 case 0x01:
8521 case 0x02:
8522 case 0x03:
8523 case 0x04:
8524 case 0x05:
8525 case 0x06:
8526 case 0x07:
8527 case 0x08:
8528 case 0x09:
8529 case 0x0a:
8530 case 0x0b:
8531 case 0x0c:
8532 case 0x0d:
8533 case 0x0e:
8534 op_semantics_69:
8535 {
8536 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
8537 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8538 int bit AU = (op[1] >> 2) & 0x07;
8539 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8540 int sd AU = op[1] & 0x03;
8541 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8542 int rdst AU = (op[2] >> 4) & 0x0f;
8543 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8544 int cond AU = op[2] & 0x0f;
8545 if (trace)
8546 {
8547 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8548 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8549 op[0], op[1], op[2]);
8550 printf (" bit = 0x%x,", bit);
8551 printf (" sd = 0x%x,", sd);
8552 printf (" rdst = 0x%x,", rdst);
8553 printf (" cond = 0x%x\n", cond);
8554 }
8555 SYNTAX("bm%2 #%1, %0%S0");
8556 #line 909 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8557 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8558
8559 }
8560 break;
8561 case 0x0f:
8562 op_semantics_70:
8563 {
8564 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
8565 #line 898 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8566 int bit AU = (op[1] >> 2) & 0x07;
8567 #line 898 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8568 int sd AU = op[1] & 0x03;
8569 #line 898 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8570 int rdst AU = (op[2] >> 4) & 0x0f;
8571 if (trace)
8572 {
8573 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8574 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8575 op[0], op[1], op[2]);
8576 printf (" bit = 0x%x,", bit);
8577 printf (" sd = 0x%x,", sd);
8578 printf (" rdst = 0x%x\n", rdst);
8579 }
8580 SYNTAX("bnot #%1, %0%S0");
8581 #line 899 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8582 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8583
8584 }
8585 break;
8586 }
8587 break;
8588 case 0xe1:
8589 GETBYTE ();
8590 switch (op[2] & 0x0f)
8591 {
8592 case 0x00:
8593 case 0x01:
8594 case 0x02:
8595 case 0x03:
8596 case 0x04:
8597 case 0x05:
8598 case 0x06:
8599 case 0x07:
8600 case 0x08:
8601 case 0x09:
8602 case 0x0a:
8603 case 0x0b:
8604 case 0x0c:
8605 case 0x0d:
8606 case 0x0e:
8607 goto op_semantics_69;
8608 break;
8609 case 0x0f:
8610 goto op_semantics_70;
8611 break;
8612 }
8613 break;
8614 case 0xe2:
8615 GETBYTE ();
8616 switch (op[2] & 0x0f)
8617 {
8618 case 0x00:
8619 case 0x01:
8620 case 0x02:
8621 case 0x03:
8622 case 0x04:
8623 case 0x05:
8624 case 0x06:
8625 case 0x07:
8626 case 0x08:
8627 case 0x09:
8628 case 0x0a:
8629 case 0x0b:
8630 case 0x0c:
8631 case 0x0d:
8632 case 0x0e:
8633 goto op_semantics_69;
8634 break;
8635 case 0x0f:
8636 goto op_semantics_70;
8637 break;
8638 }
8639 break;
8640 case 0xe3:
8641 GETBYTE ();
8642 switch (op[2] & 0x0f)
8643 {
8644 case 0x00:
8645 case 0x01:
8646 case 0x02:
8647 case 0x03:
8648 case 0x04:
8649 case 0x05:
8650 case 0x06:
8651 case 0x07:
8652 case 0x08:
8653 case 0x09:
8654 case 0x0a:
8655 case 0x0b:
8656 case 0x0c:
8657 case 0x0d:
8658 case 0x0e:
8659 goto op_semantics_69;
8660 break;
8661 case 0x0f:
8662 goto op_semantics_70;
8663 break;
8664 }
8665 break;
8666 case 0xe4:
8667 GETBYTE ();
8668 switch (op[2] & 0x0f)
8669 {
8670 case 0x00:
8671 case 0x01:
8672 case 0x02:
8673 case 0x03:
8674 case 0x04:
8675 case 0x05:
8676 case 0x06:
8677 case 0x07:
8678 case 0x08:
8679 case 0x09:
8680 case 0x0a:
8681 case 0x0b:
8682 case 0x0c:
8683 case 0x0d:
8684 case 0x0e:
8685 goto op_semantics_69;
8686 break;
8687 case 0x0f:
8688 goto op_semantics_70;
8689 break;
8690 }
8691 break;
8692 case 0xe5:
8693 GETBYTE ();
8694 switch (op[2] & 0x0f)
8695 {
8696 case 0x00:
8697 case 0x01:
8698 case 0x02:
8699 case 0x03:
8700 case 0x04:
8701 case 0x05:
8702 case 0x06:
8703 case 0x07:
8704 case 0x08:
8705 case 0x09:
8706 case 0x0a:
8707 case 0x0b:
8708 case 0x0c:
8709 case 0x0d:
8710 case 0x0e:
8711 goto op_semantics_69;
8712 break;
8713 case 0x0f:
8714 goto op_semantics_70;
8715 break;
8716 }
8717 break;
8718 case 0xe6:
8719 GETBYTE ();
8720 switch (op[2] & 0x0f)
8721 {
8722 case 0x00:
8723 case 0x01:
8724 case 0x02:
8725 case 0x03:
8726 case 0x04:
8727 case 0x05:
8728 case 0x06:
8729 case 0x07:
8730 case 0x08:
8731 case 0x09:
8732 case 0x0a:
8733 case 0x0b:
8734 case 0x0c:
8735 case 0x0d:
8736 case 0x0e:
8737 goto op_semantics_69;
8738 break;
8739 case 0x0f:
8740 goto op_semantics_70;
8741 break;
8742 }
8743 break;
8744 case 0xe7:
8745 GETBYTE ();
8746 switch (op[2] & 0x0f)
8747 {
8748 case 0x00:
8749 case 0x01:
8750 case 0x02:
8751 case 0x03:
8752 case 0x04:
8753 case 0x05:
8754 case 0x06:
8755 case 0x07:
8756 case 0x08:
8757 case 0x09:
8758 case 0x0a:
8759 case 0x0b:
8760 case 0x0c:
8761 case 0x0d:
8762 case 0x0e:
8763 goto op_semantics_69;
8764 break;
8765 case 0x0f:
8766 goto op_semantics_70;
8767 break;
8768 }
8769 break;
8770 case 0xe8:
8771 GETBYTE ();
8772 switch (op[2] & 0x0f)
8773 {
8774 case 0x00:
8775 case 0x01:
8776 case 0x02:
8777 case 0x03:
8778 case 0x04:
8779 case 0x05:
8780 case 0x06:
8781 case 0x07:
8782 case 0x08:
8783 case 0x09:
8784 case 0x0a:
8785 case 0x0b:
8786 case 0x0c:
8787 case 0x0d:
8788 case 0x0e:
8789 goto op_semantics_69;
8790 break;
8791 case 0x0f:
8792 goto op_semantics_70;
8793 break;
8794 }
8795 break;
8796 case 0xe9:
8797 GETBYTE ();
8798 switch (op[2] & 0x0f)
8799 {
8800 case 0x00:
8801 case 0x01:
8802 case 0x02:
8803 case 0x03:
8804 case 0x04:
8805 case 0x05:
8806 case 0x06:
8807 case 0x07:
8808 case 0x08:
8809 case 0x09:
8810 case 0x0a:
8811 case 0x0b:
8812 case 0x0c:
8813 case 0x0d:
8814 case 0x0e:
8815 goto op_semantics_69;
8816 break;
8817 case 0x0f:
8818 goto op_semantics_70;
8819 break;
8820 }
8821 break;
8822 case 0xea:
8823 GETBYTE ();
8824 switch (op[2] & 0x0f)
8825 {
8826 case 0x00:
8827 case 0x01:
8828 case 0x02:
8829 case 0x03:
8830 case 0x04:
8831 case 0x05:
8832 case 0x06:
8833 case 0x07:
8834 case 0x08:
8835 case 0x09:
8836 case 0x0a:
8837 case 0x0b:
8838 case 0x0c:
8839 case 0x0d:
8840 case 0x0e:
8841 goto op_semantics_69;
8842 break;
8843 case 0x0f:
8844 goto op_semantics_70;
8845 break;
8846 }
8847 break;
8848 case 0xeb:
8849 GETBYTE ();
8850 switch (op[2] & 0x0f)
8851 {
8852 case 0x00:
8853 case 0x01:
8854 case 0x02:
8855 case 0x03:
8856 case 0x04:
8857 case 0x05:
8858 case 0x06:
8859 case 0x07:
8860 case 0x08:
8861 case 0x09:
8862 case 0x0a:
8863 case 0x0b:
8864 case 0x0c:
8865 case 0x0d:
8866 case 0x0e:
8867 goto op_semantics_69;
8868 break;
8869 case 0x0f:
8870 goto op_semantics_70;
8871 break;
8872 }
8873 break;
8874 case 0xec:
8875 GETBYTE ();
8876 switch (op[2] & 0x0f)
8877 {
8878 case 0x00:
8879 case 0x01:
8880 case 0x02:
8881 case 0x03:
8882 case 0x04:
8883 case 0x05:
8884 case 0x06:
8885 case 0x07:
8886 case 0x08:
8887 case 0x09:
8888 case 0x0a:
8889 case 0x0b:
8890 case 0x0c:
8891 case 0x0d:
8892 case 0x0e:
8893 goto op_semantics_69;
8894 break;
8895 case 0x0f:
8896 goto op_semantics_70;
8897 break;
8898 }
8899 break;
8900 case 0xed:
8901 GETBYTE ();
8902 switch (op[2] & 0x0f)
8903 {
8904 case 0x00:
8905 case 0x01:
8906 case 0x02:
8907 case 0x03:
8908 case 0x04:
8909 case 0x05:
8910 case 0x06:
8911 case 0x07:
8912 case 0x08:
8913 case 0x09:
8914 case 0x0a:
8915 case 0x0b:
8916 case 0x0c:
8917 case 0x0d:
8918 case 0x0e:
8919 goto op_semantics_69;
8920 break;
8921 case 0x0f:
8922 goto op_semantics_70;
8923 break;
8924 }
8925 break;
8926 case 0xee:
8927 GETBYTE ();
8928 switch (op[2] & 0x0f)
8929 {
8930 case 0x00:
8931 case 0x01:
8932 case 0x02:
8933 case 0x03:
8934 case 0x04:
8935 case 0x05:
8936 case 0x06:
8937 case 0x07:
8938 case 0x08:
8939 case 0x09:
8940 case 0x0a:
8941 case 0x0b:
8942 case 0x0c:
8943 case 0x0d:
8944 case 0x0e:
8945 goto op_semantics_69;
8946 break;
8947 case 0x0f:
8948 goto op_semantics_70;
8949 break;
8950 }
8951 break;
8952 case 0xef:
8953 GETBYTE ();
8954 switch (op[2] & 0x0f)
8955 {
8956 case 0x00:
8957 case 0x01:
8958 case 0x02:
8959 case 0x03:
8960 case 0x04:
8961 case 0x05:
8962 case 0x06:
8963 case 0x07:
8964 case 0x08:
8965 case 0x09:
8966 case 0x0a:
8967 case 0x0b:
8968 case 0x0c:
8969 case 0x0d:
8970 case 0x0e:
8971 goto op_semantics_69;
8972 break;
8973 case 0x0f:
8974 goto op_semantics_70;
8975 break;
8976 }
8977 break;
8978 case 0xf0:
8979 GETBYTE ();
8980 switch (op[2] & 0x0f)
8981 {
8982 case 0x00:
8983 case 0x01:
8984 case 0x02:
8985 case 0x03:
8986 case 0x04:
8987 case 0x05:
8988 case 0x06:
8989 case 0x07:
8990 case 0x08:
8991 case 0x09:
8992 case 0x0a:
8993 case 0x0b:
8994 case 0x0c:
8995 case 0x0d:
8996 case 0x0e:
8997 goto op_semantics_69;
8998 break;
8999 case 0x0f:
9000 goto op_semantics_70;
9001 break;
9002 }
9003 break;
9004 case 0xf1:
9005 GETBYTE ();
9006 switch (op[2] & 0x0f)
9007 {
9008 case 0x00:
9009 case 0x01:
9010 case 0x02:
9011 case 0x03:
9012 case 0x04:
9013 case 0x05:
9014 case 0x06:
9015 case 0x07:
9016 case 0x08:
9017 case 0x09:
9018 case 0x0a:
9019 case 0x0b:
9020 case 0x0c:
9021 case 0x0d:
9022 case 0x0e:
9023 goto op_semantics_69;
9024 break;
9025 case 0x0f:
9026 goto op_semantics_70;
9027 break;
9028 }
9029 break;
9030 case 0xf2:
9031 GETBYTE ();
9032 switch (op[2] & 0x0f)
9033 {
9034 case 0x00:
9035 case 0x01:
9036 case 0x02:
9037 case 0x03:
9038 case 0x04:
9039 case 0x05:
9040 case 0x06:
9041 case 0x07:
9042 case 0x08:
9043 case 0x09:
9044 case 0x0a:
9045 case 0x0b:
9046 case 0x0c:
9047 case 0x0d:
9048 case 0x0e:
9049 goto op_semantics_69;
9050 break;
9051 case 0x0f:
9052 goto op_semantics_70;
9053 break;
9054 }
9055 break;
9056 case 0xf3:
9057 GETBYTE ();
9058 switch (op[2] & 0x0f)
9059 {
9060 case 0x00:
9061 case 0x01:
9062 case 0x02:
9063 case 0x03:
9064 case 0x04:
9065 case 0x05:
9066 case 0x06:
9067 case 0x07:
9068 case 0x08:
9069 case 0x09:
9070 case 0x0a:
9071 case 0x0b:
9072 case 0x0c:
9073 case 0x0d:
9074 case 0x0e:
9075 goto op_semantics_69;
9076 break;
9077 case 0x0f:
9078 goto op_semantics_70;
9079 break;
9080 }
9081 break;
9082 case 0xf4:
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_69;
9102 break;
9103 case 0x0f:
9104 goto op_semantics_70;
9105 break;
9106 }
9107 break;
9108 case 0xf5:
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_69;
9128 break;
9129 case 0x0f:
9130 goto op_semantics_70;
9131 break;
9132 }
9133 break;
9134 case 0xf6:
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_69;
9154 break;
9155 case 0x0f:
9156 goto op_semantics_70;
9157 break;
9158 }
9159 break;
9160 case 0xf7:
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_69;
9180 break;
9181 case 0x0f:
9182 goto op_semantics_70;
9183 break;
9184 }
9185 break;
9186 case 0xf8:
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_69;
9206 break;
9207 case 0x0f:
9208 goto op_semantics_70;
9209 break;
9210 }
9211 break;
9212 case 0xf9:
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_69;
9232 break;
9233 case 0x0f:
9234 goto op_semantics_70;
9235 break;
9236 }
9237 break;
9238 case 0xfa:
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_69;
9258 break;
9259 case 0x0f:
9260 goto op_semantics_70;
9261 break;
9262 }
9263 break;
9264 case 0xfb:
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_69;
9284 break;
9285 case 0x0f:
9286 goto op_semantics_70;
9287 break;
9288 }
9289 break;
9290 case 0xfc:
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_69;
9310 break;
9311 case 0x0f:
9312 goto op_semantics_70;
9313 break;
9314 }
9315 break;
9316 case 0xfd:
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_69;
9336 break;
9337 case 0x0f:
9338 goto op_semantics_70;
9339 break;
9340 }
9341 break;
9342 case 0xfe:
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_69;
9362 break;
9363 case 0x0f:
9364 goto op_semantics_70;
9365 break;
9366 }
9367 break;
9368 case 0xff:
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_69;
9388 break;
9389 case 0x0f:
9390 goto op_semantics_70;
9391 break;
9392 }
9393 break;
9394 default: UNSUPPORTED(); break;
9395 }
9396 break;
9397 case 0xfd:
9398 GETBYTE ();
9399 switch (op[1] & 0xff)
9400 {
9401 case 0x00:
9402 GETBYTE ();
9403 switch (op[2] & 0x00)
9404 {
9405 case 0x00:
9406 {
9407 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
9408 #line 781 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9409 int srca AU = (op[2] >> 4) & 0x0f;
9410 #line 781 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9411 int srcb AU = op[2] & 0x0f;
9412 if (trace)
9413 {
9414 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9415 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9416 op[0], op[1], op[2]);
9417 printf (" srca = 0x%x,", srca);
9418 printf (" srcb = 0x%x\n", srcb);
9419 }
9420 SYNTAX("mulhi %1, %2");
9421 #line 782 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9422 ID(mulhi); SR(srca); S2R(srcb); F("----");
9423
9424 }
9425 break;
9426 }
9427 break;
9428 case 0x01:
9429 GETBYTE ();
9430 switch (op[2] & 0x00)
9431 {
9432 case 0x00:
9433 {
9434 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
9435 #line 784 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9436 int srca AU = (op[2] >> 4) & 0x0f;
9437 #line 784 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9438 int srcb AU = op[2] & 0x0f;
9439 if (trace)
9440 {
9441 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9442 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9443 op[0], op[1], op[2]);
9444 printf (" srca = 0x%x,", srca);
9445 printf (" srcb = 0x%x\n", srcb);
9446 }
9447 SYNTAX("mullo %1, %2");
9448 #line 785 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9449 ID(mullo); SR(srca); S2R(srcb); F("----");
9450
9451 }
9452 break;
9453 }
9454 break;
9455 case 0x04:
9456 GETBYTE ();
9457 switch (op[2] & 0x00)
9458 {
9459 case 0x00:
9460 {
9461 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
9462 #line 787 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9463 int srca AU = (op[2] >> 4) & 0x0f;
9464 #line 787 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9465 int srcb AU = op[2] & 0x0f;
9466 if (trace)
9467 {
9468 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9469 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9470 op[0], op[1], op[2]);
9471 printf (" srca = 0x%x,", srca);
9472 printf (" srcb = 0x%x\n", srcb);
9473 }
9474 SYNTAX("machi %1, %2");
9475 #line 788 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9476 ID(machi); SR(srca); S2R(srcb); F("----");
9477
9478 }
9479 break;
9480 }
9481 break;
9482 case 0x05:
9483 GETBYTE ();
9484 switch (op[2] & 0x00)
9485 {
9486 case 0x00:
9487 {
9488 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
9489 #line 790 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9490 int srca AU = (op[2] >> 4) & 0x0f;
9491 #line 790 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9492 int srcb AU = op[2] & 0x0f;
9493 if (trace)
9494 {
9495 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9496 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9497 op[0], op[1], op[2]);
9498 printf (" srca = 0x%x,", srca);
9499 printf (" srcb = 0x%x\n", srcb);
9500 }
9501 SYNTAX("maclo %1, %2");
9502 #line 791 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9503 ID(maclo); SR(srca); S2R(srcb); F("----");
9504
9505 }
9506 break;
9507 }
9508 break;
9509 case 0x17:
9510 GETBYTE ();
9511 switch (op[2] & 0xf0)
9512 {
9513 case 0x00:
9514 {
9515 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9516 #line 793 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9517 int rsrc AU = op[2] & 0x0f;
9518 if (trace)
9519 {
9520 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9521 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9522 op[0], op[1], op[2]);
9523 printf (" rsrc = 0x%x\n", rsrc);
9524 }
9525 SYNTAX("mvtachi %1");
9526 #line 794 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9527 ID(mvtachi); SR(rsrc); F("----");
9528
9529 }
9530 break;
9531 case 0x10:
9532 {
9533 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9534 #line 796 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9535 int rsrc AU = op[2] & 0x0f;
9536 if (trace)
9537 {
9538 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9539 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9540 op[0], op[1], op[2]);
9541 printf (" rsrc = 0x%x\n", rsrc);
9542 }
9543 SYNTAX("mvtaclo %1");
9544 #line 797 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9545 ID(mvtaclo); SR(rsrc); F("----");
9546
9547 }
9548 break;
9549 default: UNSUPPORTED(); break;
9550 }
9551 break;
9552 case 0x18:
9553 GETBYTE ();
9554 switch (op[2] & 0xef)
9555 {
9556 case 0x00:
9557 {
9558 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
9559 #line 808 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9560 int i AU = (op[2] >> 4) & 0x01;
9561 if (trace)
9562 {
9563 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9564 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9565 op[0], op[1], op[2]);
9566 printf (" i = 0x%x\n", i);
9567 }
9568 SYNTAX("racw #%1");
9569 #line 809 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9570 ID(racw); SC(i+1); F("----");
9571
9572 /*----------------------------------------------------------------------*/
9573 /* SAT */
9574
9575 }
9576 break;
9577 default: UNSUPPORTED(); break;
9578 }
9579 break;
9580 case 0x1f:
9581 GETBYTE ();
9582 switch (op[2] & 0xf0)
9583 {
9584 case 0x00:
9585 {
9586 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9587 #line 799 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9588 int rdst AU = op[2] & 0x0f;
9589 if (trace)
9590 {
9591 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9592 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9593 op[0], op[1], op[2]);
9594 printf (" rdst = 0x%x\n", rdst);
9595 }
9596 SYNTAX("mvfachi %0");
9597 #line 800 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9598 ID(mvfachi); DR(rdst); F("----");
9599
9600 }
9601 break;
9602 case 0x10:
9603 {
9604 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9605 #line 805 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9606 int rdst AU = op[2] & 0x0f;
9607 if (trace)
9608 {
9609 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9610 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9611 op[0], op[1], op[2]);
9612 printf (" rdst = 0x%x\n", rdst);
9613 }
9614 SYNTAX("mvfaclo %0");
9615 #line 806 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9616 ID(mvfaclo); DR(rdst); F("----");
9617
9618 }
9619 break;
9620 case 0x20:
9621 {
9622 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9623 #line 802 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9624 int rdst AU = op[2] & 0x0f;
9625 if (trace)
9626 {
9627 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9628 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9629 op[0], op[1], op[2]);
9630 printf (" rdst = 0x%x\n", rdst);
9631 }
9632 SYNTAX("mvfacmi %0");
9633 #line 803 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9634 ID(mvfacmi); DR(rdst); F("----");
9635
9636 }
9637 break;
9638 default: UNSUPPORTED(); break;
9639 }
9640 break;
9641 case 0x20:
9642 GETBYTE ();
9643 switch (op[2] & 0x00)
9644 {
9645 case 0x00:
9646 op_semantics_71:
9647 {
9648 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
9649 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9650 int p AU = (op[1] >> 2) & 0x01;
9651 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9652 int sz AU = op[1] & 0x03;
9653 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9654 int rdst AU = (op[2] >> 4) & 0x0f;
9655 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9656 int rsrc AU = op[2] & 0x0f;
9657 if (trace)
9658 {
9659 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9660 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9661 op[0], op[1], op[2]);
9662 printf (" p = 0x%x,", p);
9663 printf (" sz = 0x%x,", sz);
9664 printf (" rdst = 0x%x,", rdst);
9665 printf (" rsrc = 0x%x\n", rsrc);
9666 }
9667 SYNTAX("mov%s %1, %0");
9668 #line 324 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9669 ID(mov); sBWL (sz); SR(rsrc); F("----");
9670 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9671
9672 }
9673 break;
9674 }
9675 break;
9676 case 0x21:
9677 GETBYTE ();
9678 switch (op[2] & 0x00)
9679 {
9680 case 0x00:
9681 goto op_semantics_71;
9682 break;
9683 }
9684 break;
9685 case 0x22:
9686 GETBYTE ();
9687 switch (op[2] & 0x00)
9688 {
9689 case 0x00:
9690 goto op_semantics_71;
9691 break;
9692 }
9693 break;
9694 case 0x24:
9695 GETBYTE ();
9696 switch (op[2] & 0x00)
9697 {
9698 case 0x00:
9699 goto op_semantics_71;
9700 break;
9701 }
9702 break;
9703 case 0x25:
9704 GETBYTE ();
9705 switch (op[2] & 0x00)
9706 {
9707 case 0x00:
9708 goto op_semantics_71;
9709 break;
9710 }
9711 break;
9712 case 0x26:
9713 GETBYTE ();
9714 switch (op[2] & 0x00)
9715 {
9716 case 0x00:
9717 goto op_semantics_71;
9718 break;
9719 }
9720 break;
9721 case 0x28:
9722 GETBYTE ();
9723 switch (op[2] & 0x00)
9724 {
9725 case 0x00:
9726 op_semantics_72:
9727 {
9728 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
9729 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9730 int p AU = (op[1] >> 2) & 0x01;
9731 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9732 int sz AU = op[1] & 0x03;
9733 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9734 int rsrc AU = (op[2] >> 4) & 0x0f;
9735 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9736 int rdst AU = op[2] & 0x0f;
9737 if (trace)
9738 {
9739 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9740 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9741 op[0], op[1], op[2]);
9742 printf (" p = 0x%x,", p);
9743 printf (" sz = 0x%x,", sz);
9744 printf (" rsrc = 0x%x,", rsrc);
9745 printf (" rdst = 0x%x\n", rdst);
9746 }
9747 SYNTAX("mov%s %1, %0");
9748 #line 328 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9749 ID(mov); sBWL (sz); DR(rdst); F("----");
9750 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9751
9752 }
9753 break;
9754 }
9755 break;
9756 case 0x29:
9757 GETBYTE ();
9758 switch (op[2] & 0x00)
9759 {
9760 case 0x00:
9761 goto op_semantics_72;
9762 break;
9763 }
9764 break;
9765 case 0x2a:
9766 GETBYTE ();
9767 switch (op[2] & 0x00)
9768 {
9769 case 0x00:
9770 goto op_semantics_72;
9771 break;
9772 }
9773 break;
9774 case 0x2c:
9775 GETBYTE ();
9776 switch (op[2] & 0x00)
9777 {
9778 case 0x00:
9779 goto op_semantics_72;
9780 break;
9781 }
9782 break;
9783 case 0x2d:
9784 GETBYTE ();
9785 switch (op[2] & 0x00)
9786 {
9787 case 0x00:
9788 goto op_semantics_72;
9789 break;
9790 }
9791 break;
9792 case 0x2e:
9793 GETBYTE ();
9794 switch (op[2] & 0x00)
9795 {
9796 case 0x00:
9797 goto op_semantics_72;
9798 break;
9799 }
9800 break;
9801 case 0x38:
9802 GETBYTE ();
9803 switch (op[2] & 0x00)
9804 {
9805 case 0x00:
9806 op_semantics_73:
9807 {
9808 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
9809 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9810 int p AU = (op[1] >> 2) & 0x01;
9811 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9812 int sz AU = op[1] & 0x03;
9813 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9814 int rsrc AU = (op[2] >> 4) & 0x0f;
9815 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9816 int rdst AU = op[2] & 0x0f;
9817 if (trace)
9818 {
9819 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9820 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9821 op[0], op[1], op[2]);
9822 printf (" p = 0x%x,", p);
9823 printf (" sz = 0x%x,", sz);
9824 printf (" rsrc = 0x%x,", rsrc);
9825 printf (" rdst = 0x%x\n", rdst);
9826 }
9827 SYNTAX("movu%s %1, %0");
9828 #line 338 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9829 ID(mov); uBWL (sz); DR(rdst); F("----");
9830 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9831
9832 /*----------------------------------------------------------------------*/
9833 /* PUSH/POP */
9834
9835 }
9836 break;
9837 }
9838 break;
9839 case 0x39:
9840 GETBYTE ();
9841 switch (op[2] & 0x00)
9842 {
9843 case 0x00:
9844 goto op_semantics_73;
9845 break;
9846 }
9847 break;
9848 case 0x3a:
9849 GETBYTE ();
9850 switch (op[2] & 0x00)
9851 {
9852 case 0x00:
9853 goto op_semantics_73;
9854 break;
9855 }
9856 break;
9857 case 0x3c:
9858 GETBYTE ();
9859 switch (op[2] & 0x00)
9860 {
9861 case 0x00:
9862 goto op_semantics_73;
9863 break;
9864 }
9865 break;
9866 case 0x3d:
9867 GETBYTE ();
9868 switch (op[2] & 0x00)
9869 {
9870 case 0x00:
9871 goto op_semantics_73;
9872 break;
9873 }
9874 break;
9875 case 0x3e:
9876 GETBYTE ();
9877 switch (op[2] & 0x00)
9878 {
9879 case 0x00:
9880 goto op_semantics_73;
9881 break;
9882 }
9883 break;
9884 case 0x60:
9885 GETBYTE ();
9886 switch (op[2] & 0x00)
9887 {
9888 case 0x00:
9889 {
9890 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
9891 #line 662 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9892 int rsrc AU = (op[2] >> 4) & 0x0f;
9893 #line 662 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9894 int rdst AU = op[2] & 0x0f;
9895 if (trace)
9896 {
9897 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9898 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9899 op[0], op[1], op[2]);
9900 printf (" rsrc = 0x%x,", rsrc);
9901 printf (" rdst = 0x%x\n", rdst);
9902 }
9903 SYNTAX("shlr %2, %0");
9904 #line 663 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9905 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F("-SZC");
9906
9907 }
9908 break;
9909 }
9910 break;
9911 case 0x61:
9912 GETBYTE ();
9913 switch (op[2] & 0x00)
9914 {
9915 case 0x00:
9916 {
9917 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
9918 #line 652 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9919 int rsrc AU = (op[2] >> 4) & 0x0f;
9920 #line 652 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9921 int rdst AU = op[2] & 0x0f;
9922 if (trace)
9923 {
9924 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9925 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
9926 op[0], op[1], op[2]);
9927 printf (" rsrc = 0x%x,", rsrc);
9928 printf (" rdst = 0x%x\n", rdst);
9929 }
9930 SYNTAX("shar %2, %0");
9931 #line 653 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9932 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F("0SZC");
9933
9934 }
9935 break;
9936 }
9937 break;
9938 case 0x62:
9939 GETBYTE ();
9940 switch (op[2] & 0x00)
9941 {
9942 case 0x00:
9943 {
9944 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
9945 #line 642 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9946 int rsrc AU = (op[2] >> 4) & 0x0f;
9947 #line 642 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9948 int rdst AU = op[2] & 0x0f;
9949 if (trace)
9950 {
9951 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9952 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
9953 op[0], op[1], op[2]);
9954 printf (" rsrc = 0x%x,", rsrc);
9955 printf (" rdst = 0x%x\n", rdst);
9956 }
9957 SYNTAX("shll %2, %0");
9958 #line 643 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9959 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F("OSZC");
9960
9961 }
9962 break;
9963 }
9964 break;
9965 case 0x64:
9966 GETBYTE ();
9967 switch (op[2] & 0x00)
9968 {
9969 case 0x00:
9970 {
9971 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
9972 #line 686 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9973 int rsrc AU = (op[2] >> 4) & 0x0f;
9974 #line 686 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9975 int rdst AU = op[2] & 0x0f;
9976 if (trace)
9977 {
9978 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9979 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
9980 op[0], op[1], op[2]);
9981 printf (" rsrc = 0x%x,", rsrc);
9982 printf (" rdst = 0x%x\n", rdst);
9983 }
9984 SYNTAX("rotr %1, %0");
9985 #line 687 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9986 ID(rotr); SR(rsrc); DR(rdst); F("-SZC");
9987
9988 }
9989 break;
9990 }
9991 break;
9992 case 0x65:
9993 GETBYTE ();
9994 switch (op[2] & 0x00)
9995 {
9996 case 0x00:
9997 {
9998 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
9999 #line 689 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10000 int rsrc AU = (op[2] >> 4) & 0x0f;
10001 #line 689 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10002 int rdst AU = op[2] & 0x0f;
10003 if (trace)
10004 {
10005 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10006 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10007 op[0], op[1], op[2]);
10008 printf (" rsrc = 0x%x,", rsrc);
10009 printf (" rdst = 0x%x\n", rdst);
10010 }
10011 SYNTAX("revw %1, %0");
10012 #line 690 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10013 ID(revw); SR(rsrc); DR(rdst);
10014
10015 }
10016 break;
10017 }
10018 break;
10019 case 0x66:
10020 GETBYTE ();
10021 switch (op[2] & 0x00)
10022 {
10023 case 0x00:
10024 {
10025 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
10026 #line 680 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10027 int rsrc AU = (op[2] >> 4) & 0x0f;
10028 #line 680 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10029 int rdst AU = op[2] & 0x0f;
10030 if (trace)
10031 {
10032 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10033 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10034 op[0], op[1], op[2]);
10035 printf (" rsrc = 0x%x,", rsrc);
10036 printf (" rdst = 0x%x\n", rdst);
10037 }
10038 SYNTAX("rotl %1, %0");
10039 #line 681 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10040 ID(rotl); SR(rsrc); DR(rdst); F("-SZC");
10041
10042 }
10043 break;
10044 }
10045 break;
10046 case 0x67:
10047 GETBYTE ();
10048 switch (op[2] & 0x00)
10049 {
10050 case 0x00:
10051 {
10052 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
10053 #line 692 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10054 int rsrc AU = (op[2] >> 4) & 0x0f;
10055 #line 692 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10056 int rdst AU = op[2] & 0x0f;
10057 if (trace)
10058 {
10059 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10060 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10061 op[0], op[1], op[2]);
10062 printf (" rsrc = 0x%x,", rsrc);
10063 printf (" rdst = 0x%x\n", rdst);
10064 }
10065 SYNTAX("revl %1, %0");
10066 #line 693 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10067 ID(revl); SR(rsrc); DR(rdst);
10068
10069 /*----------------------------------------------------------------------*/
10070 /* BRANCH */
10071
10072 }
10073 break;
10074 }
10075 break;
10076 case 0x68:
10077 GETBYTE ();
10078 switch (op[2] & 0x00)
10079 {
10080 case 0x00:
10081 op_semantics_74:
10082 {
10083 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
10084 #line 932 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10085 int c AU = op[1] & 0x01;
10086 #line 932 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10087 int rsrc AU = (op[2] >> 4) & 0x0f;
10088 #line 932 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10089 int rdst AU = op[2] & 0x0f;
10090 if (trace)
10091 {
10092 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10093 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10094 op[0], op[1], op[2]);
10095 printf (" c = 0x%x,", c);
10096 printf (" rsrc = 0x%x,", rsrc);
10097 printf (" rdst = 0x%x\n", rdst);
10098 }
10099 SYNTAX("mvtc %1, %0");
10100 #line 933 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10101 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10102
10103 }
10104 break;
10105 }
10106 break;
10107 case 0x69:
10108 GETBYTE ();
10109 switch (op[2] & 0x00)
10110 {
10111 case 0x00:
10112 goto op_semantics_74;
10113 break;
10114 }
10115 break;
10116 case 0x6a:
10117 GETBYTE ();
10118 switch (op[2] & 0x00)
10119 {
10120 case 0x00:
10121 op_semantics_75:
10122 {
10123 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
10124 #line 935 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10125 int s AU = op[1] & 0x01;
10126 #line 935 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10127 int rsrc AU = (op[2] >> 4) & 0x0f;
10128 #line 935 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10129 int rdst AU = op[2] & 0x0f;
10130 if (trace)
10131 {
10132 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10133 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10134 op[0], op[1], op[2]);
10135 printf (" s = 0x%x,", s);
10136 printf (" rsrc = 0x%x,", rsrc);
10137 printf (" rdst = 0x%x\n", rdst);
10138 }
10139 SYNTAX("mvfc %1, %0");
10140 #line 936 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10141 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10142
10143 }
10144 break;
10145 }
10146 break;
10147 case 0x6b:
10148 GETBYTE ();
10149 switch (op[2] & 0x00)
10150 {
10151 case 0x00:
10152 goto op_semantics_75;
10153 break;
10154 }
10155 break;
10156 case 0x6c:
10157 GETBYTE ();
10158 switch (op[2] & 0x00)
10159 {
10160 case 0x00:
10161 op_semantics_76:
10162 {
10163 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
10164 #line 683 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10165 int i AU = op[1] & 0x01;
10166 #line 683 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10167 int mmmm AU = (op[2] >> 4) & 0x0f;
10168 #line 683 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10169 int rdst AU = op[2] & 0x0f;
10170 if (trace)
10171 {
10172 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10173 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10174 op[0], op[1], op[2]);
10175 printf (" i = 0x%x,", i);
10176 printf (" mmmm = 0x%x,", mmmm);
10177 printf (" rdst = 0x%x\n", rdst);
10178 }
10179 SYNTAX("rotr #%1, %0");
10180 #line 684 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10181 ID(rotr); SC(i*16+mmmm); DR(rdst); F("-SZC");
10182
10183 }
10184 break;
10185 }
10186 break;
10187 case 0x6d:
10188 GETBYTE ();
10189 switch (op[2] & 0x00)
10190 {
10191 case 0x00:
10192 goto op_semantics_76;
10193 break;
10194 }
10195 break;
10196 case 0x6e:
10197 GETBYTE ();
10198 switch (op[2] & 0x00)
10199 {
10200 case 0x00:
10201 op_semantics_77:
10202 {
10203 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
10204 #line 677 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10205 int i AU = op[1] & 0x01;
10206 #line 677 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10207 int mmmm AU = (op[2] >> 4) & 0x0f;
10208 #line 677 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10209 int rdst AU = op[2] & 0x0f;
10210 if (trace)
10211 {
10212 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10213 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10214 op[0], op[1], op[2]);
10215 printf (" i = 0x%x,", i);
10216 printf (" mmmm = 0x%x,", mmmm);
10217 printf (" rdst = 0x%x\n", rdst);
10218 }
10219 SYNTAX("rotl #%1, %0");
10220 #line 678 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10221 ID(rotl); SC(i*16+mmmm); DR(rdst); F("-SZC");
10222
10223 }
10224 break;
10225 }
10226 break;
10227 case 0x6f:
10228 GETBYTE ();
10229 switch (op[2] & 0x00)
10230 {
10231 case 0x00:
10232 goto op_semantics_77;
10233 break;
10234 }
10235 break;
10236 case 0x70:
10237 GETBYTE ();
10238 switch (op[2] & 0xf0)
10239 {
10240 case 0x20:
10241 op_semantics_78:
10242 {
10243 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
10244 #line 467 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10245 int im AU = (op[1] >> 2) & 0x03;
10246 #line 467 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10247 int rdst AU = op[2] & 0x0f;
10248 if (trace)
10249 {
10250 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10251 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10252 op[0], op[1], op[2]);
10253 printf (" im = 0x%x,", im);
10254 printf (" rdst = 0x%x\n", rdst);
10255 }
10256 SYNTAX("adc #%1, %0");
10257 #line 468 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10258 ID(adc); SC(IMMex(im)); DR(rdst); F("OSZC");
10259
10260 }
10261 break;
10262 case 0x40:
10263 op_semantics_79:
10264 {
10265 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
10266 #line 549 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10267 int im AU = (op[1] >> 2) & 0x03;
10268 #line 549 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10269 int rdst AU = op[2] & 0x0f;
10270 if (trace)
10271 {
10272 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10273 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10274 op[0], op[1], op[2]);
10275 printf (" im = 0x%x,", im);
10276 printf (" rdst = 0x%x\n", rdst);
10277 }
10278 SYNTAX("max #%1, %0");
10279 #line 550 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10280 ID(max); DR(rdst); SC(IMMex(im));
10281
10282 }
10283 break;
10284 case 0x50:
10285 op_semantics_80:
10286 {
10287 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
10288 #line 561 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10289 int im AU = (op[1] >> 2) & 0x03;
10290 #line 561 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10291 int rdst AU = op[2] & 0x0f;
10292 if (trace)
10293 {
10294 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10295 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10296 op[0], op[1], op[2]);
10297 printf (" im = 0x%x,", im);
10298 printf (" rdst = 0x%x\n", rdst);
10299 }
10300 SYNTAX("min #%1, %0");
10301 #line 562 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10302 ID(min); DR(rdst); SC(IMMex(im));
10303
10304 }
10305 break;
10306 case 0x60:
10307 op_semantics_81:
10308 {
10309 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
10310 #line 591 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10311 int im AU = (op[1] >> 2) & 0x03;
10312 #line 591 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10313 int rdst AU = op[2] & 0x0f;
10314 if (trace)
10315 {
10316 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10317 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10318 op[0], op[1], op[2]);
10319 printf (" im = 0x%x,", im);
10320 printf (" rdst = 0x%x\n", rdst);
10321 }
10322 SYNTAX("emul #%1, %0");
10323 #line 592 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10324 ID(emul); DR(rdst); SC(IMMex(im));
10325
10326 }
10327 break;
10328 case 0x70:
10329 op_semantics_82:
10330 {
10331 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
10332 #line 603 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10333 int im AU = (op[1] >> 2) & 0x03;
10334 #line 603 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10335 int rdst AU = op[2] & 0x0f;
10336 if (trace)
10337 {
10338 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10339 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10340 op[0], op[1], op[2]);
10341 printf (" im = 0x%x,", im);
10342 printf (" rdst = 0x%x\n", rdst);
10343 }
10344 SYNTAX("emulu #%1, %0");
10345 #line 604 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10346 ID(emulu); DR(rdst); SC(IMMex(im));
10347
10348 }
10349 break;
10350 case 0x80:
10351 op_semantics_83:
10352 {
10353 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
10354 #line 615 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10355 int im AU = (op[1] >> 2) & 0x03;
10356 #line 615 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10357 int rdst AU = op[2] & 0x0f;
10358 if (trace)
10359 {
10360 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10361 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10362 op[0], op[1], op[2]);
10363 printf (" im = 0x%x,", im);
10364 printf (" rdst = 0x%x\n", rdst);
10365 }
10366 SYNTAX("div #%1, %0");
10367 #line 616 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10368 ID(div); DR(rdst); SC(IMMex(im)); F("O---");
10369
10370 }
10371 break;
10372 case 0x90:
10373 op_semantics_84:
10374 {
10375 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
10376 #line 627 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10377 int im AU = (op[1] >> 2) & 0x03;
10378 #line 627 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10379 int rdst AU = op[2] & 0x0f;
10380 if (trace)
10381 {
10382 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10383 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10384 op[0], op[1], op[2]);
10385 printf (" im = 0x%x,", im);
10386 printf (" rdst = 0x%x\n", rdst);
10387 }
10388 SYNTAX("divu #%1, %0");
10389 #line 628 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10390 ID(divu); DR(rdst); SC(IMMex(im)); F("O---");
10391
10392 }
10393 break;
10394 case 0xc0:
10395 op_semantics_85:
10396 {
10397 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
10398 #line 446 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10399 int im AU = (op[1] >> 2) & 0x03;
10400 #line 446 "/work/sources/gcc/current/opcodes/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 0111 im00 1100rdst tst #%1, %2 */",
10406 op[0], op[1], op[2]);
10407 printf (" im = 0x%x,", im);
10408 printf (" rdst = 0x%x\n", rdst);
10409 }
10410 SYNTAX("tst #%1, %2");
10411 #line 447 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10412 ID(and); SC(IMMex(im)); S2R(rdst); F("-SZ-");
10413
10414 }
10415 break;
10416 case 0xd0:
10417 op_semantics_86:
10418 {
10419 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
10420 #line 425 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10421 int im AU = (op[1] >> 2) & 0x03;
10422 #line 425 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10423 int rdst AU = op[2] & 0x0f;
10424 if (trace)
10425 {
10426 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10427 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10428 op[0], op[1], op[2]);
10429 printf (" im = 0x%x,", im);
10430 printf (" rdst = 0x%x\n", rdst);
10431 }
10432 SYNTAX("xor #%1, %0");
10433 #line 426 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10434 ID(xor); SC(IMMex(im)); DR(rdst); F("-SZ-");
10435
10436 }
10437 break;
10438 case 0xe0:
10439 op_semantics_87:
10440 {
10441 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
10442 #line 371 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10443 int im AU = (op[1] >> 2) & 0x03;
10444 #line 371 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10445 int rdst AU = op[2] & 0x0f;
10446 if (trace)
10447 {
10448 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10449 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10450 op[0], op[1], op[2]);
10451 printf (" im = 0x%x,", im);
10452 printf (" rdst = 0x%x\n", rdst);
10453 }
10454 SYNTAX("stz #%1, %0");
10455 #line 372 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10456 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10457
10458 }
10459 break;
10460 case 0xf0:
10461 op_semantics_88:
10462 {
10463 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
10464 #line 374 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10465 int im AU = (op[1] >> 2) & 0x03;
10466 #line 374 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10467 int rdst AU = op[2] & 0x0f;
10468 if (trace)
10469 {
10470 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10471 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10472 op[0], op[1], op[2]);
10473 printf (" im = 0x%x,", im);
10474 printf (" rdst = 0x%x\n", rdst);
10475 }
10476 SYNTAX("stnz #%1, %0");
10477 #line 375 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10478 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10479
10480 /*----------------------------------------------------------------------*/
10481 /* RTSD */
10482
10483 }
10484 break;
10485 default: UNSUPPORTED(); break;
10486 }
10487 break;
10488 case 0x72:
10489 GETBYTE ();
10490 switch (op[2] & 0xf0)
10491 {
10492 case 0x00:
10493 {
10494 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
10495 #line 835 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10496 int rdst AU = op[2] & 0x0f;
10497 if (trace)
10498 {
10499 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10500 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
10501 op[0], op[1], op[2]);
10502 printf (" rdst = 0x%x\n", rdst);
10503 }
10504 SYNTAX("fsub #%1, %0");
10505 #line 836 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10506 ID(fsub); DR(rdst); SC(IMM(0)); F("-SZ-");
10507
10508 }
10509 break;
10510 case 0x10:
10511 {
10512 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
10513 #line 829 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10514 int rdst AU = op[2] & 0x0f;
10515 if (trace)
10516 {
10517 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10518 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10519 op[0], op[1], op[2]);
10520 printf (" rdst = 0x%x\n", rdst);
10521 }
10522 SYNTAX("fcmp #%1, %0");
10523 #line 830 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10524 ID(fcmp); DR(rdst); SC(IMM(0)); F("OSZ-");
10525
10526 }
10527 break;
10528 case 0x20:
10529 {
10530 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
10531 #line 823 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10532 int rdst AU = op[2] & 0x0f;
10533 if (trace)
10534 {
10535 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10536 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10537 op[0], op[1], op[2]);
10538 printf (" rdst = 0x%x\n", rdst);
10539 }
10540 SYNTAX("fadd #%1, %0");
10541 #line 824 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10542 ID(fadd); DR(rdst); SC(IMM(0)); F("-SZ-");
10543
10544 }
10545 break;
10546 case 0x30:
10547 {
10548 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
10549 #line 844 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10550 int rdst AU = op[2] & 0x0f;
10551 if (trace)
10552 {
10553 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10554 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10555 op[0], op[1], op[2]);
10556 printf (" rdst = 0x%x\n", rdst);
10557 }
10558 SYNTAX("fmul #%1, %0");
10559 #line 845 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10560 ID(fmul); DR(rdst); SC(IMM(0)); F("-SZ-");
10561
10562 }
10563 break;
10564 case 0x40:
10565 {
10566 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
10567 #line 850 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10568 int rdst AU = op[2] & 0x0f;
10569 if (trace)
10570 {
10571 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10572 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10573 op[0], op[1], op[2]);
10574 printf (" rdst = 0x%x\n", rdst);
10575 }
10576 SYNTAX("fdiv #%1, %0");
10577 #line 851 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10578 ID(fdiv); DR(rdst); SC(IMM(0)); F("-SZ-");
10579
10580 }
10581 break;
10582 default: UNSUPPORTED(); break;
10583 }
10584 break;
10585 case 0x73:
10586 GETBYTE ();
10587 switch (op[2] & 0xe0)
10588 {
10589 case 0x00:
10590 op_semantics_89:
10591 {
10592 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
10593 #line 929 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10594 int im AU = (op[1] >> 2) & 0x03;
10595 #line 929 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10596 int crdst AU = op[2] & 0x1f;
10597 if (trace)
10598 {
10599 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10600 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10601 op[0], op[1], op[2]);
10602 printf (" im = 0x%x,", im);
10603 printf (" crdst = 0x%x\n", crdst);
10604 }
10605 SYNTAX("mvtc #%1, %0");
10606 #line 930 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10607 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10608
10609 }
10610 break;
10611 default: UNSUPPORTED(); break;
10612 }
10613 break;
10614 case 0x74:
10615 GETBYTE ();
10616 switch (op[2] & 0xf0)
10617 {
10618 case 0x20:
10619 goto op_semantics_78;
10620 break;
10621 case 0x40:
10622 goto op_semantics_79;
10623 break;
10624 case 0x50:
10625 goto op_semantics_80;
10626 break;
10627 case 0x60:
10628 goto op_semantics_81;
10629 break;
10630 case 0x70:
10631 goto op_semantics_82;
10632 break;
10633 case 0x80:
10634 goto op_semantics_83;
10635 break;
10636 case 0x90:
10637 goto op_semantics_84;
10638 break;
10639 case 0xc0:
10640 goto op_semantics_85;
10641 break;
10642 case 0xd0:
10643 goto op_semantics_86;
10644 break;
10645 case 0xe0:
10646 goto op_semantics_87;
10647 break;
10648 case 0xf0:
10649 goto op_semantics_88;
10650 break;
10651 default: UNSUPPORTED(); break;
10652 }
10653 break;
10654 case 0x77:
10655 GETBYTE ();
10656 switch (op[2] & 0xe0)
10657 {
10658 case 0x00:
10659 goto op_semantics_89;
10660 break;
10661 default: UNSUPPORTED(); break;
10662 }
10663 break;
10664 case 0x78:
10665 GETBYTE ();
10666 switch (op[2] & 0xf0)
10667 {
10668 case 0x20:
10669 goto op_semantics_78;
10670 break;
10671 case 0x40:
10672 goto op_semantics_79;
10673 break;
10674 case 0x50:
10675 goto op_semantics_80;
10676 break;
10677 case 0x60:
10678 goto op_semantics_81;
10679 break;
10680 case 0x70:
10681 goto op_semantics_82;
10682 break;
10683 case 0x80:
10684 goto op_semantics_83;
10685 break;
10686 case 0x90:
10687 goto op_semantics_84;
10688 break;
10689 case 0xc0:
10690 goto op_semantics_85;
10691 break;
10692 case 0xd0:
10693 goto op_semantics_86;
10694 break;
10695 case 0xe0:
10696 goto op_semantics_87;
10697 break;
10698 case 0xf0:
10699 goto op_semantics_88;
10700 break;
10701 default: UNSUPPORTED(); break;
10702 }
10703 break;
10704 case 0x7b:
10705 GETBYTE ();
10706 switch (op[2] & 0xe0)
10707 {
10708 case 0x00:
10709 goto op_semantics_89;
10710 break;
10711 default: UNSUPPORTED(); break;
10712 }
10713 break;
10714 case 0x7c:
10715 GETBYTE ();
10716 switch (op[2] & 0xf0)
10717 {
10718 case 0x20:
10719 goto op_semantics_78;
10720 break;
10721 case 0x40:
10722 goto op_semantics_79;
10723 break;
10724 case 0x50:
10725 goto op_semantics_80;
10726 break;
10727 case 0x60:
10728 goto op_semantics_81;
10729 break;
10730 case 0x70:
10731 goto op_semantics_82;
10732 break;
10733 case 0x80:
10734 goto op_semantics_83;
10735 break;
10736 case 0x90:
10737 goto op_semantics_84;
10738 break;
10739 case 0xc0:
10740 goto op_semantics_85;
10741 break;
10742 case 0xd0:
10743 goto op_semantics_86;
10744 break;
10745 case 0xe0:
10746 goto op_semantics_87;
10747 break;
10748 case 0xf0:
10749 goto op_semantics_88;
10750 break;
10751 default: UNSUPPORTED(); break;
10752 }
10753 break;
10754 case 0x7f:
10755 GETBYTE ();
10756 switch (op[2] & 0xe0)
10757 {
10758 case 0x00:
10759 goto op_semantics_89;
10760 break;
10761 default: UNSUPPORTED(); break;
10762 }
10763 break;
10764 case 0x80:
10765 GETBYTE ();
10766 switch (op[2] & 0x00)
10767 {
10768 case 0x00:
10769 op_semantics_90:
10770 {
10771 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
10772 #line 665 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10773 int immmm AU = op[1] & 0x1f;
10774 #line 665 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10775 int rsrc AU = (op[2] >> 4) & 0x0f;
10776 #line 665 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10777 int rdst AU = op[2] & 0x0f;
10778 if (trace)
10779 {
10780 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10781 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10782 op[0], op[1], op[2]);
10783 printf (" immmm = 0x%x,", immmm);
10784 printf (" rsrc = 0x%x,", rsrc);
10785 printf (" rdst = 0x%x\n", rdst);
10786 }
10787 SYNTAX("shlr #%2, %1, %0");
10788 #line 666 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10789 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F("-SZC");
10790
10791 /*----------------------------------------------------------------------*/
10792 /* ROTATE */
10793
10794 }
10795 break;
10796 }
10797 break;
10798 case 0x81:
10799 GETBYTE ();
10800 switch (op[2] & 0x00)
10801 {
10802 case 0x00:
10803 goto op_semantics_90;
10804 break;
10805 }
10806 break;
10807 case 0x82:
10808 GETBYTE ();
10809 switch (op[2] & 0x00)
10810 {
10811 case 0x00:
10812 goto op_semantics_90;
10813 break;
10814 }
10815 break;
10816 case 0x83:
10817 GETBYTE ();
10818 switch (op[2] & 0x00)
10819 {
10820 case 0x00:
10821 goto op_semantics_90;
10822 break;
10823 }
10824 break;
10825 case 0x84:
10826 GETBYTE ();
10827 switch (op[2] & 0x00)
10828 {
10829 case 0x00:
10830 goto op_semantics_90;
10831 break;
10832 }
10833 break;
10834 case 0x85:
10835 GETBYTE ();
10836 switch (op[2] & 0x00)
10837 {
10838 case 0x00:
10839 goto op_semantics_90;
10840 break;
10841 }
10842 break;
10843 case 0x86:
10844 GETBYTE ();
10845 switch (op[2] & 0x00)
10846 {
10847 case 0x00:
10848 goto op_semantics_90;
10849 break;
10850 }
10851 break;
10852 case 0x87:
10853 GETBYTE ();
10854 switch (op[2] & 0x00)
10855 {
10856 case 0x00:
10857 goto op_semantics_90;
10858 break;
10859 }
10860 break;
10861 case 0x88:
10862 GETBYTE ();
10863 switch (op[2] & 0x00)
10864 {
10865 case 0x00:
10866 goto op_semantics_90;
10867 break;
10868 }
10869 break;
10870 case 0x89:
10871 GETBYTE ();
10872 switch (op[2] & 0x00)
10873 {
10874 case 0x00:
10875 goto op_semantics_90;
10876 break;
10877 }
10878 break;
10879 case 0x8a:
10880 GETBYTE ();
10881 switch (op[2] & 0x00)
10882 {
10883 case 0x00:
10884 goto op_semantics_90;
10885 break;
10886 }
10887 break;
10888 case 0x8b:
10889 GETBYTE ();
10890 switch (op[2] & 0x00)
10891 {
10892 case 0x00:
10893 goto op_semantics_90;
10894 break;
10895 }
10896 break;
10897 case 0x8c:
10898 GETBYTE ();
10899 switch (op[2] & 0x00)
10900 {
10901 case 0x00:
10902 goto op_semantics_90;
10903 break;
10904 }
10905 break;
10906 case 0x8d:
10907 GETBYTE ();
10908 switch (op[2] & 0x00)
10909 {
10910 case 0x00:
10911 goto op_semantics_90;
10912 break;
10913 }
10914 break;
10915 case 0x8e:
10916 GETBYTE ();
10917 switch (op[2] & 0x00)
10918 {
10919 case 0x00:
10920 goto op_semantics_90;
10921 break;
10922 }
10923 break;
10924 case 0x8f:
10925 GETBYTE ();
10926 switch (op[2] & 0x00)
10927 {
10928 case 0x00:
10929 goto op_semantics_90;
10930 break;
10931 }
10932 break;
10933 case 0x90:
10934 GETBYTE ();
10935 switch (op[2] & 0x00)
10936 {
10937 case 0x00:
10938 goto op_semantics_90;
10939 break;
10940 }
10941 break;
10942 case 0x91:
10943 GETBYTE ();
10944 switch (op[2] & 0x00)
10945 {
10946 case 0x00:
10947 goto op_semantics_90;
10948 break;
10949 }
10950 break;
10951 case 0x92:
10952 GETBYTE ();
10953 switch (op[2] & 0x00)
10954 {
10955 case 0x00:
10956 goto op_semantics_90;
10957 break;
10958 }
10959 break;
10960 case 0x93:
10961 GETBYTE ();
10962 switch (op[2] & 0x00)
10963 {
10964 case 0x00:
10965 goto op_semantics_90;
10966 break;
10967 }
10968 break;
10969 case 0x94:
10970 GETBYTE ();
10971 switch (op[2] & 0x00)
10972 {
10973 case 0x00:
10974 goto op_semantics_90;
10975 break;
10976 }
10977 break;
10978 case 0x95:
10979 GETBYTE ();
10980 switch (op[2] & 0x00)
10981 {
10982 case 0x00:
10983 goto op_semantics_90;
10984 break;
10985 }
10986 break;
10987 case 0x96:
10988 GETBYTE ();
10989 switch (op[2] & 0x00)
10990 {
10991 case 0x00:
10992 goto op_semantics_90;
10993 break;
10994 }
10995 break;
10996 case 0x97:
10997 GETBYTE ();
10998 switch (op[2] & 0x00)
10999 {
11000 case 0x00:
11001 goto op_semantics_90;
11002 break;
11003 }
11004 break;
11005 case 0x98:
11006 GETBYTE ();
11007 switch (op[2] & 0x00)
11008 {
11009 case 0x00:
11010 goto op_semantics_90;
11011 break;
11012 }
11013 break;
11014 case 0x99:
11015 GETBYTE ();
11016 switch (op[2] & 0x00)
11017 {
11018 case 0x00:
11019 goto op_semantics_90;
11020 break;
11021 }
11022 break;
11023 case 0x9a:
11024 GETBYTE ();
11025 switch (op[2] & 0x00)
11026 {
11027 case 0x00:
11028 goto op_semantics_90;
11029 break;
11030 }
11031 break;
11032 case 0x9b:
11033 GETBYTE ();
11034 switch (op[2] & 0x00)
11035 {
11036 case 0x00:
11037 goto op_semantics_90;
11038 break;
11039 }
11040 break;
11041 case 0x9c:
11042 GETBYTE ();
11043 switch (op[2] & 0x00)
11044 {
11045 case 0x00:
11046 goto op_semantics_90;
11047 break;
11048 }
11049 break;
11050 case 0x9d:
11051 GETBYTE ();
11052 switch (op[2] & 0x00)
11053 {
11054 case 0x00:
11055 goto op_semantics_90;
11056 break;
11057 }
11058 break;
11059 case 0x9e:
11060 GETBYTE ();
11061 switch (op[2] & 0x00)
11062 {
11063 case 0x00:
11064 goto op_semantics_90;
11065 break;
11066 }
11067 break;
11068 case 0x9f:
11069 GETBYTE ();
11070 switch (op[2] & 0x00)
11071 {
11072 case 0x00:
11073 goto op_semantics_90;
11074 break;
11075 }
11076 break;
11077 case 0xa0:
11078 GETBYTE ();
11079 switch (op[2] & 0x00)
11080 {
11081 case 0x00:
11082 op_semantics_91:
11083 {
11084 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
11085 #line 655 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11086 int immmm AU = op[1] & 0x1f;
11087 #line 655 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11088 int rsrc AU = (op[2] >> 4) & 0x0f;
11089 #line 655 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11090 int rdst AU = op[2] & 0x0f;
11091 if (trace)
11092 {
11093 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11094 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11095 op[0], op[1], op[2]);
11096 printf (" immmm = 0x%x,", immmm);
11097 printf (" rsrc = 0x%x,", rsrc);
11098 printf (" rdst = 0x%x\n", rdst);
11099 }
11100 SYNTAX("shar #%2, %1, %0");
11101 #line 656 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11102 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F("0SZC");
11103
11104
11105 }
11106 break;
11107 }
11108 break;
11109 case 0xa1:
11110 GETBYTE ();
11111 switch (op[2] & 0x00)
11112 {
11113 case 0x00:
11114 goto op_semantics_91;
11115 break;
11116 }
11117 break;
11118 case 0xa2:
11119 GETBYTE ();
11120 switch (op[2] & 0x00)
11121 {
11122 case 0x00:
11123 goto op_semantics_91;
11124 break;
11125 }
11126 break;
11127 case 0xa3:
11128 GETBYTE ();
11129 switch (op[2] & 0x00)
11130 {
11131 case 0x00:
11132 goto op_semantics_91;
11133 break;
11134 }
11135 break;
11136 case 0xa4:
11137 GETBYTE ();
11138 switch (op[2] & 0x00)
11139 {
11140 case 0x00:
11141 goto op_semantics_91;
11142 break;
11143 }
11144 break;
11145 case 0xa5:
11146 GETBYTE ();
11147 switch (op[2] & 0x00)
11148 {
11149 case 0x00:
11150 goto op_semantics_91;
11151 break;
11152 }
11153 break;
11154 case 0xa6:
11155 GETBYTE ();
11156 switch (op[2] & 0x00)
11157 {
11158 case 0x00:
11159 goto op_semantics_91;
11160 break;
11161 }
11162 break;
11163 case 0xa7:
11164 GETBYTE ();
11165 switch (op[2] & 0x00)
11166 {
11167 case 0x00:
11168 goto op_semantics_91;
11169 break;
11170 }
11171 break;
11172 case 0xa8:
11173 GETBYTE ();
11174 switch (op[2] & 0x00)
11175 {
11176 case 0x00:
11177 goto op_semantics_91;
11178 break;
11179 }
11180 break;
11181 case 0xa9:
11182 GETBYTE ();
11183 switch (op[2] & 0x00)
11184 {
11185 case 0x00:
11186 goto op_semantics_91;
11187 break;
11188 }
11189 break;
11190 case 0xaa:
11191 GETBYTE ();
11192 switch (op[2] & 0x00)
11193 {
11194 case 0x00:
11195 goto op_semantics_91;
11196 break;
11197 }
11198 break;
11199 case 0xab:
11200 GETBYTE ();
11201 switch (op[2] & 0x00)
11202 {
11203 case 0x00:
11204 goto op_semantics_91;
11205 break;
11206 }
11207 break;
11208 case 0xac:
11209 GETBYTE ();
11210 switch (op[2] & 0x00)
11211 {
11212 case 0x00:
11213 goto op_semantics_91;
11214 break;
11215 }
11216 break;
11217 case 0xad:
11218 GETBYTE ();
11219 switch (op[2] & 0x00)
11220 {
11221 case 0x00:
11222 goto op_semantics_91;
11223 break;
11224 }
11225 break;
11226 case 0xae:
11227 GETBYTE ();
11228 switch (op[2] & 0x00)
11229 {
11230 case 0x00:
11231 goto op_semantics_91;
11232 break;
11233 }
11234 break;
11235 case 0xaf:
11236 GETBYTE ();
11237 switch (op[2] & 0x00)
11238 {
11239 case 0x00:
11240 goto op_semantics_91;
11241 break;
11242 }
11243 break;
11244 case 0xb0:
11245 GETBYTE ();
11246 switch (op[2] & 0x00)
11247 {
11248 case 0x00:
11249 goto op_semantics_91;
11250 break;
11251 }
11252 break;
11253 case 0xb1:
11254 GETBYTE ();
11255 switch (op[2] & 0x00)
11256 {
11257 case 0x00:
11258 goto op_semantics_91;
11259 break;
11260 }
11261 break;
11262 case 0xb2:
11263 GETBYTE ();
11264 switch (op[2] & 0x00)
11265 {
11266 case 0x00:
11267 goto op_semantics_91;
11268 break;
11269 }
11270 break;
11271 case 0xb3:
11272 GETBYTE ();
11273 switch (op[2] & 0x00)
11274 {
11275 case 0x00:
11276 goto op_semantics_91;
11277 break;
11278 }
11279 break;
11280 case 0xb4:
11281 GETBYTE ();
11282 switch (op[2] & 0x00)
11283 {
11284 case 0x00:
11285 goto op_semantics_91;
11286 break;
11287 }
11288 break;
11289 case 0xb5:
11290 GETBYTE ();
11291 switch (op[2] & 0x00)
11292 {
11293 case 0x00:
11294 goto op_semantics_91;
11295 break;
11296 }
11297 break;
11298 case 0xb6:
11299 GETBYTE ();
11300 switch (op[2] & 0x00)
11301 {
11302 case 0x00:
11303 goto op_semantics_91;
11304 break;
11305 }
11306 break;
11307 case 0xb7:
11308 GETBYTE ();
11309 switch (op[2] & 0x00)
11310 {
11311 case 0x00:
11312 goto op_semantics_91;
11313 break;
11314 }
11315 break;
11316 case 0xb8:
11317 GETBYTE ();
11318 switch (op[2] & 0x00)
11319 {
11320 case 0x00:
11321 goto op_semantics_91;
11322 break;
11323 }
11324 break;
11325 case 0xb9:
11326 GETBYTE ();
11327 switch (op[2] & 0x00)
11328 {
11329 case 0x00:
11330 goto op_semantics_91;
11331 break;
11332 }
11333 break;
11334 case 0xba:
11335 GETBYTE ();
11336 switch (op[2] & 0x00)
11337 {
11338 case 0x00:
11339 goto op_semantics_91;
11340 break;
11341 }
11342 break;
11343 case 0xbb:
11344 GETBYTE ();
11345 switch (op[2] & 0x00)
11346 {
11347 case 0x00:
11348 goto op_semantics_91;
11349 break;
11350 }
11351 break;
11352 case 0xbc:
11353 GETBYTE ();
11354 switch (op[2] & 0x00)
11355 {
11356 case 0x00:
11357 goto op_semantics_91;
11358 break;
11359 }
11360 break;
11361 case 0xbd:
11362 GETBYTE ();
11363 switch (op[2] & 0x00)
11364 {
11365 case 0x00:
11366 goto op_semantics_91;
11367 break;
11368 }
11369 break;
11370 case 0xbe:
11371 GETBYTE ();
11372 switch (op[2] & 0x00)
11373 {
11374 case 0x00:
11375 goto op_semantics_91;
11376 break;
11377 }
11378 break;
11379 case 0xbf:
11380 GETBYTE ();
11381 switch (op[2] & 0x00)
11382 {
11383 case 0x00:
11384 goto op_semantics_91;
11385 break;
11386 }
11387 break;
11388 case 0xc0:
11389 GETBYTE ();
11390 switch (op[2] & 0x00)
11391 {
11392 case 0x00:
11393 op_semantics_92:
11394 {
11395 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
11396 #line 645 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11397 int immmm AU = op[1] & 0x1f;
11398 #line 645 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11399 int rsrc AU = (op[2] >> 4) & 0x0f;
11400 #line 645 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11401 int rdst AU = op[2] & 0x0f;
11402 if (trace)
11403 {
11404 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11405 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11406 op[0], op[1], op[2]);
11407 printf (" immmm = 0x%x,", immmm);
11408 printf (" rsrc = 0x%x,", rsrc);
11409 printf (" rdst = 0x%x\n", rdst);
11410 }
11411 SYNTAX("shll #%2, %1, %0");
11412 #line 646 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11413 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F("OSZC");
11414
11415
11416 }
11417 break;
11418 }
11419 break;
11420 case 0xc1:
11421 GETBYTE ();
11422 switch (op[2] & 0x00)
11423 {
11424 case 0x00:
11425 goto op_semantics_92;
11426 break;
11427 }
11428 break;
11429 case 0xc2:
11430 GETBYTE ();
11431 switch (op[2] & 0x00)
11432 {
11433 case 0x00:
11434 goto op_semantics_92;
11435 break;
11436 }
11437 break;
11438 case 0xc3:
11439 GETBYTE ();
11440 switch (op[2] & 0x00)
11441 {
11442 case 0x00:
11443 goto op_semantics_92;
11444 break;
11445 }
11446 break;
11447 case 0xc4:
11448 GETBYTE ();
11449 switch (op[2] & 0x00)
11450 {
11451 case 0x00:
11452 goto op_semantics_92;
11453 break;
11454 }
11455 break;
11456 case 0xc5:
11457 GETBYTE ();
11458 switch (op[2] & 0x00)
11459 {
11460 case 0x00:
11461 goto op_semantics_92;
11462 break;
11463 }
11464 break;
11465 case 0xc6:
11466 GETBYTE ();
11467 switch (op[2] & 0x00)
11468 {
11469 case 0x00:
11470 goto op_semantics_92;
11471 break;
11472 }
11473 break;
11474 case 0xc7:
11475 GETBYTE ();
11476 switch (op[2] & 0x00)
11477 {
11478 case 0x00:
11479 goto op_semantics_92;
11480 break;
11481 }
11482 break;
11483 case 0xc8:
11484 GETBYTE ();
11485 switch (op[2] & 0x00)
11486 {
11487 case 0x00:
11488 goto op_semantics_92;
11489 break;
11490 }
11491 break;
11492 case 0xc9:
11493 GETBYTE ();
11494 switch (op[2] & 0x00)
11495 {
11496 case 0x00:
11497 goto op_semantics_92;
11498 break;
11499 }
11500 break;
11501 case 0xca:
11502 GETBYTE ();
11503 switch (op[2] & 0x00)
11504 {
11505 case 0x00:
11506 goto op_semantics_92;
11507 break;
11508 }
11509 break;
11510 case 0xcb:
11511 GETBYTE ();
11512 switch (op[2] & 0x00)
11513 {
11514 case 0x00:
11515 goto op_semantics_92;
11516 break;
11517 }
11518 break;
11519 case 0xcc:
11520 GETBYTE ();
11521 switch (op[2] & 0x00)
11522 {
11523 case 0x00:
11524 goto op_semantics_92;
11525 break;
11526 }
11527 break;
11528 case 0xcd:
11529 GETBYTE ();
11530 switch (op[2] & 0x00)
11531 {
11532 case 0x00:
11533 goto op_semantics_92;
11534 break;
11535 }
11536 break;
11537 case 0xce:
11538 GETBYTE ();
11539 switch (op[2] & 0x00)
11540 {
11541 case 0x00:
11542 goto op_semantics_92;
11543 break;
11544 }
11545 break;
11546 case 0xcf:
11547 GETBYTE ();
11548 switch (op[2] & 0x00)
11549 {
11550 case 0x00:
11551 goto op_semantics_92;
11552 break;
11553 }
11554 break;
11555 case 0xd0:
11556 GETBYTE ();
11557 switch (op[2] & 0x00)
11558 {
11559 case 0x00:
11560 goto op_semantics_92;
11561 break;
11562 }
11563 break;
11564 case 0xd1:
11565 GETBYTE ();
11566 switch (op[2] & 0x00)
11567 {
11568 case 0x00:
11569 goto op_semantics_92;
11570 break;
11571 }
11572 break;
11573 case 0xd2:
11574 GETBYTE ();
11575 switch (op[2] & 0x00)
11576 {
11577 case 0x00:
11578 goto op_semantics_92;
11579 break;
11580 }
11581 break;
11582 case 0xd3:
11583 GETBYTE ();
11584 switch (op[2] & 0x00)
11585 {
11586 case 0x00:
11587 goto op_semantics_92;
11588 break;
11589 }
11590 break;
11591 case 0xd4:
11592 GETBYTE ();
11593 switch (op[2] & 0x00)
11594 {
11595 case 0x00:
11596 goto op_semantics_92;
11597 break;
11598 }
11599 break;
11600 case 0xd5:
11601 GETBYTE ();
11602 switch (op[2] & 0x00)
11603 {
11604 case 0x00:
11605 goto op_semantics_92;
11606 break;
11607 }
11608 break;
11609 case 0xd6:
11610 GETBYTE ();
11611 switch (op[2] & 0x00)
11612 {
11613 case 0x00:
11614 goto op_semantics_92;
11615 break;
11616 }
11617 break;
11618 case 0xd7:
11619 GETBYTE ();
11620 switch (op[2] & 0x00)
11621 {
11622 case 0x00:
11623 goto op_semantics_92;
11624 break;
11625 }
11626 break;
11627 case 0xd8:
11628 GETBYTE ();
11629 switch (op[2] & 0x00)
11630 {
11631 case 0x00:
11632 goto op_semantics_92;
11633 break;
11634 }
11635 break;
11636 case 0xd9:
11637 GETBYTE ();
11638 switch (op[2] & 0x00)
11639 {
11640 case 0x00:
11641 goto op_semantics_92;
11642 break;
11643 }
11644 break;
11645 case 0xda:
11646 GETBYTE ();
11647 switch (op[2] & 0x00)
11648 {
11649 case 0x00:
11650 goto op_semantics_92;
11651 break;
11652 }
11653 break;
11654 case 0xdb:
11655 GETBYTE ();
11656 switch (op[2] & 0x00)
11657 {
11658 case 0x00:
11659 goto op_semantics_92;
11660 break;
11661 }
11662 break;
11663 case 0xdc:
11664 GETBYTE ();
11665 switch (op[2] & 0x00)
11666 {
11667 case 0x00:
11668 goto op_semantics_92;
11669 break;
11670 }
11671 break;
11672 case 0xdd:
11673 GETBYTE ();
11674 switch (op[2] & 0x00)
11675 {
11676 case 0x00:
11677 goto op_semantics_92;
11678 break;
11679 }
11680 break;
11681 case 0xde:
11682 GETBYTE ();
11683 switch (op[2] & 0x00)
11684 {
11685 case 0x00:
11686 goto op_semantics_92;
11687 break;
11688 }
11689 break;
11690 case 0xdf:
11691 GETBYTE ();
11692 switch (op[2] & 0x00)
11693 {
11694 case 0x00:
11695 goto op_semantics_92;
11696 break;
11697 }
11698 break;
11699 case 0xe0:
11700 GETBYTE ();
11701 switch (op[2] & 0xf0)
11702 {
11703 case 0x00:
11704 case 0x10:
11705 case 0x20:
11706 case 0x30:
11707 case 0x40:
11708 case 0x50:
11709 case 0x60:
11710 case 0x70:
11711 case 0x80:
11712 case 0x90:
11713 case 0xa0:
11714 case 0xb0:
11715 case 0xc0:
11716 case 0xd0:
11717 case 0xe0:
11718 op_semantics_93:
11719 {
11720 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
11721 #line 911 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11722 int bittt AU = op[1] & 0x1f;
11723 #line 911 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11724 int cond AU = (op[2] >> 4) & 0x0f;
11725 #line 911 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11726 int rdst AU = op[2] & 0x0f;
11727 if (trace)
11728 {
11729 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11730 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11731 op[0], op[1], op[2]);
11732 printf (" bittt = 0x%x,", bittt);
11733 printf (" cond = 0x%x,", cond);
11734 printf (" rdst = 0x%x\n", rdst);
11735 }
11736 SYNTAX("bm%2 #%1, %0%S0");
11737 #line 912 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11738 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11739
11740 /*----------------------------------------------------------------------*/
11741 /* CONTROL REGISTERS */
11742
11743 }
11744 break;
11745 case 0xf0:
11746 op_semantics_94:
11747 {
11748 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
11749 #line 904 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11750 int bittt AU = op[1] & 0x1f;
11751 #line 904 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11752 int rdst AU = op[2] & 0x0f;
11753 if (trace)
11754 {
11755 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11756 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11757 op[0], op[1], op[2]);
11758 printf (" bittt = 0x%x,", bittt);
11759 printf (" rdst = 0x%x\n", rdst);
11760 }
11761 SYNTAX("bnot #%1, %0");
11762 #line 905 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11763 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11764
11765
11766 }
11767 break;
11768 }
11769 break;
11770 case 0xe1:
11771 GETBYTE ();
11772 switch (op[2] & 0xf0)
11773 {
11774 case 0x00:
11775 case 0x10:
11776 case 0x20:
11777 case 0x30:
11778 case 0x40:
11779 case 0x50:
11780 case 0x60:
11781 case 0x70:
11782 case 0x80:
11783 case 0x90:
11784 case 0xa0:
11785 case 0xb0:
11786 case 0xc0:
11787 case 0xd0:
11788 case 0xe0:
11789 goto op_semantics_93;
11790 break;
11791 case 0xf0:
11792 goto op_semantics_94;
11793 break;
11794 }
11795 break;
11796 case 0xe2:
11797 GETBYTE ();
11798 switch (op[2] & 0xf0)
11799 {
11800 case 0x00:
11801 case 0x10:
11802 case 0x20:
11803 case 0x30:
11804 case 0x40:
11805 case 0x50:
11806 case 0x60:
11807 case 0x70:
11808 case 0x80:
11809 case 0x90:
11810 case 0xa0:
11811 case 0xb0:
11812 case 0xc0:
11813 case 0xd0:
11814 case 0xe0:
11815 goto op_semantics_93;
11816 break;
11817 case 0xf0:
11818 goto op_semantics_94;
11819 break;
11820 }
11821 break;
11822 case 0xe3:
11823 GETBYTE ();
11824 switch (op[2] & 0xf0)
11825 {
11826 case 0x00:
11827 case 0x10:
11828 case 0x20:
11829 case 0x30:
11830 case 0x40:
11831 case 0x50:
11832 case 0x60:
11833 case 0x70:
11834 case 0x80:
11835 case 0x90:
11836 case 0xa0:
11837 case 0xb0:
11838 case 0xc0:
11839 case 0xd0:
11840 case 0xe0:
11841 goto op_semantics_93;
11842 break;
11843 case 0xf0:
11844 goto op_semantics_94;
11845 break;
11846 }
11847 break;
11848 case 0xe4:
11849 GETBYTE ();
11850 switch (op[2] & 0xf0)
11851 {
11852 case 0x00:
11853 case 0x10:
11854 case 0x20:
11855 case 0x30:
11856 case 0x40:
11857 case 0x50:
11858 case 0x60:
11859 case 0x70:
11860 case 0x80:
11861 case 0x90:
11862 case 0xa0:
11863 case 0xb0:
11864 case 0xc0:
11865 case 0xd0:
11866 case 0xe0:
11867 goto op_semantics_93;
11868 break;
11869 case 0xf0:
11870 goto op_semantics_94;
11871 break;
11872 }
11873 break;
11874 case 0xe5:
11875 GETBYTE ();
11876 switch (op[2] & 0xf0)
11877 {
11878 case 0x00:
11879 case 0x10:
11880 case 0x20:
11881 case 0x30:
11882 case 0x40:
11883 case 0x50:
11884 case 0x60:
11885 case 0x70:
11886 case 0x80:
11887 case 0x90:
11888 case 0xa0:
11889 case 0xb0:
11890 case 0xc0:
11891 case 0xd0:
11892 case 0xe0:
11893 goto op_semantics_93;
11894 break;
11895 case 0xf0:
11896 goto op_semantics_94;
11897 break;
11898 }
11899 break;
11900 case 0xe6:
11901 GETBYTE ();
11902 switch (op[2] & 0xf0)
11903 {
11904 case 0x00:
11905 case 0x10:
11906 case 0x20:
11907 case 0x30:
11908 case 0x40:
11909 case 0x50:
11910 case 0x60:
11911 case 0x70:
11912 case 0x80:
11913 case 0x90:
11914 case 0xa0:
11915 case 0xb0:
11916 case 0xc0:
11917 case 0xd0:
11918 case 0xe0:
11919 goto op_semantics_93;
11920 break;
11921 case 0xf0:
11922 goto op_semantics_94;
11923 break;
11924 }
11925 break;
11926 case 0xe7:
11927 GETBYTE ();
11928 switch (op[2] & 0xf0)
11929 {
11930 case 0x00:
11931 case 0x10:
11932 case 0x20:
11933 case 0x30:
11934 case 0x40:
11935 case 0x50:
11936 case 0x60:
11937 case 0x70:
11938 case 0x80:
11939 case 0x90:
11940 case 0xa0:
11941 case 0xb0:
11942 case 0xc0:
11943 case 0xd0:
11944 case 0xe0:
11945 goto op_semantics_93;
11946 break;
11947 case 0xf0:
11948 goto op_semantics_94;
11949 break;
11950 }
11951 break;
11952 case 0xe8:
11953 GETBYTE ();
11954 switch (op[2] & 0xf0)
11955 {
11956 case 0x00:
11957 case 0x10:
11958 case 0x20:
11959 case 0x30:
11960 case 0x40:
11961 case 0x50:
11962 case 0x60:
11963 case 0x70:
11964 case 0x80:
11965 case 0x90:
11966 case 0xa0:
11967 case 0xb0:
11968 case 0xc0:
11969 case 0xd0:
11970 case 0xe0:
11971 goto op_semantics_93;
11972 break;
11973 case 0xf0:
11974 goto op_semantics_94;
11975 break;
11976 }
11977 break;
11978 case 0xe9:
11979 GETBYTE ();
11980 switch (op[2] & 0xf0)
11981 {
11982 case 0x00:
11983 case 0x10:
11984 case 0x20:
11985 case 0x30:
11986 case 0x40:
11987 case 0x50:
11988 case 0x60:
11989 case 0x70:
11990 case 0x80:
11991 case 0x90:
11992 case 0xa0:
11993 case 0xb0:
11994 case 0xc0:
11995 case 0xd0:
11996 case 0xe0:
11997 goto op_semantics_93;
11998 break;
11999 case 0xf0:
12000 goto op_semantics_94;
12001 break;
12002 }
12003 break;
12004 case 0xea:
12005 GETBYTE ();
12006 switch (op[2] & 0xf0)
12007 {
12008 case 0x00:
12009 case 0x10:
12010 case 0x20:
12011 case 0x30:
12012 case 0x40:
12013 case 0x50:
12014 case 0x60:
12015 case 0x70:
12016 case 0x80:
12017 case 0x90:
12018 case 0xa0:
12019 case 0xb0:
12020 case 0xc0:
12021 case 0xd0:
12022 case 0xe0:
12023 goto op_semantics_93;
12024 break;
12025 case 0xf0:
12026 goto op_semantics_94;
12027 break;
12028 }
12029 break;
12030 case 0xeb:
12031 GETBYTE ();
12032 switch (op[2] & 0xf0)
12033 {
12034 case 0x00:
12035 case 0x10:
12036 case 0x20:
12037 case 0x30:
12038 case 0x40:
12039 case 0x50:
12040 case 0x60:
12041 case 0x70:
12042 case 0x80:
12043 case 0x90:
12044 case 0xa0:
12045 case 0xb0:
12046 case 0xc0:
12047 case 0xd0:
12048 case 0xe0:
12049 goto op_semantics_93;
12050 break;
12051 case 0xf0:
12052 goto op_semantics_94;
12053 break;
12054 }
12055 break;
12056 case 0xec:
12057 GETBYTE ();
12058 switch (op[2] & 0xf0)
12059 {
12060 case 0x00:
12061 case 0x10:
12062 case 0x20:
12063 case 0x30:
12064 case 0x40:
12065 case 0x50:
12066 case 0x60:
12067 case 0x70:
12068 case 0x80:
12069 case 0x90:
12070 case 0xa0:
12071 case 0xb0:
12072 case 0xc0:
12073 case 0xd0:
12074 case 0xe0:
12075 goto op_semantics_93;
12076 break;
12077 case 0xf0:
12078 goto op_semantics_94;
12079 break;
12080 }
12081 break;
12082 case 0xed:
12083 GETBYTE ();
12084 switch (op[2] & 0xf0)
12085 {
12086 case 0x00:
12087 case 0x10:
12088 case 0x20:
12089 case 0x30:
12090 case 0x40:
12091 case 0x50:
12092 case 0x60:
12093 case 0x70:
12094 case 0x80:
12095 case 0x90:
12096 case 0xa0:
12097 case 0xb0:
12098 case 0xc0:
12099 case 0xd0:
12100 case 0xe0:
12101 goto op_semantics_93;
12102 break;
12103 case 0xf0:
12104 goto op_semantics_94;
12105 break;
12106 }
12107 break;
12108 case 0xee:
12109 GETBYTE ();
12110 switch (op[2] & 0xf0)
12111 {
12112 case 0x00:
12113 case 0x10:
12114 case 0x20:
12115 case 0x30:
12116 case 0x40:
12117 case 0x50:
12118 case 0x60:
12119 case 0x70:
12120 case 0x80:
12121 case 0x90:
12122 case 0xa0:
12123 case 0xb0:
12124 case 0xc0:
12125 case 0xd0:
12126 case 0xe0:
12127 goto op_semantics_93;
12128 break;
12129 case 0xf0:
12130 goto op_semantics_94;
12131 break;
12132 }
12133 break;
12134 case 0xef:
12135 GETBYTE ();
12136 switch (op[2] & 0xf0)
12137 {
12138 case 0x00:
12139 case 0x10:
12140 case 0x20:
12141 case 0x30:
12142 case 0x40:
12143 case 0x50:
12144 case 0x60:
12145 case 0x70:
12146 case 0x80:
12147 case 0x90:
12148 case 0xa0:
12149 case 0xb0:
12150 case 0xc0:
12151 case 0xd0:
12152 case 0xe0:
12153 goto op_semantics_93;
12154 break;
12155 case 0xf0:
12156 goto op_semantics_94;
12157 break;
12158 }
12159 break;
12160 case 0xf0:
12161 GETBYTE ();
12162 switch (op[2] & 0xf0)
12163 {
12164 case 0x00:
12165 case 0x10:
12166 case 0x20:
12167 case 0x30:
12168 case 0x40:
12169 case 0x50:
12170 case 0x60:
12171 case 0x70:
12172 case 0x80:
12173 case 0x90:
12174 case 0xa0:
12175 case 0xb0:
12176 case 0xc0:
12177 case 0xd0:
12178 case 0xe0:
12179 goto op_semantics_93;
12180 break;
12181 case 0xf0:
12182 goto op_semantics_94;
12183 break;
12184 }
12185 break;
12186 case 0xf1:
12187 GETBYTE ();
12188 switch (op[2] & 0xf0)
12189 {
12190 case 0x00:
12191 case 0x10:
12192 case 0x20:
12193 case 0x30:
12194 case 0x40:
12195 case 0x50:
12196 case 0x60:
12197 case 0x70:
12198 case 0x80:
12199 case 0x90:
12200 case 0xa0:
12201 case 0xb0:
12202 case 0xc0:
12203 case 0xd0:
12204 case 0xe0:
12205 goto op_semantics_93;
12206 break;
12207 case 0xf0:
12208 goto op_semantics_94;
12209 break;
12210 }
12211 break;
12212 case 0xf2:
12213 GETBYTE ();
12214 switch (op[2] & 0xf0)
12215 {
12216 case 0x00:
12217 case 0x10:
12218 case 0x20:
12219 case 0x30:
12220 case 0x40:
12221 case 0x50:
12222 case 0x60:
12223 case 0x70:
12224 case 0x80:
12225 case 0x90:
12226 case 0xa0:
12227 case 0xb0:
12228 case 0xc0:
12229 case 0xd0:
12230 case 0xe0:
12231 goto op_semantics_93;
12232 break;
12233 case 0xf0:
12234 goto op_semantics_94;
12235 break;
12236 }
12237 break;
12238 case 0xf3:
12239 GETBYTE ();
12240 switch (op[2] & 0xf0)
12241 {
12242 case 0x00:
12243 case 0x10:
12244 case 0x20:
12245 case 0x30:
12246 case 0x40:
12247 case 0x50:
12248 case 0x60:
12249 case 0x70:
12250 case 0x80:
12251 case 0x90:
12252 case 0xa0:
12253 case 0xb0:
12254 case 0xc0:
12255 case 0xd0:
12256 case 0xe0:
12257 goto op_semantics_93;
12258 break;
12259 case 0xf0:
12260 goto op_semantics_94;
12261 break;
12262 }
12263 break;
12264 case 0xf4:
12265 GETBYTE ();
12266 switch (op[2] & 0xf0)
12267 {
12268 case 0x00:
12269 case 0x10:
12270 case 0x20:
12271 case 0x30:
12272 case 0x40:
12273 case 0x50:
12274 case 0x60:
12275 case 0x70:
12276 case 0x80:
12277 case 0x90:
12278 case 0xa0:
12279 case 0xb0:
12280 case 0xc0:
12281 case 0xd0:
12282 case 0xe0:
12283 goto op_semantics_93;
12284 break;
12285 case 0xf0:
12286 goto op_semantics_94;
12287 break;
12288 }
12289 break;
12290 case 0xf5:
12291 GETBYTE ();
12292 switch (op[2] & 0xf0)
12293 {
12294 case 0x00:
12295 case 0x10:
12296 case 0x20:
12297 case 0x30:
12298 case 0x40:
12299 case 0x50:
12300 case 0x60:
12301 case 0x70:
12302 case 0x80:
12303 case 0x90:
12304 case 0xa0:
12305 case 0xb0:
12306 case 0xc0:
12307 case 0xd0:
12308 case 0xe0:
12309 goto op_semantics_93;
12310 break;
12311 case 0xf0:
12312 goto op_semantics_94;
12313 break;
12314 }
12315 break;
12316 case 0xf6:
12317 GETBYTE ();
12318 switch (op[2] & 0xf0)
12319 {
12320 case 0x00:
12321 case 0x10:
12322 case 0x20:
12323 case 0x30:
12324 case 0x40:
12325 case 0x50:
12326 case 0x60:
12327 case 0x70:
12328 case 0x80:
12329 case 0x90:
12330 case 0xa0:
12331 case 0xb0:
12332 case 0xc0:
12333 case 0xd0:
12334 case 0xe0:
12335 goto op_semantics_93;
12336 break;
12337 case 0xf0:
12338 goto op_semantics_94;
12339 break;
12340 }
12341 break;
12342 case 0xf7:
12343 GETBYTE ();
12344 switch (op[2] & 0xf0)
12345 {
12346 case 0x00:
12347 case 0x10:
12348 case 0x20:
12349 case 0x30:
12350 case 0x40:
12351 case 0x50:
12352 case 0x60:
12353 case 0x70:
12354 case 0x80:
12355 case 0x90:
12356 case 0xa0:
12357 case 0xb0:
12358 case 0xc0:
12359 case 0xd0:
12360 case 0xe0:
12361 goto op_semantics_93;
12362 break;
12363 case 0xf0:
12364 goto op_semantics_94;
12365 break;
12366 }
12367 break;
12368 case 0xf8:
12369 GETBYTE ();
12370 switch (op[2] & 0xf0)
12371 {
12372 case 0x00:
12373 case 0x10:
12374 case 0x20:
12375 case 0x30:
12376 case 0x40:
12377 case 0x50:
12378 case 0x60:
12379 case 0x70:
12380 case 0x80:
12381 case 0x90:
12382 case 0xa0:
12383 case 0xb0:
12384 case 0xc0:
12385 case 0xd0:
12386 case 0xe0:
12387 goto op_semantics_93;
12388 break;
12389 case 0xf0:
12390 goto op_semantics_94;
12391 break;
12392 }
12393 break;
12394 case 0xf9:
12395 GETBYTE ();
12396 switch (op[2] & 0xf0)
12397 {
12398 case 0x00:
12399 case 0x10:
12400 case 0x20:
12401 case 0x30:
12402 case 0x40:
12403 case 0x50:
12404 case 0x60:
12405 case 0x70:
12406 case 0x80:
12407 case 0x90:
12408 case 0xa0:
12409 case 0xb0:
12410 case 0xc0:
12411 case 0xd0:
12412 case 0xe0:
12413 goto op_semantics_93;
12414 break;
12415 case 0xf0:
12416 goto op_semantics_94;
12417 break;
12418 }
12419 break;
12420 case 0xfa:
12421 GETBYTE ();
12422 switch (op[2] & 0xf0)
12423 {
12424 case 0x00:
12425 case 0x10:
12426 case 0x20:
12427 case 0x30:
12428 case 0x40:
12429 case 0x50:
12430 case 0x60:
12431 case 0x70:
12432 case 0x80:
12433 case 0x90:
12434 case 0xa0:
12435 case 0xb0:
12436 case 0xc0:
12437 case 0xd0:
12438 case 0xe0:
12439 goto op_semantics_93;
12440 break;
12441 case 0xf0:
12442 goto op_semantics_94;
12443 break;
12444 }
12445 break;
12446 case 0xfb:
12447 GETBYTE ();
12448 switch (op[2] & 0xf0)
12449 {
12450 case 0x00:
12451 case 0x10:
12452 case 0x20:
12453 case 0x30:
12454 case 0x40:
12455 case 0x50:
12456 case 0x60:
12457 case 0x70:
12458 case 0x80:
12459 case 0x90:
12460 case 0xa0:
12461 case 0xb0:
12462 case 0xc0:
12463 case 0xd0:
12464 case 0xe0:
12465 goto op_semantics_93;
12466 break;
12467 case 0xf0:
12468 goto op_semantics_94;
12469 break;
12470 }
12471 break;
12472 case 0xfc:
12473 GETBYTE ();
12474 switch (op[2] & 0xf0)
12475 {
12476 case 0x00:
12477 case 0x10:
12478 case 0x20:
12479 case 0x30:
12480 case 0x40:
12481 case 0x50:
12482 case 0x60:
12483 case 0x70:
12484 case 0x80:
12485 case 0x90:
12486 case 0xa0:
12487 case 0xb0:
12488 case 0xc0:
12489 case 0xd0:
12490 case 0xe0:
12491 goto op_semantics_93;
12492 break;
12493 case 0xf0:
12494 goto op_semantics_94;
12495 break;
12496 }
12497 break;
12498 case 0xfd:
12499 GETBYTE ();
12500 switch (op[2] & 0xf0)
12501 {
12502 case 0x00:
12503 case 0x10:
12504 case 0x20:
12505 case 0x30:
12506 case 0x40:
12507 case 0x50:
12508 case 0x60:
12509 case 0x70:
12510 case 0x80:
12511 case 0x90:
12512 case 0xa0:
12513 case 0xb0:
12514 case 0xc0:
12515 case 0xd0:
12516 case 0xe0:
12517 goto op_semantics_93;
12518 break;
12519 case 0xf0:
12520 goto op_semantics_94;
12521 break;
12522 }
12523 break;
12524 case 0xfe:
12525 GETBYTE ();
12526 switch (op[2] & 0xf0)
12527 {
12528 case 0x00:
12529 case 0x10:
12530 case 0x20:
12531 case 0x30:
12532 case 0x40:
12533 case 0x50:
12534 case 0x60:
12535 case 0x70:
12536 case 0x80:
12537 case 0x90:
12538 case 0xa0:
12539 case 0xb0:
12540 case 0xc0:
12541 case 0xd0:
12542 case 0xe0:
12543 goto op_semantics_93;
12544 break;
12545 case 0xf0:
12546 goto op_semantics_94;
12547 break;
12548 }
12549 break;
12550 case 0xff:
12551 GETBYTE ();
12552 switch (op[2] & 0xf0)
12553 {
12554 case 0x00:
12555 case 0x10:
12556 case 0x20:
12557 case 0x30:
12558 case 0x40:
12559 case 0x50:
12560 case 0x60:
12561 case 0x70:
12562 case 0x80:
12563 case 0x90:
12564 case 0xa0:
12565 case 0xb0:
12566 case 0xc0:
12567 case 0xd0:
12568 case 0xe0:
12569 goto op_semantics_93;
12570 break;
12571 case 0xf0:
12572 goto op_semantics_94;
12573 break;
12574 }
12575 break;
12576 default: UNSUPPORTED(); break;
12577 }
12578 break;
12579 case 0xfe:
12580 GETBYTE ();
12581 switch (op[1] & 0xff)
12582 {
12583 case 0x00:
12584 GETBYTE ();
12585 switch (op[2] & 0x00)
12586 {
12587 case 0x00:
12588 op_semantics_95:
12589 {
12590 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
12591 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12592 int sz AU = (op[1] >> 4) & 0x03;
12593 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12594 int isrc AU = op[1] & 0x0f;
12595 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12596 int bsrc AU = (op[2] >> 4) & 0x0f;
12597 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12598 int rdst AU = op[2] & 0x0f;
12599 if (trace)
12600 {
12601 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12602 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12603 op[0], op[1], op[2]);
12604 printf (" sz = 0x%x,", sz);
12605 printf (" isrc = 0x%x,", isrc);
12606 printf (" bsrc = 0x%x,", bsrc);
12607 printf (" rdst = 0x%x\n", rdst);
12608 }
12609 SYNTAX("mov%s %0, [%1, %2]");
12610 #line 318 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12611 ID(movbir); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
12612
12613 }
12614 break;
12615 }
12616 break;
12617 case 0x01:
12618 GETBYTE ();
12619 switch (op[2] & 0x00)
12620 {
12621 case 0x00:
12622 goto op_semantics_95;
12623 break;
12624 }
12625 break;
12626 case 0x02:
12627 GETBYTE ();
12628 switch (op[2] & 0x00)
12629 {
12630 case 0x00:
12631 goto op_semantics_95;
12632 break;
12633 }
12634 break;
12635 case 0x03:
12636 GETBYTE ();
12637 switch (op[2] & 0x00)
12638 {
12639 case 0x00:
12640 goto op_semantics_95;
12641 break;
12642 }
12643 break;
12644 case 0x04:
12645 GETBYTE ();
12646 switch (op[2] & 0x00)
12647 {
12648 case 0x00:
12649 goto op_semantics_95;
12650 break;
12651 }
12652 break;
12653 case 0x05:
12654 GETBYTE ();
12655 switch (op[2] & 0x00)
12656 {
12657 case 0x00:
12658 goto op_semantics_95;
12659 break;
12660 }
12661 break;
12662 case 0x06:
12663 GETBYTE ();
12664 switch (op[2] & 0x00)
12665 {
12666 case 0x00:
12667 goto op_semantics_95;
12668 break;
12669 }
12670 break;
12671 case 0x07:
12672 GETBYTE ();
12673 switch (op[2] & 0x00)
12674 {
12675 case 0x00:
12676 goto op_semantics_95;
12677 break;
12678 }
12679 break;
12680 case 0x08:
12681 GETBYTE ();
12682 switch (op[2] & 0x00)
12683 {
12684 case 0x00:
12685 goto op_semantics_95;
12686 break;
12687 }
12688 break;
12689 case 0x09:
12690 GETBYTE ();
12691 switch (op[2] & 0x00)
12692 {
12693 case 0x00:
12694 goto op_semantics_95;
12695 break;
12696 }
12697 break;
12698 case 0x0a:
12699 GETBYTE ();
12700 switch (op[2] & 0x00)
12701 {
12702 case 0x00:
12703 goto op_semantics_95;
12704 break;
12705 }
12706 break;
12707 case 0x0b:
12708 GETBYTE ();
12709 switch (op[2] & 0x00)
12710 {
12711 case 0x00:
12712 goto op_semantics_95;
12713 break;
12714 }
12715 break;
12716 case 0x0c:
12717 GETBYTE ();
12718 switch (op[2] & 0x00)
12719 {
12720 case 0x00:
12721 goto op_semantics_95;
12722 break;
12723 }
12724 break;
12725 case 0x0d:
12726 GETBYTE ();
12727 switch (op[2] & 0x00)
12728 {
12729 case 0x00:
12730 goto op_semantics_95;
12731 break;
12732 }
12733 break;
12734 case 0x0e:
12735 GETBYTE ();
12736 switch (op[2] & 0x00)
12737 {
12738 case 0x00:
12739 goto op_semantics_95;
12740 break;
12741 }
12742 break;
12743 case 0x0f:
12744 GETBYTE ();
12745 switch (op[2] & 0x00)
12746 {
12747 case 0x00:
12748 goto op_semantics_95;
12749 break;
12750 }
12751 break;
12752 case 0x10:
12753 GETBYTE ();
12754 switch (op[2] & 0x00)
12755 {
12756 case 0x00:
12757 goto op_semantics_95;
12758 break;
12759 }
12760 break;
12761 case 0x11:
12762 GETBYTE ();
12763 switch (op[2] & 0x00)
12764 {
12765 case 0x00:
12766 goto op_semantics_95;
12767 break;
12768 }
12769 break;
12770 case 0x12:
12771 GETBYTE ();
12772 switch (op[2] & 0x00)
12773 {
12774 case 0x00:
12775 goto op_semantics_95;
12776 break;
12777 }
12778 break;
12779 case 0x13:
12780 GETBYTE ();
12781 switch (op[2] & 0x00)
12782 {
12783 case 0x00:
12784 goto op_semantics_95;
12785 break;
12786 }
12787 break;
12788 case 0x14:
12789 GETBYTE ();
12790 switch (op[2] & 0x00)
12791 {
12792 case 0x00:
12793 goto op_semantics_95;
12794 break;
12795 }
12796 break;
12797 case 0x15:
12798 GETBYTE ();
12799 switch (op[2] & 0x00)
12800 {
12801 case 0x00:
12802 goto op_semantics_95;
12803 break;
12804 }
12805 break;
12806 case 0x16:
12807 GETBYTE ();
12808 switch (op[2] & 0x00)
12809 {
12810 case 0x00:
12811 goto op_semantics_95;
12812 break;
12813 }
12814 break;
12815 case 0x17:
12816 GETBYTE ();
12817 switch (op[2] & 0x00)
12818 {
12819 case 0x00:
12820 goto op_semantics_95;
12821 break;
12822 }
12823 break;
12824 case 0x18:
12825 GETBYTE ();
12826 switch (op[2] & 0x00)
12827 {
12828 case 0x00:
12829 goto op_semantics_95;
12830 break;
12831 }
12832 break;
12833 case 0x19:
12834 GETBYTE ();
12835 switch (op[2] & 0x00)
12836 {
12837 case 0x00:
12838 goto op_semantics_95;
12839 break;
12840 }
12841 break;
12842 case 0x1a:
12843 GETBYTE ();
12844 switch (op[2] & 0x00)
12845 {
12846 case 0x00:
12847 goto op_semantics_95;
12848 break;
12849 }
12850 break;
12851 case 0x1b:
12852 GETBYTE ();
12853 switch (op[2] & 0x00)
12854 {
12855 case 0x00:
12856 goto op_semantics_95;
12857 break;
12858 }
12859 break;
12860 case 0x1c:
12861 GETBYTE ();
12862 switch (op[2] & 0x00)
12863 {
12864 case 0x00:
12865 goto op_semantics_95;
12866 break;
12867 }
12868 break;
12869 case 0x1d:
12870 GETBYTE ();
12871 switch (op[2] & 0x00)
12872 {
12873 case 0x00:
12874 goto op_semantics_95;
12875 break;
12876 }
12877 break;
12878 case 0x1e:
12879 GETBYTE ();
12880 switch (op[2] & 0x00)
12881 {
12882 case 0x00:
12883 goto op_semantics_95;
12884 break;
12885 }
12886 break;
12887 case 0x1f:
12888 GETBYTE ();
12889 switch (op[2] & 0x00)
12890 {
12891 case 0x00:
12892 goto op_semantics_95;
12893 break;
12894 }
12895 break;
12896 case 0x20:
12897 GETBYTE ();
12898 switch (op[2] & 0x00)
12899 {
12900 case 0x00:
12901 goto op_semantics_95;
12902 break;
12903 }
12904 break;
12905 case 0x21:
12906 GETBYTE ();
12907 switch (op[2] & 0x00)
12908 {
12909 case 0x00:
12910 goto op_semantics_95;
12911 break;
12912 }
12913 break;
12914 case 0x22:
12915 GETBYTE ();
12916 switch (op[2] & 0x00)
12917 {
12918 case 0x00:
12919 goto op_semantics_95;
12920 break;
12921 }
12922 break;
12923 case 0x23:
12924 GETBYTE ();
12925 switch (op[2] & 0x00)
12926 {
12927 case 0x00:
12928 goto op_semantics_95;
12929 break;
12930 }
12931 break;
12932 case 0x24:
12933 GETBYTE ();
12934 switch (op[2] & 0x00)
12935 {
12936 case 0x00:
12937 goto op_semantics_95;
12938 break;
12939 }
12940 break;
12941 case 0x25:
12942 GETBYTE ();
12943 switch (op[2] & 0x00)
12944 {
12945 case 0x00:
12946 goto op_semantics_95;
12947 break;
12948 }
12949 break;
12950 case 0x26:
12951 GETBYTE ();
12952 switch (op[2] & 0x00)
12953 {
12954 case 0x00:
12955 goto op_semantics_95;
12956 break;
12957 }
12958 break;
12959 case 0x27:
12960 GETBYTE ();
12961 switch (op[2] & 0x00)
12962 {
12963 case 0x00:
12964 goto op_semantics_95;
12965 break;
12966 }
12967 break;
12968 case 0x28:
12969 GETBYTE ();
12970 switch (op[2] & 0x00)
12971 {
12972 case 0x00:
12973 goto op_semantics_95;
12974 break;
12975 }
12976 break;
12977 case 0x29:
12978 GETBYTE ();
12979 switch (op[2] & 0x00)
12980 {
12981 case 0x00:
12982 goto op_semantics_95;
12983 break;
12984 }
12985 break;
12986 case 0x2a:
12987 GETBYTE ();
12988 switch (op[2] & 0x00)
12989 {
12990 case 0x00:
12991 goto op_semantics_95;
12992 break;
12993 }
12994 break;
12995 case 0x2b:
12996 GETBYTE ();
12997 switch (op[2] & 0x00)
12998 {
12999 case 0x00:
13000 goto op_semantics_95;
13001 break;
13002 }
13003 break;
13004 case 0x2c:
13005 GETBYTE ();
13006 switch (op[2] & 0x00)
13007 {
13008 case 0x00:
13009 goto op_semantics_95;
13010 break;
13011 }
13012 break;
13013 case 0x2d:
13014 GETBYTE ();
13015 switch (op[2] & 0x00)
13016 {
13017 case 0x00:
13018 goto op_semantics_95;
13019 break;
13020 }
13021 break;
13022 case 0x2e:
13023 GETBYTE ();
13024 switch (op[2] & 0x00)
13025 {
13026 case 0x00:
13027 goto op_semantics_95;
13028 break;
13029 }
13030 break;
13031 case 0x2f:
13032 GETBYTE ();
13033 switch (op[2] & 0x00)
13034 {
13035 case 0x00:
13036 goto op_semantics_95;
13037 break;
13038 }
13039 break;
13040 case 0x40:
13041 GETBYTE ();
13042 switch (op[2] & 0x00)
13043 {
13044 case 0x00:
13045 op_semantics_96:
13046 {
13047 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
13048 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13049 int sz AU = (op[1] >> 4) & 0x03;
13050 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13051 int isrc AU = op[1] & 0x0f;
13052 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13053 int bsrc AU = (op[2] >> 4) & 0x0f;
13054 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13055 int rdst AU = op[2] & 0x0f;
13056 if (trace)
13057 {
13058 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13059 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13060 op[0], op[1], op[2]);
13061 printf (" sz = 0x%x,", sz);
13062 printf (" isrc = 0x%x,", isrc);
13063 printf (" bsrc = 0x%x,", bsrc);
13064 printf (" rdst = 0x%x\n", rdst);
13065 }
13066 SYNTAX("mov%s [%1, %2], %0");
13067 #line 315 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13068 ID(movbi); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13069
13070 }
13071 break;
13072 }
13073 break;
13074 case 0x41:
13075 GETBYTE ();
13076 switch (op[2] & 0x00)
13077 {
13078 case 0x00:
13079 goto op_semantics_96;
13080 break;
13081 }
13082 break;
13083 case 0x42:
13084 GETBYTE ();
13085 switch (op[2] & 0x00)
13086 {
13087 case 0x00:
13088 goto op_semantics_96;
13089 break;
13090 }
13091 break;
13092 case 0x43:
13093 GETBYTE ();
13094 switch (op[2] & 0x00)
13095 {
13096 case 0x00:
13097 goto op_semantics_96;
13098 break;
13099 }
13100 break;
13101 case 0x44:
13102 GETBYTE ();
13103 switch (op[2] & 0x00)
13104 {
13105 case 0x00:
13106 goto op_semantics_96;
13107 break;
13108 }
13109 break;
13110 case 0x45:
13111 GETBYTE ();
13112 switch (op[2] & 0x00)
13113 {
13114 case 0x00:
13115 goto op_semantics_96;
13116 break;
13117 }
13118 break;
13119 case 0x46:
13120 GETBYTE ();
13121 switch (op[2] & 0x00)
13122 {
13123 case 0x00:
13124 goto op_semantics_96;
13125 break;
13126 }
13127 break;
13128 case 0x47:
13129 GETBYTE ();
13130 switch (op[2] & 0x00)
13131 {
13132 case 0x00:
13133 goto op_semantics_96;
13134 break;
13135 }
13136 break;
13137 case 0x48:
13138 GETBYTE ();
13139 switch (op[2] & 0x00)
13140 {
13141 case 0x00:
13142 goto op_semantics_96;
13143 break;
13144 }
13145 break;
13146 case 0x49:
13147 GETBYTE ();
13148 switch (op[2] & 0x00)
13149 {
13150 case 0x00:
13151 goto op_semantics_96;
13152 break;
13153 }
13154 break;
13155 case 0x4a:
13156 GETBYTE ();
13157 switch (op[2] & 0x00)
13158 {
13159 case 0x00:
13160 goto op_semantics_96;
13161 break;
13162 }
13163 break;
13164 case 0x4b:
13165 GETBYTE ();
13166 switch (op[2] & 0x00)
13167 {
13168 case 0x00:
13169 goto op_semantics_96;
13170 break;
13171 }
13172 break;
13173 case 0x4c:
13174 GETBYTE ();
13175 switch (op[2] & 0x00)
13176 {
13177 case 0x00:
13178 goto op_semantics_96;
13179 break;
13180 }
13181 break;
13182 case 0x4d:
13183 GETBYTE ();
13184 switch (op[2] & 0x00)
13185 {
13186 case 0x00:
13187 goto op_semantics_96;
13188 break;
13189 }
13190 break;
13191 case 0x4e:
13192 GETBYTE ();
13193 switch (op[2] & 0x00)
13194 {
13195 case 0x00:
13196 goto op_semantics_96;
13197 break;
13198 }
13199 break;
13200 case 0x4f:
13201 GETBYTE ();
13202 switch (op[2] & 0x00)
13203 {
13204 case 0x00:
13205 goto op_semantics_96;
13206 break;
13207 }
13208 break;
13209 case 0x50:
13210 GETBYTE ();
13211 switch (op[2] & 0x00)
13212 {
13213 case 0x00:
13214 goto op_semantics_96;
13215 break;
13216 }
13217 break;
13218 case 0x51:
13219 GETBYTE ();
13220 switch (op[2] & 0x00)
13221 {
13222 case 0x00:
13223 goto op_semantics_96;
13224 break;
13225 }
13226 break;
13227 case 0x52:
13228 GETBYTE ();
13229 switch (op[2] & 0x00)
13230 {
13231 case 0x00:
13232 goto op_semantics_96;
13233 break;
13234 }
13235 break;
13236 case 0x53:
13237 GETBYTE ();
13238 switch (op[2] & 0x00)
13239 {
13240 case 0x00:
13241 goto op_semantics_96;
13242 break;
13243 }
13244 break;
13245 case 0x54:
13246 GETBYTE ();
13247 switch (op[2] & 0x00)
13248 {
13249 case 0x00:
13250 goto op_semantics_96;
13251 break;
13252 }
13253 break;
13254 case 0x55:
13255 GETBYTE ();
13256 switch (op[2] & 0x00)
13257 {
13258 case 0x00:
13259 goto op_semantics_96;
13260 break;
13261 }
13262 break;
13263 case 0x56:
13264 GETBYTE ();
13265 switch (op[2] & 0x00)
13266 {
13267 case 0x00:
13268 goto op_semantics_96;
13269 break;
13270 }
13271 break;
13272 case 0x57:
13273 GETBYTE ();
13274 switch (op[2] & 0x00)
13275 {
13276 case 0x00:
13277 goto op_semantics_96;
13278 break;
13279 }
13280 break;
13281 case 0x58:
13282 GETBYTE ();
13283 switch (op[2] & 0x00)
13284 {
13285 case 0x00:
13286 goto op_semantics_96;
13287 break;
13288 }
13289 break;
13290 case 0x59:
13291 GETBYTE ();
13292 switch (op[2] & 0x00)
13293 {
13294 case 0x00:
13295 goto op_semantics_96;
13296 break;
13297 }
13298 break;
13299 case 0x5a:
13300 GETBYTE ();
13301 switch (op[2] & 0x00)
13302 {
13303 case 0x00:
13304 goto op_semantics_96;
13305 break;
13306 }
13307 break;
13308 case 0x5b:
13309 GETBYTE ();
13310 switch (op[2] & 0x00)
13311 {
13312 case 0x00:
13313 goto op_semantics_96;
13314 break;
13315 }
13316 break;
13317 case 0x5c:
13318 GETBYTE ();
13319 switch (op[2] & 0x00)
13320 {
13321 case 0x00:
13322 goto op_semantics_96;
13323 break;
13324 }
13325 break;
13326 case 0x5d:
13327 GETBYTE ();
13328 switch (op[2] & 0x00)
13329 {
13330 case 0x00:
13331 goto op_semantics_96;
13332 break;
13333 }
13334 break;
13335 case 0x5e:
13336 GETBYTE ();
13337 switch (op[2] & 0x00)
13338 {
13339 case 0x00:
13340 goto op_semantics_96;
13341 break;
13342 }
13343 break;
13344 case 0x5f:
13345 GETBYTE ();
13346 switch (op[2] & 0x00)
13347 {
13348 case 0x00:
13349 goto op_semantics_96;
13350 break;
13351 }
13352 break;
13353 case 0x60:
13354 GETBYTE ();
13355 switch (op[2] & 0x00)
13356 {
13357 case 0x00:
13358 goto op_semantics_96;
13359 break;
13360 }
13361 break;
13362 case 0x61:
13363 GETBYTE ();
13364 switch (op[2] & 0x00)
13365 {
13366 case 0x00:
13367 goto op_semantics_96;
13368 break;
13369 }
13370 break;
13371 case 0x62:
13372 GETBYTE ();
13373 switch (op[2] & 0x00)
13374 {
13375 case 0x00:
13376 goto op_semantics_96;
13377 break;
13378 }
13379 break;
13380 case 0x63:
13381 GETBYTE ();
13382 switch (op[2] & 0x00)
13383 {
13384 case 0x00:
13385 goto op_semantics_96;
13386 break;
13387 }
13388 break;
13389 case 0x64:
13390 GETBYTE ();
13391 switch (op[2] & 0x00)
13392 {
13393 case 0x00:
13394 goto op_semantics_96;
13395 break;
13396 }
13397 break;
13398 case 0x65:
13399 GETBYTE ();
13400 switch (op[2] & 0x00)
13401 {
13402 case 0x00:
13403 goto op_semantics_96;
13404 break;
13405 }
13406 break;
13407 case 0x66:
13408 GETBYTE ();
13409 switch (op[2] & 0x00)
13410 {
13411 case 0x00:
13412 goto op_semantics_96;
13413 break;
13414 }
13415 break;
13416 case 0x67:
13417 GETBYTE ();
13418 switch (op[2] & 0x00)
13419 {
13420 case 0x00:
13421 goto op_semantics_96;
13422 break;
13423 }
13424 break;
13425 case 0x68:
13426 GETBYTE ();
13427 switch (op[2] & 0x00)
13428 {
13429 case 0x00:
13430 goto op_semantics_96;
13431 break;
13432 }
13433 break;
13434 case 0x69:
13435 GETBYTE ();
13436 switch (op[2] & 0x00)
13437 {
13438 case 0x00:
13439 goto op_semantics_96;
13440 break;
13441 }
13442 break;
13443 case 0x6a:
13444 GETBYTE ();
13445 switch (op[2] & 0x00)
13446 {
13447 case 0x00:
13448 goto op_semantics_96;
13449 break;
13450 }
13451 break;
13452 case 0x6b:
13453 GETBYTE ();
13454 switch (op[2] & 0x00)
13455 {
13456 case 0x00:
13457 goto op_semantics_96;
13458 break;
13459 }
13460 break;
13461 case 0x6c:
13462 GETBYTE ();
13463 switch (op[2] & 0x00)
13464 {
13465 case 0x00:
13466 goto op_semantics_96;
13467 break;
13468 }
13469 break;
13470 case 0x6d:
13471 GETBYTE ();
13472 switch (op[2] & 0x00)
13473 {
13474 case 0x00:
13475 goto op_semantics_96;
13476 break;
13477 }
13478 break;
13479 case 0x6e:
13480 GETBYTE ();
13481 switch (op[2] & 0x00)
13482 {
13483 case 0x00:
13484 goto op_semantics_96;
13485 break;
13486 }
13487 break;
13488 case 0x6f:
13489 GETBYTE ();
13490 switch (op[2] & 0x00)
13491 {
13492 case 0x00:
13493 goto op_semantics_96;
13494 break;
13495 }
13496 break;
13497 case 0xc0:
13498 GETBYTE ();
13499 switch (op[2] & 0x00)
13500 {
13501 case 0x00:
13502 op_semantics_97:
13503 {
13504 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
13505 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13506 int sz AU = (op[1] >> 4) & 0x03;
13507 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13508 int isrc AU = op[1] & 0x0f;
13509 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13510 int bsrc AU = (op[2] >> 4) & 0x0f;
13511 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13512 int rdst AU = op[2] & 0x0f;
13513 if (trace)
13514 {
13515 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13516 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13517 op[0], op[1], op[2]);
13518 printf (" sz = 0x%x,", sz);
13519 printf (" isrc = 0x%x,", isrc);
13520 printf (" bsrc = 0x%x,", bsrc);
13521 printf (" rdst = 0x%x\n", rdst);
13522 }
13523 SYNTAX("movu%s [%1, %2], %0");
13524 #line 321 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13525 ID(movbi); uBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13526
13527 }
13528 break;
13529 }
13530 break;
13531 case 0xc1:
13532 GETBYTE ();
13533 switch (op[2] & 0x00)
13534 {
13535 case 0x00:
13536 goto op_semantics_97;
13537 break;
13538 }
13539 break;
13540 case 0xc2:
13541 GETBYTE ();
13542 switch (op[2] & 0x00)
13543 {
13544 case 0x00:
13545 goto op_semantics_97;
13546 break;
13547 }
13548 break;
13549 case 0xc3:
13550 GETBYTE ();
13551 switch (op[2] & 0x00)
13552 {
13553 case 0x00:
13554 goto op_semantics_97;
13555 break;
13556 }
13557 break;
13558 case 0xc4:
13559 GETBYTE ();
13560 switch (op[2] & 0x00)
13561 {
13562 case 0x00:
13563 goto op_semantics_97;
13564 break;
13565 }
13566 break;
13567 case 0xc5:
13568 GETBYTE ();
13569 switch (op[2] & 0x00)
13570 {
13571 case 0x00:
13572 goto op_semantics_97;
13573 break;
13574 }
13575 break;
13576 case 0xc6:
13577 GETBYTE ();
13578 switch (op[2] & 0x00)
13579 {
13580 case 0x00:
13581 goto op_semantics_97;
13582 break;
13583 }
13584 break;
13585 case 0xc7:
13586 GETBYTE ();
13587 switch (op[2] & 0x00)
13588 {
13589 case 0x00:
13590 goto op_semantics_97;
13591 break;
13592 }
13593 break;
13594 case 0xc8:
13595 GETBYTE ();
13596 switch (op[2] & 0x00)
13597 {
13598 case 0x00:
13599 goto op_semantics_97;
13600 break;
13601 }
13602 break;
13603 case 0xc9:
13604 GETBYTE ();
13605 switch (op[2] & 0x00)
13606 {
13607 case 0x00:
13608 goto op_semantics_97;
13609 break;
13610 }
13611 break;
13612 case 0xca:
13613 GETBYTE ();
13614 switch (op[2] & 0x00)
13615 {
13616 case 0x00:
13617 goto op_semantics_97;
13618 break;
13619 }
13620 break;
13621 case 0xcb:
13622 GETBYTE ();
13623 switch (op[2] & 0x00)
13624 {
13625 case 0x00:
13626 goto op_semantics_97;
13627 break;
13628 }
13629 break;
13630 case 0xcc:
13631 GETBYTE ();
13632 switch (op[2] & 0x00)
13633 {
13634 case 0x00:
13635 goto op_semantics_97;
13636 break;
13637 }
13638 break;
13639 case 0xcd:
13640 GETBYTE ();
13641 switch (op[2] & 0x00)
13642 {
13643 case 0x00:
13644 goto op_semantics_97;
13645 break;
13646 }
13647 break;
13648 case 0xce:
13649 GETBYTE ();
13650 switch (op[2] & 0x00)
13651 {
13652 case 0x00:
13653 goto op_semantics_97;
13654 break;
13655 }
13656 break;
13657 case 0xcf:
13658 GETBYTE ();
13659 switch (op[2] & 0x00)
13660 {
13661 case 0x00:
13662 goto op_semantics_97;
13663 break;
13664 }
13665 break;
13666 case 0xd0:
13667 GETBYTE ();
13668 switch (op[2] & 0x00)
13669 {
13670 case 0x00:
13671 goto op_semantics_97;
13672 break;
13673 }
13674 break;
13675 case 0xd1:
13676 GETBYTE ();
13677 switch (op[2] & 0x00)
13678 {
13679 case 0x00:
13680 goto op_semantics_97;
13681 break;
13682 }
13683 break;
13684 case 0xd2:
13685 GETBYTE ();
13686 switch (op[2] & 0x00)
13687 {
13688 case 0x00:
13689 goto op_semantics_97;
13690 break;
13691 }
13692 break;
13693 case 0xd3:
13694 GETBYTE ();
13695 switch (op[2] & 0x00)
13696 {
13697 case 0x00:
13698 goto op_semantics_97;
13699 break;
13700 }
13701 break;
13702 case 0xd4:
13703 GETBYTE ();
13704 switch (op[2] & 0x00)
13705 {
13706 case 0x00:
13707 goto op_semantics_97;
13708 break;
13709 }
13710 break;
13711 case 0xd5:
13712 GETBYTE ();
13713 switch (op[2] & 0x00)
13714 {
13715 case 0x00:
13716 goto op_semantics_97;
13717 break;
13718 }
13719 break;
13720 case 0xd6:
13721 GETBYTE ();
13722 switch (op[2] & 0x00)
13723 {
13724 case 0x00:
13725 goto op_semantics_97;
13726 break;
13727 }
13728 break;
13729 case 0xd7:
13730 GETBYTE ();
13731 switch (op[2] & 0x00)
13732 {
13733 case 0x00:
13734 goto op_semantics_97;
13735 break;
13736 }
13737 break;
13738 case 0xd8:
13739 GETBYTE ();
13740 switch (op[2] & 0x00)
13741 {
13742 case 0x00:
13743 goto op_semantics_97;
13744 break;
13745 }
13746 break;
13747 case 0xd9:
13748 GETBYTE ();
13749 switch (op[2] & 0x00)
13750 {
13751 case 0x00:
13752 goto op_semantics_97;
13753 break;
13754 }
13755 break;
13756 case 0xda:
13757 GETBYTE ();
13758 switch (op[2] & 0x00)
13759 {
13760 case 0x00:
13761 goto op_semantics_97;
13762 break;
13763 }
13764 break;
13765 case 0xdb:
13766 GETBYTE ();
13767 switch (op[2] & 0x00)
13768 {
13769 case 0x00:
13770 goto op_semantics_97;
13771 break;
13772 }
13773 break;
13774 case 0xdc:
13775 GETBYTE ();
13776 switch (op[2] & 0x00)
13777 {
13778 case 0x00:
13779 goto op_semantics_97;
13780 break;
13781 }
13782 break;
13783 case 0xdd:
13784 GETBYTE ();
13785 switch (op[2] & 0x00)
13786 {
13787 case 0x00:
13788 goto op_semantics_97;
13789 break;
13790 }
13791 break;
13792 case 0xde:
13793 GETBYTE ();
13794 switch (op[2] & 0x00)
13795 {
13796 case 0x00:
13797 goto op_semantics_97;
13798 break;
13799 }
13800 break;
13801 case 0xdf:
13802 GETBYTE ();
13803 switch (op[2] & 0x00)
13804 {
13805 case 0x00:
13806 goto op_semantics_97;
13807 break;
13808 }
13809 break;
13810 case 0xe0:
13811 GETBYTE ();
13812 switch (op[2] & 0x00)
13813 {
13814 case 0x00:
13815 goto op_semantics_97;
13816 break;
13817 }
13818 break;
13819 case 0xe1:
13820 GETBYTE ();
13821 switch (op[2] & 0x00)
13822 {
13823 case 0x00:
13824 goto op_semantics_97;
13825 break;
13826 }
13827 break;
13828 case 0xe2:
13829 GETBYTE ();
13830 switch (op[2] & 0x00)
13831 {
13832 case 0x00:
13833 goto op_semantics_97;
13834 break;
13835 }
13836 break;
13837 case 0xe3:
13838 GETBYTE ();
13839 switch (op[2] & 0x00)
13840 {
13841 case 0x00:
13842 goto op_semantics_97;
13843 break;
13844 }
13845 break;
13846 case 0xe4:
13847 GETBYTE ();
13848 switch (op[2] & 0x00)
13849 {
13850 case 0x00:
13851 goto op_semantics_97;
13852 break;
13853 }
13854 break;
13855 case 0xe5:
13856 GETBYTE ();
13857 switch (op[2] & 0x00)
13858 {
13859 case 0x00:
13860 goto op_semantics_97;
13861 break;
13862 }
13863 break;
13864 case 0xe6:
13865 GETBYTE ();
13866 switch (op[2] & 0x00)
13867 {
13868 case 0x00:
13869 goto op_semantics_97;
13870 break;
13871 }
13872 break;
13873 case 0xe7:
13874 GETBYTE ();
13875 switch (op[2] & 0x00)
13876 {
13877 case 0x00:
13878 goto op_semantics_97;
13879 break;
13880 }
13881 break;
13882 case 0xe8:
13883 GETBYTE ();
13884 switch (op[2] & 0x00)
13885 {
13886 case 0x00:
13887 goto op_semantics_97;
13888 break;
13889 }
13890 break;
13891 case 0xe9:
13892 GETBYTE ();
13893 switch (op[2] & 0x00)
13894 {
13895 case 0x00:
13896 goto op_semantics_97;
13897 break;
13898 }
13899 break;
13900 case 0xea:
13901 GETBYTE ();
13902 switch (op[2] & 0x00)
13903 {
13904 case 0x00:
13905 goto op_semantics_97;
13906 break;
13907 }
13908 break;
13909 case 0xeb:
13910 GETBYTE ();
13911 switch (op[2] & 0x00)
13912 {
13913 case 0x00:
13914 goto op_semantics_97;
13915 break;
13916 }
13917 break;
13918 case 0xec:
13919 GETBYTE ();
13920 switch (op[2] & 0x00)
13921 {
13922 case 0x00:
13923 goto op_semantics_97;
13924 break;
13925 }
13926 break;
13927 case 0xed:
13928 GETBYTE ();
13929 switch (op[2] & 0x00)
13930 {
13931 case 0x00:
13932 goto op_semantics_97;
13933 break;
13934 }
13935 break;
13936 case 0xee:
13937 GETBYTE ();
13938 switch (op[2] & 0x00)
13939 {
13940 case 0x00:
13941 goto op_semantics_97;
13942 break;
13943 }
13944 break;
13945 case 0xef:
13946 GETBYTE ();
13947 switch (op[2] & 0x00)
13948 {
13949 case 0x00:
13950 goto op_semantics_97;
13951 break;
13952 }
13953 break;
13954 default: UNSUPPORTED(); break;
13955 }
13956 break;
13957 case 0xff:
13958 GETBYTE ();
13959 switch (op[1] & 0xff)
13960 {
13961 case 0x00:
13962 GETBYTE ();
13963 switch (op[2] & 0x00)
13964 {
13965 case 0x00:
13966 op_semantics_98:
13967 {
13968 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
13969 #line 524 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13970 int rdst AU = op[1] & 0x0f;
13971 #line 524 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13972 int srca AU = (op[2] >> 4) & 0x0f;
13973 #line 524 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13974 int srcb AU = op[2] & 0x0f;
13975 if (trace)
13976 {
13977 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13978 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
13979 op[0], op[1], op[2]);
13980 printf (" rdst = 0x%x,", rdst);
13981 printf (" srca = 0x%x,", srca);
13982 printf (" srcb = 0x%x\n", srcb);
13983 }
13984 SYNTAX("sub %2, %1, %0");
13985 #line 525 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13986 ID(sub); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
13987
13988 /*----------------------------------------------------------------------*/
13989 /* SBB */
13990
13991 }
13992 break;
13993 }
13994 break;
13995 case 0x01:
13996 GETBYTE ();
13997 switch (op[2] & 0x00)
13998 {
13999 case 0x00:
14000 goto op_semantics_98;
14001 break;
14002 }
14003 break;
14004 case 0x02:
14005 GETBYTE ();
14006 switch (op[2] & 0x00)
14007 {
14008 case 0x00:
14009 goto op_semantics_98;
14010 break;
14011 }
14012 break;
14013 case 0x03:
14014 GETBYTE ();
14015 switch (op[2] & 0x00)
14016 {
14017 case 0x00:
14018 goto op_semantics_98;
14019 break;
14020 }
14021 break;
14022 case 0x04:
14023 GETBYTE ();
14024 switch (op[2] & 0x00)
14025 {
14026 case 0x00:
14027 goto op_semantics_98;
14028 break;
14029 }
14030 break;
14031 case 0x05:
14032 GETBYTE ();
14033 switch (op[2] & 0x00)
14034 {
14035 case 0x00:
14036 goto op_semantics_98;
14037 break;
14038 }
14039 break;
14040 case 0x06:
14041 GETBYTE ();
14042 switch (op[2] & 0x00)
14043 {
14044 case 0x00:
14045 goto op_semantics_98;
14046 break;
14047 }
14048 break;
14049 case 0x07:
14050 GETBYTE ();
14051 switch (op[2] & 0x00)
14052 {
14053 case 0x00:
14054 goto op_semantics_98;
14055 break;
14056 }
14057 break;
14058 case 0x08:
14059 GETBYTE ();
14060 switch (op[2] & 0x00)
14061 {
14062 case 0x00:
14063 goto op_semantics_98;
14064 break;
14065 }
14066 break;
14067 case 0x09:
14068 GETBYTE ();
14069 switch (op[2] & 0x00)
14070 {
14071 case 0x00:
14072 goto op_semantics_98;
14073 break;
14074 }
14075 break;
14076 case 0x0a:
14077 GETBYTE ();
14078 switch (op[2] & 0x00)
14079 {
14080 case 0x00:
14081 goto op_semantics_98;
14082 break;
14083 }
14084 break;
14085 case 0x0b:
14086 GETBYTE ();
14087 switch (op[2] & 0x00)
14088 {
14089 case 0x00:
14090 goto op_semantics_98;
14091 break;
14092 }
14093 break;
14094 case 0x0c:
14095 GETBYTE ();
14096 switch (op[2] & 0x00)
14097 {
14098 case 0x00:
14099 goto op_semantics_98;
14100 break;
14101 }
14102 break;
14103 case 0x0d:
14104 GETBYTE ();
14105 switch (op[2] & 0x00)
14106 {
14107 case 0x00:
14108 goto op_semantics_98;
14109 break;
14110 }
14111 break;
14112 case 0x0e:
14113 GETBYTE ();
14114 switch (op[2] & 0x00)
14115 {
14116 case 0x00:
14117 goto op_semantics_98;
14118 break;
14119 }
14120 break;
14121 case 0x0f:
14122 GETBYTE ();
14123 switch (op[2] & 0x00)
14124 {
14125 case 0x00:
14126 goto op_semantics_98;
14127 break;
14128 }
14129 break;
14130 case 0x20:
14131 GETBYTE ();
14132 switch (op[2] & 0x00)
14133 {
14134 case 0x00:
14135 op_semantics_99:
14136 {
14137 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
14138 #line 491 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14139 int rdst AU = op[1] & 0x0f;
14140 #line 491 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14141 int srca AU = (op[2] >> 4) & 0x0f;
14142 #line 491 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14143 int srcb AU = op[2] & 0x0f;
14144 if (trace)
14145 {
14146 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14147 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14148 op[0], op[1], op[2]);
14149 printf (" rdst = 0x%x,", rdst);
14150 printf (" srca = 0x%x,", srca);
14151 printf (" srcb = 0x%x\n", srcb);
14152 }
14153 SYNTAX("add %2, %1, %0");
14154 #line 492 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14155 ID(add); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14156
14157 /*----------------------------------------------------------------------*/
14158 /* CMP */
14159
14160 }
14161 break;
14162 }
14163 break;
14164 case 0x21:
14165 GETBYTE ();
14166 switch (op[2] & 0x00)
14167 {
14168 case 0x00:
14169 goto op_semantics_99;
14170 break;
14171 }
14172 break;
14173 case 0x22:
14174 GETBYTE ();
14175 switch (op[2] & 0x00)
14176 {
14177 case 0x00:
14178 goto op_semantics_99;
14179 break;
14180 }
14181 break;
14182 case 0x23:
14183 GETBYTE ();
14184 switch (op[2] & 0x00)
14185 {
14186 case 0x00:
14187 goto op_semantics_99;
14188 break;
14189 }
14190 break;
14191 case 0x24:
14192 GETBYTE ();
14193 switch (op[2] & 0x00)
14194 {
14195 case 0x00:
14196 goto op_semantics_99;
14197 break;
14198 }
14199 break;
14200 case 0x25:
14201 GETBYTE ();
14202 switch (op[2] & 0x00)
14203 {
14204 case 0x00:
14205 goto op_semantics_99;
14206 break;
14207 }
14208 break;
14209 case 0x26:
14210 GETBYTE ();
14211 switch (op[2] & 0x00)
14212 {
14213 case 0x00:
14214 goto op_semantics_99;
14215 break;
14216 }
14217 break;
14218 case 0x27:
14219 GETBYTE ();
14220 switch (op[2] & 0x00)
14221 {
14222 case 0x00:
14223 goto op_semantics_99;
14224 break;
14225 }
14226 break;
14227 case 0x28:
14228 GETBYTE ();
14229 switch (op[2] & 0x00)
14230 {
14231 case 0x00:
14232 goto op_semantics_99;
14233 break;
14234 }
14235 break;
14236 case 0x29:
14237 GETBYTE ();
14238 switch (op[2] & 0x00)
14239 {
14240 case 0x00:
14241 goto op_semantics_99;
14242 break;
14243 }
14244 break;
14245 case 0x2a:
14246 GETBYTE ();
14247 switch (op[2] & 0x00)
14248 {
14249 case 0x00:
14250 goto op_semantics_99;
14251 break;
14252 }
14253 break;
14254 case 0x2b:
14255 GETBYTE ();
14256 switch (op[2] & 0x00)
14257 {
14258 case 0x00:
14259 goto op_semantics_99;
14260 break;
14261 }
14262 break;
14263 case 0x2c:
14264 GETBYTE ();
14265 switch (op[2] & 0x00)
14266 {
14267 case 0x00:
14268 goto op_semantics_99;
14269 break;
14270 }
14271 break;
14272 case 0x2d:
14273 GETBYTE ();
14274 switch (op[2] & 0x00)
14275 {
14276 case 0x00:
14277 goto op_semantics_99;
14278 break;
14279 }
14280 break;
14281 case 0x2e:
14282 GETBYTE ();
14283 switch (op[2] & 0x00)
14284 {
14285 case 0x00:
14286 goto op_semantics_99;
14287 break;
14288 }
14289 break;
14290 case 0x2f:
14291 GETBYTE ();
14292 switch (op[2] & 0x00)
14293 {
14294 case 0x00:
14295 goto op_semantics_99;
14296 break;
14297 }
14298 break;
14299 case 0x30:
14300 GETBYTE ();
14301 switch (op[2] & 0x00)
14302 {
14303 case 0x00:
14304 op_semantics_100:
14305 {
14306 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
14307 #line 585 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14308 int rdst AU = op[1] & 0x0f;
14309 #line 585 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14310 int srca AU = (op[2] >> 4) & 0x0f;
14311 #line 585 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14312 int srcb AU = op[2] & 0x0f;
14313 if (trace)
14314 {
14315 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14316 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14317 op[0], op[1], op[2]);
14318 printf (" rdst = 0x%x,", rdst);
14319 printf (" srca = 0x%x,", srca);
14320 printf (" srcb = 0x%x\n", srcb);
14321 }
14322 SYNTAX("mul %2, %1, %0");
14323 #line 586 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14324 ID(mul); DR(rdst); SR(srcb); S2R(srca); F("O---");
14325
14326 /*----------------------------------------------------------------------*/
14327 /* EMUL */
14328
14329 }
14330 break;
14331 }
14332 break;
14333 case 0x31:
14334 GETBYTE ();
14335 switch (op[2] & 0x00)
14336 {
14337 case 0x00:
14338 goto op_semantics_100;
14339 break;
14340 }
14341 break;
14342 case 0x32:
14343 GETBYTE ();
14344 switch (op[2] & 0x00)
14345 {
14346 case 0x00:
14347 goto op_semantics_100;
14348 break;
14349 }
14350 break;
14351 case 0x33:
14352 GETBYTE ();
14353 switch (op[2] & 0x00)
14354 {
14355 case 0x00:
14356 goto op_semantics_100;
14357 break;
14358 }
14359 break;
14360 case 0x34:
14361 GETBYTE ();
14362 switch (op[2] & 0x00)
14363 {
14364 case 0x00:
14365 goto op_semantics_100;
14366 break;
14367 }
14368 break;
14369 case 0x35:
14370 GETBYTE ();
14371 switch (op[2] & 0x00)
14372 {
14373 case 0x00:
14374 goto op_semantics_100;
14375 break;
14376 }
14377 break;
14378 case 0x36:
14379 GETBYTE ();
14380 switch (op[2] & 0x00)
14381 {
14382 case 0x00:
14383 goto op_semantics_100;
14384 break;
14385 }
14386 break;
14387 case 0x37:
14388 GETBYTE ();
14389 switch (op[2] & 0x00)
14390 {
14391 case 0x00:
14392 goto op_semantics_100;
14393 break;
14394 }
14395 break;
14396 case 0x38:
14397 GETBYTE ();
14398 switch (op[2] & 0x00)
14399 {
14400 case 0x00:
14401 goto op_semantics_100;
14402 break;
14403 }
14404 break;
14405 case 0x39:
14406 GETBYTE ();
14407 switch (op[2] & 0x00)
14408 {
14409 case 0x00:
14410 goto op_semantics_100;
14411 break;
14412 }
14413 break;
14414 case 0x3a:
14415 GETBYTE ();
14416 switch (op[2] & 0x00)
14417 {
14418 case 0x00:
14419 goto op_semantics_100;
14420 break;
14421 }
14422 break;
14423 case 0x3b:
14424 GETBYTE ();
14425 switch (op[2] & 0x00)
14426 {
14427 case 0x00:
14428 goto op_semantics_100;
14429 break;
14430 }
14431 break;
14432 case 0x3c:
14433 GETBYTE ();
14434 switch (op[2] & 0x00)
14435 {
14436 case 0x00:
14437 goto op_semantics_100;
14438 break;
14439 }
14440 break;
14441 case 0x3d:
14442 GETBYTE ();
14443 switch (op[2] & 0x00)
14444 {
14445 case 0x00:
14446 goto op_semantics_100;
14447 break;
14448 }
14449 break;
14450 case 0x3e:
14451 GETBYTE ();
14452 switch (op[2] & 0x00)
14453 {
14454 case 0x00:
14455 goto op_semantics_100;
14456 break;
14457 }
14458 break;
14459 case 0x3f:
14460 GETBYTE ();
14461 switch (op[2] & 0x00)
14462 {
14463 case 0x00:
14464 goto op_semantics_100;
14465 break;
14466 }
14467 break;
14468 case 0x40:
14469 GETBYTE ();
14470 switch (op[2] & 0x00)
14471 {
14472 case 0x00:
14473 op_semantics_101:
14474 {
14475 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
14476 #line 401 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14477 int rdst AU = op[1] & 0x0f;
14478 #line 401 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14479 int srca AU = (op[2] >> 4) & 0x0f;
14480 #line 401 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14481 int srcb AU = op[2] & 0x0f;
14482 if (trace)
14483 {
14484 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14485 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14486 op[0], op[1], op[2]);
14487 printf (" rdst = 0x%x,", rdst);
14488 printf (" srca = 0x%x,", srca);
14489 printf (" srcb = 0x%x\n", srcb);
14490 }
14491 SYNTAX("and %2, %1, %0");
14492 #line 402 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14493 ID(and); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14494
14495 /*----------------------------------------------------------------------*/
14496 /* OR */
14497
14498 }
14499 break;
14500 }
14501 break;
14502 case 0x41:
14503 GETBYTE ();
14504 switch (op[2] & 0x00)
14505 {
14506 case 0x00:
14507 goto op_semantics_101;
14508 break;
14509 }
14510 break;
14511 case 0x42:
14512 GETBYTE ();
14513 switch (op[2] & 0x00)
14514 {
14515 case 0x00:
14516 goto op_semantics_101;
14517 break;
14518 }
14519 break;
14520 case 0x43:
14521 GETBYTE ();
14522 switch (op[2] & 0x00)
14523 {
14524 case 0x00:
14525 goto op_semantics_101;
14526 break;
14527 }
14528 break;
14529 case 0x44:
14530 GETBYTE ();
14531 switch (op[2] & 0x00)
14532 {
14533 case 0x00:
14534 goto op_semantics_101;
14535 break;
14536 }
14537 break;
14538 case 0x45:
14539 GETBYTE ();
14540 switch (op[2] & 0x00)
14541 {
14542 case 0x00:
14543 goto op_semantics_101;
14544 break;
14545 }
14546 break;
14547 case 0x46:
14548 GETBYTE ();
14549 switch (op[2] & 0x00)
14550 {
14551 case 0x00:
14552 goto op_semantics_101;
14553 break;
14554 }
14555 break;
14556 case 0x47:
14557 GETBYTE ();
14558 switch (op[2] & 0x00)
14559 {
14560 case 0x00:
14561 goto op_semantics_101;
14562 break;
14563 }
14564 break;
14565 case 0x48:
14566 GETBYTE ();
14567 switch (op[2] & 0x00)
14568 {
14569 case 0x00:
14570 goto op_semantics_101;
14571 break;
14572 }
14573 break;
14574 case 0x49:
14575 GETBYTE ();
14576 switch (op[2] & 0x00)
14577 {
14578 case 0x00:
14579 goto op_semantics_101;
14580 break;
14581 }
14582 break;
14583 case 0x4a:
14584 GETBYTE ();
14585 switch (op[2] & 0x00)
14586 {
14587 case 0x00:
14588 goto op_semantics_101;
14589 break;
14590 }
14591 break;
14592 case 0x4b:
14593 GETBYTE ();
14594 switch (op[2] & 0x00)
14595 {
14596 case 0x00:
14597 goto op_semantics_101;
14598 break;
14599 }
14600 break;
14601 case 0x4c:
14602 GETBYTE ();
14603 switch (op[2] & 0x00)
14604 {
14605 case 0x00:
14606 goto op_semantics_101;
14607 break;
14608 }
14609 break;
14610 case 0x4d:
14611 GETBYTE ();
14612 switch (op[2] & 0x00)
14613 {
14614 case 0x00:
14615 goto op_semantics_101;
14616 break;
14617 }
14618 break;
14619 case 0x4e:
14620 GETBYTE ();
14621 switch (op[2] & 0x00)
14622 {
14623 case 0x00:
14624 goto op_semantics_101;
14625 break;
14626 }
14627 break;
14628 case 0x4f:
14629 GETBYTE ();
14630 switch (op[2] & 0x00)
14631 {
14632 case 0x00:
14633 goto op_semantics_101;
14634 break;
14635 }
14636 break;
14637 case 0x50:
14638 GETBYTE ();
14639 switch (op[2] & 0x00)
14640 {
14641 case 0x00:
14642 op_semantics_102:
14643 {
14644 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
14645 #line 419 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14646 int rdst AU = op[1] & 0x0f;
14647 #line 419 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14648 int srca AU = (op[2] >> 4) & 0x0f;
14649 #line 419 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14650 int srcb AU = op[2] & 0x0f;
14651 if (trace)
14652 {
14653 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14654 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14655 op[0], op[1], op[2]);
14656 printf (" rdst = 0x%x,", rdst);
14657 printf (" srca = 0x%x,", srca);
14658 printf (" srcb = 0x%x\n", srcb);
14659 }
14660 SYNTAX("or %2, %1, %0");
14661 #line 420 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14662 ID(or); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14663
14664 /*----------------------------------------------------------------------*/
14665 /* XOR */
14666
14667 }
14668 break;
14669 }
14670 break;
14671 case 0x51:
14672 GETBYTE ();
14673 switch (op[2] & 0x00)
14674 {
14675 case 0x00:
14676 goto op_semantics_102;
14677 break;
14678 }
14679 break;
14680 case 0x52:
14681 GETBYTE ();
14682 switch (op[2] & 0x00)
14683 {
14684 case 0x00:
14685 goto op_semantics_102;
14686 break;
14687 }
14688 break;
14689 case 0x53:
14690 GETBYTE ();
14691 switch (op[2] & 0x00)
14692 {
14693 case 0x00:
14694 goto op_semantics_102;
14695 break;
14696 }
14697 break;
14698 case 0x54:
14699 GETBYTE ();
14700 switch (op[2] & 0x00)
14701 {
14702 case 0x00:
14703 goto op_semantics_102;
14704 break;
14705 }
14706 break;
14707 case 0x55:
14708 GETBYTE ();
14709 switch (op[2] & 0x00)
14710 {
14711 case 0x00:
14712 goto op_semantics_102;
14713 break;
14714 }
14715 break;
14716 case 0x56:
14717 GETBYTE ();
14718 switch (op[2] & 0x00)
14719 {
14720 case 0x00:
14721 goto op_semantics_102;
14722 break;
14723 }
14724 break;
14725 case 0x57:
14726 GETBYTE ();
14727 switch (op[2] & 0x00)
14728 {
14729 case 0x00:
14730 goto op_semantics_102;
14731 break;
14732 }
14733 break;
14734 case 0x58:
14735 GETBYTE ();
14736 switch (op[2] & 0x00)
14737 {
14738 case 0x00:
14739 goto op_semantics_102;
14740 break;
14741 }
14742 break;
14743 case 0x59:
14744 GETBYTE ();
14745 switch (op[2] & 0x00)
14746 {
14747 case 0x00:
14748 goto op_semantics_102;
14749 break;
14750 }
14751 break;
14752 case 0x5a:
14753 GETBYTE ();
14754 switch (op[2] & 0x00)
14755 {
14756 case 0x00:
14757 goto op_semantics_102;
14758 break;
14759 }
14760 break;
14761 case 0x5b:
14762 GETBYTE ();
14763 switch (op[2] & 0x00)
14764 {
14765 case 0x00:
14766 goto op_semantics_102;
14767 break;
14768 }
14769 break;
14770 case 0x5c:
14771 GETBYTE ();
14772 switch (op[2] & 0x00)
14773 {
14774 case 0x00:
14775 goto op_semantics_102;
14776 break;
14777 }
14778 break;
14779 case 0x5d:
14780 GETBYTE ();
14781 switch (op[2] & 0x00)
14782 {
14783 case 0x00:
14784 goto op_semantics_102;
14785 break;
14786 }
14787 break;
14788 case 0x5e:
14789 GETBYTE ();
14790 switch (op[2] & 0x00)
14791 {
14792 case 0x00:
14793 goto op_semantics_102;
14794 break;
14795 }
14796 break;
14797 case 0x5f:
14798 GETBYTE ();
14799 switch (op[2] & 0x00)
14800 {
14801 case 0x00:
14802 goto op_semantics_102;
14803 break;
14804 }
14805 break;
14806 default: UNSUPPORTED(); break;
14807 }
14808 break;
14809 default: UNSUPPORTED(); break;
14810 }
14811 #line 975 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14812
14813 return rx->n_bytes;
14814 }
GDB Binutils - Deliverables
This page took 0.455204 seconds and 5 git commands to generate.