/*

 *  PowerPC emulation for qemu: main translation routines.

 *

 *  Copyright (c) 2003-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 <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 "tcg-op.h"

#include "qemu-common.h"

#include "helper.h"

#define GEN_HELPER 1

#include "helper.h"

#define CPU_SINGLE_STEP 0x1

#define CPU_BRANCH_STEP 0x2

#define GDBSTUB_SINGLE_STEP 0x4

/* Include definitions for instructions classes and implementations flags */

//#define DO_SINGLE_STEP

//#define PPC_DEBUG_DISAS

//#define DO_PPC_STATISTICS

/*****************************************************************************/

/* Code translation helpers                                                  */

/* global register indexes */

static TCGv_ptr cpu_env;

static char cpu_reg_names[10*3 + 22*4 /* GPR */

#if !defined(TARGET_PPC64)

    + 10*4 + 22*5 /* SPE GPRh */

#endif

    + 10*4 + 22*5 /* FPR */

    + 2*(10*6 + 22*7) /* AVRh, AVRl */

    + 8*5 /* CRF */];

static TCGv cpu_gpr[32];

#if !defined(TARGET_PPC64)

static TCGv cpu_gprh[32];

#endif

static TCGv_i64 cpu_fpr[32];

static TCGv_i64 cpu_avrh[32], cpu_avrl[32];

static TCGv_i32 cpu_crf[8];

static TCGv cpu_nip;

static TCGv cpu_msr;

static TCGv cpu_ctr;

static TCGv cpu_lr;

static TCGv cpu_xer;

static TCGv cpu_reserve;

static TCGv_i32 cpu_fpscr;

static TCGv_i32 cpu_access_type;

#include "gen-icount.h"

