Archipelago » qemu

/*

   SPARC translation

   Copyright (C) 2003 Thomas M. Ogrisegg <tom@fnord.at>

   Copyright (C) 2003-2005 Fabrice Bellard

   This library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <inttypes.h>

#include "cpu.h"

#include "disas.h"

#include "helper.h"

#include "tcg-op.h"

#define GEN_HELPER 1

#include "helper.h"

#define DEBUG_DISAS

#define DYNAMIC_PC  1 /* dynamic pc value */

#define JUMP_PC     2 /* dynamic pc value which takes only two values

                         according to jump_pc[T2] */

/* global register indexes */

static TCGv_ptr cpu_env, cpu_regwptr;

static TCGv cpu_cc_src, cpu_cc_src2, cpu_cc_dst;

static TCGv_i32 cpu_cc_op;

static TCGv_i32 cpu_psr;

static TCGv cpu_fsr, cpu_pc, cpu_npc, cpu_gregs[8];

static TCGv cpu_y;

#ifndef CONFIG_USER_ONLY

static TCGv cpu_tbr;

#endif

static TCGv cpu_cond;

#ifdef TARGET_SPARC64

static TCGv_i32 cpu_xcc, cpu_asi, cpu_fprs;

static TCGv cpu_gsr;

static TCGv cpu_tick_cmpr, cpu_stick_cmpr, cpu_hstick_cmpr;

static TCGv cpu_hintp, cpu_htba, cpu_hver, cpu_ssr, cpu_ver;

static TCGv_i32 cpu_softint;

#else

static TCGv cpu_wim;

#endif

/* Floating point registers */

static TCGv_i64 cpu_fpr[TARGET_DPREGS];

static target_ulong gen_opc_npc[OPC_BUF_SIZE];

static target_ulong gen_opc_jump_pc[2];

#include "gen-icount.h"

typedef struct DisasContext {

    target_ulong pc;    /* current Program Counter: integer or DYNAMIC_PC */

    target_ulong npc;   /* next PC: integer or DYNAMIC_PC or JUMP_PC */

    target_ulong jump_pc[2]; /* used when JUMP_PC pc value is used */

    int is_br;

    int mem_idx;

    int fpu_enabled;

    int address_mask_32bit;

    int singlestep;

    uint32_t cc_op;  /* current CC operation */

    struct TranslationBlock *tb;

    sparc_def_t *def;

    TCGv_i32 t32[3];

    TCGv ttl[5];

    int n_t32;

    int n_ttl;

} DisasContext;

typedef struct {

    TCGCond cond;

    bool is_bool;

    bool g1, g2;

    TCGv c1, c2;

} DisasCompare;

// This function uses non-native bit order

#define GET_FIELD(X, FROM, TO)                                  \

    ((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1))

// This function uses the order in the manuals, i.e. bit 0 is 2^0

#define GET_FIELD_SP(X, FROM, TO)               \

    GET_FIELD(X, 31 - (TO), 31 - (FROM))

#define GET_FIELDs(x,a,b) sign_extend (GET_FIELD(x,a,b), (b) - (a) + 1)

#define GET_FIELD_SPs(x,a,b) sign_extend (GET_FIELD_SP(x,a,b), ((b) - (a) + 1))

#ifdef TARGET_SPARC64

#define DFPREG(r) (((r & 1) << 5) | (r & 0x1e))

#define QFPREG(r) (((r & 1) << 5) | (r & 0x1c))

#else

#define DFPREG(r) (r & 0x1e)

#define QFPREG(r) (r & 0x1c)

#endif

#define UA2005_HTRAP_MASK 0xff

#define V8_TRAP_MASK 0x7f

static int sign_extend(int x, int len)

{

    len = 32 - len;

    return (x << len) >> len;

}

#define IS_IMM (insn & (1<<13))

static inline TCGv_i32 get_temp_i32(DisasContext *dc)

