/* *  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 *///#define DEBUG_OP#include "config.h"#include "exec.h"#include "host-utils.h"#include "helper_regs.h"#include "op_helper.h"#define REG 0#include "op_template.h"#define REG 1#include "op_template.h"#define REG 2#include "op_template.h"#define REG 3#include "op_template.h"#define REG 4#include "op_template.h"#define REG 5#include "op_template.h"#define REG 6#include "op_template.h"#define REG 7#include "op_template.h"#define REG 8#include "op_template.h"#define REG 9#include "op_template.h"#define REG 10#include "op_template.h"#define REG 11#include "op_template.h"#define REG 12#include "op_template.h"#define REG 13#include "op_template.h"#define REG 14#include "op_template.h"#define REG 15#include "op_template.h"#define REG 16#include "op_template.h"#define REG 17#include "op_template.h"#define REG 18#include "op_template.h"#define REG 19#include "op_template.h"#define REG 20#include "op_template.h"#define REG 21#include "op_template.h"#define REG 22#include "op_template.h"#define REG 23#include "op_template.h"#define REG 24#include "op_template.h"#define REG 25#include "op_template.h"#define REG 26#include "op_template.h"#define REG 27#include "op_template.h"#define REG 28#include "op_template.h"#define REG 29#include "op_template.h"#define REG 30#include "op_template.h"#define REG 31#include "op_template.h"void OPPROTO op_print_mem_EA (void){    do_print_mem_EA(T0);    RETURN();}/* PowerPC state maintenance operations *//* set_Rc0 */void OPPROTO op_set_Rc0 (void){    env->crf[0] = T0 | xer_so;    RETURN();}/* Constants load */void OPPROTO op_reset_T0 (void){    T0 = 0;    RETURN();}void OPPROTO op_set_T0 (void){    T0 = (uint32_t)PARAM1;    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_set_T0_64 (void){    T0 = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;    RETURN();}#endifvoid OPPROTO op_set_T1 (void){    T1 = (uint32_t)PARAM1;    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_set_T1_64 (void){    T1 = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;    RETURN();}#endif#if 0 // unusedvoid OPPROTO op_set_T2 (void){    T2 = (uint32_t)PARAM1;    RETURN();}#endifvoid OPPROTO op_move_T1_T0 (void){    T1 = T0;    RETURN();}void OPPROTO op_move_T2_T0 (void){    T2 = T0;    RETURN();}void OPPROTO op_moven_T2_T0 (void){    T2 = ~T0;    RETURN();}/* Generate exceptions */void OPPROTO op_raise_exception_err (void){    do_raise_exception_err(PARAM1, PARAM2);}void OPPROTO op_update_nip (void){    env->nip = (uint32_t)PARAM1;    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_update_nip_64 (void){    env->nip = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;    RETURN();}#endifvoid OPPROTO op_debug (void){    do_raise_exception(EXCP_DEBUG);}void OPPROTO op_exit_tb (void){    EXIT_TB();}/* Load/store special registers */void OPPROTO op_load_cr (void){    do_load_cr();    RETURN();}void OPPROTO op_store_cr (void){    do_store_cr(PARAM1);    RETURN();}void OPPROTO op_load_cro (void){    T0 = env->crf[PARAM1];    RETURN();}void OPPROTO op_store_cro (void){    env->crf[PARAM1] = T0;    RETURN();}void OPPROTO op_load_xer_cr (void){    T0 = (xer_so << 3) | (xer_ov << 2) | (xer_ca << 1);    RETURN();}void OPPROTO op_clear_xer_ov (void){    xer_so = 0;    xer_ov = 0;    RETURN();}void OPPROTO op_clear_xer_ca (void){    xer_ca = 0;    RETURN();}void OPPROTO op_load_xer_bc (void){    T1 = xer_bc;    RETURN();}void OPPROTO op_store_xer_bc (void){    xer_bc = T0;    RETURN();}void OPPROTO op_load_xer (void){    T0 = hreg_load_xer(env);    RETURN();}void OPPROTO op_store_xer (void){    hreg_store_xer(env, T0);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_store_pri (void){    do_store_pri(PARAM1);    RETURN();}#endif#if !defined(CONFIG_USER_ONLY)/* Segment registers load and store */void OPPROTO op_load_sr (void){    T0 = env->sr[T1];    RETURN();}void OPPROTO op_store_sr (void){    do_store_sr(env, T1, T0);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_load_slb (void){    T0 = ppc_load_slb(env, T1);    RETURN();}void OPPROTO op_store_slb (void){    ppc_store_slb(env, T1, T0);    RETURN();}#endif /* defined(TARGET_PPC64) */void OPPROTO op_load_sdr1 (void){    T0 = env->sdr1;    RETURN();}void OPPROTO op_store_sdr1 (void){    do_store_sdr1(env, T0);    RETURN();}#if defined (TARGET_PPC64)void OPPROTO op_load_asr (void){    T0 = env->asr;    RETURN();}void OPPROTO op_store_asr (void){    ppc_store_asr(env, T0);    RETURN();}#endifvoid OPPROTO op_load_msr (void){    T0 = env->msr;    RETURN();}void OPPROTO op_store_msr (void){    do_store_msr();    RETURN();}#if defined (TARGET_PPC64)void OPPROTO op_store_msr_32 (void){    T0 = (env->msr & ~0xFFFFFFFFULL) | (T0 & 0xFFFFFFFF);    do_store_msr();    RETURN();}#endifvoid OPPROTO op_update_riee (void){    /* We don't call do_store_msr here as we won't trigger     * any special case nor change hflags     */    T0 &= (1 << MSR_RI) | (1 << MSR_EE);    env->msr &= ~(1 << MSR_RI) | (1 << MSR_EE);    env->msr |= T0;    RETURN();}#endif/* SPR */void OPPROTO op_load_spr (void){    T0 = env->spr[PARAM1];    RETURN();}void OPPROTO op_store_spr (void){    env->spr[PARAM1] = T0;    RETURN();}void OPPROTO op_load_dump_spr (void){    T0 = ppc_load_dump_spr(PARAM1);    RETURN();}void OPPROTO op_store_dump_spr (void){    ppc_store_dump_spr(PARAM1, T0);    RETURN();}void OPPROTO op_mask_spr (void){    env->spr[PARAM1] &= ~T0;    RETURN();}void OPPROTO op_load_lr (void){    T0 = env->lr;    RETURN();}void OPPROTO op_store_lr (void){    env->lr = T0;    RETURN();}void OPPROTO op_load_ctr (void){    T0 = env->ctr;    RETURN();}void OPPROTO op_store_ctr (void){    env->ctr = T0;    RETURN();}void OPPROTO op_load_tbl (void){    T0 = cpu_ppc_load_tbl(env);    RETURN();}void OPPROTO op_load_tbu (void){    T0 = cpu_ppc_load_tbu(env);    RETURN();}void OPPROTO op_load_atbl (void){    T0 = cpu_ppc_load_atbl(env);    RETURN();}void OPPROTO op_load_atbu (void){    T0 = cpu_ppc_load_atbu(env);    RETURN();}#if !defined(CONFIG_USER_ONLY)void OPPROTO op_store_tbl (void){    cpu_ppc_store_tbl(env, T0);    RETURN();}void OPPROTO op_store_tbu (void){    cpu_ppc_store_tbu(env, T0);    RETURN();}void OPPROTO op_store_atbl (void){    cpu_ppc_store_atbl(env, T0);    RETURN();}void OPPROTO op_store_atbu (void){    cpu_ppc_store_atbu(env, T0);    RETURN();}void OPPROTO op_load_decr (void){    T0 = cpu_ppc_load_decr(env);    RETURN();}void OPPROTO op_store_decr (void){    cpu_ppc_store_decr(env, T0);    RETURN();}void OPPROTO op_load_ibat (void){    T0 = env->IBAT[PARAM1][PARAM2];    RETURN();}void OPPROTO op_store_ibatu (void){    do_store_ibatu(env, PARAM1, T0);    RETURN();}void OPPROTO op_store_ibatl (void){#if 1    env->IBAT[1][PARAM1] = T0;#else    do_store_ibatl(env, PARAM1, T0);#endif    RETURN();}void OPPROTO op_load_dbat (void){    T0 = env->DBAT[PARAM1][PARAM2];    RETURN();}void OPPROTO op_store_dbatu (void){    do_store_dbatu(env, PARAM1, T0);    RETURN();}void OPPROTO op_store_dbatl (void){#if 1    env->DBAT[1][PARAM1] = T0;#else    do_store_dbatl(env, PARAM1, T0);#endif    RETURN();}#endif /* !defined(CONFIG_USER_ONLY) *//* FPSCR */#ifdef CONFIG_SOFTFLOATvoid OPPROTO op_reset_fpstatus (void){    env->fp_status.float_exception_flags = 0;    RETURN();}#endifvoid OPPROTO op_compute_fprf (void){    do_compute_fprf(PARAM1);    RETURN();}#ifdef CONFIG_SOFTFLOATvoid OPPROTO op_float_check_status (void){    do_float_check_status();    RETURN();}#elsevoid OPPROTO op_float_check_status (void){    if (env->exception_index == POWERPC_EXCP_PROGRAM &&        (env->error_code & POWERPC_EXCP_FP)) {        /* Differred floating-point exception after target FPR update */        if (msr_fe0 != 0 || msr_fe1 != 0)            do_raise_exception_err(env->exception_index, env->error_code);    }    RETURN();}#endif#if defined(WORDS_BIGENDIAN)#define WORD0 0#define WORD1 1#else#define WORD0 1#define WORD1 0#endifvoid OPPROTO op_load_fpscr_FT0 (void){    /* The 32 MSB of the target fpr are undefined.     * They'll be zero...     */    union {        float64 d;        struct {            uint32_t u[2];        } s;    } u;    u.s.u[WORD0] = 0;    u.s.u[WORD1] = env->fpscr;    FT0 = u.d;    RETURN();}void OPPROTO op_set_FT0 (void){    union {        float64 d;        struct {            uint32_t u[2];        } s;    } u;    u.s.u[WORD0] = 0;    u.s.u[WORD1] = PARAM1;    FT0 = u.d;    RETURN();}#undef WORD0#undef WORD1void OPPROTO op_load_fpscr_T0 (void){    T0 = (env->fpscr >> PARAM1) & 0xF;    RETURN();}void OPPROTO op_load_fpcc (void){    T0 = fpscr_fpcc;    RETURN();}void OPPROTO op_fpscr_resetbit (void){    env->fpscr &= PARAM1;    RETURN();}void OPPROTO op_fpscr_setbit (void){    do_fpscr_setbit(PARAM1);    RETURN();}void OPPROTO op_store_fpscr (void){    do_store_fpscr(PARAM1);    RETURN();}/* Branch */#define EIP env->nipvoid OPPROTO op_setlr (void){    env->lr = (uint32_t)PARAM1;    RETURN();}#if defined (TARGET_PPC64)void OPPROTO op_setlr_64 (void){    env->lr = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;    RETURN();}#endifvoid OPPROTO op_goto_tb0 (void){    GOTO_TB(op_goto_tb0, PARAM1, 0);}void OPPROTO op_goto_tb1 (void){    GOTO_TB(op_goto_tb1, PARAM1, 1);}void OPPROTO op_b_T1 (void){    env->nip = (uint32_t)(T1 & ~3);    RETURN();}#if defined (TARGET_PPC64)void OPPROTO op_b_T1_64 (void){    env->nip = (uint64_t)(T1 & ~3);    RETURN();}#endifvoid OPPROTO op_jz_T0 (void){    if (!T0)        GOTO_LABEL_PARAM(1);    RETURN();}void OPPROTO op_btest_T1 (void){    if (T0) {        env->nip = (uint32_t)(T1 & ~3);    } else {        env->nip = (uint32_t)PARAM1;    }    RETURN();}#if defined (TARGET_PPC64)void OPPROTO op_btest_T1_64 (void){    if (T0) {        env->nip = (uint64_t)(T1 & ~3);    } else {        env->nip = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;    }    RETURN();}#endifvoid OPPROTO op_movl_T1_ctr (void){    T1 = env->ctr;    RETURN();}void OPPROTO op_movl_T1_lr (void){    T1 = env->lr;    RETURN();}/* tests with result in T0 */void OPPROTO op_test_ctr (void){    T0 = (uint32_t)env->ctr;    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_test_ctr_64 (void){    T0 = (uint64_t)env->ctr;    RETURN();}#endifvoid OPPROTO op_test_ctr_true (void){    T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) != 0);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_test_ctr_true_64 (void){    T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) != 0);    RETURN();}#endifvoid OPPROTO op_test_ctr_false (void){    T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) == 0);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_test_ctr_false_64 (void){    T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) == 0);    RETURN();}#endifvoid OPPROTO op_test_ctrz (void){    T0 = ((uint32_t)env->ctr == 0);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_test_ctrz_64 (void){    T0 = ((uint64_t)env->ctr == 0);    RETURN();}#endifvoid OPPROTO op_test_ctrz_true (void){    T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) != 0);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_test_ctrz_true_64 (void){    T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) != 0);    RETURN();}#endifvoid OPPROTO op_test_ctrz_false (void){    T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) == 0);    RETURN();}#if defined(TARGET_PPC64)void OPPROTO op_test_ctrz_false_64 (void){    T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) == 0);    RETURN();}#endifvoid OPPROTO op_test_true (void){    T0 = (T0 & PARAM1);    RETURN();}void OPPROTO op_test_false (void){    T0 = ((T0 & PARAM1) == 0);    RETURN();}/* CTR maintenance */void OPPROTO op_dec_ctr (void){    env->ctr--;    RETURN();}/***                           Integer arithmetic                          ***//* add */void OPPROTO op_add (void){    T0 += T1;    RETURN();}void OPPROTO op_check_addo (void){    xer_ov = (((uint32_t)T2 ^ (uint32_t)T1 ^ UINT32_MAX) &              ((uint32_t)T2 ^ (uint32_t)T0)) >> 31;    xer_so |= xer_ov;    RETURN();}