static int decode_mips16_opc (CPUState *env, DisasContext *ctx,

                              int *is_branch)

{

    int rx, ry;

    int sa;

    int op, cnvt_op, op1, offset;

    int funct;

    int n_bytes;



    op = (ctx->opcode >> 11) & 0x1f;

    sa = (ctx->opcode >> 2) & 0x7;

    sa = sa == 0 ? 8 : sa;

    rx = xlat((ctx->opcode >> 8) & 0x7);

    cnvt_op = (ctx->opcode >> 5) & 0x7;

    ry = xlat((ctx->opcode >> 5) & 0x7);

    op1 = offset = ctx->opcode & 0x1f;



    n_bytes = 2;



    switch (op) {

    case M16_OPC_ADDIUSP:

        {

            int16_t imm = ((uint8_t) ctx->opcode) << 2;



            gen_arith_imm(env, ctx, OPC_ADDIU, rx, 29, imm);

        }

        break;

    case M16_OPC_ADDIUPC:

        gen_addiupc(ctx, rx, ((uint8_t) ctx->opcode) << 2, 0, 0);

        break;

    case M16_OPC_B:

        offset = (ctx->opcode & 0x7ff) << 1;

        offset = (int16_t)(offset << 4) >> 4;

        gen_compute_branch(ctx, OPC_BEQ, 2, 0, 0, offset);

        /* No delay slot, so just process as a normal instruction */

        break;

    case M16_OPC_JAL:

        offset = lduw_code(ctx->pc + 2);

        offset = (((ctx->opcode & 0x1f) << 21)

                  | ((ctx->opcode >> 5) & 0x1f) << 16

                  | offset) << 2;

        op = ((ctx->opcode >> 10) & 0x1) ? OPC_JALX : OPC_JAL;

        gen_compute_branch(ctx, op, 4, rx, ry, offset);

        n_bytes = 4;

        *is_branch = 1;

        break;

    case M16_OPC_BEQZ:

        gen_compute_branch(ctx, OPC_BEQ, 2, rx, 0, ((int8_t)ctx->opcode) << 1);

        /* No delay slot, so just process as a normal instruction */

        break;

    case M16_OPC_BNEQZ:

        gen_compute_branch(ctx, OPC_BNE, 2, rx, 0, ((int8_t)ctx->opcode) << 1);

        /* No delay slot, so just process as a normal instruction */

        break;

    case M16_OPC_SHIFT:

        switch (ctx->opcode & 0x3) {

        case 0x0:

            gen_shift_imm(env, ctx, OPC_SLL, rx, ry, sa);

            break;

        case 0x1:

#if defined(TARGET_MIPS64)

            check_mips_64(ctx);

            gen_shift_imm(env, ctx, OPC_DSLL, rx, ry, sa);

#else

            generate_exception(ctx, EXCP_RI);

#endif

            break;

        case 0x2:

            gen_shift_imm(env, ctx, OPC_SRL, rx, ry, sa);

            break;

        case 0x3:

            gen_shift_imm(env, ctx, OPC_SRA, rx, ry, sa);

            break;

        }

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_LD:

        check_mips_64(ctx);

        gen_ldst(ctx, OPC_LD, ry, rx, offset << 3);

        break;

#endif

    case M16_OPC_RRIA:

        {

            int16_t imm = (int8_t)((ctx->opcode & 0xf) << 4) >> 4;



            if ((ctx->opcode >> 4) & 1) {

#if defined(TARGET_MIPS64)

                check_mips_64(ctx);

                gen_arith_imm(env, ctx, OPC_DADDIU, ry, rx, imm);

#else

                generate_exception(ctx, EXCP_RI);

#endif

            } else {

                gen_arith_imm(env, ctx, OPC_ADDIU, ry, rx, imm);

            }

        }

        break;

    case M16_OPC_ADDIU8:

        {

            int16_t imm = (int8_t) ctx->opcode;



            gen_arith_imm(env, ctx, OPC_ADDIU, rx, rx, imm);

        }

        break;

    case M16_OPC_SLTI:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_slt_imm(env, OPC_SLTI, 24, rx, imm);

        }

        break;

    case M16_OPC_SLTIU:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_slt_imm(env, OPC_SLTIU, 24, rx, imm);

        }

        break;

    case M16_OPC_I8:

        {

            int reg32;



            funct = (ctx->opcode >> 8) & 0x7;

            switch (funct) {

            case I8_BTEQZ:

                gen_compute_branch(ctx, OPC_BEQ, 2, 24, 0,

                                   ((int8_t)ctx->opcode) << 1);

                break;

            case I8_BTNEZ:

                gen_compute_branch(ctx, OPC_BNE, 2, 24, 0,

                                   ((int8_t)ctx->opcode) << 1);

                break;

            case I8_SWRASP:

                gen_ldst(ctx, OPC_SW, 31, 29, (ctx->opcode & 0xff) << 2);

                break;

            case I8_ADJSP:

                gen_arith_imm(env, ctx, OPC_ADDIU, 29, 29,

                              ((int8_t)ctx->opcode) << 3);

                break;

            case I8_SVRS:

                {

                    int do_ra = ctx->opcode & (1 << 6);

                    int do_s0 = ctx->opcode & (1 << 5);

                    int do_s1 = ctx->opcode & (1 << 4);

                    int framesize = ctx->opcode & 0xf;



                    if (framesize == 0) {

                        framesize = 128;

                    } else {

                        framesize = framesize << 3;

                    }



                    if (ctx->opcode & (1 << 7)) {

                        gen_mips16_save(ctx, 0, 0,

                                        do_ra, do_s0, do_s1, framesize);

                    } else {

                        gen_mips16_restore(ctx, 0, 0,

                                           do_ra, do_s0, do_s1, framesize);

                    }

                }

                break;

            case I8_MOV32R:

                {

                    int rz = xlat(ctx->opcode & 0x7);



                    reg32 = (((ctx->opcode >> 3) & 0x3) << 3) |

                        ((ctx->opcode >> 5) & 0x7);

                    gen_arith(env, ctx, OPC_ADDU, reg32, rz, 0);

                }

                break;

            case I8_MOVR32:

                reg32 = ctx->opcode & 0x1f;

                gen_arith(env, ctx, OPC_ADDU, ry, reg32, 0);

                break;

            default:

                generate_exception(ctx, EXCP_RI);

                break;

            }

        }

        break;

    case M16_OPC_LI:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_arith_imm(env, ctx, OPC_ADDIU, rx, 0, imm);

        }

        break;

    case M16_OPC_CMPI:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_logic_imm(env, OPC_XORI, 24, rx, imm);

        }

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_SD:

        check_mips_64(ctx);

        gen_ldst(ctx, OPC_SD, ry, rx, offset << 3);

        break;

#endif

    case M16_OPC_LB:

        gen_ldst(ctx, OPC_LB, ry, rx, offset);

        break;

    case M16_OPC_LH:

        gen_ldst(ctx, OPC_LH, ry, rx, offset << 1);

        break;

    case M16_OPC_LWSP:

        gen_ldst(ctx, OPC_LW, rx, 29, ((uint8_t)ctx->opcode) << 2);

        break;

    case M16_OPC_LW:

        gen_ldst(ctx, OPC_LW, ry, rx, offset << 2);

        break;

    case M16_OPC_LBU:

        gen_ldst(ctx, OPC_LBU, ry, rx, offset);

        break;

    case M16_OPC_LHU:

        gen_ldst(ctx, OPC_LHU, ry, rx, offset << 1);

        break;

    case M16_OPC_LWPC:

        gen_ldst(ctx, OPC_LWPC, rx, 0, ((uint8_t)ctx->opcode) << 2);

        break;