{

    TCGv_i32 t;

    assert(dc->n_t32 < ARRAY_SIZE(dc->t32));

    dc->t32[dc->n_t32++] = t = tcg_temp_new_i32();

    return t;

}

static inline TCGv get_temp_tl(DisasContext *dc)

{

    TCGv t;

    assert(dc->n_ttl < ARRAY_SIZE(dc->ttl));

    dc->ttl[dc->n_ttl++] = t = tcg_temp_new();

    return t;

}

static inline void gen_update_fprs_dirty(int rd)

{

#if defined(TARGET_SPARC64)

    tcg_gen_ori_i32(cpu_fprs, cpu_fprs, (rd < 32) ? 1 : 2);

#endif

}

/* floating point registers moves */

static TCGv_i32 gen_load_fpr_F(DisasContext *dc, unsigned int src)

{

#if TCG_TARGET_REG_BITS == 32

    if (src & 1) {

        return TCGV_LOW(cpu_fpr[src / 2]);

    } else {

        return TCGV_HIGH(cpu_fpr[src / 2]);

    }

#else

    if (src & 1) {

        return MAKE_TCGV_I32(GET_TCGV_I64(cpu_fpr[src / 2]));

    } else {

        TCGv_i32 ret = get_temp_i32(dc);

        TCGv_i64 t = tcg_temp_new_i64();

        tcg_gen_shri_i64(t, cpu_fpr[src / 2], 32);

        tcg_gen_trunc_i64_i32(ret, t);

        tcg_temp_free_i64(t);

        return ret;

    }

#endif

}

static void gen_store_fpr_F(DisasContext *dc, unsigned int dst, TCGv_i32 v)

{

#if TCG_TARGET_REG_BITS == 32

    if (dst & 1) {

        tcg_gen_mov_i32(TCGV_LOW(cpu_fpr[dst / 2]), v);

    } else {

        tcg_gen_mov_i32(TCGV_HIGH(cpu_fpr[dst / 2]), v);

    }

#else

    TCGv_i64 t = MAKE_TCGV_I64(GET_TCGV_I32(v));

    tcg_gen_deposit_i64(cpu_fpr[dst / 2], cpu_fpr[dst / 2], t,

                        (dst & 1 ? 0 : 32), 32);

#endif

    gen_update_fprs_dirty(dst);

}

static TCGv_i32 gen_dest_fpr_F(DisasContext *dc)

{

    return get_temp_i32(dc);

}

static TCGv_i64 gen_load_fpr_D(DisasContext *dc, unsigned int src)

{

    src = DFPREG(src);

    return cpu_fpr[src / 2];

}

static void gen_store_fpr_D(DisasContext *dc, unsigned int dst, TCGv_i64 v)

{

    dst = DFPREG(dst);

    tcg_gen_mov_i64(cpu_fpr[dst / 2], v);

    gen_update_fprs_dirty(dst);

}

static TCGv_i64 gen_dest_fpr_D(DisasContext *dc, unsigned int dst)

{

    return cpu_fpr[DFPREG(dst) / 2];

}

static void gen_op_load_fpr_QT0(unsigned int src)

{

    tcg_gen_st_i64(cpu_fpr[src / 2], cpu_env, offsetof(CPUSPARCState, qt0) +

                   offsetof(CPU_QuadU, ll.upper));

    tcg_gen_st_i64(cpu_fpr[src/2 + 1], cpu_env, offsetof(CPUSPARCState, qt0) +

                   offsetof(CPU_QuadU, ll.lower));

}

static void gen_op_load_fpr_QT1(unsigned int src)

{

    tcg_gen_st_i64(cpu_fpr[src / 2], cpu_env, offsetof(CPUSPARCState, qt1) +

                   offsetof(CPU_QuadU, ll.upper));

    tcg_gen_st_i64(cpu_fpr[src/2 + 1], cpu_env, offsetof(CPUSPARCState, qt1) +

                   offsetof(CPU_QuadU, ll.lower));

}

