VirtualBox

Changeset 97782 in vbox


Ignore:
Timestamp:
Dec 12, 2022 5:02:29 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
154853
Message:

IEM: Implemented SSE instructions RSQRTPS, RSQRTSS, ROUNDPS, ROUNDPD, ROUNDSS, ROUNDSD, INSERTPS. FPU bits in assembler only, C implementation todo.

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

Legend:

Unmodified
Added
Removed

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

    r97257 r97782  
    46644664; to.
    46654665IEMIMPL_FP_F2 sqrtps,    2
     4666IEMIMPL_FP_F2 rsqrtps,   2
    46664667IEMIMPL_FP_F2 sqrtpd,    2
    46674668IEMIMPL_FP_F2 cvtdq2ps,  2
    … …  
    47234724IEMIMPL_FP_F2_R32 cvtss2sd
    47244725IEMIMPL_FP_F2_R32 sqrtss
     4726IEMIMPL_FP_F2_R32 rsqrtss
    47254727
    47264728
    … …  
    60696071
    60706072;;
     6073; SSE instructions with 8-bit immediates of the form
     6074;    xxx xmm1, xmm2, imm8.
     6075; where the instruction encoding takes up 6 bytes and we need to load and save the MXCSR
     6076; register.
     6077;
     6078; @param    1       The instruction name.
     6079;
     6080; @param    A0      Pointer to the MXCSR value (input/output).
     6081; @param    A1      Pointer to the first media register size operand (output).
     6082; @param    A2      Pointer to the two media register sized inputs - IEMMEDIAF2XMMSRC (input).
     6083; @param    A3      The 8-bit immediate (input).
     6084;
     6085%macro IEMIMPL_MEDIA_SSE_INSN_IMM8_MXCSR_6 1
     6086BEGINPROC_FASTCALL iemAImpl_ %+ %1 %+ _u128, 16
     6087        PROLOGUE_4_ARGS
     6088        IEMIMPL_SSE_PROLOGUE
     6089        SSE_LD_FXSTATE_MXCSR_ONLY A0
     6090
     6091        movdqu  xmm0, [A2 + IEMMEDIAF2XMMSRC.uSrc1]
     6092        movdqu  xmm1, [A2 + IEMMEDIAF2XMMSRC.uSrc2]
     6093        lea     T1, [.imm0 xWrtRIP]
     6094        lea     T0, [A3*2 + A3]        ; sizeof(insn+ret) == 7: 2 * (A3 * 3) + A3
     6095        lea     T0, [T0*2]
     6096        lea     T0, [T0 + A3]
     6097        lea     T1, [T1 + T0]
     6098        call    T1
     6099        movdqu  [A1], xmm0
     6100
     6101        SSE_ST_FXSTATE_MXCSR_ONLY_NO_FXSTATE A0
     6102        IEMIMPL_SSE_EPILOGUE
     6103        EPILOGUE_4_ARGS
     6104 %assign bImm 0
     6105 %rep 256
     6106.imm %+ bImm:
     6107       %1       xmm0, xmm1, bImm
     6108       ret
     6109  %assign bImm bImm + 1
     6110 %endrep
     6111.immEnd:                                ; 256*(6+1) == 0x700
     6112dw 0xf8ff  + (.immEnd - .imm0)          ; will cause warning if entries are too big.
     6113dw 0x106ff - (.immEnd - .imm0)          ; will cause warning if entries are too small.
     6114ENDPROC iemAImpl_ %+ %1 %+ _u128
     6115%endmacro
     6116
     6117IEMIMPL_MEDIA_SSE_INSN_IMM8_MXCSR_6 roundps
     6118IEMIMPL_MEDIA_SSE_INSN_IMM8_MXCSR_6 roundpd
     6119IEMIMPL_MEDIA_SSE_INSN_IMM8_MXCSR_6 roundss
     6120IEMIMPL_MEDIA_SSE_INSN_IMM8_MXCSR_6 roundsd
     6121
     6122
     6123;;
    60716124; SSE instructions of the form
    60726125;    xxx mm, xmm.

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

    r97534 r97782  
    1709017090
    1709117091/**
     17092 * ROUNDPS / ROUNDPD / ROUNDSS / ROUNDSD
     17093 */
     17094
     17095static RTFLOAT32U iemAImpl_round_worker_r32(uint32_t *pfMxcsr, PCRTFLOAT32U pr32Src, uint8_t bImm)
     17096{
     17097    RTFLOAT32U  r32Dst;
     17098
     17099    AssertReleaseFailed();
     17100    RT_NOREF(bImm);
     17101    RT_NOREF(pfMxcsr);
     17102    r32Dst = *pr32Src;
     17103    return r32Dst;
     17104}
     17105
     17106
     17107static RTFLOAT64U iemAImpl_round_worker_r64(uint32_t *pfMxcsr, PCRTFLOAT64U pr64Src, uint8_t bImm)
     17108{
     17109    RTFLOAT64U  r64Dst;
     17110
     17111    AssertReleaseFailed();
     17112    RT_NOREF(bImm);
     17113    RT_NOREF(pfMxcsr);
     17114    r64Dst = *pr64Src;
     17115    return r64Dst;
     17116}
     17117
     17118
     17119IEM_DECL_IMPL_DEF(void, iemAImpl_roundps_u128_fallback,(uint32_t *pfMxcsr, PX86XMMREG puDst, PCIEMMEDIAF2XMMSRC pSrc, uint8_t bImm))
     17120{
     17121    for (uint8_t i = 0; i < RT_ELEMENTS(puDst->ar32); i++)
     17122    {
     17123        puDst->ar32[i] = iemAImpl_round_worker_r32(pfMxcsr, &pSrc->uSrc2.ar32[i], bImm & 0x7);
     17124    }
     17125}
     17126
     17127
     17128IEM_DECL_IMPL_DEF(void, iemAImpl_roundpd_u128_fallback,(uint32_t *pfMxcsr, PX86XMMREG puDst, PCIEMMEDIAF2XMMSRC pSrc, uint8_t bImm))
     17129{
     17130    for (uint8_t i = 0; i < RT_ELEMENTS(puDst->ar64); i++)
     17131    {
     17132        puDst->ar64[i] = iemAImpl_round_worker_r64(pfMxcsr, &pSrc->uSrc2.ar64[i], bImm & 0x7);
     17133    }
     17134}
     17135
     17136
     17137IEM_DECL_IMPL_DEF(void, iemAImpl_roundss_u128_fallback,(uint32_t *pfMxcsr, PX86XMMREG puDst, PCIEMMEDIAF2XMMSRC pSrc, uint8_t bImm))
     17138{
     17139    puDst->ar32[0] = iemAImpl_round_worker_r32(pfMxcsr, &pSrc->uSrc2.ar32[0], bImm & 0x7);
     17140    puDst->au32[1] = pSrc->uSrc1.au32[1];
     17141    puDst->au64[1] = pSrc->uSrc1.au64[1];
     17142}
     17143
     17144
     17145IEM_DECL_IMPL_DEF(void, iemAImpl_roundsd_u128_fallback,(uint32_t *pfMxcsr, PX86XMMREG puDst, PCIEMMEDIAF2XMMSRC pSrc, uint8_t bImm))
     17146{
     17147    puDst->ar64[0] = iemAImpl_round_worker_r64(pfMxcsr, &pSrc->uSrc2.ar64[0], bImm & 0x7);
     17148    puDst->au64[1] = pSrc->uSrc1.au64[1];
     17149}
     17150
     17151
     17152/**
    1709217153 * CVTPD2PI
    1709317154 */

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

    r97676 r97782  
    9898 *
    9999 * Proper alignment of the 128-bit operand is enforced.
    100  * Exceptions type 4. SSE 4.1 cpuid checks.
     100 * No SIMD exceptions. SSE 4.1 cpuid checks.
    101101 *
    102102 * @sa  iemOpCommonSsse3_FullFullImm8_To_Full
    … …  
    108108    {
    109109        /*
    110          * Register, register.
     110         * XMM, XMM, imm8
    111111         */
    112112        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
    … …  
    127127    {
    128128        /*
    129          * Register, memory.
     129         * XMM, [mem128], imm8.
    130130         */
    131131        IEM_MC_BEGIN(3, 2);
    … …  
    145145        IEM_MC_REF_XREG_U128(puDst,             IEM_GET_MODRM_REG(pVCpu, bRm));
    146146        IEM_MC_CALL_VOID_AIMPL_3(pfnU128, puDst, puSrc, bImmArg);
     147
     148        IEM_MC_ADVANCE_RIP_AND_FINISH();
     149        IEM_MC_END();
     150    }
     151}
     152
     153
     154/**
     155 * Common worker for SSE 4.1 instructions of the form:
     156 *      xxx     xmm1, xmm2/mem128, imm8
     157 *
     158 * Proper alignment of the 128-bit operand is enforced.
     159 * MXCSR is used as input and output.
     160 * Exceptions type 4. SSE 4.1 cpuid checks.
     161 *
     162 * @sa  iemOpCommonSse41_FullFullImm8_To_Full
     163 */
     164FNIEMOP_DEF_1(iemOpCommonSse41Fp_FullFullImm8_To_Full, FNIEMAIMPLMXCSRF2XMMIMM8, pfnU128)
     165{
     166    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     167    if (IEM_IS_MODRM_REG_MODE(bRm))
     168    {
     169        /*
     170         * XMM, XMM, imm8.
     171         */
     172        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     173        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     174        IEM_MC_BEGIN(4, 2);
     175        IEM_MC_LOCAL(IEMMEDIAF2XMMSRC,              Src);
     176        IEM_MC_LOCAL(X86XMMREG,                     Dst);
     177        IEM_MC_ARG(uint32_t *,                      pfMxcsr,                0);
     178        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,            pDst,           Dst,    1);
     179        IEM_MC_ARG_LOCAL_REF(PCIEMMEDIAF2XMMSRC,    pSrc,           Src,    2);
     180        IEM_MC_ARG_CONST(uint8_t,                   bImmArg, /*=*/ bImm,    3);
     181        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     182        IEM_MC_PREPARE_SSE_USAGE();
     183        IEM_MC_REF_MXCSR(pfMxcsr);
     184        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
     185        IEM_MC_FETCH_XREG_XMM(Src.uSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
     186        IEM_MC_CALL_VOID_AIMPL_4(pfnU128, pfMxcsr, pDst, pSrc, bImmArg);
     187        IEM_MC_MAYBE_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
     188        IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
     189
     190        IEM_MC_ADVANCE_RIP_AND_FINISH();
     191        IEM_MC_END();
     192    }
     193    else
     194    {
     195        /*
     196         * XMM, [mem128], imm8.
     197         */
     198        IEM_MC_BEGIN(4, 3);
     199        IEM_MC_LOCAL(IEMMEDIAF2XMMSRC,              Src);
     200        IEM_MC_LOCAL(X86XMMREG,                     Dst);
     201        IEM_MC_ARG(uint32_t *,                      pfMxcsr,                0);
     202        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,            pDst,           Dst,    1);
     203        IEM_MC_ARG_LOCAL_REF(PCIEMMEDIAF2XMMSRC,    pSrc,           Src,    2);
     204        IEM_MC_LOCAL(RTGCPTR,                       GCPtrEffSrc);
     205
     206        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     207        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     208        IEM_MC_ARG_CONST(uint8_t,                   bImmArg, /*=*/ bImm,    3);
     209        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     210        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     211        IEM_MC_FETCH_MEM_XMM_ALIGN_SSE(Src.uSrc2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     212
     213        IEM_MC_PREPARE_SSE_USAGE();
     214        IEM_MC_REF_MXCSR(pfMxcsr);
     215        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
     216        IEM_MC_CALL_VOID_AIMPL_4(pfnU128, pfMxcsr, pDst, pSrc, bImmArg);
     217        IEM_MC_MAYBE_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
     218        IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    147219
    148220        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    221293/*  Opcode 0x66 0x0f 0x07 - invalid */
    222294/** Opcode 0x66 0x0f 0x08. */
    223 FNIEMOP_STUB(iemOp_roundps_Vx_Wx_Ib);
     295FNIEMOP_DEF(iemOp_roundps_Vx_Wx_Ib)
     296{
     297    IEMOP_MNEMONIC3(RMI, ROUNDPS, roundps, Vx, Wx, Ib, DISOPTYPE_HARMLESS | DISOPTYPE_SSE, 0);
     298    return FNIEMOP_CALL_1(iemOpCommonSse41Fp_FullFullImm8_To_Full,
     299                          IEM_SELECT_HOST_OR_FALLBACK(fSse41, iemAImpl_roundps_u128, iemAImpl_roundps_u128_fallback));
     300}
     301
     302
    224303/** Opcode 0x66 0x0f 0x09. */
    225 FNIEMOP_STUB(iemOp_roundpd_Vx_Wx_Ib);
     304FNIEMOP_DEF(iemOp_roundpd_Vx_Wx_Ib)
     305{
     306    IEMOP_MNEMONIC3(RMI, ROUNDPD, roundpd, Vx, Wx, Ib, DISOPTYPE_HARMLESS | DISOPTYPE_SSE, 0);
     307    return FNIEMOP_CALL_1(iemOpCommonSse41Fp_FullFullImm8_To_Full,
     308                          IEM_SELECT_HOST_OR_FALLBACK(fSse41, iemAImpl_roundpd_u128, iemAImpl_roundpd_u128_fallback));
     309}
     310
     311
    226312/** Opcode 0x66 0x0f 0x0a. */
    227 FNIEMOP_STUB(iemOp_roundss_Vss_Wss_Ib);
     313FNIEMOP_DEF(iemOp_roundss_Vss_Wss_Ib)
     314{
     315    /* The instruction form is very similar to CMPSS. */
     316    IEMOP_MNEMONIC3(RMI, ROUNDSS, roundss, Vss, Wss, Ib, DISOPTYPE_HARMLESS | DISOPTYPE_SSE, 0);
     317
     318    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     319    if (IEM_IS_MODRM_REG_MODE(bRm))
     320    {
     321        /*
     322         * XMM32, XMM32.
     323         */
     324        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     325        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     326        IEM_MC_BEGIN(4, 2);
     327        IEM_MC_LOCAL(IEMMEDIAF2XMMSRC,              Src);
     328        IEM_MC_LOCAL(X86XMMREG,                     Dst);
     329        IEM_MC_ARG(uint32_t *,                      pfMxcsr,                0);
     330        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,            pDst,           Dst,    1);
     331        IEM_MC_ARG_LOCAL_REF(PCIEMMEDIAF2XMMSRC,    pSrc,           Src,    2);
     332        IEM_MC_ARG_CONST(uint8_t,                   bImmArg, /*=*/ bImm,    3);
     333        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     334        IEM_MC_PREPARE_SSE_USAGE();
     335        IEM_MC_REF_MXCSR(pfMxcsr);
     336        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
     337        IEM_MC_FETCH_XREG_XMM(Src.uSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
     338        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_roundss_u128, pfMxcsr, pDst, pSrc, bImmArg);
     339        IEM_MC_MAYBE_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
     340        IEM_MC_STORE_XREG_XMM_U32(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iDword*/, Dst);
     341
     342        IEM_MC_ADVANCE_RIP_AND_FINISH();
     343        IEM_MC_END();
     344    }
     345    else
     346    {
     347        /*
     348         * XMM32, [mem32].
     349         */
     350        IEM_MC_BEGIN(4, 3);
     351        IEM_MC_LOCAL(IEMMEDIAF2XMMSRC,              Src);
     352        IEM_MC_LOCAL(X86XMMREG,                     Dst);
     353        IEM_MC_ARG(uint32_t *,                      pfMxcsr,                0);
     354        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,            pDst,           Dst,    1);
     355        IEM_MC_ARG_LOCAL_REF(PCIEMMEDIAF2XMMSRC,    pSrc,           Src,    2);
     356        IEM_MC_LOCAL(RTGCPTR,                       GCPtrEffSrc);
     357
     358        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     359        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     360        IEM_MC_ARG_CONST(uint8_t,                   bImmArg, /*=*/ bImm,    3);
     361        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     362        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     363        IEM_MC_FETCH_MEM_XMM_U32(Src.uSrc2, 0 /*a_iDword */, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     364
     365        IEM_MC_PREPARE_SSE_USAGE();
     366        IEM_MC_REF_MXCSR(pfMxcsr);
     367        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
     368        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_roundss_u128, pfMxcsr, pDst, pSrc, bImmArg);
     369        IEM_MC_MAYBE_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
     370        IEM_MC_STORE_XREG_XMM_U32(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iDword*/, Dst);
     371
     372        IEM_MC_ADVANCE_RIP_AND_FINISH();
     373        IEM_MC_END();
     374    }
     375}
     376
    228377/** Opcode 0x66 0x0f 0x0b. */
    229 FNIEMOP_STUB(iemOp_roundsd_Vsd_Wsd_Ib);
     378FNIEMOP_DEF(iemOp_roundsd_Vsd_Wsd_Ib)
     379{
     380    /* The instruction form is very similar to CMPSD. */
     381    IEMOP_MNEMONIC3(RMI, ROUNDSD, roundsd, Vsd, Wsd, Ib, DISOPTYPE_HARMLESS | DISOPTYPE_SSE, 0);
     382
     383    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     384    if (IEM_IS_MODRM_REG_MODE(bRm))
     385    {
     386        /*
     387         * XMM64, XMM64, imm8.
     388         */
     389        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     390        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     391        IEM_MC_BEGIN(4, 2);
     392        IEM_MC_LOCAL(IEMMEDIAF2XMMSRC,              Src);
     393        IEM_MC_LOCAL(X86XMMREG,                     Dst);
     394        IEM_MC_ARG(uint32_t *,                      pfMxcsr,                0);
     395        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,            pDst,           Dst,    1);
     396        IEM_MC_ARG_LOCAL_REF(PCIEMMEDIAF2XMMSRC,    pSrc,           Src,    2);
     397        IEM_MC_ARG_CONST(uint8_t,                   bImmArg, /*=*/ bImm,    3);
     398        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     399        IEM_MC_PREPARE_SSE_USAGE();
     400        IEM_MC_REF_MXCSR(pfMxcsr);
     401        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
     402        IEM_MC_FETCH_XREG_XMM(Src.uSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
     403        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_roundsd_u128, pfMxcsr, pDst, pSrc, bImmArg);
     404        IEM_MC_MAYBE_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
     405        IEM_MC_STORE_XREG_XMM_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iQword*/, Dst);
     406
     407        IEM_MC_ADVANCE_RIP_AND_FINISH();
     408        IEM_MC_END();
     409    }
     410    else
     411    {
     412        /*
     413         * XMM64, [mem64], imm8.
     414         */
     415        IEM_MC_BEGIN(4, 3);
     416        IEM_MC_LOCAL(IEMMEDIAF2XMMSRC,              Src);
     417        IEM_MC_LOCAL(X86XMMREG,                     Dst);
     418        IEM_MC_ARG(uint32_t *,                      pfMxcsr,                0);
     419        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,            pDst,           Dst,    1);
     420        IEM_MC_ARG_LOCAL_REF(PCIEMMEDIAF2XMMSRC,    pSrc,           Src,    2);
     421        IEM_MC_LOCAL(RTGCPTR,                       GCPtrEffSrc);
     422
     423        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     424        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     425        IEM_MC_ARG_CONST(uint8_t,                   bImmArg, /*=*/ bImm,    3);
     426        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     427        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     428        IEM_MC_FETCH_MEM_XMM_U64(Src.uSrc2, 0 /*a_iQword */, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     429
     430        IEM_MC_PREPARE_SSE_USAGE();
     431        IEM_MC_REF_MXCSR(pfMxcsr);
     432        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
     433        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_roundsd_u128, pfMxcsr, pDst, pSrc, bImmArg);
     434        IEM_MC_MAYBE_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
     435        IEM_MC_STORE_XREG_XMM_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iQword*/, Dst);
     436
     437        IEM_MC_ADVANCE_RIP_AND_FINISH();
     438        IEM_MC_END();
     439    }
     440}
    230441
    231442
    … …  
    626837
    627838/** Opcode 0x66 0x0f 0x21, */
    628 FNIEMOP_STUB(iemOp_insertps_Vdq_UdqMd_Ib);
    629 
     839FNIEMOP_DEF(iemOp_insertps_Vdq_UdqMd_Ib)
     840{
     841    IEMOP_MNEMONIC3(RMI, INSERTPS, insertps, Vdq, Wdq, Ib, DISOPTYPE_HARMLESS | DISOPTYPE_SSE, 0);  /// @todo
     842    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     843    if (IEM_IS_MODRM_REG_MODE(bRm))
     844    {
     845        /*
     846         * XMM, XMM.
     847         */
     848        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     849        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     850        IEM_MC_BEGIN(0, 3);
     851        IEM_MC_LOCAL(uint32_t,  uSrc);
     852        IEM_MC_LOCAL(uint8_t,   uSrcSel);
     853        IEM_MC_LOCAL(uint8_t,   uDstSel);
     854        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     855        IEM_MC_PREPARE_SSE_USAGE();
     856        IEM_MC_ASSIGN(uSrcSel, bImm);
     857        IEM_MC_SHR_LOCAL_U8(uSrcSel, 6);
     858        IEM_MC_AND_LOCAL_U8(uSrcSel, 3);
     859        IEM_MC_FETCH_XREG_U32(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm), uSrcSel);
     860        IEM_MC_ASSIGN(uDstSel, bImm);
     861        IEM_MC_SHR_LOCAL_U8(uDstSel, 4);
     862        IEM_MC_AND_LOCAL_U8(uDstSel, 3);
     863        IEM_MC_CLEAR_XREG_U32_MASK(IEM_GET_MODRM_REG(pVCpu, bRm), bImm);
     864        IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), uDstSel, uSrc);
     865        IEM_MC_ADVANCE_RIP_AND_FINISH();
     866        IEM_MC_END();
     867    }
     868    else
     869    {
     870        /*
     871         * XMM, [mem32].
     872         */
     873        IEM_MC_BEGIN(0, 3);
     874        IEM_MC_LOCAL(uint32_t,  uSrc);
     875        IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
     876        IEM_MC_LOCAL(uint8_t,   uDstSel);
     877
     878        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     879        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     880        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     881        IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     882        IEM_MC_PREPARE_SSE_USAGE();
     883
     884        IEM_MC_FETCH_MEM_U32(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     885        IEM_MC_ASSIGN(uDstSel, bImm);
     886        IEM_MC_SHR_LOCAL_U8(uDstSel, 4);
     887        IEM_MC_AND_LOCAL_U8(uDstSel, 3);
     888        IEM_MC_CLEAR_XREG_U32_MASK(IEM_GET_MODRM_REG(pVCpu, bRm), bImm);
     889        IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), uDstSel, uSrc);
     890        IEM_MC_ADVANCE_RIP_AND_FINISH();
     891        IEM_MC_END();
     892    }
     893}
    630894
    631895FNIEMOP_DEF(iemOp_pinsrd_q_Vdq_Ey_Ib)

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

    r97629 r97782  
    55575557
    55585558/** Opcode      0x0f 0x52 - rsqrtps Vps, Wps */
    5559 FNIEMOP_STUB(iemOp_rsqrtps_Vps_Wps);
     5559FNIEMOP_DEF(iemOp_rsqrtps_Vps_Wps)
     5560{
     5561    IEMOP_MNEMONIC2(RM, RSQRTPS, rsqrtps, Vps, Wps, DISOPTYPE_HARMLESS, 0);
     5562    return FNIEMOP_CALL_1(iemOpCommonSseFp_FullFull_To_Full, iemAImpl_rsqrtps_u128);
     5563}
     5564
     5565
    55605566/*  Opcode 0x66 0x0f 0x52 - invalid */
     5567
     5568
    55615569/** Opcode 0xf3 0x0f 0x52 - rsqrtss Vss, Wss */
    5562 FNIEMOP_STUB(iemOp_rsqrtss_Vss_Wss);
     5570FNIEMOP_DEF(iemOp_rsqrtss_Vss_Wss)
     5571{
     5572    IEMOP_MNEMONIC2(RM, RSQRTSS, rsqrtss, Vss, Wss, DISOPTYPE_HARMLESS, 0);
     5573    return FNIEMOP_CALL_1(iemOpCommonSseFp_FullR32_To_Full, iemAImpl_rsqrtss_u128_r32);
     5574}
     5575
     5576
    55635577/*  Opcode 0xf2 0x0f 0x52 - invalid */
    55645578

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

    r97694 r97782  
    24792479FNIEMAIMPLMXCSRF2XMMIMM8 iemAImpl_cmpss_u128;
    24802480FNIEMAIMPLMXCSRF2XMMIMM8 iemAImpl_cmpsd_u128;
     2481FNIEMAIMPLMXCSRF2XMMIMM8 iemAImpl_roundss_u128;
     2482FNIEMAIMPLMXCSRF2XMMIMM8 iemAImpl_roundsd_u128;
     2483
     2484FNIEMAIMPLMXCSRF2XMMIMM8 iemAImpl_roundps_u128, iemAImpl_roundps_u128_fallback;
     2485FNIEMAIMPLMXCSRF2XMMIMM8 iemAImpl_roundpd_u128, iemAImpl_roundpd_u128_fallback;
    24812486
    24822487typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMXCSRU64U128,(uint32_t *pfMxcsr, uint64_t *pu64Dst, PCX86XMMREG pSrc));
    … …  
    28472852FNIEMAIMPLFPSSEF2U128 iemAImpl_hsubpd_u128;
    28482853FNIEMAIMPLFPSSEF2U128 iemAImpl_sqrtps_u128;
     2854FNIEMAIMPLFPSSEF2U128 iemAImpl_rsqrtps_u128;
    28492855FNIEMAIMPLFPSSEF2U128 iemAImpl_sqrtpd_u128;
    28502856FNIEMAIMPLFPSSEF2U128 iemAImpl_addsubps_u128;
    … …  
    28762882FNIEMAIMPLFPSSEF2U128R32 iemAImpl_sqrtss_u128_r32;
    28772883FNIEMAIMPLFPSSEF2U128R64 iemAImpl_sqrtsd_u128_r64;
     2884FNIEMAIMPLFPSSEF2U128R32 iemAImpl_rsqrtss_u128_r32;
    28782885
    28792886FNIEMAIMPLFPAVXF3U128 iemAImpl_vaddps_u128, iemAImpl_vaddps_u128_fallback;

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

    r97607 r97782  
    396396#define IEM_MC_SAR_LOCAL_S64(a_i64Local, a_cShift)      do { (a_i64Local) >>= (a_cShift);  } while (0)
    397397
     398#define IEM_MC_SHR_LOCAL_U8(a_u8Local, a_cShift)        do { (a_u8Local)  >>= (a_cShift);  } while (0)
     399
    398400#define IEM_MC_SHL_LOCAL_S16(a_i16Local, a_cShift)      do { (a_i16Local) <<= (a_cShift);  } while (0)
    399401#define IEM_MC_SHL_LOCAL_S32(a_i32Local, a_cShift)      do { (a_i32Local) <<= (a_cShift);  } while (0)
    … …  
    474476    do { ((uint32_t *)(a_pu64Dst))[2] = 0xffff; } while (0)
    475477
     478#define IEM_MC_CLEAR_XREG_U32_MASK(a_iXReg, a_bMask) \
     479    do { if ((a_bMask) & (1 << 0)) pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au32[0] = 0; \
     480         if ((a_bMask) & (1 << 1)) pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au32[1] = 0; \
     481         if ((a_bMask) & (1 << 2)) pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au32[2] = 0; \
     482         if ((a_bMask) & (1 << 3)) pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au32[3] = 0; \
     483    } while (0)
    476484#define IEM_MC_FETCH_XREG_U128(a_u128Value, a_iXReg) \
    477485    do { (a_u128Value).au64[0] = pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au64[0]; \

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

    r97607 r97782  
    513513#define iemAImpl_sqrtps_u128            NULL
    514514#define iemAImpl_sqrtpd_u128            NULL
     515#define iemAImpl_rsqrtps_u128           NULL
    515516#define iemAImpl_addsubps_u128          NULL
    516517#define iemAImpl_addsubpd_u128          NULL
    … …  
    519520#define iemAImpl_shufpd_u128            NULL
    520521#define iemAImpl_shufps_u128            NULL
     522#define iemAImpl_roundps_u128           NULL
     523#define iemAImpl_roundpd_u128           NULL
    521524
    522525#define iemAImpl_cvtdq2ps_u128          NULL
    … …  
    541544#define iemAImpl_sqrtss_u128_r32        NULL
    542545#define iemAImpl_sqrtsd_u128_r64        NULL
     546#define iemAImpl_roundss_u128_r32       NULL
     547#define iemAImpl_roundsd_u128_r64       NULL
     548#define iemAImpl_rsqrtss_u128_r32       NULL
    543549
    544550#define iemAImpl_cvtss2sd_u128_r32      NULL
    … …  
    740746#define IEM_MC_SAR_LOCAL_S32(a_i32Local, a_cShift)      do { (a_i32Local) >>= (a_cShift); CHK_TYPE(int32_t, a_i32Local);  CHK_CONST(uint8_t,  a_cShift);  (void)fMcBegin; } while (0)
    741747#define IEM_MC_SAR_LOCAL_S64(a_i64Local, a_cShift)      do { (a_i64Local) >>= (a_cShift); CHK_TYPE(int64_t, a_i64Local);  CHK_CONST(uint8_t,  a_cShift);  (void)fMcBegin; } while (0)
     748#define IEM_MC_SHR_LOCAL_U8(a_u8Local, a_cShift)        do { (a_u8Local)  >>= (a_cShift); CHK_TYPE(uint8_t, a_u8Local);   CHK_CONST(uint8_t,  a_cShift);  (void)fMcBegin; } while (0)
    742749#define IEM_MC_SHL_LOCAL_S16(a_i16Local, a_cShift)      do { (a_i16Local) <<= (a_cShift); CHK_TYPE(int16_t, a_i16Local);  CHK_CONST(uint8_t,  a_cShift);  (void)fMcBegin; } while (0)
    743750#define IEM_MC_SHL_LOCAL_S32(a_i32Local, a_cShift)      do { (a_i32Local) <<= (a_cShift); CHK_TYPE(int32_t, a_i32Local);  CHK_CONST(uint8_t,  a_cShift);  (void)fMcBegin; } while (0)
    … …  
    766773#define IEM_MC_MODIFIED_MREG_BY_REF(a_pu64Dst)              do { AssertCompile(sizeof(*a_pu64Dst) <= sizeof(uint64_t)); (void)fFpuWrite; (void)fMcBegin; } while (0)
    767774
     775#define IEM_MC_CLEAR_XREG_U32_MASK(a_iXReg, a_bMask)        do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint8_t, a_bMask); (void)fSseRead;  (void)fMcBegin; } while (0)
    768776#define IEM_MC_FETCH_XREG_U128(a_u128Value, a_iXReg)        do { CHK_XREG_IDX(a_iXReg); (a_u128Value) = g_u128Zero; CHK_TYPE(RTUINT128U, a_u128Value); (void)fSseRead;  (void)fMcBegin; } while (0)
    769777#define IEM_MC_FETCH_XREG_XMM(a_XmmValue, a_iXReg)          do { CHK_XREG_IDX(a_iXReg); (a_XmmValue) = g_XmmZero; CHK_TYPE(X86XMMREG, a_XmmValue); (void)fSseRead;  (void)fMcBegin; } while (0)
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