#if defined (TARGET_MIPS64)

    case M16_OPC_LWU:

        check_mips_64(ctx);

        gen_ldst(ctx, OPC_LWU, ry, rx, offset << 2);

        break;

#endif

    case M16_OPC_SB:

        gen_ldst(ctx, OPC_SB, ry, rx, offset);

        break;

    case M16_OPC_SH:

        gen_ldst(ctx, OPC_SH, ry, rx, offset << 1);

        break;

    case M16_OPC_SWSP:

        gen_ldst(ctx, OPC_SW, rx, 29, ((uint8_t)ctx->opcode) << 2);

        break;

    case M16_OPC_SW:

        gen_ldst(ctx, OPC_SW, ry, rx, offset << 2);

        break;

    case M16_OPC_RRR:

        {

            int rz = xlat((ctx->opcode >> 2) & 0x7);

            int mips32_op;



            switch (ctx->opcode & 0x3) {

            case RRR_ADDU:

                mips32_op = OPC_ADDU;

                break;

            case RRR_SUBU:

                mips32_op = OPC_SUBU;

                break;

#if defined(TARGET_MIPS64)

            case RRR_DADDU:

                mips32_op = OPC_DADDU;

                check_mips_64(ctx);

                break;

            case RRR_DSUBU:

                mips32_op = OPC_DSUBU;

                check_mips_64(ctx);

                break;

#endif

            default:

                generate_exception(ctx, EXCP_RI);

                goto done;

            }



            gen_arith(env, ctx, mips32_op, rz, rx, ry);

        done:

            ;

        }

        break;

    case M16_OPC_RR:

        switch (op1) {

        case RR_JR:

            {

                int nd = (ctx->opcode >> 7) & 0x1;

                int link = (ctx->opcode >> 6) & 0x1;

                int ra = (ctx->opcode >> 5) & 0x1;



                if (link) {

                    op = nd ? OPC_JALRC : OPC_JALR;

                } else {

                    op = OPC_JR;

                }



                gen_compute_branch(ctx, op, 2, ra ? 31 : rx, 31, 0);

                if (!nd) {

                    *is_branch = 1;

                }

            }

            break;

        case RR_SDBBP:

            /* XXX: not clear which exception should be raised

             *      when in debug mode...

             */

            check_insn(env, ctx, ISA_MIPS32);

            if (!(ctx->hflags & MIPS_HFLAG_DM)) {

                generate_exception(ctx, EXCP_DBp);

            } else {

                generate_exception(ctx, EXCP_DBp);

            }

            break;

        case RR_SLT:

            gen_slt(env, OPC_SLT, 24, rx, ry);

            break;

        case RR_SLTU:

            gen_slt(env, OPC_SLTU, 24, rx, ry);

            break;

        case RR_BREAK:

            generate_exception(ctx, EXCP_BREAK);

            break;

        case RR_SLLV:

            gen_shift(env, ctx, OPC_SLLV, ry, rx, ry);

            break;

        case RR_SRLV:

            gen_shift(env, ctx, OPC_SRLV, ry, rx, ry);

            break;

        case RR_SRAV:

            gen_shift(env, ctx, OPC_SRAV, ry, rx, ry);

            break;

#if defined (TARGET_MIPS64)

        case RR_DSRL:

            check_mips_64(ctx);

            gen_shift_imm(env, ctx, OPC_DSRL, ry, ry, sa);

            break;

#endif

        case RR_CMP:

            gen_logic(env, OPC_XOR, 24, rx, ry);

            break;

        case RR_NEG:

            gen_arith(env, ctx, OPC_SUBU, rx, 0, ry);

            break;

        case RR_AND:

            gen_logic(env, OPC_AND, rx, rx, ry);

            break;

        case RR_OR:

            gen_logic(env, OPC_OR, rx, rx, ry);

            break;

        case RR_XOR:

            gen_logic(env, OPC_XOR, rx, rx, ry);

            break;

        case RR_NOT:

            gen_logic(env, OPC_NOR, rx, ry, 0);

            break;

        case RR_MFHI:

            gen_HILO(ctx, OPC_MFHI, rx);

            break;

        case RR_CNVT:

            switch (cnvt_op) {

            case RR_RY_CNVT_ZEB:

                tcg_gen_ext8u_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_ZEH:

                tcg_gen_ext16u_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_SEB:

                tcg_gen_ext8s_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_SEH:

                tcg_gen_ext16s_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

#if defined (TARGET_MIPS64)

            case RR_RY_CNVT_ZEW:

                check_mips_64(ctx);

                tcg_gen_ext32u_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_SEW:

                check_mips_64(ctx);

                tcg_gen_ext32s_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

#endif

            default:

                generate_exception(ctx, EXCP_RI);

                break;

            }

            break;

        case RR_MFLO:

            gen_HILO(ctx, OPC_MFLO, rx);

            break;

#if defined (TARGET_MIPS64)

        case RR_DSRA:

            check_mips_64(ctx);

            gen_shift_imm(env, ctx, OPC_DSRA, ry, ry, sa);

            break;

        case RR_DSLLV:

            check_mips_64(ctx);

            gen_shift(env, ctx, OPC_DSLLV, ry, rx, ry);

            break;

        case RR_DSRLV:

            check_mips_64(ctx);

            gen_shift(env, ctx, OPC_DSRLV, ry, rx, ry);

            break;

        case RR_DSRAV:

            check_mips_64(ctx);

            gen_shift(env, ctx, OPC_DSRAV, ry, rx, ry);

            break;

#endif

        case RR_MULT:

            gen_muldiv(ctx, OPC_MULT, rx, ry);

            break;

        case RR_MULTU:

            gen_muldiv(ctx, OPC_MULTU, rx, ry);

            break;

        case RR_DIV:

            gen_muldiv(ctx, OPC_DIV, rx, ry);

            break;

        case RR_DIVU:

            gen_muldiv(ctx, OPC_DIVU, rx, ry);

            break;

#if defined (TARGET_MIPS64)

        case RR_DMULT:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DMULT, rx, ry);

            break;

        case RR_DMULTU:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DMULTU, rx, ry);

            break;

        case RR_DDIV:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DDIV, rx, ry);

            break;

        case RR_DDIVU:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DDIVU, rx, ry);

            break;

#endif

        default:

            generate_exception(ctx, EXCP_RI);

            break;

        }

        break;

    case M16_OPC_EXTEND:

        decode_extended_mips16_opc(env, ctx, is_branch);

        n_bytes = 4;

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_I64:

        funct = (ctx->opcode >> 8) & 0x7;

        decode_i64_mips16(env, ctx, ry, funct, offset, 0);

        break;

#endif

    default:

        generate_exception(ctx, EXCP_RI);

        break;

    }



    return n_bytes;

}

static int decode_mips16_opc (CPUState *env, DisasContext *ctx,

                              int *is_branch)

