/*

 *  Alpha emulation cpu translation for qemu.

 *

 *  Copyright (c) 2007 Jocelyn Mayer

 *

 * 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

 */

#include <stdint.h>

#include <stdlib.h>

#include <stdio.h>

#include "cpu.h"

#include "exec-all.h"

#include "disas.h"

#include "host-utils.h"

#include "tcg-op.h"

#include "qemu-common.h"

#include "helper.h"

#define GEN_HELPER 1

#include "helper.h"

/* #define DO_SINGLE_STEP */

#define ALPHA_DEBUG_DISAS

/* #define DO_TB_FLUSH */

typedef struct DisasContext DisasContext;

struct DisasContext {

    uint64_t pc;

    int mem_idx;

#if !defined (CONFIG_USER_ONLY)

    int pal_mode;

#endif

    uint32_t amask;

};

/* global register indexes */

static TCGv_ptr cpu_env;

static TCGv cpu_ir[31];

static TCGv cpu_fir[31];

static TCGv cpu_pc;

static TCGv cpu_lock;

/* register names */

static char cpu_reg_names[10*4+21*5 + 10*5+21*6];

#include "gen-icount.h"

static void alpha_translate_init(void)

{

    int i;

    char *p;

    static int done_init = 0;

    if (done_init)

        return;

    cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");

    p = cpu_reg_names;

    for (i = 0; i < 31; i++) {

        sprintf(p, "ir%d", i);

        cpu_ir[i] = tcg_global_mem_new_i64(TCG_AREG0,

                                           offsetof(CPUState, ir[i]), p);

        p += (i < 10) ? 4 : 5;

        sprintf(p, "fir%d", i);

        cpu_fir[i] = tcg_global_mem_new_i64(TCG_AREG0,

                                            offsetof(CPUState, fir[i]), p);

        p += (i < 10) ? 5 : 6;

    }

    cpu_pc = tcg_global_mem_new_i64(TCG_AREG0,

                                    offsetof(CPUState, pc), "pc");

    cpu_lock = tcg_global_mem_new_i64(TCG_AREG0,

                                      offsetof(CPUState, lock), "lock");

    /* register helpers */

#define GEN_HELPER 2

#include "helper.h"

    done_init = 1;

}

static always_inline void gen_excp (DisasContext *ctx,

                                    int exception, int error_code)

{

    TCGv_i32 tmp1, tmp2;

    tcg_gen_movi_i64(cpu_pc, ctx->pc);

    tmp1 = tcg_const_i32(exception);

    tmp2 = tcg_const_i32(error_code);

    gen_helper_excp(tmp1, tmp2);

    tcg_temp_free_i32(tmp2);

    tcg_temp_free_i32(tmp1);

}

static always_inline void gen_invalid (DisasContext *ctx)

{

    gen_excp(ctx, EXCP_OPCDEC, 0);

}

static always_inline void gen_qemu_ldf (TCGv t0, TCGv t1, int flags)

{

    TCGv tmp = tcg_temp_new();

    TCGv_i32 tmp32 = tcg_temp_new_i32();

    tcg_gen_qemu_ld32u(tmp, t1, flags);

    tcg_gen_trunc_i64_i32(tmp32, tmp);

    gen_helper_memory_to_f(t0, tmp32);

    tcg_temp_free_i32(tmp32);

    tcg_temp_free(tmp);

}

static always_inline void gen_qemu_ldg (TCGv t0, TCGv t1, int flags)

{

    TCGv tmp = tcg_temp_new();

    tcg_gen_qemu_ld64(tmp, t1, flags);

    gen_helper_memory_to_g(t0, tmp);

    tcg_temp_free(tmp);

}

static always_inline void gen_qemu_lds (TCGv t0, TCGv t1, int flags)

{

    TCGv tmp = tcg_temp_new();

    TCGv_i32 tmp32 = tcg_temp_new_i32();

    tcg_gen_qemu_ld32u(tmp, t1, flags);

    tcg_gen_trunc_i64_i32(tmp32, tmp);

    gen_helper_memory_to_s(t0, tmp32);

    tcg_temp_free_i32(tmp32);

    tcg_temp_free(tmp);

}

static always_inline void gen_qemu_ldl_l (TCGv t0, TCGv t1, int flags)

{

    tcg_gen_mov_i64(cpu_lock, t1);

    tcg_gen_qemu_ld32s(t0, t1, flags);

}

