Switch most MIPS FP load/stores to TCG.

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

3 files changed, 426 insertions, 587 deletions

diff --git a/target-mips/op.c b/target-mips/op.c
index ff5aed9681..3d594aa985 100644
--- a/target-mips/op.c
+++ b/target-mips/op.c
@@ -48,103 +48,6 @@
         func(arg0, arg1, arg2, arg3)
 #endif
 
-#define FREG 0
-#include "fop_template.c"
-#undef FREG
-#define FREG 1
-#include "fop_template.c"
-#undef FREG
-#define FREG 2
-#include "fop_template.c"
-#undef FREG
-#define FREG 3
-#include "fop_template.c"
-#undef FREG
-#define FREG 4
-#include "fop_template.c"
-#undef FREG
-#define FREG 5
-#include "fop_template.c"
-#undef FREG
-#define FREG 6
-#include "fop_template.c"
-#undef FREG
-#define FREG 7
-#include "fop_template.c"
-#undef FREG
-#define FREG 8
-#include "fop_template.c"
-#undef FREG
-#define FREG 9
-#include "fop_template.c"
-#undef FREG
-#define FREG 10
-#include "fop_template.c"
-#undef FREG
-#define FREG 11
-#include "fop_template.c"
-#undef FREG
-#define FREG 12
-#include "fop_template.c"
-#undef FREG
-#define FREG 13
-#include "fop_template.c"
-#undef FREG
-#define FREG 14
-#include "fop_template.c"
-#undef FREG
-#define FREG 15
-#include "fop_template.c"
-#undef FREG
-#define FREG 16
-#include "fop_template.c"
-#undef FREG
-#define FREG 17
-#include "fop_template.c"
-#undef FREG
-#define FREG 18
-#include "fop_template.c"
-#undef FREG
-#define FREG 19
-#include "fop_template.c"
-#undef FREG
-#define FREG 20
-#include "fop_template.c"
-#undef FREG
-#define FREG 21
-#include "fop_template.c"
-#undef FREG
-#define FREG 22
-#include "fop_template.c"
-#undef FREG
-#define FREG 23
-#include "fop_template.c"
-#undef FREG
-#define FREG 24
-#include "fop_template.c"
-#undef FREG
-#define FREG 25
-#include "fop_template.c"
-#undef FREG
-#define FREG 26
-#include "fop_template.c"
-#undef FREG
-#define FREG 27
-#include "fop_template.c"
-#undef FREG
-#define FREG 28
-#include "fop_template.c"
-#undef FREG
-#define FREG 29
-#include "fop_template.c"
-#undef FREG
-#define FREG 30
-#include "fop_template.c"
-#undef FREG
-#define FREG 31
-#include "fop_template.c"
-#undef FREG
-
 /* Load and store */
 #define MEMSUFFIX _raw
 #include "op_mem.c"
@@ -467,48 +370,6 @@ void op_dmultu (void)
 # define DEBUG_FPU_STATE() do { } while(0)
 #endif
 
-void op_mfc1 (void)
-{
-    T0 = (int32_t)WT0;
-    DEBUG_FPU_STATE();
-    FORCE_RET();
-}
-
-void op_mtc1 (void)
-{
-    WT0 = T0;
-    DEBUG_FPU_STATE();
-    FORCE_RET();
-}
-
-void op_dmfc1 (void)
-{
-    T0 = DT0;
-    DEBUG_FPU_STATE();
-    FORCE_RET();
-}
-
-void op_dmtc1 (void)
-{
-    DT0 = T0;
-    DEBUG_FPU_STATE();
-    FORCE_RET();
-}
-
-void op_mfhc1 (void)
-{
-    T0 = (int32_t)WTH0;
-    DEBUG_FPU_STATE();
-    FORCE_RET();
-}
-
-void op_mthc1 (void)
-{
-    WTH0 = T0;
-    DEBUG_FPU_STATE();
-    FORCE_RET();
-}
-
 /* Float support.
    Single precition routines have a "s" suffix, double precision a
    "d" suffix, 32bit integer "w", 64bit integer "l", paired singe "ps",
diff --git a/target-mips/op_mem.c b/target-mips/op_mem.c
index 4b889a88db..cb60d06be6 100644
--- a/target-mips/op_mem.c
+++ b/target-mips/op_mem.c
@@ -268,26 +268,6 @@ void glue(op_sdr, MEMSUFFIX) (void)
 }
 #endif /* TARGET_MIPS64 */
 