{

    int rx, ry;

    int sa;

    int op, cnvt_op, op1, offset;

    int funct;

    int n_bytes;



    op = (ctx->opcode >> 11) & 0x1f;

    sa = (ctx->opcode >> 2) & 0x7;

    sa = sa == 0 ? 8 : sa;

    rx = xlat((ctx->opcode >> 8) & 0x7);

    cnvt_op = (ctx->opcode >> 5) & 0x7;

    ry = xlat((ctx->opcode >> 5) & 0x7);

    op1 = offset = ctx->opcode & 0x1f;



    n_bytes = 2;



    switch (op) {

    case M16_OPC_ADDIUSP:

        {

            int16_t imm = ((uint8_t) ctx->opcode) << 2;



            gen_arith_imm(env, ctx, OPC_ADDIU, rx, 29, imm);

        }

        break;

    case M16_OPC_ADDIUPC:

        gen_addiupc(ctx, rx, ((uint8_t) ctx->opcode) << 2, 0, 0);

        break;

    case M16_OPC_B:

        offset = (ctx->opcode & 0x7ff) << 1;

        offset = (int16_t)(offset << 4) >> 4;

        gen_compute_branch(ctx, OPC_BEQ, 2, 0, 0, offset);

        

        break;

    case M16_OPC_JAL:

        offset = lduw_code(ctx->pc + 2);

        offset = (((ctx->opcode & 0x1f) << 21)

                  | ((ctx->opcode >> 5) & 0x1f) << 16

                  | offset) << 2;

        op = ((ctx->opcode >> 10) & 0x1) ? OPC_JALX : OPC_JAL;

        gen_compute_branch(ctx, op, 4, rx, ry, offset);

        n_bytes = 4;

        *is_branch = 1;

        break;

    case M16_OPC_BEQZ:

        gen_compute_branch(ctx, OPC_BEQ, 2, rx, 0, ((int8_t)ctx->opcode) << 1);

        

        break;

    case M16_OPC_BNEQZ:

        gen_compute_branch(ctx, OPC_BNE, 2, rx, 0, ((int8_t)ctx->opcode) << 1);

        

        break;

    case M16_OPC_SHIFT:

        switch (ctx->opcode & 0x3) {

        case 0x0:

            gen_shift_imm(env, ctx, OPC_SLL, rx, ry, sa);

            break;

        case 0x1:

#if defined(TARGET_MIPS64)

            check_mips_64(ctx);

            gen_shift_imm(env, ctx, OPC_DSLL, rx, ry, sa);

#else

            generate_exception(ctx, EXCP_RI);

#endif

            break;

        case 0x2:

            gen_shift_imm(env, ctx, OPC_SRL, rx, ry, sa);

            break;

        case 0x3:

            gen_shift_imm(env, ctx, OPC_SRA, rx, ry, sa);

            break;

        }

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_LD:

        check_mips_64(ctx);

        gen_ldst(ctx, OPC_LD, ry, rx, offset << 3);

        break;

#endif

    case M16_OPC_RRIA:

        {

            int16_t imm = (int8_t)((ctx->opcode & 0xf) << 4) >> 4;



            if ((ctx->opcode >> 4) & 1) {

#if defined(TARGET_MIPS64)

                check_mips_64(ctx);

                gen_arith_imm(env, ctx, OPC_DADDIU, ry, rx, imm);

#else

                generate_exception(ctx, EXCP_RI);

#endif

            } else {

                gen_arith_imm(env, ctx, OPC_ADDIU, ry, rx, imm);

            }

        }

        break;

    case M16_OPC_ADDIU8:

        {

            int16_t imm = (int8_t) ctx->opcode;



            gen_arith_imm(env, ctx, OPC_ADDIU, rx, rx, imm);

        }

        break;

    case M16_OPC_SLTI:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_slt_imm(env, OPC_SLTI, 24, rx, imm);

        }

        break;

    case M16_OPC_SLTIU:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_slt_imm(env, OPC_SLTIU, 24, rx, imm);

        }

        break;

    case M16_OPC_I8:

        {

            int reg32;



            funct = (ctx->opcode >> 8) & 0x7;

            switch (funct) {

            case I8_BTEQZ:

                gen_compute_branch(ctx, OPC_BEQ, 2, 24, 0,

                                   ((int8_t)ctx->opcode) << 1);

                break;

            case I8_BTNEZ:

                gen_compute_branch(ctx, OPC_BNE, 2, 24, 0,

                                   ((int8_t)ctx->opcode) << 1);

                break;

            case I8_SWRASP:

                gen_ldst(ctx, OPC_SW, 31, 29, (ctx->opcode & 0xff) << 2);

                break;

            case I8_ADJSP:

                gen_arith_imm(env, ctx, OPC_ADDIU, 29, 29,

                              ((int8_t)ctx->opcode) << 3);

                break;

            case I8_SVRS:

                {

                    int do_ra = ctx->opcode & (1 << 6);

                    int do_s0 = ctx->opcode & (1 << 5);

                    int do_s1 = ctx->opcode & (1 << 4);

                    int framesize = ctx->opcode & 0xf;



                    if (framesize == 0) {

                        framesize = 128;

                    } else {

                        framesize = framesize << 3;

                    }



                    if (ctx->opcode & (1 << 7)) {

                        gen_mips16_save(ctx, 0, 0,

                                        do_ra, do_s0, do_s1, framesize);

                    } else {

                        gen_mips16_restore(ctx, 0, 0,

                                           do_ra, do_s0, do_s1, framesize);

                    }

                }

                break;

            case I8_MOV32R:

                {

                    int rz = xlat(ctx->opcode & 0x7);



                    reg32 = (((ctx->opcode >> 3) & 0x3) << 3) |

                        ((ctx->opcode >> 5) & 0x7);

                    gen_arith(env, ctx, OPC_ADDU, reg32, rz, 0);

                }

                break;

            case I8_MOVR32:

                reg32 = ctx->opcode & 0x1f;

                gen_arith(env, ctx, OPC_ADDU, ry, reg32, 0);

                break;

            default:

                generate_exception(ctx, EXCP_RI);

                break;

            }

        }

        break;

    case M16_OPC_LI:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_arith_imm(env, ctx, OPC_ADDIU, rx, 0, imm);

        }

        break;

    case M16_OPC_CMPI:

        {

            int16_t imm = (uint8_t) ctx->opcode;



            gen_logic_imm(env, OPC_XORI, 24, rx, imm);

        }

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_SD:

        check_mips_64(ctx);

        gen_ldst(ctx, OPC_SD, ry, rx, offset << 3);

        break;

#endif

    case M16_OPC_LB:

        gen_ldst(ctx, OPC_LB, ry, rx, offset);

        break;

    case M16_OPC_LH:

        gen_ldst(ctx, OPC_LH, ry, rx, offset << 1);

        break;

    case M16_OPC_LWSP:

        gen_ldst(ctx, OPC_LW, rx, 29, ((uint8_t)ctx->opcode) << 2);

        break;

    case M16_OPC_LW:

        gen_ldst(ctx, OPC_LW, ry, rx, offset << 2);

        break;

    case M16_OPC_LBU:

        gen_ldst(ctx, OPC_LBU, ry, rx, offset);

        break;

    case M16_OPC_LHU:

        gen_ldst(ctx, OPC_LHU, ry, rx, offset << 1);

        break;

    case M16_OPC_LWPC:

        gen_ldst(ctx, OPC_LWPC, rx, 0, ((uint8_t)ctx->opcode) << 2);

        break;

#if defined (TARGET_MIPS64)

    case M16_OPC_LWU:

        check_mips_64(ctx);

        gen_ldst(ctx, OPC_LWU, ry, rx, offset << 2);

        break;