static void gen_op_store_QT0_fpr(unsigned int dst)

{

    tcg_gen_ld_i64(cpu_fpr[dst / 2], cpu_env, offsetof(CPUSPARCState, qt0) +

                   offsetof(CPU_QuadU, ll.upper));

    tcg_gen_ld_i64(cpu_fpr[dst/2 + 1], cpu_env, offsetof(CPUSPARCState, qt0) +

                   offsetof(CPU_QuadU, ll.lower));

}

#ifdef TARGET_SPARC64

static void gen_move_Q(unsigned int rd, unsigned int rs)

{

    rd = QFPREG(rd);

    rs = QFPREG(rs);

    tcg_gen_mov_i64(cpu_fpr[rd / 2], cpu_fpr[rs / 2]);

    tcg_gen_mov_i64(cpu_fpr[rd / 2 + 1], cpu_fpr[rs / 2 + 1]);

    gen_update_fprs_dirty(rd);

}

#endif

/* moves */

#ifdef CONFIG_USER_ONLY

#define supervisor(dc) 0

#ifdef TARGET_SPARC64

#define hypervisor(dc) 0

#endif

#else

#define supervisor(dc) (dc->mem_idx >= MMU_KERNEL_IDX)

#ifdef TARGET_SPARC64

#define hypervisor(dc) (dc->mem_idx == MMU_HYPV_IDX)

#else

#endif

#endif

#ifdef TARGET_SPARC64

#ifndef TARGET_ABI32

#define AM_CHECK(dc) ((dc)->address_mask_32bit)

#else

#define AM_CHECK(dc) (1)

#endif

#endif

static inline void gen_address_mask(DisasContext *dc, TCGv addr)

{

#ifdef TARGET_SPARC64

    if (AM_CHECK(dc))

        tcg_gen_andi_tl(addr, addr, 0xffffffffULL);

#endif

}

static inline TCGv gen_load_gpr(DisasContext *dc, int reg)

{

    if (reg == 0 || reg >= 8) {

        TCGv t = get_temp_tl(dc);

        if (reg == 0) {

            tcg_gen_movi_tl(t, 0);

        } else {

            tcg_gen_ld_tl(t, cpu_regwptr, (reg - 8) * sizeof(target_ulong));

        }

        return t;

    } else {

        return cpu_gregs[reg];

    }

}

static inline void gen_store_gpr(DisasContext *dc, int reg, TCGv v)

{

    if (reg > 0) {

        if (reg < 8) {

            tcg_gen_mov_tl(cpu_gregs[reg], v);

        } else {

            tcg_gen_st_tl(v, cpu_regwptr, (reg - 8) * sizeof(target_ulong));

        }

    }

}

static inline TCGv gen_dest_gpr(DisasContext *dc, int reg)

{

    if (reg == 0 || reg >= 8) {

        return get_temp_tl(dc);

    } else {

        return cpu_gregs[reg];

    }

}

static inline void gen_goto_tb(DisasContext *s, int tb_num,

                               target_ulong pc, target_ulong npc)

{

    TranslationBlock *tb;

    tb = s->tb;

    if ((pc & TARGET_PAGE_MASK) == (tb->pc & TARGET_PAGE_MASK) &&

        (npc & TARGET_PAGE_MASK) == (tb->pc & TARGET_PAGE_MASK) &&

        !s->singlestep)  {

        /* jump to same page: we can use a direct jump */

        tcg_gen_goto_tb(tb_num);

        tcg_gen_movi_tl(cpu_pc, pc);

        tcg_gen_movi_tl(cpu_npc, npc);

        tcg_gen_exit_tb((tcg_target_long)tb + tb_num);

    } else {

        /* jump to another page: currently not optimized */

        tcg_gen_movi_tl(cpu_pc, pc);

        tcg_gen_movi_tl(cpu_npc, npc);

        tcg_gen_exit_tb(0);

    }

}