static always_inline void gen_qemu_ldq_l (TCGv t0, TCGv t1, int flags)

{

    tcg_gen_mov_i64(cpu_lock, t1);

    tcg_gen_qemu_ld64(t0, t1, flags);

}

static always_inline void gen_load_mem (DisasContext *ctx,

                                        void (*tcg_gen_qemu_load)(TCGv t0, TCGv t1, int flags),

                                        int ra, int rb, int32_t disp16,

                                        int fp, int clear)

{

    TCGv addr;

    if (unlikely(ra == 31))

        return;

    addr = tcg_temp_new();

    if (rb != 31) {

        tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);

        if (clear)

            tcg_gen_andi_i64(addr, addr, ~0x7);

    } else {

        if (clear)

            disp16 &= ~0x7;

        tcg_gen_movi_i64(addr, disp16);

    }

    if (fp)

        tcg_gen_qemu_load(cpu_fir[ra], addr, ctx->mem_idx);

    else

        tcg_gen_qemu_load(cpu_ir[ra], addr, ctx->mem_idx);

    tcg_temp_free(addr);

}

static always_inline void gen_qemu_stf (TCGv t0, TCGv t1, int flags)

{

    TCGv_i32 tmp32 = tcg_temp_new_i32();

    TCGv tmp = tcg_temp_new();

    gen_helper_f_to_memory(tmp32, t0);

    tcg_gen_extu_i32_i64(tmp, tmp32);

    tcg_gen_qemu_st32(tmp, t1, flags);

    tcg_temp_free(tmp);

    tcg_temp_free_i32(tmp32);

}

static always_inline void gen_qemu_stg (TCGv t0, TCGv t1, int flags)

{

    TCGv tmp = tcg_temp_new();

    gen_helper_g_to_memory(tmp, t0);

    tcg_gen_qemu_st64(tmp, t1, flags);

    tcg_temp_free(tmp);

}

static always_inline void gen_qemu_sts (TCGv t0, TCGv t1, int flags)

{

    TCGv_i32 tmp32 = tcg_temp_new_i32();

    TCGv tmp = tcg_temp_new();

    gen_helper_s_to_memory(tmp32, t0);

    tcg_gen_extu_i32_i64(tmp, tmp32);

    tcg_gen_qemu_st32(tmp, t1, flags);

    tcg_temp_free(tmp);

    tcg_temp_free_i32(tmp32);

}

static always_inline void gen_qemu_stl_c (TCGv t0, TCGv t1, int flags)

{

    int l1, l2;

    l1 = gen_new_label();

    l2 = gen_new_label();

    tcg_gen_brcond_i64(TCG_COND_NE, cpu_lock, t1, l1);

    tcg_gen_qemu_st32(t0, t1, flags);

    tcg_gen_movi_i64(t0, 1);

    tcg_gen_br(l2);

    gen_set_label(l1);

    tcg_gen_movi_i64(t0, 0);

    gen_set_label(l2);

    tcg_gen_movi_i64(cpu_lock, -1);

}

static always_inline void gen_qemu_stq_c (TCGv t0, TCGv t1, int flags)

{

    int l1, l2;

    l1 = gen_new_label();

    l2 = gen_new_label();

    tcg_gen_brcond_i64(TCG_COND_NE, cpu_lock, t1, l1);

    tcg_gen_qemu_st64(t0, t1, flags);

    tcg_gen_movi_i64(t0, 1);

    tcg_gen_br(l2);

    gen_set_label(l1);

    tcg_gen_movi_i64(t0, 0);

    gen_set_label(l2);

    tcg_gen_movi_i64(cpu_lock, -1);

}

static always_inline void gen_store_mem (DisasContext *ctx,

                                         void (*tcg_gen_qemu_store)(TCGv t0, TCGv t1, int flags),

                                         int ra, int rb, int32_t disp16,

                                         int fp, int clear, int local)

{

    TCGv addr;

    if (local)

        addr = tcg_temp_local_new();

    else

        addr = tcg_temp_new();

    if (rb != 31) {

        tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);

        if (clear)

            tcg_gen_andi_i64(addr, addr, ~0x7);

    } else {

        if (clear)

            disp16 &= ~0x7;

        tcg_gen_movi_i64(addr, disp16);

    }

    if (ra != 31) {

        if (fp)

            tcg_gen_qemu_store(cpu_fir[ra], addr, ctx->mem_idx);

        else

            tcg_gen_qemu_store(cpu_ir[ra], addr, ctx->mem_idx);

    } else {

        TCGv zero;

        if (local)

            zero = tcg_const_local_i64(0);

        else

            zero = tcg_const_i64(0);

        tcg_gen_qemu_store(zero, addr, ctx->mem_idx);

        tcg_temp_free(zero);

    }

    tcg_temp_free(addr);

}