#endif

    case M16_OPC_SB:

        gen_ldst(ctx, OPC_SB, ry, rx, offset);

        break;

    case M16_OPC_SH:

        gen_ldst(ctx, OPC_SH, ry, rx, offset << 1);

        break;

    case M16_OPC_SWSP:

        gen_ldst(ctx, OPC_SW, rx, 29, ((uint8_t)ctx->opcode) << 2);

        break;

    case M16_OPC_SW:

        gen_ldst(ctx, OPC_SW, ry, rx, offset << 2);

        break;

    case M16_OPC_RRR:

        {

            int rz = xlat((ctx->opcode >> 2) & 0x7);

            int mips32_op;



            switch (ctx->opcode & 0x3) {

            case RRR_ADDU:

                mips32_op = OPC_ADDU;

                break;

            case RRR_SUBU:

                mips32_op = OPC_SUBU;

                break;

#if defined(TARGET_MIPS64)

            case RRR_DADDU:

                mips32_op = OPC_DADDU;

                check_mips_64(ctx);

                break;

            case RRR_DSUBU:

                mips32_op = OPC_DSUBU;

                check_mips_64(ctx);

                break;

#endif

            default:

                generate_exception(ctx, EXCP_RI);

                goto done;

            }



            gen_arith(env, ctx, mips32_op, rz, rx, ry);

        done:

            ;

        }

        break;

    case M16_OPC_RR:

        switch (op1) {

        case RR_JR:

            {

                int nd = (ctx->opcode >> 7) & 0x1;

                int link = (ctx->opcode >> 6) & 0x1;

                int ra = (ctx->opcode >> 5) & 0x1;



                if (link) {

                    op = nd ? OPC_JALRC : OPC_JALR;

                } else {

                    op = OPC_JR;

                }



                gen_compute_branch(ctx, op, 2, ra ? 31 : rx, 31, 0);

                if (!nd) {

                    *is_branch = 1;

                }

            }

            break;

        case RR_SDBBP:

            





            check_insn(env, ctx, ISA_MIPS32);

            if (!(ctx->hflags & MIPS_HFLAG_DM)) {

                generate_exception(ctx, EXCP_DBp);

            } else {

                generate_exception(ctx, EXCP_DBp);

            }

            break;

        case RR_SLT:

            gen_slt(env, OPC_SLT, 24, rx, ry);

            break;

        case RR_SLTU:

            gen_slt(env, OPC_SLTU, 24, rx, ry);

            break;

        case RR_BREAK:

            generate_exception(ctx, EXCP_BREAK);

            break;

        case RR_SLLV:

            gen_shift(env, ctx, OPC_SLLV, ry, rx, ry);

            break;

        case RR_SRLV:

            gen_shift(env, ctx, OPC_SRLV, ry, rx, ry);

            break;

        case RR_SRAV:

            gen_shift(env, ctx, OPC_SRAV, ry, rx, ry);

            break;

#if defined (TARGET_MIPS64)

        case RR_DSRL:

            check_mips_64(ctx);

            gen_shift_imm(env, ctx, OPC_DSRL, ry, ry, sa);

            break;

#endif

        case RR_CMP:

            gen_logic(env, OPC_XOR, 24, rx, ry);

            break;

        case RR_NEG:

            gen_arith(env, ctx, OPC_SUBU, rx, 0, ry);

            break;

        case RR_AND:

            gen_logic(env, OPC_AND, rx, rx, ry);

            break;

        case RR_OR:

            gen_logic(env, OPC_OR, rx, rx, ry);

            break;

        case RR_XOR:

            gen_logic(env, OPC_XOR, rx, rx, ry);

            break;

        case RR_NOT:

            gen_logic(env, OPC_NOR, rx, ry, 0);

            break;

        case RR_MFHI:

            gen_HILO(ctx, OPC_MFHI, rx);

            break;

        case RR_CNVT:

            switch (cnvt_op) {

            case RR_RY_CNVT_ZEB:

                tcg_gen_ext8u_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_ZEH:

                tcg_gen_ext16u_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_SEB:

                tcg_gen_ext8s_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_SEH:

                tcg_gen_ext16s_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

#if defined (TARGET_MIPS64)

            case RR_RY_CNVT_ZEW:

                check_mips_64(ctx);

                tcg_gen_ext32u_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

            case RR_RY_CNVT_SEW:

                check_mips_64(ctx);

                tcg_gen_ext32s_tl(cpu_gpr[rx], cpu_gpr[rx]);

                break;

#endif

            default:

                generate_exception(ctx, EXCP_RI);

                break;

            }

            break;

        case RR_MFLO:

            gen_HILO(ctx, OPC_MFLO, rx);

            break;

#if defined (TARGET_MIPS64)

        case RR_DSRA:

            check_mips_64(ctx);

            gen_shift_imm(env, ctx, OPC_DSRA, ry, ry, sa);

            break;

        case RR_DSLLV:

            check_mips_64(ctx);

            gen_shift(env, ctx, OPC_DSLLV, ry, rx, ry);

            break;

        case RR_DSRLV:

            check_mips_64(ctx);

            gen_shift(env, ctx, OPC_DSRLV, ry, rx, ry);

            break;

        case RR_DSRAV:

            check_mips_64(ctx);

            gen_shift(env, ctx, OPC_DSRAV, ry, rx, ry);

            break;

#endif

        case RR_MULT:

            gen_muldiv(ctx, OPC_MULT, rx, ry);

            break;

        case RR_MULTU:

            gen_muldiv(ctx, OPC_MULTU, rx, ry);

            break;

        case RR_DIV:

            gen_muldiv(ctx, OPC_DIV, rx, ry);

            break;

        case RR_DIVU:

            gen_muldiv(ctx, OPC_DIVU, rx, ry);

            break;

#if defined (TARGET_MIPS64)

        case RR_DMULT:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DMULT, rx, ry);

            break;

        case RR_DMULTU:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DMULTU, rx, ry);

            break;

        case RR_DDIV:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DDIV, rx, ry);

            break;

        case RR_DDIVU:

            check_mips_64(ctx);

            gen_muldiv(ctx, OPC_DDIVU, rx, ry);

            break;

#endif

        default:

            generate_exception(ctx, EXCP_RI);

            break;

        }

        break;

    case M16_OPC_EXTEND:

        decode_extended_mips16_opc(env, ctx, is_branch);

        n_bytes = 4;

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_I64:

        funct = (ctx->opcode >> 8) & 0x7;

        decode_i64_mips16(env, ctx, ry, funct, offset, 0);

        break;

#endif

    default:

        generate_exception(ctx, EXCP_RI);

        break;

    }



    return n_bytes;

}

static int FUNC_0 (CPUState *VAR_0, DisasContext *VAR_1,

                              int *VAR_2)

