OSDN -- 开发和下载开源软件
简体中文翻译状态 translation status for zh
  • R/O
  • HTTP
  • SSH
  • HTTPS
Fork

提交

标签
No Tags

Frequently used words (click to add to your profile)

javac++androidlinuxc#windowsobjective-ccocoa誰得qtpythonphprubygameguibathyscaphec計画中(planning stage)翻訳omegatframeworktwitterdomtestvb.netdirectxゲームエンジンbtronarduinopreviewer

Commit MetaInfo

修订版77f5a59d60f17f356f134f90032d0c1b036fe197 (tree)
时间2018-12-19 21:49:07
作者Yoshinori Sato <ysato@user...>
CommiterYoshinori Sato

Log Message

RXv3 instructions

更改概述

差异

--- a/include/opcode/rx.h
+++ b/include/opcode/rx.h
@@ -38,6 +38,7 @@ typedef enum
3838 RX_SWord,
3939 RX_3Byte,
4040 RX_Long,
41+ RX_Double,
4142 RX_Bad_Size,
4243 RX_MAX_SIZE
4344 } RX_Size;
@@ -54,6 +55,11 @@ typedef enum
5455 RX_Operand_Condition, /* eq, gtu, etc */
5556 RX_Operand_Flag, /* [UIOSZC] */
5657 RX_Operand_TwoReg, /* [Rn + scale*R2] */
58+ RX_Operand_DoubleReg, /* DRn */
59+ RX_Operand_DoubleRegH,/* DRHn */
60+ RX_Operand_DoubleRegL,/* DRLn */
61+ RX_Operand_DoubleCReg,/* DCRxx */
62+ RX_Operand_DoubleCond,/* UN/EQ/LE/LT */
5763 } RX_Operand_Type;
5864
5965 typedef enum
@@ -180,6 +186,32 @@ typedef enum
180186 RXO_racl,
181187 RXO_rdacl,
182188 RXO_rdacw,
189+
190+ RXO_bfmov,
191+ RXO_bfmovz,
192+ RXO_rstr,
193+ RXO_save,
194+ RXO_dmov,
195+ RXO_dpopm,
196+ RXO_dpushm,
197+ RXO_mvfdc,
198+ RXO_mvfdr,
199+ RXO_mvtdc,
200+ RXO_dabs,
201+ RXO_dadd,
202+ RXO_dcmp,
203+ RXO_ddiv,
204+ RXO_dmul,
205+ RXO_dneg,
206+ RXO_dround,
207+ RXO_dsqrt,
208+ RXO_dsub,
209+ RXO_dtoi,
210+ RXO_dtof,
211+ RXO_dtou,
212+ RXO_ftod,
213+ RXO_itod,
214+ RXO_utod
183215 } RX_Opcode_ID;
184216
185217 /* Condition bitpatterns, as registers. */
--- a/opcodes/rx-decode.c
+++ b/opcodes/rx-decode.c
@@ -45,6 +45,7 @@ static int trace = 0;
4545 #define BSIZE 0
4646 #define WSIZE 1
4747 #define LSIZE 2
48+#define DSIZE 3
4849
4950 /* These are for when the upper bits are "don't care" or "undefined". */
5051 static int bwl[4] =
@@ -79,6 +80,12 @@ static int memex[4] =
7980 RX_UWord
8081 };
8182
83+static int _ld[2] =
84+{
85+ RX_Long,
86+ RX_Double
87+};
88+
8289 #define ID(x) rx->id = RXO_##x
8390 #define OP(n,t,r,a) (rx->op[n].type = t, \
8491 rx->op[n].reg = r, \
@@ -89,7 +96,7 @@ static int memex[4] =
8996 /* This is for the BWL and BW bitfields. */
9097 static int SCALE[] = { 1, 2, 4, 0 };
9198 /* This is for the prefix size enum. */
92-static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
99+static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4, 8 };
93100
94101 #define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
95102 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
@@ -115,6 +122,11 @@ static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
115122 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s))
116123 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld);
117124 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0)
125+#define DCR(r) OP (0, RX_Operand_DoubleCReg, r, 0)
126+#define DDR(r) OP (0, RX_Operand_DoubleReg, r, 0)
127+#define DDRH(r) OP (0, RX_Operand_DoubleRegH, r, 0)
128+#define DDRL(r) OP (0, RX_Operand_DoubleRegL, r, 0)
129+#define DCND(r) OP (0, RX_Operand_DoubleCond, r, 0)
118130
119131 #define SC(i) OP (1, RX_Operand_Immediate, 0, i)
120132 #define SR(r) OP (1, RX_Operand_Register, r, 0)
@@ -125,6 +137,10 @@ static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
125137 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
126138 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
127139 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0)
140+#define SCR(r) OP (1, RX_Operand_DoubleCReg, r, 0)
141+#define SDR(r) OP (1, RX_Operand_DoubleReg, r, 0)
142+#define SDRH(r) OP (1, RX_Operand_DoubleRegH, r, 0)
143+#define SDRL(r) OP (1, RX_Operand_DoubleRegL, r, 0)
128144
129145 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i)
130146 #define S2R(r) OP (2, RX_Operand_Register, r, 0)
@@ -134,11 +150,16 @@ static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
134150 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
135151 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
136152 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0)
153+#define S2DR(r) OP (2, RX_Operand_DoubleReg, r, 0)
154+#define S2CR(r) OP (2, RX_Operand_DoubleCReg, r, 0)
155+
156+#define SDD(t,r,s) rx_disp (1, t, r, bwl, ld);
137157
138158 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
139159 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
140160 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
141161 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
162+#define DL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz]
142163
143164 #define F(f) store_flags(rx, f)
144165
@@ -299,7 +320,7 @@ rx_decode_opcode (unsigned long pc AU,
299320 op[0]);
300321 }
301322 SYNTAX("brk");
302-#line 1029 "rx-decode.opc"
323+#line 1050 "rx-decode.opc"
303324 ID(brk);
304325
305326 }
@@ -314,7 +335,7 @@ rx_decode_opcode (unsigned long pc AU,
314335 op[0]);
315336 }
316337 SYNTAX("dbt");
317-#line 1032 "rx-decode.opc"
338+#line 1053 "rx-decode.opc"
318339 ID(dbt);
319340
320341 }
@@ -329,7 +350,7 @@ rx_decode_opcode (unsigned long pc AU,
329350 op[0]);
330351 }
331352 SYNTAX("rts");
332-#line 810 "rx-decode.opc"
353+#line 831 "rx-decode.opc"
333354 ID(rts);
334355
335356 /*----------------------------------------------------------------------*/
@@ -347,7 +368,7 @@ rx_decode_opcode (unsigned long pc AU,
347368 op[0]);
348369 }
349370 SYNTAX("nop");
350-#line 816 "rx-decode.opc"
371+#line 837 "rx-decode.opc"
351372 ID(nop);
352373
353374 /*----------------------------------------------------------------------*/
@@ -365,7 +386,7 @@ rx_decode_opcode (unsigned long pc AU,
365386 op[0]);
366387 }
367388 SYNTAX("bra.a %a0");
368-#line 788 "rx-decode.opc"
389+#line 809 "rx-decode.opc"
369390 ID(branch); DC(pc + IMMex(3));
370391
371392 }
@@ -380,7 +401,7 @@ rx_decode_opcode (unsigned long pc AU,
380401 op[0]);
381402 }
382403 SYNTAX("bsr.a %a0");
383-#line 804 "rx-decode.opc"
404+#line 825 "rx-decode.opc"
384405 ID(jsr); DC(pc + IMMex(3));
385406
386407 }
@@ -397,13 +418,13 @@ rx_decode_opcode (unsigned long pc AU,
397418 op_semantics_1:
398419 {
399420 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
400-#line 546 "rx-decode.opc"
421+#line 567 "rx-decode.opc"
401422 int mx AU = (op[1] >> 6) & 0x03;
402-#line 546 "rx-decode.opc"
423+#line 567 "rx-decode.opc"
403424 int ss AU = op[1] & 0x03;
404-#line 546 "rx-decode.opc"
425+#line 567 "rx-decode.opc"
405426 int rsrc AU = (op[2] >> 4) & 0x0f;
406-#line 546 "rx-decode.opc"
427+#line 567 "rx-decode.opc"
407428 int rdst AU = op[2] & 0x0f;
408429 if (trace)
409430 {
@@ -416,7 +437,7 @@ rx_decode_opcode (unsigned long pc AU,
416437 printf (" rdst = 0x%x\n", rdst);
417438 }
418439 SYNTAX("sub %2%S2, %1");
419-#line 546 "rx-decode.opc"
440+#line 567 "rx-decode.opc"
420441 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
421442
422443 }
@@ -458,13 +479,13 @@ rx_decode_opcode (unsigned long pc AU,
458479 op_semantics_2:
459480 {
460481 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */
461-#line 534 "rx-decode.opc"
482+#line 555 "rx-decode.opc"
462483 int mx AU = (op[1] >> 6) & 0x03;
463-#line 534 "rx-decode.opc"
484+#line 555 "rx-decode.opc"
464485 int ss AU = op[1] & 0x03;
465-#line 534 "rx-decode.opc"
486+#line 555 "rx-decode.opc"
466487 int rsrc AU = (op[2] >> 4) & 0x0f;
467-#line 534 "rx-decode.opc"
488+#line 555 "rx-decode.opc"
468489 int rdst AU = op[2] & 0x0f;
469490 if (trace)
470491 {
@@ -477,7 +498,7 @@ rx_decode_opcode (unsigned long pc AU,
477498 printf (" rdst = 0x%x\n", rdst);
478499 }
479500 SYNTAX("cmp %2%S2, %1");
480-#line 534 "rx-decode.opc"
501+#line 555 "rx-decode.opc"
481502 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
482503
483504 /*----------------------------------------------------------------------*/
@@ -522,13 +543,13 @@ rx_decode_opcode (unsigned long pc AU,
522543 op_semantics_3:
523544 {
524545 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
525-#line 510 "rx-decode.opc"
546+#line 531 "rx-decode.opc"
526547 int mx AU = (op[1] >> 6) & 0x03;
527-#line 510 "rx-decode.opc"
548+#line 531 "rx-decode.opc"
528549 int ss AU = op[1] & 0x03;
529-#line 510 "rx-decode.opc"
550+#line 531 "rx-decode.opc"
530551 int rsrc AU = (op[2] >> 4) & 0x0f;
531-#line 510 "rx-decode.opc"
552+#line 531 "rx-decode.opc"
532553 int rdst AU = op[2] & 0x0f;
533554 if (trace)
534555 {
@@ -541,7 +562,7 @@ rx_decode_opcode (unsigned long pc AU,
541562 printf (" rdst = 0x%x\n", rdst);
542563 }
543564 SYNTAX("add %1%S1, %0");
544-#line 510 "rx-decode.opc"
565+#line 531 "rx-decode.opc"
545566 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
546567
547568 }
@@ -583,13 +604,13 @@ rx_decode_opcode (unsigned long pc AU,
583604 op_semantics_4:
584605 {
585606 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
586-#line 653 "rx-decode.opc"
607+#line 674 "rx-decode.opc"
587608 int mx AU = (op[1] >> 6) & 0x03;
588-#line 653 "rx-decode.opc"
609+#line 674 "rx-decode.opc"
589610 int ss AU = op[1] & 0x03;
590-#line 653 "rx-decode.opc"
611+#line 674 "rx-decode.opc"
591612 int rsrc AU = (op[2] >> 4) & 0x0f;
592-#line 653 "rx-decode.opc"
613+#line 674 "rx-decode.opc"
593614 int rdst AU = op[2] & 0x0f;
594615 if (trace)
595616 {
@@ -602,7 +623,7 @@ rx_decode_opcode (unsigned long pc AU,
602623 printf (" rdst = 0x%x\n", rdst);
603624 }
604625 SYNTAX("mul %1%S1, %0");
605-#line 653 "rx-decode.opc"
626+#line 674 "rx-decode.opc"
606627 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
607628
608629 }
@@ -644,13 +665,13 @@ rx_decode_opcode (unsigned long pc AU,
644665 op_semantics_5:
645666 {
646667 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
647-#line 423 "rx-decode.opc"
668+#line 444 "rx-decode.opc"
648669 int mx AU = (op[1] >> 6) & 0x03;
649-#line 423 "rx-decode.opc"
670+#line 444 "rx-decode.opc"
650671 int ss AU = op[1] & 0x03;
651-#line 423 "rx-decode.opc"
672+#line 444 "rx-decode.opc"
652673 int rsrc AU = (op[2] >> 4) & 0x0f;
653-#line 423 "rx-decode.opc"
674+#line 444 "rx-decode.opc"
654675 int rdst AU = op[2] & 0x0f;
655676 if (trace)
656677 {
@@ -663,7 +684,7 @@ rx_decode_opcode (unsigned long pc AU,
663684 printf (" rdst = 0x%x\n", rdst);
664685 }
665686 SYNTAX("and %1%S1, %0");
666-#line 423 "rx-decode.opc"
687+#line 444 "rx-decode.opc"
667688 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
668689
669690 }
@@ -705,13 +726,13 @@ rx_decode_opcode (unsigned long pc AU,
705726 op_semantics_6:
706727 {
707728 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
708-#line 441 "rx-decode.opc"
729+#line 462 "rx-decode.opc"
709730 int mx AU = (op[1] >> 6) & 0x03;
710-#line 441 "rx-decode.opc"
731+#line 462 "rx-decode.opc"
711732 int ss AU = op[1] & 0x03;
712-#line 441 "rx-decode.opc"
733+#line 462 "rx-decode.opc"
713734 int rsrc AU = (op[2] >> 4) & 0x0f;
714-#line 441 "rx-decode.opc"
735+#line 462 "rx-decode.opc"
715736 int rdst AU = op[2] & 0x0f;
716737 if (trace)
717738 {
@@ -724,7 +745,7 @@ rx_decode_opcode (unsigned long pc AU,
724745 printf (" rdst = 0x%x\n", rdst);
725746 }
726747 SYNTAX("or %1%S1, %0");
727-#line 441 "rx-decode.opc"
748+#line 462 "rx-decode.opc"
728749 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
729750
730751 }
@@ -770,13 +791,13 @@ rx_decode_opcode (unsigned long pc AU,
770791 op_semantics_7:
771792 {
772793 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
773-#line 559 "rx-decode.opc"
794+#line 580 "rx-decode.opc"
774795 int mx AU = (op[1] >> 6) & 0x03;
775-#line 559 "rx-decode.opc"
796+#line 580 "rx-decode.opc"
776797 int sp AU = op[1] & 0x03;
777-#line 559 "rx-decode.opc"
798+#line 580 "rx-decode.opc"
778799 int rsrc AU = (op[3] >> 4) & 0x0f;
779-#line 559 "rx-decode.opc"
800+#line 580 "rx-decode.opc"
780801 int rdst AU = op[3] & 0x0f;
781802 if (trace)
782803 {
@@ -789,7 +810,7 @@ rx_decode_opcode (unsigned long pc AU,
789810 printf (" rdst = 0x%x\n", rdst);
790811 }
791812 SYNTAX("sbb %1%S1, %0");
792-#line 559 "rx-decode.opc"
813+#line 580 "rx-decode.opc"
793814 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
794815
795816 /*----------------------------------------------------------------------*/
@@ -807,13 +828,13 @@ rx_decode_opcode (unsigned long pc AU,
807828 op_semantics_8:
808829 {
809830 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
810-#line 598 "rx-decode.opc"
831+#line 619 "rx-decode.opc"
811832 int mx AU = (op[1] >> 6) & 0x03;
812-#line 598 "rx-decode.opc"
833+#line 619 "rx-decode.opc"
813834 int ss AU = op[1] & 0x03;
814-#line 598 "rx-decode.opc"
835+#line 619 "rx-decode.opc"
815836 int rsrc AU = (op[3] >> 4) & 0x0f;
816-#line 598 "rx-decode.opc"
837+#line 619 "rx-decode.opc"
817838 int rdst AU = op[3] & 0x0f;
818839 if (trace)
819840 {
@@ -826,7 +847,7 @@ rx_decode_opcode (unsigned long pc AU,
826847 printf (" rdst = 0x%x\n", rdst);
827848 }
828849 SYNTAX("max %1%S1, %0");
829-#line 598 "rx-decode.opc"
850+#line 619 "rx-decode.opc"
830851 ID(max); SPm(ss, rsrc, mx); DR(rdst);
831852
832853 /*----------------------------------------------------------------------*/
@@ -844,13 +865,13 @@ rx_decode_opcode (unsigned long pc AU,
844865 op_semantics_9:
845866 {
846867 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
847-#line 610 "rx-decode.opc"
868+#line 631 "rx-decode.opc"
848869 int mx AU = (op[1] >> 6) & 0x03;
849-#line 610 "rx-decode.opc"
870+#line 631 "rx-decode.opc"
850871 int ss AU = op[1] & 0x03;
851-#line 610 "rx-decode.opc"
872+#line 631 "rx-decode.opc"
852873 int rsrc AU = (op[3] >> 4) & 0x0f;
853-#line 610 "rx-decode.opc"
874+#line 631 "rx-decode.opc"
854875 int rdst AU = op[3] & 0x0f;
855876 if (trace)
856877 {
@@ -863,7 +884,7 @@ rx_decode_opcode (unsigned long pc AU,
863884 printf (" rdst = 0x%x\n", rdst);
864885 }
865886 SYNTAX("min %1%S1, %0");
866-#line 610 "rx-decode.opc"
887+#line 631 "rx-decode.opc"
867888 ID(min); SPm(ss, rsrc, mx); DR(rdst);
868889
869890 /*----------------------------------------------------------------------*/
@@ -881,13 +902,13 @@ rx_decode_opcode (unsigned long pc AU,
881902 op_semantics_10:
882903 {
883904 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
884-#line 668 "rx-decode.opc"
905+#line 689 "rx-decode.opc"
885906 int mx AU = (op[1] >> 6) & 0x03;
886-#line 668 "rx-decode.opc"
907+#line 689 "rx-decode.opc"
887908 int ss AU = op[1] & 0x03;
888-#line 668 "rx-decode.opc"
909+#line 689 "rx-decode.opc"
889910 int rsrc AU = (op[3] >> 4) & 0x0f;
890-#line 668 "rx-decode.opc"
911+#line 689 "rx-decode.opc"
891912 int rdst AU = op[3] & 0x0f;
892913 if (trace)
893914 {
@@ -900,7 +921,7 @@ rx_decode_opcode (unsigned long pc AU,
900921 printf (" rdst = 0x%x\n", rdst);
901922 }
902923 SYNTAX("emul %1%S1, %0");
903-#line 668 "rx-decode.opc"
924+#line 689 "rx-decode.opc"
904925 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
905926
906927 /*----------------------------------------------------------------------*/
@@ -918,13 +939,13 @@ rx_decode_opcode (unsigned long pc AU,
918939 op_semantics_11:
919940 {
920941 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
921-#line 680 "rx-decode.opc"
942+#line 701 "rx-decode.opc"
922943 int mx AU = (op[1] >> 6) & 0x03;
923-#line 680 "rx-decode.opc"
944+#line 701 "rx-decode.opc"
924945 int ss AU = op[1] & 0x03;
925-#line 680 "rx-decode.opc"
946+#line 701 "rx-decode.opc"
926947 int rsrc AU = (op[3] >> 4) & 0x0f;
927-#line 680 "rx-decode.opc"
948+#line 701 "rx-decode.opc"
928949 int rdst AU = op[3] & 0x0f;
929950 if (trace)
930951 {
@@ -937,7 +958,7 @@ rx_decode_opcode (unsigned long pc AU,
937958 printf (" rdst = 0x%x\n", rdst);
938959 }
939960 SYNTAX("emulu %1%S1, %0");
940-#line 680 "rx-decode.opc"
961+#line 701 "rx-decode.opc"
941962 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
942963
943964 /*----------------------------------------------------------------------*/
@@ -955,13 +976,13 @@ rx_decode_opcode (unsigned long pc AU,
955976 op_semantics_12:
956977 {
957978 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
958-#line 692 "rx-decode.opc"
979+#line 713 "rx-decode.opc"
959980 int mx AU = (op[1] >> 6) & 0x03;
960-#line 692 "rx-decode.opc"
981+#line 713 "rx-decode.opc"
961982 int ss AU = op[1] & 0x03;
962-#line 692 "rx-decode.opc"
983+#line 713 "rx-decode.opc"
963984 int rsrc AU = (op[3] >> 4) & 0x0f;
964-#line 692 "rx-decode.opc"
985+#line 713 "rx-decode.opc"
965986 int rdst AU = op[3] & 0x0f;
966987 if (trace)
967988 {
@@ -974,7 +995,7 @@ rx_decode_opcode (unsigned long pc AU,
974995 printf (" rdst = 0x%x\n", rdst);
975996 }
976997 SYNTAX("div %1%S1, %0");
977-#line 692 "rx-decode.opc"
998+#line 713 "rx-decode.opc"
978999 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
9791000
9801001 /*----------------------------------------------------------------------*/
@@ -992,13 +1013,13 @@ rx_decode_opcode (unsigned long pc AU,
9921013 op_semantics_13:
9931014 {
9941015 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
995-#line 704 "rx-decode.opc"
1016+#line 725 "rx-decode.opc"
9961017 int mx AU = (op[1] >> 6) & 0x03;
997-#line 704 "rx-decode.opc"
1018+#line 725 "rx-decode.opc"
9981019 int ss AU = op[1] & 0x03;
999-#line 704 "rx-decode.opc"
1020+#line 725 "rx-decode.opc"
10001021 int rsrc AU = (op[3] >> 4) & 0x0f;
1001-#line 704 "rx-decode.opc"
1022+#line 725 "rx-decode.opc"
10021023 int rdst AU = op[3] & 0x0f;
10031024 if (trace)
10041025 {
@@ -1011,7 +1032,7 @@ rx_decode_opcode (unsigned long pc AU,
10111032 printf (" rdst = 0x%x\n", rdst);
10121033 }
10131034 SYNTAX("divu %1%S1, %0");
1014-#line 704 "rx-decode.opc"
1035+#line 725 "rx-decode.opc"
10151036 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
10161037
10171038 /*----------------------------------------------------------------------*/
@@ -1029,13 +1050,13 @@ rx_decode_opcode (unsigned long pc AU,
10291050 op_semantics_14:
10301051 {
10311052 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1032-#line 477 "rx-decode.opc"
1053+#line 498 "rx-decode.opc"
10331054 int mx AU = (op[1] >> 6) & 0x03;
1034-#line 477 "rx-decode.opc"
1055+#line 498 "rx-decode.opc"
10351056 int ss AU = op[1] & 0x03;
1036-#line 477 "rx-decode.opc"
1057+#line 498 "rx-decode.opc"
10371058 int rsrc AU = (op[3] >> 4) & 0x0f;
1038-#line 477 "rx-decode.opc"
1059+#line 498 "rx-decode.opc"
10391060 int rdst AU = op[3] & 0x0f;
10401061 if (trace)
10411062 {
@@ -1048,7 +1069,7 @@ rx_decode_opcode (unsigned long pc AU,
10481069 printf (" rdst = 0x%x\n", rdst);
10491070 }
10501071 SYNTAX("tst %1%S1, %2");
1051-#line 477 "rx-decode.opc"
1072+#line 498 "rx-decode.opc"
10521073 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
10531074
10541075 /*----------------------------------------------------------------------*/
@@ -1066,13 +1087,13 @@ rx_decode_opcode (unsigned long pc AU,
10661087 op_semantics_15:
10671088 {
10681089 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1069-#line 456 "rx-decode.opc"
1090+#line 477 "rx-decode.opc"
10701091 int mx AU = (op[1] >> 6) & 0x03;
1071-#line 456 "rx-decode.opc"
1092+#line 477 "rx-decode.opc"
10721093 int ss AU = op[1] & 0x03;
1073-#line 456 "rx-decode.opc"
1094+#line 477 "rx-decode.opc"
10741095 int rsrc AU = (op[3] >> 4) & 0x0f;
1075-#line 456 "rx-decode.opc"
1096+#line 477 "rx-decode.opc"
10761097 int rdst AU = op[3] & 0x0f;
10771098 if (trace)
10781099 {
@@ -1085,7 +1106,7 @@ rx_decode_opcode (unsigned long pc AU,
10851106 printf (" rdst = 0x%x\n", rdst);
10861107 }
10871108 SYNTAX("xor %1%S1, %0");
1088-#line 456 "rx-decode.opc"
1109+#line 477 "rx-decode.opc"
10891110 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
10901111
10911112 /*----------------------------------------------------------------------*/
@@ -1103,13 +1124,13 @@ rx_decode_opcode (unsigned long pc AU,
11031124 op_semantics_16:
11041125 {
11051126 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1106-#line 390 "rx-decode.opc"
1127+#line 411 "rx-decode.opc"
11071128 int mx AU = (op[1] >> 6) & 0x03;
1108-#line 390 "rx-decode.opc"
1129+#line 411 "rx-decode.opc"
11091130 int ss AU = op[1] & 0x03;
1110-#line 390 "rx-decode.opc"
1131+#line 411 "rx-decode.opc"
11111132 int rsrc AU = (op[3] >> 4) & 0x0f;
1112-#line 390 "rx-decode.opc"
1133+#line 411 "rx-decode.opc"
11131134 int rdst AU = op[3] & 0x0f;
11141135 if (trace)
11151136 {
@@ -1122,7 +1143,7 @@ rx_decode_opcode (unsigned long pc AU,
11221143 printf (" rdst = 0x%x\n", rdst);
11231144 }
11241145 SYNTAX("xchg %1%S1, %0");
1125-#line 390 "rx-decode.opc"
1146+#line 411 "rx-decode.opc"
11261147 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
11271148
11281149 /*----------------------------------------------------------------------*/
@@ -1140,13 +1161,13 @@ rx_decode_opcode (unsigned long pc AU,
11401161 op_semantics_17:
11411162 {
11421163 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1143-#line 933 "rx-decode.opc"
1164+#line 954 "rx-decode.opc"
11441165 int mx AU = (op[1] >> 6) & 0x03;
1145-#line 933 "rx-decode.opc"
1166+#line 954 "rx-decode.opc"
11461167 int sd AU = op[1] & 0x03;
1147-#line 933 "rx-decode.opc"
1168+#line 954 "rx-decode.opc"
11481169 int rsrc AU = (op[3] >> 4) & 0x0f;
1149-#line 933 "rx-decode.opc"
1170+#line 954 "rx-decode.opc"
11501171 int rdst AU = op[3] & 0x0f;
11511172 if (trace)
11521173 {
@@ -1159,7 +1180,7 @@ rx_decode_opcode (unsigned long pc AU,
11591180 printf (" rdst = 0x%x\n", rdst);
11601181 }
11611182 SYNTAX("itof %1%S1, %0");
1162-#line 933 "rx-decode.opc"
1183+#line 954 "rx-decode.opc"
11631184 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
11641185
11651186 /*----------------------------------------------------------------------*/
@@ -1177,13 +1198,13 @@ rx_decode_opcode (unsigned long pc AU,
11771198 op_semantics_18:
11781199 {
11791200 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */
1180-#line 1119 "rx-decode.opc"
1201+#line 1140 "rx-decode.opc"
11811202 int mx AU = (op[1] >> 6) & 0x03;
1182-#line 1119 "rx-decode.opc"
1203+#line 1140 "rx-decode.opc"
11831204 int sd AU = op[1] & 0x03;
1184-#line 1119 "rx-decode.opc"
1205+#line 1140 "rx-decode.opc"
11851206 int rsrc AU = (op[3] >> 4) & 0x0f;
1186-#line 1119 "rx-decode.opc"
1207+#line 1140 "rx-decode.opc"
11871208 int rdst AU = op[3] & 0x0f;
11881209 if (trace)
11891210 {
@@ -1196,9 +1217,12 @@ rx_decode_opcode (unsigned long pc AU,
11961217 printf (" rdst = 0x%x\n", rdst);
11971218 }
11981219 SYNTAX("utof %1%S1, %0");
1199-#line 1119 "rx-decode.opc"
1220+#line 1140 "rx-decode.opc"
12001221 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
12011222
1223+ /*----------------------------------------------------------------------*/
1224+ /* RXv3 enhanced */
1225+
12021226 }
12031227 break;
12041228 }
@@ -2464,11 +2488,11 @@ rx_decode_opcode (unsigned long pc AU,
24642488 op_semantics_19:
24652489 {
24662490 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2467-#line 498 "rx-decode.opc"
2491+#line 519 "rx-decode.opc"
24682492 int ss AU = op[1] & 0x03;
2469-#line 498 "rx-decode.opc"
2493+#line 519 "rx-decode.opc"
24702494 int rsrc AU = (op[3] >> 4) & 0x0f;
2471-#line 498 "rx-decode.opc"
2495+#line 519 "rx-decode.opc"
24722496 int rdst AU = op[3] & 0x0f;
24732497 if (trace)
24742498 {
@@ -2480,7 +2504,7 @@ rx_decode_opcode (unsigned long pc AU,
24802504 printf (" rdst = 0x%x\n", rdst);
24812505 }
24822506 SYNTAX("adc %1%S1, %0");
2483-#line 498 "rx-decode.opc"
2507+#line 519 "rx-decode.opc"
24842508 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
24852509
24862510 /*----------------------------------------------------------------------*/
@@ -3653,7 +3677,7 @@ rx_decode_opcode (unsigned long pc AU,
36533677 case 0x0f:
36543678 {
36553679 /** 0000 1dsp bra.s %a0 */
3656-#line 779 "rx-decode.opc"
3680+#line 800 "rx-decode.opc"
36573681 int dsp AU = op[0] & 0x07;
36583682 if (trace)
36593683 {
@@ -3663,7 +3687,7 @@ rx_decode_opcode (unsigned long pc AU,
36633687 printf (" dsp = 0x%x\n", dsp);
36643688 }
36653689 SYNTAX("bra.s %a0");
3666-#line 779 "rx-decode.opc"
3690+#line 800 "rx-decode.opc"
36673691 ID(branch); DC(pc + dsp3map[dsp]);
36683692
36693693 }
@@ -3686,9 +3710,9 @@ rx_decode_opcode (unsigned long pc AU,
36863710 case 0x1f:
36873711 {
36883712 /** 0001 n dsp b%1.s %a0 */
3689-#line 769 "rx-decode.opc"
3713+#line 790 "rx-decode.opc"
36903714 int n AU = (op[0] >> 3) & 0x01;
3691-#line 769 "rx-decode.opc"
3715+#line 790 "rx-decode.opc"
36923716 int dsp AU = op[0] & 0x07;
36933717 if (trace)
36943718 {
@@ -3699,7 +3723,7 @@ rx_decode_opcode (unsigned long pc AU,
36993723 printf (" dsp = 0x%x\n", dsp);
37003724 }
37013725 SYNTAX("b%1.s %a0");
3702-#line 769 "rx-decode.opc"
3726+#line 790 "rx-decode.opc"
37033727 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
37043728
37053729 }
@@ -3721,7 +3745,7 @@ rx_decode_opcode (unsigned long pc AU,
37213745 case 0x2f:
37223746 {
37233747 /** 0010 cond b%1.b %a0 */
3724-#line 772 "rx-decode.opc"
3748+#line 793 "rx-decode.opc"
37253749 int cond AU = op[0] & 0x0f;
37263750 if (trace)
37273751 {
@@ -3731,7 +3755,7 @@ rx_decode_opcode (unsigned long pc AU,
37313755 printf (" cond = 0x%x\n", cond);
37323756 }
37333757 SYNTAX("b%1.b %a0");
3734-#line 772 "rx-decode.opc"
3758+#line 793 "rx-decode.opc"
37353759 ID(branch); Scc(cond); DC(pc + IMMex (1));
37363760
37373761 }
@@ -3746,7 +3770,7 @@ rx_decode_opcode (unsigned long pc AU,
37463770 op[0]);
37473771 }
37483772 SYNTAX("bra.b %a0");
3749-#line 782 "rx-decode.opc"
3773+#line 803 "rx-decode.opc"
37503774 ID(branch); DC(pc + IMMex(1));
37513775
37523776 }
@@ -3761,7 +3785,7 @@ rx_decode_opcode (unsigned long pc AU,
37613785 op[0]);
37623786 }
37633787 SYNTAX("bra.w %a0");
3764-#line 785 "rx-decode.opc"
3788+#line 806 "rx-decode.opc"
37653789 ID(branch); DC(pc + IMMex(2));
37663790
37673791 }
@@ -3776,7 +3800,7 @@ rx_decode_opcode (unsigned long pc AU,
37763800 op[0]);
37773801 }
37783802 SYNTAX("bsr.w %a0");
3779-#line 801 "rx-decode.opc"
3803+#line 822 "rx-decode.opc"
37803804 ID(jsr); DC(pc + IMMex(2));
37813805
37823806 }
@@ -3785,7 +3809,7 @@ rx_decode_opcode (unsigned long pc AU,
37853809 case 0x3b:
37863810 {
37873811 /** 0011 101c b%1.w %a0 */
3788-#line 775 "rx-decode.opc"
3812+#line 796 "rx-decode.opc"
37893813 int c AU = op[0] & 0x01;
37903814 if (trace)
37913815 {
@@ -3795,7 +3819,7 @@ rx_decode_opcode (unsigned long pc AU,
37953819 printf (" c = 0x%x\n", c);
37963820 }
37973821 SYNTAX("b%1.w %a0");
3798-#line 775 "rx-decode.opc"
3822+#line 796 "rx-decode.opc"
37993823 ID(branch); Scc(c); DC(pc + IMMex (2));
38003824
38013825
@@ -3809,13 +3833,13 @@ rx_decode_opcode (unsigned long pc AU,
38093833 op_semantics_20:
38103834 {
38113835 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3812-#line 311 "rx-decode.opc"
3836+#line 332 "rx-decode.opc"
38133837 int sz AU = op[0] & 0x03;
3814-#line 311 "rx-decode.opc"
3838+#line 332 "rx-decode.opc"
38153839 int d AU = (op[1] >> 7) & 0x01;
3816-#line 311 "rx-decode.opc"
3840+#line 332 "rx-decode.opc"
38173841 int dst AU = (op[1] >> 4) & 0x07;
3818-#line 311 "rx-decode.opc"
3842+#line 332 "rx-decode.opc"
38193843 int sppp AU = op[1] & 0x0f;
38203844 if (trace)
38213845 {
@@ -3828,7 +3852,7 @@ rx_decode_opcode (unsigned long pc AU,
38283852 printf (" sppp = 0x%x\n", sppp);
38293853 }
38303854 SYNTAX("mov%s #%1, %0");
3831-#line 311 "rx-decode.opc"
3855+#line 332 "rx-decode.opc"
38323856 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
38333857
38343858 }
@@ -3860,9 +3884,9 @@ rx_decode_opcode (unsigned long pc AU,
38603884 case 0x00:
38613885 {
38623886 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3863-#line 408 "rx-decode.opc"
3887+#line 429 "rx-decode.opc"
38643888 int rega AU = (op[1] >> 4) & 0x0f;
3865-#line 408 "rx-decode.opc"
3889+#line 429 "rx-decode.opc"
38663890 int regb AU = op[1] & 0x0f;
38673891 if (trace)
38683892 {
@@ -3873,7 +3897,7 @@ rx_decode_opcode (unsigned long pc AU,
38733897 printf (" regb = 0x%x\n", regb);
38743898 }
38753899 SYNTAX("rtsd #%1, %2-%0");
3876-#line 408 "rx-decode.opc"
3900+#line 429 "rx-decode.opc"
38773901 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
38783902
38793903 /*----------------------------------------------------------------------*/
@@ -3891,11 +3915,11 @@ rx_decode_opcode (unsigned long pc AU,
38913915 op_semantics_21:
38923916 {
38933917 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3894-#line 543 "rx-decode.opc"
3918+#line 564 "rx-decode.opc"
38953919 int ss AU = op[0] & 0x03;
3896-#line 543 "rx-decode.opc"
3920+#line 564 "rx-decode.opc"
38973921 int rsrc AU = (op[1] >> 4) & 0x0f;
3898-#line 543 "rx-decode.opc"
3922+#line 564 "rx-decode.opc"
38993923 int rdst AU = op[1] & 0x0f;
39003924 if (trace)
39013925 {
@@ -3907,7 +3931,7 @@ rx_decode_opcode (unsigned long pc AU,
39073931 printf (" rdst = 0x%x\n", rdst);
39083932 }
39093933 SYNTAX("sub %2%S2, %1");
3910-#line 543 "rx-decode.opc"
3934+#line 564 "rx-decode.opc"
39113935 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
39123936
39133937 }
@@ -3949,11 +3973,11 @@ rx_decode_opcode (unsigned long pc AU,
39493973 op_semantics_22:
39503974 {
39513975 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3952-#line 531 "rx-decode.opc"
3976+#line 552 "rx-decode.opc"
39533977 int ss AU = op[0] & 0x03;
3954-#line 531 "rx-decode.opc"
3978+#line 552 "rx-decode.opc"
39553979 int rsrc AU = (op[1] >> 4) & 0x0f;
3956-#line 531 "rx-decode.opc"
3980+#line 552 "rx-decode.opc"
39573981 int rdst AU = op[1] & 0x0f;
39583982 if (trace)
39593983 {
@@ -3965,7 +3989,7 @@ rx_decode_opcode (unsigned long pc AU,
39653989 printf (" rdst = 0x%x\n", rdst);
39663990 }
39673991 SYNTAX("cmp %2%S2, %1");
3968-#line 531 "rx-decode.opc"
3992+#line 552 "rx-decode.opc"
39693993 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
39703994
39713995 }
@@ -4007,11 +4031,11 @@ rx_decode_opcode (unsigned long pc AU,
40074031 op_semantics_23:
40084032 {
40094033 /** 0100 10ss rsrc rdst add %1%S1, %0 */
4010-#line 507 "rx-decode.opc"
4034+#line 528 "rx-decode.opc"
40114035 int ss AU = op[0] & 0x03;
4012-#line 507 "rx-decode.opc"
4036+#line 528 "rx-decode.opc"
40134037 int rsrc AU = (op[1] >> 4) & 0x0f;
4014-#line 507 "rx-decode.opc"
4038+#line 528 "rx-decode.opc"
40154039 int rdst AU = op[1] & 0x0f;
40164040 if (trace)
40174041 {
@@ -4023,7 +4047,7 @@ rx_decode_opcode (unsigned long pc AU,
40234047 printf (" rdst = 0x%x\n", rdst);
40244048 }
40254049 SYNTAX("add %1%S1, %0");
4026-#line 507 "rx-decode.opc"
4050+#line 528 "rx-decode.opc"
40274051 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
40284052
40294053 }
@@ -4065,11 +4089,11 @@ rx_decode_opcode (unsigned long pc AU,
40654089 op_semantics_24:
40664090 {
40674091 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
4068-#line 650 "rx-decode.opc"
4092+#line 671 "rx-decode.opc"
40694093 int ss AU = op[0] & 0x03;
4070-#line 650 "rx-decode.opc"
4094+#line 671 "rx-decode.opc"
40714095 int rsrc AU = (op[1] >> 4) & 0x0f;
4072-#line 650 "rx-decode.opc"
4096+#line 671 "rx-decode.opc"
40734097 int rdst AU = op[1] & 0x0f;
40744098 if (trace)
40754099 {
@@ -4081,7 +4105,7 @@ rx_decode_opcode (unsigned long pc AU,
40814105 printf (" rdst = 0x%x\n", rdst);
40824106 }
40834107 SYNTAX("mul %1%S1, %0");
4084-#line 650 "rx-decode.opc"
4108+#line 671 "rx-decode.opc"
40854109 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
40864110
40874111 }
@@ -4123,11 +4147,11 @@ rx_decode_opcode (unsigned long pc AU,
41234147 op_semantics_25:
41244148 {
41254149 /** 0101 00ss rsrc rdst and %1%S1, %0 */
4126-#line 420 "rx-decode.opc"
4150+#line 441 "rx-decode.opc"
41274151 int ss AU = op[0] & 0x03;
4128-#line 420 "rx-decode.opc"
4152+#line 441 "rx-decode.opc"
41294153 int rsrc AU = (op[1] >> 4) & 0x0f;
4130-#line 420 "rx-decode.opc"
4154+#line 441 "rx-decode.opc"
41314155 int rdst AU = op[1] & 0x0f;
41324156 if (trace)
41334157 {
@@ -4139,7 +4163,7 @@ rx_decode_opcode (unsigned long pc AU,
41394163 printf (" rdst = 0x%x\n", rdst);
41404164 }
41414165 SYNTAX("and %1%S1, %0");
4142-#line 420 "rx-decode.opc"
4166+#line 441 "rx-decode.opc"
41434167 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
41444168
41454169 }
@@ -4181,11 +4205,11 @@ rx_decode_opcode (unsigned long pc AU,
41814205 op_semantics_26:
41824206 {
41834207 /** 0101 01ss rsrc rdst or %1%S1, %0 */
4184-#line 438 "rx-decode.opc"
4208+#line 459 "rx-decode.opc"
41854209 int ss AU = op[0] & 0x03;
4186-#line 438 "rx-decode.opc"
4210+#line 459 "rx-decode.opc"
41874211 int rsrc AU = (op[1] >> 4) & 0x0f;
4188-#line 438 "rx-decode.opc"
4212+#line 459 "rx-decode.opc"
41894213 int rdst AU = op[1] & 0x0f;
41904214 if (trace)
41914215 {
@@ -4197,7 +4221,7 @@ rx_decode_opcode (unsigned long pc AU,
41974221 printf (" rdst = 0x%x\n", rdst);
41984222 }
41994223 SYNTAX("or %1%S1, %0");
4200-#line 438 "rx-decode.opc"
4224+#line 459 "rx-decode.opc"
42014225 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
42024226
42034227 }
@@ -4239,13 +4263,13 @@ rx_decode_opcode (unsigned long pc AU,
42394263 op_semantics_27:
42404264 {
42414265 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4242-#line 359 "rx-decode.opc"
4266+#line 380 "rx-decode.opc"
42434267 int s AU = (op[0] >> 2) & 0x01;
4244-#line 359 "rx-decode.opc"
4268+#line 380 "rx-decode.opc"
42454269 int ss AU = op[0] & 0x03;
4246-#line 359 "rx-decode.opc"
4270+#line 380 "rx-decode.opc"
42474271 int rsrc AU = (op[1] >> 4) & 0x0f;
4248-#line 359 "rx-decode.opc"
4272+#line 380 "rx-decode.opc"
42494273 int rdst AU = op[1] & 0x0f;
42504274 if (trace)
42514275 {
@@ -4258,7 +4282,7 @@ rx_decode_opcode (unsigned long pc AU,
42584282 printf (" rdst = 0x%x\n", rdst);
42594283 }
42604284 SYNTAX("movu%s %1, %0");
4261-#line 359 "rx-decode.opc"
4285+#line 380 "rx-decode.opc"
42624286 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
42634287
42644288 }
@@ -4335,9 +4359,9 @@ rx_decode_opcode (unsigned long pc AU,
43354359 case 0x00:
43364360 {
43374361 /** 0110 0000 immm rdst sub #%2, %0 */
4338-#line 540 "rx-decode.opc"
4362+#line 561 "rx-decode.opc"
43394363 int immm AU = (op[1] >> 4) & 0x0f;
4340-#line 540 "rx-decode.opc"
4364+#line 561 "rx-decode.opc"
43414365 int rdst AU = op[1] & 0x0f;
43424366 if (trace)
43434367 {
@@ -4348,7 +4372,7 @@ rx_decode_opcode (unsigned long pc AU,
43484372 printf (" rdst = 0x%x\n", rdst);
43494373 }
43504374 SYNTAX("sub #%2, %0");
4351-#line 540 "rx-decode.opc"
4375+#line 561 "rx-decode.opc"
43524376 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
43534377
43544378 }
@@ -4362,9 +4386,9 @@ rx_decode_opcode (unsigned long pc AU,
43624386 case 0x00:
43634387 {
43644388 /** 0110 0001 immm rdst cmp #%2, %1 */
4365-#line 522 "rx-decode.opc"
4389+#line 543 "rx-decode.opc"
43664390 int immm AU = (op[1] >> 4) & 0x0f;
4367-#line 522 "rx-decode.opc"
4391+#line 543 "rx-decode.opc"
43684392 int rdst AU = op[1] & 0x0f;
43694393 if (trace)
43704394 {
@@ -4375,7 +4399,7 @@ rx_decode_opcode (unsigned long pc AU,
43754399 printf (" rdst = 0x%x\n", rdst);
43764400 }
43774401 SYNTAX("cmp #%2, %1");
4378-#line 522 "rx-decode.opc"
4402+#line 543 "rx-decode.opc"
43794403 ID(sub); S2C(immm); SR(rdst); F_OSZC;
43804404
43814405 }
@@ -4389,9 +4413,9 @@ rx_decode_opcode (unsigned long pc AU,
43894413 case 0x00:
43904414 {
43914415 /** 0110 0010 immm rdst add #%1, %0 */
4392-#line 504 "rx-decode.opc"
4416+#line 525 "rx-decode.opc"
43934417 int immm AU = (op[1] >> 4) & 0x0f;
4394-#line 504 "rx-decode.opc"
4418+#line 525 "rx-decode.opc"
43954419 int rdst AU = op[1] & 0x0f;
43964420 if (trace)
43974421 {
@@ -4402,7 +4426,7 @@ rx_decode_opcode (unsigned long pc AU,
44024426 printf (" rdst = 0x%x\n", rdst);
44034427 }
44044428 SYNTAX("add #%1, %0");
4405-#line 504 "rx-decode.opc"
4429+#line 525 "rx-decode.opc"
44064430 ID(add); SC(immm); DR(rdst); F_OSZC;
44074431
44084432 }
@@ -4416,9 +4440,9 @@ rx_decode_opcode (unsigned long pc AU,
44164440 case 0x00:
44174441 {
44184442 /** 0110 0011 immm rdst mul #%1, %0 */
4419-#line 616 "rx-decode.opc"
4443+#line 637 "rx-decode.opc"
44204444 int immm AU = (op[1] >> 4) & 0x0f;
4421-#line 616 "rx-decode.opc"
4445+#line 637 "rx-decode.opc"
44224446 int rdst AU = op[1] & 0x0f;
44234447 if (trace)
44244448 {
@@ -4429,7 +4453,7 @@ rx_decode_opcode (unsigned long pc AU,
44294453 printf (" rdst = 0x%x\n", rdst);
44304454 }
44314455 SYNTAX("mul #%1, %0");
4432-#line 616 "rx-decode.opc"
4456+#line 637 "rx-decode.opc"
44334457 if (immm == 1 && rdst == 0)
44344458 {
44354459 ID(nop2);
@@ -4452,9 +4476,9 @@ rx_decode_opcode (unsigned long pc AU,
44524476 case 0x00:
44534477 {
44544478 /** 0110 0100 immm rdst and #%1, %0 */
4455-#line 414 "rx-decode.opc"
4479+#line 435 "rx-decode.opc"
44564480 int immm AU = (op[1] >> 4) & 0x0f;
4457-#line 414 "rx-decode.opc"
4481+#line 435 "rx-decode.opc"
44584482 int rdst AU = op[1] & 0x0f;
44594483 if (trace)
44604484 {
@@ -4465,7 +4489,7 @@ rx_decode_opcode (unsigned long pc AU,
44654489 printf (" rdst = 0x%x\n", rdst);
44664490 }
44674491 SYNTAX("and #%1, %0");
4468-#line 414 "rx-decode.opc"
4492+#line 435 "rx-decode.opc"
44694493 ID(and); SC(immm); DR(rdst); F__SZ_;
44704494
44714495 }
@@ -4479,9 +4503,9 @@ rx_decode_opcode (unsigned long pc AU,
44794503 case 0x00:
44804504 {
44814505 /** 0110 0101 immm rdst or #%1, %0 */
4482-#line 432 "rx-decode.opc"
4506+#line 453 "rx-decode.opc"
44834507 int immm AU = (op[1] >> 4) & 0x0f;
4484-#line 432 "rx-decode.opc"
4508+#line 453 "rx-decode.opc"
44854509 int rdst AU = op[1] & 0x0f;
44864510 if (trace)
44874511 {
@@ -4492,7 +4516,7 @@ rx_decode_opcode (unsigned long pc AU,
44924516 printf (" rdst = 0x%x\n", rdst);
44934517 }
44944518 SYNTAX("or #%1, %0");
4495-#line 432 "rx-decode.opc"
4519+#line 453 "rx-decode.opc"
44964520 ID(or); SC(immm); DR(rdst); F__SZ_;
44974521
44984522 }
@@ -4506,9 +4530,9 @@ rx_decode_opcode (unsigned long pc AU,
45064530 case 0x00:
45074531 {
45084532 /** 0110 0110 immm rdst mov%s #%1, %0 */
4509-#line 308 "rx-decode.opc"
4533+#line 329 "rx-decode.opc"
45104534 int immm AU = (op[1] >> 4) & 0x0f;
4511-#line 308 "rx-decode.opc"
4535+#line 329 "rx-decode.opc"
45124536 int rdst AU = op[1] & 0x0f;
45134537 if (trace)
45144538 {
@@ -4519,7 +4543,7 @@ rx_decode_opcode (unsigned long pc AU,
45194543 printf (" rdst = 0x%x\n", rdst);
45204544 }
45214545 SYNTAX("mov%s #%1, %0");
4522-#line 308 "rx-decode.opc"
4546+#line 329 "rx-decode.opc"
45234547 ID(mov); DR(rdst); SC(immm); F_____;
45244548
45254549 }
@@ -4536,7 +4560,7 @@ rx_decode_opcode (unsigned long pc AU,
45364560 op[0]);
45374561 }
45384562 SYNTAX("rtsd #%1");
4539-#line 405 "rx-decode.opc"
4563+#line 426 "rx-decode.opc"
45404564 ID(rtsd); SC(IMM(1) * 4);
45414565
45424566 }
@@ -4549,11 +4573,11 @@ rx_decode_opcode (unsigned long pc AU,
45494573 op_semantics_28:
45504574 {
45514575 /** 0110 100i mmmm rdst shlr #%2, %0 */
4552-#line 730 "rx-decode.opc"
4576+#line 751 "rx-decode.opc"
45534577 int i AU = op[0] & 0x01;
4554-#line 730 "rx-decode.opc"
4578+#line 751 "rx-decode.opc"
45554579 int mmmm AU = (op[1] >> 4) & 0x0f;
4556-#line 730 "rx-decode.opc"
4580+#line 751 "rx-decode.opc"
45574581 int rdst AU = op[1] & 0x0f;
45584582 if (trace)
45594583 {
@@ -4565,7 +4589,7 @@ rx_decode_opcode (unsigned long pc AU,
45654589 printf (" rdst = 0x%x\n", rdst);
45664590 }
45674591 SYNTAX("shlr #%2, %0");
4568-#line 730 "rx-decode.opc"
4592+#line 751 "rx-decode.opc"
45694593 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
45704594
45714595 }
@@ -4589,11 +4613,11 @@ rx_decode_opcode (unsigned long pc AU,
45894613 op_semantics_29:
45904614 {
45914615 /** 0110 101i mmmm rdst shar #%2, %0 */
4592-#line 720 "rx-decode.opc"
4616+#line 741 "rx-decode.opc"
45934617 int i AU = op[0] & 0x01;
4594-#line 720 "rx-decode.opc"
4618+#line 741 "rx-decode.opc"
45954619 int mmmm AU = (op[1] >> 4) & 0x0f;
4596-#line 720 "rx-decode.opc"
4620+#line 741 "rx-decode.opc"
45974621 int rdst AU = op[1] & 0x0f;
45984622 if (trace)
45994623 {
@@ -4605,7 +4629,7 @@ rx_decode_opcode (unsigned long pc AU,
46054629 printf (" rdst = 0x%x\n", rdst);
46064630 }
46074631 SYNTAX("shar #%2, %0");
4608-#line 720 "rx-decode.opc"
4632+#line 741 "rx-decode.opc"
46094633 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
46104634
46114635 }
@@ -4629,11 +4653,11 @@ rx_decode_opcode (unsigned long pc AU,
46294653 op_semantics_30:
46304654 {
46314655 /** 0110 110i mmmm rdst shll #%2, %0 */
4632-#line 710 "rx-decode.opc"
4656+#line 731 "rx-decode.opc"
46334657 int i AU = op[0] & 0x01;
4634-#line 710 "rx-decode.opc"
4658+#line 731 "rx-decode.opc"
46354659 int mmmm AU = (op[1] >> 4) & 0x0f;
4636-#line 710 "rx-decode.opc"
4660+#line 731 "rx-decode.opc"
46374661 int rdst AU = op[1] & 0x0f;
46384662 if (trace)
46394663 {
@@ -4645,7 +4669,7 @@ rx_decode_opcode (unsigned long pc AU,
46454669 printf (" rdst = 0x%x\n", rdst);
46464670 }
46474671 SYNTAX("shll #%2, %0");
4648-#line 710 "rx-decode.opc"
4672+#line 731 "rx-decode.opc"
46494673 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
46504674
46514675 }
@@ -4668,9 +4692,9 @@ rx_decode_opcode (unsigned long pc AU,
46684692 case 0x00:
46694693 {
46704694 /** 0110 1110 dsta dstb pushm %1-%2 */
4671-#line 372 "rx-decode.opc"
4695+#line 393 "rx-decode.opc"
46724696 int dsta AU = (op[1] >> 4) & 0x0f;
4673-#line 372 "rx-decode.opc"
4697+#line 393 "rx-decode.opc"
46744698 int dstb AU = op[1] & 0x0f;
46754699 if (trace)
46764700 {
@@ -4681,7 +4705,7 @@ rx_decode_opcode (unsigned long pc AU,
46814705 printf (" dstb = 0x%x\n", dstb);
46824706 }
46834707 SYNTAX("pushm %1-%2");
4684-#line 372 "rx-decode.opc"
4708+#line 393 "rx-decode.opc"
46854709 ID(pushm); SR(dsta); S2R(dstb); F_____;
46864710
46874711 }
@@ -4695,9 +4719,9 @@ rx_decode_opcode (unsigned long pc AU,
46954719 case 0x00:
46964720 {
46974721 /** 0110 1111 dsta dstb popm %1-%2 */
4698-#line 369 "rx-decode.opc"
4722+#line 390 "rx-decode.opc"
46994723 int dsta AU = (op[1] >> 4) & 0x0f;
4700-#line 369 "rx-decode.opc"
4724+#line 390 "rx-decode.opc"
47014725 int dstb AU = op[1] & 0x0f;
47024726 if (trace)
47034727 {
@@ -4708,7 +4732,7 @@ rx_decode_opcode (unsigned long pc AU,
47084732 printf (" dstb = 0x%x\n", dstb);
47094733 }
47104734 SYNTAX("popm %1-%2");
4711-#line 369 "rx-decode.opc"
4735+#line 390 "rx-decode.opc"
47124736 ID(popm); SR(dsta); S2R(dstb); F_____;
47134737
47144738 }
@@ -4723,11 +4747,11 @@ rx_decode_opcode (unsigned long pc AU,
47234747 op_semantics_31:
47244748 {
47254749 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4726-#line 513 "rx-decode.opc"
4750+#line 534 "rx-decode.opc"
47274751 int im AU = op[0] & 0x03;
4728-#line 513 "rx-decode.opc"
4752+#line 534 "rx-decode.opc"
47294753 int rsrc AU = (op[1] >> 4) & 0x0f;
4730-#line 513 "rx-decode.opc"
4754+#line 534 "rx-decode.opc"
47314755 int rdst AU = op[1] & 0x0f;
47324756 if (trace)
47334757 {
@@ -4739,7 +4763,7 @@ rx_decode_opcode (unsigned long pc AU,
47394763 printf (" rdst = 0x%x\n", rdst);
47404764 }
47414765 SYNTAX("add #%1, %2, %0");
4742-#line 513 "rx-decode.opc"
4766+#line 534 "rx-decode.opc"
47434767 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
47444768
47454769 }
@@ -4781,9 +4805,9 @@ rx_decode_opcode (unsigned long pc AU,
47814805 op_semantics_32:
47824806 {
47834807 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4784-#line 525 "rx-decode.opc"
4808+#line 546 "rx-decode.opc"
47854809 int im AU = op[0] & 0x03;
4786-#line 525 "rx-decode.opc"
4810+#line 546 "rx-decode.opc"
47874811 int rsrc AU = op[1] & 0x0f;
47884812 if (trace)
47894813 {
@@ -4794,7 +4818,7 @@ rx_decode_opcode (unsigned long pc AU,
47944818 printf (" rsrc = 0x%x\n", rsrc);
47954819 }
47964820 SYNTAX("cmp #%2, %1%S1");
4797-#line 525 "rx-decode.opc"
4821+#line 546 "rx-decode.opc"
47984822 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
47994823
48004824 }
@@ -4803,9 +4827,9 @@ rx_decode_opcode (unsigned long pc AU,
48034827 op_semantics_33:
48044828 {
48054829 /** 0111 01im 0001rdst mul #%1, %0 */
4806-#line 628 "rx-decode.opc"
4830+#line 649 "rx-decode.opc"
48074831 int im AU = op[0] & 0x03;
4808-#line 628 "rx-decode.opc"
4832+#line 649 "rx-decode.opc"
48094833 int rdst AU = op[1] & 0x0f;
48104834 if (trace)
48114835 {
@@ -4816,7 +4840,7 @@ rx_decode_opcode (unsigned long pc AU,
48164840 printf (" rdst = 0x%x\n", rdst);
48174841 }
48184842 SYNTAX("mul #%1, %0");
4819-#line 628 "rx-decode.opc"
4843+#line 649 "rx-decode.opc"
48204844 int val = IMMex(im);
48214845 if (val == 1 && rdst == 0)
48224846 {
@@ -4844,9 +4868,9 @@ rx_decode_opcode (unsigned long pc AU,
48444868 op_semantics_34:
48454869 {
48464870 /** 0111 01im 0010 rdst and #%1, %0 */
4847-#line 417 "rx-decode.opc"
4871+#line 438 "rx-decode.opc"
48484872 int im AU = op[0] & 0x03;
4849-#line 417 "rx-decode.opc"
4873+#line 438 "rx-decode.opc"
48504874 int rdst AU = op[1] & 0x0f;
48514875 if (trace)
48524876 {
@@ -4857,7 +4881,7 @@ rx_decode_opcode (unsigned long pc AU,
48574881 printf (" rdst = 0x%x\n", rdst);
48584882 }
48594883 SYNTAX("and #%1, %0");
4860-#line 417 "rx-decode.opc"
4884+#line 438 "rx-decode.opc"
48614885 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
48624886
48634887 }
@@ -4866,9 +4890,9 @@ rx_decode_opcode (unsigned long pc AU,
48664890 op_semantics_35:
48674891 {
48684892 /** 0111 01im 0011 rdst or #%1, %0 */
4869-#line 435 "rx-decode.opc"
4893+#line 456 "rx-decode.opc"
48704894 int im AU = op[0] & 0x03;
4871-#line 435 "rx-decode.opc"
4895+#line 456 "rx-decode.opc"
48724896 int rdst AU = op[1] & 0x0f;
48734897 if (trace)
48744898 {
@@ -4879,7 +4903,7 @@ rx_decode_opcode (unsigned long pc AU,
48794903 printf (" rdst = 0x%x\n", rdst);
48804904 }
48814905 SYNTAX("or #%1, %0");
4882-#line 435 "rx-decode.opc"
4906+#line 456 "rx-decode.opc"
48834907 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
48844908
48854909 }
@@ -4981,7 +5005,7 @@ rx_decode_opcode (unsigned long pc AU,
49815005 case 0x4f:
49825006 {
49835007 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4984-#line 289 "rx-decode.opc"
5008+#line 310 "rx-decode.opc"
49855009 int rdst AU = op[1] & 0x0f;
49865010 if (trace)
49875011 {
@@ -4991,7 +5015,7 @@ rx_decode_opcode (unsigned long pc AU,
49915015 printf (" rdst = 0x%x\n", rdst);
49925016 }
49935017 SYNTAX("mov%s #%1, %0");
4994-#line 289 "rx-decode.opc"
5018+#line 310 "rx-decode.opc"
49955019 ID(mov); DR(rdst); SC(IMM (1)); F_____;
49965020
49975021 }
@@ -5014,7 +5038,7 @@ rx_decode_opcode (unsigned long pc AU,
50145038 case 0x5f:
50155039 {
50165040 /** 0111 0101 0101 rsrc cmp #%2, %1 */
5017-#line 528 "rx-decode.opc"
5041+#line 549 "rx-decode.opc"
50185042 int rsrc AU = op[1] & 0x0f;
50195043 if (trace)
50205044 {
@@ -5024,7 +5048,7 @@ rx_decode_opcode (unsigned long pc AU,
50245048 printf (" rsrc = 0x%x\n", rsrc);
50255049 }
50265050 SYNTAX("cmp #%2, %1");
5027-#line 528 "rx-decode.opc"
5051+#line 549 "rx-decode.opc"
50285052 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
50295053
50305054 }
@@ -5039,7 +5063,7 @@ rx_decode_opcode (unsigned long pc AU,
50395063 op[0], op[1]);
50405064 }
50415065 SYNTAX("int #%1");
5042-#line 1035 "rx-decode.opc"
5066+#line 1056 "rx-decode.opc"
50435067 ID(int); SC(IMM(1));
50445068
50455069 }
@@ -5051,7 +5075,7 @@ rx_decode_opcode (unsigned long pc AU,
50515075 case 0x00:
50525076 {
50535077 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
5054-#line 1002 "rx-decode.opc"
5078+#line 1023 "rx-decode.opc"
50555079 int immm AU = op[2] & 0x0f;
50565080 if (trace)
50575081 {
@@ -5061,7 +5085,7 @@ rx_decode_opcode (unsigned long pc AU,
50615085 printf (" immm = 0x%x\n", immm);
50625086 }
50635087 SYNTAX("mvtipl #%1");
5064-#line 1002 "rx-decode.opc"
5088+#line 1023 "rx-decode.opc"
50655089 ID(mvtipl); SC(immm);
50665090
50675091 }
@@ -5069,6702 +5093,10167 @@ rx_decode_opcode (unsigned long pc AU,
50695093 default: UNSUPPORTED(); break;
50705094 }
50715095 break;
5072- default: UNSUPPORTED(); break;
5073- }
5074- break;
5075- case 0x76:
5076- GETBYTE ();
5077- switch (op[1] & 0xf0)
5078- {
5079- case 0x00:
5080- goto op_semantics_32;
5081- break;
5082- case 0x10:
5083- goto op_semantics_33;
5084- break;
5085- case 0x20:
5086- goto op_semantics_34;
5087- break;
5088- case 0x30:
5089- goto op_semantics_35;
5096+ case 0x90:
5097+ GETBYTE ();
5098+ switch (op[2] & 0xff)
5099+ {
5100+ case 0x1b:
5101+ {
5102+ /** 0111 0101 1001 0000 0001 1011 mvfdr */
5103+ if (trace)
5104+ {
5105+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5106+ "/** 0111 0101 1001 0000 0001 1011 mvfdr */",
5107+ op[0], op[1], op[2]);
5108+ }
5109+ SYNTAX("mvfdr");
5110+#line 1229 "rx-decode.opc"
5111+ ID(mvfdr); F_____;
5112+
5113+ }
5114+ break;
5115+ default: UNSUPPORTED(); break;
5116+ }
50905117 break;
5091- default: UNSUPPORTED(); break;
5092- }
5093- break;
5094- case 0x77:
5095- GETBYTE ();
5096- switch (op[1] & 0xf0)
5097- {
5098- case 0x00:
5099- goto op_semantics_32;
5100- break;
5101- case 0x10:
5102- goto op_semantics_33;
5103- break;
5104- case 0x20:
5105- goto op_semantics_34;
5106- break;
5107- case 0x30:
5108- goto op_semantics_35;
5109- break;
5110- default: UNSUPPORTED(); break;
5111- }
5112- break;
5113- case 0x78:
5114- GETBYTE ();
5115- switch (op[1] & 0x00)
5116- {
5117- case 0x00:
5118- op_semantics_36:
5118+ case 0xa0:
5119+ GETBYTE ();
5120+ switch (op[2] & 0x00)
51195121 {
5120- /** 0111 100b ittt rdst bset #%1, %0 */
5121-#line 947 "rx-decode.opc"
5122- int b AU = op[0] & 0x01;
5123-#line 947 "rx-decode.opc"
5124- int ittt AU = (op[1] >> 4) & 0x0f;
5125-#line 947 "rx-decode.opc"
5126- int rdst AU = op[1] & 0x0f;
5127- if (trace)
5128- {
5129- printf ("\033[33m%s\033[0m %02x %02x\n",
5130- "/** 0111 100b ittt rdst bset #%1, %0 */",
5131- op[0], op[1]);
5132- printf (" b = 0x%x,", b);
5133- printf (" ittt = 0x%x,", ittt);
5134- printf (" rdst = 0x%x\n", rdst);
5135- }
5136- SYNTAX("bset #%1, %0");
5137-#line 947 "rx-decode.opc"
5138- ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5139-
5122+ case 0x00:
5123+ {
5124+ /** 0111 0101 1010 0000 rdst rnum dpush.l %1-%2 */
5125+#line 1223 "rx-decode.opc"
5126+ int rdst AU = (op[2] >> 4) & 0x0f;
5127+#line 1223 "rx-decode.opc"
5128+ int rnum AU = op[2] & 0x0f;
5129+ if (trace)
5130+ {
5131+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5132+ "/** 0111 0101 1010 0000 rdst rnum dpush.l %1-%2 */",
5133+ op[0], op[1], op[2]);
5134+ printf (" rdst = 0x%x,", rdst);
5135+ printf (" rnum = 0x%x\n", rnum);
5136+ }
5137+ SYNTAX("dpush.l %1-%2");
5138+#line 1223 "rx-decode.opc"
5139+ ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____;
51405140
5141+ }
5142+ break;
51415143 }
51425144 break;
5143- }
5144- break;
5145- case 0x79:
5146- GETBYTE ();
5147- switch (op[1] & 0x00)
5148- {
5149- case 0x00:
5150- goto op_semantics_36;
5151- break;
5152- }
5153- break;
5154- case 0x7a:
5155- GETBYTE ();
5156- switch (op[1] & 0x00)
5157- {
5158- case 0x00:
5159- op_semantics_37:
5145+ case 0xa8:
5146+ GETBYTE ();
5147+ switch (op[2] & 0x00)
51605148 {
5161- /** 0111 101b ittt rdst bclr #%1, %0 */
5162-#line 959 "rx-decode.opc"
5163- int b AU = op[0] & 0x01;
5164-#line 959 "rx-decode.opc"
5165- int ittt AU = (op[1] >> 4) & 0x0f;
5166-#line 959 "rx-decode.opc"
5167- int rdst AU = op[1] & 0x0f;
5168- if (trace)
5169- {
5170- printf ("\033[33m%s\033[0m %02x %02x\n",
5171- "/** 0111 101b ittt rdst bclr #%1, %0 */",
5172- op[0], op[1]);
5173- printf (" b = 0x%x,", b);
5174- printf (" ittt = 0x%x,", ittt);
5175- printf (" rdst = 0x%x\n", rdst);
5176- }
5177- SYNTAX("bclr #%1, %0");
5178-#line 959 "rx-decode.opc"
5179- ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5180-
5149+ case 0x00:
5150+ {
5151+ /** 0111 0101 1010 1000 rdst rnum dpop.l %1-%2 */
5152+#line 1217 "rx-decode.opc"
5153+ int rdst AU = (op[2] >> 4) & 0x0f;
5154+#line 1217 "rx-decode.opc"
5155+ int rnum AU = op[2] & 0x0f;
5156+ if (trace)
5157+ {
5158+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5159+ "/** 0111 0101 1010 1000 rdst rnum dpop.l %1-%2 */",
5160+ op[0], op[1], op[2]);
5161+ printf (" rdst = 0x%x,", rdst);
5162+ printf (" rnum = 0x%x\n", rnum);
5163+ }
5164+ SYNTAX("dpop.l %1-%2");
5165+#line 1217 "rx-decode.opc"
5166+ ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____;
51815167
5168+ }
5169+ break;
51825170 }
51835171 break;
5184- }
5185- break;
5186- case 0x7b:
5187- GETBYTE ();
5188- switch (op[1] & 0x00)
5189- {
5190- case 0x00:
5191- goto op_semantics_37;
5192- break;
5193- }
5194- break;
5195- case 0x7c:
5196- GETBYTE ();
5197- switch (op[1] & 0x00)
5198- {
5199- case 0x00:
5200- op_semantics_38:
5172+ case 0xb0:
5173+ GETBYTE ();
5174+ switch (op[2] & 0x00)
52015175 {
5202- /** 0111 110b ittt rdst btst #%2, %1 */
5203-#line 971 "rx-decode.opc"
5204- int b AU = op[0] & 0x01;
5205-#line 971 "rx-decode.opc"
5206- int ittt AU = (op[1] >> 4) & 0x0f;
5207-#line 971 "rx-decode.opc"
5208- int rdst AU = op[1] & 0x0f;
5209- if (trace)
5210- {
5211- printf ("\033[33m%s\033[0m %02x %02x\n",
5212- "/** 0111 110b ittt rdst btst #%2, %1 */",
5213- op[0], op[1]);
5214- printf (" b = 0x%x,", b);
5215- printf (" ittt = 0x%x,", ittt);
5216- printf (" rdst = 0x%x\n", rdst);
5217- }
5218- SYNTAX("btst #%2, %1");
5219-#line 971 "rx-decode.opc"
5220- ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5221-
5176+ case 0x00:
5177+ {
5178+ /** 0111 0101 1011 0000 rdst rnum dpush.d %1-%2 */
5179+#line 1220 "rx-decode.opc"
5180+ int rdst AU = (op[2] >> 4) & 0x0f;
5181+#line 1220 "rx-decode.opc"
5182+ int rnum AU = op[2] & 0x0f;
5183+ if (trace)
5184+ {
5185+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5186+ "/** 0111 0101 1011 0000 rdst rnum dpush.d %1-%2 */",
5187+ op[0], op[1], op[2]);
5188+ printf (" rdst = 0x%x,", rdst);
5189+ printf (" rnum = 0x%x\n", rnum);
5190+ }
5191+ SYNTAX("dpush.d %1-%2");
5192+#line 1220 "rx-decode.opc"
5193+ ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____;
52225194
5195+ }
5196+ break;
52235197 }
52245198 break;
5225- }
5226- break;
5227- case 0x7d:
5228- GETBYTE ();
5229- switch (op[1] & 0x00)
5230- {
5231- case 0x00:
5232- goto op_semantics_38;
5199+ case 0xb8:
5200+ GETBYTE ();
5201+ switch (op[2] & 0x00)
5202+ {
5203+ case 0x00:
5204+ {
5205+ /** 0111 0101 1011 1000 rdst rnum dpop.d %1-%2 */
5206+#line 1214 "rx-decode.opc"
5207+ int rdst AU = (op[2] >> 4) & 0x0f;
5208+#line 1214 "rx-decode.opc"
5209+ int rnum AU = op[2] & 0x0f;
5210+ if (trace)
5211+ {
5212+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
5213+ "/** 0111 0101 1011 1000 rdst rnum dpop.d %1-%2 */",
5214+ op[0], op[1], op[2]);
5215+ printf (" rdst = 0x%x,", rdst);
5216+ printf (" rnum = 0x%x\n", rnum);
5217+ }
5218+ SYNTAX("dpop.d %1-%2");
5219+#line 1214 "rx-decode.opc"
5220+ ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____;
5221+
5222+ }
5223+ break;
5224+ }
52335225 break;
5226+ default: UNSUPPORTED(); break;
52345227 }
52355228 break;
5236- case 0x7e:
5229+ case 0x76:
52375230 GETBYTE ();
5238- switch (op[1] & 0xf0)
5231+ switch (op[1] & 0xff)
52395232 {
52405233 case 0x00:
5241- {
5242- /** 0111 1110 0000 rdst not %0 */
5243-#line 462 "rx-decode.opc"
5244- int rdst AU = op[1] & 0x0f;
5245- if (trace)
5246- {
5247- printf ("\033[33m%s\033[0m %02x %02x\n",
5248- "/** 0111 1110 0000 rdst not %0 */",
5249- op[0], op[1]);
5250- printf (" rdst = 0x%x\n", rdst);
5251- }
5252- SYNTAX("not %0");
5253-#line 462 "rx-decode.opc"
5254- ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5255-
5256- }
5234+ case 0x01:
5235+ case 0x02:
5236+ case 0x03:
5237+ case 0x04:
5238+ case 0x05:
5239+ case 0x06:
5240+ case 0x07:
5241+ case 0x08:
5242+ case 0x09:
5243+ case 0x0a:
5244+ case 0x0b:
5245+ case 0x0c:
5246+ case 0x0d:
5247+ case 0x0e:
5248+ case 0x0f:
5249+ goto op_semantics_32;
52575250 break;
52585251 case 0x10:
5259- {
5260- /** 0111 1110 0001 rdst neg %0 */
5261-#line 483 "rx-decode.opc"
5262- int rdst AU = op[1] & 0x0f;
5263- if (trace)
5264- {
5265- printf ("\033[33m%s\033[0m %02x %02x\n",
5266- "/** 0111 1110 0001 rdst neg %0 */",
5267- op[0], op[1]);
5268- printf (" rdst = 0x%x\n", rdst);
5269- }
5270- SYNTAX("neg %0");
5271-#line 483 "rx-decode.opc"
5272- ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5273-
5274- }
5252+ case 0x11:
5253+ case 0x12:
5254+ case 0x13:
5255+ case 0x14:
5256+ case 0x15:
5257+ case 0x16:
5258+ case 0x17:
5259+ case 0x18:
5260+ case 0x19:
5261+ case 0x1a:
5262+ case 0x1b:
5263+ case 0x1c:
5264+ case 0x1d:
5265+ case 0x1e:
5266+ case 0x1f:
5267+ goto op_semantics_33;
52755268 break;
52765269 case 0x20:
5277- {
5278- /** 0111 1110 0010 rdst abs %0 */
5279-#line 565 "rx-decode.opc"
5280- int rdst AU = op[1] & 0x0f;
5281- if (trace)
5282- {
5283- printf ("\033[33m%s\033[0m %02x %02x\n",
5284- "/** 0111 1110 0010 rdst abs %0 */",
5285- op[0], op[1]);
5286- printf (" rdst = 0x%x\n", rdst);
5287- }
5288- SYNTAX("abs %0");
5289-#line 565 "rx-decode.opc"
5290- ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5291-
5292- }
5293- break;
5294- case 0x30:
5295- {
5296- /** 0111 1110 0011 rdst sat %0 */
5297-#line 885 "rx-decode.opc"
5270+ case 0x21:
5271+ case 0x22:
5272+ case 0x23:
5273+ case 0x24:
5274+ case 0x25:
5275+ case 0x26:
5276+ case 0x27:
5277+ case 0x28:
5278+ case 0x29:
5279+ case 0x2a:
5280+ case 0x2b:
5281+ case 0x2c:
5282+ case 0x2d:
5283+ case 0x2e:
5284+ case 0x2f:
5285+ goto op_semantics_34;
5286+ break;
5287+ case 0x30:
5288+ case 0x31:
5289+ case 0x32:
5290+ case 0x33:
5291+ case 0x34:
5292+ case 0x35:
5293+ case 0x36:
5294+ case 0x37:
5295+ case 0x38:
5296+ case 0x39:
5297+ case 0x3a:
5298+ case 0x3b:
5299+ case 0x3c:
5300+ case 0x3d:
5301+ case 0x3e:
5302+ case 0x3f:
5303+ goto op_semantics_35;
5304+ break;
5305+ case 0x90:
5306+ GETBYTE ();
5307+ switch (op[2] & 0xff)
5308+ {
5309+ case 0x00:
5310+ GETBYTE ();
5311+ switch (op[3] & 0x00)
5312+ {
5313+ case 0x00:
5314+ op_semantics_36:
5315+ {
5316+ /** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */
5317+#line 1238 "rx-decode.opc"
5318+ int srcb AU = (op[2] >> 4) & 0x0f;
5319+#line 1238 "rx-decode.opc"
5320+ int rdst AU = (op[3] >> 4) & 0x0f;
5321+#line 1238 "rx-decode.opc"
5322+ int srca AU = op[3] & 0x0f;
5323+ if (trace)
5324+ {
5325+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5326+ "/** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */",
5327+ op[0], op[1], op[2], op[3]);
5328+ printf (" srcb = 0x%x,", srcb);
5329+ printf (" rdst = 0x%x,", rdst);
5330+ printf (" srca = 0x%x\n", srca);
5331+ }
5332+ SYNTAX("dadd %1, %2, %0");
5333+#line 1238 "rx-decode.opc"
5334+ ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5335+
5336+ }
5337+ break;
5338+ }
5339+ break;
5340+ case 0x01:
5341+ GETBYTE ();
5342+ switch (op[3] & 0x00)
5343+ {
5344+ case 0x00:
5345+ op_semantics_37:
5346+ {
5347+ /** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */
5348+#line 1259 "rx-decode.opc"
5349+ int srcb AU = (op[2] >> 4) & 0x0f;
5350+#line 1259 "rx-decode.opc"
5351+ int rdst AU = (op[3] >> 4) & 0x0f;
5352+#line 1259 "rx-decode.opc"
5353+ int srca AU = op[3] & 0x0f;
5354+ if (trace)
5355+ {
5356+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5357+ "/** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */",
5358+ op[0], op[1], op[2], op[3]);
5359+ printf (" srcb = 0x%x,", srcb);
5360+ printf (" rdst = 0x%x,", rdst);
5361+ printf (" srca = 0x%x\n", srca);
5362+ }
5363+ SYNTAX("dsub %1, %2, %0");
5364+#line 1259 "rx-decode.opc"
5365+ ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5366+
5367+ }
5368+ break;
5369+ }
5370+ break;
5371+ case 0x02:
5372+ GETBYTE ();
5373+ switch (op[3] & 0x00)
5374+ {
5375+ case 0x00:
5376+ op_semantics_38:
5377+ {
5378+ /** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */
5379+#line 1247 "rx-decode.opc"
5380+ int srcb AU = (op[2] >> 4) & 0x0f;
5381+#line 1247 "rx-decode.opc"
5382+ int rdst AU = (op[3] >> 4) & 0x0f;
5383+#line 1247 "rx-decode.opc"
5384+ int srca AU = op[3] & 0x0f;
5385+ if (trace)
5386+ {
5387+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5388+ "/** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */",
5389+ op[0], op[1], op[2], op[3]);
5390+ printf (" srcb = 0x%x,", srcb);
5391+ printf (" rdst = 0x%x,", rdst);
5392+ printf (" srca = 0x%x\n", srca);
5393+ }
5394+ SYNTAX("dmul %1, %2, %0");
5395+#line 1247 "rx-decode.opc"
5396+ ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5397+
5398+ }
5399+ break;
5400+ }
5401+ break;
5402+ case 0x05:
5403+ GETBYTE ();
5404+ switch (op[3] & 0x00)
5405+ {
5406+ case 0x00:
5407+ op_semantics_39:
5408+ {
5409+ /** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */
5410+#line 1244 "rx-decode.opc"
5411+ int srcb AU = (op[2] >> 4) & 0x0f;
5412+#line 1244 "rx-decode.opc"
5413+ int rdst AU = (op[3] >> 4) & 0x0f;
5414+#line 1244 "rx-decode.opc"
5415+ int srca AU = op[3] & 0x0f;
5416+ if (trace)
5417+ {
5418+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5419+ "/** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */",
5420+ op[0], op[1], op[2], op[3]);
5421+ printf (" srcb = 0x%x,", srcb);
5422+ printf (" rdst = 0x%x,", rdst);
5423+ printf (" srca = 0x%x\n", srca);
5424+ }
5425+ SYNTAX("ddiv %1, %2, %0");
5426+#line 1244 "rx-decode.opc"
5427+ ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5428+
5429+ }
5430+ break;
5431+ }
5432+ break;
5433+ case 0x08:
5434+ GETBYTE ();
5435+ switch (op[3] & 0x00)
5436+ {
5437+ case 0x00:
5438+ op_semantics_40:
5439+ {
5440+ /** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */
5441+#line 1241 "rx-decode.opc"
5442+ int srcb AU = (op[2] >> 4) & 0x0f;
5443+#line 1241 "rx-decode.opc"
5444+ int cond AU = (op[3] >> 4) & 0x0f;
5445+#line 1241 "rx-decode.opc"
5446+ int srca AU = op[3] & 0x0f;
5447+ if (trace)
5448+ {
5449+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5450+ "/** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */",
5451+ op[0], op[1], op[2], op[3]);
5452+ printf (" srcb = 0x%x,", srcb);
5453+ printf (" cond = 0x%x,", cond);
5454+ printf (" srca = 0x%x\n", srca);
5455+ }
5456+ SYNTAX("dcmp%0 %1, %2");
5457+#line 1241 "rx-decode.opc"
5458+ ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____;
5459+
5460+ }
5461+ break;
5462+ }
5463+ break;
5464+ case 0x0c:
5465+ GETBYTE ();
5466+ switch (op[3] & 0x0f)
5467+ {
5468+ case 0x00:
5469+ op_semantics_41:
5470+ {
5471+ /** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */
5472+#line 1179 "rx-decode.opc"
5473+ int rsrc AU = (op[2] >> 4) & 0x0f;
5474+#line 1179 "rx-decode.opc"
5475+ int rdst AU = (op[3] >> 4) & 0x0f;
5476+ if (trace)
5477+ {
5478+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5479+ "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */",
5480+ op[0], op[1], op[2], op[3]);
5481+ printf (" rsrc = 0x%x,", rsrc);
5482+ printf (" rdst = 0x%x\n", rdst);
5483+ }
5484+ SYNTAX("dmov.d %1, %0");
5485+#line 1179 "rx-decode.opc"
5486+ ID(dmov); DDR(rdst); SDR(rsrc); F_____;
5487+
5488+ }
5489+ break;
5490+ case 0x01:
5491+ op_semantics_42:
5492+ {
5493+ /** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */
5494+#line 1235 "rx-decode.opc"
5495+ int rsrc AU = (op[2] >> 4) & 0x0f;
5496+#line 1235 "rx-decode.opc"
5497+ int rdst AU = (op[3] >> 4) & 0x0f;
5498+ if (trace)
5499+ {
5500+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5501+ "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */",
5502+ op[0], op[1], op[2], op[3]);
5503+ printf (" rsrc = 0x%x,", rsrc);
5504+ printf (" rdst = 0x%x\n", rdst);
5505+ }
5506+ SYNTAX("dabs %1, %0");
5507+#line 1235 "rx-decode.opc"
5508+ ID(dabs); DDR(rdst); SDR(rsrc); F_____;
5509+
5510+ }
5511+ break;
5512+ case 0x02:
5513+ op_semantics_43:
5514+ {
5515+ /** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */
5516+#line 1250 "rx-decode.opc"
5517+ int rsrc AU = (op[2] >> 4) & 0x0f;
5518+#line 1250 "rx-decode.opc"
5519+ int rdst AU = (op[3] >> 4) & 0x0f;
5520+ if (trace)
5521+ {
5522+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5523+ "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */",
5524+ op[0], op[1], op[2], op[3]);
5525+ printf (" rsrc = 0x%x,", rsrc);
5526+ printf (" rdst = 0x%x\n", rdst);
5527+ }
5528+ SYNTAX("dneg %1, %0");
5529+#line 1250 "rx-decode.opc"
5530+ ID(dneg); DDR(rdst); SDR(rsrc); F_____;
5531+
5532+ }
5533+ break;
5534+ default: UNSUPPORTED(); break;
5535+ }
5536+ break;
5537+ case 0x0d:
5538+ GETBYTE ();
5539+ switch (op[3] & 0x0f)
5540+ {
5541+ case 0x00:
5542+ op_semantics_44:
5543+ {
5544+ /** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */
5545+#line 1256 "rx-decode.opc"
5546+ int rsrc AU = (op[2] >> 4) & 0x0f;
5547+#line 1256 "rx-decode.opc"
5548+ int rdst AU = (op[3] >> 4) & 0x0f;
5549+ if (trace)
5550+ {
5551+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5552+ "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */",
5553+ op[0], op[1], op[2], op[3]);
5554+ printf (" rsrc = 0x%x,", rsrc);
5555+ printf (" rdst = 0x%x\n", rdst);
5556+ }
5557+ SYNTAX("dsqrt %1, %0");
5558+#line 1256 "rx-decode.opc"
5559+ ID(dsqrt); DDR(rdst); SDR(rsrc); F_____;
5560+
5561+ }
5562+ break;
5563+ case 0x08:
5564+ op_semantics_45:
5565+ {
5566+ /** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */
5567+#line 1265 "rx-decode.opc"
5568+ int rsrc AU = (op[2] >> 4) & 0x0f;
5569+#line 1265 "rx-decode.opc"
5570+ int rdst AU = (op[3] >> 4) & 0x0f;
5571+ if (trace)
5572+ {
5573+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5574+ "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */",
5575+ op[0], op[1], op[2], op[3]);
5576+ printf (" rsrc = 0x%x,", rsrc);
5577+ printf (" rdst = 0x%x\n", rdst);
5578+ }
5579+ SYNTAX("dtoi %1, %0");
5580+#line 1265 "rx-decode.opc"
5581+ ID(dtoi); DDR(rdst); SDR(rsrc); F_____;
5582+
5583+ }
5584+ break;
5585+ case 0x09:
5586+ op_semantics_46:
5587+ {
5588+ /** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */
5589+#line 1268 "rx-decode.opc"
5590+ int rsrc AU = (op[2] >> 4) & 0x0f;
5591+#line 1268 "rx-decode.opc"
5592+ int rdst AU = (op[3] >> 4) & 0x0f;
5593+ if (trace)
5594+ {
5595+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5596+ "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */",
5597+ op[0], op[1], op[2], op[3]);
5598+ printf (" rsrc = 0x%x,", rsrc);
5599+ printf (" rdst = 0x%x\n", rdst);
5600+ }
5601+ SYNTAX("dtou %1, %0");
5602+#line 1268 "rx-decode.opc"
5603+ ID(dtou); DDR(rdst); SDR(rsrc); F_____;
5604+
5605+ }
5606+ break;
5607+ case 0x0c:
5608+ op_semantics_47:
5609+ {
5610+ /** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */
5611+#line 1262 "rx-decode.opc"
5612+ int rsrc AU = (op[2] >> 4) & 0x0f;
5613+#line 1262 "rx-decode.opc"
5614+ int rdst AU = (op[3] >> 4) & 0x0f;
5615+ if (trace)
5616+ {
5617+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5618+ "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */",
5619+ op[0], op[1], op[2], op[3]);
5620+ printf (" rsrc = 0x%x,", rsrc);
5621+ printf (" rdst = 0x%x\n", rdst);
5622+ }
5623+ SYNTAX("dtof %1, %0");
5624+#line 1262 "rx-decode.opc"
5625+ ID(dtof); DDR(rdst); SDR(rsrc); F_____;
5626+
5627+ }
5628+ break;
5629+ case 0x0d:
5630+ op_semantics_48:
5631+ {
5632+ /** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */
5633+#line 1253 "rx-decode.opc"
5634+ int rsrc AU = (op[2] >> 4) & 0x0f;
5635+#line 1253 "rx-decode.opc"
5636+ int rdst AU = (op[3] >> 4) & 0x0f;
5637+ if (trace)
5638+ {
5639+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
5640+ "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */",
5641+ op[0], op[1], op[2], op[3]);
5642+ printf (" rsrc = 0x%x,", rsrc);
5643+ printf (" rdst = 0x%x\n", rdst);
5644+ }
5645+ SYNTAX("dround %1, %0");
5646+#line 1253 "rx-decode.opc"
5647+ ID(dround); DDR(rdst); SDR(rsrc); F_____;
5648+
5649+ }
5650+ break;
5651+ default: UNSUPPORTED(); break;
5652+ }
5653+ break;
5654+ case 0x10:
5655+ GETBYTE ();
5656+ switch (op[3] & 0x00)
5657+ {
5658+ case 0x00:
5659+ goto op_semantics_36;
5660+ break;
5661+ }
5662+ break;
5663+ case 0x11:
5664+ GETBYTE ();
5665+ switch (op[3] & 0x00)
5666+ {
5667+ case 0x00:
5668+ goto op_semantics_37;
5669+ break;
5670+ }
5671+ break;
5672+ case 0x12:
5673+ GETBYTE ();
5674+ switch (op[3] & 0x00)
5675+ {
5676+ case 0x00:
5677+ goto op_semantics_38;
5678+ break;
5679+ }
5680+ break;
5681+ case 0x15:
5682+ GETBYTE ();
5683+ switch (op[3] & 0x00)
5684+ {
5685+ case 0x00:
5686+ goto op_semantics_39;
5687+ break;
5688+ }
5689+ break;
5690+ case 0x18:
5691+ GETBYTE ();
5692+ switch (op[3] & 0x00)
5693+ {
5694+ case 0x00:
5695+ goto op_semantics_40;
5696+ break;
5697+ }
5698+ break;
5699+ case 0x1c:
5700+ GETBYTE ();
5701+ switch (op[3] & 0x0f)
5702+ {
5703+ case 0x00:
5704+ goto op_semantics_41;
5705+ break;
5706+ case 0x01:
5707+ goto op_semantics_42;
5708+ break;
5709+ case 0x02:
5710+ goto op_semantics_43;
5711+ break;
5712+ default: UNSUPPORTED(); break;
5713+ }
5714+ break;
5715+ case 0x1d:
5716+ GETBYTE ();
5717+ switch (op[3] & 0x0f)
5718+ {
5719+ case 0x00:
5720+ goto op_semantics_44;
5721+ break;
5722+ case 0x08:
5723+ goto op_semantics_45;
5724+ break;
5725+ case 0x09:
5726+ goto op_semantics_46;
5727+ break;
5728+ case 0x0c:
5729+ goto op_semantics_47;
5730+ break;
5731+ case 0x0d:
5732+ goto op_semantics_48;
5733+ break;
5734+ default: UNSUPPORTED(); break;
5735+ }
5736+ break;
5737+ case 0x20:
5738+ GETBYTE ();
5739+ switch (op[3] & 0x00)
5740+ {
5741+ case 0x00:
5742+ goto op_semantics_36;
5743+ break;
5744+ }
5745+ break;
5746+ case 0x21:
5747+ GETBYTE ();
5748+ switch (op[3] & 0x00)
5749+ {
5750+ case 0x00:
5751+ goto op_semantics_37;
5752+ break;
5753+ }
5754+ break;
5755+ case 0x22:
5756+ GETBYTE ();
5757+ switch (op[3] & 0x00)
5758+ {
5759+ case 0x00:
5760+ goto op_semantics_38;
5761+ break;
5762+ }
5763+ break;
5764+ case 0x25:
5765+ GETBYTE ();
5766+ switch (op[3] & 0x00)
5767+ {
5768+ case 0x00:
5769+ goto op_semantics_39;
5770+ break;
5771+ }
5772+ break;
5773+ case 0x28:
5774+ GETBYTE ();
5775+ switch (op[3] & 0x00)
5776+ {
5777+ case 0x00:
5778+ goto op_semantics_40;
5779+ break;
5780+ }
5781+ break;
5782+ case 0x2c:
5783+ GETBYTE ();
5784+ switch (op[3] & 0x0f)
5785+ {
5786+ case 0x00:
5787+ goto op_semantics_41;
5788+ break;
5789+ case 0x01:
5790+ goto op_semantics_42;
5791+ break;
5792+ case 0x02:
5793+ goto op_semantics_43;
5794+ break;
5795+ default: UNSUPPORTED(); break;
5796+ }
5797+ break;
5798+ case 0x2d:
5799+ GETBYTE ();
5800+ switch (op[3] & 0x0f)
5801+ {
5802+ case 0x00:
5803+ goto op_semantics_44;
5804+ break;
5805+ case 0x08:
5806+ goto op_semantics_45;
5807+ break;
5808+ case 0x09:
5809+ goto op_semantics_46;
5810+ break;
5811+ case 0x0c:
5812+ goto op_semantics_47;
5813+ break;
5814+ case 0x0d:
5815+ goto op_semantics_48;
5816+ break;
5817+ default: UNSUPPORTED(); break;
5818+ }
5819+ break;
5820+ case 0x30:
5821+ GETBYTE ();
5822+ switch (op[3] & 0x00)
5823+ {
5824+ case 0x00:
5825+ goto op_semantics_36;
5826+ break;
5827+ }
5828+ break;
5829+ case 0x31:
5830+ GETBYTE ();
5831+ switch (op[3] & 0x00)
5832+ {
5833+ case 0x00:
5834+ goto op_semantics_37;
5835+ break;
5836+ }
5837+ break;
5838+ case 0x32:
5839+ GETBYTE ();
5840+ switch (op[3] & 0x00)
5841+ {
5842+ case 0x00:
5843+ goto op_semantics_38;
5844+ break;
5845+ }
5846+ break;
5847+ case 0x35:
5848+ GETBYTE ();
5849+ switch (op[3] & 0x00)
5850+ {
5851+ case 0x00:
5852+ goto op_semantics_39;
5853+ break;
5854+ }
5855+ break;
5856+ case 0x38:
5857+ GETBYTE ();
5858+ switch (op[3] & 0x00)
5859+ {
5860+ case 0x00:
5861+ goto op_semantics_40;
5862+ break;
5863+ }
5864+ break;
5865+ case 0x3c:
5866+ GETBYTE ();
5867+ switch (op[3] & 0x0f)
5868+ {
5869+ case 0x00:
5870+ goto op_semantics_41;
5871+ break;
5872+ case 0x01:
5873+ goto op_semantics_42;
5874+ break;
5875+ case 0x02:
5876+ goto op_semantics_43;
5877+ break;
5878+ default: UNSUPPORTED(); break;
5879+ }
5880+ break;
5881+ case 0x3d:
5882+ GETBYTE ();
5883+ switch (op[3] & 0x0f)
5884+ {
5885+ case 0x00:
5886+ goto op_semantics_44;
5887+ break;
5888+ case 0x08:
5889+ goto op_semantics_45;
5890+ break;
5891+ case 0x09:
5892+ goto op_semantics_46;
5893+ break;
5894+ case 0x0c:
5895+ goto op_semantics_47;
5896+ break;
5897+ case 0x0d:
5898+ goto op_semantics_48;
5899+ break;
5900+ default: UNSUPPORTED(); break;
5901+ }
5902+ break;
5903+ case 0x40:
5904+ GETBYTE ();
5905+ switch (op[3] & 0x00)
5906+ {
5907+ case 0x00:
5908+ goto op_semantics_36;
5909+ break;
5910+ }
5911+ break;
5912+ case 0x41:
5913+ GETBYTE ();
5914+ switch (op[3] & 0x00)
5915+ {
5916+ case 0x00:
5917+ goto op_semantics_37;
5918+ break;
5919+ }
5920+ break;
5921+ case 0x42:
5922+ GETBYTE ();
5923+ switch (op[3] & 0x00)
5924+ {
5925+ case 0x00:
5926+ goto op_semantics_38;
5927+ break;
5928+ }
5929+ break;
5930+ case 0x45:
5931+ GETBYTE ();
5932+ switch (op[3] & 0x00)
5933+ {
5934+ case 0x00:
5935+ goto op_semantics_39;
5936+ break;
5937+ }
5938+ break;
5939+ case 0x48:
5940+ GETBYTE ();
5941+ switch (op[3] & 0x00)
5942+ {
5943+ case 0x00:
5944+ goto op_semantics_40;
5945+ break;
5946+ }
5947+ break;
5948+ case 0x4c:
5949+ GETBYTE ();
5950+ switch (op[3] & 0x0f)
5951+ {
5952+ case 0x00:
5953+ goto op_semantics_41;
5954+ break;
5955+ case 0x01:
5956+ goto op_semantics_42;
5957+ break;
5958+ case 0x02:
5959+ goto op_semantics_43;
5960+ break;
5961+ default: UNSUPPORTED(); break;
5962+ }
5963+ break;
5964+ case 0x4d:
5965+ GETBYTE ();
5966+ switch (op[3] & 0x0f)
5967+ {
5968+ case 0x00:
5969+ goto op_semantics_44;
5970+ break;
5971+ case 0x08:
5972+ goto op_semantics_45;
5973+ break;
5974+ case 0x09:
5975+ goto op_semantics_46;
5976+ break;
5977+ case 0x0c:
5978+ goto op_semantics_47;
5979+ break;
5980+ case 0x0d:
5981+ goto op_semantics_48;
5982+ break;
5983+ default: UNSUPPORTED(); break;
5984+ }
5985+ break;
5986+ case 0x50:
5987+ GETBYTE ();
5988+ switch (op[3] & 0x00)
5989+ {
5990+ case 0x00:
5991+ goto op_semantics_36;
5992+ break;
5993+ }
5994+ break;
5995+ case 0x51:
5996+ GETBYTE ();
5997+ switch (op[3] & 0x00)
5998+ {
5999+ case 0x00:
6000+ goto op_semantics_37;
6001+ break;
6002+ }
6003+ break;
6004+ case 0x52:
6005+ GETBYTE ();
6006+ switch (op[3] & 0x00)
6007+ {
6008+ case 0x00:
6009+ goto op_semantics_38;
6010+ break;
6011+ }
6012+ break;
6013+ case 0x55:
6014+ GETBYTE ();
6015+ switch (op[3] & 0x00)
6016+ {
6017+ case 0x00:
6018+ goto op_semantics_39;
6019+ break;
6020+ }
6021+ break;
6022+ case 0x58:
6023+ GETBYTE ();
6024+ switch (op[3] & 0x00)
6025+ {
6026+ case 0x00:
6027+ goto op_semantics_40;
6028+ break;
6029+ }
6030+ break;
6031+ case 0x5c:
6032+ GETBYTE ();
6033+ switch (op[3] & 0x0f)
6034+ {
6035+ case 0x00:
6036+ goto op_semantics_41;
6037+ break;
6038+ case 0x01:
6039+ goto op_semantics_42;
6040+ break;
6041+ case 0x02:
6042+ goto op_semantics_43;
6043+ break;
6044+ default: UNSUPPORTED(); break;
6045+ }
6046+ break;
6047+ case 0x5d:
6048+ GETBYTE ();
6049+ switch (op[3] & 0x0f)
6050+ {
6051+ case 0x00:
6052+ goto op_semantics_44;
6053+ break;
6054+ case 0x08:
6055+ goto op_semantics_45;
6056+ break;
6057+ case 0x09:
6058+ goto op_semantics_46;
6059+ break;
6060+ case 0x0c:
6061+ goto op_semantics_47;
6062+ break;
6063+ case 0x0d:
6064+ goto op_semantics_48;
6065+ break;
6066+ default: UNSUPPORTED(); break;
6067+ }
6068+ break;
6069+ case 0x60:
6070+ GETBYTE ();
6071+ switch (op[3] & 0x00)
6072+ {
6073+ case 0x00:
6074+ goto op_semantics_36;
6075+ break;
6076+ }
6077+ break;
6078+ case 0x61:
6079+ GETBYTE ();
6080+ switch (op[3] & 0x00)
6081+ {
6082+ case 0x00:
6083+ goto op_semantics_37;
6084+ break;
6085+ }
6086+ break;
6087+ case 0x62:
6088+ GETBYTE ();
6089+ switch (op[3] & 0x00)
6090+ {
6091+ case 0x00:
6092+ goto op_semantics_38;
6093+ break;
6094+ }
6095+ break;
6096+ case 0x65:
6097+ GETBYTE ();
6098+ switch (op[3] & 0x00)
6099+ {
6100+ case 0x00:
6101+ goto op_semantics_39;
6102+ break;
6103+ }
6104+ break;
6105+ case 0x68:
6106+ GETBYTE ();
6107+ switch (op[3] & 0x00)
6108+ {
6109+ case 0x00:
6110+ goto op_semantics_40;
6111+ break;
6112+ }
6113+ break;
6114+ case 0x6c:
6115+ GETBYTE ();
6116+ switch (op[3] & 0x0f)
6117+ {
6118+ case 0x00:
6119+ goto op_semantics_41;
6120+ break;
6121+ case 0x01:
6122+ goto op_semantics_42;
6123+ break;
6124+ case 0x02:
6125+ goto op_semantics_43;
6126+ break;
6127+ default: UNSUPPORTED(); break;
6128+ }
6129+ break;
6130+ case 0x6d:
6131+ GETBYTE ();
6132+ switch (op[3] & 0x0f)
6133+ {
6134+ case 0x00:
6135+ goto op_semantics_44;
6136+ break;
6137+ case 0x08:
6138+ goto op_semantics_45;
6139+ break;
6140+ case 0x09:
6141+ goto op_semantics_46;
6142+ break;
6143+ case 0x0c:
6144+ goto op_semantics_47;
6145+ break;
6146+ case 0x0d:
6147+ goto op_semantics_48;
6148+ break;
6149+ default: UNSUPPORTED(); break;
6150+ }
6151+ break;
6152+ case 0x70:
6153+ GETBYTE ();
6154+ switch (op[3] & 0x00)
6155+ {
6156+ case 0x00:
6157+ goto op_semantics_36;
6158+ break;
6159+ }
6160+ break;
6161+ case 0x71:
6162+ GETBYTE ();
6163+ switch (op[3] & 0x00)
6164+ {
6165+ case 0x00:
6166+ goto op_semantics_37;
6167+ break;
6168+ }
6169+ break;
6170+ case 0x72:
6171+ GETBYTE ();
6172+ switch (op[3] & 0x00)
6173+ {
6174+ case 0x00:
6175+ goto op_semantics_38;
6176+ break;
6177+ }
6178+ break;
6179+ case 0x75:
6180+ GETBYTE ();
6181+ switch (op[3] & 0x00)
6182+ {
6183+ case 0x00:
6184+ goto op_semantics_39;
6185+ break;
6186+ }
6187+ break;
6188+ case 0x78:
6189+ GETBYTE ();
6190+ switch (op[3] & 0x00)
6191+ {
6192+ case 0x00:
6193+ goto op_semantics_40;
6194+ break;
6195+ }
6196+ break;
6197+ case 0x7c:
6198+ GETBYTE ();
6199+ switch (op[3] & 0x0f)
6200+ {
6201+ case 0x00:
6202+ goto op_semantics_41;
6203+ break;
6204+ case 0x01:
6205+ goto op_semantics_42;
6206+ break;
6207+ case 0x02:
6208+ goto op_semantics_43;
6209+ break;
6210+ default: UNSUPPORTED(); break;
6211+ }
6212+ break;
6213+ case 0x7d:
6214+ GETBYTE ();
6215+ switch (op[3] & 0x0f)
6216+ {
6217+ case 0x00:
6218+ goto op_semantics_44;
6219+ break;
6220+ case 0x08:
6221+ goto op_semantics_45;
6222+ break;
6223+ case 0x09:
6224+ goto op_semantics_46;
6225+ break;
6226+ case 0x0c:
6227+ goto op_semantics_47;
6228+ break;
6229+ case 0x0d:
6230+ goto op_semantics_48;
6231+ break;
6232+ default: UNSUPPORTED(); break;
6233+ }
6234+ break;
6235+ case 0x80:
6236+ GETBYTE ();
6237+ switch (op[3] & 0x00)
6238+ {
6239+ case 0x00:
6240+ goto op_semantics_36;
6241+ break;
6242+ }
6243+ break;
6244+ case 0x81:
6245+ GETBYTE ();
6246+ switch (op[3] & 0x00)
6247+ {
6248+ case 0x00:
6249+ goto op_semantics_37;
6250+ break;
6251+ }
6252+ break;
6253+ case 0x82:
6254+ GETBYTE ();
6255+ switch (op[3] & 0x00)
6256+ {
6257+ case 0x00:
6258+ goto op_semantics_38;
6259+ break;
6260+ }
6261+ break;
6262+ case 0x85:
6263+ GETBYTE ();
6264+ switch (op[3] & 0x00)
6265+ {
6266+ case 0x00:
6267+ goto op_semantics_39;
6268+ break;
6269+ }
6270+ break;
6271+ case 0x88:
6272+ GETBYTE ();
6273+ switch (op[3] & 0x00)
6274+ {
6275+ case 0x00:
6276+ goto op_semantics_40;
6277+ break;
6278+ }
6279+ break;
6280+ case 0x8c:
6281+ GETBYTE ();
6282+ switch (op[3] & 0x0f)
6283+ {
6284+ case 0x00:
6285+ goto op_semantics_41;
6286+ break;
6287+ case 0x01:
6288+ goto op_semantics_42;
6289+ break;
6290+ case 0x02:
6291+ goto op_semantics_43;
6292+ break;
6293+ default: UNSUPPORTED(); break;
6294+ }
6295+ break;
6296+ case 0x8d:
6297+ GETBYTE ();
6298+ switch (op[3] & 0x0f)
6299+ {
6300+ case 0x00:
6301+ goto op_semantics_44;
6302+ break;
6303+ case 0x08:
6304+ goto op_semantics_45;
6305+ break;
6306+ case 0x09:
6307+ goto op_semantics_46;
6308+ break;
6309+ case 0x0c:
6310+ goto op_semantics_47;
6311+ break;
6312+ case 0x0d:
6313+ goto op_semantics_48;
6314+ break;
6315+ default: UNSUPPORTED(); break;
6316+ }
6317+ break;
6318+ case 0x90:
6319+ GETBYTE ();
6320+ switch (op[3] & 0x00)
6321+ {
6322+ case 0x00:
6323+ goto op_semantics_36;
6324+ break;
6325+ }
6326+ break;
6327+ case 0x91:
6328+ GETBYTE ();
6329+ switch (op[3] & 0x00)
6330+ {
6331+ case 0x00:
6332+ goto op_semantics_37;
6333+ break;
6334+ }
6335+ break;
6336+ case 0x92:
6337+ GETBYTE ();
6338+ switch (op[3] & 0x00)
6339+ {
6340+ case 0x00:
6341+ goto op_semantics_38;
6342+ break;
6343+ }
6344+ break;
6345+ case 0x95:
6346+ GETBYTE ();
6347+ switch (op[3] & 0x00)
6348+ {
6349+ case 0x00:
6350+ goto op_semantics_39;
6351+ break;
6352+ }
6353+ break;
6354+ case 0x98:
6355+ GETBYTE ();
6356+ switch (op[3] & 0x00)
6357+ {
6358+ case 0x00:
6359+ goto op_semantics_40;
6360+ break;
6361+ }
6362+ break;
6363+ case 0x9c:
6364+ GETBYTE ();
6365+ switch (op[3] & 0x0f)
6366+ {
6367+ case 0x00:
6368+ goto op_semantics_41;
6369+ break;
6370+ case 0x01:
6371+ goto op_semantics_42;
6372+ break;
6373+ case 0x02:
6374+ goto op_semantics_43;
6375+ break;
6376+ default: UNSUPPORTED(); break;
6377+ }
6378+ break;
6379+ case 0x9d:
6380+ GETBYTE ();
6381+ switch (op[3] & 0x0f)
6382+ {
6383+ case 0x00:
6384+ goto op_semantics_44;
6385+ break;
6386+ case 0x08:
6387+ goto op_semantics_45;
6388+ break;
6389+ case 0x09:
6390+ goto op_semantics_46;
6391+ break;
6392+ case 0x0c:
6393+ goto op_semantics_47;
6394+ break;
6395+ case 0x0d:
6396+ goto op_semantics_48;
6397+ break;
6398+ default: UNSUPPORTED(); break;
6399+ }
6400+ break;
6401+ case 0xa0:
6402+ GETBYTE ();
6403+ switch (op[3] & 0x00)
6404+ {
6405+ case 0x00:
6406+ goto op_semantics_36;
6407+ break;
6408+ }
6409+ break;
6410+ case 0xa1:
6411+ GETBYTE ();
6412+ switch (op[3] & 0x00)
6413+ {
6414+ case 0x00:
6415+ goto op_semantics_37;
6416+ break;
6417+ }
6418+ break;
6419+ case 0xa2:
6420+ GETBYTE ();
6421+ switch (op[3] & 0x00)
6422+ {
6423+ case 0x00:
6424+ goto op_semantics_38;
6425+ break;
6426+ }
6427+ break;
6428+ case 0xa5:
6429+ GETBYTE ();
6430+ switch (op[3] & 0x00)
6431+ {
6432+ case 0x00:
6433+ goto op_semantics_39;
6434+ break;
6435+ }
6436+ break;
6437+ case 0xa8:
6438+ GETBYTE ();
6439+ switch (op[3] & 0x00)
6440+ {
6441+ case 0x00:
6442+ goto op_semantics_40;
6443+ break;
6444+ }
6445+ break;
6446+ case 0xac:
6447+ GETBYTE ();
6448+ switch (op[3] & 0x0f)
6449+ {
6450+ case 0x00:
6451+ goto op_semantics_41;
6452+ break;
6453+ case 0x01:
6454+ goto op_semantics_42;
6455+ break;
6456+ case 0x02:
6457+ goto op_semantics_43;
6458+ break;
6459+ default: UNSUPPORTED(); break;
6460+ }
6461+ break;
6462+ case 0xad:
6463+ GETBYTE ();
6464+ switch (op[3] & 0x0f)
6465+ {
6466+ case 0x00:
6467+ goto op_semantics_44;
6468+ break;
6469+ case 0x08:
6470+ goto op_semantics_45;
6471+ break;
6472+ case 0x09:
6473+ goto op_semantics_46;
6474+ break;
6475+ case 0x0c:
6476+ goto op_semantics_47;
6477+ break;
6478+ case 0x0d:
6479+ goto op_semantics_48;
6480+ break;
6481+ default: UNSUPPORTED(); break;
6482+ }
6483+ break;
6484+ case 0xb0:
6485+ GETBYTE ();
6486+ switch (op[3] & 0x00)
6487+ {
6488+ case 0x00:
6489+ goto op_semantics_36;
6490+ break;
6491+ }
6492+ break;
6493+ case 0xb1:
6494+ GETBYTE ();
6495+ switch (op[3] & 0x00)
6496+ {
6497+ case 0x00:
6498+ goto op_semantics_37;
6499+ break;
6500+ }
6501+ break;
6502+ case 0xb2:
6503+ GETBYTE ();
6504+ switch (op[3] & 0x00)
6505+ {
6506+ case 0x00:
6507+ goto op_semantics_38;
6508+ break;
6509+ }
6510+ break;
6511+ case 0xb5:
6512+ GETBYTE ();
6513+ switch (op[3] & 0x00)
6514+ {
6515+ case 0x00:
6516+ goto op_semantics_39;
6517+ break;
6518+ }
6519+ break;
6520+ case 0xb8:
6521+ GETBYTE ();
6522+ switch (op[3] & 0x00)
6523+ {
6524+ case 0x00:
6525+ goto op_semantics_40;
6526+ break;
6527+ }
6528+ break;
6529+ case 0xbc:
6530+ GETBYTE ();
6531+ switch (op[3] & 0x0f)
6532+ {
6533+ case 0x00:
6534+ goto op_semantics_41;
6535+ break;
6536+ case 0x01:
6537+ goto op_semantics_42;
6538+ break;
6539+ case 0x02:
6540+ goto op_semantics_43;
6541+ break;
6542+ default: UNSUPPORTED(); break;
6543+ }
6544+ break;
6545+ case 0xbd:
6546+ GETBYTE ();
6547+ switch (op[3] & 0x0f)
6548+ {
6549+ case 0x00:
6550+ goto op_semantics_44;
6551+ break;
6552+ case 0x08:
6553+ goto op_semantics_45;
6554+ break;
6555+ case 0x09:
6556+ goto op_semantics_46;
6557+ break;
6558+ case 0x0c:
6559+ goto op_semantics_47;
6560+ break;
6561+ case 0x0d:
6562+ goto op_semantics_48;
6563+ break;
6564+ default: UNSUPPORTED(); break;
6565+ }
6566+ break;
6567+ case 0xc0:
6568+ GETBYTE ();
6569+ switch (op[3] & 0x00)
6570+ {
6571+ case 0x00:
6572+ goto op_semantics_36;
6573+ break;
6574+ }
6575+ break;
6576+ case 0xc1:
6577+ GETBYTE ();
6578+ switch (op[3] & 0x00)
6579+ {
6580+ case 0x00:
6581+ goto op_semantics_37;
6582+ break;
6583+ }
6584+ break;
6585+ case 0xc2:
6586+ GETBYTE ();
6587+ switch (op[3] & 0x00)
6588+ {
6589+ case 0x00:
6590+ goto op_semantics_38;
6591+ break;
6592+ }
6593+ break;
6594+ case 0xc5:
6595+ GETBYTE ();
6596+ switch (op[3] & 0x00)
6597+ {
6598+ case 0x00:
6599+ goto op_semantics_39;
6600+ break;
6601+ }
6602+ break;
6603+ case 0xc8:
6604+ GETBYTE ();
6605+ switch (op[3] & 0x00)
6606+ {
6607+ case 0x00:
6608+ goto op_semantics_40;
6609+ break;
6610+ }
6611+ break;
6612+ case 0xcc:
6613+ GETBYTE ();
6614+ switch (op[3] & 0x0f)
6615+ {
6616+ case 0x00:
6617+ goto op_semantics_41;
6618+ break;
6619+ case 0x01:
6620+ goto op_semantics_42;
6621+ break;
6622+ case 0x02:
6623+ goto op_semantics_43;
6624+ break;
6625+ default: UNSUPPORTED(); break;
6626+ }
6627+ break;
6628+ case 0xcd:
6629+ GETBYTE ();
6630+ switch (op[3] & 0x0f)
6631+ {
6632+ case 0x00:
6633+ goto op_semantics_44;
6634+ break;
6635+ case 0x08:
6636+ goto op_semantics_45;
6637+ break;
6638+ case 0x09:
6639+ goto op_semantics_46;
6640+ break;
6641+ case 0x0c:
6642+ goto op_semantics_47;
6643+ break;
6644+ case 0x0d:
6645+ goto op_semantics_48;
6646+ break;
6647+ default: UNSUPPORTED(); break;
6648+ }
6649+ break;
6650+ case 0xd0:
6651+ GETBYTE ();
6652+ switch (op[3] & 0x00)
6653+ {
6654+ case 0x00:
6655+ goto op_semantics_36;
6656+ break;
6657+ }
6658+ break;
6659+ case 0xd1:
6660+ GETBYTE ();
6661+ switch (op[3] & 0x00)
6662+ {
6663+ case 0x00:
6664+ goto op_semantics_37;
6665+ break;
6666+ }
6667+ break;
6668+ case 0xd2:
6669+ GETBYTE ();
6670+ switch (op[3] & 0x00)
6671+ {
6672+ case 0x00:
6673+ goto op_semantics_38;
6674+ break;
6675+ }
6676+ break;
6677+ case 0xd5:
6678+ GETBYTE ();
6679+ switch (op[3] & 0x00)
6680+ {
6681+ case 0x00:
6682+ goto op_semantics_39;
6683+ break;
6684+ }
6685+ break;
6686+ case 0xd8:
6687+ GETBYTE ();
6688+ switch (op[3] & 0x00)
6689+ {
6690+ case 0x00:
6691+ goto op_semantics_40;
6692+ break;
6693+ }
6694+ break;
6695+ case 0xdc:
6696+ GETBYTE ();
6697+ switch (op[3] & 0x0f)
6698+ {
6699+ case 0x00:
6700+ goto op_semantics_41;
6701+ break;
6702+ case 0x01:
6703+ goto op_semantics_42;
6704+ break;
6705+ case 0x02:
6706+ goto op_semantics_43;
6707+ break;
6708+ default: UNSUPPORTED(); break;
6709+ }
6710+ break;
6711+ case 0xdd:
6712+ GETBYTE ();
6713+ switch (op[3] & 0x0f)
6714+ {
6715+ case 0x00:
6716+ goto op_semantics_44;
6717+ break;
6718+ case 0x08:
6719+ goto op_semantics_45;
6720+ break;
6721+ case 0x09:
6722+ goto op_semantics_46;
6723+ break;
6724+ case 0x0c:
6725+ goto op_semantics_47;
6726+ break;
6727+ case 0x0d:
6728+ goto op_semantics_48;
6729+ break;
6730+ default: UNSUPPORTED(); break;
6731+ }
6732+ break;
6733+ case 0xe0:
6734+ GETBYTE ();
6735+ switch (op[3] & 0x00)
6736+ {
6737+ case 0x00:
6738+ goto op_semantics_36;
6739+ break;
6740+ }
6741+ break;
6742+ case 0xe1:
6743+ GETBYTE ();
6744+ switch (op[3] & 0x00)
6745+ {
6746+ case 0x00:
6747+ goto op_semantics_37;
6748+ break;
6749+ }
6750+ break;
6751+ case 0xe2:
6752+ GETBYTE ();
6753+ switch (op[3] & 0x00)
6754+ {
6755+ case 0x00:
6756+ goto op_semantics_38;
6757+ break;
6758+ }
6759+ break;
6760+ case 0xe5:
6761+ GETBYTE ();
6762+ switch (op[3] & 0x00)
6763+ {
6764+ case 0x00:
6765+ goto op_semantics_39;
6766+ break;
6767+ }
6768+ break;
6769+ case 0xe8:
6770+ GETBYTE ();
6771+ switch (op[3] & 0x00)
6772+ {
6773+ case 0x00:
6774+ goto op_semantics_40;
6775+ break;
6776+ }
6777+ break;
6778+ case 0xec:
6779+ GETBYTE ();
6780+ switch (op[3] & 0x0f)
6781+ {
6782+ case 0x00:
6783+ goto op_semantics_41;
6784+ break;
6785+ case 0x01:
6786+ goto op_semantics_42;
6787+ break;
6788+ case 0x02:
6789+ goto op_semantics_43;
6790+ break;
6791+ default: UNSUPPORTED(); break;
6792+ }
6793+ break;
6794+ case 0xed:
6795+ GETBYTE ();
6796+ switch (op[3] & 0x0f)
6797+ {
6798+ case 0x00:
6799+ goto op_semantics_44;
6800+ break;
6801+ case 0x08:
6802+ goto op_semantics_45;
6803+ break;
6804+ case 0x09:
6805+ goto op_semantics_46;
6806+ break;
6807+ case 0x0c:
6808+ goto op_semantics_47;
6809+ break;
6810+ case 0x0d:
6811+ goto op_semantics_48;
6812+ break;
6813+ default: UNSUPPORTED(); break;
6814+ }
6815+ break;
6816+ case 0xf0:
6817+ GETBYTE ();
6818+ switch (op[3] & 0x00)
6819+ {
6820+ case 0x00:
6821+ goto op_semantics_36;
6822+ break;
6823+ }
6824+ break;
6825+ case 0xf1:
6826+ GETBYTE ();
6827+ switch (op[3] & 0x00)
6828+ {
6829+ case 0x00:
6830+ goto op_semantics_37;
6831+ break;
6832+ }
6833+ break;
6834+ case 0xf2:
6835+ GETBYTE ();
6836+ switch (op[3] & 0x00)
6837+ {
6838+ case 0x00:
6839+ goto op_semantics_38;
6840+ break;
6841+ }
6842+ break;
6843+ case 0xf5:
6844+ GETBYTE ();
6845+ switch (op[3] & 0x00)
6846+ {
6847+ case 0x00:
6848+ goto op_semantics_39;
6849+ break;
6850+ }
6851+ break;
6852+ case 0xf8:
6853+ GETBYTE ();
6854+ switch (op[3] & 0x00)
6855+ {
6856+ case 0x00:
6857+ goto op_semantics_40;
6858+ break;
6859+ }
6860+ break;
6861+ case 0xfc:
6862+ GETBYTE ();
6863+ switch (op[3] & 0x0f)
6864+ {
6865+ case 0x00:
6866+ goto op_semantics_41;
6867+ break;
6868+ case 0x01:
6869+ goto op_semantics_42;
6870+ break;
6871+ case 0x02:
6872+ goto op_semantics_43;
6873+ break;
6874+ default: UNSUPPORTED(); break;
6875+ }
6876+ break;
6877+ case 0xfd:
6878+ GETBYTE ();
6879+ switch (op[3] & 0x0f)
6880+ {
6881+ case 0x00:
6882+ goto op_semantics_44;
6883+ break;
6884+ case 0x08:
6885+ goto op_semantics_45;
6886+ break;
6887+ case 0x09:
6888+ goto op_semantics_46;
6889+ break;
6890+ case 0x0c:
6891+ goto op_semantics_47;
6892+ break;
6893+ case 0x0d:
6894+ goto op_semantics_48;
6895+ break;
6896+ default: UNSUPPORTED(); break;
6897+ }
6898+ break;
6899+ default: UNSUPPORTED(); break;
6900+ }
6901+ break;
6902+ default: UNSUPPORTED(); break;
6903+ }
6904+ break;
6905+ case 0x77:
6906+ GETBYTE ();
6907+ switch (op[1] & 0xf0)
6908+ {
6909+ case 0x00:
6910+ goto op_semantics_32;
6911+ break;
6912+ case 0x10:
6913+ goto op_semantics_33;
6914+ break;
6915+ case 0x20:
6916+ goto op_semantics_34;
6917+ break;
6918+ case 0x30:
6919+ goto op_semantics_35;
6920+ break;
6921+ default: UNSUPPORTED(); break;
6922+ }
6923+ break;
6924+ case 0x78:
6925+ GETBYTE ();
6926+ switch (op[1] & 0x00)
6927+ {
6928+ case 0x00:
6929+ op_semantics_49:
6930+ {
6931+ /** 0111 100b ittt rdst bset #%1, %0 */
6932+#line 968 "rx-decode.opc"
6933+ int b AU = op[0] & 0x01;
6934+#line 968 "rx-decode.opc"
6935+ int ittt AU = (op[1] >> 4) & 0x0f;
6936+#line 968 "rx-decode.opc"
6937+ int rdst AU = op[1] & 0x0f;
6938+ if (trace)
6939+ {
6940+ printf ("\033[33m%s\033[0m %02x %02x\n",
6941+ "/** 0111 100b ittt rdst bset #%1, %0 */",
6942+ op[0], op[1]);
6943+ printf (" b = 0x%x,", b);
6944+ printf (" ittt = 0x%x,", ittt);
6945+ printf (" rdst = 0x%x\n", rdst);
6946+ }
6947+ SYNTAX("bset #%1, %0");
6948+#line 968 "rx-decode.opc"
6949+ ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6950+
6951+
6952+ }
6953+ break;
6954+ }
6955+ break;
6956+ case 0x79:
6957+ GETBYTE ();
6958+ switch (op[1] & 0x00)
6959+ {
6960+ case 0x00:
6961+ goto op_semantics_49;
6962+ break;
6963+ }
6964+ break;
6965+ case 0x7a:
6966+ GETBYTE ();
6967+ switch (op[1] & 0x00)
6968+ {
6969+ case 0x00:
6970+ op_semantics_50:
6971+ {
6972+ /** 0111 101b ittt rdst bclr #%1, %0 */
6973+#line 980 "rx-decode.opc"
6974+ int b AU = op[0] & 0x01;
6975+#line 980 "rx-decode.opc"
6976+ int ittt AU = (op[1] >> 4) & 0x0f;
6977+#line 980 "rx-decode.opc"
6978+ int rdst AU = op[1] & 0x0f;
6979+ if (trace)
6980+ {
6981+ printf ("\033[33m%s\033[0m %02x %02x\n",
6982+ "/** 0111 101b ittt rdst bclr #%1, %0 */",
6983+ op[0], op[1]);
6984+ printf (" b = 0x%x,", b);
6985+ printf (" ittt = 0x%x,", ittt);
6986+ printf (" rdst = 0x%x\n", rdst);
6987+ }
6988+ SYNTAX("bclr #%1, %0");
6989+#line 980 "rx-decode.opc"
6990+ ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6991+
6992+
6993+ }
6994+ break;
6995+ }
6996+ break;
6997+ case 0x7b:
6998+ GETBYTE ();
6999+ switch (op[1] & 0x00)
7000+ {
7001+ case 0x00:
7002+ goto op_semantics_50;
7003+ break;
7004+ }
7005+ break;
7006+ case 0x7c:
7007+ GETBYTE ();
7008+ switch (op[1] & 0x00)
7009+ {
7010+ case 0x00:
7011+ op_semantics_51:
7012+ {
7013+ /** 0111 110b ittt rdst btst #%2, %1 */
7014+#line 992 "rx-decode.opc"
7015+ int b AU = op[0] & 0x01;
7016+#line 992 "rx-decode.opc"
7017+ int ittt AU = (op[1] >> 4) & 0x0f;
7018+#line 992 "rx-decode.opc"
7019+ int rdst AU = op[1] & 0x0f;
7020+ if (trace)
7021+ {
7022+ printf ("\033[33m%s\033[0m %02x %02x\n",
7023+ "/** 0111 110b ittt rdst btst #%2, %1 */",
7024+ op[0], op[1]);
7025+ printf (" b = 0x%x,", b);
7026+ printf (" ittt = 0x%x,", ittt);
7027+ printf (" rdst = 0x%x\n", rdst);
7028+ }
7029+ SYNTAX("btst #%2, %1");
7030+#line 992 "rx-decode.opc"
7031+ ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
7032+
7033+
7034+ }
7035+ break;
7036+ }
7037+ break;
7038+ case 0x7d:
7039+ GETBYTE ();
7040+ switch (op[1] & 0x00)
7041+ {
7042+ case 0x00:
7043+ goto op_semantics_51;
7044+ break;
7045+ }
7046+ break;
7047+ case 0x7e:
7048+ GETBYTE ();
7049+ switch (op[1] & 0xf0)
7050+ {
7051+ case 0x00:
7052+ {
7053+ /** 0111 1110 0000 rdst not %0 */
7054+#line 483 "rx-decode.opc"
52987055 int rdst AU = op[1] & 0x0f;
52997056 if (trace)
53007057 {
53017058 printf ("\033[33m%s\033[0m %02x %02x\n",
5302- "/** 0111 1110 0011 rdst sat %0 */",
7059+ "/** 0111 1110 0000 rdst not %0 */",
7060+ op[0], op[1]);
7061+ printf (" rdst = 0x%x\n", rdst);
7062+ }
7063+ SYNTAX("not %0");
7064+#line 483 "rx-decode.opc"
7065+ ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
7066+
7067+ }
7068+ break;
7069+ case 0x10:
7070+ {
7071+ /** 0111 1110 0001 rdst neg %0 */
7072+#line 504 "rx-decode.opc"
7073+ int rdst AU = op[1] & 0x0f;
7074+ if (trace)
7075+ {
7076+ printf ("\033[33m%s\033[0m %02x %02x\n",
7077+ "/** 0111 1110 0001 rdst neg %0 */",
7078+ op[0], op[1]);
7079+ printf (" rdst = 0x%x\n", rdst);
7080+ }
7081+ SYNTAX("neg %0");
7082+#line 504 "rx-decode.opc"
7083+ ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
7084+
7085+ }
7086+ break;
7087+ case 0x20:
7088+ {
7089+ /** 0111 1110 0010 rdst abs %0 */
7090+#line 586 "rx-decode.opc"
7091+ int rdst AU = op[1] & 0x0f;
7092+ if (trace)
7093+ {
7094+ printf ("\033[33m%s\033[0m %02x %02x\n",
7095+ "/** 0111 1110 0010 rdst abs %0 */",
7096+ op[0], op[1]);
7097+ printf (" rdst = 0x%x\n", rdst);
7098+ }
7099+ SYNTAX("abs %0");
7100+#line 586 "rx-decode.opc"
7101+ ID(abs); DR(rdst); SR(rdst); F_OSZ_;
7102+
7103+ }
7104+ break;
7105+ case 0x30:
7106+ {
7107+ /** 0111 1110 0011 rdst sat %0 */
7108+#line 906 "rx-decode.opc"
7109+ int rdst AU = op[1] & 0x0f;
7110+ if (trace)
7111+ {
7112+ printf ("\033[33m%s\033[0m %02x %02x\n",
7113+ "/** 0111 1110 0011 rdst sat %0 */",
7114+ op[0], op[1]);
7115+ printf (" rdst = 0x%x\n", rdst);
7116+ }
7117+ SYNTAX("sat %0");
7118+#line 906 "rx-decode.opc"
7119+ ID(sat); DR (rdst);
7120+
7121+ }
7122+ break;
7123+ case 0x40:
7124+ {
7125+ /** 0111 1110 0100 rdst rorc %0 */
7126+#line 766 "rx-decode.opc"
7127+ int rdst AU = op[1] & 0x0f;
7128+ if (trace)
7129+ {
7130+ printf ("\033[33m%s\033[0m %02x %02x\n",
7131+ "/** 0111 1110 0100 rdst rorc %0 */",
7132+ op[0], op[1]);
7133+ printf (" rdst = 0x%x\n", rdst);
7134+ }
7135+ SYNTAX("rorc %0");
7136+#line 766 "rx-decode.opc"
7137+ ID(rorc); DR(rdst); F__SZC;
7138+
7139+ }
7140+ break;
7141+ case 0x50:
7142+ {
7143+ /** 0111 1110 0101 rdst rolc %0 */
7144+#line 763 "rx-decode.opc"
7145+ int rdst AU = op[1] & 0x0f;
7146+ if (trace)
7147+ {
7148+ printf ("\033[33m%s\033[0m %02x %02x\n",
7149+ "/** 0111 1110 0101 rdst rolc %0 */",
7150+ op[0], op[1]);
7151+ printf (" rdst = 0x%x\n", rdst);
7152+ }
7153+ SYNTAX("rolc %0");
7154+#line 763 "rx-decode.opc"
7155+ ID(rolc); DR(rdst); F__SZC;
7156+
7157+ }
7158+ break;
7159+ case 0x80:
7160+ case 0x90:
7161+ case 0xa0:
7162+ {
7163+ /** 0111 1110 10sz rsrc push%s %1 */
7164+#line 399 "rx-decode.opc"
7165+ int sz AU = (op[1] >> 4) & 0x03;
7166+#line 399 "rx-decode.opc"
7167+ int rsrc AU = op[1] & 0x0f;
7168+ if (trace)
7169+ {
7170+ printf ("\033[33m%s\033[0m %02x %02x\n",
7171+ "/** 0111 1110 10sz rsrc push%s %1 */",
7172+ op[0], op[1]);
7173+ printf (" sz = 0x%x,", sz);
7174+ printf (" rsrc = 0x%x\n", rsrc);
7175+ }
7176+ SYNTAX("push%s %1");
7177+#line 399 "rx-decode.opc"
7178+ ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7179+
7180+ }
7181+ break;
7182+ case 0xb0:
7183+ {
7184+ /** 0111 1110 1011 rdst pop %0 */
7185+#line 396 "rx-decode.opc"
7186+ int rdst AU = op[1] & 0x0f;
7187+ if (trace)
7188+ {
7189+ printf ("\033[33m%s\033[0m %02x %02x\n",
7190+ "/** 0111 1110 1011 rdst pop %0 */",
7191+ op[0], op[1]);
7192+ printf (" rdst = 0x%x\n", rdst);
7193+ }
7194+ SYNTAX("pop %0");
7195+#line 396 "rx-decode.opc"
7196+ ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7197+
7198+ }
7199+ break;
7200+ case 0xc0:
7201+ case 0xd0:
7202+ {
7203+ /** 0111 1110 110 crsrc pushc %1 */
7204+#line 1029 "rx-decode.opc"
7205+ int crsrc AU = op[1] & 0x1f;
7206+ if (trace)
7207+ {
7208+ printf ("\033[33m%s\033[0m %02x %02x\n",
7209+ "/** 0111 1110 110 crsrc pushc %1 */",
7210+ op[0], op[1]);
7211+ printf (" crsrc = 0x%x\n", crsrc);
7212+ }
7213+ SYNTAX("pushc %1");
7214+#line 1029 "rx-decode.opc"
7215+ ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7216+
7217+ }
7218+ break;
7219+ case 0xe0:
7220+ case 0xf0:
7221+ {
7222+ /** 0111 1110 111 crdst popc %0 */
7223+#line 1026 "rx-decode.opc"
7224+ int crdst AU = op[1] & 0x1f;
7225+ if (trace)
7226+ {
7227+ printf ("\033[33m%s\033[0m %02x %02x\n",
7228+ "/** 0111 1110 111 crdst popc %0 */",
7229+ op[0], op[1]);
7230+ printf (" crdst = 0x%x\n", crdst);
7231+ }
7232+ SYNTAX("popc %0");
7233+#line 1026 "rx-decode.opc"
7234+ ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7235+
7236+ }
7237+ break;
7238+ default: UNSUPPORTED(); break;
7239+ }
7240+ break;
7241+ case 0x7f:
7242+ GETBYTE ();
7243+ switch (op[1] & 0xff)
7244+ {
7245+ case 0x00:
7246+ case 0x01:
7247+ case 0x02:
7248+ case 0x03:
7249+ case 0x04:
7250+ case 0x05:
7251+ case 0x06:
7252+ case 0x07:
7253+ case 0x08:
7254+ case 0x09:
7255+ case 0x0a:
7256+ case 0x0b:
7257+ case 0x0c:
7258+ case 0x0d:
7259+ case 0x0e:
7260+ case 0x0f:
7261+ {
7262+ /** 0111 1111 0000 rsrc jmp %0 */
7263+#line 816 "rx-decode.opc"
7264+ int rsrc AU = op[1] & 0x0f;
7265+ if (trace)
7266+ {
7267+ printf ("\033[33m%s\033[0m %02x %02x\n",
7268+ "/** 0111 1111 0000 rsrc jmp %0 */",
7269+ op[0], op[1]);
7270+ printf (" rsrc = 0x%x\n", rsrc);
7271+ }
7272+ SYNTAX("jmp %0");
7273+#line 816 "rx-decode.opc"
7274+ ID(branch); DR(rsrc);
7275+
7276+ }
7277+ break;
7278+ case 0x10:
7279+ case 0x11:
7280+ case 0x12:
7281+ case 0x13:
7282+ case 0x14:
7283+ case 0x15:
7284+ case 0x16:
7285+ case 0x17:
7286+ case 0x18:
7287+ case 0x19:
7288+ case 0x1a:
7289+ case 0x1b:
7290+ case 0x1c:
7291+ case 0x1d:
7292+ case 0x1e:
7293+ case 0x1f:
7294+ {
7295+ /** 0111 1111 0001 rsrc jsr %0 */
7296+#line 819 "rx-decode.opc"
7297+ int rsrc AU = op[1] & 0x0f;
7298+ if (trace)
7299+ {
7300+ printf ("\033[33m%s\033[0m %02x %02x\n",
7301+ "/** 0111 1111 0001 rsrc jsr %0 */",
7302+ op[0], op[1]);
7303+ printf (" rsrc = 0x%x\n", rsrc);
7304+ }
7305+ SYNTAX("jsr %0");
7306+#line 819 "rx-decode.opc"
7307+ ID(jsr); DR(rsrc);
7308+
7309+ }
7310+ break;
7311+ case 0x40:
7312+ case 0x41:
7313+ case 0x42:
7314+ case 0x43:
7315+ case 0x44:
7316+ case 0x45:
7317+ case 0x46:
7318+ case 0x47:
7319+ case 0x48:
7320+ case 0x49:
7321+ case 0x4a:
7322+ case 0x4b:
7323+ case 0x4c:
7324+ case 0x4d:
7325+ case 0x4e:
7326+ case 0x4f:
7327+ {
7328+ /** 0111 1111 0100 rsrc bra.l %0 */
7329+#line 812 "rx-decode.opc"
7330+ int rsrc AU = op[1] & 0x0f;
7331+ if (trace)
7332+ {
7333+ printf ("\033[33m%s\033[0m %02x %02x\n",
7334+ "/** 0111 1111 0100 rsrc bra.l %0 */",
7335+ op[0], op[1]);
7336+ printf (" rsrc = 0x%x\n", rsrc);
7337+ }
7338+ SYNTAX("bra.l %0");
7339+#line 812 "rx-decode.opc"
7340+ ID(branchrel); DR(rsrc);
7341+
7342+
7343+ }
7344+ break;
7345+ case 0x50:
7346+ case 0x51:
7347+ case 0x52:
7348+ case 0x53:
7349+ case 0x54:
7350+ case 0x55:
7351+ case 0x56:
7352+ case 0x57:
7353+ case 0x58:
7354+ case 0x59:
7355+ case 0x5a:
7356+ case 0x5b:
7357+ case 0x5c:
7358+ case 0x5d:
7359+ case 0x5e:
7360+ case 0x5f:
7361+ {
7362+ /** 0111 1111 0101 rsrc bsr.l %0 */
7363+#line 828 "rx-decode.opc"
7364+ int rsrc AU = op[1] & 0x0f;
7365+ if (trace)
7366+ {
7367+ printf ("\033[33m%s\033[0m %02x %02x\n",
7368+ "/** 0111 1111 0101 rsrc bsr.l %0 */",
7369+ op[0], op[1]);
7370+ printf (" rsrc = 0x%x\n", rsrc);
7371+ }
7372+ SYNTAX("bsr.l %0");
7373+#line 828 "rx-decode.opc"
7374+ ID(jsrrel); DR(rsrc);
7375+
7376+ }
7377+ break;
7378+ case 0x80:
7379+ case 0x81:
7380+ case 0x82:
7381+ {
7382+ /** 0111 1111 1000 00sz suntil%s */
7383+#line 852 "rx-decode.opc"
7384+ int sz AU = op[1] & 0x03;
7385+ if (trace)
7386+ {
7387+ printf ("\033[33m%s\033[0m %02x %02x\n",
7388+ "/** 0111 1111 1000 00sz suntil%s */",
7389+ op[0], op[1]);
7390+ printf (" sz = 0x%x\n", sz);
7391+ }
7392+ SYNTAX("suntil%s");
7393+#line 852 "rx-decode.opc"
7394+ ID(suntil); BWL(sz); F___ZC;
7395+
7396+ }
7397+ break;
7398+ case 0x83:
7399+ {
7400+ /** 0111 1111 1000 0011 scmpu */
7401+ if (trace)
7402+ {
7403+ printf ("\033[33m%s\033[0m %02x %02x\n",
7404+ "/** 0111 1111 1000 0011 scmpu */",
7405+ op[0], op[1]);
7406+ }
7407+ SYNTAX("scmpu");
7408+#line 843 "rx-decode.opc"
7409+ ID(scmpu); F___ZC;
7410+
7411+ }
7412+ break;
7413+ case 0x84:
7414+ case 0x85:
7415+ case 0x86:
7416+ {
7417+ /** 0111 1111 1000 01sz swhile%s */
7418+#line 855 "rx-decode.opc"
7419+ int sz AU = op[1] & 0x03;
7420+ if (trace)
7421+ {
7422+ printf ("\033[33m%s\033[0m %02x %02x\n",
7423+ "/** 0111 1111 1000 01sz swhile%s */",
7424+ op[0], op[1]);
7425+ printf (" sz = 0x%x\n", sz);
7426+ }
7427+ SYNTAX("swhile%s");
7428+#line 855 "rx-decode.opc"
7429+ ID(swhile); BWL(sz); F___ZC;
7430+
7431+ }
7432+ break;
7433+ case 0x87:
7434+ {
7435+ /** 0111 1111 1000 0111 smovu */
7436+ if (trace)
7437+ {
7438+ printf ("\033[33m%s\033[0m %02x %02x\n",
7439+ "/** 0111 1111 1000 0111 smovu */",
7440+ op[0], op[1]);
7441+ }
7442+ SYNTAX("smovu");
7443+#line 846 "rx-decode.opc"
7444+ ID(smovu);
7445+
7446+ }
7447+ break;
7448+ case 0x88:
7449+ case 0x89:
7450+ case 0x8a:
7451+ {
7452+ /** 0111 1111 1000 10sz sstr%s */
7453+#line 861 "rx-decode.opc"
7454+ int sz AU = op[1] & 0x03;
7455+ if (trace)
7456+ {
7457+ printf ("\033[33m%s\033[0m %02x %02x\n",
7458+ "/** 0111 1111 1000 10sz sstr%s */",
53037459 op[0], op[1]);
5304- printf (" rdst = 0x%x\n", rdst);
7460+ printf (" sz = 0x%x\n", sz);
53057461 }
5306- SYNTAX("sat %0");
5307-#line 885 "rx-decode.opc"
5308- ID(sat); DR (rdst);
7462+ SYNTAX("sstr%s");
7463+#line 861 "rx-decode.opc"
7464+ ID(sstr); BWL(sz);
7465+
7466+ /*----------------------------------------------------------------------*/
7467+ /* RMPA */
53097468
53107469 }
53117470 break;
5312- case 0x40:
7471+ case 0x8b:
53137472 {
5314- /** 0111 1110 0100 rdst rorc %0 */
5315-#line 745 "rx-decode.opc"
5316- int rdst AU = op[1] & 0x0f;
7473+ /** 0111 1111 1000 1011 smovb */
53177474 if (trace)
53187475 {
53197476 printf ("\033[33m%s\033[0m %02x %02x\n",
5320- "/** 0111 1110 0100 rdst rorc %0 */",
7477+ "/** 0111 1111 1000 1011 smovb */",
53217478 op[0], op[1]);
5322- printf (" rdst = 0x%x\n", rdst);
53237479 }
5324- SYNTAX("rorc %0");
5325-#line 745 "rx-decode.opc"
5326- ID(rorc); DR(rdst); F__SZC;
7480+ SYNTAX("smovb");
7481+#line 849 "rx-decode.opc"
7482+ ID(smovb);
53277483
53287484 }
53297485 break;
5330- case 0x50:
7486+ case 0x8c:
7487+ case 0x8d:
7488+ case 0x8e:
53317489 {
5332- /** 0111 1110 0101 rdst rolc %0 */
5333-#line 742 "rx-decode.opc"
5334- int rdst AU = op[1] & 0x0f;
7490+ /** 0111 1111 1000 11sz rmpa%s */
7491+#line 867 "rx-decode.opc"
7492+ int sz AU = op[1] & 0x03;
53357493 if (trace)
53367494 {
53377495 printf ("\033[33m%s\033[0m %02x %02x\n",
5338- "/** 0111 1110 0101 rdst rolc %0 */",
7496+ "/** 0111 1111 1000 11sz rmpa%s */",
53397497 op[0], op[1]);
5340- printf (" rdst = 0x%x\n", rdst);
7498+ printf (" sz = 0x%x\n", sz);
53417499 }
5342- SYNTAX("rolc %0");
5343-#line 742 "rx-decode.opc"
5344- ID(rolc); DR(rdst); F__SZC;
7500+ SYNTAX("rmpa%s");
7501+#line 867 "rx-decode.opc"
7502+ ID(rmpa); BWL(sz); F_OS__;
7503+
7504+ /*----------------------------------------------------------------------*/
7505+ /* HI/LO stuff */
53457506
53467507 }
53477508 break;
5348- case 0x80:
5349- case 0x90:
5350- case 0xa0:
7509+ case 0x8f:
53517510 {
5352- /** 0111 1110 10sz rsrc push%s %1 */
5353-#line 378 "rx-decode.opc"
5354- int sz AU = (op[1] >> 4) & 0x03;
5355-#line 378 "rx-decode.opc"
5356- int rsrc AU = op[1] & 0x0f;
7511+ /** 0111 1111 1000 1111 smovf */
53577512 if (trace)
53587513 {
53597514 printf ("\033[33m%s\033[0m %02x %02x\n",
5360- "/** 0111 1110 10sz rsrc push%s %1 */",
7515+ "/** 0111 1111 1000 1111 smovf */",
53617516 op[0], op[1]);
5362- printf (" sz = 0x%x,", sz);
5363- printf (" rsrc = 0x%x\n", rsrc);
53647517 }
5365- SYNTAX("push%s %1");
5366-#line 378 "rx-decode.opc"
5367- ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7518+ SYNTAX("smovf");
7519+#line 858 "rx-decode.opc"
7520+ ID(smovf);
53687521
53697522 }
53707523 break;
5371- case 0xb0:
7524+ case 0x93:
53727525 {
5373- /** 0111 1110 1011 rdst pop %0 */
5374-#line 375 "rx-decode.opc"
5375- int rdst AU = op[1] & 0x0f;
7526+ /** 0111 1111 1001 0011 satr */
53767527 if (trace)
53777528 {
53787529 printf ("\033[33m%s\033[0m %02x %02x\n",
5379- "/** 0111 1110 1011 rdst pop %0 */",
7530+ "/** 0111 1111 1001 0011 satr */",
53807531 op[0], op[1]);
5381- printf (" rdst = 0x%x\n", rdst);
53827532 }
5383- SYNTAX("pop %0");
5384-#line 375 "rx-decode.opc"
5385- ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7533+ SYNTAX("satr");
7534+#line 909 "rx-decode.opc"
7535+ ID(satr);
7536+
7537+ /*----------------------------------------------------------------------*/
7538+ /* FLOAT */
53867539
53877540 }
53887541 break;
5389- case 0xc0:
5390- case 0xd0:
7542+ case 0x94:
53917543 {
5392- /** 0111 1110 110 crsrc pushc %1 */
5393-#line 1008 "rx-decode.opc"
5394- int crsrc AU = op[1] & 0x1f;
7544+ /** 0111 1111 1001 0100 rtfi */
53957545 if (trace)
53967546 {
53977547 printf ("\033[33m%s\033[0m %02x %02x\n",
5398- "/** 0111 1110 110 crsrc pushc %1 */",
7548+ "/** 0111 1111 1001 0100 rtfi */",
53997549 op[0], op[1]);
5400- printf (" crsrc = 0x%x\n", crsrc);
54017550 }
5402- SYNTAX("pushc %1");
5403-#line 1008 "rx-decode.opc"
5404- ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7551+ SYNTAX("rtfi");
7552+#line 1044 "rx-decode.opc"
7553+ ID(rtfi);
54057554
54067555 }
54077556 break;
5408- case 0xe0:
5409- case 0xf0:
7557+ case 0x95:
54107558 {
5411- /** 0111 1110 111 crdst popc %0 */
5412-#line 1005 "rx-decode.opc"
5413- int crdst AU = op[1] & 0x1f;
7559+ /** 0111 1111 1001 0101 rte */
54147560 if (trace)
54157561 {
54167562 printf ("\033[33m%s\033[0m %02x %02x\n",
5417- "/** 0111 1110 111 crdst popc %0 */",
7563+ "/** 0111 1111 1001 0101 rte */",
54187564 op[0], op[1]);
5419- printf (" crdst = 0x%x\n", crdst);
54207565 }
5421- SYNTAX("popc %0");
5422-#line 1005 "rx-decode.opc"
5423- ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7566+ SYNTAX("rte");
7567+#line 1047 "rx-decode.opc"
7568+ ID(rte);
54247569
54257570 }
54267571 break;
5427- default: UNSUPPORTED(); break;
5428- }
5429- break;
5430- case 0x7f:
5431- GETBYTE ();
5432- switch (op[1] & 0xff)
5433- {
5434- case 0x00:
5435- case 0x01:
5436- case 0x02:
5437- case 0x03:
5438- case 0x04:
5439- case 0x05:
5440- case 0x06:
5441- case 0x07:
5442- case 0x08:
5443- case 0x09:
5444- case 0x0a:
5445- case 0x0b:
5446- case 0x0c:
5447- case 0x0d:
5448- case 0x0e:
5449- case 0x0f:
7572+ case 0x96:
54507573 {
5451- /** 0111 1111 0000 rsrc jmp %0 */
5452-#line 795 "rx-decode.opc"
5453- int rsrc AU = op[1] & 0x0f;
7574+ /** 0111 1111 1001 0110 wait */
54547575 if (trace)
54557576 {
54567577 printf ("\033[33m%s\033[0m %02x %02x\n",
5457- "/** 0111 1111 0000 rsrc jmp %0 */",
7578+ "/** 0111 1111 1001 0110 wait */",
54587579 op[0], op[1]);
5459- printf (" rsrc = 0x%x\n", rsrc);
54607580 }
5461- SYNTAX("jmp %0");
5462-#line 795 "rx-decode.opc"
5463- ID(branch); DR(rsrc);
7581+ SYNTAX("wait");
7582+#line 1059 "rx-decode.opc"
7583+ ID(wait);
7584+
7585+ /*----------------------------------------------------------------------*/
7586+ /* SCcnd */
54647587
54657588 }
54667589 break;
5467- case 0x10:
5468- case 0x11:
5469- case 0x12:
5470- case 0x13:
5471- case 0x14:
5472- case 0x15:
5473- case 0x16:
5474- case 0x17:
5475- case 0x18:
5476- case 0x19:
5477- case 0x1a:
5478- case 0x1b:
5479- case 0x1c:
5480- case 0x1d:
5481- case 0x1e:
5482- case 0x1f:
7590+ case 0xa0:
7591+ case 0xa1:
7592+ case 0xa2:
7593+ case 0xa3:
7594+ case 0xa4:
7595+ case 0xa5:
7596+ case 0xa6:
7597+ case 0xa7:
7598+ case 0xa8:
7599+ case 0xa9:
7600+ case 0xaa:
7601+ case 0xab:
7602+ case 0xac:
7603+ case 0xad:
7604+ case 0xae:
7605+ case 0xaf:
54837606 {
5484- /** 0111 1111 0001 rsrc jsr %0 */
5485-#line 798 "rx-decode.opc"
5486- int rsrc AU = op[1] & 0x0f;
7607+ /** 0111 1111 1010 rdst setpsw %0 */
7608+#line 1020 "rx-decode.opc"
7609+ int rdst AU = op[1] & 0x0f;
54877610 if (trace)
54887611 {
54897612 printf ("\033[33m%s\033[0m %02x %02x\n",
5490- "/** 0111 1111 0001 rsrc jsr %0 */",
7613+ "/** 0111 1111 1010 rdst setpsw %0 */",
54917614 op[0], op[1]);
5492- printf (" rsrc = 0x%x\n", rsrc);
7615+ printf (" rdst = 0x%x\n", rdst);
54937616 }
5494- SYNTAX("jsr %0");
5495-#line 798 "rx-decode.opc"
5496- ID(jsr); DR(rsrc);
7617+ SYNTAX("setpsw %0");
7618+#line 1020 "rx-decode.opc"
7619+ ID(setpsw); DF(rdst);
54977620
54987621 }
54997622 break;
5500- case 0x40:
5501- case 0x41:
5502- case 0x42:
5503- case 0x43:
5504- case 0x44:
5505- case 0x45:
5506- case 0x46:
5507- case 0x47:
5508- case 0x48:
5509- case 0x49:
5510- case 0x4a:
5511- case 0x4b:
5512- case 0x4c:
5513- case 0x4d:
5514- case 0x4e:
5515- case 0x4f:
7623+ case 0xb0:
7624+ case 0xb1:
7625+ case 0xb2:
7626+ case 0xb3:
7627+ case 0xb4:
7628+ case 0xb5:
7629+ case 0xb6:
7630+ case 0xb7:
7631+ case 0xb8:
7632+ case 0xb9:
7633+ case 0xba:
7634+ case 0xbb:
7635+ case 0xbc:
7636+ case 0xbd:
7637+ case 0xbe:
7638+ case 0xbf:
55167639 {
5517- /** 0111 1111 0100 rsrc bra.l %0 */
5518-#line 791 "rx-decode.opc"
5519- int rsrc AU = op[1] & 0x0f;
7640+ /** 0111 1111 1011 rdst clrpsw %0 */
7641+#line 1017 "rx-decode.opc"
7642+ int rdst AU = op[1] & 0x0f;
7643+ if (trace)
7644+ {
7645+ printf ("\033[33m%s\033[0m %02x %02x\n",
7646+ "/** 0111 1111 1011 rdst clrpsw %0 */",
7647+ op[0], op[1]);
7648+ printf (" rdst = 0x%x\n", rdst);
7649+ }
7650+ SYNTAX("clrpsw %0");
7651+#line 1017 "rx-decode.opc"
7652+ ID(clrpsw); DF(rdst);
7653+
7654+ }
7655+ break;
7656+ default: UNSUPPORTED(); break;
7657+ }
7658+ break;
7659+ case 0x80:
7660+ GETBYTE ();
7661+ switch (op[1] & 0x00)
7662+ {
7663+ case 0x00:
7664+ op_semantics_52:
7665+ {
7666+ /** 10sz 0dsp a dst b src mov%s %1, %0 */
7667+#line 357 "rx-decode.opc"
7668+ int sz AU = (op[0] >> 4) & 0x03;
7669+#line 357 "rx-decode.opc"
7670+ int dsp AU = op[0] & 0x07;
7671+#line 357 "rx-decode.opc"
7672+ int a AU = (op[1] >> 7) & 0x01;
7673+#line 357 "rx-decode.opc"
7674+ int dst AU = (op[1] >> 4) & 0x07;
7675+#line 357 "rx-decode.opc"
7676+ int b AU = (op[1] >> 3) & 0x01;
7677+#line 357 "rx-decode.opc"
7678+ int src AU = op[1] & 0x07;
55207679 if (trace)
55217680 {
55227681 printf ("\033[33m%s\033[0m %02x %02x\n",
5523- "/** 0111 1111 0100 rsrc bra.l %0 */",
7682+ "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
55247683 op[0], op[1]);
5525- printf (" rsrc = 0x%x\n", rsrc);
7684+ printf (" sz = 0x%x,", sz);
7685+ printf (" dsp = 0x%x,", dsp);
7686+ printf (" a = 0x%x,", a);
7687+ printf (" dst = 0x%x,", dst);
7688+ printf (" b = 0x%x,", b);
7689+ printf (" src = 0x%x\n", src);
55267690 }
5527- SYNTAX("bra.l %0");
5528-#line 791 "rx-decode.opc"
5529- ID(branchrel); DR(rsrc);
5530-
7691+ SYNTAX("mov%s %1, %0");
7692+#line 357 "rx-decode.opc"
7693+ ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
55317694
55327695 }
55337696 break;
5534- case 0x50:
5535- case 0x51:
5536- case 0x52:
5537- case 0x53:
5538- case 0x54:
5539- case 0x55:
5540- case 0x56:
5541- case 0x57:
5542- case 0x58:
5543- case 0x59:
5544- case 0x5a:
5545- case 0x5b:
5546- case 0x5c:
5547- case 0x5d:
5548- case 0x5e:
5549- case 0x5f:
7697+ }
7698+ break;
7699+ case 0x81:
7700+ GETBYTE ();
7701+ switch (op[1] & 0x00)
7702+ {
7703+ case 0x00:
7704+ goto op_semantics_52;
7705+ break;
7706+ }
7707+ break;
7708+ case 0x82:
7709+ GETBYTE ();
7710+ switch (op[1] & 0x00)
7711+ {
7712+ case 0x00:
7713+ goto op_semantics_52;
7714+ break;
7715+ }
7716+ break;
7717+ case 0x83:
7718+ GETBYTE ();
7719+ switch (op[1] & 0x00)
7720+ {
7721+ case 0x00:
7722+ goto op_semantics_52;
7723+ break;
7724+ }
7725+ break;
7726+ case 0x84:
7727+ GETBYTE ();
7728+ switch (op[1] & 0x00)
7729+ {
7730+ case 0x00:
7731+ goto op_semantics_52;
7732+ break;
7733+ }
7734+ break;
7735+ case 0x85:
7736+ GETBYTE ();
7737+ switch (op[1] & 0x00)
7738+ {
7739+ case 0x00:
7740+ goto op_semantics_52;
7741+ break;
7742+ }
7743+ break;
7744+ case 0x86:
7745+ GETBYTE ();
7746+ switch (op[1] & 0x00)
7747+ {
7748+ case 0x00:
7749+ goto op_semantics_52;
7750+ break;
7751+ }
7752+ break;
7753+ case 0x87:
7754+ GETBYTE ();
7755+ switch (op[1] & 0x00)
7756+ {
7757+ case 0x00:
7758+ goto op_semantics_52;
7759+ break;
7760+ }
7761+ break;
7762+ case 0x88:
7763+ GETBYTE ();
7764+ switch (op[1] & 0x00)
7765+ {
7766+ case 0x00:
7767+ op_semantics_53:
55507768 {
5551- /** 0111 1111 0101 rsrc bsr.l %0 */
5552-#line 807 "rx-decode.opc"
5553- int rsrc AU = op[1] & 0x0f;
7769+ /** 10sz 1dsp a src b dst mov%s %1, %0 */
7770+#line 354 "rx-decode.opc"
7771+ int sz AU = (op[0] >> 4) & 0x03;
7772+#line 354 "rx-decode.opc"
7773+ int dsp AU = op[0] & 0x07;
7774+#line 354 "rx-decode.opc"
7775+ int a AU = (op[1] >> 7) & 0x01;
7776+#line 354 "rx-decode.opc"
7777+ int src AU = (op[1] >> 4) & 0x07;
7778+#line 354 "rx-decode.opc"
7779+ int b AU = (op[1] >> 3) & 0x01;
7780+#line 354 "rx-decode.opc"
7781+ int dst AU = op[1] & 0x07;
55547782 if (trace)
55557783 {
55567784 printf ("\033[33m%s\033[0m %02x %02x\n",
5557- "/** 0111 1111 0101 rsrc bsr.l %0 */",
7785+ "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
55587786 op[0], op[1]);
5559- printf (" rsrc = 0x%x\n", rsrc);
7787+ printf (" sz = 0x%x,", sz);
7788+ printf (" dsp = 0x%x,", dsp);
7789+ printf (" a = 0x%x,", a);
7790+ printf (" src = 0x%x,", src);
7791+ printf (" b = 0x%x,", b);
7792+ printf (" dst = 0x%x\n", dst);
55607793 }
5561- SYNTAX("bsr.l %0");
5562-#line 807 "rx-decode.opc"
5563- ID(jsrrel); DR(rsrc);
7794+ SYNTAX("mov%s %1, %0");
7795+#line 354 "rx-decode.opc"
7796+ ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
55647797
55657798 }
55667799 break;
5567- case 0x80:
5568- case 0x81:
5569- case 0x82:
5570- {
5571- /** 0111 1111 1000 00sz suntil%s */
5572-#line 831 "rx-decode.opc"
5573- int sz AU = op[1] & 0x03;
5574- if (trace)
5575- {
5576- printf ("\033[33m%s\033[0m %02x %02x\n",
5577- "/** 0111 1111 1000 00sz suntil%s */",
5578- op[0], op[1]);
5579- printf (" sz = 0x%x\n", sz);
5580- }
5581- SYNTAX("suntil%s");
5582-#line 831 "rx-decode.opc"
5583- ID(suntil); BWL(sz); F___ZC;
5584-
5585- }
7800+ }
7801+ break;
7802+ case 0x89:
7803+ GETBYTE ();
7804+ switch (op[1] & 0x00)
7805+ {
7806+ case 0x00:
7807+ goto op_semantics_53;
7808+ break;
7809+ }
7810+ break;
7811+ case 0x8a:
7812+ GETBYTE ();
7813+ switch (op[1] & 0x00)
7814+ {
7815+ case 0x00:
7816+ goto op_semantics_53;
7817+ break;
7818+ }
7819+ break;
7820+ case 0x8b:
7821+ GETBYTE ();
7822+ switch (op[1] & 0x00)
7823+ {
7824+ case 0x00:
7825+ goto op_semantics_53;
7826+ break;
7827+ }
7828+ break;
7829+ case 0x8c:
7830+ GETBYTE ();
7831+ switch (op[1] & 0x00)
7832+ {
7833+ case 0x00:
7834+ goto op_semantics_53;
7835+ break;
7836+ }
7837+ break;
7838+ case 0x8d:
7839+ GETBYTE ();
7840+ switch (op[1] & 0x00)
7841+ {
7842+ case 0x00:
7843+ goto op_semantics_53;
7844+ break;
7845+ }
7846+ break;
7847+ case 0x8e:
7848+ GETBYTE ();
7849+ switch (op[1] & 0x00)
7850+ {
7851+ case 0x00:
7852+ goto op_semantics_53;
7853+ break;
7854+ }
7855+ break;
7856+ case 0x8f:
7857+ GETBYTE ();
7858+ switch (op[1] & 0x00)
7859+ {
7860+ case 0x00:
7861+ goto op_semantics_53;
7862+ break;
7863+ }
7864+ break;
7865+ case 0x90:
7866+ GETBYTE ();
7867+ switch (op[1] & 0x00)
7868+ {
7869+ case 0x00:
7870+ goto op_semantics_52;
7871+ break;
7872+ }
7873+ break;
7874+ case 0x91:
7875+ GETBYTE ();
7876+ switch (op[1] & 0x00)
7877+ {
7878+ case 0x00:
7879+ goto op_semantics_52;
7880+ break;
7881+ }
7882+ break;
7883+ case 0x92:
7884+ GETBYTE ();
7885+ switch (op[1] & 0x00)
7886+ {
7887+ case 0x00:
7888+ goto op_semantics_52;
7889+ break;
7890+ }
7891+ break;
7892+ case 0x93:
7893+ GETBYTE ();
7894+ switch (op[1] & 0x00)
7895+ {
7896+ case 0x00:
7897+ goto op_semantics_52;
7898+ break;
7899+ }
7900+ break;
7901+ case 0x94:
7902+ GETBYTE ();
7903+ switch (op[1] & 0x00)
7904+ {
7905+ case 0x00:
7906+ goto op_semantics_52;
7907+ break;
7908+ }
7909+ break;
7910+ case 0x95:
7911+ GETBYTE ();
7912+ switch (op[1] & 0x00)
7913+ {
7914+ case 0x00:
7915+ goto op_semantics_52;
7916+ break;
7917+ }
7918+ break;
7919+ case 0x96:
7920+ GETBYTE ();
7921+ switch (op[1] & 0x00)
7922+ {
7923+ case 0x00:
7924+ goto op_semantics_52;
7925+ break;
7926+ }
7927+ break;
7928+ case 0x97:
7929+ GETBYTE ();
7930+ switch (op[1] & 0x00)
7931+ {
7932+ case 0x00:
7933+ goto op_semantics_52;
7934+ break;
7935+ }
7936+ break;
7937+ case 0x98:
7938+ GETBYTE ();
7939+ switch (op[1] & 0x00)
7940+ {
7941+ case 0x00:
7942+ goto op_semantics_53;
7943+ break;
7944+ }
7945+ break;
7946+ case 0x99:
7947+ GETBYTE ();
7948+ switch (op[1] & 0x00)
7949+ {
7950+ case 0x00:
7951+ goto op_semantics_53;
7952+ break;
7953+ }
7954+ break;
7955+ case 0x9a:
7956+ GETBYTE ();
7957+ switch (op[1] & 0x00)
7958+ {
7959+ case 0x00:
7960+ goto op_semantics_53;
55867961 break;
5587- case 0x83:
5588- {
5589- /** 0111 1111 1000 0011 scmpu */
5590- if (trace)
5591- {
5592- printf ("\033[33m%s\033[0m %02x %02x\n",
5593- "/** 0111 1111 1000 0011 scmpu */",
5594- op[0], op[1]);
5595- }
5596- SYNTAX("scmpu");
5597-#line 822 "rx-decode.opc"
5598- ID(scmpu); F___ZC;
5599-
5600- }
7962+ }
7963+ break;
7964+ case 0x9b:
7965+ GETBYTE ();
7966+ switch (op[1] & 0x00)
7967+ {
7968+ case 0x00:
7969+ goto op_semantics_53;
56017970 break;
5602- case 0x84:
5603- case 0x85:
5604- case 0x86:
5605- {
5606- /** 0111 1111 1000 01sz swhile%s */
5607-#line 834 "rx-decode.opc"
5608- int sz AU = op[1] & 0x03;
5609- if (trace)
5610- {
5611- printf ("\033[33m%s\033[0m %02x %02x\n",
5612- "/** 0111 1111 1000 01sz swhile%s */",
5613- op[0], op[1]);
5614- printf (" sz = 0x%x\n", sz);
5615- }
5616- SYNTAX("swhile%s");
5617-#line 834 "rx-decode.opc"
5618- ID(swhile); BWL(sz); F___ZC;
5619-
5620- }
7971+ }
7972+ break;
7973+ case 0x9c:
7974+ GETBYTE ();
7975+ switch (op[1] & 0x00)
7976+ {
7977+ case 0x00:
7978+ goto op_semantics_53;
56217979 break;
5622- case 0x87:
5623- {
5624- /** 0111 1111 1000 0111 smovu */
5625- if (trace)
5626- {
5627- printf ("\033[33m%s\033[0m %02x %02x\n",
5628- "/** 0111 1111 1000 0111 smovu */",
5629- op[0], op[1]);
5630- }
5631- SYNTAX("smovu");
5632-#line 825 "rx-decode.opc"
5633- ID(smovu);
5634-
5635- }
7980+ }
7981+ break;
7982+ case 0x9d:
7983+ GETBYTE ();
7984+ switch (op[1] & 0x00)
7985+ {
7986+ case 0x00:
7987+ goto op_semantics_53;
56367988 break;
5637- case 0x88:
5638- case 0x89:
5639- case 0x8a:
5640- {
5641- /** 0111 1111 1000 10sz sstr%s */
5642-#line 840 "rx-decode.opc"
5643- int sz AU = op[1] & 0x03;
5644- if (trace)
5645- {
5646- printf ("\033[33m%s\033[0m %02x %02x\n",
5647- "/** 0111 1111 1000 10sz sstr%s */",
5648- op[0], op[1]);
5649- printf (" sz = 0x%x\n", sz);
5650- }
5651- SYNTAX("sstr%s");
5652-#line 840 "rx-decode.opc"
5653- ID(sstr); BWL(sz);
5654-
5655- /*----------------------------------------------------------------------*/
5656- /* RMPA */
5657-
5658- }
7989+ }
7990+ break;
7991+ case 0x9e:
7992+ GETBYTE ();
7993+ switch (op[1] & 0x00)
7994+ {
7995+ case 0x00:
7996+ goto op_semantics_53;
56597997 break;
5660- case 0x8b:
5661- {
5662- /** 0111 1111 1000 1011 smovb */
5663- if (trace)
5664- {
5665- printf ("\033[33m%s\033[0m %02x %02x\n",
5666- "/** 0111 1111 1000 1011 smovb */",
5667- op[0], op[1]);
5668- }
5669- SYNTAX("smovb");
5670-#line 828 "rx-decode.opc"
5671- ID(smovb);
5672-
5673- }
7998+ }
7999+ break;
8000+ case 0x9f:
8001+ GETBYTE ();
8002+ switch (op[1] & 0x00)
8003+ {
8004+ case 0x00:
8005+ goto op_semantics_53;
56748006 break;
5675- case 0x8c:
5676- case 0x8d:
5677- case 0x8e:
5678- {
5679- /** 0111 1111 1000 11sz rmpa%s */
5680-#line 846 "rx-decode.opc"
5681- int sz AU = op[1] & 0x03;
5682- if (trace)
5683- {
5684- printf ("\033[33m%s\033[0m %02x %02x\n",
5685- "/** 0111 1111 1000 11sz rmpa%s */",
5686- op[0], op[1]);
5687- printf (" sz = 0x%x\n", sz);
5688- }
5689- SYNTAX("rmpa%s");
5690-#line 846 "rx-decode.opc"
5691- ID(rmpa); BWL(sz); F_OS__;
5692-
5693- /*----------------------------------------------------------------------*/
5694- /* HI/LO stuff */
5695-
5696- }
8007+ }
8008+ break;
8009+ case 0xa0:
8010+ GETBYTE ();
8011+ switch (op[1] & 0x00)
8012+ {
8013+ case 0x00:
8014+ goto op_semantics_52;
56978015 break;
5698- case 0x8f:
5699- {
5700- /** 0111 1111 1000 1111 smovf */
5701- if (trace)
5702- {
5703- printf ("\033[33m%s\033[0m %02x %02x\n",
5704- "/** 0111 1111 1000 1111 smovf */",
5705- op[0], op[1]);
5706- }
5707- SYNTAX("smovf");
5708-#line 837 "rx-decode.opc"
5709- ID(smovf);
5710-
5711- }
8016+ }
8017+ break;
8018+ case 0xa1:
8019+ GETBYTE ();
8020+ switch (op[1] & 0x00)
8021+ {
8022+ case 0x00:
8023+ goto op_semantics_52;
57128024 break;
5713- case 0x93:
5714- {
5715- /** 0111 1111 1001 0011 satr */
5716- if (trace)
5717- {
5718- printf ("\033[33m%s\033[0m %02x %02x\n",
5719- "/** 0111 1111 1001 0011 satr */",
5720- op[0], op[1]);
5721- }
5722- SYNTAX("satr");
5723-#line 888 "rx-decode.opc"
5724- ID(satr);
5725-
5726- /*----------------------------------------------------------------------*/
5727- /* FLOAT */
5728-
5729- }
8025+ }
8026+ break;
8027+ case 0xa2:
8028+ GETBYTE ();
8029+ switch (op[1] & 0x00)
8030+ {
8031+ case 0x00:
8032+ goto op_semantics_52;
57308033 break;
5731- case 0x94:
5732- {
5733- /** 0111 1111 1001 0100 rtfi */
5734- if (trace)
5735- {
5736- printf ("\033[33m%s\033[0m %02x %02x\n",
5737- "/** 0111 1111 1001 0100 rtfi */",
5738- op[0], op[1]);
5739- }
5740- SYNTAX("rtfi");
5741-#line 1023 "rx-decode.opc"
5742- ID(rtfi);
5743-
5744- }
8034+ }
8035+ break;
8036+ case 0xa3:
8037+ GETBYTE ();
8038+ switch (op[1] & 0x00)
8039+ {
8040+ case 0x00:
8041+ goto op_semantics_52;
57458042 break;
5746- case 0x95:
5747- {
5748- /** 0111 1111 1001 0101 rte */
5749- if (trace)
5750- {
5751- printf ("\033[33m%s\033[0m %02x %02x\n",
5752- "/** 0111 1111 1001 0101 rte */",
5753- op[0], op[1]);
5754- }
5755- SYNTAX("rte");
5756-#line 1026 "rx-decode.opc"
5757- ID(rte);
5758-
5759- }
8043+ }
8044+ break;
8045+ case 0xa4:
8046+ GETBYTE ();
8047+ switch (op[1] & 0x00)
8048+ {
8049+ case 0x00:
8050+ goto op_semantics_52;
57608051 break;
5761- case 0x96:
5762- {
5763- /** 0111 1111 1001 0110 wait */
5764- if (trace)
5765- {
5766- printf ("\033[33m%s\033[0m %02x %02x\n",
5767- "/** 0111 1111 1001 0110 wait */",
5768- op[0], op[1]);
5769- }
5770- SYNTAX("wait");
5771-#line 1038 "rx-decode.opc"
5772- ID(wait);
5773-
5774- /*----------------------------------------------------------------------*/
5775- /* SCcnd */
5776-
5777- }
8052+ }
8053+ break;
8054+ case 0xa5:
8055+ GETBYTE ();
8056+ switch (op[1] & 0x00)
8057+ {
8058+ case 0x00:
8059+ goto op_semantics_52;
57788060 break;
5779- case 0xa0:
5780- case 0xa1:
5781- case 0xa2:
5782- case 0xa3:
5783- case 0xa4:
5784- case 0xa5:
5785- case 0xa6:
5786- case 0xa7:
5787- case 0xa8:
5788- case 0xa9:
5789- case 0xaa:
5790- case 0xab:
5791- case 0xac:
5792- case 0xad:
5793- case 0xae:
5794- case 0xaf:
5795- {
5796- /** 0111 1111 1010 rdst setpsw %0 */
5797-#line 999 "rx-decode.opc"
5798- int rdst AU = op[1] & 0x0f;
5799- if (trace)
5800- {
5801- printf ("\033[33m%s\033[0m %02x %02x\n",
5802- "/** 0111 1111 1010 rdst setpsw %0 */",
5803- op[0], op[1]);
5804- printf (" rdst = 0x%x\n", rdst);
5805- }
5806- SYNTAX("setpsw %0");
5807-#line 999 "rx-decode.opc"
5808- ID(setpsw); DF(rdst);
5809-
5810- }
8061+ }
8062+ break;
8063+ case 0xa6:
8064+ GETBYTE ();
8065+ switch (op[1] & 0x00)
8066+ {
8067+ case 0x00:
8068+ goto op_semantics_52;
58118069 break;
5812- case 0xb0:
5813- case 0xb1:
5814- case 0xb2:
5815- case 0xb3:
5816- case 0xb4:
5817- case 0xb5:
5818- case 0xb6:
5819- case 0xb7:
5820- case 0xb8:
5821- case 0xb9:
5822- case 0xba:
5823- case 0xbb:
5824- case 0xbc:
5825- case 0xbd:
5826- case 0xbe:
5827- case 0xbf:
5828- {
5829- /** 0111 1111 1011 rdst clrpsw %0 */
5830-#line 996 "rx-decode.opc"
5831- int rdst AU = op[1] & 0x0f;
5832- if (trace)
5833- {
5834- printf ("\033[33m%s\033[0m %02x %02x\n",
5835- "/** 0111 1111 1011 rdst clrpsw %0 */",
5836- op[0], op[1]);
5837- printf (" rdst = 0x%x\n", rdst);
5838- }
5839- SYNTAX("clrpsw %0");
5840-#line 996 "rx-decode.opc"
5841- ID(clrpsw); DF(rdst);
5842-
5843- }
8070+ }
8071+ break;
8072+ case 0xa7:
8073+ GETBYTE ();
8074+ switch (op[1] & 0x00)
8075+ {
8076+ case 0x00:
8077+ goto op_semantics_52;
58448078 break;
5845- default: UNSUPPORTED(); break;
58468079 }
58478080 break;
5848- case 0x80:
8081+ case 0xa8:
58498082 GETBYTE ();
58508083 switch (op[1] & 0x00)
58518084 {
58528085 case 0x00:
5853- op_semantics_39:
5854- {
5855- /** 10sz 0dsp a dst b src mov%s %1, %0 */
5856-#line 336 "rx-decode.opc"
5857- int sz AU = (op[0] >> 4) & 0x03;
5858-#line 336 "rx-decode.opc"
5859- int dsp AU = op[0] & 0x07;
5860-#line 336 "rx-decode.opc"
5861- int a AU = (op[1] >> 7) & 0x01;
5862-#line 336 "rx-decode.opc"
5863- int dst AU = (op[1] >> 4) & 0x07;
5864-#line 336 "rx-decode.opc"
5865- int b AU = (op[1] >> 3) & 0x01;
5866-#line 336 "rx-decode.opc"
5867- int src AU = op[1] & 0x07;
5868- if (trace)
5869- {
5870- printf ("\033[33m%s\033[0m %02x %02x\n",
5871- "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5872- op[0], op[1]);
5873- printf (" sz = 0x%x,", sz);
5874- printf (" dsp = 0x%x,", dsp);
5875- printf (" a = 0x%x,", a);
5876- printf (" dst = 0x%x,", dst);
5877- printf (" b = 0x%x,", b);
5878- printf (" src = 0x%x\n", src);
5879- }
5880- SYNTAX("mov%s %1, %0");
5881-#line 336 "rx-decode.opc"
5882- ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5883-
5884- }
8086+ goto op_semantics_53;
58858087 break;
58868088 }
58878089 break;
5888- case 0x81:
8090+ case 0xa9:
58898091 GETBYTE ();
58908092 switch (op[1] & 0x00)
58918093 {
58928094 case 0x00:
5893- goto op_semantics_39;
8095+ goto op_semantics_53;
58948096 break;
58958097 }
58968098 break;
5897- case 0x82:
8099+ case 0xaa:
58988100 GETBYTE ();
58998101 switch (op[1] & 0x00)
59008102 {
59018103 case 0x00:
5902- goto op_semantics_39;
8104+ goto op_semantics_53;
59038105 break;
59048106 }
59058107 break;
5906- case 0x83:
8108+ case 0xab:
59078109 GETBYTE ();
59088110 switch (op[1] & 0x00)
59098111 {
59108112 case 0x00:
5911- goto op_semantics_39;
8113+ goto op_semantics_53;
59128114 break;
59138115 }
59148116 break;
5915- case 0x84:
8117+ case 0xac:
59168118 GETBYTE ();
59178119 switch (op[1] & 0x00)
59188120 {
59198121 case 0x00:
5920- goto op_semantics_39;
8122+ goto op_semantics_53;
59218123 break;
59228124 }
59238125 break;
5924- case 0x85:
8126+ case 0xad:
59258127 GETBYTE ();
59268128 switch (op[1] & 0x00)
59278129 {
59288130 case 0x00:
5929- goto op_semantics_39;
8131+ goto op_semantics_53;
59308132 break;
59318133 }
59328134 break;
5933- case 0x86:
8135+ case 0xae:
59348136 GETBYTE ();
59358137 switch (op[1] & 0x00)
59368138 {
59378139 case 0x00:
5938- goto op_semantics_39;
8140+ goto op_semantics_53;
59398141 break;
59408142 }
59418143 break;
5942- case 0x87:
8144+ case 0xaf:
59438145 GETBYTE ();
59448146 switch (op[1] & 0x00)
59458147 {
59468148 case 0x00:
5947- goto op_semantics_39;
8149+ goto op_semantics_53;
59488150 break;
59498151 }
59508152 break;
5951- case 0x88:
8153+ case 0xb0:
59528154 GETBYTE ();
59538155 switch (op[1] & 0x00)
59548156 {
59558157 case 0x00:
5956- op_semantics_40:
8158+ op_semantics_54:
59578159 {
5958- /** 10sz 1dsp a src b dst mov%s %1, %0 */
5959-#line 333 "rx-decode.opc"
5960- int sz AU = (op[0] >> 4) & 0x03;
5961-#line 333 "rx-decode.opc"
8160+ /** 1011 w dsp a src b dst movu%s %1, %0 */
8161+#line 377 "rx-decode.opc"
8162+ int w AU = (op[0] >> 3) & 0x01;
8163+#line 377 "rx-decode.opc"
59628164 int dsp AU = op[0] & 0x07;
5963-#line 333 "rx-decode.opc"
8165+#line 377 "rx-decode.opc"
59648166 int a AU = (op[1] >> 7) & 0x01;
5965-#line 333 "rx-decode.opc"
8167+#line 377 "rx-decode.opc"
59668168 int src AU = (op[1] >> 4) & 0x07;
5967-#line 333 "rx-decode.opc"
8169+#line 377 "rx-decode.opc"
59688170 int b AU = (op[1] >> 3) & 0x01;
5969-#line 333 "rx-decode.opc"
8171+#line 377 "rx-decode.opc"
59708172 int dst AU = op[1] & 0x07;
59718173 if (trace)
59728174 {
59738175 printf ("\033[33m%s\033[0m %02x %02x\n",
5974- "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
8176+ "/** 1011 w dsp a src b dst movu%s %1, %0 */",
59758177 op[0], op[1]);
5976- printf (" sz = 0x%x,", sz);
8178+ printf (" w = 0x%x,", w);
59778179 printf (" dsp = 0x%x,", dsp);
59788180 printf (" a = 0x%x,", a);
59798181 printf (" src = 0x%x,", src);
59808182 printf (" b = 0x%x,", b);
59818183 printf (" dst = 0x%x\n", dst);
59828184 }
5983- SYNTAX("mov%s %1, %0");
5984-#line 333 "rx-decode.opc"
5985- ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
8185+ SYNTAX("movu%s %1, %0");
8186+#line 377 "rx-decode.opc"
8187+ ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
59868188
59878189 }
59888190 break;
59898191 }
59908192 break;
5991- case 0x89:
5992- GETBYTE ();
5993- switch (op[1] & 0x00)
5994- {
5995- case 0x00:
5996- goto op_semantics_40;
5997- break;
5998- }
5999- break;
6000- case 0x8a:
8193+ case 0xb1:
60018194 GETBYTE ();
60028195 switch (op[1] & 0x00)
60038196 {
60048197 case 0x00:
6005- goto op_semantics_40;
8198+ goto op_semantics_54;
60068199 break;
60078200 }
60088201 break;
6009- case 0x8b:
8202+ case 0xb2:
60108203 GETBYTE ();
60118204 switch (op[1] & 0x00)
60128205 {
60138206 case 0x00:
6014- goto op_semantics_40;
8207+ goto op_semantics_54;
60158208 break;
60168209 }
60178210 break;
6018- case 0x8c:
8211+ case 0xb3:
60198212 GETBYTE ();
60208213 switch (op[1] & 0x00)
60218214 {
60228215 case 0x00:
6023- goto op_semantics_40;
8216+ goto op_semantics_54;
60248217 break;
60258218 }
60268219 break;
6027- case 0x8d:
8220+ case 0xb4:
60288221 GETBYTE ();
60298222 switch (op[1] & 0x00)
60308223 {
60318224 case 0x00:
6032- goto op_semantics_40;
8225+ goto op_semantics_54;
60338226 break;
60348227 }
60358228 break;
6036- case 0x8e:
8229+ case 0xb5:
60378230 GETBYTE ();
60388231 switch (op[1] & 0x00)
60398232 {
60408233 case 0x00:
6041- goto op_semantics_40;
8234+ goto op_semantics_54;
60428235 break;
60438236 }
60448237 break;
6045- case 0x8f:
8238+ case 0xb6:
60468239 GETBYTE ();
60478240 switch (op[1] & 0x00)
60488241 {
60498242 case 0x00:
6050- goto op_semantics_40;
8243+ goto op_semantics_54;
60518244 break;
60528245 }
60538246 break;
6054- case 0x90:
8247+ case 0xb7:
60558248 GETBYTE ();
60568249 switch (op[1] & 0x00)
60578250 {
60588251 case 0x00:
6059- goto op_semantics_39;
8252+ goto op_semantics_54;
60608253 break;
60618254 }
60628255 break;
6063- case 0x91:
8256+ case 0xb8:
60648257 GETBYTE ();
60658258 switch (op[1] & 0x00)
60668259 {
60678260 case 0x00:
6068- goto op_semantics_39;
8261+ goto op_semantics_54;
60698262 break;
60708263 }
60718264 break;
6072- case 0x92:
8265+ case 0xb9:
60738266 GETBYTE ();
60748267 switch (op[1] & 0x00)
60758268 {
60768269 case 0x00:
6077- goto op_semantics_39;
8270+ goto op_semantics_54;
60788271 break;
60798272 }
60808273 break;
6081- case 0x93:
8274+ case 0xba:
60828275 GETBYTE ();
60838276 switch (op[1] & 0x00)
60848277 {
60858278 case 0x00:
6086- goto op_semantics_39;
8279+ goto op_semantics_54;
60878280 break;
60888281 }
60898282 break;
6090- case 0x94:
8283+ case 0xbb:
60918284 GETBYTE ();
60928285 switch (op[1] & 0x00)
60938286 {
60948287 case 0x00:
6095- goto op_semantics_39;
8288+ goto op_semantics_54;
60968289 break;
60978290 }
60988291 break;
6099- case 0x95:
8292+ case 0xbc:
61008293 GETBYTE ();
61018294 switch (op[1] & 0x00)
61028295 {
61038296 case 0x00:
6104- goto op_semantics_39;
8297+ goto op_semantics_54;
61058298 break;
61068299 }
61078300 break;
6108- case 0x96:
8301+ case 0xbd:
61098302 GETBYTE ();
61108303 switch (op[1] & 0x00)
61118304 {
61128305 case 0x00:
6113- goto op_semantics_39;
8306+ goto op_semantics_54;
61148307 break;
61158308 }
61168309 break;
6117- case 0x97:
8310+ case 0xbe:
61188311 GETBYTE ();
61198312 switch (op[1] & 0x00)
61208313 {
61218314 case 0x00:
6122- goto op_semantics_39;
8315+ goto op_semantics_54;
61238316 break;
61248317 }
61258318 break;
6126- case 0x98:
8319+ case 0xbf:
61278320 GETBYTE ();
61288321 switch (op[1] & 0x00)
61298322 {
61308323 case 0x00:
6131- goto op_semantics_40;
8324+ goto op_semantics_54;
61328325 break;
61338326 }
61348327 break;
6135- case 0x99:
8328+ case 0xc0:
61368329 GETBYTE ();
61378330 switch (op[1] & 0x00)
61388331 {
61398332 case 0x00:
6140- goto op_semantics_40;
8333+ op_semantics_55:
8334+ {
8335+ /** 11sz sd ss rsrc rdst mov%s %1, %0 */
8336+#line 335 "rx-decode.opc"
8337+ int sz AU = (op[0] >> 4) & 0x03;
8338+#line 335 "rx-decode.opc"
8339+ int sd AU = (op[0] >> 2) & 0x03;
8340+#line 335 "rx-decode.opc"
8341+ int ss AU = op[0] & 0x03;
8342+#line 335 "rx-decode.opc"
8343+ int rsrc AU = (op[1] >> 4) & 0x0f;
8344+#line 335 "rx-decode.opc"
8345+ int rdst AU = op[1] & 0x0f;
8346+ if (trace)
8347+ {
8348+ printf ("\033[33m%s\033[0m %02x %02x\n",
8349+ "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
8350+ op[0], op[1]);
8351+ printf (" sz = 0x%x,", sz);
8352+ printf (" sd = 0x%x,", sd);
8353+ printf (" ss = 0x%x,", ss);
8354+ printf (" rsrc = 0x%x,", rsrc);
8355+ printf (" rdst = 0x%x\n", rdst);
8356+ }
8357+ SYNTAX("mov%s %1, %0");
8358+#line 335 "rx-decode.opc"
8359+ if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
8360+ {
8361+ ID(nop2);
8362+ SYNTAX ("nop\t; mov.l\tr0, r0");
8363+ }
8364+ else
8365+ {
8366+ ID(mov); sBWL(sz); F_____;
8367+ if ((ss == 3) && (sd != 3))
8368+ {
8369+ SD(ss, rdst, sz); DD(sd, rsrc, sz);
8370+ }
8371+ else
8372+ {
8373+ SD(ss, rsrc, sz); DD(sd, rdst, sz);
8374+ }
8375+ }
8376+
8377+ }
61418378 break;
61428379 }
61438380 break;
6144- case 0x9a:
8381+ case 0xc1:
61458382 GETBYTE ();
61468383 switch (op[1] & 0x00)
61478384 {
61488385 case 0x00:
6149- goto op_semantics_40;
8386+ goto op_semantics_55;
61508387 break;
61518388 }
61528389 break;
6153- case 0x9b:
8390+ case 0xc2:
61548391 GETBYTE ();
61558392 switch (op[1] & 0x00)
61568393 {
61578394 case 0x00:
6158- goto op_semantics_40;
8395+ goto op_semantics_55;
61598396 break;
61608397 }
61618398 break;
6162- case 0x9c:
8399+ case 0xc3:
61638400 GETBYTE ();
61648401 switch (op[1] & 0x00)
61658402 {
61668403 case 0x00:
6167- goto op_semantics_40;
8404+ goto op_semantics_55;
61688405 break;
61698406 }
61708407 break;
6171- case 0x9d:
8408+ case 0xc4:
61728409 GETBYTE ();
61738410 switch (op[1] & 0x00)
61748411 {
61758412 case 0x00:
6176- goto op_semantics_40;
8413+ goto op_semantics_55;
61778414 break;
61788415 }
61798416 break;
6180- case 0x9e:
8417+ case 0xc5:
61818418 GETBYTE ();
61828419 switch (op[1] & 0x00)
61838420 {
61848421 case 0x00:
6185- goto op_semantics_40;
8422+ goto op_semantics_55;
61868423 break;
61878424 }
61888425 break;
6189- case 0x9f:
8426+ case 0xc6:
61908427 GETBYTE ();
61918428 switch (op[1] & 0x00)
61928429 {
61938430 case 0x00:
6194- goto op_semantics_40;
8431+ goto op_semantics_55;
61958432 break;
61968433 }
61978434 break;
6198- case 0xa0:
8435+ case 0xc7:
61998436 GETBYTE ();
62008437 switch (op[1] & 0x00)
62018438 {
62028439 case 0x00:
6203- goto op_semantics_39;
8440+ goto op_semantics_55;
62048441 break;
62058442 }
62068443 break;
6207- case 0xa1:
8444+ case 0xc8:
62088445 GETBYTE ();
62098446 switch (op[1] & 0x00)
62108447 {
62118448 case 0x00:
6212- goto op_semantics_39;
8449+ goto op_semantics_55;
62138450 break;
62148451 }
62158452 break;
6216- case 0xa2:
8453+ case 0xc9:
62178454 GETBYTE ();
62188455 switch (op[1] & 0x00)
62198456 {
62208457 case 0x00:
6221- goto op_semantics_39;
8458+ goto op_semantics_55;
62228459 break;
62238460 }
62248461 break;
6225- case 0xa3:
8462+ case 0xca:
62268463 GETBYTE ();
62278464 switch (op[1] & 0x00)
62288465 {
62298466 case 0x00:
6230- goto op_semantics_39;
8467+ goto op_semantics_55;
62318468 break;
62328469 }
62338470 break;
6234- case 0xa4:
8471+ case 0xcb:
62358472 GETBYTE ();
62368473 switch (op[1] & 0x00)
62378474 {
62388475 case 0x00:
6239- goto op_semantics_39;
8476+ goto op_semantics_55;
62408477 break;
62418478 }
62428479 break;
6243- case 0xa5:
8480+ case 0xcc:
62448481 GETBYTE ();
62458482 switch (op[1] & 0x00)
62468483 {
62478484 case 0x00:
6248- goto op_semantics_39;
8485+ goto op_semantics_55;
62498486 break;
62508487 }
62518488 break;
6252- case 0xa6:
8489+ case 0xcd:
62538490 GETBYTE ();
62548491 switch (op[1] & 0x00)
62558492 {
62568493 case 0x00:
6257- goto op_semantics_39;
8494+ goto op_semantics_55;
62588495 break;
62598496 }
62608497 break;
6261- case 0xa7:
8498+ case 0xce:
62628499 GETBYTE ();
62638500 switch (op[1] & 0x00)
62648501 {
62658502 case 0x00:
6266- goto op_semantics_39;
8503+ goto op_semantics_55;
62678504 break;
62688505 }
62698506 break;
6270- case 0xa8:
8507+ case 0xcf:
62718508 GETBYTE ();
62728509 switch (op[1] & 0x00)
62738510 {
62748511 case 0x00:
6275- goto op_semantics_40;
8512+ goto op_semantics_55;
62768513 break;
62778514 }
62788515 break;
6279- case 0xa9:
8516+ case 0xd0:
62808517 GETBYTE ();
62818518 switch (op[1] & 0x00)
62828519 {
62838520 case 0x00:
6284- goto op_semantics_40;
8521+ goto op_semantics_55;
62858522 break;
62868523 }
62878524 break;
6288- case 0xaa:
8525+ case 0xd1:
62898526 GETBYTE ();
62908527 switch (op[1] & 0x00)
62918528 {
62928529 case 0x00:
6293- goto op_semantics_40;
8530+ goto op_semantics_55;
62948531 break;
62958532 }
62968533 break;
6297- case 0xab:
8534+ case 0xd2:
62988535 GETBYTE ();
62998536 switch (op[1] & 0x00)
63008537 {
63018538 case 0x00:
6302- goto op_semantics_40;
8539+ goto op_semantics_55;
63038540 break;
63048541 }
63058542 break;
6306- case 0xac:
8543+ case 0xd3:
63078544 GETBYTE ();
63088545 switch (op[1] & 0x00)
63098546 {
63108547 case 0x00:
6311- goto op_semantics_40;
8548+ goto op_semantics_55;
63128549 break;
63138550 }
63148551 break;
6315- case 0xad:
8552+ case 0xd4:
63168553 GETBYTE ();
63178554 switch (op[1] & 0x00)
63188555 {
63198556 case 0x00:
6320- goto op_semantics_40;
8557+ goto op_semantics_55;
63218558 break;
63228559 }
63238560 break;
6324- case 0xae:
8561+ case 0xd5:
63258562 GETBYTE ();
63268563 switch (op[1] & 0x00)
63278564 {
63288565 case 0x00:
6329- goto op_semantics_40;
8566+ goto op_semantics_55;
63308567 break;
63318568 }
63328569 break;
6333- case 0xaf:
8570+ case 0xd6:
63348571 GETBYTE ();
63358572 switch (op[1] & 0x00)
63368573 {
63378574 case 0x00:
6338- goto op_semantics_40;
8575+ goto op_semantics_55;
63398576 break;
63408577 }
63418578 break;
6342- case 0xb0:
8579+ case 0xd7:
63438580 GETBYTE ();
63448581 switch (op[1] & 0x00)
63458582 {
63468583 case 0x00:
6347- op_semantics_41:
6348- {
6349- /** 1011 w dsp a src b dst movu%s %1, %0 */
6350-#line 356 "rx-decode.opc"
6351- int w AU = (op[0] >> 3) & 0x01;
6352-#line 356 "rx-decode.opc"
6353- int dsp AU = op[0] & 0x07;
6354-#line 356 "rx-decode.opc"
6355- int a AU = (op[1] >> 7) & 0x01;
6356-#line 356 "rx-decode.opc"
6357- int src AU = (op[1] >> 4) & 0x07;
6358-#line 356 "rx-decode.opc"
6359- int b AU = (op[1] >> 3) & 0x01;
6360-#line 356 "rx-decode.opc"
6361- int dst AU = op[1] & 0x07;
6362- if (trace)
6363- {
6364- printf ("\033[33m%s\033[0m %02x %02x\n",
6365- "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6366- op[0], op[1]);
6367- printf (" w = 0x%x,", w);
6368- printf (" dsp = 0x%x,", dsp);
6369- printf (" a = 0x%x,", a);
6370- printf (" src = 0x%x,", src);
6371- printf (" b = 0x%x,", b);
6372- printf (" dst = 0x%x\n", dst);
6373- }
6374- SYNTAX("movu%s %1, %0");
6375-#line 356 "rx-decode.opc"
6376- ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6377-
6378- }
8584+ goto op_semantics_55;
63798585 break;
63808586 }
63818587 break;
6382- case 0xb1:
8588+ case 0xd8:
63838589 GETBYTE ();
63848590 switch (op[1] & 0x00)
63858591 {
63868592 case 0x00:
6387- goto op_semantics_41;
8593+ goto op_semantics_55;
63888594 break;
63898595 }
63908596 break;
6391- case 0xb2:
8597+ case 0xd9:
63928598 GETBYTE ();
63938599 switch (op[1] & 0x00)
63948600 {
63958601 case 0x00:
6396- goto op_semantics_41;
8602+ goto op_semantics_55;
63978603 break;
63988604 }
63998605 break;
6400- case 0xb3:
8606+ case 0xda:
64018607 GETBYTE ();
64028608 switch (op[1] & 0x00)
64038609 {
64048610 case 0x00:
6405- goto op_semantics_41;
8611+ goto op_semantics_55;
64068612 break;
64078613 }
64088614 break;
6409- case 0xb4:
8615+ case 0xdb:
64108616 GETBYTE ();
64118617 switch (op[1] & 0x00)
64128618 {
64138619 case 0x00:
6414- goto op_semantics_41;
8620+ goto op_semantics_55;
64158621 break;
64168622 }
64178623 break;
6418- case 0xb5:
8624+ case 0xdc:
64198625 GETBYTE ();
64208626 switch (op[1] & 0x00)
64218627 {
64228628 case 0x00:
6423- goto op_semantics_41;
8629+ goto op_semantics_55;
64248630 break;
64258631 }
64268632 break;
6427- case 0xb6:
8633+ case 0xdd:
64288634 GETBYTE ();
64298635 switch (op[1] & 0x00)
64308636 {
64318637 case 0x00:
6432- goto op_semantics_41;
8638+ goto op_semantics_55;
64338639 break;
64348640 }
64358641 break;
6436- case 0xb7:
8642+ case 0xde:
64378643 GETBYTE ();
64388644 switch (op[1] & 0x00)
64398645 {
64408646 case 0x00:
6441- goto op_semantics_41;
8647+ goto op_semantics_55;
64428648 break;
64438649 }
64448650 break;
6445- case 0xb8:
8651+ case 0xdf:
64468652 GETBYTE ();
64478653 switch (op[1] & 0x00)
64488654 {
64498655 case 0x00:
6450- goto op_semantics_41;
8656+ goto op_semantics_55;
64518657 break;
64528658 }
64538659 break;
6454- case 0xb9:
8660+ case 0xe0:
64558661 GETBYTE ();
64568662 switch (op[1] & 0x00)
64578663 {
64588664 case 0x00:
6459- goto op_semantics_41;
8665+ goto op_semantics_55;
64608666 break;
64618667 }
64628668 break;
6463- case 0xba:
8669+ case 0xe1:
64648670 GETBYTE ();
64658671 switch (op[1] & 0x00)
64668672 {
64678673 case 0x00:
6468- goto op_semantics_41;
8674+ goto op_semantics_55;
64698675 break;
64708676 }
64718677 break;
6472- case 0xbb:
8678+ case 0xe2:
64738679 GETBYTE ();
64748680 switch (op[1] & 0x00)
64758681 {
64768682 case 0x00:
6477- goto op_semantics_41;
8683+ goto op_semantics_55;
64788684 break;
64798685 }
64808686 break;
6481- case 0xbc:
8687+ case 0xe3:
64828688 GETBYTE ();
64838689 switch (op[1] & 0x00)
64848690 {
64858691 case 0x00:
6486- goto op_semantics_41;
8692+ goto op_semantics_55;
64878693 break;
64888694 }
64898695 break;
6490- case 0xbd:
8696+ case 0xe4:
64918697 GETBYTE ();
64928698 switch (op[1] & 0x00)
64938699 {
64948700 case 0x00:
6495- goto op_semantics_41;
8701+ goto op_semantics_55;
64968702 break;
64978703 }
64988704 break;
6499- case 0xbe:
8705+ case 0xe5:
65008706 GETBYTE ();
65018707 switch (op[1] & 0x00)
65028708 {
65038709 case 0x00:
6504- goto op_semantics_41;
8710+ goto op_semantics_55;
65058711 break;
65068712 }
65078713 break;
6508- case 0xbf:
8714+ case 0xe6:
65098715 GETBYTE ();
65108716 switch (op[1] & 0x00)
65118717 {
65128718 case 0x00:
6513- goto op_semantics_41;
8719+ goto op_semantics_55;
65148720 break;
65158721 }
65168722 break;
6517- case 0xc0:
8723+ case 0xe7:
65188724 GETBYTE ();
65198725 switch (op[1] & 0x00)
65208726 {
65218727 case 0x00:
6522- op_semantics_42:
6523- {
6524- /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6525-#line 314 "rx-decode.opc"
6526- int sz AU = (op[0] >> 4) & 0x03;
6527-#line 314 "rx-decode.opc"
6528- int sd AU = (op[0] >> 2) & 0x03;
6529-#line 314 "rx-decode.opc"
6530- int ss AU = op[0] & 0x03;
6531-#line 314 "rx-decode.opc"
6532- int rsrc AU = (op[1] >> 4) & 0x0f;
6533-#line 314 "rx-decode.opc"
6534- int rdst AU = op[1] & 0x0f;
6535- if (trace)
6536- {
6537- printf ("\033[33m%s\033[0m %02x %02x\n",
6538- "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6539- op[0], op[1]);
6540- printf (" sz = 0x%x,", sz);
6541- printf (" sd = 0x%x,", sd);
6542- printf (" ss = 0x%x,", ss);
6543- printf (" rsrc = 0x%x,", rsrc);
6544- printf (" rdst = 0x%x\n", rdst);
6545- }
6546- SYNTAX("mov%s %1, %0");
6547-#line 314 "rx-decode.opc"
6548- if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6549- {
6550- ID(nop2);
6551- SYNTAX ("nop\t; mov.l\tr0, r0");
6552- }
6553- else
6554- {
6555- ID(mov); sBWL(sz); F_____;
6556- if ((ss == 3) && (sd != 3))
6557- {
6558- SD(ss, rdst, sz); DD(sd, rsrc, sz);
6559- }
6560- else
6561- {
6562- SD(ss, rsrc, sz); DD(sd, rdst, sz);
6563- }
6564- }
6565-
6566- }
8728+ goto op_semantics_55;
65678729 break;
65688730 }
65698731 break;
6570- case 0xc1:
8732+ case 0xe8:
65718733 GETBYTE ();
65728734 switch (op[1] & 0x00)
65738735 {
65748736 case 0x00:
6575- goto op_semantics_42;
8737+ goto op_semantics_55;
65768738 break;
65778739 }
65788740 break;
6579- case 0xc2:
8741+ case 0xe9:
65808742 GETBYTE ();
65818743 switch (op[1] & 0x00)
65828744 {
65838745 case 0x00:
6584- goto op_semantics_42;
8746+ goto op_semantics_55;
65858747 break;
65868748 }
65878749 break;
6588- case 0xc3:
8750+ case 0xea:
65898751 GETBYTE ();
65908752 switch (op[1] & 0x00)
65918753 {
65928754 case 0x00:
6593- goto op_semantics_42;
8755+ goto op_semantics_55;
65948756 break;
65958757 }
65968758 break;
6597- case 0xc4:
8759+ case 0xeb:
65988760 GETBYTE ();
65998761 switch (op[1] & 0x00)
66008762 {
66018763 case 0x00:
6602- goto op_semantics_42;
8764+ goto op_semantics_55;
66038765 break;
66048766 }
66058767 break;
6606- case 0xc5:
8768+ case 0xec:
66078769 GETBYTE ();
66088770 switch (op[1] & 0x00)
66098771 {
66108772 case 0x00:
6611- goto op_semantics_42;
8773+ goto op_semantics_55;
66128774 break;
66138775 }
66148776 break;
6615- case 0xc6:
8777+ case 0xed:
66168778 GETBYTE ();
66178779 switch (op[1] & 0x00)
66188780 {
66198781 case 0x00:
6620- goto op_semantics_42;
8782+ goto op_semantics_55;
66218783 break;
66228784 }
66238785 break;
6624- case 0xc7:
8786+ case 0xee:
66258787 GETBYTE ();
66268788 switch (op[1] & 0x00)
66278789 {
66288790 case 0x00:
6629- goto op_semantics_42;
8791+ goto op_semantics_55;
66308792 break;
66318793 }
66328794 break;
6633- case 0xc8:
8795+ case 0xef:
66348796 GETBYTE ();
66358797 switch (op[1] & 0x00)
66368798 {
66378799 case 0x00:
6638- goto op_semantics_42;
8800+ goto op_semantics_55;
66398801 break;
66408802 }
66418803 break;
6642- case 0xc9:
8804+ case 0xf0:
66438805 GETBYTE ();
6644- switch (op[1] & 0x00)
8806+ switch (op[1] & 0x08)
66458807 {
66468808 case 0x00:
6647- goto op_semantics_42;
8809+ op_semantics_56:
8810+ {
8811+ /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
8812+#line 960 "rx-decode.opc"
8813+ int sd AU = op[0] & 0x03;
8814+#line 960 "rx-decode.opc"
8815+ int rdst AU = (op[1] >> 4) & 0x0f;
8816+#line 960 "rx-decode.opc"
8817+ int bit AU = op[1] & 0x07;
8818+ if (trace)
8819+ {
8820+ printf ("\033[33m%s\033[0m %02x %02x\n",
8821+ "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
8822+ op[0], op[1]);
8823+ printf (" sd = 0x%x,", sd);
8824+ printf (" rdst = 0x%x,", rdst);
8825+ printf (" bit = 0x%x\n", bit);
8826+ }
8827+ SYNTAX("bset #%1, %0%S0");
8828+#line 960 "rx-decode.opc"
8829+ ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8830+
8831+ }
8832+ break;
8833+ case 0x08:
8834+ op_semantics_57:
8835+ {
8836+ /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
8837+#line 972 "rx-decode.opc"
8838+ int sd AU = op[0] & 0x03;
8839+#line 972 "rx-decode.opc"
8840+ int rdst AU = (op[1] >> 4) & 0x0f;
8841+#line 972 "rx-decode.opc"
8842+ int bit AU = op[1] & 0x07;
8843+ if (trace)
8844+ {
8845+ printf ("\033[33m%s\033[0m %02x %02x\n",
8846+ "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
8847+ op[0], op[1]);
8848+ printf (" sd = 0x%x,", sd);
8849+ printf (" rdst = 0x%x,", rdst);
8850+ printf (" bit = 0x%x\n", bit);
8851+ }
8852+ SYNTAX("bclr #%1, %0%S0");
8853+#line 972 "rx-decode.opc"
8854+ ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8855+
8856+ }
66488857 break;
66498858 }
66508859 break;
6651- case 0xca:
8860+ case 0xf1:
66528861 GETBYTE ();
6653- switch (op[1] & 0x00)
8862+ switch (op[1] & 0x08)
66548863 {
66558864 case 0x00:
6656- goto op_semantics_42;
8865+ goto op_semantics_56;
8866+ break;
8867+ case 0x08:
8868+ goto op_semantics_57;
66578869 break;
66588870 }
66598871 break;
6660- case 0xcb:
8872+ case 0xf2:
66618873 GETBYTE ();
6662- switch (op[1] & 0x00)
8874+ switch (op[1] & 0x08)
66638875 {
66648876 case 0x00:
6665- goto op_semantics_42;
8877+ goto op_semantics_56;
8878+ break;
8879+ case 0x08:
8880+ goto op_semantics_57;
66668881 break;
66678882 }
66688883 break;
6669- case 0xcc:
8884+ case 0xf3:
66708885 GETBYTE ();
6671- switch (op[1] & 0x00)
8886+ switch (op[1] & 0x08)
66728887 {
66738888 case 0x00:
6674- goto op_semantics_42;
8889+ goto op_semantics_56;
8890+ break;
8891+ case 0x08:
8892+ goto op_semantics_57;
66758893 break;
66768894 }
66778895 break;
6678- case 0xcd:
8896+ case 0xf4:
66798897 GETBYTE ();
6680- switch (op[1] & 0x00)
8898+ switch (op[1] & 0x0c)
66818899 {
66828900 case 0x00:
6683- goto op_semantics_42;
8901+ case 0x04:
8902+ op_semantics_58:
8903+ {
8904+ /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
8905+#line 984 "rx-decode.opc"
8906+ int sd AU = op[0] & 0x03;
8907+#line 984 "rx-decode.opc"
8908+ int rdst AU = (op[1] >> 4) & 0x0f;
8909+#line 984 "rx-decode.opc"
8910+ int bit AU = op[1] & 0x07;
8911+ if (trace)
8912+ {
8913+ printf ("\033[33m%s\033[0m %02x %02x\n",
8914+ "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
8915+ op[0], op[1]);
8916+ printf (" sd = 0x%x,", sd);
8917+ printf (" rdst = 0x%x,", rdst);
8918+ printf (" bit = 0x%x\n", bit);
8919+ }
8920+ SYNTAX("btst #%2, %1%S1");
8921+#line 984 "rx-decode.opc"
8922+ ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
8923+
8924+ }
8925+ break;
8926+ case 0x08:
8927+ op_semantics_59:
8928+ {
8929+ /** 1111 01ss rsrc 10sz push%s %1 */
8930+#line 402 "rx-decode.opc"
8931+ int ss AU = op[0] & 0x03;
8932+#line 402 "rx-decode.opc"
8933+ int rsrc AU = (op[1] >> 4) & 0x0f;
8934+#line 402 "rx-decode.opc"
8935+ int sz AU = op[1] & 0x03;
8936+ if (trace)
8937+ {
8938+ printf ("\033[33m%s\033[0m %02x %02x\n",
8939+ "/** 1111 01ss rsrc 10sz push%s %1 */",
8940+ op[0], op[1]);
8941+ printf (" ss = 0x%x,", ss);
8942+ printf (" rsrc = 0x%x,", rsrc);
8943+ printf (" sz = 0x%x\n", sz);
8944+ }
8945+ SYNTAX("push%s %1");
8946+#line 402 "rx-decode.opc"
8947+ ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
8948+
8949+ /*----------------------------------------------------------------------*/
8950+ /* XCHG */
8951+
8952+ }
66848953 break;
8954+ default: UNSUPPORTED(); break;
66858955 }
66868956 break;
6687- case 0xce:
8957+ case 0xf5:
66888958 GETBYTE ();
6689- switch (op[1] & 0x00)
8959+ switch (op[1] & 0x0c)
66908960 {
66918961 case 0x00:
6692- goto op_semantics_42;
8962+ case 0x04:
8963+ goto op_semantics_58;
66938964 break;
8965+ case 0x08:
8966+ goto op_semantics_59;
8967+ break;
8968+ default: UNSUPPORTED(); break;
66948969 }
66958970 break;
6696- case 0xcf:
8971+ case 0xf6:
66978972 GETBYTE ();
6698- switch (op[1] & 0x00)
8973+ switch (op[1] & 0x0c)
66998974 {
67008975 case 0x00:
6701- goto op_semantics_42;
8976+ case 0x04:
8977+ goto op_semantics_58;
67028978 break;
8979+ case 0x08:
8980+ goto op_semantics_59;
8981+ break;
8982+ default: UNSUPPORTED(); break;
67038983 }
67048984 break;
6705- case 0xd0:
8985+ case 0xf7:
67068986 GETBYTE ();
6707- switch (op[1] & 0x00)
8987+ switch (op[1] & 0x0c)
67088988 {
67098989 case 0x00:
6710- goto op_semantics_42;
8990+ case 0x04:
8991+ goto op_semantics_58;
67118992 break;
8993+ case 0x08:
8994+ goto op_semantics_59;
8995+ break;
8996+ default: UNSUPPORTED(); break;
67128997 }
67138998 break;
6714- case 0xd1:
8999+ case 0xf8:
67159000 GETBYTE ();
67169001 switch (op[1] & 0x00)
67179002 {
67189003 case 0x00:
6719- goto op_semantics_42;
9004+ op_semantics_60:
9005+ {
9006+ /** 1111 10sd rdst im sz mov%s #%1, %0 */
9007+#line 313 "rx-decode.opc"
9008+ int sd AU = op[0] & 0x03;
9009+#line 313 "rx-decode.opc"
9010+ int rdst AU = (op[1] >> 4) & 0x0f;
9011+#line 313 "rx-decode.opc"
9012+ int im AU = (op[1] >> 2) & 0x03;
9013+#line 313 "rx-decode.opc"
9014+ int sz AU = op[1] & 0x03;
9015+ if (trace)
9016+ {
9017+ printf ("\033[33m%s\033[0m %02x %02x\n",
9018+ "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
9019+ op[0], op[1]);
9020+ printf (" sd = 0x%x,", sd);
9021+ printf (" rdst = 0x%x,", rdst);
9022+ printf (" im = 0x%x,", im);
9023+ printf (" sz = 0x%x\n", sz);
9024+ }
9025+ SYNTAX("mov%s #%1, %0");
9026+#line 313 "rx-decode.opc"
9027+ ID(mov); DD(sd, rdst, sz);
9028+ if ((im == 1 && sz == 0)
9029+ || (im == 2 && sz == 1)
9030+ || (im == 0 && sz == 2))
9031+ {
9032+ BWL (sz);
9033+ SC(IMM(im));
9034+ }
9035+ else
9036+ {
9037+ sBWL (sz);
9038+ SC(IMMex(im));
9039+ }
9040+ F_____;
9041+
9042+ }
67209043 break;
67219044 }
67229045 break;
6723- case 0xd2:
9046+ case 0xf9:
67249047 GETBYTE ();
6725- switch (op[1] & 0x00)
9048+ switch (op[1] & 0xff)
67269049 {
67279050 case 0x00:
6728- goto op_semantics_42;
9051+ case 0x01:
9052+ case 0x02:
9053+ case 0x04:
9054+ case 0x05:
9055+ case 0x06:
9056+ case 0x08:
9057+ case 0x09:
9058+ case 0x0a:
9059+ case 0x0c:
9060+ case 0x0d:
9061+ case 0x0e:
9062+ case 0x10:
9063+ case 0x11:
9064+ case 0x12:
9065+ case 0x14:
9066+ case 0x15:
9067+ case 0x16:
9068+ case 0x18:
9069+ case 0x19:
9070+ case 0x1a:
9071+ case 0x1c:
9072+ case 0x1d:
9073+ case 0x1e:
9074+ case 0x20:
9075+ case 0x21:
9076+ case 0x22:
9077+ case 0x24:
9078+ case 0x25:
9079+ case 0x26:
9080+ case 0x28:
9081+ case 0x29:
9082+ case 0x2a:
9083+ case 0x2c:
9084+ case 0x2d:
9085+ case 0x2e:
9086+ case 0x30:
9087+ case 0x31:
9088+ case 0x32:
9089+ case 0x34:
9090+ case 0x35:
9091+ case 0x36:
9092+ case 0x38:
9093+ case 0x39:
9094+ case 0x3a:
9095+ case 0x3c:
9096+ case 0x3d:
9097+ case 0x3e:
9098+ case 0x40:
9099+ case 0x41:
9100+ case 0x42:
9101+ case 0x44:
9102+ case 0x45:
9103+ case 0x46:
9104+ case 0x48:
9105+ case 0x49:
9106+ case 0x4a:
9107+ case 0x4c:
9108+ case 0x4d:
9109+ case 0x4e:
9110+ case 0x50:
9111+ case 0x51:
9112+ case 0x52:
9113+ case 0x54:
9114+ case 0x55:
9115+ case 0x56:
9116+ case 0x58:
9117+ case 0x59:
9118+ case 0x5a:
9119+ case 0x5c:
9120+ case 0x5d:
9121+ case 0x5e:
9122+ case 0x60:
9123+ case 0x61:
9124+ case 0x62:
9125+ case 0x64:
9126+ case 0x65:
9127+ case 0x66:
9128+ case 0x68:
9129+ case 0x69:
9130+ case 0x6a:
9131+ case 0x6c:
9132+ case 0x6d:
9133+ case 0x6e:
9134+ case 0x70:
9135+ case 0x71:
9136+ case 0x72:
9137+ case 0x74:
9138+ case 0x75:
9139+ case 0x76:
9140+ case 0x78:
9141+ case 0x79:
9142+ case 0x7a:
9143+ case 0x7c:
9144+ case 0x7d:
9145+ case 0x7e:
9146+ case 0x80:
9147+ case 0x81:
9148+ case 0x82:
9149+ case 0x84:
9150+ case 0x85:
9151+ case 0x86:
9152+ case 0x88:
9153+ case 0x89:
9154+ case 0x8a:
9155+ case 0x8c:
9156+ case 0x8d:
9157+ case 0x8e:
9158+ case 0x90:
9159+ case 0x91:
9160+ case 0x92:
9161+ case 0x94:
9162+ case 0x95:
9163+ case 0x96:
9164+ case 0x98:
9165+ case 0x99:
9166+ case 0x9a:
9167+ case 0x9c:
9168+ case 0x9d:
9169+ case 0x9e:
9170+ case 0xa0:
9171+ case 0xa1:
9172+ case 0xa2:
9173+ case 0xa4:
9174+ case 0xa5:
9175+ case 0xa6:
9176+ case 0xa8:
9177+ case 0xa9:
9178+ case 0xaa:
9179+ case 0xac:
9180+ case 0xad:
9181+ case 0xae:
9182+ case 0xb0:
9183+ case 0xb1:
9184+ case 0xb2:
9185+ case 0xb4:
9186+ case 0xb5:
9187+ case 0xb6:
9188+ case 0xb8:
9189+ case 0xb9:
9190+ case 0xba:
9191+ case 0xbc:
9192+ case 0xbd:
9193+ case 0xbe:
9194+ case 0xc0:
9195+ case 0xc1:
9196+ case 0xc2:
9197+ case 0xc4:
9198+ case 0xc5:
9199+ case 0xc6:
9200+ case 0xc8:
9201+ case 0xc9:
9202+ case 0xca:
9203+ case 0xcc:
9204+ case 0xcd:
9205+ case 0xce:
9206+ case 0xd0:
9207+ case 0xd1:
9208+ case 0xd2:
9209+ case 0xd4:
9210+ case 0xd5:
9211+ case 0xd6:
9212+ case 0xd8:
9213+ case 0xd9:
9214+ case 0xda:
9215+ case 0xdc:
9216+ case 0xdd:
9217+ case 0xde:
9218+ case 0xe0:
9219+ case 0xe1:
9220+ case 0xe2:
9221+ case 0xe4:
9222+ case 0xe5:
9223+ case 0xe6:
9224+ case 0xe8:
9225+ case 0xe9:
9226+ case 0xea:
9227+ case 0xec:
9228+ case 0xed:
9229+ case 0xee:
9230+ case 0xf0:
9231+ case 0xf1:
9232+ case 0xf2:
9233+ case 0xf4:
9234+ case 0xf5:
9235+ case 0xf6:
9236+ case 0xf8:
9237+ case 0xf9:
9238+ case 0xfa:
9239+ case 0xfc:
9240+ case 0xfd:
9241+ case 0xfe:
9242+ goto op_semantics_60;
9243+ break;
9244+ case 0x03:
9245+ GETBYTE ();
9246+ switch (op[2] & 0x0f)
9247+ {
9248+ case 0x00:
9249+ {
9250+ /** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */
9251+#line 1211 "rx-decode.opc"
9252+ int rdst AU = (op[2] >> 4) & 0x0f;
9253+ if (trace)
9254+ {
9255+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9256+ "/** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */",
9257+ op[0], op[1], op[2]);
9258+ printf (" rdst = 0x%x\n", rdst);
9259+ }
9260+ SYNTAX("dmov.l #%1, %0");
9261+#line 1211 "rx-decode.opc"
9262+ ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____;
9263+
9264+ }
9265+ break;
9266+ case 0x02:
9267+ case 0x03:
9268+ {
9269+ /** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */
9270+#line 1208 "rx-decode.opc"
9271+ int rdst AU = (op[2] >> 4) & 0x0f;
9272+#line 1208 "rx-decode.opc"
9273+ int s AU = op[2] & 0x01;
9274+ if (trace)
9275+ {
9276+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9277+ "/** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */",
9278+ op[0], op[1], op[2]);
9279+ printf (" rdst = 0x%x,", rdst);
9280+ printf (" s = 0x%x\n", s);
9281+ }
9282+ SYNTAX("dmov%s #%1, %0");
9283+#line 1208 "rx-decode.opc"
9284+ ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____;
9285+
9286+ }
9287+ break;
9288+ default: UNSUPPORTED(); break;
9289+ }
67299290 break;
9291+ default: UNSUPPORTED(); break;
67309292 }
67319293 break;
6732- case 0xd3:
9294+ case 0xfa:
67339295 GETBYTE ();
67349296 switch (op[1] & 0x00)
67359297 {
67369298 case 0x00:
6737- goto op_semantics_42;
9299+ goto op_semantics_60;
67389300 break;
67399301 }
67409302 break;
6741- case 0xd4:
9303+ case 0xfb:
67429304 GETBYTE ();
67439305 switch (op[1] & 0x00)
67449306 {
67459307 case 0x00:
6746- goto op_semantics_42;
9308+ goto op_semantics_60;
67479309 break;
67489310 }
67499311 break;
6750- case 0xd5:
9312+ case 0xfc:
67519313 GETBYTE ();
6752- switch (op[1] & 0x00)
9314+ switch (op[1] & 0xff)
67539315 {
6754- case 0x00:
6755- goto op_semantics_42;
9316+ case 0x03:
9317+ GETBYTE ();
9318+ switch (op[2] & 0x00)
9319+ {
9320+ case 0x00:
9321+ {
9322+ /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
9323+#line 576 "rx-decode.opc"
9324+ int rsrc AU = (op[2] >> 4) & 0x0f;
9325+#line 576 "rx-decode.opc"
9326+ int rdst AU = op[2] & 0x0f;
9327+ if (trace)
9328+ {
9329+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9330+ "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
9331+ op[0], op[1], op[2]);
9332+ printf (" rsrc = 0x%x,", rsrc);
9333+ printf (" rdst = 0x%x\n", rdst);
9334+ }
9335+ SYNTAX("sbb %1, %0");
9336+#line 576 "rx-decode.opc"
9337+ ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
9338+
9339+ /* FIXME: only supports .L */
9340+ }
9341+ break;
9342+ }
67569343 break;
6757- }
6758- break;
6759- case 0xd6:
6760- GETBYTE ();
6761- switch (op[1] & 0x00)
6762- {
6763- case 0x00:
6764- goto op_semantics_42;
9344+ case 0x07:
9345+ GETBYTE ();
9346+ switch (op[2] & 0x00)
9347+ {
9348+ case 0x00:
9349+ {
9350+ /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
9351+#line 507 "rx-decode.opc"
9352+ int rsrc AU = (op[2] >> 4) & 0x0f;
9353+#line 507 "rx-decode.opc"
9354+ int rdst AU = op[2] & 0x0f;
9355+ if (trace)
9356+ {
9357+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9358+ "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
9359+ op[0], op[1], op[2]);
9360+ printf (" rsrc = 0x%x,", rsrc);
9361+ printf (" rdst = 0x%x\n", rdst);
9362+ }
9363+ SYNTAX("neg %2, %0");
9364+#line 507 "rx-decode.opc"
9365+ ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
9366+
9367+ /*----------------------------------------------------------------------*/
9368+ /* ADC */
9369+
9370+ }
9371+ break;
9372+ }
67659373 break;
6766- }
6767- break;
6768- case 0xd7:
6769- GETBYTE ();
6770- switch (op[1] & 0x00)
6771- {
6772- case 0x00:
6773- goto op_semantics_42;
9374+ case 0x0b:
9375+ GETBYTE ();
9376+ switch (op[2] & 0x00)
9377+ {
9378+ case 0x00:
9379+ {
9380+ /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
9381+#line 516 "rx-decode.opc"
9382+ int rsrc AU = (op[2] >> 4) & 0x0f;
9383+#line 516 "rx-decode.opc"
9384+ int rdst AU = op[2] & 0x0f;
9385+ if (trace)
9386+ {
9387+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9388+ "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
9389+ op[0], op[1], op[2]);
9390+ printf (" rsrc = 0x%x,", rsrc);
9391+ printf (" rdst = 0x%x\n", rdst);
9392+ }
9393+ SYNTAX("adc %1, %0");
9394+#line 516 "rx-decode.opc"
9395+ ID(adc); SR(rsrc); DR(rdst); F_OSZC;
9396+
9397+ }
9398+ break;
9399+ }
67749400 break;
6775- }
6776- break;
6777- case 0xd8:
6778- GETBYTE ();
6779- switch (op[1] & 0x00)
6780- {
6781- case 0x00:
6782- goto op_semantics_42;
9401+ case 0x0f:
9402+ GETBYTE ();
9403+ switch (op[2] & 0x00)
9404+ {
9405+ case 0x00:
9406+ {
9407+ /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
9408+#line 589 "rx-decode.opc"
9409+ int rsrc AU = (op[2] >> 4) & 0x0f;
9410+#line 589 "rx-decode.opc"
9411+ int rdst AU = op[2] & 0x0f;
9412+ if (trace)
9413+ {
9414+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9415+ "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
9416+ op[0], op[1], op[2]);
9417+ printf (" rsrc = 0x%x,", rsrc);
9418+ printf (" rdst = 0x%x\n", rdst);
9419+ }
9420+ SYNTAX("abs %1, %0");
9421+#line 589 "rx-decode.opc"
9422+ ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
9423+
9424+ /*----------------------------------------------------------------------*/
9425+ /* MAX */
9426+
9427+ }
9428+ break;
9429+ }
67839430 break;
6784- }
6785- break;
6786- case 0xd9:
6787- GETBYTE ();
6788- switch (op[1] & 0x00)
6789- {
6790- case 0x00:
6791- goto op_semantics_42;
9431+ case 0x10:
9432+ GETBYTE ();
9433+ switch (op[2] & 0x00)
9434+ {
9435+ case 0x00:
9436+ op_semantics_61:
9437+ {
9438+ /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
9439+#line 608 "rx-decode.opc"
9440+ int ss AU = op[1] & 0x03;
9441+#line 608 "rx-decode.opc"
9442+ int rsrc AU = (op[2] >> 4) & 0x0f;
9443+#line 608 "rx-decode.opc"
9444+ int rdst AU = op[2] & 0x0f;
9445+ if (trace)
9446+ {
9447+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9448+ "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
9449+ op[0], op[1], op[2]);
9450+ printf (" ss = 0x%x,", ss);
9451+ printf (" rsrc = 0x%x,", rsrc);
9452+ printf (" rdst = 0x%x\n", rdst);
9453+ }
9454+ SYNTAX("max %1%S1, %0");
9455+#line 608 "rx-decode.opc"
9456+ if (ss == 3 && rsrc == 0 && rdst == 0)
9457+ {
9458+ ID(nop3);
9459+ SYNTAX("nop\t; max\tr0, r0");
9460+ }
9461+ else
9462+ {
9463+ ID(max); SP(ss, rsrc); DR(rdst);
9464+ }
9465+
9466+ }
9467+ break;
9468+ }
67929469 break;
6793- }
6794- break;
6795- case 0xda:
6796- GETBYTE ();
6797- switch (op[1] & 0x00)
6798- {
6799- case 0x00:
6800- goto op_semantics_42;
9470+ case 0x11:
9471+ GETBYTE ();
9472+ switch (op[2] & 0x00)
9473+ {
9474+ case 0x00:
9475+ goto op_semantics_61;
9476+ break;
9477+ }
68019478 break;
6802- }
6803- break;
6804- case 0xdb:
6805- GETBYTE ();
6806- switch (op[1] & 0x00)
6807- {
6808- case 0x00:
6809- goto op_semantics_42;
9479+ case 0x12:
9480+ GETBYTE ();
9481+ switch (op[2] & 0x00)
9482+ {
9483+ case 0x00:
9484+ goto op_semantics_61;
9485+ break;
9486+ }
68109487 break;
6811- }
6812- break;
6813- case 0xdc:
6814- GETBYTE ();
6815- switch (op[1] & 0x00)
6816- {
6817- case 0x00:
6818- goto op_semantics_42;
9488+ case 0x13:
9489+ GETBYTE ();
9490+ switch (op[2] & 0x00)
9491+ {
9492+ case 0x00:
9493+ goto op_semantics_61;
9494+ break;
9495+ }
68199496 break;
6820- }
6821- break;
6822- case 0xdd:
6823- GETBYTE ();
6824- switch (op[1] & 0x00)
6825- {
6826- case 0x00:
6827- goto op_semantics_42;
9497+ case 0x14:
9498+ GETBYTE ();
9499+ switch (op[2] & 0x00)
9500+ {
9501+ case 0x00:
9502+ op_semantics_62:
9503+ {
9504+ /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
9505+#line 628 "rx-decode.opc"
9506+ int ss AU = op[1] & 0x03;
9507+#line 628 "rx-decode.opc"
9508+ int rsrc AU = (op[2] >> 4) & 0x0f;
9509+#line 628 "rx-decode.opc"
9510+ int rdst AU = op[2] & 0x0f;
9511+ if (trace)
9512+ {
9513+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9514+ "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
9515+ op[0], op[1], op[2]);
9516+ printf (" ss = 0x%x,", ss);
9517+ printf (" rsrc = 0x%x,", rsrc);
9518+ printf (" rdst = 0x%x\n", rdst);
9519+ }
9520+ SYNTAX("min %1%S1, %0");
9521+#line 628 "rx-decode.opc"
9522+ ID(min); SP(ss, rsrc); DR(rdst);
9523+
9524+ }
9525+ break;
9526+ }
68289527 break;
6829- }
6830- break;
6831- case 0xde:
6832- GETBYTE ();
6833- switch (op[1] & 0x00)
6834- {
6835- case 0x00:
6836- goto op_semantics_42;
9528+ case 0x15:
9529+ GETBYTE ();
9530+ switch (op[2] & 0x00)
9531+ {
9532+ case 0x00:
9533+ goto op_semantics_62;
9534+ break;
9535+ }
68379536 break;
6838- }
6839- break;
6840- case 0xdf:
6841- GETBYTE ();
6842- switch (op[1] & 0x00)
6843- {
6844- case 0x00:
6845- goto op_semantics_42;
9537+ case 0x16:
9538+ GETBYTE ();
9539+ switch (op[2] & 0x00)
9540+ {
9541+ case 0x00:
9542+ goto op_semantics_62;
9543+ break;
9544+ }
68469545 break;
6847- }
6848- break;
6849- case 0xe0:
6850- GETBYTE ();
6851- switch (op[1] & 0x00)
6852- {
6853- case 0x00:
6854- goto op_semantics_42;
9546+ case 0x17:
9547+ GETBYTE ();
9548+ switch (op[2] & 0x00)
9549+ {
9550+ case 0x00:
9551+ goto op_semantics_62;
9552+ break;
9553+ }
68559554 break;
6856- }
6857- break;
6858- case 0xe1:
6859- GETBYTE ();
6860- switch (op[1] & 0x00)
6861- {
6862- case 0x00:
6863- goto op_semantics_42;
9555+ case 0x18:
9556+ GETBYTE ();
9557+ switch (op[2] & 0x00)
9558+ {
9559+ case 0x00:
9560+ op_semantics_63:
9561+ {
9562+ /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
9563+#line 686 "rx-decode.opc"
9564+ int ss AU = op[1] & 0x03;
9565+#line 686 "rx-decode.opc"
9566+ int rsrc AU = (op[2] >> 4) & 0x0f;
9567+#line 686 "rx-decode.opc"
9568+ int rdst AU = op[2] & 0x0f;
9569+ if (trace)
9570+ {
9571+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9572+ "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
9573+ op[0], op[1], op[2]);
9574+ printf (" ss = 0x%x,", ss);
9575+ printf (" rsrc = 0x%x,", rsrc);
9576+ printf (" rdst = 0x%x\n", rdst);
9577+ }
9578+ SYNTAX("emul %1%S1, %0");
9579+#line 686 "rx-decode.opc"
9580+ ID(emul); SP(ss, rsrc); DR(rdst);
9581+
9582+ }
9583+ break;
9584+ }
68649585 break;
6865- }
6866- break;
6867- case 0xe2:
6868- GETBYTE ();
6869- switch (op[1] & 0x00)
6870- {
6871- case 0x00:
6872- goto op_semantics_42;
9586+ case 0x19:
9587+ GETBYTE ();
9588+ switch (op[2] & 0x00)
9589+ {
9590+ case 0x00:
9591+ goto op_semantics_63;
9592+ break;
9593+ }
68739594 break;
6874- }
6875- break;
6876- case 0xe3:
6877- GETBYTE ();
6878- switch (op[1] & 0x00)
6879- {
6880- case 0x00:
6881- goto op_semantics_42;
9595+ case 0x1a:
9596+ GETBYTE ();
9597+ switch (op[2] & 0x00)
9598+ {
9599+ case 0x00:
9600+ goto op_semantics_63;
9601+ break;
9602+ }
68829603 break;
6883- }
6884- break;
6885- case 0xe4:
6886- GETBYTE ();
6887- switch (op[1] & 0x00)
6888- {
6889- case 0x00:
6890- goto op_semantics_42;
9604+ case 0x1b:
9605+ GETBYTE ();
9606+ switch (op[2] & 0x00)
9607+ {
9608+ case 0x00:
9609+ goto op_semantics_63;
9610+ break;
9611+ }
68919612 break;
6892- }
6893- break;
6894- case 0xe5:
6895- GETBYTE ();
6896- switch (op[1] & 0x00)
6897- {
6898- case 0x00:
6899- goto op_semantics_42;
9613+ case 0x1c:
9614+ GETBYTE ();
9615+ switch (op[2] & 0x00)
9616+ {
9617+ case 0x00:
9618+ op_semantics_64:
9619+ {
9620+ /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
9621+#line 698 "rx-decode.opc"
9622+ int ss AU = op[1] & 0x03;
9623+#line 698 "rx-decode.opc"
9624+ int rsrc AU = (op[2] >> 4) & 0x0f;
9625+#line 698 "rx-decode.opc"
9626+ int rdst AU = op[2] & 0x0f;
9627+ if (trace)
9628+ {
9629+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9630+ "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
9631+ op[0], op[1], op[2]);
9632+ printf (" ss = 0x%x,", ss);
9633+ printf (" rsrc = 0x%x,", rsrc);
9634+ printf (" rdst = 0x%x\n", rdst);
9635+ }
9636+ SYNTAX("emulu %1%S1, %0");
9637+#line 698 "rx-decode.opc"
9638+ ID(emulu); SP(ss, rsrc); DR(rdst);
9639+
9640+ }
9641+ break;
9642+ }
69009643 break;
6901- }
6902- break;
6903- case 0xe6:
6904- GETBYTE ();
6905- switch (op[1] & 0x00)
6906- {
6907- case 0x00:
6908- goto op_semantics_42;
9644+ case 0x1d:
9645+ GETBYTE ();
9646+ switch (op[2] & 0x00)
9647+ {
9648+ case 0x00:
9649+ goto op_semantics_64;
9650+ break;
9651+ }
69099652 break;
6910- }
6911- break;
6912- case 0xe7:
6913- GETBYTE ();
6914- switch (op[1] & 0x00)
6915- {
6916- case 0x00:
6917- goto op_semantics_42;
9653+ case 0x1e:
9654+ GETBYTE ();
9655+ switch (op[2] & 0x00)
9656+ {
9657+ case 0x00:
9658+ goto op_semantics_64;
9659+ break;
9660+ }
69189661 break;
6919- }
6920- break;
6921- case 0xe8:
6922- GETBYTE ();
6923- switch (op[1] & 0x00)
6924- {
6925- case 0x00:
6926- goto op_semantics_42;
9662+ case 0x1f:
9663+ GETBYTE ();
9664+ switch (op[2] & 0x00)
9665+ {
9666+ case 0x00:
9667+ goto op_semantics_64;
9668+ break;
9669+ }
69279670 break;
6928- }
6929- break;
6930- case 0xe9:
6931- GETBYTE ();
6932- switch (op[1] & 0x00)
6933- {
6934- case 0x00:
6935- goto op_semantics_42;
9671+ case 0x20:
9672+ GETBYTE ();
9673+ switch (op[2] & 0x00)
9674+ {
9675+ case 0x00:
9676+ op_semantics_65:
9677+ {
9678+ /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
9679+#line 710 "rx-decode.opc"
9680+ int ss AU = op[1] & 0x03;
9681+#line 710 "rx-decode.opc"
9682+ int rsrc AU = (op[2] >> 4) & 0x0f;
9683+#line 710 "rx-decode.opc"
9684+ int rdst AU = op[2] & 0x0f;
9685+ if (trace)
9686+ {
9687+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9688+ "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
9689+ op[0], op[1], op[2]);
9690+ printf (" ss = 0x%x,", ss);
9691+ printf (" rsrc = 0x%x,", rsrc);
9692+ printf (" rdst = 0x%x\n", rdst);
9693+ }
9694+ SYNTAX("div %1%S1, %0");
9695+#line 710 "rx-decode.opc"
9696+ ID(div); SP(ss, rsrc); DR(rdst); F_O___;
9697+
9698+ }
9699+ break;
9700+ }
69369701 break;
6937- }
6938- break;
6939- case 0xea:
6940- GETBYTE ();
6941- switch (op[1] & 0x00)
6942- {
6943- case 0x00:
6944- goto op_semantics_42;
9702+ case 0x21:
9703+ GETBYTE ();
9704+ switch (op[2] & 0x00)
9705+ {
9706+ case 0x00:
9707+ goto op_semantics_65;
9708+ break;
9709+ }
69459710 break;
6946- }
6947- break;
6948- case 0xeb:
6949- GETBYTE ();
6950- switch (op[1] & 0x00)
6951- {
6952- case 0x00:
6953- goto op_semantics_42;
9711+ case 0x22:
9712+ GETBYTE ();
9713+ switch (op[2] & 0x00)
9714+ {
9715+ case 0x00:
9716+ goto op_semantics_65;
9717+ break;
9718+ }
69549719 break;
6955- }
6956- break;
6957- case 0xec:
6958- GETBYTE ();
6959- switch (op[1] & 0x00)
6960- {
6961- case 0x00:
6962- goto op_semantics_42;
9720+ case 0x23:
9721+ GETBYTE ();
9722+ switch (op[2] & 0x00)
9723+ {
9724+ case 0x00:
9725+ goto op_semantics_65;
9726+ break;
9727+ }
69639728 break;
6964- }
6965- break;
6966- case 0xed:
6967- GETBYTE ();
6968- switch (op[1] & 0x00)
6969- {
6970- case 0x00:
6971- goto op_semantics_42;
9729+ case 0x24:
9730+ GETBYTE ();
9731+ switch (op[2] & 0x00)
9732+ {
9733+ case 0x00:
9734+ op_semantics_66:
9735+ {
9736+ /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
9737+#line 722 "rx-decode.opc"
9738+ int ss AU = op[1] & 0x03;
9739+#line 722 "rx-decode.opc"
9740+ int rsrc AU = (op[2] >> 4) & 0x0f;
9741+#line 722 "rx-decode.opc"
9742+ int rdst AU = op[2] & 0x0f;
9743+ if (trace)
9744+ {
9745+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9746+ "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
9747+ op[0], op[1], op[2]);
9748+ printf (" ss = 0x%x,", ss);
9749+ printf (" rsrc = 0x%x,", rsrc);
9750+ printf (" rdst = 0x%x\n", rdst);
9751+ }
9752+ SYNTAX("divu %1%S1, %0");
9753+#line 722 "rx-decode.opc"
9754+ ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
9755+
9756+ }
9757+ break;
9758+ }
69729759 break;
6973- }
6974- break;
6975- case 0xee:
6976- GETBYTE ();
6977- switch (op[1] & 0x00)
6978- {
6979- case 0x00:
6980- goto op_semantics_42;
9760+ case 0x25:
9761+ GETBYTE ();
9762+ switch (op[2] & 0x00)
9763+ {
9764+ case 0x00:
9765+ goto op_semantics_66;
9766+ break;
9767+ }
69819768 break;
6982- }
6983- break;
6984- case 0xef:
6985- GETBYTE ();
6986- switch (op[1] & 0x00)
6987- {
6988- case 0x00:
6989- goto op_semantics_42;
9769+ case 0x26:
9770+ GETBYTE ();
9771+ switch (op[2] & 0x00)
9772+ {
9773+ case 0x00:
9774+ goto op_semantics_66;
9775+ break;
9776+ }
69909777 break;
6991- }
6992- break;
6993- case 0xf0:
6994- GETBYTE ();
6995- switch (op[1] & 0x08)
6996- {
6997- case 0x00:
6998- op_semantics_43:
9778+ case 0x27:
9779+ GETBYTE ();
9780+ switch (op[2] & 0x00)
69999781 {
7000- /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
7001-#line 939 "rx-decode.opc"
7002- int sd AU = op[0] & 0x03;
7003-#line 939 "rx-decode.opc"
7004- int rdst AU = (op[1] >> 4) & 0x0f;
7005-#line 939 "rx-decode.opc"
7006- int bit AU = op[1] & 0x07;
7007- if (trace)
7008- {
7009- printf ("\033[33m%s\033[0m %02x %02x\n",
7010- "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
7011- op[0], op[1]);
7012- printf (" sd = 0x%x,", sd);
7013- printf (" rdst = 0x%x,", rdst);
7014- printf (" bit = 0x%x\n", bit);
7015- }
7016- SYNTAX("bset #%1, %0%S0");
7017-#line 939 "rx-decode.opc"
7018- ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7019-
9782+ case 0x00:
9783+ goto op_semantics_66;
9784+ break;
70209785 }
70219786 break;
7022- case 0x08:
7023- op_semantics_44:
9787+ case 0x30:
9788+ GETBYTE ();
9789+ switch (op[2] & 0x00)
70249790 {
7025- /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
7026-#line 951 "rx-decode.opc"
7027- int sd AU = op[0] & 0x03;
7028-#line 951 "rx-decode.opc"
7029- int rdst AU = (op[1] >> 4) & 0x0f;
7030-#line 951 "rx-decode.opc"
7031- int bit AU = op[1] & 0x07;
7032- if (trace)
7033- {
7034- printf ("\033[33m%s\033[0m %02x %02x\n",
7035- "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
7036- op[0], op[1]);
7037- printf (" sd = 0x%x,", sd);
7038- printf (" rdst = 0x%x,", rdst);
7039- printf (" bit = 0x%x\n", bit);
7040- }
7041- SYNTAX("bclr #%1, %0%S0");
7042-#line 951 "rx-decode.opc"
7043- ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
9791+ case 0x00:
9792+ op_semantics_67:
9793+ {
9794+ /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
9795+#line 495 "rx-decode.opc"
9796+ int ss AU = op[1] & 0x03;
9797+#line 495 "rx-decode.opc"
9798+ int rsrc AU = (op[2] >> 4) & 0x0f;
9799+#line 495 "rx-decode.opc"
9800+ int rdst AU = op[2] & 0x0f;
9801+ if (trace)
9802+ {
9803+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9804+ "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
9805+ op[0], op[1], op[2]);
9806+ printf (" ss = 0x%x,", ss);
9807+ printf (" rsrc = 0x%x,", rsrc);
9808+ printf (" rdst = 0x%x\n", rdst);
9809+ }
9810+ SYNTAX("tst %1%S1, %2");
9811+#line 495 "rx-decode.opc"
9812+ ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
70449813
9814+ }
9815+ break;
70459816 }
70469817 break;
7047- }
7048- break;
7049- case 0xf1:
7050- GETBYTE ();
7051- switch (op[1] & 0x08)
7052- {
7053- case 0x00:
7054- goto op_semantics_43;
9818+ case 0x31:
9819+ GETBYTE ();
9820+ switch (op[2] & 0x00)
9821+ {
9822+ case 0x00:
9823+ goto op_semantics_67;
9824+ break;
9825+ }
70559826 break;
7056- case 0x08:
7057- goto op_semantics_44;
9827+ case 0x32:
9828+ GETBYTE ();
9829+ switch (op[2] & 0x00)
9830+ {
9831+ case 0x00:
9832+ goto op_semantics_67;
9833+ break;
9834+ }
70589835 break;
7059- }
7060- break;
7061- case 0xf2:
7062- GETBYTE ();
7063- switch (op[1] & 0x08)
7064- {
7065- case 0x00:
7066- goto op_semantics_43;
9836+ case 0x33:
9837+ GETBYTE ();
9838+ switch (op[2] & 0x00)
9839+ {
9840+ case 0x00:
9841+ goto op_semantics_67;
9842+ break;
9843+ }
70679844 break;
7068- case 0x08:
7069- goto op_semantics_44;
9845+ case 0x34:
9846+ GETBYTE ();
9847+ switch (op[2] & 0x00)
9848+ {
9849+ case 0x00:
9850+ op_semantics_68:
9851+ {
9852+ /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
9853+#line 474 "rx-decode.opc"
9854+ int ss AU = op[1] & 0x03;
9855+#line 474 "rx-decode.opc"
9856+ int rsrc AU = (op[2] >> 4) & 0x0f;
9857+#line 474 "rx-decode.opc"
9858+ int rdst AU = op[2] & 0x0f;
9859+ if (trace)
9860+ {
9861+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9862+ "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
9863+ op[0], op[1], op[2]);
9864+ printf (" ss = 0x%x,", ss);
9865+ printf (" rsrc = 0x%x,", rsrc);
9866+ printf (" rdst = 0x%x\n", rdst);
9867+ }
9868+ SYNTAX("xor %1%S1, %0");
9869+#line 474 "rx-decode.opc"
9870+ ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
9871+
9872+ }
9873+ break;
9874+ }
70709875 break;
7071- }
7072- break;
7073- case 0xf3:
7074- GETBYTE ();
7075- switch (op[1] & 0x08)
7076- {
7077- case 0x00:
7078- goto op_semantics_43;
9876+ case 0x35:
9877+ GETBYTE ();
9878+ switch (op[2] & 0x00)
9879+ {
9880+ case 0x00:
9881+ goto op_semantics_68;
9882+ break;
9883+ }
70799884 break;
7080- case 0x08:
7081- goto op_semantics_44;
9885+ case 0x36:
9886+ GETBYTE ();
9887+ switch (op[2] & 0x00)
9888+ {
9889+ case 0x00:
9890+ goto op_semantics_68;
9891+ break;
9892+ }
70829893 break;
7083- }
7084- break;
7085- case 0xf4:
7086- GETBYTE ();
7087- switch (op[1] & 0x0c)
7088- {
7089- case 0x00:
7090- case 0x04:
7091- op_semantics_45:
9894+ case 0x37:
9895+ GETBYTE ();
9896+ switch (op[2] & 0x00)
70929897 {
7093- /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
7094-#line 963 "rx-decode.opc"
7095- int sd AU = op[0] & 0x03;
7096-#line 963 "rx-decode.opc"
7097- int rdst AU = (op[1] >> 4) & 0x0f;
7098-#line 963 "rx-decode.opc"
7099- int bit AU = op[1] & 0x07;
7100- if (trace)
7101- {
7102- printf ("\033[33m%s\033[0m %02x %02x\n",
7103- "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
7104- op[0], op[1]);
7105- printf (" sd = 0x%x,", sd);
7106- printf (" rdst = 0x%x,", rdst);
7107- printf (" bit = 0x%x\n", bit);
7108- }
7109- SYNTAX("btst #%2, %1%S1");
7110-#line 963 "rx-decode.opc"
7111- ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
7112-
9898+ case 0x00:
9899+ goto op_semantics_68;
9900+ break;
71139901 }
71149902 break;
7115- case 0x08:
7116- op_semantics_46:
9903+ case 0x3b:
9904+ GETBYTE ();
9905+ switch (op[2] & 0x00)
71179906 {
7118- /** 1111 01ss rsrc 10sz push%s %1 */
7119-#line 381 "rx-decode.opc"
7120- int ss AU = op[0] & 0x03;
7121-#line 381 "rx-decode.opc"
7122- int rsrc AU = (op[1] >> 4) & 0x0f;
7123-#line 381 "rx-decode.opc"
7124- int sz AU = op[1] & 0x03;
7125- if (trace)
7126- {
7127- printf ("\033[33m%s\033[0m %02x %02x\n",
7128- "/** 1111 01ss rsrc 10sz push%s %1 */",
7129- op[0], op[1]);
7130- printf (" ss = 0x%x,", ss);
7131- printf (" rsrc = 0x%x,", rsrc);
7132- printf (" sz = 0x%x\n", sz);
7133- }
7134- SYNTAX("push%s %1");
7135-#line 381 "rx-decode.opc"
7136- ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
9907+ case 0x00:
9908+ {
9909+ /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
9910+#line 486 "rx-decode.opc"
9911+ int rsrc AU = (op[2] >> 4) & 0x0f;
9912+#line 486 "rx-decode.opc"
9913+ int rdst AU = op[2] & 0x0f;
9914+ if (trace)
9915+ {
9916+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9917+ "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
9918+ op[0], op[1], op[2]);
9919+ printf (" rsrc = 0x%x,", rsrc);
9920+ printf (" rdst = 0x%x\n", rdst);
9921+ }
9922+ SYNTAX("not %1, %0");
9923+#line 486 "rx-decode.opc"
9924+ ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
71379925
7138- /*----------------------------------------------------------------------*/
7139- /* XCHG */
9926+ /*----------------------------------------------------------------------*/
9927+ /* TST */
71409928
9929+ }
9930+ break;
71419931 }
71429932 break;
7143- default: UNSUPPORTED(); break;
7144- }
7145- break;
7146- case 0xf5:
7147- GETBYTE ();
7148- switch (op[1] & 0x0c)
7149- {
7150- case 0x00:
7151- case 0x04:
7152- goto op_semantics_45;
7153- break;
7154- case 0x08:
7155- goto op_semantics_46;
7156- break;
7157- default: UNSUPPORTED(); break;
7158- }
7159- break;
7160- case 0xf6:
7161- GETBYTE ();
7162- switch (op[1] & 0x0c)
7163- {
7164- case 0x00:
7165- case 0x04:
7166- goto op_semantics_45;
9933+ case 0x40:
9934+ GETBYTE ();
9935+ switch (op[2] & 0x00)
9936+ {
9937+ case 0x00:
9938+ op_semantics_69:
9939+ {
9940+ /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
9941+#line 408 "rx-decode.opc"
9942+ int ss AU = op[1] & 0x03;
9943+#line 408 "rx-decode.opc"
9944+ int rsrc AU = (op[2] >> 4) & 0x0f;
9945+#line 408 "rx-decode.opc"
9946+ int rdst AU = op[2] & 0x0f;
9947+ if (trace)
9948+ {
9949+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9950+ "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
9951+ op[0], op[1], op[2]);
9952+ printf (" ss = 0x%x,", ss);
9953+ printf (" rsrc = 0x%x,", rsrc);
9954+ printf (" rdst = 0x%x\n", rdst);
9955+ }
9956+ SYNTAX("xchg %1%S1, %0");
9957+#line 408 "rx-decode.opc"
9958+ ID(xchg); DR(rdst); SP(ss, rsrc);
9959+
9960+ }
9961+ break;
9962+ }
71679963 break;
7168- case 0x08:
7169- goto op_semantics_46;
9964+ case 0x41:
9965+ GETBYTE ();
9966+ switch (op[2] & 0x00)
9967+ {
9968+ case 0x00:
9969+ goto op_semantics_69;
9970+ break;
9971+ }
71709972 break;
7171- default: UNSUPPORTED(); break;
7172- }
7173- break;
7174- case 0xf7:
7175- GETBYTE ();
7176- switch (op[1] & 0x0c)
7177- {
7178- case 0x00:
7179- case 0x04:
7180- goto op_semantics_45;
9973+ case 0x42:
9974+ GETBYTE ();
9975+ switch (op[2] & 0x00)
9976+ {
9977+ case 0x00:
9978+ goto op_semantics_69;
9979+ break;
9980+ }
71819981 break;
7182- case 0x08:
7183- goto op_semantics_46;
9982+ case 0x43:
9983+ GETBYTE ();
9984+ switch (op[2] & 0x00)
9985+ {
9986+ case 0x00:
9987+ goto op_semantics_69;
9988+ break;
9989+ }
71849990 break;
7185- default: UNSUPPORTED(); break;
7186- }
7187- break;
7188- case 0xf8:
7189- GETBYTE ();
7190- switch (op[1] & 0x00)
7191- {
7192- case 0x00:
7193- op_semantics_47:
9991+ case 0x44:
9992+ GETBYTE ();
9993+ switch (op[2] & 0x00)
71949994 {
7195- /** 1111 10sd rdst im sz mov%s #%1, %0 */
7196-#line 292 "rx-decode.opc"
7197- int sd AU = op[0] & 0x03;
7198-#line 292 "rx-decode.opc"
7199- int rdst AU = (op[1] >> 4) & 0x0f;
7200-#line 292 "rx-decode.opc"
7201- int im AU = (op[1] >> 2) & 0x03;
7202-#line 292 "rx-decode.opc"
7203- int sz AU = op[1] & 0x03;
7204- if (trace)
7205- {
7206- printf ("\033[33m%s\033[0m %02x %02x\n",
7207- "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
7208- op[0], op[1]);
7209- printf (" sd = 0x%x,", sd);
7210- printf (" rdst = 0x%x,", rdst);
7211- printf (" im = 0x%x,", im);
7212- printf (" sz = 0x%x\n", sz);
7213- }
7214- SYNTAX("mov%s #%1, %0");
7215-#line 292 "rx-decode.opc"
7216- ID(mov); DD(sd, rdst, sz);
7217- if ((im == 1 && sz == 0)
7218- || (im == 2 && sz == 1)
7219- || (im == 0 && sz == 2))
7220- {
7221- BWL (sz);
7222- SC(IMM(im));
7223- }
7224- else
7225- {
7226- sBWL (sz);
7227- SC(IMMex(im));
7228- }
7229- F_____;
9995+ case 0x00:
9996+ op_semantics_70:
9997+ {
9998+ /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
9999+#line 951 "rx-decode.opc"
10000+ int sd AU = op[1] & 0x03;
10001+#line 951 "rx-decode.opc"
10002+ int rsrc AU = (op[2] >> 4) & 0x0f;
10003+#line 951 "rx-decode.opc"
10004+ int rdst AU = op[2] & 0x0f;
10005+ if (trace)
10006+ {
10007+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10008+ "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
10009+ op[0], op[1], op[2]);
10010+ printf (" sd = 0x%x,", sd);
10011+ printf (" rsrc = 0x%x,", rsrc);
10012+ printf (" rdst = 0x%x\n", rdst);
10013+ }
10014+ SYNTAX("itof %1%S1, %0");
10015+#line 951 "rx-decode.opc"
10016+ ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
723010017
10018+ }
10019+ break;
723110020 }
723210021 break;
7233- }
7234- break;
7235- case 0xf9:
7236- GETBYTE ();
7237- switch (op[1] & 0x00)
7238- {
7239- case 0x00:
7240- goto op_semantics_47;
10022+ case 0x45:
10023+ GETBYTE ();
10024+ switch (op[2] & 0x00)
10025+ {
10026+ case 0x00:
10027+ goto op_semantics_70;
10028+ break;
10029+ }
724110030 break;
7242- }
7243- break;
7244- case 0xfa:
7245- GETBYTE ();
7246- switch (op[1] & 0x00)
7247- {
7248- case 0x00:
7249- goto op_semantics_47;
10031+ case 0x46:
10032+ GETBYTE ();
10033+ switch (op[2] & 0x00)
10034+ {
10035+ case 0x00:
10036+ goto op_semantics_70;
10037+ break;
10038+ }
725010039 break;
7251- }
7252- break;
7253- case 0xfb:
7254- GETBYTE ();
7255- switch (op[1] & 0x00)
7256- {
7257- case 0x00:
7258- goto op_semantics_47;
10040+ case 0x47:
10041+ GETBYTE ();
10042+ switch (op[2] & 0x00)
10043+ {
10044+ case 0x00:
10045+ goto op_semantics_70;
10046+ break;
10047+ }
725910048 break;
7260- }
7261- break;
7262- case 0xfc:
7263- GETBYTE ();
7264- switch (op[1] & 0xff)
7265- {
7266- case 0x03:
10049+ case 0x4b:
726710050 GETBYTE ();
726810051 switch (op[2] & 0x00)
726910052 {
727010053 case 0x00:
727110054 {
7272- /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7273-#line 555 "rx-decode.opc"
10055+ /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
10056+#line 1077 "rx-decode.opc"
727410057 int rsrc AU = (op[2] >> 4) & 0x0f;
7275-#line 555 "rx-decode.opc"
10058+#line 1077 "rx-decode.opc"
727610059 int rdst AU = op[2] & 0x0f;
727710060 if (trace)
727810061 {
727910062 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7280- "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
10063+ "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
728110064 op[0], op[1], op[2]);
728210065 printf (" rsrc = 0x%x,", rsrc);
728310066 printf (" rdst = 0x%x\n", rdst);
728410067 }
7285- SYNTAX("sbb %1, %0");
7286-#line 555 "rx-decode.opc"
7287- ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
10068+ SYNTAX("stz %1, %0");
10069+#line 1077 "rx-decode.opc"
10070+ ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
728810071
7289- /* FIXME: only supports .L */
729010072 }
729110073 break;
729210074 }
729310075 break;
7294- case 0x07:
10076+ case 0x4f:
729510077 GETBYTE ();
729610078 switch (op[2] & 0x00)
729710079 {
729810080 case 0x00:
729910081 {
7300- /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7301-#line 486 "rx-decode.opc"
10082+ /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
10083+#line 1080 "rx-decode.opc"
730210084 int rsrc AU = (op[2] >> 4) & 0x0f;
7303-#line 486 "rx-decode.opc"
10085+#line 1080 "rx-decode.opc"
730410086 int rdst AU = op[2] & 0x0f;
730510087 if (trace)
730610088 {
730710089 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7308- "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
10090+ "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
730910091 op[0], op[1], op[2]);
731010092 printf (" rsrc = 0x%x,", rsrc);
731110093 printf (" rdst = 0x%x\n", rdst);
731210094 }
7313- SYNTAX("neg %2, %0");
7314-#line 486 "rx-decode.opc"
7315- ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7316-
7317- /*----------------------------------------------------------------------*/
7318- /* ADC */
10095+ SYNTAX("stnz %1, %0");
10096+#line 1080 "rx-decode.opc"
10097+ ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
731910098
732010099 }
732110100 break;
732210101 }
732310102 break;
7324- case 0x0b:
10103+ case 0x54:
732510104 GETBYTE ();
732610105 switch (op[2] & 0x00)
732710106 {
732810107 case 0x00:
10108+ op_semantics_71:
732910109 {
7330- /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7331-#line 495 "rx-decode.opc"
10110+ /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
10111+#line 1137 "rx-decode.opc"
10112+ int sd AU = op[1] & 0x03;
10113+#line 1137 "rx-decode.opc"
733210114 int rsrc AU = (op[2] >> 4) & 0x0f;
7333-#line 495 "rx-decode.opc"
10115+#line 1137 "rx-decode.opc"
733410116 int rdst AU = op[2] & 0x0f;
733510117 if (trace)
733610118 {
733710119 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7338- "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
10120+ "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
733910121 op[0], op[1], op[2]);
10122+ printf (" sd = 0x%x,", sd);
734010123 printf (" rsrc = 0x%x,", rsrc);
734110124 printf (" rdst = 0x%x\n", rdst);
734210125 }
7343- SYNTAX("adc %1, %0");
7344-#line 495 "rx-decode.opc"
7345- ID(adc); SR(rsrc); DR(rdst); F_OSZC;
10126+ SYNTAX("utof %1%S1, %0");
10127+#line 1137 "rx-decode.opc"
10128+ ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
734610129
734710130 }
734810131 break;
734910132 }
735010133 break;
7351- case 0x0f:
10134+ case 0x55:
10135+ GETBYTE ();
10136+ switch (op[2] & 0x00)
10137+ {
10138+ case 0x00:
10139+ goto op_semantics_71;
10140+ break;
10141+ }
10142+ break;
10143+ case 0x56:
10144+ GETBYTE ();
10145+ switch (op[2] & 0x00)
10146+ {
10147+ case 0x00:
10148+ goto op_semantics_71;
10149+ break;
10150+ }
10151+ break;
10152+ case 0x57:
10153+ GETBYTE ();
10154+ switch (op[2] & 0x00)
10155+ {
10156+ case 0x00:
10157+ goto op_semantics_71;
10158+ break;
10159+ }
10160+ break;
10161+ case 0x5a:
735210162 GETBYTE ();
735310163 switch (op[2] & 0x00)
735410164 {
735510165 case 0x00:
735610166 {
7357- /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7358-#line 568 "rx-decode.opc"
10167+ /** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */
10168+#line 1152 "rx-decode.opc"
735910169 int rsrc AU = (op[2] >> 4) & 0x0f;
7360-#line 568 "rx-decode.opc"
10170+#line 1152 "rx-decode.opc"
736110171 int rdst AU = op[2] & 0x0f;
736210172 if (trace)
736310173 {
736410174 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7365- "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
10175+ "/** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */",
736610176 op[0], op[1], op[2]);
736710177 printf (" rsrc = 0x%x,", rsrc);
736810178 printf (" rdst = 0x%x\n", rdst);
736910179 }
7370- SYNTAX("abs %1, %0");
7371-#line 568 "rx-decode.opc"
7372- ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7373-
7374- /*----------------------------------------------------------------------*/
7375- /* MAX */
10180+ SYNTAX("bfmovz %bf");
10181+#line 1152 "rx-decode.opc"
10182+ ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
737610183
737710184 }
737810185 break;
737910186 }
738010187 break;
7381- case 0x10:
10188+ case 0x5e:
738210189 GETBYTE ();
738310190 switch (op[2] & 0x00)
738410191 {
738510192 case 0x00:
7386- op_semantics_48:
738710193 {
7388- /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7389-#line 587 "rx-decode.opc"
7390- int ss AU = op[1] & 0x03;
7391-#line 587 "rx-decode.opc"
10194+ /** 1111 1100 0101 1110 rsrc rdst bfmov %bf */
10195+#line 1149 "rx-decode.opc"
739210196 int rsrc AU = (op[2] >> 4) & 0x0f;
7393-#line 587 "rx-decode.opc"
10197+#line 1149 "rx-decode.opc"
739410198 int rdst AU = op[2] & 0x0f;
739510199 if (trace)
739610200 {
739710201 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7398- "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
10202+ "/** 1111 1100 0101 1110 rsrc rdst bfmov %bf */",
739910203 op[0], op[1], op[2]);
7400- printf (" ss = 0x%x,", ss);
740110204 printf (" rsrc = 0x%x,", rsrc);
740210205 printf (" rdst = 0x%x\n", rdst);
740310206 }
7404- SYNTAX("max %1%S1, %0");
7405-#line 587 "rx-decode.opc"
7406- if (ss == 3 && rsrc == 0 && rdst == 0)
7407- {
7408- ID(nop3);
7409- SYNTAX("nop\t; max\tr0, r0");
7410- }
7411- else
10207+ SYNTAX("bfmov %bf");
10208+#line 1149 "rx-decode.opc"
10209+ ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10210+
10211+ }
10212+ break;
10213+ }
10214+ break;
10215+ case 0x60:
10216+ GETBYTE ();
10217+ switch (op[2] & 0x00)
10218+ {
10219+ case 0x00:
10220+ op_semantics_72:
10221+ {
10222+ /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
10223+#line 963 "rx-decode.opc"
10224+ int sd AU = op[1] & 0x03;
10225+#line 963 "rx-decode.opc"
10226+ int rdst AU = (op[2] >> 4) & 0x0f;
10227+#line 963 "rx-decode.opc"
10228+ int rsrc AU = op[2] & 0x0f;
10229+ if (trace)
741210230 {
7413- ID(max); SP(ss, rsrc); DR(rdst);
10231+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10232+ "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
10233+ op[0], op[1], op[2]);
10234+ printf (" sd = 0x%x,", sd);
10235+ printf (" rdst = 0x%x,", rdst);
10236+ printf (" rsrc = 0x%x\n", rsrc);
741410237 }
10238+ SYNTAX("bset %1, %0%S0");
10239+#line 963 "rx-decode.opc"
10240+ ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10241+ if (sd == 3) /* bset reg,reg */
10242+ BWL(LSIZE);
741510243
741610244 }
741710245 break;
741810246 }
741910247 break;
7420- case 0x11:
10248+ case 0x61:
742110249 GETBYTE ();
742210250 switch (op[2] & 0x00)
742310251 {
742410252 case 0x00:
7425- goto op_semantics_48;
10253+ goto op_semantics_72;
742610254 break;
742710255 }
742810256 break;
7429- case 0x12:
10257+ case 0x62:
743010258 GETBYTE ();
743110259 switch (op[2] & 0x00)
743210260 {
743310261 case 0x00:
7434- goto op_semantics_48;
10262+ goto op_semantics_72;
743510263 break;
743610264 }
743710265 break;
7438- case 0x13:
10266+ case 0x63:
743910267 GETBYTE ();
744010268 switch (op[2] & 0x00)
744110269 {
744210270 case 0x00:
7443- goto op_semantics_48;
10271+ goto op_semantics_72;
744410272 break;
744510273 }
744610274 break;
7447- case 0x14:
10275+ case 0x64:
744810276 GETBYTE ();
744910277 switch (op[2] & 0x00)
745010278 {
745110279 case 0x00:
7452- op_semantics_49:
10280+ op_semantics_73:
745310281 {
7454- /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7455-#line 607 "rx-decode.opc"
7456- int ss AU = op[1] & 0x03;
7457-#line 607 "rx-decode.opc"
7458- int rsrc AU = (op[2] >> 4) & 0x0f;
7459-#line 607 "rx-decode.opc"
7460- int rdst AU = op[2] & 0x0f;
10282+ /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
10283+#line 975 "rx-decode.opc"
10284+ int sd AU = op[1] & 0x03;
10285+#line 975 "rx-decode.opc"
10286+ int rdst AU = (op[2] >> 4) & 0x0f;
10287+#line 975 "rx-decode.opc"
10288+ int rsrc AU = op[2] & 0x0f;
746110289 if (trace)
746210290 {
746310291 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7464- "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
10292+ "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
746510293 op[0], op[1], op[2]);
7466- printf (" ss = 0x%x,", ss);
7467- printf (" rsrc = 0x%x,", rsrc);
7468- printf (" rdst = 0x%x\n", rdst);
10294+ printf (" sd = 0x%x,", sd);
10295+ printf (" rdst = 0x%x,", rdst);
10296+ printf (" rsrc = 0x%x\n", rsrc);
746910297 }
7470- SYNTAX("min %1%S1, %0");
7471-#line 607 "rx-decode.opc"
7472- ID(min); SP(ss, rsrc); DR(rdst);
10298+ SYNTAX("bclr %1, %0%S0");
10299+#line 975 "rx-decode.opc"
10300+ ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10301+ if (sd == 3) /* bset reg,reg */
10302+ BWL(LSIZE);
747310303
747410304 }
747510305 break;
747610306 }
747710307 break;
7478- case 0x15:
10308+ case 0x65:
747910309 GETBYTE ();
748010310 switch (op[2] & 0x00)
748110311 {
748210312 case 0x00:
7483- goto op_semantics_49;
10313+ goto op_semantics_73;
748410314 break;
748510315 }
748610316 break;
7487- case 0x16:
10317+ case 0x66:
748810318 GETBYTE ();
748910319 switch (op[2] & 0x00)
749010320 {
749110321 case 0x00:
7492- goto op_semantics_49;
10322+ goto op_semantics_73;
749310323 break;
749410324 }
749510325 break;
7496- case 0x17:
10326+ case 0x67:
749710327 GETBYTE ();
749810328 switch (op[2] & 0x00)
749910329 {
750010330 case 0x00:
7501- goto op_semantics_49;
10331+ goto op_semantics_73;
750210332 break;
750310333 }
750410334 break;
7505- case 0x18:
10335+ case 0x68:
750610336 GETBYTE ();
750710337 switch (op[2] & 0x00)
750810338 {
750910339 case 0x00:
7510- op_semantics_50:
10340+ op_semantics_74:
751110341 {
7512- /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7513-#line 665 "rx-decode.opc"
7514- int ss AU = op[1] & 0x03;
7515-#line 665 "rx-decode.opc"
7516- int rsrc AU = (op[2] >> 4) & 0x0f;
7517-#line 665 "rx-decode.opc"
7518- int rdst AU = op[2] & 0x0f;
10342+ /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
10343+#line 987 "rx-decode.opc"
10344+ int sd AU = op[1] & 0x03;
10345+#line 987 "rx-decode.opc"
10346+ int rdst AU = (op[2] >> 4) & 0x0f;
10347+#line 987 "rx-decode.opc"
10348+ int rsrc AU = op[2] & 0x0f;
751910349 if (trace)
752010350 {
752110351 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7522- "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
10352+ "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
752310353 op[0], op[1], op[2]);
7524- printf (" ss = 0x%x,", ss);
7525- printf (" rsrc = 0x%x,", rsrc);
7526- printf (" rdst = 0x%x\n", rdst);
10354+ printf (" sd = 0x%x,", sd);
10355+ printf (" rdst = 0x%x,", rdst);
10356+ printf (" rsrc = 0x%x\n", rsrc);
752710357 }
7528- SYNTAX("emul %1%S1, %0");
7529-#line 665 "rx-decode.opc"
7530- ID(emul); SP(ss, rsrc); DR(rdst);
10358+ SYNTAX("btst %2, %1%S1");
10359+#line 987 "rx-decode.opc"
10360+ ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
10361+ if (sd == 3) /* bset reg,reg */
10362+ BWL(LSIZE);
753110363
753210364 }
753310365 break;
753410366 }
753510367 break;
7536- case 0x19:
10368+ case 0x69:
753710369 GETBYTE ();
753810370 switch (op[2] & 0x00)
753910371 {
754010372 case 0x00:
7541- goto op_semantics_50;
10373+ goto op_semantics_74;
754210374 break;
754310375 }
754410376 break;
7545- case 0x1a:
10377+ case 0x6a:
754610378 GETBYTE ();
754710379 switch (op[2] & 0x00)
754810380 {
754910381 case 0x00:
7550- goto op_semantics_50;
10382+ goto op_semantics_74;
755110383 break;
755210384 }
755310385 break;
7554- case 0x1b:
10386+ case 0x6b:
755510387 GETBYTE ();
755610388 switch (op[2] & 0x00)
755710389 {
755810390 case 0x00:
7559- goto op_semantics_50;
10391+ goto op_semantics_74;
756010392 break;
756110393 }
756210394 break;
7563- case 0x1c:
10395+ case 0x6c:
756410396 GETBYTE ();
756510397 switch (op[2] & 0x00)
756610398 {
756710399 case 0x00:
7568- op_semantics_51:
10400+ op_semantics_75:
756910401 {
7570- /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7571-#line 677 "rx-decode.opc"
7572- int ss AU = op[1] & 0x03;
7573-#line 677 "rx-decode.opc"
7574- int rsrc AU = (op[2] >> 4) & 0x0f;
7575-#line 677 "rx-decode.opc"
7576- int rdst AU = op[2] & 0x0f;
10402+ /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
10403+#line 999 "rx-decode.opc"
10404+ int sd AU = op[1] & 0x03;
10405+#line 999 "rx-decode.opc"
10406+ int rdst AU = (op[2] >> 4) & 0x0f;
10407+#line 999 "rx-decode.opc"
10408+ int rsrc AU = op[2] & 0x0f;
757710409 if (trace)
757810410 {
757910411 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7580- "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
10412+ "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
758110413 op[0], op[1], op[2]);
7582- printf (" ss = 0x%x,", ss);
7583- printf (" rsrc = 0x%x,", rsrc);
7584- printf (" rdst = 0x%x\n", rdst);
10414+ printf (" sd = 0x%x,", sd);
10415+ printf (" rdst = 0x%x,", rdst);
10416+ printf (" rsrc = 0x%x\n", rsrc);
758510417 }
7586- SYNTAX("emulu %1%S1, %0");
7587-#line 677 "rx-decode.opc"
7588- ID(emulu); SP(ss, rsrc); DR(rdst);
10418+ SYNTAX("bnot %1, %0%S0");
10419+#line 999 "rx-decode.opc"
10420+ ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
10421+ if (sd == 3) /* bset reg,reg */
10422+ BWL(LSIZE);
758910423
759010424 }
759110425 break;
759210426 }
759310427 break;
7594- case 0x1d:
10428+ case 0x6d:
759510429 GETBYTE ();
759610430 switch (op[2] & 0x00)
759710431 {
759810432 case 0x00:
7599- goto op_semantics_51;
10433+ goto op_semantics_75;
760010434 break;
760110435 }
760210436 break;
7603- case 0x1e:
10437+ case 0x6e:
760410438 GETBYTE ();
760510439 switch (op[2] & 0x00)
760610440 {
760710441 case 0x00:
7608- goto op_semantics_51;
10442+ goto op_semantics_75;
760910443 break;
761010444 }
761110445 break;
7612- case 0x1f:
10446+ case 0x6f:
761310447 GETBYTE ();
761410448 switch (op[2] & 0x00)
761510449 {
761610450 case 0x00:
7617- goto op_semantics_51;
10451+ goto op_semantics_75;
761810452 break;
761910453 }
762010454 break;
7621- case 0x20:
10455+ case 0x78:
762210456 GETBYTE ();
7623- switch (op[2] & 0x00)
10457+ switch (op[2] & 0x0f)
762410458 {
7625- case 0x00:
7626- op_semantics_52:
10459+ case 0x08:
10460+ op_semantics_76:
762710461 {
7628- /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7629-#line 689 "rx-decode.opc"
7630- int ss AU = op[1] & 0x03;
7631-#line 689 "rx-decode.opc"
7632- int rsrc AU = (op[2] >> 4) & 0x0f;
7633-#line 689 "rx-decode.opc"
7634- int rdst AU = op[2] & 0x0f;
10462+ /** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */
10463+#line 1185 "rx-decode.opc"
10464+ int sz AU = op[1] & 0x03;
10465+#line 1185 "rx-decode.opc"
10466+ int rdst AU = (op[2] >> 4) & 0x0f;
763510467 if (trace)
763610468 {
763710469 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7638- "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
10470+ "/** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */",
763910471 op[0], op[1], op[2]);
7640- printf (" ss = 0x%x,", ss);
7641- printf (" rsrc = 0x%x,", rsrc);
10472+ printf (" sz = 0x%x,", sz);
764210473 printf (" rdst = 0x%x\n", rdst);
764310474 }
7644- SYNTAX("div %1%S1, %0");
7645-#line 689 "rx-decode.opc"
7646- ID(div); SP(ss, rsrc); DR(rdst); F_O___;
10475+ SYNTAX("dmov.d %1, %0");
10476+#line 1185 "rx-decode.opc"
10477+ int rsrc;
10478+ rx_disp(0, sz, rdst, RX_Double, ld);
10479+ rsrc = GETBYTE();
10480+ if (rsrc & 0x0f)
10481+ UNSUPPORTED();
10482+ else {
10483+ ID(dmov); SDR(rsrc >> 4); F_____;
10484+ }
764710485
764810486 }
764910487 break;
10488+ default: UNSUPPORTED(); break;
765010489 }
765110490 break;
7652- case 0x21:
7653- GETBYTE ();
7654- switch (op[2] & 0x00)
7655- {
7656- case 0x00:
7657- goto op_semantics_52;
7658- break;
7659- }
7660- break;
7661- case 0x22:
10491+ case 0x79:
766210492 GETBYTE ();
7663- switch (op[2] & 0x00)
10493+ switch (op[2] & 0x0f)
766410494 {
7665- case 0x00:
7666- goto op_semantics_52;
10495+ case 0x08:
10496+ goto op_semantics_76;
766710497 break;
10498+ default: UNSUPPORTED(); break;
766810499 }
766910500 break;
7670- case 0x23:
10501+ case 0x7a:
767110502 GETBYTE ();
7672- switch (op[2] & 0x00)
10503+ switch (op[2] & 0x0f)
767310504 {
7674- case 0x00:
7675- goto op_semantics_52;
10505+ case 0x08:
10506+ goto op_semantics_76;
767610507 break;
10508+ default: UNSUPPORTED(); break;
767710509 }
767810510 break;
7679- case 0x24:
10511+ case 0x80:
768010512 GETBYTE ();
768110513 switch (op[2] & 0x00)
768210514 {
768310515 case 0x00:
7684- op_semantics_53:
10516+ op_semantics_77:
768510517 {
7686- /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7687-#line 701 "rx-decode.opc"
7688- int ss AU = op[1] & 0x03;
7689-#line 701 "rx-decode.opc"
10518+ /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
10519+#line 930 "rx-decode.opc"
10520+ int sd AU = op[1] & 0x03;
10521+#line 930 "rx-decode.opc"
769010522 int rsrc AU = (op[2] >> 4) & 0x0f;
7691-#line 701 "rx-decode.opc"
10523+#line 930 "rx-decode.opc"
769210524 int rdst AU = op[2] & 0x0f;
769310525 if (trace)
769410526 {
769510527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7696- "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
10528+ "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
769710529 op[0], op[1], op[2]);
7698- printf (" ss = 0x%x,", ss);
10530+ printf (" sd = 0x%x,", sd);
769910531 printf (" rsrc = 0x%x,", rsrc);
770010532 printf (" rdst = 0x%x\n", rdst);
770110533 }
7702- SYNTAX("divu %1%S1, %0");
7703-#line 701 "rx-decode.opc"
7704- ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
10534+ SYNTAX("fsub %1%S1, %0");
10535+#line 930 "rx-decode.opc"
10536+ ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
770510537
770610538 }
770710539 break;
770810540 }
770910541 break;
7710- case 0x25:
10542+ case 0x81:
771110543 GETBYTE ();
771210544 switch (op[2] & 0x00)
771310545 {
771410546 case 0x00:
7715- goto op_semantics_53;
10547+ goto op_semantics_77;
771610548 break;
771710549 }
771810550 break;
7719- case 0x26:
10551+ case 0x82:
772010552 GETBYTE ();
772110553 switch (op[2] & 0x00)
772210554 {
772310555 case 0x00:
7724- goto op_semantics_53;
10556+ goto op_semantics_77;
772510557 break;
772610558 }
772710559 break;
7728- case 0x27:
10560+ case 0x83:
772910561 GETBYTE ();
773010562 switch (op[2] & 0x00)
773110563 {
773210564 case 0x00:
7733- goto op_semantics_53;
10565+ goto op_semantics_77;
773410566 break;
773510567 }
773610568 break;
7737- case 0x30:
10569+ case 0x84:
773810570 GETBYTE ();
773910571 switch (op[2] & 0x00)
774010572 {
774110573 case 0x00:
7742- op_semantics_54:
10574+ op_semantics_78:
774310575 {
7744- /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7745-#line 474 "rx-decode.opc"
7746- int ss AU = op[1] & 0x03;
7747-#line 474 "rx-decode.opc"
10576+ /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
10577+#line 924 "rx-decode.opc"
10578+ int sd AU = op[1] & 0x03;
10579+#line 924 "rx-decode.opc"
774810580 int rsrc AU = (op[2] >> 4) & 0x0f;
7749-#line 474 "rx-decode.opc"
10581+#line 924 "rx-decode.opc"
775010582 int rdst AU = op[2] & 0x0f;
775110583 if (trace)
775210584 {
775310585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7754- "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
10586+ "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
775510587 op[0], op[1], op[2]);
7756- printf (" ss = 0x%x,", ss);
10588+ printf (" sd = 0x%x,", sd);
775710589 printf (" rsrc = 0x%x,", rsrc);
775810590 printf (" rdst = 0x%x\n", rdst);
775910591 }
7760- SYNTAX("tst %1%S1, %2");
7761-#line 474 "rx-decode.opc"
7762- ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
10592+ SYNTAX("fcmp %1%S1, %0");
10593+#line 924 "rx-decode.opc"
10594+ ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
776310595
776410596 }
776510597 break;
776610598 }
776710599 break;
7768- case 0x31:
10600+ case 0x85:
776910601 GETBYTE ();
777010602 switch (op[2] & 0x00)
777110603 {
777210604 case 0x00:
7773- goto op_semantics_54;
10605+ goto op_semantics_78;
777410606 break;
777510607 }
777610608 break;
7777- case 0x32:
10609+ case 0x86:
777810610 GETBYTE ();
777910611 switch (op[2] & 0x00)
778010612 {
778110613 case 0x00:
7782- goto op_semantics_54;
10614+ goto op_semantics_78;
778310615 break;
778410616 }
778510617 break;
7786- case 0x33:
10618+ case 0x87:
778710619 GETBYTE ();
778810620 switch (op[2] & 0x00)
778910621 {
779010622 case 0x00:
7791- goto op_semantics_54;
10623+ goto op_semantics_78;
779210624 break;
779310625 }
779410626 break;
7795- case 0x34:
10627+ case 0x88:
779610628 GETBYTE ();
779710629 switch (op[2] & 0x00)
779810630 {
779910631 case 0x00:
7800- op_semantics_55:
10632+ op_semantics_79:
780110633 {
7802- /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7803-#line 453 "rx-decode.opc"
7804- int ss AU = op[1] & 0x03;
7805-#line 453 "rx-decode.opc"
10634+ /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
10635+#line 918 "rx-decode.opc"
10636+ int sd AU = op[1] & 0x03;
10637+#line 918 "rx-decode.opc"
780610638 int rsrc AU = (op[2] >> 4) & 0x0f;
7807-#line 453 "rx-decode.opc"
10639+#line 918 "rx-decode.opc"
780810640 int rdst AU = op[2] & 0x0f;
780910641 if (trace)
781010642 {
781110643 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7812- "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
10644+ "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
781310645 op[0], op[1], op[2]);
7814- printf (" ss = 0x%x,", ss);
10646+ printf (" sd = 0x%x,", sd);
781510647 printf (" rsrc = 0x%x,", rsrc);
781610648 printf (" rdst = 0x%x\n", rdst);
781710649 }
7818- SYNTAX("xor %1%S1, %0");
7819-#line 453 "rx-decode.opc"
7820- ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
10650+ SYNTAX("fadd %1%S1, %0");
10651+#line 918 "rx-decode.opc"
10652+ ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
782110653
782210654 }
782310655 break;
782410656 }
782510657 break;
7826- case 0x35:
7827- GETBYTE ();
7828- switch (op[2] & 0x00)
7829- {
7830- case 0x00:
7831- goto op_semantics_55;
7832- break;
7833- }
7834- break;
7835- case 0x36:
10658+ case 0x89:
783610659 GETBYTE ();
783710660 switch (op[2] & 0x00)
783810661 {
783910662 case 0x00:
7840- goto op_semantics_55;
10663+ goto op_semantics_79;
784110664 break;
784210665 }
784310666 break;
7844- case 0x37:
10667+ case 0x8a:
784510668 GETBYTE ();
784610669 switch (op[2] & 0x00)
784710670 {
784810671 case 0x00:
7849- goto op_semantics_55;
10672+ goto op_semantics_79;
785010673 break;
785110674 }
785210675 break;
7853- case 0x3b:
10676+ case 0x8b:
785410677 GETBYTE ();
785510678 switch (op[2] & 0x00)
785610679 {
785710680 case 0x00:
7858- {
7859- /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7860-#line 465 "rx-decode.opc"
7861- int rsrc AU = (op[2] >> 4) & 0x0f;
7862-#line 465 "rx-decode.opc"
7863- int rdst AU = op[2] & 0x0f;
7864- if (trace)
7865- {
7866- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7867- "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7868- op[0], op[1], op[2]);
7869- printf (" rsrc = 0x%x,", rsrc);
7870- printf (" rdst = 0x%x\n", rdst);
7871- }
7872- SYNTAX("not %1, %0");
7873-#line 465 "rx-decode.opc"
7874- ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7875-
7876- /*----------------------------------------------------------------------*/
7877- /* TST */
7878-
7879- }
10681+ goto op_semantics_79;
788010682 break;
788110683 }
788210684 break;
7883- case 0x40:
10685+ case 0x8c:
788410686 GETBYTE ();
788510687 switch (op[2] & 0x00)
788610688 {
788710689 case 0x00:
7888- op_semantics_56:
10690+ op_semantics_80:
788910691 {
7890- /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7891-#line 387 "rx-decode.opc"
7892- int ss AU = op[1] & 0x03;
7893-#line 387 "rx-decode.opc"
10692+ /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
10693+#line 939 "rx-decode.opc"
10694+ int sd AU = op[1] & 0x03;
10695+#line 939 "rx-decode.opc"
789410696 int rsrc AU = (op[2] >> 4) & 0x0f;
7895-#line 387 "rx-decode.opc"
10697+#line 939 "rx-decode.opc"
789610698 int rdst AU = op[2] & 0x0f;
789710699 if (trace)
789810700 {
789910701 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7900- "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
10702+ "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
790110703 op[0], op[1], op[2]);
7902- printf (" ss = 0x%x,", ss);
10704+ printf (" sd = 0x%x,", sd);
790310705 printf (" rsrc = 0x%x,", rsrc);
790410706 printf (" rdst = 0x%x\n", rdst);
790510707 }
7906- SYNTAX("xchg %1%S1, %0");
7907-#line 387 "rx-decode.opc"
7908- ID(xchg); DR(rdst); SP(ss, rsrc);
10708+ SYNTAX("fmul %1%S1, %0");
10709+#line 939 "rx-decode.opc"
10710+ ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
790910711
791010712 }
791110713 break;
791210714 }
791310715 break;
7914- case 0x41:
10716+ case 0x8d:
791510717 GETBYTE ();
791610718 switch (op[2] & 0x00)
791710719 {
791810720 case 0x00:
7919- goto op_semantics_56;
10721+ goto op_semantics_80;
792010722 break;
792110723 }
792210724 break;
7923- case 0x42:
10725+ case 0x8e:
792410726 GETBYTE ();
792510727 switch (op[2] & 0x00)
792610728 {
792710729 case 0x00:
7928- goto op_semantics_56;
10730+ goto op_semantics_80;
792910731 break;
793010732 }
793110733 break;
7932- case 0x43:
10734+ case 0x8f:
793310735 GETBYTE ();
793410736 switch (op[2] & 0x00)
793510737 {
793610738 case 0x00:
7937- goto op_semantics_56;
10739+ goto op_semantics_80;
793810740 break;
793910741 }
794010742 break;
7941- case 0x44:
10743+ case 0x90:
794210744 GETBYTE ();
794310745 switch (op[2] & 0x00)
794410746 {
794510747 case 0x00:
7946- op_semantics_57:
10748+ op_semantics_81:
794710749 {
7948- /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7949-#line 930 "rx-decode.opc"
10750+ /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
10751+#line 945 "rx-decode.opc"
795010752 int sd AU = op[1] & 0x03;
7951-#line 930 "rx-decode.opc"
10753+#line 945 "rx-decode.opc"
795210754 int rsrc AU = (op[2] >> 4) & 0x0f;
7953-#line 930 "rx-decode.opc"
10755+#line 945 "rx-decode.opc"
795410756 int rdst AU = op[2] & 0x0f;
795510757 if (trace)
795610758 {
795710759 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7958- "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
10760+ "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
795910761 op[0], op[1], op[2]);
796010762 printf (" sd = 0x%x,", sd);
796110763 printf (" rsrc = 0x%x,", rsrc);
796210764 printf (" rdst = 0x%x\n", rdst);
796310765 }
7964- SYNTAX("itof %1%S1, %0");
7965-#line 930 "rx-decode.opc"
7966- ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
10766+ SYNTAX("fdiv %1%S1, %0");
10767+#line 945 "rx-decode.opc"
10768+ ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
796710769
796810770 }
796910771 break;
797010772 }
797110773 break;
7972- case 0x45:
10774+ case 0x91:
797310775 GETBYTE ();
797410776 switch (op[2] & 0x00)
797510777 {
797610778 case 0x00:
7977- goto op_semantics_57;
10779+ goto op_semantics_81;
797810780 break;
797910781 }
798010782 break;
7981- case 0x46:
10783+ case 0x92:
798210784 GETBYTE ();
798310785 switch (op[2] & 0x00)
798410786 {
798510787 case 0x00:
7986- goto op_semantics_57;
10788+ goto op_semantics_81;
798710789 break;
798810790 }
798910791 break;
7990- case 0x47:
10792+ case 0x93:
799110793 GETBYTE ();
799210794 switch (op[2] & 0x00)
799310795 {
799410796 case 0x00:
7995- goto op_semantics_57;
10797+ goto op_semantics_81;
799610798 break;
799710799 }
799810800 break;
7999- case 0x4b:
10801+ case 0x94:
800010802 GETBYTE ();
800110803 switch (op[2] & 0x00)
800210804 {
800310805 case 0x00:
10806+ op_semantics_82:
800410807 {
8005- /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
8006-#line 1056 "rx-decode.opc"
10808+ /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
10809+#line 933 "rx-decode.opc"
10810+ int sd AU = op[1] & 0x03;
10811+#line 933 "rx-decode.opc"
800710812 int rsrc AU = (op[2] >> 4) & 0x0f;
8008-#line 1056 "rx-decode.opc"
10813+#line 933 "rx-decode.opc"
800910814 int rdst AU = op[2] & 0x0f;
801010815 if (trace)
801110816 {
801210817 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8013- "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
10818+ "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
801410819 op[0], op[1], op[2]);
10820+ printf (" sd = 0x%x,", sd);
801510821 printf (" rsrc = 0x%x,", rsrc);
801610822 printf (" rdst = 0x%x\n", rdst);
801710823 }
8018- SYNTAX("stz %1, %0");
8019-#line 1056 "rx-decode.opc"
8020- ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
10824+ SYNTAX("ftoi %1%S1, %0");
10825+#line 933 "rx-decode.opc"
10826+ ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
802110827
802210828 }
802310829 break;
802410830 }
802510831 break;
8026- case 0x4f:
10832+ case 0x95:
802710833 GETBYTE ();
802810834 switch (op[2] & 0x00)
802910835 {
803010836 case 0x00:
8031- {
8032- /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */
8033-#line 1059 "rx-decode.opc"
8034- int rsrc AU = (op[2] >> 4) & 0x0f;
8035-#line 1059 "rx-decode.opc"
8036- int rdst AU = op[2] & 0x0f;
8037- if (trace)
8038- {
8039- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8040- "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */",
8041- op[0], op[1], op[2]);
8042- printf (" rsrc = 0x%x,", rsrc);
8043- printf (" rdst = 0x%x\n", rdst);
8044- }
8045- SYNTAX("stnz %1, %0");
8046-#line 1059 "rx-decode.opc"
8047- ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
8048-
8049- }
10837+ goto op_semantics_82;
805010838 break;
805110839 }
805210840 break;
8053- case 0x54:
10841+ case 0x96:
10842+ GETBYTE ();
10843+ switch (op[2] & 0x00)
10844+ {
10845+ case 0x00:
10846+ goto op_semantics_82;
10847+ break;
10848+ }
10849+ break;
10850+ case 0x97:
10851+ GETBYTE ();
10852+ switch (op[2] & 0x00)
10853+ {
10854+ case 0x00:
10855+ goto op_semantics_82;
10856+ break;
10857+ }
10858+ break;
10859+ case 0x98:
805410860 GETBYTE ();
805510861 switch (op[2] & 0x00)
805610862 {
805710863 case 0x00:
8058- op_semantics_58:
10864+ op_semantics_83:
805910865 {
8060- /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */
8061-#line 1116 "rx-decode.opc"
10866+ /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
10867+#line 948 "rx-decode.opc"
806210868 int sd AU = op[1] & 0x03;
8063-#line 1116 "rx-decode.opc"
10869+#line 948 "rx-decode.opc"
806410870 int rsrc AU = (op[2] >> 4) & 0x0f;
8065-#line 1116 "rx-decode.opc"
10871+#line 948 "rx-decode.opc"
806610872 int rdst AU = op[2] & 0x0f;
806710873 if (trace)
806810874 {
806910875 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8070- "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */",
10876+ "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
807110877 op[0], op[1], op[2]);
807210878 printf (" sd = 0x%x,", sd);
807310879 printf (" rsrc = 0x%x,", rsrc);
807410880 printf (" rdst = 0x%x\n", rdst);
807510881 }
8076- SYNTAX("utof %1%S1, %0");
8077-#line 1116 "rx-decode.opc"
8078- ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
10882+ SYNTAX("round %1%S1, %0");
10883+#line 948 "rx-decode.opc"
10884+ ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
807910885
808010886 }
808110887 break;
808210888 }
808310889 break;
8084- case 0x55:
10890+ case 0x99:
808510891 GETBYTE ();
808610892 switch (op[2] & 0x00)
808710893 {
808810894 case 0x00:
8089- goto op_semantics_58;
10895+ goto op_semantics_83;
809010896 break;
809110897 }
809210898 break;
8093- case 0x56:
10899+ case 0x9a:
809410900 GETBYTE ();
809510901 switch (op[2] & 0x00)
809610902 {
809710903 case 0x00:
8098- goto op_semantics_58;
10904+ goto op_semantics_83;
809910905 break;
810010906 }
810110907 break;
8102- case 0x57:
10908+ case 0x9b:
810310909 GETBYTE ();
810410910 switch (op[2] & 0x00)
810510911 {
810610912 case 0x00:
8107- goto op_semantics_58;
10913+ goto op_semantics_83;
810810914 break;
810910915 }
811010916 break;
8111- case 0x60:
10917+ case 0xa0:
811210918 GETBYTE ();
811310919 switch (op[2] & 0x00)
811410920 {
811510921 case 0x00:
8116- op_semantics_59:
10922+ op_semantics_84:
811710923 {
8118- /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
8119-#line 942 "rx-decode.opc"
10924+ /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
10925+#line 1131 "rx-decode.opc"
812010926 int sd AU = op[1] & 0x03;
8121-#line 942 "rx-decode.opc"
8122- int rdst AU = (op[2] >> 4) & 0x0f;
8123-#line 942 "rx-decode.opc"
8124- int rsrc AU = op[2] & 0x0f;
10927+#line 1131 "rx-decode.opc"
10928+ int rsrc AU = (op[2] >> 4) & 0x0f;
10929+#line 1131 "rx-decode.opc"
10930+ int rdst AU = op[2] & 0x0f;
812510931 if (trace)
812610932 {
812710933 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8128- "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
10934+ "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
812910935 op[0], op[1], op[2]);
813010936 printf (" sd = 0x%x,", sd);
8131- printf (" rdst = 0x%x,", rdst);
8132- printf (" rsrc = 0x%x\n", rsrc);
10937+ printf (" rsrc = 0x%x,", rsrc);
10938+ printf (" rdst = 0x%x\n", rdst);
813310939 }
8134- SYNTAX("bset %1, %0%S0");
8135-#line 942 "rx-decode.opc"
8136- ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8137- if (sd == 3) /* bset reg,reg */
8138- BWL(LSIZE);
10940+ SYNTAX("fsqrt %1%S1, %0");
10941+#line 1131 "rx-decode.opc"
10942+ ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
813910943
814010944 }
814110945 break;
814210946 }
814310947 break;
8144- case 0x61:
10948+ case 0xa1:
814510949 GETBYTE ();
814610950 switch (op[2] & 0x00)
814710951 {
814810952 case 0x00:
8149- goto op_semantics_59;
10953+ goto op_semantics_84;
815010954 break;
815110955 }
815210956 break;
8153- case 0x62:
10957+ case 0xa2:
815410958 GETBYTE ();
815510959 switch (op[2] & 0x00)
815610960 {
815710961 case 0x00:
8158- goto op_semantics_59;
10962+ goto op_semantics_84;
815910963 break;
816010964 }
816110965 break;
8162- case 0x63:
10966+ case 0xa3:
816310967 GETBYTE ();
816410968 switch (op[2] & 0x00)
816510969 {
816610970 case 0x00:
8167- goto op_semantics_59;
10971+ goto op_semantics_84;
816810972 break;
816910973 }
817010974 break;
8171- case 0x64:
10975+ case 0xa4:
817210976 GETBYTE ();
817310977 switch (op[2] & 0x00)
817410978 {
817510979 case 0x00:
8176- op_semantics_60:
10980+ op_semantics_85:
817710981 {
8178- /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
8179-#line 954 "rx-decode.opc"
10982+ /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
10983+#line 1134 "rx-decode.opc"
818010984 int sd AU = op[1] & 0x03;
8181-#line 954 "rx-decode.opc"
8182- int rdst AU = (op[2] >> 4) & 0x0f;
8183-#line 954 "rx-decode.opc"
8184- int rsrc AU = op[2] & 0x0f;
10985+#line 1134 "rx-decode.opc"
10986+ int rsrc AU = (op[2] >> 4) & 0x0f;
10987+#line 1134 "rx-decode.opc"
10988+ int rdst AU = op[2] & 0x0f;
818510989 if (trace)
818610990 {
818710991 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8188- "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
10992+ "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
818910993 op[0], op[1], op[2]);
819010994 printf (" sd = 0x%x,", sd);
8191- printf (" rdst = 0x%x,", rdst);
8192- printf (" rsrc = 0x%x\n", rsrc);
10995+ printf (" rsrc = 0x%x,", rsrc);
10996+ printf (" rdst = 0x%x\n", rdst);
819310997 }
8194- SYNTAX("bclr %1, %0%S0");
8195-#line 954 "rx-decode.opc"
8196- ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8197- if (sd == 3) /* bset reg,reg */
8198- BWL(LSIZE);
10998+ SYNTAX("ftou %1%S1, %0");
10999+#line 1134 "rx-decode.opc"
11000+ ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
819911001
820011002 }
820111003 break;
820211004 }
820311005 break;
8204- case 0x65:
11006+ case 0xa5:
820511007 GETBYTE ();
820611008 switch (op[2] & 0x00)
820711009 {
820811010 case 0x00:
8209- goto op_semantics_60;
11011+ goto op_semantics_85;
821011012 break;
821111013 }
821211014 break;
8213- case 0x66:
11015+ case 0xa6:
821411016 GETBYTE ();
821511017 switch (op[2] & 0x00)
821611018 {
821711019 case 0x00:
8218- goto op_semantics_60;
11020+ goto op_semantics_85;
821911021 break;
822011022 }
822111023 break;
8222- case 0x67:
11024+ case 0xa7:
822311025 GETBYTE ();
822411026 switch (op[2] & 0x00)
822511027 {
822611028 case 0x00:
8227- goto op_semantics_60;
11029+ goto op_semantics_85;
822811030 break;
822911031 }
823011032 break;
8231- case 0x68:
11033+ case 0xc8:
823211034 GETBYTE ();
8233- switch (op[2] & 0x00)
11035+ switch (op[2] & 0x0f)
823411036 {
8235- case 0x00:
8236- op_semantics_61:
11037+ case 0x08:
11038+ op_semantics_86:
823711039 {
8238- /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
8239-#line 966 "rx-decode.opc"
8240- int sd AU = op[1] & 0x03;
8241-#line 966 "rx-decode.opc"
8242- int rdst AU = (op[2] >> 4) & 0x0f;
8243-#line 966 "rx-decode.opc"
8244- int rsrc AU = op[2] & 0x0f;
11040+ /** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */
11041+#line 1198 "rx-decode.opc"
11042+ int sz AU = op[1] & 0x03;
11043+#line 1198 "rx-decode.opc"
11044+ int rsrc AU = (op[2] >> 4) & 0x0f;
824511045 if (trace)
824611046 {
824711047 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8248- "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
11048+ "/** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */",
824911049 op[0], op[1], op[2]);
8250- printf (" sd = 0x%x,", sd);
8251- printf (" rdst = 0x%x,", rdst);
11050+ printf (" sz = 0x%x,", sz);
825211051 printf (" rsrc = 0x%x\n", rsrc);
825311052 }
8254- SYNTAX("btst %2, %1%S1");
8255-#line 966 "rx-decode.opc"
8256- ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8257- if (sd == 3) /* bset reg,reg */
8258- BWL(LSIZE);
11053+ SYNTAX("dmov.d %1, %0");
11054+#line 1198 "rx-decode.opc"
11055+ int rdst;
11056+ rx_disp(1, sz, rsrc, RX_Double, ld);
11057+ rdst = GETBYTE();
11058+ if (rdst & 0x0f)
11059+ UNSUPPORTED();
11060+ else {
11061+ ID(dmov); DDR(rdst >> 4); F_____;
11062+ }
825911063
826011064 }
826111065 break;
11066+ default: UNSUPPORTED(); break;
826211067 }
826311068 break;
8264- case 0x69:
8265- GETBYTE ();
8266- switch (op[2] & 0x00)
8267- {
8268- case 0x00:
8269- goto op_semantics_61;
8270- break;
8271- }
8272- break;
8273- case 0x6a:
11069+ case 0xc9:
827411070 GETBYTE ();
8275- switch (op[2] & 0x00)
11071+ switch (op[2] & 0x0f)
827611072 {
8277- case 0x00:
8278- goto op_semantics_61;
11073+ case 0x08:
11074+ goto op_semantics_86;
827911075 break;
11076+ default: UNSUPPORTED(); break;
828011077 }
828111078 break;
8282- case 0x6b:
11079+ case 0xca:
828311080 GETBYTE ();
8284- switch (op[2] & 0x00)
11081+ switch (op[2] & 0x0f)
828511082 {
8286- case 0x00:
8287- goto op_semantics_61;
11083+ case 0x08:
11084+ goto op_semantics_86;
828811085 break;
11086+ default: UNSUPPORTED(); break;
828911087 }
829011088 break;
8291- case 0x6c:
11089+ case 0xd0:
829211090 GETBYTE ();
829311091 switch (op[2] & 0x00)
829411092 {
829511093 case 0x00:
8296- op_semantics_62:
11094+ op_semantics_87:
829711095 {
8298- /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
8299-#line 978 "rx-decode.opc"
11096+ /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
11097+#line 1065 "rx-decode.opc"
11098+ int sz AU = (op[1] >> 2) & 0x03;
11099+#line 1065 "rx-decode.opc"
830011100 int sd AU = op[1] & 0x03;
8301-#line 978 "rx-decode.opc"
11101+#line 1065 "rx-decode.opc"
830211102 int rdst AU = (op[2] >> 4) & 0x0f;
8303-#line 978 "rx-decode.opc"
8304- int rsrc AU = op[2] & 0x0f;
11103+#line 1065 "rx-decode.opc"
11104+ int cond AU = op[2] & 0x0f;
830511105 if (trace)
830611106 {
830711107 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8308- "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
11108+ "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
830911109 op[0], op[1], op[2]);
11110+ printf (" sz = 0x%x,", sz);
831011111 printf (" sd = 0x%x,", sd);
831111112 printf (" rdst = 0x%x,", rdst);
8312- printf (" rsrc = 0x%x\n", rsrc);
11113+ printf (" cond = 0x%x\n", cond);
831311114 }
8314- SYNTAX("bnot %1, %0%S0");
8315-#line 978 "rx-decode.opc"
8316- ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8317- if (sd == 3) /* bset reg,reg */
8318- BWL(LSIZE);
11115+ SYNTAX("sc%1%s %0");
11116+#line 1065 "rx-decode.opc"
11117+ ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
11118+
11119+ /*----------------------------------------------------------------------*/
11120+ /* RXv2 enhanced */
831911121
832011122 }
832111123 break;
832211124 }
832311125 break;
8324- case 0x6d:
11126+ case 0xd1:
832511127 GETBYTE ();
832611128 switch (op[2] & 0x00)
832711129 {
832811130 case 0x00:
8329- goto op_semantics_62;
11131+ goto op_semantics_87;
833011132 break;
833111133 }
833211134 break;
8333- case 0x6e:
11135+ case 0xd2:
833411136 GETBYTE ();
833511137 switch (op[2] & 0x00)
833611138 {
833711139 case 0x00:
8338- goto op_semantics_62;
11140+ goto op_semantics_87;
833911141 break;
834011142 }
834111143 break;
8342- case 0x6f:
11144+ case 0xd3:
834311145 GETBYTE ();
834411146 switch (op[2] & 0x00)
834511147 {
834611148 case 0x00:
8347- goto op_semantics_62;
11149+ goto op_semantics_87;
834811150 break;
834911151 }
835011152 break;
8351- case 0x80:
11153+ case 0xd4:
835211154 GETBYTE ();
835311155 switch (op[2] & 0x00)
835411156 {
835511157 case 0x00:
8356- op_semantics_63:
8357- {
8358- /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8359-#line 909 "rx-decode.opc"
8360- int sd AU = op[1] & 0x03;
8361-#line 909 "rx-decode.opc"
8362- int rsrc AU = (op[2] >> 4) & 0x0f;
8363-#line 909 "rx-decode.opc"
8364- int rdst AU = op[2] & 0x0f;
8365- if (trace)
8366- {
8367- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8368- "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8369- op[0], op[1], op[2]);
8370- printf (" sd = 0x%x,", sd);
8371- printf (" rsrc = 0x%x,", rsrc);
8372- printf (" rdst = 0x%x\n", rdst);
8373- }
8374- SYNTAX("fsub %1%S1, %0");
8375-#line 909 "rx-decode.opc"
8376- ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8377-
8378- }
11158+ goto op_semantics_87;
837911159 break;
838011160 }
838111161 break;
8382- case 0x81:
11162+ case 0xd5:
838311163 GETBYTE ();
838411164 switch (op[2] & 0x00)
838511165 {
838611166 case 0x00:
8387- goto op_semantics_63;
11167+ goto op_semantics_87;
838811168 break;
838911169 }
839011170 break;
8391- case 0x82:
11171+ case 0xd6:
839211172 GETBYTE ();
839311173 switch (op[2] & 0x00)
839411174 {
839511175 case 0x00:
8396- goto op_semantics_63;
11176+ goto op_semantics_87;
839711177 break;
839811178 }
839911179 break;
8400- case 0x83:
11180+ case 0xd7:
840111181 GETBYTE ();
840211182 switch (op[2] & 0x00)
840311183 {
840411184 case 0x00:
8405- goto op_semantics_63;
11185+ goto op_semantics_87;
840611186 break;
840711187 }
840811188 break;
8409- case 0x84:
11189+ case 0xd8:
841011190 GETBYTE ();
841111191 switch (op[2] & 0x00)
841211192 {
841311193 case 0x00:
8414- op_semantics_64:
8415- {
8416- /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8417-#line 903 "rx-decode.opc"
8418- int sd AU = op[1] & 0x03;
8419-#line 903 "rx-decode.opc"
8420- int rsrc AU = (op[2] >> 4) & 0x0f;
8421-#line 903 "rx-decode.opc"
8422- int rdst AU = op[2] & 0x0f;
8423- if (trace)
8424- {
8425- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8426- "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8427- op[0], op[1], op[2]);
8428- printf (" sd = 0x%x,", sd);
8429- printf (" rsrc = 0x%x,", rsrc);
8430- printf (" rdst = 0x%x\n", rdst);
8431- }
8432- SYNTAX("fcmp %1%S1, %0");
8433-#line 903 "rx-decode.opc"
8434- ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8435-
8436- }
11194+ goto op_semantics_87;
843711195 break;
843811196 }
843911197 break;
8440- case 0x85:
11198+ case 0xd9:
844111199 GETBYTE ();
844211200 switch (op[2] & 0x00)
844311201 {
844411202 case 0x00:
8445- goto op_semantics_64;
11203+ goto op_semantics_87;
844611204 break;
844711205 }
844811206 break;
8449- case 0x86:
11207+ case 0xda:
845011208 GETBYTE ();
845111209 switch (op[2] & 0x00)
845211210 {
845311211 case 0x00:
8454- goto op_semantics_64;
11212+ goto op_semantics_87;
845511213 break;
845611214 }
845711215 break;
8458- case 0x87:
11216+ case 0xdb:
845911217 GETBYTE ();
846011218 switch (op[2] & 0x00)
846111219 {
846211220 case 0x00:
8463- goto op_semantics_64;
11221+ goto op_semantics_87;
846411222 break;
846511223 }
846611224 break;
8467- case 0x88:
11225+ case 0xe0:
846811226 GETBYTE ();
8469- switch (op[2] & 0x00)
11227+ switch (op[2] & 0x0f)
847011228 {
847111229 case 0x00:
8472- op_semantics_65:
11230+ case 0x01:
11231+ case 0x02:
11232+ case 0x03:
11233+ case 0x04:
11234+ case 0x05:
11235+ case 0x06:
11236+ case 0x07:
11237+ case 0x08:
11238+ case 0x09:
11239+ case 0x0a:
11240+ case 0x0b:
11241+ case 0x0c:
11242+ case 0x0d:
11243+ case 0x0e:
11244+ op_semantics_88:
847311245 {
8474- /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8475-#line 897 "rx-decode.opc"
11246+ /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
11247+#line 1008 "rx-decode.opc"
11248+ int bit AU = (op[1] >> 2) & 0x07;
11249+#line 1008 "rx-decode.opc"
847611250 int sd AU = op[1] & 0x03;
8477-#line 897 "rx-decode.opc"
8478- int rsrc AU = (op[2] >> 4) & 0x0f;
8479-#line 897 "rx-decode.opc"
8480- int rdst AU = op[2] & 0x0f;
11251+#line 1008 "rx-decode.opc"
11252+ int rdst AU = (op[2] >> 4) & 0x0f;
11253+#line 1008 "rx-decode.opc"
11254+ int cond AU = op[2] & 0x0f;
848111255 if (trace)
848211256 {
848311257 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8484- "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
11258+ "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
848511259 op[0], op[1], op[2]);
11260+ printf (" bit = 0x%x,", bit);
11261+ printf (" sd = 0x%x,", sd);
11262+ printf (" rdst = 0x%x,", rdst);
11263+ printf (" cond = 0x%x\n", cond);
11264+ }
11265+ SYNTAX("bm%2 #%1, %0%S0");
11266+#line 1008 "rx-decode.opc"
11267+ ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
11268+
11269+ }
11270+ break;
11271+ case 0x0f:
11272+ op_semantics_89:
11273+ {
11274+ /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
11275+#line 996 "rx-decode.opc"
11276+ int bit AU = (op[1] >> 2) & 0x07;
11277+#line 996 "rx-decode.opc"
11278+ int sd AU = op[1] & 0x03;
11279+#line 996 "rx-decode.opc"
11280+ int rdst AU = (op[2] >> 4) & 0x0f;
11281+ if (trace)
11282+ {
11283+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11284+ "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
11285+ op[0], op[1], op[2]);
11286+ printf (" bit = 0x%x,", bit);
848611287 printf (" sd = 0x%x,", sd);
8487- printf (" rsrc = 0x%x,", rsrc);
848811288 printf (" rdst = 0x%x\n", rdst);
848911289 }
8490- SYNTAX("fadd %1%S1, %0");
8491-#line 897 "rx-decode.opc"
8492- ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
11290+ SYNTAX("bnot #%1, %0%S0");
11291+#line 996 "rx-decode.opc"
11292+ ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
849311293
849411294 }
849511295 break;
849611296 }
849711297 break;
8498- case 0x89:
11298+ case 0xe1:
849911299 GETBYTE ();
8500- switch (op[2] & 0x00)
11300+ switch (op[2] & 0x0f)
850111301 {
850211302 case 0x00:
8503- goto op_semantics_65;
11303+ case 0x01:
11304+ case 0x02:
11305+ case 0x03:
11306+ case 0x04:
11307+ case 0x05:
11308+ case 0x06:
11309+ case 0x07:
11310+ case 0x08:
11311+ case 0x09:
11312+ case 0x0a:
11313+ case 0x0b:
11314+ case 0x0c:
11315+ case 0x0d:
11316+ case 0x0e:
11317+ goto op_semantics_88;
11318+ break;
11319+ case 0x0f:
11320+ goto op_semantics_89;
850411321 break;
850511322 }
850611323 break;
8507- case 0x8a:
11324+ case 0xe2:
850811325 GETBYTE ();
8509- switch (op[2] & 0x00)
11326+ switch (op[2] & 0x0f)
851011327 {
851111328 case 0x00:
8512- goto op_semantics_65;
11329+ case 0x01:
11330+ case 0x02:
11331+ case 0x03:
11332+ case 0x04:
11333+ case 0x05:
11334+ case 0x06:
11335+ case 0x07:
11336+ case 0x08:
11337+ case 0x09:
11338+ case 0x0a:
11339+ case 0x0b:
11340+ case 0x0c:
11341+ case 0x0d:
11342+ case 0x0e:
11343+ goto op_semantics_88;
11344+ break;
11345+ case 0x0f:
11346+ goto op_semantics_89;
851311347 break;
851411348 }
851511349 break;
8516- case 0x8b:
11350+ case 0xe3:
851711351 GETBYTE ();
8518- switch (op[2] & 0x00)
11352+ switch (op[2] & 0x0f)
851911353 {
852011354 case 0x00:
8521- goto op_semantics_65;
11355+ case 0x01:
11356+ case 0x02:
11357+ case 0x03:
11358+ case 0x04:
11359+ case 0x05:
11360+ case 0x06:
11361+ case 0x07:
11362+ case 0x08:
11363+ case 0x09:
11364+ case 0x0a:
11365+ case 0x0b:
11366+ case 0x0c:
11367+ case 0x0d:
11368+ case 0x0e:
11369+ goto op_semantics_88;
11370+ break;
11371+ case 0x0f:
11372+ goto op_semantics_89;
852211373 break;
852311374 }
852411375 break;
8525- case 0x8c:
11376+ case 0xe4:
852611377 GETBYTE ();
8527- switch (op[2] & 0x00)
11378+ switch (op[2] & 0x0f)
852811379 {
852911380 case 0x00:
8530- op_semantics_66:
8531- {
8532- /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8533-#line 918 "rx-decode.opc"
8534- int sd AU = op[1] & 0x03;
8535-#line 918 "rx-decode.opc"
8536- int rsrc AU = (op[2] >> 4) & 0x0f;
8537-#line 918 "rx-decode.opc"
8538- int rdst AU = op[2] & 0x0f;
8539- if (trace)
8540- {
8541- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8542- "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8543- op[0], op[1], op[2]);
8544- printf (" sd = 0x%x,", sd);
8545- printf (" rsrc = 0x%x,", rsrc);
8546- printf (" rdst = 0x%x\n", rdst);
8547- }
8548- SYNTAX("fmul %1%S1, %0");
8549-#line 918 "rx-decode.opc"
8550- ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8551-
8552- }
11381+ case 0x01:
11382+ case 0x02:
11383+ case 0x03:
11384+ case 0x04:
11385+ case 0x05:
11386+ case 0x06:
11387+ case 0x07:
11388+ case 0x08:
11389+ case 0x09:
11390+ case 0x0a:
11391+ case 0x0b:
11392+ case 0x0c:
11393+ case 0x0d:
11394+ case 0x0e:
11395+ goto op_semantics_88;
11396+ break;
11397+ case 0x0f:
11398+ goto op_semantics_89;
855311399 break;
855411400 }
855511401 break;
8556- case 0x8d:
11402+ case 0xe5:
855711403 GETBYTE ();
8558- switch (op[2] & 0x00)
11404+ switch (op[2] & 0x0f)
855911405 {
856011406 case 0x00:
8561- goto op_semantics_66;
11407+ case 0x01:
11408+ case 0x02:
11409+ case 0x03:
11410+ case 0x04:
11411+ case 0x05:
11412+ case 0x06:
11413+ case 0x07:
11414+ case 0x08:
11415+ case 0x09:
11416+ case 0x0a:
11417+ case 0x0b:
11418+ case 0x0c:
11419+ case 0x0d:
11420+ case 0x0e:
11421+ goto op_semantics_88;
11422+ break;
11423+ case 0x0f:
11424+ goto op_semantics_89;
856211425 break;
856311426 }
856411427 break;
8565- case 0x8e:
11428+ case 0xe6:
856611429 GETBYTE ();
8567- switch (op[2] & 0x00)
11430+ switch (op[2] & 0x0f)
856811431 {
856911432 case 0x00:
8570- goto op_semantics_66;
11433+ case 0x01:
11434+ case 0x02:
11435+ case 0x03:
11436+ case 0x04:
11437+ case 0x05:
11438+ case 0x06:
11439+ case 0x07:
11440+ case 0x08:
11441+ case 0x09:
11442+ case 0x0a:
11443+ case 0x0b:
11444+ case 0x0c:
11445+ case 0x0d:
11446+ case 0x0e:
11447+ goto op_semantics_88;
11448+ break;
11449+ case 0x0f:
11450+ goto op_semantics_89;
857111451 break;
857211452 }
857311453 break;
8574- case 0x8f:
11454+ case 0xe7:
857511455 GETBYTE ();
8576- switch (op[2] & 0x00)
11456+ switch (op[2] & 0x0f)
857711457 {
857811458 case 0x00:
8579- goto op_semantics_66;
11459+ case 0x01:
11460+ case 0x02:
11461+ case 0x03:
11462+ case 0x04:
11463+ case 0x05:
11464+ case 0x06:
11465+ case 0x07:
11466+ case 0x08:
11467+ case 0x09:
11468+ case 0x0a:
11469+ case 0x0b:
11470+ case 0x0c:
11471+ case 0x0d:
11472+ case 0x0e:
11473+ goto op_semantics_88;
11474+ break;
11475+ case 0x0f:
11476+ goto op_semantics_89;
858011477 break;
858111478 }
858211479 break;
8583- case 0x90:
11480+ case 0xe8:
858411481 GETBYTE ();
8585- switch (op[2] & 0x00)
11482+ switch (op[2] & 0x0f)
858611483 {
858711484 case 0x00:
8588- op_semantics_67:
8589- {
8590- /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8591-#line 924 "rx-decode.opc"
8592- int sd AU = op[1] & 0x03;
8593-#line 924 "rx-decode.opc"
8594- int rsrc AU = (op[2] >> 4) & 0x0f;
8595-#line 924 "rx-decode.opc"
8596- int rdst AU = op[2] & 0x0f;
8597- if (trace)
8598- {
8599- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8600- "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8601- op[0], op[1], op[2]);
8602- printf (" sd = 0x%x,", sd);
8603- printf (" rsrc = 0x%x,", rsrc);
8604- printf (" rdst = 0x%x\n", rdst);
8605- }
8606- SYNTAX("fdiv %1%S1, %0");
8607-#line 924 "rx-decode.opc"
8608- ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8609-
8610- }
11485+ case 0x01:
11486+ case 0x02:
11487+ case 0x03:
11488+ case 0x04:
11489+ case 0x05:
11490+ case 0x06:
11491+ case 0x07:
11492+ case 0x08:
11493+ case 0x09:
11494+ case 0x0a:
11495+ case 0x0b:
11496+ case 0x0c:
11497+ case 0x0d:
11498+ case 0x0e:
11499+ goto op_semantics_88;
11500+ break;
11501+ case 0x0f:
11502+ goto op_semantics_89;
861111503 break;
861211504 }
861311505 break;
8614- case 0x91:
11506+ case 0xe9:
861511507 GETBYTE ();
8616- switch (op[2] & 0x00)
11508+ switch (op[2] & 0x0f)
861711509 {
861811510 case 0x00:
8619- goto op_semantics_67;
11511+ case 0x01:
11512+ case 0x02:
11513+ case 0x03:
11514+ case 0x04:
11515+ case 0x05:
11516+ case 0x06:
11517+ case 0x07:
11518+ case 0x08:
11519+ case 0x09:
11520+ case 0x0a:
11521+ case 0x0b:
11522+ case 0x0c:
11523+ case 0x0d:
11524+ case 0x0e:
11525+ goto op_semantics_88;
11526+ break;
11527+ case 0x0f:
11528+ goto op_semantics_89;
862011529 break;
862111530 }
862211531 break;
8623- case 0x92:
11532+ case 0xea:
862411533 GETBYTE ();
8625- switch (op[2] & 0x00)
11534+ switch (op[2] & 0x0f)
862611535 {
862711536 case 0x00:
8628- goto op_semantics_67;
11537+ case 0x01:
11538+ case 0x02:
11539+ case 0x03:
11540+ case 0x04:
11541+ case 0x05:
11542+ case 0x06:
11543+ case 0x07:
11544+ case 0x08:
11545+ case 0x09:
11546+ case 0x0a:
11547+ case 0x0b:
11548+ case 0x0c:
11549+ case 0x0d:
11550+ case 0x0e:
11551+ goto op_semantics_88;
11552+ break;
11553+ case 0x0f:
11554+ goto op_semantics_89;
862911555 break;
863011556 }
863111557 break;
8632- case 0x93:
11558+ case 0xeb:
863311559 GETBYTE ();
8634- switch (op[2] & 0x00)
11560+ switch (op[2] & 0x0f)
863511561 {
863611562 case 0x00:
8637- goto op_semantics_67;
11563+ case 0x01:
11564+ case 0x02:
11565+ case 0x03:
11566+ case 0x04:
11567+ case 0x05:
11568+ case 0x06:
11569+ case 0x07:
11570+ case 0x08:
11571+ case 0x09:
11572+ case 0x0a:
11573+ case 0x0b:
11574+ case 0x0c:
11575+ case 0x0d:
11576+ case 0x0e:
11577+ goto op_semantics_88;
11578+ break;
11579+ case 0x0f:
11580+ goto op_semantics_89;
863811581 break;
863911582 }
864011583 break;
8641- case 0x94:
11584+ case 0xec:
864211585 GETBYTE ();
8643- switch (op[2] & 0x00)
11586+ switch (op[2] & 0x0f)
864411587 {
864511588 case 0x00:
8646- op_semantics_68:
8647- {
8648- /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8649-#line 912 "rx-decode.opc"
8650- int sd AU = op[1] & 0x03;
8651-#line 912 "rx-decode.opc"
8652- int rsrc AU = (op[2] >> 4) & 0x0f;
8653-#line 912 "rx-decode.opc"
8654- int rdst AU = op[2] & 0x0f;
8655- if (trace)
8656- {
8657- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8658- "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8659- op[0], op[1], op[2]);
8660- printf (" sd = 0x%x,", sd);
8661- printf (" rsrc = 0x%x,", rsrc);
8662- printf (" rdst = 0x%x\n", rdst);
8663- }
8664- SYNTAX("ftoi %1%S1, %0");
8665-#line 912 "rx-decode.opc"
8666- ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8667-
8668- }
11589+ case 0x01:
11590+ case 0x02:
11591+ case 0x03:
11592+ case 0x04:
11593+ case 0x05:
11594+ case 0x06:
11595+ case 0x07:
11596+ case 0x08:
11597+ case 0x09:
11598+ case 0x0a:
11599+ case 0x0b:
11600+ case 0x0c:
11601+ case 0x0d:
11602+ case 0x0e:
11603+ goto op_semantics_88;
11604+ break;
11605+ case 0x0f:
11606+ goto op_semantics_89;
866911607 break;
867011608 }
867111609 break;
8672- case 0x95:
11610+ case 0xed:
867311611 GETBYTE ();
8674- switch (op[2] & 0x00)
11612+ switch (op[2] & 0x0f)
867511613 {
867611614 case 0x00:
8677- goto op_semantics_68;
11615+ case 0x01:
11616+ case 0x02:
11617+ case 0x03:
11618+ case 0x04:
11619+ case 0x05:
11620+ case 0x06:
11621+ case 0x07:
11622+ case 0x08:
11623+ case 0x09:
11624+ case 0x0a:
11625+ case 0x0b:
11626+ case 0x0c:
11627+ case 0x0d:
11628+ case 0x0e:
11629+ goto op_semantics_88;
11630+ break;
11631+ case 0x0f:
11632+ goto op_semantics_89;
867811633 break;
867911634 }
868011635 break;
8681- case 0x96:
11636+ case 0xee:
868211637 GETBYTE ();
8683- switch (op[2] & 0x00)
11638+ switch (op[2] & 0x0f)
868411639 {
868511640 case 0x00:
8686- goto op_semantics_68;
11641+ case 0x01:
11642+ case 0x02:
11643+ case 0x03:
11644+ case 0x04:
11645+ case 0x05:
11646+ case 0x06:
11647+ case 0x07:
11648+ case 0x08:
11649+ case 0x09:
11650+ case 0x0a:
11651+ case 0x0b:
11652+ case 0x0c:
11653+ case 0x0d:
11654+ case 0x0e:
11655+ goto op_semantics_88;
868711656 break;
8688- }
8689- break;
8690- case 0x97:
8691- GETBYTE ();
8692- switch (op[2] & 0x00)
8693- {
8694- case 0x00:
8695- goto op_semantics_68;
11657+ case 0x0f:
11658+ goto op_semantics_89;
869611659 break;
869711660 }
869811661 break;
8699- case 0x98:
11662+ case 0xef:
870011663 GETBYTE ();
8701- switch (op[2] & 0x00)
11664+ switch (op[2] & 0x0f)
870211665 {
870311666 case 0x00:
8704- op_semantics_69:
8705- {
8706- /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8707-#line 927 "rx-decode.opc"
8708- int sd AU = op[1] & 0x03;
8709-#line 927 "rx-decode.opc"
8710- int rsrc AU = (op[2] >> 4) & 0x0f;
8711-#line 927 "rx-decode.opc"
8712- int rdst AU = op[2] & 0x0f;
8713- if (trace)
8714- {
8715- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8716- "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8717- op[0], op[1], op[2]);
8718- printf (" sd = 0x%x,", sd);
8719- printf (" rsrc = 0x%x,", rsrc);
8720- printf (" rdst = 0x%x\n", rdst);
8721- }
8722- SYNTAX("round %1%S1, %0");
8723-#line 927 "rx-decode.opc"
8724- ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8725-
8726- }
11667+ case 0x01:
11668+ case 0x02:
11669+ case 0x03:
11670+ case 0x04:
11671+ case 0x05:
11672+ case 0x06:
11673+ case 0x07:
11674+ case 0x08:
11675+ case 0x09:
11676+ case 0x0a:
11677+ case 0x0b:
11678+ case 0x0c:
11679+ case 0x0d:
11680+ case 0x0e:
11681+ goto op_semantics_88;
11682+ break;
11683+ case 0x0f:
11684+ goto op_semantics_89;
872711685 break;
872811686 }
872911687 break;
8730- case 0x99:
11688+ case 0xf0:
873111689 GETBYTE ();
8732- switch (op[2] & 0x00)
11690+ switch (op[2] & 0x0f)
873311691 {
873411692 case 0x00:
8735- goto op_semantics_69;
11693+ case 0x01:
11694+ case 0x02:
11695+ case 0x03:
11696+ case 0x04:
11697+ case 0x05:
11698+ case 0x06:
11699+ case 0x07:
11700+ case 0x08:
11701+ case 0x09:
11702+ case 0x0a:
11703+ case 0x0b:
11704+ case 0x0c:
11705+ case 0x0d:
11706+ case 0x0e:
11707+ goto op_semantics_88;
11708+ break;
11709+ case 0x0f:
11710+ goto op_semantics_89;
873611711 break;
873711712 }
873811713 break;
8739- case 0x9a:
11714+ case 0xf1:
874011715 GETBYTE ();
8741- switch (op[2] & 0x00)
11716+ switch (op[2] & 0x0f)
874211717 {
874311718 case 0x00:
8744- goto op_semantics_69;
11719+ case 0x01:
11720+ case 0x02:
11721+ case 0x03:
11722+ case 0x04:
11723+ case 0x05:
11724+ case 0x06:
11725+ case 0x07:
11726+ case 0x08:
11727+ case 0x09:
11728+ case 0x0a:
11729+ case 0x0b:
11730+ case 0x0c:
11731+ case 0x0d:
11732+ case 0x0e:
11733+ goto op_semantics_88;
11734+ break;
11735+ case 0x0f:
11736+ goto op_semantics_89;
874511737 break;
874611738 }
874711739 break;
8748- case 0x9b:
11740+ case 0xf2:
874911741 GETBYTE ();
8750- switch (op[2] & 0x00)
11742+ switch (op[2] & 0x0f)
875111743 {
875211744 case 0x00:
8753- goto op_semantics_69;
11745+ case 0x01:
11746+ case 0x02:
11747+ case 0x03:
11748+ case 0x04:
11749+ case 0x05:
11750+ case 0x06:
11751+ case 0x07:
11752+ case 0x08:
11753+ case 0x09:
11754+ case 0x0a:
11755+ case 0x0b:
11756+ case 0x0c:
11757+ case 0x0d:
11758+ case 0x0e:
11759+ goto op_semantics_88;
11760+ break;
11761+ case 0x0f:
11762+ goto op_semantics_89;
875411763 break;
875511764 }
875611765 break;
8757- case 0xa0:
11766+ case 0xf3:
875811767 GETBYTE ();
8759- switch (op[2] & 0x00)
11768+ switch (op[2] & 0x0f)
876011769 {
876111770 case 0x00:
8762- op_semantics_70:
8763- {
8764- /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
8765-#line 1110 "rx-decode.opc"
8766- int sd AU = op[1] & 0x03;
8767-#line 1110 "rx-decode.opc"
8768- int rsrc AU = (op[2] >> 4) & 0x0f;
8769-#line 1110 "rx-decode.opc"
8770- int rdst AU = op[2] & 0x0f;
8771- if (trace)
8772- {
8773- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8774- "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
8775- op[0], op[1], op[2]);
8776- printf (" sd = 0x%x,", sd);
8777- printf (" rsrc = 0x%x,", rsrc);
8778- printf (" rdst = 0x%x\n", rdst);
8779- }
8780- SYNTAX("fsqrt %1%S1, %0");
8781-#line 1110 "rx-decode.opc"
8782- ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8783-
8784- }
11771+ case 0x01:
11772+ case 0x02:
11773+ case 0x03:
11774+ case 0x04:
11775+ case 0x05:
11776+ case 0x06:
11777+ case 0x07:
11778+ case 0x08:
11779+ case 0x09:
11780+ case 0x0a:
11781+ case 0x0b:
11782+ case 0x0c:
11783+ case 0x0d:
11784+ case 0x0e:
11785+ goto op_semantics_88;
11786+ break;
11787+ case 0x0f:
11788+ goto op_semantics_89;
878511789 break;
878611790 }
878711791 break;
8788- case 0xa1:
11792+ case 0xf4:
878911793 GETBYTE ();
8790- switch (op[2] & 0x00)
11794+ switch (op[2] & 0x0f)
879111795 {
879211796 case 0x00:
8793- goto op_semantics_70;
11797+ case 0x01:
11798+ case 0x02:
11799+ case 0x03:
11800+ case 0x04:
11801+ case 0x05:
11802+ case 0x06:
11803+ case 0x07:
11804+ case 0x08:
11805+ case 0x09:
11806+ case 0x0a:
11807+ case 0x0b:
11808+ case 0x0c:
11809+ case 0x0d:
11810+ case 0x0e:
11811+ goto op_semantics_88;
11812+ break;
11813+ case 0x0f:
11814+ goto op_semantics_89;
879411815 break;
879511816 }
879611817 break;
8797- case 0xa2:
11818+ case 0xf5:
879811819 GETBYTE ();
8799- switch (op[2] & 0x00)
11820+ switch (op[2] & 0x0f)
880011821 {
880111822 case 0x00:
8802- goto op_semantics_70;
11823+ case 0x01:
11824+ case 0x02:
11825+ case 0x03:
11826+ case 0x04:
11827+ case 0x05:
11828+ case 0x06:
11829+ case 0x07:
11830+ case 0x08:
11831+ case 0x09:
11832+ case 0x0a:
11833+ case 0x0b:
11834+ case 0x0c:
11835+ case 0x0d:
11836+ case 0x0e:
11837+ goto op_semantics_88;
11838+ break;
11839+ case 0x0f:
11840+ goto op_semantics_89;
880311841 break;
880411842 }
880511843 break;
8806- case 0xa3:
11844+ case 0xf6:
880711845 GETBYTE ();
8808- switch (op[2] & 0x00)
11846+ switch (op[2] & 0x0f)
880911847 {
881011848 case 0x00:
8811- goto op_semantics_70;
11849+ case 0x01:
11850+ case 0x02:
11851+ case 0x03:
11852+ case 0x04:
11853+ case 0x05:
11854+ case 0x06:
11855+ case 0x07:
11856+ case 0x08:
11857+ case 0x09:
11858+ case 0x0a:
11859+ case 0x0b:
11860+ case 0x0c:
11861+ case 0x0d:
11862+ case 0x0e:
11863+ goto op_semantics_88;
11864+ break;
11865+ case 0x0f:
11866+ goto op_semantics_89;
881211867 break;
881311868 }
881411869 break;
8815- case 0xa4:
11870+ case 0xf7:
881611871 GETBYTE ();
8817- switch (op[2] & 0x00)
11872+ switch (op[2] & 0x0f)
881811873 {
881911874 case 0x00:
8820- op_semantics_71:
8821- {
8822- /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */
8823-#line 1113 "rx-decode.opc"
8824- int sd AU = op[1] & 0x03;
8825-#line 1113 "rx-decode.opc"
8826- int rsrc AU = (op[2] >> 4) & 0x0f;
8827-#line 1113 "rx-decode.opc"
8828- int rdst AU = op[2] & 0x0f;
8829- if (trace)
8830- {
8831- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8832- "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */",
8833- op[0], op[1], op[2]);
8834- printf (" sd = 0x%x,", sd);
8835- printf (" rsrc = 0x%x,", rsrc);
8836- printf (" rdst = 0x%x\n", rdst);
8837- }
8838- SYNTAX("ftou %1%S1, %0");
8839-#line 1113 "rx-decode.opc"
8840- ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8841-
8842- }
11875+ case 0x01:
11876+ case 0x02:
11877+ case 0x03:
11878+ case 0x04:
11879+ case 0x05:
11880+ case 0x06:
11881+ case 0x07:
11882+ case 0x08:
11883+ case 0x09:
11884+ case 0x0a:
11885+ case 0x0b:
11886+ case 0x0c:
11887+ case 0x0d:
11888+ case 0x0e:
11889+ goto op_semantics_88;
11890+ break;
11891+ case 0x0f:
11892+ goto op_semantics_89;
884311893 break;
884411894 }
884511895 break;
8846- case 0xa5:
11896+ case 0xf8:
884711897 GETBYTE ();
8848- switch (op[2] & 0x00)
11898+ switch (op[2] & 0x0f)
884911899 {
885011900 case 0x00:
8851- goto op_semantics_71;
11901+ case 0x01:
11902+ case 0x02:
11903+ case 0x03:
11904+ case 0x04:
11905+ case 0x05:
11906+ case 0x06:
11907+ case 0x07:
11908+ case 0x08:
11909+ case 0x09:
11910+ case 0x0a:
11911+ case 0x0b:
11912+ case 0x0c:
11913+ case 0x0d:
11914+ case 0x0e:
11915+ goto op_semantics_88;
11916+ break;
11917+ case 0x0f:
11918+ goto op_semantics_89;
885211919 break;
885311920 }
885411921 break;
8855- case 0xa6:
11922+ case 0xf9:
885611923 GETBYTE ();
8857- switch (op[2] & 0x00)
11924+ switch (op[2] & 0x0f)
885811925 {
885911926 case 0x00:
8860- goto op_semantics_71;
11927+ case 0x01:
11928+ case 0x02:
11929+ case 0x03:
11930+ case 0x04:
11931+ case 0x05:
11932+ case 0x06:
11933+ case 0x07:
11934+ case 0x08:
11935+ case 0x09:
11936+ case 0x0a:
11937+ case 0x0b:
11938+ case 0x0c:
11939+ case 0x0d:
11940+ case 0x0e:
11941+ goto op_semantics_88;
11942+ break;
11943+ case 0x0f:
11944+ goto op_semantics_89;
886111945 break;
886211946 }
886311947 break;
8864- case 0xa7:
11948+ case 0xfa:
886511949 GETBYTE ();
8866- switch (op[2] & 0x00)
11950+ switch (op[2] & 0x0f)
886711951 {
886811952 case 0x00:
8869- goto op_semantics_71;
11953+ case 0x01:
11954+ case 0x02:
11955+ case 0x03:
11956+ case 0x04:
11957+ case 0x05:
11958+ case 0x06:
11959+ case 0x07:
11960+ case 0x08:
11961+ case 0x09:
11962+ case 0x0a:
11963+ case 0x0b:
11964+ case 0x0c:
11965+ case 0x0d:
11966+ case 0x0e:
11967+ goto op_semantics_88;
11968+ break;
11969+ case 0x0f:
11970+ goto op_semantics_89;
887011971 break;
887111972 }
887211973 break;
8873- case 0xd0:
11974+ case 0xfb:
887411975 GETBYTE ();
8875- switch (op[2] & 0x00)
11976+ switch (op[2] & 0x0f)
887611977 {
887711978 case 0x00:
8878- op_semantics_72:
8879- {
8880- /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8881-#line 1044 "rx-decode.opc"
8882- int sz AU = (op[1] >> 2) & 0x03;
8883-#line 1044 "rx-decode.opc"
8884- int sd AU = op[1] & 0x03;
8885-#line 1044 "rx-decode.opc"
8886- int rdst AU = (op[2] >> 4) & 0x0f;
8887-#line 1044 "rx-decode.opc"
8888- int cond AU = op[2] & 0x0f;
8889- if (trace)
8890- {
8891- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8892- "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8893- op[0], op[1], op[2]);
8894- printf (" sz = 0x%x,", sz);
8895- printf (" sd = 0x%x,", sd);
8896- printf (" rdst = 0x%x,", rdst);
8897- printf (" cond = 0x%x\n", cond);
8898- }
8899- SYNTAX("sc%1%s %0");
8900-#line 1044 "rx-decode.opc"
8901- ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8902-
8903- /*----------------------------------------------------------------------*/
8904- /* RXv2 enhanced */
8905-
8906- }
11979+ case 0x01:
11980+ case 0x02:
11981+ case 0x03:
11982+ case 0x04:
11983+ case 0x05:
11984+ case 0x06:
11985+ case 0x07:
11986+ case 0x08:
11987+ case 0x09:
11988+ case 0x0a:
11989+ case 0x0b:
11990+ case 0x0c:
11991+ case 0x0d:
11992+ case 0x0e:
11993+ goto op_semantics_88;
11994+ break;
11995+ case 0x0f:
11996+ goto op_semantics_89;
890711997 break;
890811998 }
890911999 break;
8910- case 0xd1:
12000+ case 0xfc:
891112001 GETBYTE ();
8912- switch (op[2] & 0x00)
12002+ switch (op[2] & 0x0f)
891312003 {
891412004 case 0x00:
8915- goto op_semantics_72;
12005+ case 0x01:
12006+ case 0x02:
12007+ case 0x03:
12008+ case 0x04:
12009+ case 0x05:
12010+ case 0x06:
12011+ case 0x07:
12012+ case 0x08:
12013+ case 0x09:
12014+ case 0x0a:
12015+ case 0x0b:
12016+ case 0x0c:
12017+ case 0x0d:
12018+ case 0x0e:
12019+ goto op_semantics_88;
12020+ break;
12021+ case 0x0f:
12022+ goto op_semantics_89;
891612023 break;
891712024 }
891812025 break;
8919- case 0xd2:
12026+ case 0xfd:
892012027 GETBYTE ();
8921- switch (op[2] & 0x00)
12028+ switch (op[2] & 0x0f)
892212029 {
892312030 case 0x00:
8924- goto op_semantics_72;
12031+ case 0x01:
12032+ case 0x02:
12033+ case 0x03:
12034+ case 0x04:
12035+ case 0x05:
12036+ case 0x06:
12037+ case 0x07:
12038+ case 0x08:
12039+ case 0x09:
12040+ case 0x0a:
12041+ case 0x0b:
12042+ case 0x0c:
12043+ case 0x0d:
12044+ case 0x0e:
12045+ goto op_semantics_88;
12046+ break;
12047+ case 0x0f:
12048+ goto op_semantics_89;
892512049 break;
892612050 }
892712051 break;
8928- case 0xd3:
12052+ case 0xfe:
892912053 GETBYTE ();
8930- switch (op[2] & 0x00)
12054+ switch (op[2] & 0x0f)
893112055 {
893212056 case 0x00:
8933- goto op_semantics_72;
12057+ case 0x01:
12058+ case 0x02:
12059+ case 0x03:
12060+ case 0x04:
12061+ case 0x05:
12062+ case 0x06:
12063+ case 0x07:
12064+ case 0x08:
12065+ case 0x09:
12066+ case 0x0a:
12067+ case 0x0b:
12068+ case 0x0c:
12069+ case 0x0d:
12070+ case 0x0e:
12071+ goto op_semantics_88;
12072+ break;
12073+ case 0x0f:
12074+ goto op_semantics_89;
893412075 break;
893512076 }
893612077 break;
8937- case 0xd4:
12078+ case 0xff:
893812079 GETBYTE ();
8939- switch (op[2] & 0x00)
12080+ switch (op[2] & 0x0f)
894012081 {
894112082 case 0x00:
8942- goto op_semantics_72;
12083+ case 0x01:
12084+ case 0x02:
12085+ case 0x03:
12086+ case 0x04:
12087+ case 0x05:
12088+ case 0x06:
12089+ case 0x07:
12090+ case 0x08:
12091+ case 0x09:
12092+ case 0x0a:
12093+ case 0x0b:
12094+ case 0x0c:
12095+ case 0x0d:
12096+ case 0x0e:
12097+ goto op_semantics_88;
12098+ break;
12099+ case 0x0f:
12100+ goto op_semantics_89;
894312101 break;
894412102 }
894512103 break;
8946- case 0xd5:
12104+ default: UNSUPPORTED(); break;
12105+ }
12106+ break;
12107+ case 0xfd:
12108+ GETBYTE ();
12109+ switch (op[1] & 0xff)
12110+ {
12111+ case 0x00:
894712112 GETBYTE ();
894812113 switch (op[2] & 0x00)
894912114 {
895012115 case 0x00:
8951- goto op_semantics_72;
12116+ op_semantics_90:
12117+ {
12118+ /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
12119+#line 873 "rx-decode.opc"
12120+ int a AU = (op[1] >> 3) & 0x01;
12121+#line 873 "rx-decode.opc"
12122+ int srca AU = (op[2] >> 4) & 0x0f;
12123+#line 873 "rx-decode.opc"
12124+ int srcb AU = op[2] & 0x0f;
12125+ if (trace)
12126+ {
12127+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12128+ "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
12129+ op[0], op[1], op[2]);
12130+ printf (" a = 0x%x,", a);
12131+ printf (" srca = 0x%x,", srca);
12132+ printf (" srcb = 0x%x\n", srcb);
12133+ }
12134+ SYNTAX("mulhi %1, %2, %0");
12135+#line 873 "rx-decode.opc"
12136+ ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
12137+
12138+ }
895212139 break;
895312140 }
895412141 break;
8955- case 0xd6:
12142+ case 0x01:
895612143 GETBYTE ();
895712144 switch (op[2] & 0x00)
895812145 {
895912146 case 0x00:
8960- goto op_semantics_72;
12147+ op_semantics_91:
12148+ {
12149+ /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
12150+#line 876 "rx-decode.opc"
12151+ int a AU = (op[1] >> 3) & 0x01;
12152+#line 876 "rx-decode.opc"
12153+ int srca AU = (op[2] >> 4) & 0x0f;
12154+#line 876 "rx-decode.opc"
12155+ int srcb AU = op[2] & 0x0f;
12156+ if (trace)
12157+ {
12158+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12159+ "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
12160+ op[0], op[1], op[2]);
12161+ printf (" a = 0x%x,", a);
12162+ printf (" srca = 0x%x,", srca);
12163+ printf (" srcb = 0x%x\n", srcb);
12164+ }
12165+ SYNTAX("mullo %1, %2, %0");
12166+#line 876 "rx-decode.opc"
12167+ ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
12168+
12169+ }
896112170 break;
896212171 }
896312172 break;
8964- case 0xd7:
12173+ case 0x02:
896512174 GETBYTE ();
896612175 switch (op[2] & 0x00)
896712176 {
896812177 case 0x00:
8969- goto op_semantics_72;
12178+ op_semantics_92:
12179+ {
12180+ /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
12181+#line 1104 "rx-decode.opc"
12182+ int a AU = (op[1] >> 3) & 0x01;
12183+#line 1104 "rx-decode.opc"
12184+ int srca AU = (op[2] >> 4) & 0x0f;
12185+#line 1104 "rx-decode.opc"
12186+ int srcb AU = op[2] & 0x0f;
12187+ if (trace)
12188+ {
12189+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12190+ "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
12191+ op[0], op[1], op[2]);
12192+ printf (" a = 0x%x,", a);
12193+ printf (" srca = 0x%x,", srca);
12194+ printf (" srcb = 0x%x\n", srcb);
12195+ }
12196+ SYNTAX("mullh %1, %2, %0");
12197+#line 1104 "rx-decode.opc"
12198+ ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
12199+
12200+ }
897012201 break;
897112202 }
897212203 break;
8973- case 0xd8:
12204+ case 0x03:
897412205 GETBYTE ();
897512206 switch (op[2] & 0x00)
897612207 {
897712208 case 0x00:
8978- goto op_semantics_72;
12209+ op_semantics_93:
12210+ {
12211+ /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
12212+#line 1089 "rx-decode.opc"
12213+ int a AU = (op[1] >> 3) & 0x01;
12214+#line 1089 "rx-decode.opc"
12215+ int srca AU = (op[2] >> 4) & 0x0f;
12216+#line 1089 "rx-decode.opc"
12217+ int srcb AU = op[2] & 0x0f;
12218+ if (trace)
12219+ {
12220+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12221+ "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
12222+ op[0], op[1], op[2]);
12223+ printf (" a = 0x%x,", a);
12224+ printf (" srca = 0x%x,", srca);
12225+ printf (" srcb = 0x%x\n", srcb);
12226+ }
12227+ SYNTAX("emula %1, %2, %0");
12228+#line 1089 "rx-decode.opc"
12229+ ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
12230+
12231+ }
897912232 break;
898012233 }
898112234 break;
8982- case 0xd9:
12235+ case 0x04:
898312236 GETBYTE ();
898412237 switch (op[2] & 0x00)
898512238 {
898612239 case 0x00:
8987- goto op_semantics_72;
12240+ op_semantics_94:
12241+ {
12242+ /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
12243+#line 879 "rx-decode.opc"
12244+ int a AU = (op[1] >> 3) & 0x01;
12245+#line 879 "rx-decode.opc"
12246+ int srca AU = (op[2] >> 4) & 0x0f;
12247+#line 879 "rx-decode.opc"
12248+ int srcb AU = op[2] & 0x0f;
12249+ if (trace)
12250+ {
12251+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12252+ "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
12253+ op[0], op[1], op[2]);
12254+ printf (" a = 0x%x,", a);
12255+ printf (" srca = 0x%x,", srca);
12256+ printf (" srcb = 0x%x\n", srcb);
12257+ }
12258+ SYNTAX("machi %1, %2, %0");
12259+#line 879 "rx-decode.opc"
12260+ ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
12261+
12262+ }
898812263 break;
898912264 }
899012265 break;
8991- case 0xda:
12266+ case 0x05:
899212267 GETBYTE ();
899312268 switch (op[2] & 0x00)
899412269 {
899512270 case 0x00:
8996- goto op_semantics_72;
12271+ op_semantics_95:
12272+ {
12273+ /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
12274+#line 882 "rx-decode.opc"
12275+ int a AU = (op[1] >> 3) & 0x01;
12276+#line 882 "rx-decode.opc"
12277+ int srca AU = (op[2] >> 4) & 0x0f;
12278+#line 882 "rx-decode.opc"
12279+ int srcb AU = op[2] & 0x0f;
12280+ if (trace)
12281+ {
12282+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12283+ "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
12284+ op[0], op[1], op[2]);
12285+ printf (" a = 0x%x,", a);
12286+ printf (" srca = 0x%x,", srca);
12287+ printf (" srcb = 0x%x\n", srcb);
12288+ }
12289+ SYNTAX("maclo %1, %2, %0");
12290+#line 882 "rx-decode.opc"
12291+ ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
12292+
12293+ }
899712294 break;
899812295 }
899912296 break;
9000- case 0xdb:
12297+ case 0x06:
900112298 GETBYTE ();
900212299 switch (op[2] & 0x00)
900312300 {
900412301 case 0x00:
9005- goto op_semantics_72;
9006- break;
9007- }
9008- break;
9009- case 0xe0:
9010- GETBYTE ();
9011- switch (op[2] & 0x0f)
9012- {
9013- case 0x00:
9014- case 0x01:
9015- case 0x02:
9016- case 0x03:
9017- case 0x04:
9018- case 0x05:
9019- case 0x06:
9020- case 0x07:
9021- case 0x08:
9022- case 0x09:
9023- case 0x0a:
9024- case 0x0b:
9025- case 0x0c:
9026- case 0x0d:
9027- case 0x0e:
9028- op_semantics_73:
12302+ op_semantics_96:
902912303 {
9030- /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
9031-#line 987 "rx-decode.opc"
9032- int bit AU = (op[1] >> 2) & 0x07;
9033-#line 987 "rx-decode.opc"
9034- int sd AU = op[1] & 0x03;
9035-#line 987 "rx-decode.opc"
9036- int rdst AU = (op[2] >> 4) & 0x0f;
9037-#line 987 "rx-decode.opc"
9038- int cond AU = op[2] & 0x0f;
12304+ /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
12305+#line 1092 "rx-decode.opc"
12306+ int a AU = (op[1] >> 3) & 0x01;
12307+#line 1092 "rx-decode.opc"
12308+ int srca AU = (op[2] >> 4) & 0x0f;
12309+#line 1092 "rx-decode.opc"
12310+ int srcb AU = op[2] & 0x0f;
903912311 if (trace)
904012312 {
904112313 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9042- "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
12314+ "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
904312315 op[0], op[1], op[2]);
9044- printf (" bit = 0x%x,", bit);
9045- printf (" sd = 0x%x,", sd);
9046- printf (" rdst = 0x%x,", rdst);
9047- printf (" cond = 0x%x\n", cond);
12316+ printf (" a = 0x%x,", a);
12317+ printf (" srca = 0x%x,", srca);
12318+ printf (" srcb = 0x%x\n", srcb);
904812319 }
9049- SYNTAX("bm%2 #%1, %0%S0");
9050-#line 987 "rx-decode.opc"
9051- ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
12320+ SYNTAX("maclh %1, %2, %0");
12321+#line 1092 "rx-decode.opc"
12322+ ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
905212323
905312324 }
905412325 break;
9055- case 0x0f:
9056- op_semantics_74:
12326+ }
12327+ break;
12328+ case 0x07:
12329+ GETBYTE ();
12330+ switch (op[2] & 0x00)
12331+ {
12332+ case 0x00:
12333+ op_semantics_97:
905712334 {
9058- /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
9059-#line 975 "rx-decode.opc"
9060- int bit AU = (op[1] >> 2) & 0x07;
9061-#line 975 "rx-decode.opc"
9062- int sd AU = op[1] & 0x03;
9063-#line 975 "rx-decode.opc"
9064- int rdst AU = (op[2] >> 4) & 0x0f;
12335+ /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
12336+#line 1083 "rx-decode.opc"
12337+ int a AU = (op[1] >> 3) & 0x01;
12338+#line 1083 "rx-decode.opc"
12339+ int srca AU = (op[2] >> 4) & 0x0f;
12340+#line 1083 "rx-decode.opc"
12341+ int srcb AU = op[2] & 0x0f;
906512342 if (trace)
906612343 {
906712344 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9068- "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
12345+ "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
906912346 op[0], op[1], op[2]);
9070- printf (" bit = 0x%x,", bit);
9071- printf (" sd = 0x%x,", sd);
9072- printf (" rdst = 0x%x\n", rdst);
12347+ printf (" a = 0x%x,", a);
12348+ printf (" srca = 0x%x,", srca);
12349+ printf (" srcb = 0x%x\n", srcb);
907312350 }
9074- SYNTAX("bnot #%1, %0%S0");
9075-#line 975 "rx-decode.opc"
9076- ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
12351+ SYNTAX("emaca %1, %2, %0");
12352+#line 1083 "rx-decode.opc"
12353+ ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
907712354
907812355 }
907912356 break;
908012357 }
908112358 break;
9082- case 0xe1:
12359+ case 0x08:
908312360 GETBYTE ();
9084- switch (op[2] & 0x0f)
12361+ switch (op[2] & 0x00)
908512362 {
908612363 case 0x00:
9087- case 0x01:
9088- case 0x02:
9089- case 0x03:
9090- case 0x04:
9091- case 0x05:
9092- case 0x06:
9093- case 0x07:
9094- case 0x08:
9095- case 0x09:
9096- case 0x0a:
9097- case 0x0b:
9098- case 0x0c:
9099- case 0x0d:
9100- case 0x0e:
9101- goto op_semantics_73;
9102- break;
9103- case 0x0f:
9104- goto op_semantics_74;
12364+ goto op_semantics_90;
910512365 break;
910612366 }
910712367 break;
9108- case 0xe2:
12368+ case 0x09:
910912369 GETBYTE ();
9110- switch (op[2] & 0x0f)
12370+ switch (op[2] & 0x00)
911112371 {
911212372 case 0x00:
9113- case 0x01:
9114- case 0x02:
9115- case 0x03:
9116- case 0x04:
9117- case 0x05:
9118- case 0x06:
9119- case 0x07:
9120- case 0x08:
9121- case 0x09:
9122- case 0x0a:
9123- case 0x0b:
9124- case 0x0c:
9125- case 0x0d:
9126- case 0x0e:
9127- goto op_semantics_73;
9128- break;
9129- case 0x0f:
9130- goto op_semantics_74;
12373+ goto op_semantics_91;
913112374 break;
913212375 }
913312376 break;
9134- case 0xe3:
12377+ case 0x0a:
913512378 GETBYTE ();
9136- switch (op[2] & 0x0f)
12379+ switch (op[2] & 0x00)
913712380 {
913812381 case 0x00:
9139- case 0x01:
9140- case 0x02:
9141- case 0x03:
9142- case 0x04:
9143- case 0x05:
9144- case 0x06:
9145- case 0x07:
9146- case 0x08:
9147- case 0x09:
9148- case 0x0a:
9149- case 0x0b:
9150- case 0x0c:
9151- case 0x0d:
9152- case 0x0e:
9153- goto op_semantics_73;
12382+ goto op_semantics_92;
915412383 break;
9155- case 0x0f:
9156- goto op_semantics_74;
12384+ }
12385+ break;
12386+ case 0x0b:
12387+ GETBYTE ();
12388+ switch (op[2] & 0x00)
12389+ {
12390+ case 0x00:
12391+ goto op_semantics_93;
915712392 break;
915812393 }
915912394 break;
9160- case 0xe4:
12395+ case 0x0c:
916112396 GETBYTE ();
9162- switch (op[2] & 0x0f)
12397+ switch (op[2] & 0x00)
916312398 {
916412399 case 0x00:
9165- case 0x01:
9166- case 0x02:
9167- case 0x03:
9168- case 0x04:
9169- case 0x05:
9170- case 0x06:
9171- case 0x07:
9172- case 0x08:
9173- case 0x09:
9174- case 0x0a:
9175- case 0x0b:
9176- case 0x0c:
9177- case 0x0d:
9178- case 0x0e:
9179- goto op_semantics_73;
12400+ goto op_semantics_94;
918012401 break;
9181- case 0x0f:
9182- goto op_semantics_74;
12402+ }
12403+ break;
12404+ case 0x0d:
12405+ GETBYTE ();
12406+ switch (op[2] & 0x00)
12407+ {
12408+ case 0x00:
12409+ goto op_semantics_95;
918312410 break;
918412411 }
918512412 break;
9186- case 0xe5:
12413+ case 0x0e:
918712414 GETBYTE ();
9188- switch (op[2] & 0x0f)
12415+ switch (op[2] & 0x00)
918912416 {
919012417 case 0x00:
9191- case 0x01:
9192- case 0x02:
9193- case 0x03:
9194- case 0x04:
9195- case 0x05:
9196- case 0x06:
9197- case 0x07:
9198- case 0x08:
9199- case 0x09:
9200- case 0x0a:
9201- case 0x0b:
9202- case 0x0c:
9203- case 0x0d:
9204- case 0x0e:
9205- goto op_semantics_73;
12418+ goto op_semantics_96;
920612419 break;
9207- case 0x0f:
9208- goto op_semantics_74;
12420+ }
12421+ break;
12422+ case 0x0f:
12423+ GETBYTE ();
12424+ switch (op[2] & 0x00)
12425+ {
12426+ case 0x00:
12427+ goto op_semantics_97;
920912428 break;
921012429 }
921112430 break;
9212- case 0xe6:
12431+ case 0x17:
921312432 GETBYTE ();
9214- switch (op[2] & 0x0f)
12433+ switch (op[2] & 0x70)
921512434 {
921612435 case 0x00:
9217- case 0x01:
9218- case 0x02:
9219- case 0x03:
9220- case 0x04:
9221- case 0x05:
9222- case 0x06:
9223- case 0x07:
9224- case 0x08:
9225- case 0x09:
9226- case 0x0a:
9227- case 0x0b:
9228- case 0x0c:
9229- case 0x0d:
9230- case 0x0e:
9231- goto op_semantics_73;
12436+ {
12437+ /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
12438+#line 885 "rx-decode.opc"
12439+ int a AU = (op[2] >> 7) & 0x01;
12440+#line 885 "rx-decode.opc"
12441+ int rsrc AU = op[2] & 0x0f;
12442+ if (trace)
12443+ {
12444+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12445+ "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
12446+ op[0], op[1], op[2]);
12447+ printf (" a = 0x%x,", a);
12448+ printf (" rsrc = 0x%x\n", rsrc);
12449+ }
12450+ SYNTAX("mvtachi %1, %0");
12451+#line 885 "rx-decode.opc"
12452+ ID(mvtachi); DR(a+32); SR(rsrc); F_____;
12453+
12454+ }
923212455 break;
9233- case 0x0f:
9234- goto op_semantics_74;
12456+ case 0x10:
12457+ {
12458+ /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
12459+#line 888 "rx-decode.opc"
12460+ int a AU = (op[2] >> 7) & 0x01;
12461+#line 888 "rx-decode.opc"
12462+ int rsrc AU = op[2] & 0x0f;
12463+ if (trace)
12464+ {
12465+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12466+ "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
12467+ op[0], op[1], op[2]);
12468+ printf (" a = 0x%x,", a);
12469+ printf (" rsrc = 0x%x\n", rsrc);
12470+ }
12471+ SYNTAX("mvtaclo %1, %0");
12472+#line 888 "rx-decode.opc"
12473+ ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
12474+
12475+ }
12476+ break;
12477+ case 0x30:
12478+ {
12479+ /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
12480+#line 1110 "rx-decode.opc"
12481+ int a AU = (op[2] >> 7) & 0x01;
12482+#line 1110 "rx-decode.opc"
12483+ int rdst AU = op[2] & 0x0f;
12484+ if (trace)
12485+ {
12486+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12487+ "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
12488+ op[0], op[1], op[2]);
12489+ printf (" a = 0x%x,", a);
12490+ printf (" rdst = 0x%x\n", rdst);
12491+ }
12492+ SYNTAX("mvtacgu %0, %1");
12493+#line 1110 "rx-decode.opc"
12494+ ID(mvtacgu); DR(a+32); SR(rdst); F_____;
12495+
12496+ }
923512497 break;
12498+ default: UNSUPPORTED(); break;
923612499 }
923712500 break;
9238- case 0xe7:
12501+ case 0x18:
923912502 GETBYTE ();
9240- switch (op[2] & 0x0f)
12503+ switch (op[2] & 0x6f)
924112504 {
924212505 case 0x00:
9243- case 0x01:
9244- case 0x02:
9245- case 0x03:
9246- case 0x04:
9247- case 0x05:
9248- case 0x06:
9249- case 0x07:
9250- case 0x08:
9251- case 0x09:
9252- case 0x0a:
9253- case 0x0b:
9254- case 0x0c:
9255- case 0x0d:
9256- case 0x0e:
9257- goto op_semantics_73;
12506+ {
12507+ /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
12508+#line 900 "rx-decode.opc"
12509+ int a AU = (op[2] >> 7) & 0x01;
12510+#line 900 "rx-decode.opc"
12511+ int i AU = (op[2] >> 4) & 0x01;
12512+ if (trace)
12513+ {
12514+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12515+ "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
12516+ op[0], op[1], op[2]);
12517+ printf (" a = 0x%x,", a);
12518+ printf (" i = 0x%x\n", i);
12519+ }
12520+ SYNTAX("racw #%1, %0");
12521+#line 900 "rx-decode.opc"
12522+ ID(racw); SC(i+1); DR(a+32); F_____;
12523+
12524+ /*----------------------------------------------------------------------*/
12525+ /* SAT */
12526+
12527+ }
925812528 break;
9259- case 0x0f:
9260- goto op_semantics_74;
12529+ case 0x40:
12530+ {
12531+ /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
12532+#line 1119 "rx-decode.opc"
12533+ int a AU = (op[2] >> 7) & 0x01;
12534+#line 1119 "rx-decode.opc"
12535+ int i AU = (op[2] >> 4) & 0x01;
12536+ if (trace)
12537+ {
12538+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12539+ "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
12540+ op[0], op[1], op[2]);
12541+ printf (" a = 0x%x,", a);
12542+ printf (" i = 0x%x\n", i);
12543+ }
12544+ SYNTAX("rdacw #%1, %0");
12545+#line 1119 "rx-decode.opc"
12546+ ID(rdacw); SC(i+1); DR(a+32); F_____;
12547+
12548+ }
926112549 break;
12550+ default: UNSUPPORTED(); break;
926212551 }
926312552 break;
9264- case 0xe8:
12553+ case 0x19:
926512554 GETBYTE ();
9266- switch (op[2] & 0x0f)
12555+ switch (op[2] & 0x6f)
926712556 {
926812557 case 0x00:
9269- case 0x01:
9270- case 0x02:
9271- case 0x03:
9272- case 0x04:
9273- case 0x05:
9274- case 0x06:
9275- case 0x07:
9276- case 0x08:
9277- case 0x09:
9278- case 0x0a:
9279- case 0x0b:
9280- case 0x0c:
9281- case 0x0d:
9282- case 0x0e:
9283- goto op_semantics_73;
12558+ {
12559+ /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
12560+#line 1113 "rx-decode.opc"
12561+ int a AU = (op[2] >> 7) & 0x01;
12562+#line 1113 "rx-decode.opc"
12563+ int i AU = (op[2] >> 4) & 0x01;
12564+ if (trace)
12565+ {
12566+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12567+ "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
12568+ op[0], op[1], op[2]);
12569+ printf (" a = 0x%x,", a);
12570+ printf (" i = 0x%x\n", i);
12571+ }
12572+ SYNTAX("racl #%1, %0");
12573+#line 1113 "rx-decode.opc"
12574+ ID(racl); SC(i+1); DR(a+32); F_____;
12575+
12576+ }
928412577 break;
9285- case 0x0f:
9286- goto op_semantics_74;
12578+ case 0x40:
12579+ {
12580+ /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
12581+#line 1116 "rx-decode.opc"
12582+ int a AU = (op[2] >> 7) & 0x01;
12583+#line 1116 "rx-decode.opc"
12584+ int i AU = (op[2] >> 4) & 0x01;
12585+ if (trace)
12586+ {
12587+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12588+ "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
12589+ op[0], op[1], op[2]);
12590+ printf (" a = 0x%x,", a);
12591+ printf (" i = 0x%x\n", i);
12592+ }
12593+ SYNTAX("rdacl #%1, %0");
12594+#line 1116 "rx-decode.opc"
12595+ ID(rdacl); SC(i+1); DR(a+32); F_____;
12596+
12597+ }
928712598 break;
12599+ default: UNSUPPORTED(); break;
928812600 }
928912601 break;
9290- case 0xe9:
12602+ case 0x1e:
929112603 GETBYTE ();
9292- switch (op[2] & 0x0f)
12604+ switch (op[2] & 0x30)
929312605 {
929412606 case 0x00:
9295- case 0x01:
9296- case 0x02:
9297- case 0x03:
9298- case 0x04:
9299- case 0x05:
9300- case 0x06:
9301- case 0x07:
9302- case 0x08:
9303- case 0x09:
9304- case 0x0a:
9305- case 0x0b:
9306- case 0x0c:
9307- case 0x0d:
9308- case 0x0e:
9309- goto op_semantics_73;
12607+ op_semantics_98:
12608+ {
12609+ /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
12610+#line 891 "rx-decode.opc"
12611+ int i AU = op[1] & 0x01;
12612+#line 891 "rx-decode.opc"
12613+ int a AU = (op[2] >> 7) & 0x01;
12614+#line 891 "rx-decode.opc"
12615+ int m AU = (op[2] >> 6) & 0x01;
12616+#line 891 "rx-decode.opc"
12617+ int rdst AU = op[2] & 0x0f;
12618+ if (trace)
12619+ {
12620+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12621+ "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
12622+ op[0], op[1], op[2]);
12623+ printf (" i = 0x%x,", i);
12624+ printf (" a = 0x%x,", a);
12625+ printf (" m = 0x%x,", m);
12626+ printf (" rdst = 0x%x\n", rdst);
12627+ }
12628+ SYNTAX("mvfachi #%2, %1, %0");
12629+#line 891 "rx-decode.opc"
12630+ ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12631+
12632+ }
931012633 break;
9311- case 0x0f:
9312- goto op_semantics_74;
12634+ case 0x10:
12635+ op_semantics_99:
12636+ {
12637+ /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
12638+#line 897 "rx-decode.opc"
12639+ int i AU = op[1] & 0x01;
12640+#line 897 "rx-decode.opc"
12641+ int a AU = (op[2] >> 7) & 0x01;
12642+#line 897 "rx-decode.opc"
12643+ int m AU = (op[2] >> 6) & 0x01;
12644+#line 897 "rx-decode.opc"
12645+ int rdst AU = op[2] & 0x0f;
12646+ if (trace)
12647+ {
12648+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12649+ "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
12650+ op[0], op[1], op[2]);
12651+ printf (" i = 0x%x,", i);
12652+ printf (" a = 0x%x,", a);
12653+ printf (" m = 0x%x,", m);
12654+ printf (" rdst = 0x%x\n", rdst);
12655+ }
12656+ SYNTAX("mvfaclo #%2, %1, %0");
12657+#line 897 "rx-decode.opc"
12658+ ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12659+
12660+ }
931312661 break;
9314- }
9315- break;
9316- case 0xea:
9317- GETBYTE ();
9318- switch (op[2] & 0x0f)
9319- {
9320- case 0x00:
9321- case 0x01:
9322- case 0x02:
9323- case 0x03:
9324- case 0x04:
9325- case 0x05:
9326- case 0x06:
9327- case 0x07:
9328- case 0x08:
9329- case 0x09:
9330- case 0x0a:
9331- case 0x0b:
9332- case 0x0c:
9333- case 0x0d:
9334- case 0x0e:
9335- goto op_semantics_73;
12662+ case 0x20:
12663+ op_semantics_100:
12664+ {
12665+ /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
12666+#line 894 "rx-decode.opc"
12667+ int i AU = op[1] & 0x01;
12668+#line 894 "rx-decode.opc"
12669+ int a AU = (op[2] >> 7) & 0x01;
12670+#line 894 "rx-decode.opc"
12671+ int m AU = (op[2] >> 6) & 0x01;
12672+#line 894 "rx-decode.opc"
12673+ int rdst AU = op[2] & 0x0f;
12674+ if (trace)
12675+ {
12676+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12677+ "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
12678+ op[0], op[1], op[2]);
12679+ printf (" i = 0x%x,", i);
12680+ printf (" a = 0x%x,", a);
12681+ printf (" m = 0x%x,", m);
12682+ printf (" rdst = 0x%x\n", rdst);
12683+ }
12684+ SYNTAX("mvfacmi #%2, %1, %0");
12685+#line 894 "rx-decode.opc"
12686+ ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12687+
12688+ }
933612689 break;
9337- case 0x0f:
9338- goto op_semantics_74;
12690+ case 0x30:
12691+ op_semantics_101:
12692+ {
12693+ /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
12694+#line 1107 "rx-decode.opc"
12695+ int i AU = op[1] & 0x01;
12696+#line 1107 "rx-decode.opc"
12697+ int a AU = (op[2] >> 7) & 0x01;
12698+#line 1107 "rx-decode.opc"
12699+ int m AU = (op[2] >> 6) & 0x01;
12700+#line 1107 "rx-decode.opc"
12701+ int rdst AU = op[2] & 0x0f;
12702+ if (trace)
12703+ {
12704+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12705+ "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
12706+ op[0], op[1], op[2]);
12707+ printf (" i = 0x%x,", i);
12708+ printf (" a = 0x%x,", a);
12709+ printf (" m = 0x%x,", m);
12710+ printf (" rdst = 0x%x\n", rdst);
12711+ }
12712+ SYNTAX("mvfacgu #%2, %1, %0");
12713+#line 1107 "rx-decode.opc"
12714+ ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12715+
12716+ }
933912717 break;
934012718 }
934112719 break;
9342- case 0xeb:
12720+ case 0x1f:
934312721 GETBYTE ();
9344- switch (op[2] & 0x0f)
9345- {
9346- case 0x00:
9347- case 0x01:
9348- case 0x02:
9349- case 0x03:
9350- case 0x04:
9351- case 0x05:
9352- case 0x06:
9353- case 0x07:
9354- case 0x08:
9355- case 0x09:
9356- case 0x0a:
9357- case 0x0b:
9358- case 0x0c:
9359- case 0x0d:
9360- case 0x0e:
9361- goto op_semantics_73;
12722+ switch (op[2] & 0x30)
12723+ {
12724+ case 0x00:
12725+ goto op_semantics_98;
936212726 break;
9363- case 0x0f:
9364- goto op_semantics_74;
12727+ case 0x10:
12728+ goto op_semantics_99;
12729+ break;
12730+ case 0x20:
12731+ goto op_semantics_100;
12732+ break;
12733+ case 0x30:
12734+ goto op_semantics_101;
936512735 break;
936612736 }
936712737 break;
9368- case 0xec:
12738+ case 0x20:
936912739 GETBYTE ();
9370- switch (op[2] & 0x0f)
12740+ switch (op[2] & 0x00)
937112741 {
937212742 case 0x00:
9373- case 0x01:
9374- case 0x02:
9375- case 0x03:
9376- case 0x04:
9377- case 0x05:
9378- case 0x06:
9379- case 0x07:
9380- case 0x08:
9381- case 0x09:
9382- case 0x0a:
9383- case 0x0b:
9384- case 0x0c:
9385- case 0x0d:
9386- case 0x0e:
9387- goto op_semantics_73;
9388- break;
9389- case 0x0f:
9390- goto op_semantics_74;
12743+ op_semantics_102:
12744+ {
12745+ /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
12746+#line 369 "rx-decode.opc"
12747+ int p AU = (op[1] >> 2) & 0x01;
12748+#line 369 "rx-decode.opc"
12749+ int sz AU = op[1] & 0x03;
12750+#line 369 "rx-decode.opc"
12751+ int rdst AU = (op[2] >> 4) & 0x0f;
12752+#line 369 "rx-decode.opc"
12753+ int rsrc AU = op[2] & 0x0f;
12754+ if (trace)
12755+ {
12756+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12757+ "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
12758+ op[0], op[1], op[2]);
12759+ printf (" p = 0x%x,", p);
12760+ printf (" sz = 0x%x,", sz);
12761+ printf (" rdst = 0x%x,", rdst);
12762+ printf (" rsrc = 0x%x\n", rsrc);
12763+ }
12764+ SYNTAX("mov%s %1, %0");
12765+#line 369 "rx-decode.opc"
12766+ ID(mov); sBWL (sz); SR(rsrc); F_____;
12767+ OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
12768+
12769+ }
939112770 break;
939212771 }
939312772 break;
9394- case 0xed:
12773+ case 0x21:
939512774 GETBYTE ();
9396- switch (op[2] & 0x0f)
12775+ switch (op[2] & 0x00)
939712776 {
939812777 case 0x00:
9399- case 0x01:
9400- case 0x02:
9401- case 0x03:
9402- case 0x04:
9403- case 0x05:
9404- case 0x06:
9405- case 0x07:
9406- case 0x08:
9407- case 0x09:
9408- case 0x0a:
9409- case 0x0b:
9410- case 0x0c:
9411- case 0x0d:
9412- case 0x0e:
9413- goto op_semantics_73;
9414- break;
9415- case 0x0f:
9416- goto op_semantics_74;
12778+ goto op_semantics_102;
941712779 break;
941812780 }
941912781 break;
9420- case 0xee:
12782+ case 0x22:
942112783 GETBYTE ();
9422- switch (op[2] & 0x0f)
12784+ switch (op[2] & 0x00)
942312785 {
942412786 case 0x00:
9425- case 0x01:
9426- case 0x02:
9427- case 0x03:
9428- case 0x04:
9429- case 0x05:
9430- case 0x06:
9431- case 0x07:
9432- case 0x08:
9433- case 0x09:
9434- case 0x0a:
9435- case 0x0b:
9436- case 0x0c:
9437- case 0x0d:
9438- case 0x0e:
9439- goto op_semantics_73;
9440- break;
9441- case 0x0f:
9442- goto op_semantics_74;
12787+ goto op_semantics_102;
944312788 break;
944412789 }
944512790 break;
9446- case 0xef:
12791+ case 0x24:
944712792 GETBYTE ();
9448- switch (op[2] & 0x0f)
12793+ switch (op[2] & 0x00)
944912794 {
945012795 case 0x00:
9451- case 0x01:
9452- case 0x02:
9453- case 0x03:
9454- case 0x04:
9455- case 0x05:
9456- case 0x06:
9457- case 0x07:
9458- case 0x08:
9459- case 0x09:
9460- case 0x0a:
9461- case 0x0b:
9462- case 0x0c:
9463- case 0x0d:
9464- case 0x0e:
9465- goto op_semantics_73;
9466- break;
9467- case 0x0f:
9468- goto op_semantics_74;
12796+ goto op_semantics_102;
946912797 break;
947012798 }
947112799 break;
9472- case 0xf0:
12800+ case 0x25:
947312801 GETBYTE ();
9474- switch (op[2] & 0x0f)
12802+ switch (op[2] & 0x00)
947512803 {
947612804 case 0x00:
9477- case 0x01:
9478- case 0x02:
9479- case 0x03:
9480- case 0x04:
9481- case 0x05:
9482- case 0x06:
9483- case 0x07:
9484- case 0x08:
9485- case 0x09:
9486- case 0x0a:
9487- case 0x0b:
9488- case 0x0c:
9489- case 0x0d:
9490- case 0x0e:
9491- goto op_semantics_73;
9492- break;
9493- case 0x0f:
9494- goto op_semantics_74;
12805+ goto op_semantics_102;
949512806 break;
949612807 }
949712808 break;
9498- case 0xf1:
12809+ case 0x26:
949912810 GETBYTE ();
9500- switch (op[2] & 0x0f)
12811+ switch (op[2] & 0x00)
950112812 {
950212813 case 0x00:
9503- case 0x01:
9504- case 0x02:
9505- case 0x03:
9506- case 0x04:
9507- case 0x05:
9508- case 0x06:
9509- case 0x07:
9510- case 0x08:
9511- case 0x09:
9512- case 0x0a:
9513- case 0x0b:
9514- case 0x0c:
9515- case 0x0d:
9516- case 0x0e:
9517- goto op_semantics_73;
9518- break;
9519- case 0x0f:
9520- goto op_semantics_74;
12814+ goto op_semantics_102;
952112815 break;
952212816 }
952312817 break;
9524- case 0xf2:
12818+ case 0x27:
952512819 GETBYTE ();
9526- switch (op[2] & 0x0f)
12820+ switch (op[2] & 0x00)
952712821 {
952812822 case 0x00:
9529- case 0x01:
9530- case 0x02:
9531- case 0x03:
9532- case 0x04:
9533- case 0x05:
9534- case 0x06:
9535- case 0x07:
9536- case 0x08:
9537- case 0x09:
9538- case 0x0a:
9539- case 0x0b:
9540- case 0x0c:
9541- case 0x0d:
9542- case 0x0e:
9543- goto op_semantics_73;
9544- break;
9545- case 0x0f:
9546- goto op_semantics_74;
12823+ {
12824+ /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
12825+#line 1071 "rx-decode.opc"
12826+ int rdst AU = (op[2] >> 4) & 0x0f;
12827+#line 1071 "rx-decode.opc"
12828+ int rsrc AU = op[2] & 0x0f;
12829+ if (trace)
12830+ {
12831+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12832+ "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
12833+ op[0], op[1], op[2]);
12834+ printf (" rdst = 0x%x,", rdst);
12835+ printf (" rsrc = 0x%x\n", rsrc);
12836+ }
12837+ SYNTAX("movco %1, [%0]");
12838+#line 1071 "rx-decode.opc"
12839+ ID(movco); SR(rsrc); DR(rdst); F_____;
12840+
12841+ }
954712842 break;
954812843 }
954912844 break;
9550- case 0xf3:
12845+ case 0x28:
955112846 GETBYTE ();
9552- switch (op[2] & 0x0f)
12847+ switch (op[2] & 0x00)
955312848 {
955412849 case 0x00:
9555- case 0x01:
9556- case 0x02:
9557- case 0x03:
9558- case 0x04:
9559- case 0x05:
9560- case 0x06:
9561- case 0x07:
9562- case 0x08:
9563- case 0x09:
9564- case 0x0a:
9565- case 0x0b:
9566- case 0x0c:
9567- case 0x0d:
9568- case 0x0e:
9569- goto op_semantics_73;
9570- break;
9571- case 0x0f:
9572- goto op_semantics_74;
12850+ op_semantics_103:
12851+ {
12852+ /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
12853+#line 373 "rx-decode.opc"
12854+ int p AU = (op[1] >> 2) & 0x01;
12855+#line 373 "rx-decode.opc"
12856+ int sz AU = op[1] & 0x03;
12857+#line 373 "rx-decode.opc"
12858+ int rsrc AU = (op[2] >> 4) & 0x0f;
12859+#line 373 "rx-decode.opc"
12860+ int rdst AU = op[2] & 0x0f;
12861+ if (trace)
12862+ {
12863+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12864+ "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
12865+ op[0], op[1], op[2]);
12866+ printf (" p = 0x%x,", p);
12867+ printf (" sz = 0x%x,", sz);
12868+ printf (" rsrc = 0x%x,", rsrc);
12869+ printf (" rdst = 0x%x\n", rdst);
12870+ }
12871+ SYNTAX("mov%s %1, %0");
12872+#line 373 "rx-decode.opc"
12873+ ID(mov); sBWL (sz); DR(rdst); F_____;
12874+ OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12875+
12876+ }
957312877 break;
957412878 }
957512879 break;
9576- case 0xf4:
12880+ case 0x29:
957712881 GETBYTE ();
9578- switch (op[2] & 0x0f)
12882+ switch (op[2] & 0x00)
957912883 {
958012884 case 0x00:
9581- case 0x01:
9582- case 0x02:
9583- case 0x03:
9584- case 0x04:
9585- case 0x05:
9586- case 0x06:
9587- case 0x07:
9588- case 0x08:
9589- case 0x09:
9590- case 0x0a:
9591- case 0x0b:
9592- case 0x0c:
9593- case 0x0d:
9594- case 0x0e:
9595- goto op_semantics_73;
9596- break;
9597- case 0x0f:
9598- goto op_semantics_74;
12885+ goto op_semantics_103;
959912886 break;
960012887 }
960112888 break;
9602- case 0xf5:
12889+ case 0x2a:
960312890 GETBYTE ();
9604- switch (op[2] & 0x0f)
12891+ switch (op[2] & 0x00)
960512892 {
960612893 case 0x00:
9607- case 0x01:
9608- case 0x02:
9609- case 0x03:
9610- case 0x04:
9611- case 0x05:
9612- case 0x06:
9613- case 0x07:
9614- case 0x08:
9615- case 0x09:
9616- case 0x0a:
9617- case 0x0b:
9618- case 0x0c:
9619- case 0x0d:
9620- case 0x0e:
9621- goto op_semantics_73;
9622- break;
9623- case 0x0f:
9624- goto op_semantics_74;
12894+ goto op_semantics_103;
962512895 break;
962612896 }
962712897 break;
9628- case 0xf6:
12898+ case 0x2c:
962912899 GETBYTE ();
9630- switch (op[2] & 0x0f)
12900+ switch (op[2] & 0x00)
963112901 {
963212902 case 0x00:
9633- case 0x01:
9634- case 0x02:
9635- case 0x03:
9636- case 0x04:
9637- case 0x05:
9638- case 0x06:
9639- case 0x07:
9640- case 0x08:
9641- case 0x09:
9642- case 0x0a:
9643- case 0x0b:
9644- case 0x0c:
9645- case 0x0d:
9646- case 0x0e:
9647- goto op_semantics_73;
9648- break;
9649- case 0x0f:
9650- goto op_semantics_74;
12903+ goto op_semantics_103;
965112904 break;
965212905 }
965312906 break;
9654- case 0xf7:
12907+ case 0x2d:
965512908 GETBYTE ();
9656- switch (op[2] & 0x0f)
12909+ switch (op[2] & 0x00)
965712910 {
965812911 case 0x00:
9659- case 0x01:
9660- case 0x02:
9661- case 0x03:
9662- case 0x04:
9663- case 0x05:
9664- case 0x06:
9665- case 0x07:
9666- case 0x08:
9667- case 0x09:
9668- case 0x0a:
9669- case 0x0b:
9670- case 0x0c:
9671- case 0x0d:
9672- case 0x0e:
9673- goto op_semantics_73;
9674- break;
9675- case 0x0f:
9676- goto op_semantics_74;
12912+ goto op_semantics_103;
967712913 break;
967812914 }
967912915 break;
9680- case 0xf8:
12916+ case 0x2e:
968112917 GETBYTE ();
9682- switch (op[2] & 0x0f)
12918+ switch (op[2] & 0x00)
968312919 {
968412920 case 0x00:
9685- case 0x01:
9686- case 0x02:
9687- case 0x03:
9688- case 0x04:
9689- case 0x05:
9690- case 0x06:
9691- case 0x07:
9692- case 0x08:
9693- case 0x09:
9694- case 0x0a:
9695- case 0x0b:
9696- case 0x0c:
9697- case 0x0d:
9698- case 0x0e:
9699- goto op_semantics_73;
9700- break;
9701- case 0x0f:
9702- goto op_semantics_74;
12921+ goto op_semantics_103;
970312922 break;
970412923 }
970512924 break;
9706- case 0xf9:
12925+ case 0x2f:
970712926 GETBYTE ();
9708- switch (op[2] & 0x0f)
12927+ switch (op[2] & 0x00)
970912928 {
971012929 case 0x00:
9711- case 0x01:
9712- case 0x02:
9713- case 0x03:
9714- case 0x04:
9715- case 0x05:
9716- case 0x06:
9717- case 0x07:
9718- case 0x08:
9719- case 0x09:
9720- case 0x0a:
9721- case 0x0b:
9722- case 0x0c:
9723- case 0x0d:
9724- case 0x0e:
9725- goto op_semantics_73;
9726- break;
9727- case 0x0f:
9728- goto op_semantics_74;
12930+ {
12931+ /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
12932+#line 1074 "rx-decode.opc"
12933+ int rsrc AU = (op[2] >> 4) & 0x0f;
12934+#line 1074 "rx-decode.opc"
12935+ int rdst AU = op[2] & 0x0f;
12936+ if (trace)
12937+ {
12938+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12939+ "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
12940+ op[0], op[1], op[2]);
12941+ printf (" rsrc = 0x%x,", rsrc);
12942+ printf (" rdst = 0x%x\n", rdst);
12943+ }
12944+ SYNTAX("movli [%1], %0");
12945+#line 1074 "rx-decode.opc"
12946+ ID(movli); SR(rsrc); DR(rdst); F_____;
12947+
12948+ }
972912949 break;
973012950 }
973112951 break;
9732- case 0xfa:
12952+ case 0x38:
973312953 GETBYTE ();
9734- switch (op[2] & 0x0f)
12954+ switch (op[2] & 0x00)
973512955 {
973612956 case 0x00:
9737- case 0x01:
9738- case 0x02:
9739- case 0x03:
9740- case 0x04:
9741- case 0x05:
9742- case 0x06:
9743- case 0x07:
9744- case 0x08:
9745- case 0x09:
9746- case 0x0a:
9747- case 0x0b:
9748- case 0x0c:
9749- case 0x0d:
9750- case 0x0e:
9751- goto op_semantics_73;
9752- break;
9753- case 0x0f:
9754- goto op_semantics_74;
12957+ op_semantics_104:
12958+ {
12959+ /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
12960+#line 383 "rx-decode.opc"
12961+ int p AU = (op[1] >> 2) & 0x01;
12962+#line 383 "rx-decode.opc"
12963+ int sz AU = op[1] & 0x03;
12964+#line 383 "rx-decode.opc"
12965+ int rsrc AU = (op[2] >> 4) & 0x0f;
12966+#line 383 "rx-decode.opc"
12967+ int rdst AU = op[2] & 0x0f;
12968+ if (trace)
12969+ {
12970+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12971+ "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
12972+ op[0], op[1], op[2]);
12973+ printf (" p = 0x%x,", p);
12974+ printf (" sz = 0x%x,", sz);
12975+ printf (" rsrc = 0x%x,", rsrc);
12976+ printf (" rdst = 0x%x\n", rdst);
12977+ }
12978+ SYNTAX("movu%s %1, %0");
12979+#line 383 "rx-decode.opc"
12980+ ID(mov); uBW (sz); DR(rdst); F_____;
12981+ OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12982+
12983+ /*----------------------------------------------------------------------*/
12984+ /* PUSH/POP */
12985+
12986+ }
975512987 break;
975612988 }
975712989 break;
9758- case 0xfb:
12990+ case 0x39:
975912991 GETBYTE ();
9760- switch (op[2] & 0x0f)
12992+ switch (op[2] & 0x00)
976112993 {
976212994 case 0x00:
9763- case 0x01:
9764- case 0x02:
9765- case 0x03:
9766- case 0x04:
9767- case 0x05:
9768- case 0x06:
9769- case 0x07:
9770- case 0x08:
9771- case 0x09:
9772- case 0x0a:
9773- case 0x0b:
9774- case 0x0c:
9775- case 0x0d:
9776- case 0x0e:
9777- goto op_semantics_73;
9778- break;
9779- case 0x0f:
9780- goto op_semantics_74;
12995+ goto op_semantics_104;
978112996 break;
978212997 }
978312998 break;
9784- case 0xfc:
12999+ case 0x3a:
978513000 GETBYTE ();
9786- switch (op[2] & 0x0f)
9787- {
9788- case 0x00:
9789- case 0x01:
9790- case 0x02:
9791- case 0x03:
9792- case 0x04:
9793- case 0x05:
9794- case 0x06:
9795- case 0x07:
9796- case 0x08:
9797- case 0x09:
9798- case 0x0a:
9799- case 0x0b:
9800- case 0x0c:
9801- case 0x0d:
9802- case 0x0e:
9803- goto op_semantics_73;
9804- break;
9805- case 0x0f:
9806- goto op_semantics_74;
13001+ switch (op[2] & 0x00)
13002+ {
13003+ case 0x00:
13004+ goto op_semantics_104;
980713005 break;
980813006 }
980913007 break;
9810- case 0xfd:
13008+ case 0x3c:
981113009 GETBYTE ();
9812- switch (op[2] & 0x0f)
13010+ switch (op[2] & 0x00)
981313011 {
981413012 case 0x00:
9815- case 0x01:
9816- case 0x02:
9817- case 0x03:
9818- case 0x04:
9819- case 0x05:
9820- case 0x06:
9821- case 0x07:
9822- case 0x08:
9823- case 0x09:
9824- case 0x0a:
9825- case 0x0b:
9826- case 0x0c:
9827- case 0x0d:
9828- case 0x0e:
9829- goto op_semantics_73;
9830- break;
9831- case 0x0f:
9832- goto op_semantics_74;
13013+ goto op_semantics_104;
983313014 break;
983413015 }
983513016 break;
9836- case 0xfe:
13017+ case 0x3d:
983713018 GETBYTE ();
9838- switch (op[2] & 0x0f)
13019+ switch (op[2] & 0x00)
983913020 {
984013021 case 0x00:
9841- case 0x01:
9842- case 0x02:
9843- case 0x03:
9844- case 0x04:
9845- case 0x05:
9846- case 0x06:
9847- case 0x07:
9848- case 0x08:
9849- case 0x09:
9850- case 0x0a:
9851- case 0x0b:
9852- case 0x0c:
9853- case 0x0d:
9854- case 0x0e:
9855- goto op_semantics_73;
9856- break;
9857- case 0x0f:
9858- goto op_semantics_74;
13022+ goto op_semantics_104;
985913023 break;
986013024 }
986113025 break;
9862- case 0xff:
13026+ case 0x3e:
986313027 GETBYTE ();
9864- switch (op[2] & 0x0f)
13028+ switch (op[2] & 0x00)
986513029 {
986613030 case 0x00:
9867- case 0x01:
9868- case 0x02:
9869- case 0x03:
9870- case 0x04:
9871- case 0x05:
9872- case 0x06:
9873- case 0x07:
9874- case 0x08:
9875- case 0x09:
9876- case 0x0a:
9877- case 0x0b:
9878- case 0x0c:
9879- case 0x0d:
9880- case 0x0e:
9881- goto op_semantics_73;
13031+ goto op_semantics_104;
988213032 break;
9883- case 0x0f:
9884- goto op_semantics_74;
13033+ }
13034+ break;
13035+ case 0x44:
13036+ GETBYTE ();
13037+ switch (op[2] & 0x00)
13038+ {
13039+ case 0x00:
13040+ op_semantics_105:
13041+ {
13042+ /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
13043+#line 1095 "rx-decode.opc"
13044+ int a AU = (op[1] >> 3) & 0x01;
13045+#line 1095 "rx-decode.opc"
13046+ int srca AU = (op[2] >> 4) & 0x0f;
13047+#line 1095 "rx-decode.opc"
13048+ int srcb AU = op[2] & 0x0f;
13049+ if (trace)
13050+ {
13051+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13052+ "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
13053+ op[0], op[1], op[2]);
13054+ printf (" a = 0x%x,", a);
13055+ printf (" srca = 0x%x,", srca);
13056+ printf (" srcb = 0x%x\n", srcb);
13057+ }
13058+ SYNTAX("msbhi %1, %2, %0");
13059+#line 1095 "rx-decode.opc"
13060+ ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13061+
13062+ }
988513063 break;
988613064 }
988713065 break;
9888- default: UNSUPPORTED(); break;
9889- }
9890- break;
9891- case 0xfd:
9892- GETBYTE ();
9893- switch (op[1] & 0xff)
9894- {
9895- case 0x00:
13066+ case 0x45:
989613067 GETBYTE ();
989713068 switch (op[2] & 0x00)
989813069 {
989913070 case 0x00:
9900- op_semantics_75:
13071+ op_semantics_106:
990113072 {
9902- /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
9903-#line 852 "rx-decode.opc"
13073+ /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
13074+#line 1101 "rx-decode.opc"
990413075 int a AU = (op[1] >> 3) & 0x01;
9905-#line 852 "rx-decode.opc"
13076+#line 1101 "rx-decode.opc"
990613077 int srca AU = (op[2] >> 4) & 0x0f;
9907-#line 852 "rx-decode.opc"
13078+#line 1101 "rx-decode.opc"
990813079 int srcb AU = op[2] & 0x0f;
990913080 if (trace)
991013081 {
991113082 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9912- "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
13083+ "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
991313084 op[0], op[1], op[2]);
991413085 printf (" a = 0x%x,", a);
991513086 printf (" srca = 0x%x,", srca);
991613087 printf (" srcb = 0x%x\n", srcb);
991713088 }
9918- SYNTAX("mulhi %1, %2, %0");
9919-#line 852 "rx-decode.opc"
9920- ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13089+ SYNTAX("msblo %1, %2, %0");
13090+#line 1101 "rx-decode.opc"
13091+ ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
992113092
992213093 }
992313094 break;
992413095 }
992513096 break;
9926- case 0x01:
13097+ case 0x46:
992713098 GETBYTE ();
992813099 switch (op[2] & 0x00)
992913100 {
993013101 case 0x00:
9931- op_semantics_76:
13102+ op_semantics_107:
993213103 {
9933- /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
9934-#line 855 "rx-decode.opc"
13104+ /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
13105+#line 1098 "rx-decode.opc"
993513106 int a AU = (op[1] >> 3) & 0x01;
9936-#line 855 "rx-decode.opc"
13107+#line 1098 "rx-decode.opc"
993713108 int srca AU = (op[2] >> 4) & 0x0f;
9938-#line 855 "rx-decode.opc"
13109+#line 1098 "rx-decode.opc"
993913110 int srcb AU = op[2] & 0x0f;
994013111 if (trace)
994113112 {
994213113 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9943- "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
13114+ "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
994413115 op[0], op[1], op[2]);
994513116 printf (" a = 0x%x,", a);
994613117 printf (" srca = 0x%x,", srca);
994713118 printf (" srcb = 0x%x\n", srcb);
994813119 }
9949- SYNTAX("mullo %1, %2, %0");
9950-#line 855 "rx-decode.opc"
9951- ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
13120+ SYNTAX("msblh %1, %2, %0");
13121+#line 1098 "rx-decode.opc"
13122+ ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
995213123
995313124 }
995413125 break;
995513126 }
995613127 break;
9957- case 0x02:
13128+ case 0x47:
995813129 GETBYTE ();
995913130 switch (op[2] & 0x00)
996013131 {
996113132 case 0x00:
9962- op_semantics_77:
13133+ op_semantics_108:
996313134 {
9964- /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
9965-#line 1083 "rx-decode.opc"
13135+ /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
13136+#line 1086 "rx-decode.opc"
996613137 int a AU = (op[1] >> 3) & 0x01;
9967-#line 1083 "rx-decode.opc"
13138+#line 1086 "rx-decode.opc"
996813139 int srca AU = (op[2] >> 4) & 0x0f;
9969-#line 1083 "rx-decode.opc"
13140+#line 1086 "rx-decode.opc"
997013141 int srcb AU = op[2] & 0x0f;
997113142 if (trace)
997213143 {
997313144 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9974- "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
13145+ "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
997513146 op[0], op[1], op[2]);
997613147 printf (" a = 0x%x,", a);
997713148 printf (" srca = 0x%x,", srca);
997813149 printf (" srcb = 0x%x\n", srcb);
997913150 }
9980- SYNTAX("mullh %1, %2, %0");
9981-#line 1083 "rx-decode.opc"
9982- ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
13151+ SYNTAX("emsba %1, %2, %0");
13152+#line 1086 "rx-decode.opc"
13153+ ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
998313154
998413155 }
998513156 break;
998613157 }
998713158 break;
9988- case 0x03:
13159+ case 0x4c:
13160+ GETBYTE ();
13161+ switch (op[2] & 0x00)
13162+ {
13163+ case 0x00:
13164+ goto op_semantics_105;
13165+ break;
13166+ }
13167+ break;
13168+ case 0x4d:
13169+ GETBYTE ();
13170+ switch (op[2] & 0x00)
13171+ {
13172+ case 0x00:
13173+ goto op_semantics_106;
13174+ break;
13175+ }
13176+ break;
13177+ case 0x4e:
13178+ GETBYTE ();
13179+ switch (op[2] & 0x00)
13180+ {
13181+ case 0x00:
13182+ goto op_semantics_107;
13183+ break;
13184+ }
13185+ break;
13186+ case 0x4f:
13187+ GETBYTE ();
13188+ switch (op[2] & 0x00)
13189+ {
13190+ case 0x00:
13191+ goto op_semantics_108;
13192+ break;
13193+ }
13194+ break;
13195+ case 0x60:
13196+ GETBYTE ();
13197+ switch (op[2] & 0x00)
13198+ {
13199+ case 0x00:
13200+ {
13201+ /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
13202+#line 754 "rx-decode.opc"
13203+ int rsrc AU = (op[2] >> 4) & 0x0f;
13204+#line 754 "rx-decode.opc"
13205+ int rdst AU = op[2] & 0x0f;
13206+ if (trace)
13207+ {
13208+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13209+ "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
13210+ op[0], op[1], op[2]);
13211+ printf (" rsrc = 0x%x,", rsrc);
13212+ printf (" rdst = 0x%x\n", rdst);
13213+ }
13214+ SYNTAX("shlr %2, %0");
13215+#line 754 "rx-decode.opc"
13216+ ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
13217+
13218+ }
13219+ break;
13220+ }
13221+ break;
13222+ case 0x61:
13223+ GETBYTE ();
13224+ switch (op[2] & 0x00)
13225+ {
13226+ case 0x00:
13227+ {
13228+ /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
13229+#line 744 "rx-decode.opc"
13230+ int rsrc AU = (op[2] >> 4) & 0x0f;
13231+#line 744 "rx-decode.opc"
13232+ int rdst AU = op[2] & 0x0f;
13233+ if (trace)
13234+ {
13235+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13236+ "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
13237+ op[0], op[1], op[2]);
13238+ printf (" rsrc = 0x%x,", rsrc);
13239+ printf (" rdst = 0x%x\n", rdst);
13240+ }
13241+ SYNTAX("shar %2, %0");
13242+#line 744 "rx-decode.opc"
13243+ ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
13244+
13245+ }
13246+ break;
13247+ }
13248+ break;
13249+ case 0x62:
998913250 GETBYTE ();
999013251 switch (op[2] & 0x00)
999113252 {
999213253 case 0x00:
9993- op_semantics_78:
999413254 {
9995- /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */
9996-#line 1068 "rx-decode.opc"
9997- int a AU = (op[1] >> 3) & 0x01;
9998-#line 1068 "rx-decode.opc"
9999- int srca AU = (op[2] >> 4) & 0x0f;
10000-#line 1068 "rx-decode.opc"
10001- int srcb AU = op[2] & 0x0f;
13255+ /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
13256+#line 734 "rx-decode.opc"
13257+ int rsrc AU = (op[2] >> 4) & 0x0f;
13258+#line 734 "rx-decode.opc"
13259+ int rdst AU = op[2] & 0x0f;
1000213260 if (trace)
1000313261 {
1000413262 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10005- "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */",
13263+ "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
1000613264 op[0], op[1], op[2]);
10007- printf (" a = 0x%x,", a);
10008- printf (" srca = 0x%x,", srca);
10009- printf (" srcb = 0x%x\n", srcb);
13265+ printf (" rsrc = 0x%x,", rsrc);
13266+ printf (" rdst = 0x%x\n", rdst);
1001013267 }
10011- SYNTAX("emula %1, %2, %0");
10012-#line 1068 "rx-decode.opc"
10013- ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
13268+ SYNTAX("shll %2, %0");
13269+#line 734 "rx-decode.opc"
13270+ ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
1001413271
1001513272 }
1001613273 break;
1001713274 }
1001813275 break;
10019- case 0x04:
13276+ case 0x64:
1002013277 GETBYTE ();
1002113278 switch (op[2] & 0x00)
1002213279 {
1002313280 case 0x00:
10024- op_semantics_79:
1002513281 {
10026- /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
10027-#line 858 "rx-decode.opc"
10028- int a AU = (op[1] >> 3) & 0x01;
10029-#line 858 "rx-decode.opc"
10030- int srca AU = (op[2] >> 4) & 0x0f;
10031-#line 858 "rx-decode.opc"
10032- int srcb AU = op[2] & 0x0f;
13282+ /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
13283+#line 778 "rx-decode.opc"
13284+ int rsrc AU = (op[2] >> 4) & 0x0f;
13285+#line 778 "rx-decode.opc"
13286+ int rdst AU = op[2] & 0x0f;
1003313287 if (trace)
1003413288 {
1003513289 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10036- "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
13290+ "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
1003713291 op[0], op[1], op[2]);
10038- printf (" a = 0x%x,", a);
10039- printf (" srca = 0x%x,", srca);
10040- printf (" srcb = 0x%x\n", srcb);
13292+ printf (" rsrc = 0x%x,", rsrc);
13293+ printf (" rdst = 0x%x\n", rdst);
1004113294 }
10042- SYNTAX("machi %1, %2, %0");
10043-#line 858 "rx-decode.opc"
10044- ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
13295+ SYNTAX("rotr %1, %0");
13296+#line 778 "rx-decode.opc"
13297+ ID(rotr); SR(rsrc); DR(rdst); F__SZC;
1004513298
1004613299 }
1004713300 break;
1004813301 }
1004913302 break;
10050- case 0x05:
13303+ case 0x65:
1005113304 GETBYTE ();
1005213305 switch (op[2] & 0x00)
1005313306 {
1005413307 case 0x00:
10055- op_semantics_80:
1005613308 {
10057- /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
10058-#line 861 "rx-decode.opc"
10059- int a AU = (op[1] >> 3) & 0x01;
10060-#line 861 "rx-decode.opc"
10061- int srca AU = (op[2] >> 4) & 0x0f;
10062-#line 861 "rx-decode.opc"
10063- int srcb AU = op[2] & 0x0f;
13309+ /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
13310+#line 781 "rx-decode.opc"
13311+ int rsrc AU = (op[2] >> 4) & 0x0f;
13312+#line 781 "rx-decode.opc"
13313+ int rdst AU = op[2] & 0x0f;
1006413314 if (trace)
1006513315 {
1006613316 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10067- "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
13317+ "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
1006813318 op[0], op[1], op[2]);
10069- printf (" a = 0x%x,", a);
10070- printf (" srca = 0x%x,", srca);
10071- printf (" srcb = 0x%x\n", srcb);
13319+ printf (" rsrc = 0x%x,", rsrc);
13320+ printf (" rdst = 0x%x\n", rdst);
1007213321 }
10073- SYNTAX("maclo %1, %2, %0");
10074-#line 861 "rx-decode.opc"
10075- ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
13322+ SYNTAX("revw %1, %0");
13323+#line 781 "rx-decode.opc"
13324+ ID(revw); SR(rsrc); DR(rdst);
1007613325
1007713326 }
1007813327 break;
1007913328 }
1008013329 break;
10081- case 0x06:
13330+ case 0x66:
1008213331 GETBYTE ();
1008313332 switch (op[2] & 0x00)
1008413333 {
1008513334 case 0x00:
10086- op_semantics_81:
1008713335 {
10088- /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
10089-#line 1071 "rx-decode.opc"
10090- int a AU = (op[1] >> 3) & 0x01;
10091-#line 1071 "rx-decode.opc"
10092- int srca AU = (op[2] >> 4) & 0x0f;
10093-#line 1071 "rx-decode.opc"
10094- int srcb AU = op[2] & 0x0f;
13336+ /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
13337+#line 772 "rx-decode.opc"
13338+ int rsrc AU = (op[2] >> 4) & 0x0f;
13339+#line 772 "rx-decode.opc"
13340+ int rdst AU = op[2] & 0x0f;
1009513341 if (trace)
1009613342 {
1009713343 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10098- "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
13344+ "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
1009913345 op[0], op[1], op[2]);
10100- printf (" a = 0x%x,", a);
10101- printf (" srca = 0x%x,", srca);
10102- printf (" srcb = 0x%x\n", srcb);
13346+ printf (" rsrc = 0x%x,", rsrc);
13347+ printf (" rdst = 0x%x\n", rdst);
1010313348 }
10104- SYNTAX("maclh %1, %2, %0");
10105-#line 1071 "rx-decode.opc"
10106- ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
13349+ SYNTAX("rotl %1, %0");
13350+#line 772 "rx-decode.opc"
13351+ ID(rotl); SR(rsrc); DR(rdst); F__SZC;
1010713352
1010813353 }
1010913354 break;
1011013355 }
1011113356 break;
10112- case 0x07:
13357+ case 0x67:
1011313358 GETBYTE ();
1011413359 switch (op[2] & 0x00)
1011513360 {
1011613361 case 0x00:
10117- op_semantics_82:
1011813362 {
10119- /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */
10120-#line 1062 "rx-decode.opc"
10121- int a AU = (op[1] >> 3) & 0x01;
10122-#line 1062 "rx-decode.opc"
10123- int srca AU = (op[2] >> 4) & 0x0f;
10124-#line 1062 "rx-decode.opc"
10125- int srcb AU = op[2] & 0x0f;
13363+ /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
13364+#line 784 "rx-decode.opc"
13365+ int rsrc AU = (op[2] >> 4) & 0x0f;
13366+#line 784 "rx-decode.opc"
13367+ int rdst AU = op[2] & 0x0f;
1012613368 if (trace)
1012713369 {
1012813370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10129- "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */",
13371+ "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
1013013372 op[0], op[1], op[2]);
10131- printf (" a = 0x%x,", a);
10132- printf (" srca = 0x%x,", srca);
10133- printf (" srcb = 0x%x\n", srcb);
13373+ printf (" rsrc = 0x%x,", rsrc);
13374+ printf (" rdst = 0x%x\n", rdst);
1013413375 }
10135- SYNTAX("emaca %1, %2, %0");
10136-#line 1062 "rx-decode.opc"
10137- ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
13376+ SYNTAX("revl %1, %0");
13377+#line 784 "rx-decode.opc"
13378+ ID(revl); SR(rsrc); DR(rdst);
13379+
13380+ /*----------------------------------------------------------------------*/
13381+ /* BRANCH */
1013813382
1013913383 }
1014013384 break;
1014113385 }
1014213386 break;
10143- case 0x08:
13387+ case 0x68:
1014413388 GETBYTE ();
1014513389 switch (op[2] & 0x00)
1014613390 {
1014713391 case 0x00:
10148- goto op_semantics_75;
13392+ op_semantics_109:
13393+ {
13394+ /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
13395+#line 1035 "rx-decode.opc"
13396+ int c AU = op[1] & 0x01;
13397+#line 1035 "rx-decode.opc"
13398+ int rsrc AU = (op[2] >> 4) & 0x0f;
13399+#line 1035 "rx-decode.opc"
13400+ int rdst AU = op[2] & 0x0f;
13401+ if (trace)
13402+ {
13403+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13404+ "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
13405+ op[0], op[1], op[2]);
13406+ printf (" c = 0x%x,", c);
13407+ printf (" rsrc = 0x%x,", rsrc);
13408+ printf (" rdst = 0x%x\n", rdst);
13409+ }
13410+ SYNTAX("mvtc %1, %0");
13411+#line 1035 "rx-decode.opc"
13412+ ID(mov); SR(rsrc); DR(c*16+rdst + 16);
13413+
13414+ }
1014913415 break;
1015013416 }
1015113417 break;
10152- case 0x09:
13418+ case 0x69:
1015313419 GETBYTE ();
1015413420 switch (op[2] & 0x00)
1015513421 {
1015613422 case 0x00:
10157- goto op_semantics_76;
13423+ goto op_semantics_109;
1015813424 break;
1015913425 }
1016013426 break;
10161- case 0x0a:
13427+ case 0x6a:
1016213428 GETBYTE ();
1016313429 switch (op[2] & 0x00)
1016413430 {
1016513431 case 0x00:
10166- goto op_semantics_77;
13432+ op_semantics_110:
13433+ {
13434+ /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
13435+#line 1038 "rx-decode.opc"
13436+ int s AU = op[1] & 0x01;
13437+#line 1038 "rx-decode.opc"
13438+ int rsrc AU = (op[2] >> 4) & 0x0f;
13439+#line 1038 "rx-decode.opc"
13440+ int rdst AU = op[2] & 0x0f;
13441+ if (trace)
13442+ {
13443+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13444+ "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
13445+ op[0], op[1], op[2]);
13446+ printf (" s = 0x%x,", s);
13447+ printf (" rsrc = 0x%x,", rsrc);
13448+ printf (" rdst = 0x%x\n", rdst);
13449+ }
13450+ SYNTAX("mvfc %1, %0");
13451+#line 1038 "rx-decode.opc"
13452+ ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
13453+
13454+ /*----------------------------------------------------------------------*/
13455+ /* INTERRUPTS */
13456+
13457+ }
1016713458 break;
1016813459 }
1016913460 break;
10170- case 0x0b:
13461+ case 0x6b:
1017113462 GETBYTE ();
1017213463 switch (op[2] & 0x00)
1017313464 {
1017413465 case 0x00:
10175- goto op_semantics_78;
13466+ goto op_semantics_110;
1017613467 break;
1017713468 }
1017813469 break;
10179- case 0x0c:
13470+ case 0x6c:
1018013471 GETBYTE ();
1018113472 switch (op[2] & 0x00)
1018213473 {
1018313474 case 0x00:
10184- goto op_semantics_79;
13475+ op_semantics_111:
13476+ {
13477+ /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
13478+#line 775 "rx-decode.opc"
13479+ int i AU = op[1] & 0x01;
13480+#line 775 "rx-decode.opc"
13481+ int mmmm AU = (op[2] >> 4) & 0x0f;
13482+#line 775 "rx-decode.opc"
13483+ int rdst AU = op[2] & 0x0f;
13484+ if (trace)
13485+ {
13486+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13487+ "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
13488+ op[0], op[1], op[2]);
13489+ printf (" i = 0x%x,", i);
13490+ printf (" mmmm = 0x%x,", mmmm);
13491+ printf (" rdst = 0x%x\n", rdst);
13492+ }
13493+ SYNTAX("rotr #%1, %0");
13494+#line 775 "rx-decode.opc"
13495+ ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
13496+
13497+ }
1018513498 break;
1018613499 }
1018713500 break;
10188- case 0x0d:
13501+ case 0x6d:
1018913502 GETBYTE ();
1019013503 switch (op[2] & 0x00)
1019113504 {
1019213505 case 0x00:
10193- goto op_semantics_80;
13506+ goto op_semantics_111;
1019413507 break;
1019513508 }
1019613509 break;
10197- case 0x0e:
13510+ case 0x6e:
1019813511 GETBYTE ();
1019913512 switch (op[2] & 0x00)
1020013513 {
1020113514 case 0x00:
10202- goto op_semantics_81;
13515+ op_semantics_112:
13516+ {
13517+ /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
13518+#line 769 "rx-decode.opc"
13519+ int i AU = op[1] & 0x01;
13520+#line 769 "rx-decode.opc"
13521+ int mmmm AU = (op[2] >> 4) & 0x0f;
13522+#line 769 "rx-decode.opc"
13523+ int rdst AU = op[2] & 0x0f;
13524+ if (trace)
13525+ {
13526+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13527+ "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
13528+ op[0], op[1], op[2]);
13529+ printf (" i = 0x%x,", i);
13530+ printf (" mmmm = 0x%x,", mmmm);
13531+ printf (" rdst = 0x%x\n", rdst);
13532+ }
13533+ SYNTAX("rotl #%1, %0");
13534+#line 769 "rx-decode.opc"
13535+ ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
13536+
13537+ }
1020313538 break;
1020413539 }
1020513540 break;
10206- case 0x0f:
13541+ case 0x6f:
1020713542 GETBYTE ();
1020813543 switch (op[2] & 0x00)
1020913544 {
1021013545 case 0x00:
10211- goto op_semantics_82;
13546+ goto op_semantics_112;
1021213547 break;
1021313548 }
1021413549 break;
10215- case 0x17:
13550+ case 0x70:
1021613551 GETBYTE ();
10217- switch (op[2] & 0x70)
13552+ switch (op[2] & 0xf0)
1021813553 {
10219- case 0x00:
13554+ case 0x20:
13555+ op_semantics_113:
1022013556 {
10221- /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10222-#line 864 "rx-decode.opc"
10223- int a AU = (op[2] >> 7) & 0x01;
10224-#line 864 "rx-decode.opc"
10225- int rsrc AU = op[2] & 0x0f;
13557+ /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
13558+#line 513 "rx-decode.opc"
13559+ int im AU = (op[1] >> 2) & 0x03;
13560+#line 513 "rx-decode.opc"
13561+ int rdst AU = op[2] & 0x0f;
1022613562 if (trace)
1022713563 {
1022813564 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10229- "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
13565+ "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
1023013566 op[0], op[1], op[2]);
10231- printf (" a = 0x%x,", a);
10232- printf (" rsrc = 0x%x\n", rsrc);
13567+ printf (" im = 0x%x,", im);
13568+ printf (" rdst = 0x%x\n", rdst);
1023313569 }
10234- SYNTAX("mvtachi %1, %0");
10235-#line 864 "rx-decode.opc"
10236- ID(mvtachi); DR(a+32); SR(rsrc); F_____;
13570+ SYNTAX("adc #%1, %0");
13571+#line 513 "rx-decode.opc"
13572+ ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
1023713573
1023813574 }
1023913575 break;
10240- case 0x10:
13576+ case 0x40:
13577+ op_semantics_114:
1024113578 {
10242- /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10243-#line 867 "rx-decode.opc"
10244- int a AU = (op[2] >> 7) & 0x01;
10245-#line 867 "rx-decode.opc"
10246- int rsrc AU = op[2] & 0x0f;
13579+ /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
13580+#line 595 "rx-decode.opc"
13581+ int im AU = (op[1] >> 2) & 0x03;
13582+#line 595 "rx-decode.opc"
13583+ int rdst AU = op[2] & 0x0f;
1024713584 if (trace)
1024813585 {
1024913586 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10250- "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
13587+ "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
1025113588 op[0], op[1], op[2]);
10252- printf (" a = 0x%x,", a);
10253- printf (" rsrc = 0x%x\n", rsrc);
13589+ printf (" im = 0x%x,", im);
13590+ printf (" rdst = 0x%x\n", rdst);
1025413591 }
10255- SYNTAX("mvtaclo %1, %0");
10256-#line 867 "rx-decode.opc"
10257- ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
13592+ SYNTAX("max #%1, %0");
13593+#line 595 "rx-decode.opc"
13594+ int val = IMMex (im);
13595+ if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
13596+ {
13597+ ID (nop7);
13598+ SYNTAX("nop\t; max\t#0x80000000, r0");
13599+ }
13600+ else
13601+ {
13602+ ID(max);
13603+ }
13604+ DR(rdst); SC(val);
1025813605
1025913606 }
1026013607 break;
10261- case 0x30:
13608+ case 0x50:
13609+ op_semantics_115:
1026213610 {
10263- /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10264-#line 1089 "rx-decode.opc"
10265- int a AU = (op[2] >> 7) & 0x01;
10266-#line 1089 "rx-decode.opc"
13611+ /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
13612+#line 625 "rx-decode.opc"
13613+ int im AU = (op[1] >> 2) & 0x03;
13614+#line 625 "rx-decode.opc"
1026713615 int rdst AU = op[2] & 0x0f;
1026813616 if (trace)
1026913617 {
1027013618 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10271- "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */",
13619+ "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
1027213620 op[0], op[1], op[2]);
10273- printf (" a = 0x%x,", a);
13621+ printf (" im = 0x%x,", im);
1027413622 printf (" rdst = 0x%x\n", rdst);
1027513623 }
10276- SYNTAX("mvtacgu %0, %1");
10277-#line 1089 "rx-decode.opc"
10278- ID(mvtacgu); DR(a+32); SR(rdst); F_____;
13624+ SYNTAX("min #%1, %0");
13625+#line 625 "rx-decode.opc"
13626+ ID(min); DR(rdst); SC(IMMex(im));
1027913627
1028013628 }
1028113629 break;
10282- default: UNSUPPORTED(); break;
10283- }
10284- break;
10285- case 0x18:
10286- GETBYTE ();
10287- switch (op[2] & 0x6f)
10288- {
10289- case 0x00:
13630+ case 0x60:
13631+ op_semantics_116:
1029013632 {
10291- /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */
10292-#line 879 "rx-decode.opc"
10293- int a AU = (op[2] >> 7) & 0x01;
10294-#line 879 "rx-decode.opc"
10295- int i AU = (op[2] >> 4) & 0x01;
13633+ /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
13634+#line 683 "rx-decode.opc"
13635+ int im AU = (op[1] >> 2) & 0x03;
13636+#line 683 "rx-decode.opc"
13637+ int rdst AU = op[2] & 0x0f;
1029613638 if (trace)
1029713639 {
1029813640 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10299- "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */",
13641+ "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
1030013642 op[0], op[1], op[2]);
10301- printf (" a = 0x%x,", a);
10302- printf (" i = 0x%x\n", i);
13643+ printf (" im = 0x%x,", im);
13644+ printf (" rdst = 0x%x\n", rdst);
1030313645 }
10304- SYNTAX("racw #%1, %0");
10305-#line 879 "rx-decode.opc"
10306- ID(racw); SC(i+1); DR(a+32); F_____;
10307-
10308- /*----------------------------------------------------------------------*/
10309- /* SAT */
13646+ SYNTAX("emul #%1, %0");
13647+#line 683 "rx-decode.opc"
13648+ ID(emul); DR(rdst); SC(IMMex(im));
1031013649
1031113650 }
1031213651 break;
10313- case 0x40:
13652+ case 0x70:
13653+ op_semantics_117:
1031413654 {
10315- /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
10316-#line 1098 "rx-decode.opc"
10317- int a AU = (op[2] >> 7) & 0x01;
10318-#line 1098 "rx-decode.opc"
10319- int i AU = (op[2] >> 4) & 0x01;
13655+ /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
13656+#line 695 "rx-decode.opc"
13657+ int im AU = (op[1] >> 2) & 0x03;
13658+#line 695 "rx-decode.opc"
13659+ int rdst AU = op[2] & 0x0f;
1032013660 if (trace)
1032113661 {
1032213662 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10323- "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
13663+ "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
1032413664 op[0], op[1], op[2]);
10325- printf (" a = 0x%x,", a);
10326- printf (" i = 0x%x\n", i);
13665+ printf (" im = 0x%x,", im);
13666+ printf (" rdst = 0x%x\n", rdst);
1032713667 }
10328- SYNTAX("rdacw #%1, %0");
10329-#line 1098 "rx-decode.opc"
10330- ID(rdacw); SC(i+1); DR(a+32); F_____;
13668+ SYNTAX("emulu #%1, %0");
13669+#line 695 "rx-decode.opc"
13670+ ID(emulu); DR(rdst); SC(IMMex(im));
1033113671
1033213672 }
1033313673 break;
10334- default: UNSUPPORTED(); break;
10335- }
10336- break;
10337- case 0x19:
10338- GETBYTE ();
10339- switch (op[2] & 0x6f)
10340- {
10341- case 0x00:
13674+ case 0x80:
13675+ op_semantics_118:
1034213676 {
10343- /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */
10344-#line 1092 "rx-decode.opc"
10345- int a AU = (op[2] >> 7) & 0x01;
10346-#line 1092 "rx-decode.opc"
10347- int i AU = (op[2] >> 4) & 0x01;
13677+ /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
13678+#line 707 "rx-decode.opc"
13679+ int im AU = (op[1] >> 2) & 0x03;
13680+#line 707 "rx-decode.opc"
13681+ int rdst AU = op[2] & 0x0f;
1034813682 if (trace)
1034913683 {
1035013684 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10351- "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */",
13685+ "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
1035213686 op[0], op[1], op[2]);
10353- printf (" a = 0x%x,", a);
10354- printf (" i = 0x%x\n", i);
13687+ printf (" im = 0x%x,", im);
13688+ printf (" rdst = 0x%x\n", rdst);
1035513689 }
10356- SYNTAX("racl #%1, %0");
10357-#line 1092 "rx-decode.opc"
10358- ID(racl); SC(i+1); DR(a+32); F_____;
13690+ SYNTAX("div #%1, %0");
13691+#line 707 "rx-decode.opc"
13692+ ID(div); DR(rdst); SC(IMMex(im)); F_O___;
1035913693
1036013694 }
1036113695 break;
10362- case 0x40:
13696+ case 0x90:
13697+ op_semantics_119:
1036313698 {
10364- /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
10365-#line 1095 "rx-decode.opc"
10366- int a AU = (op[2] >> 7) & 0x01;
10367-#line 1095 "rx-decode.opc"
10368- int i AU = (op[2] >> 4) & 0x01;
13699+ /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
13700+#line 719 "rx-decode.opc"
13701+ int im AU = (op[1] >> 2) & 0x03;
13702+#line 719 "rx-decode.opc"
13703+ int rdst AU = op[2] & 0x0f;
1036913704 if (trace)
1037013705 {
1037113706 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10372- "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
13707+ "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
1037313708 op[0], op[1], op[2]);
10374- printf (" a = 0x%x,", a);
10375- printf (" i = 0x%x\n", i);
13709+ printf (" im = 0x%x,", im);
13710+ printf (" rdst = 0x%x\n", rdst);
1037613711 }
10377- SYNTAX("rdacl #%1, %0");
10378-#line 1095 "rx-decode.opc"
10379- ID(rdacl); SC(i+1); DR(a+32); F_____;
13712+ SYNTAX("divu #%1, %0");
13713+#line 719 "rx-decode.opc"
13714+ ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
1038013715
1038113716 }
1038213717 break;
10383- default: UNSUPPORTED(); break;
10384- }
10385- break;
10386- case 0x1e:
10387- GETBYTE ();
10388- switch (op[2] & 0x30)
10389- {
10390- case 0x00:
10391- op_semantics_83:
13718+ case 0xc0:
13719+ op_semantics_120:
1039213720 {
10393- /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */
10394-#line 870 "rx-decode.opc"
10395- int i AU = op[1] & 0x01;
10396-#line 870 "rx-decode.opc"
10397- int a AU = (op[2] >> 7) & 0x01;
10398-#line 870 "rx-decode.opc"
10399- int m AU = (op[2] >> 6) & 0x01;
10400-#line 870 "rx-decode.opc"
13721+ /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
13722+#line 492 "rx-decode.opc"
13723+ int im AU = (op[1] >> 2) & 0x03;
13724+#line 492 "rx-decode.opc"
1040113725 int rdst AU = op[2] & 0x0f;
1040213726 if (trace)
1040313727 {
1040413728 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10405- "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */",
13729+ "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
1040613730 op[0], op[1], op[2]);
10407- printf (" i = 0x%x,", i);
10408- printf (" a = 0x%x,", a);
10409- printf (" m = 0x%x,", m);
13731+ printf (" im = 0x%x,", im);
1041013732 printf (" rdst = 0x%x\n", rdst);
1041113733 }
10412- SYNTAX("mvfachi #%2, %1, %0");
10413-#line 870 "rx-decode.opc"
10414- ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
13734+ SYNTAX("tst #%1, %2");
13735+#line 492 "rx-decode.opc"
13736+ ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
1041513737
1041613738 }
1041713739 break;
10418- case 0x10:
10419- op_semantics_84:
13740+ case 0xd0:
13741+ op_semantics_121:
1042013742 {
10421- /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */
10422-#line 876 "rx-decode.opc"
10423- int i AU = op[1] & 0x01;
10424-#line 876 "rx-decode.opc"
10425- int a AU = (op[2] >> 7) & 0x01;
10426-#line 876 "rx-decode.opc"
10427- int m AU = (op[2] >> 6) & 0x01;
10428-#line 876 "rx-decode.opc"
13743+ /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
13744+#line 471 "rx-decode.opc"
13745+ int im AU = (op[1] >> 2) & 0x03;
13746+#line 471 "rx-decode.opc"
1042913747 int rdst AU = op[2] & 0x0f;
1043013748 if (trace)
1043113749 {
1043213750 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10433- "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */",
13751+ "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
1043413752 op[0], op[1], op[2]);
10435- printf (" i = 0x%x,", i);
10436- printf (" a = 0x%x,", a);
10437- printf (" m = 0x%x,", m);
13753+ printf (" im = 0x%x,", im);
1043813754 printf (" rdst = 0x%x\n", rdst);
1043913755 }
10440- SYNTAX("mvfaclo #%2, %1, %0");
10441-#line 876 "rx-decode.opc"
10442- ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
13756+ SYNTAX("xor #%1, %0");
13757+#line 471 "rx-decode.opc"
13758+ ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
1044313759
1044413760 }
1044513761 break;
10446- case 0x20:
10447- op_semantics_85:
13762+ case 0xe0:
13763+ op_semantics_122:
1044813764 {
10449- /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */
10450-#line 873 "rx-decode.opc"
10451- int i AU = op[1] & 0x01;
10452-#line 873 "rx-decode.opc"
10453- int a AU = (op[2] >> 7) & 0x01;
10454-#line 873 "rx-decode.opc"
10455- int m AU = (op[2] >> 6) & 0x01;
10456-#line 873 "rx-decode.opc"
13765+ /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
13766+#line 417 "rx-decode.opc"
13767+ int im AU = (op[1] >> 2) & 0x03;
13768+#line 417 "rx-decode.opc"
1045713769 int rdst AU = op[2] & 0x0f;
1045813770 if (trace)
1045913771 {
1046013772 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10461- "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */",
13773+ "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
1046213774 op[0], op[1], op[2]);
10463- printf (" i = 0x%x,", i);
10464- printf (" a = 0x%x,", a);
10465- printf (" m = 0x%x,", m);
13775+ printf (" im = 0x%x,", im);
1046613776 printf (" rdst = 0x%x\n", rdst);
1046713777 }
10468- SYNTAX("mvfacmi #%2, %1, %0");
10469-#line 873 "rx-decode.opc"
10470- ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
13778+ SYNTAX("stz #%1, %0");
13779+#line 417 "rx-decode.opc"
13780+ ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
1047113781
1047213782 }
1047313783 break;
10474- case 0x30:
10475- op_semantics_86:
13784+ case 0xf0:
13785+ op_semantics_123:
1047613786 {
10477- /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */
10478-#line 1086 "rx-decode.opc"
10479- int i AU = op[1] & 0x01;
10480-#line 1086 "rx-decode.opc"
10481- int a AU = (op[2] >> 7) & 0x01;
10482-#line 1086 "rx-decode.opc"
10483- int m AU = (op[2] >> 6) & 0x01;
10484-#line 1086 "rx-decode.opc"
13787+ /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
13788+#line 420 "rx-decode.opc"
13789+ int im AU = (op[1] >> 2) & 0x03;
13790+#line 420 "rx-decode.opc"
1048513791 int rdst AU = op[2] & 0x0f;
1048613792 if (trace)
1048713793 {
1048813794 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10489- "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */",
13795+ "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
1049013796 op[0], op[1], op[2]);
10491- printf (" i = 0x%x,", i);
10492- printf (" a = 0x%x,", a);
10493- printf (" m = 0x%x,", m);
13797+ printf (" im = 0x%x,", im);
1049413798 printf (" rdst = 0x%x\n", rdst);
1049513799 }
10496- SYNTAX("mvfacgu #%2, %1, %0");
10497-#line 1086 "rx-decode.opc"
10498- ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
13800+ SYNTAX("stnz #%1, %0");
13801+#line 420 "rx-decode.opc"
13802+ ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
13803+
13804+ /*----------------------------------------------------------------------*/
13805+ /* RTSD */
1049913806
1050013807 }
1050113808 break;
13809+ default: UNSUPPORTED(); break;
1050213810 }
1050313811 break;
10504- case 0x1f:
13812+ case 0x72:
1050513813 GETBYTE ();
10506- switch (op[2] & 0x30)
13814+ switch (op[2] & 0xf0)
1050713815 {
1050813816 case 0x00:
10509- goto op_semantics_83;
13817+ {
13818+ /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
13819+#line 927 "rx-decode.opc"
13820+ int rdst AU = op[2] & 0x0f;
13821+ if (trace)
13822+ {
13823+ printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13824+ "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
13825+ op[0], op[1], op[2]);
13826+ printf (" rdst = 0x%x\n", rdst);
13827+ }
13828+ SYNTAX("fsub #%1, %0");
13829+#line 927 "rx-decode.opc"
13830+ ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
13831+
13832+ }
1051013833 break;
1051113834 case 0x10:
10512- goto op_semantics_84;
10513- break;
10514- case 0x20:
10515- goto op_semantics_85;
10516- break;
10517- case 0x30:
10518- goto op_semantics_86;
10519- break;
10520- }
10521- break;
10522- case 0x20:
10523- GETBYTE ();
10524- switch (op[2] & 0x00)
10525- {
10526- case 0x00:
10527- op_semantics_87:
1052813835 {
10529- /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
10530-#line 348 "rx-decode.opc"
10531- int p AU = (op[1] >> 2) & 0x01;
10532-#line 348 "rx-decode.opc"
10533- int sz AU = op[1] & 0x03;
10534-#line 348 "rx-decode.opc"
10535- int rdst AU = (op[2] >> 4) & 0x0f;
10536-#line 348 "rx-decode.opc"
10537- int rsrc AU = op[2] & 0x0f;
13836+ /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
13837+#line 921 "rx-decode.opc"
13838+ int rdst AU = op[2] & 0x0f;
1053813839 if (trace)
1053913840 {
1054013841 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10541- "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
13842+ "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
1054213843 op[0], op[1], op[2]);
10543- printf (" p = 0x%x,", p);
10544- printf (" sz = 0x%x,", sz);
10545- printf (" rdst = 0x%x,", rdst);
10546- printf (" rsrc = 0x%x\n", rsrc);
13844+ printf (" rdst = 0x%x\n", rdst);
1054713845 }
10548- SYNTAX("mov%s %1, %0");
10549-#line 348 "rx-decode.opc"
10550- ID(mov); sBWL (sz); SR(rsrc); F_____;
10551- OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
13846+ SYNTAX("fcmp #%1, %0");
13847+#line 921 "rx-decode.opc"
13848+ ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
1055213849
1055313850 }
1055413851 break;
10555- }
10556- break;
10557- case 0x21:
10558- GETBYTE ();
10559- switch (op[2] & 0x00)
10560- {
10561- case 0x00:
10562- goto op_semantics_87;
10563- break;
10564- }
10565- break;
10566- case 0x22:
10567- GETBYTE ();
10568- switch (op[2] & 0x00)
10569- {
10570- case 0x00:
10571- goto op_semantics_87;
10572- break;
10573- }
10574- break;
10575- case 0x24:
10576- GETBYTE ();
10577- switch (op[2] & 0x00)
10578- {
10579- case 0x00:
10580- goto op_semantics_87;
10581- break;
10582- }
10583- break;
10584- case 0x25:
10585- GETBYTE ();
10586- switch (op[2] & 0x00)
10587- {
10588- case 0x00:
10589- goto op_semantics_87;
10590- break;
10591- }
10592- break;
10593- case 0x26:
10594- GETBYTE ();
10595- switch (op[2] & 0x00)
10596- {
10597- case 0x00:
10598- goto op_semantics_87;
10599- break;
10600- }
10601- break;
10602- case 0x27:
10603- GETBYTE ();
10604- switch (op[2] & 0x00)
10605- {
10606- case 0x00:
13852+ case 0x20:
1060713853 {
10608- /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
10609-#line 1050 "rx-decode.opc"
10610- int rdst AU = (op[2] >> 4) & 0x0f;
10611-#line 1050 "rx-decode.opc"
10612- int rsrc AU = op[2] & 0x0f;
13854+ /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
13855+#line 915 "rx-decode.opc"
13856+ int rdst AU = op[2] & 0x0f;
1061313857 if (trace)
1061413858 {
1061513859 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10616- "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
13860+ "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
1061713861 op[0], op[1], op[2]);
10618- printf (" rdst = 0x%x,", rdst);
10619- printf (" rsrc = 0x%x\n", rsrc);
13862+ printf (" rdst = 0x%x\n", rdst);
1062013863 }
10621- SYNTAX("movco %1, [%0]");
10622-#line 1050 "rx-decode.opc"
10623- ID(movco); SR(rsrc); DR(rdst); F_____;
13864+ SYNTAX("fadd #%1, %0");
13865+#line 915 "rx-decode.opc"
13866+ ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
1062413867
1062513868 }
1062613869 break;
10627- }
10628- break;
10629- case 0x28:
10630- GETBYTE ();
10631- switch (op[2] & 0x00)
10632- {
10633- case 0x00:
10634- op_semantics_88:
13870+ case 0x30:
1063513871 {
10636- /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */
10637-#line 352 "rx-decode.opc"
10638- int p AU = (op[1] >> 2) & 0x01;
10639-#line 352 "rx-decode.opc"
10640- int sz AU = op[1] & 0x03;
10641-#line 352 "rx-decode.opc"
10642- int rsrc AU = (op[2] >> 4) & 0x0f;
10643-#line 352 "rx-decode.opc"
13872+ /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
13873+#line 936 "rx-decode.opc"
1064413874 int rdst AU = op[2] & 0x0f;
1064513875 if (trace)
1064613876 {
1064713877 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10648- "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
13878+ "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
1064913879 op[0], op[1], op[2]);
10650- printf (" p = 0x%x,", p);
10651- printf (" sz = 0x%x,", sz);
10652- printf (" rsrc = 0x%x,", rsrc);
1065313880 printf (" rdst = 0x%x\n", rdst);
1065413881 }
10655- SYNTAX("mov%s %1, %0");
10656-#line 352 "rx-decode.opc"
10657- ID(mov); sBWL (sz); DR(rdst); F_____;
10658- OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
13882+ SYNTAX("fmul #%1, %0");
13883+#line 936 "rx-decode.opc"
13884+ ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
1065913885
1066013886 }
1066113887 break;
10662- }
10663- break;
10664- case 0x29:
10665- GETBYTE ();
10666- switch (op[2] & 0x00)
10667- {
10668- case 0x00:
10669- goto op_semantics_88;
10670- break;
10671- }
10672- break;
10673- case 0x2a:
10674- GETBYTE ();
10675- switch (op[2] & 0x00)
10676- {
10677- case 0x00:
10678- goto op_semantics_88;
10679- break;
10680- }
10681- break;
10682- case 0x2c:
10683- GETBYTE ();
10684- switch (op[2] & 0x00)
10685- {
10686- case 0x00:
10687- goto op_semantics_88;
10688- break;
10689- }
10690- break;
10691- case 0x2d:
10692- GETBYTE ();
10693- switch (op[2] & 0x00)
10694- {
10695- case 0x00:
10696- goto op_semantics_88;
10697- break;
10698- }
10699- break;
10700- case 0x2e:
10701- GETBYTE ();
10702- switch (op[2] & 0x00)
10703- {
10704- case 0x00:
10705- goto op_semantics_88;
10706- break;
10707- }
10708- break;
10709- case 0x2f:
10710- GETBYTE ();
10711- switch (op[2] & 0x00)
10712- {
10713- case 0x00:
13888+ case 0x40:
1071413889 {
10715- /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
10716-#line 1053 "rx-decode.opc"
10717- int rsrc AU = (op[2] >> 4) & 0x0f;
10718-#line 1053 "rx-decode.opc"
13890+ /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
13891+#line 942 "rx-decode.opc"
1071913892 int rdst AU = op[2] & 0x0f;
1072013893 if (trace)
1072113894 {
1072213895 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10723- "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
13896+ "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
1072413897 op[0], op[1], op[2]);
10725- printf (" rsrc = 0x%x,", rsrc);
1072613898 printf (" rdst = 0x%x\n", rdst);
1072713899 }
10728- SYNTAX("movli [%1], %0");
10729-#line 1053 "rx-decode.opc"
10730- ID(movli); SR(rsrc); DR(rdst); F_____;
13900+ SYNTAX("fdiv #%1, %0");
13901+#line 942 "rx-decode.opc"
13902+ ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
1073113903
1073213904 }
1073313905 break;
13906+ default: UNSUPPORTED(); break;
1073413907 }
1073513908 break;
10736- case 0x38:
13909+ case 0x73:
1073713910 GETBYTE ();
10738- switch (op[2] & 0x00)
13911+ switch (op[2] & 0xe0)
1073913912 {
1074013913 case 0x00:
10741- op_semantics_89:
13914+ op_semantics_124:
1074213915 {
10743- /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */
10744-#line 362 "rx-decode.opc"
10745- int p AU = (op[1] >> 2) & 0x01;
10746-#line 362 "rx-decode.opc"
10747- int sz AU = op[1] & 0x03;
10748-#line 362 "rx-decode.opc"
10749- int rsrc AU = (op[2] >> 4) & 0x0f;
10750-#line 362 "rx-decode.opc"
10751- int rdst AU = op[2] & 0x0f;
13916+ /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
13917+#line 1032 "rx-decode.opc"
13918+ int im AU = (op[1] >> 2) & 0x03;
13919+#line 1032 "rx-decode.opc"
13920+ int crdst AU = op[2] & 0x1f;
1075213921 if (trace)
1075313922 {
1075413923 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10755- "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
13924+ "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
1075613925 op[0], op[1], op[2]);
10757- printf (" p = 0x%x,", p);
10758- printf (" sz = 0x%x,", sz);
10759- printf (" rsrc = 0x%x,", rsrc);
10760- printf (" rdst = 0x%x\n", rdst);
13926+ printf (" im = 0x%x,", im);
13927+ printf (" crdst = 0x%x\n", crdst);
1076113928 }
10762- SYNTAX("movu%s %1, %0");
10763-#line 362 "rx-decode.opc"
10764- ID(mov); uBW (sz); DR(rdst); F_____;
10765- OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10766-
10767- /*----------------------------------------------------------------------*/
10768- /* PUSH/POP */
13929+ SYNTAX("mvtc #%1, %0");
13930+#line 1032 "rx-decode.opc"
13931+ ID(mov); SC(IMMex(im)); DR(crdst + 16);
1076913932
1077013933 }
1077113934 break;
13935+ default: UNSUPPORTED(); break;
1077213936 }
1077313937 break;
10774- case 0x39:
13938+ case 0x74:
1077513939 GETBYTE ();
10776- switch (op[2] & 0x00)
13940+ switch (op[2] & 0xf0)
1077713941 {
10778- case 0x00:
10779- goto op_semantics_89;
13942+ case 0x20:
13943+ goto op_semantics_113;
1078013944 break;
10781- }
10782- break;
10783- case 0x3a:
10784- GETBYTE ();
10785- switch (op[2] & 0x00)
10786- {
10787- case 0x00:
10788- goto op_semantics_89;
13945+ case 0x40:
13946+ goto op_semantics_114;
1078913947 break;
10790- }
10791- break;
10792- case 0x3c:
10793- GETBYTE ();
10794- switch (op[2] & 0x00)
10795- {
10796- case 0x00:
10797- goto op_semantics_89;
13948+ case 0x50:
13949+ goto op_semantics_115;
1079813950 break;
10799- }
10800- break;
10801- case 0x3d:
10802- GETBYTE ();
10803- switch (op[2] & 0x00)
10804- {
10805- case 0x00:
10806- goto op_semantics_89;
13951+ case 0x60:
13952+ goto op_semantics_116;
1080713953 break;
10808- }
10809- break;
10810- case 0x3e:
10811- GETBYTE ();
10812- switch (op[2] & 0x00)
10813- {
10814- case 0x00:
10815- goto op_semantics_89;
13954+ case 0x70:
13955+ goto op_semantics_117;
13956+ break;
13957+ case 0x80:
13958+ goto op_semantics_118;
13959+ break;
13960+ case 0x90:
13961+ goto op_semantics_119;
13962+ break;
13963+ case 0xc0:
13964+ goto op_semantics_120;
13965+ break;
13966+ case 0xd0:
13967+ goto op_semantics_121;
13968+ break;
13969+ case 0xe0:
13970+ goto op_semantics_122;
1081613971 break;
13972+ case 0xf0:
13973+ goto op_semantics_123;
13974+ break;
13975+ default: UNSUPPORTED(); break;
1081713976 }
1081813977 break;
10819- case 0x44:
13978+ case 0x75:
1082013979 GETBYTE ();
10821- switch (op[2] & 0x00)
13980+ switch (op[2] & 0xff)
1082213981 {
10823- case 0x00:
10824- op_semantics_90:
13982+ case 0x80:
13983+ GETBYTE ();
13984+ switch (op[3] & 0x0f)
1082513985 {
10826- /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
10827-#line 1074 "rx-decode.opc"
10828- int a AU = (op[1] >> 3) & 0x01;
10829-#line 1074 "rx-decode.opc"
10830- int srca AU = (op[2] >> 4) & 0x0f;
10831-#line 1074 "rx-decode.opc"
10832- int srcb AU = op[2] & 0x0f;
10833- if (trace)
10834- {
10835- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10836- "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
10837- op[0], op[1], op[2]);
10838- printf (" a = 0x%x,", a);
10839- printf (" srca = 0x%x,", srca);
10840- printf (" srcb = 0x%x\n", srcb);
10841- }
10842- SYNTAX("msbhi %1, %2, %0");
10843-#line 1074 "rx-decode.opc"
10844- ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13986+ case 0x00:
13987+ op_semantics_125:
13988+ {
13989+ /** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */
13990+#line 1176 "rx-decode.opc"
13991+ int rdst AU = op[2] & 0x0f;
13992+#line 1176 "rx-decode.opc"
13993+ int rsrc AU = (op[3] >> 4) & 0x0f;
13994+ if (trace)
13995+ {
13996+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
13997+ "/** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */",
13998+ op[0], op[1], op[2], op[3]);
13999+ printf (" rdst = 0x%x,", rdst);
14000+ printf (" rsrc = 0x%x\n", rsrc);
14001+ }
14002+ SYNTAX("dmov.l %1, %0");
14003+#line 1176 "rx-decode.opc"
14004+ ID(dmov); DR(rdst); SDRL(rsrc); F_____;
14005+
14006+ }
14007+ break;
14008+ case 0x02:
14009+ op_semantics_126:
14010+ {
14011+ /** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */
14012+#line 1173 "rx-decode.opc"
14013+ int rdst AU = op[2] & 0x0f;
14014+#line 1173 "rx-decode.opc"
14015+ int rsrc AU = (op[3] >> 4) & 0x0f;
14016+ if (trace)
14017+ {
14018+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14019+ "/** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */",
14020+ op[0], op[1], op[2], op[3]);
14021+ printf (" rdst = 0x%x,", rdst);
14022+ printf (" rsrc = 0x%x\n", rsrc);
14023+ }
14024+ SYNTAX("dmov.l %1, %0");
14025+#line 1173 "rx-decode.opc"
14026+ ID(dmov); DR(rdst); SDRH(rsrc); F_____;
1084514027
14028+ }
14029+ break;
14030+ case 0x04:
14031+ op_semantics_127:
14032+ {
14033+ /** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */
14034+#line 1226 "rx-decode.opc"
14035+ int rdst AU = op[2] & 0x0f;
14036+#line 1226 "rx-decode.opc"
14037+ int rsrc AU = (op[3] >> 4) & 0x0f;
14038+ if (trace)
14039+ {
14040+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14041+ "/** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */",
14042+ op[0], op[1], op[2], op[3]);
14043+ printf (" rdst = 0x%x,", rdst);
14044+ printf (" rsrc = 0x%x\n", rsrc);
14045+ }
14046+ SYNTAX("mvfdc %1, %0");
14047+#line 1226 "rx-decode.opc"
14048+ ID(mvfdc); DR(rdst); SCR(rsrc); F_____;
14049+
14050+ }
14051+ break;
14052+ default: UNSUPPORTED(); break;
1084614053 }
1084714054 break;
10848- }
10849- break;
10850- case 0x45:
10851- GETBYTE ();
10852- switch (op[2] & 0x00)
10853- {
10854- case 0x00:
10855- op_semantics_91:
14055+ case 0x81:
14056+ GETBYTE ();
14057+ switch (op[3] & 0x0f)
1085614058 {
10857- /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
10858-#line 1080 "rx-decode.opc"
10859- int a AU = (op[1] >> 3) & 0x01;
10860-#line 1080 "rx-decode.opc"
10861- int srca AU = (op[2] >> 4) & 0x0f;
10862-#line 1080 "rx-decode.opc"
10863- int srcb AU = op[2] & 0x0f;
10864- if (trace)
10865- {
10866- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10867- "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
10868- op[0], op[1], op[2]);
10869- printf (" a = 0x%x,", a);
10870- printf (" srca = 0x%x,", srca);
10871- printf (" srcb = 0x%x\n", srcb);
10872- }
10873- SYNTAX("msblo %1, %2, %0");
10874-#line 1080 "rx-decode.opc"
10875- ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
10876-
14059+ case 0x00:
14060+ goto op_semantics_125;
14061+ break;
14062+ case 0x02:
14063+ goto op_semantics_126;
14064+ break;
14065+ case 0x04:
14066+ goto op_semantics_127;
14067+ break;
14068+ default: UNSUPPORTED(); break;
14069+ }
14070+ break;
14071+ case 0x82:
14072+ GETBYTE ();
14073+ switch (op[3] & 0x0f)
14074+ {
14075+ case 0x00:
14076+ goto op_semantics_125;
14077+ break;
14078+ case 0x02:
14079+ goto op_semantics_126;
14080+ break;
14081+ case 0x04:
14082+ goto op_semantics_127;
14083+ break;
14084+ default: UNSUPPORTED(); break;
14085+ }
14086+ break;
14087+ case 0x83:
14088+ GETBYTE ();
14089+ switch (op[3] & 0x0f)
14090+ {
14091+ case 0x00:
14092+ goto op_semantics_125;
14093+ break;
14094+ case 0x02:
14095+ goto op_semantics_126;
14096+ break;
14097+ case 0x04:
14098+ goto op_semantics_127;
14099+ break;
14100+ default: UNSUPPORTED(); break;
14101+ }
14102+ break;
14103+ case 0x84:
14104+ GETBYTE ();
14105+ switch (op[3] & 0x0f)
14106+ {
14107+ case 0x00:
14108+ goto op_semantics_125;
14109+ break;
14110+ case 0x02:
14111+ goto op_semantics_126;
14112+ break;
14113+ case 0x04:
14114+ goto op_semantics_127;
14115+ break;
14116+ default: UNSUPPORTED(); break;
14117+ }
14118+ break;
14119+ case 0x85:
14120+ GETBYTE ();
14121+ switch (op[3] & 0x0f)
14122+ {
14123+ case 0x00:
14124+ goto op_semantics_125;
14125+ break;
14126+ case 0x02:
14127+ goto op_semantics_126;
14128+ break;
14129+ case 0x04:
14130+ goto op_semantics_127;
14131+ break;
14132+ default: UNSUPPORTED(); break;
14133+ }
14134+ break;
14135+ case 0x86:
14136+ GETBYTE ();
14137+ switch (op[3] & 0x0f)
14138+ {
14139+ case 0x00:
14140+ goto op_semantics_125;
14141+ break;
14142+ case 0x02:
14143+ goto op_semantics_126;
14144+ break;
14145+ case 0x04:
14146+ goto op_semantics_127;
14147+ break;
14148+ default: UNSUPPORTED(); break;
14149+ }
14150+ break;
14151+ case 0x87:
14152+ GETBYTE ();
14153+ switch (op[3] & 0x0f)
14154+ {
14155+ case 0x00:
14156+ goto op_semantics_125;
14157+ break;
14158+ case 0x02:
14159+ goto op_semantics_126;
14160+ break;
14161+ case 0x04:
14162+ goto op_semantics_127;
14163+ break;
14164+ default: UNSUPPORTED(); break;
14165+ }
14166+ break;
14167+ case 0x88:
14168+ GETBYTE ();
14169+ switch (op[3] & 0x0f)
14170+ {
14171+ case 0x00:
14172+ goto op_semantics_125;
14173+ break;
14174+ case 0x02:
14175+ goto op_semantics_126;
14176+ break;
14177+ case 0x04:
14178+ goto op_semantics_127;
14179+ break;
14180+ default: UNSUPPORTED(); break;
14181+ }
14182+ break;
14183+ case 0x89:
14184+ GETBYTE ();
14185+ switch (op[3] & 0x0f)
14186+ {
14187+ case 0x00:
14188+ goto op_semantics_125;
14189+ break;
14190+ case 0x02:
14191+ goto op_semantics_126;
14192+ break;
14193+ case 0x04:
14194+ goto op_semantics_127;
14195+ break;
14196+ default: UNSUPPORTED(); break;
14197+ }
14198+ break;
14199+ case 0x8a:
14200+ GETBYTE ();
14201+ switch (op[3] & 0x0f)
14202+ {
14203+ case 0x00:
14204+ goto op_semantics_125;
14205+ break;
14206+ case 0x02:
14207+ goto op_semantics_126;
14208+ break;
14209+ case 0x04:
14210+ goto op_semantics_127;
14211+ break;
14212+ default: UNSUPPORTED(); break;
1087714213 }
1087814214 break;
10879- }
10880- break;
10881- case 0x46:
10882- GETBYTE ();
10883- switch (op[2] & 0x00)
10884- {
10885- case 0x00:
10886- op_semantics_92:
14215+ case 0x8b:
14216+ GETBYTE ();
14217+ switch (op[3] & 0x0f)
1088714218 {
10888- /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
10889-#line 1077 "rx-decode.opc"
10890- int a AU = (op[1] >> 3) & 0x01;
10891-#line 1077 "rx-decode.opc"
10892- int srca AU = (op[2] >> 4) & 0x0f;
10893-#line 1077 "rx-decode.opc"
10894- int srcb AU = op[2] & 0x0f;
10895- if (trace)
10896- {
10897- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10898- "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
10899- op[0], op[1], op[2]);
10900- printf (" a = 0x%x,", a);
10901- printf (" srca = 0x%x,", srca);
10902- printf (" srcb = 0x%x\n", srcb);
10903- }
10904- SYNTAX("msblh %1, %2, %0");
10905-#line 1077 "rx-decode.opc"
10906- ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
10907-
14219+ case 0x00:
14220+ goto op_semantics_125;
14221+ break;
14222+ case 0x02:
14223+ goto op_semantics_126;
14224+ break;
14225+ case 0x04:
14226+ goto op_semantics_127;
14227+ break;
14228+ default: UNSUPPORTED(); break;
1090814229 }
1090914230 break;
10910- }
10911- break;
10912- case 0x47:
10913- GETBYTE ();
10914- switch (op[2] & 0x00)
10915- {
10916- case 0x00:
10917- op_semantics_93:
14231+ case 0x8c:
14232+ GETBYTE ();
14233+ switch (op[3] & 0x0f)
1091814234 {
10919- /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */
10920-#line 1065 "rx-decode.opc"
10921- int a AU = (op[1] >> 3) & 0x01;
10922-#line 1065 "rx-decode.opc"
10923- int srca AU = (op[2] >> 4) & 0x0f;
10924-#line 1065 "rx-decode.opc"
10925- int srcb AU = op[2] & 0x0f;
10926- if (trace)
10927- {
10928- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10929- "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */",
10930- op[0], op[1], op[2]);
10931- printf (" a = 0x%x,", a);
10932- printf (" srca = 0x%x,", srca);
10933- printf (" srcb = 0x%x\n", srcb);
10934- }
10935- SYNTAX("emsba %1, %2, %0");
10936-#line 1065 "rx-decode.opc"
10937- ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
10938-
14235+ case 0x00:
14236+ goto op_semantics_125;
14237+ break;
14238+ case 0x02:
14239+ goto op_semantics_126;
14240+ break;
14241+ case 0x04:
14242+ goto op_semantics_127;
14243+ break;
14244+ default: UNSUPPORTED(); break;
1093914245 }
1094014246 break;
10941- }
10942- break;
10943- case 0x4c:
10944- GETBYTE ();
10945- switch (op[2] & 0x00)
10946- {
10947- case 0x00:
10948- goto op_semantics_90;
10949- break;
10950- }
10951- break;
10952- case 0x4d:
10953- GETBYTE ();
10954- switch (op[2] & 0x00)
10955- {
10956- case 0x00:
10957- goto op_semantics_91;
14247+ case 0x8d:
14248+ GETBYTE ();
14249+ switch (op[3] & 0x0f)
14250+ {
14251+ case 0x00:
14252+ goto op_semantics_125;
14253+ break;
14254+ case 0x02:
14255+ goto op_semantics_126;
14256+ break;
14257+ case 0x04:
14258+ goto op_semantics_127;
14259+ break;
14260+ default: UNSUPPORTED(); break;
14261+ }
1095814262 break;
10959- }
10960- break;
10961- case 0x4e:
10962- GETBYTE ();
10963- switch (op[2] & 0x00)
10964- {
10965- case 0x00:
10966- goto op_semantics_92;
14263+ case 0x8e:
14264+ GETBYTE ();
14265+ switch (op[3] & 0x0f)
14266+ {
14267+ case 0x00:
14268+ goto op_semantics_125;
14269+ break;
14270+ case 0x02:
14271+ goto op_semantics_126;
14272+ break;
14273+ case 0x04:
14274+ goto op_semantics_127;
14275+ break;
14276+ default: UNSUPPORTED(); break;
14277+ }
1096714278 break;
10968- }
10969- break;
10970- case 0x4f:
10971- GETBYTE ();
10972- switch (op[2] & 0x00)
10973- {
10974- case 0x00:
10975- goto op_semantics_93;
14279+ case 0x8f:
14280+ GETBYTE ();
14281+ switch (op[3] & 0x0f)
14282+ {
14283+ case 0x00:
14284+ goto op_semantics_125;
14285+ break;
14286+ case 0x02:
14287+ goto op_semantics_126;
14288+ break;
14289+ case 0x04:
14290+ goto op_semantics_127;
14291+ break;
14292+ default: UNSUPPORTED(); break;
14293+ }
1097614294 break;
14295+ default: UNSUPPORTED(); break;
1097714296 }
1097814297 break;
10979- case 0x60:
14298+ case 0x76:
1098014299 GETBYTE ();
10981- switch (op[2] & 0x00)
14300+ switch (op[2] & 0xff)
1098214301 {
10983- case 0x00:
14302+ case 0xc0:
14303+ GETBYTE ();
14304+ switch (op[3] & 0xff)
1098414305 {
10985- /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
10986-#line 733 "rx-decode.opc"
10987- int rsrc AU = (op[2] >> 4) & 0x0f;
10988-#line 733 "rx-decode.opc"
10989- int rdst AU = op[2] & 0x0f;
10990- if (trace)
10991- {
10992- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10993- "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
10994- op[0], op[1], op[2]);
10995- printf (" rsrc = 0x%x,", rsrc);
10996- printf (" rdst = 0x%x\n", rdst);
10997- }
10998- SYNTAX("shlr %2, %0");
10999-#line 733 "rx-decode.opc"
11000- ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
14306+ case 0x00:
14307+ op_semantics_128:
14308+ {
14309+ /** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */
14310+#line 1161 "rx-decode.opc"
14311+ int rsrc AU = op[2] & 0x0f;
14312+ if (trace)
14313+ {
14314+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14315+ "/** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */",
14316+ op[0], op[1], op[2], op[3]);
14317+ printf (" rsrc = 0x%x\n", rsrc);
14318+ }
14319+ SYNTAX("save %1");
14320+#line 1161 "rx-decode.opc"
14321+ ID(save); SR(rsrc); F_____;
1100114322
14323+ }
14324+ break;
14325+ default: UNSUPPORTED(); break;
1100214326 }
1100314327 break;
11004- }
11005- break;
11006- case 0x61:
11007- GETBYTE ();
11008- switch (op[2] & 0x00)
11009- {
11010- case 0x00:
14328+ case 0xc1:
14329+ GETBYTE ();
14330+ switch (op[3] & 0xff)
1101114331 {
11012- /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
11013-#line 723 "rx-decode.opc"
11014- int rsrc AU = (op[2] >> 4) & 0x0f;
11015-#line 723 "rx-decode.opc"
11016- int rdst AU = op[2] & 0x0f;
11017- if (trace)
11018- {
11019- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11020- "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
11021- op[0], op[1], op[2]);
11022- printf (" rsrc = 0x%x,", rsrc);
11023- printf (" rdst = 0x%x\n", rdst);
11024- }
11025- SYNTAX("shar %2, %0");
11026-#line 723 "rx-decode.opc"
11027- ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
11028-
14332+ case 0x00:
14333+ goto op_semantics_128;
14334+ break;
14335+ default: UNSUPPORTED(); break;
1102914336 }
1103014337 break;
11031- }
11032- break;
11033- case 0x62:
11034- GETBYTE ();
11035- switch (op[2] & 0x00)
11036- {
11037- case 0x00:
14338+ case 0xc2:
14339+ GETBYTE ();
14340+ switch (op[3] & 0xff)
1103814341 {
11039- /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
11040-#line 713 "rx-decode.opc"
11041- int rsrc AU = (op[2] >> 4) & 0x0f;
11042-#line 713 "rx-decode.opc"
11043- int rdst AU = op[2] & 0x0f;
11044- if (trace)
11045- {
11046- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11047- "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
11048- op[0], op[1], op[2]);
11049- printf (" rsrc = 0x%x,", rsrc);
11050- printf (" rdst = 0x%x\n", rdst);
11051- }
11052- SYNTAX("shll %2, %0");
11053-#line 713 "rx-decode.opc"
11054- ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
11055-
14342+ case 0x00:
14343+ goto op_semantics_128;
14344+ break;
14345+ default: UNSUPPORTED(); break;
1105614346 }
1105714347 break;
11058- }
11059- break;
11060- case 0x64:
11061- GETBYTE ();
11062- switch (op[2] & 0x00)
11063- {
11064- case 0x00:
14348+ case 0xc3:
14349+ GETBYTE ();
14350+ switch (op[3] & 0xff)
1106514351 {
11066- /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
11067-#line 757 "rx-decode.opc"
11068- int rsrc AU = (op[2] >> 4) & 0x0f;
11069-#line 757 "rx-decode.opc"
11070- int rdst AU = op[2] & 0x0f;
11071- if (trace)
11072- {
11073- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11074- "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
11075- op[0], op[1], op[2]);
11076- printf (" rsrc = 0x%x,", rsrc);
11077- printf (" rdst = 0x%x\n", rdst);
11078- }
11079- SYNTAX("rotr %1, %0");
11080-#line 757 "rx-decode.opc"
11081- ID(rotr); SR(rsrc); DR(rdst); F__SZC;
11082-
14352+ case 0x00:
14353+ goto op_semantics_128;
14354+ break;
14355+ default: UNSUPPORTED(); break;
1108314356 }
1108414357 break;
11085- }
11086- break;
11087- case 0x65:
11088- GETBYTE ();
11089- switch (op[2] & 0x00)
11090- {
11091- case 0x00:
14358+ case 0xc4:
14359+ GETBYTE ();
14360+ switch (op[3] & 0xff)
1109214361 {
11093- /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
11094-#line 760 "rx-decode.opc"
11095- int rsrc AU = (op[2] >> 4) & 0x0f;
11096-#line 760 "rx-decode.opc"
11097- int rdst AU = op[2] & 0x0f;
11098- if (trace)
11099- {
11100- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11101- "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
11102- op[0], op[1], op[2]);
11103- printf (" rsrc = 0x%x,", rsrc);
11104- printf (" rdst = 0x%x\n", rdst);
11105- }
11106- SYNTAX("revw %1, %0");
11107-#line 760 "rx-decode.opc"
11108- ID(revw); SR(rsrc); DR(rdst);
11109-
14362+ case 0x00:
14363+ goto op_semantics_128;
14364+ break;
14365+ default: UNSUPPORTED(); break;
1111014366 }
1111114367 break;
11112- }
11113- break;
11114- case 0x66:
11115- GETBYTE ();
11116- switch (op[2] & 0x00)
11117- {
11118- case 0x00:
14368+ case 0xc5:
14369+ GETBYTE ();
14370+ switch (op[3] & 0xff)
1111914371 {
11120- /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
11121-#line 751 "rx-decode.opc"
11122- int rsrc AU = (op[2] >> 4) & 0x0f;
11123-#line 751 "rx-decode.opc"
11124- int rdst AU = op[2] & 0x0f;
11125- if (trace)
11126- {
11127- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11128- "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
11129- op[0], op[1], op[2]);
11130- printf (" rsrc = 0x%x,", rsrc);
11131- printf (" rdst = 0x%x\n", rdst);
11132- }
11133- SYNTAX("rotl %1, %0");
11134-#line 751 "rx-decode.opc"
11135- ID(rotl); SR(rsrc); DR(rdst); F__SZC;
11136-
14372+ case 0x00:
14373+ goto op_semantics_128;
14374+ break;
14375+ default: UNSUPPORTED(); break;
1113714376 }
1113814377 break;
11139- }
11140- break;
11141- case 0x67:
11142- GETBYTE ();
11143- switch (op[2] & 0x00)
11144- {
11145- case 0x00:
14378+ case 0xc6:
14379+ GETBYTE ();
14380+ switch (op[3] & 0xff)
1114614381 {
11147- /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
11148-#line 763 "rx-decode.opc"
11149- int rsrc AU = (op[2] >> 4) & 0x0f;
11150-#line 763 "rx-decode.opc"
11151- int rdst AU = op[2] & 0x0f;
11152- if (trace)
11153- {
11154- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11155- "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
11156- op[0], op[1], op[2]);
11157- printf (" rsrc = 0x%x,", rsrc);
11158- printf (" rdst = 0x%x\n", rdst);
11159- }
11160- SYNTAX("revl %1, %0");
11161-#line 763 "rx-decode.opc"
11162- ID(revl); SR(rsrc); DR(rdst);
11163-
11164- /*----------------------------------------------------------------------*/
11165- /* BRANCH */
11166-
14382+ case 0x00:
14383+ goto op_semantics_128;
14384+ break;
14385+ default: UNSUPPORTED(); break;
1116714386 }
1116814387 break;
11169- }
11170- break;
11171- case 0x68:
11172- GETBYTE ();
11173- switch (op[2] & 0x00)
11174- {
11175- case 0x00:
11176- op_semantics_94:
14388+ case 0xc7:
14389+ GETBYTE ();
14390+ switch (op[3] & 0xff)
1117714391 {
11178- /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
11179-#line 1014 "rx-decode.opc"
11180- int c AU = op[1] & 0x01;
11181-#line 1014 "rx-decode.opc"
11182- int rsrc AU = (op[2] >> 4) & 0x0f;
11183-#line 1014 "rx-decode.opc"
11184- int rdst AU = op[2] & 0x0f;
11185- if (trace)
11186- {
11187- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11188- "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
11189- op[0], op[1], op[2]);
11190- printf (" c = 0x%x,", c);
11191- printf (" rsrc = 0x%x,", rsrc);
11192- printf (" rdst = 0x%x\n", rdst);
11193- }
11194- SYNTAX("mvtc %1, %0");
11195-#line 1014 "rx-decode.opc"
11196- ID(mov); SR(rsrc); DR(c*16+rdst + 16);
11197-
14392+ case 0x00:
14393+ goto op_semantics_128;
14394+ break;
14395+ default: UNSUPPORTED(); break;
1119814396 }
1119914397 break;
11200- }
11201- break;
11202- case 0x69:
11203- GETBYTE ();
11204- switch (op[2] & 0x00)
11205- {
11206- case 0x00:
11207- goto op_semantics_94;
14398+ case 0xc8:
14399+ GETBYTE ();
14400+ switch (op[3] & 0xff)
14401+ {
14402+ case 0x00:
14403+ goto op_semantics_128;
14404+ break;
14405+ default: UNSUPPORTED(); break;
14406+ }
1120814407 break;
11209- }
11210- break;
11211- case 0x6a:
11212- GETBYTE ();
11213- switch (op[2] & 0x00)
11214- {
11215- case 0x00:
11216- op_semantics_95:
14408+ case 0xc9:
14409+ GETBYTE ();
14410+ switch (op[3] & 0xff)
1121714411 {
11218- /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
11219-#line 1017 "rx-decode.opc"
11220- int s AU = op[1] & 0x01;
11221-#line 1017 "rx-decode.opc"
11222- int rsrc AU = (op[2] >> 4) & 0x0f;
11223-#line 1017 "rx-decode.opc"
11224- int rdst AU = op[2] & 0x0f;
11225- if (trace)
11226- {
11227- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11228- "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
11229- op[0], op[1], op[2]);
11230- printf (" s = 0x%x,", s);
11231- printf (" rsrc = 0x%x,", rsrc);
11232- printf (" rdst = 0x%x\n", rdst);
11233- }
11234- SYNTAX("mvfc %1, %0");
11235-#line 1017 "rx-decode.opc"
11236- ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11237-
11238- /*----------------------------------------------------------------------*/
11239- /* INTERRUPTS */
11240-
14412+ case 0x00:
14413+ goto op_semantics_128;
14414+ break;
14415+ default: UNSUPPORTED(); break;
1124114416 }
1124214417 break;
11243- }
11244- break;
11245- case 0x6b:
11246- GETBYTE ();
11247- switch (op[2] & 0x00)
11248- {
11249- case 0x00:
11250- goto op_semantics_95;
14418+ case 0xca:
14419+ GETBYTE ();
14420+ switch (op[3] & 0xff)
14421+ {
14422+ case 0x00:
14423+ goto op_semantics_128;
14424+ break;
14425+ default: UNSUPPORTED(); break;
14426+ }
1125114427 break;
11252- }
11253- break;
11254- case 0x6c:
11255- GETBYTE ();
11256- switch (op[2] & 0x00)
11257- {
11258- case 0x00:
11259- op_semantics_96:
14428+ case 0xcb:
14429+ GETBYTE ();
14430+ switch (op[3] & 0xff)
1126014431 {
11261- /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
11262-#line 754 "rx-decode.opc"
11263- int i AU = op[1] & 0x01;
11264-#line 754 "rx-decode.opc"
11265- int mmmm AU = (op[2] >> 4) & 0x0f;
11266-#line 754 "rx-decode.opc"
11267- int rdst AU = op[2] & 0x0f;
11268- if (trace)
11269- {
11270- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11271- "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
11272- op[0], op[1], op[2]);
11273- printf (" i = 0x%x,", i);
11274- printf (" mmmm = 0x%x,", mmmm);
11275- printf (" rdst = 0x%x\n", rdst);
11276- }
11277- SYNTAX("rotr #%1, %0");
11278-#line 754 "rx-decode.opc"
11279- ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11280-
14432+ case 0x00:
14433+ goto op_semantics_128;
14434+ break;
14435+ default: UNSUPPORTED(); break;
1128114436 }
1128214437 break;
11283- }
11284- break;
11285- case 0x6d:
11286- GETBYTE ();
11287- switch (op[2] & 0x00)
11288- {
11289- case 0x00:
11290- goto op_semantics_96;
14438+ case 0xcc:
14439+ GETBYTE ();
14440+ switch (op[3] & 0xff)
14441+ {
14442+ case 0x00:
14443+ goto op_semantics_128;
14444+ break;
14445+ default: UNSUPPORTED(); break;
14446+ }
1129114447 break;
11292- }
11293- break;
11294- case 0x6e:
11295- GETBYTE ();
11296- switch (op[2] & 0x00)
11297- {
11298- case 0x00:
11299- op_semantics_97:
14448+ case 0xcd:
14449+ GETBYTE ();
14450+ switch (op[3] & 0xff)
1130014451 {
11301- /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
11302-#line 748 "rx-decode.opc"
11303- int i AU = op[1] & 0x01;
11304-#line 748 "rx-decode.opc"
11305- int mmmm AU = (op[2] >> 4) & 0x0f;
11306-#line 748 "rx-decode.opc"
11307- int rdst AU = op[2] & 0x0f;
11308- if (trace)
11309- {
11310- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11311- "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
11312- op[0], op[1], op[2]);
11313- printf (" i = 0x%x,", i);
11314- printf (" mmmm = 0x%x,", mmmm);
11315- printf (" rdst = 0x%x\n", rdst);
11316- }
11317- SYNTAX("rotl #%1, %0");
11318-#line 748 "rx-decode.opc"
11319- ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11320-
14452+ case 0x00:
14453+ goto op_semantics_128;
14454+ break;
14455+ default: UNSUPPORTED(); break;
1132114456 }
1132214457 break;
11323- }
11324- break;
11325- case 0x6f:
11326- GETBYTE ();
11327- switch (op[2] & 0x00)
11328- {
11329- case 0x00:
11330- goto op_semantics_97;
14458+ case 0xce:
14459+ GETBYTE ();
14460+ switch (op[3] & 0xff)
14461+ {
14462+ case 0x00:
14463+ goto op_semantics_128;
14464+ break;
14465+ default: UNSUPPORTED(); break;
14466+ }
1133114467 break;
11332- }
11333- break;
11334- case 0x70:
11335- GETBYTE ();
11336- switch (op[2] & 0xf0)
11337- {
11338- case 0x20:
11339- op_semantics_98:
14468+ case 0xcf:
14469+ GETBYTE ();
14470+ switch (op[3] & 0xff)
1134014471 {
11341- /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
11342-#line 492 "rx-decode.opc"
11343- int im AU = (op[1] >> 2) & 0x03;
11344-#line 492 "rx-decode.opc"
11345- int rdst AU = op[2] & 0x0f;
11346- if (trace)
11347- {
11348- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11349- "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
11350- op[0], op[1], op[2]);
11351- printf (" im = 0x%x,", im);
11352- printf (" rdst = 0x%x\n", rdst);
11353- }
11354- SYNTAX("adc #%1, %0");
11355-#line 492 "rx-decode.opc"
11356- ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11357-
14472+ case 0x00:
14473+ goto op_semantics_128;
14474+ break;
14475+ default: UNSUPPORTED(); break;
1135814476 }
1135914477 break;
11360- case 0x40:
11361- op_semantics_99:
14478+ case 0xd0:
14479+ GETBYTE ();
14480+ switch (op[3] & 0xff)
1136214481 {
11363- /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
11364-#line 574 "rx-decode.opc"
11365- int im AU = (op[1] >> 2) & 0x03;
11366-#line 574 "rx-decode.opc"
11367- int rdst AU = op[2] & 0x0f;
11368- if (trace)
11369- {
11370- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11371- "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
11372- op[0], op[1], op[2]);
11373- printf (" im = 0x%x,", im);
11374- printf (" rdst = 0x%x\n", rdst);
11375- }
11376- SYNTAX("max #%1, %0");
11377-#line 574 "rx-decode.opc"
11378- int val = IMMex (im);
11379- if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11380- {
11381- ID (nop7);
11382- SYNTAX("nop\t; max\t#0x80000000, r0");
11383- }
11384- else
11385- {
11386- ID(max);
11387- }
11388- DR(rdst); SC(val);
14482+ case 0x00:
14483+ op_semantics_129:
14484+ {
14485+ /** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */
14486+#line 1155 "rx-decode.opc"
14487+ int rsrc AU = op[2] & 0x0f;
14488+ if (trace)
14489+ {
14490+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14491+ "/** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */",
14492+ op[0], op[1], op[2], op[3]);
14493+ printf (" rsrc = 0x%x\n", rsrc);
14494+ }
14495+ SYNTAX("rstr %1");
14496+#line 1155 "rx-decode.opc"
14497+ ID(rstr); SR(rsrc); F_____;
1138914498
14499+ }
14500+ break;
14501+ default: UNSUPPORTED(); break;
1139014502 }
1139114503 break;
11392- case 0x50:
11393- op_semantics_100:
14504+ case 0xd1:
14505+ GETBYTE ();
14506+ switch (op[3] & 0xff)
1139414507 {
11395- /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
11396-#line 604 "rx-decode.opc"
11397- int im AU = (op[1] >> 2) & 0x03;
11398-#line 604 "rx-decode.opc"
11399- int rdst AU = op[2] & 0x0f;
11400- if (trace)
11401- {
11402- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11403- "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
11404- op[0], op[1], op[2]);
11405- printf (" im = 0x%x,", im);
11406- printf (" rdst = 0x%x\n", rdst);
11407- }
11408- SYNTAX("min #%1, %0");
11409-#line 604 "rx-decode.opc"
11410- ID(min); DR(rdst); SC(IMMex(im));
11411-
14508+ case 0x00:
14509+ goto op_semantics_129;
14510+ break;
14511+ default: UNSUPPORTED(); break;
1141214512 }
1141314513 break;
11414- case 0x60:
11415- op_semantics_101:
14514+ case 0xd2:
14515+ GETBYTE ();
14516+ switch (op[3] & 0xff)
1141614517 {
11417- /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
11418-#line 662 "rx-decode.opc"
11419- int im AU = (op[1] >> 2) & 0x03;
11420-#line 662 "rx-decode.opc"
11421- int rdst AU = op[2] & 0x0f;
11422- if (trace)
11423- {
11424- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11425- "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
11426- op[0], op[1], op[2]);
11427- printf (" im = 0x%x,", im);
11428- printf (" rdst = 0x%x\n", rdst);
11429- }
11430- SYNTAX("emul #%1, %0");
11431-#line 662 "rx-decode.opc"
11432- ID(emul); DR(rdst); SC(IMMex(im));
11433-
14518+ case 0x00:
14519+ goto op_semantics_129;
14520+ break;
14521+ default: UNSUPPORTED(); break;
1143414522 }
1143514523 break;
11436- case 0x70:
11437- op_semantics_102:
14524+ case 0xd3:
14525+ GETBYTE ();
14526+ switch (op[3] & 0xff)
1143814527 {
11439- /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
11440-#line 674 "rx-decode.opc"
11441- int im AU = (op[1] >> 2) & 0x03;
11442-#line 674 "rx-decode.opc"
11443- int rdst AU = op[2] & 0x0f;
11444- if (trace)
11445- {
11446- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11447- "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
11448- op[0], op[1], op[2]);
11449- printf (" im = 0x%x,", im);
11450- printf (" rdst = 0x%x\n", rdst);
11451- }
11452- SYNTAX("emulu #%1, %0");
11453-#line 674 "rx-decode.opc"
11454- ID(emulu); DR(rdst); SC(IMMex(im));
11455-
14528+ case 0x00:
14529+ goto op_semantics_129;
14530+ break;
14531+ default: UNSUPPORTED(); break;
1145614532 }
1145714533 break;
11458- case 0x80:
11459- op_semantics_103:
14534+ case 0xd4:
14535+ GETBYTE ();
14536+ switch (op[3] & 0xff)
1146014537 {
11461- /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
11462-#line 686 "rx-decode.opc"
11463- int im AU = (op[1] >> 2) & 0x03;
11464-#line 686 "rx-decode.opc"
11465- int rdst AU = op[2] & 0x0f;
11466- if (trace)
11467- {
11468- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11469- "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
11470- op[0], op[1], op[2]);
11471- printf (" im = 0x%x,", im);
11472- printf (" rdst = 0x%x\n", rdst);
11473- }
11474- SYNTAX("div #%1, %0");
11475-#line 686 "rx-decode.opc"
11476- ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11477-
14538+ case 0x00:
14539+ goto op_semantics_129;
14540+ break;
14541+ default: UNSUPPORTED(); break;
1147814542 }
1147914543 break;
11480- case 0x90:
11481- op_semantics_104:
14544+ case 0xd5:
14545+ GETBYTE ();
14546+ switch (op[3] & 0xff)
1148214547 {
11483- /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
11484-#line 698 "rx-decode.opc"
11485- int im AU = (op[1] >> 2) & 0x03;
11486-#line 698 "rx-decode.opc"
11487- int rdst AU = op[2] & 0x0f;
11488- if (trace)
11489- {
11490- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11491- "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
11492- op[0], op[1], op[2]);
11493- printf (" im = 0x%x,", im);
11494- printf (" rdst = 0x%x\n", rdst);
11495- }
11496- SYNTAX("divu #%1, %0");
11497-#line 698 "rx-decode.opc"
11498- ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11499-
14548+ case 0x00:
14549+ goto op_semantics_129;
14550+ break;
14551+ default: UNSUPPORTED(); break;
1150014552 }
1150114553 break;
11502- case 0xc0:
11503- op_semantics_105:
14554+ case 0xd6:
14555+ GETBYTE ();
14556+ switch (op[3] & 0xff)
1150414557 {
11505- /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
11506-#line 471 "rx-decode.opc"
11507- int im AU = (op[1] >> 2) & 0x03;
11508-#line 471 "rx-decode.opc"
11509- int rdst AU = op[2] & 0x0f;
11510- if (trace)
11511- {
11512- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11513- "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
11514- op[0], op[1], op[2]);
11515- printf (" im = 0x%x,", im);
11516- printf (" rdst = 0x%x\n", rdst);
11517- }
11518- SYNTAX("tst #%1, %2");
11519-#line 471 "rx-decode.opc"
11520- ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11521-
14558+ case 0x00:
14559+ goto op_semantics_129;
14560+ break;
14561+ default: UNSUPPORTED(); break;
1152214562 }
1152314563 break;
11524- case 0xd0:
11525- op_semantics_106:
14564+ case 0xd7:
14565+ GETBYTE ();
14566+ switch (op[3] & 0xff)
1152614567 {
11527- /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
11528-#line 450 "rx-decode.opc"
11529- int im AU = (op[1] >> 2) & 0x03;
11530-#line 450 "rx-decode.opc"
11531- int rdst AU = op[2] & 0x0f;
11532- if (trace)
11533- {
11534- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11535- "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
11536- op[0], op[1], op[2]);
11537- printf (" im = 0x%x,", im);
11538- printf (" rdst = 0x%x\n", rdst);
11539- }
11540- SYNTAX("xor #%1, %0");
11541-#line 450 "rx-decode.opc"
11542- ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11543-
14568+ case 0x00:
14569+ goto op_semantics_129;
14570+ break;
14571+ default: UNSUPPORTED(); break;
1154414572 }
1154514573 break;
11546- case 0xe0:
11547- op_semantics_107:
14574+ case 0xd8:
14575+ GETBYTE ();
14576+ switch (op[3] & 0xff)
1154814577 {
11549- /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
11550-#line 396 "rx-decode.opc"
11551- int im AU = (op[1] >> 2) & 0x03;
11552-#line 396 "rx-decode.opc"
11553- int rdst AU = op[2] & 0x0f;
11554- if (trace)
11555- {
11556- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11557- "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
11558- op[0], op[1], op[2]);
11559- printf (" im = 0x%x,", im);
11560- printf (" rdst = 0x%x\n", rdst);
11561- }
11562- SYNTAX("stz #%1, %0");
11563-#line 396 "rx-decode.opc"
11564- ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11565-
14578+ case 0x00:
14579+ goto op_semantics_129;
14580+ break;
14581+ default: UNSUPPORTED(); break;
1156614582 }
1156714583 break;
11568- case 0xf0:
11569- op_semantics_108:
14584+ case 0xd9:
14585+ GETBYTE ();
14586+ switch (op[3] & 0xff)
1157014587 {
11571- /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
11572-#line 399 "rx-decode.opc"
11573- int im AU = (op[1] >> 2) & 0x03;
11574-#line 399 "rx-decode.opc"
11575- int rdst AU = op[2] & 0x0f;
11576- if (trace)
11577- {
11578- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11579- "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
11580- op[0], op[1], op[2]);
11581- printf (" im = 0x%x,", im);
11582- printf (" rdst = 0x%x\n", rdst);
11583- }
11584- SYNTAX("stnz #%1, %0");
11585-#line 399 "rx-decode.opc"
11586- ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11587-
11588- /*----------------------------------------------------------------------*/
11589- /* RTSD */
11590-
14588+ case 0x00:
14589+ goto op_semantics_129;
14590+ break;
14591+ default: UNSUPPORTED(); break;
1159114592 }
1159214593 break;
11593- default: UNSUPPORTED(); break;
11594- }
11595- break;
11596- case 0x72:
11597- GETBYTE ();
11598- switch (op[2] & 0xf0)
11599- {
11600- case 0x00:
14594+ case 0xda:
14595+ GETBYTE ();
14596+ switch (op[3] & 0xff)
1160114597 {
11602- /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
11603-#line 906 "rx-decode.opc"
11604- int rdst AU = op[2] & 0x0f;
11605- if (trace)
11606- {
11607- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11608- "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
11609- op[0], op[1], op[2]);
11610- printf (" rdst = 0x%x\n", rdst);
11611- }
11612- SYNTAX("fsub #%1, %0");
11613-#line 906 "rx-decode.opc"
11614- ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11615-
14598+ case 0x00:
14599+ goto op_semantics_129;
14600+ break;
14601+ default: UNSUPPORTED(); break;
14602+ }
14603+ break;
14604+ case 0xdb:
14605+ GETBYTE ();
14606+ switch (op[3] & 0xff)
14607+ {
14608+ case 0x00:
14609+ goto op_semantics_129;
14610+ break;
14611+ default: UNSUPPORTED(); break;
1161614612 }
1161714613 break;
11618- case 0x10:
14614+ case 0xdc:
14615+ GETBYTE ();
14616+ switch (op[3] & 0xff)
1161914617 {
11620- /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
11621-#line 900 "rx-decode.opc"
11622- int rdst AU = op[2] & 0x0f;
11623- if (trace)
11624- {
11625- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11626- "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
11627- op[0], op[1], op[2]);
11628- printf (" rdst = 0x%x\n", rdst);
11629- }
11630- SYNTAX("fcmp #%1, %0");
11631-#line 900 "rx-decode.opc"
11632- ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11633-
14618+ case 0x00:
14619+ goto op_semantics_129;
14620+ break;
14621+ default: UNSUPPORTED(); break;
1163414622 }
1163514623 break;
11636- case 0x20:
14624+ case 0xdd:
14625+ GETBYTE ();
14626+ switch (op[3] & 0xff)
1163714627 {
11638- /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
11639-#line 894 "rx-decode.opc"
11640- int rdst AU = op[2] & 0x0f;
11641- if (trace)
11642- {
11643- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11644- "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
11645- op[0], op[1], op[2]);
11646- printf (" rdst = 0x%x\n", rdst);
11647- }
11648- SYNTAX("fadd #%1, %0");
11649-#line 894 "rx-decode.opc"
11650- ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11651-
14628+ case 0x00:
14629+ goto op_semantics_129;
14630+ break;
14631+ default: UNSUPPORTED(); break;
1165214632 }
1165314633 break;
11654- case 0x30:
14634+ case 0xde:
14635+ GETBYTE ();
14636+ switch (op[3] & 0xff)
1165514637 {
11656- /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
11657-#line 915 "rx-decode.opc"
11658- int rdst AU = op[2] & 0x0f;
14638+ case 0x00:
14639+ goto op_semantics_129;
14640+ break;
14641+ default: UNSUPPORTED(); break;
14642+ }
14643+ break;
14644+ case 0xdf:
14645+ GETBYTE ();
14646+ switch (op[3] & 0xff)
14647+ {
14648+ case 0x00:
14649+ goto op_semantics_129;
14650+ break;
14651+ default: UNSUPPORTED(); break;
14652+ }
14653+ break;
14654+ case 0xe0:
14655+ {
14656+ /** 1111 1101 0111 0110 1110 0000 save #%1 */
1165914657 if (trace)
1166014658 {
1166114659 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11662- "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
14660+ "/** 1111 1101 0111 0110 1110 0000 save #%1 */",
1166314661 op[0], op[1], op[2]);
11664- printf (" rdst = 0x%x\n", rdst);
1166514662 }
11666- SYNTAX("fmul #%1, %0");
11667-#line 915 "rx-decode.opc"
11668- ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
14663+ SYNTAX("save #%1");
14664+#line 1164 "rx-decode.opc"
14665+ ID(save); SC(IMM(1)); F_____;
1166914666
1167014667 }
1167114668 break;
11672- case 0x40:
14669+ case 0xf0:
1167314670 {
11674- /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
11675-#line 921 "rx-decode.opc"
11676- int rdst AU = op[2] & 0x0f;
14671+ /** 1111 1101 0111 0110 1111 0000 rstr #%1 */
1167714672 if (trace)
1167814673 {
1167914674 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11680- "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
14675+ "/** 1111 1101 0111 0110 1111 0000 rstr #%1 */",
1168114676 op[0], op[1], op[2]);
11682- printf (" rdst = 0x%x\n", rdst);
1168314677 }
11684- SYNTAX("fdiv #%1, %0");
11685-#line 921 "rx-decode.opc"
11686- ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
14678+ SYNTAX("rstr #%1");
14679+#line 1158 "rx-decode.opc"
14680+ ID(rstr); SC(IMM(1)); F_____;
1168714681
1168814682 }
1168914683 break;
1169014684 default: UNSUPPORTED(); break;
1169114685 }
1169214686 break;
11693- case 0x73:
14687+ case 0x77:
1169414688 GETBYTE ();
11695- switch (op[2] & 0xe0)
14689+ switch (op[2] & 0xff)
1169614690 {
1169714691 case 0x00:
11698- op_semantics_109:
14692+ case 0x01:
14693+ case 0x02:
14694+ case 0x03:
14695+ case 0x04:
14696+ case 0x05:
14697+ case 0x06:
14698+ case 0x07:
14699+ case 0x08:
14700+ case 0x09:
14701+ case 0x0a:
14702+ case 0x0b:
14703+ case 0x0c:
14704+ case 0x0d:
14705+ case 0x0e:
14706+ case 0x0f:
14707+ case 0x10:
14708+ case 0x11:
14709+ case 0x12:
14710+ case 0x13:
14711+ case 0x14:
14712+ case 0x15:
14713+ case 0x16:
14714+ case 0x17:
14715+ case 0x18:
14716+ case 0x19:
14717+ case 0x1a:
14718+ case 0x1b:
14719+ case 0x1c:
14720+ case 0x1d:
14721+ case 0x1e:
14722+ case 0x1f:
14723+ goto op_semantics_124;
14724+ break;
14725+ case 0x80:
14726+ GETBYTE ();
14727+ switch (op[3] & 0x0f)
1169914728 {
11700- /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
11701-#line 1011 "rx-decode.opc"
11702- int im AU = (op[1] >> 2) & 0x03;
11703-#line 1011 "rx-decode.opc"
11704- int crdst AU = op[2] & 0x1f;
11705- if (trace)
11706- {
11707- printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11708- "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
11709- op[0], op[1], op[2]);
11710- printf (" im = 0x%x,", im);
11711- printf (" crdst = 0x%x\n", crdst);
11712- }
11713- SYNTAX("mvtc #%1, %0");
11714-#line 1011 "rx-decode.opc"
11715- ID(mov); SC(IMMex(im)); DR(crdst + 16);
14729+ case 0x00:
14730+ op_semantics_130:
14731+ {
14732+ /** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */
14733+#line 1170 "rx-decode.opc"
14734+ int rsrc AU = op[2] & 0x0f;
14735+#line 1170 "rx-decode.opc"
14736+ int rdst AU = (op[3] >> 4) & 0x0f;
14737+ if (trace)
14738+ {
14739+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14740+ "/** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */",
14741+ op[0], op[1], op[2], op[3]);
14742+ printf (" rsrc = 0x%x,", rsrc);
14743+ printf (" rdst = 0x%x\n", rdst);
14744+ }
14745+ SYNTAX("dmov.l %1, %0");
14746+#line 1170 "rx-decode.opc"
14747+ ID(dmov); DDRL(rdst); SR(rsrc); F_____;
14748+
14749+ }
14750+ break;
14751+ case 0x02:
14752+ case 0x03:
14753+ op_semantics_131:
14754+ {
14755+ /** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */
14756+#line 1167 "rx-decode.opc"
14757+ int rsrc AU = op[2] & 0x0f;
14758+#line 1167 "rx-decode.opc"
14759+ int rdst AU = (op[3] >> 4) & 0x0f;
14760+#line 1167 "rx-decode.opc"
14761+ int s AU = op[3] & 0x01;
14762+ if (trace)
14763+ {
14764+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14765+ "/** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */",
14766+ op[0], op[1], op[2], op[3]);
14767+ printf (" rsrc = 0x%x,", rsrc);
14768+ printf (" rdst = 0x%x,", rdst);
14769+ printf (" s = 0x%x\n", s);
14770+ }
14771+ SYNTAX("dmov%s %1, %0");
14772+#line 1167 "rx-decode.opc"
14773+ ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____;
14774+
14775+ }
14776+ break;
14777+ case 0x04:
14778+ op_semantics_132:
14779+ {
14780+ /** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */
14781+#line 1232 "rx-decode.opc"
14782+ int rdst AU = op[2] & 0x0f;
14783+#line 1232 "rx-decode.opc"
14784+ int rsrc AU = (op[3] >> 4) & 0x0f;
14785+ if (trace)
14786+ {
14787+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14788+ "/** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */",
14789+ op[0], op[1], op[2], op[3]);
14790+ printf (" rdst = 0x%x,", rdst);
14791+ printf (" rsrc = 0x%x\n", rsrc);
14792+ }
14793+ SYNTAX("mvtdc %1, %0");
14794+#line 1232 "rx-decode.opc"
14795+ ID(mvtdc); DCR(rdst); SR(rsrc); F_____;
14796+
14797+ }
14798+ break;
14799+ case 0x09:
14800+ op_semantics_133:
14801+ {
14802+ /** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */
14803+#line 1274 "rx-decode.opc"
14804+ int rsrc AU = op[2] & 0x0f;
14805+#line 1274 "rx-decode.opc"
14806+ int rdst AU = (op[3] >> 4) & 0x0f;
14807+ if (trace)
14808+ {
14809+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14810+ "/** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */",
14811+ op[0], op[1], op[2], op[3]);
14812+ printf (" rsrc = 0x%x,", rsrc);
14813+ printf (" rdst = 0x%x\n", rdst);
14814+ }
14815+ SYNTAX("itod %1, %0");
14816+#line 1274 "rx-decode.opc"
14817+ ID(itod); DDR(rdst); SR(rsrc); F_____;
14818+
14819+ }
14820+ break;
14821+ case 0x0a:
14822+ op_semantics_134:
14823+ {
14824+ /** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */
14825+#line 1271 "rx-decode.opc"
14826+ int rsrc AU = op[2] & 0x0f;
14827+#line 1271 "rx-decode.opc"
14828+ int rdst AU = (op[3] >> 4) & 0x0f;
14829+ if (trace)
14830+ {
14831+ printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n",
14832+ "/** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */",
14833+

Part of diff was cut off due to size limit. Use your local client to view the full diff.