Index: /trunk/src/VBox/VMM/VMMAll/IEMAll.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/IEMAll.cpp (revision 37002) +++ /trunk/src/VBox/VMM/VMMAll/IEMAll.cpp (revision 37003) @@ -903,11 +903,11 @@ * Fetches the next opcode byte, returns automatically on failure. * - * @param pIemCpu The IEM state. * @param a_pu8 Where to return the opcode byte. - */ -#define IEM_OPCODE_GET_NEXT_BYTE(a_pIemCpu, a_pu8) \ + * @remark Implicitly references pIemCpu. + */ +#define IEM_OPCODE_GET_NEXT_U8(a_pu8) \ do \ { \ - VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU8((a_pIemCpu), (a_pu8)); \ + VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU8(pIemCpu, (a_pu8)); \ if (rcStrict2 != VINF_SUCCESS) \ return rcStrict2; \ @@ -931,11 +931,11 @@ * on failure. * - * @param pIemCpu The IEM state. * @param pi8 Where to return the signed byte. - */ -#define IEM_OPCODE_GET_NEXT_S8(a_pIemCpu, a_pi8) \ + * @remark Implicitly references pIemCpu. + */ +#define IEM_OPCODE_GET_NEXT_S8(a_pi8) \ do \ { \ - VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextS8((a_pIemCpu), (a_pi8)); \ + VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextS8(pIemCpu, (a_pi8)); \ if (rcStrict2 != VINF_SUCCESS) \ return rcStrict2; \ @@ -967,11 +967,11 @@ * a word, returning automatically on failure. * - * @param pIemCpu The IEM state. * @param pu16 Where to return the word. - */ -#define IEM_OPCODE_GET_NEXT_S8_SX_U16(a_pIemCpu, a_pu16) \ + * @remark Implicitly references pIemCpu. + */ +#define IEM_OPCODE_GET_NEXT_S8_SX_U16(a_pu16) \ do \ { \ - VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextS8SxU16((a_pIemCpu), (a_pu16)); \ + VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextS8SxU16(pIemCpu, (a_pu16)); \ if (rcStrict2 != VINF_SUCCESS) \ return rcStrict2; \ @@ -1000,11 +1000,11 @@ * Fetches the next opcode word, returns automatically on failure. * - * @param pIemCpu The IEM state. * @param a_pu16 Where to return the opcode word. - */ -#define IEM_OPCODE_GET_NEXT_U16(a_pIemCpu, a_pu16) \ + * @remark Implicitly references pIemCpu. + */ +#define IEM_OPCODE_GET_NEXT_U16(a_pu16) \ do \ { \ - VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU16((a_pIemCpu), (a_pu16)); \ + VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU16(pIemCpu, (a_pu16)); \ if (rcStrict2 != VINF_SUCCESS) \ return rcStrict2; \ @@ -1064,11 +1064,11 @@ * Fetches the next opcode dword, returns automatically on failure. * - * @param pIemCpu The IEM state. * @param a_u32 Where to return the opcode dword. - */ -#define IEM_OPCODE_GET_NEXT_U32(a_pIemCpu, a_pu32) \ + * @remark Implicitly references pIemCpu. + */ +#define IEM_OPCODE_GET_NEXT_U32(a_pu32) \ do \ { \ - VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU32((a_pIemCpu), (a_pu32)); \ + VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU32(pIemCpu, (a_pu32)); \ if (rcStrict2 != VINF_SUCCESS) \ return rcStrict2; \ @@ -1130,11 +1130,11 @@ * returns automatically on failure. * - * @param pIemCpu The IEM state. * @param a_pu64 Where to return the opcode quad word. - */ -#define IEM_OPCODE_GET_NEXT_S32_SX_U64(a_pIemCpu, a_pu64) \ + * @remark Implicitly references pIemCpu. + */ +#define IEM_OPCODE_GET_NEXT_S32_SX_U64(a_pu64) \ do \ { \ - VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextS32SxU64((a_pIemCpu), (a_pu64)); \ + VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextS32SxU64(pIemCpu, (a_pu64)); \ if (rcStrict2 != VINF_SUCCESS) \ return rcStrict2; \ @@ -1168,13 +1168,13 @@ /** - * Fetches the next opcode word, returns automatically on failure. - * - * @param pIemCpu The IEM state. - * @param a_pu64 Where to return the opcode qword. - */ -#define IEM_OPCODE_GET_NEXT_U64(a_pIemCpu, a_pu64) \ + * Fetches the next opcode quad word, returns automatically on failure. + * + * @param a_pu64 Where to return the opcode quad word. + * @remark Implicitly references pIemCpu. + */ +#define IEM_OPCODE_GET_NEXT_U64(a_pu64) \ do \ { \ - VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU64((a_pIemCpu), (a_pu64)); \ + VBOXSTRICTRC rcStrict2 = iemOpcodeGetNextU64(pIemCpu, (a_pu64)); \ if (rcStrict2 != VINF_SUCCESS) \ return rcStrict2; \ @@ -3722,4 +3722,5 @@ #define IEM_MC_ASSIGN(a_VarOrArg, a_CVariableOrConst) (a_VarOrArg) = (a_CVariableOrConst) +#define IEM_MC_ASSIGN_TO_SMALLER IEM_MC_ASSIGN #define IEM_MC_FETCH_GREG_U8(a_u8Dst, a_iGReg) (a_u8Dst) = iemGRegFetchU8(pIemCpu, (a_iGReg)) @@ -3752,4 +3753,8 @@ #define IEM_MC_STORE_GREG_U32(a_iGReg, a_u32Value) *(uint64_t *)iemGRegRef(pIemCpu, (a_iGReg)) = (uint32_t)(a_u32Value) /* clear high bits. */ #define IEM_MC_STORE_GREG_U64(a_iGReg, a_u64Value) *(uint64_t *)iemGRegRef(pIemCpu, (a_iGReg)) = (a_u64Value) +#define IEM_MC_STORE_GREG_U8_CONST IEM_MC_STORE_GREG_U8 +#define IEM_MC_STORE_GREG_U16_CONST IEM_MC_STORE_GREG_U16 +#define IEM_MC_STORE_GREG_U32_CONST IEM_MC_STORE_GREG_U32 +#define IEM_MC_STORE_GREG_U64_CONST IEM_MC_STORE_GREG_U64 #define IEM_MC_CLEAR_HIGH_GREG_U64(a_iGReg) *(uint64_t *)iemGRegRef(pIemCpu, (a_iGReg)) &= UINT32_MAX @@ -4175,5 +4180,5 @@ /* Handle the disp16 form with no registers first. */ if ((bRm & (X86_MODRM_MOD_MASK | X86_MODRM_RM_MASK)) == 6) - IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16EffAddr); + IEM_OPCODE_GET_NEXT_U16(&u16EffAddr); else { @@ -4181,7 +4186,7 @@ switch ((bRm >> X86_MODRM_MOD_SHIFT) & X86_MODRM_MOD_SMASK) { - case 0: u16EffAddr = 0; break; - case 1: IEM_OPCODE_GET_NEXT_S8_SX_U16(pIemCpu, &u16EffAddr); break; - case 2: IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16EffAddr); break; + case 0: u16EffAddr = 0; break; + case 1: IEM_OPCODE_GET_NEXT_S8_SX_U16(&u16EffAddr); break; + case 2: IEM_OPCODE_GET_NEXT_U16(&u16EffAddr); break; default: AssertFailedReturn(VERR_INTERNAL_ERROR_2); /* (caller checked for these) */ } @@ -4212,5 +4217,5 @@ /* Handle the disp32 form with no registers first. */ if ((bRm & (X86_MODRM_MOD_MASK | X86_MODRM_RM_MASK)) == 5) - IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32EffAddr); + IEM_OPCODE_GET_NEXT_U32(&u32EffAddr); else { @@ -4224,5 +4229,5 @@ case 4: /* SIB */ { - uint8_t bSib; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bSib); + uint8_t bSib; IEM_OPCODE_GET_NEXT_U8(&bSib); /* Get the index and scale it. */ @@ -4258,5 +4263,5 @@ { uint32_t u32Disp; - IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Disp); + IEM_OPCODE_GET_NEXT_U32(&u32Disp); u32EffAddr += u32Disp; } @@ -4281,6 +4286,5 @@ case 1: { - int8_t i8Disp; - IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Disp); + int8_t i8Disp; IEM_OPCODE_GET_NEXT_S8(&i8Disp); u32EffAddr += i8Disp; break; @@ -4288,6 +4292,5 @@ case 2: { - uint32_t u32Disp; - IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Disp); + uint32_t u32Disp; IEM_OPCODE_GET_NEXT_U32(&u32Disp); u32EffAddr += u32Disp; break; @@ -4316,5 +4319,5 @@ if ((bRm & (X86_MODRM_MOD_MASK | X86_MODRM_RM_MASK)) == 5) { - IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64EffAddr); + IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64EffAddr); u64EffAddr += pCtx->rip + pIemCpu->offOpcode; } @@ -4342,5 +4345,5 @@ case 12: { - uint8_t bSib; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bSib); + uint8_t bSib; IEM_OPCODE_GET_NEXT_U8(&bSib); /* Get the index and scale it. */ @@ -4399,5 +4402,5 @@ { uint32_t u32Disp; - IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Disp); + IEM_OPCODE_GET_NEXT_U32(&u32Disp); u64EffAddr += (int32_t)u32Disp; } @@ -4417,5 +4420,5 @@ { int8_t i8Disp; - IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Disp); + IEM_OPCODE_GET_NEXT_S8(&i8Disp); u64EffAddr += i8Disp; break; @@ -4424,5 +4427,5 @@ { uint32_t u32Disp; - IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Disp); + IEM_OPCODE_GET_NEXT_U32(&u32Disp); u64EffAddr += (int32_t)u32Disp; break; @@ -5239,5 +5242,5 @@ return rcStrict; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); rcStrict = FNIEMOP_CALL(g_apfnOneByteMap[b]); if (rcStrict == VINF_SUCCESS) @@ -5256,5 +5259,5 @@ if (rcStrict == VINF_SUCCESS) { - b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + b; IEM_OPCODE_GET_NEXT_U8(&b); rcStrict = FNIEMOP_CALL(g_apfnOneByteMap[b]); if (rcStrict == VINF_SUCCESS) Index: /trunk/src/VBox/VMM/VMMAll/IEMAllInstructions.cpp.h =================================================================== --- /trunk/src/VBox/VMM/VMMAll/IEMAllInstructions.cpp.h (revision 37002) +++ /trunk/src/VBox/VMM/VMMAll/IEMAllInstructions.cpp.h (revision 37003) @@ -31,6 +31,5 @@ FNIEMOP_DEF_1(iemOpHlpBinaryOperator_rm_r8, PCIEMOPBINSIZES, pImpl) { - uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); /* @@ -94,6 +93,5 @@ FNIEMOP_DEF_1(iemOpHlpBinaryOperator_rm_rv, PCIEMOPBINSIZES, pImpl) { - uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); /* @@ -241,6 +239,5 @@ FNIEMOP_DEF_1(iemOpHlpBinaryOperator_r8_rm, PCIEMOPBINSIZES, pImpl) { - uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -295,5 +292,5 @@ FNIEMOP_DEF_1(iemOpHlpBinaryOperator_rv_rm, PCIEMOPBINSIZES, pImpl) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -422,5 +419,5 @@ FNIEMOP_DEF_1(iemOpHlpBinaryOperator_AL_Ib, PCIEMOPBINSIZES, pImpl) { - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -452,5 +449,5 @@ case IEMMODE_16BIT: { - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -471,5 +468,5 @@ case IEMMODE_32BIT: { - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -490,5 +487,5 @@ case IEMMODE_64BIT: { - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -607,5 +604,5 @@ FNIEMOP_DEF(iemOp_Grp6) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) { @@ -844,5 +841,5 @@ FNIEMOP_DEF(iemOp_Grp7) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) { @@ -971,5 +968,5 @@ /** @todo Verify that the the invalid lock sequence exception (\#UD) is raised * before the privilege level violation (\#GP). */ - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); uint8_t iCrReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg; if (pIemCpu->fPrefixes & IEM_OP_PRF_LOCK) @@ -996,5 +993,5 @@ { IEMOP_MNEMONIC("mov Rd,Dd"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); if (pIemCpu->fPrefixes & IEM_OP_PRF_REX_R) @@ -1018,5 +1015,5 @@ /** @todo Verify that the the invalid lock sequence exception (\#UD) is raised * before the privilege level violation (\#GP). */ - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); uint8_t iCrReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg; if (pIemCpu->fPrefixes & IEM_OP_PRF_LOCK) @@ -1043,5 +1040,5 @@ { IEMOP_MNEMONIC("mov Dd,Rd"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); if (pIemCpu->fPrefixes & IEM_OP_PRF_REX_R) @@ -1126,5 +1123,5 @@ */ #define CMOV_X(a_Cnd) \ - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); \ + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \ if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) \ { \ @@ -2007,5 +2004,5 @@ { IEMOP_MNEMONIC("seto Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2018,7 +2015,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_OF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2047,5 +2044,5 @@ { IEMOP_MNEMONIC("setno Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2058,7 +2055,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_OF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2087,5 +2084,5 @@ { IEMOP_MNEMONIC("setc Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2098,7 +2095,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2127,5 +2124,5 @@ { IEMOP_MNEMONIC("setnc Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2138,7 +2135,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2167,5 +2164,5 @@ { IEMOP_MNEMONIC("sete Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2178,7 +2175,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2207,5 +2204,5 @@ { IEMOP_MNEMONIC("setne Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2218,7 +2215,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2247,5 +2244,5 @@ { IEMOP_MNEMONIC("setbe Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2258,7 +2255,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2287,5 +2284,5 @@ { IEMOP_MNEMONIC("setnbe Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2298,7 +2295,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2327,5 +2324,5 @@ { IEMOP_MNEMONIC("sets Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2338,7 +2335,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_SF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2367,5 +2364,5 @@ { IEMOP_MNEMONIC("setns Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2378,7 +2375,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_SF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2407,5 +2404,5 @@ { IEMOP_MNEMONIC("setnp Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2418,7 +2415,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2447,5 +2444,5 @@ { IEMOP_MNEMONIC("setnp Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2458,7 +2455,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2487,5 +2484,5 @@ { IEMOP_MNEMONIC("setl Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2498,7 +2495,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BITS_NE(X86_EFL_SF, X86_EFL_OF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2527,5 +2524,5 @@ { IEMOP_MNEMONIC("setnl Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2538,7 +2535,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BITS_NE(X86_EFL_SF, X86_EFL_OF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2567,5 +2564,5 @@ { IEMOP_MNEMONIC("setle Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2578,7 +2575,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET_OR_BITS_NE(X86_EFL_ZF, X86_EFL_SF, X86_EFL_OF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2607,5 +2604,5 @@ { IEMOP_MNEMONIC("setnle Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */ @@ -2618,7 +2615,7 @@ IEM_MC_BEGIN(0, 0); IEM_MC_IF_EFL_BIT_SET_OR_BITS_NE(X86_EFL_ZF, X86_EFL_SF, X86_EFL_OF) { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); + IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -2720,5 +2717,5 @@ FNIEMOP_DEF_1(iemOpCommonBit_Ev_Gv, PCIEMOPBINSIZES, pImpl) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF); @@ -2903,5 +2900,5 @@ FNIEMOP_DEF_1(iemOpCommonShldShrd_Ib, PCIEMOPSHIFTDBLSIZES, pImpl) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF | X86_EFL_OF); @@ -2909,5 +2906,5 @@ if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) { - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -2980,5 +2977,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEM_MC_ASSIGN(cShiftArg, cShift); IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg); @@ -3002,5 +2999,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEM_MC_ASSIGN(cShiftArg, cShift); IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg); @@ -3024,5 +3021,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEM_MC_ASSIGN(cShiftArg, cShift); IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg); @@ -3048,5 +3045,5 @@ FNIEMOP_DEF_1(iemOpCommonShldShrd_CL, PCIEMOPSHIFTDBLSIZES, pImpl) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF | X86_EFL_OF); @@ -3271,5 +3268,5 @@ FNIEMOP_DEF_1(iemOpCommonLoadSRegAndGreg, uint8_t, iSegReg) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -3368,5 +3365,5 @@ IEMOP_MNEMONIC("movzx Gv,Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -3459,5 +3456,5 @@ IEMOP_MNEMONIC("movzx Gv,Ew"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -3530,5 +3527,5 @@ FNIEMOP_DEF(iemOp_Grp8) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); PCIEMOPBINSIZES pImpl; switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) @@ -3548,5 +3545,5 @@ { /* register destination. */ - uint8_t u8Bit; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Bit); + uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -3622,5 +3619,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Bit; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Bit); + uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit); IEM_MC_ASSIGN(u16Src, u8Bit & 0x0f); IEM_MC_FETCH_EFLAGS(EFlags); @@ -3645,5 +3642,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Bit; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Bit); + uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit); IEM_MC_ASSIGN(u32Src, u8Bit & 0x1f); IEM_MC_FETCH_EFLAGS(EFlags); @@ -3668,5 +3665,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Bit; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Bit); + uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit); IEM_MC_ASSIGN(u64Src, u8Bit & 0x3f); IEM_MC_FETCH_EFLAGS(EFlags); @@ -3721,5 +3718,5 @@ IEMOP_MNEMONIC("movsx Gv,Eb"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -3812,5 +3809,5 @@ IEMOP_MNEMONIC("movsx Gv,Ew"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -4296,5 +4293,5 @@ FNIEMOP_DEF(iemOp_2byteEscape) { - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnTwoByteMap[b]); } @@ -4492,5 +4489,5 @@ pIemCpu->iEffSeg = X86_SREG_ES; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4555,5 +4552,5 @@ pIemCpu->iEffSeg = X86_SREG_CS; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4624,5 +4621,5 @@ pIemCpu->iEffSeg = X86_SREG_SS; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4689,5 +4686,5 @@ pIemCpu->iEffSeg = X86_SREG_DS; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4752,5 +4749,5 @@ pIemCpu->fPrefixes |= IEM_OP_PRF_REX; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4772,5 +4769,5 @@ pIemCpu->uRexB = 1 << 3; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4792,5 +4789,5 @@ pIemCpu->uRexIndex = 1 << 3; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4814,5 +4811,5 @@ pIemCpu->uRexIndex = 1 << 3; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4834,5 +4831,5 @@ pIemCpu->uRexReg = 1 << 3; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4855,5 +4852,5 @@ pIemCpu->uRexB = 1 << 3; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4876,5 +4873,5 @@ pIemCpu->uRexIndex = 1 << 3; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4898,5 +4895,5 @@ pIemCpu->uRexIndex = 1 << 3; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4918,5 +4915,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4939,5 +4936,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4960,5 +4957,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -4982,5 +4979,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5003,5 +5000,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5025,5 +5022,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5047,5 +5044,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5070,5 +5067,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5341,5 +5338,5 @@ pIemCpu->iEffSeg = X86_SREG_FS; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5352,5 +5349,5 @@ pIemCpu->iEffSeg = X86_SREG_GS; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5363,5 +5360,5 @@ iemRecalEffOpSize(pIemCpu); - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5380,5 +5377,5 @@ } - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -5394,5 +5391,5 @@ case IEMMODE_16BIT: { - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(0,0); @@ -5405,5 +5402,5 @@ case IEMMODE_32BIT: { - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(0,0); @@ -5416,5 +5413,5 @@ case IEMMODE_64BIT: { - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(0,0); @@ -5434,5 +5431,5 @@ { IEMOP_MNEMONIC("imul Gv,Ev,Iz"); /* Gv = Ev * Iz; */ - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF); @@ -5441,5 +5438,5 @@ case IEMMODE_16BIT: { - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEMOP_HLP_NO_LOCK_PREFIX(); if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) @@ -5486,5 +5483,5 @@ case IEMMODE_32BIT: { - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEMOP_HLP_NO_LOCK_PREFIX(); if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) @@ -5531,5 +5528,5 @@ case IEMMODE_64BIT: { - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); IEMOP_HLP_NO_LOCK_PREFIX(); if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) @@ -5582,5 +5579,5 @@ { IEMOP_MNEMONIC("push Ib"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -5609,6 +5606,6 @@ { IEMOP_MNEMONIC("imul Gv,Ev,Ib"); /* Gv = Ev * Iz; */ - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF); @@ -5927,5 +5924,5 @@ { IEMOP_MNEMONIC("jo Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -5946,5 +5943,5 @@ { IEMOP_MNEMONIC("jno Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -5964,5 +5961,5 @@ { IEMOP_MNEMONIC("jc/jnae Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -5983,5 +5980,5 @@ { IEMOP_MNEMONIC("jnc/jnb Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6002,5 +5999,5 @@ { IEMOP_MNEMONIC("je/jz Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6021,5 +6018,5 @@ { IEMOP_MNEMONIC("jne/jnz Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6040,5 +6037,5 @@ { IEMOP_MNEMONIC("jbe/jna Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6059,5 +6056,5 @@ { IEMOP_MNEMONIC("jnbe/ja Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6078,5 +6075,5 @@ { IEMOP_MNEMONIC("js Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6097,5 +6094,5 @@ { IEMOP_MNEMONIC("jns Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6116,5 +6113,5 @@ { IEMOP_MNEMONIC("jp Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6135,5 +6132,5 @@ { IEMOP_MNEMONIC("jnp Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6154,5 +6151,5 @@ { IEMOP_MNEMONIC("jl/jnge Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6173,5 +6170,5 @@ { IEMOP_MNEMONIC("jnl/jge Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6192,5 +6189,5 @@ { IEMOP_MNEMONIC("jle/jng Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6211,5 +6208,5 @@ { IEMOP_MNEMONIC("jnle/jg Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -6229,5 +6226,5 @@ FNIEMOP_DEF(iemOp_Grp1_Eb_Ib_80) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_MNEMONIC2("add\0or\0\0adc\0sbb\0and\0sub\0xor\0cmp" + ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK)*4, "Eb,Ib"); PCIEMOPBINSIZES pImpl = g_apIemImplGrp1[(bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK]; @@ -6236,5 +6233,5 @@ { /* register target */ - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(3, 0); @@ -6267,5 +6264,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEM_MC_ARG_CONST(uint8_t, u8Src, /*=*/ u8Imm, 1); @@ -6289,5 +6286,5 @@ FNIEMOP_DEF(iemOp_Grp1_Ev_Iz) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_MNEMONIC2("add\0or\0\0adc\0sbb\0and\0sub\0xor\0cmp" + ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK)*4, "Ev,Iz"); PCIEMOPBINSIZES pImpl = g_apIemImplGrp1[(bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK]; @@ -6300,5 +6297,5 @@ { /* register target */ - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(3, 0); @@ -6332,5 +6329,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEM_MC_ASSIGN(u16Src, u16Imm); IEM_MC_MEM_MAP(pu16Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -6354,5 +6351,5 @@ { /* register target */ - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(3, 0); @@ -6386,5 +6383,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEM_MC_ASSIGN(u32Src, u32Imm); IEM_MC_MEM_MAP(pu32Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -6408,5 +6405,5 @@ { /* register target */ - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(3, 0); @@ -6440,5 +6437,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); IEM_MC_ASSIGN(u64Src, u64Imm); IEM_MC_MEM_MAP(pu64Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -6472,5 +6469,5 @@ FNIEMOP_DEF(iemOp_Grp1_Ev_Ib) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_MNEMONIC2("add\0or\0\0adc\0sbb\0and\0sub\0xor\0cmp" + ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK)*4, "Ev,Ib"); PCIEMOPBINSIZES pImpl = g_apIemImplGrp1[(bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK]; @@ -6482,5 +6479,5 @@ */ IEMOP_HLP_NO_LOCK_PREFIX(); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); switch (pIemCpu->enmEffOpSize) { @@ -6559,5 +6556,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEM_MC_ASSIGN(u16Src, (int8_t)u8Imm); IEM_MC_MEM_MAP(pu16Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -6584,5 +6581,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEM_MC_ASSIGN(u32Src, (int8_t)u8Imm); IEM_MC_MEM_MAP(pu32Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -6609,5 +6606,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEM_MC_ASSIGN(u64Src, (int8_t)u8Imm); IEM_MC_MEM_MAP(pu64Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -6653,5 +6650,5 @@ FNIEMOP_DEF(iemOp_xchg_Eb_Gb) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_MNEMONIC("xchg Eb,Gb"); @@ -6702,5 +6699,5 @@ { IEMOP_MNEMONIC("xchg Ev,Gv"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); /* @@ -6825,5 +6822,5 @@ uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -6864,6 +6861,5 @@ IEMOP_MNEMONIC("mov Ev,Gv"); - uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -6953,6 +6949,5 @@ IEMOP_MNEMONIC("mov Gb,Eb"); - uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -6992,6 +6987,5 @@ IEMOP_MNEMONIC("mov Gv,Ev"); - uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -7081,6 +7075,5 @@ IEMOP_MNEMONIC("mov Ev,Sw"); - uint8_t bRm; - IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -7157,5 +7150,5 @@ { IEMOP_MNEMONIC("lea Gv,M"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) @@ -7165,8 +7158,10 @@ { case IEMMODE_16BIT: - IEM_MC_BEGIN(0, 1); - IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc); + IEM_MC_BEGIN(0, 2); + IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc); + IEM_MC_LOCAL(uint16_t, u16Cast); IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm); - IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, GCPtrEffSrc); + IEM_MC_ASSIGN_TO_SMALLER(u16Cast, GCPtrEffSrc); + IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Cast); IEM_MC_ADVANCE_RIP(); IEM_MC_END(); @@ -7174,8 +7169,10 @@ case IEMMODE_32BIT: - IEM_MC_BEGIN(0, 1); + IEM_MC_BEGIN(0, 2); IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc); + IEM_MC_LOCAL(uint32_t, u32Cast); IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm); - IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, GCPtrEffSrc); + IEM_MC_ASSIGN_TO_SMALLER(u32Cast, GCPtrEffSrc); + IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Cast); IEM_MC_ADVANCE_RIP(); IEM_MC_END(); @@ -7200,5 +7197,5 @@ IEMOP_MNEMONIC("mov Sw,Ev"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -7264,5 +7261,5 @@ * now until tests show it's checked.. */ IEMOP_MNEMONIC("pop Ev"); - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ @@ -7496,7 +7493,7 @@ IEM_MC_BEGIN(0, 1); IEM_MC_IF_GREG_BIT_SET(X86_GREG_xAX, 15) { - IEM_MC_STORE_GREG_U16(X86_GREG_xDX, UINT16_C(0xffff)); + IEM_MC_STORE_GREG_U16_CONST(X86_GREG_xDX, UINT16_C(0xffff)); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U16(X86_GREG_xDX, 0); + IEM_MC_STORE_GREG_U16_CONST(X86_GREG_xDX, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -7508,7 +7505,7 @@ IEM_MC_BEGIN(0, 1); IEM_MC_IF_GREG_BIT_SET(X86_GREG_xAX, 31) { - IEM_MC_STORE_GREG_U32(X86_GREG_xDX, UINT32_C(0xffffffff)); + IEM_MC_STORE_GREG_U32_CONST(X86_GREG_xDX, UINT32_C(0xffffffff)); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U32(X86_GREG_xDX, 0); + IEM_MC_STORE_GREG_U32_CONST(X86_GREG_xDX, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -7520,7 +7517,7 @@ IEM_MC_BEGIN(0, 1); IEM_MC_IF_GREG_BIT_SET(X86_GREG_xAX, 63) { - IEM_MC_STORE_GREG_U64(X86_GREG_xDX, UINT64_C(0xffffffffffffffff)); + IEM_MC_STORE_GREG_U64_CONST(X86_GREG_xDX, UINT64_C(0xffffffffffffffff)); } IEM_MC_ELSE() { - IEM_MC_STORE_GREG_U64(X86_GREG_xDX, 0); + IEM_MC_STORE_GREG_U64_CONST(X86_GREG_xDX, 0); } IEM_MC_ENDIF(); IEM_MC_ADVANCE_RIP(); @@ -7588,5 +7585,5 @@ case IEMMODE_16BIT: \ { \ - uint16_t u16Off; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Off); \ + uint16_t u16Off; IEM_OPCODE_GET_NEXT_U16(&u16Off); \ (a_GCPtrMemOff) = u16Off; \ break; \ @@ -7594,10 +7591,10 @@ case IEMMODE_32BIT: \ { \ - uint32_t u32Off; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Off); \ + uint32_t u32Off; IEM_OPCODE_GET_NEXT_U32(&u32Off); \ (a_GCPtrMemOff) = u32Off; \ break; \ } \ case IEMMODE_64BIT: \ - IEM_OPCODE_GET_NEXT_U64(pIemCpu, &(a_GCPtrMemOff)); \ + IEM_OPCODE_GET_NEXT_U64(&(a_GCPtrMemOff)); \ break; \ IEM_NOT_REACHED_DEFAULT_CASE_RET(); \ @@ -8557,5 +8554,5 @@ FNIEMOP_DEF_1(iemOpCommonMov_r8_Ib, uint8_t, iReg) { - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -8643,5 +8640,5 @@ case IEMMODE_16BIT: { - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -8656,5 +8653,5 @@ case IEMMODE_32BIT: { - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -8668,5 +8665,5 @@ case IEMMODE_64BIT: { - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_U64(&u64Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -8751,5 +8748,5 @@ FNIEMOP_DEF(iemOp_Grp2_Eb_Ib) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); PCIEMOPSHIFTSIZES pImpl; switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) @@ -8770,5 +8767,5 @@ { /* register */ - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEMOP_HLP_NO_LOCK_PREFIX(); IEM_MC_BEGIN(3, 0); @@ -8793,5 +8790,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEM_MC_ASSIGN(cShiftArg, cShift); IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -8811,5 +8808,5 @@ FNIEMOP_DEF(iemOp_Grp2_Ev_Ib) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); PCIEMOPSHIFTSIZES pImpl; switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) @@ -8830,5 +8827,5 @@ { /* register */ - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEMOP_HLP_NO_LOCK_PREFIX(); switch (pIemCpu->enmEffOpSize) @@ -8887,5 +8884,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEM_MC_ASSIGN(cShiftArg, cShift); IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -8907,5 +8904,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEM_MC_ASSIGN(cShiftArg, cShift); IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -8927,5 +8924,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift); + uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift); IEM_MC_ASSIGN(cShiftArg, cShift); IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -8949,5 +8946,5 @@ { IEMOP_MNEMONIC("retn Iw"); - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -8985,5 +8982,5 @@ FNIEMOP_DEF(iemOp_Grp11_Eb_Ib) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ if ((bRm & X86_MODRM_REG_MASK) != (0 << X86_MODRM_REG_SHIFT)) /* only mov Eb,Ib in this group. */ @@ -8994,5 +8991,5 @@ { /* register access */ - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEM_MC_BEGIN(0, 0); IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u8Imm); @@ -9006,5 +9003,5 @@ IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEM_MC_STORE_MEM_U8(pIemCpu->iEffSeg, GCPtrEffDst, u8Imm); IEM_MC_ADVANCE_RIP(); @@ -9018,5 +9015,5 @@ FNIEMOP_DEF(iemOp_Grp11_Ev_Iz) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */ if ((bRm & X86_MODRM_REG_MASK) != (0 << X86_MODRM_REG_SHIFT)) /* only mov Eb,Ib in this group. */ @@ -9031,5 +9028,5 @@ case IEMMODE_16BIT: IEM_MC_BEGIN(0, 0); - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u16Imm); IEM_MC_ADVANCE_RIP(); @@ -9039,5 +9036,5 @@ case IEMMODE_32BIT: IEM_MC_BEGIN(0, 0); - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Imm); IEM_MC_ADVANCE_RIP(); @@ -9047,5 +9044,5 @@ case IEMMODE_64BIT: IEM_MC_BEGIN(0, 0); - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_U64(&u64Imm); IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Imm); IEM_MC_ADVANCE_RIP(); @@ -9065,5 +9062,5 @@ IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Imm); IEM_MC_ADVANCE_RIP(); @@ -9075,5 +9072,5 @@ IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEM_MC_STORE_MEM_U32(pIemCpu->iEffSeg, GCPtrEffDst, u32Imm); IEM_MC_ADVANCE_RIP(); @@ -9085,5 +9082,5 @@ IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_U64(&u64Imm); IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffDst, u64Imm); IEM_MC_ADVANCE_RIP(); @@ -9117,5 +9114,5 @@ { IEMOP_MNEMONIC("retf Iw"); - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -9144,5 +9141,5 @@ FNIEMOP_DEF(iemOp_int_Ib) { - uint8_t u8Int; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Int); + uint8_t u8Int; IEM_OPCODE_GET_NEXT_U8(&u8Int); return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_int, u8Int, false /*fIsBpInstr*/); } @@ -9173,5 +9170,5 @@ FNIEMOP_DEF(iemOp_Grp2_Eb_1) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); PCIEMOPSHIFTSIZES pImpl; switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) @@ -9231,5 +9228,5 @@ FNIEMOP_DEF(iemOp_Grp2_Ev_1) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); PCIEMOPSHIFTSIZES pImpl; switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) @@ -9361,5 +9358,5 @@ FNIEMOP_DEF(iemOp_Grp2_Eb_CL) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); PCIEMOPSHIFTSIZES pImpl; switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) @@ -9420,5 +9417,5 @@ FNIEMOP_DEF(iemOp_Grp2_Ev_CL) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); PCIEMOPSHIFTSIZES pImpl; switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) @@ -9687,5 +9684,5 @@ FNIEMOP_DEF(iemOp_EscF3) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) { @@ -9743,5 +9740,5 @@ FNIEMOP_DEF(iemOp_EscF6) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) { @@ -9805,5 +9802,5 @@ FNIEMOP_DEF(iemOp_EscF7) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) { @@ -9837,5 +9834,5 @@ { IEMOP_MNEMONIC("loopne Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -9885,5 +9882,5 @@ { IEMOP_MNEMONIC("loope Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -9933,5 +9930,5 @@ { IEMOP_MNEMONIC("loop Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -9984,5 +9981,5 @@ { IEMOP_MNEMONIC("jecxz Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -10029,5 +10026,5 @@ { IEMOP_MNEMONIC("in eAX,Ib"); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_in, u8Imm, 1); @@ -10039,5 +10036,5 @@ { IEMOP_MNEMONIC("in eAX,Ib"); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_in, u8Imm, pIemCpu->enmEffOpSize == IEMMODE_16BIT ? 2 : 4); @@ -10049,5 +10046,5 @@ { IEMOP_MNEMONIC("out Ib,AL"); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_out, u8Imm, 1); @@ -10059,5 +10056,5 @@ { IEMOP_MNEMONIC("out Ib,eAX"); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_out, u8Imm, pIemCpu->enmEffOpSize == IEMMODE_16BIT ? 2 : 4); @@ -10074,5 +10071,5 @@ case IEMMODE_16BIT: { - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_call_rel_16, (int32_t)u16Imm); } @@ -10080,5 +10077,5 @@ case IEMMODE_32BIT: { - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_call_rel_32, (int32_t)u32Imm); } @@ -10086,5 +10083,5 @@ case IEMMODE_64BIT: { - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_call_rel_64, u64Imm); } @@ -10135,11 +10132,11 @@ uint32_t offSeg; if (pIemCpu->enmEffOpSize != IEMMODE_16BIT) - IEM_OPCODE_GET_NEXT_U32(pIemCpu, &offSeg); + IEM_OPCODE_GET_NEXT_U32(&offSeg); else { - uint16_t offSeg16; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &offSeg16); + uint16_t offSeg16; IEM_OPCODE_GET_NEXT_U16(&offSeg16); offSeg = offSeg16; } - uint16_t uSel; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &uSel); + uint16_t uSel; IEM_OPCODE_GET_NEXT_U16(&uSel); IEMOP_HLP_NO_LOCK_PREFIX(); return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_FarJmp, uSel, offSeg, pIemCpu->enmEffOpSize); @@ -10151,5 +10148,5 @@ { IEMOP_MNEMONIC("jmp Jb"); - int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(pIemCpu, &i8Imm); + int8_t i8Imm; IEM_OPCODE_GET_NEXT_S8(&i8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); IEMOP_HLP_DEFAULT_64BIT_OP_SIZE(); @@ -10203,5 +10200,5 @@ pIemCpu->fPrefixes |= IEM_OP_PRF_LOCK; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -10215,5 +10212,5 @@ pIemCpu->fPrefixes |= IEM_OP_PRF_REPNZ; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -10227,5 +10224,5 @@ pIemCpu->fPrefixes |= IEM_OP_PRF_REPZ; - uint8_t b; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &b); + uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b); return FNIEMOP_CALL(g_apfnOneByteMap[b]); } @@ -10378,5 +10375,5 @@ { /* register access */ - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEMOP_HLP_NO_LOCK_PREFIX(); @@ -10403,5 +10400,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm); + uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); IEM_MC_ASSIGN(u8Src, u8Imm); IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -10432,5 +10429,5 @@ case IEMMODE_16BIT: { - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEM_MC_BEGIN(3, 0); IEM_MC_ARG(uint16_t *, pu16Dst, 0); @@ -10447,5 +10444,5 @@ case IEMMODE_32BIT: { - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEM_MC_BEGIN(3, 0); IEM_MC_ARG(uint32_t *, pu32Dst, 0); @@ -10462,5 +10459,5 @@ case IEMMODE_64BIT: { - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); IEM_MC_BEGIN(3, 0); IEM_MC_ARG(uint64_t *, pu64Dst, 0); @@ -10492,5 +10489,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm); + uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm); IEM_MC_ASSIGN(u16Src, u16Imm); IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -10514,5 +10511,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(pIemCpu, &u32Imm); + uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm); IEM_MC_ASSIGN(u32Src, u32Imm); IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -10536,5 +10533,5 @@ IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm); - uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(pIemCpu, &u64Imm); + uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm); IEM_MC_ASSIGN(u64Src, u64Imm); IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/); @@ -10782,5 +10779,5 @@ FNIEMOP_DEF(iemOp_Grp3_Eb) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) { @@ -10798,17 +10795,17 @@ IEMOP_MNEMONIC("mul Eb"); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF); - return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, &iemAImpl_mul_u8); + return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, iemAImpl_mul_u8); case 5: IEMOP_MNEMONIC("imul Eb"); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF); - return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, &iemAImpl_imul_u8); + return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, iemAImpl_imul_u8); case 6: IEMOP_MNEMONIC("div Eb"); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_OF | X86_EFL_CF); - return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, &iemAImpl_div_u8); + return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, iemAImpl_div_u8); case 7: IEMOP_MNEMONIC("idiv Eb"); IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_OF | X86_EFL_CF); - return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, &iemAImpl_idiv_u8); + return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, iemAImpl_idiv_u8); IEM_NOT_REACHED_DEFAULT_CASE_RET(); } @@ -10819,5 +10816,5 @@ FNIEMOP_DEF(iemOp_Grp3_Ev) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) { @@ -10925,5 +10922,5 @@ FNIEMOP_DEF(iemOp_Grp4) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) { @@ -11294,5 +11291,5 @@ FNIEMOP_DEF(iemOp_Grp5) { - uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm); + uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); switch ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) { Index: /trunk/src/VBox/VMM/testcase/tstIEMCheckMc.cpp =================================================================== --- /trunk/src/VBox/VMM/testcase/tstIEMCheckMc.cpp (revision 37002) +++ /trunk/src/VBox/VMM/testcase/tstIEMCheckMc.cpp (revision 37003) @@ -39,5 +39,5 @@ #define CHK_TYPE(a_ExpectedType, a_Param) \ - do { a_ExpectedType *pCheckType = &(a_Param); } while (0) + do { a_ExpectedType const * pCheckType = &(a_Param); } while (0) #define CHK_PTYPE(a_ExpectedType, a_Param) \ do { a_ExpectedType pCheckType = (a_Param); } while (0) @@ -57,10 +57,10 @@ #define IEM_NOT_REACHED_DEFAULT_CASE_RET() default: return VERR_INTERNAL_ERROR_4 -#define IEM_OPCODE_GET_NEXT_BYTE(a_pIemCpu, a_pu8) do { *(a_pu8) = g_bRandom; CHK_PTYPE(uint8_t *, a_pu8); } while (0) -#define IEM_OPCODE_GET_NEXT_U16(a_pIemCpu, a_pu16) do { *(a_pu16) = g_bRandom; CHK_PTYPE(uint16_t *, a_pu16); } while (0) -#define IEM_OPCODE_GET_NEXT_U32(a_pIemCpu, a_pu32) do { *(a_pu32) = g_bRandom; CHK_PTYPE(uint32_t *, a_pu32); } while (0) -#define IEM_OPCODE_GET_NEXT_S32_SX_U64(a_pIemCpu, a_pu64) do { *(a_pu64) = g_bRandom; CHK_PTYPE(uint64_t *, a_pu64); } while (0) -#define IEM_OPCODE_GET_NEXT_U64(a_pIemCpu, a_pu64) do { *(a_pu64) = g_bRandom; CHK_PTYPE(uint64_t *, a_pu64); } while (0) -#define IEM_OPCODE_GET_NEXT_S8(a_pIemCpu, a_pi8) do { *(a_pi8) = g_bRandom; CHK_PTYPE(int8_t *, a_pi8); } while (0) +#define IEM_OPCODE_GET_NEXT_U8(a_pu8) do { *(a_pu8) = g_bRandom; CHK_PTYPE(uint8_t *, a_pu8); } while (0) +#define IEM_OPCODE_GET_NEXT_U16(a_pu16) do { *(a_pu16) = g_bRandom; CHK_PTYPE(uint16_t *, a_pu16); } while (0) +#define IEM_OPCODE_GET_NEXT_U32(a_pu32) do { *(a_pu32) = g_bRandom; CHK_PTYPE(uint32_t *, a_pu32); } while (0) +#define IEM_OPCODE_GET_NEXT_S32_SX_U64(a_pu64) do { *(a_pu64) = g_bRandom; CHK_PTYPE(uint64_t *, a_pu64); } while (0) +#define IEM_OPCODE_GET_NEXT_U64(a_pu64) do { *(a_pu64) = g_bRandom; CHK_PTYPE(uint64_t *, a_pu64); } while (0) +#define IEM_OPCODE_GET_NEXT_S8(a_pi8) do { *(a_pi8) = g_bRandom; CHK_PTYPE(int8_t *, a_pi8); } while (0) #define IEM_OPCODE_GET_NEXT_S16(a_pi16) do { *(a_pi16) = g_bRandom; CHK_PTYPE(int16_t *, a_pi16); } while (0) #define IEM_OPCODE_GET_NEXT_S32(a_pi32) do { *(a_pi32) = g_bRandom; CHK_PTYPE(int32_t *, a_pi32); } while (0) @@ -128,4 +128,10 @@ IEMOPSHIFTDBLSIZES g_iemAImpl_shrd; + +#define iemAImpl_idiv_u8 ((PFNIEMAIMPLMULDIVU8)0) +#define iemAImpl_div_u8 ((PFNIEMAIMPLMULDIVU8)0) +#define iemAImpl_imul_u8 ((PFNIEMAIMPLMULDIVU8)0) +#define iemAImpl_mul_u8 ((PFNIEMAIMPLMULDIVU8)0) + /** @} */ @@ -138,12 +144,11 @@ #define IEM_MC_PAUSE() do {} while (0) #define IEM_MC_CONTINUE() do {} while (0) -#define IEM_MC_RETURN_ON_FAILURE(a_Expr) do {} while (0) #define IEM_MC_ADVANCE_RIP() do {} while (0) #define IEM_MC_REL_JMP_S8(a_i8) CHK_TYPE(int8_t, a_i8) #define IEM_MC_REL_JMP_S16(a_i16) CHK_TYPE(int16_t, a_i16) #define IEM_MC_REL_JMP_S32(a_i32) CHK_TYPE(int32_t, a_i32) -#define IEM_MC_SET_RIP_U16(a_u16NewIP) do {} while (0) -#define IEM_MC_SET_RIP_U32(a_u32NewIP) do {} while (0) -#define IEM_MC_SET_RIP_U64(a_u64NewIP) do {} while (0) +#define IEM_MC_SET_RIP_U16(a_u16NewIP) CHK_TYPE(uint16_t, a_u16NewIP) +#define IEM_MC_SET_RIP_U32(a_u32NewIP) CHK_TYPE(uint32_t, a_u32NewIP) +#define IEM_MC_SET_RIP_U64(a_u64NewIP) CHK_TYPE(uint64_t, a_u64NewIP) #define IEM_MC_RAISE_DIVIDE_ERROR() return VERR_TRPM_ACTIVE_TRAP #define IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE() do {} while (0) @@ -159,40 +164,46 @@ uint32_t a_Name; \ uint32_t *a_pName = &a_Name -#define IEM_MC_COMMIT_EFLAGS(a_EFlags) do {} while (0) +#define IEM_MC_COMMIT_EFLAGS(a_EFlags) CHK_TYPE(uint32_t, a_EFlags) #define IEM_MC_ASSIGN(a_VarOrArg, a_CVariableOrConst) (a_VarOrArg) = (0) -#define IEM_MC_FETCH_GREG_U8(a_u8Dst, a_iGReg) (a_u8Dst) = 0 -#define IEM_MC_FETCH_GREG_U8_ZX_U16(a_u16Dst, a_iGReg) (a_u16Dst) = 0 -#define IEM_MC_FETCH_GREG_U8_ZX_U32(a_u32Dst, a_iGReg) (a_u32Dst) = 0 -#define IEM_MC_FETCH_GREG_U8_ZX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_GREG_U8_SX_U16(a_u16Dst, a_iGReg) (a_u16Dst) = 0 -#define IEM_MC_FETCH_GREG_U8_SX_U32(a_u32Dst, a_iGReg) (a_u32Dst) = 0 -#define IEM_MC_FETCH_GREG_U8_SX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_GREG_U16(a_u16Dst, a_iGReg) (a_u16Dst) = 0 -#define IEM_MC_FETCH_GREG_U16_ZX_U32(a_u32Dst, a_iGReg) (a_u32Dst) = 0 -#define IEM_MC_FETCH_GREG_U16_ZX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_GREG_U16_SX_U32(a_u32Dst, a_iGReg) (a_u32Dst) = 0 -#define IEM_MC_FETCH_GREG_U16_SX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_GREG_U32(a_u32Dst, a_iGReg) (a_u32Dst) = 0 -#define IEM_MC_FETCH_GREG_U32_ZX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_GREG_U32_SX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_GREG_U64(a_u64Dst, a_iGReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_SREG_U16(a_u16Dst, a_iSReg) (a_u16Dst) = 0 -#define IEM_MC_FETCH_SREG_ZX_U32(a_u32Dst, a_iSReg) (a_u32Dst) = 0 -#define IEM_MC_FETCH_SREG_ZX_U64(a_u64Dst, a_iSReg) (a_u64Dst) = 0 -#define IEM_MC_FETCH_CR0_U16(a_u16Dst) (a_u16Dst) = 0 -#define IEM_MC_FETCH_CR0_U32(a_u32Dst) (a_u32Dst) = 0 -#define IEM_MC_FETCH_CR0_U64(a_u64Dst) (a_u64Dst) = 0 -#define IEM_MC_FETCH_EFLAGS(a_EFlags) (a_EFlags) = 0 -#define IEM_MC_FETCH_FSW(a_u16Fsw) (a_u16Fsw) = 0 -#define IEM_MC_STORE_GREG_U8(a_iGReg, a_u8Value) do {} while (0) -#define IEM_MC_STORE_GREG_U16(a_iGReg, a_u16Value) do {} while (0) -#define IEM_MC_STORE_GREG_U32(a_iGReg, a_u32Value) do {} while (0) -#define IEM_MC_STORE_GREG_U64(a_iGReg, a_u64Value) do {} while (0) -#define IEM_MC_CLEAR_HIGH_GREG_U64(a_iGReg) do {} while (0) -#define IEM_MC_REF_GREG_U8(a_pu8Dst, a_iGReg) (a_pu8Dst) = (uint8_t *)((uintptr_t)0) -#define IEM_MC_REF_GREG_U16(a_pu16Dst, a_iGReg) (a_pu16Dst) = (uint16_t *)((uintptr_t)0) -#define IEM_MC_REF_GREG_U32(a_pu32Dst, a_iGReg) (a_pu32Dst) = (uint32_t *)((uintptr_t)0) -#define IEM_MC_REF_GREG_U64(a_pu64Dst, a_iGReg) (a_pu64Dst) = (uint64_t *)((uintptr_t)0) -#define IEM_MC_REF_EFLAGS(a_pEFlags) (a_pEFlags) = (uint32_t *)((uintptr_t)0) +#define IEM_MC_ASSIGN_TO_SMALLER IEM_MC_ASSIGN + +#define IEM_MC_FETCH_GREG_U8(a_u8Dst, a_iGReg) do { (a_u8Dst) = 0; CHK_TYPE(uint8_t, a_u8Dst); } while (0) +#define IEM_MC_FETCH_GREG_U8_ZX_U16(a_u16Dst, a_iGReg) do { (a_u16Dst) = 0; CHK_TYPE(uint16_t, a_u16Dst); } while (0) +#define IEM_MC_FETCH_GREG_U8_ZX_U32(a_u32Dst, a_iGReg) do { (a_u32Dst) = 0; CHK_TYPE(uint32_t, a_u32Dst); } while (0) +#define IEM_MC_FETCH_GREG_U8_ZX_U64(a_u64Dst, a_iGReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_GREG_U8_SX_U16(a_u16Dst, a_iGReg) do { (a_u16Dst) = 0; CHK_TYPE(uint16_t, a_u16Dst); } while (0) +#define IEM_MC_FETCH_GREG_U8_SX_U32(a_u32Dst, a_iGReg) do { (a_u32Dst) = 0; CHK_TYPE(uint32_t, a_u32Dst); } while (0) +#define IEM_MC_FETCH_GREG_U8_SX_U64(a_u64Dst, a_iGReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_GREG_U16(a_u16Dst, a_iGReg) do { (a_u16Dst) = 0; CHK_TYPE(uint16_t, a_u16Dst); } while (0) +#define IEM_MC_FETCH_GREG_U16_ZX_U32(a_u32Dst, a_iGReg) do { (a_u32Dst) = 0; CHK_TYPE(uint32_t, a_u32Dst); } while (0) +#define IEM_MC_FETCH_GREG_U16_ZX_U64(a_u64Dst, a_iGReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_GREG_U16_SX_U32(a_u32Dst, a_iGReg) do { (a_u32Dst) = 0; CHK_TYPE(uint32_t, a_u32Dst); } while (0) +#define IEM_MC_FETCH_GREG_U16_SX_U64(a_u64Dst, a_iGReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_GREG_U32(a_u32Dst, a_iGReg) do { (a_u32Dst) = 0; CHK_TYPE(uint32_t, a_u32Dst); } while (0) +#define IEM_MC_FETCH_GREG_U32_ZX_U64(a_u64Dst, a_iGReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_GREG_U32_SX_U64(a_u64Dst, a_iGReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_GREG_U64(a_u64Dst, a_iGReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_SREG_U16(a_u16Dst, a_iSReg) do { (a_u16Dst) = 0; CHK_TYPE(uint16_t, a_u16Dst); } while (0) +#define IEM_MC_FETCH_SREG_ZX_U32(a_u32Dst, a_iSReg) do { (a_u32Dst) = 0; CHK_TYPE(uint32_t, a_u32Dst); } while (0) +#define IEM_MC_FETCH_SREG_ZX_U64(a_u64Dst, a_iSReg) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_CR0_U16(a_u16Dst) do { (a_u16Dst) = 0; CHK_TYPE(uint16_t, a_u16Dst); } while (0) +#define IEM_MC_FETCH_CR0_U32(a_u32Dst) do { (a_u32Dst) = 0; CHK_TYPE(uint32_t, a_u32Dst); } while (0) +#define IEM_MC_FETCH_CR0_U64(a_u64Dst) do { (a_u64Dst) = 0; CHK_TYPE(uint64_t, a_u64Dst); } while (0) +#define IEM_MC_FETCH_EFLAGS(a_EFlags) do { (a_EFlags) = 0; CHK_TYPE(uint32_t, a_EFlags); } while (0) +#define IEM_MC_FETCH_FSW(a_u16Fsw) do { (a_u16Fsw) = 0; CHK_TYPE(uint16_t, a_u16Fsw); } while (0) +#define IEM_MC_STORE_GREG_U8(a_iGReg, a_u8Value) do { CHK_TYPE(uint8_t, a_u8Value); } while (0) +#define IEM_MC_STORE_GREG_U16(a_iGReg, a_u16Value) do { CHK_TYPE(uint16_t, a_u16Value); } while (0) +#define IEM_MC_STORE_GREG_U32(a_iGReg, a_u32Value) do { } while (0) +#define IEM_MC_STORE_GREG_U64(a_iGReg, a_u64Value) do { } while (0) +#define IEM_MC_STORE_GREG_U8_CONST(a_iGReg, a_u8C) do { AssertCompile((uint8_t )(a_u8C) == (a_u8C) ); } while (0) +#define IEM_MC_STORE_GREG_U16_CONST(a_iGReg, a_u16C) do { AssertCompile((uint16_t)(a_u16C) == (a_u16C)); } while (0) +#define IEM_MC_STORE_GREG_U32_CONST(a_iGReg, a_u32C) do { AssertCompile((uint32_t)(a_u32C) == (a_u32C)); } while (0) +#define IEM_MC_STORE_GREG_U64_CONST(a_iGReg, a_u64C) do { AssertCompile((uint64_t)(a_u64C) == (a_u64C)); } while (0) +#define IEM_MC_CLEAR_HIGH_GREG_U64(a_iGReg) do { } while (0) +#define IEM_MC_REF_GREG_U8(a_pu8Dst, a_iGReg) do { (a_pu8Dst) = (uint8_t *)((uintptr_t)0); CHK_PTYPE(uint8_t *, a_pu8Dst); } while (0) +#define IEM_MC_REF_GREG_U16(a_pu16Dst, a_iGReg) do { (a_pu16Dst) = (uint16_t *)((uintptr_t)0); CHK_PTYPE(uint16_t *, a_pu16Dst); } while (0) +#define IEM_MC_REF_GREG_U32(a_pu32Dst, a_iGReg) do { (a_pu32Dst) = (uint32_t *)((uintptr_t)0); CHK_PTYPE(uint32_t *, a_pu32Dst); } while (0) +#define IEM_MC_REF_GREG_U64(a_pu64Dst, a_iGReg) do { (a_pu64Dst) = (uint64_t *)((uintptr_t)0); CHK_PTYPE(uint64_t *, a_pu64Dst); } while (0) +#define IEM_MC_REF_EFLAGS(a_pEFlags) do { (a_pEFlags) = (uint32_t *)((uintptr_t)0); CHK_PTYPE(uint32_t *, a_pEFlags); } while (0) #define IEM_MC_ADD_GREG_U8(a_iGReg, a_u16Value) do {} while (0) #define IEM_MC_ADD_GREG_U16(a_iGReg, a_u16Value) do {} while (0)