{

    int VAR_3, VAR_4;

    int VAR_5;

    int VAR_6, VAR_7, VAR_8, VAR_9;

    int VAR_10;

    int VAR_11;



    VAR_6 = (VAR_1->opcode >> 11) & 0x1f;

    VAR_5 = (VAR_1->opcode >> 2) & 0x7;

    VAR_5 = VAR_5 == 0 ? 8 : VAR_5;

    VAR_3 = xlat((VAR_1->opcode >> 8) & 0x7);

    VAR_7 = (VAR_1->opcode >> 5) & 0x7;

    VAR_4 = xlat((VAR_1->opcode >> 5) & 0x7);

    VAR_8 = VAR_9 = VAR_1->opcode & 0x1f;



    VAR_11 = 2;



    switch (VAR_6) {

    case M16_OPC_ADDIUSP:

        {

            int16_t imm = ((uint8_t) VAR_1->opcode) << 2;



            gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_3, 29, imm);

        }

        break;

    case M16_OPC_ADDIUPC:

        gen_addiupc(VAR_1, VAR_3, ((uint8_t) VAR_1->opcode) << 2, 0, 0);

        break;

    case M16_OPC_B:

        VAR_9 = (VAR_1->opcode & 0x7ff) << 1;

        VAR_9 = (int16_t)(VAR_9 << 4) >> 4;

        gen_compute_branch(VAR_1, OPC_BEQ, 2, 0, 0, VAR_9);

        

        break;

    case M16_OPC_JAL:

        VAR_9 = lduw_code(VAR_1->pc + 2);

        VAR_9 = (((VAR_1->opcode & 0x1f) << 21)

                  | ((VAR_1->opcode >> 5) & 0x1f) << 16

                  | VAR_9) << 2;

        VAR_6 = ((VAR_1->opcode >> 10) & 0x1) ? OPC_JALX : OPC_JAL;

        gen_compute_branch(VAR_1, VAR_6, 4, VAR_3, VAR_4, VAR_9);

        VAR_11 = 4;

        *VAR_2 = 1;

        break;

    case M16_OPC_BEQZ:

        gen_compute_branch(VAR_1, OPC_BEQ, 2, VAR_3, 0, ((int8_t)VAR_1->opcode) << 1);

        

        break;

    case M16_OPC_BNEQZ:

        gen_compute_branch(VAR_1, OPC_BNE, 2, VAR_3, 0, ((int8_t)VAR_1->opcode) << 1);

        

        break;

    case M16_OPC_SHIFT:

        switch (VAR_1->opcode & 0x3) {

        case 0x0:

            gen_shift_imm(VAR_0, VAR_1, OPC_SLL, VAR_3, VAR_4, VAR_5);

            break;

        case 0x1:

#if defined(TARGET_MIPS64)

            check_mips_64(VAR_1);

            gen_shift_imm(VAR_0, VAR_1, OPC_DSLL, VAR_3, VAR_4, VAR_5);

#else

            generate_exception(VAR_1, EXCP_RI);

#endif

            break;

        case 0x2:

            gen_shift_imm(VAR_0, VAR_1, OPC_SRL, VAR_3, VAR_4, VAR_5);

            break;

        case 0x3:

            gen_shift_imm(VAR_0, VAR_1, OPC_SRA, VAR_3, VAR_4, VAR_5);

            break;

        }

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_LD:

        check_mips_64(VAR_1);

        gen_ldst(VAR_1, OPC_LD, VAR_4, VAR_3, VAR_9 << 3);

        break;

#endif

    case M16_OPC_RRIA:

        {

            int16_t imm = (int8_t)((VAR_1->opcode & 0xf) << 4) >> 4;



            if ((VAR_1->opcode >> 4) & 1) {

#if defined(TARGET_MIPS64)

                check_mips_64(VAR_1);

                gen_arith_imm(VAR_0, VAR_1, OPC_DADDIU, VAR_4, VAR_3, imm);

#else

                generate_exception(VAR_1, EXCP_RI);

#endif

            } else {

                gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_4, VAR_3, imm);

            }

        }

        break;

    case M16_OPC_ADDIU8:

        {

            int16_t imm = (int8_t) VAR_1->opcode;



            gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_3, VAR_3, imm);

        }

        break;

    case M16_OPC_SLTI:

        {

            int16_t imm = (uint8_t) VAR_1->opcode;



            gen_slt_imm(VAR_0, OPC_SLTI, 24, VAR_3, imm);

        }

        break;

    case M16_OPC_SLTIU:

        {

            int16_t imm = (uint8_t) VAR_1->opcode;



            gen_slt_imm(VAR_0, OPC_SLTIU, 24, VAR_3, imm);

        }

        break;

    case M16_OPC_I8:

        {

            int VAR_12;



            VAR_10 = (VAR_1->opcode >> 8) & 0x7;

            switch (VAR_10) {

            case I8_BTEQZ:

                gen_compute_branch(VAR_1, OPC_BEQ, 2, 24, 0,

                                   ((int8_t)VAR_1->opcode) << 1);

                break;

            case I8_BTNEZ:

                gen_compute_branch(VAR_1, OPC_BNE, 2, 24, 0,

                                   ((int8_t)VAR_1->opcode) << 1);

                break;

            case I8_SWRASP:

                gen_ldst(VAR_1, OPC_SW, 31, 29, (VAR_1->opcode & 0xff) << 2);

                break;

            case I8_ADJSP:

                gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, 29, 29,

                              ((int8_t)VAR_1->opcode) << 3);

                break;

            case I8_SVRS:

                {

                    int VAR_13 = VAR_1->opcode & (1 << 6);

                    int VAR_14 = VAR_1->opcode & (1 << 5);

                    int VAR_15 = VAR_1->opcode & (1 << 4);

                    int VAR_16 = VAR_1->opcode & 0xf;



                    if (VAR_16 == 0) {

                        VAR_16 = 128;

                    } else {

                        VAR_16 = VAR_16 << 3;

                    }



                    if (VAR_1->opcode & (1 << 7)) {

                        gen_mips16_save(VAR_1, 0, 0,

                                        VAR_13, VAR_14, VAR_15, VAR_16);

                    } else {

                        gen_mips16_restore(VAR_1, 0, 0,

                                           VAR_13, VAR_14, VAR_15, VAR_16);

                    }

                }

                break;

            case I8_MOV32R:

                {

                    int VAR_18 = xlat(VAR_1->opcode & 0x7);



                    VAR_12 = (((VAR_1->opcode >> 3) & 0x3) << 3) |

                        ((VAR_1->opcode >> 5) & 0x7);

                    gen_arith(VAR_0, VAR_1, OPC_ADDU, VAR_12, VAR_18, 0);

                }

                break;

            case I8_MOVR32:

                VAR_12 = VAR_1->opcode & 0x1f;

                gen_arith(VAR_0, VAR_1, OPC_ADDU, VAR_4, VAR_12, 0);

                break;

            default:

                generate_exception(VAR_1, EXCP_RI);

                break;

            }

        }

        break;

    case M16_OPC_LI:

        {

            int16_t imm = (uint8_t) VAR_1->opcode;



            gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_3, 0, imm);

        }

        break;

    case M16_OPC_CMPI:

        {

            int16_t imm = (uint8_t) VAR_1->opcode;



            gen_logic_imm(VAR_0, OPC_XORI, 24, VAR_3, imm);

        }

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_SD:

        check_mips_64(VAR_1);

        gen_ldst(VAR_1, OPC_SD, VAR_4, VAR_3, VAR_9 << 3);

        break;

#endif

    case M16_OPC_LB:

        gen_ldst(VAR_1, OPC_LB, VAR_4, VAR_3, VAR_9);

        break;

    case M16_OPC_LH:

        gen_ldst(VAR_1, OPC_LH, VAR_4, VAR_3, VAR_9 << 1);

        break;

    case M16_OPC_LWSP:

        gen_ldst(VAR_1, OPC_LW, VAR_3, 29, ((uint8_t)VAR_1->opcode) << 2);

        break;

    case M16_OPC_LW:

        gen_ldst(VAR_1, OPC_LW, VAR_4, VAR_3, VAR_9 << 2);

        break;

    case M16_OPC_LBU:

        gen_ldst(VAR_1, OPC_LBU, VAR_4, VAR_3, VAR_9);

        break;

    case M16_OPC_LHU:

        gen_ldst(VAR_1, OPC_LHU, VAR_4, VAR_3, VAR_9 << 1);

        break;

    case M16_OPC_LWPC:

        gen_ldst(VAR_1, OPC_LWPC, VAR_3, 0, ((uint8_t)VAR_1->opcode) << 2);

        break;

#if defined (TARGET_MIPS64)

    case M16_OPC_LWU:

        check_mips_64(VAR_1);

        gen_ldst(VAR_1, OPC_LWU, VAR_4, VAR_3, VAR_9 << 2);

        break;

