/ - Diff - qemu - Greek Research and Technology Network's projects

Revision aa0bf00b

             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"
-...
     # 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",

+    }
     #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);

     };
     /* 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)
+    {
-...
+    }
     /* 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] = {    \
-...
     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);
-...
     #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)
-...
            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:
-...
         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:
-...
         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:
-...
         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:
-...
             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:
-...
         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):
-...
         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);
-...
             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):
-...
         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);
-...
             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):
-...
         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];
-...
         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;
-...
         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);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Archipelago » qemu

Revision aa0bf00b