forked from mirror/qemu
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4954 lines
144 KiB
C++
4954 lines
144 KiB
C++
/*
|
|
* MIPS emulation for QEMU - nanoMIPS translation routines
|
|
*
|
|
* Copyright (c) 2004-2005 Jocelyn Mayer
|
|
* Copyright (c) 2006 Marius Groeger (FPU operations)
|
|
* Copyright (c) 2006 Thiemo Seufer (MIPS32R2 support)
|
|
* Copyright (c) 2009 CodeSourcery (MIPS16 and microMIPS support)
|
|
* Copyright (c) 2012 Jia Liu & Dongxue Zhang (MIPS ASE DSP support)
|
|
*
|
|
* SPDX-License-Identifier: LGPL-2.1-or-later
|
|
*/
|
|
|
|
/* MAJOR, P16, and P32 pools opcodes */
|
|
enum {
|
|
NM_P_ADDIU = 0x00,
|
|
NM_ADDIUPC = 0x01,
|
|
NM_MOVE_BALC = 0x02,
|
|
NM_P16_MV = 0x04,
|
|
NM_LW16 = 0x05,
|
|
NM_BC16 = 0x06,
|
|
NM_P16_SR = 0x07,
|
|
|
|
NM_POOL32A = 0x08,
|
|
NM_P_BAL = 0x0a,
|
|
NM_P16_SHIFT = 0x0c,
|
|
NM_LWSP16 = 0x0d,
|
|
NM_BALC16 = 0x0e,
|
|
NM_P16_4X4 = 0x0f,
|
|
|
|
NM_P_GP_W = 0x10,
|
|
NM_P_GP_BH = 0x11,
|
|
NM_P_J = 0x12,
|
|
NM_P16C = 0x14,
|
|
NM_LWGP16 = 0x15,
|
|
NM_P16_LB = 0x17,
|
|
|
|
NM_P48I = 0x18,
|
|
NM_P16_A1 = 0x1c,
|
|
NM_LW4X4 = 0x1d,
|
|
NM_P16_LH = 0x1f,
|
|
|
|
NM_P_U12 = 0x20,
|
|
NM_P_LS_U12 = 0x21,
|
|
NM_P_BR1 = 0x22,
|
|
NM_P16_A2 = 0x24,
|
|
NM_SW16 = 0x25,
|
|
NM_BEQZC16 = 0x26,
|
|
|
|
NM_POOL32F = 0x28,
|
|
NM_P_LS_S9 = 0x29,
|
|
NM_P_BR2 = 0x2a,
|
|
|
|
NM_P16_ADDU = 0x2c,
|
|
NM_SWSP16 = 0x2d,
|
|
NM_BNEZC16 = 0x2e,
|
|
NM_MOVEP = 0x2f,
|
|
|
|
NM_POOL32S = 0x30,
|
|
NM_P_BRI = 0x32,
|
|
NM_LI16 = 0x34,
|
|
NM_SWGP16 = 0x35,
|
|
NM_P16_BR = 0x36,
|
|
|
|
NM_P_LUI = 0x38,
|
|
NM_ANDI16 = 0x3c,
|
|
NM_SW4X4 = 0x3d,
|
|
NM_MOVEPREV = 0x3f,
|
|
};
|
|
|
|
/* POOL32A instruction pool */
|
|
enum {
|
|
NM_POOL32A0 = 0x00,
|
|
NM_SPECIAL2 = 0x01,
|
|
NM_COP2_1 = 0x02,
|
|
NM_UDI = 0x03,
|
|
NM_POOL32A5 = 0x05,
|
|
NM_POOL32A7 = 0x07,
|
|
};
|
|
|
|
/* P.GP.W instruction pool */
|
|
enum {
|
|
NM_ADDIUGP_W = 0x00,
|
|
NM_LWGP = 0x02,
|
|
NM_SWGP = 0x03,
|
|
};
|
|
|
|
/* P48I instruction pool */
|
|
enum {
|
|
NM_LI48 = 0x00,
|
|
NM_ADDIU48 = 0x01,
|
|
NM_ADDIUGP48 = 0x02,
|
|
NM_ADDIUPC48 = 0x03,
|
|
NM_LWPC48 = 0x0b,
|
|
NM_SWPC48 = 0x0f,
|
|
};
|
|
|
|
/* P.U12 instruction pool */
|
|
enum {
|
|
NM_ORI = 0x00,
|
|
NM_XORI = 0x01,
|
|
NM_ANDI = 0x02,
|
|
NM_P_SR = 0x03,
|
|
NM_SLTI = 0x04,
|
|
NM_SLTIU = 0x05,
|
|
NM_SEQI = 0x06,
|
|
NM_ADDIUNEG = 0x08,
|
|
NM_P_SHIFT = 0x0c,
|
|
NM_P_ROTX = 0x0d,
|
|
NM_P_INS = 0x0e,
|
|
NM_P_EXT = 0x0f,
|
|
};
|
|
|
|
/* POOL32F instruction pool */
|
|
enum {
|
|
NM_POOL32F_0 = 0x00,
|
|
NM_POOL32F_3 = 0x03,
|
|
NM_POOL32F_5 = 0x05,
|
|
};
|
|
|
|
/* POOL32S instruction pool */
|
|
enum {
|
|
NM_POOL32S_0 = 0x00,
|
|
NM_POOL32S_4 = 0x04,
|
|
};
|
|
|
|
/* P.LUI instruction pool */
|
|
enum {
|
|
NM_LUI = 0x00,
|
|
NM_ALUIPC = 0x01,
|
|
};
|
|
|
|
/* P.GP.BH instruction pool */
|
|
enum {
|
|
NM_LBGP = 0x00,
|
|
NM_SBGP = 0x01,
|
|
NM_LBUGP = 0x02,
|
|
NM_ADDIUGP_B = 0x03,
|
|
NM_P_GP_LH = 0x04,
|
|
NM_P_GP_SH = 0x05,
|
|
NM_P_GP_CP1 = 0x06,
|
|
};
|
|
|
|
/* P.LS.U12 instruction pool */
|
|
enum {
|
|
NM_LB = 0x00,
|
|
NM_SB = 0x01,
|
|
NM_LBU = 0x02,
|
|
NM_P_PREFU12 = 0x03,
|
|
NM_LH = 0x04,
|
|
NM_SH = 0x05,
|
|
NM_LHU = 0x06,
|
|
NM_LWU = 0x07,
|
|
NM_LW = 0x08,
|
|
NM_SW = 0x09,
|
|
NM_LWC1 = 0x0a,
|
|
NM_SWC1 = 0x0b,
|
|
NM_LDC1 = 0x0e,
|
|
NM_SDC1 = 0x0f,
|
|
};
|
|
|
|
/* P.LS.S9 instruction pool */
|
|
enum {
|
|
NM_P_LS_S0 = 0x00,
|
|
NM_P_LS_S1 = 0x01,
|
|
NM_P_LS_E0 = 0x02,
|
|
NM_P_LS_WM = 0x04,
|
|
NM_P_LS_UAWM = 0x05,
|
|
};
|
|
|
|
/* P.BAL instruction pool */
|
|
enum {
|
|
NM_BC = 0x00,
|
|
NM_BALC = 0x01,
|
|
};
|
|
|
|
/* P.J instruction pool */
|
|
enum {
|
|
NM_JALRC = 0x00,
|
|
NM_JALRC_HB = 0x01,
|
|
NM_P_BALRSC = 0x08,
|
|
};
|
|
|
|
/* P.BR1 instruction pool */
|
|
enum {
|
|
NM_BEQC = 0x00,
|
|
NM_P_BR3A = 0x01,
|
|
NM_BGEC = 0x02,
|
|
NM_BGEUC = 0x03,
|
|
};
|
|
|
|
/* P.BR2 instruction pool */
|
|
enum {
|
|
NM_BNEC = 0x00,
|
|
NM_BLTC = 0x02,
|
|
NM_BLTUC = 0x03,
|
|
};
|
|
|
|
/* P.BRI instruction pool */
|
|
enum {
|
|
NM_BEQIC = 0x00,
|
|
NM_BBEQZC = 0x01,
|
|
NM_BGEIC = 0x02,
|
|
NM_BGEIUC = 0x03,
|
|
NM_BNEIC = 0x04,
|
|
NM_BBNEZC = 0x05,
|
|
NM_BLTIC = 0x06,
|
|
NM_BLTIUC = 0x07,
|
|
};
|
|
|
|
/* P16.SHIFT instruction pool */
|
|
enum {
|
|
NM_SLL16 = 0x00,
|
|
NM_SRL16 = 0x01,
|
|
};
|
|
|
|
/* POOL16C instruction pool */
|
|
enum {
|
|
NM_POOL16C_0 = 0x00,
|
|
NM_LWXS16 = 0x01,
|
|
};
|
|
|
|
/* P16.A1 instruction pool */
|
|
enum {
|
|
NM_ADDIUR1SP = 0x01,
|
|
};
|
|
|
|
/* P16.A2 instruction pool */
|
|
enum {
|
|
NM_ADDIUR2 = 0x00,
|
|
NM_P_ADDIURS5 = 0x01,
|
|
};
|
|
|
|
/* P16.ADDU instruction pool */
|
|
enum {
|
|
NM_ADDU16 = 0x00,
|
|
NM_SUBU16 = 0x01,
|
|
};
|
|
|
|
/* P16.SR instruction pool */
|
|
enum {
|
|
NM_SAVE16 = 0x00,
|
|
NM_RESTORE_JRC16 = 0x01,
|
|
};
|
|
|
|
/* P16.4X4 instruction pool */
|
|
enum {
|
|
NM_ADDU4X4 = 0x00,
|
|
NM_MUL4X4 = 0x01,
|
|
};
|
|
|
|
/* P16.LB instruction pool */
|
|
enum {
|
|
NM_LB16 = 0x00,
|
|
NM_SB16 = 0x01,
|
|
NM_LBU16 = 0x02,
|
|
};
|
|
|
|
/* P16.LH instruction pool */
|
|
enum {
|
|
NM_LH16 = 0x00,
|
|
NM_SH16 = 0x01,
|
|
NM_LHU16 = 0x02,
|
|
};
|
|
|
|
/* P.RI instruction pool */
|
|
enum {
|
|
NM_SIGRIE = 0x00,
|
|
NM_P_SYSCALL = 0x01,
|
|
NM_BREAK = 0x02,
|
|
NM_SDBBP = 0x03,
|
|
};
|
|
|
|
/* POOL32A0 instruction pool */
|
|
enum {
|
|
NM_P_TRAP = 0x00,
|
|
NM_SEB = 0x01,
|
|
NM_SLLV = 0x02,
|
|
NM_MUL = 0x03,
|
|
NM_MFC0 = 0x06,
|
|
NM_MFHC0 = 0x07,
|
|
NM_SEH = 0x09,
|
|
NM_SRLV = 0x0a,
|
|
NM_MUH = 0x0b,
|
|
NM_MTC0 = 0x0e,
|
|
NM_MTHC0 = 0x0f,
|
|
NM_SRAV = 0x12,
|
|
NM_MULU = 0x13,
|
|
NM_ROTRV = 0x1a,
|
|
NM_MUHU = 0x1b,
|
|
NM_ADD = 0x22,
|
|
NM_DIV = 0x23,
|
|
NM_ADDU = 0x2a,
|
|
NM_MOD = 0x2b,
|
|
NM_SUB = 0x32,
|
|
NM_DIVU = 0x33,
|
|
NM_RDHWR = 0x38,
|
|
NM_SUBU = 0x3a,
|
|
NM_MODU = 0x3b,
|
|
NM_P_CMOVE = 0x42,
|
|
NM_FORK = 0x45,
|
|
NM_MFTR = 0x46,
|
|
NM_MFHTR = 0x47,
|
|
NM_AND = 0x4a,
|
|
NM_YIELD = 0x4d,
|
|
NM_MTTR = 0x4e,
|
|
NM_MTHTR = 0x4f,
|
|
NM_OR = 0x52,
|
|
NM_D_E_MT_VPE = 0x56,
|
|
NM_NOR = 0x5a,
|
|
NM_XOR = 0x62,
|
|
NM_SLT = 0x6a,
|
|
NM_P_SLTU = 0x72,
|
|
NM_SOV = 0x7a,
|
|
};
|
|
|
|
/* CRC32 instruction pool */
|
|
enum {
|
|
NM_CRC32B = 0x00,
|
|
NM_CRC32H = 0x01,
|
|
NM_CRC32W = 0x02,
|
|
NM_CRC32CB = 0x04,
|
|
NM_CRC32CH = 0x05,
|
|
NM_CRC32CW = 0x06,
|
|
};
|
|
|
|
/* POOL32A5 instruction pool */
|
|
enum {
|
|
NM_CMP_EQ_PH = 0x00,
|
|
NM_CMP_LT_PH = 0x08,
|
|
NM_CMP_LE_PH = 0x10,
|
|
NM_CMPGU_EQ_QB = 0x18,
|
|
NM_CMPGU_LT_QB = 0x20,
|
|
NM_CMPGU_LE_QB = 0x28,
|
|
NM_CMPGDU_EQ_QB = 0x30,
|
|
NM_CMPGDU_LT_QB = 0x38,
|
|
NM_CMPGDU_LE_QB = 0x40,
|
|
NM_CMPU_EQ_QB = 0x48,
|
|
NM_CMPU_LT_QB = 0x50,
|
|
NM_CMPU_LE_QB = 0x58,
|
|
NM_ADDQ_S_W = 0x60,
|
|
NM_SUBQ_S_W = 0x68,
|
|
NM_ADDSC = 0x70,
|
|
NM_ADDWC = 0x78,
|
|
|
|
NM_ADDQ_S_PH = 0x01,
|
|
NM_ADDQH_R_PH = 0x09,
|
|
NM_ADDQH_R_W = 0x11,
|
|
NM_ADDU_S_QB = 0x19,
|
|
NM_ADDU_S_PH = 0x21,
|
|
NM_ADDUH_R_QB = 0x29,
|
|
NM_SHRAV_R_PH = 0x31,
|
|
NM_SHRAV_R_QB = 0x39,
|
|
NM_SUBQ_S_PH = 0x41,
|
|
NM_SUBQH_R_PH = 0x49,
|
|
NM_SUBQH_R_W = 0x51,
|
|
NM_SUBU_S_QB = 0x59,
|
|
NM_SUBU_S_PH = 0x61,
|
|
NM_SUBUH_R_QB = 0x69,
|
|
NM_SHLLV_S_PH = 0x71,
|
|
NM_PRECR_SRA_R_PH_W = 0x79,
|
|
|
|
NM_MULEU_S_PH_QBL = 0x12,
|
|
NM_MULEU_S_PH_QBR = 0x1a,
|
|
NM_MULQ_RS_PH = 0x22,
|
|
NM_MULQ_S_PH = 0x2a,
|
|
NM_MULQ_RS_W = 0x32,
|
|
NM_MULQ_S_W = 0x3a,
|
|
NM_APPEND = 0x42,
|
|
NM_MODSUB = 0x52,
|
|
NM_SHRAV_R_W = 0x5a,
|
|
NM_SHRLV_PH = 0x62,
|
|
NM_SHRLV_QB = 0x6a,
|
|
NM_SHLLV_QB = 0x72,
|
|
NM_SHLLV_S_W = 0x7a,
|
|
|
|
NM_SHILO = 0x03,
|
|
|
|
NM_MULEQ_S_W_PHL = 0x04,
|
|
NM_MULEQ_S_W_PHR = 0x0c,
|
|
|
|
NM_MUL_S_PH = 0x05,
|
|
NM_PRECR_QB_PH = 0x0d,
|
|
NM_PRECRQ_QB_PH = 0x15,
|
|
NM_PRECRQ_PH_W = 0x1d,
|
|
NM_PRECRQ_RS_PH_W = 0x25,
|
|
NM_PRECRQU_S_QB_PH = 0x2d,
|
|
NM_PACKRL_PH = 0x35,
|
|
NM_PICK_QB = 0x3d,
|
|
NM_PICK_PH = 0x45,
|
|
|
|
NM_SHRA_R_W = 0x5e,
|
|
NM_SHRA_R_PH = 0x66,
|
|
NM_SHLL_S_PH = 0x76,
|
|
NM_SHLL_S_W = 0x7e,
|
|
|
|
NM_REPL_PH = 0x07
|
|
};
|
|
|
|
/* POOL32A7 instruction pool */
|
|
enum {
|
|
NM_P_LSX = 0x00,
|
|
NM_LSA = 0x01,
|
|
NM_EXTW = 0x03,
|
|
NM_POOL32AXF = 0x07,
|
|
};
|
|
|
|
/* P.SR instruction pool */
|
|
enum {
|
|
NM_PP_SR = 0x00,
|
|
NM_P_SR_F = 0x01,
|
|
};
|
|
|
|
/* P.SHIFT instruction pool */
|
|
enum {
|
|
NM_P_SLL = 0x00,
|
|
NM_SRL = 0x02,
|
|
NM_SRA = 0x04,
|
|
NM_ROTR = 0x06,
|
|
};
|
|
|
|
/* P.ROTX instruction pool */
|
|
enum {
|
|
NM_ROTX = 0x00,
|
|
};
|
|
|
|
/* P.INS instruction pool */
|
|
enum {
|
|
NM_INS = 0x00,
|
|
};
|
|
|
|
/* P.EXT instruction pool */
|
|
enum {
|
|
NM_EXT = 0x00,
|
|
};
|
|
|
|
/* POOL32F_0 (fmt) instruction pool */
|
|
enum {
|
|
NM_RINT_S = 0x04,
|
|
NM_RINT_D = 0x44,
|
|
NM_ADD_S = 0x06,
|
|
NM_SELEQZ_S = 0x07,
|
|
NM_SELEQZ_D = 0x47,
|
|
NM_CLASS_S = 0x0c,
|
|
NM_CLASS_D = 0x4c,
|
|
NM_SUB_S = 0x0e,
|
|
NM_SELNEZ_S = 0x0f,
|
|
NM_SELNEZ_D = 0x4f,
|
|
NM_MUL_S = 0x16,
|
|
NM_SEL_S = 0x17,
|
|
NM_SEL_D = 0x57,
|
|
NM_DIV_S = 0x1e,
|
|
NM_ADD_D = 0x26,
|
|
NM_SUB_D = 0x2e,
|
|
NM_MUL_D = 0x36,
|
|
NM_MADDF_S = 0x37,
|
|
NM_MADDF_D = 0x77,
|
|
NM_DIV_D = 0x3e,
|
|
NM_MSUBF_S = 0x3f,
|
|
NM_MSUBF_D = 0x7f,
|
|
};
|
|
|
|
/* POOL32F_3 instruction pool */
|
|
enum {
|
|
NM_MIN_FMT = 0x00,
|
|
NM_MAX_FMT = 0x01,
|
|
NM_MINA_FMT = 0x04,
|
|
NM_MAXA_FMT = 0x05,
|
|
NM_POOL32FXF = 0x07,
|
|
};
|
|
|
|
/* POOL32F_5 instruction pool */
|
|
enum {
|
|
NM_CMP_CONDN_S = 0x00,
|
|
NM_CMP_CONDN_D = 0x02,
|
|
};
|
|
|
|
/* P.GP.LH instruction pool */
|
|
enum {
|
|
NM_LHGP = 0x00,
|
|
NM_LHUGP = 0x01,
|
|
};
|
|
|
|
/* P.GP.SH instruction pool */
|
|
enum {
|
|
NM_SHGP = 0x00,
|
|
};
|
|
|
|
/* P.GP.CP1 instruction pool */
|
|
enum {
|
|
NM_LWC1GP = 0x00,
|
|
NM_SWC1GP = 0x01,
|
|
NM_LDC1GP = 0x02,
|
|
NM_SDC1GP = 0x03,
|
|
};
|
|
|
|
/* P.LS.S0 instruction pool */
|
|
enum {
|
|
NM_LBS9 = 0x00,
|
|
NM_LHS9 = 0x04,
|
|
NM_LWS9 = 0x08,
|
|
NM_LDS9 = 0x0c,
|
|
|
|
NM_SBS9 = 0x01,
|
|
NM_SHS9 = 0x05,
|
|
NM_SWS9 = 0x09,
|
|
NM_SDS9 = 0x0d,
|
|
|
|
NM_LBUS9 = 0x02,
|
|
NM_LHUS9 = 0x06,
|
|
NM_LWC1S9 = 0x0a,
|
|
NM_LDC1S9 = 0x0e,
|
|
|
|
NM_P_PREFS9 = 0x03,
|
|
NM_LWUS9 = 0x07,
|
|
NM_SWC1S9 = 0x0b,
|
|
NM_SDC1S9 = 0x0f,
|
|
};
|
|
|
|
/* P.LS.S1 instruction pool */
|
|
enum {
|
|
NM_ASET_ACLR = 0x02,
|
|
NM_UALH = 0x04,
|
|
NM_UASH = 0x05,
|
|
NM_CACHE = 0x07,
|
|
NM_P_LL = 0x0a,
|
|
NM_P_SC = 0x0b,
|
|
};
|
|
|
|
/* P.LS.E0 instruction pool */
|
|
enum {
|
|
NM_LBE = 0x00,
|
|
NM_SBE = 0x01,
|
|
NM_LBUE = 0x02,
|
|
NM_P_PREFE = 0x03,
|
|
NM_LHE = 0x04,
|
|
NM_SHE = 0x05,
|
|
NM_LHUE = 0x06,
|
|
NM_CACHEE = 0x07,
|
|
NM_LWE = 0x08,
|
|
NM_SWE = 0x09,
|
|
NM_P_LLE = 0x0a,
|
|
NM_P_SCE = 0x0b,
|
|
};
|
|
|
|
/* P.PREFE instruction pool */
|
|
enum {
|
|
NM_SYNCIE = 0x00,
|
|
NM_PREFE = 0x01,
|
|
};
|
|
|
|
/* P.LLE instruction pool */
|
|
enum {
|
|
NM_LLE = 0x00,
|
|
NM_LLWPE = 0x01,
|
|
};
|
|
|
|
/* P.SCE instruction pool */
|
|
enum {
|
|
NM_SCE = 0x00,
|
|
NM_SCWPE = 0x01,
|
|
};
|
|
|
|
/* P.LS.WM instruction pool */
|
|
enum {
|
|
NM_LWM = 0x00,
|
|
NM_SWM = 0x01,
|
|
};
|
|
|
|
/* P.LS.UAWM instruction pool */
|
|
enum {
|
|
NM_UALWM = 0x00,
|
|
NM_UASWM = 0x01,
|
|
};
|
|
|
|
/* P.BR3A instruction pool */
|
|
enum {
|
|
NM_BC1EQZC = 0x00,
|
|
NM_BC1NEZC = 0x01,
|
|
NM_BC2EQZC = 0x02,
|
|
NM_BC2NEZC = 0x03,
|
|
NM_BPOSGE32C = 0x04,
|
|
};
|
|
|
|
/* P16.RI instruction pool */
|
|
enum {
|
|
NM_P16_SYSCALL = 0x01,
|
|
NM_BREAK16 = 0x02,
|
|
NM_SDBBP16 = 0x03,
|
|
};
|
|
|
|
/* POOL16C_0 instruction pool */
|
|
enum {
|
|
NM_POOL16C_00 = 0x00,
|
|
};
|
|
|
|
/* P16.JRC instruction pool */
|
|
enum {
|
|
NM_JRC = 0x00,
|
|
NM_JALRC16 = 0x01,
|
|
};
|
|
|
|
/* P.SYSCALL instruction pool */
|
|
enum {
|
|
NM_SYSCALL = 0x00,
|
|
NM_HYPCALL = 0x01,
|
|
};
|
|
|
|
/* P.TRAP instruction pool */
|
|
enum {
|
|
NM_TEQ = 0x00,
|
|
NM_TNE = 0x01,
|
|
};
|
|
|
|
/* P.CMOVE instruction pool */
|
|
enum {
|
|
NM_MOVZ = 0x00,
|
|
NM_MOVN = 0x01,
|
|
};
|
|
|
|
/* POOL32Axf instruction pool */
|
|
enum {
|
|
NM_POOL32AXF_1 = 0x01,
|
|
NM_POOL32AXF_2 = 0x02,
|
|
NM_POOL32AXF_4 = 0x04,
|
|
NM_POOL32AXF_5 = 0x05,
|
|
NM_POOL32AXF_7 = 0x07,
|
|
};
|
|
|
|
/* POOL32Axf_1 instruction pool */
|
|
enum {
|
|
NM_POOL32AXF_1_0 = 0x00,
|
|
NM_POOL32AXF_1_1 = 0x01,
|
|
NM_POOL32AXF_1_3 = 0x03,
|
|
NM_POOL32AXF_1_4 = 0x04,
|
|
NM_POOL32AXF_1_5 = 0x05,
|
|
NM_POOL32AXF_1_7 = 0x07,
|
|
};
|
|
|
|
/* POOL32Axf_2 instruction pool */
|
|
enum {
|
|
NM_POOL32AXF_2_0_7 = 0x00,
|
|
NM_POOL32AXF_2_8_15 = 0x01,
|
|
NM_POOL32AXF_2_16_23 = 0x02,
|
|
NM_POOL32AXF_2_24_31 = 0x03,
|
|
};
|
|
|
|
/* POOL32Axf_7 instruction pool */
|
|
enum {
|
|
NM_SHRA_R_QB = 0x0,
|
|
NM_SHRL_PH = 0x1,
|
|
NM_REPL_QB = 0x2,
|
|
};
|
|
|
|
/* POOL32Axf_1_0 instruction pool */
|
|
enum {
|
|
NM_MFHI = 0x0,
|
|
NM_MFLO = 0x1,
|
|
NM_MTHI = 0x2,
|
|
NM_MTLO = 0x3,
|
|
};
|
|
|
|
/* POOL32Axf_1_1 instruction pool */
|
|
enum {
|
|
NM_MTHLIP = 0x0,
|
|
NM_SHILOV = 0x1,
|
|
};
|
|
|
|
/* POOL32Axf_1_3 instruction pool */
|
|
enum {
|
|
NM_RDDSP = 0x0,
|
|
NM_WRDSP = 0x1,
|
|
NM_EXTP = 0x2,
|
|
NM_EXTPDP = 0x3,
|
|
};
|
|
|
|
/* POOL32Axf_1_4 instruction pool */
|
|
enum {
|
|
NM_SHLL_QB = 0x0,
|
|
NM_SHRL_QB = 0x1,
|
|
};
|
|
|
|
/* POOL32Axf_1_5 instruction pool */
|
|
enum {
|
|
NM_MAQ_S_W_PHR = 0x0,
|
|
NM_MAQ_S_W_PHL = 0x1,
|
|
NM_MAQ_SA_W_PHR = 0x2,
|
|
NM_MAQ_SA_W_PHL = 0x3,
|
|
};
|
|
|
|
/* POOL32Axf_1_7 instruction pool */
|
|
enum {
|
|
NM_EXTR_W = 0x0,
|
|
NM_EXTR_R_W = 0x1,
|
|
NM_EXTR_RS_W = 0x2,
|
|
NM_EXTR_S_H = 0x3,
|
|
};
|
|
|
|
/* POOL32Axf_2_0_7 instruction pool */
|
|
enum {
|
|
NM_DPA_W_PH = 0x0,
|
|
NM_DPAQ_S_W_PH = 0x1,
|
|
NM_DPS_W_PH = 0x2,
|
|
NM_DPSQ_S_W_PH = 0x3,
|
|
NM_BALIGN = 0x4,
|
|
NM_MADD = 0x5,
|
|
NM_MULT = 0x6,
|
|
NM_EXTRV_W = 0x7,
|
|
};
|
|
|
|
/* POOL32Axf_2_8_15 instruction pool */
|
|
enum {
|
|
NM_DPAX_W_PH = 0x0,
|
|
NM_DPAQ_SA_L_W = 0x1,
|
|
NM_DPSX_W_PH = 0x2,
|
|
NM_DPSQ_SA_L_W = 0x3,
|
|
NM_MADDU = 0x5,
|
|
NM_MULTU = 0x6,
|
|
NM_EXTRV_R_W = 0x7,
|
|
};
|
|
|
|
/* POOL32Axf_2_16_23 instruction pool */
|
|
enum {
|
|
NM_DPAU_H_QBL = 0x0,
|
|
NM_DPAQX_S_W_PH = 0x1,
|
|
NM_DPSU_H_QBL = 0x2,
|
|
NM_DPSQX_S_W_PH = 0x3,
|
|
NM_EXTPV = 0x4,
|
|
NM_MSUB = 0x5,
|
|
NM_MULSA_W_PH = 0x6,
|
|
NM_EXTRV_RS_W = 0x7,
|
|
};
|
|
|
|
/* POOL32Axf_2_24_31 instruction pool */
|
|
enum {
|
|
NM_DPAU_H_QBR = 0x0,
|
|
NM_DPAQX_SA_W_PH = 0x1,
|
|
NM_DPSU_H_QBR = 0x2,
|
|
NM_DPSQX_SA_W_PH = 0x3,
|
|
NM_EXTPDPV = 0x4,
|
|
NM_MSUBU = 0x5,
|
|
NM_MULSAQ_S_W_PH = 0x6,
|
|
NM_EXTRV_S_H = 0x7,
|
|
};
|
|
|
|
/* POOL32Axf_{4, 5} instruction pool */
|
|
enum {
|
|
NM_CLO = 0x25,
|
|
NM_CLZ = 0x2d,
|
|
|
|
NM_TLBP = 0x01,
|
|
NM_TLBR = 0x09,
|
|
NM_TLBWI = 0x11,
|
|
NM_TLBWR = 0x19,
|
|
NM_TLBINV = 0x03,
|
|
NM_TLBINVF = 0x0b,
|
|
NM_DI = 0x23,
|
|
NM_EI = 0x2b,
|
|
NM_RDPGPR = 0x70,
|
|
NM_WRPGPR = 0x78,
|
|
NM_WAIT = 0x61,
|
|
NM_DERET = 0x71,
|
|
NM_ERETX = 0x79,
|
|
|
|
/* nanoMIPS DSP instructions */
|
|
NM_ABSQ_S_QB = 0x00,
|
|
NM_ABSQ_S_PH = 0x08,
|
|
NM_ABSQ_S_W = 0x10,
|
|
NM_PRECEQ_W_PHL = 0x28,
|
|
NM_PRECEQ_W_PHR = 0x30,
|
|
NM_PRECEQU_PH_QBL = 0x38,
|
|
NM_PRECEQU_PH_QBR = 0x48,
|
|
NM_PRECEU_PH_QBL = 0x58,
|
|
NM_PRECEU_PH_QBR = 0x68,
|
|
NM_PRECEQU_PH_QBLA = 0x39,
|
|
NM_PRECEQU_PH_QBRA = 0x49,
|
|
NM_PRECEU_PH_QBLA = 0x59,
|
|
NM_PRECEU_PH_QBRA = 0x69,
|
|
NM_REPLV_PH = 0x01,
|
|
NM_REPLV_QB = 0x09,
|
|
NM_BITREV = 0x18,
|
|
NM_INSV = 0x20,
|
|
NM_RADDU_W_QB = 0x78,
|
|
|
|
NM_BITSWAP = 0x05,
|
|
NM_WSBH = 0x3d,
|
|
};
|
|
|
|
/* PP.SR instruction pool */
|
|
enum {
|
|
NM_SAVE = 0x00,
|
|
NM_RESTORE = 0x02,
|
|
NM_RESTORE_JRC = 0x03,
|
|
};
|
|
|
|
/* P.SR.F instruction pool */
|
|
enum {
|
|
NM_SAVEF = 0x00,
|
|
NM_RESTOREF = 0x01,
|
|
};
|
|
|
|
/* P16.SYSCALL instruction pool */
|
|
enum {
|
|
NM_SYSCALL16 = 0x00,
|
|
NM_HYPCALL16 = 0x01,
|
|
};
|
|
|
|
/* POOL16C_00 instruction pool */
|
|
enum {
|
|
NM_NOT16 = 0x00,
|
|
NM_XOR16 = 0x01,
|
|
NM_AND16 = 0x02,
|
|
NM_OR16 = 0x03,
|
|
};
|
|
|
|
/* PP.LSX and PP.LSXS instruction pool */
|
|
enum {
|
|
NM_LBX = 0x00,
|
|
NM_LHX = 0x04,
|
|
NM_LWX = 0x08,
|
|
NM_LDX = 0x0c,
|
|
|
|
NM_SBX = 0x01,
|
|
NM_SHX = 0x05,
|
|
NM_SWX = 0x09,
|
|
NM_SDX = 0x0d,
|
|
|
|
NM_LBUX = 0x02,
|
|
NM_LHUX = 0x06,
|
|
NM_LWC1X = 0x0a,
|
|
NM_LDC1X = 0x0e,
|
|
|
|
NM_LWUX = 0x07,
|
|
NM_SWC1X = 0x0b,
|
|
NM_SDC1X = 0x0f,
|
|
|
|
NM_LHXS = 0x04,
|
|
NM_LWXS = 0x08,
|
|
NM_LDXS = 0x0c,
|
|
|
|
NM_SHXS = 0x05,
|
|
NM_SWXS = 0x09,
|
|
NM_SDXS = 0x0d,
|
|
|
|
NM_LHUXS = 0x06,
|
|
NM_LWC1XS = 0x0a,
|
|
NM_LDC1XS = 0x0e,
|
|
|
|
NM_LWUXS = 0x07,
|
|
NM_SWC1XS = 0x0b,
|
|
NM_SDC1XS = 0x0f,
|
|
};
|
|
|
|
/* ERETx instruction pool */
|
|
enum {
|
|
NM_ERET = 0x00,
|
|
NM_ERETNC = 0x01,
|
|
};
|
|
|
|
/* POOL32FxF_{0, 1} insturction pool */
|
|
enum {
|
|
NM_CFC1 = 0x40,
|
|
NM_CTC1 = 0x60,
|
|
NM_MFC1 = 0x80,
|
|
NM_MTC1 = 0xa0,
|
|
NM_MFHC1 = 0xc0,
|
|
NM_MTHC1 = 0xe0,
|
|
|
|
NM_CVT_S_PL = 0x84,
|
|
NM_CVT_S_PU = 0xa4,
|
|
|
|
NM_CVT_L_S = 0x004,
|
|
NM_CVT_L_D = 0x104,
|
|
NM_CVT_W_S = 0x024,
|
|
NM_CVT_W_D = 0x124,
|
|
|
|
NM_RSQRT_S = 0x008,
|
|
NM_RSQRT_D = 0x108,
|
|
|
|
NM_SQRT_S = 0x028,
|
|
NM_SQRT_D = 0x128,
|
|
|
|
NM_RECIP_S = 0x048,
|
|
NM_RECIP_D = 0x148,
|
|
|
|
NM_FLOOR_L_S = 0x00c,
|
|
NM_FLOOR_L_D = 0x10c,
|
|
|
|
NM_FLOOR_W_S = 0x02c,
|
|
NM_FLOOR_W_D = 0x12c,
|
|
|
|
NM_CEIL_L_S = 0x04c,
|
|
NM_CEIL_L_D = 0x14c,
|
|
NM_CEIL_W_S = 0x06c,
|
|
NM_CEIL_W_D = 0x16c,
|
|
NM_TRUNC_L_S = 0x08c,
|
|
NM_TRUNC_L_D = 0x18c,
|
|
NM_TRUNC_W_S = 0x0ac,
|
|
NM_TRUNC_W_D = 0x1ac,
|
|
NM_ROUND_L_S = 0x0cc,
|
|
NM_ROUND_L_D = 0x1cc,
|
|
NM_ROUND_W_S = 0x0ec,
|
|
NM_ROUND_W_D = 0x1ec,
|
|
|
|
NM_MOV_S = 0x01,
|
|
NM_MOV_D = 0x81,
|
|
NM_ABS_S = 0x0d,
|
|
NM_ABS_D = 0x8d,
|
|
NM_NEG_S = 0x2d,
|
|
NM_NEG_D = 0xad,
|
|
NM_CVT_D_S = 0x04d,
|
|
NM_CVT_D_W = 0x0cd,
|
|
NM_CVT_D_L = 0x14d,
|
|
NM_CVT_S_D = 0x06d,
|
|
NM_CVT_S_W = 0x0ed,
|
|
NM_CVT_S_L = 0x16d,
|
|
};
|
|
|
|
/* P.LL instruction pool */
|
|
enum {
|
|
NM_LL = 0x00,
|
|
NM_LLWP = 0x01,
|
|
};
|
|
|
|
/* P.SC instruction pool */
|
|
enum {
|
|
NM_SC = 0x00,
|
|
NM_SCWP = 0x01,
|
|
};
|
|
|
|
/* P.DVP instruction pool */
|
|
enum {
|
|
NM_DVP = 0x00,
|
|
NM_EVP = 0x01,
|
|
};
|
|
|
|
|
|
/*
|
|
*
|
|
* nanoMIPS decoding engine
|
|
*
|
|
*/
|
|
|
|
|
|
/* extraction utilities */
|
|
|
|
#define NANOMIPS_EXTRACT_RT3(op) ((op >> 7) & 0x7)
|
|
#define NANOMIPS_EXTRACT_RS3(op) ((op >> 4) & 0x7)
|
|
#define NANOMIPS_EXTRACT_RD3(op) ((op >> 1) & 0x7)
|
|
#define NANOMIPS_EXTRACT_RD5(op) ((op >> 5) & 0x1f)
|
|
#define NANOMIPS_EXTRACT_RS5(op) (op & 0x1f)
|
|
|
|
/* Implement nanoMIPS pseudocode decode_gpr(encoded_gpr, 'gpr3'). */
|
|
static inline int decode_gpr_gpr3(int r)
|
|
{
|
|
static const int map[] = { 16, 17, 18, 19, 4, 5, 6, 7 };
|
|
|
|
return map[r & 0x7];
|
|
}
|
|
|
|
/* Implement nanoMIPS pseudocode decode_gpr(encoded_gpr, 'gpr3.src.store'). */
|
|
static inline int decode_gpr_gpr3_src_store(int r)
|
|
{
|
|
static const int map[] = { 0, 17, 18, 19, 4, 5, 6, 7 };
|
|
|
|
return map[r & 0x7];
|
|
}
|
|
|
|
/* Implement nanoMIPS pseudocode decode_gpr(encoded_gpr, 'gpr4'). */
|
|
static inline int decode_gpr_gpr4(int r)
|
|
{
|
|
static const int map[] = { 8, 9, 10, 11, 4, 5, 6, 7,
|
|
16, 17, 18, 19, 20, 21, 22, 23 };
|
|
|
|
return map[r & 0xf];
|
|
}
|
|
|
|
/* Implement nanoMIPS pseudocode decode_gpr(encoded_gpr, 'gpr4.zero'). */
|
|
static inline int decode_gpr_gpr4_zero(int r)
|
|
{
|
|
static const int map[] = { 8, 9, 10, 0, 4, 5, 6, 7,
|
|
16, 17, 18, 19, 20, 21, 22, 23 };
|
|
|
|
return map[r & 0xf];
|
|
}
|
|
|
|
static void gen_ext(DisasContext *ctx, int wordsz, int rd, int rs, int rt,
|
|
int shift)
|
|
{
|
|
gen_align_bits(ctx, wordsz, rd, rs, rt, wordsz - shift);
|
|
}
|
|
|
|
static void gen_llwp(DisasContext *ctx, uint32_t base, int16_t offset,
|
|
uint32_t reg1, uint32_t reg2)
|
|
{
|
|
TCGv taddr = tcg_temp_new();
|
|
TCGv_i64 tval = tcg_temp_new_i64();
|
|
TCGv tmp1 = tcg_temp_new();
|
|
TCGv tmp2 = tcg_temp_new();
|
|
|
|
gen_base_offset_addr(ctx, taddr, base, offset);
|
|
tcg_gen_qemu_ld64(tval, taddr, ctx->mem_idx);
|
|
if (cpu_is_bigendian(ctx)) {
|
|
tcg_gen_extr_i64_tl(tmp2, tmp1, tval);
|
|
} else {
|
|
tcg_gen_extr_i64_tl(tmp1, tmp2, tval);
|
|
}
|
|
gen_store_gpr(tmp1, reg1);
|
|
tcg_temp_free(tmp1);
|
|
gen_store_gpr(tmp2, reg2);
|
|
tcg_temp_free(tmp2);
|
|
tcg_gen_st_i64(tval, cpu_env, offsetof(CPUMIPSState, llval_wp));
|
|
tcg_temp_free_i64(tval);
|
|
tcg_gen_st_tl(taddr, cpu_env, offsetof(CPUMIPSState, lladdr));
|
|
tcg_temp_free(taddr);
|
|
}
|
|
|
|
static void gen_scwp(DisasContext *ctx, uint32_t base, int16_t offset,
|
|
uint32_t reg1, uint32_t reg2, bool eva)
|
|
{
|
|
TCGv taddr = tcg_temp_local_new();
|
|
TCGv lladdr = tcg_temp_local_new();
|
|
TCGv_i64 tval = tcg_temp_new_i64();
|
|
TCGv_i64 llval = tcg_temp_new_i64();
|
|
TCGv_i64 val = tcg_temp_new_i64();
|
|
TCGv tmp1 = tcg_temp_new();
|
|
TCGv tmp2 = tcg_temp_new();
|
|
TCGLabel *lab_fail = gen_new_label();
|
|
TCGLabel *lab_done = gen_new_label();
|
|
|
|
gen_base_offset_addr(ctx, taddr, base, offset);
|
|
|
|
tcg_gen_ld_tl(lladdr, cpu_env, offsetof(CPUMIPSState, lladdr));
|
|
tcg_gen_brcond_tl(TCG_COND_NE, taddr, lladdr, lab_fail);
|
|
|
|
gen_load_gpr(tmp1, reg1);
|
|
gen_load_gpr(tmp2, reg2);
|
|
|
|
if (cpu_is_bigendian(ctx)) {
|
|
tcg_gen_concat_tl_i64(tval, tmp2, tmp1);
|
|
} else {
|
|
tcg_gen_concat_tl_i64(tval, tmp1, tmp2);
|
|
}
|
|
|
|
tcg_gen_ld_i64(llval, cpu_env, offsetof(CPUMIPSState, llval_wp));
|
|
tcg_gen_atomic_cmpxchg_i64(val, taddr, llval, tval,
|
|
eva ? MIPS_HFLAG_UM : ctx->mem_idx, MO_64);
|
|
if (reg1 != 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[reg1], 1);
|
|
}
|
|
tcg_gen_brcond_i64(TCG_COND_EQ, val, llval, lab_done);
|
|
|
|
gen_set_label(lab_fail);
|
|
|
|
if (reg1 != 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[reg1], 0);
|
|
}
|
|
gen_set_label(lab_done);
|
|
tcg_gen_movi_tl(lladdr, -1);
|
|
tcg_gen_st_tl(lladdr, cpu_env, offsetof(CPUMIPSState, lladdr));
|
|
}
|
|
|
|
static void gen_adjust_sp(DisasContext *ctx, int u)
|
|
{
|
|
gen_op_addr_addi(ctx, cpu_gpr[29], cpu_gpr[29], u);
|
|
}
|
|
|
|
static void gen_save(DisasContext *ctx, uint8_t rt, uint8_t count,
|
|
uint8_t gp, uint16_t u)
|
|
{
|
|
int counter = 0;
|
|
TCGv va = tcg_temp_new();
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
while (counter != count) {
|
|
bool use_gp = gp && (counter == count - 1);
|
|
int this_rt = use_gp ? 28 : (rt & 0x10) | ((rt + counter) & 0x1f);
|
|
int this_offset = -((counter + 1) << 2);
|
|
gen_base_offset_addr(ctx, va, 29, this_offset);
|
|
gen_load_gpr(t0, this_rt);
|
|
tcg_gen_qemu_st_tl(t0, va, ctx->mem_idx,
|
|
(MO_TEUL | ctx->default_tcg_memop_mask));
|
|
counter++;
|
|
}
|
|
|
|
/* adjust stack pointer */
|
|
gen_adjust_sp(ctx, -u);
|
|
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(va);
|
|
}
|
|
|
|
static void gen_restore(DisasContext *ctx, uint8_t rt, uint8_t count,
|
|
uint8_t gp, uint16_t u)
|
|
{
|
|
int counter = 0;
|
|
TCGv va = tcg_temp_new();
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
while (counter != count) {
|
|
bool use_gp = gp && (counter == count - 1);
|
|
int this_rt = use_gp ? 28 : (rt & 0x10) | ((rt + counter) & 0x1f);
|
|
int this_offset = u - ((counter + 1) << 2);
|
|
gen_base_offset_addr(ctx, va, 29, this_offset);
|
|
tcg_gen_qemu_ld_tl(t0, va, ctx->mem_idx, MO_TESL |
|
|
ctx->default_tcg_memop_mask);
|
|
tcg_gen_ext32s_tl(t0, t0);
|
|
gen_store_gpr(t0, this_rt);
|
|
counter++;
|
|
}
|
|
|
|
/* adjust stack pointer */
|
|
gen_adjust_sp(ctx, u);
|
|
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(va);
|
|
}
|
|
|
|
static void gen_compute_branch_nm(DisasContext *ctx, uint32_t opc,
|
|
int insn_bytes,
|
|
int rs, int rt, int32_t offset)
|
|
{
|
|
target_ulong btgt = -1;
|
|
int bcond_compute = 0;
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
|
|
/* Load needed operands */
|
|
switch (opc) {
|
|
case OPC_BEQ:
|
|
case OPC_BNE:
|
|
/* Compare two registers */
|
|
if (rs != rt) {
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
bcond_compute = 1;
|
|
}
|
|
btgt = ctx->base.pc_next + insn_bytes + offset;
|
|
break;
|
|
case OPC_BGEZAL:
|
|
/* Compare to zero */
|
|
if (rs != 0) {
|
|
gen_load_gpr(t0, rs);
|
|
bcond_compute = 1;
|
|
}
|
|
btgt = ctx->base.pc_next + insn_bytes + offset;
|
|
break;
|
|
case OPC_BPOSGE32:
|
|
tcg_gen_andi_tl(t0, cpu_dspctrl, 0x3F);
|
|
bcond_compute = 1;
|
|
btgt = ctx->base.pc_next + insn_bytes + offset;
|
|
break;
|
|
case OPC_JR:
|
|
case OPC_JALR:
|
|
/* Jump to register */
|
|
if (offset != 0 && offset != 16) {
|
|
/*
|
|
* Hint = 0 is JR/JALR, hint 16 is JR.HB/JALR.HB, the
|
|
* others are reserved.
|
|
*/
|
|
MIPS_INVAL("jump hint");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
gen_load_gpr(btarget, rs);
|
|
break;
|
|
default:
|
|
MIPS_INVAL("branch/jump");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
if (bcond_compute == 0) {
|
|
/* No condition to be computed */
|
|
switch (opc) {
|
|
case OPC_BEQ: /* rx == rx */
|
|
/* Always take */
|
|
ctx->hflags |= MIPS_HFLAG_B;
|
|
break;
|
|
case OPC_BGEZAL: /* 0 >= 0 */
|
|
/* Always take and link */
|
|
tcg_gen_movi_tl(cpu_gpr[31],
|
|
ctx->base.pc_next + insn_bytes);
|
|
ctx->hflags |= MIPS_HFLAG_B;
|
|
break;
|
|
case OPC_BNE: /* rx != rx */
|
|
tcg_gen_movi_tl(cpu_gpr[31], ctx->base.pc_next + 8);
|
|
/* Skip the instruction in the delay slot */
|
|
ctx->base.pc_next += 4;
|
|
goto out;
|
|
case OPC_JR:
|
|
ctx->hflags |= MIPS_HFLAG_BR;
|
|
break;
|
|
case OPC_JALR:
|
|
if (rt > 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[rt],
|
|
ctx->base.pc_next + insn_bytes);
|
|
}
|
|
ctx->hflags |= MIPS_HFLAG_BR;
|
|
break;
|
|
default:
|
|
MIPS_INVAL("branch/jump");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
} else {
|
|
switch (opc) {
|
|
case OPC_BEQ:
|
|
tcg_gen_setcond_tl(TCG_COND_EQ, bcond, t0, t1);
|
|
goto not_likely;
|
|
case OPC_BNE:
|
|
tcg_gen_setcond_tl(TCG_COND_NE, bcond, t0, t1);
|
|
goto not_likely;
|
|
case OPC_BGEZAL:
|
|
tcg_gen_setcondi_tl(TCG_COND_GE, bcond, t0, 0);
|
|
tcg_gen_movi_tl(cpu_gpr[31],
|
|
ctx->base.pc_next + insn_bytes);
|
|
goto not_likely;
|
|
case OPC_BPOSGE32:
|
|
tcg_gen_setcondi_tl(TCG_COND_GE, bcond, t0, 32);
|
|
not_likely:
|
|
ctx->hflags |= MIPS_HFLAG_BC;
|
|
break;
|
|
default:
|
|
MIPS_INVAL("conditional branch/jump");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ctx->btarget = btgt;
|
|
|
|
out:
|
|
if (insn_bytes == 2) {
|
|
ctx->hflags |= MIPS_HFLAG_B16;
|
|
}
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
|
|
static void gen_pool16c_nanomips_insn(DisasContext *ctx)
|
|
{
|
|
int rt = decode_gpr_gpr3(NANOMIPS_EXTRACT_RT3(ctx->opcode));
|
|
int rs = decode_gpr_gpr3(NANOMIPS_EXTRACT_RS3(ctx->opcode));
|
|
|
|
switch (extract32(ctx->opcode, 2, 2)) {
|
|
case NM_NOT16:
|
|
gen_logic(ctx, OPC_NOR, rt, rs, 0);
|
|
break;
|
|
case NM_AND16:
|
|
gen_logic(ctx, OPC_AND, rt, rt, rs);
|
|
break;
|
|
case NM_XOR16:
|
|
gen_logic(ctx, OPC_XOR, rt, rt, rs);
|
|
break;
|
|
case NM_OR16:
|
|
gen_logic(ctx, OPC_OR, rt, rt, rs);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void gen_pool32a0_nanomips_insn(CPUMIPSState *env, DisasContext *ctx)
|
|
{
|
|
int rt = extract32(ctx->opcode, 21, 5);
|
|
int rs = extract32(ctx->opcode, 16, 5);
|
|
int rd = extract32(ctx->opcode, 11, 5);
|
|
|
|
switch (extract32(ctx->opcode, 3, 7)) {
|
|
case NM_P_TRAP:
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case NM_TEQ:
|
|
check_nms(ctx);
|
|
gen_trap(ctx, OPC_TEQ, rs, rt, -1, rd);
|
|
break;
|
|
case NM_TNE:
|
|
check_nms(ctx);
|
|
gen_trap(ctx, OPC_TNE, rs, rt, -1, rd);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_RDHWR:
|
|
check_nms(ctx);
|
|
gen_rdhwr(ctx, rt, rs, extract32(ctx->opcode, 11, 3));
|
|
break;
|
|
case NM_SEB:
|
|
check_nms(ctx);
|
|
gen_bshfl(ctx, OPC_SEB, rs, rt);
|
|
break;
|
|
case NM_SEH:
|
|
gen_bshfl(ctx, OPC_SEH, rs, rt);
|
|
break;
|
|
case NM_SLLV:
|
|
gen_shift(ctx, OPC_SLLV, rd, rt, rs);
|
|
break;
|
|
case NM_SRLV:
|
|
gen_shift(ctx, OPC_SRLV, rd, rt, rs);
|
|
break;
|
|
case NM_SRAV:
|
|
gen_shift(ctx, OPC_SRAV, rd, rt, rs);
|
|
break;
|
|
case NM_ROTRV:
|
|
gen_shift(ctx, OPC_ROTRV, rd, rt, rs);
|
|
break;
|
|
case NM_ADD:
|
|
gen_arith(ctx, OPC_ADD, rd, rs, rt);
|
|
break;
|
|
case NM_ADDU:
|
|
gen_arith(ctx, OPC_ADDU, rd, rs, rt);
|
|
break;
|
|
case NM_SUB:
|
|
check_nms(ctx);
|
|
gen_arith(ctx, OPC_SUB, rd, rs, rt);
|
|
break;
|
|
case NM_SUBU:
|
|
gen_arith(ctx, OPC_SUBU, rd, rs, rt);
|
|
break;
|
|
case NM_P_CMOVE:
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case NM_MOVZ:
|
|
gen_cond_move(ctx, OPC_MOVZ, rd, rs, rt);
|
|
break;
|
|
case NM_MOVN:
|
|
gen_cond_move(ctx, OPC_MOVN, rd, rs, rt);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_AND:
|
|
gen_logic(ctx, OPC_AND, rd, rs, rt);
|
|
break;
|
|
case NM_OR:
|
|
gen_logic(ctx, OPC_OR, rd, rs, rt);
|
|
break;
|
|
case NM_NOR:
|
|
gen_logic(ctx, OPC_NOR, rd, rs, rt);
|
|
break;
|
|
case NM_XOR:
|
|
gen_logic(ctx, OPC_XOR, rd, rs, rt);
|
|
break;
|
|
case NM_SLT:
|
|
gen_slt(ctx, OPC_SLT, rd, rs, rt);
|
|
break;
|
|
case NM_P_SLTU:
|
|
if (rd == 0) {
|
|
/* P_DVP */
|
|
#ifndef CONFIG_USER_ONLY
|
|
TCGv t0 = tcg_temp_new();
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case NM_DVP:
|
|
if (ctx->vp) {
|
|
check_cp0_enabled(ctx);
|
|
gen_helper_dvp(t0, cpu_env);
|
|
gen_store_gpr(t0, rt);
|
|
}
|
|
break;
|
|
case NM_EVP:
|
|
if (ctx->vp) {
|
|
check_cp0_enabled(ctx);
|
|
gen_helper_evp(t0, cpu_env);
|
|
gen_store_gpr(t0, rt);
|
|
}
|
|
break;
|
|
}
|
|
tcg_temp_free(t0);
|
|
#endif
|
|
} else {
|
|
gen_slt(ctx, OPC_SLTU, rd, rs, rt);
|
|
}
|
|
break;
|
|
case NM_SOV:
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
TCGv t2 = tcg_temp_new();
|
|
|
|
gen_load_gpr(t1, rs);
|
|
gen_load_gpr(t2, rt);
|
|
tcg_gen_add_tl(t0, t1, t2);
|
|
tcg_gen_ext32s_tl(t0, t0);
|
|
tcg_gen_xor_tl(t1, t1, t2);
|
|
tcg_gen_xor_tl(t2, t0, t2);
|
|
tcg_gen_andc_tl(t1, t2, t1);
|
|
|
|
/* operands of same sign, result different sign */
|
|
tcg_gen_setcondi_tl(TCG_COND_LT, t0, t1, 0);
|
|
gen_store_gpr(t0, rd);
|
|
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
tcg_temp_free(t2);
|
|
}
|
|
break;
|
|
case NM_MUL:
|
|
gen_r6_muldiv(ctx, R6_OPC_MUL, rd, rs, rt);
|
|
break;
|
|
case NM_MUH:
|
|
gen_r6_muldiv(ctx, R6_OPC_MUH, rd, rs, rt);
|
|
break;
|
|
case NM_MULU:
|
|
gen_r6_muldiv(ctx, R6_OPC_MULU, rd, rs, rt);
|
|
break;
|
|
case NM_MUHU:
|
|
gen_r6_muldiv(ctx, R6_OPC_MUHU, rd, rs, rt);
|
|
break;
|
|
case NM_DIV:
|
|
gen_r6_muldiv(ctx, R6_OPC_DIV, rd, rs, rt);
|
|
break;
|
|
case NM_MOD:
|
|
gen_r6_muldiv(ctx, R6_OPC_MOD, rd, rs, rt);
|
|
break;
|
|
case NM_DIVU:
|
|
gen_r6_muldiv(ctx, R6_OPC_DIVU, rd, rs, rt);
|
|
break;
|
|
case NM_MODU:
|
|
gen_r6_muldiv(ctx, R6_OPC_MODU, rd, rs, rt);
|
|
break;
|
|
#ifndef CONFIG_USER_ONLY
|
|
case NM_MFC0:
|
|
check_cp0_enabled(ctx);
|
|
if (rt == 0) {
|
|
/* Treat as NOP. */
|
|
break;
|
|
}
|
|
gen_mfc0(ctx, cpu_gpr[rt], rs, extract32(ctx->opcode, 11, 3));
|
|
break;
|
|
case NM_MTC0:
|
|
check_cp0_enabled(ctx);
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
gen_load_gpr(t0, rt);
|
|
gen_mtc0(ctx, t0, rs, extract32(ctx->opcode, 11, 3));
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
case NM_D_E_MT_VPE:
|
|
{
|
|
uint8_t sc = extract32(ctx->opcode, 10, 1);
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
switch (sc) {
|
|
case 0:
|
|
if (rs == 1) {
|
|
/* DMT */
|
|
check_cp0_mt(ctx);
|
|
gen_helper_dmt(t0);
|
|
gen_store_gpr(t0, rt);
|
|
} else if (rs == 0) {
|
|
/* DVPE */
|
|
check_cp0_mt(ctx);
|
|
gen_helper_dvpe(t0, cpu_env);
|
|
gen_store_gpr(t0, rt);
|
|
} else {
|
|
gen_reserved_instruction(ctx);
|
|
}
|
|
break;
|
|
case 1:
|
|
if (rs == 1) {
|
|
/* EMT */
|
|
check_cp0_mt(ctx);
|
|
gen_helper_emt(t0);
|
|
gen_store_gpr(t0, rt);
|
|
} else if (rs == 0) {
|
|
/* EVPE */
|
|
check_cp0_mt(ctx);
|
|
gen_helper_evpe(t0, cpu_env);
|
|
gen_store_gpr(t0, rt);
|
|
} else {
|
|
gen_reserved_instruction(ctx);
|
|
}
|
|
break;
|
|
}
|
|
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
case NM_FORK:
|
|
check_mt(ctx);
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
|
|
gen_load_gpr(t0, rt);
|
|
gen_load_gpr(t1, rs);
|
|
gen_helper_fork(t0, t1);
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
break;
|
|
case NM_MFTR:
|
|
case NM_MFHTR:
|
|
check_cp0_enabled(ctx);
|
|
if (rd == 0) {
|
|
/* Treat as NOP. */
|
|
return;
|
|
}
|
|
gen_mftr(env, ctx, rs, rt, extract32(ctx->opcode, 10, 1),
|
|
extract32(ctx->opcode, 11, 5), extract32(ctx->opcode, 3, 1));
|
|
break;
|
|
case NM_MTTR:
|
|
case NM_MTHTR:
|
|
check_cp0_enabled(ctx);
|
|
gen_mttr(env, ctx, rs, rt, extract32(ctx->opcode, 10, 1),
|
|
extract32(ctx->opcode, 11, 5), extract32(ctx->opcode, 3, 1));
|
|
break;
|
|
case NM_YIELD:
|
|
check_mt(ctx);
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
gen_load_gpr(t0, rs);
|
|
gen_helper_yield(t0, cpu_env, t0);
|
|
gen_store_gpr(t0, rt);
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
#endif
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* dsp */
|
|
static void gen_pool32axf_1_5_nanomips_insn(DisasContext *ctx, uint32_t opc,
|
|
int ret, int v1, int v2)
|
|
{
|
|
TCGv_i32 t0;
|
|
TCGv v0_t;
|
|
TCGv v1_t;
|
|
|
|
t0 = tcg_temp_new_i32();
|
|
|
|
v0_t = tcg_temp_new();
|
|
v1_t = tcg_temp_new();
|
|
|
|
tcg_gen_movi_i32(t0, v2 >> 3);
|
|
|
|
gen_load_gpr(v0_t, ret);
|
|
gen_load_gpr(v1_t, v1);
|
|
|
|
switch (opc) {
|
|
case NM_MAQ_S_W_PHR:
|
|
check_dsp(ctx);
|
|
gen_helper_maq_s_w_phr(t0, v1_t, v0_t, cpu_env);
|
|
break;
|
|
case NM_MAQ_S_W_PHL:
|
|
check_dsp(ctx);
|
|
gen_helper_maq_s_w_phl(t0, v1_t, v0_t, cpu_env);
|
|
break;
|
|
case NM_MAQ_SA_W_PHR:
|
|
check_dsp(ctx);
|
|
gen_helper_maq_sa_w_phr(t0, v1_t, v0_t, cpu_env);
|
|
break;
|
|
case NM_MAQ_SA_W_PHL:
|
|
check_dsp(ctx);
|
|
gen_helper_maq_sa_w_phl(t0, v1_t, v0_t, cpu_env);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
|
|
tcg_temp_free_i32(t0);
|
|
|
|
tcg_temp_free(v0_t);
|
|
tcg_temp_free(v1_t);
|
|
}
|
|
|
|
|
|
static void gen_pool32axf_1_nanomips_insn(DisasContext *ctx, uint32_t opc,
|
|
int ret, int v1, int v2)
|
|
{
|
|
int16_t imm;
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
TCGv v0_t = tcg_temp_new();
|
|
|
|
gen_load_gpr(v0_t, v1);
|
|
|
|
switch (opc) {
|
|
case NM_POOL32AXF_1_0:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 12, 2)) {
|
|
case NM_MFHI:
|
|
gen_HILO(ctx, OPC_MFHI, v2 >> 3, ret);
|
|
break;
|
|
case NM_MFLO:
|
|
gen_HILO(ctx, OPC_MFLO, v2 >> 3, ret);
|
|
break;
|
|
case NM_MTHI:
|
|
gen_HILO(ctx, OPC_MTHI, v2 >> 3, v1);
|
|
break;
|
|
case NM_MTLO:
|
|
gen_HILO(ctx, OPC_MTLO, v2 >> 3, v1);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_1_1:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 12, 2)) {
|
|
case NM_MTHLIP:
|
|
tcg_gen_movi_tl(t0, v2 >> 3);
|
|
gen_helper_mthlip(t0, v0_t, cpu_env);
|
|
break;
|
|
case NM_SHILOV:
|
|
tcg_gen_movi_tl(t0, v2 >> 3);
|
|
gen_helper_shilo(t0, v0_t, cpu_env);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_1_3:
|
|
check_dsp(ctx);
|
|
imm = extract32(ctx->opcode, 14, 7);
|
|
switch (extract32(ctx->opcode, 12, 2)) {
|
|
case NM_RDDSP:
|
|
tcg_gen_movi_tl(t0, imm);
|
|
gen_helper_rddsp(t0, t0, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_WRDSP:
|
|
gen_load_gpr(t0, ret);
|
|
tcg_gen_movi_tl(t1, imm);
|
|
gen_helper_wrdsp(t0, t1, cpu_env);
|
|
break;
|
|
case NM_EXTP:
|
|
tcg_gen_movi_tl(t0, v2 >> 3);
|
|
tcg_gen_movi_tl(t1, v1);
|
|
gen_helper_extp(t0, t0, t1, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_EXTPDP:
|
|
tcg_gen_movi_tl(t0, v2 >> 3);
|
|
tcg_gen_movi_tl(t1, v1);
|
|
gen_helper_extpdp(t0, t0, t1, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_1_4:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, v2 >> 2);
|
|
switch (extract32(ctx->opcode, 12, 1)) {
|
|
case NM_SHLL_QB:
|
|
gen_helper_shll_qb(t0, t0, v0_t, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_SHRL_QB:
|
|
gen_helper_shrl_qb(t0, t0, v0_t);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_1_5:
|
|
opc = extract32(ctx->opcode, 12, 2);
|
|
gen_pool32axf_1_5_nanomips_insn(ctx, opc, ret, v1, v2);
|
|
break;
|
|
case NM_POOL32AXF_1_7:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, v2 >> 3);
|
|
tcg_gen_movi_tl(t1, v1);
|
|
switch (extract32(ctx->opcode, 12, 2)) {
|
|
case NM_EXTR_W:
|
|
gen_helper_extr_w(t0, t0, t1, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_EXTR_R_W:
|
|
gen_helper_extr_r_w(t0, t0, t1, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_EXTR_RS_W:
|
|
gen_helper_extr_rs_w(t0, t0, t1, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_EXTR_S_H:
|
|
gen_helper_extr_s_h(t0, t0, t1, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
tcg_temp_free(v0_t);
|
|
}
|
|
|
|
static void gen_pool32axf_2_multiply(DisasContext *ctx, uint32_t opc,
|
|
TCGv v0, TCGv v1, int rd)
|
|
{
|
|
TCGv_i32 t0;
|
|
|
|
t0 = tcg_temp_new_i32();
|
|
|
|
tcg_gen_movi_i32(t0, rd >> 3);
|
|
|
|
switch (opc) {
|
|
case NM_POOL32AXF_2_0_7:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPA_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dpa_w_ph(t0, v1, v0, cpu_env);
|
|
break;
|
|
case NM_DPAQ_S_W_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_dpaq_s_w_ph(t0, v1, v0, cpu_env);
|
|
break;
|
|
case NM_DPS_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dps_w_ph(t0, v1, v0, cpu_env);
|
|
break;
|
|
case NM_DPSQ_S_W_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_dpsq_s_w_ph(t0, v1, v0, cpu_env);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_2_8_15:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPAX_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dpax_w_ph(t0, v0, v1, cpu_env);
|
|
break;
|
|
case NM_DPAQ_SA_L_W:
|
|
check_dsp(ctx);
|
|
gen_helper_dpaq_sa_l_w(t0, v0, v1, cpu_env);
|
|
break;
|
|
case NM_DPSX_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dpsx_w_ph(t0, v0, v1, cpu_env);
|
|
break;
|
|
case NM_DPSQ_SA_L_W:
|
|
check_dsp(ctx);
|
|
gen_helper_dpsq_sa_l_w(t0, v0, v1, cpu_env);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_2_16_23:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPAU_H_QBL:
|
|
check_dsp(ctx);
|
|
gen_helper_dpau_h_qbl(t0, v0, v1, cpu_env);
|
|
break;
|
|
case NM_DPAQX_S_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dpaqx_s_w_ph(t0, v0, v1, cpu_env);
|
|
break;
|
|
case NM_DPSU_H_QBL:
|
|
check_dsp(ctx);
|
|
gen_helper_dpsu_h_qbl(t0, v0, v1, cpu_env);
|
|
break;
|
|
case NM_DPSQX_S_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dpsqx_s_w_ph(t0, v0, v1, cpu_env);
|
|
break;
|
|
case NM_MULSA_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_mulsa_w_ph(t0, v0, v1, cpu_env);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_2_24_31:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPAU_H_QBR:
|
|
check_dsp(ctx);
|
|
gen_helper_dpau_h_qbr(t0, v1, v0, cpu_env);
|
|
break;
|
|
case NM_DPAQX_SA_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dpaqx_sa_w_ph(t0, v1, v0, cpu_env);
|
|
break;
|
|
case NM_DPSU_H_QBR:
|
|
check_dsp(ctx);
|
|
gen_helper_dpsu_h_qbr(t0, v1, v0, cpu_env);
|
|
break;
|
|
case NM_DPSQX_SA_W_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_dpsqx_sa_w_ph(t0, v1, v0, cpu_env);
|
|
break;
|
|
case NM_MULSAQ_S_W_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_mulsaq_s_w_ph(t0, v1, v0, cpu_env);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
|
|
tcg_temp_free_i32(t0);
|
|
}
|
|
|
|
static void gen_pool32axf_2_nanomips_insn(DisasContext *ctx, uint32_t opc,
|
|
int rt, int rs, int rd)
|
|
{
|
|
int ret = rt;
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
TCGv v0_t = tcg_temp_new();
|
|
TCGv v1_t = tcg_temp_new();
|
|
|
|
gen_load_gpr(v0_t, rt);
|
|
gen_load_gpr(v1_t, rs);
|
|
|
|
switch (opc) {
|
|
case NM_POOL32AXF_2_0_7:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPA_W_PH:
|
|
case NM_DPAQ_S_W_PH:
|
|
case NM_DPS_W_PH:
|
|
case NM_DPSQ_S_W_PH:
|
|
gen_pool32axf_2_multiply(ctx, opc, v0_t, v1_t, rd);
|
|
break;
|
|
case NM_BALIGN:
|
|
check_dsp_r2(ctx);
|
|
if (rt != 0) {
|
|
gen_load_gpr(t0, rs);
|
|
rd &= 3;
|
|
if (rd != 0 && rd != 2) {
|
|
tcg_gen_shli_tl(cpu_gpr[ret], cpu_gpr[ret], 8 * rd);
|
|
tcg_gen_ext32u_tl(t0, t0);
|
|
tcg_gen_shri_tl(t0, t0, 8 * (4 - rd));
|
|
tcg_gen_or_tl(cpu_gpr[ret], cpu_gpr[ret], t0);
|
|
}
|
|
tcg_gen_ext32s_tl(cpu_gpr[ret], cpu_gpr[ret]);
|
|
}
|
|
break;
|
|
case NM_MADD:
|
|
check_dsp(ctx);
|
|
{
|
|
int acc = extract32(ctx->opcode, 14, 2);
|
|
TCGv_i64 t2 = tcg_temp_new_i64();
|
|
TCGv_i64 t3 = tcg_temp_new_i64();
|
|
|
|
gen_load_gpr(t0, rt);
|
|
gen_load_gpr(t1, rs);
|
|
tcg_gen_ext_tl_i64(t2, t0);
|
|
tcg_gen_ext_tl_i64(t3, t1);
|
|
tcg_gen_mul_i64(t2, t2, t3);
|
|
tcg_gen_concat_tl_i64(t3, cpu_LO[acc], cpu_HI[acc]);
|
|
tcg_gen_add_i64(t2, t2, t3);
|
|
tcg_temp_free_i64(t3);
|
|
gen_move_low32(cpu_LO[acc], t2);
|
|
gen_move_high32(cpu_HI[acc], t2);
|
|
tcg_temp_free_i64(t2);
|
|
}
|
|
break;
|
|
case NM_MULT:
|
|
check_dsp(ctx);
|
|
{
|
|
int acc = extract32(ctx->opcode, 14, 2);
|
|
TCGv_i32 t2 = tcg_temp_new_i32();
|
|
TCGv_i32 t3 = tcg_temp_new_i32();
|
|
|
|
if (acc || ctx->insn_flags & ISA_MIPS_R6) {
|
|
check_dsp_r2(ctx);
|
|
}
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
tcg_gen_trunc_tl_i32(t2, t0);
|
|
tcg_gen_trunc_tl_i32(t3, t1);
|
|
tcg_gen_muls2_i32(t2, t3, t2, t3);
|
|
tcg_gen_ext_i32_tl(cpu_LO[acc], t2);
|
|
tcg_gen_ext_i32_tl(cpu_HI[acc], t3);
|
|
tcg_temp_free_i32(t2);
|
|
tcg_temp_free_i32(t3);
|
|
}
|
|
break;
|
|
case NM_EXTRV_W:
|
|
check_dsp(ctx);
|
|
gen_load_gpr(v1_t, rs);
|
|
tcg_gen_movi_tl(t0, rd >> 3);
|
|
gen_helper_extr_w(t0, t0, v1_t, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_2_8_15:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPAX_W_PH:
|
|
case NM_DPAQ_SA_L_W:
|
|
case NM_DPSX_W_PH:
|
|
case NM_DPSQ_SA_L_W:
|
|
gen_pool32axf_2_multiply(ctx, opc, v0_t, v1_t, rd);
|
|
break;
|
|
case NM_MADDU:
|
|
check_dsp(ctx);
|
|
{
|
|
int acc = extract32(ctx->opcode, 14, 2);
|
|
TCGv_i64 t2 = tcg_temp_new_i64();
|
|
TCGv_i64 t3 = tcg_temp_new_i64();
|
|
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
tcg_gen_ext32u_tl(t0, t0);
|
|
tcg_gen_ext32u_tl(t1, t1);
|
|
tcg_gen_extu_tl_i64(t2, t0);
|
|
tcg_gen_extu_tl_i64(t3, t1);
|
|
tcg_gen_mul_i64(t2, t2, t3);
|
|
tcg_gen_concat_tl_i64(t3, cpu_LO[acc], cpu_HI[acc]);
|
|
tcg_gen_add_i64(t2, t2, t3);
|
|
tcg_temp_free_i64(t3);
|
|
gen_move_low32(cpu_LO[acc], t2);
|
|
gen_move_high32(cpu_HI[acc], t2);
|
|
tcg_temp_free_i64(t2);
|
|
}
|
|
break;
|
|
case NM_MULTU:
|
|
check_dsp(ctx);
|
|
{
|
|
int acc = extract32(ctx->opcode, 14, 2);
|
|
TCGv_i32 t2 = tcg_temp_new_i32();
|
|
TCGv_i32 t3 = tcg_temp_new_i32();
|
|
|
|
if (acc || ctx->insn_flags & ISA_MIPS_R6) {
|
|
check_dsp_r2(ctx);
|
|
}
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
tcg_gen_trunc_tl_i32(t2, t0);
|
|
tcg_gen_trunc_tl_i32(t3, t1);
|
|
tcg_gen_mulu2_i32(t2, t3, t2, t3);
|
|
tcg_gen_ext_i32_tl(cpu_LO[acc], t2);
|
|
tcg_gen_ext_i32_tl(cpu_HI[acc], t3);
|
|
tcg_temp_free_i32(t2);
|
|
tcg_temp_free_i32(t3);
|
|
}
|
|
break;
|
|
case NM_EXTRV_R_W:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 3);
|
|
gen_helper_extr_r_w(t0, t0, v1_t, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_2_16_23:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPAU_H_QBL:
|
|
case NM_DPAQX_S_W_PH:
|
|
case NM_DPSU_H_QBL:
|
|
case NM_DPSQX_S_W_PH:
|
|
case NM_MULSA_W_PH:
|
|
gen_pool32axf_2_multiply(ctx, opc, v0_t, v1_t, rd);
|
|
break;
|
|
case NM_EXTPV:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 3);
|
|
gen_helper_extp(t0, t0, v1_t, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_MSUB:
|
|
check_dsp(ctx);
|
|
{
|
|
int acc = extract32(ctx->opcode, 14, 2);
|
|
TCGv_i64 t2 = tcg_temp_new_i64();
|
|
TCGv_i64 t3 = tcg_temp_new_i64();
|
|
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
tcg_gen_ext_tl_i64(t2, t0);
|
|
tcg_gen_ext_tl_i64(t3, t1);
|
|
tcg_gen_mul_i64(t2, t2, t3);
|
|
tcg_gen_concat_tl_i64(t3, cpu_LO[acc], cpu_HI[acc]);
|
|
tcg_gen_sub_i64(t2, t3, t2);
|
|
tcg_temp_free_i64(t3);
|
|
gen_move_low32(cpu_LO[acc], t2);
|
|
gen_move_high32(cpu_HI[acc], t2);
|
|
tcg_temp_free_i64(t2);
|
|
}
|
|
break;
|
|
case NM_EXTRV_RS_W:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 3);
|
|
gen_helper_extr_rs_w(t0, t0, v1_t, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_2_24_31:
|
|
switch (extract32(ctx->opcode, 9, 3)) {
|
|
case NM_DPAU_H_QBR:
|
|
case NM_DPAQX_SA_W_PH:
|
|
case NM_DPSU_H_QBR:
|
|
case NM_DPSQX_SA_W_PH:
|
|
case NM_MULSAQ_S_W_PH:
|
|
gen_pool32axf_2_multiply(ctx, opc, v0_t, v1_t, rd);
|
|
break;
|
|
case NM_EXTPDPV:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 3);
|
|
gen_helper_extpdp(t0, t0, v1_t, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
case NM_MSUBU:
|
|
check_dsp(ctx);
|
|
{
|
|
int acc = extract32(ctx->opcode, 14, 2);
|
|
TCGv_i64 t2 = tcg_temp_new_i64();
|
|
TCGv_i64 t3 = tcg_temp_new_i64();
|
|
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
tcg_gen_ext32u_tl(t0, t0);
|
|
tcg_gen_ext32u_tl(t1, t1);
|
|
tcg_gen_extu_tl_i64(t2, t0);
|
|
tcg_gen_extu_tl_i64(t3, t1);
|
|
tcg_gen_mul_i64(t2, t2, t3);
|
|
tcg_gen_concat_tl_i64(t3, cpu_LO[acc], cpu_HI[acc]);
|
|
tcg_gen_sub_i64(t2, t3, t2);
|
|
tcg_temp_free_i64(t3);
|
|
gen_move_low32(cpu_LO[acc], t2);
|
|
gen_move_high32(cpu_HI[acc], t2);
|
|
tcg_temp_free_i64(t2);
|
|
}
|
|
break;
|
|
case NM_EXTRV_S_H:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 3);
|
|
gen_helper_extr_s_h(t0, t0, v1_t, cpu_env);
|
|
gen_store_gpr(t0, ret);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
|
|
tcg_temp_free(v0_t);
|
|
tcg_temp_free(v1_t);
|
|
}
|
|
|
|
static void gen_pool32axf_4_nanomips_insn(DisasContext *ctx, uint32_t opc,
|
|
int rt, int rs)
|
|
{
|
|
int ret = rt;
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv v0_t = tcg_temp_new();
|
|
|
|
gen_load_gpr(v0_t, rs);
|
|
|
|
switch (opc) {
|
|
case NM_ABSQ_S_QB:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_absq_s_qb(v0_t, v0_t, cpu_env);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_ABSQ_S_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_absq_s_ph(v0_t, v0_t, cpu_env);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_ABSQ_S_W:
|
|
check_dsp(ctx);
|
|
gen_helper_absq_s_w(v0_t, v0_t, cpu_env);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEQ_W_PHL:
|
|
check_dsp(ctx);
|
|
tcg_gen_andi_tl(v0_t, v0_t, 0xFFFF0000);
|
|
tcg_gen_ext32s_tl(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEQ_W_PHR:
|
|
check_dsp(ctx);
|
|
tcg_gen_andi_tl(v0_t, v0_t, 0x0000FFFF);
|
|
tcg_gen_shli_tl(v0_t, v0_t, 16);
|
|
tcg_gen_ext32s_tl(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEQU_PH_QBL:
|
|
check_dsp(ctx);
|
|
gen_helper_precequ_ph_qbl(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEQU_PH_QBR:
|
|
check_dsp(ctx);
|
|
gen_helper_precequ_ph_qbr(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEQU_PH_QBLA:
|
|
check_dsp(ctx);
|
|
gen_helper_precequ_ph_qbla(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEQU_PH_QBRA:
|
|
check_dsp(ctx);
|
|
gen_helper_precequ_ph_qbra(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEU_PH_QBL:
|
|
check_dsp(ctx);
|
|
gen_helper_preceu_ph_qbl(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEU_PH_QBR:
|
|
check_dsp(ctx);
|
|
gen_helper_preceu_ph_qbr(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEU_PH_QBLA:
|
|
check_dsp(ctx);
|
|
gen_helper_preceu_ph_qbla(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_PRECEU_PH_QBRA:
|
|
check_dsp(ctx);
|
|
gen_helper_preceu_ph_qbra(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_REPLV_PH:
|
|
check_dsp(ctx);
|
|
tcg_gen_ext16u_tl(v0_t, v0_t);
|
|
tcg_gen_shli_tl(t0, v0_t, 16);
|
|
tcg_gen_or_tl(v0_t, v0_t, t0);
|
|
tcg_gen_ext32s_tl(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_REPLV_QB:
|
|
check_dsp(ctx);
|
|
tcg_gen_ext8u_tl(v0_t, v0_t);
|
|
tcg_gen_shli_tl(t0, v0_t, 8);
|
|
tcg_gen_or_tl(v0_t, v0_t, t0);
|
|
tcg_gen_shli_tl(t0, v0_t, 16);
|
|
tcg_gen_or_tl(v0_t, v0_t, t0);
|
|
tcg_gen_ext32s_tl(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_BITREV:
|
|
check_dsp(ctx);
|
|
gen_helper_bitrev(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_INSV:
|
|
check_dsp(ctx);
|
|
{
|
|
TCGv tv0 = tcg_temp_new();
|
|
|
|
gen_load_gpr(tv0, rt);
|
|
gen_helper_insv(v0_t, cpu_env, v0_t, tv0);
|
|
gen_store_gpr(v0_t, ret);
|
|
tcg_temp_free(tv0);
|
|
}
|
|
break;
|
|
case NM_RADDU_W_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_raddu_w_qb(v0_t, v0_t);
|
|
gen_store_gpr(v0_t, ret);
|
|
break;
|
|
case NM_BITSWAP:
|
|
gen_bitswap(ctx, OPC_BITSWAP, ret, rs);
|
|
break;
|
|
case NM_CLO:
|
|
check_nms(ctx);
|
|
gen_cl(ctx, OPC_CLO, ret, rs);
|
|
break;
|
|
case NM_CLZ:
|
|
check_nms(ctx);
|
|
gen_cl(ctx, OPC_CLZ, ret, rs);
|
|
break;
|
|
case NM_WSBH:
|
|
gen_bshfl(ctx, OPC_WSBH, ret, rs);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
|
|
tcg_temp_free(v0_t);
|
|
tcg_temp_free(t0);
|
|
}
|
|
|
|
static void gen_pool32axf_7_nanomips_insn(DisasContext *ctx, uint32_t opc,
|
|
int rt, int rs, int rd)
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv rs_t = tcg_temp_new();
|
|
|
|
gen_load_gpr(rs_t, rs);
|
|
|
|
switch (opc) {
|
|
case NM_SHRA_R_QB:
|
|
check_dsp_r2(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 2);
|
|
switch (extract32(ctx->opcode, 12, 1)) {
|
|
case 0:
|
|
/* NM_SHRA_QB */
|
|
gen_helper_shra_qb(t0, t0, rs_t);
|
|
gen_store_gpr(t0, rt);
|
|
break;
|
|
case 1:
|
|
/* NM_SHRA_R_QB */
|
|
gen_helper_shra_r_qb(t0, t0, rs_t);
|
|
gen_store_gpr(t0, rt);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SHRL_PH:
|
|
check_dsp_r2(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 1);
|
|
gen_helper_shrl_ph(t0, t0, rs_t);
|
|
gen_store_gpr(t0, rt);
|
|
break;
|
|
case NM_REPL_QB:
|
|
check_dsp(ctx);
|
|
{
|
|
int16_t imm;
|
|
target_long result;
|
|
imm = extract32(ctx->opcode, 13, 8);
|
|
result = (uint32_t)imm << 24 |
|
|
(uint32_t)imm << 16 |
|
|
(uint32_t)imm << 8 |
|
|
(uint32_t)imm;
|
|
result = (int32_t)result;
|
|
tcg_gen_movi_tl(t0, result);
|
|
gen_store_gpr(t0, rt);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(rs_t);
|
|
}
|
|
|
|
|
|
static void gen_pool32axf_nanomips_insn(CPUMIPSState *env, DisasContext *ctx)
|
|
{
|
|
int rt = extract32(ctx->opcode, 21, 5);
|
|
int rs = extract32(ctx->opcode, 16, 5);
|
|
int rd = extract32(ctx->opcode, 11, 5);
|
|
|
|
switch (extract32(ctx->opcode, 6, 3)) {
|
|
case NM_POOL32AXF_1:
|
|
{
|
|
int32_t op1 = extract32(ctx->opcode, 9, 3);
|
|
gen_pool32axf_1_nanomips_insn(ctx, op1, rt, rs, rd);
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_2:
|
|
{
|
|
int32_t op1 = extract32(ctx->opcode, 12, 2);
|
|
gen_pool32axf_2_nanomips_insn(ctx, op1, rt, rs, rd);
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_4:
|
|
{
|
|
int32_t op1 = extract32(ctx->opcode, 9, 7);
|
|
gen_pool32axf_4_nanomips_insn(ctx, op1, rt, rs);
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_5:
|
|
switch (extract32(ctx->opcode, 9, 7)) {
|
|
#ifndef CONFIG_USER_ONLY
|
|
case NM_TLBP:
|
|
gen_cp0(env, ctx, OPC_TLBP, 0, 0);
|
|
break;
|
|
case NM_TLBR:
|
|
gen_cp0(env, ctx, OPC_TLBR, 0, 0);
|
|
break;
|
|
case NM_TLBWI:
|
|
gen_cp0(env, ctx, OPC_TLBWI, 0, 0);
|
|
break;
|
|
case NM_TLBWR:
|
|
gen_cp0(env, ctx, OPC_TLBWR, 0, 0);
|
|
break;
|
|
case NM_TLBINV:
|
|
gen_cp0(env, ctx, OPC_TLBINV, 0, 0);
|
|
break;
|
|
case NM_TLBINVF:
|
|
gen_cp0(env, ctx, OPC_TLBINVF, 0, 0);
|
|
break;
|
|
case NM_DI:
|
|
check_cp0_enabled(ctx);
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
save_cpu_state(ctx, 1);
|
|
gen_helper_di(t0, cpu_env);
|
|
gen_store_gpr(t0, rt);
|
|
/* Stop translation as we may have switched the execution mode */
|
|
ctx->base.is_jmp = DISAS_STOP;
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
case NM_EI:
|
|
check_cp0_enabled(ctx);
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
save_cpu_state(ctx, 1);
|
|
gen_helper_ei(t0, cpu_env);
|
|
gen_store_gpr(t0, rt);
|
|
/* Stop translation as we may have switched the execution mode */
|
|
ctx->base.is_jmp = DISAS_STOP;
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
case NM_RDPGPR:
|
|
check_cp0_enabled(ctx);
|
|
gen_load_srsgpr(rs, rt);
|
|
break;
|
|
case NM_WRPGPR:
|
|
check_cp0_enabled(ctx);
|
|
gen_store_srsgpr(rs, rt);
|
|
break;
|
|
case NM_WAIT:
|
|
gen_cp0(env, ctx, OPC_WAIT, 0, 0);
|
|
break;
|
|
case NM_DERET:
|
|
gen_cp0(env, ctx, OPC_DERET, 0, 0);
|
|
break;
|
|
case NM_ERETX:
|
|
gen_cp0(env, ctx, OPC_ERET, 0, 0);
|
|
break;
|
|
#endif
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32AXF_7:
|
|
{
|
|
int32_t op1 = extract32(ctx->opcode, 9, 3);
|
|
gen_pool32axf_7_nanomips_insn(ctx, op1, rt, rs, rd);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Immediate Value Compact Branches */
|
|
static void gen_compute_imm_branch(DisasContext *ctx, uint32_t opc,
|
|
int rt, int32_t imm, int32_t offset)
|
|
{
|
|
TCGCond cond = TCG_COND_ALWAYS;
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
|
|
gen_load_gpr(t0, rt);
|
|
tcg_gen_movi_tl(t1, imm);
|
|
ctx->btarget = addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
|
|
/* Load needed operands and calculate btarget */
|
|
switch (opc) {
|
|
case NM_BEQIC:
|
|
if (rt == 0 && imm == 0) {
|
|
/* Unconditional branch */
|
|
} else if (rt == 0 && imm != 0) {
|
|
/* Treat as NOP */
|
|
goto out;
|
|
} else {
|
|
cond = TCG_COND_EQ;
|
|
}
|
|
break;
|
|
case NM_BBEQZC:
|
|
case NM_BBNEZC:
|
|
check_nms(ctx);
|
|
if (imm >= 32 && !(ctx->hflags & MIPS_HFLAG_64)) {
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
} else if (rt == 0 && opc == NM_BBEQZC) {
|
|
/* Unconditional branch */
|
|
} else if (rt == 0 && opc == NM_BBNEZC) {
|
|
/* Treat as NOP */
|
|
goto out;
|
|
} else {
|
|
tcg_gen_shri_tl(t0, t0, imm);
|
|
tcg_gen_andi_tl(t0, t0, 1);
|
|
tcg_gen_movi_tl(t1, 0);
|
|
if (opc == NM_BBEQZC) {
|
|
cond = TCG_COND_EQ;
|
|
} else {
|
|
cond = TCG_COND_NE;
|
|
}
|
|
}
|
|
break;
|
|
case NM_BNEIC:
|
|
if (rt == 0 && imm == 0) {
|
|
/* Treat as NOP */
|
|
goto out;
|
|
} else if (rt == 0 && imm != 0) {
|
|
/* Unconditional branch */
|
|
} else {
|
|
cond = TCG_COND_NE;
|
|
}
|
|
break;
|
|
case NM_BGEIC:
|
|
if (rt == 0 && imm == 0) {
|
|
/* Unconditional branch */
|
|
} else {
|
|
cond = TCG_COND_GE;
|
|
}
|
|
break;
|
|
case NM_BLTIC:
|
|
cond = TCG_COND_LT;
|
|
break;
|
|
case NM_BGEIUC:
|
|
if (rt == 0 && imm == 0) {
|
|
/* Unconditional branch */
|
|
} else {
|
|
cond = TCG_COND_GEU;
|
|
}
|
|
break;
|
|
case NM_BLTIUC:
|
|
cond = TCG_COND_LTU;
|
|
break;
|
|
default:
|
|
MIPS_INVAL("Immediate Value Compact branch");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
|
|
/* branch completion */
|
|
clear_branch_hflags(ctx);
|
|
ctx->base.is_jmp = DISAS_NORETURN;
|
|
|
|
if (cond == TCG_COND_ALWAYS) {
|
|
/* Uncoditional compact branch */
|
|
gen_goto_tb(ctx, 0, ctx->btarget);
|
|
} else {
|
|
/* Conditional compact branch */
|
|
TCGLabel *fs = gen_new_label();
|
|
|
|
tcg_gen_brcond_tl(tcg_invert_cond(cond), t0, t1, fs);
|
|
|
|
gen_goto_tb(ctx, 1, ctx->btarget);
|
|
gen_set_label(fs);
|
|
|
|
gen_goto_tb(ctx, 0, ctx->base.pc_next + 4);
|
|
}
|
|
|
|
out:
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
|
|
/* P.BALRSC type nanoMIPS R6 branches: BALRSC and BRSC */
|
|
static void gen_compute_nanomips_pbalrsc_branch(DisasContext *ctx, int rs,
|
|
int rt)
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
|
|
/* load rs */
|
|
gen_load_gpr(t0, rs);
|
|
|
|
/* link */
|
|
if (rt != 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[rt], ctx->base.pc_next + 4);
|
|
}
|
|
|
|
/* calculate btarget */
|
|
tcg_gen_shli_tl(t0, t0, 1);
|
|
tcg_gen_movi_tl(t1, ctx->base.pc_next + 4);
|
|
gen_op_addr_add(ctx, btarget, t1, t0);
|
|
|
|
/* branch completion */
|
|
clear_branch_hflags(ctx);
|
|
ctx->base.is_jmp = DISAS_NORETURN;
|
|
|
|
/* unconditional branch to register */
|
|
tcg_gen_mov_tl(cpu_PC, btarget);
|
|
tcg_gen_lookup_and_goto_ptr();
|
|
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
|
|
/* nanoMIPS Branches */
|
|
static void gen_compute_compact_branch_nm(DisasContext *ctx, uint32_t opc,
|
|
int rs, int rt, int32_t offset)
|
|
{
|
|
int bcond_compute = 0;
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
|
|
/* Load needed operands and calculate btarget */
|
|
switch (opc) {
|
|
/* compact branch */
|
|
case OPC_BGEC:
|
|
case OPC_BLTC:
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
bcond_compute = 1;
|
|
ctx->btarget = addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
break;
|
|
case OPC_BGEUC:
|
|
case OPC_BLTUC:
|
|
if (rs == 0 || rs == rt) {
|
|
/* OPC_BLEZALC, OPC_BGEZALC */
|
|
/* OPC_BGTZALC, OPC_BLTZALC */
|
|
tcg_gen_movi_tl(cpu_gpr[31], ctx->base.pc_next + 4);
|
|
}
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
bcond_compute = 1;
|
|
ctx->btarget = addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
break;
|
|
case OPC_BC:
|
|
ctx->btarget = addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
break;
|
|
case OPC_BEQZC:
|
|
if (rs != 0) {
|
|
/* OPC_BEQZC, OPC_BNEZC */
|
|
gen_load_gpr(t0, rs);
|
|
bcond_compute = 1;
|
|
ctx->btarget = addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
} else {
|
|
/* OPC_JIC, OPC_JIALC */
|
|
TCGv tbase = tcg_temp_new();
|
|
TCGv toffset = tcg_temp_new();
|
|
|
|
gen_load_gpr(tbase, rt);
|
|
tcg_gen_movi_tl(toffset, offset);
|
|
gen_op_addr_add(ctx, btarget, tbase, toffset);
|
|
tcg_temp_free(tbase);
|
|
tcg_temp_free(toffset);
|
|
}
|
|
break;
|
|
default:
|
|
MIPS_INVAL("Compact branch/jump");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
|
|
if (bcond_compute == 0) {
|
|
/* Uncoditional compact branch */
|
|
switch (opc) {
|
|
case OPC_BC:
|
|
gen_goto_tb(ctx, 0, ctx->btarget);
|
|
break;
|
|
default:
|
|
MIPS_INVAL("Compact branch/jump");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
} else {
|
|
/* Conditional compact branch */
|
|
TCGLabel *fs = gen_new_label();
|
|
|
|
switch (opc) {
|
|
case OPC_BGEUC:
|
|
if (rs == 0 && rt != 0) {
|
|
/* OPC_BLEZALC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_LE), t1, 0, fs);
|
|
} else if (rs != 0 && rt != 0 && rs == rt) {
|
|
/* OPC_BGEZALC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_GE), t1, 0, fs);
|
|
} else {
|
|
/* OPC_BGEUC */
|
|
tcg_gen_brcond_tl(tcg_invert_cond(TCG_COND_GEU), t0, t1, fs);
|
|
}
|
|
break;
|
|
case OPC_BLTUC:
|
|
if (rs == 0 && rt != 0) {
|
|
/* OPC_BGTZALC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_GT), t1, 0, fs);
|
|
} else if (rs != 0 && rt != 0 && rs == rt) {
|
|
/* OPC_BLTZALC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_LT), t1, 0, fs);
|
|
} else {
|
|
/* OPC_BLTUC */
|
|
tcg_gen_brcond_tl(tcg_invert_cond(TCG_COND_LTU), t0, t1, fs);
|
|
}
|
|
break;
|
|
case OPC_BGEC:
|
|
if (rs == 0 && rt != 0) {
|
|
/* OPC_BLEZC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_LE), t1, 0, fs);
|
|
} else if (rs != 0 && rt != 0 && rs == rt) {
|
|
/* OPC_BGEZC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_GE), t1, 0, fs);
|
|
} else {
|
|
/* OPC_BGEC */
|
|
tcg_gen_brcond_tl(tcg_invert_cond(TCG_COND_GE), t0, t1, fs);
|
|
}
|
|
break;
|
|
case OPC_BLTC:
|
|
if (rs == 0 && rt != 0) {
|
|
/* OPC_BGTZC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_GT), t1, 0, fs);
|
|
} else if (rs != 0 && rt != 0 && rs == rt) {
|
|
/* OPC_BLTZC */
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_LT), t1, 0, fs);
|
|
} else {
|
|
/* OPC_BLTC */
|
|
tcg_gen_brcond_tl(tcg_invert_cond(TCG_COND_LT), t0, t1, fs);
|
|
}
|
|
break;
|
|
case OPC_BEQZC:
|
|
tcg_gen_brcondi_tl(tcg_invert_cond(TCG_COND_EQ), t0, 0, fs);
|
|
break;
|
|
default:
|
|
MIPS_INVAL("Compact conditional branch/jump");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
|
|
/* branch completion */
|
|
clear_branch_hflags(ctx);
|
|
ctx->base.is_jmp = DISAS_NORETURN;
|
|
|
|
/* Generating branch here as compact branches don't have delay slot */
|
|
gen_goto_tb(ctx, 1, ctx->btarget);
|
|
gen_set_label(fs);
|
|
|
|
gen_goto_tb(ctx, 0, ctx->base.pc_next + 4);
|
|
}
|
|
|
|
out:
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
|
|
|
|
/* nanoMIPS CP1 Branches */
|
|
static void gen_compute_branch_cp1_nm(DisasContext *ctx, uint32_t op,
|
|
int32_t ft, int32_t offset)
|
|
{
|
|
target_ulong btarget;
|
|
TCGv_i64 t0 = tcg_temp_new_i64();
|
|
|
|
gen_load_fpr64(ctx, t0, ft);
|
|
tcg_gen_andi_i64(t0, t0, 1);
|
|
|
|
btarget = addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
|
|
switch (op) {
|
|
case NM_BC1EQZC:
|
|
tcg_gen_xori_i64(t0, t0, 1);
|
|
ctx->hflags |= MIPS_HFLAG_BC;
|
|
break;
|
|
case NM_BC1NEZC:
|
|
/* t0 already set */
|
|
ctx->hflags |= MIPS_HFLAG_BC;
|
|
break;
|
|
default:
|
|
MIPS_INVAL("cp1 cond branch");
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
|
|
tcg_gen_trunc_i64_tl(bcond, t0);
|
|
|
|
ctx->btarget = btarget;
|
|
|
|
out:
|
|
tcg_temp_free_i64(t0);
|
|
}
|
|
|
|
|
|
static void gen_p_lsx(DisasContext *ctx, int rd, int rs, int rt)
|
|
{
|
|
TCGv t0, t1;
|
|
t0 = tcg_temp_new();
|
|
t1 = tcg_temp_new();
|
|
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
|
|
if ((extract32(ctx->opcode, 6, 1)) == 1) {
|
|
/* PP.LSXS instructions require shifting */
|
|
switch (extract32(ctx->opcode, 7, 4)) {
|
|
case NM_SHXS:
|
|
check_nms(ctx);
|
|
/* fall through */
|
|
case NM_LHXS:
|
|
case NM_LHUXS:
|
|
tcg_gen_shli_tl(t0, t0, 1);
|
|
break;
|
|
case NM_SWXS:
|
|
check_nms(ctx);
|
|
/* fall through */
|
|
case NM_LWXS:
|
|
case NM_LWC1XS:
|
|
case NM_SWC1XS:
|
|
tcg_gen_shli_tl(t0, t0, 2);
|
|
break;
|
|
case NM_LDC1XS:
|
|
case NM_SDC1XS:
|
|
tcg_gen_shli_tl(t0, t0, 3);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
goto out;
|
|
}
|
|
}
|
|
gen_op_addr_add(ctx, t0, t0, t1);
|
|
|
|
switch (extract32(ctx->opcode, 7, 4)) {
|
|
case NM_LBX:
|
|
tcg_gen_qemu_ld_tl(t0, t0, ctx->mem_idx,
|
|
MO_SB);
|
|
gen_store_gpr(t0, rd);
|
|
break;
|
|
case NM_LHX:
|
|
/*case NM_LHXS:*/
|
|
tcg_gen_qemu_ld_tl(t0, t0, ctx->mem_idx,
|
|
MO_TESW);
|
|
gen_store_gpr(t0, rd);
|
|
break;
|
|
case NM_LWX:
|
|
/*case NM_LWXS:*/
|
|
tcg_gen_qemu_ld_tl(t0, t0, ctx->mem_idx,
|
|
MO_TESL);
|
|
gen_store_gpr(t0, rd);
|
|
break;
|
|
case NM_LBUX:
|
|
tcg_gen_qemu_ld_tl(t0, t0, ctx->mem_idx,
|
|
MO_UB);
|
|
gen_store_gpr(t0, rd);
|
|
break;
|
|
case NM_LHUX:
|
|
/*case NM_LHUXS:*/
|
|
tcg_gen_qemu_ld_tl(t0, t0, ctx->mem_idx,
|
|
MO_TEUW);
|
|
gen_store_gpr(t0, rd);
|
|
break;
|
|
case NM_SBX:
|
|
check_nms(ctx);
|
|
gen_load_gpr(t1, rd);
|
|
tcg_gen_qemu_st_tl(t1, t0, ctx->mem_idx,
|
|
MO_8);
|
|
break;
|
|
case NM_SHX:
|
|
/*case NM_SHXS:*/
|
|
check_nms(ctx);
|
|
gen_load_gpr(t1, rd);
|
|
tcg_gen_qemu_st_tl(t1, t0, ctx->mem_idx,
|
|
MO_TEUW);
|
|
break;
|
|
case NM_SWX:
|
|
/*case NM_SWXS:*/
|
|
check_nms(ctx);
|
|
gen_load_gpr(t1, rd);
|
|
tcg_gen_qemu_st_tl(t1, t0, ctx->mem_idx,
|
|
MO_TEUL);
|
|
break;
|
|
case NM_LWC1X:
|
|
/*case NM_LWC1XS:*/
|
|
case NM_LDC1X:
|
|
/*case NM_LDC1XS:*/
|
|
case NM_SWC1X:
|
|
/*case NM_SWC1XS:*/
|
|
case NM_SDC1X:
|
|
/*case NM_SDC1XS:*/
|
|
if (ctx->CP0_Config1 & (1 << CP0C1_FP)) {
|
|
check_cp1_enabled(ctx);
|
|
switch (extract32(ctx->opcode, 7, 4)) {
|
|
case NM_LWC1X:
|
|
/*case NM_LWC1XS:*/
|
|
gen_flt_ldst(ctx, OPC_LWC1, rd, t0);
|
|
break;
|
|
case NM_LDC1X:
|
|
/*case NM_LDC1XS:*/
|
|
gen_flt_ldst(ctx, OPC_LDC1, rd, t0);
|
|
break;
|
|
case NM_SWC1X:
|
|
/*case NM_SWC1XS:*/
|
|
gen_flt_ldst(ctx, OPC_SWC1, rd, t0);
|
|
break;
|
|
case NM_SDC1X:
|
|
/*case NM_SDC1XS:*/
|
|
gen_flt_ldst(ctx, OPC_SDC1, rd, t0);
|
|
break;
|
|
}
|
|
} else {
|
|
generate_exception_err(ctx, EXCP_CpU, 1);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
|
|
out:
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
|
|
static void gen_pool32f_nanomips_insn(DisasContext *ctx)
|
|
{
|
|
int rt, rs, rd;
|
|
|
|
rt = extract32(ctx->opcode, 21, 5);
|
|
rs = extract32(ctx->opcode, 16, 5);
|
|
rd = extract32(ctx->opcode, 11, 5);
|
|
|
|
if (!(ctx->CP0_Config1 & (1 << CP0C1_FP))) {
|
|
gen_reserved_instruction(ctx);
|
|
return;
|
|
}
|
|
check_cp1_enabled(ctx);
|
|
switch (extract32(ctx->opcode, 0, 3)) {
|
|
case NM_POOL32F_0:
|
|
switch (extract32(ctx->opcode, 3, 7)) {
|
|
case NM_RINT_S:
|
|
gen_farith(ctx, OPC_RINT_S, 0, rt, rs, 0);
|
|
break;
|
|
case NM_RINT_D:
|
|
gen_farith(ctx, OPC_RINT_D, 0, rt, rs, 0);
|
|
break;
|
|
case NM_CLASS_S:
|
|
gen_farith(ctx, OPC_CLASS_S, 0, rt, rs, 0);
|
|
break;
|
|
case NM_CLASS_D:
|
|
gen_farith(ctx, OPC_CLASS_D, 0, rt, rs, 0);
|
|
break;
|
|
case NM_ADD_S:
|
|
gen_farith(ctx, OPC_ADD_S, rt, rs, rd, 0);
|
|
break;
|
|
case NM_ADD_D:
|
|
gen_farith(ctx, OPC_ADD_D, rt, rs, rd, 0);
|
|
break;
|
|
case NM_SUB_S:
|
|
gen_farith(ctx, OPC_SUB_S, rt, rs, rd, 0);
|
|
break;
|
|
case NM_SUB_D:
|
|
gen_farith(ctx, OPC_SUB_D, rt, rs, rd, 0);
|
|
break;
|
|
case NM_MUL_S:
|
|
gen_farith(ctx, OPC_MUL_S, rt, rs, rd, 0);
|
|
break;
|
|
case NM_MUL_D:
|
|
gen_farith(ctx, OPC_MUL_D, rt, rs, rd, 0);
|
|
break;
|
|
case NM_DIV_S:
|
|
gen_farith(ctx, OPC_DIV_S, rt, rs, rd, 0);
|
|
break;
|
|
case NM_DIV_D:
|
|
gen_farith(ctx, OPC_DIV_D, rt, rs, rd, 0);
|
|
break;
|
|
case NM_SELEQZ_S:
|
|
gen_sel_s(ctx, OPC_SELEQZ_S, rd, rt, rs);
|
|
break;
|
|
case NM_SELEQZ_D:
|
|
gen_sel_d(ctx, OPC_SELEQZ_D, rd, rt, rs);
|
|
break;
|
|
case NM_SELNEZ_S:
|
|
gen_sel_s(ctx, OPC_SELNEZ_S, rd, rt, rs);
|
|
break;
|
|
case NM_SELNEZ_D:
|
|
gen_sel_d(ctx, OPC_SELNEZ_D, rd, rt, rs);
|
|
break;
|
|
case NM_SEL_S:
|
|
gen_sel_s(ctx, OPC_SEL_S, rd, rt, rs);
|
|
break;
|
|
case NM_SEL_D:
|
|
gen_sel_d(ctx, OPC_SEL_D, rd, rt, rs);
|
|
break;
|
|
case NM_MADDF_S:
|
|
gen_farith(ctx, OPC_MADDF_S, rt, rs, rd, 0);
|
|
break;
|
|
case NM_MADDF_D:
|
|
gen_farith(ctx, OPC_MADDF_D, rt, rs, rd, 0);
|
|
break;
|
|
case NM_MSUBF_S:
|
|
gen_farith(ctx, OPC_MSUBF_S, rt, rs, rd, 0);
|
|
break;
|
|
case NM_MSUBF_D:
|
|
gen_farith(ctx, OPC_MSUBF_D, rt, rs, rd, 0);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32F_3:
|
|
switch (extract32(ctx->opcode, 3, 3)) {
|
|
case NM_MIN_FMT:
|
|
switch (extract32(ctx->opcode, 9, 1)) {
|
|
case FMT_SDPS_S:
|
|
gen_farith(ctx, OPC_MIN_S, rt, rs, rd, 0);
|
|
break;
|
|
case FMT_SDPS_D:
|
|
gen_farith(ctx, OPC_MIN_D, rt, rs, rd, 0);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_MAX_FMT:
|
|
switch (extract32(ctx->opcode, 9, 1)) {
|
|
case FMT_SDPS_S:
|
|
gen_farith(ctx, OPC_MAX_S, rt, rs, rd, 0);
|
|
break;
|
|
case FMT_SDPS_D:
|
|
gen_farith(ctx, OPC_MAX_D, rt, rs, rd, 0);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_MINA_FMT:
|
|
switch (extract32(ctx->opcode, 9, 1)) {
|
|
case FMT_SDPS_S:
|
|
gen_farith(ctx, OPC_MINA_S, rt, rs, rd, 0);
|
|
break;
|
|
case FMT_SDPS_D:
|
|
gen_farith(ctx, OPC_MINA_D, rt, rs, rd, 0);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_MAXA_FMT:
|
|
switch (extract32(ctx->opcode, 9, 1)) {
|
|
case FMT_SDPS_S:
|
|
gen_farith(ctx, OPC_MAXA_S, rt, rs, rd, 0);
|
|
break;
|
|
case FMT_SDPS_D:
|
|
gen_farith(ctx, OPC_MAXA_D, rt, rs, rd, 0);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32FXF:
|
|
switch (extract32(ctx->opcode, 6, 8)) {
|
|
case NM_CFC1:
|
|
gen_cp1(ctx, OPC_CFC1, rt, rs);
|
|
break;
|
|
case NM_CTC1:
|
|
gen_cp1(ctx, OPC_CTC1, rt, rs);
|
|
break;
|
|
case NM_MFC1:
|
|
gen_cp1(ctx, OPC_MFC1, rt, rs);
|
|
break;
|
|
case NM_MTC1:
|
|
gen_cp1(ctx, OPC_MTC1, rt, rs);
|
|
break;
|
|
case NM_MFHC1:
|
|
gen_cp1(ctx, OPC_MFHC1, rt, rs);
|
|
break;
|
|
case NM_MTHC1:
|
|
gen_cp1(ctx, OPC_MTHC1, rt, rs);
|
|
break;
|
|
case NM_CVT_S_PL:
|
|
gen_farith(ctx, OPC_CVT_S_PL, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_S_PU:
|
|
gen_farith(ctx, OPC_CVT_S_PU, -1, rs, rt, 0);
|
|
break;
|
|
default:
|
|
switch (extract32(ctx->opcode, 6, 9)) {
|
|
case NM_CVT_L_S:
|
|
gen_farith(ctx, OPC_CVT_L_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_L_D:
|
|
gen_farith(ctx, OPC_CVT_L_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_W_S:
|
|
gen_farith(ctx, OPC_CVT_W_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_W_D:
|
|
gen_farith(ctx, OPC_CVT_W_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_RSQRT_S:
|
|
gen_farith(ctx, OPC_RSQRT_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_RSQRT_D:
|
|
gen_farith(ctx, OPC_RSQRT_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_SQRT_S:
|
|
gen_farith(ctx, OPC_SQRT_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_SQRT_D:
|
|
gen_farith(ctx, OPC_SQRT_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_RECIP_S:
|
|
gen_farith(ctx, OPC_RECIP_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_RECIP_D:
|
|
gen_farith(ctx, OPC_RECIP_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_FLOOR_L_S:
|
|
gen_farith(ctx, OPC_FLOOR_L_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_FLOOR_L_D:
|
|
gen_farith(ctx, OPC_FLOOR_L_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_FLOOR_W_S:
|
|
gen_farith(ctx, OPC_FLOOR_W_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_FLOOR_W_D:
|
|
gen_farith(ctx, OPC_FLOOR_W_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CEIL_L_S:
|
|
gen_farith(ctx, OPC_CEIL_L_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CEIL_L_D:
|
|
gen_farith(ctx, OPC_CEIL_L_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CEIL_W_S:
|
|
gen_farith(ctx, OPC_CEIL_W_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CEIL_W_D:
|
|
gen_farith(ctx, OPC_CEIL_W_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_TRUNC_L_S:
|
|
gen_farith(ctx, OPC_TRUNC_L_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_TRUNC_L_D:
|
|
gen_farith(ctx, OPC_TRUNC_L_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_TRUNC_W_S:
|
|
gen_farith(ctx, OPC_TRUNC_W_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_TRUNC_W_D:
|
|
gen_farith(ctx, OPC_TRUNC_W_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_ROUND_L_S:
|
|
gen_farith(ctx, OPC_ROUND_L_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_ROUND_L_D:
|
|
gen_farith(ctx, OPC_ROUND_L_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_ROUND_W_S:
|
|
gen_farith(ctx, OPC_ROUND_W_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_ROUND_W_D:
|
|
gen_farith(ctx, OPC_ROUND_W_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_MOV_S:
|
|
gen_farith(ctx, OPC_MOV_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_MOV_D:
|
|
gen_farith(ctx, OPC_MOV_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_ABS_S:
|
|
gen_farith(ctx, OPC_ABS_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_ABS_D:
|
|
gen_farith(ctx, OPC_ABS_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_NEG_S:
|
|
gen_farith(ctx, OPC_NEG_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_NEG_D:
|
|
gen_farith(ctx, OPC_NEG_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_D_S:
|
|
gen_farith(ctx, OPC_CVT_D_S, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_D_W:
|
|
gen_farith(ctx, OPC_CVT_D_W, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_D_L:
|
|
gen_farith(ctx, OPC_CVT_D_L, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_S_D:
|
|
gen_farith(ctx, OPC_CVT_S_D, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_S_W:
|
|
gen_farith(ctx, OPC_CVT_S_W, -1, rs, rt, 0);
|
|
break;
|
|
case NM_CVT_S_L:
|
|
gen_farith(ctx, OPC_CVT_S_L, -1, rs, rt, 0);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32F_5:
|
|
switch (extract32(ctx->opcode, 3, 3)) {
|
|
case NM_CMP_CONDN_S:
|
|
gen_r6_cmp_s(ctx, extract32(ctx->opcode, 6, 5), rt, rs, rd);
|
|
break;
|
|
case NM_CMP_CONDN_D:
|
|
gen_r6_cmp_d(ctx, extract32(ctx->opcode, 6, 5), rt, rs, rd);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void gen_pool32a5_nanomips_insn(DisasContext *ctx, int opc,
|
|
int rd, int rs, int rt)
|
|
{
|
|
int ret = rd;
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv v1_t = tcg_temp_new();
|
|
TCGv v2_t = tcg_temp_new();
|
|
|
|
gen_load_gpr(v1_t, rs);
|
|
gen_load_gpr(v2_t, rt);
|
|
|
|
switch (opc) {
|
|
case NM_CMP_EQ_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_cmp_eq_ph(v1_t, v2_t, cpu_env);
|
|
break;
|
|
case NM_CMP_LT_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_cmp_lt_ph(v1_t, v2_t, cpu_env);
|
|
break;
|
|
case NM_CMP_LE_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_cmp_le_ph(v1_t, v2_t, cpu_env);
|
|
break;
|
|
case NM_CMPU_EQ_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_cmpu_eq_qb(v1_t, v2_t, cpu_env);
|
|
break;
|
|
case NM_CMPU_LT_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_cmpu_lt_qb(v1_t, v2_t, cpu_env);
|
|
break;
|
|
case NM_CMPU_LE_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_cmpu_le_qb(v1_t, v2_t, cpu_env);
|
|
break;
|
|
case NM_CMPGU_EQ_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_cmpgu_eq_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_CMPGU_LT_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_cmpgu_lt_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_CMPGU_LE_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_cmpgu_le_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_CMPGDU_EQ_QB:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_cmpgu_eq_qb(v1_t, v1_t, v2_t);
|
|
tcg_gen_deposit_tl(cpu_dspctrl, cpu_dspctrl, v1_t, 24, 4);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_CMPGDU_LT_QB:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_cmpgu_lt_qb(v1_t, v1_t, v2_t);
|
|
tcg_gen_deposit_tl(cpu_dspctrl, cpu_dspctrl, v1_t, 24, 4);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_CMPGDU_LE_QB:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_cmpgu_le_qb(v1_t, v1_t, v2_t);
|
|
tcg_gen_deposit_tl(cpu_dspctrl, cpu_dspctrl, v1_t, 24, 4);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_PACKRL_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_packrl_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_PICK_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_pick_qb(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_PICK_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_pick_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_ADDQ_S_W:
|
|
check_dsp(ctx);
|
|
gen_helper_addq_s_w(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SUBQ_S_W:
|
|
check_dsp(ctx);
|
|
gen_helper_subq_s_w(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_ADDSC:
|
|
check_dsp(ctx);
|
|
gen_helper_addsc(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_ADDWC:
|
|
check_dsp(ctx);
|
|
gen_helper_addwc(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_ADDQ_S_PH:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* ADDQ_PH */
|
|
gen_helper_addq_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* ADDQ_S_PH */
|
|
gen_helper_addq_s_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_ADDQH_R_PH:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* ADDQH_PH */
|
|
gen_helper_addqh_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* ADDQH_R_PH */
|
|
gen_helper_addqh_r_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_ADDQH_R_W:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* ADDQH_W */
|
|
gen_helper_addqh_w(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* ADDQH_R_W */
|
|
gen_helper_addqh_r_w(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_ADDU_S_QB:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* ADDU_QB */
|
|
gen_helper_addu_qb(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* ADDU_S_QB */
|
|
gen_helper_addu_s_qb(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_ADDU_S_PH:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* ADDU_PH */
|
|
gen_helper_addu_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* ADDU_S_PH */
|
|
gen_helper_addu_s_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_ADDUH_R_QB:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* ADDUH_QB */
|
|
gen_helper_adduh_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* ADDUH_R_QB */
|
|
gen_helper_adduh_r_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SHRAV_R_PH:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SHRAV_PH */
|
|
gen_helper_shra_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SHRAV_R_PH */
|
|
gen_helper_shra_r_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SHRAV_R_QB:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SHRAV_QB */
|
|
gen_helper_shra_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SHRAV_R_QB */
|
|
gen_helper_shra_r_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SUBQ_S_PH:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SUBQ_PH */
|
|
gen_helper_subq_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SUBQ_S_PH */
|
|
gen_helper_subq_s_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SUBQH_R_PH:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SUBQH_PH */
|
|
gen_helper_subqh_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SUBQH_R_PH */
|
|
gen_helper_subqh_r_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SUBQH_R_W:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SUBQH_W */
|
|
gen_helper_subqh_w(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SUBQH_R_W */
|
|
gen_helper_subqh_r_w(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SUBU_S_QB:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SUBU_QB */
|
|
gen_helper_subu_qb(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SUBU_S_QB */
|
|
gen_helper_subu_s_qb(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SUBU_S_PH:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SUBU_PH */
|
|
gen_helper_subu_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SUBU_S_PH */
|
|
gen_helper_subu_s_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SUBUH_R_QB:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SUBUH_QB */
|
|
gen_helper_subuh_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SUBUH_R_QB */
|
|
gen_helper_subuh_r_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SHLLV_S_PH:
|
|
check_dsp(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SHLLV_PH */
|
|
gen_helper_shll_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* SHLLV_S_PH */
|
|
gen_helper_shll_s_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_PRECR_SRA_R_PH_W:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* PRECR_SRA_PH_W */
|
|
{
|
|
TCGv_i32 sa_t = tcg_const_i32(rd);
|
|
gen_helper_precr_sra_ph_w(v1_t, sa_t, v1_t,
|
|
cpu_gpr[rt]);
|
|
gen_store_gpr(v1_t, rt);
|
|
tcg_temp_free_i32(sa_t);
|
|
}
|
|
break;
|
|
case 1:
|
|
/* PRECR_SRA_R_PH_W */
|
|
{
|
|
TCGv_i32 sa_t = tcg_const_i32(rd);
|
|
gen_helper_precr_sra_r_ph_w(v1_t, sa_t, v1_t,
|
|
cpu_gpr[rt]);
|
|
gen_store_gpr(v1_t, rt);
|
|
tcg_temp_free_i32(sa_t);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case NM_MULEU_S_PH_QBL:
|
|
check_dsp(ctx);
|
|
gen_helper_muleu_s_ph_qbl(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_MULEU_S_PH_QBR:
|
|
check_dsp(ctx);
|
|
gen_helper_muleu_s_ph_qbr(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_MULQ_RS_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_mulq_rs_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_MULQ_S_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_mulq_s_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_MULQ_RS_W:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_mulq_rs_w(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_MULQ_S_W:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_mulq_s_w(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_APPEND:
|
|
check_dsp_r2(ctx);
|
|
gen_load_gpr(t0, rs);
|
|
if (rd != 0) {
|
|
tcg_gen_deposit_tl(cpu_gpr[rt], t0, cpu_gpr[rt], rd, 32 - rd);
|
|
}
|
|
tcg_gen_ext32s_tl(cpu_gpr[rt], cpu_gpr[rt]);
|
|
break;
|
|
case NM_MODSUB:
|
|
check_dsp(ctx);
|
|
gen_helper_modsub(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SHRAV_R_W:
|
|
check_dsp(ctx);
|
|
gen_helper_shra_r_w(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SHRLV_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_shrl_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SHRLV_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_shrl_qb(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SHLLV_QB:
|
|
check_dsp(ctx);
|
|
gen_helper_shll_qb(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SHLLV_S_W:
|
|
check_dsp(ctx);
|
|
gen_helper_shll_s_w(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SHILO:
|
|
check_dsp(ctx);
|
|
{
|
|
TCGv tv0 = tcg_temp_new();
|
|
TCGv tv1 = tcg_temp_new();
|
|
int16_t imm = extract32(ctx->opcode, 16, 7);
|
|
|
|
tcg_gen_movi_tl(tv0, rd >> 3);
|
|
tcg_gen_movi_tl(tv1, imm);
|
|
gen_helper_shilo(tv0, tv1, cpu_env);
|
|
tcg_temp_free(tv1);
|
|
tcg_temp_free(tv0);
|
|
}
|
|
break;
|
|
case NM_MULEQ_S_W_PHL:
|
|
check_dsp(ctx);
|
|
gen_helper_muleq_s_w_phl(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_MULEQ_S_W_PHR:
|
|
check_dsp(ctx);
|
|
gen_helper_muleq_s_w_phr(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_MUL_S_PH:
|
|
check_dsp_r2(ctx);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* MUL_PH */
|
|
gen_helper_mul_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case 1:
|
|
/* MUL_S_PH */
|
|
gen_helper_mul_s_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_PRECR_QB_PH:
|
|
check_dsp_r2(ctx);
|
|
gen_helper_precr_qb_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_PRECRQ_QB_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_precrq_qb_ph(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_PRECRQ_PH_W:
|
|
check_dsp(ctx);
|
|
gen_helper_precrq_ph_w(v1_t, v1_t, v2_t);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_PRECRQ_RS_PH_W:
|
|
check_dsp(ctx);
|
|
gen_helper_precrq_rs_ph_w(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_PRECRQU_S_QB_PH:
|
|
check_dsp(ctx);
|
|
gen_helper_precrqu_s_qb_ph(v1_t, v1_t, v2_t, cpu_env);
|
|
gen_store_gpr(v1_t, ret);
|
|
break;
|
|
case NM_SHRA_R_W:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd);
|
|
gen_helper_shra_r_w(v1_t, t0, v1_t);
|
|
gen_store_gpr(v1_t, rt);
|
|
break;
|
|
case NM_SHRA_R_PH:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 1);
|
|
switch (extract32(ctx->opcode, 10, 1)) {
|
|
case 0:
|
|
/* SHRA_PH */
|
|
gen_helper_shra_ph(v1_t, t0, v1_t);
|
|
gen_store_gpr(v1_t, rt);
|
|
break;
|
|
case 1:
|
|
/* SHRA_R_PH */
|
|
gen_helper_shra_r_ph(v1_t, t0, v1_t);
|
|
gen_store_gpr(v1_t, rt);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SHLL_S_PH:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd >> 1);
|
|
switch (extract32(ctx->opcode, 10, 2)) {
|
|
case 0:
|
|
/* SHLL_PH */
|
|
gen_helper_shll_ph(v1_t, t0, v1_t, cpu_env);
|
|
gen_store_gpr(v1_t, rt);
|
|
break;
|
|
case 2:
|
|
/* SHLL_S_PH */
|
|
gen_helper_shll_s_ph(v1_t, t0, v1_t, cpu_env);
|
|
gen_store_gpr(v1_t, rt);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SHLL_S_W:
|
|
check_dsp(ctx);
|
|
tcg_gen_movi_tl(t0, rd);
|
|
gen_helper_shll_s_w(v1_t, t0, v1_t, cpu_env);
|
|
gen_store_gpr(v1_t, rt);
|
|
break;
|
|
case NM_REPL_PH:
|
|
check_dsp(ctx);
|
|
{
|
|
int16_t imm;
|
|
imm = sextract32(ctx->opcode, 11, 11);
|
|
imm = (int16_t)(imm << 6) >> 6;
|
|
if (rt != 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[rt], dup_const(MO_16, imm));
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
|
|
tcg_temp_free(v2_t);
|
|
tcg_temp_free(v1_t);
|
|
tcg_temp_free(t0);
|
|
}
|
|
|
|
static int decode_nanomips_32_48_opc(CPUMIPSState *env, DisasContext *ctx)
|
|
{
|
|
uint16_t insn;
|
|
uint32_t op;
|
|
int rt, rs, rd;
|
|
int offset;
|
|
int imm;
|
|
|
|
insn = translator_lduw(env, &ctx->base, ctx->base.pc_next + 2);
|
|
ctx->opcode = (ctx->opcode << 16) | insn;
|
|
|
|
rt = extract32(ctx->opcode, 21, 5);
|
|
rs = extract32(ctx->opcode, 16, 5);
|
|
rd = extract32(ctx->opcode, 11, 5);
|
|
|
|
op = extract32(ctx->opcode, 26, 6);
|
|
switch (op) {
|
|
case NM_P_ADDIU:
|
|
if (rt == 0) {
|
|
/* P.RI */
|
|
switch (extract32(ctx->opcode, 19, 2)) {
|
|
case NM_SIGRIE:
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
case NM_P_SYSCALL:
|
|
if ((extract32(ctx->opcode, 18, 1)) == NM_SYSCALL) {
|
|
generate_exception_end(ctx, EXCP_SYSCALL);
|
|
} else {
|
|
gen_reserved_instruction(ctx);
|
|
}
|
|
break;
|
|
case NM_BREAK:
|
|
generate_exception_end(ctx, EXCP_BREAK);
|
|
break;
|
|
case NM_SDBBP:
|
|
if (is_uhi(ctx, extract32(ctx->opcode, 0, 19))) {
|
|
ctx->base.is_jmp = DISAS_SEMIHOST;
|
|
} else {
|
|
if (ctx->hflags & MIPS_HFLAG_SBRI) {
|
|
gen_reserved_instruction(ctx);
|
|
} else {
|
|
generate_exception_end(ctx, EXCP_DBp);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
/* NM_ADDIU */
|
|
imm = extract32(ctx->opcode, 0, 16);
|
|
if (rs != 0) {
|
|
tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rs], imm);
|
|
} else {
|
|
tcg_gen_movi_tl(cpu_gpr[rt], imm);
|
|
}
|
|
tcg_gen_ext32s_tl(cpu_gpr[rt], cpu_gpr[rt]);
|
|
}
|
|
break;
|
|
case NM_ADDIUPC:
|
|
if (rt != 0) {
|
|
offset = sextract32(ctx->opcode, 0, 1) << 21 |
|
|
extract32(ctx->opcode, 1, 20) << 1;
|
|
target_long addr = addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
tcg_gen_movi_tl(cpu_gpr[rt], addr);
|
|
}
|
|
break;
|
|
case NM_POOL32A:
|
|
switch (ctx->opcode & 0x07) {
|
|
case NM_POOL32A0:
|
|
gen_pool32a0_nanomips_insn(env, ctx);
|
|
break;
|
|
case NM_POOL32A5:
|
|
{
|
|
int32_t op1 = extract32(ctx->opcode, 3, 7);
|
|
gen_pool32a5_nanomips_insn(ctx, op1, rd, rs, rt);
|
|
}
|
|
break;
|
|
case NM_POOL32A7:
|
|
switch (extract32(ctx->opcode, 3, 3)) {
|
|
case NM_P_LSX:
|
|
gen_p_lsx(ctx, rd, rs, rt);
|
|
break;
|
|
case NM_LSA:
|
|
/*
|
|
* In nanoMIPS, the shift field directly encodes the shift
|
|
* amount, meaning that the supported shift values are in
|
|
* the range 0 to 3 (instead of 1 to 4 in MIPSR6).
|
|
*/
|
|
gen_lsa(ctx, rd, rt, rs, extract32(ctx->opcode, 9, 2) - 1);
|
|
break;
|
|
case NM_EXTW:
|
|
gen_ext(ctx, 32, rd, rs, rt, extract32(ctx->opcode, 6, 5));
|
|
break;
|
|
case NM_POOL32AXF:
|
|
gen_pool32axf_nanomips_insn(env, ctx);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_GP_W:
|
|
switch (ctx->opcode & 0x03) {
|
|
case NM_ADDIUGP_W:
|
|
if (rt != 0) {
|
|
offset = extract32(ctx->opcode, 0, 21);
|
|
gen_op_addr_addi(ctx, cpu_gpr[rt], cpu_gpr[28], offset);
|
|
}
|
|
break;
|
|
case NM_LWGP:
|
|
gen_ld(ctx, OPC_LW, rt, 28, extract32(ctx->opcode, 2, 19) << 2);
|
|
break;
|
|
case NM_SWGP:
|
|
gen_st(ctx, OPC_SW, rt, 28, extract32(ctx->opcode, 2, 19) << 2);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P48I:
|
|
{
|
|
insn = translator_lduw(env, &ctx->base, ctx->base.pc_next + 4);
|
|
target_long addr_off = extract32(ctx->opcode, 0, 16) | insn << 16;
|
|
switch (extract32(ctx->opcode, 16, 5)) {
|
|
case NM_LI48:
|
|
check_nms(ctx);
|
|
if (rt != 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[rt], addr_off);
|
|
}
|
|
break;
|
|
case NM_ADDIU48:
|
|
check_nms(ctx);
|
|
if (rt != 0) {
|
|
tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rt], addr_off);
|
|
tcg_gen_ext32s_tl(cpu_gpr[rt], cpu_gpr[rt]);
|
|
}
|
|
break;
|
|
case NM_ADDIUGP48:
|
|
check_nms(ctx);
|
|
if (rt != 0) {
|
|
gen_op_addr_addi(ctx, cpu_gpr[rt], cpu_gpr[28], addr_off);
|
|
}
|
|
break;
|
|
case NM_ADDIUPC48:
|
|
check_nms(ctx);
|
|
if (rt != 0) {
|
|
target_long addr = addr_add(ctx, ctx->base.pc_next + 6,
|
|
addr_off);
|
|
|
|
tcg_gen_movi_tl(cpu_gpr[rt], addr);
|
|
}
|
|
break;
|
|
case NM_LWPC48:
|
|
check_nms(ctx);
|
|
if (rt != 0) {
|
|
TCGv t0;
|
|
t0 = tcg_temp_new();
|
|
|
|
target_long addr = addr_add(ctx, ctx->base.pc_next + 6,
|
|
addr_off);
|
|
|
|
tcg_gen_movi_tl(t0, addr);
|
|
tcg_gen_qemu_ld_tl(cpu_gpr[rt], t0, ctx->mem_idx, MO_TESL);
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
case NM_SWPC48:
|
|
check_nms(ctx);
|
|
{
|
|
TCGv t0, t1;
|
|
t0 = tcg_temp_new();
|
|
t1 = tcg_temp_new();
|
|
|
|
target_long addr = addr_add(ctx, ctx->base.pc_next + 6,
|
|
addr_off);
|
|
|
|
tcg_gen_movi_tl(t0, addr);
|
|
gen_load_gpr(t1, rt);
|
|
|
|
tcg_gen_qemu_st_tl(t1, t0, ctx->mem_idx, MO_TEUL);
|
|
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
return 6;
|
|
}
|
|
case NM_P_U12:
|
|
switch (extract32(ctx->opcode, 12, 4)) {
|
|
case NM_ORI:
|
|
gen_logic_imm(ctx, OPC_ORI, rt, rs, extract32(ctx->opcode, 0, 12));
|
|
break;
|
|
case NM_XORI:
|
|
gen_logic_imm(ctx, OPC_XORI, rt, rs, extract32(ctx->opcode, 0, 12));
|
|
break;
|
|
case NM_ANDI:
|
|
gen_logic_imm(ctx, OPC_ANDI, rt, rs, extract32(ctx->opcode, 0, 12));
|
|
break;
|
|
case NM_P_SR:
|
|
switch (extract32(ctx->opcode, 20, 1)) {
|
|
case NM_PP_SR:
|
|
switch (ctx->opcode & 3) {
|
|
case NM_SAVE:
|
|
gen_save(ctx, rt, extract32(ctx->opcode, 16, 4),
|
|
extract32(ctx->opcode, 2, 1),
|
|
extract32(ctx->opcode, 3, 9) << 3);
|
|
break;
|
|
case NM_RESTORE:
|
|
case NM_RESTORE_JRC:
|
|
gen_restore(ctx, rt, extract32(ctx->opcode, 16, 4),
|
|
extract32(ctx->opcode, 2, 1),
|
|
extract32(ctx->opcode, 3, 9) << 3);
|
|
if ((ctx->opcode & 3) == NM_RESTORE_JRC) {
|
|
gen_compute_branch_nm(ctx, OPC_JR, 2, 31, 0, 0);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_SR_F:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_SLTI:
|
|
gen_slt_imm(ctx, OPC_SLTI, rt, rs, extract32(ctx->opcode, 0, 12));
|
|
break;
|
|
case NM_SLTIU:
|
|
gen_slt_imm(ctx, OPC_SLTIU, rt, rs, extract32(ctx->opcode, 0, 12));
|
|
break;
|
|
case NM_SEQI:
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
|
|
imm = extract32(ctx->opcode, 0, 12);
|
|
gen_load_gpr(t0, rs);
|
|
tcg_gen_setcondi_tl(TCG_COND_EQ, t0, t0, imm);
|
|
gen_store_gpr(t0, rt);
|
|
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
case NM_ADDIUNEG:
|
|
imm = (int16_t) extract32(ctx->opcode, 0, 12);
|
|
gen_arith_imm(ctx, OPC_ADDIU, rt, rs, -imm);
|
|
break;
|
|
case NM_P_SHIFT:
|
|
{
|
|
int shift = extract32(ctx->opcode, 0, 5);
|
|
switch (extract32(ctx->opcode, 5, 4)) {
|
|
case NM_P_SLL:
|
|
if (rt == 0 && shift == 0) {
|
|
/* NOP */
|
|
} else if (rt == 0 && shift == 3) {
|
|
/* EHB - treat as NOP */
|
|
} else if (rt == 0 && shift == 5) {
|
|
/* PAUSE - treat as NOP */
|
|
} else if (rt == 0 && shift == 6) {
|
|
/* SYNC */
|
|
gen_sync(extract32(ctx->opcode, 16, 5));
|
|
} else {
|
|
/* SLL */
|
|
gen_shift_imm(ctx, OPC_SLL, rt, rs,
|
|
extract32(ctx->opcode, 0, 5));
|
|
}
|
|
break;
|
|
case NM_SRL:
|
|
gen_shift_imm(ctx, OPC_SRL, rt, rs,
|
|
extract32(ctx->opcode, 0, 5));
|
|
break;
|
|
case NM_SRA:
|
|
gen_shift_imm(ctx, OPC_SRA, rt, rs,
|
|
extract32(ctx->opcode, 0, 5));
|
|
break;
|
|
case NM_ROTR:
|
|
gen_shift_imm(ctx, OPC_ROTR, rt, rs,
|
|
extract32(ctx->opcode, 0, 5));
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_P_ROTX:
|
|
check_nms(ctx);
|
|
if (rt != 0) {
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv_i32 shift = tcg_const_i32(extract32(ctx->opcode, 0, 5));
|
|
TCGv_i32 shiftx = tcg_const_i32(extract32(ctx->opcode, 7, 4)
|
|
<< 1);
|
|
TCGv_i32 stripe = tcg_const_i32(extract32(ctx->opcode, 6, 1));
|
|
|
|
gen_load_gpr(t0, rs);
|
|
gen_helper_rotx(cpu_gpr[rt], t0, shift, shiftx, stripe);
|
|
tcg_temp_free(t0);
|
|
|
|
tcg_temp_free_i32(shift);
|
|
tcg_temp_free_i32(shiftx);
|
|
tcg_temp_free_i32(stripe);
|
|
}
|
|
break;
|
|
case NM_P_INS:
|
|
switch (((ctx->opcode >> 10) & 2) |
|
|
(extract32(ctx->opcode, 5, 1))) {
|
|
case NM_INS:
|
|
check_nms(ctx);
|
|
gen_bitops(ctx, OPC_INS, rt, rs, extract32(ctx->opcode, 0, 5),
|
|
extract32(ctx->opcode, 6, 5));
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_EXT:
|
|
switch (((ctx->opcode >> 10) & 2) |
|
|
(extract32(ctx->opcode, 5, 1))) {
|
|
case NM_EXT:
|
|
check_nms(ctx);
|
|
gen_bitops(ctx, OPC_EXT, rt, rs, extract32(ctx->opcode, 0, 5),
|
|
extract32(ctx->opcode, 6, 5));
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_POOL32F:
|
|
gen_pool32f_nanomips_insn(ctx);
|
|
break;
|
|
case NM_POOL32S:
|
|
break;
|
|
case NM_P_LUI:
|
|
switch (extract32(ctx->opcode, 1, 1)) {
|
|
case NM_LUI:
|
|
if (rt != 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[rt],
|
|
sextract32(ctx->opcode, 0, 1) << 31 |
|
|
extract32(ctx->opcode, 2, 10) << 21 |
|
|
extract32(ctx->opcode, 12, 9) << 12);
|
|
}
|
|
break;
|
|
case NM_ALUIPC:
|
|
if (rt != 0) {
|
|
offset = sextract32(ctx->opcode, 0, 1) << 31 |
|
|
extract32(ctx->opcode, 2, 10) << 21 |
|
|
extract32(ctx->opcode, 12, 9) << 12;
|
|
target_long addr;
|
|
addr = ~0xFFF & addr_add(ctx, ctx->base.pc_next + 4, offset);
|
|
tcg_gen_movi_tl(cpu_gpr[rt], addr);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_GP_BH:
|
|
{
|
|
uint32_t u = extract32(ctx->opcode, 0, 18);
|
|
|
|
switch (extract32(ctx->opcode, 18, 3)) {
|
|
case NM_LBGP:
|
|
gen_ld(ctx, OPC_LB, rt, 28, u);
|
|
break;
|
|
case NM_SBGP:
|
|
gen_st(ctx, OPC_SB, rt, 28, u);
|
|
break;
|
|
case NM_LBUGP:
|
|
gen_ld(ctx, OPC_LBU, rt, 28, u);
|
|
break;
|
|
case NM_ADDIUGP_B:
|
|
if (rt != 0) {
|
|
gen_op_addr_addi(ctx, cpu_gpr[rt], cpu_gpr[28], u);
|
|
}
|
|
break;
|
|
case NM_P_GP_LH:
|
|
u &= ~1;
|
|
switch (ctx->opcode & 1) {
|
|
case NM_LHGP:
|
|
gen_ld(ctx, OPC_LH, rt, 28, u);
|
|
break;
|
|
case NM_LHUGP:
|
|
gen_ld(ctx, OPC_LHU, rt, 28, u);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_GP_SH:
|
|
u &= ~1;
|
|
switch (ctx->opcode & 1) {
|
|
case NM_SHGP:
|
|
gen_st(ctx, OPC_SH, rt, 28, u);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_GP_CP1:
|
|
u &= ~0x3;
|
|
switch (ctx->opcode & 0x3) {
|
|
case NM_LWC1GP:
|
|
gen_cop1_ldst(ctx, OPC_LWC1, rt, 28, u);
|
|
break;
|
|
case NM_LDC1GP:
|
|
gen_cop1_ldst(ctx, OPC_LDC1, rt, 28, u);
|
|
break;
|
|
case NM_SWC1GP:
|
|
gen_cop1_ldst(ctx, OPC_SWC1, rt, 28, u);
|
|
break;
|
|
case NM_SDC1GP:
|
|
gen_cop1_ldst(ctx, OPC_SDC1, rt, 28, u);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_P_LS_U12:
|
|
{
|
|
uint32_t u = extract32(ctx->opcode, 0, 12);
|
|
|
|
switch (extract32(ctx->opcode, 12, 4)) {
|
|
case NM_P_PREFU12:
|
|
if (rt == 31) {
|
|
/* SYNCI */
|
|
/*
|
|
* Break the TB to be able to sync copied instructions
|
|
* immediately.
|
|
*/
|
|
ctx->base.is_jmp = DISAS_STOP;
|
|
} else {
|
|
/* PREF */
|
|
/* Treat as NOP. */
|
|
}
|
|
break;
|
|
case NM_LB:
|
|
gen_ld(ctx, OPC_LB, rt, rs, u);
|
|
break;
|
|
case NM_LH:
|
|
gen_ld(ctx, OPC_LH, rt, rs, u);
|
|
break;
|
|
case NM_LW:
|
|
gen_ld(ctx, OPC_LW, rt, rs, u);
|
|
break;
|
|
case NM_LBU:
|
|
gen_ld(ctx, OPC_LBU, rt, rs, u);
|
|
break;
|
|
case NM_LHU:
|
|
gen_ld(ctx, OPC_LHU, rt, rs, u);
|
|
break;
|
|
case NM_SB:
|
|
gen_st(ctx, OPC_SB, rt, rs, u);
|
|
break;
|
|
case NM_SH:
|
|
gen_st(ctx, OPC_SH, rt, rs, u);
|
|
break;
|
|
case NM_SW:
|
|
gen_st(ctx, OPC_SW, rt, rs, u);
|
|
break;
|
|
case NM_LWC1:
|
|
gen_cop1_ldst(ctx, OPC_LWC1, rt, rs, u);
|
|
break;
|
|
case NM_LDC1:
|
|
gen_cop1_ldst(ctx, OPC_LDC1, rt, rs, u);
|
|
break;
|
|
case NM_SWC1:
|
|
gen_cop1_ldst(ctx, OPC_SWC1, rt, rs, u);
|
|
break;
|
|
case NM_SDC1:
|
|
gen_cop1_ldst(ctx, OPC_SDC1, rt, rs, u);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_P_LS_S9:
|
|
{
|
|
int32_t s = (sextract32(ctx->opcode, 15, 1) << 8) |
|
|
extract32(ctx->opcode, 0, 8);
|
|
|
|
switch (extract32(ctx->opcode, 8, 3)) {
|
|
case NM_P_LS_S0:
|
|
switch (extract32(ctx->opcode, 11, 4)) {
|
|
case NM_LBS9:
|
|
gen_ld(ctx, OPC_LB, rt, rs, s);
|
|
break;
|
|
case NM_LHS9:
|
|
gen_ld(ctx, OPC_LH, rt, rs, s);
|
|
break;
|
|
case NM_LWS9:
|
|
gen_ld(ctx, OPC_LW, rt, rs, s);
|
|
break;
|
|
case NM_LBUS9:
|
|
gen_ld(ctx, OPC_LBU, rt, rs, s);
|
|
break;
|
|
case NM_LHUS9:
|
|
gen_ld(ctx, OPC_LHU, rt, rs, s);
|
|
break;
|
|
case NM_SBS9:
|
|
gen_st(ctx, OPC_SB, rt, rs, s);
|
|
break;
|
|
case NM_SHS9:
|
|
gen_st(ctx, OPC_SH, rt, rs, s);
|
|
break;
|
|
case NM_SWS9:
|
|
gen_st(ctx, OPC_SW, rt, rs, s);
|
|
break;
|
|
case NM_LWC1S9:
|
|
gen_cop1_ldst(ctx, OPC_LWC1, rt, rs, s);
|
|
break;
|
|
case NM_LDC1S9:
|
|
gen_cop1_ldst(ctx, OPC_LDC1, rt, rs, s);
|
|
break;
|
|
case NM_SWC1S9:
|
|
gen_cop1_ldst(ctx, OPC_SWC1, rt, rs, s);
|
|
break;
|
|
case NM_SDC1S9:
|
|
gen_cop1_ldst(ctx, OPC_SDC1, rt, rs, s);
|
|
break;
|
|
case NM_P_PREFS9:
|
|
if (rt == 31) {
|
|
/* SYNCI */
|
|
/*
|
|
* Break the TB to be able to sync copied instructions
|
|
* immediately.
|
|
*/
|
|
ctx->base.is_jmp = DISAS_STOP;
|
|
} else {
|
|
/* PREF */
|
|
/* Treat as NOP. */
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_LS_S1:
|
|
switch (extract32(ctx->opcode, 11, 4)) {
|
|
case NM_UALH:
|
|
case NM_UASH:
|
|
check_nms(ctx);
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
|
|
gen_base_offset_addr(ctx, t0, rs, s);
|
|
|
|
switch (extract32(ctx->opcode, 11, 4)) {
|
|
case NM_UALH:
|
|
tcg_gen_qemu_ld_tl(t0, t0, ctx->mem_idx, MO_TESW |
|
|
MO_UNALN);
|
|
gen_store_gpr(t0, rt);
|
|
break;
|
|
case NM_UASH:
|
|
gen_load_gpr(t1, rt);
|
|
tcg_gen_qemu_st_tl(t1, t0, ctx->mem_idx, MO_TEUW |
|
|
MO_UNALN);
|
|
break;
|
|
}
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
break;
|
|
case NM_P_LL:
|
|
switch (ctx->opcode & 0x03) {
|
|
case NM_LL:
|
|
gen_ld(ctx, OPC_LL, rt, rs, s);
|
|
break;
|
|
case NM_LLWP:
|
|
check_xnp(ctx);
|
|
gen_llwp(ctx, rs, 0, rt, extract32(ctx->opcode, 3, 5));
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_SC:
|
|
switch (ctx->opcode & 0x03) {
|
|
case NM_SC:
|
|
gen_st_cond(ctx, rt, rs, s, MO_TESL, false);
|
|
break;
|
|
case NM_SCWP:
|
|
check_xnp(ctx);
|
|
gen_scwp(ctx, rs, 0, rt, extract32(ctx->opcode, 3, 5),
|
|
false);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_CACHE:
|
|
check_cp0_enabled(ctx);
|
|
if (ctx->hflags & MIPS_HFLAG_ITC_CACHE) {
|
|
gen_cache_operation(ctx, rt, rs, s);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_LS_E0:
|
|
switch (extract32(ctx->opcode, 11, 4)) {
|
|
case NM_LBE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_ld(ctx, OPC_LBE, rt, rs, s);
|
|
break;
|
|
case NM_SBE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_st(ctx, OPC_SBE, rt, rs, s);
|
|
break;
|
|
case NM_LBUE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_ld(ctx, OPC_LBUE, rt, rs, s);
|
|
break;
|
|
case NM_P_PREFE:
|
|
if (rt == 31) {
|
|
/* case NM_SYNCIE */
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
/*
|
|
* Break the TB to be able to sync copied instructions
|
|
* immediately.
|
|
*/
|
|
ctx->base.is_jmp = DISAS_STOP;
|
|
} else {
|
|
/* case NM_PREFE */
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
/* Treat as NOP. */
|
|
}
|
|
break;
|
|
case NM_LHE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_ld(ctx, OPC_LHE, rt, rs, s);
|
|
break;
|
|
case NM_SHE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_st(ctx, OPC_SHE, rt, rs, s);
|
|
break;
|
|
case NM_LHUE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_ld(ctx, OPC_LHUE, rt, rs, s);
|
|
break;
|
|
case NM_CACHEE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
check_nms_dl_il_sl_tl_l2c(ctx);
|
|
gen_cache_operation(ctx, rt, rs, s);
|
|
break;
|
|
case NM_LWE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_ld(ctx, OPC_LWE, rt, rs, s);
|
|
break;
|
|
case NM_SWE:
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_st(ctx, OPC_SWE, rt, rs, s);
|
|
break;
|
|
case NM_P_LLE:
|
|
switch (extract32(ctx->opcode, 2, 2)) {
|
|
case NM_LLE:
|
|
check_xnp(ctx);
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_ld(ctx, OPC_LLE, rt, rs, s);
|
|
break;
|
|
case NM_LLWPE:
|
|
check_xnp(ctx);
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_llwp(ctx, rs, 0, rt, extract32(ctx->opcode, 3, 5));
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_SCE:
|
|
switch (extract32(ctx->opcode, 2, 2)) {
|
|
case NM_SCE:
|
|
check_xnp(ctx);
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_st_cond(ctx, rt, rs, s, MO_TESL, true);
|
|
break;
|
|
case NM_SCWPE:
|
|
check_xnp(ctx);
|
|
check_eva(ctx);
|
|
check_cp0_enabled(ctx);
|
|
gen_scwp(ctx, rs, 0, rt, extract32(ctx->opcode, 3, 5),
|
|
true);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_LS_WM:
|
|
case NM_P_LS_UAWM:
|
|
check_nms(ctx);
|
|
{
|
|
int count = extract32(ctx->opcode, 12, 3);
|
|
int counter = 0;
|
|
|
|
offset = sextract32(ctx->opcode, 15, 1) << 8 |
|
|
extract32(ctx->opcode, 0, 8);
|
|
TCGv va = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
MemOp memop = (extract32(ctx->opcode, 8, 3)) ==
|
|
NM_P_LS_UAWM ? MO_UNALN : 0;
|
|
|
|
count = (count == 0) ? 8 : count;
|
|
while (counter != count) {
|
|
int this_rt = ((rt + counter) & 0x1f) | (rt & 0x10);
|
|
int this_offset = offset + (counter << 2);
|
|
|
|
gen_base_offset_addr(ctx, va, rs, this_offset);
|
|
|
|
switch (extract32(ctx->opcode, 11, 1)) {
|
|
case NM_LWM:
|
|
tcg_gen_qemu_ld_tl(t1, va, ctx->mem_idx,
|
|
memop | MO_TESL);
|
|
gen_store_gpr(t1, this_rt);
|
|
if ((this_rt == rs) &&
|
|
(counter != (count - 1))) {
|
|
/* UNPREDICTABLE */
|
|
}
|
|
break;
|
|
case NM_SWM:
|
|
this_rt = (rt == 0) ? 0 : this_rt;
|
|
gen_load_gpr(t1, this_rt);
|
|
tcg_gen_qemu_st_tl(t1, va, ctx->mem_idx,
|
|
memop | MO_TEUL);
|
|
break;
|
|
}
|
|
counter++;
|
|
}
|
|
tcg_temp_free(va);
|
|
tcg_temp_free(t1);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_MOVE_BALC:
|
|
check_nms(ctx);
|
|
{
|
|
TCGv t0 = tcg_temp_new();
|
|
int32_t s = sextract32(ctx->opcode, 0, 1) << 21 |
|
|
extract32(ctx->opcode, 1, 20) << 1;
|
|
rd = (extract32(ctx->opcode, 24, 1)) == 0 ? 4 : 5;
|
|
rt = decode_gpr_gpr4_zero(extract32(ctx->opcode, 25, 1) << 3 |
|
|
extract32(ctx->opcode, 21, 3));
|
|
gen_load_gpr(t0, rt);
|
|
tcg_gen_mov_tl(cpu_gpr[rd], t0);
|
|
gen_compute_branch_nm(ctx, OPC_BGEZAL, 4, 0, 0, s);
|
|
tcg_temp_free(t0);
|
|
}
|
|
break;
|
|
case NM_P_BAL:
|
|
{
|
|
int32_t s = sextract32(ctx->opcode, 0, 1) << 25 |
|
|
extract32(ctx->opcode, 1, 24) << 1;
|
|
|
|
if ((extract32(ctx->opcode, 25, 1)) == 0) {
|
|
/* BC */
|
|
gen_compute_branch_nm(ctx, OPC_BEQ, 4, 0, 0, s);
|
|
} else {
|
|
/* BALC */
|
|
gen_compute_branch_nm(ctx, OPC_BGEZAL, 4, 0, 0, s);
|
|
}
|
|
}
|
|
break;
|
|
case NM_P_J:
|
|
switch (extract32(ctx->opcode, 12, 4)) {
|
|
case NM_JALRC:
|
|
case NM_JALRC_HB:
|
|
gen_compute_branch_nm(ctx, OPC_JALR, 4, rs, rt, 0);
|
|
break;
|
|
case NM_P_BALRSC:
|
|
gen_compute_nanomips_pbalrsc_branch(ctx, rs, rt);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P_BR1:
|
|
{
|
|
int32_t s = sextract32(ctx->opcode, 0, 1) << 14 |
|
|
extract32(ctx->opcode, 1, 13) << 1;
|
|
switch (extract32(ctx->opcode, 14, 2)) {
|
|
case NM_BEQC:
|
|
check_nms(ctx);
|
|
gen_compute_branch_nm(ctx, OPC_BEQ, 4, rs, rt, s);
|
|
break;
|
|
case NM_P_BR3A:
|
|
s = sextract32(ctx->opcode, 0, 1) << 14 |
|
|
extract32(ctx->opcode, 1, 13) << 1;
|
|
switch (extract32(ctx->opcode, 16, 5)) {
|
|
case NM_BC1EQZC:
|
|
check_cp1_enabled(ctx);
|
|
gen_compute_branch_cp1_nm(ctx, OPC_BC1EQZ, rt, s);
|
|
break;
|
|
case NM_BC1NEZC:
|
|
check_cp1_enabled(ctx);
|
|
gen_compute_branch_cp1_nm(ctx, OPC_BC1NEZ, rt, s);
|
|
break;
|
|
case NM_BPOSGE32C:
|
|
check_dsp_r3(ctx);
|
|
{
|
|
int32_t imm = extract32(ctx->opcode, 1, 13) |
|
|
extract32(ctx->opcode, 0, 1) << 13;
|
|
|
|
gen_compute_branch_nm(ctx, OPC_BPOSGE32, 4, -1, -2,
|
|
imm << 1);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_BGEC:
|
|
if (rs == rt) {
|
|
gen_compute_compact_branch_nm(ctx, OPC_BC, rs, rt, s);
|
|
} else {
|
|
gen_compute_compact_branch_nm(ctx, OPC_BGEC, rs, rt, s);
|
|
}
|
|
break;
|
|
case NM_BGEUC:
|
|
if (rs == rt || rt == 0) {
|
|
gen_compute_compact_branch_nm(ctx, OPC_BC, 0, 0, s);
|
|
} else if (rs == 0) {
|
|
gen_compute_compact_branch_nm(ctx, OPC_BEQZC, rt, 0, s);
|
|
} else {
|
|
gen_compute_compact_branch_nm(ctx, OPC_BGEUC, rs, rt, s);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_P_BR2:
|
|
{
|
|
int32_t s = sextract32(ctx->opcode, 0, 1) << 14 |
|
|
extract32(ctx->opcode, 1, 13) << 1;
|
|
switch (extract32(ctx->opcode, 14, 2)) {
|
|
case NM_BNEC:
|
|
check_nms(ctx);
|
|
if (rs == rt) {
|
|
/* NOP */
|
|
ctx->hflags |= MIPS_HFLAG_FBNSLOT;
|
|
} else {
|
|
gen_compute_branch_nm(ctx, OPC_BNE, 4, rs, rt, s);
|
|
}
|
|
break;
|
|
case NM_BLTC:
|
|
if (rs != 0 && rt != 0 && rs == rt) {
|
|
/* NOP */
|
|
ctx->hflags |= MIPS_HFLAG_FBNSLOT;
|
|
} else {
|
|
gen_compute_compact_branch_nm(ctx, OPC_BLTC, rs, rt, s);
|
|
}
|
|
break;
|
|
case NM_BLTUC:
|
|
if (rs == 0 || rs == rt) {
|
|
/* NOP */
|
|
ctx->hflags |= MIPS_HFLAG_FBNSLOT;
|
|
} else {
|
|
gen_compute_compact_branch_nm(ctx, OPC_BLTUC, rs, rt, s);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_P_BRI:
|
|
{
|
|
int32_t s = sextract32(ctx->opcode, 0, 1) << 11 |
|
|
extract32(ctx->opcode, 1, 10) << 1;
|
|
uint32_t u = extract32(ctx->opcode, 11, 7);
|
|
|
|
gen_compute_imm_branch(ctx, extract32(ctx->opcode, 18, 3),
|
|
rt, u, s);
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
return 4;
|
|
}
|
|
|
|
static int decode_isa_nanomips(CPUMIPSState *env, DisasContext *ctx)
|
|
{
|
|
uint32_t op;
|
|
int rt = decode_gpr_gpr3(NANOMIPS_EXTRACT_RT3(ctx->opcode));
|
|
int rs = decode_gpr_gpr3(NANOMIPS_EXTRACT_RS3(ctx->opcode));
|
|
int rd = decode_gpr_gpr3(NANOMIPS_EXTRACT_RD3(ctx->opcode));
|
|
int offset;
|
|
int imm;
|
|
|
|
/* make sure instructions are on a halfword boundary */
|
|
if (ctx->base.pc_next & 0x1) {
|
|
TCGv tmp = tcg_const_tl(ctx->base.pc_next);
|
|
tcg_gen_st_tl(tmp, cpu_env, offsetof(CPUMIPSState, CP0_BadVAddr));
|
|
tcg_temp_free(tmp);
|
|
generate_exception_end(ctx, EXCP_AdEL);
|
|
return 2;
|
|
}
|
|
|
|
op = extract32(ctx->opcode, 10, 6);
|
|
switch (op) {
|
|
case NM_P16_MV:
|
|
rt = NANOMIPS_EXTRACT_RD5(ctx->opcode);
|
|
if (rt != 0) {
|
|
/* MOVE */
|
|
rs = NANOMIPS_EXTRACT_RS5(ctx->opcode);
|
|
gen_arith(ctx, OPC_ADDU, rt, rs, 0);
|
|
} else {
|
|
/* P16.RI */
|
|
switch (extract32(ctx->opcode, 3, 2)) {
|
|
case NM_P16_SYSCALL:
|
|
if (extract32(ctx->opcode, 2, 1) == 0) {
|
|
generate_exception_end(ctx, EXCP_SYSCALL);
|
|
} else {
|
|
gen_reserved_instruction(ctx);
|
|
}
|
|
break;
|
|
case NM_BREAK16:
|
|
generate_exception_end(ctx, EXCP_BREAK);
|
|
break;
|
|
case NM_SDBBP16:
|
|
if (is_uhi(ctx, extract32(ctx->opcode, 0, 3))) {
|
|
ctx->base.is_jmp = DISAS_SEMIHOST;
|
|
} else {
|
|
if (ctx->hflags & MIPS_HFLAG_SBRI) {
|
|
gen_reserved_instruction(ctx);
|
|
} else {
|
|
generate_exception_end(ctx, EXCP_DBp);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_P16_SHIFT:
|
|
{
|
|
int shift = extract32(ctx->opcode, 0, 3);
|
|
uint32_t opc = 0;
|
|
shift = (shift == 0) ? 8 : shift;
|
|
|
|
switch (extract32(ctx->opcode, 3, 1)) {
|
|
case NM_SLL16:
|
|
opc = OPC_SLL;
|
|
break;
|
|
case NM_SRL16:
|
|
opc = OPC_SRL;
|
|
break;
|
|
}
|
|
gen_shift_imm(ctx, opc, rt, rs, shift);
|
|
}
|
|
break;
|
|
case NM_P16C:
|
|
switch (ctx->opcode & 1) {
|
|
case NM_POOL16C_0:
|
|
gen_pool16c_nanomips_insn(ctx);
|
|
break;
|
|
case NM_LWXS16:
|
|
gen_ldxs(ctx, rt, rs, rd);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P16_A1:
|
|
switch (extract32(ctx->opcode, 6, 1)) {
|
|
case NM_ADDIUR1SP:
|
|
imm = extract32(ctx->opcode, 0, 6) << 2;
|
|
gen_arith_imm(ctx, OPC_ADDIU, rt, 29, imm);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P16_A2:
|
|
switch (extract32(ctx->opcode, 3, 1)) {
|
|
case NM_ADDIUR2:
|
|
imm = extract32(ctx->opcode, 0, 3) << 2;
|
|
gen_arith_imm(ctx, OPC_ADDIU, rt, rs, imm);
|
|
break;
|
|
case NM_P_ADDIURS5:
|
|
rt = extract32(ctx->opcode, 5, 5);
|
|
if (rt != 0) {
|
|
/* imm = sign_extend(s[3] . s[2:0] , from_nbits = 4) */
|
|
imm = (sextract32(ctx->opcode, 4, 1) << 3) |
|
|
(extract32(ctx->opcode, 0, 3));
|
|
gen_arith_imm(ctx, OPC_ADDIU, rt, rt, imm);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P16_ADDU:
|
|
switch (ctx->opcode & 0x1) {
|
|
case NM_ADDU16:
|
|
gen_arith(ctx, OPC_ADDU, rd, rs, rt);
|
|
break;
|
|
case NM_SUBU16:
|
|
gen_arith(ctx, OPC_SUBU, rd, rs, rt);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P16_4X4:
|
|
rt = (extract32(ctx->opcode, 9, 1) << 3) |
|
|
extract32(ctx->opcode, 5, 3);
|
|
rs = (extract32(ctx->opcode, 4, 1) << 3) |
|
|
extract32(ctx->opcode, 0, 3);
|
|
rt = decode_gpr_gpr4(rt);
|
|
rs = decode_gpr_gpr4(rs);
|
|
switch ((extract32(ctx->opcode, 7, 2) & 0x2) |
|
|
(extract32(ctx->opcode, 3, 1))) {
|
|
case NM_ADDU4X4:
|
|
check_nms(ctx);
|
|
gen_arith(ctx, OPC_ADDU, rt, rs, rt);
|
|
break;
|
|
case NM_MUL4X4:
|
|
check_nms(ctx);
|
|
gen_r6_muldiv(ctx, R6_OPC_MUL, rt, rs, rt);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_LI16:
|
|
{
|
|
int imm = extract32(ctx->opcode, 0, 7);
|
|
imm = (imm == 0x7f ? -1 : imm);
|
|
if (rt != 0) {
|
|
tcg_gen_movi_tl(cpu_gpr[rt], imm);
|
|
}
|
|
}
|
|
break;
|
|
case NM_ANDI16:
|
|
{
|
|
uint32_t u = extract32(ctx->opcode, 0, 4);
|
|
u = (u == 12) ? 0xff :
|
|
(u == 13) ? 0xffff : u;
|
|
gen_logic_imm(ctx, OPC_ANDI, rt, rs, u);
|
|
}
|
|
break;
|
|
case NM_P16_LB:
|
|
offset = extract32(ctx->opcode, 0, 2);
|
|
switch (extract32(ctx->opcode, 2, 2)) {
|
|
case NM_LB16:
|
|
gen_ld(ctx, OPC_LB, rt, rs, offset);
|
|
break;
|
|
case NM_SB16:
|
|
rt = decode_gpr_gpr3_src_store(
|
|
NANOMIPS_EXTRACT_RT3(ctx->opcode));
|
|
gen_st(ctx, OPC_SB, rt, rs, offset);
|
|
break;
|
|
case NM_LBU16:
|
|
gen_ld(ctx, OPC_LBU, rt, rs, offset);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P16_LH:
|
|
offset = extract32(ctx->opcode, 1, 2) << 1;
|
|
switch ((extract32(ctx->opcode, 3, 1) << 1) | (ctx->opcode & 1)) {
|
|
case NM_LH16:
|
|
gen_ld(ctx, OPC_LH, rt, rs, offset);
|
|
break;
|
|
case NM_SH16:
|
|
rt = decode_gpr_gpr3_src_store(
|
|
NANOMIPS_EXTRACT_RT3(ctx->opcode));
|
|
gen_st(ctx, OPC_SH, rt, rs, offset);
|
|
break;
|
|
case NM_LHU16:
|
|
gen_ld(ctx, OPC_LHU, rt, rs, offset);
|
|
break;
|
|
default:
|
|
gen_reserved_instruction(ctx);
|
|
break;
|
|
}
|
|
break;
|
|
case NM_LW16:
|
|
offset = extract32(ctx->opcode, 0, 4) << 2;
|
|
gen_ld(ctx, OPC_LW, rt, rs, offset);
|
|
break;
|
|
case NM_LWSP16:
|
|
rt = NANOMIPS_EXTRACT_RD5(ctx->opcode);
|
|
offset = extract32(ctx->opcode, 0, 5) << 2;
|
|
gen_ld(ctx, OPC_LW, rt, 29, offset);
|
|
break;
|
|
case NM_LW4X4:
|
|
check_nms(ctx);
|
|
rt = (extract32(ctx->opcode, 9, 1) << 3) |
|
|
extract32(ctx->opcode, 5, 3);
|
|
rs = (extract32(ctx->opcode, 4, 1) << 3) |
|
|
extract32(ctx->opcode, 0, 3);
|
|
offset = (extract32(ctx->opcode, 3, 1) << 3) |
|
|
(extract32(ctx->opcode, 8, 1) << 2);
|
|
rt = decode_gpr_gpr4(rt);
|
|
rs = decode_gpr_gpr4(rs);
|
|
gen_ld(ctx, OPC_LW, rt, rs, offset);
|
|
break;
|
|
case NM_SW4X4:
|
|
check_nms(ctx);
|
|
rt = (extract32(ctx->opcode, 9, 1) << 3) |
|
|
extract32(ctx->opcode, 5, 3);
|
|
rs = (extract32(ctx->opcode, 4, 1) << 3) |
|
|
extract32(ctx->opcode, 0, 3);
|
|
offset = (extract32(ctx->opcode, 3, 1) << 3) |
|
|
(extract32(ctx->opcode, 8, 1) << 2);
|
|
rt = decode_gpr_gpr4_zero(rt);
|
|
rs = decode_gpr_gpr4(rs);
|
|
gen_st(ctx, OPC_SW, rt, rs, offset);
|
|
break;
|
|
case NM_LWGP16:
|
|
offset = extract32(ctx->opcode, 0, 7) << 2;
|
|
gen_ld(ctx, OPC_LW, rt, 28, offset);
|
|
break;
|
|
case NM_SWSP16:
|
|
rt = NANOMIPS_EXTRACT_RD5(ctx->opcode);
|
|
offset = extract32(ctx->opcode, 0, 5) << 2;
|
|
gen_st(ctx, OPC_SW, rt, 29, offset);
|
|
break;
|
|
case NM_SW16:
|
|
rt = decode_gpr_gpr3_src_store(
|
|
NANOMIPS_EXTRACT_RT3(ctx->opcode));
|
|
rs = decode_gpr_gpr3(NANOMIPS_EXTRACT_RS3(ctx->opcode));
|
|
offset = extract32(ctx->opcode, 0, 4) << 2;
|
|
gen_st(ctx, OPC_SW, rt, rs, offset);
|
|
break;
|
|
case NM_SWGP16:
|
|
rt = decode_gpr_gpr3_src_store(
|
|
NANOMIPS_EXTRACT_RT3(ctx->opcode));
|
|
offset = extract32(ctx->opcode, 0, 7) << 2;
|
|
gen_st(ctx, OPC_SW, rt, 28, offset);
|
|
break;
|
|
case NM_BC16:
|
|
gen_compute_branch_nm(ctx, OPC_BEQ, 2, 0, 0,
|
|
(sextract32(ctx->opcode, 0, 1) << 10) |
|
|
(extract32(ctx->opcode, 1, 9) << 1));
|
|
break;
|
|
case NM_BALC16:
|
|
gen_compute_branch_nm(ctx, OPC_BGEZAL, 2, 0, 0,
|
|
(sextract32(ctx->opcode, 0, 1) << 10) |
|
|
(extract32(ctx->opcode, 1, 9) << 1));
|
|
break;
|
|
case NM_BEQZC16:
|
|
gen_compute_branch_nm(ctx, OPC_BEQ, 2, rt, 0,
|
|
(sextract32(ctx->opcode, 0, 1) << 7) |
|
|
(extract32(ctx->opcode, 1, 6) << 1));
|
|
break;
|
|
case NM_BNEZC16:
|
|
gen_compute_branch_nm(ctx, OPC_BNE, 2, rt, 0,
|
|
(sextract32(ctx->opcode, 0, 1) << 7) |
|
|
(extract32(ctx->opcode, 1, 6) << 1));
|
|
break;
|
|
case NM_P16_BR:
|
|
switch (ctx->opcode & 0xf) {
|
|
case 0:
|
|
/* P16.JRC */
|
|
switch (extract32(ctx->opcode, 4, 1)) {
|
|
case NM_JRC:
|
|
gen_compute_branch_nm(ctx, OPC_JR, 2,
|
|
extract32(ctx->opcode, 5, 5), 0, 0);
|
|
break;
|
|
case NM_JALRC16:
|
|
gen_compute_branch_nm(ctx, OPC_JALR, 2,
|
|
extract32(ctx->opcode, 5, 5), 31, 0);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
/* P16.BRI */
|
|
uint32_t opc = extract32(ctx->opcode, 4, 3) <
|
|
extract32(ctx->opcode, 7, 3) ? OPC_BEQ : OPC_BNE;
|
|
gen_compute_branch_nm(ctx, opc, 2, rs, rt,
|
|
extract32(ctx->opcode, 0, 4) << 1);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case NM_P16_SR:
|
|
{
|
|
int count = extract32(ctx->opcode, 0, 4);
|
|
int u = extract32(ctx->opcode, 4, 4) << 4;
|
|
|
|
rt = 30 + extract32(ctx->opcode, 9, 1);
|
|
switch (extract32(ctx->opcode, 8, 1)) {
|
|
case NM_SAVE16:
|
|
gen_save(ctx, rt, count, 0, u);
|
|
break;
|
|
case NM_RESTORE_JRC16:
|
|
gen_restore(ctx, rt, count, 0, u);
|
|
gen_compute_branch_nm(ctx, OPC_JR, 2, 31, 0, 0);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case NM_MOVEP:
|
|
case NM_MOVEPREV:
|
|
check_nms(ctx);
|
|
{
|
|
static const int gpr2reg1[] = {4, 5, 6, 7};
|
|
static const int gpr2reg2[] = {5, 6, 7, 8};
|
|
int re;
|
|
int rd2 = extract32(ctx->opcode, 3, 1) << 1 |
|
|
extract32(ctx->opcode, 8, 1);
|
|
int r1 = gpr2reg1[rd2];
|
|
int r2 = gpr2reg2[rd2];
|
|
int r3 = extract32(ctx->opcode, 4, 1) << 3 |
|
|
extract32(ctx->opcode, 0, 3);
|
|
int r4 = extract32(ctx->opcode, 9, 1) << 3 |
|
|
extract32(ctx->opcode, 5, 3);
|
|
TCGv t0 = tcg_temp_new();
|
|
TCGv t1 = tcg_temp_new();
|
|
if (op == NM_MOVEP) {
|
|
rd = r1;
|
|
re = r2;
|
|
rs = decode_gpr_gpr4_zero(r3);
|
|
rt = decode_gpr_gpr4_zero(r4);
|
|
} else {
|
|
rd = decode_gpr_gpr4(r3);
|
|
re = decode_gpr_gpr4(r4);
|
|
rs = r1;
|
|
rt = r2;
|
|
}
|
|
gen_load_gpr(t0, rs);
|
|
gen_load_gpr(t1, rt);
|
|
tcg_gen_mov_tl(cpu_gpr[rd], t0);
|
|
tcg_gen_mov_tl(cpu_gpr[re], t1);
|
|
tcg_temp_free(t0);
|
|
tcg_temp_free(t1);
|
|
}
|
|
break;
|
|
default:
|
|
return decode_nanomips_32_48_opc(env, ctx);
|
|
}
|
|
|
|
return 2;
|
|
}
|