Mercurial > repos > blastem

comparison 68kinst.c @ 18:3e7bfde7606e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
M68K to x86 translation works for a limited subset of instructions and addressing modes
author Mike Pavone <pavone@retrodev.com>
date Tue, 04 Dec 2012 19:13:12 -0800
parents c0f339564819
children f2aaaf36c875
comparison
equal deleted inserted replaced
17:de0085d4ea40 18:3e7bfde7606e
84 void m68k_decode_cond(uint16_t op, m68kinst * decoded) 84 void m68k_decode_cond(uint16_t op, m68kinst * decoded)
85 { 85 {
86 decoded->extra.cond = (op >> 0x8) & 0xF; 86 decoded->extra.cond = (op >> 0x8) & 0xF;
87 } 87 }
88 88
89 uint8_t m68K_reg_quick_field(uint16_t op) 89 uint8_t m68k_reg_quick_field(uint16_t op)
90 { 90 {
91 return (op >> 9) & 0x7; 91 return (op >> 9) & 0x7;
92 } 92 }
93 93
94 uint16_t * m68K_decode(uint16_t * istream, m68kinst * decoded) 94 uint16_t * m68k_decode(uint16_t * istream, m68kinst * decoded, uint32_t address)
95 { 95 {
96 uint8_t optype = *istream >> 12; 96 uint8_t optype = *istream >> 12;
97 uint8_t size; 97 uint8_t size;
98 uint8_t reg; 98 uint8_t reg;
99 uint8_t opmode; 99 uint8_t opmode;
100 uint32_t immed; 100 uint32_t immed;
101 decoded->op = M68K_INVALID; 101 decoded->op = M68K_INVALID;
102 decoded->src.addr_mode = decoded->dst.addr_mode = MODE_UNUSED; 102 decoded->src.addr_mode = decoded->dst.addr_mode = MODE_UNUSED;
103 decoded->variant = VAR_NORMAL; 103 decoded->variant = VAR_NORMAL;
104 decoded->address = address;
104 switch(optype) 105 switch(optype)
105 { 106 {
106 case BIT_MOVEP_IMMED: 107 case BIT_MOVEP_IMMED:
107 if (*istream & 0x100) { 108 if (*istream & 0x100) {
108 //BTST, BCHG, BCLR, BSET 109 //BTST, BCHG, BCLR, BSET
120 case 3: 121 case 3:
121 decoded->op = M68K_BSET; 122 decoded->op = M68K_BSET;
122 break; 123 break;
123 } 124 }
124 decoded->src.addr_mode = MODE_REG; 125 decoded->src.addr_mode = MODE_REG;
125 decoded->src.params.regs.pri = m68K_reg_quick_field(*istream); 126 decoded->src.params.regs.pri = m68k_reg_quick_field(*istream);
126 decoded->extra.size = OPSIZE_LONG; 127 decoded->extra.size = OPSIZE_LONG;
127 istream = m68k_decode_op(istream, OPSIZE_LONG, &(decoded->dst)); 128 istream = m68k_decode_op(istream, OPSIZE_LONG, &(decoded->dst));
128 } else if ((*istream & 0xF00) == 0x800) { 129 } else if ((*istream & 0xF00) == 0x800) {
129 //BTST, BCHG, BCLR, BSET 130 //BTST, BCHG, BCLR, BSET
130 switch ((*istream >> 6) & 0x3) 131 switch ((*istream >> 6) & 0x3)
351 decoded->op = M68K_MOVEP; 352 decoded->op = M68K_MOVEP;
352 decoded->extra.size = *istream & 0x40 ? OPSIZE_LONG : OPSIZE_WORD; 353 decoded->extra.size = *istream & 0x40 ? OPSIZE_LONG : OPSIZE_WORD;
353 if (*istream & 0x80) { 354 if (*istream & 0x80) {
354 //memory dest 355 //memory dest
355 decoded->src.addr_mode = MODE_REG; 356 decoded->src.addr_mode = MODE_REG;
356 decoded->src.params.regs.pri = m68K_reg_quick_field(*istream); 357 decoded->src.params.regs.pri = m68k_reg_quick_field(*istream);
357 decoded->dst.addr_mode = MODE_AREG_DISPLACE; 358 decoded->dst.addr_mode = MODE_AREG_DISPLACE;
358 decoded->dst.params.regs.pri = *istream & 0x7; 359 decoded->dst.params.regs.pri = *istream & 0x7;
359 } else { 360 } else {
360 //memory source 361 //memory source
361 decoded->dst.addr_mode = MODE_REG; 362 decoded->dst.addr_mode = MODE_REG;
362 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 363 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
363 decoded->src.addr_mode = MODE_AREG_DISPLACE; 364 decoded->src.addr_mode = MODE_AREG_DISPLACE;
364 decoded->src.params.regs.pri = *istream & 0x7; 365 decoded->src.params.regs.pri = *istream & 0x7;
365 } 366 }
366 immed = *(++istream); 367 immed = *(++istream);
367 368
372 case MOVE_BYTE: 373 case MOVE_BYTE:
373 case MOVE_LONG: 374 case MOVE_LONG:
374 case MOVE_WORD: 375 case MOVE_WORD:
375 decoded->op = M68K_MOVE; 376 decoded->op = M68K_MOVE;
376 decoded->extra.size = optype == MOVE_BYTE ? OPSIZE_BYTE : (optype == MOVE_WORD ? OPSIZE_WORD : OPSIZE_LONG); 377 decoded->extra.size = optype == MOVE_BYTE ? OPSIZE_BYTE : (optype == MOVE_WORD ? OPSIZE_WORD : OPSIZE_LONG);
378 opmode = (*istream >> 6) & 0x7;
379 reg = m68k_reg_quick_field(*istream);
377 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src)); 380 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src));
378 istream = m68k_decode_op_ex(istream, (*istream >> 6) & 0x7, m68K_reg_quick_field(*istream), decoded->extra.size, &(decoded->dst)); 381 istream = m68k_decode_op_ex(istream, opmode, reg, decoded->extra.size, &(decoded->dst));
379 break; 382 break;
380 case MISC: 383 case MISC:
381 384
382 if ((*istream & 0x1C0) == 0x1C0) { 385 if ((*istream & 0x1C0) == 0x1C0) {
383 decoded->op = M68K_LEA; 386 decoded->op = M68K_LEA;
384 decoded->extra.size = OPSIZE_LONG; 387 decoded->extra.size = OPSIZE_LONG;
385 decoded->dst.addr_mode = MODE_AREG; 388 decoded->dst.addr_mode = MODE_AREG;
386 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 389 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
387 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src)); 390 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src));
388 } else { 391 } else {
389 if (*istream & 0x100) { 392 if (*istream & 0x100) {
390 decoded->op = M68K_CHK; 393 decoded->op = M68K_CHK;
391 if ((*istream & 0x180) == 0x180) { 394 if ((*istream & 0x180) == 0x180) {
399 break; 402 break;
400 #endif 403 #endif
401 } 404 }
402 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src)); 405 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src));
403 decoded->dst.addr_mode = MODE_REG; 406 decoded->dst.addr_mode = MODE_REG;
404 decoded->dst.addr_mode = m68K_reg_quick_field(*istream); 407 decoded->dst.addr_mode = m68k_reg_quick_field(*istream);
405 } else { 408 } else {
406 opmode = (*istream >> 3) & 0x7; 409 opmode = (*istream >> 3) & 0x7;
407 if ((*istream & 0xB80) == 0x880 && opmode != MODE_REG && opmode != MODE_AREG && opmode != MODE_AREG_POSTINC) { 410 if ((*istream & 0xB80) == 0x880 && opmode != MODE_REG && opmode != MODE_AREG && opmode != MODE_AREG_POSTINC) {
408 decoded->op = M68K_MOVEM; 411 decoded->op = M68K_MOVEM;
409 decoded->extra.size = *istream & 0x40 ? OPSIZE_LONG : OPSIZE_WORD; 412 decoded->extra.size = *istream & 0x40 ? OPSIZE_LONG : OPSIZE_WORD;
682 //ADDQ, SUBQ 685 //ADDQ, SUBQ
683 decoded->variant = VAR_QUICK; 686 decoded->variant = VAR_QUICK;
684 decoded->extra.size = size; 687 decoded->extra.size = size;
685 decoded->src.addr_mode = MODE_IMMEDIATE; 688 decoded->src.addr_mode = MODE_IMMEDIATE;
686 istream = m68k_decode_op(istream, size, &(decoded->dst)); 689 istream = m68k_decode_op(istream, size, &(decoded->dst));
687 immed = m68K_reg_quick_field(*istream); 690 immed = m68k_reg_quick_field(*istream);
688 if (!immed) { 691 if (!immed) {
689 immed = 8; 692 immed = 8;
690 } 693 }
691 decoded->src.params.immed = immed; 694 decoded->src.params.immed = immed;
692 if (*istream & 0x100) { 695 if (*istream & 0x100) {
720 decoded->variant = VAR_QUICK; 723 decoded->variant = VAR_QUICK;
721 decoded->extra.size = OPSIZE_LONG; 724 decoded->extra.size = OPSIZE_LONG;
722 decoded->src.addr_mode = MODE_IMMEDIATE; 725 decoded->src.addr_mode = MODE_IMMEDIATE;
723 decoded->src.params.immed = sign_extend8(*istream & 0xFF); 726 decoded->src.params.immed = sign_extend8(*istream & 0xFF);
724 decoded->dst.addr_mode = MODE_REG; 727 decoded->dst.addr_mode = MODE_REG;
725 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 728 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
726 immed = *istream & 0xFF; 729 immed = *istream & 0xFF;
727 break; 730 break;
728 case OR_DIV_SBCD: 731 case OR_DIV_SBCD:
729 //for OR, if opmode bit 2 is 1, then src = Dn, dst = <ea> 732 //for OR, if opmode bit 2 is 1, then src = Dn, dst = <ea>
730 opmode = (*istream >> 6) & 0x7; 733 opmode = (*istream >> 6) & 0x7;
783 if (*istream & 0x6) { 786 if (*istream & 0x6) {
784 if (size == OPSIZE_INVALID) { 787 if (size == OPSIZE_INVALID) {
785 //SUBA.l 788 //SUBA.l
786 decoded->extra.size = OPSIZE_LONG; 789 decoded->extra.size = OPSIZE_LONG;
787 decoded->dst.addr_mode = MODE_AREG; 790 decoded->dst.addr_mode = MODE_AREG;
791 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
788 istream = m68k_decode_op(istream, OPSIZE_LONG, &(decoded->src)); 792 istream = m68k_decode_op(istream, OPSIZE_LONG, &(decoded->src));
789 } else { 793 } else {
790 decoded->extra.size = size; 794 decoded->extra.size = size;
791 decoded->src.addr_mode = MODE_REG; 795 decoded->src.addr_mode = MODE_REG;
796 decoded->src.params.regs.pri = m68k_reg_quick_field(*istream);
792 istream = m68k_decode_op(istream, size, &(decoded->dst)); 797 istream = m68k_decode_op(istream, size, &(decoded->dst));
793 } 798 }
794 } else { 799 } else {
795 //SUBX 800 //SUBX
796 decoded->op = M68K_SUBX; 801 decoded->op = M68K_SUBX;
797 decoded->extra.size = size; 802 decoded->extra.size = size;
798 istream = m68k_decode_op(istream, size, &(decoded->src)); 803 istream = m68k_decode_op(istream, size, &(decoded->src));
799 decoded->dst.addr_mode = decoded->src.addr_mode; 804 decoded->dst.addr_mode = decoded->src.addr_mode;
800 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 805 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
801 } 806 }
802 } else { 807 } else {
803 if (size == OPSIZE_INVALID) { 808 if (size == OPSIZE_INVALID) {
804 //SUBA.w 809 //SUBA.w
805 decoded->extra.size = OPSIZE_WORD; 810 decoded->extra.size = OPSIZE_WORD;
806 decoded->dst.addr_mode = MODE_AREG; 811 decoded->dst.addr_mode = MODE_AREG;
807 } else { 812 } else {
808 decoded->extra.size = size; 813 decoded->extra.size = size;
809 decoded->dst.addr_mode = MODE_REG; 814 decoded->dst.addr_mode = MODE_REG;
810 } 815 }
811 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 816 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
812 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src)); 817 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src));
813 } 818 }
814 break; 819 break;
815 case RESERVED: 820 case RESERVED:
816 break; 821 break;
822 istream = m68k_decode_op(istream, size, &(decoded->dst)); 827 istream = m68k_decode_op(istream, size, &(decoded->dst));
823 if (decoded->src.addr_mode == MODE_AREG) { 828 if (decoded->src.addr_mode == MODE_AREG) {
824 //CMPM 829 //CMPM
825 decoded->src.addr_mode = decoded->dst.addr_mode = MODE_AREG_POSTINC; 830 decoded->src.addr_mode = decoded->dst.addr_mode = MODE_AREG_POSTINC;
826 decoded->src.params.regs.pri = decoded->dst.params.regs.pri; 831 decoded->src.params.regs.pri = decoded->dst.params.regs.pri;
827 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 832 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
828 } else { 833 } else {
829 //EOR 834 //EOR
830 decoded->op = M68K_EOR; 835 decoded->op = M68K_EOR;
831 decoded->extra.size = size; 836 decoded->extra.size = size;
832 decoded->src.addr_mode = MODE_REG; 837 decoded->src.addr_mode = MODE_REG;
833 decoded->src.params.regs.pri = m68K_reg_quick_field(*istream); 838 decoded->src.params.regs.pri = m68k_reg_quick_field(*istream);
834 } 839 }
835 } else { 840 } else {
836 //CMP 841 //CMP
837 decoded->extra.size = size; 842 decoded->extra.size = size;
838 decoded->dst.addr_mode = MODE_REG; 843 decoded->dst.addr_mode = MODE_REG;
839 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 844 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
840 istream = m68k_decode_op(istream, size, &(decoded->src)); 845 istream = m68k_decode_op(istream, size, &(decoded->src));
841 } 846 }
842 break; 847 break;
843 case AND_MUL_ABCD_EXG: 848 case AND_MUL_ABCD_EXG:
844 //page 575 for summary 849 //page 575 for summary
853 if (*istream & 0x100) { 858 if (*istream & 0x100) {
854 if ((*istream & 0xC0) == 0xC0) { 859 if ((*istream & 0xC0) == 0xC0) {
855 decoded->op = M68K_MULS; 860 decoded->op = M68K_MULS;
856 decoded->extra.size = OPSIZE_WORD; 861 decoded->extra.size = OPSIZE_WORD;
857 decoded->dst.addr_mode = MODE_REG; 862 decoded->dst.addr_mode = MODE_REG;
858 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 863 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
859 istream = m68k_decode_op(istream, OPSIZE_WORD, &(decoded->src)); 864 istream = m68k_decode_op(istream, OPSIZE_WORD, &(decoded->src));
860 } else if(!(*istream & 0xF0)) { 865 } else if(!(*istream & 0xF0)) {
861 decoded->op = M68K_ABCD; 866 decoded->op = M68K_ABCD;
862 decoded->extra.size = OPSIZE_BYTE; 867 decoded->extra.size = OPSIZE_BYTE;
863 decoded->src.params.regs.pri = *istream & 0x7; 868 decoded->src.params.regs.pri = *istream & 0x7;
864 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 869 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
865 decoded->dst.addr_mode = decoded->src.addr_mode = (*istream & 8) ? MODE_AREG_PREDEC : MODE_REG; 870 decoded->dst.addr_mode = decoded->src.addr_mode = (*istream & 8) ? MODE_AREG_PREDEC : MODE_REG;
866 } else if(!(*istream & 0x30)) { 871 } else if(!(*istream & 0x30)) {
867 decoded->op = M68K_EXG; 872 decoded->op = M68K_EXG;
868 decoded->extra.size = OPSIZE_LONG; 873 decoded->extra.size = OPSIZE_LONG;
869 decoded->src.params.regs.pri = m68K_reg_quick_field(*istream); 874 decoded->src.params.regs.pri = m68k_reg_quick_field(*istream);
870 decoded->dst.params.regs.pri = *istream & 0x7; 875 decoded->dst.params.regs.pri = *istream & 0x7;
871 if (*istream & 0x8) { 876 if (*istream & 0x8) {
872 if (*istream & 0x80) { 877 if (*istream & 0x80) {
873 decoded->src.addr_mode = MODE_REG; 878 decoded->src.addr_mode = MODE_REG;
874 decoded->dst.addr_mode = MODE_AREG; 879 decoded->dst.addr_mode = MODE_AREG;
880 } 885 }
881 } else { 886 } else {
882 decoded->op = M68K_AND; 887 decoded->op = M68K_AND;
883 decoded->extra.size = (*istream >> 6); 888 decoded->extra.size = (*istream >> 6);
884 decoded->dst.addr_mode = MODE_REG; 889 decoded->dst.addr_mode = MODE_REG;
885 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 890 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
886 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src)); 891 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src));
887 } 892 }
888 } else { 893 } else {
889 if ((*istream & 0xC0) == 0xC0) { 894 if ((*istream & 0xC0) == 0xC0) {
890 decoded->op = M68K_MULU; 895 decoded->op = M68K_MULU;
891 decoded->extra.size = OPSIZE_WORD; 896 decoded->extra.size = OPSIZE_WORD;
892 decoded->dst.addr_mode = MODE_REG; 897 decoded->dst.addr_mode = MODE_REG;
893 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 898 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
894 istream = m68k_decode_op(istream, OPSIZE_WORD, &(decoded->src)); 899 istream = m68k_decode_op(istream, OPSIZE_WORD, &(decoded->src));
895 } else { 900 } else {
896 decoded->op = M68K_AND; 901 decoded->op = M68K_AND;
897 decoded->extra.size = (*istream >> 6); 902 decoded->extra.size = (*istream >> 6);
898 decoded->src.addr_mode = MODE_REG; 903 decoded->src.addr_mode = MODE_REG;
899 decoded->src.params.regs.pri = m68K_reg_quick_field(*istream); 904 decoded->src.params.regs.pri = m68k_reg_quick_field(*istream);
900 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->dst)); 905 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->dst));
901 } 906 }
902 } 907 }
903 break; 908 break;
904 case ADD_ADDX: 909 case ADD_ADDX:
909 if (*istream & 0x6) { 914 if (*istream & 0x6) {
910 if (size == OPSIZE_INVALID) { 915 if (size == OPSIZE_INVALID) {
911 //ADDA.l 916 //ADDA.l
912 decoded->extra.size = OPSIZE_LONG; 917 decoded->extra.size = OPSIZE_LONG;
913 decoded->dst.addr_mode = MODE_AREG; 918 decoded->dst.addr_mode = MODE_AREG;
919 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
914 istream = m68k_decode_op(istream, OPSIZE_LONG, &(decoded->src)); 920 istream = m68k_decode_op(istream, OPSIZE_LONG, &(decoded->src));
915 } else { 921 } else {
916 decoded->extra.size = size; 922 decoded->extra.size = size;
917 decoded->src.addr_mode = MODE_REG; 923 decoded->src.addr_mode = MODE_REG;
924 decoded->src.params.regs.pri = m68k_reg_quick_field(*istream);
918 istream = m68k_decode_op(istream, size, &(decoded->dst)); 925 istream = m68k_decode_op(istream, size, &(decoded->dst));
919 } 926 }
920 } else { 927 } else {
921 //ADDX 928 //ADDX
922 decoded->op = M68K_ADDX; 929 decoded->op = M68K_ADDX;
923 //FIXME: Size is not technically correct 930 //FIXME: Size is not technically correct
924 decoded->extra.size = size; 931 decoded->extra.size = size;
925 istream = m68k_decode_op(istream, size, &(decoded->src)); 932 istream = m68k_decode_op(istream, size, &(decoded->src));
926 decoded->dst.addr_mode = decoded->src.addr_mode; 933 decoded->dst.addr_mode = decoded->src.addr_mode;
927 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 934 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
928 } 935 }
929 } else { 936 } else {
930 if (size == OPSIZE_INVALID) { 937 if (size == OPSIZE_INVALID) {
931 //ADDA.w 938 //ADDA.w
932 decoded->extra.size = OPSIZE_WORD; 939 decoded->extra.size = OPSIZE_WORD;
933 decoded->dst.addr_mode = MODE_AREG; 940 decoded->dst.addr_mode = MODE_AREG;
934 } else { 941 } else {
935 decoded->extra.size = size; 942 decoded->extra.size = size;
936 decoded->dst.addr_mode = MODE_REG; 943 decoded->dst.addr_mode = MODE_REG;
937 } 944 }
938 decoded->dst.params.regs.pri = m68K_reg_quick_field(*istream); 945 decoded->dst.params.regs.pri = m68k_reg_quick_field(*istream);
939 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src)); 946 istream = m68k_decode_op(istream, decoded->extra.size, &(decoded->src));
940 } 947 }
941 break; 948 break;
942 case SHIFT_ROTATE: 949 case SHIFT_ROTATE:
943 if ((*istream & 0x8C0) == 0xC0) { 950 if ((*istream & 0x8C0) == 0xC0) {