void ppc_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 < 8; i++) {

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

        cpu_crf[i] = tcg_global_mem_new_i32(TCG_AREG0,

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

        p += 5;

    }

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

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

        cpu_gpr[i] = tcg_global_mem_new(TCG_AREG0,

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

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

#if !defined(TARGET_PPC64)

        sprintf(p, "r%dH", i);

        cpu_gprh[i] = tcg_global_mem_new_i32(TCG_AREG0,

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

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

#endif

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

        cpu_fpr[i] = tcg_global_mem_new_i64(TCG_AREG0,

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

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

        sprintf(p, "avr%dH", i);

#ifdef WORDS_BIGENDIAN

        cpu_avrh[i] = tcg_global_mem_new_i64(TCG_AREG0,

                                             offsetof(CPUState, avr[i].u64[0]), p);

#else

        cpu_avrh[i] = tcg_global_mem_new_i64(TCG_AREG0,

                                             offsetof(CPUState, avr[i].u64[1]), p);

#endif

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

        sprintf(p, "avr%dL", i);

#ifdef WORDS_BIGENDIAN

        cpu_avrl[i] = tcg_global_mem_new_i64(TCG_AREG0,

                                             offsetof(CPUState, avr[i].u64[1]), p);

#else

        cpu_avrl[i] = tcg_global_mem_new_i64(TCG_AREG0,

                                             offsetof(CPUState, avr[i].u64[0]), p);

#endif

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

    }

    cpu_nip = tcg_global_mem_new(TCG_AREG0,

                                 offsetof(CPUState, nip), "nip");

    cpu_msr = tcg_global_mem_new(TCG_AREG0,

                                 offsetof(CPUState, msr), "msr");

    cpu_ctr = tcg_global_mem_new(TCG_AREG0,

                                 offsetof(CPUState, ctr), "ctr");

    cpu_lr = tcg_global_mem_new(TCG_AREG0,

                                offsetof(CPUState, lr), "lr");

    cpu_xer = tcg_global_mem_new(TCG_AREG0,

                                 offsetof(CPUState, xer), "xer");

    cpu_reserve = tcg_global_mem_new(TCG_AREG0,

                                     offsetof(CPUState, reserve), "reserve");

    cpu_fpscr = tcg_global_mem_new_i32(TCG_AREG0,

                                       offsetof(CPUState, fpscr), "fpscr");

    cpu_access_type = tcg_global_mem_new_i32(TCG_AREG0,

                                             offsetof(CPUState, access_type), "access_type");

    /* register helpers */

#define GEN_HELPER 2

#include "helper.h"

    done_init = 1;

}

/* internal defines */

typedef struct DisasContext {

    struct TranslationBlock *tb;

    target_ulong nip;

    uint32_t opcode;

    uint32_t exception;

    /* Routine used to access memory */

    int mem_idx;

    int access_type;

    /* Translation flags */

    int le_mode;

#if defined(TARGET_PPC64)

    int sf_mode;

#endif

    int fpu_enabled;

    int altivec_enabled;

    int spe_enabled;

    ppc_spr_t *spr_cb; /* Needed to check rights for mfspr/mtspr */

    int singlestep_enabled;

} DisasContext;

struct opc_handler_t {

    /* invalid bits */

    uint32_t inval;

    /* instruction type */

    uint64_t type;

    /* handler */

    void (*handler)(DisasContext *ctx);

#if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)

    const char *oname;

#endif

#if defined(DO_PPC_STATISTICS)

    uint64_t count;

#endif

};

static always_inline void gen_reset_fpstatus (void)

{

#ifdef CONFIG_SOFTFLOAT

    gen_helper_reset_fpstatus();

#endif

}

static always_inline void gen_compute_fprf (TCGv_i64 arg, int set_fprf, int set_rc)

{

    TCGv_i32 t0 = tcg_temp_new_i32();

    if (set_fprf != 0) {

        /* This case might be optimized later */

        tcg_gen_movi_i32(t0, 1);

        gen_helper_compute_fprf(t0, arg, t0);

        if (unlikely(set_rc)) {

            tcg_gen_mov_i32(cpu_crf[1], t0);

        }

        gen_helper_float_check_status();

    } else if (unlikely(set_rc)) {

        /* We always need to compute fpcc */

        tcg_gen_movi_i32(t0, 0);

        gen_helper_compute_fprf(t0, arg, t0);

        tcg_gen_mov_i32(cpu_crf[1], t0);

    }

    tcg_temp_free_i32(t0);

}

static always_inline void gen_set_access_type (DisasContext *ctx, int access_type)

{

    if (ctx->access_type != access_type) {

        tcg_gen_movi_i32(cpu_access_type, access_type);

        ctx->access_type = access_type;

    }

}

static always_inline void gen_update_nip (DisasContext *ctx, target_ulong nip)

{

#if defined(TARGET_PPC64)

    if (ctx->sf_mode)

        tcg_gen_movi_tl(cpu_nip, nip);

    else

#endif

        tcg_gen_movi_tl(cpu_nip, (uint32_t)nip);

}

static always_inline void gen_exception_err (DisasContext *ctx, uint32_t excp, uint32_t error)

{

    TCGv_i32 t0, t1;

    if (ctx->exception == POWERPC_EXCP_NONE) {

        gen_update_nip(ctx, ctx->nip);

    }

    t0 = tcg_const_i32(excp);

    t1 = tcg_const_i32(error);

    gen_helper_raise_exception_err(t0, t1);

    tcg_temp_free_i32(t0);

    tcg_temp_free_i32(t1);

    ctx->exception = (excp);

}

static always_inline void gen_exception (DisasContext *ctx, uint32_t excp)

{

    TCGv_i32 t0;

    if (ctx->exception == POWERPC_EXCP_NONE) {

        gen_update_nip(ctx, ctx->nip);

    }

    t0 = tcg_const_i32(excp);

    gen_helper_raise_exception(t0);

    tcg_temp_free_i32(t0);

    ctx->exception = (excp);

}

static always_inline void gen_debug_exception (DisasContext *ctx)

{

    TCGv_i32 t0;

    gen_update_nip(ctx, ctx->nip);

    t0 = tcg_const_i32(EXCP_DEBUG);

    gen_helper_raise_exception(t0);

    tcg_temp_free_i32(t0);

}

static always_inline void gen_inval_exception (DisasContext *ctx, uint32_t error)

{

    gen_exception_err(ctx, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_INVAL | error);

}

/* Stop translation */

static always_inline void gen_stop_exception (DisasContext *ctx)

{

    gen_update_nip(ctx, ctx->nip);

    ctx->exception = POWERPC_EXCP_STOP;

}

/* No need to update nip here, as execution flow will change */

static always_inline void gen_sync_exception (DisasContext *ctx)

{

    ctx->exception = POWERPC_EXCP_SYNC;

}

#define GEN_HANDLER(name, opc1, opc2, opc3, inval, type)                      \

static void gen_##name (DisasContext *ctx);                                   \

GEN_OPCODE(name, opc1, opc2, opc3, inval, type);                              \

static void gen_##name (DisasContext *ctx)

#define GEN_HANDLER2(name, onam, opc1, opc2, opc3, inval, type)               \

static void gen_##name (DisasContext *ctx);                                   \

GEN_OPCODE2(name, onam, opc1, opc2, opc3, inval, type);                       \

static void gen_##name (DisasContext *ctx)

typedef struct opcode_t {

    unsigned char opc1, opc2, opc3;

#if HOST_LONG_BITS == 64 /* Explicitly align to 64 bits */

    unsigned char pad[5];

#else

    unsigned char pad[1];

#endif

    opc_handler_t handler;

    const char *oname;

} opcode_t;

/*****************************************************************************/

/***                           Instruction decoding                        ***/

#define EXTRACT_HELPER(name, shift, nb)                                       \

static always_inline uint32_t name (uint32_t opcode)                          \

{                                                                             \

    return (opcode >> (shift)) & ((1 << (nb)) - 1);                           \

}

#define EXTRACT_SHELPER(name, shift, nb)                                      \

static always_inline int32_t name (uint32_t opcode)                           \

{                                                                             \

    return (int16_t)((opcode >> (shift)) & ((1 << (nb)) - 1));                \

}

/* Opcode part 1 */

EXTRACT_HELPER(opc1, 26, 6);

/* Opcode part 2 */

EXTRACT_HELPER(opc2, 1, 5);

/* Opcode part 3 */

EXTRACT_HELPER(opc3, 6, 5);

/* Update Cr0 flags */

EXTRACT_HELPER(Rc, 0, 1);

/* Destination */

EXTRACT_HELPER(rD, 21, 5);

/* Source */

EXTRACT_HELPER(rS, 21, 5);

/* First operand */

EXTRACT_HELPER(rA, 16, 5);

/* Second operand */

EXTRACT_HELPER(rB, 11, 5);

/* Third operand */

EXTRACT_HELPER(rC, 6, 5);

/***                               Get CRn                                 ***/

EXTRACT_HELPER(crfD, 23, 3);

EXTRACT_HELPER(crfS, 18, 3);

EXTRACT_HELPER(crbD, 21, 5);

EXTRACT_HELPER(crbA, 16, 5);

EXTRACT_HELPER(crbB, 11, 5);

/* SPR / TBL */

EXTRACT_HELPER(_SPR, 11, 10);

static always_inline uint32_t SPR (uint32_t opcode)

{

    uint32_t sprn = _SPR(opcode);

    return ((sprn >> 5) & 0x1F) | ((sprn & 0x1F) << 5);

}

/***                              Get constants                            ***/

EXTRACT_HELPER(IMM, 12, 8);

/* 16 bits signed immediate value */

EXTRACT_SHELPER(SIMM, 0, 16);

/* 16 bits unsigned immediate value */

EXTRACT_HELPER(UIMM, 0, 16);

/* 5 bits signed immediate value */

EXTRACT_HELPER(SIMM5, 16, 5);

/* 5 bits unsigned immediate value */

EXTRACT_HELPER(UIMM5, 16, 5);

/* Bit count */

EXTRACT_HELPER(NB, 11, 5);

/* Shift count */

EXTRACT_HELPER(SH, 11, 5);

/* Vector shift count */

EXTRACT_HELPER(VSH, 6, 4);

/* Mask start */

EXTRACT_HELPER(MB, 6, 5);

/* Mask end */

EXTRACT_HELPER(ME, 1, 5);

/* Trap operand */

EXTRACT_HELPER(TO, 21, 5);

EXTRACT_HELPER(CRM, 12, 8);

EXTRACT_HELPER(FM, 17, 8);

EXTRACT_HELPER(SR, 16, 4);

EXTRACT_HELPER(FPIMM, 12, 4);

/***                            Jump target decoding                       ***/

/* Displacement */

EXTRACT_SHELPER(d, 0, 16);

/* Immediate address */

static always_inline target_ulong LI (uint32_t opcode)

{

    return (opcode >> 0) & 0x03FFFFFC;

}

static always_inline uint32_t BD (uint32_t opcode)

{

    return (opcode >> 0) & 0xFFFC;

}

EXTRACT_HELPER(BO, 21, 5);

EXTRACT_HELPER(BI, 16, 5);

/* Absolute/relative address */

EXTRACT_HELPER(AA, 1, 1);

/* Link */

EXTRACT_HELPER(LK, 0, 1);

/* Create a mask between <start> and <end> bits */

static always_inline target_ulong MASK (uint32_t start, uint32_t end)

{

    target_ulong ret;

#if defined(TARGET_PPC64)

    if (likely(start == 0)) {

        ret = UINT64_MAX << (63 - end);

    } else if (likely(end == 63)) {

        ret = UINT64_MAX >> start;

    }

#else

    if (likely(start == 0)) {

        ret = UINT32_MAX << (31  - end);

    } else if (likely(end == 31)) {

        ret = UINT32_MAX >> start;

    }

#endif

    else {

        ret = (((target_ulong)(-1ULL)) >> (start)) ^

            (((target_ulong)(-1ULL) >> (end)) >> 1);

        if (unlikely(start > end))

            return ~ret;

    }

    return ret;

}

/*****************************************************************************/

/* PowerPC Instructions types definitions                                    */

enum {

    PPC_NONE           = 0x0000000000000000ULL,

    /* PowerPC base instructions set                                         */

    PPC_INSNS_BASE     = 0x0000000000000001ULL,

    /*   integer operations instructions                                     */

#define PPC_INTEGER PPC_INSNS_BASE

    /*   flow control instructions                                           */

#define PPC_FLOW    PPC_INSNS_BASE

    /*   virtual memory instructions                                         */

#define PPC_MEM     PPC_INSNS_BASE

    /*   ld/st with reservation instructions                                 */

#define PPC_RES     PPC_INSNS_BASE

    /*   spr/msr access instructions                                         */

#define PPC_MISC    PPC_INSNS_BASE

    /* Deprecated instruction sets                                           */

    /*   Original POWER instruction set                                      */

    PPC_POWER          = 0x0000000000000002ULL,

    /*   POWER2 instruction set extension                                    */

    PPC_POWER2         = 0x0000000000000004ULL,

    /*   Power RTC support                                                   */

    PPC_POWER_RTC      = 0x0000000000000008ULL,

    /*   Power-to-PowerPC bridge (601)                                       */

    PPC_POWER_BR       = 0x0000000000000010ULL,

    /* 64 bits PowerPC instruction set                                       */

    PPC_64B            = 0x0000000000000020ULL,

    /*   New 64 bits extensions (PowerPC 2.0x)                               */

    PPC_64BX           = 0x0000000000000040ULL,

    /*   64 bits hypervisor extensions                                       */

    PPC_64H            = 0x0000000000000080ULL,

    /*   New wait instruction (PowerPC 2.0x)                                 */

    PPC_WAIT           = 0x0000000000000100ULL,

    /*   Time base mftb instruction                                          */

    PPC_MFTB           = 0x0000000000000200ULL,

    /* Fixed-point unit extensions                                           */

    /*   PowerPC 602 specific                                                */

    PPC_602_SPEC       = 0x0000000000000400ULL,

    /*   isel instruction                                                    */

    PPC_ISEL           = 0x0000000000000800ULL,

    /*   popcntb instruction                                                 */

    PPC_POPCNTB        = 0x0000000000001000ULL,

    /*   string load / store                                                 */

    PPC_STRING         = 0x0000000000002000ULL,

    /* Floating-point unit extensions                                        */

    /*   Optional floating point instructions                                */

    PPC_FLOAT          = 0x0000000000010000ULL,

    /* New floating-point extensions (PowerPC 2.0x)                          */

    PPC_FLOAT_EXT      = 0x0000000000020000ULL,

    PPC_FLOAT_FSQRT    = 0x0000000000040000ULL,

    PPC_FLOAT_FRES     = 0x0000000000080000ULL,

    PPC_FLOAT_FRSQRTE  = 0x0000000000100000ULL,

    PPC_FLOAT_FRSQRTES = 0x0000000000200000ULL,

    PPC_FLOAT_FSEL     = 0x0000000000400000ULL,

    PPC_FLOAT_STFIWX   = 0x0000000000800000ULL,

    /* Vector/SIMD extensions                                                */

    /*   Altivec support                                                     */

    PPC_ALTIVEC        = 0x0000000001000000ULL,

    /*   PowerPC 2.03 SPE extension                                          */

    PPC_SPE            = 0x0000000002000000ULL,

    /*   PowerPC 2.03 SPE floating-point extension                           */

    PPC_SPEFPU         = 0x0000000004000000ULL,

    /* Optional memory control instructions                                  */

    PPC_MEM_TLBIA      = 0x0000000010000000ULL,

    PPC_MEM_TLBIE      = 0x0000000020000000ULL,

    PPC_MEM_TLBSYNC    = 0x0000000040000000ULL,

    /*   sync instruction                                                    */

    PPC_MEM_SYNC       = 0x0000000080000000ULL,

    /*   eieio instruction                                                   */

    PPC_MEM_EIEIO      = 0x0000000100000000ULL,

    /* Cache control instructions                                            */

    PPC_CACHE          = 0x0000000200000000ULL,

    /*   icbi instruction                                                    */

    PPC_CACHE_ICBI     = 0x0000000400000000ULL,

    /*   dcbz instruction with fixed cache line size                         */

    PPC_CACHE_DCBZ     = 0x0000000800000000ULL,

    /*   dcbz instruction with tunable cache line size                       */

    PPC_CACHE_DCBZT    = 0x0000001000000000ULL,

    /*   dcba instruction                                                    */

    PPC_CACHE_DCBA     = 0x0000002000000000ULL,

    /*   Freescale cache locking instructions                                */