Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(54)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: opcodes/rl78-decode.c

Issue 11969036: Merge GDB 7.5.1 (Closed) Base URL: http://git.chromium.org/native_client/nacl-gdb.git@master
Patch Set: Created 7 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « opcodes/ppc-opc.c ('k') | opcodes/rl78-decode.opc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 #line 1 "rl78-decode.opc" 1 #line 1 "rl78-decode.opc"
2 /* -*- c -*- */ 2 /* -*- c -*- */
3 #include "sysdep.h"
3 #include <stdio.h> 4 #include <stdio.h>
4 #include <stdlib.h> 5 #include <stdlib.h>
5 #include <string.h> 6 #include <string.h>
6
7 #include "config.h"
8 #include "ansidecl.h" 7 #include "ansidecl.h"
9 #include "opcode/rl78.h" 8 #include "opcode/rl78.h"
10 9
11 static int trace = 0; 10 static int trace = 0;
12 11
13 typedef struct 12 typedef struct
14 { 13 {
15 RL78_Opcode_Decoded * rl78; 14 RL78_Opcode_Decoded * rl78;
16 int (* getbyte)(void *); 15 int (* getbyte)(void *);
17 void * ptr; 16 void * ptr;
(...skipping 238 matching lines...) Expand 10 before | Expand all | Expand 10 after
256 case 0x08: 255 case 0x08:
257 { 256 {
258 /** 0000 1000 xch a, x */ 257 /** 0000 1000 xch a, x */
259 if (trace) 258 if (trace)
260 { 259 {
261 printf ("\033[33m%s\033[0m %02x\n", 260 printf ("\033[33m%s\033[0m %02x\n",
262 "/** 0000 1000 xch a, x */", 261 "/** 0000 1000 xch a, x */",
263 op[0]); 262 op[0]);
264 } 263 }
265 SYNTAX("xch a, x"); 264 SYNTAX("xch a, x");
266 #line 1205 "rl78-decode.opc" 265 #line 1210 "rl78-decode.opc"
267 ID(xch); DR(A); SR(X); 266 ID(xch); DR(A); SR(X);
268 267
269 /*---------------------------------------------------------------------- */ 268 /*---------------------------------------------------------------------- */
270 269
271 } 270 }
272 break; 271 break;
273 case 0x09: 272 case 0x09:
274 { 273 {
275 /** 0000 1001 mov %0, %e1%1 */ 274 /** 0000 1001 mov %0, %e1%1 */
276 if (trace) 275 if (trace)
(...skipping 302 matching lines...) Expand 10 before | Expand all | Expand 10 after
579 case 0x20: 578 case 0x20:
580 { 579 {
581 /** 0010 0000 subw %0, #%1 */ 580 /** 0010 0000 subw %0, #%1 */
582 if (trace) 581 if (trace)
583 { 582 {
584 printf ("\033[33m%s\033[0m %02x\n", 583 printf ("\033[33m%s\033[0m %02x\n",
585 "/** 0010 0000 subw %0, #%1 */", 584 "/** 0010 0000 subw %0, #%1 */",
586 op[0]); 585 op[0]);
587 } 586 }
588 SYNTAX("subw %0, #%1"); 587 SYNTAX("subw %0, #%1");
589 #line 1169 "rl78-decode.opc" 588 #line 1174 "rl78-decode.opc"
590 ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac; 589 ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
591 590
592 /*---------------------------------------------------------------------- */ 591 /*---------------------------------------------------------------------- */
593 592
594 } 593 }
595 break; 594 break;
596 case 0x21: 595 case 0x21:
597 case 0x23: 596 case 0x23:
598 case 0x25: 597 case 0x25:
599 case 0x27: 598 case 0x27:
600 { 599 {
601 /** 0010 0rw1 subw %0, %1 */ 600 /** 0010 0rw1 subw %0, %1 */
602 #line 1163 "rl78-decode.opc" 601 #line 1168 "rl78-decode.opc"
603 int rw AU = (op[0] >> 1) & 0x03; 602 int rw AU = (op[0] >> 1) & 0x03;
604 if (trace) 603 if (trace)
605 { 604 {
606 printf ("\033[33m%s\033[0m %02x\n", 605 printf ("\033[33m%s\033[0m %02x\n",
607 "/** 0010 0rw1 subw %0, %1 */", 606 "/** 0010 0rw1 subw %0, %1 */",
608 op[0]); 607 op[0]);
609 printf (" rw = 0x%x\n", rw); 608 printf (" rw = 0x%x\n", rw);
610 } 609 }
611 SYNTAX("subw %0, %1"); 610 SYNTAX("subw %0, %1");
612 #line 1163 "rl78-decode.opc" 611 #line 1168 "rl78-decode.opc"
613 ID(sub); W(); DR(AX); SRW(rw); Fzac; 612 ID(sub); W(); DR(AX); SRW(rw); Fzac;
614 613
615 } 614 }
616 break; 615 break;
617 case 0x22: 616 case 0x22:
618 { 617 {
619 /** 0010 0010 subw %0, %e1%!1 */ 618 /** 0010 0010 subw %0, %e1%!1 */
620 if (trace) 619 if (trace)
621 { 620 {
622 printf ("\033[33m%s\033[0m %02x\n", 621 printf ("\033[33m%s\033[0m %02x\n",
623 "/** 0010 0010 subw %0, %e1%!1 */", 622 "/** 0010 0010 subw %0, %e1%!1 */",
624 op[0]); 623 op[0]);
625 } 624 }
626 SYNTAX("subw %0, %e1%!1"); 625 SYNTAX("subw %0, %e1%!1");
627 #line 1154 "rl78-decode.opc" 626 #line 1159 "rl78-decode.opc"
628 ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac; 627 ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
629 628
630 } 629 }
631 break; 630 break;
632 case 0x24: 631 case 0x24:
633 { 632 {
634 /** 0010 0100 subw %0, #%1 */ 633 /** 0010 0100 subw %0, #%1 */
635 if (trace) 634 if (trace)
636 { 635 {
637 printf ("\033[33m%s\033[0m %02x\n", 636 printf ("\033[33m%s\033[0m %02x\n",
638 "/** 0010 0100 subw %0, #%1 */", 637 "/** 0010 0100 subw %0, #%1 */",
639 op[0]); 638 op[0]);
640 } 639 }
641 SYNTAX("subw %0, #%1"); 640 SYNTAX("subw %0, #%1");
642 #line 1160 "rl78-decode.opc" 641 #line 1165 "rl78-decode.opc"
643 ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac; 642 ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
644 643
645 } 644 }
646 break; 645 break;
647 case 0x26: 646 case 0x26:
648 { 647 {
649 /** 0010 0110 subw %0, %1 */ 648 /** 0010 0110 subw %0, %1 */
650 if (trace) 649 if (trace)
651 { 650 {
652 printf ("\033[33m%s\033[0m %02x\n", 651 printf ("\033[33m%s\033[0m %02x\n",
653 "/** 0010 0110 subw %0, %1 */", 652 "/** 0010 0110 subw %0, %1 */",
654 op[0]); 653 op[0]);
655 } 654 }
656 SYNTAX("subw %0, %1"); 655 SYNTAX("subw %0, %1");
657 #line 1166 "rl78-decode.opc" 656 #line 1171 "rl78-decode.opc"
658 ID(sub); W(); DR(AX); SM(None, SADDR); Fzac; 657 ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
659 658
660 } 659 }
661 break; 660 break;
662 case 0x28: 661 case 0x28:
663 { 662 {
664 /** 0010 1000 mov %e0%0, %1 */ 663 /** 0010 1000 mov %e0%0, %1 */
665 if (trace) 664 if (trace)
666 { 665 {
667 printf ("\033[33m%s\033[0m %02x\n", 666 printf ("\033[33m%s\033[0m %02x\n",
(...skipping 24 matching lines...) Expand all
692 case 0x2a: 691 case 0x2a:
693 { 692 {
694 /** 0010 1010 sub %0, #%1 */ 693 /** 0010 1010 sub %0, #%1 */
695 if (trace) 694 if (trace)
696 { 695 {
697 printf ("\033[33m%s\033[0m %02x\n", 696 printf ("\033[33m%s\033[0m %02x\n",
698 "/** 0010 1010 sub %0, #%1 */", 697 "/** 0010 1010 sub %0, #%1 */",
699 op[0]); 698 op[0]);
700 } 699 }
701 SYNTAX("sub %0, #%1"); 700 SYNTAX("sub %0, #%1");
702 #line 1117 "rl78-decode.opc" 701 #line 1122 "rl78-decode.opc"
703 ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac; 702 ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
704 703
705 /*---------------------------------------------------------------------- */ 704 /*---------------------------------------------------------------------- */
706 705
707 } 706 }
708 break; 707 break;
709 case 0x2b: 708 case 0x2b:
710 { 709 {
711 /** 0010 1011 sub %0, %1 */ 710 /** 0010 1011 sub %0, %1 */
712 if (trace) 711 if (trace)
713 { 712 {
714 printf ("\033[33m%s\033[0m %02x\n", 713 printf ("\033[33m%s\033[0m %02x\n",
715 "/** 0010 1011 sub %0, %1 */", 714 "/** 0010 1011 sub %0, %1 */",
716 op[0]); 715 op[0]);
717 } 716 }
718 SYNTAX("sub %0, %1"); 717 SYNTAX("sub %0, %1");
719 #line 1111 "rl78-decode.opc" 718 #line 1116 "rl78-decode.opc"
720 ID(sub); DR(A); SM(None, SADDR); Fzac; 719 ID(sub); DR(A); SM(None, SADDR); Fzac;
721 720
722 } 721 }
723 break; 722 break;
724 case 0x2c: 723 case 0x2c:
725 { 724 {
726 /** 0010 1100 sub %0, #%1 */ 725 /** 0010 1100 sub %0, #%1 */
727 if (trace) 726 if (trace)
728 { 727 {
729 printf ("\033[33m%s\033[0m %02x\n", 728 printf ("\033[33m%s\033[0m %02x\n",
730 "/** 0010 1100 sub %0, #%1 */", 729 "/** 0010 1100 sub %0, #%1 */",
731 op[0]); 730 op[0]);
732 } 731 }
733 SYNTAX("sub %0, #%1"); 732 SYNTAX("sub %0, #%1");
734 #line 1105 "rl78-decode.opc" 733 #line 1110 "rl78-decode.opc"
735 ID(sub); DR(A); SC(IMMU(1)); Fzac; 734 ID(sub); DR(A); SC(IMMU(1)); Fzac;
736 735
737 } 736 }
738 break; 737 break;
739 case 0x2d: 738 case 0x2d:
740 { 739 {
741 /** 0010 1101 sub %0, %e1%1 */ 740 /** 0010 1101 sub %0, %e1%1 */
742 if (trace) 741 if (trace)
743 { 742 {
744 printf ("\033[33m%s\033[0m %02x\n", 743 printf ("\033[33m%s\033[0m %02x\n",
745 "/** 0010 1101 sub %0, %e1%1 */", 744 "/** 0010 1101 sub %0, %e1%1 */",
746 op[0]); 745 op[0]);
747 } 746 }
748 SYNTAX("sub %0, %e1%1"); 747 SYNTAX("sub %0, %e1%1");
749 #line 1093 "rl78-decode.opc" 748 #line 1098 "rl78-decode.opc"
750 ID(sub); DR(A); SM(HL, 0); Fzac; 749 ID(sub); DR(A); SM(HL, 0); Fzac;
751 750
752 } 751 }
753 break; 752 break;
754 case 0x2e: 753 case 0x2e:
755 { 754 {
756 /** 0010 1110 sub %0, %e1%1 */ 755 /** 0010 1110 sub %0, %e1%1 */
757 if (trace) 756 if (trace)
758 { 757 {
759 printf ("\033[33m%s\033[0m %02x\n", 758 printf ("\033[33m%s\033[0m %02x\n",
760 "/** 0010 1110 sub %0, %e1%1 */", 759 "/** 0010 1110 sub %0, %e1%1 */",
761 op[0]); 760 op[0]);
762 } 761 }
763 SYNTAX("sub %0, %e1%1"); 762 SYNTAX("sub %0, %e1%1");
764 #line 1099 "rl78-decode.opc" 763 #line 1104 "rl78-decode.opc"
765 ID(sub); DR(A); SM(HL, IMMU(1)); Fzac; 764 ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
766 765
767 } 766 }
768 break; 767 break;
769 case 0x2f: 768 case 0x2f:
770 { 769 {
771 /** 0010 1111 sub %0, %e1%!1 */ 770 /** 0010 1111 sub %0, %e1%!1 */
772 if (trace) 771 if (trace)
773 { 772 {
774 printf ("\033[33m%s\033[0m %02x\n", 773 printf ("\033[33m%s\033[0m %02x\n",
775 "/** 0010 1111 sub %0, %e1%!1 */", 774 "/** 0010 1111 sub %0, %e1%!1 */",
776 op[0]); 775 op[0]);
777 } 776 }
778 SYNTAX("sub %0, %e1%!1"); 777 SYNTAX("sub %0, %e1%!1");
779 #line 1090 "rl78-decode.opc" 778 #line 1095 "rl78-decode.opc"
780 ID(sub); DR(A); SM(None, IMMU(2)); Fzac; 779 ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
781 780
782 } 781 }
783 break; 782 break;
784 case 0x30: 783 case 0x30:
785 case 0x32: 784 case 0x32:
786 case 0x34: 785 case 0x34:
787 case 0x36: 786 case 0x36:
788 { 787 {
789 /** 0011 0rg0 movw %0, #%1 */ 788 /** 0011 0rg0 movw %0, #%1 */
(...skipping 126 matching lines...) Expand 10 before | Expand all | Expand 10 after
916 } 915 }
917 SYNTAX("bf %1, $%a0"); 916 SYNTAX("bf %1, $%a0");
918 #line 336 "rl78-decode.opc" 917 #line 336 "rl78-decode.opc"
919 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F); 918 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F);
920 919
921 } 920 }
922 break; 921 break;
923 case 0x07: 922 case 0x07:
924 { 923 {
925 /** 0011 0001 0cnt 0111 shl %0, %1 */ 924 /** 0011 0001 0cnt 0111 shl %0, %1 */
926 #line 1046 "rl78-decode.opc" 925 #line 1051 "rl78-decode.opc"
927 int cnt AU = (op[1] >> 4) & 0x07; 926 int cnt AU = (op[1] >> 4) & 0x07;
928 if (trace) 927 if (trace)
929 { 928 {
930 printf ("\033[33m%s\033[0m %02x %02x\n", 929 printf ("\033[33m%s\033[0m %02x %02x\n",
931 "/** 0011 0001 0cnt 0111 shl %0, %1 */", 930 "/** 0011 0001 0cnt 0111 shl %0, %1 */",
932 op[0], op[1]); 931 op[0], op[1]);
933 printf (" cnt = 0x%x\n", cnt); 932 printf (" cnt = 0x%x\n", cnt);
934 } 933 }
935 SYNTAX("shl %0, %1"); 934 SYNTAX("shl %0, %1");
936 #line 1046 "rl78-decode.opc" 935 #line 1051 "rl78-decode.opc"
937 ID(shl); DR(C); SC(cnt); 936 ID(shl); DR(C); SC(cnt);
938 937
939 } 938 }
940 break; 939 break;
941 case 0x08: 940 case 0x08:
942 { 941 {
943 /** 0011 0001 0cnt 1000 shl %0, %1 */ 942 /** 0011 0001 0cnt 1000 shl %0, %1 */
944 #line 1043 "rl78-decode.opc" 943 #line 1048 "rl78-decode.opc"
945 int cnt AU = (op[1] >> 4) & 0x07; 944 int cnt AU = (op[1] >> 4) & 0x07;
946 if (trace) 945 if (trace)
947 { 946 {
948 printf ("\033[33m%s\033[0m %02x %02x\n", 947 printf ("\033[33m%s\033[0m %02x %02x\n",
949 "/** 0011 0001 0cnt 1000 shl %0, %1 */", 948 "/** 0011 0001 0cnt 1000 shl %0, %1 */",
950 op[0], op[1]); 949 op[0], op[1]);
951 printf (" cnt = 0x%x\n", cnt); 950 printf (" cnt = 0x%x\n", cnt);
952 } 951 }
953 SYNTAX("shl %0, %1"); 952 SYNTAX("shl %0, %1");
954 #line 1043 "rl78-decode.opc" 953 #line 1048 "rl78-decode.opc"
955 ID(shl); DR(B); SC(cnt); 954 ID(shl); DR(B); SC(cnt);
956 955
957 } 956 }
958 break; 957 break;
959 case 0x09: 958 case 0x09:
960 { 959 {
961 /** 0011 0001 0cnt 1001 shl %0, %1 */ 960 /** 0011 0001 0cnt 1001 shl %0, %1 */
962 #line 1040 "rl78-decode.opc" 961 #line 1045 "rl78-decode.opc"
963 int cnt AU = (op[1] >> 4) & 0x07; 962 int cnt AU = (op[1] >> 4) & 0x07;
964 if (trace) 963 if (trace)
965 { 964 {
966 printf ("\033[33m%s\033[0m %02x %02x\n", 965 printf ("\033[33m%s\033[0m %02x %02x\n",
967 "/** 0011 0001 0cnt 1001 shl %0, %1 */", 966 "/** 0011 0001 0cnt 1001 shl %0, %1 */",
968 op[0], op[1]); 967 op[0], op[1]);
969 printf (" cnt = 0x%x\n", cnt); 968 printf (" cnt = 0x%x\n", cnt);
970 } 969 }
971 SYNTAX("shl %0, %1"); 970 SYNTAX("shl %0, %1");
972 #line 1040 "rl78-decode.opc" 971 #line 1045 "rl78-decode.opc"
973 ID(shl); DR(A); SC(cnt); 972 ID(shl); DR(A); SC(cnt);
974 973
975 } 974 }
976 break; 975 break;
977 case 0x0a: 976 case 0x0a:
978 { 977 {
979 /** 0011 0001 0cnt 1010 shr %0, %1 */ 978 /** 0011 0001 0cnt 1010 shr %0, %1 */
980 #line 1057 "rl78-decode.opc" 979 #line 1062 "rl78-decode.opc"
981 int cnt AU = (op[1] >> 4) & 0x07; 980 int cnt AU = (op[1] >> 4) & 0x07;
982 if (trace) 981 if (trace)
983 { 982 {
984 printf ("\033[33m%s\033[0m %02x %02x\n", 983 printf ("\033[33m%s\033[0m %02x %02x\n",
985 "/** 0011 0001 0cnt 1010 shr %0, %1 */", 984 "/** 0011 0001 0cnt 1010 shr %0, %1 */",
986 op[0], op[1]); 985 op[0], op[1]);
987 printf (" cnt = 0x%x\n", cnt); 986 printf (" cnt = 0x%x\n", cnt);
988 } 987 }
989 SYNTAX("shr %0, %1"); 988 SYNTAX("shr %0, %1");
990 #line 1057 "rl78-decode.opc" 989 #line 1062 "rl78-decode.opc"
991 ID(shr); DR(A); SC(cnt); 990 ID(shr); DR(A); SC(cnt);
992 991
993 } 992 }
994 break; 993 break;
995 case 0x0b: 994 case 0x0b:
996 { 995 {
997 /** 0011 0001 0cnt 1011 sar %0, %1 */ 996 /** 0011 0001 0cnt 1011 sar %0, %1 */
998 #line 1004 "rl78-decode.opc" 997 #line 1009 "rl78-decode.opc"
999 int cnt AU = (op[1] >> 4) & 0x07; 998 int cnt AU = (op[1] >> 4) & 0x07;
1000 if (trace) 999 if (trace)
1001 { 1000 {
1002 printf ("\033[33m%s\033[0m %02x %02x\n", 1001 printf ("\033[33m%s\033[0m %02x %02x\n",
1003 "/** 0011 0001 0cnt 1011 sar %0, %1 */", 1002 "/** 0011 0001 0cnt 1011 sar %0, %1 */",
1004 op[0], op[1]); 1003 op[0], op[1]);
1005 printf (" cnt = 0x%x\n", cnt); 1004 printf (" cnt = 0x%x\n", cnt);
1006 } 1005 }
1007 SYNTAX("sar %0, %1"); 1006 SYNTAX("sar %0, %1");
1008 #line 1004 "rl78-decode.opc" 1007 #line 1009 "rl78-decode.opc"
1009 ID(sar); DR(A); SC(cnt); 1008 ID(sar); DR(A); SC(cnt);
1010 1009
1011 } 1010 }
1012 break; 1011 break;
1013 case 0x0c: 1012 case 0x0c:
1014 case 0x8c: 1013 case 0x8c:
1015 { 1014 {
1016 /** 0011 0001 wcnt 1100 shlw %0, %1 */ 1015 /** 0011 0001 wcnt 1100 shlw %0, %1 */
1017 #line 1052 "rl78-decode.opc" 1016 #line 1057 "rl78-decode.opc"
1018 int wcnt AU = (op[1] >> 4) & 0x0f; 1017 int wcnt AU = (op[1] >> 4) & 0x0f;
1019 if (trace) 1018 if (trace)
1020 { 1019 {
1021 printf ("\033[33m%s\033[0m %02x %02x\n", 1020 printf ("\033[33m%s\033[0m %02x %02x\n",
1022 "/** 0011 0001 wcnt 1100 shlw %0, %1 */", 1021 "/** 0011 0001 wcnt 1100 shlw %0, %1 */",
1023 op[0], op[1]); 1022 op[0], op[1]);
1024 printf (" wcnt = 0x%x\n", wcnt); 1023 printf (" wcnt = 0x%x\n", wcnt);
1025 } 1024 }
1026 SYNTAX("shlw %0, %1"); 1025 SYNTAX("shlw %0, %1");
1027 #line 1052 "rl78-decode.opc" 1026 #line 1057 "rl78-decode.opc"
1028 ID(shl); W(); DR(BC); SC(wcnt); 1027 ID(shl); W(); DR(BC); SC(wcnt);
1029 1028
1030 /*---------------------------------------------------------------- ------*/ 1029 /*---------------------------------------------------------------- ------*/
1031 1030
1032 } 1031 }
1033 break; 1032 break;
1034 case 0x0d: 1033 case 0x0d:
1035 case 0x8d: 1034 case 0x8d:
1036 { 1035 {
1037 /** 0011 0001 wcnt 1101 shlw %0, %1 */ 1036 /** 0011 0001 wcnt 1101 shlw %0, %1 */
1038 #line 1049 "rl78-decode.opc" 1037 #line 1054 "rl78-decode.opc"
1039 int wcnt AU = (op[1] >> 4) & 0x0f; 1038 int wcnt AU = (op[1] >> 4) & 0x0f;
1040 if (trace) 1039 if (trace)
1041 { 1040 {
1042 printf ("\033[33m%s\033[0m %02x %02x\n", 1041 printf ("\033[33m%s\033[0m %02x %02x\n",
1043 "/** 0011 0001 wcnt 1101 shlw %0, %1 */", 1042 "/** 0011 0001 wcnt 1101 shlw %0, %1 */",
1044 op[0], op[1]); 1043 op[0], op[1]);
1045 printf (" wcnt = 0x%x\n", wcnt); 1044 printf (" wcnt = 0x%x\n", wcnt);
1046 } 1045 }
1047 SYNTAX("shlw %0, %1"); 1046 SYNTAX("shlw %0, %1");
1048 #line 1049 "rl78-decode.opc" 1047 #line 1054 "rl78-decode.opc"
1049 ID(shl); W(); DR(AX); SC(wcnt); 1048 ID(shl); W(); DR(AX); SC(wcnt);
1050 1049
1051 } 1050 }
1052 break; 1051 break;
1053 case 0x0e: 1052 case 0x0e:
1054 case 0x8e: 1053 case 0x8e:
1055 { 1054 {
1056 /** 0011 0001 wcnt 1110 shrw %0, %1 */ 1055 /** 0011 0001 wcnt 1110 shrw %0, %1 */
1057 #line 1060 "rl78-decode.opc" 1056 #line 1065 "rl78-decode.opc"
1058 int wcnt AU = (op[1] >> 4) & 0x0f; 1057 int wcnt AU = (op[1] >> 4) & 0x0f;
1059 if (trace) 1058 if (trace)
1060 { 1059 {
1061 printf ("\033[33m%s\033[0m %02x %02x\n", 1060 printf ("\033[33m%s\033[0m %02x %02x\n",
1062 "/** 0011 0001 wcnt 1110 shrw %0, %1 */", 1061 "/** 0011 0001 wcnt 1110 shrw %0, %1 */",
1063 op[0], op[1]); 1062 op[0], op[1]);
1064 printf (" wcnt = 0x%x\n", wcnt); 1063 printf (" wcnt = 0x%x\n", wcnt);
1065 } 1064 }
1066 SYNTAX("shrw %0, %1"); 1065 SYNTAX("shrw %0, %1");
1067 #line 1060 "rl78-decode.opc" 1066 #line 1065 "rl78-decode.opc"
1068 ID(shr); W(); DR(AX); SC(wcnt); 1067 ID(shr); W(); DR(AX); SC(wcnt);
1069 1068
1070 /*---------------------------------------------------------------- ------*/ 1069 /*---------------------------------------------------------------- ------*/
1071 1070
1072 } 1071 }
1073 break; 1072 break;
1074 case 0x0f: 1073 case 0x0f:
1075 case 0x8f: 1074 case 0x8f:
1076 { 1075 {
1077 /** 0011 0001 wcnt 1111 sarw %0, %1 */ 1076 /** 0011 0001 wcnt 1111 sarw %0, %1 */
1078 #line 1007 "rl78-decode.opc" 1077 #line 1012 "rl78-decode.opc"
1079 int wcnt AU = (op[1] >> 4) & 0x0f; 1078 int wcnt AU = (op[1] >> 4) & 0x0f;
1080 if (trace) 1079 if (trace)
1081 { 1080 {
1082 printf ("\033[33m%s\033[0m %02x %02x\n", 1081 printf ("\033[33m%s\033[0m %02x %02x\n",
1083 "/** 0011 0001 wcnt 1111 sarw %0, %1 */", 1082 "/** 0011 0001 wcnt 1111 sarw %0, %1 */",
1084 op[0], op[1]); 1083 op[0], op[1]);
1085 printf (" wcnt = 0x%x\n", wcnt); 1084 printf (" wcnt = 0x%x\n", wcnt);
1086 } 1085 }
1087 SYNTAX("sarw %0, %1"); 1086 SYNTAX("sarw %0, %1");
1088 #line 1007 "rl78-decode.opc" 1087 #line 1012 "rl78-decode.opc"
1089 ID(sar); W(); DR(AX); SC(wcnt); 1088 ID(sar); W(); DR(AX); SC(wcnt);
1090 1089
1091 /*---------------------------------------------------------------- ------*/ 1090 /*---------------------------------------------------------------- ------*/
1092 1091
1093 } 1092 }
1094 break; 1093 break;
1095 case 0x80: 1094 case 0x80:
1096 { 1095 {
1097 /** 0011 0001 1bit 0000 btclr %s1, $%a0 */ 1096 /** 0011 0001 1bit 0000 btclr %s1, $%a0 */
1098 #line 392 "rl78-decode.opc" 1097 #line 392 "rl78-decode.opc"
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after
1201 } 1200 }
1202 break; 1201 break;
1203 default: UNSUPPORTED(); break; 1202 default: UNSUPPORTED(); break;
1204 } 1203 }
1205 break; 1204 break;
1206 case 0x33: 1205 case 0x33:
1207 case 0x35: 1206 case 0x35:
1208 case 0x37: 1207 case 0x37:
1209 { 1208 {
1210 /** 0011 0ra1 xchw %0, %1 */ 1209 /** 0011 0ra1 xchw %0, %1 */
1211 #line 1210 "rl78-decode.opc" 1210 #line 1215 "rl78-decode.opc"
1212 int ra AU = (op[0] >> 1) & 0x03; 1211 int ra AU = (op[0] >> 1) & 0x03;
1213 if (trace) 1212 if (trace)
1214 { 1213 {
1215 printf ("\033[33m%s\033[0m %02x\n", 1214 printf ("\033[33m%s\033[0m %02x\n",
1216 "/** 0011 0ra1 xchw %0, %1 */", 1215 "/** 0011 0ra1 xchw %0, %1 */",
1217 op[0]); 1216 op[0]);
1218 printf (" ra = 0x%x\n", ra); 1217 printf (" ra = 0x%x\n", ra);
1219 } 1218 }
1220 SYNTAX("xchw %0, %1"); 1219 SYNTAX("xchw %0, %1");
1221 #line 1210 "rl78-decode.opc" 1220 #line 1215 "rl78-decode.opc"
1222 ID(xch); W(); DR(AX); SRW(ra); 1221 ID(xch); W(); DR(AX); SRW(ra);
1223 1222
1224 /*---------------------------------------------------------------------- */ 1223 /*---------------------------------------------------------------------- */
1225 1224
1226 } 1225 }
1227 break; 1226 break;
1228 case 0x38: 1227 case 0x38:
1229 { 1228 {
1230 /** 0011 1000 mov %e0%0, #%1 */ 1229 /** 0011 1000 mov %e0%0, #%1 */
1231 if (trace) 1230 if (trace)
(...skipping 26 matching lines...) Expand all
1258 case 0x3a: 1257 case 0x3a:
1259 { 1258 {
1260 /** 0011 1010 subc %0, #%1 */ 1259 /** 0011 1010 subc %0, #%1 */
1261 if (trace) 1260 if (trace)
1262 { 1261 {
1263 printf ("\033[33m%s\033[0m %02x\n", 1262 printf ("\033[33m%s\033[0m %02x\n",
1264 "/** 0011 1010 subc %0, #%1 */", 1263 "/** 0011 1010 subc %0, #%1 */",
1265 op[0]); 1264 op[0]);
1266 } 1265 }
1267 SYNTAX("subc %0, #%1"); 1266 SYNTAX("subc %0, #%1");
1268 #line 1149 "rl78-decode.opc" 1267 #line 1154 "rl78-decode.opc"
1269 ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac; 1268 ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
1270 1269
1271 /*---------------------------------------------------------------------- */ 1270 /*---------------------------------------------------------------------- */
1272 1271
1273 } 1272 }
1274 break; 1273 break;
1275 case 0x3b: 1274 case 0x3b:
1276 { 1275 {
1277 /** 0011 1011 subc %0, %1 */ 1276 /** 0011 1011 subc %0, %1 */
1278 if (trace) 1277 if (trace)
1279 { 1278 {
1280 printf ("\033[33m%s\033[0m %02x\n", 1279 printf ("\033[33m%s\033[0m %02x\n",
1281 "/** 0011 1011 subc %0, %1 */", 1280 "/** 0011 1011 subc %0, %1 */",
1282 op[0]); 1281 op[0]);
1283 } 1282 }
1284 SYNTAX("subc %0, %1"); 1283 SYNTAX("subc %0, %1");
1285 #line 1146 "rl78-decode.opc" 1284 #line 1151 "rl78-decode.opc"
1286 ID(subc); DR(A); SM(None, SADDR); Fzac; 1285 ID(subc); DR(A); SM(None, SADDR); Fzac;
1287 1286
1288 } 1287 }
1289 break; 1288 break;
1290 case 0x3c: 1289 case 0x3c:
1291 { 1290 {
1292 /** 0011 1100 subc %0, #%1 */ 1291 /** 0011 1100 subc %0, #%1 */
1293 if (trace) 1292 if (trace)
1294 { 1293 {
1295 printf ("\033[33m%s\033[0m %02x\n", 1294 printf ("\033[33m%s\033[0m %02x\n",
1296 "/** 0011 1100 subc %0, #%1 */", 1295 "/** 0011 1100 subc %0, #%1 */",
1297 op[0]); 1296 op[0]);
1298 } 1297 }
1299 SYNTAX("subc %0, #%1"); 1298 SYNTAX("subc %0, #%1");
1300 #line 1137 "rl78-decode.opc" 1299 #line 1142 "rl78-decode.opc"
1301 ID(subc); DR(A); SC(IMMU(1)); Fzac; 1300 ID(subc); DR(A); SC(IMMU(1)); Fzac;
1302 1301
1303 } 1302 }
1304 break; 1303 break;
1305 case 0x3d: 1304 case 0x3d:
1306 { 1305 {
1307 /** 0011 1101 subc %0, %e1%1 */ 1306 /** 0011 1101 subc %0, %e1%1 */
1308 if (trace) 1307 if (trace)
1309 { 1308 {
1310 printf ("\033[33m%s\033[0m %02x\n", 1309 printf ("\033[33m%s\033[0m %02x\n",
1311 "/** 0011 1101 subc %0, %e1%1 */", 1310 "/** 0011 1101 subc %0, %e1%1 */",
1312 op[0]); 1311 op[0]);
1313 } 1312 }
1314 SYNTAX("subc %0, %e1%1"); 1313 SYNTAX("subc %0, %e1%1");
1315 #line 1125 "rl78-decode.opc" 1314 #line 1130 "rl78-decode.opc"
1316 ID(subc); DR(A); SM(HL, 0); Fzac; 1315 ID(subc); DR(A); SM(HL, 0); Fzac;
1317 1316
1318 } 1317 }
1319 break; 1318 break;
1320 case 0x3e: 1319 case 0x3e:
1321 { 1320 {
1322 /** 0011 1110 subc %0, %e1%1 */ 1321 /** 0011 1110 subc %0, %e1%1 */
1323 if (trace) 1322 if (trace)
1324 { 1323 {
1325 printf ("\033[33m%s\033[0m %02x\n", 1324 printf ("\033[33m%s\033[0m %02x\n",
1326 "/** 0011 1110 subc %0, %e1%1 */", 1325 "/** 0011 1110 subc %0, %e1%1 */",
1327 op[0]); 1326 op[0]);
1328 } 1327 }
1329 SYNTAX("subc %0, %e1%1"); 1328 SYNTAX("subc %0, %e1%1");
1330 #line 1134 "rl78-decode.opc" 1329 #line 1139 "rl78-decode.opc"
1331 ID(subc); DR(A); SM(HL, IMMU(1)); Fzac; 1330 ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
1332 1331
1333 } 1332 }
1334 break; 1333 break;
1335 case 0x3f: 1334 case 0x3f:
1336 { 1335 {
1337 /** 0011 1111 subc %0, %e1%!1 */ 1336 /** 0011 1111 subc %0, %e1%!1 */
1338 if (trace) 1337 if (trace)
1339 { 1338 {
1340 printf ("\033[33m%s\033[0m %02x\n", 1339 printf ("\033[33m%s\033[0m %02x\n",
1341 "/** 0011 1111 subc %0, %e1%!1 */", 1340 "/** 0011 1111 subc %0, %e1%!1 */",
1342 op[0]); 1341 op[0]);
1343 } 1342 }
1344 SYNTAX("subc %0, %e1%!1"); 1343 SYNTAX("subc %0, %e1%!1");
1345 #line 1122 "rl78-decode.opc" 1344 #line 1127 "rl78-decode.opc"
1346 ID(subc); DR(A); SM(None, IMMU(2)); Fzac; 1345 ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
1347 1346
1348 } 1347 }
1349 break; 1348 break;
1350 case 0x40: 1349 case 0x40:
1351 { 1350 {
1352 /** 0100 0000 cmp %e0%!0, #%1 */ 1351 /** 0100 0000 cmp %e0%!0, #%1 */
1353 if (trace) 1352 if (trace)
1354 { 1353 {
1355 printf ("\033[33m%s\033[0m %02x\n", 1354 printf ("\033[33m%s\033[0m %02x\n",
(...skipping 501 matching lines...) Expand 10 before | Expand all | Expand 10 after
1857 case 0x20: 1856 case 0x20:
1858 case 0x21: 1857 case 0x21:
1859 case 0x22: 1858 case 0x22:
1860 case 0x23: 1859 case 0x23:
1861 case 0x24: 1860 case 0x24:
1862 case 0x25: 1861 case 0x25:
1863 case 0x26: 1862 case 0x26:
1864 case 0x27: 1863 case 0x27:
1865 { 1864 {
1866 /** 0110 0001 0010 0reg sub %0, %1 */ 1865 /** 0110 0001 0010 0reg sub %0, %1 */
1867 #line 1114 "rl78-decode.opc" 1866 #line 1119 "rl78-decode.opc"
1868 int reg AU = op[1] & 0x07; 1867 int reg AU = op[1] & 0x07;
1869 if (trace) 1868 if (trace)
1870 { 1869 {
1871 printf ("\033[33m%s\033[0m %02x %02x\n", 1870 printf ("\033[33m%s\033[0m %02x %02x\n",
1872 "/** 0110 0001 0010 0reg sub %0, %1 */", 1871 "/** 0110 0001 0010 0reg sub %0, %1 */",
1873 op[0], op[1]); 1872 op[0], op[1]);
1874 printf (" reg = 0x%x\n", reg); 1873 printf (" reg = 0x%x\n", reg);
1875 } 1874 }
1876 SYNTAX("sub %0, %1"); 1875 SYNTAX("sub %0, %1");
1877 #line 1114 "rl78-decode.opc" 1876 #line 1119 "rl78-decode.opc"
1878 ID(sub); DRB(reg); SR(A); Fzac; 1877 ID(sub); DRB(reg); SR(A); Fzac;
1879 1878
1880 } 1879 }
1881 break; 1880 break;
1882 case 0x28: 1881 case 0x28:
1883 case 0x2a: 1882 case 0x2a:
1884 case 0x2b: 1883 case 0x2b:
1885 case 0x2c: 1884 case 0x2c:
1886 case 0x2d: 1885 case 0x2d:
1887 case 0x2e: 1886 case 0x2e:
1888 case 0x2f: 1887 case 0x2f:
1889 { 1888 {
1890 /** 0110 0001 0010 1rba sub %0, %1 */ 1889 /** 0110 0001 0010 1rba sub %0, %1 */
1891 #line 1108 "rl78-decode.opc" 1890 #line 1113 "rl78-decode.opc"
1892 int rba AU = op[1] & 0x07; 1891 int rba AU = op[1] & 0x07;
1893 if (trace) 1892 if (trace)
1894 { 1893 {
1895 printf ("\033[33m%s\033[0m %02x %02x\n", 1894 printf ("\033[33m%s\033[0m %02x %02x\n",
1896 "/** 0110 0001 0010 1rba sub %0, %1 */", 1895 "/** 0110 0001 0010 1rba sub %0, %1 */",
1897 op[0], op[1]); 1896 op[0], op[1]);
1898 printf (" rba = 0x%x\n", rba); 1897 printf (" rba = 0x%x\n", rba);
1899 } 1898 }
1900 SYNTAX("sub %0, %1"); 1899 SYNTAX("sub %0, %1");
1901 #line 1108 "rl78-decode.opc" 1900 #line 1113 "rl78-decode.opc"
1902 ID(sub); DR(A); SRB(rba); Fzac; 1901 ID(sub); DR(A); SRB(rba); Fzac;
1903 1902
1904 } 1903 }
1905 break; 1904 break;
1906 case 0x29: 1905 case 0x29:
1907 { 1906 {
1908 /** 0110 0001 0010 1001 subw %0, %e1%1 */ 1907 /** 0110 0001 0010 1001 subw %0, %e1%1 */
1909 if (trace) 1908 if (trace)
1910 { 1909 {
1911 printf ("\033[33m%s\033[0m %02x %02x\n", 1910 printf ("\033[33m%s\033[0m %02x %02x\n",
1912 "/** 0110 0001 0010 1001 subw %0, %e1% 1 */", 1911 "/** 0110 0001 0010 1001 subw %0, %e1% 1 */",
1913 op[0], op[1]); 1912 op[0], op[1]);
1914 } 1913 }
1915 SYNTAX("subw %0, %e1%1"); 1914 SYNTAX("subw %0, %e1%1");
1916 #line 1157 "rl78-decode.opc" 1915 #line 1162 "rl78-decode.opc"
1917 ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac; 1916 ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1918 1917
1919 } 1918 }
1920 break; 1919 break;
1921 case 0x30: 1920 case 0x30:
1922 case 0x31: 1921 case 0x31:
1923 case 0x32: 1922 case 0x32:
1924 case 0x33: 1923 case 0x33:
1925 case 0x34: 1924 case 0x34:
1926 case 0x35: 1925 case 0x35:
1927 case 0x36: 1926 case 0x36:
1928 case 0x37: 1927 case 0x37:
1929 { 1928 {
1930 /** 0110 0001 0011 0reg subc %0, %1 */ 1929 /** 0110 0001 0011 0reg subc %0, %1 */
1931 #line 1143 "rl78-decode.opc" 1930 #line 1148 "rl78-decode.opc"
1932 int reg AU = op[1] & 0x07; 1931 int reg AU = op[1] & 0x07;
1933 if (trace) 1932 if (trace)
1934 { 1933 {
1935 printf ("\033[33m%s\033[0m %02x %02x\n", 1934 printf ("\033[33m%s\033[0m %02x %02x\n",
1936 "/** 0110 0001 0011 0reg subc %0, %1 */", 1935 "/** 0110 0001 0011 0reg subc %0, %1 */",
1937 op[0], op[1]); 1936 op[0], op[1]);
1938 printf (" reg = 0x%x\n", reg); 1937 printf (" reg = 0x%x\n", reg);
1939 } 1938 }
1940 SYNTAX("subc %0, %1"); 1939 SYNTAX("subc %0, %1");
1941 #line 1143 "rl78-decode.opc" 1940 #line 1148 "rl78-decode.opc"
1942 ID(subc); DRB(reg); SR(A); Fzac; 1941 ID(subc); DRB(reg); SR(A); Fzac;
1943 1942
1944 } 1943 }
1945 break; 1944 break;
1946 case 0x38: 1945 case 0x38:
1947 case 0x3a: 1946 case 0x3a:
1948 case 0x3b: 1947 case 0x3b:
1949 case 0x3c: 1948 case 0x3c:
1950 case 0x3d: 1949 case 0x3d:
1951 case 0x3e: 1950 case 0x3e:
1952 case 0x3f: 1951 case 0x3f:
1953 { 1952 {
1954 /** 0110 0001 0011 1rba subc %0, %1 */ 1953 /** 0110 0001 0011 1rba subc %0, %1 */
1955 #line 1140 "rl78-decode.opc" 1954 #line 1145 "rl78-decode.opc"
1956 int rba AU = op[1] & 0x07; 1955 int rba AU = op[1] & 0x07;
1957 if (trace) 1956 if (trace)
1958 { 1957 {
1959 printf ("\033[33m%s\033[0m %02x %02x\n", 1958 printf ("\033[33m%s\033[0m %02x %02x\n",
1960 "/** 0110 0001 0011 1rba subc %0, %1 */", 1959 "/** 0110 0001 0011 1rba subc %0, %1 */",
1961 op[0], op[1]); 1960 op[0], op[1]);
1962 printf (" rba = 0x%x\n", rba); 1961 printf (" rba = 0x%x\n", rba);
1963 } 1962 }
1964 SYNTAX("subc %0, %1"); 1963 SYNTAX("subc %0, %1");
1965 #line 1140 "rl78-decode.opc" 1964 #line 1145 "rl78-decode.opc"
1966 ID(subc); DR(A); SRB(rba); Fzac; 1965 ID(subc); DR(A); SRB(rba); Fzac;
1967 1966
1968 } 1967 }
1969 break; 1968 break;
1970 case 0x40: 1969 case 0x40:
1971 case 0x41: 1970 case 0x41:
1972 case 0x42: 1971 case 0x42:
1973 case 0x43: 1972 case 0x43:
1974 case 0x44: 1973 case 0x44:
1975 case 0x45: 1974 case 0x45:
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after
2098 case 0x60: 2097 case 0x60:
2099 case 0x61: 2098 case 0x61:
2100 case 0x62: 2099 case 0x62:
2101 case 0x63: 2100 case 0x63:
2102 case 0x64: 2101 case 0x64:
2103 case 0x65: 2102 case 0x65:
2104 case 0x66: 2103 case 0x66:
2105 case 0x67: 2104 case 0x67:
2106 { 2105 {
2107 /** 0110 0001 0110 0reg or %0, %1 */ 2106 /** 0110 0001 0110 0reg or %0, %1 */
2108 #line 932 "rl78-decode.opc" 2107 #line 937 "rl78-decode.opc"
2109 int reg AU = op[1] & 0x07; 2108 int reg AU = op[1] & 0x07;
2110 if (trace) 2109 if (trace)
2111 { 2110 {
2112 printf ("\033[33m%s\033[0m %02x %02x\n", 2111 printf ("\033[33m%s\033[0m %02x %02x\n",
2113 "/** 0110 0001 0110 0reg or %0, %1 */", 2112 "/** 0110 0001 0110 0reg or %0, %1 */",
2114 op[0], op[1]); 2113 op[0], op[1]);
2115 printf (" reg = 0x%x\n", reg); 2114 printf (" reg = 0x%x\n", reg);
2116 } 2115 }
2117 SYNTAX("or %0, %1"); 2116 SYNTAX("or %0, %1");
2118 #line 932 "rl78-decode.opc" 2117 #line 937 "rl78-decode.opc"
2119 ID(or); DRB(reg); SR(A); Fz; 2118 ID(or); DRB(reg); SR(A); Fz;
2120 2119
2121 } 2120 }
2122 break; 2121 break;
2123 case 0x68: 2122 case 0x68:
2124 case 0x6a: 2123 case 0x6a:
2125 case 0x6b: 2124 case 0x6b:
2126 case 0x6c: 2125 case 0x6c:
2127 case 0x6d: 2126 case 0x6d:
2128 case 0x6e: 2127 case 0x6e:
2129 case 0x6f: 2128 case 0x6f:
2130 { 2129 {
2131 /** 0110 0001 0110 1rba or %0, %1 */ 2130 /** 0110 0001 0110 1rba or %0, %1 */
2132 #line 929 "rl78-decode.opc" 2131 #line 934 "rl78-decode.opc"
2133 int rba AU = op[1] & 0x07; 2132 int rba AU = op[1] & 0x07;
2134 if (trace) 2133 if (trace)
2135 { 2134 {
2136 printf ("\033[33m%s\033[0m %02x %02x\n", 2135 printf ("\033[33m%s\033[0m %02x %02x\n",
2137 "/** 0110 0001 0110 1rba or %0, %1 */", 2136 "/** 0110 0001 0110 1rba or %0, %1 */",
2138 op[0], op[1]); 2137 op[0], op[1]);
2139 printf (" rba = 0x%x\n", rba); 2138 printf (" rba = 0x%x\n", rba);
2140 } 2139 }
2141 SYNTAX("or %0, %1"); 2140 SYNTAX("or %0, %1");
2142 #line 929 "rl78-decode.opc" 2141 #line 934 "rl78-decode.opc"
2143 ID(or); DR(A); SRB(rba); Fz; 2142 ID(or); DR(A); SRB(rba); Fz;
2144 2143
2145 } 2144 }
2146 break; 2145 break;
2147 case 0x69: 2146 case 0x69:
2148 { 2147 {
2149 /** 0110 0001 0110 1001 dec %e0%0 */ 2148 /** 0110 0001 0110 1001 dec %e0%0 */
2150 if (trace) 2149 if (trace)
2151 { 2150 {
2152 printf ("\033[33m%s\033[0m %02x %02x\n", 2151 printf ("\033[33m%s\033[0m %02x %02x\n",
2153 "/** 0110 0001 0110 1001 dec %e0%0 */", 2152 "/** 0110 0001 0110 1001 dec %e0%0 */",
2154 op[0], op[1]); 2153 op[0], op[1]);
2155 } 2154 }
2156 SYNTAX("dec %e0%0"); 2155 SYNTAX("dec %e0%0");
2157 #line 530 "rl78-decode.opc" 2156 #line 530 "rl78-decode.opc"
2158 ID(sub); DM(HL, IMMU(1)); SC(1); Fza; 2157 ID(sub); DM(HL, IMMU(1)); SC(1); Fza;
2159 2158
2160 } 2159 }
2161 break; 2160 break;
2162 case 0x70: 2161 case 0x70:
2163 case 0x71: 2162 case 0x71:
2164 case 0x72: 2163 case 0x72:
2165 case 0x73: 2164 case 0x73:
2166 case 0x74: 2165 case 0x74:
2167 case 0x75: 2166 case 0x75:
2168 case 0x76: 2167 case 0x76:
2169 case 0x77: 2168 case 0x77:
2170 { 2169 {
2171 /** 0110 0001 0111 0reg xor %0, %1 */ 2170 /** 0110 0001 0111 0reg xor %0, %1 */
2172 #line 1236 "rl78-decode.opc" 2171 #line 1241 "rl78-decode.opc"
2173 int reg AU = op[1] & 0x07; 2172 int reg AU = op[1] & 0x07;
2174 if (trace) 2173 if (trace)
2175 { 2174 {
2176 printf ("\033[33m%s\033[0m %02x %02x\n", 2175 printf ("\033[33m%s\033[0m %02x %02x\n",
2177 "/** 0110 0001 0111 0reg xor %0, %1 */", 2176 "/** 0110 0001 0111 0reg xor %0, %1 */",
2178 op[0], op[1]); 2177 op[0], op[1]);
2179 printf (" reg = 0x%x\n", reg); 2178 printf (" reg = 0x%x\n", reg);
2180 } 2179 }
2181 SYNTAX("xor %0, %1"); 2180 SYNTAX("xor %0, %1");
2182 #line 1236 "rl78-decode.opc" 2181 #line 1241 "rl78-decode.opc"
2183 ID(xor); DRB(reg); SR(A); Fz; 2182 ID(xor); DRB(reg); SR(A); Fz;
2184 2183
2185 } 2184 }
2186 break; 2185 break;
2187 case 0x78: 2186 case 0x78:
2188 case 0x7a: 2187 case 0x7a:
2189 case 0x7b: 2188 case 0x7b:
2190 case 0x7c: 2189 case 0x7c:
2191 case 0x7d: 2190 case 0x7d:
2192 case 0x7e: 2191 case 0x7e:
2193 case 0x7f: 2192 case 0x7f:
2194 { 2193 {
2195 /** 0110 0001 0111 1rba xor %0, %1 */ 2194 /** 0110 0001 0111 1rba xor %0, %1 */
2196 #line 1233 "rl78-decode.opc" 2195 #line 1238 "rl78-decode.opc"
2197 int rba AU = op[1] & 0x07; 2196 int rba AU = op[1] & 0x07;
2198 if (trace) 2197 if (trace)
2199 { 2198 {
2200 printf ("\033[33m%s\033[0m %02x %02x\n", 2199 printf ("\033[33m%s\033[0m %02x %02x\n",
2201 "/** 0110 0001 0111 1rba xor %0, %1 */", 2200 "/** 0110 0001 0111 1rba xor %0, %1 */",
2202 op[0], op[1]); 2201 op[0], op[1]);
2203 printf (" rba = 0x%x\n", rba); 2202 printf (" rba = 0x%x\n", rba);
2204 } 2203 }
2205 SYNTAX("xor %0, %1"); 2204 SYNTAX("xor %0, %1");
2206 #line 1233 "rl78-decode.opc" 2205 #line 1238 "rl78-decode.opc"
2207 ID(xor); DR(A); SRB(rba); Fz; 2206 ID(xor); DR(A); SRB(rba); Fz;
2208 2207
2209 } 2208 }
2210 break; 2209 break;
2211 case 0x79: 2210 case 0x79:
2212 { 2211 {
2213 /** 0110 0001 0111 1001 incw %e0%0 */ 2212 /** 0110 0001 0111 1001 incw %e0%0 */
2214 if (trace) 2213 if (trace)
2215 { 2214 {
2216 printf ("\033[33m%s\033[0m %02x %02x\n", 2215 printf ("\033[33m%s\033[0m %02x %02x\n",
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after
2310 break; 2309 break;
2311 case 0x88: 2310 case 0x88:
2312 case 0x8a: 2311 case 0x8a:
2313 case 0x8b: 2312 case 0x8b:
2314 case 0x8c: 2313 case 0x8c:
2315 case 0x8d: 2314 case 0x8d:
2316 case 0x8e: 2315 case 0x8e:
2317 case 0x8f: 2316 case 0x8f:
2318 { 2317 {
2319 /** 0110 0001 1000 1reg xch %0, %1 */ 2318 /** 0110 0001 1000 1reg xch %0, %1 */
2320 #line 1195 "rl78-decode.opc" 2319 #line 1200 "rl78-decode.opc"
2321 int reg AU = op[1] & 0x07; 2320 int reg AU = op[1] & 0x07;
2322 if (trace) 2321 if (trace)
2323 { 2322 {
2324 printf ("\033[33m%s\033[0m %02x %02x\n", 2323 printf ("\033[33m%s\033[0m %02x %02x\n",
2325 "/** 0110 0001 1000 1reg xch %0, %1 */", 2324 "/** 0110 0001 1000 1reg xch %0, %1 */",
2326 op[0], op[1]); 2325 op[0], op[1]);
2327 printf (" reg = 0x%x\n", reg); 2326 printf (" reg = 0x%x\n", reg);
2328 } 2327 }
2329 SYNTAX("xch %0, %1"); 2328 SYNTAX("xch %0, %1");
2330 #line 1195 "rl78-decode.opc" 2329 #line 1200 "rl78-decode.opc"
2331 /* Note: DECW uses reg == X, so this must follow DECW */ 2330 /* Note: DECW uses reg == X, so this must follow DECW */
2332 ID(xch); DR(A); SRB(reg); 2331 ID(xch); DR(A); SRB(reg);
2333 2332
2334 } 2333 }
2335 break; 2334 break;
2336 case 0x89: 2335 case 0x89:
2337 { 2336 {
2338 /** 0110 0001 1000 1001 decw %e0%0 */ 2337 /** 0110 0001 1000 1001 decw %e0%0 */
2339 if (trace) 2338 if (trace)
2340 { 2339 {
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
2382 case 0xa1: 2381 case 0xa1:
2383 { 2382 {
2384 /** 0110 0001 1010 000 sub %0, %e1%1 */ 2383 /** 0110 0001 1010 000 sub %0, %e1%1 */
2385 if (trace) 2384 if (trace)
2386 { 2385 {
2387 printf ("\033[33m%s\033[0m %02x %02x\n", 2386 printf ("\033[33m%s\033[0m %02x %02x\n",
2388 "/** 0110 0001 1010 000 sub %0, %e1% 1 */", 2387 "/** 0110 0001 1010 000 sub %0, %e1% 1 */",
2389 op[0], op[1]); 2388 op[0], op[1]);
2390 } 2389 }
2391 SYNTAX("sub %0, %e1%1"); 2390 SYNTAX("sub %0, %e1%1");
2392 #line 1096 "rl78-decode.opc" 2391 #line 1101 "rl78-decode.opc"
2393 ID(sub); DR(A); SM2(HL, B, 0); Fzac; 2392 ID(sub); DR(A); SM2(HL, B, 0); Fzac;
2394 2393
2395 } 2394 }
2396 break; 2395 break;
2397 case 0xa2: 2396 case 0xa2:
2398 { 2397 {
2399 /** 0110 0001 1010 0010 sub %0, %e1%1 */ 2398 /** 0110 0001 1010 0010 sub %0, %e1%1 */
2400 if (trace) 2399 if (trace)
2401 { 2400 {
2402 printf ("\033[33m%s\033[0m %02x %02x\n", 2401 printf ("\033[33m%s\033[0m %02x %02x\n",
2403 "/** 0110 0001 1010 0010 sub %0, %e1% 1 */", 2402 "/** 0110 0001 1010 0010 sub %0, %e1% 1 */",
2404 op[0], op[1]); 2403 op[0], op[1]);
2405 } 2404 }
2406 SYNTAX("sub %0, %e1%1"); 2405 SYNTAX("sub %0, %e1%1");
2407 #line 1102 "rl78-decode.opc" 2406 #line 1107 "rl78-decode.opc"
2408 ID(sub); DR(A); SM2(HL, C, 0); Fzac; 2407 ID(sub); DR(A); SM2(HL, C, 0); Fzac;
2409 2408
2410 } 2409 }
2411 break; 2410 break;
2412 case 0xa8: 2411 case 0xa8:
2413 { 2412 {
2414 /** 0110 0001 1010 1000 xch %0, %1 */ 2413 /** 0110 0001 1010 1000 xch %0, %1 */
2415 if (trace) 2414 if (trace)
2416 { 2415 {
2417 printf ("\033[33m%s\033[0m %02x %02x\n", 2416 printf ("\033[33m%s\033[0m %02x %02x\n",
2418 "/** 0110 0001 1010 1000 xch %0, %1 */", 2417 "/** 0110 0001 1010 1000 xch %0, %1 */",
2419 op[0], op[1]); 2418 op[0], op[1]);
2420 } 2419 }
2421 SYNTAX("xch %0, %1"); 2420 SYNTAX("xch %0, %1");
2422 #line 1199 "rl78-decode.opc" 2421 #line 1204 "rl78-decode.opc"
2423 ID(xch); DR(A); SM(None, SADDR); 2422 ID(xch); DR(A); SM(None, SADDR);
2424 2423
2425 } 2424 }
2426 break; 2425 break;
2427 case 0xa9: 2426 case 0xa9:
2428 { 2427 {
2429 /** 0110 0001 1010 1001 xch %0, %e1%1 */ 2428 /** 0110 0001 1010 1001 xch %0, %e1%1 */
2430 if (trace) 2429 if (trace)
2431 { 2430 {
2432 printf ("\033[33m%s\033[0m %02x %02x\n", 2431 printf ("\033[33m%s\033[0m %02x %02x\n",
2433 "/** 0110 0001 1010 1001 xch %0, %e1% 1 */", 2432 "/** 0110 0001 1010 1001 xch %0, %e1% 1 */",
2434 op[0], op[1]); 2433 op[0], op[1]);
2435 } 2434 }
2436 SYNTAX("xch %0, %e1%1"); 2435 SYNTAX("xch %0, %e1%1");
2437 #line 1192 "rl78-decode.opc" 2436 #line 1197 "rl78-decode.opc"
2438 ID(xch); DR(A); SM2(HL, C, 0); 2437 ID(xch); DR(A); SM2(HL, C, 0);
2439 2438
2440 } 2439 }
2441 break; 2440 break;
2442 case 0xaa: 2441 case 0xaa:
2443 { 2442 {
2444 /** 0110 0001 1010 1010 xch %0, %e1%!1 */ 2443 /** 0110 0001 1010 1010 xch %0, %e1%!1 */
2445 if (trace) 2444 if (trace)
2446 { 2445 {
2447 printf ("\033[33m%s\033[0m %02x %02x\n", 2446 printf ("\033[33m%s\033[0m %02x %02x\n",
2448 "/** 0110 0001 1010 1010 xch %0, %e1% !1 */", 2447 "/** 0110 0001 1010 1010 xch %0, %e1% !1 */",
2449 op[0], op[1]); 2448 op[0], op[1]);
2450 } 2449 }
2451 SYNTAX("xch %0, %e1%!1"); 2450 SYNTAX("xch %0, %e1%!1");
2452 #line 1174 "rl78-decode.opc" 2451 #line 1179 "rl78-decode.opc"
2453 ID(xch); DR(A); SM(None, IMMU(2)); 2452 ID(xch); DR(A); SM(None, IMMU(2));
2454 2453
2455 } 2454 }
2456 break; 2455 break;
2457 case 0xab: 2456 case 0xab:
2458 { 2457 {
2459 /** 0110 0001 1010 1011 xch %0, %1 */ 2458 /** 0110 0001 1010 1011 xch %0, %1 */
2460 if (trace) 2459 if (trace)
2461 { 2460 {
2462 printf ("\033[33m%s\033[0m %02x %02x\n", 2461 printf ("\033[33m%s\033[0m %02x %02x\n",
2463 "/** 0110 0001 1010 1011 xch %0, %1 */", 2462 "/** 0110 0001 1010 1011 xch %0, %1 */",
2464 op[0], op[1]); 2463 op[0], op[1]);
2465 } 2464 }
2466 SYNTAX("xch %0, %1"); 2465 SYNTAX("xch %0, %1");
2467 #line 1202 "rl78-decode.opc" 2466 #line 1207 "rl78-decode.opc"
2468 ID(xch); DR(A); SM(None, SFR); 2467 ID(xch); DR(A); SM(None, SFR);
2469 2468
2470 } 2469 }
2471 break; 2470 break;
2472 case 0xac: 2471 case 0xac:
2473 { 2472 {
2474 /** 0110 0001 1010 1100 xch %0, %e1%1 */ 2473 /** 0110 0001 1010 1100 xch %0, %e1%1 */
2475 if (trace) 2474 if (trace)
2476 { 2475 {
2477 printf ("\033[33m%s\033[0m %02x %02x\n", 2476 printf ("\033[33m%s\033[0m %02x %02x\n",
2478 "/** 0110 0001 1010 1100 xch %0, %e1% 1 */", 2477 "/** 0110 0001 1010 1100 xch %0, %e1% 1 */",
2479 op[0], op[1]); 2478 op[0], op[1]);
2480 } 2479 }
2481 SYNTAX("xch %0, %e1%1"); 2480 SYNTAX("xch %0, %e1%1");
2482 #line 1183 "rl78-decode.opc" 2481 #line 1188 "rl78-decode.opc"
2483 ID(xch); DR(A); SM(HL, 0); 2482 ID(xch); DR(A); SM(HL, 0);
2484 2483
2485 } 2484 }
2486 break; 2485 break;
2487 case 0xad: 2486 case 0xad:
2488 { 2487 {
2489 /** 0110 0001 1010 1101 xch %0, %e1%1 */ 2488 /** 0110 0001 1010 1101 xch %0, %e1%1 */
2490 if (trace) 2489 if (trace)
2491 { 2490 {
2492 printf ("\033[33m%s\033[0m %02x %02x\n", 2491 printf ("\033[33m%s\033[0m %02x %02x\n",
2493 "/** 0110 0001 1010 1101 xch %0, %e1% 1 */", 2492 "/** 0110 0001 1010 1101 xch %0, %e1% 1 */",
2494 op[0], op[1]); 2493 op[0], op[1]);
2495 } 2494 }
2496 SYNTAX("xch %0, %e1%1"); 2495 SYNTAX("xch %0, %e1%1");
2497 #line 1189 "rl78-decode.opc" 2496 #line 1194 "rl78-decode.opc"
2498 ID(xch); DR(A); SM(HL, IMMU(1)); 2497 ID(xch); DR(A); SM(HL, IMMU(1));
2499 2498
2500 } 2499 }
2501 break; 2500 break;
2502 case 0xae: 2501 case 0xae:
2503 { 2502 {
2504 /** 0110 0001 1010 1110 xch %0, %e1%1 */ 2503 /** 0110 0001 1010 1110 xch %0, %e1%1 */
2505 if (trace) 2504 if (trace)
2506 { 2505 {
2507 printf ("\033[33m%s\033[0m %02x %02x\n", 2506 printf ("\033[33m%s\033[0m %02x %02x\n",
2508 "/** 0110 0001 1010 1110 xch %0, %e1% 1 */", 2507 "/** 0110 0001 1010 1110 xch %0, %e1% 1 */",
2509 op[0], op[1]); 2508 op[0], op[1]);
2510 } 2509 }
2511 SYNTAX("xch %0, %e1%1"); 2510 SYNTAX("xch %0, %e1%1");
2512 #line 1177 "rl78-decode.opc" 2511 #line 1182 "rl78-decode.opc"
2513 ID(xch); DR(A); SM(DE, 0); 2512 ID(xch); DR(A); SM(DE, 0);
2514 2513
2515 } 2514 }
2516 break; 2515 break;
2517 case 0xaf: 2516 case 0xaf:
2518 { 2517 {
2519 /** 0110 0001 1010 1111 xch %0, %e1%1 */ 2518 /** 0110 0001 1010 1111 xch %0, %e1%1 */
2520 if (trace) 2519 if (trace)
2521 { 2520 {
2522 printf ("\033[33m%s\033[0m %02x %02x\n", 2521 printf ("\033[33m%s\033[0m %02x %02x\n",
2523 "/** 0110 0001 1010 1111 xch %0, %e1% 1 */", 2522 "/** 0110 0001 1010 1111 xch %0, %e1% 1 */",
2524 op[0], op[1]); 2523 op[0], op[1]);
2525 } 2524 }
2526 SYNTAX("xch %0, %e1%1"); 2525 SYNTAX("xch %0, %e1%1");
2527 #line 1180 "rl78-decode.opc" 2526 #line 1185 "rl78-decode.opc"
2528 ID(xch); DR(A); SM(DE, IMMU(1)); 2527 ID(xch); DR(A); SM(DE, IMMU(1));
2529 2528
2530 } 2529 }
2531 break; 2530 break;
2532 case 0xb0: 2531 case 0xb0:
2533 { 2532 {
2534 /** 0110 0001 1011 0000 subc %0, %e1%1 */ 2533 /** 0110 0001 1011 0000 subc %0, %e1%1 */
2535 if (trace) 2534 if (trace)
2536 { 2535 {
2537 printf ("\033[33m%s\033[0m %02x %02x\n", 2536 printf ("\033[33m%s\033[0m %02x %02x\n",
2538 "/** 0110 0001 1011 0000 subc %0, %e1% 1 */", 2537 "/** 0110 0001 1011 0000 subc %0, %e1% 1 */",
2539 op[0], op[1]); 2538 op[0], op[1]);
2540 } 2539 }
2541 SYNTAX("subc %0, %e1%1"); 2540 SYNTAX("subc %0, %e1%1");
2542 #line 1128 "rl78-decode.opc" 2541 #line 1133 "rl78-decode.opc"
2543 ID(subc); DR(A); SM2(HL, B, 0); Fzac; 2542 ID(subc); DR(A); SM2(HL, B, 0); Fzac;
2544 2543
2545 } 2544 }
2546 break; 2545 break;
2547 case 0xb2: 2546 case 0xb2:
2548 { 2547 {
2549 /** 0110 0001 1011 0010 subc %0, %e1%1 */ 2548 /** 0110 0001 1011 0010 subc %0, %e1%1 */
2550 if (trace) 2549 if (trace)
2551 { 2550 {
2552 printf ("\033[33m%s\033[0m %02x %02x\n", 2551 printf ("\033[33m%s\033[0m %02x %02x\n",
2553 "/** 0110 0001 1011 0010 subc %0, %e1% 1 */", 2552 "/** 0110 0001 1011 0010 subc %0, %e1% 1 */",
2554 op[0], op[1]); 2553 op[0], op[1]);
2555 } 2554 }
2556 SYNTAX("subc %0, %e1%1"); 2555 SYNTAX("subc %0, %e1%1");
2557 #line 1131 "rl78-decode.opc" 2556 #line 1136 "rl78-decode.opc"
2558 ID(subc); DR(A); SM2(HL, C, 0); Fzac; 2557 ID(subc); DR(A); SM2(HL, C, 0); Fzac;
2559 2558
2560 } 2559 }
2561 break; 2560 break;
2562 case 0xb8: 2561 case 0xb8:
2563 { 2562 {
2564 /** 0110 0001 1011 1000 mov %0, %1 */ 2563 /** 0110 0001 1011 1000 mov %0, %1 */
2565 if (trace) 2564 if (trace)
2566 { 2565 {
2567 printf ("\033[33m%s\033[0m %02x %02x\n", 2566 printf ("\033[33m%s\033[0m %02x %02x\n",
2568 "/** 0110 0001 1011 1000 mov %0, %1 */", 2567 "/** 0110 0001 1011 1000 mov %0, %1 */",
2569 op[0], op[1]); 2568 op[0], op[1]);
2570 } 2569 }
2571 SYNTAX("mov %0, %1"); 2570 SYNTAX("mov %0, %1");
2572 #line 702 "rl78-decode.opc" 2571 #line 702 "rl78-decode.opc"
2573 ID(mov); DR(ES); SM(None, SADDR); 2572 ID(mov); DR(ES); SM(None, SADDR);
2574 2573
2575 } 2574 }
2576 break; 2575 break;
2577 case 0xb9: 2576 case 0xb9:
2578 { 2577 {
2579 /** 0110 0001 1011 1001 xch %0, %e1%1 */ 2578 /** 0110 0001 1011 1001 xch %0, %e1%1 */
2580 if (trace) 2579 if (trace)
2581 { 2580 {
2582 printf ("\033[33m%s\033[0m %02x %02x\n", 2581 printf ("\033[33m%s\033[0m %02x %02x\n",
2583 "/** 0110 0001 1011 1001 xch %0, %e1% 1 */", 2582 "/** 0110 0001 1011 1001 xch %0, %e1% 1 */",
2584 op[0], op[1]); 2583 op[0], op[1]);
2585 } 2584 }
2586 SYNTAX("xch %0, %e1%1"); 2585 SYNTAX("xch %0, %e1%1");
2587 #line 1186 "rl78-decode.opc" 2586 #line 1191 "rl78-decode.opc"
2588 ID(xch); DR(A); SM2(HL, B, 0); 2587 ID(xch); DR(A); SM2(HL, B, 0);
2589 2588
2590 } 2589 }
2591 break; 2590 break;
2592 case 0xc0: 2591 case 0xc0:
2593 { 2592 {
2594 /** 0110 0001 1100 0000 cmp %0, %e1%1 */ 2593 /** 0110 0001 1100 0000 cmp %0, %e1%1 */
2595 if (trace) 2594 if (trace)
2596 { 2595 {
2597 printf ("\033[33m%s\033[0m %02x %02x\n", 2596 printf ("\033[33m%s\033[0m %02x %02x\n",
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
2637 case 0xc8: 2636 case 0xc8:
2638 { 2637 {
2639 /** 0110 0001 1100 1000 sk%c1 */ 2638 /** 0110 0001 1100 1000 sk%c1 */
2640 if (trace) 2639 if (trace)
2641 { 2640 {
2642 printf ("\033[33m%s\033[0m %02x %02x\n", 2641 printf ("\033[33m%s\033[0m %02x %02x\n",
2643 "/** 0110 0001 1100 1000 sk%c1 */", 2642 "/** 0110 0001 1100 1000 sk%c1 */",
2644 op[0], op[1]); 2643 op[0], op[1]);
2645 } 2644 }
2646 SYNTAX("sk%c1"); 2645 SYNTAX("sk%c1");
2647 #line 1065 "rl78-decode.opc" 2646 #line 1070 "rl78-decode.opc"
2648 ID(skip); COND(C); 2647 ID(skip); COND(C);
2649 2648
2650 } 2649 }
2651 break; 2650 break;
2652 case 0xc9: 2651 case 0xc9:
2653 { 2652 {
2654 /** 0110 0001 1100 1001 mov %0, %e1%1 */ 2653 /** 0110 0001 1100 1001 mov %0, %e1%1 */
2655 if (trace) 2654 if (trace)
2656 { 2655 {
2657 printf ("\033[33m%s\033[0m %02x %02x\n", 2656 printf ("\033[33m%s\033[0m %02x %02x\n",
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
2722 case 0xcd: 2721 case 0xcd:
2723 { 2722 {
2724 /** 0110 0001 1100 1101 pop %s0 */ 2723 /** 0110 0001 1100 1101 pop %s0 */
2725 if (trace) 2724 if (trace)
2726 { 2725 {
2727 printf ("\033[33m%s\033[0m %02x %02x\n", 2726 printf ("\033[33m%s\033[0m %02x %02x\n",
2728 "/** 0110 0001 1100 1101 pop %s0 */", 2727 "/** 0110 0001 1100 1101 pop %s0 */",
2729 op[0], op[1]); 2728 op[0], op[1]);
2730 } 2729 }
2731 SYNTAX("pop %s0"); 2730 SYNTAX("pop %s0");
2732 #line 960 "rl78-decode.opc" 2731 #line 965 "rl78-decode.opc"
2733 ID(mov); W(); DR(PSW); SPOP(); 2732 ID(mov); W(); DR(PSW); SPOP();
2734 2733
2735 /*---------------------------------------------------------------- ------*/ 2734 /*---------------------------------------------------------------- ------*/
2736 2735
2737 } 2736 }
2738 break; 2737 break;
2739 case 0xce: 2738 case 0xce:
2740 { 2739 {
2741 /** 0110 0001 1100 1110 movs %e0%0, %1 */ 2740 /** 0110 0001 1100 1110 movs %e0%0, %1 */
2742 if (trace) 2741 if (trace)
2743 { 2742 {
2744 printf ("\033[33m%s\033[0m %02x %02x\n", 2743 printf ("\033[33m%s\033[0m %02x %02x\n",
2745 "/** 0110 0001 1100 1110 movs %e0%0, % 1 */", 2744 "/** 0110 0001 1100 1110 movs %e0%0, % 1 */",
2746 op[0], op[1]); 2745 op[0], op[1]);
2747 } 2746 }
2748 SYNTAX("movs %e0%0, %1"); 2747 SYNTAX("movs %e0%0, %1");
2749 #line 787 "rl78-decode.opc" 2748 #line 787 "rl78-decode.opc"
2750 ID(mov); DM(HL, IMMU(1)); SR(X); Fzc; 2749 ID(mov); DM(HL, IMMU(1)); SR(X); Fzc;
2751 2750
2752 /*---------------------------------------------------------------- ------*/ 2751 /*---------------------------------------------------------------- ------*/
2753 2752
2754 } 2753 }
2755 break; 2754 break;
2756 case 0xcf: 2755 case 0xcf:
2757 case 0xdf: 2756 case 0xdf:
2758 case 0xef: 2757 case 0xef:
2759 case 0xff: 2758 case 0xff:
2760 { 2759 {
2761 /** 0110 0001 11rb 1111 sel rb%1 */ 2760 /** 0110 0001 11rb 1111 sel rb%1 */
2762 #line 1012 "rl78-decode.opc" 2761 #line 1017 "rl78-decode.opc"
2763 int rb AU = (op[1] >> 4) & 0x03; 2762 int rb AU = (op[1] >> 4) & 0x03;
2764 if (trace) 2763 if (trace)
2765 { 2764 {
2766 printf ("\033[33m%s\033[0m %02x %02x\n", 2765 printf ("\033[33m%s\033[0m %02x %02x\n",
2767 "/** 0110 0001 11rb 1111 sel rb%1 */", 2766 "/** 0110 0001 11rb 1111 sel rb%1 */",
2768 op[0], op[1]); 2767 op[0], op[1]);
2769 printf (" rb = 0x%x\n", rb); 2768 printf (" rb = 0x%x\n", rb);
2770 } 2769 }
2771 SYNTAX("sel rb%1"); 2770 SYNTAX("sel rb%1");
2772 #line 1012 "rl78-decode.opc" 2771 #line 1017 "rl78-decode.opc"
2773 ID(sel); SC(rb); 2772 ID(sel); SC(rb);
2774 2773
2775 /*---------------------------------------------------------------- ------*/ 2774 /*---------------------------------------------------------------- ------*/
2776 2775
2777 } 2776 }
2778 break; 2777 break;
2779 case 0xd0: 2778 case 0xd0:
2780 { 2779 {
2781 /** 0110 0001 1101 0000 and %0, %e1%1 */ 2780 /** 0110 0001 1101 0000 and %0, %e1%1 */
2782 if (trace) 2781 if (trace)
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
2824 case 0xd8: 2823 case 0xd8:
2825 { 2824 {
2826 /** 0110 0001 1101 1000 sk%c1 */ 2825 /** 0110 0001 1101 1000 sk%c1 */
2827 if (trace) 2826 if (trace)
2828 { 2827 {
2829 printf ("\033[33m%s\033[0m %02x %02x\n", 2828 printf ("\033[33m%s\033[0m %02x %02x\n",
2830 "/** 0110 0001 1101 1000 sk%c1 */", 2829 "/** 0110 0001 1101 1000 sk%c1 */",
2831 op[0], op[1]); 2830 op[0], op[1]);
2832 } 2831 }
2833 SYNTAX("sk%c1"); 2832 SYNTAX("sk%c1");
2834 #line 1071 "rl78-decode.opc" 2833 #line 1076 "rl78-decode.opc"
2835 ID(skip); COND(NC); 2834 ID(skip); COND(NC);
2836 2835
2837 } 2836 }
2838 break; 2837 break;
2839 case 0xd9: 2838 case 0xd9:
2840 { 2839 {
2841 /** 0110 0001 1101 1001 mov %e0%0, %1 */ 2840 /** 0110 0001 1101 1001 mov %e0%0, %1 */
2842 if (trace) 2841 if (trace)
2843 { 2842 {
2844 printf ("\033[33m%s\033[0m %02x %02x\n", 2843 printf ("\033[33m%s\033[0m %02x %02x\n",
2845 "/** 0110 0001 1101 1001 mov %e0%0, % 1 */", 2844 "/** 0110 0001 1101 1001 mov %e0%0, % 1 */",
2846 op[0], op[1]); 2845 op[0], op[1]);
2847 } 2846 }
2848 SYNTAX("mov %e0%0, %1"); 2847 SYNTAX("mov %e0%0, %1");
2849 #line 606 "rl78-decode.opc" 2848 #line 606 "rl78-decode.opc"
2850 ID(mov); DM2(HL, B, 0); SR(A); 2849 ID(mov); DM2(HL, B, 0); SR(A);
2851 2850
2852 } 2851 }
2853 break; 2852 break;
2854 case 0xdb: 2853 case 0xdb:
2855 { 2854 {
2856 /** 0110 0001 1101 1011 ror %0, %1 */ 2855 /** 0110 0001 1101 1011 ror %0, %1 */
2857 if (trace) 2856 if (trace)
2858 { 2857 {
2859 printf ("\033[33m%s\033[0m %02x %02x\n", 2858 printf ("\033[33m%s\033[0m %02x %02x\n",
2860 "/** 0110 0001 1101 1011 ror %0, %1 */", 2859 "/** 0110 0001 1101 1011 ror %0, %1 */",
2861 op[0], op[1]); 2860 op[0], op[1]);
2862 } 2861 }
2863 SYNTAX("ror %0, %1"); 2862 SYNTAX("ror %0, %1");
2864 #line 993 "rl78-decode.opc" 2863 #line 998 "rl78-decode.opc"
2865 ID(ror); DR(A); SC(1); 2864 ID(ror); DR(A); SC(1);
2866 2865
2867 } 2866 }
2868 break; 2867 break;
2869 case 0xdc: 2868 case 0xdc:
2870 { 2869 {
2871 /** 0110 0001 1101 1100 rolc %0, %1 */ 2870 /** 0110 0001 1101 1100 rolc %0, %1 */
2872 if (trace) 2871 if (trace)
2873 { 2872 {
2874 printf ("\033[33m%s\033[0m %02x %02x\n", 2873 printf ("\033[33m%s\033[0m %02x %02x\n",
2875 "/** 0110 0001 1101 1100 rolc %0, %1 */", 2874 "/** 0110 0001 1101 1100 rolc %0, %1 */",
2876 op[0], op[1]); 2875 op[0], op[1]);
2877 } 2876 }
2878 SYNTAX("rolc %0, %1"); 2877 SYNTAX("rolc %0, %1");
2879 #line 987 "rl78-decode.opc" 2878 #line 992 "rl78-decode.opc"
2880 ID(rolc); DR(A); SC(1); 2879 ID(rolc); DR(A); SC(1);
2881 2880
2882 } 2881 }
2883 break; 2882 break;
2884 case 0xdd: 2883 case 0xdd:
2885 { 2884 {
2886 /** 0110 0001 1101 1101 push %s1 */ 2885 /** 0110 0001 1101 1101 push %s1 */
2887 if (trace) 2886 if (trace)
2888 { 2887 {
2889 printf ("\033[33m%s\033[0m %02x %02x\n", 2888 printf ("\033[33m%s\033[0m %02x %02x\n",
2890 "/** 0110 0001 1101 1101 push %s1 */", 2889 "/** 0110 0001 1101 1101 push %s1 */",
2891 op[0], op[1]); 2890 op[0], op[1]);
2892 } 2891 }
2893 SYNTAX("push %s1"); 2892 SYNTAX("push %s1");
2894 #line 968 "rl78-decode.opc" 2893 #line 973 "rl78-decode.opc"
2895 ID(mov); W(); DPUSH(); SR(PSW); 2894 ID(mov); W(); DPUSH(); SR(PSW);
2896 2895
2897 /*---------------------------------------------------------------- ------*/ 2896 /*---------------------------------------------------------------- ------*/
2898 2897
2899 } 2898 }
2900 break; 2899 break;
2901 case 0xde: 2900 case 0xde:
2902 { 2901 {
2903 /** 0110 0001 1101 1110 cmps %0, %e1%1 */ 2902 /** 0110 0001 1101 1110 cmps %0, %e1%1 */
2904 if (trace) 2903 if (trace)
(...skipping 13 matching lines...) Expand all
2918 case 0xe0: 2917 case 0xe0:
2919 { 2918 {
2920 /** 0110 0001 1110 0000 or %0, %e1%1 */ 2919 /** 0110 0001 1110 0000 or %0, %e1%1 */
2921 if (trace) 2920 if (trace)
2922 { 2921 {
2923 printf ("\033[33m%s\033[0m %02x %02x\n", 2922 printf ("\033[33m%s\033[0m %02x %02x\n",
2924 "/** 0110 0001 1110 0000 or %0, %e1% 1 */", 2923 "/** 0110 0001 1110 0000 or %0, %e1% 1 */",
2925 op[0], op[1]); 2924 op[0], op[1]);
2926 } 2925 }
2927 SYNTAX("or %0, %e1%1"); 2926 SYNTAX("or %0, %e1%1");
2928 #line 917 "rl78-decode.opc" 2927 #line 922 "rl78-decode.opc"
2929 ID(or); DR(A); SM2(HL, B, 0); Fz; 2928 ID(or); DR(A); SM2(HL, B, 0); Fz;
2930 2929
2931 } 2930 }
2932 break; 2931 break;
2933 case 0xe2: 2932 case 0xe2:
2934 { 2933 {
2935 /** 0110 0001 1110 0010 or %0, %e1%1 */ 2934 /** 0110 0001 1110 0010 or %0, %e1%1 */
2936 if (trace) 2935 if (trace)
2937 { 2936 {
2938 printf ("\033[33m%s\033[0m %02x %02x\n", 2937 printf ("\033[33m%s\033[0m %02x %02x\n",
2939 "/** 0110 0001 1110 0010 or %0, %e1% 1 */", 2938 "/** 0110 0001 1110 0010 or %0, %e1% 1 */",
2940 op[0], op[1]); 2939 op[0], op[1]);
2941 } 2940 }
2942 SYNTAX("or %0, %e1%1"); 2941 SYNTAX("or %0, %e1%1");
2943 #line 923 "rl78-decode.opc" 2942 #line 928 "rl78-decode.opc"
2944 ID(or); DR(A); SM2(HL, C, 0); Fz; 2943 ID(or); DR(A); SM2(HL, C, 0); Fz;
2945 2944
2946 } 2945 }
2947 break; 2946 break;
2948 case 0xe3: 2947 case 0xe3:
2949 { 2948 {
2950 /** 0110 0001 1110 0011 sk%c1 */ 2949 /** 0110 0001 1110 0011 sk%c1 */
2951 if (trace) 2950 if (trace)
2952 { 2951 {
2953 printf ("\033[33m%s\033[0m %02x %02x\n", 2952 printf ("\033[33m%s\033[0m %02x %02x\n",
2954 "/** 0110 0001 1110 0011 sk%c1 */", 2953 "/** 0110 0001 1110 0011 sk%c1 */",
2955 op[0], op[1]); 2954 op[0], op[1]);
2956 } 2955 }
2957 SYNTAX("sk%c1"); 2956 SYNTAX("sk%c1");
2958 #line 1068 "rl78-decode.opc" 2957 #line 1073 "rl78-decode.opc"
2959 ID(skip); COND(H); 2958 ID(skip); COND(H);
2960 2959
2961 } 2960 }
2962 break; 2961 break;
2963 case 0xe8: 2962 case 0xe8:
2964 { 2963 {
2965 /** 0110 0001 1110 1000 sk%c1 */ 2964 /** 0110 0001 1110 1000 sk%c1 */
2966 if (trace) 2965 if (trace)
2967 { 2966 {
2968 printf ("\033[33m%s\033[0m %02x %02x\n", 2967 printf ("\033[33m%s\033[0m %02x %02x\n",
2969 "/** 0110 0001 1110 1000 sk%c1 */", 2968 "/** 0110 0001 1110 1000 sk%c1 */",
2970 op[0], op[1]); 2969 op[0], op[1]);
2971 } 2970 }
2972 SYNTAX("sk%c1"); 2971 SYNTAX("sk%c1");
2973 #line 1080 "rl78-decode.opc" 2972 #line 1085 "rl78-decode.opc"
2974 ID(skip); COND(Z); 2973 ID(skip); COND(Z);
2975 2974
2976 /*---------------------------------------------------------------- ------*/ 2975 /*---------------------------------------------------------------- ------*/
2977 2976
2978 } 2977 }
2979 break; 2978 break;
2980 case 0xe9: 2979 case 0xe9:
2981 { 2980 {
2982 /** 0110 0001 1110 1001 mov %0, %e1%1 */ 2981 /** 0110 0001 1110 1001 mov %0, %e1%1 */
2983 if (trace) 2982 if (trace)
(...skipping 11 matching lines...) Expand all
2995 case 0xeb: 2994 case 0xeb:
2996 { 2995 {
2997 /** 0110 0001 1110 1011 rol %0, %1 */ 2996 /** 0110 0001 1110 1011 rol %0, %1 */
2998 if (trace) 2997 if (trace)
2999 { 2998 {
3000 printf ("\033[33m%s\033[0m %02x %02x\n", 2999 printf ("\033[33m%s\033[0m %02x %02x\n",
3001 "/** 0110 0001 1110 1011 rol %0, %1 */", 3000 "/** 0110 0001 1110 1011 rol %0, %1 */",
3002 op[0], op[1]); 3001 op[0], op[1]);
3003 } 3002 }
3004 SYNTAX("rol %0, %1"); 3003 SYNTAX("rol %0, %1");
3005 #line 984 "rl78-decode.opc" 3004 #line 989 "rl78-decode.opc"
3006 ID(rol); DR(A); SC(1); 3005 ID(rol); DR(A); SC(1);
3007 3006
3008 } 3007 }
3009 break; 3008 break;
3010 case 0xec: 3009 case 0xec:
3011 { 3010 {
3012 /** 0110 0001 1110 1100 retb */ 3011 /** 0110 0001 1110 1100 retb */
3013 if (trace) 3012 if (trace)
3014 { 3013 {
3015 printf ("\033[33m%s\033[0m %02x %02x\n", 3014 printf ("\033[33m%s\033[0m %02x %02x\n",
3016 "/** 0110 0001 1110 1100 retb */", 3015 "/** 0110 0001 1110 1100 retb */",
3017 op[0], op[1]); 3016 op[0], op[1]);
3018 } 3017 }
3019 SYNTAX("retb"); 3018 SYNTAX("retb");
3020 #line 979 "rl78-decode.opc" 3019 #line 984 "rl78-decode.opc"
3021 ID(reti); 3020 ID(reti);
3022 3021
3023 /*---------------------------------------------------------------- ------*/ 3022 /*---------------------------------------------------------------- ------*/
3024 3023
3025 } 3024 }
3026 break; 3025 break;
3027 case 0xed: 3026 case 0xed:
3028 { 3027 {
3029 /** 0110 0001 1110 1101 halt */ 3028 /** 0110 0001 1110 1101 halt */
3030 if (trace) 3029 if (trace)
3031 { 3030 {
3032 printf ("\033[33m%s\033[0m %02x %02x\n", 3031 printf ("\033[33m%s\033[0m %02x %02x\n",
3033 "/** 0110 0001 1110 1101 halt */", 3032 "/** 0110 0001 1110 1101 halt */",
3034 op[0], op[1]); 3033 op[0], op[1]);
3035 } 3034 }
3036 SYNTAX("halt"); 3035 SYNTAX("halt");
3037 #line 555 "rl78-decode.opc" 3036 #line 555 "rl78-decode.opc"
3038 ID(halt); 3037 ID(halt);
3039 3038
3040 /*---------------------------------------------------------------- ------*/ 3039 /*---------------------------------------------------------------- ------*/
3041 3040
3042 } 3041 }
3043 break; 3042 break;
3044 case 0xee: 3043 case 0xee:
3045 case 0xfe: 3044 case 0xfe:
3046 { 3045 {
3047 /** 0110 0001 111r 1110 rolwc %0, %1 */ 3046 /** 0110 0001 111r 1110 rolwc %0, %1 */
3048 #line 990 "rl78-decode.opc" 3047 #line 995 "rl78-decode.opc"
3049 int r AU = (op[1] >> 4) & 0x01; 3048 int r AU = (op[1] >> 4) & 0x01;
3050 if (trace) 3049 if (trace)
3051 { 3050 {
3052 printf ("\033[33m%s\033[0m %02x %02x\n", 3051 printf ("\033[33m%s\033[0m %02x %02x\n",
3053 "/** 0110 0001 111r 1110 rolwc %0, %1 */", 3052 "/** 0110 0001 111r 1110 rolwc %0, %1 */",
3054 op[0], op[1]); 3053 op[0], op[1]);
3055 printf (" r = 0x%x\n", r); 3054 printf (" r = 0x%x\n", r);
3056 } 3055 }
3057 SYNTAX("rolwc %0, %1"); 3056 SYNTAX("rolwc %0, %1");
3058 #line 990 "rl78-decode.opc" 3057 #line 995 "rl78-decode.opc"
3059 ID(rolc); W(); DRW(r); SC(1); 3058 ID(rolc); W(); DRW(r); SC(1);
3060 3059
3061 } 3060 }
3062 break; 3061 break;
3063 case 0xf0: 3062 case 0xf0:
3064 { 3063 {
3065 /** 0110 0001 1111 0000 xor %0, %e1%1 */ 3064 /** 0110 0001 1111 0000 xor %0, %e1%1 */
3066 if (trace) 3065 if (trace)
3067 { 3066 {
3068 printf ("\033[33m%s\033[0m %02x %02x\n", 3067 printf ("\033[33m%s\033[0m %02x %02x\n",
3069 "/** 0110 0001 1111 0000 xor %0, %e1% 1 */", 3068 "/** 0110 0001 1111 0000 xor %0, %e1% 1 */",
3070 op[0], op[1]); 3069 op[0], op[1]);
3071 } 3070 }
3072 SYNTAX("xor %0, %e1%1"); 3071 SYNTAX("xor %0, %e1%1");
3073 #line 1221 "rl78-decode.opc" 3072 #line 1226 "rl78-decode.opc"
3074 ID(xor); DR(A); SM2(HL, B, 0); Fz; 3073 ID(xor); DR(A); SM2(HL, B, 0); Fz;
3075 3074
3076 } 3075 }
3077 break; 3076 break;
3078 case 0xf2: 3077 case 0xf2:
3079 { 3078 {
3080 /** 0110 0001 1111 0010 xor %0, %e1%1 */ 3079 /** 0110 0001 1111 0010 xor %0, %e1%1 */
3081 if (trace) 3080 if (trace)
3082 { 3081 {
3083 printf ("\033[33m%s\033[0m %02x %02x\n", 3082 printf ("\033[33m%s\033[0m %02x %02x\n",
3084 "/** 0110 0001 1111 0010 xor %0, %e1% 1 */", 3083 "/** 0110 0001 1111 0010 xor %0, %e1% 1 */",
3085 op[0], op[1]); 3084 op[0], op[1]);
3086 } 3085 }
3087 SYNTAX("xor %0, %e1%1"); 3086 SYNTAX("xor %0, %e1%1");
3088 #line 1227 "rl78-decode.opc" 3087 #line 1232 "rl78-decode.opc"
3089 ID(xor); DR(A); SM2(HL, C, 0); Fz; 3088 ID(xor); DR(A); SM2(HL, C, 0); Fz;
3090 3089
3091 } 3090 }
3092 break; 3091 break;
3093 case 0xf3: 3092 case 0xf3:
3094 { 3093 {
3095 /** 0110 0001 1111 0011 sk%c1 */ 3094 /** 0110 0001 1111 0011 sk%c1 */
3096 if (trace) 3095 if (trace)
3097 { 3096 {
3098 printf ("\033[33m%s\033[0m %02x %02x\n", 3097 printf ("\033[33m%s\033[0m %02x %02x\n",
3099 "/** 0110 0001 1111 0011 sk%c1 */", 3098 "/** 0110 0001 1111 0011 sk%c1 */",
3100 op[0], op[1]); 3099 op[0], op[1]);
3101 } 3100 }
3102 SYNTAX("sk%c1"); 3101 SYNTAX("sk%c1");
3103 #line 1074 "rl78-decode.opc" 3102 #line 1079 "rl78-decode.opc"
3104 ID(skip); COND(NH); 3103 ID(skip); COND(NH);
3105 3104
3106 } 3105 }
3107 break; 3106 break;
3108 case 0xf8: 3107 case 0xf8:
3109 { 3108 {
3110 /** 0110 0001 1111 1000 sk%c1 */ 3109 /** 0110 0001 1111 1000 sk%c1 */
3111 if (trace) 3110 if (trace)
3112 { 3111 {
3113 printf ("\033[33m%s\033[0m %02x %02x\n", 3112 printf ("\033[33m%s\033[0m %02x %02x\n",
3114 "/** 0110 0001 1111 1000 sk%c1 */", 3113 "/** 0110 0001 1111 1000 sk%c1 */",
3115 op[0], op[1]); 3114 op[0], op[1]);
3116 } 3115 }
3117 SYNTAX("sk%c1"); 3116 SYNTAX("sk%c1");
3118 #line 1077 "rl78-decode.opc" 3117 #line 1082 "rl78-decode.opc"
3119 ID(skip); COND(NZ); 3118 ID(skip); COND(NZ);
3120 3119
3121 } 3120 }
3122 break; 3121 break;
3123 case 0xf9: 3122 case 0xf9:
3124 { 3123 {
3125 /** 0110 0001 1111 1001 mov %e0%0, %1 */ 3124 /** 0110 0001 1111 1001 mov %e0%0, %1 */
3126 if (trace) 3125 if (trace)
3127 { 3126 {
3128 printf ("\033[33m%s\033[0m %02x %02x\n", 3127 printf ("\033[33m%s\033[0m %02x %02x\n",
3129 "/** 0110 0001 1111 1001 mov %e0%0, % 1 */", 3128 "/** 0110 0001 1111 1001 mov %e0%0, % 1 */",
3130 op[0], op[1]); 3129 op[0], op[1]);
3131 } 3130 }
3132 SYNTAX("mov %e0%0, %1"); 3131 SYNTAX("mov %e0%0, %1");
3133 #line 615 "rl78-decode.opc" 3132 #line 615 "rl78-decode.opc"
3134 ID(mov); DM2(HL, C, 0); SR(A); 3133 ID(mov); DM2(HL, C, 0); SR(A);
3135 3134
3136 } 3135 }
3137 break; 3136 break;
3138 case 0xfb: 3137 case 0xfb:
3139 { 3138 {
3140 /** 0110 0001 1111 1011 rorc %0, %1 */ 3139 /** 0110 0001 1111 1011 rorc %0, %1 */
3141 if (trace) 3140 if (trace)
3142 { 3141 {
3143 printf ("\033[33m%s\033[0m %02x %02x\n", 3142 printf ("\033[33m%s\033[0m %02x %02x\n",
3144 "/** 0110 0001 1111 1011 rorc %0, %1 */", 3143 "/** 0110 0001 1111 1011 rorc %0, %1 */",
3145 op[0], op[1]); 3144 op[0], op[1]);
3146 } 3145 }
3147 SYNTAX("rorc %0, %1"); 3146 SYNTAX("rorc %0, %1");
3148 #line 996 "rl78-decode.opc" 3147 #line 1001 "rl78-decode.opc"
3149 ID(rorc); DR(A); SC(1); 3148 ID(rorc); DR(A); SC(1);
3150 3149
3151 /*---------------------------------------------------------------- ------*/ 3150 /*---------------------------------------------------------------- ------*/
3152 3151
3153 /* Note that the branch insns need to be listed before the shift 3152 /* Note that the branch insns need to be listed before the shift
3154 ones, as "shift count of zero" means "branch insn" */ 3153 ones, as "shift count of zero" means "branch insn" */
3155 3154
3156 } 3155 }
3157 break; 3156 break;
3158 case 0xfc: 3157 case 0xfc:
3159 { 3158 {
3160 /** 0110 0001 1111 1100 reti */ 3159 /** 0110 0001 1111 1100 reti */
3161 if (trace) 3160 if (trace)
3162 { 3161 {
3163 printf ("\033[33m%s\033[0m %02x %02x\n", 3162 printf ("\033[33m%s\033[0m %02x %02x\n",
3164 "/** 0110 0001 1111 1100 reti */", 3163 "/** 0110 0001 1111 1100 reti */",
3165 op[0], op[1]); 3164 op[0], op[1]);
3166 } 3165 }
3167 SYNTAX("reti"); 3166 SYNTAX("reti");
3168 #line 976 "rl78-decode.opc" 3167 #line 981 "rl78-decode.opc"
3169 ID(reti); 3168 ID(reti);
3170 3169
3171 } 3170 }
3172 break; 3171 break;
3173 case 0xfd: 3172 case 0xfd:
3174 { 3173 {
3175 /** 0110 0001 1111 1101 stop */ 3174 /** 0110 0001 1111 1101 stop */
3176 if (trace) 3175 if (trace)
3177 { 3176 {
3178 printf ("\033[33m%s\033[0m %02x %02x\n", 3177 printf ("\033[33m%s\033[0m %02x %02x\n",
3179 "/** 0110 0001 1111 1101 stop */", 3178 "/** 0110 0001 1111 1101 stop */",
3180 op[0], op[1]); 3179 op[0], op[1]);
3181 } 3180 }
3182 SYNTAX("stop"); 3181 SYNTAX("stop");
3183 #line 1085 "rl78-decode.opc" 3182 #line 1090 "rl78-decode.opc"
3184 ID(stop); 3183 ID(stop);
3185 3184
3186 /*---------------------------------------------------------------- ------*/ 3185 /*---------------------------------------------------------------- ------*/
3187 3186
3188 } 3187 }
3189 break; 3188 break;
3190 default: UNSUPPORTED(); break; 3189 default: UNSUPPORTED(); break;
3191 } 3190 }
3192 break; 3191 break;
3193 case 0x68: 3192 case 0x68:
(...skipping 29 matching lines...) Expand all
3223 case 0x6a: 3222 case 0x6a:
3224 { 3223 {
3225 /** 0110 1010 or %0, #%1 */ 3224 /** 0110 1010 or %0, #%1 */
3226 if (trace) 3225 if (trace)
3227 { 3226 {
3228 printf ("\033[33m%s\033[0m %02x\n", 3227 printf ("\033[33m%s\033[0m %02x\n",
3229 "/** 0110 1010 or %0, #%1 */", 3228 "/** 0110 1010 or %0, #%1 */",
3230 op[0]); 3229 op[0]);
3231 } 3230 }
3232 SYNTAX("or %0, #%1"); 3231 SYNTAX("or %0, #%1");
3233 #line 938 "rl78-decode.opc" 3232 #line 943 "rl78-decode.opc"
3234 ID(or); DM(None, SADDR); SC(IMMU(1)); Fz; 3233 ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
3235 3234
3236 /*---------------------------------------------------------------------- */ 3235 /*---------------------------------------------------------------------- */
3237 3236
3238 } 3237 }
3239 break; 3238 break;
3240 case 0x6b: 3239 case 0x6b:
3241 { 3240 {
3242 /** 0110 1011 or %0, %1 */ 3241 /** 0110 1011 or %0, %1 */
3243 if (trace) 3242 if (trace)
3244 { 3243 {
3245 printf ("\033[33m%s\033[0m %02x\n", 3244 printf ("\033[33m%s\033[0m %02x\n",
3246 "/** 0110 1011 or %0, %1 */", 3245 "/** 0110 1011 or %0, %1 */",
3247 op[0]); 3246 op[0]);
3248 } 3247 }
3249 SYNTAX("or %0, %1"); 3248 SYNTAX("or %0, %1");
3250 #line 935 "rl78-decode.opc" 3249 #line 940 "rl78-decode.opc"
3251 ID(or); DR(A); SM(None, SADDR); Fz; 3250 ID(or); DR(A); SM(None, SADDR); Fz;
3252 3251
3253 } 3252 }
3254 break; 3253 break;
3255 case 0x6c: 3254 case 0x6c:
3256 { 3255 {
3257 /** 0110 1100 or %0, #%1 */ 3256 /** 0110 1100 or %0, #%1 */
3258 if (trace) 3257 if (trace)
3259 { 3258 {
3260 printf ("\033[33m%s\033[0m %02x\n", 3259 printf ("\033[33m%s\033[0m %02x\n",
3261 "/** 0110 1100 or %0, #%1 */", 3260 "/** 0110 1100 or %0, #%1 */",
3262 op[0]); 3261 op[0]);
3263 } 3262 }
3264 SYNTAX("or %0, #%1"); 3263 SYNTAX("or %0, #%1");
3265 #line 926 "rl78-decode.opc" 3264 #line 931 "rl78-decode.opc"
3266 ID(or); DR(A); SC(IMMU(1)); Fz; 3265 ID(or); DR(A); SC(IMMU(1)); Fz;
3267 3266
3268 } 3267 }
3269 break; 3268 break;
3270 case 0x6d: 3269 case 0x6d:
3271 { 3270 {
3272 /** 0110 1101 or %0, %e1%1 */ 3271 /** 0110 1101 or %0, %e1%1 */
3273 if (trace) 3272 if (trace)
3274 { 3273 {
3275 printf ("\033[33m%s\033[0m %02x\n", 3274 printf ("\033[33m%s\033[0m %02x\n",
3276 "/** 0110 1101 or %0, %e1%1 */", 3275 "/** 0110 1101 or %0, %e1%1 */",
3277 op[0]); 3276 op[0]);
3278 } 3277 }
3279 SYNTAX("or %0, %e1%1"); 3278 SYNTAX("or %0, %e1%1");
3280 #line 914 "rl78-decode.opc" 3279 #line 919 "rl78-decode.opc"
3281 ID(or); DR(A); SM(HL, 0); Fz; 3280 ID(or); DR(A); SM(HL, 0); Fz;
3282 3281
3283 } 3282 }
3284 break; 3283 break;
3285 case 0x6e: 3284 case 0x6e:
3286 { 3285 {
3287 /** 0110 1110 or %0, %e1%1 */ 3286 /** 0110 1110 or %0, %e1%1 */
3288 if (trace) 3287 if (trace)
3289 { 3288 {
3290 printf ("\033[33m%s\033[0m %02x\n", 3289 printf ("\033[33m%s\033[0m %02x\n",
3291 "/** 0110 1110 or %0, %e1%1 */", 3290 "/** 0110 1110 or %0, %e1%1 */",
3292 op[0]); 3291 op[0]);
3293 } 3292 }
3294 SYNTAX("or %0, %e1%1"); 3293 SYNTAX("or %0, %e1%1");
3295 #line 920 "rl78-decode.opc" 3294 #line 925 "rl78-decode.opc"
3296 ID(or); DR(A); SM(HL, IMMU(1)); Fz; 3295 ID(or); DR(A); SM(HL, IMMU(1)); Fz;
3297 3296
3298 } 3297 }
3299 break; 3298 break;
3300 case 0x6f: 3299 case 0x6f:
3301 { 3300 {
3302 /** 0110 1111 or %0, %e1%!1 */ 3301 /** 0110 1111 or %0, %e1%!1 */
3303 if (trace) 3302 if (trace)
3304 { 3303 {
3305 printf ("\033[33m%s\033[0m %02x\n", 3304 printf ("\033[33m%s\033[0m %02x\n",
3306 "/** 0110 1111 or %0, %e1%!1 */", 3305 "/** 0110 1111 or %0, %e1%!1 */",
3307 op[0]); 3306 op[0]);
3308 } 3307 }
3309 SYNTAX("or %0, %e1%!1"); 3308 SYNTAX("or %0, %e1%!1");
3310 #line 911 "rl78-decode.opc" 3309 #line 916 "rl78-decode.opc"
3311 ID(or); DR(A); SM(None, IMMU(2)); Fz; 3310 ID(or); DR(A); SM(None, IMMU(2)); Fz;
3312 3311
3313 } 3312 }
3314 break; 3313 break;
3315 case 0x70: 3314 case 0x70:
3316 case 0x72: 3315 case 0x72:
3317 case 0x73: 3316 case 0x73:
3318 case 0x74: 3317 case 0x74:
3319 case 0x75: 3318 case 0x75:
3320 case 0x76: 3319 case 0x76:
(...skipping 22 matching lines...) Expand all
3343 case 0x00: 3342 case 0x00:
3344 case 0x10: 3343 case 0x10:
3345 case 0x20: 3344 case 0x20:
3346 case 0x30: 3345 case 0x30:
3347 case 0x40: 3346 case 0x40:
3348 case 0x50: 3347 case 0x50:
3349 case 0x60: 3348 case 0x60:
3350 case 0x70: 3349 case 0x70:
3351 { 3350 {
3352 /** 0111 0001 0bit 0000 set1 %e0%!0 */ 3351 /** 0111 0001 0bit 0000 set1 %e0%!0 */
3353 #line 1017 "rl78-decode.opc" 3352 #line 1022 "rl78-decode.opc"
3354 int bit AU = (op[1] >> 4) & 0x07; 3353 int bit AU = (op[1] >> 4) & 0x07;
3355 if (trace) 3354 if (trace)
3356 { 3355 {
3357 printf ("\033[33m%s\033[0m %02x %02x\n", 3356 printf ("\033[33m%s\033[0m %02x %02x\n",
3358 "/** 0111 0001 0bit 0000 set1 %e0%!0 */", 3357 "/** 0111 0001 0bit 0000 set1 %e0%!0 */",
3359 op[0], op[1]); 3358 op[0], op[1]);
3360 printf (" bit = 0x%x\n", bit); 3359 printf (" bit = 0x%x\n", bit);
3361 } 3360 }
3362 SYNTAX("set1 %e0%!0"); 3361 SYNTAX("set1 %e0%!0");
3363 #line 1017 "rl78-decode.opc" 3362 #line 1022 "rl78-decode.opc"
3364 ID(mov); DM(None, IMMU(2)); DB(bit); SC(1); 3363 ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
3365 3364
3366 } 3365 }
3367 break; 3366 break;
3368 case 0x01: 3367 case 0x01:
3369 case 0x11: 3368 case 0x11:
3370 case 0x21: 3369 case 0x21:
3371 case 0x31: 3370 case 0x31:
3372 case 0x41: 3371 case 0x41:
3373 case 0x51: 3372 case 0x51:
(...skipping 19 matching lines...) Expand all
3393 case 0x02: 3392 case 0x02:
3394 case 0x12: 3393 case 0x12:
3395 case 0x22: 3394 case 0x22:
3396 case 0x32: 3395 case 0x32:
3397 case 0x42: 3396 case 0x42:
3398 case 0x52: 3397 case 0x52:
3399 case 0x62: 3398 case 0x62:
3400 case 0x72: 3399 case 0x72:
3401 { 3400 {
3402 /** 0111 0001 0bit 0010 set1 %0 */ 3401 /** 0111 0001 0bit 0010 set1 %0 */
3403 #line 1035 "rl78-decode.opc" 3402 #line 1040 "rl78-decode.opc"
3404 int bit AU = (op[1] >> 4) & 0x07; 3403 int bit AU = (op[1] >> 4) & 0x07;
3405 if (trace) 3404 if (trace)
3406 { 3405 {
3407 printf ("\033[33m%s\033[0m %02x %02x\n", 3406 printf ("\033[33m%s\033[0m %02x %02x\n",
3408 "/** 0111 0001 0bit 0010 set1 %0 */", 3407 "/** 0111 0001 0bit 0010 set1 %0 */",
3409 op[0], op[1]); 3408 op[0], op[1]);
3410 printf (" bit = 0x%x\n", bit); 3409 printf (" bit = 0x%x\n", bit);
3411 } 3410 }
3412 SYNTAX("set1 %0"); 3411 SYNTAX("set1 %0");
3413 #line 1035 "rl78-decode.opc" 3412 #line 1040 "rl78-decode.opc"
3414 ID(mov); DM(None, SADDR); DB(bit); SC(1); 3413 ID(mov); DM(None, SADDR); DB(bit); SC(1);
3415 3414
3416 /*---------------------------------------------------------------- ------*/ 3415 /*---------------------------------------------------------------- ------*/
3417 3416
3418 } 3417 }
3419 break; 3418 break;
3420 case 0x03: 3419 case 0x03:
3421 case 0x13: 3420 case 0x13:
3422 case 0x23: 3421 case 0x23:
3423 case 0x33: 3422 case 0x33:
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after
3502 case 0x06: 3501 case 0x06:
3503 case 0x16: 3502 case 0x16:
3504 case 0x26: 3503 case 0x26:
3505 case 0x36: 3504 case 0x36:
3506 case 0x46: 3505 case 0x46:
3507 case 0x56: 3506 case 0x56:
3508 case 0x66: 3507 case 0x66:
3509 case 0x76: 3508 case 0x76:
3510 { 3509 {
3511 /** 0111 0001 0bit 0110 or1 cy, %s1 */ 3510 /** 0111 0001 0bit 0110 or1 cy, %s1 */
3512 #line 952 "rl78-decode.opc" 3511 #line 957 "rl78-decode.opc"
3513 int bit AU = (op[1] >> 4) & 0x07; 3512 int bit AU = (op[1] >> 4) & 0x07;
3514 if (trace) 3513 if (trace)
3515 { 3514 {
3516 printf ("\033[33m%s\033[0m %02x %02x\n", 3515 printf ("\033[33m%s\033[0m %02x %02x\n",
3517 "/** 0111 0001 0bit 0110 or1 cy, %s1 */", 3516 "/** 0111 0001 0bit 0110 or1 cy, %s1 */",
3518 op[0], op[1]); 3517 op[0], op[1]);
3519 printf (" bit = 0x%x\n", bit); 3518 printf (" bit = 0x%x\n", bit);
3520 } 3519 }
3521 SYNTAX("or1 cy, %s1"); 3520 SYNTAX("or1 cy, %s1");
3522 #line 952 "rl78-decode.opc" 3521 #line 957 "rl78-decode.opc"
3523 ID(or); DCY(); SM(None, SADDR); SB(bit); 3522 ID(or); DCY(); SM(None, SADDR); SB(bit);
3524 3523
3525 /*---------------------------------------------------------------- ------*/ 3524 /*---------------------------------------------------------------- ------*/
3526 3525
3527 } 3526 }
3528 break; 3527 break;
3529 case 0x07: 3528 case 0x07:
3530 case 0x17: 3529 case 0x17:
3531 case 0x27: 3530 case 0x27:
3532 case 0x37: 3531 case 0x37:
3533 case 0x47: 3532 case 0x47:
3534 case 0x57: 3533 case 0x57:
3535 case 0x67: 3534 case 0x67:
3536 case 0x77: 3535 case 0x77:
3537 { 3536 {
3538 /** 0111 0001 0bit 0111 xor1 cy, %s1 */ 3537 /** 0111 0001 0bit 0111 xor1 cy, %s1 */
3539 #line 1256 "rl78-decode.opc" 3538 #line 1261 "rl78-decode.opc"
3540 int bit AU = (op[1] >> 4) & 0x07; 3539 int bit AU = (op[1] >> 4) & 0x07;
3541 if (trace) 3540 if (trace)
3542 { 3541 {
3543 printf ("\033[33m%s\033[0m %02x %02x\n", 3542 printf ("\033[33m%s\033[0m %02x %02x\n",
3544 "/** 0111 0001 0bit 0111 xor1 cy, %s1 */", 3543 "/** 0111 0001 0bit 0111 xor1 cy, %s1 */",
3545 op[0], op[1]); 3544 op[0], op[1]);
3546 printf (" bit = 0x%x\n", bit); 3545 printf (" bit = 0x%x\n", bit);
3547 } 3546 }
3548 SYNTAX("xor1 cy, %s1"); 3547 SYNTAX("xor1 cy, %s1");
3549 #line 1256 "rl78-decode.opc" 3548 #line 1261 "rl78-decode.opc"
3550 ID(xor); DCY(); SM(None, SADDR); SB(bit); 3549 ID(xor); DCY(); SM(None, SADDR); SB(bit);
3551 3550
3552 /*---------------------------------------------------------------- ------*/ 3551 /*---------------------------------------------------------------- ------*/
3553 3552
3554 } 3553 }
3555 break; 3554 break;
3556 case 0x08: 3555 case 0x08:
3557 case 0x18: 3556 case 0x18:
3558 case 0x28: 3557 case 0x28:
3559 case 0x38: 3558 case 0x38:
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
3608 case 0x0a: 3607 case 0x0a:
3609 case 0x1a: 3608 case 0x1a:
3610 case 0x2a: 3609 case 0x2a:
3611 case 0x3a: 3610 case 0x3a:
3612 case 0x4a: 3611 case 0x4a:
3613 case 0x5a: 3612 case 0x5a:
3614 case 0x6a: 3613 case 0x6a:
3615 case 0x7a: 3614 case 0x7a:
3616 { 3615 {
3617 /** 0111 0001 0bit 1010 set1 %s0 */ 3616 /** 0111 0001 0bit 1010 set1 %s0 */
3618 #line 1029 "rl78-decode.opc" 3617 #line 1034 "rl78-decode.opc"
3619 int bit AU = (op[1] >> 4) & 0x07; 3618 int bit AU = (op[1] >> 4) & 0x07;
3620 if (trace) 3619 if (trace)
3621 { 3620 {
3622 printf ("\033[33m%s\033[0m %02x %02x\n", 3621 printf ("\033[33m%s\033[0m %02x %02x\n",
3623 "/** 0111 0001 0bit 1010 set1 %s0 */", 3622 "/** 0111 0001 0bit 1010 set1 %s0 */",
3624 op[0], op[1]); 3623 op[0], op[1]);
3625 printf (" bit = 0x%x\n", bit); 3624 printf (" bit = 0x%x\n", bit);
3626 } 3625 }
3627 SYNTAX("set1 %s0"); 3626 SYNTAX("set1 %s0");
3628 #line 1029 "rl78-decode.opc" 3627 #line 1034 "rl78-decode.opc"
3629 op0 = SFR; 3628 op0 = SFR;
3630 ID(mov); DM(None, op0); DB(bit); SC(1); 3629 ID(mov); DM(None, op0); DB(bit); SC(1);
3631 if (op0 == RL78_SFR_PSW && bit == 7) 3630 if (op0 == RL78_SFR_PSW && bit == 7)
3632 rl78->syntax = "ei"; 3631 rl78->syntax = "ei";
3633 3632
3634 } 3633 }
3635 break; 3634 break;
3636 case 0x0b: 3635 case 0x0b:
3637 case 0x1b: 3636 case 0x1b:
3638 case 0x2b: 3637 case 0x2b:
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
3714 case 0x0e: 3713 case 0x0e:
3715 case 0x1e: 3714 case 0x1e:
3716 case 0x2e: 3715 case 0x2e:
3717 case 0x3e: 3716 case 0x3e:
3718 case 0x4e: 3717 case 0x4e:
3719 case 0x5e: 3718 case 0x5e:
3720 case 0x6e: 3719 case 0x6e:
3721 case 0x7e: 3720 case 0x7e:
3722 { 3721 {
3723 /** 0111 0001 0bit 1110 or1 cy, %s1 */ 3722 /** 0111 0001 0bit 1110 or1 cy, %s1 */
3724 #line 949 "rl78-decode.opc" 3723 #line 954 "rl78-decode.opc"
3725 int bit AU = (op[1] >> 4) & 0x07; 3724 int bit AU = (op[1] >> 4) & 0x07;
3726 if (trace) 3725 if (trace)
3727 { 3726 {
3728 printf ("\033[33m%s\033[0m %02x %02x\n", 3727 printf ("\033[33m%s\033[0m %02x %02x\n",
3729 "/** 0111 0001 0bit 1110 or1 cy, %s1 */", 3728 "/** 0111 0001 0bit 1110 or1 cy, %s1 */",
3730 op[0], op[1]); 3729 op[0], op[1]);
3731 printf (" bit = 0x%x\n", bit); 3730 printf (" bit = 0x%x\n", bit);
3732 } 3731 }
3733 SYNTAX("or1 cy, %s1"); 3732 SYNTAX("or1 cy, %s1");
3734 #line 949 "rl78-decode.opc" 3733 #line 954 "rl78-decode.opc"
3735 ID(or); DCY(); SM(None, SFR); SB(bit); 3734 ID(or); DCY(); SM(None, SFR); SB(bit);
3736 3735
3737 } 3736 }
3738 break; 3737 break;
3739 case 0x0f: 3738 case 0x0f:
3740 case 0x1f: 3739 case 0x1f:
3741 case 0x2f: 3740 case 0x2f:
3742 case 0x3f: 3741 case 0x3f:
3743 case 0x4f: 3742 case 0x4f:
3744 case 0x5f: 3743 case 0x5f:
3745 case 0x6f: 3744 case 0x6f:
3746 case 0x7f: 3745 case 0x7f:
3747 { 3746 {
3748 /** 0111 0001 0bit 1111 xor1 cy, %s1 */ 3747 /** 0111 0001 0bit 1111 xor1 cy, %s1 */
3749 #line 1253 "rl78-decode.opc" 3748 #line 1258 "rl78-decode.opc"
3750 int bit AU = (op[1] >> 4) & 0x07; 3749 int bit AU = (op[1] >> 4) & 0x07;
3751 if (trace) 3750 if (trace)
3752 { 3751 {
3753 printf ("\033[33m%s\033[0m %02x %02x\n", 3752 printf ("\033[33m%s\033[0m %02x %02x\n",
3754 "/** 0111 0001 0bit 1111 xor1 cy, %s1 */", 3753 "/** 0111 0001 0bit 1111 xor1 cy, %s1 */",
3755 op[0], op[1]); 3754 op[0], op[1]);
3756 printf (" bit = 0x%x\n", bit); 3755 printf (" bit = 0x%x\n", bit);
3757 } 3756 }
3758 SYNTAX("xor1 cy, %s1"); 3757 SYNTAX("xor1 cy, %s1");
3759 #line 1253 "rl78-decode.opc" 3758 #line 1258 "rl78-decode.opc"
3760 ID(xor); DCY(); SM(None, SFR); SB(bit); 3759 ID(xor); DCY(); SM(None, SFR); SB(bit);
3761 3760
3762 } 3761 }
3763 break; 3762 break;
3764 case 0x80: 3763 case 0x80:
3765 { 3764 {
3766 /** 0111 0001 1000 0000 set1 cy */ 3765 /** 0111 0001 1000 0000 set1 cy */
3767 if (trace) 3766 if (trace)
3768 { 3767 {
3769 printf ("\033[33m%s\033[0m %02x %02x\n", 3768 printf ("\033[33m%s\033[0m %02x %02x\n",
3770 "/** 0111 0001 1000 0000 set1 cy */", 3769 "/** 0111 0001 1000 0000 set1 cy */",
3771 op[0], op[1]); 3770 op[0], op[1]);
3772 } 3771 }
3773 SYNTAX("set1 cy"); 3772 SYNTAX("set1 cy");
3774 #line 1026 "rl78-decode.opc" 3773 #line 1031 "rl78-decode.opc"
3775 ID(mov); DCY(); SC(1); 3774 ID(mov); DCY(); SC(1);
3776 3775
3777 } 3776 }
3778 break; 3777 break;
3779 case 0x81: 3778 case 0x81:
3780 case 0x91: 3779 case 0x91:
3781 case 0xa1: 3780 case 0xa1:
3782 case 0xb1: 3781 case 0xb1:
3783 case 0xc1: 3782 case 0xc1:
3784 case 0xd1: 3783 case 0xd1:
(...skipping 19 matching lines...) Expand all
3804 case 0x82: 3803 case 0x82:
3805 case 0x92: 3804 case 0x92:
3806 case 0xa2: 3805 case 0xa2:
3807 case 0xb2: 3806 case 0xb2:
3808 case 0xc2: 3807 case 0xc2:
3809 case 0xd2: 3808 case 0xd2:
3810 case 0xe2: 3809 case 0xe2:
3811 case 0xf2: 3810 case 0xf2:
3812 { 3811 {
3813 /** 0111 0001 1bit 0010 set1 %e0%0 */ 3812 /** 0111 0001 1bit 0010 set1 %e0%0 */
3814 #line 1020 "rl78-decode.opc" 3813 #line 1025 "rl78-decode.opc"
3815 int bit AU = (op[1] >> 4) & 0x07; 3814 int bit AU = (op[1] >> 4) & 0x07;
3816 if (trace) 3815 if (trace)
3817 { 3816 {
3818 printf ("\033[33m%s\033[0m %02x %02x\n", 3817 printf ("\033[33m%s\033[0m %02x %02x\n",
3819 "/** 0111 0001 1bit 0010 set1 %e0%0 */", 3818 "/** 0111 0001 1bit 0010 set1 %e0%0 */",
3820 op[0], op[1]); 3819 op[0], op[1]);
3821 printf (" bit = 0x%x\n", bit); 3820 printf (" bit = 0x%x\n", bit);
3822 } 3821 }
3823 SYNTAX("set1 %e0%0"); 3822 SYNTAX("set1 %e0%0");
3824 #line 1020 "rl78-decode.opc" 3823 #line 1025 "rl78-decode.opc"
3825 ID(mov); DM(HL, 0); DB(bit); SC(1); 3824 ID(mov); DM(HL, 0); DB(bit); SC(1);
3826 3825
3827 } 3826 }
3828 break; 3827 break;
3829 case 0x83: 3828 case 0x83:
3830 case 0x93: 3829 case 0x93:
3831 case 0xa3: 3830 case 0xa3:
3832 case 0xb3: 3831 case 0xb3:
3833 case 0xc3: 3832 case 0xc3:
3834 case 0xd3: 3833 case 0xd3:
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
3904 case 0x86: 3903 case 0x86:
3905 case 0x96: 3904 case 0x96:
3906 case 0xa6: 3905 case 0xa6:
3907 case 0xb6: 3906 case 0xb6:
3908 case 0xc6: 3907 case 0xc6:
3909 case 0xd6: 3908 case 0xd6:
3910 case 0xe6: 3909 case 0xe6:
3911 case 0xf6: 3910 case 0xf6:
3912 { 3911 {
3913 /** 0111 0001 1bit 0110 or1 cy, %e1%1 */ 3912 /** 0111 0001 1bit 0110 or1 cy, %e1%1 */
3914 #line 943 "rl78-decode.opc" 3913 #line 948 "rl78-decode.opc"
3915 int bit AU = (op[1] >> 4) & 0x07; 3914 int bit AU = (op[1] >> 4) & 0x07;
3916 if (trace) 3915 if (trace)
3917 { 3916 {
3918 printf ("\033[33m%s\033[0m %02x %02x\n", 3917 printf ("\033[33m%s\033[0m %02x %02x\n",
3919 "/** 0111 0001 1bit 0110 or1 cy, %e1% 1 */", 3918 "/** 0111 0001 1bit 0110 or1 cy, %e1% 1 */",
3920 op[0], op[1]); 3919 op[0], op[1]);
3921 printf (" bit = 0x%x\n", bit); 3920 printf (" bit = 0x%x\n", bit);
3922 } 3921 }
3923 SYNTAX("or1 cy, %e1%1"); 3922 SYNTAX("or1 cy, %e1%1");
3924 #line 943 "rl78-decode.opc" 3923 #line 948 "rl78-decode.opc"
3925 ID(or); DCY(); SM(HL, 0); SB(bit); 3924 ID(or); DCY(); SM(HL, 0); SB(bit);
3926 3925
3927 } 3926 }
3928 break; 3927 break;
3929 case 0x87: 3928 case 0x87:
3930 case 0x97: 3929 case 0x97:
3931 case 0xa7: 3930 case 0xa7:
3932 case 0xb7: 3931 case 0xb7:
3933 case 0xc7: 3932 case 0xc7:
3934 case 0xd7: 3933 case 0xd7:
3935 case 0xe7: 3934 case 0xe7:
3936 case 0xf7: 3935 case 0xf7:
3937 { 3936 {
3938 /** 0111 0001 1bit 0111 xor1 cy, %e1%1 */ 3937 /** 0111 0001 1bit 0111 xor1 cy, %e1%1 */
3939 #line 1247 "rl78-decode.opc" 3938 #line 1252 "rl78-decode.opc"
3940 int bit AU = (op[1] >> 4) & 0x07; 3939 int bit AU = (op[1] >> 4) & 0x07;
3941 if (trace) 3940 if (trace)
3942 { 3941 {
3943 printf ("\033[33m%s\033[0m %02x %02x\n", 3942 printf ("\033[33m%s\033[0m %02x %02x\n",
3944 "/** 0111 0001 1bit 0111 xor1 cy, %e1% 1 */", 3943 "/** 0111 0001 1bit 0111 xor1 cy, %e1% 1 */",
3945 op[0], op[1]); 3944 op[0], op[1]);
3946 printf (" bit = 0x%x\n", bit); 3945 printf (" bit = 0x%x\n", bit);
3947 } 3946 }
3948 SYNTAX("xor1 cy, %e1%1"); 3947 SYNTAX("xor1 cy, %e1%1");
3949 #line 1247 "rl78-decode.opc" 3948 #line 1252 "rl78-decode.opc"
3950 ID(xor); DCY(); SM(HL, 0); SB(bit); 3949 ID(xor); DCY(); SM(HL, 0); SB(bit);
3951 3950
3952 } 3951 }
3953 break; 3952 break;
3954 case 0x88: 3953 case 0x88:
3955 { 3954 {
3956 /** 0111 0001 1000 1000 clr1 cy */ 3955 /** 0111 0001 1000 1000 clr1 cy */
3957 if (trace) 3956 if (trace)
3958 { 3957 {
3959 printf ("\033[33m%s\033[0m %02x %02x\n", 3958 printf ("\033[33m%s\033[0m %02x %02x\n",
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
3994 case 0x8a: 3993 case 0x8a:
3995 case 0x9a: 3994 case 0x9a:
3996 case 0xaa: 3995 case 0xaa:
3997 case 0xba: 3996 case 0xba:
3998 case 0xca: 3997 case 0xca:
3999 case 0xda: 3998 case 0xda:
4000 case 0xea: 3999 case 0xea:
4001 case 0xfa: 4000 case 0xfa:
4002 { 4001 {
4003 /** 0111 0001 1bit 1010 set1 %0 */ 4002 /** 0111 0001 1bit 1010 set1 %0 */
4004 #line 1023 "rl78-decode.opc" 4003 #line 1028 "rl78-decode.opc"
4005 int bit AU = (op[1] >> 4) & 0x07; 4004 int bit AU = (op[1] >> 4) & 0x07;
4006 if (trace) 4005 if (trace)
4007 { 4006 {
4008 printf ("\033[33m%s\033[0m %02x %02x\n", 4007 printf ("\033[33m%s\033[0m %02x %02x\n",
4009 "/** 0111 0001 1bit 1010 set1 %0 */", 4008 "/** 0111 0001 1bit 1010 set1 %0 */",
4010 op[0], op[1]); 4009 op[0], op[1]);
4011 printf (" bit = 0x%x\n", bit); 4010 printf (" bit = 0x%x\n", bit);
4012 } 4011 }
4013 SYNTAX("set1 %0"); 4012 SYNTAX("set1 %0");
4014 #line 1023 "rl78-decode.opc" 4013 #line 1028 "rl78-decode.opc"
4015 ID(mov); DR(A); DB(bit); SC(1); 4014 ID(mov); DR(A); DB(bit); SC(1);
4016 4015
4017 } 4016 }
4018 break; 4017 break;
4019 case 0x8b: 4018 case 0x8b:
4020 case 0x9b: 4019 case 0x9b:
4021 case 0xab: 4020 case 0xab:
4022 case 0xbb: 4021 case 0xbb:
4023 case 0xcb: 4022 case 0xcb:
4024 case 0xdb: 4023 case 0xdb:
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
4094 case 0x8e: 4093 case 0x8e:
4095 case 0x9e: 4094 case 0x9e:
4096 case 0xae: 4095 case 0xae:
4097 case 0xbe: 4096 case 0xbe:
4098 case 0xce: 4097 case 0xce:
4099 case 0xde: 4098 case 0xde:
4100 case 0xee: 4099 case 0xee:
4101 case 0xfe: 4100 case 0xfe:
4102 { 4101 {
4103 /** 0111 0001 1bit 1110 or1 cy, %1 */ 4102 /** 0111 0001 1bit 1110 or1 cy, %1 */
4104 #line 946 "rl78-decode.opc" 4103 #line 951 "rl78-decode.opc"
4105 int bit AU = (op[1] >> 4) & 0x07; 4104 int bit AU = (op[1] >> 4) & 0x07;
4106 if (trace) 4105 if (trace)
4107 { 4106 {
4108 printf ("\033[33m%s\033[0m %02x %02x\n", 4107 printf ("\033[33m%s\033[0m %02x %02x\n",
4109 "/** 0111 0001 1bit 1110 or1 cy, %1 */", 4108 "/** 0111 0001 1bit 1110 or1 cy, %1 */",
4110 op[0], op[1]); 4109 op[0], op[1]);
4111 printf (" bit = 0x%x\n", bit); 4110 printf (" bit = 0x%x\n", bit);
4112 } 4111 }
4113 SYNTAX("or1 cy, %1"); 4112 SYNTAX("or1 cy, %1");
4114 #line 946 "rl78-decode.opc" 4113 #line 951 "rl78-decode.opc"
4115 ID(or); DCY(); SR(A); SB(bit); 4114 ID(or); DCY(); SR(A); SB(bit);
4116 4115
4117 } 4116 }
4118 break; 4117 break;
4119 case 0x8f: 4118 case 0x8f:
4120 case 0x9f: 4119 case 0x9f:
4121 case 0xaf: 4120 case 0xaf:
4122 case 0xbf: 4121 case 0xbf:
4123 case 0xcf: 4122 case 0xcf:
4124 case 0xdf: 4123 case 0xdf:
4125 case 0xef: 4124 case 0xef:
4126 case 0xff: 4125 case 0xff:
4127 { 4126 {
4128 /** 0111 0001 1bit 1111 xor1 cy, %1 */ 4127 /** 0111 0001 1bit 1111 xor1 cy, %1 */
4129 #line 1250 "rl78-decode.opc" 4128 #line 1255 "rl78-decode.opc"
4130 int bit AU = (op[1] >> 4) & 0x07; 4129 int bit AU = (op[1] >> 4) & 0x07;
4131 if (trace) 4130 if (trace)
4132 { 4131 {
4133 printf ("\033[33m%s\033[0m %02x %02x\n", 4132 printf ("\033[33m%s\033[0m %02x %02x\n",
4134 "/** 0111 0001 1bit 1111 xor1 cy, %1 */", 4133 "/** 0111 0001 1bit 1111 xor1 cy, %1 */",
4135 op[0], op[1]); 4134 op[0], op[1]);
4136 printf (" bit = 0x%x\n", bit); 4135 printf (" bit = 0x%x\n", bit);
4137 } 4136 }
4138 SYNTAX("xor1 cy, %1"); 4137 SYNTAX("xor1 cy, %1");
4139 #line 1250 "rl78-decode.opc" 4138 #line 1255 "rl78-decode.opc"
4140 ID(xor); DCY(); SR(A); SB(bit); 4139 ID(xor); DCY(); SR(A); SB(bit);
4141 4140
4142 } 4141 }
4143 break; 4142 break;
4143 case 0xc0:
4144 {
4145 /** 0111 0001 1100 0000 not1 cy */
4146 if (trace)
4147 {
4148 printf ("\033[33m%s\033[0m %02x %02x\n",
4149 "/** 0111 0001 1100 0000 not1 cy */",
4150 op[0], op[1]);
4151 }
4152 SYNTAX("not1 cy");
4153 #line 892 "rl78-decode.opc"
4154 ID(xor); DCY(); SC(1);
4155
4156 /*---------------------------------------------------------------- ------*/
4157
4158 }
4159 break;
4144 default: UNSUPPORTED(); break; 4160 default: UNSUPPORTED(); break;
4145 } 4161 }
4146 break; 4162 break;
4147 case 0x78: 4163 case 0x78:
4148 { 4164 {
4149 /** 0111 1000 movw %e0%0, %1 */ 4165 /** 0111 1000 movw %e0%0, %1 */
4150 if (trace) 4166 if (trace)
4151 { 4167 {
4152 printf ("\033[33m%s\033[0m %02x\n", 4168 printf ("\033[33m%s\033[0m %02x\n",
4153 "/** 0111 1000 movw %e0%0, %1 */", 4169 "/** 0111 1000 movw %e0%0, %1 */",
(...skipping 23 matching lines...) Expand all
4177 case 0x7a: 4193 case 0x7a:
4178 { 4194 {
4179 /** 0111 1010 xor %0, #%1 */ 4195 /** 0111 1010 xor %0, #%1 */
4180 if (trace) 4196 if (trace)
4181 { 4197 {
4182 printf ("\033[33m%s\033[0m %02x\n", 4198 printf ("\033[33m%s\033[0m %02x\n",
4183 "/** 0111 1010 xor %0, #%1 */", 4199 "/** 0111 1010 xor %0, #%1 */",
4184 op[0]); 4200 op[0]);
4185 } 4201 }
4186 SYNTAX("xor %0, #%1"); 4202 SYNTAX("xor %0, #%1");
4187 #line 1242 "rl78-decode.opc" 4203 #line 1247 "rl78-decode.opc"
4188 ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz; 4204 ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
4189 4205
4190 /*---------------------------------------------------------------------- */ 4206 /*---------------------------------------------------------------------- */
4191 4207
4192 } 4208 }
4193 break; 4209 break;
4194 case 0x7b: 4210 case 0x7b:
4195 { 4211 {
4196 /** 0111 1011 xor %0, %1 */ 4212 /** 0111 1011 xor %0, %1 */
4197 if (trace) 4213 if (trace)
4198 { 4214 {
4199 printf ("\033[33m%s\033[0m %02x\n", 4215 printf ("\033[33m%s\033[0m %02x\n",
4200 "/** 0111 1011 xor %0, %1 */", 4216 "/** 0111 1011 xor %0, %1 */",
4201 op[0]); 4217 op[0]);
4202 } 4218 }
4203 SYNTAX("xor %0, %1"); 4219 SYNTAX("xor %0, %1");
4204 #line 1239 "rl78-decode.opc" 4220 #line 1244 "rl78-decode.opc"
4205 ID(xor); DR(A); SM(None, SADDR); Fz; 4221 ID(xor); DR(A); SM(None, SADDR); Fz;
4206 4222
4207 } 4223 }
4208 break; 4224 break;
4209 case 0x7c: 4225 case 0x7c:
4210 { 4226 {
4211 /** 0111 1100 xor %0, #%1 */ 4227 /** 0111 1100 xor %0, #%1 */
4212 if (trace) 4228 if (trace)
4213 { 4229 {
4214 printf ("\033[33m%s\033[0m %02x\n", 4230 printf ("\033[33m%s\033[0m %02x\n",
4215 "/** 0111 1100 xor %0, #%1 */", 4231 "/** 0111 1100 xor %0, #%1 */",
4216 op[0]); 4232 op[0]);
4217 } 4233 }
4218 SYNTAX("xor %0, #%1"); 4234 SYNTAX("xor %0, #%1");
4219 #line 1230 "rl78-decode.opc" 4235 #line 1235 "rl78-decode.opc"
4220 ID(xor); DR(A); SC(IMMU(1)); Fz; 4236 ID(xor); DR(A); SC(IMMU(1)); Fz;
4221 4237
4222 } 4238 }
4223 break; 4239 break;
4224 case 0x7d: 4240 case 0x7d:
4225 { 4241 {
4226 /** 0111 1101 xor %0, %e1%1 */ 4242 /** 0111 1101 xor %0, %e1%1 */
4227 if (trace) 4243 if (trace)
4228 { 4244 {
4229 printf ("\033[33m%s\033[0m %02x\n", 4245 printf ("\033[33m%s\033[0m %02x\n",
4230 "/** 0111 1101 xor %0, %e1%1 */", 4246 "/** 0111 1101 xor %0, %e1%1 */",
4231 op[0]); 4247 op[0]);
4232 } 4248 }
4233 SYNTAX("xor %0, %e1%1"); 4249 SYNTAX("xor %0, %e1%1");
4234 #line 1218 "rl78-decode.opc" 4250 #line 1223 "rl78-decode.opc"
4235 ID(xor); DR(A); SM(HL, 0); Fz; 4251 ID(xor); DR(A); SM(HL, 0); Fz;
4236 4252
4237 } 4253 }
4238 break; 4254 break;
4239 case 0x7e: 4255 case 0x7e:
4240 { 4256 {
4241 /** 0111 1110 xor %0, %e1%1 */ 4257 /** 0111 1110 xor %0, %e1%1 */
4242 if (trace) 4258 if (trace)
4243 { 4259 {
4244 printf ("\033[33m%s\033[0m %02x\n", 4260 printf ("\033[33m%s\033[0m %02x\n",
4245 "/** 0111 1110 xor %0, %e1%1 */", 4261 "/** 0111 1110 xor %0, %e1%1 */",
4246 op[0]); 4262 op[0]);
4247 } 4263 }
4248 SYNTAX("xor %0, %e1%1"); 4264 SYNTAX("xor %0, %e1%1");
4249 #line 1224 "rl78-decode.opc" 4265 #line 1229 "rl78-decode.opc"
4250 ID(xor); DR(A); SM(HL, IMMU(1)); Fz; 4266 ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
4251 4267
4252 } 4268 }
4253 break; 4269 break;
4254 case 0x7f: 4270 case 0x7f:
4255 { 4271 {
4256 /** 0111 1111 xor %0, %e1%!1 */ 4272 /** 0111 1111 xor %0, %e1%!1 */
4257 if (trace) 4273 if (trace)
4258 { 4274 {
4259 printf ("\033[33m%s\033[0m %02x\n", 4275 printf ("\033[33m%s\033[0m %02x\n",
4260 "/** 0111 1111 xor %0, %e1%!1 */", 4276 "/** 0111 1111 xor %0, %e1%!1 */",
4261 op[0]); 4277 op[0]);
4262 } 4278 }
4263 SYNTAX("xor %0, %e1%!1"); 4279 SYNTAX("xor %0, %e1%!1");
4264 #line 1215 "rl78-decode.opc" 4280 #line 1220 "rl78-decode.opc"
4265 ID(xor); DR(A); SM(None, IMMU(2)); Fz; 4281 ID(xor); DR(A); SM(None, IMMU(2)); Fz;
4266 4282
4267 } 4283 }
4268 break; 4284 break;
4269 case 0x80: 4285 case 0x80:
4270 case 0x81: 4286 case 0x81:
4271 case 0x82: 4287 case 0x82:
4272 case 0x83: 4288 case 0x83:
4273 case 0x84: 4289 case 0x84:
4274 case 0x85: 4290 case 0x85:
(...skipping 695 matching lines...) Expand 10 before | Expand all | Expand 10 after
4970 ID(mov); W(); DM(None, IMMU(2)); SR(AX); 4986 ID(mov); W(); DM(None, IMMU(2)); SR(AX);
4971 4987
4972 } 4988 }
4973 break; 4989 break;
4974 case 0xc0: 4990 case 0xc0:
4975 case 0xc2: 4991 case 0xc2:
4976 case 0xc4: 4992 case 0xc4:
4977 case 0xc6: 4993 case 0xc6:
4978 { 4994 {
4979 /** 1100 0rg0 pop %0 */ 4995 /** 1100 0rg0 pop %0 */
4980 #line 957 "rl78-decode.opc" 4996 #line 962 "rl78-decode.opc"
4981 int rg AU = (op[0] >> 1) & 0x03; 4997 int rg AU = (op[0] >> 1) & 0x03;
4982 if (trace) 4998 if (trace)
4983 { 4999 {
4984 printf ("\033[33m%s\033[0m %02x\n", 5000 printf ("\033[33m%s\033[0m %02x\n",
4985 "/** 1100 0rg0 pop %0 */", 5001 "/** 1100 0rg0 pop %0 */",
4986 op[0]); 5002 op[0]);
4987 printf (" rg = 0x%x\n", rg); 5003 printf (" rg = 0x%x\n", rg);
4988 } 5004 }
4989 SYNTAX("pop %0"); 5005 SYNTAX("pop %0");
4990 #line 957 "rl78-decode.opc" 5006 #line 962 "rl78-decode.opc"
4991 ID(mov); W(); DRW(rg); SPOP(); 5007 ID(mov); W(); DRW(rg); SPOP();
4992 5008
4993 } 5009 }
4994 break; 5010 break;
4995 case 0xc1: 5011 case 0xc1:
4996 case 0xc3: 5012 case 0xc3:
4997 case 0xc5: 5013 case 0xc5:
4998 case 0xc7: 5014 case 0xc7:
4999 { 5015 {
5000 /** 1100 0rg1 push %1 */ 5016 /** 1100 0rg1 push %1 */
5001 #line 965 "rl78-decode.opc" 5017 #line 970 "rl78-decode.opc"
5002 int rg AU = (op[0] >> 1) & 0x03; 5018 int rg AU = (op[0] >> 1) & 0x03;
5003 if (trace) 5019 if (trace)
5004 { 5020 {
5005 printf ("\033[33m%s\033[0m %02x\n", 5021 printf ("\033[33m%s\033[0m %02x\n",
5006 "/** 1100 0rg1 push %1 */", 5022 "/** 1100 0rg1 push %1 */",
5007 op[0]); 5023 op[0]);
5008 printf (" rg = 0x%x\n", rg); 5024 printf (" rg = 0x%x\n", rg);
5009 } 5025 }
5010 SYNTAX("push %1"); 5026 SYNTAX("push %1");
5011 #line 965 "rl78-decode.opc" 5027 #line 970 "rl78-decode.opc"
5012 ID(mov); W(); DPUSH(); SRW(rg); 5028 ID(mov); W(); DPUSH(); SRW(rg);
5013 5029
5014 } 5030 }
5015 break; 5031 break;
5016 case 0xc8: 5032 case 0xc8:
5017 { 5033 {
5018 /** 1100 1000 mov %0, #%1 */ 5034 /** 1100 1000 mov %0, #%1 */
5019 if (trace) 5035 if (trace)
5020 { 5036 {
5021 printf ("\033[33m%s\033[0m %02x\n", 5037 printf ("\033[33m%s\033[0m %02x\n",
(...skipping 208 matching lines...) Expand 10 before | Expand all | Expand 10 after
5230 case 0xd7: 5246 case 0xd7:
5231 { 5247 {
5232 /** 1101 0111 ret */ 5248 /** 1101 0111 ret */
5233 if (trace) 5249 if (trace)
5234 { 5250 {
5235 printf ("\033[33m%s\033[0m %02x\n", 5251 printf ("\033[33m%s\033[0m %02x\n",
5236 "/** 1101 0111 ret */", 5252 "/** 1101 0111 ret */",
5237 op[0]); 5253 op[0]);
5238 } 5254 }
5239 SYNTAX("ret"); 5255 SYNTAX("ret");
5240 #line 973 "rl78-decode.opc" 5256 #line 978 "rl78-decode.opc"
5241 ID(ret); 5257 ID(ret);
5242 5258
5243 } 5259 }
5244 break; 5260 break;
5245 case 0xd8: 5261 case 0xd8:
5246 { 5262 {
5247 /** 1101 1000 mov %0, %1 */ 5263 /** 1101 1000 mov %0, %1 */
5248 if (trace) 5264 if (trace)
5249 { 5265 {
5250 printf ("\033[33m%s\033[0m %02x\n", 5266 printf ("\033[33m%s\033[0m %02x\n",
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after
5373 /*---------------------------------------------------------------------- */ 5389 /*---------------------------------------------------------------------- */
5374 5390
5375 } 5391 }
5376 break; 5392 break;
5377 case 0xe0: 5393 case 0xe0:
5378 case 0xe1: 5394 case 0xe1:
5379 case 0xe2: 5395 case 0xe2:
5380 case 0xe3: 5396 case 0xe3:
5381 { 5397 {
5382 /** 1110 00rg oneb %0 */ 5398 /** 1110 00rg oneb %0 */
5383 #line 895 "rl78-decode.opc" 5399 #line 900 "rl78-decode.opc"
5384 int rg AU = op[0] & 0x03; 5400 int rg AU = op[0] & 0x03;
5385 if (trace) 5401 if (trace)
5386 { 5402 {
5387 printf ("\033[33m%s\033[0m %02x\n", 5403 printf ("\033[33m%s\033[0m %02x\n",
5388 "/** 1110 00rg oneb %0 */", 5404 "/** 1110 00rg oneb %0 */",
5389 op[0]); 5405 op[0]);
5390 printf (" rg = 0x%x\n", rg); 5406 printf (" rg = 0x%x\n", rg);
5391 } 5407 }
5392 SYNTAX("oneb %0"); 5408 SYNTAX("oneb %0");
5393 #line 895 "rl78-decode.opc" 5409 #line 900 "rl78-decode.opc"
5394 ID(mov); DRB(rg); SC(1); 5410 ID(mov); DRB(rg); SC(1);
5395 5411
5396 } 5412 }
5397 break; 5413 break;
5398 case 0xe4: 5414 case 0xe4:
5399 { 5415 {
5400 /** 1110 0100 oneb %0 */ 5416 /** 1110 0100 oneb %0 */
5401 if (trace) 5417 if (trace)
5402 { 5418 {
5403 printf ("\033[33m%s\033[0m %02x\n", 5419 printf ("\033[33m%s\033[0m %02x\n",
5404 "/** 1110 0100 oneb %0 */", 5420 "/** 1110 0100 oneb %0 */",
5405 op[0]); 5421 op[0]);
5406 } 5422 }
5407 SYNTAX("oneb %0"); 5423 SYNTAX("oneb %0");
5408 #line 898 "rl78-decode.opc" 5424 #line 903 "rl78-decode.opc"
5409 ID(mov); DM(None, SADDR); SC(1); 5425 ID(mov); DM(None, SADDR); SC(1);
5410 5426
5411 /*---------------------------------------------------------------------- */ 5427 /*---------------------------------------------------------------------- */
5412 5428
5413 } 5429 }
5414 break; 5430 break;
5415 case 0xe5: 5431 case 0xe5:
5416 { 5432 {
5417 /** 1110 0101 oneb %e0%!0 */ 5433 /** 1110 0101 oneb %e0%!0 */
5418 if (trace) 5434 if (trace)
5419 { 5435 {
5420 printf ("\033[33m%s\033[0m %02x\n", 5436 printf ("\033[33m%s\033[0m %02x\n",
5421 "/** 1110 0101 oneb %e0%!0 */", 5437 "/** 1110 0101 oneb %e0%!0 */",
5422 op[0]); 5438 op[0]);
5423 } 5439 }
5424 SYNTAX("oneb %e0%!0"); 5440 SYNTAX("oneb %e0%!0");
5425 #line 892 "rl78-decode.opc" 5441 #line 897 "rl78-decode.opc"
5426 ID(mov); DM(None, IMMU(2)); SC(1); 5442 ID(mov); DM(None, IMMU(2)); SC(1);
5427 5443
5428 } 5444 }
5429 break; 5445 break;
5430 case 0xe6: 5446 case 0xe6:
5431 { 5447 {
5432 /** 1110 0110 onew %0 */ 5448 /** 1110 0110 onew %0 */
5433 if (trace) 5449 if (trace)
5434 { 5450 {
5435 printf ("\033[33m%s\033[0m %02x\n", 5451 printf ("\033[33m%s\033[0m %02x\n",
5436 "/** 1110 0110 onew %0 */", 5452 "/** 1110 0110 onew %0 */",
5437 op[0]); 5453 op[0]);
5438 } 5454 }
5439 SYNTAX("onew %0"); 5455 SYNTAX("onew %0");
5440 #line 903 "rl78-decode.opc" 5456 #line 908 "rl78-decode.opc"
5441 ID(mov); DR(AX); SC(1); 5457 ID(mov); DR(AX); SC(1);
5442 5458
5443 } 5459 }
5444 break; 5460 break;
5445 case 0xe7: 5461 case 0xe7:
5446 { 5462 {
5447 /** 1110 0111 onew %0 */ 5463 /** 1110 0111 onew %0 */
5448 if (trace) 5464 if (trace)
5449 { 5465 {
5450 printf ("\033[33m%s\033[0m %02x\n", 5466 printf ("\033[33m%s\033[0m %02x\n",
5451 "/** 1110 0111 onew %0 */", 5467 "/** 1110 0111 onew %0 */",
5452 op[0]); 5468 op[0]);
5453 } 5469 }
5454 SYNTAX("onew %0"); 5470 SYNTAX("onew %0");
5455 #line 906 "rl78-decode.opc" 5471 #line 911 "rl78-decode.opc"
5456 ID(mov); DR(BC); SC(1); 5472 ID(mov); DR(BC); SC(1);
5457 5473
5458 /*---------------------------------------------------------------------- */ 5474 /*---------------------------------------------------------------------- */
5459 5475
5460 } 5476 }
5461 break; 5477 break;
5462 case 0xe8: 5478 case 0xe8:
5463 { 5479 {
5464 /** 1110 1000 mov %0, %1 */ 5480 /** 1110 1000 mov %0, %1 */
5465 if (trace) 5481 if (trace)
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after
5718 "/** 1111 1111 brk1 */", 5734 "/** 1111 1111 brk1 */",
5719 op[0]); 5735 op[0]);
5720 } 5736 }
5721 SYNTAX("brk1"); 5737 SYNTAX("brk1");
5722 #line 364 "rl78-decode.opc" 5738 #line 364 "rl78-decode.opc"
5723 ID(break); 5739 ID(break);
5724 5740
5725 } 5741 }
5726 break; 5742 break;
5727 } 5743 }
5728 #line 1261 "rl78-decode.opc" 5744 #line 1266 "rl78-decode.opc"
5729 5745
5730 return rl78->n_bytes; 5746 return rl78->n_bytes;
5731 } 5747 }
OLDNEW
« no previous file with comments | « opcodes/ppc-opc.c ('k') | opcodes/rl78-decode.opc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698