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, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

/*

   TODO-list:

   Rest of V9 instructions, VIS instructions

   NPC/PC static optimisations (use JUMP_TB when possible)

   Optimize synthetic instructions

*/

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <inttypes.h>

#include "cpu.h"

#include "exec-all.h"

#include "disas.h"

#include "helper.h"

#include "tcg-op.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 cpu_env, cpu_T[3], cpu_regwptr, cpu_cc_src, cpu_cc_src2, cpu_cc_dst;

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

#ifdef TARGET_SPARC64

static TCGv cpu_xcc;

#endif

/* local register indexes (only used inside old micro ops) */

static TCGv cpu_tmp0;

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;

    struct TranslationBlock *tb;

} DisasContext;

typedef struct sparc_def_t sparc_def_t;

struct sparc_def_t {

    const unsigned char *name;

    target_ulong iu_version;

    uint32_t fpu_version;

    uint32_t mmu_version;

    uint32_t mmu_bm;

    uint32_t mmu_ctpr_mask;

    uint32_t mmu_cxr_mask;

    uint32_t mmu_sfsr_mask;

    uint32_t mmu_trcr_mask;

};

static const sparc_def_t *cpu_sparc_find_by_name(const unsigned char *name);

extern FILE *logfile;

extern int loglevel;

// 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 FFPREG(r) (r)

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

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

#else

#define FFPREG(r) (r)

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

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

#endif

static int sign_extend(int x, int len)

{

    len = 32 - len;

    return (x << len) >> len;

}

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

static void disas_sparc_insn(DisasContext * dc);

/* floating point registers moves */

static void gen_op_load_fpr_FT0(unsigned int src)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, ft0));

}

static void gen_op_load_fpr_FT1(unsigned int src)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, ft1));

}

static void gen_op_store_FT0_fpr(unsigned int dst)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, ft0));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[dst]));

}

static void gen_op_load_fpr_DT0(unsigned int src)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, dt0) + offsetof(CPU_DoubleU, l.upper));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, dt0) + offsetof(CPU_DoubleU, l.lower));

}

static void gen_op_load_fpr_DT1(unsigned int src)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, dt1) + offsetof(CPU_DoubleU, l.upper));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, dt1) + offsetof(CPU_DoubleU, l.lower));

}

static void gen_op_store_DT0_fpr(unsigned int dst)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, dt0) + offsetof(CPU_DoubleU, l.upper));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[dst]));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, dt0) + offsetof(CPU_DoubleU, l.lower));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[dst + 1]));

}

#ifdef CONFIG_USER_ONLY

static void gen_op_load_fpr_QT0(unsigned int src)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.upmost));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.upper));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 2]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.lower));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 3]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.lowest));

}

static void gen_op_load_fpr_QT1(unsigned int src)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt1) + offsetof(CPU_QuadU, l.upmost));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt1) + offsetof(CPU_QuadU, l.upper));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 2]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt1) + offsetof(CPU_QuadU, l.lower));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[src + 3]));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt1) + offsetof(CPU_QuadU, l.lowest));

}

static void gen_op_store_QT0_fpr(unsigned int dst)

{

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.upmost));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[dst]));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.upper));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[dst + 1]));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.lower));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[dst + 2]));

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, qt0) + offsetof(CPU_QuadU, l.lowest));

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, fpr[dst + 3]));

}

#endif

/* moves */

#ifdef CONFIG_USER_ONLY

#define supervisor(dc) 0

#ifdef TARGET_SPARC64

#define hypervisor(dc) 0

#endif

#define gen_op_ldst(name)        gen_op_##name##_raw()

#else

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

#ifdef TARGET_SPARC64

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

#define OP_LD_TABLE(width)                                              \

    static GenOpFunc * const gen_op_##width[] = {                       \

        &gen_op_##width##_user,                                         \

        &gen_op_##width##_kernel,                                       \

        &gen_op_##width##_hypv,                                         \

    };

#else

#define OP_LD_TABLE(width)                                              \

    static GenOpFunc * const gen_op_##width[] = {                       \

        &gen_op_##width##_user,                                         \

        &gen_op_##width##_kernel,                                       \

    };

#endif

#define gen_op_ldst(name)        (*gen_op_##name[dc->mem_idx])()