static always_inline void gen_bcond (DisasContext *ctx,

                                     TCGCond cond,

                                     int ra, int32_t disp16, int mask)

{

    int l1, l2;

    l1 = gen_new_label();

    l2 = gen_new_label();

    if (likely(ra != 31)) {

        if (mask) {

            TCGv tmp = tcg_temp_new();

            tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);

            tcg_gen_brcondi_i64(cond, tmp, 0, l1);

            tcg_temp_free(tmp);

        } else

            tcg_gen_brcondi_i64(cond, cpu_ir[ra], 0, l1);

    } else {

        /* Very uncommon case - Do not bother to optimize.  */

        TCGv tmp = tcg_const_i64(0);

        tcg_gen_brcondi_i64(cond, tmp, 0, l1);

        tcg_temp_free(tmp);

    }

    tcg_gen_movi_i64(cpu_pc, ctx->pc);

    tcg_gen_br(l2);

    gen_set_label(l1);

    tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp16 << 2));

    gen_set_label(l2);

}

static always_inline void gen_fbcond (DisasContext *ctx, int opc,

                                      int ra, int32_t disp16)

{

    int l1, l2;

    TCGv tmp;

    TCGv src;

    l1 = gen_new_label();

    l2 = gen_new_label();

    if (ra != 31) {

        tmp = tcg_temp_new();

        src = cpu_fir[ra];

    } else  {

        tmp = tcg_const_i64(0);

        src = tmp;

    }

    switch (opc) {

    case 0x31: /* FBEQ */

        gen_helper_cmpfeq(tmp, src);

        break;

    case 0x32: /* FBLT */

        gen_helper_cmpflt(tmp, src);

        break;

    case 0x33: /* FBLE */

        gen_helper_cmpfle(tmp, src);

        break;

    case 0x35: /* FBNE */

        gen_helper_cmpfne(tmp, src);

        break;

    case 0x36: /* FBGE */

        gen_helper_cmpfge(tmp, src);

        break;

    case 0x37: /* FBGT */

        gen_helper_cmpfgt(tmp, src);

        break;

    default:

        abort();

    }

    tcg_gen_brcondi_i64(TCG_COND_NE, tmp, 0, l1);

    tcg_gen_movi_i64(cpu_pc, ctx->pc);

    tcg_gen_br(l2);

    gen_set_label(l1);

    tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp16 << 2));

    gen_set_label(l2);

}

static always_inline void gen_cmov (TCGCond inv_cond,

                                    int ra, int rb, int rc,

                                    int islit, uint8_t lit, int mask)

{

    int l1;

    if (unlikely(rc == 31))

        return;

    l1 = gen_new_label();

    if (ra != 31) {

        if (mask) {

            TCGv tmp = tcg_temp_new();

            tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);

            tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);

            tcg_temp_free(tmp);

        } else

            tcg_gen_brcondi_i64(inv_cond, cpu_ir[ra], 0, l1);

    } else {

        /* Very uncommon case - Do not bother to optimize.  */

        TCGv tmp = tcg_const_i64(0);

        tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);

        tcg_temp_free(tmp);

    }

    if (islit)

        tcg_gen_movi_i64(cpu_ir[rc], lit);

    else

        tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);

    gen_set_label(l1);

}

#define FARITH2(name)                                       \

static always_inline void glue(gen_f, name)(int rb, int rc) \

{                                                           \

    if (unlikely(rc == 31))                                 \

      return;                                               \

                                                            \

    if (rb != 31)                                           \

        gen_helper_ ## name (cpu_fir[rc], cpu_fir[rb]);    \

    else {                                                  \

        TCGv tmp = tcg_const_i64(0);                        \

        gen_helper_ ## name (cpu_fir[rc], tmp);            \

        tcg_temp_free(tmp);                                 \

    }                                                       \

}

FARITH2(sqrts)

FARITH2(sqrtf)

FARITH2(sqrtg)

FARITH2(sqrtt)

FARITH2(cvtgf)