// XXX suboptimal

static inline void gen_mov_reg_N(TCGv reg, TCGv_i32 src)

{

    tcg_gen_extu_i32_tl(reg, src);

    tcg_gen_shri_tl(reg, reg, PSR_NEG_SHIFT);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_mov_reg_Z(TCGv reg, TCGv_i32 src)

{

    tcg_gen_extu_i32_tl(reg, src);

    tcg_gen_shri_tl(reg, reg, PSR_ZERO_SHIFT);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_mov_reg_V(TCGv reg, TCGv_i32 src)

{

    tcg_gen_extu_i32_tl(reg, src);

    tcg_gen_shri_tl(reg, reg, PSR_OVF_SHIFT);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_mov_reg_C(TCGv reg, TCGv_i32 src)

{

    tcg_gen_extu_i32_tl(reg, src);

    tcg_gen_shri_tl(reg, reg, PSR_CARRY_SHIFT);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_op_addi_cc(TCGv dst, TCGv src1, target_long src2)

{

    tcg_gen_mov_tl(cpu_cc_src, src1);

    tcg_gen_movi_tl(cpu_cc_src2, src2);

    tcg_gen_addi_tl(cpu_cc_dst, cpu_cc_src, src2);

    tcg_gen_mov_tl(dst, cpu_cc_dst);

}

static inline void gen_op_add_cc(TCGv dst, TCGv src1, TCGv src2)

{

    tcg_gen_mov_tl(cpu_cc_src, src1);

    tcg_gen_mov_tl(cpu_cc_src2, src2);

    tcg_gen_add_tl(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);

    tcg_gen_mov_tl(dst, cpu_cc_dst);

}

static TCGv_i32 gen_add32_carry32(void)

{

    TCGv_i32 carry_32, cc_src1_32, cc_src2_32;

    /* Carry is computed from a previous add: (dst < src)  */

#if TARGET_LONG_BITS == 64

    cc_src1_32 = tcg_temp_new_i32();

    cc_src2_32 = tcg_temp_new_i32();

    tcg_gen_trunc_i64_i32(cc_src1_32, cpu_cc_dst);

    tcg_gen_trunc_i64_i32(cc_src2_32, cpu_cc_src);

#else

    cc_src1_32 = cpu_cc_dst;

    cc_src2_32 = cpu_cc_src;

#endif

    carry_32 = tcg_temp_new_i32();

    tcg_gen_setcond_i32(TCG_COND_LTU, carry_32, cc_src1_32, cc_src2_32);

#if TARGET_LONG_BITS == 64

    tcg_temp_free_i32(cc_src1_32);

    tcg_temp_free_i32(cc_src2_32);

#endif

    return carry_32;

}

static TCGv_i32 gen_sub32_carry32(void)

{

    TCGv_i32 carry_32, cc_src1_32, cc_src2_32;

    /* Carry is computed from a previous borrow: (src1 < src2)  */

#if TARGET_LONG_BITS == 64

    cc_src1_32 = tcg_temp_new_i32();

    cc_src2_32 = tcg_temp_new_i32();

    tcg_gen_trunc_i64_i32(cc_src1_32, cpu_cc_src);

    tcg_gen_trunc_i64_i32(cc_src2_32, cpu_cc_src2);

#else

    cc_src1_32 = cpu_cc_src;

    cc_src2_32 = cpu_cc_src2;

#endif

    carry_32 = tcg_temp_new_i32();

    tcg_gen_setcond_i32(TCG_COND_LTU, carry_32, cc_src1_32, cc_src2_32);

#if TARGET_LONG_BITS == 64

    tcg_temp_free_i32(cc_src1_32);

    tcg_temp_free_i32(cc_src2_32);

#endif

    return carry_32;

}

static void gen_op_addx_int(DisasContext *dc, TCGv dst, TCGv src1,

                            TCGv src2, int update_cc)

{

    TCGv_i32 carry_32;

    TCGv carry;

    switch (dc->cc_op) {

    case CC_OP_DIV:

    case CC_OP_LOGIC:

        /* Carry is known to be zero.  Fall back to plain ADD.  */

        if (update_cc) {

            gen_op_add_cc(dst, src1, src2);

        } else {

            tcg_gen_add_tl(dst, src1, src2);

        }

        return;

    case CC_OP_ADD:

    case CC_OP_TADD:

    case CC_OP_TADDTV:

#if TCG_TARGET_REG_BITS == 32 && TARGET_LONG_BITS == 32

        {

            /* For 32-bit hosts, we can re-use the host's hardware carry

               generation by using an ADD2 opcode.  We discard the low

               part of the output.  Ideally we'd combine this operation

               with the add that generated the carry in the first place.  */

            TCGv dst_low = tcg_temp_new();

            tcg_gen_op6_i32(INDEX_op_add2_i32, dst_low, dst,

                            cpu_cc_src, src1, cpu_cc_src2, src2);

            tcg_temp_free(dst_low);

            goto add_done;

        }

#endif

        carry_32 = gen_add32_carry32();

        break;

    case CC_OP_SUB:

    case CC_OP_TSUB:

    case CC_OP_TSUBTV:

        carry_32 = gen_sub32_carry32();

        break;

    default:

        /* We need external help to produce the carry.  */

        carry_32 = tcg_temp_new_i32();

        gen_helper_compute_C_icc(carry_32, cpu_env);

        break;

    }

#if TARGET_LONG_BITS == 64

    carry = tcg_temp_new();

    tcg_gen_extu_i32_i64(carry, carry_32);

#else

    carry = carry_32;

#endif

    tcg_gen_add_tl(dst, src1, src2);

    tcg_gen_add_tl(dst, dst, carry);

    tcg_temp_free_i32(carry_32);

#if TARGET_LONG_BITS == 64

    tcg_temp_free(carry);

#endif

#if TCG_TARGET_REG_BITS == 32 && TARGET_LONG_BITS == 32

 add_done:

#endif

    if (update_cc) {

        tcg_gen_mov_tl(cpu_cc_src, src1);

        tcg_gen_mov_tl(cpu_cc_src2, src2);

        tcg_gen_mov_tl(cpu_cc_dst, dst);

        tcg_gen_movi_i32(cpu_cc_op, CC_OP_ADDX);

        dc->cc_op = CC_OP_ADDX;

    }

}

static inline void gen_op_subi_cc(TCGv dst, TCGv src1, target_long src2, DisasContext *dc)

{

    tcg_gen_mov_tl(cpu_cc_src, src1);

    tcg_gen_movi_tl(cpu_cc_src2, src2);

    if (src2 == 0) {

        tcg_gen_mov_tl(cpu_cc_dst, src1);

        tcg_gen_movi_i32(cpu_cc_op, CC_OP_LOGIC);

        dc->cc_op = CC_OP_LOGIC;

    } else {

        tcg_gen_subi_tl(cpu_cc_dst, cpu_cc_src, src2);

        tcg_gen_movi_i32(cpu_cc_op, CC_OP_SUB);

        dc->cc_op = CC_OP_SUB;

    }

    tcg_gen_mov_tl(dst, cpu_cc_dst);

}

static inline void gen_op_sub_cc(TCGv dst, TCGv src1, TCGv src2)

{

    tcg_gen_mov_tl(cpu_cc_src, src1);

    tcg_gen_mov_tl(cpu_cc_src2, src2);

    tcg_gen_sub_tl(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);

    tcg_gen_mov_tl(dst, cpu_cc_dst);

}

static void gen_op_subx_int(DisasContext *dc, TCGv dst, TCGv src1,

                            TCGv src2, int update_cc)

{

    TCGv_i32 carry_32;

    TCGv carry;

    switch (dc->cc_op) {

    case CC_OP_DIV:

    case CC_OP_LOGIC:

        /* Carry is known to be zero.  Fall back to plain SUB.  */

        if (update_cc) {

            gen_op_sub_cc(dst, src1, src2);

        } else {

            tcg_gen_sub_tl(dst, src1, src2);

        }

        return;

    case CC_OP_ADD:

    case CC_OP_TADD:

    case CC_OP_TADDTV:

        carry_32 = gen_add32_carry32();

        break;

    case CC_OP_SUB:

    case CC_OP_TSUB:

    case CC_OP_TSUBTV:

#if TCG_TARGET_REG_BITS == 32 && TARGET_LONG_BITS == 32

        {

            /* For 32-bit hosts, we can re-use the host's hardware carry

               generation by using a SUB2 opcode.  We discard the low

               part of the output.  Ideally we'd combine this operation

               with the add that generated the carry in the first place.  */

            TCGv dst_low = tcg_temp_new();

            tcg_gen_op6_i32(INDEX_op_sub2_i32, dst_low, dst,

                            cpu_cc_src, src1, cpu_cc_src2, src2);

            tcg_temp_free(dst_low);

            goto sub_done;

        }

#endif

        carry_32 = gen_sub32_carry32();

        break;

    default:

        /* We need external help to produce the carry.  */

        carry_32 = tcg_temp_new_i32();

        gen_helper_compute_C_icc(carry_32, cpu_env);

        break;

    }

#if TARGET_LONG_BITS == 64

    carry = tcg_temp_new();

    tcg_gen_extu_i32_i64(carry, carry_32);

#else

    carry = carry_32;

#endif

    tcg_gen_sub_tl(dst, src1, src2);

    tcg_gen_sub_tl(dst, dst, carry);

    tcg_temp_free_i32(carry_32);

#if TARGET_LONG_BITS == 64

    tcg_temp_free(carry);

#endif

#if TCG_TARGET_REG_BITS == 32 && TARGET_LONG_BITS == 32

 sub_done:

#endif

    if (update_cc) {

        tcg_gen_mov_tl(cpu_cc_src, src1);

        tcg_gen_mov_tl(cpu_cc_src2, src2);

        tcg_gen_mov_tl(cpu_cc_dst, dst);

        tcg_gen_movi_i32(cpu_cc_op, CC_OP_SUBX);

        dc->cc_op = CC_OP_SUBX;

    }

}

static inline void gen_op_mulscc(TCGv dst, TCGv src1, TCGv src2)

{

    TCGv r_temp, zero, t0;

    r_temp = tcg_temp_new();

    t0 = tcg_temp_new();

    /* old op:

    if (!(env->y & 1))

        T1 = 0;

    */

    zero = tcg_const_tl(0);

    tcg_gen_andi_tl(cpu_cc_src, src1, 0xffffffff);

    tcg_gen_andi_tl(r_temp, cpu_y, 0x1);

    tcg_gen_andi_tl(cpu_cc_src2, src2, 0xffffffff);

    tcg_gen_movcond_tl(TCG_COND_EQ, cpu_cc_src2, r_temp, zero,

                       zero, cpu_cc_src2);

    tcg_temp_free(zero);

    // b2 = T0 & 1;

    // env->y = (b2 << 31) | (env->y >> 1);

    tcg_gen_andi_tl(r_temp, cpu_cc_src, 0x1);

    tcg_gen_shli_tl(r_temp, r_temp, 31);

    tcg_gen_shri_tl(t0, cpu_y, 1);

    tcg_gen_andi_tl(t0, t0, 0x7fffffff);

    tcg_gen_or_tl(t0, t0, r_temp);

    tcg_gen_andi_tl(cpu_y, t0, 0xffffffff);

    // b1 = N ^ V;

    gen_mov_reg_N(t0, cpu_psr);

    gen_mov_reg_V(r_temp, cpu_psr);

    tcg_gen_xor_tl(t0, t0, r_temp);

    tcg_temp_free(r_temp);

    // T0 = (b1 << 31) | (T0 >> 1);

    // src1 = T0;

    tcg_gen_shli_tl(t0, t0, 31);

    tcg_gen_shri_tl(cpu_cc_src, cpu_cc_src, 1);

    tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t0);

    tcg_temp_free(t0);

    tcg_gen_add_tl(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);

    tcg_gen_mov_tl(dst, cpu_cc_dst);

}

static inline void gen_op_multiply(TCGv dst, TCGv src1, TCGv src2, int sign_ext)

{

    TCGv_i32 r_src1, r_src2;

    TCGv_i64 r_temp, r_temp2;

    r_src1 = tcg_temp_new_i32();

    r_src2 = tcg_temp_new_i32();

    tcg_gen_trunc_tl_i32(r_src1, src1);

    tcg_gen_trunc_tl_i32(r_src2, src2);

    r_temp = tcg_temp_new_i64();

    r_temp2 = tcg_temp_new_i64();

    if (sign_ext) {

        tcg_gen_ext_i32_i64(r_temp, r_src2);

        tcg_gen_ext_i32_i64(r_temp2, r_src1);

    } else {

        tcg_gen_extu_i32_i64(r_temp, r_src2);

        tcg_gen_extu_i32_i64(r_temp2, r_src1);

    }

    tcg_gen_mul_i64(r_temp2, r_temp, r_temp2);

    tcg_gen_shri_i64(r_temp, r_temp2, 32);

    tcg_gen_trunc_i64_tl(cpu_y, r_temp);

    tcg_temp_free_i64(r_temp);

    tcg_gen_andi_tl(cpu_y, cpu_y, 0xffffffff);

    tcg_gen_trunc_i64_tl(dst, r_temp2);

    tcg_temp_free_i64(r_temp2);

    tcg_temp_free_i32(r_src1);

    tcg_temp_free_i32(r_src2);

}

static inline void gen_op_umul(TCGv dst, TCGv src1, TCGv src2)

{

    /* zero-extend truncated operands before multiplication */

    gen_op_multiply(dst, src1, src2, 0);

}

static inline void gen_op_smul(TCGv dst, TCGv src1, TCGv src2)

{

    /* sign-extend truncated operands before multiplication */

    gen_op_multiply(dst, src1, src2, 1);

}

// 1

static inline void gen_op_eval_ba(TCGv dst)

{

    tcg_gen_movi_tl(dst, 1);

}

// Z

static inline void gen_op_eval_be(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_Z(dst, src);

}

// Z | (N ^ V)

static inline void gen_op_eval_ble(TCGv dst, TCGv_i32 src)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_N(t0, src);

    gen_mov_reg_V(dst, src);

    tcg_gen_xor_tl(dst, dst, t0);

    gen_mov_reg_Z(t0, src);

    tcg_gen_or_tl(dst, dst, t0);

    tcg_temp_free(t0);

}

// N ^ V

static inline void gen_op_eval_bl(TCGv dst, TCGv_i32 src)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_V(t0, src);

    gen_mov_reg_N(dst, src);

    tcg_gen_xor_tl(dst, dst, t0);

    tcg_temp_free(t0);

}

// C | Z

static inline void gen_op_eval_bleu(TCGv dst, TCGv_i32 src)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_Z(t0, src);

    gen_mov_reg_C(dst, src);

    tcg_gen_or_tl(dst, dst, t0);

    tcg_temp_free(t0);

}