#endif

#ifndef CONFIG_USER_ONLY

#ifdef __i386__

OP_LD_TABLE(std);

#endif /* __i386__ */

OP_LD_TABLE(stf);

OP_LD_TABLE(stdf);

OP_LD_TABLE(ldf);

OP_LD_TABLE(lddf);

#endif

#ifdef TARGET_ABI32

#define ABI32_MASK(addr) tcg_gen_andi_i64(addr, addr, 0xffffffffULL);

#else

#define ABI32_MASK(addr)

#endif

static inline void gen_movl_simm_T1(int32_t val)

{

    tcg_gen_movi_tl(cpu_T[1], val);

}

static inline void gen_movl_reg_TN(int reg, TCGv tn)

{

    if (reg == 0)

        tcg_gen_movi_tl(tn, 0);

    else if (reg < 8)

        tcg_gen_mov_tl(tn, cpu_gregs[reg]);

    else {

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

    }

}

static inline void gen_movl_reg_T0(int reg)

{

    gen_movl_reg_TN(reg, cpu_T[0]);

}

static inline void gen_movl_reg_T1(int reg)

{

    gen_movl_reg_TN(reg, cpu_T[1]);

}

#ifdef __i386__

static inline void gen_movl_reg_T2(int reg)

{

    gen_movl_reg_TN(reg, cpu_T[2]);

}

#endif /* __i386__ */

static inline void gen_movl_TN_reg(int reg, TCGv tn)

{

    if (reg == 0)

        return;

    else if (reg < 8)

        tcg_gen_mov_tl(cpu_gregs[reg], tn);

    else {

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

    }

}

static inline void gen_movl_T0_reg(int reg)

{

    gen_movl_TN_reg(reg, cpu_T[0]);

}

static inline void gen_movl_T1_reg(int reg)

{

    gen_movl_TN_reg(reg, cpu_T[1]);

}

static inline void gen_op_movl_T0_env(size_t offset)

{

    tcg_gen_ld_i32(cpu_T[0], cpu_env, offset);

}

static inline void gen_op_movl_env_T0(size_t offset)

{

    tcg_gen_st_i32(cpu_T[0], cpu_env, offset);

}

static inline void gen_op_movtl_T0_env(size_t offset)

{

    tcg_gen_ld_tl(cpu_T[0], cpu_env, offset);

}

static inline void gen_op_movtl_env_T0(size_t offset)

{

    tcg_gen_st_tl(cpu_T[0], cpu_env, offset);

}

static inline void gen_op_add_T1_T0(void)

{

    tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

}

static inline void gen_op_or_T1_T0(void)

{

    tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

}

static inline void gen_op_xor_T1_T0(void)

{

    tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

}

static inline void gen_jmp_im(target_ulong pc)

{

    tcg_gen_movi_tl(cpu_pc, pc);

}

static inline void gen_movl_npc_im(target_ulong npc)

{

    tcg_gen_movi_tl(cpu_npc, npc);

}

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))  {

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

        tcg_gen_goto_tb(tb_num);

        gen_jmp_im(pc);

        gen_movl_npc_im(npc);

        tcg_gen_exit_tb((long)tb + tb_num);

    } else {

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

        gen_jmp_im(pc);

        gen_movl_npc_im(npc);

        tcg_gen_exit_tb(0);

    }

}

// XXX suboptimal

static inline void gen_mov_reg_N(TCGv reg, TCGv src)