-void glue(op_lwc1, MEMSUFFIX) (void)
-{
-    WT0 = glue(ldl, MEMSUFFIX)(T0);
-    FORCE_RET();
-}
-void glue(op_swc1, MEMSUFFIX) (void)
-{
-    glue(stl, MEMSUFFIX)(T0, WT0);
-    FORCE_RET();
-}
-void glue(op_ldc1, MEMSUFFIX) (void)
-{
-    DT0 = glue(ldq, MEMSUFFIX)(T0);
-    FORCE_RET();
-}
-void glue(op_sdc1, MEMSUFFIX) (void)
-{
-    glue(stq, MEMSUFFIX)(T0, DT0);
-    FORCE_RET();
-}
 void glue(op_luxc1, MEMSUFFIX) (void)
 {
     DT0 = glue(ldq, MEMSUFFIX)(T0 & ~0x7);
diff --git a/target-mips/translate.c b/target-mips/translate.c
index 8a00336ed4..757e12bbdd 100644
--- a/target-mips/translate.c
+++ b/target-mips/translate.c
@@ -423,7 +423,10 @@ enum {
 };
 
 /* global register indices */
-static TCGv cpu_env, current_tc_gprs, current_tc_hi, cpu_T[2];
+static TCGv cpu_env, current_tc_gprs, current_tc_hi, current_fpu, cpu_T[2];
+
+/* FPU TNs, global for now. */
+static TCGv fpu32_T[3], fpu64_T[3], fpu32h_T[3];
 
 static inline void tcg_gen_helper_0_1i(void *func, TCGv arg)
 {
@@ -572,58 +575,60 @@ static inline void gen_store_srsgpr (TCGv t, int reg)
 }
 
 /* Floating point register moves. */
-#define FGEN32(func, NAME)                       \
-static GenOpFunc *NAME ## _table [32] = {        \
-NAME ## 0,  NAME ## 1,  NAME ## 2,  NAME ## 3,   \
-NAME ## 4,  NAME ## 5,  NAME ## 6,  NAME ## 7,   \
-NAME ## 8,  NAME ## 9,  NAME ## 10, NAME ## 11,  \
-NAME ## 12, NAME ## 13, NAME ## 14, NAME ## 15,  \
-NAME ## 16, NAME ## 17, NAME ## 18, NAME ## 19,  \
-NAME ## 20, NAME ## 21, NAME ## 22, NAME ## 23,  \
-NAME ## 24, NAME ## 25, NAME ## 26, NAME ## 27,  \
-NAME ## 28, NAME ## 29, NAME ## 30, NAME ## 31,  \
-};                                               \
-static always_inline void func(int n)            \
-{                                                \
-    NAME ## _table[n]();                         \
+static inline void gen_load_fpr32 (TCGv t, int reg)
+{
+    tcg_gen_ld_i32(t, current_fpu, 8 * reg + 4 * FP_ENDIAN_IDX);
 }
 
-FGEN32(gen_op_load_fpr_WT0,  gen_op_load_fpr_WT0_fpr);
-FGEN32(gen_op_store_fpr_WT0, gen_op_store_fpr_WT0_fpr);
-
-FGEN32(gen_op_load_fpr_WT1,  gen_op_load_fpr_WT1_fpr);
-FGEN32(gen_op_store_fpr_WT1, gen_op_store_fpr_WT1_fpr);
-
-FGEN32(gen_op_load_fpr_WT2,  gen_op_load_fpr_WT2_fpr);
-FGEN32(gen_op_store_fpr_WT2, gen_op_store_fpr_WT2_fpr);
-
-FGEN32(gen_op_load_fpr_DT0,  gen_op_load_fpr_DT0_fpr);
-FGEN32(gen_op_store_fpr_DT0, gen_op_store_fpr_DT0_fpr);
-
-FGEN32(gen_op_load_fpr_DT1,  gen_op_load_fpr_DT1_fpr);
-FGEN32(gen_op_store_fpr_DT1, gen_op_store_fpr_DT1_fpr);
-
-FGEN32(gen_op_load_fpr_DT2,  gen_op_load_fpr_DT2_fpr);
-FGEN32(gen_op_store_fpr_DT2, gen_op_store_fpr_DT2_fpr);
+static inline void gen_store_fpr32 (TCGv t, int reg)
+{
+    tcg_gen_st_i32(t, current_fpu, 8 * reg + 4 * FP_ENDIAN_IDX);
+}
 
-FGEN32(gen_op_load_fpr_WTH0,  gen_op_load_fpr_WTH0_fpr);
-FGEN32(gen_op_store_fpr_WTH0, gen_op_store_fpr_WTH0_fpr);
+static inline void gen_load_fpr64 (DisasContext *ctx, TCGv t, int reg)
+{
+    if (ctx->hflags & MIPS_HFLAG_F64) {
+        tcg_gen_ld_i64(t, current_fpu, 8 * reg);
+    } else {
+        TCGv r_tmp1 = tcg_temp_new(TCG_TYPE_I32);
+        TCGv r_tmp2 = tcg_temp_new(TCG_TYPE_I64);
+
+        tcg_gen_ld_i32(r_tmp1, current_fpu, 8 * (reg | 1) + 4 * FP_ENDIAN_IDX);
+        tcg_gen_extu_i32_i64(t, r_tmp1);
+        tcg_gen_shli_i64(t, t, 32);
+        tcg_gen_ld_i32(r_tmp1, current_fpu, 8 * (reg & ~1) + 4 * FP_ENDIAN_IDX);
+        tcg_gen_extu_i32_i64(r_tmp2, r_tmp1);
+        tcg_gen_or_i64(t, t, r_tmp2);
+        tcg_temp_free(r_tmp1);
+        tcg_temp_free(r_tmp2);
+    }
+}
 
-FGEN32(gen_op_load_fpr_WTH1,  gen_op_load_fpr_WTH1_fpr);
-FGEN32(gen_op_store_fpr_WTH1, gen_op_store_fpr_WTH1_fpr);
+static inline void gen_store_fpr64 (DisasContext *ctx, TCGv t, int reg)
+{
+    if (ctx->hflags & MIPS_HFLAG_F64) {
+        tcg_gen_st_i64(t, current_fpu, 8 * reg);
+    } else {
+        TCGv r_tmp = tcg_temp_new(TCG_TYPE_I32);
 
-FGEN32(gen_op_load_fpr_WTH2,  gen_op_load_fpr_WTH2_fpr);
-FGEN32(gen_op_store_fpr_WTH2, gen_op_store_fpr_WTH2_fpr);
+        tcg_gen_trunc_i64_i32(r_tmp, t);
+        tcg_gen_st_i32(r_tmp, current_fpu, 8 * (reg & ~1) + 4 * FP_ENDIAN_IDX);
+        tcg_gen_shri_i64(t, t, 32);
+        tcg_gen_trunc_i64_i32(r_tmp, t);
+        tcg_gen_st_i32(r_tmp, current_fpu, 8 * (reg | 1) + 4 * FP_ENDIAN_IDX);
+        tcg_temp_free(r_tmp);
+    }
+}
 
-#define GEN_LOAD_FREG_FTN(FTn, Fn)                                            \
-do {                                                                          \
-    glue(gen_op_load_fpr_, FTn)(Fn);                                          \
-} while (0)
+static inline void gen_load_fpr32h (TCGv t, int reg)
+{
+    tcg_gen_ld_i32(t, current_fpu, 8 * reg + 4 * !FP_ENDIAN_IDX);
+}
 
-#define GEN_STORE_FTN_FREG(Fn, FTn)                                           \
-do {                                                                          \
-    glue(gen_op_store_fpr_, FTn)(Fn);                                         \
-} while (0)
+static inline void gen_store_fpr32h (TCGv t, int reg)
+{
+    tcg_gen_st_i32(t, current_fpu, 8 * reg + 4 * !FP_ENDIAN_IDX);
+}
 
 #define FOP_CONDS(type, fmt)                                            \
 static GenOpFunc1 * gen_op_cmp ## type ## _ ## fmt ## _table[16] = {    \
@@ -950,10 +955,6 @@ OP_LD_TABLE(wl);
 OP_LD_TABLE(wr);
 OP_ST_TABLE(wl);
 OP_ST_TABLE(wr);
-OP_LD_TABLE(wc1);
-OP_ST_TABLE(wc1);
-OP_LD_TABLE(dc1);
-OP_ST_TABLE(dc1);
 OP_LD_TABLE(uxc1);
 OP_ST_TABLE(uxc1);
 
@@ -1028,26 +1029,6 @@ OP_ST_ATOMIC(scd,st64,0x7);
 #endif
 #undef OP_ST_ATOMIC
 
-void inline op_ldst_lwc1(DisasContext *ctx)
-{
-    op_ldst(lwc1);
-}
-
-void inline op_ldst_ldc1(DisasContext *ctx)
-{
-    op_ldst(ldc1);
-}
-
-void inline op_ldst_swc1(DisasContext *ctx)
-{
-    op_ldst(swc1);
-}
-
-void inline op_ldst_sdc1(DisasContext *ctx)
-{
-    op_ldst(sdc1);
-}
-
 /* Load and store */
 static void gen_ldst (DisasContext *ctx, uint32_t opc, int rt,
                       int base, int16_t offset)
@@ -1218,23 +1199,23 @@ static void gen_flt_ldst (DisasContext *ctx, uint32_t opc, int ft,
        memory access. */
     switch (opc) {
     case OPC_LWC1:
-        op_ldst_lwc1(ctx);
-        GEN_STORE_FTN_FREG(ft, WT0);
+        tcg_gen_qemu_ld32s(fpu32_T[0], cpu_T[0], ctx->mem_idx);
+        gen_store_fpr32(fpu32_T[0], ft);
         opn = "lwc1";
         break;
     case OPC_SWC1:
-        GEN_LOAD_FREG_FTN(WT0, ft);
-        op_ldst_swc1(ctx);
+        gen_load_fpr32(fpu32_T[0], ft);
+        tcg_gen_qemu_st32(fpu32_T[0], cpu_T[0], ctx->mem_idx);
         opn = "swc1";
         break;
     case OPC_LDC1:
-        op_ldst_ldc1(ctx);
-        GEN_STORE_FTN_FREG(ft, DT0);
+        tcg_gen_qemu_ld64(fpu64_T[0], cpu_T[0], ctx->mem_idx);
+        gen_store_fpr64(ctx, fpu64_T[0], ft);
         opn = "ldc1";
         break;
     case OPC_SDC1:
-        GEN_LOAD_FREG_FTN(DT0, ft);
-        op_ldst_sdc1(ctx);
+        gen_load_fpr64(ctx, fpu64_T[0], ft);
+        tcg_gen_qemu_st64(fpu64_T[0], cpu_T[0], ctx->mem_idx);
         opn = "sdc1";
         break;
     default:
@@ -5073,11 +5054,11 @@ static void gen_mftr(CPUState *env, DisasContext *ctx, int rt,
     case 2:
         /* XXX: For now we support only a single FPU context. */
         if (h == 0) {
-            GEN_LOAD_FREG_FTN(WT0, rt);
-            gen_op_mfc1();
+            gen_load_fpr32(fpu32_T[0], rt);
+            tcg_gen_ext_i32_tl(cpu_T[0], fpu32_T[0]);
         } else {
-            GEN_LOAD_FREG_FTN(WTH0, rt);
-            gen_op_mfhc1();
+            gen_load_fpr32h(fpu32h_T[0], rt);
+            tcg_gen_ext_i32_tl(cpu_T[0], fpu32h_T[0]);
         }
         break;
     case 3:
@@ -5237,11 +5218,11 @@ static void gen_mttr(CPUState *env, DisasContext *ctx, int rd,
     case 2:
         /* XXX: For now we support only a single FPU context. */
         if (h == 0) {
-            gen_op_mtc1();
-            GEN_STORE_FTN_FREG(rd, WT0);
+            tcg_gen_trunc_tl_i32(fpu32_T[0], cpu_T[0]);
+            gen_store_fpr32(fpu32_T[0], rd);
         } else {
-            gen_op_mthc1();
-            GEN_STORE_FTN_FREG(rd, WTH0);
+            tcg_gen_trunc_tl_i32(fpu32h_T[0], cpu_T[0]);
+            gen_store_fpr32h(fpu32h_T[0], rd);
         }
         break;
     case 3:
@@ -5464,15 +5445,15 @@ static void gen_cp1 (DisasContext *ctx, uint32_t opc, int rt, int fs)
 
     switch (opc) {
     case OPC_MFC1:
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        gen_op_mfc1();
+        gen_load_fpr32(fpu32_T[0], fs);
+        tcg_gen_ext_i32_tl(cpu_T[0], fpu32_T[0]);
         gen_store_gpr(cpu_T[0], rt);
         opn = "mfc1";
         break;
     case OPC_MTC1:
         gen_load_gpr(cpu_T[0], rt);
-        gen_op_mtc1();
-        GEN_STORE_FTN_FREG(fs, WT0);
+        tcg_gen_trunc_tl_i32(fpu32_T[0], cpu_T[0]);
+        gen_store_fpr32(fpu32_T[0], fs);
         opn = "mtc1";
         break;
     case OPC_CFC1:
@@ -5486,27 +5467,27 @@ static void gen_cp1 (DisasContext *ctx, uint32_t opc, int rt, int fs)
         opn = "ctc1";
         break;
     case OPC_DMFC1:
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        gen_op_dmfc1();
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        tcg_gen_mov_tl(cpu_T[0], fpu64_T[0]);
         gen_store_gpr(cpu_T[0], rt);
         opn = "dmfc1";
         break;
     case OPC_DMTC1:
         gen_load_gpr(cpu_T[0], rt);
-        gen_op_dmtc1();
-        GEN_STORE_FTN_FREG(fs, DT0);
+        tcg_gen_mov_tl(fpu64_T[0], cpu_T[0]);
+        gen_store_fpr64(ctx, fpu64_T[0], fs);
         opn = "dmtc1";
         break;
     case OPC_MFHC1:
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        gen_op_mfhc1();
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        tcg_gen_ext_i32_tl(cpu_T[0], fpu32h_T[0]);
         gen_store_gpr(cpu_T[0], rt);
         opn = "mfhc1";
         break;
     case OPC_MTHC1:
         gen_load_gpr(cpu_T[0], rt);
-        gen_op_mthc1();
-        GEN_STORE_FTN_FREG(fs, WTH0);
+        tcg_gen_trunc_tl_i32(fpu32h_T[0], cpu_T[0]);
+        gen_store_fpr32h(fpu32h_T[0], fs);
         opn = "mthc1";
         break;
     default:
@@ -5614,207 +5595,207 @@ static void gen_farith (DisasContext *ctx, uint32_t op1,
 
     switch (ctx->opcode & FOP(0x3f, 0x1f)) {
     case FOP(0, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
         gen_op_float_add_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "add.s";
         optype = BINOP;
         break;
     case FOP(1, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
         gen_op_float_sub_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "sub.s";
         optype = BINOP;
         break;
     case FOP(2, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
         gen_op_float_mul_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "mul.s";
         optype = BINOP;
         break;
     case FOP(3, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
         gen_op_float_div_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "div.s";
         optype = BINOP;
         break;
     case FOP(4, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_sqrt_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "sqrt.s";
         break;
     case FOP(5, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_abs_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "abs.s";
         break;
     case FOP(6, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_mov_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "mov.s";
         break;
     case FOP(7, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_chs_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "neg.s";
         break;
     case FOP(8, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_roundl_s();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "round.l.s";
         break;
     case FOP(9, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_truncl_s();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "trunc.l.s";
         break;
     case FOP(10, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_ceill_s();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "ceil.l.s";
         break;
     case FOP(11, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_floorl_s();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "floor.l.s";
         break;
     case FOP(12, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_roundw_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "round.w.s";
         break;
     case FOP(13, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_truncw_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "trunc.w.s";
         break;
     case FOP(14, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_ceilw_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "ceil.w.s";
         break;
     case FOP(15, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_floorw_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "floor.w.s";
         break;
     case FOP(17, 16):
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
         gen_movcf_s(ctx, (ft >> 2) & 0x7, ft & 0x1);
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "movcf.s";
         break;
     case FOP(18, 16):
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
         gen_op_float_movz_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "movz.s";
         break;
     case FOP(19, 16):
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
         gen_op_float_movn_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "movn.s";
         break;
     case FOP(21, 16):
         check_cop1x(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_recip_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "recip.s";
         break;
     case FOP(22, 16):
         check_cop1x(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_rsqrt_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "rsqrt.s";
         break;
     case FOP(28, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
         gen_op_float_recip2_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "recip2.s";
         break;
     case FOP(29, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_recip1_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "recip1.s";
         break;
     case FOP(30, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_rsqrt1_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "rsqrt1.s";
         break;
     case FOP(31, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT2, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], ft);
         gen_op_float_rsqrt2_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "rsqrt2.s";
         break;
     case FOP(33, 16):
         check_cp1_registers(ctx, fd);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_cvtd_s();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "cvt.d.s";
         break;
     case FOP(36, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_cvtw_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "cvt.w.s";
         break;
     case FOP(37, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_cvtl_s();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "cvt.l.s";
         break;
     case FOP(38, 16):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT1, fs);
-        GEN_LOAD_FREG_FTN(WT0, ft);
+        gen_load_fpr32(fpu32_T[1], fs);
+        gen_load_fpr32(fpu32_T[0], ft);
         gen_op_float_cvtps_s();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "cvt.ps.s";
         break;
     case FOP(48, 16):
@@ -5833,8 +5814,8 @@ static void gen_farith (DisasContext *ctx, uint32_t op1,
     case FOP(61, 16):
     case FOP(62, 16):
     case FOP(63, 16):
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
         if (ctx->opcode & (1 << 6)) {
             check_cop1x(ctx);
             gen_cmpabs_s(func-48, cc);
@@ -5846,190 +5827,190 @@ static void gen_farith (DisasContext *ctx, uint32_t op1,
         break;
     case FOP(0, 17):
         check_cp1_registers(ctx, fs | ft | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
         gen_op_float_add_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "add.d";
         optype = BINOP;
         break;
     case FOP(1, 17):
         check_cp1_registers(ctx, fs | ft | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
         gen_op_float_sub_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "sub.d";
         optype = BINOP;
         break;
     case FOP(2, 17):
         check_cp1_registers(ctx, fs | ft | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
         gen_op_float_mul_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "mul.d";
         optype = BINOP;
         break;
     case FOP(3, 17):
         check_cp1_registers(ctx, fs | ft | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
         gen_op_float_div_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "div.d";
         optype = BINOP;
         break;
     case FOP(4, 17):
         check_cp1_registers(ctx, fs | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_sqrt_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "sqrt.d";
         break;
     case FOP(5, 17):
         check_cp1_registers(ctx, fs | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_abs_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "abs.d";
         break;
     case FOP(6, 17):
         check_cp1_registers(ctx, fs | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_mov_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "mov.d";
         break;
     case FOP(7, 17):
         check_cp1_registers(ctx, fs | fd);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_chs_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "neg.d";
         break;
     case FOP(8, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_roundl_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "round.l.d";
         break;
     case FOP(9, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_truncl_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "trunc.l.d";
         break;
     case FOP(10, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_ceill_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "ceil.l.d";
         break;
     case FOP(11, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_floorl_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "floor.l.d";
         break;
     case FOP(12, 17):
         check_cp1_registers(ctx, fs);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_roundw_d();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "round.w.d";
         break;
     case FOP(13, 17):
         check_cp1_registers(ctx, fs);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_truncw_d();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "trunc.w.d";
         break;
     case FOP(14, 17):
         check_cp1_registers(ctx, fs);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_ceilw_d();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "ceil.w.d";
         break;
     case FOP(15, 17):
         check_cp1_registers(ctx, fs);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_floorw_d();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "floor.w.d";
         break;
     case FOP(17, 17):
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT2, fd);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[2], fd);
         gen_movcf_d(ctx, (ft >> 2) & 0x7, ft & 0x1);
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "movcf.d";
         break;
     case FOP(18, 17):
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT2, fd);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[2], fd);
         gen_op_float_movz_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "movz.d";
         break;
     case FOP(19, 17):
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT2, fd);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[2], fd);
         gen_op_float_movn_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "movn.d";
         break;
     case FOP(21, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_recip_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "recip.d";
         break;
     case FOP(22, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_rsqrt_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "rsqrt.d";
         break;
     case FOP(28, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT2, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[2], ft);
         gen_op_float_recip2_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "recip2.d";
         break;
     case FOP(29, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_recip1_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "recip1.d";
         break;
     case FOP(30, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_rsqrt1_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "rsqrt1.d";
         break;
     case FOP(31, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT2, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[2], ft);
         gen_op_float_rsqrt2_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "rsqrt2.d";
         break;
     case FOP(48, 17):
@@ -6048,8 +6029,8 @@ static void gen_farith (DisasContext *ctx, uint32_t op1,
     case FOP(61, 17):
     case FOP(62, 17):
     case FOP(63, 17):
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
         if (ctx->opcode & (1 << 6)) {
             check_cop1x(ctx);
             check_cp1_registers(ctx, fs | ft);
@@ -6063,275 +6044,275 @@ static void gen_farith (DisasContext *ctx, uint32_t op1,
         break;
     case FOP(32, 17):
         check_cp1_registers(ctx, fs);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_cvts_d();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "cvt.s.d";
         break;
     case FOP(36, 17):
         check_cp1_registers(ctx, fs);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_cvtw_d();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "cvt.w.d";
         break;
     case FOP(37, 17):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_cvtl_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "cvt.l.d";
         break;
     case FOP(32, 20):
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_cvts_w();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "cvt.s.w";
         break;
     case FOP(33, 20):
         check_cp1_registers(ctx, fd);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_cvtd_w();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "cvt.d.w";
         break;
     case FOP(32, 21):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_cvts_l();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "cvt.s.l";
         break;
     case FOP(33, 21):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         gen_op_float_cvtd_l();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "cvt.d.l";
         break;
     case FOP(38, 20):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_cvtps_pw();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "cvt.ps.pw";
         break;
     case FOP(0, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
         gen_op_float_add_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "add.ps";
         break;
     case FOP(1, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
         gen_op_float_sub_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "sub.ps";
         break;
     case FOP(2, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
         gen_op_float_mul_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "mul.ps";
         break;
     case FOP(5, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_abs_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "abs.ps";
         break;
     case FOP(6, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_mov_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "mov.ps";
         break;
     case FOP(7, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_chs_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "neg.ps";
         break;
     case FOP(17, 22):
         check_cp1_64bitmode(ctx);
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
-        GEN_LOAD_FREG_FTN(WTH2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
+        gen_load_fpr32h(fpu32h_T[2], fd);
         if (ft & 0x1)
             gen_op_float_movt_ps ((ft >> 2) & 0x7);
         else
             gen_op_float_movf_ps ((ft >> 2) & 0x7);
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "movcf.ps";
         break;
     case FOP(18, 22):
         check_cp1_64bitmode(ctx);
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
-        GEN_LOAD_FREG_FTN(WTH2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
+        gen_load_fpr32h(fpu32h_T[2], fd);
         gen_op_float_movz_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "movz.ps";
         break;
     case FOP(19, 22):
         check_cp1_64bitmode(ctx);
         gen_load_gpr(cpu_T[0], ft);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
-        GEN_LOAD_FREG_FTN(WTH2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
+        gen_load_fpr32h(fpu32h_T[2], fd);
         gen_op_float_movn_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "movn.ps";
         break;
     case FOP(24, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, ft);
-        GEN_LOAD_FREG_FTN(WTH0, ft);
-        GEN_LOAD_FREG_FTN(WT1, fs);
-        GEN_LOAD_FREG_FTN(WTH1, fs);
+        gen_load_fpr32(fpu32_T[0], ft);
+        gen_load_fpr32h(fpu32h_T[0], ft);
+        gen_load_fpr32(fpu32_T[1], fs);
+        gen_load_fpr32h(fpu32h_T[1], fs);
         gen_op_float_addr_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "addr.ps";
         break;
     case FOP(26, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, ft);
-        GEN_LOAD_FREG_FTN(WTH0, ft);
-        GEN_LOAD_FREG_FTN(WT1, fs);
-        GEN_LOAD_FREG_FTN(WTH1, fs);
+        gen_load_fpr32(fpu32_T[0], ft);
+        gen_load_fpr32h(fpu32h_T[0], ft);
+        gen_load_fpr32(fpu32_T[1], fs);
+        gen_load_fpr32h(fpu32h_T[1], fs);
         gen_op_float_mulr_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "mulr.ps";
         break;
     case FOP(28, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT2, fd);
-        GEN_LOAD_FREG_FTN(WTH2, fd);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], fd);
+        gen_load_fpr32h(fpu32h_T[2], fd);
         gen_op_float_recip2_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "recip2.ps";
         break;
     case FOP(29, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_recip1_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "recip1.ps";
         break;
     case FOP(30, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_rsqrt1_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "rsqrt1.ps";
         break;
     case FOP(31, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT2, ft);
-        GEN_LOAD_FREG_FTN(WTH2, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[2], ft);
+        gen_load_fpr32h(fpu32h_T[2], ft);
         gen_op_float_rsqrt2_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "rsqrt2.ps";
         break;
     case FOP(32, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_cvts_pu();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "cvt.s.pu";
         break;
     case FOP(36, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
         gen_op_float_cvtpw_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "cvt.pw.ps";
         break;
     case FOP(40, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
+        gen_load_fpr32(fpu32_T[0], fs);
         gen_op_float_cvts_pl();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "cvt.s.pl";
         break;
     case FOP(44, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
         gen_op_float_pll_ps();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "pll.ps";
         break;
     case FOP(45, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[1], ft);
         gen_op_float_plu_ps();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "plu.ps";
         break;
     case FOP(46, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
         gen_op_float_pul_ps();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "pul.ps";
         break;
     case FOP(47, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[1], ft);
         gen_op_float_puu_ps();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "puu.ps";
         break;
     case FOP(48, 22):
@@ -6351,10 +6332,10 @@ static void gen_farith (DisasContext *ctx, uint32_t op1,
     case FOP(62, 22):
     case FOP(63, 22):
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
         if (ctx->opcode & (1 << 6)) {
             gen_cmpabs_ps(func-48, cc);
             opn = condnames_abs[func-48];
@@ -6402,41 +6383,41 @@ static void gen_flt3_ldst (DisasContext *ctx, uint32_t opc,
     switch (opc) {
     case OPC_LWXC1:
         check_cop1x(ctx);
-        op_ldst_lwc1(ctx);
-        GEN_STORE_FTN_FREG(fd, WT0);
+        tcg_gen_qemu_ld32s(fpu32_T[0], cpu_T[0], ctx->mem_idx);
+        gen_store_fpr32(fpu32_T[0], fd);
         opn = "lwxc1";
         break;
     case OPC_LDXC1:
         check_cop1x(ctx);
         check_cp1_registers(ctx, fd);
-        op_ldst_ldc1(ctx);
-        GEN_STORE_FTN_FREG(fd, DT0);
+        tcg_gen_qemu_ld64(fpu64_T[0], cpu_T[0], ctx->mem_idx);
+        gen_store_fpr64(ctx, fpu64_T[0], fd);
         opn = "ldxc1";
         break;
     case OPC_LUXC1:
         check_cp1_64bitmode(ctx);
         op_ldst(luxc1);
-        GEN_STORE_FTN_FREG(fd, DT0);
+        gen_store_fpr64(ctx, fpu64_T[0], fd);
         opn = "luxc1";
         break;
     case OPC_SWXC1:
         check_cop1x(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        op_ldst_swc1(ctx);
+        gen_load_fpr32(fpu32_T[0], fs);
+        tcg_gen_qemu_st32(fpu32_T[0], cpu_T[0], ctx->mem_idx);
         opn = "swxc1";
         store = 1;
         break;
     case OPC_SDXC1:
         check_cop1x(ctx);
         check_cp1_registers(ctx, fs);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        op_ldst_sdc1(ctx);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        tcg_gen_qemu_st64(fpu64_T[0], cpu_T[0], ctx->mem_idx);
         opn = "sdxc1";
         store = 1;
         break;
     case OPC_SUXC1:
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(DT0, fs);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
         op_ldst(suxc1);
         opn = "suxc1";
         store = 1;
@@ -6459,138 +6440,138 @@ static void gen_flt3_arith (DisasContext *ctx, uint32_t opc,
     case OPC_ALNV_PS:
         check_cp1_64bitmode(ctx);
         gen_load_gpr(cpu_T[0], fr);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
         gen_op_float_alnv_ps();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "alnv.ps";
         break;
     case OPC_MADD_S:
         check_cop1x(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
         gen_op_float_muladd_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "madd.s";
         break;
     case OPC_MADD_D:
         check_cop1x(ctx);
         check_cp1_registers(ctx, fd | fs | ft | fr);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
-        GEN_LOAD_FREG_FTN(DT2, fr);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
+        gen_load_fpr64(ctx, fpu64_T[2], fr);
         gen_op_float_muladd_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "madd.d";
         break;
     case OPC_MADD_PS:
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
-        GEN_LOAD_FREG_FTN(WTH2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
+        gen_load_fpr32h(fpu32h_T[2], fr);
         gen_op_float_muladd_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "madd.ps";
         break;
     case OPC_MSUB_S:
         check_cop1x(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
         gen_op_float_mulsub_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "msub.s";
         break;
     case OPC_MSUB_D:
         check_cop1x(ctx);
         check_cp1_registers(ctx, fd | fs | ft | fr);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
-        GEN_LOAD_FREG_FTN(DT2, fr);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
+        gen_load_fpr64(ctx, fpu64_T[2], fr);
         gen_op_float_mulsub_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "msub.d";
         break;
     case OPC_MSUB_PS:
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
-        GEN_LOAD_FREG_FTN(WTH2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
+        gen_load_fpr32h(fpu32h_T[2], fr);
         gen_op_float_mulsub_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "msub.ps";
         break;
     case OPC_NMADD_S:
         check_cop1x(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
         gen_op_float_nmuladd_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "nmadd.s";
         break;
     case OPC_NMADD_D:
         check_cop1x(ctx);
         check_cp1_registers(ctx, fd | fs | ft | fr);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
-        GEN_LOAD_FREG_FTN(DT2, fr);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
+        gen_load_fpr64(ctx, fpu64_T[2], fr);
         gen_op_float_nmuladd_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "nmadd.d";
         break;
     case OPC_NMADD_PS:
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
-        GEN_LOAD_FREG_FTN(WTH2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
+        gen_load_fpr32h(fpu32h_T[2], fr);
         gen_op_float_nmuladd_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "nmadd.ps";
         break;
     case OPC_NMSUB_S:
         check_cop1x(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
         gen_op_float_nmulsub_s();
-        GEN_STORE_FTN_FREG(fd, WT2);
+        gen_store_fpr32(fpu32_T[2], fd);
         opn = "nmsub.s";
         break;
     case OPC_NMSUB_D:
         check_cop1x(ctx);
         check_cp1_registers(ctx, fd | fs | ft | fr);
-        GEN_LOAD_FREG_FTN(DT0, fs);
-        GEN_LOAD_FREG_FTN(DT1, ft);
-        GEN_LOAD_FREG_FTN(DT2, fr);
+        gen_load_fpr64(ctx, fpu64_T[0], fs);
+        gen_load_fpr64(ctx, fpu64_T[1], ft);
+        gen_load_fpr64(ctx, fpu64_T[2], fr);
         gen_op_float_nmulsub_d();
-        GEN_STORE_FTN_FREG(fd, DT2);
+        gen_store_fpr64(ctx, fpu64_T[2], fd);
         opn = "nmsub.d";
         break;
     case OPC_NMSUB_PS:
         check_cp1_64bitmode(ctx);
-        GEN_LOAD_FREG_FTN(WT0, fs);
-        GEN_LOAD_FREG_FTN(WTH0, fs);
-        GEN_LOAD_FREG_FTN(WT1, ft);
-        GEN_LOAD_FREG_FTN(WTH1, ft);
-        GEN_LOAD_FREG_FTN(WT2, fr);
-        GEN_LOAD_FREG_FTN(WTH2, fr);
+        gen_load_fpr32(fpu32_T[0], fs);
+        gen_load_fpr32h(fpu32h_T[0], fs);
+        gen_load_fpr32(fpu32_T[1], ft);
+        gen_load_fpr32h(fpu32h_T[1], ft);
+        gen_load_fpr32(fpu32_T[2], fr);
+        gen_load_fpr32h(fpu32h_T[2], fr);
         gen_op_float_nmulsub_ps();
-        GEN_STORE_FTN_FREG(fd, WT2);
-        GEN_STORE_FTN_FREG(fd, WTH2);
+        gen_store_fpr32(fpu32_T[2], fd);
+        gen_store_fpr32h(fpu32h_T[2], fd);
         opn = "nmsub.ps";
         break;
     default:
@@ -7294,6 +7275,9 @@ gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb,
         if (gen_opc_ptr >= gen_opc_end)
             break;
 
+        if (gen_opc_ptr >= gen_opc_end)
+            break;
+
 #if defined (MIPS_SINGLE_STEP)
         break;
 #endif
@@ -7487,6 +7471,10 @@ static void mips_tcg_init(void)
                                        TCG_AREG0,
                                        offsetof(CPUState, current_tc_hi),
                                        "current_tc_hi");
+    current_fpu = tcg_global_mem_new(TCG_TYPE_PTR,
+                                     TCG_AREG0,
+                                     offsetof(CPUState, fpu),
+                                     "current_fpu");
 #if TARGET_LONG_BITS > HOST_LONG_BITS
     cpu_T[0] = tcg_global_mem_new(TCG_TYPE_TL,
                                   TCG_AREG0, offsetof(CPUState, t0), "T0");
@@ -7502,6 +7490,16 @@ static void mips_tcg_init(void)
 #define DEF_HELPER(ret, name, params) tcg_register_helper(name, #name);
 #include "helper.h"
 
+    fpu32_T[0] = tcg_global_mem_new(TCG_TYPE_I32, TCG_AREG0, offsetof(CPUState, ft0.w[FP_ENDIAN_IDX]), "WT0");
+    fpu32_T[1] = tcg_global_mem_new(TCG_TYPE_I32, TCG_AREG0, offsetof(CPUState, ft1.w[FP_ENDIAN_IDX]), "WT1");
+    fpu32_T[2] = tcg_global_mem_new(TCG_TYPE_I32, TCG_AREG0, offsetof(CPUState, ft2.w[FP_ENDIAN_IDX]), "WT2");
+    fpu64_T[0] = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0, offsetof(CPUState, ft0.d), "DT0");
+    fpu64_T[1] = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0, offsetof(CPUState, ft1.d), "DT1");
+    fpu64_T[2] = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0, offsetof(CPUState, ft2.d), "DT2");
+    fpu32h_T[0] = tcg_global_mem_new(TCG_TYPE_I32, TCG_AREG0, offsetof(CPUState, ft0.w[!FP_ENDIAN_IDX]), "WTH0");
+    fpu32h_T[1] = tcg_global_mem_new(TCG_TYPE_I32, TCG_AREG0, offsetof(CPUState, ft1.w[!FP_ENDIAN_IDX]), "WTH1");
+    fpu32h_T[2] = tcg_global_mem_new(TCG_TYPE_I32, TCG_AREG0, offsetof(CPUState, ft2.w[!FP_ENDIAN_IDX]), "WTH2");
+
     inited = 1;
 }