ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/uae_cpu/gencpu.c
(Generate patch)

Comparing BasiliskII/src/uae_cpu/gencpu.c (file contents):
Revision 1.13 by gbeauche, 2001-03-20T17:35:46Z vs.
Revision 1.14 by gbeauche, 2001-07-13T10:13:57Z

# Line 715 | Line 715 | static void genflags_normal (flagtypes t
715  
716   static void genflags (flagtypes type, wordsizes size, char *value, char *src, char *dst)
717   {
718 < #ifdef SPARC_V8_ASSEMBLY
719 <        switch(type)
720 <        {
721 <                case flag_add:
722 <                        start_brace();
723 <                        printf("\tuae_u32 %s;\n", value);
724 <                        switch(size)
725 <                        {
726 <                                case sz_byte:
727 <                                        printf("\t%s = sparc_v8_flag_add_8(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
728 <                                        break;
729 <                                case sz_word:
730 <                                        printf("\t%s = sparc_v8_flag_add_16(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
731 <                                        break;
732 <                                case sz_long:
733 <                                        printf("\t%s = sparc_v8_flag_add_32(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
734 <                                        break;
735 <                        }
736 <                        return;
737 <                
738 <                case flag_sub:
739 <                        start_brace();
740 <                        printf("\tuae_u32 %s;\n", value);
741 <                        switch(size)
742 <                        {
743 <                                case sz_byte:
744 <                                        printf("\t%s = sparc_v8_flag_sub_8(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
745 <                                        break;
746 <                                case sz_word:
747 <                                        printf("\t%s = sparc_v8_flag_sub_16(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
748 <                                        break;
749 <                                case sz_long:
750 <                                        printf("\t%s = sparc_v8_flag_sub_32(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
751 <                                        break;
752 <                        }
753 <                        return;
754 <                
755 <                case flag_cmp:
756 <                        switch(size)
757 <                        {
758 <                                case sz_byte:
759 < //                                      printf("\tsparc_v8_flag_cmp_8(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", src, dst);
760 <                                        break;
761 <                                case sz_word:
762 < //                                      printf("\tsparc_v8_flag_cmp_16(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", src, dst);
763 <                                        break;
764 <                                case sz_long:
765 < #if 1
766 <                                        printf("\tsparc_v8_flag_cmp_32(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", src, dst);
767 <                                        return;
768 < #endif
769 <                                        break;
770 <                        }
771 < //                      return;
772 <                        break;
773 <        }
774 < #elif defined(SPARC_V9_ASSEMBLY)
775 <        switch(type)
776 <        {
777 <                case flag_add:
778 <                        start_brace();
779 <                        printf("\tuae_u32 %s;\n", value);
780 <                        switch(size)
781 <                        {
782 <                                case sz_byte:
783 <                                        printf("\t%s = sparc_v9_flag_add_8(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
784 <                                        break;
785 <                                case sz_word:
786 <                                        printf("\t%s = sparc_v9_flag_add_16(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
787 <                                        break;
788 <                                case sz_long:
789 <                                        printf("\t%s = sparc_v9_flag_add_32(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
790 <                                        break;
791 <                        }
792 <                        return;
793 <                
794 <                case flag_sub:
795 <                        start_brace();
796 <                        printf("\tuae_u32 %s;\n", value);
797 <                        switch(size)
798 <                        {
799 <                                case sz_byte:
800 <                                        printf("\t%s = sparc_v9_flag_sub_8(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
801 <                                        break;
802 <                                case sz_word:
803 <                                        printf("\t%s = sparc_v9_flag_sub_16(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
804 <                                        break;
805 <                                case sz_long:
806 <                                        printf("\t%s = sparc_v9_flag_sub_32(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", value, src, dst);
807 <                                        break;
808 <                        }
809 <                        return;
810 <                
811 <                case flag_cmp:
812 <                        switch(size)
813 <                        {
814 <                                case sz_byte:
815 <                                        printf("\tsparc_v9_flag_cmp_8(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", src, dst);
816 <                                        break;
817 <                                case sz_word:
818 <                                        printf("\tsparc_v9_flag_cmp_16(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", src, dst);
819 <                                        break;
820 <                                case sz_long:
821 <                                        printf("\tsparc_v9_flag_cmp_32(&regflags, (uae_u32)(%s), (uae_u32)(%s));\n", src, dst);
822 <                                        break;
823 <                        }
824 <                        return;
825 <                
826 <                case flag_logical:
827 <                        if (strcmp(value, "0") == 0) {
828 <                                printf("\tregflags.nzvc = 0x04;\n");
829 <                        } else {
830 <                                switch(size) {
831 <                                        case sz_byte:
832 <                                                printf("\tsparc_v9_flag_test_8(&regflags, (uae_u32)(%s));\n", value);
833 <                                                break;
834 <                                        case sz_word:
835 <                                                printf("\tsparc_v9_flag_test_16(&regflags, (uae_u32)(%s));\n", value);
836 <                                                break;
837 <                                        case sz_long:
838 <                                                printf("\tsparc_v9_flag_test_32(&regflags, (uae_u32)(%s));\n", value);
839 <                                                break;
840 <                                }
841 <                        }
842 <                        return;
843 <                
844 < #if 0
845 <                case flag_logical_noclobber:
846 <                        printf("\t{uae_u32 old_flags = regflags.nzvc & ~0x0C;\n");
847 <                        if (strcmp(value, "0") == 0) {
848 <                                printf("\tregflags.nzvc = old_flags | 0x04;\n");
849 <                        } else {
850 <                                switch(size) {
851 <                                        case sz_byte:
852 <                                                printf("\tsparc_v9_flag_test_8(&regflags, (uae_u32)(%s));\n", value);
853 <                                                break;
854 <                                        case sz_word:
855 <                                                printf("\tsparc_v9_flag_test_16(&regflags, (uae_u32)(%s));\n", value);
856 <                                                break;
857 <                                        case sz_long:
858 <                                                printf("\tsparc_v9_flag_test_32(&regflags, (uae_u32)(%s));\n", value);
859 <                                                break;
860 <                                }
861 <                                printf("\tregflags.nzvc |= old_flags;\n");
862 <                        }
863 <                        printf("\t}\n");
864 <                        return;
865 < #endif
866 <        }
867 < #elif defined(X86_ASSEMBLY)
718 >    /* Temporarily deleted 68k/ARM flag optimizations.  I'd prefer to have
719 >       them in the appropriate m68k.h files and use just one copy of this
720 >       code here.  The API can be changed if necessary.  */
721 > #ifdef OPTIMIZED_FLAGS
722      switch (type) {
723       case flag_add:
724       case flag_sub:
# Line 879 | Line 733 | static void genflags (flagtypes type, wo
733      /* At least some of those casts are fairly important! */
734      switch (type) {
735       case flag_logical_noclobber:
736 <        printf ("\t{uae_u32 oldcznv = regflags.cznv & ~0xC0;\n");
736 >        printf ("\t{uae_u32 oldcznv = GET_CZNV & ~(FLAGVAL_Z | FLAGVAL_N);\n");
737          if (strcmp (value, "0") == 0) {
738 <            printf ("\tregflags.cznv = olcznv | 64;\n");
738 >            printf ("\tSET_CZNV (olcznv | FLAGVAL_Z);\n");
739          } else {
740              switch (size) {
741 <             case sz_byte: printf ("\tx86_flag_testb ((uae_s8)(%s));\n", value); break;
742 <             case sz_word: printf ("\tx86_flag_testw ((uae_s16)(%s));\n", value); break;
743 <             case sz_long: printf ("\tx86_flag_testl ((uae_s32)(%s));\n", value); break;
741 >             case sz_byte: printf ("\toptflag_testb ((uae_s8)(%s));\n", value); break;
742 >             case sz_word: printf ("\toptflag_testw ((uae_s16)(%s));\n", value); break;
743 >             case sz_long: printf ("\toptflag_testl ((uae_s32)(%s));\n", value); break;
744              }
745 <            printf ("\tregflags.cznv |= oldcznv;\n");
745 >            printf ("\tIOR_CZNV (oldcznv);\n");
746          }
747          printf ("\t}\n");
748          return;
749       case flag_logical:
750          if (strcmp (value, "0") == 0) {
751 <            printf ("\tregflags.cznv = 64;\n");
751 >            printf ("\tSET_CZNV (FLAGVAL_Z);\n");
752          } else {
753              switch (size) {
754 <             case sz_byte: printf ("\tx86_flag_testb ((uae_s8)(%s));\n", value); break;
755 <             case sz_word: printf ("\tx86_flag_testw ((uae_s16)(%s));\n", value); break;
756 <             case sz_long: printf ("\tx86_flag_testl ((uae_s32)(%s));\n", value); break;
754 >             case sz_byte: printf ("\toptflag_testb ((uae_s8)(%s));\n", value); break;
755 >             case sz_word: printf ("\toptflag_testw ((uae_s16)(%s));\n", value); break;
756 >             case sz_long: printf ("\toptflag_testl ((uae_s32)(%s));\n", value); break;
757              }
758          }
759          return;
760  
761       case flag_add:
762          switch (size) {
763 <         case sz_byte: printf ("\tx86_flag_addb (%s, (uae_s8)(%s), (uae_s8)(%s));\n", value, src, dst); break;
764 <         case sz_word: printf ("\tx86_flag_addw (%s, (uae_s16)(%s), (uae_s16)(%s));\n", value, src, dst); break;
765 <         case sz_long: printf ("\tx86_flag_addl (%s, (uae_s32)(%s), (uae_s32)(%s));\n", value, src, dst); break;
763 >         case sz_byte: printf ("\toptflag_addb (%s, (uae_s8)(%s), (uae_s8)(%s));\n", value, src, dst); break;
764 >         case sz_word: printf ("\toptflag_addw (%s, (uae_s16)(%s), (uae_s16)(%s));\n", value, src, dst); break;
765 >         case sz_long: printf ("\toptflag_addl (%s, (uae_s32)(%s), (uae_s32)(%s));\n", value, src, dst); break;
766          }
767          return;
768  
769       case flag_sub:
770          switch (size) {
771 <         case sz_byte: printf ("\tx86_flag_subb (%s, (uae_s8)(%s), (uae_s8)(%s));\n", value, src, dst); break;
772 <         case sz_word: printf ("\tx86_flag_subw (%s, (uae_s16)(%s), (uae_s16)(%s));\n", value, src, dst); break;
773 <         case sz_long: printf ("\tx86_flag_subl (%s, (uae_s32)(%s), (uae_s32)(%s));\n", value, src, dst); break;
771 >         case sz_byte: printf ("\toptflag_subb (%s, (uae_s8)(%s), (uae_s8)(%s));\n", value, src, dst); break;
772 >         case sz_word: printf ("\toptflag_subw (%s, (uae_s16)(%s), (uae_s16)(%s));\n", value, src, dst); break;
773 >         case sz_long: printf ("\toptflag_subl (%s, (uae_s32)(%s), (uae_s32)(%s));\n", value, src, dst); break;
774          }
775          return;
776  
777       case flag_cmp:
778          switch (size) {
779 <         case sz_byte: printf ("\tx86_flag_cmpb ((uae_s8)(%s), (uae_s8)(%s));\n", src, dst); break;
780 <         case sz_word: printf ("\tx86_flag_cmpw ((uae_s16)(%s), (uae_s16)(%s));\n", src, dst); break;
781 <         case sz_long: printf ("\tx86_flag_cmpl ((uae_s32)(%s), (uae_s32)(%s));\n", src, dst); break;
779 >         case sz_byte: printf ("\toptflag_cmpb ((uae_s8)(%s), (uae_s8)(%s));\n", src, dst); break;
780 >         case sz_word: printf ("\toptflag_cmpw ((uae_s16)(%s), (uae_s16)(%s));\n", src, dst); break;
781 >         case sz_long: printf ("\toptflag_cmpl ((uae_s32)(%s), (uae_s32)(%s));\n", src, dst); break;
782          }
783          return;
784          
785       default:
786          break;
787      }
934 #elif defined(M68K_FLAG_OPT)
935    /* sam: here I'm cloning what X86_ASSEMBLY does */
936 #define EXT(size)  (size==sz_byte?"b":(size==sz_word?"w":"l"))
937 #define CAST(size) (size==sz_byte?"uae_s8":(size==sz_word?"uae_s16":"uae_s32"))
938    switch (type) {
939     case flag_add:
940     case flag_sub:
941        start_brace ();
942        printf ("\tuae_u32 %s;\n", value);
943        break;
944
945     default:
946        break;
947    }
948
949    switch (type) {
950     case flag_logical:
951        if (strcmp (value, "0") == 0) {
952            printf ("\t*(uae_u16 *)&regflags = 4;\n");  /* Z = 1 */
953        } else {
954            printf ("\tm68k_flag_tst (%s, (%s)(%s));\n",
955                    EXT (size), CAST (size), value);
956        }
957        return;
958
959     case flag_add:
960        printf ("\t{uae_u16 ccr;\n");
961        printf ("\tm68k_flag_add (%s, (%s)%s, (%s)(%s), (%s)(%s));\n",
962                EXT (size), CAST (size), value, CAST (size), src, CAST (size), dst);
963        printf ("\t((uae_u16*)&regflags)[1]=((uae_u16*)&regflags)[0]=ccr;}\n");
964        return;
965
966     case flag_sub:
967        printf ("\t{uae_u16 ccr;\n");
968        printf ("\tm68k_flag_sub (%s, (%s)%s, (%s)(%s), (%s)(%s));\n",
969                EXT (size), CAST (size), value, CAST (size), src, CAST (size), dst);
970        printf ("\t((uae_u16*)&regflags)[1]=((uae_u16*)&regflags)[0]=ccr;}\n");
971        return;
972
973     case flag_cmp:
974        printf ("\tm68k_flag_cmp (%s, (%s)(%s), (%s)(%s));\n",
975                EXT (size), CAST (size), src, CAST (size), dst);
976        return;
977
978     default:
979        break;
980    }
981 #elif defined(ACORN_FLAG_OPT) && defined(__GNUC_MINOR__)
982 /*
983 * This is new. Might be quite buggy.
984 */
985    switch (type) {
986     case flag_av:
987     case flag_sv:
988     case flag_zn:
989     case flag_addx:
990     case flag_subx:
991        break;
992
993     case flag_logical:
994        if (strcmp (value, "0") == 0) {
995            /* v=c=n=0 z=1 */
996            printf ("\t*(ULONG*)&regflags = 0x40000000;\n");
997            return;
998        } else {
999            start_brace ();
1000            switch (size) {
1001             case sz_byte:
1002                printf ("\tUBYTE ccr;\n");
1003                printf ("\tULONG shift;\n");
1004                printf ("\t__asm__(\"mov %%2,%%1,lsl#24\n\ttst %%2,%%2\n\tmov %%0,r15,lsr#24\n\tbic %%0,%%0,#0x30\"\n"
1005                        "\t: \"=r\" (ccr) : \"r\" (%s), \"r\" (shift) : \"cc\" );\n", value);
1006                printf ("\t*((UBYTE*)&regflags+3) = ccr;\n");
1007                return;
1008             case sz_word:
1009                printf ("\tUBYTE ccr;\n");
1010                printf ("\tULONG shift;\n");
1011                printf ("\t__asm__(\"mov %%2,%%1,lsl#16\n\ttst %%2,%%2\n\tmov %%0,r15,lsr#24\n\tbic %%0,%%0,#0x30\"\n"
1012                        "\t: \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", value);
1013                printf ("\t*((UBYTE*)&regflags+3) = ccr;\n");
1014                return;
1015             case sz_long:
1016                printf ("\tUBYTE ccr;\n");
1017                printf ("\t__asm__(\"tst %%1,%%1\n\tmov %%0,r15,lsr#24\n\tbic %%0,%%0,#0x30\"\n"
1018                        "\t: \"=r\" (ccr) : \"r\" ((LONG)%s) : \"cc\" );\n", value);
1019                printf ("\t*((UBYTE*)&regflags+3) = ccr;\n");
1020                return;
1021            }
1022        }
1023        break;
1024     case flag_add:
1025        if (strcmp (dst, "0") == 0) {
1026            printf ("/* Error! Hier muss Peter noch was machen !!! (ADD-Flags) */");
1027        } else {
1028            start_brace ();
1029            switch (size) {
1030             case sz_byte:
1031                printf ("\tULONG ccr, shift, %s;\n", value);
1032                printf ("\t__asm__(\"mov %%4,%%3,lsl#24\n\tadds %%0,%%4,%%2,lsl#24\n\tmov %%0,%%0,asr#24\n\tmov %%1,r15\n\torr %%1,%%1,%%1,lsr#29\"\n"
1033                        "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" (%s), \"r\" (%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
1034                printf ("\t*(ULONG*)&regflags = ccr;\n");
1035                return;
1036             case sz_word:
1037                printf ("\tULONG ccr, shift, %s;\n", value);
1038                printf ("\t__asm__(\"mov %%4,%%3,lsl#16\n\tadds %%0,%%4,%%2,lsl#16\n\tmov %%0,%%0,asr#16\n\tmov %%1,r15\n\torr %%1,%%1,%%1,lsr#29\"\n"
1039                        "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
1040                printf ("\t*(ULONG*)&regflags = ccr;\n");
1041                return;
1042             case sz_long:
1043                printf ("\tULONG ccr, %s;\n", value);
1044                printf ("\t__asm__(\"adds %%0,%%3,%%2\n\tmov %%1,r15\n\torr %%1,%%1,%%1,lsr#29\"\n"
1045                        "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((LONG)%s), \"r\" ((LONG)%s) : \"cc\" );\n", value, src, dst);
1046                printf ("\t*(ULONG*)&regflags = ccr;\n");
1047                return;
1048            }
1049        }
1050        break;
1051     case flag_sub:
1052        if (strcmp (dst, "0") == 0) {
1053            printf ("/* Error! Hier muss Peter noch was machen !!! (SUB-Flags) */");
1054        } else {
1055            start_brace ();
1056            switch (size) {
1057             case sz_byte:
1058                printf ("\tULONG ccr, shift, %s;\n", value);
1059                printf ("\t__asm__(\"mov %%4,%%3,lsl#24\n\tsubs %%0,%%4,%%2,lsl#24\n\tmov %%0,%%0,asr#24\n\tmov %%1,r15\n\teor %%1,%%1,#0x20000000\n\torr %%1,%%1,%%1,lsr#29\"\n"
1060                        "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" (%s), \"r\" (%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
1061                printf ("\t*(ULONG*)&regflags = ccr;\n");
1062                return;
1063             case sz_word:
1064                printf ("\tULONG ccr, shift, %s;\n", value);
1065                printf ("\t__asm__(\"mov %%4,%%3,lsl#16\n\tsubs %%0,%%4,%%2,lsl#16\n\tmov %%0,%%0,asr#16\n\tmov %%1,r15\n\teor %%1,%%1,#0x20000000\n\torr %%1,%%1,%%1,lsr#29\"\n"
1066                        "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
1067                printf ("\t*(ULONG*)&regflags = ccr;\n");
1068                return;
1069             case sz_long:
1070                printf ("\tULONG ccr, %s;\n", value);
1071                printf ("\t__asm__(\"subs %%0,%%3,%%2\n\tmov %%1,r15\n\teor %%1,%%1,#0x20000000\n\torr %%1,%%1,%%1,lsr#29\"\n"
1072                        "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((LONG)%s), \"r\" ((LONG)%s) : \"cc\" );\n", value, src, dst);
1073                printf ("\t*(ULONG*)&regflags = ccr;\n");
1074                return;
1075            }
1076        }
1077        break;
1078     case flag_cmp:
1079        if (strcmp (dst, "0") == 0) {
1080            printf ("/*Error! Hier muss Peter noch was machen !!! (CMP-Flags)*/");
1081        } else {
1082            start_brace ();
1083            switch (size) {
1084             case sz_byte:
1085                printf ("\tULONG shift, ccr;\n");
1086                printf ("\t__asm__(\"mov %%3,%%2,lsl#24\n\tcmp %%3,%%1,lsl#24\n\tmov %%0,r15,lsr#24\n\teor %%0,%%0,#0x20\"\n"
1087                        "\t: \"=r\" (ccr) : \"r\" (%s), \"r\" (%s), \"r\" (shift) : \"cc\" );\n", src, dst);
1088                printf ("\t*((UBYTE*)&regflags+3) = ccr;\n");
1089                return;
1090             case sz_word:
1091                printf ("\tULONG shift, ccr;\n");
1092                printf ("\t__asm__(\"mov %%3,%%2,lsl#16\n\tcmp %%3,%%1,lsl#16\n\tmov %%0,r15,lsr#24\n\teor %%0,%%0,#0x20\"\n"
1093                        "\t: \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", src, dst);
1094                printf ("\t*((UBYTE*)&regflags+3) = ccr;\n");
1095                return;
1096             case sz_long:
1097                printf ("\tULONG ccr;\n");
1098                printf ("\t__asm__(\"cmp %%2,%%1\n\tmov %%0,r15,lsr#24\n\teor %%0,%%0,#0x20\"\n"
1099                        "\t: \"=r\" (ccr) : \"r\" ((LONG)%s), \"r\" ((LONG)%s) : \"cc\" );\n", src, dst);
1100                printf ("\t*((UBYTE*)&regflags+3) = ccr;\n");
1101                /*printf ("\tprintf (\"%%08x %%08x %%08x\\n\", %s, %s, *((ULONG*)&regflags));\n", src, dst); */
1102                return;
1103            }
1104        }
1105        break;
1106    }
788   #endif
789 +
790      genflags_normal (type, size, value, src, dst);
791   }
792  
# Line 1238 | Line 920 | static void gen_opcode (unsigned long in
920          printf ("\tint cflg;\n");
921          printf ("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
922          printf ("\tnewv = newv_hi + (newv_lo & 0xF);");
923 <        printf ("\tSET_CFLG (cflg = (newv_hi & 0x1F0) > 0x90);\n");
923 >        printf ("\tcflg = (newv_hi & 0x1F0) > 0x90;\n");
924 >        printf ("\tSET_CFLG (cflg);\n");
925          duplicate_carry ();
926          printf ("\tif (cflg) newv -= 0x60;\n");
927          genflags (flag_zn, curi->size, "newv", "", "");
# Line 1278 | Line 961 | static void gen_opcode (unsigned long in
961          printf ("\tint cflg;\n");
962          printf ("\tif (newv_lo > 9) { newv_lo +=6; }\n");
963          printf ("\tnewv = newv_hi + newv_lo;");
964 <        printf ("\tSET_CFLG (cflg = (newv & 0x1F0) > 0x90);\n");
964 >        printf ("\tcflg = (newv & 0x1F0) > 0x90;\n");
965 >        printf ("\tSET_CFLG (cflg);\n");
966          duplicate_carry ();
967          printf ("\tif (cflg) newv += 0x60;\n");
968          genflags (flag_zn, curi->size, "newv", "", "");
# Line 1308 | Line 992 | static void gen_opcode (unsigned long in
992          printf ("\tint cflg;\n");
993          printf ("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
994          printf ("\tnewv = newv_hi + (newv_lo & 0xF);");
995 <        printf ("\tSET_CFLG (cflg = (newv_hi & 0x1F0) > 0x90);\n");
995 >        printf ("\tcflg = cflg = (newv_hi & 0x1F0) > 0x90;\n");
996 >        printf ("\tSET_CFLG (cflg);\n");
997          duplicate_carry();
998          printf ("\tif (cflg) newv -= 0x60;\n");
999          genflags (flag_zn, curi->size, "newv", "", "");
# Line 1347 | Line 1032 | static void gen_opcode (unsigned long in
1032          else
1033              printf ("\tsrc &= 31;\n");
1034          printf ("\tdst ^= (1 << src);\n");
1035 <        printf ("\tSET_ZFLG ((dst & (1 << src)) >> src);\n");
1035 >        printf ("\tSET_ZFLG (((uae_u32)dst & (1 << src)) >> src);\n");
1036          genastore ("dst", curi->dmode, "dstreg", curi->size, "dst");
1037          break;
1038       case i_BCLR:
# Line 1686 | Line 1371 | static void gen_opcode (unsigned long in
1371          printf ("\tuaecptr oldpc = m68k_getpc();\n");
1372          genamode (curi->smode, "srcreg", sz_word, "src", 1, 0);
1373          genamode (curi->dmode, "dstreg", sz_long, "dst", 1, 0);
1374 <        printf ("\tif(src == 0) { Exception(5,oldpc); goto %s; } else {\n", endlabelstr);
1374 >        sync_m68k_pc ();
1375 >        /* Clear V flag when dividing by zero - Alcatraz Odyssey demo depends
1376 >         * on this (actually, it's doing a DIVS).  */
1377 >        printf ("\tif (src == 0) { SET_VFLG (0); Exception (5, oldpc); goto %s; } else {\n", endlabelstr);
1378          printf ("\tuae_u32 newv = (uae_u32)dst / (uae_u32)(uae_u16)src;\n");
1379          printf ("\tuae_u32 rem = (uae_u32)dst %% (uae_u32)(uae_u16)src;\n");
1380          /* The N flag appears to be set each time there is an overflow.
# Line 1704 | Line 1392 | static void gen_opcode (unsigned long in
1392          printf ("\tuaecptr oldpc = m68k_getpc();\n");
1393          genamode (curi->smode, "srcreg", sz_word, "src", 1, 0);
1394          genamode (curi->dmode, "dstreg", sz_long, "dst", 1, 0);
1395 <        printf ("\tif(src == 0) { Exception(5,oldpc); goto %s; } else {\n", endlabelstr);
1395 >        sync_m68k_pc ();
1396 >        printf ("\tif (src == 0) { SET_VFLG (0); Exception(5,oldpc); goto %s; } else {\n", endlabelstr);
1397          printf ("\tuae_s32 newv = (uae_s32)dst / (uae_s32)(uae_s16)src;\n");
1398          printf ("\tuae_u16 rem = (uae_s32)dst %% (uae_s32)(uae_s16)src;\n");
1399          printf ("\tif ((newv & 0xffff8000) != 0 && (newv & 0xffff8000) != 0xffff8000) { SET_VFLG (1); SET_NFLG (1); SET_CFLG (0); } else\n\t{\n");
# Line 1964 | Line 1653 | static void gen_opcode (unsigned long in
1653          }
1654          printf ("\tcnt &= 63;\n");
1655          printf ("\tCLEAR_CZNV;\n");
1967        if (! source_is_imm1_8 (curi))
1968            force_range_for_rox ("cnt", curi->size);
1656          if (source_is_imm1_8 (curi))
1657              printf ("{");
1658 <        else
1658 >        else {
1659 >            force_range_for_rox ("cnt", curi->size);
1660              printf ("\tif (cnt > 0) {\n");
1661 +        }
1662          printf ("\tcnt--;\n");
1663          printf ("\t{\n\tuae_u32 carry;\n");
1664          printf ("\tuae_u32 loval = val >> (%d - cnt);\n", bit_size (curi->size) - 1);
# Line 1994 | Line 1683 | static void gen_opcode (unsigned long in
1683          }
1684          printf ("\tcnt &= 63;\n");
1685          printf ("\tCLEAR_CZNV;\n");
1997        if (! source_is_imm1_8 (curi))
1998            force_range_for_rox ("cnt", curi->size);
1686          if (source_is_imm1_8 (curi))
1687              printf ("{");
1688 <        else
1688 >        else {
1689 >            force_range_for_rox ("cnt", curi->size);
1690              printf ("\tif (cnt > 0) {\n");
1691 +        }
1692          printf ("\tcnt--;\n");
1693          printf ("\t{\n\tuae_u32 carry;\n");
1694          printf ("\tuae_u32 hival = (val << 1) | GET_XFLG;\n");
# Line 2155 | Line 1844 | static void gen_opcode (unsigned long in
1844          start_brace ();
1845          printf ("\tint regno = (src >> 12) & 15;\n");
1846          printf ("\tuae_u32 *regp = regs.regs + regno;\n");
1847 <        printf ("\tm68k_movec2(src & 0xFFF, regp);\n");
1847 >        printf ("\tif (! m68k_movec2(src & 0xFFF, regp)) goto %s;\n", endlabelstr);
1848          break;
1849       case i_MOVE2C:
1850          genamode (curi->smode, "srcreg", curi->size, "src", 1, 0);
1851          start_brace ();
1852          printf ("\tint regno = (src >> 12) & 15;\n");
1853          printf ("\tuae_u32 *regp = regs.regs + regno;\n");
1854 <        printf ("\tm68k_move2c(src & 0xFFF, regp);\n");
1854 >        printf ("\tif (! m68k_move2c(src & 0xFFF, regp)) goto %s;\n", endlabelstr);
1855          break;
1856       case i_CAS:
1857          {

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines