target-ppc: convert FPU load/store to TCG

Signed-off-by: NAurelien Jarno <aurelien@aurel32.net>

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

target-ppc/helper.h

@@ -35,6 +35,8 @@ DEF_HELPER_0(reset_fpstatus, void)
 DEF_HELPER_2(compute_fprf, i32, i64, i32)
 DEF_HELPER_2(store_fpscr, void, i64, i32)
 DEF_HELPER_1(fpscr_setbit, void, i32)
+DEF_HELPER_1(float64_to_float32, i32, i64)
+DEF_HELPER_1(float32_to_float64, i64, i32)
 
 DEF_HELPER_1(fctiw, i64, i64)
 DEF_HELPER_1(fctiwz, i64, i64)

target-ppc/op_helper.c

@@ -237,6 +237,24 @@ target_ulong helper_popcntb_64 (target_ulong val)
 
 /*****************************************************************************/
 /* Floating point operations helpers */
+uint64_t helper_float32_to_float64(uint32_t arg)
+{
+    CPU_FloatU f;
+    CPU_DoubleU d;
+    f.l = arg;
+    d.d = float32_to_float64(f.f, &env->fp_status);
+    return d.ll;
+}
+
+uint32_t helper_float64_to_float32(uint64_t arg)
+{
+    CPU_FloatU f;
+    CPU_DoubleU d;
+    d.ll = arg;
+    f.f = float64_to_float32(d.d, &env->fp_status);
+    return f.l;
+}
+
 static always_inline int fpisneg (float64 d)
 {
     CPU_DoubleU u;

target-ppc/op_mem.h

@@ -145,139 +145,6 @@ void OPPROTO glue(op_stsw_64, MEMSUFFIX) (void)
 }
 #endif
 
-/***                         Floating-point store                          ***/
-#define PPC_STF_OP(name, op)                                                  \
-void OPPROTO glue(glue(op_st, name), MEMSUFFIX) (void)                        \
-{                                                                             \
-    glue(op, MEMSUFFIX)((uint32_t)T0, FT0);                                   \
-    RETURN();                                                                 \
-}
-
-#if defined(TARGET_PPC64)
-#define PPC_STF_OP_64(name, op)                                               \
-void OPPROTO glue(glue(glue(op_st, name), _64), MEMSUFFIX) (void)             \
-{                                                                             \
-    glue(op, MEMSUFFIX)((uint64_t)T0, FT0);                                   \
-    RETURN();                                                                 \
-}
-#endif
-
-static always_inline void glue(stfs, MEMSUFFIX) (target_ulong EA, float64 d)
-{
-    glue(stfl, MEMSUFFIX)(EA, float64_to_float32(d, &env->fp_status));
-}
-
-static always_inline void glue(stfiw, MEMSUFFIX) (target_ulong EA, float64 d)
-{
-    CPU_DoubleU u;
-
-    /* Store the low order 32 bits without any conversion */
-    u.d = d;
-    glue(st32, MEMSUFFIX)(EA, u.l.lower);
-}
-
-PPC_STF_OP(fd, stfq);
-PPC_STF_OP(fs, stfs);
-PPC_STF_OP(fiw, stfiw);
-#if defined(TARGET_PPC64)
-PPC_STF_OP_64(fd, stfq);
-PPC_STF_OP_64(fs, stfs);
-PPC_STF_OP_64(fiw, stfiw);
-#endif
-
-static always_inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, float64 d)
-{
-    CPU_DoubleU u;
-
-    u.d = d;
-    u.ll = bswap64(u.ll);
-    glue(stfq, MEMSUFFIX)(EA, u.d);
-}
-
-static always_inline void glue(stfsr, MEMSUFFIX) (target_ulong EA, float64 d)
-{
-    CPU_FloatU u;
-
-    u.f = float64_to_float32(d, &env->fp_status);
-    u.l = bswap32(u.l);
-    glue(stfl, MEMSUFFIX)(EA, u.f);
-}
-
-static always_inline void glue(stfiwr, MEMSUFFIX) (target_ulong EA, float64 d)
-{
-    CPU_DoubleU u;
-
-    /* Store the low order 32 bits without any conversion */
-    u.d = d;
-    u.l.lower = bswap32(u.l.lower);
-    glue(st32, MEMSUFFIX)(EA, u.l.lower);
-}
-
-PPC_STF_OP(fd_le, stfqr);
-PPC_STF_OP(fs_le, stfsr);
-PPC_STF_OP(fiw_le, stfiwr);
-#if defined(TARGET_PPC64)
-PPC_STF_OP_64(fd_le, stfqr);
-PPC_STF_OP_64(fs_le, stfsr);
-PPC_STF_OP_64(fiw_le, stfiwr);
-#endif
-
-/***                         Floating-point load                           ***/
-#define PPC_LDF_OP(name, op)                                                  \
-void OPPROTO glue(glue(op_l, name), MEMSUFFIX) (void)                         \
-{                                                                             \
-    FT0 = glue(op, MEMSUFFIX)((uint32_t)T0);                                  \
-    RETURN();                                                                 \
-}
-
-#if defined(TARGET_PPC64)
-#define PPC_LDF_OP_64(name, op)                                               \
-void OPPROTO glue(glue(glue(op_l, name), _64), MEMSUFFIX) (void)              \
-{                                                                             \
-    FT0 = glue(op, MEMSUFFIX)((uint64_t)T0);                                  \
-    RETURN();                                                                 \
-}
-#endif
-
-static always_inline float64 glue(ldfs, MEMSUFFIX) (target_ulong EA)
-{
-    return float32_to_float64(glue(ldfl, MEMSUFFIX)(EA), &env->fp_status);
-}
-
-PPC_LDF_OP(fd, ldfq);
-PPC_LDF_OP(fs, ldfs);
-#if defined(TARGET_PPC64)
-PPC_LDF_OP_64(fd, ldfq);
-PPC_LDF_OP_64(fs, ldfs);
-#endif
-
-static always_inline float64 glue(ldfqr, MEMSUFFIX) (target_ulong EA)
-{
-    CPU_DoubleU u;
-
-    u.d = glue(ldfq, MEMSUFFIX)(EA);
-    u.ll = bswap64(u.ll);
-
-    return u.d;
-}
-
-static always_inline float64 glue(ldfsr, MEMSUFFIX) (target_ulong EA)
-{
-    CPU_FloatU u;
-
-    u.f = glue(ldfl, MEMSUFFIX)(EA);
-    u.l = bswap32(u.l);
-
-    return float32_to_float64(u.f, &env->fp_status);
-}
-
-PPC_LDF_OP(fd_le, ldfqr);
-PPC_LDF_OP(fs_le, ldfsr);
-#if defined(TARGET_PPC64)
-PPC_LDF_OP_64(fd_le, ldfqr);
-PPC_LDF_OP_64(fs_le, ldfsr);
-#endif
-
 /* Load and set reservation */
 void OPPROTO glue(op_lwarx, MEMSUFFIX) (void)
 {