2 * m68k micro operations
4 * Copyright (c) 2006-2007 CodeSourcery
5 * Written by Paul Brook
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "m68k-qreg.h"
26 #define offsetof(type, field) ((size_t) &((type *)0)->field)
29 static long qreg_offsets[] = {
30 #define DEFO32(name, offset) offsetof(CPUState, offset),
31 #define DEFR(name, reg, mode) -1,
32 #define DEFF64(name, offset) offsetof(CPUState, offset),
37 #define CPU_FP_STATUS env->fp_status
39 #define RAISE_EXCEPTION(n) do { \
40 env->exception_index = n; \
44 #define get_op helper_get_op
45 #define set_op helper_set_op
46 #define get_opf64 helper_get_opf64
47 #define set_opf64 helper_set_opf64
51 if (qreg >= TARGET_NUM_QREGS) {
52 return env->qregs[qreg - TARGET_NUM_QREGS];
53 } else if (qreg == QREG_T0) {
56 return *(uint32_t *)(((long)env) + qreg_offsets[qreg]);
60 void set_op(int qreg, uint32_t val)
62 if (qreg >= TARGET_NUM_QREGS) {
63 env->qregs[qreg - TARGET_NUM_QREGS] = val;
64 } else if (qreg == QREG_T0) {
67 *(uint32_t *)(((long)env) + qreg_offsets[qreg]) = val;
71 float64 get_opf64(int qreg)
73 if (qreg < TARGET_NUM_QREGS) {
74 return *(float64 *)(((long)env) + qreg_offsets[qreg]);
76 return *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS];
80 void set_opf64(int qreg, float64 val)
82 if (qreg < TARGET_NUM_QREGS) {
83 *(float64 *)(((long)env) + qreg_offsets[qreg]) = val;
85 *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS] = val;
89 #define OP(name) void OPPROTO glue(op_,name) (void)
93 set_op(PARAM1, get_op(PARAM2));
99 set_op(PARAM1, PARAM2);
105 set_opf64(PARAM1, get_opf64(PARAM2));
111 set_opf64(PARAM1, 0);
117 uint32_t op2 = get_op(PARAM2);
118 uint32_t op3 = get_op(PARAM3);
119 set_op(PARAM1, op2 + op3);
125 uint32_t op2 = get_op(PARAM2);
126 uint32_t op3 = get_op(PARAM3);
127 set_op(PARAM1, op2 - op3);
133 uint32_t op2 = get_op(PARAM2);
134 uint32_t op3 = get_op(PARAM3);
135 set_op(PARAM1, op2 * op3);
141 uint32_t arg = get_op(PARAM2);
142 set_op(PARAM1, ~arg);
148 uint32_t arg = get_op(PARAM2);
149 set_op(PARAM1, -arg);
155 uint32_t arg = get_op(PARAM2);
156 arg = (arg >> 24) | (arg << 24)
157 | ((arg >> 16) & 0xff00) | ((arg << 16) & 0xff0000);
164 uint32_t op1 = get_op(PARAM1);
165 uint32_t op2 = get_op(PARAM2);
167 env->cc_dest &= ~CCF_Z;
169 env->cc_dest |= CCF_Z;
175 uint32_t arg = get_op(PARAM2);
177 for (n = 32; arg; n--)
185 uint32_t op1 = get_op(PARAM1);
186 uint32_t op2 = get_op(PARAM2);
189 env->cc_x = (op1 <= op2);
190 env->cc_op = CC_OP_SUBX;
191 res = op1 - (op2 + 1);
193 env->cc_x = (op1 < op2);
194 env->cc_op = CC_OP_SUB;
203 uint32_t op1 = get_op(PARAM1);
204 uint32_t op2 = get_op(PARAM2);
208 env->cc_x = (res <= op2);
209 env->cc_op = CC_OP_ADDX;
212 env->cc_x = (res < op2);
213 env->cc_op = CC_OP_ADD;
223 uint32_t op2 = get_op(PARAM2);
224 uint32_t op3 = get_op(PARAM3);
225 set_op(PARAM1, op2 & op3);
231 uint32_t op2 = get_op(PARAM2);
232 uint32_t op3 = get_op(PARAM3);
233 set_op(PARAM1, op2 | op3);
239 uint32_t op2 = get_op(PARAM2);
240 uint32_t op3 = get_op(PARAM3);
241 set_op(PARAM1, op2 ^ op3);
248 uint32_t op2 = get_op(PARAM2);
249 uint32_t op3 = get_op(PARAM3);
252 set_op(PARAM1, result);
258 uint32_t op1 = get_op(PARAM1);
259 uint32_t op2 = get_op(PARAM2);
262 set_op(PARAM1, result);
263 env->cc_x = (op1 << (op2 - 1)) & 1;
269 uint32_t op2 = get_op(PARAM2);
270 uint32_t op3 = get_op(PARAM3);
273 set_op(PARAM1, result);
279 uint32_t op1 = get_op(PARAM1);
280 uint32_t op2 = get_op(PARAM2);
283 set_op(PARAM1, result);
284 env->cc_x = (op1 >> (op2 - 1)) & 1;
290 int32_t op2 = get_op(PARAM2);
291 uint32_t op3 = get_op(PARAM3);
294 set_op(PARAM1, result);
300 int32_t op1 = get_op(PARAM1);
301 uint32_t op2 = get_op(PARAM2);
304 set_op(PARAM1, result);
305 env->cc_x = (op1 >> (op2 - 1)) & 1;
313 uint32_t op2 = get_op(PARAM2);
314 set_op(PARAM1, (uint8_t)op2);
320 uint32_t op2 = get_op(PARAM2);
321 set_op(PARAM1, (int8_t)op2);
327 uint32_t op2 = get_op(PARAM2);
328 set_op(PARAM1, (uint16_t)op2);
334 uint32_t op2 = get_op(PARAM2);
335 set_op(PARAM1, (int16_t)op2);
342 if (cc_op == CC_OP_DYNAMIC)
344 cpu_m68k_flush_flags(env, cc_op);
358 /* ??? This needs to make sure the throwing location is accurate. */
360 RAISE_EXCEPTION(EXCP_DIV0);
364 /* Avoid using a PARAM1 of zero. This breaks dyngen because it uses
365 the address of a symbol, and gcc knows symbols can't have address
367 if (PARAM1 == 2 && quot > 0xffff)
371 else if ((int32_t)quot < 0)
375 env->cc_dest = flags;
390 RAISE_EXCEPTION(EXCP_DIV0);
394 if (PARAM1 == 2 && quot != (int16_t)quot)
402 env->cc_dest = flags;
406 /* Halt is special because it may be a semihosting call. */
409 RAISE_EXCEPTION(EXCP_HALT_INSN);
416 RAISE_EXCEPTION(EXCP_HLT);
422 RAISE_EXCEPTION(PARAM1);
426 /* Floating point comparison sets flags differently to other instructions. */
432 src0 = get_opf64(PARAM2);
433 src1 = get_opf64(PARAM3);
434 set_opf64(PARAM1, helper_sub_cmpf64(env, src0, src1));
440 uint32_t op1 = get_op(PARAM1);
447 uint32_t op1 = get_op(PARAM1);
448 uint32_t op2 = get_op(PARAM2);
449 env->cc_x = (op1 < op2);
455 set_op(PARAM1, env->cc_x);
461 uint32_t op1 = get_op(PARAM1);
468 uint32_t op1 = get_op(PARAM1);
469 uint32_t op2 = get_op(PARAM2);
477 env->fp_result = get_opf64(PARAM1);
483 env->sr = get_op(PARAM1);
493 /* These ops involve a function call, which probably requires a stack frame
494 and breaks things on some hosts. */
497 uint32_t arg = get_op(PARAM1);
505 uint32_t arg = get_op(PARAM1);
513 int32_t arg = get_op(PARAM1);
521 int32_t arg = get_op(PARAM1);
527 void OPPROTO op_goto_tb0(void)
529 GOTO_TB(op_goto_tb0, PARAM1, 0);
532 void OPPROTO op_goto_tb1(void)
534 GOTO_TB(op_goto_tb1, PARAM1, 1);
543 /* Floating point. */
546 set_op(PARAM1, float64_to_int32(get_opf64(PARAM2), &CPU_FP_STATUS));
556 u.f = float64_to_float32(get_opf64(PARAM2), &CPU_FP_STATUS);
563 set_opf64(PARAM1, int32_to_float64(get_op(PARAM2), &CPU_FP_STATUS));
573 u.i = get_op(PARAM2);
574 set_opf64(PARAM1, float32_to_float64(u.f, &CPU_FP_STATUS));
580 float64 op0 = get_opf64(PARAM2);
581 set_opf64(PARAM1, float64_abs(op0));
587 float64 op0 = get_opf64(PARAM2);
588 set_opf64(PARAM1, float64_chs(op0));
594 float64 op0 = get_opf64(PARAM2);
595 set_opf64(PARAM1, float64_sqrt(op0, &CPU_FP_STATUS));
601 float64 op0 = get_opf64(PARAM2);
602 float64 op1 = get_opf64(PARAM3);
603 set_opf64(PARAM1, float64_add(op0, op1, &CPU_FP_STATUS));
609 float64 op0 = get_opf64(PARAM2);
610 float64 op1 = get_opf64(PARAM3);
611 set_opf64(PARAM1, float64_sub(op0, op1, &CPU_FP_STATUS));
617 float64 op0 = get_opf64(PARAM2);
618 float64 op1 = get_opf64(PARAM3);
619 set_opf64(PARAM1, float64_mul(op0, op1, &CPU_FP_STATUS));
625 float64 op0 = get_opf64(PARAM2);
626 float64 op1 = get_opf64(PARAM3);
627 set_opf64(PARAM1, float64_div(op0, op1, &CPU_FP_STATUS));
633 float64 op0 = get_opf64(PARAM2);
634 set_opf64(PARAM1, float64_round_to_int(op0, &CPU_FP_STATUS));
640 float64 op0 = get_opf64(PARAM2);
641 set_opf64(PARAM1, float64_trunc_to_int(op0, &CPU_FP_STATUS));
647 float64 op0 = get_opf64(PARAM2);
648 float64 op1 = get_opf64(PARAM3);
649 set_op(PARAM1, float64_compare_quiet(op0, op1, &CPU_FP_STATUS));
655 int op1 = get_op(PARAM1);
656 uint32_t op2 = get_op(PARAM2);
657 helper_movec(env, op1, op2);
662 #define MEMSUFFIX _raw
665 #if !defined(CONFIG_USER_ONLY)
666 #define MEMSUFFIX _user
668 #define MEMSUFFIX _kernel
673 /* TODO: The MAC instructions use 64-bit arithmetic fairly extensively.
674 This results in fairly large ops (and sometimes other issues) on 32-bit
675 hosts. Maybe move most of them into helpers. */
678 uint32_t op1 = get_op(PARAM1);
679 uint32_t op2 = get_op(PARAM2);
683 product = (uint64_t)op1 * op2;
684 res = (product << 24) >> 24;
685 if (res != product) {
686 env->macsr |= MACSR_V;
687 if (env->macsr & MACSR_OMC) {
688 /* Make sure the accumulate operation overflows. */
701 uint32_t op1 = get_op(PARAM1);
702 uint32_t op2 = get_op(PARAM2);
705 product = (uint64_t)op1 * op2;
706 if (product & (0xffffffull << 40)) {
707 env->macsr |= MACSR_V;
708 if (env->macsr & MACSR_OMC) {
709 /* Make sure the accumulate operation overflows. */
712 product &= ((1ull << 40) - 1);
715 env->mactmp = product;
721 int32_t op1 = get_op(PARAM1);
722 int32_t op2 = get_op(PARAM2);
726 product = (uint64_t)op1 * op2;
727 if (env->macsr & MACSR_RT) {
728 remainder = product & 0xffffff;
730 if (remainder > 0x800000)
732 else if (remainder == 0x800000)
733 product += (product & 1);
737 env->mactmp = product;
754 env->macc[acc] += env->mactmp;
761 env->macc[acc] -= env->mactmp;
771 sum = env->macc[acc];
772 result = (sum << 16) >> 16;
774 env->macsr |= MACSR_V;
776 if (env->macsr & MACSR_V) {
777 env->macsr |= MACSR_PAV0 << acc;
778 if (env->macsr & MACSR_OMC) {
779 /* The result is saturated to 32 bits, despite overflow occuring
780 at 48 bits. Seems weird, but that's what the hardware docs
782 result = (result >> 63) ^ 0x7fffffff;
785 env->macc[acc] = result;
794 sum = env->macc[acc];
795 if (sum & (0xffffull << 48)) {
796 env->macsr |= MACSR_V;
798 if (env->macsr & MACSR_V) {
799 env->macsr |= MACSR_PAV0 << acc;
800 if (env->macsr & MACSR_OMC) {
801 if (sum > (1ull << 53))
804 sum = (1ull << 48) - 1;
806 sum &= ((1ull << 48) - 1);
818 sum = env->macc[acc];
819 result = (sum << 16) >> 16;
821 env->macsr |= MACSR_V;
823 if (env->macsr & MACSR_V) {
824 env->macsr |= MACSR_PAV0 << acc;
825 if (env->macsr & MACSR_OMC) {
826 result = (result >> 63) ^ 0x7fffffffffffll;
829 env->macc[acc] = result;
835 env->macsr &= ~(MACSR_V | MACSR_Z | MACSR_N | MACSR_EV);
842 val = env->macc[acc];
844 env->macsr |= MACSR_Z;
845 else if (val & (1ull << 47));
846 env->macsr |= MACSR_N;
847 if (env->macsr & (MACSR_PAV0 << acc)) {
848 env->macsr |= MACSR_V;
850 if (env->macsr & MACSR_FI) {
851 val = ((int64_t)val) >> 40;
852 if (val != 0 && val != -1)
853 env->macsr |= MACSR_EV;
854 } else if (env->macsr & MACSR_SU) {
855 val = ((int64_t)val) >> 32;
856 if (val != 0 && val != -1)
857 env->macsr |= MACSR_EV;
859 if ((val >> 32) != 0)
860 env->macsr |= MACSR_EV;
872 val = env->macc[acc];
873 if (env->macsr & MACSR_SU) {
874 /* 16-bit rounding. */
875 rem = val & 0xffffff;
876 val = (val >> 24) & 0xffffu;
879 else if (rem == 0x800000)
881 } else if (env->macsr & MACSR_RT) {
882 /* 32-bit rounding. */
887 else if (rem == 0x80)
893 if (env->macsr & MACSR_OMC) {
895 if (env->macsr & MACSR_SU) {
896 if (val != (uint16_t) val) {
897 result = ((val >> 63) ^ 0x7fff) & 0xffff;
899 result = val & 0xffff;
902 if (val != (uint32_t)val) {
903 result = ((uint32_t)(val >> 63) & 0x7fffffff);
905 result = (uint32_t)val;
910 if (env->macsr & MACSR_SU) {
911 result = val & 0xffff;
913 result = (uint32_t)val;
916 set_op(PARAM1, result);
923 set_op(PARAM1, (uint32_t)env->macc[acc]);
930 int64_t val = env->macc[acc];
932 if (val == (int32_t)val) {
933 result = (int32_t)val;
935 result = (val >> 61) ^ 0x7fffffff;
937 set_op(PARAM1, result);
944 uint64_t val = env->macc[acc];
946 if ((val >> 32) == 0) {
947 result = (uint32_t)val;
949 result = 0xffffffffu;
951 set_op(PARAM1, result);
960 env->macsr &= ~(MACSR_PAV0 << acc);
969 env->macc[dest] = env->macc[src];
970 mask = MACSR_PAV0 << dest;
971 if (env->macsr & (MACSR_PAV0 << src))
982 val = env->macc[acc] & 0x00ff;
983 val = (env->macc[acc] >> 32) & 0xff00;
984 val |= (env->macc[acc + 1] << 16) & 0x00ff0000;
985 val |= (env->macc[acc + 1] >> 16) & 0xff000000;
994 val = (env->macc[acc] >> 32) & 0xffff;
995 val |= (env->macc[acc + 1] >> 16) & 0xffff0000;
1003 int32_t val = get_op(PARAM1);
1004 env->macc[acc] = ((int64_t)val) << 8;
1005 env->macsr &= ~(MACSR_PAV0 << acc);
1012 int32_t val = get_op(PARAM1);
1013 env->macc[acc] = val;
1014 env->macsr &= ~(MACSR_PAV0 << acc);
1021 uint32_t val = get_op(PARAM1);
1022 env->macc[acc] = val;
1023 env->macsr &= ~(MACSR_PAV0 << acc);
1030 int32_t val = get_op(PARAM1);
1033 res = env->macc[acc] & 0xffffffff00ull;
1034 tmp = (int16_t)(val & 0xff00);
1035 res |= ((int64_t)tmp) << 32;
1037 env->macc[acc] = res;
1038 res = env->macc[acc + 1] & 0xffffffff00ull;
1039 tmp = (val & 0xff000000);
1040 res |= ((int64_t)tmp) << 16;
1041 res |= (val >> 16) & 0xff;
1042 env->macc[acc + 1] = res;
1048 int32_t val = get_op(PARAM1);
1051 res = (uint32_t)env->macc[acc];
1053 res |= ((int64_t)tmp) << 32;
1054 env->macc[acc] = res;
1055 res = (uint32_t)env->macc[acc + 1];
1056 tmp = val & 0xffff0000;
1057 res |= (int64_t)tmp << 16;
1058 env->macc[acc + 1] = res;
1064 int32_t val = get_op(PARAM1);
1066 res = (uint32_t)env->macc[acc];
1067 res |= ((uint64_t)(val & 0xffff)) << 32;
1068 env->macc[acc] = res;
1069 res = (uint32_t)env->macc[acc + 1];
1070 res |= (uint64_t)(val & 0xffff0000) << 16;
1071 env->macc[acc + 1] = res;
1076 m68k_set_macsr(env, get_op(PARAM1));