{

    tcg_gen_shri_i32(reg, src, 23);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_mov_reg_Z(TCGv reg, TCGv src)

{

    tcg_gen_shri_i32(reg, src, 22);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_mov_reg_V(TCGv reg, TCGv src)

{

    tcg_gen_shri_i32(reg, src, 21);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_mov_reg_C(TCGv reg, TCGv src)

{

    tcg_gen_shri_i32(reg, src, 20);

    tcg_gen_andi_tl(reg, reg, 0x1);

}

static inline void gen_op_exception(int exception)

{

    tcg_gen_movi_i32(cpu_tmp0, exception);

    tcg_gen_helper_0_1(raise_exception, cpu_tmp0);

}

static inline void gen_cc_clear(void)

{

    tcg_gen_movi_i32(cpu_psr, 0);

#ifdef TARGET_SPARC64

    tcg_gen_movi_i32(cpu_xcc, 0);

#endif

}

/* old op:

    if (!T0)

        env->psr |= PSR_ZERO;

    if ((int32_t) T0 < 0)

        env->psr |= PSR_NEG;

*/

static inline void gen_cc_NZ(TCGv dst)

{

    int l1, l2;

    l1 = gen_new_label();

    l2 = gen_new_label();

    tcg_gen_brcond_i32(TCG_COND_NE, dst, tcg_const_i32(0), l1);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_ZERO);

    gen_set_label(l1);

    tcg_gen_brcond_i32(TCG_COND_GE, dst, tcg_const_i32(0), l2);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_NEG);

    gen_set_label(l2);

#ifdef TARGET_SPARC64

    {

        int l3, l4;

        l3 = gen_new_label();

        l4 = gen_new_label();

        tcg_gen_brcond_tl(TCG_COND_NE, dst, tcg_const_tl(0), l3);

        tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_ZERO);

        gen_set_label(l3);

        tcg_gen_brcond_tl(TCG_COND_GE, dst, tcg_const_tl(0), l4);

        tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_NEG);

        gen_set_label(l4);

    }

#endif

}

/* old op:

    if (T0 < src1)

        env->psr |= PSR_CARRY;

*/

static inline void gen_cc_C_add(TCGv dst, TCGv src1)

{

    int l1;

    l1 = gen_new_label();

    tcg_gen_brcond_i32(TCG_COND_GEU, dst, src1, l1);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_CARRY);

    gen_set_label(l1);

#ifdef TARGET_SPARC64

    {

        int l2;

        l2 = gen_new_label();

        tcg_gen_brcond_tl(TCG_COND_GEU, dst, src1, l2);

        tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_CARRY);

        gen_set_label(l2);

    }

#endif

}

/* old op:

    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))

        env->psr |= PSR_OVF;

*/

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

{

    TCGv r_temp;

    int l1;

    l1 = gen_new_label();

    r_temp = tcg_temp_new(TCG_TYPE_TL);

    tcg_gen_xor_tl(r_temp, src1, src2);

    tcg_gen_xori_tl(r_temp, r_temp, -1);

    tcg_gen_xor_tl(cpu_tmp0, src1, dst);

    tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

    tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));

    tcg_gen_brcond_i32(TCG_COND_EQ, r_temp, tcg_const_i32(0), l1);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_OVF);

    gen_set_label(l1);

#ifdef TARGET_SPARC64

    {

        int l2;

        l2 = gen_new_label();

        tcg_gen_xor_tl(r_temp, src1, src2);

        tcg_gen_xori_tl(r_temp, r_temp, -1);

        tcg_gen_xor_tl(cpu_tmp0, src1, dst);

        tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

        tcg_gen_andi_tl(r_temp, r_temp, (1ULL << 63));

        tcg_gen_brcond_tl(TCG_COND_EQ, r_temp, tcg_const_tl(0), l2);

        tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_OVF);

        gen_set_label(l2);

    }

#endif

    tcg_gen_discard_tl(r_temp);

}

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

{

    TCGv r_temp;

    int l1;

    l1 = gen_new_label();

    r_temp = tcg_temp_new(TCG_TYPE_TL);

    tcg_gen_xor_tl(r_temp, src1, src2);

    tcg_gen_xori_tl(r_temp, r_temp, -1);

    tcg_gen_xor_tl(cpu_tmp0, src1, dst);

    tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

    tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));

    tcg_gen_brcond_i32(TCG_COND_EQ, r_temp, tcg_const_i32(0), l1);

    gen_op_exception(TT_TOVF);

    gen_set_label(l1);

#ifdef TARGET_SPARC64

    {

        int l2;

        l2 = gen_new_label();

        tcg_gen_xor_tl(r_temp, src1, src2);

        tcg_gen_xori_tl(r_temp, r_temp, -1);

        tcg_gen_xor_tl(cpu_tmp0, src1, dst);

        tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

        tcg_gen_andi_tl(r_temp, r_temp, (1ULL << 63));

        tcg_gen_brcond_tl(TCG_COND_EQ, r_temp, tcg_const_tl(0), l2);

        gen_op_exception(TT_TOVF);

        gen_set_label(l2);

    }