// C

static inline void gen_op_eval_bcs(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_C(dst, src);

}

// V

static inline void gen_op_eval_bvs(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_V(dst, src);

}

// 0

static inline void gen_op_eval_bn(TCGv dst)

{

    tcg_gen_movi_tl(dst, 0);

}

// N

static inline void gen_op_eval_bneg(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_N(dst, src);

}

// !Z

static inline void gen_op_eval_bne(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_Z(dst, src);

    tcg_gen_xori_tl(dst, dst, 0x1);

}

// !(Z | (N ^ V))

static inline void gen_op_eval_bg(TCGv dst, TCGv_i32 src)

{

    gen_op_eval_ble(dst, src);

    tcg_gen_xori_tl(dst, dst, 0x1);

}

// !(N ^ V)

static inline void gen_op_eval_bge(TCGv dst, TCGv_i32 src)

{

    gen_op_eval_bl(dst, src);

    tcg_gen_xori_tl(dst, dst, 0x1);

}

// !(C | Z)

static inline void gen_op_eval_bgu(TCGv dst, TCGv_i32 src)

{

    gen_op_eval_bleu(dst, src);

    tcg_gen_xori_tl(dst, dst, 0x1);

}

// !C

static inline void gen_op_eval_bcc(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_C(dst, src);

    tcg_gen_xori_tl(dst, dst, 0x1);

}

