/* *  PowerPC emulation micro-operations for qemu. * *  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 "op_mem_access.h"/***                             Integer load                              ***/#define PPC_LD_OP(name, op)                                                   \void OPPROTO glue(glue(op_l, name), MEMSUFFIX) (void)                         \{                                                                             \    T1 = glue(op, MEMSUFFIX)((uint32_t)T0);                                   \    RETURN();                                                                 \}#if defined(TARGET_PPC64)#define PPC_LD_OP_64(name, op)                                                \void OPPROTO glue(glue(glue(op_l, name), _64), MEMSUFFIX) (void)              \{                                                                             \    T1 = glue(op, MEMSUFFIX)((uint64_t)T0);                                   \    RETURN();                                                                 \}#endif#define PPC_ST_OP(name, op)                                                   \void OPPROTO glue(glue(op_st, name), MEMSUFFIX) (void)                        \{                                                                             \    glue(op, MEMSUFFIX)((uint32_t)T0, T1);                                    \    RETURN();                                                                 \}#if defined(TARGET_PPC64)#define PPC_ST_OP_64(name, op)                                                \void OPPROTO glue(glue(glue(op_st, name), _64), MEMSUFFIX) (void)             \{                                                                             \    glue(op, MEMSUFFIX)((uint64_t)T0, T1);                                    \    RETURN();                                                                 \}#endifPPC_LD_OP(bz, ldu8);PPC_LD_OP(ha, lds16);PPC_LD_OP(hz, ldu16);PPC_LD_OP(wz, ldu32);#if defined(TARGET_PPC64)PPC_LD_OP(wa, lds32);PPC_LD_OP(d, ldu64);PPC_LD_OP_64(bz, ldu8);PPC_LD_OP_64(ha, lds16);PPC_LD_OP_64(hz, ldu16);PPC_LD_OP_64(wz, ldu32);PPC_LD_OP_64(wa, lds32);PPC_LD_OP_64(d, ldu64);#endifPPC_LD_OP(ha_le, lds16r);PPC_LD_OP(hz_le, ldu16r);PPC_LD_OP(wz_le, ldu32r);#if defined(TARGET_PPC64)PPC_LD_OP(wa_le, lds32r);PPC_LD_OP(d_le, ldu64r);PPC_LD_OP_64(ha_le, lds16r);PPC_LD_OP_64(hz_le, ldu16r);PPC_LD_OP_64(wz_le, ldu32r);PPC_LD_OP_64(wa_le, lds32r);PPC_LD_OP_64(d_le, ldu64r);#endif/***                              Integer store                            ***/PPC_ST_OP(b, st8);PPC_ST_OP(h, st16);PPC_ST_OP(w, st32);#if defined(TARGET_PPC64)PPC_ST_OP(d, st64);PPC_ST_OP_64(b, st8);PPC_ST_OP_64(h, st16);PPC_ST_OP_64(w, st32);PPC_ST_OP_64(d, st64);#endifPPC_ST_OP(h_le, st16r);PPC_ST_OP(w_le, st32r);#if defined(TARGET_PPC64)PPC_ST_OP(d_le, st64r);PPC_ST_OP_64(h_le, st16r);PPC_ST_OP_64(w_le, st32r);PPC_ST_OP_64(d_le, st64r);#endif/***                Integer load and store with byte reverse               ***/PPC_LD_OP(hbr, ldu16r);PPC_LD_OP(wbr, ldu32r);PPC_ST_OP(hbr, st16r);PPC_ST_OP(wbr, st32r);#if defined(TARGET_PPC64)PPC_LD_OP_64(hbr, ldu16r);PPC_LD_OP_64(wbr, ldu32r);PPC_ST_OP_64(hbr, st16r);PPC_ST_OP_64(wbr, st32r);#endifPPC_LD_OP(hbr_le, ldu16);PPC_LD_OP(wbr_le, ldu32);PPC_ST_OP(hbr_le, st16);PPC_ST_OP(wbr_le, st32);#if defined(TARGET_PPC64)PPC_LD_OP_64(hbr_le, ldu16);PPC_LD_OP_64(wbr_le, ldu32);PPC_ST_OP_64(hbr_le, st16);PPC_ST_OP_64(wbr_le, st32);#endif/***                    Integer load and store multiple                    ***/void OPPROTO glue(op_lmw, MEMSUFFIX) (void){    glue(do_lmw, MEMSUFFIX)(PARAM1);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO glue(op_lmw_64, MEMSUFFIX) (void){    glue(do_lmw_64, MEMSUFFIX)(PARAM1);    RETURN();}#endifvoid OPPROTO glue(op_lmw_le, MEMSUFFIX) (void){    glue(do_lmw_le, MEMSUFFIX)(PARAM1);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO glue(op_lmw_le_64, MEMSUFFIX) (void){    glue(do_lmw_le_64, MEMSUFFIX)(PARAM1);    RETURN();}#endifvoid OPPROTO glue(op_stmw, MEMSUFFIX) (void){    glue(do_stmw, MEMSUFFIX)(PARAM1);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO glue(op_stmw_64, MEMSUFFIX) (void){    glue(do_stmw_64, MEMSUFFIX)(PARAM1);    RETURN();}#endifvoid OPPROTO glue(op_stmw_le, MEMSUFFIX) (void){    glue(do_stmw_le, MEMSUFFIX)(PARAM1);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO glue(op_stmw_le_64, MEMSUFFIX) (void){    glue(do_stmw_le_64, MEMSUFFIX)(PARAM1);    RETURN();}#endif/***                    Integer load and store strings                     ***/void OPPROTO glue(op_lswi, MEMSUFFIX) (void){    glue(do_lsw, MEMSUFFIX)(PARAM1);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO glue(op_lswi_64, MEMSUFFIX) (void){    glue(do_lsw_64, MEMSUFFIX)(PARAM1);    RETURN();}#endif/* PPC32 specification says we must generate an exception if * rA is in the range of registers to be loaded. * In an other hand, IBM says this is valid, but rA won't be loaded. * For now, I'll follow the spec... */void OPPROTO glue(op_lswx, MEMSUFFIX) (void){    /* Note: T1 comes from xer_bc then no cast is needed */    if (likely(T1 != 0)) {        if (unlikely((PARAM1 < PARAM2 && (PARAM1 + T1) > PARAM2) ||                     (PARAM1 < PARAM3 && (PARAM1 + T1) > PARAM3))) {            do_raise_exception_err(POWERPC_EXCP_PROGRAM,                                   POWERPC_EXCP_INVAL |                                   POWERPC_EXCP_INVAL_LSWX);        } else {            glue(do_lsw, MEMSUFFIX)(PARAM1);        }    }    RETURN();}#if defined(TARGET_PPC64)void OPPROTO glue(op_lswx_64, MEMSUFFIX) (void){    /* Note: T1 comes from xer_bc then no cast is needed */    if (likely(T1 != 0)) {        if (unlikely((PARAM1 < PARAM2 && (PARAM1 + T1) > PARAM2) ||                     (PARAM1 < PARAM3 && (PARAM1 + T1) > PARAM3))) {            do_raise_exception_err(POWERPC_EXCP_PROGRAM,                                   POWERPC_EXCP_INVAL |                                   POWERPC_EXCP_INVAL_LSWX);        } else {            glue(do_lsw_64, MEMSUFFIX)(PARAM1);        }    }    RETURN();}#endifvoid OPPROTO glue(op_stsw, MEMSUFFIX) (void){    glue(do_stsw, MEMSUFFIX)(PARAM1);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO glue(op_stsw_64, MEMSUFFIX) (void){    glue(do_stsw_64, MEMSUFFIX)(PARAM1);    RETURN();}#endif/***                         Floating-point store                          ***/#define PPC_STF_OP(name, op)                                                  \void OPPROTO glue(glue(op_st, name), MEMSUFFIX) (void)                        \{                                                                             \    glue(op, MEMSUFFIX)((uint32_t)T0, FT0);                                   \    RETURN();                                                                 \}#if defined(TARGET_PPC64)#define PPC_STF_OP_64(name, op)                                               \void OPPROTO glue(glue(glue(op_st, name), _64), MEMSUFFIX) (void)             \{                                                                             \    glue(op, MEMSUFFIX)((uint64_t)T0, FT0);                                   \    RETURN();                                                                 \}#endifstatic always_inline void glue(stfs, MEMSUFFIX) (target_ulong EA, double d){    glue(stfl, MEMSUFFIX)(EA, float64_to_float32(d, &env->fp_status));}#if defined(WORDS_BIGENDIAN)#define WORD0 0#define WORD1 1#else#define WORD0 1#define WORD1 0#endifstatic always_inline void glue(stfiw, MEMSUFFIX) (target_ulong EA, double d){    union {        double d;        uint32_t u[2];    } u;    /* Store the low order 32 bits without any conversion */    u.d = d;    glue(st32, MEMSUFFIX)(EA, u.u[WORD0]);}#undef WORD0#undef WORD1PPC_STF_OP(fd, stfq);PPC_STF_OP(fs, stfs);PPC_STF_OP(fiw, stfiw);#if defined(TARGET_PPC64)PPC_STF_OP_64(fd, stfq);PPC_STF_OP_64(fs, stfs);PPC_STF_OP_64(fiw, stfiw);#endifstatic always_inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, double d){    union {        double d;        uint64_t u;    } u;    u.d = d;    u.u = bswap64(u.u);    glue(stfq, MEMSUFFIX)(EA, u.d);}static always_inline void glue(stfsr, MEMSUFFIX) (target_ulong EA, double d){    union {        float f;        uint32_t u;    } u;    u.f = float64_to_float32(d, &env->fp_status);    u.u = bswap32(u.u);    glue(stfl, MEMSUFFIX)(EA, u.f);}static always_inline void glue(stfiwr, MEMSUFFIX) (target_ulong EA, double d){    union {        double d;        uint64_t u;    } u;    /* Store the low order 32 bits without any conversion */    u.d = d;    u.u = bswap32(u.u);    glue(st32, MEMSUFFIX)(EA, u.u);}PPC_STF_OP(fd_le, stfqr);PPC_STF_OP(fs_le, stfsr);PPC_STF_OP(fiw_le, stfiwr);#if defined(TARGET_PPC64)PPC_STF_OP_64(fd_le, stfqr);PPC_STF_OP_64(fs_le, stfsr);PPC_STF_OP_64(fiw_le, stfiwr);#endif/***                         Floating-point load                           ***/#define PPC_LDF_OP(name, op)                                                  \void OPPROTO glue(glue(op_l, name), MEMSUFFIX) (void)                         \{                                                                             \    FT0 = glue(op, MEMSUFFIX)((uint32_t)T0);                                  \    RETURN();                                                                 \}#if defined(TARGET_PPC64)#define PPC_LDF_OP_64(name, op)                                               \void OPPROTO glue(glue(glue(op_l, name), _64), MEMSUFFIX) (void)              \{                                                                             \    FT0 = glue(op, MEMSUFFIX)((uint64_t)T0);                                  \    RETURN();                                                                 \}#endifstatic always_inline double glue(ldfs, MEMSUFFIX) (target_ulong EA){    return float32_to_float64(glue(ldfl, MEMSUFFIX)(EA), &env->fp_status);}PPC_LDF_OP(fd, ldfq);PPC_LDF_OP(fs, ldfs);#if defined(TARGET_PPC64)PPC_LDF_OP_64(fd, ldfq);PPC_LDF_OP_64(fs, ldfs);#endifstatic always_inline double glue(ldfqr, MEMSUFFIX) (target_ulong EA){    union {        double d;        uint64_t u;    } u;    u.d = glue(ldfq, MEMSUFFIX)(EA);    u.u = bswap64(u.u);    return u.d;}static always_inline double glue(ldfsr, MEMSUFFIX) (target_ulong EA){    union {        float f;        uint32_t u;    } u;    u.f = glue(ldfl, MEMSUFFIX)(EA);    u.u = bswap32(u.u);    return float32_to_float64(u.f, &env->fp_status);}PPC_LDF_OP(fd_le, ldfqr);PPC_LDF_OP(fs_le, ldfsr);#if defined(TARGET_PPC64)PPC_LDF_OP_64(fd_le, ldfqr);PPC_LDF_OP_64(fs_le, ldfsr);#endif