#endif

    tcg_gen_discard_tl(r_temp);

}

static inline void gen_cc_V_tag(TCGv src1, TCGv src2)

{

    int l1;

    l1 = gen_new_label();

    tcg_gen_or_tl(cpu_tmp0, src1, src2);

    tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, 0x3);

    tcg_gen_brcond_tl(TCG_COND_EQ, cpu_tmp0, tcg_const_tl(0), l1);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_OVF);

    gen_set_label(l1);

}

static inline void gen_tag_tv(TCGv src1, TCGv src2)

{

    int l1;

    l1 = gen_new_label();

    tcg_gen_or_tl(cpu_tmp0, src1, src2);

    tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, 0x3);

    tcg_gen_brcond_tl(TCG_COND_EQ, cpu_tmp0, tcg_const_tl(0), l1);

    gen_op_exception(TT_TOVF);

    gen_set_label(l1);

}

static inline void gen_op_add_T1_T0_cc(void)

{

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    gen_cc_C_add(cpu_T[0], cpu_cc_src);

    gen_cc_V_add(cpu_T[0], cpu_cc_src, cpu_T[1]);

}

static inline void gen_op_addx_T1_T0_cc(void)

{

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    gen_mov_reg_C(cpu_tmp0, cpu_psr);

    tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_tmp0);

    gen_cc_clear();

    gen_cc_C_add(cpu_T[0], cpu_cc_src);

    tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_cc_C_add(cpu_T[0], cpu_cc_src);

    gen_cc_NZ(cpu_T[0]);

    gen_cc_V_add(cpu_T[0], cpu_cc_src, cpu_T[1]);

}

static inline void gen_op_tadd_T1_T0_cc(void)

{

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    gen_cc_C_add(cpu_T[0], cpu_cc_src);

    gen_cc_V_add(cpu_T[0], cpu_cc_src, cpu_T[1]);

    gen_cc_V_tag(cpu_cc_src, cpu_T[1]);

}

static inline void gen_op_tadd_T1_T0_ccTV(void)

{

    gen_tag_tv(cpu_T[0], cpu_T[1]);

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_add_tv(cpu_T[0], cpu_cc_src, cpu_T[1]);

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    gen_cc_C_add(cpu_T[0], cpu_cc_src);

}

/* old op:

    if (src1 < T1)

        env->psr |= PSR_CARRY;

*/

static inline void gen_cc_C_sub(TCGv src1, TCGv src2)

{

    int l1;

    l1 = gen_new_label();

    tcg_gen_brcond_i32(TCG_COND_GEU, src1, src2, l1);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_CARRY);

    gen_set_label(l1);

#ifdef TARGET_SPARC64

    {

        int l2;

        l2 = gen_new_label();

        tcg_gen_brcond_tl(TCG_COND_GEU, src1, src2, l2);

        tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_CARRY);

        gen_set_label(l2);

    }

#endif

}

/* old op:

    if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))

        env->psr |= PSR_OVF;

*/

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

{

    TCGv r_temp;

    int l1;

    l1 = gen_new_label();

    r_temp = tcg_temp_new(TCG_TYPE_TL);

    tcg_gen_xor_tl(r_temp, src1, src2);

    tcg_gen_xor_tl(cpu_tmp0, src1, dst);

    tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

    tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));

    tcg_gen_brcond_i32(TCG_COND_EQ, r_temp, tcg_const_i32(0), l1);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_OVF);

    gen_set_label(l1);

#ifdef TARGET_SPARC64

    {

        int l2;

        l2 = gen_new_label();

        tcg_gen_xor_tl(r_temp, src1, src2);

        tcg_gen_xor_tl(cpu_tmp0, src1, dst);

        tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

        tcg_gen_andi_tl(r_temp, r_temp, (1ULL << 63));

        tcg_gen_brcond_tl(TCG_COND_EQ, r_temp, tcg_const_tl(0), l2);

        tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_OVF);

        gen_set_label(l2);

    }

#endif

    tcg_gen_discard_tl(r_temp);

}

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

