Convert m68k target to TCG.

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@4565 c046a42c-6fe2-441c-8c8c-71466251a162

Convert m68k target to TCG.
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@4565 c046a42c-6fe2-441c-8c8c-71466251a162
pbrook
1 parent 3979144c
Showing 10 changed files with 763 additions and 1316 deletions
configure
target-m68k/cpu.h
target-m68k/exec.h
target-m68k/helper.c
target-m68k/helpers.h
target-m68k/op-hacks.h
target-m68k/op.c
target-m68k/op_helper.c
target-m68k/op_mem.h
target-m68k/qregs.def
@@ -1237,10 +1237,8 @@ case &quot;$target_cpu&quot; in
   ;;
   m68k)
     echo "TARGET_ARCH=m68k" >> $config_mak
-    echo "CONFIG_DYNGEN_OP=yes" >> $config_mak
     echo "#define TARGET_ARCH \"m68k\"" >> $config_h
     echo "#define TARGET_M68K 1" >> $config_h
-    echo "#define CONFIG_DYNGEN_OP 1" >> $config_h
     bflt="yes"
   ;;
   mips|mipsel)
@@ -108,7 +108,7 @@ typedef struct CPUM68KState {
     int exception_index;
     int interrupt_request;
     int user_mode_only;
-    int halted;
+    uint32_t halted;
     int pending_vector;
     int pending_level;
@@ -120,6 +120,7 @@ typedef struct CPUM68KState {
     uint32_t features;
 } CPUM68KState;
+void m68k_tcg_init(void);
 CPUM68KState *cpu_m68k_init(const char *cpu_model);
 int cpu_m68k_exec(CPUM68KState *s);
 void cpu_m68k_close(CPUM68KState *s);
@@ -141,9 +142,7 @@ enum {
     CC_OP_CMPW,  /* CC_DEST = result, CC_SRC = source */
     CC_OP_ADDX,  /* CC_DEST = result, CC_SRC = source */
     CC_OP_SUBX,  /* CC_DEST = result, CC_SRC = source */
-    CC_OP_SHL,   /* CC_DEST = source, CC_SRC = shift */
-    CC_OP_SHR,   /* CC_DEST = source, CC_SRC = shift */
-    CC_OP_SAR,   /* CC_DEST = source, CC_SRC = shift */
+    CC_OP_SHIFT, /* CC_DEST = result, CC_SRC = carry */
 };
 #define CCF_C 0x01
@@ -45,8 +45,6 @@ int cpu_m68k_handle_mmu_fault (CPUState *env, target_ulong address, int rw,
 #endif
 void cpu_m68k_flush_flags(CPUM68KState *env, int cc_op);
-float64 helper_sub_cmpf64(CPUM68KState *env, float64 src0, float64 src1);
-void helper_movec(CPUM68KState *env, int reg, uint32_t val);
 void cpu_loop_exit(void);
@@ -27,6 +27,10 @@
 #include "exec-all.h"
 #include "qemu-common.h"
+#include "helpers.h"
+
+#define SIGNBIT (1u << 31)
+
 enum m68k_cpuid {
     M68K_CPUID_M5206,
     M68K_CPUID_M5208,
@@ -121,11 +125,16 @@ void cpu_reset(CPUM68KState *env)
 CPUM68KState *cpu_m68k_init(const char *cpu_model)
 {
     CPUM68KState *env;
+    static int inited;
     env = malloc(sizeof(CPUM68KState));
     if (!env)
         return NULL;
     cpu_exec_init(env);
+    if (!inited) {
+        inited = 1;
+        m68k_tcg_init();
+    }
     env->cpu_model_str = cpu_model;
@@ -211,34 +220,9 @@ void cpu_m68k_flush_flags(CPUM68KState *env, int cc_op)
         if (HIGHBIT & (tmp ^ dest) & (tmp ^ src))
             flags |= CCF_V;
         break;
-    case CC_OP_SHL:
-        if (src >= 32) {
-            SET_NZ(0);
-        } else {
-            tmp = dest << src;
-            SET_NZ(tmp);
-        }
-        if (src && src <= 32 && (dest & (1 << (32 - src))))
-            flags |= CCF_C;
-        break;
-    case CC_OP_SHR:
-        if (src >= 32) {
-            SET_NZ(0);
-        } else {
-            tmp = dest >> src;
-            SET_NZ(tmp);
-        }
-        if (src && src <= 32 && ((dest >> (src - 1)) & 1))
-            flags |= CCF_C;
-        break;
-    case CC_OP_SAR:
-        if (src >= 32) {
-            SET_NZ(-1);
-        } else {
-            tmp = (int32_t)dest >> src;
-            SET_NZ(tmp);
-        }
-        if (src && src <= 32 && (((int32_t)dest >> (src - 1)) & 1))
+    case CC_OP_SHIFT:
+        SET_NZ(dest);
+        if (src)
             flags |= CCF_C;
         break;
     default:
@@ -248,25 +232,7 @@ void cpu_m68k_flush_flags(CPUM68KState *env, int cc_op)
     env->cc_dest = flags;
 }
-float64 helper_sub_cmpf64(CPUM68KState *env, float64 src0, float64 src1)
-{
-    /* ??? This may incorrectly raise exceptions.  */
-    /* ??? Should flush denormals to zero.  */
-    float64 res;
-    res = float64_sub(src0, src1, &env->fp_status);
-    if (float64_is_nan(res)) {
-        /* +/-inf compares equal against itself, but sub returns nan.  */
-        if (!float64_is_nan(src0)
-            && !float64_is_nan(src1)) {
-            res = float64_zero;
-            if (float64_lt_quiet(src0, res, &env->fp_status))
-                res = float64_chs(res);
-        }
-    }
-    return res;
-}
-
-void helper_movec(CPUM68KState *env, int reg, uint32_t val)
+void HELPER(movec)(CPUM68KState *env, uint32_t reg, uint32_t val)
 {
     switch (reg) {
     case 0x02: /* CACR */
@@ -286,7 +252,7 @@ void helper_movec(CPUM68KState *env, int reg, uint32_t val)
     }
 }
-void m68k_set_macsr(CPUM68KState *env, uint32_t val)
+void HELPER(set_macsr)(CPUM68KState *env, uint32_t val)
 {
     uint32_t acc;
     int8_t exthigh;
@@ -376,3 +342,541 @@ void m68k_set_irq_level(CPUM68KState *env, int level, uint8_t vector)
 }
 #endif
+
+uint32_t HELPER(bitrev)(uint32_t x)
+{
+    x = ((x >> 1) & 0x55555555u) | ((x << 1) & 0xaaaaaaaau);
+    x = ((x >> 2) & 0x33333333u) | ((x << 2) & 0xccccccccu);
+    x = ((x >> 4) & 0x0f0f0f0fu) | ((x << 4) & 0xf0f0f0f0u);
+    return bswap32(x);
+}
+
+uint32_t HELPER(ff1)(uint32_t x)
+{
+    int n;
+    for (n = 32; x; n--)
+        x >>= 1;
+    return n;
+}
+
+uint32_t HELPER(sats)(uint32_t val, uint32_t ccr)
+{
+    /* The result has the opposite sign to the original value.  */
+    if (ccr & CCF_V)
+        val = (((int32_t)val) >> 31) ^ SIGNBIT;
+    return val;
+}
+
+uint32_t HELPER(subx_cc)(CPUState *env, uint32_t op1, uint32_t op2)
+{
+    uint32_t res;
+    uint32_t old_flags;
+
+    old_flags = env->cc_dest;
+    if (env->cc_x) {
+        env->cc_x = (op1 <= op2);
+        env->cc_op = CC_OP_SUBX;
+        res = op1 - (op2 + 1);
+    } else {
+        env->cc_x = (op1 < op2);
+        env->cc_op = CC_OP_SUB;
+        res = op1 - op2;
+    }
+    env->cc_dest = res;
+    env->cc_src = op2;
+    cpu_m68k_flush_flags(env, env->cc_op);
+    /* !Z is sticky.  */
+    env->cc_dest &= (old_flags | ~CCF_Z);
+    return res;
+}
+
+uint32_t HELPER(addx_cc)(CPUState *env, uint32_t op1, uint32_t op2)
+{
+    uint32_t res;
+    uint32_t old_flags;
+
+    old_flags = env->cc_dest;
+    if (env->cc_x) {
+        res = op1 + op2 + 1;
+        env->cc_x = (res <= op2);
+        env->cc_op = CC_OP_ADDX;
+    } else {
+        res = op1 + op2;
+        env->cc_x = (res < op2);
+        env->cc_op = CC_OP_ADD;
+    }
+    env->cc_dest = res;
+    env->cc_src = op2;
+    cpu_m68k_flush_flags(env, env->cc_op);
+    /* !Z is sticky.  */
+    env->cc_dest &= (old_flags | ~CCF_Z);
+    return res;
+}
+
+uint32_t HELPER(xflag_lt)(uint32_t a, uint32_t b)
+{
+    return a < b;
+}
+
+uint32_t HELPER(btest)(uint32_t x)
+{
+    return x != 0;
+}
+
+void HELPER(set_sr)(CPUState *env, uint32_t val)
+{
+    env->sr = val & 0xffff;
+    m68k_switch_sp(env);
+}
+
+uint32_t HELPER(shl_cc)(CPUState *env, uint32_t val, uint32_t shift)
+{
+    uint32_t result;
+    uint32_t cf;
+
+    shift &= 63;
+    if (shift == 0) {
+        result = val;
+        cf = env->cc_src & CCF_C;
+    } else if (shift < 32) {
+        result = val << shift;
+        cf = (val >> (32 - shift)) & 1;
+    } else if (shift == 32) {
+        result = 0;
+        cf = val & 1;
+    } else /* shift > 32 */ {
+        result = 0;
+        cf = 0;
+    }
+    env->cc_src = cf;
+    env->cc_x = (cf != 0);
+    env->cc_dest = result;
+    return result;
+}
+
+uint32_t HELPER(shr_cc)(CPUState *env, uint32_t val, uint32_t shift)
+{
+    uint32_t result;
+    uint32_t cf;
+
+    shift &= 63;
+    if (shift == 0) {
+        result = val;
+        cf = env->cc_src & CCF_C;
+    } else if (shift < 32) {
+        result = val >> shift;
+        cf = (val >> (shift - 1)) & 1;
+    } else if (shift == 32) {
+        result = 0;
+        cf = val >> 31;
+    } else /* shift > 32 */ {
+        result = 0;
+        cf = 0;
+    }
+    env->cc_src = cf;
+    env->cc_x = (cf != 0);
+    env->cc_dest = result;
+    return result;
+}
+
+uint32_t HELPER(sar_cc)(CPUState *env, uint32_t val, uint32_t shift)
+{
+    uint32_t result;
+    uint32_t cf;
+
+    shift &= 63;
+    if (shift == 0) {
+        result = val;
+        cf = (env->cc_src & CCF_C) != 0;
+    } else if (shift < 32) {
+        result = (int32_t)val >> shift;
+        cf = (val >> (shift - 1)) & 1;
+    } else /* shift >= 32 */ {
+        result = (int32_t)val >> 31;
+        cf = val >> 31;
+    }
+    env->cc_src = cf;
+    env->cc_x = cf;
+    env->cc_dest = result;
+    return result;
+}
+
+/* FPU helpers.  */
+uint32_t HELPER(f64_to_i32)(CPUState *env, float64 val)
+{
+    return float64_to_int32(val, &env->fp_status);
+}
+
+float32 HELPER(f64_to_f32)(CPUState *env, float64 val)
+{
+    return float64_to_float32(val, &env->fp_status);
+}
+
+float64 HELPER(i32_to_f64)(CPUState *env, uint32_t val)
+{
+    return int32_to_float64(val, &env->fp_status);
+}
+
+float64 HELPER(f32_to_f64)(CPUState *env, float32 val)
+{
+    return float32_to_float64(val, &env->fp_status);
+}
+
+float64 HELPER(iround_f64)(CPUState *env, float64 val)
+{
+    return float64_round_to_int(val, &env->fp_status);
+}
+
+float64 HELPER(itrunc_f64)(CPUState *env, float64 val)
+{
+    return float64_trunc_to_int(val, &env->fp_status);
+}
+
+float64 HELPER(sqrt_f64)(CPUState *env, float64 val)
+{
+    return float64_sqrt(val, &env->fp_status);
+}
+
+float64 HELPER(abs_f64)(float64 val)
+{
+    return float64_abs(val);
+}
+
+float64 HELPER(chs_f64)(float64 val)
+{
+    return float64_chs(val);
+}
+
+float64 HELPER(add_f64)(CPUState *env, float64 a, float64 b)
+{
+    return float64_add(a, b, &env->fp_status);
+}
+
+float64 HELPER(sub_f64)(CPUState *env, float64 a, float64 b)
+{
+    return float64_sub(a, b, &env->fp_status);
+}
+
+float64 HELPER(mul_f64)(CPUState *env, float64 a, float64 b)
+{
+    return float64_mul(a, b, &env->fp_status);
+}
+
+float64 HELPER(div_f64)(CPUState *env, float64 a, float64 b)
+{
+    return float64_div(a, b, &env->fp_status);
+}
+
+float64 HELPER(sub_cmp_f64)(CPUState *env, float64 a, float64 b)
+{
+    /* ??? This may incorrectly raise exceptions.  */
+    /* ??? Should flush denormals to zero.  */
+    float64 res;
+    res = float64_sub(a, b, &env->fp_status);
+    if (float64_is_nan(res)) {
+        /* +/-inf compares equal against itself, but sub returns nan.  */
+        if (!float64_is_nan(a)
+            && !float64_is_nan(b)) {
+            res = float64_zero;
+            if (float64_lt_quiet(a, res, &env->fp_status))
+                res = float64_chs(res);
+        }
+    }
+    return res;
+}
+
+uint32_t HELPER(compare_f64)(CPUState *env, float64 val)
+{
+    return float64_compare_quiet(val, float64_zero, &env->fp_status);
+}
+
+/* MAC unit.  */
+/* FIXME: The MAC unit implementation is a bit of a mess.  Some helpers
+   take values,  others take register numbers and manipulate the contents
+   in-place.  */
+void HELPER(mac_move)(CPUState *env, uint32_t dest, uint32_t src)
+{
+    uint32_t mask;
+    env->macc[dest] = env->macc[src];
+    mask = MACSR_PAV0 << dest;
+    if (env->macsr & (MACSR_PAV0 << src))
+        env->macsr |= mask;
+    else
+        env->macsr &= ~mask;
+}
+
+uint64_t HELPER(macmuls)(CPUState *env, uint32_t op1, uint32_t op2)
+{
+    int64_t product;
+    int64_t res;
+
+    product = (uint64_t)op1 * op2;
+    res = (product << 24) >> 24;
+    if (res != product) {
+        env->macsr |= MACSR_V;
+        if (env->macsr & MACSR_OMC) {
+            /* Make sure the accumulate operation overflows.  */
+            if (product < 0)
+                res = ~(1ll << 50);
+            else
+                res = 1ll << 50;
+        }
+    }
+    return res;
+}
+
+uint64_t HELPER(macmulu)(CPUState *env, uint32_t op1, uint32_t op2)
+{
+    uint64_t product;
+
+    product = (uint64_t)op1 * op2;
+    if (product & (0xffffffull << 40)) {
+        env->macsr |= MACSR_V;
+        if (env->macsr & MACSR_OMC) {
+            /* Make sure the accumulate operation overflows.  */
+            product = 1ll << 50;
+        } else {
+            product &= ((1ull << 40) - 1);
+        }
+    }
+    return product;
+}
+
+uint64_t HELPER(macmulf)(CPUState *env, uint32_t op1, uint32_t op2)
+{
+    uint64_t product;
+    uint32_t remainder;
+
+    product = (uint64_t)op1 * op2;
+    if (env->macsr & MACSR_RT) {
+        remainder = product & 0xffffff;
+        product >>= 24;
+        if (remainder > 0x800000)
+            product++;
+        else if (remainder == 0x800000)
+            product += (product & 1);
+    } else {
+        product >>= 24;
+    }
+    return product;
+}
+
+void HELPER(macsats)(CPUState *env, uint32_t acc)
+{
+    int64_t tmp;
+    int64_t result;
+    tmp = env->macc[acc];
+    result = ((tmp << 16) >> 16);
+    if (result != tmp) {
+        env->macsr |= MACSR_V;
+    }
+    if (env->macsr & MACSR_V) {
+        env->macsr |= MACSR_PAV0 << acc;
+        if (env->macsr & MACSR_OMC) {
+            /* The result is saturated to 32 bits, despite overflow occuring
+               at 48 bits.  Seems weird, but that's what the hardware docs
+               say.  */
+            result = (result >> 63) ^ 0x7fffffff;
+        }
+    }
+    env->macc[acc] = result;
+}
+
+void HELPER(macsatu)(CPUState *env, uint32_t acc)
+{
+    uint64_t val;
+
+    val = env->macc[acc];
+    if (val & (0xffffull << 48)) {
+        env->macsr |= MACSR_V;
+    }
+    if (env->macsr & MACSR_V) {
+        env->macsr |= MACSR_PAV0 << acc;
+        if (env->macsr & MACSR_OMC) {
+            if (val > (1ull << 53))
+                val = 0;
+            else
+                val = (1ull << 48) - 1;
+        } else {
+            val &= ((1ull << 48) - 1);
+        }
+    }
+    env->macc[acc] = val;
+}
+
+void HELPER(macsatf)(CPUState *env, uint32_t acc)
+{
+    int64_t sum;
+    int64_t result;
+
+    sum = env->macc[acc];
+    result = (sum << 16) >> 16;
+    if (result != sum) {
+        env->macsr |= MACSR_V;
+    }
+    if (env->macsr & MACSR_V) {
+        env->macsr |= MACSR_PAV0 << acc;
+        if (env->macsr & MACSR_OMC) {
+            result = (result >> 63) ^ 0x7fffffffffffll;
+        }
+    }
+    env->macc[acc] = result;
+}
+
+void HELPER(mac_set_flags)(CPUState *env, uint32_t acc)
+{
+    uint64_t val;
+    val = env->macc[acc];
+    if (val == 0)
+        env->macsr |= MACSR_Z;
+    else if (val & (1ull << 47));
+        env->macsr |= MACSR_N;
+    if (env->macsr & (MACSR_PAV0 << acc)) {
+        env->macsr |= MACSR_V;
+    }
+    if (env->macsr & MACSR_FI) {
+        val = ((int64_t)val) >> 40;
+        if (val != 0 && val != -1)
+            env->macsr |= MACSR_EV;
+    } else if (env->macsr & MACSR_SU) {
+        val = ((int64_t)val) >> 32;
+        if (val != 0 && val != -1)
+            env->macsr |= MACSR_EV;
+    } else {
+        if ((val >> 32) != 0)
+            env->macsr |= MACSR_EV;
+    }
+}
+
+void HELPER(flush_flags)(CPUState *env, uint32_t cc_op)
+{
+    cpu_m68k_flush_flags(env, cc_op);
+}
+
+uint32_t HELPER(get_macf)(CPUState *env, uint64_t val)
+{
+    int rem;
+    uint32_t result;
+
+    if (env->macsr & MACSR_SU) {
+        /* 16-bit rounding.  */
+        rem = val & 0xffffff;
+        val = (val >> 24) & 0xffffu;
+        if (rem > 0x800000)
+            val++;
+        else if (rem == 0x800000)
+            val += (val & 1);
+    } else if (env->macsr & MACSR_RT) {
+        /* 32-bit rounding.  */
+        rem = val & 0xff;
+        val >>= 8;
+        if (rem > 0x80)
+            val++;
+        else if (rem == 0x80)
+            val += (val & 1);
+    } else {
+        /* No rounding.  */
+        val >>= 8;
+    }
+    if (env->macsr & MACSR_OMC) {
+        /* Saturate.  */
+        if (env->macsr & MACSR_SU) {
+            if (val != (uint16_t) val) {
+                result = ((val >> 63) ^ 0x7fff) & 0xffff;
+            } else {
+                result = val & 0xffff;
+            }
+        } else {
+            if (val != (uint32_t)val) {
+                result = ((uint32_t)(val >> 63) & 0x7fffffff);
+            } else {
+                result = (uint32_t)val;
+            }
+        }
+    } else {
+        /* No saturation.  */
+        if (env->macsr & MACSR_SU) {
+            result = val & 0xffff;
+        } else {
+            result = (uint32_t)val;
+        }
+    }
+    return result;
+}
+
+uint32_t HELPER(get_macs)(uint64_t val)
+{
+    if (val == (int32_t)val) {
+        return (int32_t)val;
+    } else {
+        return (val >> 61) ^ ~SIGNBIT;
+    }
+}
+
+uint32_t HELPER(get_macu)(uint64_t val)
+{
+    if ((val >> 32) == 0) {
+        return (uint32_t)val;
+    } else {
+        return 0xffffffffu;
+    }
+}
+
+uint32_t HELPER(get_mac_extf)(CPUState *env, uint32_t acc)
+{
+    uint32_t val;
+    val = env->macc[acc] & 0x00ff;
+    val = (env->macc[acc] >> 32) & 0xff00;
+    val |= (env->macc[acc + 1] << 16) & 0x00ff0000;
+    val |= (env->macc[acc + 1] >> 16) & 0xff000000;
+    return val;
+}
+
+uint32_t HELPER(get_mac_exti)(CPUState *env, uint32_t acc)
+{
+    uint32_t val;
+    val = (env->macc[acc] >> 32) & 0xffff;
+    val |= (env->macc[acc + 1] >> 16) & 0xffff0000;
+    return val;
+}
+
+void HELPER(set_mac_extf)(CPUState *env, uint32_t val, uint32_t acc)
+{
+    int64_t res;
+    int32_t tmp;
+    res = env->macc[acc] & 0xffffffff00ull;
+    tmp = (int16_t)(val & 0xff00);
+    res |= ((int64_t)tmp) << 32;
+    res |= val & 0xff;
+    env->macc[acc] = res;
+    res = env->macc[acc + 1] & 0xffffffff00ull;
+    tmp = (val & 0xff000000);
+    res |= ((int64_t)tmp) << 16;
+    res |= (val >> 16) & 0xff;
+    env->macc[acc + 1] = res;
+}
+
+void HELPER(set_mac_exts)(CPUState *env, uint32_t val, uint32_t acc)
+{
+    int64_t res;
+    int32_t tmp;
+    res = (uint32_t)env->macc[acc];
+    tmp = (int16_t)val;
+    res |= ((int64_t)tmp) << 32;
+    env->macc[acc] = res;
+    res = (uint32_t)env->macc[acc + 1];
+    tmp = val & 0xffff0000;
+    res |= (int64_t)tmp << 16;
+    env->macc[acc + 1] = res;
+}
+
+void HELPER(set_mac_extu)(CPUState *env, uint32_t val, uint32_t acc)
+{
+    uint64_t res;
+    res = (uint32_t)env->macc[acc];
+    res |= ((uint64_t)(val & 0xffff)) << 32;
+    env->macc[acc] = res;
+    res = (uint32_t)env->macc[acc + 1];
+    res |= (uint64_t)(val & 0xffff0000) << 16;
+    env->macc[acc + 1] = res;
+}
+#ifndef DEF_HELPER
+#define DEF_HELPER(name, ret, args) ret glue(helper_,name) args;
+#endif
+
+#ifdef GEN_HELPER
+#define DEF_HELPER_0_0(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(void) \
+{ \
+    tcg_gen_helper_0_0(helper_##name); \
+}
+#define DEF_HELPER_0_1(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(TCGv arg1) \
+{ \
+    tcg_gen_helper_0_1(helper_##name, arg1); \
+}
+#define DEF_HELPER_0_2(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(TCGv arg1, TCGv arg2) \
+{ \
+    tcg_gen_helper_0_2(helper_##name, arg1, arg2); \
+}
+#define DEF_HELPER_0_3(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name( \
+    TCGv arg1, TCGv arg2, TCGv arg3) \
+{ \
+    tcg_gen_helper_0_3(helper_##name, arg1, arg2, arg3); \
+}
+#define DEF_HELPER_1_0(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(TCGv ret) \
+{ \
+    tcg_gen_helper_1_0(helper_##name, ret); \
+}
+#define DEF_HELPER_1_1(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(TCGv ret, TCGv arg1) \
+{ \
+    tcg_gen_helper_1_1(helper_##name, ret, arg1); \
+}
+#define DEF_HELPER_1_2(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(TCGv ret, TCGv arg1, TCGv arg2) \
+{ \
+    tcg_gen_helper_1_2(helper_##name, ret, arg1, arg2); \
+}
+#define DEF_HELPER_1_3(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(TCGv ret, \
+    TCGv arg1, TCGv arg2, TCGv arg3) \
+{ \
+    tcg_gen_helper_1_3(helper_##name, ret, arg1, arg2, arg3); \
+}
+#define DEF_HELPER_1_4(name, ret, args) \
+DEF_HELPER(name, ret, args) \
+static inline void gen_helper_##name(TCGv ret, \
+    TCGv arg1, TCGv arg2, TCGv arg3, TCGv arg4) \
+{ \
+    tcg_gen_helper_1_4(helper_##name, ret, arg1, arg2, arg3, arg4); \
+}
+#else /* !GEN_HELPER */
+#define DEF_HELPER_0_0 DEF_HELPER
+#define DEF_HELPER_0_1 DEF_HELPER
+#define DEF_HELPER_0_2 DEF_HELPER
+#define DEF_HELPER_0_3 DEF_HELPER
+#define DEF_HELPER_1_0 DEF_HELPER
+#define DEF_HELPER_1_1 DEF_HELPER
+#define DEF_HELPER_1_2 DEF_HELPER
+#define DEF_HELPER_1_3 DEF_HELPER
+#define DEF_HELPER_1_4 DEF_HELPER
+#define HELPER(x) glue(helper_,x)
+#endif
+
+DEF_HELPER_1_1(bitrev, uint32_t, (uint32_t))
+DEF_HELPER_1_1(ff1, uint32_t, (uint32_t))
+DEF_HELPER_1_2(sats, uint32_t, (uint32_t, uint32_t))
+DEF_HELPER_0_2(divu, void, (CPUState *, uint32_t))
+DEF_HELPER_0_2(divs, void, (CPUState *, uint32_t))
+DEF_HELPER_1_3(addx_cc, uint32_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_3(subx_cc, uint32_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_3(shl_cc, uint32_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_3(shr_cc, uint32_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_3(sar_cc, uint32_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_2(xflag_lt, uint32_t, (uint32_t, uint32_t))
+DEF_HELPER_0_2(set_sr, void, (CPUState *, uint32_t))
+DEF_HELPER_0_3(movec, void, (CPUState *, uint32_t, uint32_t))
+
+DEF_HELPER_1_2(f64_to_i32, float32, (CPUState *, float64))
+DEF_HELPER_1_2(f64_to_f32, float32, (CPUState *, float64))
+DEF_HELPER_1_2(i32_to_f64, float64, (CPUState *, uint32_t))
+DEF_HELPER_1_2(f32_to_f64, float64, (CPUState *, float32))
+DEF_HELPER_1_2(iround_f64, float64, (CPUState *, float64))
+DEF_HELPER_1_2(itrunc_f64, float64, (CPUState *, float64))
+DEF_HELPER_1_2(sqrt_f64, float64, (CPUState *, float64))
+DEF_HELPER_1_1(abs_f64, float64, (float64))
+DEF_HELPER_1_1(chs_f64, float64, (float64))
+DEF_HELPER_1_3(add_f64, float64, (CPUState *, float64, float64))
+DEF_HELPER_1_3(sub_f64, float64, (CPUState *, float64, float64))
+DEF_HELPER_1_3(mul_f64, float64, (CPUState *, float64, float64))
+DEF_HELPER_1_3(div_f64, float64, (CPUState *, float64, float64))
+DEF_HELPER_1_3(sub_cmp_f64, float64, (CPUState *, float64, float64))
+DEF_HELPER_1_2(compare_f64, uint32_t, (CPUState *, float64))
+
+DEF_HELPER_0_3(mac_move, void, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_3(macmulf, uint64_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_3(macmuls, uint64_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_1_3(macmulu, uint64_t, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_0_2(macsats, void, (CPUState *, uint32_t))
+DEF_HELPER_0_2(macsatu, void, (CPUState *, uint32_t))
+DEF_HELPER_0_2(macsatf, void, (CPUState *, uint32_t))
+DEF_HELPER_0_2(mac_set_flags, void, (CPUState *, uint32_t))
+DEF_HELPER_0_2(set_macsr, void, (CPUState *, uint32_t))
+DEF_HELPER_1_2(get_macf, uint32_t, (CPUState *, uint64_t))
+DEF_HELPER_1_1(get_macs, uint32_t, (uint64_t))
+DEF_HELPER_1_1(get_macu, uint32_t, (uint64_t))
+DEF_HELPER_1_2(get_mac_extf, uint32_t, (CPUState *, uint32_t))
+DEF_HELPER_1_2(get_mac_exti, uint32_t, (CPUState *, uint32_t))
+DEF_HELPER_0_3(set_mac_extf, void, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_0_3(set_mac_exts, void, (CPUState *, uint32_t, uint32_t))
+DEF_HELPER_0_3(set_mac_extu, void, (CPUState *, uint32_t, uint32_t))
+
+DEF_HELPER_0_2(flush_flags, void, (CPUState *, uint32_t))
+DEF_HELPER_0_1(raise_exception, void, (uint32_t))
+
+#undef DEF_HELPER
+#undef DEF_HELPER_0_0
+#undef DEF_HELPER_0_1
+#undef DEF_HELPER_0_2
+#undef DEF_HELPER_0_3
+#undef DEF_HELPER_1_0
+#undef DEF_HELPER_1_1
+#undef DEF_HELPER_1_2
+#undef DEF_HELPER_1_3
+#undef DEF_HELPER_1_4
+#undef GEN_HELPER
+#undef DEF_HELPER
-/* Various hacks to make code written for a dynamic code generator work
-   with regular QEMU.  */
-
-static int free_qreg;
-
-#define QMODE_I32 1
-#define QMODE_F32 1
-#define QMODE_F64 2
-
-static inline int gen_new_qreg(int mode)
-{
-    int qreg;
-
-    qreg = free_qreg;
-    free_qreg += mode;
-    if (free_qreg > MAX_QREGS) {
-        fprintf(stderr, "qreg overflow\n");
-        abort();
-    }
-    return qreg + TARGET_NUM_QREGS;
-}
-
-static inline int gen_im32(uint32_t i)
-{
-    int qreg = gen_new_qreg(QMODE_I32);
-    gen_op_mov32_im(qreg, i);
-    return qreg;
-}
-
-static inline void gen_op_ldf32_raw(int dest, int addr)
-{
-    gen_op_ld32_raw(dest, addr);
-}
-
-static inline void gen_op_stf32_raw(int addr, int dest)
-{
-    gen_op_st32_raw(addr, dest);
-}
-
-#if !defined(CONFIG_USER_ONLY)
-static inline void gen_op_ldf32_user(int dest, int addr)
-{
-    gen_op_ld32_user(dest, addr);
-}
-
-static inline void gen_op_stf32_user(int addr, int dest)
-{
-    gen_op_st32_user(addr, dest);
-}
-
-static inline void gen_op_ldf32_kernel(int dest, int addr)
-{
-    gen_op_ld32_kernel(dest, addr);
-}
-
-static inline void gen_op_stf32_kernel(int addr, int dest)
-{
-    gen_op_st32_kernel(addr, dest);
-}
-#endif
-
-static inline void gen_op_pack_32_f32(int dest, int src)
-{
-    gen_op_mov32(dest, src);
-}
-
-static inline void gen_op_pack_f32_32(int dest, int src)
-{
-    gen_op_mov32(dest, src);
-}
-
-static inline void gen_op_flags_set(void)
-{
-    /* Dummy op.  */
-}
-
-static inline void gen_op_shl_im_cc(int val, int shift)
-{
-    gen_op_shl_cc(val, gen_im32(shift));
-}
-
-static inline void gen_op_shr_im_cc(int val, int shift)
-{
-    gen_op_shr_cc(val, gen_im32(shift));
-}
-
-static inline void gen_op_sar_im_cc(int val, int shift)
-{
-    gen_op_sar_cc(val, gen_im32(shift));
-}
-
-#ifdef USE_DIRECT_JUMP
-#define TBPARAM(x)
-#else
-#define TBPARAM(x) (long)(x)
-#endif
-
-static inline void gen_op_goto_tb(int dummy, int n, long tb)
-{
-    if (n == 0) {
-        gen_op_goto_tb0(TBPARAM(tb));
-    } else {
-        gen_op_goto_tb1(TBPARAM(tb));
-    }
-}
-
-static inline void gen_op_jmp_z32(int val, int label)
-{
-    gen_op_set_T0_z32(val);
-    gen_op_jmp_T0(label);
-}
-
-static inline void gen_op_jmp_nz32(int val, int label)
-{
-    gen_op_set_T0_nz32(val);
-    gen_op_jmp_T0(label);
-}
-
-static inline void gen_op_jmp_s32(int val, int label)
-{
-    gen_op_set_T0_s32(val);
-    gen_op_jmp_T0(label);
-}
-
-static inline void gen_op_jmp_ns32(int val, int label)
-{
-    gen_op_set_T0_ns32(val);
-    gen_op_jmp_T0(label);
-}
-
-/*
- *  m68k micro operations
- *
- *  Copyright (c) 2006-2007 CodeSourcery
- *  Written by Paul Brook
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include "exec.h"
-#include "m68k-qreg.h"
-
-#ifndef offsetof
-#define offsetof(type, field) ((size_t) &((type *)0)->field)
-#endif
-
-static long qreg_offsets[] = {
-#define DEFO32(name, offset) offsetof(CPUState, offset),
-#define DEFR(name, reg, mode) -1,
-#define DEFF64(name, offset) offsetof(CPUState, offset),
-    0,
-#include "qregs.def"
-};
-
-#define CPU_FP_STATUS env->fp_status
-
-#define RAISE_EXCEPTION(n) do { \
-    env->exception_index = n; \
-    cpu_loop_exit(); \
-    } while(0)
-
-#define get_op helper_get_op
-#define set_op helper_set_op
-#define get_opf64 helper_get_opf64
-#define set_opf64 helper_set_opf64
-uint32_t
-get_op(int qreg)
-{
-    if (qreg >= TARGET_NUM_QREGS) {
-        return env->qregs[qreg - TARGET_NUM_QREGS];
-    } else if (qreg == QREG_T0) {
-        return T0;
-    } else {
-        return *(uint32_t *)(((long)env) + qreg_offsets[qreg]);
-    }
-}
-
-void set_op(int qreg, uint32_t val)
-{
-    if (qreg >= TARGET_NUM_QREGS) {
-        env->qregs[qreg - TARGET_NUM_QREGS] = val;
-    } else if (qreg == QREG_T0) {
-        T0 = val;
-    } else {
-        *(uint32_t *)(((long)env) + qreg_offsets[qreg]) = val;
-    }
-}
-
-float64 get_opf64(int qreg)
-{
-    if (qreg < TARGET_NUM_QREGS) {
-        return *(float64 *)(((long)env) + qreg_offsets[qreg]);
-    } else {
-        return *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS];
-    }
-}
-
-void set_opf64(int qreg, float64 val)
-{
-    if (qreg < TARGET_NUM_QREGS) {
-        *(float64 *)(((long)env) + qreg_offsets[qreg]) = val;
-    } else {
-        *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS] = val;
-    }
-}
-
-#define OP(name) void OPPROTO glue(op_,name) (void)
-
-OP(mov32)
-{
-    set_op(PARAM1, get_op(PARAM2));
-    FORCE_RET();
-}
-
-OP(mov32_im)
-{
-    set_op(PARAM1, PARAM2);
-    FORCE_RET();
-}
-
-OP(movf64)
-{
-    set_opf64(PARAM1, get_opf64(PARAM2));
-    FORCE_RET();
-}
-
-OP(zerof64)
-{
-    set_opf64(PARAM1, float64_zero);
-    FORCE_RET();
-}
-
-OP(add32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    set_op(PARAM1, op2 + op3);
-    FORCE_RET();
-}
-
-OP(sub32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    set_op(PARAM1, op2 - op3);
-    FORCE_RET();
-}
-
-OP(mul32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    set_op(PARAM1, op2 * op3);
-    FORCE_RET();
-}
-
-OP(not32)
-{
-    uint32_t arg = get_op(PARAM2);
-    set_op(PARAM1, ~arg);
-    FORCE_RET();
-}
-
-OP(neg32)
-{
-    uint32_t arg = get_op(PARAM2);
-    set_op(PARAM1, -arg);
-    FORCE_RET();
-}
-
-OP(bswap32)
-{
-    uint32_t arg = get_op(PARAM2);
-    arg = (arg >> 24) | (arg << 24)
-          | ((arg >> 16) & 0xff00) | ((arg << 16) & 0xff0000);
-    set_op(PARAM1, arg);
-    FORCE_RET();
-}
-
-OP(btest)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    if (op1 & op2)
-        env->cc_dest &= ~CCF_Z;
-    else
-        env->cc_dest |= CCF_Z;
-    FORCE_RET();
-}
-
-OP(ff1)
-{
-    uint32_t arg = get_op(PARAM2);
-    int n;
-    for (n = 32; arg; n--)
-        arg >>= 1;
-    set_op(PARAM1, n);
-    FORCE_RET();
-}
-
-OP(subx_cc)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t res;
-    if (env->cc_x) {
-        env->cc_x = (op1 <= op2);
-        env->cc_op = CC_OP_SUBX;
-        res = op1 - (op2 + 1);
-    } else {
-        env->cc_x = (op1 < op2);
-        env->cc_op = CC_OP_SUB;
-        res = op1 - op2;
-    }
-    set_op(PARAM1, res);
-    FORCE_RET();
-}
-
-OP(addx_cc)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t res;
-    if (env->cc_x) {
-        res = op1 + op2 + 1;
-        env->cc_x = (res <= op2);
-        env->cc_op = CC_OP_ADDX;
-    } else {
-        res = op1 + op2;
-        env->cc_x = (res < op2);
-        env->cc_op = CC_OP_ADD;
-    }
-    set_op(PARAM1, res);
-    FORCE_RET();
-}
-
-/* Logic ops.  */
-
-OP(and32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    set_op(PARAM1, op2 & op3);
-    FORCE_RET();
-}
-
-OP(or32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    set_op(PARAM1, op2 | op3);
-    FORCE_RET();
-}
-
-OP(xor32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    set_op(PARAM1, op2 ^ op3);
-    FORCE_RET();
-}
-
-/* Shifts.  */
-OP(shl32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    uint32_t result;
-    result = op2 << op3;
-    set_op(PARAM1, result);
-    FORCE_RET();
-}
-
-OP(shl_cc)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t result;
-    result = op1 << op2;
-    set_op(PARAM1, result);
-    env->cc_x = (op1 << (op2 - 1)) & 1;
-    FORCE_RET();
-}
-
-OP(shr32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    uint32_t result;
-    result = op2 >> op3;
-    set_op(PARAM1, result);
-    FORCE_RET();
-}
-
-OP(shr_cc)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t result;
-    result = op1 >> op2;
-    set_op(PARAM1, result);
-    env->cc_x = (op1 >> (op2 - 1)) & 1;
-    FORCE_RET();
-}
-
-OP(sar32)
-{
-    int32_t op2 = get_op(PARAM2);
-    uint32_t op3 = get_op(PARAM3);
-    uint32_t result;
-    result = op2 >> op3;
-    set_op(PARAM1, result);
-    FORCE_RET();
-}
-
-OP(sar_cc)
-{
-    int32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    uint32_t result;
-    result = op1 >> op2;
-    set_op(PARAM1, result);
-    env->cc_x = (op1 >> (op2 - 1)) & 1;
-    FORCE_RET();
-}
-
-/* Value extend.  */
-
-OP(ext8u32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    set_op(PARAM1, (uint8_t)op2);
-    FORCE_RET();
-}
-
-OP(ext8s32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    set_op(PARAM1, (int8_t)op2);
-    FORCE_RET();
-}
-
-OP(ext16u32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    set_op(PARAM1, (uint16_t)op2);
-    FORCE_RET();
-}
-
-OP(ext16s32)
-{
-    uint32_t op2 = get_op(PARAM2);
-    set_op(PARAM1, (int16_t)op2);
-    FORCE_RET();
-}
-
-OP(flush_flags)
-{
-    cpu_m68k_flush_flags(env, env->cc_op);
-    FORCE_RET();
-}
-
-OP(divu)
-{
-    uint32_t num;
-    uint32_t den;
-    uint32_t quot;
-    uint32_t rem;
-    uint32_t flags;
-
-    num = env->div1;
-    den = env->div2;
-    /* ??? This needs to make sure the throwing location is accurate.  */
-    if (den == 0)
-        RAISE_EXCEPTION(EXCP_DIV0);
-    quot = num / den;
-    rem = num % den;
-    flags = 0;
-    /* Avoid using a PARAM1 of zero.  This breaks dyngen because it uses
-       the address of a symbol, and gcc knows symbols can't have address
-       zero.  */
-    if (PARAM1 == 2 && quot > 0xffff)
-        flags |= CCF_V;
-    if (quot == 0)
-        flags |= CCF_Z;
-    else if ((int32_t)quot < 0)
-        flags |= CCF_N;
-    env->div1 = quot;
-    env->div2 = rem;
-    env->cc_dest = flags;
-    FORCE_RET();
-}
-
-OP(divs)
-{
-    int32_t num;
-    int32_t den;
-    int32_t quot;
-    int32_t rem;
-    int32_t flags;
-
-    num = env->div1;
-    den = env->div2;
-    if (den == 0)
-        RAISE_EXCEPTION(EXCP_DIV0);
-    quot = num / den;
-    rem = num % den;
-    flags = 0;
-    if (PARAM1 == 2 && quot != (int16_t)quot)
-        flags |= CCF_V;
-    if (quot == 0)
-        flags |= CCF_Z;
-    else if (quot < 0)
-        flags |= CCF_N;
-    env->div1 = quot;
-    env->div2 = rem;
-    env->cc_dest = flags;
-    FORCE_RET();
-}
-
-/* Halt is special because it may be a semihosting call.  */
-OP(halt)
-{
-    RAISE_EXCEPTION(EXCP_HALT_INSN);
-    FORCE_RET();
-}
-
-OP(stop)
-{
-    env->halted = 1;
-    RAISE_EXCEPTION(EXCP_HLT);
-    FORCE_RET();
-}
-
-OP(raise_exception)
-{
-    RAISE_EXCEPTION(PARAM1);
-    FORCE_RET();
-}
-
-/* Floating point comparison sets flags differently to other instructions.  */
-
-OP(sub_cmpf64)
-{
-    float64 src0;
-    float64 src1;
-    src0 = get_opf64(PARAM2);
-    src1 = get_opf64(PARAM3);
-    set_opf64(PARAM1, helper_sub_cmpf64(env, src0, src1));
-    FORCE_RET();
-}
-
-OP(update_xflag_tst)
-{
-    uint32_t op1 = get_op(PARAM1);
-    env->cc_x = op1;
-    FORCE_RET();
-}
-
-OP(update_xflag_lt)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    env->cc_x = (op1 < op2);
-    FORCE_RET();
-}
-
-OP(get_xflag)
-{
-    set_op(PARAM1, env->cc_x);
-    FORCE_RET();
-}
-
-OP(logic_cc)
-{
-    uint32_t op1 = get_op(PARAM1);
-    env->cc_dest = op1;
-    FORCE_RET();
-}
-
-OP(update_cc_add)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    env->cc_dest = op1;
-    env->cc_src = op2;
-    FORCE_RET();
-}
-
-OP(fp_result)
-{
-    env->fp_result = get_opf64(PARAM1);
-    FORCE_RET();
-}
-
-OP(set_sr)
-{
-    env->sr = get_op(PARAM1) & 0xffff;
-    m68k_switch_sp(env);
-    FORCE_RET();
-}
-
-OP(jmp_im)
-{
-    GOTO_LABEL_PARAM(1);
-}
-
-OP(set_T0_z32)
-{
-    uint32_t arg = get_op(PARAM1);
-    T0 = (arg == 0);
-    FORCE_RET();
-}
-
-OP(set_T0_nz32)
-{
-    uint32_t arg = get_op(PARAM1);
-    T0 = (arg != 0);
-    FORCE_RET();
-}
-
-OP(set_T0_s32)
-{
-    int32_t arg = get_op(PARAM1);
-    T0 = (arg < 0);
-    FORCE_RET();
-}
-
-OP(set_T0_ns32)
-{
-    int32_t arg = get_op(PARAM1);
-    T0 = (arg >= 0);
-    FORCE_RET();
-}
-
-OP(jmp_T0)
-{
-    if (T0)
-        GOTO_LABEL_PARAM(1);
-    FORCE_RET();
-}
-
-/* Floating point.  */
-OP(f64_to_i32)
-{
-    set_op(PARAM1, float64_to_int32(get_opf64(PARAM2), &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(f64_to_f32)
-{
-    union {
-        float32 f;
-        uint32_t i;
-    } u;
-    u.f = float64_to_float32(get_opf64(PARAM2), &CPU_FP_STATUS);
-    set_op(PARAM1, u.i);
-    FORCE_RET();
-}
-
-OP(i32_to_f64)
-{
-    set_opf64(PARAM1, int32_to_float64(get_op(PARAM2), &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(f32_to_f64)
-{
-    union {
-        float32 f;
-        uint32_t i;
-    } u;
-    u.i = get_op(PARAM2);
-    set_opf64(PARAM1, float32_to_float64(u.f, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(absf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    set_opf64(PARAM1, float64_abs(op0));
-    FORCE_RET();
-}
-
-OP(chsf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    set_opf64(PARAM1, float64_chs(op0));
-    FORCE_RET();
-}
-
-OP(sqrtf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    set_opf64(PARAM1, float64_sqrt(op0, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(addf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    float64 op1 = get_opf64(PARAM3);
-    set_opf64(PARAM1, float64_add(op0, op1, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(subf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    float64 op1 = get_opf64(PARAM3);
-    set_opf64(PARAM1, float64_sub(op0, op1, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(mulf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    float64 op1 = get_opf64(PARAM3);
-    set_opf64(PARAM1, float64_mul(op0, op1, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(divf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    float64 op1 = get_opf64(PARAM3);
-    set_opf64(PARAM1, float64_div(op0, op1, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(iround_f64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    set_opf64(PARAM1, float64_round_to_int(op0, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(itrunc_f64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    set_opf64(PARAM1, float64_trunc_to_int(op0, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(compare_quietf64)
-{
-    float64 op0 = get_opf64(PARAM2);
-    float64 op1 = get_opf64(PARAM3);
-    set_op(PARAM1, float64_compare_quiet(op0, op1, &CPU_FP_STATUS));
-    FORCE_RET();
-}
-
-OP(movec)
-{
-    int op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    helper_movec(env, op1, op2);
-}
-
-/* Memory access.  */
-
-#define MEMSUFFIX _raw
-#include "op_mem.h"
-
-#if !defined(CONFIG_USER_ONLY)
-#define MEMSUFFIX _user
-#include "op_mem.h"
-#define MEMSUFFIX _kernel
-#include "op_mem.h"
-#endif
-
-/* MAC unit.  */
-/* TODO: The MAC instructions use 64-bit arithmetic fairly extensively.
-   This results in fairly large ops (and sometimes other issues) on 32-bit
-   hosts.  Maybe move most of them into helpers.  */
-OP(macmuls)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    int64_t product;
-    int64_t res;
-
-    product = (uint64_t)op1 * op2;
-    res = (product << 24) >> 24;
-    if (res != product) {
-        env->macsr |= MACSR_V;
-        if (env->macsr & MACSR_OMC) {
-            /* Make sure the accumulate operation overflows.  */
-            if (product < 0)
-                res = ~(1ll << 50);
-            else
-                res = 1ll << 50;
-        }
-    }
-    env->mactmp = res;
-    FORCE_RET();
-}
-
-OP(macmulu)
-{
-    uint32_t op1 = get_op(PARAM1);
-    uint32_t op2 = get_op(PARAM2);
-    uint64_t product;
-
-    product = (uint64_t)op1 * op2;
-    if (product & (0xffffffull << 40)) {
-        env->macsr |= MACSR_V;
-        if (env->macsr & MACSR_OMC) {
-            /* Make sure the accumulate operation overflows.  */
-            product = 1ll << 50;
-        } else {
-            product &= ((1ull << 40) - 1);
-        }
-    }
-    env->mactmp = product;
-    FORCE_RET();
-}
-
-OP(macmulf)
-{
-    int32_t op1 = get_op(PARAM1);
-    int32_t op2 = get_op(PARAM2);
-    uint64_t product;
-    uint32_t remainder;
-
-    product = (uint64_t)op1 * op2;
-    if (env->macsr & MACSR_RT) {
-        remainder = product & 0xffffff;
-        product >>= 24;
-        if (remainder > 0x800000)
-            product++;
-        else if (remainder == 0x800000)
-            product += (product & 1);
-    } else {
-        product >>= 24;
-    }
-    env->mactmp = product;
-    FORCE_RET();
-}
-
-OP(macshl)
-{
-    env->mactmp <<= 1;
-}
-
-OP(macshr)
-{
-    env->mactmp >>= 1;
-}
-
-OP(macadd)
-{
-    int acc = PARAM1;
-    env->macc[acc] += env->mactmp;
-    FORCE_RET();
-}
-
-OP(macsub)
-{
-    int acc = PARAM1;
-    env->macc[acc] -= env->mactmp;
-    FORCE_RET();
-}
-
-OP(macsats)
-{
-    int acc = PARAM1;
-    int64_t sum;
-    int64_t result;
-
-    sum = env->macc[acc];
-    result = (sum << 16) >> 16;
-    if (result != sum) {
-        env->macsr |= MACSR_V;
-    }
-    if (env->macsr & MACSR_V) {
-        env->macsr |= MACSR_PAV0 << acc;
-        if (env->macsr & MACSR_OMC) {
-            /* The result is saturated to 32 bits, despite overflow occuring
-               at 48 bits.  Seems weird, but that's what the hardware docs
-               say.  */
-            result = (result >> 63) ^ 0x7fffffff;
-        }
-    }
-    env->macc[acc] = result;
-    FORCE_RET();
-}
-
-OP(macsatu)
-{
-    int acc = PARAM1;
-    uint64_t sum;
-
-    sum = env->macc[acc];
-    if (sum & (0xffffull << 48)) {
-        env->macsr |= MACSR_V;
-    }
-    if (env->macsr & MACSR_V) {
-        env->macsr |= MACSR_PAV0 << acc;
-        if (env->macsr & MACSR_OMC) {
-            if (sum > (1ull << 53))
-                sum = 0;
-            else
-                sum = (1ull << 48) - 1;
-        } else {
-            sum &= ((1ull << 48) - 1);
-        }
-    }
-    FORCE_RET();
-}
-
-OP(macsatf)
-{
-    int acc = PARAM1;
-    int64_t sum;
-    int64_t result;
-
-    sum = env->macc[acc];
-    result = (sum << 16) >> 16;
-    if (result != sum) {
-        env->macsr |= MACSR_V;
-    }
-    if (env->macsr & MACSR_V) {
-        env->macsr |= MACSR_PAV0 << acc;
-        if (env->macsr & MACSR_OMC) {
-            result = (result >> 63) ^ 0x7fffffffffffll;
-        }
-    }
-    env->macc[acc] = result;
-    FORCE_RET();
-}
-
-OP(mac_clear_flags)
-{
-    env->macsr &= ~(MACSR_V | MACSR_Z | MACSR_N | MACSR_EV);
-}
-
-OP(mac_set_flags)
-{
-    int acc = PARAM1;
-    uint64_t val;
-    val = env->macc[acc];
-    if (val == 0)
-        env->macsr |= MACSR_Z;
-    else if (val & (1ull << 47));
-        env->macsr |= MACSR_N;
-    if (env->macsr & (MACSR_PAV0 << acc)) {
-        env->macsr |= MACSR_V;
-    }
-    if (env->macsr & MACSR_FI) {
-        val = ((int64_t)val) >> 40;
-        if (val != 0 && val != -1)
-            env->macsr |= MACSR_EV;
-    } else if (env->macsr & MACSR_SU) {
-        val = ((int64_t)val) >> 32;
-        if (val != 0 && val != -1)
-            env->macsr |= MACSR_EV;
-    } else {
-        if ((val >> 32) != 0)
-            env->macsr |= MACSR_EV;
-    }
-    FORCE_RET();
-}
-
-OP(get_macf)
-{
-    int acc = PARAM2;
-    int64_t val;
-    int rem;
-    uint32_t result;
-
-    val = env->macc[acc];
-    if (env->macsr & MACSR_SU) {
-        /* 16-bit rounding.  */
-        rem = val & 0xffffff;
-        val = (val >> 24) & 0xffffu;
-        if (rem > 0x800000)
-            val++;
-        else if (rem == 0x800000)
-            val += (val & 1);
-    } else if (env->macsr & MACSR_RT) {
-        /* 32-bit rounding.  */
-        rem = val & 0xff;
-        val >>= 8;
-        if (rem > 0x80)
-            val++;
-        else if (rem == 0x80)
-            val += (val & 1);
-    } else {
-        /* No rounding.  */
-        val >>= 8;
-    }
-    if (env->macsr & MACSR_OMC) {
-        /* Saturate.  */
-        if (env->macsr & MACSR_SU) {
-            if (val != (uint16_t) val) {
-                result = ((val >> 63) ^ 0x7fff) & 0xffff;
-            } else {
-                result = val & 0xffff;
-            }
-        } else {
-            if (val != (uint32_t)val) {
-                result = ((uint32_t)(val >> 63) & 0x7fffffff);
-            } else {
-                result = (uint32_t)val;
-            }
-        }
-    } else {
-        /* No saturation.  */
-        if (env->macsr & MACSR_SU) {
-            result = val & 0xffff;
-        } else {
-            result = (uint32_t)val;
-        }
-    }
-    set_op(PARAM1, result);
-    FORCE_RET();
-}
-
-OP(get_maci)
-{
-    int acc = PARAM2;
-    set_op(PARAM1, (uint32_t)env->macc[acc]);
-    FORCE_RET();
-}
-
-OP(get_macs)
-{
-    int acc = PARAM2;
-    int64_t val = env->macc[acc];
-    uint32_t result;
-    if (val == (int32_t)val) {
-        result = (int32_t)val;
-    } else {
-        result = (val >> 61) ^ 0x7fffffff;
-    }
-    set_op(PARAM1, result);
-    FORCE_RET();
-}
-
-OP(get_macu)
-{
-    int acc = PARAM2;
-    uint64_t val = env->macc[acc];
-    uint32_t result;
-    if ((val >> 32) == 0) {
-        result = (uint32_t)val;
-    } else {
-        result = 0xffffffffu;
-    }
-    set_op(PARAM1, result);
-    FORCE_RET();
-}
-
-OP(clear_mac)
-{
-    int acc = PARAM1;
-
-    env->macc[acc] = 0;
-    env->macsr &= ~(MACSR_PAV0 << acc);
-    FORCE_RET();
-}
-
-OP(move_mac)
-{
-    int dest = PARAM1;
-    int src = PARAM2;
-    uint32_t mask;
-    env->macc[dest] = env->macc[src];
-    mask = MACSR_PAV0 << dest;
-    if (env->macsr & (MACSR_PAV0 << src))
-        env->macsr |= mask;
-    else
-        env->macsr &= ~mask;
-    FORCE_RET();
-}
-
-OP(get_mac_extf)
-{
-    uint32_t val;
-    int acc = PARAM2;
-    val = env->macc[acc] & 0x00ff;
-    val = (env->macc[acc] >> 32) & 0xff00;
-    val |= (env->macc[acc + 1] << 16) & 0x00ff0000;
-    val |= (env->macc[acc + 1] >> 16) & 0xff000000;
-    set_op(PARAM1, val);
-    FORCE_RET();
-}
-
-OP(get_mac_exti)
-{
-    uint32_t val;
-    int acc = PARAM2;
-    val = (env->macc[acc] >> 32) & 0xffff;
-    val |= (env->macc[acc + 1] >> 16) & 0xffff0000;
-    set_op(PARAM1, val);
-    FORCE_RET();
-}
-
-OP(set_macf)
-{
-    int acc = PARAM2;
-    int32_t val = get_op(PARAM1);
-    env->macc[acc] = ((int64_t)val) << 8;
-    env->macsr &= ~(MACSR_PAV0 << acc);
-    FORCE_RET();
-}
-
-OP(set_macs)
-{
-    int acc = PARAM2;
-    int32_t val = get_op(PARAM1);
-    env->macc[acc] = val;
-    env->macsr &= ~(MACSR_PAV0 << acc);
-    FORCE_RET();
-}
-
-OP(set_macu)
-{
-    int acc = PARAM2;
-    uint32_t val = get_op(PARAM1);
-    env->macc[acc] = val;
-    env->macsr &= ~(MACSR_PAV0 << acc);
-    FORCE_RET();
-}
-
-OP(set_mac_extf)
-{
-    int acc = PARAM2;
-    int32_t val = get_op(PARAM1);
-    int64_t res;
-    int32_t tmp;
-    res = env->macc[acc] & 0xffffffff00ull;
-    tmp = (int16_t)(val & 0xff00);
-    res |= ((int64_t)tmp) << 32;
-    res |= val & 0xff;
-    env->macc[acc] = res;
-    res = env->macc[acc + 1] & 0xffffffff00ull;
-    tmp = (val & 0xff000000);
-    res |= ((int64_t)tmp) << 16;
-    res |= (val >> 16) & 0xff;
-    env->macc[acc + 1] = res;
-}
-
-OP(set_mac_exts)
-{
-    int acc = PARAM2;
-    int32_t val = get_op(PARAM1);
-    int64_t res;
-    int32_t tmp;
-    res = (uint32_t)env->macc[acc];
-    tmp = (int16_t)val;
-    res |= ((int64_t)tmp) << 32;
-    env->macc[acc] = res;
-    res = (uint32_t)env->macc[acc + 1];
-    tmp = val & 0xffff0000;
-    res |= (int64_t)tmp << 16;
-    env->macc[acc + 1] = res;
-}
-
-OP(set_mac_extu)
-{
-    int acc = PARAM2;
-    int32_t val = get_op(PARAM1);
-    uint64_t res;
-    res = (uint32_t)env->macc[acc];
-    res |= ((uint64_t)(val & 0xffff)) << 32;
-    env->macc[acc] = res;
-    res = (uint32_t)env->macc[acc + 1];
-    res |= (uint64_t)(val & 0xffff0000) << 16;
-    env->macc[acc + 1] = res;
-}
-
-OP(set_macsr)
-{
-    m68k_set_macsr(env, get_op(PARAM1));
-}
@@ -18,6 +18,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include "exec.h"
+#include "helpers.h"
 #if defined(CONFIG_USER_ONLY)
@@ -161,3 +162,71 @@ void do_interrupt(int is_hw)
 }
 #endif
+
+static void raise_exception(int tt)
+{
+    env->exception_index = tt;
+    cpu_loop_exit();
+}
+
+void HELPER(raise_exception)(uint32_t tt)
+{
+    raise_exception(tt);
+}
+
+void HELPER(divu)(CPUState *env, uint32_t word)
+{
+    uint32_t num;
+    uint32_t den;
+    uint32_t quot;
+    uint32_t rem;
+    uint32_t flags;
+
+    num = env->div1;
+    den = env->div2;
+    /* ??? This needs to make sure the throwing location is accurate.  */
+    if (den == 0)
+        raise_exception(EXCP_DIV0);
+    quot = num / den;
+    rem = num % den;
+    flags = 0;
+    /* Avoid using a PARAM1 of zero.  This breaks dyngen because it uses
+       the address of a symbol, and gcc knows symbols can't have address
+       zero.  */
+    if (word && quot > 0xffff)
+        flags |= CCF_V;
+    if (quot == 0)
+        flags |= CCF_Z;
+    else if ((int32_t)quot < 0)
+        flags |= CCF_N;
+    env->div1 = quot;
+    env->div2 = rem;
+    env->cc_dest = flags;
+}
+
+void HELPER(divs)(CPUState *env, uint32_t word)
+{
+    int32_t num;
+    int32_t den;
+    int32_t quot;
+    int32_t rem;
+    int32_t flags;
+
+    num = env->div1;
+    den = env->div2;
+    if (den == 0)
+        raise_exception(EXCP_DIV0);
+    quot = num / den;
+    rem = num % den;
+    flags = 0;
+    if (word && quot != (int16_t)quot)
+        flags |= CCF_V;
+    if (quot == 0)
+        flags |= CCF_Z;
+    else if (quot < 0)
+        flags |= CCF_N;
+    env->div1 = quot;
+    env->div2 = rem;
+    env->cc_dest = flags;
+}
+
-/* Load/store ops.  */
-#define MEM_LD_OP(name,suffix) \
-OP(glue(glue(ld,name),MEMSUFFIX)) \
-{ \
-    uint32_t addr = get_op(PARAM2); \
-    set_op(PARAM1, glue(glue(ld,suffix),MEMSUFFIX)(addr)); \
-    FORCE_RET(); \
-}
-
-MEM_LD_OP(8u32,ub)
-MEM_LD_OP(8s32,sb)
-MEM_LD_OP(16u32,uw)
-MEM_LD_OP(16s32,sw)
-MEM_LD_OP(32,l)
-
-#undef MEM_LD_OP
-
-#define MEM_ST_OP(name,suffix) \
-OP(glue(glue(st,name),MEMSUFFIX)) \
-{ \
-    uint32_t addr = get_op(PARAM1); \
-    glue(glue(st,suffix),MEMSUFFIX)(addr, get_op(PARAM2)); \
-    FORCE_RET(); \
-}
-
-MEM_ST_OP(8,b)
-MEM_ST_OP(16,w)
-MEM_ST_OP(32,l)
-
-#undef MEM_ST_OP
-
-OP(glue(ldf64,MEMSUFFIX))
-{
-    uint32_t addr = get_op(PARAM2);
-    set_opf64(PARAM1, glue(ldfq,MEMSUFFIX)(addr));
-    FORCE_RET();
-}
-
-OP(glue(stf64,MEMSUFFIX))
-{
-    uint32_t addr = get_op(PARAM1);
-    glue(stfq,MEMSUFFIX)(addr, get_opf64(PARAM2));
-    FORCE_RET();
-}
-
-#undef MEMSUFFIX
-DEFO32(D0, dregs[0])
-DEFO32(D1, dregs[1])
-DEFO32(D2, dregs[2])
-DEFO32(D3, dregs[3])
-DEFO32(D4, dregs[4])
-DEFO32(D5, dregs[5])
-DEFO32(D6, dregs[6])
-DEFO32(D7, dregs[7])
-DEFO32(A0, aregs[0])
-DEFO32(A1, aregs[1])
-DEFO32(A2, aregs[2])
-DEFO32(A3, aregs[3])
-DEFO32(A4, aregs[4])
-DEFO32(A5, aregs[5])
-DEFO32(A6, aregs[6])
-DEFO32(SP, aregs[7]) /* A7 */
-DEFF64(F0, fregs[0])
-DEFF64(F1, fregs[1])
-DEFF64(F2, fregs[2])
-DEFF64(F3, fregs[3])
-DEFF64(F4, fregs[4])
-DEFF64(F5, fregs[5])
-DEFF64(F6, fregs[6])
-DEFF64(F7, fregs[7])
 DEFF64(FP_RESULT, fp_result)
 DEFO32(PC, pc)
 DEFO32(SR, sr)
 DEFO32(CC_OP, cc_op)
-DEFR(T0, AREG1, QMODE_I32)
 DEFO32(CC_DEST, cc_dest)
 DEFO32(CC_SRC, cc_src)
 DEFO32(CC_X, cc_x)
 DEFO32(DIV1, div1)
 DEFO32(DIV2, div2)
 DEFO32(EXCEPTION, exception_index)
+DEFO32(HALTED, halted)
 DEFO32(MACSR, macsr)
 DEFO32(MAC_MASK, mac_mask)