FARITH2(cvtgq)

FARITH2(cvtqf)

FARITH2(cvtqg)

FARITH2(cvtst)

FARITH2(cvtts)

FARITH2(cvttq)

FARITH2(cvtqs)

FARITH2(cvtqt)

FARITH2(cvtlq)

FARITH2(cvtql)

FARITH2(cvtqlv)

FARITH2(cvtqlsv)

#define FARITH3(name)                                                     \

static always_inline void glue(gen_f, name) (int ra, int rb, int rc)      \

{                                                                         \

    if (unlikely(rc == 31))                                               \

        return;                                                           \

                                                                          \

    if (ra != 31) {                                                       \

        if (rb != 31)                                                     \

            gen_helper_ ## name (cpu_fir[rc], cpu_fir[ra], cpu_fir[rb]);  \

        else {                                                            \

            TCGv tmp = tcg_const_i64(0);                                  \

            gen_helper_ ## name (cpu_fir[rc], cpu_fir[ra], tmp);          \

            tcg_temp_free(tmp);                                           \

        }                                                                 \

    } else {                                                              \

        TCGv tmp = tcg_const_i64(0);                                      \

        if (rb != 31)                                                     \

            gen_helper_ ## name (cpu_fir[rc], tmp, cpu_fir[rb]);          \

        else                                                              \

            gen_helper_ ## name (cpu_fir[rc], tmp, tmp);                   \

        tcg_temp_free(tmp);                                               \

    }                                                                     \

}

FARITH3(addf)

FARITH3(subf)

FARITH3(mulf)

FARITH3(divf)

FARITH3(addg)

FARITH3(subg)

FARITH3(mulg)

FARITH3(divg)

FARITH3(cmpgeq)

FARITH3(cmpglt)

FARITH3(cmpgle)

FARITH3(adds)

FARITH3(subs)

FARITH3(muls)

FARITH3(divs)

FARITH3(addt)

FARITH3(subt)

FARITH3(mult)

FARITH3(divt)

FARITH3(cmptun)

FARITH3(cmpteq)

FARITH3(cmptlt)

FARITH3(cmptle)

FARITH3(cpys)

FARITH3(cpysn)

FARITH3(cpyse)

#define FCMOV(name)                                                   \

static always_inline void glue(gen_f, name) (int ra, int rb, int rc)  \

{                                                                     \

    int l1;                                                           \

    TCGv tmp;                                                         \

                                                                      \

    if (unlikely(rc == 31))                                           \

        return;                                                       \

                                                                      \

    l1 = gen_new_label();                                             \

    tmp = tcg_temp_new();                                 \

    if (ra != 31) {                                                   \

        tmp = tcg_temp_new();                             \

        gen_helper_ ## name (tmp, cpu_fir[ra]);                       \

    } else  {                                                         \

        tmp = tcg_const_i64(0);                                       \

        gen_helper_ ## name (tmp, tmp);                               \

    }                                                                 \

    tcg_gen_brcondi_i64(TCG_COND_EQ, tmp, 0, l1);                     \

    if (rb != 31)                                                     \

        tcg_gen_mov_i64(cpu_fir[rc], cpu_fir[ra]);                    \

    else                                                              \

        tcg_gen_movi_i64(cpu_fir[rc], 0);                             \

    gen_set_label(l1);                                                \

}

FCMOV(cmpfeq)

FCMOV(cmpfne)

FCMOV(cmpflt)

FCMOV(cmpfge)

FCMOV(cmpfle)

FCMOV(cmpfgt)

/* EXTWH, EXTWH, EXTLH, EXTQH */

static always_inline void gen_ext_h(void (*tcg_gen_ext_i64)(TCGv t0, TCGv t1),

                                    int ra, int rb, int rc,

                                    int islit, uint8_t lit)

{

    if (unlikely(rc == 31))

        return;

    if (ra != 31) {

        if (islit) {

            if (lit != 0)

                tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 64 - ((lit & 7) * 8));

            else

                tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);

        } else {

            TCGv tmp1, tmp2;

            tmp1 = tcg_temp_new();

            tcg_gen_andi_i64(tmp1, cpu_ir[rb], 7);

            tcg_gen_shli_i64(tmp1, tmp1, 3);

            tmp2 = tcg_const_i64(64);

            tcg_gen_sub_i64(tmp1, tmp2, tmp1);

            tcg_temp_free(tmp2);