{

    TCGv r_temp;

    int l1;

    l1 = gen_new_label();

    r_temp = tcg_temp_new(TCG_TYPE_TL);

    tcg_gen_xor_tl(r_temp, src1, src2);

    tcg_gen_xor_tl(cpu_tmp0, src1, dst);

    tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

    tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));

    tcg_gen_brcond_i32(TCG_COND_EQ, r_temp, tcg_const_i32(0), l1);

    gen_op_exception(TT_TOVF);

    gen_set_label(l1);

#ifdef TARGET_SPARC64

    {

        int l2;

        l2 = gen_new_label();

        tcg_gen_xor_tl(r_temp, src1, src2);

        tcg_gen_xor_tl(cpu_tmp0, src1, dst);

        tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);

        tcg_gen_andi_tl(r_temp, r_temp, (1ULL << 63));

        tcg_gen_brcond_tl(TCG_COND_EQ, r_temp, tcg_const_tl(0), l2);

        gen_op_exception(TT_TOVF);

        gen_set_label(l2);

    }

#endif

    tcg_gen_discard_tl(r_temp);

}

static inline void gen_op_sub_T1_T0_cc(void)

{

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    gen_cc_C_sub(cpu_cc_src, cpu_T[1]);

    gen_cc_V_sub(cpu_T[0], cpu_cc_src, cpu_T[1]);

}

static inline void gen_op_subx_T1_T0_cc(void)

{

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    gen_mov_reg_C(cpu_tmp0, cpu_psr);

    tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_tmp0);

    gen_cc_clear();

    gen_cc_C_sub(cpu_T[0], cpu_cc_src);

    tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_cc_C_sub(cpu_T[0], cpu_cc_src);

    gen_cc_NZ(cpu_T[0]);

    gen_cc_V_sub(cpu_T[0], cpu_cc_src, cpu_T[1]);

}

static inline void gen_op_tsub_T1_T0_cc(void)

{

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    gen_cc_C_sub(cpu_cc_src, cpu_T[1]);

    gen_cc_V_sub(cpu_T[0], cpu_cc_src, cpu_T[1]);

    gen_cc_V_tag(cpu_cc_src, cpu_T[1]);

}

static inline void gen_op_tsub_T1_T0_ccTV(void)

{

    gen_tag_tv(cpu_T[0], cpu_T[1]);

    tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);

    tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_sub_tv(cpu_T[0], cpu_cc_src, cpu_T[1]);

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    gen_cc_C_sub(cpu_cc_src, cpu_T[1]);

}

static inline void gen_op_mulscc_T1_T0(void)

{

    TCGv r_temp;

    int l1, l2;

    l1 = gen_new_label();

    l2 = gen_new_label();

    r_temp = tcg_temp_new(TCG_TYPE_TL);

    /* old op:

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

        T1 = 0;

    */

    tcg_gen_ld_i32(r_temp, cpu_env, offsetof(CPUSPARCState, y));

    tcg_gen_andi_i32(r_temp, r_temp, 0x1);

    tcg_gen_brcond_i32(TCG_COND_EQ, r_temp, tcg_const_tl(0), l1);

    tcg_gen_mov_tl(cpu_cc_src2, cpu_T[1]);

    tcg_gen_br(l2);

    gen_set_label(l1);

    tcg_gen_movi_tl(cpu_cc_src2, 0);

    gen_set_label(l2);

    // b2 = T0 & 1;

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

    tcg_gen_shli_i32(r_temp, cpu_T[0], 31);

    tcg_gen_ld_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, y));

    tcg_gen_shri_i32(cpu_tmp0, cpu_tmp0, 1);

    tcg_gen_or_i32(cpu_tmp0, cpu_tmp0, r_temp);

    tcg_gen_st_i32(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, y));

    // b1 = N ^ V;

    gen_mov_reg_N(cpu_tmp0, cpu_psr);

    gen_mov_reg_V(r_temp, cpu_psr);

    tcg_gen_xor_tl(cpu_tmp0, cpu_tmp0, r_temp);

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

    // src1 = T0;

    tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, 31);

    tcg_gen_shri_tl(cpu_cc_src, cpu_T[0], 1);

    tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_tmp0);

    /* do addition and update flags */

    tcg_gen_add_tl(cpu_T[0], cpu_cc_src, cpu_cc_src2);

    tcg_gen_discard_tl(r_temp);

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    gen_cc_V_add(cpu_T[0], cpu_cc_src, cpu_cc_src2);

    gen_cc_C_add(cpu_T[0], cpu_cc_src);

}

