VirtualBox

Changeset 95403 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Jun 27, 2022 11:38:38 PM (3 years ago)
Author:
vboxsync
Message:

VMM/IEM: vxorps, vxorpd, vpxor, xorps, xorpd and various related fixes. bugref:9898

Location:
trunk/src/VBox/VMM
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/Config.kmk

    r94934 r95403  
    4949 endif
    5050endif
     51ifdef IEM_WITHOUT_ASSEMBLY
     52 VMM_COMMON_DEFS += IEM_WITHOUT_ASSEMBLY
     53endif
    5154# part of global DEFS
    5255ifdef VBOX_WITH_MULTI_CORE

  • trunk/src/VBox/VMM/Makefile.kmk

    r94955 r95403  
    299299
    300300
    301 #
    302 # This'll apply to both VBoxVMM and VMMR0.
    303 #
    304 ifdef IEM_WITHOUT_ASSEMBLY
    305 VMMAll/IEMAllAImplC.cpp_DEFS = IEM_WITHOUT_ASSEMBLY
    306 endif
    307 
    308301
    309302#

  • trunk/src/VBox/VMM/VMMAll/IEMAllAImpl.asm

    r95360 r95403  
    35533553%endmacro
    35543554
     3555;; @todo what do we need to do for AVX?
     3556%macro IEMIMPL_AVX_PROLOGUE 0
     3557%endmacro
     3558%macro IEMIMPL_AVX_EPILOGUE 0
     3559%endmacro
     3560
    35553561
    35563562;;
    … …  
    37883794ENDPROC iemAImpl_pmovmskb_u128
    37893795
     3796
     3797;;
     3798; Media instruction working on two full sized source registers and one destination (AVX).
     3799;
     3800; @param    1       The instruction
     3801;
     3802; @param    A0      Pointer to the extended CPU/FPU state (X86XSAVEAREA).
     3803; @param    A1      Pointer to the destination media register size operand (output).
     3804; @param    A2      Pointer to the first source media register size operand (input).
     3805; @param    A3      Pointer to the second source media register size operand (input).
     3806;
     3807%macro IEMIMPL_MEDIA_F3 1
     3808BEGINPROC_FASTCALL iemAImpl_ %+ %1 %+ _u128, 16
     3809        PROLOGUE_4_ARGS
     3810        IEMIMPL_AVX_PROLOGUE
     3811
     3812        vmovdqu  xmm0, [A2]
     3813        vmovdqu  xmm1, [A3]
     3814        %1       xmm0, xmm0, xmm1
     3815        vmovdqu  [A1], xmm0
     3816
     3817        IEMIMPL_AVX_PROLOGUE
     3818        EPILOGUE_4_ARGS
     3819ENDPROC iemAImpl_ %+ %1 %+ _u128
     3820
     3821BEGINPROC_FASTCALL iemAImpl_ %+ %1 %+ _u256, 16
     3822        PROLOGUE_4_ARGS
     3823        IEMIMPL_SSE_PROLOGUE
     3824
     3825        vmovdqu  ymm0, [A2]
     3826        vmovdqu  ymm1, [A3]
     3827        %1       ymm0, ymm0, ymm1
     3828        vmovdqu  [A1], ymm0
     3829
     3830        IEMIMPL_AVX_PROLOGUE
     3831        EPILOGUE_4_ARGS
     3832ENDPROC iemAImpl_ %+ %1 %+ _u256
     3833%endmacro
     3834
     3835IEMIMPL_MEDIA_F3 vpxor
     3836

  • trunk/src/VBox/VMM/VMMAll/IEMAllAImplC.cpp

    r95360 r95403  
    70727072
    70737073
    7074 IEM_DECL_IMPL_DEF(void, iemAImpl_pxor_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
     7074/*
     7075 * PXOR / VPXOR / PXORPS / VPXORPS / PXORPD / VPXORPD
     7076 */
     7077
     7078IEM_DECL_IMPL_DEF(void, iemAImpl_pxor_u64,(PCX86FXSTATE pFpuState, uint64_t *puDst, uint64_t const *puSrc))
     7079{
     7080    RT_NOREF(pFpuState);
     7081    *puDst ^= *puSrc;
     7082}
     7083
     7084
     7085IEM_DECL_IMPL_DEF(void, iemAImpl_pxor_u128,(PCX86FXSTATE pFpuState, PRTUINT128U puDst, PCRTUINT128U puSrc))
     7086{
     7087    RT_NOREF(pFpuState);
     7088    puDst->au64[0] ^= puSrc->au64[0];
     7089    puDst->au64[1] ^= puSrc->au64[1];
     7090}
     7091
     7092#endif /* IEM_WITHOUT_ASSEMBLY */
     7093
     7094IEM_DECL_IMPL_DEF(void, iemAImpl_vpxor_u128_fallback,(PX86XSAVEAREA pExtState, PRTUINT128U puDst,
     7095                                                      PCRTUINT128U puSrc1, PCRTUINT128U puSrc2))
     7096{
     7097    RT_NOREF(pExtState);
     7098    puDst->au64[0] = puSrc1->au64[0] ^ puSrc2->au64[0];
     7099    puDst->au64[1] = puSrc1->au64[1] ^ puSrc2->au64[1];
     7100}
     7101
     7102
     7103IEM_DECL_IMPL_DEF(void, iemAImpl_vpxor_u256_fallback,(PX86XSAVEAREA pExtState, PRTUINT256U puDst,
     7104                                                      PCRTUINT256U puSrc1, PCRTUINT256U puSrc2))
     7105{
     7106    RT_NOREF(pExtState);
     7107    puDst->au64[0] = puSrc1->au64[0] ^ puSrc2->au64[0];
     7108    puDst->au64[1] = puSrc1->au64[1] ^ puSrc2->au64[1];
     7109    puDst->au64[2] = puSrc1->au64[2] ^ puSrc2->au64[2];
     7110    puDst->au64[3] = puSrc1->au64[3] ^ puSrc2->au64[3];
     7111}
     7112
     7113#ifdef IEM_WITHOUT_ASSEMBLY
     7114
     7115IEM_DECL_IMPL_DEF(void, iemAImpl_pmovmskb_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
    70757116{
    70767117    RT_NOREF(pFpuState, pu64Dst, pu64Src);
    70777118    AssertReleaseFailed();
    7078 }
    7079 
    7080 
    7081 IEM_DECL_IMPL_DEF(void, iemAImpl_pxor_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
     7119
     7120}
     7121
     7122
     7123IEM_DECL_IMPL_DEF(void, iemAImpl_pmovmskb_u128,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, PCRTUINT128U pu128Src))
     7124{
     7125    RT_NOREF(pFpuState, pu64Dst, pu128Src);
     7126    AssertReleaseFailed();
     7127}
     7128
     7129
     7130IEM_DECL_IMPL_DEF(void, iemAImpl_pshufw,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src, uint8_t bEvil))
     7131{
     7132    RT_NOREF(pFpuState, pu64Dst, pu64Src, bEvil);
     7133    AssertReleaseFailed();
     7134}
     7135
     7136
     7137IEM_DECL_IMPL_DEF(void, iemAImpl_pshufhw,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src, uint8_t bEvil))
     7138{
     7139    RT_NOREF(pFpuState, pu128Dst, pu128Src, bEvil);
     7140    AssertReleaseFailed();
     7141}
     7142
     7143
     7144IEM_DECL_IMPL_DEF(void, iemAImpl_pshuflw,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src, uint8_t bEvil))
     7145{
     7146    RT_NOREF(pFpuState, pu128Dst, pu128Src, bEvil);
     7147    AssertReleaseFailed();
     7148}
     7149
     7150
     7151IEM_DECL_IMPL_DEF(void, iemAImpl_pshufd,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src, uint8_t bEvil))
     7152{
     7153    RT_NOREF(pFpuState, pu128Dst, pu128Src, bEvil);
     7154    AssertReleaseFailed();
     7155}
     7156
     7157/* PUNPCKHxxx */
     7158
     7159IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhbw_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
     7160{
     7161    RT_NOREF(pFpuState, pu64Dst, pu64Src);
     7162    AssertReleaseFailed();
     7163}
     7164
     7165
     7166IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhbw_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
    70827167{
    70837168    RT_NOREF(pFpuState, pu128Dst, pu128Src);
    … …  
    70867171
    70877172
    7088 IEM_DECL_IMPL_DEF(void, iemAImpl_pmovmskb_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
     7173IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhwd_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
    70897174{
    70907175    RT_NOREF(pFpuState, pu64Dst, pu64Src);
    70917176    AssertReleaseFailed();
    7092 
    7093 }
    7094 
    7095 
    7096 IEM_DECL_IMPL_DEF(void, iemAImpl_pmovmskb_u128,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, PCRTUINT128U pu128Src))
    7097 {
    7098     RT_NOREF(pFpuState, pu64Dst, pu128Src);
     7177}
     7178
     7179
     7180IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhwd_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
     7181{
     7182    RT_NOREF(pFpuState, pu128Dst, pu128Src);
    70997183    AssertReleaseFailed();
    71007184}
    71017185
    71027186
    7103 IEM_DECL_IMPL_DEF(void, iemAImpl_pshufw,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src, uint8_t bEvil))
    7104 {
    7105     RT_NOREF(pFpuState, pu64Dst, pu64Src, bEvil);
    7106     AssertReleaseFailed();
    7107 }
    7108 
    7109 
    7110 IEM_DECL_IMPL_DEF(void, iemAImpl_pshufhw,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src, uint8_t bEvil))
    7111 {
    7112     RT_NOREF(pFpuState, pu128Dst, pu128Src, bEvil);
    7113     AssertReleaseFailed();
    7114 }
    7115 
    7116 
    7117 IEM_DECL_IMPL_DEF(void, iemAImpl_pshuflw,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src, uint8_t bEvil))
    7118 {
    7119     RT_NOREF(pFpuState, pu128Dst, pu128Src, bEvil);
    7120     AssertReleaseFailed();
    7121 }
    7122 
    7123 
    7124 IEM_DECL_IMPL_DEF(void, iemAImpl_pshufd,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src, uint8_t bEvil))
    7125 {
    7126     RT_NOREF(pFpuState, pu128Dst, pu128Src, bEvil);
    7127     AssertReleaseFailed();
    7128 }
    7129 
    7130 /* PUNPCKHxxx */
    7131 
    7132 IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhbw_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
     7187IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhdq_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
    71337188{
    71347189    RT_NOREF(pFpuState, pu64Dst, pu64Src);
    … …  
    71377192
    71387193
    7139 IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhbw_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
     7194IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhdq_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
    71407195{
    71417196    RT_NOREF(pFpuState, pu128Dst, pu128Src);
    … …  
    71447199
    71457200
    7146 IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhwd_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
    7147 {
    7148     RT_NOREF(pFpuState, pu64Dst, pu64Src);
    7149     AssertReleaseFailed();
    7150 }
    7151 
    7152 
    7153 IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhwd_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
     7201IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhqdq_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
    71547202{
    71557203    RT_NOREF(pFpuState, pu128Dst, pu128Src);
    … …  
    71577205}
    71587206
    7159 
    7160 IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhdq_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src))
    7161 {
    7162     RT_NOREF(pFpuState, pu64Dst, pu64Src);
    7163     AssertReleaseFailed();
    7164 }
    7165 
    7166 
    7167 IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhdq_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
    7168 {
    7169     RT_NOREF(pFpuState, pu128Dst, pu128Src);
    7170     AssertReleaseFailed();
    7171 }
    7172 
    7173 
    7174 IEM_DECL_IMPL_DEF(void, iemAImpl_punpckhqdq_u128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src))
    7175 {
    7176     RT_NOREF(pFpuState, pu128Dst, pu128Src);
    7177     AssertReleaseFailed();
    7178 }
    7179 
    71807207/* PUNPCKLxxx */
    71817208

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImpl.cpp

    r95248 r95403  
    83708370        pDst->Rsrvd1 = pSrc->Rsrvd1;
    83718371        pDst->Rsrvd2 = pSrc->Rsrvd2;
    8372         pDst->au32RsrvdForSoftware[0] = 0;
    83738372    }
    83748373    else
    … …  
    83768375        pDst->Rsrvd1 = 0;
    83778376        pDst->Rsrvd2 = 0;
    8378         pDst->au32RsrvdForSoftware[0] = X86_FXSTATE_RSVD_32BIT_MAGIC;
    83798377    }
    83808378
    … …  
    86018599            pDst->Rsrvd1 = pSrc->Rsrvd1;
    86028600            pDst->Rsrvd2 = pSrc->Rsrvd2;
    8603             pDst->au32RsrvdForSoftware[0] = 0;
    86048601        }
    86058602        else
    … …  
    86078604            pDst->Rsrvd1 = 0;
    86088605            pDst->Rsrvd2 = 0;
    8609             pDst->au32RsrvdForSoftware[0] = X86_FXSTATE_RSVD_32BIT_MAGIC;
    86108606        }
    86118607        for (uint32_t i = 0; i < RT_ELEMENTS(pDst->aRegs); i++)

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsInterpretOnly.cpp

    r94768 r95403  
    919919IEM_STATIC const IEMOPMEDIAF2 g_iemAImpl_pcmpeqd      = { iemAImpl_pcmpeqd_u64,    iemAImpl_pcmpeqd_u128 };
    920920
     921# ifndef IEM_WITHOUT_ASSEMBLY
     922/** Function table for the VPXOR instruction */
     923IEM_STATIC const IEMOPMEDIAF3 g_iemAImpl_vpxor          = { iemAImpl_vpxor_u128,   iemAImpl_vpxor_u256 };
     924# endif
     925/** Function table for the VPXOR instruction, software fallback. */
     926IEM_STATIC const IEMOPMEDIAF3 g_iemAImpl_vpxor_fallback = { iemAImpl_vpxor_u128_fallback, iemAImpl_vpxor_u256_fallback };
     927
    921928#endif /* !TST_IEM_CHECK_MC */
    922929

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsPython.py

    r95347 r95403  
    302302    # VEX.vvvv
    303303    'By':           ( 'IDX_UseModRM',       'vvvv',   '%By',  'By',      'V',     ),
     304    'Hps':          ( 'IDX_UseModRM',       'vvvv',   '%Hps', 'Hps',     'V',     ),
     305    'Hpd':          ( 'IDX_UseModRM',       'vvvv',   '%Hpd', 'Hpd',     'V',     ),
    304306    'HssHi':        ( 'IDX_UseModRM',       'vvvv',   '%Hx',  'HssHi',   'V',     ),
    305307    'HsdHi':        ( 'IDX_UseModRM',       'vvvv',   '%Hx',  'HsdHi',   'V',     ),
    306308    'HqHi':         ( 'IDX_UseModRM',       'vvvv',   '%Hq',  'HqHi',    'V',     ),
     309    'Hx':           ( 'IDX_UseModRM',       'vvvv',   '%Hx',  'Hx',      'V',     ),
    307310
    308311    # Immediate values.

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsTwoByte0f.cpp.h

    r95360 r95403  
    2424 * @{
    2525 */
     26
     27
     28/**
     29 * Common worker for MMX instructions on the form:
     30 *      pxxx    mm1, mm2/mem64
     31 */
     32FNIEMOP_DEF_1(iemOpCommonMmx_FullFull_To_Full, PCIEMOPMEDIAF2, pImpl)
     33{
     34    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     35    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     36    {
     37        /*
     38         * Register, register.
     39         */
     40        /** @todo testcase: REX.B / REX.R and MMX register indexing. Ignored? */
     41        /** @todo testcase: REX.B / REX.R and segment register indexing. Ignored? */
     42        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     43        IEM_MC_BEGIN(2, 0);
     44        IEM_MC_ARG(uint64_t *,          pDst, 0);
     45        IEM_MC_ARG(uint64_t const *,    pSrc, 1);
     46        IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     47        IEM_MC_PREPARE_FPU_USAGE();
     48        IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
     49        IEM_MC_REF_MREG_U64_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
     50        IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
     51        IEM_MC_FPU_TO_MMX_MODE();
     52        IEM_MC_ADVANCE_RIP();
     53        IEM_MC_END();
     54    }
     55    else
     56    {
     57        /*
     58         * Register, memory.
     59         */
     60        IEM_MC_BEGIN(2, 2);
     61        IEM_MC_ARG(uint64_t *,                  pDst,       0);
     62        IEM_MC_LOCAL(uint64_t,                  uSrc);
     63        IEM_MC_ARG_LOCAL_REF(uint64_t const *,  pSrc, uSrc, 1);
     64        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
     65
     66        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     67        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     68        IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     69        IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     70
     71        IEM_MC_PREPARE_FPU_USAGE();
     72        IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
     73        IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
     74        IEM_MC_FPU_TO_MMX_MODE();
     75
     76        IEM_MC_ADVANCE_RIP();
     77        IEM_MC_END();
     78    }
     79    return VINF_SUCCESS;
     80}
     81
     82
     83/**
     84 * Common worker for SSE2 instructions on the forms:
     85 *      pxxx    xmm1, xmm2/mem128
     86 *
     87 * Proper alignment of the 128-bit operand is enforced.
     88 * Exceptions type 4. SSE2 cpuid checks.
     89 */
     90FNIEMOP_DEF_1(iemOpCommonSse2_FullFull_To_Full, PCIEMOPMEDIAF2, pImpl)
     91{
     92    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     93    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     94    {
     95        /*
     96         * Register, register.
     97         */
     98        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     99        IEM_MC_BEGIN(2, 0);
     100        IEM_MC_ARG(PRTUINT128U,          pDst, 0);
     101        IEM_MC_ARG(PCRTUINT128U,         pSrc, 1);
     102        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     103        IEM_MC_PREPARE_SSE_USAGE();
     104        IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     105        IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     106        IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
     107        IEM_MC_ADVANCE_RIP();
     108        IEM_MC_END();
     109    }
     110    else
     111    {
     112        /*
     113         * Register, memory.
     114         */
     115        IEM_MC_BEGIN(2, 2);
     116        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
     117        IEM_MC_LOCAL(RTUINT128U,                uSrc);
     118        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
     119        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
     120
     121        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     122        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     123        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     124        IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     125
     126        IEM_MC_PREPARE_SSE_USAGE();
     127        IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     128        IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
     129
     130        IEM_MC_ADVANCE_RIP();
     131        IEM_MC_END();
     132    }
     133    return VINF_SUCCESS;
     134}
     135
    26136
    27137/** Opcode 0x0f 0x00 /0. */
    … …  
    29393049/*  Opcode 0xf2 0x0f 0x56 - invalid */
    29403050
     3051
    29413052/** Opcode      0x0f 0x57 - xorps Vps, Wps */
    2942 FNIEMOP_STUB(iemOp_xorps_Vps_Wps);
     3053FNIEMOP_DEF(iemOp_xorps_Vps_Wps)
     3054{
     3055    IEMOP_MNEMONIC2(RM, XORPS, xorps, Vps, Wps, DISOPTYPE_HARMLESS, 0);
     3056    return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pxor);
     3057}
     3058
     3059
    29433060/** Opcode 0x66 0x0f 0x57 - xorpd Vpd, Wpd */
    2944 FNIEMOP_STUB(iemOp_xorpd_Vpd_Wpd);
     3061FNIEMOP_DEF(iemOp_xorpd_Vpd_Wpd)
     3062{
     3063    IEMOP_MNEMONIC2(RM, XORPD, xorpd, Vpd, Wpd, DISOPTYPE_HARMLESS, 0);
     3064    return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pxor);
     3065}
     3066
     3067
    29453068/*  Opcode 0xf3 0x0f 0x57 - invalid */
    29463069/*  Opcode 0xf2 0x0f 0x57 - invalid */
    … …  
    41444267
    41454268
    4146 /**
    4147  * Common worker for MMX instructions on the form:
    4148  *      pxxx    mm1, mm2/mem64
    4149  */
    4150 FNIEMOP_DEF_1(iemOpCommonMmx_FullFull_To_Full, PCIEMOPMEDIAF2, pImpl)
    4151 {
    4152     uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    4153     if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    4154     {
    4155         /*
    4156          * Register, register.
    4157          */
    4158         /** @todo testcase: REX.B / REX.R and MMX register indexing. Ignored? */
    4159         /** @todo testcase: REX.B / REX.R and segment register indexing. Ignored? */
    4160         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    4161         IEM_MC_BEGIN(2, 0);
    4162         IEM_MC_ARG(uint64_t *,          pDst, 0);
    4163         IEM_MC_ARG(uint64_t const *,    pSrc, 1);
    4164         IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    4165         IEM_MC_PREPARE_FPU_USAGE();
    4166         IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    4167         IEM_MC_REF_MREG_U64_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
    4168         IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
    4169         IEM_MC_ADVANCE_RIP();
    4170         IEM_MC_END();
    4171     }
    4172     else
    4173     {
    4174         /*
    4175          * Register, memory.
    4176          */
    4177         IEM_MC_BEGIN(2, 2);
    4178         IEM_MC_ARG(uint64_t *,                  pDst,       0);
    4179         IEM_MC_LOCAL(uint64_t,                  uSrc);
    4180         IEM_MC_ARG_LOCAL_REF(uint64_t const *,  pSrc, uSrc, 1);
    4181         IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    4182 
    4183         IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    4184         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    4185         IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    4186         IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    4187 
    4188         IEM_MC_PREPARE_FPU_USAGE();
    4189         IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    4190         IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
    4191 
    4192         IEM_MC_ADVANCE_RIP();
    4193         IEM_MC_END();
    4194     }
    4195     return VINF_SUCCESS;
    4196 }
    4197 
    4198 
    4199 /**
    4200  * Common worker for SSE2 instructions on the forms:
    4201  *      pxxx    xmm1, xmm2/mem128
    4202  *
    4203  * Proper alignment of the 128-bit operand is enforced.
    4204  * Exceptions type 4. SSE2 cpuid checks.
    4205  */
    4206 FNIEMOP_DEF_1(iemOpCommonSse2_FullFull_To_Full, PCIEMOPMEDIAF2, pImpl)
    4207 {
    4208     uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    4209     if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    4210     {
    4211         /*
    4212          * Register, register.
    4213          */
    4214         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    4215         IEM_MC_BEGIN(2, 0);
    4216         IEM_MC_ARG(PRTUINT128U,          pDst, 0);
    4217         IEM_MC_ARG(PCRTUINT128U,         pSrc, 1);
    4218         IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    4219         IEM_MC_PREPARE_SSE_USAGE();
    4220         IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    4221         IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    4222         IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    4223         IEM_MC_ADVANCE_RIP();
    4224         IEM_MC_END();
    4225     }
    4226     else
    4227     {
    4228         /*
    4229          * Register, memory.
    4230          */
    4231         IEM_MC_BEGIN(2, 2);
    4232         IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
    4233         IEM_MC_LOCAL(RTUINT128U,                uSrc);
    4234         IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
    4235         IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    4236 
    4237         IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    4238         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    4239         IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    4240         IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    4241 
    4242         IEM_MC_PREPARE_SSE_USAGE();
    4243         IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    4244         IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    4245 
    4246         IEM_MC_ADVANCE_RIP();
    4247         IEM_MC_END();
    4248     }
    4249     return VINF_SUCCESS;
    4250 }
    4251 
    4252 
    42534269/** Opcode      0x0f 0x74 - pcmpeqb Pq, Qq */
    42544270FNIEMOP_DEF(iemOp_pcmpeqb_Pq_Qq)
    … …  
    42614277FNIEMOP_DEF(iemOp_pcmpeqb_Vx_Wx)
    42624278{
    4263     IEMOP_MNEMONIC(vpcmpeqb_Vx_Wx, "pcmpeqb");
     4279    IEMOP_MNEMONIC(pcmpeqb_Vx_Wx, "pcmpeqb");
    42644280    return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pcmpeqb);
    42654281}
    … …  
    42974313FNIEMOP_DEF(iemOp_pcmpeqd_Vx_Wx)
    42984314{
    4299     IEMOP_MNEMONIC(pcmpeqd_Vx_Wx, "vpcmpeqd");
     4315    IEMOP_MNEMONIC(pcmpeqd_Vx_Wx, "pcmpeqd");
    43004316    return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pcmpeqd);
    43014317}
    … …  
    78107826        return iemOp_InvalidNeedRM(pVCpu);
    78117827#ifndef TST_IEM_CHECK_MC
    7812 # if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
     7828# if (defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)) && !defined(IEM_WITHOUT_ASSEMBLY)
    78137829    static const IEMOPBINSIZES s_Native =
    78147830    {   NULL, NULL, iemAImpl_popcnt_u16, NULL, iemAImpl_popcnt_u32, NULL, iemAImpl_popcnt_u64, NULL };
    … …  
    96089624}
    96099625
     9626
    96109627/** Opcode 0x66 0x0f 0xef - pxor Vx, Wx */
    96119628FNIEMOP_DEF(iemOp_pxor_Vx_Wx)

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsVexMap1.cpp.h

    r93115 r95403  
    2323 * @{
    2424 */
     25
     26/**
     27 * Common worker for AVX2 instructions on the forms:
     28 *     - vpxxx    xmm0, xmm1, xmm2/mem128
     29 *     - vpxxx    ymm0, ymm1, ymm2/mem256
     30 *
     31 * Exceptions type 4. AVX2 cpuid checks.
     32 */
     33FNIEMOP_DEF_1(iemOpCommonAvx2_Vx_Hx_Wx, PCIEMOPMEDIAF3, pImpl)
     34{
     35    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     36    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     37    {
     38        /*
     39         * Register, register.
     40         */
     41        IEMOP_HLP_DONE_VEX_DECODING();
     42        if (pVCpu->iem.s.uVexLength)
     43        {
     44            IEM_MC_BEGIN(4, 3);
     45            IEM_MC_LOCAL(RTUINT256U,            uDst);
     46            IEM_MC_LOCAL(RTUINT256U,            uSrc1);
     47            IEM_MC_LOCAL(RTUINT256U,            uSrc2);
     48            IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
     49            IEM_MC_ARG_LOCAL_REF(PRTUINT256U,   puDst,  uDst,  1);
     50            IEM_MC_ARG_LOCAL_REF(PCRTUINT256U,  puSrc1, uSrc1, 2);
     51            IEM_MC_ARG_LOCAL_REF(PCRTUINT256U,  puSrc2, uSrc2, 3);
     52            IEM_MC_MAYBE_RAISE_AVX2_RELATED_XCPT();
     53            IEM_MC_PREPARE_AVX_USAGE();
     54            IEM_MC_FETCH_YREG_U256(uSrc1,   IEM_GET_EFFECTIVE_VVVV(pVCpu));
     55            IEM_MC_FETCH_YREG_U256(uSrc2,   IEM_GET_MODRM_RM(pVCpu, bRm));
     56            IEM_MC_CALL_AVX_AIMPL_3(pImpl->pfnU256, puDst, puSrc1, puSrc2);
     57            IEM_MC_STORE_YREG_U256_ZX_VLMAX(IEM_GET_MODRM_REG(pVCpu, bRm), uDst);
     58            IEM_MC_ADVANCE_RIP();
     59            IEM_MC_END();
     60        }
     61        else
     62        {
     63            IEM_MC_BEGIN(4, 0);
     64            IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
     65            IEM_MC_ARG(PRTUINT128U,          puDst,  1);
     66            IEM_MC_ARG(PCRTUINT128U,         puSrc1, 2);
     67            IEM_MC_ARG(PCRTUINT128U,         puSrc2, 3);
     68            IEM_MC_MAYBE_RAISE_AVX2_RELATED_XCPT();
     69            IEM_MC_PREPARE_AVX_USAGE();
     70            IEM_MC_REF_XREG_U128(puDst,        IEM_GET_MODRM_REG(pVCpu, bRm));
     71            IEM_MC_REF_XREG_U128_CONST(puSrc1, IEM_GET_EFFECTIVE_VVVV(pVCpu));
     72            IEM_MC_REF_XREG_U128_CONST(puSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
     73            IEM_MC_CALL_AVX_AIMPL_3(pImpl->pfnU128, puDst, puSrc1, puSrc2);
     74            IEM_MC_CLEAR_YREG_128_UP(          IEM_GET_MODRM_REG(pVCpu, bRm));
     75            IEM_MC_ADVANCE_RIP();
     76            IEM_MC_END();
     77        }
     78    }
     79    else
     80    {
     81        /*
     82         * Register, memory.
     83         */
     84        if (pVCpu->iem.s.uVexLength)
     85        {
     86            IEM_MC_BEGIN(4, 4);
     87            IEM_MC_LOCAL(RTUINT256U,            uDst);
     88            IEM_MC_LOCAL(RTUINT256U,            uSrc1);
     89            IEM_MC_LOCAL(RTUINT256U,            uSrc2);
     90            IEM_MC_LOCAL(RTGCPTR,               GCPtrEffSrc);
     91            IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
     92            IEM_MC_ARG_LOCAL_REF(PRTUINT256U,   puDst,  uDst,  1);
     93            IEM_MC_ARG_LOCAL_REF(PCRTUINT256U,  puSrc1, uSrc1, 2);
     94            IEM_MC_ARG_LOCAL_REF(PCRTUINT256U,  puSrc2, uSrc2, 3);
     95
     96            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     97            IEMOP_HLP_DONE_VEX_DECODING();
     98            IEM_MC_MAYBE_RAISE_AVX2_RELATED_XCPT();
     99            IEM_MC_PREPARE_AVX_USAGE();
     100
     101            IEM_MC_FETCH_MEM_U256_NO_AC(uSrc2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     102            IEM_MC_FETCH_YREG_U256(uSrc1,      IEM_GET_EFFECTIVE_VVVV(pVCpu));
     103            IEM_MC_CALL_AVX_AIMPL_3(pImpl->pfnU256, puDst, puSrc1, puSrc2);
     104            IEM_MC_STORE_YREG_U256_ZX_VLMAX(   IEM_GET_MODRM_REG(pVCpu, bRm), uDst);
     105
     106            IEM_MC_ADVANCE_RIP();
     107            IEM_MC_END();
     108        }
     109        else
     110        {
     111            IEM_MC_BEGIN(4, 2);
     112            IEM_MC_LOCAL(RTUINT128U,                uSrc2);
     113            IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
     114            IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
     115            IEM_MC_ARG(PRTUINT128U,                 puDst,         1);
     116            IEM_MC_ARG(PCRTUINT128U,                puSrc1,        2);
     117            IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      puSrc2, uSrc2, 3);
     118
     119            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     120            IEMOP_HLP_DONE_VEX_DECODING();
     121            IEM_MC_MAYBE_RAISE_AVX2_RELATED_XCPT();
     122            IEM_MC_PREPARE_AVX_USAGE();
     123
     124            IEM_MC_FETCH_MEM_U128_NO_AC(uSrc2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     125            IEM_MC_REF_XREG_U128(puDst,         IEM_GET_MODRM_REG(pVCpu, bRm));
     126            IEM_MC_REF_XREG_U128_CONST(puSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     127            IEM_MC_CALL_AVX_AIMPL_3(pImpl->pfnU128, puDst, puSrc1, puSrc2);
     128            IEM_MC_CLEAR_YREG_128_UP(           IEM_GET_MODRM_REG(pVCpu, bRm));
     129
     130            IEM_MC_ADVANCE_RIP();
     131            IEM_MC_END();
     132        }
     133    }
     134    return VINF_SUCCESS;
     135}
     136
    25137
    26138
    … …  
    17071819/*  Opcode VEX.F2.0F 0x56 - invalid */
    17081820
     1821
    17091822/** Opcode VEX.0F 0x57 - vxorps Vps, Hps, Wps */
    1710 FNIEMOP_STUB(iemOp_vxorps_Vps_Hps_Wps);
     1823FNIEMOP_DEF(iemOp_vxorps_Vps_Hps_Wps)
     1824{
     1825    IEMOP_MNEMONIC3(VEX_RVM, VXORPS, vxorps, Vps, Hps, Wps, DISOPTYPE_HARMLESS, 0);
     1826    return FNIEMOP_CALL_1(iemOpCommonAvx2_Vx_Hx_Wx,
     1827                          IEM_SELECT_HOST_OR_FALLBACK(fAvx2, &g_iemAImpl_vpxor, &g_iemAImpl_vpxor_fallback));
     1828}
     1829
     1830
    17111831/** Opcode VEX.66.0F 0x57 - vxorpd Vpd, Hpd, Wpd */
    1712 FNIEMOP_STUB(iemOp_vxorpd_Vpd_Hpd_Wpd);
     1832FNIEMOP_DEF(iemOp_vxorpd_Vpd_Hpd_Wpd)
     1833{
     1834    IEMOP_MNEMONIC3(VEX_RVM, VXORPD, vxorpd, Vpd, Hpd, Wpd, DISOPTYPE_HARMLESS, 0);
     1835    return FNIEMOP_CALL_1(iemOpCommonAvx2_Vx_Hx_Wx,
     1836                          IEM_SELECT_HOST_OR_FALLBACK(fAvx2, &g_iemAImpl_vpxor, &g_iemAImpl_vpxor_fallback));
     1837}
     1838
     1839
    17131840/*  Opcode VEX.F3.0F 0x57 - invalid */
    17141841/*  Opcode VEX.F2.0F 0x57 - invalid */
    … …  
    25962723
    25972724
    2598 ///**
    2599 // * Common worker for SSE2 instructions on the forms:
    2600 // *      pxxx    xmm1, xmm2/mem128
    2601 // *
    2602 // * Proper alignment of the 128-bit operand is enforced.
    2603 // * Exceptions type 4. SSE2 cpuid checks.
    2604 // */
    2605 //FNIEMOP_DEF_1(iemOpCommonSse2_FullFull_To_Full, PCIEMOPMEDIAF2, pImpl)
    2606 //{
    2607 //    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    2608 //    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    2609 //    {
    2610 //        /*
    2611 //         * Register, register.
    2612 //         */
    2613 //        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    2614 //        IEM_MC_BEGIN(2, 0);
    2615 //        IEM_MC_ARG(PRTUINT128U,          pDst, 0);
    2616 //        IEM_MC_ARG(PCRTUINT128U,         pSrc, 1);
    2617 //        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    2618 //        IEM_MC_PREPARE_SSE_USAGE();
    2619 //        IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    2620 //        IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    2621 //        IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    2622 //        IEM_MC_ADVANCE_RIP();
    2623 //        IEM_MC_END();
    2624 //    }
    2625 //    else
    2626 //    {
    2627 //        /*
    2628 //         * Register, memory.
    2629 //         */
    2630 //        IEM_MC_BEGIN(2, 2);
    2631 //        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
    2632 //        IEM_MC_LOCAL(RTUINT128U,                uSrc);
    2633 //        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
    2634 //        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    2635 //
    2636 //        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    2637 //        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    2638 //        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    2639 //        IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    2640 //
    2641 //        IEM_MC_PREPARE_SSE_USAGE();
    2642 //        IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    2643 //        IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    2644 //
    2645 //        IEM_MC_ADVANCE_RIP();
    2646 //        IEM_MC_END();
    2647 //    }
    2648 //    return VINF_SUCCESS;
    2649 //}
    2650 
    2651 
    26522725/*  Opcode VEX.0F 0x74 - invalid */
    26532726
    … …  
    36673740FNIEMOP_DEF(iemOp_vpxor_Vx_Hx_Wx)
    36683741{
    3669     IEMOP_MNEMONIC(vpxor, "vpxor");
    3670     return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pxor);
     3742    IEMOP_MNEMONIC3(VEX_RVM, VPXOR, vpxor, Vx, Hx, Wx, DISOPTYPE_HARMLESS, 0);
     3743    return FNIEMOP_CALL_1(iemOpCommonAvx2_Vx_Hx_Wx,
     3744                          IEM_SELECT_HOST_OR_FALLBACK(fAvx2, &g_iemAImpl_vpxor, &g_iemAImpl_vpxor_fallback));
    36713745}
    36723746

  • trunk/src/VBox/VMM/include/IEMInternal.h

    r95360 r95403  
    152152 * @sa IEMTARGETCPU_EFL_BEHAVIOR_SELECT_EX
    153153 */
    154 #if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
     154#if (defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)) && !defined(IEM_WITHOUT_ASSEMBLY)
    155155# define IEM_SELECT_HOST_OR_FALLBACK(a_fCpumFeatureMember, a_pfnNative, a_pfnFallback) \
    156156    (g_CpumHostFeatures.s.a_fCpumFeatureMember ? a_pfnNative : a_pfnFallback)
    … …  
    17361736/** @name Media (SSE/MMX/AVX) operations: full1 + full2 -> full1.
    17371737 * @{ */
    1738 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF2U64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src));
     1738typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF2U64,(PCX86FXSTATE pFpuState, uint64_t *puDst, uint64_t const *puSrc));
    17391739typedef FNIEMAIMPLMEDIAF2U64   *PFNIEMAIMPLMEDIAF2U64;
    1740 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF2U128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src));
     1740typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF2U128,(PCX86FXSTATE pFpuState, PRTUINT128U puDst, PCRTUINT128U puSrc));
    17411741typedef FNIEMAIMPLMEDIAF2U128  *PFNIEMAIMPLMEDIAF2U128;
     1742typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF3U128,(PX86XSAVEAREA pExtState, PRTUINT128U puDst, PCRTUINT128U puSrc1, PCRTUINT128U puSrc2));
     1743typedef FNIEMAIMPLMEDIAF3U128  *PFNIEMAIMPLMEDIAF3U128;
     1744typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF3U256,(PX86XSAVEAREA pExtState, PRTUINT256U puDst, PCRTUINT256U puSrc1, PCRTUINT256U puSrc2));
     1745typedef FNIEMAIMPLMEDIAF3U256  *PFNIEMAIMPLMEDIAF3U256;
    17421746FNIEMAIMPLMEDIAF2U64  iemAImpl_pxor_u64,  iemAImpl_pcmpeqb_u64,  iemAImpl_pcmpeqw_u64,  iemAImpl_pcmpeqd_u64;
    17431747FNIEMAIMPLMEDIAF2U128 iemAImpl_pxor_u128, iemAImpl_pcmpeqb_u128, iemAImpl_pcmpeqw_u128, iemAImpl_pcmpeqd_u128;
     1748FNIEMAIMPLMEDIAF3U128 iemAImpl_vpxor_u128, iemAImpl_vpxor_u128_fallback;
     1749FNIEMAIMPLMEDIAF3U256 iemAImpl_vpxor_u256, iemAImpl_vpxor_u256_fallback;
    17441750/** @} */
    17451751
    … …  
    19051911/** Pointer to a media operation function table for hihalf+hihalf -> full. */
    19061912typedef IEMOPMEDIAF1H1 const *PCIEMOPMEDIAF1H1;
     1913
     1914
     1915/**
     1916 * Function table for media instruction taking two full sized media source
     1917 * registers and one full sized destination register (AVX).
     1918 */
     1919typedef struct IEMOPMEDIAF3
     1920{
     1921    PFNIEMAIMPLMEDIAF3U128 pfnU128;
     1922    PFNIEMAIMPLMEDIAF3U256 pfnU256;
     1923} IEMOPMEDIAF3;
     1924/** Pointer to a media operation function table for 3 full sized ops (AVX). */
     1925typedef IEMOPMEDIAF3 const *PCIEMOPMEDIAF3;
    19071926
    19081927

  • trunk/src/VBox/VMM/include/IEMMc.h

    r94768 r95403  
    129129        if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_TS) \
    130130            return iemRaiseDeviceNotAvailable(pVCpu); \
     131        if (pVCpu->cpum.GstCtx.XState.x87.FSW & X86_FSW_ES) \
     132            return iemRaiseMathFault(pVCpu); \
    131133    } while (0)
    132134#define IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT_CHECK_SSE_OR_MMXEXT() \
    … …  
    643645# define IEM_MC_FETCH_MEM_U128(a_u128Dst, a_iSeg, a_GCPtrMem) \
    644646    IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU128(pVCpu, &(a_u128Dst), (a_iSeg), (a_GCPtrMem)))
     647# define IEM_MC_FETCH_MEM_U128_NO_AC(a_u128Dst, a_iSeg, a_GCPtrMem) \
     648    IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU128(pVCpu, &(a_u128Dst), (a_iSeg), (a_GCPtrMem)))
    645649# define IEM_MC_FETCH_MEM_U128_ALIGN_SSE(a_u128Dst, a_iSeg, a_GCPtrMem) \
    646650    IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU128AlignedSse(pVCpu, &(a_u128Dst), (a_iSeg), (a_GCPtrMem)))
    … …  
    648652# define IEM_MC_FETCH_MEM_U128(a_u128Dst, a_iSeg, a_GCPtrMem) \
    649653    iemMemFetchDataU128Jmp(pVCpu, &(a_u128Dst), (a_iSeg), (a_GCPtrMem))
     654# define IEM_MC_FETCH_MEM_U128_NO_AC(a_u128Dst, a_iSeg, a_GCPtrMem) \
     655    iemMemFetchDataU128Jmp(pVCpu, &(a_u128Dst), (a_iSeg), (a_GCPtrMem))
    650656# define IEM_MC_FETCH_MEM_U128_ALIGN_SSE(a_u128Dst, a_iSeg, a_GCPtrMem) \
    651657    iemMemFetchDataU128AlignedSseJmp(pVCpu, &(a_u128Dst), (a_iSeg), (a_GCPtrMem))
    … …  
    654660#ifndef IEM_WITH_SETJMP
    655661# define IEM_MC_FETCH_MEM_U256(a_u256Dst, a_iSeg, a_GCPtrMem) \
     662    IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU256(pVCpu, &(a_u256Dst), (a_iSeg), (a_GCPtrMem)))
     663# define IEM_MC_FETCH_MEM_U256_NO_AC(a_u256Dst, a_iSeg, a_GCPtrMem) \
    656664    IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU256(pVCpu, &(a_u256Dst), (a_iSeg), (a_GCPtrMem)))
    657665# define IEM_MC_FETCH_MEM_U256_ALIGN_AVX(a_u256Dst, a_iSeg, a_GCPtrMem) \
    … …  
    659667#else
    660668# define IEM_MC_FETCH_MEM_U256(a_u256Dst, a_iSeg, a_GCPtrMem) \
     669    iemMemFetchDataU256Jmp(pVCpu, &(a_u256Dst), (a_iSeg), (a_GCPtrMem))
     670# define IEM_MC_FETCH_MEM_U256_NO_AC(a_u256Dst, a_iSeg, a_GCPtrMem) \
    661671    iemMemFetchDataU256Jmp(pVCpu, &(a_u256Dst), (a_iSeg), (a_GCPtrMem))
    662672# define IEM_MC_FETCH_MEM_U256_ALIGN_AVX(a_u256Dst, a_iSeg, a_GCPtrMem) \

  • trunk/src/VBox/VMM/testcase/tstIEMCheckMc.cpp

    r95360 r95403  
    596596#define IEM_MC_FETCH_MEM_D80(a_d80Dst, a_iSeg, a_GCPtrMem)              do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTPBCD80U,  a_d80Dst); (void)fMcBegin; } while (0)
    597597#define IEM_MC_FETCH_MEM_U128(a_u128Dst, a_iSeg, a_GCPtrMem)            do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT128U, a_u128Dst); (void)fMcBegin; } while (0)
     598#define IEM_MC_FETCH_MEM_U128_NO_AC(a_u128Dst, a_iSeg, a_GCPtrMem)      do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT128U, a_u128Dst); (void)fMcBegin; } while (0)
    598599#define IEM_MC_FETCH_MEM_U128_ALIGN_SSE(a_u128Dst, a_iSeg, a_GCPtrMem)  do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT128U, a_u128Dst); (void)fMcBegin; } while (0)
    599600#define IEM_MC_FETCH_MEM_U256(a_u256Dst, a_iSeg, a_GCPtrMem)            do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT256U, a_u256Dst); (void)fMcBegin; } while (0)
     601#define IEM_MC_FETCH_MEM_U256_NO_AC(a_u256Dst, a_iSeg, a_GCPtrMem)      do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT256U, a_u256Dst); (void)fMcBegin; } while (0)
    600602#define IEM_MC_FETCH_MEM_U256_ALIGN_AVX(a_u256Dst, a_iSeg, a_GCPtrMem)  do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT256U, a_u256Dst); (void)fMcBegin; } while (0)
    601603
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette