VirtualBox

Changeset 104174 in vbox


Ignore:
Timestamp:
Apr 5, 2024 10:21:30 AM (10 months ago)
Author:
vboxsync
Message:

VMM/IEM: Get rid of IEM_MC_REF_MXCSR() and convert the users to use IEM_MC_CALL_SSE_AIMPL_XXX which handles the MXCSR, avoids passing the MXCSR as a reference so the recompiler can use shadowed registers, bugref:10641

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

Legend:

Unmodified
Added
Removed

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

    r104157 r104174  
    63296329
    63306330;;
    6331 ; Initialize the SSE MXCSR register using the guest value partially to
    6332 ; account for rounding mode.
    6333 ;
    6334 ; @uses     4 bytes of stack to save the original value, T0.
    6335 ; @param    1       Expression giving the address of the MXCSR register of the guest.
    6336 ;
    6337 %macro SSE_LD_FXSTATE_MXCSR_ONLY 1
    6338         sub     xSP, 4
    6339 
    6340         stmxcsr [xSP]
    6341         mov     T0_32, [%1]
    6342         and     T0_32, X86_MXCSR_FZ | X86_MXCSR_RC_MASK | X86_MXCSR_DAZ
    6343         or      T0_32, X86_MXCSR_XCPT_MASK
    6344         sub     xSP, 4
    6345         mov     [xSP], T0_32
    6346         ldmxcsr [xSP]
    6347         add     xSP, 4
    6348 %endmacro
    6349 
    6350 
    6351 ;;
    6352 ; Restores the SSE MXCSR register with the original value.
    6353 ;
    6354 ; @uses     4 bytes of stack to save the content of MXCSR value, T0, T1.
    6355 ; @param    1       Expression giving the address where to return the MXCSR value - only the MXCSR is stored, no IEMSSERESULT is used.
    6356 ;
    6357 ; @note Restores the stack pointer.
    6358 ;
    6359 %macro SSE_ST_FXSTATE_MXCSR_ONLY_NO_FXSTATE 1
    6360         sub     xSP, 4
    6361         stmxcsr [xSP]
    6362         mov     T0_32, [xSP]
    6363         add     xSP, 4
    6364         ; Merge the status bits into the original MXCSR value.
    6365         mov     T1_32, [%1]
    6366         and     T0_32, X86_MXCSR_XCPT_FLAGS
    6367         or      T0_32, T1_32
    6368         mov     [%1], T0_32
    6369 
    6370         ldmxcsr [xSP]
    6371         add     xSP, 4
    6372 %endmacro
    6373 
    6374 
    6375 ;;
    63766331; Need to move this as well somewhere better?
    63776332;
    … …  
    65426497; @param    1       The instruction name.
    65436498;
    6544 ; @param    A0      Pointer to the MXCSR value (input/output).
     6499; @return   R0_32   The new MXCSR value of the guest.
     6500; @param    A0_32   The guest's MXCSR register value to use (input).
    65456501; @param    A1      Pointer to the first MMX register sized operand (output).
    65466502; @param    A2      Pointer to the media register sized operand (input).
    … …  
    65506506        PROLOGUE_3_ARGS
    65516507        IEMIMPL_SSE_PROLOGUE
    6552         SSE_LD_FXSTATE_MXCSR_ONLY A0
     6508        SSE_AVX_LD_MXCSR A0_32
    65536509
    65546510        movdqu  xmm0, [A2]
    … …  
    65566512        movq    [A1], mm0
    65576513
    6558         SSE_ST_FXSTATE_MXCSR_ONLY_NO_FXSTATE A0
     6514        SSE_AVX_ST_MXCSR R0_32, A0_32
    65596515        IEMIMPL_SSE_EPILOGUE
    65606516        EPILOGUE_3_ARGS
    … …  
    65726528; @param    1       The instruction name.
    65736529;
    6574 ; @param    A0      Pointer to the MXCSR value (input/output).
     6530; @return   R0_32   The new MXCSR value of the guest.
     6531; @param    A0_32   The guest's MXCSR register value to use (input).
    65756532; @param    A1      Pointer to the first media register sized operand (input/output).
    65766533; @param    A2      The 64bit source value from a MMX media register (input)
    … …  
    65806537        PROLOGUE_3_ARGS
    65816538        IEMIMPL_SSE_PROLOGUE
    6582         SSE_LD_FXSTATE_MXCSR_ONLY A0
     6539        SSE_AVX_LD_MXCSR A0_32
    65836540
    65846541        movdqu  xmm0, [A1]
    … …  
    65876544        movdqu  [A1], xmm0
    65886545
    6589         SSE_ST_FXSTATE_MXCSR_ONLY_NO_FXSTATE A0
     6546        SSE_AVX_ST_MXCSR R0_32, A0_32
    65906547        IEMIMPL_SSE_EPILOGUE
    65916548        EPILOGUE_3_ARGS
    … …  
    66036560; @param    1       The instruction name.
    66046561;
    6605 ; @param    A0      Pointer to the MXCSR value (input/output).
     6562; @return   R0_32   The new MXCSR value of the guest.
     6563; @param    A0_32   The guest's MXCSR register value to use (input).
    66066564; @param    A1      Pointer to the first MMX media register sized operand (output).
    66076565; @param    A2      The 64bit source value (input).
    … …  
    66116569        PROLOGUE_3_ARGS
    66126570        IEMIMPL_SSE_PROLOGUE
    6613         SSE_LD_FXSTATE_MXCSR_ONLY A0
     6571        SSE_AVX_LD_MXCSR A0_32
    66146572
    66156573        movq    xmm0, A2
    … …  
    66176575        movq    [A1], mm0
    66186576
    6619         SSE_ST_FXSTATE_MXCSR_ONLY_NO_FXSTATE A0
     6577        SSE_AVX_ST_MXCSR R0_32, A0_32
    66206578        IEMIMPL_SSE_EPILOGUE
    66216579        EPILOGUE_3_ARGS

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

    r104173 r104174  
    1866518665
    1866618666
    18667 IEM_DECL_IMPL_DEF(void, iemAImpl_cvtpd2pi_u128,(uint32_t *pfMxcsr, uint64_t *pu64Dst, PCX86XMMREG pSrc))
     18667IEM_DECL_IMPL_DEF(uint32_t, iemAImpl_cvtpd2pi_u128,(uint32_t fMxCsrIn, uint64_t *pu64Dst, PCX86XMMREG pSrc))
    1866818668{
    1866918669    RTUINT64U u64Res;
    18670     uint32_t fMxcsrOut  = iemAImpl_cvtpd2pi_u128_worker(*pfMxcsr, &u64Res.ai32[0], &pSrc->ar64[0]);
    18671              fMxcsrOut |= iemAImpl_cvtpd2pi_u128_worker(*pfMxcsr, &u64Res.ai32[1], &pSrc->ar64[1]);
     18670    uint32_t fMxcsrOut  = iemAImpl_cvtpd2pi_u128_worker(fMxCsrIn, &u64Res.ai32[0], &pSrc->ar64[0]);
     18671             fMxcsrOut |= iemAImpl_cvtpd2pi_u128_worker(fMxCsrIn, &u64Res.ai32[1], &pSrc->ar64[1]);
    1867218672
    1867318673    *pu64Dst = u64Res.u;
    18674     *pfMxcsr = fMxcsrOut;
     18674    return fMxcsrOut;
    1867518675}
    1867618676#endif
    … …  
    1869218692
    1869318693
    18694 IEM_DECL_IMPL_DEF(void, iemAImpl_cvttpd2pi_u128,(uint32_t *pfMxcsr, uint64_t *pu64Dst, PCX86XMMREG pSrc))
     18694IEM_DECL_IMPL_DEF(uint32_t, iemAImpl_cvttpd2pi_u128,(uint32_t fMxCsrIn, uint64_t *pu64Dst, PCX86XMMREG pSrc))
    1869518695{
    1869618696    RTUINT64U u64Res;
    18697     uint32_t fMxcsrOut  = iemAImpl_cvttpd2pi_u128_worker(*pfMxcsr, &u64Res.ai32[0], &pSrc->ar64[0]);
    18698              fMxcsrOut |= iemAImpl_cvttpd2pi_u128_worker(*pfMxcsr, &u64Res.ai32[1], &pSrc->ar64[1]);
     18697    uint32_t fMxcsrOut  = iemAImpl_cvttpd2pi_u128_worker(fMxCsrIn, &u64Res.ai32[0], &pSrc->ar64[0]);
     18698             fMxcsrOut |= iemAImpl_cvttpd2pi_u128_worker(fMxCsrIn, &u64Res.ai32[1], &pSrc->ar64[1]);
    1869918699
    1870018700    *pu64Dst = u64Res.u;
    18701     *pfMxcsr = fMxcsrOut;
     18701    return fMxcsrOut;
    1870218702}
    1870318703#endif
    … …  
    1871618716
    1871718717
    18718 IEM_DECL_IMPL_DEF(void, iemAImpl_cvtpi2ps_u128,(uint32_t *pfMxcsr, PX86XMMREG pDst, uint64_t u64Src))
     18718IEM_DECL_IMPL_DEF(uint32_t, iemAImpl_cvtpi2ps_u128,(uint32_t fMxCsrIn, PX86XMMREG pDst, uint64_t u64Src))
    1871918719{
    1872018720    RTUINT64U uSrc = { u64Src };
    18721     uint32_t fMxcsrOut  = iemAImpl_cvtpi2ps_u128_worker(*pfMxcsr, &pDst->ar32[0], uSrc.ai32[0]);
    18722              fMxcsrOut |= iemAImpl_cvtpi2ps_u128_worker(*pfMxcsr, &pDst->ar32[1], uSrc.ai32[1]);
    18723     *pfMxcsr = fMxcsrOut;
     18721    uint32_t fMxcsrOut  = iemAImpl_cvtpi2ps_u128_worker(fMxCsrIn, &pDst->ar32[0], uSrc.ai32[0]);
     18722             fMxcsrOut |= iemAImpl_cvtpi2ps_u128_worker(fMxCsrIn, &pDst->ar32[1], uSrc.ai32[1]);
     18723    return fMxcsrOut;
    1872418724}
    1872518725#endif
    … …  
    1873818738
    1873918739
    18740 IEM_DECL_IMPL_DEF(void, iemAImpl_cvtpi2pd_u128,(uint32_t *pfMxcsr, PX86XMMREG pDst, uint64_t u64Src))
     18740IEM_DECL_IMPL_DEF(uint32_t, iemAImpl_cvtpi2pd_u128,(uint32_t fMxCsrIn, PX86XMMREG pDst, uint64_t u64Src))
    1874118741{
    1874218742    RTUINT64U uSrc = { u64Src };
    18743     uint32_t fMxcsrOut  = iemAImpl_cvtpi2pd_u128_worker(*pfMxcsr, &pDst->ar64[0], uSrc.ai32[0]);
    18744              fMxcsrOut |= iemAImpl_cvtpi2pd_u128_worker(*pfMxcsr, &pDst->ar64[1], uSrc.ai32[1]);
    18745     *pfMxcsr = fMxcsrOut;
     18743    uint32_t fMxcsrOut  = iemAImpl_cvtpi2pd_u128_worker(fMxCsrIn, &pDst->ar64[0], uSrc.ai32[0]);
     18744             fMxcsrOut |= iemAImpl_cvtpi2pd_u128_worker(fMxCsrIn, &pDst->ar64[1], uSrc.ai32[1]);
     18745    return fMxcsrOut;
    1874618746}
    1874718747#endif
    … …  
    1876318763
    1876418764
    18765 IEM_DECL_IMPL_DEF(void, iemAImpl_cvtps2pi_u128,(uint32_t *pfMxcsr, uint64_t *pu64Dst, uint64_t u64Src))
     18765IEM_DECL_IMPL_DEF(uint32_t, iemAImpl_cvtps2pi_u128,(uint32_t fMxCsrIn, uint64_t *pu64Dst, uint64_t u64Src))
    1876618766{
    1876718767    RTUINT64U uDst;
    1876818768    RTUINT64U uSrc = { u64Src };
    18769     uint32_t fMxcsrOut  = iemAImpl_cvtps2pi_u128_worker(*pfMxcsr, &uDst.ai32[0], (PCRTFLOAT32U)&uSrc.au32[0]);
    18770              fMxcsrOut |= iemAImpl_cvtps2pi_u128_worker(*pfMxcsr, &uDst.ai32[1], (PCRTFLOAT32U)&uSrc.au32[1]);
     18769    uint32_t fMxcsrOut  = iemAImpl_cvtps2pi_u128_worker(fMxCsrIn, &uDst.ai32[0], (PCRTFLOAT32U)&uSrc.au32[0]);
     18770             fMxcsrOut |= iemAImpl_cvtps2pi_u128_worker(fMxCsrIn, &uDst.ai32[1], (PCRTFLOAT32U)&uSrc.au32[1]);
    1877118771    *pu64Dst = uDst.u;
    18772     *pfMxcsr = fMxcsrOut;
     18772    return fMxcsrOut;
    1877318773}
    1877418774#endif
    … …  
    1879018790
    1879118791
    18792 IEM_DECL_IMPL_DEF(void, iemAImpl_cvttps2pi_u128,(uint32_t *pfMxcsr, uint64_t *pu64Dst, uint64_t u64Src))
     18792IEM_DECL_IMPL_DEF(uint32_t, iemAImpl_cvttps2pi_u128,(uint32_t fMxCsrIn, uint64_t *pu64Dst, uint64_t u64Src))
    1879318793{
    1879418794    RTUINT64U uDst;
    1879518795    RTUINT64U uSrc = { u64Src };
    18796     uint32_t fMxcsrOut  = iemAImpl_cvttps2pi_u128_worker(*pfMxcsr, &uDst.ai32[0], (PCRTFLOAT32U)&uSrc.au32[0]);
    18797              fMxcsrOut |= iemAImpl_cvttps2pi_u128_worker(*pfMxcsr, &uDst.ai32[1], (PCRTFLOAT32U)&uSrc.au32[1]);
     18796    uint32_t fMxcsrOut  = iemAImpl_cvttps2pi_u128_worker(fMxCsrIn, &uDst.ai32[0], (PCRTFLOAT32U)&uSrc.au32[0]);
     18797             fMxcsrOut |= iemAImpl_cvttps2pi_u128_worker(fMxCsrIn, &uDst.ai32[1], (PCRTFLOAT32U)&uSrc.au32[1]);
    1879818798    *pu64Dst = uDst.u;
    18799     *pfMxcsr = fMxcsrOut;
     18799    return fMxcsrOut;
    1880018800}
    1880118801#endif

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

    r104155 r104174  
    32793279    'IEM_MC_REF_MREG_U64':                                       (McBlock.parseMcGeneric,           False, False, False, ),
    32803280    'IEM_MC_REF_MREG_U64_CONST':                                 (McBlock.parseMcGeneric,           False, False, False, ),
    3281     'IEM_MC_REF_MXCSR':                                          (McBlock.parseMcGeneric,           False, False, True,  ),
    32823281    'IEM_MC_REF_XREG_R32_CONST':                                 (McBlock.parseMcGeneric,           False, False, g_fNativeSimd),
    32833282    'IEM_MC_REF_XREG_R64_CONST':                                 (McBlock.parseMcGeneric,           False, False, g_fNativeSimd),

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

    r104156 r104174  
    34753475        IEM_MC_BEGIN(0, 0);
    34763476        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    3477         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    34783477        IEM_MC_LOCAL(X86XMMREG,             Dst);
    3479         IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          1);
    3480         IEM_MC_ARG(uint64_t,                u64Src,             2);
     3478        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          0);
     3479        IEM_MC_ARG(uint64_t,                u64Src,             1);
    34813480        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    34823481        IEM_MC_MAYBE_RAISE_FPU_XCPT();
    … …  
    34843483        IEM_MC_FPU_TO_MMX_MODE();
    34853484
    3486         IEM_MC_REF_MXCSR(pfMxcsr);
    34873485        IEM_MC_FETCH_XREG_XMM(Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); /* Need it because the high quadword remains unchanged. */
    34883486        IEM_MC_FETCH_MREG_U64(u64Src, IEM_GET_MODRM_RM_8(bRm));
    34893487
    3490         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2ps_u128, pfMxcsr, pDst, u64Src);
     3488        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtpi2ps_u128, pDst, u64Src);
    34913489        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    34923490            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    35043502         */
    35053503        IEM_MC_BEGIN(0, 0);
    3506         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    35073504        IEM_MC_LOCAL(X86XMMREG,             Dst);
    3508         IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          1);
    3509         IEM_MC_ARG(uint64_t,                u64Src,             2);
     3505        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          0);
     3506        IEM_MC_ARG(uint64_t,                u64Src,             1);
    35103507        IEM_MC_LOCAL(RTGCPTR,               GCPtrEffSrc);
    35113508
    … …  
    35183515        IEM_MC_PREPARE_FPU_USAGE();
    35193516        IEM_MC_FPU_TO_MMX_MODE();
    3520         IEM_MC_REF_MXCSR(pfMxcsr);
    3521 
    3522         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2ps_u128, pfMxcsr, pDst, u64Src);
     3517
     3518        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtpi2ps_u128, pDst, u64Src);
    35233519        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    35243520            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    35453541        IEM_MC_BEGIN(0, 0);
    35463542        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    3547         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    35483543        IEM_MC_LOCAL(X86XMMREG,             Dst);
    3549         IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          1);
    3550         IEM_MC_ARG(uint64_t,                u64Src,             2);
     3544        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          0);
     3545        IEM_MC_ARG(uint64_t,                u64Src,             1);
    35513546        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    35523547        IEM_MC_MAYBE_RAISE_FPU_XCPT();
    … …  
    35543549        IEM_MC_FPU_TO_MMX_MODE();
    35553550
    3556         IEM_MC_REF_MXCSR(pfMxcsr);
    35573551        IEM_MC_FETCH_MREG_U64(u64Src, IEM_GET_MODRM_RM_8(bRm));
    35583552
    3559         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2pd_u128, pfMxcsr, pDst, u64Src);
     3553        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtpi2pd_u128, pDst, u64Src);
    35603554        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    35613555            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    35733567         */
    35743568        IEM_MC_BEGIN(0, 0);
    3575         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    35763569        IEM_MC_LOCAL(X86XMMREG,             Dst);
    3577         IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          1);
    3578         IEM_MC_ARG(uint64_t,                u64Src,             2);
     3570        IEM_MC_ARG_LOCAL_REF(PX86XMMREG,    pDst, Dst,          0);
     3571        IEM_MC_ARG(uint64_t,                u64Src,             1);
    35793572        IEM_MC_LOCAL(RTGCPTR,               GCPtrEffSrc);
    35803573
    … …  
    35873580        /* Doesn't cause a transition to MMX mode. */
    35883581        IEM_MC_PREPARE_SSE_USAGE();
    3589         IEM_MC_REF_MXCSR(pfMxcsr);
    3590 
    3591         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2pd_u128, pfMxcsr, pDst, u64Src);
     3582
     3583        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtpi2pd_u128, pDst, u64Src);
    35923584        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    35933585            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    39213913        IEM_MC_BEGIN(0, 0);
    39223914        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    3923         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    39243915        IEM_MC_LOCAL(uint64_t,              u64Dst);
    3925         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    1);
    3926         IEM_MC_ARG(uint64_t,                u64Src,             2);
     3916        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    0);
     3917        IEM_MC_ARG(uint64_t,                u64Src,             1);
    39273918        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    39283919        IEM_MC_PREPARE_FPU_USAGE();
    39293920        IEM_MC_FPU_TO_MMX_MODE();
    39303921
    3931         IEM_MC_REF_MXCSR(pfMxcsr);
    39323922        IEM_MC_FETCH_XREG_U64(u64Src, IEM_GET_MODRM_RM(pVCpu, bRm), 0 /* a_iQword*/);
    39333923
    3934         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttps2pi_u128, pfMxcsr, pu64Dst, u64Src);
     3924        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvttps2pi_u128, pu64Dst, u64Src);
    39353925        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    39363926            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    39483938         */
    39493939        IEM_MC_BEGIN(0, 0);
    3950         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    39513940        IEM_MC_LOCAL(uint64_t,              u64Dst);
    3952         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    1);
    3953         IEM_MC_ARG(uint64_t,                u64Src,             2);
     3941        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    0);
     3942        IEM_MC_ARG(uint64_t,                u64Src,             1);
    39543943        IEM_MC_LOCAL(RTGCPTR,               GCPtrEffSrc);
    39553944
    … …  
    39613950        IEM_MC_PREPARE_FPU_USAGE();
    39623951        IEM_MC_FPU_TO_MMX_MODE();
    3963         IEM_MC_REF_MXCSR(pfMxcsr);
    3964 
    3965         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttps2pi_u128, pfMxcsr, pu64Dst, u64Src);
     3952
     3953        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvttps2pi_u128, pu64Dst, u64Src);
    39663954        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    39673955            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    39883976        IEM_MC_BEGIN(0, 0);
    39893977        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    3990         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    39913978        IEM_MC_LOCAL(uint64_t,              u64Dst);
    3992         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    1);
    3993         IEM_MC_ARG(PCX86XMMREG,             pSrc,               2);
     3979        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    0);
     3980        IEM_MC_ARG(PCX86XMMREG,             pSrc,               1);
    39943981        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    39953982        IEM_MC_PREPARE_FPU_USAGE();
    39963983        IEM_MC_FPU_TO_MMX_MODE();
    39973984
    3998         IEM_MC_REF_MXCSR(pfMxcsr);
    39993985        IEM_MC_REF_XREG_XMM_CONST(pSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    40003986
    4001         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
     3987        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvttpd2pi_u128, pu64Dst, pSrc);
    40023988        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    40033989            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    40154001         */
    40164002        IEM_MC_BEGIN(0, 0);
    4017         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    40184003        IEM_MC_LOCAL(uint64_t,              u64Dst);
    4019         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst,    u64Dst, 1);
     4004        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst,    u64Dst, 0);
    40204005        IEM_MC_LOCAL(X86XMMREG,             uSrc);
    4021         IEM_MC_ARG_LOCAL_REF(PCX86XMMREG,   pSrc,       uSrc,   2);
     4006        IEM_MC_ARG_LOCAL_REF(PCX86XMMREG,   pSrc,       uSrc,   1);
    40224007        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    40234008
    … …  
    40304015        IEM_MC_FPU_TO_MMX_MODE();
    40314016
    4032         IEM_MC_REF_MXCSR(pfMxcsr);
    4033 
    4034         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
     4017        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvttpd2pi_u128, pu64Dst, pSrc);
    40354018        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    40364019            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    42834266        IEM_MC_BEGIN(0, 0);
    42844267        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    4285         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    42864268        IEM_MC_LOCAL(uint64_t,              u64Dst);
    4287         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    1);
    4288         IEM_MC_ARG(uint64_t,                u64Src,             2);
     4269        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    0);
     4270        IEM_MC_ARG(uint64_t,                u64Src,             1);
    42894271
    42904272        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    … …  
    42924274        IEM_MC_FPU_TO_MMX_MODE();
    42934275
    4294         IEM_MC_REF_MXCSR(pfMxcsr);
    42954276        IEM_MC_FETCH_XREG_U64(u64Src, IEM_GET_MODRM_RM(pVCpu, bRm), 0 /* a_iQword*/);
    42964277
    4297         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtps2pi_u128, pfMxcsr, pu64Dst, u64Src);
     4278        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtps2pi_u128, pu64Dst, u64Src);
    42984279        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    42994280            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    43114292         */
    43124293        IEM_MC_BEGIN(0, 0);
    4313         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    43144294        IEM_MC_LOCAL(uint64_t,              u64Dst);
    4315         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    1);
    4316         IEM_MC_ARG(uint64_t,                u64Src,             2);
     4295        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    0);
     4296        IEM_MC_ARG(uint64_t,                u64Src,             1);
    43174297        IEM_MC_LOCAL(RTGCPTR,               GCPtrEffSrc);
    43184298
    … …  
    43244304        IEM_MC_PREPARE_FPU_USAGE();
    43254305        IEM_MC_FPU_TO_MMX_MODE();
    4326         IEM_MC_REF_MXCSR(pfMxcsr);
    4327 
    4328         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtps2pi_u128, pfMxcsr, pu64Dst, u64Src);
     4306
     4307        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtps2pi_u128, pu64Dst, u64Src);
    43294308        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    43304309            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    43514330        IEM_MC_BEGIN(0, 0);
    43524331        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    4353         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    43544332        IEM_MC_LOCAL(uint64_t,              u64Dst);
    4355         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    1);
    4356         IEM_MC_ARG(PCX86XMMREG,             pSrc,               2);
     4333        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst, u64Dst,    0);
     4334        IEM_MC_ARG(PCX86XMMREG,             pSrc,               1);
    43574335
    43584336        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    … …  
    43604338        IEM_MC_FPU_TO_MMX_MODE();
    43614339
    4362         IEM_MC_REF_MXCSR(pfMxcsr);
    43634340        IEM_MC_REF_XREG_XMM_CONST(pSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    43644341
    4365         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
     4342        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtpd2pi_u128, pu64Dst, pSrc);
    43664343        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    43674344            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    … …  
    43794356         */
    43804357        IEM_MC_BEGIN(0, 0);
    4381         IEM_MC_ARG(uint32_t *,              pfMxcsr,            0);
    43824358        IEM_MC_LOCAL(uint64_t,              u64Dst);
    4383         IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst,    u64Dst, 1);
     4359        IEM_MC_ARG_LOCAL_REF(uint64_t *,    pu64Dst,    u64Dst, 0);
    43844360        IEM_MC_LOCAL(X86XMMREG,             uSrc);
    4385         IEM_MC_ARG_LOCAL_REF(PCX86XMMREG,   pSrc,       uSrc,   2);
     4361        IEM_MC_ARG_LOCAL_REF(PCX86XMMREG,   pSrc,       uSrc,   1);
    43864362        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    43874363
    … …  
    43944370        IEM_MC_FPU_TO_MMX_MODE();
    43954371
    4396         IEM_MC_REF_MXCSR(pfMxcsr);
    4397 
    4398         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
     4372        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_cvtpd2pi_u128, pu64Dst, pSrc);
    43994373        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    44004374            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();

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

    r104155 r104174  
    585585    } while (0)
    586586#define IEM_MC_ASSERT_EFLAGS(a_fEflInput, a_fEflOutput)             NOP()
    587 #define IEM_MC_REF_MXCSR(a_pfMxcsr)                                 IEM_LIVENESS_MXCSR_MODIFY()
    588587
    589588

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

    r104156 r104174  
    39273927FNIEMAIMPLMXCSRF2XMMIMM8 iemAImpl_dppd_u128, iemAImpl_dppd_u128_fallback;
    39283928
    3929 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMXCSRU64U128,(uint32_t *pfMxcsr, uint64_t *pu64Dst, PCX86XMMREG pSrc));
     3929typedef IEM_DECL_IMPL_TYPE(uint32_t, FNIEMAIMPLMXCSRU64U128,(uint32_t fMxCsrIn, uint64_t *pu64Dst, PCX86XMMREG pSrc));
    39303930typedef FNIEMAIMPLMXCSRU64U128 *PFNIEMAIMPLMXCSRU64U128;
    39313931
    … …  
    39333933FNIEMAIMPLMXCSRU64U128 iemAImpl_cvttpd2pi_u128;
    39343934
    3935 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMXCSRU128U64,(uint32_t *pfMxcsr, PX86XMMREG pDst, uint64_t u64Src));
     3935typedef IEM_DECL_IMPL_TYPE(uint32_t, FNIEMAIMPLMXCSRU128U64,(uint32_t fMxCsrIn, PX86XMMREG pDst, uint64_t u64Src));
    39363936typedef FNIEMAIMPLMXCSRU128U64 *PFNIEMAIMPLMXCSRU128U64;
    39373937
    … …  
    39393939FNIEMAIMPLMXCSRU128U64 iemAImpl_cvtpi2pd_u128;
    39403940
    3941 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMXCSRU64U64,(uint32_t *pfMxcsr, uint64_t *pu64Dst, uint64_t u64Src));
     3941typedef IEM_DECL_IMPL_TYPE(uint32_t, FNIEMAIMPLMXCSRU64U64,(uint32_t fMxCsrIn, uint64_t *pu64Dst, uint64_t u64Src));
    39423942typedef FNIEMAIMPLMXCSRU64U64 *PFNIEMAIMPLMXCSRU64U64;
    39433943

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

    r104168 r104174  
    329329#define IEM_MC_REF_EFLAGS(a_pEFlags)                    (a_pEFlags) = &pVCpu->cpum.GstCtx.eflags.uBoth
    330330#define IEM_MC_REF_EFLAGS_EX(a_pEFlags, a_fEflInput, a_fEflOutput) IEM_MC_REF_EFLAGS(a_pEFlags)
    331 #define IEM_MC_REF_MXCSR(a_pfMxcsr)                     (a_pfMxcsr) = &pVCpu->cpum.GstCtx.XState.x87.MXCSR
    332331
    333332#define IEM_MC_ADD_GREG_U16(a_iGReg, a_u16Value)        *iemGRegRefU16(pVCpu, (a_iGReg)) += (a_u16Value)

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

    r104173 r104174  
    89068906                                          | (iFz  ? X86_MXCSR_FZ  : 0)
    89078907                                          | X86_MXCSR_XCPT_MASK;
    8908                         uint32_t fMxcsrM  = fMxcsrIn;
    89098908                        uint64_t u64ResM;
    8910                         pfn(&fMxcsrM, &u64ResM, &TestData.InVal);
     8909                        uint32_t fMxcsrM    = pfn(fMxcsrIn, &u64ResM, &TestData.InVal);
    89118910                        TestData.fMxcsrIn   = fMxcsrIn;
    89128911                        TestData.fMxcsrOut  = fMxcsrM;
    … …  
    89158914
    89168915                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
    8917                         uint32_t fMxcsrU  = fMxcsrIn;
    89188916                        uint64_t u64ResU;
    8919                         pfn(&fMxcsrU, &u64ResU, &TestData.InVal);
     8917                        uint32_t fMxcsrU    = pfn(fMxcsrIn, &u64ResU, &TestData.InVal);
    89208918                        TestData.fMxcsrIn   = fMxcsrIn;
    89218919                        TestData.fMxcsrOut  = fMxcsrU;
    … …  
    89278925                        {
    89288926                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    8929                             uint32_t fMxcsr1  = fMxcsrIn;
    89308927                            uint64_t u64Res1;
    8931                             pfn(&fMxcsr1, &u64Res1, &TestData.InVal);
     8928                            uint32_t fMxcsr1    = pfn(fMxcsrIn, &u64Res1, &TestData.InVal);
    89328929                            TestData.fMxcsrIn   = fMxcsrIn;
    89338930                            TestData.fMxcsrOut  = fMxcsr1;
    … …  
    89398936                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    89408937                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    8941                                 uint32_t fMxcsr2  = fMxcsrIn;
    89428938                                uint64_t u64Res2;
    8943                                 pfn(&fMxcsr2, &u64Res2, &TestData.InVal);
     8939                                uint32_t fMxcsr2    = pfn(fMxcsrIn, &u64Res2, &TestData.InVal);
    89448940                                TestData.fMxcsrIn   = fMxcsrIn;
    89458941                                TestData.fMxcsrOut  = fMxcsr2;
    … …  
    89528948                                    {
    89538949                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    8954                                         uint32_t fMxcsr3  = fMxcsrIn;
    89558950                                        uint64_t u64Res3;
    8956                                         pfn(&fMxcsr3, &u64Res3, &TestData.InVal);
     8951                                        uint32_t fMxcsr3    = pfn(fMxcsrIn, &u64Res3, &TestData.InVal);
    89578952                                        TestData.fMxcsrIn   = fMxcsrIn;
    89588953                                        TestData.fMxcsrOut  = fMxcsr3;
    … …  
    89878982            {
    89888983                RTUINT64U ValOut;
    8989                 uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
    8990                 pfn(&fMxcsr, &ValOut.u, &paTests[iTest].InVal);
     8984                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &ValOut.u, &paTests[iTest].InVal);
    89918985                if (   fMxcsr != paTests[iTest].fMxcsrOut
    89928986                    || ValOut.ai32[0] != paTests[iTest].OutVal.ai32[0]
    … …  
    90609054                                          | (iFz  ? X86_MXCSR_FZ  : 0)
    90619055                                          | X86_MXCSR_XCPT_MASK;
    9062                         uint32_t fMxcsrM  = fMxcsrIn;
    9063                         pfn(&fMxcsrM, &TestData.OutVal, TestData.InVal.u);
     9056                        uint32_t fMxcsrM    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    90649057                        TestData.fMxcsrIn   = fMxcsrIn;
    90659058                        TestData.fMxcsrOut  = fMxcsrM;
    … …  
    90679060
    90689061                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
    9069                         uint32_t fMxcsrU  = fMxcsrIn;
    9070                         pfn(&fMxcsrU, &TestData.OutVal, TestData.InVal.u);
     9062                        uint32_t fMxcsrU    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    90719063                        TestData.fMxcsrIn   = fMxcsrIn;
    90729064                        TestData.fMxcsrOut  = fMxcsrU;
    … …  
    90779069                        {
    90789070                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    9079                             uint32_t fMxcsr1  = fMxcsrIn;
    9080                             pfn(&fMxcsr1, &TestData.OutVal, TestData.InVal.u);
     9071                            uint32_t fMxcsr1    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    90819072                            TestData.fMxcsrIn   = fMxcsrIn;
    90829073                            TestData.fMxcsrOut  = fMxcsr1;
    … …  
    90879078                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    90889079                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    9089                                 uint32_t fMxcsr2  = fMxcsrIn;
    9090                                 pfn(&fMxcsr2, &TestData.OutVal, TestData.InVal.u);
     9080                                uint32_t fMxcsr2    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    90919081                                TestData.fMxcsrIn   = fMxcsrIn;
    90929082                                TestData.fMxcsrOut  = fMxcsr2;
    … …  
    90989088                                    {
    90999089                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    9100                                         uint32_t fMxcsr3  = fMxcsrIn;
    9101                                         pfn(&fMxcsr3, &TestData.OutVal, TestData.InVal.u);
     9090                                        uint32_t fMxcsr3    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    91029091                                        TestData.fMxcsrIn   = fMxcsrIn;
    91039092                                        TestData.fMxcsrOut  = fMxcsr3;
    … …  
    91319120            {
    91329121                X86XMMREG ValOut;
    9133                 uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
    9134                 pfn(&fMxcsr, &ValOut, paTests[iTest].InVal.u);
     9122                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &ValOut, paTests[iTest].InVal.u);
    91359123                if (   fMxcsr != paTests[iTest].fMxcsrOut
    91369124                    || !RTFLOAT64U_ARE_IDENTICAL(&ValOut.ar64[0], &paTests[iTest].OutVal.ar64[0])
    … …  
    92059193                                          | (iFz  ? X86_MXCSR_FZ  : 0)
    92069194                                          | X86_MXCSR_XCPT_MASK;
    9207                         uint32_t fMxcsrM  = fMxcsrIn;
    9208                         pfn(&fMxcsrM, &TestData.OutVal, TestData.InVal.u);
     9195                        uint32_t fMxcsrM    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    92099196                        TestData.fMxcsrIn   = fMxcsrIn;
    92109197                        TestData.fMxcsrOut  = fMxcsrM;
    … …  
    92129199
    92139200                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
    9214                         uint32_t fMxcsrU  = fMxcsrIn;
    9215                         pfn(&fMxcsrU, &TestData.OutVal, TestData.InVal.u);
     9201                        uint32_t fMxcsrU    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    92169202                        TestData.fMxcsrIn   = fMxcsrIn;
    92179203                        TestData.fMxcsrOut  = fMxcsrU;
    … …  
    92229208                        {
    92239209                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    9224                             uint32_t fMxcsr1  = fMxcsrIn;
    9225                             pfn(&fMxcsr1, &TestData.OutVal, TestData.InVal.u);
     9210                            uint32_t fMxcsr1    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    92269211                            TestData.fMxcsrIn   = fMxcsrIn;
    92279212                            TestData.fMxcsrOut  = fMxcsr1;
    … …  
    92329217                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    92339218                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    9234                                 uint32_t fMxcsr2  = fMxcsrIn;
    9235                                 pfn(&fMxcsr2, &TestData.OutVal, TestData.InVal.u);
     9219                                uint32_t fMxcsr2    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    92369220                                TestData.fMxcsrIn   = fMxcsrIn;
    92379221                                TestData.fMxcsrOut  = fMxcsr2;
    … …  
    92439227                                    {
    92449228                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    9245                                         uint32_t fMxcsr3  = fMxcsrIn;
    9246                                         pfn(&fMxcsr3, &TestData.OutVal, TestData.InVal.u);
     9229                                        uint32_t fMxcsr3    = pfn(fMxcsrIn, &TestData.OutVal, TestData.InVal.u);
    92479230                                        TestData.fMxcsrIn   = fMxcsrIn;
    92489231                                        TestData.fMxcsrOut  = fMxcsr3;
    … …  
    92769259            {
    92779260                X86XMMREG ValOut;
    9278                 uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
    9279                 pfn(&fMxcsr, &ValOut, paTests[iTest].InVal.u);
     9261                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &ValOut, paTests[iTest].InVal.u);
    92809262                if (   fMxcsr != paTests[iTest].fMxcsrOut
    92819263                    || !RTFLOAT32U_ARE_IDENTICAL(&ValOut.ar32[0], &paTests[iTest].OutVal.ar32[0])
    … …  
    93689350                                          | (iFz  ? X86_MXCSR_FZ  : 0)
    93699351                                          | X86_MXCSR_XCPT_MASK;
    9370                         uint32_t fMxcsrM  = fMxcsrIn;
    93719352                        uint64_t u64ResM;
    9372                         pfn(&fMxcsrM, &u64ResM, TestVal.u);
     9353                        uint32_t fMxcsrM   = pfn(fMxcsrIn, &u64ResM, TestVal.u);
    93739354                        TestData.fMxcsrIn  = fMxcsrIn;
    93749355                        TestData.fMxcsrOut = fMxcsrM;
    … …  
    93779358
    93789359                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
    9379                         uint32_t fMxcsrU  = fMxcsrIn;
    93809360                        uint64_t u64ResU;
    9381                         pfn(&fMxcsrU, &u64ResU, TestVal.u);
     9361                        uint32_t fMxcsrU   = pfn(fMxcsrIn, &u64ResU, TestVal.u);
    93829362                        TestData.fMxcsrIn  = fMxcsrIn;
    93839363                        TestData.fMxcsrOut = fMxcsrU;
    … …  
    93899369                        {
    93909370                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    9391                             uint32_t fMxcsr1  = fMxcsrIn;
    93929371                            uint64_t u64Res1;
    9393                             pfn(&fMxcsr1, &u64Res1, TestVal.u);
     9372                            uint32_t fMxcsr1   = pfn(fMxcsrIn, &u64Res1, TestVal.u);
    93949373                            TestData.fMxcsrIn  = fMxcsrIn;
    93959374                            TestData.fMxcsrOut = fMxcsr1;
    … …  
    94019380                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    94029381                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    9403                                 uint32_t fMxcsr2  = fMxcsrIn;
    94049382                                uint64_t u64Res2;
    9405                                 pfn(&fMxcsr2, &u64Res2, TestVal.u);
     9383                                uint32_t fMxcsr2   = pfn(fMxcsrIn, &u64Res2, TestVal.u);
    94069384                                TestData.fMxcsrIn  = fMxcsrIn;
    94079385                                TestData.fMxcsrOut = fMxcsr2;
    … …  
    94149392                                    {
    94159393                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    9416                                         uint32_t fMxcsr3  = fMxcsrIn;
    94179394                                        uint64_t u64Res3;
    9418                                         pfn(&fMxcsr3, &u64Res3, TestVal.u);
     9395                                        uint32_t fMxcsr3   = pfn(fMxcsrIn, &u64Res3, TestVal.u);
    94199396                                        TestData.fMxcsrIn  = fMxcsrIn;
    94209397                                        TestData.fMxcsrOut = fMxcsr3;
    … …  
    94579434                ValIn.au32[1] = paTests[iTest].ar32InVal[1].u;
    94589435
    9459                 uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
    9460                 pfn(&fMxcsr, &ValOut.u, ValIn.u);
     9436                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &ValOut.u, ValIn.u);
    94619437                if (   fMxcsr != paTests[iTest].fMxcsrOut
    94629438                    || ValOut.ai32[0] != paTests[iTest].OutVal.ai32[0]

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

    r104150 r104174  
    729729#define IEM_MC_REF_EFLAGS_EX(a_pEFlags, a_fEflInput, a_fEflOutput) IEM_MC_REF_EFLAGS(a_pEFlags)
    730730#define IEM_MC_REF_FPUREG(a_pr80Dst, a_iSt)             do { (a_pr80Dst) = (PRTFLOAT80U)((uintptr_t)0); CHK_PTYPE(PCRTFLOAT80U, a_pr80Dst); CHK_VAR(a_pr80Dst); AssertCompile((a_iSt) < 8); (void)fMcBegin; } while (0)
    731 #define IEM_MC_REF_MXCSR(a_pfMxcsr)                     do { (a_pfMxcsr) = (uint32_t *)((uintptr_t)0);  CHK_PTYPE(uint32_t *, a_pfMxcsr);   CHK_VAR(a_pfMxcsr); (void)fMcBegin; (void)fSseRead; } while (0)
    732731
    733732#define IEM_MC_ADD_GREG_U16(a_iGReg, a_u16Const)        do { CHK_GREG_IDX(a_iGReg); CHK_CONST(uint16_t, a_u16Const); (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