static inline void gen_op_umul_T1_T0(void)

{

    TCGv r_temp, r_temp2;

    r_temp = tcg_temp_new(TCG_TYPE_I64);

    r_temp2 = tcg_temp_new(TCG_TYPE_I64);

    tcg_gen_extu_i32_i64(r_temp, cpu_T[1]);

    tcg_gen_extu_i32_i64(r_temp2, cpu_T[0]);

    tcg_gen_mul_i64(r_temp2, r_temp, r_temp2);

    tcg_gen_shri_i64(r_temp, r_temp2, 32);

    tcg_gen_trunc_i64_i32(r_temp, r_temp);

    tcg_gen_st_i32(r_temp, cpu_env, offsetof(CPUSPARCState, y));

#ifdef TARGET_SPARC64

    tcg_gen_mov_i64(cpu_T[0], r_temp2);

#else

    tcg_gen_trunc_i64_i32(cpu_T[0], r_temp2);

#endif

    tcg_gen_discard_i64(r_temp);

    tcg_gen_discard_i64(r_temp2);

}

static inline void gen_op_smul_T1_T0(void)

{

    TCGv r_temp, r_temp2;

    r_temp = tcg_temp_new(TCG_TYPE_I64);

    r_temp2 = tcg_temp_new(TCG_TYPE_I64);

    tcg_gen_ext_i32_i64(r_temp, cpu_T[1]);

    tcg_gen_ext_i32_i64(r_temp2, cpu_T[0]);

    tcg_gen_mul_i64(r_temp2, r_temp, r_temp2);

    tcg_gen_shri_i64(r_temp, r_temp2, 32);

    tcg_gen_trunc_i64_i32(r_temp, r_temp);

    tcg_gen_st_i32(r_temp, cpu_env, offsetof(CPUSPARCState, y));

#ifdef TARGET_SPARC64

    tcg_gen_mov_i64(cpu_T[0], r_temp2);

#else

    tcg_gen_trunc_i64_i32(cpu_T[0], r_temp2);

#endif

    tcg_gen_discard_i64(r_temp);

    tcg_gen_discard_i64(r_temp2);

}

static inline void gen_op_udiv_T1_T0(void)

{

    tcg_gen_helper_1_2(helper_udiv, cpu_T[0], cpu_T[0], cpu_T[1]);

}

static inline void gen_op_sdiv_T1_T0(void)

{

    tcg_gen_helper_1_2(helper_sdiv, cpu_T[0], cpu_T[0], cpu_T[1]);

}

#ifdef TARGET_SPARC64

static inline void gen_trap_ifdivzero_i64(TCGv divisor)

{

    int l1;

    l1 = gen_new_label();

    tcg_gen_brcond_i64(TCG_COND_NE, divisor, tcg_const_tl(0), l1);

    gen_op_exception(TT_DIV_ZERO);

    gen_set_label(l1);

}

static inline void gen_op_sdivx_T1_T0(void)

{

    int l1, l2;

    l1 = gen_new_label();

    l2 = gen_new_label();

    gen_trap_ifdivzero_i64(cpu_T[1]);

    tcg_gen_brcond_i64(TCG_COND_NE, cpu_T[0], tcg_const_i64(INT64_MIN), l1);

    tcg_gen_brcond_i64(TCG_COND_NE, cpu_T[1], tcg_const_i64(-1), l1);

    tcg_gen_movi_i64(cpu_T[0], INT64_MIN);

    tcg_gen_br(l2);

    gen_set_label(l1);

    tcg_gen_div_i64(cpu_T[0], cpu_T[0], cpu_T[1]);

    gen_set_label(l2);

}

#endif

static inline void gen_op_div_cc(void)

{

    int l1;

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

    l1 = gen_new_label();

    tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, cc_src2));

    tcg_gen_brcond_tl(TCG_COND_EQ, cpu_tmp0, tcg_const_tl(0), l1);

    tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_OVF);

    gen_set_label(l1);

}

static inline void gen_op_logic_T0_cc(void)

{

    gen_cc_clear();

    gen_cc_NZ(cpu_T[0]);

}

// 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 src)

{