// !N

static inline void gen_op_eval_bpos(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_N(dst, src);

    tcg_gen_xori_tl(dst, dst, 0x1);

}

// !V

static inline void gen_op_eval_bvc(TCGv dst, TCGv_i32 src)

{

    gen_mov_reg_V(dst, src);

    tcg_gen_xori_tl(dst, dst, 0x1);

}

/*

  FPSR bit field FCC1 | FCC0:

   0 =

   1 <

   2 >

   3 unordered

*/

static inline void gen_mov_reg_FCC0(TCGv reg, TCGv src,

                                    unsigned int fcc_offset)

{

    tcg_gen_shri_tl(reg, src, FSR_FCC0_SHIFT + fcc_offset);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_mov_reg_FCC1(TCGv reg, TCGv src,

                                    unsigned int fcc_offset)

{

    tcg_gen_shri_tl(reg, src, FSR_FCC1_SHIFT + fcc_offset);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

// !0: FCC0 | FCC1

static inline void gen_op_eval_fbne(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_FCC0(dst, src, fcc_offset);

    gen_mov_reg_FCC1(t0, src, fcc_offset);

    tcg_gen_or_tl(dst, dst, t0);

    tcg_temp_free(t0);

}

// 1 or 2: FCC0 ^ FCC1

static inline void gen_op_eval_fblg(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_FCC0(dst, src, fcc_offset);

    gen_mov_reg_FCC1(t0, src, fcc_offset);

    tcg_gen_xor_tl(dst, dst, t0);

    tcg_temp_free(t0);

}

// 1 or 3: FCC0

static inline void gen_op_eval_fbul(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)

{

    gen_mov_reg_FCC0(dst, src, fcc_offset);

}

// 1: FCC0 & !FCC1

static inline void gen_op_eval_fbl(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_FCC0(dst, src, fcc_offset);

    gen_mov_reg_FCC1(t0, src, fcc_offset);

    tcg_gen_andc_tl(dst, dst, t0);

    tcg_temp_free(t0);

}

// 2 or 3: FCC1

static inline void gen_op_eval_fbug(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)

{

    gen_mov_reg_FCC1(dst, src, fcc_offset);

}

// 2: !FCC0 & FCC1

static inline void gen_op_eval_fbg(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_FCC0(dst, src, fcc_offset);

    gen_mov_reg_FCC1(t0, src, fcc_offset);

    tcg_gen_andc_tl(dst, t0, dst);

    tcg_temp_free(t0);

}

// 3: FCC0 & FCC1

static inline void gen_op_eval_fbu(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)

{

    TCGv t0 = tcg_temp_new();

    gen_mov_reg_FCC0(dst, src, fcc_offset);

    gen_mov_reg_FCC1(t0, src, fcc_offset);

    tcg_gen_and_tl(dst, dst, t0);

    tcg_temp_free(t0);

}

// 0: !(FCC0 | FCC1)

static inline void gen_op_eval_fbe(TCGv dst, TCGv src,

                                    unsigned int fcc_offset)