#endif

    case M16_OPC_SB:

        gen_ldst(VAR_1, OPC_SB, VAR_4, VAR_3, VAR_9);

        break;

    case M16_OPC_SH:

        gen_ldst(VAR_1, OPC_SH, VAR_4, VAR_3, VAR_9 << 1);

        break;

    case M16_OPC_SWSP:

        gen_ldst(VAR_1, OPC_SW, VAR_3, 29, ((uint8_t)VAR_1->opcode) << 2);

        break;

    case M16_OPC_SW:

        gen_ldst(VAR_1, OPC_SW, VAR_4, VAR_3, VAR_9 << 2);

        break;

    case M16_OPC_RRR:

        {

            int VAR_18 = xlat((VAR_1->opcode >> 2) & 0x7);

            int VAR_18;



            switch (VAR_1->opcode & 0x3) {

            case RRR_ADDU:

                VAR_18 = OPC_ADDU;

                break;

            case RRR_SUBU:

                VAR_18 = OPC_SUBU;

                break;

#if defined(TARGET_MIPS64)

            case RRR_DADDU:

                VAR_18 = OPC_DADDU;

                check_mips_64(VAR_1);

                break;

            case RRR_DSUBU:

                VAR_18 = OPC_DSUBU;

                check_mips_64(VAR_1);

                break;

#endif

            default:

                generate_exception(VAR_1, EXCP_RI);

                goto done;

            }



            gen_arith(VAR_0, VAR_1, VAR_18, VAR_18, VAR_3, VAR_4);

        done:

            ;

        }

        break;

    case M16_OPC_RR:

        switch (VAR_8) {

        case RR_JR:

            {

                int VAR_19 = (VAR_1->opcode >> 7) & 0x1;

                int VAR_20 = (VAR_1->opcode >> 6) & 0x1;

                int VAR_21 = (VAR_1->opcode >> 5) & 0x1;



                if (VAR_20) {

                    VAR_6 = VAR_19 ? OPC_JALRC : OPC_JALR;

                } else {

                    VAR_6 = OPC_JR;

                }



                gen_compute_branch(VAR_1, VAR_6, 2, VAR_21 ? 31 : VAR_3, 31, 0);

                if (!VAR_19) {

                    *VAR_2 = 1;

                }

            }

            break;

        case RR_SDBBP:

            





            check_insn(VAR_0, VAR_1, ISA_MIPS32);

            if (!(VAR_1->hflags & MIPS_HFLAG_DM)) {

                generate_exception(VAR_1, EXCP_DBp);

            } else {

                generate_exception(VAR_1, EXCP_DBp);

            }

            break;

        case RR_SLT:

            gen_slt(VAR_0, OPC_SLT, 24, VAR_3, VAR_4);

            break;

        case RR_SLTU:

            gen_slt(VAR_0, OPC_SLTU, 24, VAR_3, VAR_4);

            break;

        case RR_BREAK:

            generate_exception(VAR_1, EXCP_BREAK);

            break;

        case RR_SLLV:

            gen_shift(VAR_0, VAR_1, OPC_SLLV, VAR_4, VAR_3, VAR_4);

            break;

        case RR_SRLV:

            gen_shift(VAR_0, VAR_1, OPC_SRLV, VAR_4, VAR_3, VAR_4);

            break;

        case RR_SRAV:

            gen_shift(VAR_0, VAR_1, OPC_SRAV, VAR_4, VAR_3, VAR_4);

            break;

#if defined (TARGET_MIPS64)

        case RR_DSRL:

            check_mips_64(VAR_1);

            gen_shift_imm(VAR_0, VAR_1, OPC_DSRL, VAR_4, VAR_4, VAR_5);

            break;

#endif

        case RR_CMP:

            gen_logic(VAR_0, OPC_XOR, 24, VAR_3, VAR_4);

            break;

        case RR_NEG:

            gen_arith(VAR_0, VAR_1, OPC_SUBU, VAR_3, 0, VAR_4);

            break;

        case RR_AND:

            gen_logic(VAR_0, OPC_AND, VAR_3, VAR_3, VAR_4);

            break;

        case RR_OR:

            gen_logic(VAR_0, OPC_OR, VAR_3, VAR_3, VAR_4);

            break;

        case RR_XOR:

            gen_logic(VAR_0, OPC_XOR, VAR_3, VAR_3, VAR_4);

            break;

        case RR_NOT:

            gen_logic(VAR_0, OPC_NOR, VAR_3, VAR_4, 0);

            break;

        case RR_MFHI:

            gen_HILO(VAR_1, OPC_MFHI, VAR_3);

            break;

        case RR_CNVT:

            switch (VAR_7) {

            case RR_RY_CNVT_ZEB:

                tcg_gen_ext8u_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]);

                break;

            case RR_RY_CNVT_ZEH:

                tcg_gen_ext16u_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]);

                break;

            case RR_RY_CNVT_SEB:

                tcg_gen_ext8s_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]);

                break;

            case RR_RY_CNVT_SEH:

                tcg_gen_ext16s_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]);

                break;

#if defined (TARGET_MIPS64)

            case RR_RY_CNVT_ZEW:

                check_mips_64(VAR_1);

                tcg_gen_ext32u_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]);

                break;

            case RR_RY_CNVT_SEW:

                check_mips_64(VAR_1);

                tcg_gen_ext32s_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]);

                break;

#endif

            default:

                generate_exception(VAR_1, EXCP_RI);

                break;

            }

            break;

        case RR_MFLO:

            gen_HILO(VAR_1, OPC_MFLO, VAR_3);

            break;

#if defined (TARGET_MIPS64)

        case RR_DSRA:

            check_mips_64(VAR_1);

            gen_shift_imm(VAR_0, VAR_1, OPC_DSRA, VAR_4, VAR_4, VAR_5);

            break;

        case RR_DSLLV:

            check_mips_64(VAR_1);

            gen_shift(VAR_0, VAR_1, OPC_DSLLV, VAR_4, VAR_3, VAR_4);

            break;

        case RR_DSRLV:

            check_mips_64(VAR_1);

            gen_shift(VAR_0, VAR_1, OPC_DSRLV, VAR_4, VAR_3, VAR_4);

            break;

        case RR_DSRAV:

            check_mips_64(VAR_1);

            gen_shift(VAR_0, VAR_1, OPC_DSRAV, VAR_4, VAR_3, VAR_4);

            break;

#endif

        case RR_MULT:

            gen_muldiv(VAR_1, OPC_MULT, VAR_3, VAR_4);

            break;

        case RR_MULTU:

            gen_muldiv(VAR_1, OPC_MULTU, VAR_3, VAR_4);

            break;

        case RR_DIV:

            gen_muldiv(VAR_1, OPC_DIV, VAR_3, VAR_4);

            break;

        case RR_DIVU:

            gen_muldiv(VAR_1, OPC_DIVU, VAR_3, VAR_4);

            break;

#if defined (TARGET_MIPS64)

        case RR_DMULT:

            check_mips_64(VAR_1);

            gen_muldiv(VAR_1, OPC_DMULT, VAR_3, VAR_4);

            break;

        case RR_DMULTU:

            check_mips_64(VAR_1);

            gen_muldiv(VAR_1, OPC_DMULTU, VAR_3, VAR_4);

            break;

        case RR_DDIV:

            check_mips_64(VAR_1);

            gen_muldiv(VAR_1, OPC_DDIV, VAR_3, VAR_4);

            break;

        case RR_DDIVU:

            check_mips_64(VAR_1);

            gen_muldiv(VAR_1, OPC_DDIVU, VAR_3, VAR_4);

            break;

#endif

        default:

            generate_exception(VAR_1, EXCP_RI);

            break;

        }

        break;

    case M16_OPC_EXTEND:

        decode_extended_mips16_opc(VAR_0, VAR_1, VAR_2);

        VAR_11 = 4;

        break;

#if defined(TARGET_MIPS64)

    case M16_OPC_I64:

        VAR_10 = (VAR_1->opcode >> 8) & 0x7;

        decode_i64_mips16(VAR_0, VAR_1, VAR_4, VAR_10, VAR_9, 0);

        break;

#endif

    default:

        generate_exception(VAR_1, EXCP_RI);

        break;

    }



    return VAR_11;

}

static int FUNC_0 (CPUState *VAR_0, DisasContext *VAR_1,
int *VAR_2)
{ int VAR_3, VAR_4; int VAR_5; int VAR_6, VAR_7, VAR_8, VAR_9; int VAR_10; int VAR_11; VAR_6 = (VAR_1->opcode >> 11) & 0x1f; VAR_5 = (VAR_1->opcode >> 2) & 0x7; VAR_5 = VAR_5 == 0 ? 8 : VAR_5; VAR_3 = xlat((VAR_1->opcode >> 8) & 0x7); VAR_7 = (VAR_1->opcode >> 5) & 0x7; VAR_4 = xlat((VAR_1->opcode >> 5) & 0x7); VAR_8 = VAR_9 = VAR_1->opcode & 0x1f; VAR_11 = 2; switch (VAR_6) { case M16_OPC_ADDIUSP:
{ int16_t imm = ((uint8_t) VAR_1->opcode) << 2; gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_3, 29, imm); } break; case M16_OPC_ADDIUPC:
gen_addiupc(VAR_1, VAR_3, ((uint8_t) VAR_1->opcode) << 2, 0, 0); break; case M16_OPC_B:
VAR_9 = (VAR_1->opcode & 0x7ff) << 1; VAR_9 = (int16_t)(VAR_9 << 4) >> 4; gen_compute_branch(VAR_1, OPC_BEQ, 2, 0, 0, VAR_9); break; case M16_OPC_JAL:
VAR_9 = lduw_code(VAR_1->pc + 2); VAR_9 = (((VAR_1->opcode & 0x1f) << 21)
| ((VAR_1->opcode >> 5) & 0x1f) << 16
| VAR_9) << 2; VAR_6 = ((VAR_1->opcode >> 10) & 0x1) ? OPC_JALX : OPC_JAL; gen_compute_branch(VAR_1, VAR_6, 4, VAR_3, VAR_4, VAR_9); VAR_11 = 4; *VAR_2 = 1; break; case M16_OPC_BEQZ:
gen_compute_branch(VAR_1, OPC_BEQ, 2, VAR_3, 0, ((int8_t)VAR_1->opcode) << 1); break; case M16_OPC_BNEQZ:
gen_compute_branch(VAR_1, OPC_BNE, 2, VAR_3, 0, ((int8_t)VAR_1->opcode) << 1); break; case M16_OPC_SHIFT:
switch (VAR_1->opcode & 0x3) { case 0x0:
gen_shift_imm(VAR_0, VAR_1, OPC_SLL, VAR_3, VAR_4, VAR_5); break; case 0x1:
#if defined(TARGET_MIPS64)
check_mips_64(VAR_1); gen_shift_imm(VAR_0, VAR_1, OPC_DSLL, VAR_3, VAR_4, VAR_5); #else
generate_exception(VAR_1, EXCP_RI); #endif
break; case 0x2:
gen_shift_imm(VAR_0, VAR_1, OPC_SRL, VAR_3, VAR_4, VAR_5); break; case 0x3:
gen_shift_imm(VAR_0, VAR_1, OPC_SRA, VAR_3, VAR_4, VAR_5); break; } break; #if defined(TARGET_MIPS64)
case M16_OPC_LD:
check_mips_64(VAR_1); gen_ldst(VAR_1, OPC_LD, VAR_4, VAR_3, VAR_9 << 3); break; #endif
case M16_OPC_RRIA:
{ int16_t imm = (int8_t)((VAR_1->opcode & 0xf) << 4) >> 4; if ((VAR_1->opcode >> 4) & 1) { #if defined(TARGET_MIPS64)
check_mips_64(VAR_1); gen_arith_imm(VAR_0, VAR_1, OPC_DADDIU, VAR_4, VAR_3, imm); #else
generate_exception(VAR_1, EXCP_RI); #endif
} else { gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_4, VAR_3, imm); } } break; case M16_OPC_ADDIU8:
{ int16_t imm = (int8_t) VAR_1->opcode; gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_3, VAR_3, imm); } break; case M16_OPC_SLTI:
{ int16_t imm = (uint8_t) VAR_1->opcode; gen_slt_imm(VAR_0, OPC_SLTI, 24, VAR_3, imm); } break; case M16_OPC_SLTIU:
{ int16_t imm = (uint8_t) VAR_1->opcode; gen_slt_imm(VAR_0, OPC_SLTIU, 24, VAR_3, imm); } break; case M16_OPC_I8:
{ int VAR_12; VAR_10 = (VAR_1->opcode >> 8) & 0x7; switch (VAR_10) { case I8_BTEQZ:
gen_compute_branch(VAR_1, OPC_BEQ, 2, 24, 0,
((int8_t)VAR_1->opcode) << 1); break; case I8_BTNEZ:
gen_compute_branch(VAR_1, OPC_BNE, 2, 24, 0,
((int8_t)VAR_1->opcode) << 1); break; case I8_SWRASP:
gen_ldst(VAR_1, OPC_SW, 31, 29, (VAR_1->opcode & 0xff) << 2); break; case I8_ADJSP:
gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, 29, 29,
((int8_t)VAR_1->opcode) << 3); break; case I8_SVRS:
{ int VAR_13 = VAR_1->opcode & (1 << 6); int VAR_14 = VAR_1->opcode & (1 << 5); int VAR_15 = VAR_1->opcode & (1 << 4); int VAR_16 = VAR_1->opcode & 0xf; if (VAR_16 == 0) { VAR_16 = 128; } else { VAR_16 = VAR_16 << 3; } if (VAR_1->opcode & (1 << 7)) { gen_mips16_save(VAR_1, 0, 0,
VAR_13, VAR_14, VAR_15, VAR_16); } else { gen_mips16_restore(VAR_1, 0, 0,
VAR_13, VAR_14, VAR_15, VAR_16); } } break; case I8_MOV32R:
{ int VAR_18 = xlat(VAR_1->opcode & 0x7); VAR_12 = (((VAR_1->opcode >> 3) & 0x3) << 3) |
((VAR_1->opcode >> 5) & 0x7); gen_arith(VAR_0, VAR_1, OPC_ADDU, VAR_12, VAR_18, 0); } break; case I8_MOVR32:
VAR_12 = VAR_1->opcode & 0x1f; gen_arith(VAR_0, VAR_1, OPC_ADDU, VAR_4, VAR_12, 0); break; default:
generate_exception(VAR_1, EXCP_RI); break; } } break; case M16_OPC_LI:
{ int16_t imm = (uint8_t) VAR_1->opcode; gen_arith_imm(VAR_0, VAR_1, OPC_ADDIU, VAR_3, 0, imm); } break; case M16_OPC_CMPI:
{ int16_t imm = (uint8_t) VAR_1->opcode; gen_logic_imm(VAR_0, OPC_XORI, 24, VAR_3, imm); } break; #if defined(TARGET_MIPS64)
case M16_OPC_SD:
check_mips_64(VAR_1); gen_ldst(VAR_1, OPC_SD, VAR_4, VAR_3, VAR_9 << 3); break; #endif
case M16_OPC_LB:
gen_ldst(VAR_1, OPC_LB, VAR_4, VAR_3, VAR_9); break; case M16_OPC_LH:
gen_ldst(VAR_1, OPC_LH, VAR_4, VAR_3, VAR_9 << 1); break; case M16_OPC_LWSP:
gen_ldst(VAR_1, OPC_LW, VAR_3, 29, ((uint8_t)VAR_1->opcode) << 2); break; case M16_OPC_LW:
gen_ldst(VAR_1, OPC_LW, VAR_4, VAR_3, VAR_9 << 2); break; case M16_OPC_LBU:
gen_ldst(VAR_1, OPC_LBU, VAR_4, VAR_3, VAR_9); break; case M16_OPC_LHU:
gen_ldst(VAR_1, OPC_LHU, VAR_4, VAR_3, VAR_9 << 1); break; case M16_OPC_LWPC:
gen_ldst(VAR_1, OPC_LWPC, VAR_3, 0, ((uint8_t)VAR_1->opcode) << 2); break; #if defined (TARGET_MIPS64)
case M16_OPC_LWU:
check_mips_64(VAR_1); gen_ldst(VAR_1, OPC_LWU, VAR_4, VAR_3, VAR_9 << 2); break; #endif
case M16_OPC_SB:
gen_ldst(VAR_1, OPC_SB, VAR_4, VAR_3, VAR_9); break; case M16_OPC_SH:
gen_ldst(VAR_1, OPC_SH, VAR_4, VAR_3, VAR_9 << 1); break; case M16_OPC_SWSP:
gen_ldst(VAR_1, OPC_SW, VAR_3, 29, ((uint8_t)VAR_1->opcode) << 2); break; case M16_OPC_SW:
gen_ldst(VAR_1, OPC_SW, VAR_4, VAR_3, VAR_9 << 2); break; case M16_OPC_RRR:
{ int VAR_18 = xlat((VAR_1->opcode >> 2) & 0x7); int VAR_18; switch (VAR_1->opcode & 0x3) { case RRR_ADDU:
VAR_18 = OPC_ADDU; break; case RRR_SUBU:
VAR_18 = OPC_SUBU; break; #if defined(TARGET_MIPS64)
case RRR_DADDU:
VAR_18 = OPC_DADDU; check_mips_64(VAR_1); break; case RRR_DSUBU:
VAR_18 = OPC_DSUBU; check_mips_64(VAR_1); break; #endif
default:
generate_exception(VAR_1, EXCP_RI); goto done; } gen_arith(VAR_0, VAR_1, VAR_18, VAR_18, VAR_3, VAR_4); done:
; } break; case M16_OPC_RR:
switch (VAR_8) { case RR_JR:
{ int VAR_19 = (VAR_1->opcode >> 7) & 0x1; int VAR_20 = (VAR_1->opcode >> 6) & 0x1; int VAR_21 = (VAR_1->opcode >> 5) & 0x1; if (VAR_20) { VAR_6 = VAR_19 ? OPC_JALRC : OPC_JALR; } else { VAR_6 = OPC_JR; } gen_compute_branch(VAR_1, VAR_6, 2, VAR_21 ? 31 : VAR_3, 31, 0); if (!VAR_19) { *VAR_2 = 1; } } break; case RR_SDBBP:
check_insn(VAR_0, VAR_1, ISA_MIPS32); if (!(VAR_1->hflags & MIPS_HFLAG_DM)) { generate_exception(VAR_1, EXCP_DBp); } else { generate_exception(VAR_1, EXCP_DBp); } break; case RR_SLT:
gen_slt(VAR_0, OPC_SLT, 24, VAR_3, VAR_4); break; case RR_SLTU:
gen_slt(VAR_0, OPC_SLTU, 24, VAR_3, VAR_4); break; case RR_BREAK:
generate_exception(VAR_1, EXCP_BREAK); break; case RR_SLLV:
gen_shift(VAR_0, VAR_1, OPC_SLLV, VAR_4, VAR_3, VAR_4); break; case RR_SRLV:
gen_shift(VAR_0, VAR_1, OPC_SRLV, VAR_4, VAR_3, VAR_4); break; case RR_SRAV:
gen_shift(VAR_0, VAR_1, OPC_SRAV, VAR_4, VAR_3, VAR_4); break; #if defined (TARGET_MIPS64)
case RR_DSRL:
check_mips_64(VAR_1); gen_shift_imm(VAR_0, VAR_1, OPC_DSRL, VAR_4, VAR_4, VAR_5); break; #endif
case RR_CMP:
gen_logic(VAR_0, OPC_XOR, 24, VAR_3, VAR_4); break; case RR_NEG:
gen_arith(VAR_0, VAR_1, OPC_SUBU, VAR_3, 0, VAR_4); break; case RR_AND:
gen_logic(VAR_0, OPC_AND, VAR_3, VAR_3, VAR_4); break; case RR_OR:
gen_logic(VAR_0, OPC_OR, VAR_3, VAR_3, VAR_4); break; case RR_XOR:
gen_logic(VAR_0, OPC_XOR, VAR_3, VAR_3, VAR_4); break; case RR_NOT:
gen_logic(VAR_0, OPC_NOR, VAR_3, VAR_4, 0); break; case RR_MFHI:
gen_HILO(VAR_1, OPC_MFHI, VAR_3); break; case RR_CNVT:
switch (VAR_7) { case RR_RY_CNVT_ZEB:
tcg_gen_ext8u_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]); break; case RR_RY_CNVT_ZEH:
tcg_gen_ext16u_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]); break; case RR_RY_CNVT_SEB:
tcg_gen_ext8s_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]); break; case RR_RY_CNVT_SEH:
tcg_gen_ext16s_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]); break; #if defined (TARGET_MIPS64)
case RR_RY_CNVT_ZEW:
check_mips_64(VAR_1); tcg_gen_ext32u_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]); break; case RR_RY_CNVT_SEW:
check_mips_64(VAR_1); tcg_gen_ext32s_tl(cpu_gpr[VAR_3], cpu_gpr[VAR_3]); break; #endif
default:
generate_exception(VAR_1, EXCP_RI); break; } break; case RR_MFLO:
gen_HILO(VAR_1, OPC_MFLO, VAR_3); break; #if defined (TARGET_MIPS64)
case RR_DSRA:
check_mips_64(VAR_1); gen_shift_imm(VAR_0, VAR_1, OPC_DSRA, VAR_4, VAR_4, VAR_5); break; case RR_DSLLV:
check_mips_64(VAR_1); gen_shift(VAR_0, VAR_1, OPC_DSLLV, VAR_4, VAR_3, VAR_4); break; case RR_DSRLV:
check_mips_64(VAR_1); gen_shift(VAR_0, VAR_1, OPC_DSRLV, VAR_4, VAR_3, VAR_4); break; case RR_DSRAV:
check_mips_64(VAR_1); gen_shift(VAR_0, VAR_1, OPC_DSRAV, VAR_4, VAR_3, VAR_4); break; #endif
case RR_MULT:
gen_muldiv(VAR_1, OPC_MULT, VAR_3, VAR_4); break; case RR_MULTU:
gen_muldiv(VAR_1, OPC_MULTU, VAR_3, VAR_4); break; case RR_DIV:
gen_muldiv(VAR_1, OPC_DIV, VAR_3, VAR_4); break; case RR_DIVU:
gen_muldiv(VAR_1, OPC_DIVU, VAR_3, VAR_4); break; #if defined (TARGET_MIPS64)
case RR_DMULT:
check_mips_64(VAR_1); gen_muldiv(VAR_1, OPC_DMULT, VAR_3, VAR_4); break; case RR_DMULTU:
check_mips_64(VAR_1); gen_muldiv(VAR_1, OPC_DMULTU, VAR_3, VAR_4); break; case RR_DDIV:
check_mips_64(VAR_1); gen_muldiv(VAR_1, OPC_DDIV, VAR_3, VAR_4); break; case RR_DDIVU:
check_mips_64(VAR_1); gen_muldiv(VAR_1, OPC_DDIVU, VAR_3, VAR_4); break; #endif
default:
generate_exception(VAR_1, EXCP_RI); break; } break; case M16_OPC_EXTEND:
decode_extended_mips16_opc(VAR_0, VAR_1, VAR_2); VAR_11 = 4; break; #if defined(TARGET_MIPS64)
case M16_OPC_I64:
VAR_10 = (VAR_1->opcode >> 8) & 0x7; decode_i64_mips16(VAR_0, VAR_1, VAR_4, VAR_10, VAR_9, 0); break; #endif
default:
generate_exception(VAR_1, EXCP_RI); break; } return VAR_11; }